From 2dbaf1c7be0f10b958cca7a280eaf6c5ef6d33b4 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Thu, 15 May 2025 17:20:10 +0000
Subject: Create summary comment for lintcheck runs

---
 .github/workflows/lintcheck.yml         |  28 +++++----
 .github/workflows/lintcheck_summary.yml | 106 ++++++++++++++++++++++++++++++++
 lintcheck/src/config.rs                 |   3 +
 lintcheck/src/json.rs                   | 105 ++++++++++++++++++++-----------
 lintcheck/src/main.rs                   |   7 ++-
 5 files changed, 200 insertions(+), 49 deletions(-)
 create mode 100644 .github/workflows/lintcheck_summary.yml

diff --git a/.github/workflows/lintcheck.yml b/.github/workflows/lintcheck.yml
index 70c805903d3..003d0395739 100644
--- a/.github/workflows/lintcheck.yml
+++ b/.github/workflows/lintcheck.yml
@@ -128,21 +128,27 @@ jobs:
     - name: Download JSON
       uses: actions/download-artifact@v4
 
+    - name: Store PR number
+      run: echo ${{ github.event.pull_request.number }} > pr.txt
+
     - name: Diff results
-      # GH's summery has a maximum size of 1024k:
-      # https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-markdown-summary
-      # That's why we first log to file and then to the summary and logs
+      # GH's summery has a maximum size of 1MiB:
+      # https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/workflow-commands-for-github-actions#step-isolation-and-limits
+      # We upload the full diff as an artifact in case it's truncated
       run: |
-        ./target/debug/lintcheck diff {base,head}/ci_crates_logs.json --truncate >> truncated_diff.md
-        head -c 1024000 truncated_diff.md >> $GITHUB_STEP_SUMMARY
-        cat truncated_diff.md
-        ./target/debug/lintcheck diff {base,head}/ci_crates_logs.json >> full_diff.md
+        ./target/debug/lintcheck diff {base,head}/ci_crates_logs.json --truncate | head -c 1M > $GITHUB_STEP_SUMMARY
+        ./target/debug/lintcheck diff {base,head}/ci_crates_logs.json --write-summary summary.json > full_diff.md
 
     - name: Upload full diff
       uses: actions/upload-artifact@v4
       with:
-        name: diff
-        if-no-files-found: ignore
+        name: full_diff
+        path: full_diff.md
+
+    - name: Upload summary
+      uses: actions/upload-artifact@v4
+      with:
+        name: summary
         path: |
-          full_diff.md
-          truncated_diff.md
+          summary.json
+          pr.txt
diff --git a/.github/workflows/lintcheck_summary.yml b/.github/workflows/lintcheck_summary.yml
new file mode 100644
index 00000000000..52f52e155a0
--- /dev/null
+++ b/.github/workflows/lintcheck_summary.yml
@@ -0,0 +1,106 @@
+name: Lintcheck summary
+
+# The workflow_run event runs in the context of the Clippy repo giving it write
+# access, needed here to create a PR comment when the PR originates from a fork
+#
+# The summary artifact is a JSON file that we verify in this action to prevent
+# the creation of arbitrary comments
+#
+# This action must not checkout/run code from the originating workflow_run
+# or directly interpolate ${{}} untrusted fields into code
+#
+# https://docs.github.com/en/actions/writing-workflows/choosing-when-your-workflow-runs/events-that-trigger-workflows#workflow_run
+# https://docs.github.com/en/actions/security-for-github-actions/security-guides/security-hardening-for-github-actions#understanding-the-risk-of-script-injections
+
+on:
+  workflow_run:
+    workflows: [Lintcheck]
+    types: [completed]
+
+# Restrict the default permission scope https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#defining-access-for-the-github_token-scopes
+permissions:
+  pull-requests: write
+
+jobs:
+  download:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    steps:
+      - name: Download artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: summary
+          path: untrusted
+          run-id: ${{ github.event.workflow_run.id }}
+          github-token: ${{ github.token }}
+
+      - name: Format comment
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require("fs");
+            const assert = require("assert/strict");
+
+            function validateName(s) {
+              assert.match(s, /^[a-z0-9_:]+$/);
+              return s;
+            }
+
+            function validateInt(i) {
+              assert.ok(Number.isInteger(i));
+              return i;
+            }
+
+            function tryReadSummary() {
+              try {
+                return JSON.parse(fs.readFileSync("untrusted/summary.json"));
+              } catch {
+                return null;
+              }
+            }
+
+            const prNumber = parseInt(fs.readFileSync("untrusted/pr.txt"), 10);
+            core.exportVariable("PR", prNumber.toString());
+
+            const untrustedSummary = tryReadSummary();
+            if (!Array.isArray(untrustedSummary)) {
+              return;
+            }
+
+            let summary = `Lintcheck changes for ${context.payload.workflow_run.head_sha}
+            
+            | Lint | Added | Removed | Changed |
+            | ---- | ----: | ------: | ------: |
+            `;
+
+            for (const untrustedRow of untrustedSummary) {
+              const name = validateName(untrustedRow.name);
+
+              const added = validateInt(untrustedRow.added);
+              const removed = validateInt(untrustedRow.removed);
+              const changed = validateInt(untrustedRow.changed);
+
+              const id = name.replace("clippy::", "user-content-").replaceAll("_", "-");
+              const url = `https://github.com/${process.env.GITHUB_REPOSITORY}/actions/runs/${context.payload.workflow_run.id}#${id}`;
+
+              summary += `| [\`${name}\`](${url}) | ${added} | ${removed} | ${changed} |\n`;
+            }
+
+            summary += "\nThis comment will be updated if you push new changes";
+
+            fs.writeFileSync("summary.md", summary);
+
+      - name: Create/update comment
+        run: |
+          if [[ -f summary.md ]]; then
+             gh pr comment "$PR" --body-file summary.md --edit-last --create-if-none
+          else
+            # There were no changes detected by Lintcheck
+            # - If a comment exists from a previous run that did detect changes, edit it (--edit-last)
+            # - If no comment exists do not create one, the `gh` command exits with an error which
+            #   `|| true` ignores
+            gh pr comment "$PR" --body "No changes for ${{ github.event.workflow_run.head_sha }}" --edit-last || true
+          fi
+        env:
+          GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
diff --git a/lintcheck/src/config.rs b/lintcheck/src/config.rs
index 83c3d7aba02..3b2ebf0c28a 100644
--- a/lintcheck/src/config.rs
+++ b/lintcheck/src/config.rs
@@ -68,6 +68,9 @@ pub(crate) enum Commands {
         /// This will limit the number of warnings that will be printed for each lint
         #[clap(long)]
         truncate: bool,
+        /// Write the diff summary to a JSON file if there are any changes
+        #[clap(long, value_name = "PATH")]
+        write_summary: Option<PathBuf>,
     },
     /// Create a lintcheck crates TOML file containing the top N popular crates
     Popular {
diff --git a/lintcheck/src/json.rs b/lintcheck/src/json.rs
index 8ea0a41ed36..808997ff022 100644
--- a/lintcheck/src/json.rs
+++ b/lintcheck/src/json.rs
@@ -4,8 +4,8 @@
 //! loading warnings from JSON files, and generating human-readable diffs
 //! between different linting runs.
 
-use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
+use std::{fmt, fs};
 
 use itertools::{EitherOrBoth, Itertools};
 use serde::{Deserialize, Serialize};
@@ -17,7 +17,6 @@ const DEFAULT_LIMIT_PER_LINT: usize = 300;
 /// Target for total warnings to display across all lints when truncating output.
 const TRUNCATION_TOTAL_TARGET: usize = 1000;
 
-/// Representation of a single Clippy warning for JSON serialization.
 #[derive(Debug, Deserialize, Serialize)]
 struct LintJson {
     /// The lint name e.g. `clippy::bytes_nth`
@@ -29,7 +28,6 @@ struct LintJson {
 }
 
 impl LintJson {
-    /// Returns a tuple of name and `file_line` for sorting and comparison.
     fn key(&self) -> impl Ord + '_ {
         (self.name.as_str(), self.file_line.as_str())
     }
@@ -40,6 +38,57 @@ impl LintJson {
     }
 }
 
+#[derive(Debug, Serialize)]
+struct SummaryRow {
+    name: String,
+    added: usize,
+    removed: usize,
+    changed: usize,
+}
+
+#[derive(Debug, Serialize)]
+struct Summary(Vec<SummaryRow>);
+
+impl fmt::Display for Summary {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(
+            "\
+| Lint | Added | Removed | Changed |
+| ---- | ----: | ------: | ------: |
+",
+        )?;
+
+        for SummaryRow {
+            name,
+            added,
+            changed,
+            removed,
+        } in &self.0
+        {
+            let html_id = to_html_id(name);
+            writeln!(f, "| [`{name}`](#{html_id}) | {added} | {changed} | {removed} |")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl Summary {
+    fn new(lints: &[LintWarnings]) -> Self {
+        Summary(
+            lints
+                .iter()
+                .map(|lint| SummaryRow {
+                    name: lint.name.clone(),
+                    added: lint.added.len(),
+                    removed: lint.removed.len(),
+                    changed: lint.changed.len(),
+                })
+                .collect(),
+        )
+    }
+}
+
 /// Creates the log file output for [`crate::config::OutputFormat::Json`]
 pub(crate) fn output(clippy_warnings: Vec<ClippyWarning>) -> String {
     let mut lints: Vec<LintJson> = clippy_warnings
@@ -74,7 +123,7 @@ fn load_warnings(path: &Path) -> Vec<LintJson> {
 ///
 /// Compares warnings from `old_path` and `new_path`, then displays a summary table
 /// and detailed information about added, removed, and changed warnings.
-pub(crate) fn diff(old_path: &Path, new_path: &Path, truncate: bool) {
+pub(crate) fn diff(old_path: &Path, new_path: &Path, truncate: bool, write_summary: Option<PathBuf>) {
     let old_warnings = load_warnings(old_path);
     let new_warnings = load_warnings(new_path);
 
@@ -108,13 +157,16 @@ pub(crate) fn diff(old_path: &Path, new_path: &Path, truncate: bool) {
         }
     }
 
-    print_summary_table(&lint_warnings);
-    println!();
-
     if lint_warnings.is_empty() {
         return;
     }
 
+    let summary = Summary::new(&lint_warnings);
+    if let Some(path) = write_summary {
+        let json = serde_json::to_string(&summary).unwrap();
+        fs::write(path, json).unwrap();
+    }
+
     let truncate_after = if truncate {
         // Max 15 ensures that we at least have five messages per lint
         DEFAULT_LIMIT_PER_LINT
@@ -126,6 +178,7 @@ pub(crate) fn diff(old_path: &Path, new_path: &Path, truncate: bool) {
         usize::MAX
     };
 
+    println!("{summary}");
     for lint in lint_warnings {
         print_lint_warnings(&lint, truncate_after);
     }
@@ -140,13 +193,11 @@ struct LintWarnings {
     changed: Vec<(LintJson, LintJson)>,
 }
 
-/// Prints a formatted report for a single lint type with its warnings.
 fn print_lint_warnings(lint: &LintWarnings, truncate_after: usize) {
     let name = &lint.name;
     let html_id = to_html_id(name);
 
-    // The additional anchor is added for non GH viewers that don't prefix ID's
-    println!(r#"## `{name}` <a id="user-content-{html_id}"></a>"#);
+    println!(r#"<h2 id="{html_id}"><code>{name}</code></h2>"#);
     println!();
 
     print!(
@@ -162,22 +213,6 @@ fn print_lint_warnings(lint: &LintWarnings, truncate_after: usize) {
     print_changed_diff(&lint.changed, truncate_after / 3);
 }
 
-/// Prints a summary table of all lints with counts of added, removed, and changed warnings.
-fn print_summary_table(lints: &[LintWarnings]) {
-    println!("| Lint                                       | Added   | Removed | Changed |");
-    println!("| ------------------------------------------ | ------: | ------: | ------: |");
-
-    for lint in lints {
-        println!(
-            "| {:<62} | {:>7} | {:>7} | {:>7} |",
-            format!("[`{}`](#user-content-{})", lint.name, to_html_id(&lint.name)),
-            lint.added.len(),
-            lint.removed.len(),
-            lint.changed.len()
-        );
-    }
-}
-
 /// Prints a section of warnings with a header and formatted code blocks.
 fn print_warnings(title: &str, warnings: &[LintJson], truncate_after: usize) {
     if warnings.is_empty() {
@@ -248,17 +283,16 @@ fn truncate<T>(list: &[T], truncate_after: usize) -> &[T] {
     }
 }
 
-/// Prints a level 3 heading with an appropriate HTML ID for linking.
 fn print_h3(lint: &str, title: &str) {
     let html_id = to_html_id(lint);
-    // We have to use HTML here to be able to manually add an id.
-    println!(r#"### {title} <a id="user-content-{html_id}-{title}"></a>"#);
+    // We have to use HTML here to be able to manually add an id, GitHub doesn't add them automatically
+    println!(r#"<h3 id="{html_id}-{title}">{title}</h3>"#);
 }
 
-/// GitHub's markdown parsers doesn't like IDs with `::` and `_`. This simplifies
-/// the lint name for the HTML ID.
+/// Creates a custom ID allowed by GitHub, they must start with `user-content-` and cannot contain
+/// `::`/`_`
 fn to_html_id(lint_name: &str) -> String {
-    lint_name.replace("clippy::", "").replace('_', "-")
+    lint_name.replace("clippy::", "user-content-").replace('_', "-")
 }
 
 /// This generates the `x added` string for the start of the job summery.
@@ -270,9 +304,6 @@ fn count_string(lint: &str, label: &str, count: usize) -> String {
         format!("0 {label}")
     } else {
         let html_id = to_html_id(lint);
-        // GitHub's job summaries don't add HTML ids to headings. That's why we
-        // manually have to add them. GitHub prefixes these manual ids with
-        // `user-content-` and that's how we end up with these awesome links :D
-        format!("[{count} {label}](#user-content-{html_id}-{label})")
+        format!("[{count} {label}](#{html_id}-{label})")
     }
 }
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index d4bf6cd48a1..8fc2a8a4e79 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -297,7 +297,12 @@ fn main() {
     let config = LintcheckConfig::new();
 
     match config.subcommand {
-        Some(Commands::Diff { old, new, truncate }) => json::diff(&old, &new, truncate),
+        Some(Commands::Diff {
+            old,
+            new,
+            truncate,
+            write_summary,
+        }) => json::diff(&old, &new, truncate, write_summary),
         Some(Commands::Popular { output, number }) => popular_crates::fetch(output, number).unwrap(),
         None => lintcheck(config),
     }
-- 
cgit 1.4.1-3-g733a5


From 8bb957eeac0e887649122a779f544e38bacb2a45 Mon Sep 17 00:00:00 2001
From: lolbinarycat <binarycat@envs.net>
Date: Thu, 22 May 2025 19:25:02 -0500
Subject: triagebot: enable issue transfer

---
 triagebot.toml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 389f22c6a2c..a3589122340 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -15,6 +15,8 @@ allow-unauthenticated = [
 
 [close]
 
+[transfer]
+
 [issue-links]
 
 # Prevents mentions in commits to avoid users being spammed
-- 
cgit 1.4.1-3-g733a5


From cdeca5cbd323841285d41af33825864b5764642e Mon Sep 17 00:00:00 2001
From: The 8472 <git@infinite-source.de>
Date: Wed, 30 Apr 2025 20:51:22 +0200
Subject: fix Zip unsoundness (again)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Some history: The Zip TrustedRandomAccess specialization has tried
to emulate the side-effects of the naive implementation for a long time,
including backwards iteration. 82292¹ tried to fix unsoundness (82291¹) in that
side-effect-preservation code, but this introduced some panic-safety
unsoundness (86443¹), but the fix 86452¹ didn't fix it for nested Zip
iterators (137255¹).

Rather than piling yet another fix ontop of this heap of fixes this PR reduces
the number of cases in which side-effects will be preserved; the necessary
API guarantee change was approved in 83791¹ but we haven't made use of that
so far.

¹ see merge commit for linkfied issues.
---
 library/core/src/iter/adapters/zip.rs           | 74 +++++++++----------
 library/coretests/tests/iter/adapters/cloned.rs |  3 +-
 library/coretests/tests/iter/adapters/zip.rs    | 97 ++++++++++++++++---------
 3 files changed, 99 insertions(+), 75 deletions(-)

diff --git a/library/core/src/iter/adapters/zip.rs b/library/core/src/iter/adapters/zip.rs
index 8090c98e7ed..c5e199c3082 100644
--- a/library/core/src/iter/adapters/zip.rs
+++ b/library/core/src/iter/adapters/zip.rs
@@ -18,7 +18,6 @@ pub struct Zip<A, B> {
     // index, len and a_len are only used by the specialized version of zip
     index: usize,
     len: usize,
-    a_len: usize,
 }
 impl<A: Iterator, B: Iterator> Zip<A, B> {
     pub(in crate::iter) fn new(a: A, b: B) -> Zip<A, B> {
@@ -158,7 +157,6 @@ macro_rules! zip_impl_general_defaults {
                 b,
                 index: 0, // unused
                 len: 0,   // unused
-                a_len: 0, // unused
             }
         }
 
@@ -299,9 +297,8 @@ where
     B: TrustedRandomAccess + Iterator,
 {
     fn new(a: A, b: B) -> Self {
-        let a_len = a.size();
-        let len = cmp::min(a_len, b.size());
-        Zip { a, b, index: 0, len, a_len }
+        let len = cmp::min(a.size(), b.size());
+        Zip { a, b, index: 0, len }
     }
 
     #[inline]
@@ -315,17 +312,6 @@ where
             unsafe {
                 Some((self.a.__iterator_get_unchecked(i), self.b.__iterator_get_unchecked(i)))
             }
-        } else if A::MAY_HAVE_SIDE_EFFECT && self.index < self.a_len {
-            let i = self.index;
-            // as above, increment before executing code that may panic
-            self.index += 1;
-            self.len += 1;
-            // match the base implementation's potential side effects
-            // SAFETY: we just checked that `i` < `self.a.len()`
-            unsafe {
-                self.a.__iterator_get_unchecked(i);
-            }
-            None
         } else {
             None
         }
@@ -371,36 +357,42 @@ where
         A: DoubleEndedIterator + ExactSizeIterator,
         B: DoubleEndedIterator + ExactSizeIterator,
     {
-        if A::MAY_HAVE_SIDE_EFFECT || B::MAY_HAVE_SIDE_EFFECT {
-            let sz_a = self.a.size();
-            let sz_b = self.b.size();
-            // Adjust a, b to equal length, make sure that only the first call
-            // of `next_back` does this, otherwise we will break the restriction
-            // on calls to `self.next_back()` after calling `get_unchecked()`.
-            if sz_a != sz_b {
+        // No effects when the iterator is exhausted, to reduce the number of
+        // cases the unsafe code has to handle.
+        // See #137255 for a case where where too many epicycles lead to unsoundness.
+        if self.index < self.len {
+            let old_len = self.len;
+
+            // since get_unchecked and the side-effecting code can execute user code
+            // which can panic we decrement the counter beforehand
+            // so that the same index won't be accessed twice, as required by TrustedRandomAccess.
+            // Additionally this will ensure that the side-effects code won't run a second time.
+            self.len -= 1;
+
+            // Adjust a, b to equal length if we're iterating backwards.
+            if A::MAY_HAVE_SIDE_EFFECT || B::MAY_HAVE_SIDE_EFFECT {
+                // note if some forward-iteration already happened then these aren't the real
+                // remaining lengths of the inner iterators, so we have to relate them to
+                // Zip's internal length-tracking.
                 let sz_a = self.a.size();
-                if A::MAY_HAVE_SIDE_EFFECT && sz_a > self.len {
-                    for _ in 0..sz_a - self.len {
-                        // since next_back() may panic we increment the counters beforehand
-                        // to keep Zip's state in sync with the underlying iterator source
-                        self.a_len -= 1;
-                        self.a.next_back();
-                    }
-                    debug_assert_eq!(self.a_len, self.len);
-                }
                 let sz_b = self.b.size();
-                if B::MAY_HAVE_SIDE_EFFECT && sz_b > self.len {
-                    for _ in 0..sz_b - self.len {
-                        self.b.next_back();
+                // This condition can and must only be true on the first `next_back` call,
+                // otherwise we will break the restriction on calls to `self.next_back()`
+                // after calling `get_unchecked()`.
+                if sz_a != sz_b && (old_len == sz_a || old_len == sz_b) {
+                    if A::MAY_HAVE_SIDE_EFFECT && sz_a > old_len {
+                        for _ in 0..sz_a - old_len {
+                            self.a.next_back();
+                        }
                     }
+                    if B::MAY_HAVE_SIDE_EFFECT && sz_b > old_len {
+                        for _ in 0..sz_b - old_len {
+                            self.b.next_back();
+                        }
+                    }
+                    debug_assert_eq!(self.a.size(), self.b.size());
                 }
             }
-        }
-        if self.index < self.len {
-            // since get_unchecked executes code which can panic we increment the counters beforehand
-            // so that the same index won't be accessed twice, as required by TrustedRandomAccess
-            self.len -= 1;
-            self.a_len -= 1;
             let i = self.len;
             // SAFETY: `i` is smaller than the previous value of `self.len`,
             // which is also smaller than or equal to `self.a.len()` and `self.b.len()`
diff --git a/library/coretests/tests/iter/adapters/cloned.rs b/library/coretests/tests/iter/adapters/cloned.rs
index 78babb7feab..0a3dd1ce46e 100644
--- a/library/coretests/tests/iter/adapters/cloned.rs
+++ b/library/coretests/tests/iter/adapters/cloned.rs
@@ -31,7 +31,8 @@ fn test_cloned_side_effects() {
             .zip(&[1]);
         for _ in iter {}
     }
-    assert_eq!(count, 2);
+    // Zip documentation provides some leeway about side-effects
+    assert!([1, 2].iter().any(|v| *v == count));
 }
 
 #[test]
diff --git a/library/coretests/tests/iter/adapters/zip.rs b/library/coretests/tests/iter/adapters/zip.rs
index 70392dca0fa..b00433c70fe 100644
--- a/library/coretests/tests/iter/adapters/zip.rs
+++ b/library/coretests/tests/iter/adapters/zip.rs
@@ -107,9 +107,19 @@ fn test_zip_next_back_side_effects_exhausted() {
     iter.next();
     iter.next();
     iter.next();
-    iter.next();
+    assert_eq!(iter.next(), None);
     assert_eq!(iter.next_back(), None);
-    assert_eq!(a, vec![1, 2, 3, 4, 6, 5]);
+
+    assert!(a.starts_with(&[1, 2, 3]));
+    let a_len = a.len();
+    // Tail-side-effects of forward-iteration are "at most one" per next().
+    // And for reverse iteration we don't guarantee much either.
+    // But we can put some bounds on the possible behaviors.
+    assert!(a_len <= 6);
+    assert!(a_len >= 3);
+    a.sort();
+    assert_eq!(a, &[1, 2, 3, 4, 5, 6][..a.len()]);
+
     assert_eq!(b, vec![200, 300, 400]);
 }
 
@@ -120,7 +130,8 @@ fn test_zip_cloned_sideffectful() {
 
     for _ in xs.iter().cloned().zip(ys.iter().cloned()) {}
 
-    assert_eq!(&xs, &[1, 1, 1, 0][..]);
+    // Zip documentation permits either case.
+    assert!([&[1, 1, 1, 0], &[1, 1, 0, 0]].iter().any(|v| &xs == *v));
     assert_eq!(&ys, &[1, 1][..]);
 
     let xs = [CountClone::new(), CountClone::new()];
@@ -139,7 +150,8 @@ fn test_zip_map_sideffectful() {
 
     for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) {}
 
-    assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
+    // Zip documentation permits either case.
+    assert!([&[1, 1, 1, 1, 1, 0], &[1, 1, 1, 1, 0, 0]].iter().any(|v| &xs == *v));
     assert_eq!(&ys, &[1, 1, 1, 1]);
 
     let mut xs = [0; 4];
@@ -168,7 +180,8 @@ fn test_zip_map_rev_sideffectful() {
 
     {
         let mut it = xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1));
-        (&mut it).take(5).count();
+        // the current impl only trims the tails if the iterator isn't exhausted
+        (&mut it).take(3).count();
         it.next_back();
     }
     assert_eq!(&xs, &[1, 1, 1, 1, 1, 1]);
@@ -211,9 +224,18 @@ fn test_zip_nth_back_side_effects_exhausted() {
     iter.next();
     iter.next();
     iter.next();
-    iter.next();
+    assert_eq!(iter.next(), None);
     assert_eq!(iter.nth_back(0), None);
-    assert_eq!(a, vec![1, 2, 3, 4, 6, 5]);
+    assert!(a.starts_with(&[1, 2, 3]));
+    let a_len = a.len();
+    // Tail-side-effects of forward-iteration are "at most one" per next().
+    // And for reverse iteration we don't guarantee much either.
+    // But we can put some bounds on the possible behaviors.
+    assert!(a_len <= 6);
+    assert!(a_len >= 3);
+    a.sort();
+    assert_eq!(a, &[1, 2, 3, 4, 5, 6][..a.len()]);
+
     assert_eq!(b, vec![200, 300, 400]);
 }
 
@@ -237,32 +259,6 @@ fn test_zip_trusted_random_access_composition() {
     assert_eq!(z2.next().unwrap(), ((1, 1), 1));
 }
 
-#[test]
-#[cfg(panic = "unwind")]
-fn test_zip_trusted_random_access_next_back_drop() {
-    use std::panic::{AssertUnwindSafe, catch_unwind};
-
-    let mut counter = 0;
-
-    let it = [42].iter().map(|e| {
-        let c = counter;
-        counter += 1;
-        if c == 0 {
-            panic!("bomb");
-        }
-
-        e
-    });
-    let it2 = [(); 0].iter();
-    let mut zip = it.zip(it2);
-    catch_unwind(AssertUnwindSafe(|| {
-        zip.next_back();
-    }))
-    .unwrap_err();
-    assert!(zip.next().is_none());
-    assert_eq!(counter, 1);
-}
-
 #[test]
 fn test_double_ended_zip() {
     let xs = [1, 2, 3, 4, 5, 6];
@@ -275,6 +271,41 @@ fn test_double_ended_zip() {
     assert_eq!(it.next(), None);
 }
 
+#[test]
+#[cfg(panic = "unwind")]
+fn test_nested_zip_panic_safety() {
+    use std::panic::{AssertUnwindSafe, catch_unwind, resume_unwind};
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    let mut panic = true;
+    let witness = [8, 9, 10, 11, 12].map(|i| (i, AtomicUsize::new(0)));
+    let a = witness.as_slice().iter().map(|e| {
+        e.1.fetch_add(1, Ordering::Relaxed);
+        if panic {
+            panic = false;
+            resume_unwind(Box::new(()))
+        }
+        e.0
+    });
+    let b = [1, 2, 3, 4].as_slice().iter().copied();
+    let c = [5, 6, 7].as_slice().iter().copied();
+    let ab = zip(a, b);
+
+    let mut abc = zip(ab, c);
+
+    assert_eq!(abc.len(), 3);
+    catch_unwind(AssertUnwindSafe(|| abc.next_back())).ok();
+    assert_eq!(abc.len(), 2);
+    assert_eq!(abc.next(), Some(((8, 1), 5)));
+    assert_eq!(abc.next_back(), Some(((9, 2), 6)));
+    for (i, (_, w)) in witness.iter().enumerate() {
+        let v = w.load(Ordering::Relaxed);
+        assert!(v <= 1, "expected idx {i} to be visited at most once, actual: {v}");
+    }
+    // backwards trimming panicked and should only run once, so this one won't be visited.
+    assert_eq!(witness[3].1.load(Ordering::Relaxed), 0);
+}
+
 #[test]
 fn test_issue_82282() {
     fn overflowed_zip(arr: &[i32]) -> impl Iterator<Item = (i32, &())> {
-- 
cgit 1.4.1-3-g733a5


From 61c2c1211fc0591ff000fcb742f352f4e319ea82 Mon Sep 17 00:00:00 2001
From: The 8472 <git@infinite-source.de>
Date: Thu, 5 Jun 2025 01:25:19 +0200
Subject: add comments to Zip unsoundness regression test

---
 library/coretests/tests/iter/adapters/zip.rs | 26 ++++++++++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

diff --git a/library/coretests/tests/iter/adapters/zip.rs b/library/coretests/tests/iter/adapters/zip.rs
index b00433c70fe..83279380175 100644
--- a/library/coretests/tests/iter/adapters/zip.rs
+++ b/library/coretests/tests/iter/adapters/zip.rs
@@ -273,11 +273,18 @@ fn test_double_ended_zip() {
 
 #[test]
 #[cfg(panic = "unwind")]
+/// Regresion test for #137255
+/// A previous implementation of Zip TrustedRandomAccess specializations tried to do a lot of work
+/// to preserve side-effects of equalizing the iterator lengths during backwards iteration.
+/// This lead to several cases of unsoundness, twice due to being left in an inconsistent state
+/// after panics.
+/// The new implementation does not try as hard, but we still need panic-safety.
 fn test_nested_zip_panic_safety() {
     use std::panic::{AssertUnwindSafe, catch_unwind, resume_unwind};
     use std::sync::atomic::{AtomicUsize, Ordering};
 
     let mut panic = true;
+    // keeps track of how often element get visited, must be at most once each
     let witness = [8, 9, 10, 11, 12].map(|i| (i, AtomicUsize::new(0)));
     let a = witness.as_slice().iter().map(|e| {
         e.1.fetch_add(1, Ordering::Relaxed);
@@ -287,22 +294,37 @@ fn test_nested_zip_panic_safety() {
         }
         e.0
     });
+    // shorter than `a`, so `a` will get trimmed
     let b = [1, 2, 3, 4].as_slice().iter().copied();
+    // shorter still, so `ab` will get trimmed.`
     let c = [5, 6, 7].as_slice().iter().copied();
-    let ab = zip(a, b);
 
+    // This will panic during backwards trimming.
+    let ab = zip(a, b);
+    // This being Zip + TrustedRandomAccess means it will only call `next_back``
+    // during trimming and otherwise do calls `__iterator_get_unchecked` on `ab`.
     let mut abc = zip(ab, c);
 
     assert_eq!(abc.len(), 3);
+    // This will first trigger backwards trimming before it would normally obtain the
+    // actual element if it weren't for the panic.
+    // This used to corrupt the internal state of `abc`, which then lead to
+    // TrustedRandomAccess safety contract violations in calls to  `ab`,
+    // which ultimately lead to UB.
     catch_unwind(AssertUnwindSafe(|| abc.next_back())).ok();
+    // check for sane outward behavior after the panic, which indicates a sane internal state.
+    // Technically these outcomes are not required because a panic frees us from correctness obligations.
     assert_eq!(abc.len(), 2);
     assert_eq!(abc.next(), Some(((8, 1), 5)));
     assert_eq!(abc.next_back(), Some(((9, 2), 6)));
     for (i, (_, w)) in witness.iter().enumerate() {
         let v = w.load(Ordering::Relaxed);
+        // required by TRA contract
         assert!(v <= 1, "expected idx {i} to be visited at most once, actual: {v}");
     }
-    // backwards trimming panicked and should only run once, so this one won't be visited.
+    // Trimming panicked and should only run once, so this one won't be visited.
+    // Implementation detail, but not trying to run it again is what keeps
+    // things simple.
     assert_eq!(witness[3].1.load(Ordering::Relaxed), 0);
 }
 
-- 
cgit 1.4.1-3-g733a5


From c416249337e238ff888d7c079b904c2938dd8534 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Mon, 12 May 2025 14:02:58 +0800
Subject: feat: ide-assist, generate single field struct From

---
 .../handlers/generate_single_field_struct_from.rs  | 1000 ++++++++++++++++++++
 .../rust-analyzer/crates/ide-assists/src/lib.rs    |    2 +
 .../crates/ide-assists/src/tests/generated.rs      |   28 +
 .../rust-analyzer/crates/ide-assists/src/utils.rs  |   19 +-
 4 files changed, 1043 insertions(+), 6 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
new file mode 100644
index 00000000000..4e95ceb2e85
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_single_field_struct_from.rs
@@ -0,0 +1,1000 @@
+use ast::make;
+use hir::{HasCrate, ModuleDef, Semantics};
+use ide_db::{
+    RootDatabase, famous_defs::FamousDefs, helpers::mod_path_to_ast,
+    imports::import_assets::item_for_path_search, use_trivial_constructor::use_trivial_constructor,
+};
+use syntax::{
+    TokenText,
+    ast::{self, AstNode, HasGenericParams, HasName, edit, edit_in_place::Indent},
+};
+
+use crate::{
+    AssistId,
+    assist_context::{AssistContext, Assists},
+    utils::add_cfg_attrs_to,
+};
+
+// Assist: generate_single_field_struct_from
+//
+// Implement From for a single field structure, ignore trivial types.
+//
+// ```
+// # //- minicore: from, phantom_data
+// use core::marker::PhantomData;
+// struct $0Foo<T> {
+//     id: i32,
+//     _phantom_data: PhantomData<T>,
+// }
+// ```
+// ->
+// ```
+// use core::marker::PhantomData;
+// struct Foo<T> {
+//     id: i32,
+//     _phantom_data: PhantomData<T>,
+// }
+//
+// impl<T> From<i32> for Foo<T> {
+//     fn from(id: i32) -> Self {
+//         Self { id, _phantom_data: PhantomData }
+//     }
+// }
+// ```
+pub(crate) fn generate_single_field_struct_from(
+    acc: &mut Assists,
+    ctx: &AssistContext<'_>,
+) -> Option<()> {
+    let strukt_name = ctx.find_node_at_offset::<ast::Name>()?;
+    let adt = ast::Adt::cast(strukt_name.syntax().parent()?)?;
+    let ast::Adt::Struct(strukt) = adt else {
+        return None;
+    };
+
+    let sema = &ctx.sema;
+    let (names, types) = get_fields(&strukt)?;
+
+    let module = sema.scope(strukt.syntax())?.module();
+    let constructors = make_constructors(ctx, module, &types);
+
+    if constructors.iter().filter(|expr| expr.is_none()).count() != 1 {
+        return None;
+    }
+    let main_field_i = constructors.iter().position(Option::is_none)?;
+    if from_impl_exists(&strukt, main_field_i, &ctx.sema).is_some() {
+        return None;
+    }
+
+    let main_field_name =
+        names.as_ref().map_or(TokenText::borrowed("value"), |names| names[main_field_i].text());
+    let main_field_ty = types[main_field_i].clone();
+
+    acc.add(
+        AssistId::generate("generate_single_field_struct_from"),
+        "Generate single field `From`",
+        strukt.syntax().text_range(),
+        |builder| {
+            let indent = strukt.indent_level();
+            let ty_where_clause = strukt.where_clause();
+            let type_gen_params = strukt.generic_param_list();
+            let type_gen_args = type_gen_params.as_ref().map(|params| params.to_generic_args());
+            let trait_gen_args = Some(make::generic_arg_list([ast::GenericArg::TypeArg(
+                make::type_arg(main_field_ty.clone()),
+            )]));
+
+            let ty = make::ty(&strukt_name.text());
+
+            let constructor =
+                make_adt_constructor(names.as_deref(), constructors, &main_field_name);
+            let body = make::block_expr([], Some(constructor));
+
+            let fn_ = make::fn_(
+                None,
+                make::name("from"),
+                None,
+                None,
+                make::param_list(
+                    None,
+                    [make::param(
+                        make::path_pat(make::path_from_text(&main_field_name)),
+                        main_field_ty,
+                    )],
+                ),
+                body,
+                Some(make::ret_type(make::ty("Self"))),
+                false,
+                false,
+                false,
+                false,
+            )
+            .clone_for_update();
+
+            fn_.indent(1.into());
+
+            let impl_ = make::impl_trait(
+                false,
+                None,
+                trait_gen_args,
+                type_gen_params,
+                type_gen_args,
+                false,
+                make::ty("From"),
+                ty.clone(),
+                None,
+                ty_where_clause.map(|wc| edit::AstNodeEdit::reset_indent(&wc)),
+                None,
+            )
+            .clone_for_update();
+
+            impl_.get_or_create_assoc_item_list().add_item(fn_.into());
+
+            add_cfg_attrs_to(&strukt, &impl_);
+
+            impl_.reindent_to(indent);
+
+            builder.insert(strukt.syntax().text_range().end(), format!("\n\n{indent}{impl_}"));
+        },
+    )
+}
+
+fn make_adt_constructor(
+    names: Option<&[ast::Name]>,
+    constructors: Vec<Option<ast::Expr>>,
+    main_field_name: &TokenText<'_>,
+) -> ast::Expr {
+    if let Some(names) = names {
+        let fields = make::record_expr_field_list(names.iter().zip(constructors).map(
+            |(name, initializer)| {
+                make::record_expr_field(make::name_ref(&name.text()), initializer)
+            },
+        ));
+        make::record_expr(make::path_from_text("Self"), fields).into()
+    } else {
+        let arg_list = make::arg_list(constructors.into_iter().map(|expr| {
+            expr.unwrap_or_else(|| make::expr_path(make::path_from_text(main_field_name)))
+        }));
+        make::expr_call(make::expr_path(make::path_from_text("Self")), arg_list).into()
+    }
+}
+
+fn make_constructors(
+    ctx: &AssistContext<'_>,
+    module: hir::Module,
+    types: &[ast::Type],
+) -> Vec<Option<ast::Expr>> {
+    let (db, sema) = (ctx.db(), &ctx.sema);
+    types
+        .iter()
+        .map(|ty| {
+            let ty = sema.resolve_type(ty)?;
+            if ty.is_unit() {
+                return Some(make::expr_tuple([]).into());
+            }
+            let item_in_ns = ModuleDef::Adt(ty.as_adt()?).into();
+            let edition = module.krate().edition(db);
+
+            let ty_path = module.find_path(
+                db,
+                item_for_path_search(db, item_in_ns)?,
+                ctx.config.import_path_config(),
+            )?;
+
+            use_trivial_constructor(db, mod_path_to_ast(&ty_path, edition), &ty, edition)
+        })
+        .collect()
+}
+
+fn get_fields(strukt: &ast::Struct) -> Option<(Option<Vec<ast::Name>>, Vec<ast::Type>)> {
+    Some(match strukt.kind() {
+        ast::StructKind::Unit => return None,
+        ast::StructKind::Record(fields) => {
+            let names = fields.fields().map(|field| field.name()).collect::<Option<_>>()?;
+            let types = fields.fields().map(|field| field.ty()).collect::<Option<_>>()?;
+            (Some(names), types)
+        }
+        ast::StructKind::Tuple(fields) => {
+            (None, fields.fields().map(|field| field.ty()).collect::<Option<_>>()?)
+        }
+    })
+}
+
+fn from_impl_exists(
+    strukt: &ast::Struct,
+    main_field_i: usize,
+    sema: &Semantics<'_, RootDatabase>,
+) -> Option<()> {
+    let db = sema.db;
+    let strukt = sema.to_def(strukt)?;
+    let krate = strukt.krate(db);
+    let from_trait = FamousDefs(sema, krate).core_convert_From()?;
+    let ty = strukt.fields(db).get(main_field_i)?.ty(db);
+
+    strukt.ty(db).impls_trait(db, from_trait, &[ty]).then_some(())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::generate_single_field_struct_from;
+
+    #[test]
+    fn works() {
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo {
+                foo: i32,
+            }
+            "#,
+            r#"
+            struct Foo {
+                foo: i32,
+            }
+
+            impl From<i32> for Foo {
+                fn from(foo: i32) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from, phantom_data
+            struct $0Foo {
+                b1: (),
+                b2: core::marker::PhantomData,
+                foo: i32,
+                a1: (),
+                a2: core::marker::PhantomData,
+            }
+            "#,
+            r#"
+            struct Foo {
+                b1: (),
+                b2: core::marker::PhantomData,
+                foo: i32,
+                a1: (),
+                a2: core::marker::PhantomData,
+            }
+
+            impl From<i32> for Foo {
+                fn from(foo: i32) -> Self {
+                    Self { b1: (), b2: core::marker::PhantomData, foo, a1: (), a2: core::marker::PhantomData }
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn cfgs() {
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            #[cfg(feature = "foo")]
+            #[cfg(test)]
+            struct $0Foo {
+                foo: i32,
+            }
+            "#,
+            r#"
+            #[cfg(feature = "foo")]
+            #[cfg(test)]
+            struct Foo {
+                foo: i32,
+            }
+
+            #[cfg(feature = "foo")]
+            #[cfg(test)]
+            impl From<i32> for Foo {
+                fn from(foo: i32) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn indent() {
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            mod foo {
+                struct $0Foo {
+                    foo: i32,
+                }
+            }
+            "#,
+            r#"
+            mod foo {
+                struct Foo {
+                    foo: i32,
+                }
+
+                impl From<i32> for Foo {
+                    fn from(foo: i32) -> Self {
+                        Self { foo }
+                    }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            mod foo {
+                mod bar {
+                    struct $0Foo {
+                        foo: i32,
+                    }
+                }
+            }
+            "#,
+            r#"
+            mod foo {
+                mod bar {
+                    struct Foo {
+                        foo: i32,
+                    }
+
+                    impl From<i32> for Foo {
+                        fn from(foo: i32) -> Self {
+                            Self { foo }
+                        }
+                    }
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn where_clause_indent() {
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            mod foo {
+                mod bar {
+                    trait Trait {}
+                    struct $0Foo<T>
+                    where
+                        T: Trait,
+                    {
+                        foo: T,
+                    }
+                }
+            }
+            "#,
+            r#"
+            mod foo {
+                mod bar {
+                    trait Trait {}
+                    struct Foo<T>
+                    where
+                        T: Trait,
+                    {
+                        foo: T,
+                    }
+
+                    impl<T> From<T> for Foo<T>
+                    where
+                        T: Trait,
+                    {
+                        fn from(foo: T) -> Self {
+                            Self { foo }
+                        }
+                    }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            mod foo {
+                mod bar {
+                    trait Trait<const B: bool> {}
+                    struct $0Foo<T>
+                    where
+                        T: Trait<{
+                            true
+                        }>
+                    {
+                        foo: T,
+                    }
+                }
+            }
+            "#,
+            r#"
+            mod foo {
+                mod bar {
+                    trait Trait<const B: bool> {}
+                    struct Foo<T>
+                    where
+                        T: Trait<{
+                            true
+                        }>
+                    {
+                        foo: T,
+                    }
+
+                    impl<T> From<T> for Foo<T>
+                    where
+                        T: Trait<{
+                            true
+                        }>
+                    {
+                        fn from(foo: T) -> Self {
+                            Self { foo }
+                        }
+                    }
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn generics() {
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T> {
+                foo: T,
+            }
+            "#,
+            r#"
+            struct Foo<T> {
+                foo: T,
+            }
+
+            impl<T> From<T> for Foo<T> {
+                fn from(foo: T) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T: Send> {
+                foo: T,
+            }
+            "#,
+            r#"
+            struct Foo<T: Send> {
+                foo: T,
+            }
+
+            impl<T: Send> From<T> for Foo<T> {
+                fn from(foo: T) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T: Send> where T: Sync,{
+                foo: T,
+            }
+            "#,
+            r#"
+            struct Foo<T: Send> where T: Sync,{
+                foo: T,
+            }
+
+            impl<T: Send> From<T> for Foo<T>
+            where T: Sync,
+            {
+                fn from(foo: T) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T: Send> where T: Sync {
+                foo: T,
+            }
+            "#,
+            r#"
+            struct Foo<T: Send> where T: Sync {
+                foo: T,
+            }
+
+            impl<T: Send> From<T> for Foo<T>
+            where T: Sync
+            {
+                fn from(foo: T) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T: Send> where T: Sync, Self: Send {
+                foo: T,
+            }
+            "#,
+            r#"
+            struct Foo<T: Send> where T: Sync, Self: Send {
+                foo: T,
+            }
+
+            impl<T: Send> From<T> for Foo<T>
+            where T: Sync, Self: Send
+            {
+                fn from(foo: T) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T: Send>
+            where T: Sync, Self: Send
+            {
+                foo: T,
+            }
+            "#,
+            r#"
+            struct Foo<T: Send>
+            where T: Sync, Self: Send
+            {
+                foo: T,
+            }
+
+            impl<T: Send> From<T> for Foo<T>
+            where T: Sync, Self: Send
+            {
+                fn from(foo: T) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T: Send>
+            where T: Sync, Self: Send,
+            {
+                foo: T,
+            }
+            "#,
+            r#"
+            struct Foo<T: Send>
+            where T: Sync, Self: Send,
+            {
+                foo: T,
+            }
+
+            impl<T: Send> From<T> for Foo<T>
+            where T: Sync, Self: Send,
+            {
+                fn from(foo: T) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T: Send>
+            where T: Sync,
+                  Self: Send,
+            {
+                foo: T,
+            }
+            "#,
+            r#"
+            struct Foo<T: Send>
+            where T: Sync,
+                  Self: Send,
+            {
+                foo: T,
+            }
+
+            impl<T: Send> From<T> for Foo<T>
+            where T: Sync,
+                  Self: Send,
+            {
+                fn from(foo: T) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T: Send>
+            where
+                T: Sync,
+                Self: Send,
+            {
+                foo: T,
+            }
+            "#,
+            r#"
+            struct Foo<T: Send>
+            where
+                T: Sync,
+                Self: Send,
+            {
+                foo: T,
+            }
+
+            impl<T: Send> From<T> for Foo<T>
+            where
+                T: Sync,
+                Self: Send,
+            {
+                fn from(foo: T) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T: Send + Sync>
+            where
+                T: Sync,
+                Self: Send,
+            {
+                foo: T,
+            }
+            "#,
+            r#"
+            struct Foo<T: Send + Sync>
+            where
+                T: Sync,
+                Self: Send,
+            {
+                foo: T,
+            }
+
+            impl<T: Send + Sync> From<T> for Foo<T>
+            where
+                T: Sync,
+                Self: Send,
+            {
+                fn from(foo: T) -> Self {
+                    Self { foo }
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn tuple() {
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo(i32);
+            "#,
+            r#"
+            struct Foo(i32);
+
+            impl From<i32> for Foo {
+                fn from(value: i32) -> Self {
+                    Self(value)
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T>(T);
+            "#,
+            r#"
+            struct Foo<T>(T);
+
+            impl<T> From<T> for Foo<T> {
+                fn from(value: T) -> Self {
+                    Self(value)
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn trivial() {
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from, phantom_data
+            use core::marker::PhantomData;
+            struct $0Foo(i32, PhantomData<i32>);
+            "#,
+            r#"
+            use core::marker::PhantomData;
+            struct Foo(i32, PhantomData<i32>);
+
+            impl From<i32> for Foo {
+                fn from(value: i32) -> Self {
+                    Self(value, PhantomData)
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from, phantom_data
+            use core::marker::PhantomData;
+            struct $0Foo(i32, PhantomData<()>);
+            "#,
+            r#"
+            use core::marker::PhantomData;
+            struct Foo(i32, PhantomData<()>);
+
+            impl From<i32> for Foo {
+                fn from(value: i32) -> Self {
+                    Self(value, PhantomData)
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from, phantom_data
+            use core::marker::PhantomData;
+            struct $0Foo(PhantomData<()>, i32, PhantomData<()>);
+            "#,
+            r#"
+            use core::marker::PhantomData;
+            struct Foo(PhantomData<()>, i32, PhantomData<()>);
+
+            impl From<i32> for Foo {
+                fn from(value: i32) -> Self {
+                    Self(PhantomData, value, PhantomData)
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from, phantom_data
+            use core::marker::PhantomData;
+            struct $0Foo<T>(PhantomData<T>, i32, PhantomData<()>);
+            "#,
+            r#"
+            use core::marker::PhantomData;
+            struct Foo<T>(PhantomData<T>, i32, PhantomData<()>);
+
+            impl<T> From<i32> for Foo<T> {
+                fn from(value: i32) -> Self {
+                    Self(PhantomData, value, PhantomData)
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn unit() {
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo(i32, ());
+            "#,
+            r#"
+            struct Foo(i32, ());
+
+            impl From<i32> for Foo {
+                fn from(value: i32) -> Self {
+                    Self(value, ())
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo((), i32, ());
+            "#,
+            r#"
+            struct Foo((), i32, ());
+
+            impl From<i32> for Foo {
+                fn from(value: i32) -> Self {
+                    Self((), value, ())
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo((), (), i32, ());
+            "#,
+            r#"
+            struct Foo((), (), i32, ());
+
+            impl From<i32> for Foo {
+                fn from(value: i32) -> Self {
+                    Self((), (), value, ())
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn invalid_multiple_main_field() {
+        check_assist_not_applicable(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo(i32, i32);
+            "#,
+        );
+        check_assist_not_applicable(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T>(i32, T);
+            "#,
+        );
+        check_assist_not_applicable(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T>(T, T);
+            "#,
+        );
+        check_assist_not_applicable(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo<T> { foo: T, bar: i32 }
+            "#,
+        );
+        check_assist_not_applicable(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo { foo: i32, bar: i64 }
+            "#,
+        );
+    }
+
+    #[test]
+    fn exists_other_from() {
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo(i32);
+
+            impl From<&i32> for Foo {
+                fn from(value: &i32) -> Self {
+                    todo!()
+                }
+            }
+            "#,
+            r#"
+            struct Foo(i32);
+
+            impl From<i32> for Foo {
+                fn from(value: i32) -> Self {
+                    Self(value)
+                }
+            }
+
+            impl From<&i32> for Foo {
+                fn from(value: &i32) -> Self {
+                    todo!()
+                }
+            }
+            "#,
+        );
+        check_assist(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo(i32);
+
+            type X = i32;
+
+            impl From<&X> for Foo {
+                fn from(value: &X) -> Self {
+                    todo!()
+                }
+            }
+            "#,
+            r#"
+            struct Foo(i32);
+
+            impl From<i32> for Foo {
+                fn from(value: i32) -> Self {
+                    Self(value)
+                }
+            }
+
+            type X = i32;
+
+            impl From<&X> for Foo {
+                fn from(value: &X) -> Self {
+                    todo!()
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn exists_from() {
+        check_assist_not_applicable(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo(i32);
+
+            impl From<i32> for Foo {
+                fn from(_: i32) -> Self {
+                    todo!()
+                }
+            }
+            "#,
+        );
+        check_assist_not_applicable(
+            generate_single_field_struct_from,
+            r#"
+            //- minicore: from
+            struct $0Foo(i32);
+
+            type X = i32;
+
+            impl From<X> for Foo {
+                fn from(_: X) -> Self {
+                    todo!()
+                }
+            }
+            "#,
+        );
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs b/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs
index 2395091b6f2..1f8826e7660 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/lib.rs
@@ -171,6 +171,7 @@ mod handlers {
     mod generate_is_empty_from_len;
     mod generate_mut_trait_impl;
     mod generate_new;
+    mod generate_single_field_struct_from;
     mod generate_trait_from_impl;
     mod inline_call;
     mod inline_const_as_literal;
@@ -304,6 +305,7 @@ mod handlers {
             generate_mut_trait_impl::generate_mut_trait_impl,
             generate_new::generate_new,
             generate_trait_from_impl::generate_trait_from_impl,
+            generate_single_field_struct_from::generate_single_field_struct_from,
             inline_call::inline_call,
             inline_call::inline_into_callers,
             inline_const_as_literal::inline_const_as_literal,
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 76134acb36e..0b8b74ead03 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
@@ -1953,6 +1953,34 @@ impl Person {
     )
 }
 
+#[test]
+fn doctest_generate_single_field_struct_from() {
+    check_doc_test(
+        "generate_single_field_struct_from",
+        r#####"
+//- minicore: from, phantom_data
+use core::marker::PhantomData;
+struct $0Foo<T> {
+    id: i32,
+    _phantom_data: PhantomData<T>,
+}
+"#####,
+        r#####"
+use core::marker::PhantomData;
+struct Foo<T> {
+    id: i32,
+    _phantom_data: PhantomData<T>,
+}
+
+impl<T> From<i32> for Foo<T> {
+    fn from(id: i32) -> Self {
+        Self { id, _phantom_data: PhantomData }
+    }
+}
+"#####,
+    )
+}
+
 #[test]
 fn doctest_generate_trait_from_impl() {
     check_doc_test(
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 ef6914fda1d..e4ae4d18359 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -747,16 +747,23 @@ fn generate_impl_inner(
     .clone_for_update();
 
     // Copy any cfg attrs from the original adt
-    let cfg_attrs = adt
-        .attrs()
-        .filter(|attr| attr.as_simple_call().map(|(name, _arg)| name == "cfg").unwrap_or(false));
-    for attr in cfg_attrs {
-        impl_.add_attr(attr.clone_for_update());
-    }
+    add_cfg_attrs_to(adt, &impl_);
 
     impl_
 }
 
+pub(crate) fn add_cfg_attrs_to<T, U>(from: &T, to: &U)
+where
+    T: HasAttrs,
+    U: AttrsOwnerEdit,
+{
+    let cfg_attrs =
+        from.attrs().filter(|attr| attr.as_simple_call().is_some_and(|(name, _arg)| name == "cfg"));
+    for attr in cfg_attrs {
+        to.add_attr(attr.clone_for_update());
+    }
+}
+
 pub(crate) fn add_method_to_adt(
     builder: &mut SourceChangeBuilder,
     adt: &ast::Adt,
-- 
cgit 1.4.1-3-g733a5


From 709efc21d247744448c134f337c1815258520911 Mon Sep 17 00:00:00 2001
From: Félix Fischer <felix91gr@gmail.com>
Date: Wed, 28 May 2025 21:03:58 -0400
Subject: Correct the CC lint's documentation

---
 clippy_lints/src/cognitive_complexity.rs | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 5c64216dd92..d5d937d9133 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -14,18 +14,25 @@ use rustc_span::def_id::LocalDefId;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for methods with high cognitive complexity.
+    /// We used to think it measured how hard a method is to understand.
     ///
     /// ### Why is this bad?
-    /// Methods of high cognitive complexity tend to be hard to
-    /// both read and maintain. Also LLVM will tend to optimize small methods better.
+    /// Ideally, we would like to be able to measure how hard a function is
+    /// to understand given its context (what we call its Cognitive Complexity).
+    /// But that's not what this lint does. See "Known problems"
     ///
     /// ### Known problems
-    /// Sometimes it's hard to find a way to reduce the
-    /// complexity.
+    /// The true Cognitive Complexity of a method is not something we can
+    /// calculate using modern technology. This lint has been left in the
+    /// `nursery` so as to not mislead users into using this lint as a
+    /// measurement tool.
     ///
-    /// ### Example
-    /// You'll see it when you get the warning.
+    /// For more detailed information, see [rust-clippy#3793](https://github.com/rust-lang/rust-clippy/issues/3793)
+    ///
+    /// ### Lints to consider instead of this
+    ///
+    /// * [`excessive_nesting`](https://rust-lang.github.io/rust-clippy/master/index.html#excessive_nesting)
+    /// * [`too_many_lines`](https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines)
     #[clippy::version = "1.35.0"]
     pub COGNITIVE_COMPLEXITY,
     nursery,
-- 
cgit 1.4.1-3-g733a5


From 6d1e93d8cdea975303397d91f726c40f5a7396fd Mon Sep 17 00:00:00 2001
From: Daniel Bloom <daniel@wormholelabs.xyz>
Date: Sun, 13 Apr 2025 22:17:26 -0700
Subject: Add support for $crate to Ident

---
 library/proc_macro/src/bridge/symbol.rs          |   4 +-
 tests/ui/proc-macro/auxiliary/mixed-site-span.rs | 110 ++++-
 tests/ui/proc-macro/auxiliary/token-site-span.rs |  30 ++
 tests/ui/proc-macro/mixed-site-span.rs           | 164 ++++++-
 tests/ui/proc-macro/mixed-site-span.stderr       | 600 ++++++++++++++++++++++-
 5 files changed, 859 insertions(+), 49 deletions(-)
 create mode 100644 tests/ui/proc-macro/auxiliary/token-site-span.rs

diff --git a/library/proc_macro/src/bridge/symbol.rs b/library/proc_macro/src/bridge/symbol.rs
index 6a1cecd69fb..57ca7db9fcd 100644
--- a/library/proc_macro/src/bridge/symbol.rs
+++ b/library/proc_macro/src/bridge/symbol.rs
@@ -33,7 +33,7 @@ impl Symbol {
     /// Validates and normalizes before converting it to a symbol.
     pub(crate) fn new_ident(string: &str, is_raw: bool) -> Self {
         // Fast-path: check if this is a valid ASCII identifier
-        if Self::is_valid_ascii_ident(string.as_bytes()) {
+        if Self::is_valid_ascii_ident(string.as_bytes()) || string == "$crate" {
             if is_raw && !Self::can_be_raw(string) {
                 panic!("`{}` cannot be a raw identifier", string);
             }
@@ -79,7 +79,7 @@ impl Symbol {
     // Mimics the behavior of `Symbol::can_be_raw` from `rustc_span`
     fn can_be_raw(string: &str) -> bool {
         match string {
-            "_" | "super" | "self" | "Self" | "crate" => false,
+            "_" | "super" | "self" | "Self" | "crate" | "$crate" => false,
             _ => true,
         }
     }
diff --git a/tests/ui/proc-macro/auxiliary/mixed-site-span.rs b/tests/ui/proc-macro/auxiliary/mixed-site-span.rs
index d837c88c955..18df712debc 100644
--- a/tests/ui/proc-macro/auxiliary/mixed-site-span.rs
+++ b/tests/ui/proc-macro/auxiliary/mixed-site-span.rs
@@ -3,33 +3,89 @@
 extern crate proc_macro;
 use proc_macro::*;
 
+
+#[proc_macro]
+pub fn proc_macro_item(input: TokenStream) -> TokenStream {
+    input
+}
+
+#[proc_macro]
+pub fn proc_macro_rules(_input: TokenStream) -> TokenStream {
+    let id = |s| TokenTree::from(Ident::new(s, Span::mixed_site()));
+    let item_def = id("ItemDef");
+    let local_def = id("local_def");
+    let item_use = id("ItemUse");
+    let local_use = id("local_use");
+    let mut single_quote = Punct::new('\'', Spacing::Joint);
+    single_quote.set_span(Span::mixed_site());
+    let label_use: TokenStream = [
+        TokenTree::from(single_quote),
+        id("label_use"),
+    ].iter().cloned().collect();
+    let dollar_crate = id("$crate");
+    quote!(
+        use $dollar_crate::proc_macro_item as _; // OK
+        type A = $dollar_crate::ItemUse; // ERROR
+
+        struct $item_def;
+        let $local_def = 0;
+
+        $item_use; // OK
+        $local_use; // ERROR
+        break $label_use; // ERROR
+    )
+}
+
+#[proc_macro]
+pub fn with_crate(input: TokenStream) -> TokenStream {
+    let mut input = input.into_iter();
+    let TokenTree::Ident(mut krate) = input.next().unwrap() else { panic!("missing $crate") };
+    let TokenTree::Ident(span) = input.next().unwrap() else { panic!("missing span") };
+    let TokenTree::Ident(ident) = input.next().unwrap() else { panic!("missing ident") };
+
+    match (krate.to_string().as_str(), span.to_string().as_str()) {
+        ("$crate", "input") => {},
+        (_, "input") => krate = Ident::new("$crate", krate.span()),
+
+        ("$crate", "mixed") => krate.set_span(Span::mixed_site()),
+        (_, "mixed") => krate = Ident::new("$crate", Span::mixed_site()),
+
+        ("$crate", "call") => krate.set_span(Span::call_site()),
+        (_, "call") => krate = Ident::new("$crate", Span::call_site()),
+
+        (_, x) => panic!("bad span {}", x),
+    }
+
+    quote!(use $krate::$ident as _;)
+}
+
 #[proc_macro]
-pub fn proc_macro_rules(input: TokenStream) -> TokenStream {
-    if input.is_empty() {
-        let id = |s| TokenTree::from(Ident::new(s, Span::mixed_site()));
-        let item_def = id("ItemDef");
-        let local_def = id("local_def");
-        let item_use = id("ItemUse");
-        let local_use = id("local_use");
-        let mut single_quote = Punct::new('\'', Spacing::Joint);
-        single_quote.set_span(Span::mixed_site());
-        let label_use: TokenStream = [
-            TokenTree::from(single_quote),
-            id("label_use"),
-        ].iter().cloned().collect();
-        quote!(
-            struct $item_def;
-            let $local_def = 0;
-
-            $item_use; // OK
-            $local_use; // ERROR
-            break $label_use; // ERROR
-        )
-    } else {
-        let mut dollar_crate = input.into_iter().next().unwrap();
-        dollar_crate.set_span(Span::mixed_site());
-        quote!(
-            type A = $dollar_crate::ItemUse;
-        )
+pub fn declare_macro(input: TokenStream) -> TokenStream {
+    let mut input = input.into_iter();
+    let TokenTree::Ident(mut krate) = input.next().unwrap() else { panic!("missing $crate") };
+    let TokenTree::Ident(span) = input.next().unwrap() else { panic!("missing span") };
+    let TokenTree::Ident(ident) = input.next().unwrap() else { panic!("missing ident") };
+
+
+    match (krate.to_string().as_str(), span.to_string().as_str()) {
+        ("$crate", "input") => {},
+        (_, "input") => krate = Ident::new("$crate", krate.span()),
+
+        ("$crate", "mixed") => krate.set_span(Span::mixed_site()),
+        (_, "mixed") => krate = Ident::new("$crate", Span::mixed_site()),
+
+        ("$crate", "call") => krate.set_span(Span::call_site()),
+        (_, "call") => krate = Ident::new("$crate", Span::call_site()),
+
+        (_, x) => panic!("bad span {}", x),
     }
+
+    quote!(
+        #[macro_export]
+        macro_rules! $ident {
+            ($$i:ident) => {
+                use $krate::$$i as _;
+            };
+        }
+    )
 }
diff --git a/tests/ui/proc-macro/auxiliary/token-site-span.rs b/tests/ui/proc-macro/auxiliary/token-site-span.rs
new file mode 100644
index 00000000000..39ad8368a50
--- /dev/null
+++ b/tests/ui/proc-macro/auxiliary/token-site-span.rs
@@ -0,0 +1,30 @@
+// Testing token span hygiene.
+
+//@ proc-macro: mixed-site-span.rs
+
+extern crate mixed_site_span;
+
+use mixed_site_span::declare_macro;
+
+pub struct TokenItem;
+
+#[macro_export]
+macro_rules! invoke_with_crate {
+    ($s:ident $i:ident) => { with_crate!{$crate $s $i} };
+}
+
+#[macro_export]
+macro_rules! invoke_with_ident {
+    ($s:ident $i:ident) => { with_crate!{krate $s $i} };
+    ($m:ident $s:ident $i:ident) => { with_crate!{$m $s $i} };
+}
+
+macro_rules! local {() => {
+    declare_macro!{$crate input use_input_crate}
+    declare_macro!{$crate mixed use_mixed_crate}
+    declare_macro!{$crate call use_call_crate}
+}}
+local!{}
+declare_macro!{krate input use_input_krate}
+declare_macro!{krate mixed use_mixed_krate}
+declare_macro!{krate call use_call_krate}
diff --git a/tests/ui/proc-macro/mixed-site-span.rs b/tests/ui/proc-macro/mixed-site-span.rs
index 2b5d9757043..442b440c121 100644
--- a/tests/ui/proc-macro/mixed-site-span.rs
+++ b/tests/ui/proc-macro/mixed-site-span.rs
@@ -1,24 +1,174 @@
 // Proc macros using `mixed_site` spans exhibit usual properties of `macro_rules` hygiene.
 
+//@ aux-build: token-site-span.rs
 //@ proc-macro: mixed-site-span.rs
 
-#[macro_use]
 extern crate mixed_site_span;
+extern crate token_site_span;
 
-struct ItemUse;
+use mixed_site_span::{proc_macro_rules, with_crate};
+use token_site_span::{
+    invoke_with_crate, invoke_with_ident,
+    use_input_crate, use_mixed_crate, use_call_crate,
+    use_input_krate, use_mixed_krate, use_call_krate,
+};
+
+pub struct ItemUse;
 
 fn main() {
     'label_use: loop {
         let local_use = 1;
         proc_macro_rules!();
-        //~^ ERROR use of undeclared label `'label_use`
+        //~^ ERROR cannot find type `ItemUse` in crate `$crate`
+        //~| ERROR use of undeclared label `'label_use`
         //~| ERROR cannot find value `local_use` in this scope
         ItemDef; // OK
         local_def; //~ ERROR cannot find value `local_def` in this scope
     }
 }
 
-macro_rules! pass_dollar_crate {
-    () => (proc_macro_rules!($crate);) //~ ERROR cannot find type `ItemUse` in crate `$crate`
-}
-pass_dollar_crate!();
+// Successful resolutions of `mixed_site_span::proc_macro_item`
+const _: () = {
+    invoke_with_crate!{mixed proc_macro_item}
+    invoke_with_ident!{mixed proc_macro_item}
+    invoke_with_ident!{krate mixed proc_macro_item}
+    with_crate!{krate mixed proc_macro_item}
+
+    macro_rules! test {() => {
+        invoke_with_ident!{$crate mixed proc_macro_item}
+        with_crate!{$crate mixed proc_macro_item}
+    }}
+    test!();
+};
+
+// Failed resolutions of `proc_macro_item`
+const _: () = {
+    // token_site_span::proc_macro_item
+    invoke_with_crate!{input proc_macro_item}            //~ ERROR unresolved import `$crate`
+    invoke_with_ident!{input proc_macro_item}            //~ ERROR unresolved import `$crate`
+    invoke_with_crate!{call proc_macro_item}             //~ ERROR unresolved import `$crate`
+    invoke_with_ident!{call proc_macro_item}             //~ ERROR unresolved import `$crate`
+    invoke_with_ident!{hello call proc_macro_item}       //~ ERROR unresolved import `$crate`
+
+    // crate::proc_macro_item
+    invoke_with_ident!{krate input proc_macro_item}      //~ ERROR unresolved import `$crate::proc_macro_item`
+    with_crate!{krate input proc_macro_item}             //~ ERROR unresolved import `$crate::proc_macro_item`
+    with_crate!{krate call proc_macro_item}              //~ ERROR unresolved import `$crate`
+
+    macro_rules! test {() => {
+        // crate::proc_macro_item
+        invoke_with_ident!{$crate input proc_macro_item} //~ ERROR unresolved import `$crate`
+        with_crate!{$crate input proc_macro_item}        //~ ERROR unresolved import `$crate`
+        with_crate!{$crate call proc_macro_item}         //~ ERROR unresolved import `$crate`
+
+        // token_site_span::proc_macro_item
+        invoke_with_ident!{$crate call proc_macro_item}  //~ ERROR unresolved import `$crate`
+    }}
+    test!();
+};
+
+// Successful resolutions of `token_site_span::TokenItem`
+const _: () = {
+    invoke_with_crate!{input TokenItem}
+    invoke_with_ident!{input TokenItem}
+    invoke_with_crate!{call TokenItem}
+    invoke_with_ident!{call TokenItem}
+    invoke_with_ident!{hello call TokenItem}
+
+    macro_rules! test {() => {
+        invoke_with_ident!{$crate call TokenItem}
+    }}
+    test!();
+};
+
+// Failed resolutions of `TokenItem`
+const _: () = {
+    // crate::TokenItem
+    invoke_with_ident!{krate input TokenItem}       //~ ERROR unresolved import `$crate::TokenItem`
+    with_crate!{krate input TokenItem}              //~ ERROR unresolved import `$crate::TokenItem`
+    with_crate!{krate call TokenItem}               //~ ERROR unresolved import `$crate`
+
+    // mixed_site_span::TokenItem
+    invoke_with_crate!{mixed TokenItem}             //~ ERROR unresolved import `$crate`
+    invoke_with_ident!{mixed TokenItem}             //~ ERROR unresolved import `$crate`
+    invoke_with_ident!{krate mixed TokenItem}       //~ ERROR unresolved import `$crate`
+    with_crate!{krate mixed TokenItem}              //~ ERROR unresolved import `$crate`
+
+    macro_rules! test {() => {
+        // crate::TokenItem
+        invoke_with_ident!{$crate input TokenItem}  //~ ERROR unresolved import `$crate`
+        with_crate!{$crate input TokenItem}         //~ ERROR unresolved import `$crate`
+        with_crate!{$crate call TokenItem}          //~ ERROR unresolved import `$crate`
+
+        // mixed_site_span::TokenItem
+        invoke_with_ident!{$crate mixed TokenItem}  //~ ERROR unresolved import `$crate`
+        with_crate!{$crate mixed TokenItem}         //~ ERROR unresolved import `$crate`
+
+    }}
+    test!();
+};
+
+
+// Successful resolutions of `crate::ItemUse`
+const _: () = {
+    invoke_with_ident!{krate input ItemUse}
+    with_crate!{krate input ItemUse}
+    with_crate!{krate call ItemUse}
+
+    macro_rules! test {() => {
+        invoke_with_ident!{$crate input ItemUse}
+        with_crate!{$crate input ItemUse}
+        with_crate!{$crate call ItemUse}
+    }}
+    test!();
+};
+
+// Failed resolutions of `ItemUse`
+const _: () = {
+    // token_site_span::ItemUse
+    invoke_with_crate!{input ItemUse}            //~ ERROR unresolved import `$crate`
+    invoke_with_ident!{input ItemUse}            //~ ERROR unresolved import `$crate`
+
+    // mixed_site_span::ItemUse
+    invoke_with_crate!{mixed ItemUse}            //~ ERROR unresolved import `$crate`
+    invoke_with_ident!{mixed ItemUse}            //~ ERROR unresolved import `$crate`
+    invoke_with_ident!{krate mixed ItemUse}      //~ ERROR unresolved import `$crate`
+    with_crate!{krate mixed ItemUse}             //~ ERROR unresolved import `$crate`
+
+    invoke_with_crate!{call ItemUse}             //~ ERROR unresolved import `$crate`
+    invoke_with_ident!{call ItemUse}             //~ ERROR unresolved import `$crate`
+    invoke_with_ident!{hello call ItemUse}       //~ ERROR unresolved import `$crate`
+
+    macro_rules! test {() => {
+        invoke_with_ident!{$crate mixed ItemUse} //~ ERROR unresolved import `$crate`
+        with_crate!{$crate mixed ItemUse}        //~ ERROR unresolved import `$crate`
+
+        invoke_with_ident!{$crate call ItemUse}  //~ ERROR unresolved import `$crate`
+    }}
+    test!();
+};
+
+
+// Only mixed should see mixed_site_span::proc_macro_item
+use_input_crate!{proc_macro_item}   //~ ERROR unresolved import `$crate`
+use_input_krate!{proc_macro_item}   //~ ERROR unresolved import `$crate`
+use_mixed_crate!{proc_macro_item}
+use_mixed_krate!{proc_macro_item}
+use_call_crate!{proc_macro_item}    //~ ERROR unresolved import `$crate`
+use_call_krate!{proc_macro_item}    //~ ERROR unresolved import `$crate`
+
+// Only mixed should fail to see token_site_span::TokenItem
+use_input_crate!{TokenItem}
+use_input_krate!{TokenItem}
+use_mixed_crate!{TokenItem}         //~ ERROR unresolved import `$crate`
+use_mixed_krate!{TokenItem}         //~ ERROR unresolved import `$crate`
+use_call_crate!{TokenItem}
+use_call_krate!{TokenItem}
+
+// Everything should fail to see crate::ItemUse
+use_input_crate!{ItemUse}           //~ ERROR unresolved import `$crate`
+use_input_krate!{ItemUse}           //~ ERROR unresolved import `$crate`
+use_mixed_crate!{ItemUse}           //~ ERROR unresolved import `$crate`
+use_mixed_krate!{ItemUse}           //~ ERROR unresolved import `$crate`
+use_call_crate!{ItemUse}            //~ ERROR unresolved import `$crate`
+use_call_krate!{ItemUse}            //~ ERROR unresolved import `$crate`
diff --git a/tests/ui/proc-macro/mixed-site-span.stderr b/tests/ui/proc-macro/mixed-site-span.stderr
index 13786080124..d62031a853c 100644
--- a/tests/ui/proc-macro/mixed-site-span.stderr
+++ b/tests/ui/proc-macro/mixed-site-span.stderr
@@ -1,13 +1,595 @@
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:47:5
+   |
+LL |     invoke_with_crate!{input proc_macro_item}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `invoke_with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:48:5
+   |
+LL |     invoke_with_ident!{input proc_macro_item}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:49:5
+   |
+LL |     invoke_with_crate!{call proc_macro_item}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:50:5
+   |
+LL |     invoke_with_ident!{call proc_macro_item}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:51:5
+   |
+LL |     invoke_with_ident!{hello call proc_macro_item}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate::proc_macro_item`
+  --> $DIR/mixed-site-span.rs:54:5
+   |
+LL |     invoke_with_ident!{krate input proc_macro_item}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------^
+   |     |                              |
+   |     |                              help: a similar name exists in the module: `proc_macro_rules`
+   |     no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate::proc_macro_item`
+  --> $DIR/mixed-site-span.rs:55:5
+   |
+LL |     with_crate!{krate input proc_macro_item}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^---------------^
+   |     |                       |
+   |     |                       help: a similar name exists in the module: `proc_macro_rules`
+   |     no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:56:5
+   |
+LL |     with_crate!{krate call proc_macro_item}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
+   |     |                      |
+   |     |                      help: a similar name exists in the module: `proc_macro_rules`
+   |     no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:60:28
+   |
+LL |         invoke_with_ident!{$crate input proc_macro_item}
+   |                            ^^^^^^       --------------- help: a similar name exists in the module: `proc_macro_rules`
+   |                            |
+   |                            no `proc_macro_item` in the root
+...
+LL |     test!();
+   |     ------- in this macro invocation
+   |
+   = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:61:21
+   |
+LL |         with_crate!{$crate input proc_macro_item}
+   |                     ^^^^^^       --------------- help: a similar name exists in the module: `proc_macro_rules`
+   |                     |
+   |                     no `proc_macro_item` in the root
+...
+LL |     test!();
+   |     ------- in this macro invocation
+   |
+   = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:62:9
+   |
+LL |         with_crate!{$crate call proc_macro_item}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^---------------^
+   |         |                       |
+   |         |                       help: a similar name exists in the module: `proc_macro_rules`
+   |         no `proc_macro_item` in the root
+...
+LL |     test!();
+   |     ------- in this macro invocation
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:67:5
+   |
+LL |     test!();
+   |     ^^^^^^^ no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate::TokenItem`
+  --> $DIR/mixed-site-span.rs:87:5
+   |
+LL |     invoke_with_ident!{krate input TokenItem}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/mixed-site-span.rs:59:34
+   |
+LL |     quote!(use $krate::$ident as token_site_span::TokenItem as _;)
+   |                                  +++++++++++++++++++++++++++++
+
+error[E0432]: unresolved import `$crate::TokenItem`
+  --> $DIR/mixed-site-span.rs:88:5
+   |
+LL |     with_crate!{krate input TokenItem}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
+   |
+   = note: this error originates in the macro `with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/mixed-site-span.rs:59:34
+   |
+LL |     quote!(use $krate::$ident as token_site_span::TokenItem as _;)
+   |                                  +++++++++++++++++++++++++++++
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:89:5
+   |
+LL |     with_crate!{krate call TokenItem}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
+   |
+   = note: this error originates in the macro `with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+   |
+LL -     with_crate!{krate call TokenItem}
+LL +     token_site_span::TokenItem as _
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:92:5
+   |
+LL |     invoke_with_crate!{mixed TokenItem}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:13:30
+   |
+LL -     ($s:ident $i:ident) => { with_crate!{$crate $s $i} };
+LL +     ($s:ident $i:ident) => { token_site_span::TokenItem as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:93:5
+   |
+LL |     invoke_with_ident!{mixed TokenItem}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:18:30
+   |
+LL -     ($s:ident $i:ident) => { with_crate!{krate $s $i} };
+LL +     ($s:ident $i:ident) => { token_site_span::TokenItem as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:94:5
+   |
+LL |     invoke_with_ident!{krate mixed TokenItem}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:19:39
+   |
+LL -     ($m:ident $s:ident $i:ident) => { with_crate!{$m $s $i} };
+LL +     ($m:ident $s:ident $i:ident) => { token_site_span::TokenItem as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:95:5
+   |
+LL |     with_crate!{krate mixed TokenItem}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
+   |
+   = note: this error originates in the macro `with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+   |
+LL -     with_crate!{krate mixed TokenItem}
+LL +     token_site_span::TokenItem as _
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:99:28
+   |
+LL |         invoke_with_ident!{$crate input TokenItem}
+   |                            ^^^^^^ no `TokenItem` in the root
+...
+LL |     test!();
+   |     ------- in this macro invocation
+   |
+   = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+   |
+LL -         invoke_with_ident!{$crate input TokenItem}
+LL +         invoke_with_ident!{token_site_span::TokenItem as _ input TokenItem}
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:100:21
+   |
+LL |         with_crate!{$crate input TokenItem}
+   |                     ^^^^^^ no `TokenItem` in the root
+...
+LL |     test!();
+   |     ------- in this macro invocation
+   |
+   = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+   |
+LL -         with_crate!{$crate input TokenItem}
+LL +         with_crate!{token_site_span::TokenItem as _ input TokenItem}
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:101:9
+   |
+LL |         with_crate!{$crate call TokenItem}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
+...
+LL |     test!();
+   |     ------- in this macro invocation
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+   |
+LL -         with_crate!{$crate call TokenItem}
+LL +         token_site_span::TokenItem as _
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:108:5
+   |
+LL |     test!();
+   |     ^^^^^^^ no `TokenItem` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:19:39
+   |
+LL -     ($m:ident $s:ident $i:ident) => { with_crate!{$m $s $i} };
+LL +     ($m:ident $s:ident $i:ident) => { token_site_span::TokenItem as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:105:9
+   |
+LL |         with_crate!{$crate mixed TokenItem}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
+...
+LL |     test!();
+   |     ------- in this macro invocation
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+   |
+LL -         with_crate!{$crate mixed TokenItem}
+LL +         token_site_span::TokenItem as _
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:129:5
+   |
+LL |     invoke_with_crate!{input ItemUse}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `invoke_with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:13:42
+   |
+LL -     ($s:ident $i:ident) => { with_crate!{$crate $s $i} };
+LL +     ($s:ident $i:ident) => { with_crate!{ItemUse as _ $s $i} };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:130:5
+   |
+LL |     invoke_with_ident!{input ItemUse}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:18:42
+   |
+LL -     ($s:ident $i:ident) => { with_crate!{krate $s $i} };
+LL +     ($s:ident $i:ident) => { with_crate!{ItemUse as _ $s $i} };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:133:5
+   |
+LL |     invoke_with_crate!{mixed ItemUse}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:13:30
+   |
+LL -     ($s:ident $i:ident) => { with_crate!{$crate $s $i} };
+LL +     ($s:ident $i:ident) => { ItemUse as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:134:5
+   |
+LL |     invoke_with_ident!{mixed ItemUse}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:18:30
+   |
+LL -     ($s:ident $i:ident) => { with_crate!{krate $s $i} };
+LL +     ($s:ident $i:ident) => { ItemUse as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:135:5
+   |
+LL |     invoke_with_ident!{krate mixed ItemUse}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:19:39
+   |
+LL -     ($m:ident $s:ident $i:ident) => { with_crate!{$m $s $i} };
+LL +     ($m:ident $s:ident $i:ident) => { ItemUse as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:136:5
+   |
+LL |     with_crate!{krate mixed ItemUse}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+   |
+LL -     with_crate!{krate mixed ItemUse}
+LL +     ItemUse as _
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:138:5
+   |
+LL |     invoke_with_crate!{call ItemUse}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:13:30
+   |
+LL -     ($s:ident $i:ident) => { with_crate!{$crate $s $i} };
+LL +     ($s:ident $i:ident) => { ItemUse as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:139:5
+   |
+LL |     invoke_with_ident!{call ItemUse}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:18:30
+   |
+LL -     ($s:ident $i:ident) => { with_crate!{krate $s $i} };
+LL +     ($s:ident $i:ident) => { ItemUse as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:140:5
+   |
+LL |     invoke_with_ident!{hello call ItemUse}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `invoke_with_ident` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:19:39
+   |
+LL -     ($m:ident $s:ident $i:ident) => { with_crate!{$m $s $i} };
+LL +     ($m:ident $s:ident $i:ident) => { ItemUse as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:148:5
+   |
+LL |     test!();
+   |     ^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:19:39
+   |
+LL -     ($m:ident $s:ident $i:ident) => { with_crate!{$m $s $i} };
+LL +     ($m:ident $s:ident $i:ident) => { ItemUse as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:144:9
+   |
+LL |         with_crate!{$crate mixed ItemUse}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+...
+LL |     test!();
+   |     ------- in this macro invocation
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+   |
+LL -         with_crate!{$crate mixed ItemUse}
+LL +         ItemUse as _
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:148:5
+   |
+LL |     test!();
+   |     ^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `with_crate` which comes from the expansion of the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:19:39
+   |
+LL -     ($m:ident $s:ident $i:ident) => { with_crate!{$m $s $i} };
+LL +     ($m:ident $s:ident $i:ident) => { ItemUse as _ };
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:153:1
+   |
+LL | use_input_crate!{proc_macro_item}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `use_input_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:154:1
+   |
+LL | use_input_krate!{proc_macro_item}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `use_input_krate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:157:1
+   |
+LL | use_call_crate!{proc_macro_item}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `use_call_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:158:1
+   |
+LL | use_call_krate!{proc_macro_item}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `proc_macro_item` in the root
+   |
+   = note: this error originates in the macro `use_call_krate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:163:1
+   |
+LL | use_mixed_crate!{TokenItem}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
+   |
+   = note: this error originates in the macro `use_mixed_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:24:5
+   |
+LL -     declare_macro!{$crate mixed use_mixed_crate}
+LL +     token_site_span::TokenItem as _
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:164:1
+   |
+LL | use_mixed_krate!{TokenItem}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `TokenItem` in the root
+   |
+   = note: this error originates in the macro `use_mixed_krate` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct instead
+  --> $DIR/auxiliary/token-site-span.rs:29:1
+   |
+LL - declare_macro!{krate mixed use_mixed_krate}
+LL + token_site_span::TokenItem as _
+   |
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:169:1
+   |
+LL | use_input_crate!{ItemUse}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `use_input_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:170:1
+   |
+LL | use_input_krate!{ItemUse}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `use_input_krate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:171:1
+   |
+LL | use_mixed_crate!{ItemUse}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `use_mixed_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:172:1
+   |
+LL | use_mixed_krate!{ItemUse}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `use_mixed_krate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:173:1
+   |
+LL | use_call_crate!{ItemUse}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `use_call_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0432]: unresolved import `$crate`
+  --> $DIR/mixed-site-span.rs:174:1
+   |
+LL | use_call_krate!{ItemUse}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^ no `ItemUse` in the root
+   |
+   = note: this error originates in the macro `use_call_krate` (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error[E0426]: use of undeclared label `'label_use`
-  --> $DIR/mixed-site-span.rs:13:9
+  --> $DIR/mixed-site-span.rs:21:9
    |
 LL |         proc_macro_rules!();
    |         ^^^^^^^^^^^^^^^^^^^ undeclared label `'label_use`
    |
    = note: this error originates in the macro `proc_macro_rules` (in Nightly builds, run with -Z macro-backtrace for more info)
 
+error[E0412]: cannot find type `ItemUse` in crate `$crate`
+  --> $DIR/mixed-site-span.rs:21:9
+   |
+LL |         proc_macro_rules!();
+   |         ^^^^^^^^^^^^^^^^^^^ not found in `$crate`
+   |
+   = note: this error originates in the macro `proc_macro_rules` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing this struct
+   |
+LL + use ItemUse;
+   |
+
 error[E0425]: cannot find value `local_use` in this scope
-  --> $DIR/mixed-site-span.rs:13:9
+  --> $DIR/mixed-site-span.rs:21:9
    |
 LL |         proc_macro_rules!();
    |         ^^^^^^^^^^^^^^^^^^^ help: a local variable with a similar name exists: `local_def`
@@ -15,20 +597,12 @@ LL |         proc_macro_rules!();
    = note: this error originates in the macro `proc_macro_rules` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0425]: cannot find value `local_def` in this scope
-  --> $DIR/mixed-site-span.rs:17:9
+  --> $DIR/mixed-site-span.rs:26:9
    |
 LL |         local_def;
    |         ^^^^^^^^^ help: a local variable with a similar name exists: `local_use`
 
-error[E0412]: cannot find type `ItemUse` in crate `$crate`
-  --> $DIR/mixed-site-span.rs:24:1
-   |
-LL | pass_dollar_crate!();
-   | ^^^^^^^^^^^^^^^^^^^^ not found in `$crate`
-   |
-   = note: this error originates in the macro `proc_macro_rules` which comes from the expansion of the macro `pass_dollar_crate` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: aborting due to 4 previous errors
+error: aborting due to 52 previous errors
 
-Some errors have detailed explanations: E0412, E0425, E0426.
+Some errors have detailed explanations: E0412, E0425, E0426, E0432.
 For more information about an error, try `rustc --explain E0412`.
-- 
cgit 1.4.1-3-g733a5


From 00feedcb312228532460cd8f197b518ec74a8911 Mon Sep 17 00:00:00 2001
From: Tom Vijlbrief <tvijlbrief@gmail.com>
Date: Fri, 13 Jun 2025 10:49:00 +0200
Subject: Add modern AVR mcus like avr128db28 and attiny3224

---
 compiler/rustc_target/src/spec/base/avr.rs | 46 ++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/compiler/rustc_target/src/spec/base/avr.rs b/compiler/rustc_target/src/spec/base/avr.rs
index 85b73e61e52..d2e4453d957 100644
--- a/compiler/rustc_target/src/spec/base/avr.rs
+++ b/compiler/rustc_target/src/spec/base/avr.rs
@@ -322,6 +322,9 @@ pub fn ef_avr_arch(target_cpu: &str) -> u32 {
         "attiny1624" => elf::EF_AVR_ARCH_XMEGA3,
         "attiny1626" => elf::EF_AVR_ARCH_XMEGA3,
         "attiny1627" => elf::EF_AVR_ARCH_XMEGA3,
+        "attiny3224" => elf::EF_AVR_ARCH_XMEGA3,
+        "attiny3226" => elf::EF_AVR_ARCH_XMEGA3,
+        "attiny3227" => elf::EF_AVR_ARCH_XMEGA3,
         "atmega808" => elf::EF_AVR_ARCH_XMEGA3,
         "atmega809" => elf::EF_AVR_ARCH_XMEGA3,
         "atmega1608" => elf::EF_AVR_ARCH_XMEGA3,
@@ -331,6 +334,49 @@ pub fn ef_avr_arch(target_cpu: &str) -> u32 {
         "atmega4808" => elf::EF_AVR_ARCH_XMEGA3,
         "atmega4809" => elf::EF_AVR_ARCH_XMEGA3,
 
+        "avr16dd20" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16dd28" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16dd32" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16du14" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16du20" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16du28" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16du32" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32da28" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32da32" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32da48" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32db28" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32db32" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32db48" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32dd14" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32dd20" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32dd28" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32dd32" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32du14" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32du20" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32du28" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32du32" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16eb14" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16eb20" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16eb28" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16eb32" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16ea28" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16ea32" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr16ea48" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32ea28" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32ea32" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32ea48" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32sd20" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32sd28" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr32sd32" => elf::EF_AVR_ARCH_XMEGA3,
+        "avr128da28" => elf::EF_AVR_ARCH_XMEGA4,
+        "avr128da32" => elf::EF_AVR_ARCH_XMEGA4,
+        "avr128da48" => elf::EF_AVR_ARCH_XMEGA4,
+        "avr128da64" => elf::EF_AVR_ARCH_XMEGA4,
+        "avr128db28" => elf::EF_AVR_ARCH_XMEGA4,
+        "avr128db32" => elf::EF_AVR_ARCH_XMEGA4,
+        "avr128db48" => elf::EF_AVR_ARCH_XMEGA4,
+        "avr128db64" => elf::EF_AVR_ARCH_XMEGA4,
+
         // Unknown target CPU => Unspecified/generic code
         _ => 0,
     }
-- 
cgit 1.4.1-3-g733a5


From 1323fd6f73ffbd427bcb81e9766f68eccf1f531e Mon Sep 17 00:00:00 2001
From: Tom Vijlbrief <tvijlbrief@gmail.com>
Date: Fri, 13 Jun 2025 16:03:57 +0200
Subject: Add missing avr64* series

---
 compiler/rustc_target/src/spec/base/avr.rs | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/compiler/rustc_target/src/spec/base/avr.rs b/compiler/rustc_target/src/spec/base/avr.rs
index d2e4453d957..fb3ebb509ad 100644
--- a/compiler/rustc_target/src/spec/base/avr.rs
+++ b/compiler/rustc_target/src/spec/base/avr.rs
@@ -334,6 +334,27 @@ pub fn ef_avr_arch(target_cpu: &str) -> u32 {
         "atmega4808" => elf::EF_AVR_ARCH_XMEGA3,
         "atmega4809" => elf::EF_AVR_ARCH_XMEGA3,
 
+        "avr64da28" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64da32" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64da48" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64da64" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64db28" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64db32" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64db48" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64db64" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64dd14" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64dd20" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64dd28" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64dd32" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64du28" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64du32" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64ea28" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64ea32" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64ea48" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64sd28" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64sd32" => elf::EF_AVR_ARCH_XMEGA2,
+        "avr64sd48" => elf::EF_AVR_ARCH_XMEGA2,
+
         "avr16dd20" => elf::EF_AVR_ARCH_XMEGA3,
         "avr16dd28" => elf::EF_AVR_ARCH_XMEGA3,
         "avr16dd32" => elf::EF_AVR_ARCH_XMEGA3,
-- 
cgit 1.4.1-3-g733a5


From 295378729b782d7ec45588af136a0d7c7305e8df Mon Sep 17 00:00:00 2001
From: Daniel Paoliello <danpao@microsoft.com>
Date: Mon, 28 Apr 2025 12:07:30 -0700
Subject: DRAFT: Add an aarch64-msvc build running on ARM64 Windows

---
 .github/workflows/ci.yml        |  3 +++
 src/ci/github-actions/jobs.yml  | 21 +++++++++++++++++++--
 src/ci/scripts/install-clang.sh | 16 +++++++++++++---
 src/ci/scripts/install-rust.sh  | 15 +++++++++++++++
 4 files changed, 50 insertions(+), 5 deletions(-)
 create mode 100755 src/ci/scripts/install-rust.sh

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 841bc39bf1e..cb0510115ae 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -163,6 +163,9 @@ jobs:
       - name: show the current environment
         run: src/ci/scripts/dump-environment.sh
 
+      - name: install rust
+        run: src/ci/scripts/install-rust.sh
+
       - name: install awscli
         run: src/ci/scripts/install-awscli.sh
 
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 43c77d1ddf7..0bd05b99bbc 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -46,6 +46,10 @@ runners:
     os: windows-2025-8core-32gb
     <<: *base-job
 
+  - &job-windows-aarch64
+    os: windows-11-arm
+    <<: *base-job
+
   - &job-aarch64-linux
     # Free some disk space to avoid running out of space during the build.
     free_disk: true
@@ -539,6 +543,19 @@ auto:
       SCRIPT: make ci-msvc-ps1
     <<: *job-windows
 
+  # aarch64-msvc is split into two jobs to run tests in parallel.
+  - name: aarch64-msvc-1
+    env:
+      RUST_CONFIGURE_ARGS: --build=aarch64-pc-windows-msvc
+      SCRIPT: make ci-msvc-py
+    <<: *job-windows-aarch64
+
+  - name: aarch64-msvc-2
+    env:
+      RUST_CONFIGURE_ARGS: --build=aarch64-pc-windows-msvc
+      SCRIPT: make ci-msvc-ps1
+    <<: *job-windows-aarch64
+
   # x86_64-msvc-ext is split into multiple jobs to run tests in parallel.
   - name: x86_64-msvc-ext1
     env:
@@ -634,14 +651,14 @@ auto:
   - name: dist-aarch64-msvc
     env:
       RUST_CONFIGURE_ARGS: >-
-        --build=x86_64-pc-windows-msvc
+        --build=aarch64-pc-windows-msvc
         --host=aarch64-pc-windows-msvc
         --target=aarch64-pc-windows-msvc,arm64ec-pc-windows-msvc
         --enable-full-tools
         --enable-profiler
       SCRIPT: python x.py dist bootstrap --include-default-paths
       DIST_REQUIRE_ALL_TOOLS: 1
-    <<: *job-windows
+    <<: *job-windows-aarch64
 
   - name: dist-i686-mingw
     env:
diff --git a/src/ci/scripts/install-clang.sh b/src/ci/scripts/install-clang.sh
index a9528e92915..657e1492a6d 100755
--- a/src/ci/scripts/install-clang.sh
+++ b/src/ci/scripts/install-clang.sh
@@ -56,9 +56,19 @@ elif isWindows && ! isKnownToBeMingwBuild; then
 
     mkdir -p citools/clang-rust
     cd citools
-    retry curl -f "${MIRRORS_BASE}/LLVM-${LLVM_VERSION}-win64.exe" \
-        -o "LLVM-${LLVM_VERSION}-win64.exe"
-    7z x -oclang-rust/ "LLVM-${LLVM_VERSION}-win64.exe"
+
+    if [[ "${CI_JOB_NAME}" = *aarch64* ]]; then
+        suffix=woa64
+
+        # On Arm64, the Ring crate requires that Clang be on the PATH.
+        # https://github.com/briansmith/ring/blob/main/BUILDING.md
+        ciCommandAddPath "$(cygpath -m "$(pwd)/clang-rust/bin")"
+    else
+        suffix=win64
+    fi
+    retry curl -f "${MIRRORS_BASE}/LLVM-${LLVM_VERSION}-${suffix}.exe" \
+        -o "LLVM-${LLVM_VERSION}-${suffix}.exe"
+    7z x -oclang-rust/ "LLVM-${LLVM_VERSION}-${suffix}.exe"
     ciCommandSetEnv RUST_CONFIGURE_ARGS \
         "${RUST_CONFIGURE_ARGS} --set llvm.clang-cl=$(pwd)/clang-rust/bin/clang-cl.exe"
 
diff --git a/src/ci/scripts/install-rust.sh b/src/ci/scripts/install-rust.sh
new file mode 100755
index 00000000000..e4aee98c9fb
--- /dev/null
+++ b/src/ci/scripts/install-rust.sh
@@ -0,0 +1,15 @@
+#!/bin/bash
+
+# The Arm64 Windows Runner does not have Rust already installed
+# https://github.com/actions/partner-runner-images/issues/77
+
+set -euo pipefail
+IFS=$'\n\t'
+
+source "$(cd "$(dirname "$0")" && pwd)/../shared.sh"
+
+if [[ "${CI_JOB_NAME}" = *aarch64* ]] && isWindows; then
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
+    sh -s -- -y -q --default-host aarch64-pc-windows-msvc
+    ciCommandAddPath "${USERPROFILE}/.cargo/bin"
+fi
-- 
cgit 1.4.1-3-g733a5


From 3dc30176918fd9085f29006e19d5e250e9ab67d1 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 14 Jun 2025 12:08:25 +0200
Subject: use `is_multiple_of` to check if an addr is aligned

---
 library/compiler-builtins/compiler-builtins/src/arm.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/library/compiler-builtins/compiler-builtins/src/arm.rs b/library/compiler-builtins/compiler-builtins/src/arm.rs
index a7d84e49b34..617cc8e507b 100644
--- a/library/compiler-builtins/compiler-builtins/src/arm.rs
+++ b/library/compiler-builtins/compiler-builtins/src/arm.rs
@@ -135,8 +135,8 @@ intrinsics! {
     /// eight bytes.
     #[cfg(not(target_vendor = "apple"))]
     pub unsafe extern "aapcs" fn __aeabi_memcpy8(dst: *mut u8, src: *const u8, n: usize) {
-        debug_assert!(dst.addr() & 7 == 0);
-        debug_assert!(src.addr() & 7 == 0);
+        debug_assert!(dst.addr().is_multiple_of(8));
+        debug_assert!(src.addr().is_multiple_of(8));
 
         // SAFETY: memcpy preconditions apply, less strict alignment.
         unsafe { __aeabi_memcpy4(dst, src, n) };
@@ -161,8 +161,8 @@ intrinsics! {
     /// four bytes.
     #[cfg(not(any(target_vendor = "apple", target_env = "msvc")))]
     pub unsafe extern "aapcs" fn __aeabi_memmove4(dst: *mut u8, src: *const u8, n: usize) {
-        debug_assert!(dst.addr() & 3 == 0);
-        debug_assert!(src.addr() & 3 == 0);
+        debug_assert!(dst.addr().is_multiple_of(4));
+        debug_assert!(src.addr().is_multiple_of(4));
 
         // SAFETY: same preconditions, less strict aligment.
         unsafe { __aeabi_memmove(dst, src, n) };
@@ -176,8 +176,8 @@ intrinsics! {
     /// eight bytes.
     #[cfg(not(any(target_vendor = "apple", target_env = "msvc")))]
     pub unsafe extern "aapcs" fn __aeabi_memmove8(dst: *mut u8, src: *const u8, n: usize) {
-        debug_assert!(dst.addr() & 7 == 0);
-        debug_assert!(src.addr() & 7 == 0);
+        debug_assert!(dst.addr().is_multiple_of(8));
+        debug_assert!(src.addr().is_multiple_of(8));
 
         // SAFETY: memmove preconditions apply, less strict alignment.
         unsafe { __aeabi_memmove(dst, src, n) };
@@ -236,7 +236,7 @@ intrinsics! {
     /// eight bytes.
     #[cfg(not(target_vendor = "apple"))]
     pub unsafe extern "aapcs" fn __aeabi_memset8(dst: *mut u8, n: usize, c: i32) {
-        debug_assert!(dst.addr() & 7 == 0);
+        debug_assert!(dst.addr().is_multiple_of(8));
 
         // SAFETY: memset preconditions apply, less strict alignment.
         unsafe { __aeabi_memset4(dst, n, c) };
@@ -261,7 +261,7 @@ intrinsics! {
     /// four bytes.
     #[cfg(not(any(target_vendor = "apple", target_env = "msvc")))]
     pub unsafe extern "aapcs" fn __aeabi_memclr4(dst: *mut u8, n: usize) {
-        debug_assert!(dst.addr() & 3 == 0);
+        debug_assert!(dst.addr().is_multiple_of(4));
 
         // SAFETY: memclr preconditions apply, less strict alignment.
         unsafe { __aeabi_memset4(dst, n, 0) };
@@ -275,7 +275,7 @@ intrinsics! {
     /// eight bytes.
     #[cfg(not(any(target_vendor = "apple", target_env = "msvc")))]
     pub unsafe extern "aapcs" fn __aeabi_memclr8(dst: *mut u8, n: usize) {
-        debug_assert!(dst.addr() & 7 == 0);
+        debug_assert!(dst.addr().is_multiple_of(8));
 
         // SAFETY: memclr preconditions apply, less strict alignment.
         unsafe { __aeabi_memset4(dst, n, 0) };
-- 
cgit 1.4.1-3-g733a5


From a413cca7d39d45837b9c595a135c369779275963 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Sat, 14 Jun 2025 20:17:23 +0200
Subject: use `extern "custom"` on naked functions with a custom calling
 convention

---
 .../compiler-builtins/compiler-builtins/src/aarch64.rs    |  2 +-
 library/compiler-builtins/compiler-builtins/src/arm.rs    | 13 ++++++-------
 .../compiler-builtins/compiler-builtins/src/int/udiv.rs   |  2 +-
 library/compiler-builtins/compiler-builtins/src/lib.rs    |  1 +
 .../compiler-builtins/compiler-builtins/src/probestack.rs | 15 +++------------
 library/compiler-builtins/compiler-builtins/src/x86.rs    | 10 +++++-----
 library/compiler-builtins/compiler-builtins/src/x86_64.rs |  4 ++--
 7 files changed, 19 insertions(+), 28 deletions(-)

diff --git a/library/compiler-builtins/compiler-builtins/src/aarch64.rs b/library/compiler-builtins/compiler-builtins/src/aarch64.rs
index 80392187c89..a72b30d29f0 100644
--- a/library/compiler-builtins/compiler-builtins/src/aarch64.rs
+++ b/library/compiler-builtins/compiler-builtins/src/aarch64.rs
@@ -5,7 +5,7 @@ use core::intrinsics;
 intrinsics! {
     #[unsafe(naked)]
     #[cfg(all(target_os = "uefi", not(feature = "no-asm")))]
-    pub unsafe extern "C" fn __chkstk() {
+    pub unsafe extern "custom" fn __chkstk() {
         core::arch::naked_asm!(
             ".p2align 2",
             "lsl    x16, x15, #4",
diff --git a/library/compiler-builtins/compiler-builtins/src/arm.rs b/library/compiler-builtins/compiler-builtins/src/arm.rs
index 617cc8e507b..fbec93ca431 100644
--- a/library/compiler-builtins/compiler-builtins/src/arm.rs
+++ b/library/compiler-builtins/compiler-builtins/src/arm.rs
@@ -9,11 +9,10 @@ unsafe extern "C" {
 }
 
 // SAFETY: these are defined in compiler-builtins
-// FIXME(extern_custom), this isn't always the correct ABI
-unsafe extern "aapcs" {
+unsafe extern "custom" {
     // AAPCS is not always the correct ABI for these intrinsics, but we only use this to
     // forward another `__aeabi_` call so it doesn't matter.
-    fn __aeabi_idiv(a: i32, b: i32) -> i32;
+    fn __aeabi_idiv();
 }
 
 intrinsics! {
@@ -21,7 +20,7 @@ intrinsics! {
     // custom calling convention which can't be implemented using a normal Rust function.
     #[unsafe(naked)]
     #[cfg(not(target_env = "msvc"))]
-    pub unsafe extern "C" fn __aeabi_uidivmod() {
+    pub unsafe extern "custom" fn __aeabi_uidivmod() {
         core::arch::naked_asm!(
             "push {{lr}}",
             "sub sp, sp, #4",
@@ -35,7 +34,7 @@ intrinsics! {
     }
 
     #[unsafe(naked)]
-    pub unsafe extern "C" fn __aeabi_uldivmod() {
+    pub unsafe extern "custom" fn __aeabi_uldivmod() {
         core::arch::naked_asm!(
             "push {{r4, lr}}",
             "sub sp, sp, #16",
@@ -51,7 +50,7 @@ intrinsics! {
     }
 
     #[unsafe(naked)]
-    pub unsafe extern "C" fn __aeabi_idivmod() {
+    pub unsafe extern "custom" fn __aeabi_idivmod() {
         core::arch::naked_asm!(
             "push {{r0, r1, r4, lr}}",
             "bl {trampoline}",
@@ -64,7 +63,7 @@ intrinsics! {
     }
 
     #[unsafe(naked)]
-    pub unsafe extern "C" fn __aeabi_ldivmod() {
+    pub unsafe extern "custom" fn __aeabi_ldivmod() {
         core::arch::naked_asm!(
             "push {{r4, lr}}",
             "sub sp, sp, #16",
diff --git a/library/compiler-builtins/compiler-builtins/src/int/udiv.rs b/library/compiler-builtins/compiler-builtins/src/int/udiv.rs
index b9dee63c4cc..017a81ac914 100644
--- a/library/compiler-builtins/compiler-builtins/src/int/udiv.rs
+++ b/library/compiler-builtins/compiler-builtins/src/int/udiv.rs
@@ -44,7 +44,7 @@ intrinsics! {
     }
 
     #[unsafe(naked)]
-    pub unsafe extern "C" fn __udivmodqi4() {
+    pub unsafe extern "custom" fn __udivmodqi4() {
         // compute unsigned 8-bit `n / d` and `n % d`.
         //
         // Note: GCC implements a [non-standard calling convention](https://gcc.gnu.org/wiki/avr-gcc#Exceptions_to_the_Calling_Convention) for this function.
diff --git a/library/compiler-builtins/compiler-builtins/src/lib.rs b/library/compiler-builtins/compiler-builtins/src/lib.rs
index 1cec39d8b41..dd9920cae01 100644
--- a/library/compiler-builtins/compiler-builtins/src/lib.rs
+++ b/library/compiler-builtins/compiler-builtins/src/lib.rs
@@ -1,5 +1,6 @@
 #![cfg_attr(feature = "compiler-builtins", compiler_builtins)]
 #![cfg_attr(all(target_family = "wasm"), feature(wasm_numeric_instr))]
+#![feature(abi_custom)]
 #![feature(abi_unadjusted)]
 #![feature(asm_experimental_arch)]
 #![feature(cfg_target_has_atomic)]
diff --git a/library/compiler-builtins/compiler-builtins/src/probestack.rs b/library/compiler-builtins/compiler-builtins/src/probestack.rs
index 1441fd73b8d..1d0010842cb 100644
--- a/library/compiler-builtins/compiler-builtins/src/probestack.rs
+++ b/library/compiler-builtins/compiler-builtins/src/probestack.rs
@@ -52,15 +52,12 @@
 // Our goal here is to touch each page between %rsp+8 and %rsp+8-%rax,
 // ensuring that if any pages are unmapped we'll make a page fault.
 //
-// FIXME(abi_custom): This function is unsafe because it uses a custom ABI,
-// it does not actually match `extern "C"`.
-//
 // The ABI here is that the stack frame size is located in `%rax`. Upon
 // return we're not supposed to modify `%rsp` or `%rax`.
 #[cfg(target_arch = "x86_64")]
 #[unsafe(naked)]
 #[rustc_std_internal_symbol]
-pub unsafe extern "C" fn __rust_probestack() {
+pub unsafe extern "custom" fn __rust_probestack() {
     #[cfg(not(all(target_env = "sgx", target_vendor = "fortanix")))]
     macro_rules! ret {
         () => {
@@ -144,13 +141,10 @@ pub unsafe extern "C" fn __rust_probestack() {
 // that on Unix we're expected to restore everything as it was, this
 // function basically can't tamper with anything.
 //
-// FIXME(abi_custom): This function is unsafe because it uses a custom ABI,
-// it does not actually match `extern "C"`.
-//
 // The ABI here is the same as x86_64, except everything is 32-bits large.
 #[unsafe(naked)]
 #[rustc_std_internal_symbol]
-pub unsafe extern "C" fn __rust_probestack() {
+pub unsafe extern "custom" fn __rust_probestack() {
     core::arch::naked_asm!(
         "
             .cfi_startproc
@@ -192,9 +186,6 @@ pub unsafe extern "C" fn __rust_probestack() {
 // probestack function will also do things like _chkstk in MSVC.
 // So we need to sub %ax %sp in probestack when arch is x86.
 //
-// FIXME(abi_custom): This function is unsafe because it uses a custom ABI,
-// it does not actually match `extern "C"`.
-//
 // REF: Rust commit(74e80468347)
 // rust\src\llvm-project\llvm\lib\Target\X86\X86FrameLowering.cpp: 805
 // Comments in LLVM:
@@ -203,7 +194,7 @@ pub unsafe extern "C" fn __rust_probestack() {
 //   themselves.
 #[unsafe(naked)]
 #[rustc_std_internal_symbol]
-pub unsafe extern "C" fn __rust_probestack() {
+pub unsafe extern "custom" fn __rust_probestack() {
     core::arch::naked_asm!(
         "
             .cfi_startproc
diff --git a/library/compiler-builtins/compiler-builtins/src/x86.rs b/library/compiler-builtins/compiler-builtins/src/x86.rs
index 01152d9c798..16e50922a94 100644
--- a/library/compiler-builtins/compiler-builtins/src/x86.rs
+++ b/library/compiler-builtins/compiler-builtins/src/x86.rs
@@ -2,7 +2,7 @@
 
 use core::intrinsics;
 
-// NOTE These functions are implemented using assembly because they using a custom
+// NOTE These functions are implemented using assembly because they use a custom
 // calling convention which can't be implemented using a normal Rust function
 
 // NOTE These functions are never mangled as they are not tested against compiler-rt
@@ -13,10 +13,10 @@ intrinsics! {
         any(all(windows, target_env = "gnu"), target_os = "uefi"),
         not(feature = "no-asm")
     ))]
-    pub unsafe extern "C" fn __chkstk() {
+    pub unsafe extern "custom" fn __chkstk() {
         core::arch::naked_asm!(
-            "jmp __alloca", // Jump to __alloca since fallthrough may be unreliable"
-            options(att_syntax)
+            "jmp {}", // Jump to __alloca since fallthrough may be unreliable"
+            sym crate::x86::_alloca::_alloca,
         );
     }
 
@@ -25,7 +25,7 @@ intrinsics! {
         any(all(windows, target_env = "gnu"), target_os = "uefi"),
         not(feature = "no-asm")
     ))]
-    pub unsafe extern "C" fn _alloca() {
+    pub unsafe extern "custom" fn _alloca() {
         // __chkstk and _alloca are the same function
         core::arch::naked_asm!(
             "push   %ecx",
diff --git a/library/compiler-builtins/compiler-builtins/src/x86_64.rs b/library/compiler-builtins/compiler-builtins/src/x86_64.rs
index fc1190f79b2..9b7133b482e 100644
--- a/library/compiler-builtins/compiler-builtins/src/x86_64.rs
+++ b/library/compiler-builtins/compiler-builtins/src/x86_64.rs
@@ -2,7 +2,7 @@
 
 use core::intrinsics;
 
-// NOTE These functions are implemented using assembly because they using a custom
+// NOTE These functions are implemented using assembly because they use a custom
 // calling convention which can't be implemented using a normal Rust function
 
 // NOTE These functions are never mangled as they are not tested against compiler-rt
@@ -17,7 +17,7 @@ intrinsics! {
         ),
         not(feature = "no-asm")
     ))]
-    pub unsafe extern "C" fn ___chkstk_ms() {
+    pub unsafe extern "custom" fn ___chkstk_ms() {
         core::arch::naked_asm!(
             "push   %rcx",
             "push   %rax",
-- 
cgit 1.4.1-3-g733a5


From a2b234554d7c175ec578c6003f7a966b05258752 Mon Sep 17 00:00:00 2001
From: Benjamin Saunders <ben.e.saunders@gmail.com>
Date: Sat, 14 Jun 2025 12:26:45 -0700
Subject: Fix coerce_container_to_any false positive on autoderef

---
 clippy_lints/src/coerce_container_to_any.rs | 27 +++++++++++++++------------
 tests/ui/coerce_container_to_any.fixed      |  4 ++++
 tests/ui/coerce_container_to_any.rs         |  4 ++++
 3 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/clippy_lints/src/coerce_container_to_any.rs b/clippy_lints/src/coerce_container_to_any.rs
index 8c12a42ba4e..46759021995 100644
--- a/clippy_lints/src/coerce_container_to_any.rs
+++ b/clippy_lints/src/coerce_container_to_any.rs
@@ -4,6 +4,7 @@ use clippy_utils::sym;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::adjustment::{Adjust, PointerCoercion};
 use rustc_middle::ty::{self, ExistentialPredicate, Ty, TyCtxt};
 use rustc_session::declare_lint_pass;
 
@@ -49,23 +50,18 @@ declare_lint_pass!(CoerceContainerToAny => [COERCE_CONTAINER_TO_ANY]);
 
 impl<'tcx> LateLintPass<'tcx> for CoerceContainerToAny {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        // If this expression has an effective type of `&dyn Any` ...
-        {
-            let coerced_ty = cx.typeck_results().expr_ty_adjusted(e);
-
-            let ty::Ref(_, coerced_ref_ty, _) = *coerced_ty.kind() else {
-                return;
-            };
-            if !is_dyn_any(cx.tcx, coerced_ref_ty) {
-                return;
-            }
+        // If this expression was coerced to `&dyn Any` ...
+        if !cx.typeck_results().expr_adjustments(e).last().is_some_and(|adj| {
+            matches!(adj.kind, Adjust::Pointer(PointerCoercion::Unsize)) && is_ref_dyn_any(cx.tcx, adj.target)
+        }) {
+            return;
         }
 
         let expr_ty = cx.typeck_results().expr_ty(e);
         let ty::Ref(_, expr_ref_ty, _) = *expr_ty.kind() else {
             return;
         };
-        // ... but only due to coercion ...
+        // ... but it's not actually `&dyn Any` ...
         if is_dyn_any(cx.tcx, expr_ref_ty) {
             return;
         }
@@ -89,12 +85,19 @@ impl<'tcx> LateLintPass<'tcx> for CoerceContainerToAny {
             e.span,
             format!("coercing `{expr_ty}` to `&dyn Any`"),
             "consider dereferencing",
-            format!("&{}{}", str::repeat("*", deref_count), snippet(cx, span, "x")),
+            format!("&{}{}", str::repeat("*", deref_count), snippet(cx, span, "..")),
             Applicability::MaybeIncorrect,
         );
     }
 }
 
+fn is_ref_dyn_any(tcx: TyCtxt<'_>, ty: Ty<'_>) -> bool {
+    let ty::Ref(_, ref_ty, _) = *ty.kind() else {
+        return false;
+    };
+    is_dyn_any(tcx, ref_ty)
+}
+
 fn is_dyn_any(tcx: TyCtxt<'_>, ty: Ty<'_>) -> bool {
     let ty::Dynamic(traits, ..) = ty.kind() else {
         return false;
diff --git a/tests/ui/coerce_container_to_any.fixed b/tests/ui/coerce_container_to_any.fixed
index ae9d3ef9656..eb8487bac17 100644
--- a/tests/ui/coerce_container_to_any.fixed
+++ b/tests/ui/coerce_container_to_any.fixed
@@ -21,6 +21,10 @@ fn main() {
     f(&**ref_x);
     f(&*x);
     let _: &dyn Any = &*x;
+
+    // https://github.com/rust-lang/rust-clippy/issues/15045
+    #[allow(clippy::needless_borrow)]
+    (&x).downcast_ref::<()>().unwrap();
 }
 
 fn f(_: &dyn Any) {}
diff --git a/tests/ui/coerce_container_to_any.rs b/tests/ui/coerce_container_to_any.rs
index 9948bd48e0d..7edb65fa0f7 100644
--- a/tests/ui/coerce_container_to_any.rs
+++ b/tests/ui/coerce_container_to_any.rs
@@ -21,6 +21,10 @@ fn main() {
     f(&**ref_x);
     f(&*x);
     let _: &dyn Any = &*x;
+
+    // https://github.com/rust-lang/rust-clippy/issues/15045
+    #[allow(clippy::needless_borrow)]
+    (&x).downcast_ref::<()>().unwrap();
 }
 
 fn f(_: &dyn Any) {}
-- 
cgit 1.4.1-3-g733a5


From 8e285d6f1ae89a0edc4e93509b846661c012ca33 Mon Sep 17 00:00:00 2001
From: Benjamin Saunders <ben.e.saunders@gmail.com>
Date: Sat, 14 Jun 2025 13:53:21 -0700
Subject: Use precedence-aware formatting for coerce_container_to_any
 suggestions

---
 clippy_lints/src/coerce_container_to_any.rs | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/coerce_container_to_any.rs b/clippy_lints/src/coerce_container_to_any.rs
index 46759021995..fd3399decc1 100644
--- a/clippy_lints/src/coerce_container_to_any.rs
+++ b/clippy_lints/src/coerce_container_to_any.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
+use clippy_utils::sugg::{self, Sugg};
 use clippy_utils::sym;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -74,18 +74,22 @@ impl<'tcx> LateLintPass<'tcx> for CoerceContainerToAny {
         }
 
         // ... that's probably not intended.
-        let (span, deref_count) = match e.kind {
+        let (target_expr, deref_count) = match e.kind {
             // If `e` was already an `&` expression, skip `*&` in the suggestion
-            ExprKind::AddrOf(_, _, referent) => (referent.span, depth),
-            _ => (e.span, depth + 1),
+            ExprKind::AddrOf(_, _, referent) => (referent, depth),
+            _ => (e, depth + 1),
         };
+        let sugg = sugg::make_unop(
+            &format!("&{}", str::repeat("*", deref_count)),
+            Sugg::hir(cx, target_expr, ".."),
+        );
         span_lint_and_sugg(
             cx,
             COERCE_CONTAINER_TO_ANY,
             e.span,
             format!("coercing `{expr_ty}` to `&dyn Any`"),
             "consider dereferencing",
-            format!("&{}{}", str::repeat("*", deref_count), snippet(cx, span, "..")),
+            sugg.to_string(),
             Applicability::MaybeIncorrect,
         );
     }
-- 
cgit 1.4.1-3-g733a5


From dc1b9ce754202493d05a8d7e1627f1d6bc272528 Mon Sep 17 00:00:00 2001
From: Benjamin Saunders <ben.e.saunders@gmail.com>
Date: Sat, 14 Jun 2025 14:02:53 -0700
Subject: Fix reference mutability in coerce_container_to_any diagnostics

---
 clippy_lints/src/coerce_container_to_any.rs |  7 +++++--
 tests/ui/coerce_container_to_any.fixed      |  9 ++++++++-
 tests/ui/coerce_container_to_any.rs         |  9 ++++++++-
 tests/ui/coerce_container_to_any.stderr     | 14 +++++++++++++-
 4 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/coerce_container_to_any.rs b/clippy_lints/src/coerce_container_to_any.rs
index fd3399decc1..3311a35ef79 100644
--- a/clippy_lints/src/coerce_container_to_any.rs
+++ b/clippy_lints/src/coerce_container_to_any.rs
@@ -79,15 +79,18 @@ impl<'tcx> LateLintPass<'tcx> for CoerceContainerToAny {
             ExprKind::AddrOf(_, _, referent) => (referent, depth),
             _ => (e, depth + 1),
         };
+        let ty::Ref(_, _, mutability) = *cx.typeck_results().expr_ty_adjusted(e).kind() else {
+            return;
+        };
         let sugg = sugg::make_unop(
-            &format!("&{}", str::repeat("*", deref_count)),
+            &format!("{}{}", mutability.ref_prefix_str(), str::repeat("*", deref_count)),
             Sugg::hir(cx, target_expr, ".."),
         );
         span_lint_and_sugg(
             cx,
             COERCE_CONTAINER_TO_ANY,
             e.span,
-            format!("coercing `{expr_ty}` to `&dyn Any`"),
+            format!("coercing `{expr_ty}` to `{}dyn Any`", mutability.ref_prefix_str()),
             "consider dereferencing",
             sugg.to_string(),
             Applicability::MaybeIncorrect,
diff --git a/tests/ui/coerce_container_to_any.fixed b/tests/ui/coerce_container_to_any.fixed
index eb8487bac17..b5b3f15b4de 100644
--- a/tests/ui/coerce_container_to_any.fixed
+++ b/tests/ui/coerce_container_to_any.fixed
@@ -3,7 +3,7 @@
 use std::any::Any;
 
 fn main() {
-    let x: Box<dyn Any> = Box::new(());
+    let mut x: Box<dyn Any> = Box::new(());
     let ref_x = &x;
 
     f(&*x);
@@ -15,9 +15,16 @@ fn main() {
     let _: &dyn Any = &*x;
     //~^ coerce_container_to_any
 
+    let _: &dyn Any = &*x;
+    //~^ coerce_container_to_any
+
+    let _: &mut dyn Any = &mut *x;
+    //~^ coerce_container_to_any
+
     f(&42);
     f(&Box::new(()));
     f(&Box::new(Box::new(())));
+    let ref_x = &x;
     f(&**ref_x);
     f(&*x);
     let _: &dyn Any = &*x;
diff --git a/tests/ui/coerce_container_to_any.rs b/tests/ui/coerce_container_to_any.rs
index 7edb65fa0f7..4d6527bb552 100644
--- a/tests/ui/coerce_container_to_any.rs
+++ b/tests/ui/coerce_container_to_any.rs
@@ -3,7 +3,7 @@
 use std::any::Any;
 
 fn main() {
-    let x: Box<dyn Any> = Box::new(());
+    let mut x: Box<dyn Any> = Box::new(());
     let ref_x = &x;
 
     f(&x);
@@ -15,9 +15,16 @@ fn main() {
     let _: &dyn Any = &x;
     //~^ coerce_container_to_any
 
+    let _: &dyn Any = &mut x;
+    //~^ coerce_container_to_any
+
+    let _: &mut dyn Any = &mut x;
+    //~^ coerce_container_to_any
+
     f(&42);
     f(&Box::new(()));
     f(&Box::new(Box::new(())));
+    let ref_x = &x;
     f(&**ref_x);
     f(&*x);
     let _: &dyn Any = &*x;
diff --git a/tests/ui/coerce_container_to_any.stderr b/tests/ui/coerce_container_to_any.stderr
index 00ab77e0ce0..26389c9186e 100644
--- a/tests/ui/coerce_container_to_any.stderr
+++ b/tests/ui/coerce_container_to_any.stderr
@@ -19,5 +19,17 @@ error: coercing `&std::boxed::Box<dyn std::any::Any>` to `&dyn Any`
 LL |     let _: &dyn Any = &x;
    |                       ^^ help: consider dereferencing: `&*x`
 
-error: aborting due to 3 previous errors
+error: coercing `&mut std::boxed::Box<dyn std::any::Any>` to `&dyn Any`
+  --> tests/ui/coerce_container_to_any.rs:18:23
+   |
+LL |     let _: &dyn Any = &mut x;
+   |                       ^^^^^^ help: consider dereferencing: `&*x`
+
+error: coercing `&mut std::boxed::Box<dyn std::any::Any>` to `&mut dyn Any`
+  --> tests/ui/coerce_container_to_any.rs:21:27
+   |
+LL |     let _: &mut dyn Any = &mut x;
+   |                           ^^^^^^ help: consider dereferencing: `&mut *x`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bcc96da3c3ee8350bbb212d3ed6c27c68fc2ba05 Mon Sep 17 00:00:00 2001
From: Urgau <3616612+Urgau@users.noreply.github.com>
Date: Sun, 15 Jun 2025 00:43:17 +0200
Subject: Add minimal triagebot config

This PR adds a minimal `triagebot.toml` config to make contributions to
this repository respect upstream rust-lang/rust conventions and avoid
issues when syncing this subtree.
---
 library/compiler-builtins/triagebot.toml | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 library/compiler-builtins/triagebot.toml

diff --git a/library/compiler-builtins/triagebot.toml b/library/compiler-builtins/triagebot.toml
new file mode 100644
index 00000000000..ecc05da0195
--- /dev/null
+++ b/library/compiler-builtins/triagebot.toml
@@ -0,0 +1,21 @@
+## See <https://forge.rust-lang.org/triagebot/index.html> for documentation
+## of these features.
+
+# Warns when a PR contains merge commits
+# Documentation at: https://forge.rust-lang.org/triagebot/no-merge.html
+[no-merges]
+exclude_titles = ["Update from"]
+
+# Canonicalize issue numbers to avoid closing the wrong issue
+# when commits are included in subtrees, as well as warning links in commits.
+# Documentation at: https://forge.rust-lang.org/triagebot/issue-links.html
+[issue-links]
+check-commits = false
+
+# Prevents mentions in commits to avoid users being spammed
+# Documentation at: https://forge.rust-lang.org/triagebot/no-mentions.html
+[no-mentions]
+
+# Enable issue transfers within the org
+# Documentation at: https://forge.rust-lang.org/triagebot/transfer.html
+[transfer]
-- 
cgit 1.4.1-3-g733a5


From b9382e9ef1649222561b9031b07782fa07284467 Mon Sep 17 00:00:00 2001
From: sayantn <sayantn05@gmail.com>
Date: Thu, 5 Jun 2025 20:41:41 +0530
Subject: Implement `simd_round_ties_even` for miri, cg_clif and cg_gcc

---
 src/intrinsic/simd.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/intrinsic/simd.rs b/src/intrinsic/simd.rs
index 82ef0d0b13a..18ba1ca3d77 100644
--- a/src/intrinsic/simd.rs
+++ b/src/intrinsic/simd.rs
@@ -779,6 +779,7 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
             sym::simd_fsin => "sin",
             sym::simd_fsqrt => "sqrt",
             sym::simd_round => "round",
+            sym::simd_round_ties_even => "rint",
             sym::simd_trunc => "trunc",
             _ => return_error!(InvalidMonomorphization::UnrecognizedIntrinsic { span, name }),
         };
@@ -826,6 +827,7 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
             | sym::simd_fsin
             | sym::simd_fsqrt
             | sym::simd_round
+            | sym::simd_round_ties_even
             | sym::simd_trunc
     ) {
         return simd_simple_float_intrinsic(name, in_elem, in_ty, in_len, bx, span, args);
-- 
cgit 1.4.1-3-g733a5


From 9f4670fd2b3c204567f57e5580a3cd41e9ea4b58 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sat, 14 Jun 2025 23:39:24 +0000
Subject: symcheck: Add a wrapper around an archive

Rather than re-opening the archive file for each check, add a wrapper
that keeps the data in memory. Additionally, collect the `--target`
argument so it can be used within this crate.
---
 .../crates/symbol-check/src/main.rs                | 104 ++++++++++++++++-----
 1 file changed, 80 insertions(+), 24 deletions(-)

diff --git a/library/compiler-builtins/crates/symbol-check/src/main.rs b/library/compiler-builtins/crates/symbol-check/src/main.rs
index d83cd318d6a..843a943fb5f 100644
--- a/library/compiler-builtins/crates/symbol-check/src/main.rs
+++ b/library/compiler-builtins/crates/symbol-check/src/main.rs
@@ -8,7 +8,9 @@ use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
 use object::read::archive::{ArchiveFile, ArchiveMember};
-use object::{Object, ObjectSymbol, Symbol, SymbolKind, SymbolScope, SymbolSection};
+use object::{
+    File as ObjFile, Object, ObjectSymbol, Symbol, SymbolKind, SymbolScope, SymbolSection,
+};
 use serde_json::Value;
 
 const CHECK_LIBRARIES: &[&str] = &["compiler_builtins", "builtins_test_intrinsics"];
@@ -28,13 +30,11 @@ fn main() {
     let args_ref = args.iter().map(String::as_str).collect::<Vec<_>>();
 
     match &args_ref[1..] {
-        ["build-and-check", rest @ ..] if !rest.is_empty() => {
-            let paths = exec_cargo_with_args(rest);
-            for path in paths {
-                println!("Checking {}", path.display());
-                verify_no_duplicates(&path);
-                verify_core_symbols(&path);
-            }
+        ["build-and-check", "--target", target, args @ ..] if !args.is_empty() => {
+            run_build_and_check(Some(target), args);
+        }
+        ["build-and-check", args @ ..] if !args.is_empty() => {
+            run_build_and_check(None, args);
         }
         _ => {
             println!("{USAGE}");
@@ -43,12 +43,42 @@ fn main() {
     }
 }
 
+fn run_build_and_check(target: Option<&str>, args: &[&str]) {
+    let paths = exec_cargo_with_args(target, args);
+    for path in paths {
+        println!("Checking {}", path.display());
+        let archive = Archive::from_path(&path);
+
+        verify_no_duplicates(&archive);
+        verify_core_symbols(&archive);
+    }
+}
+
+fn host_target() -> String {
+    let out = Command::new("rustc")
+        .arg("--version")
+        .arg("--verbose")
+        .output()
+        .unwrap();
+    assert!(out.status.success());
+    let out = String::from_utf8(out.stdout).unwrap();
+    out.lines()
+        .find_map(|s| s.strip_prefix("host: "))
+        .unwrap()
+        .to_owned()
+}
+
 /// Run `cargo build` with the provided additional arguments, collecting the list of created
 /// libraries.
-fn exec_cargo_with_args(args: &[&str]) -> Vec<PathBuf> {
+fn exec_cargo_with_args(target: Option<&str>, args: &[&str]) -> Vec<PathBuf> {
+    let mut host = String::new();
+    let target = target.unwrap_or_else(|| {
+        host = host_target();
+        host.as_str()
+    });
+
     let mut cmd = Command::new("cargo");
-    cmd.arg("build")
-        .arg("--message-format=json")
+    cmd.args(["build", "--target", target, "--message-format=json"])
         .args(args)
         .stdout(Stdio::piped());
 
@@ -133,12 +163,12 @@ impl SymInfo {
 /// Note that this will also locate cases where a symbol is weakly defined in more than one place.
 /// Technically there are no linker errors that will come from this, but it keeps our binary more
 /// straightforward and saves some distribution size.
-fn verify_no_duplicates(path: &Path) {
+fn verify_no_duplicates(archive: &Archive) {
     let mut syms = BTreeMap::<String, SymInfo>::new();
     let mut dups = Vec::new();
     let mut found_any = false;
 
-    for_each_symbol(path, |symbol, member| {
+    archive.for_each_symbol(|symbol, member| {
         // Only check defined globals
         if !symbol.is_global() || symbol.is_undefined() {
             return;
@@ -185,12 +215,12 @@ fn verify_no_duplicates(path: &Path) {
 }
 
 /// Ensure that there are no references to symbols from `core` that aren't also (somehow) defined.
-fn verify_core_symbols(path: &Path) {
+fn verify_core_symbols(archive: &Archive) {
     let mut defined = BTreeSet::new();
     let mut undefined = Vec::new();
     let mut has_symbols = false;
 
-    for_each_symbol(path, |symbol, member| {
+    archive.for_each_symbol(|symbol, member| {
         has_symbols = true;
 
         // Find only symbols from `core`
@@ -219,14 +249,40 @@ fn verify_core_symbols(path: &Path) {
     println!("    success: no undefined references to core found");
 }
 
-/// For a given archive path, do something with each symbol.
-fn for_each_symbol(path: &Path, mut f: impl FnMut(Symbol, &ArchiveMember)) {
-    let data = fs::read(path).expect("reading file failed");
-    let archive = ArchiveFile::parse(data.as_slice()).expect("archive parse failed");
-    for member in archive.members() {
-        let member = member.expect("failed to access member");
-        let obj_data = member.data(&*data).expect("failed to access object");
-        let obj = object::File::parse(obj_data).expect("failed to parse object");
-        obj.symbols().for_each(|sym| f(sym, &member));
+/// Thin wrapper for owning data used by `object`.
+struct Archive {
+    data: Vec<u8>,
+}
+
+impl Archive {
+    fn from_path(path: &Path) -> Self {
+        Self {
+            data: fs::read(path).expect("reading file failed"),
+        }
+    }
+
+    fn file(&self) -> ArchiveFile<'_> {
+        ArchiveFile::parse(self.data.as_slice()).expect("archive parse failed")
+    }
+
+    /// For a given archive, do something with each object file.
+    fn for_each_object(&self, mut f: impl FnMut(ObjFile, &ArchiveMember)) {
+        let archive = self.file();
+
+        for member in archive.members() {
+            let member = member.expect("failed to access member");
+            let obj_data = member
+                .data(self.data.as_slice())
+                .expect("failed to access object");
+            let obj = ObjFile::parse(obj_data).expect("failed to parse object");
+            f(obj, &member);
+        }
+    }
+
+    /// For a given archive, do something with each symbol.
+    fn for_each_symbol(&self, mut f: impl FnMut(Symbol, &ArchiveMember)) {
+        self.for_each_object(|obj, member| {
+            obj.symbols().for_each(|sym| f(sym, member));
+        });
     }
 }
-- 
cgit 1.4.1-3-g733a5


From f46cf875f44aa2416801ec743f6bad760a9672fa Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Tue, 17 Jun 2025 21:50:37 +0800
Subject: fix: `op_ref` wrongly showed macro definition in suggestions

---
 clippy_lints/src/operators/op_ref.rs | 30 +++++++++++++++---------------
 tests/ui/op_ref.fixed                | 34 ++++++++++++++++++++++++++++++++++
 tests/ui/op_ref.rs                   | 34 ++++++++++++++++++++++++++++++++++
 tests/ui/op_ref.stderr               | 22 +++++++++++++++++++++-
 4 files changed, 104 insertions(+), 16 deletions(-)

diff --git a/clippy_lints/src/operators/op_ref.rs b/clippy_lints/src/operators/op_ref.rs
index 0faa7b9e646..21e1ab0f4f2 100644
--- a/clippy_lints/src/operators/op_ref.rs
+++ b/clippy_lints/src/operators/op_ref.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_enclosing_block;
-use clippy_utils::source::snippet;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{implements_trait, is_copy};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -61,12 +61,13 @@ pub(crate) fn check<'tcx>(
                         e.span,
                         "needlessly taken reference of both operands",
                         |diag| {
-                            let lsnip = snippet(cx, l.span, "...").to_string();
-                            let rsnip = snippet(cx, r.span, "...").to_string();
+                            let mut applicability = Applicability::MachineApplicable;
+                            let (lsnip, _) = snippet_with_context(cx, l.span, e.span.ctxt(), "...", &mut applicability);
+                            let (rsnip, _) = snippet_with_context(cx, r.span, e.span.ctxt(), "...", &mut applicability);
                             diag.multipart_suggestion(
                                 "use the values directly",
-                                vec![(left.span, lsnip), (right.span, rsnip)],
-                                Applicability::MachineApplicable,
+                                vec![(left.span, lsnip.to_string()), (right.span, rsnip.to_string())],
+                                applicability,
                             );
                         },
                     );
@@ -80,13 +81,9 @@ pub(crate) fn check<'tcx>(
                         e.span,
                         "needlessly taken reference of left operand",
                         |diag| {
-                            let lsnip = snippet(cx, l.span, "...").to_string();
-                            diag.span_suggestion(
-                                left.span,
-                                "use the left value directly",
-                                lsnip,
-                                Applicability::MachineApplicable,
-                            );
+                            let mut applicability = Applicability::MachineApplicable;
+                            let (lsnip, _) = snippet_with_context(cx, l.span, e.span.ctxt(), "...", &mut applicability);
+                            diag.span_suggestion(left.span, "use the left value directly", lsnip, applicability);
                         },
                     );
                 } else if !lcpy
@@ -99,7 +96,8 @@ pub(crate) fn check<'tcx>(
                         e.span,
                         "needlessly taken reference of right operand",
                         |diag| {
-                            let rsnip = snippet(cx, r.span, "...").to_string();
+                            let mut applicability = Applicability::MachineApplicable;
+                            let (rsnip, _) = snippet_with_context(cx, r.span, e.span.ctxt(), "...", &mut applicability);
                             diag.span_suggestion(
                                 right.span,
                                 "use the right value directly",
@@ -131,7 +129,8 @@ pub(crate) fn check<'tcx>(
                         e.span,
                         "needlessly taken reference of left operand",
                         |diag| {
-                            let lsnip = snippet(cx, l.span, "...").to_string();
+                            let mut applicability = Applicability::MachineApplicable;
+                            let (lsnip, _) = snippet_with_context(cx, l.span, e.span.ctxt(), "...", &mut applicability);
                             diag.span_suggestion(
                                 left.span,
                                 "use the left value directly",
@@ -158,7 +157,8 @@ pub(crate) fn check<'tcx>(
                     && implements_trait(cx, cx.typeck_results().expr_ty(left), trait_id, &[rty.into()])
                 {
                     span_lint_and_then(cx, OP_REF, e.span, "taken reference of right operand", |diag| {
-                        let rsnip = snippet(cx, r.span, "...").to_string();
+                        let mut applicability = Applicability::MachineApplicable;
+                        let (rsnip, _) = snippet_with_context(cx, r.span, e.span.ctxt(), "...", &mut applicability);
                         diag.span_suggestion(
                             right.span,
                             "use the right value directly",
diff --git a/tests/ui/op_ref.fixed b/tests/ui/op_ref.fixed
index f412190b9fd..4bf4b91888c 100644
--- a/tests/ui/op_ref.fixed
+++ b/tests/ui/op_ref.fixed
@@ -110,3 +110,37 @@ mod issue_2597 {
         &array[idx] < val
     }
 }
+
+#[allow(clippy::needless_if)]
+fn issue15063() {
+    use std::ops::BitAnd;
+
+    macro_rules! mac {
+        ($e:expr) => {
+            $e.clone()
+        };
+    }
+
+    let x = 1;
+    if x == mac!(1) {}
+    //~^ op_ref
+
+    #[derive(Copy, Clone)]
+    struct Y(i32);
+    impl BitAnd for Y {
+        type Output = Y;
+        fn bitand(self, rhs: Y) -> Y {
+            Y(self.0 & rhs.0)
+        }
+    }
+    impl<'a> BitAnd<&'a Y> for Y {
+        type Output = Y;
+        fn bitand(self, rhs: &'a Y) -> Y {
+            Y(self.0 & rhs.0)
+        }
+    }
+    let x = Y(1);
+    let y = Y(2);
+    let z = x & mac!(y);
+    //~^ op_ref
+}
diff --git a/tests/ui/op_ref.rs b/tests/ui/op_ref.rs
index a4bbd86c7e9..9a192661aaf 100644
--- a/tests/ui/op_ref.rs
+++ b/tests/ui/op_ref.rs
@@ -110,3 +110,37 @@ mod issue_2597 {
         &array[idx] < val
     }
 }
+
+#[allow(clippy::needless_if)]
+fn issue15063() {
+    use std::ops::BitAnd;
+
+    macro_rules! mac {
+        ($e:expr) => {
+            $e.clone()
+        };
+    }
+
+    let x = 1;
+    if &x == &mac!(1) {}
+    //~^ op_ref
+
+    #[derive(Copy, Clone)]
+    struct Y(i32);
+    impl BitAnd for Y {
+        type Output = Y;
+        fn bitand(self, rhs: Y) -> Y {
+            Y(self.0 & rhs.0)
+        }
+    }
+    impl<'a> BitAnd<&'a Y> for Y {
+        type Output = Y;
+        fn bitand(self, rhs: &'a Y) -> Y {
+            Y(self.0 & rhs.0)
+        }
+    }
+    let x = Y(1);
+    let y = Y(2);
+    let z = x & &mac!(y);
+    //~^ op_ref
+}
diff --git a/tests/ui/op_ref.stderr b/tests/ui/op_ref.stderr
index 51c2963a9ee..8a58b154c81 100644
--- a/tests/ui/op_ref.stderr
+++ b/tests/ui/op_ref.stderr
@@ -36,5 +36,25 @@ LL |         let _ = two + &three;
    |                       |
    |                       help: use the right value directly: `three`
 
-error: aborting due to 4 previous errors
+error: needlessly taken reference of both operands
+  --> tests/ui/op_ref.rs:125:8
+   |
+LL |     if &x == &mac!(1) {}
+   |        ^^^^^^^^^^^^^^
+   |
+help: use the values directly
+   |
+LL -     if &x == &mac!(1) {}
+LL +     if x == mac!(1) {}
+   |
+
+error: taken reference of right operand
+  --> tests/ui/op_ref.rs:144:13
+   |
+LL |     let z = x & &mac!(y);
+   |             ^^^^--------
+   |                 |
+   |                 help: use the right value directly: `mac!(y)`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f29aa6934b289204b9ec14b7b919f84a89cd3417 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Tue, 17 Jun 2025 22:07:18 +0800
Subject: fix: `needless_bool_assign` missing curlies when on else if

---
 clippy_lints/src/needless_bool.rs    |  7 ++++++-
 tests/ui/needless_bool_assign.fixed  |  9 +++++++++
 tests/ui/needless_bool_assign.rs     | 13 +++++++++++++
 tests/ui/needless_bool_assign.stderr | 13 ++++++++++++-
 4 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 3ed4b1c2ea9..b3aa1a7286a 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -199,11 +199,16 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
                 let mut applicability = Applicability::MachineApplicable;
                 let cond = Sugg::hir_with_applicability(cx, cond, "..", &mut applicability);
                 let lhs = snippet_with_applicability(cx, lhs_a.span, "..", &mut applicability);
-                let sugg = if a == b {
+                let mut sugg = if a == b {
                     format!("{cond}; {lhs} = {a:?};")
                 } else {
                     format!("{lhs} = {};", if a { cond } else { !cond })
                 };
+
+                if is_else_clause(cx.tcx, e) {
+                    sugg = format!("{{ {sugg} }}");
+                }
+
                 span_lint_and_sugg(
                     cx,
                     NEEDLESS_BOOL_ASSIGN,
diff --git a/tests/ui/needless_bool_assign.fixed b/tests/ui/needless_bool_assign.fixed
index e0c717ecda2..d6fab4c51b5 100644
--- a/tests/ui/needless_bool_assign.fixed
+++ b/tests/ui/needless_bool_assign.fixed
@@ -33,3 +33,12 @@ fn main() {
         b = true;
     }
 }
+
+fn issue15063(x: bool, y: bool) {
+    let mut z = false;
+
+    if x && y {
+        todo!()
+    } else { z = x || y; }
+    //~^^^^^ needless_bool_assign
+}
diff --git a/tests/ui/needless_bool_assign.rs b/tests/ui/needless_bool_assign.rs
index 3e4fecefa78..c504f61f4dd 100644
--- a/tests/ui/needless_bool_assign.rs
+++ b/tests/ui/needless_bool_assign.rs
@@ -45,3 +45,16 @@ fn main() {
         b = true;
     }
 }
+
+fn issue15063(x: bool, y: bool) {
+    let mut z = false;
+
+    if x && y {
+        todo!()
+    } else if x || y {
+        z = true;
+    } else {
+        z = false;
+    }
+    //~^^^^^ needless_bool_assign
+}
diff --git a/tests/ui/needless_bool_assign.stderr b/tests/ui/needless_bool_assign.stderr
index f33a4bc0c59..1d09b8b25a0 100644
--- a/tests/ui/needless_bool_assign.stderr
+++ b/tests/ui/needless_bool_assign.stderr
@@ -51,5 +51,16 @@ LL | |     }
    = note: `-D clippy::if-same-then-else` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::if_same_then_else)]`
 
-error: aborting due to 4 previous errors
+error: this if-then-else expression assigns a bool literal
+  --> tests/ui/needless_bool_assign.rs:54:12
+   |
+LL |       } else if x || y {
+   |  ____________^
+LL | |         z = true;
+LL | |     } else {
+LL | |         z = false;
+LL | |     }
+   | |_____^ help: you can reduce it to: `{ z = x || y; }`
+
+error: aborting due to 5 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From dc3b8bef8052a6dbd877cd9ecc4c26592685aa4c Mon Sep 17 00:00:00 2001
From: klensy <klensy@users.noreply.github.com>
Date: Tue, 17 Jun 2025 17:21:46 +0300
Subject: precommit test

---
 tests/ui/or_fun_call.fixed | 18 ++++++++++++++++++
 tests/ui/or_fun_call.rs    | 18 ++++++++++++++++++
 2 files changed, 36 insertions(+)

diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 34f3e046841..bb46ce04466 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -439,4 +439,22 @@ fn test_option_get_or_insert() {
     //~^ or_fun_call
 }
 
+fn test_option_and() {
+    // assume that this is slow call
+    fn g() -> Option<u8> {
+        Some(99)
+    }
+    let mut x = Some(42_u8);
+    let _ = x.and(g());
+}
+
+fn test_result_and() {
+    // assume that this is slow call
+    fn g() -> Result<u8, ()> {
+        Ok(99)
+    }
+    let mut x: Result<u8, ()> = Ok(42);
+    let _ = x.and(g());
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index dc57bd6060a..68ef244a019 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -439,4 +439,22 @@ fn test_option_get_or_insert() {
     //~^ or_fun_call
 }
 
+fn test_option_and() {
+    // assume that this is slow call
+    fn g() -> Option<u8> {
+        Some(99)
+    }
+    let mut x = Some(42_u8);
+    let _ = x.and(g());
+}
+
+fn test_result_and() {
+    // assume that this is slow call
+    fn g() -> Result<u8, ()> {
+        Ok(99)
+    }
+    let mut x: Result<u8, ()> = Ok(42);
+    let _ = x.and(g());
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From a82c142f3e0be8f88e588a18bf897899d30f179d Mon Sep 17 00:00:00 2001
From: klensy <klensy@users.noreply.github.com>
Date: Tue, 17 Jun 2025 17:27:56 +0300
Subject: or_fun_call: lint Option/Result::and(_then) too

---
 clippy_lints/src/methods/or_fun_call.rs |  4 +++-
 tests/ui/or_fun_call.fixed              |  6 ++++--
 tests/ui/or_fun_call.rs                 |  2 ++
 tests/ui/or_fun_call.stderr             | 14 +++++++++++++-
 4 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 2139466ce74..6ce7dd3d4d0 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -136,7 +136,7 @@ pub(super) fn check<'tcx>(
         fun_span: Option<Span>,
     ) -> bool {
         // (path, fn_has_argument, methods, suffix)
-        const KNOW_TYPES: [(Symbol, bool, &[Symbol], &str); 5] = [
+        const KNOW_TYPES: [(Symbol, bool, &[Symbol], &str); 7] = [
             (sym::BTreeEntry, false, &[sym::or_insert], "with"),
             (sym::HashMapEntry, false, &[sym::or_insert], "with"),
             (
@@ -146,7 +146,9 @@ pub(super) fn check<'tcx>(
                 "else",
             ),
             (sym::Option, false, &[sym::get_or_insert], "with"),
+            (sym::Option, true, &[sym::and], "then"),
             (sym::Result, true, &[sym::map_or, sym::or, sym::unwrap_or], "else"),
+            (sym::Result, true, &[sym::and], "then"),
         ];
 
         if KNOW_TYPES.iter().any(|k| k.2.contains(&name))
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index bb46ce04466..bcd2602edb6 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -445,7 +445,8 @@ fn test_option_and() {
         Some(99)
     }
     let mut x = Some(42_u8);
-    let _ = x.and(g());
+    let _ = x.and_then(|_| g());
+    //~^ or_fun_call
 }
 
 fn test_result_and() {
@@ -454,7 +455,8 @@ fn test_result_and() {
         Ok(99)
     }
     let mut x: Result<u8, ()> = Ok(42);
-    let _ = x.and(g());
+    let _ = x.and_then(|_| g());
+    //~^ or_fun_call
 }
 
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 68ef244a019..8d1202ebf91 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -446,6 +446,7 @@ fn test_option_and() {
     }
     let mut x = Some(42_u8);
     let _ = x.and(g());
+    //~^ or_fun_call
 }
 
 fn test_result_and() {
@@ -455,6 +456,7 @@ fn test_result_and() {
     }
     let mut x: Result<u8, ()> = Ok(42);
     let _ = x.and(g());
+    //~^ or_fun_call
 }
 
 fn main() {}
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 0f159fe8bff..585ee2d0e19 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -264,5 +264,17 @@ error: function call inside of `get_or_insert`
 LL |     let _ = x.get_or_insert(g());
    |               ^^^^^^^^^^^^^^^^^^ help: try: `get_or_insert_with(g)`
 
-error: aborting due to 41 previous errors
+error: function call inside of `and`
+  --> tests/ui/or_fun_call.rs:448:15
+   |
+LL |     let _ = x.and(g());
+   |               ^^^^^^^^ help: try: `and_then(|_| g())`
+
+error: function call inside of `and`
+  --> tests/ui/or_fun_call.rs:458:15
+   |
+LL |     let _ = x.and(g());
+   |               ^^^^^^^^ help: try: `and_then(|_| g())`
+
+error: aborting due to 43 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 89e5db8fea71e1055437454285d1c128576ec9b9 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sun, 24 Dec 2023 01:04:16 +0000
Subject: Only inherit local hash for paths.

---
 compiler/rustc_hir/src/definitions.rs           | 16 +++++++++++++---
 tests/mir-opt/inline/cycle.rs                   |  2 +-
 tests/ui/symbol-names/basic.legacy.stderr       |  4 ++--
 tests/ui/symbol-names/issue-60925.legacy.stderr |  4 ++--
 tests/ui/thir-print/thir-tree-match.stdout      |  8 ++++----
 5 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_hir/src/definitions.rs b/compiler/rustc_hir/src/definitions.rs
index f93b9e5af53..d9fea542100 100644
--- a/compiler/rustc_hir/src/definitions.rs
+++ b/compiler/rustc_hir/src/definitions.rs
@@ -140,7 +140,9 @@ impl DefKey {
     pub(crate) fn compute_stable_hash(&self, parent: DefPathHash) -> DefPathHash {
         let mut hasher = StableHasher::new();
 
-        parent.hash(&mut hasher);
+        // The new path is in the same crate as `parent`, and will contain the stable_crate_id.
+        // Therefore, we only need to include information of the parent's local hash.
+        parent.local_hash().hash(&mut hasher);
 
         let DisambiguatedDefPathData { ref data, disambiguator } = self.disambiguated_data;
 
@@ -361,8 +363,16 @@ impl Definitions {
             },
         };
 
-        let parent_hash = DefPathHash::new(stable_crate_id, Hash64::ZERO);
-        let def_path_hash = key.compute_stable_hash(parent_hash);
+        // We want *both* halves of a DefPathHash to depend on the crate-id of the defining crate.
+        // The crate-id can be more easily changed than the DefPath of an item, so, in the case of
+        // a crate-local DefPathHash collision, the user can simply "roll the dice again" for all
+        // DefPathHashes in the crate by changing the crate disambiguator (e.g. via bumping the
+        // crate's version number).
+        //
+        // Children paths will only hash the local portion, and still inherit the change to the
+        // root hash.
+        let def_path_hash =
+            DefPathHash::new(stable_crate_id, Hash64::new(stable_crate_id.as_u64()));
 
         // Create the root definition.
         let mut table = DefPathTable::new(stable_crate_id);
diff --git a/tests/mir-opt/inline/cycle.rs b/tests/mir-opt/inline/cycle.rs
index 383d0796a88..6e0f45bb3e9 100644
--- a/tests/mir-opt/inline/cycle.rs
+++ b/tests/mir-opt/inline/cycle.rs
@@ -13,7 +13,7 @@ fn f(g: impl Fn()) {
 #[inline(always)]
 fn g() {
     // CHECK-LABEL: fn g(
-    // CHECK-NOT: (inlined f::<fn() {main}>)
+    // CHECK-NOT: inlined
     f(main);
 }
 
diff --git a/tests/ui/symbol-names/basic.legacy.stderr b/tests/ui/symbol-names/basic.legacy.stderr
index 167262dcf06..a028f433172 100644
--- a/tests/ui/symbol-names/basic.legacy.stderr
+++ b/tests/ui/symbol-names/basic.legacy.stderr
@@ -1,10 +1,10 @@
-error: symbol-name(_ZN5basic4main17hc88b9d80a69d119aE)
+error: symbol-name(_ZN5basic4main17h1dddcfd03744167fE)
   --> $DIR/basic.rs:8:1
    |
 LL | #[rustc_symbol_name]
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(basic::main::hc88b9d80a69d119a)
+error: demangling(basic::main::h1dddcfd03744167f)
   --> $DIR/basic.rs:8:1
    |
 LL | #[rustc_symbol_name]
diff --git a/tests/ui/symbol-names/issue-60925.legacy.stderr b/tests/ui/symbol-names/issue-60925.legacy.stderr
index 4e17bdc4577..14cbd877d9f 100644
--- a/tests/ui/symbol-names/issue-60925.legacy.stderr
+++ b/tests/ui/symbol-names/issue-60925.legacy.stderr
@@ -1,10 +1,10 @@
-error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17hbddb77d6f71afb32E)
+error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17h4b3099ec5dc5d306E)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::hbddb77d6f71afb32)
+error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::h4b3099ec5dc5d306)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]
diff --git a/tests/ui/thir-print/thir-tree-match.stdout b/tests/ui/thir-print/thir-tree-match.stdout
index 910582ae4d9..2049c531abd 100644
--- a/tests/ui/thir-print/thir-tree-match.stdout
+++ b/tests/ui/thir-print/thir-tree-match.stdout
@@ -94,7 +94,7 @@ body:
                                                                                                 did: DefId(0:10 ~ thir_tree_match[fcf8]::Foo)
                                                                                                 variants: [VariantDef { def_id: DefId(0:11 ~ thir_tree_match[fcf8]::Foo::FooOne), ctor: Some((Fn, DefId(0:12 ~ thir_tree_match[fcf8]::Foo::FooOne::{constructor#0}))), name: "FooOne", discr: Relative(0), fields: [FieldDef { did: DefId(0:13 ~ thir_tree_match[fcf8]::Foo::FooOne::0), name: "0", vis: Restricted(DefId(0:0 ~ thir_tree_match[fcf8])), safety: Safe, value: None }], tainted: None, flags:  }, VariantDef { def_id: DefId(0:14 ~ thir_tree_match[fcf8]::Foo::FooTwo), ctor: Some((Const, DefId(0:15 ~ thir_tree_match[fcf8]::Foo::FooTwo::{constructor#0}))), name: "FooTwo", discr: Relative(1), fields: [], tainted: None, flags:  }]
                                                                                                 flags: IS_ENUM
-                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 3477539199540094892 }
+                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 13397682652773712997 }
                                                                                         args: []
                                                                                         variant_index: 0
                                                                                         subpatterns: [
@@ -108,7 +108,7 @@ body:
                                                                                                                 did: DefId(0:3 ~ thir_tree_match[fcf8]::Bar)
                                                                                                                 variants: [VariantDef { def_id: DefId(0:4 ~ thir_tree_match[fcf8]::Bar::First), ctor: Some((Const, DefId(0:5 ~ thir_tree_match[fcf8]::Bar::First::{constructor#0}))), name: "First", discr: Relative(0), fields: [], tainted: None, flags:  }, VariantDef { def_id: DefId(0:6 ~ thir_tree_match[fcf8]::Bar::Second), ctor: Some((Const, DefId(0:7 ~ thir_tree_match[fcf8]::Bar::Second::{constructor#0}))), name: "Second", discr: Relative(1), fields: [], tainted: None, flags:  }, VariantDef { def_id: DefId(0:8 ~ thir_tree_match[fcf8]::Bar::Third), ctor: Some((Const, DefId(0:9 ~ thir_tree_match[fcf8]::Bar::Third::{constructor#0}))), name: "Third", discr: Relative(2), fields: [], tainted: None, flags:  }]
                                                                                                                 flags: IS_ENUM
-                                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 10333377570083945360 }
+                                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 7908585036048874241 }
                                                                                                         args: []
                                                                                                         variant_index: 0
                                                                                                         subpatterns: []
@@ -156,7 +156,7 @@ body:
                                                                                                 did: DefId(0:10 ~ thir_tree_match[fcf8]::Foo)
                                                                                                 variants: [VariantDef { def_id: DefId(0:11 ~ thir_tree_match[fcf8]::Foo::FooOne), ctor: Some((Fn, DefId(0:12 ~ thir_tree_match[fcf8]::Foo::FooOne::{constructor#0}))), name: "FooOne", discr: Relative(0), fields: [FieldDef { did: DefId(0:13 ~ thir_tree_match[fcf8]::Foo::FooOne::0), name: "0", vis: Restricted(DefId(0:0 ~ thir_tree_match[fcf8])), safety: Safe, value: None }], tainted: None, flags:  }, VariantDef { def_id: DefId(0:14 ~ thir_tree_match[fcf8]::Foo::FooTwo), ctor: Some((Const, DefId(0:15 ~ thir_tree_match[fcf8]::Foo::FooTwo::{constructor#0}))), name: "FooTwo", discr: Relative(1), fields: [], tainted: None, flags:  }]
                                                                                                 flags: IS_ENUM
-                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 3477539199540094892 }
+                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 13397682652773712997 }
                                                                                         args: []
                                                                                         variant_index: 0
                                                                                         subpatterns: [
@@ -208,7 +208,7 @@ body:
                                                                                                 did: DefId(0:10 ~ thir_tree_match[fcf8]::Foo)
                                                                                                 variants: [VariantDef { def_id: DefId(0:11 ~ thir_tree_match[fcf8]::Foo::FooOne), ctor: Some((Fn, DefId(0:12 ~ thir_tree_match[fcf8]::Foo::FooOne::{constructor#0}))), name: "FooOne", discr: Relative(0), fields: [FieldDef { did: DefId(0:13 ~ thir_tree_match[fcf8]::Foo::FooOne::0), name: "0", vis: Restricted(DefId(0:0 ~ thir_tree_match[fcf8])), safety: Safe, value: None }], tainted: None, flags:  }, VariantDef { def_id: DefId(0:14 ~ thir_tree_match[fcf8]::Foo::FooTwo), ctor: Some((Const, DefId(0:15 ~ thir_tree_match[fcf8]::Foo::FooTwo::{constructor#0}))), name: "FooTwo", discr: Relative(1), fields: [], tainted: None, flags:  }]
                                                                                                 flags: IS_ENUM
-                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 3477539199540094892 }
+                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 13397682652773712997 }
                                                                                         args: []
                                                                                         variant_index: 1
                                                                                         subpatterns: []
-- 
cgit 1.4.1-3-g733a5


From 1b4a19d4ac514bd50a98b28421a9149159e7c2f4 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sun, 22 Jun 2025 16:03:28 +0000
Subject: Hash less while hashing def-ids.

---
 compiler/rustc_span/src/def_id.rs | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_span/src/def_id.rs b/compiler/rustc_span/src/def_id.rs
index 641bac88ad0..77f01548bca 100644
--- a/compiler/rustc_span/src/def_id.rs
+++ b/compiler/rustc_span/src/def_id.rs
@@ -110,6 +110,7 @@ impl DefPathHash {
 
     /// Builds a new [DefPathHash] with the given [StableCrateId] and
     /// `local_hash`, where `local_hash` must be unique within its crate.
+    #[inline]
     pub fn new(stable_crate_id: StableCrateId, local_hash: Hash64) -> DefPathHash {
         DefPathHash(Fingerprint::new(stable_crate_id.0, local_hash))
     }
@@ -404,21 +405,21 @@ rustc_data_structures::define_id_collections!(
 impl<CTX: HashStableContext> HashStable<CTX> for DefId {
     #[inline]
     fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
-        self.to_stable_hash_key(hcx).hash_stable(hcx, hasher);
+        hcx.def_path_hash(*self).hash_stable(hcx, hasher);
     }
 }
 
 impl<CTX: HashStableContext> HashStable<CTX> for LocalDefId {
     #[inline]
     fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
-        self.to_stable_hash_key(hcx).hash_stable(hcx, hasher);
+        hcx.def_path_hash(self.to_def_id()).local_hash().hash_stable(hcx, hasher);
     }
 }
 
 impl<CTX: HashStableContext> HashStable<CTX> for CrateNum {
     #[inline]
     fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
-        self.to_stable_hash_key(hcx).hash_stable(hcx, hasher);
+        self.as_def_id().to_stable_hash_key(hcx).stable_crate_id().hash_stable(hcx, hasher);
     }
 }
 
@@ -464,30 +465,36 @@ macro_rules! typed_def_id {
         pub struct $Name(DefId);
 
         impl $Name {
+            #[inline]
             pub const fn new_unchecked(def_id: DefId) -> Self {
                 Self(def_id)
             }
 
+            #[inline]
             pub fn to_def_id(self) -> DefId {
                 self.into()
             }
 
+            #[inline]
             pub fn is_local(self) -> bool {
                 self.0.is_local()
             }
 
+            #[inline]
             pub fn as_local(self) -> Option<$LocalName> {
                 self.0.as_local().map($LocalName::new_unchecked)
             }
         }
 
         impl From<$LocalName> for $Name {
+            #[inline]
             fn from(local: $LocalName) -> Self {
                 Self(local.0.to_def_id())
             }
         }
 
         impl From<$Name> for DefId {
+            #[inline]
             fn from(typed: $Name) -> Self {
                 typed.0
             }
@@ -500,26 +507,31 @@ macro_rules! typed_def_id {
         impl !PartialOrd for $LocalName {}
 
         impl $LocalName {
+            #[inline]
             pub const fn new_unchecked(def_id: LocalDefId) -> Self {
                 Self(def_id)
             }
 
+            #[inline]
             pub fn to_def_id(self) -> DefId {
                 self.0.into()
             }
 
+            #[inline]
             pub fn to_local_def_id(self) -> LocalDefId {
                 self.0
             }
         }
 
         impl From<$LocalName> for LocalDefId {
+            #[inline]
             fn from(typed: $LocalName) -> Self {
                 typed.0
             }
         }
 
         impl From<$LocalName> for DefId {
+            #[inline]
             fn from(typed: $LocalName) -> Self {
                 typed.0.into()
             }
-- 
cgit 1.4.1-3-g733a5


From 7a6f7bc7a668aa309249ca7e8a4275f7fedce173 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 27 May 2025 16:16:18 +0200
Subject: Update clippy source code to changes on
 `source_span_for_markdown_range`

---
 clippy_lints/src/doc/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index e0fc2fd9347..d38588bb799 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -765,8 +765,8 @@ impl Fragments<'_> {
     /// get the span for the markdown range. Note that this function is not cheap, use it with
     /// caution.
     #[must_use]
-    fn span(&self, cx: &LateContext<'_>, range: Range<usize>) -> Option<Span> {
-        source_span_for_markdown_range(cx.tcx, self.doc, &range, self.fragments)
+    fn span(self, cx: &LateContext<'_>, range: Range<usize>) -> Option<Span> {
+        source_span_for_markdown_range(cx.tcx, self.doc, &range, self.fragments).map(|(sp, _)| sp)
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 89f7a4301d8a547ee819dfefd95ac7d40005b8cc Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Mon, 23 Jun 2025 11:15:04 +0200
Subject: Properly check that an expression might be the one returned

The `TyCtxt::hir_get_fn_id_for_return_block()` function was too broad,
as it will return positively even when given part of an expression that can
be used as a return value. A new `potential_return_of_enclosing_body()`
utility function has been made to represent the fact that an expression
might be directly returned from its enclosing body.
---
 clippy_lints/src/methods/return_and_then.rs |  29 ++++--
 clippy_utils/src/lib.rs                     |  61 +++++++++++++
 tests/ui/return_and_then.fixed              | 131 ++++++++++++++++++++++++++++
 tests/ui/return_and_then.rs                 | 114 ++++++++++++++++++++++++
 tests/ui/return_and_then.stderr             |  96 +++++++++++++++++++-
 5 files changed, 422 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/methods/return_and_then.rs b/clippy_lints/src/methods/return_and_then.rs
index df8544f9220..54f38a322b8 100644
--- a/clippy_lints/src/methods/return_and_then.rs
+++ b/clippy_lints/src/methods/return_and_then.rs
@@ -1,5 +1,5 @@
 use rustc_errors::Applicability;
-use rustc_hir as hir;
+use rustc_hir::{self as hir, Node};
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, GenericArg, Ty};
 use rustc_span::sym;
@@ -9,7 +9,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_with_applicability};
 use clippy_utils::ty::get_type_diagnostic_name;
 use clippy_utils::visitors::for_each_unconsumed_temporary;
-use clippy_utils::{get_parent_expr, peel_blocks};
+use clippy_utils::{peel_blocks, potential_return_of_enclosing_body};
 
 use super::RETURN_AND_THEN;
 
@@ -21,7 +21,7 @@ pub(super) fn check<'tcx>(
     recv: &'tcx hir::Expr<'tcx>,
     arg: &'tcx hir::Expr<'_>,
 ) {
-    if cx.tcx.hir_get_fn_id_for_return_block(expr.hir_id).is_none() {
+    if !potential_return_of_enclosing_body(cx, expr) {
         return;
     }
 
@@ -55,15 +55,28 @@ pub(super) fn check<'tcx>(
         None => &body_snip,
     };
 
-    // If suggestion is going to get inserted as part of a `return` expression, it must be blockified.
-    let sugg = if let Some(parent_expr) = get_parent_expr(cx, expr) {
-        let base_indent = indent_of(cx, parent_expr.span);
+    // If suggestion is going to get inserted as part of a `return` expression or as a match expression
+    // arm, it must be blockified.
+    let (parent_span_for_indent, opening_paren, closing_paren) = match cx.tcx.parent_hir_node(expr.hir_id) {
+        Node::Expr(parent_expr) if matches!(parent_expr.kind, hir::ExprKind::Break(..)) => {
+            (Some(parent_expr.span), "(", ")")
+        },
+        Node::Expr(parent_expr) => (Some(parent_expr.span), "", ""),
+        Node::Arm(match_arm) => (Some(match_arm.span), "", ""),
+        _ => (None, "", ""),
+    };
+    let sugg = if let Some(span) = parent_span_for_indent {
+        let base_indent = indent_of(cx, span);
         let inner_indent = base_indent.map(|i| i + 4);
         format!(
             "{}\n{}\n{}",
-            reindent_multiline(&format!("{{\nlet {arg_snip} = {recv_snip}?;"), true, inner_indent),
+            reindent_multiline(
+                &format!("{opening_paren}{{\nlet {arg_snip} = {recv_snip}?;"),
+                true,
+                inner_indent
+            ),
             reindent_multiline(inner, false, inner_indent),
-            reindent_multiline("}", false, base_indent),
+            reindent_multiline(&format!("}}{closing_paren}"), false, base_indent),
         )
     } else {
         format!(
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 7fa52229fef..9ac851454af 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -3497,3 +3497,64 @@ pub fn is_expr_default<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) ->
         false
     }
 }
+
+/// Checks if `expr` may be directly used as the return value of its enclosing body.
+/// The following cases are covered:
+/// - `expr` as the last expression of the body, or of a block that can be used as the return value
+/// - `return expr`
+/// - then or else part of a `if` in return position
+/// - arm body of a `match` in a return position
+/// - `break expr` or `break 'label expr` if the loop or block being exited is used as a return
+///   value
+///
+/// Contrary to [`TyCtxt::hir_get_fn_id_for_return_block()`], if `expr` is part of a
+/// larger expression, for example a field expression of a `struct`, it will not be
+/// considered as matching the condition and will return `false`.
+///
+/// Also, even if `expr` is assigned to a variable which is later returned, this function
+/// will still return `false` because `expr` is not used *directly* as the return value
+/// as it goes through the intermediate variable.
+pub fn potential_return_of_enclosing_body(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let enclosing_body_owner = cx
+        .tcx
+        .local_def_id_to_hir_id(cx.tcx.hir_enclosing_body_owner(expr.hir_id));
+    let mut prev_id = expr.hir_id;
+    let mut skip_until_id = None;
+    for (hir_id, node) in cx.tcx.hir_parent_iter(expr.hir_id) {
+        if hir_id == enclosing_body_owner {
+            return true;
+        }
+        if let Some(id) = skip_until_id {
+            prev_id = hir_id;
+            if id == hir_id {
+                skip_until_id = None;
+            }
+            continue;
+        }
+        match node {
+            Node::Block(Block { expr, .. }) if expr.is_some_and(|expr| expr.hir_id == prev_id) => {},
+            Node::Arm(arm) if arm.body.hir_id == prev_id => {},
+            Node::Expr(expr) => match expr.kind {
+                ExprKind::Ret(_) => return true,
+                ExprKind::If(_, then, opt_else)
+                    if then.hir_id == prev_id || opt_else.is_some_and(|els| els.hir_id == prev_id) => {},
+                ExprKind::Match(_, arms, _) if arms.iter().any(|arm| arm.hir_id == prev_id) => {},
+                ExprKind::Block(block, _) if block.hir_id == prev_id => {},
+                ExprKind::Break(
+                    Destination {
+                        target_id: Ok(target_id),
+                        ..
+                    },
+                    _,
+                ) => skip_until_id = Some(target_id),
+                _ => break,
+            },
+            _ => break,
+        }
+        prev_id = hir_id;
+    }
+
+    // `expr` is used as part of "something" and is not returned directly from its
+    // enclosing body.
+    false
+}
diff --git a/tests/ui/return_and_then.fixed b/tests/ui/return_and_then.fixed
index 8d9481d1595..8ee259b97f3 100644
--- a/tests/ui/return_and_then.fixed
+++ b/tests/ui/return_and_then.fixed
@@ -99,6 +99,92 @@ fn main() {
         };
         None
     }
+
+    #[expect(clippy::diverging_sub_expression)]
+    fn with_return_in_expression() -> Option<i32> {
+        _ = (
+            return {
+                let x = Some("")?;
+                if x.len() > 2 { Some(3) } else { None }
+            },
+            //~^ return_and_then
+            10,
+        );
+    }
+
+    fn inside_if(a: bool, i: Option<u32>) -> Option<u32> {
+        if a {
+            let i = i?;
+            if i > 3 { Some(i) } else { None }
+            //~^ return_and_then
+        } else {
+            Some(42)
+        }
+    }
+
+    fn inside_match(a: u32, i: Option<u32>) -> Option<u32> {
+        match a {
+            1 | 2 => {
+                let i = i?;
+                if i > 3 { Some(i) } else { None }
+            },
+            //~^ return_and_then
+            3 | 4 => Some(42),
+            _ => None,
+        }
+    }
+
+    fn inside_match_and_block_and_if(a: u32, i: Option<u32>) -> Option<u32> {
+        match a {
+            1 | 2 => {
+                let a = a * 3;
+                if a.is_multiple_of(2) {
+                    let i = i?;
+                    if i > 3 { Some(i) } else { None }
+                    //~^ return_and_then
+                } else {
+                    Some(10)
+                }
+            },
+            3 | 4 => Some(42),
+            _ => None,
+        }
+    }
+
+    #[expect(clippy::never_loop)]
+    fn with_break(i: Option<u32>) -> Option<u32> {
+        match i {
+            Some(1) => loop {
+                break ({
+                    let i = i?;
+                    if i > 3 { Some(i) } else { None }
+                });
+                //~^ return_and_then
+            },
+            Some(2) => 'foo: loop {
+                loop {
+                    break 'foo ({
+                        let i = i?;
+                        if i > 3 { Some(i) } else { None }
+                    });
+                    //~^ return_and_then
+                }
+            },
+            Some(3) => 'bar: {
+                break 'bar ({
+                    let i = i?;
+                    if i > 3 { Some(i) } else { None }
+                });
+                //~^ return_and_then
+            },
+            Some(4) => 'baz: loop {
+                _ = loop {
+                    break i.and_then(|i| if i > 3 { Some(i) } else { None });
+                };
+            },
+            _ => None,
+        }
+    }
 }
 
 fn gen_option(n: i32) -> Option<i32> {
@@ -124,3 +210,48 @@ mod issue14781 {
         Ok(())
     }
 }
+
+mod issue15111 {
+    #[derive(Debug)]
+    struct EvenOdd {
+        even: Option<u32>,
+        odd: Option<u32>,
+    }
+
+    impl EvenOdd {
+        fn new(i: Option<u32>) -> Self {
+            Self {
+                even: i.and_then(|i| if i.is_multiple_of(2) { Some(i) } else { None }),
+                odd: i.and_then(|i| if i.is_multiple_of(2) { None } else { Some(i) }),
+            }
+        }
+    }
+
+    fn with_if_let(i: Option<u32>) -> u32 {
+        if let Some(x) = i.and_then(|i| if i.is_multiple_of(2) { Some(i) } else { None }) {
+            x
+        } else {
+            std::hint::black_box(0)
+        }
+    }
+
+    fn main() {
+        let _ = EvenOdd::new(Some(2));
+    }
+}
+
+mod issue14927 {
+    use std::path::Path;
+    struct A {
+        pub func: fn(check: bool, a: &Path, b: Option<&Path>),
+    }
+    const MY_A: A = A {
+        func: |check, a, b| {
+            if check {
+                let _ = ();
+            } else if let Some(parent) = b.and_then(|p| p.parent()) {
+                let _ = ();
+            }
+        },
+    };
+}
diff --git a/tests/ui/return_and_then.rs b/tests/ui/return_and_then.rs
index beada921a91..dcb344f142b 100644
--- a/tests/ui/return_and_then.rs
+++ b/tests/ui/return_and_then.rs
@@ -90,6 +90,75 @@ fn main() {
         };
         None
     }
+
+    #[expect(clippy::diverging_sub_expression)]
+    fn with_return_in_expression() -> Option<i32> {
+        _ = (
+            return Some("").and_then(|x| if x.len() > 2 { Some(3) } else { None }),
+            //~^ return_and_then
+            10,
+        );
+    }
+
+    fn inside_if(a: bool, i: Option<u32>) -> Option<u32> {
+        if a {
+            i.and_then(|i| if i > 3 { Some(i) } else { None })
+            //~^ return_and_then
+        } else {
+            Some(42)
+        }
+    }
+
+    fn inside_match(a: u32, i: Option<u32>) -> Option<u32> {
+        match a {
+            1 | 2 => i.and_then(|i| if i > 3 { Some(i) } else { None }),
+            //~^ return_and_then
+            3 | 4 => Some(42),
+            _ => None,
+        }
+    }
+
+    fn inside_match_and_block_and_if(a: u32, i: Option<u32>) -> Option<u32> {
+        match a {
+            1 | 2 => {
+                let a = a * 3;
+                if a.is_multiple_of(2) {
+                    i.and_then(|i| if i > 3 { Some(i) } else { None })
+                    //~^ return_and_then
+                } else {
+                    Some(10)
+                }
+            },
+            3 | 4 => Some(42),
+            _ => None,
+        }
+    }
+
+    #[expect(clippy::never_loop)]
+    fn with_break(i: Option<u32>) -> Option<u32> {
+        match i {
+            Some(1) => loop {
+                break i.and_then(|i| if i > 3 { Some(i) } else { None });
+                //~^ return_and_then
+            },
+            Some(2) => 'foo: loop {
+                loop {
+                    break 'foo i.and_then(|i| if i > 3 { Some(i) } else { None });
+                    //~^ return_and_then
+                }
+            },
+            Some(3) => 'bar: {
+                break 'bar i.and_then(|i| if i > 3 { Some(i) } else { None });
+                //~^ return_and_then
+            },
+            Some(4) => 'baz: loop {
+                _ = loop {
+                    break i.and_then(|i| if i > 3 { Some(i) } else { None });
+                };
+            },
+            _ => None,
+        }
+    }
 }
 
 fn gen_option(n: i32) -> Option<i32> {
@@ -115,3 +184,48 @@ mod issue14781 {
         Ok(())
     }
 }
+
+mod issue15111 {
+    #[derive(Debug)]
+    struct EvenOdd {
+        even: Option<u32>,
+        odd: Option<u32>,
+    }
+
+    impl EvenOdd {
+        fn new(i: Option<u32>) -> Self {
+            Self {
+                even: i.and_then(|i| if i.is_multiple_of(2) { Some(i) } else { None }),
+                odd: i.and_then(|i| if i.is_multiple_of(2) { None } else { Some(i) }),
+            }
+        }
+    }
+
+    fn with_if_let(i: Option<u32>) -> u32 {
+        if let Some(x) = i.and_then(|i| if i.is_multiple_of(2) { Some(i) } else { None }) {
+            x
+        } else {
+            std::hint::black_box(0)
+        }
+    }
+
+    fn main() {
+        let _ = EvenOdd::new(Some(2));
+    }
+}
+
+mod issue14927 {
+    use std::path::Path;
+    struct A {
+        pub func: fn(check: bool, a: &Path, b: Option<&Path>),
+    }
+    const MY_A: A = A {
+        func: |check, a, b| {
+            if check {
+                let _ = ();
+            } else if let Some(parent) = b.and_then(|p| p.parent()) {
+                let _ = ();
+            }
+        },
+    };
+}
diff --git a/tests/ui/return_and_then.stderr b/tests/ui/return_and_then.stderr
index 5feca882860..33867ea818a 100644
--- a/tests/ui/return_and_then.stderr
+++ b/tests/ui/return_and_then.stderr
@@ -146,5 +146,99 @@ LL +                 if x.len() > 2 { Some(3) } else { None }
 LL ~             };
    |
 
-error: aborting due to 10 previous errors
+error: use the `?` operator instead of an `and_then` call
+  --> tests/ui/return_and_then.rs:97:20
+   |
+LL |             return Some("").and_then(|x| if x.len() > 2 { Some(3) } else { None }),
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~             return {
+LL +                 let x = Some("")?;
+LL +                 if x.len() > 2 { Some(3) } else { None }
+LL ~             },
+   |
+
+error: use the `?` operator instead of an `and_then` call
+  --> tests/ui/return_and_then.rs:105:13
+   |
+LL |             i.and_then(|i| if i > 3 { Some(i) } else { None })
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~             let i = i?;
+LL +             if i > 3 { Some(i) } else { None }
+   |
+
+error: use the `?` operator instead of an `and_then` call
+  --> tests/ui/return_and_then.rs:114:22
+   |
+LL |             1 | 2 => i.and_then(|i| if i > 3 { Some(i) } else { None }),
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~             1 | 2 => {
+LL +                 let i = i?;
+LL +                 if i > 3 { Some(i) } else { None }
+LL ~             },
+   |
+
+error: use the `?` operator instead of an `and_then` call
+  --> tests/ui/return_and_then.rs:126:21
+   |
+LL |                     i.and_then(|i| if i > 3 { Some(i) } else { None })
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~                     let i = i?;
+LL +                     if i > 3 { Some(i) } else { None }
+   |
+
+error: use the `?` operator instead of an `and_then` call
+  --> tests/ui/return_and_then.rs:141:23
+   |
+LL |                 break i.and_then(|i| if i > 3 { Some(i) } else { None });
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~                 break ({
+LL +                     let i = i?;
+LL +                     if i > 3 { Some(i) } else { None }
+LL ~                 });
+   |
+
+error: use the `?` operator instead of an `and_then` call
+  --> tests/ui/return_and_then.rs:146:32
+   |
+LL |                     break 'foo i.and_then(|i| if i > 3 { Some(i) } else { None });
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~                     break 'foo ({
+LL +                         let i = i?;
+LL +                         if i > 3 { Some(i) } else { None }
+LL ~                     });
+   |
+
+error: use the `?` operator instead of an `and_then` call
+  --> tests/ui/return_and_then.rs:151:28
+   |
+LL |                 break 'bar i.and_then(|i| if i > 3 { Some(i) } else { None });
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~                 break 'bar ({
+LL +                     let i = i?;
+LL +                     if i > 3 { Some(i) } else { None }
+LL ~                 });
+   |
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From aa460dc24751c038a6598a8adff7914065025b93 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Tue, 10 Jun 2025 19:25:36 +0200
Subject: tests: Add `RUST_BACKTRACE` and `-Cpanic` revisions to
 `panic-main.rs` test

---
 tests/ui/panics/panic-main.rs | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/tests/ui/panics/panic-main.rs b/tests/ui/panics/panic-main.rs
index 3876dbb37c3..bf79de78a57 100644
--- a/tests/ui/panics/panic-main.rs
+++ b/tests/ui/panics/panic-main.rs
@@ -1,3 +1,26 @@
+//@ revisions: default abort-zero abort-one abort-full unwind-zero unwind-one unwind-full
+
+//@[abort-zero] compile-flags: -Cpanic=abort
+//@[abort-zero] no-prefer-dynamic
+//@[abort-zero] exec-env:RUST_BACKTRACE=0
+
+//@[abort-one] compile-flags: -Cpanic=abort
+//@[abort-one] no-prefer-dynamic
+//@[abort-one] exec-env:RUST_BACKTRACE=1
+
+//@[abort-full] compile-flags: -Cpanic=abort
+//@[abort-full] no-prefer-dynamic
+//@[abort-full] exec-env:RUST_BACKTRACE=full
+
+//@[unwind-zero] compile-flags: -Cpanic=unwind
+//@[unwind-zero] exec-env:RUST_BACKTRACE=0
+
+//@[unwind-one] compile-flags: -Cpanic=unwind
+//@[unwind-one] exec-env:RUST_BACKTRACE=1
+
+//@[unwind-full] compile-flags: -Cpanic=unwind
+//@[unwind-full] exec-env:RUST_BACKTRACE=full
+
 //@ run-fail
 //@ error-pattern:moop
 //@ needs-subprocess
-- 
cgit 1.4.1-3-g733a5


From cd682446535c16b8c2d0b0e323bb8ee210371604 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Mon, 23 Jun 2025 10:57:51 -0700
Subject: Handle potentially-shadowing bindings in manual_let_else

This commit also adds more test cases, which work fine but were
mentioned in the issue.
---
 clippy_lints/src/manual_let_else.rs   | 39 ++++++++++++++-----
 tests/ui/manual_let_else_match.fixed  | 45 +++++++++++++++++++++
 tests/ui/manual_let_else_match.rs     | 73 +++++++++++++++++++++++++++++++++++
 tests/ui/manual_let_else_match.stderr | 72 +++++++++++++++++++++++++++++++++-
 4 files changed, 218 insertions(+), 11 deletions(-)

diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 9ff82cdcb66..1f9a943f13d 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -245,17 +245,36 @@ fn replace_in_pattern(
         }
 
         match pat.kind {
-            PatKind::Binding(_ann, _id, binding_name, opt_subpt) => {
-                let Some((pat_to_put, binding_mode)) = ident_map.get(&binding_name.name) else {
-                    break 'a;
-                };
-                let sn_pfx = binding_mode.prefix_str();
-                let (sn_ptp, _) = snippet_with_context(cx, pat_to_put.span, span.ctxt(), "", app);
-                if let Some(subpt) = opt_subpt {
-                    let subpt = replace_in_pattern(cx, span, ident_map, subpt, app, false);
-                    return format!("{sn_pfx}{sn_ptp} @ {subpt}");
+            PatKind::Binding(ann, _id, binding_name, opt_subpt) => {
+                match (ident_map.get(&binding_name.name), opt_subpt) {
+                    (Some((pat_to_put, binding_mode)), opt_subpt) => {
+                        let sn_pfx = binding_mode.prefix_str();
+                        let (sn_ptp, _) = snippet_with_context(cx, pat_to_put.span, span.ctxt(), "", app);
+                        if let Some(subpt) = opt_subpt {
+                            let subpt = replace_in_pattern(cx, span, ident_map, subpt, app, false);
+                            return format!("{sn_pfx}{sn_ptp} @ {subpt}");
+                        }
+                        return format!("{sn_pfx}{sn_ptp}");
+                    },
+                    (None, Some(subpt)) => {
+                        let subpt = replace_in_pattern(cx, span, ident_map, subpt, app, false);
+                        // scanning for a value that matches is not sensitive to order
+                        #[expect(rustc::potential_query_instability)]
+                        if ident_map.values().any(|(other_pat, _)| {
+                            if let PatKind::Binding(_, _, other_name, _) = other_pat.kind {
+                                other_name == binding_name
+                            } else {
+                                false
+                            }
+                        }) {
+                            // this name is shadowed, and, therefore, not usable
+                            return subpt;
+                        }
+                        let binding_pfx = ann.prefix_str();
+                        return format!("{binding_pfx}{binding_name} @ {subpt}");
+                    },
+                    (None, None) => break 'a,
                 }
-                return format!("{sn_pfx}{sn_ptp}");
             },
             PatKind::Or(pats) => {
                 let patterns = pats
diff --git a/tests/ui/manual_let_else_match.fixed b/tests/ui/manual_let_else_match.fixed
index 588ba5edd8f..15f604aec29 100644
--- a/tests/ui/manual_let_else_match.fixed
+++ b/tests/ui/manual_let_else_match.fixed
@@ -137,3 +137,48 @@ fn not_fire() {
 fn issue11579() {
     let Some(msg) = Some("hi") else { unreachable!("can't happen") };
 }
+
+#[derive(Clone, Copy)]
+struct Issue9939<T> {
+    avalanche: T,
+}
+
+fn issue9939() {
+    let issue = Some(Issue9939 { avalanche: 1 });
+    let Some(Issue9939 { avalanche: tornado }) = issue else { unreachable!("can't happen") };
+    let issue = Some(Issue9939 { avalanche: true });
+    let Some(Issue9939 { avalanche: acid_rain }) = issue else { unreachable!("can't happen") };
+    assert_eq!(tornado, 1);
+    assert!(acid_rain);
+
+    // without shadowing
+    let _x @ Some(Issue9939 { avalanche: _y }) = issue else { unreachable!("can't happen") };
+
+    // with shadowing
+    let Some(Issue9939 { avalanche: _x }) = issue else { unreachable!("can't happen") };
+}
+
+#[derive(Clone, Copy)]
+struct Issue9939b<T, U> {
+    earthquake: T,
+    hurricane: U,
+}
+
+fn issue9939b() {
+    let issue = Some(Issue9939b {
+        earthquake: true,
+        hurricane: 1,
+    });
+    let issue @ Some(Issue9939b { earthquake: flood, hurricane: drought }) = issue else { unreachable!("can't happen") };
+    assert_eq!(drought, 1);
+    assert!(flood);
+    assert!(issue.is_some());
+
+    // without shadowing
+    let _x @ Some(Issue9939b { earthquake: erosion, hurricane: _y }) = issue else { unreachable!("can't happen") };
+    assert!(erosion);
+
+    // with shadowing
+    let Some(Issue9939b { earthquake: erosion, hurricane: _x }) = issue else { unreachable!("can't happen") };
+    assert!(erosion);
+}
diff --git a/tests/ui/manual_let_else_match.rs b/tests/ui/manual_let_else_match.rs
index 6416753bac1..44a044b142b 100644
--- a/tests/ui/manual_let_else_match.rs
+++ b/tests/ui/manual_let_else_match.rs
@@ -177,3 +177,76 @@ fn issue11579() {
         _ => unreachable!("can't happen"),
     };
 }
+
+#[derive(Clone, Copy)]
+struct Issue9939<T> {
+    avalanche: T,
+}
+
+fn issue9939() {
+    let issue = Some(Issue9939 { avalanche: 1 });
+    let tornado = match issue {
+        //~^ manual_let_else
+        Some(Issue9939 { avalanche }) => avalanche,
+        _ => unreachable!("can't happen"),
+    };
+    let issue = Some(Issue9939 { avalanche: true });
+    let acid_rain = match issue {
+        //~^ manual_let_else
+        Some(Issue9939 { avalanche: tornado }) => tornado,
+        _ => unreachable!("can't happen"),
+    };
+    assert_eq!(tornado, 1);
+    assert!(acid_rain);
+
+    // without shadowing
+    let _y = match issue {
+        //~^ manual_let_else
+        _x @ Some(Issue9939 { avalanche }) => avalanche,
+        None => unreachable!("can't happen"),
+    };
+
+    // with shadowing
+    let _x = match issue {
+        //~^ manual_let_else
+        _x @ Some(Issue9939 { avalanche }) => avalanche,
+        None => unreachable!("can't happen"),
+    };
+}
+
+#[derive(Clone, Copy)]
+struct Issue9939b<T, U> {
+    earthquake: T,
+    hurricane: U,
+}
+
+fn issue9939b() {
+    let issue = Some(Issue9939b {
+        earthquake: true,
+        hurricane: 1,
+    });
+    let (issue, drought, flood) = match issue {
+        //~^ manual_let_else
+        flood @ Some(Issue9939b { earthquake, hurricane }) => (flood, hurricane, earthquake),
+        None => unreachable!("can't happen"),
+    };
+    assert_eq!(drought, 1);
+    assert!(flood);
+    assert!(issue.is_some());
+
+    // without shadowing
+    let (_y, erosion) = match issue {
+        //~^ manual_let_else
+        _x @ Some(Issue9939b { earthquake, hurricane }) => (hurricane, earthquake),
+        None => unreachable!("can't happen"),
+    };
+    assert!(erosion);
+
+    // with shadowing
+    let (_x, erosion) = match issue {
+        //~^ manual_let_else
+        _x @ Some(Issue9939b { earthquake, hurricane }) => (hurricane, earthquake),
+        None => unreachable!("can't happen"),
+    };
+    assert!(erosion);
+}
diff --git a/tests/ui/manual_let_else_match.stderr b/tests/ui/manual_let_else_match.stderr
index 393562c629b..ed6117ebffb 100644
--- a/tests/ui/manual_let_else_match.stderr
+++ b/tests/ui/manual_let_else_match.stderr
@@ -101,5 +101,75 @@ LL | |         _ => unreachable!("can't happen"),
 LL | |     };
    | |______^ help: consider writing: `let Some(msg) = Some("hi") else { unreachable!("can't happen") };`
 
-error: aborting due to 10 previous errors
+error: this could be rewritten as `let...else`
+  --> tests/ui/manual_let_else_match.rs:188:5
+   |
+LL | /     let tornado = match issue {
+LL | |
+LL | |         Some(Issue9939 { avalanche }) => avalanche,
+LL | |         _ => unreachable!("can't happen"),
+LL | |     };
+   | |______^ help: consider writing: `let Some(Issue9939 { avalanche: tornado }) = issue else { unreachable!("can't happen") };`
+
+error: this could be rewritten as `let...else`
+  --> tests/ui/manual_let_else_match.rs:194:5
+   |
+LL | /     let acid_rain = match issue {
+LL | |
+LL | |         Some(Issue9939 { avalanche: tornado }) => tornado,
+LL | |         _ => unreachable!("can't happen"),
+LL | |     };
+   | |______^ help: consider writing: `let Some(Issue9939 { avalanche: acid_rain }) = issue else { unreachable!("can't happen") };`
+
+error: this could be rewritten as `let...else`
+  --> tests/ui/manual_let_else_match.rs:203:5
+   |
+LL | /     let _y = match issue {
+LL | |
+LL | |         _x @ Some(Issue9939 { avalanche }) => avalanche,
+LL | |         None => unreachable!("can't happen"),
+LL | |     };
+   | |______^ help: consider writing: `let _x @ Some(Issue9939 { avalanche: _y }) = issue else { unreachable!("can't happen") };`
+
+error: this could be rewritten as `let...else`
+  --> tests/ui/manual_let_else_match.rs:210:5
+   |
+LL | /     let _x = match issue {
+LL | |
+LL | |         _x @ Some(Issue9939 { avalanche }) => avalanche,
+LL | |         None => unreachable!("can't happen"),
+LL | |     };
+   | |______^ help: consider writing: `let Some(Issue9939 { avalanche: _x }) = issue else { unreachable!("can't happen") };`
+
+error: this could be rewritten as `let...else`
+  --> tests/ui/manual_let_else_match.rs:228:5
+   |
+LL | /     let (issue, drought, flood) = match issue {
+LL | |
+LL | |         flood @ Some(Issue9939b { earthquake, hurricane }) => (flood, hurricane, earthquake),
+LL | |         None => unreachable!("can't happen"),
+LL | |     };
+   | |______^ help: consider writing: `let issue @ Some(Issue9939b { earthquake: flood, hurricane: drought }) = issue else { unreachable!("can't happen") };`
+
+error: this could be rewritten as `let...else`
+  --> tests/ui/manual_let_else_match.rs:238:5
+   |
+LL | /     let (_y, erosion) = match issue {
+LL | |
+LL | |         _x @ Some(Issue9939b { earthquake, hurricane }) => (hurricane, earthquake),
+LL | |         None => unreachable!("can't happen"),
+LL | |     };
+   | |______^ help: consider writing: `let _x @ Some(Issue9939b { earthquake: erosion, hurricane: _y }) = issue else { unreachable!("can't happen") };`
+
+error: this could be rewritten as `let...else`
+  --> tests/ui/manual_let_else_match.rs:246:5
+   |
+LL | /     let (_x, erosion) = match issue {
+LL | |
+LL | |         _x @ Some(Issue9939b { earthquake, hurricane }) => (hurricane, earthquake),
+LL | |         None => unreachable!("can't happen"),
+LL | |     };
+   | |______^ help: consider writing: `let Some(Issue9939b { earthquake: erosion, hurricane: _x }) = issue else { unreachable!("can't happen") };`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 068f3ac20b4074b523e80c07b3bf139ced9374dd Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Tue, 24 Jun 2025 04:05:27 +0000
Subject: Update test.

---
 compiler/rustc_hir/src/tests.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_hir/src/tests.rs b/compiler/rustc_hir/src/tests.rs
index 18c2bfdac8c..3b797c1f103 100644
--- a/compiler/rustc_hir/src/tests.rs
+++ b/compiler/rustc_hir/src/tests.rs
@@ -28,7 +28,8 @@ fn def_path_hash_depends_on_crate_id() {
         assert_ne!(h0.local_hash(), h1.local_hash());
 
         fn mk_test_hash(stable_crate_id: StableCrateId) -> DefPathHash {
-            let parent_hash = DefPathHash::new(stable_crate_id, Hash64::ZERO);
+            let parent_hash =
+                DefPathHash::new(stable_crate_id, Hash64::new(stable_crate_id.as_u64()));
 
             let key = DefKey {
                 parent: None,
-- 
cgit 1.4.1-3-g733a5


From 962ff16101b66ea9937163de9bd9ae948aea9332 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Tue, 24 Jun 2025 20:40:08 +0200
Subject: Use `asm_cfg` in `probestack`

cc https://www.github.com/rust-lang/rust/issues/140364
---
 .../compiler-builtins/compiler-builtins/src/lib.rs |  1 +
 .../compiler-builtins/src/probestack.rs            | 35 ++++++++--------------
 2 files changed, 13 insertions(+), 23 deletions(-)

diff --git a/library/compiler-builtins/compiler-builtins/src/lib.rs b/library/compiler-builtins/compiler-builtins/src/lib.rs
index dd9920cae01..fe0ad81dd3a 100644
--- a/library/compiler-builtins/compiler-builtins/src/lib.rs
+++ b/library/compiler-builtins/compiler-builtins/src/lib.rs
@@ -7,6 +7,7 @@
 #![feature(compiler_builtins)]
 #![feature(core_intrinsics)]
 #![feature(linkage)]
+#![feature(asm_cfg)]
 #![feature(naked_functions)]
 #![feature(repr_simd)]
 #![feature(macro_metavar_expr_concat)]
diff --git a/library/compiler-builtins/compiler-builtins/src/probestack.rs b/library/compiler-builtins/compiler-builtins/src/probestack.rs
index 1d0010842cb..f4105dde57e 100644
--- a/library/compiler-builtins/compiler-builtins/src/probestack.rs
+++ b/library/compiler-builtins/compiler-builtins/src/probestack.rs
@@ -58,27 +58,6 @@
 #[unsafe(naked)]
 #[rustc_std_internal_symbol]
 pub unsafe extern "custom" fn __rust_probestack() {
-    #[cfg(not(all(target_env = "sgx", target_vendor = "fortanix")))]
-    macro_rules! ret {
-        () => {
-            "ret"
-        };
-    }
-
-    #[cfg(all(target_env = "sgx", target_vendor = "fortanix"))]
-    macro_rules! ret {
-        // for this target, [manually patch for LVI].
-        //
-        // [manually patch for LVI]: https://software.intel.com/security-software-guidance/insights/deep-dive-load-value-injection#specialinstructions
-        () => {
-            "
-            pop %r11
-            lfence
-            jmp *%r11
-            "
-        };
-    }
-
     core::arch::naked_asm!(
         "
             .cfi_startproc
@@ -128,8 +107,18 @@ pub unsafe extern "custom" fn __rust_probestack() {
             .cfi_def_cfa_register %rsp
             .cfi_adjust_cfa_offset -8
     ",
-        ret!(),
-        "
+    #[cfg(not(all(target_env = "sgx", target_vendor = "fortanix")))]
+    "       ret",
+    #[cfg(all(target_env = "sgx", target_vendor = "fortanix"))]
+    "
+            // for this target, [manually patch for LVI].
+            //
+            // [manually patch for LVI]: https://software.intel.com/security-software-guidance/insights/deep-dive-load-value-injection#specialinstructions
+            pop %r11
+            lfence
+            jmp *%r11
+    ",
+    "
             .cfi_endproc
     ",
         options(att_syntax)
-- 
cgit 1.4.1-3-g733a5


From 71ff9a09d103e63a29d813b5ae54905f8a25774e Mon Sep 17 00:00:00 2001
From: Chengxu Bian <cbian564@gmail.com>
Date: Wed, 25 Jun 2025 07:23:48 -0400
Subject: fix mul_add uncertain sugg

---
 clippy_lints/src/floating_point_arithmetic.rs | 36 +++++++++++++++++++++++++--
 tests/ui/floating_point_mul_add.fixed         | 20 +++++++++++++++
 tests/ui/floating_point_mul_add.rs            | 20 +++++++++++++++
 tests/ui/floating_point_mul_add.stderr        | 32 +++++++++++++++++++++++-
 4 files changed, 105 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index b3c9e860758..6b03a5a8f85 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -7,7 +7,8 @@ use clippy_utils::{
 };
 use rustc_ast::ast;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
+use rustc_hir::def::Res;
+use rustc_hir::{BinOpKind, Expr, ExprKind, Node, PathSegment, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
@@ -455,7 +456,32 @@ fn is_float_mul_expr<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(&'
     None
 }
 
-// TODO: Fix rust-lang/rust-clippy#4735
+// Check if any variable in an expression has an ambiguous type (could be f32 or f64)
+fn has_ambiguous_float_type(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    match &expr.kind {
+        ExprKind::Path(qpath) => {
+            if let Res::Local(hir_id) = cx.qpath_res(qpath, expr.hir_id) {
+                if let Node::LetStmt(local) = cx.tcx.parent_hir_node(hir_id) {
+                    // If the local has no type annotation and the initializer is an unsuffixed float literal,
+                    // then the type is ambiguous
+                    if local.ty.is_none() {
+                        if let Some(init) = local.init {
+                            if let ExprKind::Lit(lit) = &init.kind {
+                                if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            false
+        },
+        ExprKind::Binary(_, lhs, rhs) => has_ambiguous_float_type(cx, lhs) || has_ambiguous_float_type(cx, rhs),
+        _ => false,
+    }
+}
+
 fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if let ExprKind::Binary(
         Spanned {
@@ -491,6 +517,12 @@ fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
             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 has_ambiguous_float_type(cx, recv) {
+            return;
+        }
+
         span_lint_and_sugg(
             cx,
             SUBOPTIMAL_FLOPS,
diff --git a/tests/ui/floating_point_mul_add.fixed b/tests/ui/floating_point_mul_add.fixed
index 83aeddb2a1f..3f647730f01 100644
--- a/tests/ui/floating_point_mul_add.fixed
+++ b/tests/ui/floating_point_mul_add.fixed
@@ -69,3 +69,23 @@ fn _issue11831() {
 
     let _ = a + b * c;
 }
+
+fn _issue12331() {
+    let x = 1.0;
+    let _ = x * 2.0 + 0.5; // should not suggest mul_add
+    let _ = 0.5 + x * 2.0; // should not suggest mul_add
+
+    let _ = 2.0f64.mul_add(x, 0.5);
+    //~^ suboptimal_flops
+    let _ = 2.0f64.mul_add(x, 0.5);
+    //~^ suboptimal_flops
+
+    let _ = 2.0f64.mul_add(4.0, x);
+    //~^ suboptimal_flops
+
+    let y: f64 = 1.0;
+    let _ = y.mul_add(2.0, 0.5);
+    //~^ suboptimal_flops
+    let _ = 1.0f64.mul_add(2.0, 0.5);
+    //~^ suboptimal_flops
+}
diff --git a/tests/ui/floating_point_mul_add.rs b/tests/ui/floating_point_mul_add.rs
index 039ee8d053f..44b29a42743 100644
--- a/tests/ui/floating_point_mul_add.rs
+++ b/tests/ui/floating_point_mul_add.rs
@@ -69,3 +69,23 @@ fn _issue11831() {
 
     let _ = a + b * c;
 }
+
+fn _issue14897() {
+    let x = 1.0;
+    let _ = x * 2.0 + 0.5; // should not suggest mul_add
+    let _ = 0.5 + x * 2.0; // should not suggest mul_add
+
+    let _ = 0.5 + 2.0 * x;
+    //~^ suboptimal_flops
+    let _ = 2.0 * x + 0.5;
+    //~^ suboptimal_flops
+
+    let _ = x + 2.0 * 4.0;
+    //~^ suboptimal_flops
+
+    let y: f64 = 1.0;
+    let _ = y * 2.0 + 0.5;
+    //~^ suboptimal_flops
+    let _ = 1.0 * 2.0 + 0.5;
+    //~^ suboptimal_flops
+}
diff --git a/tests/ui/floating_point_mul_add.stderr b/tests/ui/floating_point_mul_add.stderr
index 6482127bcc0..58d6e61bea3 100644
--- a/tests/ui/floating_point_mul_add.stderr
+++ b/tests/ui/floating_point_mul_add.stderr
@@ -79,5 +79,35 @@ error: multiply and add expressions can be calculated more efficiently and accur
 LL |     let _ = a - (b * u as f64);
    |             ^^^^^^^^^^^^^^^^^^ help: consider using: `b.mul_add(-(u as f64), a)`
 
-error: aborting due to 13 previous errors
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> tests/ui/floating_point_mul_add.rs:78:13
+   |
+LL |     let _ = 0.5 + 2.0 * x;
+   |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(x, 0.5)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> tests/ui/floating_point_mul_add.rs:80:13
+   |
+LL |     let _ = 2.0 * x + 0.5;
+   |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(x, 0.5)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> tests/ui/floating_point_mul_add.rs:83:13
+   |
+LL |     let _ = x + 2.0 * 4.0;
+   |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4.0, x)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> tests/ui/floating_point_mul_add.rs:87:13
+   |
+LL |     let _ = y * 2.0 + 0.5;
+   |             ^^^^^^^^^^^^^ help: consider using: `y.mul_add(2.0, 0.5)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> tests/ui/floating_point_mul_add.rs:89:13
+   |
+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
 
-- 
cgit 1.4.1-3-g733a5


From 1eb2920318ca139fbc1a1b10f071775f7a49da4a Mon Sep 17 00:00:00 2001
From: Chengxu Bian <cbian564@gmail.com>
Date: Wed, 25 Jun 2025 08:28:29 -0400
Subject: add more test cases and clauses

---
 clippy_lints/src/floating_point_arithmetic.rs | 45 ++++++++++++++++++++++-----
 tests/ui/floating_point_mul_add.fixed         | 16 +++++++++-
 tests/ui/floating_point_mul_add.rs            | 14 +++++++++
 tests/ui/floating_point_mul_add.stderr        | 18 +++++++----
 4 files changed, 78 insertions(+), 15 deletions(-)

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 6b03a5a8f85..39b8e8c54fa 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -462,22 +462,51 @@ fn has_ambiguous_float_type(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         ExprKind::Path(qpath) => {
             if let Res::Local(hir_id) = cx.qpath_res(qpath, expr.hir_id) {
                 if let Node::LetStmt(local) = cx.tcx.parent_hir_node(hir_id) {
-                    // If the local has no type annotation and the initializer is an unsuffixed float literal,
-                    // then the type is ambiguous
+                    // If the local has no type annotation, check if the initializer has ambiguous float literals
                     if local.ty.is_none() {
                         if let Some(init) = local.init {
-                            if let ExprKind::Lit(lit) = &init.kind {
-                                if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node {
-                                    return true;
-                                }
-                            }
+                            return has_ambiguous_float_literal_in_expr(cx, init);
                         }
                     }
                 }
             }
             false
         },
-        ExprKind::Binary(_, lhs, rhs) => has_ambiguous_float_type(cx, lhs) || has_ambiguous_float_type(cx, rhs),
+        _ => false, // only check path
+    }
+}
+
+// Recursively check if an expression contains any unsuffixed float literals
+fn has_ambiguous_float_literal_in_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    match &expr.kind {
+        ExprKind::Lit(lit) => {
+            if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node {
+                return true;
+            }
+            false
+        },
+        ExprKind::Binary(_, lhs, rhs) => {
+            has_ambiguous_float_literal_in_expr(cx, lhs) || has_ambiguous_float_literal_in_expr(cx, rhs)
+        },
+        ExprKind::Unary(_, expr) => has_ambiguous_float_literal_in_expr(cx, expr),
+        ExprKind::If(_, then, else_) => {
+            has_ambiguous_float_literal_in_expr(cx, then)
+                || else_
+                    .as_ref()
+                    .map_or(false, |else_expr| has_ambiguous_float_literal_in_expr(cx, else_expr))
+        },
+        ExprKind::Block(block, _) => block
+            .expr
+            .as_ref()
+            .map_or(false, |expr| has_ambiguous_float_literal_in_expr(cx, expr)),
+        ExprKind::MethodCall(_, receiver, args, _) => {
+            has_ambiguous_float_literal_in_expr(cx, receiver)
+                || args.iter().any(|arg| has_ambiguous_float_literal_in_expr(cx, arg))
+        },
+        ExprKind::Call(func, args) => {
+            has_ambiguous_float_literal_in_expr(cx, func)
+                || args.iter().any(|arg| has_ambiguous_float_literal_in_expr(cx, arg))
+        },
         _ => false,
     }
 }
diff --git a/tests/ui/floating_point_mul_add.fixed b/tests/ui/floating_point_mul_add.fixed
index 3f647730f01..b07f3a6cc69 100644
--- a/tests/ui/floating_point_mul_add.fixed
+++ b/tests/ui/floating_point_mul_add.fixed
@@ -70,10 +70,24 @@ fn _issue11831() {
     let _ = a + b * c;
 }
 
-fn _issue12331() {
+fn _issue14897() {
     let x = 1.0;
     let _ = x * 2.0 + 0.5; // should not suggest mul_add
     let _ = 0.5 + x * 2.0; // should not suggest mul_add
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
+    let _ = 1.2 + x * 1.2; // should not suggest mul_add
+
+    let x = -1.0;
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
+
+    let x = { 4.0 };
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
+
+    let x = if 1 > 2 { 1.0 } else { 2.0 };
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
+
+    let x = 2.4 + 1.2;
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
 
     let _ = 2.0f64.mul_add(x, 0.5);
     //~^ suboptimal_flops
diff --git a/tests/ui/floating_point_mul_add.rs b/tests/ui/floating_point_mul_add.rs
index 44b29a42743..8af9c51f271 100644
--- a/tests/ui/floating_point_mul_add.rs
+++ b/tests/ui/floating_point_mul_add.rs
@@ -74,6 +74,20 @@ fn _issue14897() {
     let x = 1.0;
     let _ = x * 2.0 + 0.5; // should not suggest mul_add
     let _ = 0.5 + x * 2.0; // should not suggest mul_add
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
+    let _ = 1.2 + x * 1.2; // should not suggest mul_add
+
+    let x = -1.0;
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
+
+    let x = { 4.0 };
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
+
+    let x = if 1 > 2 { 1.0 } else { 2.0 };
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
+
+    let x = 2.4 + 1.2;
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
 
     let _ = 0.5 + 2.0 * x;
     //~^ suboptimal_flops
diff --git a/tests/ui/floating_point_mul_add.stderr b/tests/ui/floating_point_mul_add.stderr
index 58d6e61bea3..80d08c7de73 100644
--- a/tests/ui/floating_point_mul_add.stderr
+++ b/tests/ui/floating_point_mul_add.stderr
@@ -80,34 +80,40 @@ LL |     let _ = a - (b * u as f64);
    |             ^^^^^^^^^^^^^^^^^^ help: consider using: `b.mul_add(-(u as f64), a)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:78:13
+  --> tests/ui/floating_point_mul_add.rs:85:13
+   |
+LL |     let _ = 0.5 + x * 1.2; // should not suggest mul_add
+   |             ^^^^^^^^^^^^^ help: consider using: `x.mul_add(1.2, 0.5)`
+
+error: multiply and add expressions can be calculated more efficiently and accurately
+  --> tests/ui/floating_point_mul_add.rs:96:13
    |
 LL |     let _ = 0.5 + 2.0 * x;
    |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(x, 0.5)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:80:13
+  --> tests/ui/floating_point_mul_add.rs:98:13
    |
 LL |     let _ = 2.0 * x + 0.5;
    |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(x, 0.5)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:83:13
+  --> tests/ui/floating_point_mul_add.rs:101:13
    |
 LL |     let _ = x + 2.0 * 4.0;
    |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4.0, x)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:87:13
+  --> tests/ui/floating_point_mul_add.rs:105:13
    |
 LL |     let _ = y * 2.0 + 0.5;
    |             ^^^^^^^^^^^^^ help: consider using: `y.mul_add(2.0, 0.5)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:89:13
+  --> tests/ui/floating_point_mul_add.rs:107:13
    |
 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: aborting due to 19 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 962404697732f3e5d3eb2efdf1782189fae9f2ae Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Tue, 24 Jun 2025 19:51:24 +0200
Subject: deny AMBIGUOUS_GLOB_IMPORTS; tests fail in this commit

---
 compiler/rustc_lint_defs/src/builtin.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 5fa00fcc4a0..582ddec7676 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -4343,11 +4343,12 @@ declare_lint! {
     ///
     /// [future-incompatible]: ../index.md#future-incompatible-lints
     pub AMBIGUOUS_GLOB_IMPORTS,
-    Warn,
+    Deny,
     "detects certain glob imports that require reporting an ambiguity error",
     @future_incompatible = FutureIncompatibleInfo {
         reason: FutureIncompatibilityReason::FutureReleaseError,
         reference: "issue #114095 <https://github.com/rust-lang/rust/issues/114095>",
+        report_in_deps: true,
     };
 }
 
-- 
cgit 1.4.1-3-g733a5


From 3be0b6b72cb41eaf1094f0b19b3e54fb2d722968 Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Tue, 24 Jun 2025 21:08:15 +0200
Subject: update ui/import tests

---
 tests/ui/imports/ambiguous-1.rs                    |  3 +-
 tests/ui/imports/ambiguous-1.stderr                | 38 +++++++++---
 tests/ui/imports/ambiguous-10.rs                   |  3 +-
 tests/ui/imports/ambiguous-10.stderr               | 36 +++++++++--
 tests/ui/imports/ambiguous-12.rs                   |  3 +-
 tests/ui/imports/ambiguous-12.stderr               | 36 +++++++++--
 tests/ui/imports/ambiguous-13.rs                   |  3 +-
 tests/ui/imports/ambiguous-13.stderr               | 36 +++++++++--
 tests/ui/imports/ambiguous-14.rs                   |  3 +-
 tests/ui/imports/ambiguous-14.stderr               | 36 +++++++++--
 tests/ui/imports/ambiguous-15.rs                   |  3 +-
 tests/ui/imports/ambiguous-15.stderr               | 36 +++++++++--
 tests/ui/imports/ambiguous-16.rs                   |  3 +-
 tests/ui/imports/ambiguous-16.stderr               | 36 +++++++++--
 tests/ui/imports/ambiguous-17.rs                   |  3 +-
 tests/ui/imports/ambiguous-17.stderr               | 38 +++++++++---
 tests/ui/imports/ambiguous-2.rs                    |  3 +-
 tests/ui/imports/ambiguous-3.rs                    |  3 +-
 tests/ui/imports/ambiguous-3.stderr                | 36 +++++++++--
 tests/ui/imports/ambiguous-4-extern.rs             |  3 +-
 tests/ui/imports/ambiguous-4-extern.stderr         | 38 +++++++++---
 tests/ui/imports/ambiguous-4.rs                    |  3 +-
 tests/ui/imports/ambiguous-5.rs                    |  3 +-
 tests/ui/imports/ambiguous-5.stderr                | 36 +++++++++--
 tests/ui/imports/ambiguous-6.rs                    |  3 +-
 tests/ui/imports/ambiguous-6.stderr                | 36 +++++++++--
 tests/ui/imports/ambiguous-9.rs                    |  5 +-
 tests/ui/imports/ambiguous-9.stderr                | 72 ++++++++++++++++++----
 tests/ui/imports/duplicate.rs                      |  2 +-
 tests/ui/imports/duplicate.stderr                  | 30 ++++++++-
 tests/ui/imports/unresolved-seg-after-ambiguous.rs |  2 +-
 .../imports/unresolved-seg-after-ambiguous.stderr  | 30 ++++++++-
 32 files changed, 497 insertions(+), 124 deletions(-)

diff --git a/tests/ui/imports/ambiguous-1.rs b/tests/ui/imports/ambiguous-1.rs
index d175444c0f2..dca26b17466 100644
--- a/tests/ui/imports/ambiguous-1.rs
+++ b/tests/ui/imports/ambiguous-1.rs
@@ -1,4 +1,3 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/pull/112743#issuecomment-1601986883
 
 macro_rules! m {
@@ -25,6 +24,6 @@ pub use openssl::*;
 
 fn main() {
     id();
-    //~^ WARNING `id` is ambiguous
+    //~^ ERROR `id` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
diff --git a/tests/ui/imports/ambiguous-1.stderr b/tests/ui/imports/ambiguous-1.stderr
index 61b3077c354..c4b7fc41932 100644
--- a/tests/ui/imports/ambiguous-1.stderr
+++ b/tests/ui/imports/ambiguous-1.stderr
@@ -1,5 +1,5 @@
 warning: ambiguous glob re-exports
-  --> $DIR/ambiguous-1.rs:11:13
+  --> $DIR/ambiguous-1.rs:10:13
    |
 LL |     pub use self::evp::*;
    |             ^^^^^^^^^^^^ the name `id` in the value namespace is first re-exported here
@@ -9,8 +9,8 @@ LL |     pub use self::handwritten::*;
    |
    = note: `#[warn(ambiguous_glob_reexports)]` on by default
 
-warning: `id` is ambiguous
-  --> $DIR/ambiguous-1.rs:27:5
+error: `id` is ambiguous
+  --> $DIR/ambiguous-1.rs:26:5
    |
 LL |     id();
    |     ^^ ambiguous name
@@ -19,18 +19,42 @@ LL |     id();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `id` could refer to the function imported here
-  --> $DIR/ambiguous-1.rs:11:13
+  --> $DIR/ambiguous-1.rs:10:13
    |
 LL |     pub use self::evp::*;
    |             ^^^^^^^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
 note: `id` could also refer to the function imported here
-  --> $DIR/ambiguous-1.rs:13:13
+  --> $DIR/ambiguous-1.rs:12:13
    |
 LL |     pub use self::handwritten::*;
    |             ^^^^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
-warning: 2 warnings emitted
+error: aborting due to 1 previous error; 1 warning emitted
+
+Future incompatibility report: Future breakage diagnostic:
+error: `id` is ambiguous
+  --> $DIR/ambiguous-1.rs:26:5
+   |
+LL |     id();
+   |     ^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `id` could refer to the function imported here
+  --> $DIR/ambiguous-1.rs:10:13
+   |
+LL |     pub use self::evp::*;
+   |             ^^^^^^^^^^^^
+   = help: consider adding an explicit import of `id` to disambiguate
+note: `id` could also refer to the function imported here
+  --> $DIR/ambiguous-1.rs:12:13
+   |
+LL |     pub use self::handwritten::*;
+   |             ^^^^^^^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `id` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-10.rs b/tests/ui/imports/ambiguous-10.rs
index 7c14e3343eb..166b01ede12 100644
--- a/tests/ui/imports/ambiguous-10.rs
+++ b/tests/ui/imports/ambiguous-10.rs
@@ -1,4 +1,3 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/pull/113099#issuecomment-1637022296
 
 mod a {
@@ -14,6 +13,6 @@ mod b {
 use crate::a::*;
 use crate::b::*;
 fn c(_: Token) {}
-//~^ WARNING `Token` is ambiguous
+//~^ ERROR `Token` is ambiguous
 //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 fn main() { }
diff --git a/tests/ui/imports/ambiguous-10.stderr b/tests/ui/imports/ambiguous-10.stderr
index 704af616b43..cd36795b3c0 100644
--- a/tests/ui/imports/ambiguous-10.stderr
+++ b/tests/ui/imports/ambiguous-10.stderr
@@ -1,5 +1,5 @@
-warning: `Token` is ambiguous
-  --> $DIR/ambiguous-10.rs:16:9
+error: `Token` is ambiguous
+  --> $DIR/ambiguous-10.rs:15:9
    |
 LL | fn c(_: Token) {}
    |         ^^^^^ ambiguous name
@@ -8,18 +8,42 @@ LL | fn c(_: Token) {}
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `Token` could refer to the enum imported here
-  --> $DIR/ambiguous-10.rs:14:5
+  --> $DIR/ambiguous-10.rs:13:5
    |
 LL | use crate::a::*;
    |     ^^^^^^^^^^^
    = help: consider adding an explicit import of `Token` to disambiguate
 note: `Token` could also refer to the enum imported here
-  --> $DIR/ambiguous-10.rs:15:5
+  --> $DIR/ambiguous-10.rs:14:5
    |
 LL | use crate::b::*;
    |     ^^^^^^^^^^^
    = help: consider adding an explicit import of `Token` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
+
+error: aborting due to 1 previous error
 
-warning: 1 warning emitted
+Future incompatibility report: Future breakage diagnostic:
+error: `Token` is ambiguous
+  --> $DIR/ambiguous-10.rs:15:9
+   |
+LL | fn c(_: Token) {}
+   |         ^^^^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `Token` could refer to the enum imported here
+  --> $DIR/ambiguous-10.rs:13:5
+   |
+LL | use crate::a::*;
+   |     ^^^^^^^^^^^
+   = help: consider adding an explicit import of `Token` to disambiguate
+note: `Token` could also refer to the enum imported here
+  --> $DIR/ambiguous-10.rs:14:5
+   |
+LL | use crate::b::*;
+   |     ^^^^^^^^^^^
+   = help: consider adding an explicit import of `Token` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-12.rs b/tests/ui/imports/ambiguous-12.rs
index a033b51f709..543396b8dfe 100644
--- a/tests/ui/imports/ambiguous-12.rs
+++ b/tests/ui/imports/ambiguous-12.rs
@@ -1,4 +1,3 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/pull/113099#issuecomment-1637022296
 
 macro_rules! m {
@@ -20,6 +19,6 @@ use crate::public::*;
 
 fn main() {
     b();
-    //~^ WARNING `b` is ambiguous
+    //~^ ERROR `b` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
diff --git a/tests/ui/imports/ambiguous-12.stderr b/tests/ui/imports/ambiguous-12.stderr
index 4725c38849c..273a4ed3c0f 100644
--- a/tests/ui/imports/ambiguous-12.stderr
+++ b/tests/ui/imports/ambiguous-12.stderr
@@ -1,5 +1,5 @@
-warning: `b` is ambiguous
-  --> $DIR/ambiguous-12.rs:22:5
+error: `b` is ambiguous
+  --> $DIR/ambiguous-12.rs:21:5
    |
 LL |     b();
    |     ^ ambiguous name
@@ -8,18 +8,42 @@ LL |     b();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `b` could refer to the function imported here
-  --> $DIR/ambiguous-12.rs:18:5
+  --> $DIR/ambiguous-12.rs:17:5
    |
 LL | use crate::ciphertext::*;
    |     ^^^^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `b` to disambiguate
 note: `b` could also refer to the function imported here
-  --> $DIR/ambiguous-12.rs:19:5
+  --> $DIR/ambiguous-12.rs:18:5
    |
 LL | use crate::public::*;
    |     ^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `b` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
+
+error: aborting due to 1 previous error
 
-warning: 1 warning emitted
+Future incompatibility report: Future breakage diagnostic:
+error: `b` is ambiguous
+  --> $DIR/ambiguous-12.rs:21:5
+   |
+LL |     b();
+   |     ^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `b` could refer to the function imported here
+  --> $DIR/ambiguous-12.rs:17:5
+   |
+LL | use crate::ciphertext::*;
+   |     ^^^^^^^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `b` to disambiguate
+note: `b` could also refer to the function imported here
+  --> $DIR/ambiguous-12.rs:18:5
+   |
+LL | use crate::public::*;
+   |     ^^^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `b` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-13.rs b/tests/ui/imports/ambiguous-13.rs
index 1ea04e05d57..3569dd5d9ad 100644
--- a/tests/ui/imports/ambiguous-13.rs
+++ b/tests/ui/imports/ambiguous-13.rs
@@ -1,4 +1,3 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/pull/113099#issuecomment-1637022296
 
 pub mod object {
@@ -17,6 +16,6 @@ use crate::object::*;
 use crate::content::*;
 
 fn a(_: Rect) {}
-//~^ WARNING `Rect` is ambiguous
+//~^ ERROR `Rect` is ambiguous
 //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 fn main() { }
diff --git a/tests/ui/imports/ambiguous-13.stderr b/tests/ui/imports/ambiguous-13.stderr
index 3e78100b658..c4a42c01c91 100644
--- a/tests/ui/imports/ambiguous-13.stderr
+++ b/tests/ui/imports/ambiguous-13.stderr
@@ -1,5 +1,5 @@
-warning: `Rect` is ambiguous
-  --> $DIR/ambiguous-13.rs:19:9
+error: `Rect` is ambiguous
+  --> $DIR/ambiguous-13.rs:18:9
    |
 LL | fn a(_: Rect) {}
    |         ^^^^ ambiguous name
@@ -8,18 +8,42 @@ LL | fn a(_: Rect) {}
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `Rect` could refer to the struct imported here
-  --> $DIR/ambiguous-13.rs:16:5
+  --> $DIR/ambiguous-13.rs:15:5
    |
 LL | use crate::object::*;
    |     ^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `Rect` to disambiguate
 note: `Rect` could also refer to the struct imported here
-  --> $DIR/ambiguous-13.rs:17:5
+  --> $DIR/ambiguous-13.rs:16:5
    |
 LL | use crate::content::*;
    |     ^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `Rect` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
+
+error: aborting due to 1 previous error
 
-warning: 1 warning emitted
+Future incompatibility report: Future breakage diagnostic:
+error: `Rect` is ambiguous
+  --> $DIR/ambiguous-13.rs:18:9
+   |
+LL | fn a(_: Rect) {}
+   |         ^^^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `Rect` could refer to the struct imported here
+  --> $DIR/ambiguous-13.rs:15:5
+   |
+LL | use crate::object::*;
+   |     ^^^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `Rect` to disambiguate
+note: `Rect` could also refer to the struct imported here
+  --> $DIR/ambiguous-13.rs:16:5
+   |
+LL | use crate::content::*;
+   |     ^^^^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `Rect` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-14.rs b/tests/ui/imports/ambiguous-14.rs
index 30d14be9d0e..f752387aa7e 100644
--- a/tests/ui/imports/ambiguous-14.rs
+++ b/tests/ui/imports/ambiguous-14.rs
@@ -1,4 +1,3 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/issues/98467
 
 mod a {
@@ -21,6 +20,6 @@ mod g {
 
 fn main() {
     g::foo();
-    //~^ WARNING `foo` is ambiguous
+    //~^ ERROR `foo` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
diff --git a/tests/ui/imports/ambiguous-14.stderr b/tests/ui/imports/ambiguous-14.stderr
index bece5853668..f3115f8c8b5 100644
--- a/tests/ui/imports/ambiguous-14.stderr
+++ b/tests/ui/imports/ambiguous-14.stderr
@@ -1,5 +1,5 @@
-warning: `foo` is ambiguous
-  --> $DIR/ambiguous-14.rs:23:8
+error: `foo` is ambiguous
+  --> $DIR/ambiguous-14.rs:22:8
    |
 LL |     g::foo();
    |        ^^^ ambiguous name
@@ -8,18 +8,42 @@ LL |     g::foo();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `foo` could refer to the function imported here
-  --> $DIR/ambiguous-14.rs:13:13
+  --> $DIR/ambiguous-14.rs:12:13
    |
 LL |     pub use a::*;
    |             ^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
 note: `foo` could also refer to the function imported here
-  --> $DIR/ambiguous-14.rs:14:13
+  --> $DIR/ambiguous-14.rs:13:13
    |
 LL |     pub use b::*;
    |             ^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
+
+error: aborting due to 1 previous error
 
-warning: 1 warning emitted
+Future incompatibility report: Future breakage diagnostic:
+error: `foo` is ambiguous
+  --> $DIR/ambiguous-14.rs:22:8
+   |
+LL |     g::foo();
+   |        ^^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `foo` could refer to the function imported here
+  --> $DIR/ambiguous-14.rs:12:13
+   |
+LL |     pub use a::*;
+   |             ^^^^
+   = help: consider adding an explicit import of `foo` to disambiguate
+note: `foo` could also refer to the function imported here
+  --> $DIR/ambiguous-14.rs:13:13
+   |
+LL |     pub use b::*;
+   |             ^^^^
+   = help: consider adding an explicit import of `foo` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-15.rs b/tests/ui/imports/ambiguous-15.rs
index b9e8f020d43..07d8893b2de 100644
--- a/tests/ui/imports/ambiguous-15.rs
+++ b/tests/ui/imports/ambiguous-15.rs
@@ -1,4 +1,3 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/pull/113099#issuecomment-1638206152
 
 mod t2 {
@@ -21,7 +20,7 @@ mod t3 {
 
 use self::t3::*;
 fn a<E: Error>(_: E) {}
-//~^ WARNING `Error` is ambiguous
+//~^ ERROR `Error` is ambiguous
 //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 fn main() {}
diff --git a/tests/ui/imports/ambiguous-15.stderr b/tests/ui/imports/ambiguous-15.stderr
index 838256752d0..1312f2c63c4 100644
--- a/tests/ui/imports/ambiguous-15.stderr
+++ b/tests/ui/imports/ambiguous-15.stderr
@@ -1,5 +1,5 @@
-warning: `Error` is ambiguous
-  --> $DIR/ambiguous-15.rs:23:9
+error: `Error` is ambiguous
+  --> $DIR/ambiguous-15.rs:22:9
    |
 LL | fn a<E: Error>(_: E) {}
    |         ^^^^^ ambiguous name
@@ -8,18 +8,42 @@ LL | fn a<E: Error>(_: E) {}
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `Error` could refer to the trait imported here
-  --> $DIR/ambiguous-15.rs:22:5
+  --> $DIR/ambiguous-15.rs:21:5
    |
 LL | use self::t3::*;
    |     ^^^^^^^^^^^
    = help: consider adding an explicit import of `Error` to disambiguate
 note: `Error` could also refer to the enum imported here
-  --> $DIR/ambiguous-15.rs:16:9
+  --> $DIR/ambiguous-15.rs:15:9
    |
 LL | pub use t2::*;
    |         ^^^^^
    = help: consider adding an explicit import of `Error` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
-warning: 1 warning emitted
+error: aborting due to 1 previous error
+
+Future incompatibility report: Future breakage diagnostic:
+error: `Error` is ambiguous
+  --> $DIR/ambiguous-15.rs:22:9
+   |
+LL | fn a<E: Error>(_: E) {}
+   |         ^^^^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `Error` could refer to the trait imported here
+  --> $DIR/ambiguous-15.rs:21:5
+   |
+LL | use self::t3::*;
+   |     ^^^^^^^^^^^
+   = help: consider adding an explicit import of `Error` to disambiguate
+note: `Error` could also refer to the enum imported here
+  --> $DIR/ambiguous-15.rs:15:9
+   |
+LL | pub use t2::*;
+   |         ^^^^^
+   = help: consider adding an explicit import of `Error` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-16.rs b/tests/ui/imports/ambiguous-16.rs
index ed30c9d241a..f31c78d18a3 100644
--- a/tests/ui/imports/ambiguous-16.rs
+++ b/tests/ui/imports/ambiguous-16.rs
@@ -1,4 +1,3 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/pull/113099
 
 mod framing {
@@ -21,7 +20,7 @@ mod framing {
 }
 
 use crate::framing::ConfirmedTranscriptHashInput;
-//~^ WARNING `ConfirmedTranscriptHashInput` is ambiguous
+//~^ ERROR `ConfirmedTranscriptHashInput` is ambiguous
 //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 fn main() { }
diff --git a/tests/ui/imports/ambiguous-16.stderr b/tests/ui/imports/ambiguous-16.stderr
index 7366cabc47a..ae65f9a84fc 100644
--- a/tests/ui/imports/ambiguous-16.stderr
+++ b/tests/ui/imports/ambiguous-16.stderr
@@ -1,5 +1,5 @@
-warning: `ConfirmedTranscriptHashInput` is ambiguous
-  --> $DIR/ambiguous-16.rs:23:21
+error: `ConfirmedTranscriptHashInput` is ambiguous
+  --> $DIR/ambiguous-16.rs:22:21
    |
 LL | use crate::framing::ConfirmedTranscriptHashInput;
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ambiguous name
@@ -8,18 +8,42 @@ LL | use crate::framing::ConfirmedTranscriptHashInput;
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `ConfirmedTranscriptHashInput` could refer to the struct imported here
-  --> $DIR/ambiguous-16.rs:19:13
+  --> $DIR/ambiguous-16.rs:18:13
    |
 LL |     pub use self::public_message::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `ConfirmedTranscriptHashInput` to disambiguate
 note: `ConfirmedTranscriptHashInput` could also refer to the struct imported here
-  --> $DIR/ambiguous-16.rs:20:13
+  --> $DIR/ambiguous-16.rs:19:13
    |
 LL |     pub use self::public_message_in::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `ConfirmedTranscriptHashInput` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
+
+error: aborting due to 1 previous error
 
-warning: 1 warning emitted
+Future incompatibility report: Future breakage diagnostic:
+error: `ConfirmedTranscriptHashInput` is ambiguous
+  --> $DIR/ambiguous-16.rs:22:21
+   |
+LL | use crate::framing::ConfirmedTranscriptHashInput;
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `ConfirmedTranscriptHashInput` could refer to the struct imported here
+  --> $DIR/ambiguous-16.rs:18:13
+   |
+LL |     pub use self::public_message::*;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `ConfirmedTranscriptHashInput` to disambiguate
+note: `ConfirmedTranscriptHashInput` could also refer to the struct imported here
+  --> $DIR/ambiguous-16.rs:19:13
+   |
+LL |     pub use self::public_message_in::*;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `ConfirmedTranscriptHashInput` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-17.rs b/tests/ui/imports/ambiguous-17.rs
index 28c9c1cc864..520ac70c6f1 100644
--- a/tests/ui/imports/ambiguous-17.rs
+++ b/tests/ui/imports/ambiguous-17.rs
@@ -1,4 +1,3 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/pull/113099#issuecomment-1638206152
 
 pub use evp::*; //~ WARNING ambiguous glob re-exports
@@ -24,6 +23,6 @@ mod handwritten {
 
 fn main() {
     id();
-    //~^ WARNING `id` is ambiguous
+    //~^ ERROR `id` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
diff --git a/tests/ui/imports/ambiguous-17.stderr b/tests/ui/imports/ambiguous-17.stderr
index 55bc01095c7..a87e2572d63 100644
--- a/tests/ui/imports/ambiguous-17.stderr
+++ b/tests/ui/imports/ambiguous-17.stderr
@@ -1,5 +1,5 @@
 warning: ambiguous glob re-exports
-  --> $DIR/ambiguous-17.rs:4:9
+  --> $DIR/ambiguous-17.rs:3:9
    |
 LL | pub use evp::*;
    |         ^^^^^^ the name `id` in the value namespace is first re-exported here
@@ -8,8 +8,8 @@ LL | pub use handwritten::*;
    |
    = note: `#[warn(ambiguous_glob_reexports)]` on by default
 
-warning: `id` is ambiguous
-  --> $DIR/ambiguous-17.rs:26:5
+error: `id` is ambiguous
+  --> $DIR/ambiguous-17.rs:25:5
    |
 LL |     id();
    |     ^^ ambiguous name
@@ -18,18 +18,42 @@ LL |     id();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `id` could refer to the function imported here
-  --> $DIR/ambiguous-17.rs:4:9
+  --> $DIR/ambiguous-17.rs:3:9
    |
 LL | pub use evp::*;
    |         ^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
 note: `id` could also refer to the function imported here
-  --> $DIR/ambiguous-17.rs:5:9
+  --> $DIR/ambiguous-17.rs:4:9
    |
 LL | pub use handwritten::*;
    |         ^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
-warning: 2 warnings emitted
+error: aborting due to 1 previous error; 1 warning emitted
+
+Future incompatibility report: Future breakage diagnostic:
+error: `id` is ambiguous
+  --> $DIR/ambiguous-17.rs:25:5
+   |
+LL |     id();
+   |     ^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `id` could refer to the function imported here
+  --> $DIR/ambiguous-17.rs:3:9
+   |
+LL | pub use evp::*;
+   |         ^^^^^^
+   = help: consider adding an explicit import of `id` to disambiguate
+note: `id` could also refer to the function imported here
+  --> $DIR/ambiguous-17.rs:4:9
+   |
+LL | pub use handwritten::*;
+   |         ^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `id` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-2.rs b/tests/ui/imports/ambiguous-2.rs
index 087431485ad..cffdcb9d922 100644
--- a/tests/ui/imports/ambiguous-2.rs
+++ b/tests/ui/imports/ambiguous-2.rs
@@ -1,4 +1,5 @@
-//@ check-pass
+//@ ignore-test
+// ^^ don't know how to change this test
 //@ aux-build: ../ambiguous-1.rs
 // https://github.com/rust-lang/rust/pull/113099#issuecomment-1633574396
 
diff --git a/tests/ui/imports/ambiguous-3.rs b/tests/ui/imports/ambiguous-3.rs
index aa98ffe395e..ff0dcc221ec 100644
--- a/tests/ui/imports/ambiguous-3.rs
+++ b/tests/ui/imports/ambiguous-3.rs
@@ -1,10 +1,9 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/issues/47525
 
 fn main() {
     use a::*;
     x();
-    //~^ WARNING `x` is ambiguous
+    //~^ ERROR `x` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
 
diff --git a/tests/ui/imports/ambiguous-3.stderr b/tests/ui/imports/ambiguous-3.stderr
index f019f6d8957..8766db5654a 100644
--- a/tests/ui/imports/ambiguous-3.stderr
+++ b/tests/ui/imports/ambiguous-3.stderr
@@ -1,5 +1,5 @@
-warning: `x` is ambiguous
-  --> $DIR/ambiguous-3.rs:6:5
+error: `x` is ambiguous
+  --> $DIR/ambiguous-3.rs:5:5
    |
 LL |     x();
    |     ^ ambiguous name
@@ -8,18 +8,42 @@ LL |     x();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `x` could refer to the function imported here
-  --> $DIR/ambiguous-3.rs:19:13
+  --> $DIR/ambiguous-3.rs:18:13
    |
 LL |     pub use self::b::*;
    |             ^^^^^^^^^^
    = help: consider adding an explicit import of `x` to disambiguate
 note: `x` could also refer to the function imported here
-  --> $DIR/ambiguous-3.rs:20:13
+  --> $DIR/ambiguous-3.rs:19:13
    |
 LL |     pub use self::c::*;
    |             ^^^^^^^^^^
    = help: consider adding an explicit import of `x` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
+
+error: aborting due to 1 previous error
 
-warning: 1 warning emitted
+Future incompatibility report: Future breakage diagnostic:
+error: `x` is ambiguous
+  --> $DIR/ambiguous-3.rs:5:5
+   |
+LL |     x();
+   |     ^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `x` could refer to the function imported here
+  --> $DIR/ambiguous-3.rs:18:13
+   |
+LL |     pub use self::b::*;
+   |             ^^^^^^^^^^
+   = help: consider adding an explicit import of `x` to disambiguate
+note: `x` could also refer to the function imported here
+  --> $DIR/ambiguous-3.rs:19:13
+   |
+LL |     pub use self::c::*;
+   |             ^^^^^^^^^^
+   = help: consider adding an explicit import of `x` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-4-extern.rs b/tests/ui/imports/ambiguous-4-extern.rs
index a045ab3d8a5..b70d0484801 100644
--- a/tests/ui/imports/ambiguous-4-extern.rs
+++ b/tests/ui/imports/ambiguous-4-extern.rs
@@ -1,4 +1,3 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/pull/112743#issuecomment-1601986883
 
 macro_rules! m {
@@ -21,6 +20,6 @@ mod handwritten {
 
 fn main() {
     id();
-    //~^ WARNING `id` is ambiguous
+    //~^ ERROR `id` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
diff --git a/tests/ui/imports/ambiguous-4-extern.stderr b/tests/ui/imports/ambiguous-4-extern.stderr
index 0011973212b..3e79c455c42 100644
--- a/tests/ui/imports/ambiguous-4-extern.stderr
+++ b/tests/ui/imports/ambiguous-4-extern.stderr
@@ -1,5 +1,5 @@
 warning: ambiguous glob re-exports
-  --> $DIR/ambiguous-4-extern.rs:10:9
+  --> $DIR/ambiguous-4-extern.rs:9:9
    |
 LL | pub use evp::*;
    |         ^^^^^^ the name `id` in the value namespace is first re-exported here
@@ -8,8 +8,8 @@ LL | pub use handwritten::*;
    |
    = note: `#[warn(ambiguous_glob_reexports)]` on by default
 
-warning: `id` is ambiguous
-  --> $DIR/ambiguous-4-extern.rs:23:5
+error: `id` is ambiguous
+  --> $DIR/ambiguous-4-extern.rs:22:5
    |
 LL |     id();
    |     ^^ ambiguous name
@@ -18,18 +18,42 @@ LL |     id();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `id` could refer to the function imported here
-  --> $DIR/ambiguous-4-extern.rs:10:9
+  --> $DIR/ambiguous-4-extern.rs:9:9
    |
 LL | pub use evp::*;
    |         ^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
 note: `id` could also refer to the function imported here
-  --> $DIR/ambiguous-4-extern.rs:11:9
+  --> $DIR/ambiguous-4-extern.rs:10:9
    |
 LL | pub use handwritten::*;
    |         ^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
-warning: 2 warnings emitted
+error: aborting due to 1 previous error; 1 warning emitted
+
+Future incompatibility report: Future breakage diagnostic:
+error: `id` is ambiguous
+  --> $DIR/ambiguous-4-extern.rs:22:5
+   |
+LL |     id();
+   |     ^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `id` could refer to the function imported here
+  --> $DIR/ambiguous-4-extern.rs:9:9
+   |
+LL | pub use evp::*;
+   |         ^^^^^^
+   = help: consider adding an explicit import of `id` to disambiguate
+note: `id` could also refer to the function imported here
+  --> $DIR/ambiguous-4-extern.rs:10:9
+   |
+LL | pub use handwritten::*;
+   |         ^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `id` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-4.rs b/tests/ui/imports/ambiguous-4.rs
index fcb7b5c6671..e367c120adf 100644
--- a/tests/ui/imports/ambiguous-4.rs
+++ b/tests/ui/imports/ambiguous-4.rs
@@ -1,4 +1,5 @@
-//@ build-pass
+//@ ignore-test
+// ^^ don't know how to change this test
 //@ aux-build: ../ambiguous-4-extern.rs
 
 extern crate ambiguous_4_extern;
diff --git a/tests/ui/imports/ambiguous-5.rs b/tests/ui/imports/ambiguous-5.rs
index 28447e10d1b..8f89c966d4a 100644
--- a/tests/ui/imports/ambiguous-5.rs
+++ b/tests/ui/imports/ambiguous-5.rs
@@ -1,4 +1,3 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/pull/113099#issuecomment-1637022296
 
 mod a {
@@ -11,7 +10,7 @@ mod gpos {
     use super::gsubgpos::*;
     use super::*;
     struct MarkRecord(Class);
-    //~^ WARNING `Class` is ambiguous
+    //~^ ERROR`Class` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
 
diff --git a/tests/ui/imports/ambiguous-5.stderr b/tests/ui/imports/ambiguous-5.stderr
index 4bc35f86d3a..41c15809351 100644
--- a/tests/ui/imports/ambiguous-5.stderr
+++ b/tests/ui/imports/ambiguous-5.stderr
@@ -1,5 +1,5 @@
-warning: `Class` is ambiguous
-  --> $DIR/ambiguous-5.rs:13:23
+error: `Class` is ambiguous
+  --> $DIR/ambiguous-5.rs:12:23
    |
 LL |     struct MarkRecord(Class);
    |                       ^^^^^ ambiguous name
@@ -8,18 +8,42 @@ LL |     struct MarkRecord(Class);
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `Class` could refer to the struct imported here
-  --> $DIR/ambiguous-5.rs:12:9
+  --> $DIR/ambiguous-5.rs:11:9
    |
 LL |     use super::*;
    |         ^^^^^^^^
    = help: consider adding an explicit import of `Class` to disambiguate
 note: `Class` could also refer to the struct imported here
-  --> $DIR/ambiguous-5.rs:11:9
+  --> $DIR/ambiguous-5.rs:10:9
    |
 LL |     use super::gsubgpos::*;
    |         ^^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `Class` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
+
+error: aborting due to 1 previous error
 
-warning: 1 warning emitted
+Future incompatibility report: Future breakage diagnostic:
+error: `Class` is ambiguous
+  --> $DIR/ambiguous-5.rs:12:23
+   |
+LL |     struct MarkRecord(Class);
+   |                       ^^^^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `Class` could refer to the struct imported here
+  --> $DIR/ambiguous-5.rs:11:9
+   |
+LL |     use super::*;
+   |         ^^^^^^^^
+   = help: consider adding an explicit import of `Class` to disambiguate
+note: `Class` could also refer to the struct imported here
+  --> $DIR/ambiguous-5.rs:10:9
+   |
+LL |     use super::gsubgpos::*;
+   |         ^^^^^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `Class` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-6.rs b/tests/ui/imports/ambiguous-6.rs
index 955cdc3854f..1c6e3437716 100644
--- a/tests/ui/imports/ambiguous-6.rs
+++ b/tests/ui/imports/ambiguous-6.rs
@@ -1,11 +1,10 @@
-//@ check-pass
 //@ edition: 2021
 // https://github.com/rust-lang/rust/issues/112713
 
 pub fn foo() -> u32 {
     use sub::*;
     C
-    //~^ WARNING `C` is ambiguous
+    //~^ ERROR `C` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
 
diff --git a/tests/ui/imports/ambiguous-6.stderr b/tests/ui/imports/ambiguous-6.stderr
index d7871a0b8cb..d988126dbfb 100644
--- a/tests/ui/imports/ambiguous-6.stderr
+++ b/tests/ui/imports/ambiguous-6.stderr
@@ -1,5 +1,5 @@
-warning: `C` is ambiguous
-  --> $DIR/ambiguous-6.rs:7:5
+error: `C` is ambiguous
+  --> $DIR/ambiguous-6.rs:6:5
    |
 LL |     C
    |     ^ ambiguous name
@@ -8,18 +8,42 @@ LL |     C
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `C` could refer to the constant imported here
-  --> $DIR/ambiguous-6.rs:16:13
+  --> $DIR/ambiguous-6.rs:15:13
    |
 LL |     pub use mod1::*;
    |             ^^^^^^^
    = help: consider adding an explicit import of `C` to disambiguate
 note: `C` could also refer to the constant imported here
-  --> $DIR/ambiguous-6.rs:17:13
+  --> $DIR/ambiguous-6.rs:16:13
    |
 LL |     pub use mod2::*;
    |             ^^^^^^^
    = help: consider adding an explicit import of `C` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
+
+error: aborting due to 1 previous error
 
-warning: 1 warning emitted
+Future incompatibility report: Future breakage diagnostic:
+error: `C` is ambiguous
+  --> $DIR/ambiguous-6.rs:6:5
+   |
+LL |     C
+   |     ^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `C` could refer to the constant imported here
+  --> $DIR/ambiguous-6.rs:15:13
+   |
+LL |     pub use mod1::*;
+   |             ^^^^^^^
+   = help: consider adding an explicit import of `C` to disambiguate
+note: `C` could also refer to the constant imported here
+  --> $DIR/ambiguous-6.rs:16:13
+   |
+LL |     pub use mod2::*;
+   |             ^^^^^^^
+   = help: consider adding an explicit import of `C` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/ambiguous-9.rs b/tests/ui/imports/ambiguous-9.rs
index 97321512df0..c10b1268060 100644
--- a/tests/ui/imports/ambiguous-9.rs
+++ b/tests/ui/imports/ambiguous-9.rs
@@ -1,4 +1,3 @@
-//@ check-pass
 // https://github.com/rust-lang/rust/pull/113099#issuecomment-1638206152
 
 pub mod dsl {
@@ -22,8 +21,8 @@ use prelude::*;
 
 fn main() {
     date_range();
-    //~^ WARNING `date_range` is ambiguous
+    //~^ ERROR `date_range` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-    //~| WARNING `date_range` is ambiguous
+    //~| ERROR `date_range` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
diff --git a/tests/ui/imports/ambiguous-9.stderr b/tests/ui/imports/ambiguous-9.stderr
index 6c7d79174da..1c4768da827 100644
--- a/tests/ui/imports/ambiguous-9.stderr
+++ b/tests/ui/imports/ambiguous-9.stderr
@@ -1,5 +1,5 @@
 warning: ambiguous glob re-exports
-  --> $DIR/ambiguous-9.rs:8:13
+  --> $DIR/ambiguous-9.rs:7:13
    |
 LL |     pub use self::range::*;
    |             ^^^^^^^^^^^^^^ the name `date_range` in the value namespace is first re-exported here
@@ -8,8 +8,8 @@ LL |     use super::prelude::*;
    |
    = note: `#[warn(ambiguous_glob_reexports)]` on by default
 
-warning: `date_range` is ambiguous
-  --> $DIR/ambiguous-9.rs:24:5
+error: `date_range` is ambiguous
+  --> $DIR/ambiguous-9.rs:23:5
    |
 LL |     date_range();
    |     ^^^^^^^^^^ ambiguous name
@@ -18,29 +18,29 @@ LL |     date_range();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `date_range` could refer to the function imported here
-  --> $DIR/ambiguous-9.rs:8:13
+  --> $DIR/ambiguous-9.rs:7:13
    |
 LL |     pub use self::range::*;
    |             ^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `date_range` to disambiguate
 note: `date_range` could also refer to the function imported here
-  --> $DIR/ambiguous-9.rs:9:9
+  --> $DIR/ambiguous-9.rs:8:9
    |
 LL |     use super::prelude::*;
    |         ^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `date_range` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
 warning: ambiguous glob re-exports
-  --> $DIR/ambiguous-9.rs:16:13
+  --> $DIR/ambiguous-9.rs:15:13
    |
 LL |     pub use self::t::*;
    |             ^^^^^^^^^^ the name `date_range` in the value namespace is first re-exported here
 LL |     pub use super::dsl::*;
    |             ------------- but the name `date_range` in the value namespace is also re-exported here
 
-warning: `date_range` is ambiguous
-  --> $DIR/ambiguous-9.rs:24:5
+error: `date_range` is ambiguous
+  --> $DIR/ambiguous-9.rs:23:5
    |
 LL |     date_range();
    |     ^^^^^^^^^^ ambiguous name
@@ -49,17 +49,65 @@ LL |     date_range();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `date_range` could refer to the function imported here
-  --> $DIR/ambiguous-9.rs:20:5
+  --> $DIR/ambiguous-9.rs:19:5
    |
 LL | use dsl::*;
    |     ^^^^^^
    = help: consider adding an explicit import of `date_range` to disambiguate
 note: `date_range` could also refer to the function imported here
-  --> $DIR/ambiguous-9.rs:21:5
+  --> $DIR/ambiguous-9.rs:20:5
    |
 LL | use prelude::*;
    |     ^^^^^^^^^^
    = help: consider adding an explicit import of `date_range` to disambiguate
 
-warning: 4 warnings emitted
+error: aborting due to 2 previous errors; 2 warnings emitted
+
+Future incompatibility report: Future breakage diagnostic:
+error: `date_range` is ambiguous
+  --> $DIR/ambiguous-9.rs:23:5
+   |
+LL |     date_range();
+   |     ^^^^^^^^^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `date_range` could refer to the function imported here
+  --> $DIR/ambiguous-9.rs:7:13
+   |
+LL |     pub use self::range::*;
+   |             ^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `date_range` to disambiguate
+note: `date_range` could also refer to the function imported here
+  --> $DIR/ambiguous-9.rs:8:9
+   |
+LL |     use super::prelude::*;
+   |         ^^^^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `date_range` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
+
+Future breakage diagnostic:
+error: `date_range` is ambiguous
+  --> $DIR/ambiguous-9.rs:23:5
+   |
+LL |     date_range();
+   |     ^^^^^^^^^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `date_range` could refer to the function imported here
+  --> $DIR/ambiguous-9.rs:19:5
+   |
+LL | use dsl::*;
+   |     ^^^^^^
+   = help: consider adding an explicit import of `date_range` to disambiguate
+note: `date_range` could also refer to the function imported here
+  --> $DIR/ambiguous-9.rs:20:5
+   |
+LL | use prelude::*;
+   |     ^^^^^^^^^^
+   = help: consider adding an explicit import of `date_range` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
diff --git a/tests/ui/imports/duplicate.rs b/tests/ui/imports/duplicate.rs
index 69ec82aafbd..0a652889ca8 100644
--- a/tests/ui/imports/duplicate.rs
+++ b/tests/ui/imports/duplicate.rs
@@ -34,7 +34,7 @@ fn main() {
     e::foo();
     f::foo(); //~ ERROR `foo` is ambiguous
     g::foo();
-    //~^ WARNING `foo` is ambiguous
+    //~^ ERROR `foo` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
 
diff --git a/tests/ui/imports/duplicate.stderr b/tests/ui/imports/duplicate.stderr
index f7dc7312b9d..ef987d07c04 100644
--- a/tests/ui/imports/duplicate.stderr
+++ b/tests/ui/imports/duplicate.stderr
@@ -68,7 +68,7 @@ LL |     use self::m2::*;
    |         ^^^^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
 
-warning: `foo` is ambiguous
+error: `foo` is ambiguous
   --> $DIR/duplicate.rs:36:8
    |
 LL |     g::foo();
@@ -89,9 +89,33 @@ note: `foo` could also refer to the function imported here
 LL |     pub use crate::b::*;
    |             ^^^^^^^^^^^
    = help: consider adding an explicit import of `foo` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
-error: aborting due to 4 previous errors; 1 warning emitted
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0252, E0659.
 For more information about an error, try `rustc --explain E0252`.
+Future incompatibility report: Future breakage diagnostic:
+error: `foo` is ambiguous
+  --> $DIR/duplicate.rs:36:8
+   |
+LL |     g::foo();
+   |        ^^^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `foo` could refer to the function imported here
+  --> $DIR/duplicate.rs:24:13
+   |
+LL |     pub use crate::a::*;
+   |             ^^^^^^^^^^^
+   = help: consider adding an explicit import of `foo` to disambiguate
+note: `foo` could also refer to the function imported here
+  --> $DIR/duplicate.rs:25:13
+   |
+LL |     pub use crate::b::*;
+   |             ^^^^^^^^^^^
+   = help: consider adding an explicit import of `foo` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
+
diff --git a/tests/ui/imports/unresolved-seg-after-ambiguous.rs b/tests/ui/imports/unresolved-seg-after-ambiguous.rs
index dcabc528a85..67366deabaa 100644
--- a/tests/ui/imports/unresolved-seg-after-ambiguous.rs
+++ b/tests/ui/imports/unresolved-seg-after-ambiguous.rs
@@ -18,7 +18,7 @@ mod a {
 
 use self::a::E::in_exist;
 //~^ ERROR: unresolved import `self::a::E`
-//~| WARNING: `E` is ambiguous
+//~| ERROR: `E` is ambiguous
 //~| WARNING: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 fn main() {}
diff --git a/tests/ui/imports/unresolved-seg-after-ambiguous.stderr b/tests/ui/imports/unresolved-seg-after-ambiguous.stderr
index 9e0efd4a75f..3b50ae32683 100644
--- a/tests/ui/imports/unresolved-seg-after-ambiguous.stderr
+++ b/tests/ui/imports/unresolved-seg-after-ambiguous.stderr
@@ -4,7 +4,7 @@ error[E0432]: unresolved import `self::a::E`
 LL | use self::a::E::in_exist;
    |              ^ `E` is a struct, not a module
 
-warning: `E` is ambiguous
+error: `E` is ambiguous
   --> $DIR/unresolved-seg-after-ambiguous.rs:19:14
    |
 LL | use self::a::E::in_exist;
@@ -25,8 +25,32 @@ note: `E` could also refer to the struct imported here
 LL |         pub use self::d::*;
    |                 ^^^^^^^^^^
    = help: consider adding an explicit import of `E` to disambiguate
-   = note: `#[warn(ambiguous_glob_imports)]` on by default
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
 
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0432`.
+Future incompatibility report: Future breakage diagnostic:
+error: `E` is ambiguous
+  --> $DIR/unresolved-seg-after-ambiguous.rs:19:14
+   |
+LL | use self::a::E::in_exist;
+   |              ^ ambiguous name
+   |
+   = 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 #114095 <https://github.com/rust-lang/rust/issues/114095>
+   = note: ambiguous because of multiple glob imports of a name in the same module
+note: `E` could refer to the struct imported here
+  --> $DIR/unresolved-seg-after-ambiguous.rs:13:17
+   |
+LL |         pub use self::c::*;
+   |                 ^^^^^^^^^^
+   = help: consider adding an explicit import of `E` to disambiguate
+note: `E` could also refer to the struct imported here
+  --> $DIR/unresolved-seg-after-ambiguous.rs:12:17
+   |
+LL |         pub use self::d::*;
+   |                 ^^^^^^^^^^
+   = help: consider adding an explicit import of `E` to disambiguate
+   = note: `#[deny(ambiguous_glob_imports)]` on by default
+
-- 
cgit 1.4.1-3-g733a5


From ecb397a3650d9a6001a2c3a7b51f395c1625727a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Wed, 25 Jun 2025 20:39:14 +0200
Subject: Reduce page size and number of DOM elements on clippy lints page

---
 util/gh-pages/index_template.html | 28 ++++++++++++----------------
 util/gh-pages/style.css           | 19 +++++++++++++++++--
 2 files changed, 29 insertions(+), 18 deletions(-)

diff --git a/util/gh-pages/index_template.html b/util/gh-pages/index_template.html
index 865b9523c39..458f20d9f99 100644
--- a/util/gh-pages/index_template.html
+++ b/util/gh-pages/index_template.html
@@ -149,25 +149,21 @@ Otherwise, have a great day =^.^=
                 <article class="panel panel-default" id="{{lint.id}}"> {# #}
                     <input id="label-{{lint.id}}" type="checkbox"> {# #}
                     <label for="label-{{lint.id}}"> {# #}
-                        <header class="panel-heading"> {# #}
-                            <h2 class="panel-title"> {# #}
-                                <div class="panel-title-name" id="lint-{{lint.id}}"> {# #}
-                                    <span>{{lint.id}}</span> {#+ #}
-                                    <a href="#{{lint.id}}" class="lint-anchor anchor label label-default">&para;</a> {#+ #}
-                                    <a href="" class="copy-to-clipboard anchor label label-default"> {# #}
-                                        &#128203; {# #}
-                                    </a> {# #}
-                                </div> {# #}
+                        <h2 class="lint-title"> {# #}
+                            <div class="panel-title-name" id="lint-{{lint.id}}"> {# #}
+                                <span>{{lint.id}}</span> {#+ #}
+                                <a href="#{{lint.id}}" class="lint-anchor anchor label label-default">&para;</a> {#+ #}
+                                <a href="" class="copy-to-clipboard anchor label label-default"> {# #}
+                                    &#128203; {# #}
+                                </a> {# #}
+                            </div> {# #}
 
-                                <div class="panel-title-addons"> {# #}
-                                    <span class="label label-lint-group label-default label-group-{{lint.group}}">{{lint.group}}</span> {#+ #}
+                            <span class="label label-lint-group label-default label-group-{{lint.group}}">{{lint.group}}</span> {#+ #}
 
-                                    <span class="label label-lint-level label-lint-level-{{lint.level}}">{{lint.level}}</span> {#+ #}
+                            <span class="label label-lint-level label-lint-level-{{lint.level}}">{{lint.level}}</span> {#+ #}
 
-                                    <span class="label label-doc-folding"></span> {# #}
-                                </div> {# #}
-                            </h2> {# #}
-                        </header> {# #}
+                            <span class="label label-doc-folding"></span> {# #}
+                        </h2> {# #}
                     </label> {# #}
 
                     <div class="list-group lint-docs"> {# #}
diff --git a/util/gh-pages/style.css b/util/gh-pages/style.css
index 3cc7a919c23..046a2a5df7c 100644
--- a/util/gh-pages/style.css
+++ b/util/gh-pages/style.css
@@ -50,8 +50,23 @@ div.panel div.panel-body  button.open {
 
 .panel-heading { cursor: pointer; }
 
-.panel-title { display: flex; flex-wrap: wrap;}
-.panel-title .label { display: inline-block; }
+.lint-title {
+    cursor: pointer;
+    margin-top: 0;
+    margin-bottom: 0;
+    font-size: 16px;
+    display: flex;
+    flex-wrap: wrap;
+    background: var(--theme-hover);
+    color: var(--fg);
+    border: 1px solid var(--theme-popup-border);
+    padding: 10px 15px;
+    border-top-left-radius: 3px;
+    border-top-right-radius: 3px;
+    gap: 4px;
+}
+
+.lint-title .label { display: inline-block; }
 
 .panel-title-name { flex: 1; min-width: 400px;}
 .panel-title-name span { vertical-align: bottom; }
-- 
cgit 1.4.1-3-g733a5


From 0c0a4d559263cb56e96825be356b540d380d13d4 Mon Sep 17 00:00:00 2001
From: Chengxu Bian <cbian564@gmail.com>
Date: Wed, 25 Jun 2025 20:32:22 -0400
Subject: fix closure and refactor tooling code

---
 clippy_lints/src/floating_point_arithmetic.rs | 66 ++-------------------
 clippy_utils/src/hir_utils.rs                 | 82 ++++++++++++++++++++++++---
 clippy_utils/src/lib.rs                       |  3 +-
 clippy_utils/src/visitors.rs                  | 10 ++--
 tests/ui/floating_point_mul_add.fixed         | 10 ++++
 tests/ui/floating_point_mul_add.rs            | 10 ++++
 tests/ui/floating_point_mul_add.stderr        | 18 ++----
 7 files changed, 112 insertions(+), 87 deletions(-)

diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 39b8e8c54fa..d5abaa547e8 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -2,13 +2,12 @@ use clippy_utils::consts::Constant::{F32, F64, Int};
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::{
-    eq_expr_value, get_parent_expr, higher, is_in_const_context, is_inherent_method_call, is_no_std_crate,
-    numeric_literal, peel_blocks, sugg, sym,
+    eq_expr_value, get_parent_expr, has_ambiguous_literal_in_expr, higher, is_in_const_context,
+    is_inherent_method_call, is_no_std_crate, numeric_literal, peel_blocks, sugg, sym,
 };
 use rustc_ast::ast;
 use rustc_errors::Applicability;
-use rustc_hir::def::Res;
-use rustc_hir::{BinOpKind, Expr, ExprKind, Node, PathSegment, UnOp};
+use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
@@ -456,61 +455,6 @@ fn is_float_mul_expr<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(&'
     None
 }
 
-// Check if any variable in an expression has an ambiguous type (could be f32 or f64)
-fn has_ambiguous_float_type(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    match &expr.kind {
-        ExprKind::Path(qpath) => {
-            if let Res::Local(hir_id) = cx.qpath_res(qpath, expr.hir_id) {
-                if let Node::LetStmt(local) = cx.tcx.parent_hir_node(hir_id) {
-                    // If the local has no type annotation, check if the initializer has ambiguous float literals
-                    if local.ty.is_none() {
-                        if let Some(init) = local.init {
-                            return has_ambiguous_float_literal_in_expr(cx, init);
-                        }
-                    }
-                }
-            }
-            false
-        },
-        _ => false, // only check path
-    }
-}
-
-// Recursively check if an expression contains any unsuffixed float literals
-fn has_ambiguous_float_literal_in_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    match &expr.kind {
-        ExprKind::Lit(lit) => {
-            if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node {
-                return true;
-            }
-            false
-        },
-        ExprKind::Binary(_, lhs, rhs) => {
-            has_ambiguous_float_literal_in_expr(cx, lhs) || has_ambiguous_float_literal_in_expr(cx, rhs)
-        },
-        ExprKind::Unary(_, expr) => has_ambiguous_float_literal_in_expr(cx, expr),
-        ExprKind::If(_, then, else_) => {
-            has_ambiguous_float_literal_in_expr(cx, then)
-                || else_
-                    .as_ref()
-                    .map_or(false, |else_expr| has_ambiguous_float_literal_in_expr(cx, else_expr))
-        },
-        ExprKind::Block(block, _) => block
-            .expr
-            .as_ref()
-            .map_or(false, |expr| has_ambiguous_float_literal_in_expr(cx, expr)),
-        ExprKind::MethodCall(_, receiver, args, _) => {
-            has_ambiguous_float_literal_in_expr(cx, receiver)
-                || args.iter().any(|arg| has_ambiguous_float_literal_in_expr(cx, arg))
-        },
-        ExprKind::Call(func, args) => {
-            has_ambiguous_float_literal_in_expr(cx, func)
-                || args.iter().any(|arg| has_ambiguous_float_literal_in_expr(cx, arg))
-        },
-        _ => false,
-    }
-}
-
 fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if let ExprKind::Binary(
         Spanned {
@@ -548,7 +492,9 @@ fn check_mul_add(cx: &LateContext<'_>, expr: &Expr<'_>) {
 
         // 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 has_ambiguous_float_type(cx, recv) {
+        if (matches!(recv.kind, ExprKind::Path(_)) || matches!(recv.kind, ExprKind::Call(_, _)))
+            && has_ambiguous_literal_in_expr(cx, recv)
+        {
             return;
         }
 
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index c37231d0931..e249f87058d 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -2,6 +2,7 @@ use crate::consts::ConstEvalCtxt;
 use crate::macros::macro_backtrace;
 use crate::source::{SpanRange, SpanRangeExt, walk_span_to_context};
 use crate::tokenize_with_text;
+use rustc_ast::ast;
 use rustc_ast::ast::InlineAsmTemplatePiece;
 use rustc_data_structures::fx::FxHasher;
 use rustc_hir::MatchSource::TryDesugar;
@@ -9,8 +10,8 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{
     AssocItemConstraint, BinOpKind, BindingMode, Block, BodyId, Closure, ConstArg, ConstArgKind, Expr, ExprField,
     ExprKind, FnRetTy, GenericArg, GenericArgs, HirId, HirIdMap, InlineAsmOperand, LetExpr, Lifetime, LifetimeKind,
-    Pat, PatExpr, PatExprKind, PatField, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, StructTailExpr,
-    TraitBoundModifiers, Ty, TyKind, TyPat, TyPatKind,
+    Node, Pat, PatExpr, PatExprKind, PatField, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind,
+    StructTailExpr, TraitBoundModifiers, Ty, TyKind, TyPat, TyPatKind,
 };
 use rustc_lexer::{TokenKind, tokenize};
 use rustc_lint::LateContext;
@@ -1004,8 +1005,8 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     self.hash_expr(e);
                 }
             },
-            ExprKind::Match(e, arms, s) => {
-                self.hash_expr(e);
+            ExprKind::Match(scrutinee, arms, _) => {
+                self.hash_expr(scrutinee);
 
                 for arm in *arms {
                     self.hash_pat(arm.pat);
@@ -1014,8 +1015,6 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                     }
                     self.hash_expr(arm.body);
                 }
-
-                s.hash(&mut self.s);
             },
             ExprKind::MethodCall(path, receiver, args, _fn_span) => {
                 self.hash_name(path.ident.name);
@@ -1058,8 +1057,8 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
             ExprKind::Use(expr, _) => {
                 self.hash_expr(expr);
             },
-            ExprKind::Unary(lop, le) => {
-                std::mem::discriminant(lop).hash(&mut self.s);
+            ExprKind::Unary(l_op, le) => {
+                std::mem::discriminant(l_op).hash(&mut self.s);
                 self.hash_expr(le);
             },
             ExprKind::UnsafeBinderCast(kind, expr, ty) => {
@@ -1394,3 +1393,70 @@ fn eq_span_tokens(
     }
     f(cx, left.into_range(), right.into_range(), pred)
 }
+
+/// Returns true if the expression contains ambiguous literals (unsuffixed float or int literals)
+/// that could be interpreted as either f32/f64 or i32/i64 depending on context.
+pub fn has_ambiguous_literal_in_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Path(ref qpath) => {
+            if let Res::Local(hir_id) = cx.qpath_res(qpath, expr.hir_id)
+                && let Node::LetStmt(local) = cx.tcx.parent_hir_node(hir_id)
+                && local.ty.is_none()
+                && let Some(init) = local.init
+            {
+                return has_ambiguous_literal_in_expr(cx, init);
+            }
+            false
+        },
+        ExprKind::Lit(lit) => matches!(
+            lit.node,
+            ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) | ast::LitKind::Int(_, ast::LitIntType::Unsuffixed)
+        ),
+
+        ExprKind::Array(exprs) | ExprKind::Tup(exprs) => exprs.iter().any(|e| has_ambiguous_literal_in_expr(cx, e)),
+
+        ExprKind::Assign(lhs, rhs, _) | ExprKind::AssignOp(_, lhs, rhs) | ExprKind::Binary(_, lhs, rhs) => {
+            has_ambiguous_literal_in_expr(cx, lhs) || has_ambiguous_literal_in_expr(cx, rhs)
+        },
+
+        ExprKind::Unary(_, e)
+        | ExprKind::Cast(e, _)
+        | ExprKind::Type(e, _)
+        | ExprKind::DropTemps(e)
+        | ExprKind::AddrOf(_, _, e)
+        | ExprKind::Field(e, _)
+        | ExprKind::Index(e, _, _)
+        | ExprKind::Yield(e, _) => has_ambiguous_literal_in_expr(cx, e),
+
+        ExprKind::MethodCall(_, receiver, args, _) | ExprKind::Call(receiver, args) => {
+            has_ambiguous_literal_in_expr(cx, receiver) || args.iter().any(|e| has_ambiguous_literal_in_expr(cx, e))
+        },
+
+        ExprKind::Closure(Closure { body, .. }) => {
+            let body = cx.tcx.hir_body(*body);
+            let closure_expr = crate::peel_blocks(body.value);
+            has_ambiguous_literal_in_expr(cx, closure_expr)
+        },
+
+        ExprKind::Block(blk, _) => blk.expr.as_ref().is_some_and(|e| has_ambiguous_literal_in_expr(cx, e)),
+
+        ExprKind::If(cond, then_expr, else_expr) => {
+            has_ambiguous_literal_in_expr(cx, cond)
+                || has_ambiguous_literal_in_expr(cx, then_expr)
+                || else_expr.as_ref().is_some_and(|e| has_ambiguous_literal_in_expr(cx, e))
+        },
+
+        ExprKind::Match(scrutinee, arms, _) => {
+            has_ambiguous_literal_in_expr(cx, scrutinee)
+                || arms.iter().any(|arm| has_ambiguous_literal_in_expr(cx, arm.body))
+        },
+
+        ExprKind::Loop(body, ..) => body.expr.is_some_and(|e| has_ambiguous_literal_in_expr(cx, e)),
+
+        ExprKind::Ret(opt_expr) | ExprKind::Break(_, opt_expr) => {
+            opt_expr.as_ref().is_some_and(|e| has_ambiguous_literal_in_expr(cx, e))
+        },
+
+        _ => false,
+    }
+}
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 7fa52229fef..ade839cd441 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -77,7 +77,8 @@ pub mod visitors;
 pub use self::attrs::*;
 pub use self::check_proc_macro::{is_from_proc_macro, is_span_if, is_span_match};
 pub use self::hir_utils::{
-    HirEqInterExpr, SpanlessEq, SpanlessHash, both, count_eq, eq_expr_value, hash_expr, hash_stmt, is_bool, over,
+    HirEqInterExpr, SpanlessEq, SpanlessHash, both, count_eq, eq_expr_value, has_ambiguous_literal_in_expr, hash_expr,
+    hash_stmt, is_bool, over,
 };
 
 use core::mem;
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index fc6e30a9804..48f1c36117c 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -353,7 +353,7 @@ pub fn is_const_evaluatable<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) ->
                 ExprKind::Binary(_, lhs, rhs)
                     if self.cx.typeck_results().expr_ty(lhs).peel_refs().is_primitive_ty()
                         && self.cx.typeck_results().expr_ty(rhs).peel_refs().is_primitive_ty() => {},
-                ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results().expr_ty(e).is_ref() => (),
+                ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results().expr_ty(e).is_raw_ptr() => (),
                 ExprKind::Unary(_, e) if self.cx.typeck_results().expr_ty(e).peel_refs().is_primitive_ty() => (),
                 ExprKind::Index(base, _, _)
                     if matches!(
@@ -388,7 +388,8 @@ pub fn is_const_evaluatable<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) ->
                 | ExprKind::Repeat(..)
                 | ExprKind::Struct(..)
                 | ExprKind::Tup(_)
-                | ExprKind::Type(..) => (),
+                | ExprKind::Type(..)
+                | ExprKind::UnsafeBinderCast(..) => (),
 
                 _ => {
                     return ControlFlow::Break(());
@@ -676,10 +677,7 @@ pub fn for_each_unconsumed_temporary<'tcx, B>(
                     helper(typeck, true, else_expr, f)?;
                 }
             },
-            ExprKind::Type(e, _) => {
-                helper(typeck, consume, e, f)?;
-            },
-            ExprKind::UnsafeBinderCast(_, e, _) => {
+            ExprKind::Type(e, _) | ExprKind::UnsafeBinderCast(_, e, _) => {
                 helper(typeck, consume, e, f)?;
             },
 
diff --git a/tests/ui/floating_point_mul_add.fixed b/tests/ui/floating_point_mul_add.fixed
index b07f3a6cc69..884bae00432 100644
--- a/tests/ui/floating_point_mul_add.fixed
+++ b/tests/ui/floating_point_mul_add.fixed
@@ -89,6 +89,16 @@ fn _issue14897() {
     let x = 2.4 + 1.2;
     let _ = 0.5 + x * 1.2; // should not suggest mul_add
 
+    let f = || 4.0;
+    let x = f();
+    let _ = 0.5 + f() * 1.2; // should not suggest mul_add
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
+
+    let x = 0.1;
+    let y = x;
+    let z = y;
+    let _ = 0.5 + z * 1.2; // should not suggest mul_add
+
     let _ = 2.0f64.mul_add(x, 0.5);
     //~^ suboptimal_flops
     let _ = 2.0f64.mul_add(x, 0.5);
diff --git a/tests/ui/floating_point_mul_add.rs b/tests/ui/floating_point_mul_add.rs
index 8af9c51f271..9ceb2ec9606 100644
--- a/tests/ui/floating_point_mul_add.rs
+++ b/tests/ui/floating_point_mul_add.rs
@@ -89,6 +89,16 @@ fn _issue14897() {
     let x = 2.4 + 1.2;
     let _ = 0.5 + x * 1.2; // should not suggest mul_add
 
+    let f = || 4.0;
+    let x = f();
+    let _ = 0.5 + f() * 1.2; // should not suggest mul_add
+    let _ = 0.5 + x * 1.2; // should not suggest mul_add
+
+    let x = 0.1;
+    let y = x;
+    let z = y;
+    let _ = 0.5 + z * 1.2; // should not suggest mul_add
+
     let _ = 0.5 + 2.0 * x;
     //~^ suboptimal_flops
     let _ = 2.0 * x + 0.5;
diff --git a/tests/ui/floating_point_mul_add.stderr b/tests/ui/floating_point_mul_add.stderr
index 80d08c7de73..dad65ddf2ec 100644
--- a/tests/ui/floating_point_mul_add.stderr
+++ b/tests/ui/floating_point_mul_add.stderr
@@ -80,40 +80,34 @@ LL |     let _ = a - (b * u as f64);
    |             ^^^^^^^^^^^^^^^^^^ help: consider using: `b.mul_add(-(u as f64), a)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:85:13
-   |
-LL |     let _ = 0.5 + x * 1.2; // should not suggest mul_add
-   |             ^^^^^^^^^^^^^ help: consider using: `x.mul_add(1.2, 0.5)`
-
-error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:96:13
+  --> tests/ui/floating_point_mul_add.rs:102:13
    |
 LL |     let _ = 0.5 + 2.0 * x;
    |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(x, 0.5)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:98:13
+  --> tests/ui/floating_point_mul_add.rs:104:13
    |
 LL |     let _ = 2.0 * x + 0.5;
    |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(x, 0.5)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:101:13
+  --> tests/ui/floating_point_mul_add.rs:107:13
    |
 LL |     let _ = x + 2.0 * 4.0;
    |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4.0, x)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:105:13
+  --> tests/ui/floating_point_mul_add.rs:111:13
    |
 LL |     let _ = y * 2.0 + 0.5;
    |             ^^^^^^^^^^^^^ help: consider using: `y.mul_add(2.0, 0.5)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:107:13
+  --> tests/ui/floating_point_mul_add.rs:113:13
    |
 LL |     let _ = 1.0 * 2.0 + 0.5;
    |             ^^^^^^^^^^^^^^^ help: consider using: `1.0f64.mul_add(2.0, 0.5)`
 
-error: aborting due to 19 previous errors
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9b4231dcd9c691a07e1507c7824c6d339716c6ab Mon Sep 17 00:00:00 2001
From: Chengxu Bian <cbian564@gmail.com>
Date: Wed, 25 Jun 2025 22:00:05 -0400
Subject: fix redudant closure broken fix

---
 clippy_lints/src/redundant_closure_call.rs     | 22 +++++++++-----------
 tests/ui/redundant_closure_call_fixable.fixed  | 14 ++++++++++++-
 tests/ui/redundant_closure_call_fixable.rs     | 12 +++++++++++
 tests/ui/redundant_closure_call_fixable.stderr | 28 ++++++++++++++++++++++++--
 4 files changed, 61 insertions(+), 15 deletions(-)

diff --git a/clippy_lints/src/redundant_closure_call.rs b/clippy_lints/src/redundant_closure_call.rs
index 84597269a58..1c23fe998ad 100644
--- a/clippy_lints/src/redundant_closure_call.rs
+++ b/clippy_lints/src/redundant_closure_call.rs
@@ -5,9 +5,7 @@ use hir::Param;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{Visitor as HirVisitor, Visitor};
-use rustc_hir::{
-    ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, ExprKind, Node, intravisit as hir_visit,
-};
+use rustc_hir::{ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, ExprKind, intravisit as hir_visit};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty;
@@ -198,15 +196,15 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
                             hint = hint.asyncify();
                         }
 
-                        let is_in_fn_call_arg = if let Node::Expr(expr) = cx.tcx.parent_hir_node(expr.hir_id) {
-                            matches!(expr.kind, ExprKind::Call(_, _))
-                        } else {
-                            false
-                        };
-
-                        // avoid clippy::double_parens
-                        if !is_in_fn_call_arg {
-                            hint = hint.maybe_paren();
+                        // If the closure body is a block with a single expression, suggest just the inner expression,
+                        // not the block. Example: `(|| { Some(true) })()` should suggest
+                        // `Some(true)`
+                        if let ExprKind::Block(block, _) = body.kind
+                            && block.stmts.is_empty()
+                            && let Some(expr) = block.expr
+                        {
+                            hint = Sugg::hir_with_context(cx, expr, full_expr.span.ctxt(), "..", &mut applicability)
+                                .maybe_paren();
                         }
 
                         diag.span_suggestion(full_expr.span, "try doing something like", hint, applicability);
diff --git a/tests/ui/redundant_closure_call_fixable.fixed b/tests/ui/redundant_closure_call_fixable.fixed
index 099c118e64e..9f6643e8d52 100644
--- a/tests/ui/redundant_closure_call_fixable.fixed
+++ b/tests/ui/redundant_closure_call_fixable.fixed
@@ -60,7 +60,7 @@ fn issue9956() {
     //~^ redundant_closure_call
 
     // immediately calling only one closure, so we can't remove the other ones
-    let a = (|| || 123);
+    let a = || || 123;
     //~^ redundant_closure_call
     dbg!(a()());
 
@@ -144,3 +144,15 @@ fn issue_12358() {
     // different.
     make_closure!(x)();
 }
+
+#[rustfmt::skip]
+fn issue_9583() {
+    Some(true) == Some(true);
+     //~^ redundant_closure_call
+    Some(true) == Some(true);
+    //~^ redundant_closure_call
+    Some(if 1 > 2 {1} else {2}) == Some(2);
+    //~^ redundant_closure_call
+    Some( 1 > 2 ) == Some(true);
+    //~^ redundant_closure_call
+}
diff --git a/tests/ui/redundant_closure_call_fixable.rs b/tests/ui/redundant_closure_call_fixable.rs
index da5dd7ef263..34f22878678 100644
--- a/tests/ui/redundant_closure_call_fixable.rs
+++ b/tests/ui/redundant_closure_call_fixable.rs
@@ -144,3 +144,15 @@ fn issue_12358() {
     // different.
     make_closure!(x)();
 }
+
+#[rustfmt::skip]
+fn issue_9583() {
+    (|| { Some(true) })() == Some(true);
+     //~^ redundant_closure_call
+    (|| Some(true))() == Some(true);
+    //~^ redundant_closure_call
+    (|| { Some(if 1 > 2 {1} else {2}) })() == Some(2);
+    //~^ redundant_closure_call
+    (|| { Some( 1 > 2 ) })() == Some(true);
+    //~^ redundant_closure_call
+}
diff --git a/tests/ui/redundant_closure_call_fixable.stderr b/tests/ui/redundant_closure_call_fixable.stderr
index 2c35aafbe31..a5591cf7813 100644
--- a/tests/ui/redundant_closure_call_fixable.stderr
+++ b/tests/ui/redundant_closure_call_fixable.stderr
@@ -95,7 +95,7 @@ error: try not to call a closure in the expression where it is declared
   --> tests/ui/redundant_closure_call_fixable.rs:63:13
    |
 LL |     let a = (|| || || 123)();
-   |             ^^^^^^^^^^^^^^^^ help: try doing something like: `(|| || 123)`
+   |             ^^^^^^^^^^^^^^^^ help: try doing something like: `|| || 123`
 
 error: try not to call a closure in the expression where it is declared
   --> tests/ui/redundant_closure_call_fixable.rs:68:13
@@ -145,5 +145,29 @@ error: try not to call a closure in the expression where it is declared
 LL |     std::convert::identity((|| 13_i32 + 36_i32)()).leading_zeros();
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `13_i32 + 36_i32`
 
-error: aborting due to 17 previous errors
+error: try not to call a closure in the expression where it is declared
+  --> tests/ui/redundant_closure_call_fixable.rs:150:5
+   |
+LL |     (|| { Some(true) })() == Some(true);
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `Some(true)`
+
+error: try not to call a closure in the expression where it is declared
+  --> tests/ui/redundant_closure_call_fixable.rs:152:5
+   |
+LL |     (|| Some(true))() == Some(true);
+   |     ^^^^^^^^^^^^^^^^^ help: try doing something like: `Some(true)`
+
+error: try not to call a closure in the expression where it is declared
+  --> tests/ui/redundant_closure_call_fixable.rs:154:5
+   |
+LL |     (|| { Some(if 1 > 2 {1} else {2}) })() == Some(2);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `Some(if 1 > 2 {1} else {2})`
+
+error: try not to call a closure in the expression where it is declared
+  --> tests/ui/redundant_closure_call_fixable.rs:156:5
+   |
+LL |     (|| { Some( 1 > 2 ) })() == Some(true);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `Some( 1 > 2 )`
+
+error: aborting due to 21 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From bb59c39fd2f18398d3d044525a0bf7557f9c4768 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 26 Jun 2025 09:35:11 +0200
Subject: Don't remove explicit cast to trait object pointer

---
 clippy_lints/src/casts/borrow_as_ptr.rs | 3 ++-
 tests/ui/borrow_as_ptr.fixed            | 6 ++++++
 tests/ui/borrow_as_ptr.rs               | 6 ++++++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/casts/borrow_as_ptr.rs b/clippy_lints/src/casts/borrow_as_ptr.rs
index ad0a4f8cdf3..e3b125a8d5b 100644
--- a/clippy_lints/src/casts/borrow_as_ptr.rs
+++ b/clippy_lints/src/casts/borrow_as_ptr.rs
@@ -18,7 +18,8 @@ pub(super) fn check<'tcx>(
     cast_to: &'tcx Ty<'_>,
     msrv: Msrv,
 ) -> bool {
-    if matches!(cast_to.kind, TyKind::Ptr(_))
+    if let TyKind::Ptr(target) = cast_to.kind
+        && !matches!(target.ty.kind, TyKind::TraitObject(..))
         && let ExprKind::AddrOf(BorrowKind::Ref, mutability, e) = cast_expr.kind
         && !is_lint_allowed(cx, BORROW_AS_PTR, expr.hir_id)
     {
diff --git a/tests/ui/borrow_as_ptr.fixed b/tests/ui/borrow_as_ptr.fixed
index 3ba2eea59f0..3f6e5245b87 100644
--- a/tests/ui/borrow_as_ptr.fixed
+++ b/tests/ui/borrow_as_ptr.fixed
@@ -47,3 +47,9 @@ fn implicit_cast() {
     // Do not lint references to temporaries
     core::ptr::eq(&0i32, &1i32);
 }
+
+fn issue_15141() {
+    let a = String::new();
+    // Don't lint cast to dyn trait pointers
+    let b = &a as *const dyn std::any::Any;
+}
diff --git a/tests/ui/borrow_as_ptr.rs b/tests/ui/borrow_as_ptr.rs
index 8cdd0512da5..20f4f40e001 100644
--- a/tests/ui/borrow_as_ptr.rs
+++ b/tests/ui/borrow_as_ptr.rs
@@ -47,3 +47,9 @@ fn implicit_cast() {
     // Do not lint references to temporaries
     core::ptr::eq(&0i32, &1i32);
 }
+
+fn issue_15141() {
+    let a = String::new();
+    // Don't lint cast to dyn trait pointers
+    let b = &a as *const dyn std::any::Any;
+}
-- 
cgit 1.4.1-3-g733a5


From 4f3c17486eafadd4ccebdf5230b27a285c9a110d Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Tue, 11 Mar 2025 12:08:45 +0000
Subject: Change const trait bound syntax from ~const to [const]

---
 clippy_utils/src/qualify_min_const_fn.rs    | 2 +-
 tests/ui/assign_ops.fixed                   | 2 +-
 tests/ui/assign_ops.rs                      | 2 +-
 tests/ui/trait_duplication_in_bounds.fixed  | 4 ++--
 tests/ui/trait_duplication_in_bounds.rs     | 4 ++--
 tests/ui/trait_duplication_in_bounds.stderr | 4 ++--
 6 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index e629012b187..328fe3d428b 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -436,7 +436,7 @@ fn is_ty_const_destruct<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>
     // FIXME(const_trait_impl, fee1-dead) revert to const destruct once it works again
     #[expect(unused)]
     fn is_ty_const_destruct_unused<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>) -> bool {
-        // If this doesn't need drop at all, then don't select `~const Destruct`.
+        // If this doesn't need drop at all, then don't select `[const] Destruct`.
         if !ty.needs_drop(tcx, body.typing_env(tcx)) {
             return false;
         }
diff --git a/tests/ui/assign_ops.fixed b/tests/ui/assign_ops.fixed
index 3bc6885d7c3..99beea850a2 100644
--- a/tests/ui/assign_ops.fixed
+++ b/tests/ui/assign_ops.fixed
@@ -91,7 +91,7 @@ mod issue14871 {
 
     impl<T> const NumberConstants for T
     where
-        T: Number + ~const core::ops::Add,
+        T: Number + [const] core::ops::Add,
     {
         fn constant(value: usize) -> Self {
             let mut res = Self::ZERO;
diff --git a/tests/ui/assign_ops.rs b/tests/ui/assign_ops.rs
index f1f8f9daff9..900d5ad38e0 100644
--- a/tests/ui/assign_ops.rs
+++ b/tests/ui/assign_ops.rs
@@ -91,7 +91,7 @@ mod issue14871 {
 
     impl<T> const NumberConstants for T
     where
-        T: Number + ~const core::ops::Add,
+        T: Number + [const] core::ops::Add,
     {
         fn constant(value: usize) -> Self {
             let mut res = Self::ZERO;
diff --git a/tests/ui/trait_duplication_in_bounds.fixed b/tests/ui/trait_duplication_in_bounds.fixed
index 666ff78b218..cf52ecf2f03 100644
--- a/tests/ui/trait_duplication_in_bounds.fixed
+++ b/tests/ui/trait_duplication_in_bounds.fixed
@@ -169,9 +169,9 @@ where
 // #13476
 #[const_trait]
 trait ConstTrait {}
-const fn const_trait_bounds_good<T: ConstTrait + ~const ConstTrait>() {}
+const fn const_trait_bounds_good<T: ConstTrait + [const] ConstTrait>() {}
 
-const fn const_trait_bounds_bad<T: ~const ConstTrait>() {}
+const fn const_trait_bounds_bad<T: [const] ConstTrait>() {}
 //~^ trait_duplication_in_bounds
 
 fn projections<T, U, V>()
diff --git a/tests/ui/trait_duplication_in_bounds.rs b/tests/ui/trait_duplication_in_bounds.rs
index a1a86fe058e..955562f08dc 100644
--- a/tests/ui/trait_duplication_in_bounds.rs
+++ b/tests/ui/trait_duplication_in_bounds.rs
@@ -169,9 +169,9 @@ where
 // #13476
 #[const_trait]
 trait ConstTrait {}
-const fn const_trait_bounds_good<T: ConstTrait + ~const ConstTrait>() {}
+const fn const_trait_bounds_good<T: ConstTrait + [const] ConstTrait>() {}
 
-const fn const_trait_bounds_bad<T: ~const ConstTrait + ~const ConstTrait>() {}
+const fn const_trait_bounds_bad<T: [const] ConstTrait + [const] ConstTrait>() {}
 //~^ trait_duplication_in_bounds
 
 fn projections<T, U, V>()
diff --git a/tests/ui/trait_duplication_in_bounds.stderr b/tests/ui/trait_duplication_in_bounds.stderr
index d76b4e45848..ab31721ef51 100644
--- a/tests/ui/trait_duplication_in_bounds.stderr
+++ b/tests/ui/trait_duplication_in_bounds.stderr
@@ -61,8 +61,8 @@ LL | fn bad_trait_object(arg0: &(dyn Any + Send + Send)) {
 error: these bounds contain repeated elements
   --> tests/ui/trait_duplication_in_bounds.rs:174:36
    |
-LL | const fn const_trait_bounds_bad<T: ~const ConstTrait + ~const ConstTrait>() {}
-   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `~const ConstTrait`
+LL | const fn const_trait_bounds_bad<T: [const] ConstTrait + [const] ConstTrait>() {}
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[const] ConstTrait`
 
 error: these where clauses contain repeated elements
   --> tests/ui/trait_duplication_in_bounds.rs:181:8
-- 
cgit 1.4.1-3-g733a5


From 664b143dac42362bebdd93ea1a864c21bac5dd4d Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 26 Jun 2025 09:18:43 -0700
Subject: doc_nested_refdefs: do not falsely report checkboxes as refdefs

---
 clippy_lints/src/doc/mod.rs                     |  4 +++-
 tests/ui/doc/doc_nested_refdef_list_item.fixed  |  6 ++----
 tests/ui/doc/doc_nested_refdef_list_item.rs     |  2 --
 tests/ui/doc/doc_nested_refdef_list_item.stderr | 26 +------------------------
 4 files changed, 6 insertions(+), 32 deletions(-)

diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index 1b6c48e53f5..49397938ca7 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -1249,7 +1249,9 @@ fn looks_like_refdef(doc: &str, range: Range<usize>) -> Option<Range<usize>> {
             b'[' => {
                 start = Some(i + offset);
             },
-            b']' if let Some(start) = start => {
+            b']' if let Some(start) = start
+                && doc.as_bytes().get(i + offset + 1) == Some(&b':') =>
+            {
                 return Some(start..i + offset + 1);
             },
             _ => {},
diff --git a/tests/ui/doc/doc_nested_refdef_list_item.fixed b/tests/ui/doc/doc_nested_refdef_list_item.fixed
index 065f4486e39..5c57c58fbc0 100644
--- a/tests/ui/doc/doc_nested_refdef_list_item.fixed
+++ b/tests/ui/doc/doc_nested_refdef_list_item.fixed
@@ -72,8 +72,6 @@ pub struct NotEmptyTight;
 
 /// ## Heading
 ///
-/// - [x][] - Done
-//~^ ERROR: link reference defined in list item
-/// - [ ][] - Not Done
-//~^ ERROR: link reference defined in list item
+/// - [x] - Done
+/// - [ ] - Not Done
 pub struct GithubCheckboxes;
diff --git a/tests/ui/doc/doc_nested_refdef_list_item.rs b/tests/ui/doc/doc_nested_refdef_list_item.rs
index c7eab50c8b3..06b6ba49e19 100644
--- a/tests/ui/doc/doc_nested_refdef_list_item.rs
+++ b/tests/ui/doc/doc_nested_refdef_list_item.rs
@@ -73,7 +73,5 @@ pub struct NotEmptyTight;
 /// ## Heading
 ///
 /// - [x] - Done
-//~^ ERROR: link reference defined in list item
 /// - [ ] - Not Done
-//~^ ERROR: link reference defined in list item
 pub struct GithubCheckboxes;
diff --git a/tests/ui/doc/doc_nested_refdef_list_item.stderr b/tests/ui/doc/doc_nested_refdef_list_item.stderr
index 5a815dabf4d..27314c7e968 100644
--- a/tests/ui/doc/doc_nested_refdef_list_item.stderr
+++ b/tests/ui/doc/doc_nested_refdef_list_item.stderr
@@ -144,29 +144,5 @@ help: for an intra-doc link, add `[]` between the label and the colon
 LL | /// - [link][]: def "title"
    |             ++
 
-error: link reference defined in list item
-  --> tests/ui/doc/doc_nested_refdef_list_item.rs:75:7
-   |
-LL | /// - [x] - Done
-   |       ^^^
-   |
-   = help: link definitions are not shown in rendered documentation
-help: for an intra-doc link, add `[]` between the label and the colon
-   |
-LL | /// - [x][] - Done
-   |          ++
-
-error: link reference defined in list item
-  --> tests/ui/doc/doc_nested_refdef_list_item.rs:77:7
-   |
-LL | /// - [ ] - Not Done
-   |       ^^^
-   |
-   = help: link definitions are not shown in rendered documentation
-help: for an intra-doc link, add `[]` between the label and the colon
-   |
-LL | /// - [ ][] - Not Done
-   |          ++
-
-error: aborting due to 14 previous errors
+error: aborting due to 12 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6240a2b5b929dfd86c18c2c21e2c227ffd613efa Mon Sep 17 00:00:00 2001
From: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
Date: Fri, 27 Jun 2025 02:23:49 +0900
Subject: generate new for tuple field

Signed-off-by: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
---
 .../ide-assists/src/handlers/generate_new.rs       | 359 +++++++++++++++++++--
 1 file changed, 337 insertions(+), 22 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 4837f92f934..6bb993df5b7 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
@@ -35,10 +35,16 @@ use crate::{
 pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
     let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
 
-    // We want to only apply this to non-union structs with named fields
     let field_list = match strukt.kind() {
-        StructKind::Record(named) => named,
-        _ => return None,
+        StructKind::Record(named) => {
+            named.fields().filter_map(|f| Some((f.name()?, f.ty()?))).collect::<Vec<_>>()
+        }
+        StructKind::Tuple(tuple) => tuple
+            .fields()
+            .enumerate()
+            .filter_map(|(i, f)| Some((make::name(&format!("_{}", i)), f.ty()?)))
+            .collect::<Vec<_>>(),
+        StructKind::Unit => return None,
     };
 
     // Return early if we've found an existing new fn
@@ -50,11 +56,9 @@ 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 trivial_constructors = field_list
-            .fields()
-            .map(|f| {
-                let name = f.name()?;
-
-                let ty = ctx.sema.resolve_type(&f.ty()?)?;
+            .iter()
+            .map(|(name, ty)| {
+                let ty = ctx.sema.resolve_type(ty)?;
 
                 let item_in_ns = hir::ItemInNs::from(hir::ModuleDef::from(ty.as_adt()?));
 
@@ -73,34 +77,44 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
                     edition,
                 )?;
 
-                Some(make::record_expr_field(make::name_ref(&name.text()), Some(expr)))
+                Some((make::name_ref(&name.text()), Some(expr)))
             })
             .collect::<Vec<_>>();
 
-        let params = field_list.fields().enumerate().filter_map(|(i, f)| {
+        let params = field_list.iter().enumerate().filter_map(|(i, (name, ty))| {
             if trivial_constructors[i].is_none() {
-                let name = f.name()?;
-                let ty = f.ty()?;
-
-                Some(make::param(make::ident_pat(false, false, name).into(), ty))
+                Some(make::param(make::ident_pat(false, false, name.clone()).into(), ty.clone()))
             } else {
                 None
             }
         });
         let params = make::param_list(None, params);
 
-        let fields = field_list.fields().enumerate().filter_map(|(i, f)| {
-            let constructor = trivial_constructors[i].clone();
-            if constructor.is_some() {
+        let fields = field_list.iter().enumerate().map(|(i, (name, _))| {
+            if let Some(constructor) = trivial_constructors[i].clone() {
                 constructor
             } else {
-                Some(make::record_expr_field(make::name_ref(&f.name()?.text()), None))
+                (make::name_ref(&name.text()), None)
             }
         });
-        let fields = make::record_expr_field_list(fields);
 
-        let record_expr = make::record_expr(make::ext::ident_path("Self"), fields);
-        let body = make::block_expr(None, Some(record_expr.into()));
+        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()
+            }
+            StructKind::Tuple(_) => {
+                let args = fields.map(|(arg, expr)| {
+                    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()
+            }
+            StructKind::Unit => unreachable!(),
+        };
+        let body = make::block_expr(None, tail_expr.into());
 
         let ret_type = make::ret_type(make::ty_path(make::ext::ident_path("Self")));
 
@@ -157,7 +171,7 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
 }
 
 #[cfg(test)]
-mod tests {
+mod record_tests {
     use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
 
     use super::*;
@@ -695,3 +709,304 @@ impl<T> Source<T> {
         );
     }
 }
+
+#[cfg(test)]
+mod tuple_tests {
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
+
+    use super::*;
+
+    #[test]
+    fn test_generate_new_with_zst_fields() {
+        check_assist(
+            generate_new,
+            r#"
+struct Empty;
+
+struct Foo(Empty$0);
+"#,
+            r#"
+struct Empty;
+
+struct Foo(Empty);
+
+impl Foo {
+    fn $0new() -> Self {
+        Self(Empty)
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_new,
+            r#"
+struct Empty;
+
+struct Foo(String, Empty$0);
+"#,
+            r#"
+struct Empty;
+
+struct Foo(String, Empty);
+
+impl Foo {
+    fn $0new(_0: String) -> Self {
+        Self(_0, Empty)
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_new,
+            r#"
+enum Empty { Bar }
+
+struct Foo(Empty$0);
+"#,
+            r#"
+enum Empty { Bar }
+
+struct Foo(Empty);
+
+impl Foo {
+    fn $0new() -> Self {
+        Self(Empty::Bar)
+    }
+}
+"#,
+        );
+
+        // make sure the assist only works on unit variants
+        check_assist(
+            generate_new,
+            r#"
+struct Empty {}
+
+struct Foo(Empty$0);
+"#,
+            r#"
+struct Empty {}
+
+struct Foo(Empty);
+
+impl Foo {
+    fn $0new(_0: Empty) -> Self {
+        Self(_0)
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_new,
+            r#"
+enum Empty { Bar {} }
+
+struct Foo(Empty$0);
+"#,
+            r#"
+enum Empty { Bar {} }
+
+struct Foo(Empty);
+
+impl Foo {
+    fn $0new(_0: Empty) -> Self {
+        Self(_0)
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_new() {
+        check_assist(
+            generate_new,
+            r#"
+struct Foo($0);
+"#,
+            r#"
+struct Foo();
+
+impl Foo {
+    fn $0new() -> Self {
+        Self()
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_new,
+            r#"
+struct Foo<T: Clone>($0);
+"#,
+            r#"
+struct Foo<T: Clone>();
+
+impl<T: Clone> Foo<T> {
+    fn $0new() -> Self {
+        Self()
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_new,
+            r#"
+struct Foo<'a, T: Foo<'a>>($0);
+"#,
+            r#"
+struct Foo<'a, T: Foo<'a>>();
+
+impl<'a, T: Foo<'a>> Foo<'a, T> {
+    fn $0new() -> Self {
+        Self()
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_new,
+            r#"
+struct Foo(String$0);
+"#,
+            r#"
+struct Foo(String);
+
+impl Foo {
+    fn $0new(_0: String) -> Self {
+        Self(_0)
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_new,
+            r#"
+struct Foo(String, Vec<i32>$0);
+"#,
+            r#"
+struct Foo(String, Vec<i32>);
+
+impl Foo {
+    fn $0new(_0: String, _1: Vec<i32>) -> Self {
+        Self(_0, _1)
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn check_that_visibility_modifiers_dont_get_brought_in() {
+        check_assist(
+            generate_new,
+            r#"
+struct Foo(pub String, pub Vec<i32>$0);
+"#,
+            r#"
+struct Foo(pub String, pub Vec<i32>);
+
+impl Foo {
+    fn $0new(_0: String, _1: Vec<i32>) -> Self {
+        Self(_0, _1)
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn generate_new_not_applicable_if_fn_exists() {
+        check_assist_not_applicable(
+            generate_new,
+            r#"
+struct Foo($0);
+
+impl Foo {
+    fn new() -> Self {
+        Self
+    }
+}
+"#,
+        );
+
+        check_assist_not_applicable(
+            generate_new,
+            r#"
+struct Foo($0);
+
+impl Foo {
+    fn New() -> Self {
+        Self
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn generate_new_target() {
+        check_assist_target(
+            generate_new,
+            r#"
+struct SomeThingIrrelevant;
+/// Has a lifetime parameter
+struct Foo<'a, T: Foo<'a>>($0);
+struct EvenMoreIrrelevant;
+"#,
+            "/// Has a lifetime parameter
+struct Foo<'a, T: Foo<'a>>();",
+        );
+    }
+
+    #[test]
+    fn test_unrelated_new() {
+        check_assist(
+            generate_new,
+            r#"
+pub struct AstId<N: AstNode> {
+    file_id: HirFileId,
+    file_ast_id: FileAstId<N>,
+}
+
+impl<N: AstNode> AstId<N> {
+    pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {
+        AstId { file_id, file_ast_id }
+    }
+}
+
+pub struct Source<T>(pub HirFileId,$0 pub T);
+
+impl<T> Source<T> {
+    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
+        Source(self.file_id, f(self.ast))
+    }
+}
+"#,
+            r#"
+pub struct AstId<N: AstNode> {
+    file_id: HirFileId,
+    file_ast_id: FileAstId<N>,
+}
+
+impl<N: AstNode> AstId<N> {
+    pub fn new(file_id: HirFileId, file_ast_id: FileAstId<N>) -> AstId<N> {
+        AstId { file_id, file_ast_id }
+    }
+}
+
+pub struct Source<T>(pub HirFileId, pub T);
+
+impl<T> Source<T> {
+    pub fn $0new(_0: HirFileId, _1: T) -> Self {
+        Self(_0, _1)
+    }
+
+    pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
+        Source(self.file_id, f(self.ast))
+    }
+}
+"#,
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 9117cb0223eaf72ab9015cee10549b2b774d8f74 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 26 Jun 2025 22:51:58 +0200
Subject: `zero_ptr`: lint in `const` context as well

The lint was extra restrictive, and didn't suggest using
`core::ptr::null` and `core::ptr::null_mut` in `const` contexts although
they have been const-stabilized since Rust 1.24.
---
 book/src/lint_configuration.md     | 1 +
 clippy_config/src/conf.rs          | 1 +
 clippy_lints/src/casts/mod.rs      | 2 +-
 clippy_lints/src/casts/zero_ptr.rs | 5 +++--
 clippy_utils/src/msrvs.rs          | 2 +-
 tests/ui/zero_ptr.fixed            | 8 ++++++++
 tests/ui/zero_ptr.rs               | 8 ++++++++
 tests/ui/zero_ptr.stderr           | 8 +++++++-
 8 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index e9b7f42a183..992ed2c6aaa 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -892,6 +892,7 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`unnested_or_patterns`](https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns)
 * [`unused_trait_names`](https://rust-lang.github.io/rust-clippy/master/index.html#unused_trait_names)
 * [`use_self`](https://rust-lang.github.io/rust-clippy/master/index.html#use_self)
+* [`zero_ptr`](https://rust-lang.github.io/rust-clippy/master/index.html#zero_ptr)
 
 
 ## `pass-by-value-size-limit`
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 841facdca06..555f54bcfb8 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -794,6 +794,7 @@ define_Conf! {
         unnested_or_patterns,
         unused_trait_names,
         use_self,
+        zero_ptr,
     )]
     msrv: Msrv = Msrv::default(),
     /// The minimum size (in bytes) to consider a type for passing by reference instead of by value.
diff --git a/clippy_lints/src/casts/mod.rs b/clippy_lints/src/casts/mod.rs
index daae9a8bb08..37accff5eaa 100644
--- a/clippy_lints/src/casts/mod.rs
+++ b/clippy_lints/src/casts/mod.rs
@@ -878,7 +878,7 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             confusing_method_to_numeric_cast::check(cx, expr, cast_from_expr, cast_from, cast_to);
             fn_to_numeric_cast::check(cx, expr, cast_from_expr, cast_from, cast_to);
             fn_to_numeric_cast_with_truncation::check(cx, expr, cast_from_expr, cast_from, cast_to);
-            zero_ptr::check(cx, expr, cast_from_expr, cast_to_hir);
+            zero_ptr::check(cx, expr, cast_from_expr, cast_to_hir, self.msrv);
 
             if self.msrv.meets(cx, msrvs::MANUAL_DANGLING_PTR) {
                 manual_dangling_ptr::check(cx, expr, cast_from_expr, cast_to_hir);
diff --git a/clippy_lints/src/casts/zero_ptr.rs b/clippy_lints/src/casts/zero_ptr.rs
index a34af6bc226..f4738e7b0d5 100644
--- a/clippy_lints/src/casts/zero_ptr.rs
+++ b/clippy_lints/src/casts/zero_ptr.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::SpanRangeExt;
 use clippy_utils::{is_in_const_context, is_integer_literal, std_or_core};
 use rustc_errors::Applicability;
@@ -7,10 +8,10 @@ use rustc_lint::LateContext;
 
 use super::ZERO_PTR;
 
-pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, from: &Expr<'_>, to: &Ty<'_>) {
+pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, from: &Expr<'_>, to: &Ty<'_>, msrv: Msrv) {
     if let TyKind::Ptr(ref mut_ty) = to.kind
         && is_integer_literal(from, 0)
-        && !is_in_const_context(cx)
+        && (!is_in_const_context(cx) || msrv.meets(cx, msrvs::PTR_NULL))
         && let Some(std_or_core) = std_or_core(cx)
     {
         let (msg, sugg_fn) = match mut_ty.mutbl {
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index 7a0bef1a9bb..24ed4c3a8be 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -74,7 +74,7 @@ msrv_aliases! {
     1,28,0 { FROM_BOOL, REPEAT_WITH, SLICE_FROM_REF }
     1,27,0 { ITERATOR_TRY_FOLD }
     1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN }
-    1,24,0 { IS_ASCII_DIGIT }
+    1,24,0 { IS_ASCII_DIGIT, PTR_NULL }
     1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
     1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
     1,16,0 { STR_REPEAT }
diff --git a/tests/ui/zero_ptr.fixed b/tests/ui/zero_ptr.fixed
index f2375d57f3a..f9d9d2db176 100644
--- a/tests/ui/zero_ptr.fixed
+++ b/tests/ui/zero_ptr.fixed
@@ -16,3 +16,11 @@ fn main() {
     let z = 0;
     let _ = z as *const usize; // this is currently not caught
 }
+
+const fn in_const_context() {
+    #[clippy::msrv = "1.23"]
+    let _: *const usize = 0 as *const _;
+    #[clippy::msrv = "1.24"]
+    let _: *const usize = std::ptr::null();
+    //~^ zero_ptr
+}
diff --git a/tests/ui/zero_ptr.rs b/tests/ui/zero_ptr.rs
index ee01e426a43..41455fee5b5 100644
--- a/tests/ui/zero_ptr.rs
+++ b/tests/ui/zero_ptr.rs
@@ -16,3 +16,11 @@ fn main() {
     let z = 0;
     let _ = z as *const usize; // this is currently not caught
 }
+
+const fn in_const_context() {
+    #[clippy::msrv = "1.23"]
+    let _: *const usize = 0 as *const _;
+    #[clippy::msrv = "1.24"]
+    let _: *const usize = 0 as *const _;
+    //~^ zero_ptr
+}
diff --git a/tests/ui/zero_ptr.stderr b/tests/ui/zero_ptr.stderr
index 8dc781f3625..81269de6c60 100644
--- a/tests/ui/zero_ptr.stderr
+++ b/tests/ui/zero_ptr.stderr
@@ -31,5 +31,11 @@ error: `0 as *mut _` detected
 LL |     foo(0 as *const _, 0 as *mut _);
    |                        ^^^^^^^^^^^ help: try: `std::ptr::null_mut()`
 
-error: aborting due to 5 previous errors
+error: `0 as *const _` detected
+  --> tests/ui/zero_ptr.rs:24:27
+   |
+LL |     let _: *const usize = 0 as *const _;
+   |                           ^^^^^^^^^^^^^ help: try: `std::ptr::null()`
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 6759aacb29e99a7eed55fa87bbdf26d79a6ec172 Mon Sep 17 00:00:00 2001
From: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
Date: Fri, 27 Jun 2025 18:48:39 +0900
Subject: use name_generator

Signed-off-by: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
---
 .../ide-assists/src/handlers/generate_new.rs       | 27 +++++++++++++++++-----
 1 file changed, 21 insertions(+), 6 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 6bb993df5b7..74e75607b72 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
@@ -1,5 +1,6 @@
 use ide_db::{
-    imports::import_assets::item_for_path_search, use_trivial_constructor::use_trivial_constructor,
+    imports::import_assets::item_for_path_search, syntax_helpers::suggest_name::NameGenerator,
+    use_trivial_constructor::use_trivial_constructor,
 };
 use syntax::{
     ast::{self, AstNode, HasName, HasVisibility, StructKind, edit_in_place::Indent, make},
@@ -39,11 +40,25 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
         StructKind::Record(named) => {
             named.fields().filter_map(|f| Some((f.name()?, f.ty()?))).collect::<Vec<_>>()
         }
-        StructKind::Tuple(tuple) => tuple
-            .fields()
-            .enumerate()
-            .filter_map(|(i, f)| Some((make::name(&format!("_{}", i)), f.ty()?)))
-            .collect::<Vec<_>>(),
+        StructKind::Tuple(tuple) => {
+            let mut name_generator = NameGenerator::default();
+            tuple
+                .fields()
+                .enumerate()
+                .filter_map(|(i, f)| {
+                    let ty = f.ty()?;
+                    let name = match name_generator.for_type(
+                        &ctx.sema.resolve_type(&ty)?,
+                        ctx.db(),
+                        ctx.edition(),
+                    ) {
+                        Some(name) => name,
+                        None => name_generator.suggest_name(&format!("_{i}")),
+                    };
+                    Some((make::name(name.as_str()), f.ty()?))
+                })
+                .collect::<Vec<_>>()
+        }
         StructKind::Unit => return None,
     };
 
-- 
cgit 1.4.1-3-g733a5


From 08a36de7761cd0b4c82403efdebbda41a5528193 Mon Sep 17 00:00:00 2001
From: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
Date: Fri, 27 Jun 2025 18:49:08 +0900
Subject: use placeholder_snippet

Signed-off-by: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
---
 .../ide-assists/src/handlers/generate_new.rs       | 61 ++++++++++++++++------
 1 file changed, 46 insertions(+), 15 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 74e75607b72..51c2f65e025 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
@@ -149,8 +149,35 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
         .clone_for_update();
         fn_.indent(1.into());
 
-        // Add a tabstop before the name
         if let Some(cap) = ctx.config.snippet_cap {
+            match strukt.kind() {
+                StructKind::Tuple(_) => {
+                    let struct_args = fn_
+                        .body()
+                        .unwrap()
+                        .syntax()
+                        .descendants()
+                        .filter(|it| syntax::ast::ArgList::can_cast(it.kind()))
+                        .flat_map(|args| args.children())
+                        .filter(|it| syntax::ast::PathExpr::can_cast(it.kind()))
+                        .enumerate()
+                        .filter_map(|(i, node)| {
+                            if trivial_constructors[i].is_none() { Some(node) } else { None }
+                        });
+                    if let Some(fn_params) = fn_.param_list() {
+                        for (struct_arg, fn_param) in struct_args.zip(fn_params.params()) {
+                            if let Some(fn_pat) = fn_param.pat() {
+                                let fn_pat = fn_pat.syntax().clone();
+                                builder
+                                    .add_placeholder_snippet_group(cap, vec![struct_arg, fn_pat]);
+                            }
+                        }
+                    }
+                }
+                _ => {}
+            }
+
+            // Add a tabstop before the name
             if let Some(name) = fn_.name() {
                 builder.add_tabstop_before(cap, name);
             }
@@ -765,8 +792,8 @@ struct Empty;
 struct Foo(String, Empty);
 
 impl Foo {
-    fn $0new(_0: String) -> Self {
-        Self(_0, Empty)
+    fn $0new(${1:_0}: String) -> Self {
+        Self(${1:_0}, Empty)
     }
 }
 "#,
@@ -805,8 +832,8 @@ struct Empty {}
 struct Foo(Empty);
 
 impl Foo {
-    fn $0new(_0: Empty) -> Self {
-        Self(_0)
+    fn $0new(${1:empty}: Empty) -> Self {
+        Self(${1:empty})
     }
 }
 "#,
@@ -824,8 +851,8 @@ enum Empty { Bar {} }
 struct Foo(Empty);
 
 impl Foo {
-    fn $0new(_0: Empty) -> Self {
-        Self(_0)
+    fn $0new(${1:empty}: Empty) -> Self {
+        Self(${1:empty})
     }
 }
 "#,
@@ -888,8 +915,8 @@ struct Foo(String$0);
 struct Foo(String);
 
 impl Foo {
-    fn $0new(_0: String) -> Self {
-        Self(_0)
+    fn $0new(${1:_0}: String) -> Self {
+        Self(${1:_0})
     }
 }
 "#,
@@ -897,14 +924,16 @@ impl Foo {
         check_assist(
             generate_new,
             r#"
+struct Vec<T> { };
 struct Foo(String, Vec<i32>$0);
 "#,
             r#"
+struct Vec<T> { };
 struct Foo(String, Vec<i32>);
 
 impl Foo {
-    fn $0new(_0: String, _1: Vec<i32>) -> Self {
-        Self(_0, _1)
+    fn $0new(${1:_0}: String, ${2:items}: Vec<i32>) -> Self {
+        Self(${1:_0}, ${2:items})
     }
 }
 "#,
@@ -916,14 +945,16 @@ impl Foo {
         check_assist(
             generate_new,
             r#"
+struct Vec<T> { };
 struct Foo(pub String, pub Vec<i32>$0);
 "#,
             r#"
+struct Vec<T> { };
 struct Foo(pub String, pub Vec<i32>);
 
 impl Foo {
-    fn $0new(_0: String, _1: Vec<i32>) -> Self {
-        Self(_0, _1)
+    fn $0new(${1:_0}: String, ${2:items}: Vec<i32>) -> Self {
+        Self(${1:_0}, ${2:items})
     }
 }
 "#,
@@ -1013,8 +1044,8 @@ impl<N: AstNode> AstId<N> {
 pub struct Source<T>(pub HirFileId, pub T);
 
 impl<T> Source<T> {
-    pub fn $0new(_0: HirFileId, _1: T) -> Self {
-        Self(_0, _1)
+    pub fn $0new(${1:_0}: HirFileId, ${2:_1}: T) -> Self {
+        Self(${1:_0}, ${2:_1})
     }
 
     pub fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
-- 
cgit 1.4.1-3-g733a5


From 074ccaf3c0818c1c7162babe8e7874f1fa551e18 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Fri, 27 Jun 2025 12:20:57 +0200
Subject: Merge commit 'c5dbd1de07e0407b9687619a868384d6de06253f' into
 clippy-subtree-update

---
 .github/ISSUE_TEMPLATE/new_lint.yml                |   4 +-
 .github/PULL_REQUEST_TEMPLATE.md                   |   4 +
 .github/workflows/feature_freeze.yml               |  25 ++
 CHANGELOG.md                                       |  91 ++++++-
 Cargo.toml                                         |   3 +-
 book/src/README.md                                 |   4 +
 book/src/SUMMARY.md                                |   1 +
 book/src/development/adding_lints.md               |   3 +
 book/src/development/feature_freeze.md             |  55 ++++
 book/src/lint_configuration.md                     |  24 +-
 clippy_config/Cargo.toml                           |   2 +-
 clippy_config/src/conf.rs                          |  25 +-
 clippy_dev/src/lint.rs                             |   4 +-
 clippy_dev/src/release.rs                          |   1 +
 clippy_dev/src/serve.rs                            |   2 +-
 clippy_dev/src/update_lints.rs                     | 291 ++++++++++++---------
 clippy_dev/src/utils.rs                            |  15 --
 clippy_lints/Cargo.toml                            |   3 +-
 clippy_lints/src/attrs/inline_always.rs            |   4 +-
 clippy_lints/src/attrs/mod.rs                      |   2 +-
 clippy_lints/src/attrs/utils.rs                    |  12 +-
 clippy_lints/src/borrow_deref_ref.rs               |  15 +-
 clippy_lints/src/casts/cast_sign_loss.rs           |   2 +-
 clippy_lints/src/collapsible_if.rs                 | 127 ++++++---
 clippy_lints/src/copies.rs                         |  18 +-
 clippy_lints/src/declare_clippy_lint.rs            | 168 ------------
 clippy_lints/src/declared_lints.rs                 |   4 +-
 clippy_lints/src/disallowed_macros.rs              |   3 +
 clippy_lints/src/disallowed_methods.rs             |   3 +
 clippy_lints/src/disallowed_types.rs               |   3 +
 clippy_lints/src/doc/broken_link.rs                |  83 ++++++
 clippy_lints/src/doc/doc_suspicious_footnotes.rs   |   6 +-
 clippy_lints/src/doc/mod.rs                        |  50 +++-
 clippy_lints/src/doc/needless_doctest_main.rs      |  27 +-
 clippy_lints/src/empty_line_after.rs               |  64 ++++-
 clippy_lints/src/eta_reduction.rs                  |  92 ++++---
 clippy_lints/src/exhaustive_items.rs               |   2 +-
 clippy_lints/src/floating_point_arithmetic.rs      |   3 +-
 clippy_lints/src/functions/must_use.rs             |  53 +++-
 clippy_lints/src/if_not_else.rs                    |  11 +-
 clippy_lints/src/inline_fn_without_body.rs         |  10 +-
 clippy_lints/src/lib.rs                            | 126 +--------
 clippy_lints/src/loops/same_item_push.rs           |  15 +-
 clippy_lints/src/manual_let_else.rs                |   1 -
 clippy_lints/src/matches/manual_ok_err.rs          |  20 +-
 clippy_lints/src/matches/match_wild_enum.rs        |  14 +-
 clippy_lints/src/methods/mod.rs                    |   2 +-
 clippy_lints/src/methods/or_fun_call.rs            |  11 +-
 clippy_lints/src/missing_inline.rs                 |   2 +-
 .../src/needless_borrows_for_generic_args.rs       |  12 +-
 .../src/needless_parens_on_range_literals.rs       |   1 -
 clippy_lints/src/needless_pass_by_value.rs         |   6 +-
 clippy_lints/src/no_mangle_with_rust_abi.rs        |   5 +-
 clippy_lints/src/non_copy_const.rs                 |   2 +-
 clippy_lints/src/operators/identity_op.rs          |  76 +++++-
 .../src/operators/manual_is_multiple_of.rs         |  66 +++++
 clippy_lints/src/operators/mod.rs                  |  33 +++
 clippy_lints/src/pass_by_ref_or_value.rs           |   4 +-
 clippy_lints/src/question_mark.rs                  |   1 +
 clippy_lints/src/question_mark_used.rs             |   1 -
 clippy_lints/src/read_zero_byte_vec.rs             |   3 +-
 clippy_lints/src/return_self_not_must_use.rs       |   5 +-
 clippy_lints/src/single_component_path_imports.rs  |  29 +-
 clippy_lints/src/undocumented_unsafe_blocks.rs     |  45 ++--
 clippy_utils/Cargo.toml                            |   2 +-
 clippy_utils/README.md                             |   2 +-
 clippy_utils/src/consts.rs                         |  15 ++
 clippy_utils/src/diagnostics.rs                    |   6 +-
 clippy_utils/src/lib.rs                            |  22 +-
 clippy_utils/src/msrvs.rs                          |   3 +-
 clippy_utils/src/qualify_min_const_fn.rs           |  15 ++
 clippy_utils/src/sugg.rs                           |  22 +-
 clippy_utils/src/sym.rs                            |   5 +-
 clippy_utils/src/ty/mod.rs                         |  24 +-
 declare_clippy_lint/Cargo.toml                     |  10 +
 declare_clippy_lint/src/lib.rs                     | 280 ++++++++++++++++++++
 lintcheck/src/main.rs                              |   2 +-
 rust-toolchain.toml                                |   2 +-
 src/driver.rs                                      |   8 +-
 src/main.rs                                        |   2 +-
 tests/compile-test.rs                              |   6 +-
 tests/dogfood.rs                                   |   1 +
 .../collapsible_if/collapsible_else_if.fixed       |  50 ++++
 .../ui-toml/collapsible_if/collapsible_else_if.rs  |  55 ++++
 .../collapsible_if/collapsible_else_if.stderr      | 105 ++++++++
 tests/ui/borrow_deref_ref.fixed                    |  47 ++++
 tests/ui/borrow_deref_ref.rs                       |  47 ++++
 tests/ui/borrow_deref_ref.stderr                   |  32 ++-
 tests/ui/borrow_interior_mutable_const.rs          |  16 ++
 tests/ui/box_default.fixed                         |   2 +-
 tests/ui/box_default.rs                            |   2 +-
 tests/ui/branches_sharing_code/shared_at_bottom.rs |  24 ++
 .../branches_sharing_code/shared_at_bottom.stderr  |  32 ++-
 tests/ui/collapsible_else_if.fixed                 |  18 ++
 tests/ui/collapsible_else_if.rs                    |  18 ++
 tests/ui/collapsible_if.fixed                      |   9 +
 tests/ui/collapsible_if.rs                         |   9 +
 tests/ui/doc/needless_doctest_main.rs              | 112 +++++++-
 tests/ui/doc/needless_doctest_main.stderr          |  36 +++
 tests/ui/doc_broken_link.rs                        |  72 +++++
 tests/ui/doc_broken_link.stderr                    |  29 ++
 tests/ui/empty_line_after/outer_attribute.1.fixed  |   9 +
 tests/ui/empty_line_after/outer_attribute.2.fixed  |   9 +
 tests/ui/empty_line_after/outer_attribute.rs       |  10 +
 tests/ui/empty_line_after/outer_attribute.stderr   |  13 +-
 tests/ui/eta.fixed                                 |  18 ++
 tests/ui/eta.rs                                    |  18 ++
 tests/ui/exhaustive_items.fixed                    |   7 +
 tests/ui/exhaustive_items.rs                       |   7 +
 tests/ui/exhaustive_items.stderr                   |  10 +-
 tests/ui/identity_op.fixed                         |  46 ++++
 tests/ui/identity_op.rs                            |  46 ++++
 tests/ui/identity_op.stderr                        |  44 +++-
 tests/ui/infinite_iter.rs                          |   2 +-
 tests/ui/infinite_iter.stderr                      |   4 +-
 tests/ui/iter_kv_map.fixed                         |  20 +-
 tests/ui/iter_kv_map.rs                            |  20 +-
 tests/ui/iter_kv_map.stderr                        |  64 ++---
 tests/ui/let_unit.fixed                            |   2 +-
 tests/ui/let_unit.rs                               |   2 +-
 tests/ui/let_unit.stderr                           |   2 +-
 tests/ui/manual_contains.fixed                     |   2 +-
 tests/ui/manual_contains.rs                        |   2 +-
 tests/ui/manual_find_fixable.fixed                 |   4 +-
 tests/ui/manual_find_fixable.rs                    |   4 +-
 tests/ui/manual_find_fixable.stderr                |   4 +-
 tests/ui/manual_is_multiple_of.fixed               |  25 ++
 tests/ui/manual_is_multiple_of.rs                  |  25 ++
 tests/ui/manual_is_multiple_of.stderr              |  41 +++
 tests/ui/manual_is_variant_and.fixed               |   8 +-
 tests/ui/manual_is_variant_and.rs                  |   8 +-
 tests/ui/manual_is_variant_and.stderr              |  12 +-
 tests/ui/manual_ok_err.fixed                       |  24 ++
 tests/ui/manual_ok_err.rs                          |  36 +++
 tests/ui/manual_ok_err.stderr                      |  32 ++-
 tests/ui/missing_const_for_fn/const_trait.fixed    |   2 +-
 tests/ui/missing_const_for_fn/const_trait.rs       |   2 +-
 tests/ui/missing_const_for_fn/could_be_const.fixed |  57 ++++
 tests/ui/missing_const_for_fn/could_be_const.rs    |  57 ++++
 .../ui/missing_const_for_fn/could_be_const.stderr  |  72 ++++-
 tests/ui/nonminimal_bool.stderr                    |   4 +-
 tests/ui/or_fun_call.fixed                         |  30 +++
 tests/ui/or_fun_call.rs                            |  30 +++
 tests/ui/or_fun_call.stderr                        |  96 ++++---
 tests/ui/question_mark.fixed                       |  12 +
 tests/ui/question_mark.rs                          |  12 +
 tests/ui/unnecessary_os_str_debug_formatting.rs    |  13 +
 .../ui/unnecessary_os_str_debug_formatting.stderr  |  11 +-
 tests/ui/wildcard_enum_match_arm.fixed             |  29 ++
 tests/ui/wildcard_enum_match_arm.rs                |  29 ++
 tests/ui/wildcard_enum_match_arm.stderr            |  14 +-
 tests/versioncheck.rs                              |   1 +
 triagebot.toml                                     |   3 +
 util/versions.py                                   |   6 +-
 154 files changed, 3158 insertions(+), 843 deletions(-)
 create mode 100644 .github/workflows/feature_freeze.yml
 create mode 100644 book/src/development/feature_freeze.md
 delete mode 100644 clippy_lints/src/declare_clippy_lint.rs
 create mode 100644 clippy_lints/src/doc/broken_link.rs
 create mode 100644 clippy_lints/src/operators/manual_is_multiple_of.rs
 create mode 100644 declare_clippy_lint/Cargo.toml
 create mode 100644 declare_clippy_lint/src/lib.rs
 create mode 100644 tests/ui-toml/collapsible_if/collapsible_else_if.fixed
 create mode 100644 tests/ui-toml/collapsible_if/collapsible_else_if.rs
 create mode 100644 tests/ui-toml/collapsible_if/collapsible_else_if.stderr
 create mode 100644 tests/ui/doc/needless_doctest_main.stderr
 create mode 100644 tests/ui/doc_broken_link.rs
 create mode 100644 tests/ui/doc_broken_link.stderr
 create mode 100644 tests/ui/manual_is_multiple_of.fixed
 create mode 100644 tests/ui/manual_is_multiple_of.rs
 create mode 100644 tests/ui/manual_is_multiple_of.stderr

diff --git a/.github/ISSUE_TEMPLATE/new_lint.yml b/.github/ISSUE_TEMPLATE/new_lint.yml
index b49493edce1..464740640e0 100644
--- a/.github/ISSUE_TEMPLATE/new_lint.yml
+++ b/.github/ISSUE_TEMPLATE/new_lint.yml
@@ -1,5 +1,7 @@
 name: New lint suggestion
-description: Suggest a new Clippy lint.
+description: |
+  Suggest a new Clippy lint (currently not accepting new lints)
+  Check out the Clippy book for more information about the feature freeze.
 labels: ["A-lint"]
 body:
   - type: markdown
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 9e49f60892d..83bfd8e9c68 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -32,6 +32,10 @@ order to get feedback.
 
 Delete this line and everything above before opening your PR.
 
+Note that we are currently not taking in new PRs that add new lints. We are in a
+feature freeze. Check out the book for more information. If you open a
+feature-adding pull request, its review will be delayed.
+
 ---
 
 *Please write a short comment explaining your change (or "none" for internal only changes)*
diff --git a/.github/workflows/feature_freeze.yml b/.github/workflows/feature_freeze.yml
new file mode 100644
index 00000000000..a5f8d4bc145
--- /dev/null
+++ b/.github/workflows/feature_freeze.yml
@@ -0,0 +1,25 @@
+name: Feature freeze check
+
+on:
+  pull_request:
+    paths:
+      - 'clippy_lints/src/declared_lints.rs'
+
+jobs:
+  auto-comment:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Check PR Changes
+      id: pr-changes
+      run: echo "::set-output name=changes::${{ toJson(github.event.pull_request.changed_files) }}"
+
+    - name: Create Comment
+      if: steps.pr-changes.outputs.changes != '[]'
+      run: |
+        # Use GitHub API to create a comment on the PR
+        PR_NUMBER=${{ github.event.pull_request.number }}
+        COMMENT="**Seems that you are trying to add a new lint!**\nWe are currently in a [feature freeze](https://doc.rust-lang.org/nightly/clippy/development/feature_freeze.html), so we are delaying all lint-adding PRs to August 1st and focusing on bugfixes.\nThanks a lot for your contribution, and sorry for the inconvenience.\nWith ❤ from the Clippy team"
+        GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}
+        COMMENT_URL="https://api.github.com/repos/${{ github.repository }}/issues/${PR_NUMBER}/comments"
+        curl -s -H "Authorization: token ${GITHUB_TOKEN}" -X POST $COMMENT_URL -d "{\"body\":\"$COMMENT\"}"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0cfe89ad378..a92fbdc767b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,94 @@ document.
 
 ## Unreleased / Beta / In Rust Nightly
 
-[1e5237f4...master](https://github.com/rust-lang/rust-clippy/compare/1e5237f4...master)
+[03a5b6b9...master](https://github.com/rust-lang/rust-clippy/compare/03a5b6b9...master)
+
+## Rust 1.88
+
+Current stable, released 2025-06-26
+
+[View all 126 merged pull requests](https://github.com/rust-lang/rust-clippy/pulls?q=merged%3A2025-03-21T10%3A30%3A57Z..2025-05-01T08%3A03%3A26Z+base%3Amaster)
+
+### New Lints
+
+* Added [`swap_with_temporary`] to `complexity` [#14046](https://github.com/rust-lang/rust-clippy/pull/14046)
+* Added [`redundant_test_prefix`] to `restriction` [#13710](https://github.com/rust-lang/rust-clippy/pull/13710)
+* Added [`manual_dangling_ptr`] to `style` [#14107](https://github.com/rust-lang/rust-clippy/pull/14107)
+* Added [`char_indices_as_byte_indices`] to `correctness` [#13435](https://github.com/rust-lang/rust-clippy/pull/13435)
+* Added [`manual_abs_diff`] to `complexity` [#14482](https://github.com/rust-lang/rust-clippy/pull/14482)
+* Added [`ignore_without_reason`] to `pedantic` [#13931](https://github.com/rust-lang/rust-clippy/pull/13931)
+
+### Moves and Deprecations
+
+* Moved [`uninlined_format_args`] to `style` (from `pedantic`)
+  [#14160](https://github.com/rust-lang/rust-clippy/pull/14160)
+* [`match_on_vec_items`] deprecated in favor of [`indexing_slicing`]
+  [#14217](https://github.com/rust-lang/rust-clippy/pull/14217)
+* Removed superseded lints: `transmute_float_to_int`, `transmute_int_to_char`,
+  `transmute_int_to_float`, `transmute_num_to_bytes` (now in rustc)
+  [#14703](https://github.com/rust-lang/rust-clippy/pull/14703)
+
+### Enhancements
+
+* Configuration renamed from `lint-inconsistent-struct-field-initializers`
+  to `check-inconsistent-struct-field-initializers`
+  [#14280](https://github.com/rust-lang/rust-clippy/pull/14280)
+* Paths in `disallowed_*` configurations are now validated
+  [#14397](https://github.com/rust-lang/rust-clippy/pull/14397)
+* [`borrow_as_ptr`] now lints implicit casts as well
+  [#14408](https://github.com/rust-lang/rust-clippy/pull/14408)
+* [`iter_kv_map`] now recognizes references on maps
+  [#14596](https://github.com/rust-lang/rust-clippy/pull/14596)
+* [`empty_enum_variants_with_brackets`] no longer lints reachable enums or enums used 
+  as functions within same crate [#12971](https://github.com/rust-lang/rust-clippy/pull/12971)
+* [`needless_lifetimes`] now checks for lifetime uses in closures
+  [#14608](https://github.com/rust-lang/rust-clippy/pull/14608)
+* [`wildcard_imports`] now lints on `pub use` when `warn_on_all_wildcard_imports` is enabled
+  [#14182](https://github.com/rust-lang/rust-clippy/pull/14182)
+* [`collapsible_if`] now recognizes the `let_chains` feature
+  [#14481](https://github.com/rust-lang/rust-clippy/pull/14481)
+* [`match_single_binding`] now allows macros in scrutinee and patterns
+  [#14635](https://github.com/rust-lang/rust-clippy/pull/14635)
+* [`needless_borrow`] does not contradict the compiler's
+  `dangerous_implicit_autorefs` lint even though the references
+  are not mandatory
+  [#14810](https://github.com/rust-lang/rust-clippy/pull/14810)
+
+### False Positive Fixes
+
+* [`double_ended_iterator_last`] and [`needless_collect`] fixed FP when iter has side effects
+  [#14490](https://github.com/rust-lang/rust-clippy/pull/14490)
+* [`mut_from_ref`] fixed FP where lifetimes nested in types were not considered
+  [#14471](https://github.com/rust-lang/rust-clippy/pull/14471)
+* [`redundant_clone`] fixed FP in overlapping lifetime
+  [#14237](https://github.com/rust-lang/rust-clippy/pull/14237)
+* [`map_entry`] fixed FP where lint would trigger without insert calls present
+  [#14568](https://github.com/rust-lang/rust-clippy/pull/14568)
+* [`iter_cloned_collect`] fixed FP with custom `From`/`IntoIterator` impl
+  [#14473](https://github.com/rust-lang/rust-clippy/pull/14473)
+* [`shadow_unrelated`] fixed FP in destructuring assignments
+  [#14381](https://github.com/rust-lang/rust-clippy/pull/14381)
+* [`redundant_clone`] fixed FP on enum cast
+  [#14395](https://github.com/rust-lang/rust-clippy/pull/14395)
+* [`collapsible_if`] fixed FP on block stmt before expr
+  [#14730](https://github.com/rust-lang/rust-clippy/pull/14730)
+
+### ICE Fixes
+
+* [`missing_const_for_fn`] fix ICE with `-Z validate-mir` compilation option
+  [#14776](https://github.com/rust-lang/rust-clippy/pull/14776)
+
+### Documentation Improvements
+
+* [`missing_asserts_for_indexing`] improved documentation and examples
+  [#14108](https://github.com/rust-lang/rust-clippy/pull/14108)
+
+### Others
+
+* We're testing with edition 2024 now
+  [#14602](https://github.com/rust-lang/rust-clippy/pull/14602)
+* Don't warn about unloaded crates in `clippy.toml` disallowed paths
+  [#14733](https://github.com/rust-lang/rust-clippy/pull/14733)
 
 ## Rust 1.87
 
@@ -5729,6 +5816,7 @@ Released 2018-09-13
 [`disallowed_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_type
 [`disallowed_types`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types
 [`diverging_sub_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#diverging_sub_expression
+[`doc_broken_link`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_broken_link
 [`doc_comment_double_space_linebreaks`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_comment_double_space_linebreaks
 [`doc_include_without_cfg`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_include_without_cfg
 [`doc_lazy_continuation`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_lazy_continuation
@@ -5967,6 +6055,7 @@ Released 2018-09-13
 [`manual_is_ascii_check`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check
 [`manual_is_finite`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_finite
 [`manual_is_infinite`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_infinite
+[`manual_is_multiple_of`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_multiple_of
 [`manual_is_power_of_two`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_power_of_two
 [`manual_is_variant_and`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_variant_and
 [`manual_let_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else
diff --git a/Cargo.toml b/Cargo.toml
index 13cf82a062b..1278427b5a7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy"
-version = "0.1.89"
+version = "0.1.90"
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
 readme = "README.md"
@@ -24,6 +24,7 @@ path = "src/driver.rs"
 clippy_config = { path = "clippy_config" }
 clippy_lints = { path = "clippy_lints" }
 clippy_utils = { path = "clippy_utils" }
+declare_clippy_lint = { path = "declare_clippy_lint" }
 rustc_tools_util = { path = "rustc_tools_util", version = "0.4.2" }
 clippy_lints_internal = { path = "clippy_lints_internal", optional = true }
 tempfile = { version = "3.20", optional = true }
diff --git a/book/src/README.md b/book/src/README.md
index 5d2c3972b06..db73b49ecc2 100644
--- a/book/src/README.md
+++ b/book/src/README.md
@@ -1,5 +1,9 @@
 # Clippy
 
+[### IMPORTANT NOTE FOR CONTRIBUTORS ================](development/feature_freeze.md)
+
+----
+
 [![License: MIT OR Apache-2.0](https://img.shields.io/crates/l/clippy.svg)](https://github.com/rust-lang/rust-clippy#license)
 
 A collection of lints to catch common mistakes and improve your
diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md
index 39fe7358ed8..b66c3481e49 100644
--- a/book/src/SUMMARY.md
+++ b/book/src/SUMMARY.md
@@ -13,6 +13,7 @@
     - [GitLab CI](continuous_integration/gitlab.md)
     - [Travis CI](continuous_integration/travis.md)
 - [Development](development/README.md)
+    - [IMPORTANT: FEATURE FREEZE](development/feature_freeze.md)
     - [Basics](development/basics.md)
     - [Adding Lints](development/adding_lints.md)
     - [Defining Lints](development/defining_lints.md)
diff --git a/book/src/development/adding_lints.md b/book/src/development/adding_lints.md
index 2b89e94cf8f..a42a2983744 100644
--- a/book/src/development/adding_lints.md
+++ b/book/src/development/adding_lints.md
@@ -1,5 +1,8 @@
 # Adding a new lint
 
+[### IMPORTANT NOTE FOR CONTRIBUTORS ================](feature_freeze.md)
+
+
 You are probably here because you want to add a new lint to Clippy. If this is
 the first time you're contributing to Clippy, this document guides you through
 creating an example lint from scratch.
diff --git a/book/src/development/feature_freeze.md b/book/src/development/feature_freeze.md
new file mode 100644
index 00000000000..260cb136cc0
--- /dev/null
+++ b/book/src/development/feature_freeze.md
@@ -0,0 +1,55 @@
+# IMPORTANT: FEATURE FREEZE
+
+This is a temporary notice.
+
+From the 26th of June until the 18th of September we will perform a feature freeze. Only bugfix PRs will be reviewed
+except already open ones. Every feature-adding PR opened in between those dates will be moved into a
+milestone to be reviewed separately at another time.
+
+We do this because of the long backlog of bugs that need to be addressed
+in order to continue being the state-of-the-art linter that Clippy has become known for being.
+
+## For contributors
+
+If you are a contributor or are planning to become one, **please do not open a lint-adding PR**, we have lots of open
+bugs of all levels of difficulty that you can address instead!
+
+We currently have about 800 lints, each one posing a maintainability challenge that needs to account to every possible
+use case of the whole ecosystem. Bugs are natural in every software, but the Clippy team considers that Clippy needs a
+refinement period.
+
+If you open a PR at this time, we will not review it but push it into a milestone until the refinement period ends,
+adding additional load into our reviewing schedules.
+
+## I want to help, what can I do
+
+Thanks a lot to everyone who wants to help Clippy become better software in this feature freeze period!
+If you'd like to help, making a bugfix, making sure that it works, and opening a PR is a great step!
+
+To find things to fix, go to the [tracking issue][tracking_issue], find an issue that you like, go there and claim that
+issue with `@rustbot claim`.
+
+As a general metric and always taking into account your skill and knowledge level, you can use this guide:
+
+- 🟥 [ICEs][search_ice], these are compiler errors that causes Clippy to panic and crash. Usually involves high-level
+debugging, sometimes interacting directly with the upstream compiler. Difficult to fix but a great challenge that
+improves a lot developer workflows!
+
+- 🟧 [Suggestion causes bug][sugg_causes_bug], Clippy suggested code that changed logic in some silent way.
+Unacceptable, as this may have disastrous consequences. Easier to fix than ICEs
+
+- 🟨 [Suggestion causes error][sugg_causes_error], Clippy suggested code snippet that caused a compiler error
+when applied. We need to make sure that Clippy doesn't suggest using a variable twice at the same time or similar
+easy-to-happen occurrences.
+
+- 🟩 [False positives][false_positive], a lint should not have fired, the easiest of them all, as this is "just"
+identifying the root of a false positive and making an exception for those cases.
+
+Note that false negatives do not have priority unless the case is very clear, as they are a feature-request in a
+trench coat.
+
+[search_ice]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc+state%3Aopen+label%3A%22I-ICE%22
+[sugg_causes_bug]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc%20state%3Aopen%20label%3AI-suggestion-causes-bug
+[sugg_causes_error]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc%20state%3Aopen%20label%3AI-suggestion-causes-error%20
+[false_positive]: https://github.com/rust-lang/rust-clippy/issues?q=sort%3Aupdated-desc%20state%3Aopen%20label%3AI-false-positive
+[tracking_issue]: https://github.com/rust-lang/rust-clippy/issues/15086
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 7c850b4b023..e9b7f42a183 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -488,6 +488,13 @@ The maximum cognitive complexity a function can have
 ## `disallowed-macros`
 The list of disallowed macros, written as fully qualified paths.
 
+**Fields:**
+- `path` (required): the fully qualified path to the macro that should be disallowed
+- `reason` (optional): explanation why this macro is disallowed
+- `replacement` (optional): suggested alternative macro
+- `allow-invalid` (optional, `false` by default): when set to `true`, it will ignore this entry
+  if the path doesn't exist, instead of emitting an error
+
 **Default Value:** `[]`
 
 ---
@@ -498,6 +505,13 @@ The list of disallowed macros, written as fully qualified paths.
 ## `disallowed-methods`
 The list of disallowed methods, written as fully qualified paths.
 
+**Fields:**
+- `path` (required): the fully qualified path to the method that should be disallowed
+- `reason` (optional): explanation why this method is disallowed
+- `replacement` (optional): suggested alternative method
+- `allow-invalid` (optional, `false` by default): when set to `true`, it will ignore this entry
+  if the path doesn't exist, instead of emitting an error
+
 **Default Value:** `[]`
 
 ---
@@ -520,6 +534,13 @@ default configuration of Clippy. By default, any configuration will replace the
 ## `disallowed-types`
 The list of disallowed types, written as fully qualified paths.
 
+**Fields:**
+- `path` (required): the fully qualified path to the type that should be disallowed
+- `reason` (optional): explanation why this type is disallowed
+- `replacement` (optional): suggested alternative type
+- `allow-invalid` (optional, `false` by default): when set to `true`, it will ignore this entry
+  if the path doesn't exist, instead of emitting an error
+
 **Default Value:** `[]`
 
 ---
@@ -651,13 +672,14 @@ The maximum size of the `Err`-variant in a `Result` returned from a function
 
 
 ## `lint-commented-code`
-Whether collapsible `if` chains are linted if they contain comments inside the parts
+Whether collapsible `if` and `else if` chains are linted if they contain comments inside the parts
 that would be collapsed.
 
 **Default Value:** `false`
 
 ---
 **Affected lints:**
+* [`collapsible_else_if`](https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_else_if)
 * [`collapsible_if`](https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if)
 
 
diff --git a/clippy_config/Cargo.toml b/clippy_config/Cargo.toml
index 0606245f990..858366c8a5c 100644
--- a/clippy_config/Cargo.toml
+++ b/clippy_config/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_config"
-version = "0.1.89"
+version = "0.1.90"
 edition = "2024"
 publish = false
 
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 87158cec42b..841facdca06 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -575,10 +575,24 @@ define_Conf! {
     #[conf_deprecated("Please use `cognitive-complexity-threshold` instead", cognitive_complexity_threshold)]
     cyclomatic_complexity_threshold: u64 = 25,
     /// The list of disallowed macros, written as fully qualified paths.
+    ///
+    /// **Fields:**
+    /// - `path` (required): the fully qualified path to the macro that should be disallowed
+    /// - `reason` (optional): explanation why this macro is disallowed
+    /// - `replacement` (optional): suggested alternative macro
+    /// - `allow-invalid` (optional, `false` by default): when set to `true`, it will ignore this entry
+    ///   if the path doesn't exist, instead of emitting an error
     #[disallowed_paths_allow_replacements = true]
     #[lints(disallowed_macros)]
     disallowed_macros: Vec<DisallowedPath> = Vec::new(),
     /// The list of disallowed methods, written as fully qualified paths.
+    ///
+    /// **Fields:**
+    /// - `path` (required): the fully qualified path to the method that should be disallowed
+    /// - `reason` (optional): explanation why this method is disallowed
+    /// - `replacement` (optional): suggested alternative method
+    /// - `allow-invalid` (optional, `false` by default): when set to `true`, it will ignore this entry
+    ///   if the path doesn't exist, instead of emitting an error
     #[disallowed_paths_allow_replacements = true]
     #[lints(disallowed_methods)]
     disallowed_methods: Vec<DisallowedPath> = Vec::new(),
@@ -588,6 +602,13 @@ define_Conf! {
     #[lints(disallowed_names)]
     disallowed_names: Vec<String> = DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect(),
     /// The list of disallowed types, written as fully qualified paths.
+    ///
+    /// **Fields:**
+    /// - `path` (required): the fully qualified path to the type that should be disallowed
+    /// - `reason` (optional): explanation why this type is disallowed
+    /// - `replacement` (optional): suggested alternative type
+    /// - `allow-invalid` (optional, `false` by default): when set to `true`, it will ignore this entry
+    ///   if the path doesn't exist, instead of emitting an error
     #[disallowed_paths_allow_replacements = true]
     #[lints(disallowed_types)]
     disallowed_types: Vec<DisallowedPath> = Vec::new(),
@@ -641,9 +662,9 @@ define_Conf! {
     /// The maximum size of the `Err`-variant in a `Result` returned from a function
     #[lints(result_large_err)]
     large_error_threshold: u64 = 128,
-    /// Whether collapsible `if` chains are linted if they contain comments inside the parts
+    /// Whether collapsible `if` and `else if` chains are linted if they contain comments inside the parts
     /// that would be collapsed.
-    #[lints(collapsible_if)]
+    #[lints(collapsible_else_if, collapsible_if)]
     lint_commented_code: bool = false,
     /// Whether to suggest reordering constructor fields when initializers are present.
     /// DEPRECATED CONFIGURATION: lint-inconsistent-struct-field-initializers
diff --git a/clippy_dev/src/lint.rs b/clippy_dev/src/lint.rs
index e0e036757d5..0d66f167a38 100644
--- a/clippy_dev/src/lint.rs
+++ b/clippy_dev/src/lint.rs
@@ -13,7 +13,7 @@ pub fn run<'a>(path: &str, edition: &str, args: impl Iterator<Item = &'a String>
 
     if is_file {
         exit_if_err(
-            Command::new(env::var("CARGO").unwrap_or("cargo".into()))
+            Command::new(env::var("CARGO").unwrap_or_else(|_| "cargo".into()))
                 .args(["run", "--bin", "clippy-driver", "--"])
                 .args(["-L", "./target/debug"])
                 .args(["-Z", "no-codegen"])
@@ -26,7 +26,7 @@ pub fn run<'a>(path: &str, edition: &str, args: impl Iterator<Item = &'a String>
         );
     } else {
         exit_if_err(
-            Command::new(env::var("CARGO").unwrap_or("cargo".into()))
+            Command::new(env::var("CARGO").unwrap_or_else(|_| "cargo".into()))
                 .arg("build")
                 .status(),
         );
diff --git a/clippy_dev/src/release.rs b/clippy_dev/src/release.rs
index 62c1bee8185..15392dd1d29 100644
--- a/clippy_dev/src/release.rs
+++ b/clippy_dev/src/release.rs
@@ -5,6 +5,7 @@ static CARGO_TOML_FILES: &[&str] = &[
     "clippy_config/Cargo.toml",
     "clippy_lints/Cargo.toml",
     "clippy_utils/Cargo.toml",
+    "declare_clippy_lint/Cargo.toml",
     "Cargo.toml",
 ];
 
diff --git a/clippy_dev/src/serve.rs b/clippy_dev/src/serve.rs
index a2d1236629f..498ffeba9d6 100644
--- a/clippy_dev/src/serve.rs
+++ b/clippy_dev/src/serve.rs
@@ -28,7 +28,7 @@ pub fn run(port: u16, lint: Option<String>) -> ! {
         .map(mtime);
 
         if times.iter().any(|&time| index_time < time) {
-            Command::new(env::var("CARGO").unwrap_or("cargo".into()))
+            Command::new(env::var("CARGO").unwrap_or_else(|_| "cargo".into()))
                 .arg("collect-metadata")
                 .spawn()
                 .unwrap()
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 3b827cc5603..5f6e874ffe2 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -2,11 +2,11 @@ use crate::utils::{
     ErrAction, File, FileUpdater, RustSearcher, Token, UpdateMode, UpdateStatus, expect_action, update_text_region_fn,
 };
 use itertools::Itertools;
-use rustc_lexer::{LiteralKind, TokenKind, tokenize};
 use std::collections::HashSet;
 use std::fmt::Write;
+use std::fs;
 use std::ops::Range;
-use std::path::{Path, PathBuf};
+use std::path::{self, Path, PathBuf};
 use walkdir::{DirEntry, WalkDir};
 
 const GENERATED_FILE_COMMENT: &str = "// This file was generated by `cargo dev update_lints`.\n\
@@ -37,123 +37,164 @@ pub fn generate_lint_files(
     deprecated: &[DeprecatedLint],
     renamed: &[RenamedLint],
 ) {
-    FileUpdater::default().update_files_checked(
+    let mut updater = FileUpdater::default();
+    updater.update_file_checked(
         "cargo dev update_lints",
         update_mode,
-        &mut [
-            (
-                "README.md",
-                &mut update_text_region_fn("[There are over ", " lints included in this crate!]", |dst| {
-                    write!(dst, "{}", round_to_fifty(lints.len())).unwrap();
-                }),
-            ),
-            (
-                "book/src/README.md",
-                &mut update_text_region_fn("[There are over ", " lints included in this crate!]", |dst| {
-                    write!(dst, "{}", round_to_fifty(lints.len())).unwrap();
-                }),
-            ),
-            (
-                "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
-                            .iter()
-                            .map(|l| &*l.name)
-                            .chain(deprecated.iter().filter_map(|l| l.name.strip_prefix("clippy::")))
-                            .chain(renamed.iter().filter_map(|l| l.old_name.strip_prefix("clippy::")))
-                            .sorted()
-                        {
-                            writeln!(dst, "[`{lint}`]: {DOCS_LINK}#{lint}").unwrap();
-                        }
-                    },
-                ),
-            ),
-            (
-                "clippy_lints/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| {
-                        for lint_mod in lints.iter().map(|l| &l.module).sorted().dedup() {
-                            writeln!(dst, "mod {lint_mod};").unwrap();
-                        }
-                    },
-                ),
-            ),
-            ("clippy_lints/src/declared_lints.rs", &mut |_, src, dst| {
-                dst.push_str(GENERATED_FILE_COMMENT);
-                dst.push_str("pub static LINTS: &[&crate::LintInfo] = &[\n");
-                for (module_name, lint_name) in lints.iter().map(|l| (&l.module, l.name.to_uppercase())).sorted() {
-                    writeln!(dst, "    crate::{module_name}::{lint_name}_INFO,").unwrap();
-                }
-                dst.push_str("];\n");
-                UpdateStatus::from_changed(src != dst)
-            }),
-            ("clippy_lints/src/deprecated_lints.rs", &mut |_, src, dst| {
-                let mut searcher = RustSearcher::new(src);
-                assert!(
-                    searcher.find_token(Token::Ident("declare_with_version"))
-                        && searcher.find_token(Token::Ident("declare_with_version")),
-                    "error reading deprecated lints"
-                );
-                dst.push_str(&src[..searcher.pos() as usize]);
-                dst.push_str("! { DEPRECATED(DEPRECATED_VERSION) = [\n");
-                for lint in deprecated {
-                    write!(
-                        dst,
-                        "    #[clippy::version = \"{}\"]\n    (\"{}\", \"{}\"),\n",
-                        lint.version, lint.name, lint.reason,
-                    )
-                    .unwrap();
+        "README.md",
+        &mut update_text_region_fn("[There are over ", " lints included in this crate!]", |dst| {
+            write!(dst, "{}", round_to_fifty(lints.len())).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, "{}", round_to_fifty(lints.len())).unwrap();
+        }),
+    );
+    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
+                    .iter()
+                    .map(|l| &*l.name)
+                    .chain(deprecated.iter().filter_map(|l| l.name.strip_prefix("clippy::")))
+                    .chain(renamed.iter().filter_map(|l| l.old_name.strip_prefix("clippy::")))
+                    .sorted()
+                {
+                    writeln!(dst, "[`{lint}`]: {DOCS_LINK}#{lint}").unwrap();
                 }
-                dst.push_str(
-                    "]}\n\n\
+            },
+        ),
+    );
+    updater.update_file_checked(
+        "cargo dev update_lints",
+        update_mode,
+        "clippy_lints/src/deprecated_lints.rs",
+        &mut |_, src, dst| {
+            let mut searcher = RustSearcher::new(src);
+            assert!(
+                searcher.find_token(Token::Ident("declare_with_version"))
+                    && searcher.find_token(Token::Ident("declare_with_version")),
+                "error reading deprecated lints"
+            );
+            dst.push_str(&src[..searcher.pos() as usize]);
+            dst.push_str("! { DEPRECATED(DEPRECATED_VERSION) = [\n");
+            for lint in deprecated {
+                write!(
+                    dst,
+                    "    #[clippy::version = \"{}\"]\n    (\"{}\", \"{}\"),\n",
+                    lint.version, lint.name, lint.reason,
+                )
+                .unwrap();
+            }
+            dst.push_str(
+                "]}\n\n\
                     #[rustfmt::skip]\n\
                     declare_with_version! { RENAMED(RENAMED_VERSION) = [\n\
                 ",
-                );
-                for lint in renamed {
-                    write!(
-                        dst,
-                        "    #[clippy::version = \"{}\"]\n    (\"{}\", \"{}\"),\n",
-                        lint.version, lint.old_name, lint.new_name,
-                    )
-                    .unwrap();
+            );
+            for lint in renamed {
+                write!(
+                    dst,
+                    "    #[clippy::version = \"{}\"]\n    (\"{}\", \"{}\"),\n",
+                    lint.version, lint.old_name, lint.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({})] //~ ERROR: lint `{}`", lint.name, lint.name).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();
                 }
-                dst.push_str("]}\n");
-                UpdateStatus::from_changed(src != dst)
-            }),
-            ("tests/ui/deprecated.rs", &mut |_, src, dst| {
-                dst.push_str(GENERATED_FILE_COMMENT);
-                for lint in deprecated {
-                    writeln!(dst, "#![warn({})] //~ ERROR: lint `{}`", lint.name, lint.name).unwrap();
+            }
+            seen_lints.clear();
+            for lint in renamed {
+                if seen_lints.insert(&lint.old_name) {
+                    writeln!(dst, "#![warn({})] //~ ERROR: lint `{}`", lint.old_name, lint.old_name).unwrap();
                 }
-                dst.push_str("\nfn main() {}\n");
-                UpdateStatus::from_changed(src != dst)
-            }),
-            ("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();
+            }
+            dst.push_str("\nfn main() {}\n");
+            UpdateStatus::from_changed(src != dst)
+        },
+    );
+    for (crate_name, lints) in lints.iter().into_group_map_by(|&l| {
+        let Some(path::Component::Normal(name)) = l.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 `{}`", l.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| {
+                    for lint_mod in lints
+                        .iter()
+                        .filter(|l| !l.module.is_empty())
+                        .map(|l| l.module.split_once("::").map_or(&*l.module, |x| x.0))
+                        .sorted()
+                        .dedup()
+                    {
+                        writeln!(dst, "mod {lint_mod};").unwrap();
                     }
-                }
-                seen_lints.clear();
-                for lint in renamed {
-                    if seen_lints.insert(&lint.old_name) {
-                        writeln!(dst, "#![warn({})] //~ ERROR: lint `{}`", lint.old_name, lint.old_name).unwrap();
+                },
+            ),
+        );
+        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");
+                for (module_path, lint_name) in lints.iter().map(|l| (&l.module, l.name.to_uppercase())).sorted() {
+                    if module_path.is_empty() {
+                        writeln!(dst, "    crate::{lint_name}_INFO,").unwrap();
+                    } else {
+                        writeln!(dst, "    crate::{module_path}::{lint_name}_INFO,").unwrap();
                     }
                 }
-                dst.push_str("\nfn main() {}\n");
+                dst.push_str("];\n");
                 UpdateStatus::from_changed(src != dst)
-            }),
-        ],
-    );
+            },
+        );
+    }
 }
 
 fn round_to_fifty(count: usize) -> usize {
@@ -187,13 +228,25 @@ pub struct RenamedLint {
 pub fn find_lint_decls() -> Vec<Lint> {
     let mut lints = Vec::with_capacity(1000);
     let mut contents = String::new();
-    for (file, module) in read_src_with_module("clippy_lints/src".as_ref()) {
-        parse_clippy_lint_decls(
-            file.path(),
-            File::open_read_to_cleared_string(file.path(), &mut contents),
-            &module,
-            &mut lints,
-        );
+    for e in expect_action(fs::read_dir("."), ErrAction::Read, ".") {
+        let e = expect_action(e, ErrAction::Read, ".");
+        if !expect_action(e.file_type(), ErrAction::Read, ".").is_dir() {
+            continue;
+        }
+        let Ok(mut name) = e.file_name().into_string() else {
+            continue;
+        };
+        if name.starts_with("clippy_lints") && name != "clippy_lints_internal" {
+            name.push_str("/src");
+            for (file, module) in read_src_with_module(name.as_ref()) {
+                parse_clippy_lint_decls(
+                    file.path(),
+                    File::open_read_to_cleared_string(file.path(), &mut contents),
+                    &module,
+                    &mut lints,
+                );
+            }
+        }
     }
     lints.sort_by(|lhs, rhs| lhs.name.cmp(&rhs.name));
     lints
@@ -205,7 +258,7 @@ fn read_src_with_module(src_root: &Path) -> impl use<'_> + Iterator<Item = (DirE
         let e = expect_action(e, ErrAction::Read, src_root);
         let path = e.path().as_os_str().as_encoded_bytes();
         if let Some(path) = path.strip_suffix(b".rs")
-            && let Some(path) = path.get("clippy_lints/src/".len()..)
+            && let Some(path) = path.get(src_root.as_os_str().len() + 1..)
         {
             if path == b"lib" {
                 Some((e, String::new()))
@@ -333,17 +386,13 @@ pub fn read_deprecated_lints() -> (Vec<DeprecatedLint>, Vec<RenamedLint>) {
 
 /// Removes the line splices and surrounding quotes from a string literal
 fn parse_str_lit(s: &str) -> String {
-    let (s, mode) = if let Some(s) = s.strip_prefix("r") {
-        (s.trim_matches('#'), rustc_literal_escaper::Mode::RawStr)
-    } else {
-        (s, rustc_literal_escaper::Mode::Str)
-    };
+    let s = s.strip_prefix("r").unwrap_or(s).trim_matches('#');
     let s = s
         .strip_prefix('"')
         .and_then(|s| s.strip_suffix('"'))
         .unwrap_or_else(|| panic!("expected quoted string, found `{s}`"));
     let mut res = String::with_capacity(s.len());
-    rustc_literal_escaper::unescape_str(s, |range, ch| {
+    rustc_literal_escaper::unescape_str(s, &mut |_, ch| {
         if let Ok(ch) = ch {
             res.push(ch);
         }
diff --git a/clippy_dev/src/utils.rs b/clippy_dev/src/utils.rs
index c4808b7048b..89962a11034 100644
--- a/clippy_dev/src/utils.rs
+++ b/clippy_dev/src/utils.rs
@@ -383,21 +383,6 @@ impl FileUpdater {
         self.update_file_checked_inner(tool, mode, path.as_ref(), update);
     }
 
-    #[expect(clippy::type_complexity)]
-    pub fn update_files_checked(
-        &mut self,
-        tool: &str,
-        mode: UpdateMode,
-        files: &mut [(
-            impl AsRef<Path>,
-            &mut dyn FnMut(&Path, &str, &mut String) -> UpdateStatus,
-        )],
-    ) {
-        for (path, update) in files {
-            self.update_file_checked_inner(tool, mode, path.as_ref(), update);
-        }
-    }
-
     pub fn update_file(
         &mut self,
         path: impl AsRef<Path>,
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 39e4e2e365e..c03cc99b581 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_lints"
-version = "0.1.89"
+version = "0.1.90"
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
 readme = "README.md"
@@ -13,6 +13,7 @@ arrayvec = { version = "0.7", default-features = false }
 cargo_metadata = "0.18"
 clippy_config = { path = "../clippy_config" }
 clippy_utils = { path = "../clippy_utils" }
+declare_clippy_lint = { path = "../declare_clippy_lint" }
 itertools = "0.12"
 quine-mc_cluskey = "0.2"
 regex-syntax = "0.8"
diff --git a/clippy_lints/src/attrs/inline_always.rs b/clippy_lints/src/attrs/inline_always.rs
index 58e51128a0d..b8f93ee5e2c 100644
--- a/clippy_lints/src/attrs/inline_always.rs
+++ b/clippy_lints/src/attrs/inline_always.rs
@@ -1,10 +1,10 @@
 use super::INLINE_ALWAYS;
 use clippy_utils::diagnostics::span_lint;
-use rustc_attr_data_structures::{find_attr, AttributeKind, InlineAttr};
+use rustc_attr_data_structures::{AttributeKind, InlineAttr, find_attr};
 use rustc_hir::Attribute;
 use rustc_lint::LateContext;
-use rustc_span::symbol::Symbol;
 use rustc_span::Span;
+use rustc_span::symbol::Symbol;
 
 pub(super) fn check(cx: &LateContext<'_>, span: Span, name: Symbol, attrs: &[Attribute]) {
     if span.from_expansion() {
diff --git a/clippy_lints/src/attrs/mod.rs b/clippy_lints/src/attrs/mod.rs
index 9a124298041..91c2dc7f3dc 100644
--- a/clippy_lints/src/attrs/mod.rs
+++ b/clippy_lints/src/attrs/mod.rs
@@ -207,7 +207,7 @@ declare_clippy_lint! {
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of the `#[allow]` attribute and suggests replacing it with
-    /// the `#[expect]` (See [RFC 2383](https://rust-lang.github.io/rfcs/2383-lint-reasons.html))
+    /// 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.
diff --git a/clippy_lints/src/attrs/utils.rs b/clippy_lints/src/attrs/utils.rs
index a5ce2137bff..7b66f91f6c0 100644
--- a/clippy_lints/src/attrs/utils.rs
+++ b/clippy_lints/src/attrs/utils.rs
@@ -46,11 +46,13 @@ pub(super) fn is_relevant_trait(cx: &LateContext<'_>, item: &TraitItem<'_>) -> b
 }
 
 fn is_relevant_block(cx: &LateContext<'_>, typeck_results: &ty::TypeckResults<'_>, block: &Block<'_>) -> bool {
-    block.stmts.first().map_or(
-        block
-            .expr
-            .as_ref()
-            .is_some_and(|e| is_relevant_expr(cx, typeck_results, e)),
+    block.stmts.first().map_or_else(
+        || {
+            block
+                .expr
+                .as_ref()
+                .is_some_and(|e| is_relevant_expr(cx, typeck_results, e))
+        },
         |stmt| match &stmt.kind {
             StmtKind::Let(_) => true,
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => is_relevant_expr(cx, typeck_results, expr),
diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index 7cde007a9b6..70c9c45a60c 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -2,9 +2,9 @@ use crate::reference::DEREF_ADDROF;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{get_parent_expr, is_from_proc_macro, is_lint_allowed, is_mutable};
+use clippy_utils::{get_parent_expr, is_expr_temporary_value, is_from_proc_macro, is_lint_allowed, is_mutable};
 use rustc_errors::Applicability;
-use rustc_hir::{BorrowKind, ExprKind, UnOp};
+use rustc_hir::{BorrowKind, Expr, ExprKind, Node, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty;
@@ -48,7 +48,7 @@ declare_clippy_lint! {
 declare_lint_pass!(BorrowDerefRef => [BORROW_DEREF_REF]);
 
 impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &rustc_hir::Expr<'tcx>) {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) {
         if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, addrof_target) = e.kind
             && let ExprKind::Unary(UnOp::Deref, deref_target) = addrof_target.kind
             && !matches!(deref_target.kind, ExprKind::Unary(UnOp::Deref, ..))
@@ -76,6 +76,9 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
             && let e_ty = cx.typeck_results().expr_ty_adjusted(e)
             // check if the reference is coercing to a mutable reference
             && (!matches!(e_ty.kind(), ty::Ref(_, _, Mutability::Mut)) || is_mutable(cx, deref_target))
+            // If the new borrow might be itself borrowed mutably and the original reference is not a temporary
+            // value, do not propose to use it directly.
+            && (is_expr_temporary_value(cx, deref_target) || !potentially_bound_to_mutable_ref(cx, e))
             && let Some(deref_text) = deref_target.span.get_source_text(cx)
         {
             span_lint_and_then(
@@ -110,3 +113,9 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
         }
     }
 }
+
+/// Checks if `expr` is used as part of a `let` statement containing a `ref mut` binding.
+fn potentially_bound_to_mutable_ref<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+    matches!(cx.tcx.parent_hir_node(expr.hir_id), Node::LetStmt(let_stmt)
+             if let_stmt.pat.contains_explicit_ref_binding() == Some(Mutability::Mut))
+}
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index 9a1ad8a7473..a70bd886191 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -168,7 +168,7 @@ fn pow_call_result_sign(cx: &LateContext<'_>, base: &Expr<'_>, exponent: &Expr<'
 
     // Rust's integer pow() functions take an unsigned exponent.
     let exponent_val = get_const_unsigned_int_eval(cx, exponent, None);
-    let exponent_is_even = exponent_val.map(|val| val % 2 == 0);
+    let exponent_is_even = exponent_val.map(|val| val.is_multiple_of(2));
 
     match (base_sign, exponent_is_even) {
         // Non-negative bases always return non-negative results, ignoring overflow.
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index 7f6ecea99fb..1854d86c53b 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -1,13 +1,16 @@
 use clippy_config::Conf;
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::{IntoSpan as _, SpanRangeExt, snippet, snippet_block, snippet_block_with_applicability};
+use clippy_utils::source::{IntoSpan as _, SpanRangeExt, snippet, snippet_block_with_applicability};
+use clippy_utils::{span_contains_non_whitespace, tokenize_with_text};
 use rustc_ast::BinOpKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, Stmt, StmtKind};
+use rustc_lexer::TokenKind;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
-use rustc_span::Span;
+use rustc_span::source_map::SourceMap;
+use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -90,35 +93,74 @@ impl CollapsibleIf {
         }
     }
 
-    fn check_collapsible_else_if(cx: &LateContext<'_>, then_span: Span, else_block: &Block<'_>) {
-        if !block_starts_with_comment(cx, else_block)
-            && let Some(else_) = expr_block(else_block)
+    fn check_collapsible_else_if(&self, cx: &LateContext<'_>, then_span: Span, else_block: &Block<'_>) {
+        if let Some(else_) = expr_block(else_block)
             && cx.tcx.hir_attrs(else_.hir_id).is_empty()
             && !else_.span.from_expansion()
-            && let ExprKind::If(..) = else_.kind
+            && let ExprKind::If(else_if_cond, ..) = else_.kind
+            && !block_starts_with_significant_tokens(cx, else_block, else_, self.lint_commented_code)
         {
-            // Prevent "elseif"
-            // Check that the "else" is followed by whitespace
-            let up_to_else = then_span.between(else_block.span);
-            let requires_space = if let Some(c) = snippet(cx, up_to_else, "..").chars().last() {
-                !c.is_whitespace()
-            } else {
-                false
-            };
-
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 COLLAPSIBLE_ELSE_IF,
                 else_block.span,
                 "this `else { if .. }` block can be collapsed",
-                "collapse nested if block",
-                format!(
-                    "{}{}",
-                    if requires_space { " " } else { "" },
-                    snippet_block_with_applicability(cx, else_.span, "..", Some(else_block.span), &mut applicability)
-                ),
-                applicability,
+                |diag| {
+                    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 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();
+                        let else_closing_bracket = {
+                            let end = else_block.span.shrink_to_hi();
+                            end.with_lo(end.lo() - BytePos(1))
+                                .with_leading_whitespace(cx)
+                                .into_span()
+                        };
+                        let sugg = vec![
+                            // Remove the outer else block `else`
+                            (else_keyword_span, String::new()),
+                            // Replace the inner `if` by `else if`
+                            (else_if_keyword_span, String::from("else if")),
+                            // Remove the outer else block `{`
+                            (else_open_bracket, String::new()),
+                            // Remove the outer else block '}'
+                            (else_closing_bracket, String::new()),
+                        ];
+                        diag.multipart_suggestion("collapse nested if block", sugg, Applicability::MachineApplicable);
+                        return;
+                    }
+
+                    // Prevent "elseif"
+                    // Check that the "else" is followed by whitespace
+                    let requires_space = if let Some(c) = snippet(cx, up_to_else, "..").chars().last() {
+                        !c.is_whitespace()
+                    } else {
+                        false
+                    };
+                    let mut applicability = Applicability::MachineApplicable;
+                    diag.span_suggestion(
+                        else_block.span,
+                        "collapse nested if block",
+                        format!(
+                            "{}{}",
+                            if requires_space { " " } else { "" },
+                            snippet_block_with_applicability(
+                                cx,
+                                else_.span,
+                                "..",
+                                Some(else_block.span),
+                                &mut applicability
+                            )
+                        ),
+                        applicability,
+                    );
+                },
             );
         }
     }
@@ -130,7 +172,7 @@ impl CollapsibleIf {
             && self.eligible_condition(cx, check_inner)
             && let ctxt = expr.span.ctxt()
             && inner.span.ctxt() == ctxt
-            && (self.lint_commented_code || !block_starts_with_comment(cx, then))
+            && !block_starts_with_significant_tokens(cx, then, inner, self.lint_commented_code)
         {
             span_lint_and_then(
                 cx,
@@ -141,7 +183,7 @@ impl CollapsibleIf {
                     let then_open_bracket = then.span.split_at(1).0.with_leading_whitespace(cx).into_span();
                     let then_closing_bracket = {
                         let end = then.span.shrink_to_hi();
-                        end.with_lo(end.lo() - rustc_span::BytePos(1))
+                        end.with_lo(end.lo() - BytePos(1))
                             .with_leading_whitespace(cx)
                             .into_span()
                     };
@@ -179,7 +221,7 @@ impl LateLintPass<'_> for CollapsibleIf {
             if let Some(else_) = else_
                 && let ExprKind::Block(else_, None) = else_.kind
             {
-                Self::check_collapsible_else_if(cx, then.span, else_);
+                self.check_collapsible_else_if(cx, then.span, else_);
             } else if else_.is_none()
                 && self.eligible_condition(cx, cond)
                 && let ExprKind::Block(then, None) = then.kind
@@ -190,12 +232,16 @@ impl LateLintPass<'_> for CollapsibleIf {
     }
 }
 
-fn block_starts_with_comment(cx: &LateContext<'_>, block: &Block<'_>) -> bool {
-    // We trim all opening braces and whitespaces and then check if the next string is a comment.
-    let trimmed_block_text = snippet_block(cx, block.span, "..", None)
-        .trim_start_matches(|c: char| c.is_whitespace() || c == '{')
-        .to_owned();
-    trimmed_block_text.starts_with("//") || trimmed_block_text.starts_with("/*")
+// Check that nothing significant can be found but whitespaces between the initial `{` of `block`
+// and the beginning of `stop_at`.
+fn block_starts_with_significant_tokens(
+    cx: &LateContext<'_>,
+    block: &Block<'_>,
+    stop_at: &Expr<'_>,
+    lint_commented_code: bool,
+) -> bool {
+    let span = block.span.split_at(1).1.until(stop_at.span);
+    span_contains_non_whitespace(cx, span, lint_commented_code)
 }
 
 /// If `block` is a block with either one expression or a statement containing an expression,
@@ -226,3 +272,16 @@ fn parens_around(expr: &Expr<'_>) -> Vec<(Span, String)> {
         vec![]
     }
 }
+
+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()
+}
diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs
index 5ef726638a5..27918698cd6 100644
--- a/clippy_lints/src/copies.rs
+++ b/clippy_lints/src/copies.rs
@@ -11,7 +11,7 @@ use clippy_utils::{
 use core::iter;
 use core::ops::ControlFlow;
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, HirIdSet, Stmt, StmtKind, intravisit};
+use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, HirIdSet, LetStmt, Node, Stmt, StmtKind, intravisit};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::impl_lint_pass;
@@ -295,7 +295,7 @@ fn lint_branches_sharing_code<'tcx>(
                 sugg,
                 Applicability::Unspecified,
             );
-            if !cx.typeck_results().expr_ty(expr).is_unit() {
+            if is_expr_parent_assignment(cx, expr) || !cx.typeck_results().expr_ty(expr).is_unit() {
                 diag.note("the end suggestion probably needs some adjustments to use the expression result correctly");
             }
         }
@@ -660,3 +660,17 @@ fn lint_same_fns_in_if_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
         );
     }
 }
+
+fn is_expr_parent_assignment(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    let parent = cx.tcx.parent_hir_node(expr.hir_id);
+    if let Node::LetStmt(LetStmt { init: Some(e), .. })
+    | Node::Expr(Expr {
+        kind: ExprKind::Assign(_, e, _),
+        ..
+    }) = parent
+    {
+        return e.hir_id == expr.hir_id;
+    }
+
+    false
+}
diff --git a/clippy_lints/src/declare_clippy_lint.rs b/clippy_lints/src/declare_clippy_lint.rs
deleted file mode 100644
index 9f82f876727..00000000000
--- a/clippy_lints/src/declare_clippy_lint.rs
+++ /dev/null
@@ -1,168 +0,0 @@
-#[macro_export]
-#[allow(clippy::crate_in_macro_def)]
-macro_rules! declare_clippy_lint {
-    (@
-        $(#[doc = $lit:literal])*
-        pub $lint_name:ident,
-        $level:ident,
-        $lintcategory:expr,
-        $desc:literal,
-        $version_expr:expr,
-        $version_lit:literal
-        $(, $eval_always: literal)?
-    ) => {
-        rustc_session::declare_tool_lint! {
-            $(#[doc = $lit])*
-            #[clippy::version = $version_lit]
-            pub clippy::$lint_name,
-            $level,
-            $desc,
-            report_in_external_macro:true
-            $(, @eval_always = $eval_always)?
-        }
-
-        pub(crate) static ${concat($lint_name, _INFO)}: &'static crate::LintInfo = &crate::LintInfo {
-            lint: &$lint_name,
-            category:  $lintcategory,
-            explanation: concat!($($lit,"\n",)*),
-            location: concat!(file!(), "#L", line!()),
-            version: $version_expr
-        };
-    };
-    (
-        $(#[doc = $lit:literal])*
-        #[clippy::version = $version:literal]
-        pub $lint_name:ident,
-        restriction,
-        $desc:literal
-        $(, @eval_always = $eval_always: literal)?
-    ) => {
-        declare_clippy_lint! {@
-            $(#[doc = $lit])*
-            pub $lint_name, Allow, crate::LintCategory::Restriction, $desc,
-            Some($version), $version
-            $(, $eval_always)?
-        }
-    };
-    (
-        $(#[doc = $lit:literal])*
-        #[clippy::version = $version:literal]
-        pub $lint_name:ident,
-        style,
-        $desc:literal
-        $(, @eval_always = $eval_always: literal)?
-    ) => {
-        declare_clippy_lint! {@
-            $(#[doc = $lit])*
-            pub $lint_name, Warn, crate::LintCategory::Style, $desc,
-            Some($version), $version
-            $(, $eval_always)?
-        }
-    };
-    (
-        $(#[doc = $lit:literal])*
-        #[clippy::version = $version:literal]
-        pub $lint_name:ident,
-        correctness,
-        $desc:literal
-        $(, @eval_always = $eval_always: literal)?
-    ) => {
-        declare_clippy_lint! {@
-            $(#[doc = $lit])*
-            pub $lint_name, Deny, crate::LintCategory::Correctness, $desc,
-            Some($version), $version
-            $(, $eval_always)?
-
-        }
-    };
-    (
-        $(#[doc = $lit:literal])*
-        #[clippy::version = $version:literal]
-        pub $lint_name:ident,
-        perf,
-        $desc:literal
-        $(, @eval_always = $eval_always: literal)?
-    ) => {
-        declare_clippy_lint! {@
-            $(#[doc = $lit])*
-            pub $lint_name, Warn, crate::LintCategory::Perf, $desc,
-            Some($version), $version
-            $(, $eval_always)?
-        }
-    };
-    (
-        $(#[doc = $lit:literal])*
-        #[clippy::version = $version:literal]
-        pub $lint_name:ident,
-        complexity,
-        $desc:literal
-        $(, @eval_always = $eval_always: literal)?
-    ) => {
-        declare_clippy_lint! {@
-            $(#[doc = $lit])*
-            pub $lint_name, Warn, crate::LintCategory::Complexity, $desc,
-            Some($version), $version
-            $(, $eval_always)?
-        }
-    };
-    (
-        $(#[doc = $lit:literal])*
-        #[clippy::version = $version:literal]
-        pub $lint_name:ident,
-        suspicious,
-        $desc:literal
-        $(, @eval_always = $eval_always: literal)?
-    ) => {
-        declare_clippy_lint! {@
-            $(#[doc = $lit])*
-            pub $lint_name, Warn, crate::LintCategory::Suspicious, $desc,
-            Some($version), $version
-            $(, $eval_always)?
-        }
-    };
-    (
-        $(#[doc = $lit:literal])*
-        #[clippy::version = $version:literal]
-        pub $lint_name:ident,
-        nursery,
-        $desc:literal
-        $(, @eval_always = $eval_always: literal)?
-    ) => {
-        declare_clippy_lint! {@
-            $(#[doc = $lit])*
-            pub $lint_name, Allow, crate::LintCategory::Nursery, $desc,
-            Some($version), $version
-            $(, $eval_always)?
-        }
-    };
-    (
-        $(#[doc = $lit:literal])*
-        #[clippy::version = $version:literal]
-        pub $lint_name:ident,
-        pedantic,
-        $desc:literal
-        $(, @eval_always = $eval_always: literal)?
-    ) => {
-        declare_clippy_lint! {@
-            $(#[doc = $lit])*
-            pub $lint_name, Allow, crate::LintCategory::Pedantic, $desc,
-            Some($version), $version
-            $(, $eval_always)?
-        }
-    };
-    (
-        $(#[doc = $lit:literal])*
-        #[clippy::version = $version:literal]
-        pub $lint_name:ident,
-        cargo,
-        $desc:literal
-        $(, @eval_always = $eval_always: literal)?
-    ) => {
-        declare_clippy_lint! {@
-            $(#[doc = $lit])*
-            pub $lint_name, Allow, crate::LintCategory::Cargo, $desc,
-            Some($version), $version
-            $(, $eval_always)?
-        }
-    };
-}
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 1e3907d9ede..c3f8e02b4c0 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -2,7 +2,7 @@
 // Use that command to update this file and do not edit by hand.
 // Manual edits will be overwritten.
 
-pub static LINTS: &[&crate::LintInfo] = &[
+pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::absolute_paths::ABSOLUTE_PATHS_INFO,
     crate::almost_complete_range::ALMOST_COMPLETE_RANGE_INFO,
     crate::approx_const::APPROX_CONSTANT_INFO,
@@ -112,6 +112,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::disallowed_names::DISALLOWED_NAMES_INFO,
     crate::disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS_INFO,
     crate::disallowed_types::DISALLOWED_TYPES_INFO,
+    crate::doc::DOC_BROKEN_LINK_INFO,
     crate::doc::DOC_COMMENT_DOUBLE_SPACE_LINEBREAKS_INFO,
     crate::doc::DOC_INCLUDE_WITHOUT_CFG_INFO,
     crate::doc::DOC_LAZY_CONTINUATION_INFO,
@@ -590,6 +591,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::operators::IMPOSSIBLE_COMPARISONS_INFO,
     crate::operators::INEFFECTIVE_BIT_MASK_INFO,
     crate::operators::INTEGER_DIVISION_INFO,
+    crate::operators::MANUAL_IS_MULTIPLE_OF_INFO,
     crate::operators::MANUAL_MIDPOINT_INFO,
     crate::operators::MISREFACTORED_ASSIGN_OP_INFO,
     crate::operators::MODULO_ARITHMETIC_INFO,
diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
index 9814d4fa84f..d55aeae98ed 100644
--- a/clippy_lints/src/disallowed_macros.rs
+++ b/clippy_lints/src/disallowed_macros.rs
@@ -40,6 +40,9 @@ declare_clippy_lint! {
     ///     # When using an inline table, can add a `reason` for why the macro
     ///     # is disallowed.
     ///     { path = "serde::Serialize", reason = "no serializing" },
+    ///     # This would normally error if the path is incorrect, but with `allow-invalid` = `true`,
+    ///     # it will be silently ignored
+    ///     { path = "std::invalid_macro", reason = "use alternative instead", allow-invalid = true }
     /// ]
     /// ```
     /// ```no_run
diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
index fb970e17f38..8c067432cb4 100644
--- a/clippy_lints/src/disallowed_methods.rs
+++ b/clippy_lints/src/disallowed_methods.rs
@@ -34,6 +34,9 @@ declare_clippy_lint! {
     ///     { path = "std::vec::Vec::leak", reason = "no leaking memory" },
     ///     # Can also add a `replacement` that will be offered as a suggestion.
     ///     { path = "std::sync::Mutex::new", reason = "prefer faster & simpler non-poisonable mutex", replacement = "parking_lot::Mutex::new" },
+    ///     # This would normally error if the path is incorrect, but with `allow-invalid` = `true`,
+    ///     # it will be silently ignored
+    ///     { path = "std::fs::InvalidPath", reason = "use alternative instead", allow-invalid = true },
     /// ]
     /// ```
     ///
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
index 7875cdd77e8..9a82327a0d7 100644
--- a/clippy_lints/src/disallowed_types.rs
+++ b/clippy_lints/src/disallowed_types.rs
@@ -35,6 +35,9 @@ declare_clippy_lint! {
     ///     { path = "std::net::Ipv4Addr", reason = "no IPv4 allowed" },
     ///     # Can also add a `replacement` that will be offered as a suggestion.
     ///     { path = "std::sync::Mutex", reason = "prefer faster & simpler non-poisonable mutex", replacement = "parking_lot::Mutex" },
+    ///     # This would normally error if the path is incorrect, but with `allow-invalid` = `true`,
+    ///     # it will be silently ignored
+    ///     { path = "std::invalid::Type", reason = "use alternative instead", allow-invalid = true }
     /// ]
     /// ```
     ///
diff --git a/clippy_lints/src/doc/broken_link.rs b/clippy_lints/src/doc/broken_link.rs
new file mode 100644
index 00000000000..a97b807e605
--- /dev/null
+++ b/clippy_lints/src/doc/broken_link.rs
@@ -0,0 +1,83 @@
+use clippy_utils::diagnostics::span_lint;
+use pulldown_cmark::BrokenLink as PullDownBrokenLink;
+use rustc_lint::LateContext;
+use rustc_resolve::rustdoc::{DocFragment, source_span_for_markdown_range};
+use rustc_span::{BytePos, Pos, Span};
+
+use super::DOC_BROKEN_LINK;
+
+/// Scan and report broken link on documents.
+/// It ignores false positives detected by `pulldown_cmark`, and only
+/// warns users when the broken link is consider a URL.
+// NOTE: We don't check these other cases because
+// rustdoc itself will check and warn about it:
+// - When a link url is broken across multiple lines in the URL path part
+// - When a link tag is missing the close parenthesis character at the end.
+// - When a link has whitespace within the url link.
+pub fn check(cx: &LateContext<'_>, bl: &PullDownBrokenLink<'_>, doc: &str, fragments: &[DocFragment]) {
+    warn_if_broken_link(cx, bl, doc, fragments);
+}
+
+fn warn_if_broken_link(cx: &LateContext<'_>, bl: &PullDownBrokenLink<'_>, doc: &str, fragments: &[DocFragment]) {
+    if let Some(span) = source_span_for_markdown_range(cx.tcx, doc, &bl.span, fragments) {
+        let mut len = 0;
+
+        // grab raw link data
+        let (_, raw_link) = doc.split_at(bl.span.start);
+
+        // strip off link text part
+        let raw_link = match raw_link.split_once(']') {
+            None => return,
+            Some((prefix, suffix)) => {
+                len += prefix.len() + 1;
+                suffix
+            },
+        };
+
+        let raw_link = match raw_link.split_once('(') {
+            None => return,
+            Some((prefix, suffix)) => {
+                if !prefix.is_empty() {
+                    // there is text between ']' and '(' chars, so it is not a valid link
+                    return;
+                }
+                len += prefix.len() + 1;
+                suffix
+            },
+        };
+
+        if raw_link.starts_with("(http") {
+            // reduce chances of false positive reports
+            // by limiting this checking only to http/https links.
+            return;
+        }
+
+        for c in raw_link.chars() {
+            if c == ')' {
+                // it is a valid link
+                return;
+            }
+
+            if c == '\n' {
+                report_broken_link(cx, span, len);
+                break;
+            }
+
+            len += 1;
+        }
+    }
+}
+
+fn report_broken_link(cx: &LateContext<'_>, frag_span: Span, offset: usize) {
+    let start = frag_span.lo();
+    let end = start + BytePos::from_usize(offset);
+
+    let span = Span::new(start, end, frag_span.ctxt(), frag_span.parent());
+
+    span_lint(
+        cx,
+        DOC_BROKEN_LINK,
+        span,
+        "possible broken doc link: broken across multiple lines",
+    );
+}
diff --git a/clippy_lints/src/doc/doc_suspicious_footnotes.rs b/clippy_lints/src/doc/doc_suspicious_footnotes.rs
index d3c39686976..3330cc5defd 100644
--- a/clippy_lints/src/doc/doc_suspicious_footnotes.rs
+++ b/clippy_lints/src/doc/doc_suspicious_footnotes.rs
@@ -49,11 +49,7 @@ pub fn check(cx: &LateContext<'_>, doc: &str, range: Range<usize>, fragments: &F
                             .filter(|attr| attr.span().overlaps(this_fragment.span))
                             .rev()
                             .find_map(|attr| {
-                                Some((
-                                    attr,
-                                    attr.doc_str_and_comment_kind()?,
-                                    attr.doc_resolution_scope()?,
-                                ))
+                                Some((attr, attr.doc_str_and_comment_kind()?, attr.doc_resolution_scope()?))
                             })
                             .unwrap();
                         let (to_add, terminator) = match (doc_attr_comment_kind, attr_style) {
diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index d38588bb799..5ea55e102df 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -24,6 +24,7 @@ use rustc_span::edition::Edition;
 use std::ops::Range;
 use url::Url;
 
+mod broken_link;
 mod doc_comment_double_space_linebreaks;
 mod doc_suspicious_footnotes;
 mod include_in_doc_without_cfg;
@@ -292,6 +293,34 @@ declare_clippy_lint! {
     "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.84.0"]
+    pub DOC_BROKEN_LINK,
+    pedantic,
+    "broken document link"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the doc comments of publicly visible
@@ -656,6 +685,7 @@ impl Documentation {
 impl_lint_pass!(Documentation => [
     DOC_LINK_CODE,
     DOC_LINK_WITH_QUOTES,
+    DOC_BROKEN_LINK,
     DOC_MARKDOWN,
     DOC_NESTED_REFDEFS,
     MISSING_SAFETY_DOC,
@@ -786,9 +816,9 @@ struct DocHeaders {
 /// back in the various late lint pass methods if they need the final doc headers, like "Safety" or
 /// "Panics" sections.
 fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[Attribute]) -> Option<DocHeaders> {
-    /// We don't want the parser to choke on intra doc links. Since we don't
-    /// actually care about rendering them, just pretend that all broken links
-    /// point to a fake address.
+    // We don't want the parser to choke on intra doc links. Since we don't
+    // actually care about rendering them, just pretend that all broken links
+    // point to a fake address.
     #[expect(clippy::unnecessary_wraps)] // we're following a type signature
     fn fake_broken_link_callback<'a>(_: BrokenLink<'_>) -> Option<(CowStr<'a>, CowStr<'a>)> {
         Some(("fake".into(), "fake".into()))
@@ -828,14 +858,12 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         return Some(DocHeaders::default());
     }
 
-    let mut cb = fake_broken_link_callback;
-
     check_for_code_clusters(
         cx,
         pulldown_cmark::Parser::new_with_broken_link_callback(
             &doc,
             main_body_opts() - Options::ENABLE_SMART_PUNCTUATION,
-            Some(&mut cb),
+            Some(&mut fake_broken_link_callback),
         )
         .into_offset_iter(),
         &doc,
@@ -845,9 +873,17 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         },
     );
 
+    // NOTE: check_doc uses it own cb function,
+    // to avoid causing duplicated diagnostics for the broken link checker.
+    let mut full_fake_broken_link_callback = |bl: BrokenLink<'_>| -> Option<(CowStr<'_>, CowStr<'_>)> {
+        broken_link::check(cx, &bl, &doc, &fragments);
+        Some(("fake".into(), "fake".into()))
+    };
+
     // disable smart punctuation to pick up ['link'] more easily
     let opts = main_body_opts() - Options::ENABLE_SMART_PUNCTUATION;
-    let parser = pulldown_cmark::Parser::new_with_broken_link_callback(&doc, opts, Some(&mut cb));
+    let parser =
+        pulldown_cmark::Parser::new_with_broken_link_callback(&doc, opts, Some(&mut full_fake_broken_link_callback));
 
     Some(check_doc(
         cx,
diff --git a/clippy_lints/src/doc/needless_doctest_main.rs b/clippy_lints/src/doc/needless_doctest_main.rs
index 7ba11c20f45..74283d7ba86 100644
--- a/clippy_lints/src/doc/needless_doctest_main.rs
+++ b/clippy_lints/src/doc/needless_doctest_main.rs
@@ -71,6 +71,7 @@ pub fn check(
                                 if !ignore {
                                     get_test_spans(&item, *ident, &mut test_attr_spans);
                                 }
+
                                 let is_async = matches!(sig.header.coroutine_kind, Some(CoroutineKind::Async { .. }));
                                 let returns_nothing = match &sig.decl.output {
                                     FnRetTy::Default(..) => true,
@@ -89,9 +90,14 @@ pub fn check(
                             // Another function was found; this case is ignored for needless_doctest_main
                             ItemKind::Fn(fn_) => {
                                 eligible = false;
-                                if !ignore {
-                                    get_test_spans(&item, fn_.ident, &mut test_attr_spans);
+                                if ignore {
+                                    // If ignore is active invalidating one lint,
+                                    // and we already found another function thus
+                                    // invalidating the other one, we have no
+                                    // business continuing.
+                                    return (false, test_attr_spans);
                                 }
+                                get_test_spans(&item, fn_.ident, &mut test_attr_spans);
                             },
                             // Tests with one of these items are ignored
                             ItemKind::Static(..)
@@ -104,7 +110,10 @@ pub fn check(
                         },
                         Ok(None) => break,
                         Err(e) => {
-                            e.cancel();
+                            // See issue #15041. When calling `.cancel()` on the `Diag`, Clippy will unexpectedly panic
+                            // when the `Diag` is unwinded. Meanwhile, we can just call `.emit()`, since the `DiagCtxt`
+                            // is just a sink, nothing will be printed.
+                            e.emit();
                             return (false, test_attr_spans);
                         },
                     }
@@ -119,6 +128,18 @@ pub fn check(
 
     let trailing_whitespace = text.len() - text.trim_end().len();
 
+    // We currently only test for "fn main". Checking for the real
+    // entrypoint (with tcx.entry_fn(())) in each block would be unnecessarily
+    // expensive, as those are probably intended and relevant. Same goes for
+    // macros and other weird ways of declaring a main function.
+    //
+    // Also, as we only check for attribute names and don't do macro expansion,
+    // we can check only for #[test]
+
+    if !((text.contains("main") && text.contains("fn")) || text.contains("#[test]")) {
+        return;
+    }
+
     // Because of the global session, we need to create a new session in a different thread with
     // the edition we need.
     let text = text.to_owned();
diff --git a/clippy_lints/src/empty_line_after.rs b/clippy_lints/src/empty_line_after.rs
index 0c5f8bbf4ca..3bd74856165 100644
--- a/clippy_lints/src/empty_line_after.rs
+++ b/clippy_lints/src/empty_line_after.rs
@@ -10,7 +10,7 @@ use rustc_errors::{Applicability, Diag, SuggestionStyle};
 use rustc_lexer::TokenKind;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::impl_lint_pass;
-use rustc_span::{BytePos, ExpnKind, Ident, InnerSpan, Span, SpanData, Symbol, kw};
+use rustc_span::{BytePos, ExpnKind, Ident, InnerSpan, Span, SpanData, Symbol, kw, sym};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -129,10 +129,55 @@ struct Stop {
     kind: StopKind,
     first: usize,
     last: usize,
+    name: Option<Symbol>,
 }
 
 impl Stop {
-    fn convert_to_inner(&self) -> (Span, String) {
+    fn is_outer_attr_only(&self) -> bool {
+        let Some(name) = self.name else {
+            return false;
+        };
+        // Check if the attribute only has effect when as an outer attribute
+        // The below attributes are collected from the builtin attributes of The Rust Reference
+        // https://doc.rust-lang.org/reference/attributes.html#r-attributes.builtin
+        // And the comments below are from compiler errors and warnings
+        matches!(
+            name,
+            // Cannot be used at crate level
+            sym::repr | sym::test | sym::derive | sym::automatically_derived | sym::path | sym::global_allocator |
+            // Only has an effect on macro definitions
+            sym::macro_export |
+            // Only be applied to trait definitions
+            sym::on_unimplemented |
+            // Only be placed on trait implementations
+            sym::do_not_recommend |
+            // Only has an effect on items
+            sym::ignore | sym::should_panic | sym::proc_macro | sym::proc_macro_derive | sym::proc_macro_attribute |
+            // Has no effect when applied to a module
+            sym::must_use |
+            // Should be applied to a foreign function or static
+            sym::link_name | sym::link_ordinal | sym::link_section |
+            // Should be applied to an `extern crate` item
+            sym::no_link |
+            // Should be applied to a free function, impl method or static
+            sym::export_name | sym::no_mangle |
+            // Should be applied to a `static` variable
+            sym::used |
+            // Should be applied to function or closure
+            sym::inline |
+            // Should be applied to a function definition
+            sym::cold | sym::target_feature | sym::track_caller | sym::instruction_set |
+            // Should be applied to a struct or enum
+            sym::non_exhaustive |
+            // Note: No any warning when it as an inner attribute, but it has no effect
+            sym::panic_handler
+        )
+    }
+
+    fn convert_to_inner(&self) -> Option<(Span, String)> {
+        if self.is_outer_attr_only() {
+            return None;
+        }
         let inner = match self.kind {
             // #![...]
             StopKind::Attr => InnerSpan::new(1, 1),
@@ -140,7 +185,7 @@ impl Stop {
             //   ^      ^
             StopKind::Doc(_) => InnerSpan::new(2, 3),
         };
-        (self.span.from_inner(inner), "!".into())
+        Some((self.span.from_inner(inner), "!".into()))
     }
 
     fn comment_out(&self, cx: &EarlyContext<'_>, suggestions: &mut Vec<(Span, String)>) {
@@ -177,6 +222,7 @@ impl Stop {
             },
             first: file.lookup_line(file.relative_position(lo))?,
             last: file.lookup_line(file.relative_position(hi))?,
+            name: attr.name(),
         })
     }
 }
@@ -356,6 +402,12 @@ impl EmptyLineAfter {
         if let Some(parent) = self.items.iter().rev().nth(1)
             && (parent.kind == "module" || parent.kind == "crate")
             && parent.mod_items == Some(id)
+            && let suggestions = gaps
+                .iter()
+                .flat_map(|gap| gap.prev_chunk)
+                .filter_map(Stop::convert_to_inner)
+                .collect::<Vec<_>>()
+            && !suggestions.is_empty()
         {
             let desc = if parent.kind == "module" {
                 "parent module"
@@ -367,10 +419,7 @@ impl EmptyLineAfter {
                     StopKind::Attr => format!("if the attribute should apply to the {desc} use an inner attribute"),
                     StopKind::Doc(_) => format!("if the comment should document the {desc} use an inner doc comment"),
                 },
-                gaps.iter()
-                    .flat_map(|gap| gap.prev_chunk)
-                    .map(Stop::convert_to_inner)
-                    .collect(),
+                suggestions,
                 Applicability::MaybeIncorrect,
             );
         }
@@ -425,6 +474,7 @@ impl EmptyLineAfter {
                 first: line.line,
                 // last doesn't need to be accurate here, we don't compare it with anything
                 last: line.line,
+                name: None,
             });
         }
 
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index b0077a9b05f..0288747d6f3 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::{snippet_opt, snippet_with_applicability};
 use clippy_utils::ty::get_type_diagnostic_name;
@@ -109,14 +109,20 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
         {
             let vec_crate = if is_no_std_crate(cx) { "alloc" } else { "std" };
             // replace `|| vec![]` with `Vec::new`
-            span_lint_and_sugg(
+            span_lint_hir_and_then(
                 cx,
                 REDUNDANT_CLOSURE,
+                expr.hir_id,
                 expr.span,
                 "redundant closure",
-                "replace the closure with `Vec::new`",
-                format!("{vec_crate}::vec::Vec::new"),
-                Applicability::MachineApplicable,
+                |diag| {
+                    diag.span_suggestion(
+                        expr.span,
+                        "replace the closure with `Vec::new`",
+                        format!("{vec_crate}::vec::Vec::new"),
+                        Applicability::MachineApplicable,
+                    );
+                },
             );
         }
         // skip `foo(|| macro!())`
@@ -198,41 +204,48 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
                 // For now ignore all callee types which reference a type parameter.
                 && !generic_args.types().any(|t| matches!(t.kind(), ty::Param(_)))
             {
-                span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
-                    if let Some(mut snippet) = snippet_opt(cx, callee.span) {
-                        if path_to_local(callee).is_some_and(|l| {
-                            // FIXME: Do we really need this `local_used_in` check?
-                            // Isn't it checking something like... `callee(callee)`?
-                            // If somehow this check is needed, add some test for it,
-                            // 'cuz currently nothing changes after deleting this check.
-                            local_used_in(cx, l, args) || local_used_after_expr(cx, l, expr)
-                        }) {
-                            match cx
-                                .tcx
-                                .infer_ctxt()
-                                .build(cx.typing_mode())
-                                .err_ctxt()
-                                .type_implements_fn_trait(
-                                    cx.param_env,
-                                    Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
-                                    ty::PredicatePolarity::Positive,
-                                ) {
-                                // Mutable closure is used after current expr; we cannot consume it.
-                                Ok((ClosureKind::FnMut, _)) => snippet = format!("&mut {snippet}"),
-                                Ok((ClosureKind::Fn, _)) if !callee_ty_raw.is_ref() => {
-                                    snippet = format!("&{snippet}");
-                                },
-                                _ => (),
+                span_lint_hir_and_then(
+                    cx,
+                    REDUNDANT_CLOSURE,
+                    expr.hir_id,
+                    expr.span,
+                    "redundant closure",
+                    |diag| {
+                        if let Some(mut snippet) = snippet_opt(cx, callee.span) {
+                            if path_to_local(callee).is_some_and(|l| {
+                                // FIXME: Do we really need this `local_used_in` check?
+                                // Isn't it checking something like... `callee(callee)`?
+                                // If somehow this check is needed, add some test for it,
+                                // 'cuz currently nothing changes after deleting this check.
+                                local_used_in(cx, l, args) || local_used_after_expr(cx, l, expr)
+                            }) {
+                                match cx
+                                    .tcx
+                                    .infer_ctxt()
+                                    .build(cx.typing_mode())
+                                    .err_ctxt()
+                                    .type_implements_fn_trait(
+                                        cx.param_env,
+                                        Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
+                                        ty::PredicatePolarity::Positive,
+                                    ) {
+                                    // Mutable closure is used after current expr; we cannot consume it.
+                                    Ok((ClosureKind::FnMut, _)) => snippet = format!("&mut {snippet}"),
+                                    Ok((ClosureKind::Fn, _)) if !callee_ty_raw.is_ref() => {
+                                        snippet = format!("&{snippet}");
+                                    },
+                                    _ => (),
+                                }
                             }
+                            diag.span_suggestion(
+                                expr.span,
+                                "replace the closure with the function itself",
+                                snippet,
+                                Applicability::MachineApplicable,
+                            );
                         }
-                        diag.span_suggestion(
-                            expr.span,
-                            "replace the closure with the function itself",
-                            snippet,
-                            Applicability::MachineApplicable,
-                        );
-                    }
-                });
+                    },
+                );
             }
         },
         ExprKind::MethodCall(path, self_, args, _) if check_inputs(typeck, body.params, Some(self_), args) => {
@@ -245,9 +258,10 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx
                     Some(span) => format!("::{}", snippet_with_applicability(cx, span, "<..>", &mut app)),
                     None => String::new(),
                 };
-                span_lint_and_then(
+                span_lint_hir_and_then(
                     cx,
                     REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
+                    expr.hir_id,
                     expr.span,
                     "redundant closure",
                     |diag| {
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 1fb0e4d24d0..86d9038ec45 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -76,7 +76,7 @@ impl LateLintPass<'_> for ExhaustiveItems {
                 "exported enums should not be exhaustive",
                 [].as_slice(),
             ),
-            ItemKind::Struct(_, _, v) => (
+            ItemKind::Struct(_, _, v) if v.fields().iter().all(|f| f.default.is_none()) => (
                 EXHAUSTIVE_STRUCTS,
                 "exported structs should not be exhaustive",
                 v.fields(),
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 3c7e83b0697..b3c9e860758 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -5,14 +5,13 @@ use clippy_utils::{
     eq_expr_value, get_parent_expr, higher, is_in_const_context, is_inherent_method_call, is_no_std_crate,
     numeric_literal, peel_blocks, sugg, sym,
 };
+use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
-
-use rustc_ast::ast;
 use std::f32::consts as f32_consts;
 use std::f64::consts as f64_consts;
 use sugg::Sugg;
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index c0c23e217fd..d959981a83c 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -14,9 +14,9 @@ use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::is_must_use_ty;
 use clippy_utils::visitors::for_each_expr_without_closures;
 use clippy_utils::{return_ty, trait_ref_of_method};
-use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
-use rustc_span::Symbol;
 use rustc_attr_data_structures::{AttributeKind, find_attr};
+use rustc_span::Symbol;
+use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 
 use core::ops::ControlFlow;
 
@@ -34,7 +34,17 @@ pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>
         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());
         if let Some((attr_span, reason)) = attr {
-            check_needless_must_use(cx, sig.decl, item.owner_id, item.span, fn_header_span, *attr_span, *reason, attrs, sig);
+            check_needless_must_use(
+                cx,
+                sig.decl,
+                item.owner_id,
+                item.span,
+                fn_header_span,
+                *attr_span,
+                *reason,
+                attrs,
+                sig,
+            );
         } else if is_public && !is_proc_macro(attrs) && !find_attr!(attrs, AttributeKind::NoMangle(..)) {
             check_must_use_candidate(
                 cx,
@@ -54,9 +64,20 @@ 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()), AttributeKind::MustUse { span, reason } => (span, reason));
+        let attr =
+            find_attr!(cx.tcx.hir_attrs(item.hir_id()), AttributeKind::MustUse { span, reason } => (span, reason));
         if let Some((attr_span, reason)) = attr {
-            check_needless_must_use(cx, sig.decl, item.owner_id, item.span, fn_header_span, *attr_span, *reason, attrs, sig);
+            check_needless_must_use(
+                cx,
+                sig.decl,
+                item.owner_id,
+                item.span,
+                fn_header_span,
+                *attr_span,
+                *reason,
+                attrs,
+                sig,
+            );
         } else if is_public && !is_proc_macro(attrs) && trait_ref_of_method(cx, item.owner_id).is_none() {
             check_must_use_candidate(
                 cx,
@@ -77,9 +98,20 @@ 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()), AttributeKind::MustUse { span, reason } => (span, reason));
+        let attr =
+            find_attr!(cx.tcx.hir_attrs(item.hir_id()), AttributeKind::MustUse { span, reason } => (span, reason));
         if let Some((attr_span, reason)) = attr {
-            check_needless_must_use(cx, sig.decl, item.owner_id, item.span, fn_header_span, *attr_span, *reason, attrs, sig);
+            check_needless_must_use(
+                cx,
+                sig.decl,
+                item.owner_id,
+                item.span,
+                fn_header_span,
+                *attr_span,
+                *reason,
+                attrs,
+                sig,
+            );
         } else if let hir::TraitFn::Provided(eid) = *eid {
             let body = cx.tcx.hir_body(eid);
             if attr.is_none() && is_public && !is_proc_macro(attrs) {
@@ -121,12 +153,7 @@ fn check_needless_must_use(
                 fn_header_span,
                 "this unit-returning function has a `#[must_use]` attribute",
                 |diag| {
-                    diag.span_suggestion(
-                        attr_span,
-                        "remove the attribute",
-                        "",
-                        Applicability::MachineApplicable,
-                    );
+                    diag.span_suggestion(attr_span, "remove the attribute", "", Applicability::MachineApplicable);
                 },
             );
         } else {
diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index 45f9aa0a53e..ab7a965b367 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{ConstEvalCtxt, Constant};
+use clippy_utils::consts::is_zero_integer_const;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::is_else_clause;
 use clippy_utils::source::{HasSession, indent_of, reindent_multiline, snippet};
@@ -48,13 +48,6 @@ declare_clippy_lint! {
 
 declare_lint_pass!(IfNotElse => [IF_NOT_ELSE]);
 
-fn is_zero_const(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
-    if let Some(value) = ConstEvalCtxt::new(cx).eval_simple(expr) {
-        return Constant::Int(0) == value;
-    }
-    false
-}
-
 impl LateLintPass<'_> for IfNotElse {
     fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
         if let ExprKind::If(cond, cond_inner, Some(els)) = e.kind
@@ -68,7 +61,7 @@ impl LateLintPass<'_> for IfNotElse {
                 ),
                 // Don't lint on `… != 0`, as these are likely to be bit tests.
                 // For example, `if foo & 0x0F00 != 0 { … } else { … }` is already in the "proper" order.
-                ExprKind::Binary(op, _, rhs) if op.node == BinOpKind::Ne && !is_zero_const(rhs, cx) => (
+                ExprKind::Binary(op, _, rhs) if op.node == BinOpKind::Ne && !is_zero_integer_const(cx, rhs) => (
                     "unnecessary `!=` operation",
                     "change to `==` and swap the blocks of the `if`/`else`",
                 ),
diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs
index 617c006795b..ffe6ad14f63 100644
--- a/clippy_lints/src/inline_fn_without_body.rs
+++ b/clippy_lints/src/inline_fn_without_body.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::DiagExt;
-use rustc_attr_data_structures::{find_attr, AttributeKind};
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_errors::Applicability;
 use rustc_hir::{TraitFn, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -33,10 +33,10 @@ impl<'tcx> LateLintPass<'tcx> for InlineFnWithoutBody {
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
         if let TraitItemKind::Fn(_, TraitFn::Required(_)) = item.kind
             && let Some(attr_span) = find_attr!(cx
-                .tcx
-                .hir_attrs(item.hir_id()),
-                AttributeKind::Inline(_, span) => *span
-        )
+                    .tcx
+                    .hir_attrs(item.hir_id()),
+                    AttributeKind::Inline(_, span) => *span
+            )
         {
             span_lint_and_then(
                 cx,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index be9142b17fe..96a6dee5885 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -59,10 +59,10 @@ extern crate smallvec;
 extern crate thin_vec;
 
 #[macro_use]
-mod declare_clippy_lint;
+extern crate clippy_utils;
 
 #[macro_use]
-extern crate clippy_utils;
+extern crate declare_clippy_lint;
 
 mod utils;
 
@@ -411,108 +411,9 @@ mod zombie_processes;
 use clippy_config::{Conf, get_configuration_metadata, sanitize_explanation};
 use clippy_utils::macros::FormatArgsStorage;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_lint::{Lint, LintId};
+use rustc_lint::Lint;
 use utils::attr_collector::{AttrCollector, AttrStorage};
 
-#[derive(Default)]
-struct RegistrationGroups {
-    all: Vec<LintId>,
-    cargo: Vec<LintId>,
-    complexity: Vec<LintId>,
-    correctness: Vec<LintId>,
-    nursery: Vec<LintId>,
-    pedantic: Vec<LintId>,
-    perf: Vec<LintId>,
-    restriction: Vec<LintId>,
-    style: Vec<LintId>,
-    suspicious: Vec<LintId>,
-}
-
-impl RegistrationGroups {
-    #[rustfmt::skip]
-    fn register(self, store: &mut rustc_lint::LintStore) {
-        store.register_group(true, "clippy::all", Some("clippy_all"), self.all);
-        store.register_group(true, "clippy::cargo", Some("clippy_cargo"), self.cargo);
-        store.register_group(true, "clippy::complexity", Some("clippy_complexity"), self.complexity);
-        store.register_group(true, "clippy::correctness", Some("clippy_correctness"), self.correctness);
-        store.register_group(true, "clippy::nursery", Some("clippy_nursery"), self.nursery);
-        store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), self.pedantic);
-        store.register_group(true, "clippy::perf", Some("clippy_perf"), self.perf);
-        store.register_group(true, "clippy::restriction", Some("clippy_restriction"), self.restriction);
-        store.register_group(true, "clippy::style", Some("clippy_style"), self.style);
-        store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), self.suspicious);
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub(crate) enum LintCategory {
-    Cargo,
-    Complexity,
-    Correctness,
-    Nursery,
-    Pedantic,
-    Perf,
-    Restriction,
-    Style,
-    Suspicious,
-}
-
-#[allow(clippy::enum_glob_use)]
-use LintCategory::*;
-
-impl LintCategory {
-    fn is_all(self) -> bool {
-        matches!(self, Correctness | Suspicious | Style | Complexity | Perf)
-    }
-
-    fn group(self, groups: &mut RegistrationGroups) -> &mut Vec<LintId> {
-        match self {
-            Cargo => &mut groups.cargo,
-            Complexity => &mut groups.complexity,
-            Correctness => &mut groups.correctness,
-            Nursery => &mut groups.nursery,
-            Pedantic => &mut groups.pedantic,
-            Perf => &mut groups.perf,
-            Restriction => &mut groups.restriction,
-            Style => &mut groups.style,
-            Suspicious => &mut groups.suspicious,
-        }
-    }
-}
-
-pub struct LintInfo {
-    /// Double reference to maintain pointer equality
-    pub lint: &'static &'static Lint,
-    category: LintCategory,
-    pub explanation: &'static str,
-    /// e.g. `clippy_lints/src/absolute_paths.rs#43`
-    pub location: &'static str,
-    pub version: Option<&'static str>,
-}
-
-impl LintInfo {
-    /// Returns the lint name in lowercase without the `clippy::` prefix
-    #[allow(clippy::missing_panics_doc)]
-    pub fn name_lower(&self) -> String {
-        self.lint.name.strip_prefix("clippy::").unwrap().to_ascii_lowercase()
-    }
-
-    /// Returns the name of the lint's category in lowercase (`style`, `pedantic`)
-    pub fn category_str(&self) -> &'static str {
-        match self.category {
-            Cargo => "cargo",
-            Complexity => "complexity",
-            Correctness => "correctness",
-            Nursery => "nursery",
-            Pedantic => "pedantic",
-            Perf => "perf",
-            Restriction => "restriction",
-            Style => "style",
-            Suspicious => "suspicious",
-        }
-    }
-}
-
 pub fn explain(name: &str) -> i32 {
     let target = format!("clippy::{}", name.to_ascii_uppercase());
 
@@ -535,30 +436,11 @@ pub fn explain(name: &str) -> i32 {
     }
 }
 
-fn register_categories(store: &mut rustc_lint::LintStore) {
-    let mut groups = RegistrationGroups::default();
-
-    for LintInfo { lint, category, .. } in declared_lints::LINTS {
-        if category.is_all() {
-            groups.all.push(LintId::of(lint));
-        }
-
-        category.group(&mut groups).push(LintId::of(lint));
-    }
-
-    let lints: Vec<&'static Lint> = declared_lints::LINTS.iter().map(|info| *info.lint).collect();
-
-    store.register_lints(&lints);
-    groups.register(store);
-}
-
 /// Register all lints and lint groups with the rustc lint store
 ///
 /// Used in `./src/driver.rs`.
 #[expect(clippy::too_many_lines)]
-pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
-    register_categories(store);
-
+pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     for (old_name, new_name) in deprecated_lints::RENAMED {
         store.register_renamed(old_name, new_name);
     }
diff --git a/clippy_lints/src/loops/same_item_push.rs b/clippy_lints/src/loops/same_item_push.rs
index 388034c39f5..e792edbe23e 100644
--- a/clippy_lints/src/loops/same_item_push.rs
+++ b/clippy_lints/src/loops/same_item_push.rs
@@ -163,15 +163,14 @@ impl<'tcx> Visitor<'tcx> for SameItemPushVisitor<'_, 'tcx> {
                 StmtKind::Expr(expr) | StmtKind::Semi(expr) => self.visit_expr(expr),
                 _ => {},
             }
+        }
+        // Current statement is a push ...check whether another
+        // push had been previously done
+        else if self.vec_push.is_none() {
+            self.vec_push = vec_push_option;
         } else {
-            // Current statement is a push ...check whether another
-            // push had been previously done
-            if self.vec_push.is_none() {
-                self.vec_push = vec_push_option;
-            } else {
-                // There are multiple pushes ... don't lint
-                self.multiple_pushes = true;
-            }
+            // There are multiple pushes ... don't lint
+            self.multiple_pushes = true;
         }
     }
 }
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 0b3bec714c0..9ff82cdcb66 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -13,7 +13,6 @@ use rustc_errors::Applicability;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::{Arm, Expr, ExprKind, HirId, MatchSource, Pat, PatExpr, PatExprKind, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LintContext};
-
 use rustc_span::Span;
 use rustc_span::symbol::{Symbol, sym};
 use std::slice;
diff --git a/clippy_lints/src/matches/manual_ok_err.rs b/clippy_lints/src/matches/manual_ok_err.rs
index 4959908dad6..edbb556fd97 100644
--- a/clippy_lints/src/matches/manual_ok_err.rs
+++ b/clippy_lints/src/matches/manual_ok_err.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::option_arg_ty;
+use clippy_utils::ty::{option_arg_ty, peel_mid_ty_refs_is_mutable};
 use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res, peel_blocks, span_contains_comment};
-use rustc_ast::BindingMode;
+use rustc_ast::{BindingMode, Mutability};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr};
 use rustc_hir::def::{DefKind, Res};
@@ -133,7 +133,21 @@ fn apply_lint(cx: &LateContext<'_>, expr: &Expr<'_>, scrutinee: &Expr<'_>, is_ok
         Applicability::MachineApplicable
     };
     let scrut = Sugg::hir_with_applicability(cx, scrutinee, "..", &mut app).maybe_paren();
-    let sugg = format!("{scrut}.{method}()");
+
+    let scrutinee_ty = cx.typeck_results().expr_ty(scrutinee);
+    let (_, n_ref, mutability) = peel_mid_ty_refs_is_mutable(scrutinee_ty);
+    let prefix = if n_ref > 0 {
+        if mutability == Mutability::Mut {
+            ".as_mut()"
+        } else {
+            ".as_ref()"
+        }
+    } else {
+        ""
+    };
+
+    let sugg = format!("{scrut}{prefix}.{method}()");
+
     // If the expression being expanded is the `if …` part of an `else if …`, it must be blockified.
     let sugg = if let Some(parent_expr) = get_parent_expr(cx, expr)
         && let ExprKind::If(_, _, Some(else_part)) = parent_expr.kind
diff --git a/clippy_lints/src/matches/match_wild_enum.rs b/clippy_lints/src/matches/match_wild_enum.rs
index 24b4a675800..70a03ff9376 100644
--- a/clippy_lints/src/matches/match_wild_enum.rs
+++ b/clippy_lints/src/matches/match_wild_enum.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{is_refutable, peel_hir_pat_refs, recurse_or_patterns};
 use rustc_errors::Applicability;
@@ -116,11 +117,12 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
     let format_suggestion = |variant: &VariantDef| {
         format!(
             "{}{}{}{}",
-            if let Some(ident) = wildcard_ident {
-                format!("{} @ ", ident.name)
-            } else {
-                String::new()
-            },
+            wildcard_ident.map_or(String::new(), |ident| {
+                ident
+                    .span
+                    .get_source_text(cx)
+                    .map_or_else(|| format!("{} @ ", ident.name), |s| format!("{s} @ "))
+            }),
             if let CommonPrefixSearcher::Path(path_prefix) = path_prefix {
                 let mut s = String::new();
                 for seg in path_prefix {
@@ -138,7 +140,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
                 Some(CtorKind::Fn) if variant.fields.len() == 1 => "(_)",
                 Some(CtorKind::Fn) => "(..)",
                 Some(CtorKind::Const) => "",
-                None => "{ .. }",
+                None => " { .. }",
             }
         )
     };
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 347960e0003..f2dabdd3438 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -4426,7 +4426,7 @@ declare_clippy_lint! {
     /// ```no_run
     /// use std::io::{BufReader, Read};
     /// use std::fs::File;
-    /// let file = BufReader::new(std::fs::File::open("./bytes.txt").unwrap());
+    /// let file = BufReader::new(File::open("./bytes.txt").unwrap());
     /// file.bytes();
     /// ```
     #[clippy::version = "1.87.0"]
diff --git a/clippy_lints/src/methods/or_fun_call.rs b/clippy_lints/src/methods/or_fun_call.rs
index 7bdd999bbba..2139466ce74 100644
--- a/clippy_lints/src/methods/or_fun_call.rs
+++ b/clippy_lints/src/methods/or_fun_call.rs
@@ -136,7 +136,7 @@ pub(super) fn check<'tcx>(
         fun_span: Option<Span>,
     ) -> bool {
         // (path, fn_has_argument, methods, suffix)
-        const KNOW_TYPES: [(Symbol, bool, &[Symbol], &str); 4] = [
+        const KNOW_TYPES: [(Symbol, bool, &[Symbol], &str); 5] = [
             (sym::BTreeEntry, false, &[sym::or_insert], "with"),
             (sym::HashMapEntry, false, &[sym::or_insert], "with"),
             (
@@ -145,16 +145,17 @@ pub(super) fn check<'tcx>(
                 &[sym::map_or, sym::ok_or, sym::or, sym::unwrap_or],
                 "else",
             ),
-            (sym::Result, true, &[sym::or, sym::unwrap_or], "else"),
+            (sym::Option, false, &[sym::get_or_insert], "with"),
+            (sym::Result, true, &[sym::map_or, sym::or, sym::unwrap_or], "else"),
         ];
 
         if KNOW_TYPES.iter().any(|k| k.2.contains(&name))
             && switch_to_lazy_eval(cx, arg)
             && !contains_return(arg)
             && let self_ty = cx.typeck_results().expr_ty(self_expr)
-            && let Some(&(_, fn_has_arguments, poss, suffix)) =
-                KNOW_TYPES.iter().find(|&&i| is_type_diagnostic_item(cx, self_ty, i.0))
-            && poss.contains(&name)
+            && let Some(&(_, fn_has_arguments, _, suffix)) = KNOW_TYPES
+                .iter()
+                .find(|&&i| is_type_diagnostic_item(cx, self_ty, i.0) && i.2.contains(&name))
         {
             let ctxt = span.ctxt();
             let mut app = Applicability::HasPlaceholders;
diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs
index f835bbb7c56..25c95d23436 100644
--- a/clippy_lints/src/missing_inline.rs
+++ b/clippy_lints/src/missing_inline.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use rustc_attr_data_structures::{find_attr, AttributeKind};
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_hir as hir;
 use rustc_hir::Attribute;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
index 8d2f8029112..17d251a7bbb 100644
--- a/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -161,7 +161,7 @@ fn path_has_args(p: &QPath<'_>) -> bool {
 ///   - `Copy` itself, or
 ///   - the only use of a mutable reference, or
 ///   - not a variable (created by a function call)
-#[expect(clippy::too_many_arguments)]
+#[expect(clippy::too_many_arguments, clippy::too_many_lines)]
 fn needless_borrow_count<'tcx>(
     cx: &LateContext<'tcx>,
     possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
@@ -232,11 +232,11 @@ fn needless_borrow_count<'tcx>(
     let mut args_with_referent_ty = callee_args.to_vec();
 
     let mut check_reference_and_referent = |reference: &Expr<'tcx>, referent: &Expr<'tcx>| {
-        if let ExprKind::Field(base, _) = &referent.kind {
-            let base_ty = cx.typeck_results().expr_ty(base);
-            if drop_trait_def_id.is_some_and(|id| implements_trait(cx, base_ty, id, &[])) {
-                return false;
-            }
+        if let ExprKind::Field(base, _) = &referent.kind
+            && let base_ty = cx.typeck_results().expr_ty(base)
+            && drop_trait_def_id.is_some_and(|id| implements_trait(cx, base_ty, id, &[]))
+        {
+            return false;
         }
 
         let referent_ty = cx.typeck_results().expr_ty(referent);
diff --git a/clippy_lints/src/needless_parens_on_range_literals.rs b/clippy_lints/src/needless_parens_on_range_literals.rs
index 8a62106377c..021a11593f3 100644
--- a/clippy_lints/src/needless_parens_on_range_literals.rs
+++ b/clippy_lints/src/needless_parens_on_range_literals.rs
@@ -5,7 +5,6 @@ use clippy_utils::source::{snippet, snippet_with_applicability};
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
-
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index 9aede1dec93..c97ecce75b4 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -124,8 +124,10 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                 // Note that we do not want to deal with qualified predicates here.
                 match pred.kind().no_bound_vars() {
                     Some(ty::ClauseKind::Trait(pred))
-                        if pred.def_id() != sized_trait && pred.def_id() != meta_sized_trait
-                            => Some(pred),
+                        if pred.def_id() != sized_trait && pred.def_id() != meta_sized_trait =>
+                    {
+                        Some(pred)
+                    },
                     _ => None,
                 }
             })
diff --git a/clippy_lints/src/no_mangle_with_rust_abi.rs b/clippy_lints/src/no_mangle_with_rust_abi.rs
index 0159c5d2ac1..dee8efeb291 100644
--- a/clippy_lints/src/no_mangle_with_rust_abi.rs
+++ b/clippy_lints/src/no_mangle_with_rust_abi.rs
@@ -1,13 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use rustc_abi::ExternAbi;
+use rustc_attr_data_structures::AttributeKind;
 use rustc_errors::Applicability;
-use rustc_hir::{Item, ItemKind};
+use rustc_hir::{Attribute, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::{BytePos, Pos};
-use rustc_attr_data_structures::AttributeKind;
-use rustc_hir::Attribute;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index a27c6aa75e3..5f10e1968f1 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -617,7 +617,7 @@ impl<'tcx> NonCopyConst<'tcx> {
 
             // Then a type check. Note we only check the type here as the result
             // gets cached.
-            let ty = EarlyBinder::bind(typeck.expr_ty(src_expr)).instantiate(tcx, init_args);
+            let ty = typeck.expr_ty(src_expr);
             // Normalized as we need to check if this is an array later.
             let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
             if self.is_ty_freeze(tcx, typing_env, ty).is_freeze() {
diff --git a/clippy_lints/src/operators/identity_op.rs b/clippy_lints/src/operators/identity_op.rs
index e1fd09549a4..3efbb896358 100644
--- a/clippy_lints/src/operators/identity_op.rs
+++ b/clippy_lints/src/operators/identity_op.rs
@@ -1,12 +1,13 @@
-use clippy_utils::consts::{ConstEvalCtxt, Constant, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, Constant, FullInt, integer_const, is_zero_integer_const};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{clip, peel_hir_expr_refs, unsext};
+use clippy_utils::{ExprUseNode, clip, expr_use_ctxt, peel_hir_expr_refs, unsext};
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind, Node};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::{BinOpKind, Expr, ExprKind, Node, Path, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::Span;
+use rustc_span::{Span, kw};
 
 use super::IDENTITY_OP;
 
@@ -17,7 +18,7 @@ pub(crate) fn check<'tcx>(
     left: &'tcx Expr<'_>,
     right: &'tcx Expr<'_>,
 ) {
-    if !is_allowed(cx, op, left, right) {
+    if !is_allowed(cx, expr, op, left, right) {
         return;
     }
 
@@ -165,14 +166,27 @@ fn needs_parenthesis(cx: &LateContext<'_>, binary: &Expr<'_>, child: &Expr<'_>)
     Parens::Needed
 }
 
-fn is_allowed(cx: &LateContext<'_>, cmp: BinOpKind, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+fn is_allowed<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    cmp: BinOpKind,
+    left: &Expr<'tcx>,
+    right: &Expr<'tcx>,
+) -> bool {
+    // Exclude case where the left or right side is associated function call returns a type which is
+    // `Self` that is not given explicitly, and the expression is not a let binding's init
+    // expression and the let binding has a type annotation, or a function's return value.
+    if (is_assoc_fn_without_type_instance(cx, left) || is_assoc_fn_without_type_instance(cx, right))
+        && !is_expr_used_with_type_annotation(cx, expr)
+    {
+        return false;
+    }
+
     // This lint applies to integers and their references
     cx.typeck_results().expr_ty(left).peel_refs().is_integral()
         && cx.typeck_results().expr_ty(right).peel_refs().is_integral()
         // `1 << 0` is a common pattern in bit manipulation code
-        && !(cmp == BinOpKind::Shl
-            && ConstEvalCtxt::new(cx).eval_simple(right) == Some(Constant::Int(0))
-            && ConstEvalCtxt::new(cx).eval_simple(left) == Some(Constant::Int(1)))
+        && !(cmp == BinOpKind::Shl && is_zero_integer_const(cx, right) && integer_const(cx, left) == Some(1))
 }
 
 fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span: Span, arg: Span) {
@@ -234,3 +248,47 @@ fn span_ineffective_operation(
         applicability,
     );
 }
+
+fn is_expr_used_with_type_annotation<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    match expr_use_ctxt(cx, expr).use_node(cx) {
+        ExprUseNode::LetStmt(letstmt) => letstmt.ty.is_some(),
+        ExprUseNode::Return(_) => true,
+        _ => false,
+    }
+}
+
+/// Check if the expression is an associated function without a type instance.
+/// Example:
+/// ```
+/// trait Def {
+///     fn def() -> Self;
+/// }
+/// impl Def for usize {
+///     fn def() -> Self {
+///         0
+///     }
+/// }
+/// fn test() {
+///     let _ = 0usize + &Default::default();
+///     let _ = 0usize + &Def::def();
+/// }
+/// ```
+fn is_assoc_fn_without_type_instance<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> bool {
+    if let ExprKind::Call(func, _) = peel_hir_expr_refs(expr).0.kind
+        && let ExprKind::Path(QPath::Resolved(
+            // If it's not None, don't need to go further.
+            None,
+            Path {
+                res: Res::Def(DefKind::AssocFn, def_id),
+                ..
+            },
+        )) = func.kind
+        && let output_ty = cx.tcx.fn_sig(def_id).instantiate_identity().skip_binder().output()
+        && let ty::Param(ty::ParamTy {
+            name: kw::SelfUpper, ..
+        }) = output_ty.kind()
+    {
+        return true;
+    }
+    false
+}
diff --git a/clippy_lints/src/operators/manual_is_multiple_of.rs b/clippy_lints/src/operators/manual_is_multiple_of.rs
new file mode 100644
index 00000000000..821178a4315
--- /dev/null
+++ b/clippy_lints/src/operators/manual_is_multiple_of.rs
@@ -0,0 +1,66 @@
+use clippy_utils::consts::is_zero_integer_const;
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::sugg::Sugg;
+use rustc_ast::BinOpKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+
+use super::MANUAL_IS_MULTIPLE_OF;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'_>,
+    op: BinOpKind,
+    lhs: &'tcx Expr<'tcx>,
+    rhs: &'tcx Expr<'tcx>,
+    msrv: Msrv,
+) {
+    if msrv.meets(cx, msrvs::UNSIGNED_IS_MULTIPLE_OF)
+        && let Some(operand) = uint_compare_to_zero(cx, op, lhs, rhs)
+        && let ExprKind::Binary(operand_op, operand_left, operand_right) = operand.kind
+        && operand_op.node == BinOpKind::Rem
+    {
+        let mut app = Applicability::MachineApplicable;
+        let divisor = Sugg::hir_with_applicability(cx, operand_right, "_", &mut app);
+        span_lint_and_sugg(
+            cx,
+            MANUAL_IS_MULTIPLE_OF,
+            expr.span,
+            "manual implementation of `.is_multiple_of()`",
+            "replace with",
+            format!(
+                "{}{}.is_multiple_of({divisor})",
+                if op == BinOpKind::Eq { "" } else { "!" },
+                Sugg::hir_with_applicability(cx, operand_left, "_", &mut app).maybe_paren()
+            ),
+            app,
+        );
+    }
+}
+
+// If we have a `x == 0`, `x != 0` or `x > 0` (or the reverted ones), return the non-zero operand
+fn uint_compare_to_zero<'tcx>(
+    cx: &LateContext<'tcx>,
+    op: BinOpKind,
+    lhs: &'tcx Expr<'tcx>,
+    rhs: &'tcx Expr<'tcx>,
+) -> Option<&'tcx Expr<'tcx>> {
+    let operand = if matches!(lhs.kind, ExprKind::Binary(..))
+        && matches!(op, BinOpKind::Eq | BinOpKind::Ne | BinOpKind::Gt)
+        && is_zero_integer_const(cx, rhs)
+    {
+        lhs
+    } else if matches!(rhs.kind, ExprKind::Binary(..))
+        && matches!(op, BinOpKind::Eq | BinOpKind::Ne | BinOpKind::Lt)
+        && is_zero_integer_const(cx, lhs)
+    {
+        rhs
+    } else {
+        return None;
+    };
+
+    matches!(cx.typeck_results().expr_ty_adjusted(operand).kind(), ty::Uint(_)).then_some(operand)
+}
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 2f4e8e99588..bdbbb3475cd 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -11,6 +11,7 @@ mod float_cmp;
 mod float_equality_without_abs;
 mod identity_op;
 mod integer_division;
+mod manual_is_multiple_of;
 mod manual_midpoint;
 mod misrefactored_assign_op;
 mod modulo_arithmetic;
@@ -830,12 +831,42 @@ declare_clippy_lint! {
     "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.89.0"]
+    pub MANUAL_IS_MULTIPLE_OF,
+    complexity,
+    "manual implementation of `.is_multiple_of()`"
+}
+
 pub struct Operators {
     arithmetic_context: numeric_arithmetic::Context,
     verbose_bit_mask_threshold: u64,
     modulo_arithmetic_allow_comparison_to_zero: bool,
     msrv: Msrv,
 }
+
 impl Operators {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
@@ -874,6 +905,7 @@ impl_lint_pass!(Operators => [
     NEEDLESS_BITWISE_BOOL,
     SELF_ASSIGNMENT,
     MANUAL_MIDPOINT,
+    MANUAL_IS_MULTIPLE_OF,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Operators {
@@ -891,6 +923,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                     identity_op::check(cx, e, op.node, lhs, rhs);
                     needless_bitwise_bool::check(cx, e, op.node, lhs, rhs);
                     manual_midpoint::check(cx, e, op.node, lhs, rhs, self.msrv);
+                    manual_is_multiple_of::check(cx, e, op.node, lhs, rhs, self.msrv);
                 }
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
                 bit_mask::check(cx, e, op.node, lhs, rhs);
diff --git a/clippy_lints/src/pass_by_ref_or_value.rs b/clippy_lints/src/pass_by_ref_or_value.rs
index e18bdfb34ac..b8005dfd6f8 100644
--- a/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/clippy_lints/src/pass_by_ref_or_value.rs
@@ -3,10 +3,10 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{for_each_top_level_late_bound_region, is_copy};
 use clippy_utils::{is_self, is_self_ty};
-use rustc_attr_data_structures::{find_attr, AttributeKind, InlineAttr};
-use rustc_data_structures::fx::FxHashSet;
 use core::ops::ControlFlow;
 use rustc_abi::ExternAbi;
+use rustc_attr_data_structures::{AttributeKind, InlineAttr, find_attr};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index c02e5e0621c..de12a25b03d 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -142,6 +142,7 @@ fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         && 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_cfg(cx, els.span)
     {
         let mut applicability = Applicability::MaybeIncorrect;
         let init_expr_str = Sugg::hir_with_applicability(cx, init_expr, "..", &mut applicability).maybe_paren();
diff --git a/clippy_lints/src/question_mark_used.rs b/clippy_lints/src/question_mark_used.rs
index 96ea485d769..7bbbd0d25ac 100644
--- a/clippy_lints/src/question_mark_used.rs
+++ b/clippy_lints/src/question_mark_used.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-
 use clippy_utils::macros::span_is_local;
 use rustc_hir::{Expr, ExprKind, MatchSource};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/read_zero_byte_vec.rs b/clippy_lints/src/read_zero_byte_vec.rs
index 6b1dc864fb7..acd840401c6 100644
--- a/clippy_lints/src/read_zero_byte_vec.rs
+++ b/clippy_lints/src/read_zero_byte_vec.rs
@@ -3,11 +3,10 @@ use clippy_utils::higher::{VecInitKind, get_vec_init_kind};
 use clippy_utils::source::snippet;
 use clippy_utils::{get_enclosing_block, sym};
 
-use hir::{Expr, ExprKind, HirId, LetStmt, PatKind, PathSegment, QPath, StmtKind};
 use rustc_errors::Applicability;
-use rustc_hir as hir;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{Visitor, walk_expr};
+use rustc_hir::{self as hir, Expr, ExprKind, HirId, LetStmt, PatKind, PathSegment, QPath, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 
diff --git a/clippy_lints/src/return_self_not_must_use.rs b/clippy_lints/src/return_self_not_must_use.rs
index 1b304dc5768..25929b853af 100644
--- a/clippy_lints/src/return_self_not_must_use.rs
+++ b/clippy_lints/src/return_self_not_must_use.rs
@@ -1,14 +1,13 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_must_use_ty;
 use clippy_utils::{nth_arg, return_ty};
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, OwnerId, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::declare_lint_pass;
-use rustc_span::{Span};
-use rustc_attr_data_structures::AttributeKind;
-use rustc_attr_data_structures::find_attr;
+use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/clippy_lints/src/single_component_path_imports.rs b/clippy_lints/src/single_component_path_imports.rs
index 62939912304..38cf7e3822a 100644
--- a/clippy_lints/src/single_component_path_imports.rs
+++ b/clippy_lints/src/single_component_path_imports.rs
@@ -219,22 +219,21 @@ impl SingleComponentPathImports {
                             }
                         }
                     }
-                } else {
-                    // keep track of `use self::some_module` usages
-                    if segments[0].ident.name == kw::SelfLower {
-                        // simple case such as `use self::module::SomeStruct`
-                        if segments.len() > 1 {
-                            imports_reused_with_self.push(segments[1].ident.name);
-                            return;
-                        }
+                }
+                // keep track of `use self::some_module` usages
+                else if segments[0].ident.name == kw::SelfLower {
+                    // simple case such as `use self::module::SomeStruct`
+                    if segments.len() > 1 {
+                        imports_reused_with_self.push(segments[1].ident.name);
+                        return;
+                    }
 
-                        // nested case such as `use self::{module1::Struct1, module2::Struct2}`
-                        if let UseTreeKind::Nested { items, .. } = &use_tree.kind {
-                            for tree in items {
-                                let segments = &tree.0.prefix.segments;
-                                if !segments.is_empty() {
-                                    imports_reused_with_self.push(segments[0].ident.name);
-                                }
+                    // nested case such as `use self::{module1::Struct1, module2::Struct2}`
+                    if let UseTreeKind::Nested { items, .. } = &use_tree.kind {
+                        for tree in items {
+                            let segments = &tree.0.prefix.segments;
+                            if !segments.is_empty() {
+                                imports_reused_with_self.push(segments[0].ident.name);
                             }
                         }
                     }
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index a2938c86c76..92427473a8e 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -606,32 +606,31 @@ fn span_from_macro_expansion_has_safety_comment(cx: &LateContext<'_>, span: Span
     let ctxt = span.ctxt();
     if ctxt == SyntaxContext::root() {
         HasSafetyComment::Maybe
-    } else {
-        // From a macro expansion. Get the text from the start of the macro declaration to start of the
-        // unsafe block.
-        //     macro_rules! foo { () => { stuff }; (x) => { unsafe { stuff } }; }
-        //     ^--------------------------------------------^
-        if let Ok(unsafe_line) = source_map.lookup_line(span.lo())
-            && let Ok(macro_line) = source_map.lookup_line(ctxt.outer_expn_data().def_site.lo())
-            && Arc::ptr_eq(&unsafe_line.sf, &macro_line.sf)
-            && let Some(src) = unsafe_line.sf.src.as_deref()
-        {
-            if macro_line.line < unsafe_line.line {
-                match text_has_safety_comment(
-                    src,
-                    &unsafe_line.sf.lines()[macro_line.line + 1..=unsafe_line.line],
-                    unsafe_line.sf.start_pos,
-                ) {
-                    Some(b) => HasSafetyComment::Yes(b),
-                    None => HasSafetyComment::No,
-                }
-            } else {
-                HasSafetyComment::No
+    }
+    // From a macro expansion. Get the text from the start of the macro declaration to start of the
+    // unsafe block.
+    //     macro_rules! foo { () => { stuff }; (x) => { unsafe { stuff } }; }
+    //     ^--------------------------------------------^
+    else if let Ok(unsafe_line) = source_map.lookup_line(span.lo())
+        && let Ok(macro_line) = source_map.lookup_line(ctxt.outer_expn_data().def_site.lo())
+        && Arc::ptr_eq(&unsafe_line.sf, &macro_line.sf)
+        && let Some(src) = unsafe_line.sf.src.as_deref()
+    {
+        if macro_line.line < unsafe_line.line {
+            match text_has_safety_comment(
+                src,
+                &unsafe_line.sf.lines()[macro_line.line + 1..=unsafe_line.line],
+                unsafe_line.sf.start_pos,
+            ) {
+                Some(b) => HasSafetyComment::Yes(b),
+                None => HasSafetyComment::No,
             }
         } else {
-            // Problem getting source text. Pretend a comment was found.
-            HasSafetyComment::Maybe
+            HasSafetyComment::No
         }
+    } else {
+        // Problem getting source text. Pretend a comment was found.
+        HasSafetyComment::Maybe
     }
 }
 
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index 615c0995e8b..73291aa8cdf 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "clippy_utils"
-version = "0.1.89"
+version = "0.1.90"
 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 1aa16e3943c..649748d1534 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-2025-06-12
+nightly-2025-06-26
 ```
 <!-- end autogenerated nightly -->
 
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 1ec5d11384f..aaa071fd5c9 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -958,3 +958,18 @@ fn field_of_struct<'tcx>(
         None
     }
 }
+
+/// If `expr` evaluates to an integer constant, return its value.
+pub fn integer_const(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
+    if let Some(Constant::Int(value)) = ConstEvalCtxt::new(cx).eval_simple(expr) {
+        Some(value)
+    } else {
+        None
+    }
+}
+
+/// Check if `expr` evaluates to an integer constant of 0.
+#[inline]
+pub fn is_zero_integer_const(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    integer_const(cx, expr) == Some(0)
+}
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index cd2098a8989..dc240dd067b 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -109,7 +109,7 @@ pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<Mult
     });
 }
 
-/// Same as `span_lint` but with an extra `help` message.
+/// Same as [`span_lint`] but with an extra `help` message.
 ///
 /// Use this if you want to provide some general help but
 /// can't provide a specific machine applicable suggestion.
@@ -166,7 +166,7 @@ pub fn span_lint_and_help<T: LintContext>(
     });
 }
 
-/// Like `span_lint` but with a `note` section instead of a `help` message.
+/// Like [`span_lint`] but with a `note` section instead of a `help` message.
 ///
 /// The `note` message is presented separately from the main lint message
 /// and is attached to a specific span:
@@ -226,7 +226,7 @@ pub fn span_lint_and_note<T: LintContext>(
     });
 }
 
-/// Like `span_lint` but allows to add notes, help and suggestions using a closure.
+/// Like [`span_lint`] but allows to add notes, help and suggestions using a closure.
 ///
 /// If you need to customize your lint output a lot, use this function.
 /// If you change the signature, remember to update the internal lint `CollapsibleCalls`
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 913589319fc..a8b33418c8c 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -122,7 +122,7 @@ use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::{Ident, Symbol, kw};
 use rustc_span::{InnerSpan, Span};
-use source::walk_span_to_context;
+use source::{SpanRangeExt, walk_span_to_context};
 use visitors::{Visitable, for_each_unconsumed_temporary};
 
 use crate::consts::{ConstEvalCtxt, Constant, mir_to_const};
@@ -1886,10 +1886,7 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         _ => None,
     };
 
-    did.is_some_and(|did| find_attr!(
-            cx.tcx.get_all_attrs(did),
-            AttributeKind::MustUse { ..}
-        ))
+    did.is_some_and(|did| find_attr!(cx.tcx.get_all_attrs(did), AttributeKind::MustUse { .. }))
 }
 
 /// Checks if a function's body represents the identity function. Looks for bodies of the form:
@@ -2713,7 +2710,7 @@ impl<'tcx> ExprUseNode<'tcx> {
 }
 
 /// Gets the context an expression's value is used in.
-pub fn expr_use_ctxt<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> ExprUseCtxt<'tcx> {
+pub fn expr_use_ctxt<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'tcx>) -> ExprUseCtxt<'tcx> {
     let mut adjustments = [].as_slice();
     let mut is_ty_unified = false;
     let mut moved_before_use = false;
@@ -2790,6 +2787,19 @@ pub fn span_contains_comment(sm: &SourceMap, span: Span) -> bool {
     });
 }
 
+/// Checks whether a given span has any significant token. A significant token is a non-whitespace
+/// token, including comments unless `skip_comments` is set.
+/// 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 {
+            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
diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs
index a5e66ad463b..7a0bef1a9bb 100644
--- a/clippy_utils/src/msrvs.rs
+++ b/clippy_utils/src/msrvs.rs
@@ -24,7 +24,7 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,88,0 { LET_CHAINS }
-    1,87,0 { OS_STR_DISPLAY, INT_MIDPOINT, CONST_CHAR_IS_DIGIT }
+    1,87,0 { OS_STR_DISPLAY, INT_MIDPOINT, CONST_CHAR_IS_DIGIT, UNSIGNED_IS_MULTIPLE_OF }
     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 }
@@ -42,6 +42,7 @@ msrv_aliases! {
     1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
     1,63,0 { CLONE_INTO, CONST_SLICE_FROM_REF }
     1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE, CONST_EXTERN_C_FN }
+    1,61,0 { CONST_FN_TRAIT_BOUND }
     1,60,0 { ABS_DIFF }
     1,59,0 { THREAD_LOCAL_CONST_INIT }
     1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY, CONST_RAW_PTR_DEREF }
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index e629012b187..be93f275fab 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -32,6 +32,21 @@ pub fn is_min_const_fn<'tcx>(cx: &LateContext<'tcx>, body: &Body<'tcx>, msrv: Ms
     for local in &body.local_decls {
         check_ty(cx, local.ty, local.source_info.span, msrv)?;
     }
+    if !msrv.meets(cx, msrvs::CONST_FN_TRAIT_BOUND)
+        && let Some(sized_did) = cx.tcx.lang_items().sized_trait()
+        && let Some(meta_sized_did) = cx.tcx.lang_items().meta_sized_trait()
+        && cx.tcx.param_env(def_id).caller_bounds().iter().any(|bound| {
+            bound.as_trait_clause().is_some_and(|clause| {
+                let did = clause.def_id();
+                did != sized_did && did != meta_sized_did
+            })
+        })
+    {
+        return Err((
+            body.span,
+            "non-`Sized` trait clause before `const_fn_trait_bound` is stabilized".into(),
+        ));
+    }
     // impl trait is gone in MIR, so check the return type manually
     check_ty(
         cx,
diff --git a/clippy_utils/src/sugg.rs b/clippy_utils/src/sugg.rs
index 6974e6512e2..7a24d07fa1d 100644
--- a/clippy_utils/src/sugg.rs
+++ b/clippy_utils/src/sugg.rs
@@ -494,7 +494,17 @@ impl<T: Display> Display for ParenHelper<T> {
 /// operators have the same
 /// precedence.
 pub fn make_unop(op: &str, expr: Sugg<'_>) -> Sugg<'static> {
-    Sugg::MaybeParen(format!("{op}{}", expr.maybe_paren()).into())
+    // If the `expr` starts with `op` already, do not add wrap it in
+    // parentheses.
+    let expr = if let Sugg::MaybeParen(ref sugg) = expr
+        && !has_enclosing_paren(sugg)
+        && sugg.starts_with(op)
+    {
+        expr
+    } else {
+        expr.maybe_paren()
+    };
+    Sugg::MaybeParen(format!("{op}{expr}").into())
 }
 
 /// Builds the string for `<lhs> <op> <rhs>` adding parenthesis when necessary.
@@ -1016,6 +1026,16 @@ mod test {
         let sugg = Sugg::BinOp(AssocOp::Binary(ast::BinOpKind::Add), "(1 + 1)".into(), "(1 + 1)".into());
         assert_eq!("((1 + 1) + (1 + 1))", sugg.maybe_paren().to_string());
     }
+
+    #[test]
+    fn unop_parenthesize() {
+        let sugg = Sugg::NonParen("x".into()).mut_addr();
+        assert_eq!("&mut x", sugg.to_string());
+        let sugg = sugg.mut_addr();
+        assert_eq!("&mut &mut x", sugg.to_string());
+        assert_eq!("(&mut &mut x)", sugg.maybe_paren().to_string());
+    }
+
     #[test]
     fn not_op() {
         use ast::BinOpKind::{Add, And, Eq, Ge, Gt, Le, Lt, Ne, Or};
diff --git a/clippy_utils/src/sym.rs b/clippy_utils/src/sym.rs
index 3b58dba5628..8a8218c6976 100644
--- a/clippy_utils/src/sym.rs
+++ b/clippy_utils/src/sym.rs
@@ -46,7 +46,6 @@ generate! {
     DOUBLE_QUOTE: "\"",
     Deserialize,
     EarlyLintPass,
-    ErrorKind,
     IntoIter,
     Itertools,
     LF: "\n",
@@ -65,7 +64,6 @@ generate! {
     RegexBuilder,
     RegexSet,
     Start,
-    Step,
     Symbol,
     SyntaxContext,
     TBD,
@@ -158,7 +156,6 @@ generate! {
     from_ne_bytes,
     from_ptr,
     from_raw,
-    from_ref,
     from_str,
     from_str_radix,
     fs,
@@ -166,6 +163,7 @@ generate! {
     futures_util,
     get,
     get_mut,
+    get_or_insert,
     get_or_insert_with,
     get_unchecked,
     get_unchecked_mut,
@@ -216,7 +214,6 @@ generate! {
     max_by_key,
     max_value,
     maximum,
-    mem,
     min,
     min_by,
     min_by_key,
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index 782b079ce09..bffbcf073ab 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -6,6 +6,7 @@ use core::ops::ControlFlow;
 use itertools::Itertools;
 use rustc_abi::VariantIdx;
 use rustc_ast::ast::Mutability;
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
@@ -20,8 +21,8 @@ use rustc_middle::traits::EvaluationResult;
 use rustc_middle::ty::layout::ValidityRequirement;
 use rustc_middle::ty::{
     self, AdtDef, AliasTy, AssocItem, AssocTag, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
-    GenericParamDefKind, IntTy, Region, RegionKind, TraitRef, Ty, TyCtxt, TypeSuperVisitable,
-    TypeVisitable, TypeVisitableExt, TypeVisitor, UintTy, Upcast, VariantDef, VariantDiscr,
+    GenericParamDefKind, IntTy, Region, RegionKind, TraitRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
+    TypeVisitableExt, TypeVisitor, UintTy, Upcast, VariantDef, VariantDiscr,
 };
 use rustc_span::symbol::Ident;
 use rustc_span::{DUMMY_SP, Span, Symbol, sym};
@@ -31,8 +32,6 @@ use rustc_trait_selection::traits::{Obligation, ObligationCause};
 use std::assert_matches::debug_assert_matches;
 use std::collections::hash_map::Entry;
 use std::iter;
-use rustc_attr_data_structures::find_attr;
-use rustc_attr_data_structures::AttributeKind;
 
 use crate::path_res;
 use crate::paths::{PathNS, lookup_path_str};
@@ -328,14 +327,8 @@ pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
 // Returns whether the type has #[must_use] attribute
 pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     match ty.kind() {
-        ty::Adt(adt, _) => find_attr!(
-            cx.tcx.get_all_attrs(adt.did()),
-            AttributeKind::MustUse { ..}
-        ),
-        ty::Foreign(did) => find_attr!(
-            cx.tcx.get_all_attrs(*did),
-            AttributeKind::MustUse { ..}
-        ),
+        ty::Adt(adt, _) => find_attr!(cx.tcx.get_all_attrs(adt.did()), AttributeKind::MustUse { .. }),
+        ty::Foreign(did) => find_attr!(cx.tcx.get_all_attrs(*did), AttributeKind::MustUse { .. }),
         ty::Slice(ty) | ty::Array(ty, _) | ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => {
             // for the Array case we don't need to care for the len == 0 case
             // because we don't want to lint functions returning empty arrays
@@ -345,7 +338,10 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         ty::Alias(ty::Opaque, AliasTy { def_id, .. }) => {
             for (predicate, _) in cx.tcx.explicit_item_self_bounds(def_id).skip_binder() {
                 if let ty::ClauseKind::Trait(trait_predicate) = predicate.kind().skip_binder()
-                    && find_attr!(cx.tcx.get_all_attrs(trait_predicate.trait_ref.def_id), AttributeKind::MustUse { ..})
+                    && find_attr!(
+                        cx.tcx.get_all_attrs(trait_predicate.trait_ref.def_id),
+                        AttributeKind::MustUse { .. }
+                    )
                 {
                     return true;
                 }
@@ -355,7 +351,7 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         ty::Dynamic(binder, _, _) => {
             for predicate in *binder {
                 if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder()
-                    && find_attr!(cx.tcx.get_all_attrs(trait_ref.def_id), AttributeKind::MustUse { ..})
+                    && find_attr!(cx.tcx.get_all_attrs(trait_ref.def_id), AttributeKind::MustUse { .. })
                 {
                     return true;
                 }
diff --git a/declare_clippy_lint/Cargo.toml b/declare_clippy_lint/Cargo.toml
new file mode 100644
index 00000000000..bd6b4dfdee4
--- /dev/null
+++ b/declare_clippy_lint/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "declare_clippy_lint"
+version = "0.1.90"
+edition = "2024"
+repository = "https://github.com/rust-lang/rust-clippy"
+license = "MIT OR Apache-2.0"
+
+[package.metadata.rust-analyzer]
+# This crate uses #[feature(rustc_private)]
+rustc_private = true
diff --git a/declare_clippy_lint/src/lib.rs b/declare_clippy_lint/src/lib.rs
new file mode 100644
index 00000000000..f7d9c64bfbd
--- /dev/null
+++ b/declare_clippy_lint/src/lib.rs
@@ -0,0 +1,280 @@
+#![feature(macro_metavar_expr_concat, rustc_private)]
+
+extern crate rustc_lint;
+
+use rustc_lint::{Lint, LintId, LintStore};
+
+// Needed by `declare_clippy_lint!`.
+pub extern crate rustc_session;
+
+#[derive(Default)]
+pub struct LintListBuilder {
+    lints: Vec<&'static Lint>,
+    all: Vec<LintId>,
+    cargo: Vec<LintId>,
+    complexity: Vec<LintId>,
+    correctness: Vec<LintId>,
+    nursery: Vec<LintId>,
+    pedantic: Vec<LintId>,
+    perf: Vec<LintId>,
+    restriction: Vec<LintId>,
+    style: Vec<LintId>,
+    suspicious: Vec<LintId>,
+}
+impl LintListBuilder {
+    pub fn insert(&mut self, lints: &[&LintInfo]) {
+        #[allow(clippy::enum_glob_use)]
+        use LintCategory::*;
+
+        self.lints.extend(lints.iter().map(|&x| x.lint));
+        for &&LintInfo { lint, category, .. } in lints {
+            let (all, cat) = match category {
+                Complexity => (Some(&mut self.all), &mut self.complexity),
+                Correctness => (Some(&mut self.all), &mut self.correctness),
+                Perf => (Some(&mut self.all), &mut self.perf),
+                Style => (Some(&mut self.all), &mut self.style),
+                Suspicious => (Some(&mut self.all), &mut self.suspicious),
+                Cargo => (None, &mut self.cargo),
+                Nursery => (None, &mut self.nursery),
+                Pedantic => (None, &mut self.pedantic),
+                Restriction => (None, &mut self.restriction),
+            };
+            if let Some(all) = all {
+                all.push(LintId::of(lint));
+            }
+            cat.push(LintId::of(lint));
+        }
+    }
+
+    pub fn register(self, store: &mut LintStore) {
+        store.register_lints(&self.lints);
+        store.register_group(true, "clippy::all", Some("clippy_all"), self.all);
+        store.register_group(true, "clippy::cargo", Some("clippy_cargo"), self.cargo);
+        store.register_group(true, "clippy::complexity", Some("clippy_complexity"), self.complexity);
+        store.register_group(
+            true,
+            "clippy::correctness",
+            Some("clippy_correctness"),
+            self.correctness,
+        );
+        store.register_group(true, "clippy::nursery", Some("clippy_nursery"), self.nursery);
+        store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), self.pedantic);
+        store.register_group(true, "clippy::perf", Some("clippy_perf"), self.perf);
+        store.register_group(
+            true,
+            "clippy::restriction",
+            Some("clippy_restriction"),
+            self.restriction,
+        );
+        store.register_group(true, "clippy::style", Some("clippy_style"), self.style);
+        store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), self.suspicious);
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum LintCategory {
+    Cargo,
+    Complexity,
+    Correctness,
+    Nursery,
+    Pedantic,
+    Perf,
+    Restriction,
+    Style,
+    Suspicious,
+}
+impl LintCategory {
+    #[must_use]
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Cargo => "cargo",
+            Self::Complexity => "complexity",
+            Self::Correctness => "correctness",
+            Self::Nursery => "nursery",
+            Self::Pedantic => "pedantic",
+            Self::Perf => "perf",
+            Self::Restriction => "restriction",
+            Self::Style => "style",
+            Self::Suspicious => "suspicious",
+        }
+    }
+}
+
+pub struct LintInfo {
+    pub lint: &'static Lint,
+    pub category: LintCategory,
+    pub explanation: &'static str,
+    /// e.g. `clippy_lints/src/absolute_paths.rs#43`
+    pub location: &'static str,
+    pub version: &'static str,
+}
+
+impl LintInfo {
+    /// Returns the lint name in lowercase without the `clippy::` prefix
+    #[must_use]
+    #[expect(clippy::missing_panics_doc)]
+    pub fn name_lower(&self) -> String {
+        self.lint.name.strip_prefix("clippy::").unwrap().to_ascii_lowercase()
+    }
+}
+
+#[macro_export]
+macro_rules! declare_clippy_lint_inner {
+    (
+        $(#[doc = $docs:literal])*
+        #[clippy::version = $version:literal]
+        $vis:vis $lint_name:ident,
+        $level:ident,
+        $category:ident,
+        $desc:literal
+        $(, @eval_always = $eval_always:literal)?
+    ) => {
+        $crate::rustc_session::declare_tool_lint! {
+            $(#[doc = $docs])*
+            #[clippy::version = $version]
+            $vis clippy::$lint_name,
+            $level,
+            $desc,
+            report_in_external_macro:true
+            $(, @eval_always = $eval_always)?
+        }
+
+        pub(crate) static ${concat($lint_name, _INFO)}: &'static $crate::LintInfo = &$crate::LintInfo {
+            lint: $lint_name,
+            category: $crate::LintCategory::$category,
+            explanation: concat!($($docs,"\n",)*),
+            location: concat!(file!(), "#L", line!()),
+            version: $version,
+        };
+    };
+}
+
+#[macro_export]
+macro_rules! declare_clippy_lint {
+    (
+        $(#[$($meta:tt)*])*
+        $vis:vis $lint_name:ident,
+        correctness,
+        $($rest:tt)*
+    ) => {
+        $crate::declare_clippy_lint_inner! {
+            $(#[$($meta)*])*
+            $vis $lint_name,
+            Deny,
+            Correctness,
+            $($rest)*
+        }
+    };
+    (
+        $(#[$($meta:tt)*])*
+        $vis:vis $lint_name:ident,
+        complexity,
+        $($rest:tt)*
+    ) => {
+        $crate::declare_clippy_lint_inner! {
+            $(#[$($meta)*])*
+            $vis $lint_name,
+            Warn,
+            Complexity,
+            $($rest)*
+        }
+    };
+    (
+        $(#[$($meta:tt)*])*
+        $vis:vis $lint_name:ident,
+        perf,
+        $($rest:tt)*
+    ) => {
+        $crate::declare_clippy_lint_inner! {
+            $(#[$($meta)*])*
+            $vis $lint_name,
+            Warn,
+            Perf,
+            $($rest)*
+        }
+    };
+    (
+        $(#[$($meta:tt)*])*
+        $vis:vis $lint_name:ident,
+        style,
+        $($rest:tt)*
+    ) => {
+        $crate::declare_clippy_lint_inner! {
+            $(#[$($meta)*])*
+            $vis $lint_name,
+            Warn,
+            Style,
+            $($rest)*
+        }
+    };
+    (
+        $(#[$($meta:tt)*])*
+        $vis:vis $lint_name:ident,
+        suspicious,
+        $($rest:tt)*
+    ) => {
+        $crate::declare_clippy_lint_inner! {
+            $(#[$($meta)*])*
+            $vis $lint_name,
+            Warn,
+            Suspicious,
+            $($rest)*
+        }
+    };
+    (
+        $(#[$($meta:tt)*])*
+        $vis:vis $lint_name:ident,
+        cargo,
+        $($rest:tt)*
+    ) => {
+        $crate::declare_clippy_lint_inner! {
+            $(#[$($meta)*])*
+            $vis $lint_name,
+            Allow,
+            Cargo,
+            $($rest)*
+        }
+    };
+    (
+        $(#[$($meta:tt)*])*
+        $vis:vis $lint_name:ident,
+        nursery,
+        $($rest:tt)*
+    ) => {
+        $crate::declare_clippy_lint_inner! {
+            $(#[$($meta)*])*
+            $vis $lint_name,
+            Allow,
+            Nursery,
+            $($rest)*
+        }
+    };
+    (
+        $(#[$($meta:tt)*])*
+        $vis:vis $lint_name:ident,
+        pedantic,
+        $($rest:tt)*
+    ) => {
+        $crate::declare_clippy_lint_inner! {
+            $(#[$($meta)*])*
+            $vis $lint_name,
+            Allow,
+            Pedantic,
+            $($rest)*
+        }
+    };
+    (
+        $(#[$($meta:tt)*])*
+        $vis:vis $lint_name:ident,
+        restriction,
+        $($rest:tt)*
+    ) => {
+        $crate::declare_clippy_lint_inner! {
+            $(#[$($meta)*])*
+            $vis $lint_name,
+            Allow,
+            Restriction,
+            $($rest)*
+        }
+    };
+}
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index 84183831432..eb390eecbcc 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -45,7 +45,7 @@ use rayon::prelude::*;
 
 #[must_use]
 pub fn target_dir() -> String {
-    env::var("CARGO_TARGET_DIR").unwrap_or("target".to_owned())
+    env::var("CARGO_TARGET_DIR").unwrap_or_else(|_| "target".to_owned())
 }
 
 fn lintcheck_sources() -> String {
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 3fc5a1224a8..124756a3600 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2025-06-12"
+channel = "nightly-2025-06-26"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"
diff --git a/src/driver.rs b/src/driver.rs
index 426ba870f5f..c4076cbaa77 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -19,6 +19,7 @@ extern crate rustc_span;
 extern crate tikv_jemalloc_sys as jemalloc_sys;
 
 use clippy_utils::sym;
+use declare_clippy_lint::LintListBuilder;
 use rustc_interface::interface;
 use rustc_session::EarlyDiagCtxt;
 use rustc_session::config::ErrorOutputType;
@@ -156,8 +157,13 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
                 (previous)(sess, lint_store);
             }
 
+            let mut list_builder = LintListBuilder::default();
+            list_builder.insert(clippy_lints::declared_lints::LINTS);
+            list_builder.register(lint_store);
+
             let conf = clippy_config::Conf::read(sess, &conf_path);
-            clippy_lints::register_lints(lint_store, conf);
+            clippy_lints::register_lint_passes(lint_store, conf);
+
             #[cfg(feature = "internal")]
             clippy_lints_internal::register_lints(lint_store);
         }));
diff --git a/src/main.rs b/src/main.rs
index c9853e53f3b..3c2eec1f05b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -107,7 +107,7 @@ impl ClippyCmd {
     }
 
     fn into_std_cmd(self) -> Command {
-        let mut cmd = Command::new(env::var("CARGO").unwrap_or("cargo".into()));
+        let mut cmd = Command::new(env::var("CARGO").unwrap_or_else(|_| "cargo".into()));
         let clippy_args: String = self
             .clippy_args
             .iter()
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 99a01257a7b..cefe654fef6 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -7,9 +7,9 @@ use askama::filters::Safe;
 use cargo_metadata::Message;
 use cargo_metadata::diagnostic::{Applicability, Diagnostic};
 use clippy_config::ClippyConfiguration;
-use clippy_lints::LintInfo;
 use clippy_lints::declared_lints::LINTS;
 use clippy_lints::deprecated_lints::{DEPRECATED, DEPRECATED_VERSION, RENAMED};
+use declare_clippy_lint::LintInfo;
 use pulldown_cmark::{Options, Parser, html};
 use serde::Deserialize;
 use test_utils::IS_RUSTC_TEST_SUITE;
@@ -568,10 +568,10 @@ impl LintMetadata {
         Self {
             id: name,
             id_location: Some(lint.location),
-            group: lint.category_str(),
+            group: lint.category.name(),
             level: lint.lint.default_level.as_str(),
             docs,
-            version: lint.version.unwrap(),
+            version: lint.version,
             applicability,
         }
     }
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index 4ac2bd53285..389616801fc 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -40,6 +40,7 @@ fn dogfood() {
         "clippy_lints",
         "clippy_utils",
         "clippy_config",
+        "declare_clippy_lint",
         "lintcheck",
         "rustc_tools_util",
     ] {
diff --git a/tests/ui-toml/collapsible_if/collapsible_else_if.fixed b/tests/ui-toml/collapsible_if/collapsible_else_if.fixed
new file mode 100644
index 00000000000..0dc0fc230c8
--- /dev/null
+++ b/tests/ui-toml/collapsible_if/collapsible_else_if.fixed
@@ -0,0 +1,50 @@
+#![allow(clippy::eq_op, clippy::nonminimal_bool)]
+
+#[rustfmt::skip]
+#[warn(clippy::collapsible_if)]
+fn main() {
+    let (x, y) = ("hello", "world");
+
+    if x == "hello" {
+        todo!()
+    }
+        // Comment must be kept
+        else if y == "world" {
+            println!("Hello world!");
+        }
+    //~^^^^^^ collapsible_else_if
+
+    if x == "hello" {
+        todo!()
+    } // Inner comment
+        else if y == "world" {
+            println!("Hello world!");
+        }
+    //~^^^^^ collapsible_else_if
+
+    if x == "hello" {
+        todo!()
+    }
+        /* Inner comment */
+        else if y == "world" {
+            println!("Hello world!");
+        }
+    //~^^^^^^ collapsible_else_if
+
+    if x == "hello" { 
+        todo!()
+    } /* Inner comment */
+        else if y == "world" {
+            println!("Hello world!");
+        }
+    //~^^^^^ collapsible_else_if
+
+    if x == "hello" {
+        todo!()
+    } /* This should not be removed */ /* So does this */
+        // Comment must be kept
+        else if y == "world" {
+            println!("Hello world!");
+        }
+    //~^^^^^^ collapsible_else_if
+}
diff --git a/tests/ui-toml/collapsible_if/collapsible_else_if.rs b/tests/ui-toml/collapsible_if/collapsible_else_if.rs
new file mode 100644
index 00000000000..8344c122f16
--- /dev/null
+++ b/tests/ui-toml/collapsible_if/collapsible_else_if.rs
@@ -0,0 +1,55 @@
+#![allow(clippy::eq_op, clippy::nonminimal_bool)]
+
+#[rustfmt::skip]
+#[warn(clippy::collapsible_if)]
+fn main() {
+    let (x, y) = ("hello", "world");
+
+    if x == "hello" {
+        todo!()
+    } else {
+        // Comment must be kept
+        if y == "world" {
+            println!("Hello world!");
+        }
+    }
+    //~^^^^^^ collapsible_else_if
+
+    if x == "hello" {
+        todo!()
+    } else { // Inner comment
+        if y == "world" {
+            println!("Hello world!");
+        }
+    }
+    //~^^^^^ collapsible_else_if
+
+    if x == "hello" {
+        todo!()
+    } else {
+        /* Inner comment */
+        if y == "world" {
+            println!("Hello world!");
+        }
+    }
+    //~^^^^^^ collapsible_else_if
+
+    if x == "hello" { 
+        todo!()
+    } else { /* Inner comment */
+        if y == "world" {
+            println!("Hello world!");
+        }
+    }
+    //~^^^^^ collapsible_else_if
+
+    if x == "hello" {
+        todo!()
+    } /* This should not be removed */ else /* So does this */ {
+        // Comment must be kept
+        if y == "world" {
+            println!("Hello world!");
+        }
+    }
+    //~^^^^^^ collapsible_else_if
+}
diff --git a/tests/ui-toml/collapsible_if/collapsible_else_if.stderr b/tests/ui-toml/collapsible_if/collapsible_else_if.stderr
new file mode 100644
index 00000000000..0ffe5f0a960
--- /dev/null
+++ b/tests/ui-toml/collapsible_if/collapsible_else_if.stderr
@@ -0,0 +1,105 @@
+error: this `else { if .. }` block can be collapsed
+  --> tests/ui-toml/collapsible_if/collapsible_else_if.rs:10:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         // Comment must be kept
+LL | |         if y == "world" {
+LL | |             println!("Hello world!");
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+   = note: `-D clippy::collapsible-else-if` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::collapsible_else_if)]`
+help: collapse nested if block
+   |
+LL ~     }
+LL |         // Comment must be kept
+LL ~         else if y == "world" {
+LL |             println!("Hello world!");
+LL ~         }
+   |
+
+error: this `else { if .. }` block can be collapsed
+  --> tests/ui-toml/collapsible_if/collapsible_else_if.rs:20:12
+   |
+LL |       } else { // Inner comment
+   |  ____________^
+LL | |         if y == "world" {
+LL | |             println!("Hello world!");
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: collapse nested if block
+   |
+LL ~     } // Inner comment
+LL ~         else if y == "world" {
+LL |             println!("Hello world!");
+LL ~         }
+   |
+
+error: this `else { if .. }` block can be collapsed
+  --> tests/ui-toml/collapsible_if/collapsible_else_if.rs:29:12
+   |
+LL |       } else {
+   |  ____________^
+LL | |         /* Inner comment */
+LL | |         if y == "world" {
+LL | |             println!("Hello world!");
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: collapse nested if block
+   |
+LL ~     }
+LL |         /* Inner comment */
+LL ~         else if y == "world" {
+LL |             println!("Hello world!");
+LL ~         }
+   |
+
+error: this `else { if .. }` block can be collapsed
+  --> tests/ui-toml/collapsible_if/collapsible_else_if.rs:39:12
+   |
+LL |       } else { /* Inner comment */
+   |  ____________^
+LL | |         if y == "world" {
+LL | |             println!("Hello world!");
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: collapse nested if block
+   |
+LL ~     } /* Inner comment */
+LL ~         else if y == "world" {
+LL |             println!("Hello world!");
+LL ~         }
+   |
+
+error: this `else { if .. }` block can be collapsed
+  --> tests/ui-toml/collapsible_if/collapsible_else_if.rs:48:64
+   |
+LL |       } /* This should not be removed */ else /* So does this */ {
+   |  ________________________________________________________________^
+LL | |         // Comment must be kept
+LL | |         if y == "world" {
+LL | |             println!("Hello world!");
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: collapse nested if block
+   |
+LL ~     } /* This should not be removed */ /* So does this */
+LL |         // Comment must be kept
+LL ~         else if y == "world" {
+LL |             println!("Hello world!");
+LL ~         }
+   |
+
+error: aborting due to 5 previous errors
+
diff --git a/tests/ui/borrow_deref_ref.fixed b/tests/ui/borrow_deref_ref.fixed
index 765dd75fceb..6d06fcc3037 100644
--- a/tests/ui/borrow_deref_ref.fixed
+++ b/tests/ui/borrow_deref_ref.fixed
@@ -124,3 +124,50 @@ mod issue_11346 {
         //~^ borrow_deref_ref
     }
 }
+
+fn issue_14934() {
+    let x: &'static str = "x";
+    let y = "y".to_string();
+    {
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = &*x; // Do not lint
+        *x = &*y;
+    }
+    {
+        let mut x = x;
+        //~^ borrow_deref_ref
+        x = &*y;
+    }
+    {
+        #[expect(clippy::toplevel_ref_arg, clippy::needless_borrow)]
+        let ref x = x;
+        //~^ borrow_deref_ref
+    }
+    {
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = std::convert::identity(x);
+        //~^ borrow_deref_ref
+        *x = &*y;
+    }
+    {
+        #[derive(Clone)]
+        struct S(&'static str);
+        let s = S("foo");
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = &*s.0; // Do not lint
+        *x = "bar";
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = s.clone().0;
+        //~^ borrow_deref_ref
+        *x = "bar";
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = &*std::convert::identity(&s).0;
+        *x = "bar";
+    }
+    {
+        let y = &1;
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = { y };
+        //~^ borrow_deref_ref
+    }
+}
diff --git a/tests/ui/borrow_deref_ref.rs b/tests/ui/borrow_deref_ref.rs
index 8ee66bfa881..b43f4c93bf2 100644
--- a/tests/ui/borrow_deref_ref.rs
+++ b/tests/ui/borrow_deref_ref.rs
@@ -124,3 +124,50 @@ mod issue_11346 {
         //~^ borrow_deref_ref
     }
 }
+
+fn issue_14934() {
+    let x: &'static str = "x";
+    let y = "y".to_string();
+    {
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = &*x; // Do not lint
+        *x = &*y;
+    }
+    {
+        let mut x = &*x;
+        //~^ borrow_deref_ref
+        x = &*y;
+    }
+    {
+        #[expect(clippy::toplevel_ref_arg, clippy::needless_borrow)]
+        let ref x = &*x;
+        //~^ borrow_deref_ref
+    }
+    {
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = &*std::convert::identity(x);
+        //~^ borrow_deref_ref
+        *x = &*y;
+    }
+    {
+        #[derive(Clone)]
+        struct S(&'static str);
+        let s = S("foo");
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = &*s.0; // Do not lint
+        *x = "bar";
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = &*s.clone().0;
+        //~^ borrow_deref_ref
+        *x = "bar";
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = &*std::convert::identity(&s).0;
+        *x = "bar";
+    }
+    {
+        let y = &1;
+        #[expect(clippy::toplevel_ref_arg)]
+        let ref mut x = { &*y };
+        //~^ borrow_deref_ref
+    }
+}
diff --git a/tests/ui/borrow_deref_ref.stderr b/tests/ui/borrow_deref_ref.stderr
index 3d55da25b9b..3a1f968b4be 100644
--- a/tests/ui/borrow_deref_ref.stderr
+++ b/tests/ui/borrow_deref_ref.stderr
@@ -25,5 +25,35 @@ error: deref on an immutable reference
 LL |         (&*s).foo();
    |         ^^^^^ help: if you would like to reborrow, try removing `&*`: `s`
 
-error: aborting due to 4 previous errors
+error: deref on an immutable reference
+  --> tests/ui/borrow_deref_ref.rs:137:21
+   |
+LL |         let mut x = &*x;
+   |                     ^^^ help: if you would like to reborrow, try removing `&*`: `x`
+
+error: deref on an immutable reference
+  --> tests/ui/borrow_deref_ref.rs:143:21
+   |
+LL |         let ref x = &*x;
+   |                     ^^^ help: if you would like to reborrow, try removing `&*`: `x`
+
+error: deref on an immutable reference
+  --> tests/ui/borrow_deref_ref.rs:148:25
+   |
+LL |         let ref mut x = &*std::convert::identity(x);
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you would like to reborrow, try removing `&*`: `std::convert::identity(x)`
+
+error: deref on an immutable reference
+  --> tests/ui/borrow_deref_ref.rs:160:25
+   |
+LL |         let ref mut x = &*s.clone().0;
+   |                         ^^^^^^^^^^^^^ help: if you would like to reborrow, try removing `&*`: `s.clone().0`
+
+error: deref on an immutable reference
+  --> tests/ui/borrow_deref_ref.rs:170:27
+   |
+LL |         let ref mut x = { &*y };
+   |                           ^^^ help: if you would like to reborrow, try removing `&*`: `y`
+
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/borrow_interior_mutable_const.rs b/tests/ui/borrow_interior_mutable_const.rs
index 0f439f78915..674450a73ad 100644
--- a/tests/ui/borrow_interior_mutable_const.rs
+++ b/tests/ui/borrow_interior_mutable_const.rs
@@ -218,4 +218,20 @@ fn main() {
         let _ = &S::VALUE.1; //~ borrow_interior_mutable_const
         let _ = &S::VALUE.2;
     }
+    {
+        pub struct Foo<T, const N: usize>(pub Entry<N>, pub T);
+
+        pub struct Entry<const N: usize>(pub Cell<[u32; N]>);
+
+        impl<const N: usize> Entry<N> {
+            const INIT: Self = Self(Cell::new([42; N]));
+        }
+
+        impl<T, const N: usize> Foo<T, N> {
+            pub fn make_foo(v: T) -> Self {
+                // Used to ICE due to incorrect instantiation.
+                Foo(Entry::INIT, v)
+            }
+        }
+    }
 }
diff --git a/tests/ui/box_default.fixed b/tests/ui/box_default.fixed
index 80000f5de4f..ed00494433b 100644
--- a/tests/ui/box_default.fixed
+++ b/tests/ui/box_default.fixed
@@ -126,7 +126,7 @@ fn issue_10381() {
     impl Bar for Foo {}
 
     fn maybe_get_bar(i: u32) -> Option<Box<dyn Bar>> {
-        if i % 2 == 0 {
+        if i.is_multiple_of(2) {
             Some(Box::new(Foo::default()))
         } else {
             None
diff --git a/tests/ui/box_default.rs b/tests/ui/box_default.rs
index 4681016d7cd..801d92f5c29 100644
--- a/tests/ui/box_default.rs
+++ b/tests/ui/box_default.rs
@@ -126,7 +126,7 @@ fn issue_10381() {
     impl Bar for Foo {}
 
     fn maybe_get_bar(i: u32) -> Option<Box<dyn Bar>> {
-        if i % 2 == 0 {
+        if i.is_multiple_of(2) {
             Some(Box::new(Foo::default()))
         } else {
             None
diff --git a/tests/ui/branches_sharing_code/shared_at_bottom.rs b/tests/ui/branches_sharing_code/shared_at_bottom.rs
index 922d30443fc..fa322dc28a7 100644
--- a/tests/ui/branches_sharing_code/shared_at_bottom.rs
+++ b/tests/ui/branches_sharing_code/shared_at_bottom.rs
@@ -276,3 +276,27 @@ mod issue14873 {
         }
     }
 }
+
+fn issue15004() {
+    let a = 12u32;
+    let b = 13u32;
+    let mut c = 8u32;
+
+    let mut result = if b > a {
+        c += 1;
+        0
+    } else {
+        c += 2;
+        0
+        //~^ branches_sharing_code
+    };
+
+    result = if b > a {
+        c += 1;
+        1
+    } else {
+        c += 2;
+        1
+        //~^ branches_sharing_code
+    };
+}
diff --git a/tests/ui/branches_sharing_code/shared_at_bottom.stderr b/tests/ui/branches_sharing_code/shared_at_bottom.stderr
index f437db8b733..1c470fb0da5 100644
--- a/tests/ui/branches_sharing_code/shared_at_bottom.stderr
+++ b/tests/ui/branches_sharing_code/shared_at_bottom.stderr
@@ -172,5 +172,35 @@ LL ~         }
 LL +         let y = 1;
    |
 
-error: aborting due to 10 previous errors
+error: all if blocks contain the same code at the end
+  --> tests/ui/branches_sharing_code/shared_at_bottom.rs:290:5
+   |
+LL | /         0
+LL | |
+LL | |     };
+   | |_____^
+   |
+   = note: the end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving these statements after the if
+   |
+LL ~     }
+LL ~     0;
+   |
+
+error: all if blocks contain the same code at the end
+  --> tests/ui/branches_sharing_code/shared_at_bottom.rs:299:5
+   |
+LL | /         1
+LL | |
+LL | |     };
+   | |_____^
+   |
+   = note: the end suggestion probably needs some adjustments to use the expression result correctly
+help: consider moving these statements after the if
+   |
+LL ~     }
+LL ~     1;
+   |
+
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/collapsible_else_if.fixed b/tests/ui/collapsible_else_if.fixed
index 9f530ad670a..fed75244c6f 100644
--- a/tests/ui/collapsible_else_if.fixed
+++ b/tests/ui/collapsible_else_if.fixed
@@ -86,3 +86,21 @@ fn issue_7318() {
     }else if false {}
     //~^^^ collapsible_else_if
 }
+
+fn issue14799() {
+    use std::ops::ControlFlow;
+
+    let c: ControlFlow<_, ()> = ControlFlow::Break(Some(42));
+    if let ControlFlow::Break(Some(_)) = c {
+        todo!();
+    } else {
+        #[cfg(target_os = "freebsd")]
+        todo!();
+
+        if let ControlFlow::Break(None) = c {
+            todo!();
+        } else {
+            todo!();
+        }
+    }
+}
diff --git a/tests/ui/collapsible_else_if.rs b/tests/ui/collapsible_else_if.rs
index 2c646cd1d4d..e50e781fb69 100644
--- a/tests/ui/collapsible_else_if.rs
+++ b/tests/ui/collapsible_else_if.rs
@@ -102,3 +102,21 @@ fn issue_7318() {
     }
     //~^^^ collapsible_else_if
 }
+
+fn issue14799() {
+    use std::ops::ControlFlow;
+
+    let c: ControlFlow<_, ()> = ControlFlow::Break(Some(42));
+    if let ControlFlow::Break(Some(_)) = c {
+        todo!();
+    } else {
+        #[cfg(target_os = "freebsd")]
+        todo!();
+
+        if let ControlFlow::Break(None) = c {
+            todo!();
+        } else {
+            todo!();
+        }
+    }
+}
diff --git a/tests/ui/collapsible_if.fixed b/tests/ui/collapsible_if.fixed
index b553182a445..77bc791ea8e 100644
--- a/tests/ui/collapsible_if.fixed
+++ b/tests/ui/collapsible_if.fixed
@@ -154,3 +154,12 @@ fn issue14722() {
         None
     };
 }
+
+fn issue14799() {
+    if true {
+        #[cfg(target_os = "freebsd")]
+        todo!();
+
+        if true {}
+    };
+}
diff --git a/tests/ui/collapsible_if.rs b/tests/ui/collapsible_if.rs
index f5998457ca6..d30df157d5e 100644
--- a/tests/ui/collapsible_if.rs
+++ b/tests/ui/collapsible_if.rs
@@ -164,3 +164,12 @@ fn issue14722() {
         None
     };
 }
+
+fn issue14799() {
+    if true {
+        #[cfg(target_os = "freebsd")]
+        todo!();
+
+        if true {}
+    };
+}
diff --git a/tests/ui/doc/needless_doctest_main.rs b/tests/ui/doc/needless_doctest_main.rs
index 633a435ca5e..8c3217624d4 100644
--- a/tests/ui/doc/needless_doctest_main.rs
+++ b/tests/ui/doc/needless_doctest_main.rs
@@ -1,5 +1,3 @@
-//@ check-pass
-
 #![warn(clippy::needless_doctest_main)]
 //! issue 10491:
 //! ```rust,no_test
@@ -19,4 +17,114 @@
 /// ```
 fn foo() {}
 
+#[rustfmt::skip]
+/// Description
+/// ```rust
+/// fn main() {
+//~^ error: needless `fn main` in doctest
+///     let a = 0;
+/// }
+/// ```
+fn mulpipulpi() {}
+
+#[rustfmt::skip]
+/// With a `#[no_main]`
+/// ```rust
+/// #[no_main]
+/// fn a() {
+///     let _ = 0;
+/// }
+/// ```
+fn pulpimulpi() {}
+
+// Without a `#[no_main]` attribute
+/// ```rust
+/// fn a() {
+///     let _ = 0;
+/// }
+/// ```
+fn plumilupi() {}
+
+#[rustfmt::skip]
+/// Additional function, shouldn't trigger
+/// ```rust
+/// fn additional_function() {
+///     let _ = 0;
+///     // Thus `fn main` is actually relevant!
+/// }
+/// fn main() {
+///     let _ = 0;
+/// }
+/// ```
+fn mlupipupi() {}
+
+#[rustfmt::skip]
+/// Additional function AFTER main, shouldn't trigger
+/// ```rust
+/// fn main() {
+///     let _ = 0;
+/// }
+/// fn additional_function() {
+///     let _ = 0;
+///     // Thus `fn main` is actually relevant!
+/// }
+/// ```
+fn lumpimupli() {}
+
+#[rustfmt::skip]
+/// Ignore code block, should not lint at all
+/// ```rust, ignore
+/// fn main() {
+//~^ error: needless `fn main` in doctest
+///     // Hi!
+///     let _ = 0;
+/// }
+/// ```
+fn mpulpilumi() {}
+
+#[rustfmt::skip]
+/// Spaces in weird positions (including an \u{A0} after `main`)
+/// ```rust
+/// fn     main (){
+//~^ error: needless `fn main` in doctest
+///     let _ = 0;
+/// }
+/// ```
+fn plumpiplupi() {}
+
+/// 4 Functions, this should not lint because there are several function
+///
+/// ```rust
+/// fn a() {let _ = 0; }
+/// fn b() {let _ = 0; }
+/// fn main() { let _ = 0; }
+/// fn d() { let _ = 0; }
+/// ```
+fn pulmipulmip() {}
+
+/// 3 Functions but main is first, should also not lint
+///
+///```rust
+/// fn main() { let _ = 0; }
+/// fn b() { let _ = 0; }
+/// fn c() { let _ = 0; }
+/// ```
+fn pmuplimulip() {}
+
 fn main() {}
+
+fn issue8244() -> Result<(), ()> {
+    //! ```compile_fail
+    //! fn test() -> Result< {}
+    //! ```
+    Ok(())
+}
+
+/// # Examples
+///
+/// ```
+/// use std::error::Error;
+/// fn main() -> Result<(), Box<dyn Error>/* > */ {
+/// }
+/// ```
+fn issue15041() {}
diff --git a/tests/ui/doc/needless_doctest_main.stderr b/tests/ui/doc/needless_doctest_main.stderr
new file mode 100644
index 00000000000..dd5474ccb85
--- /dev/null
+++ b/tests/ui/doc/needless_doctest_main.stderr
@@ -0,0 +1,36 @@
+error: needless `fn main` in doctest
+  --> tests/ui/doc/needless_doctest_main.rs:23:5
+   |
+LL |   /// fn main() {
+   |  _____^
+LL | |
+LL | | ///     let a = 0;
+LL | | /// }
+   | |_____^
+   |
+   = note: `-D clippy::needless-doctest-main` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::needless_doctest_main)]`
+
+error: needless `fn main` in doctest
+  --> tests/ui/doc/needless_doctest_main.rs:77:5
+   |
+LL |   /// fn main() {
+   |  _____^
+LL | |
+LL | | ///     // Hi!
+LL | | ///     let _ = 0;
+LL | | /// }
+   | |_____^
+
+error: needless `fn main` in doctest
+  --> tests/ui/doc/needless_doctest_main.rs:88:5
+   |
+LL |   /// fn     main (){
+   |  _____^
+LL | |
+LL | | ///     let _ = 0;
+LL | | /// }
+   | |_____^
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/doc_broken_link.rs b/tests/ui/doc_broken_link.rs
new file mode 100644
index 00000000000..7d9c0ef13b3
--- /dev/null
+++ b/tests/ui/doc_broken_link.rs
@@ -0,0 +1,72 @@
+#![warn(clippy::doc_broken_link)]
+
+fn main() {}
+
+pub struct FakeType {}
+
+/// This might be considered a link false positive
+/// and should be ignored by this lint rule:
+/// Example of referencing some code with brackets [FakeType].
+pub fn doc_ignore_link_false_positive_1() {}
+
+/// This might be considered a link false positive
+/// and should be ignored by this lint rule:
+/// [`FakeType`]. Continue text after brackets,
+/// then (something in
+/// parenthesis).
+pub fn doc_ignore_link_false_positive_2() {}
+
+/// Test valid link, whole link single line.
+/// [doc valid link](https://test.fake/doc_valid_link)
+pub fn doc_valid_link() {}
+
+/// Test valid link, whole link single line but it has special chars such as brackets and
+/// parenthesis. [doc invalid link url invalid char](https://test.fake/doc_valid_link_url_invalid_char?foo[bar]=1&bar(foo)=2)
+pub fn doc_valid_link_url_invalid_char() {}
+
+/// Test valid link, text tag broken across multiple lines.
+/// [doc valid link broken
+/// text](https://test.fake/doc_valid_link_broken_text)
+pub fn doc_valid_link_broken_text() {}
+
+/// Test valid link, url tag broken across multiple lines, but
+/// the whole url part in a single line.
+/// [doc valid link broken url tag two lines first](https://test.fake/doc_valid_link_broken_url_tag_two_lines_first
+/// )
+pub fn doc_valid_link_broken_url_tag_two_lines_first() {}
+
+/// Test valid link, url tag broken across multiple lines, but
+/// the whole url part in a single line.
+/// [doc valid link broken url tag two lines second](
+/// https://test.fake/doc_valid_link_broken_url_tag_two_lines_second)
+pub fn doc_valid_link_broken_url_tag_two_lines_second() {}
+
+/// Test valid link, url tag broken across multiple lines, but
+/// the whole url part in a single line, but the closing pharentesis
+/// in a third line.
+/// [doc valid link broken url tag three lines](
+/// https://test.fake/doc_valid_link_broken_url_tag_three_lines
+/// )
+pub fn doc_valid_link_broken_url_tag_three_lines() {}
+
+/// Test invalid link, url part broken across multiple lines.
+/// [doc invalid link broken url scheme part](https://
+/// test.fake/doc_invalid_link_broken_url_scheme_part)
+//~^^ ERROR: possible broken doc link: broken across multiple lines
+pub fn doc_invalid_link_broken_url_scheme_part() {}
+
+/// Test invalid link, url part broken across multiple lines.
+/// [doc invalid link broken url host part](https://test
+/// .fake/doc_invalid_link_broken_url_host_part)
+//~^^ ERROR: possible broken doc link: broken across multiple lines
+pub fn doc_invalid_link_broken_url_host_part() {}
+
+/// Test invalid link, for multiple urls in the same block of comment.
+/// There is a [fist link - invalid](https://test
+/// .fake) then it continues
+//~^^ ERROR: possible broken doc link: broken across multiple lines
+/// with a [second link - valid](https://test.fake/doc_valid_link) and another [third link - invalid](https://test
+/// .fake). It ends with another
+//~^^ ERROR: possible broken doc link: broken across multiple lines
+/// line of comment.
+pub fn doc_multiple_invalid_link_broken_url() {}
diff --git a/tests/ui/doc_broken_link.stderr b/tests/ui/doc_broken_link.stderr
new file mode 100644
index 00000000000..179ed97635e
--- /dev/null
+++ b/tests/ui/doc_broken_link.stderr
@@ -0,0 +1,29 @@
+error: possible broken doc link: broken across multiple lines
+  --> tests/ui/doc_broken_link.rs:53:5
+   |
+LL | /// [doc invalid link broken url scheme part](https://
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::doc-broken-link` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::doc_broken_link)]`
+
+error: possible broken doc link: broken across multiple lines
+  --> tests/ui/doc_broken_link.rs:59:5
+   |
+LL | /// [doc invalid link broken url host part](https://test
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: possible broken doc link: broken across multiple lines
+  --> tests/ui/doc_broken_link.rs:65:16
+   |
+LL | /// There is a [fist link - invalid](https://test
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: possible broken doc link: broken across multiple lines
+  --> tests/ui/doc_broken_link.rs:68:80
+   |
+LL | /// with a [second link - valid](https://test.fake/doc_valid_link) and another [third link - invalid](https://test
+   |                                                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/empty_line_after/outer_attribute.1.fixed b/tests/ui/empty_line_after/outer_attribute.1.fixed
index 36d80a2c95b..e36e3c2aea6 100644
--- a/tests/ui/empty_line_after/outer_attribute.1.fixed
+++ b/tests/ui/empty_line_after/outer_attribute.1.fixed
@@ -105,4 +105,13 @@ second line
 ")]
 pub struct Args;
 
+mod issue_14980 {
+    //~v empty_line_after_outer_attr
+    #[repr(align(536870912))]
+    enum Aligned {
+        Zero = 0,
+        One = 1,
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/empty_line_after/outer_attribute.2.fixed b/tests/ui/empty_line_after/outer_attribute.2.fixed
index 0e8e4129e85..b0908fc7214 100644
--- a/tests/ui/empty_line_after/outer_attribute.2.fixed
+++ b/tests/ui/empty_line_after/outer_attribute.2.fixed
@@ -108,4 +108,13 @@ second line
 ")]
 pub struct Args;
 
+mod issue_14980 {
+    //~v empty_line_after_outer_attr
+    #[repr(align(536870912))]
+    enum Aligned {
+        Zero = 0,
+        One = 1,
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/empty_line_after/outer_attribute.rs b/tests/ui/empty_line_after/outer_attribute.rs
index 1295088ac00..4ae113c68f5 100644
--- a/tests/ui/empty_line_after/outer_attribute.rs
+++ b/tests/ui/empty_line_after/outer_attribute.rs
@@ -116,4 +116,14 @@ second line
 ")]
 pub struct Args;
 
+mod issue_14980 {
+    //~v empty_line_after_outer_attr
+    #[repr(align(536870912))]
+
+    enum Aligned {
+        Zero = 0,
+        One = 1,
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/empty_line_after/outer_attribute.stderr b/tests/ui/empty_line_after/outer_attribute.stderr
index 519ba6e6761..331bc7c8856 100644
--- a/tests/ui/empty_line_after/outer_attribute.stderr
+++ b/tests/ui/empty_line_after/outer_attribute.stderr
@@ -111,5 +111,16 @@ LL |   pub fn isolated_comment() {}
    |
    = help: if the empty lines are unintentional, remove them
 
-error: aborting due to 9 previous errors
+error: empty line after outer attribute
+  --> tests/ui/empty_line_after/outer_attribute.rs:121:5
+   |
+LL | /     #[repr(align(536870912))]
+LL | |
+   | |_^
+LL |       enum Aligned {
+   |       ------------ the attribute applies to this enum
+   |
+   = help: if the empty line is unintentional, remove it
+
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 0ba631fda05..c93b83f53ec 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -543,3 +543,21 @@ mod issue_13073 {
         //~^ redundant_closure
     }
 }
+
+fn issue_14789() {
+    _ = Some(1u8).map(
+        #[expect(clippy::redundant_closure)]
+        |a| foo(a),
+    );
+
+    _ = Some("foo").map(
+        #[expect(clippy::redundant_closure_for_method_calls)]
+        |s| s.to_owned(),
+    );
+
+    let _: Vec<u8> = None.map_or_else(
+        #[expect(clippy::redundant_closure)]
+        || vec![],
+        std::convert::identity,
+    );
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 4d8b29d450c..273c8b21f4a 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -543,3 +543,21 @@ mod issue_13073 {
         //~^ redundant_closure
     }
 }
+
+fn issue_14789() {
+    _ = Some(1u8).map(
+        #[expect(clippy::redundant_closure)]
+        |a| foo(a),
+    );
+
+    _ = Some("foo").map(
+        #[expect(clippy::redundant_closure_for_method_calls)]
+        |s| s.to_owned(),
+    );
+
+    let _: Vec<u8> = None.map_or_else(
+        #[expect(clippy::redundant_closure)]
+        || vec![],
+        std::convert::identity,
+    );
+}
diff --git a/tests/ui/exhaustive_items.fixed b/tests/ui/exhaustive_items.fixed
index 79c74aeefbd..3b2f33dbd2c 100644
--- a/tests/ui/exhaustive_items.fixed
+++ b/tests/ui/exhaustive_items.fixed
@@ -1,3 +1,4 @@
+#![feature(default_field_values)]
 #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
 #![allow(unused)]
 
@@ -90,3 +91,9 @@ pub mod structs {
         pub bar: String,
     }
 }
+
+pub mod issue14992 {
+    pub struct A {
+        pub a: isize = 42,
+    }
+}
diff --git a/tests/ui/exhaustive_items.rs b/tests/ui/exhaustive_items.rs
index 4e851f4c492..b0a6a717076 100644
--- a/tests/ui/exhaustive_items.rs
+++ b/tests/ui/exhaustive_items.rs
@@ -1,3 +1,4 @@
+#![feature(default_field_values)]
 #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
 #![allow(unused)]
 
@@ -87,3 +88,9 @@ pub mod structs {
         pub bar: String,
     }
 }
+
+pub mod issue14992 {
+    pub struct A {
+        pub a: isize = 42,
+    }
+}
diff --git a/tests/ui/exhaustive_items.stderr b/tests/ui/exhaustive_items.stderr
index c92c8a9efaa..55928fa458d 100644
--- a/tests/ui/exhaustive_items.stderr
+++ b/tests/ui/exhaustive_items.stderr
@@ -1,5 +1,5 @@
 error: exported enums should not be exhaustive
-  --> tests/ui/exhaustive_items.rs:9:5
+  --> tests/ui/exhaustive_items.rs:10:5
    |
 LL | /     pub enum Exhaustive {
 LL | |
@@ -11,7 +11,7 @@ LL | |     }
    | |_____^
    |
 note: the lint level is defined here
-  --> tests/ui/exhaustive_items.rs:1:9
+  --> tests/ui/exhaustive_items.rs:2:9
    |
 LL | #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL ~     pub enum Exhaustive {
    |
 
 error: exported enums should not be exhaustive
-  --> tests/ui/exhaustive_items.rs:19:5
+  --> tests/ui/exhaustive_items.rs:20:5
    |
 LL | /     pub enum ExhaustiveWithAttrs {
 LL | |
@@ -40,7 +40,7 @@ LL ~     pub enum ExhaustiveWithAttrs {
    |
 
 error: exported structs should not be exhaustive
-  --> tests/ui/exhaustive_items.rs:55:5
+  --> tests/ui/exhaustive_items.rs:56:5
    |
 LL | /     pub struct Exhaustive {
 LL | |
@@ -50,7 +50,7 @@ LL | |     }
    | |_____^
    |
 note: the lint level is defined here
-  --> tests/ui/exhaustive_items.rs:1:35
+  --> tests/ui/exhaustive_items.rs:2:35
    |
 LL | #![deny(clippy::exhaustive_enums, clippy::exhaustive_structs)]
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/identity_op.fixed b/tests/ui/identity_op.fixed
index a1b55602998..4e14e1a5e33 100644
--- a/tests/ui/identity_op.fixed
+++ b/tests/ui/identity_op.fixed
@@ -312,3 +312,49 @@ fn issue_13470() {
     let _: u64 = 1u64 + ((x as i32 + y as i32) as u64);
     //~^ identity_op
 }
+
+fn issue_14932() {
+    let _ = 0usize + &Default::default(); // no error
+
+    0usize + &Default::default(); // no error
+
+    <usize as Default>::default();
+    //~^ identity_op
+
+    let _ = usize::default();
+    //~^ identity_op
+
+    let _n: usize = Default::default();
+    //~^ identity_op
+}
+
+// Expr's type can be inferred by the function's return type
+fn issue_14932_2() -> usize {
+    Default::default()
+    //~^ identity_op
+}
+
+trait Def {
+    fn def() -> Self;
+}
+
+impl Def for usize {
+    fn def() -> Self {
+        0
+    }
+}
+
+fn issue_14932_3() {
+    let _ = 0usize + &Def::def(); // no error
+
+    0usize + &Def::def(); // no error
+
+    <usize as Def>::def();
+    //~^ identity_op
+
+    let _ = usize::def();
+    //~^ identity_op
+
+    let _n: usize = Def::def();
+    //~^ identity_op
+}
diff --git a/tests/ui/identity_op.rs b/tests/ui/identity_op.rs
index f603e1078e4..ebbef5723ff 100644
--- a/tests/ui/identity_op.rs
+++ b/tests/ui/identity_op.rs
@@ -312,3 +312,49 @@ fn issue_13470() {
     let _: u64 = 1u64 + ((x as i32 + y as i32) as u64 + 0u64);
     //~^ identity_op
 }
+
+fn issue_14932() {
+    let _ = 0usize + &Default::default(); // no error
+
+    0usize + &Default::default(); // no error
+
+    0usize + &<usize as Default>::default();
+    //~^ identity_op
+
+    let _ = 0usize + &usize::default();
+    //~^ identity_op
+
+    let _n: usize = 0usize + &Default::default();
+    //~^ identity_op
+}
+
+// Expr's type can be inferred by the function's return type
+fn issue_14932_2() -> usize {
+    0usize + &Default::default()
+    //~^ identity_op
+}
+
+trait Def {
+    fn def() -> Self;
+}
+
+impl Def for usize {
+    fn def() -> Self {
+        0
+    }
+}
+
+fn issue_14932_3() {
+    let _ = 0usize + &Def::def(); // no error
+
+    0usize + &Def::def(); // no error
+
+    0usize + &<usize as Def>::def();
+    //~^ identity_op
+
+    let _ = 0usize + &usize::def();
+    //~^ identity_op
+
+    let _n: usize = 0usize + &Def::def();
+    //~^ identity_op
+}
diff --git a/tests/ui/identity_op.stderr b/tests/ui/identity_op.stderr
index 8f9c2b603c4..24fa5db08ce 100644
--- a/tests/ui/identity_op.stderr
+++ b/tests/ui/identity_op.stderr
@@ -379,5 +379,47 @@ error: this operation has no effect
 LL |     let _: u64 = 1u64 + ((x as i32 + y as i32) as u64 + 0u64);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `((x as i32 + y as i32) as u64)`
 
-error: aborting due to 63 previous errors
+error: this operation has no effect
+  --> tests/ui/identity_op.rs:321:5
+   |
+LL |     0usize + &<usize as Default>::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `<usize as Default>::default()`
+
+error: this operation has no effect
+  --> tests/ui/identity_op.rs:324:13
+   |
+LL |     let _ = 0usize + &usize::default();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `usize::default()`
+
+error: this operation has no effect
+  --> tests/ui/identity_op.rs:327:21
+   |
+LL |     let _n: usize = 0usize + &Default::default();
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `Default::default()`
+
+error: this operation has no effect
+  --> tests/ui/identity_op.rs:333:5
+   |
+LL |     0usize + &Default::default()
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `Default::default()`
+
+error: this operation has no effect
+  --> tests/ui/identity_op.rs:352:5
+   |
+LL |     0usize + &<usize as Def>::def();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `<usize as Def>::def()`
+
+error: this operation has no effect
+  --> tests/ui/identity_op.rs:355:13
+   |
+LL |     let _ = 0usize + &usize::def();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `usize::def()`
+
+error: this operation has no effect
+  --> tests/ui/identity_op.rs:358:21
+   |
+LL |     let _n: usize = 0usize + &Def::def();
+   |                     ^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `Def::def()`
+
+error: aborting due to 70 previous errors
 
diff --git a/tests/ui/infinite_iter.rs b/tests/ui/infinite_iter.rs
index 002a791a657..701a86534ba 100644
--- a/tests/ui/infinite_iter.rs
+++ b/tests/ui/infinite_iter.rs
@@ -38,7 +38,7 @@ fn infinite_iters() {
     //~^ infinite_iter
 
     // infinite iter
-    (0_u64..).filter(|x| x % 2 == 0).last();
+    (0_u64..).filter(|x| x.is_multiple_of(2)).last();
     //~^ infinite_iter
 
     // not an infinite, because ranges are double-ended
diff --git a/tests/ui/infinite_iter.stderr b/tests/ui/infinite_iter.stderr
index 47133a2ea62..b9e7c008f93 100644
--- a/tests/ui/infinite_iter.stderr
+++ b/tests/ui/infinite_iter.stderr
@@ -42,8 +42,8 @@ LL |     (0_usize..).flat_map(|x| 0..x).product::<usize>();
 error: infinite iteration detected
   --> tests/ui/infinite_iter.rs:41:5
    |
-LL |     (0_u64..).filter(|x| x % 2 == 0).last();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     (0_u64..).filter(|x| x.is_multiple_of(2)).last();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: possible infinite iteration detected
   --> tests/ui/infinite_iter.rs:53:5
diff --git a/tests/ui/iter_kv_map.fixed b/tests/ui/iter_kv_map.fixed
index 874f749b33d..b18dda35887 100644
--- a/tests/ui/iter_kv_map.fixed
+++ b/tests/ui/iter_kv_map.fixed
@@ -30,15 +30,19 @@ fn main() {
 
     let _ = map.clone().values().collect::<Vec<_>>();
     //~^ iter_kv_map
-    let _ = map.keys().filter(|x| *x % 2 == 0).count();
+    let _ = map.keys().filter(|x| x.is_multiple_of(2)).count();
     //~^ iter_kv_map
 
     // Don't lint
-    let _ = map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
+    let _ = map
+        .iter()
+        .filter(|(_, val)| val.is_multiple_of(2))
+        .map(|(key, _)| key)
+        .count();
     let _ = map.iter().map(get_key).collect::<Vec<_>>();
 
     // Linting the following could be an improvement to the lint
-    // map.iter().filter_map(|(_, val)| (val % 2 == 0).then(val * 17)).count();
+    // map.iter().filter_map(|(_, val)| (val.is_multiple_of(2)).then(val * 17)).count();
 
     // Lint
     let _ = map.keys().map(|key| key * 9).count();
@@ -84,15 +88,19 @@ fn main() {
 
     let _ = map.clone().values().collect::<Vec<_>>();
     //~^ iter_kv_map
-    let _ = map.keys().filter(|x| *x % 2 == 0).count();
+    let _ = map.keys().filter(|x| x.is_multiple_of(2)).count();
     //~^ iter_kv_map
 
     // Don't lint
-    let _ = map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
+    let _ = map
+        .iter()
+        .filter(|(_, val)| val.is_multiple_of(2))
+        .map(|(key, _)| key)
+        .count();
     let _ = map.iter().map(get_key).collect::<Vec<_>>();
 
     // Linting the following could be an improvement to the lint
-    // map.iter().filter_map(|(_, val)| (val % 2 == 0).then(val * 17)).count();
+    // map.iter().filter_map(|(_, val)| (val.is_multiple_of(2)).then(val * 17)).count();
 
     // Lint
     let _ = map.keys().map(|key| key * 9).count();
diff --git a/tests/ui/iter_kv_map.rs b/tests/ui/iter_kv_map.rs
index f570e3c32cb..729e4e8a266 100644
--- a/tests/ui/iter_kv_map.rs
+++ b/tests/ui/iter_kv_map.rs
@@ -30,15 +30,19 @@ fn main() {
 
     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
     //~^ iter_kv_map
-    let _ = map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
+    let _ = map.iter().map(|(key, _)| key).filter(|x| x.is_multiple_of(2)).count();
     //~^ iter_kv_map
 
     // Don't lint
-    let _ = map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
+    let _ = map
+        .iter()
+        .filter(|(_, val)| val.is_multiple_of(2))
+        .map(|(key, _)| key)
+        .count();
     let _ = map.iter().map(get_key).collect::<Vec<_>>();
 
     // Linting the following could be an improvement to the lint
-    // map.iter().filter_map(|(_, val)| (val % 2 == 0).then(val * 17)).count();
+    // map.iter().filter_map(|(_, val)| (val.is_multiple_of(2)).then(val * 17)).count();
 
     // Lint
     let _ = map.iter().map(|(key, _value)| key * 9).count();
@@ -86,15 +90,19 @@ fn main() {
 
     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
     //~^ iter_kv_map
-    let _ = map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
+    let _ = map.iter().map(|(key, _)| key).filter(|x| x.is_multiple_of(2)).count();
     //~^ iter_kv_map
 
     // Don't lint
-    let _ = map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
+    let _ = map
+        .iter()
+        .filter(|(_, val)| val.is_multiple_of(2))
+        .map(|(key, _)| key)
+        .count();
     let _ = map.iter().map(get_key).collect::<Vec<_>>();
 
     // Linting the following could be an improvement to the lint
-    // map.iter().filter_map(|(_, val)| (val % 2 == 0).then(val * 17)).count();
+    // map.iter().filter_map(|(_, val)| (val.is_multiple_of(2)).then(val * 17)).count();
 
     // Lint
     let _ = map.iter().map(|(key, _value)| key * 9).count();
diff --git a/tests/ui/iter_kv_map.stderr b/tests/ui/iter_kv_map.stderr
index 31ee76c25b7..8f73541f503 100644
--- a/tests/ui/iter_kv_map.stderr
+++ b/tests/ui/iter_kv_map.stderr
@@ -52,29 +52,29 @@ LL |     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
 error: iterating on a map's keys
   --> tests/ui/iter_kv_map.rs:33:13
    |
-LL |     let _ = map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
+LL |     let _ = map.iter().map(|(key, _)| key).filter(|x| x.is_multiple_of(2)).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:44:13
+  --> tests/ui/iter_kv_map.rs:48:13
    |
 LL |     let _ = map.iter().map(|(key, _value)| key * 9).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys().map(|key| key * 9)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:46:13
+  --> tests/ui/iter_kv_map.rs:50:13
    |
 LL |     let _ = map.iter().map(|(_key, value)| value * 17).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|value| value * 17)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:50:13
+  --> tests/ui/iter_kv_map.rs:54:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, ref val)| ref_acceptor(val)).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|ref val| ref_acceptor(val))`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:54:13
+  --> tests/ui/iter_kv_map.rs:58:13
    |
 LL |       let _ = map
    |  _____________^
@@ -97,85 +97,85 @@ LL +         })
    |
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:65:13
+  --> tests/ui/iter_kv_map.rs:69:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:70:13
+  --> tests/ui/iter_kv_map.rs:74:13
    |
 LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:72:13
+  --> tests/ui/iter_kv_map.rs:76:13
    |
 LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:74:13
+  --> tests/ui/iter_kv_map.rs:78:13
    |
 LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:77:13
+  --> tests/ui/iter_kv_map.rs:81:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:79:13
+  --> tests/ui/iter_kv_map.rs:83:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys().map(|key| key + 2)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:82:13
+  --> tests/ui/iter_kv_map.rs:86:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:84:13
+  --> tests/ui/iter_kv_map.rs:88:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|val| val + 2)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:87:13
+  --> tests/ui/iter_kv_map.rs:91:13
    |
 LL |     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().values()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:89:13
+  --> tests/ui/iter_kv_map.rs:93:13
    |
-LL |     let _ = map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
+LL |     let _ = map.iter().map(|(key, _)| key).filter(|x| x.is_multiple_of(2)).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:100:13
+  --> tests/ui/iter_kv_map.rs:108:13
    |
 LL |     let _ = map.iter().map(|(key, _value)| key * 9).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys().map(|key| key * 9)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:102:13
+  --> tests/ui/iter_kv_map.rs:110:13
    |
 LL |     let _ = map.iter().map(|(_key, value)| value * 17).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|value| value * 17)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:106:13
+  --> tests/ui/iter_kv_map.rs:114:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, ref val)| ref_acceptor(val)).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|ref val| ref_acceptor(val))`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:110:13
+  --> tests/ui/iter_kv_map.rs:118:13
    |
 LL |       let _ = map
    |  _____________^
@@ -198,73 +198,73 @@ LL +         })
    |
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:121:13
+  --> tests/ui/iter_kv_map.rs:129:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:137:13
+  --> tests/ui/iter_kv_map.rs:145:13
    |
 LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:140:13
+  --> tests/ui/iter_kv_map.rs:148:13
    |
 LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:143:13
+  --> tests/ui/iter_kv_map.rs:151:13
    |
 LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:152:13
+  --> tests/ui/iter_kv_map.rs:160:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:155:13
+  --> tests/ui/iter_kv_map.rs:163:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys().map(|key| key + 2)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:158:13
+  --> tests/ui/iter_kv_map.rs:166:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:161:13
+  --> tests/ui/iter_kv_map.rs:169:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|val| val + 2)`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:164:13
+  --> tests/ui/iter_kv_map.rs:172:13
    |
 LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:167:13
+  --> tests/ui/iter_kv_map.rs:175:13
    |
 LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:170:13
+  --> tests/ui/iter_kv_map.rs:178:13
    |
 LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:185:13
+  --> tests/ui/iter_kv_map.rs:193:13
    |
 LL |     let _ = map.as_ref().iter().map(|(_, v)| v).copied().collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.as_ref().values()`
diff --git a/tests/ui/let_unit.fixed b/tests/ui/let_unit.fixed
index 5e7a2ad37a8..304eacecd94 100644
--- a/tests/ui/let_unit.fixed
+++ b/tests/ui/let_unit.fixed
@@ -61,7 +61,7 @@ fn multiline_sugg() {
         //~^ let_unit_value
         .into_iter()
         .map(|i| i * 2)
-        .filter(|i| i % 2 == 0)
+        .filter(|i| i.is_multiple_of(2))
         .map(|_| ())
         .next()
         .unwrap();
diff --git a/tests/ui/let_unit.rs b/tests/ui/let_unit.rs
index 7b06f694012..a02cb346ff9 100644
--- a/tests/ui/let_unit.rs
+++ b/tests/ui/let_unit.rs
@@ -61,7 +61,7 @@ fn multiline_sugg() {
         //~^ let_unit_value
         .into_iter()
         .map(|i| i * 2)
-        .filter(|i| i % 2 == 0)
+        .filter(|i| i.is_multiple_of(2))
         .map(|_| ())
         .next()
         .unwrap();
diff --git a/tests/ui/let_unit.stderr b/tests/ui/let_unit.stderr
index d7d01d304ca..d743110c99d 100644
--- a/tests/ui/let_unit.stderr
+++ b/tests/ui/let_unit.stderr
@@ -25,7 +25,7 @@ LL ~     v
 LL +
 LL +         .into_iter()
 LL +         .map(|i| i * 2)
-LL +         .filter(|i| i % 2 == 0)
+LL +         .filter(|i| i.is_multiple_of(2))
 LL +         .map(|_| ())
 LL +         .next()
 LL +         .unwrap();
diff --git a/tests/ui/manual_contains.fixed b/tests/ui/manual_contains.fixed
index d26c948a781..18171f0b2b4 100644
--- a/tests/ui/manual_contains.fixed
+++ b/tests/ui/manual_contains.fixed
@@ -58,7 +58,7 @@ fn should_not_lint() {
 
     let vec: Vec<u32> = vec![1, 2, 3, 4, 5, 6];
     let values = &vec[..];
-    let _ = values.iter().any(|&v| v % 2 == 0);
+    let _ = values.iter().any(|&v| v.is_multiple_of(2));
     let _ = values.iter().any(|&v| v * 2 == 6);
     let _ = values.iter().any(|&v| v == v);
     let _ = values.iter().any(|&v| 4 == 4);
diff --git a/tests/ui/manual_contains.rs b/tests/ui/manual_contains.rs
index fe67d2ee5d5..918f4d6b8dd 100644
--- a/tests/ui/manual_contains.rs
+++ b/tests/ui/manual_contains.rs
@@ -58,7 +58,7 @@ fn should_not_lint() {
 
     let vec: Vec<u32> = vec![1, 2, 3, 4, 5, 6];
     let values = &vec[..];
-    let _ = values.iter().any(|&v| v % 2 == 0);
+    let _ = values.iter().any(|&v| v.is_multiple_of(2));
     let _ = values.iter().any(|&v| v * 2 == 6);
     let _ = values.iter().any(|&v| v == v);
     let _ = values.iter().any(|&v| 4 == 4);
diff --git a/tests/ui/manual_find_fixable.fixed b/tests/ui/manual_find_fixable.fixed
index 01b3ebacbeb..c69b0cb11e3 100644
--- a/tests/ui/manual_find_fixable.fixed
+++ b/tests/ui/manual_find_fixable.fixed
@@ -11,7 +11,7 @@ fn lookup(n: u32) -> Option<u32> {
 }
 
 fn with_pat(arr: Vec<(u32, u32)>) -> Option<u32> {
-    arr.into_iter().map(|(a, _)| a).find(|&a| a % 2 == 0)
+    arr.into_iter().map(|(a, _)| a).find(|&a| a.is_multiple_of(2))
 }
 
 struct Data {
@@ -63,7 +63,7 @@ fn with_side_effects(arr: Vec<u32>) -> Option<u32> {
 
 fn with_else(arr: Vec<u32>) -> Option<u32> {
     for el in arr {
-        if el % 2 == 0 {
+        if el.is_multiple_of(2) {
             return Some(el);
         } else {
             println!("{}", el);
diff --git a/tests/ui/manual_find_fixable.rs b/tests/ui/manual_find_fixable.rs
index ce62a4beba1..db7092f020c 100644
--- a/tests/ui/manual_find_fixable.rs
+++ b/tests/ui/manual_find_fixable.rs
@@ -19,7 +19,7 @@ fn lookup(n: u32) -> Option<u32> {
 fn with_pat(arr: Vec<(u32, u32)>) -> Option<u32> {
     for (a, _) in arr {
         //~^ manual_find
-        if a % 2 == 0 {
+        if a.is_multiple_of(2) {
             return Some(a);
         }
     }
@@ -111,7 +111,7 @@ fn with_side_effects(arr: Vec<u32>) -> Option<u32> {
 
 fn with_else(arr: Vec<u32>) -> Option<u32> {
     for el in arr {
-        if el % 2 == 0 {
+        if el.is_multiple_of(2) {
             return Some(el);
         } else {
             println!("{}", el);
diff --git a/tests/ui/manual_find_fixable.stderr b/tests/ui/manual_find_fixable.stderr
index 020635d90bb..0c05c0d2c44 100644
--- a/tests/ui/manual_find_fixable.stderr
+++ b/tests/ui/manual_find_fixable.stderr
@@ -17,11 +17,11 @@ error: manual implementation of `Iterator::find`
    |
 LL | /     for (a, _) in arr {
 LL | |
-LL | |         if a % 2 == 0 {
+LL | |         if a.is_multiple_of(2) {
 LL | |             return Some(a);
 ...  |
 LL | |     None
-   | |________^ help: replace with an iterator: `arr.into_iter().map(|(a, _)| a).find(|&a| a % 2 == 0)`
+   | |________^ help: replace with an iterator: `arr.into_iter().map(|(a, _)| a).find(|&a| a.is_multiple_of(2))`
 
 error: manual implementation of `Iterator::find`
   --> tests/ui/manual_find_fixable.rs:34:5
diff --git a/tests/ui/manual_is_multiple_of.fixed b/tests/ui/manual_is_multiple_of.fixed
new file mode 100644
index 00000000000..6735b99f298
--- /dev/null
+++ b/tests/ui/manual_is_multiple_of.fixed
@@ -0,0 +1,25 @@
+//@aux-build: proc_macros.rs
+#![warn(clippy::manual_is_multiple_of)]
+
+fn main() {}
+
+#[clippy::msrv = "1.87"]
+fn f(a: u64, b: u64) {
+    let _ = a.is_multiple_of(b); //~ manual_is_multiple_of
+    let _ = (a + 1).is_multiple_of(b + 1); //~ manual_is_multiple_of
+    let _ = !a.is_multiple_of(b); //~ manual_is_multiple_of
+    let _ = !(a + 1).is_multiple_of(b + 1); //~ manual_is_multiple_of
+
+    let _ = !a.is_multiple_of(b); //~ manual_is_multiple_of
+    let _ = !a.is_multiple_of(b); //~ manual_is_multiple_of
+
+    proc_macros::external! {
+        let a: u64 = 23424;
+        let _ = a % 4096 == 0;
+    }
+}
+
+#[clippy::msrv = "1.86"]
+fn g(a: u64, b: u64) {
+    let _ = a % b == 0;
+}
diff --git a/tests/ui/manual_is_multiple_of.rs b/tests/ui/manual_is_multiple_of.rs
new file mode 100644
index 00000000000..00b638e4fd9
--- /dev/null
+++ b/tests/ui/manual_is_multiple_of.rs
@@ -0,0 +1,25 @@
+//@aux-build: proc_macros.rs
+#![warn(clippy::manual_is_multiple_of)]
+
+fn main() {}
+
+#[clippy::msrv = "1.87"]
+fn f(a: u64, b: u64) {
+    let _ = a % b == 0; //~ manual_is_multiple_of
+    let _ = (a + 1) % (b + 1) == 0; //~ manual_is_multiple_of
+    let _ = a % b != 0; //~ manual_is_multiple_of
+    let _ = (a + 1) % (b + 1) != 0; //~ manual_is_multiple_of
+
+    let _ = a % b > 0; //~ manual_is_multiple_of
+    let _ = 0 < a % b; //~ manual_is_multiple_of
+
+    proc_macros::external! {
+        let a: u64 = 23424;
+        let _ = a % 4096 == 0;
+    }
+}
+
+#[clippy::msrv = "1.86"]
+fn g(a: u64, b: u64) {
+    let _ = a % b == 0;
+}
diff --git a/tests/ui/manual_is_multiple_of.stderr b/tests/ui/manual_is_multiple_of.stderr
new file mode 100644
index 00000000000..0b1ae70c2a7
--- /dev/null
+++ b/tests/ui/manual_is_multiple_of.stderr
@@ -0,0 +1,41 @@
+error: manual implementation of `.is_multiple_of()`
+  --> tests/ui/manual_is_multiple_of.rs:8:13
+   |
+LL |     let _ = a % b == 0;
+   |             ^^^^^^^^^^ help: replace with: `a.is_multiple_of(b)`
+   |
+   = note: `-D clippy::manual-is-multiple-of` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::manual_is_multiple_of)]`
+
+error: manual implementation of `.is_multiple_of()`
+  --> tests/ui/manual_is_multiple_of.rs:9:13
+   |
+LL |     let _ = (a + 1) % (b + 1) == 0;
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `(a + 1).is_multiple_of(b + 1)`
+
+error: manual implementation of `.is_multiple_of()`
+  --> tests/ui/manual_is_multiple_of.rs:10:13
+   |
+LL |     let _ = a % b != 0;
+   |             ^^^^^^^^^^ help: replace with: `!a.is_multiple_of(b)`
+
+error: manual implementation of `.is_multiple_of()`
+  --> tests/ui/manual_is_multiple_of.rs:11:13
+   |
+LL |     let _ = (a + 1) % (b + 1) != 0;
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `!(a + 1).is_multiple_of(b + 1)`
+
+error: manual implementation of `.is_multiple_of()`
+  --> tests/ui/manual_is_multiple_of.rs:13:13
+   |
+LL |     let _ = a % b > 0;
+   |             ^^^^^^^^^ help: replace with: `!a.is_multiple_of(b)`
+
+error: manual implementation of `.is_multiple_of()`
+  --> tests/ui/manual_is_multiple_of.rs:14:13
+   |
+LL |     let _ = 0 < a % b;
+   |             ^^^^^^^^^ help: replace with: `!a.is_multiple_of(b)`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/manual_is_variant_and.fixed b/tests/ui/manual_is_variant_and.fixed
index 18a72188ab5..6425f32c09c 100644
--- a/tests/ui/manual_is_variant_and.fixed
+++ b/tests/ui/manual_is_variant_and.fixed
@@ -77,7 +77,7 @@ fn option_methods() {
     let _ = opt_map!(opt2, |x| x == 'a').unwrap_or_default(); // should not lint
 
     // Should not lint.
-    let _ = Foo::<u32>(0).map(|x| x % 2 == 0) == Some(true);
+    let _ = Foo::<u32>(0).map(|x| x.is_multiple_of(2)) == Some(true);
     let _ = Some(2).map(|x| x % 2 == 0) != foo();
     let _ = mac!(eq Some(2).map(|x| x % 2 == 0), Some(true));
     let _ = mac!(some 2).map(|x| x % 2 == 0) == Some(true);
@@ -96,11 +96,11 @@ fn result_methods() {
     });
     let _ = res.is_ok_and(|x| x > 1);
 
-    let _ = Ok::<usize, ()>(2).is_ok_and(|x| x % 2 == 0);
+    let _ = Ok::<usize, ()>(2).is_ok_and(|x| x.is_multiple_of(2));
     //~^ manual_is_variant_and
-    let _ = !Ok::<usize, ()>(2).is_ok_and(|x| x % 2 == 0);
+    let _ = !Ok::<usize, ()>(2).is_ok_and(|x| x.is_multiple_of(2));
     //~^ manual_is_variant_and
-    let _ = !Ok::<usize, ()>(2).is_ok_and(|x| x % 2 == 0);
+    let _ = !Ok::<usize, ()>(2).is_ok_and(|x| x.is_multiple_of(2));
     //~^ manual_is_variant_and
 
     // won't fix because the return type of the closure is not `bool`
diff --git a/tests/ui/manual_is_variant_and.rs b/tests/ui/manual_is_variant_and.rs
index a92f7c04369..e069e97a04d 100644
--- a/tests/ui/manual_is_variant_and.rs
+++ b/tests/ui/manual_is_variant_and.rs
@@ -83,7 +83,7 @@ fn option_methods() {
     let _ = opt_map!(opt2, |x| x == 'a').unwrap_or_default(); // should not lint
 
     // Should not lint.
-    let _ = Foo::<u32>(0).map(|x| x % 2 == 0) == Some(true);
+    let _ = Foo::<u32>(0).map(|x| x.is_multiple_of(2)) == Some(true);
     let _ = Some(2).map(|x| x % 2 == 0) != foo();
     let _ = mac!(eq Some(2).map(|x| x % 2 == 0), Some(true));
     let _ = mac!(some 2).map(|x| x % 2 == 0) == Some(true);
@@ -105,11 +105,11 @@ fn result_methods() {
     //~^ manual_is_variant_and
         .unwrap_or_default();
 
-    let _ = Ok::<usize, ()>(2).map(|x| x % 2 == 0) == Ok(true);
+    let _ = Ok::<usize, ()>(2).map(|x| x.is_multiple_of(2)) == Ok(true);
     //~^ manual_is_variant_and
-    let _ = Ok::<usize, ()>(2).map(|x| x % 2 == 0) != Ok(true);
+    let _ = Ok::<usize, ()>(2).map(|x| x.is_multiple_of(2)) != Ok(true);
     //~^ manual_is_variant_and
-    let _ = Ok::<usize, ()>(2).map(|x| x % 2 == 0) != Ok(true);
+    let _ = Ok::<usize, ()>(2).map(|x| x.is_multiple_of(2)) != Ok(true);
     //~^ manual_is_variant_and
 
     // won't fix because the return type of the closure is not `bool`
diff --git a/tests/ui/manual_is_variant_and.stderr b/tests/ui/manual_is_variant_and.stderr
index 1fb437a8bc7..f770319a268 100644
--- a/tests/ui/manual_is_variant_and.stderr
+++ b/tests/ui/manual_is_variant_and.stderr
@@ -105,20 +105,20 @@ LL | |         .unwrap_or_default();
 error: called `.map() == Ok()`
   --> tests/ui/manual_is_variant_and.rs:108:13
    |
-LL |     let _ = Ok::<usize, ()>(2).map(|x| x % 2 == 0) == Ok(true);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `Ok::<usize, ()>(2).is_ok_and(|x| x % 2 == 0)`
+LL |     let _ = Ok::<usize, ()>(2).map(|x| x.is_multiple_of(2)) == Ok(true);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `Ok::<usize, ()>(2).is_ok_and(|x| x.is_multiple_of(2))`
 
 error: called `.map() != Ok()`
   --> tests/ui/manual_is_variant_and.rs:110:13
    |
-LL |     let _ = Ok::<usize, ()>(2).map(|x| x % 2 == 0) != Ok(true);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `!Ok::<usize, ()>(2).is_ok_and(|x| x % 2 == 0)`
+LL |     let _ = Ok::<usize, ()>(2).map(|x| x.is_multiple_of(2)) != Ok(true);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `!Ok::<usize, ()>(2).is_ok_and(|x| x.is_multiple_of(2))`
 
 error: called `.map() != Ok()`
   --> tests/ui/manual_is_variant_and.rs:112:13
    |
-LL |     let _ = Ok::<usize, ()>(2).map(|x| x % 2 == 0) != Ok(true);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `!Ok::<usize, ()>(2).is_ok_and(|x| x % 2 == 0)`
+LL |     let _ = Ok::<usize, ()>(2).map(|x| x.is_multiple_of(2)) != Ok(true);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `!Ok::<usize, ()>(2).is_ok_and(|x| x.is_multiple_of(2))`
 
 error: called `map(<f>).unwrap_or_default()` on a `Result` value
   --> tests/ui/manual_is_variant_and.rs:119:18
diff --git a/tests/ui/manual_ok_err.fixed b/tests/ui/manual_ok_err.fixed
index e6f799aa58d..9b70ce0df43 100644
--- a/tests/ui/manual_ok_err.fixed
+++ b/tests/ui/manual_ok_err.fixed
@@ -103,3 +103,27 @@ fn issue14239() {
     };
     //~^^^^^ manual_ok_err
 }
+
+mod issue15051 {
+    struct Container {
+        field: Result<bool, ()>,
+    }
+
+    #[allow(clippy::needless_borrow)]
+    fn with_addr_of(x: &Container) -> Option<&bool> {
+        (&x.field).as_ref().ok()
+    }
+
+    fn from_fn(x: &Container) -> Option<&bool> {
+        let result_with_ref = || &x.field;
+        result_with_ref().as_ref().ok()
+    }
+
+    fn result_with_ref_mut(x: &mut Container) -> &mut Result<bool, ()> {
+        &mut x.field
+    }
+
+    fn from_fn_mut(x: &mut Container) -> Option<&mut bool> {
+        result_with_ref_mut(x).as_mut().ok()
+    }
+}
diff --git a/tests/ui/manual_ok_err.rs b/tests/ui/manual_ok_err.rs
index 972b2c41ee7..dee90463824 100644
--- a/tests/ui/manual_ok_err.rs
+++ b/tests/ui/manual_ok_err.rs
@@ -141,3 +141,39 @@ fn issue14239() {
     };
     //~^^^^^ manual_ok_err
 }
+
+mod issue15051 {
+    struct Container {
+        field: Result<bool, ()>,
+    }
+
+    #[allow(clippy::needless_borrow)]
+    fn with_addr_of(x: &Container) -> Option<&bool> {
+        match &x.field {
+            //~^ manual_ok_err
+            Ok(panel) => Some(panel),
+            Err(_) => None,
+        }
+    }
+
+    fn from_fn(x: &Container) -> Option<&bool> {
+        let result_with_ref = || &x.field;
+        match result_with_ref() {
+            //~^ manual_ok_err
+            Ok(panel) => Some(panel),
+            Err(_) => None,
+        }
+    }
+
+    fn result_with_ref_mut(x: &mut Container) -> &mut Result<bool, ()> {
+        &mut x.field
+    }
+
+    fn from_fn_mut(x: &mut Container) -> Option<&mut bool> {
+        match result_with_ref_mut(x) {
+            //~^ manual_ok_err
+            Ok(panel) => Some(panel),
+            Err(_) => None,
+        }
+    }
+}
diff --git a/tests/ui/manual_ok_err.stderr b/tests/ui/manual_ok_err.stderr
index 040e170f397..448fbffc050 100644
--- a/tests/ui/manual_ok_err.stderr
+++ b/tests/ui/manual_ok_err.stderr
@@ -111,5 +111,35 @@ LL +         "1".parse::<u8>().ok()
 LL ~     };
    |
 
-error: aborting due to 9 previous errors
+error: manual implementation of `ok`
+  --> tests/ui/manual_ok_err.rs:152:9
+   |
+LL | /         match &x.field {
+LL | |
+LL | |             Ok(panel) => Some(panel),
+LL | |             Err(_) => None,
+LL | |         }
+   | |_________^ help: replace with: `(&x.field).as_ref().ok()`
+
+error: manual implementation of `ok`
+  --> tests/ui/manual_ok_err.rs:161:9
+   |
+LL | /         match result_with_ref() {
+LL | |
+LL | |             Ok(panel) => Some(panel),
+LL | |             Err(_) => None,
+LL | |         }
+   | |_________^ help: replace with: `result_with_ref().as_ref().ok()`
+
+error: manual implementation of `ok`
+  --> tests/ui/manual_ok_err.rs:173:9
+   |
+LL | /         match result_with_ref_mut(x) {
+LL | |
+LL | |             Ok(panel) => Some(panel),
+LL | |             Err(_) => None,
+LL | |         }
+   | |_________^ help: replace with: `result_with_ref_mut(x).as_mut().ok()`
+
+error: aborting due to 12 previous errors
 
diff --git a/tests/ui/missing_const_for_fn/const_trait.fixed b/tests/ui/missing_const_for_fn/const_trait.fixed
index 7e0d4fccaae..f1d5579a723 100644
--- a/tests/ui/missing_const_for_fn/const_trait.fixed
+++ b/tests/ui/missing_const_for_fn/const_trait.fixed
@@ -25,7 +25,7 @@ const fn can_be_const() {
     0u64.method();
 }
 
-// False negative, see FIXME comment in `clipy_utils::qualify_min_const`
+// False negative, see FIXME comment in `clippy_utils::qualify_min_const_fn`
 fn could_be_const_but_does_not_trigger<T>(t: T)
 where
     T: const ConstTrait,
diff --git a/tests/ui/missing_const_for_fn/const_trait.rs b/tests/ui/missing_const_for_fn/const_trait.rs
index 439da4622d7..d495759526d 100644
--- a/tests/ui/missing_const_for_fn/const_trait.rs
+++ b/tests/ui/missing_const_for_fn/const_trait.rs
@@ -25,7 +25,7 @@ fn can_be_const() {
     0u64.method();
 }
 
-// False negative, see FIXME comment in `clipy_utils::qualify_min_const`
+// False negative, see FIXME comment in `clippy_utils::qualify_min_const_fn`
 fn could_be_const_but_does_not_trigger<T>(t: T)
 where
     T: const ConstTrait,
diff --git a/tests/ui/missing_const_for_fn/could_be_const.fixed b/tests/ui/missing_const_for_fn/could_be_const.fixed
index 65eb2d5938b..95bf63ed1df 100644
--- a/tests/ui/missing_const_for_fn/could_be_const.fixed
+++ b/tests/ui/missing_const_for_fn/could_be_const.fixed
@@ -221,3 +221,60 @@ const fn mut_add(x: &mut i32) {
     //~^ missing_const_for_fn
     *x += 1;
 }
+
+mod issue_15079 {
+    pub trait Trait {}
+
+    pub struct Struct<T: Trait> {
+        _t: Option<T>,
+    }
+
+    impl<T: Trait> Struct<T> {
+        #[clippy::msrv = "1.60"]
+        pub fn new_1_60() -> Self {
+            Self { _t: None }
+        }
+
+        #[clippy::msrv = "1.61"]
+        pub const fn new_1_61() -> Self {
+            //~^ missing_const_for_fn
+            Self { _t: None }
+        }
+    }
+
+    pub struct S2<T> {
+        _t: Option<T>,
+    }
+
+    impl<T> S2<T> {
+        #[clippy::msrv = "1.60"]
+        pub const fn new_1_60() -> Self {
+            //~^ missing_const_for_fn
+            Self { _t: None }
+        }
+
+        #[clippy::msrv = "1.61"]
+        pub const fn new_1_61() -> Self {
+            //~^ missing_const_for_fn
+            Self { _t: None }
+        }
+    }
+
+    pub struct S3<T: ?Sized + 'static> {
+        _t: Option<&'static T>,
+    }
+
+    impl<T: ?Sized + 'static> S3<T> {
+        #[clippy::msrv = "1.60"]
+        pub const fn new_1_60() -> Self {
+            //~^ missing_const_for_fn
+            Self { _t: None }
+        }
+
+        #[clippy::msrv = "1.61"]
+        pub const fn new_1_61() -> Self {
+            //~^ missing_const_for_fn
+            Self { _t: None }
+        }
+    }
+}
diff --git a/tests/ui/missing_const_for_fn/could_be_const.rs b/tests/ui/missing_const_for_fn/could_be_const.rs
index 3690d2f799f..8290be67546 100644
--- a/tests/ui/missing_const_for_fn/could_be_const.rs
+++ b/tests/ui/missing_const_for_fn/could_be_const.rs
@@ -221,3 +221,60 @@ fn mut_add(x: &mut i32) {
     //~^ missing_const_for_fn
     *x += 1;
 }
+
+mod issue_15079 {
+    pub trait Trait {}
+
+    pub struct Struct<T: Trait> {
+        _t: Option<T>,
+    }
+
+    impl<T: Trait> Struct<T> {
+        #[clippy::msrv = "1.60"]
+        pub fn new_1_60() -> Self {
+            Self { _t: None }
+        }
+
+        #[clippy::msrv = "1.61"]
+        pub fn new_1_61() -> Self {
+            //~^ missing_const_for_fn
+            Self { _t: None }
+        }
+    }
+
+    pub struct S2<T> {
+        _t: Option<T>,
+    }
+
+    impl<T> S2<T> {
+        #[clippy::msrv = "1.60"]
+        pub fn new_1_60() -> Self {
+            //~^ missing_const_for_fn
+            Self { _t: None }
+        }
+
+        #[clippy::msrv = "1.61"]
+        pub fn new_1_61() -> Self {
+            //~^ missing_const_for_fn
+            Self { _t: None }
+        }
+    }
+
+    pub struct S3<T: ?Sized + 'static> {
+        _t: Option<&'static T>,
+    }
+
+    impl<T: ?Sized + 'static> S3<T> {
+        #[clippy::msrv = "1.60"]
+        pub fn new_1_60() -> Self {
+            //~^ missing_const_for_fn
+            Self { _t: None }
+        }
+
+        #[clippy::msrv = "1.61"]
+        pub fn new_1_61() -> Self {
+            //~^ missing_const_for_fn
+            Self { _t: None }
+        }
+    }
+}
diff --git a/tests/ui/missing_const_for_fn/could_be_const.stderr b/tests/ui/missing_const_for_fn/could_be_const.stderr
index 10e07d12f5a..17cbc431276 100644
--- a/tests/ui/missing_const_for_fn/could_be_const.stderr
+++ b/tests/ui/missing_const_for_fn/could_be_const.stderr
@@ -332,5 +332,75 @@ help: make the function `const`
 LL | const fn mut_add(x: &mut i32) {
    | +++++
 
-error: aborting due to 25 previous errors
+error: this could be a `const fn`
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:239:9
+   |
+LL | /         pub fn new_1_61() -> Self {
+LL | |
+LL | |             Self { _t: None }
+LL | |         }
+   | |_________^
+   |
+help: make the function `const`
+   |
+LL |         pub const fn new_1_61() -> Self {
+   |             +++++
+
+error: this could be a `const fn`
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:251:9
+   |
+LL | /         pub fn new_1_60() -> Self {
+LL | |
+LL | |             Self { _t: None }
+LL | |         }
+   | |_________^
+   |
+help: make the function `const`
+   |
+LL |         pub const fn new_1_60() -> Self {
+   |             +++++
+
+error: this could be a `const fn`
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:257:9
+   |
+LL | /         pub fn new_1_61() -> Self {
+LL | |
+LL | |             Self { _t: None }
+LL | |         }
+   | |_________^
+   |
+help: make the function `const`
+   |
+LL |         pub const fn new_1_61() -> Self {
+   |             +++++
+
+error: this could be a `const fn`
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:269:9
+   |
+LL | /         pub fn new_1_60() -> Self {
+LL | |
+LL | |             Self { _t: None }
+LL | |         }
+   | |_________^
+   |
+help: make the function `const`
+   |
+LL |         pub const fn new_1_60() -> Self {
+   |             +++++
+
+error: this could be a `const fn`
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:275:9
+   |
+LL | /         pub fn new_1_61() -> Self {
+LL | |
+LL | |             Self { _t: None }
+LL | |         }
+   | |_________^
+   |
+help: make the function `const`
+   |
+LL |         pub const fn new_1_61() -> Self {
+   |             +++++
+
+error: aborting due to 30 previous errors
 
diff --git a/tests/ui/nonminimal_bool.stderr b/tests/ui/nonminimal_bool.stderr
index 0e3e4cf7988..ecb82a23da0 100644
--- a/tests/ui/nonminimal_bool.stderr
+++ b/tests/ui/nonminimal_bool.stderr
@@ -179,7 +179,7 @@ error: inequality checks against true can be replaced by a negation
   --> tests/ui/nonminimal_bool.rs:186:8
    |
 LL |     if !b != true {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!(!b)`
+   |        ^^^^^^^^^^ help: try simplifying it as shown: `!!b`
 
 error: this boolean expression can be simplified
   --> tests/ui/nonminimal_bool.rs:189:8
@@ -209,7 +209,7 @@ error: inequality checks against true can be replaced by a negation
   --> tests/ui/nonminimal_bool.rs:193:8
    |
 LL |     if true != !b {}
-   |        ^^^^^^^^^^ help: try simplifying it as shown: `!(!b)`
+   |        ^^^^^^^^^^ help: try simplifying it as shown: `!!b`
 
 error: this boolean expression can be simplified
   --> tests/ui/nonminimal_bool.rs:196:8
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index a1119d75c23..34f3e046841 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -5,6 +5,7 @@
     clippy::uninlined_format_args,
     clippy::unnecessary_wraps,
     clippy::unnecessary_literal_unwrap,
+    clippy::unnecessary_result_map_or_else,
     clippy::useless_vec
 )]
 
@@ -409,4 +410,33 @@ fn fn_call_in_nested_expr() {
     //~^ or_fun_call
 }
 
+mod result_map_or {
+    fn g() -> i32 {
+        3
+    }
+
+    fn f(n: i32) -> i32 {
+        n
+    }
+
+    fn test_map_or() {
+        let x: Result<i32, ()> = Ok(4);
+        let _ = x.map_or_else(|_| g(), |v| v);
+        //~^ or_fun_call
+        let _ = x.map_or_else(|_| g(), f);
+        //~^ or_fun_call
+        let _ = x.map_or(0, f);
+    }
+}
+
+fn test_option_get_or_insert() {
+    // assume that this is slow call
+    fn g() -> u8 {
+        99
+    }
+    let mut x = Some(42_u8);
+    let _ = x.get_or_insert_with(g);
+    //~^ or_fun_call
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index a7cd632bf16..dc57bd6060a 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -5,6 +5,7 @@
     clippy::uninlined_format_args,
     clippy::unnecessary_wraps,
     clippy::unnecessary_literal_unwrap,
+    clippy::unnecessary_result_map_or_else,
     clippy::useless_vec
 )]
 
@@ -409,4 +410,33 @@ fn fn_call_in_nested_expr() {
     //~^ or_fun_call
 }
 
+mod result_map_or {
+    fn g() -> i32 {
+        3
+    }
+
+    fn f(n: i32) -> i32 {
+        n
+    }
+
+    fn test_map_or() {
+        let x: Result<i32, ()> = Ok(4);
+        let _ = x.map_or(g(), |v| v);
+        //~^ or_fun_call
+        let _ = x.map_or(g(), f);
+        //~^ or_fun_call
+        let _ = x.map_or(0, f);
+    }
+}
+
+fn test_option_get_or_insert() {
+    // assume that this is slow call
+    fn g() -> u8 {
+        99
+    }
+    let mut x = Some(42_u8);
+    let _ = x.get_or_insert(g());
+    //~^ or_fun_call
+}
+
 fn main() {}
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 35bda7e4d33..0f159fe8bff 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -1,5 +1,5 @@
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:52:22
+  --> tests/ui/or_fun_call.rs:53:22
    |
 LL |     with_constructor.unwrap_or(make());
    |                      ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(make)`
@@ -8,7 +8,7 @@ LL |     with_constructor.unwrap_or(make());
    = help: to override `-D warnings` add `#[allow(clippy::or_fun_call)]`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:56:14
+  --> tests/ui/or_fun_call.rs:57:14
    |
 LL |     with_new.unwrap_or(Vec::new());
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
@@ -17,199 +17,199 @@ LL |     with_new.unwrap_or(Vec::new());
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_or_default)]`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:60:21
+  --> tests/ui/or_fun_call.rs:61:21
    |
 LL |     with_const_args.unwrap_or(Vec::with_capacity(12));
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Vec::with_capacity(12))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:64:14
+  --> tests/ui/or_fun_call.rs:65:14
    |
 LL |     with_err.unwrap_or(make());
    |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| make())`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:68:19
+  --> tests/ui/or_fun_call.rs:69:19
    |
 LL |     with_err_args.unwrap_or(Vec::with_capacity(12));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| Vec::with_capacity(12))`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:72:24
+  --> tests/ui/or_fun_call.rs:73:24
    |
 LL |     with_default_trait.unwrap_or(Default::default());
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:76:23
+  --> tests/ui/or_fun_call.rs:77:23
    |
 LL |     with_default_type.unwrap_or(u64::default());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:80:18
+  --> tests/ui/or_fun_call.rs:81:18
    |
 LL |     self_default.unwrap_or(<FakeDefault>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(<FakeDefault>::default)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:84:18
+  --> tests/ui/or_fun_call.rs:85:18
    |
 LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:88:14
+  --> tests/ui/or_fun_call.rs:89:14
    |
 LL |     with_vec.unwrap_or(vec![]);
    |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:92:21
+  --> tests/ui/or_fun_call.rs:93:21
    |
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(Foo::new)`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:96:19
+  --> tests/ui/or_fun_call.rs:97:19
    |
 LL |     map.entry(42).or_insert(String::new());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:100:23
+  --> tests/ui/or_fun_call.rs:101:23
    |
 LL |     map_vec.entry(42).or_insert(vec![]);
    |                       ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:104:21
+  --> tests/ui/or_fun_call.rs:105:21
    |
 LL |     btree.entry(42).or_insert(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:108:25
+  --> tests/ui/or_fun_call.rs:109:25
    |
 LL |     btree_vec.entry(42).or_insert(vec![]);
    |                         ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:112:21
+  --> tests/ui/or_fun_call.rs:113:21
    |
 LL |     let _ = stringy.unwrap_or(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `ok_or`
-  --> tests/ui/or_fun_call.rs:117:17
+  --> tests/ui/or_fun_call.rs:118:17
    |
 LL |     let _ = opt.ok_or(format!("{} world.", hello));
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ok_or_else(|| format!("{} world.", hello))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:122:21
+  --> tests/ui/or_fun_call.rs:123:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:125:21
+  --> tests/ui/or_fun_call.rs:126:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `or`
-  --> tests/ui/or_fun_call.rs:150:35
+  --> tests/ui/or_fun_call.rs:151:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_else(|| Some("b".to_string()))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:193:18
+  --> tests/ui/or_fun_call.rs:194:18
    |
 LL |             None.unwrap_or(ptr_to_ref(s));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| ptr_to_ref(s))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:201:14
+  --> tests/ui/or_fun_call.rs:202:14
    |
 LL |         None.unwrap_or(unsafe { ptr_to_ref(s) });
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:204:14
+  --> tests/ui/or_fun_call.rs:205:14
    |
 LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:280:25
+  --> tests/ui/or_fun_call.rs:281:25
    |
 LL |         let _ = Some(4).map_or(g(), |v| v);
    |                         ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(g, |v| v)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:282:25
+  --> tests/ui/or_fun_call.rs:283:25
    |
 LL |         let _ = Some(4).map_or(g(), f);
    |                         ^^^^^^^^^^^^^^ help: try: `map_or_else(g, f)`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:314:18
+  --> tests/ui/or_fun_call.rs:315:18
    |
 LL |         with_new.unwrap_or_else(Vec::new);
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:318:28
+  --> tests/ui/or_fun_call.rs:319:28
    |
 LL |         with_default_trait.unwrap_or_else(Default::default);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:322:27
+  --> tests/ui/or_fun_call.rs:323:27
    |
 LL |         with_default_type.unwrap_or_else(u64::default);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:326:22
+  --> tests/ui/or_fun_call.rs:327:22
    |
 LL |         real_default.unwrap_or_else(<FakeDefault as Default>::default);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:330:23
+  --> tests/ui/or_fun_call.rs:331:23
    |
 LL |         map.entry(42).or_insert_with(String::new);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:334:25
+  --> tests/ui/or_fun_call.rs:335:25
    |
 LL |         btree.entry(42).or_insert_with(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:338:25
+  --> tests/ui/or_fun_call.rs:339:25
    |
 LL |         let _ = stringy.unwrap_or_else(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:380:17
+  --> tests/ui/or_fun_call.rs:381:17
    |
 LL |     let _ = opt.unwrap_or({ f() }); // suggest `.unwrap_or_else(f)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(f)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:385:17
+  --> tests/ui/or_fun_call.rs:386:17
    |
 LL |     let _ = opt.unwrap_or(f() + 1); // suggest `.unwrap_or_else(|| f() + 1)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| f() + 1)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:390:17
+  --> tests/ui/or_fun_call.rs:391:17
    |
 LL |       let _ = opt.unwrap_or({
    |  _________________^
@@ -229,22 +229,40 @@ LL ~     });
    |
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:396:17
+  --> tests/ui/or_fun_call.rs:397:17
    |
 LL |     let _ = opt.map_or(f() + 1, |v| v); // suggest `.map_or_else(|| f() + 1, |v| v)`
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|| f() + 1, |v| v)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:401:17
+  --> tests/ui/or_fun_call.rs:402:17
    |
 LL |     let _ = opt.unwrap_or({ i32::default() });
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:408:21
+  --> tests/ui/or_fun_call.rs:409:21
    |
 LL |     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Foo { val: String::default() })`
 
-error: aborting due to 38 previous errors
+error: function call inside of `map_or`
+  --> tests/ui/or_fun_call.rs:424:19
+   |
+LL |         let _ = x.map_or(g(), |v| v);
+   |                   ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|_| g(), |v| v)`
+
+error: function call inside of `map_or`
+  --> tests/ui/or_fun_call.rs:426:19
+   |
+LL |         let _ = x.map_or(g(), f);
+   |                   ^^^^^^^^^^^^^^ help: try: `map_or_else(|_| g(), f)`
+
+error: function call inside of `get_or_insert`
+  --> tests/ui/or_fun_call.rs:438:15
+   |
+LL |     let _ = x.get_or_insert(g());
+   |               ^^^^^^^^^^^^^^^^^^ help: try: `get_or_insert_with(g)`
+
+error: aborting due to 41 previous errors
 
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 60dc1c101b6..8d6f5fbadca 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -453,3 +453,15 @@ fn const_in_pattern(x: Option<(i32, i32)>) -> Option<()> {
 
     None
 }
+
+fn issue_13642(x: Option<i32>) -> Option<()> {
+    let Some(x) = x else {
+        #[cfg(false)]
+        panic!();
+
+        #[cfg(true)]
+        return None;
+    };
+
+    None
+}
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index 99d0122a98f..f13eee29c11 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -549,3 +549,15 @@ fn const_in_pattern(x: Option<(i32, i32)>) -> Option<()> {
 
     None
 }
+
+fn issue_13642(x: Option<i32>) -> Option<()> {
+    let Some(x) = x else {
+        #[cfg(false)]
+        panic!();
+
+        #[cfg(true)]
+        return None;
+    };
+
+    None
+}
diff --git a/tests/ui/unnecessary_os_str_debug_formatting.rs b/tests/ui/unnecessary_os_str_debug_formatting.rs
index 6652efd9ae1..66590be3d05 100644
--- a/tests/ui/unnecessary_os_str_debug_formatting.rs
+++ b/tests/ui/unnecessary_os_str_debug_formatting.rs
@@ -21,3 +21,16 @@ fn main() {
     let _: String = format!("{:?}", os_str); //~ unnecessary_debug_formatting
     let _: String = format!("{:?}", os_string); //~ unnecessary_debug_formatting
 }
+
+#[clippy::msrv = "1.86"]
+fn msrv_1_86() {
+    let os_str = OsStr::new("test");
+    println!("{:?}", os_str);
+}
+
+#[clippy::msrv = "1.87"]
+fn msrv_1_87() {
+    let os_str = OsStr::new("test");
+    println!("{:?}", os_str);
+    //~^ unnecessary_debug_formatting
+}
diff --git a/tests/ui/unnecessary_os_str_debug_formatting.stderr b/tests/ui/unnecessary_os_str_debug_formatting.stderr
index 382e59b0461..f04d2d5bdc8 100644
--- a/tests/ui/unnecessary_os_str_debug_formatting.stderr
+++ b/tests/ui/unnecessary_os_str_debug_formatting.stderr
@@ -54,5 +54,14 @@ LL |     let _: String = format!("{:?}", os_string);
    = help: use `Display` formatting and change this to `os_string.display()`
    = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
 
-error: aborting due to 6 previous errors
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_os_str_debug_formatting.rs:34:22
+   |
+LL |     println!("{:?}", os_str);
+   |                      ^^^^^^
+   |
+   = help: use `Display` formatting and change this to `os_str.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/wildcard_enum_match_arm.fixed b/tests/ui/wildcard_enum_match_arm.fixed
index 141ff6eb2ac..5f738a254dc 100644
--- a/tests/ui/wildcard_enum_match_arm.fixed
+++ b/tests/ui/wildcard_enum_match_arm.fixed
@@ -90,6 +90,21 @@ fn main() {
         _ => {},
     }
 
+    {
+        pub enum Enum {
+            A,
+            B,
+            C(u8),
+            D(u8, u8),
+            E { e: u8 },
+        };
+        match Enum::A {
+            Enum::A => (),
+            Enum::B | Enum::C(_) | Enum::D(..) | Enum::E { .. } => (),
+            //~^ wildcard_enum_match_arm
+        }
+    }
+
     {
         #![allow(clippy::manual_non_exhaustive)]
         pub enum Enum {
@@ -105,3 +120,17 @@ fn main() {
         }
     }
 }
+
+fn issue15091() {
+    enum Foo {
+        A,
+        B,
+        C,
+    }
+
+    match Foo::A {
+        Foo::A => {},
+        r#type @ Foo::B | r#type @ Foo::C => {},
+        //~^ wildcard_enum_match_arm
+    }
+}
diff --git a/tests/ui/wildcard_enum_match_arm.rs b/tests/ui/wildcard_enum_match_arm.rs
index a13684e9100..4bc4bfdcb79 100644
--- a/tests/ui/wildcard_enum_match_arm.rs
+++ b/tests/ui/wildcard_enum_match_arm.rs
@@ -90,6 +90,21 @@ fn main() {
         _ => {},
     }
 
+    {
+        pub enum Enum {
+            A,
+            B,
+            C(u8),
+            D(u8, u8),
+            E { e: u8 },
+        };
+        match Enum::A {
+            Enum::A => (),
+            _ => (),
+            //~^ wildcard_enum_match_arm
+        }
+    }
+
     {
         #![allow(clippy::manual_non_exhaustive)]
         pub enum Enum {
@@ -105,3 +120,17 @@ fn main() {
         }
     }
 }
+
+fn issue15091() {
+    enum Foo {
+        A,
+        B,
+        C,
+    }
+
+    match Foo::A {
+        Foo::A => {},
+        r#type => {},
+        //~^ wildcard_enum_match_arm
+    }
+}
diff --git a/tests/ui/wildcard_enum_match_arm.stderr b/tests/ui/wildcard_enum_match_arm.stderr
index 088c6b7b284..d0929989494 100644
--- a/tests/ui/wildcard_enum_match_arm.stderr
+++ b/tests/ui/wildcard_enum_match_arm.stderr
@@ -37,8 +37,20 @@ LL |         _ => {},
 error: wildcard match will also match any future added variants
   --> tests/ui/wildcard_enum_match_arm.rs:103:13
    |
+LL |             _ => (),
+   |             ^ help: try: `Enum::B | Enum::C(_) | Enum::D(..) | Enum::E { .. }`
+
+error: wildcard match will also match any future added variants
+  --> tests/ui/wildcard_enum_match_arm.rs:118:13
+   |
 LL |             _ => (),
    |             ^ help: try: `Enum::B | Enum::__Private`
 
-error: aborting due to 6 previous errors
+error: wildcard match will also match any future added variants
+  --> tests/ui/wildcard_enum_match_arm.rs:133:9
+   |
+LL |         r#type => {},
+   |         ^^^^^^ help: try: `r#type @ Foo::B | r#type @ Foo::C`
+
+error: aborting due to 8 previous errors
 
diff --git a/tests/versioncheck.rs b/tests/versioncheck.rs
index f6fc2354ca0..b0179387b2b 100644
--- a/tests/versioncheck.rs
+++ b/tests/versioncheck.rs
@@ -27,6 +27,7 @@ fn consistent_clippy_crate_versions() {
         "clippy_config/Cargo.toml",
         "clippy_lints/Cargo.toml",
         "clippy_utils/Cargo.toml",
+        "declare_clippy_lint/Cargo.toml",
     ];
 
     for path in paths {
diff --git a/triagebot.toml b/triagebot.toml
index 16557a4bebb..4f370758c00 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -17,6 +17,9 @@ allow-unauthenticated = [
 
 [issue-links]
 
+[mentions."clippy_lints/src/doc"]
+cc = ["@notriddle"]
+
 # Prevents mentions in commits to avoid users being spammed
 [no-mentions]
 
diff --git a/util/versions.py b/util/versions.py
index fee0d292df1..6e06d77a771 100755
--- a/util/versions.py
+++ b/util/versions.py
@@ -6,11 +6,11 @@ import os
 import sys
 
 def key(v):
-    if v == "master":
-        return sys.maxsize
     if v == "stable":
-        return sys.maxsize - 1
+        return sys.maxsize 
     if v == "beta":
+        return sys.maxsize - 1
+    if v == "master":
         return sys.maxsize - 2
     if v == "pre-1.29.0":
         return -1
-- 
cgit 1.4.1-3-g733a5


From 4a8eec34ee888852f3f2b909c575df0bedf9f61a Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Fri, 27 Jun 2025 12:21:41 +0200
Subject: broken_links: Fix rustdoc API usage

---
 clippy_lints/src/doc/broken_link.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/doc/broken_link.rs b/clippy_lints/src/doc/broken_link.rs
index a97b807e605..4af10510023 100644
--- a/clippy_lints/src/doc/broken_link.rs
+++ b/clippy_lints/src/doc/broken_link.rs
@@ -19,7 +19,7 @@ pub fn check(cx: &LateContext<'_>, bl: &PullDownBrokenLink<'_>, doc: &str, fragm
 }
 
 fn warn_if_broken_link(cx: &LateContext<'_>, bl: &PullDownBrokenLink<'_>, doc: &str, fragments: &[DocFragment]) {
-    if let Some(span) = source_span_for_markdown_range(cx.tcx, doc, &bl.span, fragments) {
+    if let Some((span, _)) = source_span_for_markdown_range(cx.tcx, doc, &bl.span, fragments) {
         let mut len = 0;
 
         // grab raw link data
-- 
cgit 1.4.1-3-g733a5


From 7e406e276a1778390c06ce40a9a4929e3d371776 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Tue, 24 Jun 2025 21:18:22 +0800
Subject: fix: `disallowed_script_idents` FP on identifiers with `_`

---
 clippy_lints/src/disallowed_script_idents.rs |  4 ++++
 tests/ui/disallowed_script_idents.rs         | 14 ++++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/clippy_lints/src/disallowed_script_idents.rs b/clippy_lints/src/disallowed_script_idents.rs
index d1a8590c59b..cf964d4b580 100644
--- a/clippy_lints/src/disallowed_script_idents.rs
+++ b/clippy_lints/src/disallowed_script_idents.rs
@@ -89,6 +89,10 @@ impl EarlyLintPass for DisallowedScriptIdents {
             // Fast path for ascii-only idents.
             if !symbol_str.is_ascii()
                 && let Some(script) = symbol_str.chars().find_map(|c| {
+                    if c.is_ascii() {
+                        return None;
+                    }
+
                     c.script_extension()
                         .iter()
                         .find(|script| !self.whitelist.contains(script))
diff --git a/tests/ui/disallowed_script_idents.rs b/tests/ui/disallowed_script_idents.rs
index 08fd1d9669e..dae380045ae 100644
--- a/tests/ui/disallowed_script_idents.rs
+++ b/tests/ui/disallowed_script_idents.rs
@@ -15,3 +15,17 @@ fn main() {
     let カウンタ = 10;
     //~^ disallowed_script_idents
 }
+
+fn issue15116() {
+    const ÄÖÜ: u8 = 0;
+    const _ÄÖÜ: u8 = 0;
+    const Ä_ÖÜ: u8 = 0;
+    const ÄÖ_Ü: u8 = 0;
+    const ÄÖÜ_: u8 = 0;
+    let äöüß = 1;
+    let _äöüß = 1;
+    let ä_öüß = 1;
+    let äö_üß = 1;
+    let äöü_ß = 1;
+    let äöüß_ = 1;
+}
-- 
cgit 1.4.1-3-g733a5


From 56af6625c8a1b5815b5628425c145d8e43e1ec26 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 28 Jun 2025 23:37:08 +0200
Subject: Merge commit 'b7091eca6d8eb0fe88b58cc9a7aec405d8de5b85' into
 subtree-update_cg_gcc_2025-06-28

---
 build_system/src/abi_test.rs                       | 65 ++++++++++++++++++++++
 build_system/src/main.rs                           |  8 ++-
 build_system/src/test.rs                           |  9 +--
 .../0001-Pin-compiler_builtins-to-0.1.160.patch    | 39 -------------
 rust-toolchain                                     |  2 +-
 src/builder.rs                                     | 65 ++++++++++++++--------
 src/common.rs                                      | 13 -----
 src/context.rs                                     | 33 ++++++-----
 src/debuginfo.rs                                   |  6 +-
 src/declare.rs                                     |  5 +-
 src/intrinsic/mod.rs                               | 21 ++++---
 tests/failing-ui-tests.txt                         |  1 +
 12 files changed, 150 insertions(+), 117 deletions(-)
 create mode 100644 build_system/src/abi_test.rs
 delete mode 100644 patches/0001-Pin-compiler_builtins-to-0.1.160.patch

diff --git a/build_system/src/abi_test.rs b/build_system/src/abi_test.rs
new file mode 100644
index 00000000000..3c1531be27a
--- /dev/null
+++ b/build_system/src/abi_test.rs
@@ -0,0 +1,65 @@
+use std::ffi::OsStr;
+use std::path::Path;
+
+use crate::utils::run_command_with_output;
+
+fn show_usage() {
+    println!(
+        r#"
+`abi-test` command help:
+    --help                 : Show this help"#
+    );
+}
+
+pub fn run() -> Result<(), String> {
+    let mut args = std::env::args().skip(2);
+    // FractalFir: In the future, I'd like to add some more subcommands / options.
+    // So, this loop ought to stay for that purpose. It should also stay as a while loop(to parse args)
+    #[allow(clippy::never_loop, clippy::while_let_on_iterator)]
+    while let Some(arg) = args.next() {
+        match arg.as_str() {
+            "--help" => {
+                show_usage();
+                return Ok(());
+            }
+            _ => return Err(format!("Unknown option {arg:?}")),
+        }
+    }
+    // Ensure that we have a cloned version of abi-cafe on hand.
+    crate::utils::git_clone(
+        "https://github.com/Gankra/abi-cafe.git",
+        Some("clones/abi-cafe".as_ref()),
+        true,
+    )
+    .map_err(|err| (format!("Git clone failed with message: {err:?}!")))?;
+    // Configure abi-cafe to use the exact same rustc version we use - this is crucial.
+    // Otherwise, the concept of ABI compatibility becomes meanignless.
+    std::fs::copy("rust-toolchain", "clones/abi-cafe/rust-toolchain")
+        .expect("Could not copy toolchain configs!");
+    // Get the backend path.
+    // We will use the *debug* build of the backend - it has more checks enabled.
+    let backend_path = std::path::absolute("target/debug/librustc_codegen_gcc.so").unwrap();
+    let backend_arg = format!("--add-rustc-codegen-backend=cg_gcc:{}", backend_path.display());
+    // Run ABI cafe using cargo.
+    let cmd: &[&dyn AsRef<OsStr>] = &[
+        &"cargo",
+        &"run",
+        &"--release",
+        &"--",
+        &backend_arg,
+        // Test rust-LLVM to Rust-GCC calls
+        &"--pairs",
+        &"rustc_calls_cg_gcc",
+        &"--pairs",
+        &"cg_gcc_calls_rustc",
+        // Test Rust-GCC to C calls
+        &"--pairs",
+        &"cg_gcc_calls_c",
+        &"--pairs",
+        &"c_calls_cg_gcc",
+    ];
+    // Run ABI cafe.
+    run_command_with_output(cmd, Some(Path::new("clones/abi-cafe")))?;
+
+    Ok(())
+}
diff --git a/build_system/src/main.rs b/build_system/src/main.rs
index 078a4726ba8..ae975c94fff 100644
--- a/build_system/src/main.rs
+++ b/build_system/src/main.rs
@@ -1,5 +1,6 @@
 use std::{env, process};
 
+mod abi_test;
 mod build;
 mod clean;
 mod clone_gcc;
@@ -12,7 +13,6 @@ mod rust_tools;
 mod rustc_info;
 mod test;
 mod utils;
-
 const BUILD_DIR: &str = "build";
 
 macro_rules! arg_error {
@@ -44,7 +44,8 @@ Commands:
         info      : Displays information about the build environment and project configuration.
         clone-gcc : Clones the GCC compiler from a specified source.
         fmt       : Runs rustfmt
-        fuzz      : Fuzzes `cg_gcc` using rustlantis"
+        fuzz      : Fuzzes `cg_gcc` using rustlantis
+        abi-test   : Runs the abi-cafe test suite on the codegen, checking for ABI compatibility with LLVM"
     );
 }
 
@@ -59,6 +60,7 @@ pub enum Command {
     Info,
     Fmt,
     Fuzz,
+    AbiTest,
 }
 
 fn main() {
@@ -77,6 +79,7 @@ fn main() {
         Some("test") => Command::Test,
         Some("info") => Command::Info,
         Some("clone-gcc") => Command::CloneGcc,
+        Some("abi-test") => Command::AbiTest,
         Some("fmt") => Command::Fmt,
         Some("fuzz") => Command::Fuzz,
         Some("--help") => {
@@ -102,6 +105,7 @@ fn main() {
         Command::CloneGcc => clone_gcc::run(),
         Command::Fmt => fmt::run(),
         Command::Fuzz => fuzz::run(),
+        Command::AbiTest => abi_test::run(),
     } {
         eprintln!("Command failed to run: {e}");
         process::exit(1);
diff --git a/build_system/src/test.rs b/build_system/src/test.rs
index bcaab0fb526..f1f31f83ca2 100644
--- a/build_system/src/test.rs
+++ b/build_system/src/test.rs
@@ -738,14 +738,7 @@ fn test_libcore(env: &Env, args: &TestArg) -> Result<(), String> {
     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.
-    // TODO(antoyo): remove the --skip f16::test_total_cmp when this issue is fixed:
-    // https://github.com/rust-lang/rust/issues/141503
-    run_cargo_command(
-        &[&"test", &"--", &"--skip", &"f16::test_total_cmp"],
-        Some(&path),
-        env,
-        args,
-    )?;
+    run_cargo_command(&[&"test"], Some(&path), env, args)?;
     Ok(())
 }
 
diff --git a/patches/0001-Pin-compiler_builtins-to-0.1.160.patch b/patches/0001-Pin-compiler_builtins-to-0.1.160.patch
deleted file mode 100644
index 39266e081ed..00000000000
--- a/patches/0001-Pin-compiler_builtins-to-0.1.160.patch
+++ /dev/null
@@ -1,39 +0,0 @@
-From cdb3d407740e4f15c3746051f8ba89b8e74e99d3 Mon Sep 17 00:00:00 2001
-From: None <none@example.com>
-Date: Fri, 30 May 2025 13:46:22 -0400
-Subject: [PATCH] Pin compiler_builtins to 0.1.160
-
----
- library/alloc/Cargo.toml | 2 +-
- library/std/Cargo.toml   | 2 +-
- 2 files changed, 2 insertions(+), 2 deletions(-)
-
-diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
-index 9d0d957..365c9dc 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 = { version = "=0.1.159", features = ['rustc-dep-of-std'] }
-+compiler_builtins = { version = "=0.1.160", features = ['rustc-dep-of-std'] }
- 
- [features]
- compiler-builtins-mem = ['compiler_builtins/mem']
-diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
-index 4ff4895..31371f0 100644
---- a/library/std/Cargo.toml
-+++ b/library/std/Cargo.toml
-@@ -18,7 +18,7 @@ cfg-if = { version = "1.0", features = ['rustc-dep-of-std'] }
- panic_unwind = { path = "../panic_unwind", optional = true }
- panic_abort = { path = "../panic_abort" }
- core = { path = "../core", public = true }
--compiler_builtins = { version = "=0.1.159" }
-+compiler_builtins = { version = "=0.1.160" }
- unwind = { path = "../unwind" }
- hashbrown = { version = "0.15", default-features = false, features = [
-     'rustc-dep-of-std',
--- 
-2.49.0
-
diff --git a/rust-toolchain b/rust-toolchain
index bafe497a2a2..8be204c1581 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2025-05-21"
+channel = "nightly-2025-06-02"
 components = ["rust-src", "rustc-dev", "llvm-tools-preview"]
diff --git a/src/builder.rs b/src/builder.rs
index 7852aebe0c2..a4454cd9c73 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -520,8 +520,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         self.block
     }
 
-    fn append_block(cx: &'a CodegenCx<'gcc, 'tcx>, func: RValue<'gcc>, name: &str) -> Block<'gcc> {
-        let func = cx.rvalue_as_function(func);
+    fn append_block(_: &'a CodegenCx<'gcc, 'tcx>, func: Function<'gcc>, name: &str) -> Block<'gcc> {
         func.new_block(name)
     }
 
@@ -782,6 +781,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
                 return self.context.new_call(self.location, fmod, &[a, b]);
             }
             TypeKind::FP128 => {
+                // TODO(antoyo): use get_simple_function_f128_2args.
                 let f128_type = self.type_f128();
                 let fmodf128 = self.context.new_function(
                     None,
@@ -938,22 +938,36 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
     fn load(&mut self, pointee_ty: Type<'gcc>, ptr: RValue<'gcc>, align: Align) -> RValue<'gcc> {
         let block = self.llbb();
         let function = block.get_function();
+        // NOTE(FractalFir): In some cases, we *should* skip the call to get_aligned.
+        // For example, calling `get_aligned` on a i8 is pointless(since it can only be 1 aligned)
+        // Calling get_aligned on a `u128`/`i128` causes the attribute to become "stacked"
+        //
+        // From GCCs perspective:
+        // __int128_t  __attribute__((aligned(16)))  __attribute__((aligned(16)))
+        // and:
+        // __int128_t  __attribute__((aligned(16)))
+        // are 2 distinct, incompatible types.
+        //
+        // So, we skip the call to `get_aligned` in such a case. *Ideally*, we could do this for all the types,
+        // but the GCC APIs to facilitate this just aren't quite there yet.
+
+        // This checks that we only skip `get_aligned` on 128 bit ints if they have the correct alignment.
+        // Otherwise, this may be an under-aligned load, so we will still call get_aligned.
+        let mut can_skip_align = (pointee_ty == self.cx.u128_type
+            || pointee_ty == self.cx.i128_type)
+            && align == self.int128_align;
+        // We can skip the call to `get_aligned` for byte-sized types with alignment of 1.
+        can_skip_align = can_skip_align
+            || (pointee_ty == self.cx.u8_type || pointee_ty == self.cx.i8_type)
+                && align.bytes() == 1;
+        // Skip the call to `get_aligned` when possible.
+        let aligned_type =
+            if can_skip_align { pointee_ty } else { pointee_ty.get_aligned(align.bytes()) };
+
+        let ptr = self.context.new_cast(self.location, ptr, aligned_type.make_pointer());
         // NOTE: instead of returning the dereference here, we have to assign it to a variable in
         // the current basic block. Otherwise, it could be used in another basic block, causing a
         // dereference after a drop, for instance.
-        // FIXME(antoyo): this check that we don't call get_aligned() a second time on a type.
-        // Ideally, we shouldn't need to do this check.
-        // FractalFir: the `align == self.int128_align` check ensures we *do* call `get_aligned` if
-        // the alignment of a `u128`/`i128` is not the one mandated by the ABI. This ensures we handle
-        // under-aligned loads correctly.
-        let aligned_type = if (pointee_ty == self.cx.u128_type || pointee_ty == self.cx.i128_type)
-            && align == self.int128_align
-        {
-            pointee_ty
-        } else {
-            pointee_ty.get_aligned(align.bytes())
-        };
-        let ptr = self.context.new_cast(self.location, ptr, aligned_type.make_pointer());
         let deref = ptr.dereference(self.location).to_rvalue();
         let loaded_value = function.new_local(
             self.location,
@@ -1105,7 +1119,13 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         // TODO(antoyo)
     }
 
-    fn store(&mut self, val: RValue<'gcc>, ptr: RValue<'gcc>, align: Align) -> RValue<'gcc> {
+    fn store(&mut self, mut val: RValue<'gcc>, ptr: RValue<'gcc>, align: Align) -> RValue<'gcc> {
+        if self.structs_as_pointer.borrow().contains(&val) {
+            // NOTE: hack to workaround a limitation of the rustc API: see comment on
+            // CodegenCx.structs_as_pointer
+            val = val.dereference(self.location).to_rvalue();
+        }
+
         self.store_with_flags(val, ptr, align, MemFlags::empty())
     }
 
@@ -1551,16 +1571,13 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         aggregate_value
     }
 
-    fn set_personality_fn(&mut self, _personality: RValue<'gcc>) {
+    fn set_personality_fn(&mut self, _personality: Function<'gcc>) {
         #[cfg(feature = "master")]
-        {
-            let personality = self.rvalue_as_function(_personality);
-            self.current_func().set_personality_function(personality);
-        }
+        self.current_func().set_personality_function(_personality);
     }
 
     #[cfg(feature = "master")]
-    fn cleanup_landing_pad(&mut self, pers_fn: RValue<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
+    fn cleanup_landing_pad(&mut self, pers_fn: Function<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
         self.set_personality_fn(pers_fn);
 
         // NOTE: insert the current block in a variable so that a later call to invoke knows to
@@ -1581,7 +1598,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
     }
 
     #[cfg(not(feature = "master"))]
-    fn cleanup_landing_pad(&mut self, _pers_fn: RValue<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
+    fn cleanup_landing_pad(&mut self, _pers_fn: Function<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
         let value1 = self
             .current_func()
             .new_local(self.location, self.u8_type.make_pointer(), "landing_pad0")
@@ -1591,7 +1608,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         (value1, value2)
     }
 
-    fn filter_landing_pad(&mut self, pers_fn: RValue<'gcc>) {
+    fn filter_landing_pad(&mut self, pers_fn: Function<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
         // TODO(antoyo): generate the correct landing pad
         self.cleanup_landing_pad(pers_fn);
     }
diff --git a/src/common.rs b/src/common.rs
index 58ff2f1f8f0..fdd47821b51 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -234,19 +234,6 @@ impl<'gcc, 'tcx> ConstCodegenMethods for CodegenCx<'gcc, 'tcx> {
         match cv {
             Scalar::Int(int) => {
                 let data = int.to_bits(layout.size(self));
-
-                // FIXME(antoyo): there's some issues with using the u128 code that follows, so hard-code
-                // the paths for floating-point values.
-                // TODO: Remove this code?
-                /*if ty == self.float_type {
-                    return self
-                        .context
-                        .new_rvalue_from_double(ty, f32::from_bits(data as u32) as f64);
-                }
-                if ty == self.double_type {
-                    return self.context.new_rvalue_from_double(ty, f64::from_bits(data as u64));
-                }*/
-
                 let value = self.const_uint_big(self.type_ix(bitsize), data);
                 let bytesize = layout.size(self).bytes();
                 if bitsize > 1 && ty.is_integral() && bytesize as u32 == ty.get_size() {
diff --git a/src/context.rs b/src/context.rs
index ff141ad365b..1d029811dfe 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -118,14 +118,15 @@ pub struct CodegenCx<'gcc, 'tcx> {
     /// A counter that is used for generating local symbol names
     local_gen_sym_counter: Cell<usize>,
 
-    eh_personality: Cell<Option<RValue<'gcc>>>,
+    eh_personality: Cell<Option<Function<'gcc>>>,
     #[cfg(feature = "master")]
     pub rust_try_fn: Cell<Option<(Type<'gcc>, Function<'gcc>)>>,
 
     pub pointee_infos: RefCell<FxHashMap<(Ty<'tcx>, Size), Option<PointeeInfo>>>,
 
     /// NOTE: a hack is used because the rustc API is not suitable to libgccjit and as such,
-    /// `const_undef()` returns struct as pointer so that they can later be assigned a value.
+    /// `const_undef()` returns struct as pointer so that they can later be assigned a value (in
+    /// e.g. Builder::insert_value).
     /// As such, this set remembers which of these pointers were returned by this function so that
     /// they can be dereferenced later.
     /// FIXME(antoyo): fix the rustc API to avoid having this hack.
@@ -155,6 +156,13 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
                 .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(rust_type))
                 .unwrap();
             let align = layout.align.abi.bytes();
+            // For types with size 1, the alignment can be 1 and only 1
+            // So, we can skip the call to ``get_aligned`.
+            // In the future, we can add a GCC API to query the type align,
+            // and call `get_aligned` if and only if that differs from Rust's expectations.
+            if layout.size.bytes() == 1 {
+                return context.new_c_type(ctype);
+            }
             #[cfg(feature = "master")]
             {
                 context.new_c_type(ctype).get_aligned(align)
@@ -373,8 +381,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
 impl<'gcc, 'tcx> BackendTypes for CodegenCx<'gcc, 'tcx> {
     type Value = RValue<'gcc>;
     type Metadata = RValue<'gcc>;
-    // TODO(antoyo): change to Function<'gcc>.
-    type Function = RValue<'gcc>;
+    type Function = Function<'gcc>;
 
     type BasicBlock = Block<'gcc>;
     type Type = Type<'gcc>;
@@ -392,11 +399,10 @@ impl<'gcc, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         &self.vtables
     }
 
-    fn get_fn(&self, instance: Instance<'tcx>) -> RValue<'gcc> {
+    fn get_fn(&self, instance: Instance<'tcx>) -> Function<'gcc> {
         let func = get_fn(self, instance);
         *self.current_func.borrow_mut() = Some(func);
-        // FIXME(antoyo): this is a wrong cast. That requires changing the compiler API.
-        unsafe { std::mem::transmute(func) }
+        func
     }
 
     fn get_fn_addr(&self, instance: Instance<'tcx>) -> RValue<'gcc> {
@@ -420,7 +426,7 @@ impl<'gcc, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         ptr
     }
 
-    fn eh_personality(&self) -> RValue<'gcc> {
+    fn eh_personality(&self) -> Function<'gcc> {
         // The exception handling personality function.
         //
         // If our compilation unit has the `eh_personality` lang item somewhere
@@ -458,9 +464,7 @@ impl<'gcc, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                 let symbol_name = tcx.symbol_name(instance).name;
                 let fn_abi = self.fn_abi_of_instance(instance, ty::List::empty());
                 self.linkage.set(FunctionType::Extern);
-                let func = self.declare_fn(symbol_name, fn_abi);
-                let func: RValue<'gcc> = unsafe { std::mem::transmute(func) };
-                func
+                self.declare_fn(symbol_name, fn_abi)
             }
             _ => {
                 let name = if wants_msvc_seh(self.sess()) {
@@ -468,8 +472,7 @@ impl<'gcc, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                 } else {
                     "rust_eh_personality"
                 };
-                let func = self.declare_func(name, self.type_i32(), &[], true);
-                unsafe { std::mem::transmute::<Function<'gcc>, RValue<'gcc>>(func) }
+                self.declare_func(name, self.type_i32(), &[], true)
             }
         };
         // TODO(antoyo): apply target cpu attributes.
@@ -481,11 +484,11 @@ impl<'gcc, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         self.tcx.sess
     }
 
-    fn set_frame_pointer_type(&self, _llfn: RValue<'gcc>) {
+    fn set_frame_pointer_type(&self, _llfn: Function<'gcc>) {
         // TODO(antoyo)
     }
 
-    fn apply_target_cpu_attr(&self, _llfn: RValue<'gcc>) {
+    fn apply_target_cpu_attr(&self, _llfn: Function<'gcc>) {
         // TODO(antoyo)
     }
 
diff --git a/src/debuginfo.rs b/src/debuginfo.rs
index 3a265fbc64f..4c8585192a1 100644
--- a/src/debuginfo.rs
+++ b/src/debuginfo.rs
@@ -1,7 +1,7 @@
 use std::ops::Range;
 use std::sync::Arc;
 
-use gccjit::{Location, RValue};
+use gccjit::{Function, Location, RValue};
 use rustc_abi::Size;
 use rustc_codegen_ssa::mir::debuginfo::{DebugScope, FunctionDebugContext, VariableKind};
 use rustc_codegen_ssa::traits::{DebugInfoBuilderMethods, DebugInfoCodegenMethods};
@@ -221,7 +221,7 @@ impl<'gcc, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         &self,
         instance: Instance<'tcx>,
         fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
-        llfn: RValue<'gcc>,
+        llfn: Function<'gcc>,
         mir: &mir::Body<'tcx>,
     ) -> Option<FunctionDebugContext<'tcx, Self::DIScope, Self::DILocation>> {
         if self.sess().opts.debuginfo == DebugInfo::None {
@@ -272,7 +272,7 @@ impl<'gcc, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         &self,
         _instance: Instance<'tcx>,
         _fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
-        _maybe_definition_llfn: Option<RValue<'gcc>>,
+        _maybe_definition_llfn: Option<Function<'gcc>>,
     ) -> Self::DIScope {
         // TODO(antoyo): implement.
     }
diff --git a/src/declare.rs b/src/declare.rs
index bed82073e2c..691fd8729e3 100644
--- a/src/declare.rs
+++ b/src/declare.rs
@@ -94,7 +94,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         _fn_type: Type<'gcc>,
         #[cfg(feature = "master")] callconv: Option<FnAttribute<'gcc>>,
         #[cfg(not(feature = "master"))] callconv: Option<()>,
-    ) -> RValue<'gcc> {
+    ) -> Function<'gcc> {
         // TODO(antoyo): use the fn_type parameter.
         let const_string = self.context.new_type::<u8>().make_pointer().make_pointer();
         let return_type = self.type_i32();
@@ -111,8 +111,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         // NOTE: it is needed to set the current_func here as well, because get_fn() is not called
         // for the main function.
         *self.current_func.borrow_mut() = Some(func);
-        // FIXME(antoyo): this is a wrong cast. That requires changing the compiler API.
-        unsafe { std::mem::transmute(func) }
+        func
     }
 
     pub fn declare_fn(&self, name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> Function<'gcc> {
diff --git a/src/intrinsic/mod.rs b/src/intrinsic/mod.rs
index 09132c34aae..4c10380fe74 100644
--- a/src/intrinsic/mod.rs
+++ b/src/intrinsic/mod.rs
@@ -4,7 +4,9 @@ mod simd;
 #[cfg(feature = "master")]
 use std::iter;
 
-use gccjit::{ComparisonOp, Function, FunctionType, RValue, ToRValue, Type, UnaryOp};
+#[cfg(feature = "master")]
+use gccjit::Type;
+use gccjit::{ComparisonOp, Function, FunctionType, RValue, ToRValue, UnaryOp};
 #[cfg(feature = "master")]
 use rustc_abi::ExternAbi;
 use rustc_abi::{BackendRepr, HasDataLayout};
@@ -300,6 +302,8 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
         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
+        // 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));
@@ -441,7 +445,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                 match int_type_width_signed(args[0].layout.ty, self) {
                     Some((width, signed)) => match name {
                         sym::ctlz | sym::cttz => {
-                            let func = self.current_func.borrow().expect("func");
+                            let func = self.current_func();
                             let then_block = func.new_block("then");
                             let else_block = func.new_block("else");
                             let after_block = func.new_block("after");
@@ -1109,7 +1113,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         // for (int counter = 0; value != 0; counter++) {
         //     value &= value - 1;
         // }
-        let func = self.current_func.borrow().expect("func");
+        let func = self.current_func();
         let loop_head = func.new_block("head");
         let loop_body = func.new_block("body");
         let loop_tail = func.new_block("tail");
@@ -1188,7 +1192,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         let result_type = lhs.get_type();
         if signed {
             // Based on algorithm from: https://stackoverflow.com/a/56531252/389119
-            let func = self.current_func.borrow().expect("func");
+            let func = self.current_func();
             let res = func.new_local(self.location, result_type, "saturating_sum");
             let supports_native_type = self.is_native_int_type(result_type);
             let overflow = if supports_native_type {
@@ -1259,7 +1263,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         let result_type = lhs.get_type();
         if signed {
             // Based on algorithm from: https://stackoverflow.com/a/56531252/389119
-            let func = self.current_func.borrow().expect("func");
+            let func = self.current_func();
             let res = func.new_local(self.location, result_type, "saturating_diff");
             let supports_native_type = self.is_native_int_type(result_type);
             let overflow = if supports_native_type {
@@ -1483,10 +1487,9 @@ fn gen_fn<'a, 'gcc, 'tcx>(
     // FIXME(eddyb) find a nicer way to do this.
     cx.linkage.set(FunctionType::Internal);
     let func = cx.declare_fn(name, fn_abi);
-    let func_val = unsafe { std::mem::transmute::<Function<'gcc>, RValue<'gcc>>(func) };
-    cx.set_frame_pointer_type(func_val);
-    cx.apply_target_cpu_attr(func_val);
-    let block = Builder::append_block(cx, func_val, "entry-block");
+    cx.set_frame_pointer_type(func);
+    cx.apply_target_cpu_attr(func);
+    let block = Builder::append_block(cx, func, "entry-block");
     let bx = Builder::build(cx, block);
     codegen(bx);
     (return_type, func)
diff --git a/tests/failing-ui-tests.txt b/tests/failing-ui-tests.txt
index d931f0d3b5e..544d0bfc710 100644
--- a/tests/failing-ui-tests.txt
+++ b/tests/failing-ui-tests.txt
@@ -9,6 +9,7 @@ tests/ui/iterators/iter-sum-overflow-debug.rs
 tests/ui/iterators/iter-sum-overflow-overflow-checks.rs
 tests/ui/mir/mir_drop_order.rs
 tests/ui/mir/mir_let_chains_drop_order.rs
+tests/ui/mir/mir_match_guard_let_chains_drop_order.rs
 tests/ui/oom_unwind.rs
 tests/ui/panic-runtime/abort-link-to-unwinding-crates.rs
 tests/ui/panic-runtime/abort.rs
-- 
cgit 1.4.1-3-g733a5


From 5a29dddfdd47f1f37b6e6e38e77a4b0f94f007d6 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 28 Jun 2025 23:50:00 +0200
Subject: Remove unwanted semi-colon in `rustc_codegen_gcc`

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

diff --git a/src/builder.rs b/src/builder.rs
index a4454cd9c73..805f68cd74c 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -1610,7 +1610,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
 
     fn filter_landing_pad(&mut self, pers_fn: Function<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
         // TODO(antoyo): generate the correct landing pad
-        self.cleanup_landing_pad(pers_fn);
+        self.cleanup_landing_pad(pers_fn)
     }
 
     #[cfg(feature = "master")]
-- 
cgit 1.4.1-3-g733a5


From 2359b6bd91631d5d0489109743093056e149ed82 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 29 Jun 2025 00:00:58 +0200
Subject: Fix signature of `filter_landing_pad`

---
 src/builder.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/builder.rs b/src/builder.rs
index 805f68cd74c..7f16d804103 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -1608,9 +1608,9 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         (value1, value2)
     }
 
-    fn filter_landing_pad(&mut self, pers_fn: Function<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
+    fn filter_landing_pad(&mut self, pers_fn: Function<'gcc>) -> () {
         // TODO(antoyo): generate the correct landing pad
-        self.cleanup_landing_pad(pers_fn)
+        self.cleanup_landing_pad(pers_fn);
     }
 
     #[cfg(feature = "master")]
-- 
cgit 1.4.1-3-g733a5


From 6e635990da9ceabfbd67d1d129e45879be97813d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 28 Jun 2025 15:20:33 +0200
Subject: give Pointer::into_parts a more scary name and offer a safer
 alternative

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

diff --git a/src/common.rs b/src/common.rs
index 58ff2f1f8f0..cc077059dba 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -261,7 +261,7 @@ impl<'gcc, 'tcx> ConstCodegenMethods for CodegenCx<'gcc, 'tcx> {
                 }
             }
             Scalar::Ptr(ptr, _size) => {
-                let (prov, offset) = ptr.into_parts(); // we know the `offset` is relative
+                let (prov, offset) = ptr.prov_and_relative_offset();
                 let alloc_id = prov.alloc_id();
                 let base_addr = match self.tcx.global_alloc(alloc_id) {
                     GlobalAlloc::Memory(alloc) => {
-- 
cgit 1.4.1-3-g733a5


From a7715a44b8b48dc74c530d121ec50399f26d5e22 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 29 Jun 2025 00:20:15 +0200
Subject: Remove `()` returned value

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

diff --git a/src/builder.rs b/src/builder.rs
index 7f16d804103..1fce547ad1b 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -1608,7 +1608,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         (value1, value2)
     }
 
-    fn filter_landing_pad(&mut self, pers_fn: Function<'gcc>) -> () {
+    fn filter_landing_pad(&mut self, pers_fn: Function<'gcc>) {
         // TODO(antoyo): generate the correct landing pad
         self.cleanup_landing_pad(pers_fn);
     }
-- 
cgit 1.4.1-3-g733a5


From 76b9fbf5b2641c77c1d6ae8b3d86ce087c99ab9e Mon Sep 17 00:00:00 2001
From: quaternic <57393910+quaternic@users.noreply.github.com>
Date: Sun, 29 Jun 2025 06:53:07 +0300
Subject: apply suggestions for clippy::manual_is_multiple_of in libm-test

---
 library/compiler-builtins/libm-test/tests/z_extensive/run.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/compiler-builtins/libm-test/tests/z_extensive/run.rs b/library/compiler-builtins/libm-test/tests/z_extensive/run.rs
index f2ba6a4a0e3..e04e00c6d74 100644
--- a/library/compiler-builtins/libm-test/tests/z_extensive/run.rs
+++ b/library/compiler-builtins/libm-test/tests/z_extensive/run.rs
@@ -197,15 +197,15 @@ impl Progress {
 
     fn update(&self, completed: u64, input: impl fmt::Debug) {
         // Infrequently update the progress bar.
-        if completed % 20_000 == 0 {
+        if completed.is_multiple_of(20_000) {
             self.pb.set_position(completed);
         }
 
-        if completed % 500_000 == 0 {
+        if completed.is_multiple_of(500_000) {
             self.pb.set_message(format!("input: {input:<24?}"));
         }
 
-        if !self.is_tty && completed % 5_000_000 == 0 {
+        if !self.is_tty && completed.is_multiple_of(5_000_000) {
             let len = self.pb.length().unwrap_or_default();
             eprintln!(
                 "[{elapsed:3?}s {percent:3.0}%] {name} \
-- 
cgit 1.4.1-3-g733a5


From ad7de948a871d7f11bcb62b4c301506de620085d Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Sun, 29 Jun 2025 11:08:12 +0200
Subject: Consider deref'ed argument as non-temporary

If there are more than one dereference (there is one corresponding
matched with a borrow in any case), consider that the argument might
point to a place expression, which is the safest choice.

Also, use an appropriate number of dereferences in suggestions involving
arguments using themselves multiple dereferences.
---
 clippy_lints/src/methods/swap_with_temporary.rs | 52 ++++++++++++++++++-------
 tests/ui/swap_with_temporary.fixed              | 46 ++++++++++++++++++++++
 tests/ui/swap_with_temporary.rs                 | 46 ++++++++++++++++++++++
 tests/ui/swap_with_temporary.stderr             | 38 +++++++++++++++++-
 4 files changed, 166 insertions(+), 16 deletions(-)

diff --git a/clippy_lints/src/methods/swap_with_temporary.rs b/clippy_lints/src/methods/swap_with_temporary.rs
index de729fb343a..e378cbd6ae0 100644
--- a/clippy_lints/src/methods/swap_with_temporary.rs
+++ b/clippy_lints/src/methods/swap_with_temporary.rs
@@ -4,6 +4,7 @@ use rustc_ast::BorrowKind;
 use rustc_errors::{Applicability, Diag};
 use rustc_hir::{Expr, ExprKind, Node, QPath};
 use rustc_lint::LateContext;
+use rustc_middle::ty::adjustment::Adjust;
 use rustc_span::sym;
 
 use super::SWAP_WITH_TEMPORARY;
@@ -11,12 +12,12 @@ use super::SWAP_WITH_TEMPORARY;
 const MSG_TEMPORARY: &str = "this expression returns a temporary value";
 const MSG_TEMPORARY_REFMUT: &str = "this is a mutable reference to a temporary value";
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, func: &Expr<'_>, args: &[Expr<'_>]) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, func: &Expr<'_>, args: &'tcx [Expr<'_>]) {
     if let ExprKind::Path(QPath::Resolved(_, func_path)) = func.kind
         && let Some(func_def_id) = func_path.res.opt_def_id()
         && cx.tcx.is_diagnostic_item(sym::mem_swap, func_def_id)
     {
-        match (ArgKind::new(&args[0]), ArgKind::new(&args[1])) {
+        match (ArgKind::new(cx, &args[0]), ArgKind::new(cx, &args[1])) {
             (ArgKind::RefMutToTemp(left_temp), ArgKind::RefMutToTemp(right_temp)) => {
                 emit_lint_useless(cx, expr, &args[0], &args[1], left_temp, right_temp);
             },
@@ -28,10 +29,10 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, func: &Expr<'_>, args
 }
 
 enum ArgKind<'tcx> {
-    // Mutable reference to a place, coming from a macro
-    RefMutToPlaceAsMacro(&'tcx Expr<'tcx>),
-    // Place behind a mutable reference
-    RefMutToPlace(&'tcx Expr<'tcx>),
+    // Mutable reference to a place, coming from a macro, and number of dereferences to use
+    RefMutToPlaceAsMacro(&'tcx Expr<'tcx>, usize),
+    // Place behind a mutable reference, and number of dereferences to use
+    RefMutToPlace(&'tcx Expr<'tcx>, usize),
     // Temporary value behind a mutable reference
     RefMutToTemp(&'tcx Expr<'tcx>),
     // Any other case
@@ -39,13 +40,29 @@ enum ArgKind<'tcx> {
 }
 
 impl<'tcx> ArgKind<'tcx> {
-    fn new(arg: &'tcx Expr<'tcx>) -> Self {
-        if let ExprKind::AddrOf(BorrowKind::Ref, _, target) = arg.kind {
-            if target.is_syntactic_place_expr() {
+    /// Build a new `ArgKind` from `arg`. There must be no false positive when returning a
+    /// `ArgKind::RefMutToTemp` variant, as this may cause a spurious lint to be emitted.
+    fn new(cx: &LateContext<'tcx>, arg: &'tcx Expr<'tcx>) -> Self {
+        if let ExprKind::AddrOf(BorrowKind::Ref, _, target) = arg.kind
+            && let adjustments = cx.typeck_results().expr_adjustments(arg)
+            && adjustments
+                .first()
+                .is_some_and(|adj| matches!(adj.kind, Adjust::Deref(None)))
+            && adjustments
+                .last()
+                .is_some_and(|adj| matches!(adj.kind, Adjust::Borrow(_)))
+        {
+            let extra_derefs = adjustments[1..adjustments.len() - 1]
+                .iter()
+                .filter(|adj| matches!(adj.kind, Adjust::Deref(_)))
+                .count();
+            // If a deref is used, `arg` might be a place expression. For example, a mutex guard
+            // would dereference into the mutex content which is probably not temporary.
+            if target.is_syntactic_place_expr() || extra_derefs > 0 {
                 if arg.span.from_expansion() {
-                    ArgKind::RefMutToPlaceAsMacro(arg)
+                    ArgKind::RefMutToPlaceAsMacro(arg, extra_derefs)
                 } else {
-                    ArgKind::RefMutToPlace(target)
+                    ArgKind::RefMutToPlace(target, extra_derefs)
                 }
             } else {
                 ArgKind::RefMutToTemp(target)
@@ -106,10 +123,15 @@ fn emit_lint_assign(cx: &LateContext<'_>, expr: &Expr<'_>, target: &ArgKind<'_>,
                 let mut applicability = Applicability::MachineApplicable;
                 let ctxt = expr.span.ctxt();
                 let assign_target = match target {
-                    ArgKind::Expr(target) | ArgKind::RefMutToPlaceAsMacro(target) => {
-                        Sugg::hir_with_context(cx, target, ctxt, "_", &mut applicability).deref()
-                    },
-                    ArgKind::RefMutToPlace(target) => Sugg::hir_with_context(cx, target, ctxt, "_", &mut applicability),
+                    ArgKind::Expr(target) => Sugg::hir_with_context(cx, target, ctxt, "_", &mut applicability).deref(),
+                    ArgKind::RefMutToPlaceAsMacro(arg, derefs) => (0..*derefs).fold(
+                        Sugg::hir_with_context(cx, arg, ctxt, "_", &mut applicability).deref(),
+                        |sugg, _| sugg.deref(),
+                    ),
+                    ArgKind::RefMutToPlace(target, derefs) => (0..*derefs).fold(
+                        Sugg::hir_with_context(cx, target, ctxt, "_", &mut applicability),
+                        |sugg, _| sugg.deref(),
+                    ),
                     ArgKind::RefMutToTemp(_) => unreachable!(),
                 };
                 let assign_source = Sugg::hir_with_context(cx, temp, ctxt, "_", &mut applicability);
diff --git a/tests/ui/swap_with_temporary.fixed b/tests/ui/swap_with_temporary.fixed
index 4007d998ba0..4b4b0d4aebd 100644
--- a/tests/ui/swap_with_temporary.fixed
+++ b/tests/ui/swap_with_temporary.fixed
@@ -72,3 +72,49 @@ fn dont_lint_those(s: &mut S, v: &mut [String], w: Option<&mut String>) {
     swap(&mut s.t, v.get_mut(0).unwrap());
     swap(w.unwrap(), &mut s.t);
 }
+
+fn issue15166() {
+    use std::sync::Mutex;
+
+    struct A {
+        thing: Mutex<Vec<u8>>,
+    }
+
+    impl A {
+        fn a(&self) {
+            let mut new_vec = vec![42];
+            // Do not lint here, as neither `new_vec` nor the result of `.lock().unwrap()` are temporaries
+            swap(&mut new_vec, &mut self.thing.lock().unwrap());
+            for v in new_vec {
+                // Do something with v
+            }
+            // Here `vec![42]` is temporary though, and a proper dereference will have to be used in the fix
+            *self.thing.lock().unwrap() = vec![42];
+            //~^ ERROR: swapping with a temporary value is inefficient
+        }
+    }
+}
+
+fn multiple_deref() {
+    let mut v1 = &mut &mut &mut vec![42];
+    ***v1 = vec![];
+    //~^ ERROR: swapping with a temporary value is inefficient
+
+    struct Wrapper<T: ?Sized>(T);
+    impl<T: ?Sized> std::ops::Deref for Wrapper<T> {
+        type Target = T;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    impl<T: ?Sized> std::ops::DerefMut for Wrapper<T> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+
+    use std::sync::Mutex;
+    let mut v1 = Mutex::new(Wrapper(Wrapper(vec![42])));
+    ***v1.lock().unwrap() = vec![];
+    //~^ ERROR: swapping with a temporary value is inefficient
+}
diff --git a/tests/ui/swap_with_temporary.rs b/tests/ui/swap_with_temporary.rs
index d403c086c0f..8e35e6144d9 100644
--- a/tests/ui/swap_with_temporary.rs
+++ b/tests/ui/swap_with_temporary.rs
@@ -72,3 +72,49 @@ fn dont_lint_those(s: &mut S, v: &mut [String], w: Option<&mut String>) {
     swap(&mut s.t, v.get_mut(0).unwrap());
     swap(w.unwrap(), &mut s.t);
 }
+
+fn issue15166() {
+    use std::sync::Mutex;
+
+    struct A {
+        thing: Mutex<Vec<u8>>,
+    }
+
+    impl A {
+        fn a(&self) {
+            let mut new_vec = vec![42];
+            // Do not lint here, as neither `new_vec` nor the result of `.lock().unwrap()` are temporaries
+            swap(&mut new_vec, &mut self.thing.lock().unwrap());
+            for v in new_vec {
+                // Do something with v
+            }
+            // Here `vec![42]` is temporary though, and a proper dereference will have to be used in the fix
+            swap(&mut vec![42], &mut self.thing.lock().unwrap());
+            //~^ ERROR: swapping with a temporary value is inefficient
+        }
+    }
+}
+
+fn multiple_deref() {
+    let mut v1 = &mut &mut &mut vec![42];
+    swap(&mut ***v1, &mut vec![]);
+    //~^ ERROR: swapping with a temporary value is inefficient
+
+    struct Wrapper<T: ?Sized>(T);
+    impl<T: ?Sized> std::ops::Deref for Wrapper<T> {
+        type Target = T;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+    impl<T: ?Sized> std::ops::DerefMut for Wrapper<T> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.0
+        }
+    }
+
+    use std::sync::Mutex;
+    let mut v1 = Mutex::new(Wrapper(Wrapper(vec![42])));
+    swap(&mut vec![], &mut v1.lock().unwrap());
+    //~^ ERROR: swapping with a temporary value is inefficient
+}
diff --git a/tests/ui/swap_with_temporary.stderr b/tests/ui/swap_with_temporary.stderr
index 59355771a96..5ca4fccd37a 100644
--- a/tests/ui/swap_with_temporary.stderr
+++ b/tests/ui/swap_with_temporary.stderr
@@ -96,5 +96,41 @@ note: this expression returns a temporary value
 LL |     swap(mac!(refmut y), &mut func());
    |                               ^^^^^^
 
-error: aborting due to 8 previous errors
+error: swapping with a temporary value is inefficient
+  --> tests/ui/swap_with_temporary.rs:92:13
+   |
+LL |             swap(&mut vec![42], &mut self.thing.lock().unwrap());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use assignment instead: `*self.thing.lock().unwrap() = vec![42]`
+   |
+note: this expression returns a temporary value
+  --> tests/ui/swap_with_temporary.rs:92:23
+   |
+LL |             swap(&mut vec![42], &mut self.thing.lock().unwrap());
+   |                       ^^^^^^^^
+
+error: swapping with a temporary value is inefficient
+  --> tests/ui/swap_with_temporary.rs:100:5
+   |
+LL |     swap(&mut ***v1, &mut vec![]);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use assignment instead: `***v1 = vec![]`
+   |
+note: this expression returns a temporary value
+  --> tests/ui/swap_with_temporary.rs:100:27
+   |
+LL |     swap(&mut ***v1, &mut vec![]);
+   |                           ^^^^^^
+
+error: swapping with a temporary value is inefficient
+  --> tests/ui/swap_with_temporary.rs:118:5
+   |
+LL |     swap(&mut vec![], &mut v1.lock().unwrap());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use assignment instead: `***v1.lock().unwrap() = vec![]`
+   |
+note: this expression returns a temporary value
+  --> tests/ui/swap_with_temporary.rs:118:15
+   |
+LL |     swap(&mut vec![], &mut v1.lock().unwrap());
+   |               ^^^^^^
+
+error: aborting due to 11 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From ff3c9c15b7ae8a0ef7b4079b1c39ebb3a3bdbedb Mon Sep 17 00:00:00 2001
From: itsjunetime <junewelker@gmail.com>
Date: Sun, 29 Jun 2025 10:54:13 -0600
Subject: `missing_panics_doc`: Correctly distinguish maybe-const vs
 always-const contexts for missing_panics_doc

changelog: [`missing_panics_doc`]: Allow unwrap() and expect()s in const-only contexts
---
 clippy_lints/src/doc/missing_headers.rs |  7 ++++--
 tests/ui/missing_panics_doc.rs          | 28 ++++++++++++++++++++++++
 tests/ui/missing_panics_doc.stderr      | 38 ++++++++++++++++++++++++++++++++-
 3 files changed, 70 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/doc/missing_headers.rs b/clippy_lints/src/doc/missing_headers.rs
index 9ee32fced8c..3033ac0d0b0 100644
--- a/clippy_lints/src/doc/missing_headers.rs
+++ b/clippy_lints/src/doc/missing_headers.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
 use clippy_utils::macros::{is_panic, root_macro_call_first_node};
 use clippy_utils::ty::{get_type_diagnostic_name, implements_trait_with_env, is_type_diagnostic_item};
 use clippy_utils::visitors::for_each_expr;
-use clippy_utils::{fulfill_or_allowed, is_doc_hidden, method_chain_args, return_ty};
+use clippy_utils::{fulfill_or_allowed, is_doc_hidden, is_inside_always_const_context, method_chain_args, return_ty};
 use rustc_hir::{BodyId, FnSig, OwnerId, Safety};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
@@ -99,13 +99,16 @@ fn find_panic(cx: &LateContext<'_>, body_id: BodyId) -> Option<Span> {
     let mut panic_span = None;
     let typeck = cx.tcx.typeck_body(body_id);
     for_each_expr(cx, cx.tcx.hir_body(body_id), |expr| {
+        if is_inside_always_const_context(cx.tcx, expr.hir_id) {
+            return ControlFlow::<!>::Continue(());
+        }
+
         if let Some(macro_call) = root_macro_call_first_node(cx, expr)
             && (is_panic(cx, macro_call.def_id)
                 || matches!(
                     cx.tcx.get_diagnostic_name(macro_call.def_id),
                     Some(sym::assert_macro | sym::assert_eq_macro | sym::assert_ne_macro)
                 ))
-            && !cx.tcx.hir_is_inside_const_context(expr.hir_id)
             && !fulfill_or_allowed(cx, MISSING_PANICS_DOC, [expr.hir_id])
             && panic_span.is_none()
         {
diff --git a/tests/ui/missing_panics_doc.rs b/tests/ui/missing_panics_doc.rs
index ffdae8504f7..d016e099e30 100644
--- a/tests/ui/missing_panics_doc.rs
+++ b/tests/ui/missing_panics_doc.rs
@@ -250,3 +250,31 @@ pub fn issue_12760<const N: usize>() {
         }
     }
 }
+
+/// This needs documenting
+pub fn unwrap_expect_etc_in_const() {
+    let a = const { std::num::NonZeroUsize::new(1).unwrap() };
+    // This should still pass the lint even if it is guaranteed to panic at compile-time
+    let b = const { std::num::NonZeroUsize::new(0).unwrap() };
+}
+
+/// This needs documenting
+pub const fn unwrap_expect_etc_in_const_fn_fails() {
+    //~^ missing_panics_doc
+    let a = std::num::NonZeroUsize::new(1).unwrap();
+}
+
+/// This needs documenting
+pub const fn assert_in_const_fn_fails() {
+    //~^ missing_panics_doc
+    let x = 0;
+    if x == 0 {
+        panic!();
+    }
+}
+
+/// This needs documenting
+pub const fn in_const_fn<const N: usize>(n: usize) {
+    //~^ missing_panics_doc
+    assert!(N > n);
+}
diff --git a/tests/ui/missing_panics_doc.stderr b/tests/ui/missing_panics_doc.stderr
index 7f0acf8de9b..85a00914427 100644
--- a/tests/ui/missing_panics_doc.stderr
+++ b/tests/ui/missing_panics_doc.stderr
@@ -180,5 +180,41 @@ note: first possible panic found here
 LL |         *v.last().expect("passed an empty thing")
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 15 previous errors
+error: docs for function which may panic missing `# Panics` section
+  --> tests/ui/missing_panics_doc.rs:262:1
+   |
+LL | pub const fn unwrap_expect_etc_in_const_fn_fails() {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: first possible panic found here
+  --> tests/ui/missing_panics_doc.rs:264:13
+   |
+LL |     let a = std::num::NonZeroUsize::new(1).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: docs for function which may panic missing `# Panics` section
+  --> tests/ui/missing_panics_doc.rs:268:1
+   |
+LL | pub const fn assert_in_const_fn_fails() {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: first possible panic found here
+  --> tests/ui/missing_panics_doc.rs:272:9
+   |
+LL |         panic!();
+   |         ^^^^^^^^
+
+error: docs for function which may panic missing `# Panics` section
+  --> tests/ui/missing_panics_doc.rs:277:1
+   |
+LL | pub const fn in_const_fn<const N: usize>(n: usize) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: first possible panic found here
+  --> tests/ui/missing_panics_doc.rs:279:5
+   |
+LL |     assert!(N > n);
+   |     ^^^^^^^^^^^^^^
+
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 9cba70b2838a2c3d6fe9bbe9eb4a5c6a8f4dda92 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Sat, 28 Jun 2025 22:12:01 +0800
Subject: fix: `cast_possible_truncation` should not suggest inside const
 context

---
 clippy_lints/src/casts/cast_possible_truncation.rs |  6 ++++--
 tests/ui/cast_size.32bit.stderr                    | 10 +++++++++-
 tests/ui/cast_size.64bit.stderr                    | 10 +++++++++-
 tests/ui/cast_size.rs                              |  6 ++++++
 4 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index a2ecb5fb44a..2eebe849232 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::source::snippet;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{get_discriminant_value, is_isize_or_usize};
-use clippy_utils::{expr_or_init, sym};
+use clippy_utils::{expr_or_init, is_in_const_context, sym};
 use rustc_abi::IntegerType;
 use rustc_errors::{Applicability, Diag};
 use rustc_hir::def::{DefKind, Res};
@@ -168,7 +168,9 @@ pub(super) fn check(
 
     span_lint_and_then(cx, CAST_POSSIBLE_TRUNCATION, expr.span, msg, |diag| {
         diag.help("if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...");
-        if !cast_from.is_floating_point() {
+        // TODO: Remove the condition for const contexts when `try_from` and other commonly used methods
+        // become const fn.
+        if !is_in_const_context(cx) && !cast_from.is_floating_point() {
             offer_suggestion(cx, expr, cast_expr, cast_to_span, diag);
         }
     });
diff --git a/tests/ui/cast_size.32bit.stderr b/tests/ui/cast_size.32bit.stderr
index cb1620e36a2..5811cb3607b 100644
--- a/tests/ui/cast_size.32bit.stderr
+++ b/tests/ui/cast_size.32bit.stderr
@@ -177,6 +177,14 @@ error: casting `usize` to `f64` causes a loss of precision on targets with 64-bi
 LL |     9_999_999_999_999_999usize as f64;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: casting `usize` to `u16` may truncate the value
+  --> tests/ui/cast_size.rs:71:20
+   |
+LL |     const N: u16 = M as u16;
+   |                    ^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+
 error: literal out of range for `usize`
   --> tests/ui/cast_size.rs:63:5
    |
@@ -186,5 +194,5 @@ LL |     9_999_999_999_999_999usize as f64;
    = note: the literal `9_999_999_999_999_999usize` does not fit into the type `usize` whose range is `0..=4294967295`
    = note: `#[deny(overflowing_literals)]` on by default
 
-error: aborting due to 19 previous errors
+error: aborting due to 20 previous errors
 
diff --git a/tests/ui/cast_size.64bit.stderr b/tests/ui/cast_size.64bit.stderr
index b6000a52abb..ba1419583ae 100644
--- a/tests/ui/cast_size.64bit.stderr
+++ b/tests/ui/cast_size.64bit.stderr
@@ -177,5 +177,13 @@ error: casting `usize` to `f64` causes a loss of precision on targets with 64-bi
 LL |     9_999_999_999_999_999usize as f64;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 18 previous errors
+error: casting `usize` to `u16` may truncate the value
+  --> tests/ui/cast_size.rs:71:20
+   |
+LL |     const N: u16 = M as u16;
+   |                    ^^^^^^^^
+   |
+   = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
+
+error: aborting due to 19 previous errors
 
diff --git a/tests/ui/cast_size.rs b/tests/ui/cast_size.rs
index e5bef2a99d5..ecc58669419 100644
--- a/tests/ui/cast_size.rs
+++ b/tests/ui/cast_size.rs
@@ -65,3 +65,9 @@ fn main() {
     //~[32bit]^^ ERROR: literal out of range for `usize`
     // 999_999_999_999_999_999_999_999_999_999u128 as f128;
 }
+
+fn issue15163() {
+    const M: usize = 100;
+    const N: u16 = M as u16;
+    //~^ cast_possible_truncation
+}
-- 
cgit 1.4.1-3-g733a5


From f1d6f48e9133f73277e096ed667820e584d021eb Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Sat, 21 Jun 2025 11:26:27 +0000
Subject: Stop backends from needing to support nullary intrinsics

---
 example/mini_core_hello_world.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/example/mini_core_hello_world.rs b/example/mini_core_hello_world.rs
index c3bd62e5897..6b6f71edaf8 100644
--- a/example/mini_core_hello_world.rs
+++ b/example/mini_core_hello_world.rs
@@ -6,6 +6,7 @@
 )]
 #![no_core]
 #![allow(dead_code, internal_features, non_camel_case_types)]
+#![rustfmt::skip]
 
 extern crate mini_core;
 
@@ -197,10 +198,10 @@ fn main() {
         assert_eq!(intrinsics::align_of::<u16>() as u8, 2);
         assert_eq!(intrinsics::align_of_val(&a) as u8, intrinsics::align_of::<&str>() as u8);
 
-        assert!(!intrinsics::needs_drop::<u8>());
-        assert!(!intrinsics::needs_drop::<[u8]>());
-        assert!(intrinsics::needs_drop::<NoisyDrop>());
-        assert!(intrinsics::needs_drop::<NoisyDropUnsized>());
+        assert!(!const { intrinsics::needs_drop::<u8>() });
+        assert!(!const { intrinsics::needs_drop::<[u8]>() });
+        assert!(const { intrinsics::needs_drop::<NoisyDrop>() });
+        assert!(const { intrinsics::needs_drop::<NoisyDropUnsized>() });
 
         Unique {
             pointer: 0 as *const &str,
-- 
cgit 1.4.1-3-g733a5


From 383dcd500722ec69292b6075462417e6c9fc03bf Mon Sep 17 00:00:00 2001
From: Young-Flash <dongyang@apache.org>
Date: Sat, 21 Jun 2025 15:44:52 +0800
Subject: feat: support folding multiline arg list & fn body in one folding
 range

---
 .../rust-analyzer/crates/ide/src/folding_ranges.rs | 29 +++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs b/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
index 9bd8504733a..a9072773a1c 100755
--- a/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
@@ -47,6 +47,7 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
     let mut res = vec![];
     let mut visited_comments = FxHashSet::default();
     let mut visited_nodes = FxHashSet::default();
+    let mut merged_fn_bodies = FxHashSet::default();
 
     // regions can be nested, here is a LIFO buffer
     let mut region_starts: Vec<TextSize> = vec![];
@@ -59,6 +60,31 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
                 NodeOrToken::Token(token) => token.text().contains('\n'),
             };
             if is_multiline {
+                // for the arg list, we need to special handle
+                if matches!(element.kind(), ARG_LIST | PARAM_LIST) {
+                    if let NodeOrToken::Node(node) = &element {
+                        if let Some(fn_node) = node.parent().and_then(ast::Fn::cast) {
+                            if let Some(body) = fn_node.body() {
+                                // just add a big fold combine the params and body
+                                res.push(Fold {
+                                    range: TextRange::new(
+                                        node.text_range().start(),
+                                        body.syntax().text_range().end(),
+                                    ),
+                                    kind: FoldKind::ArgList,
+                                });
+                                merged_fn_bodies.insert(body.syntax().text_range());
+                                continue;
+                            }
+                        }
+                    }
+                }
+                // skip the merged function body
+                if matches!(element.kind(), BLOCK_EXPR)
+                    && merged_fn_bodies.contains(&element.text_range())
+                {
+                    continue;
+                }
                 res.push(Fold { range: element.text_range(), kind });
                 continue;
             }
@@ -291,6 +317,7 @@ mod tests {
 
     use super::*;
 
+    #[track_caller]
     fn check(#[rust_analyzer::rust_fixture] ra_fixture: &str) {
         let (ranges, text) = extract_tags(ra_fixture, "fold");
 
@@ -544,7 +571,7 @@ const _: S = S <fold block>{
 fn foo<fold arglist>(
     x: i32,
     y: String,
-)</fold> {}
+) {}</fold>
 "#,
         )
     }
-- 
cgit 1.4.1-3-g733a5


From e0e21dd939dfde5549dccaa638a28710b8cf7ed4 Mon Sep 17 00:00:00 2001
From: Young-Flash <dongyang@apache.org>
Date: Mon, 30 Jun 2025 17:26:20 +0800
Subject: internal: add `FoldKind::Function`

---
 .../rust-analyzer/crates/ide/src/folding_ranges.rs | 28 ++++++++++++----------
 .../crates/rust-analyzer/src/lsp/to_proto.rs       |  3 ++-
 2 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs b/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
index a9072773a1c..7ac160dac2e 100755
--- a/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
@@ -23,6 +23,7 @@ pub enum FoldKind {
     WhereClause,
     ReturnType,
     MatchArm,
+    Function,
     // region: item runs
     Modules,
     Consts,
@@ -60,18 +61,25 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
                 NodeOrToken::Token(token) => token.text().contains('\n'),
             };
             if is_multiline {
-                // for the arg list, we need to special handle
-                if matches!(element.kind(), ARG_LIST | PARAM_LIST) {
+                // for the func with multiline param list
+                if matches!(element.kind(), FN) {
                     if let NodeOrToken::Node(node) = &element {
-                        if let Some(fn_node) = node.parent().and_then(ast::Fn::cast) {
+                        if let Some(fn_node) = ast::Fn::cast(node.clone()) {
+                            if !fn_node
+                                .param_list()
+                                .map(|param_list| param_list.syntax().text().contains_char('\n'))
+                                .unwrap_or(false)
+                            {
+                                continue;
+                            }
+
                             if let Some(body) = fn_node.body() {
-                                // just add a big fold combine the params and body
                                 res.push(Fold {
                                     range: TextRange::new(
                                         node.text_range().start(),
-                                        body.syntax().text_range().end(),
+                                        node.text_range().end(),
                                     ),
-                                    kind: FoldKind::ArgList,
+                                    kind: FoldKind::Function,
                                 });
                                 merged_fn_bodies.insert(body.syntax().text_range());
                                 continue;
@@ -79,12 +87,6 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
                         }
                     }
                 }
-                // skip the merged function body
-                if matches!(element.kind(), BLOCK_EXPR)
-                    && merged_fn_bodies.contains(&element.text_range())
-                {
-                    continue;
-                }
                 res.push(Fold { range: element.text_range(), kind });
                 continue;
             }
@@ -178,6 +180,7 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
         ARG_LIST | PARAM_LIST | GENERIC_ARG_LIST | GENERIC_PARAM_LIST => Some(FoldKind::ArgList),
         ARRAY_EXPR => Some(FoldKind::Array),
         RET_TYPE => Some(FoldKind::ReturnType),
+        FN => Some(FoldKind::Function),
         WHERE_CLAUSE => Some(FoldKind::WhereClause),
         ASSOC_ITEM_LIST
         | RECORD_FIELD_LIST
@@ -349,6 +352,7 @@ mod tests {
                 FoldKind::WhereClause => "whereclause",
                 FoldKind::ReturnType => "returntype",
                 FoldKind::MatchArm => "matcharm",
+                FoldKind::Function => "function",
                 FoldKind::TraitAliases => "traitaliases",
                 FoldKind::ExternCrates => "externcrates",
             };
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
index 8a848fb848c..292be1d5315 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
@@ -911,7 +911,8 @@ pub(crate) fn folding_range(
         | FoldKind::Array
         | FoldKind::TraitAliases
         | FoldKind::ExternCrates
-        | FoldKind::MatchArm => None,
+        | FoldKind::MatchArm
+        | FoldKind::Function => None,
     };
 
     let range = range(line_index, fold.range);
-- 
cgit 1.4.1-3-g733a5


From 594252fdc4a3ec5a3db94df5a2f4697a63e61283 Mon Sep 17 00:00:00 2001
From: Young-Flash <dongyang@apache.org>
Date: Mon, 30 Jun 2025 17:27:07 +0800
Subject: test: add test case for func with multiline param list

---
 .../rust-analyzer/crates/ide/src/folding_ranges.rs  | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs b/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
index 7ac160dac2e..c081796d078 100755
--- a/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
@@ -360,6 +360,23 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_fold_func_with_multiline_param_list() {
+        check(
+            r#"
+<fold function>fn func<fold arglist>(
+    a: i32,
+    b: i32,
+    c: i32,
+)</fold> <fold block>{
+
+
+
+}</fold></fold>
+"#,
+        );
+    }
+
     #[test]
     fn test_fold_comments() {
         check(
@@ -572,10 +589,10 @@ const _: S = S <fold block>{
     fn fold_multiline_params() {
         check(
             r#"
-fn foo<fold arglist>(
+<fold function>fn foo<fold arglist>(
     x: i32,
     y: String,
-) {}</fold>
+)</fold> {}</fold>
 "#,
         )
     }
-- 
cgit 1.4.1-3-g733a5


From 6709720e4c9208519874b50158150a8ce3c1afb1 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 2 Jun 2025 08:59:29 +1000
Subject: Introduce `ByteSymbol`.

It's like `Symbol` but for byte strings. The interner is now used for
both `Symbol` and `ByteSymbol`. E.g. if you intern `"dog"` and `b"dog"`
you'll get a `Symbol` and a `ByteSymbol` with the same index and the
characters will only be stored once.

The motivation for this is to eliminate the `Arc`s in `ast::LitKind`, to
make `ast::LitKind` impl `Copy`, and to avoid the need to arena-allocate
`ast::LitKind` in HIR. The latter change reduces peak memory by a
non-trivial amount on literal-heavy benchmarks such as `deep-vector` and
`tuple-stress`.

`Encoder`, `Decoder`, `SpanEncoder`, and `SpanDecoder` all get some
changes so that they can handle normal strings and byte strings.

This change does slow down compilation of programs that use
`include_bytes!` on large files, because the contents of those files are
now interned (hashed). This makes `include_bytes!` more similar to
`include_str!`, though `include_bytes!` contents still aren't escaped,
and hashing is still much cheaper than escaping.
---
 clippy_lints/src/approx_const.rs                 |  2 +-
 clippy_lints/src/bool_assert_comparison.rs       |  2 +-
 clippy_lints/src/casts/manual_dangling_ptr.rs    |  2 +-
 clippy_lints/src/casts/unnecessary_cast.rs       |  2 +-
 clippy_lints/src/default_numeric_fallback.rs     |  4 ++--
 clippy_lints/src/large_include_file.rs           |  2 +-
 clippy_lints/src/manual_ignore_case_cmp.rs       |  8 ++++----
 clippy_lints/src/manual_strip.rs                 |  2 +-
 clippy_lints/src/matches/match_like_matches.rs   |  2 +-
 clippy_lints/src/matches/match_same_arms.rs      |  8 +++++---
 clippy_lints/src/methods/open_options.rs         |  2 +-
 clippy_lints/src/missing_asserts_for_indexing.rs |  2 +-
 clippy_lints/src/utils/author.rs                 |  2 +-
 clippy_utils/src/consts.rs                       | 12 +++++++-----
 14 files changed, 28 insertions(+), 24 deletions(-)

diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index 852e48cbcae..5ed4c82634a 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -74,7 +74,7 @@ impl ApproxConstant {
 }
 
 impl LateLintPass<'_> for ApproxConstant {
-    fn check_lit(&mut self, cx: &LateContext<'_>, _hir_id: HirId, lit: &Lit, _negated: bool) {
+    fn check_lit(&mut self, cx: &LateContext<'_>, _hir_id: HirId, lit: Lit, _negated: bool) {
         match lit.node {
             LitKind::Float(s, LitFloatType::Suffixed(fty)) => match fty {
                 FloatTy::F16 => self.check_known_consts(cx, lit.span, s, "f16"),
diff --git a/clippy_lints/src/bool_assert_comparison.rs b/clippy_lints/src/bool_assert_comparison.rs
index 8f95e44bf85..581fe33ea0b 100644
--- a/clippy_lints/src/bool_assert_comparison.rs
+++ b/clippy_lints/src/bool_assert_comparison.rs
@@ -42,7 +42,7 @@ fn extract_bool_lit(e: &Expr<'_>) -> Option<bool> {
     }) = e.kind
         && !e.span.from_expansion()
     {
-        Some(*b)
+        Some(b)
     } else {
         None
     }
diff --git a/clippy_lints/src/casts/manual_dangling_ptr.rs b/clippy_lints/src/casts/manual_dangling_ptr.rs
index d9e88d6a401..92910cf8adf 100644
--- a/clippy_lints/src/casts/manual_dangling_ptr.rs
+++ b/clippy_lints/src/casts/manual_dangling_ptr.rs
@@ -46,7 +46,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, from: &Expr<'_>, to:
 fn is_expr_const_aligned(cx: &LateContext<'_>, expr: &Expr<'_>, to: &Ty<'_>) -> bool {
     match expr.kind {
         ExprKind::Call(fun, _) => is_align_of_call(cx, fun, to),
-        ExprKind::Lit(lit) => is_literal_aligned(cx, lit, to),
+        ExprKind::Lit(lit) => is_literal_aligned(cx, &lit, to),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index 010f09d4c1d..c88a0539d70 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -243,7 +243,7 @@ fn lint_unnecessary_cast(
     );
 }
 
-fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<&'e Lit> {
+fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<Lit> {
     match expr.kind {
         ExprKind::Lit(lit) => Some(lit),
         ExprKind::Unary(UnOp::Neg, e) => {
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 784214c29af..1507f1ed305 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -83,7 +83,7 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
     }
 
     /// Check whether a passed literal has potential to cause fallback or not.
-    fn check_lit(&self, lit: &Lit, lit_ty: Ty<'tcx>, emit_hir_id: HirId) {
+    fn check_lit(&self, lit: Lit, lit_ty: Ty<'tcx>, emit_hir_id: HirId) {
         if !lit.span.in_external_macro(self.cx.sess().source_map())
             && matches!(self.ty_bounds.last(), Some(ExplicitTyBound(false)))
             && matches!(
@@ -210,7 +210,7 @@ impl<'tcx> Visitor<'tcx> for NumericFallbackVisitor<'_, 'tcx> {
 
             ExprKind::Lit(lit) => {
                 let ty = self.cx.typeck_results().expr_ty(expr);
-                self.check_lit(lit, ty, expr.hir_id);
+                self.check_lit(*lit, ty, expr.hir_id);
                 return;
             },
 
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index 621a2af1d32..8707612fbdd 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -57,7 +57,7 @@ impl LateLintPass<'_> for LargeIncludeFile {
         if let ExprKind::Lit(lit) = &expr.kind
             && let len = match &lit.node {
                 // include_bytes
-                LitKind::ByteStr(bstr, _) => bstr.len(),
+                LitKind::ByteStr(bstr, _) => bstr.as_byte_str().len(),
                 // include_str
                 LitKind::Str(sym, _) => sym.as_str().len(),
                 _ => return,
diff --git a/clippy_lints/src/manual_ignore_case_cmp.rs b/clippy_lints/src/manual_ignore_case_cmp.rs
index 57c03fbb2ed..f7d9ec1fae8 100644
--- a/clippy_lints/src/manual_ignore_case_cmp.rs
+++ b/clippy_lints/src/manual_ignore_case_cmp.rs
@@ -41,12 +41,12 @@ declare_clippy_lint! {
 
 declare_lint_pass!(ManualIgnoreCaseCmp => [MANUAL_IGNORE_CASE_CMP]);
 
-enum MatchType<'a, 'b> {
+enum MatchType<'a> {
     ToAscii(bool, Ty<'a>),
-    Literal(&'b LitKind),
+    Literal(LitKind),
 }
 
-fn get_ascii_type<'a, 'b>(cx: &LateContext<'a>, kind: rustc_hir::ExprKind<'b>) -> Option<(Span, MatchType<'a, 'b>)> {
+fn get_ascii_type<'a>(cx: &LateContext<'a>, kind: rustc_hir::ExprKind<'_>) -> Option<(Span, MatchType<'a>)> {
     if let MethodCall(path, expr, _, _) = kind {
         let is_lower = match path.ident.name {
             sym::to_ascii_lowercase => true,
@@ -63,7 +63,7 @@ fn get_ascii_type<'a, 'b>(cx: &LateContext<'a>, kind: rustc_hir::ExprKind<'b>) -
             return Some((expr.span, ToAscii(is_lower, ty_raw)));
         }
     } else if let Lit(expr) = kind {
-        return Some((expr.span, Literal(&expr.node)));
+        return Some((expr.span, Literal(expr.node)));
     }
     None
 }
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 9e911e61f19..6bf43a1c6d4 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -184,7 +184,7 @@ fn eq_pattern_length<'tcx>(cx: &LateContext<'tcx>, pattern: &Expr<'_>, expr: &'t
         ..
     }) = expr.kind
     {
-        constant_length(cx, pattern).is_some_and(|length| *n == length)
+        constant_length(cx, pattern).is_some_and(|length| n == length)
     } else {
         len_arg(cx, expr).is_some_and(|arg| eq_expr_value(cx, pattern, arg))
     }
diff --git a/clippy_lints/src/matches/match_like_matches.rs b/clippy_lints/src/matches/match_like_matches.rs
index f14b69d91ce..5816da5695e 100644
--- a/clippy_lints/src/matches/match_like_matches.rs
+++ b/clippy_lints/src/matches/match_like_matches.rs
@@ -159,7 +159,7 @@ fn find_bool_lit(ex: &ExprKind<'_>) -> Option<bool> {
                 node: LitKind::Bool(b), ..
             }) = exp.kind
             {
-                Some(*b)
+                Some(b)
             } else {
                 None
             }
diff --git a/clippy_lints/src/matches/match_same_arms.rs b/clippy_lints/src/matches/match_same_arms.rs
index dbb29ee776b..ede68f30941 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, PatExp
 use rustc_lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::ty;
-use rustc_span::{ErrorGuaranteed, Span, Symbol};
+use rustc_span::{ByteSymbol, ErrorGuaranteed, Span, Symbol};
 
 use super::MATCH_SAME_ARMS;
 
@@ -193,7 +193,7 @@ enum NormalizedPat<'a> {
     Or(&'a [Self]),
     Path(Option<DefId>),
     LitStr(Symbol),
-    LitBytes(&'a [u8]),
+    LitBytes(ByteSymbol),
     LitInt(u128),
     LitBool(bool),
     Range(PatRange),
@@ -332,7 +332,9 @@ impl<'a> NormalizedPat<'a> {
                 // TODO: Handle negative integers. They're currently treated as a wild match.
                 PatExprKind::Lit { lit, negated: false } => match lit.node {
                     LitKind::Str(sym, _) => Self::LitStr(sym),
-                    LitKind::ByteStr(ref bytes, _) | LitKind::CStr(ref bytes, _) => Self::LitBytes(bytes),
+                    LitKind::ByteStr(byte_sym, _) | LitKind::CStr(byte_sym, _) => {
+                        Self::LitBytes(byte_sym)
+                    }
                     LitKind::Byte(val) => Self::LitInt(val.into()),
                     LitKind::Char(val) => Self::LitInt(val.into()),
                     LitKind::Int(val, _) => Self::LitInt(val.get()),
diff --git a/clippy_lints/src/methods/open_options.rs b/clippy_lints/src/methods/open_options.rs
index fd368024177..9b5f138295c 100644
--- a/clippy_lints/src/methods/open_options.rs
+++ b/clippy_lints/src/methods/open_options.rs
@@ -76,7 +76,7 @@ fn get_open_options(
                         ..
                     } = span
                     {
-                        Argument::Set(*lit)
+                        Argument::Set(lit)
                     } else {
                         // The function is called with a literal which is not a boolean literal.
                         // This is theoretically possible, but not very likely.
diff --git a/clippy_lints/src/missing_asserts_for_indexing.rs b/clippy_lints/src/missing_asserts_for_indexing.rs
index c8e3462b24e..cf0c85990b1 100644
--- a/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/clippy_lints/src/missing_asserts_for_indexing.rs
@@ -104,7 +104,7 @@ fn len_comparison<'hir>(
 ) -> Option<(LengthComparison, usize, &'hir Expr<'hir>)> {
     macro_rules! int_lit_pat {
         ($id:ident) => {
-            ExprKind::Lit(&Spanned {
+            ExprKind::Lit(Spanned {
                 node: LitKind::Int(Pu128($id), _),
                 ..
             })
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 3a08531cf1c..ac92ab5a245 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -324,7 +324,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
         }
     }
 
-    fn lit(&self, lit: &Binding<&Lit>) {
+    fn lit(&self, lit: &Binding<Lit>) {
         let kind = |kind| chain!(self, "let LitKind::{kind} = {lit}.node");
         macro_rules! kind {
             ($($t:tt)*) => (kind(format_args!($($t)*)));
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index aaa071fd5c9..09299c869dc 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -4,8 +4,6 @@
 //! executable MIR bodies, so we have to do this instead.
 #![allow(clippy::float_cmp)]
 
-use std::sync::Arc;
-
 use crate::source::{SpanRangeExt, walk_span_to_context};
 use crate::{clip, is_direct_expn_of, sext, unsext};
 
@@ -38,7 +36,7 @@ pub enum Constant<'tcx> {
     /// A `String` (e.g., "abc").
     Str(String),
     /// A binary string (e.g., `b"abc"`).
-    Binary(Arc<[u8]>),
+    Binary(Vec<u8>),
     /// A single `char` (e.g., `'a'`).
     Char(char),
     /// An integer's bit representation.
@@ -306,7 +304,9 @@ pub fn lit_to_mir_constant<'tcx>(lit: &LitKind, ty: Option<Ty<'tcx>>) -> Constan
     match *lit {
         LitKind::Str(ref is, _) => Constant::Str(is.to_string()),
         LitKind::Byte(b) => Constant::Int(u128::from(b)),
-        LitKind::ByteStr(ref s, _) | LitKind::CStr(ref s, _) => Constant::Binary(Arc::clone(s)),
+        LitKind::ByteStr(ref s, _) | LitKind::CStr(ref s, _) => {
+            Constant::Binary(s.as_byte_str().to_vec())
+        }
         LitKind::Char(c) => Constant::Char(c),
         LitKind::Int(n, _) => Constant::Int(n.get()),
         LitKind::Float(ref is, LitFloatType::Suffixed(fty)) => match fty {
@@ -568,7 +568,9 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
                 } else {
                     match &lit.node {
                         LitKind::Str(is, _) => Some(is.is_empty()),
-                        LitKind::ByteStr(s, _) | LitKind::CStr(s, _) => Some(s.is_empty()),
+                        LitKind::ByteStr(s, _) | LitKind::CStr(s, _) => {
+                            Some(s.as_byte_str().is_empty())
+                        }
                         _ => None,
                     }
                 }
-- 
cgit 1.4.1-3-g733a5


From f3b3c096fdaf5f2041a0886a5f4375aa76c5c5e5 Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Sun, 29 Jun 2025 02:14:43 +0500
Subject: Polishing changelog update doc

---
 book/src/development/infrastructure/backport.md    |  2 +-
 .../development/infrastructure/changelog_update.md | 32 +++++++---------------
 2 files changed, 11 insertions(+), 23 deletions(-)

diff --git a/book/src/development/infrastructure/backport.md b/book/src/development/infrastructure/backport.md
index 9526d8af1c9..47ea6a412c5 100644
--- a/book/src/development/infrastructure/backport.md
+++ b/book/src/development/infrastructure/backport.md
@@ -109,4 +109,4 @@ worth backporting this.
 When a PR is backported to Rust `beta`, label the PR with `beta-accepted`. This
 will then get picked up when [writing the changelog].
 
-[writing the changelog]: changelog_update.md#31-include-beta-accepted-prs
+[writing the changelog]: changelog_update.md#4-include-beta-accepted-prs
diff --git a/book/src/development/infrastructure/changelog_update.md b/book/src/development/infrastructure/changelog_update.md
index eede6b78d92..c96ff228b01 100644
--- a/book/src/development/infrastructure/changelog_update.md
+++ b/book/src/development/infrastructure/changelog_update.md
@@ -38,7 +38,7 @@ Usually you want to write the changelog of the **upcoming stable release**. Make
 sure though, that `beta` was already branched in the Rust repository.
 
 To find the commit hash, issue the following command when in a `rust-lang/rust`
-checkout:
+checkout (most of the time on the `upstream/beta` branch):
 ```
 git log --oneline -- src/tools/clippy/ | grep -o "Merge commit '[a-f0-9]*' into .*" | head -1 | sed -e "s/Merge commit '\([a-f0-9]*\)' into .*/\1/g"
 ```
@@ -48,16 +48,13 @@ git log --oneline -- src/tools/clippy/ | grep -o "Merge commit '[a-f0-9]*' into
 Once you've got the correct commit range, run
 
 ```
-util/fetch_prs_between.sh commit1 commit2 > changes.txt
+util/fetch_prs_between.sh start_commit end_commit > changes.txt
 ```
 
-where `commit2` is the commit hash from the previous command and `commit1`
-is the commit hash from the current CHANGELOG file.
+where `end_commit` is the commit hash from the previous command and `start_commit`
+is [the commit hash][beta_section] from the current CHANGELOG file.
 Open `changes.txt` file in your editor of choice.
 
-When updating the changelog it's also a good idea to make sure that `commit1` is
-already correct in the current changelog.
-
 ### 3. Authoring the final changelog
 
 The above script should have dumped all the relevant PRs to the file you
@@ -70,17 +67,7 @@ With the PRs filtered, you can start to take each PR and move the `changelog: `
 content to `CHANGELOG.md`. Adapt the wording as you see fit but try to keep it
 somewhat coherent.
 
-The order should roughly be:
-
-1. New lints
-2. Moves or deprecations of lints
-3. Changes that expand what code existing lints cover
-4. False positive fixes
-5. ICE fixes
-6. Documentation improvements
-7. Others
-
-As section headers, we use:
+The sections order should roughly be:
 
 ```
 ### New Lints
@@ -97,10 +84,10 @@ As section headers, we use:
 ### Others
 ```
 
-Please also be sure to update the Beta/Unreleased sections at the top with the
-relevant commit ranges.
+Please also be sure to update [the `Unreleased/Beta/In Rust Nightly` section][beta_section] at the top with the
+relevant commits ranges and to add the `Rust <version>` section with release date and PR ranges.
 
-#### 3.1 Include `beta-accepted` PRs
+### 4. Include `beta-accepted` PRs
 
 Look for the [`beta-accepted`] label and make sure to also include the PRs with
 that label in the changelog. If you can, remove the `beta-accepted` labels
@@ -109,7 +96,7 @@ that label in the changelog. If you can, remove the `beta-accepted` labels
 > _Note:_ Some of those PRs might even get backported to the previous `beta`.
 > Those have to be included in the changelog of the _previous_ release.
 
-### 4. Update `clippy::version` attributes
+### 5. Update `clippy::version` attributes
 
 Next, make sure to check that the `#[clippy::version]` attributes for the added
 lints contain the correct version. 
@@ -129,3 +116,4 @@ written for. If not, update the version to the changelog version.
 [rust_beta_tools]: https://github.com/rust-lang/rust/tree/beta/src/tools/clippy
 [rust_stable_tools]: https://github.com/rust-lang/rust/releases
 [`beta-accepted`]: https://github.com/rust-lang/rust-clippy/issues?q=label%3Abeta-accepted+
+[beta_section]: https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md#unreleased--beta--in-rust-nightly
-- 
cgit 1.4.1-3-g733a5


From a4d584e7a6d2bb4ce08b72faec0c35206dd6e4b7 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sat, 14 Jun 2025 08:44:37 +0000
Subject: josh-sync: Replace `#xxxx`-style links in messages

Often our short summaries will pick up a Bors "Auto merge of #xxxx ...`
commit message. Replace these with something like `rust-lang/rust#1234`
to avoid broken links when going between repositories.
---
 .../compiler-builtins/crates/josh-sync/Cargo.toml  |  1 +
 .../compiler-builtins/crates/josh-sync/src/sync.rs | 30 ++++++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/library/compiler-builtins/crates/josh-sync/Cargo.toml b/library/compiler-builtins/crates/josh-sync/Cargo.toml
index 1f3bb376d6d..8e2e891db54 100644
--- a/library/compiler-builtins/crates/josh-sync/Cargo.toml
+++ b/library/compiler-builtins/crates/josh-sync/Cargo.toml
@@ -5,3 +5,4 @@ publish = false
 
 [dependencies]
 directories = "6.0.0"
+regex-lite = "0.1.6"
diff --git a/library/compiler-builtins/crates/josh-sync/src/sync.rs b/library/compiler-builtins/crates/josh-sync/src/sync.rs
index 003cf187d83..2d89d2d1cea 100644
--- a/library/compiler-builtins/crates/josh-sync/src/sync.rs
+++ b/library/compiler-builtins/crates/josh-sync/src/sync.rs
@@ -1,8 +1,11 @@
+use std::borrow::Cow;
 use std::net::{SocketAddr, TcpStream};
 use std::process::{Command, Stdio, exit};
 use std::time::Duration;
 use std::{env, fs, process, thread};
 
+use regex_lite::Regex;
+
 const JOSH_PORT: u16 = 42042;
 const DEFAULT_PR_BRANCH: &str = "update-builtins";
 
@@ -77,6 +80,7 @@ impl GitSync {
             "--depth=1",
         ]);
         let new_summary = check_output(["git", "log", "-1", "--format=%h %s", &new_upstream_base]);
+        let new_summary = replace_references(&new_summary, &self.upstream_repo);
 
         // Update rust-version file. As a separate commit, since making it part of
         // the merge has confused the heck out of josh in the past.
@@ -297,6 +301,13 @@ fn check_output_cfg(prog: &str, f: impl FnOnce(&mut Command) -> &mut Command) ->
     String::from_utf8(out.stdout.trim_ascii().to_vec()).expect("non-UTF8 output")
 }
 
+/// Replace `#1234`-style issue/PR references with `repo#1234` to ensure links work across
+/// repositories.
+fn replace_references<'a>(s: &'a str, repo: &str) -> Cow<'a, str> {
+    let re = Regex::new(r"\B(?P<id>#\d+)\b").unwrap();
+    re.replace(s, &format!("{repo}$id"))
+}
+
 /// Create a wrapper that stops Josh on drop.
 pub struct Josh(process::Child);
 
@@ -369,3 +380,22 @@ impl Drop for Josh {
         self.0.kill().expect("failed to SIGKILL josh-proxy");
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_replace() {
+        assert_eq!(replace_references("#1234", "r-l/rust"), "r-l/rust#1234");
+        assert_eq!(replace_references("#1234x", "r-l/rust"), "#1234x");
+        assert_eq!(
+            replace_references("merge #1234", "r-l/rust"),
+            "merge r-l/rust#1234"
+        );
+        assert_eq!(
+            replace_references("foo/bar#1234", "r-l/rust"),
+            "foo/bar#1234"
+        );
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 609a8abaabb1de574ba07f23ef5de9e6db5fb68a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 30 Jun 2025 16:12:42 +0200
Subject: Merge commit '4b5c44b14166083eef8d71f15f5ea1f53fc976a0' into
 subtree-update_cg_gcc_2025-06-30

---
 build_system/build_sysroot/Cargo.toml              |   1 +
 build_system/src/test.rs                           |  28 +----
 ...1-Workaround-to-make-a-run-make-test-pass.patch |  25 -----
 rust-toolchain                                     |   2 +-
 src/abi.rs                                         |   4 +-
 src/builder.rs                                     |  46 ++------
 src/common.rs                                      |  10 +-
 src/context.rs                                     |   9 --
 src/intrinsic/archs.rs                             | 124 +++++++++++----------
 src/intrinsic/llvm.rs                              |  37 ++++++
 src/intrinsic/mod.rs                               |   4 +-
 tools/generate_intrinsics.py                       |  12 +-
 12 files changed, 131 insertions(+), 171 deletions(-)
 delete mode 100644 patches/tests/0001-Workaround-to-make-a-run-make-test-pass.patch

diff --git a/build_system/build_sysroot/Cargo.toml b/build_system/build_sysroot/Cargo.toml
index 931f6097abc..29a3bcec304 100644
--- a/build_system/build_sysroot/Cargo.toml
+++ b/build_system/build_sysroot/Cargo.toml
@@ -6,6 +6,7 @@ resolver = "2"
 
 [dependencies]
 core = { path = "./sysroot_src/library/core" }
+compiler_builtins = { path = "./sysroot_src/library/compiler-builtins/compiler-builtins" }
 alloc = { path = "./sysroot_src/library/alloc" }
 std = { path = "./sysroot_src/library/std", features = ["panic_unwind", "backtrace"] }
 test = { path = "./sysroot_src/library/test" }
diff --git a/build_system/src/test.rs b/build_system/src/test.rs
index f1f31f83ca2..cbb0f949383 100644
--- a/build_system/src/test.rs
+++ b/build_system/src/test.rs
@@ -9,8 +9,8 @@ use crate::build;
 use crate::config::{Channel, ConfigInfo};
 use crate::utils::{
     create_dir, get_sysroot_dir, get_toolchain, git_clone, git_clone_root_dir, remove_file,
-    run_command, run_command_with_env, run_command_with_output, run_command_with_output_and_env,
-    rustc_version_info, split_args, walk_dir,
+    run_command, run_command_with_env, run_command_with_output_and_env, rustc_version_info,
+    split_args, walk_dir,
 };
 
 type Env = HashMap<String, String>;
@@ -485,30 +485,6 @@ fn setup_rustc(env: &mut Env, args: &TestArg) -> Result<PathBuf, String> {
         run_command_with_output_and_env(&[&"git", &"checkout"], rust_dir, Some(env))?;
     }
 
-    let mut patches = Vec::new();
-    walk_dir(
-        "patches/tests",
-        &mut |_| Ok(()),
-        &mut |file_path: &Path| {
-            patches.push(file_path.to_path_buf());
-            Ok(())
-        },
-        false,
-    )?;
-    patches.sort();
-    // TODO: remove duplication with prepare.rs by creating a apply_patch function in the utils
-    // module.
-    for file_path in patches {
-        println!("[GIT] apply `{}`", file_path.display());
-        let path = Path::new("../..").join(file_path);
-        run_command_with_output(&[&"git", &"apply", &path], rust_dir)?;
-        run_command_with_output(&[&"git", &"add", &"-A"], rust_dir)?;
-        run_command_with_output(
-            &[&"git", &"commit", &"--no-gpg-sign", &"-m", &format!("Patch {}", path.display())],
-            rust_dir,
-        )?;
-    }
-
     let cargo = String::from_utf8(
         run_command_with_env(&[&"rustup", &"which", &"cargo"], rust_dir, Some(env))?.stdout,
     )
diff --git a/patches/tests/0001-Workaround-to-make-a-run-make-test-pass.patch b/patches/tests/0001-Workaround-to-make-a-run-make-test-pass.patch
deleted file mode 100644
index a329d09a95e..00000000000
--- a/patches/tests/0001-Workaround-to-make-a-run-make-test-pass.patch
+++ /dev/null
@@ -1,25 +0,0 @@
-From a131c69e54b5c02fe3b517e8f3ad23d4f784ffc8 Mon Sep 17 00:00:00 2001
-From: Antoni Boucher <bouanto@zoho.com>
-Date: Fri, 13 Jun 2025 20:25:33 -0400
-Subject: [PATCH] Workaround to make a run-make test pass
-
----
- tests/run-make/linker-warning/rmake.rs | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/tests/run-make/linker-warning/rmake.rs b/tests/run-make/linker-warning/rmake.rs
-index bc21739fefc..0946a7e2a48 100644
---- a/tests/run-make/linker-warning/rmake.rs
-+++ b/tests/run-make/linker-warning/rmake.rs
-@@ -55,7 +55,7 @@ fn main() {
-         diff()
-             .expected_file("short-error.txt")
-             .actual_text("(linker error)", out.stderr())
--            .normalize(r#"/rustc[^/]*/"#, "/rustc/")
-+            .normalize(r#"/tmp/rustc[^/]*/"#, "/tmp/rustc/")
-             .normalize(
-                 regex::escape(run_make_support::build_root().to_str().unwrap()),
-                 "/build-root",
--- 
-2.49.0
-
diff --git a/rust-toolchain b/rust-toolchain
index 8be204c1581..bccbc6cd2c5 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2025-06-02"
+channel = "nightly-2025-06-28"
 components = ["rust-src", "rustc-dev", "llvm-tools-preview"]
diff --git a/src/abi.rs b/src/abi.rs
index 08f3d281904..0b359f1c5c8 100644
--- a/src/abi.rs
+++ b/src/abi.rs
@@ -1,7 +1,9 @@
 #[cfg(feature = "master")]
 use gccjit::FnAttribute;
 use gccjit::{ToLValue, ToRValue, Type};
-use rustc_abi::{ArmCall, CanonAbi, InterruptKind, Reg, RegKind, X86Call};
+#[cfg(feature = "master")]
+use rustc_abi::{ArmCall, CanonAbi, InterruptKind, X86Call};
+use rustc_abi::{Reg, RegKind};
 use rustc_codegen_ssa::traits::{AbiBuilderMethods, BaseTypeCodegenMethods};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_middle::bug;
diff --git a/src/builder.rs b/src/builder.rs
index 1fce547ad1b..b1785af444a 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -538,11 +538,6 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
     }
 
     fn ret(&mut self, mut value: RValue<'gcc>) {
-        if self.structs_as_pointer.borrow().contains(&value) {
-            // NOTE: hack to workaround a limitation of the rustc API: see comment on
-            // CodegenCx.structs_as_pointer
-            value = value.dereference(self.location).to_rvalue();
-        }
         let expected_return_type = self.current_func().get_return_type();
         if !expected_return_type.is_compatible_with(value.get_type()) {
             // NOTE: due to opaque pointers now being used, we need to cast here.
@@ -700,7 +695,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         let a = self.gcc_int_cast(a, a_type);
         let b_type = b.get_type().to_unsigned(self);
         let b = self.gcc_int_cast(b, b_type);
-        a / b
+        self.gcc_udiv(a, b)
     }
 
     fn sdiv(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
@@ -712,8 +707,8 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         // 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);
-        let b = self.context.new_cast(self.location, b, typ);
-        a / b
+        let b = self.gcc_int_cast(b, typ);
+        self.gcc_sdiv(a, b)
     }
 
     fn fdiv(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
@@ -1119,13 +1114,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         // TODO(antoyo)
     }
 
-    fn store(&mut self, mut val: RValue<'gcc>, ptr: RValue<'gcc>, align: Align) -> RValue<'gcc> {
-        if self.structs_as_pointer.borrow().contains(&val) {
-            // NOTE: hack to workaround a limitation of the rustc API: see comment on
-            // CodegenCx.structs_as_pointer
-            val = val.dereference(self.location).to_rvalue();
-        }
-
+    fn store(&mut self, val: RValue<'gcc>, ptr: RValue<'gcc>, align: Align) -> RValue<'gcc> {
         self.store_with_flags(val, ptr, align, MemFlags::empty())
     }
 
@@ -1508,16 +1497,6 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
             element.get_address(self.location)
         } else if value_type.dyncast_vector().is_some() {
             panic!();
-        } else if let Some(pointer_type) = value_type.get_pointee() {
-            if let Some(struct_type) = pointer_type.is_struct() {
-                // NOTE: hack to workaround a limitation of the rustc API: see comment on
-                // CodegenCx.structs_as_pointer
-                aggregate_value
-                    .dereference_field(self.location, struct_type.get_field(idx as i32))
-                    .to_rvalue()
-            } else {
-                panic!("Unexpected type {:?}", value_type);
-            }
         } else if let Some(struct_type) = value_type.is_struct() {
             aggregate_value
                 .access_field(self.location, struct_type.get_field(idx as i32))
@@ -1537,21 +1516,18 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         assert_eq!(idx as usize as u64, idx);
         let value_type = aggregate_value.get_type();
 
+        let new_val = self.current_func().new_local(None, value_type, "aggregate_value");
+        self.block.add_assignment(None, new_val, aggregate_value);
+
         let lvalue = if value_type.dyncast_array().is_some() {
             let index = self
                 .context
                 .new_rvalue_from_long(self.u64_type, i64::try_from(idx).expect("i64::try_from"));
-            self.context.new_array_access(self.location, aggregate_value, index)
+            self.context.new_array_access(self.location, new_val, index)
         } else if value_type.dyncast_vector().is_some() {
             panic!();
-        } else if let Some(pointer_type) = value_type.get_pointee() {
-            if let Some(struct_type) = pointer_type.is_struct() {
-                // NOTE: hack to workaround a limitation of the rustc API: see comment on
-                // CodegenCx.structs_as_pointer
-                aggregate_value.dereference_field(self.location, struct_type.get_field(idx as i32))
-            } else {
-                panic!("Unexpected type {:?}", value_type);
-            }
+        } else if let Some(struct_type) = value_type.is_struct() {
+            new_val.access_field(None, struct_type.get_field(idx as i32))
         } else {
             panic!("Unexpected type {:?}", value_type);
         };
@@ -1568,7 +1544,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
 
         self.llbb().add_assignment(self.location, lvalue, value);
 
-        aggregate_value
+        new_val.to_rvalue()
     }
 
     fn set_personality_fn(&mut self, _personality: Function<'gcc>) {
diff --git a/src/common.rs b/src/common.rs
index fdd47821b51..38348a48e47 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -117,15 +117,7 @@ impl<'gcc, 'tcx> ConstCodegenMethods for CodegenCx<'gcc, 'tcx> {
 
     fn const_undef(&self, typ: Type<'gcc>) -> RValue<'gcc> {
         let local = self.current_func.borrow().expect("func").new_local(None, typ, "undefined");
-        if typ.is_struct().is_some() {
-            // NOTE: hack to workaround a limitation of the rustc API: see comment on
-            // CodegenCx.structs_as_pointer
-            let pointer = local.get_address(None);
-            self.structs_as_pointer.borrow_mut().insert(pointer);
-            pointer
-        } else {
-            local.to_rvalue()
-        }
+        local.to_rvalue()
     }
 
     fn const_poison(&self, typ: Type<'gcc>) -> RValue<'gcc> {
diff --git a/src/context.rs b/src/context.rs
index 1d029811dfe..665cf22ddba 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -124,14 +124,6 @@ pub struct CodegenCx<'gcc, 'tcx> {
 
     pub pointee_infos: RefCell<FxHashMap<(Ty<'tcx>, Size), Option<PointeeInfo>>>,
 
-    /// NOTE: a hack is used because the rustc API is not suitable to libgccjit and as such,
-    /// `const_undef()` returns struct as pointer so that they can later be assigned a value (in
-    /// e.g. Builder::insert_value).
-    /// As such, this set remembers which of these pointers were returned by this function so that
-    /// they can be dereferenced later.
-    /// FIXME(antoyo): fix the rustc API to avoid having this hack.
-    pub structs_as_pointer: RefCell<FxHashSet<RValue<'gcc>>>,
-
     #[cfg(feature = "master")]
     pub cleanup_blocks: RefCell<FxHashSet<Block<'gcc>>>,
     /// The alignment of a u128/i128 type.
@@ -304,7 +296,6 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             #[cfg(feature = "master")]
             rust_try_fn: Cell::new(None),
             pointee_infos: Default::default(),
-            structs_as_pointer: Default::default(),
             #[cfg(feature = "master")]
             cleanup_blocks: Default::default(),
         };
diff --git a/src/intrinsic/archs.rs b/src/intrinsic/archs.rs
index f0352c5e6e5..915ed875e32 100644
--- a/src/intrinsic/archs.rs
+++ b/src/intrinsic/archs.rs
@@ -1,9 +1,9 @@
 // File generated by `rustc_codegen_gcc/tools/generate_intrinsics.py`
 // DO NOT EDIT IT!
 /// Translate a given LLVM intrinsic name to an equivalent GCC one.
-fn map_arch_intrinsic(name: &str) -> &str {
-    let Some(name) = name.strip_prefix("llvm.") else {
-        unimplemented!("***** unsupported LLVM intrinsic {}", name)
+fn map_arch_intrinsic(full_name: &str) -> &'static str {
+    let Some(name) = full_name.strip_prefix("llvm.") else {
+        unimplemented!("***** unsupported LLVM intrinsic {}", full_name)
     };
     let Some((arch, name)) = name.split_once('.') else {
         unimplemented!("***** unsupported LLVM intrinsic {}", name)
@@ -11,7 +11,7 @@ fn map_arch_intrinsic(name: &str) -> &str {
     match arch {
         "AMDGPU" => {
             #[allow(non_snake_case)]
-            fn AMDGPU(name: &str) -> &str {
+            fn AMDGPU(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // AMDGPU
                     "div.fixup.f32" => "__builtin_amdgpu_div_fixup",
@@ -42,14 +42,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "trig.preop.f64" => "__builtin_amdgpu_trig_preop",
                     "trig.preop.v2f64" => "__builtin_amdgpu_trig_preop",
                     "trig.preop.v4f32" => "__builtin_amdgpu_trig_preop",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            AMDGPU(name)
+            AMDGPU(name, full_name)
         }
         "aarch64" => {
             #[allow(non_snake_case)]
-            fn aarch64(name: &str) -> &str {
+            fn aarch64(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // aarch64
                     "chkfeat" => "__builtin_arm_chkfeat",
@@ -75,14 +75,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "tcommit" => "__builtin_arm_tcommit",
                     "tstart" => "__builtin_arm_tstart",
                     "ttest" => "__builtin_arm_ttest",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            aarch64(name)
+            aarch64(name, full_name)
         }
         "amdgcn" => {
             #[allow(non_snake_case)]
-            fn amdgcn(name: &str) -> &str {
+            fn amdgcn(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // amdgcn
                     "alignbyte" => "__builtin_amdgcn_alignbyte",
@@ -99,6 +99,8 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "cvt.f32.fp8" => "__builtin_amdgcn_cvt_f32_fp8",
                     "cvt.off.f32.i4" => "__builtin_amdgcn_cvt_off_f32_i4",
                     "cvt.pk.bf8.f32" => "__builtin_amdgcn_cvt_pk_bf8_f32",
+                    "cvt.pk.f16.bf8" => "__builtin_amdgcn_cvt_pk_f16_bf8",
+                    "cvt.pk.f16.fp8" => "__builtin_amdgcn_cvt_pk_f16_fp8",
                     "cvt.pk.f32.bf8" => "__builtin_amdgcn_cvt_pk_f32_bf8",
                     "cvt.pk.f32.fp8" => "__builtin_amdgcn_cvt_pk_f32_fp8",
                     "cvt.pk.fp8.f32" => "__builtin_amdgcn_cvt_pk_fp8_f32",
@@ -292,6 +294,7 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "s.sendmsg" => "__builtin_amdgcn_s_sendmsg",
                     "s.sendmsghalt" => "__builtin_amdgcn_s_sendmsghalt",
                     "s.setprio" => "__builtin_amdgcn_s_setprio",
+                    "s.setprio.inc.wg" => "__builtin_amdgcn_s_setprio_inc_wg",
                     "s.setreg" => "__builtin_amdgcn_s_setreg",
                     "s.sleep" => "__builtin_amdgcn_s_sleep",
                     "s.sleep.var" => "__builtin_amdgcn_s_sleep_var",
@@ -356,14 +359,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "workitem.id.x" => "__builtin_amdgcn_workitem_id_x",
                     "workitem.id.y" => "__builtin_amdgcn_workitem_id_y",
                     "workitem.id.z" => "__builtin_amdgcn_workitem_id_z",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            amdgcn(name)
+            amdgcn(name, full_name)
         }
         "arm" => {
             #[allow(non_snake_case)]
-            fn arm(name: &str) -> &str {
+            fn arm(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // arm
                     "cdp" => "__builtin_arm_cdp",
@@ -465,14 +468,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "usub8" => "__builtin_arm_usub8",
                     "uxtab16" => "__builtin_arm_uxtab16",
                     "uxtb16" => "__builtin_arm_uxtb16",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            arm(name)
+            arm(name, full_name)
         }
         "bpf" => {
             #[allow(non_snake_case)]
-            fn bpf(name: &str) -> &str {
+            fn bpf(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // bpf
                     "btf.type.id" => "__builtin_bpf_btf_type_id",
@@ -487,25 +490,25 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "preserve.field.info" => "__builtin_bpf_preserve_field_info",
                     "preserve.type.info" => "__builtin_bpf_preserve_type_info",
                     "pseudo" => "__builtin_bpf_pseudo",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            bpf(name)
+            bpf(name, full_name)
         }
         "cuda" => {
             #[allow(non_snake_case)]
-            fn cuda(name: &str) -> &str {
+            fn cuda(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // cuda
                     "syncthreads" => "__syncthreads",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            cuda(name)
+            cuda(name, full_name)
         }
         "hexagon" => {
             #[allow(non_snake_case)]
-            fn hexagon(name: &str) -> &str {
+            fn hexagon(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // hexagon
                     "A2.abs" => "__builtin_HEXAGON_A2_abs",
@@ -2479,14 +2482,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "prefetch" => "__builtin_HEXAGON_prefetch",
                     "vmemcpy" => "__builtin_hexagon_vmemcpy",
                     "vmemset" => "__builtin_hexagon_vmemset",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            hexagon(name)
+            hexagon(name, full_name)
         }
         "loongarch" => {
             #[allow(non_snake_case)]
-            fn loongarch(name: &str) -> &str {
+            fn loongarch(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // loongarch
                     "asrtgt.d" => "__builtin_loongarch_asrtgt_d",
@@ -3988,14 +3991,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "movfcsr2gr" => "__builtin_loongarch_movfcsr2gr",
                     "movgr2fcsr" => "__builtin_loongarch_movgr2fcsr",
                     "syscall" => "__builtin_loongarch_syscall",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            loongarch(name)
+            loongarch(name, full_name)
         }
         "mips" => {
             #[allow(non_snake_case)]
-            fn mips(name: &str) -> &str {
+            fn mips(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // mips
                     "absq.s.ph" => "__builtin_mips_absq_s_ph",
@@ -4669,14 +4672,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "wrdsp" => "__builtin_mips_wrdsp",
                     "xor.v" => "__builtin_msa_xor_v",
                     "xori.b" => "__builtin_msa_xori_b",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            mips(name)
+            mips(name, full_name)
         }
         "nvvm" => {
             #[allow(non_snake_case)]
-            fn nvvm(name: &str) -> &str {
+            fn nvvm(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // nvvm
                     "abs.i" => "__nvvm_abs_i",
@@ -5024,6 +5027,7 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "nanosleep" => "__nvvm_nanosleep",
                     "neg.bf16" => "__nvvm_neg_bf16",
                     "neg.bf16x2" => "__nvvm_neg_bf16x2",
+                    "pm.event.mask" => "__nvvm_pm_event_mask",
                     "popc.i" => "__nvvm_popc_i",
                     "popc.ll" => "__nvvm_popc_ll",
                     "prmt" => "__nvvm_prmt",
@@ -5448,14 +5452,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "vote.ballot.sync" => "__nvvm_vote_ballot_sync",
                     "vote.uni" => "__nvvm_vote_uni",
                     "vote.uni.sync" => "__nvvm_vote_uni_sync",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            nvvm(name)
+            nvvm(name, full_name)
         }
         "ppc" => {
             #[allow(non_snake_case)]
-            fn ppc(name: &str) -> &str {
+            fn ppc(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // ppc
                     "addex" => "__builtin_ppc_addex",
@@ -5842,7 +5846,10 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "mulhdu" => "__builtin_ppc_mulhdu",
                     "mulhw" => "__builtin_ppc_mulhw",
                     "mulhwu" => "__builtin_ppc_mulhwu",
+                    "national2packed" => "__builtin_ppc_national2packed",
                     "pack.longdouble" => "__builtin_pack_longdouble",
+                    "packed2national" => "__builtin_ppc_packed2national",
+                    "packed2zoned" => "__builtin_ppc_packed2zoned",
                     "pdepd" => "__builtin_pdepd",
                     "pextd" => "__builtin_pextd",
                     "qpx.qvfabs" => "__builtin_qpx_qvfabs",
@@ -6035,14 +6042,15 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "vsx.xxinsertw" => "__builtin_vsx_xxinsertw",
                     "vsx.xxleqv" => "__builtin_vsx_xxleqv",
                     "vsx.xxpermx" => "__builtin_vsx_xxpermx",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    "zoned2packed" => "__builtin_ppc_zoned2packed",
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            ppc(name)
+            ppc(name, full_name)
         }
         "ptx" => {
             #[allow(non_snake_case)]
-            fn ptx(name: &str) -> &str {
+            fn ptx(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // ptx
                     "bar.sync" => "__builtin_ptx_bar_sync",
@@ -6063,14 +6071,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "read.pm3" => "__builtin_ptx_read_pm3",
                     "read.smid" => "__builtin_ptx_read_smid",
                     "read.warpid" => "__builtin_ptx_read_warpid",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            ptx(name)
+            ptx(name, full_name)
         }
         "r600" => {
             #[allow(non_snake_case)]
-            fn r600(name: &str) -> &str {
+            fn r600(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // r600
                     "group.barrier" => "__builtin_r600_group_barrier",
@@ -6088,14 +6096,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "read.tidig.x" => "__builtin_r600_read_tidig_x",
                     "read.tidig.y" => "__builtin_r600_read_tidig_y",
                     "read.tidig.z" => "__builtin_r600_read_tidig_z",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            r600(name)
+            r600(name, full_name)
         }
         "riscv" => {
             #[allow(non_snake_case)]
-            fn riscv(name: &str) -> &str {
+            fn riscv(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // riscv
                     "aes32dsi" => "__builtin_riscv_aes32dsi",
@@ -6119,14 +6127,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "sha512sum0r" => "__builtin_riscv_sha512sum0r",
                     "sha512sum1" => "__builtin_riscv_sha512sum1",
                     "sha512sum1r" => "__builtin_riscv_sha512sum1r",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            riscv(name)
+            riscv(name, full_name)
         }
         "s390" => {
             #[allow(non_snake_case)]
-            fn s390(name: &str) -> &str {
+            fn s390(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // s390
                     "bdepg" => "__builtin_s390_bdepg",
@@ -6313,14 +6321,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "vupllf" => "__builtin_s390_vupllf",
                     "vupllg" => "__builtin_s390_vupllg",
                     "vupllh" => "__builtin_s390_vupllh",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            s390(name)
+            s390(name, full_name)
         }
         "ve" => {
             #[allow(non_snake_case)]
-            fn ve(name: &str) -> &str {
+            fn ve(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // ve
                     "vl.andm.MMM" => "__builtin_ve_vl_andm_MMM",
@@ -7586,14 +7594,14 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "vl.vxor.vvvvl" => "__builtin_ve_vl_vxor_vvvvl",
                     "vl.xorm.MMM" => "__builtin_ve_vl_xorm_MMM",
                     "vl.xorm.mmm" => "__builtin_ve_vl_xorm_mmm",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            ve(name)
+            ve(name, full_name)
         }
         "x86" => {
             #[allow(non_snake_case)]
-            fn x86(name: &str) -> &str {
+            fn x86(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // x86
                     "aadd32" => "__builtin_ia32_aadd32",
@@ -10154,25 +10162,25 @@ fn map_arch_intrinsic(name: &str) -> &str {
                     "xresldtrk" => "__builtin_ia32_xresldtrk",
                     "xsusldtrk" => "__builtin_ia32_xsusldtrk",
                     "xtest" => "__builtin_ia32_xtest",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            x86(name)
+            x86(name, full_name)
         }
         "xcore" => {
             #[allow(non_snake_case)]
-            fn xcore(name: &str) -> &str {
+            fn xcore(name: &str, full_name: &str) -> &'static str {
                 match name {
                     // xcore
                     "bitrev" => "__builtin_bitrev",
                     "getid" => "__builtin_getid",
                     "getps" => "__builtin_getps",
                     "setps" => "__builtin_setps",
-                    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+                    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),
                 }
             }
-            xcore(name)
+            xcore(name, full_name)
         }
-        _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),
+        _ => unimplemented!("***** unsupported LLVM architecture {arch}, intrinsic:{full_name}"),
     }
 }
diff --git a/src/intrinsic/llvm.rs b/src/intrinsic/llvm.rs
index 0b77694f115..39dba28b24c 100644
--- a/src/intrinsic/llvm.rs
+++ b/src/intrinsic/llvm.rs
@@ -648,6 +648,11 @@ pub fn adjust_intrinsic_arguments<'a, 'b, 'gcc, 'tcx>(
                 new_args.push(handle);
                 args = new_args.into();
             }
+            "__builtin_ia32_rdtscp" => {
+                let result = builder.current_func().new_local(None, builder.u32_type, "result");
+                let new_args = vec![result.get_address(None).to_rvalue()];
+                args = new_args.into();
+            }
             _ => (),
         }
     } else {
@@ -764,6 +769,14 @@ pub fn adjust_intrinsic_arguments<'a, 'b, 'gcc, 'tcx>(
                 new_args.swap(0, 1);
                 args = new_args.into();
             }
+            "__builtin_ia32_dpps256" => {
+                let mut new_args = args.to_vec();
+                // NOTE: without this cast to u8 (and it needs to be a u8 to fix the issue), we
+                // would get the following error:
+                // the last argument must be an 8-bit immediate
+                new_args[2] = builder.context.new_cast(None, new_args[2], builder.cx.type_u8());
+                args = new_args.into();
+            }
             _ => (),
         }
     }
@@ -935,6 +948,19 @@ pub fn adjust_intrinsic_return_value<'a, 'gcc, 'tcx>(
             );
             return_value = result.to_rvalue();
         }
+        "__builtin_ia32_rdtscp" => {
+            let field1 = builder.context.new_field(None, return_value.get_type(), "rdtscpField1");
+            let return2 = args[0].dereference(None).to_rvalue();
+            let field2 = builder.context.new_field(None, return2.get_type(), "rdtscpField2");
+            let struct_type =
+                builder.context.new_struct_type(None, "rdtscpResult", &[field1, field2]);
+            return_value = builder.context.new_struct_constructor(
+                None,
+                struct_type.as_type(),
+                None,
+                &[return_value, return2],
+            );
+        }
         _ => (),
     }
 
@@ -1529,6 +1555,17 @@ pub fn intrinsic<'gcc, 'tcx>(name: &str, cx: &CodegenCx<'gcc, 'tcx>) -> Function
         "llvm.x86.aesdecwide128kl" => "__builtin_ia32_aesdecwide128kl_u8",
         "llvm.x86.aesencwide256kl" => "__builtin_ia32_aesencwide256kl_u8",
         "llvm.x86.aesdecwide256kl" => "__builtin_ia32_aesdecwide256kl_u8",
+        "llvm.x86.avx512.uitofp.round.v8f16.v8i16" => "__builtin_ia32_vcvtuw2ph128_mask",
+        "llvm.x86.avx512.uitofp.round.v16f16.v16i16" => "__builtin_ia32_vcvtuw2ph256_mask",
+        "llvm.x86.avx512.uitofp.round.v32f16.v32i16" => "__builtin_ia32_vcvtuw2ph512_mask_round",
+        "llvm.x86.avx512.uitofp.round.v8f16.v8i32" => "__builtin_ia32_vcvtudq2ph256_mask",
+        "llvm.x86.avx512.uitofp.round.v16f16.v16i32" => "__builtin_ia32_vcvtudq2ph512_mask_round",
+        "llvm.x86.avx512.uitofp.round.v8f16.v8i64" => "__builtin_ia32_vcvtuqq2ph512_mask_round",
+        "llvm.x86.avx512.uitofp.round.v8f64.v8i64" => "__builtin_ia32_cvtuqq2pd512_mask",
+        "llvm.x86.avx512.uitofp.round.v2f64.v2i64" => "__builtin_ia32_cvtuqq2pd128_mask",
+        "llvm.x86.avx512.uitofp.round.v4f64.v4i64" => "__builtin_ia32_cvtuqq2pd256_mask",
+        "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:
         "llvm.x86.ldtilecfg" => "__builtin_trap",
diff --git a/src/intrinsic/mod.rs b/src/intrinsic/mod.rs
index 4c10380fe74..497605978fe 100644
--- a/src/intrinsic/mod.rs
+++ b/src/intrinsic/mod.rs
@@ -114,7 +114,6 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
         }
         sym::copysignf32 => "copysignf",
         sym::copysignf64 => "copysign",
-        sym::copysignf128 => "copysignl",
         sym::floorf32 => "floorf",
         sym::floorf64 => "floor",
         sym::ceilf32 => "ceilf",
@@ -238,6 +237,7 @@ fn get_simple_function_f128_2args<'gcc, 'tcx>(
     let func_name = match name {
         sym::maxnumf128 => "fmaxf128",
         sym::minnumf128 => "fminf128",
+        sym::copysignf128 => "copysignf128",
         _ => return None,
     };
     Some(cx.context.new_function(
@@ -261,6 +261,7 @@ fn f16_builtin<'gcc, 'tcx>(
     let f32_type = cx.type_f32();
     let builtin_name = match name {
         sym::ceilf16 => "__builtin_ceilf",
+        sym::copysignf16 => "__builtin_copysignf",
         sym::floorf16 => "__builtin_floorf",
         sym::fmaf16 => "fmaf",
         sym::maxnumf16 => "__builtin_fmaxf",
@@ -330,6 +331,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                 )
             }
             sym::ceilf16
+            | sym::copysignf16
             | sym::floorf16
             | sym::fmaf16
             | sym::maxnumf16
diff --git a/tools/generate_intrinsics.py b/tools/generate_intrinsics.py
index ed0ebf00719..88927f39b93 100644
--- a/tools/generate_intrinsics.py
+++ b/tools/generate_intrinsics.py
@@ -176,14 +176,14 @@ def update_intrinsics(llvm_path, llvmint, llvmint2):
         out.write("// File generated by `rustc_codegen_gcc/tools/generate_intrinsics.py`\n")
         out.write("// DO NOT EDIT IT!\n")
         out.write("/// Translate a given LLVM intrinsic name to an equivalent GCC one.\n")
-        out.write("fn map_arch_intrinsic(name:&str)->&str{\n")
-        out.write('let Some(name) = name.strip_prefix("llvm.") else { unimplemented!("***** unsupported LLVM intrinsic {}", name) };\n')
+        out.write("fn map_arch_intrinsic(full_name:&str)->&'static str{\n")
+        out.write('let Some(name) = full_name.strip_prefix("llvm.") else { unimplemented!("***** unsupported LLVM intrinsic {}", full_name) };\n')
         out.write('let Some((arch, name)) = name.split_once(\'.\') else { unimplemented!("***** unsupported LLVM intrinsic {}", name) };\n')
         out.write("match arch {\n")
         for arch in archs:
             if len(intrinsics[arch]) == 0:
                 continue
-            out.write("\"{}\" => {{ #[allow(non_snake_case)] fn {}(name: &str) -> &str {{ match name {{".format(arch,arch))
+            out.write("\"{}\" => {{ #[allow(non_snake_case)] fn {}(name: &str,full_name:&str) -> &'static str {{ match name {{".format(arch,arch))
             intrinsics[arch].sort(key=lambda x: (x[0], x[2]))
             out.write('    // {}\n'.format(arch))
             for entry in intrinsics[arch]:
@@ -196,9 +196,9 @@ def update_intrinsics(llvm_path, llvmint, llvmint2):
                     out.write('    // [INVALID CONVERSION]: "{}" => "{}",\n'.format(llvm_name, entry[1]))
                 else:
                     out.write('    "{}" => "{}",\n'.format(llvm_name, entry[1]))
-            out.write('    _ => unimplemented!("***** unsupported LLVM intrinsic {}", name),\n')
-            out.write("}} }} {}(name) }}\n,".format(arch))
-        out.write('    _ => unimplemented!("***** unsupported LLVM architecture {}", name),\n')
+            out.write('    _ => unimplemented!("***** unsupported LLVM intrinsic {full_name}"),\n')
+            out.write("}} }} {}(name,full_name) }}\n,".format(arch))
+        out.write('    _ => unimplemented!("***** unsupported LLVM architecture {arch}, intrinsic:{full_name}"),\n')
         out.write("}\n}")
     subprocess.call(["rustfmt", output_file])
     print("Done!")
-- 
cgit 1.4.1-3-g733a5


From a1e6ae9c3ead5ecc72667e02458734905ed930b5 Mon Sep 17 00:00:00 2001
From: Dario Heinisch <dario.heinisch@gmail.com>
Date: Mon, 30 Jun 2025 18:54:49 +0200
Subject: FIX: NegMultiply should preserve parenthesis when method is called

changelog: [`neg_multiply`] does not remove parenthesis anymore if a method
is being called on the affected expression
---
 clippy_lints/src/neg_multiply.rs | 40 ++++++++++++++++++++++++++++++++--------
 tests/ui/neg_multiply.fixed      | 12 ++++++++++++
 tests/ui/neg_multiply.rs         | 12 ++++++++++++
 tests/ui/neg_multiply.stderr     |  8 +++++++-
 4 files changed, 63 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs
index 442280f9998..946114e1041 100644
--- a/clippy_lints/src/neg_multiply.rs
+++ b/clippy_lints/src/neg_multiply.rs
@@ -1,13 +1,13 @@
 use clippy_utils::consts::{self, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_with_context;
+use clippy_utils::get_parent_expr;
+use clippy_utils::source::{snippet, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::Span;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -33,6 +33,19 @@ declare_clippy_lint! {
 
 declare_lint_pass!(NegMultiply => [NEG_MULTIPLY]);
 
+fn is_in_parens_with_postfix(cx: &LateContext<'_>, mul_expr: &Expr<'_>) -> bool {
+    if let Some(parent) = get_parent_expr(cx, mul_expr) {
+        let mult_snippet = snippet(cx, mul_expr.span, "");
+        if has_enclosing_paren(&mult_snippet)
+            && let ExprKind::MethodCall(_, _, _, _) = parent.kind
+        {
+            return true;
+        }
+    }
+
+    false
+}
+
 impl<'tcx> LateLintPass<'tcx> for NegMultiply {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
         if let ExprKind::Binary(ref op, left, right) = e.kind
@@ -40,15 +53,15 @@ impl<'tcx> LateLintPass<'tcx> for NegMultiply {
         {
             match (&left.kind, &right.kind) {
                 (&ExprKind::Unary(..), &ExprKind::Unary(..)) => {},
-                (&ExprKind::Unary(UnOp::Neg, lit), _) => check_mul(cx, e.span, lit, right),
-                (_, &ExprKind::Unary(UnOp::Neg, lit)) => check_mul(cx, e.span, lit, left),
+                (&ExprKind::Unary(UnOp::Neg, lit), _) => check_mul(cx, e, lit, right),
+                (_, &ExprKind::Unary(UnOp::Neg, lit)) => check_mul(cx, e, lit, left),
                 _ => {},
             }
         }
     }
 }
 
-fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
+fn check_mul(cx: &LateContext<'_>, mul_expr: &Expr<'_>, lit: &Expr<'_>, exp: &Expr<'_>) {
     const F16_ONE: u16 = 1.0_f16.to_bits();
     const F128_ONE: u128 = 1.0_f128.to_bits();
     if let ExprKind::Lit(l) = lit.kind
@@ -63,8 +76,19 @@ fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
         && cx.typeck_results().expr_ty(exp).is_numeric()
     {
         let mut applicability = Applicability::MachineApplicable;
-        let (snip, from_macro) = snippet_with_context(cx, exp.span, span.ctxt(), "..", &mut applicability);
-        let suggestion = if !from_macro && cx.precedence(exp) < ExprPrecedence::Prefix && !has_enclosing_paren(&snip) {
+        let (snip, from_macro) = snippet_with_context(cx, exp.span, mul_expr.span.ctxt(), "..", &mut applicability);
+
+        let needs_parens_for_postfix = is_in_parens_with_postfix(cx, mul_expr);
+
+        let suggestion = if needs_parens_for_postfix {
+            // Special case: when the multiplication is in parentheses followed by a method call
+            // we need to preserve the grouping but negate the inner expression.
+            // Consider this expression: `((a.delta - 0.5).abs() * -1.0).total_cmp(&1.0)`
+            // We need to end up with: `(-(a.delta - 0.5).abs()).total_cmp(&1.0)`
+            // Otherwise, without the parentheses we would try to negate an Ordering:
+            // `-(a.delta - 0.5).abs().total_cmp(&1.0)`
+            format!("(-{snip})")
+        } else if !from_macro && cx.precedence(exp) < ExprPrecedence::Prefix && !has_enclosing_paren(&snip) {
             format!("-({snip})")
         } else {
             format!("-{snip}")
@@ -72,7 +96,7 @@ fn check_mul(cx: &LateContext<'_>, span: Span, lit: &Expr<'_>, exp: &Expr<'_>) {
         span_lint_and_sugg(
             cx,
             NEG_MULTIPLY,
-            span,
+            mul_expr.span,
             "this multiplication by -1 can be written more succinctly",
             "consider using",
             suggestion,
diff --git a/tests/ui/neg_multiply.fixed b/tests/ui/neg_multiply.fixed
index ff6e08300e2..93d314fea5f 100644
--- a/tests/ui/neg_multiply.fixed
+++ b/tests/ui/neg_multiply.fixed
@@ -82,3 +82,15 @@ fn float() {
 
     -1.0 * -1.0; // should be ok
 }
+
+struct Y {
+    delta: f64
+}
+
+fn nested() {
+    let a = Y {delta: 1.0};
+    let b = Y {delta: 1.0};
+    let _ = (-(a.delta - 0.5).abs()).total_cmp(&1.0);
+    //~^ neg_multiply
+    let _ = (-(a.delta - 0.5).abs()).total_cmp(&1.0);
+}
diff --git a/tests/ui/neg_multiply.rs b/tests/ui/neg_multiply.rs
index b0f4e85c78e..5b60b57e7ef 100644
--- a/tests/ui/neg_multiply.rs
+++ b/tests/ui/neg_multiply.rs
@@ -82,3 +82,15 @@ fn float() {
 
     -1.0 * -1.0; // should be ok
 }
+
+struct Y {
+    delta: f64
+}
+
+fn nested() {
+    let a = Y {delta: 1.0};
+    let b = Y {delta: 1.0};
+    let _ = ((a.delta - 0.5).abs() * -1.0).total_cmp(&1.0);
+    //~^ neg_multiply
+    let _ = (-(a.delta - 0.5).abs()).total_cmp(&1.0);
+}
diff --git a/tests/ui/neg_multiply.stderr b/tests/ui/neg_multiply.stderr
index 2ef7e32ce05..f4fb6d3ce54 100644
--- a/tests/ui/neg_multiply.stderr
+++ b/tests/ui/neg_multiply.stderr
@@ -97,5 +97,11 @@ error: this multiplication by -1 can be written more succinctly
 LL |     (3.0_f32 as f64) * -1.0;
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `-(3.0_f32 as f64)`
 
-error: aborting due to 16 previous errors
+error: this multiplication by -1 can be written more succinctly
+  --> tests/ui/neg_multiply.rs:93:13
+   |
+LL |     let _ = ((a.delta - 0.5).abs() * -1.0).total_cmp(&1.0);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-(a.delta - 0.5).abs())`
+
+error: aborting due to 17 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c69905a995dad100185ef38fffcb1ec3079ec66a Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Mon, 30 Jun 2025 19:45:09 +0200
Subject: Do not remove method call if type is adjusted

Propose to replace `x.map_or(false, |y| y == z)` by `x == Some(z)` only
if `x` is not adjusted. Otherwise, the type of `x` in the comparaison
may not be the expected one, as it may be the product of an auto-deref.
---
 clippy_lints/src/methods/unnecessary_map_or.rs |  3 ++-
 tests/ui/unnecessary_map_or.fixed              | 10 ++++++++++
 tests/ui/unnecessary_map_or.rs                 | 10 ++++++++++
 tests/ui/unnecessary_map_or.stderr             | 26 +++++++++++++++++++++++++-
 4 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/methods/unnecessary_map_or.rs b/clippy_lints/src/methods/unnecessary_map_or.rs
index b90748dd158..4a9007c607c 100644
--- a/clippy_lints/src/methods/unnecessary_map_or.rs
+++ b/clippy_lints/src/methods/unnecessary_map_or.rs
@@ -62,7 +62,8 @@ pub(super) fn check<'a>(
 
     let ext_def_span = def.span.until(map.span);
 
-    let (sugg, method, applicability) = if let ExprKind::Closure(map_closure) = map.kind
+    let (sugg, method, applicability) = if cx.typeck_results().expr_adjustments(recv).is_empty()
+            && let ExprKind::Closure(map_closure) = map.kind
             && let closure_body = cx.tcx.hir_body(map_closure.body)
             && let closure_body_value = closure_body.value.peel_blocks()
             && let ExprKind::Binary(op, l, r) = closure_body_value.kind
diff --git a/tests/ui/unnecessary_map_or.fixed b/tests/ui/unnecessary_map_or.fixed
index 3c724397284..3109c4af8e2 100644
--- a/tests/ui/unnecessary_map_or.fixed
+++ b/tests/ui/unnecessary_map_or.fixed
@@ -130,3 +130,13 @@ fn issue14201(a: Option<String>, b: Option<String>, s: &String) -> bool {
     //~^ unnecessary_map_or
     x && y
 }
+
+fn issue15180() {
+    let s = std::sync::Mutex::new(Some("foo"));
+    _ = s.lock().unwrap().is_some_and(|s| s == "foo");
+    //~^ unnecessary_map_or
+
+    let s = &&&&Some("foo");
+    _ = s.is_some_and(|s| s == "foo");
+    //~^ unnecessary_map_or
+}
diff --git a/tests/ui/unnecessary_map_or.rs b/tests/ui/unnecessary_map_or.rs
index e734a27bada..52a55f9fc9e 100644
--- a/tests/ui/unnecessary_map_or.rs
+++ b/tests/ui/unnecessary_map_or.rs
@@ -134,3 +134,13 @@ fn issue14201(a: Option<String>, b: Option<String>, s: &String) -> bool {
     //~^ unnecessary_map_or
     x && y
 }
+
+fn issue15180() {
+    let s = std::sync::Mutex::new(Some("foo"));
+    _ = s.lock().unwrap().map_or(false, |s| s == "foo");
+    //~^ unnecessary_map_or
+
+    let s = &&&&Some("foo");
+    _ = s.map_or(false, |s| s == "foo");
+    //~^ unnecessary_map_or
+}
diff --git a/tests/ui/unnecessary_map_or.stderr b/tests/ui/unnecessary_map_or.stderr
index 0f9466a6a6b..99e17e8b34b 100644
--- a/tests/ui/unnecessary_map_or.stderr
+++ b/tests/ui/unnecessary_map_or.stderr
@@ -326,5 +326,29 @@ LL -     let y = b.map_or(true, |b| b == *s);
 LL +     let y = b.is_none_or(|b| b == *s);
    |
 
-error: aborting due to 26 previous errors
+error: this `map_or` can be simplified
+  --> tests/ui/unnecessary_map_or.rs:140:9
+   |
+LL |     _ = s.lock().unwrap().map_or(false, |s| s == "foo");
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use is_some_and instead
+   |
+LL -     _ = s.lock().unwrap().map_or(false, |s| s == "foo");
+LL +     _ = s.lock().unwrap().is_some_and(|s| s == "foo");
+   |
+
+error: this `map_or` can be simplified
+  --> tests/ui/unnecessary_map_or.rs:144:9
+   |
+LL |     _ = s.map_or(false, |s| s == "foo");
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use is_some_and instead
+   |
+LL -     _ = s.map_or(false, |s| s == "foo");
+LL +     _ = s.is_some_and(|s| s == "foo");
+   |
+
+error: aborting due to 28 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8ceb91e1c7f3d644ca26f45ae63dac2216f98a4e Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Mon, 30 Jun 2025 20:43:45 +0200
Subject: Do not remove `as` if it changes the type

While `expr as T` can be removed as a statement if `expr` has no
side-effect, the `as T` part alone cannot be removed if the type
of `expr` would be ambiguous without the cast.
---
 clippy_lints/src/no_effect.rs        |  6 ++++--
 tests/ui/unnecessary_operation.fixed | 13 +++++++++++++
 tests/ui/unnecessary_operation.rs    | 13 +++++++++++++
 3 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 02c48166131..72e6503e7e4 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::source::SpanRangeExt;
-use clippy_utils::ty::has_drop;
+use clippy_utils::ty::{expr_type_is_certain, has_drop};
 use clippy_utils::{
     in_automatically_derived, is_inside_always_const_context, is_lint_allowed, path_to_local, peel_blocks,
 };
@@ -340,11 +340,13 @@ fn reduce_expression<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<Vec
         },
         ExprKind::Array(v) | ExprKind::Tup(v) => Some(v.iter().collect()),
         ExprKind::Repeat(inner, _)
-        | ExprKind::Cast(inner, _)
         | ExprKind::Type(inner, _)
         | ExprKind::Unary(_, inner)
         | ExprKind::Field(inner, _)
         | ExprKind::AddrOf(_, _, inner) => reduce_expression(cx, inner).or_else(|| Some(vec![inner])),
+        ExprKind::Cast(inner, _) if expr_type_is_certain(cx, inner) => {
+            reduce_expression(cx, inner).or_else(|| Some(vec![inner]))
+        },
         ExprKind::Struct(_, fields, ref base) => {
             if has_drop(cx, cx.typeck_results().expr_ty(expr)) {
                 None
diff --git a/tests/ui/unnecessary_operation.fixed b/tests/ui/unnecessary_operation.fixed
index 645b56fe95e..ac9fa4de20a 100644
--- a/tests/ui/unnecessary_operation.fixed
+++ b/tests/ui/unnecessary_operation.fixed
@@ -144,3 +144,16 @@ const fn foo() {
     assert!([42, 55].len() > get_usize());
     //~^ unnecessary_operation
 }
+
+fn issue15173() {
+    // No lint as `Box::new(None)` alone would be ambiguous
+    Box::new(None) as Box<Option<i32>>;
+}
+
+#[expect(clippy::redundant_closure_call)]
+fn issue15173_original<MsU>(handler: impl FnOnce() -> MsU + Clone + 'static) {
+    Box::new(move |value| {
+        (|_| handler.clone()())(value);
+        None
+    }) as Box<dyn Fn(i32) -> Option<i32>>;
+}
diff --git a/tests/ui/unnecessary_operation.rs b/tests/ui/unnecessary_operation.rs
index 97e90269c5c..a3e6c6288ad 100644
--- a/tests/ui/unnecessary_operation.rs
+++ b/tests/ui/unnecessary_operation.rs
@@ -150,3 +150,16 @@ const fn foo() {
     [42, 55][get_usize()];
     //~^ unnecessary_operation
 }
+
+fn issue15173() {
+    // No lint as `Box::new(None)` alone would be ambiguous
+    Box::new(None) as Box<Option<i32>>;
+}
+
+#[expect(clippy::redundant_closure_call)]
+fn issue15173_original<MsU>(handler: impl FnOnce() -> MsU + Clone + 'static) {
+    Box::new(move |value| {
+        (|_| handler.clone()())(value);
+        None
+    }) as Box<dyn Fn(i32) -> Option<i32>>;
+}
-- 
cgit 1.4.1-3-g733a5


From 9a7db566d7b7bb534c5dc3bcfbd2ddd51d99a8d5 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Tue, 1 Jul 2025 02:45:14 +0500
Subject: moved tests

---
 tests/ui/codegen/output-slot-init-vs-noninit.rs    | 68 ++++++++++++++++++++++
 tests/ui/codegen/remark-flag-functionality.rs      | 28 +++++++++
 tests/ui/codegen/shift-right-operand-mutation.rs   | 12 ++++
 tests/ui/codegen/sret-aliasing-rules.rs            | 23 ++++++++
 tests/ui/macros/macro-paren-span-diagnostic.rs     | 21 +++++++
 tests/ui/macros/macro-paren-span-diagnostic.stderr |  9 +++
 tests/ui/optimization-remark.rs                    | 28 ---------
 tests/ui/out-pointer-aliasing.rs                   | 23 --------
 tests/ui/output-slot-variants.rs                   | 68 ----------------------
 tests/ui/over-constrained-vregs.rs                 | 12 ----
 tests/ui/panic-while-printing.rs                   | 25 --------
 tests/ui/panic_implementation-closures.rs          | 10 ----
 tests/ui/panics/panic-during-display-formatting.rs | 25 ++++++++
 tests/ui/panics/panic-handler-closures.rs          | 10 ++++
 tests/ui/paren-span.rs                             | 21 -------
 tests/ui/paren-span.stderr                         |  9 ---
 tests/ui/parser/ufcs-return-unused-parens.fixed    | 17 ++++++
 tests/ui/parser/ufcs-return-unused-parens.rs       | 17 ++++++
 tests/ui/parser/ufcs-return-unused-parens.stderr   | 19 ++++++
 tests/ui/partialeq_help.rs                         | 12 ----
 tests/ui/partialeq_help.stderr                     | 35 -----------
 tests/ui/path-lookahead.fixed                      | 17 ------
 tests/ui/path-lookahead.rs                         | 17 ------
 tests/ui/path-lookahead.stderr                     | 19 ------
 .../ui/traits/partialeq-ref-mismatch-diagnostic.rs | 12 ++++
 .../partialeq-ref-mismatch-diagnostic.stderr       | 35 +++++++++++
 26 files changed, 296 insertions(+), 296 deletions(-)
 create mode 100644 tests/ui/codegen/output-slot-init-vs-noninit.rs
 create mode 100644 tests/ui/codegen/remark-flag-functionality.rs
 create mode 100644 tests/ui/codegen/shift-right-operand-mutation.rs
 create mode 100644 tests/ui/codegen/sret-aliasing-rules.rs
 create mode 100644 tests/ui/macros/macro-paren-span-diagnostic.rs
 create mode 100644 tests/ui/macros/macro-paren-span-diagnostic.stderr
 delete mode 100644 tests/ui/optimization-remark.rs
 delete mode 100644 tests/ui/out-pointer-aliasing.rs
 delete mode 100644 tests/ui/output-slot-variants.rs
 delete mode 100644 tests/ui/over-constrained-vregs.rs
 delete mode 100644 tests/ui/panic-while-printing.rs
 delete mode 100644 tests/ui/panic_implementation-closures.rs
 create mode 100644 tests/ui/panics/panic-during-display-formatting.rs
 create mode 100644 tests/ui/panics/panic-handler-closures.rs
 delete mode 100644 tests/ui/paren-span.rs
 delete mode 100644 tests/ui/paren-span.stderr
 create mode 100644 tests/ui/parser/ufcs-return-unused-parens.fixed
 create mode 100644 tests/ui/parser/ufcs-return-unused-parens.rs
 create mode 100644 tests/ui/parser/ufcs-return-unused-parens.stderr
 delete mode 100644 tests/ui/partialeq_help.rs
 delete mode 100644 tests/ui/partialeq_help.stderr
 delete mode 100644 tests/ui/path-lookahead.fixed
 delete mode 100644 tests/ui/path-lookahead.rs
 delete mode 100644 tests/ui/path-lookahead.stderr
 create mode 100644 tests/ui/traits/partialeq-ref-mismatch-diagnostic.rs
 create mode 100644 tests/ui/traits/partialeq-ref-mismatch-diagnostic.stderr

diff --git a/tests/ui/codegen/output-slot-init-vs-noninit.rs b/tests/ui/codegen/output-slot-init-vs-noninit.rs
new file mode 100644
index 00000000000..97757e74fc4
--- /dev/null
+++ b/tests/ui/codegen/output-slot-init-vs-noninit.rs
@@ -0,0 +1,68 @@
+//@ run-pass
+
+#![allow(dead_code)]
+#![allow(unused_assignments)]
+#![allow(unknown_lints)]
+
+#![allow(dead_assignment)]
+#![allow(unused_variables)]
+
+struct A { a: isize, b: isize }
+struct Abox { a: Box<isize>, b: Box<isize> }
+
+fn ret_int_i() -> isize { 10 }
+
+fn ret_ext_i() -> Box<isize> { Box::new(10) }
+
+fn ret_int_rec() -> A { A {a: 10, b: 10} }
+
+fn ret_ext_rec() -> Box<A> { Box::new(A {a: 10, b: 10}) }
+
+fn ret_ext_mem() -> Abox { Abox {a: Box::new(10), b: Box::new(10) } }
+
+fn ret_ext_ext_mem() -> Box<Abox> { Box::new(Abox{a: Box::new(10), b: Box::new(10) }) }
+
+pub fn main() {
+    let mut int_i: isize;
+    let mut ext_i: Box<isize>;
+    let mut int_rec: A;
+    let mut ext_rec: Box<A>;
+    let mut ext_mem: Abox;
+    let mut ext_ext_mem: Box<Abox>;
+    int_i = ret_int_i(); // initializing
+
+    int_i = ret_int_i(); // non-initializing
+
+    int_i = ret_int_i(); // non-initializing
+
+    ext_i = ret_ext_i(); // initializing
+
+    ext_i = ret_ext_i(); // non-initializing
+
+    ext_i = ret_ext_i(); // non-initializing
+
+    int_rec = ret_int_rec(); // initializing
+
+    int_rec = ret_int_rec(); // non-initializing
+
+    int_rec = ret_int_rec(); // non-initializing
+
+    ext_rec = ret_ext_rec(); // initializing
+
+    ext_rec = ret_ext_rec(); // non-initializing
+
+    ext_rec = ret_ext_rec(); // non-initializing
+
+    ext_mem = ret_ext_mem(); // initializing
+
+    ext_mem = ret_ext_mem(); // non-initializing
+
+    ext_mem = ret_ext_mem(); // non-initializing
+
+    ext_ext_mem = ret_ext_ext_mem(); // initializing
+
+    ext_ext_mem = ret_ext_ext_mem(); // non-initializing
+
+    ext_ext_mem = ret_ext_ext_mem(); // non-initializing
+
+}
diff --git a/tests/ui/codegen/remark-flag-functionality.rs b/tests/ui/codegen/remark-flag-functionality.rs
new file mode 100644
index 00000000000..165fc63c007
--- /dev/null
+++ b/tests/ui/codegen/remark-flag-functionality.rs
@@ -0,0 +1,28 @@
+//@ build-pass
+//@ ignore-pass
+//@ revisions: all inline merge1 merge2
+//@ compile-flags: --crate-type=lib -Cdebuginfo=1 -Copt-level=2
+//
+// Check that remarks can be enabled individually or with "all":
+//
+//@ [all]    compile-flags: -Cremark=all
+//@ [inline] compile-flags: -Cremark=inline
+//
+// Check that values of -Cremark flag are accumulated:
+//
+//@ [merge1] compile-flags: -Cremark=all    -Cremark=giraffe
+//@ [merge2] compile-flags: -Cremark=inline -Cremark=giraffe
+//@ dont-check-compiler-stderr
+//@ dont-require-annotations: NOTE
+
+#[no_mangle]
+#[inline(never)]
+pub fn f() {
+}
+
+#[no_mangle]
+pub fn g() {
+    f();
+}
+
+//~? NOTE inline (missed): 'f' not inlined into 'g'
diff --git a/tests/ui/codegen/shift-right-operand-mutation.rs b/tests/ui/codegen/shift-right-operand-mutation.rs
new file mode 100644
index 00000000000..016a667e937
--- /dev/null
+++ b/tests/ui/codegen/shift-right-operand-mutation.rs
@@ -0,0 +1,12 @@
+//@ run-pass
+
+#![allow(unused_must_use)]
+// Regression test for issue #152.
+pub fn main() {
+    let mut b: usize = 1_usize;
+    while b < std::mem::size_of::<usize>() {
+        0_usize << b;
+        b <<= 1_usize;
+        println!("{}", b);
+    }
+}
diff --git a/tests/ui/codegen/sret-aliasing-rules.rs b/tests/ui/codegen/sret-aliasing-rules.rs
new file mode 100644
index 00000000000..0dfaa19fadb
--- /dev/null
+++ b/tests/ui/codegen/sret-aliasing-rules.rs
@@ -0,0 +1,23 @@
+//@ run-pass
+
+#[derive(Copy, Clone)]
+pub struct Foo {
+    f1: isize,
+    _f2: isize,
+}
+
+#[inline(never)]
+pub fn foo(f: &mut Foo) -> Foo {
+    let ret = *f;
+    f.f1 = 0;
+    ret
+}
+
+pub fn main() {
+    let mut f = Foo {
+        f1: 8,
+        _f2: 9,
+    };
+    f = foo(&mut f);
+    assert_eq!(f.f1, 8);
+}
diff --git a/tests/ui/macros/macro-paren-span-diagnostic.rs b/tests/ui/macros/macro-paren-span-diagnostic.rs
new file mode 100644
index 00000000000..c8cb63d5190
--- /dev/null
+++ b/tests/ui/macros/macro-paren-span-diagnostic.rs
@@ -0,0 +1,21 @@
+// Be smart about span of parenthesized expression in macro.
+
+macro_rules! paren {
+    ($e:expr) => (($e))
+    //            ^^^^ do not highlight here
+}
+
+mod m {
+    pub struct S {
+        x: i32
+    }
+    pub fn make() -> S {
+        S { x: 0 }
+    }
+}
+
+fn main() {
+    let s = m::make();
+    paren!(s.x); //~ ERROR field `x` of struct `S` is private
+    //     ^^^ highlight here
+}
diff --git a/tests/ui/macros/macro-paren-span-diagnostic.stderr b/tests/ui/macros/macro-paren-span-diagnostic.stderr
new file mode 100644
index 00000000000..da2f57033a4
--- /dev/null
+++ b/tests/ui/macros/macro-paren-span-diagnostic.stderr
@@ -0,0 +1,9 @@
+error[E0616]: field `x` of struct `S` is private
+  --> $DIR/paren-span.rs:19:14
+   |
+LL |     paren!(s.x);
+   |              ^ private field
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/optimization-remark.rs b/tests/ui/optimization-remark.rs
deleted file mode 100644
index 165fc63c007..00000000000
--- a/tests/ui/optimization-remark.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ build-pass
-//@ ignore-pass
-//@ revisions: all inline merge1 merge2
-//@ compile-flags: --crate-type=lib -Cdebuginfo=1 -Copt-level=2
-//
-// Check that remarks can be enabled individually or with "all":
-//
-//@ [all]    compile-flags: -Cremark=all
-//@ [inline] compile-flags: -Cremark=inline
-//
-// Check that values of -Cremark flag are accumulated:
-//
-//@ [merge1] compile-flags: -Cremark=all    -Cremark=giraffe
-//@ [merge2] compile-flags: -Cremark=inline -Cremark=giraffe
-//@ dont-check-compiler-stderr
-//@ dont-require-annotations: NOTE
-
-#[no_mangle]
-#[inline(never)]
-pub fn f() {
-}
-
-#[no_mangle]
-pub fn g() {
-    f();
-}
-
-//~? NOTE inline (missed): 'f' not inlined into 'g'
diff --git a/tests/ui/out-pointer-aliasing.rs b/tests/ui/out-pointer-aliasing.rs
deleted file mode 100644
index 0dfaa19fadb..00000000000
--- a/tests/ui/out-pointer-aliasing.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ run-pass
-
-#[derive(Copy, Clone)]
-pub struct Foo {
-    f1: isize,
-    _f2: isize,
-}
-
-#[inline(never)]
-pub fn foo(f: &mut Foo) -> Foo {
-    let ret = *f;
-    f.f1 = 0;
-    ret
-}
-
-pub fn main() {
-    let mut f = Foo {
-        f1: 8,
-        _f2: 9,
-    };
-    f = foo(&mut f);
-    assert_eq!(f.f1, 8);
-}
diff --git a/tests/ui/output-slot-variants.rs b/tests/ui/output-slot-variants.rs
deleted file mode 100644
index 97757e74fc4..00000000000
--- a/tests/ui/output-slot-variants.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//@ run-pass
-
-#![allow(dead_code)]
-#![allow(unused_assignments)]
-#![allow(unknown_lints)]
-
-#![allow(dead_assignment)]
-#![allow(unused_variables)]
-
-struct A { a: isize, b: isize }
-struct Abox { a: Box<isize>, b: Box<isize> }
-
-fn ret_int_i() -> isize { 10 }
-
-fn ret_ext_i() -> Box<isize> { Box::new(10) }
-
-fn ret_int_rec() -> A { A {a: 10, b: 10} }
-
-fn ret_ext_rec() -> Box<A> { Box::new(A {a: 10, b: 10}) }
-
-fn ret_ext_mem() -> Abox { Abox {a: Box::new(10), b: Box::new(10) } }
-
-fn ret_ext_ext_mem() -> Box<Abox> { Box::new(Abox{a: Box::new(10), b: Box::new(10) }) }
-
-pub fn main() {
-    let mut int_i: isize;
-    let mut ext_i: Box<isize>;
-    let mut int_rec: A;
-    let mut ext_rec: Box<A>;
-    let mut ext_mem: Abox;
-    let mut ext_ext_mem: Box<Abox>;
-    int_i = ret_int_i(); // initializing
-
-    int_i = ret_int_i(); // non-initializing
-
-    int_i = ret_int_i(); // non-initializing
-
-    ext_i = ret_ext_i(); // initializing
-
-    ext_i = ret_ext_i(); // non-initializing
-
-    ext_i = ret_ext_i(); // non-initializing
-
-    int_rec = ret_int_rec(); // initializing
-
-    int_rec = ret_int_rec(); // non-initializing
-
-    int_rec = ret_int_rec(); // non-initializing
-
-    ext_rec = ret_ext_rec(); // initializing
-
-    ext_rec = ret_ext_rec(); // non-initializing
-
-    ext_rec = ret_ext_rec(); // non-initializing
-
-    ext_mem = ret_ext_mem(); // initializing
-
-    ext_mem = ret_ext_mem(); // non-initializing
-
-    ext_mem = ret_ext_mem(); // non-initializing
-
-    ext_ext_mem = ret_ext_ext_mem(); // initializing
-
-    ext_ext_mem = ret_ext_ext_mem(); // non-initializing
-
-    ext_ext_mem = ret_ext_ext_mem(); // non-initializing
-
-}
diff --git a/tests/ui/over-constrained-vregs.rs b/tests/ui/over-constrained-vregs.rs
deleted file mode 100644
index 016a667e937..00000000000
--- a/tests/ui/over-constrained-vregs.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ run-pass
-
-#![allow(unused_must_use)]
-// Regression test for issue #152.
-pub fn main() {
-    let mut b: usize = 1_usize;
-    while b < std::mem::size_of::<usize>() {
-        0_usize << b;
-        b <<= 1_usize;
-        println!("{}", b);
-    }
-}
diff --git a/tests/ui/panic-while-printing.rs b/tests/ui/panic-while-printing.rs
deleted file mode 100644
index 6505a69fef7..00000000000
--- a/tests/ui/panic-while-printing.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ run-pass
-//@ needs-unwind
-
-#![feature(internal_output_capture)]
-
-use std::fmt;
-use std::fmt::{Display, Formatter};
-use std::io::set_output_capture;
-use std::sync::{Arc, Mutex};
-
-pub struct A;
-
-impl Display for A {
-    fn fmt(&self, _f: &mut Formatter<'_>) -> fmt::Result {
-        panic!();
-    }
-}
-
-fn main() {
-    set_output_capture(Some(Arc::new(Mutex::new(Vec::new()))));
-    assert!(std::panic::catch_unwind(|| {
-        eprintln!("{}", A);
-    })
-    .is_err());
-}
diff --git a/tests/ui/panic_implementation-closures.rs b/tests/ui/panic_implementation-closures.rs
deleted file mode 100644
index b161859bf9c..00000000000
--- a/tests/ui/panic_implementation-closures.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ build-pass (FIXME(62277): could be check-pass?)
-
-#![crate_type = "rlib"]
-#![no_std]
-
-#[panic_handler]
-pub fn panic_fmt(_: &::core::panic::PanicInfo) -> ! {
-    |x: u8| x;
-    loop {}
-}
diff --git a/tests/ui/panics/panic-during-display-formatting.rs b/tests/ui/panics/panic-during-display-formatting.rs
new file mode 100644
index 00000000000..6505a69fef7
--- /dev/null
+++ b/tests/ui/panics/panic-during-display-formatting.rs
@@ -0,0 +1,25 @@
+//@ run-pass
+//@ needs-unwind
+
+#![feature(internal_output_capture)]
+
+use std::fmt;
+use std::fmt::{Display, Formatter};
+use std::io::set_output_capture;
+use std::sync::{Arc, Mutex};
+
+pub struct A;
+
+impl Display for A {
+    fn fmt(&self, _f: &mut Formatter<'_>) -> fmt::Result {
+        panic!();
+    }
+}
+
+fn main() {
+    set_output_capture(Some(Arc::new(Mutex::new(Vec::new()))));
+    assert!(std::panic::catch_unwind(|| {
+        eprintln!("{}", A);
+    })
+    .is_err());
+}
diff --git a/tests/ui/panics/panic-handler-closures.rs b/tests/ui/panics/panic-handler-closures.rs
new file mode 100644
index 00000000000..b161859bf9c
--- /dev/null
+++ b/tests/ui/panics/panic-handler-closures.rs
@@ -0,0 +1,10 @@
+//@ build-pass (FIXME(62277): could be check-pass?)
+
+#![crate_type = "rlib"]
+#![no_std]
+
+#[panic_handler]
+pub fn panic_fmt(_: &::core::panic::PanicInfo) -> ! {
+    |x: u8| x;
+    loop {}
+}
diff --git a/tests/ui/paren-span.rs b/tests/ui/paren-span.rs
deleted file mode 100644
index c8cb63d5190..00000000000
--- a/tests/ui/paren-span.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Be smart about span of parenthesized expression in macro.
-
-macro_rules! paren {
-    ($e:expr) => (($e))
-    //            ^^^^ do not highlight here
-}
-
-mod m {
-    pub struct S {
-        x: i32
-    }
-    pub fn make() -> S {
-        S { x: 0 }
-    }
-}
-
-fn main() {
-    let s = m::make();
-    paren!(s.x); //~ ERROR field `x` of struct `S` is private
-    //     ^^^ highlight here
-}
diff --git a/tests/ui/paren-span.stderr b/tests/ui/paren-span.stderr
deleted file mode 100644
index da2f57033a4..00000000000
--- a/tests/ui/paren-span.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0616]: field `x` of struct `S` is private
-  --> $DIR/paren-span.rs:19:14
-   |
-LL |     paren!(s.x);
-   |              ^ private field
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0616`.
diff --git a/tests/ui/parser/ufcs-return-unused-parens.fixed b/tests/ui/parser/ufcs-return-unused-parens.fixed
new file mode 100644
index 00000000000..440b22edd7d
--- /dev/null
+++ b/tests/ui/parser/ufcs-return-unused-parens.fixed
@@ -0,0 +1,17 @@
+//@ run-pass
+//@ run-rustfix
+
+#![allow(dead_code)]
+#![warn(unused_parens)]
+
+// Parser test for #37765
+
+fn with_parens<T: ToString>(arg: T) -> String {
+    return <T as ToString>::to_string(&arg); //~WARN unnecessary parentheses around `return` value
+}
+
+fn no_parens<T: ToString>(arg: T) -> String {
+    return <T as ToString>::to_string(&arg);
+}
+
+fn main() {}
diff --git a/tests/ui/parser/ufcs-return-unused-parens.rs b/tests/ui/parser/ufcs-return-unused-parens.rs
new file mode 100644
index 00000000000..7eaacd6bba7
--- /dev/null
+++ b/tests/ui/parser/ufcs-return-unused-parens.rs
@@ -0,0 +1,17 @@
+//@ run-pass
+//@ run-rustfix
+
+#![allow(dead_code)]
+#![warn(unused_parens)]
+
+// Parser test for #37765
+
+fn with_parens<T: ToString>(arg: T) -> String {
+    return (<T as ToString>::to_string(&arg)); //~WARN unnecessary parentheses around `return` value
+}
+
+fn no_parens<T: ToString>(arg: T) -> String {
+    return <T as ToString>::to_string(&arg);
+}
+
+fn main() {}
diff --git a/tests/ui/parser/ufcs-return-unused-parens.stderr b/tests/ui/parser/ufcs-return-unused-parens.stderr
new file mode 100644
index 00000000000..2cc786fd947
--- /dev/null
+++ b/tests/ui/parser/ufcs-return-unused-parens.stderr
@@ -0,0 +1,19 @@
+warning: unnecessary parentheses around `return` value
+  --> $DIR/path-lookahead.rs:10:12
+   |
+LL |     return (<T as ToString>::to_string(&arg));
+   |            ^                                ^
+   |
+note: the lint level is defined here
+  --> $DIR/path-lookahead.rs:5:9
+   |
+LL | #![warn(unused_parens)]
+   |         ^^^^^^^^^^^^^
+help: remove these parentheses
+   |
+LL -     return (<T as ToString>::to_string(&arg));
+LL +     return <T as ToString>::to_string(&arg);
+   |
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/partialeq_help.rs b/tests/ui/partialeq_help.rs
deleted file mode 100644
index 34b88b8a866..00000000000
--- a/tests/ui/partialeq_help.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-fn foo<T: PartialEq>(a: &T, b: T) {
-    a == b; //~ ERROR E0277
-}
-
-fn foo2<T: PartialEq>(a: &T, b: T) where {
-    a == b; //~ ERROR E0277
-}
-
-fn main() {
-    foo(&1, 1);
-    foo2(&1, 1);
-}
diff --git a/tests/ui/partialeq_help.stderr b/tests/ui/partialeq_help.stderr
deleted file mode 100644
index f5de1308e87..00000000000
--- a/tests/ui/partialeq_help.stderr
+++ /dev/null
@@ -1,35 +0,0 @@
-error[E0277]: can't compare `&T` with `T`
-  --> $DIR/partialeq_help.rs:2:7
-   |
-LL |     a == b;
-   |       ^^ no implementation for `&T == T`
-   |
-   = help: the trait `PartialEq<T>` is not implemented for `&T`
-help: consider dereferencing here
-   |
-LL |     *a == b;
-   |     +
-help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
-   |
-LL | fn foo<T: PartialEq>(a: &T, b: T) where &T: PartialEq<T> {
-   |                                   ++++++++++++++++++++++
-
-error[E0277]: can't compare `&T` with `T`
-  --> $DIR/partialeq_help.rs:6:7
-   |
-LL |     a == b;
-   |       ^^ no implementation for `&T == T`
-   |
-   = help: the trait `PartialEq<T>` is not implemented for `&T`
-help: consider dereferencing here
-   |
-LL |     *a == b;
-   |     +
-help: consider extending the `where` clause, but there might be an alternative better way to express this requirement
-   |
-LL | fn foo2<T: PartialEq>(a: &T, b: T) where &T: PartialEq<T> {
-   |                                          ++++++++++++++++
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/path-lookahead.fixed b/tests/ui/path-lookahead.fixed
deleted file mode 100644
index 440b22edd7d..00000000000
--- a/tests/ui/path-lookahead.fixed
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ run-pass
-//@ run-rustfix
-
-#![allow(dead_code)]
-#![warn(unused_parens)]
-
-// Parser test for #37765
-
-fn with_parens<T: ToString>(arg: T) -> String {
-    return <T as ToString>::to_string(&arg); //~WARN unnecessary parentheses around `return` value
-}
-
-fn no_parens<T: ToString>(arg: T) -> String {
-    return <T as ToString>::to_string(&arg);
-}
-
-fn main() {}
diff --git a/tests/ui/path-lookahead.rs b/tests/ui/path-lookahead.rs
deleted file mode 100644
index 7eaacd6bba7..00000000000
--- a/tests/ui/path-lookahead.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ run-pass
-//@ run-rustfix
-
-#![allow(dead_code)]
-#![warn(unused_parens)]
-
-// Parser test for #37765
-
-fn with_parens<T: ToString>(arg: T) -> String {
-    return (<T as ToString>::to_string(&arg)); //~WARN unnecessary parentheses around `return` value
-}
-
-fn no_parens<T: ToString>(arg: T) -> String {
-    return <T as ToString>::to_string(&arg);
-}
-
-fn main() {}
diff --git a/tests/ui/path-lookahead.stderr b/tests/ui/path-lookahead.stderr
deleted file mode 100644
index 2cc786fd947..00000000000
--- a/tests/ui/path-lookahead.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-warning: unnecessary parentheses around `return` value
-  --> $DIR/path-lookahead.rs:10:12
-   |
-LL |     return (<T as ToString>::to_string(&arg));
-   |            ^                                ^
-   |
-note: the lint level is defined here
-  --> $DIR/path-lookahead.rs:5:9
-   |
-LL | #![warn(unused_parens)]
-   |         ^^^^^^^^^^^^^
-help: remove these parentheses
-   |
-LL -     return (<T as ToString>::to_string(&arg));
-LL +     return <T as ToString>::to_string(&arg);
-   |
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/traits/partialeq-ref-mismatch-diagnostic.rs b/tests/ui/traits/partialeq-ref-mismatch-diagnostic.rs
new file mode 100644
index 00000000000..34b88b8a866
--- /dev/null
+++ b/tests/ui/traits/partialeq-ref-mismatch-diagnostic.rs
@@ -0,0 +1,12 @@
+fn foo<T: PartialEq>(a: &T, b: T) {
+    a == b; //~ ERROR E0277
+}
+
+fn foo2<T: PartialEq>(a: &T, b: T) where {
+    a == b; //~ ERROR E0277
+}
+
+fn main() {
+    foo(&1, 1);
+    foo2(&1, 1);
+}
diff --git a/tests/ui/traits/partialeq-ref-mismatch-diagnostic.stderr b/tests/ui/traits/partialeq-ref-mismatch-diagnostic.stderr
new file mode 100644
index 00000000000..f5de1308e87
--- /dev/null
+++ b/tests/ui/traits/partialeq-ref-mismatch-diagnostic.stderr
@@ -0,0 +1,35 @@
+error[E0277]: can't compare `&T` with `T`
+  --> $DIR/partialeq_help.rs:2:7
+   |
+LL |     a == b;
+   |       ^^ no implementation for `&T == T`
+   |
+   = help: the trait `PartialEq<T>` is not implemented for `&T`
+help: consider dereferencing here
+   |
+LL |     *a == b;
+   |     +
+help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
+   |
+LL | fn foo<T: PartialEq>(a: &T, b: T) where &T: PartialEq<T> {
+   |                                   ++++++++++++++++++++++
+
+error[E0277]: can't compare `&T` with `T`
+  --> $DIR/partialeq_help.rs:6:7
+   |
+LL |     a == b;
+   |       ^^ no implementation for `&T == T`
+   |
+   = help: the trait `PartialEq<T>` is not implemented for `&T`
+help: consider dereferencing here
+   |
+LL |     *a == b;
+   |     +
+help: consider extending the `where` clause, but there might be an alternative better way to express this requirement
+   |
+LL | fn foo2<T: PartialEq>(a: &T, b: T) where &T: PartialEq<T> {
+   |                                          ++++++++++++++++
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From fd3161c20125252db57a5a14f8031338c431f626 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Mon, 30 Jun 2025 18:58:43 -0700
Subject: Mention as_chunks in the docs for chunks

---
 library/core/src/slice/mod.rs | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index 3a3f44c6b85..b472307871f 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -1120,6 +1120,9 @@ impl<T> [T] {
     /// `chunk_size` elements, and [`rchunks`] for the same iterator but starting at the end of the
     /// slice.
     ///
+    /// If your `chunk_size` is a constant, consider using [`as_chunks`] instead, which will
+    /// give references to arrays of exactly that length, rather than slices.
+    ///
     /// # Panics
     ///
     /// Panics if `chunk_size` is zero.
@@ -1137,6 +1140,7 @@ impl<T> [T] {
     ///
     /// [`chunks_exact`]: slice::chunks_exact
     /// [`rchunks`]: slice::rchunks
+    /// [`as_chunks`]: slice::as_chunks
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_const_unstable(feature = "const_slice_make_iter", issue = "137737")]
     #[inline]
@@ -1156,6 +1160,9 @@ impl<T> [T] {
     /// exactly `chunk_size` elements, and [`rchunks_mut`] for the same iterator but starting at
     /// the end of the slice.
     ///
+    /// If your `chunk_size` is a constant, consider using [`as_chunks_mut`] instead, which will
+    /// give references to arrays of exactly that length, rather than slices.
+    ///
     /// # Panics
     ///
     /// Panics if `chunk_size` is zero.
@@ -1177,6 +1184,7 @@ impl<T> [T] {
     ///
     /// [`chunks_exact_mut`]: slice::chunks_exact_mut
     /// [`rchunks_mut`]: slice::rchunks_mut
+    /// [`as_chunks_mut`]: slice::as_chunks_mut
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_const_unstable(feature = "const_slice_make_iter", issue = "137737")]
     #[inline]
@@ -1199,6 +1207,9 @@ impl<T> [T] {
     /// See [`chunks`] for a variant of this iterator that also returns the remainder as a smaller
     /// chunk, and [`rchunks_exact`] for the same iterator but starting at the end of the slice.
     ///
+    /// If your `chunk_size` is a constant, consider using [`as_chunks`] instead, which will
+    /// give references to arrays of exactly that length, rather than slices.
+    ///
     /// # Panics
     ///
     /// Panics if `chunk_size` is zero.
@@ -1216,6 +1227,7 @@ impl<T> [T] {
     ///
     /// [`chunks`]: slice::chunks
     /// [`rchunks_exact`]: slice::rchunks_exact
+    /// [`as_chunks`]: slice::chunks
     #[stable(feature = "chunks_exact", since = "1.31.0")]
     #[rustc_const_unstable(feature = "const_slice_make_iter", issue = "137737")]
     #[inline]
@@ -1239,6 +1251,9 @@ impl<T> [T] {
     /// smaller chunk, and [`rchunks_exact_mut`] for the same iterator but starting at the end of
     /// the slice.
     ///
+    /// If your `chunk_size` is a constant, consider using [`as_chunks_mut`] instead, which will
+    /// give references to arrays of exactly that length, rather than slices.
+    ///
     /// # Panics
     ///
     /// Panics if `chunk_size` is zero.
@@ -1260,6 +1275,7 @@ impl<T> [T] {
     ///
     /// [`chunks_mut`]: slice::chunks_mut
     /// [`rchunks_exact_mut`]: slice::rchunks_exact_mut
+    /// [`as_chunks_mut`]: slice::as_chunks_mut
     #[stable(feature = "chunks_exact", since = "1.31.0")]
     #[rustc_const_unstable(feature = "const_slice_make_iter", issue = "137737")]
     #[inline]
@@ -1707,6 +1723,9 @@ impl<T> [T] {
     /// `chunk_size` elements, and [`chunks`] for the same iterator but starting at the beginning
     /// of the slice.
     ///
+    /// If your `chunk_size` is a constant, consider using [`as_rchunks`] instead, which will
+    /// give references to arrays of exactly that length, rather than slices.
+    ///
     /// # Panics
     ///
     /// Panics if `chunk_size` is zero.
@@ -1724,6 +1743,7 @@ impl<T> [T] {
     ///
     /// [`rchunks_exact`]: slice::rchunks_exact
     /// [`chunks`]: slice::chunks
+    /// [`as_rchunks`]: slice::as_rchunks
     #[stable(feature = "rchunks", since = "1.31.0")]
     #[rustc_const_unstable(feature = "const_slice_make_iter", issue = "137737")]
     #[inline]
@@ -1743,6 +1763,9 @@ impl<T> [T] {
     /// exactly `chunk_size` elements, and [`chunks_mut`] for the same iterator but starting at the
     /// beginning of the slice.
     ///
+    /// If your `chunk_size` is a constant, consider using [`as_rchunks_mut`] instead, which will
+    /// give references to arrays of exactly that length, rather than slices.
+    ///
     /// # Panics
     ///
     /// Panics if `chunk_size` is zero.
@@ -1764,6 +1787,7 @@ impl<T> [T] {
     ///
     /// [`rchunks_exact_mut`]: slice::rchunks_exact_mut
     /// [`chunks_mut`]: slice::chunks_mut
+    /// [`as_rchunks_mut`]: slice::as_rchunks_mut
     #[stable(feature = "rchunks", since = "1.31.0")]
     #[rustc_const_unstable(feature = "const_slice_make_iter", issue = "137737")]
     #[inline]
@@ -1787,6 +1811,9 @@ impl<T> [T] {
     /// chunk, and [`chunks_exact`] for the same iterator but starting at the beginning of the
     /// slice.
     ///
+    /// If your `chunk_size` is a constant, consider using [`as_rchunks`] instead, which will
+    /// give references to arrays of exactly that length, rather than slices.
+    ///
     /// # Panics
     ///
     /// Panics if `chunk_size` is zero.
@@ -1805,6 +1832,7 @@ impl<T> [T] {
     /// [`chunks`]: slice::chunks
     /// [`rchunks`]: slice::rchunks
     /// [`chunks_exact`]: slice::chunks_exact
+    /// [`as_rchunks`]: slice::as_rchunks
     #[stable(feature = "rchunks", since = "1.31.0")]
     #[rustc_const_unstable(feature = "const_slice_make_iter", issue = "137737")]
     #[inline]
@@ -1828,6 +1856,9 @@ impl<T> [T] {
     /// smaller chunk, and [`chunks_exact_mut`] for the same iterator but starting at the beginning
     /// of the slice.
     ///
+    /// If your `chunk_size` is a constant, consider using [`as_rchunks_mut`] instead, which will
+    /// give references to arrays of exactly that length, rather than slices.
+    ///
     /// # Panics
     ///
     /// Panics if `chunk_size` is zero.
@@ -1850,6 +1881,7 @@ impl<T> [T] {
     /// [`chunks_mut`]: slice::chunks_mut
     /// [`rchunks_mut`]: slice::rchunks_mut
     /// [`chunks_exact_mut`]: slice::chunks_exact_mut
+    /// [`as_rchunks_mut`]: slice::as_rchunks_mut
     #[stable(feature = "rchunks", since = "1.31.0")]
     #[rustc_const_unstable(feature = "const_slice_make_iter", issue = "137737")]
     #[inline]
-- 
cgit 1.4.1-3-g733a5


From 1fcd632be3b3e10f2fe3401f29af1250f496c52f Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 30 Jun 2025 21:29:57 +0200
Subject: bump ui_test to 0.30.1

---
 Cargo.toml            |  2 +-
 tests/compile-test.rs | 11 ++++++-----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 8cbdcf45693..0f85d040f08 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,7 +34,7 @@ anstream = "0.6.18"
 
 [dev-dependencies]
 cargo_metadata = "0.18.1"
-ui_test = "0.29.2"
+ui_test = "0.30.1"
 regex = "1.5.5"
 serde = { version = "1.0.145", features = ["derive"] }
 serde_json = "1.0.122"
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index cefe654fef6..c9718161c4c 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -17,7 +17,8 @@ use ui_test::custom_flags::Flag;
 use ui_test::custom_flags::edition::Edition;
 use ui_test::custom_flags::rustfix::RustfixMode;
 use ui_test::spanned::Spanned;
-use ui_test::{Args, CommandBuilder, Config, Match, error_on_output_conflict, status_emitter};
+use ui_test::status_emitter::StatusEmitter;
+use ui_test::{Args, CommandBuilder, Config, Match, error_on_output_conflict};
 
 use std::collections::{BTreeMap, HashMap};
 use std::env::{self, set_var, var_os};
@@ -217,7 +218,7 @@ fn run_ui(cx: &TestContext) {
         vec![config],
         ui_test::default_file_filter,
         ui_test::default_per_file_config,
-        status_emitter::Text::from(cx.args.format),
+        Box::<dyn StatusEmitter>::from(cx.args.format),
     )
     .unwrap();
 }
@@ -233,7 +234,7 @@ fn run_internal_tests(cx: &TestContext) {
         vec![config],
         ui_test::default_file_filter,
         ui_test::default_per_file_config,
-        status_emitter::Text::from(cx.args.format),
+        Box::<dyn StatusEmitter>::from(cx.args.format),
     )
     .unwrap();
 }
@@ -257,7 +258,7 @@ fn run_ui_toml(cx: &TestContext) {
                 .envs
                 .push(("CLIPPY_CONF_DIR".into(), Some(path.parent().unwrap().into())));
         },
-        status_emitter::Text::from(cx.args.format),
+        Box::<dyn StatusEmitter>::from(cx.args.format),
     )
     .unwrap();
 }
@@ -304,7 +305,7 @@ fn run_ui_cargo(cx: &TestContext) {
                 .then(|| ui_test::default_any_file_filter(path, config) && !ignored_32bit(path))
         },
         |_config, _file_contents| {},
-        status_emitter::Text::from(cx.args.format),
+        Box::<dyn StatusEmitter>::from(cx.args.format),
     )
     .unwrap();
 }
-- 
cgit 1.4.1-3-g733a5


From e32c65d714a4c5698a032b24a8908c3ddc09b38c Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Mon, 30 Jun 2025 11:30:02 +0200
Subject: Activate feature freeze automated notice

---
 .github/workflows/feature_freeze.yml | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/feature_freeze.yml b/.github/workflows/feature_freeze.yml
index a5f8d4bc145..7ad58af77d4 100644
--- a/.github/workflows/feature_freeze.yml
+++ b/.github/workflows/feature_freeze.yml
@@ -1,7 +1,11 @@
 name: Feature freeze check
 
 on:
-  pull_request:
+  pull_request_target:
+    types:
+      - opened
+    branches:
+      - master
     paths:
       - 'clippy_lints/src/declared_lints.rs'
 
@@ -9,6 +13,12 @@ jobs:
   auto-comment:
     runs-on: ubuntu-latest
 
+    permissions:
+      pull-requests: write
+
+    # Do not in any case add code that runs anything coming from the  the content
+    # of the pull request, as malicious code would be able to access the private
+    # GitHub token.
     steps:
     - name: Check PR Changes
       id: pr-changes
@@ -19,7 +29,7 @@ jobs:
       run: |
         # Use GitHub API to create a comment on the PR
         PR_NUMBER=${{ github.event.pull_request.number }}
-        COMMENT="**Seems that you are trying to add a new lint!**\nWe are currently in a [feature freeze](https://doc.rust-lang.org/nightly/clippy/development/feature_freeze.html), so we are delaying all lint-adding PRs to August 1st and focusing on bugfixes.\nThanks a lot for your contribution, and sorry for the inconvenience.\nWith ❤ from the Clippy team"
+        COMMENT="**Seems that you are trying to add a new lint!**\nWe are currently in a [feature freeze](https://doc.rust-lang.org/nightly/clippy/development/feature_freeze.html), so we are delaying all lint-adding PRs to September 18 and focusing on bugfixes.\nThanks a lot for your contribution, and sorry for the inconvenience.\nWith ❤ from the Clippy team\n\n@rustbot note Feature-freeze\n@rustbot blocked\n@rustbot label +A-lint\n"
         GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}
         COMMENT_URL="https://api.github.com/repos/${{ github.repository }}/issues/${PR_NUMBER}/comments"
         curl -s -H "Authorization: token ${GITHUB_TOKEN}" -X POST $COMMENT_URL -d "{\"body\":\"$COMMENT\"}"
-- 
cgit 1.4.1-3-g733a5


From 7ca9f9363dbb42a845ea70dfb449253f08c83ce1 Mon Sep 17 00:00:00 2001
From: Tim Neumann <timnn@google.com>
Date: Tue, 1 Jul 2025 09:17:29 +0200
Subject: tests/codegen/enum/enum-match.rs: accept negative range attribute

---
 tests/codegen/enum/enum-match.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/codegen/enum/enum-match.rs b/tests/codegen/enum/enum-match.rs
index 6da6ad1f078..98635008d06 100644
--- a/tests/codegen/enum/enum-match.rs
+++ b/tests/codegen/enum/enum-match.rs
@@ -98,7 +98,7 @@ pub enum Enum2 {
     E,
 }
 
-// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match2(i8{{.+}}%0)
+// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, -?[0-9]+\))?}} i8 @match2(i8{{.+}}%0)
 // CHECK-NEXT: start:
 // CHECK-NEXT: %[[REL_VAR:.+]] = add i8 %0, 2
 // CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
-- 
cgit 1.4.1-3-g733a5


From 6c4221818e00828ecf54b395475477f49d0ea716 Mon Sep 17 00:00:00 2001
From: quaternic <57393910+quaternic@users.noreply.github.com>
Date: Tue, 1 Jul 2025 11:07:48 +0300
Subject: libm: Improved integer utilities, implement shifts and bug fixes for
 i256 and u256

`i256` and `u256`
- operators now use the same overflow convention as primitives
- implement `<<` and `-` (previously just `>>` and `+`)
- implement `Ord` correctly (the previous `PartialOrd` was broken)
- correct `i256::SIGNED` to `true`

The `Int`-trait is extended with `trailing_zeros`, `carrying_add`, and
`borrowing_sub`.
---
 .../compiler-builtins/libm-test/benches/icount.rs  |  18 ++-
 library/compiler-builtins/libm-test/tests/u256.rs  |  46 ++++++-
 .../compiler-builtins/libm/src/math/support/big.rs | 133 ++++++++++++---------
 .../libm/src/math/support/big/tests.rs             |  63 +++++++++-
 .../libm/src/math/support/int_traits.rs            |  23 +++-
 5 files changed, 223 insertions(+), 60 deletions(-)

diff --git a/library/compiler-builtins/libm-test/benches/icount.rs b/library/compiler-builtins/libm-test/benches/icount.rs
index a0928a29f99..02ee13f804f 100644
--- a/library/compiler-builtins/libm-test/benches/icount.rs
+++ b/library/compiler-builtins/libm-test/benches/icount.rs
@@ -119,6 +119,22 @@ fn icount_bench_u256_add(cases: Vec<(u256, u256)>) {
     }
 }
 
+#[library_benchmark]
+#[bench::linspace(setup_u256_add())]
+fn icount_bench_u256_sub(cases: Vec<(u256, u256)>) {
+    for (x, y) in cases.iter().copied() {
+        black_box(black_box(x) - black_box(y));
+    }
+}
+
+#[library_benchmark]
+#[bench::linspace(setup_u256_shift())]
+fn icount_bench_u256_shl(cases: Vec<(u256, u32)>) {
+    for (x, y) in cases.iter().copied() {
+        black_box(black_box(x) << black_box(y));
+    }
+}
+
 #[library_benchmark]
 #[bench::linspace(setup_u256_shift())]
 fn icount_bench_u256_shr(cases: Vec<(u256, u32)>) {
@@ -129,7 +145,7 @@ fn icount_bench_u256_shr(cases: Vec<(u256, u32)>) {
 
 library_benchmark_group!(
     name = icount_bench_u128_group;
-    benchmarks = icount_bench_u128_widen_mul, icount_bench_u256_add, icount_bench_u256_shr
+    benchmarks = icount_bench_u128_widen_mul, icount_bench_u256_add, icount_bench_u256_sub, icount_bench_u256_shl, icount_bench_u256_shr
 );
 
 #[library_benchmark]
diff --git a/library/compiler-builtins/libm-test/tests/u256.rs b/library/compiler-builtins/libm-test/tests/u256.rs
index 8cbb3ad226f..d1c5cfbcc58 100644
--- a/library/compiler-builtins/libm-test/tests/u256.rs
+++ b/library/compiler-builtins/libm-test/tests/u256.rs
@@ -111,12 +111,54 @@ fn mp_u256_add() {
         let y = random_u256(&mut rng);
         assign_bigint(&mut bx, x);
         assign_bigint(&mut by, y);
-        let actual = x + y;
+        let actual = if u256::MAX - x >= y {
+            x + y
+        } else {
+            // otherwise (u256::MAX - x) < y, so the wrapped result is
+            // (x + y) - (u256::MAX + 1) == y - (u256::MAX - x) - 1
+            y - (u256::MAX - x) - 1_u128.widen()
+        };
         bx += &by;
         check_one(|| hexu(x), || Some(hexu(y)), actual, &mut bx);
     }
 }
 
+#[test]
+fn mp_u256_sub() {
+    let mut rng = ChaCha8Rng::from_seed(*SEED);
+    let mut bx = BigInt::new();
+    let mut by = BigInt::new();
+
+    for _ in 0..bigint_fuzz_iteration_count() {
+        let x = random_u256(&mut rng);
+        let y = random_u256(&mut rng);
+        assign_bigint(&mut bx, x);
+        assign_bigint(&mut by, y);
+
+        // since the operators (may) panic on overflow,
+        // we should test something that doesn't
+        let actual = if x >= y { x - y } else { y - x };
+        bx -= &by;
+        bx.abs_mut();
+        check_one(|| hexu(x), || Some(hexu(y)), actual, &mut bx);
+    }
+}
+
+#[test]
+fn mp_u256_shl() {
+    let mut rng = ChaCha8Rng::from_seed(*SEED);
+    let mut bx = BigInt::new();
+
+    for _ in 0..bigint_fuzz_iteration_count() {
+        let x = random_u256(&mut rng);
+        let shift: u32 = rng.random_range(0..256);
+        assign_bigint(&mut bx, x);
+        let actual = x << shift;
+        bx <<= shift;
+        check_one(|| hexu(x), || Some(shift.to_string()), actual, &mut bx);
+    }
+}
+
 #[test]
 fn mp_u256_shr() {
     let mut rng = ChaCha8Rng::from_seed(*SEED);
@@ -124,7 +166,7 @@ fn mp_u256_shr() {
 
     for _ in 0..bigint_fuzz_iteration_count() {
         let x = random_u256(&mut rng);
-        let shift: u32 = rng.random_range(0..255);
+        let shift: u32 = rng.random_range(0..256);
         assign_bigint(&mut bx, x);
         let actual = x >> shift;
         bx >>= shift;
diff --git a/library/compiler-builtins/libm/src/math/support/big.rs b/library/compiler-builtins/libm/src/math/support/big.rs
index 8a52d86cc98..b7f12854249 100644
--- a/library/compiler-builtins/libm/src/math/support/big.rs
+++ b/library/compiler-builtins/libm/src/math/support/big.rs
@@ -11,10 +11,10 @@ const U128_LO_MASK: u128 = u64::MAX as u128;
 
 /// A 256-bit unsigned integer represented as two 128-bit native-endian limbs.
 #[allow(non_camel_case_types)]
-#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord)]
 pub struct u256 {
-    pub lo: u128,
     pub hi: u128,
+    pub lo: u128,
 }
 
 impl u256 {
@@ -28,17 +28,17 @@ impl u256 {
     pub fn signed(self) -> i256 {
         i256 {
             lo: self.lo,
-            hi: self.hi,
+            hi: self.hi as i128,
         }
     }
 }
 
 /// A 256-bit signed integer represented as two 128-bit native-endian limbs.
 #[allow(non_camel_case_types)]
-#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord)]
 pub struct i256 {
+    pub hi: i128,
     pub lo: u128,
-    pub hi: u128,
 }
 
 impl i256 {
@@ -47,7 +47,7 @@ impl i256 {
     pub fn unsigned(self) -> u256 {
         u256 {
             lo: self.lo,
-            hi: self.hi,
+            hi: self.hi as u128,
         }
     }
 }
@@ -73,17 +73,17 @@ impl MinInt for i256 {
 
     type Unsigned = u256;
 
-    const SIGNED: bool = false;
+    const SIGNED: bool = true;
     const BITS: u32 = 256;
     const ZERO: Self = Self { lo: 0, hi: 0 };
     const ONE: Self = Self { lo: 1, hi: 0 };
     const MIN: Self = Self {
-        lo: 0,
-        hi: 1 << 127,
+        lo: u128::MIN,
+        hi: i128::MIN,
     };
     const MAX: Self = Self {
         lo: u128::MAX,
-        hi: u128::MAX >> 1,
+        hi: i128::MAX,
     };
 }
 
@@ -109,60 +109,86 @@ macro_rules! impl_common {
             }
         }
 
-        impl ops::Shl<u32> for $ty {
+        impl ops::Add<Self> for $ty {
             type Output = Self;
 
-            fn shl(self, _rhs: u32) -> Self::Output {
-                unimplemented!("only used to meet trait bounds")
+            fn add(self, rhs: Self) -> Self::Output {
+                let (lo, carry) = self.lo.overflowing_add(rhs.lo);
+                let (hi, of) = Int::carrying_add(self.hi, rhs.hi, carry);
+                debug_assert!(!of, "attempt to add with overflow");
+                Self { lo, hi }
             }
         }
-    };
-}
 
-impl_common!(i256);
-impl_common!(u256);
+        impl ops::Sub<Self> for $ty {
+            type Output = Self;
 
-impl ops::Add<Self> for u256 {
-    type Output = Self;
+            fn sub(self, rhs: Self) -> Self::Output {
+                let (lo, borrow) = self.lo.overflowing_sub(rhs.lo);
+                let (hi, of) = Int::borrowing_sub(self.hi, rhs.hi, borrow);
+                debug_assert!(!of, "attempt to subtract with overflow");
+                Self { lo, hi }
+            }
+        }
 
-    fn add(self, rhs: Self) -> Self::Output {
-        let (lo, carry) = self.lo.overflowing_add(rhs.lo);
-        let hi = self.hi.wrapping_add(carry as u128).wrapping_add(rhs.hi);
+        impl ops::Shl<u32> for $ty {
+            type Output = Self;
 
-        Self { lo, hi }
-    }
-}
+            fn shl(mut self, rhs: u32) -> Self::Output {
+                debug_assert!(rhs < Self::BITS, "attempt to shift left with overflow");
 
-impl ops::Shr<u32> for u256 {
-    type Output = Self;
+                let half_bits = Self::BITS / 2;
+                let low_mask = half_bits - 1;
+                let s = rhs & low_mask;
 
-    fn shr(mut self, rhs: u32) -> Self::Output {
-        debug_assert!(rhs < Self::BITS, "attempted to shift right with overflow");
-        if rhs >= Self::BITS {
-            return Self::ZERO;
-        }
+                let lo = self.lo;
+                let hi = self.hi;
 
-        if rhs == 0 {
-            return self;
-        }
+                self.lo = lo << s;
 
-        if rhs < 128 {
-            self.lo >>= rhs;
-            self.lo |= self.hi << (128 - rhs);
-        } else {
-            self.lo = self.hi >> (rhs - 128);
+                if rhs & half_bits == 0 {
+                    self.hi = (lo >> (low_mask ^ s) >> 1) as _;
+                    self.hi |= hi << s;
+                } else {
+                    self.hi = self.lo as _;
+                    self.lo = 0;
+                }
+                self
+            }
         }
 
-        if rhs < 128 {
-            self.hi >>= rhs;
-        } else {
-            self.hi = 0;
-        }
+        impl ops::Shr<u32> for $ty {
+            type Output = Self;
 
-        self
-    }
+            fn shr(mut self, rhs: u32) -> Self::Output {
+                debug_assert!(rhs < Self::BITS, "attempt to shift right with overflow");
+
+                let half_bits = Self::BITS / 2;
+                let low_mask = half_bits - 1;
+                let s = rhs & low_mask;
+
+                let lo = self.lo;
+                let hi = self.hi;
+
+                self.hi = hi >> s;
+
+                #[allow(unused_comparisons)]
+                if rhs & half_bits == 0 {
+                    self.lo = (hi << (low_mask ^ s) << 1) as _;
+                    self.lo |= lo >> s;
+                } else {
+                    self.lo = self.hi as _;
+                    self.hi = if hi < 0 { !0 } else { 0 };
+                }
+                self
+            }
+        }
+    };
 }
 
+impl_common!(i256);
+impl_common!(u256);
+
 impl HInt for u128 {
     type D = u256;
 
@@ -200,7 +226,7 @@ impl HInt for u128 {
     }
 
     fn widen_hi(self) -> Self::D {
-        self.widen() << <Self as MinInt>::BITS
+        u256 { lo: 0, hi: self }
     }
 }
 
@@ -208,11 +234,10 @@ impl HInt for i128 {
     type D = i256;
 
     fn widen(self) -> Self::D {
-        let mut ret = self.unsigned().zero_widen().signed();
-        if self.is_negative() {
-            ret.hi = u128::MAX;
+        i256 {
+            lo: self as u128,
+            hi: if self < 0 { -1 } else { 0 },
         }
-        ret
     }
 
     fn zero_widen(self) -> Self::D {
@@ -228,7 +253,7 @@ impl HInt for i128 {
     }
 
     fn widen_hi(self) -> Self::D {
-        self.widen() << <Self as MinInt>::BITS
+        i256 { lo: 0, hi: self }
     }
 }
 
@@ -252,6 +277,6 @@ impl DInt for i256 {
     }
 
     fn hi(self) -> Self::H {
-        self.hi as i128
+        self.hi
     }
 }
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 d2010f0216e..d54706c7260 100644
--- a/library/compiler-builtins/libm/src/math/support/big/tests.rs
+++ b/library/compiler-builtins/libm/src/math/support/big/tests.rs
@@ -36,7 +36,7 @@ fn widen_i128() {
         (LOHI_SPLIT as i128).widen(),
         i256 {
             lo: LOHI_SPLIT,
-            hi: u128::MAX
+            hi: -1,
         }
     );
     assert_eq!((-1i128).zero_widen().unsigned(), (u128::MAX).widen());
@@ -275,3 +275,64 @@ fn shr_u256_overflow() {
     assert_eq!(u256::MAX >> 257, u256::ZERO);
     assert_eq!(u256::MAX >> u32::MAX, u256::ZERO);
 }
+
+#[test]
+fn u256_ord() {
+    let _1 = u256::ONE;
+    let _2 = _1 + _1;
+    for x in u8::MIN..u8::MAX {
+        let y = x + 1;
+        let wx = (x as u128).widen_hi();
+        let wy = (y as u128).widen_hi();
+        assert!([wx, wx + _1, wx + _2, wy, wy + _1, wy + _2].is_sorted());
+    }
+}
+#[test]
+fn i256_ord() {
+    let _1 = i256::ONE;
+    let _2 = _1 + _1;
+    for x in i8::MIN..i8::MAX {
+        let y = x + 1;
+        let wx = (x as i128).widen_hi();
+        let wy = (y as i128).widen_hi();
+        assert!([wx, wx + _1, wx + _2, wy - _2, wy - _1, wy].is_sorted());
+    }
+}
+
+#[test]
+fn u256_shifts() {
+    let _1 = u256::ONE;
+    for k in 0..255 {
+        let x = _1 << k;
+        let x2 = _1 << (k + 1);
+        assert!(x < x2);
+        assert_eq!(x << 1, x2);
+        assert_eq!(x + x, x2);
+        assert_eq!(x >> k, _1);
+        assert_eq!(x2 >> (k + 1), _1);
+    }
+}
+#[test]
+fn i256_shifts() {
+    let _1 = i256::ONE;
+    for k in 0..254 {
+        let x = _1 << k;
+        let x2 = _1 << (k + 1);
+        assert!(x < x2);
+        assert_eq!(x << 1, x2);
+        assert_eq!(x + x, x2);
+        assert_eq!(x >> k, _1);
+        assert_eq!(x2 >> (k + 1), _1);
+    }
+
+    let min = _1 << 255;
+    assert_eq!(min, i256::MIN);
+    let mut x = min;
+    for k in 0..255 {
+        assert_eq!(x, min >> k);
+        let y = x >> 1;
+        assert_eq!(y + y, x);
+        assert!(x < y);
+        x = y;
+    }
+}
diff --git a/library/compiler-builtins/libm/src/math/support/int_traits.rs b/library/compiler-builtins/libm/src/math/support/int_traits.rs
index 9b29e2f4561..9d8826dfed3 100644
--- a/library/compiler-builtins/libm/src/math/support/int_traits.rs
+++ b/library/compiler-builtins/libm/src/math/support/int_traits.rs
@@ -37,8 +37,6 @@ pub trait Int:
     + fmt::Display
     + fmt::Binary
     + fmt::LowerHex
-    + PartialEq
-    + PartialOrd
     + ops::AddAssign
     + ops::SubAssign
     + ops::MulAssign
@@ -102,7 +100,10 @@ pub trait Int:
     fn rotate_left(self, other: u32) -> Self;
     fn overflowing_add(self, other: Self) -> (Self, bool);
     fn overflowing_sub(self, other: Self) -> (Self, bool);
+    fn carrying_add(self, other: Self, carry: bool) -> (Self, bool);
+    fn borrowing_sub(self, other: Self, borrow: bool) -> (Self, bool);
     fn leading_zeros(self) -> u32;
+    fn trailing_zeros(self) -> u32;
     fn ilog2(self) -> u32;
 }
 
@@ -168,12 +169,30 @@ macro_rules! int_impl_common {
             <Self>::leading_zeros(self)
         }
 
+        fn trailing_zeros(self) -> u32 {
+            <Self>::trailing_zeros(self)
+        }
+
         fn ilog2(self) -> u32 {
             // On our older MSRV, this resolves to the trait method. Which won't actually work,
             // but this is only called behind other gates.
             #[allow(clippy::incompatible_msrv)]
             <Self>::ilog2(self)
         }
+
+        fn carrying_add(self, other: Self, carry: bool) -> (Self, bool) {
+            let (ab, of1) = self.overflowing_add(other);
+            let (abc, of2) = ab.overflowing_add(Self::from_bool(carry));
+            // `of1 && of2` is possible with signed integers if a negative sum
+            // overflows to `MAX` and adding the carry overflows again back to `MIN`
+            (abc, of1 ^ of2)
+        }
+
+        fn borrowing_sub(self, other: Self, borrow: bool) -> (Self, bool) {
+            let (ab, of1) = self.overflowing_sub(other);
+            let (abc, of2) = ab.overflowing_sub(Self::from_bool(borrow));
+            (abc, of1 ^ of2)
+        }
     };
 }
 
-- 
cgit 1.4.1-3-g733a5


From 708ea873b11b7a099cbdd59c1d45f3743362554e Mon Sep 17 00:00:00 2001
From: Dario Heinisch <dario.heinisch@gmail.com>
Date: Tue, 1 Jul 2025 10:46:27 +0200
Subject: run cargo dev fmt

---
 tests/ui/neg_multiply.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/ui/neg_multiply.rs b/tests/ui/neg_multiply.rs
index 5b60b57e7ef..241a72c6d99 100644
--- a/tests/ui/neg_multiply.rs
+++ b/tests/ui/neg_multiply.rs
@@ -84,12 +84,12 @@ fn float() {
 }
 
 struct Y {
-    delta: f64
+    delta: f64,
 }
 
 fn nested() {
-    let a = Y {delta: 1.0};
-    let b = Y {delta: 1.0};
+    let a = Y { delta: 1.0 };
+    let b = Y { delta: 1.0 };
     let _ = ((a.delta - 0.5).abs() * -1.0).total_cmp(&1.0);
     //~^ neg_multiply
     let _ = (-(a.delta - 0.5).abs()).total_cmp(&1.0);
-- 
cgit 1.4.1-3-g733a5


From e7fa5364c67dbd45a92432678878d406ad715630 Mon Sep 17 00:00:00 2001
From: Dario Heinisch <dario.heinisch@gmail.com>
Date: Tue, 1 Jul 2025 10:51:18 +0200
Subject: fix tests (run cargo uibless after fmt)

---
 tests/ui/neg_multiply.fixed | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/ui/neg_multiply.fixed b/tests/ui/neg_multiply.fixed
index 93d314fea5f..32d466e88fc 100644
--- a/tests/ui/neg_multiply.fixed
+++ b/tests/ui/neg_multiply.fixed
@@ -84,12 +84,12 @@ fn float() {
 }
 
 struct Y {
-    delta: f64
+    delta: f64,
 }
 
 fn nested() {
-    let a = Y {delta: 1.0};
-    let b = Y {delta: 1.0};
+    let a = Y { delta: 1.0 };
+    let b = Y { delta: 1.0 };
     let _ = (-(a.delta - 0.5).abs()).total_cmp(&1.0);
     //~^ neg_multiply
     let _ = (-(a.delta - 0.5).abs()).total_cmp(&1.0);
-- 
cgit 1.4.1-3-g733a5


From 5ff1a4164c98ca3815b103a6dfbf26a0d817cb69 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 1 Jul 2025 13:27:49 +0200
Subject: use ui_test dependency builder for non-internal test dependencies

---
 Cargo.toml                   | 10 +------
 clippy_test_deps/Cargo.toml  | 17 ++++++++++++
 clippy_test_deps/src/main.rs |  1 +
 tests/compile-test.rs        | 65 +++++++++++++++++++-------------------------
 4 files changed, 47 insertions(+), 46 deletions(-)
 create mode 100644 clippy_test_deps/Cargo.toml
 create mode 100644 clippy_test_deps/src/main.rs

diff --git a/Cargo.toml b/Cargo.toml
index 0f85d040f08..bdc299749d7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,7 +34,7 @@ anstream = "0.6.18"
 
 [dev-dependencies]
 cargo_metadata = "0.18.1"
-ui_test = "0.30.1"
+ui_test = "0.30.2"
 regex = "1.5.5"
 serde = { version = "1.0.145", features = ["derive"] }
 serde_json = "1.0.122"
@@ -45,14 +45,6 @@ itertools = "0.12"
 pulldown-cmark = { version = "0.11", default-features = false, features = ["html"] }
 askama = { version = "0.14", default-features = false, features = ["alloc", "config", "derive"] }
 
-# UI test dependencies
-if_chain = "1.0"
-quote = "1.0.25"
-syn = { version = "2.0", features = ["full"] }
-futures = "0.3"
-parking_lot = "0.12"
-tokio = { version = "1", features = ["io-util"] }
-
 [build-dependencies]
 rustc_tools_util = { path = "rustc_tools_util", version = "0.4.2" }
 
diff --git a/clippy_test_deps/Cargo.toml b/clippy_test_deps/Cargo.toml
new file mode 100644
index 00000000000..f41334f0ade
--- /dev/null
+++ b/clippy_test_deps/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "clippy_test_deps"
+version = "0.1.0"
+edition = "2021"
+
+# Add dependencies here to make them available in ui tests.
+
+[dependencies]
+regex = "1.5.5"
+serde = { version = "1.0.145", features = ["derive"] }
+if_chain = "1.0"
+quote = "1.0.25"
+syn = { version = "2.0", features = ["full"] }
+futures = "0.3"
+parking_lot = "0.12"
+tokio = { version = "1", features = ["io-util"] }
+itertools = "0.12"
diff --git a/clippy_test_deps/src/main.rs b/clippy_test_deps/src/main.rs
new file mode 100644
index 00000000000..f328e4d9d04
--- /dev/null
+++ b/clippy_test_deps/src/main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index c9718161c4c..aa786334711 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -16,6 +16,7 @@ use test_utils::IS_RUSTC_TEST_SUITE;
 use ui_test::custom_flags::Flag;
 use ui_test::custom_flags::edition::Edition;
 use ui_test::custom_flags::rustfix::RustfixMode;
+use ui_test::dependencies::DependencyBuilder;
 use ui_test::spanned::Spanned;
 use ui_test::status_emitter::StatusEmitter;
 use ui_test::{Args, CommandBuilder, Config, Match, error_on_output_conflict};
@@ -28,46 +29,26 @@ use std::path::{Path, PathBuf};
 use std::sync::mpsc::{Sender, channel};
 use std::{fs, iter, thread};
 
-// Test dependencies may need an `extern crate` here to ensure that they show up
-// in the depinfo file (otherwise cargo thinks they are unused)
-extern crate futures;
-extern crate if_chain;
-extern crate itertools;
-extern crate parking_lot;
-extern crate quote;
-extern crate syn;
-extern crate tokio;
-
 mod test_utils;
 
-/// All crates used in UI tests are listed here
-static TEST_DEPENDENCIES: &[&str] = &[
-    "clippy_config",
-    "clippy_lints",
-    "clippy_utils",
-    "futures",
-    "if_chain",
-    "itertools",
-    "parking_lot",
-    "quote",
-    "regex",
-    "serde_derive",
-    "serde",
-    "syn",
-    "tokio",
-];
-
-/// Produces a string with an `--extern` flag for all UI test crate
-/// dependencies.
+/// All crates used in internal UI tests are listed here.
+/// We directly re-use these crates from their normal clippy builds, so we don't have them
+/// in `clippy_test_devs`. That saves a lot of time but also means they don't work in a stage 1
+/// test in rustc bootstrap.
+static INTERNAL_TEST_DEPENDENCIES: &[&str] = &["clippy_config", "clippy_lints", "clippy_utils"];
+
+/// Produces a string with an `--extern` flag for all `INTERNAL_TEST_DEPENDENCIES`.
 ///
 /// The dependency files are located by parsing the depinfo file for this test
 /// module. This assumes the `-Z binary-dep-depinfo` flag is enabled. All test
 /// dependencies must be added to Cargo.toml at the project root. Test
 /// dependencies that are not *directly* used by this test module require an
 /// `extern crate` declaration.
-fn extern_flags() -> Vec<String> {
+fn internal_extern_flags() -> Vec<String> {
+    let current_exe_path = env::current_exe().unwrap();
+    let deps_path = current_exe_path.parent().unwrap();
     let current_exe_depinfo = {
-        let mut path = env::current_exe().unwrap();
+        let mut path = current_exe_path.clone();
         path.set_extension("d");
         fs::read_to_string(path).unwrap()
     };
@@ -89,7 +70,7 @@ fn extern_flags() -> Vec<String> {
             Some((name, path_str))
         };
         if let Some((name, path)) = parse_name_path()
-            && TEST_DEPENDENCIES.contains(&name)
+            && INTERNAL_TEST_DEPENDENCIES.contains(&name)
         {
             // A dependency may be listed twice if it is available in sysroot,
             // and the sysroot dependencies are listed first. As of the writing,
@@ -97,7 +78,7 @@ fn extern_flags() -> Vec<String> {
             crates.insert(name, path);
         }
     }
-    let not_found: Vec<&str> = TEST_DEPENDENCIES
+    let not_found: Vec<&str> = INTERNAL_TEST_DEPENDENCIES
         .iter()
         .copied()
         .filter(|n| !crates.contains_key(n))
@@ -112,6 +93,7 @@ fn extern_flags() -> Vec<String> {
     crates
         .into_iter()
         .map(|(name, path)| format!("--extern={name}={path}"))
+        .chain([format!("-Ldependency={}", deps_path.display())])
         .collect()
 }
 
@@ -120,7 +102,6 @@ const RUN_INTERNAL_TESTS: bool = cfg!(feature = "internal");
 
 struct TestContext {
     args: Args,
-    extern_flags: Vec<String>,
     diagnostic_collector: Option<DiagnosticCollector>,
     collector_thread: Option<thread::JoinHandle<()>>,
 }
@@ -135,7 +116,6 @@ impl TestContext {
             .unzip();
         Self {
             args,
-            extern_flags: extern_flags(),
             diagnostic_collector,
             collector_thread,
         }
@@ -159,6 +139,15 @@ impl TestContext {
         };
         let defaults = config.comment_defaults.base();
         defaults.set_custom("edition", Edition("2024".into()));
+        defaults.set_custom(
+            "dependencies",
+            DependencyBuilder {
+                program: CommandBuilder::cargo(),
+                crate_manifest_path: Path::new("clippy_test_deps").join("Cargo.toml"),
+                build_std: None,
+                bless_lockfile: self.args.bless,
+            },
+        );
         defaults.exit_status = None.into();
         if mandatory_annotations {
             defaults.require_annotations = Some(Spanned::dummy(true)).into();
@@ -183,12 +172,10 @@ impl TestContext {
                 "-Zui-testing",
                 "-Zdeduplicate-diagnostics=no",
                 "-Dwarnings",
-                &format!("-Ldependency={}", deps_path.display()),
             ]
             .map(OsString::from),
         );
 
-        config.program.args.extend(self.extern_flags.iter().map(OsString::from));
         // Prevent rustc from creating `rustc-ice-*` files the console output is enough.
         config.program.envs.push(("RUSTC_ICE".into(), Some("0".into())));
 
@@ -228,6 +215,10 @@ fn run_internal_tests(cx: &TestContext) {
         return;
     }
     let mut config = cx.base_config("ui-internal", true);
+    config
+        .program
+        .args
+        .extend(internal_extern_flags().iter().map(OsString::from));
     config.bless_command = Some("cargo uitest --features internal -- -- --bless".into());
 
     ui_test::run_tests_generic(
-- 
cgit 1.4.1-3-g733a5


From fba4177d0fd07fc3f2d2202b39199ab913fb6164 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Mon, 23 Jun 2025 16:08:01 +0000
Subject: Simplify assignments.

---
 compiler/rustc_mir_transform/src/gvn.rs | 61 ++++++++++++++++++---------------
 1 file changed, 33 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index bda71ceaa55..b19323239b6 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -1755,7 +1755,7 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, 'tcx> {
 
     fn visit_place(&mut self, place: &mut Place<'tcx>, context: PlaceContext, location: Location) {
         self.simplify_place_projection(place, location);
-        if context.is_mutating_use() && !place.projection.is_empty() {
+        if context.is_mutating_use() && place.is_indirect() {
             // Non-local mutation maybe invalidate deref.
             self.invalidate_derefs();
         }
@@ -1767,36 +1767,41 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, 'tcx> {
         self.super_operand(operand, location);
     }
 
-    fn visit_statement(&mut self, stmt: &mut Statement<'tcx>, location: Location) {
-        if let StatementKind::Assign(box (ref mut lhs, ref mut rvalue)) = stmt.kind {
-            self.simplify_place_projection(lhs, location);
-
-            let value = self.simplify_rvalue(lhs, rvalue, location);
-            let value = if let Some(local) = lhs.as_local()
-                && self.ssa.is_ssa(local)
-                // FIXME(#112651) `rvalue` may have a subtype to `local`. We can only mark
-                // `local` as reusable if we have an exact type match.
-                && self.local_decls[local].ty == rvalue.ty(self.local_decls, self.tcx)
+    fn visit_assign(
+        &mut self,
+        lhs: &mut Place<'tcx>,
+        rvalue: &mut Rvalue<'tcx>,
+        location: Location,
+    ) {
+        self.simplify_place_projection(lhs, location);
+
+        let value = self.simplify_rvalue(lhs, rvalue, location);
+        if let Some(value) = value {
+            if let Some(const_) = self.try_as_constant(value) {
+                *rvalue = Rvalue::Use(Operand::Constant(Box::new(const_)));
+            } else if let Some(place) = self.try_as_place(value, location, false)
+                && *rvalue != Rvalue::Use(Operand::Move(place))
+                && *rvalue != Rvalue::Use(Operand::Copy(place))
             {
-                let value = value.unwrap_or_else(|| self.new_opaque());
-                self.assign(local, value);
-                Some(value)
-            } else {
-                value
-            };
-            if let Some(value) = value {
-                if let Some(const_) = self.try_as_constant(value) {
-                    *rvalue = Rvalue::Use(Operand::Constant(Box::new(const_)));
-                } else if let Some(place) = self.try_as_place(value, location, false)
-                    && *rvalue != Rvalue::Use(Operand::Move(place))
-                    && *rvalue != Rvalue::Use(Operand::Copy(place))
-                {
-                    *rvalue = Rvalue::Use(Operand::Copy(place));
-                    self.reused_locals.insert(place.local);
-                }
+                *rvalue = Rvalue::Use(Operand::Copy(place));
+                self.reused_locals.insert(place.local);
             }
         }
-        self.super_statement(stmt, location);
+
+        if lhs.is_indirect() {
+            // Non-local mutation maybe invalidate deref.
+            self.invalidate_derefs();
+        }
+
+        if let Some(local) = lhs.as_local()
+            && self.ssa.is_ssa(local)
+            // FIXME(#112651) `rvalue` may have a subtype to `local`. We can only mark
+            // `local` as reusable if we have an exact type match.
+            && self.local_decls[local].ty == rvalue.ty(self.local_decls, self.tcx)
+        {
+            let value = value.unwrap_or_else(|| self.new_opaque());
+            self.assign(local, value);
+        }
     }
 
     fn visit_terminator(&mut self, terminator: &mut Terminator<'tcx>, location: Location) {
-- 
cgit 1.4.1-3-g733a5


From ac70dc85e74d789b82b8352a895335b18e1a569e Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Mon, 30 Jun 2025 18:26:37 +0000
Subject: Introduce Value::RawPtr as it behaves differently from other
 aggregates.

---
 compiler/rustc_mir_transform/src/gvn.rs | 122 ++++++++++++++++++--------------
 1 file changed, 67 insertions(+), 55 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index b19323239b6..b59b7353112 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -163,12 +163,6 @@ enum AggregateTy<'tcx> {
     Array,
     Tuple,
     Def(DefId, ty::GenericArgsRef<'tcx>),
-    RawPtr {
-        /// Needed for cast propagation.
-        data_pointer_ty: Ty<'tcx>,
-        /// The data pointer can be anything thin, so doesn't determine the output.
-        output_pointer_ty: Ty<'tcx>,
-    },
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
@@ -194,6 +188,17 @@ enum Value<'tcx> {
     /// An aggregate value, either tuple/closure/struct/enum.
     /// This does not contain unions, as we cannot reason with the value.
     Aggregate(AggregateTy<'tcx>, VariantIdx, Vec<VnIndex>),
+    /// A raw pointer aggregate built from a thin pointer and metadata.
+    RawPtr {
+        /// Thin pointer component. This is field 0 in MIR.
+        pointer: VnIndex,
+        /// Metadata component. This is field 1 in MIR.
+        metadata: VnIndex,
+        /// Needed for cast propagation.
+        data_pointer_ty: Ty<'tcx>,
+        /// The data pointer can be anything thin, so doesn't determine the output.
+        output_pointer_ty: Ty<'tcx>,
+    },
     /// This corresponds to a `[value; count]` expression.
     Repeat(VnIndex, ty::Const<'tcx>),
     /// The address of a place.
@@ -402,22 +407,11 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     AggregateTy::Def(def_id, args) => {
                         self.tcx.type_of(def_id).instantiate(self.tcx, args)
                     }
-                    AggregateTy::RawPtr { output_pointer_ty, .. } => output_pointer_ty,
                 };
                 let variant = if ty.is_enum() { Some(variant) } else { None };
                 let ty = self.ecx.layout_of(ty).ok()?;
                 if ty.is_zst() {
                     ImmTy::uninit(ty).into()
-                } else if matches!(kind, AggregateTy::RawPtr { .. }) {
-                    // Pointers don't have fields, so don't `project_field` them.
-                    let data = self.ecx.read_pointer(fields[0]).discard_err()?;
-                    let meta = if fields[1].layout.is_zst() {
-                        MemPlaceMeta::None
-                    } else {
-                        MemPlaceMeta::Meta(self.ecx.read_scalar(fields[1]).discard_err()?)
-                    };
-                    let ptr_imm = Immediate::new_pointer_with_meta(data, meta, &self.ecx);
-                    ImmTy::from_immediate(ptr_imm, ty).into()
                 } else if matches!(
                     ty.backend_repr,
                     BackendRepr::Scalar(..) | BackendRepr::ScalarPair(..)
@@ -446,6 +440,22 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     return None;
                 }
             }
+            RawPtr { pointer, metadata, output_pointer_ty, data_pointer_ty: _ } => {
+                let pointer = self.evaluated[pointer].as_ref()?;
+                let metadata = self.evaluated[metadata].as_ref()?;
+                let output_pointer_ty = self.ecx.layout_of(output_pointer_ty).ok()?;
+                debug_assert!(!output_pointer_ty.is_zst());
+
+                // Pointers don't have fields, so don't `project_field` them.
+                let data = self.ecx.read_pointer(pointer).discard_err()?;
+                let meta = if metadata.layout.is_zst() {
+                    MemPlaceMeta::None
+                } else {
+                    MemPlaceMeta::Meta(self.ecx.read_scalar(metadata).discard_err()?)
+                };
+                let ptr_imm = Immediate::new_pointer_with_meta(data, meta, &self.ecx);
+                ImmTy::from_immediate(ptr_imm, output_pointer_ty).into()
+            }
 
             Projection(base, elem) => {
                 let value = self.evaluated[base].as_ref()?;
@@ -1026,7 +1036,12 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
         }
 
-        let (mut ty, variant_index) = match *kind {
+        let fields: Vec<_> = field_ops
+            .iter_mut()
+            .map(|op| self.simplify_operand(op, location).unwrap_or_else(|| self.new_opaque()))
+            .collect();
+
+        let (ty, variant_index) = match *kind {
             AggregateKind::Array(..) => {
                 assert!(!field_ops.is_empty());
                 (AggregateTy::Array, FIRST_VARIANT)
@@ -1045,41 +1060,41 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             AggregateKind::Adt(_, _, _, _, Some(_)) => return None,
             AggregateKind::RawPtr(pointee_ty, mtbl) => {
                 assert_eq!(field_ops.len(), 2);
-                let data_pointer_ty = field_ops[FieldIdx::ZERO].ty(self.local_decls, self.tcx);
+                let mut data_pointer_ty = field_ops[FieldIdx::ZERO].ty(self.local_decls, self.tcx);
                 let output_pointer_ty = Ty::new_ptr(self.tcx, pointee_ty, mtbl);
-                (AggregateTy::RawPtr { data_pointer_ty, output_pointer_ty }, FIRST_VARIANT)
-            }
-        };
-
-        let mut fields: Vec<_> = field_ops
-            .iter_mut()
-            .map(|op| self.simplify_operand(op, location).unwrap_or_else(|| self.new_opaque()))
-            .collect();
 
-        if let AggregateTy::RawPtr { data_pointer_ty, output_pointer_ty } = &mut ty {
-            let mut was_updated = false;
+                let [mut pointer, metadata] = fields.try_into().unwrap();
+
+                // Any thin pointer of matching mutability is fine as the data pointer.
+                let mut was_updated = false;
+                while let Value::Cast {
+                    kind: CastKind::PtrToPtr,
+                    value: cast_value,
+                    from: cast_from,
+                    to: _,
+                } = self.get(pointer)
+                    && let ty::RawPtr(from_pointee_ty, from_mtbl) = cast_from.kind()
+                    && let ty::RawPtr(_, output_mtbl) = output_pointer_ty.kind()
+                    && from_mtbl == output_mtbl
+                    && from_pointee_ty.is_sized(self.tcx, self.typing_env())
+                {
+                    pointer = *cast_value;
+                    data_pointer_ty = *cast_from;
+                    was_updated = true;
+                }
 
-            // Any thin pointer of matching mutability is fine as the data pointer.
-            while let Value::Cast {
-                kind: CastKind::PtrToPtr,
-                value: cast_value,
-                from: cast_from,
-                to: _,
-            } = self.get(fields[0])
-                && let ty::RawPtr(from_pointee_ty, from_mtbl) = cast_from.kind()
-                && let ty::RawPtr(_, output_mtbl) = output_pointer_ty.kind()
-                && from_mtbl == output_mtbl
-                && from_pointee_ty.is_sized(self.tcx, self.typing_env())
-            {
-                fields[0] = *cast_value;
-                *data_pointer_ty = *cast_from;
-                was_updated = true;
-            }
+                if was_updated && let Some(op) = self.try_as_operand(pointer, location) {
+                    field_ops[FieldIdx::ZERO] = op;
+                }
 
-            if was_updated && let Some(op) = self.try_as_operand(fields[0], location) {
-                field_ops[FieldIdx::ZERO] = op;
+                return Some(self.insert(Value::RawPtr {
+                    output_pointer_ty,
+                    data_pointer_ty,
+                    pointer,
+                    metadata,
+                }));
             }
-        }
+        };
 
         if let AggregateTy::Array = ty
             && fields.len() > 4
@@ -1165,9 +1180,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             (UnOp::Not, Value::BinaryOp(BinOp::Ne, lhs, rhs)) => {
                 Value::BinaryOp(BinOp::Eq, *lhs, *rhs)
             }
-            (UnOp::PtrMetadata, Value::Aggregate(AggregateTy::RawPtr { .. }, _, fields)) => {
-                return Some(fields[1]);
-            }
+            (UnOp::PtrMetadata, Value::RawPtr { metadata, .. }) => return Some(*metadata),
             // We have an unsizing cast, which assigns the length to wide pointer metadata.
             (
                 UnOp::PtrMetadata,
@@ -1399,16 +1412,15 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             // If a cast just casts away the metadata again, then we can get it by
             // casting the original thin pointer passed to `from_raw_parts`
             if let PtrToPtr = kind
-                && let Value::Aggregate(AggregateTy::RawPtr { data_pointer_ty, .. }, _, fields) =
-                    self.get(value)
+                && let Value::RawPtr { data_pointer_ty, pointer, .. } = self.get(value)
                 && let ty::RawPtr(to_pointee, _) = to.kind()
                 && to_pointee.is_sized(self.tcx, self.typing_env())
             {
                 from = *data_pointer_ty;
-                value = fields[0];
+                value = *pointer;
                 was_updated_this_iteration = true;
                 if *data_pointer_ty == to {
-                    return Some(fields[0]);
+                    return Some(*pointer);
                 }
             }
 
-- 
cgit 1.4.1-3-g733a5


From be41333604c15acef2766619beac604bb3726538 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Mon, 30 Jun 2025 19:27:27 +0000
Subject: Store a full Ty with each Value.

---
 compiler/rustc_mir_transform/src/gvn.rs            | 244 ++++++++++-----------
 tests/mir-opt/const_prop/transmute.rs              |   2 +-
 .../transmute.unreachable_direct.GVN.32bit.diff    |   2 +-
 .../transmute.unreachable_direct.GVN.64bit.diff    |   2 +-
 .../gvn.generic_cast_metadata.GVN.panic-abort.diff |   3 +-
 ...gvn.generic_cast_metadata.GVN.panic-unwind.diff |   3 +-
 tests/mir-opt/gvn.rs                               |   2 +-
 7 files changed, 122 insertions(+), 136 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index b59b7353112..3e4c05b355f 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -130,7 +130,7 @@ impl<'tcx> crate::MirPass<'tcx> for GVN {
         let mut state = VnState::new(tcx, body, typing_env, &ssa, dominators, &body.local_decls);
 
         for local in body.args_iter().filter(|&local| ssa.is_ssa(local)) {
-            let opaque = state.new_opaque();
+            let opaque = state.new_opaque(body.local_decls[local].ty);
             state.assign(local, opaque);
         }
 
@@ -238,7 +238,7 @@ struct VnState<'body, 'tcx> {
     /// Locals that are assigned that value.
     // This vector does not hold all the values of `VnIndex` that we create.
     rev_locals: IndexVec<VnIndex, SmallVec<[Local; 1]>>,
-    values: FxIndexSet<Value<'tcx>>,
+    values: FxIndexSet<(Value<'tcx>, Ty<'tcx>)>,
     /// Values evaluated as constants if possible.
     evaluated: IndexVec<VnIndex, Option<OpTy<'tcx>>>,
     /// Counter to generate different values.
@@ -287,8 +287,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     }
 
     #[instrument(level = "trace", skip(self), ret)]
-    fn insert(&mut self, value: Value<'tcx>) -> VnIndex {
-        let (index, new) = self.values.insert_full(value);
+    fn insert(&mut self, ty: Ty<'tcx>, value: Value<'tcx>) -> VnIndex {
+        let (index, new) = self.values.insert_full((value, ty));
         let index = VnIndex::from_usize(index);
         if new {
             // Grow `evaluated` and `rev_locals` here to amortize the allocations.
@@ -310,20 +310,33 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     /// Create a new `Value` for which we have no information at all, except that it is distinct
     /// from all the others.
     #[instrument(level = "trace", skip(self), ret)]
-    fn new_opaque(&mut self) -> VnIndex {
+    fn new_opaque(&mut self, ty: Ty<'tcx>) -> VnIndex {
         let value = Value::Opaque(self.next_opaque());
-        self.insert(value)
+        self.insert(ty, value)
     }
 
     /// Create a new `Value::Address` distinct from all the others.
     #[instrument(level = "trace", skip(self), ret)]
     fn new_pointer(&mut self, place: Place<'tcx>, kind: AddressKind) -> VnIndex {
+        let pty = place.ty(self.local_decls, self.tcx).ty;
+        let ty = match kind {
+            AddressKind::Ref(bk) => {
+                Ty::new_ref(self.tcx, self.tcx.lifetimes.re_erased, pty, bk.to_mutbl_lossy())
+            }
+            AddressKind::Address(mutbl) => Ty::new_ptr(self.tcx, pty, mutbl.to_mutbl_lossy()),
+        };
         let value = Value::Address { place, kind, provenance: self.next_opaque() };
-        self.insert(value)
+        self.insert(ty, value)
     }
 
+    #[inline]
     fn get(&self, index: VnIndex) -> &Value<'tcx> {
-        self.values.get_index(index.as_usize()).unwrap()
+        &self.values.get_index(index.as_usize()).unwrap().0
+    }
+
+    #[inline]
+    fn ty(&self, index: VnIndex) -> Ty<'tcx> {
+        self.values.get_index(index.as_usize()).unwrap().1
     }
 
     /// Record that `local` is assigned `value`. `local` must be SSA.
@@ -346,29 +359,29 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             debug_assert_ne!(disambiguator, 0);
             disambiguator
         };
-        self.insert(Value::Constant { value, disambiguator })
+        self.insert(value.ty(), Value::Constant { value, disambiguator })
     }
 
     fn insert_bool(&mut self, flag: bool) -> VnIndex {
         // Booleans are deterministic.
         let value = Const::from_bool(self.tcx, flag);
         debug_assert!(value.is_deterministic());
-        self.insert(Value::Constant { value, disambiguator: 0 })
+        self.insert(self.tcx.types.bool, Value::Constant { value, disambiguator: 0 })
     }
 
-    fn insert_scalar(&mut self, scalar: Scalar, ty: Ty<'tcx>) -> VnIndex {
+    fn insert_scalar(&mut self, ty: Ty<'tcx>, scalar: Scalar) -> VnIndex {
         // Scalars are deterministic.
         let value = Const::from_scalar(self.tcx, scalar, ty);
         debug_assert!(value.is_deterministic());
-        self.insert(Value::Constant { value, disambiguator: 0 })
+        self.insert(ty, Value::Constant { value, disambiguator: 0 })
     }
 
-    fn insert_tuple(&mut self, values: Vec<VnIndex>) -> VnIndex {
-        self.insert(Value::Aggregate(AggregateTy::Tuple, VariantIdx::ZERO, values))
+    fn insert_tuple(&mut self, ty: Ty<'tcx>, values: Vec<VnIndex>) -> VnIndex {
+        self.insert(ty, Value::Aggregate(AggregateTy::Tuple, VariantIdx::ZERO, values))
     }
 
-    fn insert_deref(&mut self, value: VnIndex) -> VnIndex {
-        let value = self.insert(Value::Projection(value, ProjectionElem::Deref));
+    fn insert_deref(&mut self, ty: Ty<'tcx>, value: VnIndex) -> VnIndex {
+        let value = self.insert(ty, Value::Projection(value, ProjectionElem::Deref));
         self.derefs.push(value);
         value
     }
@@ -376,14 +389,18 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     fn invalidate_derefs(&mut self) {
         for deref in std::mem::take(&mut self.derefs) {
             let opaque = self.next_opaque();
-            *self.values.get_index_mut2(deref.index()).unwrap() = Value::Opaque(opaque);
+            self.values.get_index_mut2(deref.index()).unwrap().0 = Value::Opaque(opaque);
         }
     }
 
     #[instrument(level = "trace", skip(self), ret)]
     fn eval_to_const(&mut self, value: VnIndex) -> Option<OpTy<'tcx>> {
         use Value::*;
+        let ty = self.ty(value);
+        let ty = self.ecx.layout_of(ty).ok()?;
         let op = match *self.get(value) {
+            _ if ty.is_zst() => ImmTy::uninit(ty).into(),
+
             Opaque(_) => return None,
             // Do not bother evaluating repeat expressions. This would uselessly consume memory.
             Repeat(..) => return None,
@@ -391,31 +408,14 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             Constant { ref value, disambiguator: _ } => {
                 self.ecx.eval_mir_constant(value, DUMMY_SP, None).discard_err()?
             }
-            Aggregate(kind, variant, ref fields) => {
+            Aggregate(_, variant, ref fields) => {
                 let fields = fields
                     .iter()
                     .map(|&f| self.evaluated[f].as_ref())
                     .collect::<Option<Vec<_>>>()?;
-                let ty = match kind {
-                    AggregateTy::Array => {
-                        assert!(fields.len() > 0);
-                        Ty::new_array(self.tcx, fields[0].layout.ty, fields.len() as u64)
-                    }
-                    AggregateTy::Tuple => {
-                        Ty::new_tup_from_iter(self.tcx, fields.iter().map(|f| f.layout.ty))
-                    }
-                    AggregateTy::Def(def_id, args) => {
-                        self.tcx.type_of(def_id).instantiate(self.tcx, args)
-                    }
-                };
-                let variant = if ty.is_enum() { Some(variant) } else { None };
-                let ty = self.ecx.layout_of(ty).ok()?;
-                if ty.is_zst() {
-                    ImmTy::uninit(ty).into()
-                } else if matches!(
-                    ty.backend_repr,
-                    BackendRepr::Scalar(..) | BackendRepr::ScalarPair(..)
-                ) {
+                let variant = if ty.ty.is_enum() { Some(variant) } else { None };
+                if matches!(ty.backend_repr, BackendRepr::Scalar(..) | BackendRepr::ScalarPair(..))
+                {
                     let dest = self.ecx.allocate(ty, MemoryKind::Stack).discard_err()?;
                     let variant_dest = if let Some(variant) = variant {
                         self.ecx.project_downcast(&dest, variant).discard_err()?
@@ -440,11 +440,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     return None;
                 }
             }
-            RawPtr { pointer, metadata, output_pointer_ty, data_pointer_ty: _ } => {
+            RawPtr { pointer, metadata, output_pointer_ty: _, data_pointer_ty: _ } => {
                 let pointer = self.evaluated[pointer].as_ref()?;
                 let metadata = self.evaluated[metadata].as_ref()?;
-                let output_pointer_ty = self.ecx.layout_of(output_pointer_ty).ok()?;
-                debug_assert!(!output_pointer_ty.is_zst());
 
                 // Pointers don't have fields, so don't `project_field` them.
                 let data = self.ecx.read_pointer(pointer).discard_err()?;
@@ -454,7 +452,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     MemPlaceMeta::Meta(self.ecx.read_scalar(metadata).discard_err()?)
                 };
                 let ptr_imm = Immediate::new_pointer_with_meta(data, meta, &self.ecx);
-                ImmTy::from_immediate(ptr_imm, output_pointer_ty).into()
+                ImmTy::from_immediate(ptr_imm, ty).into()
             }
 
             Projection(base, elem) => {
@@ -481,7 +479,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 };
                 self.ecx.project(value, elem).discard_err()?
             }
-            Address { place, kind, provenance: _ } => {
+            Address { place, kind: _, provenance: _ } => {
                 if !place.is_indirect_first_projection() {
                     return None;
                 }
@@ -497,19 +495,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     mplace = self.ecx.project(&mplace, proj).discard_err()?;
                 }
                 let pointer = mplace.to_ref(&self.ecx);
-                let ty = match kind {
-                    AddressKind::Ref(bk) => Ty::new_ref(
-                        self.tcx,
-                        self.tcx.lifetimes.re_erased,
-                        mplace.layout.ty,
-                        bk.to_mutbl_lossy(),
-                    ),
-                    AddressKind::Address(mutbl) => {
-                        Ty::new_ptr(self.tcx, mplace.layout.ty, mutbl.to_mutbl_lossy())
-                    }
-                };
-                let layout = self.ecx.layout_of(ty).ok()?;
-                ImmTy::from_immediate(pointer, layout).into()
+                ImmTy::from_immediate(pointer, ty).into()
             }
 
             Discriminant(base) => {
@@ -521,32 +507,28 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
             Len(slice) => {
                 let slice = self.evaluated[slice].as_ref()?;
-                let usize_layout = self.ecx.layout_of(self.tcx.types.usize).unwrap();
                 let len = slice.len(&self.ecx).discard_err()?;
-                let imm = ImmTy::from_uint(len, usize_layout);
-                imm.into()
+                ImmTy::from_uint(len, ty).into()
             }
-            NullaryOp(null_op, ty) => {
-                let layout = self.ecx.layout_of(ty).ok()?;
+            NullaryOp(null_op, arg_ty) => {
+                let arg_layout = self.ecx.layout_of(arg_ty).ok()?;
                 if let NullOp::SizeOf | NullOp::AlignOf = null_op
-                    && layout.is_unsized()
+                    && arg_layout.is_unsized()
                 {
                     return None;
                 }
                 let val = match null_op {
-                    NullOp::SizeOf => layout.size.bytes(),
-                    NullOp::AlignOf => layout.align.abi.bytes(),
+                    NullOp::SizeOf => arg_layout.size.bytes(),
+                    NullOp::AlignOf => arg_layout.align.abi.bytes(),
                     NullOp::OffsetOf(fields) => self
                         .ecx
                         .tcx
-                        .offset_of_subfield(self.typing_env(), layout, fields.iter())
+                        .offset_of_subfield(self.typing_env(), arg_layout, fields.iter())
                         .bytes(),
                     NullOp::UbChecks => return None,
                     NullOp::ContractChecks => return None,
                 };
-                let usize_layout = self.ecx.layout_of(self.tcx.types.usize).unwrap();
-                let imm = ImmTy::from_uint(val, usize_layout);
-                imm.into()
+                ImmTy::from_uint(val, ty).into()
             }
             UnaryOp(un_op, operand) => {
                 let operand = self.evaluated[operand].as_ref()?;
@@ -562,30 +544,27 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 let val = self.ecx.binary_op(bin_op, &lhs, &rhs).discard_err()?;
                 val.into()
             }
-            Cast { kind, value, from: _, to } => match kind {
+            Cast { kind, value, from: _, to: _ } => match kind {
                 CastKind::IntToInt | CastKind::IntToFloat => {
                     let value = self.evaluated[value].as_ref()?;
                     let value = self.ecx.read_immediate(value).discard_err()?;
-                    let to = self.ecx.layout_of(to).ok()?;
-                    let res = self.ecx.int_to_int_or_float(&value, to).discard_err()?;
+                    let res = self.ecx.int_to_int_or_float(&value, ty).discard_err()?;
                     res.into()
                 }
                 CastKind::FloatToFloat | CastKind::FloatToInt => {
                     let value = self.evaluated[value].as_ref()?;
                     let value = self.ecx.read_immediate(value).discard_err()?;
-                    let to = self.ecx.layout_of(to).ok()?;
-                    let res = self.ecx.float_to_float_or_int(&value, to).discard_err()?;
+                    let res = self.ecx.float_to_float_or_int(&value, ty).discard_err()?;
                     res.into()
                 }
                 CastKind::Transmute => {
                     let value = self.evaluated[value].as_ref()?;
-                    let to = self.ecx.layout_of(to).ok()?;
                     // `offset` for immediates generally only supports projections that match the
                     // type of the immediate. However, as a HACK, we exploit that it can also do
                     // limited transmutes: it only works between types with the same layout, and
                     // cannot transmute pointers to integers.
                     if value.as_mplace_or_imm().is_right() {
-                        let can_transmute = match (value.layout.backend_repr, to.backend_repr) {
+                        let can_transmute = match (value.layout.backend_repr, ty.backend_repr) {
                             (BackendRepr::Scalar(s1), BackendRepr::Scalar(s2)) => {
                                 s1.size(&self.ecx) == s2.size(&self.ecx)
                                     && !matches!(s1.primitive(), Primitive::Pointer(..))
@@ -605,13 +584,12 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                             return None;
                         }
                     }
-                    value.offset(Size::ZERO, to, &self.ecx).discard_err()?
+                    value.offset(Size::ZERO, ty, &self.ecx).discard_err()?
                 }
                 CastKind::PointerCoercion(ty::adjustment::PointerCoercion::Unsize, _) => {
                     let src = self.evaluated[value].as_ref()?;
-                    let to = self.ecx.layout_of(to).ok()?;
-                    let dest = self.ecx.allocate(to, MemoryKind::Stack).discard_err()?;
-                    self.ecx.unsize_into(src, to, &dest.clone().into()).discard_err()?;
+                    let dest = self.ecx.allocate(ty, MemoryKind::Stack).discard_err()?;
+                    self.ecx.unsize_into(src, ty, &dest.clone().into()).discard_err()?;
                     self.ecx
                         .alloc_mark_immutable(dest.ptr().provenance.unwrap().alloc_id())
                         .discard_err()?;
@@ -620,15 +598,13 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 CastKind::FnPtrToPtr | CastKind::PtrToPtr => {
                     let src = self.evaluated[value].as_ref()?;
                     let src = self.ecx.read_immediate(src).discard_err()?;
-                    let to = self.ecx.layout_of(to).ok()?;
-                    let ret = self.ecx.ptr_to_ptr(&src, to).discard_err()?;
+                    let ret = self.ecx.ptr_to_ptr(&src, ty).discard_err()?;
                     ret.into()
                 }
                 CastKind::PointerCoercion(ty::adjustment::PointerCoercion::UnsafeFnPointer, _) => {
                     let src = self.evaluated[value].as_ref()?;
                     let src = self.ecx.read_immediate(src).discard_err()?;
-                    let to = self.ecx.layout_of(to).ok()?;
-                    ImmTy::from_immediate(*src, to).into()
+                    ImmTy::from_immediate(*src, ty).into()
                 }
                 _ => return None,
             },
@@ -638,21 +614,20 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
     fn project(
         &mut self,
-        place: PlaceRef<'tcx>,
+        place_ty: PlaceTy<'tcx>,
         value: VnIndex,
         proj: PlaceElem<'tcx>,
         from_non_ssa_index: &mut bool,
-    ) -> Option<VnIndex> {
+    ) -> Option<(PlaceTy<'tcx>, VnIndex)> {
+        let projection_ty = place_ty.projection_ty(self.tcx, proj);
         let proj = match proj {
             ProjectionElem::Deref => {
-                let ty = place.ty(self.local_decls, self.tcx).ty;
-                if let Some(Mutability::Not) = ty.ref_mutability()
-                    && let Some(pointee_ty) = ty.builtin_deref(true)
-                    && pointee_ty.is_freeze(self.tcx, self.typing_env())
+                if let Some(Mutability::Not) = place_ty.ty.ref_mutability()
+                    && projection_ty.ty.is_freeze(self.tcx, self.typing_env())
                 {
                     // An immutable borrow `_x` always points to the same value for the
                     // lifetime of the borrow, so we can merge all instances of `*_x`.
-                    return Some(self.insert_deref(value));
+                    return Some((projection_ty, self.insert_deref(projection_ty.ty, value)));
                 } else {
                     return None;
                 }
@@ -660,7 +635,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             ProjectionElem::Downcast(name, index) => ProjectionElem::Downcast(name, index),
             ProjectionElem::Field(f, ty) => {
                 if let Value::Aggregate(_, _, fields) = self.get(value) {
-                    return Some(fields[f.as_usize()]);
+                    return Some((projection_ty, fields[f.as_usize()]));
                 } else if let Value::Projection(outer_value, ProjectionElem::Downcast(_, read_variant)) = self.get(value)
                     && let Value::Aggregate(_, written_variant, fields) = self.get(*outer_value)
                     // This pass is not aware of control-flow, so we do not know whether the
@@ -680,14 +655,14 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     // a downcast to an inactive variant.
                     && written_variant == read_variant
                 {
-                    return Some(fields[f.as_usize()]);
+                    return Some((projection_ty, fields[f.as_usize()]));
                 }
                 ProjectionElem::Field(f, ty)
             }
             ProjectionElem::Index(idx) => {
                 if let Value::Repeat(inner, _) = self.get(value) {
                     *from_non_ssa_index |= self.locals[idx].is_none();
-                    return Some(*inner);
+                    return Some((projection_ty, *inner));
                 }
                 let idx = self.locals[idx]?;
                 ProjectionElem::Index(idx)
@@ -695,7 +670,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             ProjectionElem::ConstantIndex { offset, min_length, from_end } => {
                 match self.get(value) {
                     Value::Repeat(inner, _) => {
-                        return Some(*inner);
+                        return Some((projection_ty, *inner));
                     }
                     Value::Aggregate(AggregateTy::Array, _, operands) => {
                         let offset = if from_end {
@@ -703,7 +678,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                         } else {
                             offset as usize
                         };
-                        return operands.get(offset).copied();
+                        let value = operands.get(offset).copied()?;
+                        return Some((projection_ty, value));
                     }
                     _ => {}
                 };
@@ -717,7 +693,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             ProjectionElem::UnwrapUnsafeBinder(ty) => ProjectionElem::UnwrapUnsafeBinder(ty),
         };
 
-        Some(self.insert(Value::Projection(value, proj)))
+        let value = self.insert(projection_ty.ty, Value::Projection(value, proj));
+        Some((projection_ty, value))
     }
 
     /// Simplify the projection chain if we know better.
@@ -779,6 +756,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
         // Invariant: `value` holds the value up-to the `index`th projection excluded.
         let mut value = self.locals[place.local]?;
+        // Invariant: `value` has type `place_ty`, with optional downcast variant if needed.
+        let mut place_ty = PlaceTy::from_ty(self.local_decls[place.local].ty);
         let mut from_non_ssa_index = false;
         for (index, proj) in place.projection.iter().enumerate() {
             if let Value::Projection(pointer, ProjectionElem::Deref) = *self.get(value)
@@ -796,8 +775,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 place_ref = PlaceRef { local, projection: &place.projection[index..] };
             }
 
-            let base = PlaceRef { local: place.local, projection: &place.projection[..index] };
-            value = self.project(base, value, proj, &mut from_non_ssa_index)?;
+            (place_ty, value) = self.project(place_ty, value, proj, &mut from_non_ssa_index)?;
         }
 
         if let Value::Projection(pointer, ProjectionElem::Deref) = *self.get(value)
@@ -906,8 +884,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             // Unsupported values.
             Rvalue::ThreadLocalRef(..) | Rvalue::ShallowInitBox(..) => return None,
         };
-        debug!(?value);
-        Some(self.insert(value))
+        let ty = rvalue.ty(self.local_decls, self.tcx);
+        Some(self.insert(ty, value))
     }
 
     fn simplify_discriminant(&mut self, place: VnIndex) -> Option<VnIndex> {
@@ -917,7 +895,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         {
             let enum_ty = self.tcx.type_of(enum_did).instantiate(self.tcx, enum_args);
             let discr = self.ecx.discriminant_for_variant(enum_ty, variant).discard_err()?;
-            return Some(self.insert_scalar(discr.to_scalar(), discr.layout.ty));
+            return Some(self.insert_scalar(discr.layout.ty, discr.to_scalar()));
         }
 
         None
@@ -1014,9 +992,11 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         rvalue: &mut Rvalue<'tcx>,
         location: Location,
     ) -> Option<VnIndex> {
+        let tcx = self.tcx;
+        let ty = rvalue.ty(self.local_decls, tcx);
+
         let Rvalue::Aggregate(box ref kind, ref mut field_ops) = *rvalue else { bug!() };
 
-        let tcx = self.tcx;
         if field_ops.is_empty() {
             let is_zst = match *kind {
                 AggregateKind::Array(..)
@@ -1031,17 +1011,19 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             };
 
             if is_zst {
-                let ty = rvalue.ty(self.local_decls, tcx);
                 return Some(self.insert_constant(Const::zero_sized(ty)));
             }
         }
 
         let fields: Vec<_> = field_ops
             .iter_mut()
-            .map(|op| self.simplify_operand(op, location).unwrap_or_else(|| self.new_opaque()))
+            .map(|op| {
+                self.simplify_operand(op, location)
+                    .unwrap_or_else(|| self.new_opaque(op.ty(self.local_decls, self.tcx)))
+            })
             .collect();
 
-        let (ty, variant_index) = match *kind {
+        let (aty, variant_index) = match *kind {
             AggregateKind::Array(..) => {
                 assert!(!field_ops.is_empty());
                 (AggregateTy::Array, FIRST_VARIANT)
@@ -1058,10 +1040,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
             // Do not track unions.
             AggregateKind::Adt(_, _, _, _, Some(_)) => return None,
-            AggregateKind::RawPtr(pointee_ty, mtbl) => {
+            AggregateKind::RawPtr(..) => {
                 assert_eq!(field_ops.len(), 2);
                 let mut data_pointer_ty = field_ops[FieldIdx::ZERO].ty(self.local_decls, self.tcx);
-                let output_pointer_ty = Ty::new_ptr(self.tcx, pointee_ty, mtbl);
 
                 let [mut pointer, metadata] = fields.try_into().unwrap();
 
@@ -1074,7 +1055,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     to: _,
                 } = self.get(pointer)
                     && let ty::RawPtr(from_pointee_ty, from_mtbl) = cast_from.kind()
-                    && let ty::RawPtr(_, output_mtbl) = output_pointer_ty.kind()
+                    && let ty::RawPtr(_, output_mtbl) = ty.kind()
                     && from_mtbl == output_mtbl
                     && from_pointee_ty.is_sized(self.tcx, self.typing_env())
                 {
@@ -1087,16 +1068,14 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     field_ops[FieldIdx::ZERO] = op;
                 }
 
-                return Some(self.insert(Value::RawPtr {
-                    output_pointer_ty,
-                    data_pointer_ty,
-                    pointer,
-                    metadata,
-                }));
+                return Some(self.insert(
+                    ty,
+                    Value::RawPtr { output_pointer_ty: ty, data_pointer_ty, pointer, metadata },
+                ));
             }
         };
 
-        if let AggregateTy::Array = ty
+        if let AggregateTy::Array = aty
             && fields.len() > 4
         {
             let first = fields[0];
@@ -1105,18 +1084,18 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 if let Some(op) = self.try_as_operand(first, location) {
                     *rvalue = Rvalue::Repeat(op, len);
                 }
-                return Some(self.insert(Value::Repeat(first, len)));
+                return Some(self.insert(ty, Value::Repeat(first, len)));
             }
         }
 
-        if let AggregateTy::Def(_, _) = ty
+        if let AggregateTy::Def(_, _) = aty
             && let Some(value) =
                 self.simplify_aggregate_to_copy(lhs, rvalue, location, &fields, variant_index)
         {
             return Some(value);
         }
 
-        Some(self.insert(Value::Aggregate(ty, variant_index, fields)))
+        Some(self.insert(ty, Value::Aggregate(aty, variant_index, fields)))
     }
 
     #[instrument(level = "trace", skip(self), ret)]
@@ -1197,7 +1176,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
             _ => Value::UnaryOp(op, arg_index),
         };
-        Some(self.insert(value))
+        let ty = op.ty(self.tcx, self.ty(arg_index));
+        Some(self.insert(ty, value))
     }
 
     #[instrument(level = "trace", skip(self), ret)]
@@ -1243,8 +1223,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         if let Some(value) = self.simplify_binary_inner(op, lhs_ty, lhs, rhs) {
             return Some(value);
         }
+        let ty = op.ty(self.tcx, self.ty(lhs), self.ty(rhs));
         let value = Value::BinaryOp(op, lhs, rhs);
-        Some(self.insert(value))
+        Some(self.insert(ty, value))
     }
 
     fn simplify_binary_inner(
@@ -1336,19 +1317,19 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 | BinOp::Shr,
                 Left(0),
                 _,
-            ) => self.insert_scalar(Scalar::from_uint(0u128, layout.size), lhs_ty),
+            ) => self.insert_scalar(lhs_ty, Scalar::from_uint(0u128, layout.size)),
             // Attempt to simplify `x | ALL_ONES` to `ALL_ONES`.
             (BinOp::BitOr, _, Left(ones)) | (BinOp::BitOr, Left(ones), _)
                 if ones == layout.size.truncate(u128::MAX)
                     || (layout.ty.is_bool() && ones == 1) =>
             {
-                self.insert_scalar(Scalar::from_uint(ones, layout.size), lhs_ty)
+                self.insert_scalar(lhs_ty, Scalar::from_uint(ones, layout.size))
             }
             // Sub/Xor with itself.
             (BinOp::Sub | BinOp::SubWithOverflow | BinOp::SubUnchecked | BinOp::BitXor, a, b)
                 if a == b =>
             {
-                self.insert_scalar(Scalar::from_uint(0u128, layout.size), lhs_ty)
+                self.insert_scalar(lhs_ty, Scalar::from_uint(0u128, layout.size))
             }
             // Comparison:
             // - if both operands can be computed as bits, just compare the bits;
@@ -1362,8 +1343,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         };
 
         if op.is_overflowing() {
+            let ty = Ty::new_tup(self.tcx, &[self.ty(result), self.tcx.types.bool]);
             let false_val = self.insert_bool(false);
-            Some(self.insert_tuple(vec![result, false_val]))
+            Some(self.insert_tuple(ty, vec![result, false_val]))
         } else {
             Some(result)
         }
@@ -1389,7 +1371,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         if let CastKind::PointerCoercion(ReifyFnPointer | ClosureFnPointer(_), _) = kind {
             // Each reification of a generic fn may get a different pointer.
             // Do not try to merge them.
-            return Some(self.new_opaque());
+            return Some(self.new_opaque(to));
         }
 
         let mut was_ever_updated = false;
@@ -1497,7 +1479,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             *initial_kind = kind;
         }
 
-        Some(self.insert(Value::Cast { kind, value, from, to }))
+        Some(self.insert(to, Value::Cast { kind, value, from, to }))
     }
 
     fn simplify_len(&mut self, place: &mut Place<'tcx>, location: Location) -> Option<VnIndex> {
@@ -1530,7 +1512,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         }
 
         // Fallback: a symbolic `Len`.
-        Some(self.insert(Value::Len(inner)))
+        Some(self.insert(self.tcx.types.usize, Value::Len(inner)))
     }
 
     fn pointers_have_same_metadata(&self, left_ptr_ty: Ty<'tcx>, right_ptr_ty: Ty<'tcx>) -> bool {
@@ -1807,11 +1789,12 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, 'tcx> {
 
         if let Some(local) = lhs.as_local()
             && self.ssa.is_ssa(local)
+            && let rvalue_ty = rvalue.ty(self.local_decls, self.tcx)
             // FIXME(#112651) `rvalue` may have a subtype to `local`. We can only mark
             // `local` as reusable if we have an exact type match.
-            && self.local_decls[local].ty == rvalue.ty(self.local_decls, self.tcx)
+            && self.local_decls[local].ty == rvalue_ty
         {
-            let value = value.unwrap_or_else(|| self.new_opaque());
+            let value = value.unwrap_or_else(|| self.new_opaque(rvalue_ty));
             self.assign(local, value);
         }
     }
@@ -1821,7 +1804,8 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, 'tcx> {
             if let Some(local) = destination.as_local()
                 && self.ssa.is_ssa(local)
             {
-                let opaque = self.new_opaque();
+                let ty = self.local_decls[local].ty;
+                let opaque = self.new_opaque(ty);
                 self.assign(local, opaque);
             }
         }
diff --git a/tests/mir-opt/const_prop/transmute.rs b/tests/mir-opt/const_prop/transmute.rs
index 892b91a5414..33cbefbf053 100644
--- a/tests/mir-opt/const_prop/transmute.rs
+++ b/tests/mir-opt/const_prop/transmute.rs
@@ -56,7 +56,7 @@ pub unsafe fn undef_union_as_integer() -> u32 {
 pub unsafe fn unreachable_direct() -> ! {
     // CHECK-LABEL: fn unreachable_direct(
     // CHECK: = const ();
-    // CHECK: = const () as Never (Transmute);
+    // CHECK: = const ZeroSized: Never;
     let x: Never = unsafe { transmute(()) };
     match x {}
 }
diff --git a/tests/mir-opt/const_prop/transmute.unreachable_direct.GVN.32bit.diff b/tests/mir-opt/const_prop/transmute.unreachable_direct.GVN.32bit.diff
index 3364782022d..5aeb55a5a6a 100644
--- a/tests/mir-opt/const_prop/transmute.unreachable_direct.GVN.32bit.diff
+++ b/tests/mir-opt/const_prop/transmute.unreachable_direct.GVN.32bit.diff
@@ -15,7 +15,7 @@
 -         _2 = ();
 -         _1 = move _2 as Never (Transmute);
 +         _2 = const ();
-+         _1 = const () as Never (Transmute);
++         _1 = const ZeroSized: Never;
           unreachable;
       }
   }
diff --git a/tests/mir-opt/const_prop/transmute.unreachable_direct.GVN.64bit.diff b/tests/mir-opt/const_prop/transmute.unreachable_direct.GVN.64bit.diff
index 3364782022d..5aeb55a5a6a 100644
--- a/tests/mir-opt/const_prop/transmute.unreachable_direct.GVN.64bit.diff
+++ b/tests/mir-opt/const_prop/transmute.unreachable_direct.GVN.64bit.diff
@@ -15,7 +15,7 @@
 -         _2 = ();
 -         _1 = move _2 as Never (Transmute);
 +         _2 = const ();
-+         _1 = const () as Never (Transmute);
++         _1 = const ZeroSized: Never;
           unreachable;
       }
   }
diff --git a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff
index 770c6730775..ffe4a0272b4 100644
--- a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff
@@ -18,7 +18,8 @@
   
       bb0: {
           _4 = copy _1 as *const T (PtrToPtr);
-          _5 = PtrMetadata(copy _4);
+-         _5 = PtrMetadata(copy _4);
++         _5 = const ();
           _6 = copy _1 as *const (&A, [T]) (PtrToPtr);
 -         _7 = PtrMetadata(copy _6);
 +         _7 = PtrMetadata(copy _1);
diff --git a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff
index 770c6730775..ffe4a0272b4 100644
--- a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff
@@ -18,7 +18,8 @@
   
       bb0: {
           _4 = copy _1 as *const T (PtrToPtr);
-          _5 = PtrMetadata(copy _4);
+-         _5 = PtrMetadata(copy _4);
++         _5 = const ();
           _6 = copy _1 as *const (&A, [T]) (PtrToPtr);
 -         _7 = PtrMetadata(copy _6);
 +         _7 = PtrMetadata(copy _1);
diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs
index 6ef320c90de..5d348bc3c1e 100644
--- a/tests/mir-opt/gvn.rs
+++ b/tests/mir-opt/gvn.rs
@@ -869,7 +869,7 @@ fn generic_cast_metadata<T, A: ?Sized, B: ?Sized>(ps: *const [T], pa: *const A,
 
             // Metadata usize -> (), do not optimize.
             // CHECK: [[T:_.+]] = copy _1 as
-            // CHECK-NEXT: PtrMetadata(copy [[T]])
+            // CHECK-NEXT: const ();
             let t1 = CastPtrToPtr::<_, *const T>(ps);
             let m1 = PtrMetadata(t1);
 
-- 
cgit 1.4.1-3-g733a5


From 4750dff54eab52a308a1a1afd85b4614d652841a Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Mon, 30 Jun 2025 19:50:11 +0000
Subject: Remove extraneous types.

---
 compiler/rustc_mir_transform/src/gvn.rs            | 209 ++++++++-------------
 ...umerated_loop.PreCodegen.after.panic-unwind.mir |   5 +-
 2 files changed, 80 insertions(+), 134 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 3e4c05b355f..e081d1fde93 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -105,7 +105,6 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::layout::{HasTypingEnv, LayoutOf};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::DUMMY_SP;
-use rustc_span::def_id::DefId;
 use smallvec::SmallVec;
 use tracing::{debug, instrument, trace};
 
@@ -155,16 +154,6 @@ newtype_index! {
     struct VnIndex {}
 }
 
-/// Computing the aggregate's type can be quite slow, so we only keep the minimal amount of
-/// information to reconstruct it when needed.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-enum AggregateTy<'tcx> {
-    /// Invariant: this must not be used for an empty array.
-    Array,
-    Tuple,
-    Def(DefId, ty::GenericArgsRef<'tcx>),
-}
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 enum AddressKind {
     Ref(BorrowKind),
@@ -187,17 +176,13 @@ enum Value<'tcx> {
     },
     /// An aggregate value, either tuple/closure/struct/enum.
     /// This does not contain unions, as we cannot reason with the value.
-    Aggregate(AggregateTy<'tcx>, VariantIdx, Vec<VnIndex>),
+    Aggregate(VariantIdx, Vec<VnIndex>),
     /// A raw pointer aggregate built from a thin pointer and metadata.
     RawPtr {
         /// Thin pointer component. This is field 0 in MIR.
         pointer: VnIndex,
         /// Metadata component. This is field 1 in MIR.
         metadata: VnIndex,
-        /// Needed for cast propagation.
-        data_pointer_ty: Ty<'tcx>,
-        /// The data pointer can be anything thin, so doesn't determine the output.
-        output_pointer_ty: Ty<'tcx>,
     },
     /// This corresponds to a `[value; count]` expression.
     Repeat(VnIndex, ty::Const<'tcx>),
@@ -211,7 +196,7 @@ enum Value<'tcx> {
 
     // Extractions.
     /// This is the *value* obtained by projecting another value.
-    Projection(VnIndex, ProjectionElem<VnIndex, Ty<'tcx>>),
+    Projection(VnIndex, ProjectionElem<VnIndex, ()>),
     /// Discriminant of the given value.
     Discriminant(VnIndex),
     /// Length of an array or slice.
@@ -224,8 +209,6 @@ enum Value<'tcx> {
     Cast {
         kind: CastKind,
         value: VnIndex,
-        from: Ty<'tcx>,
-        to: Ty<'tcx>,
     },
 }
 
@@ -377,7 +360,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     }
 
     fn insert_tuple(&mut self, ty: Ty<'tcx>, values: Vec<VnIndex>) -> VnIndex {
-        self.insert(ty, Value::Aggregate(AggregateTy::Tuple, VariantIdx::ZERO, values))
+        self.insert(ty, Value::Aggregate(VariantIdx::ZERO, values))
     }
 
     fn insert_deref(&mut self, ty: Ty<'tcx>, value: VnIndex) -> VnIndex {
@@ -408,7 +391,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             Constant { ref value, disambiguator: _ } => {
                 self.ecx.eval_mir_constant(value, DUMMY_SP, None).discard_err()?
             }
-            Aggregate(_, variant, ref fields) => {
+            Aggregate(variant, ref fields) => {
                 let fields = fields
                     .iter()
                     .map(|&f| self.evaluated[f].as_ref())
@@ -440,7 +423,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     return None;
                 }
             }
-            RawPtr { pointer, metadata, output_pointer_ty: _, data_pointer_ty: _ } => {
+            RawPtr { pointer, metadata } => {
                 let pointer = self.evaluated[pointer].as_ref()?;
                 let metadata = self.evaluated[metadata].as_ref()?;
 
@@ -456,28 +439,28 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
 
             Projection(base, elem) => {
-                let value = self.evaluated[base].as_ref()?;
+                let base = self.evaluated[base].as_ref()?;
                 let elem = match elem {
                     ProjectionElem::Deref => ProjectionElem::Deref,
                     ProjectionElem::Downcast(name, read_variant) => {
                         ProjectionElem::Downcast(name, read_variant)
                     }
-                    ProjectionElem::Field(f, ty) => ProjectionElem::Field(f, ty),
+                    ProjectionElem::Field(f, ()) => ProjectionElem::Field(f, ty.ty),
                     ProjectionElem::ConstantIndex { offset, min_length, from_end } => {
                         ProjectionElem::ConstantIndex { offset, min_length, from_end }
                     }
                     ProjectionElem::Subslice { from, to, from_end } => {
                         ProjectionElem::Subslice { from, to, from_end }
                     }
-                    ProjectionElem::OpaqueCast(ty) => ProjectionElem::OpaqueCast(ty),
-                    ProjectionElem::Subtype(ty) => ProjectionElem::Subtype(ty),
-                    ProjectionElem::UnwrapUnsafeBinder(ty) => {
-                        ProjectionElem::UnwrapUnsafeBinder(ty)
+                    ProjectionElem::OpaqueCast(()) => ProjectionElem::OpaqueCast(ty.ty),
+                    ProjectionElem::Subtype(()) => ProjectionElem::Subtype(ty.ty),
+                    ProjectionElem::UnwrapUnsafeBinder(()) => {
+                        ProjectionElem::UnwrapUnsafeBinder(ty.ty)
                     }
                     // This should have been replaced by a `ConstantIndex` earlier.
                     ProjectionElem::Index(_) => return None,
                 };
-                self.ecx.project(value, elem).discard_err()?
+                self.ecx.project(base, elem).discard_err()?
             }
             Address { place, kind: _, provenance: _ } => {
                 if !place.is_indirect_first_projection() {
@@ -544,7 +527,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 let val = self.ecx.binary_op(bin_op, &lhs, &rhs).discard_err()?;
                 val.into()
             }
-            Cast { kind, value, from: _, to: _ } => match kind {
+            Cast { kind, value } => match kind {
                 CastKind::IntToInt | CastKind::IntToFloat => {
                     let value = self.evaluated[value].as_ref()?;
                     let value = self.ecx.read_immediate(value).discard_err()?;
@@ -633,11 +616,11 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 }
             }
             ProjectionElem::Downcast(name, index) => ProjectionElem::Downcast(name, index),
-            ProjectionElem::Field(f, ty) => {
-                if let Value::Aggregate(_, _, fields) = self.get(value) {
+            ProjectionElem::Field(f, _) => {
+                if let Value::Aggregate(_, fields) = self.get(value) {
                     return Some((projection_ty, fields[f.as_usize()]));
                 } else if let Value::Projection(outer_value, ProjectionElem::Downcast(_, read_variant)) = self.get(value)
-                    && let Value::Aggregate(_, written_variant, fields) = self.get(*outer_value)
+                    && let Value::Aggregate(written_variant, fields) = self.get(*outer_value)
                     // This pass is not aware of control-flow, so we do not know whether the
                     // replacement we are doing is actually reachable. We could be in any arm of
                     // ```
@@ -657,7 +640,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 {
                     return Some((projection_ty, fields[f.as_usize()]));
                 }
-                ProjectionElem::Field(f, ty)
+                ProjectionElem::Field(f, ())
             }
             ProjectionElem::Index(idx) => {
                 if let Value::Repeat(inner, _) = self.get(value) {
@@ -672,7 +655,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     Value::Repeat(inner, _) => {
                         return Some((projection_ty, *inner));
                     }
-                    Value::Aggregate(AggregateTy::Array, _, operands) => {
+                    Value::Aggregate(_, operands) => {
                         let offset = if from_end {
                             operands.len() - offset as usize
                         } else {
@@ -688,9 +671,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             ProjectionElem::Subslice { from, to, from_end } => {
                 ProjectionElem::Subslice { from, to, from_end }
             }
-            ProjectionElem::OpaqueCast(ty) => ProjectionElem::OpaqueCast(ty),
-            ProjectionElem::Subtype(ty) => ProjectionElem::Subtype(ty),
-            ProjectionElem::UnwrapUnsafeBinder(ty) => ProjectionElem::UnwrapUnsafeBinder(ty),
+            ProjectionElem::OpaqueCast(_) => ProjectionElem::OpaqueCast(()),
+            ProjectionElem::Subtype(_) => ProjectionElem::Subtype(()),
+            ProjectionElem::UnwrapUnsafeBinder(_) => ProjectionElem::UnwrapUnsafeBinder(()),
         };
 
         let value = self.insert(projection_ty.ty, Value::Projection(value, proj));
@@ -852,14 +835,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 self.simplify_place_projection(place, location);
                 return Some(self.new_pointer(*place, AddressKind::Address(mutbl)));
             }
-            Rvalue::WrapUnsafeBinder(ref mut op, ty) => {
+            Rvalue::WrapUnsafeBinder(ref mut op, _) => {
                 let value = self.simplify_operand(op, location)?;
-                Value::Cast {
-                    kind: CastKind::Transmute,
-                    value,
-                    from: op.ty(self.local_decls, self.tcx),
-                    to: ty,
-                }
+                Value::Cast { kind: CastKind::Transmute, value }
             }
 
             // Operations.
@@ -889,11 +867,10 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     }
 
     fn simplify_discriminant(&mut self, place: VnIndex) -> Option<VnIndex> {
-        if let Value::Aggregate(enum_ty, variant, _) = *self.get(place)
-            && let AggregateTy::Def(enum_did, enum_args) = enum_ty
-            && let DefKind::Enum = self.tcx.def_kind(enum_did)
+        let enum_ty = self.ty(place);
+        if enum_ty.is_enum()
+            && let Value::Aggregate(variant, _) = *self.get(place)
         {
-            let enum_ty = self.tcx.type_of(enum_did).instantiate(self.tcx, enum_args);
             let discr = self.ecx.discriminant_for_variant(enum_ty, variant).discard_err()?;
             return Some(self.insert_scalar(discr.layout.ty, discr.to_scalar()));
         }
@@ -903,12 +880,13 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
     fn try_as_place_elem(
         &mut self,
-        proj: ProjectionElem<VnIndex, Ty<'tcx>>,
+        ty: Ty<'tcx>,
+        proj: ProjectionElem<VnIndex, ()>,
         loc: Location,
     ) -> Option<PlaceElem<'tcx>> {
         Some(match proj {
             ProjectionElem::Deref => ProjectionElem::Deref,
-            ProjectionElem::Field(idx, ty) => ProjectionElem::Field(idx, ty),
+            ProjectionElem::Field(idx, ()) => ProjectionElem::Field(idx, ty),
             ProjectionElem::Index(idx) => {
                 let Some(local) = self.try_as_local(idx, loc) else {
                     return None;
@@ -923,9 +901,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 ProjectionElem::Subslice { from, to, from_end }
             }
             ProjectionElem::Downcast(symbol, idx) => ProjectionElem::Downcast(symbol, idx),
-            ProjectionElem::OpaqueCast(idx) => ProjectionElem::OpaqueCast(idx),
-            ProjectionElem::Subtype(idx) => ProjectionElem::Subtype(idx),
-            ProjectionElem::UnwrapUnsafeBinder(ty) => ProjectionElem::UnwrapUnsafeBinder(ty),
+            ProjectionElem::OpaqueCast(()) => ProjectionElem::OpaqueCast(ty),
+            ProjectionElem::Subtype(()) => ProjectionElem::Subtype(ty),
+            ProjectionElem::UnwrapUnsafeBinder(()) => ProjectionElem::UnwrapUnsafeBinder(ty),
         })
     }
 
@@ -971,8 +949,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
         // Allow introducing places with non-constant offsets, as those are still better than
         // reconstructing an aggregate.
-        if let Some(place) = self.try_as_place(copy_from_local_value, location, true)
-            && rvalue.ty(self.local_decls, self.tcx) == place.ty(self.local_decls, self.tcx).ty
+        if self.ty(copy_from_local_value) == rvalue.ty(self.local_decls, self.tcx)
+            && let Some(place) = self.try_as_place(copy_from_local_value, location, true)
         {
             // Avoid creating `*a = copy (*b)`, as they might be aliases resulting in overlapping assignments.
             // FIXME: This also avoids any kind of projection, not just derefs. We can add allowed projections.
@@ -1023,44 +1001,31 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             })
             .collect();
 
-        let (aty, variant_index) = match *kind {
-            AggregateKind::Array(..) => {
+        let variant_index = match *kind {
+            AggregateKind::Array(..) | AggregateKind::Tuple => {
                 assert!(!field_ops.is_empty());
-                (AggregateTy::Array, FIRST_VARIANT)
-            }
-            AggregateKind::Tuple => {
-                assert!(!field_ops.is_empty());
-                (AggregateTy::Tuple, FIRST_VARIANT)
-            }
-            AggregateKind::Closure(did, args)
-            | AggregateKind::CoroutineClosure(did, args)
-            | AggregateKind::Coroutine(did, args) => (AggregateTy::Def(did, args), FIRST_VARIANT),
-            AggregateKind::Adt(did, variant_index, args, _, None) => {
-                (AggregateTy::Def(did, args), variant_index)
+                FIRST_VARIANT
             }
+            AggregateKind::Closure(..)
+            | AggregateKind::CoroutineClosure(..)
+            | AggregateKind::Coroutine(..) => FIRST_VARIANT,
+            AggregateKind::Adt(_, variant_index, _, _, None) => variant_index,
             // Do not track unions.
             AggregateKind::Adt(_, _, _, _, Some(_)) => return None,
             AggregateKind::RawPtr(..) => {
                 assert_eq!(field_ops.len(), 2);
-                let mut data_pointer_ty = field_ops[FieldIdx::ZERO].ty(self.local_decls, self.tcx);
-
                 let [mut pointer, metadata] = fields.try_into().unwrap();
 
                 // Any thin pointer of matching mutability is fine as the data pointer.
                 let mut was_updated = false;
-                while let Value::Cast {
-                    kind: CastKind::PtrToPtr,
-                    value: cast_value,
-                    from: cast_from,
-                    to: _,
-                } = self.get(pointer)
-                    && let ty::RawPtr(from_pointee_ty, from_mtbl) = cast_from.kind()
+                while let Value::Cast { kind: CastKind::PtrToPtr, value: cast_value } =
+                    self.get(pointer)
+                    && let ty::RawPtr(from_pointee_ty, from_mtbl) = self.ty(*cast_value).kind()
                     && let ty::RawPtr(_, output_mtbl) = ty.kind()
                     && from_mtbl == output_mtbl
                     && from_pointee_ty.is_sized(self.tcx, self.typing_env())
                 {
                     pointer = *cast_value;
-                    data_pointer_ty = *cast_from;
                     was_updated = true;
                 }
 
@@ -1068,16 +1033,11 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     field_ops[FieldIdx::ZERO] = op;
                 }
 
-                return Some(self.insert(
-                    ty,
-                    Value::RawPtr { output_pointer_ty: ty, data_pointer_ty, pointer, metadata },
-                ));
+                return Some(self.insert(ty, Value::RawPtr { pointer, metadata }));
             }
         };
 
-        if let AggregateTy::Array = aty
-            && fields.len() > 4
-        {
+        if ty.is_array() && fields.len() > 4 {
             let first = fields[0];
             if fields.iter().all(|&v| v == first) {
                 let len = ty::Const::from_target_usize(self.tcx, fields.len().try_into().unwrap());
@@ -1088,14 +1048,13 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
         }
 
-        if let AggregateTy::Def(_, _) = aty
-            && let Some(value) =
-                self.simplify_aggregate_to_copy(lhs, rvalue, location, &fields, variant_index)
+        if let Some(value) =
+            self.simplify_aggregate_to_copy(lhs, rvalue, location, &fields, variant_index)
         {
             return Some(value);
         }
 
-        Some(self.insert(ty, Value::Aggregate(aty, variant_index, fields)))
+        Some(self.insert(ty, Value::Aggregate(variant_index, fields)))
     }
 
     #[instrument(level = "trace", skip(self), ret)]
@@ -1106,6 +1065,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         location: Location,
     ) -> Option<VnIndex> {
         let mut arg_index = self.simplify_operand(arg_op, location)?;
+        let arg_ty = self.ty(arg_index);
+        let ret_ty = op.ty(self.tcx, arg_ty);
 
         // PtrMetadata doesn't care about *const vs *mut vs & vs &mut,
         // so start by removing those distinctions so we can update the `Operand`
@@ -1121,8 +1082,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     // we can't always know exactly what the metadata are.
                     // To allow things like `*mut (?A, ?T)` <-> `*mut (?B, ?T)`,
                     // it's fine to get a projection as the type.
-                    Value::Cast { kind: CastKind::PtrToPtr, value: inner, from, to }
-                        if self.pointers_have_same_metadata(*from, *to) =>
+                    Value::Cast { kind: CastKind::PtrToPtr, value: inner }
+                        if self.pointers_have_same_metadata(self.ty(*inner), arg_ty) =>
                     {
                         arg_index = *inner;
                         was_updated = true;
@@ -1165,19 +1126,16 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 UnOp::PtrMetadata,
                 Value::Cast {
                     kind: CastKind::PointerCoercion(ty::adjustment::PointerCoercion::Unsize, _),
-                    from,
-                    to,
-                    ..
+                    value: inner,
                 },
-            ) if let ty::Slice(..) = to.builtin_deref(true).unwrap().kind()
-                && let ty::Array(_, len) = from.builtin_deref(true).unwrap().kind() =>
+            ) if let ty::Slice(..) = arg_ty.builtin_deref(true).unwrap().kind()
+                && let ty::Array(_, len) = self.ty(*inner).builtin_deref(true).unwrap().kind() =>
             {
                 return Some(self.insert_constant(Const::Ty(self.tcx.types.usize, *len)));
             }
             _ => Value::UnaryOp(op, arg_index),
         };
-        let ty = op.ty(self.tcx, self.ty(arg_index));
-        Some(self.insert(ty, value))
+        Some(self.insert(ret_ty, value))
     }
 
     #[instrument(level = "trace", skip(self), ret)]
@@ -1190,25 +1148,23 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     ) -> Option<VnIndex> {
         let lhs = self.simplify_operand(lhs_operand, location);
         let rhs = self.simplify_operand(rhs_operand, location);
+
         // Only short-circuit options after we called `simplify_operand`
         // on both operands for side effect.
         let mut lhs = lhs?;
         let mut rhs = rhs?;
 
-        let lhs_ty = lhs_operand.ty(self.local_decls, self.tcx);
+        let lhs_ty = self.ty(lhs);
 
         // If we're comparing pointers, remove `PtrToPtr` casts if the from
         // types of both casts and the metadata all match.
         if let BinOp::Eq | BinOp::Ne | BinOp::Lt | BinOp::Le | BinOp::Gt | BinOp::Ge = op
             && lhs_ty.is_any_ptr()
-            && let Value::Cast {
-                kind: CastKind::PtrToPtr, value: lhs_value, from: lhs_from, ..
-            } = self.get(lhs)
-            && let Value::Cast {
-                kind: CastKind::PtrToPtr, value: rhs_value, from: rhs_from, ..
-            } = self.get(rhs)
-            && lhs_from == rhs_from
-            && self.pointers_have_same_metadata(*lhs_from, lhs_ty)
+            && let Value::Cast { kind: CastKind::PtrToPtr, value: lhs_value } = self.get(lhs)
+            && let Value::Cast { kind: CastKind::PtrToPtr, value: rhs_value } = self.get(rhs)
+            && let lhs_from = self.ty(*lhs_value)
+            && lhs_from == self.ty(*rhs_value)
+            && self.pointers_have_same_metadata(lhs_from, lhs_ty)
         {
             lhs = *lhs_value;
             rhs = *rhs_value;
@@ -1223,7 +1179,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         if let Some(value) = self.simplify_binary_inner(op, lhs_ty, lhs, rhs) {
             return Some(value);
         }
-        let ty = op.ty(self.tcx, self.ty(lhs), self.ty(rhs));
+        let ty = op.ty(self.tcx, lhs_ty, self.ty(rhs));
         let value = Value::BinaryOp(op, lhs, rhs);
         Some(self.insert(ty, value))
     }
@@ -1361,9 +1317,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         use CastKind::*;
         use rustc_middle::ty::adjustment::PointerCoercion::*;
 
-        let mut from = initial_operand.ty(self.local_decls, self.tcx);
         let mut kind = *initial_kind;
         let mut value = self.simplify_operand(initial_operand, location)?;
+        let mut from = self.ty(value);
         if from == to {
             return Some(value);
         }
@@ -1394,14 +1350,14 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             // If a cast just casts away the metadata again, then we can get it by
             // casting the original thin pointer passed to `from_raw_parts`
             if let PtrToPtr = kind
-                && let Value::RawPtr { data_pointer_ty, pointer, .. } = self.get(value)
+                && let Value::RawPtr { pointer, .. } = self.get(value)
                 && let ty::RawPtr(to_pointee, _) = to.kind()
                 && to_pointee.is_sized(self.tcx, self.typing_env())
             {
-                from = *data_pointer_ty;
+                from = self.ty(*pointer);
                 value = *pointer;
                 was_updated_this_iteration = true;
-                if *data_pointer_ty == to {
+                if from == to {
                     return Some(*pointer);
                 }
             }
@@ -1409,7 +1365,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             // Aggregate-then-Transmute can just transmute the original field value,
             // so long as the bytes of a value from only from a single field.
             if let Transmute = kind
-                && let Value::Aggregate(_aggregate_ty, variant_idx, field_values) = self.get(value)
+                && let Value::Aggregate(variant_idx, field_values) = self.get(value)
                 && let Some((field_idx, field_ty)) =
                     self.value_is_all_in_one_field(from, *variant_idx)
             {
@@ -1422,13 +1378,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
 
             // Various cast-then-cast cases can be simplified.
-            if let Value::Cast {
-                kind: inner_kind,
-                value: inner_value,
-                from: inner_from,
-                to: inner_to,
-            } = *self.get(value)
-            {
+            if let Value::Cast { kind: inner_kind, value: inner_value } = *self.get(value) {
+                let inner_from = self.ty(inner_value);
                 let new_kind = match (inner_kind, kind) {
                     // Even if there's a narrowing cast in here that's fine, because
                     // things like `*mut [i32] -> *mut i32 -> *const i32` and
@@ -1437,9 +1388,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     // PtrToPtr-then-Transmute is fine so long as the pointer cast is identity:
                     // `*const T -> *mut T -> NonNull<T>` is fine, but we need to check for narrowing
                     // to skip things like `*const [i32] -> *const i32 -> NonNull<T>`.
-                    (PtrToPtr, Transmute)
-                        if self.pointers_have_same_metadata(inner_from, inner_to) =>
-                    {
+                    (PtrToPtr, Transmute) if self.pointers_have_same_metadata(inner_from, from) => {
                         Some(Transmute)
                     }
                     // Similarly, for Transmute-then-PtrToPtr. Note that we need to check different
@@ -1450,7 +1399,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     // If would be legal to always do this, but we don't want to hide information
                     // from the backend that it'd otherwise be able to use for optimizations.
                     (Transmute, Transmute)
-                        if !self.type_may_have_niche_of_interest_to_backend(inner_to) =>
+                        if !self.type_may_have_niche_of_interest_to_backend(from) =>
                     {
                         Some(Transmute)
                     }
@@ -1479,7 +1428,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             *initial_kind = kind;
         }
 
-        Some(self.insert(to, Value::Cast { kind, value, from, to }))
+        Some(self.insert(to, Value::Cast { kind, value }))
     }
 
     fn simplify_len(&mut self, place: &mut Place<'tcx>, location: Location) -> Option<VnIndex> {
@@ -1501,11 +1450,11 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         }
 
         // We have an unsizing cast, which assigns the length to wide pointer metadata.
-        if let Value::Cast { kind, from, to, .. } = self.get(inner)
+        if let Value::Cast { kind, value: from } = self.get(inner)
             && let CastKind::PointerCoercion(ty::adjustment::PointerCoercion::Unsize, _) = kind
-            && let Some(from) = from.builtin_deref(true)
+            && let Some(from) = self.ty(*from).builtin_deref(true)
             && let ty::Array(_, len) = from.kind()
-            && let Some(to) = to.builtin_deref(true)
+            && let Some(to) = self.ty(inner).builtin_deref(true)
             && let ty::Slice(..) = to.kind()
         {
             return Some(self.insert_constant(Const::Ty(self.tcx.types.usize, *len)));
@@ -1721,7 +1670,7 @@ impl<'tcx> VnState<'_, 'tcx> {
                 return Some(place);
             } else if let Value::Projection(pointer, proj) = *self.get(index)
                 && (allow_complex_projection || proj.is_stable_offset())
-                && let Some(proj) = self.try_as_place_elem(proj, loc)
+                && let Some(proj) = self.try_as_place_elem(self.ty(index), proj, loc)
             {
                 projection.push(proj);
                 index = pointer;
diff --git a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir
index 3b58f1d61f4..8c5fbda6392 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir
@@ -109,7 +109,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb4: {
-        StorageLive(_15);
         _14 = &mut _13;
         _15 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _14) -> [return: bb5, unwind: bb11];
     }
@@ -120,7 +119,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb6: {
-        StorageDead(_15);
         StorageDead(_13);
         drop(_2) -> [return: bb7, unwind continue];
     }
@@ -135,14 +133,13 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         StorageLive(_19);
         _19 = &_2;
         StorageLive(_20);
-        _20 = (copy _17, copy _18);
+        _20 = copy ((_15 as Some).0: (usize, &T));
         _21 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _19, move _20) -> [return: bb9, unwind: bb11];
     }
 
     bb9: {
         StorageDead(_20);
         StorageDead(_19);
-        StorageDead(_15);
         goto -> bb4;
     }
 
-- 
cgit 1.4.1-3-g733a5


From 136d24fd7f2cd8685d0f92e672f7d43aac62fedf Mon Sep 17 00:00:00 2001
From: Benoît du Garreau <benoit@dugarreau.fr>
Date: Sun, 22 Jun 2025 20:50:42 +0200
Subject: core: Add `BorrowedCursor::with_unfilled_buf`

Implementation of https://github.com/rust-lang/libs-team/issues/367.

This mainly adds `BorrowedCursor::with_unfilled_buf`, with enables using
the unfilled part of a cursor as a `BorrowedBuf`.

Note that unlike the ACP, `BorrowedCursor::unfilled_buf` was moved to a
`From` conversion. This is more consistent with other ways of creating a
`BorrowedBuf` and hides a bit this conversion that requires unsafe code
to be used correctly.
---
 library/core/src/io/borrowed_buf.rs        | 51 ++++++++++++++++++++++++++++++
 library/coretests/tests/io/borrowed_buf.rs | 36 +++++++++++++++++++++
 2 files changed, 87 insertions(+)

diff --git a/library/core/src/io/borrowed_buf.rs b/library/core/src/io/borrowed_buf.rs
index 6bd9c18e00b..b1aa7606b3b 100644
--- a/library/core/src/io/borrowed_buf.rs
+++ b/library/core/src/io/borrowed_buf.rs
@@ -69,6 +69,23 @@ impl<'data> From<&'data mut [MaybeUninit<u8>]> for BorrowedBuf<'data> {
     }
 }
 
+/// Creates a new `BorrowedBuf` from a cursor.
+///
+/// Use `BorrowedCursor::with_unfilled_buf` instead for a safer alternative.
+impl<'data> From<BorrowedCursor<'data>> for BorrowedBuf<'data> {
+    #[inline]
+    fn from(mut buf: BorrowedCursor<'data>) -> BorrowedBuf<'data> {
+        let init = buf.init_mut().len();
+        BorrowedBuf {
+            // SAFETY: no initialized byte is ever uninitialized as per
+            // `BorrowedBuf`'s invariant
+            buf: unsafe { buf.buf.buf.get_unchecked_mut(buf.buf.filled..) },
+            filled: 0,
+            init,
+        }
+    }
+}
+
 impl<'data> BorrowedBuf<'data> {
     /// Returns the total capacity of the buffer.
     #[inline]
@@ -353,4 +370,38 @@ impl<'a> BorrowedCursor<'a> {
         }
         self.buf.filled += buf.len();
     }
+
+    /// Runs the given closure with a `BorrowedBuf` containing the unfilled part
+    /// of the cursor.
+    ///
+    /// This enables inspecting what was written to the cursor.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the `BorrowedBuf` given to the closure is replaced by another
+    /// one.
+    pub fn with_unfilled_buf<T>(&mut self, f: impl FnOnce(&mut BorrowedBuf<'_>) -> T) -> T {
+        let mut buf = BorrowedBuf::from(self.reborrow());
+        let prev_ptr = buf.buf as *const _;
+        let res = f(&mut buf);
+
+        // Check that the caller didn't replace the `BorrowedBuf`.
+        // This is necessary for the safety of the code below: if the check wasn't
+        // there, one could mark some bytes as initialized even though there aren't.
+        assert!(core::ptr::addr_eq(prev_ptr, buf.buf));
+
+        let filled = buf.filled;
+        let init = buf.init;
+
+        // Update `init` and `filled` fields with what was written to the buffer.
+        // `self.buf.filled` was the starting length of the `BorrowedBuf`.
+        //
+        // SAFETY: These amounts of bytes were initialized/filled in the `BorrowedBuf`,
+        // and therefore they are initialized/filled in the cursor too, because the
+        // buffer wasn't replaced.
+        self.buf.init = self.buf.filled + init;
+        self.buf.filled += filled;
+
+        res
+    }
 }
diff --git a/library/coretests/tests/io/borrowed_buf.rs b/library/coretests/tests/io/borrowed_buf.rs
index fbd3864dcac..73dbfaf5ee9 100644
--- a/library/coretests/tests/io/borrowed_buf.rs
+++ b/library/coretests/tests/io/borrowed_buf.rs
@@ -165,3 +165,39 @@ fn cursor_set_init() {
     assert_eq!(rbuf.unfilled().uninit_mut().len(), 4);
     assert_eq!(unsafe { rbuf.unfilled().as_mut().len() }, 12);
 }
+
+#[test]
+fn cursor_with_unfilled_buf() {
+    let buf: &mut [_] = &mut [MaybeUninit::uninit(); 16];
+    let mut rbuf = BorrowedBuf::from(buf);
+    let mut cursor = rbuf.unfilled();
+
+    cursor.with_unfilled_buf(|buf| {
+        buf.unfilled().append(&[1, 2, 3]);
+        assert_eq!(buf.filled(), &[1, 2, 3]);
+    });
+
+    assert_eq!(cursor.init_mut().len(), 0);
+    assert_eq!(cursor.written(), 3);
+
+    cursor.with_unfilled_buf(|buf| {
+        assert_eq!(buf.capacity(), 13);
+        assert_eq!(buf.init_len(), 0);
+
+        buf.unfilled().ensure_init();
+        buf.unfilled().advance(4);
+    });
+
+    assert_eq!(cursor.init_mut().len(), 9);
+    assert_eq!(cursor.written(), 7);
+
+    cursor.with_unfilled_buf(|buf| {
+        assert_eq!(buf.capacity(), 9);
+        assert_eq!(buf.init_len(), 9);
+    });
+
+    assert_eq!(cursor.init_mut().len(), 9);
+    assert_eq!(cursor.written(), 7);
+
+    assert_eq!(rbuf.filled(), &[1, 2, 3, 0, 0, 0, 0]);
+}
-- 
cgit 1.4.1-3-g733a5


From cbc3cf716e16c20ba8fb652f8a41dc1d62f03f66 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Tue, 1 Jul 2025 12:06:39 +0000
Subject: Avoid computing layouts inside coroutines.

---
 compiler/rustc_mir_transform/src/gvn.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index e081d1fde93..461aa7e5284 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -216,6 +216,7 @@ struct VnState<'body, 'tcx> {
     tcx: TyCtxt<'tcx>,
     ecx: InterpCx<'tcx, DummyMachine>,
     local_decls: &'body LocalDecls<'tcx>,
+    is_coroutine: bool,
     /// Value stored in each local.
     locals: IndexVec<Local, Option<VnIndex>>,
     /// Locals that are assigned that value.
@@ -253,6 +254,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             tcx,
             ecx: InterpCx::new(tcx, DUMMY_SP, typing_env, DummyMachine),
             local_decls,
+            is_coroutine: body.coroutine.is_some(),
             locals: IndexVec::from_elem(None, local_decls),
             rev_locals: IndexVec::with_capacity(num_values),
             values: FxIndexSet::with_capacity_and_hasher(num_values, Default::default()),
@@ -380,7 +382,12 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     fn eval_to_const(&mut self, value: VnIndex) -> Option<OpTy<'tcx>> {
         use Value::*;
         let ty = self.ty(value);
-        let ty = self.ecx.layout_of(ty).ok()?;
+        // Avoid computing layouts inside a coroutine, as that can cause cycles.
+        let ty = if !self.is_coroutine || ty.is_scalar() {
+            self.ecx.layout_of(ty).ok()?
+        } else {
+            return None;
+        };
         let op = match *self.get(value) {
             _ if ty.is_zst() => ImmTy::uninit(ty).into(),
 
-- 
cgit 1.4.1-3-g733a5


From c42b1773feb5808ae870f8b578a4a8601c7bd322 Mon Sep 17 00:00:00 2001
From: Nurzhan Sakén <nurzhan.sakenov@gmail.com>
Date: Tue, 1 Jul 2025 17:02:32 +0400
Subject: Add `uX::strict_sub_signed`

---
 library/core/src/num/uint_macros.rs | 45 +++++++++++++++++++++++++++++++++----
 1 file changed, 41 insertions(+), 4 deletions(-)

diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 079032f2f96..cf34ab8a3cd 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -556,7 +556,7 @@ macro_rules! uint_impl {
         pub const fn strict_add(self, rhs: Self) -> Self {
             let (a, b) = self.overflowing_add(rhs);
             if b { overflow_panic::add() } else { a }
-         }
+        }
 
         /// Unchecked integer addition. Computes `self + rhs`, assuming overflow
         /// cannot occur.
@@ -653,7 +653,7 @@ macro_rules! uint_impl {
         pub const fn strict_add_signed(self, rhs: $SignedT) -> Self {
             let (a, b) = self.overflowing_add_signed(rhs);
             if b { overflow_panic::add() } else { a }
-         }
+        }
 
         /// Checked integer subtraction. Computes `self - rhs`, returning
         /// `None` if overflow occurred.
@@ -713,7 +713,7 @@ macro_rules! uint_impl {
         pub const fn strict_sub(self, rhs: Self) -> Self {
             let (a, b) = self.overflowing_sub(rhs);
             if b { overflow_panic::sub() } else { a }
-         }
+        }
 
         /// Unchecked integer subtraction. Computes `self - rhs`, assuming overflow
         /// cannot occur.
@@ -805,6 +805,43 @@ macro_rules! uint_impl {
             }
         }
 
+        /// Strict subtraction with a signed integer. Computes `self - rhs`,
+        /// panicking if overflow occurred.
+        ///
+        /// # Panics
+        ///
+        /// ## Overflow behavior
+        ///
+        /// This function will always panic on overflow, regardless of whether overflow checks are enabled.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// #![feature(strict_overflow_ops)]
+        #[doc = concat!("assert_eq!(3", stringify!($SelfT), ".strict_sub_signed(2), 1);")]
+        /// ```
+        ///
+        /// The following panic because of overflow:
+        ///
+        /// ```should_panic
+        /// #![feature(strict_overflow_ops)]
+        #[doc = concat!("let _ = 1", stringify!($SelfT), ".strict_sub_signed(2);")]
+        /// ```
+        ///
+        /// ```should_panic
+        /// #![feature(strict_overflow_ops)]
+        #[doc = concat!("let _ = (", stringify!($SelfT), "::MIN + 2).strict_sub_signed(3);")]
+        /// ```
+        #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        #[track_caller]
+        pub const fn strict_sub_signed(self, rhs: $SignedT) -> Self {
+            let (a, b) = self.overflowing_sub_signed(rhs);
+            if b { overflow_panic::sub() } else { a }
+        }
+
         #[doc = concat!(
             "Checked integer subtraction. Computes `self - rhs` and checks if the result fits into an [`",
             stringify!($SignedT), "`], returning `None` if overflow occurred."
@@ -913,7 +950,7 @@ macro_rules! uint_impl {
         pub const fn strict_mul(self, rhs: Self) -> Self {
             let (a, b) = self.overflowing_mul(rhs);
             if b { overflow_panic::mul() } else { a }
-         }
+        }
 
         /// Unchecked integer multiplication. Computes `self * rhs`, assuming overflow
         /// cannot occur.
-- 
cgit 1.4.1-3-g733a5


From 9eb85122558fd7c3a8909939f9cbe4d0f15d73f3 Mon Sep 17 00:00:00 2001
From: yanglsh <yanglsh@shanghaitech.edu.cn>
Date: Sun, 29 Jun 2025 01:13:17 +0800
Subject: fix: `std-instead-of-core` FP when not all items come from the new
 crate

---
 clippy_lints/src/std_instead_of_core.rs       | 109 ++++++++++++++++++--------
 tests/ui/std_instead_of_core.fixed            |   7 --
 tests/ui/std_instead_of_core.rs               |   7 --
 tests/ui/std_instead_of_core.stderr           |  30 +++----
 tests/ui/std_instead_of_core_unfixable.rs     |  18 +++++
 tests/ui/std_instead_of_core_unfixable.stderr |  30 +++++++
 6 files changed, 139 insertions(+), 62 deletions(-)
 create mode 100644 tests/ui/std_instead_of_core_unfixable.rs
 create mode 100644 tests/ui/std_instead_of_core_unfixable.stderr

diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index 442b3250d86..cf70e883bd0 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -1,10 +1,10 @@
 use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::msrvs::Msrv;
 use rustc_attr_data_structures::{StabilityLevel, StableSince};
 use rustc_errors::Applicability;
-use rustc_hir::def::Res;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Block, Body, HirId, Path, PathSegment};
 use rustc_lint::{LateContext, LateLintPass, Lint, LintContext};
@@ -88,49 +88,52 @@ declare_clippy_lint! {
 }
 
 pub struct StdReexports {
-    lint_point: (Span, Option<LintPoint>),
+    lint_points: Option<(Span, Vec<LintPoint>)>,
     msrv: Msrv,
 }
 
 impl StdReexports {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            lint_point: Default::default(),
+            lint_points: Option::default(),
             msrv: conf.msrv,
         }
     }
 
-    fn lint_if_finish(&mut self, cx: &LateContext<'_>, (span, item): (Span, Option<LintPoint>)) {
-        if span.source_equal(self.lint_point.0) {
-            return;
+    fn lint_if_finish(&mut self, cx: &LateContext<'_>, krate: Span, lint_point: LintPoint) {
+        match &mut self.lint_points {
+            Some((prev_krate, prev_lints)) if prev_krate.overlaps(krate) => {
+                prev_lints.push(lint_point);
+            },
+            _ => emit_lints(cx, self.lint_points.replace((krate, vec![lint_point]))),
         }
-
-        if !self.lint_point.0.is_dummy() {
-            emit_lints(cx, &self.lint_point);
-        }
-
-        self.lint_point = (span, item);
     }
 }
 
 impl_lint_pass!(StdReexports => [STD_INSTEAD_OF_CORE, STD_INSTEAD_OF_ALLOC, ALLOC_INSTEAD_OF_CORE]);
 
-type LintPoint = (&'static Lint, &'static str, &'static str);
+#[derive(Debug)]
+enum LintPoint {
+    Available(Span, &'static Lint, &'static str, &'static str),
+    Conflict,
+}
 
 impl<'tcx> LateLintPass<'tcx> for StdReexports {
     fn check_path(&mut self, cx: &LateContext<'tcx>, path: &Path<'tcx>, _: HirId) {
-        if let Res::Def(_, def_id) = path.res
+        if let Res::Def(def_kind, def_id) = path.res
             && let Some(first_segment) = get_first_segment(path)
             && is_stable(cx, def_id, self.msrv)
             && !path.span.in_external_macro(cx.sess().source_map())
             && !is_from_proc_macro(cx, &first_segment.ident)
+            && !matches!(def_kind, DefKind::Macro(_))
+            && let Some(last_segment) = path.segments.last()
         {
             let (lint, used_mod, replace_with) = match first_segment.ident.name {
                 sym::std => match cx.tcx.crate_name(def_id.krate) {
                     sym::core => (STD_INSTEAD_OF_CORE, "std", "core"),
                     sym::alloc => (STD_INSTEAD_OF_ALLOC, "std", "alloc"),
                     _ => {
-                        self.lint_if_finish(cx, (first_segment.ident.span, None));
+                        self.lint_if_finish(cx, first_segment.ident.span, LintPoint::Conflict);
                         return;
                     },
                 },
@@ -138,44 +141,84 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
                     if cx.tcx.crate_name(def_id.krate) == sym::core {
                         (ALLOC_INSTEAD_OF_CORE, "alloc", "core")
                     } else {
-                        self.lint_if_finish(cx, (first_segment.ident.span, None));
+                        self.lint_if_finish(cx, first_segment.ident.span, LintPoint::Conflict);
                         return;
                     }
                 },
-                _ => return,
+                _ => {
+                    self.lint_if_finish(cx, first_segment.ident.span, LintPoint::Conflict);
+                    return;
+                },
             };
 
-            self.lint_if_finish(cx, (first_segment.ident.span, Some((lint, used_mod, replace_with))));
+            self.lint_if_finish(
+                cx,
+                first_segment.ident.span,
+                LintPoint::Available(last_segment.ident.span, lint, used_mod, replace_with),
+            );
         }
     }
 
     fn check_block_post(&mut self, cx: &LateContext<'tcx>, _: &Block<'tcx>) {
-        self.lint_if_finish(cx, Default::default());
+        emit_lints(cx, self.lint_points.take());
     }
 
     fn check_body_post(&mut self, cx: &LateContext<'tcx>, _: &Body<'tcx>) {
-        self.lint_if_finish(cx, Default::default());
+        emit_lints(cx, self.lint_points.take());
     }
 
     fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
-        self.lint_if_finish(cx, Default::default());
+        emit_lints(cx, self.lint_points.take());
     }
 }
 
-fn emit_lints(cx: &LateContext<'_>, (span, item): &(Span, Option<LintPoint>)) {
-    let Some((lint, used_mod, replace_with)) = item else {
+fn emit_lints(cx: &LateContext<'_>, lint_points: Option<(Span, Vec<LintPoint>)>) {
+    let Some((krate_span, lint_points)) = lint_points else {
         return;
     };
 
-    span_lint_and_sugg(
-        cx,
-        lint,
-        *span,
-        format!("used import from `{used_mod}` instead of `{replace_with}`"),
-        format!("consider importing the item from `{replace_with}`"),
-        (*replace_with).to_string(),
-        Applicability::MachineApplicable,
-    );
+    let mut lint: Option<(&'static Lint, &'static str, &'static str)> = None;
+    let mut has_conflict = false;
+    for lint_point in &lint_points {
+        match lint_point {
+            LintPoint::Available(_, l, used_mod, replace_with)
+                if lint.is_none_or(|(prev_l, ..)| l.name == prev_l.name) =>
+            {
+                lint = Some((l, used_mod, replace_with));
+            },
+            _ => {
+                has_conflict = true;
+                break;
+            },
+        }
+    }
+
+    if !has_conflict && let Some((lint, used_mod, replace_with)) = lint {
+        span_lint_and_sugg(
+            cx,
+            lint,
+            krate_span,
+            format!("used import from `{used_mod}` instead of `{replace_with}`"),
+            format!("consider importing the item from `{replace_with}`"),
+            (*replace_with).to_string(),
+            Applicability::MachineApplicable,
+        );
+        return;
+    }
+
+    for lint_point in lint_points {
+        let LintPoint::Available(span, lint, used_mod, replace_with) = lint_point else {
+            continue;
+        };
+        span_lint_and_help(
+            cx,
+            lint,
+            span,
+            format!("used import from `{used_mod}` instead of `{replace_with}`"),
+            None,
+            format!("consider importing the item from `{replace_with}`"),
+        );
+    }
 }
 
 /// Returns the first named segment of a [`Path`].
diff --git a/tests/ui/std_instead_of_core.fixed b/tests/ui/std_instead_of_core.fixed
index 1820ade422f..603ab0accb0 100644
--- a/tests/ui/std_instead_of_core.fixed
+++ b/tests/ui/std_instead_of_core.fixed
@@ -8,7 +8,6 @@ extern crate alloc;
 #[macro_use]
 extern crate proc_macro_derive;
 
-#[warn(clippy::std_instead_of_core)]
 fn std_instead_of_core() {
     // Regular import
     use core::hash::Hasher;
@@ -90,9 +89,3 @@ fn msrv_1_76(_: std::net::IpAddr) {}
 #[clippy::msrv = "1.77"]
 fn msrv_1_77(_: core::net::IpAddr) {}
 //~^ std_instead_of_core
-
-#[warn(clippy::std_instead_of_core)]
-#[rustfmt::skip]
-fn issue14982() {
-    use std::{collections::HashMap, hash::Hash};
-}
diff --git a/tests/ui/std_instead_of_core.rs b/tests/ui/std_instead_of_core.rs
index 32c49330981..b6d4abad9f8 100644
--- a/tests/ui/std_instead_of_core.rs
+++ b/tests/ui/std_instead_of_core.rs
@@ -8,7 +8,6 @@ extern crate alloc;
 #[macro_use]
 extern crate proc_macro_derive;
 
-#[warn(clippy::std_instead_of_core)]
 fn std_instead_of_core() {
     // Regular import
     use std::hash::Hasher;
@@ -90,9 +89,3 @@ fn msrv_1_76(_: std::net::IpAddr) {}
 #[clippy::msrv = "1.77"]
 fn msrv_1_77(_: std::net::IpAddr) {}
 //~^ std_instead_of_core
-
-#[warn(clippy::std_instead_of_core)]
-#[rustfmt::skip]
-fn issue14982() {
-    use std::{collections::HashMap, hash::Hash};
-}
diff --git a/tests/ui/std_instead_of_core.stderr b/tests/ui/std_instead_of_core.stderr
index 45d60d235ce..a5f8fbbe37c 100644
--- a/tests/ui/std_instead_of_core.stderr
+++ b/tests/ui/std_instead_of_core.stderr
@@ -1,5 +1,5 @@
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:14:9
+  --> tests/ui/std_instead_of_core.rs:13:9
    |
 LL |     use std::hash::Hasher;
    |         ^^^ help: consider importing the item from `core`: `core`
@@ -8,61 +8,61 @@ LL |     use std::hash::Hasher;
    = help: to override `-D warnings` add `#[allow(clippy::std_instead_of_core)]`
 
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:17:11
+  --> tests/ui/std_instead_of_core.rs:16:11
    |
 LL |     use ::std::hash::Hash;
    |           ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:23:9
+  --> tests/ui/std_instead_of_core.rs:22:9
    |
 LL |     use std::fmt::{Debug, Result};
    |         ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:28:9
+  --> tests/ui/std_instead_of_core.rs:27:9
    |
 LL |     use std::{
    |         ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:35:15
+  --> tests/ui/std_instead_of_core.rs:34:15
    |
 LL |     let ptr = std::ptr::null::<u32>();
    |               ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:37:21
+  --> tests/ui/std_instead_of_core.rs:36:21
    |
 LL |     let ptr_mut = ::std::ptr::null_mut::<usize>();
    |                     ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:41:16
+  --> tests/ui/std_instead_of_core.rs:40:16
    |
 LL |     let cell = std::cell::Cell::new(8u32);
    |                ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:43:27
+  --> tests/ui/std_instead_of_core.rs:42:27
    |
 LL |     let cell_absolute = ::std::cell::Cell::new(8u32);
    |                           ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:48:9
+  --> tests/ui/std_instead_of_core.rs:47:9
    |
 LL |     use std::error::Error;
    |         ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:52:9
+  --> tests/ui/std_instead_of_core.rs:51:9
    |
 LL |     use std::iter::Iterator;
    |         ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `alloc`
-  --> tests/ui/std_instead_of_core.rs:59:9
+  --> tests/ui/std_instead_of_core.rs:58:9
    |
 LL |     use std::vec;
    |         ^^^ help: consider importing the item from `alloc`: `alloc`
@@ -71,13 +71,13 @@ LL |     use std::vec;
    = help: to override `-D warnings` add `#[allow(clippy::std_instead_of_alloc)]`
 
 error: used import from `std` instead of `alloc`
-  --> tests/ui/std_instead_of_core.rs:61:9
+  --> tests/ui/std_instead_of_core.rs:60:9
    |
 LL |     use std::vec::Vec;
    |         ^^^ help: consider importing the item from `alloc`: `alloc`
 
 error: used import from `alloc` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:67:9
+  --> tests/ui/std_instead_of_core.rs:66:9
    |
 LL |     use alloc::slice::from_ref;
    |         ^^^^^ help: consider importing the item from `core`: `core`
@@ -86,13 +86,13 @@ LL |     use alloc::slice::from_ref;
    = help: to override `-D warnings` add `#[allow(clippy::alloc_instead_of_core)]`
 
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:82:9
+  --> tests/ui/std_instead_of_core.rs:81:9
    |
 LL |         std::intrinsics::copy(a, b, 1);
    |         ^^^ help: consider importing the item from `core`: `core`
 
 error: used import from `std` instead of `core`
-  --> tests/ui/std_instead_of_core.rs:91:17
+  --> tests/ui/std_instead_of_core.rs:90:17
    |
 LL | fn msrv_1_77(_: std::net::IpAddr) {}
    |                 ^^^ help: consider importing the item from `core`: `core`
diff --git a/tests/ui/std_instead_of_core_unfixable.rs b/tests/ui/std_instead_of_core_unfixable.rs
new file mode 100644
index 00000000000..957f472a454
--- /dev/null
+++ b/tests/ui/std_instead_of_core_unfixable.rs
@@ -0,0 +1,18 @@
+//@no-rustfix
+
+#![warn(clippy::std_instead_of_core)]
+#![warn(clippy::std_instead_of_alloc)]
+#![allow(unused_imports)]
+
+#[rustfmt::skip]
+fn issue14982() {
+    use std::{collections::HashMap, hash::Hash};
+    //~^ std_instead_of_core
+}
+
+#[rustfmt::skip]
+fn issue15143() {
+    use std::{error::Error, vec::Vec, fs::File};
+    //~^ std_instead_of_core
+    //~| std_instead_of_alloc
+}
diff --git a/tests/ui/std_instead_of_core_unfixable.stderr b/tests/ui/std_instead_of_core_unfixable.stderr
new file mode 100644
index 00000000000..0cdec56c992
--- /dev/null
+++ b/tests/ui/std_instead_of_core_unfixable.stderr
@@ -0,0 +1,30 @@
+error: used import from `std` instead of `core`
+  --> tests/ui/std_instead_of_core_unfixable.rs:9:43
+   |
+LL |     use std::{collections::HashMap, hash::Hash};
+   |                                           ^^^^
+   |
+   = help: consider importing the item from `core`
+   = note: `-D clippy::std-instead-of-core` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::std_instead_of_core)]`
+
+error: used import from `std` instead of `core`
+  --> tests/ui/std_instead_of_core_unfixable.rs:15:22
+   |
+LL |     use std::{error::Error, vec::Vec, fs::File};
+   |                      ^^^^^
+   |
+   = help: consider importing the item from `core`
+
+error: used import from `std` instead of `alloc`
+  --> tests/ui/std_instead_of_core_unfixable.rs:15:34
+   |
+LL |     use std::{error::Error, vec::Vec, fs::File};
+   |                                  ^^^
+   |
+   = help: consider importing the item from `alloc`
+   = note: `-D clippy::std-instead-of-alloc` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::std_instead_of_alloc)]`
+
+error: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 4793fd1c46f3e091b2c81e20a2c1d59f049760a3 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 1 Jul 2025 15:15:44 +0200
Subject: Update clippy source code to make use of `TyCtxt::def_descr` instead
 of `ItemKind::descr`

---
 clippy_lints/src/undocumented_unsafe_blocks.rs                 | 10 ++++++++--
 .../undocumented_unsafe_blocks.default.stderr                  |  2 +-
 .../undocumented_unsafe_blocks.disabled.stderr                 |  2 +-
 tests/ui/unnecessary_safety_comment.stderr                     |  4 ++--
 4 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 92427473a8e..6cc4b589a72 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -256,7 +256,10 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
                             cx,
                             UNNECESSARY_SAFETY_COMMENT,
                             span,
-                            format!("{} has unnecessary safety comment", item.kind.descr()),
+                            format!(
+                                "{} has unnecessary safety comment",
+                                cx.tcx.def_descr(item.owner_id.to_def_id()),
+                            ),
                             |diag| {
                                 diag.span_help(help_span, "consider removing the safety comment");
                             },
@@ -274,7 +277,10 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
                         cx,
                         UNNECESSARY_SAFETY_COMMENT,
                         span,
-                        format!("{} has unnecessary safety comment", item.kind.descr()),
+                        format!(
+                            "{} has unnecessary safety comment",
+                            cx.tcx.def_descr(item.owner_id.to_def_id()),
+                        ),
                         |diag| {
                             diag.span_help(help_span, "consider removing the safety comment");
                         },
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr
index 8a2f201009a..bfc14be5421 100644
--- a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr
@@ -240,7 +240,7 @@ LL |     unsafe impl TrailingComment for () {} // SAFETY:
    |
    = help: consider adding a safety comment on the preceding line
 
-error: constant item has unnecessary safety comment
+error: constant has unnecessary safety comment
   --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:508:5
    |
 LL |     const BIG_NUMBER: i32 = 1000000;
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
index e9c5e5f9f11..20cdff5fcd1 100644
--- a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
@@ -240,7 +240,7 @@ LL |     unsafe impl TrailingComment for () {} // SAFETY:
    |
    = help: consider adding a safety comment on the preceding line
 
-error: constant item has unnecessary safety comment
+error: constant has unnecessary safety comment
   --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:508:5
    |
 LL |     const BIG_NUMBER: i32 = 1000000;
diff --git a/tests/ui/unnecessary_safety_comment.stderr b/tests/ui/unnecessary_safety_comment.stderr
index b56e8b35493..732e6767c17 100644
--- a/tests/ui/unnecessary_safety_comment.stderr
+++ b/tests/ui/unnecessary_safety_comment.stderr
@@ -1,4 +1,4 @@
-error: constant item has unnecessary safety comment
+error: constant has unnecessary safety comment
   --> tests/ui/unnecessary_safety_comment.rs:6:5
    |
 LL |     const CONST: u32 = 0;
@@ -12,7 +12,7 @@ LL |     // SAFETY:
    = note: `-D clippy::unnecessary-safety-comment` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_safety_comment)]`
 
-error: static item has unnecessary safety comment
+error: static has unnecessary safety comment
   --> tests/ui/unnecessary_safety_comment.rs:10:5
    |
 LL |     static STATIC: u32 = 0;
-- 
cgit 1.4.1-3-g733a5


From e9191ec57ee5bdd0961a22fd9852f361a5c97ea0 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Tue, 1 Jul 2025 21:42:20 +0500
Subject: moved tests

---
 tests/ui/auto-traits/auto-traits-type-parameter    |  36 ++++
 tests/ui/consts/const-eval-array-len-in-impl.rs    |  13 ++
 .../ui/consts/const-eval-array-len-in-impl.stderr  |  11 ++
 .../let-binding-tuple-destructuring.rs             |   7 +
 .../lifetimes/any-lifetime-escape-higher-rank.rs   |  31 ++++
 tests/ui/limits/type-length-limit-enforcement.rs   |  34 ++++
 .../ui/limits/type-length-limit-enforcement.stderr |  15 ++
 .../macro-fragment-ident-underscore-error.rs       |   9 +
 .../macro-fragment-ident-underscore-error.stderr   |  17 ++
 .../struct-type-and-function-name-coexistence.rs   |   7 +
 .../integer-literal-method-call-underscore.rs      |  11 ++
 tests/ui/ptr_ops/ptr-write-bool-representation.rs  |  11 ++
 tests/ui/ptr_ops/raw-pointer-type-basic.rs         |   9 +
 tests/ui/try-operator-hygiene.rs                   |  26 ---
 tests/ui/try-operator.rs                           | 192 ---------------------
 .../ui/try-trait/try-operator-expansion-hygiene.rs |  26 +++
 .../ui/try-trait/try-operator-various-contexts.rs  | 192 +++++++++++++++++++++
 tests/ui/tydesc-name.rs                            |  14 --
 tests/ui/type-id-higher-rank-2.rs                  |  31 ----
 .../type-inference-none-in-generic-ref.rs          |   7 +
 .../type-inference-none-in-generic-ref.stderr      |  14 ++
 .../type-inference-unconstrained-none.rs           |   5 +
 .../type-inference-unconstrained-none.stderr       |  14 ++
 tests/ui/type-namespace.rs                         |   7 -
 tests/ui/type-param-constraints.rs                 |  36 ----
 tests/ui/type-ptr.rs                               |   9 -
 tests/ui/type-use-i1-versus-i8.rs                  |  11 --
 tests/ui/type/type-name-basic.rs                   |  14 ++
 tests/ui/type/typeid-consistency-comprehensive.rs  |  97 +++++++++++
 tests/ui/type_length_limit.rs                      |  34 ----
 tests/ui/type_length_limit.stderr                  |  15 --
 tests/ui/typeid-intrinsic.rs                       |  97 -----------
 tests/ui/typestate-multi-decl.rs                   |   7 -
 tests/ui/unconstrained-none.rs                     |   5 -
 tests/ui/unconstrained-none.stderr                 |  14 --
 tests/ui/unconstrained-ref.rs                      |   7 -
 tests/ui/unconstrained-ref.stderr                  |  14 --
 tests/ui/underscore-ident-matcher.rs               |   9 -
 tests/ui/underscore-ident-matcher.stderr           |  17 --
 .../basic-underscore-lifetime-elision.rs           |  38 ++++
 tests/ui/underscore-lifetimes.rs                   |  38 ----
 tests/ui/underscore-method-after-integer.rs        |  11 --
 tests/ui/unevaluated_fixed_size_array_len.rs       |  13 --
 tests/ui/unevaluated_fixed_size_array_len.stderr   |  11 --
 44 files changed, 618 insertions(+), 618 deletions(-)
 create mode 100644 tests/ui/auto-traits/auto-traits-type-parameter
 create mode 100644 tests/ui/consts/const-eval-array-len-in-impl.rs
 create mode 100644 tests/ui/consts/const-eval-array-len-in-impl.stderr
 create mode 100644 tests/ui/destructuring-assignment/let-binding-tuple-destructuring.rs
 create mode 100644 tests/ui/lifetimes/any-lifetime-escape-higher-rank.rs
 create mode 100644 tests/ui/limits/type-length-limit-enforcement.rs
 create mode 100644 tests/ui/limits/type-length-limit-enforcement.stderr
 create mode 100644 tests/ui/macros/macro-fragment-ident-underscore-error.rs
 create mode 100644 tests/ui/macros/macro-fragment-ident-underscore-error.stderr
 create mode 100644 tests/ui/namespace/struct-type-and-function-name-coexistence.rs
 create mode 100644 tests/ui/parser/integer-literal-method-call-underscore.rs
 create mode 100644 tests/ui/ptr_ops/ptr-write-bool-representation.rs
 create mode 100644 tests/ui/ptr_ops/raw-pointer-type-basic.rs
 delete mode 100644 tests/ui/try-operator-hygiene.rs
 delete mode 100644 tests/ui/try-operator.rs
 create mode 100644 tests/ui/try-trait/try-operator-expansion-hygiene.rs
 create mode 100644 tests/ui/try-trait/try-operator-various-contexts.rs
 delete mode 100644 tests/ui/tydesc-name.rs
 delete mode 100644 tests/ui/type-id-higher-rank-2.rs
 create mode 100644 tests/ui/type-inference/type-inference-none-in-generic-ref.rs
 create mode 100644 tests/ui/type-inference/type-inference-none-in-generic-ref.stderr
 create mode 100644 tests/ui/type-inference/type-inference-unconstrained-none.rs
 create mode 100644 tests/ui/type-inference/type-inference-unconstrained-none.stderr
 delete mode 100644 tests/ui/type-namespace.rs
 delete mode 100644 tests/ui/type-param-constraints.rs
 delete mode 100644 tests/ui/type-ptr.rs
 delete mode 100644 tests/ui/type-use-i1-versus-i8.rs
 create mode 100644 tests/ui/type/type-name-basic.rs
 create mode 100644 tests/ui/type/typeid-consistency-comprehensive.rs
 delete mode 100644 tests/ui/type_length_limit.rs
 delete mode 100644 tests/ui/type_length_limit.stderr
 delete mode 100644 tests/ui/typeid-intrinsic.rs
 delete mode 100644 tests/ui/typestate-multi-decl.rs
 delete mode 100644 tests/ui/unconstrained-none.rs
 delete mode 100644 tests/ui/unconstrained-none.stderr
 delete mode 100644 tests/ui/unconstrained-ref.rs
 delete mode 100644 tests/ui/unconstrained-ref.stderr
 delete mode 100644 tests/ui/underscore-ident-matcher.rs
 delete mode 100644 tests/ui/underscore-ident-matcher.stderr
 create mode 100644 tests/ui/underscore-lifetime/basic-underscore-lifetime-elision.rs
 delete mode 100644 tests/ui/underscore-lifetimes.rs
 delete mode 100644 tests/ui/underscore-method-after-integer.rs
 delete mode 100644 tests/ui/unevaluated_fixed_size_array_len.rs
 delete mode 100644 tests/ui/unevaluated_fixed_size_array_len.stderr

diff --git a/tests/ui/auto-traits/auto-traits-type-parameter b/tests/ui/auto-traits/auto-traits-type-parameter
new file mode 100644
index 00000000000..83d81c0d833
--- /dev/null
+++ b/tests/ui/auto-traits/auto-traits-type-parameter
@@ -0,0 +1,36 @@
+//@ run-pass
+
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]
+
+fn p_foo<T>(_pinned: T) { }
+fn s_foo<T>(_shared: T) { }
+fn u_foo<T:Send>(_unique: T) { }
+
+struct r {
+  i: isize,
+}
+
+impl Drop for r {
+    fn drop(&mut self) {}
+}
+
+fn r(i:isize) -> r {
+    r {
+        i: i
+    }
+}
+
+pub fn main() {
+    p_foo(r(10));
+
+    p_foo::<Box<_>>(Box::new(r(10)));
+    p_foo::<Box<_>>(Box::new(10));
+    p_foo(10);
+
+    s_foo::<Box<_>>(Box::new(10));
+    s_foo(10);
+
+    u_foo::<Box<_>>(Box::new(10));
+    u_foo(10);
+}
diff --git a/tests/ui/consts/const-eval-array-len-in-impl.rs b/tests/ui/consts/const-eval-array-len-in-impl.rs
new file mode 100644
index 00000000000..6c545913dd9
--- /dev/null
+++ b/tests/ui/consts/const-eval-array-len-in-impl.rs
@@ -0,0 +1,13 @@
+// https://github.com/rust-lang/rust/issues/49208
+
+trait Foo {
+    fn foo();
+}
+
+impl Foo for [(); 1] {
+    fn foo() {}
+}
+
+fn main() {
+    <[(); 0] as Foo>::foo() //~ ERROR E0277
+}
diff --git a/tests/ui/consts/const-eval-array-len-in-impl.stderr b/tests/ui/consts/const-eval-array-len-in-impl.stderr
new file mode 100644
index 00000000000..43cc377006e
--- /dev/null
+++ b/tests/ui/consts/const-eval-array-len-in-impl.stderr
@@ -0,0 +1,11 @@
+error[E0277]: the trait bound `[(); 0]: Foo` is not satisfied
+  --> $DIR/unevaluated_fixed_size_array_len.rs:12:6
+   |
+LL |     <[(); 0] as Foo>::foo()
+   |      ^^^^^^^ the trait `Foo` is not implemented for `[(); 0]`
+   |
+   = help: the trait `Foo` is implemented for `[(); 1]`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/destructuring-assignment/let-binding-tuple-destructuring.rs b/tests/ui/destructuring-assignment/let-binding-tuple-destructuring.rs
new file mode 100644
index 00000000000..3d0e79632bb
--- /dev/null
+++ b/tests/ui/destructuring-assignment/let-binding-tuple-destructuring.rs
@@ -0,0 +1,7 @@
+//@ run-pass
+
+pub fn main() {
+    let (x, y) = (10, 20);
+    let z = x + y;
+    assert_eq!(z, 30);
+}
diff --git a/tests/ui/lifetimes/any-lifetime-escape-higher-rank.rs b/tests/ui/lifetimes/any-lifetime-escape-higher-rank.rs
new file mode 100644
index 00000000000..7b0c7b53940
--- /dev/null
+++ b/tests/ui/lifetimes/any-lifetime-escape-higher-rank.rs
@@ -0,0 +1,31 @@
+//@ run-pass
+// Test that we can't ignore lifetimes by going through Any.
+
+use std::any::Any;
+
+struct Foo<'a>(&'a str);
+
+fn good(s: &String) -> Foo<'_> { Foo(s) }
+
+fn bad1(s: String) -> Option<&'static str> {
+    let a: Box<dyn Any> = Box::new(good as fn(&String) -> Foo);
+    a.downcast_ref::<fn(&String) -> Foo<'static>>().map(|f| f(&s).0)
+}
+
+trait AsStr<'a, 'b> {
+    fn get(&'a self) -> &'b str;
+}
+
+impl<'a> AsStr<'a, 'a> for String {
+   fn get(&'a self) -> &'a str { self }
+}
+
+fn bad2(s: String) -> Option<&'static str> {
+    let a: Box<dyn Any> = Box::new(Box::new(s) as Box<dyn for<'a> AsStr<'a, 'a>>);
+    a.downcast_ref::<Box<dyn for<'a> AsStr<'a, 'static>>>().map(|x| x.get())
+}
+
+fn main() {
+    assert_eq!(bad1(String::from("foo")), None);
+    assert_eq!(bad2(String::from("bar")), None);
+}
diff --git a/tests/ui/limits/type-length-limit-enforcement.rs b/tests/ui/limits/type-length-limit-enforcement.rs
new file mode 100644
index 00000000000..87f5ffd76d7
--- /dev/null
+++ b/tests/ui/limits/type-length-limit-enforcement.rs
@@ -0,0 +1,34 @@
+//@ build-fail
+//@ compile-flags: -Copt-level=0 -Zenforce-type-length-limit
+//~^^ ERROR reached the type-length limit
+
+// Test that the type length limit can be changed.
+// The exact type depends on optimizations, so disable them.
+
+#![allow(dead_code)]
+#![type_length_limit="8"]
+
+macro_rules! link {
+    ($id:ident, $t:ty) => {
+        pub type $id = ($t, $t, $t);
+    }
+}
+
+link! { A1, B1 }
+link! { B1, C1 }
+link! { C1, D1 }
+link! { D1, E1 }
+link! { E1, A }
+link! { A, B }
+link! { B, C }
+link! { C, D }
+link! { D, E }
+link! { E, F }
+link! { F, G<Option<i32>, Option<i32>> }
+
+pub struct G<T, K>(std::marker::PhantomData::<(T, K)>);
+
+fn main() {
+    drop::<Option<A>>(None);
+    //~^ ERROR reached the type-length limit
+}
diff --git a/tests/ui/limits/type-length-limit-enforcement.stderr b/tests/ui/limits/type-length-limit-enforcement.stderr
new file mode 100644
index 00000000000..198d133c08c
--- /dev/null
+++ b/tests/ui/limits/type-length-limit-enforcement.stderr
@@ -0,0 +1,15 @@
+error: reached the type-length limit while instantiating `std::mem::drop::<Option<((((..., ..., ...), ..., ...), ..., ...), ..., ...)>>`
+  --> $DIR/type_length_limit.rs:32:5
+   |
+LL |     drop::<Option<A>>(None);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider adding a `#![type_length_limit="4010"]` attribute to your crate
+   = note: the full type name has been written to '$TEST_BUILD_DIR/type_length_limit.long-type.txt'
+
+error: reached the type-length limit while instantiating `<{closure@rt::lang_start<()>::{closure#0}} as FnMut<()>>::call_mut`
+   |
+   = help: consider adding a `#![type_length_limit="10"]` attribute to your crate
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/macros/macro-fragment-ident-underscore-error.rs b/tests/ui/macros/macro-fragment-ident-underscore-error.rs
new file mode 100644
index 00000000000..77ec70d43d5
--- /dev/null
+++ b/tests/ui/macros/macro-fragment-ident-underscore-error.rs
@@ -0,0 +1,9 @@
+macro_rules! identity {
+    ($i: ident) => (
+        $i
+    )
+}
+
+fn main() {
+    let identity!(_) = 10; //~ ERROR no rules expected reserved identifier `_`
+}
diff --git a/tests/ui/macros/macro-fragment-ident-underscore-error.stderr b/tests/ui/macros/macro-fragment-ident-underscore-error.stderr
new file mode 100644
index 00000000000..0c3f980cf6c
--- /dev/null
+++ b/tests/ui/macros/macro-fragment-ident-underscore-error.stderr
@@ -0,0 +1,17 @@
+error: no rules expected reserved identifier `_`
+  --> $DIR/underscore-ident-matcher.rs:8:19
+   |
+LL | macro_rules! identity {
+   | --------------------- when calling this macro
+...
+LL |     let identity!(_) = 10;
+   |                   ^ no rules expected this token in macro call
+   |
+note: while trying to match meta-variable `$i:ident`
+  --> $DIR/underscore-ident-matcher.rs:2:6
+   |
+LL |     ($i: ident) => (
+   |      ^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/namespace/struct-type-and-function-name-coexistence.rs b/tests/ui/namespace/struct-type-and-function-name-coexistence.rs
new file mode 100644
index 00000000000..31dc684a214
--- /dev/null
+++ b/tests/ui/namespace/struct-type-and-function-name-coexistence.rs
@@ -0,0 +1,7 @@
+//@ run-pass
+
+struct A { a: isize }
+
+fn a(a: A) -> isize { return a.a; }
+
+pub fn main() { let x: A = A {a: 1}; assert_eq!(a(x), 1); }
diff --git a/tests/ui/parser/integer-literal-method-call-underscore.rs b/tests/ui/parser/integer-literal-method-call-underscore.rs
new file mode 100644
index 00000000000..d9eb21894e8
--- /dev/null
+++ b/tests/ui/parser/integer-literal-method-call-underscore.rs
@@ -0,0 +1,11 @@
+//@ run-pass
+
+trait Tr : Sized {
+    fn _method_on_numbers(self) {}
+}
+
+impl Tr for i32 {}
+
+fn main() {
+    42._method_on_numbers();
+}
diff --git a/tests/ui/ptr_ops/ptr-write-bool-representation.rs b/tests/ui/ptr_ops/ptr-write-bool-representation.rs
new file mode 100644
index 00000000000..4eb25329223
--- /dev/null
+++ b/tests/ui/ptr_ops/ptr-write-bool-representation.rs
@@ -0,0 +1,11 @@
+//@ run-pass
+
+use std::ptr;
+
+pub fn main() {
+    unsafe {
+        let mut x: bool = false;
+        // this line breaks it
+        ptr::write(&mut x, false);
+    }
+}
diff --git a/tests/ui/ptr_ops/raw-pointer-type-basic.rs b/tests/ui/ptr_ops/raw-pointer-type-basic.rs
new file mode 100644
index 00000000000..5c8ed344ab3
--- /dev/null
+++ b/tests/ui/ptr_ops/raw-pointer-type-basic.rs
@@ -0,0 +1,9 @@
+//@ run-pass
+
+#![allow(dead_code)]
+
+fn f(a: *const isize) -> *const isize { return a; }
+
+fn g(a: *const isize) -> *const isize { let b = f(a); return b; }
+
+pub fn main() { return; }
diff --git a/tests/ui/try-operator-hygiene.rs b/tests/ui/try-operator-hygiene.rs
deleted file mode 100644
index 20538e094c6..00000000000
--- a/tests/ui/try-operator-hygiene.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//@ run-pass
-
-#![allow(non_upper_case_globals)]
-#![allow(dead_code)]
-// `expr?` expands to:
-//
-// match expr {
-//     Ok(val) => val,
-//     Err(err) => return Err(From::from(err)),
-// }
-//
-// This test verifies that the expansion is hygienic, i.e., it's not affected by other `val` and
-// `err` bindings that may be in scope.
-
-use std::num::ParseIntError;
-
-fn main() {
-    assert_eq!(parse(), Ok(1));
-}
-
-fn parse() -> Result<i32, ParseIntError> {
-    const val: char = 'a';
-    const err: char = 'b';
-
-    Ok("1".parse::<i32>()?)
-}
diff --git a/tests/ui/try-operator.rs b/tests/ui/try-operator.rs
deleted file mode 100644
index b9978204557..00000000000
--- a/tests/ui/try-operator.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-//@ run-pass
-
-#![allow(dead_code)]
-
-use std::fs::File;
-use std::io::{Read, self};
-use std::num::ParseIntError;
-use std::str::FromStr;
-
-fn on_method() -> Result<i32, ParseIntError> {
-    Ok("1".parse::<i32>()? + "2".parse::<i32>()?)
-}
-
-fn in_chain() -> Result<String, ParseIntError> {
-    Ok("3".parse::<i32>()?.to_string())
-}
-
-fn on_call() -> Result<i32, ParseIntError> {
-    fn parse<T: FromStr>(s: &str) -> Result<T, T::Err> {
-        s.parse()
-    }
-
-    Ok(parse("4")?)
-}
-
-fn nested() -> Result<i32, ParseIntError> {
-    Ok("5".parse::<i32>()?.to_string().parse()?)
-}
-
-fn on_path() -> Result<i32, ParseIntError> {
-    let x = "6".parse::<i32>();
-
-    Ok(x?)
-}
-
-fn on_macro() -> Result<i32, ParseIntError> {
-    macro_rules! id {
-        ($e:expr) => { $e }
-    }
-
-    Ok(id!("7".parse::<i32>())?)
-}
-
-fn on_parens() -> Result<i32, ParseIntError> {
-    let x = "8".parse::<i32>();
-
-    Ok((x)?)
-}
-
-fn on_block() -> Result<i32, ParseIntError> {
-    let x = "9".parse::<i32>();
-
-    Ok({x}?)
-}
-
-fn on_field() -> Result<i32, ParseIntError> {
-    struct Pair<A, B> { a: A, b: B }
-
-    let x = Pair { a: "10".parse::<i32>(), b: 0 };
-
-    Ok(x.a?)
-}
-
-fn on_tuple_field() -> Result<i32, ParseIntError> {
-    let x = ("11".parse::<i32>(), 0);
-
-    Ok(x.0?)
-}
-
-fn on_try() -> Result<i32, ParseIntError> {
-    let x = "12".parse::<i32>().map(|i| i.to_string().parse::<i32>());
-
-    Ok(x??)
-}
-
-fn on_binary_op() -> Result<i32, ParseIntError> {
-    let x = 13 - "14".parse::<i32>()?;
-    let y = "15".parse::<i32>()? - 16;
-    let z = "17".parse::<i32>()? - "18".parse::<i32>()?;
-
-    Ok(x + y + z)
-}
-
-fn on_index() -> Result<i32, ParseIntError> {
-    let x = [19];
-    let y = "0".parse::<usize>();
-
-    Ok(x[y?])
-}
-
-fn on_args() -> Result<i32, ParseIntError> {
-    fn sub(x: i32, y: i32) -> i32 { x - y }
-
-    let x = "20".parse();
-    let y = "21".parse();
-
-    Ok(sub(x?, y?))
-}
-
-fn on_if() -> Result<i32, ParseIntError> {
-    Ok(if true {
-        "22".parse::<i32>()
-    } else {
-        "23".parse::<i32>()
-    }?)
-}
-
-fn on_if_let() -> Result<i32, ParseIntError> {
-    Ok(if let Ok(..) = "24".parse::<i32>() {
-        "25".parse::<i32>()
-    } else {
-        "26".parse::<i32>()
-    }?)
-}
-
-fn on_match() -> Result<i32, ParseIntError> {
-    Ok(match "27".parse::<i32>() {
-        Err(..) => "28".parse::<i32>(),
-        Ok(..) => "29".parse::<i32>(),
-    }?)
-}
-
-fn tight_binding() -> Result<bool, ()> {
-    fn ok<T>(x: T) -> Result<T, ()> { Ok(x) }
-
-    let x = ok(true);
-    Ok(!x?)
-}
-
-// just type check
-fn merge_error() -> Result<i32, Error> {
-    let mut s = String::new();
-
-    File::open("foo.txt")?.read_to_string(&mut s)?;
-
-    Ok(s.parse::<i32>()? + 1)
-}
-
-fn main() {
-    assert_eq!(Ok(3), on_method());
-
-    assert_eq!(Ok("3".to_string()), in_chain());
-
-    assert_eq!(Ok(4), on_call());
-
-    assert_eq!(Ok(5), nested());
-
-    assert_eq!(Ok(6), on_path());
-
-    assert_eq!(Ok(7), on_macro());
-
-    assert_eq!(Ok(8), on_parens());
-
-    assert_eq!(Ok(9), on_block());
-
-    assert_eq!(Ok(10), on_field());
-
-    assert_eq!(Ok(11), on_tuple_field());
-
-    assert_eq!(Ok(12), on_try());
-
-    assert_eq!(Ok(-3), on_binary_op());
-
-    assert_eq!(Ok(19), on_index());
-
-    assert_eq!(Ok(-1), on_args());
-
-    assert_eq!(Ok(22), on_if());
-
-    assert_eq!(Ok(25), on_if_let());
-
-    assert_eq!(Ok(29), on_match());
-
-    assert_eq!(Ok(false), tight_binding());
-}
-
-enum Error {
-    Io(io::Error),
-    Parse(ParseIntError),
-}
-
-impl From<io::Error> for Error {
-    fn from(e: io::Error) -> Error {
-        Error::Io(e)
-    }
-}
-
-impl From<ParseIntError> for Error {
-    fn from(e: ParseIntError) -> Error {
-        Error::Parse(e)
-    }
-}
diff --git a/tests/ui/try-trait/try-operator-expansion-hygiene.rs b/tests/ui/try-trait/try-operator-expansion-hygiene.rs
new file mode 100644
index 00000000000..20538e094c6
--- /dev/null
+++ b/tests/ui/try-trait/try-operator-expansion-hygiene.rs
@@ -0,0 +1,26 @@
+//@ run-pass
+
+#![allow(non_upper_case_globals)]
+#![allow(dead_code)]
+// `expr?` expands to:
+//
+// match expr {
+//     Ok(val) => val,
+//     Err(err) => return Err(From::from(err)),
+// }
+//
+// This test verifies that the expansion is hygienic, i.e., it's not affected by other `val` and
+// `err` bindings that may be in scope.
+
+use std::num::ParseIntError;
+
+fn main() {
+    assert_eq!(parse(), Ok(1));
+}
+
+fn parse() -> Result<i32, ParseIntError> {
+    const val: char = 'a';
+    const err: char = 'b';
+
+    Ok("1".parse::<i32>()?)
+}
diff --git a/tests/ui/try-trait/try-operator-various-contexts.rs b/tests/ui/try-trait/try-operator-various-contexts.rs
new file mode 100644
index 00000000000..b9978204557
--- /dev/null
+++ b/tests/ui/try-trait/try-operator-various-contexts.rs
@@ -0,0 +1,192 @@
+//@ run-pass
+
+#![allow(dead_code)]
+
+use std::fs::File;
+use std::io::{Read, self};
+use std::num::ParseIntError;
+use std::str::FromStr;
+
+fn on_method() -> Result<i32, ParseIntError> {
+    Ok("1".parse::<i32>()? + "2".parse::<i32>()?)
+}
+
+fn in_chain() -> Result<String, ParseIntError> {
+    Ok("3".parse::<i32>()?.to_string())
+}
+
+fn on_call() -> Result<i32, ParseIntError> {
+    fn parse<T: FromStr>(s: &str) -> Result<T, T::Err> {
+        s.parse()
+    }
+
+    Ok(parse("4")?)
+}
+
+fn nested() -> Result<i32, ParseIntError> {
+    Ok("5".parse::<i32>()?.to_string().parse()?)
+}
+
+fn on_path() -> Result<i32, ParseIntError> {
+    let x = "6".parse::<i32>();
+
+    Ok(x?)
+}
+
+fn on_macro() -> Result<i32, ParseIntError> {
+    macro_rules! id {
+        ($e:expr) => { $e }
+    }
+
+    Ok(id!("7".parse::<i32>())?)
+}
+
+fn on_parens() -> Result<i32, ParseIntError> {
+    let x = "8".parse::<i32>();
+
+    Ok((x)?)
+}
+
+fn on_block() -> Result<i32, ParseIntError> {
+    let x = "9".parse::<i32>();
+
+    Ok({x}?)
+}
+
+fn on_field() -> Result<i32, ParseIntError> {
+    struct Pair<A, B> { a: A, b: B }
+
+    let x = Pair { a: "10".parse::<i32>(), b: 0 };
+
+    Ok(x.a?)
+}
+
+fn on_tuple_field() -> Result<i32, ParseIntError> {
+    let x = ("11".parse::<i32>(), 0);
+
+    Ok(x.0?)
+}
+
+fn on_try() -> Result<i32, ParseIntError> {
+    let x = "12".parse::<i32>().map(|i| i.to_string().parse::<i32>());
+
+    Ok(x??)
+}
+
+fn on_binary_op() -> Result<i32, ParseIntError> {
+    let x = 13 - "14".parse::<i32>()?;
+    let y = "15".parse::<i32>()? - 16;
+    let z = "17".parse::<i32>()? - "18".parse::<i32>()?;
+
+    Ok(x + y + z)
+}
+
+fn on_index() -> Result<i32, ParseIntError> {
+    let x = [19];
+    let y = "0".parse::<usize>();
+
+    Ok(x[y?])
+}
+
+fn on_args() -> Result<i32, ParseIntError> {
+    fn sub(x: i32, y: i32) -> i32 { x - y }
+
+    let x = "20".parse();
+    let y = "21".parse();
+
+    Ok(sub(x?, y?))
+}
+
+fn on_if() -> Result<i32, ParseIntError> {
+    Ok(if true {
+        "22".parse::<i32>()
+    } else {
+        "23".parse::<i32>()
+    }?)
+}
+
+fn on_if_let() -> Result<i32, ParseIntError> {
+    Ok(if let Ok(..) = "24".parse::<i32>() {
+        "25".parse::<i32>()
+    } else {
+        "26".parse::<i32>()
+    }?)
+}
+
+fn on_match() -> Result<i32, ParseIntError> {
+    Ok(match "27".parse::<i32>() {
+        Err(..) => "28".parse::<i32>(),
+        Ok(..) => "29".parse::<i32>(),
+    }?)
+}
+
+fn tight_binding() -> Result<bool, ()> {
+    fn ok<T>(x: T) -> Result<T, ()> { Ok(x) }
+
+    let x = ok(true);
+    Ok(!x?)
+}
+
+// just type check
+fn merge_error() -> Result<i32, Error> {
+    let mut s = String::new();
+
+    File::open("foo.txt")?.read_to_string(&mut s)?;
+
+    Ok(s.parse::<i32>()? + 1)
+}
+
+fn main() {
+    assert_eq!(Ok(3), on_method());
+
+    assert_eq!(Ok("3".to_string()), in_chain());
+
+    assert_eq!(Ok(4), on_call());
+
+    assert_eq!(Ok(5), nested());
+
+    assert_eq!(Ok(6), on_path());
+
+    assert_eq!(Ok(7), on_macro());
+
+    assert_eq!(Ok(8), on_parens());
+
+    assert_eq!(Ok(9), on_block());
+
+    assert_eq!(Ok(10), on_field());
+
+    assert_eq!(Ok(11), on_tuple_field());
+
+    assert_eq!(Ok(12), on_try());
+
+    assert_eq!(Ok(-3), on_binary_op());
+
+    assert_eq!(Ok(19), on_index());
+
+    assert_eq!(Ok(-1), on_args());
+
+    assert_eq!(Ok(22), on_if());
+
+    assert_eq!(Ok(25), on_if_let());
+
+    assert_eq!(Ok(29), on_match());
+
+    assert_eq!(Ok(false), tight_binding());
+}
+
+enum Error {
+    Io(io::Error),
+    Parse(ParseIntError),
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Error {
+        Error::Io(e)
+    }
+}
+
+impl From<ParseIntError> for Error {
+    fn from(e: ParseIntError) -> Error {
+        Error::Parse(e)
+    }
+}
diff --git a/tests/ui/tydesc-name.rs b/tests/ui/tydesc-name.rs
deleted file mode 100644
index 068a42606c2..00000000000
--- a/tests/ui/tydesc-name.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ run-pass
-
-#![allow(dead_code)]
-
-use std::any::type_name;
-
-struct Foo<T> {
-    x: T
-}
-
-pub fn main() {
-    assert_eq!(type_name::<isize>(), "isize");
-    assert_eq!(type_name::<Foo<usize>>(), "tydesc_name::Foo<usize>");
-}
diff --git a/tests/ui/type-id-higher-rank-2.rs b/tests/ui/type-id-higher-rank-2.rs
deleted file mode 100644
index 7b0c7b53940..00000000000
--- a/tests/ui/type-id-higher-rank-2.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ run-pass
-// Test that we can't ignore lifetimes by going through Any.
-
-use std::any::Any;
-
-struct Foo<'a>(&'a str);
-
-fn good(s: &String) -> Foo<'_> { Foo(s) }
-
-fn bad1(s: String) -> Option<&'static str> {
-    let a: Box<dyn Any> = Box::new(good as fn(&String) -> Foo);
-    a.downcast_ref::<fn(&String) -> Foo<'static>>().map(|f| f(&s).0)
-}
-
-trait AsStr<'a, 'b> {
-    fn get(&'a self) -> &'b str;
-}
-
-impl<'a> AsStr<'a, 'a> for String {
-   fn get(&'a self) -> &'a str { self }
-}
-
-fn bad2(s: String) -> Option<&'static str> {
-    let a: Box<dyn Any> = Box::new(Box::new(s) as Box<dyn for<'a> AsStr<'a, 'a>>);
-    a.downcast_ref::<Box<dyn for<'a> AsStr<'a, 'static>>>().map(|x| x.get())
-}
-
-fn main() {
-    assert_eq!(bad1(String::from("foo")), None);
-    assert_eq!(bad2(String::from("bar")), None);
-}
diff --git a/tests/ui/type-inference/type-inference-none-in-generic-ref.rs b/tests/ui/type-inference/type-inference-none-in-generic-ref.rs
new file mode 100644
index 00000000000..473ca954b23
--- /dev/null
+++ b/tests/ui/type-inference/type-inference-none-in-generic-ref.rs
@@ -0,0 +1,7 @@
+struct S<'a, T:'a> {
+    o: &'a Option<T>
+}
+
+fn main() {
+    S { o: &None }; //~ ERROR type annotations needed [E0282]
+}
diff --git a/tests/ui/type-inference/type-inference-none-in-generic-ref.stderr b/tests/ui/type-inference/type-inference-none-in-generic-ref.stderr
new file mode 100644
index 00000000000..72fd0202f4e
--- /dev/null
+++ b/tests/ui/type-inference/type-inference-none-in-generic-ref.stderr
@@ -0,0 +1,14 @@
+error[E0282]: type annotations needed
+  --> $DIR/unconstrained-ref.rs:6:5
+   |
+LL |     S { o: &None };
+   |     ^^^^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the struct `S`
+   |
+help: consider specifying the generic argument
+   |
+LL |     S::<T> { o: &None };
+   |      +++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/type-inference/type-inference-unconstrained-none.rs b/tests/ui/type-inference/type-inference-unconstrained-none.rs
new file mode 100644
index 00000000000..e180b3163d4
--- /dev/null
+++ b/tests/ui/type-inference/type-inference-unconstrained-none.rs
@@ -0,0 +1,5 @@
+// Issue #5062
+
+fn main() {
+    None; //~ ERROR type annotations needed [E0282]
+}
diff --git a/tests/ui/type-inference/type-inference-unconstrained-none.stderr b/tests/ui/type-inference/type-inference-unconstrained-none.stderr
new file mode 100644
index 00000000000..4af6f412e5b
--- /dev/null
+++ b/tests/ui/type-inference/type-inference-unconstrained-none.stderr
@@ -0,0 +1,14 @@
+error[E0282]: type annotations needed
+  --> $DIR/unconstrained-none.rs:4:5
+   |
+LL |     None;
+   |     ^^^^ cannot infer type of the type parameter `T` declared on the enum `Option`
+   |
+help: consider specifying the generic argument
+   |
+LL |     None::<T>;
+   |         +++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/type-namespace.rs b/tests/ui/type-namespace.rs
deleted file mode 100644
index 31dc684a214..00000000000
--- a/tests/ui/type-namespace.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ run-pass
-
-struct A { a: isize }
-
-fn a(a: A) -> isize { return a.a; }
-
-pub fn main() { let x: A = A {a: 1}; assert_eq!(a(x), 1); }
diff --git a/tests/ui/type-param-constraints.rs b/tests/ui/type-param-constraints.rs
deleted file mode 100644
index 83d81c0d833..00000000000
--- a/tests/ui/type-param-constraints.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ run-pass
-
-#![allow(non_camel_case_types)]
-#![allow(dead_code)]
-
-fn p_foo<T>(_pinned: T) { }
-fn s_foo<T>(_shared: T) { }
-fn u_foo<T:Send>(_unique: T) { }
-
-struct r {
-  i: isize,
-}
-
-impl Drop for r {
-    fn drop(&mut self) {}
-}
-
-fn r(i:isize) -> r {
-    r {
-        i: i
-    }
-}
-
-pub fn main() {
-    p_foo(r(10));
-
-    p_foo::<Box<_>>(Box::new(r(10)));
-    p_foo::<Box<_>>(Box::new(10));
-    p_foo(10);
-
-    s_foo::<Box<_>>(Box::new(10));
-    s_foo(10);
-
-    u_foo::<Box<_>>(Box::new(10));
-    u_foo(10);
-}
diff --git a/tests/ui/type-ptr.rs b/tests/ui/type-ptr.rs
deleted file mode 100644
index 5c8ed344ab3..00000000000
--- a/tests/ui/type-ptr.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ run-pass
-
-#![allow(dead_code)]
-
-fn f(a: *const isize) -> *const isize { return a; }
-
-fn g(a: *const isize) -> *const isize { let b = f(a); return b; }
-
-pub fn main() { return; }
diff --git a/tests/ui/type-use-i1-versus-i8.rs b/tests/ui/type-use-i1-versus-i8.rs
deleted file mode 100644
index 4eb25329223..00000000000
--- a/tests/ui/type-use-i1-versus-i8.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ run-pass
-
-use std::ptr;
-
-pub fn main() {
-    unsafe {
-        let mut x: bool = false;
-        // this line breaks it
-        ptr::write(&mut x, false);
-    }
-}
diff --git a/tests/ui/type/type-name-basic.rs b/tests/ui/type/type-name-basic.rs
new file mode 100644
index 00000000000..068a42606c2
--- /dev/null
+++ b/tests/ui/type/type-name-basic.rs
@@ -0,0 +1,14 @@
+//@ run-pass
+
+#![allow(dead_code)]
+
+use std::any::type_name;
+
+struct Foo<T> {
+    x: T
+}
+
+pub fn main() {
+    assert_eq!(type_name::<isize>(), "isize");
+    assert_eq!(type_name::<Foo<usize>>(), "tydesc_name::Foo<usize>");
+}
diff --git a/tests/ui/type/typeid-consistency-comprehensive.rs b/tests/ui/type/typeid-consistency-comprehensive.rs
new file mode 100644
index 00000000000..7c4fb3f95a9
--- /dev/null
+++ b/tests/ui/type/typeid-consistency-comprehensive.rs
@@ -0,0 +1,97 @@
+//@ run-pass
+
+#![allow(deprecated)]
+//@ aux-build:typeid-intrinsic-aux1.rs
+//@ aux-build:typeid-intrinsic-aux2.rs
+
+#![feature(core_intrinsics)]
+
+extern crate typeid_intrinsic_aux1 as other1;
+extern crate typeid_intrinsic_aux2 as other2;
+
+use std::hash::{SipHasher, Hasher, Hash};
+use std::any::TypeId;
+
+struct A;
+struct Test;
+
+pub fn main() {
+    assert_eq!(TypeId::of::<other1::A>(), other1::id_A());
+    assert_eq!(TypeId::of::<other1::B>(), other1::id_B());
+    assert_eq!(TypeId::of::<other1::C>(), other1::id_C());
+    assert_eq!(TypeId::of::<other1::D>(), other1::id_D());
+    assert_eq!(TypeId::of::<other1::E>(), other1::id_E());
+    assert_eq!(TypeId::of::<other1::F>(), other1::id_F());
+    assert_eq!(TypeId::of::<other1::G>(), other1::id_G());
+    assert_eq!(TypeId::of::<other1::H>(), other1::id_H());
+    assert_eq!(TypeId::of::<other1::I>(), other1::id_I());
+
+    assert_eq!(TypeId::of::<other2::A>(), other2::id_A());
+    assert_eq!(TypeId::of::<other2::B>(), other2::id_B());
+    assert_eq!(TypeId::of::<other2::C>(), other2::id_C());
+    assert_eq!(TypeId::of::<other2::D>(), other2::id_D());
+    assert_eq!(TypeId::of::<other2::E>(), other2::id_E());
+    assert_eq!(TypeId::of::<other2::F>(), other2::id_F());
+    assert_eq!(TypeId::of::<other2::G>(), other2::id_G());
+    assert_eq!(TypeId::of::<other2::H>(), other2::id_H());
+    assert_eq!(TypeId::of::<other1::I>(), other2::id_I());
+
+    assert_eq!(other1::id_F(), other2::id_F());
+    assert_eq!(other1::id_G(), other2::id_G());
+    assert_eq!(other1::id_H(), other2::id_H());
+    assert_eq!(other1::id_I(), other2::id_I());
+
+    assert_eq!(TypeId::of::<isize>(), other2::foo::<isize>());
+    assert_eq!(TypeId::of::<isize>(), other1::foo::<isize>());
+    assert_eq!(other2::foo::<isize>(), other1::foo::<isize>());
+    assert_eq!(TypeId::of::<A>(), other2::foo::<A>());
+    assert_eq!(TypeId::of::<A>(), other1::foo::<A>());
+    assert_eq!(other2::foo::<A>(), other1::foo::<A>());
+
+    // sanity test of TypeId
+    let (a, b, c) = (TypeId::of::<usize>(), TypeId::of::<&'static str>(),
+                     TypeId::of::<Test>());
+    let (d, e, f) = (TypeId::of::<usize>(), TypeId::of::<&'static str>(),
+                     TypeId::of::<Test>());
+
+    assert!(a != b);
+    assert!(a != c);
+    assert!(b != c);
+
+    assert_eq!(a, d);
+    assert_eq!(b, e);
+    assert_eq!(c, f);
+
+    // check it has a hash
+    let (a, b) = (TypeId::of::<usize>(), TypeId::of::<usize>());
+
+    let mut s1 = SipHasher::new();
+    a.hash(&mut s1);
+    let mut s2 = SipHasher::new();
+    b.hash(&mut s2);
+
+    assert_eq!(s1.finish(), s2.finish());
+
+    // Check projections
+
+    assert_eq!(TypeId::of::<other1::I32Iterator>(), other1::id_i32_iterator());
+    assert_eq!(TypeId::of::<other1::U32Iterator>(), other1::id_u32_iterator());
+    assert_eq!(other1::id_i32_iterator(), other2::id_i32_iterator());
+    assert_eq!(other1::id_u32_iterator(), other2::id_u32_iterator());
+    assert_ne!(other1::id_i32_iterator(), other1::id_u32_iterator());
+    assert_ne!(TypeId::of::<other1::I32Iterator>(), TypeId::of::<other1::U32Iterator>());
+
+    // Check fn pointer against collisions
+    assert_ne!(
+        TypeId::of::<fn(fn(A) -> A) -> A>(),
+        TypeId::of::<fn(fn() -> A, A) -> A>()
+    );
+    assert_ne!(
+        TypeId::of::<for<'a> fn(&'a i32) -> &'a i32>(),
+        TypeId::of::<for<'a> fn(&'a i32) -> &'static i32>()
+    );
+    assert_ne!(
+        TypeId::of::<for<'a, 'b> fn(&'a i32, &'b i32) -> &'a i32>(),
+        TypeId::of::<for<'a, 'b> fn(&'b i32, &'a i32) -> &'a i32>()
+    );
+}
diff --git a/tests/ui/type_length_limit.rs b/tests/ui/type_length_limit.rs
deleted file mode 100644
index 87f5ffd76d7..00000000000
--- a/tests/ui/type_length_limit.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//@ build-fail
-//@ compile-flags: -Copt-level=0 -Zenforce-type-length-limit
-//~^^ ERROR reached the type-length limit
-
-// Test that the type length limit can be changed.
-// The exact type depends on optimizations, so disable them.
-
-#![allow(dead_code)]
-#![type_length_limit="8"]
-
-macro_rules! link {
-    ($id:ident, $t:ty) => {
-        pub type $id = ($t, $t, $t);
-    }
-}
-
-link! { A1, B1 }
-link! { B1, C1 }
-link! { C1, D1 }
-link! { D1, E1 }
-link! { E1, A }
-link! { A, B }
-link! { B, C }
-link! { C, D }
-link! { D, E }
-link! { E, F }
-link! { F, G<Option<i32>, Option<i32>> }
-
-pub struct G<T, K>(std::marker::PhantomData::<(T, K)>);
-
-fn main() {
-    drop::<Option<A>>(None);
-    //~^ ERROR reached the type-length limit
-}
diff --git a/tests/ui/type_length_limit.stderr b/tests/ui/type_length_limit.stderr
deleted file mode 100644
index 198d133c08c..00000000000
--- a/tests/ui/type_length_limit.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: reached the type-length limit while instantiating `std::mem::drop::<Option<((((..., ..., ...), ..., ...), ..., ...), ..., ...)>>`
-  --> $DIR/type_length_limit.rs:32:5
-   |
-LL |     drop::<Option<A>>(None);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider adding a `#![type_length_limit="4010"]` attribute to your crate
-   = note: the full type name has been written to '$TEST_BUILD_DIR/type_length_limit.long-type.txt'
-
-error: reached the type-length limit while instantiating `<{closure@rt::lang_start<()>::{closure#0}} as FnMut<()>>::call_mut`
-   |
-   = help: consider adding a `#![type_length_limit="10"]` attribute to your crate
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/typeid-intrinsic.rs b/tests/ui/typeid-intrinsic.rs
deleted file mode 100644
index 7c4fb3f95a9..00000000000
--- a/tests/ui/typeid-intrinsic.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-//@ run-pass
-
-#![allow(deprecated)]
-//@ aux-build:typeid-intrinsic-aux1.rs
-//@ aux-build:typeid-intrinsic-aux2.rs
-
-#![feature(core_intrinsics)]
-
-extern crate typeid_intrinsic_aux1 as other1;
-extern crate typeid_intrinsic_aux2 as other2;
-
-use std::hash::{SipHasher, Hasher, Hash};
-use std::any::TypeId;
-
-struct A;
-struct Test;
-
-pub fn main() {
-    assert_eq!(TypeId::of::<other1::A>(), other1::id_A());
-    assert_eq!(TypeId::of::<other1::B>(), other1::id_B());
-    assert_eq!(TypeId::of::<other1::C>(), other1::id_C());
-    assert_eq!(TypeId::of::<other1::D>(), other1::id_D());
-    assert_eq!(TypeId::of::<other1::E>(), other1::id_E());
-    assert_eq!(TypeId::of::<other1::F>(), other1::id_F());
-    assert_eq!(TypeId::of::<other1::G>(), other1::id_G());
-    assert_eq!(TypeId::of::<other1::H>(), other1::id_H());
-    assert_eq!(TypeId::of::<other1::I>(), other1::id_I());
-
-    assert_eq!(TypeId::of::<other2::A>(), other2::id_A());
-    assert_eq!(TypeId::of::<other2::B>(), other2::id_B());
-    assert_eq!(TypeId::of::<other2::C>(), other2::id_C());
-    assert_eq!(TypeId::of::<other2::D>(), other2::id_D());
-    assert_eq!(TypeId::of::<other2::E>(), other2::id_E());
-    assert_eq!(TypeId::of::<other2::F>(), other2::id_F());
-    assert_eq!(TypeId::of::<other2::G>(), other2::id_G());
-    assert_eq!(TypeId::of::<other2::H>(), other2::id_H());
-    assert_eq!(TypeId::of::<other1::I>(), other2::id_I());
-
-    assert_eq!(other1::id_F(), other2::id_F());
-    assert_eq!(other1::id_G(), other2::id_G());
-    assert_eq!(other1::id_H(), other2::id_H());
-    assert_eq!(other1::id_I(), other2::id_I());
-
-    assert_eq!(TypeId::of::<isize>(), other2::foo::<isize>());
-    assert_eq!(TypeId::of::<isize>(), other1::foo::<isize>());
-    assert_eq!(other2::foo::<isize>(), other1::foo::<isize>());
-    assert_eq!(TypeId::of::<A>(), other2::foo::<A>());
-    assert_eq!(TypeId::of::<A>(), other1::foo::<A>());
-    assert_eq!(other2::foo::<A>(), other1::foo::<A>());
-
-    // sanity test of TypeId
-    let (a, b, c) = (TypeId::of::<usize>(), TypeId::of::<&'static str>(),
-                     TypeId::of::<Test>());
-    let (d, e, f) = (TypeId::of::<usize>(), TypeId::of::<&'static str>(),
-                     TypeId::of::<Test>());
-
-    assert!(a != b);
-    assert!(a != c);
-    assert!(b != c);
-
-    assert_eq!(a, d);
-    assert_eq!(b, e);
-    assert_eq!(c, f);
-
-    // check it has a hash
-    let (a, b) = (TypeId::of::<usize>(), TypeId::of::<usize>());
-
-    let mut s1 = SipHasher::new();
-    a.hash(&mut s1);
-    let mut s2 = SipHasher::new();
-    b.hash(&mut s2);
-
-    assert_eq!(s1.finish(), s2.finish());
-
-    // Check projections
-
-    assert_eq!(TypeId::of::<other1::I32Iterator>(), other1::id_i32_iterator());
-    assert_eq!(TypeId::of::<other1::U32Iterator>(), other1::id_u32_iterator());
-    assert_eq!(other1::id_i32_iterator(), other2::id_i32_iterator());
-    assert_eq!(other1::id_u32_iterator(), other2::id_u32_iterator());
-    assert_ne!(other1::id_i32_iterator(), other1::id_u32_iterator());
-    assert_ne!(TypeId::of::<other1::I32Iterator>(), TypeId::of::<other1::U32Iterator>());
-
-    // Check fn pointer against collisions
-    assert_ne!(
-        TypeId::of::<fn(fn(A) -> A) -> A>(),
-        TypeId::of::<fn(fn() -> A, A) -> A>()
-    );
-    assert_ne!(
-        TypeId::of::<for<'a> fn(&'a i32) -> &'a i32>(),
-        TypeId::of::<for<'a> fn(&'a i32) -> &'static i32>()
-    );
-    assert_ne!(
-        TypeId::of::<for<'a, 'b> fn(&'a i32, &'b i32) -> &'a i32>(),
-        TypeId::of::<for<'a, 'b> fn(&'b i32, &'a i32) -> &'a i32>()
-    );
-}
diff --git a/tests/ui/typestate-multi-decl.rs b/tests/ui/typestate-multi-decl.rs
deleted file mode 100644
index 3d0e79632bb..00000000000
--- a/tests/ui/typestate-multi-decl.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ run-pass
-
-pub fn main() {
-    let (x, y) = (10, 20);
-    let z = x + y;
-    assert_eq!(z, 30);
-}
diff --git a/tests/ui/unconstrained-none.rs b/tests/ui/unconstrained-none.rs
deleted file mode 100644
index e180b3163d4..00000000000
--- a/tests/ui/unconstrained-none.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Issue #5062
-
-fn main() {
-    None; //~ ERROR type annotations needed [E0282]
-}
diff --git a/tests/ui/unconstrained-none.stderr b/tests/ui/unconstrained-none.stderr
deleted file mode 100644
index 4af6f412e5b..00000000000
--- a/tests/ui/unconstrained-none.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error[E0282]: type annotations needed
-  --> $DIR/unconstrained-none.rs:4:5
-   |
-LL |     None;
-   |     ^^^^ cannot infer type of the type parameter `T` declared on the enum `Option`
-   |
-help: consider specifying the generic argument
-   |
-LL |     None::<T>;
-   |         +++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/unconstrained-ref.rs b/tests/ui/unconstrained-ref.rs
deleted file mode 100644
index 473ca954b23..00000000000
--- a/tests/ui/unconstrained-ref.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-struct S<'a, T:'a> {
-    o: &'a Option<T>
-}
-
-fn main() {
-    S { o: &None }; //~ ERROR type annotations needed [E0282]
-}
diff --git a/tests/ui/unconstrained-ref.stderr b/tests/ui/unconstrained-ref.stderr
deleted file mode 100644
index 72fd0202f4e..00000000000
--- a/tests/ui/unconstrained-ref.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error[E0282]: type annotations needed
-  --> $DIR/unconstrained-ref.rs:6:5
-   |
-LL |     S { o: &None };
-   |     ^^^^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the struct `S`
-   |
-help: consider specifying the generic argument
-   |
-LL |     S::<T> { o: &None };
-   |      +++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/underscore-ident-matcher.rs b/tests/ui/underscore-ident-matcher.rs
deleted file mode 100644
index 77ec70d43d5..00000000000
--- a/tests/ui/underscore-ident-matcher.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-macro_rules! identity {
-    ($i: ident) => (
-        $i
-    )
-}
-
-fn main() {
-    let identity!(_) = 10; //~ ERROR no rules expected reserved identifier `_`
-}
diff --git a/tests/ui/underscore-ident-matcher.stderr b/tests/ui/underscore-ident-matcher.stderr
deleted file mode 100644
index 0c3f980cf6c..00000000000
--- a/tests/ui/underscore-ident-matcher.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error: no rules expected reserved identifier `_`
-  --> $DIR/underscore-ident-matcher.rs:8:19
-   |
-LL | macro_rules! identity {
-   | --------------------- when calling this macro
-...
-LL |     let identity!(_) = 10;
-   |                   ^ no rules expected this token in macro call
-   |
-note: while trying to match meta-variable `$i:ident`
-  --> $DIR/underscore-ident-matcher.rs:2:6
-   |
-LL |     ($i: ident) => (
-   |      ^^^^^^^^^
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/underscore-lifetime/basic-underscore-lifetime-elision.rs b/tests/ui/underscore-lifetime/basic-underscore-lifetime-elision.rs
new file mode 100644
index 00000000000..a372851f9cf
--- /dev/null
+++ b/tests/ui/underscore-lifetime/basic-underscore-lifetime-elision.rs
@@ -0,0 +1,38 @@
+//@ run-pass
+
+#![allow(dead_code, mismatched_lifetime_syntaxes)]
+struct Foo<'a>(&'a u8);
+
+fn foo(x: &u8) -> Foo<'_> {
+    Foo(x)
+}
+
+fn foo2(x: &'_ u8) -> Foo<'_> {
+    Foo(x)
+}
+
+fn foo3(x: &'_ u8) -> Foo {
+    Foo(x)
+}
+
+fn foo4(_: Foo<'_>) {}
+
+struct Foo2<'a, 'b> {
+    a: &'a u8,
+    b: &'b u8,
+}
+fn foo5<'b>(foo: Foo2<'_, 'b>) -> &'b u8 {
+    foo.b
+}
+
+fn main() {
+    let x = &5;
+    let _ = foo(x);
+    let _ = foo2(x);
+    let _ = foo3(x);
+    foo4(Foo(x));
+    let _ = foo5(Foo2 {
+        a: x,
+        b: &6,
+    });
+}
diff --git a/tests/ui/underscore-lifetimes.rs b/tests/ui/underscore-lifetimes.rs
deleted file mode 100644
index a372851f9cf..00000000000
--- a/tests/ui/underscore-lifetimes.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//@ run-pass
-
-#![allow(dead_code, mismatched_lifetime_syntaxes)]
-struct Foo<'a>(&'a u8);
-
-fn foo(x: &u8) -> Foo<'_> {
-    Foo(x)
-}
-
-fn foo2(x: &'_ u8) -> Foo<'_> {
-    Foo(x)
-}
-
-fn foo3(x: &'_ u8) -> Foo {
-    Foo(x)
-}
-
-fn foo4(_: Foo<'_>) {}
-
-struct Foo2<'a, 'b> {
-    a: &'a u8,
-    b: &'b u8,
-}
-fn foo5<'b>(foo: Foo2<'_, 'b>) -> &'b u8 {
-    foo.b
-}
-
-fn main() {
-    let x = &5;
-    let _ = foo(x);
-    let _ = foo2(x);
-    let _ = foo3(x);
-    foo4(Foo(x));
-    let _ = foo5(Foo2 {
-        a: x,
-        b: &6,
-    });
-}
diff --git a/tests/ui/underscore-method-after-integer.rs b/tests/ui/underscore-method-after-integer.rs
deleted file mode 100644
index d9eb21894e8..00000000000
--- a/tests/ui/underscore-method-after-integer.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ run-pass
-
-trait Tr : Sized {
-    fn _method_on_numbers(self) {}
-}
-
-impl Tr for i32 {}
-
-fn main() {
-    42._method_on_numbers();
-}
diff --git a/tests/ui/unevaluated_fixed_size_array_len.rs b/tests/ui/unevaluated_fixed_size_array_len.rs
deleted file mode 100644
index 6c545913dd9..00000000000
--- a/tests/ui/unevaluated_fixed_size_array_len.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// https://github.com/rust-lang/rust/issues/49208
-
-trait Foo {
-    fn foo();
-}
-
-impl Foo for [(); 1] {
-    fn foo() {}
-}
-
-fn main() {
-    <[(); 0] as Foo>::foo() //~ ERROR E0277
-}
diff --git a/tests/ui/unevaluated_fixed_size_array_len.stderr b/tests/ui/unevaluated_fixed_size_array_len.stderr
deleted file mode 100644
index 43cc377006e..00000000000
--- a/tests/ui/unevaluated_fixed_size_array_len.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error[E0277]: the trait bound `[(); 0]: Foo` is not satisfied
-  --> $DIR/unevaluated_fixed_size_array_len.rs:12:6
-   |
-LL |     <[(); 0] as Foo>::foo()
-   |      ^^^^^^^ the trait `Foo` is not implemented for `[(); 0]`
-   |
-   = help: the trait `Foo` is implemented for `[(); 1]`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 79ed7c1f415f40b3167d946c4a292b84b92eede5 Mon Sep 17 00:00:00 2001
From: Nurzhan Saken <nurzhan.sakenov@gmail.com>
Date: Tue, 1 Jul 2025 22:32:19 +0400
Subject: Test upper overflow in `strict_sub_signed`

Co-authored-by: zachs18 <8355914+zachs18@users.noreply.github.com>
---
 library/core/src/num/uint_macros.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index cf34ab8a3cd..78002593b63 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -830,7 +830,7 @@ macro_rules! uint_impl {
         ///
         /// ```should_panic
         /// #![feature(strict_overflow_ops)]
-        #[doc = concat!("let _ = (", stringify!($SelfT), "::MIN + 2).strict_sub_signed(3);")]
+        #[doc = concat!("let _ = (", stringify!($SelfT), "::MAX).strict_sub_signed(-1);")]
         /// ```
         #[unstable(feature = "strict_overflow_ops", issue = "118260")]
         #[must_use = "this returns the result of the operation, \
-- 
cgit 1.4.1-3-g733a5


From 1fb5e0149fb85af0e49fa40329cbc352b4cba861 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Tue, 1 Jul 2025 23:33:59 +0500
Subject: moved tests

---
 tests/ui/allocator/weak-uninhabited-type.rs        |   7 +
 .../underscore-prefixed-function-argument.rs       |  13 +
 .../ownership-struct-update-moved-error.rs         |  17 ++
 .../ownership-struct-update-moved-error.stderr     |  20 ++
 tests/ui/closures/no-capture-closure-call.rs       |   7 +
 tests/ui/codegen/llvm-args-invalid-flag.rs         |  22 ++
 tests/ui/codegen/llvm-args-invalid-flag.stderr     |   1 +
 .../box-drop-unused-value-statement-regression.rs  |  12 +
 tests/ui/expr/syntax-edge-cases-lint-clean.rs      | 303 +++++++++++++++++++++
 tests/ui/hashmap/hashset-enum-variant.rs           |  31 +++
 tests/ui/io-checks/write-macro-error.rs            |  55 ++++
 .../lang-item-unknown-definition-error.rs          |  10 +
 .../lang-item-unknown-definition-error.stderr      |   9 +
 tests/ui/modules/module-qualified-paths-basic.rs   |  11 +
 tests/ui/modules/module-use-nested-groups.rs       |  32 +++
 .../primitive-type-module-deprecated-paths.rs      |  12 +
 .../ui/modules/use-keyword-reexport-type-alias.rs  |  23 ++
 .../unary-negation-unsigned-integer-error.rs       |   5 +
 .../unary-negation-unsigned-integer-error.stderr   |  42 +++
 tests/ui/panics/unwind-force-no-unwind-tables.rs   |  34 +++
 tests/ui/process/process-spawn-failure.rs          |  71 +++++
 tests/ui/process/windows-exit-code-still-active.rs |  28 ++
 .../diverging-expressions-unreachable-code.rs      |  19 ++
 .../unreachable-code-diverging-expressions.rs      |  35 +++
 tests/ui/traits/virtual-call-parameter-handling.rs |  45 +++
 tests/ui/type/unit-type-basic-usages.rs            |  16 ++
 tests/ui/type/usize-no-generic-arguments.rs        |   5 +
 tests/ui/type/usize-no-generic-arguments.stderr    |  17 ++
 tests/ui/uninit-empty-types.rs                     |  18 --
 tests/ui/unit.rs                                   |  16 --
 tests/ui/unknown-language-item.rs                  |  10 -
 tests/ui/unknown-language-item.stderr              |   9 -
 tests/ui/unknown-llvm-arg.rs                       |  22 --
 tests/ui/unknown-llvm-arg.stderr                   |   1 -
 tests/ui/unnamed_argument_mode.rs                  |  13 -
 tests/ui/unreachable-code-1.rs                     |  19 --
 tests/ui/unreachable-code.rs                       |  35 ---
 tests/ui/unsafe/maybe-uninit-zero-sized-types.rs   |  18 ++
 tests/ui/unsigned-literal-negation.rs              |   5 -
 tests/ui/unsigned-literal-negation.stderr          |  42 ---
 tests/ui/unused-move-capture.rs                    |   7 -
 tests/ui/unused-move.rs                            |  12 -
 tests/ui/unwind-no-uwtable.rs                      |  34 ---
 tests/ui/use-import-export.rs                      |  11 -
 tests/ui/use-keyword-2.rs                          |  23 --
 tests/ui/use-module-level-int-consts.rs            |  12 -
 tests/ui/use-nested-groups.rs                      |  32 ---
 tests/ui/usize-generic-argument-parent.rs          |   5 -
 tests/ui/usize-generic-argument-parent.stderr      |  17 --
 tests/ui/virtual-call-attrs-issue-137646.rs        |  45 ---
 tests/ui/wait-forked-but-failed-child.rs           |  71 -----
 tests/ui/walk-struct-literal-with.rs               |  17 --
 tests/ui/walk-struct-literal-with.stderr           |  20 --
 tests/ui/weak-new-uninhabited-issue-48493.rs       |   7 -
 tests/ui/weird-exit-code.rs                        |  28 --
 tests/ui/weird-exprs.rs                            | 303 ---------------------
 tests/ui/write-fmt-errors.rs                       |  55 ----
 tests/ui/wrong-hashset-issue-42918.rs              |  31 ---
 58 files changed, 920 insertions(+), 920 deletions(-)
 create mode 100644 tests/ui/allocator/weak-uninhabited-type.rs
 create mode 100644 tests/ui/binding/underscore-prefixed-function-argument.rs
 create mode 100644 tests/ui/borrowck/ownership-struct-update-moved-error.rs
 create mode 100644 tests/ui/borrowck/ownership-struct-update-moved-error.stderr
 create mode 100644 tests/ui/closures/no-capture-closure-call.rs
 create mode 100644 tests/ui/codegen/llvm-args-invalid-flag.rs
 create mode 100644 tests/ui/codegen/llvm-args-invalid-flag.stderr
 create mode 100644 tests/ui/drop/box-drop-unused-value-statement-regression.rs
 create mode 100644 tests/ui/expr/syntax-edge-cases-lint-clean.rs
 create mode 100644 tests/ui/hashmap/hashset-enum-variant.rs
 create mode 100644 tests/ui/io-checks/write-macro-error.rs
 create mode 100644 tests/ui/lang-items/lang-item-unknown-definition-error.rs
 create mode 100644 tests/ui/lang-items/lang-item-unknown-definition-error.stderr
 create mode 100644 tests/ui/modules/module-qualified-paths-basic.rs
 create mode 100644 tests/ui/modules/module-use-nested-groups.rs
 create mode 100644 tests/ui/modules/primitive-type-module-deprecated-paths.rs
 create mode 100644 tests/ui/modules/use-keyword-reexport-type-alias.rs
 create mode 100644 tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs
 create mode 100644 tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr
 create mode 100644 tests/ui/panics/unwind-force-no-unwind-tables.rs
 create mode 100644 tests/ui/process/process-spawn-failure.rs
 create mode 100644 tests/ui/process/windows-exit-code-still-active.rs
 create mode 100644 tests/ui/reachable/diverging-expressions-unreachable-code.rs
 create mode 100644 tests/ui/reachable/unreachable-code-diverging-expressions.rs
 create mode 100644 tests/ui/traits/virtual-call-parameter-handling.rs
 create mode 100644 tests/ui/type/unit-type-basic-usages.rs
 create mode 100644 tests/ui/type/usize-no-generic-arguments.rs
 create mode 100644 tests/ui/type/usize-no-generic-arguments.stderr
 delete mode 100644 tests/ui/uninit-empty-types.rs
 delete mode 100644 tests/ui/unit.rs
 delete mode 100644 tests/ui/unknown-language-item.rs
 delete mode 100644 tests/ui/unknown-language-item.stderr
 delete mode 100644 tests/ui/unknown-llvm-arg.rs
 delete mode 100644 tests/ui/unknown-llvm-arg.stderr
 delete mode 100644 tests/ui/unnamed_argument_mode.rs
 delete mode 100644 tests/ui/unreachable-code-1.rs
 delete mode 100644 tests/ui/unreachable-code.rs
 create mode 100644 tests/ui/unsafe/maybe-uninit-zero-sized-types.rs
 delete mode 100644 tests/ui/unsigned-literal-negation.rs
 delete mode 100644 tests/ui/unsigned-literal-negation.stderr
 delete mode 100644 tests/ui/unused-move-capture.rs
 delete mode 100644 tests/ui/unused-move.rs
 delete mode 100644 tests/ui/unwind-no-uwtable.rs
 delete mode 100644 tests/ui/use-import-export.rs
 delete mode 100644 tests/ui/use-keyword-2.rs
 delete mode 100644 tests/ui/use-module-level-int-consts.rs
 delete mode 100644 tests/ui/use-nested-groups.rs
 delete mode 100644 tests/ui/usize-generic-argument-parent.rs
 delete mode 100644 tests/ui/usize-generic-argument-parent.stderr
 delete mode 100644 tests/ui/virtual-call-attrs-issue-137646.rs
 delete mode 100644 tests/ui/wait-forked-but-failed-child.rs
 delete mode 100644 tests/ui/walk-struct-literal-with.rs
 delete mode 100644 tests/ui/walk-struct-literal-with.stderr
 delete mode 100644 tests/ui/weak-new-uninhabited-issue-48493.rs
 delete mode 100644 tests/ui/weird-exit-code.rs
 delete mode 100644 tests/ui/weird-exprs.rs
 delete mode 100644 tests/ui/write-fmt-errors.rs
 delete mode 100644 tests/ui/wrong-hashset-issue-42918.rs

diff --git a/tests/ui/allocator/weak-uninhabited-type.rs b/tests/ui/allocator/weak-uninhabited-type.rs
new file mode 100644
index 00000000000..ce7d5786b41
--- /dev/null
+++ b/tests/ui/allocator/weak-uninhabited-type.rs
@@ -0,0 +1,7 @@
+//@ run-pass
+
+fn main() {
+    enum Void {}
+    let _ = std::rc::Weak::<Void>::new();
+    let _ = std::sync::Weak::<Void>::new();
+}
diff --git a/tests/ui/binding/underscore-prefixed-function-argument.rs b/tests/ui/binding/underscore-prefixed-function-argument.rs
new file mode 100644
index 00000000000..2014e0d23d8
--- /dev/null
+++ b/tests/ui/binding/underscore-prefixed-function-argument.rs
@@ -0,0 +1,13 @@
+//@ run-pass
+
+fn good(_a: &isize) {
+}
+
+// unnamed argument &isize is now parse x: &isize
+
+fn called<F>(_f: F) where F: FnOnce(&isize) {
+}
+
+pub fn main() {
+    called(good);
+}
diff --git a/tests/ui/borrowck/ownership-struct-update-moved-error.rs b/tests/ui/borrowck/ownership-struct-update-moved-error.rs
new file mode 100644
index 00000000000..ee1a77eb9a4
--- /dev/null
+++ b/tests/ui/borrowck/ownership-struct-update-moved-error.rs
@@ -0,0 +1,17 @@
+struct Mine{
+    test: String,
+    other_val: isize
+}
+
+impl Mine{
+    fn make_string_bar(mut self) -> Mine{
+        self.test = "Bar".to_string();
+        self
+    }
+}
+
+fn main(){
+    let start = Mine{test:"Foo".to_string(), other_val:0};
+    let end = Mine{other_val:1, ..start.make_string_bar()};
+    println!("{}", start.test); //~ ERROR borrow of moved value: `start`
+}
diff --git a/tests/ui/borrowck/ownership-struct-update-moved-error.stderr b/tests/ui/borrowck/ownership-struct-update-moved-error.stderr
new file mode 100644
index 00000000000..34b501f8ec8
--- /dev/null
+++ b/tests/ui/borrowck/ownership-struct-update-moved-error.stderr
@@ -0,0 +1,20 @@
+error[E0382]: borrow of moved value: `start`
+  --> $DIR/walk-struct-literal-with.rs:16:20
+   |
+LL |     let start = Mine{test:"Foo".to_string(), other_val:0};
+   |         ----- move occurs because `start` has type `Mine`, which does not implement the `Copy` trait
+LL |     let end = Mine{other_val:1, ..start.make_string_bar()};
+   |                                         ----------------- `start` moved due to this method call
+LL |     println!("{}", start.test);
+   |                    ^^^^^^^^^^ value borrowed here after move
+   |
+note: `Mine::make_string_bar` takes ownership of the receiver `self`, which moves `start`
+  --> $DIR/walk-struct-literal-with.rs:7:28
+   |
+LL |     fn make_string_bar(mut self) -> Mine{
+   |                            ^^^^
+   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (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 E0382`.
diff --git a/tests/ui/closures/no-capture-closure-call.rs b/tests/ui/closures/no-capture-closure-call.rs
new file mode 100644
index 00000000000..5f42bcbe280
--- /dev/null
+++ b/tests/ui/closures/no-capture-closure-call.rs
@@ -0,0 +1,7 @@
+//@ run-pass
+
+pub fn main() {
+    let _x: Box<_> = Box::new(1);
+    let lam_move = || {};
+    lam_move();
+}
diff --git a/tests/ui/codegen/llvm-args-invalid-flag.rs b/tests/ui/codegen/llvm-args-invalid-flag.rs
new file mode 100644
index 00000000000..a8fa55a220a
--- /dev/null
+++ b/tests/ui/codegen/llvm-args-invalid-flag.rs
@@ -0,0 +1,22 @@
+//@ compile-flags: -Cllvm-args=-not-a-real-llvm-arg
+//@ normalize-stderr: "--help" -> "-help"
+//@ normalize-stderr: "\n(\n|.)*" -> ""
+
+// I'm seeing "--help" locally, but "-help" in CI, so I'm normalizing it to just "-help".
+
+// Note that the rustc-supplied "program name", given when invoking LLVM, is used by LLVM to
+// generate user-facing error messages and a usage (--help) messages. If the program name is
+// `rustc`, the usage message in response to `--llvm-args="--help"` starts with:
+// ```
+//   USAGE: rustc [options]
+// ```
+// followed by the list of options not to `rustc` but to `llvm`.
+//
+// On the other hand, if the program name is set to `rustc -Cllvm-args="..." with`, the usage
+// message is more clear:
+// ```
+//   USAGE: rustc -Cllvm-args="..." with [options]
+// ```
+// This test captures the effect of the current program name setting on LLVM command line
+// error messages.
+fn main() {}
diff --git a/tests/ui/codegen/llvm-args-invalid-flag.stderr b/tests/ui/codegen/llvm-args-invalid-flag.stderr
new file mode 100644
index 00000000000..e1d3cfea28f
--- /dev/null
+++ b/tests/ui/codegen/llvm-args-invalid-flag.stderr
@@ -0,0 +1 @@
+rustc -Cllvm-args="..." with: Unknown command line argument '-not-a-real-llvm-arg'.  Try: 'rustc -Cllvm-args="..." with -help'
\ No newline at end of file
diff --git a/tests/ui/drop/box-drop-unused-value-statement-regression.rs b/tests/ui/drop/box-drop-unused-value-statement-regression.rs
new file mode 100644
index 00000000000..3d5eff2c48d
--- /dev/null
+++ b/tests/ui/drop/box-drop-unused-value-statement-regression.rs
@@ -0,0 +1,12 @@
+//@ run-pass
+// Issue #3878
+// Issue Name: Unused move causes a crash
+// Abstract: zero-fill to block after drop
+
+
+#![allow(path_statements)]
+
+pub fn main() {
+    let y: Box<_> = Box::new(1);
+    y;
+}
diff --git a/tests/ui/expr/syntax-edge-cases-lint-clean.rs b/tests/ui/expr/syntax-edge-cases-lint-clean.rs
new file mode 100644
index 00000000000..7db92d46067
--- /dev/null
+++ b/tests/ui/expr/syntax-edge-cases-lint-clean.rs
@@ -0,0 +1,303 @@
+//@ run-pass
+
+#![feature(coroutines)]
+
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]
+#![allow(redundant_semicolons)]
+#![allow(unreachable_code)]
+#![allow(unused_braces, unused_must_use, unused_parens)]
+#![allow(uncommon_codepoints, confusable_idents)]
+#![allow(unused_imports)]
+#![allow(unreachable_patterns)]
+
+#![recursion_limit = "256"]
+
+extern crate core;
+use std::cell::Cell;
+use std::mem::swap;
+use std::ops::Deref;
+
+// Just a grab bag of stuff that you wouldn't want to actually write.
+
+fn strange() -> bool { let _x: bool = return true; }
+
+fn funny() {
+    fn f(_x: ()) { }
+    f(return);
+}
+
+fn what() {
+    fn the(x: &Cell<bool>) {
+        return while !x.get() { x.set(true); };
+    }
+    let i = &Cell::new(false);
+    let dont = {||the(i)};
+    dont();
+    assert!(i.get());
+}
+
+fn zombiejesus() {
+    loop {
+        while (return) {
+            if (return) {
+                match (return) {
+                    1 => {
+                        if (return) {
+                            return
+                        } else {
+                            return
+                        }
+                    }
+                    _ => { return }
+                };
+            } else if (return) {
+                return;
+            }
+        }
+        if (return) { break; }
+    }
+}
+
+fn notsure() {
+    let mut _x: isize;
+    let mut _y = (_x = 0) == (_x = 0);
+    let mut _z = (_x = 0) < (_x = 0);
+    let _a = (_x += 0) == (_x = 0);
+    let _b = swap(&mut _y, &mut _z) == swap(&mut _y, &mut _z);
+}
+
+fn canttouchthis() -> usize {
+    fn p() -> bool { true }
+    let _a = (assert!(true) == (assert!(p())));
+    let _c = (assert!(p()) == ());
+    let _b: bool = (println!("{}", 0) == (return 0));
+}
+
+fn angrydome() {
+    loop { if break { } }
+    let mut i = 0;
+    loop { i += 1; if i == 1 { match (continue) { 1 => { }, _ => panic!("wat") } }
+      break; }
+}
+
+fn evil_lincoln() { let _evil: () = println!("lincoln"); }
+
+fn dots() {
+    assert_eq!(String::from(".................................................."),
+               format!("{:?}", .. .. .. .. .. .. .. .. .. .. .. .. ..
+                               .. .. .. .. .. .. .. .. .. .. .. ..));
+}
+
+fn u8(u8: u8) {
+    if u8 != 0u8 {
+        assert_eq!(8u8, {
+            macro_rules! u8 {
+                (u8) => {
+                    mod u8 {
+                        pub fn u8<'u8: 'u8 + 'u8>(u8: &'u8 u8) -> &'u8 u8 {
+                            "u8";
+                            u8
+                        }
+                    }
+                };
+            }
+
+            u8!(u8);
+            let &u8: &u8 = u8::u8(&8u8);
+            crate::u8(0u8);
+            u8
+        });
+    }
+}
+
+fn fishy() {
+    assert_eq!(String::from("><>"),
+               String::<>::from::<>("><>").chars::<>().rev::<>().collect::<String>());
+}
+
+fn union() {
+    union union<'union> { union: &'union union<'union>, }
+}
+
+fn special_characters() {
+    let val = !((|(..):(_,_),(|__@_|__)|__)((&*"\\",'🤔')/**/,{})=={&[..=..][..];})//
+    ;
+    assert!(!val);
+}
+
+fn punch_card() -> impl std::fmt::Debug {
+    ..=..=.. ..    .. .. .. ..    .. .. .. ..    .. .. .. ..
+    ..=.. ..=..    .. .. .. ..    .. .. .. ..    .. ..=.. ..
+    ..=.. ..=..    ..=.. ..=..    .. ..=..=..    ..=..=..=..
+    ..=..=.. ..    ..=.. ..=..    ..=.. .. ..    .. ..=.. ..
+    ..=.. ..=..    ..=.. ..=..    .. ..=.. ..    .. ..=.. ..
+    ..=.. ..=..    ..=.. ..=..    .. .. ..=..    .. ..=.. ..
+    ..=.. ..=..    .. ..=..=..    ..=..=.. ..    .. ..=..=..
+}
+
+fn r#match() {
+    let val: () = match match match match match () {
+        () => ()
+    } {
+        () => ()
+    } {
+        () => ()
+    } {
+        () => ()
+    } {
+        () => ()
+    };
+    assert_eq!(val, ());
+}
+
+fn i_yield() {
+    #[coroutine]
+    static || {
+        yield yield yield yield yield yield yield yield yield;
+    };
+}
+
+fn match_nested_if() {
+    let val = match () {
+        () if if if if true {true} else {false} {true} else {false} {true} else {false} => true,
+        _ => false,
+    };
+    assert!(val);
+}
+
+fn monkey_barrel() {
+    let val: () = ()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=();
+    assert_eq!(val, ());
+}
+
+fn 𝚌𝚘𝚗𝚝𝚒𝚗𝚞𝚎() {
+    type 𝚕𝚘𝚘𝚙 = i32;
+    fn 𝚋𝚛𝚎𝚊𝚔() -> 𝚕𝚘𝚘𝚙 {
+        let 𝚛𝚎𝚝𝚞𝚛𝚗 = 42;
+        return 𝚛𝚎𝚝𝚞𝚛𝚗;
+    }
+    assert_eq!(loop {
+        break 𝚋𝚛𝚎𝚊𝚔 ();
+    }, 42);
+}
+
+fn function() {
+    struct foo;
+    impl Deref for foo {
+        type Target = fn() -> Self;
+        fn deref(&self) -> &Self::Target {
+            &((|| foo) as _)
+        }
+    }
+    let foo = foo () ()() ()()() ()()()() ()()()()();
+}
+
+fn bathroom_stall() {
+    let mut i = 1;
+    matches!(2, _|_|_|_|_|_ if (i+=1) != (i+=1));
+    assert_eq!(i, 13);
+}
+
+fn closure_matching() {
+    let x = |_| Some(1);
+    let (|x| x) = match x(..) {
+        |_| Some(2) => |_| Some(3),
+        |_| _ => unreachable!(),
+    };
+    assert!(matches!(x(..), |_| Some(4)));
+}
+
+fn semisemisemisemisemi() {
+    ;;;;;;; ;;;;;;; ;;;    ;;; ;;
+    ;;      ;;      ;;;;  ;;;; ;;
+    ;;;;;;; ;;;;;   ;; ;;;; ;; ;;
+         ;; ;;      ;;  ;;  ;; ;;
+    ;;;;;;; ;;;;;;; ;;      ;; ;;
+}
+
+fn useful_syntax() {
+    use {{std::{{collections::{{HashMap}}}}}};
+    use ::{{{{core}, {std}}}};
+    use {{::{{core as core2}}}};
+}
+
+fn infcx() {
+    pub mod cx {
+        pub mod cx {
+            pub use super::cx;
+            pub struct Cx;
+        }
+    }
+    let _cx: cx::cx::Cx = cx::cx::cx::cx::cx::Cx;
+}
+
+fn return_already() -> impl std::fmt::Debug {
+    loop {
+        return !!!!!!!
+        break !!!!!!1111
+    }
+}
+
+fn fake_macros() -> impl std::fmt::Debug {
+    loop {
+        if! {
+            match! (
+                break! {
+                    return! {
+                        1337
+                    }
+                }
+            )
+
+            {}
+        }
+
+        {}
+    }
+}
+
+fn fish_fight() {
+    trait Rope {
+        fn _____________<U>(_: Self, _: U) where Self: Sized {}
+    }
+
+    struct T;
+
+    impl Rope for T {}
+
+    fn tug_o_war(_: impl Fn(T, T)) {}
+
+    tug_o_war(<T>::_____________::<T>);
+}
+
+pub fn main() {
+    strange();
+    funny();
+    what();
+    zombiejesus();
+    notsure();
+    canttouchthis();
+    angrydome();
+    evil_lincoln();
+    dots();
+    u8(8u8);
+    fishy();
+    union();
+    special_characters();
+    punch_card();
+    r#match();
+    i_yield();
+    match_nested_if();
+    monkey_barrel();
+    𝚌𝚘𝚗𝚝𝚒𝚗𝚞𝚎();
+    function();
+    bathroom_stall();
+    closure_matching();
+    semisemisemisemisemi();
+    useful_syntax();
+    infcx();
+    return_already();
+    fake_macros();
+    fish_fight();
+}
diff --git a/tests/ui/hashmap/hashset-enum-variant.rs b/tests/ui/hashmap/hashset-enum-variant.rs
new file mode 100644
index 00000000000..5795cc527cf
--- /dev/null
+++ b/tests/ui/hashmap/hashset-enum-variant.rs
@@ -0,0 +1,31 @@
+//@ run-pass
+//
+#![allow(dead_code)]
+//@ compile-flags: -O
+
+use std::collections::HashSet;
+
+#[derive(PartialEq, Debug, Hash, Eq, Clone, PartialOrd, Ord)]
+enum MyEnum {
+    E0,
+
+    E1,
+
+    E2,
+    E3,
+    E4,
+
+    E5,
+    E6,
+    E7,
+}
+
+
+fn main() {
+    use MyEnum::*;
+    let s: HashSet<_> = [E4, E1].iter().cloned().collect();
+    let mut v: Vec<_> = s.into_iter().collect();
+    v.sort();
+
+    assert_eq!([E1, E4], &v[..]);
+}
diff --git a/tests/ui/io-checks/write-macro-error.rs b/tests/ui/io-checks/write-macro-error.rs
new file mode 100644
index 00000000000..b48fa3f11cc
--- /dev/null
+++ b/tests/ui/io-checks/write-macro-error.rs
@@ -0,0 +1,55 @@
+//@ run-pass
+//@ needs-unwind
+
+#![feature(io_error_uncategorized)]
+
+use std::fmt;
+use std::io::{self, Error, Write};
+use std::panic::catch_unwind;
+
+struct ErrorDisplay;
+
+impl fmt::Display for ErrorDisplay {
+    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
+        Err(fmt::Error)
+    }
+}
+
+struct ErrorWriter;
+
+const WRITER_ERROR: io::ErrorKind = io::ErrorKind::NotConnected;
+
+impl Write for ErrorWriter {
+    fn write(&mut self, _buf: &[u8]) -> io::Result<usize> {
+        Err(Error::new(WRITER_ERROR, "not connected"))
+    }
+
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+}
+
+fn main() {
+    // Test that an underlying error is propagated
+    let res = write!(ErrorWriter, "abc");
+    assert!(res.is_err(), "writer error did not propagate");
+
+    // Test that the error from the formatter is detected.
+    let res = catch_unwind(|| write!(vec![], "{} {} {}", 1, ErrorDisplay, "bar"));
+    let err = res.expect_err("formatter error did not lead to panic").downcast::<&str>().unwrap();
+    assert!(
+        err.contains("formatting trait implementation returned an error"),
+        "unexpected panic: {}", err
+    );
+
+    // Writer error when there's some string before the first `{}`
+    let res = write!(ErrorWriter, "abc {}", ErrorDisplay);
+    assert!(res.is_err(), "writer error did not propagate");
+    assert_eq!(res.unwrap_err().kind(), WRITER_ERROR);
+
+    // Formatter error when the `{}` comes first
+    let res = catch_unwind(|| write!(ErrorWriter, "{} abc", ErrorDisplay));
+    let err = res.expect_err("formatter error did not lead to panic").downcast::<&str>().unwrap();
+    assert!(
+        err.contains("formatting trait implementation returned an error"),
+        "unexpected panic: {}", err
+    );
+}
diff --git a/tests/ui/lang-items/lang-item-unknown-definition-error.rs b/tests/ui/lang-items/lang-item-unknown-definition-error.rs
new file mode 100644
index 00000000000..ce206d20358
--- /dev/null
+++ b/tests/ui/lang-items/lang-item-unknown-definition-error.rs
@@ -0,0 +1,10 @@
+#![allow(unused)]
+#![feature(lang_items)]
+
+#[lang = "foo"]
+fn bar() -> ! {
+//~^^ ERROR definition of an unknown lang item: `foo`
+    loop {}
+}
+
+fn main() {}
diff --git a/tests/ui/lang-items/lang-item-unknown-definition-error.stderr b/tests/ui/lang-items/lang-item-unknown-definition-error.stderr
new file mode 100644
index 00000000000..832f1342418
--- /dev/null
+++ b/tests/ui/lang-items/lang-item-unknown-definition-error.stderr
@@ -0,0 +1,9 @@
+error[E0522]: definition of an unknown lang item: `foo`
+  --> $DIR/unknown-language-item.rs:4:1
+   |
+LL | #[lang = "foo"]
+   | ^^^^^^^^^^^^^^^ definition of unknown lang item `foo`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0522`.
diff --git a/tests/ui/modules/module-qualified-paths-basic.rs b/tests/ui/modules/module-qualified-paths-basic.rs
new file mode 100644
index 00000000000..d948ffc1520
--- /dev/null
+++ b/tests/ui/modules/module-qualified-paths-basic.rs
@@ -0,0 +1,11 @@
+//@ run-pass
+
+mod foo {
+    pub fn x() -> isize { return 1; }
+}
+
+mod bar {
+    pub fn y() -> isize { return 1; }
+}
+
+pub fn main() { foo::x(); bar::y(); }
diff --git a/tests/ui/modules/module-use-nested-groups.rs b/tests/ui/modules/module-use-nested-groups.rs
new file mode 100644
index 00000000000..c5d66a86935
--- /dev/null
+++ b/tests/ui/modules/module-use-nested-groups.rs
@@ -0,0 +1,32 @@
+//@ run-pass
+
+mod a {
+    pub enum B {}
+
+    pub mod d {
+        pub enum E {}
+        pub enum F {}
+
+        pub mod g {
+            pub enum H {}
+            pub enum I {}
+        }
+    }
+}
+
+// Test every possible part of the syntax
+use a::{B, d::{self, *, g::H}};
+
+// Test a more common use case
+use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
+
+fn main() {
+    let _: B;
+    let _: E;
+    let _: F;
+    let _: H;
+    let _: d::g::I;
+
+    let _: Arc<AtomicBool>;
+    let _: Ordering;
+}
diff --git a/tests/ui/modules/primitive-type-module-deprecated-paths.rs b/tests/ui/modules/primitive-type-module-deprecated-paths.rs
new file mode 100644
index 00000000000..6e8c7053c57
--- /dev/null
+++ b/tests/ui/modules/primitive-type-module-deprecated-paths.rs
@@ -0,0 +1,12 @@
+//@ run-pass
+
+// Make sure the module level constants are still there and accessible even after
+// the corresponding associated constants have been added, and later stabilized.
+#![allow(deprecated, deprecated_in_future)]
+use std::{u16, f32};
+
+fn main() {
+    let _ = u16::MAX;
+    let _ = f32::EPSILON;
+    let _ = std::f64::MANTISSA_DIGITS;
+}
diff --git a/tests/ui/modules/use-keyword-reexport-type-alias.rs b/tests/ui/modules/use-keyword-reexport-type-alias.rs
new file mode 100644
index 00000000000..4f3d1ee500d
--- /dev/null
+++ b/tests/ui/modules/use-keyword-reexport-type-alias.rs
@@ -0,0 +1,23 @@
+//@ run-pass
+
+#![allow(unused_variables)]
+pub struct A;
+
+mod test {
+    pub use super :: A;
+
+    pub use self :: A as B;
+}
+
+impl A {
+    fn f() {}
+    fn g() {
+        Self :: f()
+    }
+}
+
+fn main() {
+    let a: A = test::A;
+    let b: A = test::B;
+    let c: () = A::g();
+}
diff --git a/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs
new file mode 100644
index 00000000000..943c7f79742
--- /dev/null
+++ b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs
@@ -0,0 +1,5 @@
+fn main() {
+    let x = -1 as usize; //~ ERROR: cannot apply unary operator `-`
+    let x = (-1) as usize; //~ ERROR: cannot apply unary operator `-`
+    let x: u32 = -1; //~ ERROR: cannot apply unary operator `-`
+}
diff --git a/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr
new file mode 100644
index 00000000000..0bedbc1accd
--- /dev/null
+++ b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr
@@ -0,0 +1,42 @@
+error[E0600]: cannot apply unary operator `-` to type `usize`
+  --> $DIR/unsigned-literal-negation.rs:2:13
+   |
+LL |     let x = -1 as usize;
+   |             ^^ cannot apply unary operator `-`
+   |
+   = note: unsigned values cannot be negated
+help: you may have meant the maximum value of `usize`
+   |
+LL -     let x = -1 as usize;
+LL +     let x = usize::MAX;
+   |
+
+error[E0600]: cannot apply unary operator `-` to type `usize`
+  --> $DIR/unsigned-literal-negation.rs:3:13
+   |
+LL |     let x = (-1) as usize;
+   |             ^^^^ cannot apply unary operator `-`
+   |
+   = note: unsigned values cannot be negated
+help: you may have meant the maximum value of `usize`
+   |
+LL -     let x = (-1) as usize;
+LL +     let x = usize::MAX;
+   |
+
+error[E0600]: cannot apply unary operator `-` to type `u32`
+  --> $DIR/unsigned-literal-negation.rs:4:18
+   |
+LL |     let x: u32 = -1;
+   |                  ^^ cannot apply unary operator `-`
+   |
+   = note: unsigned values cannot be negated
+help: you may have meant the maximum value of `u32`
+   |
+LL -     let x: u32 = -1;
+LL +     let x: u32 = u32::MAX;
+   |
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0600`.
diff --git a/tests/ui/panics/unwind-force-no-unwind-tables.rs b/tests/ui/panics/unwind-force-no-unwind-tables.rs
new file mode 100644
index 00000000000..fb8082e3188
--- /dev/null
+++ b/tests/ui/panics/unwind-force-no-unwind-tables.rs
@@ -0,0 +1,34 @@
+//@ run-pass
+//@ needs-unwind
+//@ ignore-windows target requires uwtable
+//@ compile-flags: -C panic=unwind -C force-unwind-tables=n
+
+use std::panic::{self, AssertUnwindSafe};
+
+struct Increase<'a>(&'a mut u8);
+
+impl Drop for Increase<'_> {
+    fn drop(&mut self) {
+        *self.0 += 1;
+    }
+}
+
+#[inline(never)]
+fn unwind() {
+    panic!();
+}
+
+#[inline(never)]
+fn increase(count: &mut u8) {
+    let _increase = Increase(count);
+    unwind();
+}
+
+fn main() {
+    let mut count = 0;
+    assert!(panic::catch_unwind(AssertUnwindSafe(
+        #[inline(never)]
+        || increase(&mut count)
+    )).is_err());
+    assert_eq!(count, 1);
+}
diff --git a/tests/ui/process/process-spawn-failure.rs b/tests/ui/process/process-spawn-failure.rs
new file mode 100644
index 00000000000..4a7f2bee9d9
--- /dev/null
+++ b/tests/ui/process/process-spawn-failure.rs
@@ -0,0 +1,71 @@
+//@ run-pass
+//@ needs-subprocess
+//@ ignore-vxworks no 'ps'
+//@ ignore-fuchsia no 'ps'
+//@ ignore-nto no 'ps'
+
+#![feature(rustc_private)]
+
+use std::process::Command;
+
+// The output from "ps -A -o pid,ppid,args" should look like this:
+//   PID  PPID COMMAND
+//     1     0 /sbin/init
+//     2     0 [kthreadd]
+// ...
+//  6076  9064 /bin/zsh
+// ...
+//  7164  6076 ./spawn-failure
+//  7165  7164 [spawn-failure] <defunct>
+//  7166  7164 [spawn-failure] <defunct>
+// ...
+//  7197  7164 [spawn-failure] <defunct>
+//  7198  7164 ps -A -o pid,ppid,command
+// ...
+
+#[cfg(unix)]
+fn find_zombies() {
+    extern crate libc;
+    let my_pid = unsafe { libc::getpid() };
+
+    // https://pubs.opengroup.org/onlinepubs/9699919799/utilities/ps.html
+    let ps_cmd_output = Command::new("ps").args(&["-A", "-o", "pid,ppid,args"]).output().unwrap();
+    let ps_output = String::from_utf8_lossy(&ps_cmd_output.stdout);
+    // On AIX, the PPID is not always present, such as when a process is blocked
+    // (marked as <exiting>), or if a process is idle. In these situations,
+    // the PPID column contains a "-" for the respective process.
+    // Filter out any lines that have a "-" as the PPID as the PPID is
+    // expected to be an integer.
+    let filtered_ps: Vec<_> = ps_output
+        .lines()
+        .filter(|line| line.split_whitespace().nth(1) != Some("-"))
+        .collect();
+
+    for (line_no, line) in filtered_ps.into_iter().enumerate() {
+        if 0 < line_no && 0 < line.len() &&
+           my_pid == line.split(' ').filter(|w| 0 < w.len()).nth(1)
+                         .expect("1st column should be PPID")
+                         .parse().ok()
+                         .expect("PPID string into integer") &&
+           line.contains("defunct") {
+            panic!("Zombie child {}", line);
+        }
+    }
+}
+
+#[cfg(windows)]
+fn find_zombies() { }
+
+fn main() {
+    let too_long = format!("/NoSuchCommand{:0300}", 0u8);
+
+    let _failures = (0..100).map(|_| {
+        let mut cmd = Command::new(&too_long);
+        let failed = cmd.spawn();
+        assert!(failed.is_err(), "Make sure the command fails to spawn(): {:?}", cmd);
+        failed
+    }).collect::<Vec<_>>();
+
+    find_zombies();
+    // then _failures goes out of scope
+}
diff --git a/tests/ui/process/windows-exit-code-still-active.rs b/tests/ui/process/windows-exit-code-still-active.rs
new file mode 100644
index 00000000000..e016343f8ba
--- /dev/null
+++ b/tests/ui/process/windows-exit-code-still-active.rs
@@ -0,0 +1,28 @@
+//@ run-pass
+// On Windows the GetExitCodeProcess API is used to get the exit code of a
+// process, but it's easy to mistake a process exiting with the code 259 as
+// "still running" because this is the value of the STILL_ACTIVE constant. Make
+// sure we handle this case in the standard library and correctly report the
+// status.
+//
+// Note that this is disabled on unix as processes exiting with 259 will have
+// their exit status truncated to 3 (only the lower 8 bits are used).
+
+#[cfg(windows)]
+fn main() {
+    use std::process::{self, Command};
+    use std::env;
+
+    if env::args().len() == 1 {
+        let status = Command::new(env::current_exe().unwrap())
+                             .arg("foo")
+                             .status()
+                             .unwrap();
+        assert_eq!(status.code(), Some(259));
+    } else {
+        process::exit(259);
+    }
+}
+
+#[cfg(not(windows))]
+fn main() {}
diff --git a/tests/ui/reachable/diverging-expressions-unreachable-code.rs b/tests/ui/reachable/diverging-expressions-unreachable-code.rs
new file mode 100644
index 00000000000..9c5f7c8f451
--- /dev/null
+++ b/tests/ui/reachable/diverging-expressions-unreachable-code.rs
@@ -0,0 +1,19 @@
+//@ run-pass
+
+#![allow(unused_must_use)]
+#![allow(unreachable_code)]
+
+#![allow(unused_variables)]
+#![allow(dead_code)]
+
+fn id(x: bool) -> bool { x }
+
+fn call_id() {
+    let c = panic!();
+    id(c);
+}
+
+fn call_id_3() { id(return) && id(return); }
+
+pub fn main() {
+}
diff --git a/tests/ui/reachable/unreachable-code-diverging-expressions.rs b/tests/ui/reachable/unreachable-code-diverging-expressions.rs
new file mode 100644
index 00000000000..0c46a38d73f
--- /dev/null
+++ b/tests/ui/reachable/unreachable-code-diverging-expressions.rs
@@ -0,0 +1,35 @@
+//@ run-pass
+
+#![allow(unused_must_use)]
+#![allow(dead_code)]
+#![allow(path_statements)]
+#![allow(unreachable_code)]
+#![allow(unused_variables)]
+#![feature(if_let_guard)]
+
+fn id(x: bool) -> bool {
+    x
+}
+
+fn call_id() {
+    let c = panic!();
+    id(c);
+}
+
+fn call_id_2() {
+    id(true) && id(return);
+}
+
+fn call_id_3() {
+    id(return) && id(return);
+}
+
+fn ret_guard() {
+    match 2 {
+      x if (return) => { x; }
+      x if let true = return => { x; }
+      _ => {}
+    }
+}
+
+pub fn main() {}
diff --git a/tests/ui/traits/virtual-call-parameter-handling.rs b/tests/ui/traits/virtual-call-parameter-handling.rs
new file mode 100644
index 00000000000..e80bd5768a4
--- /dev/null
+++ b/tests/ui/traits/virtual-call-parameter-handling.rs
@@ -0,0 +1,45 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/137646.
+//! The parameter value at all calls to `check` should be `(1, 1, 1)`.
+
+//@ run-pass
+
+use std::hint::black_box;
+
+type T = (i32, i32, i32);
+
+pub trait Trait {
+    fn m(&self, _: T, _: T) {}
+}
+
+impl Trait for () {
+    fn m(&self, mut _v1: T, v2: T) {
+        _v1 = (0, 0, 0);
+        check(v2);
+    }
+}
+
+pub fn run_1(trait_: &dyn Trait) {
+    let v1 = (1, 1, 1);
+    let v2 = (1, 1, 1);
+    trait_.m(v1, v2);
+}
+
+pub fn run_2(trait_: &dyn Trait) {
+    let v1 = (1, 1, 1);
+    let v2 = (1, 1, 1);
+    trait_.m(v1, v2);
+    check(v1);
+    check(v2);
+}
+
+#[inline(never)]
+fn check(v: T) {
+    assert_eq!(v, (1, 1, 1));
+}
+
+fn main() {
+    black_box(run_1 as fn(&dyn Trait));
+    black_box(run_2 as fn(&dyn Trait));
+    run_1(&());
+    run_2(&());
+}
diff --git a/tests/ui/type/unit-type-basic-usages.rs b/tests/ui/type/unit-type-basic-usages.rs
new file mode 100644
index 00000000000..04404fc3f5e
--- /dev/null
+++ b/tests/ui/type/unit-type-basic-usages.rs
@@ -0,0 +1,16 @@
+//@ run-pass
+
+#![allow(unused_assignments)]
+#![allow(unknown_lints)]
+
+#![allow(unused_variables)]
+#![allow(dead_assignment)]
+
+fn f(u: ()) { return u; }
+
+pub fn main() {
+    let u1: () = ();
+    let mut u2: () = f(u1);
+    u2 = ();
+    return ();
+}
diff --git a/tests/ui/type/usize-no-generic-arguments.rs b/tests/ui/type/usize-no-generic-arguments.rs
new file mode 100644
index 00000000000..4ab80d944a5
--- /dev/null
+++ b/tests/ui/type/usize-no-generic-arguments.rs
@@ -0,0 +1,5 @@
+fn foo() {
+    let x: usize<foo>; //~ ERROR const arguments are not allowed on builtin type `usize`
+}
+
+fn main() {}
diff --git a/tests/ui/type/usize-no-generic-arguments.stderr b/tests/ui/type/usize-no-generic-arguments.stderr
new file mode 100644
index 00000000000..9c081a287ed
--- /dev/null
+++ b/tests/ui/type/usize-no-generic-arguments.stderr
@@ -0,0 +1,17 @@
+error[E0109]: const arguments are not allowed on builtin type `usize`
+  --> $DIR/usize-generic-argument-parent.rs:2:18
+   |
+LL |     let x: usize<foo>;
+   |            ----- ^^^ const argument not allowed
+   |            |
+   |            not allowed on builtin type `usize`
+   |
+help: primitive type `usize` doesn't have generic parameters
+   |
+LL -     let x: usize<foo>;
+LL +     let x: usize;
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0109`.
diff --git a/tests/ui/uninit-empty-types.rs b/tests/ui/uninit-empty-types.rs
deleted file mode 100644
index 82474d873b7..00000000000
--- a/tests/ui/uninit-empty-types.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ build-pass
-// Test the uninit() construct returning various empty types.
-
-
-use std::mem::MaybeUninit;
-
-struct Foo;
-
-#[allow(deprecated)]
-pub fn main() {
-    unsafe {
-        // `Foo` and `[Foo; 2]` are both zero sized and inhabited, so this is safe.
-        let _x: Foo = MaybeUninit::uninit().assume_init();
-        let _x: [Foo; 2] = MaybeUninit::uninit().assume_init();
-        let _x: Foo = std::mem::uninitialized();
-        let _x: [Foo; 2] = std::mem::uninitialized();
-    }
-}
diff --git a/tests/ui/unit.rs b/tests/ui/unit.rs
deleted file mode 100644
index 04404fc3f5e..00000000000
--- a/tests/ui/unit.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ run-pass
-
-#![allow(unused_assignments)]
-#![allow(unknown_lints)]
-
-#![allow(unused_variables)]
-#![allow(dead_assignment)]
-
-fn f(u: ()) { return u; }
-
-pub fn main() {
-    let u1: () = ();
-    let mut u2: () = f(u1);
-    u2 = ();
-    return ();
-}
diff --git a/tests/ui/unknown-language-item.rs b/tests/ui/unknown-language-item.rs
deleted file mode 100644
index ce206d20358..00000000000
--- a/tests/ui/unknown-language-item.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![allow(unused)]
-#![feature(lang_items)]
-
-#[lang = "foo"]
-fn bar() -> ! {
-//~^^ ERROR definition of an unknown lang item: `foo`
-    loop {}
-}
-
-fn main() {}
diff --git a/tests/ui/unknown-language-item.stderr b/tests/ui/unknown-language-item.stderr
deleted file mode 100644
index 832f1342418..00000000000
--- a/tests/ui/unknown-language-item.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0522]: definition of an unknown lang item: `foo`
-  --> $DIR/unknown-language-item.rs:4:1
-   |
-LL | #[lang = "foo"]
-   | ^^^^^^^^^^^^^^^ definition of unknown lang item `foo`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0522`.
diff --git a/tests/ui/unknown-llvm-arg.rs b/tests/ui/unknown-llvm-arg.rs
deleted file mode 100644
index a8fa55a220a..00000000000
--- a/tests/ui/unknown-llvm-arg.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//@ compile-flags: -Cllvm-args=-not-a-real-llvm-arg
-//@ normalize-stderr: "--help" -> "-help"
-//@ normalize-stderr: "\n(\n|.)*" -> ""
-
-// I'm seeing "--help" locally, but "-help" in CI, so I'm normalizing it to just "-help".
-
-// Note that the rustc-supplied "program name", given when invoking LLVM, is used by LLVM to
-// generate user-facing error messages and a usage (--help) messages. If the program name is
-// `rustc`, the usage message in response to `--llvm-args="--help"` starts with:
-// ```
-//   USAGE: rustc [options]
-// ```
-// followed by the list of options not to `rustc` but to `llvm`.
-//
-// On the other hand, if the program name is set to `rustc -Cllvm-args="..." with`, the usage
-// message is more clear:
-// ```
-//   USAGE: rustc -Cllvm-args="..." with [options]
-// ```
-// This test captures the effect of the current program name setting on LLVM command line
-// error messages.
-fn main() {}
diff --git a/tests/ui/unknown-llvm-arg.stderr b/tests/ui/unknown-llvm-arg.stderr
deleted file mode 100644
index e1d3cfea28f..00000000000
--- a/tests/ui/unknown-llvm-arg.stderr
+++ /dev/null
@@ -1 +0,0 @@
-rustc -Cllvm-args="..." with: Unknown command line argument '-not-a-real-llvm-arg'.  Try: 'rustc -Cllvm-args="..." with -help'
\ No newline at end of file
diff --git a/tests/ui/unnamed_argument_mode.rs b/tests/ui/unnamed_argument_mode.rs
deleted file mode 100644
index 2014e0d23d8..00000000000
--- a/tests/ui/unnamed_argument_mode.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ run-pass
-
-fn good(_a: &isize) {
-}
-
-// unnamed argument &isize is now parse x: &isize
-
-fn called<F>(_f: F) where F: FnOnce(&isize) {
-}
-
-pub fn main() {
-    called(good);
-}
diff --git a/tests/ui/unreachable-code-1.rs b/tests/ui/unreachable-code-1.rs
deleted file mode 100644
index 9c5f7c8f451..00000000000
--- a/tests/ui/unreachable-code-1.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ run-pass
-
-#![allow(unused_must_use)]
-#![allow(unreachable_code)]
-
-#![allow(unused_variables)]
-#![allow(dead_code)]
-
-fn id(x: bool) -> bool { x }
-
-fn call_id() {
-    let c = panic!();
-    id(c);
-}
-
-fn call_id_3() { id(return) && id(return); }
-
-pub fn main() {
-}
diff --git a/tests/ui/unreachable-code.rs b/tests/ui/unreachable-code.rs
deleted file mode 100644
index 0c46a38d73f..00000000000
--- a/tests/ui/unreachable-code.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ run-pass
-
-#![allow(unused_must_use)]
-#![allow(dead_code)]
-#![allow(path_statements)]
-#![allow(unreachable_code)]
-#![allow(unused_variables)]
-#![feature(if_let_guard)]
-
-fn id(x: bool) -> bool {
-    x
-}
-
-fn call_id() {
-    let c = panic!();
-    id(c);
-}
-
-fn call_id_2() {
-    id(true) && id(return);
-}
-
-fn call_id_3() {
-    id(return) && id(return);
-}
-
-fn ret_guard() {
-    match 2 {
-      x if (return) => { x; }
-      x if let true = return => { x; }
-      _ => {}
-    }
-}
-
-pub fn main() {}
diff --git a/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs b/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs
new file mode 100644
index 00000000000..82474d873b7
--- /dev/null
+++ b/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs
@@ -0,0 +1,18 @@
+//@ build-pass
+// Test the uninit() construct returning various empty types.
+
+
+use std::mem::MaybeUninit;
+
+struct Foo;
+
+#[allow(deprecated)]
+pub fn main() {
+    unsafe {
+        // `Foo` and `[Foo; 2]` are both zero sized and inhabited, so this is safe.
+        let _x: Foo = MaybeUninit::uninit().assume_init();
+        let _x: [Foo; 2] = MaybeUninit::uninit().assume_init();
+        let _x: Foo = std::mem::uninitialized();
+        let _x: [Foo; 2] = std::mem::uninitialized();
+    }
+}
diff --git a/tests/ui/unsigned-literal-negation.rs b/tests/ui/unsigned-literal-negation.rs
deleted file mode 100644
index 943c7f79742..00000000000
--- a/tests/ui/unsigned-literal-negation.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn main() {
-    let x = -1 as usize; //~ ERROR: cannot apply unary operator `-`
-    let x = (-1) as usize; //~ ERROR: cannot apply unary operator `-`
-    let x: u32 = -1; //~ ERROR: cannot apply unary operator `-`
-}
diff --git a/tests/ui/unsigned-literal-negation.stderr b/tests/ui/unsigned-literal-negation.stderr
deleted file mode 100644
index 0bedbc1accd..00000000000
--- a/tests/ui/unsigned-literal-negation.stderr
+++ /dev/null
@@ -1,42 +0,0 @@
-error[E0600]: cannot apply unary operator `-` to type `usize`
-  --> $DIR/unsigned-literal-negation.rs:2:13
-   |
-LL |     let x = -1 as usize;
-   |             ^^ cannot apply unary operator `-`
-   |
-   = note: unsigned values cannot be negated
-help: you may have meant the maximum value of `usize`
-   |
-LL -     let x = -1 as usize;
-LL +     let x = usize::MAX;
-   |
-
-error[E0600]: cannot apply unary operator `-` to type `usize`
-  --> $DIR/unsigned-literal-negation.rs:3:13
-   |
-LL |     let x = (-1) as usize;
-   |             ^^^^ cannot apply unary operator `-`
-   |
-   = note: unsigned values cannot be negated
-help: you may have meant the maximum value of `usize`
-   |
-LL -     let x = (-1) as usize;
-LL +     let x = usize::MAX;
-   |
-
-error[E0600]: cannot apply unary operator `-` to type `u32`
-  --> $DIR/unsigned-literal-negation.rs:4:18
-   |
-LL |     let x: u32 = -1;
-   |                  ^^ cannot apply unary operator `-`
-   |
-   = note: unsigned values cannot be negated
-help: you may have meant the maximum value of `u32`
-   |
-LL -     let x: u32 = -1;
-LL +     let x: u32 = u32::MAX;
-   |
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0600`.
diff --git a/tests/ui/unused-move-capture.rs b/tests/ui/unused-move-capture.rs
deleted file mode 100644
index 5f42bcbe280..00000000000
--- a/tests/ui/unused-move-capture.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ run-pass
-
-pub fn main() {
-    let _x: Box<_> = Box::new(1);
-    let lam_move = || {};
-    lam_move();
-}
diff --git a/tests/ui/unused-move.rs b/tests/ui/unused-move.rs
deleted file mode 100644
index 3d5eff2c48d..00000000000
--- a/tests/ui/unused-move.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ run-pass
-// Issue #3878
-// Issue Name: Unused move causes a crash
-// Abstract: zero-fill to block after drop
-
-
-#![allow(path_statements)]
-
-pub fn main() {
-    let y: Box<_> = Box::new(1);
-    y;
-}
diff --git a/tests/ui/unwind-no-uwtable.rs b/tests/ui/unwind-no-uwtable.rs
deleted file mode 100644
index fb8082e3188..00000000000
--- a/tests/ui/unwind-no-uwtable.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//@ run-pass
-//@ needs-unwind
-//@ ignore-windows target requires uwtable
-//@ compile-flags: -C panic=unwind -C force-unwind-tables=n
-
-use std::panic::{self, AssertUnwindSafe};
-
-struct Increase<'a>(&'a mut u8);
-
-impl Drop for Increase<'_> {
-    fn drop(&mut self) {
-        *self.0 += 1;
-    }
-}
-
-#[inline(never)]
-fn unwind() {
-    panic!();
-}
-
-#[inline(never)]
-fn increase(count: &mut u8) {
-    let _increase = Increase(count);
-    unwind();
-}
-
-fn main() {
-    let mut count = 0;
-    assert!(panic::catch_unwind(AssertUnwindSafe(
-        #[inline(never)]
-        || increase(&mut count)
-    )).is_err());
-    assert_eq!(count, 1);
-}
diff --git a/tests/ui/use-import-export.rs b/tests/ui/use-import-export.rs
deleted file mode 100644
index d948ffc1520..00000000000
--- a/tests/ui/use-import-export.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ run-pass
-
-mod foo {
-    pub fn x() -> isize { return 1; }
-}
-
-mod bar {
-    pub fn y() -> isize { return 1; }
-}
-
-pub fn main() { foo::x(); bar::y(); }
diff --git a/tests/ui/use-keyword-2.rs b/tests/ui/use-keyword-2.rs
deleted file mode 100644
index 4f3d1ee500d..00000000000
--- a/tests/ui/use-keyword-2.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ run-pass
-
-#![allow(unused_variables)]
-pub struct A;
-
-mod test {
-    pub use super :: A;
-
-    pub use self :: A as B;
-}
-
-impl A {
-    fn f() {}
-    fn g() {
-        Self :: f()
-    }
-}
-
-fn main() {
-    let a: A = test::A;
-    let b: A = test::B;
-    let c: () = A::g();
-}
diff --git a/tests/ui/use-module-level-int-consts.rs b/tests/ui/use-module-level-int-consts.rs
deleted file mode 100644
index 6e8c7053c57..00000000000
--- a/tests/ui/use-module-level-int-consts.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ run-pass
-
-// Make sure the module level constants are still there and accessible even after
-// the corresponding associated constants have been added, and later stabilized.
-#![allow(deprecated, deprecated_in_future)]
-use std::{u16, f32};
-
-fn main() {
-    let _ = u16::MAX;
-    let _ = f32::EPSILON;
-    let _ = std::f64::MANTISSA_DIGITS;
-}
diff --git a/tests/ui/use-nested-groups.rs b/tests/ui/use-nested-groups.rs
deleted file mode 100644
index c5d66a86935..00000000000
--- a/tests/ui/use-nested-groups.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ run-pass
-
-mod a {
-    pub enum B {}
-
-    pub mod d {
-        pub enum E {}
-        pub enum F {}
-
-        pub mod g {
-            pub enum H {}
-            pub enum I {}
-        }
-    }
-}
-
-// Test every possible part of the syntax
-use a::{B, d::{self, *, g::H}};
-
-// Test a more common use case
-use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
-
-fn main() {
-    let _: B;
-    let _: E;
-    let _: F;
-    let _: H;
-    let _: d::g::I;
-
-    let _: Arc<AtomicBool>;
-    let _: Ordering;
-}
diff --git a/tests/ui/usize-generic-argument-parent.rs b/tests/ui/usize-generic-argument-parent.rs
deleted file mode 100644
index 4ab80d944a5..00000000000
--- a/tests/ui/usize-generic-argument-parent.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn foo() {
-    let x: usize<foo>; //~ ERROR const arguments are not allowed on builtin type `usize`
-}
-
-fn main() {}
diff --git a/tests/ui/usize-generic-argument-parent.stderr b/tests/ui/usize-generic-argument-parent.stderr
deleted file mode 100644
index 9c081a287ed..00000000000
--- a/tests/ui/usize-generic-argument-parent.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error[E0109]: const arguments are not allowed on builtin type `usize`
-  --> $DIR/usize-generic-argument-parent.rs:2:18
-   |
-LL |     let x: usize<foo>;
-   |            ----- ^^^ const argument not allowed
-   |            |
-   |            not allowed on builtin type `usize`
-   |
-help: primitive type `usize` doesn't have generic parameters
-   |
-LL -     let x: usize<foo>;
-LL +     let x: usize;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0109`.
diff --git a/tests/ui/virtual-call-attrs-issue-137646.rs b/tests/ui/virtual-call-attrs-issue-137646.rs
deleted file mode 100644
index e80bd5768a4..00000000000
--- a/tests/ui/virtual-call-attrs-issue-137646.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//! Regression test for https://github.com/rust-lang/rust/issues/137646.
-//! The parameter value at all calls to `check` should be `(1, 1, 1)`.
-
-//@ run-pass
-
-use std::hint::black_box;
-
-type T = (i32, i32, i32);
-
-pub trait Trait {
-    fn m(&self, _: T, _: T) {}
-}
-
-impl Trait for () {
-    fn m(&self, mut _v1: T, v2: T) {
-        _v1 = (0, 0, 0);
-        check(v2);
-    }
-}
-
-pub fn run_1(trait_: &dyn Trait) {
-    let v1 = (1, 1, 1);
-    let v2 = (1, 1, 1);
-    trait_.m(v1, v2);
-}
-
-pub fn run_2(trait_: &dyn Trait) {
-    let v1 = (1, 1, 1);
-    let v2 = (1, 1, 1);
-    trait_.m(v1, v2);
-    check(v1);
-    check(v2);
-}
-
-#[inline(never)]
-fn check(v: T) {
-    assert_eq!(v, (1, 1, 1));
-}
-
-fn main() {
-    black_box(run_1 as fn(&dyn Trait));
-    black_box(run_2 as fn(&dyn Trait));
-    run_1(&());
-    run_2(&());
-}
diff --git a/tests/ui/wait-forked-but-failed-child.rs b/tests/ui/wait-forked-but-failed-child.rs
deleted file mode 100644
index 4a7f2bee9d9..00000000000
--- a/tests/ui/wait-forked-but-failed-child.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-//@ run-pass
-//@ needs-subprocess
-//@ ignore-vxworks no 'ps'
-//@ ignore-fuchsia no 'ps'
-//@ ignore-nto no 'ps'
-
-#![feature(rustc_private)]
-
-use std::process::Command;
-
-// The output from "ps -A -o pid,ppid,args" should look like this:
-//   PID  PPID COMMAND
-//     1     0 /sbin/init
-//     2     0 [kthreadd]
-// ...
-//  6076  9064 /bin/zsh
-// ...
-//  7164  6076 ./spawn-failure
-//  7165  7164 [spawn-failure] <defunct>
-//  7166  7164 [spawn-failure] <defunct>
-// ...
-//  7197  7164 [spawn-failure] <defunct>
-//  7198  7164 ps -A -o pid,ppid,command
-// ...
-
-#[cfg(unix)]
-fn find_zombies() {
-    extern crate libc;
-    let my_pid = unsafe { libc::getpid() };
-
-    // https://pubs.opengroup.org/onlinepubs/9699919799/utilities/ps.html
-    let ps_cmd_output = Command::new("ps").args(&["-A", "-o", "pid,ppid,args"]).output().unwrap();
-    let ps_output = String::from_utf8_lossy(&ps_cmd_output.stdout);
-    // On AIX, the PPID is not always present, such as when a process is blocked
-    // (marked as <exiting>), or if a process is idle. In these situations,
-    // the PPID column contains a "-" for the respective process.
-    // Filter out any lines that have a "-" as the PPID as the PPID is
-    // expected to be an integer.
-    let filtered_ps: Vec<_> = ps_output
-        .lines()
-        .filter(|line| line.split_whitespace().nth(1) != Some("-"))
-        .collect();
-
-    for (line_no, line) in filtered_ps.into_iter().enumerate() {
-        if 0 < line_no && 0 < line.len() &&
-           my_pid == line.split(' ').filter(|w| 0 < w.len()).nth(1)
-                         .expect("1st column should be PPID")
-                         .parse().ok()
-                         .expect("PPID string into integer") &&
-           line.contains("defunct") {
-            panic!("Zombie child {}", line);
-        }
-    }
-}
-
-#[cfg(windows)]
-fn find_zombies() { }
-
-fn main() {
-    let too_long = format!("/NoSuchCommand{:0300}", 0u8);
-
-    let _failures = (0..100).map(|_| {
-        let mut cmd = Command::new(&too_long);
-        let failed = cmd.spawn();
-        assert!(failed.is_err(), "Make sure the command fails to spawn(): {:?}", cmd);
-        failed
-    }).collect::<Vec<_>>();
-
-    find_zombies();
-    // then _failures goes out of scope
-}
diff --git a/tests/ui/walk-struct-literal-with.rs b/tests/ui/walk-struct-literal-with.rs
deleted file mode 100644
index ee1a77eb9a4..00000000000
--- a/tests/ui/walk-struct-literal-with.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-struct Mine{
-    test: String,
-    other_val: isize
-}
-
-impl Mine{
-    fn make_string_bar(mut self) -> Mine{
-        self.test = "Bar".to_string();
-        self
-    }
-}
-
-fn main(){
-    let start = Mine{test:"Foo".to_string(), other_val:0};
-    let end = Mine{other_val:1, ..start.make_string_bar()};
-    println!("{}", start.test); //~ ERROR borrow of moved value: `start`
-}
diff --git a/tests/ui/walk-struct-literal-with.stderr b/tests/ui/walk-struct-literal-with.stderr
deleted file mode 100644
index 34b501f8ec8..00000000000
--- a/tests/ui/walk-struct-literal-with.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error[E0382]: borrow of moved value: `start`
-  --> $DIR/walk-struct-literal-with.rs:16:20
-   |
-LL |     let start = Mine{test:"Foo".to_string(), other_val:0};
-   |         ----- move occurs because `start` has type `Mine`, which does not implement the `Copy` trait
-LL |     let end = Mine{other_val:1, ..start.make_string_bar()};
-   |                                         ----------------- `start` moved due to this method call
-LL |     println!("{}", start.test);
-   |                    ^^^^^^^^^^ value borrowed here after move
-   |
-note: `Mine::make_string_bar` takes ownership of the receiver `self`, which moves `start`
-  --> $DIR/walk-struct-literal-with.rs:7:28
-   |
-LL |     fn make_string_bar(mut self) -> Mine{
-   |                            ^^^^
-   = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (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 E0382`.
diff --git a/tests/ui/weak-new-uninhabited-issue-48493.rs b/tests/ui/weak-new-uninhabited-issue-48493.rs
deleted file mode 100644
index ce7d5786b41..00000000000
--- a/tests/ui/weak-new-uninhabited-issue-48493.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ run-pass
-
-fn main() {
-    enum Void {}
-    let _ = std::rc::Weak::<Void>::new();
-    let _ = std::sync::Weak::<Void>::new();
-}
diff --git a/tests/ui/weird-exit-code.rs b/tests/ui/weird-exit-code.rs
deleted file mode 100644
index e016343f8ba..00000000000
--- a/tests/ui/weird-exit-code.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ run-pass
-// On Windows the GetExitCodeProcess API is used to get the exit code of a
-// process, but it's easy to mistake a process exiting with the code 259 as
-// "still running" because this is the value of the STILL_ACTIVE constant. Make
-// sure we handle this case in the standard library and correctly report the
-// status.
-//
-// Note that this is disabled on unix as processes exiting with 259 will have
-// their exit status truncated to 3 (only the lower 8 bits are used).
-
-#[cfg(windows)]
-fn main() {
-    use std::process::{self, Command};
-    use std::env;
-
-    if env::args().len() == 1 {
-        let status = Command::new(env::current_exe().unwrap())
-                             .arg("foo")
-                             .status()
-                             .unwrap();
-        assert_eq!(status.code(), Some(259));
-    } else {
-        process::exit(259);
-    }
-}
-
-#[cfg(not(windows))]
-fn main() {}
diff --git a/tests/ui/weird-exprs.rs b/tests/ui/weird-exprs.rs
deleted file mode 100644
index 7db92d46067..00000000000
--- a/tests/ui/weird-exprs.rs
+++ /dev/null
@@ -1,303 +0,0 @@
-//@ run-pass
-
-#![feature(coroutines)]
-
-#![allow(non_camel_case_types)]
-#![allow(dead_code)]
-#![allow(redundant_semicolons)]
-#![allow(unreachable_code)]
-#![allow(unused_braces, unused_must_use, unused_parens)]
-#![allow(uncommon_codepoints, confusable_idents)]
-#![allow(unused_imports)]
-#![allow(unreachable_patterns)]
-
-#![recursion_limit = "256"]
-
-extern crate core;
-use std::cell::Cell;
-use std::mem::swap;
-use std::ops::Deref;
-
-// Just a grab bag of stuff that you wouldn't want to actually write.
-
-fn strange() -> bool { let _x: bool = return true; }
-
-fn funny() {
-    fn f(_x: ()) { }
-    f(return);
-}
-
-fn what() {
-    fn the(x: &Cell<bool>) {
-        return while !x.get() { x.set(true); };
-    }
-    let i = &Cell::new(false);
-    let dont = {||the(i)};
-    dont();
-    assert!(i.get());
-}
-
-fn zombiejesus() {
-    loop {
-        while (return) {
-            if (return) {
-                match (return) {
-                    1 => {
-                        if (return) {
-                            return
-                        } else {
-                            return
-                        }
-                    }
-                    _ => { return }
-                };
-            } else if (return) {
-                return;
-            }
-        }
-        if (return) { break; }
-    }
-}
-
-fn notsure() {
-    let mut _x: isize;
-    let mut _y = (_x = 0) == (_x = 0);
-    let mut _z = (_x = 0) < (_x = 0);
-    let _a = (_x += 0) == (_x = 0);
-    let _b = swap(&mut _y, &mut _z) == swap(&mut _y, &mut _z);
-}
-
-fn canttouchthis() -> usize {
-    fn p() -> bool { true }
-    let _a = (assert!(true) == (assert!(p())));
-    let _c = (assert!(p()) == ());
-    let _b: bool = (println!("{}", 0) == (return 0));
-}
-
-fn angrydome() {
-    loop { if break { } }
-    let mut i = 0;
-    loop { i += 1; if i == 1 { match (continue) { 1 => { }, _ => panic!("wat") } }
-      break; }
-}
-
-fn evil_lincoln() { let _evil: () = println!("lincoln"); }
-
-fn dots() {
-    assert_eq!(String::from(".................................................."),
-               format!("{:?}", .. .. .. .. .. .. .. .. .. .. .. .. ..
-                               .. .. .. .. .. .. .. .. .. .. .. ..));
-}
-
-fn u8(u8: u8) {
-    if u8 != 0u8 {
-        assert_eq!(8u8, {
-            macro_rules! u8 {
-                (u8) => {
-                    mod u8 {
-                        pub fn u8<'u8: 'u8 + 'u8>(u8: &'u8 u8) -> &'u8 u8 {
-                            "u8";
-                            u8
-                        }
-                    }
-                };
-            }
-
-            u8!(u8);
-            let &u8: &u8 = u8::u8(&8u8);
-            crate::u8(0u8);
-            u8
-        });
-    }
-}
-
-fn fishy() {
-    assert_eq!(String::from("><>"),
-               String::<>::from::<>("><>").chars::<>().rev::<>().collect::<String>());
-}
-
-fn union() {
-    union union<'union> { union: &'union union<'union>, }
-}
-
-fn special_characters() {
-    let val = !((|(..):(_,_),(|__@_|__)|__)((&*"\\",'🤔')/**/,{})=={&[..=..][..];})//
-    ;
-    assert!(!val);
-}
-
-fn punch_card() -> impl std::fmt::Debug {
-    ..=..=.. ..    .. .. .. ..    .. .. .. ..    .. .. .. ..
-    ..=.. ..=..    .. .. .. ..    .. .. .. ..    .. ..=.. ..
-    ..=.. ..=..    ..=.. ..=..    .. ..=..=..    ..=..=..=..
-    ..=..=.. ..    ..=.. ..=..    ..=.. .. ..    .. ..=.. ..
-    ..=.. ..=..    ..=.. ..=..    .. ..=.. ..    .. ..=.. ..
-    ..=.. ..=..    ..=.. ..=..    .. .. ..=..    .. ..=.. ..
-    ..=.. ..=..    .. ..=..=..    ..=..=.. ..    .. ..=..=..
-}
-
-fn r#match() {
-    let val: () = match match match match match () {
-        () => ()
-    } {
-        () => ()
-    } {
-        () => ()
-    } {
-        () => ()
-    } {
-        () => ()
-    };
-    assert_eq!(val, ());
-}
-
-fn i_yield() {
-    #[coroutine]
-    static || {
-        yield yield yield yield yield yield yield yield yield;
-    };
-}
-
-fn match_nested_if() {
-    let val = match () {
-        () if if if if true {true} else {false} {true} else {false} {true} else {false} => true,
-        _ => false,
-    };
-    assert!(val);
-}
-
-fn monkey_barrel() {
-    let val: () = ()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=();
-    assert_eq!(val, ());
-}
-
-fn 𝚌𝚘𝚗𝚝𝚒𝚗𝚞𝚎() {
-    type 𝚕𝚘𝚘𝚙 = i32;
-    fn 𝚋𝚛𝚎𝚊𝚔() -> 𝚕𝚘𝚘𝚙 {
-        let 𝚛𝚎𝚝𝚞𝚛𝚗 = 42;
-        return 𝚛𝚎𝚝𝚞𝚛𝚗;
-    }
-    assert_eq!(loop {
-        break 𝚋𝚛𝚎𝚊𝚔 ();
-    }, 42);
-}
-
-fn function() {
-    struct foo;
-    impl Deref for foo {
-        type Target = fn() -> Self;
-        fn deref(&self) -> &Self::Target {
-            &((|| foo) as _)
-        }
-    }
-    let foo = foo () ()() ()()() ()()()() ()()()()();
-}
-
-fn bathroom_stall() {
-    let mut i = 1;
-    matches!(2, _|_|_|_|_|_ if (i+=1) != (i+=1));
-    assert_eq!(i, 13);
-}
-
-fn closure_matching() {
-    let x = |_| Some(1);
-    let (|x| x) = match x(..) {
-        |_| Some(2) => |_| Some(3),
-        |_| _ => unreachable!(),
-    };
-    assert!(matches!(x(..), |_| Some(4)));
-}
-
-fn semisemisemisemisemi() {
-    ;;;;;;; ;;;;;;; ;;;    ;;; ;;
-    ;;      ;;      ;;;;  ;;;; ;;
-    ;;;;;;; ;;;;;   ;; ;;;; ;; ;;
-         ;; ;;      ;;  ;;  ;; ;;
-    ;;;;;;; ;;;;;;; ;;      ;; ;;
-}
-
-fn useful_syntax() {
-    use {{std::{{collections::{{HashMap}}}}}};
-    use ::{{{{core}, {std}}}};
-    use {{::{{core as core2}}}};
-}
-
-fn infcx() {
-    pub mod cx {
-        pub mod cx {
-            pub use super::cx;
-            pub struct Cx;
-        }
-    }
-    let _cx: cx::cx::Cx = cx::cx::cx::cx::cx::Cx;
-}
-
-fn return_already() -> impl std::fmt::Debug {
-    loop {
-        return !!!!!!!
-        break !!!!!!1111
-    }
-}
-
-fn fake_macros() -> impl std::fmt::Debug {
-    loop {
-        if! {
-            match! (
-                break! {
-                    return! {
-                        1337
-                    }
-                }
-            )
-
-            {}
-        }
-
-        {}
-    }
-}
-
-fn fish_fight() {
-    trait Rope {
-        fn _____________<U>(_: Self, _: U) where Self: Sized {}
-    }
-
-    struct T;
-
-    impl Rope for T {}
-
-    fn tug_o_war(_: impl Fn(T, T)) {}
-
-    tug_o_war(<T>::_____________::<T>);
-}
-
-pub fn main() {
-    strange();
-    funny();
-    what();
-    zombiejesus();
-    notsure();
-    canttouchthis();
-    angrydome();
-    evil_lincoln();
-    dots();
-    u8(8u8);
-    fishy();
-    union();
-    special_characters();
-    punch_card();
-    r#match();
-    i_yield();
-    match_nested_if();
-    monkey_barrel();
-    𝚌𝚘𝚗𝚝𝚒𝚗𝚞𝚎();
-    function();
-    bathroom_stall();
-    closure_matching();
-    semisemisemisemisemi();
-    useful_syntax();
-    infcx();
-    return_already();
-    fake_macros();
-    fish_fight();
-}
diff --git a/tests/ui/write-fmt-errors.rs b/tests/ui/write-fmt-errors.rs
deleted file mode 100644
index b48fa3f11cc..00000000000
--- a/tests/ui/write-fmt-errors.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//@ run-pass
-//@ needs-unwind
-
-#![feature(io_error_uncategorized)]
-
-use std::fmt;
-use std::io::{self, Error, Write};
-use std::panic::catch_unwind;
-
-struct ErrorDisplay;
-
-impl fmt::Display for ErrorDisplay {
-    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
-        Err(fmt::Error)
-    }
-}
-
-struct ErrorWriter;
-
-const WRITER_ERROR: io::ErrorKind = io::ErrorKind::NotConnected;
-
-impl Write for ErrorWriter {
-    fn write(&mut self, _buf: &[u8]) -> io::Result<usize> {
-        Err(Error::new(WRITER_ERROR, "not connected"))
-    }
-
-    fn flush(&mut self) -> io::Result<()> { Ok(()) }
-}
-
-fn main() {
-    // Test that an underlying error is propagated
-    let res = write!(ErrorWriter, "abc");
-    assert!(res.is_err(), "writer error did not propagate");
-
-    // Test that the error from the formatter is detected.
-    let res = catch_unwind(|| write!(vec![], "{} {} {}", 1, ErrorDisplay, "bar"));
-    let err = res.expect_err("formatter error did not lead to panic").downcast::<&str>().unwrap();
-    assert!(
-        err.contains("formatting trait implementation returned an error"),
-        "unexpected panic: {}", err
-    );
-
-    // Writer error when there's some string before the first `{}`
-    let res = write!(ErrorWriter, "abc {}", ErrorDisplay);
-    assert!(res.is_err(), "writer error did not propagate");
-    assert_eq!(res.unwrap_err().kind(), WRITER_ERROR);
-
-    // Formatter error when the `{}` comes first
-    let res = catch_unwind(|| write!(ErrorWriter, "{} abc", ErrorDisplay));
-    let err = res.expect_err("formatter error did not lead to panic").downcast::<&str>().unwrap();
-    assert!(
-        err.contains("formatting trait implementation returned an error"),
-        "unexpected panic: {}", err
-    );
-}
diff --git a/tests/ui/wrong-hashset-issue-42918.rs b/tests/ui/wrong-hashset-issue-42918.rs
deleted file mode 100644
index 5795cc527cf..00000000000
--- a/tests/ui/wrong-hashset-issue-42918.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ run-pass
-//
-#![allow(dead_code)]
-//@ compile-flags: -O
-
-use std::collections::HashSet;
-
-#[derive(PartialEq, Debug, Hash, Eq, Clone, PartialOrd, Ord)]
-enum MyEnum {
-    E0,
-
-    E1,
-
-    E2,
-    E3,
-    E4,
-
-    E5,
-    E6,
-    E7,
-}
-
-
-fn main() {
-    use MyEnum::*;
-    let s: HashSet<_> = [E4, E1].iter().cloned().collect();
-    let mut v: Vec<_> = s.into_iter().collect();
-    v.sort();
-
-    assert_eq!([E1, E4], &v[..]);
-}
-- 
cgit 1.4.1-3-g733a5


From eeaa63f39aadd452ae4dc1710820c8e9b4883ab2 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 26 Jun 2025 02:01:38 +0000
Subject: Remove support for dyn*

---
 clippy_utils/src/qualify_min_const_fn.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index 8f1ebb8ada6..942c71ac33b 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -175,10 +175,6 @@ fn check_rvalue<'tcx>(
         Rvalue::Cast(CastKind::PointerExposeProvenance, _, _) => {
             Err((span, "casting pointers to ints is unstable in const fn".into()))
         },
-        Rvalue::Cast(CastKind::PointerCoercion(PointerCoercion::DynStar, _), _, _) => {
-            // FIXME(dyn-star)
-            unimplemented!()
-        },
         Rvalue::Cast(CastKind::Transmute, _, _) => Err((
             span,
             "transmute can attempt to turn pointers into integers, so is unstable in const fn".into(),
-- 
cgit 1.4.1-3-g733a5


From fc3d5e682781ec440dc21f3235207e3d4e230de3 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Wed, 21 May 2025 17:28:19 +0200
Subject: Remove unneeded `.as_bytes()`

`&str` already implements `AsRef<[u8]>`
---
 clippy_dev/src/fmt.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_dev/src/fmt.rs b/clippy_dev/src/fmt.rs
index c1b6b370706..bd9e57c9f6d 100644
--- a/clippy_dev/src/fmt.rs
+++ b/clippy_dev/src/fmt.rs
@@ -223,7 +223,7 @@ fn fmt_conf(check: bool) -> Result<(), Error> {
         if check {
             return Err(Error::CheckFailed);
         }
-        fs::write(path, new_text.as_bytes())?;
+        fs::write(path, new_text)?;
     }
     Ok(())
 }
-- 
cgit 1.4.1-3-g733a5


From 1d2b874b847e2d59a7deb639ef79999b87ee2837 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Tue, 1 Jul 2025 18:29:17 -0400
Subject: Remove OVERWRITE_TARGET_TRIPLE env var now that config.sh is gone

---
 .github/workflows/m68k.yml | 13 ++++++++++---
 build_system/src/config.rs | 12 ++++++++----
 doc/tips.md                |  4 ++--
 3 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/m68k.yml b/.github/workflows/m68k.yml
index 245bee7f2a3..4a8ccebaf79 100644
--- a/.github/workflows/m68k.yml
+++ b/.github/workflows/m68k.yml
@@ -14,8 +14,6 @@ permissions:
 env:
   # Enable backtraces for easier debugging
   RUST_BACKTRACE: 1
-  # TODO: remove when confish.sh is removed.
-  OVERWRITE_TARGET_TRIPLE: m68k-unknown-linux-gnu
 
 jobs:
   build:
@@ -106,7 +104,16 @@ jobs:
 
     - name: Run tests
       run: |
-        ./y.sh test --release --clean --build-sysroot --sysroot-features compiler_builtins/no-f16-f128 ${{ matrix.commands }}
+        ./y.sh test--target-triple m68k-unknown-linux-gnu --release --clean --build-sysroot --sysroot-features compiler_builtins/no-f16-f128 ${{ matrix.commands }}
+
+    - name: Run Hello World!
+      run: |
+        ./y.sh build --target-triple m68k-unknown-linux-gnu
+
+        cd tests/hello-world
+        ../../y.sh cargo build --target m68k-unknown-linux-gnu
+        ../../y.sh cargo run --target m68k-unknown-linux-gnu > hello_world_stdout
+        test $(cat hello_world_stdout) == "Hello, world!" || exit 1
 
   # Summary job for the merge queue.
   # ALL THE PREVIOUS JOBS NEED TO BE ADDED TO THE `needs` SECTION OF THIS JOB!
diff --git a/build_system/src/config.rs b/build_system/src/config.rs
index 650c030ca53..121c43822fd 100644
--- a/build_system/src/config.rs
+++ b/build_system/src/config.rs
@@ -352,10 +352,14 @@ impl ConfigInfo {
             None => return Err("no host found".to_string()),
         };
 
-        if self.target_triple.is_empty()
-            && let Some(overwrite) = env.get("OVERWRITE_TARGET_TRIPLE")
-        {
-            self.target_triple = overwrite.clone();
+        if self.target_triple.is_empty() {
+            // TODO: set target triple.
+            // TODO: why do we even need to set target_triple?
+            // It seems to only be needed for the linker (we could add an environment variable to
+            // remove this need) and the sysroot (perhaps we could find another way to find it).
+            // TODO TODO: seems like we would still need OVERWRITE_TARGET_TRIPLE when using a
+            // json spec file.
+            // ====> maybe not since we specify both --target and --target-triple.
         }
         if self.target_triple.is_empty() {
             self.target_triple = self.host_triple.clone();
diff --git a/doc/tips.md b/doc/tips.md
index 86c22db186e..4ab135f3df6 100644
--- a/doc/tips.md
+++ b/doc/tips.md
@@ -63,13 +63,13 @@ generate it in [gimple.md](./doc/gimple.md).
  * Run `./y.sh prepare --cross` so that the sysroot is patched for the cross-compiling case.
  * Set the path to the cross-compiling libgccjit in `gcc-path` (in `config.toml`).
  * Make sure you have the linker for your target (for instance `m68k-unknown-linux-gnu-gcc`) in your `$PATH`. Currently, the linker name is hardcoded as being `$TARGET-gcc`. Specify the target when building the sysroot: `./y.sh build --sysroot --target-triple m68k-unknown-linux-gnu`.
- * Build your project by specifying the target: `OVERWRITE_TARGET_TRIPLE=m68k-unknown-linux-gnu ../y.sh cargo build --target m68k-unknown-linux-gnu`.
+ * Build your project by specifying the target: `../y.sh cargo build --target m68k-unknown-linux-gnu`.
 
 If the target is not yet supported by the Rust compiler, create a [target specification file](https://docs.rust-embedded.org/embedonomicon/custom-target.html) (note that the `arch` specified in this file must be supported by the rust compiler).
 Then, you can use it the following way:
 
  * Add the target specification file using `--target` as an **absolute** path to build the sysroot: `./y.sh build --sysroot --target-triple m68k-unknown-linux-gnu --target $(pwd)/m68k-unknown-linux-gnu.json`
- * Build your project by specifying the target specification file: `OVERWRITE_TARGET_TRIPLE=m68k-unknown-linux-gnu ../y.sh cargo build --target path/to/m68k-unknown-linux-gnu.json`.
+ * Build your project by specifying the target specification file: `../y.sh cargo build --target path/to/m68k-unknown-linux-gnu.json`.
 
 If you get the following error:
 
-- 
cgit 1.4.1-3-g733a5


From 1bbe5946f231b4c05818fb18f9252b68af251498 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Tue, 1 Jul 2025 18:50:39 -0400
Subject: Fix installation of libgccjit for m68k

---
 .github/workflows/m68k.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/m68k.yml b/.github/workflows/m68k.yml
index 4a8ccebaf79..04e09dc7b8c 100644
--- a/.github/workflows/m68k.yml
+++ b/.github/workflows/m68k.yml
@@ -57,7 +57,7 @@ jobs:
 
     - name: Setup path to libgccjit
       run: |
-          sudo dpkg -i gcc-m68k-15.deb
+          sudo dpkg --force-overwrite -i gcc-m68k-15.deb
           echo 'gcc-path = "/usr/lib/"' > config.toml
 
     - name: Set env
-- 
cgit 1.4.1-3-g733a5


From 89f0cb3bfc97473a33cb5ae073be6073fa0931b9 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Tue, 1 Jul 2025 19:03:08 -0400
Subject: Specify linker in m68k CI

---
 .github/workflows/m68k.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/m68k.yml b/.github/workflows/m68k.yml
index 04e09dc7b8c..249fb965be1 100644
--- a/.github/workflows/m68k.yml
+++ b/.github/workflows/m68k.yml
@@ -63,8 +63,6 @@ jobs:
     - name: Set env
       run: |
         echo "workspace="$GITHUB_WORKSPACE >> $GITHUB_ENV
-        
-        
 
     #- name: Cache rust repository
       ## We only clone the rust repository for rustc tests
@@ -85,7 +83,7 @@ jobs:
       run: |
         ./y.sh prepare --only-libcore --cross
         ./y.sh build --sysroot --features compiler_builtins/no-f16-f128 --target-triple m68k-unknown-linux-gnu --target ${{ github.workspace }}/target_specs/m68k-unknown-linux-gnu.json
-        ./y.sh cargo build --manifest-path=./tests/hello-world/Cargo.toml --target ${{ github.workspace }}/target_specs/m68k-unknown-linux-gnu.json
+        CG_RUSTFLAGS="-Clinker=m68k-unknown-linux-gnu-gcc" ./y.sh cargo build --manifest-path=./tests/hello-world/Cargo.toml --target ${{ github.workspace }}/target_specs/m68k-unknown-linux-gnu.json
         ./y.sh clean all
 
     - name: Build
-- 
cgit 1.4.1-3-g733a5


From cf509d87d909c551c942b315ac16f2722a71db2e Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Tue, 1 Jul 2025 19:17:18 -0400
Subject: Add missing --target-triple flags in m68k CI

---
 .github/workflows/m68k.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/m68k.yml b/.github/workflows/m68k.yml
index 249fb965be1..b78f17c0e26 100644
--- a/.github/workflows/m68k.yml
+++ b/.github/workflows/m68k.yml
@@ -90,8 +90,8 @@ jobs:
       run: |
         ./y.sh prepare --only-libcore --cross
         ./y.sh build --sysroot --features compiler_builtins/no-f16-f128 --target-triple m68k-unknown-linux-gnu
-        ./y.sh test --mini-tests
-        CG_GCC_TEST_TARGET=m68k-unknown-linux-gnu ./y.sh test --cargo-tests
+        ./y.sh test --mini-tests --target-triple m68k-unknown-linux-gnu
+        CG_GCC_TEST_TARGET=m68k-unknown-linux-gnu ./y.sh test --cargo-tests --target-triple m68k-unknown-linux-gnu
         ./y.sh clean all
 
     - name: Prepare dependencies
-- 
cgit 1.4.1-3-g733a5


From fec79b86a2fb9f7086229d1b94bafd204eec6c27 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Tue, 1 Jul 2025 19:35:39 -0400
Subject: Add missing space before --target-triple

---
 .github/workflows/m68k.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/m68k.yml b/.github/workflows/m68k.yml
index b78f17c0e26..511e2ff3dec 100644
--- a/.github/workflows/m68k.yml
+++ b/.github/workflows/m68k.yml
@@ -102,7 +102,7 @@ jobs:
 
     - name: Run tests
       run: |
-        ./y.sh test--target-triple m68k-unknown-linux-gnu --release --clean --build-sysroot --sysroot-features compiler_builtins/no-f16-f128 ${{ matrix.commands }}
+        ./y.sh test --target-triple m68k-unknown-linux-gnu --release --clean --build-sysroot --sysroot-features compiler_builtins/no-f16-f128 ${{ matrix.commands }}
 
     - name: Run Hello World!
       run: |
-- 
cgit 1.4.1-3-g733a5


From 3021598bdfc5adec0e71401a191e780bdc0060fb Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Tue, 1 Jul 2025 19:44:00 -0400
Subject: Specify the linker when building the test project in m68k CI

---
 .github/workflows/m68k.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/m68k.yml b/.github/workflows/m68k.yml
index 511e2ff3dec..5f347498f32 100644
--- a/.github/workflows/m68k.yml
+++ b/.github/workflows/m68k.yml
@@ -109,8 +109,8 @@ jobs:
         ./y.sh build --target-triple m68k-unknown-linux-gnu
 
         cd tests/hello-world
-        ../../y.sh cargo build --target m68k-unknown-linux-gnu
-        ../../y.sh cargo run --target m68k-unknown-linux-gnu > hello_world_stdout
+        CG_RUSTFLAGS="-Clinker=m68k-unknown-linux-gnu-gcc" ../../y.sh cargo build --target m68k-unknown-linux-gnu
+        CG_RUSTFLAGS="-Clinker=m68k-unknown-linux-gnu-gcc" ../../y.sh cargo run --target m68k-unknown-linux-gnu > hello_world_stdout
         test $(cat hello_world_stdout) == "Hello, world!" || exit 1
 
   # Summary job for the merge queue.
-- 
cgit 1.4.1-3-g733a5


From 5773d38c7a7d522e6d867de1e57375d129ae478e Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Mon, 30 Jun 2025 14:29:59 +0000
Subject: fix: Fix TypePrintFn flag passing for autodiff codegen

Signed-off-by: Karan Janthe <karanjanthe@gmail.com>
---
 compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp | 13 +++++++++++++
 src/tools/enzyme                                 |  2 +-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index d4a05fbbbc5..7771b41bd66 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -700,6 +700,10 @@ struct LLVMRustSanitizerOptions {
 #ifdef ENZYME
 extern "C" void registerEnzymeAndPassPipeline(llvm::PassBuilder &PB,
                                               /* augmentPassBuilder */ bool);
+
+extern "C" {
+extern llvm::cl::opt<std::string> EnzymeFunctionToAnalyze;
+}
 #endif
 
 extern "C" LLVMRustResult LLVMRustOptimize(
@@ -1069,6 +1073,15 @@ extern "C" LLVMRustResult LLVMRustOptimize(
       return LLVMRustResult::Failure;
     }
 
+    // Check if PrintTAFn was used and add type analysis pass if needed
+    if (!EnzymeFunctionToAnalyze.empty()) {
+      if (auto Err = PB.parsePassPipeline(MPM, "print-type-analysis")) {
+        std::string ErrMsg = toString(std::move(Err));
+        LLVMRustSetLastError(ErrMsg.c_str());
+        return LLVMRustResult::Failure;
+      }
+    }
+
     if (PrintAfterEnzyme) {
       // Handle the Rust flag `-Zautodiff=PrintModAfter`.
       std::string Banner = "Module after EnzymeNewPM";
diff --git a/src/tools/enzyme b/src/tools/enzyme
index b5098d515d5..0f65f31837a 160000
--- a/src/tools/enzyme
+++ b/src/tools/enzyme
@@ -1 +1 @@
-Subproject commit b5098d515d5e1bd0f5470553bc0d18da9794ca8b
+Subproject commit 0f65f31837a608db469ebde94adbc921be70bd8a
-- 
cgit 1.4.1-3-g733a5


From be35d37d8b6c206576ff3cdcad956d921b47cc6b Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Mon, 30 Jun 2025 16:53:21 -0500
Subject: Use the compiler to determine whether or not to enable `f16` and
 `f128`

Currently we whether or not to build and test `f16` and `f128` support
mostly based on the target triple. This isn't always accurate, however,
since support also varies by backend and the backend version.

Since recently, `rustc` is aware of this with the unstable config option
`target_has_reliable_{f16,f128}`, which better represents when the types
are actually expected to be available and usable. Switch our
compiler-builtins and libm configuration to use this by probing `rustc`
for the target's settings.

A few small `cfg` fixes are needed with this.
---
 .../builtins-test-intrinsics/build.rs              |  1 -
 .../builtins-test/benches/float_cmp.rs             |  2 +
 library/compiler-builtins/builtins-test/build.rs   |  1 -
 .../compiler-builtins/builtins-test/tests/conv.rs  |  4 +-
 .../builtins-test/tests/div_rem.rs                 |  4 +-
 .../compiler-builtins/compiler-builtins/build.rs   |  3 +-
 .../compiler-builtins/configure.rs                 | 81 ++++++++--------------
 library/compiler-builtins/libm/configure.rs        | 81 ++++++++--------------
 8 files changed, 66 insertions(+), 111 deletions(-)

diff --git a/library/compiler-builtins/builtins-test-intrinsics/build.rs b/library/compiler-builtins/builtins-test-intrinsics/build.rs
index 89b126ff2b2..b82581262f7 100644
--- a/library/compiler-builtins/builtins-test-intrinsics/build.rs
+++ b/library/compiler-builtins/builtins-test-intrinsics/build.rs
@@ -6,6 +6,5 @@ fn main() {
     println!("cargo::rerun-if-changed=../configure.rs");
 
     let target = builtins_configure::Target::from_env();
-    builtins_configure::configure_f16_f128(&target);
     builtins_configure::configure_aliases(&target);
 }
diff --git a/library/compiler-builtins/builtins-test/benches/float_cmp.rs b/library/compiler-builtins/builtins-test/benches/float_cmp.rs
index 87a89efb5a4..da29b5d3132 100644
--- a/library/compiler-builtins/builtins-test/benches/float_cmp.rs
+++ b/library/compiler-builtins/builtins-test/benches/float_cmp.rs
@@ -177,6 +177,7 @@ float_bench! {
     ],
 }
 
+#[cfg(f128_enabled)]
 float_bench! {
     name: cmp_f128_gt,
     sig: (a: f128, b: f128) -> CmpResult,
@@ -189,6 +190,7 @@ float_bench! {
     asm: []
 }
 
+#[cfg(f128_enabled)]
 float_bench! {
     name: cmp_f128_unord,
     sig: (a: f128, b: f128) -> CmpResult,
diff --git a/library/compiler-builtins/builtins-test/build.rs b/library/compiler-builtins/builtins-test/build.rs
index e8f4eb4dd22..5b2dcd12ef8 100644
--- a/library/compiler-builtins/builtins-test/build.rs
+++ b/library/compiler-builtins/builtins-test/build.rs
@@ -116,5 +116,4 @@ fn main() {
     }
 
     builtins_configure::configure_aliases(&target);
-    builtins_configure::configure_f16_f128(&target);
 }
diff --git a/library/compiler-builtins/builtins-test/tests/conv.rs b/library/compiler-builtins/builtins-test/tests/conv.rs
index 491915d9bb1..7d729364fae 100644
--- a/library/compiler-builtins/builtins-test/tests/conv.rs
+++ b/library/compiler-builtins/builtins-test/tests/conv.rs
@@ -118,7 +118,7 @@ mod i_to_f {
         i128, __floattidf;
     }
 
-    #[cfg(not(feature = "no-f16-f128"))]
+    #[cfg(f128_enabled)]
     #[cfg(not(any(target_arch = "powerpc", target_arch = "powerpc64")))]
     i_to_f! { f128, Quad, not(feature = "no-sys-f128-int-convert"),
         u32, __floatunsitf;
@@ -129,7 +129,7 @@ mod i_to_f {
         i128, __floattitf;
     }
 
-    #[cfg(not(feature = "no-f16-f128"))]
+    #[cfg(f128_enabled)]
     #[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
     i_to_f! { f128, Quad, not(feature = "no-sys-f128-int-convert"),
         u32, __floatunsikf;
diff --git a/library/compiler-builtins/builtins-test/tests/div_rem.rs b/library/compiler-builtins/builtins-test/tests/div_rem.rs
index 5ae653cc90c..e8327f9b4b8 100644
--- a/library/compiler-builtins/builtins-test/tests/div_rem.rs
+++ b/library/compiler-builtins/builtins-test/tests/div_rem.rs
@@ -147,7 +147,7 @@ mod float_div {
         f64, __divdf3, Double, all();
     }
 
-    #[cfg(not(feature = "no-f16-f128"))]
+    #[cfg(f128_enabled)]
     #[cfg(not(any(target_arch = "powerpc", target_arch = "powerpc64")))]
     float! {
         f128, __divtf3, Quad,
@@ -156,7 +156,7 @@ mod float_div {
         not(any(feature = "no-sys-f128", all(target_arch = "aarch64", target_os = "linux")));
     }
 
-    #[cfg(not(feature = "no-f16-f128"))]
+    #[cfg(f128_enabled)]
     #[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
     float! {
         f128, __divkf3, Quad, not(feature = "no-sys-f128");
diff --git a/library/compiler-builtins/compiler-builtins/build.rs b/library/compiler-builtins/compiler-builtins/build.rs
index 018899faf1d..8f51c12b535 100644
--- a/library/compiler-builtins/compiler-builtins/build.rs
+++ b/library/compiler-builtins/compiler-builtins/build.rs
@@ -2,7 +2,7 @@ mod configure;
 
 use std::env;
 
-use configure::{Target, configure_aliases, configure_f16_f128};
+use configure::{Target, configure_aliases};
 
 fn main() {
     println!("cargo::rerun-if-changed=build.rs");
@@ -12,7 +12,6 @@ fn main() {
     let cwd = env::current_dir().unwrap();
 
     configure_check_cfg();
-    configure_f16_f128(&target);
     configure_aliases(&target);
 
     configure_libm(&target);
diff --git a/library/compiler-builtins/compiler-builtins/configure.rs b/library/compiler-builtins/compiler-builtins/configure.rs
index d825f35a9aa..a1e45080e71 100644
--- a/library/compiler-builtins/compiler-builtins/configure.rs
+++ b/library/compiler-builtins/compiler-builtins/configure.rs
@@ -1,6 +1,7 @@
 // Configuration that is shared between `compiler_builtins` and `builtins_test`.
 
-use std::env;
+use std::process::{Command, Stdio};
+use std::{env, str};
 
 #[derive(Debug)]
 #[allow(dead_code)]
@@ -16,6 +17,8 @@ pub struct Target {
     pub pointer_width: u8,
     pub little_endian: bool,
     pub features: Vec<String>,
+    pub reliable_f128: bool,
+    pub reliable_f16: bool,
 }
 
 impl Target {
@@ -32,6 +35,19 @@ impl Target {
             .map(|s| s.to_lowercase().replace("_", "-"))
             .collect();
 
+        // Query rustc for options that Cargo does not provide env for. The bootstrap hack is used
+        // to get consistent output regardless of channel (`f16`/`f128` config options are hidden
+        // on stable otherwise).
+        let mut cmd = Command::new(env::var("RUSTC").unwrap());
+        cmd.args(["--print=cfg", "--target", &triple])
+            .env("RUSTC_BOOTSTRAP", "1")
+            .stderr(Stdio::inherit());
+        let out = cmd
+            .output()
+            .unwrap_or_else(|e| panic!("failed to run `{cmd:?}`: {e}"));
+        assert!(out.status.success(), "failed to run `{cmd:?}`");
+        let rustc_cfg = str::from_utf8(&out.stdout).unwrap();
+
         Self {
             triple,
             triple_split,
@@ -51,6 +67,8 @@ impl Target {
                 .split(",")
                 .map(ToOwned::to_owned)
                 .collect(),
+            reliable_f128: rustc_cfg.lines().any(|l| l == "target_has_reliable_f128"),
+            reliable_f16: rustc_cfg.lines().any(|l| l == "target_has_reliable_f16"),
         }
     }
 
@@ -74,63 +92,24 @@ pub fn configure_aliases(target: &Target) {
     if target.triple_split[0] == "thumbv6m" || target.triple_split[0] == "thumbv8m.base" {
         println!("cargo:rustc-cfg=thumb_1")
     }
-}
-
-/// Configure whether or not `f16` and `f128` support should be enabled.
-pub fn configure_f16_f128(target: &Target) {
-    // Set whether or not `f16` and `f128` are supported at a basic level by LLVM. This only means
-    // that the backend will not crash when using these types and generates code that can be called
-    // without crashing (no infinite recursion). This does not mean that the platform doesn't have
-    // ABI or other bugs.
-    //
-    // We do this here rather than in `rust-lang/rust` because configuring via cargo features is
-    // not straightforward.
-    //
-    // Original source of this list:
-    // <https://github.com/rust-lang/compiler-builtins/pull/652#issuecomment-2266151350>
-    let f16_enabled = match target.arch.as_str() {
-        // Unsupported <https://github.com/llvm/llvm-project/issues/94434>
-        "arm64ec" => false,
-        // Selection failure <https://github.com/llvm/llvm-project/issues/50374>
-        "s390x" => false,
-        // Infinite recursion <https://github.com/llvm/llvm-project/issues/97981>
-        "csky" => false,
-        "hexagon" => false,
-        "powerpc" | "powerpc64" => false,
-        "sparc" | "sparc64" => false,
-        "wasm32" | "wasm64" => false,
-        // Most everything else works as of LLVM 19
-        _ => true,
-    };
 
-    let f128_enabled = match target.arch.as_str() {
-        // Unsupported (libcall is not supported) <https://github.com/llvm/llvm-project/issues/121122>
-        "amdgpu" => false,
-        // Unsupported <https://github.com/llvm/llvm-project/issues/94434>
-        "arm64ec" => false,
-        // FIXME(llvm20): fixed by <https://github.com/llvm/llvm-project/pull/117525>
-        "mips64" | "mips64r6" => false,
-        // Selection failure <https://github.com/llvm/llvm-project/issues/95471>
-        "nvptx64" => false,
-        // Selection failure <https://github.com/llvm/llvm-project/issues/101545>
-        "powerpc64" if &target.os == "aix" => false,
-        // Selection failure <https://github.com/llvm/llvm-project/issues/41838>
-        "sparc" => false,
-        // Most everything else works as of LLVM 19
-        _ => true,
-    };
+    /* Not all backends support `f16` and `f128` to the same level on all architectures, so we
+     * need to disable things if the compiler may crash. See configuration at:
+     * * https://github.com/rust-lang/rust/blob/c65dccabacdfd6c8a7f7439eba13422fdd89b91e/compiler/rustc_codegen_llvm/src/llvm_util.rs#L367-L432
+     * * https://github.com/rust-lang/rustc_codegen_gcc/blob/4b5c44b14166083eef8d71f15f5ea1f53fc976a0/src/lib.rs#L496-L507
+     * * https://github.com/rust-lang/rustc_codegen_cranelift/blob/c713ffab3c6e28ab4b4dd4e392330f786ea657ad/src/lib.rs#L196-L226
+     */
 
-    // If the feature is set, disable these types.
-    let disable_both = env::var_os("CARGO_FEATURE_NO_F16_F128").is_some();
+    // If the feature is set, disable both of these types.
+    let no_f16_f128 = target.cargo_features.iter().any(|s| s == "no-f16-f128");
 
     println!("cargo::rustc-check-cfg=cfg(f16_enabled)");
-    println!("cargo::rustc-check-cfg=cfg(f128_enabled)");
-
-    if f16_enabled && !disable_both {
+    if target.reliable_f16 && !no_f16_f128 {
         println!("cargo::rustc-cfg=f16_enabled");
     }
 
-    if f128_enabled && !disable_both {
+    println!("cargo::rustc-check-cfg=cfg(f128_enabled)");
+    if target.reliable_f128 && !no_f16_f128 {
         println!("cargo::rustc-cfg=f128_enabled");
     }
 }
diff --git a/library/compiler-builtins/libm/configure.rs b/library/compiler-builtins/libm/configure.rs
index 2a497c7b117..6562ecbe5db 100644
--- a/library/compiler-builtins/libm/configure.rs
+++ b/library/compiler-builtins/libm/configure.rs
@@ -1,7 +1,8 @@
 // Configuration shared with both libm and libm-test
 
-use std::env;
 use std::path::PathBuf;
+use std::process::{Command, Stdio};
+use std::{env, str};
 
 #[allow(dead_code)]
 pub struct Config {
@@ -9,6 +10,7 @@ pub struct Config {
     pub out_dir: PathBuf,
     pub opt_level: String,
     pub cargo_features: Vec<String>,
+    pub target_triple: String,
     pub target_arch: String,
     pub target_env: String,
     pub target_family: Option<String>,
@@ -16,10 +18,13 @@ pub struct Config {
     pub target_string: String,
     pub target_vendor: String,
     pub target_features: Vec<String>,
+    pub reliable_f128: bool,
+    pub reliable_f16: bool,
 }
 
 impl Config {
     pub fn from_env() -> Self {
+        let target_triple = env::var("TARGET").unwrap();
         let target_features = env::var("CARGO_CFG_TARGET_FEATURE")
             .map(|feats| feats.split(',').map(ToOwned::to_owned).collect())
             .unwrap_or_default();
@@ -28,7 +33,21 @@ impl Config {
             .map(|s| s.to_lowercase().replace("_", "-"))
             .collect();
 
+        // Query rustc for options that Cargo does not provide env for. The bootstrap hack is used
+        // to get consistent output regardless of channel (`f16`/`f128` config options are hidden
+        // on stable otherwise).
+        let mut cmd = Command::new(env::var("RUSTC").unwrap());
+        cmd.args(["--print=cfg", "--target", &target_triple])
+            .env("RUSTC_BOOTSTRAP", "1")
+            .stderr(Stdio::inherit());
+        let out = cmd
+            .output()
+            .unwrap_or_else(|e| panic!("failed to run `{cmd:?}`: {e}"));
+        assert!(out.status.success(), "failed to run `{cmd:?}`");
+        let rustc_cfg = str::from_utf8(&out.stdout).unwrap();
+
         Self {
+            target_triple,
             manifest_dir: PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap()),
             out_dir: PathBuf::from(env::var("OUT_DIR").unwrap()),
             opt_level: env::var("OPT_LEVEL").unwrap(),
@@ -40,6 +59,8 @@ impl Config {
             target_string: env::var("TARGET").unwrap(),
             target_vendor: env::var("CARGO_CFG_TARGET_VENDOR").unwrap(),
             target_features,
+            reliable_f128: rustc_cfg.lines().any(|l| l == "target_has_reliable_f128"),
+            reliable_f16: rustc_cfg.lines().any(|l| l == "target_has_reliable_f16"),
         }
     }
 }
@@ -128,62 +149,18 @@ fn emit_f16_f128_cfg(cfg: &Config) {
         return;
     }
 
-    // Set whether or not `f16` and `f128` are supported at a basic level by LLVM. This only means
-    // that the backend will not crash when using these types and generates code that can be called
-    // without crashing (no infinite recursion). This does not mean that the platform doesn't have
-    // ABI or other bugs.
-    //
-    // We do this here rather than in `rust-lang/rust` because configuring via cargo features is
-    // not straightforward.
-    //
-    // Original source of this list:
-    // <https://github.com/rust-lang/compiler-builtins/pull/652#issuecomment-2266151350>
-    let f16_enabled = match cfg.target_arch.as_str() {
-        // Unsupported <https://github.com/llvm/llvm-project/issues/94434>
-        "arm64ec" => false,
-        // Selection failure <https://github.com/llvm/llvm-project/issues/50374>
-        "s390x" => false,
-        // Infinite recursion <https://github.com/llvm/llvm-project/issues/97981>
-        // FIXME(llvm): loongarch fixed by <https://github.com/llvm/llvm-project/pull/107791>
-        "csky" => false,
-        "hexagon" => false,
-        "loongarch64" => false,
-        "mips" | "mips64" | "mips32r6" | "mips64r6" => false,
-        "powerpc" | "powerpc64" => false,
-        "sparc" | "sparc64" => false,
-        "wasm32" | "wasm64" => false,
-        // Most everything else works as of LLVM 19
-        _ => true,
-    };
-
-    let f128_enabled = match cfg.target_arch.as_str() {
-        // Unsupported (libcall is not supported) <https://github.com/llvm/llvm-project/issues/121122>
-        "amdgpu" => false,
-        // Unsupported <https://github.com/llvm/llvm-project/issues/94434>
-        "arm64ec" => false,
-        // Selection failure <https://github.com/llvm/llvm-project/issues/96432>
-        "mips64" | "mips64r6" => false,
-        // Selection failure <https://github.com/llvm/llvm-project/issues/95471>
-        "nvptx64" => false,
-        // Selection failure <https://github.com/llvm/llvm-project/issues/101545>
-        "powerpc64" if &cfg.target_os == "aix" => false,
-        // Selection failure <https://github.com/llvm/llvm-project/issues/41838>
-        "sparc" => false,
-        // Most everything else works as of LLVM 19
-        _ => true,
-    };
-
-    // If the feature is set, disable these types.
-    let disable_both = env::var_os("CARGO_FEATURE_NO_F16_F128").is_some();
+    /* See the compiler-builtins configure file for info about the meaning of these options */
 
-    println!("cargo:rustc-check-cfg=cfg(f16_enabled)");
-    println!("cargo:rustc-check-cfg=cfg(f128_enabled)");
+    // If the feature is set, disable both of these types.
+    let no_f16_f128 = cfg.cargo_features.iter().any(|s| s == "no-f16-f128");
 
-    if f16_enabled && !disable_both {
+    println!("cargo:rustc-check-cfg=cfg(f16_enabled)");
+    if cfg.reliable_f16 && !no_f16_f128 {
         println!("cargo:rustc-cfg=f16_enabled");
     }
 
-    if f128_enabled && !disable_both {
+    println!("cargo:rustc-check-cfg=cfg(f128_enabled)");
+    if cfg.reliable_f128 && !no_f16_f128 {
         println!("cargo:rustc-cfg=f128_enabled");
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 8bd580b80e3c31f9c2d4115768a3ac0b71372587 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Wed, 2 Jul 2025 00:57:59 +0200
Subject: Add `track_caller` attributes to trace origin of Clippy lints

This allows the use of `-Z track-diagnostics` to see the origin of
Clippy lints emission, as is already the case for lints coming from
rustc.
---
 clippy_utils/src/diagnostics.rs          |  7 +++++++
 tests/ui/track-diagnostics-clippy.rs     | 22 ++++++++++++++++++++++
 tests/ui/track-diagnostics-clippy.stderr | 29 +++++++++++++++++++++++++++++
 3 files changed, 58 insertions(+)
 create mode 100644 tests/ui/track-diagnostics-clippy.rs
 create mode 100644 tests/ui/track-diagnostics-clippy.stderr

diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index dc240dd067b..8453165818b 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -98,6 +98,7 @@ fn validate_diag(diag: &Diag<'_, impl EmissionGuarantee>) {
 /// 17 |     std::mem::forget(seven);
 ///    |     ^^^^^^^^^^^^^^^^^^^^^^^
 /// ```
+#[track_caller]
 pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
     #[expect(clippy::disallowed_methods)]
     cx.span_lint(lint, sp, |diag| {
@@ -143,6 +144,7 @@ pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<Mult
 ///    |
 ///    = help: consider using `f64::NAN` if you would like a constant representing NaN
 /// ```
+#[track_caller]
 pub fn span_lint_and_help<T: LintContext>(
     cx: &T,
     lint: &'static Lint,
@@ -203,6 +205,7 @@ pub fn span_lint_and_help<T: LintContext>(
 /// 10 |     forget(&SomeStruct);
 ///    |            ^^^^^^^^^^^
 /// ```
+#[track_caller]
 pub fn span_lint_and_note<T: LintContext>(
     cx: &T,
     lint: &'static Lint,
@@ -244,6 +247,7 @@ pub fn span_lint_and_note<T: LintContext>(
 /// If you're unsure which function you should use, you can test if the `#[expect]` attribute works
 /// where you would expect it to.
 /// If it doesn't, you likely need to use [`span_lint_hir_and_then`] instead.
+#[track_caller]
 pub fn span_lint_and_then<C, S, M, F>(cx: &C, lint: &'static Lint, sp: S, msg: M, f: F)
 where
     C: LintContext,
@@ -286,6 +290,7 @@ where
 /// Instead, use this function and also pass the `HirId` of `<expr_1>`, which will let
 /// the compiler check lint level attributes at the place of the expression and
 /// the `#[allow]` will work.
+#[track_caller]
 pub fn span_lint_hir(cx: &LateContext<'_>, lint: &'static Lint, hir_id: HirId, sp: Span, msg: impl Into<DiagMessage>) {
     #[expect(clippy::disallowed_methods)]
     cx.tcx.node_span_lint(lint, hir_id, sp, |diag| {
@@ -321,6 +326,7 @@ pub fn span_lint_hir(cx: &LateContext<'_>, lint: &'static Lint, hir_id: HirId, s
 /// Instead, use this function and also pass the `HirId` of `<expr_1>`, which will let
 /// the compiler check lint level attributes at the place of the expression and
 /// the `#[allow]` will work.
+#[track_caller]
 pub fn span_lint_hir_and_then(
     cx: &LateContext<'_>,
     lint: &'static Lint,
@@ -374,6 +380,7 @@ pub fn span_lint_hir_and_then(
 ///     = note: `-D fold-any` implied by `-D warnings`
 /// ```
 #[cfg_attr(not(debug_assertions), expect(clippy::collapsible_span_lint_calls))]
+#[track_caller]
 pub fn span_lint_and_sugg<T: LintContext>(
     cx: &T,
     lint: &'static Lint,
diff --git a/tests/ui/track-diagnostics-clippy.rs b/tests/ui/track-diagnostics-clippy.rs
new file mode 100644
index 00000000000..2e67fb65efc
--- /dev/null
+++ b/tests/ui/track-diagnostics-clippy.rs
@@ -0,0 +1,22 @@
+//@compile-flags: -Z track-diagnostics
+//@no-rustfix
+
+// Normalize the emitted location so this doesn't need
+// updating everytime someone adds or removes a line.
+//@normalize-stderr-test: ".rs:\d+:\d+" -> ".rs:LL:CC"
+
+#![warn(clippy::let_and_return, clippy::unnecessary_cast)]
+
+fn main() {
+    // Check the provenance of a lint sent through `LintContext::span_lint()`
+    let a = 3u32;
+    let b = a as u32;
+    //~^ unnecessary_cast
+    
+    // Check the provenance of a lint sent through `TyCtxt::node_span_lint()`
+    let c = {
+        let d = 42;
+        d
+        //~^ let_and_return
+    };
+}
diff --git a/tests/ui/track-diagnostics-clippy.stderr b/tests/ui/track-diagnostics-clippy.stderr
new file mode 100644
index 00000000000..f3aca685417
--- /dev/null
+++ b/tests/ui/track-diagnostics-clippy.stderr
@@ -0,0 +1,29 @@
+error: casting to the same type is unnecessary (`u32` -> `u32`)
+  --> tests/ui/track-diagnostics-clippy.rs:LL:CC
+   |
+LL |     let b = a as u32;
+   |             ^^^^^^^^ help: try: `a`
+-Ztrack-diagnostics: created at src/tools/clippy/clippy_lints/src/casts/unnecessary_cast.rs:LL:CC
+   |
+   = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_cast)]`
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/track-diagnostics-clippy.rs:LL:CC
+   |
+LL |         let d = 42;
+   |         ----------- unnecessary `let` binding
+LL |         d
+   |         ^
+-Ztrack-diagnostics: created at src/tools/clippy/clippy_lints/src/returns.rs:LL:CC
+   |
+   = note: `-D clippy::let-and-return` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::let_and_return)]`
+help: return the expression directly
+   |
+LL ~         
+LL ~         42
+   |
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 4a95b165274f9de5c6a0d3c13ae3103e2ac23eb9 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Wed, 2 Jul 2025 10:42:07 +0000
Subject: Move crashes tests.

---
 tests/crashes/128094.rs                            | 15 -------------
 tests/crashes/135128.rs                            | 13 -----------
 tests/ui/mir/gvn-nonsensical-coroutine-layout.rs   | 19 ++++++++++++++++
 .../ui/mir/gvn-nonsensical-coroutine-layout.stderr | 26 ++++++++++++++++++++++
 tests/ui/mir/gvn-nonsensical-sized-str.rs          | 16 +++++++++++++
 tests/ui/mir/gvn-nonsensical-sized-str.stderr      | 10 +++++++++
 6 files changed, 71 insertions(+), 28 deletions(-)
 delete mode 100644 tests/crashes/128094.rs
 delete mode 100644 tests/crashes/135128.rs
 create mode 100644 tests/ui/mir/gvn-nonsensical-coroutine-layout.rs
 create mode 100644 tests/ui/mir/gvn-nonsensical-coroutine-layout.stderr
 create mode 100644 tests/ui/mir/gvn-nonsensical-sized-str.rs
 create mode 100644 tests/ui/mir/gvn-nonsensical-sized-str.stderr

diff --git a/tests/crashes/128094.rs b/tests/crashes/128094.rs
deleted file mode 100644
index 56d09d78bed..00000000000
--- a/tests/crashes/128094.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ known-bug: rust-lang/rust#128094
-//@ compile-flags: -Zmir-enable-passes=+GVN
-//@ edition: 2018
-
-pub enum Request {
-    TestSome(T),
-}
-
-pub async fn handle_event(event: Request) {
-    async move {
-        static instance: Request = Request { bar: 17 };
-        &instance
-    }
-    .await;
-}
diff --git a/tests/crashes/135128.rs b/tests/crashes/135128.rs
deleted file mode 100644
index c718b758dc6..00000000000
--- a/tests/crashes/135128.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ known-bug: #135128
-//@ compile-flags: -Copt-level=1
-//@ edition: 2021
-
-#![feature(trivial_bounds)]
-
-async fn return_str() -> str
-where
-    str: Sized,
-{
-    *"Sized".to_string().into_boxed_str()
-}
-fn main() {}
diff --git a/tests/ui/mir/gvn-nonsensical-coroutine-layout.rs b/tests/ui/mir/gvn-nonsensical-coroutine-layout.rs
new file mode 100644
index 00000000000..f0d174cd01b
--- /dev/null
+++ b/tests/ui/mir/gvn-nonsensical-coroutine-layout.rs
@@ -0,0 +1,19 @@
+//! Verify that we do not ICE when a coroutine body is malformed.
+//@ compile-flags: -Zmir-enable-passes=+GVN
+//@ edition: 2018
+
+pub enum Request {
+    TestSome(T),
+    //~^ ERROR cannot find type `T` in this scope [E0412]
+}
+
+pub async fn handle_event(event: Request) {
+    async move {
+        static instance: Request = Request { bar: 17 };
+        //~^ ERROR expected struct, variant or union type, found enum `Request` [E0574]
+        &instance
+    }
+    .await;
+}
+
+fn main() {}
diff --git a/tests/ui/mir/gvn-nonsensical-coroutine-layout.stderr b/tests/ui/mir/gvn-nonsensical-coroutine-layout.stderr
new file mode 100644
index 00000000000..abc7b16ca74
--- /dev/null
+++ b/tests/ui/mir/gvn-nonsensical-coroutine-layout.stderr
@@ -0,0 +1,26 @@
+error[E0412]: cannot find type `T` in this scope
+  --> $DIR/gvn-nonsensical-coroutine-layout.rs:6:14
+   |
+LL |     TestSome(T),
+   |              ^ not found in this scope
+   |
+help: you might be missing a type parameter
+   |
+LL | pub enum Request<T> {
+   |                 +++
+
+error[E0574]: expected struct, variant or union type, found enum `Request`
+  --> $DIR/gvn-nonsensical-coroutine-layout.rs:12:36
+   |
+LL |         static instance: Request = Request { bar: 17 };
+   |                                    ^^^^^^^ not a struct, variant or union type
+   |
+help: consider importing this struct instead
+   |
+LL + use std::error::Request;
+   |
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0412, E0574.
+For more information about an error, try `rustc --explain E0412`.
diff --git a/tests/ui/mir/gvn-nonsensical-sized-str.rs b/tests/ui/mir/gvn-nonsensical-sized-str.rs
new file mode 100644
index 00000000000..29a82f8ce2a
--- /dev/null
+++ b/tests/ui/mir/gvn-nonsensical-sized-str.rs
@@ -0,0 +1,16 @@
+//! Verify that we do not ICE when optimizing bodies with nonsensical bounds.
+//@ compile-flags: -Copt-level=1
+//@ edition: 2021
+//@ build-pass
+
+#![feature(trivial_bounds)]
+
+async fn return_str() -> str
+where
+    str: Sized,
+    //~^ WARN trait bound str: Sized does not depend on any type or lifetime parameters
+{
+    *"Sized".to_string().into_boxed_str()
+}
+
+fn main() {}
diff --git a/tests/ui/mir/gvn-nonsensical-sized-str.stderr b/tests/ui/mir/gvn-nonsensical-sized-str.stderr
new file mode 100644
index 00000000000..08f0193e9f6
--- /dev/null
+++ b/tests/ui/mir/gvn-nonsensical-sized-str.stderr
@@ -0,0 +1,10 @@
+warning: trait bound str: Sized does not depend on any type or lifetime parameters
+  --> $DIR/gvn-nonsensical-sized-str.rs:10:10
+   |
+LL |     str: Sized,
+   |          ^^^^^
+   |
+   = note: `#[warn(trivial_bounds)]` on by default
+
+warning: 1 warning emitted
+
-- 
cgit 1.4.1-3-g733a5


From 674724c741062ab12cd359ff1439388b0632f2a0 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Wed, 2 Jul 2025 12:26:20 +0000
Subject: remove deprecated from core::ffi::c_str

---
 library/core/src/ffi/c_str.rs | 26 +++++++++-----------------
 1 file changed, 9 insertions(+), 17 deletions(-)

diff --git a/library/core/src/ffi/c_str.rs b/library/core/src/ffi/c_str.rs
index 881a7a24083..c43f3834630 100644
--- a/library/core/src/ffi/c_str.rs
+++ b/library/core/src/ffi/c_str.rs
@@ -135,16 +135,20 @@ pub enum FromBytesWithNulError {
 }
 
 #[stable(feature = "frombyteswithnulerror_impls", since = "1.17.0")]
-impl Error for FromBytesWithNulError {
-    #[allow(deprecated)]
-    fn description(&self) -> &str {
+impl fmt::Display for FromBytesWithNulError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::InteriorNul { .. } => "data provided contains an interior nul byte",
-            Self::NotNulTerminated => "data provided is not nul terminated",
+            Self::InteriorNul { position } => {
+                write!(f, "data provided contains an interior nul byte at byte position {position}")
+            }
+            Self::NotNulTerminated => write!(f, "data provided is not nul terminated"),
         }
     }
 }
 
+#[stable(feature = "frombyteswithnulerror_impls", since = "1.17.0")]
+impl Error for FromBytesWithNulError {}
+
 /// An error indicating that no nul byte was present.
 ///
 /// A slice used to create a [`CStr`] must contain a nul byte somewhere
@@ -181,18 +185,6 @@ impl Default for &CStr {
     }
 }
 
-#[stable(feature = "frombyteswithnulerror_impls", since = "1.17.0")]
-impl fmt::Display for FromBytesWithNulError {
-    #[allow(deprecated, deprecated_in_future)]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(self.description())?;
-        if let Self::InteriorNul { position } = self {
-            write!(f, " at byte pos {position}")?;
-        }
-        Ok(())
-    }
-}
-
 impl CStr {
     /// Wraps a raw C string with a safe C string wrapper.
     ///
-- 
cgit 1.4.1-3-g733a5


From fc076315d298c9cdef6baf770d9492f56e920c92 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 29 May 2025 16:38:06 +0200
Subject: Add Triagebot's `concern` capability to the Clippy repository

This is a newly added triagebot capability, which allows registering and
then resolving concerns with an issue or a pull request. The concerns
are gathered by Triagebot in the issue/PR summary.

Concerns are different from notes: when a concern is resolved, it is
striked through in the issue/PR summary, and a link to the comment
resolving it is also added, whereas a note can only be removed and then
disappears from the summary.

The `has-concerns` label, which must be created at the time of merging
this change, will be automatically set on issues/PRs that have
unresolved concerns, and cleared when all concerns are resolved.
---
 triagebot.toml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 16557a4bebb..a20e3ec2894 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -40,6 +40,10 @@ reviewed_label = "S-waiting-on-author"
 [autolabel."S-waiting-on-review"]
 new_pr = true
 
+[concern]
+# These labels are set when there are unresolved concerns, removed otherwise
+labels = ["S-waiting-on-concerns"]
+
 [assign]
 contributing_url = "https://github.com/rust-lang/rust-clippy/blob/master/CONTRIBUTING.md"
 users_on_vacation = [
-- 
cgit 1.4.1-3-g733a5


From 0b61286dd3a95522a5c9acea6d941fc27500cd38 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Wed, 2 Jul 2025 09:38:38 -0400
Subject: Fix m68k CI

---
 .github/workflows/m68k.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/m68k.yml b/.github/workflows/m68k.yml
index 245bee7f2a3..179b36c1c7e 100644
--- a/.github/workflows/m68k.yml
+++ b/.github/workflows/m68k.yml
@@ -59,14 +59,12 @@ jobs:
 
     - name: Setup path to libgccjit
       run: |
-          sudo dpkg -i gcc-m68k-15.deb
+          sudo dpkg --force-overwrite -i gcc-m68k-15.deb
           echo 'gcc-path = "/usr/lib/"' > config.toml
 
     - name: Set env
       run: |
         echo "workspace="$GITHUB_WORKSPACE >> $GITHUB_ENV
-        
-        
 
     #- name: Cache rust repository
       ## We only clone the rust repository for rustc tests
-- 
cgit 1.4.1-3-g733a5


From ed1e9b7015a3b1599d1322a433771b5845beae68 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Wed, 2 Jul 2025 09:24:55 -0400
Subject: Manually run in a VM in the m68k CI

---
 .github/workflows/m68k.yml | 6 ++++--
 build_system/src/config.rs | 1 +
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/m68k.yml b/.github/workflows/m68k.yml
index 5f347498f32..8b8f58fef5f 100644
--- a/.github/workflows/m68k.yml
+++ b/.github/workflows/m68k.yml
@@ -108,10 +108,12 @@ jobs:
       run: |
         ./y.sh build --target-triple m68k-unknown-linux-gnu
 
+        vm_dir=$(pwd)/vm
         cd tests/hello-world
         CG_RUSTFLAGS="-Clinker=m68k-unknown-linux-gnu-gcc" ../../y.sh cargo build --target m68k-unknown-linux-gnu
-        CG_RUSTFLAGS="-Clinker=m68k-unknown-linux-gnu-gcc" ../../y.sh cargo run --target m68k-unknown-linux-gnu > hello_world_stdout
-        test $(cat hello_world_stdout) == "Hello, world!" || exit 1
+        sudo cp target/m68k-unknown-linux-gnu/debug/hello_world $vm_dir/home/
+        sudo chroot $vm_dir qemu-m68k-static /home/hello_world > hello_world_stdout
+        test $(cat hello_world_stdout) == "Hello, world!" || (echo "Output differs. Actual output: $(cat hello_world_stdout)"; exit 1)
 
   # Summary job for the merge queue.
   # ALL THE PREVIOUS JOBS NEED TO BE ADDED TO THE `needs` SECTION OF THIS JOB!
diff --git a/build_system/src/config.rs b/build_system/src/config.rs
index 121c43822fd..428f3766e5d 100644
--- a/build_system/src/config.rs
+++ b/build_system/src/config.rs
@@ -374,6 +374,7 @@ impl ConfigInfo {
             if self.target_triple.is_empty() {
                 return Err("Unknown non-native platform".to_string());
             }
+            // TODO: check if this is still needed.
             linker = Some(format!("-Clinker={}-gcc", self.target_triple));
             self.run_in_vm = true;
         }
-- 
cgit 1.4.1-3-g733a5


From 21c8639d797850bfbb55546d69c09ba424361aa2 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Wed, 2 Jul 2025 11:39:27 -0400
Subject: Fix to use the correct expected output for m68k CI test

---
 .github/workflows/m68k.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/m68k.yml b/.github/workflows/m68k.yml
index 8b8f58fef5f..4b67360df9d 100644
--- a/.github/workflows/m68k.yml
+++ b/.github/workflows/m68k.yml
@@ -113,7 +113,8 @@ jobs:
         CG_RUSTFLAGS="-Clinker=m68k-unknown-linux-gnu-gcc" ../../y.sh cargo build --target m68k-unknown-linux-gnu
         sudo cp target/m68k-unknown-linux-gnu/debug/hello_world $vm_dir/home/
         sudo chroot $vm_dir qemu-m68k-static /home/hello_world > hello_world_stdout
-        test $(cat hello_world_stdout) == "Hello, world!" || (echo "Output differs. Actual output: $(cat hello_world_stdout)"; exit 1)
+        expected_output="40"
+        test $(cat hello_world_stdout) == $expected_output || (echo "Output differs. Actual output: $(cat hello_world_stdout)"; exit 1)
 
   # Summary job for the merge queue.
   # ALL THE PREVIOUS JOBS NEED TO BE ADDED TO THE `needs` SECTION OF THIS JOB!
-- 
cgit 1.4.1-3-g733a5


From 188108733af702a7f60982c18da2d87d54ed8f5b Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Wed, 2 Jul 2025 11:48:49 -0400
Subject: Update the doc to reflect the new way to specify the linker for
 cross-compilation

---
 doc/tips.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/tips.md b/doc/tips.md
index 4ab135f3df6..e62c3402a29 100644
--- a/doc/tips.md
+++ b/doc/tips.md
@@ -62,8 +62,8 @@ generate it in [gimple.md](./doc/gimple.md).
 
  * Run `./y.sh prepare --cross` so that the sysroot is patched for the cross-compiling case.
  * Set the path to the cross-compiling libgccjit in `gcc-path` (in `config.toml`).
- * Make sure you have the linker for your target (for instance `m68k-unknown-linux-gnu-gcc`) in your `$PATH`. Currently, the linker name is hardcoded as being `$TARGET-gcc`. Specify the target when building the sysroot: `./y.sh build --sysroot --target-triple m68k-unknown-linux-gnu`.
- * Build your project by specifying the target: `../y.sh cargo build --target m68k-unknown-linux-gnu`.
+ * Make sure you have the linker for your target (for instance `m68k-unknown-linux-gnu-gcc`) in your `$PATH`. You can specify which linker to use via `CG_RUSTFLAGS="-Clinker=<linker>"`, for instance: `CG_RUSTFLAGS="-Clinker=m68k-unknown-linux-gnu-gcc"`. Specify the target when building the sysroot: `./y.sh build --sysroot --target-triple m68k-unknown-linux-gnu`.
+ * Build your project by specifying the target and the linker to use: `CG_RUSTFLAGS="-Clinker=m68k-unknown-linux-gnu-gcc" ../y.sh cargo build --target m68k-unknown-linux-gnu`.
 
 If the target is not yet supported by the Rust compiler, create a [target specification file](https://docs.rust-embedded.org/embedonomicon/custom-target.html) (note that the `arch` specified in this file must be supported by the rust compiler).
 Then, you can use it the following way:
-- 
cgit 1.4.1-3-g733a5


From f1c71ffb4764b17d6d23b432d871c3f0c7bb9d91 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Wed, 2 Jul 2025 11:49:05 -0400
Subject: Clean some config stuff up

---
 build_system/src/config.rs | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/build_system/src/config.rs b/build_system/src/config.rs
index 428f3766e5d..a5f802e293a 100644
--- a/build_system/src/config.rs
+++ b/build_system/src/config.rs
@@ -352,15 +352,6 @@ impl ConfigInfo {
             None => return Err("no host found".to_string()),
         };
 
-        if self.target_triple.is_empty() {
-            // TODO: set target triple.
-            // TODO: why do we even need to set target_triple?
-            // It seems to only be needed for the linker (we could add an environment variable to
-            // remove this need) and the sysroot (perhaps we could find another way to find it).
-            // TODO TODO: seems like we would still need OVERWRITE_TARGET_TRIPLE when using a
-            // json spec file.
-            // ====> maybe not since we specify both --target and --target-triple.
-        }
         if self.target_triple.is_empty() {
             self.target_triple = self.host_triple.clone();
         }
@@ -374,7 +365,6 @@ impl ConfigInfo {
             if self.target_triple.is_empty() {
                 return Err("Unknown non-native platform".to_string());
             }
-            // TODO: check if this is still needed.
             linker = Some(format!("-Clinker={}-gcc", self.target_triple));
             self.run_in_vm = true;
         }
-- 
cgit 1.4.1-3-g733a5


From f1b5a5638ec3aba301dc5a50daccb4c1ed69ac78 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Thu, 3 Jul 2025 08:57:32 +0000
Subject: wrapping shift: remove first bitmask and table

---
 library/core/src/num/wrapping.rs | 48 +++++-----------------------------------
 1 file changed, 6 insertions(+), 42 deletions(-)

diff --git a/library/core/src/num/wrapping.rs b/library/core/src/num/wrapping.rs
index 55fa91d0b9f..c460f38bd2e 100644
--- a/library/core/src/num/wrapping.rs
+++ b/library/core/src/num/wrapping.rs
@@ -94,9 +94,9 @@ macro_rules! sh_impl_signed {
             #[inline]
             fn shl(self, other: $f) -> Wrapping<$t> {
                 if other < 0 {
-                    Wrapping(self.0.wrapping_shr((-other & self::shift_max::$t as $f) as u32))
+                    Wrapping(self.0.wrapping_shr(-other as u32))
                 } else {
-                    Wrapping(self.0.wrapping_shl((other & self::shift_max::$t as $f) as u32))
+                    Wrapping(self.0.wrapping_shl(other as u32))
                 }
             }
         }
@@ -119,9 +119,9 @@ macro_rules! sh_impl_signed {
             #[inline]
             fn shr(self, other: $f) -> Wrapping<$t> {
                 if other < 0 {
-                    Wrapping(self.0.wrapping_shl((-other & self::shift_max::$t as $f) as u32))
+                    Wrapping(self.0.wrapping_shl(-other as u32))
                 } else {
-                    Wrapping(self.0.wrapping_shr((other & self::shift_max::$t as $f) as u32))
+                    Wrapping(self.0.wrapping_shr(other as u32))
                 }
             }
         }
@@ -147,7 +147,7 @@ macro_rules! sh_impl_unsigned {
 
             #[inline]
             fn shl(self, other: $f) -> Wrapping<$t> {
-                Wrapping(self.0.wrapping_shl((other & self::shift_max::$t as $f) as u32))
+                Wrapping(self.0.wrapping_shl(other as u32))
             }
         }
         forward_ref_binop! { impl Shl, shl for Wrapping<$t>, $f,
@@ -168,7 +168,7 @@ macro_rules! sh_impl_unsigned {
 
             #[inline]
             fn shr(self, other: $f) -> Wrapping<$t> {
-                Wrapping(self.0.wrapping_shr((other & self::shift_max::$t as $f) as u32))
+                Wrapping(self.0.wrapping_shr(other as u32))
             }
         }
         forward_ref_binop! { impl Shr, shr for Wrapping<$t>, $f,
@@ -1052,39 +1052,3 @@ macro_rules! wrapping_int_impl_unsigned {
 }
 
 wrapping_int_impl_unsigned! { usize u8 u16 u32 u64 u128 }
-
-mod shift_max {
-    #![allow(non_upper_case_globals)]
-
-    #[cfg(target_pointer_width = "16")]
-    mod platform {
-        pub(crate) const usize: u32 = super::u16;
-        pub(crate) const isize: u32 = super::i16;
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    mod platform {
-        pub(crate) const usize: u32 = super::u32;
-        pub(crate) const isize: u32 = super::i32;
-    }
-
-    #[cfg(target_pointer_width = "64")]
-    mod platform {
-        pub(crate) const usize: u32 = super::u64;
-        pub(crate) const isize: u32 = super::i64;
-    }
-
-    pub(super) const i8: u32 = (1 << 3) - 1;
-    pub(super) const i16: u32 = (1 << 4) - 1;
-    pub(super) const i32: u32 = (1 << 5) - 1;
-    pub(super) const i64: u32 = (1 << 6) - 1;
-    pub(super) const i128: u32 = (1 << 7) - 1;
-    pub(super) use self::platform::isize;
-
-    pub(super) const u8: u32 = i8;
-    pub(super) const u16: u32 = i16;
-    pub(super) const u32: u32 = i32;
-    pub(super) const u64: u32 = i64;
-    pub(super) const u128: u32 = i128;
-    pub(super) use self::platform::usize;
-}
-- 
cgit 1.4.1-3-g733a5


From 8bc4add5796fa81ce53c1df6509867fb49a7582d Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Thu, 3 Jul 2025 12:50:03 +0200
Subject: Do not lint intrinsics as empty loops

---
 clippy_lints/src/loops/empty_loop.rs | 15 +++++++++++++--
 tests/ui/empty_loop_intrinsic.rs     | 13 +++++++++++++
 2 files changed, 26 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/empty_loop_intrinsic.rs

diff --git a/clippy_lints/src/loops/empty_loop.rs b/clippy_lints/src/loops/empty_loop.rs
index 823cf0f4322..e809987d75a 100644
--- a/clippy_lints/src/loops/empty_loop.rs
+++ b/clippy_lints/src/loops/empty_loop.rs
@@ -1,11 +1,22 @@
 use super::EMPTY_LOOP;
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{is_in_panic_handler, is_no_std_crate};
+use clippy_utils::{is_in_panic_handler, is_no_std_crate, sym};
 
-use rustc_hir::{Block, Expr};
+use rustc_hir::{Block, Expr, ItemKind, Node};
 use rustc_lint::LateContext;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, loop_block: &Block<'_>) {
+    let parent_hir_id = cx.tcx.parent_hir_id(expr.hir_id);
+    if let Node::Item(parent_node) = cx.tcx.hir_node(parent_hir_id)
+        && matches!(parent_node.kind, ItemKind::Fn { .. })
+        && let attrs = cx.tcx.hir_attrs(parent_hir_id)
+        && attrs.iter().any(|attr| attr.has_name(sym::rustc_intrinsic))
+    {
+        // Intrinsic functions are expanded into an empty loop when lowering the AST
+        // to simplify the job of later passes which might expect any function to have a body.
+        return;
+    }
+
     if loop_block.stmts.is_empty() && loop_block.expr.is_none() && !is_in_panic_handler(cx, expr) {
         let msg = "empty `loop {}` wastes CPU cycles";
         let help = if is_no_std_crate(cx) {
diff --git a/tests/ui/empty_loop_intrinsic.rs b/tests/ui/empty_loop_intrinsic.rs
new file mode 100644
index 00000000000..a550e560965
--- /dev/null
+++ b/tests/ui/empty_loop_intrinsic.rs
@@ -0,0 +1,13 @@
+//@check-pass
+
+#![warn(clippy::empty_loop)]
+#![feature(intrinsics)]
+#![feature(rustc_attrs)]
+
+// From issue #15200
+#[rustc_intrinsic]
+#[rustc_nounwind]
+/// # Safety
+pub const unsafe fn simd_insert<T, U>(x: T, idx: u32, val: U) -> T;
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 7060377bfe52e08fe1f52b45dd67f665d2944c50 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Mon, 2 Jun 2025 23:40:01 -0600
Subject: refactor: Make -Ztrack-diagnostics emit like a note

---
 tests/ui/track-diagnostics-clippy.stderr | 4 ++--
 tests/ui/track-diagnostics.rs            | 1 +
 tests/ui/track-diagnostics.stderr        | 3 ++-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/tests/ui/track-diagnostics-clippy.stderr b/tests/ui/track-diagnostics-clippy.stderr
index f3aca685417..9d6538112bf 100644
--- a/tests/ui/track-diagnostics-clippy.stderr
+++ b/tests/ui/track-diagnostics-clippy.stderr
@@ -3,8 +3,8 @@ error: casting to the same type is unnecessary (`u32` -> `u32`)
    |
 LL |     let b = a as u32;
    |             ^^^^^^^^ help: try: `a`
--Ztrack-diagnostics: created at src/tools/clippy/clippy_lints/src/casts/unnecessary_cast.rs:LL:CC
    |
+   = note: -Ztrack-diagnostics: created at src/tools/clippy/clippy_lints/src/casts/unnecessary_cast.rs:LL:CC
    = note: `-D clippy::unnecessary-cast` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_cast)]`
 
@@ -15,8 +15,8 @@ LL |         let d = 42;
    |         ----------- unnecessary `let` binding
 LL |         d
    |         ^
--Ztrack-diagnostics: created at src/tools/clippy/clippy_lints/src/returns.rs:LL:CC
    |
+   = note: -Ztrack-diagnostics: created at src/tools/clippy/clippy_lints/src/returns.rs:LL:CC
    = note: `-D clippy::let-and-return` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::let_and_return)]`
 help: return the expression directly
diff --git a/tests/ui/track-diagnostics.rs b/tests/ui/track-diagnostics.rs
index 723ea23e9a6..0fbde867390 100644
--- a/tests/ui/track-diagnostics.rs
+++ b/tests/ui/track-diagnostics.rs
@@ -8,5 +8,6 @@ struct A;
 struct B;
 const S: A = B;
 //~^ ERROR: mismatched types
+//~| NOTE: created at
 
 fn main() {}
diff --git a/tests/ui/track-diagnostics.stderr b/tests/ui/track-diagnostics.stderr
index 83451fb658d..45262ba618f 100644
--- a/tests/ui/track-diagnostics.stderr
+++ b/tests/ui/track-diagnostics.stderr
@@ -3,7 +3,8 @@ error[E0308]: mismatched types
    |
 LL | const S: A = B;
    |              ^ expected `A`, found `B`
--Ztrack-diagnostics: created at compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs:LL:CC
+   |
+   = note: -Ztrack-diagnostics: created at compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs:LL:CC
 
 error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From 653bb64c7530c86d00b875e1ef14ac75455d2d80 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 3 Jul 2025 14:24:58 +0000
Subject: Remove LtoModuleCodegen

Most uses of it either contain a fat or thin lto module. Only
WorkItem::LTO could contain both, but splitting that enum variant
doesn't complicate things much.
---
 compiler/rustc_codegen_gcc/src/back/lto.rs     | 15 +++----
 compiler/rustc_codegen_gcc/src/lib.rs          |  6 +--
 compiler/rustc_codegen_llvm/src/back/lto.rs    | 17 +++-----
 compiler/rustc_codegen_llvm/src/lib.rs         |  6 +--
 compiler/rustc_codegen_ssa/src/back/lto.rs     | 60 --------------------------
 compiler/rustc_codegen_ssa/src/back/write.rs   | 48 +++++++++++++++------
 compiler/rustc_codegen_ssa/src/traits/write.rs |  6 +--
 7 files changed, 58 insertions(+), 100 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/back/lto.rs b/compiler/rustc_codegen_gcc/src/back/lto.rs
index 10fce860b77..e554dd2500b 100644
--- a/compiler/rustc_codegen_gcc/src/back/lto.rs
+++ b/compiler/rustc_codegen_gcc/src/back/lto.rs
@@ -24,7 +24,7 @@ use std::sync::Arc;
 
 use gccjit::{Context, OutputKind};
 use object::read::archive::ArchiveFile;
-use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule, ThinShared};
+use rustc_codegen_ssa::back::lto::{SerializedModule, ThinModule, ThinShared};
 use rustc_codegen_ssa::back::symbol_export;
 use rustc_codegen_ssa::back::write::{CodegenContext, FatLtoInput};
 use rustc_codegen_ssa::traits::*;
@@ -176,7 +176,7 @@ pub(crate) fn run_fat(
     cgcx: &CodegenContext<GccCodegenBackend>,
     modules: Vec<FatLtoInput<GccCodegenBackend>>,
     cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
-) -> Result<LtoModuleCodegen<GccCodegenBackend>, FatalError> {
+) -> Result<ModuleCodegen<GccContext>, FatalError> {
     let dcx = cgcx.create_dcx();
     let dcx = dcx.handle();
     let lto_data = prepare_lto(cgcx, dcx)?;
@@ -201,7 +201,7 @@ fn fat_lto(
     mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
     tmp_path: TempDir,
     //symbols_below_threshold: &[String],
-) -> Result<LtoModuleCodegen<GccCodegenBackend>, FatalError> {
+) -> Result<ModuleCodegen<GccContext>, FatalError> {
     let _timer = cgcx.prof.generic_activity("GCC_fat_lto_build_monolithic_module");
     info!("going for a fat lto");
 
@@ -334,7 +334,7 @@ fn fat_lto(
     // of now.
     module.module_llvm.temp_dir = Some(tmp_path);
 
-    Ok(LtoModuleCodegen::Fat(module))
+    Ok(module)
 }
 
 pub struct ModuleBuffer(PathBuf);
@@ -358,7 +358,7 @@ pub(crate) fn run_thin(
     cgcx: &CodegenContext<GccCodegenBackend>,
     modules: Vec<(String, ThinBuffer)>,
     cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
-) -> Result<(Vec<LtoModuleCodegen<GccCodegenBackend>>, Vec<WorkProduct>), FatalError> {
+) -> Result<(Vec<ThinModule<GccCodegenBackend>>, Vec<WorkProduct>), FatalError> {
     let dcx = cgcx.create_dcx();
     let dcx = dcx.handle();
     let lto_data = prepare_lto(cgcx, dcx)?;
@@ -427,7 +427,7 @@ fn thin_lto(
     tmp_path: TempDir,
     cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
     //_symbols_below_threshold: &[String],
-) -> Result<(Vec<LtoModuleCodegen<GccCodegenBackend>>, Vec<WorkProduct>), FatalError> {
+) -> Result<(Vec<ThinModule<GccCodegenBackend>>, Vec<WorkProduct>), FatalError> {
     let _timer = cgcx.prof.generic_activity("LLVM_thin_lto_global_analysis");
     info!("going for that thin, thin LTO");
 
@@ -573,8 +573,7 @@ fn thin_lto(
         }*/
 
         info!(" - {}: re-compiled", module_name);
-        opt_jobs
-            .push(LtoModuleCodegen::Thin(ThinModule { shared: shared.clone(), idx: module_index }));
+        opt_jobs.push(ThinModule { shared: shared.clone(), idx: module_index });
     }
 
     // Save the current ThinLTO import information for the next compilation
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index a912678ef2a..a151a0ab755 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -97,7 +97,7 @@ use gccjit::{CType, Context, OptimizationLevel};
 use gccjit::{TargetInfo, Version};
 use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_ast::expand::autodiff_attrs::AutoDiffItem;
-use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
+use rustc_codegen_ssa::back::lto::{SerializedModule, ThinModule};
 use rustc_codegen_ssa::back::write::{
     CodegenContext, FatLtoInput, ModuleConfig, TargetMachineFactoryFn,
 };
@@ -361,7 +361,7 @@ impl WriteBackendMethods for GccCodegenBackend {
         cgcx: &CodegenContext<Self>,
         modules: Vec<FatLtoInput<Self>>,
         cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
-    ) -> Result<LtoModuleCodegen<Self>, FatalError> {
+    ) -> Result<ModuleCodegen<Self::Module>, FatalError> {
         back::lto::run_fat(cgcx, modules, cached_modules)
     }
 
@@ -369,7 +369,7 @@ impl WriteBackendMethods for GccCodegenBackend {
         cgcx: &CodegenContext<Self>,
         modules: Vec<(String, Self::ThinBuffer)>,
         cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
-    ) -> Result<(Vec<LtoModuleCodegen<Self>>, Vec<WorkProduct>), FatalError> {
+    ) -> Result<(Vec<ThinModule<Self>>, Vec<WorkProduct>), FatalError> {
         back::lto::run_thin(cgcx, modules, cached_modules)
     }
 
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index 9c62244f3c9..0198b9f0cf0 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -7,7 +7,7 @@ use std::sync::Arc;
 use std::{io, iter, slice};
 
 use object::read::archive::ArchiveFile;
-use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule, ThinShared};
+use rustc_codegen_ssa::back::lto::{SerializedModule, ThinModule, ThinShared};
 use rustc_codegen_ssa::back::symbol_export;
 use rustc_codegen_ssa::back::write::{CodegenContext, FatLtoInput};
 use rustc_codegen_ssa::traits::*;
@@ -201,7 +201,7 @@ pub(crate) fn run_fat(
     cgcx: &CodegenContext<LlvmCodegenBackend>,
     modules: Vec<FatLtoInput<LlvmCodegenBackend>>,
     cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
-) -> Result<LtoModuleCodegen<LlvmCodegenBackend>, FatalError> {
+) -> Result<ModuleCodegen<ModuleLlvm>, FatalError> {
     let dcx = cgcx.create_dcx();
     let dcx = dcx.handle();
     let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, dcx)?;
@@ -217,7 +217,7 @@ pub(crate) fn run_thin(
     cgcx: &CodegenContext<LlvmCodegenBackend>,
     modules: Vec<(String, ThinBuffer)>,
     cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
-) -> Result<(Vec<LtoModuleCodegen<LlvmCodegenBackend>>, Vec<WorkProduct>), FatalError> {
+) -> Result<(Vec<ThinModule<LlvmCodegenBackend>>, Vec<WorkProduct>), FatalError> {
     let dcx = cgcx.create_dcx();
     let dcx = dcx.handle();
     let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, dcx)?;
@@ -248,7 +248,7 @@ fn fat_lto(
     cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
     mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
     symbols_below_threshold: &[*const libc::c_char],
-) -> Result<LtoModuleCodegen<LlvmCodegenBackend>, FatalError> {
+) -> Result<ModuleCodegen<ModuleLlvm>, FatalError> {
     let _timer = cgcx.prof.generic_activity("LLVM_fat_lto_build_monolithic_module");
     info!("going for a fat lto");
 
@@ -366,7 +366,7 @@ fn fat_lto(
         save_temp_bitcode(cgcx, &module, "lto.after-restriction");
     }
 
-    Ok(LtoModuleCodegen::Fat(module))
+    Ok(module)
 }
 
 pub(crate) struct Linker<'a>(&'a mut llvm::Linker<'a>);
@@ -436,7 +436,7 @@ fn thin_lto(
     serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
     cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
     symbols_below_threshold: &[*const libc::c_char],
-) -> Result<(Vec<LtoModuleCodegen<LlvmCodegenBackend>>, Vec<WorkProduct>), FatalError> {
+) -> Result<(Vec<ThinModule<LlvmCodegenBackend>>, Vec<WorkProduct>), FatalError> {
     let _timer = cgcx.prof.generic_activity("LLVM_thin_lto_global_analysis");
     unsafe {
         info!("going for that thin, thin LTO");
@@ -568,10 +568,7 @@ fn thin_lto(
             }
 
             info!(" - {}: re-compiled", module_name);
-            opt_jobs.push(LtoModuleCodegen::Thin(ThinModule {
-                shared: Arc::clone(&shared),
-                idx: module_index,
-            }));
+            opt_jobs.push(ThinModule { shared: Arc::clone(&shared), idx: module_index });
         }
 
         // Save the current ThinLTO import information for the next compilation
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index cdfffbe47bf..57b37959e0d 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -30,7 +30,7 @@ use errors::{AutoDiffWithoutLTO, ParseTargetMachineConfig};
 use llvm_util::target_config;
 use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_ast::expand::autodiff_attrs::AutoDiffItem;
-use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
+use rustc_codegen_ssa::back::lto::{SerializedModule, ThinModule};
 use rustc_codegen_ssa::back::write::{
     CodegenContext, FatLtoInput, ModuleConfig, TargetMachineFactoryConfig, TargetMachineFactoryFn,
 };
@@ -178,14 +178,14 @@ impl WriteBackendMethods for LlvmCodegenBackend {
         cgcx: &CodegenContext<Self>,
         modules: Vec<FatLtoInput<Self>>,
         cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
-    ) -> Result<LtoModuleCodegen<Self>, FatalError> {
+    ) -> Result<ModuleCodegen<Self::Module>, FatalError> {
         back::lto::run_fat(cgcx, modules, cached_modules)
     }
     fn run_thin_lto(
         cgcx: &CodegenContext<Self>,
         modules: Vec<(String, Self::ThinBuffer)>,
         cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
-    ) -> Result<(Vec<LtoModuleCodegen<Self>>, Vec<WorkProduct>), FatalError> {
+    ) -> Result<(Vec<ThinModule<Self>>, Vec<WorkProduct>), FatalError> {
         back::lto::run_thin(cgcx, modules, cached_modules)
     }
     fn optimize(
diff --git a/compiler/rustc_codegen_ssa/src/back/lto.rs b/compiler/rustc_codegen_ssa/src/back/lto.rs
index ce6fe8a191b..b49b6783bbd 100644
--- a/compiler/rustc_codegen_ssa/src/back/lto.rs
+++ b/compiler/rustc_codegen_ssa/src/back/lto.rs
@@ -1,13 +1,8 @@
 use std::ffi::CString;
 use std::sync::Arc;
 
-use rustc_ast::expand::autodiff_attrs::AutoDiffItem;
 use rustc_data_structures::memmap::Mmap;
-use rustc_errors::FatalError;
 
-use super::write::CodegenContext;
-use crate::ModuleCodegen;
-use crate::back::write::ModuleConfig;
 use crate::traits::*;
 
 pub struct ThinModule<B: WriteBackendMethods> {
@@ -42,61 +37,6 @@ pub struct ThinShared<B: WriteBackendMethods> {
     pub module_names: Vec<CString>,
 }
 
-pub enum LtoModuleCodegen<B: WriteBackendMethods> {
-    Fat(ModuleCodegen<B::Module>),
-    Thin(ThinModule<B>),
-}
-
-impl<B: WriteBackendMethods> LtoModuleCodegen<B> {
-    pub fn name(&self) -> &str {
-        match *self {
-            LtoModuleCodegen::Fat(_) => "everything",
-            LtoModuleCodegen::Thin(ref m) => m.name(),
-        }
-    }
-
-    /// Optimize this module within the given codegen context.
-    pub fn optimize(
-        self,
-        cgcx: &CodegenContext<B>,
-    ) -> Result<ModuleCodegen<B::Module>, FatalError> {
-        match self {
-            LtoModuleCodegen::Fat(mut module) => {
-                B::optimize_fat(cgcx, &mut module)?;
-                Ok(module)
-            }
-            LtoModuleCodegen::Thin(thin) => B::optimize_thin(cgcx, thin),
-        }
-    }
-
-    /// A "gauge" of how costly it is to optimize this module, used to sort
-    /// biggest modules first.
-    pub fn cost(&self) -> u64 {
-        match *self {
-            // Only one module with fat LTO, so the cost doesn't matter.
-            LtoModuleCodegen::Fat(_) => 0,
-            LtoModuleCodegen::Thin(ref m) => m.cost(),
-        }
-    }
-
-    /// Run autodiff on Fat LTO module
-    pub fn autodiff(
-        self,
-        cgcx: &CodegenContext<B>,
-        diff_fncs: Vec<AutoDiffItem>,
-        config: &ModuleConfig,
-    ) -> Result<LtoModuleCodegen<B>, FatalError> {
-        match &self {
-            LtoModuleCodegen::Fat(module) => {
-                B::autodiff(cgcx, &module, diff_fncs, config)?;
-            }
-            _ => panic!("autodiff called with non-fat LTO module"),
-        }
-
-        Ok(self)
-    }
-}
-
 pub enum SerializedModule<M: ModuleBufferMethods> {
     Local(M),
     FromRlib(Vec<u8>),
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 8330e4f7af0..5395b55092b 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -408,14 +408,16 @@ fn generate_lto_work<B: ExtraBackendMethods>(
 
     if !needs_fat_lto.is_empty() {
         assert!(needs_thin_lto.is_empty());
-        let mut module =
+        let module =
             B::run_fat_lto(cgcx, needs_fat_lto, import_only_modules).unwrap_or_else(|e| e.raise());
         if cgcx.lto == Lto::Fat && !autodiff.is_empty() {
             let config = cgcx.config(ModuleKind::Regular);
-            module = module.autodiff(cgcx, autodiff, config).unwrap_or_else(|e| e.raise());
+            if let Err(err) = B::autodiff(cgcx, &module, autodiff, config) {
+                err.raise();
+            }
         }
         // We are adding a single work item, so the cost doesn't matter.
-        vec![(WorkItem::LTO(module), 0)]
+        vec![(WorkItem::FatLto(module), 0)]
     } else {
         if !autodiff.is_empty() {
             let dcx = cgcx.create_dcx();
@@ -428,7 +430,7 @@ fn generate_lto_work<B: ExtraBackendMethods>(
             .into_iter()
             .map(|module| {
                 let cost = module.cost();
-                (WorkItem::LTO(module), cost)
+                (WorkItem::ThinLto(module), cost)
             })
             .chain(copy_jobs.into_iter().map(|wp| {
                 (
@@ -736,15 +738,19 @@ pub(crate) enum WorkItem<B: WriteBackendMethods> {
     /// Copy the post-LTO artifacts from the incremental cache to the output
     /// directory.
     CopyPostLtoArtifacts(CachedModuleCodegen),
-    /// Performs (Thin)LTO on the given module.
-    LTO(lto::LtoModuleCodegen<B>),
+    /// Performs fat LTO on the given module.
+    FatLto(ModuleCodegen<B::Module>),
+    /// Performs thin-LTO on the given module.
+    ThinLto(lto::ThinModule<B>),
 }
 
 impl<B: WriteBackendMethods> WorkItem<B> {
     fn module_kind(&self) -> ModuleKind {
         match *self {
             WorkItem::Optimize(ref m) => m.kind,
-            WorkItem::CopyPostLtoArtifacts(_) | WorkItem::LTO(_) => ModuleKind::Regular,
+            WorkItem::CopyPostLtoArtifacts(_) | WorkItem::FatLto(_) | WorkItem::ThinLto(_) => {
+                ModuleKind::Regular
+            }
         }
     }
 
@@ -792,7 +798,8 @@ impl<B: WriteBackendMethods> WorkItem<B> {
         match self {
             WorkItem::Optimize(m) => desc("opt", "optimize module", &m.name),
             WorkItem::CopyPostLtoArtifacts(m) => desc("cpy", "copy LTO artifacts for", &m.name),
-            WorkItem::LTO(m) => desc("lto", "LTO module", m.name()),
+            WorkItem::FatLto(_) => desc("lto", "fat LTO module", "everything"),
+            WorkItem::ThinLto(m) => desc("lto", "thin-LTO module", m.name()),
         }
     }
 }
@@ -996,12 +1003,21 @@ fn execute_copy_from_cache_work_item<B: ExtraBackendMethods>(
     })
 }
 
-fn execute_lto_work_item<B: ExtraBackendMethods>(
+fn execute_fat_lto_work_item<B: ExtraBackendMethods>(
+    cgcx: &CodegenContext<B>,
+    mut module: ModuleCodegen<B::Module>,
+    module_config: &ModuleConfig,
+) -> Result<WorkItemResult<B>, FatalError> {
+    B::optimize_fat(cgcx, &mut module)?;
+    finish_intra_module_work(cgcx, module, module_config)
+}
+
+fn execute_thin_lto_work_item<B: ExtraBackendMethods>(
     cgcx: &CodegenContext<B>,
-    module: lto::LtoModuleCodegen<B>,
+    module: lto::ThinModule<B>,
     module_config: &ModuleConfig,
 ) -> Result<WorkItemResult<B>, FatalError> {
-    let module = module.optimize(cgcx)?;
+    let module = B::optimize_thin(cgcx, module)?;
     finish_intra_module_work(cgcx, module, module_config)
 }
 
@@ -1842,10 +1858,16 @@ fn spawn_work<'a, B: ExtraBackendMethods>(
                     );
                     Ok(execute_copy_from_cache_work_item(&cgcx, m, module_config))
                 }
-                WorkItem::LTO(m) => {
+                WorkItem::FatLto(m) => {
+                    let _timer = cgcx
+                        .prof
+                        .generic_activity_with_arg("codegen_module_perform_lto", "everything");
+                    execute_fat_lto_work_item(&cgcx, m, module_config)
+                }
+                WorkItem::ThinLto(m) => {
                     let _timer =
                         cgcx.prof.generic_activity_with_arg("codegen_module_perform_lto", m.name());
-                    execute_lto_work_item(&cgcx, m, module_config)
+                    execute_thin_lto_work_item(&cgcx, m, module_config)
                 }
             })
         };
diff --git a/compiler/rustc_codegen_ssa/src/traits/write.rs b/compiler/rustc_codegen_ssa/src/traits/write.rs
index 07a0609fda1..78380973ffc 100644
--- a/compiler/rustc_codegen_ssa/src/traits/write.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/write.rs
@@ -2,7 +2,7 @@ use rustc_ast::expand::autodiff_attrs::AutoDiffItem;
 use rustc_errors::{DiagCtxtHandle, FatalError};
 use rustc_middle::dep_graph::WorkProduct;
 
-use crate::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
+use crate::back::lto::{SerializedModule, ThinModule};
 use crate::back::write::{CodegenContext, FatLtoInput, ModuleConfig};
 use crate::{CompiledModule, ModuleCodegen};
 
@@ -26,7 +26,7 @@ pub trait WriteBackendMethods: Clone + 'static {
         cgcx: &CodegenContext<Self>,
         modules: Vec<FatLtoInput<Self>>,
         cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
-    ) -> Result<LtoModuleCodegen<Self>, FatalError>;
+    ) -> Result<ModuleCodegen<Self::Module>, FatalError>;
     /// Performs thin LTO by performing necessary global analysis and returning two
     /// lists, one of the modules that need optimization and another for modules that
     /// can simply be copied over from the incr. comp. cache.
@@ -34,7 +34,7 @@ pub trait WriteBackendMethods: Clone + 'static {
         cgcx: &CodegenContext<Self>,
         modules: Vec<(String, Self::ThinBuffer)>,
         cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
-    ) -> Result<(Vec<LtoModuleCodegen<Self>>, Vec<WorkProduct>), FatalError>;
+    ) -> Result<(Vec<ThinModule<Self>>, Vec<WorkProduct>), FatalError>;
     fn print_pass_timings(&self);
     fn print_statistics(&self);
     fn optimize(
-- 
cgit 1.4.1-3-g733a5


From 7fd78df3463c761a693ea79265a6a1faaf2ed51b Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 3 Jul 2025 14:43:09 +0000
Subject: Move dcx creation into WriteBackendMethods::codegen

---
 compiler/rustc_codegen_gcc/src/back/write.rs   | 4 +++-
 compiler/rustc_codegen_gcc/src/lib.rs          | 3 +--
 compiler/rustc_codegen_llvm/src/back/write.rs  | 4 +++-
 compiler/rustc_codegen_llvm/src/lib.rs         | 3 +--
 compiler/rustc_codegen_ssa/src/back/write.rs   | 7 ++-----
 compiler/rustc_codegen_ssa/src/traits/write.rs | 1 -
 6 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/back/write.rs b/compiler/rustc_codegen_gcc/src/back/write.rs
index d03d063bdac..113abe70805 100644
--- a/compiler/rustc_codegen_gcc/src/back/write.rs
+++ b/compiler/rustc_codegen_gcc/src/back/write.rs
@@ -16,10 +16,12 @@ use crate::{GccCodegenBackend, GccContext};
 
 pub(crate) fn codegen(
     cgcx: &CodegenContext<GccCodegenBackend>,
-    dcx: DiagCtxtHandle<'_>,
     module: ModuleCodegen<GccContext>,
     config: &ModuleConfig,
 ) -> Result<CompiledModule, FatalError> {
+    let dcx = cgcx.create_dcx();
+    let dcx = dcx.handle();
+
     let _timer = cgcx.prof.generic_activity_with_arg("GCC_module_codegen", &*module.name);
     {
         let context = &module.module_llvm.context;
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index a151a0ab755..34452bdd200 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -408,11 +408,10 @@ impl WriteBackendMethods for GccCodegenBackend {
 
     fn codegen(
         cgcx: &CodegenContext<Self>,
-        dcx: DiagCtxtHandle<'_>,
         module: ModuleCodegen<Self::Module>,
         config: &ModuleConfig,
     ) -> Result<CompiledModule, FatalError> {
-        back::write::codegen(cgcx, dcx, module, config)
+        back::write::codegen(cgcx, module, config)
     }
 
     fn prepare_thin(
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index bde6a9cf4bc..1f7a785bbe7 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -817,10 +817,12 @@ pub(crate) fn link(
 
 pub(crate) fn codegen(
     cgcx: &CodegenContext<LlvmCodegenBackend>,
-    dcx: DiagCtxtHandle<'_>,
     module: ModuleCodegen<ModuleLlvm>,
     config: &ModuleConfig,
 ) -> Result<CompiledModule, FatalError> {
+    let dcx = cgcx.create_dcx();
+    let dcx = dcx.handle();
+
     let _timer = cgcx.prof.generic_activity_with_arg("LLVM_module_codegen", &*module.name);
     {
         let llmod = module.module_llvm.llmod();
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 57b37959e0d..4d85683de8c 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -212,11 +212,10 @@ impl WriteBackendMethods for LlvmCodegenBackend {
     }
     fn codegen(
         cgcx: &CodegenContext<Self>,
-        dcx: DiagCtxtHandle<'_>,
         module: ModuleCodegen<Self::Module>,
         config: &ModuleConfig,
     ) -> Result<CompiledModule, FatalError> {
-        back::write::codegen(cgcx, dcx, module, config)
+        back::write::codegen(cgcx, module, config)
     }
     fn prepare_thin(
         module: ModuleCodegen<Self::Module>,
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 5395b55092b..29e67be6eb6 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -1026,11 +1026,8 @@ fn finish_intra_module_work<B: ExtraBackendMethods>(
     module: ModuleCodegen<B::Module>,
     module_config: &ModuleConfig,
 ) -> Result<WorkItemResult<B>, FatalError> {
-    let dcx = cgcx.create_dcx();
-    let dcx = dcx.handle();
-
     if !cgcx.opts.unstable_opts.combine_cgu || module.kind == ModuleKind::Allocator {
-        let module = B::codegen(cgcx, dcx, module, module_config)?;
+        let module = B::codegen(cgcx, module, module_config)?;
         Ok(WorkItemResult::Finished(module))
     } else {
         Ok(WorkItemResult::NeedsLink(module))
@@ -1718,7 +1715,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
             let dcx = dcx.handle();
             let module = B::run_link(&cgcx, dcx, needs_link).map_err(|_| ())?;
             let module =
-                B::codegen(&cgcx, dcx, module, cgcx.config(ModuleKind::Regular)).map_err(|_| ())?;
+                B::codegen(&cgcx, module, cgcx.config(ModuleKind::Regular)).map_err(|_| ())?;
             compiled_modules.push(module);
         }
 
diff --git a/compiler/rustc_codegen_ssa/src/traits/write.rs b/compiler/rustc_codegen_ssa/src/traits/write.rs
index 78380973ffc..c732c4b2ab8 100644
--- a/compiler/rustc_codegen_ssa/src/traits/write.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/write.rs
@@ -53,7 +53,6 @@ pub trait WriteBackendMethods: Clone + 'static {
     ) -> Result<ModuleCodegen<Self::Module>, FatalError>;
     fn codegen(
         cgcx: &CodegenContext<Self>,
-        dcx: DiagCtxtHandle<'_>,
         module: ModuleCodegen<Self::Module>,
         config: &ModuleConfig,
     ) -> Result<CompiledModule, FatalError>;
-- 
cgit 1.4.1-3-g733a5


From ee280a596d3b7c401547be9a6afadf7298ee3a55 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 3 Jul 2025 14:44:26 +0000
Subject: Fat LTO always produces a single object file, so -Zcombine-cgu has no
 effect

---
 compiler/rustc_codegen_ssa/src/back/write.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 29e67be6eb6..762dc8f6c2d 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -1009,7 +1009,9 @@ fn execute_fat_lto_work_item<B: ExtraBackendMethods>(
     module_config: &ModuleConfig,
 ) -> Result<WorkItemResult<B>, FatalError> {
     B::optimize_fat(cgcx, &mut module)?;
-    finish_intra_module_work(cgcx, module, module_config)
+
+    let module = B::codegen(cgcx, module, module_config)?;
+    Ok(WorkItemResult::Finished(module))
 }
 
 fn execute_thin_lto_work_item<B: ExtraBackendMethods>(
-- 
cgit 1.4.1-3-g733a5


From 797084dc92c251ff0c986adfdd4a7e261f499b02 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 3 Jul 2025 14:50:28 +0000
Subject: Split generate_lto_work between fat and thin-LTO cases

---
 compiler/rustc_codegen_ssa/src/back/write.rs | 112 +++++++++++++++------------
 1 file changed, 63 insertions(+), 49 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 762dc8f6c2d..21d5d3ced00 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -397,52 +397,50 @@ impl<B: WriteBackendMethods> CodegenContext<B> {
     }
 }
 
-fn generate_lto_work<B: ExtraBackendMethods>(
+fn generate_fat_lto_work<B: ExtraBackendMethods>(
     cgcx: &CodegenContext<B>,
     autodiff: Vec<AutoDiffItem>,
     needs_fat_lto: Vec<FatLtoInput<B>>,
-    needs_thin_lto: Vec<(String, B::ThinBuffer)>,
     import_only_modules: Vec<(SerializedModule<B::ModuleBuffer>, WorkProduct)>,
-) -> Vec<(WorkItem<B>, u64)> {
+) -> WorkItem<B> {
     let _prof_timer = cgcx.prof.generic_activity("codegen_generate_lto_work");
 
-    if !needs_fat_lto.is_empty() {
-        assert!(needs_thin_lto.is_empty());
-        let module =
-            B::run_fat_lto(cgcx, needs_fat_lto, import_only_modules).unwrap_or_else(|e| e.raise());
-        if cgcx.lto == Lto::Fat && !autodiff.is_empty() {
-            let config = cgcx.config(ModuleKind::Regular);
-            if let Err(err) = B::autodiff(cgcx, &module, autodiff, config) {
-                err.raise();
-            }
+    let module =
+        B::run_fat_lto(cgcx, needs_fat_lto, import_only_modules).unwrap_or_else(|e| e.raise());
+    if cgcx.lto == Lto::Fat && !autodiff.is_empty() {
+        let config = cgcx.config(ModuleKind::Regular);
+        if let Err(err) = B::autodiff(cgcx, &module, autodiff, config) {
+            err.raise();
         }
-        // We are adding a single work item, so the cost doesn't matter.
-        vec![(WorkItem::FatLto(module), 0)]
-    } else {
-        if !autodiff.is_empty() {
-            let dcx = cgcx.create_dcx();
-            dcx.handle().emit_fatal(AutodiffWithoutLto {});
-        }
-        assert!(needs_fat_lto.is_empty());
-        let (lto_modules, copy_jobs) = B::run_thin_lto(cgcx, needs_thin_lto, import_only_modules)
-            .unwrap_or_else(|e| e.raise());
-        lto_modules
-            .into_iter()
-            .map(|module| {
-                let cost = module.cost();
-                (WorkItem::ThinLto(module), cost)
-            })
-            .chain(copy_jobs.into_iter().map(|wp| {
-                (
-                    WorkItem::CopyPostLtoArtifacts(CachedModuleCodegen {
-                        name: wp.cgu_name.clone(),
-                        source: wp,
-                    }),
-                    0, // copying is very cheap
-                )
-            }))
-            .collect()
     }
+    WorkItem::FatLto(module)
+}
+
+fn generate_thin_lto_work<B: ExtraBackendMethods>(
+    cgcx: &CodegenContext<B>,
+    needs_thin_lto: Vec<(String, B::ThinBuffer)>,
+    import_only_modules: Vec<(SerializedModule<B::ModuleBuffer>, WorkProduct)>,
+) -> Vec<(WorkItem<B>, u64)> {
+    let _prof_timer = cgcx.prof.generic_activity("codegen_thin_generate_lto_work");
+
+    let (lto_modules, copy_jobs) =
+        B::run_thin_lto(cgcx, needs_thin_lto, import_only_modules).unwrap_or_else(|e| e.raise());
+    lto_modules
+        .into_iter()
+        .map(|module| {
+            let cost = module.cost();
+            (WorkItem::ThinLto(module), cost)
+        })
+        .chain(copy_jobs.into_iter().map(|wp| {
+            (
+                WorkItem::CopyPostLtoArtifacts(CachedModuleCodegen {
+                    name: wp.cgu_name.clone(),
+                    source: wp,
+                }),
+                0, // copying is very cheap
+            )
+        }))
+        .collect()
 }
 
 struct CompiledModules {
@@ -1489,20 +1487,36 @@ fn start_executing_work<B: ExtraBackendMethods>(
                     let needs_thin_lto = mem::take(&mut needs_thin_lto);
                     let import_only_modules = mem::take(&mut lto_import_only_modules);
 
-                    for (work, cost) in generate_lto_work(
-                        &cgcx,
-                        autodiff_items.clone(),
-                        needs_fat_lto,
-                        needs_thin_lto,
-                        import_only_modules,
-                    ) {
-                        let insertion_index = work_items
-                            .binary_search_by_key(&cost, |&(_, cost)| cost)
-                            .unwrap_or_else(|e| e);
-                        work_items.insert(insertion_index, (work, cost));
+                    if !needs_fat_lto.is_empty() {
+                        assert!(needs_thin_lto.is_empty());
+
+                        let work = generate_fat_lto_work(
+                            &cgcx,
+                            autodiff_items.clone(),
+                            needs_fat_lto,
+                            import_only_modules,
+                        );
+                        work_items.push((work, 0));
                         if cgcx.parallel {
                             helper.request_token();
                         }
+                    } else {
+                        if !autodiff_items.is_empty() {
+                            let dcx = cgcx.create_dcx();
+                            dcx.handle().emit_fatal(AutodiffWithoutLto {});
+                        }
+
+                        for (work, cost) in
+                            generate_thin_lto_work(&cgcx, needs_thin_lto, import_only_modules)
+                        {
+                            let insertion_index = work_items
+                                .binary_search_by_key(&cost, |&(_, cost)| cost)
+                                .unwrap_or_else(|e| e);
+                            work_items.insert(insertion_index, (work, cost));
+                            if cgcx.parallel {
+                                helper.request_token();
+                            }
+                        }
                     }
                 }
 
-- 
cgit 1.4.1-3-g733a5


From a4f9d7a3f3de0096780e86b7a82a8474fc14fc59 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Tue, 2 Jul 2024 09:38:49 +0000
Subject: Replace kw_span by full span.

---
 clippy_utils/src/ast_utils/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_utils/src/ast_utils/mod.rs b/clippy_utils/src/ast_utils/mod.rs
index e65914b9b5e..e6396987cc6 100644
--- a/clippy_utils/src/ast_utils/mod.rs
+++ b/clippy_utils/src/ast_utils/mod.rs
@@ -886,13 +886,13 @@ pub fn eq_generic_param(l: &GenericParam, r: &GenericParam) -> bool {
             (
                 Const {
                     ty: lt,
-                    kw_span: _,
                     default: ld,
+                    span: _,
                 },
                 Const {
                     ty: rt,
-                    kw_span: _,
                     default: rd,
+                    span: _,
                 },
             ) => eq_ty(lt, rt) && both(ld.as_ref(), rd.as_ref(), eq_anon_const),
             _ => false,
-- 
cgit 1.4.1-3-g733a5


From 25ab022f2951318e8ffdec2d8566c3a7d164e00d Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Sun, 29 Jun 2025 15:37:28 +0800
Subject: move `tests/ui/resolve/suggest*` to `tests/ui/resolve/suggestions/`

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 .../auxiliary/suggest-constructor-cycle-error.rs   |  12 --
 tests/ui/resolve/suggest-builder-fn.rs             |  64 --------
 tests/ui/resolve/suggest-builder-fn.stderr         |  51 ------
 .../ui/resolve/suggest-constructor-cycle-error.rs  |  10 --
 .../resolve/suggest-constructor-cycle-error.stderr |  15 --
 .../suggest-import-without-clobbering-attrs.fixed  |  16 --
 .../suggest-import-without-clobbering-attrs.rs     |  15 --
 .../suggest-import-without-clobbering-attrs.stderr |  14 --
 tests/ui/resolve/suggest-path-for-tuple-struct.rs  |  26 ---
 .../resolve/suggest-path-for-tuple-struct.stderr   |  27 ----
 .../suggest-path-instead-of-mod-dot-item.rs        | 111 -------------
 .../suggest-path-instead-of-mod-dot-item.stderr    | 178 ---------------------
 .../auxiliary/suggest-constructor-cycle-error.rs   |  12 ++
 tests/ui/resolve/suggestions/suggest-builder-fn.rs |  64 ++++++++
 .../resolve/suggestions/suggest-builder-fn.stderr  |  51 ++++++
 .../suggestions/suggest-constructor-cycle-error.rs |  10 ++
 .../suggest-constructor-cycle-error.stderr         |  15 ++
 .../suggest-import-without-clobbering-attrs.fixed  |  16 ++
 .../suggest-import-without-clobbering-attrs.rs     |  15 ++
 .../suggest-import-without-clobbering-attrs.stderr |  14 ++
 .../suggestions/suggest-path-for-tuple-struct.rs   |  26 +++
 .../suggest-path-for-tuple-struct.stderr           |  27 ++++
 .../suggest-path-instead-of-mod-dot-item.rs        | 111 +++++++++++++
 .../suggest-path-instead-of-mod-dot-item.stderr    | 178 +++++++++++++++++++++
 24 files changed, 539 insertions(+), 539 deletions(-)
 delete mode 100644 tests/ui/resolve/auxiliary/suggest-constructor-cycle-error.rs
 delete mode 100644 tests/ui/resolve/suggest-builder-fn.rs
 delete mode 100644 tests/ui/resolve/suggest-builder-fn.stderr
 delete mode 100644 tests/ui/resolve/suggest-constructor-cycle-error.rs
 delete mode 100644 tests/ui/resolve/suggest-constructor-cycle-error.stderr
 delete mode 100644 tests/ui/resolve/suggest-import-without-clobbering-attrs.fixed
 delete mode 100644 tests/ui/resolve/suggest-import-without-clobbering-attrs.rs
 delete mode 100644 tests/ui/resolve/suggest-import-without-clobbering-attrs.stderr
 delete mode 100644 tests/ui/resolve/suggest-path-for-tuple-struct.rs
 delete mode 100644 tests/ui/resolve/suggest-path-for-tuple-struct.stderr
 delete mode 100644 tests/ui/resolve/suggest-path-instead-of-mod-dot-item.rs
 delete mode 100644 tests/ui/resolve/suggest-path-instead-of-mod-dot-item.stderr
 create mode 100644 tests/ui/resolve/suggestions/auxiliary/suggest-constructor-cycle-error.rs
 create mode 100644 tests/ui/resolve/suggestions/suggest-builder-fn.rs
 create mode 100644 tests/ui/resolve/suggestions/suggest-builder-fn.stderr
 create mode 100644 tests/ui/resolve/suggestions/suggest-constructor-cycle-error.rs
 create mode 100644 tests/ui/resolve/suggestions/suggest-constructor-cycle-error.stderr
 create mode 100644 tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.fixed
 create mode 100644 tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.rs
 create mode 100644 tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.stderr
 create mode 100644 tests/ui/resolve/suggestions/suggest-path-for-tuple-struct.rs
 create mode 100644 tests/ui/resolve/suggestions/suggest-path-for-tuple-struct.stderr
 create mode 100644 tests/ui/resolve/suggestions/suggest-path-instead-of-mod-dot-item.rs
 create mode 100644 tests/ui/resolve/suggestions/suggest-path-instead-of-mod-dot-item.stderr

diff --git a/tests/ui/resolve/auxiliary/suggest-constructor-cycle-error.rs b/tests/ui/resolve/auxiliary/suggest-constructor-cycle-error.rs
deleted file mode 100644
index 8de68c38bc3..00000000000
--- a/tests/ui/resolve/auxiliary/suggest-constructor-cycle-error.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-mod m {
-    pub struct Uuid(());
-
-    impl Uuid {
-        pub fn encode_buffer() -> [u8; LENGTH] {
-            []
-        }
-    }
-    const LENGTH: usize = 0;
-}
-
-pub use m::Uuid;
diff --git a/tests/ui/resolve/suggest-builder-fn.rs b/tests/ui/resolve/suggest-builder-fn.rs
deleted file mode 100644
index 959675ef2c9..00000000000
--- a/tests/ui/resolve/suggest-builder-fn.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Tests that we suggest the right alternatives when
-// a builder method cannot be resolved
-
-use std::net::TcpStream;
-
-trait SomeTrait {}
-
-struct Foo<T> {
-    v : T
-}
-
-impl<T: SomeTrait + Default> Foo<T> {
-    // Should not be suggested if constraint on the impl not met
-    fn new() -> Self {
-        Self { v: T::default() }
-    }
-}
-
-struct Bar;
-
-impl Bar {
-    // Should be suggested
-    fn build() -> Self {
-        Self {}
-    }
-
-    // Method with self can't be a builder.
-    // Should not be suggested
-    fn build_with_self(&self) -> Self {
-        Self {}
-    }
-}
-
-mod SomeMod {
-    use crate::Bar;
-
-    impl Bar {
-        // Public method. Should be suggested
-        pub fn build_public() -> Self {
-            Self {}
-        }
-
-        // Private method. Should not be suggested
-        fn build_private() -> Self {
-            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
-
-    // 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
-
-   // 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
-}
diff --git a/tests/ui/resolve/suggest-builder-fn.stderr b/tests/ui/resolve/suggest-builder-fn.stderr
deleted file mode 100644
index 9c5eed35ccf..00000000000
--- a/tests/ui/resolve/suggest-builder-fn.stderr
+++ /dev/null
@@ -1,51 +0,0 @@
-error[E0599]: no function or associated item 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`
-   |
-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
-  --> $DIR/suggest-builder-fn.rs:57:27
-   |
-LL | struct Foo<T> {
-   | ------------- function or associated item `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
-   |
-note: trait bound `u8: SomeTrait` was not satisfied
-  --> $DIR/suggest-builder-fn.rs:12:9
-   |
-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
-  --> $DIR/suggest-builder-fn.rs:62:21
-   |
-LL | struct Bar;
-   | ---------- function or associated item `new` not found for this struct
-...
-LL |     let _bar = Bar::new();
-   |                     ^^^ function or associated item not found in `Bar`
-   |
-note: if you're trying to build a new `Bar` consider using one of the following associated functions:
-      Bar::build
-      SomeMod::<impl Bar>::build_public
-  --> $DIR/suggest-builder-fn.rs:23:5
-   |
-LL |     fn build() -> Self {
-   |     ^^^^^^^^^^^^^^^^^^
-...
-LL |         pub fn build_public() -> Self {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/resolve/suggest-constructor-cycle-error.rs b/tests/ui/resolve/suggest-constructor-cycle-error.rs
deleted file mode 100644
index c23d6788eef..00000000000
--- a/tests/ui/resolve/suggest-constructor-cycle-error.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ aux-build:suggest-constructor-cycle-error.rs
-
-// Regression test for https://github.com/rust-lang/rust/issues/119625
-
-extern crate suggest_constructor_cycle_error as a;
-
-const CONST_NAME: a::Uuid = a::Uuid(());
-//~^ ERROR: cannot initialize a tuple struct which contains private fields [E0423]
-
-fn main() {}
diff --git a/tests/ui/resolve/suggest-constructor-cycle-error.stderr b/tests/ui/resolve/suggest-constructor-cycle-error.stderr
deleted file mode 100644
index c6ec2465a43..00000000000
--- a/tests/ui/resolve/suggest-constructor-cycle-error.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0423]: cannot initialize a tuple struct which contains private fields
-  --> $DIR/suggest-constructor-cycle-error.rs:7:29
-   |
-LL | const CONST_NAME: a::Uuid = a::Uuid(());
-   |                             ^^^^^^^
-   |
-note: constructor is not visible here due to private fields
-  --> $DIR/auxiliary/suggest-constructor-cycle-error.rs:2:21
-   |
-LL |     pub struct Uuid(());
-   |                     ^^ private field
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/resolve/suggest-import-without-clobbering-attrs.fixed b/tests/ui/resolve/suggest-import-without-clobbering-attrs.fixed
deleted file mode 100644
index 607c9af4927..00000000000
--- a/tests/ui/resolve/suggest-import-without-clobbering-attrs.fixed
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ run-rustfix
-//@ compile-flags: -Aunused
-
-use y::z;
-#[cfg(all())]
-use y::Whatever;
-
-mod y {
-    pub(crate) fn z() {}
-    pub(crate) struct Whatever;
-}
-
-fn main() {
-    z();
-    //~^ ERROR cannot find function `z` in this scope
-}
diff --git a/tests/ui/resolve/suggest-import-without-clobbering-attrs.rs b/tests/ui/resolve/suggest-import-without-clobbering-attrs.rs
deleted file mode 100644
index 6cc53fb1086..00000000000
--- a/tests/ui/resolve/suggest-import-without-clobbering-attrs.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ run-rustfix
-//@ compile-flags: -Aunused
-
-#[cfg(all())]
-use y::Whatever;
-
-mod y {
-    pub(crate) fn z() {}
-    pub(crate) struct Whatever;
-}
-
-fn main() {
-    z();
-    //~^ ERROR cannot find function `z` in this scope
-}
diff --git a/tests/ui/resolve/suggest-import-without-clobbering-attrs.stderr b/tests/ui/resolve/suggest-import-without-clobbering-attrs.stderr
deleted file mode 100644
index de65d695dd2..00000000000
--- a/tests/ui/resolve/suggest-import-without-clobbering-attrs.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error[E0425]: cannot find function `z` in this scope
-  --> $DIR/suggest-import-without-clobbering-attrs.rs:13:5
-   |
-LL |     z();
-   |     ^ not found in this scope
-   |
-help: consider importing this function
-   |
-LL + use y::z;
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/suggest-path-for-tuple-struct.rs b/tests/ui/resolve/suggest-path-for-tuple-struct.rs
deleted file mode 100644
index c8bc3e79fe2..00000000000
--- a/tests/ui/resolve/suggest-path-for-tuple-struct.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-mod module {
-    pub struct SomeTupleStruct(u8);
-    pub struct SomeRegularStruct {
-        foo: u8
-    }
-
-    impl SomeTupleStruct {
-        pub fn new() -> Self {
-            Self(0)
-        }
-    }
-    impl SomeRegularStruct {
-        pub fn new() -> Self {
-            Self { foo: 0 }
-        }
-    }
-}
-
-use module::{SomeTupleStruct, SomeRegularStruct};
-
-fn main() {
-    let _ = SomeTupleStruct.new();
-    //~^ ERROR expected value, found struct `SomeTupleStruct`
-    let _ = SomeRegularStruct.new();
-    //~^ ERROR expected value, found struct `SomeRegularStruct`
-}
diff --git a/tests/ui/resolve/suggest-path-for-tuple-struct.stderr b/tests/ui/resolve/suggest-path-for-tuple-struct.stderr
deleted file mode 100644
index 68a5b550978..00000000000
--- a/tests/ui/resolve/suggest-path-for-tuple-struct.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-error[E0423]: expected value, found struct `SomeTupleStruct`
-  --> $DIR/suggest-path-for-tuple-struct.rs:22:13
-   |
-LL |     let _ = SomeTupleStruct.new();
-   |             ^^^^^^^^^^^^^^^
-   |
-help: use the path separator to refer to an item
-   |
-LL -     let _ = SomeTupleStruct.new();
-LL +     let _ = SomeTupleStruct::new();
-   |
-
-error[E0423]: expected value, found struct `SomeRegularStruct`
-  --> $DIR/suggest-path-for-tuple-struct.rs:24:13
-   |
-LL |     let _ = SomeRegularStruct.new();
-   |             ^^^^^^^^^^^^^^^^^
-   |
-help: use the path separator to refer to an item
-   |
-LL -     let _ = SomeRegularStruct.new();
-LL +     let _ = SomeRegularStruct::new();
-   |
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/resolve/suggest-path-instead-of-mod-dot-item.rs b/tests/ui/resolve/suggest-path-instead-of-mod-dot-item.rs
deleted file mode 100644
index d5d6b13d62c..00000000000
--- a/tests/ui/resolve/suggest-path-instead-of-mod-dot-item.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-// Beginners write `mod.item` when they should write `mod::item`.
-// This tests that we suggest the latter when we encounter the former.
-
-pub mod a {
-    pub const I: i32 = 1;
-
-    pub fn f() -> i32 { 2 }
-
-    pub mod b {
-        pub const J: i32 = 3;
-
-        pub fn g() -> i32 { 4 }
-    }
-}
-
-fn h1() -> i32 {
-    a.I
-    //~^ ERROR expected value, found module `a`
-    //~| HELP use the path separator
-}
-
-fn h2() -> i32 {
-    a.g()
-    //~^ ERROR expected value, found module `a`
-    //~| HELP use the path separator
-}
-
-fn h3() -> i32 {
-    a.b.J
-    //~^ ERROR expected value, found module `a`
-    //~| HELP use the path separator
-}
-
-fn h4() -> i32 {
-    a::b.J
-    //~^ ERROR expected value, found module `a::b`
-    //~| HELP a constant with a similar name exists
-    //~| HELP use the path separator
-}
-
-fn h5() {
-    a.b.f();
-    //~^ ERROR expected value, found module `a`
-    //~| HELP use the path separator
-    let v = Vec::new();
-    v.push(a::b);
-    //~^ ERROR expected value, found module `a::b`
-    //~| HELP a constant with a similar name exists
-}
-
-fn h6() -> i32 {
-    a::b.f()
-    //~^ ERROR expected value, found module `a::b`
-    //~| HELP a constant with a similar name exists
-    //~| HELP use the path separator
-}
-
-fn h7() {
-    a::b
-    //~^ ERROR expected value, found module `a::b`
-    //~| HELP a constant with a similar name exists
-}
-
-fn h8() -> i32 {
-    a::b()
-    //~^ ERROR expected function, found module `a::b`
-    //~| HELP a constant with a similar name exists
-}
-
-macro_rules! module {
-    () => {
-        a
-        //~^ ERROR expected value, found module `a`
-        //~| ERROR expected value, found module `a`
-    };
-}
-
-macro_rules! create {
-    (method) => {
-        a.f()
-        //~^ ERROR expected value, found module `a`
-        //~| HELP use the path separator
-    };
-    (field) => {
-        a.f
-        //~^ ERROR expected value, found module `a`
-        //~| HELP use the path separator
-    };
-}
-
-fn h9() {
-    //
-    // Note that if the receiver is a macro call, we do not want to suggest to replace
-    // `.` with `::` as that would be a syntax error.
-    // Since the receiver is a module and not a type, we cannot suggest to surround
-    // it with angle brackets.
-    //
-
-    module!().g::<()>(); // no `help` here!
-
-    module!().g; // no `help` here!
-
-    //
-    // Ensure that the suggestion is shown for expressions inside of macro definitions.
-    //
-
-    let _ = create!(method);
-    let _ = create!(field);
-}
-
-fn main() {}
diff --git a/tests/ui/resolve/suggest-path-instead-of-mod-dot-item.stderr b/tests/ui/resolve/suggest-path-instead-of-mod-dot-item.stderr
deleted file mode 100644
index 5db943cd10d..00000000000
--- a/tests/ui/resolve/suggest-path-instead-of-mod-dot-item.stderr
+++ /dev/null
@@ -1,178 +0,0 @@
-error[E0423]: expected value, found module `a`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:17:5
-   |
-LL |     a.I
-   |     ^
-   |
-help: use the path separator to refer to an item
-   |
-LL -     a.I
-LL +     a::I
-   |
-
-error[E0423]: expected value, found module `a`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:23:5
-   |
-LL |     a.g()
-   |     ^
-   |
-help: use the path separator to refer to an item
-   |
-LL -     a.g()
-LL +     a::g()
-   |
-
-error[E0423]: expected value, found module `a`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:29:5
-   |
-LL |     a.b.J
-   |     ^
-   |
-help: use the path separator to refer to an item
-   |
-LL -     a.b.J
-LL +     a::b.J
-   |
-
-error[E0423]: expected value, found module `a::b`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:35:5
-   |
-LL |     pub const I: i32 = 1;
-   |     --------------------- similarly named constant `I` defined here
-...
-LL |     a::b.J
-   |     ^^^^
-   |
-help: use the path separator to refer to an item
-   |
-LL -     a::b.J
-LL +     a::b::J
-   |
-help: a constant with a similar name exists
-   |
-LL -     a::b.J
-LL +     a::I.J
-   |
-
-error[E0423]: expected value, found module `a`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:42:5
-   |
-LL |     a.b.f();
-   |     ^
-   |
-help: use the path separator to refer to an item
-   |
-LL -     a.b.f();
-LL +     a::b.f();
-   |
-
-error[E0423]: expected value, found module `a::b`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:46:12
-   |
-LL |     pub const I: i32 = 1;
-   |     --------------------- similarly named constant `I` defined here
-...
-LL |     v.push(a::b);
-   |            ^^^-
-   |               |
-   |               help: a constant with a similar name exists: `I`
-
-error[E0423]: expected value, found module `a::b`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:52:5
-   |
-LL |     pub const I: i32 = 1;
-   |     --------------------- similarly named constant `I` defined here
-...
-LL |     a::b.f()
-   |     ^^^^
-   |
-help: use the path separator to refer to an item
-   |
-LL -     a::b.f()
-LL +     a::b::f()
-   |
-help: a constant with a similar name exists
-   |
-LL -     a::b.f()
-LL +     a::I.f()
-   |
-
-error[E0423]: expected value, found module `a::b`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:59:5
-   |
-LL |     pub const I: i32 = 1;
-   |     --------------------- similarly named constant `I` defined here
-...
-LL |     a::b
-   |     ^^^-
-   |        |
-   |        help: a constant with a similar name exists: `I`
-
-error[E0423]: expected function, found module `a::b`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:65:5
-   |
-LL |     pub const I: i32 = 1;
-   |     --------------------- similarly named constant `I` defined here
-...
-LL |     a::b()
-   |     ^^^-
-   |        |
-   |        help: a constant with a similar name exists: `I`
-
-error[E0423]: expected value, found module `a`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:72:9
-   |
-LL |         a
-   |         ^ not a value
-...
-LL |     module!().g::<()>(); // no `help` here!
-   |     --------- in this macro invocation
-   |
-   = note: this error originates in the macro `module` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0423]: expected value, found module `a`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:72:9
-   |
-LL |         a
-   |         ^ not a value
-...
-LL |     module!().g; // no `help` here!
-   |     --------- in this macro invocation
-   |
-   = note: this error originates in the macro `module` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0423]: expected value, found module `a`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:80:9
-   |
-LL |         a.f()
-   |         ^
-...
-LL |     let _ = create!(method);
-   |             --------------- in this macro invocation
-   |
-   = note: this error originates in the macro `create` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: use the path separator to refer to an item
-   |
-LL -         a.f()
-LL +         a::f()
-   |
-
-error[E0423]: expected value, found module `a`
-  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:85:9
-   |
-LL |         a.f
-   |         ^
-...
-LL |     let _ = create!(field);
-   |             -------------- in this macro invocation
-   |
-   = note: this error originates in the macro `create` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: use the path separator to refer to an item
-   |
-LL -         a.f
-LL +         a::f
-   |
-
-error: aborting due to 13 previous errors
-
-For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/resolve/suggestions/auxiliary/suggest-constructor-cycle-error.rs b/tests/ui/resolve/suggestions/auxiliary/suggest-constructor-cycle-error.rs
new file mode 100644
index 00000000000..8de68c38bc3
--- /dev/null
+++ b/tests/ui/resolve/suggestions/auxiliary/suggest-constructor-cycle-error.rs
@@ -0,0 +1,12 @@
+mod m {
+    pub struct Uuid(());
+
+    impl Uuid {
+        pub fn encode_buffer() -> [u8; LENGTH] {
+            []
+        }
+    }
+    const LENGTH: usize = 0;
+}
+
+pub use m::Uuid;
diff --git a/tests/ui/resolve/suggestions/suggest-builder-fn.rs b/tests/ui/resolve/suggestions/suggest-builder-fn.rs
new file mode 100644
index 00000000000..959675ef2c9
--- /dev/null
+++ b/tests/ui/resolve/suggestions/suggest-builder-fn.rs
@@ -0,0 +1,64 @@
+// Tests that we suggest the right alternatives when
+// a builder method cannot be resolved
+
+use std::net::TcpStream;
+
+trait SomeTrait {}
+
+struct Foo<T> {
+    v : T
+}
+
+impl<T: SomeTrait + Default> Foo<T> {
+    // Should not be suggested if constraint on the impl not met
+    fn new() -> Self {
+        Self { v: T::default() }
+    }
+}
+
+struct Bar;
+
+impl Bar {
+    // Should be suggested
+    fn build() -> Self {
+        Self {}
+    }
+
+    // Method with self can't be a builder.
+    // Should not be suggested
+    fn build_with_self(&self) -> Self {
+        Self {}
+    }
+}
+
+mod SomeMod {
+    use crate::Bar;
+
+    impl Bar {
+        // Public method. Should be suggested
+        pub fn build_public() -> Self {
+            Self {}
+        }
+
+        // Private method. Should not be suggested
+        fn build_private() -> Self {
+            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
+
+    // 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
+
+   // 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
+}
diff --git a/tests/ui/resolve/suggestions/suggest-builder-fn.stderr b/tests/ui/resolve/suggestions/suggest-builder-fn.stderr
new file mode 100644
index 00000000000..9c5eed35ccf
--- /dev/null
+++ b/tests/ui/resolve/suggestions/suggest-builder-fn.stderr
@@ -0,0 +1,51 @@
+error[E0599]: no function or associated item 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`
+   |
+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
+  --> $DIR/suggest-builder-fn.rs:57:27
+   |
+LL | struct Foo<T> {
+   | ------------- function or associated item `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
+   |
+note: trait bound `u8: SomeTrait` was not satisfied
+  --> $DIR/suggest-builder-fn.rs:12:9
+   |
+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
+  --> $DIR/suggest-builder-fn.rs:62:21
+   |
+LL | struct Bar;
+   | ---------- function or associated item `new` not found for this struct
+...
+LL |     let _bar = Bar::new();
+   |                     ^^^ function or associated item not found in `Bar`
+   |
+note: if you're trying to build a new `Bar` consider using one of the following associated functions:
+      Bar::build
+      SomeMod::<impl Bar>::build_public
+  --> $DIR/suggest-builder-fn.rs:23:5
+   |
+LL |     fn build() -> Self {
+   |     ^^^^^^^^^^^^^^^^^^
+...
+LL |         pub fn build_public() -> Self {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0599`.
diff --git a/tests/ui/resolve/suggestions/suggest-constructor-cycle-error.rs b/tests/ui/resolve/suggestions/suggest-constructor-cycle-error.rs
new file mode 100644
index 00000000000..c23d6788eef
--- /dev/null
+++ b/tests/ui/resolve/suggestions/suggest-constructor-cycle-error.rs
@@ -0,0 +1,10 @@
+//@ aux-build:suggest-constructor-cycle-error.rs
+
+// Regression test for https://github.com/rust-lang/rust/issues/119625
+
+extern crate suggest_constructor_cycle_error as a;
+
+const CONST_NAME: a::Uuid = a::Uuid(());
+//~^ ERROR: cannot initialize a tuple struct which contains private fields [E0423]
+
+fn main() {}
diff --git a/tests/ui/resolve/suggestions/suggest-constructor-cycle-error.stderr b/tests/ui/resolve/suggestions/suggest-constructor-cycle-error.stderr
new file mode 100644
index 00000000000..c6ec2465a43
--- /dev/null
+++ b/tests/ui/resolve/suggestions/suggest-constructor-cycle-error.stderr
@@ -0,0 +1,15 @@
+error[E0423]: cannot initialize a tuple struct which contains private fields
+  --> $DIR/suggest-constructor-cycle-error.rs:7:29
+   |
+LL | const CONST_NAME: a::Uuid = a::Uuid(());
+   |                             ^^^^^^^
+   |
+note: constructor is not visible here due to private fields
+  --> $DIR/auxiliary/suggest-constructor-cycle-error.rs:2:21
+   |
+LL |     pub struct Uuid(());
+   |                     ^^ private field
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.fixed b/tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.fixed
new file mode 100644
index 00000000000..607c9af4927
--- /dev/null
+++ b/tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.fixed
@@ -0,0 +1,16 @@
+//@ run-rustfix
+//@ compile-flags: -Aunused
+
+use y::z;
+#[cfg(all())]
+use y::Whatever;
+
+mod y {
+    pub(crate) fn z() {}
+    pub(crate) struct Whatever;
+}
+
+fn main() {
+    z();
+    //~^ ERROR cannot find function `z` in this scope
+}
diff --git a/tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.rs b/tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.rs
new file mode 100644
index 00000000000..6cc53fb1086
--- /dev/null
+++ b/tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.rs
@@ -0,0 +1,15 @@
+//@ run-rustfix
+//@ compile-flags: -Aunused
+
+#[cfg(all())]
+use y::Whatever;
+
+mod y {
+    pub(crate) fn z() {}
+    pub(crate) struct Whatever;
+}
+
+fn main() {
+    z();
+    //~^ ERROR cannot find function `z` in this scope
+}
diff --git a/tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.stderr b/tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.stderr
new file mode 100644
index 00000000000..de65d695dd2
--- /dev/null
+++ b/tests/ui/resolve/suggestions/suggest-import-without-clobbering-attrs.stderr
@@ -0,0 +1,14 @@
+error[E0425]: cannot find function `z` in this scope
+  --> $DIR/suggest-import-without-clobbering-attrs.rs:13:5
+   |
+LL |     z();
+   |     ^ not found in this scope
+   |
+help: consider importing this function
+   |
+LL + use y::z;
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/resolve/suggestions/suggest-path-for-tuple-struct.rs b/tests/ui/resolve/suggestions/suggest-path-for-tuple-struct.rs
new file mode 100644
index 00000000000..c8bc3e79fe2
--- /dev/null
+++ b/tests/ui/resolve/suggestions/suggest-path-for-tuple-struct.rs
@@ -0,0 +1,26 @@
+mod module {
+    pub struct SomeTupleStruct(u8);
+    pub struct SomeRegularStruct {
+        foo: u8
+    }
+
+    impl SomeTupleStruct {
+        pub fn new() -> Self {
+            Self(0)
+        }
+    }
+    impl SomeRegularStruct {
+        pub fn new() -> Self {
+            Self { foo: 0 }
+        }
+    }
+}
+
+use module::{SomeTupleStruct, SomeRegularStruct};
+
+fn main() {
+    let _ = SomeTupleStruct.new();
+    //~^ ERROR expected value, found struct `SomeTupleStruct`
+    let _ = SomeRegularStruct.new();
+    //~^ ERROR expected value, found struct `SomeRegularStruct`
+}
diff --git a/tests/ui/resolve/suggestions/suggest-path-for-tuple-struct.stderr b/tests/ui/resolve/suggestions/suggest-path-for-tuple-struct.stderr
new file mode 100644
index 00000000000..68a5b550978
--- /dev/null
+++ b/tests/ui/resolve/suggestions/suggest-path-for-tuple-struct.stderr
@@ -0,0 +1,27 @@
+error[E0423]: expected value, found struct `SomeTupleStruct`
+  --> $DIR/suggest-path-for-tuple-struct.rs:22:13
+   |
+LL |     let _ = SomeTupleStruct.new();
+   |             ^^^^^^^^^^^^^^^
+   |
+help: use the path separator to refer to an item
+   |
+LL -     let _ = SomeTupleStruct.new();
+LL +     let _ = SomeTupleStruct::new();
+   |
+
+error[E0423]: expected value, found struct `SomeRegularStruct`
+  --> $DIR/suggest-path-for-tuple-struct.rs:24:13
+   |
+LL |     let _ = SomeRegularStruct.new();
+   |             ^^^^^^^^^^^^^^^^^
+   |
+help: use the path separator to refer to an item
+   |
+LL -     let _ = SomeRegularStruct.new();
+LL +     let _ = SomeRegularStruct::new();
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/resolve/suggestions/suggest-path-instead-of-mod-dot-item.rs b/tests/ui/resolve/suggestions/suggest-path-instead-of-mod-dot-item.rs
new file mode 100644
index 00000000000..d5d6b13d62c
--- /dev/null
+++ b/tests/ui/resolve/suggestions/suggest-path-instead-of-mod-dot-item.rs
@@ -0,0 +1,111 @@
+// Beginners write `mod.item` when they should write `mod::item`.
+// This tests that we suggest the latter when we encounter the former.
+
+pub mod a {
+    pub const I: i32 = 1;
+
+    pub fn f() -> i32 { 2 }
+
+    pub mod b {
+        pub const J: i32 = 3;
+
+        pub fn g() -> i32 { 4 }
+    }
+}
+
+fn h1() -> i32 {
+    a.I
+    //~^ ERROR expected value, found module `a`
+    //~| HELP use the path separator
+}
+
+fn h2() -> i32 {
+    a.g()
+    //~^ ERROR expected value, found module `a`
+    //~| HELP use the path separator
+}
+
+fn h3() -> i32 {
+    a.b.J
+    //~^ ERROR expected value, found module `a`
+    //~| HELP use the path separator
+}
+
+fn h4() -> i32 {
+    a::b.J
+    //~^ ERROR expected value, found module `a::b`
+    //~| HELP a constant with a similar name exists
+    //~| HELP use the path separator
+}
+
+fn h5() {
+    a.b.f();
+    //~^ ERROR expected value, found module `a`
+    //~| HELP use the path separator
+    let v = Vec::new();
+    v.push(a::b);
+    //~^ ERROR expected value, found module `a::b`
+    //~| HELP a constant with a similar name exists
+}
+
+fn h6() -> i32 {
+    a::b.f()
+    //~^ ERROR expected value, found module `a::b`
+    //~| HELP a constant with a similar name exists
+    //~| HELP use the path separator
+}
+
+fn h7() {
+    a::b
+    //~^ ERROR expected value, found module `a::b`
+    //~| HELP a constant with a similar name exists
+}
+
+fn h8() -> i32 {
+    a::b()
+    //~^ ERROR expected function, found module `a::b`
+    //~| HELP a constant with a similar name exists
+}
+
+macro_rules! module {
+    () => {
+        a
+        //~^ ERROR expected value, found module `a`
+        //~| ERROR expected value, found module `a`
+    };
+}
+
+macro_rules! create {
+    (method) => {
+        a.f()
+        //~^ ERROR expected value, found module `a`
+        //~| HELP use the path separator
+    };
+    (field) => {
+        a.f
+        //~^ ERROR expected value, found module `a`
+        //~| HELP use the path separator
+    };
+}
+
+fn h9() {
+    //
+    // Note that if the receiver is a macro call, we do not want to suggest to replace
+    // `.` with `::` as that would be a syntax error.
+    // Since the receiver is a module and not a type, we cannot suggest to surround
+    // it with angle brackets.
+    //
+
+    module!().g::<()>(); // no `help` here!
+
+    module!().g; // no `help` here!
+
+    //
+    // Ensure that the suggestion is shown for expressions inside of macro definitions.
+    //
+
+    let _ = create!(method);
+    let _ = create!(field);
+}
+
+fn main() {}
diff --git a/tests/ui/resolve/suggestions/suggest-path-instead-of-mod-dot-item.stderr b/tests/ui/resolve/suggestions/suggest-path-instead-of-mod-dot-item.stderr
new file mode 100644
index 00000000000..5db943cd10d
--- /dev/null
+++ b/tests/ui/resolve/suggestions/suggest-path-instead-of-mod-dot-item.stderr
@@ -0,0 +1,178 @@
+error[E0423]: expected value, found module `a`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:17:5
+   |
+LL |     a.I
+   |     ^
+   |
+help: use the path separator to refer to an item
+   |
+LL -     a.I
+LL +     a::I
+   |
+
+error[E0423]: expected value, found module `a`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:23:5
+   |
+LL |     a.g()
+   |     ^
+   |
+help: use the path separator to refer to an item
+   |
+LL -     a.g()
+LL +     a::g()
+   |
+
+error[E0423]: expected value, found module `a`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:29:5
+   |
+LL |     a.b.J
+   |     ^
+   |
+help: use the path separator to refer to an item
+   |
+LL -     a.b.J
+LL +     a::b.J
+   |
+
+error[E0423]: expected value, found module `a::b`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:35:5
+   |
+LL |     pub const I: i32 = 1;
+   |     --------------------- similarly named constant `I` defined here
+...
+LL |     a::b.J
+   |     ^^^^
+   |
+help: use the path separator to refer to an item
+   |
+LL -     a::b.J
+LL +     a::b::J
+   |
+help: a constant with a similar name exists
+   |
+LL -     a::b.J
+LL +     a::I.J
+   |
+
+error[E0423]: expected value, found module `a`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:42:5
+   |
+LL |     a.b.f();
+   |     ^
+   |
+help: use the path separator to refer to an item
+   |
+LL -     a.b.f();
+LL +     a::b.f();
+   |
+
+error[E0423]: expected value, found module `a::b`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:46:12
+   |
+LL |     pub const I: i32 = 1;
+   |     --------------------- similarly named constant `I` defined here
+...
+LL |     v.push(a::b);
+   |            ^^^-
+   |               |
+   |               help: a constant with a similar name exists: `I`
+
+error[E0423]: expected value, found module `a::b`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:52:5
+   |
+LL |     pub const I: i32 = 1;
+   |     --------------------- similarly named constant `I` defined here
+...
+LL |     a::b.f()
+   |     ^^^^
+   |
+help: use the path separator to refer to an item
+   |
+LL -     a::b.f()
+LL +     a::b::f()
+   |
+help: a constant with a similar name exists
+   |
+LL -     a::b.f()
+LL +     a::I.f()
+   |
+
+error[E0423]: expected value, found module `a::b`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:59:5
+   |
+LL |     pub const I: i32 = 1;
+   |     --------------------- similarly named constant `I` defined here
+...
+LL |     a::b
+   |     ^^^-
+   |        |
+   |        help: a constant with a similar name exists: `I`
+
+error[E0423]: expected function, found module `a::b`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:65:5
+   |
+LL |     pub const I: i32 = 1;
+   |     --------------------- similarly named constant `I` defined here
+...
+LL |     a::b()
+   |     ^^^-
+   |        |
+   |        help: a constant with a similar name exists: `I`
+
+error[E0423]: expected value, found module `a`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:72:9
+   |
+LL |         a
+   |         ^ not a value
+...
+LL |     module!().g::<()>(); // no `help` here!
+   |     --------- in this macro invocation
+   |
+   = note: this error originates in the macro `module` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0423]: expected value, found module `a`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:72:9
+   |
+LL |         a
+   |         ^ not a value
+...
+LL |     module!().g; // no `help` here!
+   |     --------- in this macro invocation
+   |
+   = note: this error originates in the macro `module` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0423]: expected value, found module `a`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:80:9
+   |
+LL |         a.f()
+   |         ^
+...
+LL |     let _ = create!(method);
+   |             --------------- in this macro invocation
+   |
+   = note: this error originates in the macro `create` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: use the path separator to refer to an item
+   |
+LL -         a.f()
+LL +         a::f()
+   |
+
+error[E0423]: expected value, found module `a`
+  --> $DIR/suggest-path-instead-of-mod-dot-item.rs:85:9
+   |
+LL |         a.f
+   |         ^
+...
+LL |     let _ = create!(field);
+   |             -------------- in this macro invocation
+   |
+   = note: this error originates in the macro `create` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: use the path separator to refer to an item
+   |
+LL -         a.f
+LL +         a::f
+   |
+
+error: aborting due to 13 previous errors
+
+For more information about this error, try `rustc --explain E0423`.
-- 
cgit 1.4.1-3-g733a5


From 000f038e9999ebdbaf3167c42dadc3db872a5d3f Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Sun, 29 Jun 2025 15:38:09 +0800
Subject: Add ui test resolve/false-self-in-macro-issue-143134.rs

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 tests/ui/resolve/false-self-in-macro-issue-143134.rs     | 10 ++++++++++
 tests/ui/resolve/false-self-in-macro-issue-143134.stderr | 12 ++++++++++++
 2 files changed, 22 insertions(+)
 create mode 100644 tests/ui/resolve/false-self-in-macro-issue-143134.rs
 create mode 100644 tests/ui/resolve/false-self-in-macro-issue-143134.stderr

diff --git a/tests/ui/resolve/false-self-in-macro-issue-143134.rs b/tests/ui/resolve/false-self-in-macro-issue-143134.rs
new file mode 100644
index 00000000000..0983b8b3dc3
--- /dev/null
+++ b/tests/ui/resolve/false-self-in-macro-issue-143134.rs
@@ -0,0 +1,10 @@
+trait T {
+    fn f(self);
+  }
+  impl T for () {
+    fn f(self) {
+        let self = (); //~ ERROR expected unit struct, unit variant or constant, found local variable `self`
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/resolve/false-self-in-macro-issue-143134.stderr b/tests/ui/resolve/false-self-in-macro-issue-143134.stderr
new file mode 100644
index 00000000000..43e77e183ae
--- /dev/null
+++ b/tests/ui/resolve/false-self-in-macro-issue-143134.stderr
@@ -0,0 +1,12 @@
+error[E0424]: expected unit struct, unit variant or constant, found local variable `self`
+  --> $DIR/false-self-in-macro-issue-143134.rs:6:13
+   |
+LL | /     fn f(self) {
+LL | |         let self = ();
+   | |             ^^^^ `self` value is a keyword and may not be bound to variables or shadowed
+LL | |     }
+   | |_____- this function has a `self` parameter, but a macro invocation can only access identifiers it receives from parameters
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0424`.
-- 
cgit 1.4.1-3-g733a5


From 332f1b1bdddb01f2f203f47cd3f30f677ae8d9ea Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 3 Jul 2025 15:39:19 +0000
Subject: Pass in autodiff items when starting the coordinator thread

As opposed to sending a message to the coordinator thread.
---
 compiler/rustc_codegen_ssa/src/back/write.rs | 16 ++++------------
 compiler/rustc_codegen_ssa/src/base.rs       |  9 ++-------
 2 files changed, 6 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 21d5d3ced00..dcee7aec733 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -470,6 +470,7 @@ pub(crate) fn start_async_codegen<B: ExtraBackendMethods>(
     backend: B,
     tcx: TyCtxt<'_>,
     target_cpu: String,
+    autodiff_items: &[AutoDiffItem],
 ) -> OngoingCodegen<B> {
     let (coordinator_send, coordinator_receive) = channel();
 
@@ -488,6 +489,7 @@ pub(crate) fn start_async_codegen<B: ExtraBackendMethods>(
         backend.clone(),
         tcx,
         &crate_info,
+        autodiff_items,
         shared_emitter,
         codegen_worker_send,
         coordinator_receive,
@@ -1044,9 +1046,6 @@ pub(crate) enum Message<B: WriteBackendMethods> {
     /// Sent from a backend worker thread.
     WorkItem { result: Result<WorkItemResult<B>, Option<WorkerFatalError>>, worker_id: usize },
 
-    /// A vector containing all the AutoDiff tasks that we have to pass to Enzyme.
-    AddAutoDiffItems(Vec<AutoDiffItem>),
-
     /// The frontend has finished generating something (backend IR or a
     /// post-LTO artifact) for a codegen unit, and it should be passed to the
     /// backend. Sent from the main thread.
@@ -1113,6 +1112,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
     backend: B,
     tcx: TyCtxt<'_>,
     crate_info: &CrateInfo,
+    autodiff_items: &[AutoDiffItem],
     shared_emitter: SharedEmitter,
     codegen_worker_send: Sender<CguMessage>,
     coordinator_receive: Receiver<Box<dyn Any + Send>>,
@@ -1122,6 +1122,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
 ) -> thread::JoinHandle<Result<CompiledModules, ()>> {
     let coordinator_send = tx_to_llvm_workers;
     let sess = tcx.sess;
+    let autodiff_items = autodiff_items.to_vec();
 
     let mut each_linked_rlib_for_lto = Vec::new();
     drop(link::each_linked_rlib(crate_info, None, &mut |cnum, path| {
@@ -1375,7 +1376,6 @@ fn start_executing_work<B: ExtraBackendMethods>(
 
         // This is where we collect codegen units that have gone all the way
         // through codegen and LLVM.
-        let mut autodiff_items = Vec::new();
         let mut compiled_modules = vec![];
         let mut compiled_allocator_module = None;
         let mut needs_link = Vec::new();
@@ -1645,10 +1645,6 @@ fn start_executing_work<B: ExtraBackendMethods>(
                     main_thread_state = MainThreadState::Idle;
                 }
 
-                Message::AddAutoDiffItems(mut items) => {
-                    autodiff_items.append(&mut items);
-                }
-
                 Message::CodegenComplete => {
                     if codegen_state != Aborted {
                         codegen_state = Completed;
@@ -2117,10 +2113,6 @@ impl<B: ExtraBackendMethods> OngoingCodegen<B> {
         drop(self.coordinator.sender.send(Box::new(Message::CodegenComplete::<B>)));
     }
 
-    pub(crate) fn submit_autodiff_items(&self, items: Vec<AutoDiffItem>) {
-        drop(self.coordinator.sender.send(Box::new(Message::<B>::AddAutoDiffItems(items))));
-    }
-
     pub(crate) fn check_for_errors(&self, sess: &Session) {
         self.shared_emitter_main.check(sess, false);
     }
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 102d4ea2fa6..01ce07f4ccf 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -647,7 +647,7 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
 ) -> OngoingCodegen<B> {
     // Skip crate items and just output metadata in -Z no-codegen mode.
     if tcx.sess.opts.unstable_opts.no_codegen || !tcx.sess.opts.output_types.should_codegen() {
-        let ongoing_codegen = start_async_codegen(backend, tcx, target_cpu);
+        let ongoing_codegen = start_async_codegen(backend, tcx, target_cpu, &[]);
 
         ongoing_codegen.codegen_finished(tcx);
 
@@ -667,7 +667,6 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
     // codegen units.
     let MonoItemPartitions { codegen_units, autodiff_items, .. } =
         tcx.collect_and_partition_mono_items(());
-    let autodiff_fncs = autodiff_items.to_vec();
 
     // Force all codegen_unit queries so they are already either red or green
     // when compile_codegen_unit accesses them. We are not able to re-execute
@@ -680,7 +679,7 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
         }
     }
 
-    let ongoing_codegen = start_async_codegen(backend.clone(), tcx, target_cpu);
+    let ongoing_codegen = start_async_codegen(backend.clone(), tcx, target_cpu, autodiff_items);
 
     // Codegen an allocator shim, if necessary.
     if let Some(kind) = allocator_kind_for_codegen(tcx) {
@@ -710,10 +709,6 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
         );
     }
 
-    if !autodiff_fncs.is_empty() {
-        ongoing_codegen.submit_autodiff_items(autodiff_fncs);
-    }
-
     // For better throughput during parallel processing by LLVM, we used to sort
     // CGUs largest to smallest. This would lead to better thread utilization
     // by, for example, preventing a large CGU from being processed last and
-- 
cgit 1.4.1-3-g733a5


From 3c56c2ecf53b8bbaa863c32c9e93ef2d3b102e28 Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Thu, 3 Jul 2025 23:39:31 +0800
Subject: stabilize `const_slice_reverse`

---
 library/core/src/slice/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index 3a3f44c6b85..35bebdbe522 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -967,7 +967,7 @@ impl<T> [T] {
     /// assert!(v == [3, 2, 1]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_slice_reverse", issue = "135120")]
+    #[rustc_const_stable(feature = "const_slice_reverse", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn reverse(&mut self) {
         let half_len = self.len() / 2;
@@ -1000,6 +1000,7 @@ impl<T> [T] {
             // this check tells LLVM that the indexing below is
             // in-bounds. Then after inlining -- once the actual
             // lengths of the slices are known -- it's removed.
+            // FIXME(const_trait_impl) replace with let (a, b) = (&mut a[..n], &mut b[..n]);
             let (a, _) = a.split_at_mut(n);
             let (b, _) = b.split_at_mut(n);
 
-- 
cgit 1.4.1-3-g733a5


From 236b392904d234d9ec2968c55ae20132405a555d Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Sun, 29 Jun 2025 16:10:52 +0800
Subject: Return early when `self` resolve failure because of `let self = ...`

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 compiler/rustc_resolve/src/late/diagnostics.rs           | 16 ++++++++++++----
 tests/ui/error-codes/E0424.stderr                        |  2 --
 tests/ui/resolve/false-self-in-macro-issue-143134.stderr |  7 ++-----
 3 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index e7b8c988cd4..0b78835326f 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -1183,15 +1183,23 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                 _ => "`self` value is a keyword only available in methods with a `self` parameter",
             },
         );
+
+        // using `let self` is wrong even if we're not in an associated method or if we're in a macro expansion.
+        // So, we should return early if we're in a pattern, see issue #143134.
+        if matches!(source, PathSource::Pat) {
+            return true;
+        }
+
         let is_assoc_fn = self.self_type_is_available();
         let self_from_macro = "a `self` parameter, but a macro invocation can only \
                                access identifiers it receives from parameters";
-        if let Some((fn_kind, span)) = &self.diag_metadata.current_function {
+        if let Some((fn_kind, fn_span)) = &self.diag_metadata.current_function {
             // The current function has a `self` parameter, but we were unable to resolve
             // a reference to `self`. This can only happen if the `self` identifier we
-            // are resolving came from a different hygiene context.
+            // are resolving came from a different hygiene context or a variable binding.
+            // But variable binding error is returned early above.
             if fn_kind.decl().inputs.get(0).is_some_and(|p| p.is_self()) {
-                err.span_label(*span, format!("this function has {self_from_macro}"));
+                err.span_label(*fn_span, format!("this function has {self_from_macro}"));
             } else {
                 let doesnt = if is_assoc_fn {
                     let (span, sugg) = fn_kind
@@ -1204,7 +1212,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                             // This avoids placing the suggestion into the visibility specifier.
                             let span = fn_kind
                                 .ident()
-                                .map_or(*span, |ident| span.with_lo(ident.span.hi()));
+                                .map_or(*fn_span, |ident| fn_span.with_lo(ident.span.hi()));
                             (
                                 self.r
                                     .tcx
diff --git a/tests/ui/error-codes/E0424.stderr b/tests/ui/error-codes/E0424.stderr
index d02da3e4ecb..831a070bf6c 100644
--- a/tests/ui/error-codes/E0424.stderr
+++ b/tests/ui/error-codes/E0424.stderr
@@ -40,8 +40,6 @@ LL |     fn qux(&self) {
 error[E0424]: expected unit struct, unit variant or constant, found module `self`
   --> $DIR/E0424.rs:20:9
    |
-LL | fn main () {
-   |    ---- this function can't have a `self` parameter
 LL |     let self = "self";
    |         ^^^^ `self` value is a keyword and may not be bound to variables or shadowed
 
diff --git a/tests/ui/resolve/false-self-in-macro-issue-143134.stderr b/tests/ui/resolve/false-self-in-macro-issue-143134.stderr
index 43e77e183ae..48c979575ea 100644
--- a/tests/ui/resolve/false-self-in-macro-issue-143134.stderr
+++ b/tests/ui/resolve/false-self-in-macro-issue-143134.stderr
@@ -1,11 +1,8 @@
 error[E0424]: expected unit struct, unit variant or constant, found local variable `self`
   --> $DIR/false-self-in-macro-issue-143134.rs:6:13
    |
-LL | /     fn f(self) {
-LL | |         let self = ();
-   | |             ^^^^ `self` value is a keyword and may not be bound to variables or shadowed
-LL | |     }
-   | |_____- this function has a `self` parameter, but a macro invocation can only access identifiers it receives from parameters
+LL |         let self = ();
+   |             ^^^^ `self` value is a keyword and may not be bound to variables or shadowed
 
 error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From 779cb00311dc0bbb942dbdaefa24f98bd2d4cbbe Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 3 Jul 2025 16:05:38 +0000
Subject: Move run_fat_lto call into execute_fat_lto_work_item

This will allow merging all fat LTO steps together. In addition it
reduces the amount of work done on the coordinator thread without
jobserver token.
---
 compiler/rustc_codegen_ssa/src/back/write.rs | 68 +++++++++++++++-------------
 1 file changed, 36 insertions(+), 32 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index dcee7aec733..c7d2fcef29f 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -397,25 +397,6 @@ impl<B: WriteBackendMethods> CodegenContext<B> {
     }
 }
 
-fn generate_fat_lto_work<B: ExtraBackendMethods>(
-    cgcx: &CodegenContext<B>,
-    autodiff: Vec<AutoDiffItem>,
-    needs_fat_lto: Vec<FatLtoInput<B>>,
-    import_only_modules: Vec<(SerializedModule<B::ModuleBuffer>, WorkProduct)>,
-) -> WorkItem<B> {
-    let _prof_timer = cgcx.prof.generic_activity("codegen_generate_lto_work");
-
-    let module =
-        B::run_fat_lto(cgcx, needs_fat_lto, import_only_modules).unwrap_or_else(|e| e.raise());
-    if cgcx.lto == Lto::Fat && !autodiff.is_empty() {
-        let config = cgcx.config(ModuleKind::Regular);
-        if let Err(err) = B::autodiff(cgcx, &module, autodiff, config) {
-            err.raise();
-        }
-    }
-    WorkItem::FatLto(module)
-}
-
 fn generate_thin_lto_work<B: ExtraBackendMethods>(
     cgcx: &CodegenContext<B>,
     needs_thin_lto: Vec<(String, B::ThinBuffer)>,
@@ -739,7 +720,11 @@ pub(crate) enum WorkItem<B: WriteBackendMethods> {
     /// directory.
     CopyPostLtoArtifacts(CachedModuleCodegen),
     /// Performs fat LTO on the given module.
-    FatLto(ModuleCodegen<B::Module>),
+    FatLto {
+        needs_fat_lto: Vec<FatLtoInput<B>>,
+        import_only_modules: Vec<(SerializedModule<B::ModuleBuffer>, WorkProduct)>,
+        autodiff: Vec<AutoDiffItem>,
+    },
     /// Performs thin-LTO on the given module.
     ThinLto(lto::ThinModule<B>),
 }
@@ -748,7 +733,7 @@ impl<B: WriteBackendMethods> WorkItem<B> {
     fn module_kind(&self) -> ModuleKind {
         match *self {
             WorkItem::Optimize(ref m) => m.kind,
-            WorkItem::CopyPostLtoArtifacts(_) | WorkItem::FatLto(_) | WorkItem::ThinLto(_) => {
+            WorkItem::CopyPostLtoArtifacts(_) | WorkItem::FatLto { .. } | WorkItem::ThinLto(_) => {
                 ModuleKind::Regular
             }
         }
@@ -798,7 +783,7 @@ impl<B: WriteBackendMethods> WorkItem<B> {
         match self {
             WorkItem::Optimize(m) => desc("opt", "optimize module", &m.name),
             WorkItem::CopyPostLtoArtifacts(m) => desc("cpy", "copy LTO artifacts for", &m.name),
-            WorkItem::FatLto(_) => desc("lto", "fat LTO module", "everything"),
+            WorkItem::FatLto { .. } => desc("lto", "fat LTO module", "everything"),
             WorkItem::ThinLto(m) => desc("lto", "thin-LTO module", m.name()),
         }
     }
@@ -1005,9 +990,21 @@ fn execute_copy_from_cache_work_item<B: ExtraBackendMethods>(
 
 fn execute_fat_lto_work_item<B: ExtraBackendMethods>(
     cgcx: &CodegenContext<B>,
-    mut module: ModuleCodegen<B::Module>,
+    needs_fat_lto: Vec<FatLtoInput<B>>,
+    import_only_modules: Vec<(SerializedModule<B::ModuleBuffer>, WorkProduct)>,
+    autodiff: Vec<AutoDiffItem>,
     module_config: &ModuleConfig,
 ) -> Result<WorkItemResult<B>, FatalError> {
+    let mut module =
+        B::run_fat_lto(cgcx, needs_fat_lto, import_only_modules).unwrap_or_else(|e| e.raise());
+
+    if cgcx.lto == Lto::Fat && !autodiff.is_empty() {
+        let config = cgcx.config(ModuleKind::Regular);
+        if let Err(err) = B::autodiff(cgcx, &module, autodiff, config) {
+            err.raise();
+        }
+    }
+
     B::optimize_fat(cgcx, &mut module)?;
 
     let module = B::codegen(cgcx, module, module_config)?;
@@ -1490,13 +1487,14 @@ fn start_executing_work<B: ExtraBackendMethods>(
                     if !needs_fat_lto.is_empty() {
                         assert!(needs_thin_lto.is_empty());
 
-                        let work = generate_fat_lto_work(
-                            &cgcx,
-                            autodiff_items.clone(),
-                            needs_fat_lto,
-                            import_only_modules,
-                        );
-                        work_items.push((work, 0));
+                        work_items.push((
+                            WorkItem::FatLto {
+                                needs_fat_lto,
+                                import_only_modules,
+                                autodiff: autodiff_items.clone(),
+                            },
+                            0,
+                        ));
                         if cgcx.parallel {
                             helper.request_token();
                         }
@@ -1867,11 +1865,17 @@ fn spawn_work<'a, B: ExtraBackendMethods>(
                     );
                     Ok(execute_copy_from_cache_work_item(&cgcx, m, module_config))
                 }
-                WorkItem::FatLto(m) => {
+                WorkItem::FatLto { needs_fat_lto, import_only_modules, autodiff } => {
                     let _timer = cgcx
                         .prof
                         .generic_activity_with_arg("codegen_module_perform_lto", "everything");
-                    execute_fat_lto_work_item(&cgcx, m, module_config)
+                    execute_fat_lto_work_item(
+                        &cgcx,
+                        needs_fat_lto,
+                        import_only_modules,
+                        autodiff,
+                        module_config,
+                    )
                 }
                 WorkItem::ThinLto(m) => {
                     let _timer =
-- 
cgit 1.4.1-3-g733a5


From 9a3aa8fdb192b42e665eb9059a0061f865b3d352 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 3 Jul 2025 16:07:28 +0000
Subject: Remove unnecessary check for fat LTO

---
 compiler/rustc_codegen_ssa/src/back/write.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index c7d2fcef29f..433cb63882f 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -998,7 +998,7 @@ fn execute_fat_lto_work_item<B: ExtraBackendMethods>(
     let mut module =
         B::run_fat_lto(cgcx, needs_fat_lto, import_only_modules).unwrap_or_else(|e| e.raise());
 
-    if cgcx.lto == Lto::Fat && !autodiff.is_empty() {
+    if !autodiff.is_empty() {
         let config = cgcx.config(ModuleKind::Regular);
         if let Err(err) = B::autodiff(cgcx, &module, autodiff, config) {
             err.raise();
-- 
cgit 1.4.1-3-g733a5


From 8d63c7a1d68cd30383dceb03a76499c658fa7f40 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 3 Jul 2025 16:09:10 +0000
Subject: Remove unused config param from WriteBackendMethods::autodiff

---
 compiler/rustc_codegen_gcc/src/lib.rs               | 1 -
 compiler/rustc_codegen_llvm/src/builder/autodiff.rs | 2 --
 compiler/rustc_codegen_llvm/src/lib.rs              | 3 +--
 compiler/rustc_codegen_ssa/src/back/write.rs        | 3 +--
 compiler/rustc_codegen_ssa/src/traits/write.rs      | 1 -
 5 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index 34452bdd200..8e63ebc8494 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -437,7 +437,6 @@ impl WriteBackendMethods for GccCodegenBackend {
         _cgcx: &CodegenContext<Self>,
         _module: &ModuleCodegen<Self::Module>,
         _diff_functions: Vec<AutoDiffItem>,
-        _config: &ModuleConfig,
     ) -> Result<(), FatalError> {
         unimplemented!()
     }
diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index b07d9a5cfca..c27e161ba99 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -2,7 +2,6 @@ use std::ptr;
 
 use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, AutoDiffItem, DiffActivity, DiffMode};
 use rustc_codegen_ssa::ModuleCodegen;
-use rustc_codegen_ssa::back::write::ModuleConfig;
 use rustc_codegen_ssa::common::TypeKind;
 use rustc_codegen_ssa::traits::BaseTypeCodegenMethods;
 use rustc_errors::FatalError;
@@ -461,7 +460,6 @@ pub(crate) fn differentiate<'ll>(
     module: &'ll ModuleCodegen<ModuleLlvm>,
     cgcx: &CodegenContext<LlvmCodegenBackend>,
     diff_items: Vec<AutoDiffItem>,
-    _config: &ModuleConfig,
 ) -> Result<(), FatalError> {
     for item in &diff_items {
         trace!("{}", item);
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 4d85683de8c..7f54416ec0e 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -231,13 +231,12 @@ impl WriteBackendMethods for LlvmCodegenBackend {
         cgcx: &CodegenContext<Self>,
         module: &ModuleCodegen<Self::Module>,
         diff_fncs: Vec<AutoDiffItem>,
-        config: &ModuleConfig,
     ) -> Result<(), FatalError> {
         if cgcx.lto != Lto::Fat {
             let dcx = cgcx.create_dcx();
             return Err(dcx.handle().emit_almost_fatal(AutoDiffWithoutLTO));
         }
-        builder::autodiff::differentiate(module, cgcx, diff_fncs, config)
+        builder::autodiff::differentiate(module, cgcx, diff_fncs)
     }
 }
 
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 433cb63882f..24f648bdb2e 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -999,8 +999,7 @@ fn execute_fat_lto_work_item<B: ExtraBackendMethods>(
         B::run_fat_lto(cgcx, needs_fat_lto, import_only_modules).unwrap_or_else(|e| e.raise());
 
     if !autodiff.is_empty() {
-        let config = cgcx.config(ModuleKind::Regular);
-        if let Err(err) = B::autodiff(cgcx, &module, autodiff, config) {
+        if let Err(err) = B::autodiff(cgcx, &module, autodiff) {
             err.raise();
         }
     }
diff --git a/compiler/rustc_codegen_ssa/src/traits/write.rs b/compiler/rustc_codegen_ssa/src/traits/write.rs
index c732c4b2ab8..949fb818c78 100644
--- a/compiler/rustc_codegen_ssa/src/traits/write.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/write.rs
@@ -65,7 +65,6 @@ pub trait WriteBackendMethods: Clone + 'static {
         cgcx: &CodegenContext<Self>,
         module: &ModuleCodegen<Self::Module>,
         diff_fncs: Vec<AutoDiffItem>,
-        config: &ModuleConfig,
     ) -> Result<(), FatalError>;
 }
 
-- 
cgit 1.4.1-3-g733a5


From 21026cae8d34241b65924198b72c7231ce4f5a3d Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 3 Jul 2025 16:22:32 +0000
Subject: Merge run_fat_lto, optimize_fat and autodiff into
 run_and_optimize_fat_lto

---
 compiler/rustc_codegen_gcc/src/lib.rs          | 23 ++++-----------
 compiler/rustc_codegen_llvm/messages.ftl       |  1 -
 compiler/rustc_codegen_llvm/src/errors.rs      |  4 ---
 compiler/rustc_codegen_llvm/src/lib.rs         | 39 ++++++++++----------------
 compiler/rustc_codegen_ssa/src/back/write.rs   | 12 +-------
 compiler/rustc_codegen_ssa/src/traits/write.rs | 16 +++--------
 6 files changed, 26 insertions(+), 69 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index 8e63ebc8494..75c36fffec9 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -357,11 +357,16 @@ impl WriteBackendMethods for GccCodegenBackend {
     type ThinData = ThinData;
     type ThinBuffer = ThinBuffer;
 
-    fn run_fat_lto(
+    fn run_and_optimize_fat_lto(
         cgcx: &CodegenContext<Self>,
         modules: Vec<FatLtoInput<Self>>,
         cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
+        diff_fncs: Vec<AutoDiffItem>,
     ) -> Result<ModuleCodegen<Self::Module>, FatalError> {
+        if !diff_fncs.is_empty() {
+            unimplemented!();
+        }
+
         back::lto::run_fat(cgcx, modules, cached_modules)
     }
 
@@ -391,14 +396,6 @@ impl WriteBackendMethods for GccCodegenBackend {
         Ok(())
     }
 
-    fn optimize_fat(
-        _cgcx: &CodegenContext<Self>,
-        _module: &mut ModuleCodegen<Self::Module>,
-    ) -> Result<(), FatalError> {
-        // TODO(antoyo)
-        Ok(())
-    }
-
     fn optimize_thin(
         cgcx: &CodegenContext<Self>,
         thin: ThinModule<Self>,
@@ -432,14 +429,6 @@ impl WriteBackendMethods for GccCodegenBackend {
     ) -> Result<ModuleCodegen<Self::Module>, FatalError> {
         back::write::link(cgcx, dcx, modules)
     }
-
-    fn autodiff(
-        _cgcx: &CodegenContext<Self>,
-        _module: &ModuleCodegen<Self::Module>,
-        _diff_functions: Vec<AutoDiffItem>,
-    ) -> Result<(), FatalError> {
-        unimplemented!()
-    }
 }
 
 /// This is the entrypoint for a hot plugged rustc_codegen_gccjit
diff --git a/compiler/rustc_codegen_llvm/messages.ftl b/compiler/rustc_codegen_llvm/messages.ftl
index 3885f18271f..f197ea74473 100644
--- a/compiler/rustc_codegen_llvm/messages.ftl
+++ b/compiler/rustc_codegen_llvm/messages.ftl
@@ -1,5 +1,4 @@
 codegen_llvm_autodiff_without_enable = using the autodiff feature requires -Z autodiff=Enable
-codegen_llvm_autodiff_without_lto = using the autodiff feature requires using fat-lto
 
 codegen_llvm_copy_bitcode = failed to copy bitcode to object file: {$err}
 
diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs
index d50ad8a1a9c..31d49e86319 100644
--- a/compiler/rustc_codegen_llvm/src/errors.rs
+++ b/compiler/rustc_codegen_llvm/src/errors.rs
@@ -37,10 +37,6 @@ impl<G: EmissionGuarantee> Diagnostic<'_, G> for ParseTargetMachineConfig<'_> {
     }
 }
 
-#[derive(Diagnostic)]
-#[diag(codegen_llvm_autodiff_without_lto)]
-pub(crate) struct AutoDiffWithoutLTO;
-
 #[derive(Diagnostic)]
 #[diag(codegen_llvm_autodiff_without_enable)]
 pub(crate) struct AutoDiffWithoutEnable;
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 7f54416ec0e..5d551c3af87 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -26,7 +26,7 @@ use std::mem::ManuallyDrop;
 use back::owned_target_machine::OwnedTargetMachine;
 use back::write::{create_informational_target_machine, create_target_machine};
 use context::SimpleCx;
-use errors::{AutoDiffWithoutLTO, ParseTargetMachineConfig};
+use errors::ParseTargetMachineConfig;
 use llvm_util::target_config;
 use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_ast::expand::autodiff_attrs::AutoDiffItem;
@@ -43,7 +43,7 @@ use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::util::Providers;
 use rustc_session::Session;
-use rustc_session::config::{Lto, OptLevel, OutputFilenames, PrintKind, PrintRequest};
+use rustc_session::config::{OptLevel, OutputFilenames, PrintKind, PrintRequest};
 use rustc_span::Symbol;
 
 mod back {
@@ -174,12 +174,23 @@ impl WriteBackendMethods for LlvmCodegenBackend {
     ) -> Result<ModuleCodegen<Self::Module>, FatalError> {
         back::write::link(cgcx, dcx, modules)
     }
-    fn run_fat_lto(
+    fn run_and_optimize_fat_lto(
         cgcx: &CodegenContext<Self>,
         modules: Vec<FatLtoInput<Self>>,
         cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
+        diff_fncs: Vec<AutoDiffItem>,
     ) -> Result<ModuleCodegen<Self::Module>, FatalError> {
-        back::lto::run_fat(cgcx, modules, cached_modules)
+        let mut module = back::lto::run_fat(cgcx, modules, cached_modules)?;
+
+        if !diff_fncs.is_empty() {
+            builder::autodiff::differentiate(&module, cgcx, diff_fncs)?;
+        }
+
+        let dcx = cgcx.create_dcx();
+        let dcx = dcx.handle();
+        back::lto::run_pass_manager(cgcx, dcx, &mut module, false)?;
+
+        Ok(module)
     }
     fn run_thin_lto(
         cgcx: &CodegenContext<Self>,
@@ -196,14 +207,6 @@ impl WriteBackendMethods for LlvmCodegenBackend {
     ) -> Result<(), FatalError> {
         back::write::optimize(cgcx, dcx, module, config)
     }
-    fn optimize_fat(
-        cgcx: &CodegenContext<Self>,
-        module: &mut ModuleCodegen<Self::Module>,
-    ) -> Result<(), FatalError> {
-        let dcx = cgcx.create_dcx();
-        let dcx = dcx.handle();
-        back::lto::run_pass_manager(cgcx, dcx, module, false)
-    }
     fn optimize_thin(
         cgcx: &CodegenContext<Self>,
         thin: ThinModule<Self>,
@@ -226,18 +229,6 @@ impl WriteBackendMethods for LlvmCodegenBackend {
     fn serialize_module(module: ModuleCodegen<Self::Module>) -> (String, Self::ModuleBuffer) {
         (module.name, back::lto::ModuleBuffer::new(module.module_llvm.llmod()))
     }
-    /// Generate autodiff rules
-    fn autodiff(
-        cgcx: &CodegenContext<Self>,
-        module: &ModuleCodegen<Self::Module>,
-        diff_fncs: Vec<AutoDiffItem>,
-    ) -> Result<(), FatalError> {
-        if cgcx.lto != Lto::Fat {
-            let dcx = cgcx.create_dcx();
-            return Err(dcx.handle().emit_almost_fatal(AutoDiffWithoutLTO));
-        }
-        builder::autodiff::differentiate(module, cgcx, diff_fncs)
-    }
 }
 
 impl LlvmCodegenBackend {
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 24f648bdb2e..26fc593da98 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -995,17 +995,7 @@ fn execute_fat_lto_work_item<B: ExtraBackendMethods>(
     autodiff: Vec<AutoDiffItem>,
     module_config: &ModuleConfig,
 ) -> Result<WorkItemResult<B>, FatalError> {
-    let mut module =
-        B::run_fat_lto(cgcx, needs_fat_lto, import_only_modules).unwrap_or_else(|e| e.raise());
-
-    if !autodiff.is_empty() {
-        if let Err(err) = B::autodiff(cgcx, &module, autodiff) {
-            err.raise();
-        }
-    }
-
-    B::optimize_fat(cgcx, &mut module)?;
-
+    let module = B::run_and_optimize_fat_lto(cgcx, needs_fat_lto, import_only_modules, autodiff)?;
     let module = B::codegen(cgcx, module, module_config)?;
     Ok(WorkItemResult::Finished(module))
 }
diff --git a/compiler/rustc_codegen_ssa/src/traits/write.rs b/compiler/rustc_codegen_ssa/src/traits/write.rs
index 949fb818c78..5e993640472 100644
--- a/compiler/rustc_codegen_ssa/src/traits/write.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/write.rs
@@ -20,12 +20,13 @@ pub trait WriteBackendMethods: Clone + 'static {
         dcx: DiagCtxtHandle<'_>,
         modules: Vec<ModuleCodegen<Self::Module>>,
     ) -> Result<ModuleCodegen<Self::Module>, FatalError>;
-    /// Performs fat LTO by merging all modules into a single one and returning it
-    /// for further optimization.
-    fn run_fat_lto(
+    /// Performs fat LTO by merging all modules into a single one, running autodiff
+    /// if necessary and running any further optimizations
+    fn run_and_optimize_fat_lto(
         cgcx: &CodegenContext<Self>,
         modules: Vec<FatLtoInput<Self>>,
         cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
+        diff_fncs: Vec<AutoDiffItem>,
     ) -> Result<ModuleCodegen<Self::Module>, FatalError>;
     /// Performs thin LTO by performing necessary global analysis and returning two
     /// lists, one of the modules that need optimization and another for modules that
@@ -43,10 +44,6 @@ pub trait WriteBackendMethods: Clone + 'static {
         module: &mut ModuleCodegen<Self::Module>,
         config: &ModuleConfig,
     ) -> Result<(), FatalError>;
-    fn optimize_fat(
-        cgcx: &CodegenContext<Self>,
-        llmod: &mut ModuleCodegen<Self::Module>,
-    ) -> Result<(), FatalError>;
     fn optimize_thin(
         cgcx: &CodegenContext<Self>,
         thin: ThinModule<Self>,
@@ -61,11 +58,6 @@ pub trait WriteBackendMethods: Clone + 'static {
         want_summary: bool,
     ) -> (String, Self::ThinBuffer);
     fn serialize_module(module: ModuleCodegen<Self::Module>) -> (String, Self::ModuleBuffer);
-    fn autodiff(
-        cgcx: &CodegenContext<Self>,
-        module: &ModuleCodegen<Self::Module>,
-        diff_fncs: Vec<AutoDiffItem>,
-    ) -> Result<(), FatalError>;
 }
 
 pub trait ThinBufferMethods: Send + Sync {
-- 
cgit 1.4.1-3-g733a5


From a7eefc3fc4c16786844841af511b09db832f6a01 Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Fri, 4 Jul 2025 07:04:46 +0200
Subject: Enable xgot feature for mips64 musl targets

This was missed in b65c2afdfd9aaee977302516c9ef177861abfe74, which only
enabled it for the glibc targets.

I didn't feel comfortable touching the OpenWRT target, whoever maintains
that will probably want to take a look whether it is necessary there as
well.

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 .../rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs     | 2 +-
 .../rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

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 fd509503053..f95ce756354 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
@@ -5,7 +5,7 @@ use crate::spec::{Target, TargetMetadata, TargetOptions, base};
 pub(crate) fn target() -> Target {
     let mut base = base::linux_musl::opts();
     base.cpu = "mips64r2".into();
-    base.features = "+mips64r2".into();
+    base.features = "+mips64r2,+xgot".into();
     base.max_atomic_width = Some(64);
     Target {
         // LLVM doesn't recognize "muslabi64" yet.
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 aa087b1a35a..d42e097b0fd 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
@@ -3,7 +3,7 @@ use crate::spec::{Target, TargetMetadata, TargetOptions, base};
 pub(crate) fn target() -> Target {
     let mut base = base::linux_musl::opts();
     base.cpu = "mips64r2".into();
-    base.features = "+mips64r2".into();
+    base.features = "+mips64r2,+xgot".into();
     base.max_atomic_width = Some(64);
     // FIXME(compiler-team#422): musl targets should be dynamically linked by default.
     base.crt_static_default = true;
-- 
cgit 1.4.1-3-g733a5


From 9d8e68d1d6a071696588c1f81e5f1d6df8709042 Mon Sep 17 00:00:00 2001
From: klensy <klensy@users.noreply.github.com>
Date: Fri, 4 Jul 2025 11:55:03 +0300
Subject: bump termize

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

diff --git a/Cargo.toml b/Cargo.toml
index bdc299749d7..2b6139e7e7f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,7 +28,7 @@ declare_clippy_lint = { path = "declare_clippy_lint" }
 rustc_tools_util = { path = "rustc_tools_util", version = "0.4.2" }
 clippy_lints_internal = { path = "clippy_lints_internal", optional = true }
 tempfile = { version = "3.20", optional = true }
-termize = "0.1"
+termize = "0.2"
 color-print = "0.3.4"
 anstream = "0.6.18"
 
-- 
cgit 1.4.1-3-g733a5


From 92144e1ee183fc8ed097c937fcc4754242b69a99 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 11:41:19 +0200
Subject: Remove `josh-sync` tooling and update README

---
 src/doc/rustc-dev-guide/README.md             |  35 +--
 src/doc/rustc-dev-guide/josh-sync/Cargo.lock  | 430 --------------------------
 src/doc/rustc-dev-guide/josh-sync/Cargo.toml  |   9 -
 src/doc/rustc-dev-guide/josh-sync/README.md   |   4 -
 src/doc/rustc-dev-guide/josh-sync/src/main.rs |  41 ---
 src/doc/rustc-dev-guide/josh-sync/src/sync.rs | 275 ----------------
 6 files changed, 5 insertions(+), 789 deletions(-)
 delete mode 100644 src/doc/rustc-dev-guide/josh-sync/Cargo.lock
 delete mode 100644 src/doc/rustc-dev-guide/josh-sync/Cargo.toml
 delete mode 100644 src/doc/rustc-dev-guide/josh-sync/README.md
 delete mode 100644 src/doc/rustc-dev-guide/josh-sync/src/main.rs
 delete mode 100644 src/doc/rustc-dev-guide/josh-sync/src/sync.rs

diff --git a/src/doc/rustc-dev-guide/README.md b/src/doc/rustc-dev-guide/README.md
index 0425c15f83c..f11290e44d8 100644
--- a/src/doc/rustc-dev-guide/README.md
+++ b/src/doc/rustc-dev-guide/README.md
@@ -72,49 +72,24 @@ including the `<!-- toc -->` marker at the place where you want the TOC.
 
 ## Synchronizing josh subtree with rustc
 
-This repository is linked to `rust-lang/rust` as a [josh](https://josh-project.github.io/josh/intro.html) subtree. You can use the following commands to synchronize the subtree in both directions.
+This repository is linked to `rust-lang/rust` as a [josh](https://josh-project.github.io/josh/intro.html) subtree. You can use the [rustc-josh-sync](https://github.com/rust-lang/josh-sync) tool to perform synchronization.
 
-You'll need to install `josh-proxy` locally via
-
-```
-cargo install josh-proxy --git https://github.com/josh-project/josh --tag r24.10.04
-```
-Older versions of `josh-proxy` may not round trip commits losslessly so it is important to install this exact version.
+You can install the tool using `cargo install --locked --git https://github.com/rust-lang/josh-sync`.
 
 ### Pull changes from `rust-lang/rust` into this repository
 
 1) Checkout a new branch that will be used to create a PR into `rust-lang/rustc-dev-guide`
 2) Run the pull command
     ```
-    cargo run --manifest-path josh-sync/Cargo.toml rustc-pull
+    rustc-josh-sync pull
     ```
 3) Push the branch to your fork and create a PR into `rustc-dev-guide`
+   - If you have `gh` CLI installed, `rustc-josh-sync` can create the PR for you.
 
 ### Push changes from this repository into `rust-lang/rust`
 
-NOTE: If you use Git protocol to push to your fork of `rust-lang/rust`,
-ensure that you have this entry in your Git config,
-else the 2 steps that follow would prompt for a username and password:
-
-```
-[url "git@github.com:"]
-insteadOf = "https://github.com/"
-```
-
 1) Run the push command to create a branch named `<branch-name>` in a `rustc` fork under the `<gh-username>` account
     ```
-    cargo run --manifest-path josh-sync/Cargo.toml rustc-push <branch-name> <gh-username>
+    rustc-josh-sync push <branch-name> <gh-username>
     ```
 2) Create a PR from `<branch-name>` into `rust-lang/rust`
-
-#### Minimal git config
-
-For simplicity (ease of implementation purposes), the josh-sync script simply calls out to system git. This means that the git invocation may be influenced by global (or local) git configuration.
-
-You may observe "Nothing to pull" even if you *know* rustc-pull has something to pull if your global git config sets `fetch.prunetags = true` (and possibly other configurations may cause unexpected outcomes).
-
-To minimize the likelihood of this happening, you may wish to keep a separate *minimal* git config that *only* has `[user]` entries from global git config, then repoint system git to use the minimal git config instead. E.g.
-
-```
-GIT_CONFIG_GLOBAL=/path/to/minimal/gitconfig GIT_CONFIG_SYSTEM='' cargo run --manifest-path josh-sync/Cargo.toml -- rustc-pull
-```
diff --git a/src/doc/rustc-dev-guide/josh-sync/Cargo.lock b/src/doc/rustc-dev-guide/josh-sync/Cargo.lock
deleted file mode 100644
index a8183a740db..00000000000
--- a/src/doc/rustc-dev-guide/josh-sync/Cargo.lock
+++ /dev/null
@@ -1,430 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "anstream"
-version = "0.6.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
-dependencies = [
- "anstyle",
- "anstyle-parse",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "is_terminal_polyfill",
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle"
-version = "1.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
-
-[[package]]
-name = "anstyle-parse"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
-dependencies = [
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "3.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125"
-dependencies = [
- "anstyle",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "anyhow"
-version = "1.0.95"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
-
-[[package]]
-name = "bitflags"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "clap"
-version = "4.5.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3135e7ec2ef7b10c6ed8950f0f792ed96ee093fa088608f1c76e569722700c84"
-dependencies = [
- "clap_builder",
- "clap_derive",
-]
-
-[[package]]
-name = "clap_builder"
-version = "4.5.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30582fc632330df2bd26877bde0c1f4470d57c582bbc070376afcd04d8cb4838"
-dependencies = [
- "anstream",
- "anstyle",
- "clap_lex",
- "strsim",
-]
-
-[[package]]
-name = "clap_derive"
-version = "4.5.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "clap_lex"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
-
-[[package]]
-name = "colorchoice"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
-
-[[package]]
-name = "directories"
-version = "5.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a49173b84e034382284f27f1af4dcbbd231ffa358c0fe316541a7337f376a35"
-dependencies = [
- "dirs-sys",
-]
-
-[[package]]
-name = "dirs-sys"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
-dependencies = [
- "libc",
- "option-ext",
- "redox_users",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "heck"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
-
-[[package]]
-name = "is_terminal_polyfill"
-version = "1.70.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
-
-[[package]]
-name = "josh-sync"
-version = "0.0.0"
-dependencies = [
- "anyhow",
- "clap",
- "directories",
- "xshell",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.169"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
-
-[[package]]
-name = "libredox"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
-dependencies = [
- "bitflags",
- "libc",
-]
-
-[[package]]
-name = "option-ext"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.38"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "redox_users"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
-dependencies = [
- "getrandom",
- "libredox",
- "thiserror",
-]
-
-[[package]]
-name = "strsim"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
-
-[[package]]
-name = "syn"
-version = "2.0.93"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c786062daee0d6db1132800e623df74274a0a87322d8e183338e01b3d98d058"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
-
-[[package]]
-name = "utf8parse"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "windows-sys"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
-dependencies = [
- "windows-targets 0.48.5",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.59.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
-dependencies = [
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
-dependencies = [
- "windows_aarch64_gnullvm 0.48.5",
- "windows_aarch64_msvc 0.48.5",
- "windows_i686_gnu 0.48.5",
- "windows_i686_msvc 0.48.5",
- "windows_x86_64_gnu 0.48.5",
- "windows_x86_64_gnullvm 0.48.5",
- "windows_x86_64_msvc 0.48.5",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
-dependencies = [
- "windows_aarch64_gnullvm 0.52.6",
- "windows_aarch64_msvc 0.52.6",
- "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm",
- "windows_i686_msvc 0.52.6",
- "windows_x86_64_gnu 0.52.6",
- "windows_x86_64_gnullvm 0.52.6",
- "windows_x86_64_msvc 0.52.6",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
-
-[[package]]
-name = "xshell"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e7290c623014758632efe00737145b6867b66292c42167f2ec381eb566a373d"
-dependencies = [
- "xshell-macros",
-]
-
-[[package]]
-name = "xshell-macros"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547"
diff --git a/src/doc/rustc-dev-guide/josh-sync/Cargo.toml b/src/doc/rustc-dev-guide/josh-sync/Cargo.toml
deleted file mode 100644
index 1f8bf2a0093..00000000000
--- a/src/doc/rustc-dev-guide/josh-sync/Cargo.toml
+++ /dev/null
@@ -1,9 +0,0 @@
-[package]
-name = "josh-sync"
-edition = "2024"
-
-[dependencies]
-anyhow = "1.0.95"
-clap = { version = "4.5.21", features = ["derive"] }
-directories = "5"
-xshell = "0.2.6"
diff --git a/src/doc/rustc-dev-guide/josh-sync/README.md b/src/doc/rustc-dev-guide/josh-sync/README.md
deleted file mode 100644
index a3dd876e8b8..00000000000
--- a/src/doc/rustc-dev-guide/josh-sync/README.md
+++ /dev/null
@@ -1,4 +0,0 @@
-# Git josh sync
-This utility serves for syncing the josh git subtree to and from the rust-lang/rust repository.
-
-See CLI help for usage.
diff --git a/src/doc/rustc-dev-guide/josh-sync/src/main.rs b/src/doc/rustc-dev-guide/josh-sync/src/main.rs
deleted file mode 100644
index aeedee5be22..00000000000
--- a/src/doc/rustc-dev-guide/josh-sync/src/main.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use clap::Parser;
-
-use crate::sync::{GitSync, RustcPullError};
-
-mod sync;
-
-#[derive(clap::Parser)]
-enum Args {
-    /// Pull changes from the main `rustc` repository.
-    /// This creates new commits that should be then merged into `rustc-dev-guide`.
-    RustcPull,
-    /// Push changes from `rustc-dev-guide` to the given `branch` of a `rustc` fork under the given
-    /// GitHub `username`.
-    /// The pushed branch should then be merged into the `rustc` repository.
-    RustcPush { branch: String, github_username: String },
-}
-
-fn main() -> anyhow::Result<()> {
-    let args = Args::parse();
-    let sync = GitSync::from_current_dir()?;
-    match args {
-        Args::RustcPull => {
-            if let Err(error) = sync.rustc_pull(None) {
-                match error {
-                    RustcPullError::NothingToPull => {
-                        eprintln!("Nothing to pull");
-                        std::process::exit(2);
-                    }
-                    RustcPullError::PullFailed(error) => {
-                        eprintln!("Pull failure: {error:?}");
-                        std::process::exit(1);
-                    }
-                }
-            }
-        }
-        Args::RustcPush { github_username, branch } => {
-            sync.rustc_push(github_username, branch)?;
-        }
-    }
-    Ok(())
-}
diff --git a/src/doc/rustc-dev-guide/josh-sync/src/sync.rs b/src/doc/rustc-dev-guide/josh-sync/src/sync.rs
deleted file mode 100644
index ed38d1403a0..00000000000
--- a/src/doc/rustc-dev-guide/josh-sync/src/sync.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-use std::io::Write;
-use std::ops::Not;
-use std::path::PathBuf;
-use std::time::Duration;
-use std::{env, net, process};
-
-use anyhow::{Context, anyhow, bail};
-use xshell::{Shell, cmd};
-
-/// Used for rustc syncs.
-const JOSH_FILTER: &str = ":/src/doc/rustc-dev-guide";
-const JOSH_PORT: u16 = 42042;
-const UPSTREAM_REPO: &str = "rust-lang/rust";
-
-pub enum RustcPullError {
-    /// No changes are available to be pulled.
-    NothingToPull,
-    /// A rustc-pull has failed, probably a git operation error has occurred.
-    PullFailed(anyhow::Error),
-}
-
-impl<E> From<E> for RustcPullError
-where
-    E: Into<anyhow::Error>,
-{
-    fn from(error: E) -> Self {
-        Self::PullFailed(error.into())
-    }
-}
-
-pub struct GitSync {
-    dir: PathBuf,
-}
-
-/// This code was adapted from the miri repository
-/// (https://github.com/rust-lang/miri/blob/6a68a79f38064c3bc30617cca4bdbfb2c336b140/miri-script/src/commands.rs#L236).
-impl GitSync {
-    pub fn from_current_dir() -> anyhow::Result<Self> {
-        Ok(Self { dir: std::env::current_dir()? })
-    }
-
-    pub fn rustc_pull(&self, commit: Option<String>) -> Result<(), RustcPullError> {
-        let sh = Shell::new()?;
-        sh.change_dir(&self.dir);
-        let commit = commit.map(Ok).unwrap_or_else(|| {
-            let rust_repo_head =
-                cmd!(sh, "git ls-remote https://github.com/{UPSTREAM_REPO}/ HEAD").read()?;
-            rust_repo_head
-                .split_whitespace()
-                .next()
-                .map(|front| front.trim().to_owned())
-                .ok_or_else(|| anyhow!("Could not obtain Rust repo HEAD from remote."))
-        })?;
-        // Make sure the repo is clean.
-        if cmd!(sh, "git status --untracked-files=no --porcelain").read()?.is_empty().not() {
-            return Err(anyhow::anyhow!(
-                "working directory must be clean before performing rustc pull"
-            )
-            .into());
-        }
-        // Make sure josh is running.
-        let josh = Self::start_josh()?;
-        let josh_url =
-            format!("http://localhost:{JOSH_PORT}/{UPSTREAM_REPO}.git@{commit}{JOSH_FILTER}.git");
-
-        let previous_base_commit = sh.read_file("rust-version")?.trim().to_string();
-        if previous_base_commit == commit {
-            return Err(RustcPullError::NothingToPull);
-        }
-
-        // Update rust-version file. As a separate commit, since making it part of
-        // the merge has confused the heck out of josh in the past.
-        // We pass `--no-verify` to avoid running git hooks.
-        // We do this before the merge so that if there are merge conflicts, we have
-        // the right rust-version file while resolving them.
-        sh.write_file("rust-version", format!("{commit}\n"))?;
-        const PREPARING_COMMIT_MESSAGE: &str = "Preparing for merge from rustc";
-        cmd!(sh, "git commit rust-version --no-verify -m {PREPARING_COMMIT_MESSAGE}")
-            .run()
-            .context("FAILED to commit rust-version file, something went wrong")?;
-
-        // Fetch given rustc commit.
-        cmd!(sh, "git fetch {josh_url}")
-            .run()
-            .inspect_err(|_| {
-                // Try to un-do the previous `git commit`, to leave the repo in the state we found it.
-                cmd!(sh, "git reset --hard HEAD^")
-                    .run()
-                    .expect("FAILED to clean up again after failed `git fetch`, sorry for that");
-            })
-            .context("FAILED to fetch new commits, something went wrong (committing the rust-version file has been undone)")?;
-
-        // This should not add any new root commits. So count those before and after merging.
-        let num_roots = || -> anyhow::Result<u32> {
-            Ok(cmd!(sh, "git rev-list HEAD --max-parents=0 --count")
-                .read()
-                .context("failed to determine the number of root commits")?
-                .parse::<u32>()?)
-        };
-        let num_roots_before = num_roots()?;
-
-        let sha =
-            cmd!(sh, "git rev-parse HEAD").output().context("FAILED to get current commit")?.stdout;
-
-        // Merge the fetched commit.
-        const MERGE_COMMIT_MESSAGE: &str = "Merge from rustc";
-        cmd!(sh, "git merge FETCH_HEAD --no-verify --no-ff -m {MERGE_COMMIT_MESSAGE}")
-            .run()
-            .context("FAILED to merge new commits, something went wrong")?;
-
-        let current_sha =
-            cmd!(sh, "git rev-parse HEAD").output().context("FAILED to get current commit")?.stdout;
-        if current_sha == sha {
-            cmd!(sh, "git reset --hard HEAD^")
-                .run()
-                .expect("FAILED to clean up after creating the preparation commit");
-            eprintln!(
-                "No merge was performed, no changes to pull were found. Rolled back the preparation commit."
-            );
-            return Err(RustcPullError::NothingToPull);
-        }
-
-        // Check that the number of roots did not increase.
-        if num_roots()? != num_roots_before {
-            return Err(anyhow::anyhow!(
-                "Josh created a new root commit. This is probably not the history you want."
-            )
-            .into());
-        }
-
-        drop(josh);
-        Ok(())
-    }
-
-    pub fn rustc_push(&self, github_user: String, branch: String) -> anyhow::Result<()> {
-        let sh = Shell::new()?;
-        sh.change_dir(&self.dir);
-        let base = sh.read_file("rust-version")?.trim().to_owned();
-        // Make sure the repo is clean.
-        if cmd!(sh, "git status --untracked-files=no --porcelain").read()?.is_empty().not() {
-            bail!("working directory must be clean before running `rustc-push`");
-        }
-        // Make sure josh is running.
-        let josh = Self::start_josh()?;
-        let josh_url =
-            format!("http://localhost:{JOSH_PORT}/{github_user}/rust.git{JOSH_FILTER}.git");
-
-        // Find a repo we can do our preparation in.
-        if let Ok(rustc_git) = env::var("RUSTC_GIT") {
-            // If rustc_git is `Some`, we'll use an existing fork for the branch updates.
-            sh.change_dir(rustc_git);
-        } else {
-            // Otherwise, do this in the local repo.
-            println!(
-                "This will pull a copy of the rust-lang/rust history into this checkout, growing it by about 1GB."
-            );
-            print!(
-                "To avoid that, abort now and set the `RUSTC_GIT` environment variable to an existing rustc checkout. Proceed? [y/N] "
-            );
-            std::io::stdout().flush()?;
-            let mut answer = String::new();
-            std::io::stdin().read_line(&mut answer)?;
-            if answer.trim().to_lowercase() != "y" {
-                std::process::exit(1);
-            }
-        };
-        // Prepare the branch. Pushing works much better if we use as base exactly
-        // the commit that we pulled from last time, so we use the `rust-version`
-        // file to find out which commit that would be.
-        println!("Preparing {github_user}/rust (base: {base})...");
-        if cmd!(sh, "git fetch https://github.com/{github_user}/rust {branch}")
-            .ignore_stderr()
-            .read()
-            .is_ok()
-        {
-            println!(
-                "The branch '{branch}' seems to already exist in 'https://github.com/{github_user}/rust'. Please delete it and try again."
-            );
-            std::process::exit(1);
-        }
-        cmd!(sh, "git fetch https://github.com/{UPSTREAM_REPO} {base}").run()?;
-        cmd!(sh, "git push https://github.com/{github_user}/rust {base}:refs/heads/{branch}")
-            .ignore_stdout()
-            .ignore_stderr() // silence the "create GitHub PR" message
-            .run()?;
-        println!();
-
-        // Do the actual push.
-        sh.change_dir(&self.dir);
-        println!("Pushing changes...");
-        cmd!(sh, "git push {josh_url} HEAD:{branch}").run()?;
-        println!();
-
-        // Do a round-trip check to make sure the push worked as expected.
-        cmd!(sh, "git fetch {josh_url} {branch}").ignore_stderr().read()?;
-        let head = cmd!(sh, "git rev-parse HEAD").read()?;
-        let fetch_head = cmd!(sh, "git rev-parse FETCH_HEAD").read()?;
-        if head != fetch_head {
-            bail!(
-                "Josh created a non-roundtrip push! Do NOT merge this into rustc!\n\
-                Expected {head}, got {fetch_head}."
-            );
-        }
-        println!(
-            "Confirmed that the push round-trips back to rustc-dev-guide properly. Please create a rustc PR:"
-        );
-        println!(
-            // Open PR with `subtree update` title to silence the `no-merges` triagebot check
-            "    https://github.com/{UPSTREAM_REPO}/compare/{github_user}:{branch}?quick_pull=1&title=rustc-dev-guide+subtree+update&body=r?+@ghost"
-        );
-
-        drop(josh);
-        Ok(())
-    }
-
-    fn start_josh() -> anyhow::Result<impl Drop> {
-        // Determine cache directory.
-        let local_dir = {
-            let user_dirs =
-                directories::ProjectDirs::from("org", "rust-lang", "rustc-dev-guide-josh").unwrap();
-            user_dirs.cache_dir().to_owned()
-        };
-
-        // Start josh, silencing its output.
-        let mut cmd = process::Command::new("josh-proxy");
-        cmd.arg("--local").arg(local_dir);
-        cmd.arg("--remote").arg("https://github.com");
-        cmd.arg("--port").arg(JOSH_PORT.to_string());
-        cmd.arg("--no-background");
-        cmd.stdout(process::Stdio::null());
-        cmd.stderr(process::Stdio::null());
-        let josh = cmd.spawn().context("failed to start josh-proxy, make sure it is installed")?;
-
-        // Create a wrapper that stops it on drop.
-        struct Josh(process::Child);
-        impl Drop for Josh {
-            fn drop(&mut self) {
-                #[cfg(unix)]
-                {
-                    // Try to gracefully shut it down.
-                    process::Command::new("kill")
-                        .args(["-s", "INT", &self.0.id().to_string()])
-                        .output()
-                        .expect("failed to SIGINT josh-proxy");
-                    // Sadly there is no "wait with timeout"... so we just give it some time to finish.
-                    std::thread::sleep(Duration::from_millis(100));
-                    // Now hopefully it is gone.
-                    if self.0.try_wait().expect("failed to wait for josh-proxy").is_some() {
-                        return;
-                    }
-                }
-                // If that didn't work (or we're not on Unix), kill it hard.
-                eprintln!(
-                    "I have to kill josh-proxy the hard way, let's hope this does not break anything."
-                );
-                self.0.kill().expect("failed to SIGKILL josh-proxy");
-            }
-        }
-
-        // Wait until the port is open. We try every 10ms until 1s passed.
-        for _ in 0..100 {
-            // This will generally fail immediately when the port is still closed.
-            let josh_ready = net::TcpStream::connect_timeout(
-                &net::SocketAddr::from(([127, 0, 0, 1], JOSH_PORT)),
-                Duration::from_millis(1),
-            );
-            if josh_ready.is_ok() {
-                return Ok(Josh(josh));
-            }
-            // Not ready yet.
-            std::thread::sleep(Duration::from_millis(10));
-        }
-        bail!("Even after waiting for 1s, josh-proxy is still not available.")
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From 13dca5e1baede8fe0df76ccba1875a14dda10269 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 11:44:58 +0200
Subject: Update CI workflow to use rustc-josh-sync

---
 src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml b/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
index 1e430d8b4e6..7190fc733db 100644
--- a/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
+++ b/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
@@ -24,11 +24,10 @@ jobs:
         run: rustup update stable
       - uses: Swatinem/rust-cache@v2
         with:
-          workspaces: "josh-sync"
           # Cache the josh directory with checked out rustc
-          cache-directories: "/home/runner/.cache/rustc-dev-guide-josh"
-      - name: Install josh
-        run: RUSTFLAGS="--cap-lints warn" cargo install josh-proxy --git https://github.com/josh-project/josh --tag r24.10.04
+          cache-directories: "/home/runner/.cache/rustc-josh"
+      - name: Install rustc-josh-sync
+        run: cargo install --locked --git https://github.com/rust-lang/josh-sync
       - name: Setup bot git name and email
         run: |
           git config --global user.name 'The rustc-dev-guide Cronjob Bot'
@@ -38,7 +37,7 @@ jobs:
         # Turn off -e to disable early exit
         shell: bash {0}
         run: |
-          cargo run --manifest-path josh-sync/Cargo.toml -- rustc-pull
+          rustc-josh-sync pull
           exitcode=$?
 
           # If no pull was performed, we want to mark this job as successful,
-- 
cgit 1.4.1-3-g733a5


From 9d83749cdd02531b000eead51cd0de40ec9a59e4 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 13:14:23 +0200
Subject: Document `rustc-josh-sync`

---
 src/doc/rustc-dev-guide/README.md             | 20 +--------
 src/doc/rustc-dev-guide/src/external-repos.md | 62 ++++++++++++++++++++++-----
 2 files changed, 52 insertions(+), 30 deletions(-)

diff --git a/src/doc/rustc-dev-guide/README.md b/src/doc/rustc-dev-guide/README.md
index f11290e44d8..5932da467ab 100644
--- a/src/doc/rustc-dev-guide/README.md
+++ b/src/doc/rustc-dev-guide/README.md
@@ -74,22 +74,4 @@ including the `<!-- toc -->` marker at the place where you want the TOC.
 
 This repository is linked to `rust-lang/rust` as a [josh](https://josh-project.github.io/josh/intro.html) subtree. You can use the [rustc-josh-sync](https://github.com/rust-lang/josh-sync) tool to perform synchronization.
 
-You can install the tool using `cargo install --locked --git https://github.com/rust-lang/josh-sync`.
-
-### Pull changes from `rust-lang/rust` into this repository
-
-1) Checkout a new branch that will be used to create a PR into `rust-lang/rustc-dev-guide`
-2) Run the pull command
-    ```
-    rustc-josh-sync pull
-    ```
-3) Push the branch to your fork and create a PR into `rustc-dev-guide`
-   - If you have `gh` CLI installed, `rustc-josh-sync` can create the PR for you.
-
-### Push changes from this repository into `rust-lang/rust`
-
-1) Run the push command to create a branch named `<branch-name>` in a `rustc` fork under the `<gh-username>` account
-    ```
-    rustc-josh-sync push <branch-name> <gh-username>
-    ```
-2) Create a PR from `<branch-name>` into `rust-lang/rust`
+You can find a guide on how to perform the synchronization [here](./src/external-repos.md#synchronizing-a-josh-subtree).
diff --git a/src/doc/rustc-dev-guide/src/external-repos.md b/src/doc/rustc-dev-guide/src/external-repos.md
index f3170c9222d..a19b1116de8 100644
--- a/src/doc/rustc-dev-guide/src/external-repos.md
+++ b/src/doc/rustc-dev-guide/src/external-repos.md
@@ -9,7 +9,7 @@ There are three main ways we use dependencies:
 As a general rule:
 - Use crates.io for libraries that could be useful for others in the ecosystem
 - Use subtrees for tools that depend on compiler internals and need to be updated if there are breaking
-changes
+  changes
 - Use submodules for tools that are independent of the compiler
 
 ## External Dependencies (subtrees)
@@ -23,6 +23,8 @@ The following external projects are managed using some form of a `subtree`:
 * [rust-analyzer](https://github.com/rust-lang/rust-analyzer)
 * [rustc_codegen_cranelift](https://github.com/rust-lang/rustc_codegen_cranelift)
 * [rustc-dev-guide](https://github.com/rust-lang/rustc-dev-guide)
+* [compiler-builtins](https://github.com/rust-lang/compiler-builtins)
+* [stdarch](https://github.com/rust-lang/stdarch)
 
 In contrast to `submodule` dependencies
 (see below for those), the `subtree` dependencies are just regular files and directories which can
@@ -34,20 +36,57 @@ implement a new tool feature or test, that should happen in one collective rustc
 `subtree` dependencies are currently managed by two distinct approaches:
 
 * Using `git subtree`
-  * `clippy` ([sync guide](https://doc.rust-lang.org/nightly/clippy/development/infrastructure/sync.html#performing-the-sync-from-rust-langrust-to-clippy))
-  * `portable-simd` ([sync script](https://github.com/rust-lang/portable-simd/blob/master/subtree-sync.sh))
-  * `rustfmt`
-  * `rustc_codegen_cranelift` ([sync script](https://github.com/rust-lang/rustc_codegen_cranelift/blob/113af154d459e41b3dc2c5d7d878e3d3a8f33c69/scripts/rustup.sh#L7))
+    * `clippy` ([sync guide](https://doc.rust-lang.org/nightly/clippy/development/infrastructure/sync.html#performing-the-sync-from-rust-langrust-to-clippy))
+    * `portable-simd` ([sync script](https://github.com/rust-lang/portable-simd/blob/master/subtree-sync.sh))
+    * `rustfmt`
+    * `rustc_codegen_cranelift` ([sync script](https://github.com/rust-lang/rustc_codegen_cranelift/blob/113af154d459e41b3dc2c5d7d878e3d3a8f33c69/scripts/rustup.sh#L7))
 * Using the [josh] tool
-  * `miri` ([sync guide](https://github.com/rust-lang/miri/blob/master/CONTRIBUTING.md#advanced-topic-syncing-with-the-rustc-repo))
-  * `rust-analyzer` ([sync script](https://github.com/rust-lang/rust-analyzer/blob/2e13684be123eca7181aa48e043e185d8044a84a/xtask/src/release.rs#L147))
-  * `rustc-dev-guide` ([sync guide](https://github.com/rust-lang/rustc-dev-guide#synchronizing-josh-subtree-with-rustc))
+    * `miri` ([sync guide](https://github.com/rust-lang/miri/blob/master/CONTRIBUTING.md#advanced-topic-syncing-with-the-rustc-repo))
+    * `rust-analyzer` ([sync script](https://github.com/rust-lang/rust-analyzer/blob/2e13684be123eca7181aa48e043e185d8044a84a/xtask/src/release.rs#L147))
+    * `rustc-dev-guide`
+    * `compiler-builtins`
+    * `stdarch`
 
-The [josh] tool is an alternative to git subtrees, which manages git history in a different way and scales better to larger repositories. Specific tooling is required to work with josh, you can check out the `miri` or `rust-analyzer` scripts linked above for inspiration. If you want to migrate a repository dependency from `git subtree` or `git submodule` to josh, you can check out [this guide](https://hackmd.io/7pOuxnkdQDaL1Y1FQr65xg).
+### Josh subtrees
 
-Below you can find a guide on how to perform push and pull synchronization with the main rustc repo using `git subtree`, although these instructions might differ repo from repo.
+The [josh] tool is an alternative to git subtrees, which manages git history in a different way and scales better to larger repositories. Specific tooling is required to work with josh, you can check out the `miri` or `rust-analyzer` scripts linked above for inspiration. We provide a helper [`rustc-josh-sync`][josh-sync] tool to help with the synchronization, it is described [below](#synchronizing-a-josh-subtree).
 
-### Synchronizing a subtree
+### Synchronizing a Josh subtree
+
+We use a dedicated tool called [`rustc-josh-sync`][josh-sync] for performing Josh subtree updates.
+Currently, we are migrating Josh repositories to it. So far, it is used in:
+
+- rustc-dev-guide
+
+To use the tool, first install it with `cargo install --locked --git https://github.
+com/rust-lang/josh-sync`.
+
+Both pulls (synchronize changes from rust-lang/rust into the subtree) and pushes (synchronize
+changes from the subtree to rust-lang/rust) are performed from the subtree repository (so first
+switch to its repository checkout directory in your terminal).
+
+#### Performing pull
+1) Checkout a new branch that will be used to create a PR into the subtree
+2) Run the pull command
+    ```
+    rustc-josh-sync pull
+    ```
+3) Push the branch to your fork and create a PR into the subtree repository
+    - If you have `gh` CLI installed, `rustc-josh-sync` can create the PR for you.
+
+#### Performing push
+
+1) Run the push command to create a branch named `<branch-name>` in a `rustc` fork under the `<gh-username>` account
+    ```
+    rustc-josh-sync push <branch-name> <gh-username>
+    ```
+2) Create a PR from `<branch-name>` into `rust-lang/rust`
+
+### Creating a new Josh subtree dependency
+
+If you want to migrate a repository dependency from `git subtree` or `git submodule` to josh, you can check out [this guide](https://hackmd.io/7pOuxnkdQDaL1Y1FQr65xg).
+
+### Synchronizing a git subtree
 
 Periodically the changes made to subtree based dependencies need to be synchronized between this
 repository and the upstream tool repositories.
@@ -129,3 +168,4 @@ the week leading up to the beta cut.
 [toolstate website]: https://rust-lang-nursery.github.io/rust-toolstate/
 [Toolstate chapter]: https://forge.rust-lang.org/infra/toolstate.html
 [josh]: https://josh-project.github.io/josh/intro.html
+[josh-sync]: https://github.com/rust-lang/josh-sync
-- 
cgit 1.4.1-3-g733a5


From 1a1b52acbf44f55f7458dd38b260479843fe3810 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 4 Jul 2025 11:33:36 +0000
Subject: clippy fix: indentation

---
 library/core/src/alloc/layout.rs |  4 ++--
 library/core/src/cell.rs         | 28 ++++++++++++++--------------
 library/core/src/error.rs        | 24 ++++++++++++------------
 library/core/src/fmt/mod.rs      | 14 +++++++-------
 library/core/src/marker.rs       |  4 ++--
 library/core/src/ops/drop.rs     |  2 +-
 library/core/src/option.rs       |  1 +
 library/core/src/pin.rs          | 16 ++++++++--------
 8 files changed, 47 insertions(+), 46 deletions(-)

diff --git a/library/core/src/alloc/layout.rs b/library/core/src/alloc/layout.rs
index 380f67f91f9..49275975f04 100644
--- a/library/core/src/alloc/layout.rs
+++ b/library/core/src/alloc/layout.rs
@@ -61,8 +61,8 @@ impl Layout {
     /// * `align` must be a power of two,
     ///
     /// * `size`, when rounded up to the nearest multiple of `align`,
-    ///    must not overflow `isize` (i.e., the rounded value must be
-    ///    less than or equal to `isize::MAX`).
+    ///   must not overflow `isize` (i.e., the rounded value must be
+    ///   less than or equal to `isize::MAX`).
     #[stable(feature = "alloc_layout", since = "1.28.0")]
     #[rustc_const_stable(feature = "const_alloc_layout_size_align", since = "1.50.0")]
     #[inline]
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 7ce03e3d831..2cd5c19bf4e 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -1941,21 +1941,21 @@ impl<T: ?Sized + fmt::Display> fmt::Display for RefMut<'_, T> {
 /// The precise Rust aliasing rules are somewhat in flux, but the main points are not contentious:
 ///
 /// - If you create a safe reference with lifetime `'a` (either a `&T` or `&mut T` reference), then
-/// you must not access the data in any way that contradicts that reference for the remainder of
-/// `'a`. For example, this means that if you take the `*mut T` from an `UnsafeCell<T>` and cast it
-/// to an `&T`, then the data in `T` must remain immutable (modulo any `UnsafeCell` data found
-/// within `T`, of course) until that reference's lifetime expires. Similarly, if you create a `&mut
-/// T` reference that is released to safe code, then you must not access the data within the
-/// `UnsafeCell` until that reference expires.
+///   you must not access the data in any way that contradicts that reference for the remainder of
+///   `'a`. For example, this means that if you take the `*mut T` from an `UnsafeCell<T>` and cast it
+///   to an `&T`, then the data in `T` must remain immutable (modulo any `UnsafeCell` data found
+///   within `T`, of course) until that reference's lifetime expires. Similarly, if you create a
+///   `&mut T` reference that is released to safe code, then you must not access the data within the
+///   `UnsafeCell` until that reference expires.
 ///
 /// - For both `&T` without `UnsafeCell<_>` and `&mut T`, you must also not deallocate the data
-/// until the reference expires. As a special exception, given an `&T`, any part of it that is
-/// inside an `UnsafeCell<_>` may be deallocated during the lifetime of the reference, after the
-/// last time the reference is used (dereferenced or reborrowed). Since you cannot deallocate a part
-/// of what a reference points to, this means the memory an `&T` points to can be deallocated only if
-/// *every part of it* (including padding) is inside an `UnsafeCell`.
+///   until the reference expires. As a special exception, given an `&T`, any part of it that is
+///   inside an `UnsafeCell<_>` may be deallocated during the lifetime of the reference, after the
+///   last time the reference is used (dereferenced or reborrowed). Since you cannot deallocate a part
+///   of what a reference points to, this means the memory an `&T` points to can be deallocated only if
+///   *every part of it* (including padding) is inside an `UnsafeCell`.
 ///
-///     However, whenever a `&UnsafeCell<T>` is constructed or dereferenced, it must still point to
+/// However, whenever a `&UnsafeCell<T>` is constructed or dereferenced, it must still point to
 /// live memory and the compiler is allowed to insert spurious reads if it can prove that this
 /// memory has not yet been deallocated.
 ///
@@ -1963,10 +1963,10 @@ impl<T: ?Sized + fmt::Display> fmt::Display for RefMut<'_, T> {
 /// for single-threaded code:
 ///
 /// 1. A `&T` reference can be released to safe code and there it can co-exist with other `&T`
-/// references, but not with a `&mut T`
+///    references, but not with a `&mut T`
 ///
 /// 2. A `&mut T` reference may be released to safe code provided neither other `&mut T` nor `&T`
-/// co-exist with it. A `&mut T` must always be unique.
+///    co-exist with it. A `&mut T` must always be unique.
 ///
 /// Note that whilst mutating the contents of an `&UnsafeCell<T>` (even while other
 /// `&UnsafeCell<T>` references alias the cell) is
diff --git a/library/core/src/error.rs b/library/core/src/error.rs
index 7f5c6ac42bc..88e633c9eef 100644
--- a/library/core/src/error.rs
+++ b/library/core/src/error.rs
@@ -447,28 +447,28 @@ where
 /// separated by API boundaries:
 ///
 /// * Consumer - the consumer requests objects using a Request instance; eg a crate that offers
-/// fancy `Error`/`Result` reporting to users wants to request a Backtrace from a given `dyn Error`.
+///   fancy `Error`/`Result` reporting to users wants to request a Backtrace from a given `dyn Error`.
 ///
 /// * Producer - the producer provides objects when requested via Request; eg. a library with an
-/// an `Error` implementation that automatically captures backtraces at the time instances are
-/// created.
+///   an `Error` implementation that automatically captures backtraces at the time instances are
+///   created.
 ///
 /// The consumer only needs to know where to submit their request and are expected to handle the
 /// request not being fulfilled by the use of `Option<T>` in the responses offered by the producer.
 ///
 /// * A Producer initializes the value of one of its fields of a specific type. (or is otherwise
-/// prepared to generate a value requested). eg, `backtrace::Backtrace` or
-/// `std::backtrace::Backtrace`
+///   prepared to generate a value requested). eg, `backtrace::Backtrace` or
+///   `std::backtrace::Backtrace`
 /// * A Consumer requests an object of a specific type (say `std::backtrace::Backtrace`). In the
-/// case of a `dyn Error` trait object (the Producer), there are functions called `request_ref` and
-/// `request_value` to simplify obtaining an `Option<T>` for a given type.
+///   case of a `dyn Error` trait object (the Producer), there are functions called `request_ref` and
+///   `request_value` to simplify obtaining an `Option<T>` for a given type.
 /// * The Producer, when requested, populates the given Request object which is given as a mutable
-/// reference.
+///   reference.
 /// * The Consumer extracts a value or reference to the requested type from the `Request` object
-/// wrapped in an `Option<T>`; in the case of `dyn Error` the aforementioned `request_ref` and `
-/// request_value` methods mean that `dyn Error` users don't have to deal with the `Request` type at
-/// all (but `Error` implementors do). The `None` case of the `Option` suggests only that the
-/// Producer cannot currently offer an instance of the requested type, not it can't or never will.
+///   wrapped in an `Option<T>`; in the case of `dyn Error` the aforementioned `request_ref` and `
+///   request_value` methods mean that `dyn Error` users don't have to deal with the `Request` type at
+///   all (but `Error` implementors do). The `None` case of the `Option` suggests only that the
+///   Producer cannot currently offer an instance of the requested type, not it can't or never will.
 ///
 /// # Examples
 ///
diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
index c593737af8a..223b50dda09 100644
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@@ -349,10 +349,10 @@ impl FormattingOptions {
     /// Sets or removes the sign (the `+` or the `-` flag).
     ///
     /// - `+`: This is intended for numeric types and indicates that the sign
-    /// should always be printed. By default only the negative sign of signed
-    /// values is printed, and the sign of positive or unsigned values is
-    /// omitted. This flag indicates that the correct sign (+ or -) should
-    /// always be printed.
+    ///   should always be printed. By default only the negative sign of signed
+    ///   values is printed, and the sign of positive or unsigned values is
+    ///   omitted. This flag indicates that the correct sign (+ or -) should
+    ///   always be printed.
     /// - `-`: Currently not used
     #[unstable(feature = "formatting_options", issue = "118117")]
     pub fn sign(&mut self, sign: Option<Sign>) -> &mut Self {
@@ -439,9 +439,9 @@ impl FormattingOptions {
     /// Sets or removes the precision.
     ///
     /// - For non-numeric types, this can be considered a “maximum width”. If
-    /// the resulting string is longer than this width, then it is truncated
-    /// down to this many characters and that truncated value is emitted with
-    /// proper fill, alignment and width if those parameters are set.
+    ///   the resulting string is longer than this width, then it is truncated
+    ///   down to this many characters and that truncated value is emitted with
+    ///   proper fill, alignment and width if those parameters are set.
     /// - For integral types, this is ignored.
     /// - For floating-point types, this indicates how many digits after the
     /// decimal point should be printed.
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index 67f95a02af3..0f9a1ff02d1 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -211,8 +211,8 @@ pub trait PointeeSized {
 ///   - The type is sized.
 ///   - The type outlives `'a`.
 /// - Structs `Foo<..., T1, ..., Tn, ...>` implement `Unsize<Foo<..., U1, ..., Un, ...>>`
-/// where any number of (type and const) parameters may be changed if all of these conditions
-/// are met:
+///   where any number of (type and const) parameters may be changed if all of these conditions
+///   are met:
 ///   - Only the last field of `Foo` has a type involving the parameters `T1`, ..., `Tn`.
 ///   - All other parameters of the struct are equal.
 ///   - `Field<T1, ..., Tn>: Unsize<Field<U1, ..., Un>>`, where `Field<...>` stands for the actual
diff --git a/library/core/src/ops/drop.rs b/library/core/src/ops/drop.rs
index 5d040804a8d..bbef7023207 100644
--- a/library/core/src/ops/drop.rs
+++ b/library/core/src/ops/drop.rs
@@ -11,7 +11,7 @@
 /// This destructor consists of two components:
 /// - A call to `Drop::drop` for that value, if this special `Drop` trait is implemented for its type.
 /// - The automatically generated "drop glue" which recursively calls the destructors
-///     of all the fields of this value.
+///   of all the fields of this value.
 ///
 /// As Rust automatically calls the destructors of all contained fields,
 /// you don't have to implement `Drop` in most cases. But there are some cases where
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index f2a1e901188..f83a73fa566 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -125,6 +125,7 @@
 //!   `Option::<T>::None`
 //! - `transmute::<_, [u8; size_of::<T>()]>(Option::<T>::None)` is sound and produces
 //!   `[0u8; size_of::<T>()]`
+//!
 //! These cases are identified by the second column:
 //!
 //! | `T`                                                                 | Transmuting between `[0u8; size_of::<T>()]` and `Option::<T>::None` sound? |
diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index 3ca6feb679b..14bf7ba9015 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -137,10 +137,10 @@
 //! 2. An operation causes the value to depend on its own address not changing
 //!     * e.g. calling [`poll`] for the first time on the produced [`Future`]
 //! 3. Further pieces of the safe interface of the type use internal [`unsafe`] operations which
-//! assume that the address of the value is stable
+//!    assume that the address of the value is stable
 //!     * e.g. subsequent calls to [`poll`]
 //! 4. Before the value is invalidated (e.g. deallocated), it is *dropped*, giving it a chance to
-//! notify anything with pointers to itself that those pointers will be invalidated
+//!    notify anything with pointers to itself that those pointers will be invalidated
 //!     * e.g. [`drop`]ping the [`Future`] [^pin-drop-future]
 //!
 //! There are two possible ways to ensure the invariants required for 2. and 3. above (which
@@ -148,8 +148,8 @@
 //!
 //! 1. Have the value detect when it is moved and update all the pointers that point to itself.
 //! 2. Guarantee that the address of the value does not change (and that memory is not re-used
-//! for anything else) during the time that the pointers to it are expected to be valid to
-//! dereference.
+//!    for anything else) during the time that the pointers to it are expected to be valid to
+//!    dereference.
 //!
 //! Since, as we discussed, Rust can move values without notifying them that they have moved, the
 //! first option is ruled out.
@@ -160,11 +160,11 @@
 //! be able to enforce this invariant in Rust:
 //!
 //! 1. Offer a wholly `unsafe` API to interact with the object, thus requiring every caller to
-//! uphold the invariant themselves
+//!    uphold the invariant themselves
 //! 2. Store the value that must not be moved behind a carefully managed pointer internal to
-//! the object
+//!    the object
 //! 3. Leverage the type system to encode and enforce this invariant by presenting a restricted
-//! API surface to interact with *any* object that requires these invariants
+//!    API surface to interact with *any* object that requires these invariants
 //!
 //! The first option is quite obviously undesirable, as the [`unsafe`]ty of the interface will
 //! become viral throughout all code that interacts with the object.
@@ -530,7 +530,7 @@
 //! but it also implies that,
 //!
 //! 2. The memory location that stores the value must not get invalidated or otherwise repurposed
-//! during the lifespan of the pinned value until its [`drop`] returns or panics
+//!    during the lifespan of the pinned value until its [`drop`] returns or panics
 //!
 //! This point is subtle but required for intrusive data structures to be implemented soundly.
 //!
-- 
cgit 1.4.1-3-g733a5


From dd1a52f8b6ced8f49384859bbf379c9a05493f5c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 4 Jul 2025 13:57:38 +0200
Subject: Simplify clippy lints page further

---
 util/gh-pages/index_template.html | 16 ++++++++--------
 util/gh-pages/script.js           |  6 +++---
 util/gh-pages/style.css           |  7 +++----
 3 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/util/gh-pages/index_template.html b/util/gh-pages/index_template.html
index 458f20d9f99..6f380ec8fee 100644
--- a/util/gh-pages/index_template.html
+++ b/util/gh-pages/index_template.html
@@ -151,8 +151,8 @@ Otherwise, have a great day =^.^=
                     <label for="label-{{lint.id}}"> {# #}
                         <h2 class="lint-title"> {# #}
                             <div class="panel-title-name" id="lint-{{lint.id}}"> {# #}
-                                <span>{{lint.id}}</span> {#+ #}
-                                <a href="#{{lint.id}}" class="lint-anchor anchor label label-default">&para;</a> {#+ #}
+                                {{lint.id +}}
+                                <a href="#{{lint.id}}" class="anchor label label-default">&para;</a> {#+ #}
                                 <a href="" class="copy-to-clipboard anchor label label-default"> {# #}
                                     &#128203; {# #}
                                 </a> {# #}
@@ -170,24 +170,24 @@ Otherwise, have a great day =^.^=
                         <div class="list-group-item lint-doc-md">{{Self::markdown(lint.docs)}}</div> {# #}
                         <div class="lint-additional-info-container">
                             {# Applicability #}
-                            <div class="lint-additional-info-item"> {# #}
-                                <span> Applicability: </span> {# #}
+                            <div> {# #}
+                                Applicability: {#+ #}
                                 <span class="label label-default 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 class="lint-additional-info-item"> {# #}
-                                <span>{% if lint.group == "deprecated" %}Deprecated{% else %} Added{% endif +%} in: </span> {# #}
+                            <div> {# #}
+                                {% if lint.group == "deprecated" %}Deprecated{% else %} Added{% endif +%} in: {#+ #}
                                 <span class="label label-default label-version">{{lint.version}}</span> {# #}
                             </div>
                             {# Open related issues #}
-                            <div class="lint-additional-info-item"> {# #}
+                            <div> {# #}
                                 <a href="https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+{{lint.id}}">Related Issues</a> {# #}
                             </div>
 
                             {# Jump to source #}
                             {% if let Some(id_location) = lint.id_location %}
-                                <div class="lint-additional-info-item"> {# #}
+                                <div> {# #}
                                     <a href="https://github.com/rust-lang/rust-clippy/blob/master/{{id_location}}">View Source</a> {# #}
                                 </div>
                             {% endif %}
diff --git a/util/gh-pages/script.js b/util/gh-pages/script.js
index 285aa34e701..ee13f1c0cd8 100644
--- a/util/gh-pages/script.js
+++ b/util/gh-pages/script.js
@@ -554,10 +554,10 @@ function addListeners() {
             return;
         }
 
-        if (event.target.classList.contains("lint-anchor")) {
-            lintAnchor(event);
-        } else if (event.target.classList.contains("copy-to-clipboard")) {
+        if (event.target.classList.contains("copy-to-clipboard")) {
             copyToClipboard(event);
+        } else if (event.target.classList.contains("anchor")) {
+            lintAnchor(event);
         }
     });
 
diff --git a/util/gh-pages/style.css b/util/gh-pages/style.css
index 046a2a5df7c..022ea875200 100644
--- a/util/gh-pages/style.css
+++ b/util/gh-pages/style.css
@@ -69,7 +69,6 @@ div.panel div.panel-body  button.open {
 .lint-title .label { display: inline-block; }
 
 .panel-title-name { flex: 1; min-width: 400px;}
-.panel-title-name span { vertical-align: bottom; }
 
 .panel .panel-title-name .anchor { display: none; }
 .panel:hover .panel-title-name .anchor { display: inline;}
@@ -162,7 +161,7 @@ div.panel div.panel-body  button.open {
         display: flex;
         flex-flow: column;
     }
-    .lint-additional-info-item + .lint-additional-info-item {
+    .lint-additional-info-container > div + div {
         border-top: 1px solid var(--theme-popup-border);
     }
 }
@@ -171,12 +170,12 @@ div.panel div.panel-body  button.open {
         display: flex;
         flex-flow: row;
     }
-    .lint-additional-info-item + .lint-additional-info-item {
+    .lint-additional-info-container > div + div {
         border-left: 1px solid var(--theme-popup-border);
     }
 }
 
-.lint-additional-info-item {
+.lint-additional-info-container > div {
     display: inline-flex;
     min-width: 200px;
     flex-grow: 1;
-- 
cgit 1.4.1-3-g733a5


From f167f9b49ec85dae8756c21f5183cdb1f43c6d4d Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Fri, 4 Jul 2025 14:13:15 +0200
Subject: external-repos.md: small fixes

---
 src/doc/rustc-dev-guide/src/external-repos.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/external-repos.md b/src/doc/rustc-dev-guide/src/external-repos.md
index a19b1116de8..fc40b5d2bfa 100644
--- a/src/doc/rustc-dev-guide/src/external-repos.md
+++ b/src/doc/rustc-dev-guide/src/external-repos.md
@@ -49,7 +49,7 @@ implement a new tool feature or test, that should happen in one collective rustc
 
 ### Josh subtrees
 
-The [josh] tool is an alternative to git subtrees, which manages git history in a different way and scales better to larger repositories. Specific tooling is required to work with josh, you can check out the `miri` or `rust-analyzer` scripts linked above for inspiration. We provide a helper [`rustc-josh-sync`][josh-sync] tool to help with the synchronization, it is described [below](#synchronizing-a-josh-subtree).
+The [josh] tool is an alternative to git subtrees, which manages git history in a different way and scales better to larger repositories. Specific tooling is required to work with josh; you can check out the `miri` or `rust-analyzer` scripts linked above for inspiration. We provide a helper [`rustc-josh-sync`][josh-sync] tool to help with the synchronization, described [below](#synchronizing-a-josh-subtree).
 
 ### Synchronizing a Josh subtree
 
@@ -58,8 +58,7 @@ Currently, we are migrating Josh repositories to it. So far, it is used in:
 
 - rustc-dev-guide
 
-To use the tool, first install it with `cargo install --locked --git https://github.
-com/rust-lang/josh-sync`.
+To use the tool, first install it with `cargo install --locked --git https://github.com/rust-lang/josh-sync`.
 
 Both pulls (synchronize changes from rust-lang/rust into the subtree) and pushes (synchronize
 changes from the subtree to rust-lang/rust) are performed from the subtree repository (so first
-- 
cgit 1.4.1-3-g733a5


From 2111525850863ec2f4c14c964ae37a761de64f63 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Fri, 4 Jul 2025 20:54:45 +0800
Subject: Add test false-sealed-traits-note.rs

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 .../sealed-traits/false-sealed-traits-note.rs       | 13 +++++++++++++
 .../sealed-traits/false-sealed-traits-note.stderr   | 21 +++++++++++++++++++++
 2 files changed, 34 insertions(+)
 create mode 100644 tests/ui/privacy/sealed-traits/false-sealed-traits-note.rs
 create mode 100644 tests/ui/privacy/sealed-traits/false-sealed-traits-note.stderr

diff --git a/tests/ui/privacy/sealed-traits/false-sealed-traits-note.rs b/tests/ui/privacy/sealed-traits/false-sealed-traits-note.rs
new file mode 100644
index 00000000000..75bc11b0678
--- /dev/null
+++ b/tests/ui/privacy/sealed-traits/false-sealed-traits-note.rs
@@ -0,0 +1,13 @@
+// when we impl TraitA for Struct, it can compile, we should not emit sealed traits note, see issue #143392
+
+mod inner {
+    pub trait TraitA {}
+
+    pub trait TraitB: TraitA {}
+}
+
+struct Struct;
+
+impl inner::TraitB for Struct {} //~ ERROR the trait bound `Struct: TraitA` is not satisfied [E0277]
+
+fn main(){}
\ No newline at end of file
diff --git a/tests/ui/privacy/sealed-traits/false-sealed-traits-note.stderr b/tests/ui/privacy/sealed-traits/false-sealed-traits-note.stderr
new file mode 100644
index 00000000000..38555160285
--- /dev/null
+++ b/tests/ui/privacy/sealed-traits/false-sealed-traits-note.stderr
@@ -0,0 +1,21 @@
+error[E0277]: the trait bound `Struct: TraitA` is not satisfied
+  --> $DIR/false-sealed-traits-note.rs:11:24
+   |
+LL | impl inner::TraitB for Struct {}
+   |                        ^^^^^^ the trait `TraitA` is not implemented for `Struct`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/false-sealed-traits-note.rs:4:5
+   |
+LL |     pub trait TraitA {}
+   |     ^^^^^^^^^^^^^^^^
+note: required by a bound in `TraitB`
+  --> $DIR/false-sealed-traits-note.rs:6:23
+   |
+LL |     pub trait TraitB: TraitA {}
+   |                       ^^^^^^ required by this bound in `TraitB`
+   = note: `TraitB` is a "sealed trait", because to implement it you also need to implement `inner::TraitA`, which is not accessible; this is usually done to force you to use one of the provided types that already implement it
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 312dcd77796d59743aab30720d8df897504284e6 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Fri, 4 Jul 2025 09:47:14 -0400
Subject: Update to nightly-2025-07-04

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

diff --git a/rust-toolchain b/rust-toolchain
index bccbc6cd2c5..2fe8ec4647f 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2025-06-28"
+channel = "nightly-2025-07-04"
 components = ["rust-src", "rustc-dev", "llvm-tools-preview"]
-- 
cgit 1.4.1-3-g733a5


From b4a0cd99950871b9e694d81a24f6e41827b3a4e5 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 3 Jul 2025 13:42:36 +0000
Subject: Remove names_imported_by_glob_use query.

---
 clippy_lints/src/wildcard_imports.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index d9dda6eadb2..22fd15d153a 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -130,7 +130,7 @@ impl LateLintPass<'_> for WildcardImports {
         }
         if let ItemKind::Use(use_path, UseKind::Glob) = &item.kind
             && (self.warn_on_all || !self.check_exceptions(cx, item, use_path.segments))
-            && let used_imports = cx.tcx.names_imported_by_glob_use(item.owner_id.def_id)
+            && let Some(used_imports) = cx.tcx.resolutions(()).glob_map.get(&item.owner_id.def_id)
             && !used_imports.is_empty() // Already handled by `unused_imports`
             && !used_imports.contains(&kw::Underscore)
         {
-- 
cgit 1.4.1-3-g733a5


From 9c9ee348072ef5c8f29ccd8c0496d2269ba244df Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Thu, 3 Jul 2025 09:10:49 +0200
Subject: Port `#[non_exhaustive]` to the new attribute parsing infrastructure

---
 clippy_lints/src/exhaustive_items.rs      |  6 ++++--
 clippy_lints/src/manual_non_exhaustive.rs | 13 +++++++------
 clippy_utils/src/attrs.rs                 |  9 +++++----
 3 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 86d9038ec45..7dda3e0fdb9 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -4,7 +4,9 @@ use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::sym;
+use rustc_attr_data_structures::AttributeKind;
+use rustc_attr_data_structures::find_attr;
+
 
 declare_clippy_lint! {
     /// ### What it does
@@ -85,7 +87,7 @@ impl LateLintPass<'_> for ExhaustiveItems {
         };
         if cx.effective_visibilities.is_exported(item.owner_id.def_id)
             && let attrs = cx.tcx.hir_attrs(item.hir_id())
-            && !attrs.iter().any(|a| a.has_name(sym::non_exhaustive))
+            && !find_attr!(attrs, AttributeKind::NonExhaustive(..))
             && fields.iter().all(|f| cx.tcx.visibility(f.def_id).is_public())
         {
             span_lint_and_then(cx, lint, item.span, msg, |diag| {
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 3562b1ff5cc..51696b38880 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -4,7 +4,6 @@ use clippy_utils::is_doc_hidden;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_indent;
 use itertools::Itertools;
-use rustc_ast::attr;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
@@ -12,7 +11,9 @@ use rustc_hir::{Expr, ExprKind, Item, ItemKind, QPath, TyKind, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
-use rustc_span::{Span, sym};
+use rustc_span::Span;
+use rustc_attr_data_structures::find_attr;
+use rustc_attr_data_structures::AttributeKind;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -93,7 +94,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustive {
                         .then_some((v.def_id, v.span))
                 });
                 if let Ok((id, span)) = iter.exactly_one()
-                    && !attr::contains_name(cx.tcx.hir_attrs(item.hir_id()), sym::non_exhaustive)
+                    && !find_attr!(cx.tcx.hir_attrs(item.hir_id()), AttributeKind::NonExhaustive(..))
                 {
                     self.potential_enums.push((item.owner_id.def_id, id, item.span, span));
                 }
@@ -113,10 +114,10 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustive {
                         item.span,
                         "this seems like a manual implementation of the non-exhaustive pattern",
                         |diag| {
-                            if let Some(non_exhaustive) =
-                                attr::find_by_name(cx.tcx.hir_attrs(item.hir_id()), sym::non_exhaustive)
+                            if let Some(non_exhaustive_span) =
+                                find_attr!(cx.tcx.hir_attrs(item.hir_id()), AttributeKind::NonExhaustive(span) => *span)
                             {
-                                diag.span_note(non_exhaustive.span(), "the struct is already non-exhaustive");
+                                diag.span_note(non_exhaustive_span, "the struct is already non-exhaustive");
                             } else {
                                 let indent = snippet_indent(cx, item.span).unwrap_or_default();
                                 diag.span_suggestion_verbose(
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index 8a0ff5323c9..4c7a589e185 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -7,9 +7,10 @@ use rustc_middle::ty::{AdtDef, TyCtxt};
 use rustc_session::Session;
 use rustc_span::{Span, Symbol};
 use std::str::FromStr;
-
+use rustc_attr_data_structures::find_attr;
 use crate::source::SpanRangeExt;
 use crate::{sym, tokenize_with_text};
+use rustc_attr_data_structures::AttributeKind;
 
 /// Deprecation status of attributes known by Clippy.
 pub enum DeprecationStatus {
@@ -165,13 +166,13 @@ pub fn is_doc_hidden(attrs: &[impl AttributeExt]) -> bool {
 
 pub fn has_non_exhaustive_attr(tcx: TyCtxt<'_>, adt: AdtDef<'_>) -> bool {
     adt.is_variant_list_non_exhaustive()
-        || tcx.has_attr(adt.did(), sym::non_exhaustive)
+        || find_attr!(tcx.get_all_attrs(adt.did()), AttributeKind::NonExhaustive(..))
         || adt.variants().iter().any(|variant_def| {
-            variant_def.is_field_list_non_exhaustive() || tcx.has_attr(variant_def.def_id, sym::non_exhaustive)
+            variant_def.is_field_list_non_exhaustive() || find_attr!(tcx.get_all_attrs(variant_def.def_id), AttributeKind::NonExhaustive(..))
         })
         || adt
             .all_fields()
-            .any(|field_def| tcx.has_attr(field_def.did, sym::non_exhaustive))
+            .any(|field_def| find_attr!(tcx.get_all_attrs(field_def.did), AttributeKind::NonExhaustive(..)))
 }
 
 /// Checks if the given span contains a `#[cfg(..)]` attribute
-- 
cgit 1.4.1-3-g733a5


From 148a220e38f0b2ba4ec8014d0c1e83ca6d52d47e Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Fri, 4 Jul 2025 13:10:34 +0200
Subject: remote-test-client: Exit code `128 + <signal-number>` instead of `3`

If the remote process is terminated by a signal, make `remote-test-client` exit
with the code `128 + <signal-number>` instead of always `3`. This follows common
practice among tools such as bash [^1]:

> When a command terminates on a fatal signal whose number is N, Bash uses the
> value 128+N as the exit status.

It also allows us to differentiate between `run-pass` and `run-crash` ui tests
without special case code in compiletest for that when `remote-test-client` is
used.

[^1]: https://www.gnu.org/software/bash/manual/html_node/Exit-Status.html
---
 src/tools/remote-test-client/src/main.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/tools/remote-test-client/src/main.rs b/src/tools/remote-test-client/src/main.rs
index bda08423487..b9741431b50 100644
--- a/src/tools/remote-test-client/src/main.rs
+++ b/src/tools/remote-test-client/src/main.rs
@@ -335,7 +335,9 @@ fn run(support_lib_count: usize, exe: String, all_args: Vec<String>) {
         std::process::exit(code);
     } else {
         println!("died due to signal {}", code);
-        std::process::exit(3);
+        // Behave like bash and other tools and exit with 128 + the signal
+        // number. That way we can avoid special case code in other places.
+        std::process::exit(128 + code);
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 4a261a15131e5eec10252d5131c8a3c3f89edbf7 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Fri, 4 Jul 2025 21:38:46 +0800
Subject: Use relative visibility when noting sealed trait to reduce false
 positive

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 .../src/error_reporting/traits/suggestions.rs        | 20 +++++++++++++++-----
 .../sealed-traits/false-sealed-traits-note.rs        |  4 ++--
 .../sealed-traits/false-sealed-traits-note.stderr    |  1 -
 3 files changed, 17 insertions(+), 8 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 362052e9fdb..dda517074f4 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -22,6 +22,7 @@ use rustc_hir::{
     expr_needs_parens, is_range_literal,
 };
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferCtxt, InferOk};
+use rustc_middle::middle::privacy::Level;
 use rustc_middle::traits::IsConstable;
 use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::print::{
@@ -2775,11 +2776,20 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         ty::ClauseKind::Trait(trait_pred) => {
                             let def_id = trait_pred.def_id();
                             let visible_item = if let Some(local) = def_id.as_local() {
-                                // Check for local traits being reachable.
-                                let vis = &tcx.resolutions(()).effective_visibilities;
-                                // Account for non-`pub` traits in the root of the local crate.
-                                let is_locally_reachable = tcx.parent(def_id).is_crate_root();
-                                vis.is_reachable(local) || is_locally_reachable
+                                let ty = trait_pred.self_ty();
+                                // when `TraitA: TraitB` and `S` only impl TraitA,
+                                // we check if `TraitB` can be reachable from `S`
+                                // to determine whether to note `TraitA` is sealed trait.
+                                if let ty::Adt(adt, _) = ty.kind() {
+                                    let visibilities = tcx.effective_visibilities(());
+                                    visibilities.effective_vis(local).is_none_or(|v| {
+                                        v.at_level(Level::Reexported)
+                                            .is_accessible_from(adt.did(), tcx)
+                                    })
+                                } else {
+                                    // FIXME(xizheyin): if the type is not ADT, we should not suggest it
+                                    true
+                                }
                             } else {
                                 // Check for foreign traits being reachable.
                                 tcx.visible_parent_map(()).get(&def_id).is_some()
diff --git a/tests/ui/privacy/sealed-traits/false-sealed-traits-note.rs b/tests/ui/privacy/sealed-traits/false-sealed-traits-note.rs
index 75bc11b0678..13f3065e442 100644
--- a/tests/ui/privacy/sealed-traits/false-sealed-traits-note.rs
+++ b/tests/ui/privacy/sealed-traits/false-sealed-traits-note.rs
@@ -1,4 +1,4 @@
-// when we impl TraitA for Struct, it can compile, we should not emit sealed traits note, see issue #143392
+// We should not emit sealed traits note, see issue #143392
 
 mod inner {
     pub trait TraitA {}
@@ -10,4 +10,4 @@ struct Struct;
 
 impl inner::TraitB for Struct {} //~ ERROR the trait bound `Struct: TraitA` is not satisfied [E0277]
 
-fn main(){}
\ No newline at end of file
+fn main(){}
diff --git a/tests/ui/privacy/sealed-traits/false-sealed-traits-note.stderr b/tests/ui/privacy/sealed-traits/false-sealed-traits-note.stderr
index 38555160285..f80d985ad6e 100644
--- a/tests/ui/privacy/sealed-traits/false-sealed-traits-note.stderr
+++ b/tests/ui/privacy/sealed-traits/false-sealed-traits-note.stderr
@@ -14,7 +14,6 @@ note: required by a bound in `TraitB`
    |
 LL |     pub trait TraitB: TraitA {}
    |                       ^^^^^^ required by this bound in `TraitB`
-   = note: `TraitB` is a "sealed trait", because to implement it you also need to implement `inner::TraitA`, which is not accessible; this is usually done to force you to use one of the provided types that already implement it
 
 error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From 6ae56f4e965418d920da4981303cbdc43477cb39 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Fri, 4 Jul 2025 16:53:19 -0500
Subject: Remove the `let_chains` feature now that it is stable

---
 library/compiler-builtins/crates/libm-macros/src/lib.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/library/compiler-builtins/crates/libm-macros/src/lib.rs b/library/compiler-builtins/crates/libm-macros/src/lib.rs
index 482da974ca8..7efa1488f57 100644
--- a/library/compiler-builtins/crates/libm-macros/src/lib.rs
+++ b/library/compiler-builtins/crates/libm-macros/src/lib.rs
@@ -1,5 +1,3 @@
-#![feature(let_chains)]
-
 mod enums;
 mod parse;
 mod shared;
-- 
cgit 1.4.1-3-g733a5


From e164811f5d69c00baf93694dfe203001b40ecdeb Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Fri, 4 Jul 2025 17:03:45 -0500
Subject: symcheck: Make `target` a positional argument

This makes it more obvious what we intend to check rather than looking
for `--target`.
---
 library/compiler-builtins/ci/run.sh                | 27 +++++++---------
 .../crates/symbol-check/src/main.rs                | 37 ++++++++++++++--------
 2 files changed, 35 insertions(+), 29 deletions(-)

diff --git a/library/compiler-builtins/ci/run.sh b/library/compiler-builtins/ci/run.sh
index 27b9686eac6..8b7965bb205 100755
--- a/library/compiler-builtins/ci/run.sh
+++ b/library/compiler-builtins/ci/run.sh
@@ -54,29 +54,26 @@ symcheck=(cargo run -p symbol-check --release)
 [[ "$target" = "wasm"* ]] && symcheck+=(--features wasm)
 symcheck+=(-- build-and-check)
 
-"${symcheck[@]}" -p compiler_builtins --target "$target"
-"${symcheck[@]}" -p compiler_builtins --target "$target" --release
-"${symcheck[@]}" -p compiler_builtins --target "$target" --features c
-"${symcheck[@]}" -p compiler_builtins --target "$target" --features c --release
-"${symcheck[@]}" -p compiler_builtins --target "$target" --features no-asm
-"${symcheck[@]}" -p compiler_builtins --target "$target" --features no-asm --release
-"${symcheck[@]}" -p compiler_builtins --target "$target" --features no-f16-f128
-"${symcheck[@]}" -p compiler_builtins --target "$target" --features no-f16-f128 --release
+"${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[@]}" "$target" -- -p compiler_builtins --features no-f16-f128
+"${symcheck[@]}" "$target" -- -p compiler_builtins --features no-f16-f128 --release
 
 run_intrinsics_test() {
-    args=(
-        --target "$target" --verbose \
-        --manifest-path builtins-test-intrinsics/Cargo.toml
-    )
-    args+=( "$@" )
+    build_args=(--verbose --manifest-path builtins-test-intrinsics/Cargo.toml)
+    build_args+=("$@")
 
     # symcheck also checks the results of builtins-test-intrinsics
-    "${symcheck[@]}" "${args[@]}"
+    "${symcheck[@]}" "$target" -- "${build_args[@]}"
 
     # FIXME: we get access violations on Windows, our entrypoint may need to
     # be tweaked.
     if [ "${BUILD_ONLY:-}" != "1" ] && ! [[ "$target" = *"windows"* ]]; then
-        cargo run "${args[@]}"
+        cargo run --target "$target" "${build_args[@]}"
     fi
 }
 
diff --git a/library/compiler-builtins/crates/symbol-check/src/main.rs b/library/compiler-builtins/crates/symbol-check/src/main.rs
index 843a943fb5f..f60d4f0d36f 100644
--- a/library/compiler-builtins/crates/symbol-check/src/main.rs
+++ b/library/compiler-builtins/crates/symbol-check/src/main.rs
@@ -18,10 +18,12 @@ const CHECK_EXTENSIONS: &[Option<&str>] = &[Some("rlib"), Some("a"), Some("exe")
 
 const USAGE: &str = "Usage:
 
-    symbol-check build-and-check CARGO_ARGS ...
+    symbol-check build-and-check [TARGET] -- CARGO_BUILD_ARGS ...
 
-Cargo will get invoked with `CARGO_ARGS` and all output
+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.
 ";
 
 fn main() {
@@ -30,11 +32,13 @@ fn main() {
     let args_ref = args.iter().map(String::as_str).collect::<Vec<_>>();
 
     match &args_ref[1..] {
-        ["build-and-check", "--target", target, args @ ..] if !args.is_empty() => {
-            run_build_and_check(Some(target), args);
+        ["build-and-check", target, "--", args @ ..] if !args.is_empty() => {
+            check_cargo_args(args);
+            run_build_and_check(target, args);
         }
-        ["build-and-check", args @ ..] if !args.is_empty() => {
-            run_build_and_check(None, args);
+        ["build-and-check", "--", args @ ..] if !args.is_empty() => {
+            check_cargo_args(args);
+            run_build_and_check(&host_target(), args);
         }
         _ => {
             println!("{USAGE}");
@@ -43,7 +47,18 @@ fn main() {
     }
 }
 
-fn run_build_and_check(target: Option<&str>, args: &[&str]) {
+/// Make sure `--target` isn't passed to avoid confusion (since it should be proivded only once,
+/// positionally).
+fn check_cargo_args(args: &[&str]) {
+    for arg in args {
+        assert!(
+            !arg.contains("--target"),
+            "target must be passed positionally. {USAGE}"
+        );
+    }
+}
+
+fn run_build_and_check(target: &str, args: &[&str]) {
     let paths = exec_cargo_with_args(target, args);
     for path in paths {
         println!("Checking {}", path.display());
@@ -70,13 +85,7 @@ fn host_target() -> String {
 
 /// Run `cargo build` with the provided additional arguments, collecting the list of created
 /// libraries.
-fn exec_cargo_with_args(target: Option<&str>, args: &[&str]) -> Vec<PathBuf> {
-    let mut host = String::new();
-    let target = target.unwrap_or_else(|| {
-        host = host_target();
-        host.as_str()
-    });
-
+fn exec_cargo_with_args(target: &str, args: &[&str]) -> Vec<PathBuf> {
     let mut cmd = Command::new("cargo");
     cmd.args(["build", "--target", target, "--message-format=json"])
         .args(args)
-- 
cgit 1.4.1-3-g733a5


From 7c2cc2ce40f962edeb7badc50172c5b6ff280f12 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Tue, 1 Jul 2025 02:46:47 +0500
Subject: cleaned up some tests

---
 tests/ui/codegen/output-slot-init-vs-noninit.rs    | 54 +++++++++++++---------
 tests/ui/codegen/remark-flag-functionality.rs      | 14 +++---
 tests/ui/codegen/shift-right-operand-mutation.rs   | 21 ++++++---
 tests/ui/codegen/sret-aliasing-rules.rs            | 13 ++++--
 tests/ui/macros/macro-paren-span-diagnostic.rs     |  6 ++-
 tests/ui/macros/macro-paren-span-diagnostic.stderr |  2 +-
 tests/ui/panics/panic-during-display-formatting.rs | 12 +++--
 tests/ui/panics/panic-handler-closures.rs          |  6 ++-
 tests/ui/parser/ufcs-return-unused-parens.fixed    |  9 ++--
 tests/ui/parser/ufcs-return-unused-parens.rs       |  9 ++--
 tests/ui/parser/ufcs-return-unused-parens.stderr   |  4 +-
 .../ui/traits/partialeq-ref-mismatch-diagnostic.rs |  4 +-
 .../partialeq-ref-mismatch-diagnostic.stderr       |  8 ++--
 13 files changed, 101 insertions(+), 61 deletions(-)

diff --git a/tests/ui/codegen/output-slot-init-vs-noninit.rs b/tests/ui/codegen/output-slot-init-vs-noninit.rs
index 97757e74fc4..55586843740 100644
--- a/tests/ui/codegen/output-slot-init-vs-noninit.rs
+++ b/tests/ui/codegen/output-slot-init-vs-noninit.rs
@@ -1,26 +1,48 @@
+//! Check that output slots work correctly for both initializing and non-initializing assignments.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/24>.
+
 //@ run-pass
 
 #![allow(dead_code)]
 #![allow(unused_assignments)]
 #![allow(unknown_lints)]
-
 #![allow(dead_assignment)]
 #![allow(unused_variables)]
 
-struct A { a: isize, b: isize }
-struct Abox { a: Box<isize>, b: Box<isize> }
+struct A {
+    a: isize,
+    b: isize,
+}
 
-fn ret_int_i() -> isize { 10 }
+struct Abox {
+    a: Box<isize>,
+    b: Box<isize>,
+}
 
-fn ret_ext_i() -> Box<isize> { Box::new(10) }
+fn ret_int_i() -> isize {
+    10
+}
 
-fn ret_int_rec() -> A { A {a: 10, b: 10} }
+fn ret_ext_i() -> Box<isize> {
+    Box::new(10)
+}
 
-fn ret_ext_rec() -> Box<A> { Box::new(A {a: 10, b: 10}) }
+fn ret_int_rec() -> A {
+    A { a: 10, b: 10 }
+}
 
-fn ret_ext_mem() -> Abox { Abox {a: Box::new(10), b: Box::new(10) } }
+fn ret_ext_rec() -> Box<A> {
+    Box::new(A { a: 10, b: 10 })
+}
+
+fn ret_ext_mem() -> Abox {
+    Abox { a: Box::new(10), b: Box::new(10) }
+}
 
-fn ret_ext_ext_mem() -> Box<Abox> { Box::new(Abox{a: Box::new(10), b: Box::new(10) }) }
+fn ret_ext_ext_mem() -> Box<Abox> {
+    Box::new(Abox { a: Box::new(10), b: Box::new(10) })
+}
 
 pub fn main() {
     let mut int_i: isize;
@@ -29,40 +51,28 @@ pub fn main() {
     let mut ext_rec: Box<A>;
     let mut ext_mem: Abox;
     let mut ext_ext_mem: Box<Abox>;
-    int_i = ret_int_i(); // initializing
 
+    int_i = ret_int_i(); // initializing
     int_i = ret_int_i(); // non-initializing
-
     int_i = ret_int_i(); // non-initializing
 
     ext_i = ret_ext_i(); // initializing
-
     ext_i = ret_ext_i(); // non-initializing
-
     ext_i = ret_ext_i(); // non-initializing
 
     int_rec = ret_int_rec(); // initializing
-
     int_rec = ret_int_rec(); // non-initializing
-
     int_rec = ret_int_rec(); // non-initializing
 
     ext_rec = ret_ext_rec(); // initializing
-
     ext_rec = ret_ext_rec(); // non-initializing
-
     ext_rec = ret_ext_rec(); // non-initializing
 
     ext_mem = ret_ext_mem(); // initializing
-
     ext_mem = ret_ext_mem(); // non-initializing
-
     ext_mem = ret_ext_mem(); // non-initializing
 
     ext_ext_mem = ret_ext_ext_mem(); // initializing
-
     ext_ext_mem = ret_ext_ext_mem(); // non-initializing
-
     ext_ext_mem = ret_ext_ext_mem(); // non-initializing
-
 }
diff --git a/tests/ui/codegen/remark-flag-functionality.rs b/tests/ui/codegen/remark-flag-functionality.rs
index 165fc63c007..797c55ba830 100644
--- a/tests/ui/codegen/remark-flag-functionality.rs
+++ b/tests/ui/codegen/remark-flag-functionality.rs
@@ -1,24 +1,26 @@
+//! Check that `-Cremark` flag correctly emits LLVM optimization remarks.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/90924>.
+
 //@ build-pass
 //@ ignore-pass
 //@ revisions: all inline merge1 merge2
 //@ compile-flags: --crate-type=lib -Cdebuginfo=1 -Copt-level=2
-//
+
 // Check that remarks can be enabled individually or with "all":
-//
 //@ [all]    compile-flags: -Cremark=all
 //@ [inline] compile-flags: -Cremark=inline
-//
+
 // Check that values of -Cremark flag are accumulated:
-//
 //@ [merge1] compile-flags: -Cremark=all    -Cremark=giraffe
 //@ [merge2] compile-flags: -Cremark=inline -Cremark=giraffe
+
 //@ dont-check-compiler-stderr
 //@ dont-require-annotations: NOTE
 
 #[no_mangle]
 #[inline(never)]
-pub fn f() {
-}
+pub fn f() {}
 
 #[no_mangle]
 pub fn g() {
diff --git a/tests/ui/codegen/shift-right-operand-mutation.rs b/tests/ui/codegen/shift-right-operand-mutation.rs
index 016a667e937..b37a0baa6f8 100644
--- a/tests/ui/codegen/shift-right-operand-mutation.rs
+++ b/tests/ui/codegen/shift-right-operand-mutation.rs
@@ -1,12 +1,19 @@
+//! Ensure shift operations don't mutate their right operand.
+//!
+//! This test checks that expressions like `0 << b` don't accidentally
+//! modify the variable `b` due to codegen issues with virtual registers.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/152>.
+
 //@ run-pass
 
-#![allow(unused_must_use)]
-// Regression test for issue #152.
 pub fn main() {
-    let mut b: usize = 1_usize;
-    while b < std::mem::size_of::<usize>() {
-        0_usize << b;
-        b <<= 1_usize;
-        println!("{}", b);
+    let mut b: usize = 1;
+    while b < size_of::<usize>() {
+        // This shift operation should not mutate `b`
+        let _ = 0_usize << b;
+        b <<= 1;
+        std::hint::black_box(b);
     }
+    assert_eq!(size_of::<usize>(), b);
 }
diff --git a/tests/ui/codegen/sret-aliasing-rules.rs b/tests/ui/codegen/sret-aliasing-rules.rs
index 0dfaa19fadb..f35e722f764 100644
--- a/tests/ui/codegen/sret-aliasing-rules.rs
+++ b/tests/ui/codegen/sret-aliasing-rules.rs
@@ -1,3 +1,11 @@
+//! Check that functions with sret results don't violate aliasing rules.
+//!
+//! When `foo = func(&mut foo)` is called, the compiler must avoid creating
+//! two mutable references to the same variable simultaneously (one for the
+//! parameter and one for the hidden sret out-pointer).
+//!
+//! Regression test for <https://github.com/rust-lang/rust/pull/18250>.
+
 //@ run-pass
 
 #[derive(Copy, Clone)]
@@ -14,10 +22,7 @@ pub fn foo(f: &mut Foo) -> Foo {
 }
 
 pub fn main() {
-    let mut f = Foo {
-        f1: 8,
-        _f2: 9,
-    };
+    let mut f = Foo { f1: 8, _f2: 9 };
     f = foo(&mut f);
     assert_eq!(f.f1, 8);
 }
diff --git a/tests/ui/macros/macro-paren-span-diagnostic.rs b/tests/ui/macros/macro-paren-span-diagnostic.rs
index c8cb63d5190..cbcb0231e4e 100644
--- a/tests/ui/macros/macro-paren-span-diagnostic.rs
+++ b/tests/ui/macros/macro-paren-span-diagnostic.rs
@@ -1,5 +1,6 @@
-// Be smart about span of parenthesized expression in macro.
+//! Check that error spans in parenthesized macro expressions point to the call site.
 
+#[rustfmt::skip]
 macro_rules! paren {
     ($e:expr) => (($e))
     //            ^^^^ do not highlight here
@@ -7,8 +8,9 @@ macro_rules! paren {
 
 mod m {
     pub struct S {
-        x: i32
+        x: i32,
     }
+
     pub fn make() -> S {
         S { x: 0 }
     }
diff --git a/tests/ui/macros/macro-paren-span-diagnostic.stderr b/tests/ui/macros/macro-paren-span-diagnostic.stderr
index da2f57033a4..ede6ff51c71 100644
--- a/tests/ui/macros/macro-paren-span-diagnostic.stderr
+++ b/tests/ui/macros/macro-paren-span-diagnostic.stderr
@@ -1,5 +1,5 @@
 error[E0616]: field `x` of struct `S` is private
-  --> $DIR/paren-span.rs:19:14
+  --> $DIR/macro-paren-span-diagnostic.rs:21:14
    |
 LL |     paren!(s.x);
    |              ^ private field
diff --git a/tests/ui/panics/panic-during-display-formatting.rs b/tests/ui/panics/panic-during-display-formatting.rs
index 6505a69fef7..a307ee49385 100644
--- a/tests/ui/panics/panic-during-display-formatting.rs
+++ b/tests/ui/panics/panic-during-display-formatting.rs
@@ -1,3 +1,5 @@
+//! Check that panics in `Display::fmt` during printing are properly handled.
+
 //@ run-pass
 //@ needs-unwind
 
@@ -18,8 +20,10 @@ impl Display for A {
 
 fn main() {
     set_output_capture(Some(Arc::new(Mutex::new(Vec::new()))));
-    assert!(std::panic::catch_unwind(|| {
-        eprintln!("{}", A);
-    })
-    .is_err());
+    assert!(
+        std::panic::catch_unwind(|| {
+            eprintln!("{}", A);
+        })
+        .is_err()
+    );
 }
diff --git a/tests/ui/panics/panic-handler-closures.rs b/tests/ui/panics/panic-handler-closures.rs
index b161859bf9c..27fea925720 100644
--- a/tests/ui/panics/panic-handler-closures.rs
+++ b/tests/ui/panics/panic-handler-closures.rs
@@ -1,10 +1,12 @@
-//@ build-pass (FIXME(62277): could be check-pass?)
+//! Check that closures can be used inside `#[panic_handler]` functions.
+
+//@ check-pass
 
 #![crate_type = "rlib"]
 #![no_std]
 
 #[panic_handler]
-pub fn panic_fmt(_: &::core::panic::PanicInfo) -> ! {
+pub fn panicfmt(_: &::core::panic::PanicInfo) -> ! {
     |x: u8| x;
     loop {}
 }
diff --git a/tests/ui/parser/ufcs-return-unused-parens.fixed b/tests/ui/parser/ufcs-return-unused-parens.fixed
index 440b22edd7d..811a853b769 100644
--- a/tests/ui/parser/ufcs-return-unused-parens.fixed
+++ b/tests/ui/parser/ufcs-return-unused-parens.fixed
@@ -1,13 +1,16 @@
+//! Check that UFCS syntax works correctly in return statements
+//! without requiring workaround parentheses.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/37765>.
+
 //@ run-pass
 //@ run-rustfix
 
 #![allow(dead_code)]
 #![warn(unused_parens)]
 
-// Parser test for #37765
-
 fn with_parens<T: ToString>(arg: T) -> String {
-    return <T as ToString>::to_string(&arg); //~WARN unnecessary parentheses around `return` value
+    return <T as ToString>::to_string(&arg); //~ WARN unnecessary parentheses around `return` value
 }
 
 fn no_parens<T: ToString>(arg: T) -> String {
diff --git a/tests/ui/parser/ufcs-return-unused-parens.rs b/tests/ui/parser/ufcs-return-unused-parens.rs
index 7eaacd6bba7..6ea69ef9a26 100644
--- a/tests/ui/parser/ufcs-return-unused-parens.rs
+++ b/tests/ui/parser/ufcs-return-unused-parens.rs
@@ -1,13 +1,16 @@
+//! Check that UFCS syntax works correctly in return statements
+//! without requiring workaround parentheses.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/37765>.
+
 //@ run-pass
 //@ run-rustfix
 
 #![allow(dead_code)]
 #![warn(unused_parens)]
 
-// Parser test for #37765
-
 fn with_parens<T: ToString>(arg: T) -> String {
-    return (<T as ToString>::to_string(&arg)); //~WARN unnecessary parentheses around `return` value
+    return (<T as ToString>::to_string(&arg)); //~ WARN unnecessary parentheses around `return` value
 }
 
 fn no_parens<T: ToString>(arg: T) -> String {
diff --git a/tests/ui/parser/ufcs-return-unused-parens.stderr b/tests/ui/parser/ufcs-return-unused-parens.stderr
index 2cc786fd947..6c09e98e7b1 100644
--- a/tests/ui/parser/ufcs-return-unused-parens.stderr
+++ b/tests/ui/parser/ufcs-return-unused-parens.stderr
@@ -1,11 +1,11 @@
 warning: unnecessary parentheses around `return` value
-  --> $DIR/path-lookahead.rs:10:12
+  --> $DIR/ufcs-return-unused-parens.rs:13:12
    |
 LL |     return (<T as ToString>::to_string(&arg));
    |            ^                                ^
    |
 note: the lint level is defined here
-  --> $DIR/path-lookahead.rs:5:9
+  --> $DIR/ufcs-return-unused-parens.rs:10:9
    |
 LL | #![warn(unused_parens)]
    |         ^^^^^^^^^^^^^
diff --git a/tests/ui/traits/partialeq-ref-mismatch-diagnostic.rs b/tests/ui/traits/partialeq-ref-mismatch-diagnostic.rs
index 34b88b8a866..26ef8050b87 100644
--- a/tests/ui/traits/partialeq-ref-mismatch-diagnostic.rs
+++ b/tests/ui/traits/partialeq-ref-mismatch-diagnostic.rs
@@ -1,8 +1,10 @@
+//! Check diagnostic messages for `PartialEq` trait bound mismatches between `&T` and `T`.
+
 fn foo<T: PartialEq>(a: &T, b: T) {
     a == b; //~ ERROR E0277
 }
 
-fn foo2<T: PartialEq>(a: &T, b: T) where {
+fn foo2<T: PartialEq>(a: &T, b: T) {
     a == b; //~ ERROR E0277
 }
 
diff --git a/tests/ui/traits/partialeq-ref-mismatch-diagnostic.stderr b/tests/ui/traits/partialeq-ref-mismatch-diagnostic.stderr
index f5de1308e87..4cbd31656dc 100644
--- a/tests/ui/traits/partialeq-ref-mismatch-diagnostic.stderr
+++ b/tests/ui/traits/partialeq-ref-mismatch-diagnostic.stderr
@@ -1,5 +1,5 @@
 error[E0277]: can't compare `&T` with `T`
-  --> $DIR/partialeq_help.rs:2:7
+  --> $DIR/partialeq-ref-mismatch-diagnostic.rs:4:7
    |
 LL |     a == b;
    |       ^^ no implementation for `&T == T`
@@ -15,7 +15,7 @@ LL | fn foo<T: PartialEq>(a: &T, b: T) where &T: PartialEq<T> {
    |                                   ++++++++++++++++++++++
 
 error[E0277]: can't compare `&T` with `T`
-  --> $DIR/partialeq_help.rs:6:7
+  --> $DIR/partialeq-ref-mismatch-diagnostic.rs:8:7
    |
 LL |     a == b;
    |       ^^ no implementation for `&T == T`
@@ -25,10 +25,10 @@ help: consider dereferencing here
    |
 LL |     *a == b;
    |     +
-help: consider extending the `where` clause, but there might be an alternative better way to express this requirement
+help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
    |
 LL | fn foo2<T: PartialEq>(a: &T, b: T) where &T: PartialEq<T> {
-   |                                          ++++++++++++++++
+   |                                    ++++++++++++++++++++++
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 84060f608b375d77bed9845709d57441393ceed6 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Fri, 4 Jul 2025 18:10:27 -0500
Subject: symcheck: Improve diagnostics from spawned Cargo

Rather than printing the entire JSON dump, use the rendered version.
---
 .../crates/symbol-check/src/main.rs                | 29 ++++++++++++++++------
 1 file changed, 22 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 f60d4f0d36f..1312a717970 100644
--- a/library/compiler-builtins/crates/symbol-check/src/main.rs
+++ b/library/compiler-builtins/crates/symbol-check/src/main.rs
@@ -87,9 +87,14 @@ fn host_target() -> String {
 /// libraries.
 fn exec_cargo_with_args(target: &str, args: &[&str]) -> Vec<PathBuf> {
     let mut cmd = Command::new("cargo");
-    cmd.args(["build", "--target", target, "--message-format=json"])
-        .args(args)
-        .stdout(Stdio::piped());
+    cmd.args([
+        "build",
+        "--target",
+        target,
+        "--message-format=json-diagnostic-rendered-ansi",
+    ])
+    .args(args)
+    .stdout(Stdio::piped());
 
     println!("running: {cmd:?}");
     let mut child = cmd.spawn().expect("failed to launch Cargo");
@@ -100,11 +105,21 @@ fn exec_cargo_with_args(target: &str, args: &[&str]) -> Vec<PathBuf> {
 
     for line in reader.lines() {
         let line = line.expect("failed to read line");
-        println!("{line}"); // tee to stdout
-
-        // Select only steps that create files
         let j: Value = serde_json::from_str(&line).expect("failed to deserialize");
-        if j["reason"] != "compiler-artifact" {
+        let reason = &j["reason"];
+
+        // Forward output that is meant to be user-facing
+        if reason == "compiler-message" {
+            println!("{}", j["message"]["rendered"].as_str().unwrap());
+        } else if reason == "build-finished" {
+            println!("build finshed. success: {}", j["success"]);
+        } else if reason == "build-script-executed" {
+            let pretty = serde_json::to_string_pretty(&j).unwrap();
+            println!("build script output: {pretty}",);
+        }
+
+        // Only interested in the artifact list now
+        if reason != "compiler-artifact" {
             continue;
         }
 
-- 
cgit 1.4.1-3-g733a5


From 19ab6461fbb1d9c05c3a6b6cdbaf9ffcd0f1c8d9 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Fri, 4 Jul 2025 19:30:31 -0500
Subject: Remove unused custom target JSON files

8521530f4938 ("Fix __divsi3 and __udivsi3 on thumbv6m targets") removed
tests that use these `thumb*-linux` target files in favor of tests that
use the `thumb*-none` targets, which are available via Rustup. The JSON
files haven't been used since then and are outdated, so remove them.
---
 library/compiler-builtins/thumbv6m-linux-eabi.json | 28 ----------------------
 .../compiler-builtins/thumbv7em-linux-eabi.json    | 27 ---------------------
 .../compiler-builtins/thumbv7em-linux-eabihf.json  | 28 ----------------------
 library/compiler-builtins/thumbv7m-linux-eabi.json | 27 ---------------------
 4 files changed, 110 deletions(-)
 delete mode 100644 library/compiler-builtins/thumbv6m-linux-eabi.json
 delete mode 100644 library/compiler-builtins/thumbv7em-linux-eabi.json
 delete mode 100644 library/compiler-builtins/thumbv7em-linux-eabihf.json
 delete mode 100644 library/compiler-builtins/thumbv7m-linux-eabi.json

diff --git a/library/compiler-builtins/thumbv6m-linux-eabi.json b/library/compiler-builtins/thumbv6m-linux-eabi.json
deleted file mode 100644
index ac736eae686..00000000000
--- a/library/compiler-builtins/thumbv6m-linux-eabi.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-    "abi-blacklist": [
-        "stdcall",
-        "fastcall",
-        "vectorcall",
-        "win64",
-        "sysv64"
-    ],
-    "arch": "arm",
-    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
-    "env": "",
-    "executables": true,
-    "features": "+strict-align",
-    "linker": "arm-none-eabi-gcc",
-    "linker-flavor": "gcc",
-    "llvm-target": "thumbv6m-none-eabi",
-    "max-atomic-width": 0,
-    "os": "linux",
-    "panic-strategy": "abort",
-    "pre-link-args": {
-        "gcc": ["-nostartfiles"]
-    },
-    "relocation-model": "static",
-    "target-endian": "little",
-    "target-pointer-width": "32",
-    "target-c-int-width": "32",
-    "vendor": ""
-}
diff --git a/library/compiler-builtins/thumbv7em-linux-eabi.json b/library/compiler-builtins/thumbv7em-linux-eabi.json
deleted file mode 100644
index b6d4a6bda7b..00000000000
--- a/library/compiler-builtins/thumbv7em-linux-eabi.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-    "abi-blacklist": [
-        "stdcall",
-        "fastcall",
-        "vectorcall",
-        "win64",
-        "sysv64"
-    ],
-    "arch": "arm",
-    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
-    "env": "",
-    "executables": true,
-    "linker": "arm-none-eabi-gcc",
-    "linker-flavor": "gcc",
-    "llvm-target": "thumbv7em-none-eabi",
-    "max-atomic-width": 32,
-    "os": "linux",
-    "panic-strategy": "abort",
-    "pre-link-args": {
-        "gcc": ["-nostartfiles"]
-    },
-    "relocation-model": "static",
-    "target-endian": "little",
-    "target-pointer-width": "32",
-    "target-c-int-width": "32",
-    "vendor": ""
-}
diff --git a/library/compiler-builtins/thumbv7em-linux-eabihf.json b/library/compiler-builtins/thumbv7em-linux-eabihf.json
deleted file mode 100644
index 81cfcd48d56..00000000000
--- a/library/compiler-builtins/thumbv7em-linux-eabihf.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-    "abi-blacklist": [
-        "stdcall",
-        "fastcall",
-        "vectorcall",
-        "win64",
-        "sysv64"
-    ],
-    "arch": "arm",
-    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
-    "env": "",
-    "executables": true,
-    "features": "+vfp4,+d16,+fp-only-sp",
-    "linker": "arm-none-eabi-gcc",
-    "linker-flavor": "gcc",
-    "llvm-target": "thumbv7em-none-eabihf",
-    "max-atomic-width": 32,
-    "os": "linux",
-    "panic-strategy": "abort",
-    "pre-link-args": {
-        "gcc": ["-nostartfiles"]
-    },
-    "relocation-model": "static",
-    "target-endian": "little",
-    "target-pointer-width": "32",
-    "target-c-int-width": "32",
-    "vendor": ""
-}
diff --git a/library/compiler-builtins/thumbv7m-linux-eabi.json b/library/compiler-builtins/thumbv7m-linux-eabi.json
deleted file mode 100644
index abe037c5bef..00000000000
--- a/library/compiler-builtins/thumbv7m-linux-eabi.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-    "abi-blacklist": [
-        "stdcall",
-        "fastcall",
-        "vectorcall",
-        "win64",
-        "sysv64"
-    ],
-    "arch": "arm",
-    "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
-    "env": "",
-    "executables": true,
-    "linker": "arm-none-eabi-gcc",
-    "linker-flavor": "gcc",
-    "llvm-target": "thumbv7m-none-eabi",
-    "max-atomic-width": 32,
-    "os": "linux",
-    "panic-strategy": "abort",
-    "pre-link-args": {
-        "gcc": ["-nostartfiles"]
-    },
-    "relocation-model": "static",
-    "target-endian": "little",
-    "target-pointer-width": "32",
-    "target-c-int-width": "32",
-    "vendor": ""
-}
-- 
cgit 1.4.1-3-g733a5


From 016bc61312b85fae0f0f53c56946239b712b4604 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Fri, 4 Jul 2025 19:42:18 -0500
Subject: Test building custom targets and resolve an issue probing `rustc`

The `rustc` probe done in our build scripts needs to pass `--target` to
get the correct configuration, which usually comes from the `TARGET`
environment variable. However, for targets specified via a `target.json`
file, `TARGET` gets set to the file name without an extension or path.
`rustc` will check a search path to attempt to locate the file, but this
is likely to fail since the directory where Cargo invokes build scripts
(and hence where those scripts invoke `rustc`) might not have any
relation to the JSON spec file.

Resolve this for now by leaving `f16` and `f128` disabled if the `rustc`
command fails. Result of the discussion at CARGO-14208 may eventually
provide a better solution.

A CI test is also added since custom JSON files are an edge case that
could fail in other ways. I verified this fails without the fix here.
The JSON file is the output for `thumbv7em-none-eabi`, just renamed so
`rustc` doesn't identify it.
---
 .../compiler-builtins/.github/workflows/main.yaml  | 20 +++++++++++++++++++
 .../compiler-builtins/configure.rs                 | 13 +++++++++---
 .../etc/thumbv7em-none-eabi-renamed.json           | 23 ++++++++++++++++++++++
 library/compiler-builtins/libm/configure.rs        | 13 +++++++++---
 4 files changed, 63 insertions(+), 6 deletions(-)
 create mode 100644 library/compiler-builtins/etc/thumbv7em-none-eabi-renamed.json

diff --git a/library/compiler-builtins/.github/workflows/main.yaml b/library/compiler-builtins/.github/workflows/main.yaml
index 95b0962b082..541c99c828d 100644
--- a/library/compiler-builtins/.github/workflows/main.yaml
+++ b/library/compiler-builtins/.github/workflows/main.yaml
@@ -195,6 +195,25 @@ jobs:
       run: ./ci/update-musl.sh
     - run: cargo clippy --workspace --all-targets
 
+  build-custom:
+    name: Build custom target
+    runs-on: ubuntu-24.04
+    timeout-minutes: 10
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install Rust
+      run: |
+        rustup update nightly --no-self-update
+        rustup default nightly
+        rustup component add rust-src
+    - uses: Swatinem/rust-cache@v2
+    - run: |
+        # Ensure we can build with custom target.json files (these can interact
+        # poorly with build scripts)
+        cargo build -p compiler_builtins -p libm \
+          --target etc/thumbv7em-none-eabi-renamed.json \
+          -Zbuild-std=core
+
   benchmarks:
     name: Benchmarks
     timeout-minutes: 20
@@ -331,6 +350,7 @@ jobs:
   success:
     needs:
       - benchmarks
+      - build-custom
       - clippy
       - extensive
       - miri
diff --git a/library/compiler-builtins/compiler-builtins/configure.rs b/library/compiler-builtins/compiler-builtins/configure.rs
index a1e45080e71..9721ddf090c 100644
--- a/library/compiler-builtins/compiler-builtins/configure.rs
+++ b/library/compiler-builtins/compiler-builtins/configure.rs
@@ -45,9 +45,16 @@ impl Target {
         let out = cmd
             .output()
             .unwrap_or_else(|e| panic!("failed to run `{cmd:?}`: {e}"));
-        assert!(out.status.success(), "failed to run `{cmd:?}`");
         let rustc_cfg = str::from_utf8(&out.stdout).unwrap();
 
+        // If we couldn't query `rustc` (e.g. a custom JSON target was used), make the safe
+        // choice and leave `f16` and `f128` disabled.
+        let rustc_output_ok = out.status.success();
+        let reliable_f128 =
+            rustc_output_ok && rustc_cfg.lines().any(|l| l == "target_has_reliable_f128");
+        let reliable_f16 =
+            rustc_output_ok && rustc_cfg.lines().any(|l| l == "target_has_reliable_f16");
+
         Self {
             triple,
             triple_split,
@@ -67,8 +74,8 @@ impl Target {
                 .split(",")
                 .map(ToOwned::to_owned)
                 .collect(),
-            reliable_f128: rustc_cfg.lines().any(|l| l == "target_has_reliable_f128"),
-            reliable_f16: rustc_cfg.lines().any(|l| l == "target_has_reliable_f16"),
+            reliable_f128,
+            reliable_f16,
         }
     }
 
diff --git a/library/compiler-builtins/etc/thumbv7em-none-eabi-renamed.json b/library/compiler-builtins/etc/thumbv7em-none-eabi-renamed.json
new file mode 100644
index 00000000000..81273d44e49
--- /dev/null
+++ b/library/compiler-builtins/etc/thumbv7em-none-eabi-renamed.json
@@ -0,0 +1,23 @@
+{
+  "abi": "eabi",
+  "arch": "arm",
+  "c-enum-min-bits": 8,
+  "crt-objects-fallback": "false",
+  "data-layout": "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64",
+  "emit-debug-gdb-scripts": false,
+  "frame-pointer": "always",
+  "linker": "rust-lld",
+  "linker-flavor": "gnu-lld",
+  "llvm-floatabi": "soft",
+  "llvm-target": "thumbv7em-none-eabi",
+  "max-atomic-width": 32,
+  "metadata": {
+    "description": "Bare ARMv7E-M",
+    "host_tools": false,
+    "std": false,
+    "tier": 2
+  },
+  "panic-strategy": "abort",
+  "relocation-model": "static",
+  "target-pointer-width": "32"
+}
diff --git a/library/compiler-builtins/libm/configure.rs b/library/compiler-builtins/libm/configure.rs
index 6562ecbe5db..f9100d2d58b 100644
--- a/library/compiler-builtins/libm/configure.rs
+++ b/library/compiler-builtins/libm/configure.rs
@@ -43,9 +43,16 @@ impl Config {
         let out = cmd
             .output()
             .unwrap_or_else(|e| panic!("failed to run `{cmd:?}`: {e}"));
-        assert!(out.status.success(), "failed to run `{cmd:?}`");
         let rustc_cfg = str::from_utf8(&out.stdout).unwrap();
 
+        // If we couldn't query `rustc` (e.g. a custom JSON target was used), make the safe
+        // choice and leave `f16` and `f128` disabled.
+        let rustc_output_ok = out.status.success();
+        let reliable_f128 =
+            rustc_output_ok && rustc_cfg.lines().any(|l| l == "target_has_reliable_f128");
+        let reliable_f16 =
+            rustc_output_ok && rustc_cfg.lines().any(|l| l == "target_has_reliable_f16");
+
         Self {
             target_triple,
             manifest_dir: PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap()),
@@ -59,8 +66,8 @@ impl Config {
             target_string: env::var("TARGET").unwrap(),
             target_vendor: env::var("CARGO_CFG_TARGET_VENDOR").unwrap(),
             target_features,
-            reliable_f128: rustc_cfg.lines().any(|l| l == "target_has_reliable_f128"),
-            reliable_f16: rustc_cfg.lines().any(|l| l == "target_has_reliable_f16"),
+            reliable_f128,
+            reliable_f16,
         }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 50061f3b11f51d7a6e3acd8ce793a1f17f99b597 Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Fri, 4 Jul 2025 21:17:40 -0700
Subject: always check for mixed deref pattern and normal constructors

This makes it work for box patterns and in rust-analyzer.
---
 compiler/rustc_pattern_analysis/src/checks.rs      | 50 ++++++++++++++++
 compiler/rustc_pattern_analysis/src/lib.rs         | 10 ++++
 compiler/rustc_pattern_analysis/src/rustc.rs       | 67 +++++-----------------
 compiler/rustc_pattern_analysis/src/usefulness.rs  |  5 +-
 .../rustc_pattern_analysis/tests/common/mod.rs     |  9 +++
 .../src/diagnostics/match_check/pat_analysis.rs    |  8 +++
 .../ui/pattern/box-pattern-constructor-mismatch.rs | 11 ++++
 .../box-pattern-constructor-mismatch.stderr        | 10 ++++
 8 files changed, 117 insertions(+), 53 deletions(-)
 create mode 100644 compiler/rustc_pattern_analysis/src/checks.rs
 create mode 100644 tests/ui/pattern/box-pattern-constructor-mismatch.rs
 create mode 100644 tests/ui/pattern/box-pattern-constructor-mismatch.stderr

diff --git a/compiler/rustc_pattern_analysis/src/checks.rs b/compiler/rustc_pattern_analysis/src/checks.rs
new file mode 100644
index 00000000000..88ccaa1e0e5
--- /dev/null
+++ b/compiler/rustc_pattern_analysis/src/checks.rs
@@ -0,0 +1,50 @@
+//! Contains checks that must be run to validate matches before performing usefulness analysis.
+
+use crate::constructor::Constructor::*;
+use crate::pat_column::PatternColumn;
+use crate::{MatchArm, PatCx};
+
+/// Validate that deref patterns and normal constructors aren't used to match on the same place.
+pub(crate) fn detect_mixed_deref_pat_ctors<'p, Cx: PatCx>(
+    cx: &Cx,
+    arms: &[MatchArm<'p, Cx>],
+) -> Result<(), Cx::Error> {
+    let pat_column = PatternColumn::new(arms);
+    detect_mixed_deref_pat_ctors_inner(cx, &pat_column)
+}
+
+fn detect_mixed_deref_pat_ctors_inner<'p, Cx: PatCx>(
+    cx: &Cx,
+    column: &PatternColumn<'p, Cx>,
+) -> Result<(), Cx::Error> {
+    let Some(ty) = column.head_ty() else {
+        return Ok(());
+    };
+
+    // Check for a mix of deref patterns and normal constructors.
+    let mut deref_pat = None;
+    let mut normal_pat = None;
+    for pat in column.iter() {
+        match pat.ctor() {
+            // The analysis can handle mixing deref patterns with wildcards and opaque patterns.
+            Wildcard | Opaque(_) => {}
+            DerefPattern(_) => deref_pat = Some(pat),
+            // Nothing else can be compared to deref patterns in `Constructor::is_covered_by`.
+            _ => normal_pat = Some(pat),
+        }
+    }
+    if let Some(deref_pat) = deref_pat
+        && let Some(normal_pat) = normal_pat
+    {
+        return Err(cx.report_mixed_deref_pat_ctors(deref_pat, normal_pat));
+    }
+
+    // Specialize and recurse into the patterns' fields.
+    let set = column.analyze_ctors(cx, &ty)?;
+    for ctor in set.present {
+        for specialized_column in column.specialize(cx, &ty, &ctor).iter() {
+            detect_mixed_deref_pat_ctors_inner(cx, specialized_column)?;
+        }
+    }
+    Ok(())
+}
diff --git a/compiler/rustc_pattern_analysis/src/lib.rs b/compiler/rustc_pattern_analysis/src/lib.rs
index 2b85d7b26ce..129fd38725c 100644
--- a/compiler/rustc_pattern_analysis/src/lib.rs
+++ b/compiler/rustc_pattern_analysis/src/lib.rs
@@ -8,6 +8,7 @@
 #![allow(unused_crate_dependencies)]
 // tidy-alphabetical-end
 
+pub(crate) mod checks;
 pub mod constructor;
 #[cfg(feature = "rustc")]
 pub mod errors;
@@ -107,6 +108,15 @@ pub trait PatCx: Sized + fmt::Debug {
         _gapped_with: &[&DeconstructedPat<Self>],
     ) {
     }
+
+    /// The current implementation of deref patterns requires that they can't match on the same
+    /// place as a normal constructor. Since this isn't caught by type-checking, we check it in the
+    /// `PatCx` before running the analysis. This reports an error if the check fails.
+    fn report_mixed_deref_pat_ctors(
+        &self,
+        deref_pat: &DeconstructedPat<Self>,
+        normal_pat: &DeconstructedPat<Self>,
+    ) -> Self::Error;
 }
 
 /// The arm of a match expression.
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index e53cebc59ba..e9795126db6 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -1027,6 +1027,21 @@ impl<'p, 'tcx: 'p> PatCx for RustcPatCtxt<'p, 'tcx> {
             );
         }
     }
+
+    fn report_mixed_deref_pat_ctors(
+        &self,
+        deref_pat: &crate::pat::DeconstructedPat<Self>,
+        normal_pat: &crate::pat::DeconstructedPat<Self>,
+    ) -> Self::Error {
+        let deref_pattern_label = deref_pat.data().span;
+        let normal_constructor_label = normal_pat.data().span;
+        self.tcx.dcx().emit_err(errors::MixedDerefPatternConstructors {
+            spans: vec![deref_pattern_label, normal_constructor_label],
+            smart_pointer_ty: deref_pat.ty().inner(),
+            deref_pattern_label,
+            normal_constructor_label,
+        })
+    }
 }
 
 /// Recursively expand this pattern into its subpatterns. Only useful for or-patterns.
@@ -1055,13 +1070,6 @@ pub fn analyze_match<'p, 'tcx>(
 ) -> Result<UsefulnessReport<'p, 'tcx>, ErrorGuaranteed> {
     let scrut_ty = tycx.reveal_opaque_ty(scrut_ty);
 
-    // The analysis doesn't support deref patterns mixed with normal constructors; error if present.
-    // FIXME(deref_patterns): This only needs to run when a deref pattern was found during lowering.
-    if tycx.tcx.features().deref_patterns() {
-        let pat_column = PatternColumn::new(arms);
-        detect_mixed_deref_pat_ctors(tycx, &pat_column)?;
-    }
-
     let scrut_validity = PlaceValidity::from_bool(tycx.known_valid_scrutinee);
     let report = compute_match_usefulness(
         tycx,
@@ -1080,48 +1088,3 @@ pub fn analyze_match<'p, 'tcx>(
 
     Ok(report)
 }
-
-// FIXME(deref_patterns): Currently it's the responsibility of the frontend (rustc or rust-analyzer)
-// to ensure that deref patterns don't appear in the same column as normal constructors. Deref
-// patterns aren't currently implemented in rust-analyzer, but should they be, the columnwise check
-// here could be made generic and shared between frontends.
-fn detect_mixed_deref_pat_ctors<'p, 'tcx>(
-    cx: &RustcPatCtxt<'p, 'tcx>,
-    column: &PatternColumn<'p, RustcPatCtxt<'p, 'tcx>>,
-) -> Result<(), ErrorGuaranteed> {
-    let Some(&ty) = column.head_ty() else {
-        return Ok(());
-    };
-
-    // Check for a mix of deref patterns and normal constructors.
-    let mut normal_ctor_span = None;
-    let mut deref_pat_span = None;
-    for pat in column.iter() {
-        match pat.ctor() {
-            // The analysis can handle mixing deref patterns with wildcards and opaque patterns.
-            Wildcard | Opaque(_) => {}
-            DerefPattern(_) => deref_pat_span = Some(pat.data().span),
-            // Nothing else can be compared to deref patterns in `Constructor::is_covered_by`.
-            _ => normal_ctor_span = Some(pat.data().span),
-        }
-    }
-    if let Some(normal_constructor_label) = normal_ctor_span
-        && let Some(deref_pattern_label) = deref_pat_span
-    {
-        return Err(cx.tcx.dcx().emit_err(errors::MixedDerefPatternConstructors {
-            spans: vec![deref_pattern_label, normal_constructor_label],
-            smart_pointer_ty: ty.inner(),
-            deref_pattern_label,
-            normal_constructor_label,
-        }));
-    }
-
-    // Specialize and recurse into the patterns' fields.
-    let set = column.analyze_ctors(cx, &ty)?;
-    for ctor in set.present {
-        for specialized_column in column.specialize(cx, &ty, &ctor).iter() {
-            detect_mixed_deref_pat_ctors(cx, specialized_column)?;
-        }
-    }
-    Ok(())
-}
diff --git a/compiler/rustc_pattern_analysis/src/usefulness.rs b/compiler/rustc_pattern_analysis/src/usefulness.rs
index c348cd508f9..fb94b4afebb 100644
--- a/compiler/rustc_pattern_analysis/src/usefulness.rs
+++ b/compiler/rustc_pattern_analysis/src/usefulness.rs
@@ -720,7 +720,7 @@ use tracing::{debug, instrument};
 use self::PlaceValidity::*;
 use crate::constructor::{Constructor, ConstructorSet, IntRange};
 use crate::pat::{DeconstructedPat, PatId, PatOrWild, WitnessPat};
-use crate::{MatchArm, PatCx, PrivateUninhabitedField};
+use crate::{MatchArm, PatCx, PrivateUninhabitedField, checks};
 #[cfg(not(feature = "rustc"))]
 pub fn ensure_sufficient_stack<R>(f: impl FnOnce() -> R) -> R {
     f()
@@ -1836,6 +1836,9 @@ pub fn compute_match_usefulness<'p, Cx: PatCx>(
     scrut_validity: PlaceValidity,
     complexity_limit: usize,
 ) -> Result<UsefulnessReport<'p, Cx>, Cx::Error> {
+    // The analysis doesn't support deref patterns mixed with normal constructors; error if present.
+    checks::detect_mixed_deref_pat_ctors(tycx, arms)?;
+
     let mut cx = UsefulnessCtxt {
         tycx,
         branch_usefulness: FxHashMap::default(),
diff --git a/compiler/rustc_pattern_analysis/tests/common/mod.rs b/compiler/rustc_pattern_analysis/tests/common/mod.rs
index 8980b644f59..0b939ef7816 100644
--- a/compiler/rustc_pattern_analysis/tests/common/mod.rs
+++ b/compiler/rustc_pattern_analysis/tests/common/mod.rs
@@ -1,6 +1,7 @@
 use rustc_pattern_analysis::constructor::{
     Constructor, ConstructorSet, IntRange, MaybeInfiniteInt, RangeEnd, VariantVisibility,
 };
+use rustc_pattern_analysis::pat::DeconstructedPat;
 use rustc_pattern_analysis::usefulness::{PlaceValidity, UsefulnessReport};
 use rustc_pattern_analysis::{MatchArm, PatCx, PrivateUninhabitedField};
 
@@ -184,6 +185,14 @@ impl PatCx for Cx {
     fn complexity_exceeded(&self) -> Result<(), Self::Error> {
         Err(())
     }
+
+    fn report_mixed_deref_pat_ctors(
+        &self,
+        _deref_pat: &DeconstructedPat<Self>,
+        _normal_pat: &DeconstructedPat<Self>,
+    ) -> Self::Error {
+        panic!("`rustc_pattern_analysis::tests` currently doesn't test deref pattern errors")
+    }
 }
 
 /// Construct a single pattern; see `pats!()`.
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 7cf22c64d0f..2e408b1fac9 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
@@ -527,6 +527,14 @@ impl PatCx for MatchCheckCtx<'_> {
     fn complexity_exceeded(&self) -> Result<(), Self::Error> {
         Err(())
     }
+
+    fn report_mixed_deref_pat_ctors(
+        &self,
+        _deref_pat: &DeconstructedPat<'_>,
+        _normal_pat: &DeconstructedPat<'_>,
+    ) {
+        // FIXME(deref_patterns): This could report an error comparable to the one in rustc.
+    }
 }
 
 impl fmt::Debug for MatchCheckCtx<'_> {
diff --git a/tests/ui/pattern/box-pattern-constructor-mismatch.rs b/tests/ui/pattern/box-pattern-constructor-mismatch.rs
new file mode 100644
index 00000000000..8f0a19d7407
--- /dev/null
+++ b/tests/ui/pattern/box-pattern-constructor-mismatch.rs
@@ -0,0 +1,11 @@
+//! Test that `box _` patterns and `Box { .. }` patterns can't be used to match on the same place.
+//! This is required for the current implementation of exhaustiveness analysis for deref patterns.
+
+#![feature(box_patterns)]
+
+fn main() {
+    match Box::new(0) {
+        box _ => {} //~ ERROR mix of deref patterns and normal constructors
+        Box { .. } => {}
+    }
+}
diff --git a/tests/ui/pattern/box-pattern-constructor-mismatch.stderr b/tests/ui/pattern/box-pattern-constructor-mismatch.stderr
new file mode 100644
index 00000000000..489eefe0d21
--- /dev/null
+++ b/tests/ui/pattern/box-pattern-constructor-mismatch.stderr
@@ -0,0 +1,10 @@
+error: mix of deref patterns and normal constructors
+  --> $DIR/box-pattern-constructor-mismatch.rs:8:9
+   |
+LL |         box _ => {}
+   |         ^^^^^ matches on the result of dereferencing `Box<i32>`
+LL |         Box { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Box<i32>`
+
+error: aborting due to 1 previous error
+
-- 
cgit 1.4.1-3-g733a5


From bb643159786c789c0b64f819d36a0979c63f9791 Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Fri, 4 Jul 2025 21:53:03 -0700
Subject: only check for mixed deref/normal constructors when needed

---
 compiler/rustc_mir_build/src/builder/scope.rs            |  1 +
 compiler/rustc_mir_build/src/thir/pattern/check_match.rs |  1 +
 compiler/rustc_pattern_analysis/src/lib.rs               |  5 +++++
 compiler/rustc_pattern_analysis/src/rustc.rs             | 16 ++++++++++++++++
 compiler/rustc_pattern_analysis/src/usefulness.rs        |  4 +++-
 5 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_mir_build/src/builder/scope.rs b/compiler/rustc_mir_build/src/builder/scope.rs
index 405d47c7c79..7fd3050012f 100644
--- a/compiler/rustc_mir_build/src/builder/scope.rs
+++ b/compiler/rustc_mir_build/src/builder/scope.rs
@@ -927,6 +927,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             scrut_span: rustc_span::Span::default(),
             refutable: true,
             known_valid_scrutinee: true,
+            internal_state: Default::default(),
         };
 
         let valtree = match self.eval_unevaluated_mir_constant_to_valtree(constant) {
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 b7b160c738d..a49bfc1b8f4 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -406,6 +406,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             scrut_span,
             refutable,
             known_valid_scrutinee,
+            internal_state: Default::default(),
         }
     }
 
diff --git a/compiler/rustc_pattern_analysis/src/lib.rs b/compiler/rustc_pattern_analysis/src/lib.rs
index 129fd38725c..66df35f9ee4 100644
--- a/compiler/rustc_pattern_analysis/src/lib.rs
+++ b/compiler/rustc_pattern_analysis/src/lib.rs
@@ -109,6 +109,11 @@ pub trait PatCx: Sized + fmt::Debug {
     ) {
     }
 
+    /// Check if we may need to perform additional deref-pattern-specific validation.
+    fn match_may_contain_deref_pats(&self) -> bool {
+        true
+    }
+
     /// The current implementation of deref patterns requires that they can't match on the same
     /// place as a normal constructor. Since this isn't caught by type-checking, we check it in the
     /// `PatCx` before running the analysis. This reports an error if the check fails.
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index e9795126db6..ee72b676b38 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -1,3 +1,4 @@
+use std::cell::Cell;
 use std::fmt;
 use std::iter::once;
 
@@ -99,6 +100,16 @@ pub struct RustcPatCtxt<'p, 'tcx: 'p> {
     /// Whether the data at the scrutinee is known to be valid. This is false if the scrutinee comes
     /// from a union field, a pointer deref, or a reference deref (pending opsem decisions).
     pub known_valid_scrutinee: bool,
+    pub internal_state: RustcPatCtxtState,
+}
+
+/// Private fields of [`RustcPatCtxt`], separated out to permit record initialization syntax.
+#[derive(Clone, Default)]
+pub struct RustcPatCtxtState {
+    /// Has a deref pattern been lowered? This is initialized to `false` and is updated by
+    /// [`RustcPatCtxt::lower_pat`] in order to avoid performing deref-pattern-specific validation
+    /// for everything containing patterns.
+    has_lowered_deref_pat: Cell<bool>,
 }
 
 impl<'p, 'tcx: 'p> fmt::Debug for RustcPatCtxt<'p, 'tcx> {
@@ -474,6 +485,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 fields = vec![self.lower_pat(subpattern).at_index(0)];
                 arity = 1;
                 ctor = DerefPattern(cx.reveal_opaque_ty(subpattern.ty));
+                self.internal_state.has_lowered_deref_pat.set(true);
             }
             PatKind::Leaf { subpatterns } | PatKind::Variant { subpatterns, .. } => {
                 match ty.kind() {
@@ -1028,6 +1040,10 @@ impl<'p, 'tcx: 'p> PatCx for RustcPatCtxt<'p, 'tcx> {
         }
     }
 
+    fn match_may_contain_deref_pats(&self) -> bool {
+        self.internal_state.has_lowered_deref_pat.get()
+    }
+
     fn report_mixed_deref_pat_ctors(
         &self,
         deref_pat: &crate::pat::DeconstructedPat<Self>,
diff --git a/compiler/rustc_pattern_analysis/src/usefulness.rs b/compiler/rustc_pattern_analysis/src/usefulness.rs
index fb94b4afebb..b1c646e9884 100644
--- a/compiler/rustc_pattern_analysis/src/usefulness.rs
+++ b/compiler/rustc_pattern_analysis/src/usefulness.rs
@@ -1837,7 +1837,9 @@ pub fn compute_match_usefulness<'p, Cx: PatCx>(
     complexity_limit: usize,
 ) -> Result<UsefulnessReport<'p, Cx>, Cx::Error> {
     // The analysis doesn't support deref patterns mixed with normal constructors; error if present.
-    checks::detect_mixed_deref_pat_ctors(tycx, arms)?;
+    if tycx.match_may_contain_deref_pats() {
+        checks::detect_mixed_deref_pat_ctors(tycx, arms)?;
+    }
 
     let mut cx = UsefulnessCtxt {
         tycx,
-- 
cgit 1.4.1-3-g733a5


From c4d9c0f248f05542024ad55a52774ea84406db81 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sat, 5 Jul 2025 01:46:49 -0500
Subject: tests: Use `cfg_target_has_reliable_f16_f128`

`conv-bits-runtime-const` gates `f16` and `f128` tests behind `x86_64`,
but this isn't always accurate. In particular, x86 `MinGW` has an ABI
bug [1] which means things work when linked to our Rust math libraries
but don't work with host libraries. RUST-143405 slightly adjusts which
targets we provide `f16` and `f128` symbols for and effectively removes
MinGW from that list, meaning host libraries start getting linked,
meaning `f16` and `f128` tests start to fail.

Account for this by changing the gates in one such test to
`cfg(target_has_reliable_{f16,f128})` which is the way we should be
gating all behavior related to the types going forward.

`rustfmt` also seems to have formatted the macros which is fine.

[1]: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054
---
 tests/ui/float/conv-bits-runtime-const.rs | 43 ++++++++++++++-----------------
 1 file changed, 20 insertions(+), 23 deletions(-)

diff --git a/tests/ui/float/conv-bits-runtime-const.rs b/tests/ui/float/conv-bits-runtime-const.rs
index 3046728fe66..1373001b74d 100644
--- a/tests/ui/float/conv-bits-runtime-const.rs
+++ b/tests/ui/float/conv-bits-runtime-const.rs
@@ -5,25 +5,24 @@
 
 #![feature(f16)]
 #![feature(f128)]
+#![feature(cfg_target_has_reliable_f16_f128)]
 #![allow(unused_macro_rules)]
+// expect the unexpected (`target_has_reliable_*` are not "known" configs since they are unstable)
+#![expect(unexpected_cfgs)]
 
 use std::hint::black_box;
 
 macro_rules! both_assert {
-    ($a:expr) => {
-        {
-            const _: () = assert!($a);
-            // `black_box` prevents promotion, and MIR opts are disabled above, so this is truly
-            // going through LLVM.
-            assert!(black_box($a));
-        }
-    };
-    ($a:expr, $b:expr) => {
-        {
-            const _: () = assert!($a == $b);
-            assert_eq!(black_box($a), black_box($b));
-        }
-    };
+    ($a:expr) => {{
+        const _: () = assert!($a);
+        // `black_box` prevents promotion, and MIR opts are disabled above, so this is truly
+        // going through LLVM.
+        assert!(black_box($a));
+    }};
+    ($a:expr, $b:expr) => {{
+        const _: () = assert!($a == $b);
+        assert_eq!(black_box($a), black_box($b));
+    }};
 }
 
 fn has_broken_floats() -> bool {
@@ -31,8 +30,8 @@ fn has_broken_floats() -> bool {
     cfg!(all(target_arch = "x86", not(target_feature = "sse2")))
 }
 
-#[cfg(target_arch = "x86_64")]
-fn f16(){
+#[cfg(target_has_reliable_f16)]
+fn f16() {
     both_assert!((1f16).to_bits(), 0x3c00);
     both_assert!(u16::from_be_bytes(1f16.to_be_bytes()), 0x3c00);
     both_assert!((12.5f16).to_bits(), 0x4a40);
@@ -122,7 +121,7 @@ fn f64() {
     }
 }
 
-#[cfg(target_arch = "x86_64")]
+#[cfg(target_has_reliable_f128)]
 fn f128() {
     both_assert!((1f128).to_bits(), 0x3fff0000000000000000000000000000);
     both_assert!(u128::from_be_bytes(1f128.to_be_bytes()), 0x3fff0000000000000000000000000000);
@@ -154,12 +153,10 @@ fn f128() {
 }
 
 fn main() {
+    #[cfg(target_has_reliable_f16)]
+    f16();
     f32();
     f64();
-
-    #[cfg(target_arch = "x86_64")]
-    {
-        f16();
-        f128();
-    }
+    #[cfg(target_has_reliable_f128)]
+    f128();
 }
-- 
cgit 1.4.1-3-g733a5


From 43506591e8996fda9617c26d489497c50379abea Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 5 Jul 2025 10:32:16 +0200
Subject: miri-script: set msrv so clippy doesn't suggest too-new features

---
 src/tools/miri/miri-script/Cargo.toml      | 1 +
 src/tools/miri/miri-script/src/commands.rs | 2 --
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/tools/miri/miri-script/Cargo.toml b/src/tools/miri/miri-script/Cargo.toml
index 462a9cc62bf..9240788d6bc 100644
--- a/src/tools/miri/miri-script/Cargo.toml
+++ b/src/tools/miri/miri-script/Cargo.toml
@@ -7,6 +7,7 @@ repository = "https://github.com/rust-lang/miri"
 version = "0.1.0"
 default-run = "miri-script"
 edition = "2024"
+rust-version = "1.85"
 
 [workspace]
 # We make this a workspace root so that cargo does not go looking in ../Cargo.toml for the workspace root.
diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index e948beef004..e6ebdf54e38 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -702,7 +702,6 @@ impl Command {
         let mut early_flags = Vec::<OsString>::new();
 
         // In `dep` mode, the target is already passed via `MIRI_TEST_TARGET`
-        #[expect(clippy::collapsible_if)] // we need to wait until this is stable
         if !dep {
             if let Some(target) = &target {
                 early_flags.push("--target".into());
@@ -735,7 +734,6 @@ impl Command {
         // Add Miri flags
         let mut cmd = cmd.args(&miri_flags).args(&early_flags).args(&flags);
         // For `--dep` we also need to set the target in the env var.
-        #[expect(clippy::collapsible_if)] // we need to wait until this is stable
         if dep {
             if let Some(target) = &target {
                 cmd = cmd.env("MIRI_TEST_TARGET", target);
-- 
cgit 1.4.1-3-g733a5


From d87984e12934cc2f1cf64461f2416a82d76383fe Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Sat, 5 Jul 2025 05:06:18 +0100
Subject: shims::fs adding more fields to FileMetadata

addressing, partially at least, FIXME comment and
targetting unixes, adding device, user and group ids.
---
 src/tools/miri/src/shims/unix/fs.rs | 31 +++++++++++++++++++++++++++----
 1 file changed, 27 insertions(+), 4 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index 0f7d453b296..073072a883d 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -128,16 +128,19 @@ trait EvalContextExtPrivate<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let (created_sec, created_nsec) = metadata.created.unwrap_or((0, 0));
         let (modified_sec, modified_nsec) = metadata.modified.unwrap_or((0, 0));
         let mode = metadata.mode.to_uint(this.libc_ty_layout("mode_t").size)?;
+        let dev = metadata.dev;
+        let uid = metadata.uid;
+        let gid = metadata.gid;
 
         let buf = this.deref_pointer_as(buf_op, this.libc_ty_layout("stat"))?;
         this.write_int_fields_named(
             &[
-                ("st_dev", 0),
+                ("st_dev", dev.into()),
                 ("st_mode", mode.try_into().unwrap()),
                 ("st_nlink", 0),
                 ("st_ino", 0),
-                ("st_uid", 0),
-                ("st_gid", 0),
+                ("st_uid", uid.into()),
+                ("st_gid", gid.into()),
                 ("st_rdev", 0),
                 ("st_atime", access_sec.into()),
                 ("st_mtime", modified_sec.into()),
@@ -1544,6 +1547,9 @@ struct FileMetadata {
     created: Option<(u64, u32)>,
     accessed: Option<(u64, u32)>,
     modified: Option<(u64, u32)>,
+    dev: u64,
+    uid: u32,
+    gid: u32,
 }
 
 impl FileMetadata {
@@ -1575,6 +1581,9 @@ impl FileMetadata {
         ecx: &mut MiriInterpCx<'tcx>,
         metadata: Result<std::fs::Metadata, std::io::Error>,
     ) -> InterpResult<'tcx, Result<FileMetadata, IoError>> {
+        #[cfg(unix)]
+        use std::os::unix::fs::MetadataExt;
+
         let metadata = match metadata {
             Ok(metadata) => metadata,
             Err(e) => {
@@ -1601,6 +1610,20 @@ impl FileMetadata {
         let modified = extract_sec_and_nsec(metadata.modified())?;
 
         // FIXME: Provide more fields using platform specific methods.
-        interp_ok(Ok(FileMetadata { mode, size, created, accessed, modified }))
+
+        cfg_select! {
+            unix => {
+                let dev = metadata.dev();
+                let uid = metadata.uid();
+                let gid = metadata.gid();
+            }
+            _ => {
+                let dev = 0;
+                let uid = 0;
+                let gid = 0;
+            }
+        }
+
+        interp_ok(Ok(FileMetadata { mode, size, created, accessed, modified, dev, uid, gid }))
     }
 }
-- 
cgit 1.4.1-3-g733a5


From ef0490c8685ad6ef76e2777934571fc913abd1a8 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 5 Jul 2025 11:40:37 +0200
Subject: minor cleanup

---
 src/tools/miri/src/shims/unix/fs.rs | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index 073072a883d..0f2878ad26c 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -128,19 +128,16 @@ trait EvalContextExtPrivate<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let (created_sec, created_nsec) = metadata.created.unwrap_or((0, 0));
         let (modified_sec, modified_nsec) = metadata.modified.unwrap_or((0, 0));
         let mode = metadata.mode.to_uint(this.libc_ty_layout("mode_t").size)?;
-        let dev = metadata.dev;
-        let uid = metadata.uid;
-        let gid = metadata.gid;
 
         let buf = this.deref_pointer_as(buf_op, this.libc_ty_layout("stat"))?;
         this.write_int_fields_named(
             &[
-                ("st_dev", dev.into()),
+                ("st_dev", metadata.dev.into()),
                 ("st_mode", mode.try_into().unwrap()),
                 ("st_nlink", 0),
                 ("st_ino", 0),
-                ("st_uid", uid.into()),
-                ("st_gid", gid.into()),
+                ("st_uid", metadata.uid.into()),
+                ("st_gid", metadata.gid.into()),
                 ("st_rdev", 0),
                 ("st_atime", access_sec.into()),
                 ("st_mtime", modified_sec.into()),
@@ -1581,9 +1578,6 @@ impl FileMetadata {
         ecx: &mut MiriInterpCx<'tcx>,
         metadata: Result<std::fs::Metadata, std::io::Error>,
     ) -> InterpResult<'tcx, Result<FileMetadata, IoError>> {
-        #[cfg(unix)]
-        use std::os::unix::fs::MetadataExt;
-
         let metadata = match metadata {
             Ok(metadata) => metadata,
             Err(e) => {
@@ -1613,6 +1607,7 @@ impl FileMetadata {
 
         cfg_select! {
             unix => {
+                use std::os::unix::fs::MetadataExt;
                 let dev = metadata.dev();
                 let uid = metadata.uid();
                 let gid = metadata.gid();
-- 
cgit 1.4.1-3-g733a5


From 995eeeb54cda2f3c7884e14a82bbe1f279143388 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 5 Jul 2025 17:47:28 +0000
Subject: Don't call predicates_of on a dummy obligation cause's body id

---
 .../src/error_reporting/traits/ambiguity.rs        | 33 +++++++++++++---------
 .../ambiguity-in-dropck-err-reporting.rs           | 18 ++++++++++++
 .../ambiguity-in-dropck-err-reporting.stderr       | 19 +++++++++++++
 3 files changed, 57 insertions(+), 13 deletions(-)
 create mode 100644 tests/ui/traits/error-reporting/ambiguity-in-dropck-err-reporting.rs
 create mode 100644 tests/ui/traits/error-reporting/ambiguity-in-dropck-err-reporting.stderr

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 39f115ce0cd..a8ba1baf6b9 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
@@ -4,7 +4,7 @@ use rustc_errors::{Applicability, Diag, E0283, E0284, E0790, MultiSpan, struct_s
 use rustc_hir as hir;
 use rustc_hir::LangItem;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::{CRATE_DEF_ID, DefId};
 use rustc_hir::intravisit::Visitor as _;
 use rustc_infer::infer::{BoundRegionConversionTime, InferCtxt};
 use rustc_infer::traits::util::elaborate;
@@ -128,19 +128,26 @@ pub fn compute_applicable_impls_for_diagnostics<'tcx>(
         },
     );
 
-    let predicates =
-        tcx.predicates_of(obligation.cause.body_id.to_def_id()).instantiate_identity(tcx);
-    for (pred, span) in elaborate(tcx, predicates.into_iter()) {
-        let kind = pred.kind();
-        if let ty::ClauseKind::Trait(trait_pred) = kind.skip_binder()
-            && param_env_candidate_may_apply(kind.rebind(trait_pred))
-        {
-            if kind.rebind(trait_pred.trait_ref)
-                == ty::Binder::dummy(ty::TraitRef::identity(tcx, trait_pred.def_id()))
+    // If our `body_id` has been set (and isn't just from a dummy obligation cause),
+    // then try to look for a param-env clause that would apply. The way we compute
+    // this is somewhat manual, since we need the spans, so we elaborate this directly
+    // from `predicates_of` rather than actually looking at the param-env which
+    // otherwise would be more appropriate.
+    let body_id = obligation.cause.body_id;
+    if body_id != CRATE_DEF_ID {
+        let predicates = tcx.predicates_of(body_id.to_def_id()).instantiate_identity(tcx);
+        for (pred, span) in elaborate(tcx, predicates.into_iter()) {
+            let kind = pred.kind();
+            if let ty::ClauseKind::Trait(trait_pred) = kind.skip_binder()
+                && param_env_candidate_may_apply(kind.rebind(trait_pred))
             {
-                ambiguities.push(CandidateSource::ParamEnv(tcx.def_span(trait_pred.def_id())))
-            } else {
-                ambiguities.push(CandidateSource::ParamEnv(span))
+                if kind.rebind(trait_pred.trait_ref)
+                    == ty::Binder::dummy(ty::TraitRef::identity(tcx, trait_pred.def_id()))
+                {
+                    ambiguities.push(CandidateSource::ParamEnv(tcx.def_span(trait_pred.def_id())))
+                } else {
+                    ambiguities.push(CandidateSource::ParamEnv(span))
+                }
             }
         }
     }
diff --git a/tests/ui/traits/error-reporting/ambiguity-in-dropck-err-reporting.rs b/tests/ui/traits/error-reporting/ambiguity-in-dropck-err-reporting.rs
new file mode 100644
index 00000000000..ad313823fe4
--- /dev/null
+++ b/tests/ui/traits/error-reporting/ambiguity-in-dropck-err-reporting.rs
@@ -0,0 +1,18 @@
+// Regression test for #143481, where we were calling `predicates_of` on
+// a Crate HIR node because we were using a dummy obligation cause's body id
+// without checking that it was meaningful first.
+
+trait Role {
+    type Inner;
+}
+struct HandshakeCallback<C>(C);
+impl<C: Clone> Role for HandshakeCallback {
+    //~^ ERROR missing generics
+    type Inner = usize;
+}
+struct Handshake<R: Role>(R::Inner);
+fn accept() -> Handshake<HandshakeCallback<()>> {
+    todo!()
+}
+
+fn main() {}
diff --git a/tests/ui/traits/error-reporting/ambiguity-in-dropck-err-reporting.stderr b/tests/ui/traits/error-reporting/ambiguity-in-dropck-err-reporting.stderr
new file mode 100644
index 00000000000..17ace03e891
--- /dev/null
+++ b/tests/ui/traits/error-reporting/ambiguity-in-dropck-err-reporting.stderr
@@ -0,0 +1,19 @@
+error[E0107]: missing generics for struct `HandshakeCallback`
+  --> $DIR/ambiguity-in-dropck-err-reporting.rs:9:25
+   |
+LL | impl<C: Clone> Role for HandshakeCallback {
+   |                         ^^^^^^^^^^^^^^^^^ expected 1 generic argument
+   |
+note: struct defined here, with 1 generic parameter: `C`
+  --> $DIR/ambiguity-in-dropck-err-reporting.rs:8:8
+   |
+LL | struct HandshakeCallback<C>(C);
+   |        ^^^^^^^^^^^^^^^^^ -
+help: add missing generic argument
+   |
+LL | impl<C: Clone> Role for HandshakeCallback<C> {
+   |                                          +++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0107`.
-- 
cgit 1.4.1-3-g733a5


From 75cea03e0385b793a640f3f74237e3caf5060641 Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Sat, 28 Jun 2025 01:37:33 -0700
Subject: de-duplicate condition scoping logic

---
 compiler/rustc_ast_lowering/src/expr.rs         | 45 +++----------------------
 compiler/rustc_hir_analysis/src/check/region.rs | 38 +++++++++++++++------
 compiler/rustc_hir_typeck/src/lib.rs            |  6 ++--
 3 files changed, 33 insertions(+), 56 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index c2140514e31..9942862a25d 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -532,7 +532,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         then: &Block,
         else_opt: Option<&Expr>,
     ) -> hir::ExprKind<'hir> {
-        let lowered_cond = self.lower_cond(cond);
+        let lowered_cond = self.lower_expr(cond);
         let then_expr = self.lower_block_expr(then);
         if let Some(rslt) = else_opt {
             hir::ExprKind::If(
@@ -545,44 +545,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    // Lowers a condition (i.e. `cond` in `if cond` or `while cond`), wrapping it in a terminating scope
-    // so that temporaries created in the condition don't live beyond it.
-    fn lower_cond(&mut self, cond: &Expr) -> &'hir hir::Expr<'hir> {
-        fn has_let_expr(expr: &Expr) -> bool {
-            match &expr.kind {
-                ExprKind::Binary(_, lhs, rhs) => has_let_expr(lhs) || has_let_expr(rhs),
-                ExprKind::Let(..) => true,
-                _ => false,
-            }
-        }
-
-        // We have to take special care for `let` exprs in the condition, e.g. in
-        // `if let pat = val` or `if foo && let pat = val`, as we _do_ want `val` to live beyond the
-        // condition in this case.
-        //
-        // In order to maintain the drop behavior for the non `let` parts of the condition,
-        // we still wrap them in terminating scopes, e.g. `if foo && let pat = val` essentially
-        // gets transformed into `if { let _t = foo; _t } && let pat = val`
-        match &cond.kind {
-            ExprKind::Binary(op @ Spanned { node: ast::BinOpKind::And, .. }, lhs, rhs)
-                if has_let_expr(cond) =>
-            {
-                let op = self.lower_binop(*op);
-                let lhs = self.lower_cond(lhs);
-                let rhs = self.lower_cond(rhs);
-
-                self.arena.alloc(self.expr(cond.span, hir::ExprKind::Binary(op, lhs, rhs)))
-            }
-            ExprKind::Let(..) => self.lower_expr(cond),
-            _ => {
-                let cond = self.lower_expr(cond);
-                let reason = DesugaringKind::CondTemporary;
-                let span_block = self.mark_span_with_reason(reason, cond.span, None);
-                self.expr_drop_temps(span_block, cond)
-            }
-        }
-    }
-
     // We desugar: `'label: while $cond $body` into:
     //
     // ```
@@ -606,7 +568,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         body: &Block,
         opt_label: Option<Label>,
     ) -> hir::ExprKind<'hir> {
-        let lowered_cond = self.with_loop_condition_scope(|t| t.lower_cond(cond));
+        let lowered_cond = self.with_loop_condition_scope(|t| t.lower_expr(cond));
         let then = self.lower_block_expr(body);
         let expr_break = self.expr_break(span);
         let stmt_break = self.stmt_expr(span, expr_break);
@@ -2095,7 +2057,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
     /// In terms of drop order, it has the same effect as wrapping `expr` in
     /// `{ let _t = $expr; _t }` but should provide better compile-time performance.
     ///
-    /// The drop order can be important in e.g. `if expr { .. }`.
+    /// The drop order can be important, e.g. to drop temporaries from an `async fn`
+    /// body before its parameters.
     pub(super) fn expr_drop_temps(
         &mut self,
         span: Span,
diff --git a/compiler/rustc_hir_analysis/src/check/region.rs b/compiler/rustc_hir_analysis/src/check/region.rs
index c458878da15..0c575430f0e 100644
--- a/compiler/rustc_hir_analysis/src/check/region.rs
+++ b/compiler/rustc_hir_analysis/src/check/region.rs
@@ -176,15 +176,31 @@ fn resolve_block<'tcx>(
     visitor.cx = prev_cx;
 }
 
-fn resolve_arm<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, arm: &'tcx hir::Arm<'tcx>) {
-    fn has_let_expr(expr: &Expr<'_>) -> bool {
-        match &expr.kind {
-            hir::ExprKind::Binary(_, lhs, rhs) => has_let_expr(lhs) || has_let_expr(rhs),
-            hir::ExprKind::Let(..) => true,
-            _ => false,
-        }
-    }
+/// Resolve a condition from an `if` expression or match guard so that it is a terminating scope
+/// if it doesn't contain `let` expressions.
+fn resolve_cond<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, cond: &'tcx hir::Expr<'tcx>) {
+    let terminate = match cond.kind {
+        // Temporaries for `let` expressions must live into the success branch.
+        hir::ExprKind::Let(_) => false,
+        // Logical operator chains are handled in `resolve_expr`. Since logical operator chains in
+        // conditions are lowered to control-flow rather than boolean temporaries, there's no
+        // temporary to drop for logical operators themselves. `resolve_expr` will also recursively
+        // wrap any operands in terminating scopes, other than `let` expressions (which we shouldn't
+        // terminate) and other logical operators (which don't need a terminating scope, since their
+        // 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, .. },
+            _,
+            _,
+        ) => false,
+        // Otherwise, conditions should always drop their temporaries.
+        _ => true,
+    };
+    resolve_expr(visitor, cond, terminate);
+}
 
+fn resolve_arm<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, arm: &'tcx hir::Arm<'tcx>) {
     let prev_cx = visitor.cx;
 
     visitor.enter_node_scope_with_dtor(arm.hir_id.local_id, true);
@@ -192,7 +208,7 @@ fn resolve_arm<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, arm: &'tcx hir:
 
     resolve_pat(visitor, arm.pat);
     if let Some(guard) = arm.guard {
-        resolve_expr(visitor, guard, !has_let_expr(guard));
+        resolve_cond(visitor, guard);
     }
     resolve_expr(visitor, arm.body, false);
 
@@ -420,7 +436,7 @@ fn resolve_expr<'tcx>(
             };
             visitor.enter_scope(Scope { local_id: then.hir_id.local_id, data });
             visitor.cx.var_parent = visitor.cx.parent;
-            visitor.visit_expr(cond);
+            resolve_cond(visitor, cond);
             resolve_expr(visitor, then, true);
             visitor.cx = expr_cx;
             resolve_expr(visitor, otherwise, true);
@@ -435,7 +451,7 @@ fn resolve_expr<'tcx>(
             };
             visitor.enter_scope(Scope { local_id: then.hir_id.local_id, data });
             visitor.cx.var_parent = visitor.cx.parent;
-            visitor.visit_expr(cond);
+            resolve_cond(visitor, cond);
             resolve_expr(visitor, then, true);
             visitor.cx = expr_cx;
         }
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 1cc618e2aee..b3de473acdb 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -428,11 +428,9 @@ fn report_unexpected_variant_res(
                 }
                 hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Binary(..), hir_id, .. }) => {
                     suggestion.push((expr.span.shrink_to_lo(), "(".to_string()));
-                    if let hir::Node::Expr(drop_temps) = tcx.parent_hir_node(*hir_id)
-                        && let hir::ExprKind::DropTemps(_) = drop_temps.kind
-                        && let hir::Node::Expr(parent) = tcx.parent_hir_node(drop_temps.hir_id)
+                    if let hir::Node::Expr(parent) = tcx.parent_hir_node(*hir_id)
                         && let hir::ExprKind::If(condition, block, None) = parent.kind
-                        && condition.hir_id == drop_temps.hir_id
+                        && condition.hir_id == *hir_id
                         && let hir::ExprKind::Block(block, _) = block.kind
                         && block.stmts.is_empty()
                         && let Some(expr) = block.expr
-- 
cgit 1.4.1-3-g733a5


From fc557bc5a5686ba3330c64b8187d883d94ac163f Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Sun, 29 Jun 2025 20:34:33 -0700
Subject: clippy: conditions are no longer wrapped in `DropTemps`

---
 src/tools/clippy/clippy_lints/src/booleans.rs      |  5 ++-
 src/tools/clippy/clippy_lints/src/if_not_else.rs   |  1 -
 .../clippy_lints/src/implicit_saturating_add.rs    |  5 +--
 src/tools/clippy/clippy_lints/src/let_if_seq.rs    | 11 +----
 src/tools/clippy/clippy_utils/src/higher.rs        | 49 +++++++++-------------
 src/tools/clippy/tests/ui/author/if.stdout         |  3 +-
 src/tools/clippy/tests/ui/author/struct.stdout     |  3 +-
 7 files changed, 29 insertions(+), 48 deletions(-)

diff --git a/src/tools/clippy/clippy_lints/src/booleans.rs b/src/tools/clippy/clippy_lints/src/booleans.rs
index bf43234ff50..61c2fc49bd7 100644
--- a/src/tools/clippy/clippy_lints/src/booleans.rs
+++ b/src/tools/clippy/clippy_lints/src/booleans.rs
@@ -1,5 +1,6 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
+use clippy_utils::higher::has_let_expr;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::SpanRangeExt;
 use clippy_utils::sugg::Sugg;
@@ -646,7 +647,9 @@ impl<'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'_, 'tcx> {
     fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
         if !e.span.from_expansion() {
             match &e.kind {
-                ExprKind::Binary(binop, _, _) if binop.node == BinOpKind::Or || binop.node == BinOpKind::And => {
+                ExprKind::Binary(binop, _, _)
+                    if binop.node == BinOpKind::Or || binop.node == BinOpKind::And && !has_let_expr(e) =>
+                {
                     self.bool_expr(e);
                 },
                 ExprKind::Unary(UnOp::Not, inner) => {
diff --git a/src/tools/clippy/clippy_lints/src/if_not_else.rs b/src/tools/clippy/clippy_lints/src/if_not_else.rs
index ab7a965b367..25fed0d4dd1 100644
--- a/src/tools/clippy/clippy_lints/src/if_not_else.rs
+++ b/src/tools/clippy/clippy_lints/src/if_not_else.rs
@@ -51,7 +51,6 @@ declare_lint_pass!(IfNotElse => [IF_NOT_ELSE]);
 impl LateLintPass<'_> for IfNotElse {
     fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
         if let ExprKind::If(cond, cond_inner, Some(els)) = e.kind
-            && let ExprKind::DropTemps(cond) = cond.kind
             && let ExprKind::Block(..) = els.kind
         {
             let (msg, help) = match cond.kind {
diff --git a/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs b/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs
index 185fc2aa2d4..0fdbf679738 100644
--- a/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs
+++ b/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs
@@ -41,8 +41,7 @@ declare_lint_pass!(ImplicitSaturatingAdd => [IMPLICIT_SATURATING_ADD]);
 impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let ExprKind::If(cond, then, None) = expr.kind
-            && let ExprKind::DropTemps(expr1) = cond.kind
-            && let Some((c, op_node, l)) = get_const(cx, expr1)
+            && let Some((c, op_node, l)) = get_const(cx, cond)
             && let BinOpKind::Ne | BinOpKind::Lt = op_node
             && let ExprKind::Block(block, None) = then.kind
             && let Block {
@@ -66,7 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
             && Some(c) == get_int_max(ty)
             && let ctxt = expr.span.ctxt()
             && ex.span.ctxt() == ctxt
-            && expr1.span.ctxt() == ctxt
+            && cond.span.ctxt() == ctxt
             && clippy_utils::SpanlessEq::new(cx).eq_expr(l, target)
             && AssignOpKind::AddAssign == op1.node
             && let ExprKind::Lit(lit) = value.kind
diff --git a/src/tools/clippy/clippy_lints/src/let_if_seq.rs b/src/tools/clippy/clippy_lints/src/let_if_seq.rs
index 5db28e9ae9b..e480c8fbed5 100644
--- a/src/tools/clippy/clippy_lints/src/let_if_seq.rs
+++ b/src/tools/clippy/clippy_lints/src/let_if_seq.rs
@@ -62,15 +62,8 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
             if let hir::StmtKind::Let(local) = stmt.kind
                 && let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind
                 && let hir::StmtKind::Expr(if_) = next.kind
-                && let hir::ExprKind::If(
-                    hir::Expr {
-                        kind: hir::ExprKind::DropTemps(cond),
-                        ..
-                    },
-                    then,
-                    else_,
-                ) = if_.kind
-                && !is_local_used(cx, *cond, canonical_id)
+                && let hir::ExprKind::If(cond, then, else_) = if_.kind
+                && !is_local_used(cx, cond, canonical_id)
                 && let hir::ExprKind::Block(then, _) = then.kind
                 && let Some(value) = check_assign(cx, canonical_id, then)
                 && !is_local_used(cx, value, canonical_id)
diff --git a/src/tools/clippy/clippy_utils/src/higher.rs b/src/tools/clippy/clippy_utils/src/higher.rs
index 6971b488013..4e0b00df950 100644
--- a/src/tools/clippy/clippy_utils/src/higher.rs
+++ b/src/tools/clippy/clippy_utils/src/higher.rs
@@ -54,7 +54,7 @@ impl<'tcx> ForLoop<'tcx> {
     }
 }
 
-/// An `if` expression without `DropTemps`
+/// An `if` expression without `let`
 pub struct If<'hir> {
     /// `if` condition
     pub cond: &'hir Expr<'hir>,
@@ -66,16 +66,10 @@ pub struct If<'hir> {
 
 impl<'hir> If<'hir> {
     #[inline]
-    /// Parses an `if` expression
+    /// Parses an `if` expression without `let`
     pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
-        if let ExprKind::If(
-            Expr {
-                kind: ExprKind::DropTemps(cond),
-                ..
-            },
-            then,
-            r#else,
-        ) = expr.kind
+        if let ExprKind::If(cond, then, r#else) = expr.kind
+            && !has_let_expr(cond)
         {
             Some(Self { cond, then, r#else })
         } else {
@@ -198,18 +192,10 @@ impl<'hir> IfOrIfLet<'hir> {
     /// Parses an `if` or `if let` expression
     pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
         if let ExprKind::If(cond, then, r#else) = expr.kind {
-            if let ExprKind::DropTemps(new_cond) = cond.kind {
-                return Some(Self {
-                    cond: new_cond,
-                    then,
-                    r#else,
-                });
-            }
-            if let ExprKind::Let(..) = cond.kind {
-                return Some(Self { cond, then, r#else });
-            }
+            Some(Self { cond, then, r#else })
+        } else {
+            None
         }
-        None
     }
 }
 
@@ -343,15 +329,7 @@ impl<'hir> While<'hir> {
             Block {
                 expr:
                     Some(Expr {
-                        kind:
-                            ExprKind::If(
-                                Expr {
-                                    kind: ExprKind::DropTemps(condition),
-                                    ..
-                                },
-                                body,
-                                _,
-                            ),
+                        kind: ExprKind::If(condition, body, _),
                         ..
                     }),
                 ..
@@ -360,6 +338,7 @@ impl<'hir> While<'hir> {
             LoopSource::While,
             span,
         ) = expr.kind
+            && !has_let_expr(condition)
         {
             return Some(Self { condition, body, span });
         }
@@ -493,3 +472,13 @@ pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -
     }
     None
 }
+
+/// Checks that a condition doesn't have a `let` expression, to keep `If` and `While` from accepting
+/// `if let` and `while let`.
+pub const fn has_let_expr<'tcx>(cond: &'tcx Expr<'tcx>) -> bool {
+    match &cond.kind {
+        ExprKind::Let(_) => true,
+        ExprKind::Binary(_, lhs, rhs) => has_let_expr(lhs) || has_let_expr(rhs),
+        _ => false,
+    }
+}
diff --git a/src/tools/clippy/tests/ui/author/if.stdout b/src/tools/clippy/tests/ui/author/if.stdout
index da359866bff..dbff55634ea 100644
--- a/src/tools/clippy/tests/ui/author/if.stdout
+++ b/src/tools/clippy/tests/ui/author/if.stdout
@@ -1,8 +1,7 @@
 if let StmtKind::Let(local) = stmt.kind
     && let Some(init) = local.init
     && let ExprKind::If(cond, then, Some(else_expr)) = init.kind
-    && let ExprKind::DropTemps(expr) = cond.kind
-    && let ExprKind::Lit(ref lit) = expr.kind
+    && let ExprKind::Lit(ref lit) = cond.kind
     && let LitKind::Bool(true) = lit.node
     && let ExprKind::Block(block, None) = then.kind
     && block.stmts.len() == 1
diff --git a/src/tools/clippy/tests/ui/author/struct.stdout b/src/tools/clippy/tests/ui/author/struct.stdout
index 1e8fbafd30c..2dedab56dce 100644
--- a/src/tools/clippy/tests/ui/author/struct.stdout
+++ b/src/tools/clippy/tests/ui/author/struct.stdout
@@ -2,8 +2,7 @@ if let ExprKind::Struct(qpath, fields, None) = expr.kind
     && fields.len() == 1
     && fields[0].ident.as_str() == "field"
     && let ExprKind::If(cond, then, Some(else_expr)) = fields[0].expr.kind
-    && let ExprKind::DropTemps(expr1) = cond.kind
-    && let ExprKind::Lit(ref lit) = expr1.kind
+    && let ExprKind::Lit(ref lit) = cond.kind
     && let LitKind::Bool(true) = lit.node
     && let ExprKind::Block(block, None) = then.kind
     && block.stmts.is_empty()
-- 
cgit 1.4.1-3-g733a5


From 68d860f8be6ce5de68cb0e9969e8426ceb3ad532 Mon Sep 17 00:00:00 2001
From: dianne <diannes.gm@gmail.com>
Date: Sun, 29 Jun 2025 22:09:30 -0700
Subject: remove `DesugaringKind::CondTemporary`

---
 compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs |  6 ------
 compiler/rustc_hir_typeck/src/pat.rs           | 12 +-----------
 compiler/rustc_span/src/hygiene.rs             |  7 -------
 3 files changed, 1 insertion(+), 24 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 58751f232d0..af1fc045ac8 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -51,12 +51,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         };
 
         match span.desugaring_kind() {
-            // If span arose from a desugaring of `if` or `while`, then it is the condition
-            // itself, which diverges, that we are about to lint on. This gives suboptimal
-            // diagnostics. Instead, stop here so that the `if`- or `while`-expression's
-            // block is linted instead.
-            Some(DesugaringKind::CondTemporary) => return,
-
             // Don't lint if the result of an async block or async function is `!`.
             // This does not affect the unreachable lints *within* the body.
             Some(DesugaringKind::Async) => return,
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index 349e72090d3..d014883d8ac 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -24,7 +24,6 @@ use rustc_session::lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
 use rustc_session::parse::feature_err;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::edition::Edition;
-use rustc_span::hygiene::DesugaringKind;
 use rustc_span::source_map::Spanned;
 use rustc_span::{BytePos, DUMMY_SP, Ident, Span, kw, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
@@ -902,16 +901,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // then that's equivalent to there existing a LUB.
         let cause = self.pattern_cause(ti, span);
         if let Err(err) = self.demand_suptype_with_origin(&cause, expected, pat_ty) {
-            err.emit_unless(
-                ti.span
-                    .filter(|&s| {
-                        // In the case of `if`- and `while`-expressions we've already checked
-                        // that `scrutinee: bool`. We know that the pattern is `true`,
-                        // so an error here would be a duplicate and from the wrong POV.
-                        s.is_desugaring(DesugaringKind::CondTemporary)
-                    })
-                    .is_some(),
-            );
+            err.emit();
         }
 
         pat_ty
diff --git a/compiler/rustc_span/src/hygiene.rs b/compiler/rustc_span/src/hygiene.rs
index 29be3b73ee9..c3080875da8 100644
--- a/compiler/rustc_span/src/hygiene.rs
+++ b/compiler/rustc_span/src/hygiene.rs
@@ -1191,11 +1191,6 @@ impl AstPass {
 /// The kind of compiler desugaring.
 #[derive(Clone, Copy, PartialEq, Debug, Encodable, Decodable, HashStable_Generic)]
 pub enum DesugaringKind {
-    /// We desugar `if c { i } else { e }` to `match $ExprKind::Use(c) { true => i, _ => e }`.
-    /// However, we do not want to blame `c` for unreachability but rather say that `i`
-    /// is unreachable. This desugaring kind allows us to avoid blaming `c`.
-    /// This also applies to `while` loops.
-    CondTemporary,
     QuestionMark,
     TryBlock,
     YeetExpr,
@@ -1230,7 +1225,6 @@ impl DesugaringKind {
     /// The description wording should combine well with "desugaring of {}".
     pub fn descr(self) -> &'static str {
         match self {
-            DesugaringKind::CondTemporary => "`if` or `while` condition",
             DesugaringKind::Async => "`async` block or function",
             DesugaringKind::Await => "`await` expression",
             DesugaringKind::QuestionMark => "operator `?`",
@@ -1253,7 +1247,6 @@ impl DesugaringKind {
     /// like `from_desugaring = "QuestionMark"`
     pub fn matches(&self, value: &str) -> bool {
         match self {
-            DesugaringKind::CondTemporary => value == "CondTemporary",
             DesugaringKind::Async => value == "Async",
             DesugaringKind::Await => value == "Await",
             DesugaringKind::QuestionMark => value == "QuestionMark",
-- 
cgit 1.4.1-3-g733a5


From f74e9b0ebfacf79e318077cf959f734a24a38e93 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Sun, 6 Jul 2025 03:21:43 +0300
Subject: Always bump in the parser in `err_and_bump()`

Even when at curly braces, otherwise the parser can get stuck.

This has happened in the past in #18625, but it was just worked around instead of handling the root of the problem. Now this happened again in #20171. IMO we can't let `err_and_bump()` not bump, that's too confusing and invites errors. We can (as I did) workaround the worse recovery instead.
---
 .../hir-def/src/macro_expansion_tests/mod.rs       | 42 ++++++++++++++++++++--
 .../crates/hir-expand/src/builtin/quote.rs         |  2 +-
 .../crates/parser/src/grammar/expressions/atom.rs  |  7 ++--
 .../rust-analyzer/crates/parser/src/parser.rs      |  7 ++--
 4 files changed, 50 insertions(+), 8 deletions(-)

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 1c69b37f164..5e95b061399 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
@@ -20,13 +20,14 @@ use base_db::RootQueryDb;
 use expect_test::Expect;
 use hir_expand::{
     AstId, InFile, MacroCallId, MacroCallKind, MacroKind,
+    builtin::quote::quote,
     db::ExpandDatabase,
     proc_macro::{ProcMacro, ProcMacroExpander, ProcMacroExpansionError, ProcMacroKind},
     span_map::SpanMapRef,
 };
-use intern::Symbol;
+use intern::{Symbol, sym};
 use itertools::Itertools;
-use span::{Edition, Span};
+use span::{Edition, ROOT_ERASED_FILE_AST_ID, Span, SpanAnchor, SyntaxContext};
 use stdx::{format_to, format_to_acc};
 use syntax::{
     AstNode, AstPtr,
@@ -34,7 +35,9 @@ use syntax::{
     SyntaxNode, T,
     ast::{self, edit::IndentLevel},
 };
+use syntax_bridge::token_tree_to_syntax_node;
 use test_fixture::WithFixture;
+use tt::{TextRange, TextSize};
 
 use crate::{
     AdtId, Lookup, ModuleDefId,
@@ -386,3 +389,38 @@ impl ProcMacroExpander for IdentityWhenValidProcMacroExpander {
         other.type_id() == TypeId::of::<Self>()
     }
 }
+
+#[test]
+fn regression_20171() {
+    // This really isn't the appropriate place to put this test, but it's convenient with access to `quote!`.
+    let span = Span {
+        range: TextRange::empty(TextSize::new(0)),
+        anchor: SpanAnchor {
+            file_id: span::EditionedFileId::current_edition(span::FileId::from_raw(0)),
+            ast_id: ROOT_ERASED_FILE_AST_ID,
+        },
+        ctx: SyntaxContext::root(Edition::CURRENT),
+    };
+    let close_brace = tt::Punct { char: '}', spacing: tt::Spacing::Alone, span };
+    let dotdot1 = tt::Punct { char: '.', spacing: tt::Spacing::Joint, span };
+    let dotdot2 = tt::Punct { char: '.', spacing: tt::Spacing::Alone, span };
+    let dollar_crate = sym::dollar_crate;
+    let tt = quote! {
+            span => {
+        if !((matches!(
+            drive_parser(&mut parser, data, false),
+            Err(TarParserError::CorruptField {
+                field: CorruptFieldContext::PaxKvLength,
+                error: GeneralParseError::ParseInt(ParseIntError { #dotdot1 #dotdot2 })
+            })
+        #close_brace  ))) {
+        #dollar_crate::panic::panic_2021!();
+    }}
+        };
+    token_tree_to_syntax_node(
+        &tt,
+        syntax_bridge::TopEntryPoint::MacroStmts,
+        &mut |_| Edition::CURRENT,
+        Edition::CURRENT,
+    );
+}
diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/quote.rs b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/quote.rs
index d5874f829ba..70c38d4d7c7 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/builtin/quote.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/builtin/quote.rs
@@ -129,7 +129,7 @@ macro_rules! quote {
         }
     }
 }
-pub(super) use quote;
+pub use quote;
 
 pub trait ToTokenTree {
     fn to_tokens(self, span: Span, builder: &mut TopSubtreeBuilder);
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 8ed0fc6729f..c31ebc42a86 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
@@ -411,11 +411,10 @@ fn parse_asm_expr(p: &mut Parser<'_>, m: Marker) -> Option<CompletedMarker> {
             dir_spec.abandon(p);
             op.abandon(p);
             op_n.abandon(p);
-            p.err_and_bump("expected asm operand");
 
-            // improves error recovery and handles err_and_bump recovering from `{` which gets
-            // the parser stuck here
+            // improves error recovery
             if p.at(T!['{']) {
+                p.error("expected asm operand");
                 // test_err bad_asm_expr
                 // fn foo() {
                 //     builtin#asm(
@@ -423,6 +422,8 @@ fn parse_asm_expr(p: &mut Parser<'_>, m: Marker) -> Option<CompletedMarker> {
                 //     );
                 // }
                 expr(p);
+            } else {
+                p.err_and_bump("expected asm operand");
             }
 
             if p.at(T!['}']) {
diff --git a/src/tools/rust-analyzer/crates/parser/src/parser.rs b/src/tools/rust-analyzer/crates/parser/src/parser.rs
index 36a363afe93..ca02d9fdfde 100644
--- a/src/tools/rust-analyzer/crates/parser/src/parser.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/parser.rs
@@ -29,7 +29,7 @@ pub(crate) struct Parser<'t> {
     edition: Edition,
 }
 
-const PARSER_STEP_LIMIT: usize = 15_000_000;
+const PARSER_STEP_LIMIT: usize = if cfg!(debug_assertions) { 150_000 } else { 15_000_000 };
 
 impl<'t> Parser<'t> {
     pub(super) fn new(inp: &'t Input, edition: Edition) -> Parser<'t> {
@@ -254,7 +254,10 @@ impl<'t> Parser<'t> {
 
     /// Create an error node and consume the next token.
     pub(crate) fn err_and_bump(&mut self, message: &str) {
-        self.err_recover(message, TokenSet::EMPTY);
+        let m = self.start();
+        self.error(message);
+        self.bump_any();
+        m.complete(self, ERROR);
     }
 
     /// Create an error node and consume the next token unless it is in the recovery set.
-- 
cgit 1.4.1-3-g733a5


From e0e881f8735cbd817a5e286eef232711020b21f4 Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sun, 6 Jul 2025 02:09:54 +0200
Subject: Propagate accept-comment-above-attributes to statements

Turns out that things like `#[attr]return unsafe { func(); }` didn't work
because we weren't checking above attributes on statements, only on blocks!
---
 clippy_lints/src/undocumented_unsafe_blocks.rs       | 20 +++++++++++++++++---
 .../undocumented_unsafe_blocks.disabled.stderr       | 10 +++++++++-
 .../undocumented_unsafe_blocks.rs                    | 11 +++++++++++
 3 files changed, 37 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 92427473a8e..d4f8b1b4e30 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -143,7 +143,8 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
         if let Some(tail) = block.expr
             && !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, tail.hir_id)
             && !tail.span.in_external_macro(cx.tcx.sess.source_map())
-            && let HasSafetyComment::Yes(pos) = stmt_has_safety_comment(cx, tail.span, tail.hir_id)
+            && let HasSafetyComment::Yes(pos) =
+                stmt_has_safety_comment(cx, tail.span, tail.hir_id, self.accept_comment_above_attributes)
             && let Some(help_span) = expr_has_unnecessary_safety_comment(cx, tail, pos)
         {
             span_lint_and_then(
@@ -167,7 +168,8 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
         };
         if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, stmt.hir_id)
             && !stmt.span.in_external_macro(cx.tcx.sess.source_map())
-            && let HasSafetyComment::Yes(pos) = stmt_has_safety_comment(cx, stmt.span, stmt.hir_id)
+            && let HasSafetyComment::Yes(pos) =
+                stmt_has_safety_comment(cx, stmt.span, stmt.hir_id, self.accept_comment_above_attributes)
             && let Some(help_span) = expr_has_unnecessary_safety_comment(cx, expr, pos)
         {
             span_lint_and_then(
@@ -534,7 +536,12 @@ fn item_has_safety_comment(cx: &LateContext<'_>, item: &hir::Item<'_>) -> HasSaf
 
 /// Checks if the lines immediately preceding the item contain a safety comment.
 #[allow(clippy::collapsible_match)]
-fn stmt_has_safety_comment(cx: &LateContext<'_>, span: Span, hir_id: HirId) -> HasSafetyComment {
+fn stmt_has_safety_comment(
+    cx: &LateContext<'_>,
+    span: Span,
+    hir_id: HirId,
+    accept_comment_above_attributes: bool,
+) -> HasSafetyComment {
     match span_from_macro_expansion_has_safety_comment(cx, span) {
         HasSafetyComment::Maybe => (),
         has_safety_comment => return has_safety_comment,
@@ -549,6 +556,13 @@ fn stmt_has_safety_comment(cx: &LateContext<'_>, span: Span, hir_id: HirId) -> H
         _ => return HasSafetyComment::Maybe,
     };
 
+    // if span_with_attrs_has_safety_comment(cx, span, hir_id, accept_comment_above_attrib
+    // }
+    let mut span = span;
+    if accept_comment_above_attributes {
+        span = include_attrs_in_span(cx, hir_id, span);
+    }
+
     let source_map = cx.sess().source_map();
     if let Some(comment_start) = comment_start
         && let Ok(unsafe_line) = source_map.lookup_line(span.lo())
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
index e9c5e5f9f11..453bcf1ab33 100644
--- a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
@@ -450,5 +450,13 @@ help: consider removing the safety comment
 LL |     // SAFETY: unnecessary_safety_comment triggers here
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 52 previous errors
+error: unsafe block missing a safety comment
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:733:12
+   |
+LL |     return unsafe { h() };
+   |            ^^^^^^^^^^^^^^
+   |
+   = help: consider adding a safety comment on the preceding line
+
+error: aborting due to 53 previous errors
 
diff --git a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
index 91a02bc3d7c..a2d7c1b6c79 100644
--- a/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
+++ b/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
@@ -723,4 +723,15 @@ fn issue_13039() {
     _ = unsafe { foo() }
 }
 
+fn rfl_issue15034() -> i32 {
+    unsafe fn h() -> i32 {
+        1i32
+    }
+    // This shouldn't lint with accept-comment-above-attributes! Thus fixing a false positive!
+    // SAFETY: My safety comment!
+    #[allow(clippy::unnecessary_cast)]
+    return unsafe { h() };
+    //~[disabled]^ ERROR: unsafe block missing a safety comment
+}
+
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From b49064e9df8c159828502167abcd80aafa5464fa Mon Sep 17 00:00:00 2001
From: blyxyas <blyxyas@gmail.com>
Date: Sun, 6 Jul 2025 02:21:20 +0200
Subject: Not on vacation, again!

---
 triagebot.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/triagebot.toml b/triagebot.toml
index b7a8749fbaa..81718413c38 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -52,7 +52,6 @@ contributing_url = "https://github.com/rust-lang/rust-clippy/blob/master/CONTRIB
 users_on_vacation = [
     "matthiaskrgr",
     "Manishearth",
-    "blyxyas",
 ]
 
 [assign.owners]
-- 
cgit 1.4.1-3-g733a5


From 8aad0e6ad9c0a31f458c62529ccbe1708c12b560 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Fri, 4 Jul 2025 12:42:33 +0200
Subject: Rewrite empty attribute lint

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>
---
 clippy_lints/src/arbitrary_source_item_ordering.rs | 2 +-
 clippy_lints/src/attrs/repr_attributes.rs          | 2 +-
 clippy_lints/src/default_union_representation.rs   | 2 +-
 clippy_utils/src/lib.rs                            | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/clippy_lints/src/arbitrary_source_item_ordering.rs b/clippy_lints/src/arbitrary_source_item_ordering.rs
index b9ae9afe851..8b6bfaebbe5 100644
--- a/clippy_lints/src/arbitrary_source_item_ordering.rs
+++ b/clippy_lints/src/arbitrary_source_item_ordering.rs
@@ -266,7 +266,7 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
             .tcx
             .hir_attrs(item.hir_id())
             .iter()
-            .any(|attr| matches!(attr, Attribute::Parsed(AttributeKind::Repr(..))))
+            .any(|attr| matches!(attr, Attribute::Parsed(AttributeKind::Repr{ .. })))
         {
             // Do not lint items with a `#[repr]` attribute as their layout may be imposed by an external API.
             return;
diff --git a/clippy_lints/src/attrs/repr_attributes.rs b/clippy_lints/src/attrs/repr_attributes.rs
index 05d8a8c26d1..3e8808cec61 100644
--- a/clippy_lints/src/attrs/repr_attributes.rs
+++ b/clippy_lints/src/attrs/repr_attributes.rs
@@ -9,7 +9,7 @@ use clippy_utils::msrvs::{self, Msrv};
 use super::REPR_PACKED_WITHOUT_ABI;
 
 pub(super) fn check(cx: &LateContext<'_>, item_span: Span, attrs: &[Attribute], msrv: Msrv) {
-    if let Some(reprs) = find_attr!(attrs, AttributeKind::Repr(r) => r) {
+    if let Some(reprs) = find_attr!(attrs, AttributeKind::Repr { reprs, .. } => reprs) {
         let packed_span = reprs
             .iter()
             .find(|(r, _)| matches!(r, ReprAttr::ReprPacked(..)))
diff --git a/clippy_lints/src/default_union_representation.rs b/clippy_lints/src/default_union_representation.rs
index 615421f3a40..9bf2144e445 100644
--- a/clippy_lints/src/default_union_representation.rs
+++ b/clippy_lints/src/default_union_representation.rs
@@ -99,5 +99,5 @@ fn is_zst<'tcx>(cx: &LateContext<'tcx>, field: &FieldDef, args: ty::GenericArgsR
 fn has_c_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
     let attrs = cx.tcx.hir_attrs(hir_id);
 
-    find_attr!(attrs, AttributeKind::Repr(r) if r.iter().any(|(x, _)| *x == ReprAttr::ReprC))
+    find_attr!(attrs, AttributeKind::Repr { reprs, .. } if reprs.iter().any(|(x, _)| *x == ReprAttr::ReprC))
 }
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index a8b33418c8c..c01f0ffaac9 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -1761,7 +1761,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), AttributeKind::Repr(..))
+    find_attr!(cx.tcx.hir_attrs(hir_id), AttributeKind::Repr { .. })
 }
 
 pub fn any_parent_has_attr(tcx: TyCtxt<'_>, node: HirId, symbol: Symbol) -> bool {
-- 
cgit 1.4.1-3-g733a5


From a9b8eec4b7d69176e14646c13b0580b4cdb9eab2 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Sun, 6 Jul 2025 14:52:10 +0300
Subject: Include enum variants in world symbols

I opted to not include enum variant imports, only under the enum, and to not gate this behind a setting.
---
 src/tools/rust-analyzer/crates/hir/src/symbols.rs  |  7 +++
 .../src/test_data/test_symbol_index_collection.txt | 68 ++++++++++++++++++++++
 2 files changed, 75 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/hir/src/symbols.rs b/src/tools/rust-analyzer/crates/hir/src/symbols.rs
index 756650891d4..dca10193e29 100644
--- a/src/tools/rust-analyzer/crates/hir/src/symbols.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/symbols.rs
@@ -125,6 +125,13 @@ impl<'a> SymbolCollector<'a> {
                 }
                 ModuleDefId::AdtId(AdtId::EnumId(id)) => {
                     this.push_decl(id, name, false, None);
+                    let enum_name = this.db.enum_signature(id).name.as_str().to_smolstr();
+                    this.with_container_name(Some(enum_name), |this| {
+                        let variants = id.enum_variants(this.db);
+                        for (variant_id, variant_name, _) in &variants.variants {
+                            this.push_decl(*variant_id, variant_name, true, None);
+                        }
+                    });
                 }
                 ModuleDefId::AdtId(AdtId::UnionId(id)) => {
                     this.push_decl(id, name, false, None);
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 de046e70c67..973256c470f 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
@@ -10,6 +10,40 @@
             },
         },
         [
+            FileSymbol {
+                name: "A",
+                def: Variant(
+                    Variant {
+                        id: EnumVariantId(
+                            7800,
+                        ),
+                    },
+                ),
+                loc: DeclarationLocation {
+                    hir_file_id: FileId(
+                        EditionedFileId(
+                            Id(2000),
+                        ),
+                    ),
+                    ptr: SyntaxNodePtr {
+                        kind: VARIANT,
+                        range: 201..202,
+                    },
+                    name_ptr: AstPtr(
+                        SyntaxNodePtr {
+                            kind: NAME,
+                            range: 201..202,
+                        },
+                    ),
+                },
+                container_name: Some(
+                    "Enum",
+                ),
+                is_alias: false,
+                is_assoc: true,
+                is_import: false,
+                do_not_complete: Yes,
+            },
             FileSymbol {
                 name: "Alias",
                 def: TypeAlias(
@@ -42,6 +76,40 @@
                 is_import: false,
                 do_not_complete: Yes,
             },
+            FileSymbol {
+                name: "B",
+                def: Variant(
+                    Variant {
+                        id: EnumVariantId(
+                            7801,
+                        ),
+                    },
+                ),
+                loc: DeclarationLocation {
+                    hir_file_id: FileId(
+                        EditionedFileId(
+                            Id(2000),
+                        ),
+                    ),
+                    ptr: SyntaxNodePtr {
+                        kind: VARIANT,
+                        range: 204..205,
+                    },
+                    name_ptr: AstPtr(
+                        SyntaxNodePtr {
+                            kind: NAME,
+                            range: 204..205,
+                        },
+                    ),
+                },
+                container_name: Some(
+                    "Enum",
+                ),
+                is_alias: false,
+                is_assoc: true,
+                is_import: false,
+                do_not_complete: Yes,
+            },
             FileSymbol {
                 name: "CONST",
                 def: Const(
-- 
cgit 1.4.1-3-g733a5


From e40f8b26ada6f517235fd5813231adbb79e58ced Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 6 Jul 2025 16:51:14 +0200
Subject: rename panic_paylods → unwind_payloads
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/tools/miri/src/concurrency/thread.rs | 10 +++++-----
 src/tools/miri/src/shims/panic.rs        |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/tools/miri/src/concurrency/thread.rs b/src/tools/miri/src/concurrency/thread.rs
index 56c19794854..ec65ea685e1 100644
--- a/src/tools/miri/src/concurrency/thread.rs
+++ b/src/tools/miri/src/concurrency/thread.rs
@@ -186,15 +186,15 @@ pub struct Thread<'tcx> {
     /// The join status.
     join_status: ThreadJoinStatus,
 
-    /// Stack of active panic payloads for the current thread. Used for storing
-    /// the argument of the call to `miri_start_unwind` (the panic payload) when unwinding.
+    /// Stack of active unwind payloads for the current thread. Used for storing
+    /// the argument of the call to `miri_start_unwind` (the payload) when unwinding.
     /// This is pointer-sized, and matches the `Payload` type in `src/libpanic_unwind/miri.rs`.
     ///
     /// In real unwinding, the payload gets passed as an argument to the landing pad,
     /// which then forwards it to 'Resume'. However this argument is implicit in MIR,
     /// so we have to store it out-of-band. When there are multiple active unwinds,
     /// the innermost one is always caught first, so we can store them as a stack.
-    pub(crate) panic_payloads: Vec<ImmTy<'tcx>>,
+    pub(crate) unwind_payloads: Vec<ImmTy<'tcx>>,
 
     /// Last OS error location in memory. It is a 32-bit integer.
     pub(crate) last_error: Option<MPlaceTy<'tcx>>,
@@ -282,7 +282,7 @@ impl<'tcx> Thread<'tcx> {
             stack: Vec::new(),
             top_user_relevant_frame: None,
             join_status: ThreadJoinStatus::Joinable,
-            panic_payloads: Vec::new(),
+            unwind_payloads: Vec::new(),
             last_error: None,
             on_stack_empty,
         }
@@ -292,7 +292,7 @@ impl<'tcx> Thread<'tcx> {
 impl VisitProvenance for Thread<'_> {
     fn visit_provenance(&self, visit: &mut VisitWith<'_>) {
         let Thread {
-            panic_payloads: panic_payload,
+            unwind_payloads: panic_payload,
             last_error,
             stack,
             top_user_relevant_frame: _,
diff --git a/src/tools/miri/src/shims/panic.rs b/src/tools/miri/src/shims/panic.rs
index a6bce830149..b3b7b6ae718 100644
--- a/src/tools/miri/src/shims/panic.rs
+++ b/src/tools/miri/src/shims/panic.rs
@@ -51,7 +51,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         let payload = this.read_immediate(payload)?;
         let thread = this.active_thread_mut();
-        thread.panic_payloads.push(payload);
+        thread.unwind_payloads.push(payload);
 
         interp_ok(())
     }
@@ -132,7 +132,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
             // The Thread's `panic_payload` holds what was passed to `miri_start_unwind`.
             // This is exactly the second argument we need to pass to `catch_fn`.
-            let payload = this.active_thread_mut().panic_payloads.pop().unwrap();
+            let payload = this.active_thread_mut().unwind_payloads.pop().unwrap();
 
             // Push the `catch_fn` stackframe.
             let f_instance = this.get_ptr_fn(catch_unwind.catch_fn)?.as_instance()?;
-- 
cgit 1.4.1-3-g733a5


From b63f920ccf6e148547aea4c0fd045c4536aac483 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 6 Jul 2025 17:30:09 +0000
Subject: More carefully consider span context when suggesting remove &mut

---
 .../src/error_reporting/traits/suggestions.rs      | 13 ++++++++-----
 tests/ui/suggestions/suggest-remove-refs-6.rs      | 12 ++++++++++++
 tests/ui/suggestions/suggest-remove-refs-6.stderr  | 22 ++++++++++++++++++++++
 3 files changed, 42 insertions(+), 5 deletions(-)
 create mode 100644 tests/ui/suggestions/suggest-remove-refs-6.rs
 create mode 100644 tests/ui/suggestions/suggest-remove-refs-6.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 362052e9fdb..1dc1588842f 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -1511,12 +1511,15 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         'outer: loop {
             while let hir::ExprKind::AddrOf(_, _, borrowed) = expr.kind {
                 count += 1;
-                let span = if expr.span.eq_ctxt(borrowed.span) {
-                    expr.span.until(borrowed.span)
-                } else {
-                    expr.span.with_hi(expr.span.lo() + BytePos(1))
-                };
+                let span =
+                    if let Some(borrowed_span) = borrowed.span.find_ancestor_inside(expr.span) {
+                        expr.span.until(borrowed_span)
+                    } else {
+                        break 'outer;
+                    };
 
+                // Double check that the span we extracted actually corresponds to a borrow,
+                // rather than some macro garbage.
                 match self.tcx.sess.source_map().span_to_snippet(span) {
                     Ok(snippet) if snippet.starts_with("&") => {}
                     _ => break 'outer,
diff --git a/tests/ui/suggestions/suggest-remove-refs-6.rs b/tests/ui/suggestions/suggest-remove-refs-6.rs
new file mode 100644
index 00000000000..0d06aed4806
--- /dev/null
+++ b/tests/ui/suggestions/suggest-remove-refs-6.rs
@@ -0,0 +1,12 @@
+// Regression test for #143523.
+
+trait Trait {}
+
+impl Trait for Vec<i32> {}
+
+fn foo(_: impl Trait) {}
+
+fn main() {
+    foo(&mut vec![1]);
+    //~^ ERROR the trait bound `&mut Vec<{integer}>: Trait` is not satisfied
+}
diff --git a/tests/ui/suggestions/suggest-remove-refs-6.stderr b/tests/ui/suggestions/suggest-remove-refs-6.stderr
new file mode 100644
index 00000000000..bdc5a8a9049
--- /dev/null
+++ b/tests/ui/suggestions/suggest-remove-refs-6.stderr
@@ -0,0 +1,22 @@
+error[E0277]: the trait bound `&mut Vec<{integer}>: Trait` is not satisfied
+  --> $DIR/suggest-remove-refs-6.rs:10:9
+   |
+LL |     foo(&mut vec![1]);
+   |     --- ^^^^^^^^^^^^ the trait `Trait` is not implemented for `&mut Vec<{integer}>`
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: required by a bound in `foo`
+  --> $DIR/suggest-remove-refs-6.rs:7:16
+   |
+LL | fn foo(_: impl Trait) {}
+   |                ^^^^^ required by this bound in `foo`
+help: consider removing the leading `&`-reference
+   |
+LL -     foo(&mut vec![1]);
+LL +     foo(vec![1]);
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From d8ba94b0ae59b9e140f65bce27527c12357bfbf7 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Fri, 4 Jul 2025 00:11:38 +0200
Subject: Fix `manual_is_variant_and` condition generation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When comparing `x.map(func) == Some(bool_lit)`, the value of `bool_lit` was
ignored, despite the fact that its value should determine the value of
the proposed expression.

`func` can be either a closure or a path. For the latter, η-expansion
will be used if needed to invert the result of the function call.
---
 clippy_lints/src/methods/manual_is_variant_and.rs | 168 +++++++++++++++++-----
 tests/ui/manual_is_variant_and.fixed              | 112 ++++++++++++++-
 tests/ui/manual_is_variant_and.rs                 | 110 ++++++++++++++
 tests/ui/manual_is_variant_and.stderr             | 100 ++++++++++++-
 4 files changed, 454 insertions(+), 36 deletions(-)

diff --git a/clippy_lints/src/methods/manual_is_variant_and.rs b/clippy_lints/src/methods/manual_is_variant_and.rs
index 4a61c223d2c..93325ca488e 100644
--- a/clippy_lints/src/methods/manual_is_variant_and.rs
+++ b/clippy_lints/src/methods/manual_is_variant_and.rs
@@ -1,14 +1,16 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::get_parent_expr;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::{snippet, snippet_opt};
+use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{get_parent_expr, sym};
+use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
-use rustc_hir::{BinOpKind, Expr, ExprKind, QPath};
+use rustc_hir::{BinOpKind, Closure, Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::{BytePos, Span, sym};
+use rustc_span::{Span, Symbol};
 
 use super::MANUAL_IS_VARIANT_AND;
 
@@ -62,54 +64,154 @@ pub(super) fn check(
     );
 }
 
-fn emit_lint(cx: &LateContext<'_>, op: BinOpKind, parent: &Expr<'_>, method_span: Span, is_option: bool) {
-    if let Some(before_map_snippet) = snippet_opt(cx, parent.span.with_hi(method_span.lo()))
-        && let Some(after_map_snippet) = snippet_opt(cx, method_span.with_lo(method_span.lo() + BytePos(3)))
-    {
-        span_lint_and_sugg(
-            cx,
-            MANUAL_IS_VARIANT_AND,
-            parent.span,
-            format!(
-                "called `.map() {}= {}()`",
-                if op == BinOpKind::Eq { '=' } else { '!' },
-                if is_option { "Some" } else { "Ok" },
-            ),
-            "use",
-            if is_option && op == BinOpKind::Ne {
-                format!("{before_map_snippet}is_none_or{after_map_snippet}",)
-            } else {
+#[derive(Clone, Copy, PartialEq)]
+enum Flavor {
+    Option,
+    Result,
+}
+
+impl Flavor {
+    const fn symbol(self) -> Symbol {
+        match self {
+            Self::Option => sym::Option,
+            Self::Result => sym::Result,
+        }
+    }
+
+    const fn positive(self) -> Symbol {
+        match self {
+            Self::Option => sym::Some,
+            Self::Result => sym::Ok,
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq)]
+enum Op {
+    Eq,
+    Ne,
+}
+
+impl std::fmt::Display for Op {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Eq => write!(f, "=="),
+            Self::Ne => write!(f, "!="),
+        }
+    }
+}
+
+impl TryFrom<BinOpKind> for Op {
+    type Error = ();
+    fn try_from(op: BinOpKind) -> Result<Self, Self::Error> {
+        match op {
+            BinOpKind::Eq => Ok(Self::Eq),
+            BinOpKind::Ne => Ok(Self::Ne),
+            _ => Err(()),
+        }
+    }
+}
+
+/// Represents the argument of the `.map()` function, as a closure or as a path
+/// in case η-reduction is used.
+enum MapFunc<'hir> {
+    Closure(&'hir Closure<'hir>),
+    Path(&'hir Expr<'hir>),
+}
+
+impl<'hir> TryFrom<&'hir Expr<'hir>> for MapFunc<'hir> {
+    type Error = ();
+
+    fn try_from(expr: &'hir Expr<'hir>) -> Result<Self, Self::Error> {
+        match expr.kind {
+            ExprKind::Closure(closure) => Ok(Self::Closure(closure)),
+            ExprKind::Path(_) => Ok(Self::Path(expr)),
+            _ => Err(()),
+        }
+    }
+}
+
+impl<'hir> MapFunc<'hir> {
+    /// Build a suggestion suitable for use in a `.map()`-like function. η-expansion will be applied
+    /// as needed.
+    fn sugg(self, cx: &LateContext<'hir>, invert: bool, app: &mut Applicability) -> String {
+        match self {
+            Self::Closure(closure) => {
+                let body = Sugg::hir_with_applicability(cx, cx.tcx.hir_body(closure.body).value, "..", app);
                 format!(
-                    "{}{before_map_snippet}{}{after_map_snippet}",
-                    if op == BinOpKind::Eq { "" } else { "!" },
-                    if is_option { "is_some_and" } else { "is_ok_and" },
+                    "{} {}",
+                    snippet_with_applicability(cx, closure.fn_decl_span, "|..|", app),
+                    if invert { !body } else { body }
                 )
             },
-            Applicability::MachineApplicable,
-        );
+            Self::Path(expr) => {
+                let path = snippet_with_applicability(cx, expr.span, "_", app);
+                if invert {
+                    format!("|x| !{path}(x)")
+                } else {
+                    path.to_string()
+                }
+            },
+        }
     }
 }
 
+fn emit_lint<'tcx>(
+    cx: &LateContext<'tcx>,
+    span: Span,
+    op: Op,
+    flavor: Flavor,
+    in_some_or_ok: bool,
+    map_func: MapFunc<'tcx>,
+    recv: &Expr<'_>,
+) {
+    let mut app = Applicability::MachineApplicable;
+    let recv = snippet_with_applicability(cx, recv.span, "_", &mut app);
+
+    let (invert_expr, method, invert_body) = match (flavor, op) {
+        (Flavor::Option, Op::Eq) => (false, "is_some_and", !in_some_or_ok),
+        (Flavor::Option, Op::Ne) => (false, "is_none_or", in_some_or_ok),
+        (Flavor::Result, Op::Eq) => (false, "is_ok_and", !in_some_or_ok),
+        (Flavor::Result, Op::Ne) => (true, "is_ok_and", !in_some_or_ok),
+    };
+    span_lint_and_sugg(
+        cx,
+        MANUAL_IS_VARIANT_AND,
+        span,
+        format!("called `.map() {op} {pos}()`", pos = flavor.positive(),),
+        "use",
+        format!(
+            "{inversion}{recv}.{method}({body})",
+            inversion = if invert_expr { "!" } else { "" },
+            body = map_func.sugg(cx, invert_body, &mut app),
+        ),
+        app,
+    );
+}
+
 pub(super) fn check_map(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if let Some(parent_expr) = get_parent_expr(cx, expr)
         && let ExprKind::Binary(op, left, right) = parent_expr.kind
-        && matches!(op.node, BinOpKind::Eq | BinOpKind::Ne)
         && op.span.eq_ctxt(expr.span)
+        && let Ok(op) = Op::try_from(op.node)
     {
         // Check `left` and `right` expression in any order, and for `Option` and `Result`
         for (expr1, expr2) in [(left, right), (right, left)] {
-            for item in [sym::Option, sym::Result] {
-                if let ExprKind::Call(call, ..) = expr1.kind
+            for flavor in [Flavor::Option, Flavor::Result] {
+                if let ExprKind::Call(call, [arg]) = expr1.kind
+                    && let ExprKind::Lit(lit) = arg.kind
+                    && let LitKind::Bool(bool_cst) = lit.node
                     && let ExprKind::Path(QPath::Resolved(_, path)) = call.kind
                     && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), _) = path.res
                     && let ty = cx.typeck_results().expr_ty(expr1)
                     && let ty::Adt(adt, args) = ty.kind()
-                    && cx.tcx.is_diagnostic_item(item, adt.did())
+                    && cx.tcx.is_diagnostic_item(flavor.symbol(), adt.did())
                     && args.type_at(0).is_bool()
-                    && let ExprKind::MethodCall(_, recv, _, span) = expr2.kind
-                    && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), item)
+                    && let ExprKind::MethodCall(_, recv, [map_expr], _) = expr2.kind
+                    && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), flavor.symbol())
+                    && let Ok(map_func) = MapFunc::try_from(map_expr)
                 {
-                    return emit_lint(cx, op.node, parent_expr, span, item == sym::Option);
+                    return emit_lint(cx, parent_expr.span, op, flavor, bool_cst, map_func, recv);
                 }
             }
         }
diff --git a/tests/ui/manual_is_variant_and.fixed b/tests/ui/manual_is_variant_and.fixed
index 6425f32c09c..65a9cfa6e64 100644
--- a/tests/ui/manual_is_variant_and.fixed
+++ b/tests/ui/manual_is_variant_and.fixed
@@ -61,7 +61,7 @@ fn option_methods() {
 
     let _ = Some(2).is_some_and(|x| x % 2 == 0);
     //~^ manual_is_variant_and
-    let _ = Some(2).is_none_or(|x| x % 2 == 0);
+    let _ = Some(2).is_none_or(|x| x % 2 != 0);
     //~^ manual_is_variant_and
     let _ = Some(2).is_some_and(|x| x % 2 == 0);
     //~^ manual_is_variant_and
@@ -116,3 +116,113 @@ fn main() {
     option_methods();
     result_methods();
 }
+
+fn issue15202() {
+    let xs = [None, Some(b'_'), Some(b'1')];
+    for x in xs {
+        let a1 = x.is_none_or(|b| !b.is_ascii_digit());
+        //~^ manual_is_variant_and
+        let a2 = x.is_none_or(|b| !b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = x.is_none_or(|b| b.is_ascii_digit());
+        //~^ manual_is_variant_and
+        let a2 = x.is_none_or(|b| b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = x.is_some_and(|b| b.is_ascii_digit());
+        //~^ manual_is_variant_and
+        let a2 = x.is_some_and(|b| b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = x.is_some_and(|b| !b.is_ascii_digit());
+        //~^ manual_is_variant_and
+        let a2 = x.is_some_and(|b| !b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    let xs = [Err("foo"), Ok(b'_'), Ok(b'1')];
+    for x in xs {
+        let a1 = !x.is_ok_and(|b| b.is_ascii_digit());
+        //~^ manual_is_variant_and
+        let a2 = !x.is_ok_and(|b| b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = !x.is_ok_and(|b| !b.is_ascii_digit());
+        //~^ manual_is_variant_and
+        let a2 = !x.is_ok_and(|b| !b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = x.is_ok_and(|b| b.is_ascii_digit());
+        //~^ manual_is_variant_and
+        let a2 = x.is_ok_and(|b| b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = x.is_ok_and(|b| !b.is_ascii_digit());
+        //~^ manual_is_variant_and
+        let a2 = x.is_ok_and(|b| !b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+}
+
+mod with_func {
+    fn iad(b: u8) -> bool {
+        b.is_ascii_digit()
+    }
+
+    fn check_option(b: Option<u8>) {
+        let a1 = b.is_some_and(iad);
+        //~^ manual_is_variant_and
+        let a2 = b.is_some_and(iad);
+        assert_eq!(a1, a2);
+
+        let a1 = b.is_some_and(|x| !iad(x));
+        //~^ manual_is_variant_and
+        let a2 = b.is_some_and(|x| !iad(x));
+        assert_eq!(a1, a2);
+
+        let a1 = b.is_none_or(|x| !iad(x));
+        //~^ manual_is_variant_and
+        let a2 = b.is_none_or(|x| !iad(x));
+        assert_eq!(a1, a2);
+
+        let a1 = b.is_none_or(iad);
+        //~^ manual_is_variant_and
+        let a2 = b.is_none_or(iad);
+        assert_eq!(a1, a2);
+    }
+
+    fn check_result(b: Result<u8, ()>) {
+        let a1 = b.is_ok_and(iad);
+        //~^ manual_is_variant_and
+        let a2 = b.is_ok_and(iad);
+        assert_eq!(a1, a2);
+
+        let a1 = b.is_ok_and(|x| !iad(x));
+        //~^ manual_is_variant_and
+        let a2 = b.is_ok_and(|x| !iad(x));
+        assert_eq!(a1, a2);
+
+        let a1 = !b.is_ok_and(iad);
+        //~^ manual_is_variant_and
+        let a2 = !b.is_ok_and(iad);
+        assert_eq!(a1, a2);
+
+        let a1 = !b.is_ok_and(|x| !iad(x));
+        //~^ manual_is_variant_and
+        let a2 = !b.is_ok_and(|x| !iad(x));
+        assert_eq!(a1, a2);
+    }
+}
diff --git a/tests/ui/manual_is_variant_and.rs b/tests/ui/manual_is_variant_and.rs
index e069e97a04d..85b45d654a7 100644
--- a/tests/ui/manual_is_variant_and.rs
+++ b/tests/ui/manual_is_variant_and.rs
@@ -125,3 +125,113 @@ fn main() {
     option_methods();
     result_methods();
 }
+
+fn issue15202() {
+    let xs = [None, Some(b'_'), Some(b'1')];
+    for x in xs {
+        let a1 = x.map(|b| b.is_ascii_digit()) != Some(true);
+        //~^ manual_is_variant_and
+        let a2 = x.is_none_or(|b| !b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = x.map(|b| b.is_ascii_digit()) != Some(false);
+        //~^ manual_is_variant_and
+        let a2 = x.is_none_or(|b| b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = x.map(|b| b.is_ascii_digit()) == Some(true);
+        //~^ manual_is_variant_and
+        let a2 = x.is_some_and(|b| b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = x.map(|b| b.is_ascii_digit()) == Some(false);
+        //~^ manual_is_variant_and
+        let a2 = x.is_some_and(|b| !b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    let xs = [Err("foo"), Ok(b'_'), Ok(b'1')];
+    for x in xs {
+        let a1 = x.map(|b| b.is_ascii_digit()) != Ok(true);
+        //~^ manual_is_variant_and
+        let a2 = !x.is_ok_and(|b| b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = x.map(|b| b.is_ascii_digit()) != Ok(false);
+        //~^ manual_is_variant_and
+        let a2 = !x.is_ok_and(|b| !b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = x.map(|b| b.is_ascii_digit()) == Ok(true);
+        //~^ manual_is_variant_and
+        let a2 = x.is_ok_and(|b| b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+
+    for x in xs {
+        let a1 = x.map(|b| b.is_ascii_digit()) == Ok(false);
+        //~^ manual_is_variant_and
+        let a2 = x.is_ok_and(|b| !b.is_ascii_digit());
+        assert_eq!(a1, a2);
+    }
+}
+
+mod with_func {
+    fn iad(b: u8) -> bool {
+        b.is_ascii_digit()
+    }
+
+    fn check_option(b: Option<u8>) {
+        let a1 = b.map(iad) == Some(true);
+        //~^ manual_is_variant_and
+        let a2 = b.is_some_and(iad);
+        assert_eq!(a1, a2);
+
+        let a1 = b.map(iad) == Some(false);
+        //~^ manual_is_variant_and
+        let a2 = b.is_some_and(|x| !iad(x));
+        assert_eq!(a1, a2);
+
+        let a1 = b.map(iad) != Some(true);
+        //~^ manual_is_variant_and
+        let a2 = b.is_none_or(|x| !iad(x));
+        assert_eq!(a1, a2);
+
+        let a1 = b.map(iad) != Some(false);
+        //~^ manual_is_variant_and
+        let a2 = b.is_none_or(iad);
+        assert_eq!(a1, a2);
+    }
+
+    fn check_result(b: Result<u8, ()>) {
+        let a1 = b.map(iad) == Ok(true);
+        //~^ manual_is_variant_and
+        let a2 = b.is_ok_and(iad);
+        assert_eq!(a1, a2);
+
+        let a1 = b.map(iad) == Ok(false);
+        //~^ manual_is_variant_and
+        let a2 = b.is_ok_and(|x| !iad(x));
+        assert_eq!(a1, a2);
+
+        let a1 = b.map(iad) != Ok(true);
+        //~^ manual_is_variant_and
+        let a2 = !b.is_ok_and(iad);
+        assert_eq!(a1, a2);
+
+        let a1 = b.map(iad) != Ok(false);
+        //~^ manual_is_variant_and
+        let a2 = !b.is_ok_and(|x| !iad(x));
+        assert_eq!(a1, a2);
+    }
+}
diff --git a/tests/ui/manual_is_variant_and.stderr b/tests/ui/manual_is_variant_and.stderr
index f770319a268..da36b5a07d2 100644
--- a/tests/ui/manual_is_variant_and.stderr
+++ b/tests/ui/manual_is_variant_and.stderr
@@ -54,7 +54,7 @@ error: called `.map() != Some()`
   --> tests/ui/manual_is_variant_and.rs:70:13
    |
 LL |     let _ = Some(2).map(|x| x % 2 == 0) != Some(true);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `Some(2).is_none_or(|x| x % 2 == 0)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `Some(2).is_none_or(|x| x % 2 != 0)`
 
 error: called `.map() == Some()`
   --> tests/ui/manual_is_variant_and.rs:72:13
@@ -126,5 +126,101 @@ error: called `map(<f>).unwrap_or_default()` on a `Result` value
 LL |     let _ = res2.map(char::is_alphanumeric).unwrap_or_default(); // should lint
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `is_ok_and(char::is_alphanumeric)`
 
-error: aborting due to 15 previous errors
+error: called `.map() != Some()`
+  --> tests/ui/manual_is_variant_and.rs:132:18
+   |
+LL |         let a1 = x.map(|b| b.is_ascii_digit()) != Some(true);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `x.is_none_or(|b| !b.is_ascii_digit())`
+
+error: called `.map() != Some()`
+  --> tests/ui/manual_is_variant_and.rs:139:18
+   |
+LL |         let a1 = x.map(|b| b.is_ascii_digit()) != Some(false);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `x.is_none_or(|b| b.is_ascii_digit())`
+
+error: called `.map() == Some()`
+  --> tests/ui/manual_is_variant_and.rs:146:18
+   |
+LL |         let a1 = x.map(|b| b.is_ascii_digit()) == Some(true);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `x.is_some_and(|b| b.is_ascii_digit())`
+
+error: called `.map() == Some()`
+  --> tests/ui/manual_is_variant_and.rs:153:18
+   |
+LL |         let a1 = x.map(|b| b.is_ascii_digit()) == Some(false);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `x.is_some_and(|b| !b.is_ascii_digit())`
+
+error: called `.map() != Ok()`
+  --> tests/ui/manual_is_variant_and.rs:161:18
+   |
+LL |         let a1 = x.map(|b| b.is_ascii_digit()) != Ok(true);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `!x.is_ok_and(|b| b.is_ascii_digit())`
+
+error: called `.map() != Ok()`
+  --> tests/ui/manual_is_variant_and.rs:168:18
+   |
+LL |         let a1 = x.map(|b| b.is_ascii_digit()) != Ok(false);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `!x.is_ok_and(|b| !b.is_ascii_digit())`
+
+error: called `.map() == Ok()`
+  --> tests/ui/manual_is_variant_and.rs:175:18
+   |
+LL |         let a1 = x.map(|b| b.is_ascii_digit()) == Ok(true);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `x.is_ok_and(|b| b.is_ascii_digit())`
+
+error: called `.map() == Ok()`
+  --> tests/ui/manual_is_variant_and.rs:182:18
+   |
+LL |         let a1 = x.map(|b| b.is_ascii_digit()) == Ok(false);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `x.is_ok_and(|b| !b.is_ascii_digit())`
+
+error: called `.map() == Some()`
+  --> tests/ui/manual_is_variant_and.rs:195:18
+   |
+LL |         let a1 = b.map(iad) == Some(true);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `b.is_some_and(iad)`
+
+error: called `.map() == Some()`
+  --> tests/ui/manual_is_variant_and.rs:200:18
+   |
+LL |         let a1 = b.map(iad) == Some(false);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `b.is_some_and(|x| !iad(x))`
+
+error: called `.map() != Some()`
+  --> tests/ui/manual_is_variant_and.rs:205:18
+   |
+LL |         let a1 = b.map(iad) != Some(true);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `b.is_none_or(|x| !iad(x))`
+
+error: called `.map() != Some()`
+  --> tests/ui/manual_is_variant_and.rs:210:18
+   |
+LL |         let a1 = b.map(iad) != Some(false);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `b.is_none_or(iad)`
+
+error: called `.map() == Ok()`
+  --> tests/ui/manual_is_variant_and.rs:217:18
+   |
+LL |         let a1 = b.map(iad) == Ok(true);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^ help: use: `b.is_ok_and(iad)`
+
+error: called `.map() == Ok()`
+  --> tests/ui/manual_is_variant_and.rs:222:18
+   |
+LL |         let a1 = b.map(iad) == Ok(false);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^ help: use: `b.is_ok_and(|x| !iad(x))`
+
+error: called `.map() != Ok()`
+  --> tests/ui/manual_is_variant_and.rs:227:18
+   |
+LL |         let a1 = b.map(iad) != Ok(true);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^ help: use: `!b.is_ok_and(iad)`
+
+error: called `.map() != Ok()`
+  --> tests/ui/manual_is_variant_and.rs:232:18
+   |
+LL |         let a1 = b.map(iad) != Ok(false);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^ help: use: `!b.is_ok_and(|x| !iad(x))`
+
+error: aborting due to 31 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 491c8feaabff3c941a30d02c0c2a2622acf257e3 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Sun, 6 Jul 2025 13:30:42 -0700
Subject: clippy: migrate BareFn -> FnPtr

---
 clippy_lints/src/dereference.rs           |  2 +-
 clippy_lints/src/lifetimes.rs             |  4 ++--
 clippy_lints/src/types/type_complexity.rs |  2 +-
 clippy_utils/src/ast_utils/mod.rs         |  2 +-
 clippy_utils/src/check_proc_macro.rs      | 10 +++++-----
 clippy_utils/src/hir_utils.rs             | 14 +++++++-------
 6 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 7463d7b5c3b..5099df3fa02 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -824,7 +824,7 @@ impl TyCoercionStability {
                 TyKind::Slice(_)
                 | TyKind::Array(..)
                 | TyKind::Ptr(_)
-                | TyKind::BareFn(_)
+                | TyKind::FnPtr(_)
                 | TyKind::Pat(..)
                 | TyKind::Never
                 | TyKind::Tup(_)
diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs
index 8fe0c9d60f9..caf17c10484 100644
--- a/clippy_lints/src/lifetimes.rs
+++ b/clippy_lints/src/lifetimes.rs
@@ -13,7 +13,7 @@ use rustc_hir::intravisit::{
     walk_poly_trait_ref, walk_trait_ref, walk_ty, walk_unambig_ty, walk_where_predicate,
 };
 use rustc_hir::{
-    AmbigArg, BareFnTy, BodyId, FnDecl, FnSig, GenericArg, GenericArgs, GenericBound, GenericParam, GenericParamKind,
+    AmbigArg, BodyId, FnDecl, FnPtrTy, FnSig, GenericArg, GenericArgs, GenericBound, GenericParam, GenericParamKind,
     Generics, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind, Lifetime, LifetimeKind, LifetimeParamKind, Node,
     PolyTraitRef, PredicateOrigin, TraitFn, TraitItem, TraitItemKind, Ty, TyKind, WhereBoundPredicate, WherePredicate,
     WherePredicateKind, lang_items,
@@ -480,7 +480,7 @@ impl<'tcx> Visitor<'tcx> for RefVisitor<'_, 'tcx> {
 
     fn visit_ty(&mut self, ty: &'tcx Ty<'_, AmbigArg>) {
         match ty.kind {
-            TyKind::BareFn(&BareFnTy { decl, .. }) => {
+            TyKind::FnPtr(&FnPtrTy { decl, .. }) => {
                 let mut sub_visitor = RefVisitor::new(self.cx);
                 sub_visitor.visit_fn_decl(decl);
                 self.nested_elision_site_lts.append(&mut sub_visitor.all_lts());
diff --git a/clippy_lints/src/types/type_complexity.rs b/clippy_lints/src/types/type_complexity.rs
index 0704653385f..52c6fda8097 100644
--- a/clippy_lints/src/types/type_complexity.rs
+++ b/clippy_lints/src/types/type_complexity.rs
@@ -50,7 +50,7 @@ impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
             TyKind::Path(..) | TyKind::Slice(..) | TyKind::Tup(..) | TyKind::Array(..) => (10 * self.nest, 1),
 
             // function types bring a lot of overhead
-            TyKind::BareFn(bare) if bare.abi == ExternAbi::Rust => (50 * self.nest, 1),
+            TyKind::FnPtr(fn_ptr) if fn_ptr.abi == ExternAbi::Rust => (50 * self.nest, 1),
 
             TyKind::TraitObject(param_bounds, _) => {
                 let has_lifetime_parameters = param_bounds.iter().any(|bound| {
diff --git a/clippy_utils/src/ast_utils/mod.rs b/clippy_utils/src/ast_utils/mod.rs
index e6396987cc6..42254ec8e92 100644
--- a/clippy_utils/src/ast_utils/mod.rs
+++ b/clippy_utils/src/ast_utils/mod.rs
@@ -838,7 +838,7 @@ pub fn eq_ty(l: &Ty, r: &Ty) -> bool {
         (PinnedRef(ll, l), PinnedRef(rl, r)) => {
             both(ll.as_ref(), rl.as_ref(), |l, r| eq_id(l.ident, r.ident)) && l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty)
         },
-        (BareFn(l), BareFn(r)) => {
+        (FnPtr(l), FnPtr(r)) => {
             l.safety == r.safety
                 && eq_ext(&l.ext, &r.ext)
                 && over(&l.generic_params, &r.generic_params, eq_generic_param)
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 407e92d88fb..ce61fffe0de 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -372,17 +372,17 @@ fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
         TyKind::Slice(..) | TyKind::Array(..) => (Pat::Str("["), Pat::Str("]")),
         TyKind::Ptr(MutTy { ty, .. }) => (Pat::Str("*"), ty_search_pat(ty).1),
         TyKind::Ref(_, MutTy { ty, .. }) => (Pat::Str("&"), ty_search_pat(ty).1),
-        TyKind::BareFn(bare_fn) => (
-            if bare_fn.safety.is_unsafe() {
+        TyKind::FnPtr(fn_ptr) => (
+            if fn_ptr.safety.is_unsafe() {
                 Pat::Str("unsafe")
-            } else if bare_fn.abi != ExternAbi::Rust {
+            } else if fn_ptr.abi != ExternAbi::Rust {
                 Pat::Str("extern")
             } else {
                 Pat::MultiStr(&["fn", "extern"])
             },
-            match bare_fn.decl.output {
+            match fn_ptr.decl.output {
                 FnRetTy::DefaultReturn(_) => {
-                    if let [.., ty] = bare_fn.decl.inputs {
+                    if let [.., ty] = fn_ptr.decl.inputs {
                         ty_search_pat(ty).1
                     } else {
                         Pat::Str("(")
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index c37231d0931..0ca494f16e3 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1283,20 +1283,20 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 self.hash_ty(mut_ty.ty);
                 mut_ty.mutbl.hash(&mut self.s);
             },
-            TyKind::BareFn(bfn) => {
-                bfn.safety.hash(&mut self.s);
-                bfn.abi.hash(&mut self.s);
-                for arg in bfn.decl.inputs {
+            TyKind::FnPtr(fn_ptr) => {
+                fn_ptr.safety.hash(&mut self.s);
+                fn_ptr.abi.hash(&mut self.s);
+                for arg in fn_ptr.decl.inputs {
                     self.hash_ty(arg);
                 }
-                std::mem::discriminant(&bfn.decl.output).hash(&mut self.s);
-                match bfn.decl.output {
+                std::mem::discriminant(&fn_ptr.decl.output).hash(&mut self.s);
+                match fn_ptr.decl.output {
                     FnRetTy::DefaultReturn(_) => {},
                     FnRetTy::Return(ty) => {
                         self.hash_ty(ty);
                     },
                 }
-                bfn.decl.c_variadic.hash(&mut self.s);
+                fn_ptr.decl.c_variadic.hash(&mut self.s);
             },
             TyKind::Tup(ty_list) => {
                 for ty in *ty_list {
-- 
cgit 1.4.1-3-g733a5


From 59af8f36e31165dc2fa5968941a2edad3e1c0025 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Mon, 7 Jul 2025 04:58:18 +0000
Subject: Preparing for merge from rustc

---
 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 0130cf13a45..7ca7acb3fd7 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-733b47ea4b1b86216f14ef56e49440c33933f230
+ca98d4d4b3114116203699c2734805547df86f9a
-- 
cgit 1.4.1-3-g733a5


From ae3b9765f4510362b3e7ce7e1a62841b2cf5887d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 7 Jul 2025 08:18:32 +0200
Subject: split unwinding logic from panic logic

---
 src/tools/miri/src/lib.rs          |   3 +-
 src/tools/miri/src/shims/mod.rs    |   1 +
 src/tools/miri/src/shims/panic.rs  | 152 +----------------------------------
 src/tools/miri/src/shims/unwind.rs | 160 +++++++++++++++++++++++++++++++++++++
 4 files changed, 164 insertions(+), 152 deletions(-)
 create mode 100644 src/tools/miri/src/shims/unwind.rs

diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index c86e33e5185..ca99d69b32d 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -154,9 +154,10 @@ pub use crate::shims::env::{EnvVars, EvalContextExt as _};
 pub use crate::shims::foreign_items::{DynSym, EvalContextExt as _};
 pub use crate::shims::io_error::{EvalContextExt as _, IoError, LibcError};
 pub use crate::shims::os_str::EvalContextExt as _;
-pub use crate::shims::panic::{CatchUnwindData, EvalContextExt as _};
+pub use crate::shims::panic::EvalContextExt as _;
 pub use crate::shims::time::EvalContextExt as _;
 pub use crate::shims::tls::TlsData;
+pub use crate::shims::unwind::{CatchUnwindData, EvalContextExt as _};
 
 /// Insert rustc arguments at the beginning of the argument list that Miri wants to be
 /// set per default, for maximal validation power.
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index f09fc546b3e..60c0e289292 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -19,6 +19,7 @@ pub mod os_str;
 pub mod panic;
 pub mod time;
 pub mod tls;
+pub mod unwind;
 
 pub use self::files::FdTable;
 //#[cfg(target_os = "linux")]
diff --git a/src/tools/miri/src/shims/panic.rs b/src/tools/miri/src/shims/panic.rs
index b3b7b6ae718..5fcb783d688 100644
--- a/src/tools/miri/src/shims/panic.rs
+++ b/src/tools/miri/src/shims/panic.rs
@@ -1,162 +1,12 @@
-//! Panic runtime for Miri.
-//!
-//! The core pieces of the runtime are:
-//! - An implementation of `__rust_maybe_catch_panic` that pushes the invoked stack frame with
-//!   some extra metadata derived from the panic-catching arguments of `__rust_maybe_catch_panic`.
-//! - A hack in `libpanic_unwind` that calls the `miri_start_unwind` intrinsic instead of the
-//!   target-native panic runtime. (This lives in the rustc repo.)
-//! - An implementation of `miri_start_unwind` that stores its argument (the panic payload), and then
-//!   immediately returns, but on the *unwind* edge (not the normal return edge), thus initiating unwinding.
-//! - A hook executed each time a frame is popped, such that if the frame pushed by `__rust_maybe_catch_panic`
-//!   gets popped *during unwinding*, we take the panic payload and store it according to the extra
-//!   metadata we remembered when pushing said frame.
+//! Helper functions for causing panics.
 
 use rustc_abi::ExternAbi;
 use rustc_middle::{mir, ty};
-use rustc_target::spec::PanicStrategy;
 
-use self::helpers::check_intrinsic_arg_count;
 use crate::*;
 
-/// Holds all of the relevant data for when unwinding hits a `try` frame.
-#[derive(Debug)]
-pub struct CatchUnwindData<'tcx> {
-    /// The `catch_fn` callback to call in case of a panic.
-    catch_fn: Pointer,
-    /// The `data` argument for that callback.
-    data: ImmTy<'tcx>,
-    /// The return place from the original call to `try`.
-    dest: MPlaceTy<'tcx>,
-    /// The return block from the original call to `try`.
-    ret: Option<mir::BasicBlock>,
-}
-
-impl VisitProvenance for CatchUnwindData<'_> {
-    fn visit_provenance(&self, visit: &mut VisitWith<'_>) {
-        let CatchUnwindData { catch_fn, data, dest, ret: _ } = self;
-        catch_fn.visit_provenance(visit);
-        data.visit_provenance(visit);
-        dest.visit_provenance(visit);
-    }
-}
-
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
-    /// Handles the special `miri_start_unwind` intrinsic, which is called
-    /// by libpanic_unwind to delegate the actual unwinding process to Miri.
-    fn handle_miri_start_unwind(&mut self, payload: &OpTy<'tcx>) -> InterpResult<'tcx> {
-        let this = self.eval_context_mut();
-
-        trace!("miri_start_unwind: {:?}", this.frame().instance());
-
-        let payload = this.read_immediate(payload)?;
-        let thread = this.active_thread_mut();
-        thread.unwind_payloads.push(payload);
-
-        interp_ok(())
-    }
-
-    /// Handles the `catch_unwind` intrinsic.
-    fn handle_catch_unwind(
-        &mut self,
-        args: &[OpTy<'tcx>],
-        dest: &MPlaceTy<'tcx>,
-        ret: Option<mir::BasicBlock>,
-    ) -> InterpResult<'tcx> {
-        let this = self.eval_context_mut();
-
-        // Signature:
-        //   fn catch_unwind(try_fn: fn(*mut u8), data: *mut u8, catch_fn: fn(*mut u8, *mut u8)) -> i32
-        // Calls `try_fn` with `data` as argument. If that executes normally, returns 0.
-        // If that unwinds, calls `catch_fn` with the first argument being `data` and
-        // then second argument being a target-dependent `payload` (i.e. it is up to us to define
-        // what that is), and returns 1.
-        // The `payload` is passed (by libstd) to `__rust_panic_cleanup`, which is then expected to
-        // return a `Box<dyn Any + Send + 'static>`.
-        // In Miri, `miri_start_unwind` is passed exactly that type, so we make the `payload` simply
-        // a pointer to `Box<dyn Any + Send + 'static>`.
-
-        // Get all the arguments.
-        let [try_fn, data, catch_fn] = check_intrinsic_arg_count(args)?;
-        let try_fn = this.read_pointer(try_fn)?;
-        let data = this.read_immediate(data)?;
-        let catch_fn = this.read_pointer(catch_fn)?;
-
-        // Now we make a function call, and pass `data` as first and only argument.
-        let f_instance = this.get_ptr_fn(try_fn)?.as_instance()?;
-        trace!("try_fn: {:?}", f_instance);
-        #[allow(clippy::cloned_ref_to_slice_refs)] // the code is clearer as-is
-        this.call_function(
-            f_instance,
-            ExternAbi::Rust,
-            &[data.clone()],
-            None,
-            // Directly return to caller.
-            StackPopCleanup::Goto { ret, unwind: mir::UnwindAction::Continue },
-        )?;
-
-        // We ourselves will return `0`, eventually (will be overwritten if we catch a panic).
-        this.write_null(dest)?;
-
-        // In unwind mode, we tag this frame with the extra data needed to catch unwinding.
-        // This lets `handle_stack_pop` (below) know that we should stop unwinding
-        // when we pop this frame.
-        if this.tcx.sess.panic_strategy() == PanicStrategy::Unwind {
-            this.frame_mut().extra.catch_unwind =
-                Some(CatchUnwindData { catch_fn, data, dest: dest.clone(), ret });
-        }
-
-        interp_ok(())
-    }
-
-    fn handle_stack_pop_unwind(
-        &mut self,
-        mut extra: FrameExtra<'tcx>,
-        unwinding: bool,
-    ) -> InterpResult<'tcx, ReturnAction> {
-        let this = self.eval_context_mut();
-        trace!("handle_stack_pop_unwind(extra = {:?}, unwinding = {})", extra, unwinding);
-
-        // We only care about `catch_panic` if we're unwinding - if we're doing a normal
-        // return, then we don't need to do anything special.
-        if let (true, Some(catch_unwind)) = (unwinding, extra.catch_unwind.take()) {
-            // We've just popped a frame that was pushed by `catch_unwind`,
-            // and we are unwinding, so we should catch that.
-            trace!(
-                "unwinding: found catch_panic frame during unwinding: {:?}",
-                this.frame().instance()
-            );
-
-            // We set the return value of `catch_unwind` to 1, since there was a panic.
-            this.write_scalar(Scalar::from_i32(1), &catch_unwind.dest)?;
-
-            // The Thread's `panic_payload` holds what was passed to `miri_start_unwind`.
-            // This is exactly the second argument we need to pass to `catch_fn`.
-            let payload = this.active_thread_mut().unwind_payloads.pop().unwrap();
-
-            // Push the `catch_fn` stackframe.
-            let f_instance = this.get_ptr_fn(catch_unwind.catch_fn)?.as_instance()?;
-            trace!("catch_fn: {:?}", f_instance);
-            this.call_function(
-                f_instance,
-                ExternAbi::Rust,
-                &[catch_unwind.data, payload],
-                None,
-                // Directly return to caller of `catch_unwind`.
-                StackPopCleanup::Goto {
-                    ret: catch_unwind.ret,
-                    // `catch_fn` must not unwind.
-                    unwind: mir::UnwindAction::Unreachable,
-                },
-            )?;
-
-            // We pushed a new stack frame, the engine should not do any jumping now!
-            interp_ok(ReturnAction::NoJump)
-        } else {
-            interp_ok(ReturnAction::Normal)
-        }
-    }
-
     /// Start a panic in the interpreter with the given message as payload.
     fn start_panic(&mut self, msg: &str, unwind: mir::UnwindAction) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
diff --git a/src/tools/miri/src/shims/unwind.rs b/src/tools/miri/src/shims/unwind.rs
new file mode 100644
index 00000000000..7cbbbb7f4d7
--- /dev/null
+++ b/src/tools/miri/src/shims/unwind.rs
@@ -0,0 +1,160 @@
+//! Unwinding runtime for Miri.
+//!
+//! The core pieces of the runtime are:
+//! - An implementation of `catch_unwind` that pushes the invoked stack frame with
+//!   some extra metadata derived from the panic-catching arguments of `catch_unwind`.
+//! - A hack in `libpanic_unwind` that calls the `miri_start_unwind` intrinsic instead of the
+//!   target-native panic runtime. (This lives in the rustc repo.)
+//! - An implementation of `miri_start_unwind` that stores its argument (the panic payload), and
+//!   then immediately returns, but on the *unwind* edge (not the normal return edge), thus
+//!   initiating unwinding.
+//! - A hook executed each time a frame is popped, such that if the frame pushed by `catch_unwind`
+//!   gets popped *during unwinding*, we take the panic payload and store it according to the extra
+//!   metadata we remembered when pushing said frame.
+
+use rustc_abi::ExternAbi;
+use rustc_middle::mir;
+use rustc_target::spec::PanicStrategy;
+
+use self::helpers::check_intrinsic_arg_count;
+use crate::*;
+
+/// Holds all of the relevant data for when unwinding hits a `try` frame.
+#[derive(Debug)]
+pub struct CatchUnwindData<'tcx> {
+    /// The `catch_fn` callback to call in case of a panic.
+    catch_fn: Pointer,
+    /// The `data` argument for that callback.
+    data: ImmTy<'tcx>,
+    /// The return place from the original call to `try`.
+    dest: MPlaceTy<'tcx>,
+    /// The return block from the original call to `try`.
+    ret: Option<mir::BasicBlock>,
+}
+
+impl VisitProvenance for CatchUnwindData<'_> {
+    fn visit_provenance(&self, visit: &mut VisitWith<'_>) {
+        let CatchUnwindData { catch_fn, data, dest, ret: _ } = self;
+        catch_fn.visit_provenance(visit);
+        data.visit_provenance(visit);
+        dest.visit_provenance(visit);
+    }
+}
+
+impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
+pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
+    /// Handles the special `miri_start_unwind` intrinsic, which is called
+    /// by libpanic_unwind to delegate the actual unwinding process to Miri.
+    fn handle_miri_start_unwind(&mut self, payload: &OpTy<'tcx>) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+
+        trace!("miri_start_unwind: {:?}", this.frame().instance());
+
+        let payload = this.read_immediate(payload)?;
+        let thread = this.active_thread_mut();
+        thread.unwind_payloads.push(payload);
+
+        interp_ok(())
+    }
+
+    /// Handles the `catch_unwind` intrinsic.
+    fn handle_catch_unwind(
+        &mut self,
+        args: &[OpTy<'tcx>],
+        dest: &MPlaceTy<'tcx>,
+        ret: Option<mir::BasicBlock>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+
+        // Signature:
+        //   fn catch_unwind(try_fn: fn(*mut u8), data: *mut u8, catch_fn: fn(*mut u8, *mut u8)) -> i32
+        // Calls `try_fn` with `data` as argument. If that executes normally, returns 0.
+        // If that unwinds, calls `catch_fn` with the first argument being `data` and
+        // then second argument being a target-dependent `payload` (i.e. it is up to us to define
+        // what that is), and returns 1.
+        // The `payload` is passed (by libstd) to `__rust_panic_cleanup`, which is then expected to
+        // return a `Box<dyn Any + Send + 'static>`.
+        // In Miri, `miri_start_unwind` is passed exactly that type, so we make the `payload` simply
+        // a pointer to `Box<dyn Any + Send + 'static>`.
+
+        // Get all the arguments.
+        let [try_fn, data, catch_fn] = check_intrinsic_arg_count(args)?;
+        let try_fn = this.read_pointer(try_fn)?;
+        let data = this.read_immediate(data)?;
+        let catch_fn = this.read_pointer(catch_fn)?;
+
+        // Now we make a function call, and pass `data` as first and only argument.
+        let f_instance = this.get_ptr_fn(try_fn)?.as_instance()?;
+        trace!("try_fn: {:?}", f_instance);
+        #[allow(clippy::cloned_ref_to_slice_refs)] // the code is clearer as-is
+        this.call_function(
+            f_instance,
+            ExternAbi::Rust,
+            &[data.clone()],
+            None,
+            // Directly return to caller.
+            StackPopCleanup::Goto { ret, unwind: mir::UnwindAction::Continue },
+        )?;
+
+        // We ourselves will return `0`, eventually (will be overwritten if we catch a panic).
+        this.write_null(dest)?;
+
+        // In unwind mode, we tag this frame with the extra data needed to catch unwinding.
+        // This lets `handle_stack_pop` (below) know that we should stop unwinding
+        // when we pop this frame.
+        if this.tcx.sess.panic_strategy() == PanicStrategy::Unwind {
+            this.frame_mut().extra.catch_unwind =
+                Some(CatchUnwindData { catch_fn, data, dest: dest.clone(), ret });
+        }
+
+        interp_ok(())
+    }
+
+    fn handle_stack_pop_unwind(
+        &mut self,
+        mut extra: FrameExtra<'tcx>,
+        unwinding: bool,
+    ) -> InterpResult<'tcx, ReturnAction> {
+        let this = self.eval_context_mut();
+        trace!("handle_stack_pop_unwind(extra = {:?}, unwinding = {})", extra, unwinding);
+
+        // We only care about `catch_panic` if we're unwinding - if we're doing a normal
+        // return, then we don't need to do anything special.
+        if let (true, Some(catch_unwind)) = (unwinding, extra.catch_unwind.take()) {
+            // We've just popped a frame that was pushed by `catch_unwind`,
+            // and we are unwinding, so we should catch that.
+            trace!(
+                "unwinding: found catch_panic frame during unwinding: {:?}",
+                this.frame().instance()
+            );
+
+            // We set the return value of `catch_unwind` to 1, since there was a panic.
+            this.write_scalar(Scalar::from_i32(1), &catch_unwind.dest)?;
+
+            // The Thread's `panic_payload` holds what was passed to `miri_start_unwind`.
+            // This is exactly the second argument we need to pass to `catch_fn`.
+            let payload = this.active_thread_mut().unwind_payloads.pop().unwrap();
+
+            // Push the `catch_fn` stackframe.
+            let f_instance = this.get_ptr_fn(catch_unwind.catch_fn)?.as_instance()?;
+            trace!("catch_fn: {:?}", f_instance);
+            this.call_function(
+                f_instance,
+                ExternAbi::Rust,
+                &[catch_unwind.data, payload],
+                None,
+                // Directly return to caller of `catch_unwind`.
+                StackPopCleanup::Goto {
+                    ret: catch_unwind.ret,
+                    // `catch_fn` must not unwind.
+                    unwind: mir::UnwindAction::Unreachable,
+                },
+            )?;
+
+            // We pushed a new stack frame, the engine should not do any jumping now!
+            interp_ok(ReturnAction::NoJump)
+        } else {
+            interp_ok(ReturnAction::Normal)
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From f4e2b5c7f542f441d8bbd0cf7e1fdd9d71952431 Mon Sep 17 00:00:00 2001
From: Edoardo Marangoni <edoardo.marangoni@scisemi.com>
Date: Sun, 29 Jun 2025 12:11:51 +0200
Subject: compiler: Parse `p-` specs in datalayout string, allow definition of
 custom default data address space

---
 clippy_lints/src/casts/fn_to_numeric_cast.rs                 | 2 +-
 clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs | 2 +-
 clippy_lints/src/casts/utils.rs                              | 2 +-
 clippy_lints/src/enum_clike.rs                               | 2 +-
 clippy_utils/src/consts.rs                                   | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/casts/fn_to_numeric_cast.rs b/clippy_lints/src/casts/fn_to_numeric_cast.rs
index 105477093b5..55e27a05f3c 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast.rs
@@ -17,7 +17,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         ty::FnDef(..) | ty::FnPtr(..) => {
             let mut applicability = Applicability::MaybeIncorrect;
 
-            if to_nbits >= cx.tcx.data_layout.pointer_size.bits() && !cast_to.is_usize() {
+            if to_nbits >= cx.tcx.data_layout.pointer_size().bits() && !cast_to.is_usize() {
                 let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
                 span_lint_and_sugg(
                     cx,
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
index 700b7d0d426..4da79205e20 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
@@ -17,7 +17,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
             let mut applicability = Applicability::MaybeIncorrect;
             let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
 
-            if to_nbits < cx.tcx.data_layout.pointer_size.bits() {
+            if to_nbits < cx.tcx.data_layout.pointer_size().bits() {
                 span_lint_and_sugg(
                     cx,
                     FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
diff --git a/clippy_lints/src/casts/utils.rs b/clippy_lints/src/casts/utils.rs
index 318a1646477..d846d78b9ee 100644
--- a/clippy_lints/src/casts/utils.rs
+++ b/clippy_lints/src/casts/utils.rs
@@ -5,7 +5,7 @@ use rustc_middle::ty::{self, AdtDef, IntTy, Ty, TyCtxt, UintTy, VariantDiscr};
 /// integral type.
 pub(super) fn int_ty_to_nbits(tcx: TyCtxt<'_>, ty: Ty<'_>) -> Option<u64> {
     match ty.kind() {
-        ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize) => Some(tcx.data_layout.pointer_size.bits()),
+        ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize) => Some(tcx.data_layout.pointer_size().bits()),
         ty::Int(i) => i.bit_width(),
         ty::Uint(i) => i.bit_width(),
         _ => None,
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index 098571a5351..c828fc57f76 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -35,7 +35,7 @@ declare_lint_pass!(UnportableVariant => [ENUM_CLIKE_UNPORTABLE_VARIANT]);
 impl<'tcx> LateLintPass<'tcx> for UnportableVariant {
     #[expect(clippy::cast_possible_wrap)]
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if cx.tcx.data_layout.pointer_size.bits() != 64 {
+        if cx.tcx.data_layout.pointer_size().bits() != 64 {
             return;
         }
         if let ItemKind::Enum(_, _, def) = &item.kind {
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index 09299c869dc..ba0376e4d40 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -918,7 +918,7 @@ fn mir_is_empty<'tcx>(tcx: TyCtxt<'tcx>, result: mir::Const<'tcx>) -> Option<boo
                     // Get the length from the slice, using the same formula as
                     // [`ConstValue::try_get_slice_bytes_for_diagnostics`].
                     let a = tcx.global_alloc(alloc_id).unwrap_memory().inner();
-                    let ptr_size = tcx.data_layout.pointer_size;
+                    let ptr_size = tcx.data_layout.pointer_size();
                     if a.size() < offset + 2 * ptr_size {
                         // (partially) dangling reference
                         return None;
-- 
cgit 1.4.1-3-g733a5


From 229be21d0d5297a66e7fe6b56606d0549bfccd5f Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Tue, 24 Jun 2025 16:09:42 +0800
Subject: Add ui test unnessary-error-issue-138401.rs

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 .../ui/parser/issues/unnessary-error-issue-138401.rs  |  7 +++++++
 .../parser/issues/unnessary-error-issue-138401.stderr | 19 +++++++++++++++++++
 2 files changed, 26 insertions(+)
 create mode 100644 tests/ui/parser/issues/unnessary-error-issue-138401.rs
 create mode 100644 tests/ui/parser/issues/unnessary-error-issue-138401.stderr

diff --git a/tests/ui/parser/issues/unnessary-error-issue-138401.rs b/tests/ui/parser/issues/unnessary-error-issue-138401.rs
new file mode 100644
index 00000000000..e5e5f1ee4e9
--- /dev/null
+++ b/tests/ui/parser/issues/unnessary-error-issue-138401.rs
@@ -0,0 +1,7 @@
+pub fn foo(x: i64) -> i64 {
+    x.abs) 
+    //~^ ERROR mismatched closing delimiter
+}
+//~^ ERROR unexpected closing delimiter: `}`
+
+fn main() {}
diff --git a/tests/ui/parser/issues/unnessary-error-issue-138401.stderr b/tests/ui/parser/issues/unnessary-error-issue-138401.stderr
new file mode 100644
index 00000000000..b50f77f1247
--- /dev/null
+++ b/tests/ui/parser/issues/unnessary-error-issue-138401.stderr
@@ -0,0 +1,19 @@
+error: mismatched closing delimiter: `)`
+  --> $DIR/unnessary-error-issue-138401.rs:1:27
+   |
+LL | pub fn foo(x: i64) -> i64 {
+   |                           ^ unclosed delimiter
+LL |     x.abs) 
+   |          ^ mismatched closing delimiter
+
+error: unexpected closing delimiter: `}`
+  --> $DIR/unnessary-error-issue-138401.rs:4:1
+   |
+LL |     x.abs) 
+   |          - missing open `(` for this delimiter
+LL |
+LL | }
+   | ^ unexpected closing delimiter
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From bb8b741c32b3b2f32e358b1cfc1111c19cf82306 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Mon, 16 Jun 2025 22:11:41 +0300
Subject: Port `#[export_stable]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs     |  3 +++
 .../rustc_attr_data_structures/src/encode_cross_crate.rs  |  1 +
 compiler/rustc_attr_parsing/src/attributes/link_attrs.rs  | 13 +++++++++++--
 compiler/rustc_attr_parsing/src/context.rs                |  3 ++-
 compiler/rustc_parse/src/validate_attr.rs                 |  1 +
 compiler/rustc_passes/src/check_attr.rs                   |  4 +++-
 compiler/rustc_passes/src/check_export.rs                 |  7 ++++---
 tests/ui/attributes/malformed-attrs.stderr                | 15 +++++++++------
 8 files changed, 34 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 2cbb7270785..8c94bf79dce 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -248,6 +248,9 @@ pub enum AttributeKind {
         span: Span,
     },
 
+    /// Represents `#[export_stable]`.
+    ExportStable,
+
     /// Represents `#[ignore]`
     Ignore {
         span: Span,
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index a6ae49d2808..250cb1f1783 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -26,6 +26,7 @@ impl AttributeKind {
             Deprecation { .. } => Yes,
             DocComment { .. } => Yes,
             ExportName { .. } => Yes,
+            ExportStable => No,
             Ignore { .. } => No,
             Inline(..) => No,
             LinkName { .. } => Yes,
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
index e298053ab76..935002be314 100644
--- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -1,9 +1,11 @@
 use rustc_attr_data_structures::AttributeKind;
 use rustc_attr_data_structures::AttributeKind::{LinkName, LinkSection};
 use rustc_feature::{AttributeTemplate, template};
-use rustc_span::{Symbol, sym};
+use rustc_span::{Span, Symbol, sym};
 
-use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
+use crate::attributes::{
+    AttributeOrder, NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
+};
 use crate::context::{AcceptContext, Stage};
 use crate::parser::ArgParser;
 use crate::session_diagnostics::NullOnLinkSection;
@@ -57,3 +59,10 @@ impl<S: Stage> SingleAttributeParser<S> for LinkSectionParser {
         Some(LinkSection { name, span: cx.attr_span })
     }
 }
+
+pub(crate) struct ExportStableParser;
+impl<S: Stage> NoArgsAttributeParser<S> for ExportStableParser {
+    const PATH: &[Symbol] = &[sym::export_stable];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::ExportStable;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 939f4a6fde7..db66fd5da23 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -22,7 +22,7 @@ use crate::attributes::codegen_attrs::{
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
-use crate::attributes::link_attrs::{LinkNameParser, LinkSectionParser};
+use crate::attributes::link_attrs::{ExportStableParser, LinkNameParser, LinkSectionParser};
 use crate::attributes::lint_helpers::{AsPtrParser, PassByValueParser, PubTransparentParser};
 use crate::attributes::loop_match::{ConstContinueParser, LoopMatchParser};
 use crate::attributes::must_use::MustUseParser;
@@ -145,6 +145,7 @@ attribute_parsers!(
         Single<WithoutArgs<ColdParser>>,
         Single<WithoutArgs<ConstContinueParser>>,
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
+        Single<WithoutArgs<ExportStableParser>>,
         Single<WithoutArgs<LoopMatchParser>>,
         Single<WithoutArgs<MayDangleParser>>,
         Single<WithoutArgs<NoImplicitPreludeParser>>,
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 67b68e77d2b..47432a3b7ff 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -271,6 +271,7 @@ pub fn check_builtin_meta_item(
         if matches!(
             name,
             sym::inline
+                | sym::export_stable
                 | sym::may_dangle
                 | sym::rustc_as_ptr
                 | sym::rustc_pub_transparent
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 9e4e78c1db6..bf8dc06c7b7 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -204,6 +204,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     AttributeKind::RustcLayoutScalarValidRangeStart(_num, attr_span)
                     | AttributeKind::RustcLayoutScalarValidRangeEnd(_num, attr_span),
                 ) => self.check_rustc_layout_scalar_valid_range(*attr_span, span, target),
+                Attribute::Parsed(AttributeKind::ExportStable) => {
+                    // handled in `check_export`
+                }
                 Attribute::Parsed(
                     AttributeKind::BodyStability { .. }
                     | AttributeKind::ConstStabilityIndirect
@@ -346,7 +349,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             | sym::cfg_attr
                             | sym::cfg_trace
                             | sym::cfg_attr_trace
-                            | sym::export_stable // handled in `check_export`
                             // need to be fixed
                             | sym::cfi_encoding // FIXME(cfi_encoding)
                             | sym::pointee // FIXME(derive_coerce_pointee)
diff --git a/compiler/rustc_passes/src/check_export.rs b/compiler/rustc_passes/src/check_export.rs
index f8f489d7d06..b1f4584c2a8 100644
--- a/compiler/rustc_passes/src/check_export.rs
+++ b/compiler/rustc_passes/src/check_export.rs
@@ -2,6 +2,7 @@ use std::iter;
 use std::ops::ControlFlow;
 
 use rustc_abi::ExternAbi;
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
@@ -14,7 +15,7 @@ use rustc_middle::ty::{
     self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor, Visibility,
 };
 use rustc_session::config::CrateType;
-use rustc_span::{Span, sym};
+use rustc_span::Span;
 
 use crate::errors::UnexportableItem;
 
@@ -44,7 +45,7 @@ impl<'tcx> ExportableItemCollector<'tcx> {
     }
 
     fn item_is_exportable(&self, def_id: LocalDefId) -> bool {
-        let has_attr = self.tcx.has_attr(def_id, sym::export_stable);
+        let has_attr = find_attr!(self.tcx.get_all_attrs(def_id), AttributeKind::ExportStable);
         if !self.in_exportable_mod && !has_attr {
             return false;
         }
@@ -80,7 +81,7 @@ impl<'tcx> ExportableItemCollector<'tcx> {
     fn walk_item_with_mod(&mut self, item: &'tcx hir::Item<'tcx>) {
         let def_id = item.hir_id().owner.def_id;
         let old_exportable_mod = self.in_exportable_mod;
-        if self.tcx.get_attr(def_id, sym::export_stable).is_some() {
+        if find_attr!(self.tcx.get_all_attrs(def_id), AttributeKind::ExportStable) {
             self.in_exportable_mod = true;
         }
         let old_seen_exportable_in_mod = std::mem::replace(&mut self.seen_exportable_in_mod, false);
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index 2f7bf50ead5..0b42284f90c 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -40,12 +40,6 @@ error: malformed `crate_name` attribute input
 LL | #[crate_name]
    | ^^^^^^^^^^^^^ help: must be of the form: `#[crate_name = "name"]`
 
-error: malformed `export_stable` attribute input
-  --> $DIR/malformed-attrs.rs:81:1
-   |
-LL | #[export_stable = 1]
-   | ^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[export_stable]`
-
 error: malformed `coverage` attribute input
   --> $DIR/malformed-attrs.rs:90:1
    |
@@ -481,6 +475,15 @@ LL | #[target_feature]
    | expected this to be a list
    | help: must be of the form: `#[target_feature(enable = "feat1, feat2")]`
 
+error[E0565]: malformed `export_stable` attribute input
+  --> $DIR/malformed-attrs.rs:81:1
+   |
+LL | #[export_stable = 1]
+   | ^^^^^^^^^^^^^^^^---^
+   | |               |
+   | |               didn't expect any arguments here
+   | help: must be of the form: `#[export_stable]`
+
 error[E0539]: malformed `link_name` attribute input
   --> $DIR/malformed-attrs.rs:86:1
    |
-- 
cgit 1.4.1-3-g733a5


From 99a9fe1b22edd82697a315e67392bfb35690152d Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 01:00:30 +0300
Subject: Port `#[ffi_const]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs     |  3 +++
 .../rustc_attr_data_structures/src/encode_cross_crate.rs  |  1 +
 compiler/rustc_attr_parsing/src/attributes/link_attrs.rs  |  7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                |  5 ++++-
 compiler/rustc_codegen_ssa/src/codegen_attrs.rs           |  4 +++-
 compiler/rustc_parse/src/validate_attr.rs                 |  1 +
 compiler/rustc_passes/src/check_attr.rs                   |  6 ++++--
 tests/ui/attributes/malformed-attrs.stderr                | 15 +++++++++------
 8 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 8c94bf79dce..4f9ea8be314 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -251,6 +251,9 @@ pub enum AttributeKind {
     /// Represents `#[export_stable]`.
     ExportStable,
 
+    /// Represents `#[ffi_const]`.
+    FfiConst(Span),
+
     /// Represents `#[ignore]`
     Ignore {
         span: Span,
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 250cb1f1783..e69a543d459 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -27,6 +27,7 @@ impl AttributeKind {
             DocComment { .. } => Yes,
             ExportName { .. } => Yes,
             ExportStable => No,
+            FfiConst(..) => No,
             Ignore { .. } => No,
             Inline(..) => No,
             LinkName { .. } => Yes,
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
index 935002be314..74283645a5a 100644
--- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -66,3 +66,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for ExportStableParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::ExportStable;
 }
+
+pub(crate) struct FfiConstParser;
+impl<S: Stage> NoArgsAttributeParser<S> for FfiConstParser {
+    const PATH: &[Symbol] = &[sym::ffi_const];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::FfiConst;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index db66fd5da23..6544278573b 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -22,7 +22,9 @@ use crate::attributes::codegen_attrs::{
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
-use crate::attributes::link_attrs::{ExportStableParser, LinkNameParser, LinkSectionParser};
+use crate::attributes::link_attrs::{
+    ExportStableParser, FfiConstParser, LinkNameParser, LinkSectionParser,
+};
 use crate::attributes::lint_helpers::{AsPtrParser, PassByValueParser, PubTransparentParser};
 use crate::attributes::loop_match::{ConstContinueParser, LoopMatchParser};
 use crate::attributes::must_use::MustUseParser;
@@ -146,6 +148,7 @@ attribute_parsers!(
         Single<WithoutArgs<ConstContinueParser>>,
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
         Single<WithoutArgs<ExportStableParser>>,
+        Single<WithoutArgs<FfiConstParser>>,
         Single<WithoutArgs<LoopMatchParser>>,
         Single<WithoutArgs<MayDangleParser>>,
         Single<WithoutArgs<NoImplicitPreludeParser>>,
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index ff454427871..72bb9e8fac5 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -203,6 +203,9 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                     UsedBy::Compiler => codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED_COMPILER,
                     UsedBy::Linker => codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED_LINKER,
                 },
+                AttributeKind::FfiConst(_) => {
+                    codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_CONST
+                }
                 _ => {}
             }
         }
@@ -214,7 +217,6 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         match name {
             sym::rustc_allocator => codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR,
             sym::ffi_pure => codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_PURE,
-            sym::ffi_const => codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_CONST,
             sym::rustc_nounwind => codegen_fn_attrs.flags |= CodegenFnAttrFlags::NEVER_UNWIND,
             sym::rustc_reallocator => codegen_fn_attrs.flags |= CodegenFnAttrFlags::REALLOCATOR,
             sym::rustc_deallocator => codegen_fn_attrs.flags |= CodegenFnAttrFlags::DEALLOCATOR,
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 47432a3b7ff..ff5bcdce97b 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -272,6 +272,7 @@ pub fn check_builtin_meta_item(
             name,
             sym::inline
                 | sym::export_stable
+                | sym::ffi_const
                 | sym::may_dangle
                 | sym::rustc_as_ptr
                 | sym::rustc_pub_transparent
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index bf8dc06c7b7..8a59b07a4f3 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -207,6 +207,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 Attribute::Parsed(AttributeKind::ExportStable) => {
                     // handled in `check_export`
                 }
+                &Attribute::Parsed(AttributeKind::FfiConst(attr_span)) => {
+                    self.check_ffi_const(attr_span, target)
+                }
                 Attribute::Parsed(
                     AttributeKind::BodyStability { .. }
                     | AttributeKind::ConstStabilityIndirect
@@ -304,7 +307,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             self.check_has_incoherent_inherent_impls(attr, span, target)
                         }
                         [sym::ffi_pure, ..] => self.check_ffi_pure(attr.span(), attrs, target),
-                        [sym::ffi_const, ..] => self.check_ffi_const(attr.span(), target),
                         [sym::link_ordinal, ..] => self.check_link_ordinal(attr, span, target),
                         [sym::link, ..] => self.check_link(hir_id, attr, span, target),
                         [sym::macro_use, ..] | [sym::macro_escape, ..] => {
@@ -1509,7 +1511,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             self.dcx().emit_err(errors::FfiPureInvalidTarget { attr_span });
             return;
         }
-        if attrs.iter().any(|a| a.has_name(sym::ffi_const)) {
+        if find_attr!(attrs, AttributeKind::FfiConst(_)) {
             // `#[ffi_const]` functions cannot be `#[ffi_pure]`
             self.dcx().emit_err(errors::BothFfiConstAndPure { attr_span });
         }
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index 0b42284f90c..908b2ba6314 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -146,12 +146,6 @@ error: malformed `link_ordinal` attribute input
 LL |     #[link_ordinal]
    |     ^^^^^^^^^^^^^^^ help: must be of the form: `#[link_ordinal(ordinal)]`
 
-error: malformed `ffi_const` attribute input
-  --> $DIR/malformed-attrs.rs:171:5
-   |
-LL |     #[unsafe(ffi_const = 1)]
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[ffi_const]`
-
 error: malformed `linkage` attribute input
   --> $DIR/malformed-attrs.rs:173:5
    |
@@ -540,6 +534,15 @@ LL | #[rustc_layout_scalar_valid_range_end]
    | expected this to be a list
    | help: must be of the form: `#[rustc_layout_scalar_valid_range_end(end)]`
 
+error[E0565]: malformed `ffi_const` attribute input
+  --> $DIR/malformed-attrs.rs:171:5
+   |
+LL |     #[unsafe(ffi_const = 1)]
+   |     ^^^^^^^^^^^^^^^^^^^---^^
+   |     |                  |
+   |     |                  didn't expect any arguments here
+   |     help: must be of the form: `#[ffi_const]`
+
 error[E0565]: malformed `non_exhaustive` attribute input
   --> $DIR/malformed-attrs.rs:197:1
    |
-- 
cgit 1.4.1-3-g733a5


From 5d7771e50d1ed3f4174269c78f06691596e632d3 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 01:10:12 +0300
Subject: Port `#[ffi_pure]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs     |  3 +++
 .../rustc_attr_data_structures/src/encode_cross_crate.rs  |  1 +
 compiler/rustc_attr_parsing/src/attributes/link_attrs.rs  |  7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                |  3 ++-
 compiler/rustc_codegen_ssa/src/codegen_attrs.rs           |  2 +-
 compiler/rustc_parse/src/validate_attr.rs                 |  1 +
 compiler/rustc_passes/src/check_attr.rs                   |  4 +++-
 tests/ui/attributes/malformed-attrs.stderr                | 15 +++++++++------
 8 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 4f9ea8be314..a004a4ed4d7 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -254,6 +254,9 @@ pub enum AttributeKind {
     /// Represents `#[ffi_const]`.
     FfiConst(Span),
 
+    /// Represents `#[ffi_pure]`.
+    FfiPure(Span),
+
     /// Represents `#[ignore]`
     Ignore {
         span: Span,
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index e69a543d459..5f0f7152f86 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -28,6 +28,7 @@ impl AttributeKind {
             ExportName { .. } => Yes,
             ExportStable => No,
             FfiConst(..) => No,
+            FfiPure(..) => No,
             Ignore { .. } => No,
             Inline(..) => No,
             LinkName { .. } => Yes,
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
index 74283645a5a..42d901041d5 100644
--- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -73,3 +73,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for FfiConstParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::FfiConst;
 }
+
+pub(crate) struct FfiPureParser;
+impl<S: Stage> NoArgsAttributeParser<S> for FfiPureParser {
+    const PATH: &[Symbol] = &[sym::ffi_pure];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::FfiPure;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 6544278573b..f40d69c67a8 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -23,7 +23,7 @@ use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
 use crate::attributes::link_attrs::{
-    ExportStableParser, FfiConstParser, LinkNameParser, LinkSectionParser,
+    ExportStableParser, FfiConstParser, FfiPureParser, LinkNameParser, LinkSectionParser,
 };
 use crate::attributes::lint_helpers::{AsPtrParser, PassByValueParser, PubTransparentParser};
 use crate::attributes::loop_match::{ConstContinueParser, LoopMatchParser};
@@ -149,6 +149,7 @@ attribute_parsers!(
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
         Single<WithoutArgs<ExportStableParser>>,
         Single<WithoutArgs<FfiConstParser>>,
+        Single<WithoutArgs<FfiPureParser>>,
         Single<WithoutArgs<LoopMatchParser>>,
         Single<WithoutArgs<MayDangleParser>>,
         Single<WithoutArgs<NoImplicitPreludeParser>>,
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 72bb9e8fac5..1791df67803 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -206,6 +206,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                 AttributeKind::FfiConst(_) => {
                     codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_CONST
                 }
+                AttributeKind::FfiPure(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_PURE,
                 _ => {}
             }
         }
@@ -216,7 +217,6 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
 
         match name {
             sym::rustc_allocator => codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR,
-            sym::ffi_pure => codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_PURE,
             sym::rustc_nounwind => codegen_fn_attrs.flags |= CodegenFnAttrFlags::NEVER_UNWIND,
             sym::rustc_reallocator => codegen_fn_attrs.flags |= CodegenFnAttrFlags::REALLOCATOR,
             sym::rustc_deallocator => codegen_fn_attrs.flags |= CodegenFnAttrFlags::DEALLOCATOR,
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index ff5bcdce97b..2fc0eca1645 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -273,6 +273,7 @@ pub fn check_builtin_meta_item(
             sym::inline
                 | sym::export_stable
                 | sym::ffi_const
+                | sym::ffi_pure
                 | sym::may_dangle
                 | sym::rustc_as_ptr
                 | sym::rustc_pub_transparent
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 8a59b07a4f3..32e21c99f06 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -210,6 +210,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 &Attribute::Parsed(AttributeKind::FfiConst(attr_span)) => {
                     self.check_ffi_const(attr_span, target)
                 }
+                &Attribute::Parsed(AttributeKind::FfiPure(attr_span)) => {
+                    self.check_ffi_pure(attr_span, attrs, target)
+                }
                 Attribute::Parsed(
                     AttributeKind::BodyStability { .. }
                     | AttributeKind::ConstStabilityIndirect
@@ -306,7 +309,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::rustc_has_incoherent_inherent_impls, ..] => {
                             self.check_has_incoherent_inherent_impls(attr, span, target)
                         }
-                        [sym::ffi_pure, ..] => self.check_ffi_pure(attr.span(), attrs, target),
                         [sym::link_ordinal, ..] => self.check_link_ordinal(attr, span, target),
                         [sym::link, ..] => self.check_link(hir_id, attr, span, target),
                         [sym::macro_use, ..] | [sym::macro_escape, ..] => {
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index 908b2ba6314..5bcb0c4dc0a 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -134,12 +134,6 @@ error: malformed `fundamental` attribute input
 LL | #[fundamental()]
    | ^^^^^^^^^^^^^^^^ help: must be of the form: `#[fundamental]`
 
-error: malformed `ffi_pure` attribute input
-  --> $DIR/malformed-attrs.rs:165:5
-   |
-LL |     #[unsafe(ffi_pure = 1)]
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[ffi_pure]`
-
 error: malformed `link_ordinal` attribute input
   --> $DIR/malformed-attrs.rs:167:5
    |
@@ -534,6 +528,15 @@ LL | #[rustc_layout_scalar_valid_range_end]
    | expected this to be a list
    | help: must be of the form: `#[rustc_layout_scalar_valid_range_end(end)]`
 
+error[E0565]: malformed `ffi_pure` attribute input
+  --> $DIR/malformed-attrs.rs:165:5
+   |
+LL |     #[unsafe(ffi_pure = 1)]
+   |     ^^^^^^^^^^^^^^^^^^---^^
+   |     |                 |
+   |     |                 didn't expect any arguments here
+   |     help: must be of the form: `#[ffi_pure]`
+
 error[E0565]: malformed `ffi_const` attribute input
   --> $DIR/malformed-attrs.rs:171:5
    |
-- 
cgit 1.4.1-3-g733a5


From 4f0b0b0f01ef3e5a2445993faf8367a4e17b8df0 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Fri, 4 Jul 2025 15:53:03 +0300
Subject: Port `#[rustc_std_internal_symbol]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs        |  3 +++
 .../rustc_attr_data_structures/src/encode_cross_crate.rs     |  1 +
 compiler/rustc_attr_parsing/src/attributes/link_attrs.rs     |  7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                   |  2 ++
 compiler/rustc_codegen_ssa/src/codegen_attrs.rs              |  6 +++---
 compiler/rustc_parse/src/validate_attr.rs                    |  1 +
 compiler/rustc_passes/src/check_attr.rs                      | 12 +++++-------
 7 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index a004a4ed4d7..d3ab368bb20 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -335,6 +335,9 @@ pub enum AttributeKind {
         span: Span,
     },
 
+    /// Represents `#[rustc_std_internal_symbol]`.
+    StdInternalSymbol(Span),
+
     /// Represents `#[target_feature(enable = "...")]`
     TargetFeature(ThinVec<(Symbol, Span)>, Span),
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 5f0f7152f86..7b4885d86c5 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -51,6 +51,7 @@ impl AttributeKind {
             RustcObjectLifetimeDefault => No,
             SkipDuringMethodDispatch { .. } => No,
             Stability { .. } => Yes,
+            StdInternalSymbol(..) => No,
             TargetFeature(..) => No,
             TrackCaller(..) => Yes,
             Used { .. } => No,
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
index 42d901041d5..1a66eec870f 100644
--- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -80,3 +80,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for FfiPureParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::FfiPure;
 }
+
+pub(crate) struct StdInternalSymbolParser;
+impl<S: Stage> NoArgsAttributeParser<S> for StdInternalSymbolParser {
+    const PATH: &[Symbol] = &[sym::rustc_std_internal_symbol];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::StdInternalSymbol;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index f40d69c67a8..e6e1978b8db 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -24,6 +24,7 @@ use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
 use crate::attributes::link_attrs::{
     ExportStableParser, FfiConstParser, FfiPureParser, LinkNameParser, LinkSectionParser,
+    StdInternalSymbolParser,
 };
 use crate::attributes::lint_helpers::{AsPtrParser, PassByValueParser, PubTransparentParser};
 use crate::attributes::loop_match::{ConstContinueParser, LoopMatchParser};
@@ -157,6 +158,7 @@ attribute_parsers!(
         Single<WithoutArgs<NonExhaustiveParser>>,
         Single<WithoutArgs<PassByValueParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
+        Single<WithoutArgs<StdInternalSymbolParser>>,
         Single<WithoutArgs<TrackCallerParser>>,
         // tidy-alphabetical-end
     ];
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 1791df67803..85d01d4f938 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -207,6 +207,9 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                     codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_CONST
                 }
                 AttributeKind::FfiPure(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_PURE,
+                AttributeKind::StdInternalSymbol(_) => {
+                    codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL
+                }
                 _ => {}
             }
         }
@@ -223,9 +226,6 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
             sym::rustc_allocator_zeroed => {
                 codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR_ZEROED
             }
-            sym::rustc_std_internal_symbol => {
-                codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL
-            }
             sym::thread_local => codegen_fn_attrs.flags |= CodegenFnAttrFlags::THREAD_LOCAL,
             sym::linkage => {
                 if let Some(val) = attr.value_str() {
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 2fc0eca1645..11424ec3724 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -274,6 +274,7 @@ pub fn check_builtin_meta_item(
                 | sym::export_stable
                 | sym::ffi_const
                 | sym::ffi_pure
+                | sym::rustc_std_internal_symbol
                 | sym::may_dangle
                 | sym::rustc_as_ptr
                 | sym::rustc_pub_transparent
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 32e21c99f06..66166c53336 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -242,6 +242,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 &Attribute::Parsed(AttributeKind::PassByValue(attr_span)) => {
                     self.check_pass_by_value(attr_span, span, target)
                 }
+                &Attribute::Parsed(AttributeKind::StdInternalSymbol(attr_span)) => {
+                    self.check_rustc_std_internal_symbol(attr_span, span, target)
+                }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);
                     match attr.path().as_slice() {
@@ -267,9 +270,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         ),
                         [sym::no_link, ..] => self.check_no_link(hir_id, attr, span, target),
                         [sym::debugger_visualizer, ..] => self.check_debugger_visualizer(attr, target),
-                        [sym::rustc_std_internal_symbol, ..] => {
-                            self.check_rustc_std_internal_symbol(attr, span, target)
-                        }
                         [sym::rustc_no_implicit_autorefs, ..] => {
                             self.check_applied_to_fn_or_method(hir_id, attr.span(), span, target)
                         }
@@ -2220,13 +2220,11 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    fn check_rustc_std_internal_symbol(&self, attr: &Attribute, span: Span, target: Target) {
+    fn check_rustc_std_internal_symbol(&self, attr_span: Span, span: Span, target: Target) {
         match target {
             Target::Fn | Target::Static | Target::ForeignFn | Target::ForeignStatic => {}
             _ => {
-                self.tcx
-                    .dcx()
-                    .emit_err(errors::RustcStdInternalSymbol { attr_span: attr.span(), span });
+                self.tcx.dcx().emit_err(errors::RustcStdInternalSymbol { attr_span, span });
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 2b93d2cca61ede7af6201dc7a2be7c6957ebfb77 Mon Sep 17 00:00:00 2001
From: Jared Davis <message@jared-pri.me>
Date: Mon, 7 Jul 2025 10:38:29 -0400
Subject: skip exit late lint pass on tests

When using the `--test` or `--all-targets` flag, the exit lint should not fail on the main function.
---
 clippy_lints/src/exit.rs | 4 +++-
 tests/ui/exit4.rs        | 8 ++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/exit4.rs

diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index cc8e4d7d9e2..862dd6d6476 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_entrypoint_fn;
 use rustc_hir::{Expr, ExprKind, Item, ItemKind, OwnerNode};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
@@ -43,6 +43,8 @@ declare_lint_pass!(Exit => [EXIT]);
 
 impl<'tcx> LateLintPass<'tcx> for Exit {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        if cx.sess().is_test_crate() { return; }
+
         if let ExprKind::Call(path_expr, [_]) = e.kind
             && let ExprKind::Path(ref path) = path_expr.kind
             && let Some(def_id) = cx.qpath_res(path, path_expr.hir_id).opt_def_id()
diff --git a/tests/ui/exit4.rs b/tests/ui/exit4.rs
new file mode 100644
index 00000000000..d52cdbce0ea
--- /dev/null
+++ b/tests/ui/exit4.rs
@@ -0,0 +1,8 @@
+//@ check-pass
+//@compile-flags: --test
+
+#![warn(clippy::exit)]
+
+fn main() {
+    std::process::exit(0)
+}
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From 1f36d4df9369b5665e936e812b587e1c6bfa0e28 Mon Sep 17 00:00:00 2001
From: Jared Davis <message@jared-pri.me>
Date: Mon, 7 Jul 2025 11:08:45 -0400
Subject: run `cargo dev fmt` on changes

---
 clippy_lints/src/exit.rs | 4 +++-
 tests/ui/exit4.rs        | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 862dd6d6476..e6f1b7d8954 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -43,7 +43,9 @@ declare_lint_pass!(Exit => [EXIT]);
 
 impl<'tcx> LateLintPass<'tcx> for Exit {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if cx.sess().is_test_crate() { return; }
+        if cx.sess().is_test_crate() {
+            return;
+        }
 
         if let ExprKind::Call(path_expr, [_]) = e.kind
             && let ExprKind::Path(ref path) = path_expr.kind
diff --git a/tests/ui/exit4.rs b/tests/ui/exit4.rs
index d52cdbce0ea..821a26fd78b 100644
--- a/tests/ui/exit4.rs
+++ b/tests/ui/exit4.rs
@@ -5,4 +5,4 @@
 
 fn main() {
     std::process::exit(0)
-}
\ No newline at end of file
+}
-- 
cgit 1.4.1-3-g733a5


From 2412f8921ce39b986664e27c71b07f0ae24ac100 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Mon, 7 Jul 2025 15:39:31 +0000
Subject: UWP: link ntdll functions using raw-dylib

---
 library/std/src/sys/pal/windows/c.rs | 69 +++++-------------------------------
 library/windows_targets/src/lib.rs   | 23 ++++++++++--
 2 files changed, 30 insertions(+), 62 deletions(-)

diff --git a/library/std/src/sys/pal/windows/c.rs b/library/std/src/sys/pal/windows/c.rs
index eee169d410a..edac5262a4e 100644
--- a/library/std/src/sys/pal/windows/c.rs
+++ b/library/std/src/sys/pal/windows/c.rs
@@ -197,7 +197,7 @@ compat_fn_optional! {
     pub fn WakeByAddressSingle(address: *const c_void);
 }
 
-#[cfg(any(target_vendor = "win7", target_vendor = "uwp"))]
+#[cfg(any(target_vendor = "win7"))]
 compat_fn_with_fallback! {
     pub static NTDLL: &CStr = c"ntdll";
 
@@ -228,65 +228,14 @@ compat_fn_with_fallback! {
     ) -> NTSTATUS {
         panic!("keyed events not available")
     }
+}
 
-    // These functions are available on UWP when lazily loaded. They will fail WACK if loaded statically.
-    #[cfg(target_vendor = "uwp")]
-    pub fn NtCreateFile(
-        filehandle: *mut HANDLE,
-        desiredaccess: FILE_ACCESS_RIGHTS,
-        objectattributes: *const OBJECT_ATTRIBUTES,
-        iostatusblock: *mut IO_STATUS_BLOCK,
-        allocationsize: *const i64,
-        fileattributes: FILE_FLAGS_AND_ATTRIBUTES,
-        shareaccess: FILE_SHARE_MODE,
-        createdisposition: NTCREATEFILE_CREATE_DISPOSITION,
-        createoptions: NTCREATEFILE_CREATE_OPTIONS,
-        eabuffer: *const c_void,
-        ealength: u32
-    ) -> NTSTATUS {
-        STATUS_NOT_IMPLEMENTED
-    }
-    #[cfg(target_vendor = "uwp")]
-    pub fn NtOpenFile(
-        filehandle: *mut HANDLE,
-        desiredaccess: u32,
-        objectattributes: *const OBJECT_ATTRIBUTES,
-        iostatusblock: *mut IO_STATUS_BLOCK,
-        shareaccess: u32,
-        openoptions: u32
-    ) -> NTSTATUS {
-        STATUS_NOT_IMPLEMENTED
-    }
-    #[cfg(target_vendor = "uwp")]
-    pub fn NtReadFile(
-        filehandle: HANDLE,
-        event: HANDLE,
-        apcroutine: PIO_APC_ROUTINE,
-        apccontext: *const c_void,
-        iostatusblock: *mut IO_STATUS_BLOCK,
-        buffer: *mut c_void,
-        length: u32,
-        byteoffset: *const i64,
-        key: *const u32
-    ) -> NTSTATUS {
-        STATUS_NOT_IMPLEMENTED
-    }
-    #[cfg(target_vendor = "uwp")]
-    pub fn NtWriteFile(
-        filehandle: HANDLE,
-        event: HANDLE,
-        apcroutine: PIO_APC_ROUTINE,
-        apccontext: *const c_void,
-        iostatusblock: *mut IO_STATUS_BLOCK,
-        buffer: *const c_void,
-        length: u32,
-        byteoffset: *const i64,
-        key: *const u32
-    ) -> NTSTATUS {
-        STATUS_NOT_IMPLEMENTED
-    }
-    #[cfg(target_vendor = "uwp")]
-    pub fn RtlNtStatusToDosError(Status: NTSTATUS) -> u32 {
-        Status as u32
+cfg_if::cfg_if! {
+    if #[cfg(target_vendor = "uwp")] {
+        windows_targets::link_raw_dylib!("ntdll.dll" "system" fn NtCreateFile(filehandle : *mut HANDLE, desiredaccess : FILE_ACCESS_RIGHTS, objectattributes : *const OBJECT_ATTRIBUTES, iostatusblock : *mut IO_STATUS_BLOCK, allocationsize : *const i64, fileattributes : FILE_FLAGS_AND_ATTRIBUTES, shareaccess : FILE_SHARE_MODE, createdisposition : NTCREATEFILE_CREATE_DISPOSITION, createoptions : NTCREATEFILE_CREATE_OPTIONS, eabuffer : *const core::ffi::c_void, ealength : u32) -> NTSTATUS);
+        windows_targets::link_raw_dylib!("ntdll.dll" "system" fn NtOpenFile(filehandle : *mut HANDLE, desiredaccess : u32, objectattributes : *const OBJECT_ATTRIBUTES, iostatusblock : *mut IO_STATUS_BLOCK, shareaccess : u32, openoptions : u32) -> NTSTATUS);
+        windows_targets::link_raw_dylib!("ntdll.dll" "system" fn NtReadFile(filehandle : HANDLE, event : HANDLE, apcroutine : PIO_APC_ROUTINE, apccontext : *const core::ffi::c_void, iostatusblock : *mut IO_STATUS_BLOCK, buffer : *mut core::ffi::c_void, length : u32, byteoffset : *const i64, key : *const u32) -> NTSTATUS);
+        windows_targets::link_raw_dylib!("ntdll.dll" "system" fn NtWriteFile(filehandle : HANDLE, event : HANDLE, apcroutine : PIO_APC_ROUTINE, apccontext : *const core::ffi::c_void, iostatusblock : *mut IO_STATUS_BLOCK, buffer : *const core::ffi::c_void, length : u32, byteoffset : *const i64, key : *const u32) -> NTSTATUS);
+        windows_targets::link_raw_dylib!("ntdll.dll" "system" fn RtlNtStatusToDosError(status : NTSTATUS) -> u32);
     }
 }
diff --git a/library/windows_targets/src/lib.rs b/library/windows_targets/src/lib.rs
index bce54c5ffce..9e82e6a7200 100644
--- a/library/windows_targets/src/lib.rs
+++ b/library/windows_targets/src/lib.rs
@@ -7,8 +7,7 @@
 #![feature(decl_macro)]
 #![feature(no_core)]
 
-#[cfg(feature = "windows_raw_dylib")]
-pub macro link {
+pub macro link_raw_dylib {
     ($library:literal $abi:literal $($link_name:literal)? $(#[$doc:meta])? fn $($function:tt)*) => (
         #[cfg_attr(not(target_arch = "x86"), link(name = $library, kind = "raw-dylib", modifiers = "+verbatim"))]
         #[cfg_attr(target_arch = "x86", link(name = $library, kind = "raw-dylib", modifiers = "+verbatim", import_name_type = "undecorated"))]
@@ -18,6 +17,26 @@ pub macro link {
         }
     )
 }
+
+pub macro link_dylib {
+    ($library:literal $abi:literal $($link_name:literal)? $(#[$doc:meta])? fn $($function:tt)*) => (
+        // Note: the windows-targets crate uses a pre-built Windows.lib import library which we don't
+        // have in this repo. So instead we always link kernel32.lib and add the rest of the import
+        // libraries below by using an empty extern block. This works because extern blocks are not
+        // connected to the library given in the #[link] attribute.
+        #[link(name = "kernel32")]
+        unsafe extern $abi {
+            $(#[link_name=$link_name])?
+            pub fn $($function)*;
+        }
+    )
+}
+
+#[cfg(feature = "windows_raw_dylib")]
+pub macro link($($tt:tt)*) {
+    $crate::link_raw_dylib!($($tt)*)
+}
+
 #[cfg(not(feature = "windows_raw_dylib"))]
 pub macro link {
     ($library:literal $abi:literal $($link_name:literal)? $(#[$doc:meta])? fn $($function:tt)*) => (
-- 
cgit 1.4.1-3-g733a5


From e296e6bdfed270453e5423e68cb9f3b7ca49fec3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 7 Jul 2025 17:53:23 +0200
Subject: move our data structures into a central location

---
 .../miri/src/borrow_tracker/stacked_borrows/mod.rs |   4 +-
 .../miri/src/borrow_tracker/tree_borrows/mod.rs    |   2 +-
 .../miri/src/borrow_tracker/tree_borrows/tree.rs   |   6 +-
 src/tools/miri/src/concurrency/data_race.rs        |   4 +-
 src/tools/miri/src/concurrency/mod.rs              |   1 -
 src/tools/miri/src/concurrency/range_object_map.rs | 270 ----------------
 src/tools/miri/src/concurrency/weak_memory.rs      |   2 +-
 .../miri/src/data_structures/dedup_range_map.rs    | 344 +++++++++++++++++++++
 src/tools/miri/src/data_structures/mod.rs          |   3 +
 .../miri/src/data_structures/mono_hash_map.rs      | 118 +++++++
 .../miri/src/data_structures/range_object_map.rs   | 270 ++++++++++++++++
 src/tools/miri/src/lib.rs                          |   7 +-
 src/tools/miri/src/mono_hash_map.rs                | 118 -------
 src/tools/miri/src/range_map.rs                    | 344 ---------------------
 14 files changed, 747 insertions(+), 746 deletions(-)
 delete mode 100644 src/tools/miri/src/concurrency/range_object_map.rs
 create mode 100644 src/tools/miri/src/data_structures/dedup_range_map.rs
 create mode 100644 src/tools/miri/src/data_structures/mod.rs
 create mode 100644 src/tools/miri/src/data_structures/mono_hash_map.rs
 create mode 100644 src/tools/miri/src/data_structures/range_object_map.rs
 delete mode 100644 src/tools/miri/src/mono_hash_map.rs
 delete mode 100644 src/tools/miri/src/range_map.rs

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 b8bcacf7c99..834a4b41f22 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
@@ -30,7 +30,7 @@ pub type AllocState = Stacks;
 #[derive(Clone, Debug)]
 pub struct Stacks {
     // Even reading memory can have effects on the stack, so we need a `RefCell` here.
-    stacks: RangeMap<Stack>,
+    stacks: DedupRangeMap<Stack>,
     /// Stores past operations on this allocation
     history: AllocHistory,
     /// The set of tags that have been exposed inside this allocation.
@@ -468,7 +468,7 @@ impl<'tcx> Stacks {
         let stack = Stack::new(item);
 
         Stacks {
-            stacks: RangeMap::new(size, stack),
+            stacks: DedupRangeMap::new(size, stack),
             history: AllocHistory::new(id, item, machine),
             exposed_tags: FxHashSet::default(),
         }
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 a0761cb07a1..c157c69d7c8 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -314,7 +314,7 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let span = this.machine.current_span();
 
         // Store initial permissions and their corresponding range.
-        let mut perms_map: RangeMap<LocationState> = RangeMap::new(
+        let mut perms_map: DedupRangeMap<LocationState> = DedupRangeMap::new(
             ptr_size,
             LocationState::new_accessed(Permission::new_disabled(), IdempotentForeignAccess::None), // this will be overwritten
         );
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
index 48e4a19e263..1f29bcfc2b0 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
@@ -247,7 +247,7 @@ pub struct Tree {
     /// `unwrap` any `perm.get(key)`.
     ///
     /// We do uphold the fact that `keys(perms)` is a subset of `keys(nodes)`
-    pub(super) rperms: RangeMap<UniValMap<LocationState>>,
+    pub(super) rperms: DedupRangeMap<UniValMap<LocationState>>,
     /// The index of the root node.
     pub(super) root: UniIndex,
 }
@@ -609,7 +609,7 @@ impl Tree {
                     IdempotentForeignAccess::None,
                 ),
             );
-            RangeMap::new(size, perms)
+            DedupRangeMap::new(size, perms)
         };
         Self { root: root_idx, nodes, rperms, tag_mapping }
     }
@@ -631,7 +631,7 @@ impl<'tcx> Tree {
         base_offset: Size,
         parent_tag: BorTag,
         new_tag: BorTag,
-        initial_perms: RangeMap<LocationState>,
+        initial_perms: DedupRangeMap<LocationState>,
         default_perm: Permission,
         protected: bool,
         span: Span,
diff --git a/src/tools/miri/src/concurrency/data_race.rs b/src/tools/miri/src/concurrency/data_race.rs
index b5e7e9d0ac0..38d76f5cf73 100644
--- a/src/tools/miri/src/concurrency/data_race.rs
+++ b/src/tools/miri/src/concurrency/data_race.rs
@@ -997,7 +997,7 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
 #[derive(Debug, Clone)]
 pub struct VClockAlloc {
     /// Assigning each byte a MemoryCellClocks.
-    alloc_ranges: RefCell<RangeMap<MemoryCellClocks>>,
+    alloc_ranges: RefCell<DedupRangeMap<MemoryCellClocks>>,
 }
 
 impl VisitProvenance for VClockAlloc {
@@ -1045,7 +1045,7 @@ impl VClockAlloc {
                 (VTimestamp::ZERO, global.thread_index(ThreadId::MAIN_THREAD)),
         };
         VClockAlloc {
-            alloc_ranges: RefCell::new(RangeMap::new(
+            alloc_ranges: RefCell::new(DedupRangeMap::new(
                 len,
                 MemoryCellClocks::new(alloc_timestamp, alloc_index),
             )),
diff --git a/src/tools/miri/src/concurrency/mod.rs b/src/tools/miri/src/concurrency/mod.rs
index 49bcc0d30b5..c2ea8a00dec 100644
--- a/src/tools/miri/src/concurrency/mod.rs
+++ b/src/tools/miri/src/concurrency/mod.rs
@@ -2,7 +2,6 @@ pub mod cpu_affinity;
 pub mod data_race;
 mod data_race_handler;
 pub mod init_once;
-mod range_object_map;
 pub mod sync;
 pub mod thread;
 mod vector_clock;
diff --git a/src/tools/miri/src/concurrency/range_object_map.rs b/src/tools/miri/src/concurrency/range_object_map.rs
deleted file mode 100644
index 4c9cf3dc635..00000000000
--- a/src/tools/miri/src/concurrency/range_object_map.rs
+++ /dev/null
@@ -1,270 +0,0 @@
-//! Implements a map from allocation ranges to data. This is somewhat similar to RangeMap, but the
-//! ranges and data are discrete and non-splittable -- they represent distinct "objects". An
-//! allocation in the map will always have the same range until explicitly removed
-
-use std::ops::{Index, IndexMut, Range};
-
-use rustc_abi::Size;
-use rustc_const_eval::interpret::AllocRange;
-
-#[derive(Clone, Debug)]
-struct Elem<T> {
-    /// The range covered by this element; never empty.
-    range: AllocRange,
-    /// The data stored for this element.
-    data: T,
-}
-
-/// Index of an allocation within the map
-type Position = usize;
-
-#[derive(Clone, Debug)]
-pub struct RangeObjectMap<T> {
-    v: Vec<Elem<T>>,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum AccessType {
-    /// The access perfectly overlaps (same offset and range) with the existing allocation
-    PerfectlyOverlapping(Position),
-    /// The access does not touch any existing allocation
-    Empty(Position),
-    /// The access overlaps with one or more existing allocations
-    ImperfectlyOverlapping(Range<Position>),
-}
-
-impl<T> RangeObjectMap<T> {
-    pub fn new() -> Self {
-        Self { v: Vec::new() }
-    }
-
-    /// Finds the position of the allocation containing the given offset. If the offset is not
-    /// in an existing allocation, then returns Err containing the position
-    /// where such allocation should be inserted
-    fn find_offset(&self, offset: Size) -> Result<Position, Position> {
-        self.v.binary_search_by(|elem| -> std::cmp::Ordering {
-            if offset < elem.range.start {
-                // We are too far right (offset is further left).
-                // (`Greater` means that `elem` is greater than the desired target.)
-                std::cmp::Ordering::Greater
-            } else if offset >= elem.range.end() {
-                // We are too far left (offset is further right).
-                std::cmp::Ordering::Less
-            } else {
-                // This is it!
-                std::cmp::Ordering::Equal
-            }
-        })
-    }
-
-    /// Determines whether a given access on `range` overlaps with
-    /// an existing allocation
-    pub fn access_type(&self, range: AllocRange) -> AccessType {
-        match self.find_offset(range.start) {
-            Ok(pos) => {
-                // Start of the range belongs to an existing object, now let's check the overlapping situation
-                let elem = &self.v[pos];
-                // FIXME: derive Eq for AllocRange in rustc
-                if elem.range.start == range.start && elem.range.size == range.size {
-                    // Happy case: perfectly overlapping access
-                    AccessType::PerfectlyOverlapping(pos)
-                } else {
-                    // FIXME: add a last() method to AllocRange that returns the last inclusive offset (end() is exclusive)
-                    let end_pos = match self.find_offset(range.end() - Size::from_bytes(1)) {
-                        // If the end lands in an existing object, add one to get the exclusive position
-                        Ok(inclusive_pos) => inclusive_pos + 1,
-                        Err(exclusive_pos) => exclusive_pos,
-                    };
-
-                    AccessType::ImperfectlyOverlapping(pos..end_pos)
-                }
-            }
-            Err(pos) => {
-                // Start of the range doesn't belong to an existing object
-                match self.find_offset(range.end() - Size::from_bytes(1)) {
-                    // Neither does the end
-                    Err(end_pos) =>
-                        if pos == end_pos {
-                            // There's nothing between the start and the end, so the range thing is empty
-                            AccessType::Empty(pos)
-                        } else {
-                            // Otherwise we have entirely covered an existing object
-                            AccessType::ImperfectlyOverlapping(pos..end_pos)
-                        },
-                    // Otherwise at least part of it overlaps with something else
-                    Ok(end_pos) => AccessType::ImperfectlyOverlapping(pos..end_pos + 1),
-                }
-            }
-        }
-    }
-
-    /// Inserts an object and its occupied range at given position
-    // The Position can be calculated from AllocRange, but the only user of AllocationMap
-    // always calls access_type before calling insert/index/index_mut, and we don't
-    // want to repeat the binary search on each time, so we ask the caller to supply Position
-    pub fn insert_at_pos(&mut self, pos: Position, range: AllocRange, data: T) {
-        self.v.insert(pos, Elem { range, data });
-        // If we aren't the first element, then our start must be greater than the previous element's end
-        if pos > 0 {
-            assert!(self.v[pos - 1].range.end() <= range.start);
-        }
-        // If we aren't the last element, then our end must be smaller than next element's start
-        if pos < self.v.len() - 1 {
-            assert!(range.end() <= self.v[pos + 1].range.start);
-        }
-    }
-
-    pub fn remove_pos_range(&mut self, pos_range: Range<Position>) {
-        self.v.drain(pos_range);
-    }
-
-    pub fn remove_from_pos(&mut self, pos: Position) {
-        self.v.remove(pos);
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = &T> {
-        self.v.iter().map(|e| &e.data)
-    }
-}
-
-impl<T> Index<Position> for RangeObjectMap<T> {
-    type Output = T;
-
-    fn index(&self, pos: Position) -> &Self::Output {
-        &self.v[pos].data
-    }
-}
-
-impl<T> IndexMut<Position> for RangeObjectMap<T> {
-    fn index_mut(&mut self, pos: Position) -> &mut Self::Output {
-        &mut self.v[pos].data
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use rustc_const_eval::interpret::alloc_range;
-
-    use super::*;
-
-    #[test]
-    fn empty_map() {
-        // FIXME: make Size::from_bytes const
-        let four = Size::from_bytes(4);
-        let map = RangeObjectMap::<()>::new();
-
-        // Correctly tells where we should insert the first element (at position 0)
-        assert_eq!(map.find_offset(Size::from_bytes(3)), Err(0));
-
-        // Correctly tells the access type along with the supposed position
-        assert_eq!(map.access_type(alloc_range(Size::ZERO, four)), AccessType::Empty(0));
-    }
-
-    #[test]
-    #[should_panic]
-    fn no_overlapping_inserts() {
-        let four = Size::from_bytes(4);
-
-        let mut map = RangeObjectMap::<&str>::new();
-
-        // |_|_|_|_|#|#|#|#|_|_|_|_|...
-        //  0 1 2 3 4 5 6 7 8 9 a b c d
-        map.insert_at_pos(0, alloc_range(four, four), "#");
-        // |_|_|_|_|#|#|#|#|_|_|_|_|...
-        //  0 ^ ^ ^ ^ 5 6 7 8 9 a b c d
-        map.insert_at_pos(0, alloc_range(Size::from_bytes(1), four), "@");
-    }
-
-    #[test]
-    fn boundaries() {
-        let four = Size::from_bytes(4);
-
-        let mut map = RangeObjectMap::<&str>::new();
-
-        // |#|#|#|#|_|_|...
-        //  0 1 2 3 4 5
-        map.insert_at_pos(0, alloc_range(Size::ZERO, four), "#");
-        // |#|#|#|#|_|_|...
-        //  0 1 2 3 ^ 5
-        assert_eq!(map.find_offset(four), Err(1));
-        // |#|#|#|#|_|_|_|_|_|...
-        //  0 1 2 3 ^ ^ ^ ^ 8
-        assert_eq!(map.access_type(alloc_range(four, four)), AccessType::Empty(1));
-
-        let eight = Size::from_bytes(8);
-        // |#|#|#|#|_|_|_|_|@|@|@|@|_|_|...
-        //  0 1 2 3 4 5 6 7 8 9 a b c d
-        map.insert_at_pos(1, alloc_range(eight, four), "@");
-        // |#|#|#|#|_|_|_|_|@|@|@|@|_|_|...
-        //  0 1 2 3 4 5 6 ^ 8 9 a b c d
-        assert_eq!(map.find_offset(Size::from_bytes(7)), Err(1));
-        // |#|#|#|#|_|_|_|_|@|@|@|@|_|_|...
-        //  0 1 2 3 ^ ^ ^ ^ 8 9 a b c d
-        assert_eq!(map.access_type(alloc_range(four, four)), AccessType::Empty(1));
-    }
-
-    #[test]
-    fn perfectly_overlapping() {
-        let four = Size::from_bytes(4);
-
-        let mut map = RangeObjectMap::<&str>::new();
-
-        // |#|#|#|#|_|_|...
-        //  0 1 2 3 4 5
-        map.insert_at_pos(0, alloc_range(Size::ZERO, four), "#");
-        // |#|#|#|#|_|_|...
-        //  ^ ^ ^ ^ 4 5
-        assert_eq!(map.find_offset(Size::ZERO), Ok(0));
-        assert_eq!(
-            map.access_type(alloc_range(Size::ZERO, four)),
-            AccessType::PerfectlyOverlapping(0)
-        );
-
-        // |#|#|#|#|@|@|@|@|_|...
-        //  0 1 2 3 4 5 6 7 8
-        map.insert_at_pos(1, alloc_range(four, four), "@");
-        // |#|#|#|#|@|@|@|@|_|...
-        //  0 1 2 3 ^ ^ ^ ^ 8
-        assert_eq!(map.find_offset(four), Ok(1));
-        assert_eq!(map.access_type(alloc_range(four, four)), AccessType::PerfectlyOverlapping(1));
-    }
-
-    #[test]
-    fn straddling() {
-        let four = Size::from_bytes(4);
-
-        let mut map = RangeObjectMap::<&str>::new();
-
-        // |_|_|_|_|#|#|#|#|_|_|_|_|...
-        //  0 1 2 3 4 5 6 7 8 9 a b c d
-        map.insert_at_pos(0, alloc_range(four, four), "#");
-        // |_|_|_|_|#|#|#|#|_|_|_|_|...
-        //  0 1 ^ ^ ^ ^ 6 7 8 9 a b c d
-        assert_eq!(
-            map.access_type(alloc_range(Size::from_bytes(2), four)),
-            AccessType::ImperfectlyOverlapping(0..1)
-        );
-        // |_|_|_|_|#|#|#|#|_|_|_|_|...
-        //  0 1 2 3 4 5 ^ ^ ^ ^ a b c d
-        assert_eq!(
-            map.access_type(alloc_range(Size::from_bytes(6), four)),
-            AccessType::ImperfectlyOverlapping(0..1)
-        );
-        // |_|_|_|_|#|#|#|#|_|_|_|_|...
-        //  0 1 ^ ^ ^ ^ ^ ^ ^ ^ a b c d
-        assert_eq!(
-            map.access_type(alloc_range(Size::from_bytes(2), Size::from_bytes(8))),
-            AccessType::ImperfectlyOverlapping(0..1)
-        );
-
-        // |_|_|_|_|#|#|#|#|_|_|@|@|_|_|...
-        //  0 1 2 3 4 5 6 7 8 9 a b c d
-        map.insert_at_pos(1, alloc_range(Size::from_bytes(10), Size::from_bytes(2)), "@");
-        // |_|_|_|_|#|#|#|#|_|_|@|@|_|_|...
-        //  0 1 2 3 4 5 ^ ^ ^ ^ ^ ^ ^ ^
-        assert_eq!(
-            map.access_type(alloc_range(Size::from_bytes(6), Size::from_bytes(8))),
-            AccessType::ImperfectlyOverlapping(0..2)
-        );
-    }
-}
diff --git a/src/tools/miri/src/concurrency/weak_memory.rs b/src/tools/miri/src/concurrency/weak_memory.rs
index 95c010be2fd..a752ef7e454 100644
--- a/src/tools/miri/src/concurrency/weak_memory.rs
+++ b/src/tools/miri/src/concurrency/weak_memory.rs
@@ -90,9 +90,9 @@ use rustc_data_structures::fx::FxHashMap;
 
 use super::AllocDataRaceHandler;
 use super::data_race::{GlobalState as DataRaceState, ThreadClockSet};
-use super::range_object_map::{AccessType, RangeObjectMap};
 use super::vector_clock::{VClock, VTimestamp, VectorIdx};
 use crate::concurrency::GlobalDataRaceHandler;
+use crate::data_structures::range_object_map::{AccessType, RangeObjectMap};
 use crate::*;
 
 pub type AllocState = StoreBufferAlloc;
diff --git a/src/tools/miri/src/data_structures/dedup_range_map.rs b/src/tools/miri/src/data_structures/dedup_range_map.rs
new file mode 100644
index 00000000000..56e9883b1ca
--- /dev/null
+++ b/src/tools/miri/src/data_structures/dedup_range_map.rs
@@ -0,0 +1,344 @@
+//! Implements a map from integer indices to data.
+//! Rather than storing data for every index, internally, this maps entire ranges to the data.
+//! To this end, the APIs all work on ranges, not on individual integers. Ranges are split as
+//! necessary (e.g., when [0,5) is first associated with X, and then [1,2) is mutated).
+//! Users must not depend on whether a range is coalesced or not, even though this is observable
+//! via the iteration APIs.
+
+use std::ops;
+
+use rustc_abi::Size;
+
+#[derive(Clone, Debug)]
+struct Elem<T> {
+    /// The range covered by this element; never empty.
+    range: ops::Range<u64>,
+    /// The data stored for this element.
+    data: T,
+}
+#[derive(Clone, Debug)]
+pub struct DedupRangeMap<T> {
+    v: Vec<Elem<T>>,
+}
+
+impl<T> DedupRangeMap<T> {
+    /// Creates a new `RangeMap` for the given size, and with the given initial value used for
+    /// the entire range.
+    #[inline(always)]
+    pub fn new(size: Size, init: T) -> DedupRangeMap<T> {
+        let size = size.bytes();
+        let v = if size > 0 { vec![Elem { range: 0..size, data: init }] } else { Vec::new() };
+        DedupRangeMap { v }
+    }
+
+    pub fn size(&self) -> Size {
+        let size = self.v.last().map(|x| x.range.end).unwrap_or(0);
+        Size::from_bytes(size)
+    }
+
+    /// Finds the index containing the given offset.
+    fn find_offset(&self, offset: u64) -> usize {
+        self.v
+            .binary_search_by(|elem| -> std::cmp::Ordering {
+                if offset < elem.range.start {
+                    // We are too far right (offset is further left).
+                    // (`Greater` means that `elem` is greater than the desired target.)
+                    std::cmp::Ordering::Greater
+                } else if offset >= elem.range.end {
+                    // We are too far left (offset is further right).
+                    std::cmp::Ordering::Less
+                } else {
+                    // This is it!
+                    std::cmp::Ordering::Equal
+                }
+            })
+            .unwrap()
+    }
+
+    /// Provides read-only iteration over everything in the given range. This does
+    /// *not* split items if they overlap with the edges. Do not use this to mutate
+    /// through interior mutability.
+    ///
+    /// The iterator also provides the range of the given element.
+    /// How exactly the ranges are split can differ even for otherwise identical
+    /// maps, so user-visible behavior should never depend on the exact range.
+    pub fn iter(&self, offset: Size, len: Size) -> impl Iterator<Item = (ops::Range<u64>, &T)> {
+        let offset = offset.bytes();
+        let len = len.bytes();
+        // Compute a slice starting with the elements we care about.
+        let slice: &[Elem<T>] = if len == 0 {
+            // We just need any empty iterator. We don't even want to
+            // yield the element that surrounds this position.
+            &[]
+        } else {
+            let first_idx = self.find_offset(offset);
+            &self.v[first_idx..]
+        };
+        // The first offset that is not included any more.
+        let end = offset + len;
+        assert!(end <= self.size().bytes(), "iterating beyond the bounds of this RangeMap");
+        slice
+            .iter()
+            .take_while(move |elem| elem.range.start < end)
+            .map(|elem| (elem.range.clone(), &elem.data))
+    }
+
+    /// Provides mutable iteration over all elements.
+    /// The iterator also provides the range of the given element.
+    /// How exactly the ranges are split can differ even for otherwise identical
+    /// maps, so user-visible behavior should never depend on the exact range.
+    pub fn iter_mut_all(&mut self) -> impl Iterator<Item = (ops::Range<u64>, &mut T)> {
+        self.v.iter_mut().map(|elem| (elem.range.clone(), &mut elem.data))
+    }
+
+    /// Provides iteration over all elements.
+    /// The iterator also provides the range of the given element.
+    /// How exactly the ranges are split can differ even for otherwise identical
+    /// maps, so user-visible behavior should never depend on the exact range.
+    pub fn iter_all(&self) -> impl Iterator<Item = (ops::Range<u64>, &T)> {
+        self.v.iter().map(|elem| (elem.range.clone(), &elem.data))
+    }
+
+    // Splits the element situated at the given `index`, such that the 2nd one starts at offset
+    // `split_offset`. Do nothing if the element already starts there.
+    // Returns whether a split was necessary.
+    fn split_index(&mut self, index: usize, split_offset: u64) -> bool
+    where
+        T: Clone,
+    {
+        let elem = &mut self.v[index];
+        if split_offset == elem.range.start || split_offset == elem.range.end {
+            // Nothing to do.
+            return false;
+        }
+        debug_assert!(
+            elem.range.contains(&split_offset),
+            "the `split_offset` is not in the element to be split"
+        );
+
+        // Now we really have to split. Reduce length of first element.
+        let second_range = split_offset..elem.range.end;
+        elem.range.end = split_offset;
+        // Copy the data, and insert second element.
+        let second = Elem { range: second_range, data: elem.data.clone() };
+        self.v.insert(index + 1, second);
+        true
+    }
+
+    /// Provides mutable iteration over everything in the given range. As a side-effect,
+    /// this will split entries in the map that are only partially hit by the given range,
+    /// to make sure that when they are mutated, the effect is constrained to the given range.
+    /// Moreover, this will opportunistically merge neighbouring equal blocks.
+    ///
+    /// The iterator also provides the range of the given element.
+    /// How exactly the ranges are split (both prior to and resulting from the execution of this
+    /// function) can differ even for otherwise identical maps,
+    /// so user-visible behavior should never depend on the exact range.
+    pub fn iter_mut(
+        &mut self,
+        offset: Size,
+        len: Size,
+    ) -> impl Iterator<Item = (ops::Range<u64>, &mut T)>
+    where
+        T: Clone + PartialEq,
+    {
+        let offset = offset.bytes();
+        let len = len.bytes();
+        // Compute a slice containing exactly the elements we care about
+        let slice: &mut [Elem<T>] = if len == 0 {
+            // We just need any empty iterator. We don't even want to
+            // yield the element that surrounds this position, nor do
+            // any splitting.
+            &mut []
+        } else {
+            // Make sure we got a clear beginning
+            let mut first_idx = self.find_offset(offset);
+            if self.split_index(first_idx, offset) {
+                // The newly created 2nd element is ours
+                first_idx += 1;
+            }
+            // No more mutation.
+            let first_idx = first_idx;
+            // Find our end. Linear scan, but that's ok because the iteration
+            // is doing the same linear scan anyway -- no increase in complexity.
+            // We combine this scan with a scan for duplicates that we can merge, to reduce
+            // the number of elements.
+            // We stop searching after the first "block" of size 1, to avoid spending excessive
+            // amounts of time on the merging.
+            let mut equal_since_idx = first_idx;
+            // Once we see too many non-mergeable blocks, we stop.
+            // The initial value is chosen via... magic. Benchmarking and magic.
+            let mut successful_merge_count = 3usize;
+            // When the loop is done, this is the first excluded element.
+            let mut end_idx = first_idx;
+            loop {
+                // Compute if `end` is the last element we need to look at.
+                let done = self.v[end_idx].range.end >= offset + len;
+                // We definitely need to include `end`, so move the index.
+                end_idx += 1;
+                debug_assert!(
+                    done || end_idx < self.v.len(),
+                    "iter_mut: end-offset {} is out-of-bounds",
+                    offset + len
+                );
+                // see if we want to merge everything in `equal_since..end` (exclusive at the end!)
+                if successful_merge_count > 0 {
+                    if done || self.v[end_idx].data != self.v[equal_since_idx].data {
+                        // Everything in `equal_since..end` was equal. Make them just one element covering
+                        // the entire range.
+                        let removed_elems = end_idx - equal_since_idx - 1; // number of elements that we would remove
+                        if removed_elems > 0 {
+                            // Adjust the range of the first element to cover all of them.
+                            let equal_until = self.v[end_idx - 1].range.end; // end of range of last of the equal elements
+                            self.v[equal_since_idx].range.end = equal_until;
+                            // Delete the rest of them.
+                            self.v.splice(equal_since_idx + 1..end_idx, std::iter::empty());
+                            // Adjust `end_idx` because we made the list shorter.
+                            end_idx -= removed_elems;
+                            // Adjust the count for the cutoff.
+                            successful_merge_count += removed_elems;
+                        } else {
+                            // Adjust the count for the cutoff.
+                            successful_merge_count -= 1;
+                        }
+                        // Go on scanning for the next block starting here.
+                        equal_since_idx = end_idx;
+                    }
+                }
+                // Leave loop if this is the last element.
+                if done {
+                    break;
+                }
+            }
+            // Move to last included instead of first excluded index.
+            let end_idx = end_idx - 1;
+            // We need to split the end as well. Even if this performs a
+            // split, we don't have to adjust our index as we only care about
+            // the first part of the split.
+            self.split_index(end_idx, offset + len);
+            // Now we yield the slice. `end` is inclusive.
+            &mut self.v[first_idx..=end_idx]
+        };
+        slice.iter_mut().map(|elem| (elem.range.clone(), &mut elem.data))
+    }
+
+    /// Remove all adjacent duplicates
+    pub fn merge_adjacent_thorough(&mut self)
+    where
+        T: PartialEq,
+    {
+        let clean = Vec::with_capacity(self.v.len());
+        for elem in std::mem::replace(&mut self.v, clean) {
+            if let Some(prev) = self.v.last_mut() {
+                if prev.data == elem.data {
+                    assert_eq!(prev.range.end, elem.range.start);
+                    prev.range.end = elem.range.end;
+                    continue;
+                }
+            }
+            self.v.push(elem);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Query the map at every offset in the range and collect the results.
+    fn to_vec<T: Copy>(map: &DedupRangeMap<T>, offset: u64, len: u64) -> Vec<T> {
+        (offset..offset + len)
+            .map(|i| {
+                map.iter(Size::from_bytes(i), Size::from_bytes(1)).next().map(|(_, &t)| t).unwrap()
+            })
+            .collect()
+    }
+
+    #[test]
+    fn basic_insert() {
+        let mut map = DedupRangeMap::<i32>::new(Size::from_bytes(20), -1);
+        // Insert.
+        for (_, x) in map.iter_mut(Size::from_bytes(10), Size::from_bytes(1)) {
+            *x = 42;
+        }
+        // Check.
+        assert_eq!(to_vec(&map, 10, 1), vec![42]);
+        assert_eq!(map.v.len(), 3);
+
+        // Insert with size 0.
+        for (_, x) in map.iter_mut(Size::from_bytes(10), Size::from_bytes(0)) {
+            *x = 19;
+        }
+        for (_, x) in map.iter_mut(Size::from_bytes(11), Size::from_bytes(0)) {
+            *x = 19;
+        }
+        assert_eq!(to_vec(&map, 10, 2), vec![42, -1]);
+        assert_eq!(map.v.len(), 3);
+    }
+
+    #[test]
+    fn gaps() {
+        let mut map = DedupRangeMap::<i32>::new(Size::from_bytes(20), -1);
+        for (_, x) in map.iter_mut(Size::from_bytes(11), Size::from_bytes(1)) {
+            *x = 42;
+        }
+        for (_, x) in map.iter_mut(Size::from_bytes(15), Size::from_bytes(1)) {
+            *x = 43;
+        }
+        assert_eq!(map.v.len(), 5);
+        assert_eq!(to_vec(&map, 10, 10), vec![-1, 42, -1, -1, -1, 43, -1, -1, -1, -1]);
+
+        for (_, x) in map.iter_mut(Size::from_bytes(10), Size::from_bytes(10)) {
+            if *x < 42 {
+                *x = 23;
+            }
+        }
+        assert_eq!(map.v.len(), 6);
+        assert_eq!(to_vec(&map, 10, 10), vec![23, 42, 23, 23, 23, 43, 23, 23, 23, 23]);
+        assert_eq!(to_vec(&map, 13, 5), vec![23, 23, 43, 23, 23]);
+
+        for (_, x) in map.iter_mut(Size::from_bytes(15), Size::from_bytes(5)) {
+            *x = 19;
+        }
+        assert_eq!(map.v.len(), 6);
+        assert_eq!(to_vec(&map, 10, 10), vec![23, 42, 23, 23, 23, 19, 19, 19, 19, 19]);
+        // Should be seeing two blocks with 19.
+        assert_eq!(
+            map.iter(Size::from_bytes(15), Size::from_bytes(2))
+                .map(|(_, &t)| t)
+                .collect::<Vec<_>>(),
+            vec![19, 19]
+        );
+
+        // A NOP `iter_mut` should trigger merging.
+        for _ in map.iter_mut(Size::from_bytes(15), Size::from_bytes(5)) {}
+        assert_eq!(map.v.len(), 5);
+        assert_eq!(to_vec(&map, 10, 10), vec![23, 42, 23, 23, 23, 19, 19, 19, 19, 19]);
+    }
+
+    #[test]
+    #[should_panic]
+    fn out_of_range_iter_mut() {
+        let mut map = DedupRangeMap::<i32>::new(Size::from_bytes(20), -1);
+        let _ = map.iter_mut(Size::from_bytes(11), Size::from_bytes(11));
+    }
+
+    #[test]
+    #[should_panic]
+    fn out_of_range_iter() {
+        let map = DedupRangeMap::<i32>::new(Size::from_bytes(20), -1);
+        let _ = map.iter(Size::from_bytes(11), Size::from_bytes(11));
+    }
+
+    #[test]
+    fn empty_map_iter() {
+        let map = DedupRangeMap::<i32>::new(Size::from_bytes(0), -1);
+        let _ = map.iter(Size::from_bytes(0), Size::from_bytes(0));
+    }
+
+    #[test]
+    fn empty_map_iter_mut() {
+        let mut map = DedupRangeMap::<i32>::new(Size::from_bytes(0), -1);
+        let _ = map.iter_mut(Size::from_bytes(0), Size::from_bytes(0));
+    }
+}
diff --git a/src/tools/miri/src/data_structures/mod.rs b/src/tools/miri/src/data_structures/mod.rs
new file mode 100644
index 00000000000..d4468bc57ea
--- /dev/null
+++ b/src/tools/miri/src/data_structures/mod.rs
@@ -0,0 +1,3 @@
+pub mod dedup_range_map;
+pub mod mono_hash_map;
+pub mod range_object_map;
diff --git a/src/tools/miri/src/data_structures/mono_hash_map.rs b/src/tools/miri/src/data_structures/mono_hash_map.rs
new file mode 100644
index 00000000000..220233f8ff5
--- /dev/null
+++ b/src/tools/miri/src/data_structures/mono_hash_map.rs
@@ -0,0 +1,118 @@
+//! This is a "monotonic `FxHashMap`": A `FxHashMap` that, when shared, can be pushed to but not
+//! otherwise mutated. We also box items in the map. This means we can safely provide
+//! shared references into existing items in the `FxHashMap`, because they will not be dropped
+//! (from being removed) or moved (because they are boxed).
+//! The API is completely tailored to what `memory.rs` needs. It is still in
+//! a separate file to minimize the amount of code that has to care about the unsafety.
+
+use std::borrow::Borrow;
+use std::cell::RefCell;
+use std::collections::hash_map::Entry;
+use std::hash::Hash;
+
+use rustc_data_structures::fx::FxHashMap;
+
+use crate::AllocMap;
+
+#[derive(Debug, Clone)]
+pub struct MonoHashMap<K: Hash + Eq, V>(RefCell<FxHashMap<K, Box<V>>>);
+
+impl<K: Hash + Eq, V> MonoHashMap<K, V> {
+    /// This function exists for priroda to be able to iterate over all evaluator memory.
+    ///
+    /// The function is somewhat roundabout with the closure argument because internally the
+    /// `MonoHashMap` uses a `RefCell`. When iterating over the `FxHashMap` inside the `RefCell`,
+    /// we need to keep a borrow to the `FxHashMap` inside the iterator. The borrow is only alive
+    /// as long as the `Ref` returned by `RefCell::borrow()` is alive. So we can't return the
+    /// iterator, as that would drop the `Ref`. We can't return both, as it's not possible in Rust
+    /// to have a struct/tuple with a field that refers to another field.
+    pub fn iter<T>(&self, f: impl FnOnce(&mut dyn Iterator<Item = (&K, &V)>) -> T) -> T {
+        f(&mut self.0.borrow().iter().map(|(k, v)| (k, &**v)))
+    }
+}
+
+impl<K: Hash + Eq, V> Default for MonoHashMap<K, V> {
+    fn default() -> Self {
+        MonoHashMap(RefCell::new(Default::default()))
+    }
+}
+
+impl<K: Hash + Eq, V> AllocMap<K, V> for MonoHashMap<K, V> {
+    #[inline(always)]
+    fn contains_key<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> bool
+    where
+        K: Borrow<Q>,
+    {
+        self.0.get_mut().contains_key(k)
+    }
+
+    #[inline(always)]
+    fn contains_key_ref<Q: ?Sized + Hash + Eq>(&self, k: &Q) -> bool
+    where
+        K: Borrow<Q>,
+    {
+        self.0.borrow().contains_key(k)
+    }
+
+    #[inline(always)]
+    fn insert(&mut self, k: K, v: V) -> Option<V> {
+        self.0.get_mut().insert(k, Box::new(v)).map(|x| *x)
+    }
+
+    #[inline(always)]
+    fn remove<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> Option<V>
+    where
+        K: Borrow<Q>,
+    {
+        self.0.get_mut().remove(k).map(|x| *x)
+    }
+
+    #[inline(always)]
+    fn filter_map_collect<T>(&self, mut f: impl FnMut(&K, &V) -> Option<T>) -> Vec<T> {
+        self.0.borrow().iter().filter_map(move |(k, v)| f(k, v)).collect()
+    }
+
+    /// The most interesting method: Providing a shared reference without
+    /// holding the `RefCell` open, and inserting new data if the key
+    /// is not used yet.
+    /// `vacant` is called if the key is not found in the map;
+    /// if it returns a reference, that is used directly, if it
+    /// returns owned data, that is put into the map and returned.
+    #[inline(always)]
+    fn get_or<E>(&self, k: K, vacant: impl FnOnce() -> Result<V, E>) -> Result<&V, E> {
+        // We cannot hold borrow_mut while calling `vacant`, since that might have to do lookups in this very map.
+        if let Some(v) = self.0.borrow().get(&k) {
+            let val: *const V = &**v;
+            // This is safe because `val` points into a `Box`, that we know will not move and
+            // will also not be dropped as long as the shared reference `self` is live.
+            return unsafe { Ok(&*val) };
+        }
+        let new_val = Box::new(vacant()?);
+        let val: *const V = &**self.0.borrow_mut().try_insert(k, new_val).ok().unwrap();
+        // This is safe because `val` points into a `Box`, that we know will not move and
+        // will also not be dropped as long as the shared reference `self` is live.
+        unsafe { Ok(&*val) }
+    }
+
+    /// Read-only lookup (avoid read-acquiring the RefCell).
+    fn get(&self, k: K) -> Option<&V> {
+        let val: *const V = match self.0.borrow().get(&k) {
+            Some(v) => &**v,
+            None => return None,
+        };
+        // This is safe because `val` points into a `Box`, that we know will not move and
+        // will also not be dropped as long as the shared reference `self` is live.
+        unsafe { Some(&*val) }
+    }
+
+    #[inline(always)]
+    fn get_mut_or<E>(&mut self, k: K, vacant: impl FnOnce() -> Result<V, E>) -> Result<&mut V, E> {
+        match self.0.get_mut().entry(k) {
+            Entry::Occupied(e) => Ok(e.into_mut()),
+            Entry::Vacant(e) => {
+                let v = vacant()?;
+                Ok(e.insert(Box::new(v)))
+            }
+        }
+    }
+}
diff --git a/src/tools/miri/src/data_structures/range_object_map.rs b/src/tools/miri/src/data_structures/range_object_map.rs
new file mode 100644
index 00000000000..4c9cf3dc635
--- /dev/null
+++ b/src/tools/miri/src/data_structures/range_object_map.rs
@@ -0,0 +1,270 @@
+//! Implements a map from allocation ranges to data. This is somewhat similar to RangeMap, but the
+//! ranges and data are discrete and non-splittable -- they represent distinct "objects". An
+//! allocation in the map will always have the same range until explicitly removed
+
+use std::ops::{Index, IndexMut, Range};
+
+use rustc_abi::Size;
+use rustc_const_eval::interpret::AllocRange;
+
+#[derive(Clone, Debug)]
+struct Elem<T> {
+    /// The range covered by this element; never empty.
+    range: AllocRange,
+    /// The data stored for this element.
+    data: T,
+}
+
+/// Index of an allocation within the map
+type Position = usize;
+
+#[derive(Clone, Debug)]
+pub struct RangeObjectMap<T> {
+    v: Vec<Elem<T>>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum AccessType {
+    /// The access perfectly overlaps (same offset and range) with the existing allocation
+    PerfectlyOverlapping(Position),
+    /// The access does not touch any existing allocation
+    Empty(Position),
+    /// The access overlaps with one or more existing allocations
+    ImperfectlyOverlapping(Range<Position>),
+}
+
+impl<T> RangeObjectMap<T> {
+    pub fn new() -> Self {
+        Self { v: Vec::new() }
+    }
+
+    /// Finds the position of the allocation containing the given offset. If the offset is not
+    /// in an existing allocation, then returns Err containing the position
+    /// where such allocation should be inserted
+    fn find_offset(&self, offset: Size) -> Result<Position, Position> {
+        self.v.binary_search_by(|elem| -> std::cmp::Ordering {
+            if offset < elem.range.start {
+                // We are too far right (offset is further left).
+                // (`Greater` means that `elem` is greater than the desired target.)
+                std::cmp::Ordering::Greater
+            } else if offset >= elem.range.end() {
+                // We are too far left (offset is further right).
+                std::cmp::Ordering::Less
+            } else {
+                // This is it!
+                std::cmp::Ordering::Equal
+            }
+        })
+    }
+
+    /// Determines whether a given access on `range` overlaps with
+    /// an existing allocation
+    pub fn access_type(&self, range: AllocRange) -> AccessType {
+        match self.find_offset(range.start) {
+            Ok(pos) => {
+                // Start of the range belongs to an existing object, now let's check the overlapping situation
+                let elem = &self.v[pos];
+                // FIXME: derive Eq for AllocRange in rustc
+                if elem.range.start == range.start && elem.range.size == range.size {
+                    // Happy case: perfectly overlapping access
+                    AccessType::PerfectlyOverlapping(pos)
+                } else {
+                    // FIXME: add a last() method to AllocRange that returns the last inclusive offset (end() is exclusive)
+                    let end_pos = match self.find_offset(range.end() - Size::from_bytes(1)) {
+                        // If the end lands in an existing object, add one to get the exclusive position
+                        Ok(inclusive_pos) => inclusive_pos + 1,
+                        Err(exclusive_pos) => exclusive_pos,
+                    };
+
+                    AccessType::ImperfectlyOverlapping(pos..end_pos)
+                }
+            }
+            Err(pos) => {
+                // Start of the range doesn't belong to an existing object
+                match self.find_offset(range.end() - Size::from_bytes(1)) {
+                    // Neither does the end
+                    Err(end_pos) =>
+                        if pos == end_pos {
+                            // There's nothing between the start and the end, so the range thing is empty
+                            AccessType::Empty(pos)
+                        } else {
+                            // Otherwise we have entirely covered an existing object
+                            AccessType::ImperfectlyOverlapping(pos..end_pos)
+                        },
+                    // Otherwise at least part of it overlaps with something else
+                    Ok(end_pos) => AccessType::ImperfectlyOverlapping(pos..end_pos + 1),
+                }
+            }
+        }
+    }
+
+    /// Inserts an object and its occupied range at given position
+    // The Position can be calculated from AllocRange, but the only user of AllocationMap
+    // always calls access_type before calling insert/index/index_mut, and we don't
+    // want to repeat the binary search on each time, so we ask the caller to supply Position
+    pub fn insert_at_pos(&mut self, pos: Position, range: AllocRange, data: T) {
+        self.v.insert(pos, Elem { range, data });
+        // If we aren't the first element, then our start must be greater than the previous element's end
+        if pos > 0 {
+            assert!(self.v[pos - 1].range.end() <= range.start);
+        }
+        // If we aren't the last element, then our end must be smaller than next element's start
+        if pos < self.v.len() - 1 {
+            assert!(range.end() <= self.v[pos + 1].range.start);
+        }
+    }
+
+    pub fn remove_pos_range(&mut self, pos_range: Range<Position>) {
+        self.v.drain(pos_range);
+    }
+
+    pub fn remove_from_pos(&mut self, pos: Position) {
+        self.v.remove(pos);
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &T> {
+        self.v.iter().map(|e| &e.data)
+    }
+}
+
+impl<T> Index<Position> for RangeObjectMap<T> {
+    type Output = T;
+
+    fn index(&self, pos: Position) -> &Self::Output {
+        &self.v[pos].data
+    }
+}
+
+impl<T> IndexMut<Position> for RangeObjectMap<T> {
+    fn index_mut(&mut self, pos: Position) -> &mut Self::Output {
+        &mut self.v[pos].data
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rustc_const_eval::interpret::alloc_range;
+
+    use super::*;
+
+    #[test]
+    fn empty_map() {
+        // FIXME: make Size::from_bytes const
+        let four = Size::from_bytes(4);
+        let map = RangeObjectMap::<()>::new();
+
+        // Correctly tells where we should insert the first element (at position 0)
+        assert_eq!(map.find_offset(Size::from_bytes(3)), Err(0));
+
+        // Correctly tells the access type along with the supposed position
+        assert_eq!(map.access_type(alloc_range(Size::ZERO, four)), AccessType::Empty(0));
+    }
+
+    #[test]
+    #[should_panic]
+    fn no_overlapping_inserts() {
+        let four = Size::from_bytes(4);
+
+        let mut map = RangeObjectMap::<&str>::new();
+
+        // |_|_|_|_|#|#|#|#|_|_|_|_|...
+        //  0 1 2 3 4 5 6 7 8 9 a b c d
+        map.insert_at_pos(0, alloc_range(four, four), "#");
+        // |_|_|_|_|#|#|#|#|_|_|_|_|...
+        //  0 ^ ^ ^ ^ 5 6 7 8 9 a b c d
+        map.insert_at_pos(0, alloc_range(Size::from_bytes(1), four), "@");
+    }
+
+    #[test]
+    fn boundaries() {
+        let four = Size::from_bytes(4);
+
+        let mut map = RangeObjectMap::<&str>::new();
+
+        // |#|#|#|#|_|_|...
+        //  0 1 2 3 4 5
+        map.insert_at_pos(0, alloc_range(Size::ZERO, four), "#");
+        // |#|#|#|#|_|_|...
+        //  0 1 2 3 ^ 5
+        assert_eq!(map.find_offset(four), Err(1));
+        // |#|#|#|#|_|_|_|_|_|...
+        //  0 1 2 3 ^ ^ ^ ^ 8
+        assert_eq!(map.access_type(alloc_range(four, four)), AccessType::Empty(1));
+
+        let eight = Size::from_bytes(8);
+        // |#|#|#|#|_|_|_|_|@|@|@|@|_|_|...
+        //  0 1 2 3 4 5 6 7 8 9 a b c d
+        map.insert_at_pos(1, alloc_range(eight, four), "@");
+        // |#|#|#|#|_|_|_|_|@|@|@|@|_|_|...
+        //  0 1 2 3 4 5 6 ^ 8 9 a b c d
+        assert_eq!(map.find_offset(Size::from_bytes(7)), Err(1));
+        // |#|#|#|#|_|_|_|_|@|@|@|@|_|_|...
+        //  0 1 2 3 ^ ^ ^ ^ 8 9 a b c d
+        assert_eq!(map.access_type(alloc_range(four, four)), AccessType::Empty(1));
+    }
+
+    #[test]
+    fn perfectly_overlapping() {
+        let four = Size::from_bytes(4);
+
+        let mut map = RangeObjectMap::<&str>::new();
+
+        // |#|#|#|#|_|_|...
+        //  0 1 2 3 4 5
+        map.insert_at_pos(0, alloc_range(Size::ZERO, four), "#");
+        // |#|#|#|#|_|_|...
+        //  ^ ^ ^ ^ 4 5
+        assert_eq!(map.find_offset(Size::ZERO), Ok(0));
+        assert_eq!(
+            map.access_type(alloc_range(Size::ZERO, four)),
+            AccessType::PerfectlyOverlapping(0)
+        );
+
+        // |#|#|#|#|@|@|@|@|_|...
+        //  0 1 2 3 4 5 6 7 8
+        map.insert_at_pos(1, alloc_range(four, four), "@");
+        // |#|#|#|#|@|@|@|@|_|...
+        //  0 1 2 3 ^ ^ ^ ^ 8
+        assert_eq!(map.find_offset(four), Ok(1));
+        assert_eq!(map.access_type(alloc_range(four, four)), AccessType::PerfectlyOverlapping(1));
+    }
+
+    #[test]
+    fn straddling() {
+        let four = Size::from_bytes(4);
+
+        let mut map = RangeObjectMap::<&str>::new();
+
+        // |_|_|_|_|#|#|#|#|_|_|_|_|...
+        //  0 1 2 3 4 5 6 7 8 9 a b c d
+        map.insert_at_pos(0, alloc_range(four, four), "#");
+        // |_|_|_|_|#|#|#|#|_|_|_|_|...
+        //  0 1 ^ ^ ^ ^ 6 7 8 9 a b c d
+        assert_eq!(
+            map.access_type(alloc_range(Size::from_bytes(2), four)),
+            AccessType::ImperfectlyOverlapping(0..1)
+        );
+        // |_|_|_|_|#|#|#|#|_|_|_|_|...
+        //  0 1 2 3 4 5 ^ ^ ^ ^ a b c d
+        assert_eq!(
+            map.access_type(alloc_range(Size::from_bytes(6), four)),
+            AccessType::ImperfectlyOverlapping(0..1)
+        );
+        // |_|_|_|_|#|#|#|#|_|_|_|_|...
+        //  0 1 ^ ^ ^ ^ ^ ^ ^ ^ a b c d
+        assert_eq!(
+            map.access_type(alloc_range(Size::from_bytes(2), Size::from_bytes(8))),
+            AccessType::ImperfectlyOverlapping(0..1)
+        );
+
+        // |_|_|_|_|#|#|#|#|_|_|@|@|_|_|...
+        //  0 1 2 3 4 5 6 7 8 9 a b c d
+        map.insert_at_pos(1, alloc_range(Size::from_bytes(10), Size::from_bytes(2)), "@");
+        // |_|_|_|_|#|#|#|#|_|_|@|@|_|_|...
+        //  0 1 2 3 4 5 ^ ^ ^ ^ ^ ^ ^ ^
+        assert_eq!(
+            map.access_type(alloc_range(Size::from_bytes(6), Size::from_bytes(8))),
+            AccessType::ImperfectlyOverlapping(0..2)
+        );
+    }
+}
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index ca99d69b32d..642b7ee9840 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -75,16 +75,15 @@ mod alloc_addresses;
 mod borrow_tracker;
 mod clock;
 mod concurrency;
+mod data_structures;
 mod diagnostics;
 mod eval;
 mod helpers;
 mod intrinsics;
 mod machine;
 mod math;
-mod mono_hash_map;
 mod operator;
 mod provenance_gc;
-mod range_map;
 mod shims;
 
 // Establish a "crate-wide prelude": we often import `crate::*`.
@@ -132,6 +131,8 @@ pub use crate::concurrency::thread::{
     ThreadManager, TimeoutAnchor, TimeoutClock, UnblockKind,
 };
 pub use crate::concurrency::{GenmcConfig, GenmcCtx};
+pub use crate::data_structures::dedup_range_map::DedupRangeMap;
+pub use crate::data_structures::mono_hash_map::MonoHashMap;
 pub use crate::diagnostics::{
     EvalContextExt as _, NonHaltingDiagnostic, TerminationInfo, report_error,
 };
@@ -145,10 +146,8 @@ pub use crate::machine::{
     AllocExtra, DynMachineCallback, FrameExtra, MachineCallback, MemoryKind, MiriInterpCx,
     MiriInterpCxExt, MiriMachine, MiriMemoryKind, PrimitiveLayouts, Provenance, ProvenanceExtra,
 };
-pub use crate::mono_hash_map::MonoHashMap;
 pub use crate::operator::EvalContextExt as _;
 pub use crate::provenance_gc::{EvalContextExt as _, LiveAllocs, VisitProvenance, VisitWith};
-pub use crate::range_map::RangeMap;
 pub use crate::shims::EmulateItemResult;
 pub use crate::shims::env::{EnvVars, EvalContextExt as _};
 pub use crate::shims::foreign_items::{DynSym, EvalContextExt as _};
diff --git a/src/tools/miri/src/mono_hash_map.rs b/src/tools/miri/src/mono_hash_map.rs
deleted file mode 100644
index 220233f8ff5..00000000000
--- a/src/tools/miri/src/mono_hash_map.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-//! This is a "monotonic `FxHashMap`": A `FxHashMap` that, when shared, can be pushed to but not
-//! otherwise mutated. We also box items in the map. This means we can safely provide
-//! shared references into existing items in the `FxHashMap`, because they will not be dropped
-//! (from being removed) or moved (because they are boxed).
-//! The API is completely tailored to what `memory.rs` needs. It is still in
-//! a separate file to minimize the amount of code that has to care about the unsafety.
-
-use std::borrow::Borrow;
-use std::cell::RefCell;
-use std::collections::hash_map::Entry;
-use std::hash::Hash;
-
-use rustc_data_structures::fx::FxHashMap;
-
-use crate::AllocMap;
-
-#[derive(Debug, Clone)]
-pub struct MonoHashMap<K: Hash + Eq, V>(RefCell<FxHashMap<K, Box<V>>>);
-
-impl<K: Hash + Eq, V> MonoHashMap<K, V> {
-    /// This function exists for priroda to be able to iterate over all evaluator memory.
-    ///
-    /// The function is somewhat roundabout with the closure argument because internally the
-    /// `MonoHashMap` uses a `RefCell`. When iterating over the `FxHashMap` inside the `RefCell`,
-    /// we need to keep a borrow to the `FxHashMap` inside the iterator. The borrow is only alive
-    /// as long as the `Ref` returned by `RefCell::borrow()` is alive. So we can't return the
-    /// iterator, as that would drop the `Ref`. We can't return both, as it's not possible in Rust
-    /// to have a struct/tuple with a field that refers to another field.
-    pub fn iter<T>(&self, f: impl FnOnce(&mut dyn Iterator<Item = (&K, &V)>) -> T) -> T {
-        f(&mut self.0.borrow().iter().map(|(k, v)| (k, &**v)))
-    }
-}
-
-impl<K: Hash + Eq, V> Default for MonoHashMap<K, V> {
-    fn default() -> Self {
-        MonoHashMap(RefCell::new(Default::default()))
-    }
-}
-
-impl<K: Hash + Eq, V> AllocMap<K, V> for MonoHashMap<K, V> {
-    #[inline(always)]
-    fn contains_key<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> bool
-    where
-        K: Borrow<Q>,
-    {
-        self.0.get_mut().contains_key(k)
-    }
-
-    #[inline(always)]
-    fn contains_key_ref<Q: ?Sized + Hash + Eq>(&self, k: &Q) -> bool
-    where
-        K: Borrow<Q>,
-    {
-        self.0.borrow().contains_key(k)
-    }
-
-    #[inline(always)]
-    fn insert(&mut self, k: K, v: V) -> Option<V> {
-        self.0.get_mut().insert(k, Box::new(v)).map(|x| *x)
-    }
-
-    #[inline(always)]
-    fn remove<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> Option<V>
-    where
-        K: Borrow<Q>,
-    {
-        self.0.get_mut().remove(k).map(|x| *x)
-    }
-
-    #[inline(always)]
-    fn filter_map_collect<T>(&self, mut f: impl FnMut(&K, &V) -> Option<T>) -> Vec<T> {
-        self.0.borrow().iter().filter_map(move |(k, v)| f(k, v)).collect()
-    }
-
-    /// The most interesting method: Providing a shared reference without
-    /// holding the `RefCell` open, and inserting new data if the key
-    /// is not used yet.
-    /// `vacant` is called if the key is not found in the map;
-    /// if it returns a reference, that is used directly, if it
-    /// returns owned data, that is put into the map and returned.
-    #[inline(always)]
-    fn get_or<E>(&self, k: K, vacant: impl FnOnce() -> Result<V, E>) -> Result<&V, E> {
-        // We cannot hold borrow_mut while calling `vacant`, since that might have to do lookups in this very map.
-        if let Some(v) = self.0.borrow().get(&k) {
-            let val: *const V = &**v;
-            // This is safe because `val` points into a `Box`, that we know will not move and
-            // will also not be dropped as long as the shared reference `self` is live.
-            return unsafe { Ok(&*val) };
-        }
-        let new_val = Box::new(vacant()?);
-        let val: *const V = &**self.0.borrow_mut().try_insert(k, new_val).ok().unwrap();
-        // This is safe because `val` points into a `Box`, that we know will not move and
-        // will also not be dropped as long as the shared reference `self` is live.
-        unsafe { Ok(&*val) }
-    }
-
-    /// Read-only lookup (avoid read-acquiring the RefCell).
-    fn get(&self, k: K) -> Option<&V> {
-        let val: *const V = match self.0.borrow().get(&k) {
-            Some(v) => &**v,
-            None => return None,
-        };
-        // This is safe because `val` points into a `Box`, that we know will not move and
-        // will also not be dropped as long as the shared reference `self` is live.
-        unsafe { Some(&*val) }
-    }
-
-    #[inline(always)]
-    fn get_mut_or<E>(&mut self, k: K, vacant: impl FnOnce() -> Result<V, E>) -> Result<&mut V, E> {
-        match self.0.get_mut().entry(k) {
-            Entry::Occupied(e) => Ok(e.into_mut()),
-            Entry::Vacant(e) => {
-                let v = vacant()?;
-                Ok(e.insert(Box::new(v)))
-            }
-        }
-    }
-}
diff --git a/src/tools/miri/src/range_map.rs b/src/tools/miri/src/range_map.rs
deleted file mode 100644
index 29a5a8537a4..00000000000
--- a/src/tools/miri/src/range_map.rs
+++ /dev/null
@@ -1,344 +0,0 @@
-//! Implements a map from integer indices to data.
-//! Rather than storing data for every index, internally, this maps entire ranges to the data.
-//! To this end, the APIs all work on ranges, not on individual integers. Ranges are split as
-//! necessary (e.g., when [0,5) is first associated with X, and then [1,2) is mutated).
-//! Users must not depend on whether a range is coalesced or not, even though this is observable
-//! via the iteration APIs.
-
-use std::ops;
-
-use rustc_abi::Size;
-
-#[derive(Clone, Debug)]
-struct Elem<T> {
-    /// The range covered by this element; never empty.
-    range: ops::Range<u64>,
-    /// The data stored for this element.
-    data: T,
-}
-#[derive(Clone, Debug)]
-pub struct RangeMap<T> {
-    v: Vec<Elem<T>>,
-}
-
-impl<T> RangeMap<T> {
-    /// Creates a new `RangeMap` for the given size, and with the given initial value used for
-    /// the entire range.
-    #[inline(always)]
-    pub fn new(size: Size, init: T) -> RangeMap<T> {
-        let size = size.bytes();
-        let v = if size > 0 { vec![Elem { range: 0..size, data: init }] } else { Vec::new() };
-        RangeMap { v }
-    }
-
-    pub fn size(&self) -> Size {
-        let size = self.v.last().map(|x| x.range.end).unwrap_or(0);
-        Size::from_bytes(size)
-    }
-
-    /// Finds the index containing the given offset.
-    fn find_offset(&self, offset: u64) -> usize {
-        self.v
-            .binary_search_by(|elem| -> std::cmp::Ordering {
-                if offset < elem.range.start {
-                    // We are too far right (offset is further left).
-                    // (`Greater` means that `elem` is greater than the desired target.)
-                    std::cmp::Ordering::Greater
-                } else if offset >= elem.range.end {
-                    // We are too far left (offset is further right).
-                    std::cmp::Ordering::Less
-                } else {
-                    // This is it!
-                    std::cmp::Ordering::Equal
-                }
-            })
-            .unwrap()
-    }
-
-    /// Provides read-only iteration over everything in the given range. This does
-    /// *not* split items if they overlap with the edges. Do not use this to mutate
-    /// through interior mutability.
-    ///
-    /// The iterator also provides the range of the given element.
-    /// How exactly the ranges are split can differ even for otherwise identical
-    /// maps, so user-visible behavior should never depend on the exact range.
-    pub fn iter(&self, offset: Size, len: Size) -> impl Iterator<Item = (ops::Range<u64>, &T)> {
-        let offset = offset.bytes();
-        let len = len.bytes();
-        // Compute a slice starting with the elements we care about.
-        let slice: &[Elem<T>] = if len == 0 {
-            // We just need any empty iterator. We don't even want to
-            // yield the element that surrounds this position.
-            &[]
-        } else {
-            let first_idx = self.find_offset(offset);
-            &self.v[first_idx..]
-        };
-        // The first offset that is not included any more.
-        let end = offset + len;
-        assert!(end <= self.size().bytes(), "iterating beyond the bounds of this RangeMap");
-        slice
-            .iter()
-            .take_while(move |elem| elem.range.start < end)
-            .map(|elem| (elem.range.clone(), &elem.data))
-    }
-
-    /// Provides mutable iteration over all elements.
-    /// The iterator also provides the range of the given element.
-    /// How exactly the ranges are split can differ even for otherwise identical
-    /// maps, so user-visible behavior should never depend on the exact range.
-    pub fn iter_mut_all(&mut self) -> impl Iterator<Item = (ops::Range<u64>, &mut T)> {
-        self.v.iter_mut().map(|elem| (elem.range.clone(), &mut elem.data))
-    }
-
-    /// Provides iteration over all elements.
-    /// The iterator also provides the range of the given element.
-    /// How exactly the ranges are split can differ even for otherwise identical
-    /// maps, so user-visible behavior should never depend on the exact range.
-    pub fn iter_all(&self) -> impl Iterator<Item = (ops::Range<u64>, &T)> {
-        self.v.iter().map(|elem| (elem.range.clone(), &elem.data))
-    }
-
-    // Splits the element situated at the given `index`, such that the 2nd one starts at offset
-    // `split_offset`. Do nothing if the element already starts there.
-    // Returns whether a split was necessary.
-    fn split_index(&mut self, index: usize, split_offset: u64) -> bool
-    where
-        T: Clone,
-    {
-        let elem = &mut self.v[index];
-        if split_offset == elem.range.start || split_offset == elem.range.end {
-            // Nothing to do.
-            return false;
-        }
-        debug_assert!(
-            elem.range.contains(&split_offset),
-            "the `split_offset` is not in the element to be split"
-        );
-
-        // Now we really have to split. Reduce length of first element.
-        let second_range = split_offset..elem.range.end;
-        elem.range.end = split_offset;
-        // Copy the data, and insert second element.
-        let second = Elem { range: second_range, data: elem.data.clone() };
-        self.v.insert(index + 1, second);
-        true
-    }
-
-    /// Provides mutable iteration over everything in the given range. As a side-effect,
-    /// this will split entries in the map that are only partially hit by the given range,
-    /// to make sure that when they are mutated, the effect is constrained to the given range.
-    /// Moreover, this will opportunistically merge neighbouring equal blocks.
-    ///
-    /// The iterator also provides the range of the given element.
-    /// How exactly the ranges are split (both prior to and resulting from the execution of this
-    /// function) can differ even for otherwise identical maps,
-    /// so user-visible behavior should never depend on the exact range.
-    pub fn iter_mut(
-        &mut self,
-        offset: Size,
-        len: Size,
-    ) -> impl Iterator<Item = (ops::Range<u64>, &mut T)>
-    where
-        T: Clone + PartialEq,
-    {
-        let offset = offset.bytes();
-        let len = len.bytes();
-        // Compute a slice containing exactly the elements we care about
-        let slice: &mut [Elem<T>] = if len == 0 {
-            // We just need any empty iterator. We don't even want to
-            // yield the element that surrounds this position, nor do
-            // any splitting.
-            &mut []
-        } else {
-            // Make sure we got a clear beginning
-            let mut first_idx = self.find_offset(offset);
-            if self.split_index(first_idx, offset) {
-                // The newly created 2nd element is ours
-                first_idx += 1;
-            }
-            // No more mutation.
-            let first_idx = first_idx;
-            // Find our end. Linear scan, but that's ok because the iteration
-            // is doing the same linear scan anyway -- no increase in complexity.
-            // We combine this scan with a scan for duplicates that we can merge, to reduce
-            // the number of elements.
-            // We stop searching after the first "block" of size 1, to avoid spending excessive
-            // amounts of time on the merging.
-            let mut equal_since_idx = first_idx;
-            // Once we see too many non-mergeable blocks, we stop.
-            // The initial value is chosen via... magic. Benchmarking and magic.
-            let mut successful_merge_count = 3usize;
-            // When the loop is done, this is the first excluded element.
-            let mut end_idx = first_idx;
-            loop {
-                // Compute if `end` is the last element we need to look at.
-                let done = self.v[end_idx].range.end >= offset + len;
-                // We definitely need to include `end`, so move the index.
-                end_idx += 1;
-                debug_assert!(
-                    done || end_idx < self.v.len(),
-                    "iter_mut: end-offset {} is out-of-bounds",
-                    offset + len
-                );
-                // see if we want to merge everything in `equal_since..end` (exclusive at the end!)
-                if successful_merge_count > 0 {
-                    if done || self.v[end_idx].data != self.v[equal_since_idx].data {
-                        // Everything in `equal_since..end` was equal. Make them just one element covering
-                        // the entire range.
-                        let removed_elems = end_idx - equal_since_idx - 1; // number of elements that we would remove
-                        if removed_elems > 0 {
-                            // Adjust the range of the first element to cover all of them.
-                            let equal_until = self.v[end_idx - 1].range.end; // end of range of last of the equal elements
-                            self.v[equal_since_idx].range.end = equal_until;
-                            // Delete the rest of them.
-                            self.v.splice(equal_since_idx + 1..end_idx, std::iter::empty());
-                            // Adjust `end_idx` because we made the list shorter.
-                            end_idx -= removed_elems;
-                            // Adjust the count for the cutoff.
-                            successful_merge_count += removed_elems;
-                        } else {
-                            // Adjust the count for the cutoff.
-                            successful_merge_count -= 1;
-                        }
-                        // Go on scanning for the next block starting here.
-                        equal_since_idx = end_idx;
-                    }
-                }
-                // Leave loop if this is the last element.
-                if done {
-                    break;
-                }
-            }
-            // Move to last included instead of first excluded index.
-            let end_idx = end_idx - 1;
-            // We need to split the end as well. Even if this performs a
-            // split, we don't have to adjust our index as we only care about
-            // the first part of the split.
-            self.split_index(end_idx, offset + len);
-            // Now we yield the slice. `end` is inclusive.
-            &mut self.v[first_idx..=end_idx]
-        };
-        slice.iter_mut().map(|elem| (elem.range.clone(), &mut elem.data))
-    }
-
-    /// Remove all adjacent duplicates
-    pub fn merge_adjacent_thorough(&mut self)
-    where
-        T: PartialEq,
-    {
-        let clean = Vec::with_capacity(self.v.len());
-        for elem in std::mem::replace(&mut self.v, clean) {
-            if let Some(prev) = self.v.last_mut() {
-                if prev.data == elem.data {
-                    assert_eq!(prev.range.end, elem.range.start);
-                    prev.range.end = elem.range.end;
-                    continue;
-                }
-            }
-            self.v.push(elem);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// Query the map at every offset in the range and collect the results.
-    fn to_vec<T: Copy>(map: &RangeMap<T>, offset: u64, len: u64) -> Vec<T> {
-        (offset..offset + len)
-            .map(|i| {
-                map.iter(Size::from_bytes(i), Size::from_bytes(1)).next().map(|(_, &t)| t).unwrap()
-            })
-            .collect()
-    }
-
-    #[test]
-    fn basic_insert() {
-        let mut map = RangeMap::<i32>::new(Size::from_bytes(20), -1);
-        // Insert.
-        for (_, x) in map.iter_mut(Size::from_bytes(10), Size::from_bytes(1)) {
-            *x = 42;
-        }
-        // Check.
-        assert_eq!(to_vec(&map, 10, 1), vec![42]);
-        assert_eq!(map.v.len(), 3);
-
-        // Insert with size 0.
-        for (_, x) in map.iter_mut(Size::from_bytes(10), Size::from_bytes(0)) {
-            *x = 19;
-        }
-        for (_, x) in map.iter_mut(Size::from_bytes(11), Size::from_bytes(0)) {
-            *x = 19;
-        }
-        assert_eq!(to_vec(&map, 10, 2), vec![42, -1]);
-        assert_eq!(map.v.len(), 3);
-    }
-
-    #[test]
-    fn gaps() {
-        let mut map = RangeMap::<i32>::new(Size::from_bytes(20), -1);
-        for (_, x) in map.iter_mut(Size::from_bytes(11), Size::from_bytes(1)) {
-            *x = 42;
-        }
-        for (_, x) in map.iter_mut(Size::from_bytes(15), Size::from_bytes(1)) {
-            *x = 43;
-        }
-        assert_eq!(map.v.len(), 5);
-        assert_eq!(to_vec(&map, 10, 10), vec![-1, 42, -1, -1, -1, 43, -1, -1, -1, -1]);
-
-        for (_, x) in map.iter_mut(Size::from_bytes(10), Size::from_bytes(10)) {
-            if *x < 42 {
-                *x = 23;
-            }
-        }
-        assert_eq!(map.v.len(), 6);
-        assert_eq!(to_vec(&map, 10, 10), vec![23, 42, 23, 23, 23, 43, 23, 23, 23, 23]);
-        assert_eq!(to_vec(&map, 13, 5), vec![23, 23, 43, 23, 23]);
-
-        for (_, x) in map.iter_mut(Size::from_bytes(15), Size::from_bytes(5)) {
-            *x = 19;
-        }
-        assert_eq!(map.v.len(), 6);
-        assert_eq!(to_vec(&map, 10, 10), vec![23, 42, 23, 23, 23, 19, 19, 19, 19, 19]);
-        // Should be seeing two blocks with 19.
-        assert_eq!(
-            map.iter(Size::from_bytes(15), Size::from_bytes(2))
-                .map(|(_, &t)| t)
-                .collect::<Vec<_>>(),
-            vec![19, 19]
-        );
-
-        // A NOP `iter_mut` should trigger merging.
-        for _ in map.iter_mut(Size::from_bytes(15), Size::from_bytes(5)) {}
-        assert_eq!(map.v.len(), 5);
-        assert_eq!(to_vec(&map, 10, 10), vec![23, 42, 23, 23, 23, 19, 19, 19, 19, 19]);
-    }
-
-    #[test]
-    #[should_panic]
-    fn out_of_range_iter_mut() {
-        let mut map = RangeMap::<i32>::new(Size::from_bytes(20), -1);
-        let _ = map.iter_mut(Size::from_bytes(11), Size::from_bytes(11));
-    }
-
-    #[test]
-    #[should_panic]
-    fn out_of_range_iter() {
-        let map = RangeMap::<i32>::new(Size::from_bytes(20), -1);
-        let _ = map.iter(Size::from_bytes(11), Size::from_bytes(11));
-    }
-
-    #[test]
-    fn empty_map_iter() {
-        let map = RangeMap::<i32>::new(Size::from_bytes(0), -1);
-        let _ = map.iter(Size::from_bytes(0), Size::from_bytes(0));
-    }
-
-    #[test]
-    fn empty_map_iter_mut() {
-        let mut map = RangeMap::<i32>::new(Size::from_bytes(0), -1);
-        let _ = map.iter_mut(Size::from_bytes(0), Size::from_bytes(0));
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From b4e68e212ece6896ea574c6345e14d4350c5c517 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bkersting@google.com>
Date: Wed, 2 Jul 2025 20:33:28 +0300
Subject: Respect endianness correctly in CheckEnums test suite

The endianness can change the test expectation for the enum check.
This change is fixing the failing tests on big endian by changing
the tests so that they behave the same as on little endian.
---
 tests/ui/mir/enum/convert_non_enum_break.rs        | 20 ---------------
 tests/ui/mir/enum/convert_non_enum_niche_break.rs  | 27 --------------------
 tests/ui/mir/enum/convert_non_enum_niche_ok.rs     | 29 ----------------------
 tests/ui/mir/enum/convert_non_enum_ok.rs           | 20 ---------------
 tests/ui/mir/enum/convert_non_integer_break.rs     | 19 ++++++++++++++
 .../ui/mir/enum/convert_non_integer_niche_break.rs | 27 ++++++++++++++++++++
 tests/ui/mir/enum/convert_non_integer_niche_ok.rs  | 29 ++++++++++++++++++++++
 tests/ui/mir/enum/convert_non_integer_ok.rs        | 19 ++++++++++++++
 tests/ui/mir/enum/niche_option_tuple_break.rs      | 11 ++++----
 tests/ui/mir/enum/with_niche_int_break.rs          |  4 +--
 10 files changed, 102 insertions(+), 103 deletions(-)
 delete mode 100644 tests/ui/mir/enum/convert_non_enum_break.rs
 delete mode 100644 tests/ui/mir/enum/convert_non_enum_niche_break.rs
 delete mode 100644 tests/ui/mir/enum/convert_non_enum_niche_ok.rs
 delete mode 100644 tests/ui/mir/enum/convert_non_enum_ok.rs
 create mode 100644 tests/ui/mir/enum/convert_non_integer_break.rs
 create mode 100644 tests/ui/mir/enum/convert_non_integer_niche_break.rs
 create mode 100644 tests/ui/mir/enum/convert_non_integer_niche_ok.rs
 create mode 100644 tests/ui/mir/enum/convert_non_integer_ok.rs

diff --git a/tests/ui/mir/enum/convert_non_enum_break.rs b/tests/ui/mir/enum/convert_non_enum_break.rs
deleted file mode 100644
index de062c39907..00000000000
--- a/tests/ui/mir/enum/convert_non_enum_break.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ run-fail
-//@ compile-flags: -C debug-assertions
-//@ error-pattern: trying to construct an enum from an invalid value 0x10000
-
-#[allow(dead_code)]
-#[repr(u32)]
-enum Foo {
-    A,
-    B,
-}
-
-#[allow(dead_code)]
-struct Bar {
-    a: u16,
-    b: u16,
-}
-
-fn main() {
-    let _val: Foo = unsafe { std::mem::transmute::<_, Foo>(Bar { a: 0, b: 1 }) };
-}
diff --git a/tests/ui/mir/enum/convert_non_enum_niche_break.rs b/tests/ui/mir/enum/convert_non_enum_niche_break.rs
deleted file mode 100644
index 9ff4849c5b1..00000000000
--- a/tests/ui/mir/enum/convert_non_enum_niche_break.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ run-fail
-//@ compile-flags: -C debug-assertions
-//@ error-pattern: trying to construct an enum from an invalid value 0x5
-
-#[allow(dead_code)]
-#[repr(u16)]
-enum Mix {
-    A,
-    B(u16),
-}
-
-#[allow(dead_code)]
-enum Nested {
-    C(Mix),
-    D,
-    E,
-}
-
-#[allow(dead_code)]
-struct Bar {
-    a: u16,
-    b: u16,
-}
-
-fn main() {
-    let _val: Nested = unsafe { std::mem::transmute::<_, Nested>(Bar { a: 5, b: 0 }) };
-}
diff --git a/tests/ui/mir/enum/convert_non_enum_niche_ok.rs b/tests/ui/mir/enum/convert_non_enum_niche_ok.rs
deleted file mode 100644
index 24027da5458..00000000000
--- a/tests/ui/mir/enum/convert_non_enum_niche_ok.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//@ run-pass
-//@ compile-flags: -C debug-assertions
-
-#[allow(dead_code)]
-#[repr(u16)]
-enum Mix {
-    A,
-    B(u16),
-}
-
-#[allow(dead_code)]
-enum Nested {
-    C(Mix),
-    D,
-    E,
-}
-
-#[allow(dead_code)]
-struct Bar {
-    a: u16,
-    b: u16,
-}
-
-fn main() {
-    let _val: Nested = unsafe { std::mem::transmute::<_, Nested>(Bar { a: 0, b: 0 }) };
-    let _val: Nested = unsafe { std::mem::transmute::<_, Nested>(Bar { a: 1, b: 0 }) };
-    let _val: Nested = unsafe { std::mem::transmute::<_, Nested>(Bar { a: 2, b: 0 }) };
-    let _val: Nested = unsafe { std::mem::transmute::<_, Nested>(Bar { a: 3, b: 0 }) };
-}
diff --git a/tests/ui/mir/enum/convert_non_enum_ok.rs b/tests/ui/mir/enum/convert_non_enum_ok.rs
deleted file mode 100644
index 37fc64342ca..00000000000
--- a/tests/ui/mir/enum/convert_non_enum_ok.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ run-pass
-//@ compile-flags: -C debug-assertions
-
-#[allow(dead_code)]
-#[repr(u32)]
-enum Foo {
-    A,
-    B,
-}
-
-#[allow(dead_code)]
-struct Bar {
-    a: u16,
-    b: u16,
-}
-
-fn main() {
-    let _val: Foo = unsafe { std::mem::transmute::<_, Foo>(Bar { a: 0, b: 0 }) };
-    let _val: Foo = unsafe { std::mem::transmute::<_, Foo>(Bar { a: 1, b: 0 }) };
-}
diff --git a/tests/ui/mir/enum/convert_non_integer_break.rs b/tests/ui/mir/enum/convert_non_integer_break.rs
new file mode 100644
index 00000000000..29795190bf6
--- /dev/null
+++ b/tests/ui/mir/enum/convert_non_integer_break.rs
@@ -0,0 +1,19 @@
+//@ run-fail
+//@ compile-flags: -C debug-assertions
+//@ error-pattern: trying to construct an enum from an invalid value
+
+#[allow(dead_code)]
+#[repr(u32)]
+enum Foo {
+    A,
+    B,
+}
+
+#[allow(dead_code)]
+struct Bar {
+    a: u32,
+}
+
+fn main() {
+    let _val: Foo = unsafe { std::mem::transmute::<_, Foo>(Bar { a: 3 }) };
+}
diff --git a/tests/ui/mir/enum/convert_non_integer_niche_break.rs b/tests/ui/mir/enum/convert_non_integer_niche_break.rs
new file mode 100644
index 00000000000..9ff4849c5b1
--- /dev/null
+++ b/tests/ui/mir/enum/convert_non_integer_niche_break.rs
@@ -0,0 +1,27 @@
+//@ run-fail
+//@ compile-flags: -C debug-assertions
+//@ error-pattern: trying to construct an enum from an invalid value 0x5
+
+#[allow(dead_code)]
+#[repr(u16)]
+enum Mix {
+    A,
+    B(u16),
+}
+
+#[allow(dead_code)]
+enum Nested {
+    C(Mix),
+    D,
+    E,
+}
+
+#[allow(dead_code)]
+struct Bar {
+    a: u16,
+    b: u16,
+}
+
+fn main() {
+    let _val: Nested = unsafe { std::mem::transmute::<_, Nested>(Bar { a: 5, b: 0 }) };
+}
diff --git a/tests/ui/mir/enum/convert_non_integer_niche_ok.rs b/tests/ui/mir/enum/convert_non_integer_niche_ok.rs
new file mode 100644
index 00000000000..24027da5458
--- /dev/null
+++ b/tests/ui/mir/enum/convert_non_integer_niche_ok.rs
@@ -0,0 +1,29 @@
+//@ run-pass
+//@ compile-flags: -C debug-assertions
+
+#[allow(dead_code)]
+#[repr(u16)]
+enum Mix {
+    A,
+    B(u16),
+}
+
+#[allow(dead_code)]
+enum Nested {
+    C(Mix),
+    D,
+    E,
+}
+
+#[allow(dead_code)]
+struct Bar {
+    a: u16,
+    b: u16,
+}
+
+fn main() {
+    let _val: Nested = unsafe { std::mem::transmute::<_, Nested>(Bar { a: 0, b: 0 }) };
+    let _val: Nested = unsafe { std::mem::transmute::<_, Nested>(Bar { a: 1, b: 0 }) };
+    let _val: Nested = unsafe { std::mem::transmute::<_, Nested>(Bar { a: 2, b: 0 }) };
+    let _val: Nested = unsafe { std::mem::transmute::<_, Nested>(Bar { a: 3, b: 0 }) };
+}
diff --git a/tests/ui/mir/enum/convert_non_integer_ok.rs b/tests/ui/mir/enum/convert_non_integer_ok.rs
new file mode 100644
index 00000000000..c9831531386
--- /dev/null
+++ b/tests/ui/mir/enum/convert_non_integer_ok.rs
@@ -0,0 +1,19 @@
+//@ run-pass
+//@ compile-flags: -C debug-assertions
+
+#[allow(dead_code)]
+#[repr(u32)]
+enum Foo {
+    A,
+    B,
+}
+
+#[allow(dead_code)]
+struct Bar {
+    a: u32,
+}
+
+fn main() {
+    let _val: Foo = unsafe { std::mem::transmute::<_, Foo>(Bar { a: 0 }) };
+    let _val: Foo = unsafe { std::mem::transmute::<_, Foo>(Bar { a: 1 }) };
+}
diff --git a/tests/ui/mir/enum/niche_option_tuple_break.rs b/tests/ui/mir/enum/niche_option_tuple_break.rs
index 43eef3a4cc5..affdc4784a3 100644
--- a/tests/ui/mir/enum/niche_option_tuple_break.rs
+++ b/tests/ui/mir/enum/niche_option_tuple_break.rs
@@ -1,8 +1,9 @@
 //@ run-fail
 //@ compile-flags: -C debug-assertions
-//@ error-pattern: trying to construct an enum from an invalid value 0x3
+//@ error-pattern: trying to construct an enum from an invalid value
 
 #[allow(dead_code)]
+#[repr(u32)]
 enum Foo {
     A,
     B,
@@ -10,11 +11,11 @@ enum Foo {
 
 #[allow(dead_code)]
 struct Bar {
-    a: usize,
-    b: usize,
+    a: u32,
+    b: u32,
 }
 
 fn main() {
-    let _val: Option<(usize, Foo)> =
-        unsafe { std::mem::transmute::<_, Option<(usize, Foo)>>(Bar { a: 3, b: 3 }) };
+    let _val: Option<(u32, Foo)> =
+        unsafe { std::mem::transmute::<_, Option<(u32, Foo)>>(Bar { a: 3, b: 3 }) };
 }
diff --git a/tests/ui/mir/enum/with_niche_int_break.rs b/tests/ui/mir/enum/with_niche_int_break.rs
index 0ec60a33564..6a97eaa8f4f 100644
--- a/tests/ui/mir/enum/with_niche_int_break.rs
+++ b/tests/ui/mir/enum/with_niche_int_break.rs
@@ -1,6 +1,6 @@
 //@ run-fail
 //@ compile-flags: -C debug-assertions
-//@ error-pattern: trying to construct an enum from an invalid value 0x4
+//@ error-pattern: trying to construct an enum from an invalid value
 
 #[allow(dead_code)]
 #[repr(u16)]
@@ -17,5 +17,5 @@ enum Nested {
 }
 
 fn main() {
-    let _val: Nested = unsafe { std::mem::transmute::<u32, Nested>(4) };
+    let _val: Nested = unsafe { std::mem::transmute::<u32, Nested>(u32::MAX) };
 }
-- 
cgit 1.4.1-3-g733a5


From 429deed03a1aa6814ef0431c2662973cf4942462 Mon Sep 17 00:00:00 2001
From: mejrs <59372212+mejrs@users.noreply.github.com>
Date: Mon, 7 Jul 2025 17:44:36 +0200
Subject: Port #[rustc_dummy]

---
 compiler/rustc_attr_data_structures/src/attributes.rs |  3 +++
 .../src/encode_cross_crate.rs                         |  1 +
 compiler/rustc_attr_parsing/src/attributes/dummy.rs   | 19 +++++++++++++++++++
 compiler/rustc_attr_parsing/src/attributes/mod.rs     |  1 +
 compiler/rustc_attr_parsing/src/context.rs            |  2 ++
 compiler/rustc_passes/src/check_attr.rs               |  3 ++-
 6 files changed, 28 insertions(+), 1 deletion(-)
 create mode 100644 compiler/rustc_attr_parsing/src/attributes/dummy.rs

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 2cbb7270785..f9da7fa0b3a 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -240,6 +240,9 @@ pub enum AttributeKind {
     /// Represents [`#[doc]`](https://doc.rust-lang.org/stable/rustdoc/write-documentation/the-doc-attribute.html).
     DocComment { style: AttrStyle, kind: CommentKind, span: Span, comment: Symbol },
 
+    /// Represents `#[rustc_dummy]`.
+    Dummy,
+
     /// Represents [`#[export_name]`](https://doc.rust-lang.org/reference/abi.html#the-export_name-attribute).
     ExportName {
         /// The name to export this item with.
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index a6ae49d2808..34eaa5eff14 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -25,6 +25,7 @@ impl AttributeKind {
             ConstStabilityIndirect => No,
             Deprecation { .. } => Yes,
             DocComment { .. } => Yes,
+            Dummy => No,
             ExportName { .. } => Yes,
             Ignore { .. } => No,
             Inline(..) => No,
diff --git a/compiler/rustc_attr_parsing/src/attributes/dummy.rs b/compiler/rustc_attr_parsing/src/attributes/dummy.rs
new file mode 100644
index 00000000000..8a9b94fb1ff
--- /dev/null
+++ b/compiler/rustc_attr_parsing/src/attributes/dummy.rs
@@ -0,0 +1,19 @@
+use rustc_attr_data_structures::AttributeKind;
+use rustc_feature::{AttributeTemplate, template};
+use rustc_span::{Symbol, sym};
+
+use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
+use crate::context::{AcceptContext, Stage};
+use crate::parser::ArgParser;
+
+pub(crate) struct DummyParser;
+impl<S: Stage> SingleAttributeParser<S> for DummyParser {
+    const PATH: &[Symbol] = &[sym::rustc_dummy];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Ignore;
+    const TEMPLATE: AttributeTemplate = template!(Word); // Anything, really
+
+    fn convert(_: &mut AcceptContext<'_, '_, S>, _: &ArgParser<'_>) -> Option<AttributeKind> {
+        Some(AttributeKind::Dummy)
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
index ba7572434df..c6ea15b2338 100644
--- a/compiler/rustc_attr_parsing/src/attributes/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -30,6 +30,7 @@ pub(crate) mod cfg;
 pub(crate) mod codegen_attrs;
 pub(crate) mod confusables;
 pub(crate) mod deprecation;
+pub(crate) mod dummy;
 pub(crate) mod inline;
 pub(crate) mod link_attrs;
 pub(crate) mod lint_helpers;
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 939f4a6fde7..6ebd01f10c6 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -21,6 +21,7 @@ use crate::attributes::codegen_attrs::{
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::deprecation::DeprecationParser;
+use crate::attributes::dummy::DummyParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
 use crate::attributes::link_attrs::{LinkNameParser, LinkSectionParser};
 use crate::attributes::lint_helpers::{AsPtrParser, PassByValueParser, PubTransparentParser};
@@ -127,6 +128,7 @@ attribute_parsers!(
 
         // tidy-alphabetical-start
         Single<DeprecationParser>,
+        Single<DummyParser>,
         Single<ExportNameParser>,
         Single<IgnoreParser>,
         Single<InlineParser>,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 9e4e78c1db6..12986c75631 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -207,7 +207,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 Attribute::Parsed(
                     AttributeKind::BodyStability { .. }
                     | AttributeKind::ConstStabilityIndirect
-                    | AttributeKind::MacroTransparency(_),
+                    | AttributeKind::MacroTransparency(_)
+                    | AttributeKind::Dummy,
                 ) => { /* do nothing  */ }
                 Attribute::Parsed(AttributeKind::AsPtr(attr_span)) => {
                     self.check_applied_to_fn_or_method(hir_id, *attr_span, span, target)
-- 
cgit 1.4.1-3-g733a5


From 7ec8c89c1501881d3435556148cc27e4cefa43b8 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Mon, 7 Jul 2025 10:42:08 -0700
Subject: Update intro blurb in `wasm32-wasip1` docs

I was reading over this documentation in light of the effort to enlist
more maintainers for Tier 2 targets and figured it was time for a
refresh of this documentation now that historical renames/etc have all
become a thing of the past. No new major changes to this documentation,
mostly just wanted to update it and reflect the modern status quo for
this target.
---
 .../rustc/src/platform-support/wasm32-wasip1.md    | 48 +++++++++++-----------
 1 file changed, 23 insertions(+), 25 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip1.md b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
index 4f065a554cf..1e7447698bc 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip1.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
@@ -4,37 +4,35 @@
 
 The `wasm32-wasip1` target is a WebAssembly compilation target which
 assumes that the [WASIp1] (aka "WASI preview1") set of "syscalls" are available
-for use in the standard library. Historically this target in the Rust compiler
-was one of the first for WebAssembly where Rust and C code are explicitly
-intended to interoperate as well.
-
-There's a bit of history to the target and current development which is also
-worth explaining before going much further. Historically this target was
-originally called `wasm32-wasi` in both rustc and Clang. This was first added
-to Rust in 2019. In the intervening years leading up to 2024 the WASI standard
-continued to be developed and was eventually "rebased" on top of the [Component
-Model]. This was a large change to the WASI specification and was released as
-0.2.0 ("WASIp2" colloquially) in January 2024. The previous target's name in
-rustc, `wasm32-wasi`, was then renamed to `wasm32-wasip1`, to avoid
-confusion with this new target to be added to rustc as `wasm32-wasip2`.
-Some more context can be found in these MCPs:
-
-* [Rename wasm32-wasi target to wasm32-wasip1](https://github.com/rust-lang/compiler-team/issues/607)
-* [Smooth the renaming transition of wasm32-wasi](https://github.com/rust-lang/compiler-team/issues/695)
-
-At this point the `wasm32-wasip1` target is intended for historical
-compatibility with the first version of the WASI standard. As of now (January
-2024) the 0.2.0 target of WASI ("WASIp2") is relatively new. The state of
-WASI will likely change in few years after which point this documentation will
-probably receive another update.
-
-[WASI Preview1]: https://github.com/WebAssembly/WASI/tree/main/legacy/preview1
+for use in the standard library. This target explicitly supports interop with
+non-Rust code such as C and C++.
+
+The [WASIp1] set of syscalls is standard insofar as it was written down once by
+a set of folks and has not changed since then. Additionally the [WASIp1]
+syscalls have been adapted and adopted into a number of runtimes and embeddings.
+It is not standard in the sense that there are no formal semantics for each
+syscall and APIs are no longer receiving any maintenance (e.g. no new APIs, no
+new documentation, etc). After [WASIp1] was originally developed in 2019 the
+WASI standard effort has since been "rebased" on top of the [Component Model].
+This was a large change to the WASI specification and was released as 0.2.0
+("WASIp2" colloquially) in January 2024. Current standardization efforts are
+focused on the Component Model-based definition of WASI. At this point the
+`wasm32-wasip1` Rust target is intended for historical compatibility with
+[WASIp1] set of syscalls.
+
+[WASIp1]: https://github.com/WebAssembly/WASI/tree/main/legacy/preview1
 [Component Model]: https://github.com/webassembly/component-model
 
 Today the `wasm32-wasip1` target will generate core WebAssembly modules
 which will import functions from the `wasi_snapshot_preview1` module for
 OS-related functionality (e.g. printing).
 
+> **Note**: Prior to March 2024 this target was known as `wasm32-wasi` with some
+> historical context found in old MCPs:
+>
+> * [Rename wasm32-wasi target to wasm32-wasip1](https://github.com/rust-lang/compiler-team/issues/607)
+> * [Smooth the renaming transition of wasm32-wasi](https://github.com/rust-lang/compiler-team/issues/695)
+
 ## Target maintainers
 
 When this target was added to the compiler platform-specific documentation here
-- 
cgit 1.4.1-3-g733a5


From aa331b1c5f91562d8c1ad0875b5e0dc6668dc2b0 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Mon, 7 Jul 2025 20:44:18 +0300
Subject: Fix a case where the link type was `None`

Which caused a panic.
---
 .../rust-analyzer/crates/ide/src/doc_links.rs      |  6 ++---
 .../rust-analyzer/crates/ide/src/hover/tests.rs    | 27 ++++++++++++++++++++++
 2 files changed, 30 insertions(+), 3 deletions(-)

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 f58202a4213..a5d9a10d2e5 100644
--- a/src/tools/rust-analyzer/crates/ide/src/doc_links.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/doc_links.rs
@@ -505,7 +505,7 @@ fn map_links<'e>(
         Event::End(Tag::Link(link_type, target, _)) => {
             in_link = false;
             Event::End(Tag::Link(
-                end_link_type.unwrap_or(link_type),
+                end_link_type.take().unwrap_or(link_type),
                 end_link_target.take().unwrap_or(target),
                 CowStr::Borrowed(""),
             ))
@@ -514,7 +514,7 @@ fn map_links<'e>(
             let (link_type, link_target_s, link_name) =
                 callback(&end_link_target.take().unwrap(), &s, range, end_link_type.unwrap());
             end_link_target = Some(CowStr::Boxed(link_target_s.into()));
-            if !matches!(end_link_type, Some(LinkType::Autolink)) {
+            if !matches!(end_link_type, Some(LinkType::Autolink)) && link_type.is_some() {
                 end_link_type = link_type;
             }
             Event::Text(CowStr::Boxed(link_name.into()))
@@ -523,7 +523,7 @@ fn map_links<'e>(
             let (link_type, link_target_s, link_name) =
                 callback(&end_link_target.take().unwrap(), &s, range, end_link_type.unwrap());
             end_link_target = Some(CowStr::Boxed(link_target_s.into()));
-            if !matches!(end_link_type, Some(LinkType::Autolink)) {
+            if !matches!(end_link_type, Some(LinkType::Autolink)) && link_type.is_some() {
                 end_link_type = link_type;
             }
             Event::Code(CowStr::Boxed(link_name.into()))
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
index f63499aa0fd..c3afd7da2df 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
@@ -10958,3 +10958,30 @@ fn bar$0() -> Foo {
         "#]],
     );
 }
+
+#[test]
+fn regression_20190() {
+    check(
+        r#"
+struct Foo;
+
+/// [`foo` bar](Foo).
+fn has_docs$0() {}
+    "#,
+        expect![[r#"
+            *has_docs*
+
+            ```rust
+            ra_test_fixture
+            ```
+
+            ```rust
+            fn has_docs()
+            ```
+
+            ---
+
+            [`foo` bar](https://docs.rs/ra_test_fixture/*/ra_test_fixture/struct.Foo.html).
+        "#]],
+    );
+}
-- 
cgit 1.4.1-3-g733a5


From 6254afa5f20ea9c6aa6e13555363d81f112c01cd Mon Sep 17 00:00:00 2001
From: Anne Stijns <anstijns@gmail.com>
Date: Mon, 7 Jul 2025 20:22:56 +0200
Subject: Clarify the meaning of `AttributeOrder::KeepFirst` and
 `AttributeOrder::KeepLast`

---
 compiler/rustc_attr_parsing/src/attributes/mod.rs | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
index ba7572434df..d466d946cc0 100644
--- a/compiler/rustc_attr_parsing/src/attributes/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -217,7 +217,14 @@ impl<S: Stage> OnDuplicate<S> {
 // them will be merged in another PR
 #[allow(unused)]
 pub(crate) enum AttributeOrder {
-    /// Duplicates after the first attribute will be an error.
+    /// Duplicates after the first attribute will be an error. I.e. only keep the lowest attribute.
+    ///
+    /// Attributes are processed from bottom to top, so this raises an error on all the attributes
+    /// further above the lowest one:
+    /// ```
+    /// #[stable(since="1.0")] //~ WARNING duplicated attribute
+    /// #[stable(since="2.0")]
+    /// ```
     ///
     /// This should be used where duplicates would be ignored, but carry extra
     /// meaning that could cause confusion. For example, `#[stable(since="1.0")]
@@ -227,6 +234,13 @@ pub(crate) enum AttributeOrder {
     /// Duplicates preceding the last instance of the attribute will be a
     /// warning, with a note that this will be an error in the future.
     ///
+    /// Attributes are processed from bottom to top, so this raises a warning on all the attributes
+    /// below the higher one:
+    /// ```
+    /// #[path="foo.rs"]
+    /// #[path="bar.rs"] //~ WARNING duplicated attribute
+    /// ```
+    ///
     /// This is the same as `FutureWarnFollowing`, except the last attribute is
     /// the one that is "used". Ideally these can eventually migrate to
     /// `ErrorPreceding`.
-- 
cgit 1.4.1-3-g733a5


From e2891c0fb9060f80e6aa24e0dc0a9c43b0861b8f Mon Sep 17 00:00:00 2001
From: Aleksey Kliger <alklig@microsoft.com>
Date: Mon, 7 Jul 2025 14:54:50 -0400
Subject: configure.py: Write last key in each section

The loop that writes the keys in each section of bootstrap.toml
accumulates all the commented lines before a given key and emits them
when it reaches the next key in the section.  This ends up dropping
lines accumulated for the last key
---
 src/bootstrap/configure.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/bootstrap/configure.py b/src/bootstrap/configure.py
index c077555b906..bec7a1c41b4 100755
--- a/src/bootstrap/configure.py
+++ b/src/bootstrap/configure.py
@@ -752,6 +752,10 @@ def write_uncommented(target, f):
             is_comment = True
             continue
         is_comment = is_comment and line.startswith("#")
+    # Write the last accumulated block
+    if len(block) > 0 and not is_comment:
+        for ln in block:
+            f.write(ln + "\n")
     return f
 
 
-- 
cgit 1.4.1-3-g733a5


From c000a0136ccec78d3a7d6cf5ad0422eeb13bf9eb Mon Sep 17 00:00:00 2001
From: Ses Goe <jsesgoe@gmail.com>
Date: Mon, 7 Jul 2025 15:08:38 -0400
Subject: fix: check against 'main' function name instead of entrypoint
 function update docs to be a bit more clear

---
 clippy_lints/src/exit.rs | 35 ++++++++++++++++++++++++++---------
 1 file changed, 26 insertions(+), 9 deletions(-)

diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index e6f1b7d8954..0f63b36d5d2 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_entrypoint_fn;
 use rustc_hir::{Expr, ExprKind, Item, ItemKind, OwnerNode};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::declare_lint_pass;
@@ -7,7 +6,8 @@ use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Detects calls to the `exit()` function which terminates the program.
+    /// Detects calls to the `exit()` function that are not in the `main` function. Calls to `exit()`
+    /// immediately terminate the program.
     ///
     /// ### Why restrict this?
     /// `exit()` immediately terminates the program with no information other than an exit code.
@@ -15,11 +15,24 @@ declare_clippy_lint! {
     ///
     /// Codebases may use this lint to require that all exits are performed either by panicking
     /// (which produces a message, a code location, and optionally a backtrace)
-    /// or by returning from `main()` (which is a single place to look).
+    /// or by calling `exit()` from `main()` (which is a single place to look).
     ///
-    /// ### Example
+    /// ### Good example
     /// ```no_run
-    /// std::process::exit(0)
+    /// fn main() {
+    ///     std::process::exit(0);
+    /// }
+    /// ```
+    ///
+    /// ### Bad example
+    /// ```no_run
+    /// fn main() {
+    ///     other_function();
+    /// }
+    ///
+    /// fn other_function() {
+    ///     std::process::exit(0);
+    /// }
     /// ```
     ///
     /// Use instead:
@@ -36,7 +49,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.41.0"]
     pub EXIT,
     restriction,
-    "detects `std::process::exit` calls"
+    "detects `std::process::exit` calls outside of `main`"
 }
 
 declare_lint_pass!(Exit => [EXIT]);
@@ -52,10 +65,14 @@ impl<'tcx> LateLintPass<'tcx> for Exit {
             && let Some(def_id) = cx.qpath_res(path, path_expr.hir_id).opt_def_id()
             && cx.tcx.is_diagnostic_item(sym::process_exit, def_id)
             && let parent = cx.tcx.hir_get_parent_item(e.hir_id)
-            && let OwnerNode::Item(Item{kind: ItemKind::Fn{ .. }, ..}) = cx.tcx.hir_owner_node(parent)
-            // If the next item up is a function we check if it is an entry point
+            && let OwnerNode::Item(Item{kind: ItemKind::Fn{ ident, .. }, ..}) = cx.tcx.hir_owner_node(parent)
+            // If the next item up is a function we check if it isn't named "main"
             // and only then emit a linter warning
-            && !is_entrypoint_fn(cx, parent.to_def_id())
+
+            // if you instead check for the parent of the `exit()` call being the entrypoint function, as this worked before,
+            // in compilation contexts like --all-targets (which include --tests), you get false positives
+            // because in a test context, main is not the entrypoint function
+            && ident.name.as_str() != "main"
         {
             span_lint(cx, EXIT, e.span, "usage of `process::exit`");
         }
-- 
cgit 1.4.1-3-g733a5


From 5853e6fa7e951a880dea88fc1076ef43827e6c32 Mon Sep 17 00:00:00 2001
From: Ses Goe <jsesgoe@gmail.com>
Date: Mon, 7 Jul 2025 15:08:38 -0400
Subject: chore: add tests to check against the --test compile flag

---
 tests/ui/exit1_compile_flag_test.rs     | 17 +++++++++++++++++
 tests/ui/exit1_compile_flag_test.stderr | 11 +++++++++++
 tests/ui/exit2_compile_flag_test.rs     | 15 +++++++++++++++
 tests/ui/exit2_compile_flag_test.stderr | 11 +++++++++++
 tests/ui/exit3_compile_flag_test.rs     | 11 +++++++++++
 5 files changed, 65 insertions(+)
 create mode 100644 tests/ui/exit1_compile_flag_test.rs
 create mode 100644 tests/ui/exit1_compile_flag_test.stderr
 create mode 100644 tests/ui/exit2_compile_flag_test.rs
 create mode 100644 tests/ui/exit2_compile_flag_test.stderr
 create mode 100644 tests/ui/exit3_compile_flag_test.rs

diff --git a/tests/ui/exit1_compile_flag_test.rs b/tests/ui/exit1_compile_flag_test.rs
new file mode 100644
index 00000000000..9f83ed32533
--- /dev/null
+++ b/tests/ui/exit1_compile_flag_test.rs
@@ -0,0 +1,17 @@
+//@compile-flags: --test
+#![warn(clippy::exit)]
+
+fn not_main() {
+    if true {
+        std::process::exit(4);
+        //~^ exit
+    }
+}
+
+fn main() {
+    if true {
+        std::process::exit(2);
+    };
+    not_main();
+    std::process::exit(1);
+}
diff --git a/tests/ui/exit1_compile_flag_test.stderr b/tests/ui/exit1_compile_flag_test.stderr
new file mode 100644
index 00000000000..6e33c39f0d7
--- /dev/null
+++ b/tests/ui/exit1_compile_flag_test.stderr
@@ -0,0 +1,11 @@
+error: usage of `process::exit`
+  --> tests/ui/exit1_compile_flag_test.rs:6:9
+   |
+LL |         std::process::exit(4);
+   |         ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::exit` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::exit)]`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/exit2_compile_flag_test.rs b/tests/ui/exit2_compile_flag_test.rs
new file mode 100644
index 00000000000..0b994ebc56c
--- /dev/null
+++ b/tests/ui/exit2_compile_flag_test.rs
@@ -0,0 +1,15 @@
+//@compile-flags: --test
+#![warn(clippy::exit)]
+
+fn also_not_main() {
+    std::process::exit(3);
+    //~^ exit
+}
+
+fn main() {
+    if true {
+        std::process::exit(2);
+    };
+    also_not_main();
+    std::process::exit(1);
+}
diff --git a/tests/ui/exit2_compile_flag_test.stderr b/tests/ui/exit2_compile_flag_test.stderr
new file mode 100644
index 00000000000..51eb26e9c2a
--- /dev/null
+++ b/tests/ui/exit2_compile_flag_test.stderr
@@ -0,0 +1,11 @@
+error: usage of `process::exit`
+  --> tests/ui/exit2_compile_flag_test.rs:5:5
+   |
+LL |     std::process::exit(3);
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::exit` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::exit)]`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/exit3_compile_flag_test.rs b/tests/ui/exit3_compile_flag_test.rs
new file mode 100644
index 00000000000..f8131ead2da
--- /dev/null
+++ b/tests/ui/exit3_compile_flag_test.rs
@@ -0,0 +1,11 @@
+//@ check-pass
+//@compile-flags: --test
+
+#![warn(clippy::exit)]
+
+fn main() {
+    if true {
+        std::process::exit(2);
+    };
+    std::process::exit(1);
+}
-- 
cgit 1.4.1-3-g733a5


From b6d21308672c9a0aa5c73beeb1d528aab3d347ed Mon Sep 17 00:00:00 2001
From: Aleksey Kliger <alklig@microsoft.com>
Date: Mon, 7 Jul 2025 15:45:18 -0400
Subject: Add docstring

---
 src/bootstrap/configure.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/bootstrap/configure.py b/src/bootstrap/configure.py
index bec7a1c41b4..94e02f942dc 100755
--- a/src/bootstrap/configure.py
+++ b/src/bootstrap/configure.py
@@ -739,6 +739,10 @@ def configure_file(sections, top_level_keys, targets, config):
 
 
 def write_uncommented(target, f):
+    """Writes each block in 'target' that is not composed entirely of comments to 'f'.
+
+    A block is a sequence of non-empty lines separated by empty lines.
+    """
     block = []
     is_comment = True
 
-- 
cgit 1.4.1-3-g733a5


From 1c7fb0ff918f39621c0e1b27c89f6a9a6e8efc70 Mon Sep 17 00:00:00 2001
From: Jared Davis <message@jared-pri.me>
Date: Mon, 7 Jul 2025 15:59:38 -0400
Subject: do not completely suppress warning with test code

---
 clippy_lints/src/exit.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 0f63b36d5d2..248094a0b25 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -56,10 +56,6 @@ declare_lint_pass!(Exit => [EXIT]);
 
 impl<'tcx> LateLintPass<'tcx> for Exit {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
-        if cx.sess().is_test_crate() {
-            return;
-        }
-
         if let ExprKind::Call(path_expr, [_]) = e.kind
             && let ExprKind::Path(ref path) = path_expr.kind
             && let Some(def_id) = cx.qpath_res(path, path_expr.hir_id).opt_def_id()
-- 
cgit 1.4.1-3-g733a5


From 9580d61dc52b08e2986eb4005f2cd991f112718e Mon Sep 17 00:00:00 2001
From: Jared Davis <message@jared-pri.me>
Date: Mon, 7 Jul 2025 16:05:03 -0400
Subject: remove no longer used import

---
 clippy_lints/src/exit.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index 248094a0b25..a43d788fc16 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Expr, ExprKind, Item, ItemKind, OwnerNode};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
-- 
cgit 1.4.1-3-g733a5


From 81dd4e61ed8b63d3398a4bdee033edccc75d2994 Mon Sep 17 00:00:00 2001
From: Jared Davis <message@jared-pri.me>
Date: Mon, 7 Jul 2025 16:17:19 -0400
Subject: use preinterned symbol

fixes https://github.com/rust-lang/rust-clippy/actions/runs/16126736130/job/45505355614?pr=15222#logs
---
 clippy_lints/src/exit.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/exit.rs b/clippy_lints/src/exit.rs
index a43d788fc16..487db69027a 100644
--- a/clippy_lints/src/exit.rs
+++ b/clippy_lints/src/exit.rs
@@ -68,7 +68,7 @@ impl<'tcx> LateLintPass<'tcx> for Exit {
             // if you instead check for the parent of the `exit()` call being the entrypoint function, as this worked before,
             // in compilation contexts like --all-targets (which include --tests), you get false positives
             // because in a test context, main is not the entrypoint function
-            && ident.name.as_str() != "main"
+            && ident.name != sym::main
         {
             span_lint(cx, EXIT, e.span, "usage of `process::exit`");
         }
-- 
cgit 1.4.1-3-g733a5


From 49421d1fa382fba84792e5d5dd7721c1c3e0e46e Mon Sep 17 00:00:00 2001
From: mejrs <59372212+mejrs@users.noreply.github.com>
Date: Tue, 24 Jun 2025 16:58:46 +0200
Subject: Remove support for dynamic allocas

---
 compiler/rustc_codegen_gcc/src/builder.rs        |  4 ---
 compiler/rustc_codegen_llvm/src/builder.rs       | 10 ------
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs      |  6 ----
 compiler/rustc_codegen_ssa/src/mir/mod.rs        |  6 ++--
 compiler/rustc_codegen_ssa/src/mir/operand.rs    | 40 +-----------------------
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs     | 21 -------------
 compiler/rustc_codegen_ssa/src/mir/statement.rs  |  7 ++++-
 compiler/rustc_codegen_ssa/src/traits/builder.rs |  1 -
 library/core/src/mem/mod.rs                      |  2 +-
 9 files changed, 11 insertions(+), 86 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/builder.rs b/compiler/rustc_codegen_gcc/src/builder.rs
index b1785af444a..28d1ec7d895 100644
--- a/compiler/rustc_codegen_gcc/src/builder.rs
+++ b/compiler/rustc_codegen_gcc/src/builder.rs
@@ -926,10 +926,6 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
             .get_address(self.location)
     }
 
-    fn dynamic_alloca(&mut self, _len: RValue<'gcc>, _align: Align) -> RValue<'gcc> {
-        unimplemented!();
-    }
-
     fn load(&mut self, pointee_ty: Type<'gcc>, ptr: RValue<'gcc>, align: Align) -> RValue<'gcc> {
         let block = self.llbb();
         let function = block.get_function();
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index d0aa7320b4b..9c3b866aa3c 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -538,16 +538,6 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
-    fn dynamic_alloca(&mut self, size: &'ll Value, align: Align) -> &'ll Value {
-        unsafe {
-            let alloca =
-                llvm::LLVMBuildArrayAlloca(self.llbuilder, self.cx().type_i8(), size, UNNAMED);
-            llvm::LLVMSetAlignment(alloca, align.bytes() as c_uint);
-            // Cast to default addrspace if necessary
-            llvm::LLVMBuildPointerCast(self.llbuilder, alloca, self.cx().type_ptr(), UNNAMED)
-        }
-    }
-
     fn load(&mut self, ty: &'ll Type, ptr: &'ll Value, align: Align) -> &'ll Value {
         unsafe {
             let load = llvm::LLVMBuildLoad2(self.llbuilder, ty, ptr, UNNAMED);
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 91ada856d59..00a6ec7dfba 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1492,12 +1492,6 @@ unsafe extern "C" {
         Ty: &'a Type,
         Name: *const c_char,
     ) -> &'a Value;
-    pub(crate) fn LLVMBuildArrayAlloca<'a>(
-        B: &Builder<'a>,
-        Ty: &'a Type,
-        Val: &'a Value,
-        Name: *const c_char,
-    ) -> &'a Value;
     pub(crate) fn LLVMBuildLoad2<'a>(
         B: &Builder<'a>,
         Ty: &'a Type,
diff --git a/compiler/rustc_codegen_ssa/src/mir/mod.rs b/compiler/rustc_codegen_ssa/src/mir/mod.rs
index 10b44a1faf0..4e35b143173 100644
--- a/compiler/rustc_codegen_ssa/src/mir/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -140,8 +140,8 @@ enum LocalRef<'tcx, V> {
     Place(PlaceRef<'tcx, V>),
     /// `UnsizedPlace(p)`: `p` itself is a thin pointer (indirect place).
     /// `*p` is the wide pointer that references the actual unsized place.
-    /// Every time it is initialized, we have to reallocate the place
-    /// and update the wide pointer. That's the reason why it is indirect.
+    ///
+    /// Rust has no alloca and thus no ability to move the unsized place.
     UnsizedPlace(PlaceRef<'tcx, V>),
     /// The backend [`OperandValue`] has already been generated.
     Operand(OperandRef<'tcx, V>),
@@ -498,7 +498,7 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
                         LocalRef::Place(PlaceRef::new_sized(llarg, arg.layout))
                     }
                 }
-                // Unsized indirect qrguments
+                // Unsized indirect arguments
                 PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => {
                     // As the storage for the indirect argument lives during
                     // the whole function call, we just copy the wide pointer.
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index 2896dfd5463..f6a8e1fc6a5 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -16,9 +16,9 @@ use tracing::{debug, instrument};
 use super::place::{PlaceRef, PlaceValue};
 use super::rvalue::transmute_scalar;
 use super::{FunctionCx, LocalRef};
+use crate::MemFlags;
 use crate::common::IntPredicate;
 use crate::traits::*;
-use crate::{MemFlags, size_of_val};
 
 /// The representation of a Rust value. The enum variant is in fact
 /// uniquely determined by the value's type, but is kept as a
@@ -800,44 +800,6 @@ impl<'a, 'tcx, V: CodegenObject> OperandValue<V> {
             }
         }
     }
-
-    pub fn store_unsized<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
-        self,
-        bx: &mut Bx,
-        indirect_dest: PlaceRef<'tcx, V>,
-    ) {
-        debug!("OperandRef::store_unsized: operand={:?}, indirect_dest={:?}", self, indirect_dest);
-        // `indirect_dest` must have `*mut T` type. We extract `T` out of it.
-        let unsized_ty = indirect_dest
-            .layout
-            .ty
-            .builtin_deref(true)
-            .unwrap_or_else(|| bug!("indirect_dest has non-pointer type: {:?}", indirect_dest));
-
-        let OperandValue::Ref(PlaceValue { llval: llptr, llextra: Some(llextra), .. }) = self
-        else {
-            bug!("store_unsized called with a sized value (or with an extern type)")
-        };
-
-        // Allocate an appropriate region on the stack, and copy the value into it. Since alloca
-        // doesn't support dynamic alignment, we allocate an extra align - 1 bytes, and align the
-        // pointer manually.
-        let (size, align) = size_of_val::size_and_align_of_dst(bx, unsized_ty, Some(llextra));
-        let one = bx.const_usize(1);
-        let align_minus_1 = bx.sub(align, one);
-        let size_extra = bx.add(size, align_minus_1);
-        let min_align = Align::ONE;
-        let alloca = bx.dynamic_alloca(size_extra, min_align);
-        let address = bx.ptrtoint(alloca, bx.type_isize());
-        let neg_address = bx.neg(address);
-        let offset = bx.and(neg_address, align_minus_1);
-        let dst = bx.inbounds_ptradd(alloca, offset);
-        bx.memcpy(dst, min_align, llptr, min_align, size, MemFlags::empty());
-
-        // Store the allocated region and the extra to the indirect place.
-        let indirect_operand = OperandValue::Pair(dst, llextra);
-        indirect_operand.store(bx, indirect_dest);
-    }
 }
 
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index 43726e93252..4572dc19594 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -328,27 +328,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         Some(imm)
     }
 
-    pub(crate) fn codegen_rvalue_unsized(
-        &mut self,
-        bx: &mut Bx,
-        indirect_dest: PlaceRef<'tcx, Bx::Value>,
-        rvalue: &mir::Rvalue<'tcx>,
-    ) {
-        debug!(
-            "codegen_rvalue_unsized(indirect_dest.llval={:?}, rvalue={:?})",
-            indirect_dest.val.llval, rvalue
-        );
-
-        match *rvalue {
-            mir::Rvalue::Use(ref operand) => {
-                let cg_operand = self.codegen_operand(bx, operand);
-                cg_operand.val.store_unsized(bx, indirect_dest);
-            }
-
-            _ => bug!("unsized assignment other than `Rvalue::Use`"),
-        }
-    }
-
     pub(crate) fn codegen_rvalue_operand(
         &mut self,
         bx: &mut Bx,
diff --git a/compiler/rustc_codegen_ssa/src/mir/statement.rs b/compiler/rustc_codegen_ssa/src/mir/statement.rs
index cd55a838a75..f164e0f9123 100644
--- a/compiler/rustc_codegen_ssa/src/mir/statement.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/statement.rs
@@ -15,7 +15,12 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     match self.locals[index] {
                         LocalRef::Place(cg_dest) => self.codegen_rvalue(bx, cg_dest, rvalue),
                         LocalRef::UnsizedPlace(cg_indirect_dest) => {
-                            self.codegen_rvalue_unsized(bx, cg_indirect_dest, rvalue)
+                            let ty = cg_indirect_dest.layout.ty;
+                            span_bug!(
+                                statement.source_info.span,
+                                "cannot reallocate from `UnsizedPlace({ty})` \
+                                into `{rvalue:?}`; dynamic alloca is not supported",
+                            );
                         }
                         LocalRef::PendingOperand => {
                             let operand = self.codegen_rvalue_operand(bx, rvalue);
diff --git a/compiler/rustc_codegen_ssa/src/traits/builder.rs b/compiler/rustc_codegen_ssa/src/traits/builder.rs
index 9d367748c2a..1f266514f34 100644
--- a/compiler/rustc_codegen_ssa/src/traits/builder.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/builder.rs
@@ -224,7 +224,6 @@ pub trait BuilderMethods<'a, 'tcx>:
     fn to_immediate_scalar(&mut self, val: Self::Value, scalar: Scalar) -> Self::Value;
 
     fn alloca(&mut self, size: Size, align: Align) -> Self::Value;
-    fn dynamic_alloca(&mut self, size: Self::Value, align: Align) -> Self::Value;
 
     fn load(&mut self, ty: Self::Type, ptr: Self::Value, align: Align) -> Self::Value;
     fn volatile_load(&mut self, ty: Self::Type, ptr: Self::Value) -> Self::Value;
diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
index c00585de064..1bd12d818cf 100644
--- a/library/core/src/mem/mod.rs
+++ b/library/core/src/mem/mod.rs
@@ -151,7 +151,7 @@ pub const fn forget<T>(t: T) {
 ///
 /// While Rust does not permit unsized locals since its removal in [#111942] it is
 /// still possible to call functions with unsized values from a function argument
-/// or in-place construction.
+/// or place expression.
 ///
 /// ```rust
 /// #![feature(unsized_fn_params, forget_unsized)]
-- 
cgit 1.4.1-3-g733a5


From 8a195efa1e38021dd4a83d884861b5822bb6afc6 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Mon, 7 Jul 2025 23:06:18 +0200
Subject: Make it possible to attach opaque string metadata to `StepMetadata`

---
 src/bootstrap/src/core/builder/mod.rs   | 9 ++++++++-
 src/bootstrap/src/core/builder/tests.rs | 5 ++++-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index b96a988cde3..72e5728f2c2 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -146,6 +146,8 @@ pub struct StepMetadata {
     target: TargetSelection,
     built_by: Option<Compiler>,
     stage: Option<u32>,
+    /// Additional opaque string printed in the metadata
+    metadata: Option<String>,
 }
 
 impl StepMetadata {
@@ -170,7 +172,7 @@ impl StepMetadata {
     }
 
     fn new(name: &'static str, target: TargetSelection, kind: Kind) -> Self {
-        Self { name, kind, target, built_by: None, stage: None }
+        Self { name, kind, target, built_by: None, stage: None, metadata: None }
     }
 
     pub fn built_by(mut self, compiler: Compiler) -> Self {
@@ -183,6 +185,11 @@ impl StepMetadata {
         self
     }
 
+    pub fn with_metadata(mut self, metadata: String) -> Self {
+        self.metadata = Some(metadata);
+        self
+    }
+
     pub fn get_stage(&self) -> Option<u32> {
         self.stage.or(self
             .built_by
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 1d5690a8197..9433e15f6ff 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1587,7 +1587,7 @@ impl ExecutedSteps {
 }
 
 fn fuzzy_metadata_eq(executed: &StepMetadata, to_match: &StepMetadata) -> bool {
-    let StepMetadata { name, kind, target, built_by: _, stage: _ } = executed;
+    let StepMetadata { name, kind, target, built_by: _, stage: _, metadata } = executed;
     *name == to_match.name && *kind == to_match.kind && *target == to_match.target
 }
 
@@ -1648,6 +1648,9 @@ fn render_metadata(metadata: &StepMetadata) -> String {
     }
     let stage = metadata.get_stage().map(|stage| format!("{stage} ")).unwrap_or_default();
     write!(record, "{} {stage}<{}>", metadata.name, normalize_target(metadata.target));
+    if let Some(metadata) = &metadata.metadata {
+        write!(record, " {metadata}");
+    }
     record
 }
 
-- 
cgit 1.4.1-3-g733a5


From 45053e21b2229c3f7b3b68b253772c4ea19a87c0 Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <code@alona.page>
Date: Mon, 7 Jul 2025 21:56:54 +0000
Subject: Run `tests/rustdoc-json/attrs/target_features` on all hosts.

Makes it more convenient to test rustdoc on non x86_64. I mainly care
about the aarch64 dev-desktops.

This works because rustdoc uses all target features, not just that of
the target.
---
 tests/rustdoc-json/attrs/target_feature.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/rustdoc-json/attrs/target_feature.rs b/tests/rustdoc-json/attrs/target_feature.rs
index ee2b3235f72..ed1a717e1f0 100644
--- a/tests/rustdoc-json/attrs/target_feature.rs
+++ b/tests/rustdoc-json/attrs/target_feature.rs
@@ -1,5 +1,3 @@
-//@ only-x86_64
-
 //@ is "$.index[?(@.name=='test1')].attrs" '["#[target_feature(enable=\"avx\")]"]'
 #[target_feature(enable = "avx")]
 pub fn test1() {}
-- 
cgit 1.4.1-3-g733a5


From ae5cb5f66d88f75d88eb9d37fc1bf73c169f47c5 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Mon, 7 Jul 2025 22:43:59 +0300
Subject: Mention more APIs in `ParseIntError` docs

---
 library/core/src/num/error.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/library/core/src/num/error.rs b/library/core/src/num/error.rs
index a5242d60bf1..f9c4cdd0ebe 100644
--- a/library/core/src/num/error.rs
+++ b/library/core/src/num/error.rs
@@ -45,8 +45,11 @@ impl From<!> for TryFromIntError {
 
 /// An error which can be returned when parsing an integer.
 ///
-/// This error is used as the error type for the `from_str_radix()` functions
-/// on the primitive integer types, such as [`i8::from_str_radix`].
+/// For example, this error is returned by the `from_str_radix()` functions
+/// on the primitive integer types (such as [`i8::from_str_radix`])
+/// and is used as the error type in their [`FromStr`] implementations.
+///
+/// [`FromStr`]: crate::str::FromStr
 ///
 /// # Potential causes
 ///
-- 
cgit 1.4.1-3-g733a5


From c3301503b97cd6b768a944661b81a92994e9db00 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Sat, 21 Dec 2024 20:25:43 +0000
Subject: Make `Default` const and add some `const Default` impls

Full list of `impl const Default` types:

- ()
- bool
- char
- Cell
- std::ascii::Char
- usize
- u8
- u16
- u32
- u64
- u128
- i8
- i16
- i32
- i64
- i128
- f16
- f32
- f64
- f128
- std::marker::PhantomData<T>
- Option<T>
- std::iter::Empty<T>
- std::ptr::Alignment
- &[T]
- &mut [T]
- &str
- &mut str
- String
- Vec<T>
---
 library/alloc/src/lib.rs                           |  2 +
 library/alloc/src/string.rs                        |  3 +-
 library/alloc/src/vec/mod.rs                       |  3 +-
 library/core/src/cell.rs                           | 12 +++--
 library/core/src/default.rs                        |  5 +-
 library/core/src/iter/sources/empty.rs             |  3 +-
 library/core/src/marker.rs                         |  3 +-
 library/core/src/option.rs                         |  3 +-
 library/core/src/ptr/alignment.rs                  |  3 +-
 library/core/src/slice/mod.rs                      |  6 ++-
 library/core/src/str/mod.rs                        |  6 ++-
 src/tools/clippy/tests/ui/or_fun_call.fixed        |  4 +-
 src/tools/clippy/tests/ui/or_fun_call.rs           |  2 +-
 src/tools/clippy/tests/ui/or_fun_call.stderr       |  8 +--
 tests/ui/consts/rustc-impl-const-stability.rs      |  8 +--
 tests/ui/consts/rustc-impl-const-stability.stderr  |  6 +--
 .../lint/dead-code/unused-struct-derive-default.rs |  4 +-
 tests/ui/specialization/const_trait_impl.rs        |  8 +--
 tests/ui/specialization/const_trait_impl.stderr    | 60 +++++++++++-----------
 tests/ui/traits/const-traits/const-traits-alloc.rs |  9 ++++
 tests/ui/traits/const-traits/const-traits-core.rs  | 46 +++++++++++++++++
 .../const_derives/derive-const-gate.rs             |  5 +-
 .../const_derives/derive-const-gate.stderr         | 21 +++++---
 .../const_derives/derive-const-non-const-type.rs   |  8 +--
 .../derive-const-non-const-type.stderr             | 18 +++----
 .../const-traits/const_derives/derive-const-use.rs |  2 +-
 .../const_derives/derive-const-use.stderr          | 57 +-------------------
 .../traits/const-traits/std-impl-gate.gated.stderr | 18 -------
 tests/ui/traits/const-traits/std-impl-gate.rs      |  7 +--
 .../traits/const-traits/std-impl-gate.stock.stderr | 20 ++++++--
 30 files changed, 192 insertions(+), 168 deletions(-)
 create mode 100644 tests/ui/traits/const-traits/const-traits-alloc.rs
 create mode 100644 tests/ui/traits/const-traits/const-traits-core.rs
 delete mode 100644 tests/ui/traits/const-traits/std-impl-gate.gated.stderr

diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 4290bb7a8a9..4ad65e678c3 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -107,8 +107,10 @@
 #![feature(char_max_len)]
 #![feature(clone_to_uninit)]
 #![feature(coerce_unsized)]
+#![feature(const_default)]
 #![feature(const_eval_select)]
 #![feature(const_heap)]
+#![feature(const_trait_impl)]
 #![feature(core_intrinsics)]
 #![feature(deprecated_suggestion)]
 #![feature(deref_pure_trait)]
diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs
index 5f69f699867..84b82423202 100644
--- a/library/alloc/src/string.rs
+++ b/library/alloc/src/string.rs
@@ -2611,7 +2611,8 @@ impl_eq! { Cow<'a, str>, &'b str }
 impl_eq! { Cow<'a, str>, String }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl Default for String {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl const Default for String {
     /// Creates an empty `String`.
     #[inline]
     fn default() -> String {
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index c8341750f4d..9dac58bac4f 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -3895,7 +3895,8 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Default for Vec<T> {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl<T> const Default for Vec<T> {
     /// Creates an empty `Vec<T>`.
     ///
     /// The vector will not allocate until elements are pushed onto it.
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index dfed8a00b7d..f7ea1f37a39 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -333,7 +333,8 @@ impl<T: Copy> Clone for Cell<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Default> Default for Cell<T> {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl<T: ~const Default> const Default for Cell<T> {
     /// Creates a `Cell<T>`, with the `Default` value for T.
     #[inline]
     fn default() -> Cell<T> {
@@ -1323,7 +1324,8 @@ impl<T: Clone> Clone for RefCell<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Default> Default for RefCell<T> {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl<T: ~const Default> const Default for RefCell<T> {
     /// Creates a `RefCell<T>`, with the `Default` value for T.
     #[inline]
     fn default() -> RefCell<T> {
@@ -2330,7 +2332,8 @@ impl<T: ?Sized> UnsafeCell<T> {
 }
 
 #[stable(feature = "unsafe_cell_default", since = "1.10.0")]
-impl<T: Default> Default for UnsafeCell<T> {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl<T: ~const Default> const Default for UnsafeCell<T> {
     /// Creates an `UnsafeCell`, with the `Default` value for T.
     fn default() -> UnsafeCell<T> {
         UnsafeCell::new(Default::default())
@@ -2434,7 +2437,8 @@ impl<T: ?Sized> SyncUnsafeCell<T> {
 }
 
 #[unstable(feature = "sync_unsafe_cell", issue = "95439")]
-impl<T: Default> Default for SyncUnsafeCell<T> {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl<T: ~const Default> const Default for SyncUnsafeCell<T> {
     /// Creates an `SyncUnsafeCell`, with the `Default` value for T.
     fn default() -> SyncUnsafeCell<T> {
         SyncUnsafeCell::new(Default::default())
diff --git a/library/core/src/default.rs b/library/core/src/default.rs
index 0a15cedfb55..4d108b0c18e 100644
--- a/library/core/src/default.rs
+++ b/library/core/src/default.rs
@@ -103,6 +103,8 @@ use crate::ascii::Char as AsciiChar;
 /// ```
 #[rustc_diagnostic_item = "Default"]
 #[stable(feature = "rust1", since = "1.0.0")]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
 pub trait Default: Sized {
     /// Returns the "default value" for a type.
     ///
@@ -149,7 +151,8 @@ pub macro Default($item:item) {
 macro_rules! default_impl {
     ($t:ty, $v:expr, $doc:tt) => {
         #[stable(feature = "rust1", since = "1.0.0")]
-        impl Default for $t {
+        #[rustc_const_unstable(feature = "const_default", issue = "67792")]
+        impl const Default for $t {
             #[inline(always)]
             #[doc = $doc]
             fn default() -> $t {
diff --git a/library/core/src/iter/sources/empty.rs b/library/core/src/iter/sources/empty.rs
index 3c3acceded8..309962ab70c 100644
--- a/library/core/src/iter/sources/empty.rs
+++ b/library/core/src/iter/sources/empty.rs
@@ -81,7 +81,8 @@ impl<T> Clone for Empty<T> {
 // not #[derive] because that adds a Default bound on T,
 // which isn't necessary.
 #[stable(feature = "iter_empty", since = "1.2.0")]
-impl<T> Default for Empty<T> {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl<T> const Default for Empty<T> {
     fn default() -> Empty<T> {
         Empty(marker::PhantomData)
     }
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index ccbd2b00cfd..2aeb0b0c31e 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -858,7 +858,8 @@ impl<T: PointeeSized> Clone for PhantomData<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PointeeSized> Default for PhantomData<T> {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl<T: PointeeSized> const Default for PhantomData<T> {
     fn default() -> Self {
         Self
     }
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index f2a1e901188..38eb2662b34 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -2111,7 +2111,8 @@ where
 impl<T> crate::clone::UseCloned for Option<T> where T: crate::clone::UseCloned {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Default for Option<T> {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl<T> const Default for Option<T> {
     /// Returns [`None`][Option::None].
     ///
     /// # Examples
diff --git a/library/core/src/ptr/alignment.rs b/library/core/src/ptr/alignment.rs
index 3e66e271f03..304cde05af9 100644
--- a/library/core/src/ptr/alignment.rs
+++ b/library/core/src/ptr/alignment.rs
@@ -230,7 +230,8 @@ impl hash::Hash for Alignment {
 
 /// Returns [`Alignment::MIN`], which is valid for any type.
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-impl Default for Alignment {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl const Default for Alignment {
     fn default() -> Alignment {
         Alignment::MIN
     }
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index dc09ba8d788..479fe0f1554 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -5158,7 +5158,8 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Default for &[T] {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl<T> const Default for &[T] {
     /// Creates an empty slice.
     fn default() -> Self {
         &[]
@@ -5166,7 +5167,8 @@ impl<T> Default for &[T] {
 }
 
 #[stable(feature = "mut_slice_default", since = "1.5.0")]
-impl<T> Default for &mut [T] {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl<T> const Default for &mut [T] {
     /// Creates a mutable empty slice.
     fn default() -> Self {
         &mut []
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index fe64132ff22..32a22988175 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -3072,7 +3072,8 @@ impl AsRef<[u8]> for str {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl Default for &str {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl const Default for &str {
     /// Creates an empty str
     #[inline]
     fn default() -> Self {
@@ -3081,7 +3082,8 @@ impl Default for &str {
 }
 
 #[stable(feature = "default_mut_str", since = "1.28.0")]
-impl Default for &mut str {
+#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+impl const Default for &mut str {
     /// Creates an empty mutable str
     #[inline]
     fn default() -> Self {
diff --git a/src/tools/clippy/tests/ui/or_fun_call.fixed b/src/tools/clippy/tests/ui/or_fun_call.fixed
index 34f3e046841..38822bdbb30 100644
--- a/src/tools/clippy/tests/ui/or_fun_call.fixed
+++ b/src/tools/clippy/tests/ui/or_fun_call.fixed
@@ -406,8 +406,8 @@ fn fn_call_in_nested_expr() {
         val: String::from("123"),
     });
 
-    let _ = opt_foo.unwrap_or_else(|| Foo { val: String::default() });
-    //~^ or_fun_call
+    // ok, `String::default()` is now `const`
+    let _ = opt_foo.unwrap_or(Foo { val: String::default() });
 }
 
 mod result_map_or {
diff --git a/src/tools/clippy/tests/ui/or_fun_call.rs b/src/tools/clippy/tests/ui/or_fun_call.rs
index dc57bd6060a..7e8647f221c 100644
--- a/src/tools/clippy/tests/ui/or_fun_call.rs
+++ b/src/tools/clippy/tests/ui/or_fun_call.rs
@@ -406,8 +406,8 @@ fn fn_call_in_nested_expr() {
         val: String::from("123"),
     });
 
+    // ok, `String::default()` is now `const`
     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
-    //~^ or_fun_call
 }
 
 mod result_map_or {
diff --git a/src/tools/clippy/tests/ui/or_fun_call.stderr b/src/tools/clippy/tests/ui/or_fun_call.stderr
index 0f159fe8bff..0d88929e131 100644
--- a/src/tools/clippy/tests/ui/or_fun_call.stderr
+++ b/src/tools/clippy/tests/ui/or_fun_call.stderr
@@ -240,12 +240,6 @@ error: use of `unwrap_or` to construct default value
 LL |     let _ = opt.unwrap_or({ i32::default() });
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:409:21
-   |
-LL |     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Foo { val: String::default() })`
-
 error: function call inside of `map_or`
   --> tests/ui/or_fun_call.rs:424:19
    |
@@ -264,5 +258,5 @@ error: function call inside of `get_or_insert`
 LL |     let _ = x.get_or_insert(g());
    |               ^^^^^^^^^^^^^^^^^^ help: try: `get_or_insert_with(g)`
 
-error: aborting due to 41 previous errors
+error: aborting due to 40 previous errors
 
diff --git a/tests/ui/consts/rustc-impl-const-stability.rs b/tests/ui/consts/rustc-impl-const-stability.rs
index 0df8482bec1..93a5e8e4f45 100644
--- a/tests/ui/consts/rustc-impl-const-stability.rs
+++ b/tests/ui/consts/rustc-impl-const-stability.rs
@@ -2,7 +2,7 @@
 //@ known-bug: #110395
 
 #![crate_type = "lib"]
-#![feature(staged_api, const_trait_impl)]
+#![feature(staged_api, const_trait_impl, const_default)]
 #![stable(feature = "foo", since = "1.0.0")]
 
 #[stable(feature = "potato", since = "1.27.0")]
@@ -12,8 +12,8 @@ pub struct Data {
 
 #[stable(feature = "potato", since = "1.27.0")]
 #[rustc_const_unstable(feature = "data_foo", issue = "none")]
-impl const Default for Data {
-    fn default() -> Data {
-        Data { _data: 42 }
+impl const std::fmt::Debug for Data {
+    fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        Ok(())
     }
 }
diff --git a/tests/ui/consts/rustc-impl-const-stability.stderr b/tests/ui/consts/rustc-impl-const-stability.stderr
index 19c6bb5907f..a3ef4031a13 100644
--- a/tests/ui/consts/rustc-impl-const-stability.stderr
+++ b/tests/ui/consts/rustc-impl-const-stability.stderr
@@ -1,8 +1,8 @@
-error: const `impl` for trait `Default` which is not marked with `#[const_trait]`
+error: const `impl` for trait `Debug` which is not marked with `#[const_trait]`
   --> $DIR/rustc-impl-const-stability.rs:15:12
    |
-LL | impl const Default for Data {
-   |            ^^^^^^^ this trait is not `const`
+LL | impl const std::fmt::Debug for Data {
+   |            ^^^^^^^^^^^^^^^ this trait is not `const`
    |
    = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
diff --git a/tests/ui/lint/dead-code/unused-struct-derive-default.rs b/tests/ui/lint/dead-code/unused-struct-derive-default.rs
index f20b7cb66ee..bfbdf57b0dc 100644
--- a/tests/ui/lint/dead-code/unused-struct-derive-default.rs
+++ b/tests/ui/lint/dead-code/unused-struct-derive-default.rs
@@ -1,4 +1,4 @@
-#![deny(dead_code)]
+#![deny(dead_code)] //~ NOTE the lint level is defined here
 
 #[derive(Default)]
 struct T; //~ ERROR struct `T` is never constructed
@@ -7,7 +7,7 @@ struct T; //~ ERROR struct `T` is never constructed
 struct Used;
 
 #[derive(Default)]
-enum E {
+enum E { //~ NOTE variant in this enum
     #[default]
     A,
     B, //~ ERROR variant `B` is never constructed
diff --git a/tests/ui/specialization/const_trait_impl.rs b/tests/ui/specialization/const_trait_impl.rs
index 2df92dfad3b..e917263d193 100644
--- a/tests/ui/specialization/const_trait_impl.rs
+++ b/tests/ui/specialization/const_trait_impl.rs
@@ -2,6 +2,8 @@
 
 #![feature(const_trait_impl, min_specialization, rustc_attrs)]
 
+use std::fmt::Debug;
+
 #[rustc_specialization_trait]
 #[const_trait]
 pub unsafe trait Sup {
@@ -31,19 +33,19 @@ pub trait A {
     fn a() -> u32;
 }
 
-impl<T: [const] Default> const A for T {
+impl<T: [const] Debug> const A for T {
     default fn a() -> u32 {
         2
     }
 }
 
-impl<T: [const] Default + [const] Sup> const A for T {
+impl<T: [const] Debug + [const] Sup> const A for T {
     default fn a() -> u32 {
         3
     }
 }
 
-impl<T: [const] Default + [const] Sub> const A for T {
+impl<T: [const] Debug + [const] Sub> const A for T {
     fn a() -> u32 {
         T::foo()
     }
diff --git a/tests/ui/specialization/const_trait_impl.stderr b/tests/ui/specialization/const_trait_impl.stderr
index ea3ec16ac1e..b9c768812c8 100644
--- a/tests/ui/specialization/const_trait_impl.stderr
+++ b/tests/ui/specialization/const_trait_impl.stderr
@@ -1,58 +1,58 @@
 error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const_trait_impl.rs:34:9
+  --> $DIR/const_trait_impl.rs:36:9
    |
-LL | impl<T: [const] Default> const A for T {
-   |         ^^^^^^^ can't be applied to `Default`
+LL | impl<T: [const] Debug> const A for T {
+   |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/default.rs:LL:COL
+note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
 
 error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const_trait_impl.rs:40:9
+  --> $DIR/const_trait_impl.rs:42:9
    |
-LL | impl<T: [const] Default + [const] Sup> const A for T {
-   |         ^^^^^^^ can't be applied to `Default`
+LL | impl<T: [const] Debug + [const] Sup> const A for T {
+   |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/default.rs:LL:COL
+note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
 
 error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const_trait_impl.rs:46:9
+  --> $DIR/const_trait_impl.rs:48:9
    |
-LL | impl<T: [const] Default + [const] Sub> const A for T {
-   |         ^^^^^^^ can't be applied to `Default`
+LL | impl<T: [const] Debug + [const] Sub> const A for T {
+   |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/default.rs:LL:COL
+note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
 
 error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const_trait_impl.rs:40:9
+  --> $DIR/const_trait_impl.rs:42:9
    |
-LL | impl<T: [const] Default + [const] Sup> const A for T {
-   |         ^^^^^^^ can't be applied to `Default`
+LL | impl<T: [const] Debug + [const] Sup> const A for T {
+   |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/default.rs:LL:COL
+note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const_trait_impl.rs:34:9
+  --> $DIR/const_trait_impl.rs:36:9
    |
-LL | impl<T: [const] Default> const A for T {
-   |         ^^^^^^^ can't be applied to `Default`
+LL | impl<T: [const] Debug> const A for T {
+   |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/default.rs:LL:COL
+note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const_trait_impl.rs:46:9
+  --> $DIR/const_trait_impl.rs:48:9
    |
-LL | impl<T: [const] Default + [const] Sub> const A for T {
-   |         ^^^^^^^ can't be applied to `Default`
+LL | impl<T: [const] Debug + [const] Sub> const A for T {
+   |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/default.rs:LL:COL
+note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+  --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: aborting due to 6 previous errors
diff --git a/tests/ui/traits/const-traits/const-traits-alloc.rs b/tests/ui/traits/const-traits/const-traits-alloc.rs
new file mode 100644
index 00000000000..07725ef02f1
--- /dev/null
+++ b/tests/ui/traits/const-traits/const-traits-alloc.rs
@@ -0,0 +1,9 @@
+//@ run-pass
+#![feature(const_trait_impl, const_default)]
+#![allow(dead_code)]
+// alloc::string
+const STRING: String = Default::default();
+// alloc::vec
+const VEC: Vec<()> = Default::default();
+
+fn main() {}
diff --git a/tests/ui/traits/const-traits/const-traits-core.rs b/tests/ui/traits/const-traits/const-traits-core.rs
new file mode 100644
index 00000000000..6df53daae13
--- /dev/null
+++ b/tests/ui/traits/const-traits/const-traits-core.rs
@@ -0,0 +1,46 @@
+//@ run-pass
+#![feature(
+    const_trait_impl, const_default, ptr_alignment_type, ascii_char, f16, f128, sync_unsafe_cell,
+)]
+#![allow(dead_code)]
+// core::default
+const UNIT: () = Default::default();
+const BOOL: bool = Default::default();
+const CHAR: char = Default::default();
+const ASCII_CHAR: std::ascii::Char = Default::default();
+const USIZE: usize = Default::default();
+const U8: u8 = Default::default();
+const U16: u16 = Default::default();
+const U32: u32 = Default::default();
+const U64: u64 = Default::default();
+const U128: u128 = Default::default();
+const I8: i8 = Default::default();
+const I16: i16 = Default::default();
+const I32: i32 = Default::default();
+const I64: i64 = Default::default();
+const I128: i128 = Default::default();
+const F16: f16 = Default::default();
+const F32: f32 = Default::default();
+const F64: f64 = Default::default();
+const F128: f128 = Default::default();
+// core::marker
+const PHANTOM: std::marker::PhantomData<()> = Default::default();
+// core::option
+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::slice
+const SLICE: &[()] = Default::default();
+const MUT_SLICE: &mut [()] = Default::default();
+// core::str
+const STR: &str = Default::default();
+const MUT_STR: &mut str = Default::default();
+// core::cell
+const CELL: std::cell::Cell<()> = Default::default();
+const REF_CELL: std::cell::RefCell<()> = Default::default();
+const UNSAFE_CELL: std::cell::UnsafeCell<()> = Default::default();
+const SYNC_UNSAFE_CELL: std::cell::SyncUnsafeCell<()> = Default::default();
+
+fn main() {}
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-gate.rs b/tests/ui/traits/const-traits/const_derives/derive-const-gate.rs
index a772d69c9e2..04fea1189ae 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-gate.rs
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-gate.rs
@@ -1,5 +1,6 @@
-#[derive_const(Default)] //~ ERROR use of unstable library feature
-//~^ ERROR const `impl` for trait `Default` which is not marked with `#[const_trait]`
+#[derive_const(Debug)] //~ ERROR use of unstable library feature
+//~^ ERROR const `impl` for trait `Debug` which is not marked with `#[const_trait]`
+//~| ERROR cannot call non-const method
 pub struct S;
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr b/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr
index 202210a2e65..5bde358001c 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr
@@ -1,21 +1,30 @@
 error[E0658]: use of unstable library feature `derive_const`
   --> $DIR/derive-const-gate.rs:1:3
    |
-LL | #[derive_const(Default)]
+LL | #[derive_const(Debug)]
    |   ^^^^^^^^^^^^
    |
    = help: add `#![feature(derive_const)]` 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: const `impl` for trait `Default` which is not marked with `#[const_trait]`
+error: const `impl` for trait `Debug` which is not marked with `#[const_trait]`
   --> $DIR/derive-const-gate.rs:1:16
    |
-LL | #[derive_const(Default)]
-   |                ^^^^^^^ this trait is not `const`
+LL | #[derive_const(Debug)]
+   |                ^^^^^ this trait is not `const`
    |
    = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
-error: aborting due to 2 previous errors
+error[E0015]: cannot call non-const method `Formatter::<'_>::write_str` in constant functions
+  --> $DIR/derive-const-gate.rs:1:16
+   |
+LL | #[derive_const(Debug)]
+   |                ^^^^^
+   |
+   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+
+error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0658`.
+Some errors have detailed explanations: E0015, E0658.
+For more information about an error, try `rustc --explain E0015`.
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.rs b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.rs
index 7bda7117a47..0bc25ce5f65 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.rs
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.rs
@@ -3,11 +3,13 @@
 
 pub struct A;
 
-impl Default for A {
-    fn default() -> A { A }
+impl std::fmt::Debug for A {
+    fn fmt(&self, _: &mut std::fmt::Formatter<'_>)  -> Result<(), std::fmt::Error> {
+        panic!()
+    }
 }
 
-#[derive_const(Default)]
+#[derive_const(Debug)]
 pub struct S(A);
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
index 27f4bcf46ef..c0bd360ebe5 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
@@ -1,19 +1,17 @@
-error: const `impl` for trait `Default` which is not marked with `#[const_trait]`
-  --> $DIR/derive-const-non-const-type.rs:10:16
+error: const `impl` for trait `Debug` which is not marked with `#[const_trait]`
+  --> $DIR/derive-const-non-const-type.rs:12:16
    |
-LL | #[derive_const(Default)]
-   |                ^^^^^^^ this trait is not `const`
+LL | #[derive_const(Debug)]
+   |                ^^^^^ this trait is not `const`
    |
    = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
-error[E0015]: cannot call non-const associated function `<A as Default>::default` in constant functions
-  --> $DIR/derive-const-non-const-type.rs:11:14
+error[E0015]: cannot call non-const method `Formatter::<'_>::debug_tuple_field1_finish` in constant functions
+  --> $DIR/derive-const-non-const-type.rs:12:16
    |
-LL | #[derive_const(Default)]
-   |                ------- in this derive macro expansion
-LL | pub struct S(A);
-   |              ^
+LL | #[derive_const(Debug)]
+   |                ^^^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-use.rs b/tests/ui/traits/const-traits/const_derives/derive-const-use.rs
index 1e447147213..1a3012de06f 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-use.rs
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-use.rs
@@ -1,6 +1,6 @@
 //@ known-bug: #110395
 
-#![feature(const_trait_impl, const_cmp, const_default_impls, derive_const)]
+#![feature(const_trait_impl, const_default, const_cmp, derive_const)]
 
 pub struct A;
 
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-use.stderr b/tests/ui/traits/const-traits/const_derives/derive-const-use.stderr
index ce61eb9a1ab..4ea11a0c7ed 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-use.stderr
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-use.stderr
@@ -1,27 +1,3 @@
-error[E0635]: unknown feature `const_default_impls`
-  --> $DIR/derive-const-use.rs:3:41
-   |
-LL | #![feature(const_trait_impl, const_cmp, const_default_impls, derive_const)]
-   |                                         ^^^^^^^^^^^^^^^^^^^
-
-error: const `impl` for trait `Default` which is not marked with `#[const_trait]`
-  --> $DIR/derive-const-use.rs:7:12
-   |
-LL | impl const Default for A {
-   |            ^^^^^^^ this trait is not `const`
-   |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
-error: const `impl` for trait `Default` which is not marked with `#[const_trait]`
-  --> $DIR/derive-const-use.rs:15:16
-   |
-LL | #[derive_const(Default, PartialEq)]
-   |                ^^^^^^^ this trait is not `const`
-   |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
 error[E0277]: the trait bound `(): [const] PartialEq` is not satisfied
   --> $DIR/derive-const-use.rs:16:14
    |
@@ -30,35 +6,6 @@ LL | #[derive_const(Default, PartialEq)]
 LL | pub struct S((), A);
    |              ^^
 
-error[E0015]: cannot call non-const associated function `<S as Default>::default` in constants
-  --> $DIR/derive-const-use.rs:18:35
-   |
-LL | const _: () = assert!(S((), A) == S::default());
-   |                                   ^^^^^^^^^^^^
-   |
-   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: cannot call non-const associated function `<() as Default>::default` in constant functions
-  --> $DIR/derive-const-use.rs:16:14
-   |
-LL | #[derive_const(Default, PartialEq)]
-   |                ------- in this derive macro expansion
-LL | pub struct S((), A);
-   |              ^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: cannot call non-const associated function `<A as Default>::default` in constant functions
-  --> $DIR/derive-const-use.rs:16:18
-   |
-LL | #[derive_const(Default, PartialEq)]
-   |                ------- in this derive macro expansion
-LL | pub struct S((), A);
-   |                  ^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 7 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0015, E0277, E0635.
-For more information about an error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/std-impl-gate.gated.stderr b/tests/ui/traits/const-traits/std-impl-gate.gated.stderr
deleted file mode 100644
index a78cf8ce61e..00000000000
--- a/tests/ui/traits/const-traits/std-impl-gate.gated.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0635]: unknown feature `const_default_impls`
-  --> $DIR/std-impl-gate.rs:6:46
-   |
-LL | #![cfg_attr(gated, feature(const_trait_impl, const_default_impls))]
-   |                                              ^^^^^^^^^^^^^^^^^^^
-
-error[E0015]: cannot call non-const associated function `<Vec<usize> as Default>::default` in constant functions
-  --> $DIR/std-impl-gate.rs:13:5
-   |
-LL |     Default::default()
-   |     ^^^^^^^^^^^^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 2 previous errors
-
-Some errors have detailed explanations: E0015, E0635.
-For more information about an error, try `rustc --explain E0015`.
diff --git a/tests/ui/traits/const-traits/std-impl-gate.rs b/tests/ui/traits/const-traits/std-impl-gate.rs
index 84091931997..d29bccf17c9 100644
--- a/tests/ui/traits/const-traits/std-impl-gate.rs
+++ b/tests/ui/traits/const-traits/std-impl-gate.rs
@@ -1,9 +1,9 @@
 // This tests feature gates for const impls in the standard library.
 
 //@ revisions: stock gated
-//@[gated] known-bug: #110395
+//@[gated] run-pass
 
-#![cfg_attr(gated, feature(const_trait_impl, const_default_impls))]
+#![cfg_attr(gated, feature(const_trait_impl, const_default))]
 
 fn non_const_context() -> Vec<usize> {
     Default::default()
@@ -11,7 +11,8 @@ fn non_const_context() -> Vec<usize> {
 
 const fn const_context() -> Vec<usize> {
     Default::default()
-    //[stock]~^ ERROR cannot call non-const associated function
+    //[stock]~^ ERROR cannot call conditionally-const associated function
+    //[stock]~| ERROR `Default` is not yet stable as a const trait
 }
 
 fn main() {
diff --git a/tests/ui/traits/const-traits/std-impl-gate.stock.stderr b/tests/ui/traits/const-traits/std-impl-gate.stock.stderr
index 8728f652ef9..1fa71e41a98 100644
--- a/tests/ui/traits/const-traits/std-impl-gate.stock.stderr
+++ b/tests/ui/traits/const-traits/std-impl-gate.stock.stderr
@@ -1,11 +1,25 @@
-error[E0015]: cannot call non-const associated function `<Vec<usize> as Default>::default` in constant functions
+error[E0658]: cannot call conditionally-const associated function `<Vec<usize> as Default>::default` in constant functions
   --> $DIR/std-impl-gate.rs:13:5
    |
 LL |     Default::default()
    |     ^^^^^^^^^^^^^^^^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> 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 1 previous error
+error: `Default` is not yet stable as a const trait
+  --> $DIR/std-impl-gate.rs:13:5
+   |
+LL |     Default::default()
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+help: add `#![feature(const_default)]` to the crate attributes to enable
+   |
+LL + #![feature(const_default)]
+   |
+
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0658`.
-- 
cgit 1.4.1-3-g733a5


From d6f7aad00ee9fe8658722d634bfa8473352cfc95 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Sat, 21 Dec 2024 20:25:43 +0000
Subject: Make `Default` const and add some `const Default` impls

Full list of `impl const Default` types:

- ()
- bool
- char
- Cell
- std::ascii::Char
- usize
- u8
- u16
- u32
- u64
- u128
- i8
- i16
- i32
- i64
- i128
- f16
- f32
- f64
- f128
- std::marker::PhantomData<T>
- Option<T>
- std::iter::Empty<T>
- std::ptr::Alignment
- &[T]
- &mut [T]
- &str
- &mut str
- String
- Vec<T>
---
 tests/ui/or_fun_call.fixed  | 4 ++--
 tests/ui/or_fun_call.rs     | 2 +-
 tests/ui/or_fun_call.stderr | 8 +-------
 3 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 34f3e046841..38822bdbb30 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -406,8 +406,8 @@ fn fn_call_in_nested_expr() {
         val: String::from("123"),
     });
 
-    let _ = opt_foo.unwrap_or_else(|| Foo { val: String::default() });
-    //~^ or_fun_call
+    // ok, `String::default()` is now `const`
+    let _ = opt_foo.unwrap_or(Foo { val: String::default() });
 }
 
 mod result_map_or {
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index dc57bd6060a..7e8647f221c 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -406,8 +406,8 @@ fn fn_call_in_nested_expr() {
         val: String::from("123"),
     });
 
+    // ok, `String::default()` is now `const`
     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
-    //~^ or_fun_call
 }
 
 mod result_map_or {
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 0f159fe8bff..0d88929e131 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -240,12 +240,6 @@ error: use of `unwrap_or` to construct default value
 LL |     let _ = opt.unwrap_or({ i32::default() });
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:409:21
-   |
-LL |     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Foo { val: String::default() })`
-
 error: function call inside of `map_or`
   --> tests/ui/or_fun_call.rs:424:19
    |
@@ -264,5 +258,5 @@ error: function call inside of `get_or_insert`
 LL |     let _ = x.get_or_insert(g());
    |               ^^^^^^^^^^^^^^^^^^ help: try: `get_or_insert_with(g)`
 
-error: aborting due to 41 previous errors
+error: aborting due to 40 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8f8099fb42f0b067cd9b6a82e704ce3cc0e63301 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Mon, 7 Jul 2025 23:07:32 +0000
Subject: Account for const stability in clippy when checking constness

---
 src/tools/clippy/clippy_utils/src/visitors.rs | 6 ++++--
 src/tools/clippy/tests/ui/or_fun_call.fixed   | 4 ++--
 src/tools/clippy/tests/ui/or_fun_call.rs      | 2 +-
 src/tools/clippy/tests/ui/or_fun_call.stderr  | 8 +++++++-
 4 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/src/tools/clippy/clippy_utils/src/visitors.rs b/src/tools/clippy/clippy_utils/src/visitors.rs
index fc6e30a9804..615a0910dfd 100644
--- a/src/tools/clippy/clippy_utils/src/visitors.rs
+++ b/src/tools/clippy/clippy_utils/src/visitors.rs
@@ -1,5 +1,7 @@
+use crate::msrvs::Msrv;
 use crate::ty::needs_ordered_drop;
 use crate::{get_enclosing_block, path_to_local_id};
+use crate::qualify_min_const_fn::is_stable_const_fn;
 use core::ops::ControlFlow;
 use rustc_ast::visit::{VisitorResult, try_visit};
 use rustc_hir::def::{CtorKind, DefKind, Res};
@@ -343,13 +345,13 @@ pub fn is_const_evaluatable<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) ->
                     .cx
                     .qpath_res(p, hir_id)
                     .opt_def_id()
-                    .is_some_and(|id| self.cx.tcx.is_const_fn(id)) => {},
+                    .is_some_and(|id| is_stable_const_fn(self.cx, id, Msrv::default())) => {},
                 ExprKind::MethodCall(..)
                     if self
                         .cx
                         .typeck_results()
                         .type_dependent_def_id(e.hir_id)
-                        .is_some_and(|id| self.cx.tcx.is_const_fn(id)) => {},
+                        .is_some_and(|id| is_stable_const_fn(self.cx, id, Msrv::default())) => {},
                 ExprKind::Binary(_, lhs, rhs)
                     if self.cx.typeck_results().expr_ty(lhs).peel_refs().is_primitive_ty()
                         && self.cx.typeck_results().expr_ty(rhs).peel_refs().is_primitive_ty() => {},
diff --git a/src/tools/clippy/tests/ui/or_fun_call.fixed b/src/tools/clippy/tests/ui/or_fun_call.fixed
index 38822bdbb30..34f3e046841 100644
--- a/src/tools/clippy/tests/ui/or_fun_call.fixed
+++ b/src/tools/clippy/tests/ui/or_fun_call.fixed
@@ -406,8 +406,8 @@ fn fn_call_in_nested_expr() {
         val: String::from("123"),
     });
 
-    // ok, `String::default()` is now `const`
-    let _ = opt_foo.unwrap_or(Foo { val: String::default() });
+    let _ = opt_foo.unwrap_or_else(|| Foo { val: String::default() });
+    //~^ or_fun_call
 }
 
 mod result_map_or {
diff --git a/src/tools/clippy/tests/ui/or_fun_call.rs b/src/tools/clippy/tests/ui/or_fun_call.rs
index 7e8647f221c..dc57bd6060a 100644
--- a/src/tools/clippy/tests/ui/or_fun_call.rs
+++ b/src/tools/clippy/tests/ui/or_fun_call.rs
@@ -406,8 +406,8 @@ fn fn_call_in_nested_expr() {
         val: String::from("123"),
     });
 
-    // ok, `String::default()` is now `const`
     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
+    //~^ or_fun_call
 }
 
 mod result_map_or {
diff --git a/src/tools/clippy/tests/ui/or_fun_call.stderr b/src/tools/clippy/tests/ui/or_fun_call.stderr
index 0d88929e131..0f159fe8bff 100644
--- a/src/tools/clippy/tests/ui/or_fun_call.stderr
+++ b/src/tools/clippy/tests/ui/or_fun_call.stderr
@@ -240,6 +240,12 @@ error: use of `unwrap_or` to construct default value
 LL |     let _ = opt.unwrap_or({ i32::default() });
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
+error: function call inside of `unwrap_or`
+  --> tests/ui/or_fun_call.rs:409:21
+   |
+LL |     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Foo { val: String::default() })`
+
 error: function call inside of `map_or`
   --> tests/ui/or_fun_call.rs:424:19
    |
@@ -258,5 +264,5 @@ error: function call inside of `get_or_insert`
 LL |     let _ = x.get_or_insert(g());
    |               ^^^^^^^^^^^^^^^^^^ help: try: `get_or_insert_with(g)`
 
-error: aborting due to 40 previous errors
+error: aborting due to 41 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 5228e2846995ef24c743710877b6668fa0260ba6 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Mon, 7 Jul 2025 23:07:32 +0000
Subject: Account for const stability in clippy when checking constness

---
 clippy_utils/src/visitors.rs | 6 ++++--
 tests/ui/or_fun_call.fixed   | 4 ++--
 tests/ui/or_fun_call.rs      | 2 +-
 tests/ui/or_fun_call.stderr  | 8 +++++++-
 4 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index fc6e30a9804..615a0910dfd 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -1,5 +1,7 @@
+use crate::msrvs::Msrv;
 use crate::ty::needs_ordered_drop;
 use crate::{get_enclosing_block, path_to_local_id};
+use crate::qualify_min_const_fn::is_stable_const_fn;
 use core::ops::ControlFlow;
 use rustc_ast::visit::{VisitorResult, try_visit};
 use rustc_hir::def::{CtorKind, DefKind, Res};
@@ -343,13 +345,13 @@ pub fn is_const_evaluatable<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) ->
                     .cx
                     .qpath_res(p, hir_id)
                     .opt_def_id()
-                    .is_some_and(|id| self.cx.tcx.is_const_fn(id)) => {},
+                    .is_some_and(|id| is_stable_const_fn(self.cx, id, Msrv::default())) => {},
                 ExprKind::MethodCall(..)
                     if self
                         .cx
                         .typeck_results()
                         .type_dependent_def_id(e.hir_id)
-                        .is_some_and(|id| self.cx.tcx.is_const_fn(id)) => {},
+                        .is_some_and(|id| is_stable_const_fn(self.cx, id, Msrv::default())) => {},
                 ExprKind::Binary(_, lhs, rhs)
                     if self.cx.typeck_results().expr_ty(lhs).peel_refs().is_primitive_ty()
                         && self.cx.typeck_results().expr_ty(rhs).peel_refs().is_primitive_ty() => {},
diff --git a/tests/ui/or_fun_call.fixed b/tests/ui/or_fun_call.fixed
index 38822bdbb30..34f3e046841 100644
--- a/tests/ui/or_fun_call.fixed
+++ b/tests/ui/or_fun_call.fixed
@@ -406,8 +406,8 @@ fn fn_call_in_nested_expr() {
         val: String::from("123"),
     });
 
-    // ok, `String::default()` is now `const`
-    let _ = opt_foo.unwrap_or(Foo { val: String::default() });
+    let _ = opt_foo.unwrap_or_else(|| Foo { val: String::default() });
+    //~^ or_fun_call
 }
 
 mod result_map_or {
diff --git a/tests/ui/or_fun_call.rs b/tests/ui/or_fun_call.rs
index 7e8647f221c..dc57bd6060a 100644
--- a/tests/ui/or_fun_call.rs
+++ b/tests/ui/or_fun_call.rs
@@ -406,8 +406,8 @@ fn fn_call_in_nested_expr() {
         val: String::from("123"),
     });
 
-    // ok, `String::default()` is now `const`
     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
+    //~^ or_fun_call
 }
 
 mod result_map_or {
diff --git a/tests/ui/or_fun_call.stderr b/tests/ui/or_fun_call.stderr
index 0d88929e131..0f159fe8bff 100644
--- a/tests/ui/or_fun_call.stderr
+++ b/tests/ui/or_fun_call.stderr
@@ -240,6 +240,12 @@ error: use of `unwrap_or` to construct default value
 LL |     let _ = opt.unwrap_or({ i32::default() });
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
+error: function call inside of `unwrap_or`
+  --> tests/ui/or_fun_call.rs:409:21
+   |
+LL |     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Foo { val: String::default() })`
+
 error: function call inside of `map_or`
   --> tests/ui/or_fun_call.rs:424:19
    |
@@ -258,5 +264,5 @@ error: function call inside of `get_or_insert`
 LL |     let _ = x.get_or_insert(g());
    |               ^^^^^^^^^^^^^^^^^^ help: try: `get_or_insert_with(g)`
 
-error: aborting due to 40 previous errors
+error: aborting due to 41 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 62951c2e07dea61ec20fd6f6e849400f4cd194c3 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Mon, 7 Jul 2025 18:22:28 -0600
Subject: fix: Remove newline from multiple crate versions note

---
 .../src/error_reporting/traits/fulfillment_errors.rs                    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 28d572b303a..cd3e6c4bc54 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
@@ -1933,7 +1933,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     StringPart::highlighted("multiple different versions".to_string()),
                     StringPart::normal(" of crate `".to_string()),
                     StringPart::highlighted(format!("{crate_name}")),
-                    StringPart::normal("` in the dependency graph\n".to_string()),
+                    StringPart::normal("` in the dependency graph".to_string()),
                 ],
             );
             if points_at_type {
-- 
cgit 1.4.1-3-g733a5


From a58a423f9a37c614d56f86fbbfbebec414caaaf1 Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Tue, 8 Jul 2025 03:16:46 +0200
Subject: Add target maintainer information for mips64-unknown-linux-muslabi64

The mips64-unknown-linux-muslabi64 target is currently rather broken,
but I'm working on getting it fixed so that it can at least be used
again.

While I can't commit to maintaining the LLVM side of this target, I
don't mind looking into any other MIPS or musl-related issues that arise
with this target.

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 src/doc/rustc/src/SUMMARY.md                       |  1 +
 src/doc/rustc/src/platform-support.md              |  2 +-
 .../mips64-unknown-linux-muslabi64.md              | 49 ++++++++++++++++++++++
 3 files changed, 51 insertions(+), 1 deletion(-)
 create mode 100644 src/doc/rustc/src/platform-support/mips64-unknown-linux-muslabi64.md

diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 9fe4c218121..e1742631f63 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -83,6 +83,7 @@
     - [m68k-unknown-linux-gnu](platform-support/m68k-unknown-linux-gnu.md)
     - [m68k-unknown-none-elf](platform-support/m68k-unknown-none-elf.md)
     - [mips64-openwrt-linux-musl](platform-support/mips64-openwrt-linux-musl.md)
+    - [mips64-unknown-linux-muslabi64](platform-support/mips64-unknown-linux-muslabi64.md)
     - [mipsel-sony-psx](platform-support/mipsel-sony-psx.md)
     - [mipsel-unknown-linux-gnu](platform-support/mipsel-unknown-linux-gnu.md)
     - [mips\*-mti-none-elf](platform-support/mips-mti-none-elf.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index 285b1e519b7..ed01de4c1c3 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -333,7 +333,7 @@ target | std | host | notes
 `mips-unknown-linux-uclibc` | ✓ |  | MIPS Linux with uClibc
 [`mips64-openwrt-linux-musl`](platform-support/mips64-openwrt-linux-musl.md) | ? |  | MIPS64 for OpenWrt Linux musl 1.2.3
 `mips64-unknown-linux-gnuabi64` | ✓ | ✓ | MIPS64 Linux, N64 ABI (kernel 4.4, glibc 2.23)
-`mips64-unknown-linux-muslabi64` | ✓ |  | MIPS64 Linux, N64 ABI, musl 1.2.3
+[`mips64-unknown-linux-muslabi64`](platform-support/mips64-unknown-linux-muslabi64.md) | ✓ | ✓ | MIPS64 Linux, N64 ABI, musl 1.2.3
 `mips64el-unknown-linux-gnuabi64` | ✓ | ✓ | MIPS64 (little endian) Linux, N64 ABI (kernel 4.4, glibc 2.23)
 `mips64el-unknown-linux-muslabi64` | ✓ |  | MIPS64 (little endian) Linux, N64 ABI, musl 1.2.3
 `mipsel-sony-psp` | * |  | MIPS (LE) Sony PlayStation Portable (PSP)
diff --git a/src/doc/rustc/src/platform-support/mips64-unknown-linux-muslabi64.md b/src/doc/rustc/src/platform-support/mips64-unknown-linux-muslabi64.md
new file mode 100644
index 00000000000..60c0972bb3e
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/mips64-unknown-linux-muslabi64.md
@@ -0,0 +1,49 @@
+# mips64-unknown-linux-muslabi64
+
+**Tier: 3**
+
+Target for 64-bit big endian MIPS Linux programs using musl libc and the N64 ABI.
+
+## Target maintainers
+
+[@Gelbpunkt](https://github.com/Gelbpunkt)
+
+## Requirements
+
+Building the target itself requires a 64-bit big endian MIPS compiler that is
+supported by `cc-rs`.
+
+## Building the target
+
+The target can be built by enabling it for a `rustc` build.
+
+```toml
+[build]
+target = ["mips64-unknown-linux-muslabi64"]
+```
+
+Make sure your C compiler is included in `$PATH`, then add it to the
+`bootstrap.toml`:
+
+```toml
+[target.mips64-unknown-linux-muslabi64]
+cc = "mips64-linux-musl-gcc"
+cxx = "mips64-linux-musl-g++"
+ar = "mips64-linux-musl-ar"
+linker = "mips64-linux-musl-gcc"
+```
+
+## Building Rust programs
+
+Rust does not yet ship pre-compiled artifacts for this target. To compile for
+this target, you will first need to build Rust with the target enabled (see
+"Building the target" above).
+
+## Cross-compilation
+
+This target can be cross-compiled from any host.
+
+## Testing
+
+This target can be tested as normal with `x.py` on a 64-bit big endian MIPS
+host or via QEMU emulation.
-- 
cgit 1.4.1-3-g733a5


From 717041232ae0ae0ae445a2a302510aab3375ea47 Mon Sep 17 00:00:00 2001
From: Predrag Gruevski <obi1kenobi82@gmail.com>
Date: Mon, 7 Jul 2025 00:56:29 +0000
Subject: Don't mark `#[target_feature]` safe fns as unsafe in rustdoc JSON.

---
 src/librustdoc/json/conversions.rs         | 15 ++++++++++++++-
 tests/rustdoc-json/attrs/target_feature.rs | 23 +++++++++++++++++++++++
 2 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index f51b35097f6..f76ff11590b 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -9,6 +9,7 @@ use rustc_ast::ast;
 use rustc_attr_data_structures::{self as attrs, DeprecatedSince};
 use rustc_hir::def::CtorKind;
 use rustc_hir::def_id::DefId;
+use rustc_hir::{HeaderSafety, Safety};
 use rustc_metadata::rendered_const;
 use rustc_middle::{bug, ty};
 use rustc_span::{Pos, kw, sym};
@@ -383,10 +384,22 @@ impl FromClean<clean::Union> for Union {
 
 impl FromClean<rustc_hir::FnHeader> for FunctionHeader {
     fn from_clean(header: &rustc_hir::FnHeader, renderer: &JsonRenderer<'_>) -> Self {
+        let is_unsafe = match header.safety {
+            HeaderSafety::SafeTargetFeatures => {
+                // The type system's internal implementation details consider
+                // safe functions with the `#[target_feature]` attribute to be analogous
+                // to unsafe functions: `header.is_unsafe()` returns `true` for them.
+                // For rustdoc, this isn't the right decision, so we explicitly return `false`.
+                // Context: https://github.com/rust-lang/rust/issues/142655
+                false
+            }
+            HeaderSafety::Normal(Safety::Safe) => false,
+            HeaderSafety::Normal(Safety::Unsafe) => true,
+        };
         FunctionHeader {
             is_async: header.is_async(),
             is_const: header.is_const(),
-            is_unsafe: header.is_unsafe(),
+            is_unsafe,
             abi: header.abi.into_json(renderer),
         }
     }
diff --git a/tests/rustdoc-json/attrs/target_feature.rs b/tests/rustdoc-json/attrs/target_feature.rs
index ee2b3235f72..80262d8e332 100644
--- a/tests/rustdoc-json/attrs/target_feature.rs
+++ b/tests/rustdoc-json/attrs/target_feature.rs
@@ -1,17 +1,40 @@
 //@ only-x86_64
 
 //@ is "$.index[?(@.name=='test1')].attrs" '["#[target_feature(enable=\"avx\")]"]'
+//@ is "$.index[?(@.name=='test1')].inner.function.header.is_unsafe" false
 #[target_feature(enable = "avx")]
 pub fn test1() {}
 
 //@ is "$.index[?(@.name=='test2')].attrs" '["#[target_feature(enable=\"avx\", enable=\"avx2\")]"]'
+//@ is "$.index[?(@.name=='test1')].inner.function.header.is_unsafe" false
 #[target_feature(enable = "avx,avx2")]
 pub fn test2() {}
 
 //@ is "$.index[?(@.name=='test3')].attrs" '["#[target_feature(enable=\"avx\", enable=\"avx2\")]"]'
+//@ is "$.index[?(@.name=='test1')].inner.function.header.is_unsafe" false
 #[target_feature(enable = "avx", enable = "avx2")]
 pub fn test3() {}
 
 //@ is "$.index[?(@.name=='test4')].attrs" '["#[target_feature(enable=\"avx\", enable=\"avx2\", enable=\"avx512f\")]"]'
+//@ is "$.index[?(@.name=='test1')].inner.function.header.is_unsafe" false
 #[target_feature(enable = "avx", enable = "avx2,avx512f")]
 pub fn test4() {}
+
+//@ is "$.index[?(@.name=='test_unsafe_fn')].attrs" '["#[target_feature(enable=\"avx\")]"]'
+//@ is "$.index[?(@.name=='test_unsafe_fn')].inner.function.header.is_unsafe" true
+#[target_feature(enable = "avx")]
+pub unsafe fn test_unsafe_fn() {}
+
+pub struct Example;
+
+impl Example {
+    //@ is "$.index[?(@.name=='safe_assoc_fn')].attrs" '["#[target_feature(enable=\"avx\")]"]'
+    //@ is "$.index[?(@.name=='safe_assoc_fn')].inner.function.header.is_unsafe" false
+    #[target_feature(enable = "avx")]
+    pub fn safe_assoc_fn() {}
+
+    //@ is "$.index[?(@.name=='unsafe_assoc_fn')].attrs" '["#[target_feature(enable=\"avx\")]"]'
+    //@ is "$.index[?(@.name=='unsafe_assoc_fn')].inner.function.header.is_unsafe" true
+    #[target_feature(enable = "avx")]
+    pub unsafe fn unsafe_assoc_fn() {}
+}
-- 
cgit 1.4.1-3-g733a5


From 8cf2c71243f8c093e7728370e6653aa940dbaf22 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Fri, 4 Jul 2025 23:16:41 -0700
Subject: Let `rvalue_creates_operand` return true for *all*
 `Rvalue::Aggregate`s

Inspired by <https://github.com/rust-lang/rust/pull/138759#discussion_r2156375342> where I noticed that we were nearly at this point, plus the comments I was writing in 143410 that reminded me a type-dependent `true` is fine.

This PR splits the `OperandRef::builder` logic out to a separate type, with the updates needed to handle SIMD as well.  In doing so, that makes the existing `Aggregate` path in `codegen_rvalue_operand` capable of handing SIMD values just fine.

As a result, we no longer need to do layout calculations for aggregate result types when running the analysis to determine which things can be SSA in codegen.
---
 compiler/rustc_codegen_ssa/src/mir/analyze.rs |   3 +-
 compiler/rustc_codegen_ssa/src/mir/operand.rs | 175 +++++++++++++++++---------
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs  |  25 ++--
 tests/codegen/enum/enum-aggregate.rs          |  15 +--
 tests/codegen/simd/aggregate-simd.rs          | 106 ++++++++++++++++
 tests/codegen/union-aggregate.rs              |  23 ++++
 6 files changed, 261 insertions(+), 86 deletions(-)
 create mode 100644 tests/codegen/simd/aggregate-simd.rs

diff --git a/compiler/rustc_codegen_ssa/src/mir/analyze.rs b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
index 99f35b79208..6d6465dd798 100644
--- a/compiler/rustc_codegen_ssa/src/mir/analyze.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
@@ -171,8 +171,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'b, 'tcx>> Visitor<'tcx> for LocalAnalyzer
         if let Some(local) = place.as_local() {
             self.define(local, DefLocation::Assignment(location));
             if self.locals[local] != LocalKind::Memory {
-                let decl_span = self.fx.mir.local_decls[local].source_info.span;
-                if !self.fx.rvalue_creates_operand(rvalue, decl_span) {
+                if !self.fx.rvalue_creates_operand(rvalue) {
                     self.locals[local] = LocalKind::Memory;
                 }
             }
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index 2896dfd5463..e5b95e5ecc5 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -565,118 +565,167 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
             }
         }
     }
+}
 
-    /// Creates an incomplete operand containing the [`abi::Scalar`]s expected based
-    /// on the `layout` passed. This is for use with [`OperandRef::insert_field`]
-    /// later to set the necessary immediate(s), one-by-one converting all the `Right` to `Left`.
-    ///
-    /// Returns `None` for `layout`s which cannot be built this way.
-    pub(crate) fn builder(
-        layout: TyAndLayout<'tcx>,
-    ) -> Option<OperandRef<'tcx, Either<V, abi::Scalar>>> {
-        // Uninhabited types are weird, because for example `Result<!, !>`
-        // shows up as `FieldsShape::Primitive` and we need to be able to write
-        // a field into `(u32, !)`. We'll do that in an `alloca` instead.
-        if layout.uninhabited {
-            return None;
-        }
+/// Each of these variants starts out as `Either::Right` when it's uninitialized,
+/// then setting the field changes that to `Either::Left` with the backend value.
+#[derive(Debug, Copy, Clone)]
+enum OperandValueBuilder<V> {
+    ZeroSized,
+    Immediate(Either<V, abi::Scalar>),
+    Pair(Either<V, abi::Scalar>, Either<V, abi::Scalar>),
+    /// `repr(simd)` types need special handling because they each have a non-empty
+    /// array field (which uses [`OperandValue::Ref`]) despite the SIMD type itself
+    /// using [`OperandValue::Immediate`] which for any other kind of type would
+    /// mean that its one non-ZST field would also be [`OperandValue::Immediate`].
+    Vector(Either<V, ()>),
+}
+
+/// Allows building up an `OperandRef` by setting fields one at a time.
+#[derive(Debug, Copy, Clone)]
+pub(super) struct OperandRefBuilder<'tcx, V> {
+    val: OperandValueBuilder<V>,
+    layout: TyAndLayout<'tcx>,
+}
 
+impl<'a, 'tcx, V: CodegenObject> OperandRefBuilder<'tcx, V> {
+    /// Creates an uninitialized builder for an instance of the `layout`.
+    ///
+    /// ICEs for [`BackendRepr::Memory`] types (other than ZSTs), which should
+    /// be built up inside a [`PlaceRef`] instead as they need an allocated place
+    /// into which to write the values of the fields.
+    pub(super) fn new(layout: TyAndLayout<'tcx>) -> Self {
         let val = match layout.backend_repr {
-            BackendRepr::Memory { .. } if layout.is_zst() => OperandValue::ZeroSized,
-            BackendRepr::Scalar(s) => OperandValue::Immediate(Either::Right(s)),
-            BackendRepr::ScalarPair(a, b) => OperandValue::Pair(Either::Right(a), Either::Right(b)),
-            BackendRepr::Memory { .. } | BackendRepr::SimdVector { .. } => return None,
+            BackendRepr::Memory { .. } if layout.is_zst() => OperandValueBuilder::ZeroSized,
+            BackendRepr::Scalar(s) => OperandValueBuilder::Immediate(Either::Right(s)),
+            BackendRepr::ScalarPair(a, b) => {
+                OperandValueBuilder::Pair(Either::Right(a), Either::Right(b))
+            }
+            BackendRepr::SimdVector { .. } => OperandValueBuilder::Vector(Either::Right(())),
+            BackendRepr::Memory { .. } => {
+                bug!("Cannot use non-ZST Memory-ABI type in operand builder: {layout:?}");
+            }
         };
-        Some(OperandRef { val, layout })
+        OperandRefBuilder { val, layout }
     }
-}
 
-impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, Either<V, abi::Scalar>> {
-    pub(crate) fn insert_field<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
+    pub(super) fn insert_field<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
         &mut self,
         bx: &mut Bx,
-        v: VariantIdx,
-        f: FieldIdx,
-        operand: OperandRef<'tcx, V>,
+        variant: VariantIdx,
+        field: FieldIdx,
+        field_operand: OperandRef<'tcx, V>,
     ) {
-        let (expect_zst, is_zero_offset) = if let abi::FieldsShape::Primitive = self.layout.fields {
+        if let OperandValue::ZeroSized = field_operand.val {
+            // A ZST never adds any state, so just ignore it.
+            // This special-casing is worth it because of things like
+            // `Result<!, !>` where `Ok(never)` is legal to write,
+            // but the type shows as FieldShape::Primitive so we can't
+            // actually look at the layout for the field being set.
+            return;
+        }
+
+        let is_zero_offset = if let abi::FieldsShape::Primitive = self.layout.fields {
             // The other branch looking at field layouts ICEs for primitives,
             // so we need to handle them separately.
-            // Multiple fields is possible for cases such as aggregating
-            // a thin pointer, where the second field is the unit.
+            // Because we handled ZSTs above (like the metadata in a thin pointer),
+            // the only possibility is that we're setting the one-and-only field.
             assert!(!self.layout.is_zst());
-            assert_eq!(v, FIRST_VARIANT);
-            let first_field = f == FieldIdx::ZERO;
-            (!first_field, first_field)
+            assert_eq!(variant, FIRST_VARIANT);
+            assert_eq!(field, FieldIdx::ZERO);
+            true
         } else {
-            let variant_layout = self.layout.for_variant(bx.cx(), v);
-            let field_layout = variant_layout.field(bx.cx(), f.as_usize());
-            let field_offset = variant_layout.fields.offset(f.as_usize());
-            (field_layout.is_zst(), field_offset == Size::ZERO)
+            let variant_layout = self.layout.for_variant(bx.cx(), variant);
+            let field_offset = variant_layout.fields.offset(field.as_usize());
+            field_offset == Size::ZERO
         };
 
         let mut update = |tgt: &mut Either<V, abi::Scalar>, src, from_scalar| {
             let to_scalar = tgt.unwrap_right();
+            // We transmute here (rather than just `from_immediate`) because in
+            // `Result<usize, *const ()>` the field of the `Ok` is an integer,
+            // but the corresponding scalar in the enum is a pointer.
             let imm = transmute_scalar(bx, src, from_scalar, to_scalar);
             *tgt = Either::Left(imm);
         };
 
-        match (operand.val, operand.layout.backend_repr) {
-            (OperandValue::ZeroSized, _) if expect_zst => {}
+        match (field_operand.val, field_operand.layout.backend_repr) {
+            (OperandValue::ZeroSized, _) => unreachable!("Handled above"),
             (OperandValue::Immediate(v), BackendRepr::Scalar(from_scalar)) => match &mut self.val {
-                OperandValue::Immediate(val @ Either::Right(_)) if is_zero_offset => {
+                OperandValueBuilder::Immediate(val @ Either::Right(_)) if is_zero_offset => {
                     update(val, v, from_scalar);
                 }
-                OperandValue::Pair(fst @ Either::Right(_), _) if is_zero_offset => {
+                OperandValueBuilder::Pair(fst @ Either::Right(_), _) if is_zero_offset => {
                     update(fst, v, from_scalar);
                 }
-                OperandValue::Pair(_, snd @ Either::Right(_)) if !is_zero_offset => {
+                OperandValueBuilder::Pair(_, snd @ Either::Right(_)) if !is_zero_offset => {
                     update(snd, v, from_scalar);
                 }
-                _ => bug!("Tried to insert {operand:?} into {v:?}.{f:?} of {self:?}"),
+                _ => {
+                    bug!("Tried to insert {field_operand:?} into {variant:?}.{field:?} of {self:?}")
+                }
+            },
+            (OperandValue::Immediate(v), BackendRepr::SimdVector { .. }) => match &mut self.val {
+                OperandValueBuilder::Vector(val @ Either::Right(())) if is_zero_offset => {
+                    *val = Either::Left(v);
+                }
+                _ => {
+                    bug!("Tried to insert {field_operand:?} into {variant:?}.{field:?} of {self:?}")
+                }
             },
             (OperandValue::Pair(a, b), BackendRepr::ScalarPair(from_sa, from_sb)) => {
                 match &mut self.val {
-                    OperandValue::Pair(fst @ Either::Right(_), snd @ Either::Right(_)) => {
+                    OperandValueBuilder::Pair(fst @ Either::Right(_), snd @ Either::Right(_)) => {
                         update(fst, a, from_sa);
                         update(snd, b, from_sb);
                     }
-                    _ => bug!("Tried to insert {operand:?} into {v:?}.{f:?} of {self:?}"),
+                    _ => bug!(
+                        "Tried to insert {field_operand:?} into {variant:?}.{field:?} of {self:?}"
+                    ),
                 }
             }
-            _ => bug!("Unsupported operand {operand:?} inserting into {v:?}.{f:?} of {self:?}"),
+            (OperandValue::Ref(place), BackendRepr::Memory { .. }) => match &mut self.val {
+                OperandValueBuilder::Vector(val @ Either::Right(())) => {
+                    let ibty = bx.cx().immediate_backend_type(self.layout);
+                    let simd = bx.load_from_place(ibty, place);
+                    *val = Either::Left(simd);
+                }
+                _ => {
+                    bug!("Tried to insert {field_operand:?} into {variant:?}.{field:?} of {self:?}")
+                }
+            },
+            _ => bug!("Operand cannot be used with `insert_field`: {field_operand:?}"),
         }
     }
 
     /// Insert the immediate value `imm` for field `f` in the *type itself*,
     /// rather than into one of the variants.
     ///
-    /// Most things want [`OperandRef::insert_field`] instead, but this one is
+    /// Most things want [`Self::insert_field`] instead, but this one is
     /// necessary for writing things like enum tags that aren't in any variant.
     pub(super) fn insert_imm(&mut self, f: FieldIdx, imm: V) {
         let field_offset = self.layout.fields.offset(f.as_usize());
         let is_zero_offset = field_offset == Size::ZERO;
         match &mut self.val {
-            OperandValue::Immediate(val @ Either::Right(_)) if is_zero_offset => {
+            OperandValueBuilder::Immediate(val @ Either::Right(_)) if is_zero_offset => {
                 *val = Either::Left(imm);
             }
-            OperandValue::Pair(fst @ Either::Right(_), _) if is_zero_offset => {
+            OperandValueBuilder::Pair(fst @ Either::Right(_), _) if is_zero_offset => {
                 *fst = Either::Left(imm);
             }
-            OperandValue::Pair(_, snd @ Either::Right(_)) if !is_zero_offset => {
+            OperandValueBuilder::Pair(_, snd @ Either::Right(_)) if !is_zero_offset => {
                 *snd = Either::Left(imm);
             }
             _ => bug!("Tried to insert {imm:?} into field {f:?} of {self:?}"),
         }
     }
 
-    /// After having set all necessary fields, this converts the
-    /// `OperandValue<Either<V, _>>` (as obtained from [`OperandRef::builder`])
-    /// to the normal `OperandValue<V>`.
+    /// After having set all necessary fields, this converts the builder back
+    /// to the normal `OperandRef`.
     ///
     /// ICEs if any required fields were not set.
-    pub fn build(&self, cx: &impl CodegenMethods<'tcx, Value = V>) -> OperandRef<'tcx, V> {
-        let OperandRef { val, layout } = *self;
+    pub(super) fn build(&self, cx: &impl CodegenMethods<'tcx, Value = V>) -> OperandRef<'tcx, V> {
+        let OperandRefBuilder { val, layout } = *self;
 
         // For something like `Option::<u32>::None`, it's expected that the
         // payload scalar will not actually have been set, so this converts
@@ -692,10 +741,22 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, Either<V, abi::Scalar>> {
         };
 
         let val = match val {
-            OperandValue::ZeroSized => OperandValue::ZeroSized,
-            OperandValue::Immediate(v) => OperandValue::Immediate(unwrap(v)),
-            OperandValue::Pair(a, b) => OperandValue::Pair(unwrap(a), unwrap(b)),
-            OperandValue::Ref(_) => bug!(),
+            OperandValueBuilder::ZeroSized => OperandValue::ZeroSized,
+            OperandValueBuilder::Immediate(v) => OperandValue::Immediate(unwrap(v)),
+            OperandValueBuilder::Pair(a, b) => OperandValue::Pair(unwrap(a), unwrap(b)),
+            OperandValueBuilder::Vector(v) => match v {
+                Either::Left(v) => OperandValue::Immediate(v),
+                Either::Right(())
+                    if let BackendRepr::SimdVector { element, .. } = layout.backend_repr
+                        && element.is_uninit_valid() =>
+                {
+                    let bty = cx.immediate_backend_type(layout);
+                    OperandValue::Immediate(cx.const_undef(bty))
+                }
+                Either::Right(()) => {
+                    bug!("OperandRef::build called while fields are missing {self:?}")
+                }
+            },
         };
         OperandRef { val, layout }
     }
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index 43726e93252..2a7efdfe8bb 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -4,10 +4,9 @@ use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
 use rustc_middle::{bug, mir};
 use rustc_session::config::OptLevel;
-use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument};
 
-use super::operand::{OperandRef, OperandValue};
+use super::operand::{OperandRef, OperandRefBuilder, OperandValue};
 use super::place::{PlaceRef, codegen_tag_value};
 use super::{FunctionCx, LocalRef};
 use crate::common::{IntPredicate, TypeKind};
@@ -181,7 +180,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }
 
             _ => {
-                assert!(self.rvalue_creates_operand(rvalue, DUMMY_SP));
+                assert!(self.rvalue_creates_operand(rvalue));
                 let temp = self.codegen_rvalue_operand(bx, rvalue);
                 temp.val.store(bx, dest);
             }
@@ -354,10 +353,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         bx: &mut Bx,
         rvalue: &mir::Rvalue<'tcx>,
     ) -> OperandRef<'tcx, Bx::Value> {
-        assert!(
-            self.rvalue_creates_operand(rvalue, DUMMY_SP),
-            "cannot codegen {rvalue:?} to operand",
-        );
+        assert!(self.rvalue_creates_operand(rvalue), "cannot codegen {rvalue:?} to operand",);
 
         match *rvalue {
             mir::Rvalue::Cast(ref kind, ref source, mir_cast_ty) => {
@@ -668,9 +664,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
                 // `rvalue_creates_operand` has arranged that we only get here if
                 // we can build the aggregate immediate from the field immediates.
-                let Some(mut builder) = OperandRef::builder(layout) else {
-                    bug!("Cannot use type in operand builder: {layout:?}")
-                };
+                let mut builder = OperandRefBuilder::new(layout);
                 for (field_idx, field) in fields.iter_enumerated() {
                     let op = self.codegen_operand(bx, field);
                     let fi = active_field_index.unwrap_or(field_idx);
@@ -980,7 +974,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     /// will not actually take the operand path because the result type is such
     /// that it always gets an `alloca`, but where it's not worth re-checking the
     /// layout in this code when the right thing will happen anyway.
-    pub(crate) fn rvalue_creates_operand(&self, rvalue: &mir::Rvalue<'tcx>, span: Span) -> bool {
+    pub(crate) fn rvalue_creates_operand(&self, rvalue: &mir::Rvalue<'tcx>) -> bool {
         match *rvalue {
             mir::Rvalue::Cast(mir::CastKind::Transmute, ref operand, cast_ty) => {
                 let operand_ty = operand.ty(self.mir, self.cx.tcx());
@@ -1025,18 +1019,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             mir::Rvalue::NullaryOp(..) |
             mir::Rvalue::ThreadLocalRef(_) |
             mir::Rvalue::Use(..) |
+            mir::Rvalue::Aggregate(..) | // (*)
             mir::Rvalue::WrapUnsafeBinder(..) => // (*)
                 true,
             // Arrays are always aggregates, so it's not worth checking anything here.
             // (If it's really `[(); N]` or `[T; 0]` and we use the place path, fine.)
             mir::Rvalue::Repeat(..) => false,
-            mir::Rvalue::Aggregate(..) => {
-                    let ty = rvalue.ty(self.mir, self.cx.tcx());
-                    let ty = self.monomorphize(ty);
-                    let layout = self.cx.spanned_layout_of(ty, span);
-                    OperandRef::<Bx::Value>::builder(layout).is_some()
-                }
-            }
+        }
 
         // (*) this is only true if the type is suitable
     }
diff --git a/tests/codegen/enum/enum-aggregate.rs b/tests/codegen/enum/enum-aggregate.rs
index b6a9b8dd814..0161e5f3fa1 100644
--- a/tests/codegen/enum/enum-aggregate.rs
+++ b/tests/codegen/enum/enum-aggregate.rs
@@ -112,17 +112,14 @@ fn make_uninhabited_err_indirectly(n: Never) -> Result<u32, Never> {
 
 #[no_mangle]
 fn make_fully_uninhabited_result(v: u32, n: Never) -> Result<(u32, Never), (Never, u32)> {
-    // We don't try to do this in SSA form since the whole type is uninhabited.
+    // Actually reaching this would be UB, so we don't actually build a result.
 
     // CHECK-LABEL: { i32, i32 } @make_fully_uninhabited_result(i32 %v)
-    // CHECK: %[[ALLOC_V:.+]] = alloca [4 x i8]
-    // CHECK: %[[RET:.+]] = alloca [8 x i8]
-    // CHECK: store i32 %v, ptr %[[ALLOC_V]]
-    // CHECK: %[[TEMP_V:.+]] = load i32, ptr %[[ALLOC_V]]
-    // CHECK: %[[INNER:.+]] = getelementptr inbounds i8, ptr %[[RET]]
-    // CHECK: store i32 %[[TEMP_V]], ptr %[[INNER]]
-    // CHECK: call void @llvm.trap()
-    // CHECK: unreachable
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: call void @llvm.trap()
+    // CHECK-NEXT: call void @llvm.trap()
+    // CHECK-NEXT: call void @llvm.trap()
+    // CHECK-NEXT: unreachable
     Ok((v, n))
 }
 
diff --git a/tests/codegen/simd/aggregate-simd.rs b/tests/codegen/simd/aggregate-simd.rs
new file mode 100644
index 00000000000..065e429a4c7
--- /dev/null
+++ b/tests/codegen/simd/aggregate-simd.rs
@@ -0,0 +1,106 @@
+//@ compile-flags: -C opt-level=3 -C no-prepopulate-passes
+//@ only-64bit
+
+#![feature(core_intrinsics, repr_simd)]
+#![no_std]
+#![crate_type = "lib"]
+
+use core::intrinsics::simd::{simd_add, simd_extract};
+
+#[repr(simd)]
+#[derive(Clone, Copy)]
+pub struct Simd<T, const N: usize>([T; N]);
+
+#[repr(simd, packed)]
+#[derive(Clone, Copy)]
+pub struct PackedSimd<T, const N: usize>([T; N]);
+
+#[repr(transparent)]
+pub struct Transparent<T>(T);
+
+// These tests don't actually care about the add/extract, but it ensures the
+// aggregated temporaries are only used in potentially-SSA ways.
+
+#[no_mangle]
+pub fn simd_aggregate_pot(x: [u32; 4], y: [u32; 4]) -> u32 {
+    // CHECK-LABEL: simd_aggregate_pot
+    // CHECK: %a = load <4 x i32>, ptr %x, align 4
+    // CHECK: %b = load <4 x i32>, ptr %y, align 4
+    // CHECK: add <4 x i32> %a, %b
+
+    unsafe {
+        let a = Simd(x);
+        let b = Simd(y);
+        let c = simd_add(a, b);
+        simd_extract(c, 1)
+    }
+}
+
+#[no_mangle]
+pub fn simd_aggregate_npot(x: [u32; 7], y: [u32; 7]) -> u32 {
+    // CHECK-LABEL: simd_aggregate_npot
+    // CHECK: %a = load <7 x i32>, ptr %x, align 4
+    // CHECK: %b = load <7 x i32>, ptr %y, align 4
+    // CHECK: add <7 x i32> %a, %b
+
+    unsafe {
+        let a = Simd(x);
+        let b = Simd(y);
+        let c = simd_add(a, b);
+        simd_extract(c, 1)
+    }
+}
+
+#[no_mangle]
+pub fn packed_simd_aggregate_pot(x: [u32; 4], y: [u32; 4]) -> u32 {
+    // CHECK-LABEL: packed_simd_aggregate_pot
+    // CHECK: %a = load <4 x i32>, ptr %x, align 4
+    // CHECK: %b = load <4 x i32>, ptr %y, align 4
+    // CHECK: add <4 x i32> %a, %b
+
+    unsafe {
+        let a = PackedSimd(x);
+        let b = PackedSimd(y);
+        let c = simd_add(a, b);
+        simd_extract(c, 1)
+    }
+}
+
+#[no_mangle]
+pub fn packed_simd_aggregate_npot(x: [u32; 7], y: [u32; 7]) -> u32 {
+    // CHECK-LABEL: packed_simd_aggregate_npot
+    // CHECK: %b = alloca [28 x i8], align 4
+    // CHECK: %a = alloca [28 x i8], align 4
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a, ptr align 4 %x, i64 28, i1 false)
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %b, ptr align 4 %y, i64 28, i1 false)
+    // CHECK: %[[TEMPA:.+]] = load <7 x i32>, ptr %a, align 4
+    // CHECK: %[[TEMPB:.+]] = load <7 x i32>, ptr %b, align 4
+    // CHECK: add <7 x i32> %[[TEMPA]], %[[TEMPB]]
+
+    unsafe {
+        let a = PackedSimd(x);
+        let b = PackedSimd(y);
+        let c = simd_add(a, b);
+        simd_extract(c, 1)
+    }
+}
+
+#[no_mangle]
+pub fn transparent_simd_aggregate(x: [u32; 4]) -> u32 {
+    // The transparent wrapper can just use the same SSA value as its field.
+    // No extra processing or spilling needed.
+
+    // CHECK-LABEL: transparent_simd_aggregate
+    // CHECK-NOT: alloca
+    // CHECK: %[[RET:.+]] = alloca [4 x i8]
+    // CHECK-NOT: alloca
+    // CHECK: %a = load <4 x i32>, ptr %x, align 4
+    // CHECK: %[[TEMP:.+]] = extractelement <4 x i32> %a, i32 1
+    // CHECK: store i32 %[[TEMP]], ptr %[[RET]]
+
+    unsafe {
+        let a = Simd(x);
+        let b = Transparent(a);
+        simd_extract(b.0, 1)
+    }
+}
diff --git a/tests/codegen/union-aggregate.rs b/tests/codegen/union-aggregate.rs
index 3c6053379fa..aac66c5dcdd 100644
--- a/tests/codegen/union-aggregate.rs
+++ b/tests/codegen/union-aggregate.rs
@@ -4,6 +4,7 @@
 
 #![crate_type = "lib"]
 #![feature(transparent_unions)]
+#![feature(repr_simd)]
 
 #[repr(transparent)]
 union MU<T: Copy> {
@@ -83,3 +84,25 @@ fn make_mu_pair_uninit() -> MU<(u8, u32)> {
     // CHECK-NEXT: ret { i8, i32 } undef
     MU { uninit: () }
 }
+
+#[repr(simd)]
+#[derive(Copy, Clone)]
+struct I32X32([i32; 32]);
+
+#[no_mangle]
+fn make_mu_simd(x: I32X32) -> MU<I32X32> {
+    // CHECK-LABEL: void @make_mu_simd(ptr{{.+}}%_0, ptr{{.+}}%x)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %[[TEMP:.+]] = load <32 x i32>, ptr %x,
+    // CHECK-NEXT: store <32 x i32> %[[TEMP]], ptr %_0,
+    // CHECK-NEXT: ret void
+    MU { value: x }
+}
+
+#[no_mangle]
+fn make_mu_simd_uninit() -> MU<I32X32> {
+    // CHECK-LABEL: void @make_mu_simd_uninit(ptr{{.+}}%_0)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret void
+    MU { uninit: () }
+}
-- 
cgit 1.4.1-3-g733a5


From 0d306dd7f43574eede5bfdd883c298a07da0b2cc Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 8 Jul 2025 08:22:53 +0200
Subject: Preparing for merge from rustc

---
 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 7ca7acb3fd7..a9394819541 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-ca98d4d4b3114116203699c2734805547df86f9a
+688ea65df6a47866d0f72a00f1e18b47a7edf83b
-- 
cgit 1.4.1-3-g733a5


From 2f20628da281cf08436659f578d1498d85aee9e5 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 22:15:27 +0200
Subject: Remove josh-sync crate

---
 library/compiler-builtins/Cargo.toml               |   1 -
 .../compiler-builtins/crates/josh-sync/Cargo.toml  |   8 -
 .../compiler-builtins/crates/josh-sync/src/main.rs |  45 ---
 .../compiler-builtins/crates/josh-sync/src/sync.rs | 401 ---------------------
 4 files changed, 455 deletions(-)
 delete mode 100644 library/compiler-builtins/crates/josh-sync/Cargo.toml
 delete mode 100644 library/compiler-builtins/crates/josh-sync/src/main.rs
 delete mode 100644 library/compiler-builtins/crates/josh-sync/src/sync.rs

diff --git a/library/compiler-builtins/Cargo.toml b/library/compiler-builtins/Cargo.toml
index 41350c6cb99..956d738f3b1 100644
--- a/library/compiler-builtins/Cargo.toml
+++ b/library/compiler-builtins/Cargo.toml
@@ -3,7 +3,6 @@ resolver = "2"
 members = [
     "builtins-shim",
     "builtins-test",
-    "crates/josh-sync",
     "crates/libm-macros",
     "crates/musl-math-sys",
     "crates/panic-handler",
diff --git a/library/compiler-builtins/crates/josh-sync/Cargo.toml b/library/compiler-builtins/crates/josh-sync/Cargo.toml
deleted file mode 100644
index 8e2e891db54..00000000000
--- a/library/compiler-builtins/crates/josh-sync/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[package]
-name = "josh-sync"
-edition = "2024"
-publish = false
-
-[dependencies]
-directories = "6.0.0"
-regex-lite = "0.1.6"
diff --git a/library/compiler-builtins/crates/josh-sync/src/main.rs b/library/compiler-builtins/crates/josh-sync/src/main.rs
deleted file mode 100644
index 7f0b1190033..00000000000
--- a/library/compiler-builtins/crates/josh-sync/src/main.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use std::io::{Read, Write};
-use std::process::exit;
-use std::{env, io};
-
-use crate::sync::{GitSync, Josh};
-
-mod sync;
-
-const USAGE: &str = r#"Utility for synchroniing compiler-builtins with rust-lang/rust
-
-Usage:
-
-    josh-sync rustc-pull
-
-        Pull from rust-lang/rust to compiler-builtins. Creates a commit
-        updating the version file, followed by a merge commit.
-
-    josh-sync rustc-push GITHUB_USERNAME [BRANCH]
-
-        Create a branch off of rust-lang/rust updating compiler-builtins.
-"#;
-
-fn main() {
-    let sync = GitSync::from_current_dir();
-
-    // Collect args, then recollect as str refs so we can match on them
-    let args: Vec<_> = env::args().collect();
-    let args: Vec<&str> = args.iter().map(String::as_str).collect();
-
-    match args.as_slice()[1..] {
-        ["rustc-pull"] => sync.rustc_pull(None),
-        ["rustc-push", github_user, branch] => sync.rustc_push(github_user, Some(branch)),
-        ["rustc-push", github_user] => sync.rustc_push(github_user, None),
-        ["start-josh"] => {
-            let _josh = Josh::start();
-            println!("press enter to stop");
-            io::stdout().flush().unwrap();
-            let _ = io::stdin().read(&mut [0u8]).unwrap();
-        }
-        _ => {
-            println!("{USAGE}");
-            exit(1);
-        }
-    }
-}
diff --git a/library/compiler-builtins/crates/josh-sync/src/sync.rs b/library/compiler-builtins/crates/josh-sync/src/sync.rs
deleted file mode 100644
index 2d89d2d1cea..00000000000
--- a/library/compiler-builtins/crates/josh-sync/src/sync.rs
+++ /dev/null
@@ -1,401 +0,0 @@
-use std::borrow::Cow;
-use std::net::{SocketAddr, TcpStream};
-use std::process::{Command, Stdio, exit};
-use std::time::Duration;
-use std::{env, fs, process, thread};
-
-use regex_lite::Regex;
-
-const JOSH_PORT: u16 = 42042;
-const DEFAULT_PR_BRANCH: &str = "update-builtins";
-
-pub struct GitSync {
-    upstream_repo: String,
-    upstream_ref: String,
-    upstream_url: String,
-    josh_filter: String,
-    josh_url_base: String,
-}
-
-/// This code was adapted from the miri repository, via the rustc-dev-guide
-/// (<https://github.com/rust-lang/rustc-dev-guide/tree/c51adbd12d/josh-sync>)
-impl GitSync {
-    pub fn from_current_dir() -> Self {
-        let upstream_repo =
-            env::var("UPSTREAM_ORG").unwrap_or_else(|_| "rust-lang".to_owned()) + "/rust";
-
-        Self {
-            upstream_url: format!("https://github.com/{upstream_repo}"),
-            upstream_repo,
-            upstream_ref: env::var("UPSTREAM_REF").unwrap_or_else(|_| "HEAD".to_owned()),
-            josh_filter: ":/library/compiler-builtins".to_owned(),
-            josh_url_base: format!("http://localhost:{JOSH_PORT}"),
-        }
-    }
-
-    /// Pull from rust-lang/rust to compiler-builtins.
-    pub fn rustc_pull(&self, commit: Option<String>) {
-        let Self {
-            upstream_ref,
-            upstream_url,
-            upstream_repo,
-            ..
-        } = self;
-
-        let new_upstream_base = commit.unwrap_or_else(|| {
-            let out = check_output(["git", "ls-remote", upstream_url, upstream_ref]);
-            out.split_whitespace()
-                .next()
-                .unwrap_or_else(|| panic!("could not split output: '{out}'"))
-                .to_owned()
-        });
-
-        ensure_clean();
-
-        // Make sure josh is running.
-        let _josh = Josh::start();
-        let josh_url_filtered = self.josh_url(
-            &self.upstream_repo,
-            Some(&new_upstream_base),
-            Some(&self.josh_filter),
-        );
-
-        let previous_upstream_base = fs::read_to_string("rust-version")
-            .expect("failed to read `rust-version`")
-            .trim()
-            .to_string();
-        assert_ne!(previous_upstream_base, new_upstream_base, "nothing to pull");
-
-        let orig_head = check_output(["git", "rev-parse", "HEAD"]);
-        println!("original upstream base: {previous_upstream_base}");
-        println!("new upstream base: {new_upstream_base}");
-        println!("original HEAD: {orig_head}");
-
-        // Fetch the latest upstream HEAD so we can get a summary. Use the Josh URL for caching.
-        run([
-            "git",
-            "fetch",
-            &self.josh_url(&self.upstream_repo, Some(&new_upstream_base), Some(":/")),
-            &new_upstream_base,
-            "--depth=1",
-        ]);
-        let new_summary = check_output(["git", "log", "-1", "--format=%h %s", &new_upstream_base]);
-        let new_summary = replace_references(&new_summary, &self.upstream_repo);
-
-        // Update rust-version file. As a separate commit, since making it part of
-        // the merge has confused the heck out of josh in the past.
-        // We pass `--no-verify` to avoid running git hooks.
-        // We do this before the merge so that if there are merge conflicts, we have
-        // the right rust-version file while resolving them.
-        fs::write("rust-version", format!("{new_upstream_base}\n"))
-            .expect("failed to write rust-version");
-
-        let prep_message = format!(
-            "Update the upstream Rust version\n\n\
-            To prepare for merging from {upstream_repo}, set the version file to:\n\n    \
-            {new_summary}\n\
-            ",
-        );
-        run([
-            "git",
-            "commit",
-            "rust-version",
-            "--no-verify",
-            "-m",
-            &prep_message,
-        ]);
-
-        // Fetch given rustc commit.
-        run(["git", "fetch", &josh_url_filtered]);
-        let incoming_ref = check_output(["git", "rev-parse", "FETCH_HEAD"]);
-        println!("incoming ref: {incoming_ref}");
-
-        let merge_message = format!(
-            "Merge ref '{upstream_head_short}{filter}' from {upstream_url}\n\n\
-            Pull recent changes from {upstream_repo} via Josh.\n\n\
-            Upstream ref: {new_upstream_base}\n\
-            Filtered ref: {incoming_ref}\n\
-            ",
-            upstream_head_short = &new_upstream_base[..12],
-            filter = self.josh_filter
-        );
-
-        // This should not add any new root commits. So count those before and after merging.
-        let num_roots = || -> u32 {
-            let out = check_output(["git", "rev-list", "HEAD", "--max-parents=0", "--count"]);
-            out.trim()
-                .parse::<u32>()
-                .unwrap_or_else(|e| panic!("failed to parse `{out}`: {e}"))
-        };
-        let num_roots_before = num_roots();
-
-        let pre_merge_sha = check_output(["git", "rev-parse", "HEAD"]);
-        println!("pre-merge HEAD: {pre_merge_sha}");
-
-        // Merge the fetched commit.
-        run([
-            "git",
-            "merge",
-            "FETCH_HEAD",
-            "--no-verify",
-            "--no-ff",
-            "-m",
-            &merge_message,
-        ]);
-
-        let current_sha = check_output(["git", "rev-parse", "HEAD"]);
-        if current_sha == pre_merge_sha {
-            run(["git", "reset", "--hard", &orig_head]);
-            eprintln!(
-                "No merge was performed, no changes to pull were found. \
-                Rolled back the preparation commit."
-            );
-            exit(1);
-        }
-
-        // Check that the number of roots did not increase.
-        assert_eq!(
-            num_roots(),
-            num_roots_before,
-            "Josh created a new root commit. This is probably not the history you want."
-        );
-    }
-
-    /// Construct an update to rust-lang/rust from compiler-builtins.
-    pub fn rustc_push(&self, github_user: &str, branch: Option<&str>) {
-        let Self {
-            josh_filter,
-            upstream_url,
-            ..
-        } = self;
-
-        let branch = branch.unwrap_or(DEFAULT_PR_BRANCH);
-        let josh_url = self.josh_url(&format!("{github_user}/rust"), None, Some(josh_filter));
-        let user_upstream_url = format!("git@github.com:{github_user}/rust.git");
-
-        let Ok(rustc_git) = env::var("RUSTC_GIT") else {
-            panic!("the RUSTC_GIT environment variable must be set to a rust-lang/rust checkout")
-        };
-
-        ensure_clean();
-        let base = fs::read_to_string("rust-version")
-            .expect("failed to read `rust-version`")
-            .trim()
-            .to_string();
-
-        // Make sure josh is running.
-        let _josh = Josh::start();
-
-        // Prepare the branch. Pushing works much better if we use as base exactly
-        // the commit that we pulled from last time, so we use the `rust-version`
-        // file to find out which commit that would be.
-        println!("Preparing {github_user}/rust (base: {base})...");
-
-        if Command::new("git")
-            .args(["-C", &rustc_git, "fetch", &user_upstream_url, branch])
-            .output() // capture output
-            .expect("could not run fetch")
-            .status
-            .success()
-        {
-            panic!(
-                "The branch '{branch}' seems to already exist in '{user_upstream_url}'. \
-                 Please delete it and try again."
-            );
-        }
-
-        run(["git", "-C", &rustc_git, "fetch", upstream_url, &base]);
-
-        run_cfg("git", |c| {
-            c.args([
-                "-C",
-                &rustc_git,
-                "push",
-                &user_upstream_url,
-                &format!("{base}:refs/heads/{branch}"),
-            ])
-            .stdout(Stdio::null())
-            .stderr(Stdio::null()) // silence the "create GitHub PR" message
-        });
-        println!("pushed PR branch");
-
-        // Do the actual push.
-        println!("Pushing changes...");
-        run(["git", "push", &josh_url, &format!("HEAD:{branch}")]);
-        println!();
-
-        // Do a round-trip check to make sure the push worked as expected.
-        run(["git", "fetch", &josh_url, branch]);
-
-        let head = check_output(["git", "rev-parse", "HEAD"]);
-        let fetch_head = check_output(["git", "rev-parse", "FETCH_HEAD"]);
-        assert_eq!(
-            head, fetch_head,
-            "Josh created a non-roundtrip push! Do NOT merge this into rustc!\n\
-             Expected {head}, got {fetch_head}."
-        );
-        println!(
-            "Confirmed that the push round-trips back to compiler-builtins properly. Please \
-            create a rustc PR:"
-        );
-        // Open PR with `subtree update` title to silence the `no-merges` triagebot check
-        println!(
-            "    {upstream_url}/compare/{github_user}:{branch}?quick_pull=1\
-            &title=Update%20the%20%60compiler-builtins%60%20subtree\
-            &body=Update%20the%20Josh%20subtree%20to%20https%3A%2F%2Fgithub.com%2Frust-lang%2F\
-            compiler-builtins%2Fcommit%2F{head_short}.%0A%0Ar%3F%20%40ghost",
-            head_short = &head[..12],
-        );
-    }
-
-    /// Construct a url to the local Josh server with (optionally)
-    fn josh_url(&self, repo: &str, rev: Option<&str>, filter: Option<&str>) -> String {
-        format!(
-            "{base}/{repo}.git{at}{rev}{filter}{filt_git}",
-            base = self.josh_url_base,
-            at = if rev.is_some() { "@" } else { "" },
-            rev = rev.unwrap_or_default(),
-            filter = filter.unwrap_or_default(),
-            filt_git = if filter.is_some() { ".git" } else { "" }
-        )
-    }
-}
-
-/// Fail if there are files that need to be checked in.
-fn ensure_clean() {
-    let read = check_output(["git", "status", "--untracked-files=no", "--porcelain"]);
-    assert!(
-        read.is_empty(),
-        "working directory must be clean before performing rustc pull"
-    );
-}
-
-/* Helpers for running commands with logged invocations */
-
-/// Run a command from an array, passing its output through.
-fn run<'a, Args: AsRef<[&'a str]>>(l: Args) {
-    let l = l.as_ref();
-    run_cfg(l[0], |c| c.args(&l[1..]));
-}
-
-/// Run a command from an array, collecting its output.
-fn check_output<'a, Args: AsRef<[&'a str]>>(l: Args) -> String {
-    let l = l.as_ref();
-    check_output_cfg(l[0], |c| c.args(&l[1..]))
-}
-
-/// [`run`] with configuration.
-fn run_cfg(prog: &str, f: impl FnOnce(&mut Command) -> &mut Command) {
-    // self.read(l.as_ref());
-    check_output_cfg(prog, |c| f(c.stdout(Stdio::inherit())));
-}
-
-/// [`read`] with configuration. All shell helpers print the command and pass stderr.
-fn check_output_cfg(prog: &str, f: impl FnOnce(&mut Command) -> &mut Command) -> String {
-    let mut cmd = Command::new(prog);
-    cmd.stderr(Stdio::inherit());
-    f(&mut cmd);
-    eprintln!("+ {cmd:?}");
-    let out = cmd.output().expect("command failed");
-    assert!(out.status.success());
-    String::from_utf8(out.stdout.trim_ascii().to_vec()).expect("non-UTF8 output")
-}
-
-/// Replace `#1234`-style issue/PR references with `repo#1234` to ensure links work across
-/// repositories.
-fn replace_references<'a>(s: &'a str, repo: &str) -> Cow<'a, str> {
-    let re = Regex::new(r"\B(?P<id>#\d+)\b").unwrap();
-    re.replace(s, &format!("{repo}$id"))
-}
-
-/// Create a wrapper that stops Josh on drop.
-pub struct Josh(process::Child);
-
-impl Josh {
-    pub fn start() -> Self {
-        // Determine cache directory.
-        let user_dirs =
-            directories::ProjectDirs::from("org", "rust-lang", "rustc-compiler-builtins-josh")
-                .unwrap();
-        let local_dir = user_dirs.cache_dir().to_owned();
-
-        // Start josh, silencing its output.
-        #[expect(clippy::zombie_processes, reason = "clippy can't handle the loop")]
-        let josh = process::Command::new("josh-proxy")
-            .arg("--local")
-            .arg(local_dir)
-            .args([
-                "--remote=https://github.com",
-                &format!("--port={JOSH_PORT}"),
-                "--no-background",
-            ])
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .spawn()
-            .expect("failed to start josh-proxy, make sure it is installed");
-
-        // Wait until the port is open. We try every 10ms until 1s passed.
-        for _ in 0..100 {
-            // This will generally fail immediately when the port is still closed.
-            let addr = SocketAddr::from(([127, 0, 0, 1], JOSH_PORT));
-            let josh_ready = TcpStream::connect_timeout(&addr, Duration::from_millis(1));
-
-            if josh_ready.is_ok() {
-                println!("josh up and running");
-                return Josh(josh);
-            }
-
-            // Not ready yet.
-            thread::sleep(Duration::from_millis(10));
-        }
-        panic!("Even after waiting for 1s, josh-proxy is still not available.")
-    }
-}
-
-impl Drop for Josh {
-    fn drop(&mut self) {
-        if cfg!(unix) {
-            // Try to gracefully shut it down.
-            Command::new("kill")
-                .args(["-s", "INT", &self.0.id().to_string()])
-                .output()
-                .expect("failed to SIGINT josh-proxy");
-            // Sadly there is no "wait with timeout"... so we just give it some time to finish.
-            thread::sleep(Duration::from_millis(100));
-            // Now hopefully it is gone.
-            if self
-                .0
-                .try_wait()
-                .expect("failed to wait for josh-proxy")
-                .is_some()
-            {
-                return;
-            }
-        }
-        // If that didn't work (or we're not on Unix), kill it hard.
-        eprintln!(
-            "I have to kill josh-proxy the hard way, let's hope this does not \
-            break anything."
-        );
-        self.0.kill().expect("failed to SIGKILL josh-proxy");
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_replace() {
-        assert_eq!(replace_references("#1234", "r-l/rust"), "r-l/rust#1234");
-        assert_eq!(replace_references("#1234x", "r-l/rust"), "#1234x");
-        assert_eq!(
-            replace_references("merge #1234", "r-l/rust"),
-            "merge r-l/rust#1234"
-        );
-        assert_eq!(
-            replace_references("foo/bar#1234", "r-l/rust"),
-            "foo/bar#1234"
-        );
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From f2b5199f4f3c8abd8bc0fd660717f3d6ec049a76 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 22:15:56 +0200
Subject: Add josh-sync config file

---
 library/compiler-builtins/josh-sync.toml | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 library/compiler-builtins/josh-sync.toml

diff --git a/library/compiler-builtins/josh-sync.toml b/library/compiler-builtins/josh-sync.toml
new file mode 100644
index 00000000000..599a12af8e5
--- /dev/null
+++ b/library/compiler-builtins/josh-sync.toml
@@ -0,0 +1,3 @@
+org = "rust-lang"
+repo = "compiler-builtins"
+path = "library/compiler-builtins"
-- 
cgit 1.4.1-3-g733a5


From 922ee88762e36dea38113f84ca3898b2e59531ee Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 8 Jul 2025 08:57:05 +0200
Subject: Mention that stdarch is managed by josh-sync

---
 src/doc/rustc-dev-guide/src/external-repos.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/external-repos.md b/src/doc/rustc-dev-guide/src/external-repos.md
index fc40b5d2bfa..0f7322357b9 100644
--- a/src/doc/rustc-dev-guide/src/external-repos.md
+++ b/src/doc/rustc-dev-guide/src/external-repos.md
@@ -43,9 +43,9 @@ implement a new tool feature or test, that should happen in one collective rustc
 * Using the [josh] tool
     * `miri` ([sync guide](https://github.com/rust-lang/miri/blob/master/CONTRIBUTING.md#advanced-topic-syncing-with-the-rustc-repo))
     * `rust-analyzer` ([sync script](https://github.com/rust-lang/rust-analyzer/blob/2e13684be123eca7181aa48e043e185d8044a84a/xtask/src/release.rs#L147))
-    * `rustc-dev-guide`
+    * `rustc-dev-guide` ([josh sync](#synchronizing-a-josh-subtree))
     * `compiler-builtins`
-    * `stdarch`
+    * `stdarch` ([josh sync](#synchronizing-a-josh-subtree))
 
 ### Josh subtrees
 
@@ -57,6 +57,7 @@ We use a dedicated tool called [`rustc-josh-sync`][josh-sync] for performing Jos
 Currently, we are migrating Josh repositories to it. So far, it is used in:
 
 - rustc-dev-guide
+- stdarch
 
 To use the tool, first install it with `cargo install --locked --git https://github.com/rust-lang/josh-sync`.
 
-- 
cgit 1.4.1-3-g733a5


From 8d0c55cb6b39f3c7b1931ccd739dece821a4ced2 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Mon, 7 Jul 2025 23:08:33 +0200
Subject: Remove test hack for std crates

---
 src/bootstrap/src/core/build_steps/compile.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 3e2bdc2d6b5..6dec950266d 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -451,11 +451,6 @@ fn copy_self_contained_objects(
 
 /// Resolves standard library crates for `Std::run_make` for any build kind (like check, build, clippy, etc.).
 pub fn std_crates_for_run_make(run: &RunConfig<'_>) -> Vec<String> {
-    // FIXME: Extend builder tests to cover the `crates` field of `Std` instances.
-    if cfg!(test) {
-        return vec![];
-    }
-
     let has_alias = run.paths.iter().any(|set| set.assert_single_path().path.ends_with("library"));
     let target_is_no_std = run.builder.no_std(run.target).unwrap_or(false);
 
-- 
cgit 1.4.1-3-g733a5


From 5880a3196be4137e2b70bcc5d432dea20155fc13 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Mon, 7 Jul 2025 23:11:18 +0200
Subject: Add `crates` metadata to `doc::Std` step

---
 src/bootstrap/src/core/build_steps/doc.rs |  6 ++++-
 src/bootstrap/src/core/builder/tests.rs   | 38 +++++++++++++++----------------
 2 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index f7c4c5ad0bb..48dde4aae68 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -665,7 +665,11 @@ impl Step for Std {
     }
 
     fn metadata(&self) -> Option<StepMetadata> {
-        Some(StepMetadata::doc("std", self.target).stage(self.stage))
+        Some(
+            StepMetadata::doc("std", self.target)
+                .stage(self.stage)
+                .with_metadata(format!("crates=[{}]", self.crates.join(","))),
+        )
     }
 }
 
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 9433e15f6ff..3d889729f90 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -942,7 +942,7 @@ mod snapshot {
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustdoc 0 <host>
-        [doc] std 1 <host>
+        [doc] std 1 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
         ");
     }
 
@@ -991,12 +991,12 @@ mod snapshot {
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <host>
+        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> LintDocs 1 <host>
         [build] rustc 0 <host> -> RustInstaller 1 <host>
         [dist] docs <host>
-        [doc] std 2 <host>
+        [doc] std 2 <host> crates=[]
         [dist] mingw <host>
         [build] rustc 0 <host> -> GenerateCopyright 1 <host>
         [dist] rustc <host>
@@ -1023,12 +1023,12 @@ mod snapshot {
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustc 1 <host> -> WasmComponentLd 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <host>
+        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> LintDocs 1 <host>
         [build] rustc 0 <host> -> RustInstaller 1 <host>
         [dist] docs <host>
-        [doc] std 2 <host>
+        [doc] std 2 <host> crates=[]
         [dist] mingw <host>
         [build] rustc 0 <host> -> GenerateCopyright 1 <host>
         [dist] rustc <host>
@@ -1059,15 +1059,15 @@ mod snapshot {
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <host>
-        [doc] std 2 <target1>
+        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> LintDocs 1 <host>
         [build] rustc 0 <host> -> RustInstaller 1 <host>
         [dist] docs <host>
         [dist] docs <target1>
-        [doc] std 2 <host>
-        [doc] std 2 <target1>
+        [doc] std 2 <host> crates=[]
+        [doc] std 2 <target1> crates=[]
         [dist] mingw <host>
         [dist] mingw <target1>
         [build] rustc 0 <host> -> GenerateCopyright 1 <host>
@@ -1096,14 +1096,14 @@ mod snapshot {
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <host>
+        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> LintDocs 1 <host>
         [build] rustc 1 <host> -> std 1 <target1>
         [build] rustc 2 <host> -> std 2 <target1>
         [build] rustc 0 <host> -> RustInstaller 1 <host>
         [dist] docs <host>
-        [doc] std 2 <host>
+        [doc] std 2 <host> crates=[]
         [dist] mingw <host>
         [build] rustc 0 <host> -> GenerateCopyright 1 <host>
         [dist] rustc <host>
@@ -1133,8 +1133,8 @@ mod snapshot {
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <host>
-        [doc] std 2 <target1>
+        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> LintDocs 1 <host>
         [build] rustc 1 <host> -> std 1 <target1>
@@ -1142,8 +1142,8 @@ mod snapshot {
         [build] rustc 0 <host> -> RustInstaller 1 <host>
         [dist] docs <host>
         [dist] docs <target1>
-        [doc] std 2 <host>
-        [doc] std 2 <target1>
+        [doc] std 2 <host> crates=[]
+        [doc] std 2 <target1> crates=[]
         [dist] mingw <host>
         [dist] mingw <target1>
         [build] rustc 0 <host> -> GenerateCopyright 1 <host>
@@ -1175,11 +1175,11 @@ mod snapshot {
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <target1>
+        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> RustInstaller 1 <host>
         [dist] docs <target1>
-        [doc] std 2 <target1>
+        [doc] std 2 <target1> crates=[]
         [dist] mingw <target1>
         [build] rustc 2 <host> -> std 2 <target1>
         [dist] rustc 2 <host> -> std 2 <target1>
@@ -1207,14 +1207,14 @@ mod snapshot {
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustc 1 <host> -> WasmComponentLd 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <target1>
+        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 1 <host> -> std 1 <target1>
         [build] rustc 2 <host> -> std 2 <target1>
         [build] rustc 0 <host> -> LintDocs 1 <host>
         [build] rustc 0 <host> -> RustInstaller 1 <host>
         [dist] docs <target1>
-        [doc] std 2 <target1>
+        [doc] std 2 <target1> crates=[]
         [dist] mingw <target1>
         [build] llvm <target1>
         [build] rustc 1 <host> -> rustc 2 <target1>
-- 
cgit 1.4.1-3-g733a5


From d6bc881afb69047afb32a23664be6ffa75219f1c Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Mon, 7 Jul 2025 23:31:03 +0200
Subject: Fix handling of std crates for no_std targets

---
 src/bootstrap/src/core/build_steps/compile.rs | 25 +++----
 src/bootstrap/src/core/builder/tests.rs       | 94 +++++++++++++++++++++------
 src/bootstrap/src/utils/tests/mod.rs          | 28 ++++----
 3 files changed, 106 insertions(+), 41 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 6dec950266d..caf2d83d213 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -449,21 +449,24 @@ fn copy_self_contained_objects(
     target_deps
 }
 
-/// Resolves standard library crates for `Std::run_make` for any build kind (like check, build, clippy, etc.).
+/// Resolves standard library crates for `Std::run_make` for any build kind (like check, doc,
+/// build, clippy, etc.).
 pub fn std_crates_for_run_make(run: &RunConfig<'_>) -> Vec<String> {
-    let has_alias = run.paths.iter().any(|set| set.assert_single_path().path.ends_with("library"));
+    let mut crates = run.make_run_crates(builder::Alias::Library);
+
+    // For no_std targets, we only want to check core and alloc
+    // Regardless of core/alloc being selected explicitly or via the "library" default alias,
+    // we only want to keep these two crates.
+    // The set of no_std crates should be kept in sync with what `Builder::std_cargo` does.
+    // Note: an alternative design would be to return an enum from this function (Default vs Subset)
+    // of crates. However, several steps currently pass `-p <package>` even if all crates are
+    // selected, because Cargo behaves differently in that case. To keep that behavior without
+    // making further changes, we pre-filter the no-std crates here.
     let target_is_no_std = run.builder.no_std(run.target).unwrap_or(false);
-
-    // For no_std targets, do not add any additional crates to the compilation other than what `compile::std_cargo` already adds for no_std targets.
     if target_is_no_std {
-        vec![]
-    }
-    // If the paths include "library", build the entire standard library.
-    else if has_alias {
-        run.make_run_crates(builder::Alias::Library)
-    } else {
-        run.cargo_crates_in_set()
+        crates.retain(|c| c == "core" || c == "alloc");
     }
+    crates
 }
 
 /// Tries to find LLVM's `compiler-rt` source directory, for building `library/profiler_builtins`.
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 3d889729f90..b1e8150a20f 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -637,8 +637,8 @@ mod snapshot {
 
     use crate::core::build_steps::{compile, dist, doc, test, tool};
     use crate::core::builder::tests::{
-        TEST_TRIPLE_1, TEST_TRIPLE_2, TEST_TRIPLE_3, configure, configure_with_args, first,
-        host_target, render_steps, run_build,
+        RenderConfig, TEST_TRIPLE_1, TEST_TRIPLE_2, TEST_TRIPLE_3, configure, configure_with_args,
+        first, host_target, render_steps, run_build,
     };
     use crate::core::builder::{Builder, Kind, StepDescription, StepMetadata};
     use crate::core::config::TargetSelection;
@@ -1521,6 +1521,49 @@ mod snapshot {
         steps.assert_contains(StepMetadata::test("CrateLibrustc", host));
         steps.assert_contains_fuzzy(StepMetadata::build("rustc", host));
     }
+
+    #[test]
+    fn doc_library() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("doc")
+                .path("library")
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustdoc 0 <host>
+        [doc] std 1 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        ");
+    }
+
+    #[test]
+    fn doc_core() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("doc")
+                .path("core")
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustdoc 0 <host>
+        [doc] std 1 <host> crates=[core]
+        ");
+    }
+
+    #[test]
+    fn doc_library_no_std_target() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("doc")
+                .path("core")
+                .override_target_no_std(&host_target())
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustdoc 0 <host>
+        [doc] std 1 <host> crates=[core]
+        ");
+    }
 }
 
 struct ExecutedSteps {
@@ -1529,7 +1572,10 @@ struct ExecutedSteps {
 
 impl ExecutedSteps {
     fn render(&self) -> String {
-        render_steps(&self.steps)
+        self.render_with(RenderConfig::default())
+    }
+    fn render_with(&self, config: RenderConfig) -> String {
+        render_steps(&self.steps, config)
     }
 
     #[track_caller]
@@ -1538,7 +1584,7 @@ impl ExecutedSteps {
         if !self.contains(&metadata) {
             panic!(
                 "Metadata `{}` ({metadata:?}) not found in executed steps:\n{}",
-                render_metadata(&metadata),
+                render_metadata(&metadata, &RenderConfig::default()),
                 self.render()
             );
         }
@@ -1553,7 +1599,7 @@ impl ExecutedSteps {
         if !self.contains_fuzzy(&metadata) {
             panic!(
                 "Metadata `{}` ({metadata:?}) not found in executed steps:\n{}",
-                render_metadata(&metadata),
+                render_metadata(&metadata, &RenderConfig::default()),
                 self.render()
             );
         }
@@ -1565,7 +1611,7 @@ impl ExecutedSteps {
         if self.contains(&metadata) {
             panic!(
                 "Metadata `{}` ({metadata:?}) found in executed steps (it should not be there):\n{}",
-                render_metadata(&metadata),
+                render_metadata(&metadata, &RenderConfig::default()),
                 self.render()
             );
         }
@@ -1618,6 +1664,16 @@ impl ConfigBuilder {
     }
 }
 
+struct RenderConfig {
+    normalize_host: bool,
+}
+
+impl Default for RenderConfig {
+    fn default() -> Self {
+        Self { normalize_host: true }
+    }
+}
+
 /// Renders the executed bootstrap steps for usage in snapshot tests with insta.
 /// Only renders certain important steps.
 /// Each value in `steps` should be a tuple of (Step, step output).
@@ -1625,7 +1681,7 @@ impl ConfigBuilder {
 /// The arrow in the rendered output (`X -> Y`) means `X builds Y`.
 /// This is similar to the output printed by bootstrap to stdout, but here it is
 /// generated purely for the purpose of tests.
-fn render_steps(steps: &[ExecutedStep]) -> String {
+fn render_steps(steps: &[ExecutedStep], config: RenderConfig) -> String {
     steps
         .iter()
         .filter_map(|step| {
@@ -1635,35 +1691,35 @@ fn render_steps(steps: &[ExecutedStep]) -> String {
                 return None;
             };
 
-            Some(render_metadata(&metadata))
+            Some(render_metadata(&metadata, &config))
         })
         .collect::<Vec<_>>()
         .join("\n")
 }
 
-fn render_metadata(metadata: &StepMetadata) -> String {
+fn render_metadata(metadata: &StepMetadata, config: &RenderConfig) -> String {
     let mut record = format!("[{}] ", metadata.kind.as_str());
     if let Some(compiler) = metadata.built_by {
-        write!(record, "{} -> ", render_compiler(compiler));
+        write!(record, "{} -> ", render_compiler(compiler, config));
     }
     let stage = metadata.get_stage().map(|stage| format!("{stage} ")).unwrap_or_default();
-    write!(record, "{} {stage}<{}>", metadata.name, normalize_target(metadata.target));
+    write!(record, "{} {stage}<{}>", metadata.name, normalize_target(metadata.target, config));
     if let Some(metadata) = &metadata.metadata {
         write!(record, " {metadata}");
     }
     record
 }
 
-fn normalize_target(target: TargetSelection) -> String {
-    target
-        .to_string()
-        .replace(&host_target(), "host")
-        .replace(TEST_TRIPLE_1, "target1")
-        .replace(TEST_TRIPLE_2, "target2")
+fn normalize_target(target: TargetSelection, config: &RenderConfig) -> String {
+    let mut target = target.to_string();
+    if config.normalize_host {
+        target = target.replace(&host_target(), "host");
+    }
+    target.replace(TEST_TRIPLE_1, "target1").replace(TEST_TRIPLE_2, "target2")
 }
 
-fn render_compiler(compiler: Compiler) -> String {
-    format!("rustc {} <{}>", compiler.stage, normalize_target(compiler.host))
+fn render_compiler(compiler: Compiler, config: &RenderConfig) -> String {
+    format!("rustc {} <{}>", compiler.stage, normalize_target(compiler.host, config))
 }
 
 fn host_target() -> String {
diff --git a/src/bootstrap/src/utils/tests/mod.rs b/src/bootstrap/src/utils/tests/mod.rs
index 59c169b0f2b..0e516b45268 100644
--- a/src/bootstrap/src/utils/tests/mod.rs
+++ b/src/bootstrap/src/utils/tests/mod.rs
@@ -48,17 +48,30 @@ impl ConfigBuilder {
     }
 
     pub fn path(mut self, path: &str) -> Self {
-        self.args.push(path.to_string());
-        self
+        self.arg(path)
     }
 
     pub fn paths(mut self, paths: &[&str]) -> Self {
-        for path in paths {
-            self = self.path(path);
+        self.args(paths)
+    }
+
+    pub fn arg(mut self, arg: &str) -> Self {
+        self.args.push(arg.to_string());
+        self
+    }
+
+    pub fn args(mut self, args: &[&str]) -> Self {
+        for arg in args {
+            self = self.arg(arg);
         }
         self
     }
 
+    /// Set the specified target to be treated as a no_std target.
+    pub fn override_target_no_std(mut self, target: &str) -> Self {
+        self.args(&["--set", &format!("target.{target}.no-std=true")])
+    }
+
     pub fn hosts(mut self, targets: &[&str]) -> Self {
         self.args.push("--host".to_string());
         self.args.push(targets.join(","));
@@ -77,13 +90,6 @@ impl ConfigBuilder {
         self
     }
 
-    pub fn args(mut self, args: &[&str]) -> Self {
-        for arg in args {
-            self.args.push(arg.to_string());
-        }
-        self
-    }
-
     pub fn create_config(mut self) -> Config {
         // Run in dry-check, otherwise the test would be too slow
         self.args.push("--dry-run".to_string());
-- 
cgit 1.4.1-3-g733a5


From a4ea949356b8d40e7c588cccf30739fbb22cd45c Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Mon, 17 Mar 2025 21:57:44 +0100
Subject: use LLD by default on x64 regardless of channel

---
 src/bootstrap/src/core/build_steps/compile.rs | 4 +---
 src/bootstrap/src/core/config/toml/rust.rs    | 5 +----
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 3e2bdc2d6b5..ca74771bb6e 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -1369,9 +1369,7 @@ pub fn rustc_cargo_env(
     }
 
     // Enable rustc's env var for `rust-lld` when requested.
-    if builder.config.lld_enabled
-        && (builder.config.channel == "dev" || builder.config.channel == "nightly")
-    {
+    if builder.config.lld_enabled {
         cargo.env("CFG_USE_SELF_CONTAINED_LINKER", "1");
     }
 
diff --git a/src/bootstrap/src/core/config/toml/rust.rs b/src/bootstrap/src/core/config/toml/rust.rs
index ac5eaea3bcb..0fae235bb93 100644
--- a/src/bootstrap/src/core/config/toml/rust.rs
+++ b/src/bootstrap/src/core/config/toml/rust.rs
@@ -619,7 +619,6 @@ impl Config {
         // build our internal lld and use it as the default linker, by setting the `rust.lld` config
         // to true by default:
         // - on the `x86_64-unknown-linux-gnu` target
-        // - on the `dev` and `nightly` channels
         // - when building our in-tree llvm (i.e. the target has not set an `llvm-config`), so that
         //   we're also able to build the corresponding lld
         // - or when using an external llvm that's downloaded from CI, which also contains our prebuilt
@@ -628,9 +627,7 @@ impl Config {
         //   thus, disabled
         // - similarly, lld will not be built nor used by default when explicitly asked not to, e.g.
         //   when the config sets `rust.lld = false`
-        if self.host_target.triple == "x86_64-unknown-linux-gnu"
-            && self.hosts == [self.host_target]
-            && (self.channel == "dev" || self.channel == "nightly")
+        if self.host_target.triple == "x86_64-unknown-linux-gnu" && self.hosts == [self.host_target]
         {
             let no_llvm_config = self
                 .target_config
-- 
cgit 1.4.1-3-g733a5


From aa527115432df082f3c9e4d2459acb7bb02ed5a6 Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Tue, 18 Mar 2025 08:17:38 +0100
Subject: add post-dist test for checking that we use LLD

And remove the previous beta/stable/nightly LLD tests.
---
 src/tools/opt-dist/src/tests.rs                      |  3 +++
 .../run-make/rust-lld-by-default-beta-stable/main.rs |  1 -
 .../rust-lld-by-default-beta-stable/rmake.rs         | 14 --------------
 tests/run-make/rust-lld-by-default-nightly/main.rs   |  5 -----
 tests/run-make/rust-lld-by-default-nightly/rmake.rs  | 19 -------------------
 .../rust-lld-x86_64-unknown-linux-gnu-dist/main.rs   |  5 +++++
 .../rust-lld-x86_64-unknown-linux-gnu-dist/rmake.rs  | 16 ++++++++++++++++
 .../rust-lld-x86_64-unknown-linux-gnu/main.rs        |  5 +++++
 .../rust-lld-x86_64-unknown-linux-gnu/rmake.rs       | 20 ++++++++++++++++++++
 9 files changed, 49 insertions(+), 39 deletions(-)
 delete mode 100644 tests/run-make/rust-lld-by-default-beta-stable/main.rs
 delete mode 100644 tests/run-make/rust-lld-by-default-beta-stable/rmake.rs
 delete mode 100644 tests/run-make/rust-lld-by-default-nightly/main.rs
 delete mode 100644 tests/run-make/rust-lld-by-default-nightly/rmake.rs
 create mode 100644 tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/main.rs
 create mode 100644 tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/rmake.rs
 create mode 100644 tests/run-make/rust-lld-x86_64-unknown-linux-gnu/main.rs
 create mode 100644 tests/run-make/rust-lld-x86_64-unknown-linux-gnu/rmake.rs

diff --git a/src/tools/opt-dist/src/tests.rs b/src/tools/opt-dist/src/tests.rs
index 705a1750ae8..2d2aab86eda 100644
--- a/src/tools/opt-dist/src/tests.rs
+++ b/src/tools/opt-dist/src/tests.rs
@@ -106,7 +106,10 @@ llvm-config = "{llvm_config}"
             "tests/incremental",
             "tests/mir-opt",
             "tests/pretty",
+            // Make sure that we don't use too new GLIBC symbols on x64
             "tests/run-make/glibc-symbols-x86_64-unknown-linux-gnu",
+            // Make sure that we use LLD by default on x64
+            "tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist",
             "tests/ui",
             "tests/crashes",
         ];
diff --git a/tests/run-make/rust-lld-by-default-beta-stable/main.rs b/tests/run-make/rust-lld-by-default-beta-stable/main.rs
deleted file mode 100644
index f328e4d9d04..00000000000
--- a/tests/run-make/rust-lld-by-default-beta-stable/main.rs
+++ /dev/null
@@ -1 +0,0 @@
-fn main() {}
diff --git a/tests/run-make/rust-lld-by-default-beta-stable/rmake.rs b/tests/run-make/rust-lld-by-default-beta-stable/rmake.rs
deleted file mode 100644
index 9a08991c4b8..00000000000
--- a/tests/run-make/rust-lld-by-default-beta-stable/rmake.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Ensure that rust-lld is *not* used as the default linker on `x86_64-unknown-linux-gnu` on stable
-// or beta.
-
-//@ ignore-nightly
-//@ only-x86_64-unknown-linux-gnu
-
-use run_make_support::linker::assert_rustc_doesnt_use_lld;
-use run_make_support::rustc;
-
-fn main() {
-    // A regular compilation should not use rust-lld by default. We'll check that by asking the
-    // linker to display its version number with a link-arg.
-    assert_rustc_doesnt_use_lld(rustc().input("main.rs"));
-}
diff --git a/tests/run-make/rust-lld-by-default-nightly/main.rs b/tests/run-make/rust-lld-by-default-nightly/main.rs
deleted file mode 100644
index e9f655fc09e..00000000000
--- a/tests/run-make/rust-lld-by-default-nightly/main.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Test linking using `cc` with `rust-lld`, which is on by default on the x86_64-unknown-linux-gnu
-// target.
-// See https://github.com/rust-lang/compiler-team/issues/510 for more info
-
-fn main() {}
diff --git a/tests/run-make/rust-lld-by-default-nightly/rmake.rs b/tests/run-make/rust-lld-by-default-nightly/rmake.rs
deleted file mode 100644
index 3ff1e2770e6..00000000000
--- a/tests/run-make/rust-lld-by-default-nightly/rmake.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Ensure that rust-lld is used as the default linker on `x86_64-unknown-linux-gnu` on the nightly
-// channel, and that it can also be turned off with a CLI flag.
-
-//@ needs-rust-lld
-//@ ignore-beta
-//@ ignore-stable
-//@ only-x86_64-unknown-linux-gnu
-
-use run_make_support::linker::{assert_rustc_doesnt_use_lld, assert_rustc_uses_lld};
-use run_make_support::rustc;
-
-fn main() {
-    // A regular compilation should use rust-lld by default. We'll check that by asking the linker
-    // to display its version number with a link-arg.
-    assert_rustc_uses_lld(rustc().input("main.rs"));
-
-    // But it can still be disabled by turning the linker feature off.
-    assert_rustc_doesnt_use_lld(rustc().arg("-Zlinker-features=-lld").input("main.rs"));
-}
diff --git a/tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/main.rs b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/main.rs
new file mode 100644
index 00000000000..e9f655fc09e
--- /dev/null
+++ b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/main.rs
@@ -0,0 +1,5 @@
+// Test linking using `cc` with `rust-lld`, which is on by default on the x86_64-unknown-linux-gnu
+// target.
+// See https://github.com/rust-lang/compiler-team/issues/510 for more info
+
+fn main() {}
diff --git a/tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/rmake.rs b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/rmake.rs
new file mode 100644
index 00000000000..c26f82b7d37
--- /dev/null
+++ b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/rmake.rs
@@ -0,0 +1,16 @@
+// Ensure that rust-lld is used as the default linker on `x86_64-unknown-linux-gnu`
+// dist artifacts and that it can also be turned off with a CLI flag.
+
+//@ only-dist
+//@ only-x86_64-unknown-linux-gnu
+
+use run_make_support::linker::{assert_rustc_doesnt_use_lld, assert_rustc_uses_lld};
+use run_make_support::rustc;
+
+fn main() {
+    // A regular compilation should use rust-lld by default.
+    assert_rustc_uses_lld(rustc().input("main.rs"));
+
+    // But it can still be disabled by turning the linker feature off.
+    assert_rustc_doesnt_use_lld(rustc().arg("-Zlinker-features=-lld").input("main.rs"));
+}
diff --git a/tests/run-make/rust-lld-x86_64-unknown-linux-gnu/main.rs b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu/main.rs
new file mode 100644
index 00000000000..e9f655fc09e
--- /dev/null
+++ b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu/main.rs
@@ -0,0 +1,5 @@
+// Test linking using `cc` with `rust-lld`, which is on by default on the x86_64-unknown-linux-gnu
+// target.
+// See https://github.com/rust-lang/compiler-team/issues/510 for more info
+
+fn main() {}
diff --git a/tests/run-make/rust-lld-x86_64-unknown-linux-gnu/rmake.rs b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu/rmake.rs
new file mode 100644
index 00000000000..e71a47f11e2
--- /dev/null
+++ b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu/rmake.rs
@@ -0,0 +1,20 @@
+// Ensure that rust-lld is used as the default linker on `x86_64-unknown-linux-gnu`
+// and that it can also be turned off with a CLI flag.
+//
+// This version of the test checks that LLD is used by default when LLD is enabled in the
+// toolchain. There is a separate test that checks that LLD is used for dist artifacts
+// unconditionally.
+
+//@ needs-rust-lld
+//@ only-x86_64-unknown-linux-gnu
+
+use run_make_support::linker::{assert_rustc_doesnt_use_lld, assert_rustc_uses_lld};
+use run_make_support::rustc;
+
+fn main() {
+    // A regular compilation should use rust-lld by default.
+    assert_rustc_uses_lld(rustc().input("main.rs"));
+
+    // But it can still be disabled by turning the linker feature off.
+    assert_rustc_doesnt_use_lld(rustc().arg("-Zlinker-features=-lld").input("main.rs"));
+}
-- 
cgit 1.4.1-3-g733a5


From 24a25dbb88bc6a6dafe7bad2337948f0a2b37c0f Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Tue, 10 Jun 2025 23:46:39 +0800
Subject: Revert `tests/run-make/mte-ffi` changes

Partially reverts commit 40311c4dcf666e8bddcec4a8059e7d9f12bbd363.
---
 tests/run-make/mte-ffi/bar.h        | 2 --
 tests/run-make/mte-ffi/bar_float.c  | 4 ++--
 tests/run-make/mte-ffi/bar_int.c    | 2 +-
 tests/run-make/mte-ffi/bar_string.c | 3 +--
 4 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/tests/run-make/mte-ffi/bar.h b/tests/run-make/mte-ffi/bar.h
index 9b030c618d1..a2292ae02a3 100644
--- a/tests/run-make/mte-ffi/bar.h
+++ b/tests/run-make/mte-ffi/bar.h
@@ -1,5 +1,3 @@
-// FIXME(#141600) the mte-ffi test doesn't fail in aarch64-gnu
-
 #ifndef __BAR_H
 #define __BAR_H
 
diff --git a/tests/run-make/mte-ffi/bar_float.c b/tests/run-make/mte-ffi/bar_float.c
index acc2f5d9266..a1590f62765 100644
--- a/tests/run-make/mte-ffi/bar_float.c
+++ b/tests/run-make/mte-ffi/bar_float.c
@@ -3,9 +3,9 @@
 #include <stdint.h>
 #include "bar.h"
 
-extern void foo(float*);
+extern void foo(char*);
 
-void bar(float *ptr) {
+void bar(char *ptr) {
     if (((uintptr_t)ptr >> 56) != 0x1f) {
         fprintf(stderr, "Top byte corrupted on Rust -> C FFI boundary!\n");
         exit(1);
diff --git a/tests/run-make/mte-ffi/bar_int.c b/tests/run-make/mte-ffi/bar_int.c
index c92e765302c..d1c79e95dc9 100644
--- a/tests/run-make/mte-ffi/bar_int.c
+++ b/tests/run-make/mte-ffi/bar_int.c
@@ -5,7 +5,7 @@
 
 extern void foo(unsigned int *);
 
-void bar(unsigned int *ptr) {
+void bar(char *ptr) {
     if (((uintptr_t)ptr >> 56) != 0x1f) {
         fprintf(stderr, "Top byte corrupted on Rust -> C FFI boundary!\n");
         exit(1);
diff --git a/tests/run-make/mte-ffi/bar_string.c b/tests/run-make/mte-ffi/bar_string.c
index 8e1202f6fd1..5669ffd6695 100644
--- a/tests/run-make/mte-ffi/bar_string.c
+++ b/tests/run-make/mte-ffi/bar_string.c
@@ -1,7 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
-#include <string.h>
 #include "bar.h"
 
 extern void foo(char*);
@@ -33,7 +32,7 @@ int main(void)
 
     // Store an arbitrary tag in bits 56-59 of the pointer (where an MTE tag may be),
     // and a different value in the ignored top 4 bits.
-    ptr = (char *)((uintptr_t)ptr | 0x1fl << 56);
+    ptr = (unsigned int *)((uintptr_t)ptr | 0x1fl << 56);
 
     if (mte_enabled()) {
         set_tag(ptr);
-- 
cgit 1.4.1-3-g733a5


From 37136dd9748736d68c050d2dc132045b8b57ce3e Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Tue, 8 Jul 2025 16:39:03 +0800
Subject: Disable `tests/run-make/mte-ffi`

See RUST-141600: this test is broken in two ways:

1. This test triggers `-Wincompatible-pointer-types` on GCC 14.
2. This test requires ARMv8.5+ w/ MTE extensions enabled, but GHA CI
   runner hardware do not have this enabled.
---
 tests/run-make/mte-ffi/rmake.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/run-make/mte-ffi/rmake.rs b/tests/run-make/mte-ffi/rmake.rs
index a8da0dc0ee0..71d8318d946 100644
--- a/tests/run-make/mte-ffi/rmake.rs
+++ b/tests/run-make/mte-ffi/rmake.rs
@@ -2,6 +2,13 @@
 //! FFI boundaries (C <-> Rust). This test does not require MTE: whilst the test will use MTE if
 //! available, if it is not, arbitrary tag bits are set using TBI.
 
+//@ ignore-test (FIXME #141600)
+//
+// FIXME(#141600): this test is broken in two ways:
+// 1. This test triggers `-Wincompatible-pointer-types` on GCC 14.
+// 2. This test requires ARMv8.5+ w/ MTE extensions enabled, but GHA CI runner hardware do not have
+//    this enabled.
+
 //@ only-aarch64-unknown-linux-gnu
 // Reason: this test is only valid for AArch64 with `gcc`. The linker must be explicitly specified
 // when cross-compiling, so it is limited to `aarch64-unknown-linux-gnu`.
-- 
cgit 1.4.1-3-g733a5


From 2e6d82c9c96348a2f7dafd1a3337287408fc9751 Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Tue, 8 Jul 2025 09:01:25 +0000
Subject: stabilize `-Clinker-features=-lld` on x64 linux

This stabilizes a subset of the `-Clinker-features` components on x64 linux:
the lld opt-out.

The opt-in is not stabilized, as interactions with other stable flags require
more internal work, but are not needed for stabilizing using rust-lld by default.

Similarly, since we only switch to rust-lld on x64 linux, the opt-out is
only stabilized there. Other targets still require `-Zunstable-options`
to use it.
---
 compiler/rustc_codegen_ssa/src/back/link.rs        |  2 +-
 compiler/rustc_session/src/config.rs               | 48 +++++++++++++++++++---
 compiler/rustc_session/src/options.rs              |  4 +-
 compiler/rustc_target/src/spec/mod.rs              | 15 ++++++-
 tests/run-make/compressed-debuginfo-zstd/rmake.rs  |  2 +-
 tests/run-make/rust-lld-custom-target/rmake.rs     |  3 +-
 .../run-make/rust-lld-link-script-provide/rmake.rs |  2 +-
 .../rmake.rs                                       |  2 +-
 .../rust-lld-x86_64-unknown-linux-gnu/rmake.rs     |  2 +-
 tests/run-make/rust-lld/rmake.rs                   | 10 ++---
 10 files changed, 70 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 343cb0eeca9..34328687e3f 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1379,7 +1379,7 @@ pub fn linker_and_flavor(sess: &Session) -> (PathBuf, LinkerFlavor) {
         }
     }
 
-    let features = sess.opts.unstable_opts.linker_features;
+    let features = sess.opts.cg.linker_features;
 
     // linker and linker flavor specified via command line have precedence over what the target
     // specification specifies
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 4627c2978fc..76969a0c409 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -402,7 +402,7 @@ impl LinkSelfContained {
     }
 }
 
-/// The different values that `-Z linker-features` can take on the CLI: a list of individually
+/// The different values that `-C linker-features` can take on the CLI: a list of individually
 /// enabled or disabled features used during linking.
 ///
 /// There is no need to enable or disable them in bulk. Each feature is fine-grained, and can be
@@ -442,6 +442,39 @@ impl LinkerFeaturesCli {
             _ => None,
         }
     }
+
+    /// When *not* using `-Z unstable-options` on the CLI, ensure only stable linker features are
+    /// used, for the given `TargetTuple`. Returns `Ok` if no unstable variants are used.
+    /// The caller should ensure that e.g. `nightly_options::is_unstable_enabled()`
+    /// returns false.
+    pub(crate) fn check_unstable_variants(&self, target_tuple: &TargetTuple) -> Result<(), String> {
+        // `-C linker-features=-lld` is only stable on x64 linux.
+        let has_minus_lld = self.disabled.is_lld_enabled();
+        if has_minus_lld && target_tuple.tuple() != "x86_64-unknown-linux-gnu" {
+            return Err(format!(
+                "`-C linker-features=-lld` is unstable on the `{target_tuple}` \
+                    target. The `-Z unstable-options` flag must also be passed to use it on this target",
+            ));
+        }
+
+        // Any `+lld` or non-lld feature used is unstable, and that's an error.
+        let unstable_enabled = self.enabled;
+        let unstable_disabled = self.disabled - LinkerFeatures::LLD;
+        if !unstable_enabled.union(unstable_disabled).is_empty() {
+            let unstable_features: Vec<_> = unstable_enabled
+                .iter()
+                .map(|f| format!("+{}", f.as_str().unwrap()))
+                .chain(unstable_disabled.iter().map(|f| format!("-{}", f.as_str().unwrap())))
+                .collect();
+            return Err(format!(
+                "`-C linker-features={}` is unstable, and also requires the \
+                `-Z unstable-options` flag to be used",
+                unstable_features.join(","),
+            ));
+        }
+
+        Ok(())
+    }
 }
 
 /// Used with `-Z assert-incr-state`.
@@ -2638,9 +2671,8 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
         }
     }
 
-    if !nightly_options::is_unstable_enabled(matches)
-        && cg.force_frame_pointers == FramePointer::NonLeaf
-    {
+    let unstable_options_enabled = nightly_options::is_unstable_enabled(matches);
+    if !unstable_options_enabled && cg.force_frame_pointers == FramePointer::NonLeaf {
         early_dcx.early_fatal(
             "`-Cforce-frame-pointers=non-leaf` or `always` also requires `-Zunstable-options` \
                 and a nightly compiler",
@@ -2650,7 +2682,7 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
     // For testing purposes, until we have more feedback about these options: ensure `-Z
     // unstable-options` is required when using the unstable `-C link-self-contained` and `-C
     // linker-flavor` options.
-    if !nightly_options::is_unstable_enabled(matches) {
+    if !unstable_options_enabled {
         let uses_unstable_self_contained_option =
             cg.link_self_contained.are_unstable_variants_set();
         if uses_unstable_self_contained_option {
@@ -2706,6 +2738,12 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
     let debuginfo = select_debuginfo(matches, &cg);
     let debuginfo_compression = unstable_opts.debuginfo_compression;
 
+    if !unstable_options_enabled {
+        if let Err(error) = cg.linker_features.check_unstable_variants(&target_triple) {
+            early_dcx.early_fatal(error);
+        }
+    }
+
     let crate_name = matches.opt_str("crate-name");
     let unstable_features = UnstableFeatures::from_environment(crate_name.as_deref());
     // Parse any `-l` flags, which link to native libraries.
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index ecd82c0cc01..626262c8442 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -2015,6 +2015,8 @@ options! {
         on a C toolchain or linker installed in the system"),
     linker: Option<PathBuf> = (None, parse_opt_pathbuf, [UNTRACKED],
         "system linker to link outputs with"),
+    linker_features: LinkerFeaturesCli = (LinkerFeaturesCli::default(), parse_linker_features, [UNTRACKED],
+        "a comma-separated list of linker features to enable (+) or disable (-): `lld`"),
     linker_flavor: Option<LinkerFlavorCli> = (None, parse_linker_flavor, [UNTRACKED],
         "linker flavor"),
     linker_plugin_lto: LinkerPluginLto = (LinkerPluginLto::Disabled,
@@ -2307,8 +2309,6 @@ options! {
         "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)"),
-    linker_features: LinkerFeaturesCli = (LinkerFeaturesCli::default(), parse_linker_features, [UNTRACKED],
-        "a comma-separated list of linker features to enable (+) or disable (-): `lld`"),
     lint_llvm_ir: bool = (false, parse_bool, [TRACKED],
         "lint LLVM IR (default: no)"),
     lint_mir: bool = (false, parse_bool, [UNTRACKED],
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 5346b206a17..4bc0d88a910 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -725,7 +725,7 @@ impl ToJson for LinkSelfContainedComponents {
 }
 
 bitflags::bitflags! {
-    /// The `-Z linker-features` components that can individually be enabled or disabled.
+    /// The `-C linker-features` components that can individually be enabled or disabled.
     ///
     /// They are feature flags intended to be a more flexible mechanism than linker flavors, and
     /// also to prevent a combinatorial explosion of flavors whenever a new linker feature is
@@ -756,7 +756,7 @@ bitflags::bitflags! {
 rustc_data_structures::external_bitflags_debug! { LinkerFeatures }
 
 impl LinkerFeatures {
-    /// Parses a single `-Z linker-features` well-known feature, not a set of flags.
+    /// Parses a single `-C linker-features` well-known feature, not a set of flags.
     pub fn from_str(s: &str) -> Option<LinkerFeatures> {
         Some(match s {
             "cc" => LinkerFeatures::CC,
@@ -765,6 +765,17 @@ impl LinkerFeatures {
         })
     }
 
+    /// Return the linker feature name, as would be passed on the CLI.
+    ///
+    /// Returns `None` if the bitflags aren't a singular component (but a mix of multiple flags).
+    pub fn as_str(self) -> Option<&'static str> {
+        Some(match self {
+            LinkerFeatures::CC => "cc",
+            LinkerFeatures::LLD => "lld",
+            _ => return None,
+        })
+    }
+
     /// Returns whether the `lld` linker feature is enabled.
     pub fn is_lld_enabled(self) -> bool {
         self.contains(LinkerFeatures::LLD)
diff --git a/tests/run-make/compressed-debuginfo-zstd/rmake.rs b/tests/run-make/compressed-debuginfo-zstd/rmake.rs
index cd8cf223047..8d7e5c089da 100644
--- a/tests/run-make/compressed-debuginfo-zstd/rmake.rs
+++ b/tests/run-make/compressed-debuginfo-zstd/rmake.rs
@@ -26,7 +26,7 @@ fn prepare_and_check<F: FnOnce(&mut Rustc) -> &mut Rustc>(to_find: &str, prepare
     run_in_tmpdir(|| {
         let mut rustc = Rustc::new();
         rustc
-            .arg("-Zlinker-features=+lld")
+            .arg("-Clinker-features=+lld")
             .arg("-Clink-self-contained=+linker")
             .arg("-Zunstable-options")
             .arg("-Cdebuginfo=full")
diff --git a/tests/run-make/rust-lld-custom-target/rmake.rs b/tests/run-make/rust-lld-custom-target/rmake.rs
index e2b065a10b1..90ba424ffe9 100644
--- a/tests/run-make/rust-lld-custom-target/rmake.rs
+++ b/tests/run-make/rust-lld-custom-target/rmake.rs
@@ -23,7 +23,8 @@ fn main() {
         rustc()
             .crate_type("cdylib")
             .target("custom-target.json")
-            .arg("-Zlinker-features=-lld")
+            .arg("-Clinker-features=-lld")
+            .arg("-Zunstable-options")
             .input("lib.rs"),
     );
 }
diff --git a/tests/run-make/rust-lld-link-script-provide/rmake.rs b/tests/run-make/rust-lld-link-script-provide/rmake.rs
index e78a411bc15..c637dff9038 100644
--- a/tests/run-make/rust-lld-link-script-provide/rmake.rs
+++ b/tests/run-make/rust-lld-link-script-provide/rmake.rs
@@ -10,7 +10,7 @@ use run_make_support::rustc;
 fn main() {
     rustc()
         .input("main.rs")
-        .arg("-Zlinker-features=+lld")
+        .arg("-Clinker-features=+lld")
         .arg("-Clink-self-contained=+linker")
         .arg("-Zunstable-options")
         .link_arg("-Tscript.t")
diff --git a/tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/rmake.rs b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/rmake.rs
index c26f82b7d37..c315d36a39d 100644
--- a/tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/rmake.rs
+++ b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu-dist/rmake.rs
@@ -12,5 +12,5 @@ fn main() {
     assert_rustc_uses_lld(rustc().input("main.rs"));
 
     // But it can still be disabled by turning the linker feature off.
-    assert_rustc_doesnt_use_lld(rustc().arg("-Zlinker-features=-lld").input("main.rs"));
+    assert_rustc_doesnt_use_lld(rustc().arg("-Clinker-features=-lld").input("main.rs"));
 }
diff --git a/tests/run-make/rust-lld-x86_64-unknown-linux-gnu/rmake.rs b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu/rmake.rs
index e71a47f11e2..00415d27aaf 100644
--- a/tests/run-make/rust-lld-x86_64-unknown-linux-gnu/rmake.rs
+++ b/tests/run-make/rust-lld-x86_64-unknown-linux-gnu/rmake.rs
@@ -16,5 +16,5 @@ fn main() {
     assert_rustc_uses_lld(rustc().input("main.rs"));
 
     // But it can still be disabled by turning the linker feature off.
-    assert_rustc_doesnt_use_lld(rustc().arg("-Zlinker-features=-lld").input("main.rs"));
+    assert_rustc_doesnt_use_lld(rustc().arg("-Clinker-features=-lld").input("main.rs"));
 }
diff --git a/tests/run-make/rust-lld/rmake.rs b/tests/run-make/rust-lld/rmake.rs
index 9470f5d0be1..2b914f19ac0 100644
--- a/tests/run-make/rust-lld/rmake.rs
+++ b/tests/run-make/rust-lld/rmake.rs
@@ -12,14 +12,14 @@ fn main() {
     // asking the linker to display its version number with a link-arg.
     assert_rustc_uses_lld(
         rustc()
-            .arg("-Zlinker-features=+lld")
+            .arg("-Clinker-features=+lld")
             .arg("-Clink-self-contained=+linker")
             .arg("-Zunstable-options")
             .input("main.rs"),
     );
 
     // It should not be used when we explicitly opt out of lld.
-    assert_rustc_doesnt_use_lld(rustc().arg("-Zlinker-features=-lld").input("main.rs"));
+    assert_rustc_doesnt_use_lld(rustc().arg("-Clinker-features=-lld").input("main.rs"));
 
     // While we're here, also check that the last linker feature flag "wins" when passed multiple
     // times to rustc.
@@ -27,9 +27,9 @@ fn main() {
         rustc()
             .arg("-Clink-self-contained=+linker")
             .arg("-Zunstable-options")
-            .arg("-Zlinker-features=-lld")
-            .arg("-Zlinker-features=+lld")
-            .arg("-Zlinker-features=-lld,+lld")
+            .arg("-Clinker-features=-lld")
+            .arg("-Clinker-features=+lld")
+            .arg("-Clinker-features=-lld,+lld")
             .input("main.rs"),
     );
 }
-- 
cgit 1.4.1-3-g733a5


From 3f194a86eeb4e8cf23556bc92946728f29c21da4 Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Tue, 8 Jul 2025 09:10:39 +0000
Subject: stabilize `-Clink-self-contained=-linker` on x64 linux

This stabilizes a subset of the `-Clink-self-contained` components on x64 linux:
the rust-lld opt-out.

The opt-in is not stabilized, as interactions with other stable flags require
more internal work, but are not needed for stabilizing using rust-lld by default.

Similarly, since we only switch to rust-lld on x64 linux, the opt-out is
only stabilized there. Other targets still require `-Zunstable-options`
to use it.
---
 compiler/rustc_session/src/config.rs | 51 ++++++++++++++++++++++++------------
 tests/run-make/rust-lld/rmake.rs     | 10 ++++---
 2 files changed, 40 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 76969a0c409..a91e2140fd4 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -370,12 +370,34 @@ impl LinkSelfContained {
     }
 
     /// To help checking CLI usage while some of the values are unstable: returns whether one of the
-    /// components was set individually. This would also require the `-Zunstable-options` flag, to
-    /// be allowed.
-    fn are_unstable_variants_set(&self) -> bool {
-        let any_component_set =
-            !self.enabled_components.is_empty() || !self.disabled_components.is_empty();
-        self.explicitly_set.is_none() && any_component_set
+    /// unstable components was set individually, for the given `TargetTuple`. This would also
+    /// require the `-Zunstable-options` flag, to be allowed.
+    fn check_unstable_variants(&self, target_tuple: &TargetTuple) -> Result<(), String> {
+        if self.explicitly_set.is_some() {
+            return Ok(());
+        }
+
+        // `-C link-self-contained=-linker` is only stable on x64 linux.
+        let has_minus_linker = self.disabled_components.is_linker_enabled();
+        if has_minus_linker && target_tuple.tuple() != "x86_64-unknown-linux-gnu" {
+            return Err(format!(
+                "`-C link-self-contained=-linker` is unstable on the `{target_tuple}` \
+                    target. The `-Z unstable-options` flag must also be passed to use it on this target",
+            ));
+        }
+
+        // Any `+linker` or other component used is unstable, and that's an error.
+        let unstable_enabled = self.enabled_components;
+        let unstable_disabled = self.disabled_components - LinkSelfContainedComponents::LINKER;
+        if !unstable_enabled.union(unstable_disabled).is_empty() {
+            return Err(String::from(
+                "only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off`/`-linker` \
+                are stable, the `-Z unstable-options` flag must also be passed to use \
+                the unstable values",
+            ));
+        }
+
+        Ok(())
     }
 
     /// Returns whether the self-contained linker component was enabled on the CLI, using the
@@ -2679,17 +2701,13 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
         )
     }
 
-    // For testing purposes, until we have more feedback about these options: ensure `-Z
-    // unstable-options` is required when using the unstable `-C link-self-contained` and `-C
-    // linker-flavor` options.
+    let target_triple = parse_target_triple(early_dcx, matches);
+
+    // Ensure `-Z unstable-options` is required when using the unstable `-C link-self-contained` and
+    // `-C linker-flavor` options.
     if !unstable_options_enabled {
-        let uses_unstable_self_contained_option =
-            cg.link_self_contained.are_unstable_variants_set();
-        if uses_unstable_self_contained_option {
-            early_dcx.early_fatal(
-                "only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off` are stable, \
-                the `-Z unstable-options` flag must also be passed to use the unstable values",
-            );
+        if let Err(error) = cg.link_self_contained.check_unstable_variants(&target_triple) {
+            early_dcx.early_fatal(error);
         }
 
         if let Some(flavor) = cg.linker_flavor {
@@ -2729,7 +2747,6 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
 
     let cg = cg;
 
-    let target_triple = parse_target_triple(early_dcx, matches);
     let opt_level = parse_opt_level(early_dcx, matches, &cg);
     // The `-g` and `-C debuginfo` flags specify the same setting, so we want to be able
     // to use them interchangeably. See the note above (regarding `-O` and `-C opt-level`)
diff --git a/tests/run-make/rust-lld/rmake.rs b/tests/run-make/rust-lld/rmake.rs
index 2b914f19ac0..932c2697ba0 100644
--- a/tests/run-make/rust-lld/rmake.rs
+++ b/tests/run-make/rust-lld/rmake.rs
@@ -1,5 +1,5 @@
-// Test linking using `cc` with `rust-lld`, using the unstable CLI described in MCP 510
-// see https://github.com/rust-lang/compiler-team/issues/510 for more info
+// Test linking using `cc` with `rust-lld`, using the `-Clinker-features` and
+// `-Clink-self-contained` CLI flags.
 
 //@ needs-rust-lld
 //@ ignore-s390x lld does not yet support s390x as target
@@ -14,12 +14,14 @@ fn main() {
         rustc()
             .arg("-Clinker-features=+lld")
             .arg("-Clink-self-contained=+linker")
-            .arg("-Zunstable-options")
+            .arg("-Zunstable-options") // the opt-ins are unstable
             .input("main.rs"),
     );
 
     // It should not be used when we explicitly opt out of lld.
-    assert_rustc_doesnt_use_lld(rustc().arg("-Clinker-features=-lld").input("main.rs"));
+    assert_rustc_doesnt_use_lld(
+        rustc().arg("-Clinker-features=-lld").arg("-Zunstable-options").input("main.rs"),
+    );
 
     // While we're here, also check that the last linker feature flag "wins" when passed multiple
     // times to rustc.
-- 
cgit 1.4.1-3-g733a5


From d6179022c1d86f6c3e63a64933dff2734b366935 Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Tue, 8 Jul 2025 09:20:14 +0000
Subject: update bootstrap mcp510 handling

beta and stage1 need to use different flags (-C vs -Z) to be able to use
the old and new `linker-features` and `link-self-contained` flags
---
 src/bootstrap/src/core/build_steps/test.rs | 20 ++++++++++++++++----
 src/bootstrap/src/core/builder/cargo.rs    | 15 ++++++++++-----
 src/bootstrap/src/core/builder/mod.rs      |  2 +-
 src/bootstrap/src/utils/helpers.rs         | 25 +++++++++++++++++++------
 4 files changed, 46 insertions(+), 16 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index a5b7b22aba8..716bef3f38c 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -262,7 +262,13 @@ impl Step for Cargotest {
             .args(builder.config.test_args())
             .env("RUSTC", builder.rustc(compiler))
             .env("RUSTDOC", builder.rustdoc(compiler));
-        add_rustdoc_cargo_linker_args(&mut cmd, builder, compiler.host, LldThreads::No);
+        add_rustdoc_cargo_linker_args(
+            &mut cmd,
+            builder,
+            compiler.host,
+            LldThreads::No,
+            compiler.stage,
+        );
         cmd.delay_failure().run(builder);
     }
 }
@@ -857,7 +863,7 @@ impl Step for RustdocTheme {
             .env("CFG_RELEASE_CHANNEL", &builder.config.channel)
             .env("RUSTDOC_REAL", builder.rustdoc(self.compiler))
             .env("RUSTC_BOOTSTRAP", "1");
-        cmd.args(linker_args(builder, self.compiler.host, LldThreads::No));
+        cmd.args(linker_args(builder, self.compiler.host, LldThreads::No, self.compiler.stage));
 
         cmd.delay_failure().run(builder);
     }
@@ -1033,7 +1039,13 @@ impl Step for RustdocGUI {
         cmd.env("RUSTDOC", builder.rustdoc(self.compiler))
             .env("RUSTC", builder.rustc(self.compiler));
 
-        add_rustdoc_cargo_linker_args(&mut cmd, builder, self.compiler.host, LldThreads::No);
+        add_rustdoc_cargo_linker_args(
+            &mut cmd,
+            builder,
+            self.compiler.host,
+            LldThreads::No,
+            self.compiler.stage,
+        );
 
         for path in &builder.paths {
             if let Some(p) = helpers::is_valid_test_suite_arg(path, "tests/rustdoc-gui", builder) {
@@ -1812,7 +1824,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         }
 
         let mut hostflags = flags.clone();
-        hostflags.extend(linker_flags(builder, compiler.host, LldThreads::No));
+        hostflags.extend(linker_flags(builder, compiler.host, LldThreads::No, compiler.stage));
 
         let mut targetflags = flags;
 
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index deb7106f185..065d7e45e0f 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -115,7 +115,7 @@ impl Cargo {
             // No need to configure the target linker for these command types.
             Kind::Clean | Kind::Check | Kind::Suggest | Kind::Format | Kind::Setup => {}
             _ => {
-                cargo.configure_linker(builder);
+                cargo.configure_linker(builder, mode);
             }
         }
 
@@ -209,7 +209,7 @@ impl Cargo {
 
     // FIXME(onur-ozkan): Add coverage to make sure modifications to this function
     // doesn't cause cache invalidations (e.g., #130108).
-    fn configure_linker(&mut self, builder: &Builder<'_>) -> &mut Cargo {
+    fn configure_linker(&mut self, builder: &Builder<'_>, mode: Mode) -> &mut Cargo {
         let target = self.target;
         let compiler = self.compiler;
 
@@ -264,7 +264,12 @@ impl Cargo {
             }
         }
 
-        for arg in linker_args(builder, compiler.host, LldThreads::Yes) {
+        // We use the snapshot compiler when building host code (build scripts/proc macros) of
+        // `Mode::Std` tools, so we need to determine the current stage here to pass the proper
+        // linker args (e.g. -C vs -Z).
+        // This should stay synchronized with the [cargo] function.
+        let host_stage = if mode == Mode::Std { 0 } else { compiler.stage };
+        for arg in linker_args(builder, compiler.host, LldThreads::Yes, host_stage) {
             self.hostflags.arg(&arg);
         }
 
@@ -274,10 +279,10 @@ impl Cargo {
         }
         // We want to set -Clinker using Cargo, therefore we only call `linker_flags` and not
         // `linker_args` here.
-        for flag in linker_flags(builder, target, LldThreads::Yes) {
+        for flag in linker_flags(builder, target, LldThreads::Yes, compiler.stage) {
             self.rustflags.arg(&flag);
         }
-        for arg in linker_args(builder, target, LldThreads::Yes) {
+        for arg in linker_args(builder, target, LldThreads::Yes, compiler.stage) {
             self.rustdocflags.arg(&arg);
         }
 
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index b96a988cde3..7464327fde9 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -1599,7 +1599,7 @@ You have to build a stage1 compiler for `{}` first, and then use it to build a s
             cmd.arg("-Dwarnings");
         }
         cmd.arg("-Znormalize-docs");
-        cmd.args(linker_args(self, compiler.host, LldThreads::Yes));
+        cmd.args(linker_args(self, compiler.host, LldThreads::Yes, compiler.stage));
         cmd
     }
 
diff --git a/src/bootstrap/src/utils/helpers.rs b/src/bootstrap/src/utils/helpers.rs
index 3c5f612daa7..eb00ed566c2 100644
--- a/src/bootstrap/src/utils/helpers.rs
+++ b/src/bootstrap/src/utils/helpers.rs
@@ -404,8 +404,9 @@ pub fn linker_args(
     builder: &Builder<'_>,
     target: TargetSelection,
     lld_threads: LldThreads,
+    stage: u32,
 ) -> Vec<String> {
-    let mut args = linker_flags(builder, target, lld_threads);
+    let mut args = linker_flags(builder, target, lld_threads, stage);
 
     if let Some(linker) = builder.linker(target) {
         args.push(format!("-Clinker={}", linker.display()));
@@ -420,19 +421,30 @@ pub fn linker_flags(
     builder: &Builder<'_>,
     target: TargetSelection,
     lld_threads: LldThreads,
+    stage: u32,
 ) -> Vec<String> {
     let mut args = vec![];
     if !builder.is_lld_direct_linker(target) && builder.config.lld_mode.is_used() {
         match builder.config.lld_mode {
             LldMode::External => {
-                args.push("-Zlinker-features=+lld".to_string());
-                // FIXME(kobzol): remove this flag once MCP510 gets stabilized
+                // cfg(bootstrap) - remove the stage 0 check after updating the bootstrap compiler:
+                // `-Clinker-features` has been stabilized.
+                if stage == 0 {
+                    args.push("-Zlinker-features=+lld".to_string());
+                } else {
+                    args.push("-Clinker-features=+lld".to_string());
+                }
                 args.push("-Zunstable-options".to_string());
             }
             LldMode::SelfContained => {
-                args.push("-Zlinker-features=+lld".to_string());
+                // cfg(bootstrap) - remove the stage 0 check after updating the bootstrap compiler:
+                // `-Clinker-features` has been stabilized.
+                if stage == 0 {
+                    args.push("-Zlinker-features=+lld".to_string());
+                } else {
+                    args.push("-Clinker-features=+lld".to_string());
+                }
                 args.push("-Clink-self-contained=+linker".to_string());
-                // FIXME(kobzol): remove this flag once MCP510 gets stabilized
                 args.push("-Zunstable-options".to_string());
             }
             LldMode::Unused => unreachable!(),
@@ -453,8 +465,9 @@ pub fn add_rustdoc_cargo_linker_args(
     builder: &Builder<'_>,
     target: TargetSelection,
     lld_threads: LldThreads,
+    stage: u32,
 ) {
-    let args = linker_args(builder, target, lld_threads);
+    let args = linker_args(builder, target, lld_threads, stage);
     let mut flags = cmd
         .get_envs()
         .find_map(|(k, v)| if k == OsStr::new("RUSTDOCFLAGS") { v } else { None })
-- 
cgit 1.4.1-3-g733a5


From 856c66256781ef3f9b0934b11abb2a6edcfb487f Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Tue, 8 Jul 2025 09:02:14 +0000
Subject: expand `-Clinker-features` tests

- ensure only `-Clinker-features=-lld` is stabilized, and only on x64
  linux
- test `-Clinker-features` unstable values
---
 tests/ui/linking/linker-features-lld-disallowed.rs | 19 ++++++++++++++++
 ...eatures-lld-disallowed.unstable_positive.stderr |  2 ++
 ...-lld-disallowed.unstable_target_negative.stderr |  2 ++
 ...-lld-disallowed.unstable_target_positive.stderr |  2 ++
 ...nker-features-malformed.invalid_modifier.stderr |  2 +-
 ...ker-features-malformed.invalid_separator.stderr |  2 +-
 .../linker-features-malformed.no_value.stderr      |  2 +-
 tests/ui/linking/linker-features-malformed.rs      | 26 +++++++++++-----------
 ...inker-features-malformed.unknown_boolean.stderr |  2 +-
 ...eatures-malformed.unknown_modifier_value.stderr |  2 +-
 .../linker-features-malformed.unknown_value.stderr |  2 +-
 tests/ui/linking/linker-features-unstable-cc.rs    | 13 +++++++++++
 .../ui/linking/linker-features-unstable-cc.stderr  |  2 ++
 13 files changed, 59 insertions(+), 19 deletions(-)
 create mode 100644 tests/ui/linking/linker-features-lld-disallowed.rs
 create mode 100644 tests/ui/linking/linker-features-lld-disallowed.unstable_positive.stderr
 create mode 100644 tests/ui/linking/linker-features-lld-disallowed.unstable_target_negative.stderr
 create mode 100644 tests/ui/linking/linker-features-lld-disallowed.unstable_target_positive.stderr
 create mode 100644 tests/ui/linking/linker-features-unstable-cc.rs
 create mode 100644 tests/ui/linking/linker-features-unstable-cc.stderr

diff --git a/tests/ui/linking/linker-features-lld-disallowed.rs b/tests/ui/linking/linker-features-lld-disallowed.rs
new file mode 100644
index 00000000000..9b8fa2b11e6
--- /dev/null
+++ b/tests/ui/linking/linker-features-lld-disallowed.rs
@@ -0,0 +1,19 @@
+// Check that only `-C linker-features=-lld` is stable on x64 linux. Any other value or target,
+// needs `-Z unstable-options`.
+
+// ignore-tidy-linelength
+
+//@ revisions: unstable_target_positive unstable_target_negative unstable_positive
+//@ [unstable_target_negative] compile-flags: --target=x86_64-unknown-linux-musl -C linker-features=-lld --crate-type=rlib
+//@ [unstable_target_negative] needs-llvm-components: x86
+//@ [unstable_target_positive] compile-flags: --target=x86_64-unknown-linux-musl -C linker-features=+lld --crate-type=rlib
+//@ [unstable_target_positive] needs-llvm-components: x86
+//@ [unstable_positive] compile-flags: --target=x86_64-unknown-linux-gnu -C linker-features=+lld --crate-type=rlib
+//@ [unstable_positive] needs-llvm-components: x86
+
+
+#![feature(no_core)]
+#![no_core]
+
+//[unstable_target_negative]~? ERROR `-C linker-features=-lld` is unstable on the `x86_64-unknown-linux-musl` target
+//[unstable_target_positive,unstable_positive]~? ERROR `-C linker-features=+lld` is unstable, and also requires the `-Z unstable-options`
diff --git a/tests/ui/linking/linker-features-lld-disallowed.unstable_positive.stderr b/tests/ui/linking/linker-features-lld-disallowed.unstable_positive.stderr
new file mode 100644
index 00000000000..09e7e4975c4
--- /dev/null
+++ b/tests/ui/linking/linker-features-lld-disallowed.unstable_positive.stderr
@@ -0,0 +1,2 @@
+error: `-C linker-features=+lld` is unstable, and also requires the `-Z unstable-options` flag to be used
+
diff --git a/tests/ui/linking/linker-features-lld-disallowed.unstable_target_negative.stderr b/tests/ui/linking/linker-features-lld-disallowed.unstable_target_negative.stderr
new file mode 100644
index 00000000000..205082b0726
--- /dev/null
+++ b/tests/ui/linking/linker-features-lld-disallowed.unstable_target_negative.stderr
@@ -0,0 +1,2 @@
+error: `-C linker-features=-lld` is unstable on the `x86_64-unknown-linux-musl` target. The `-Z unstable-options` flag must also be passed to use it on this target
+
diff --git a/tests/ui/linking/linker-features-lld-disallowed.unstable_target_positive.stderr b/tests/ui/linking/linker-features-lld-disallowed.unstable_target_positive.stderr
new file mode 100644
index 00000000000..09e7e4975c4
--- /dev/null
+++ b/tests/ui/linking/linker-features-lld-disallowed.unstable_target_positive.stderr
@@ -0,0 +1,2 @@
+error: `-C linker-features=+lld` is unstable, and also requires the `-Z unstable-options` flag to be used
+
diff --git a/tests/ui/linking/linker-features-malformed.invalid_modifier.stderr b/tests/ui/linking/linker-features-malformed.invalid_modifier.stderr
index 909b277089f..d9ed65ad3e2 100644
--- a/tests/ui/linking/linker-features-malformed.invalid_modifier.stderr
+++ b/tests/ui/linking/linker-features-malformed.invalid_modifier.stderr
@@ -1,2 +1,2 @@
-error: incorrect value `*lld` for unstable option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
+error: incorrect value `*lld` for codegen option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
 
diff --git a/tests/ui/linking/linker-features-malformed.invalid_separator.stderr b/tests/ui/linking/linker-features-malformed.invalid_separator.stderr
index 0f84898a774..e950d8f3e8f 100644
--- a/tests/ui/linking/linker-features-malformed.invalid_separator.stderr
+++ b/tests/ui/linking/linker-features-malformed.invalid_separator.stderr
@@ -1,2 +1,2 @@
-error: incorrect value `-lld@+lld` for unstable option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
+error: incorrect value `-lld@+lld` for codegen option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
 
diff --git a/tests/ui/linking/linker-features-malformed.no_value.stderr b/tests/ui/linking/linker-features-malformed.no_value.stderr
index e93a4e79bb1..e03d3b34bb1 100644
--- a/tests/ui/linking/linker-features-malformed.no_value.stderr
+++ b/tests/ui/linking/linker-features-malformed.no_value.stderr
@@ -1,2 +1,2 @@
-error: incorrect value `` for unstable option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
+error: incorrect value `` for codegen option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
 
diff --git a/tests/ui/linking/linker-features-malformed.rs b/tests/ui/linking/linker-features-malformed.rs
index 0bdcfa39920..627b8e68920 100644
--- a/tests/ui/linking/linker-features-malformed.rs
+++ b/tests/ui/linking/linker-features-malformed.rs
@@ -1,27 +1,27 @@
-//! Check that malformed `-Zlinker-features` flags are properly rejected.
+//! Check that malformed `-Clinker-features` flags are properly rejected.
 
 //@ revisions: no_value
-//@[no_value] compile-flags: -Zlinker-features=
-//[no_value]~? ERROR incorrect value `` for unstable option `linker-features`
+//@[no_value] compile-flags: -Clinker-features=
+//[no_value]~? ERROR incorrect value `` for codegen option `linker-features`
 
 //@ revisions: invalid_modifier
-//@[invalid_modifier] compile-flags: -Zlinker-features=*lld
-//[invalid_modifier]~? ERROR incorrect value `*lld` for unstable option `linker-features`
+//@[invalid_modifier] compile-flags: -Clinker-features=*lld
+//[invalid_modifier]~? ERROR incorrect value `*lld` for codegen option `linker-features`
 
 //@ revisions: unknown_value
-//@[unknown_value] compile-flags: -Zlinker-features=unknown
-//[unknown_value]~? ERROR incorrect value `unknown` for unstable option `linker-features`
+//@[unknown_value] compile-flags: -Clinker-features=unknown
+//[unknown_value]~? ERROR incorrect value `unknown` for codegen option `linker-features`
 
 //@ revisions: unknown_modifier_value
-//@[unknown_modifier_value] compile-flags: -Zlinker-features=-unknown
-//[unknown_modifier_value]~? ERROR incorrect value `-unknown` for unstable option `linker-features`
+//@[unknown_modifier_value] compile-flags: -Clinker-features=-unknown
+//[unknown_modifier_value]~? ERROR incorrect value `-unknown` for codegen option `linker-features`
 
 //@ revisions: unknown_boolean
-//@[unknown_boolean] compile-flags: -Zlinker-features=maybe
-//[unknown_boolean]~? ERROR incorrect value `maybe` for unstable option `linker-features`
+//@[unknown_boolean] compile-flags: -Clinker-features=maybe
+//[unknown_boolean]~? ERROR incorrect value `maybe` for codegen option `linker-features`
 
 //@ revisions: invalid_separator
-//@[invalid_separator] compile-flags: -Zlinker-features=-lld@+lld
-//[invalid_separator]~? ERROR incorrect value `-lld@+lld` for unstable option `linker-features`
+//@[invalid_separator] compile-flags: -Clinker-features=-lld@+lld
+//[invalid_separator]~? ERROR incorrect value `-lld@+lld` for codegen option `linker-features`
 
 fn main() {}
diff --git a/tests/ui/linking/linker-features-malformed.unknown_boolean.stderr b/tests/ui/linking/linker-features-malformed.unknown_boolean.stderr
index 865738d0ccc..d82c2ea04b4 100644
--- a/tests/ui/linking/linker-features-malformed.unknown_boolean.stderr
+++ b/tests/ui/linking/linker-features-malformed.unknown_boolean.stderr
@@ -1,2 +1,2 @@
-error: incorrect value `maybe` for unstable option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
+error: incorrect value `maybe` for codegen option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
 
diff --git a/tests/ui/linking/linker-features-malformed.unknown_modifier_value.stderr b/tests/ui/linking/linker-features-malformed.unknown_modifier_value.stderr
index 03b9620ca26..59366e28e44 100644
--- a/tests/ui/linking/linker-features-malformed.unknown_modifier_value.stderr
+++ b/tests/ui/linking/linker-features-malformed.unknown_modifier_value.stderr
@@ -1,2 +1,2 @@
-error: incorrect value `-unknown` for unstable option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
+error: incorrect value `-unknown` for codegen option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
 
diff --git a/tests/ui/linking/linker-features-malformed.unknown_value.stderr b/tests/ui/linking/linker-features-malformed.unknown_value.stderr
index 566632a3df3..e8f6d5e637c 100644
--- a/tests/ui/linking/linker-features-malformed.unknown_value.stderr
+++ b/tests/ui/linking/linker-features-malformed.unknown_value.stderr
@@ -1,2 +1,2 @@
-error: incorrect value `unknown` for unstable option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
+error: incorrect value `unknown` for codegen option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
 
diff --git a/tests/ui/linking/linker-features-unstable-cc.rs b/tests/ui/linking/linker-features-unstable-cc.rs
new file mode 100644
index 00000000000..38103c81060
--- /dev/null
+++ b/tests/ui/linking/linker-features-unstable-cc.rs
@@ -0,0 +1,13 @@
+// Check that only `-C linker-features=-lld` is stable on x64 linux, and that other linker
+// features require using `-Z unstable-options`.
+//
+// Note that, currently, only `lld` is parsed on the CLI, but that other linker features can exist
+// internally (`cc`).
+//
+//@ compile-flags: --target=x86_64-unknown-linux-gnu -C linker-features=+cc --crate-type=rlib
+//@ needs-llvm-components: x86
+
+#![feature(no_core)]
+#![no_core]
+
+//~? ERROR incorrect value `+cc` for codegen option `linker-features`
diff --git a/tests/ui/linking/linker-features-unstable-cc.stderr b/tests/ui/linking/linker-features-unstable-cc.stderr
new file mode 100644
index 00000000000..a69b4198160
--- /dev/null
+++ b/tests/ui/linking/linker-features-unstable-cc.stderr
@@ -0,0 +1,2 @@
+error: incorrect value `+cc` for codegen option `linker-features` - a list of enabled (`+` prefix) and disabled (`-` prefix) features: `lld` was expected
+
-- 
cgit 1.4.1-3-g733a5


From 754d46e33a2a01fef9732b4bb7c2bb479f744195 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 10 Jun 2025 20:15:36 +0200
Subject: Remove `extra_features` from `LlvmBitcodeLinker`

It wasn't used anywhere.
---
 src/bootstrap/src/core/build_steps/compile.rs | 1 -
 src/bootstrap/src/core/build_steps/dist.rs    | 3 +--
 src/bootstrap/src/core/build_steps/tool.rs    | 4 +---
 3 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 3e2bdc2d6b5..c84f451bbb2 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -2061,7 +2061,6 @@ impl Step for Assemble {
                     builder.ensure(crate::core::build_steps::tool::LlvmBitcodeLinker {
                         compiler,
                         target: target_compiler.host,
-                        extra_features: vec![],
                     });
                 let tool_exe = exe("llvm-bitcode-linker", target_compiler.host);
                 builder.copy_link(
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index 25b7e5a1b5d..f2aace76896 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -2374,8 +2374,7 @@ impl Step for LlvmBitcodeLinker {
 
         builder.ensure(compile::Rustc::new(compiler, target));
 
-        let llbc_linker =
-            builder.ensure(tool::LlvmBitcodeLinker { compiler, target, extra_features: vec![] });
+        let llbc_linker = builder.ensure(tool::LlvmBitcodeLinker { compiler, target });
 
         let self_contained_bin_dir = format!("lib/rustlib/{}/bin/self-contained", target.triple);
 
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index b05b34b9b22..b906409aedd 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -1016,7 +1016,6 @@ impl Step for RustAnalyzerProcMacroSrv {
 pub struct LlvmBitcodeLinker {
     pub compiler: Compiler,
     pub target: TargetSelection,
-    pub extra_features: Vec<String>,
 }
 
 impl Step for LlvmBitcodeLinker {
@@ -1033,7 +1032,6 @@ impl Step for LlvmBitcodeLinker {
     fn make_run(run: RunConfig<'_>) {
         run.builder.ensure(LlvmBitcodeLinker {
             compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.host_target),
-            extra_features: Vec::new(),
             target: run.target,
         });
     }
@@ -1050,7 +1048,7 @@ impl Step for LlvmBitcodeLinker {
             mode: Mode::ToolRustc,
             path: "src/tools/llvm-bitcode-linker",
             source_type: SourceType::InTree,
-            extra_features: self.extra_features,
+            extra_features: vec![],
             allow_features: "",
             cargo_args: Vec::new(),
             artifact_kind: ToolArtifactKind::Binary,
-- 
cgit 1.4.1-3-g733a5


From c33f908f57cf1f3ea1a1261440062d2757909dc4 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Wed, 11 Jun 2025 08:50:09 +0200
Subject: Remove sysroot copy from `LlvmBitcodeLinker` step

That step should be responsible for building the tool, not performing side-effects. Also, only copy the tool to the `self-contained` directory, not to the `rustlib/<target>/bin` directory.
---
 src/bootstrap/src/core/build_steps/compile.rs |  9 ++++++++-
 src/bootstrap/src/core/build_steps/tool.rs    | 21 ++-------------------
 2 files changed, 10 insertions(+), 20 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index c84f451bbb2..1d095cfc58e 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -2062,10 +2062,17 @@ impl Step for Assemble {
                         compiler,
                         target: target_compiler.host,
                     });
+
+                // Copy the llvm-bitcode-linker to the self-contained binary directory
+                let bindir_self_contained = builder
+                    .sysroot(compiler)
+                    .join(format!("lib/rustlib/{}/bin/self-contained", compiler.host));
                 let tool_exe = exe("llvm-bitcode-linker", target_compiler.host);
+
+                t!(fs::create_dir_all(&bindir_self_contained));
                 builder.copy_link(
                     &llvm_bitcode_linker.tool_path,
-                    &libdir_bin.join(tool_exe),
+                    &bindir_self_contained.join(tool_exe),
                     FileType::Executable,
                 );
             }
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index b906409aedd..8396099d380 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -1041,7 +1041,7 @@ impl Step for LlvmBitcodeLinker {
         instrument(level = "debug", name = "LlvmBitcodeLinker::run", skip_all)
     )]
     fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
-        let tool_result = builder.ensure(ToolBuild {
+        builder.ensure(ToolBuild {
             compiler: self.compiler,
             target: self.target,
             tool: "llvm-bitcode-linker",
@@ -1052,24 +1052,7 @@ impl Step for LlvmBitcodeLinker {
             allow_features: "",
             cargo_args: Vec::new(),
             artifact_kind: ToolArtifactKind::Binary,
-        });
-
-        if tool_result.target_compiler.stage > 0 {
-            let bindir_self_contained = builder
-                .sysroot(tool_result.target_compiler)
-                .join(format!("lib/rustlib/{}/bin/self-contained", self.target.triple));
-            t!(fs::create_dir_all(&bindir_self_contained));
-            let bin_destination = bindir_self_contained
-                .join(exe("llvm-bitcode-linker", tool_result.target_compiler.host));
-            builder.copy_link(&tool_result.tool_path, &bin_destination, FileType::Executable);
-            ToolBuildResult {
-                tool_path: bin_destination,
-                build_compiler: tool_result.build_compiler,
-                target_compiler: tool_result.target_compiler,
-            }
-        } else {
-            tool_result
-        }
+        })
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From fd3772200140b82324a7af8b4153c2a1a2ac1e89 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 8 Jul 2025 11:47:57 +0200
Subject: Update llvm-bitcode-linker tests

---
 src/bootstrap/src/core/build_steps/compile.rs |  2 +-
 src/bootstrap/src/core/build_steps/dist.rs    |  3 ++-
 src/bootstrap/src/core/build_steps/tool.rs    | 12 +++++++++---
 src/bootstrap/src/core/builder/tests.rs       | 23 +++++++++++++++++++++++
 4 files changed, 35 insertions(+), 5 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 1d095cfc58e..29300ff56f5 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -2059,7 +2059,7 @@ impl Step for Assemble {
                 trace!("llvm-bitcode-linker enabled, installing");
                 let llvm_bitcode_linker =
                     builder.ensure(crate::core::build_steps::tool::LlvmBitcodeLinker {
-                        compiler,
+                        build_compiler: compiler,
                         target: target_compiler.host,
                     });
 
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index f2aace76896..8b2d65ace50 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -2374,7 +2374,8 @@ impl Step for LlvmBitcodeLinker {
 
         builder.ensure(compile::Rustc::new(compiler, target));
 
-        let llbc_linker = builder.ensure(tool::LlvmBitcodeLinker { compiler, target });
+        let llbc_linker =
+            builder.ensure(tool::LlvmBitcodeLinker { build_compiler: compiler, target });
 
         let self_contained_bin_dir = format!("lib/rustlib/{}/bin/self-contained", target.triple);
 
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 8396099d380..a7f6a2c7bae 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -1014,7 +1014,7 @@ impl Step for RustAnalyzerProcMacroSrv {
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct LlvmBitcodeLinker {
-    pub compiler: Compiler,
+    pub build_compiler: Compiler,
     pub target: TargetSelection,
 }
 
@@ -1031,7 +1031,9 @@ impl Step for LlvmBitcodeLinker {
 
     fn make_run(run: RunConfig<'_>) {
         run.builder.ensure(LlvmBitcodeLinker {
-            compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.host_target),
+            build_compiler: run
+                .builder
+                .compiler(run.builder.top_stage, run.builder.config.host_target),
             target: run.target,
         });
     }
@@ -1042,7 +1044,7 @@ impl Step for LlvmBitcodeLinker {
     )]
     fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
         builder.ensure(ToolBuild {
-            compiler: self.compiler,
+            compiler: self.build_compiler,
             target: self.target,
             tool: "llvm-bitcode-linker",
             mode: Mode::ToolRustc,
@@ -1054,6 +1056,10 @@ impl Step for LlvmBitcodeLinker {
             artifact_kind: ToolArtifactKind::Binary,
         })
     }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(StepMetadata::build("LlvmBitcodeLinker", self.target).built_by(self.build_compiler))
+    }
 }
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 1d5690a8197..131394f2a65 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -757,6 +757,27 @@ mod snapshot {
         ");
     }
 
+    #[test]
+    fn build_compiler_tools() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx
+                .config("build")
+                .stage(2)
+                .args(&["--set", "rust.llvm-bitcode-linker=true"])
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustc 1 <host> -> rustc 2 <host>
+        [build] rustc 2 <host> -> LlvmBitcodeLinker 3 <host>
+        [build] rustc 2 <host> -> std 2 <host>
+        [build] rustdoc 1 <host>
+        "
+        );
+    }
+
     #[test]
     fn build_library_no_explicit_stage() {
         let ctx = TestCtx::new();
@@ -1040,6 +1061,7 @@ mod snapshot {
         [build] rustc 0 <host> -> cargo-clippy 1 <host>
         [build] rustc 0 <host> -> miri 1 <host>
         [build] rustc 0 <host> -> cargo-miri 1 <host>
+        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
         ");
     }
 
@@ -1230,6 +1252,7 @@ mod snapshot {
         [build] rustc 0 <host> -> cargo-clippy 1 <target1>
         [build] rustc 0 <host> -> miri 1 <target1>
         [build] rustc 0 <host> -> cargo-miri 1 <target1>
+        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <target1>
         ");
     }
 
-- 
cgit 1.4.1-3-g733a5


From b14323aedcfef75bde97aff4f2562dcab8e9a3cd Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 8 Jul 2025 11:49:08 +0200
Subject: Also test `LldWrapper` and remove `llvm-config` override from tests

---
 src/bootstrap/src/core/build_steps/tool.rs | 7 +++++++
 src/bootstrap/src/core/builder/tests.rs    | 4 +++-
 src/bootstrap/src/utils/tests/mod.rs       | 2 --
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index a7f6a2c7bae..5de1b472d79 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -910,6 +910,13 @@ impl Step for LldWrapper {
 
         tool_result
     }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(
+            StepMetadata::build("LldWrapper", self.target_compiler.host)
+                .built_by(self.build_compiler),
+        )
+    }
 }
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 131394f2a65..b240d670b6b 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -764,13 +764,15 @@ mod snapshot {
             ctx
                 .config("build")
                 .stage(2)
-                .args(&["--set", "rust.llvm-bitcode-linker=true"])
+                .args(&["--set", "rust.lld=true", "--set", "rust.llvm-bitcode-linker=true"])
                 .render_steps(), @r"
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 0 <host> -> LldWrapper 1 <host>
         [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
+        [build] rustc 1 <host> -> LldWrapper 2 <host>
         [build] rustc 2 <host> -> LlvmBitcodeLinker 3 <host>
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustdoc 1 <host>
diff --git a/src/bootstrap/src/utils/tests/mod.rs b/src/bootstrap/src/utils/tests/mod.rs
index 59c169b0f2b..5b568c1df5b 100644
--- a/src/bootstrap/src/utils/tests/mod.rs
+++ b/src/bootstrap/src/utils/tests/mod.rs
@@ -96,8 +96,6 @@ impl ConfigBuilder {
         // in-tree LLVM from sources.
         self.args.push("--set".to_string());
         self.args.push("llvm.download-ci-llvm=false".to_string());
-        self.args.push("--set".to_string());
-        self.args.push(format!("target.'{}'.llvm-config=false", get_host_target()));
 
         // Do not mess with the local rustc checkout build directory
         self.args.push("--build-dir".to_string());
-- 
cgit 1.4.1-3-g733a5


From d44dcd451326d32516c22ee5f998304afaf19c4d Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Tue, 8 Jul 2025 10:16:44 +0000
Subject: update to literal-escaper-0.0.5

---
 Cargo.lock                             | 4 ++--
 compiler/rustc_ast/Cargo.toml          | 2 +-
 compiler/rustc_ast/src/util/literal.rs | 6 +++---
 compiler/rustc_parse/Cargo.toml        | 2 +-
 compiler/rustc_parse_format/Cargo.toml | 2 +-
 compiler/rustc_proc_macro/Cargo.toml   | 2 +-
 library/Cargo.lock                     | 4 ++--
 library/proc_macro/Cargo.toml          | 2 +-
 library/proc_macro/src/lib.rs          | 6 +++---
 src/tools/lint-docs/Cargo.toml         | 2 +-
 10 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6d823c5b5a5..bc34a8dc777 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3260,9 +3260,9 @@ checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
 name = "rustc-literal-escaper"
-version = "0.0.4"
+version = "0.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab03008eb631b703dd16978282ae36c73282e7922fe101a4bd072a40ecea7b8b"
+checksum = "e4ee29da77c5a54f42697493cd4c9b9f31b74df666a6c04dfc4fde77abe0438b"
 
 [[package]]
 name = "rustc-main"
diff --git a/compiler/rustc_ast/Cargo.toml b/compiler/rustc_ast/Cargo.toml
index 5de2e69072f..155e14a3796 100644
--- a/compiler/rustc_ast/Cargo.toml
+++ b/compiler/rustc_ast/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2024"
 # tidy-alphabetical-start
 bitflags = "2.4.1"
 memchr = "2.7.4"
-rustc-literal-escaper = "0.0.4"
+rustc-literal-escaper = "0.0.5"
 rustc_ast_ir = { path = "../rustc_ast_ir" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_index = { path = "../rustc_index" }
diff --git a/compiler/rustc_ast/src/util/literal.rs b/compiler/rustc_ast/src/util/literal.rs
index fa7878873e5..2dfd695d880 100644
--- a/compiler/rustc_ast/src/util/literal.rs
+++ b/compiler/rustc_ast/src/util/literal.rs
@@ -126,11 +126,11 @@ impl LitKind {
             token::CStr => {
                 let s = symbol.as_str();
                 let mut buf = Vec::with_capacity(s.len());
-                unescape_c_str(s, |_span, c| match c {
+                unescape_c_str(s, |_span, res| match res {
                     Ok(MixedUnit::Char(c)) => {
-                        buf.extend_from_slice(c.encode_utf8(&mut [0; 4]).as_bytes())
+                        buf.extend_from_slice(c.get().encode_utf8(&mut [0; 4]).as_bytes())
                     }
-                    Ok(MixedUnit::HighByte(b)) => buf.push(b),
+                    Ok(MixedUnit::HighByte(b)) => buf.push(b.get()),
                     Err(err) => {
                         assert!(!err.is_fatal(), "failed to unescape C string literal")
                     }
diff --git a/compiler/rustc_parse/Cargo.toml b/compiler/rustc_parse/Cargo.toml
index c4a0ae2ce9d..a92012f8329 100644
--- a/compiler/rustc_parse/Cargo.toml
+++ b/compiler/rustc_parse/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2024"
 [dependencies]
 # tidy-alphabetical-start
 bitflags = "2.4.1"
-rustc-literal-escaper = "0.0.4"
+rustc-literal-escaper = "0.0.5"
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_data_structures = { path = "../rustc_data_structures" }
diff --git a/compiler/rustc_parse_format/Cargo.toml b/compiler/rustc_parse_format/Cargo.toml
index 0666ae29409..d178fcda1fb 100644
--- a/compiler/rustc_parse_format/Cargo.toml
+++ b/compiler/rustc_parse_format/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-rustc-literal-escaper = "0.0.4"
+rustc-literal-escaper = "0.0.5"
 rustc_lexer = { path = "../rustc_lexer" }
 # tidy-alphabetical-end
 
diff --git a/compiler/rustc_proc_macro/Cargo.toml b/compiler/rustc_proc_macro/Cargo.toml
index 748fa944e28..762acf9a1eb 100644
--- a/compiler/rustc_proc_macro/Cargo.toml
+++ b/compiler/rustc_proc_macro/Cargo.toml
@@ -15,7 +15,7 @@ test = false
 doctest = false
 
 [dependencies]
-rustc-literal-escaper = "0.0.4"
+rustc-literal-escaper = "0.0.5"
 
 [features]
 rustc-dep-of-std = []
diff --git a/library/Cargo.lock b/library/Cargo.lock
index c681c5935df..8b5275e5065 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -271,9 +271,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-literal-escaper"
-version = "0.0.4"
+version = "0.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab03008eb631b703dd16978282ae36c73282e7922fe101a4bd072a40ecea7b8b"
+checksum = "e4ee29da77c5a54f42697493cd4c9b9f31b74df666a6c04dfc4fde77abe0438b"
 dependencies = [
  "rustc-std-workspace-core",
  "rustc-std-workspace-std",
diff --git a/library/proc_macro/Cargo.toml b/library/proc_macro/Cargo.toml
index 8ea92088a84..0042a6e8ece 100644
--- a/library/proc_macro/Cargo.toml
+++ b/library/proc_macro/Cargo.toml
@@ -9,7 +9,7 @@ std = { path = "../std" }
 # `core` when resolving doc links. Without this line a different `core` will be
 # loaded from sysroot causing duplicate lang items and other similar errors.
 core = { path = "../core" }
-rustc-literal-escaper = { version = "0.0.4", features = ["rustc-dep-of-std"] }
+rustc-literal-escaper = { version = "0.0.5", features = ["rustc-dep-of-std"] }
 
 [features]
 default = ["rustc-dep-of-std"]
diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
index ff326342989..162b4fdcc8a 100644
--- a/library/proc_macro/src/lib.rs
+++ b/library/proc_macro/src/lib.rs
@@ -1471,11 +1471,11 @@ impl Literal {
                 let mut error = None;
                 let mut buf = Vec::with_capacity(symbol.len());
 
-                unescape_c_str(symbol, |_span, c| match c {
+                unescape_c_str(symbol, |_span, res| match res {
                     Ok(MixedUnit::Char(c)) => {
-                        buf.extend_from_slice(c.encode_utf8(&mut [0; 4]).as_bytes())
+                        buf.extend_from_slice(c.get().encode_utf8(&mut [0; 4]).as_bytes())
                     }
-                    Ok(MixedUnit::HighByte(b)) => buf.push(b),
+                    Ok(MixedUnit::HighByte(b)) => buf.push(b.get()),
                     Err(err) => {
                         if err.is_fatal() {
                             error = Some(ConversionErrorKind::FailedToUnescape(err));
diff --git a/src/tools/lint-docs/Cargo.toml b/src/tools/lint-docs/Cargo.toml
index e914a2df2ba..6e1ab84ed18 100644
--- a/src/tools/lint-docs/Cargo.toml
+++ b/src/tools/lint-docs/Cargo.toml
@@ -7,7 +7,7 @@ description = "A script to extract the lint documentation for the rustc book."
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rustc-literal-escaper = "0.0.4"
+rustc-literal-escaper = "0.0.5"
 serde_json = "1.0.57"
 tempfile = "3.1.0"
 walkdir = "2.3.1"
-- 
cgit 1.4.1-3-g733a5


From e32b1d712650bec425ea5b551473387cd9eea2ec Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Tue, 8 Jul 2025 09:29:12 +0000
Subject: expand `-Clink-self-contained` tests

- update existing tests for stabilization
- ensure `-Clink-self-contained=-linker` is only stable on x64 linux
- test invalid `-Clink-self-contained` components
---
 tests/ui/linking/link-self-contained-consistency.rs    |  1 -
 .../linking/link-self-contained-linker-disallowed.rs   | 18 ++++++++++++++++++
 ...ontained-linker-disallowed.unstable_positive.stderr |  2 ++
 ...d-linker-disallowed.unstable_target_negative.stderr |  2 ++
 ...d-linker-disallowed.unstable_target_positive.stderr |  2 ++
 .../linking/link-self-contained-unstable.crto.stderr   |  2 ++
 .../linking/link-self-contained-unstable.libc.stderr   |  2 ++
 .../linking/link-self-contained-unstable.mingw.stderr  |  2 ++
 tests/ui/linking/link-self-contained-unstable.rs       | 13 +++++++++++++
 .../link-self-contained-unstable.sanitizers.stderr     |  2 ++
 .../linking/link-self-contained-unstable.unwind.stderr |  2 ++
 11 files changed, 47 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/linking/link-self-contained-linker-disallowed.rs
 create mode 100644 tests/ui/linking/link-self-contained-linker-disallowed.unstable_positive.stderr
 create mode 100644 tests/ui/linking/link-self-contained-linker-disallowed.unstable_target_negative.stderr
 create mode 100644 tests/ui/linking/link-self-contained-linker-disallowed.unstable_target_positive.stderr
 create mode 100644 tests/ui/linking/link-self-contained-unstable.crto.stderr
 create mode 100644 tests/ui/linking/link-self-contained-unstable.libc.stderr
 create mode 100644 tests/ui/linking/link-self-contained-unstable.mingw.stderr
 create mode 100644 tests/ui/linking/link-self-contained-unstable.rs
 create mode 100644 tests/ui/linking/link-self-contained-unstable.sanitizers.stderr
 create mode 100644 tests/ui/linking/link-self-contained-unstable.unwind.stderr

diff --git a/tests/ui/linking/link-self-contained-consistency.rs b/tests/ui/linking/link-self-contained-consistency.rs
index 08227433891..e3944fc0360 100644
--- a/tests/ui/linking/link-self-contained-consistency.rs
+++ b/tests/ui/linking/link-self-contained-consistency.rs
@@ -1,7 +1,6 @@
 // Checks that self-contained linking components cannot be both enabled and disabled at the same
 // time on the CLI.
 
-//@ check-fail
 //@ revisions: one many
 //@ [one] compile-flags: -Clink-self-contained=-linker -Clink-self-contained=+linker -Zunstable-options
 //@ [many] compile-flags: -Clink-self-contained=+linker,+crto -Clink-self-contained=-linker,-crto -Zunstable-options
diff --git a/tests/ui/linking/link-self-contained-linker-disallowed.rs b/tests/ui/linking/link-self-contained-linker-disallowed.rs
new file mode 100644
index 00000000000..f076eb2017a
--- /dev/null
+++ b/tests/ui/linking/link-self-contained-linker-disallowed.rs
@@ -0,0 +1,18 @@
+// Check that only `-C link-self-contained=-linker` is stable on x64 linux. Any other value or
+// target, needs `-Z unstable-options`.
+
+// ignore-tidy-linelength
+
+//@ revisions: unstable_target_positive unstable_target_negative unstable_positive
+//@ [unstable_target_negative] compile-flags: --target=x86_64-unknown-linux-musl -C link-self-contained=-linker --crate-type=rlib
+//@ [unstable_target_negative] needs-llvm-components: x86
+//@ [unstable_target_positive] compile-flags: --target=x86_64-unknown-linux-musl -C link-self-contained=+linker --crate-type=rlib
+//@ [unstable_target_positive] needs-llvm-components: x86
+//@ [unstable_positive] compile-flags: --target=x86_64-unknown-linux-gnu -C link-self-contained=+linker --crate-type=rlib
+//@ [unstable_positive] needs-llvm-components: x86
+
+#![feature(no_core)]
+#![no_core]
+
+//[unstable_target_negative]~? ERROR `-C link-self-contained=-linker` is unstable on the `x86_64-unknown-linux-musl` target
+//[unstable_target_positive,unstable_positive]~? ERROR only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off`/`-linker` are stable
diff --git a/tests/ui/linking/link-self-contained-linker-disallowed.unstable_positive.stderr b/tests/ui/linking/link-self-contained-linker-disallowed.unstable_positive.stderr
new file mode 100644
index 00000000000..4eb0ff04b65
--- /dev/null
+++ b/tests/ui/linking/link-self-contained-linker-disallowed.unstable_positive.stderr
@@ -0,0 +1,2 @@
+error: only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off`/`-linker` are stable, the `-Z unstable-options` flag must also be passed to use the unstable values
+
diff --git a/tests/ui/linking/link-self-contained-linker-disallowed.unstable_target_negative.stderr b/tests/ui/linking/link-self-contained-linker-disallowed.unstable_target_negative.stderr
new file mode 100644
index 00000000000..8bf71941c44
--- /dev/null
+++ b/tests/ui/linking/link-self-contained-linker-disallowed.unstable_target_negative.stderr
@@ -0,0 +1,2 @@
+error: `-C link-self-contained=-linker` is unstable on the `x86_64-unknown-linux-musl` target. The `-Z unstable-options` flag must also be passed to use it on this target
+
diff --git a/tests/ui/linking/link-self-contained-linker-disallowed.unstable_target_positive.stderr b/tests/ui/linking/link-self-contained-linker-disallowed.unstable_target_positive.stderr
new file mode 100644
index 00000000000..4eb0ff04b65
--- /dev/null
+++ b/tests/ui/linking/link-self-contained-linker-disallowed.unstable_target_positive.stderr
@@ -0,0 +1,2 @@
+error: only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off`/`-linker` are stable, the `-Z unstable-options` flag must also be passed to use the unstable values
+
diff --git a/tests/ui/linking/link-self-contained-unstable.crto.stderr b/tests/ui/linking/link-self-contained-unstable.crto.stderr
new file mode 100644
index 00000000000..4eb0ff04b65
--- /dev/null
+++ b/tests/ui/linking/link-self-contained-unstable.crto.stderr
@@ -0,0 +1,2 @@
+error: only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off`/`-linker` are stable, the `-Z unstable-options` flag must also be passed to use the unstable values
+
diff --git a/tests/ui/linking/link-self-contained-unstable.libc.stderr b/tests/ui/linking/link-self-contained-unstable.libc.stderr
new file mode 100644
index 00000000000..4eb0ff04b65
--- /dev/null
+++ b/tests/ui/linking/link-self-contained-unstable.libc.stderr
@@ -0,0 +1,2 @@
+error: only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off`/`-linker` are stable, the `-Z unstable-options` flag must also be passed to use the unstable values
+
diff --git a/tests/ui/linking/link-self-contained-unstable.mingw.stderr b/tests/ui/linking/link-self-contained-unstable.mingw.stderr
new file mode 100644
index 00000000000..4eb0ff04b65
--- /dev/null
+++ b/tests/ui/linking/link-self-contained-unstable.mingw.stderr
@@ -0,0 +1,2 @@
+error: only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off`/`-linker` are stable, the `-Z unstable-options` flag must also be passed to use the unstable values
+
diff --git a/tests/ui/linking/link-self-contained-unstable.rs b/tests/ui/linking/link-self-contained-unstable.rs
new file mode 100644
index 00000000000..10c895909d5
--- /dev/null
+++ b/tests/ui/linking/link-self-contained-unstable.rs
@@ -0,0 +1,13 @@
+// Checks that values for `-Clink-self-contained` other than the blanket enable/disable and
+// `-linker` require `-Zunstable-options`.
+
+//@ revisions: crto libc unwind sanitizers mingw
+//@ [crto] compile-flags: -Clink-self-contained=+crto
+//@ [libc] compile-flags: -Clink-self-contained=-libc
+//@ [unwind] compile-flags: -Clink-self-contained=+unwind
+//@ [sanitizers] compile-flags: -Clink-self-contained=-sanitizers
+//@ [mingw] compile-flags: -Clink-self-contained=+mingw
+
+fn main() {}
+
+//~? ERROR only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off`/`-linker` are stable
diff --git a/tests/ui/linking/link-self-contained-unstable.sanitizers.stderr b/tests/ui/linking/link-self-contained-unstable.sanitizers.stderr
new file mode 100644
index 00000000000..4eb0ff04b65
--- /dev/null
+++ b/tests/ui/linking/link-self-contained-unstable.sanitizers.stderr
@@ -0,0 +1,2 @@
+error: only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off`/`-linker` are stable, the `-Z unstable-options` flag must also be passed to use the unstable values
+
diff --git a/tests/ui/linking/link-self-contained-unstable.unwind.stderr b/tests/ui/linking/link-self-contained-unstable.unwind.stderr
new file mode 100644
index 00000000000..4eb0ff04b65
--- /dev/null
+++ b/tests/ui/linking/link-self-contained-unstable.unwind.stderr
@@ -0,0 +1,2 @@
+error: only `-C link-self-contained` values `y`/`yes`/`on`/`n`/`no`/`off`/`-linker` are stable, the `-Z unstable-options` flag must also be passed to use the unstable values
+
-- 
cgit 1.4.1-3-g733a5


From 889638a8b3591d71bdec38efbac27469f5019b49 Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Tue, 8 Jul 2025 09:19:58 +0000
Subject: document new stable flags, with x64 linux implementation notes

---
 src/doc/rustc/src/codegen-options/index.md         | 59 ++++++++++++++++++++--
 .../src/compiler-flags/codegen-options.md          |  8 +--
 .../src/compiler-flags/linker-features.md          | 35 -------------
 3 files changed, 59 insertions(+), 43 deletions(-)
 delete mode 100644 src/doc/unstable-book/src/compiler-flags/linker-features.md

diff --git a/src/doc/rustc/src/codegen-options/index.md b/src/doc/rustc/src/codegen-options/index.md
index bb109adf76f..07eafdf4c4c 100644
--- a/src/doc/rustc/src/codegen-options/index.md
+++ b/src/doc/rustc/src/codegen-options/index.md
@@ -235,15 +235,33 @@ coverage measurement. Its use is not recommended.
 
 ## link-self-contained
 
-On `windows-gnu`, `linux-musl`, and `wasi` targets, this flag controls whether the
-linker will use libraries and objects shipped with Rust instead of those in the system.
-It takes one of the following values:
+This flag controls whether the linker will use libraries and objects shipped with Rust instead of
+those in the system.  It also controls which binary is used for the linker itself. This allows
+overriding cases when detection fails or the user wants to use shipped libraries.
+
+You can enable or disable the usage of any self-contained components using one of the following values:
 
 * no value: rustc will use heuristic to disable self-contained mode if system has necessary tools.
 * `y`, `yes`, `on`, `true`: use only libraries/objects shipped with Rust.
 * `n`, `no`, `off` or `false`: rely on the user or the linker to provide non-Rust libraries/objects.
 
-This allows overriding cases when detection fails or user wants to use shipped libraries.
+It is also possible to enable or disable specific self-contained components in a more granular way.
+You can pass a comma-separated list of self-contained components, individually enabled
+(`+component`) or disabled (`-component`).
+
+Currently, only the `linker` granular option is stabilized, and only on the `x86_64-unknown-linux-gnu` target:
+- `linker`: toggle the usage of self-contained linker binaries (linker, dlltool, and their necessary libraries)
+
+Note that only the `-linker` opt-out is stable on the `x86_64-unknown-linux-gnu` target: `+linker` is
+already the default on this target.
+
+#### Implementation notes
+
+On the `x86_64-unknown-linux-gnu` target, when using the default linker flavor (using `cc` as the
+linker driver) and linker features (to try using `lld`), `rustc` will try to use the self-contained
+linker by passing a `-B /path/to/sysroot/` link argument to the driver to find `rust-lld` in the
+sysroot. For backwards-compatibility, and to limit name and `PATH` collisions, this is done using a
+shim executable (the `lld-wrapper` tool) that forwards execution to the `rust-lld` executable itself.
 
 ## linker
 
@@ -256,6 +274,39 @@ Note that on Unix-like targets (for example, `*-unknown-linux-gnu` or `*-unknown
 the C compiler (for example `cc` or `clang`) is used as the "linker" here, serving as a linker driver.
 It will invoke the actual linker with all the necessary flags to be able to link against the system libraries like libc.
 
+## linker-features
+
+The `-Clinker-features` flag allows enabling or disabling specific features used during linking.
+
+These feature flags are a flexible extension mechanism that is complementary to linker flavors,
+designed to avoid the combinatorial explosion of having to create a new set of flavors for each
+linker feature we'd want to use.
+
+The flag accepts a comma-separated list of features, individually enabled (`+feature`) or disabled
+(`-feature`).
+
+Currently only one is stable, and only on the `x86_64-unknown-linux-gnu` target:
+- `lld`: to toggle trying to use the lld linker, either the system-installed binary, or the self-contained
+  `rust-lld` linker (via the [`-Clink-self-contained=+linker`](#link-self-contained) flag).
+
+For example, use:
+- `-Clinker-features=+lld` to opt into using the `lld` linker, when possible (see the Implementation notes below)
+- `-Clinker-features=-lld` to opt out instead, for targets where it is configured as the default linker
+
+Note that only the `-lld` opt-out is stable on the `x86_64-unknown-linux-gnu` target: `+lld` is
+already the default on this target.
+
+#### Implementation notes
+
+On the `x86_64-unknown-linux-gnu` target, when using the default linker flavor (using `cc` as the
+linker driver), `rustc` will try to use lld by passing a `-fuse-ld=lld` link argument to the driver.
+`rustc` will also try to detect if that _causes_ an error during linking (for example, if GCC is too
+old to understand the flag, and returns an error) and will then retry linking without this argument,
+as a fallback.
+
+If the user _also_ passes a `-Clink-arg=-fuse-ld=$value`, both will be given to the linker
+driver but the user's will be passed last, and would generally have priority over `rustc`'s.
+
 ## linker-flavor
 
 This flag controls the linker flavor used by `rustc`. If a linker is given with
diff --git a/src/doc/unstable-book/src/compiler-flags/codegen-options.md b/src/doc/unstable-book/src/compiler-flags/codegen-options.md
index cc51554706d..f927e5c439c 100644
--- a/src/doc/unstable-book/src/compiler-flags/codegen-options.md
+++ b/src/doc/unstable-book/src/compiler-flags/codegen-options.md
@@ -51,10 +51,10 @@ instead of those in the system. The stable boolean values for this flag are coar
 - `mingw`: other MinGW libs and Windows import libs
 
 Out of the above self-contained linking components, `linker` is the only one currently implemented
-(beyond parsing the CLI options).
+(beyond parsing the CLI options) and stabilized.
 
 It refers to the LLD linker, built from the same LLVM revision used by rustc (named `rust-lld` to
 avoid naming conflicts), that is distributed via `rustup` with the compiler (and is used by default
-for the wasm targets). One can also opt-in to use it by combining this flag with an appropriate
-linker flavor: for example, `-Clinker-flavor=gnu-lld-cc -Clink-self-contained=+linker` will use the
-toolchain's `rust-lld` as the linker.
+for the wasm targets). One can also opt into using it by combining this flag with the appropriate
+linker feature: for example, `-Clinker-features=+lld -Clink-self-contained=+linker` will use the
+toolchain's `rust-lld` as the linker instead of the system's lld with `-Clinker-features=+lld` only.
diff --git a/src/doc/unstable-book/src/compiler-flags/linker-features.md b/src/doc/unstable-book/src/compiler-flags/linker-features.md
deleted file mode 100644
index 643fcf7c6d7..00000000000
--- a/src/doc/unstable-book/src/compiler-flags/linker-features.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# `linker-features`
-
---------------------
-
-The `-Zlinker-features` compiler flag allows enabling or disabling specific features used during
-linking, and is intended to be stabilized under the codegen options as `-Clinker-features`.
-
-These feature flags are a flexible extension mechanism that is complementary to linker flavors,
-designed to avoid the combinatorial explosion of having to create a new set of flavors for each
-linker feature we'd want to use.
-
-For example, this design allows:
-- default feature sets for principal flavors, or for specific targets.
-- flavor-specific features: for example, clang offers automatic cross-linking with `--target`, which
-  gcc-style compilers don't support. The *flavor* is still a C/C++ compiler, and we don't want to
-  multiply the number of flavors for this use-case. Instead, we can have a single `+target` feature.
-- umbrella features: for example, if clang accumulates more features in the future than just the
-  `+target` above. That could be modeled as `+clang`.
-- niche features for resolving specific issues: for example, on Apple targets the linker flag
-  implementing the `as-needed` native link modifier (#99424) is only possible on sufficiently recent
-  linker versions.
-- still allows for discovery and automation, for example via feature detection. This can be useful
-  in exotic environments/build systems.
-
-The flag accepts a comma-separated list of features, individually enabled (`+features`) or disabled
-(`-features`), though currently only one is exposed on the CLI:
-- `lld`: to toggle using the lld linker, either the system-installed binary, or the self-contained
-  `rust-lld` linker.
-
-As described above, this list is intended to grow in the future.
-
-One of the most common uses of this flag will be to toggle self-contained linking with `rust-lld` on
-and off: `-Clinker-features=+lld -Clink-self-contained=+linker` will use the toolchain's `rust-lld`
-as the linker. Inversely, `-Clinker-features=-lld` would opt out of that, if the current target had
-self-contained linking enabled by default.
-- 
cgit 1.4.1-3-g733a5


From 5059315e28fde405edffd7ad9eed3853cc412fad Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Fri, 6 Jun 2025 12:17:55 +0000
Subject: remove `-znostart-stop-gc` workaround

Now that `#[used(linker)]` is the default on ELF, we don't need to use the
`-znostart-stop-gc` link-arg workaround to match bfd's behavior when
using lld.
---
 compiler/rustc_codegen_ssa/src/back/link.rs | 29 -----------------------------
 1 file changed, 29 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 34328687e3f..b46773396fc 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -3327,35 +3327,6 @@ fn add_lld_args(
     // this, `wasm-component-ld`, which is overridden if this option is passed.
     if !sess.target.is_like_wasm {
         cmd.cc_arg("-fuse-ld=lld");
-
-        // On ELF platforms like at least x64 linux, GNU ld and LLD have opposite defaults on some
-        // section garbage-collection features. For example, the somewhat popular `linkme` crate and
-        // its dependents rely in practice on this difference: when using lld, they need `-z
-        // nostart-stop-gc` to prevent encapsulation symbols and sections from being
-        // garbage-collected.
-        //
-        // More information about all this can be found in:
-        // - https://maskray.me/blog/2021-01-31-metadata-sections-comdat-and-shf-link-order
-        // - https://lld.llvm.org/ELF/start-stop-gc
-        //
-        // So when using lld, we restore, for now, the traditional behavior to help migration, but
-        // will remove it in the future.
-        // Since this only disables an optimization, it shouldn't create issues, but is in theory
-        // slightly suboptimal. However, it:
-        // - doesn't have any visible impact on our benchmarks
-        // - reduces the need to disable lld for the crates that depend on this
-        //
-        // Note that lld can detect some cases where this difference is relied on, and emits a
-        // dedicated error to add this link arg. We could make use of this error to emit an FCW. As
-        // of writing this, we don't do it, because lld is already enabled by default on nightly
-        // without this mitigation: no working project would see the FCW, so we do this to help
-        // stabilization.
-        //
-        // FIXME: emit an FCW if linking fails due its absence, and then remove this link-arg in the
-        // future.
-        if sess.target.llvm_target == "x86_64-unknown-linux-gnu" {
-            cmd.link_arg("-znostart-stop-gc");
-        }
     }
 
     if !flavor.is_gnu() {
-- 
cgit 1.4.1-3-g733a5


From 045557797431bfff807145341efbe8f8fb08817e Mon Sep 17 00:00:00 2001
From: Dillon Amburgey <dillona@dillona.com>
Date: Tue, 8 Jul 2025 06:17:03 -0500
Subject: fix: correct parameter names in LLVMRustBuildMinNum and
 LLVMRustBuildMaxNum FFI declarations

---
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 91ada856d59..b9dd10ff014 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1980,12 +1980,12 @@ unsafe extern "C" {
     pub(crate) fn LLVMRustBuildMinNum<'a>(
         B: &Builder<'a>,
         LHS: &'a Value,
-        LHS: &'a Value,
+        RHS: &'a Value,
     ) -> &'a Value;
     pub(crate) fn LLVMRustBuildMaxNum<'a>(
         B: &Builder<'a>,
         LHS: &'a Value,
-        LHS: &'a Value,
+        RHS: &'a Value,
     ) -> &'a Value;
 
     // Atomic Operations
-- 
cgit 1.4.1-3-g733a5


From b2299e20b2c2a25254fb554ccc59a8b60fdc25e0 Mon Sep 17 00:00:00 2001
From: Dillon Amburgey <dillona@dillona.com>
Date: Tue, 8 Jul 2025 06:18:18 -0500
Subject: fix: correct assertion to check for 'noinline' attribute presence
 before removal

---
 compiler/rustc_codegen_llvm/src/back/lto.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index 9c62244f3c9..74418adc43c 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -680,7 +680,7 @@ pub(crate) fn run_pass_manager(
             if attributes::has_string_attr(function, enzyme_marker) {
                 // Sanity check: Ensure 'noinline' is present before replacing it.
                 assert!(
-                    !attributes::has_attr(function, Function, llvm::AttributeKind::NoInline),
+                    attributes::has_attr(function, Function, llvm::AttributeKind::NoInline),
                     "Expected __enzyme function to have 'noinline' before adding 'alwaysinline'"
                 );
 
-- 
cgit 1.4.1-3-g733a5


From 3ba8e330f9960a52b2c8ca10c8cba425514919f9 Mon Sep 17 00:00:00 2001
From: Aleksey Kliger <aleksey@lambdageek.org>
Date: Tue, 8 Jul 2025 07:34:51 -0400
Subject: Rewrite for clarity

move common code to a helper function

Co-Authored-By: Kobzol <berykubik@gmail.com>
---
 src/bootstrap/configure.py | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/bootstrap/configure.py b/src/bootstrap/configure.py
index 94e02f942dc..86208b94261 100755
--- a/src/bootstrap/configure.py
+++ b/src/bootstrap/configure.py
@@ -744,22 +744,24 @@ def write_uncommented(target, f):
     A block is a sequence of non-empty lines separated by empty lines.
     """
     block = []
-    is_comment = True
+
+    def flush(last):
+        # If the block is entiry made of comments, ignore it
+        entire_block_comments = all(ln.startswith("#") or ln == "" for ln in block)
+        if not entire_block_comments and len(block) > 0:
+            for line in block:
+                f.write(line + "\n")
+            # Required to output a newline before the start of a new section
+            if last:
+                f.write("\n")
+        block.clear()
 
     for line in target:
         block.append(line)
         if len(line) == 0:
-            if not is_comment:
-                for ln in block:
-                    f.write(ln + "\n")
-            block = []
-            is_comment = True
-            continue
-        is_comment = is_comment and line.startswith("#")
-    # Write the last accumulated block
-    if len(block) > 0 and not is_comment:
-        for ln in block:
-            f.write(ln + "\n")
+            flush(last=False)
+
+    flush(last=True)
     return f
 
 
-- 
cgit 1.4.1-3-g733a5


From 004478a829c7b4b7aa608f0f2d4d58a97c7836af Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Wed, 2 Jul 2025 13:19:41 +0000
Subject: int_log10.rs: change top level doc comments to outer

---
 library/core/src/num/int_log10.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/core/src/num/int_log10.rs b/library/core/src/num/int_log10.rs
index 28a3f5d880a..649a736b6e7 100644
--- a/library/core/src/num/int_log10.rs
+++ b/library/core/src/num/int_log10.rs
@@ -1,5 +1,5 @@
-/// These functions compute the integer logarithm of their type, assuming
-/// that someone has already checked that the value is strictly positive.
+//! These functions compute the integer logarithm of their type, assuming
+//! that someone has already checked that the value is strictly positive.
 
 // 0 < val <= u8::MAX
 #[inline]
-- 
cgit 1.4.1-3-g733a5


From f96d5d960256557a0c2434a308fd32c98e94aa7f Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Wed, 2 Jul 2025 13:29:16 +0000
Subject: collect.rs: remove empty line after doc comment

---
 library/core/src/fmt/mod.rs             | 1 -
 library/core/src/iter/traits/collect.rs | 1 -
 library/core/src/lib.rs                 | 6 +++---
 library/core/src/net/ip_addr.rs         | 1 -
 library/core/src/primitive_docs.rs      | 1 -
 library/core/src/str/mod.rs             | 1 -
 6 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
index 5e50eacec6e..77ab1c4201c 100644
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@@ -854,7 +854,6 @@ impl Display for Arguments<'_> {
 /// }";
 /// assert_eq!(format!("The origin is: {origin:#?}"), expected);
 /// ```
-
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_on_unimplemented(
     on(
diff --git a/library/core/src/iter/traits/collect.rs b/library/core/src/iter/traits/collect.rs
index 3bc9cff8072..ab276500679 100644
--- a/library/core/src/iter/traits/collect.rs
+++ b/library/core/src/iter/traits/collect.rs
@@ -436,7 +436,6 @@ pub trait Extend<A> {
     /// **For implementors:** For a collection to unsafely rely on this method's safety precondition (that is,
     /// invoke UB if they are violated), it must implement `extend_reserve` correctly. In other words,
     /// callers may assume that if they `extend_reserve`ed enough space they can call this method.
-
     // This method is for internal usage only. It is only on the trait because of specialization's limitations.
     #[unstable(feature = "extend_one_unchecked", issue = "none")]
     #[doc(hidden)]
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 2f701171505..de5174bcbf6 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -39,9 +39,9 @@
 //!   return. You should mark your implementation using `#[panic_handler]`.
 //!
 //! * `rust_eh_personality` - is used by the failure mechanisms of the
-//!    compiler. This is often mapped to GCC's personality function, but crates
-//!    which do not trigger a panic can be assured that this function is never
-//!    called. The `lang` attribute is called `eh_personality`.
+//!   compiler. This is often mapped to GCC's personality function, but crates
+//!   which do not trigger a panic can be assured that this function is never
+//!   called. The `lang` attribute is called `eh_personality`.
 
 #![stable(feature = "core", since = "1.6.0")]
 #![doc(
diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index aaa68e8d7d1..49a7ae5de5c 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -787,7 +787,6 @@ impl Ipv4Addr {
     /// [IANA IPv4 Special-Purpose Address Registry]: https://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry.xhtml
     /// [unspecified address]: Ipv4Addr::UNSPECIFIED
     /// [broadcast address]: Ipv4Addr::BROADCAST
-
     ///
     /// # Examples
     ///
diff --git a/library/core/src/primitive_docs.rs b/library/core/src/primitive_docs.rs
index 2c77c55745b..28124ac5aa8 100644
--- a/library/core/src/primitive_docs.rs
+++ b/library/core/src/primitive_docs.rs
@@ -1365,7 +1365,6 @@ mod prim_f16 {}
 /// x = a + b + c + d; // As written
 /// x = (a + c) + (b + d); // Reordered to shorten critical path and enable vectorization
 /// ```
-
 #[stable(feature = "rust1", since = "1.0.0")]
 mod prim_f32 {}
 
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index fe64132ff22..98b5e29009c 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -2648,7 +2648,6 @@ impl str {
     /// you're trying to parse into.
     ///
     /// `parse` can parse into any type that implements the [`FromStr`] trait.
-
     ///
     /// # Errors
     ///
-- 
cgit 1.4.1-3-g733a5


From ca4a712b59b9ed216e8bb6e24140b08d7020c68c Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Thu, 3 Jul 2025 12:41:05 +0000
Subject: clippy fix: markdown indentation for indented items after line break

---
 library/core/src/async_iter/async_iter.rs    | 10 +++++-----
 library/core/src/mem/mod.rs                  |  2 +-
 library/core/src/ptr/docs/as_uninit_slice.md | 20 ++++++++++----------
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/library/core/src/async_iter/async_iter.rs b/library/core/src/async_iter/async_iter.rs
index 069c50c2531..c21c08320be 100644
--- a/library/core/src/async_iter/async_iter.rs
+++ b/library/core/src/async_iter/async_iter.rs
@@ -28,15 +28,15 @@ pub trait AsyncIterator {
     /// async iterator state:
     ///
     /// - `Poll::Pending` means that this async iterator's next value is not ready
-    /// yet. Implementations will ensure that the current task will be notified
-    /// when the next value may be ready.
+    ///   yet. Implementations will ensure that the current task will be notified
+    ///   when the next value may be ready.
     ///
     /// - `Poll::Ready(Some(val))` means that the async iterator has successfully
-    /// produced a value, `val`, and may produce further values on subsequent
-    /// `poll_next` calls.
+    ///   produced a value, `val`, and may produce further values on subsequent
+    ///   `poll_next` calls.
     ///
     /// - `Poll::Ready(None)` means that the async iterator has terminated, and
-    /// `poll_next` should not be invoked again.
+    ///   `poll_next` should not be invoked again.
     ///
     /// # Panics
     ///
diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
index c00585de064..8db52a38014 100644
--- a/library/core/src/mem/mod.rs
+++ b/library/core/src/mem/mod.rs
@@ -36,7 +36,7 @@ pub use crate::intrinsics::transmute;
 /// * If you want to leak memory, see [`Box::leak`].
 /// * If you want to obtain a raw pointer to the memory, see [`Box::into_raw`].
 /// * If you want to dispose of a value properly, running its destructor, see
-/// [`mem::drop`].
+///   [`mem::drop`].
 ///
 /// # Safety
 ///
diff --git a/library/core/src/ptr/docs/as_uninit_slice.md b/library/core/src/ptr/docs/as_uninit_slice.md
index c80c0405883..1113f4748c2 100644
--- a/library/core/src/ptr/docs/as_uninit_slice.md
+++ b/library/core/src/ptr/docs/as_uninit_slice.md
@@ -10,24 +10,24 @@ When calling this method, you have to ensure that *either* the pointer is null *
 all of the following is true:
 
 * The pointer must be [valid] for reads for `ptr.len() * size_of::<T>()` many bytes,
-and it must be properly aligned. This means in particular:
+  and it must be properly aligned. This means in particular:
 
 * The entire memory range of this slice must be contained within a single [allocation]!
-Slices can never span across multiple allocations.
+  Slices can never span across multiple allocations.
 
 * The pointer must be aligned even for zero-length slices. One
-reason for this is that enum layout optimizations may rely on references
-(including slices of any length) being aligned and non-null to distinguish
-them from other data. You can obtain a pointer that is usable as `data`
-for zero-length slices using [`NonNull::dangling()`].
+  reason for this is that enum layout optimizations may rely on references
+  (including slices of any length) being aligned and non-null to distinguish
+  them from other data. You can obtain a pointer that is usable as `data`
+  for zero-length slices using [`NonNull::dangling()`].
 
 * The total size `ptr.len() * size_of::<T>()` of the slice must be no larger than `isize::MAX`.
-See the safety documentation of [`pointer::offset`].
+  See the safety documentation of [`pointer::offset`].
 
 * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-In particular, while this reference exists, the memory the pointer points to must
-not get mutated (except inside `UnsafeCell`).
+  arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
+  In particular, while this reference exists, the memory the pointer points to must
+  not get mutated (except inside `UnsafeCell`).
 
 This applies even if the result of this method is unused!
 
-- 
cgit 1.4.1-3-g733a5


From 961bac0b197bf5ded0da8faf1395c96598923b20 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 8 Jul 2025 15:06:27 +0200
Subject: Add cross-compilation tool test

---
 src/bootstrap/src/core/builder/tests.rs | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index b240d670b6b..bbcb58fca14 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -780,6 +780,35 @@ mod snapshot {
         );
     }
 
+    #[test]
+    fn build_compiler_tools_cross() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx
+                .config("build")
+                .stage(2)
+                .args(&["--set", "rust.lld=true", "--set", "rust.llvm-bitcode-linker=true"])
+                .hosts(&[TEST_TRIPLE_1])
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 0 <host> -> LldWrapper 1 <host>
+        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
+        [build] rustc 1 <host> -> std 1 <host>
+        [build] rustc 1 <host> -> rustc 2 <host>
+        [build] rustc 1 <host> -> LldWrapper 2 <host>
+        [build] rustc 2 <host> -> LlvmBitcodeLinker 3 <host>
+        [build] rustc 1 <host> -> std 1 <target1>
+        [build] rustc 2 <host> -> std 2 <target1>
+        [build] llvm <target1>
+        [build] rustc 1 <host> -> rustc 2 <target1>
+        [build] rustc 1 <host> -> LldWrapper 2 <target1>
+        [build] rustc 2 <target1> -> LlvmBitcodeLinker 3 <target1>
+        [build] rustdoc 1 <target1>
+        "
+        );
+    }
+
     #[test]
     fn build_library_no_explicit_stage() {
         let ctx = TestCtx::new();
-- 
cgit 1.4.1-3-g733a5


From c4bf37d35824cf22dade0c1c4595186a29a8714d Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Wed, 2 Jul 2025 18:10:57 +0200
Subject: Always inline InterpCx::layout_of after perf regression

---
 compiler/rustc_const_eval/src/interpret/eval_context.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_const_eval/src/interpret/eval_context.rs b/compiler/rustc_const_eval/src/interpret/eval_context.rs
index 068d6369f87..41fc8d47cd3 100644
--- a/compiler/rustc_const_eval/src/interpret/eval_context.rs
+++ b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@@ -96,7 +96,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// This inherent method takes priority over the trait method with the same name in LayoutOf,
     /// and allows wrapping the actual [LayoutOf::layout_of] with a tracing span.
     /// See [LayoutOf::layout_of] for the original documentation.
-    #[inline]
+    #[inline(always)]
     pub fn layout_of(
         &self,
         ty: Ty<'tcx>,
-- 
cgit 1.4.1-3-g733a5


From 07143afee43a4b516ca446e5e49570411043dfdb Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Sat, 5 Jul 2025 11:13:04 +0200
Subject: Replace TRACING_ENABLED with enter_trace_span()

Hopefully this will make tracing calls be optimized out properly when tracing is disabled
---
 compiler/rustc_const_eval/src/interpret/machine.rs | 20 +++++++++++--------
 compiler/rustc_const_eval/src/interpret/mod.rs     |  1 +
 compiler/rustc_const_eval/src/interpret/util.rs    | 23 +++++++++++-----------
 3 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
index 844c19fea2d..33afadd94f5 100644
--- a/compiler/rustc_const_eval/src/interpret/machine.rs
+++ b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -18,8 +18,8 @@ use rustc_target::callconv::FnAbi;
 
 use super::{
     AllocBytes, AllocId, AllocKind, AllocRange, Allocation, CTFE_ALLOC_SALT, ConstAllocation,
-    CtfeProvenance, FnArg, Frame, ImmTy, InterpCx, InterpResult, MPlaceTy, MemoryKind,
-    Misalignment, OpTy, PlaceTy, Pointer, Provenance, RangeSet, interp_ok, throw_unsup,
+    CtfeProvenance, EnteredTraceSpan, FnArg, Frame, ImmTy, InterpCx, InterpResult, MPlaceTy,
+    MemoryKind, Misalignment, OpTy, PlaceTy, Pointer, Provenance, RangeSet, interp_ok, throw_unsup,
 };
 
 /// Data returned by [`Machine::after_stack_pop`], and consumed by
@@ -147,12 +147,6 @@ pub trait Machine<'tcx>: Sized {
     /// already been checked before.
     const ALL_CONSTS_ARE_PRECHECKED: bool = true;
 
-    /// Determines whether rustc_const_eval functions that make use of the [Machine] should make
-    /// tracing calls (to the `tracing` library). By default this is `false`, meaning the tracing
-    /// calls will supposedly be optimized out. This flag is set to `true` inside Miri, to allow
-    /// tracing the interpretation steps, among other things.
-    const TRACING_ENABLED: bool = false;
-
     /// Whether memory accesses should be alignment-checked.
     fn enforce_alignment(ecx: &InterpCx<'tcx, Self>) -> bool;
 
@@ -634,6 +628,16 @@ pub trait Machine<'tcx>: Sized {
     /// Compute the value passed to the constructors of the `AllocBytes` type for
     /// abstract machine allocations.
     fn get_default_alloc_params(&self) -> <Self::Bytes as AllocBytes>::AllocParams;
+
+    /// Allows enabling/disabling tracing calls from within `rustc_const_eval` at compile time, by
+    /// delegating the entering of [tracing::Span]s to implementors of the [Machine] trait. The
+    /// default implementation corresponds to tracing being disabled, meaning the tracing calls will
+    /// supposedly be optimized out completely. To enable tracing, override this trait method and
+    /// return `span.entered()`. Also see [crate::enter_trace_span].
+    #[must_use]
+    fn enter_trace_span(_span: tracing::Span) -> impl EnteredTraceSpan {
+        ()
+    }
 }
 
 /// A lot of the flexibility above is just needed for `Miri`, but all "compile-time" machines
diff --git a/compiler/rustc_const_eval/src/interpret/mod.rs b/compiler/rustc_const_eval/src/interpret/mod.rs
index 8303f891f98..2fc372dd019 100644
--- a/compiler/rustc_const_eval/src/interpret/mod.rs
+++ b/compiler/rustc_const_eval/src/interpret/mod.rs
@@ -37,6 +37,7 @@ pub use self::place::{MPlaceTy, MemPlaceMeta, PlaceTy, Writeable};
 use self::place::{MemPlace, Place};
 pub use self::projection::{OffsetMode, Projectable};
 pub use self::stack::{Frame, FrameInfo, LocalState, ReturnContinuation, StackPopInfo};
+pub use self::util::EnteredTraceSpan;
 pub(crate) use self::util::create_static_alloc;
 pub use self::validity::{CtfeValidationMode, RangeSet, RefTracking};
 pub use self::visitor::ValueVisitor;
diff --git a/compiler/rustc_const_eval/src/interpret/util.rs b/compiler/rustc_const_eval/src/interpret/util.rs
index 99add01f95c..eeab32fd79c 100644
--- a/compiler/rustc_const_eval/src/interpret/util.rs
+++ b/compiler/rustc_const_eval/src/interpret/util.rs
@@ -46,21 +46,20 @@ pub(crate) fn create_static_alloc<'tcx>(
     interp_ok(ecx.ptr_to_mplace(Pointer::from(alloc_id).into(), layout))
 }
 
-/// This struct is needed to enforce `#[must_use]` on [tracing::span::EnteredSpan]
-/// while wrapping them in an `Option`.
-#[must_use]
-pub enum MaybeEnteredSpan {
-    Some(tracing::span::EnteredSpan),
-    None,
-}
+/// A marker trait returned by [crate::interpret::Machine::enter_trace_span], identifying either a
+/// real [tracing::span::EnteredSpan] in case tracing is enabled, or the dummy type `()` when
+/// tracing is disabled.
+pub trait EnteredTraceSpan {}
+impl EnteredTraceSpan for () {}
+impl EnteredTraceSpan for tracing::span::EnteredSpan {}
 
+/// Shortand for calling [crate::interpret::Machine::enter_trace_span] on a [tracing::info_span].
+/// This is supposed to be compiled out when [crate::interpret::Machine::enter_trace_span] has the
+/// default implementation (i.e. when it does not actually enter the span but instead returns `()`).
+/// Note: the result of this macro **must be used** because the span is exited when it's dropped.
 #[macro_export]
 macro_rules! enter_trace_span {
     ($machine:ident, $($tt:tt)*) => {
-        if $machine::TRACING_ENABLED {
-            $crate::interpret::util::MaybeEnteredSpan::Some(tracing::info_span!($($tt)*).entered())
-        } else {
-            $crate::interpret::util::MaybeEnteredSpan::None
-        }
+        $machine::enter_trace_span(tracing::info_span!($($tt)*))
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 3cacaa7d0ebd8994f521fbcfc5277f8725f9348c Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Sun, 6 Jul 2025 08:53:50 +0200
Subject: Add inline(always) to Machine::enter_trace_span

---
 compiler/rustc_const_eval/src/interpret/machine.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
index 33afadd94f5..64aa971d14e 100644
--- a/compiler/rustc_const_eval/src/interpret/machine.rs
+++ b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -635,6 +635,7 @@ pub trait Machine<'tcx>: Sized {
     /// supposedly be optimized out completely. To enable tracing, override this trait method and
     /// return `span.entered()`. Also see [crate::enter_trace_span].
     #[must_use]
+    #[inline(always)]
     fn enter_trace_span(_span: tracing::Span) -> impl EnteredTraceSpan {
         ()
     }
-- 
cgit 1.4.1-3-g733a5


From e8c8330ba1a0fb7dcf8e74a8758569ab71261ef7 Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Sun, 6 Jul 2025 08:58:19 +0200
Subject: Make enter_trace_span take a closure for better optimization

---
 compiler/rustc_const_eval/src/interpret/machine.rs | 2 +-
 compiler/rustc_const_eval/src/interpret/util.rs    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
index 64aa971d14e..d150ed69250 100644
--- a/compiler/rustc_const_eval/src/interpret/machine.rs
+++ b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -636,7 +636,7 @@ pub trait Machine<'tcx>: Sized {
     /// return `span.entered()`. Also see [crate::enter_trace_span].
     #[must_use]
     #[inline(always)]
-    fn enter_trace_span(_span: tracing::Span) -> impl EnteredTraceSpan {
+    fn enter_trace_span(_span: impl FnOnce() -> tracing::Span) -> impl EnteredTraceSpan {
         ()
     }
 }
diff --git a/compiler/rustc_const_eval/src/interpret/util.rs b/compiler/rustc_const_eval/src/interpret/util.rs
index eeab32fd79c..72650d545c3 100644
--- a/compiler/rustc_const_eval/src/interpret/util.rs
+++ b/compiler/rustc_const_eval/src/interpret/util.rs
@@ -60,6 +60,6 @@ impl EnteredTraceSpan for tracing::span::EnteredSpan {}
 #[macro_export]
 macro_rules! enter_trace_span {
     ($machine:ident, $($tt:tt)*) => {
-        $machine::enter_trace_span(tracing::info_span!($($tt)*))
+        $machine::enter_trace_span(|| tracing::info_span!($($tt)*))
     }
 }
-- 
cgit 1.4.1-3-g733a5


From e5f7d4d783c1567ddc16e02091bae8bacfca1418 Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Tue, 8 Jul 2025 15:37:01 +0200
Subject: Implement enter_trace_span() in MiriMachine

---
 src/tools/miri/src/machine.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 693b8916d89..35399dbf4cb 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1014,8 +1014,6 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
 
     const PANIC_ON_ALLOC_FAIL: bool = false;
 
-    const TRACING_ENABLED: bool = cfg!(feature = "tracing");
-
     #[inline(always)]
     fn enforce_alignment(ecx: &MiriInterpCx<'tcx>) -> bool {
         ecx.machine.check_alignment != AlignmentCheck::None
@@ -1827,6 +1825,16 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         #[cfg(not(target_os = "linux"))]
         MiriAllocParams::Global
     }
+
+    fn enter_trace_span(span: impl FnOnce() -> tracing::Span) -> impl EnteredTraceSpan {
+        #[cfg(feature = "tracing")]
+        { span().entered() }
+        #[cfg(not(feature = "tracing"))]
+        {
+            let _ = span; // so we avoid the "unused variable" warning
+            ()
+        }
+    }
 }
 
 /// Trait for callbacks handling asynchronous machine operations.
-- 
cgit 1.4.1-3-g733a5


From 543c860ea6c78e77b0a12685e066a74fe26dc301 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Thu, 3 Jul 2025 09:14:56 +0000
Subject: Constify `Fn*` traits

---
 compiler/rustc_hir_typeck/src/upvar.rs             |   6 +-
 .../rustc_trait_selection/src/traits/effects.rs    |  54 ++++++-
 library/core/src/ops/function.rs                   |  34 ++--
 tests/ui/consts/fn_trait_refs.stderr               | 175 +--------------------
 .../ui/consts/unstable-const-fn-in-libcore.stderr  |  32 +---
 tests/ui/impl-trait/normalize-tait-in-const.stderr |  32 +---
 tests/ui/traits/const-traits/call.rs               |   2 +-
 tests/ui/traits/const-traits/call.stderr           |   7 +-
 .../const-closure-parse-not-item.stderr            |  32 +---
 .../const-closure-trait-method-fail.stderr         |  33 +---
 .../const-traits/const-closure-trait-method.rs     |   5 +-
 .../const-traits/const-closure-trait-method.stderr |  30 ----
 tests/ui/traits/const-traits/const-closures.rs     |   5 +-
 tests/ui/traits/const-traits/const-closures.stderr | 103 ------------
 .../const_closure-const_trait_impl-ice-113381.rs   |   5 +-
 ...onst_closure-const_trait_impl-ice-113381.stderr |  12 +-
 .../ice-112822-expected-type-for-param.rs          |   6 +-
 .../ice-112822-expected-type-for-param.stderr      |  46 +-----
 .../ice-123664-unexpected-bound-var.rs             |   8 -
 .../ice-123664-unexpected-bound-var.stderr         |  21 ---
 .../non-const-op-const-closure-non-const-outer.rs  |   2 +-
 ...n-const-op-const-closure-non-const-outer.stderr |  10 +-
 22 files changed, 128 insertions(+), 532 deletions(-)
 delete mode 100644 tests/ui/traits/const-traits/const-closure-trait-method.stderr
 delete mode 100644 tests/ui/traits/const-traits/const-closures.stderr
 delete mode 100644 tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.rs
 delete mode 100644 tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.stderr

diff --git a/compiler/rustc_hir_typeck/src/upvar.rs b/compiler/rustc_hir_typeck/src/upvar.rs
index 982cfa2e42b..be774106abf 100644
--- a/compiler/rustc_hir_typeck/src/upvar.rs
+++ b/compiler/rustc_hir_typeck/src/upvar.rs
@@ -529,7 +529,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // process any deferred resolutions.
         let deferred_call_resolutions = self.remove_deferred_call_resolutions(closure_def_id);
         for deferred_call_resolution in deferred_call_resolutions {
-            deferred_call_resolution.resolve(self);
+            deferred_call_resolution.resolve(&mut FnCtxt::new(
+                self,
+                self.param_env,
+                closure_def_id,
+            ));
         }
     }
 
diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs
index 176d308de91..d24f861723b 100644
--- a/compiler/rustc_trait_selection/src/traits/effects.rs
+++ b/compiler/rustc_trait_selection/src/traits/effects.rs
@@ -1,7 +1,8 @@
 use rustc_hir::{self as hir, LangItem};
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes};
 use rustc_infer::traits::{
-    ImplDerivedHostCause, ImplSource, Obligation, ObligationCauseCode, PredicateObligation,
+    ImplDerivedHostCause, ImplSource, Obligation, ObligationCause, ObligationCauseCode,
+    PredicateObligation,
 };
 use rustc_middle::span_bug;
 use rustc_middle::traits::query::NoSolution;
@@ -303,6 +304,9 @@ fn evaluate_host_effect_from_builtin_impls<'tcx>(
 ) -> Result<ThinVec<PredicateObligation<'tcx>>, EvaluationFailure> {
     match selcx.tcx().as_lang_item(obligation.predicate.def_id()) {
         Some(LangItem::Destruct) => evaluate_host_effect_for_destruct_goal(selcx, obligation),
+        Some(LangItem::Fn | LangItem::FnMut | LangItem::FnOnce) => {
+            evaluate_host_effect_for_fn_goal(selcx, obligation)
+        }
         _ => Err(EvaluationFailure::NoSolution),
     }
 }
@@ -398,6 +402,54 @@ fn evaluate_host_effect_for_destruct_goal<'tcx>(
         .collect())
 }
 
+// NOTE: Keep this in sync with `extract_fn_def_from_const_callable` in the new solver.
+fn evaluate_host_effect_for_fn_goal<'tcx>(
+    selcx: &mut SelectionContext<'_, 'tcx>,
+    obligation: &HostEffectObligation<'tcx>,
+) -> Result<ThinVec<PredicateObligation<'tcx>>, EvaluationFailure> {
+    let tcx = selcx.tcx();
+    let self_ty = obligation.predicate.self_ty();
+
+    let (def, args) = match *self_ty.kind() {
+        ty::FnDef(def, args) => (def, args),
+
+        // We may support function pointers at some point in the future
+        ty::FnPtr(..) => return Err(EvaluationFailure::NoSolution),
+
+        // Coroutines could implement `[const] Fn`,
+        // but they don't really need to right now.
+        ty::Closure(..)
+        | ty::CoroutineClosure(_, _)
+        | ty::Coroutine(_, _)
+        | ty::CoroutineWitness(_, _) => {
+            return Err(EvaluationFailure::NoSolution);
+        }
+
+        // Everything else needs explicit impls or cannot have an impl
+        _ => return Err(EvaluationFailure::NoSolution),
+    };
+
+    match tcx.constness(def) {
+        hir::Constness::Const => Ok(tcx
+            .const_conditions(def)
+            .instantiate(tcx, args)
+            .into_iter()
+            .map(|(c, span)| {
+                let code = ObligationCauseCode::WhereClause(def, span);
+                let cause =
+                    ObligationCause::new(obligation.cause.span, obligation.cause.body_id, code);
+                Obligation::new(
+                    tcx,
+                    cause,
+                    obligation.param_env,
+                    c.to_host_effect_clause(tcx, obligation.predicate.constness),
+                )
+            })
+            .collect()),
+        hir::Constness::NotConst => Err(EvaluationFailure::NoSolution),
+    }
+}
+
 fn evaluate_host_effect_from_selection_candidate<'tcx>(
     selcx: &mut SelectionContext<'_, 'tcx>,
     obligation: &HostEffectObligation<'tcx>,
diff --git a/library/core/src/ops/function.rs b/library/core/src/ops/function.rs
index df48c104410..763b60d88e5 100644
--- a/library/core/src/ops/function.rs
+++ b/library/core/src/ops/function.rs
@@ -72,7 +72,8 @@ use crate::marker::Tuple;
 )]
 #[fundamental] // so that regex can rely that `&str: !FnMut`
 #[must_use = "closures are lazy and do nothing unless called"]
-// FIXME(const_trait_impl) #[const_trait]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
 pub trait Fn<Args: Tuple>: FnMut<Args> {
     /// Performs the call operation.
     #[unstable(feature = "fn_traits", issue = "29625")]
@@ -159,7 +160,8 @@ pub trait Fn<Args: Tuple>: FnMut<Args> {
 )]
 #[fundamental] // so that regex can rely that `&str: !FnMut`
 #[must_use = "closures are lazy and do nothing unless called"]
-// FIXME(const_trait_impl) #[const_trait]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
 pub trait FnMut<Args: Tuple>: FnOnce<Args> {
     /// Performs the call operation.
     #[unstable(feature = "fn_traits", issue = "29625")]
@@ -238,7 +240,8 @@ pub trait FnMut<Args: Tuple>: FnOnce<Args> {
 )]
 #[fundamental] // so that regex can rely that `&str: !FnMut`
 #[must_use = "closures are lazy and do nothing unless called"]
-// FIXME(const_trait_impl) #[const_trait]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
 pub trait FnOnce<Args: Tuple> {
     /// The returned type after the call operator is used.
     #[lang = "fn_once_output"]
@@ -254,9 +257,10 @@ mod impls {
     use crate::marker::Tuple;
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: Tuple, F: ?Sized> Fn<A> for &F
+    #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+    impl<A: Tuple, F: ?Sized> const Fn<A> for &F
     where
-        F: Fn<A>,
+        F: ~const Fn<A>,
     {
         extern "rust-call" fn call(&self, args: A) -> F::Output {
             (**self).call(args)
@@ -264,9 +268,10 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: Tuple, F: ?Sized> FnMut<A> for &F
+    #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+    impl<A: Tuple, F: ?Sized> const FnMut<A> for &F
     where
-        F: Fn<A>,
+        F: ~const Fn<A>,
     {
         extern "rust-call" fn call_mut(&mut self, args: A) -> F::Output {
             (**self).call(args)
@@ -274,9 +279,10 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: Tuple, F: ?Sized> FnOnce<A> for &F
+    #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+    impl<A: Tuple, F: ?Sized> const FnOnce<A> for &F
     where
-        F: Fn<A>,
+        F: ~const Fn<A>,
     {
         type Output = F::Output;
 
@@ -286,9 +292,10 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: Tuple, F: ?Sized> FnMut<A> for &mut F
+    #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+    impl<A: Tuple, F: ?Sized> const FnMut<A> for &mut F
     where
-        F: FnMut<A>,
+        F: ~const FnMut<A>,
     {
         extern "rust-call" fn call_mut(&mut self, args: A) -> F::Output {
             (*self).call_mut(args)
@@ -296,9 +303,10 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    impl<A: Tuple, F: ?Sized> FnOnce<A> for &mut F
+    #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+    impl<A: Tuple, F: ?Sized> const FnOnce<A> for &mut F
     where
-        F: FnMut<A>,
+        F: ~const FnMut<A>,
     {
         type Output = F::Output;
         extern "rust-call" fn call_once(self, args: A) -> F::Output {
diff --git a/tests/ui/consts/fn_trait_refs.stderr b/tests/ui/consts/fn_trait_refs.stderr
index 445dd75f824..bbe0714801c 100644
--- a/tests/ui/consts/fn_trait_refs.stderr
+++ b/tests/ui/consts/fn_trait_refs.stderr
@@ -4,151 +4,6 @@ error[E0635]: unknown feature `const_fn_trait_ref_impls`
 LL | #![feature(const_fn_trait_ref_impls)]
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:14:8
-   |
-LL |     T: [const] Fn<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:14:8
-   |
-LL |     T: [const] Fn<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:14:8
-   |
-LL |     T: [const] Fn<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:21:8
-   |
-LL |     T: [const] FnMut<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `FnMut`
-   |
-note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:21:8
-   |
-LL |     T: [const] FnMut<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `FnMut`
-   |
-note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:21:8
-   |
-LL |     T: [const] FnMut<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `FnMut`
-   |
-note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:28:8
-   |
-LL |     T: [const] FnOnce<()>,
-   |        ^^^^^^^ can't be applied to `FnOnce`
-   |
-note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:28:8
-   |
-LL |     T: [const] FnOnce<()>,
-   |        ^^^^^^^ can't be applied to `FnOnce`
-   |
-note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:28:8
-   |
-LL |     T: [const] FnOnce<()>,
-   |        ^^^^^^^ can't be applied to `FnOnce`
-   |
-note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:35:8
-   |
-LL |     T: [const] Fn<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:35:8
-   |
-LL |     T: [const] Fn<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:35:8
-   |
-LL |     T: [const] Fn<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:49:8
-   |
-LL |     T: [const] FnMut<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `FnMut`
-   |
-note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:49:8
-   |
-LL |     T: [const] FnMut<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `FnMut`
-   |
-note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/fn_trait_refs.rs:49:8
-   |
-LL |     T: [const] FnMut<()> + [const] Destruct,
-   |        ^^^^^^^ can't be applied to `FnMut`
-   |
-note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
 error[E0277]: the trait bound `(i32, i32, i32): const PartialEq` is not satisfied
   --> $DIR/fn_trait_refs.rs:71:17
    |
@@ -161,31 +16,7 @@ error[E0277]: the trait bound `(i32, i32): const PartialEq` is not satisfied
 LL |         assert!(test_two == (2, 2));
    |                 ^^^^^^^^^^^^^^^^^^
 
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/fn_trait_refs.rs:16:5
-   |
-LL |     f()
-   |     ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/fn_trait_refs.rs:23:5
-   |
-LL |     f()
-   |     ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/fn_trait_refs.rs:30:5
-   |
-LL |     f()
-   |     ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 21 previous errors
+error: aborting due to 3 previous errors
 
-Some errors have detailed explanations: E0015, E0277, E0635.
-For more information about an error, try `rustc --explain E0015`.
+Some errors have detailed explanations: E0277, E0635.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/unstable-const-fn-in-libcore.stderr b/tests/ui/consts/unstable-const-fn-in-libcore.stderr
index 95e48b7b7c8..16db7791cd8 100644
--- a/tests/ui/consts/unstable-const-fn-in-libcore.stderr
+++ b/tests/ui/consts/unstable-const-fn-in-libcore.stderr
@@ -1,30 +1,3 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/unstable-const-fn-in-libcore.rs:19:32
-   |
-LL |     const fn unwrap_or_else<F: [const] FnOnce() -> T>(self, f: F) -> T {
-   |                                ^^^^^^^ can't be applied to `FnOnce`
-   |
-note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/unstable-const-fn-in-libcore.rs:19:32
-   |
-LL |     const fn unwrap_or_else<F: [const] FnOnce() -> T>(self, f: F) -> T {
-   |                                ^^^^^^^ can't be applied to `FnOnce`
-   |
-note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/unstable-const-fn-in-libcore.rs:24:26
-   |
-LL |             Opt::None => f(),
-   |                          ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
 error[E0493]: destructor of `F` cannot be evaluated at compile-time
   --> $DIR/unstable-const-fn-in-libcore.rs:19:61
    |
@@ -43,7 +16,6 @@ LL |     const fn unwrap_or_else<F: [const] FnOnce() -> T>(self, f: F) -> T {
 LL |     }
    |     - value is dropped here
 
-error: aborting due to 5 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0015, E0493.
-For more information about an error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/impl-trait/normalize-tait-in-const.stderr b/tests/ui/impl-trait/normalize-tait-in-const.stderr
index e17737d1860..051eb62d9cb 100644
--- a/tests/ui/impl-trait/normalize-tait-in-const.stderr
+++ b/tests/ui/impl-trait/normalize-tait-in-const.stderr
@@ -1,22 +1,3 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/normalize-tait-in-const.rs:27:35
-   |
-LL | const fn with_positive<F: for<'a> [const] Fn(&'a Alias<'a>) + [const] Destruct>(fun: F) {
-   |                                   ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/normalize-tait-in-const.rs:27:35
-   |
-LL | const fn with_positive<F: for<'a> [const] Fn(&'a Alias<'a>) + [const] Destruct>(fun: F) {
-   |                                   ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
 error: unconstrained opaque type
   --> $DIR/normalize-tait-in-const.rs:14:26
    |
@@ -44,15 +25,6 @@ note: this item must have a `#[define_opaque(foo::Alias)]` attribute to be able
 LL |     pub const fn filter_positive<'a>() -> &'a Alias<'a> {
    |                  ^^^^^^^^^^^^^^^
 
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/normalize-tait-in-const.rs:28:5
-   |
-LL |     fun(filter_positive());
-   |     ^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 5 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0015, E0308.
-For more information about an error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/traits/const-traits/call.rs b/tests/ui/traits/const-traits/call.rs
index b985e3da345..b1080fe78bb 100644
--- a/tests/ui/traits/const-traits/call.rs
+++ b/tests/ui/traits/const-traits/call.rs
@@ -5,7 +5,7 @@
 
 pub const _: () = {
     assert!((const || true)());
-    //~^ ERROR cannot call non-const closure in constants
+    //~^ 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 e9bf64092f3..8e32cab6dfc 100644
--- a/tests/ui/traits/const-traits/call.stderr
+++ b/tests/ui/traits/const-traits/call.stderr
@@ -1,12 +1,9 @@
-error[E0015]: cannot call non-const closure in constants
+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)());
    |             ^^^^^^^^^^^^^^^^^
-   |
-   = 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
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0277`.
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
index fdfe3b95d55..1d8d5ff1b4f 100644
--- a/tests/ui/traits/const-traits/const-closure-parse-not-item.stderr
+++ b/tests/ui/traits/const-traits/const-closure-parse-not-item.stderr
@@ -1,31 +1,9 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closure-parse-not-item.rs:7:25
+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() {
-   |                         ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closure-parse-not-item.rs:7:25
-   |
-LL | const fn test() -> impl [const] Fn() {
-   |                         ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closure-parse-not-item.rs:7:25
-   |
-LL | const fn test() -> impl [const] Fn() {
-   |                         ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+   |                    ^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+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-trait-method-fail.stderr b/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
index 89b202b3438..fddd8d10bcc 100644
--- a/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
+++ b/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
@@ -1,30 +1,9 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closure-trait-method-fail.rs:14:32
+error[E0277]: the trait bound `(): const Tr` is not satisfied
+  --> $DIR/const-closure-trait-method-fail.rs:18:23
    |
-LL | const fn need_const_closure<T: [const] FnOnce(()) -> i32>(x: T) -> i32 {
-   |                                ^^^^^^^ can't be applied to `FnOnce`
-   |
-note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closure-trait-method-fail.rs:14:32
-   |
-LL | const fn need_const_closure<T: [const] FnOnce(()) -> i32>(x: T) -> i32 {
-   |                                ^^^^^^^ can't be applied to `FnOnce`
-   |
-note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/const-closure-trait-method-fail.rs:15:5
-   |
-LL |     x(())
-   |     ^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+LL | const _: () = assert!(need_const_closure(Tr::a) == 42);
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/const-closure-trait-method.rs b/tests/ui/traits/const-traits/const-closure-trait-method.rs
index 831d6e27946..6477aa63c68 100644
--- a/tests/ui/traits/const-traits/const-closure-trait-method.rs
+++ b/tests/ui/traits/const-traits/const-closure-trait-method.rs
@@ -1,5 +1,6 @@
-//@ known-bug: #110395
-// FIXME check-pass
+//@ check-pass
+//@ revisions: next old
+//@[next] compile-flags: -Znext-solver
 #![feature(const_trait_impl)]
 
 #[const_trait]
diff --git a/tests/ui/traits/const-traits/const-closure-trait-method.stderr b/tests/ui/traits/const-traits/const-closure-trait-method.stderr
deleted file mode 100644
index 6de25dc11ef..00000000000
--- a/tests/ui/traits/const-traits/const-closure-trait-method.stderr
+++ /dev/null
@@ -1,30 +0,0 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closure-trait-method.rs:14:32
-   |
-LL | const fn need_const_closure<T: [const] FnOnce(()) -> i32>(x: T) -> i32 {
-   |                                ^^^^^^^ can't be applied to `FnOnce`
-   |
-note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closure-trait-method.rs:14:32
-   |
-LL | const fn need_const_closure<T: [const] FnOnce(()) -> i32>(x: T) -> i32 {
-   |                                ^^^^^^^ can't be applied to `FnOnce`
-   |
-note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/const-closure-trait-method.rs:15:5
-   |
-LL |     x(())
-   |     ^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/traits/const-traits/const-closures.rs b/tests/ui/traits/const-traits/const-closures.rs
index 2f6f4dc4ba3..8f1c018ca5d 100644
--- a/tests/ui/traits/const-traits/const-closures.rs
+++ b/tests/ui/traits/const-traits/const-closures.rs
@@ -1,5 +1,6 @@
-//@ known-bug: #110395
-// FIXME check-pass
+//@ check-pass
+//@ revisions: next old
+//@[next] compile-flags: -Znext-solver
 
 #![feature(const_trait_impl)]
 
diff --git a/tests/ui/traits/const-traits/const-closures.stderr b/tests/ui/traits/const-traits/const-closures.stderr
deleted file mode 100644
index 19869b47085..00000000000
--- a/tests/ui/traits/const-traits/const-closures.stderr
+++ /dev/null
@@ -1,103 +0,0 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closures.rs:8:12
-   |
-LL |         F: [const] FnOnce() -> u8,
-   |            ^^^^^^^ can't be applied to `FnOnce`
-   |
-note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closures.rs:9:12
-   |
-LL |         F: [const] FnMut() -> u8,
-   |            ^^^^^^^ can't be applied to `FnMut`
-   |
-note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closures.rs:10:12
-   |
-LL |         F: [const] Fn() -> u8,
-   |            ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closures.rs:8:12
-   |
-LL |         F: [const] FnOnce() -> u8,
-   |            ^^^^^^^ can't be applied to `FnOnce`
-   |
-note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closures.rs:9:12
-   |
-LL |         F: [const] FnMut() -> u8,
-   |            ^^^^^^^ can't be applied to `FnMut`
-   |
-note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closures.rs:10:12
-   |
-LL |         F: [const] Fn() -> u8,
-   |            ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closures.rs:23:20
-   |
-LL | const fn answer<F: [const] Fn() -> u8>(f: &F) -> u8 {
-   |                    ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-closures.rs:23:20
-   |
-LL | const fn answer<F: [const] Fn() -> u8>(f: &F) -> u8 {
-   |                    ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/const-closures.rs:24:5
-   |
-LL |     f() + f()
-   |     ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/const-closures.rs:24:11
-   |
-LL |     f() + f()
-   |           ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: cannot call non-const closure in constant functions
-  --> $DIR/const-closures.rs:12:5
-   |
-LL |     f() * 7
-   |     ^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 11 previous errors
-
-For more information about this error, try `rustc --explain E0015`.
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 92427039b43..30002038f68 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,3 +1,4 @@
+//@ known-bug: #110395
 //@ compile-flags: -Znext-solver
 #![feature(const_closures, const_trait_impl)]
 #![allow(incomplete_features)]
@@ -11,7 +12,7 @@ impl Foo for () {
 }
 
 fn main() {
-    (const || { (()).foo() })();
-    //~^ ERROR: cannot call non-const method `<() as Foo>::foo` in constant functions
+    (const || (()).foo())();
+    // ^ ERROR: cannot call non-const method `<() as Foo>::foo` in constant functions
     // FIXME(const_trait_impl) this should probably say constant closures
 }
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 c08642ba5a3..dab3f14161f 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,11 +1,9 @@
-error[E0015]: cannot call non-const method `<() as Foo>::foo` in constant functions
-  --> $DIR/const_closure-const_trait_impl-ice-113381.rs:14:22
+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
    |
-LL |     (const || { (()).foo() })();
-   |                      ^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+LL |     (const || (()).foo())();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0277`.
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 026f2c0d603..8ee3db445d0 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,16 +1,14 @@
 #![feature(const_trait_impl)]
 
 const fn test() -> impl [const] Fn() {
-    //~^ ERROR `[const]` can only be applied to `#[const_trait]` traits
-    //~| ERROR `[const]` can only be applied to `#[const_trait]` traits
-    //~| ERROR `[const]` can only be applied to `#[const_trait]` traits
+    //~^ ERROR: }: [const] Fn()` is not satisfied
     const move || { //~ ERROR const closures are experimental
         let sl: &[u8] = b"foo";
 
         match sl {
             [first, remainder @ ..] => {
                 assert_eq!(first, &b'f');
-                //~^ ERROR cannot call non-const function
+                // FIXME(const_closures) ^ 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 78d7b962cc4..abbe0a0070a 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[E0658]: const closures are experimental
-  --> $DIR/ice-112822-expected-type-for-param.rs:7:5
+  --> $DIR/ice-112822-expected-type-for-param.rs:5:5
    |
 LL |     const move || {
    |     ^^^^^
@@ -8,45 +8,13 @@ LL |     const move || {
    = 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: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/ice-112822-expected-type-for-param.rs:3:25
+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
    |
 LL | const fn test() -> impl [const] Fn() {
-   |                         ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/ice-112822-expected-type-for-param.rs:3:25
-   |
-LL | const fn test() -> impl [const] Fn() {
-   |                         ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/ice-112822-expected-type-for-param.rs:3:25
-   |
-LL | const fn test() -> impl [const] Fn() {
-   |                         ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0015]: cannot call non-const function `core::panicking::assert_failed::<&u8, &u8>` in constant functions
-  --> $DIR/ice-112822-expected-type-for-param.rs:12:17
-   |
-LL |                 assert_eq!(first, &b'f');
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: this error originates in the macro `assert_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
+   |                    ^^^^^^^^^^^^^^^^^
 
-error: aborting due to 5 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0015, E0658.
-For more information about an error, try `rustc --explain E0015`.
+Some errors have detailed explanations: E0277, E0658.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.rs b/tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.rs
deleted file mode 100644
index f1dbd947161..00000000000
--- a/tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![allow(incomplete_features)]
-#![feature(generic_const_exprs, const_trait_impl)]
-
-const fn with_positive<F: [const] Fn()>() {}
-//~^ ERROR `[const]` can only be applied to `#[const_trait]` traits
-//~| ERROR `[const]` can only be applied to `#[const_trait]` traits
-
-pub fn main() {}
diff --git a/tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.stderr b/tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.stderr
deleted file mode 100644
index 1eccb16b46e..00000000000
--- a/tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.stderr
+++ /dev/null
@@ -1,21 +0,0 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/ice-123664-unexpected-bound-var.rs:4:27
-   |
-LL | const fn with_positive<F: [const] Fn()>() {}
-   |                           ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/ice-123664-unexpected-bound-var.rs:4:27
-   |
-LL | const fn with_positive<F: [const] Fn()>() {}
-   |                           ^^^^^^^ can't be applied to `Fn`
-   |
-note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/ops/function.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 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 fa0f7869644..d0470fa3458 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
@@ -11,5 +11,5 @@ impl Foo for () {
 
 fn main() {
     (const || { (()).foo() })();
-    //~^ ERROR: cannot call non-const method
+    //~^ ERROR: }: [const] Fn()` is not satisfied
 }
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 2d33406c222..dcf65ab6940 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,11 +1,9 @@
-error[E0015]: cannot call non-const method `<() as Foo>::foo` in constant functions
-  --> $DIR/non-const-op-const-closure-non-const-outer.rs:13:22
+error[E0277]: the trait bound `{closure@$DIR/non-const-op-const-closure-non-const-outer.rs:13:6: 13:14}: [const] Fn()` is not satisfied
+  --> $DIR/non-const-op-const-closure-non-const-outer.rs:13:5
    |
 LL |     (const || { (()).foo() })();
-   |                      ^^^^^
-   |
-   = 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 E0015`.
+For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 29b75a6b34c966524b81e6137b2f868a1006722f Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 7 Jul 2025 17:02:59 +0200
Subject: Fix weird rustdoc output when single and glob reexport conflict on a
 name

---
 src/librustdoc/clean/inline.rs | 10 +++++--
 src/librustdoc/clean/mod.rs    | 50 +++++++++++++++++++--------------
 src/librustdoc/visit_ast.rs    | 64 +++++++++++++++++++++++++++++++-----------
 3 files changed, 84 insertions(+), 40 deletions(-)

diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index 96199cb972a..37b012d6d0d 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -152,8 +152,14 @@ pub(crate) fn try_inline(
     };
 
     cx.inlined.insert(did.into());
-    let mut item =
-        crate::clean::generate_item_with_correct_attrs(cx, kind, did, name, import_def_id, None);
+    let mut item = crate::clean::generate_item_with_correct_attrs(
+        cx,
+        kind,
+        did,
+        name,
+        import_def_id.as_slice(),
+        None,
+    );
     // The visibility needs to reflect the one from the reexport and not from the "source" DefId.
     item.inner.inline_stmt_id = import_def_id;
     ret.push(item);
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index c2f3da18cd3..e6f7aef02c0 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -94,12 +94,12 @@ pub(crate) fn clean_doc_module<'tcx>(doc: &DocModule<'tcx>, cx: &mut DocContext<
     // This covers the case where somebody does an import which should pull in an item,
     // but there's already an item with the same namespace and same name. Rust gives
     // priority to the not-imported one, so we should, too.
-    items.extend(doc.items.values().flat_map(|(item, renamed, import_id)| {
+    items.extend(doc.items.values().flat_map(|(item, renamed, import_ids)| {
         // First, lower everything other than glob imports.
         if matches!(item.kind, hir::ItemKind::Use(_, hir::UseKind::Glob)) {
             return Vec::new();
         }
-        let v = clean_maybe_renamed_item(cx, item, *renamed, *import_id);
+        let v = clean_maybe_renamed_item(cx, item, *renamed, import_ids);
         for item in &v {
             if let Some(name) = item.name
                 && (cx.render_options.document_hidden || !item.is_doc_hidden())
@@ -162,7 +162,7 @@ pub(crate) fn clean_doc_module<'tcx>(doc: &DocModule<'tcx>, cx: &mut DocContext<
         kind,
         doc.def_id.to_def_id(),
         doc.name,
-        doc.import_id,
+        doc.import_id.as_slice(),
         doc.renamed,
     )
 }
@@ -182,22 +182,29 @@ fn generate_item_with_correct_attrs(
     kind: ItemKind,
     def_id: DefId,
     name: Symbol,
-    import_id: Option<LocalDefId>,
+    import_ids: &[LocalDefId],
     renamed: Option<Symbol>,
 ) -> Item {
     let target_attrs = inline::load_attrs(cx, def_id);
-    let attrs = if let Some(import_id) = import_id {
-        // glob reexports are treated the same as `#[doc(inline)]` items.
-        //
-        // For glob re-exports the item may or may not exist to be re-exported (potentially the cfgs
-        // on the path up until the glob can be removed, and only cfgs on the globbed item itself
-        // matter), for non-inlined re-exports see #85043.
-        let is_inline = hir_attr_lists(inline::load_attrs(cx, import_id.to_def_id()), sym::doc)
-            .get_word_attr(sym::inline)
-            .is_some()
-            || (is_glob_import(cx.tcx, import_id)
-                && (cx.render_options.document_hidden || !cx.tcx.is_doc_hidden(def_id)));
-        let mut attrs = get_all_import_attributes(cx, import_id, def_id, is_inline);
+    let attrs = if !import_ids.is_empty() {
+        let mut attrs = Vec::with_capacity(import_ids.len());
+        let mut is_inline = false;
+
+        for import_id in import_ids.iter().copied() {
+            // glob reexports are treated the same as `#[doc(inline)]` items.
+            //
+            // For glob re-exports the item may or may not exist to be re-exported (potentially the
+            // cfgs on the path up until the glob can be removed, and only cfgs on the globbed item
+            // itself matter), for non-inlined re-exports see #85043.
+            let import_is_inline =
+                hir_attr_lists(inline::load_attrs(cx, import_id.to_def_id()), sym::doc)
+                    .get_word_attr(sym::inline)
+                    .is_some()
+                    || (is_glob_import(cx.tcx, import_id)
+                        && (cx.render_options.document_hidden || !cx.tcx.is_doc_hidden(def_id)));
+            attrs.extend(get_all_import_attributes(cx, import_id, def_id, is_inline));
+            is_inline = is_inline || import_is_inline;
+        }
         add_without_unwanted_attributes(&mut attrs, target_attrs, is_inline, None);
         attrs
     } else {
@@ -216,7 +223,8 @@ fn generate_item_with_correct_attrs(
 
     let name = renamed.or(Some(name));
     let mut item = Item::from_def_id_and_attrs_and_parts(def_id, name, kind, attrs, cfg);
-    item.inner.inline_stmt_id = import_id;
+    // FIXME (GuillaumeGomez): Should we also make `inline_stmt_id` a `Vec` instead of an `Option`?
+    item.inner.inline_stmt_id = import_ids.first().copied();
     item
 }
 
@@ -2754,7 +2762,7 @@ fn clean_maybe_renamed_item<'tcx>(
     cx: &mut DocContext<'tcx>,
     item: &hir::Item<'tcx>,
     renamed: Option<Symbol>,
-    import_id: Option<LocalDefId>,
+    import_ids: &[LocalDefId],
 ) -> Vec<Item> {
     use hir::ItemKind;
     fn get_name(
@@ -2825,7 +2833,7 @@ fn clean_maybe_renamed_item<'tcx>(
                     })),
                     item.owner_id.def_id.to_def_id(),
                     name,
-                    import_id,
+                    import_ids,
                     renamed,
                 ));
                 return ret;
@@ -2880,7 +2888,7 @@ fn clean_maybe_renamed_item<'tcx>(
             kind,
             item.owner_id.def_id.to_def_id(),
             name,
-            import_id,
+            import_ids,
             renamed,
         )]
     })
@@ -3151,7 +3159,7 @@ fn clean_maybe_renamed_foreign_item<'tcx>(
             kind,
             item.owner_id.def_id.to_def_id(),
             item.ident.name,
-            import_id,
+            import_id.as_slice(),
             renamed,
         )
     })
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index 2889bfae7b0..2784d7c761a 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -32,11 +32,29 @@ pub(crate) struct Module<'hir> {
     pub(crate) def_id: LocalDefId,
     pub(crate) renamed: Option<Symbol>,
     pub(crate) import_id: Option<LocalDefId>,
-    /// The key is the item `ItemId` and the value is: (item, renamed, import_id).
+    /// The key is the item `ItemId` and the value is: (item, renamed, Vec<import_id>).
     /// We use `FxIndexMap` to keep the insert order.
+    ///
+    /// `import_id` needs to be a `Vec` because we live in a dark world where you can have code
+    /// like:
+    ///
+    /// ```
+    /// mod raw {
+    ///     pub fn foo() {}
+    /// }
+    ///
+    /// /// Foobar
+    /// pub use raw::foo;
+    ///
+    /// pub use raw::*;
+    /// ```
+    ///
+    /// So in this case, we don't want to have two items but just one with attributes from all
+    /// non-glob imports to be merged. Glob imports attributes are always ignored, whether they're
+    /// shadowed or not.
     pub(crate) items: FxIndexMap<
         (LocalDefId, Option<Symbol>),
-        (&'hir hir::Item<'hir>, Option<Symbol>, Option<LocalDefId>),
+        (&'hir hir::Item<'hir>, Option<Symbol>, Vec<LocalDefId>),
     >,
 
     /// (def_id, renamed) -> (res, local_import_id)
@@ -154,7 +172,9 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             {
                 let item = self.cx.tcx.hir_expect_item(local_def_id);
                 let (ident, _, _) = item.expect_macro();
-                top_level_module.items.insert((local_def_id, Some(ident.name)), (item, None, None));
+                top_level_module
+                    .items
+                    .insert((local_def_id, Some(ident.name)), (item, None, Vec::new()));
             }
         }
 
@@ -236,7 +256,6 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
     ) -> bool {
         debug!("maybe_inline_local (renamed: {renamed:?}) res: {res:?}");
 
-        let glob = renamed.is_none();
         if renamed == Some(kw::Underscore) {
             // We never inline `_` reexports.
             return false;
@@ -261,6 +280,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             return false;
         }
 
+        let is_glob = renamed.is_none();
         let is_hidden = !document_hidden && tcx.is_doc_hidden(ori_res_did);
         let Some(res_did) = ori_res_did.as_local() else {
             // For cross-crate impl inlining we need to know whether items are
@@ -268,7 +288,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             // made reachable by cross-crate inlining which we're checking here.
             // (this is done here because we need to know this upfront).
             crate::visit_lib::lib_embargo_visit_item(self.cx, ori_res_did);
-            if is_hidden || glob {
+            if is_hidden || is_glob {
                 return false;
             }
             // We store inlined foreign items otherwise, it'd mean that the `use` item would be kept
@@ -316,10 +336,10 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             // Bang macros are handled a bit on their because of how they are handled by the
             // compiler. If they have `#[doc(hidden)]` and the re-export doesn't have
             // `#[doc(inline)]`, then we don't inline it.
-            Node::Item(_) if is_bang_macro && !please_inline && renamed.is_some() && is_hidden => {
+            Node::Item(_) if is_bang_macro && !please_inline && !is_glob && is_hidden => {
                 return false;
             }
-            Node::Item(&hir::Item { kind: hir::ItemKind::Mod(_, m), .. }) if glob => {
+            Node::Item(&hir::Item { kind: hir::ItemKind::Mod(_, m), .. }) if is_glob => {
                 let prev = mem::replace(&mut self.inlining, true);
                 for &i in m.item_ids {
                     let i = tcx.hir_item(i);
@@ -328,13 +348,13 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
                 self.inlining = prev;
                 true
             }
-            Node::Item(it) if !glob => {
+            Node::Item(it) if !is_glob => {
                 let prev = mem::replace(&mut self.inlining, true);
                 self.visit_item_inner(it, renamed, Some(def_id));
                 self.inlining = prev;
                 true
             }
-            Node::ForeignItem(it) if !glob => {
+            Node::ForeignItem(it) if !is_glob => {
                 let prev = mem::replace(&mut self.inlining, true);
                 self.visit_foreign_item_inner(it, renamed, Some(def_id));
                 self.inlining = prev;
@@ -378,8 +398,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
     fn add_to_current_mod(
         &mut self,
         item: &'tcx hir::Item<'_>,
-        renamed: Option<Symbol>,
-        parent_id: Option<LocalDefId>,
+        mut renamed: Option<Symbol>,
+        import_id: Option<LocalDefId>,
     ) {
         if self.is_importable_from_parent
             // If we're inside an item, only impl blocks and `macro_rules!` with the `macro_export`
@@ -392,11 +412,21 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
                 _ => false,
             }
         {
-            self.modules
-                .last_mut()
-                .unwrap()
-                .items
-                .insert((item.owner_id.def_id, renamed), (item, renamed, parent_id));
+            if renamed == item.kind.ident().map(|ident| ident.name) {
+                renamed = None;
+            }
+            let key = (item.owner_id.def_id, renamed);
+            if let Some(import_id) = import_id {
+                self.modules
+                    .last_mut()
+                    .unwrap()
+                    .items
+                    .entry(key)
+                    .and_modify(|v| v.2.push(import_id))
+                    .or_insert_with(|| (item, renamed, vec![import_id]));
+            } else {
+                self.modules.last_mut().unwrap().items.insert(key, (item, renamed, Vec::new()));
+            }
         }
     }
 
@@ -468,7 +498,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
                             _ => false,
                         });
                         let ident = match kind {
-                            hir::UseKind::Single(ident) => Some(renamed.unwrap_or(ident.name)),
+                            hir::UseKind::Single(ident) => Some(ident.name),
                             hir::UseKind::Glob => None,
                             hir::UseKind::ListStem => unreachable!(),
                         };
-- 
cgit 1.4.1-3-g733a5


From b1d45f6b3e672cee544e6ff197a9f21022026871 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Tue, 8 Jul 2025 15:41:13 +0000
Subject: Remove `const_eval_select` hack

---
 compiler/rustc_hir_typeck/messages.ftl             |  7 ---
 compiler/rustc_hir_typeck/src/callee.rs            | 23 ---------
 compiler/rustc_hir_typeck/src/errors.rs            | 18 -------
 .../rustc_trait_selection/src/traits/effects.rs    |  7 +--
 library/core/src/intrinsics/mod.rs                 |  2 +-
 tests/ui/intrinsics/const-eval-select-bad.rs       |  7 +--
 tests/ui/intrinsics/const-eval-select-bad.stderr   | 58 +++++++---------------
 7 files changed, 23 insertions(+), 99 deletions(-)

diff --git a/compiler/rustc_hir_typeck/messages.ftl b/compiler/rustc_hir_typeck/messages.ftl
index c21b16c9f9f..bac4d70103c 100644
--- a/compiler/rustc_hir_typeck/messages.ftl
+++ b/compiler/rustc_hir_typeck/messages.ftl
@@ -82,13 +82,6 @@ hir_typeck_cast_unknown_pointer = cannot cast {$to ->
 hir_typeck_const_continue_bad_label =
     `#[const_continue]` must break to a labeled block that participates in a `#[loop_match]`
 
-hir_typeck_const_select_must_be_const = this argument must be a `const fn`
-    .help = consult the documentation on `const_eval_select` for more information
-
-hir_typeck_const_select_must_be_fn = this argument must be a function item
-    .note = expected a function item, found {$ty}
-    .help = consult the documentation on `const_eval_select` for more information
-
 hir_typeck_continue_labeled_block =
     `continue` pointing to a labeled block
     .label = labeled blocks cannot be `continue`'d
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
index 7611f8ac3e1..48bb45de53e 100644
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -578,29 +578,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
 
-        if let Some(def_id) = def_id
-            && self.tcx.def_kind(def_id) == hir::def::DefKind::Fn
-            && self.tcx.is_intrinsic(def_id, sym::const_eval_select)
-        {
-            let fn_sig = self.resolve_vars_if_possible(fn_sig);
-            for idx in 0..=1 {
-                let arg_ty = fn_sig.inputs()[idx + 1];
-                let span = arg_exprs.get(idx + 1).map_or(call_expr.span, |arg| arg.span);
-                // Check that second and third argument of `const_eval_select` must be `FnDef`, and additionally that
-                // the second argument must be `const fn`. The first argument must be a tuple, but this is already expressed
-                // in the function signature (`F: FnOnce<ARG>`), so I did not bother to add another check here.
-                //
-                // This check is here because there is currently no way to express a trait bound for `FnDef` types only.
-                if let ty::FnDef(def_id, _args) = *arg_ty.kind() {
-                    if idx == 0 && !self.tcx.is_const_fn(def_id) {
-                        self.dcx().emit_err(errors::ConstSelectMustBeConst { span });
-                    }
-                } else {
-                    self.dcx().emit_err(errors::ConstSelectMustBeFn { span, ty: arg_ty });
-                }
-            }
-        }
-
         fn_sig.output()
     }
 
diff --git a/compiler/rustc_hir_typeck/src/errors.rs b/compiler/rustc_hir_typeck/src/errors.rs
index 3606c778fc4..a8bb6956f10 100644
--- a/compiler/rustc_hir_typeck/src/errors.rs
+++ b/compiler/rustc_hir_typeck/src/errors.rs
@@ -605,24 +605,6 @@ impl Subdiagnostic for RemoveSemiForCoerce {
     }
 }
 
-#[derive(Diagnostic)]
-#[diag(hir_typeck_const_select_must_be_const)]
-#[help]
-pub(crate) struct ConstSelectMustBeConst {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(Diagnostic)]
-#[diag(hir_typeck_const_select_must_be_fn)]
-#[note]
-#[help]
-pub(crate) struct ConstSelectMustBeFn<'a> {
-    #[primary_span]
-    pub span: Span,
-    pub ty: Ty<'a>,
-}
-
 #[derive(Diagnostic)]
 #[diag(hir_typeck_union_pat_multiple_fields)]
 pub(crate) struct UnionPatMultipleFields {
diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs
index d24f861723b..d694a092853 100644
--- a/compiler/rustc_trait_selection/src/traits/effects.rs
+++ b/compiler/rustc_trait_selection/src/traits/effects.rs
@@ -416,12 +416,9 @@ 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),
 
-        // Coroutines could implement `[const] Fn`,
+        // Closures could implement `[const] Fn`,
         // but they don't really need to right now.
-        ty::Closure(..)
-        | ty::CoroutineClosure(_, _)
-        | ty::Coroutine(_, _)
-        | ty::CoroutineWitness(_, _) => {
+        ty::Closure(..) | ty::CoroutineClosure(_, _) => {
             return Err(EvaluationFailure::NoSolution);
         }
 
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 791d10eda6d..1ac0c7ff89b 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2279,7 +2279,7 @@ pub const fn const_eval_select<ARG: Tuple, F, G, RET>(
 ) -> RET
 where
     G: FnOnce<ARG, Output = RET>,
-    F: FnOnce<ARG, Output = RET>;
+    F: const FnOnce<ARG, Output = RET>;
 
 /// A macro to make it easier to invoke const_eval_select. Use as follows:
 /// ```rust,ignore (just a macro example)
diff --git a/tests/ui/intrinsics/const-eval-select-bad.rs b/tests/ui/intrinsics/const-eval-select-bad.rs
index 3365d57af7c..f4071251299 100644
--- a/tests/ui/intrinsics/const-eval-select-bad.rs
+++ b/tests/ui/intrinsics/const-eval-select-bad.rs
@@ -5,13 +5,10 @@ use std::intrinsics::const_eval_select;
 
 const fn not_fn_items() {
     const_eval_select((), || {}, || {});
-    //~^ ERROR this argument must be a function item
-    //~| ERROR this argument must be a function item
+    //~^ ERROR const FnOnce()` is not satisfied
     const_eval_select((), 42, 0xDEADBEEF);
     //~^ ERROR expected a `FnOnce()` closure
     //~| ERROR expected a `FnOnce()` closure
-    //~| ERROR this argument must be a function item
-    //~| ERROR this argument must be a function item
 }
 
 const fn foo(n: i32) -> i32 {
@@ -40,7 +37,7 @@ const fn args_ty_mismatch() {
 
 const fn non_const_fn() {
     const_eval_select((1,), bar, bar);
-    //~^ ERROR this argument must be a `const fn`
+    //~^ ERROR the trait bound `fn(i32) -> bool {bar}: const FnOnce(i32)` is not satisfied
 }
 
 fn main() {}
diff --git a/tests/ui/intrinsics/const-eval-select-bad.stderr b/tests/ui/intrinsics/const-eval-select-bad.stderr
index bb159bed282..d701f5ea909 100644
--- a/tests/ui/intrinsics/const-eval-select-bad.stderr
+++ b/tests/ui/intrinsics/const-eval-select-bad.stderr
@@ -1,23 +1,16 @@
-error: this argument must be a function item
+error[E0277]: the trait bound `{closure@$DIR/const-eval-select-bad.rs:7:27: 7:29}: const FnOnce()` is not satisfied
   --> $DIR/const-eval-select-bad.rs:7:27
    |
 LL |     const_eval_select((), || {}, || {});
-   |                           ^^^^^
-   |
-   = note: expected a function item, found {closure@$DIR/const-eval-select-bad.rs:7:27: 7:29}
-   = help: consult the documentation on `const_eval_select` for more information
-
-error: this argument must be a function item
-  --> $DIR/const-eval-select-bad.rs:7:34
-   |
-LL |     const_eval_select((), || {}, || {});
-   |                                  ^^^^^
+   |     -----------------     ^^^^^
+   |     |
+   |     required by a bound introduced by this call
    |
-   = note: expected a function item, found {closure@$DIR/const-eval-select-bad.rs:7:34: 7:36}
-   = help: consult the documentation on `const_eval_select` for more information
+note: required by a bound in `const_eval_select`
+  --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
 
 error[E0277]: expected a `FnOnce()` closure, found `{integer}`
-  --> $DIR/const-eval-select-bad.rs:10:27
+  --> $DIR/const-eval-select-bad.rs:9:27
    |
 LL |     const_eval_select((), 42, 0xDEADBEEF);
    |     -----------------     ^^ expected an `FnOnce()` closure, found `{integer}`
@@ -30,7 +23,7 @@ note: required by a bound in `const_eval_select`
   --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
 
 error[E0277]: expected a `FnOnce()` closure, found `{integer}`
-  --> $DIR/const-eval-select-bad.rs:10:31
+  --> $DIR/const-eval-select-bad.rs:9:31
    |
 LL |     const_eval_select((), 42, 0xDEADBEEF);
    |     -----------------         ^^^^^^^^^^ expected an `FnOnce()` closure, found `{integer}`
@@ -42,26 +35,8 @@ LL |     const_eval_select((), 42, 0xDEADBEEF);
 note: required by a bound in `const_eval_select`
   --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
 
-error: this argument must be a function item
-  --> $DIR/const-eval-select-bad.rs:10:27
-   |
-LL |     const_eval_select((), 42, 0xDEADBEEF);
-   |                           ^^
-   |
-   = note: expected a function item, found {integer}
-   = help: consult the documentation on `const_eval_select` for more information
-
-error: this argument must be a function item
-  --> $DIR/const-eval-select-bad.rs:10:31
-   |
-LL |     const_eval_select((), 42, 0xDEADBEEF);
-   |                               ^^^^^^^^^^
-   |
-   = note: expected a function item, found {integer}
-   = help: consult the documentation on `const_eval_select` for more information
-
 error[E0271]: expected `bar` to return `i32`, but it returns `bool`
-  --> $DIR/const-eval-select-bad.rs:32:34
+  --> $DIR/const-eval-select-bad.rs:29:34
    |
 LL |     const_eval_select((1,), foo, bar);
    |     -----------------            ^^^ expected `i32`, found `bool`
@@ -72,7 +47,7 @@ note: required by a bound in `const_eval_select`
   --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
 
 error[E0631]: type mismatch in function arguments
-  --> $DIR/const-eval-select-bad.rs:37:32
+  --> $DIR/const-eval-select-bad.rs:34:32
    |
 LL | const fn foo(n: i32) -> i32 {
    | --------------------------- found signature defined here
@@ -91,15 +66,18 @@ help: consider wrapping the function in a closure
 LL |     const_eval_select((true,), |arg0: bool| foo(/* i32 */), baz);
    |                                ++++++++++++    +++++++++++
 
-error: this argument must be a `const fn`
-  --> $DIR/const-eval-select-bad.rs:42:29
+error[E0277]: the trait bound `fn(i32) -> bool {bar}: const FnOnce(i32)` is not satisfied
+  --> $DIR/const-eval-select-bad.rs:39:29
    |
 LL |     const_eval_select((1,), bar, bar);
-   |                             ^^^
+   |     -----------------       ^^^
+   |     |
+   |     required by a bound introduced by this call
    |
-   = help: consult the documentation on `const_eval_select` for more information
+note: required by a bound in `const_eval_select`
+  --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
 
-error: aborting due to 9 previous errors
+error: aborting due to 6 previous errors
 
 Some errors have detailed explanations: E0271, E0277, E0631.
 For more information about an error, try `rustc --explain E0271`.
-- 
cgit 1.4.1-3-g733a5


From 5834bda8be6a8cd6019985266b67b308b85af712 Mon Sep 17 00:00:00 2001
From: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
Date: Tue, 8 Jul 2025 16:12:58 +0900
Subject: Migrate `pull_assignment_up` assist to `SyntaxEditor`

Signed-off-by: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
---
 .../src/handlers/generate_getter_or_setter.rs      |  2 +-
 .../ide-assists/src/handlers/pull_assignment_up.rs | 69 ++++++++++++++--------
 .../rust-analyzer/crates/syntax/src/ast/make.rs    |  2 +-
 .../syntax/src/ast/syntax_factory/constructors.rs  | 13 ++++
 4 files changed, 59 insertions(+), 27 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 c7e5e41aac4..20ee9253d37 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
@@ -294,7 +294,7 @@ fn generate_setter_from_info(info: &AssistInfo, record_field_info: &RecordFieldI
     let self_expr = make::ext::expr_self();
     let lhs = make::expr_field(self_expr, field_name);
     let rhs = make::expr_path(make::ext::ident_path(field_name));
-    let assign_stmt = make::expr_stmt(make::expr_assignment(lhs, rhs));
+    let assign_stmt = make::expr_stmt(make::expr_assignment(lhs, rhs).into());
     let body = make::block_expr([assign_stmt.into()], None);
 
     // Make the setter fn
diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/pull_assignment_up.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/pull_assignment_up.rs
index 5f626d29571..1b0c3139353 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/pull_assignment_up.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/pull_assignment_up.rs
@@ -1,7 +1,8 @@
 use syntax::{
     AstNode,
-    ast::{self, make},
-    ted,
+    algo::find_node_at_range,
+    ast::{self, syntax_factory::SyntaxFactory},
+    syntax_editor::SyntaxEditor,
 };
 
 use crate::{
@@ -66,33 +67,51 @@ pub(crate) fn pull_assignment_up(acc: &mut Assists, ctx: &AssistContext<'_>) ->
             return None;
         }
     }
-
+    let target = tgt.syntax().text_range();
+
+    let edit_tgt = tgt.syntax().clone_subtree();
+    let assignments: Vec<_> = collector
+        .assignments
+        .into_iter()
+        .filter_map(|(stmt, rhs)| {
+            Some((
+                find_node_at_range::<ast::BinExpr>(
+                    &edit_tgt,
+                    stmt.syntax().text_range() - target.start(),
+                )?,
+                find_node_at_range::<ast::Expr>(
+                    &edit_tgt,
+                    rhs.syntax().text_range() - target.start(),
+                )?,
+            ))
+        })
+        .collect();
+
+    let mut editor = SyntaxEditor::new(edit_tgt);
+    for (stmt, rhs) in assignments {
+        let mut stmt = stmt.syntax().clone();
+        if let Some(parent) = stmt.parent() {
+            if ast::ExprStmt::cast(parent.clone()).is_some() {
+                stmt = parent.clone();
+            }
+        }
+        editor.replace(stmt, rhs.syntax());
+    }
+    let new_tgt_root = editor.finish().new_root().clone();
+    let new_tgt = ast::Expr::cast(new_tgt_root)?;
     acc.add(
         AssistId::refactor_extract("pull_assignment_up"),
         "Pull assignment up",
-        tgt.syntax().text_range(),
+        target,
         move |edit| {
-            let assignments: Vec<_> = collector
-                .assignments
-                .into_iter()
-                .map(|(stmt, rhs)| (edit.make_mut(stmt), rhs.clone_for_update()))
-                .collect();
-
-            let tgt = edit.make_mut(tgt);
-
-            for (stmt, rhs) in assignments {
-                let mut stmt = stmt.syntax().clone();
-                if let Some(parent) = stmt.parent() {
-                    if ast::ExprStmt::cast(parent.clone()).is_some() {
-                        stmt = parent.clone();
-                    }
-                }
-                ted::replace(stmt, rhs.syntax());
-            }
-            let assign_expr = make::expr_assignment(collector.common_lhs, tgt.clone());
-            let assign_stmt = make::expr_stmt(assign_expr);
-
-            ted::replace(tgt.syntax(), assign_stmt.syntax().clone_for_update());
+            let make = SyntaxFactory::with_mappings();
+            let mut editor = edit.make_editor(tgt.syntax());
+            let assign_expr = make.expr_assignment(collector.common_lhs, new_tgt.clone());
+            let assign_stmt = make.expr_stmt(assign_expr.into());
+
+            editor.replace(tgt.syntax(), assign_stmt.syntax());
+            editor.add_mappings(make.finish_with_mappings());
+            edit.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
 }
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 309332873cb..d67f24fda96 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/make.rs
@@ -680,7 +680,7 @@ pub fn expr_tuple(elements: impl IntoIterator<Item = ast::Expr>) -> ast::TupleEx
     let expr = elements.into_iter().format(", ");
     expr_from_text(&format!("({expr})"))
 }
-pub fn expr_assignment(lhs: ast::Expr, rhs: ast::Expr) -> ast::Expr {
+pub fn expr_assignment(lhs: ast::Expr, rhs: ast::Expr) -> ast::BinExpr {
     expr_from_text(&format!("{lhs} = {rhs}"))
 }
 fn expr_from_text<E: Into<ast::Expr> + AstNode>(text: &str) -> E {
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 17cc5f9c057..1ba61073151 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
@@ -440,6 +440,19 @@ impl SyntaxFactory {
         ast
     }
 
+    pub fn expr_assignment(&self, lhs: ast::Expr, rhs: ast::Expr) -> ast::BinExpr {
+        let ast = make::expr_assignment(lhs.clone(), rhs.clone()).clone_for_update();
+
+        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
+    }
+
     pub fn expr_bin(&self, lhs: ast::Expr, op: ast::BinaryOp, rhs: ast::Expr) -> ast::BinExpr {
         let ast::Expr::BinExpr(ast) =
             make::expr_bin_op(lhs.clone(), op, rhs.clone()).clone_for_update()
-- 
cgit 1.4.1-3-g733a5


From 8d2d4eb89af09104bd1306073320d3e67ead5fe6 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 6 Jul 2025 20:02:45 +0000
Subject: Instantiate auto trait before computing higher-ranked constituent
 types

---
 .../src/traits/select/confirmation.rs              |  1 +
 .../rustc_trait_selection/src/traits/select/mod.rs | 38 +++++++++++++---------
 2 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index 545531f927a..b5408ef3c51 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -403,6 +403,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
             let self_ty =
                 obligation.predicate.self_ty().map_bound(|ty| self.infcx.shallow_resolve(ty));
+            let self_ty = self.infcx.enter_forall_and_leak_universe(self_ty);
 
             let types = self.constituent_types_for_ty(self_ty)?;
             let types = self.infcx.enter_forall_and_leak_universe(types);
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index c9930c69b32..308a0307afd 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -2330,9 +2330,9 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
     #[instrument(level = "debug", skip(self), ret)]
     fn constituent_types_for_ty(
         &self,
-        t: ty::Binder<'tcx, Ty<'tcx>>,
+        t: Ty<'tcx>,
     ) -> Result<ty::Binder<'tcx, Vec<Ty<'tcx>>>, SelectionError<'tcx>> {
-        Ok(match *t.skip_binder().kind() {
+        Ok(match *t.kind() {
             ty::Uint(_)
             | ty::Int(_)
             | ty::Bool
@@ -2349,8 +2349,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             // `assemble_candidates_from_auto_impls`.
             ty::Foreign(..) => ty::Binder::dummy(Vec::new()),
 
-            // FIXME(unsafe_binders): Squash the double binder for now, I guess.
-            ty::UnsafeBinder(_) => return Err(SelectionError::Unimplemented),
+            ty::UnsafeBinder(ty) => ty.map_bound(|ty| vec![ty]),
 
             // Treat this like `struct str([u8]);`
             ty::Str => ty::Binder::dummy(vec![Ty::new_slice(self.tcx(), self.tcx().types.u8)]),
@@ -2364,40 +2363,47 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 bug!("asked to assemble constituent types of unexpected type: {:?}", t);
             }
 
-            ty::RawPtr(element_ty, _) | ty::Ref(_, element_ty, _) => t.rebind(vec![element_ty]),
+            ty::RawPtr(element_ty, _) | ty::Ref(_, element_ty, _) => {
+                ty::Binder::dummy(vec![element_ty])
+            }
 
-            ty::Pat(ty, _) | ty::Array(ty, _) | ty::Slice(ty) => t.rebind(vec![ty]),
+            ty::Pat(ty, _) | ty::Array(ty, _) | ty::Slice(ty) => ty::Binder::dummy(vec![ty]),
 
             ty::Tuple(tys) => {
                 // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet
-                t.rebind(tys.iter().collect())
+                ty::Binder::dummy(tys.iter().collect())
             }
 
             ty::Closure(_, args) => {
                 let ty = self.infcx.shallow_resolve(args.as_closure().tupled_upvars_ty());
-                t.rebind(vec![ty])
+                ty::Binder::dummy(vec![ty])
             }
 
             ty::CoroutineClosure(_, args) => {
                 let ty = self.infcx.shallow_resolve(args.as_coroutine_closure().tupled_upvars_ty());
-                t.rebind(vec![ty])
+                ty::Binder::dummy(vec![ty])
             }
 
             ty::Coroutine(_, args) => {
                 let ty = self.infcx.shallow_resolve(args.as_coroutine().tupled_upvars_ty());
                 let witness = args.as_coroutine().witness();
-                t.rebind([ty].into_iter().chain(iter::once(witness)).collect())
+                ty::Binder::dummy([ty].into_iter().chain(iter::once(witness)).collect())
             }
 
-            ty::CoroutineWitness(def_id, args) => {
-                rebind_coroutine_witness_types(self.infcx.tcx, def_id, args, t.bound_vars())
-            }
+            ty::CoroutineWitness(def_id, args) => self
+                .infcx
+                .tcx
+                .coroutine_hidden_types(def_id)
+                .instantiate(self.infcx.tcx, args)
+                .map_bound(|witness| witness.types.to_vec()),
 
             // For `PhantomData<T>`, we pass `T`.
-            ty::Adt(def, args) if def.is_phantom_data() => t.rebind(args.types().collect()),
+            ty::Adt(def, args) if def.is_phantom_data() => {
+                ty::Binder::dummy(args.types().collect())
+            }
 
             ty::Adt(def, args) => {
-                t.rebind(def.all_fields().map(|f| f.ty(self.tcx(), args)).collect())
+                ty::Binder::dummy(def.all_fields().map(|f| f.ty(self.tcx(), args)).collect())
             }
 
             ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => {
@@ -2408,7 +2414,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                     // which enforces a DAG between the functions requiring
                     // the auto trait bounds in question.
                     match self.tcx().type_of_opaque(def_id) {
-                        Ok(ty) => t.rebind(vec![ty.instantiate(self.tcx(), args)]),
+                        Ok(ty) => ty::Binder::dummy(vec![ty.instantiate(self.tcx(), args)]),
                         Err(_) => {
                             return Err(SelectionError::OpaqueTypeAutoTraitLeakageUnknown(def_id));
                         }
-- 
cgit 1.4.1-3-g733a5


From bbb409cc68e2588b72d95f77f2b551f5455a201d Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 7 Jul 2025 22:21:08 +0000
Subject: Instantiate binder for Copy/Clone/Sized eagerly

---
 .../src/traits/select/candidate_assembly.rs        | 180 ++++++++++++++---
 .../src/traits/select/confirmation.rs              |  26 ++-
 .../rustc_trait_selection/src/traits/select/mod.rs | 212 ++++++---------------
 3 files changed, 222 insertions(+), 196 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index 9af85f5e3f0..cc188a280aa 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -19,7 +19,7 @@ use rustc_middle::{bug, span_bug};
 use tracing::{debug, instrument, trace};
 
 use super::SelectionCandidate::*;
-use super::{BuiltinImplConditions, SelectionCandidateSet, SelectionContext, TraitObligationStack};
+use super::{SelectionCandidateSet, SelectionContext, TraitObligationStack};
 use crate::traits::util;
 
 impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
@@ -75,8 +75,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     self.assemble_candidates_from_impls(obligation, &mut candidates);
 
                     // For other types, we'll use the builtin rules.
-                    let copy_conditions = self.copy_clone_conditions(obligation);
-                    self.assemble_builtin_bound_candidates(copy_conditions, &mut candidates);
+                    self.assemble_builtin_copy_clone_candidate(
+                        obligation.predicate.self_ty().skip_binder(),
+                        &mut candidates,
+                    );
                 }
                 Some(LangItem::DiscriminantKind) => {
                     // `DiscriminantKind` is automatically implemented for every type.
@@ -88,14 +90,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 }
                 Some(LangItem::Sized) => {
                     self.assemble_builtin_sized_candidate(
-                        obligation,
+                        obligation.predicate.self_ty().skip_binder(),
                         &mut candidates,
                         SizedTraitKind::Sized,
                     );
                 }
                 Some(LangItem::MetaSized) => {
                     self.assemble_builtin_sized_candidate(
-                        obligation,
+                        obligation.predicate.self_ty().skip_binder(),
                         &mut candidates,
                         SizedTraitKind::MetaSized,
                     );
@@ -357,14 +359,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         obligation: &PolyTraitObligation<'tcx>,
         candidates: &mut SelectionCandidateSet<'tcx>,
     ) {
-        let self_ty = obligation.self_ty().skip_binder();
-        // gen constructs get lowered to a special kind of coroutine that
-        // should directly `impl FusedIterator`.
-        if let ty::Coroutine(did, ..) = self_ty.kind()
-            && self.tcx().coroutine_is_gen(*did)
-        {
-            debug!(?self_ty, ?obligation, "assemble_fused_iterator_candidates",);
-
+        if self.coroutine_is_gen(obligation.self_ty().skip_binder()) {
             candidates.vec.push(BuiltinCandidate);
         }
     }
@@ -1113,41 +1108,164 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         }
     }
 
-    /// Assembles the `Sized` and `MetaSized` traits which are built-in to the language itself.
+    /// Assembles `Copy` and `Clone` candidates for built-in types with no libcore-defined
+    /// `Copy` or `Clone` impls.
     #[instrument(level = "debug", skip(self, candidates))]
-    fn assemble_builtin_sized_candidate(
+    fn assemble_builtin_copy_clone_candidate(
         &mut self,
-        obligation: &PolyTraitObligation<'tcx>,
+        self_ty: Ty<'tcx>,
         candidates: &mut SelectionCandidateSet<'tcx>,
-        sizedness: SizedTraitKind,
     ) {
-        match self.sizedness_conditions(obligation, sizedness) {
-            BuiltinImplConditions::Where(_nested) => {
-                candidates.vec.push(SizedCandidate);
+        match *self_ty.kind() {
+            // These impls are built-in because we cannot express sufficiently
+            // generic impls in libcore.
+            ty::FnDef(..)
+            | ty::FnPtr(..)
+            | ty::Error(_)
+            | ty::Tuple(..)
+            | ty::CoroutineWitness(..)
+            | ty::Pat(..) => {
+                candidates.vec.push(BuiltinCandidate);
+            }
+
+            // Implementations provided in libcore.
+            ty::Uint(_)
+            | ty::Int(_)
+            | ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
+            | ty::Bool
+            | ty::Float(_)
+            | ty::Char
+            | ty::RawPtr(..)
+            | ty::Never
+            | ty::Ref(_, _, hir::Mutability::Not)
+            | ty::Array(..) => {}
+
+            // FIXME(unsafe_binder): Should we conditionally
+            // (i.e. universally) implement copy/clone?
+            ty::UnsafeBinder(_) => {}
+
+            // Not `Sized`, which is a supertrait of `Copy`/`Clone`.
+            ty::Dynamic(..) | ty::Str | ty::Slice(..) | ty::Foreign(..) => {}
+
+            // Not `Copy` or `Clone` by design.
+            ty::Ref(_, _, hir::Mutability::Mut) => {}
+
+            ty::Coroutine(coroutine_def_id, args) => {
+                match self.tcx().coroutine_movability(coroutine_def_id) {
+                    hir::Movability::Static => {}
+                    hir::Movability::Movable => {
+                        if self.tcx().features().coroutine_clone() {
+                            let resolved_upvars =
+                                self.infcx.shallow_resolve(args.as_coroutine().tupled_upvars_ty());
+                            let resolved_witness =
+                                self.infcx.shallow_resolve(args.as_coroutine().witness());
+                            if resolved_upvars.is_ty_var() || resolved_witness.is_ty_var() {
+                                // Not yet resolved.
+                                candidates.ambiguous = true;
+                            } else {
+                                candidates.vec.push(BuiltinCandidate);
+                            }
+                        }
+                    }
+                }
             }
-            BuiltinImplConditions::None => {}
-            BuiltinImplConditions::Ambiguous => {
+
+            ty::Closure(_, args) => {
+                let resolved_upvars =
+                    self.infcx.shallow_resolve(args.as_closure().tupled_upvars_ty());
+                if resolved_upvars.is_ty_var() {
+                    // Not yet resolved.
+                    candidates.ambiguous = true;
+                } else {
+                    candidates.vec.push(BuiltinCandidate);
+                }
+            }
+
+            ty::CoroutineClosure(_, args) => {
+                let resolved_upvars =
+                    self.infcx.shallow_resolve(args.as_coroutine_closure().tupled_upvars_ty());
+                if resolved_upvars.is_ty_var() {
+                    // Not yet resolved.
+                    candidates.ambiguous = true;
+                } else {
+                    candidates.vec.push(BuiltinCandidate);
+                }
+            }
+
+            // Fallback to whatever user-defined impls or param-env clauses exist in this case.
+            ty::Adt(..) | ty::Alias(..) | ty::Param(..) | ty::Placeholder(..) => {}
+
+            ty::Infer(ty::TyVar(_)) => {
                 candidates.ambiguous = true;
             }
+
+            // Only appears when assembling higher-ranked `for<T> T: Clone`.
+            ty::Bound(..) => {}
+
+            ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
+                bug!("asked to assemble builtin bounds of unexpected type: {:?}", self_ty);
+            }
         }
     }
 
-    /// Assembles the trait which are built-in to the language itself:
-    /// e.g. `Copy` and `Clone`.
+    /// Assembles the `Sized` and `MetaSized` traits which are built-in to the language itself.
     #[instrument(level = "debug", skip(self, candidates))]
-    fn assemble_builtin_bound_candidates(
+    fn assemble_builtin_sized_candidate(
         &mut self,
-        conditions: BuiltinImplConditions<'tcx>,
+        self_ty: Ty<'tcx>,
         candidates: &mut SelectionCandidateSet<'tcx>,
+        sizedness: SizedTraitKind,
     ) {
-        match conditions {
-            BuiltinImplConditions::Where(_) => {
-                candidates.vec.push(BuiltinCandidate);
+        match *self_ty.kind() {
+            // Always sized.
+            ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
+            | ty::Uint(_)
+            | ty::Int(_)
+            | ty::Bool
+            | ty::Float(_)
+            | ty::FnDef(..)
+            | ty::FnPtr(..)
+            | ty::RawPtr(..)
+            | ty::Char
+            | ty::Ref(..)
+            | ty::Coroutine(..)
+            | ty::CoroutineWitness(..)
+            | ty::Array(..)
+            | ty::Closure(..)
+            | ty::CoroutineClosure(..)
+            | ty::Never
+            | ty::Error(_) => {
+                candidates.vec.push(SizedCandidate);
+            }
+
+            // Conditionally `Sized`.
+            ty::Tuple(..) | ty::Pat(..) | ty::Adt(..) | ty::UnsafeBinder(_) => {
+                candidates.vec.push(SizedCandidate);
             }
-            BuiltinImplConditions::None => {}
-            BuiltinImplConditions::Ambiguous => {
+
+            // `MetaSized` but not `Sized`.
+            ty::Str | ty::Slice(_) | ty::Dynamic(..) => match sizedness {
+                SizedTraitKind::Sized => {}
+                SizedTraitKind::MetaSized => {
+                    candidates.vec.push(SizedCandidate);
+                }
+            },
+
+            // Not `MetaSized` or `Sized`.
+            ty::Foreign(..) => {}
+
+            ty::Alias(..) | ty::Param(_) | ty::Placeholder(..) => {}
+
+            ty::Infer(ty::TyVar(_)) => {
                 candidates.ambiguous = true;
             }
+
+            // Only appears when assembling higher-ranked `for<T> T: Sized`.
+            ty::Bound(..) => {}
+
+            ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
+                bug!("asked to assemble builtin bounds of unexpected type: {:?}", self_ty);
+            }
         }
     }
 
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index b5408ef3c51..ee8cef20279 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -21,7 +21,7 @@ use thin_vec::thin_vec;
 use tracing::{debug, instrument};
 
 use super::SelectionCandidate::{self, *};
-use super::{BuiltinImplConditions, PredicateObligations, SelectionContext};
+use super::{PredicateObligations, SelectionContext};
 use crate::traits::normalize::{normalize_with_depth, normalize_with_depth_to};
 use crate::traits::util::{self, closure_trait_ref_and_return_type};
 use crate::traits::{
@@ -257,16 +257,25 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         debug!(?obligation, "confirm_builtin_candidate");
         let tcx = self.tcx();
         let trait_def = obligation.predicate.def_id();
-        let conditions = match tcx.as_lang_item(trait_def) {
-            Some(LangItem::Sized) => self.sizedness_conditions(obligation, SizedTraitKind::Sized),
+        let self_ty = self.infcx.shallow_resolve(
+            self.infcx.enter_forall_and_leak_universe(obligation.predicate.self_ty()),
+        );
+        let types = match tcx.as_lang_item(trait_def) {
+            Some(LangItem::Sized) => self.sizedness_conditions(self_ty, SizedTraitKind::Sized),
             Some(LangItem::MetaSized) => {
-                self.sizedness_conditions(obligation, SizedTraitKind::MetaSized)
+                self.sizedness_conditions(self_ty, SizedTraitKind::MetaSized)
             }
             Some(LangItem::PointeeSized) => {
                 bug!("`PointeeSized` is removing during lowering");
             }
-            Some(LangItem::Copy | LangItem::Clone) => self.copy_clone_conditions(obligation),
-            Some(LangItem::FusedIterator) => self.fused_iterator_conditions(obligation),
+            Some(LangItem::Copy | LangItem::Clone) => self.copy_clone_conditions(self_ty),
+            Some(LangItem::FusedIterator) => {
+                if self.coroutine_is_gen(self_ty) {
+                    ty::Binder::dummy(vec![])
+                } else {
+                    unreachable!("tried to assemble `FusedIterator` for non-gen coroutine");
+                }
+            }
             Some(
                 LangItem::Destruct
                 | LangItem::DiscriminantKind
@@ -274,12 +283,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | LangItem::PointeeTrait
                 | LangItem::Tuple
                 | LangItem::Unpin,
-            ) => BuiltinImplConditions::Where(ty::Binder::dummy(vec![])),
+            ) => ty::Binder::dummy(vec![]),
             other => bug!("unexpected builtin trait {trait_def:?} ({other:?})"),
         };
-        let BuiltinImplConditions::Where(types) = conditions else {
-            bug!("obligation {:?} had matched a builtin impl but now doesn't", obligation);
-        };
         let types = self.infcx.enter_forall_and_leak_universe(types);
 
         let cause = obligation.derived_cause(ObligationCauseCode::BuiltinDerived);
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 308a0307afd..2e65750db25 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -188,18 +188,6 @@ struct EvaluatedCandidate<'tcx> {
     evaluation: EvaluationResult,
 }
 
-/// When does the builtin impl for `T: Trait` apply?
-#[derive(Debug)]
-enum BuiltinImplConditions<'tcx> {
-    /// The impl is conditional on `T1, T2, ...: Trait`.
-    Where(ty::Binder<'tcx, Vec<Ty<'tcx>>>),
-    /// There is no built-in impl. There may be some other
-    /// candidate (a where-clause or user-defined impl).
-    None,
-    /// It is unknown whether there is an impl.
-    Ambiguous,
-}
-
 impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     pub fn new(infcx: &'cx InferCtxt<'tcx>) -> SelectionContext<'cx, 'tcx> {
         SelectionContext {
@@ -2104,14 +2092,9 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
 impl<'tcx> SelectionContext<'_, 'tcx> {
     fn sizedness_conditions(
         &mut self,
-        obligation: &PolyTraitObligation<'tcx>,
+        self_ty: Ty<'tcx>,
         sizedness: SizedTraitKind,
-    ) -> BuiltinImplConditions<'tcx> {
-        use self::BuiltinImplConditions::{Ambiguous, None, Where};
-
-        // NOTE: binder moved to (*)
-        let self_ty = self.infcx.shallow_resolve(obligation.predicate.skip_binder().self_ty());
-
+    ) -> ty::Binder<'tcx, Vec<Ty<'tcx>>> {
         match self_ty.kind() {
             ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
             | ty::Uint(_)
@@ -2129,59 +2112,44 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Never
-            | ty::Error(_) => {
-                // safe for everything
-                Where(ty::Binder::dummy(Vec::new()))
-            }
+            | ty::Error(_) => ty::Binder::dummy(vec![]),
 
             ty::Str | ty::Slice(_) | ty::Dynamic(..) => match sizedness {
-                SizedTraitKind::Sized => None,
-                SizedTraitKind::MetaSized => Where(ty::Binder::dummy(Vec::new())),
+                SizedTraitKind::Sized => unreachable!("tried to assemble `Sized` for unsized type"),
+                SizedTraitKind::MetaSized => ty::Binder::dummy(vec![]),
             },
 
-            ty::Foreign(..) => None,
+            ty::Foreign(..) => unreachable!("tried to assemble `Sized` for unsized type"),
 
-            ty::Tuple(tys) => Where(
-                obligation.predicate.rebind(tys.last().map_or_else(Vec::new, |&last| vec![last])),
-            ),
+            ty::Tuple(tys) => {
+                ty::Binder::dummy(tys.last().map_or_else(Vec::new, |&last| vec![last]))
+            }
 
-            ty::Pat(ty, _) => Where(obligation.predicate.rebind(vec![*ty])),
+            ty::Pat(ty, _) => ty::Binder::dummy(vec![*ty]),
 
             ty::Adt(def, args) => {
                 if let Some(crit) = def.sizedness_constraint(self.tcx(), sizedness) {
-                    // (*) binder moved here
-                    Where(obligation.predicate.rebind(vec![crit.instantiate(self.tcx(), args)]))
+                    ty::Binder::dummy(vec![crit.instantiate(self.tcx(), args)])
                 } else {
-                    Where(ty::Binder::dummy(Vec::new()))
+                    ty::Binder::dummy(vec![])
                 }
             }
 
-            // FIXME(unsafe_binders): This binder needs to be squashed
-            ty::UnsafeBinder(binder_ty) => Where(binder_ty.map_bound(|ty| vec![ty])),
-
-            ty::Alias(..) | ty::Param(_) | ty::Placeholder(..) => None,
-            ty::Infer(ty::TyVar(_)) => Ambiguous,
-
-            // We can make this an ICE if/once we actually instantiate the trait obligation eagerly.
-            ty::Bound(..) => None,
+            ty::UnsafeBinder(binder_ty) => binder_ty.map_bound(|ty| vec![ty]),
 
-            ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
-                bug!("asked to assemble builtin bounds of unexpected type: {:?}", self_ty);
+            ty::Alias(..)
+            | ty::Param(_)
+            | ty::Placeholder(..)
+            | ty::Infer(ty::TyVar(_) | ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_))
+            | ty::Bound(..) => {
+                bug!("asked to assemble `Sized` of unexpected type: {:?}", self_ty);
             }
         }
     }
 
-    fn copy_clone_conditions(
-        &mut self,
-        obligation: &PolyTraitObligation<'tcx>,
-    ) -> BuiltinImplConditions<'tcx> {
-        // NOTE: binder moved to (*)
-        let self_ty = self.infcx.shallow_resolve(obligation.predicate.skip_binder().self_ty());
-
-        use self::BuiltinImplConditions::{Ambiguous, None, Where};
-
+    fn copy_clone_conditions(&mut self, self_ty: Ty<'tcx>) -> ty::Binder<'tcx, Vec<Ty<'tcx>>> {
         match *self_ty.kind() {
-            ty::FnDef(..) | ty::FnPtr(..) | ty::Error(_) => Where(ty::Binder::dummy(Vec::new())),
+            ty::FnDef(..) | ty::FnPtr(..) | ty::Error(_) => ty::Binder::dummy(vec![]),
 
             ty::Uint(_)
             | ty::Int(_)
@@ -2193,127 +2161,78 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             | ty::Never
             | ty::Ref(_, _, hir::Mutability::Not)
             | ty::Array(..) => {
-                // Implementations provided in libcore
-                None
+                unreachable!("tried to assemble `Sized` for type with libcore-provided impl")
             }
 
             // FIXME(unsafe_binder): Should we conditionally
             // (i.e. universally) implement copy/clone?
-            ty::UnsafeBinder(_) => None,
-
-            ty::Dynamic(..)
-            | ty::Str
-            | ty::Slice(..)
-            | ty::Foreign(..)
-            | ty::Ref(_, _, hir::Mutability::Mut) => None,
+            ty::UnsafeBinder(_) => unreachable!("tried to assemble `Sized` for unsafe binder"),
 
             ty::Tuple(tys) => {
                 // (*) binder moved here
-                Where(obligation.predicate.rebind(tys.iter().collect()))
+                ty::Binder::dummy(tys.iter().collect())
             }
 
             ty::Pat(ty, _) => {
                 // (*) binder moved here
-                Where(obligation.predicate.rebind(vec![ty]))
+                ty::Binder::dummy(vec![ty])
             }
 
             ty::Coroutine(coroutine_def_id, args) => {
                 match self.tcx().coroutine_movability(coroutine_def_id) {
-                    hir::Movability::Static => None,
+                    hir::Movability::Static => {
+                        unreachable!("tried to assemble `Sized` for static coroutine")
+                    }
                     hir::Movability::Movable => {
                         if self.tcx().features().coroutine_clone() {
-                            let resolved_upvars =
-                                self.infcx.shallow_resolve(args.as_coroutine().tupled_upvars_ty());
-                            let resolved_witness =
-                                self.infcx.shallow_resolve(args.as_coroutine().witness());
-                            if resolved_upvars.is_ty_var() || resolved_witness.is_ty_var() {
-                                // Not yet resolved.
-                                Ambiguous
-                            } else {
-                                let all = args
-                                    .as_coroutine()
+                            ty::Binder::dummy(
+                                args.as_coroutine()
                                     .upvar_tys()
                                     .iter()
                                     .chain([args.as_coroutine().witness()])
-                                    .collect::<Vec<_>>();
-                                Where(obligation.predicate.rebind(all))
-                            }
+                                    .collect::<Vec<_>>(),
+                            )
                         } else {
-                            None
+                            unreachable!(
+                                "tried to assemble `Sized` for coroutine without enabled feature"
+                            )
                         }
                     }
                 }
             }
 
-            ty::CoroutineWitness(def_id, args) => {
-                let hidden_types = rebind_coroutine_witness_types(
-                    self.infcx.tcx,
-                    def_id,
-                    args,
-                    obligation.predicate.bound_vars(),
-                );
-                Where(hidden_types)
-            }
+            ty::CoroutineWitness(def_id, args) => self
+                .infcx
+                .tcx
+                .coroutine_hidden_types(def_id)
+                .instantiate(self.infcx.tcx, args)
+                .map_bound(|witness| witness.types.to_vec()),
 
-            ty::Closure(_, args) => {
-                // (*) binder moved here
-                let ty = self.infcx.shallow_resolve(args.as_closure().tupled_upvars_ty());
-                if let ty::Infer(ty::TyVar(_)) = ty.kind() {
-                    // Not yet resolved.
-                    Ambiguous
-                } else {
-                    Where(obligation.predicate.rebind(args.as_closure().upvar_tys().to_vec()))
-                }
-            }
+            ty::Closure(_, args) => ty::Binder::dummy(args.as_closure().upvar_tys().to_vec()),
 
             ty::CoroutineClosure(_, args) => {
-                // (*) binder moved here
-                let ty = self.infcx.shallow_resolve(args.as_coroutine_closure().tupled_upvars_ty());
-                if let ty::Infer(ty::TyVar(_)) = ty.kind() {
-                    // Not yet resolved.
-                    Ambiguous
-                } else {
-                    Where(
-                        obligation
-                            .predicate
-                            .rebind(args.as_coroutine_closure().upvar_tys().to_vec()),
-                    )
-                }
-            }
-
-            ty::Adt(..) | ty::Alias(..) | ty::Param(..) | ty::Placeholder(..) => {
-                // Fallback to whatever user-defined impls exist in this case.
-                None
+                ty::Binder::dummy(args.as_coroutine_closure().upvar_tys().to_vec())
             }
 
-            ty::Infer(ty::TyVar(_)) => {
-                // Unbound type variable. Might or might not have
-                // applicable impls and so forth, depending on what
-                // those type variables wind up being bound to.
-                Ambiguous
-            }
-
-            // We can make this an ICE if/once we actually instantiate the trait obligation eagerly.
-            ty::Bound(..) => None,
-
-            ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
+            ty::Foreign(..)
+            | ty::Str
+            | ty::Slice(_)
+            | ty::Dynamic(..)
+            | ty::Adt(..)
+            | ty::Alias(..)
+            | ty::Param(..)
+            | ty::Placeholder(..)
+            | ty::Bound(..)
+            | ty::Ref(_, _, ty::Mutability::Mut)
+            | ty::Infer(ty::TyVar(_) | ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
                 bug!("asked to assemble builtin bounds of unexpected type: {:?}", self_ty);
             }
         }
     }
 
-    fn fused_iterator_conditions(
-        &mut self,
-        obligation: &PolyTraitObligation<'tcx>,
-    ) -> BuiltinImplConditions<'tcx> {
-        let self_ty = self.infcx.shallow_resolve(obligation.self_ty().skip_binder());
-        if let ty::Coroutine(did, ..) = *self_ty.kind()
-            && self.tcx().coroutine_is_gen(did)
-        {
-            BuiltinImplConditions::Where(ty::Binder::dummy(Vec::new()))
-        } else {
-            BuiltinImplConditions::None
-        }
+    fn coroutine_is_gen(&mut self, self_ty: Ty<'tcx>) -> bool {
+        matches!(*self_ty.kind(), ty::Coroutine(did, ..)
+            if self.tcx().coroutine_is_gen(did))
     }
 
     /// For default impls, we need to break apart a type into its
@@ -2886,23 +2805,6 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
     }
 }
 
-fn rebind_coroutine_witness_types<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    def_id: DefId,
-    args: ty::GenericArgsRef<'tcx>,
-    bound_vars: &'tcx ty::List<ty::BoundVariableKind>,
-) -> ty::Binder<'tcx, Vec<Ty<'tcx>>> {
-    let bound_coroutine_types = tcx.coroutine_hidden_types(def_id).skip_binder();
-    let shifted_coroutine_types =
-        tcx.shift_bound_var_indices(bound_vars.len(), bound_coroutine_types.skip_binder());
-    ty::Binder::bind_with_vars(
-        ty::EarlyBinder::bind(shifted_coroutine_types.types.to_vec()).instantiate(tcx, args),
-        tcx.mk_bound_variable_kinds_from_iter(
-            bound_vars.iter().chain(bound_coroutine_types.bound_vars()),
-        ),
-    )
-}
-
 impl<'o, 'tcx> TraitObligationStack<'o, 'tcx> {
     fn list(&'o self) -> TraitObligationStackList<'o, 'tcx> {
         TraitObligationStackList::with(self)
-- 
cgit 1.4.1-3-g733a5


From fab9c64e2d98af65820a660f345106cc586b0006 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 8 Jul 2025 19:03:33 +0200
Subject: Add triagebot stdarch mention ping

---
 triagebot.toml | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 4e3dff219f1..6b989102f12 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -931,6 +931,15 @@ instead.
 """
 cc = ["@tgross35"]
 
+[mentions."library/stdarch"]
+message = """
+`stdarch` is developed in its own repository. If possible, consider \
+making this change to \
+[rust-lang/stdarch](https://github.com/rust-lang/stdarch) \
+instead.
+"""
+cc = ["@Amanieu", "@folkertdev", "@sayantn"]
+
 [mentions."library/core/src/intrinsics/simd.rs"]
 message = """
 Some changes occurred to the platform-builtins intrinsics. Make sure the
-- 
cgit 1.4.1-3-g733a5


From 66bc2340876746365870a61b3ee3f769713c7525 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 3 Jul 2025 13:21:35 -0500
Subject: tidy: refactor --extra-checks parsing

---
 src/tools/tidy/src/ext_tool_checks.rs | 125 ++++++++++++++++++++++++++++++----
 1 file changed, 111 insertions(+), 14 deletions(-)

diff --git a/src/tools/tidy/src/ext_tool_checks.rs b/src/tools/tidy/src/ext_tool_checks.rs
index d2da63a9703..c552cf8e400 100644
--- a/src/tools/tidy/src/ext_tool_checks.rs
+++ b/src/tools/tidy/src/ext_tool_checks.rs
@@ -20,6 +20,7 @@
 use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::str::FromStr;
 use std::{fmt, fs, io};
 
 const MIN_PY_REV: (u32, u32) = (3, 9);
@@ -61,25 +62,38 @@ fn check_impl(
 
     // Split comma-separated args up
     let lint_args = match extra_checks {
-        Some(s) => s.strip_prefix("--extra-checks=").unwrap().split(',').collect(),
+        Some(s) => s
+            .strip_prefix("--extra-checks=")
+            .unwrap()
+            .split(',')
+            .map(|s| {
+                if s == "spellcheck:fix" {
+                    eprintln!("warning: `spellcheck:fix` is no longer valid, use `--extra=check=spellcheck --bless`");
+                }
+                (ExtraCheckArg::from_str(s), s)
+            })
+            .filter_map(|(res, src)| match res {
+                Ok(x) => Some(x),
+                Err(err) => {
+                    eprintln!("warning: bad extra check argument {src:?}: {err:?}");
+                    None
+                }
+            })
+            .collect(),
         None => vec![],
     };
 
-    if lint_args.contains(&"spellcheck:fix") {
-        return Err(Error::Generic(
-            "`spellcheck:fix` is no longer valid, use `--extra=check=spellcheck --bless`"
-                .to_string(),
-        ));
+    macro_rules! extra_check {
+        ($lang:ident, $kind:ident) => {
+            lint_args.iter().any(|arg| arg.matches(ExtraCheckLang::$lang, ExtraCheckKind::$kind))
+        };
     }
 
-    let python_all = lint_args.contains(&"py");
-    let python_lint = lint_args.contains(&"py:lint") || python_all;
-    let python_fmt = lint_args.contains(&"py:fmt") || python_all;
-    let shell_all = lint_args.contains(&"shell");
-    let shell_lint = lint_args.contains(&"shell:lint") || shell_all;
-    let cpp_all = lint_args.contains(&"cpp");
-    let cpp_fmt = lint_args.contains(&"cpp:fmt") || cpp_all;
-    let spellcheck = lint_args.contains(&"spellcheck");
+    let python_lint = extra_check!(Py, Lint);
+    let python_fmt = extra_check!(Py, Fmt);
+    let shell_lint = extra_check!(Shell, Lint);
+    let cpp_fmt = extra_check!(Cpp, Fmt);
+    let spellcheck = extra_check!(Spellcheck, None);
 
     let mut py_path = None;
 
@@ -638,3 +652,86 @@ impl From<io::Error> for Error {
         Self::Io(value)
     }
 }
+
+#[derive(Debug)]
+enum ExtraCheckParseError {
+    #[allow(dead_code, reason = "shown through Debug")]
+    UnknownKind(String),
+    #[allow(dead_code)]
+    UnknownLang(String),
+    /// Too many `:`
+    TooManyParts,
+    /// Tried to parse the empty string
+    Empty,
+}
+
+struct ExtraCheckArg {
+    lang: ExtraCheckLang,
+    /// None = run all extra checks for the given lang
+    kind: Option<ExtraCheckKind>,
+}
+
+impl ExtraCheckArg {
+    fn matches(&self, lang: ExtraCheckLang, kind: ExtraCheckKind) -> bool {
+        self.lang == lang && self.kind.map(|k| k == kind).unwrap_or(true)
+    }
+}
+
+impl FromStr for ExtraCheckArg {
+    type Err = ExtraCheckParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut parts = s.split(':');
+        let Some(first) = parts.next() else {
+            return Err(ExtraCheckParseError::Empty);
+        };
+        let second = parts.next();
+        if parts.next().is_some() {
+            return Err(ExtraCheckParseError::TooManyParts);
+        }
+        Ok(Self { lang: first.parse()?, kind: second.map(|s| s.parse()).transpose()? })
+    }
+}
+
+#[derive(PartialEq, Copy, Clone)]
+enum ExtraCheckLang {
+    Py,
+    Shell,
+    Cpp,
+    Spellcheck,
+}
+
+impl FromStr for ExtraCheckLang {
+    type Err = ExtraCheckParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "py" => Self::Py,
+            "shell" => Self::Shell,
+            "cpp" => Self::Cpp,
+            "spellcheck" => Self::Spellcheck,
+            _ => return Err(ExtraCheckParseError::UnknownLang(s.to_string())),
+        })
+    }
+}
+
+#[derive(PartialEq, Copy, Clone)]
+enum ExtraCheckKind {
+    Lint,
+    Fmt,
+    /// Never parsed, but used as a placeholder for
+    /// langs that never have a specific kind.
+    None,
+}
+
+impl FromStr for ExtraCheckKind {
+    type Err = ExtraCheckParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "lint" => Self::Lint,
+            "fmt" => Self::Fmt,
+            _ => return Err(ExtraCheckParseError::UnknownKind(s.to_string())),
+        })
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 7c8a6d978bb47827eeef15448ca95f82af32c381 Mon Sep 17 00:00:00 2001
From: Aleksey Kliger <alklig@microsoft.com>
Date: Tue, 8 Jul 2025 14:18:07 -0400
Subject: Spelling

---
 src/bootstrap/configure.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bootstrap/configure.py b/src/bootstrap/configure.py
index 86208b94261..b05a5cc8b81 100755
--- a/src/bootstrap/configure.py
+++ b/src/bootstrap/configure.py
@@ -746,7 +746,7 @@ def write_uncommented(target, f):
     block = []
 
     def flush(last):
-        # If the block is entiry made of comments, ignore it
+        # If the block is entirely made of comments, ignore it
         entire_block_comments = all(ln.startswith("#") or ln == "" for ln in block)
         if not entire_block_comments and len(block) > 0:
             for line in block:
-- 
cgit 1.4.1-3-g733a5


From 96cdbb9ba77b9a840a1637e4dab05bb2cc64fef0 Mon Sep 17 00:00:00 2001
From: George Tokmaji <tokmajigeorge@gmail.com>
Date: Tue, 8 Jul 2025 21:19:38 +0200
Subject: Win: Use exceptions with empty data for SEH panic exception copies
 instead of a new panic

For unwinding with SEH, we currently construct a C++ exception with the
panic data. Being a regular C++ exception, it interacts with the C++
exception handling machinery and can be retrieved via
`std::current_exception`, which needs to copy the exception. We can't
support that, so we panic, which throws another exception, which the
C++ runtime tries to copy and store into the exception_ptr, which panics
again, which causes the C++ runtime to store a `bad_exception` instance.

However, this doesn't work because the panics thrown by the copy
function will be dropped without being rethrown, and causes unnecessary
log spam in stderr. Fix this by directly throwing an exception without
data, which doesn't cause log spam and can be dropped without being
rethrown.
---
 library/panic_unwind/src/seh.rs | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/library/panic_unwind/src/seh.rs b/library/panic_unwind/src/seh.rs
index 003ac4f0cd3..668e988abff 100644
--- a/library/panic_unwind/src/seh.rs
+++ b/library/panic_unwind/src/seh.rs
@@ -61,6 +61,7 @@ struct Exception {
     // and its destructor is executed by the C++ runtime. When we take the Box
     // out of the exception, we need to leave the exception in a valid state
     // for its destructor to run without double-dropping the Box.
+    // We also construct this as None for copies of the exception.
     data: Option<Box<dyn Any + Send>>,
 }
 
@@ -264,7 +265,11 @@ static mut TYPE_DESCRIPTOR: _TypeDescriptor = _TypeDescriptor {
 // runtime under a try/catch block and the panic that we generate here will be
 // used as the result of the exception copy. This is used by the C++ runtime to
 // support capturing exceptions with std::exception_ptr, which we can't support
-// because Box<dyn Any> isn't clonable.
+// because Box<dyn Any> isn't clonable. Thus we throw an exception without data,
+// which the C++ runtime will attempt to copy, which will once again fail, and
+// a std::bad_exception instance ends up in the std::exception_ptr instance.
+// The lack of data doesn't matter because the exception will never be rethrown
+// - it is purely used to signal to the C++ runtime that copying failed.
 macro_rules! define_cleanup {
     ($abi:tt $abi2:tt) => {
         unsafe extern $abi fn exception_cleanup(e: *mut Exception) {
@@ -278,7 +283,9 @@ macro_rules! define_cleanup {
         unsafe extern $abi2 fn exception_copy(
             _dest: *mut Exception, _src: *mut Exception
         ) -> *mut Exception {
-            panic!("Rust panics cannot be copied");
+            unsafe {
+                throw_exception(None);
+            }
         }
     }
 }
@@ -291,6 +298,10 @@ cfg_if::cfg_if! {
 }
 
 pub(crate) unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
+    unsafe { throw_exception(Some(data)) }
+}
+
+unsafe fn throw_exception(data: Option<Box<dyn Any + Send>>) -> ! {
     use core::intrinsics::{AtomicOrdering, atomic_store};
 
     // _CxxThrowException executes entirely on this stack frame, so there's no
@@ -300,8 +311,7 @@ pub(crate) unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
     // The ManuallyDrop is needed here since we don't want Exception to be
     // dropped when unwinding. Instead it will be dropped by exception_cleanup
     // which is invoked by the C++ runtime.
-    let mut exception =
-        ManuallyDrop::new(Exception { canary: (&raw const TYPE_DESCRIPTOR), data: Some(data) });
+    let mut exception = ManuallyDrop::new(Exception { canary: (&raw const TYPE_DESCRIPTOR), data });
     let throw_ptr = (&raw mut exception) as *mut _;
 
     // This... may seems surprising, and justifiably so. On 32-bit MSVC the
-- 
cgit 1.4.1-3-g733a5


From 25eb3829e5661ab85067188ca9e6586c29aed6e9 Mon Sep 17 00:00:00 2001
From: mejrs <59372212+mejrs@users.noreply.github.com>
Date: Tue, 8 Jul 2025 22:37:12 +0200
Subject: Error on moving unsized values rather than ICE'ing

---
 compiler/rustc_codegen_ssa/src/mir/mod.rs          |  7 +-
 compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs    | 20 +++++-
 compiler/rustc_middle/src/traits/mod.rs            |  4 ++
 .../src/error_reporting/traits/suggestions.rs      |  6 ++
 tests/ui/unsized-locals/unsized-exprs-rpass.rs     |  5 --
 tests/ui/unsized-locals/unsized-exprs.stderr       | 12 +++-
 tests/ui/unsized-locals/unsized-non-place-exprs.rs | 27 ++++++++
 .../unsized-locals/unsized-non-place-exprs.stderr  | 81 ++++++++++++++++++++++
 8 files changed, 153 insertions(+), 9 deletions(-)
 create mode 100644 tests/ui/unsized-locals/unsized-non-place-exprs.rs
 create mode 100644 tests/ui/unsized-locals/unsized-non-place-exprs.stderr

diff --git a/compiler/rustc_codegen_ssa/src/mir/mod.rs b/compiler/rustc_codegen_ssa/src/mir/mod.rs
index 4e35b143173..fa69820d5d2 100644
--- a/compiler/rustc_codegen_ssa/src/mir/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -141,7 +141,12 @@ enum LocalRef<'tcx, V> {
     /// `UnsizedPlace(p)`: `p` itself is a thin pointer (indirect place).
     /// `*p` is the wide pointer that references the actual unsized place.
     ///
-    /// Rust has no alloca and thus no ability to move the unsized place.
+    /// MIR only supports unsized args, not dynamically-sized locals, so
+    /// new unsized temps don't exist and we must reuse the referred-to place.
+    ///
+    /// FIXME: Since the removal of unsized locals in <https://github.com/rust-lang/rust/pull/142911>,
+    /// can we maybe use `Place` here? Or refactor it in another way? There are quite a few
+    /// `UnsizedPlace => bug` branches now.
     UnsizedPlace(PlaceRef<'tcx, V>),
     /// The backend [`OperandValue`] has already been generated.
     Operand(OperandRef<'tcx, V>),
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index eeb8d33ef65..eb8d671c939 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -241,6 +241,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 arg_expr.span,
                 ObligationCauseCode::WellFormed(None),
             );
+
+            self.check_place_expr_if_unsized(fn_input_ty, arg_expr);
         }
 
         // First, let's unify the formal method signature with the expectation eagerly.
@@ -543,6 +545,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    /// If `unsized_fn_params` is active, check that unsized values are place expressions. Since
+    /// the removal of `unsized_locals` in <https://github.com/rust-lang/rust/pull/142911> we can't
+    /// store them in MIR locals as temporaries.
+    ///
+    /// If `unsized_fn_params` is inactive, this will be checked in borrowck instead.
+    fn check_place_expr_if_unsized(&self, ty: Ty<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
+        if self.tcx.features().unsized_fn_params() && !expr.is_syntactic_place_expr() {
+            self.require_type_is_sized(
+                ty,
+                expr.span,
+                ObligationCauseCode::UnsizedNonPlaceExpr(expr.span),
+            );
+        }
+    }
+
     fn report_arg_errors(
         &self,
         compatibility_diagonal: IndexVec<ProvidedIdx, Compatibility<'tcx>>,
@@ -1873,7 +1890,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 });
             }
             hir::StmtKind::Semi(expr) => {
-                self.check_expr(expr);
+                let ty = self.check_expr(expr);
+                self.check_place_expr_if_unsized(ty, expr);
             }
         }
 
diff --git a/compiler/rustc_middle/src/traits/mod.rs b/compiler/rustc_middle/src/traits/mod.rs
index 1a5a9765ce7..5bdde3a514e 100644
--- a/compiler/rustc_middle/src/traits/mod.rs
+++ b/compiler/rustc_middle/src/traits/mod.rs
@@ -412,6 +412,10 @@ pub enum ObligationCauseCode<'tcx> {
 
     /// Obligations emitted during the normalization of a free type alias.
     TypeAlias(ObligationCauseCodeHandle<'tcx>, Span, DefId),
+
+    /// Only reachable if the `unsized_fn_params` feature is used. Unsized function arguments must
+    /// be place expressions because we can't store them in MIR locals as temporaries.
+    UnsizedNonPlaceExpr(Span),
 }
 
 /// Whether a value can be extracted into a const.
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 362052e9fdb..c5b85c95ba2 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -3624,6 +3624,12 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 );
                 suggest_remove_deref(err, &expr);
             }
+            ObligationCauseCode::UnsizedNonPlaceExpr(span) => {
+                err.span_note(
+                    span,
+                    "unsized values must be place expressions and cannot be put in temporaries",
+                );
+            }
         }
     }
 
diff --git a/tests/ui/unsized-locals/unsized-exprs-rpass.rs b/tests/ui/unsized-locals/unsized-exprs-rpass.rs
index 54ecd000343..ce31bd63f7c 100644
--- a/tests/ui/unsized-locals/unsized-exprs-rpass.rs
+++ b/tests/ui/unsized-locals/unsized-exprs-rpass.rs
@@ -18,11 +18,6 @@ impl std::ops::Add<i32> for A<[u8]> {
 }
 
 fn main() {
-    udrop::<[u8]>(loop {
-        break *foo();
-    });
-    udrop::<[u8]>(if true { *foo() } else { *foo() });
-    udrop::<[u8]>({ *foo() });
     udrop::<[u8]>((*foo()));
     *afoo() + 42;
     udrop as fn([u8]);
diff --git a/tests/ui/unsized-locals/unsized-exprs.stderr b/tests/ui/unsized-locals/unsized-exprs.stderr
index 1b61254870f..0455edbe8e7 100644
--- a/tests/ui/unsized-locals/unsized-exprs.stderr
+++ b/tests/ui/unsized-locals/unsized-exprs.stderr
@@ -10,7 +10,11 @@ note: required because it appears within the type `A<[u8]>`
    |
 LL | struct A<X: ?Sized>(X);
    |        ^
-   = note: structs must have a statically known size to be initialized
+note: unsized values must be place expressions and cannot be put in temporaries
+  --> $DIR/unsized-exprs.rs:19:22
+   |
+LL |     udrop::<A<[u8]>>(A { 0: *foo() });
+   |                      ^^^^^^^^^^^^^^^
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
   --> $DIR/unsized-exprs.rs:21:22
@@ -24,7 +28,11 @@ note: required because it appears within the type `A<[u8]>`
    |
 LL | struct A<X: ?Sized>(X);
    |        ^
-   = note: the return type of a function must have a statically known size
+note: unsized values must be place expressions and cannot be put in temporaries
+  --> $DIR/unsized-exprs.rs:21:22
+   |
+LL |     udrop::<A<[u8]>>(A(*foo()));
+   |                      ^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/unsized-locals/unsized-non-place-exprs.rs b/tests/ui/unsized-locals/unsized-non-place-exprs.rs
new file mode 100644
index 00000000000..d724fcf81a4
--- /dev/null
+++ b/tests/ui/unsized-locals/unsized-non-place-exprs.rs
@@ -0,0 +1,27 @@
+//! `#![feature(unsized_fn_params)]` lets you use unsized function parameters. In particular this
+//! is load bearing for `Box<dyn FnOnce()>: FnOnce()`. To do that, borrowck relaxes the requirement
+//! that certain places must be `Sized`. But in #142911 we removed alloca support, so these
+//! arguments cannot be put in temporaries (or ICE at codegen) That means when `unsized_fn_params`
+//! is enabled, we must explicitly check that unsized function arguments are place expressions.
+//!
+//! Also see tests/ui/unsized_locals/unsized-exprs-rpass.rs
+
+#![feature(unsized_fn_params)]
+
+fn foo() -> Box<[u8]> {
+    Box::new(*b"foo")
+}
+
+fn udrop<T: ?Sized>(_x: T) {}
+
+fn main(){
+    // NB The ordering of the following operations matters, otherwise errors get swallowed somehow.
+
+    udrop::<[u8]>(if true { *foo() } else { *foo() }); //~ERROR the size for values of type `[u8]` cannot be known at compilation time
+    udrop::<[u8]>({ *foo() }); //~ERROR the size for values of type `[u8]` cannot be known at compilation time
+    udrop(match foo() { x => *x }); //~ERROR the size for values of type `[u8]` cannot be known at compilation time
+    udrop::<[u8]>({ loop { break *foo(); } }); //~ERROR the size for values of type `[u8]` cannot be known at compilation time
+
+    { *foo() }; //~ERROR the size for values of type `[u8]` cannot be known at compilation time
+    { loop { break *foo(); } }; //~ERROR the size for values of type `[u8]` cannot be known at compilation time
+}
diff --git a/tests/ui/unsized-locals/unsized-non-place-exprs.stderr b/tests/ui/unsized-locals/unsized-non-place-exprs.stderr
new file mode 100644
index 00000000000..f9507e9a888
--- /dev/null
+++ b/tests/ui/unsized-locals/unsized-non-place-exprs.stderr
@@ -0,0 +1,81 @@
+error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
+  --> $DIR/unsized-non-place-exprs.rs:20:19
+   |
+LL |     udrop::<[u8]>(if true { *foo() } else { *foo() });
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `[u8]`
+note: unsized values must be place expressions and cannot be put in temporaries
+  --> $DIR/unsized-non-place-exprs.rs:20:19
+   |
+LL |     udrop::<[u8]>(if true { *foo() } else { *foo() });
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
+  --> $DIR/unsized-non-place-exprs.rs:21:19
+   |
+LL |     udrop::<[u8]>({ *foo() });
+   |                   ^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `[u8]`
+note: unsized values must be place expressions and cannot be put in temporaries
+  --> $DIR/unsized-non-place-exprs.rs:21:19
+   |
+LL |     udrop::<[u8]>({ *foo() });
+   |                   ^^^^^^^^^^
+
+error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
+  --> $DIR/unsized-non-place-exprs.rs:22:11
+   |
+LL |     udrop(match foo() { x => *x });
+   |           ^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `[u8]`
+note: unsized values must be place expressions and cannot be put in temporaries
+  --> $DIR/unsized-non-place-exprs.rs:22:11
+   |
+LL |     udrop(match foo() { x => *x });
+   |           ^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
+  --> $DIR/unsized-non-place-exprs.rs:23:19
+   |
+LL |     udrop::<[u8]>({ loop { break *foo(); } });
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `[u8]`
+note: unsized values must be place expressions and cannot be put in temporaries
+  --> $DIR/unsized-non-place-exprs.rs:23:19
+   |
+LL |     udrop::<[u8]>({ loop { break *foo(); } });
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
+  --> $DIR/unsized-non-place-exprs.rs:25:5
+   |
+LL |     { *foo() };
+   |     ^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `[u8]`
+note: unsized values must be place expressions and cannot be put in temporaries
+  --> $DIR/unsized-non-place-exprs.rs:25:5
+   |
+LL |     { *foo() };
+   |     ^^^^^^^^^^
+
+error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
+  --> $DIR/unsized-non-place-exprs.rs:26:5
+   |
+LL |     { loop { break *foo(); } };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `[u8]`
+note: unsized values must be place expressions and cannot be put in temporaries
+  --> $DIR/unsized-non-place-exprs.rs:26:5
+   |
+LL |     { loop { break *foo(); } };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 910c78b75a3d2070c97ed48435f991bf564fd23b Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 8 Jul 2025 23:41:22 +0300
Subject: Revert "Re-enable fixpoint iteration for variance computation"

---
 src/tools/rust-analyzer/crates/hir-expand/src/name.rs |  3 +--
 src/tools/rust-analyzer/crates/hir-ty/src/db.rs       |  5 +++--
 src/tools/rust-analyzer/crates/hir-ty/src/variance.rs | 18 +++++++++---------
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-expand/src/name.rs b/src/tools/rust-analyzer/crates/hir-expand/src/name.rs
index 679f61112ad..217d991d110 100644
--- a/src/tools/rust-analyzer/crates/hir-expand/src/name.rs
+++ b/src/tools/rust-analyzer/crates/hir-expand/src/name.rs
@@ -179,10 +179,9 @@ impl Name {
         self.symbol.as_str()
     }
 
-    #[inline]
     pub fn display<'a>(
         &'a self,
-        db: &dyn salsa::Database,
+        db: &dyn crate::db::ExpandDatabase,
         edition: Edition,
     ) -> impl fmt::Display + 'a {
         _ = db;
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 5d3be07f3db..b3d46845c44 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/db.rs
@@ -273,8 +273,9 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
 
     #[salsa::invoke(crate::variance::variances_of)]
     #[salsa::cycle(
-        cycle_fn = crate::variance::variances_of_cycle_fn,
-        cycle_initial = crate::variance::variances_of_cycle_initial,
+        // cycle_fn = crate::variance::variances_of_cycle_fn,
+        // cycle_initial = crate::variance::variances_of_cycle_initial,
+        cycle_result = crate::variance::variances_of_cycle_initial,
     )]
     fn variances_of(&self, def: GenericDefId) -> Option<Arc<[crate::variance::Variance]>>;
 
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 87d9df611bd..08a215fecf6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/variance.rs
@@ -54,14 +54,14 @@ pub(crate) fn variances_of(db: &dyn HirDatabase, def: GenericDefId) -> Option<Ar
     variances.is_empty().not().then(|| Arc::from_iter(variances))
 }
 
-pub(crate) fn variances_of_cycle_fn(
-    _db: &dyn HirDatabase,
-    _result: &Option<Arc<[Variance]>>,
-    _count: u32,
-    _def: GenericDefId,
-) -> salsa::CycleRecoveryAction<Option<Arc<[Variance]>>> {
-    salsa::CycleRecoveryAction::Iterate
-}
+// pub(crate) fn variances_of_cycle_fn(
+//     _db: &dyn HirDatabase,
+//     _result: &Option<Arc<[Variance]>>,
+//     _count: u32,
+//     _def: GenericDefId,
+// ) -> salsa::CycleRecoveryAction<Option<Arc<[Variance]>>> {
+//     salsa::CycleRecoveryAction::Iterate
+// }
 
 pub(crate) fn variances_of_cycle_initial(
     db: &dyn HirDatabase,
@@ -965,7 +965,7 @@ struct S3<T>(S<T, T>);
 struct FixedPoint<T, U, V>(&'static FixedPoint<(), T, U>, V);
 "#,
             expect![[r#"
-                FixedPoint[T: covariant, U: covariant, V: covariant]
+                FixedPoint[T: bivariant, U: bivariant, V: bivariant]
             "#]],
         );
     }
-- 
cgit 1.4.1-3-g733a5


From 9eb180541ac58409b1b2c82ad86e4078bcbb741b Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 3 Jul 2025 13:37:20 -0500
Subject: tidy: factor out change detection logic and make it more robust

now does proper parsing of git's output and falls back to
assuming all files are modified if `git` doesn't work.

accepts a closure so extensions can be checked.
---
 src/tools/tidy/src/lib.rs          | 26 ++++++++++++++++++++++++++
 src/tools/tidy/src/rustdoc_json.rs | 20 ++++----------------
 2 files changed, 30 insertions(+), 16 deletions(-)

diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 237737f0f16..90111079ecd 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -124,6 +124,32 @@ pub fn git_diff<S: AsRef<OsStr>>(base_commit: &str, extra_arg: S) -> Option<Stri
     Some(String::from_utf8_lossy(&output.stdout).into())
 }
 
+/// Returns true if any modified file matches the predicate, or if unable to list modified files.
+pub fn files_modified(base_commit: &str, pred: impl Fn(&str) -> bool) -> bool {
+    match crate::git_diff(&base_commit, "--name-status") {
+        Some(output) => {
+            let modified_files = output.lines().filter_map(|ln| {
+                let (status, name) = ln
+                    .trim_end()
+                    .split_once('\t')
+                    .expect("bad format from `git diff --name-status`");
+                if status == "M" { Some(name) } else { None }
+            });
+            for modified_file in modified_files {
+                if pred(modified_file) {
+                    return true;
+                }
+            }
+            false
+        }
+        None => {
+            eprintln!("warning: failed to run `git diff` to check for changes");
+            eprintln!("warning: assuming all files are modified");
+            true
+        }
+    }
+}
+
 pub mod alphabetical;
 pub mod bins;
 pub mod debug_artifacts;
diff --git a/src/tools/tidy/src/rustdoc_json.rs b/src/tools/tidy/src/rustdoc_json.rs
index dfbb35d69f1..da6f51c2a22 100644
--- a/src/tools/tidy/src/rustdoc_json.rs
+++ b/src/tools/tidy/src/rustdoc_json.rs
@@ -14,22 +14,10 @@ pub fn check(src_path: &Path, ci_info: &crate::CiInfo, bad: &mut bool) {
     };
 
     // First we check that `src/rustdoc-json-types` was modified.
-    match crate::git_diff(&base_commit, "--name-status") {
-        Some(output) => {
-            if !output
-                .lines()
-                .any(|line| line.starts_with("M") && line.contains(RUSTDOC_JSON_TYPES))
-            {
-                // `rustdoc-json-types` was not modified so nothing more to check here.
-                println!("`rustdoc-json-types` was not modified.");
-                return;
-            }
-        }
-        None => {
-            *bad = true;
-            eprintln!("error: failed to run `git diff` in rustdoc_json check");
-            return;
-        }
+    if !crate::files_modified(base_commit, |p| p == RUSTDOC_JSON_TYPES) {
+        // `rustdoc-json-types` was not modified so nothing more to check here.
+        println!("`rustdoc-json-types` was not modified.");
+        return;
     }
     // Then we check that if `FORMAT_VERSION` was updated, the `Latest feature:` was also updated.
     match crate::git_diff(&base_commit, src_path.join("rustdoc-json-types")) {
-- 
cgit 1.4.1-3-g733a5


From 4a6f6977f98026a9359a3b168b6d50045b1c07a8 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 3 Jul 2025 14:06:32 -0500
Subject: tidy: update files_modified to take CiInfo

---
 src/tools/tidy/src/lib.rs          | 8 ++++++--
 src/tools/tidy/src/rustdoc_json.rs | 2 +-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 90111079ecd..062cfe7b597 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -124,8 +124,12 @@ pub fn git_diff<S: AsRef<OsStr>>(base_commit: &str, extra_arg: S) -> Option<Stri
     Some(String::from_utf8_lossy(&output.stdout).into())
 }
 
-/// Returns true if any modified file matches the predicate, or if unable to list modified files.
-pub fn files_modified(base_commit: &str, pred: impl Fn(&str) -> bool) -> bool {
+/// Returns true if any modified file matches the predicate, if we are in CI, or if unable to list modified files.
+pub fn files_modified(ci_info: &CiInfo, pred: impl Fn(&str) -> bool) -> bool {
+    let Some(base_commit) = &ci_info.base_commit else {
+        eprintln!("No base commit, assuming all files are modified");
+        return true;
+    };
     match crate::git_diff(&base_commit, "--name-status") {
         Some(output) => {
             let modified_files = output.lines().filter_map(|ln| {
diff --git a/src/tools/tidy/src/rustdoc_json.rs b/src/tools/tidy/src/rustdoc_json.rs
index da6f51c2a22..19b8e79ec33 100644
--- a/src/tools/tidy/src/rustdoc_json.rs
+++ b/src/tools/tidy/src/rustdoc_json.rs
@@ -14,7 +14,7 @@ pub fn check(src_path: &Path, ci_info: &crate::CiInfo, bad: &mut bool) {
     };
 
     // First we check that `src/rustdoc-json-types` was modified.
-    if !crate::files_modified(base_commit, |p| p == RUSTDOC_JSON_TYPES) {
+    if !crate::files_modified(ci_info, |p| p == RUSTDOC_JSON_TYPES) {
         // `rustdoc-json-types` was not modified so nothing more to check here.
         println!("`rustdoc-json-types` was not modified.");
         return;
-- 
cgit 1.4.1-3-g733a5


From 64456e07b8e8550376d5136600fb0c59178df6a0 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 3 Jul 2025 14:27:47 -0500
Subject: tidy: add `auto:` prefix to --extra-checks syntax

currently this just uses a very simple
extension-based heirustic.
---
 src/bootstrap/src/core/config/flags.rs |  5 ++-
 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.zsh           |  2 +-
 src/etc/completions/x.zsh              |  2 +-
 src/tools/tidy/src/ext_tool_checks.rs  | 60 +++++++++++++++++++++++++++-------
 src/tools/tidy/src/main.rs             | 10 +++++-
 9 files changed, 67 insertions(+), 20 deletions(-)

diff --git a/src/bootstrap/src/core/config/flags.rs b/src/bootstrap/src/core/config/flags.rs
index bfc06f90d4f..19e0d3413bb 100644
--- a/src/bootstrap/src/core/config/flags.rs
+++ b/src/bootstrap/src/core/config/flags.rs
@@ -383,7 +383,10 @@ pub enum Subcommand {
         bless: bool,
         #[arg(long)]
         /// comma-separated list of other files types to check (accepts py, py:lint,
-        /// py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck, spellcheck:fix)
+        /// py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck)
+        ///
+        /// Any argument can be prefixed with "auto:" to only run if
+        /// relevant files are modified (eg. "auto:py").
         extra_checks: Option<String>,
         #[arg(long)]
         /// rerun tests even if the inputs are unchanged
diff --git a/src/etc/completions/x.fish b/src/etc/completions/x.fish
index 69bd525a312..3009dd85e93 100644
--- a/src/etc/completions/x.fish
+++ b/src/etc/completions/x.fish
@@ -293,7 +293,7 @@ complete -c x -n "__fish_x_using_subcommand doc" -l skip-std-check-if-no-downloa
 complete -c x -n "__fish_x_using_subcommand doc" -s h -l help -d 'Print help (see more with \'--help\')'
 complete -c x -n "__fish_x_using_subcommand test" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r
 complete -c x -n "__fish_x_using_subcommand test" -l compiletest-rustc-args -d 'extra options to pass the compiler when running compiletest tests' -r
-complete -c x -n "__fish_x_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck, spellcheck:fix)' -r
+complete -c x -n "__fish_x_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck)' -r
 complete -c x -n "__fish_x_using_subcommand test" -l compare-mode -d 'mode describing what file the actual ui output will be compared to' -r
 complete -c x -n "__fish_x_using_subcommand test" -l pass -d 'force {check,build,run}-pass tests to this mode' -r
 complete -c x -n "__fish_x_using_subcommand test" -l run -d 'whether to execute run-* tests' -r
diff --git a/src/etc/completions/x.ps1 b/src/etc/completions/x.ps1
index 7b142ba97ce..8002ec31592 100644
--- a/src/etc/completions/x.ps1
+++ b/src/etc/completions/x.ps1
@@ -339,7 +339,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
         'x;test' {
             [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)')
             [CompletionResult]::new('--compiletest-rustc-args', '--compiletest-rustc-args', [CompletionResultType]::ParameterName, 'extra options to pass the compiler when running compiletest tests')
-            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck, spellcheck:fix)')
+            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck)')
             [CompletionResult]::new('--compare-mode', '--compare-mode', [CompletionResultType]::ParameterName, 'mode describing what file the actual ui output will be compared to')
             [CompletionResult]::new('--pass', '--pass', [CompletionResultType]::ParameterName, 'force {check,build,run}-pass tests to this mode')
             [CompletionResult]::new('--run', '--run', [CompletionResultType]::ParameterName, 'whether to execute run-* tests')
diff --git a/src/etc/completions/x.py.fish b/src/etc/completions/x.py.fish
index e982cde634f..4766a5ee0c7 100644
--- a/src/etc/completions/x.py.fish
+++ b/src/etc/completions/x.py.fish
@@ -293,7 +293,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand doc" -l skip-std-check-if-no-d
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -s h -l help -d 'Print help (see more with \'--help\')'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l compiletest-rustc-args -d 'extra options to pass the compiler when running compiletest tests' -r
-complete -c x.py -n "__fish_x.py_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck, spellcheck:fix)' -r
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck)' -r
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l compare-mode -d 'mode describing what file the actual ui output will be compared to' -r
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l pass -d 'force {check,build,run}-pass tests to this mode' -r
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l run -d 'whether to execute run-* tests' -r
diff --git a/src/etc/completions/x.py.ps1 b/src/etc/completions/x.py.ps1
index f4b26fac0bc..1aff3c433b4 100644
--- a/src/etc/completions/x.py.ps1
+++ b/src/etc/completions/x.py.ps1
@@ -339,7 +339,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
         'x.py;test' {
             [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)')
             [CompletionResult]::new('--compiletest-rustc-args', '--compiletest-rustc-args', [CompletionResultType]::ParameterName, 'extra options to pass the compiler when running compiletest tests')
-            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck, spellcheck:fix)')
+            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck)')
             [CompletionResult]::new('--compare-mode', '--compare-mode', [CompletionResultType]::ParameterName, 'mode describing what file the actual ui output will be compared to')
             [CompletionResult]::new('--pass', '--pass', [CompletionResultType]::ParameterName, 'force {check,build,run}-pass tests to this mode')
             [CompletionResult]::new('--run', '--run', [CompletionResultType]::ParameterName, 'whether to execute run-* tests')
diff --git a/src/etc/completions/x.py.zsh b/src/etc/completions/x.py.zsh
index 8fc4f052252..77f995c1704 100644
--- a/src/etc/completions/x.py.zsh
+++ b/src/etc/completions/x.py.zsh
@@ -338,7 +338,7 @@ _arguments "${_arguments_options[@]}" : \
 _arguments "${_arguments_options[@]}" : \
 '*--test-args=[extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)]:ARGS:_default' \
 '*--compiletest-rustc-args=[extra options to pass the compiler when running compiletest tests]:ARGS:_default' \
-'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, shell\:lint, cpp, cpp\:fmt, spellcheck, spellcheck\:fix)]:EXTRA_CHECKS:_default' \
+'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, shell\:lint, cpp, cpp\:fmt, spellcheck)]:EXTRA_CHECKS:_default' \
 '--compare-mode=[mode describing what file the actual ui output will be compared to]:COMPARE MODE:_default' \
 '--pass=[force {check,build,run}-pass tests to this mode]:check | build | run:_default' \
 '--run=[whether to execute run-* tests]:auto | always | never:_default' \
diff --git a/src/etc/completions/x.zsh b/src/etc/completions/x.zsh
index c495e8318ba..6c6d7b3f49f 100644
--- a/src/etc/completions/x.zsh
+++ b/src/etc/completions/x.zsh
@@ -338,7 +338,7 @@ _arguments "${_arguments_options[@]}" : \
 _arguments "${_arguments_options[@]}" : \
 '*--test-args=[extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)]:ARGS:_default' \
 '*--compiletest-rustc-args=[extra options to pass the compiler when running compiletest tests]:ARGS:_default' \
-'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, shell\:lint, cpp, cpp\:fmt, spellcheck, spellcheck\:fix)]:EXTRA_CHECKS:_default' \
+'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, shell\:lint, cpp, cpp\:fmt, spellcheck)]:EXTRA_CHECKS:_default' \
 '--compare-mode=[mode describing what file the actual ui output will be compared to]:COMPARE MODE:_default' \
 '--pass=[force {check,build,run}-pass tests to this mode]:check | build | run:_default' \
 '--run=[whether to execute run-* tests]:auto | always | never:_default' \
diff --git a/src/tools/tidy/src/ext_tool_checks.rs b/src/tools/tidy/src/ext_tool_checks.rs
index c552cf8e400..be2f585a6d8 100644
--- a/src/tools/tidy/src/ext_tool_checks.rs
+++ b/src/tools/tidy/src/ext_tool_checks.rs
@@ -23,6 +23,8 @@ use std::process::Command;
 use std::str::FromStr;
 use std::{fmt, fs, io};
 
+use crate::CiInfo;
+
 const MIN_PY_REV: (u32, u32) = (3, 9);
 const MIN_PY_REV_STR: &str = "≥3.9";
 
@@ -37,15 +39,18 @@ const RUFF_CONFIG_PATH: &[&str] = &["src", "tools", "tidy", "config", "ruff.toml
 const RUFF_CACHE_PATH: &[&str] = &["cache", "ruff_cache"];
 const PIP_REQ_PATH: &[&str] = &["src", "tools", "tidy", "config", "requirements.txt"];
 
+const SPELLCHECK_DIRS: &[&str] = &["compiler", "library", "src/bootstrap", "src/librustdoc"];
+
 pub fn check(
     root_path: &Path,
     outdir: &Path,
+    ci_info: &CiInfo,
     bless: bool,
     extra_checks: Option<&str>,
     pos_args: &[String],
     bad: &mut bool,
 ) {
-    if let Err(e) = check_impl(root_path, outdir, bless, extra_checks, pos_args) {
+    if let Err(e) = check_impl(root_path, outdir, ci_info, bless, extra_checks, pos_args) {
         tidy_error!(bad, "{e}");
     }
 }
@@ -53,6 +58,7 @@ pub fn check(
 fn check_impl(
     root_path: &Path,
     outdir: &Path,
+    ci_info: &CiInfo,
     bless: bool,
     extra_checks: Option<&str>,
     pos_args: &[String],
@@ -73,7 +79,13 @@ fn check_impl(
                 (ExtraCheckArg::from_str(s), s)
             })
             .filter_map(|(res, src)| match res {
-                Ok(x) => Some(x),
+                Ok(arg) => {
+                    if arg.is_inactive_auto(ci_info) {
+                        None
+                    } else {
+                        Some(arg)
+                    }
+                }
                 Err(err) => {
                     eprintln!("warning: bad extra check argument {src:?}: {err:?}");
                     None
@@ -249,14 +261,9 @@ fn check_impl(
     if spellcheck {
         let config_path = root_path.join("typos.toml");
         // sync target files with .github/workflows/spellcheck.yml
-        let mut args = vec![
-            "-c",
-            config_path.as_os_str().to_str().unwrap(),
-            "./compiler",
-            "./library",
-            "./src/bootstrap",
-            "./src/librustdoc",
-        ];
+        let mut args = vec!["-c", config_path.as_os_str().to_str().unwrap()];
+
+        args.extend_from_slice(SPELLCHECK_DIRS);
 
         if bless {
             eprintln!("spellcheck files and fix");
@@ -663,9 +670,12 @@ enum ExtraCheckParseError {
     TooManyParts,
     /// Tried to parse the empty string
     Empty,
+    /// `auto` specified without lang part.
+    AutoRequiresLang,
 }
 
 struct ExtraCheckArg {
+    auto: bool,
     lang: ExtraCheckLang,
     /// None = run all extra checks for the given lang
     kind: Option<ExtraCheckKind>,
@@ -675,21 +685,47 @@ impl ExtraCheckArg {
     fn matches(&self, lang: ExtraCheckLang, kind: ExtraCheckKind) -> bool {
         self.lang == lang && self.kind.map(|k| k == kind).unwrap_or(true)
     }
+
+    /// Returns `true` if this is an auto arg and the relevant files are not modified.
+    fn is_inactive_auto(&self, ci_info: &CiInfo) -> bool {
+        if !self.auto {
+            return false;
+        }
+        let ext = match self.lang {
+            ExtraCheckLang::Py => ".py",
+            ExtraCheckLang::Cpp => ".cpp",
+            ExtraCheckLang::Shell => ".sh",
+            ExtraCheckLang::Spellcheck => {
+                return !crate::files_modified(ci_info, |s| {
+                    SPELLCHECK_DIRS.iter().any(|dir| Path::new(s).starts_with(dir))
+                });
+            }
+        };
+        !crate::files_modified(ci_info, |s| s.ends_with(ext))
+    }
 }
 
 impl FromStr for ExtraCheckArg {
     type Err = ExtraCheckParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut auto = false;
         let mut parts = s.split(':');
-        let Some(first) = parts.next() else {
+        let Some(mut first) = parts.next() else {
             return Err(ExtraCheckParseError::Empty);
         };
+        if first == "auto" {
+            let Some(part) = parts.next() else {
+                return Err(ExtraCheckParseError::AutoRequiresLang);
+            };
+            auto = true;
+            first = part;
+        }
         let second = parts.next();
         if parts.next().is_some() {
             return Err(ExtraCheckParseError::TooManyParts);
         }
-        Ok(Self { lang: first.parse()?, kind: second.map(|s| s.parse()).transpose()? })
+        Ok(Self { auto, lang: first.parse()?, kind: second.map(|s| s.parse()).transpose()? })
     }
 }
 
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index ef6ff5c9277..1eb5485f2b8 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -173,7 +173,15 @@ fn main() {
         };
         check!(unstable_book, &src_path, collected);
 
-        check!(ext_tool_checks, &root_path, &output_directory, bless, extra_checks, pos_args);
+        check!(
+            ext_tool_checks,
+            &root_path,
+            &output_directory,
+            &ci_info,
+            bless,
+            extra_checks,
+            pos_args
+        );
     });
 
     if bad.load(Ordering::Relaxed) {
-- 
cgit 1.4.1-3-g733a5


From 6b349a41da18b0960c7a2e7bb2d8444b56f32054 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 3 Jul 2025 14:42:42 -0500
Subject: tidy: warn when --extra-checks is passed an invalid lang:kind combo
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Jakub Beránek <berykubik@gmail.com>
---
 src/tools/tidy/src/ext_tool_checks.rs | 28 +++++++++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

diff --git a/src/tools/tidy/src/ext_tool_checks.rs b/src/tools/tidy/src/ext_tool_checks.rs
index be2f585a6d8..baab46752a5 100644
--- a/src/tools/tidy/src/ext_tool_checks.rs
+++ b/src/tools/tidy/src/ext_tool_checks.rs
@@ -39,6 +39,7 @@ const RUFF_CONFIG_PATH: &[&str] = &["src", "tools", "tidy", "config", "ruff.toml
 const RUFF_CACHE_PATH: &[&str] = &["cache", "ruff_cache"];
 const PIP_REQ_PATH: &[&str] = &["src", "tools", "tidy", "config", "requirements.txt"];
 
+// this must be kept in sync with with .github/workflows/spellcheck.yml
 const SPELLCHECK_DIRS: &[&str] = &["compiler", "library", "src/bootstrap", "src/librustdoc"];
 
 pub fn check(
@@ -74,7 +75,7 @@ fn check_impl(
             .split(',')
             .map(|s| {
                 if s == "spellcheck:fix" {
-                    eprintln!("warning: `spellcheck:fix` is no longer valid, use `--extra=check=spellcheck --bless`");
+                    eprintln!("warning: `spellcheck:fix` is no longer valid, use `--extra-checks=spellcheck --bless`");
                 }
                 (ExtraCheckArg::from_str(s), s)
             })
@@ -87,6 +88,7 @@ fn check_impl(
                     }
                 }
                 Err(err) => {
+                    // only warn because before bad extra checks would be silently ignored.
                     eprintln!("warning: bad extra check argument {src:?}: {err:?}");
                     None
                 }
@@ -260,7 +262,6 @@ fn check_impl(
 
     if spellcheck {
         let config_path = root_path.join("typos.toml");
-        // sync target files with .github/workflows/spellcheck.yml
         let mut args = vec!["-c", config_path.as_os_str().to_str().unwrap()];
 
         args.extend_from_slice(SPELLCHECK_DIRS);
@@ -666,6 +667,7 @@ enum ExtraCheckParseError {
     UnknownKind(String),
     #[allow(dead_code)]
     UnknownLang(String),
+    UnsupportedKindForLang,
     /// Too many `:`
     TooManyParts,
     /// Tried to parse the empty string
@@ -703,6 +705,21 @@ impl ExtraCheckArg {
         };
         !crate::files_modified(ci_info, |s| s.ends_with(ext))
     }
+
+    fn has_supported_kind(&self) -> bool {
+        let Some(kind) = self.kind else {
+            // "run all extra checks" mode is supported for all languages.
+            return true;
+        };
+        use ExtraCheckKind::*;
+        let supported_kinds: &[_] = match self.lang {
+            ExtraCheckLang::Py => &[Fmt, Lint],
+            ExtraCheckLang::Cpp => &[Fmt],
+            ExtraCheckLang::Shell => &[Lint],
+            ExtraCheckLang::Spellcheck => &[],
+        };
+        supported_kinds.contains(&kind)
+    }
 }
 
 impl FromStr for ExtraCheckArg {
@@ -725,7 +742,12 @@ impl FromStr for ExtraCheckArg {
         if parts.next().is_some() {
             return Err(ExtraCheckParseError::TooManyParts);
         }
-        Ok(Self { auto, lang: first.parse()?, kind: second.map(|s| s.parse()).transpose()? })
+        let arg = Self { auto, lang: first.parse()?, kind: second.map(|s| s.parse()).transpose()? };
+        if !arg.has_supported_kind() {
+            return Err(ExtraCheckParseError::UnsupportedKindForLang);
+        }
+
+        Ok(arg)
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 9aafc98244c0a8e0ec83203e7d17e02fcdfa0371 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Tue, 8 Jul 2025 12:32:33 -0500
Subject: tidy: assume all files are modified in CI

---
 src/tools/tidy/src/lib.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 062cfe7b597..77855392b4d 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -126,6 +126,10 @@ pub fn git_diff<S: AsRef<OsStr>>(base_commit: &str, extra_arg: S) -> Option<Stri
 
 /// Returns true if any modified file matches the predicate, if we are in CI, or if unable to list modified files.
 pub fn files_modified(ci_info: &CiInfo, pred: impl Fn(&str) -> bool) -> bool {
+    if CiEnv::is_ci() {
+        // assume everything is modified on CI because we really don't want false positives there.
+        return true;
+    }
     let Some(base_commit) = &ci_info.base_commit else {
         eprintln!("No base commit, assuming all files are modified");
         return true;
-- 
cgit 1.4.1-3-g733a5


From 1f80fd0f23405bd5d6061684eb2259dc92116f81 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Tue, 8 Jul 2025 12:36:15 -0500
Subject: bootstrap: add change tracker entry for new --extra-checks=auto:
 feature

---
 src/bootstrap/src/utils/change_tracker.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 424f211c7d4..29591edc9cc 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -461,4 +461,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Warning,
         summary: "`download-rustc` has been temporarily disabled for the library profile due to implementation bugs (see #142505).",
     },
+    ChangeInfo {
+        change_id: 143398,
+        severity: ChangeSeverity::Info,
+        summary: "The --extra-checks flag now supports prefixing any check with `auto:` to only run it if relevant files are modified",
+    },
 ];
-- 
cgit 1.4.1-3-g733a5


From c9ff1609d4f7ccd001d9a1487e644831d0b06947 Mon Sep 17 00:00:00 2001
From: Moulins <arthur.heuillard@orange.fr>
Date: Tue, 8 Jul 2025 21:10:40 +0200
Subject: docs: document trait upcasting rules in `Unsize` trait

---
 library/core/src/marker.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index 2aeb0b0c31e..f092916eb8c 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -210,6 +210,11 @@ pub trait PointeeSized {
 ///   - `Trait` is dyn-compatible[^1].
 ///   - The type is sized.
 ///   - The type outlives `'a`.
+/// - Trait objects `dyn TraitA + AutoA... + 'a` implement `Unsize<dyn TraitB + AutoB... + 'b>`
+///    if all of these conditions are met:
+///   - `TraitB` is a supertrait of `TraitA`.
+///   - `AutoB...` is a subset of `AutoA...`.
+///   - `'a` outlives `'b`.
 /// - Structs `Foo<..., T1, ..., Tn, ...>` implement `Unsize<Foo<..., U1, ..., Un, ...>>`
 /// where any number of (type and const) parameters may be changed if all of these conditions
 /// are met:
-- 
cgit 1.4.1-3-g733a5


From 62f58dbb2d4b9cc0f2a20cb836eb48d869358416 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Mon, 23 Jun 2025 23:41:33 +0300
Subject: Port `#[const_trait]` to the new attribute system

---
 .../rustc_attr_data_structures/src/attributes.rs   |  3 ++
 .../src/encode_cross_crate.rs                      |  1 +
 .../rustc_attr_parsing/src/attributes/traits.rs    | 13 +++++--
 compiler/rustc_attr_parsing/src/context.rs         |  3 +-
 compiler/rustc_hir_analysis/src/collect.rs         | 40 ++++++++++++----------
 compiler/rustc_middle/src/ty/mod.rs                | 11 +++---
 compiler/rustc_parse/src/validate_attr.rs          |  1 +
 compiler/rustc_passes/src/check_attr.rs            | 10 +++---
 8 files changed, 49 insertions(+), 33 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index b656db32528..6ea98f66405 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -234,6 +234,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_const_stable_indirect]`.
     ConstStabilityIndirect,
 
+    /// Represents `#[const_trait]`.
+    ConstTrait(Span),
+
     /// Represents [`#[deprecated]`](https://doc.rust-lang.org/stable/reference/attributes/diagnostics.html#the-deprecated-attribute).
     Deprecation { deprecation: Deprecation, span: Span },
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 5414c7b103b..f22a64b2fd0 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -23,6 +23,7 @@ impl AttributeKind {
             ConstContinue(..) => No,
             ConstStability { .. } => Yes,
             ConstStabilityIndirect => No,
+            ConstTrait(..) => No,
             Deprecation { .. } => Yes,
             DocComment { .. } => Yes,
             Dummy => No,
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index 83a98c53c7f..e897fc76ad7 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -2,9 +2,11 @@ use core::mem;
 
 use rustc_attr_data_structures::AttributeKind;
 use rustc_feature::{AttributeTemplate, template};
-use rustc_span::{Symbol, sym};
+use rustc_span::{Span, Symbol, sym};
 
-use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
+use crate::attributes::{
+    AttributeOrder, NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
+};
 use crate::context::{AcceptContext, Stage};
 use crate::parser::ArgParser;
 
@@ -52,3 +54,10 @@ impl<S: Stage> SingleAttributeParser<S> for SkipDuringMethodDispatchParser {
         Some(AttributeKind::SkipDuringMethodDispatch { array, boxed_slice, span: cx.attr_span })
     }
 }
+
+pub(crate) struct ConstTraitParser;
+impl<S: Stage> NoArgsAttributeParser<S> for ConstTraitParser {
+    const PATH: &[Symbol] = &[sym::const_trait];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::ConstTrait;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index dbe1a5b2ad0..9d294b0528d 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -43,7 +43,7 @@ use crate::attributes::stability::{
     BodyStabilityParser, ConstStabilityIndirectParser, ConstStabilityParser, StabilityParser,
 };
 use crate::attributes::test_attrs::IgnoreParser;
-use crate::attributes::traits::SkipDuringMethodDispatchParser;
+use crate::attributes::traits::{ConstTraitParser, SkipDuringMethodDispatchParser};
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
 use crate::parser::{ArgParser, MetaItemParser, PathParser};
@@ -150,6 +150,7 @@ attribute_parsers!(
         Single<WithoutArgs<ColdParser>>,
         Single<WithoutArgs<ConstContinueParser>>,
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
+        Single<WithoutArgs<ConstTraitParser>>,
         Single<WithoutArgs<ExportStableParser>>,
         Single<WithoutArgs<FfiConstParser>>,
         Single<WithoutArgs<FfiPureParser>>,
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index a185291887d..75e732ff461 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -852,39 +852,42 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
         _ => span_bug!(item.span, "trait_def_of_item invoked on non-trait"),
     };
 
+    let attrs = tcx.get_all_attrs(def_id);
     // Only regular traits can be const.
-    let constness = if !is_alias && tcx.has_attr(def_id, sym::const_trait) {
+    let constness = if !is_alias && find_attr!(attrs, AttributeKind::ConstTrait(_)) {
         hir::Constness::Const
     } else {
         hir::Constness::NotConst
     };
 
-    let paren_sugar = tcx.has_attr(def_id, sym::rustc_paren_sugar);
+    let paren_sugar = attrs.iter().any(|attr| attr.has_name(sym::rustc_paren_sugar));
     if paren_sugar && !tcx.features().unboxed_closures() {
         tcx.dcx().emit_err(errors::ParenSugarAttribute { span: item.span });
     }
 
     // Only regular traits can be marker.
-    let is_marker = !is_alias && tcx.has_attr(def_id, sym::marker);
+    let is_marker = !is_alias && attrs.iter().any(|attr| attr.has_name(sym::marker));
 
-    let rustc_coinductive = tcx.has_attr(def_id, sym::rustc_coinductive);
-    let is_fundamental = tcx.has_attr(def_id, sym::fundamental);
+    let rustc_coinductive = attrs.iter().any(|attr| attr.has_name(sym::rustc_coinductive));
+    let is_fundamental = attrs.iter().any(|attr| attr.has_name(sym::fundamental));
 
     let [skip_array_during_method_dispatch, skip_boxed_slice_during_method_dispatch] = find_attr!(
-        tcx.get_all_attrs(def_id),
-        AttributeKind::SkipDuringMethodDispatch { array, boxed_slice, span:_ } => [*array, *boxed_slice]
+        attrs,
+        AttributeKind::SkipDuringMethodDispatch { array, boxed_slice, span: _ } => [*array, *boxed_slice]
     )
     .unwrap_or([false; 2]);
 
-    let specialization_kind = if tcx.has_attr(def_id, sym::rustc_unsafe_specialization_marker) {
-        ty::trait_def::TraitSpecializationKind::Marker
-    } else if tcx.has_attr(def_id, sym::rustc_specialization_trait) {
-        ty::trait_def::TraitSpecializationKind::AlwaysApplicable
-    } else {
-        ty::trait_def::TraitSpecializationKind::None
-    };
-    let must_implement_one_of = tcx
-        .get_attr(def_id, sym::rustc_must_implement_one_of)
+    let specialization_kind =
+        if attrs.iter().any(|attr| attr.has_name(sym::rustc_unsafe_specialization_marker)) {
+            ty::trait_def::TraitSpecializationKind::Marker
+        } else if attrs.iter().any(|attr| attr.has_name(sym::rustc_specialization_trait)) {
+            ty::trait_def::TraitSpecializationKind::AlwaysApplicable
+        } else {
+            ty::trait_def::TraitSpecializationKind::None
+        };
+    let must_implement_one_of = attrs
+        .iter()
+        .find(|attr| attr.has_name(sym::rustc_must_implement_one_of))
         // Check that there are at least 2 arguments of `#[rustc_must_implement_one_of]`
         // and that they are all identifiers
         .and_then(|attr| match attr.meta_item_list() {
@@ -958,8 +961,9 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
             no_dups.then_some(list)
         });
 
-    let deny_explicit_impl = tcx.has_attr(def_id, sym::rustc_deny_explicit_impl);
-    let implement_via_object = !tcx.has_attr(def_id, sym::rustc_do_not_implement_via_object);
+    let deny_explicit_impl = attrs.iter().any(|attr| attr.has_name(sym::rustc_deny_explicit_impl));
+    let implement_via_object =
+        !attrs.iter().any(|attr| attr.has_name(sym::rustc_do_not_implement_via_object));
 
     ty::TraitDef {
         def_id: def_id.to_def_id(),
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index b780b1c5776..0177a95498b 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1782,21 +1782,18 @@ impl<'tcx> TyCtxt<'tcx> {
         did: impl Into<DefId>,
         attr: Symbol,
     ) -> impl Iterator<Item = &'tcx hir::Attribute> {
-        self.get_all_attrs(did).filter(move |a: &&hir::Attribute| a.has_name(attr))
+        self.get_all_attrs(did).iter().filter(move |a: &&hir::Attribute| a.has_name(attr))
     }
 
     /// Gets all attributes.
     ///
     /// To see if an item has a specific attribute, you should use [`rustc_attr_data_structures::find_attr!`] so you can use matching.
-    pub fn get_all_attrs(
-        self,
-        did: impl Into<DefId>,
-    ) -> impl Iterator<Item = &'tcx hir::Attribute> {
+    pub fn get_all_attrs(self, did: impl Into<DefId>) -> &'tcx [hir::Attribute] {
         let did: DefId = did.into();
         if let Some(did) = did.as_local() {
-            self.hir_attrs(self.local_def_id_to_hir_id(did)).iter()
+            self.hir_attrs(self.local_def_id_to_hir_id(did))
         } else {
-            self.attrs_for_def(did).iter()
+            self.attrs_for_def(did)
         }
     }
 
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 11424ec3724..53346b40e2b 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -283,6 +283,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_confusables
                 | sym::rustc_skip_during_method_dispatch
                 | sym::rustc_pass_by_value
+                | sym::const_trait
                 | sym::repr
                 | sym::align
                 | sym::deprecated
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 0aa6a2b41cf..744f93506fe 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -120,10 +120,10 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         for attr in attrs {
             let mut style = None;
             match attr {
-                Attribute::Parsed(AttributeKind::SkipDuringMethodDispatch {
-                    span: attr_span,
-                    ..
-                }) => {
+                Attribute::Parsed(
+                    AttributeKind::SkipDuringMethodDispatch { span: attr_span, .. }
+                    | AttributeKind::ConstTrait(attr_span),
+                ) => {
                     self.check_must_be_applied_to_trait(*attr_span, span, target);
                 }
                 Attribute::Parsed(AttributeKind::Confusables { first_span, .. }) => {
@@ -301,7 +301,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         | [sym::rustc_must_implement_one_of, ..]
                         | [sym::rustc_deny_explicit_impl, ..]
                         | [sym::rustc_do_not_implement_via_object, ..]
-                        | [sym::const_trait, ..] => self.check_must_be_applied_to_trait(attr.span(), span, target),
+                        => self.check_must_be_applied_to_trait(attr.span(), span, target),
                         [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target),
                         [sym::must_not_suspend, ..] => self.check_must_not_suspend(attr, span, target),
                         [sym::rustc_allow_incoherent_impl, ..] => {
-- 
cgit 1.4.1-3-g733a5


From 938916d220f2b8f7a5c5de26e7c43a826382d27f Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 00:18:37 +0300
Subject: Port `#[rustc_deny_explicit_impl]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs         | 3 +++
 compiler/rustc_attr_data_structures/src/encode_cross_crate.rs | 1 +
 compiler/rustc_attr_parsing/src/attributes/traits.rs          | 7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                    | 5 ++++-
 compiler/rustc_hir_analysis/src/collect.rs                    | 2 +-
 compiler/rustc_parse/src/validate_attr.rs                     | 1 +
 compiler/rustc_passes/src/check_attr.rs                       | 4 ++--
 7 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 6ea98f66405..f554b7a258a 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -237,6 +237,9 @@ pub enum AttributeKind {
     /// Represents `#[const_trait]`.
     ConstTrait(Span),
 
+    ///Represents `#[rustc_deny_explicit_impl]`.
+    DenyExplicitImpl(Span),
+
     /// Represents [`#[deprecated]`](https://doc.rust-lang.org/stable/reference/attributes/diagnostics.html#the-deprecated-attribute).
     Deprecation { deprecation: Deprecation, span: Span },
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index f22a64b2fd0..183a789f636 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -24,6 +24,7 @@ impl AttributeKind {
             ConstStability { .. } => Yes,
             ConstStabilityIndirect => No,
             ConstTrait(..) => No,
+            DenyExplicitImpl(..) => No,
             Deprecation { .. } => Yes,
             DocComment { .. } => Yes,
             Dummy => No,
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index e897fc76ad7..a7c9a77ca8c 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -61,3 +61,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for ConstTraitParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::ConstTrait;
 }
+
+pub(crate) struct DenyExplicitImplParser;
+impl<S: Stage> NoArgsAttributeParser<S> for DenyExplicitImplParser {
+    const PATH: &[Symbol] = &[sym::rustc_deny_explicit_impl];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::DenyExplicitImpl;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 9d294b0528d..a6d41de36b6 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -43,7 +43,9 @@ use crate::attributes::stability::{
     BodyStabilityParser, ConstStabilityIndirectParser, ConstStabilityParser, StabilityParser,
 };
 use crate::attributes::test_attrs::IgnoreParser;
-use crate::attributes::traits::{ConstTraitParser, SkipDuringMethodDispatchParser};
+use crate::attributes::traits::{
+    ConstTraitParser, DenyExplicitImplParser, SkipDuringMethodDispatchParser,
+};
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
 use crate::parser::{ArgParser, MetaItemParser, PathParser};
@@ -151,6 +153,7 @@ attribute_parsers!(
         Single<WithoutArgs<ConstContinueParser>>,
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
         Single<WithoutArgs<ConstTraitParser>>,
+        Single<WithoutArgs<DenyExplicitImplParser>>,
         Single<WithoutArgs<ExportStableParser>>,
         Single<WithoutArgs<FfiConstParser>>,
         Single<WithoutArgs<FfiPureParser>>,
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 75e732ff461..0c997c8ee18 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -961,7 +961,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
             no_dups.then_some(list)
         });
 
-    let deny_explicit_impl = attrs.iter().any(|attr| attr.has_name(sym::rustc_deny_explicit_impl));
+    let deny_explicit_impl = find_attr!(attrs, AttributeKind::DenyExplicitImpl(_));
     let implement_via_object =
         !attrs.iter().any(|attr| attr.has_name(sym::rustc_do_not_implement_via_object));
 
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 53346b40e2b..3fc10e31fc6 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -283,6 +283,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_confusables
                 | sym::rustc_skip_during_method_dispatch
                 | sym::rustc_pass_by_value
+                | sym::rustc_deny_explicit_impl
                 | sym::const_trait
                 | sym::repr
                 | sym::align
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 744f93506fe..470b41d9cc7 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -122,7 +122,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             match attr {
                 Attribute::Parsed(
                     AttributeKind::SkipDuringMethodDispatch { span: attr_span, .. }
-                    | AttributeKind::ConstTrait(attr_span),
+                    | AttributeKind::ConstTrait(attr_span)
+                    | AttributeKind::DenyExplicitImpl(attr_span),
                 ) => {
                     self.check_must_be_applied_to_trait(*attr_span, span, target);
                 }
@@ -299,7 +300,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         | [sym::rustc_then_this_would_need, ..] => self.check_rustc_dirty_clean(attr),
                         [sym::rustc_coinductive, ..]
                         | [sym::rustc_must_implement_one_of, ..]
-                        | [sym::rustc_deny_explicit_impl, ..]
                         | [sym::rustc_do_not_implement_via_object, ..]
                         => self.check_must_be_applied_to_trait(attr.span(), span, target),
                         [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target),
-- 
cgit 1.4.1-3-g733a5


From adb325fc163bcb3b4248804309245a6a482dabe2 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 00:22:09 +0300
Subject: Port `#[rustc_do_not_implement_via_object]` to the new attribute
 system

---
 compiler/rustc_attr_data_structures/src/attributes.rs         | 3 +++
 compiler/rustc_attr_data_structures/src/encode_cross_crate.rs | 1 +
 compiler/rustc_attr_parsing/src/attributes/traits.rs          | 7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                    | 4 +++-
 compiler/rustc_hir_analysis/src/collect.rs                    | 3 +--
 compiler/rustc_parse/src/validate_attr.rs                     | 1 +
 compiler/rustc_passes/src/check_attr.rs                       | 4 ++--
 7 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index f554b7a258a..0127cea6505 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -243,6 +243,9 @@ pub enum AttributeKind {
     /// Represents [`#[deprecated]`](https://doc.rust-lang.org/stable/reference/attributes/diagnostics.html#the-deprecated-attribute).
     Deprecation { deprecation: Deprecation, span: Span },
 
+    /// Represents `#[rustc_do_not_implement_via_object]`.
+    DoNotImplementViaObject(Span),
+
     /// Represents [`#[doc]`](https://doc.rust-lang.org/stable/rustdoc/write-documentation/the-doc-attribute.html).
     DocComment { style: AttrStyle, kind: CommentKind, span: Span, comment: Symbol },
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 183a789f636..d2b1edda1a4 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -26,6 +26,7 @@ impl AttributeKind {
             ConstTrait(..) => No,
             DenyExplicitImpl(..) => No,
             Deprecation { .. } => Yes,
+            DoNotImplementViaObject(..) => No,
             DocComment { .. } => Yes,
             Dummy => No,
             ExportName { .. } => Yes,
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index a7c9a77ca8c..3aa7389d1f2 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -68,3 +68,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for DenyExplicitImplParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::DenyExplicitImpl;
 }
+
+pub(crate) struct DoNotImplementViaObjectParser;
+impl<S: Stage> NoArgsAttributeParser<S> for DoNotImplementViaObjectParser {
+    const PATH: &[Symbol] = &[sym::rustc_do_not_implement_via_object];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::DoNotImplementViaObject;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index a6d41de36b6..baa944b8405 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -44,7 +44,8 @@ use crate::attributes::stability::{
 };
 use crate::attributes::test_attrs::IgnoreParser;
 use crate::attributes::traits::{
-    ConstTraitParser, DenyExplicitImplParser, SkipDuringMethodDispatchParser,
+    ConstTraitParser, DenyExplicitImplParser, DoNotImplementViaObjectParser,
+    SkipDuringMethodDispatchParser,
 };
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
@@ -154,6 +155,7 @@ attribute_parsers!(
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
         Single<WithoutArgs<ConstTraitParser>>,
         Single<WithoutArgs<DenyExplicitImplParser>>,
+        Single<WithoutArgs<DoNotImplementViaObjectParser>>,
         Single<WithoutArgs<ExportStableParser>>,
         Single<WithoutArgs<FfiConstParser>>,
         Single<WithoutArgs<FfiPureParser>>,
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 0c997c8ee18..6bc33973541 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -962,8 +962,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
         });
 
     let deny_explicit_impl = find_attr!(attrs, AttributeKind::DenyExplicitImpl(_));
-    let implement_via_object =
-        !attrs.iter().any(|attr| attr.has_name(sym::rustc_do_not_implement_via_object));
+    let implement_via_object = !find_attr!(attrs, AttributeKind::DoNotImplementViaObject(_));
 
     ty::TraitDef {
         def_id: def_id.to_def_id(),
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 3fc10e31fc6..0290f605337 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -284,6 +284,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_skip_during_method_dispatch
                 | sym::rustc_pass_by_value
                 | sym::rustc_deny_explicit_impl
+                | sym::rustc_do_not_implement_via_object
                 | sym::const_trait
                 | sym::repr
                 | sym::align
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 470b41d9cc7..4aaf3b34b71 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -123,7 +123,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 Attribute::Parsed(
                     AttributeKind::SkipDuringMethodDispatch { span: attr_span, .. }
                     | AttributeKind::ConstTrait(attr_span)
-                    | AttributeKind::DenyExplicitImpl(attr_span),
+                    | AttributeKind::DenyExplicitImpl(attr_span)
+                    | AttributeKind::DoNotImplementViaObject(attr_span),
                 ) => {
                     self.check_must_be_applied_to_trait(*attr_span, span, target);
                 }
@@ -300,7 +301,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         | [sym::rustc_then_this_would_need, ..] => self.check_rustc_dirty_clean(attr),
                         [sym::rustc_coinductive, ..]
                         | [sym::rustc_must_implement_one_of, ..]
-                        | [sym::rustc_do_not_implement_via_object, ..]
                         => self.check_must_be_applied_to_trait(attr.span(), span, target),
                         [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target),
                         [sym::must_not_suspend, ..] => self.check_must_not_suspend(attr, span, target),
-- 
cgit 1.4.1-3-g733a5


From 6f8e92d5aaa717773e38c1be547a0c4556ed9145 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 00:27:30 +0300
Subject: Port `#[rustc_coinductive]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs         | 3 +++
 compiler/rustc_attr_data_structures/src/encode_cross_crate.rs | 1 +
 compiler/rustc_attr_parsing/src/attributes/traits.rs          | 7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                    | 3 ++-
 compiler/rustc_hir_analysis/src/collect.rs                    | 2 +-
 compiler/rustc_parse/src/validate_attr.rs                     | 1 +
 compiler/rustc_passes/src/check_attr.rs                       | 5 ++---
 7 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 0127cea6505..f8a3ba093f7 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -211,6 +211,9 @@ pub enum AttributeKind {
         span: Span,
     },
 
+    /// Represents `#[rustc_coinductive]`.
+    Coinductive(Span),
+
     /// Represents `#[cold]`.
     Cold(Span),
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index d2b1edda1a4..d78483b7c09 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -18,6 +18,7 @@ impl AttributeKind {
             AllowInternalUnstable(..) => Yes,
             AsPtr(..) => Yes,
             BodyStability { .. } => No,
+            Coinductive(..) => No,
             Cold(..) => No,
             Confusables { .. } => Yes,
             ConstContinue(..) => No,
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index 3aa7389d1f2..e6f50761caa 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -75,3 +75,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for DoNotImplementViaObjectParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::DoNotImplementViaObject;
 }
+
+pub(crate) struct CoinductiveParser;
+impl<S: Stage> NoArgsAttributeParser<S> for CoinductiveParser {
+    const PATH: &[Symbol] = &[sym::rustc_coinductive];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::Coinductive;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index baa944b8405..c1584cd878f 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -44,7 +44,7 @@ use crate::attributes::stability::{
 };
 use crate::attributes::test_attrs::IgnoreParser;
 use crate::attributes::traits::{
-    ConstTraitParser, DenyExplicitImplParser, DoNotImplementViaObjectParser,
+    CoinductiveParser, ConstTraitParser, DenyExplicitImplParser, DoNotImplementViaObjectParser,
     SkipDuringMethodDispatchParser,
 };
 use crate::attributes::transparency::TransparencyParser;
@@ -150,6 +150,7 @@ attribute_parsers!(
         Single<SkipDuringMethodDispatchParser>,
         Single<TransparencyParser>,
         Single<WithoutArgs<AsPtrParser>>,
+        Single<WithoutArgs<CoinductiveParser>>,
         Single<WithoutArgs<ColdParser>>,
         Single<WithoutArgs<ConstContinueParser>>,
         Single<WithoutArgs<ConstStabilityIndirectParser>>,
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 6bc33973541..e6d6c3fad26 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -868,7 +868,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     // Only regular traits can be marker.
     let is_marker = !is_alias && attrs.iter().any(|attr| attr.has_name(sym::marker));
 
-    let rustc_coinductive = attrs.iter().any(|attr| attr.has_name(sym::rustc_coinductive));
+    let rustc_coinductive = find_attr!(attrs, AttributeKind::Coinductive(_));
     let is_fundamental = attrs.iter().any(|attr| attr.has_name(sym::fundamental));
 
     let [skip_array_during_method_dispatch, skip_boxed_slice_during_method_dispatch] = find_attr!(
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 0290f605337..700f5e78884 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -285,6 +285,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_pass_by_value
                 | sym::rustc_deny_explicit_impl
                 | sym::rustc_do_not_implement_via_object
+                | sym::rustc_coinductive
                 | sym::const_trait
                 | sym::repr
                 | sym::align
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 4aaf3b34b71..2aa3f0f4e00 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -122,6 +122,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             match attr {
                 Attribute::Parsed(
                     AttributeKind::SkipDuringMethodDispatch { span: attr_span, .. }
+                    | AttributeKind::Coinductive(attr_span)
                     | AttributeKind::ConstTrait(attr_span)
                     | AttributeKind::DenyExplicitImpl(attr_span)
                     | AttributeKind::DoNotImplementViaObject(attr_span),
@@ -299,9 +300,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         | [sym::rustc_dirty, ..]
                         | [sym::rustc_if_this_changed, ..]
                         | [sym::rustc_then_this_would_need, ..] => self.check_rustc_dirty_clean(attr),
-                        [sym::rustc_coinductive, ..]
-                        | [sym::rustc_must_implement_one_of, ..]
-                        => self.check_must_be_applied_to_trait(attr.span(), span, target),
+                        [sym::rustc_must_implement_one_of, ..] => self.check_must_be_applied_to_trait(attr.span(), span, target),
                         [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target),
                         [sym::must_not_suspend, ..] => self.check_must_not_suspend(attr, span, target),
                         [sym::rustc_allow_incoherent_impl, ..] => {
-- 
cgit 1.4.1-3-g733a5


From 813ec60744a4cc85740b73fb5bc2aba14bce41da Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 00:51:16 +0300
Subject: Port `#[type_const]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs  |  3 +++
 .../src/encode_cross_crate.rs                          |  1 +
 compiler/rustc_attr_parsing/src/attributes/traits.rs   |  7 +++++++
 compiler/rustc_attr_parsing/src/context.rs             |  3 ++-
 compiler/rustc_middle/src/ty/assoc.rs                  |  5 +++--
 compiler/rustc_parse/src/validate_attr.rs              |  1 +
 compiler/rustc_passes/src/check_attr.rs                | 10 +++++-----
 tests/ui/attributes/malformed-attrs.stderr             | 15 +++++++++------
 .../const-generics/mgca/bad-type_const-syntax.stderr   | 18 +++++++++++-------
 9 files changed, 42 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index f8a3ba093f7..dd301fdfb12 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -359,6 +359,9 @@ pub enum AttributeKind {
     /// Represents `#[track_caller]`
     TrackCaller(Span),
 
+    /// Represents `#[type_const]`.
+    TypeConst(Span),
+
     /// Represents `#[used]`
     Used { used_by: UsedBy, span: Span },
     // tidy-alphabetical-end
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index d78483b7c09..08e5e971a7d 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -59,6 +59,7 @@ impl AttributeKind {
             StdInternalSymbol(..) => No,
             TargetFeature(..) => No,
             TrackCaller(..) => Yes,
+            TypeConst(..) => Yes,
             Used { .. } => No,
             // tidy-alphabetical-end
         }
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index e6f50761caa..5f9d182b00f 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -82,3 +82,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for CoinductiveParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::Coinductive;
 }
+
+pub(crate) struct TypeConstParser;
+impl<S: Stage> NoArgsAttributeParser<S> for TypeConstParser {
+    const PATH: &[Symbol] = &[sym::type_const];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::TypeConst;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index c1584cd878f..f86f5c7a1f4 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -45,7 +45,7 @@ use crate::attributes::stability::{
 use crate::attributes::test_attrs::IgnoreParser;
 use crate::attributes::traits::{
     CoinductiveParser, ConstTraitParser, DenyExplicitImplParser, DoNotImplementViaObjectParser,
-    SkipDuringMethodDispatchParser,
+    SkipDuringMethodDispatchParser, TypeConstParser,
 };
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
@@ -169,6 +169,7 @@ attribute_parsers!(
         Single<WithoutArgs<PubTransparentParser>>,
         Single<WithoutArgs<StdInternalSymbolParser>>,
         Single<WithoutArgs<TrackCallerParser>>,
+        Single<WithoutArgs<TypeConstParser>>,
         // tidy-alphabetical-end
     ];
 );
diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs
index 78b2e265b48..344a81f5e24 100644
--- a/compiler/rustc_middle/src/ty/assoc.rs
+++ b/compiler/rustc_middle/src/ty/assoc.rs
@@ -1,9 +1,10 @@
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::sorted_map::SortedIndexMultiMap;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Namespace};
 use rustc_hir::def_id::DefId;
 use rustc_macros::{Decodable, Encodable, HashStable};
-use rustc_span::{Ident, Symbol, sym};
+use rustc_span::{Ident, Symbol};
 
 use super::{TyCtxt, Visibility};
 use crate::ty;
@@ -160,7 +161,7 @@ impl AssocItem {
             // Inherent impl but this attr is only applied to trait assoc items.
             (AssocItemContainer::Impl, None) => return true,
         };
-        tcx.has_attr(def_id, sym::type_const)
+        find_attr!(tcx.get_all_attrs(def_id), AttributeKind::TypeConst(_))
     }
 }
 
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 700f5e78884..50a0366d9fe 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -287,6 +287,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_do_not_implement_via_object
                 | sym::rustc_coinductive
                 | sym::const_trait
+                | sym::type_const
                 | sym::repr
                 | sym::align
                 | sym::deprecated
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2aa3f0f4e00..0951c49de11 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -129,6 +129,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 ) => {
                     self.check_must_be_applied_to_trait(*attr_span, span, target);
                 }
+                &Attribute::Parsed(AttributeKind::TypeConst(attr_span)) => {
+                    self.check_type_const(hir_id, attr_span, target)
+                }
                 Attribute::Parsed(AttributeKind::Confusables { first_span, .. }) => {
                     self.check_confusables(*first_span, target);
                 }
@@ -338,9 +341,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::coroutine, ..] => {
                             self.check_coroutine(attr, target);
                         }
-                        [sym::type_const, ..] => {
-                            self.check_type_const(hir_id,attr, target);
-                        }
                         [sym::linkage, ..] => self.check_linkage(attr, span, target),
                         [
                             // ok
@@ -2513,7 +2513,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    fn check_type_const(&self, hir_id: HirId, attr: &Attribute, target: Target) {
+    fn check_type_const(&self, hir_id: HirId, attr_span: Span, target: Target) {
         let tcx = self.tcx;
         if target == Target::AssocConst
             && let parent = tcx.parent(hir_id.expect_owner().to_def_id())
@@ -2523,7 +2523,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         } else {
             self.dcx()
                 .struct_span_err(
-                    attr.span(),
+                    attr_span,
                     "`#[type_const]` must only be applied to trait associated constants",
                 )
                 .emit();
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index 5bcb0c4dc0a..ef5dcf7b2a0 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -116,12 +116,6 @@ error: malformed `cfi_encoding` attribute input
 LL | #[cfi_encoding]
    | ^^^^^^^^^^^^^^^ help: must be of the form: `#[cfi_encoding = "encoding"]`
 
-error: malformed `type_const` attribute input
-  --> $DIR/malformed-attrs.rs:143:5
-   |
-LL |     #[type_const = 1]
-   |     ^^^^^^^^^^^^^^^^^ help: must be of the form: `#[type_const]`
-
 error: malformed `marker` attribute input
   --> $DIR/malformed-attrs.rs:155:1
    |
@@ -555,6 +549,15 @@ LL | #[non_exhaustive = 1]
    | |                didn't expect any arguments here
    | help: must be of the form: `#[non_exhaustive]`
 
+error[E0565]: malformed `type_const` attribute input
+  --> $DIR/malformed-attrs.rs:143:5
+   |
+LL |     #[type_const = 1]
+   |     ^^^^^^^^^^^^^---^
+   |     |            |
+   |     |            didn't expect any arguments here
+   |     help: must be of the form: `#[type_const]`
+
 error: attribute should be applied to `const fn`
   --> $DIR/malformed-attrs.rs:34:1
    |
diff --git a/tests/ui/const-generics/mgca/bad-type_const-syntax.stderr b/tests/ui/const-generics/mgca/bad-type_const-syntax.stderr
index 579aff849d6..125c778ef1c 100644
--- a/tests/ui/const-generics/mgca/bad-type_const-syntax.stderr
+++ b/tests/ui/const-generics/mgca/bad-type_const-syntax.stderr
@@ -1,9 +1,3 @@
-error: malformed `type_const` attribute input
-  --> $DIR/bad-type_const-syntax.rs:2:5
-   |
-LL |     #[type_const()]
-   |     ^^^^^^^^^^^^^^^ help: must be of the form: `#[type_const]`
-
 error[E0658]: the `#[type_const]` attribute is an experimental feature
   --> $DIR/bad-type_const-syntax.rs:2:5
    |
@@ -24,6 +18,15 @@ LL |     #[type_const]
    = help: add `#![feature(min_generic_const_args)]` 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[E0565]: malformed `type_const` attribute input
+  --> $DIR/bad-type_const-syntax.rs:2:5
+   |
+LL |     #[type_const()]
+   |     ^^^^^^^^^^^^--^
+   |     |           |
+   |     |           didn't expect any arguments here
+   |     help: must be of the form: `#[type_const]`
+
 error: `#[type_const]` must only be applied to trait associated constants
   --> $DIR/bad-type_const-syntax.rs:11:5
    |
@@ -32,4 +35,5 @@ LL |     #[type_const]
 
 error: aborting due to 4 previous errors
 
-For more information about this error, try `rustc --explain E0658`.
+Some errors have detailed explanations: E0565, E0658.
+For more information about an error, try `rustc --explain E0565`.
-- 
cgit 1.4.1-3-g733a5


From 61937839616b89838afe77a0a9d14c70d51a3f09 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 01:29:44 +0300
Subject: Port `#[rustc_specialization_trait]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs         | 3 +++
 compiler/rustc_attr_data_structures/src/encode_cross_crate.rs | 1 +
 compiler/rustc_attr_parsing/src/attributes/traits.rs          | 7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                    | 3 ++-
 compiler/rustc_hir_analysis/src/collect.rs                    | 2 +-
 compiler/rustc_parse/src/validate_attr.rs                     | 1 +
 compiler/rustc_passes/src/check_attr.rs                       | 3 ++-
 7 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index dd301fdfb12..fe947c778b5 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -343,6 +343,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_skip_during_method_dispatch]`.
     SkipDuringMethodDispatch { array: bool, boxed_slice: bool, span: Span },
 
+    /// Represents `#[rustc_specialization_trait]`.
+    SpecializationTrait(Span),
+
     /// Represents `#[stable]`, `#[unstable]` and `#[rustc_allowed_through_unstable_modules]`.
     Stability {
         stability: Stability,
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 08e5e971a7d..8833f6102db 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -55,6 +55,7 @@ impl AttributeKind {
             RustcLayoutScalarValidRangeStart(..) => Yes,
             RustcObjectLifetimeDefault => No,
             SkipDuringMethodDispatch { .. } => No,
+            SpecializationTrait(..) => No,
             Stability { .. } => Yes,
             StdInternalSymbol(..) => No,
             TargetFeature(..) => No,
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index 5f9d182b00f..d5aabea6823 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -89,3 +89,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for TypeConstParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::TypeConst;
 }
+
+pub(crate) struct SpecializationTraitParser;
+impl<S: Stage> NoArgsAttributeParser<S> for SpecializationTraitParser {
+    const PATH: &[Symbol] = &[sym::rustc_specialization_trait];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::SpecializationTrait;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index f86f5c7a1f4..f9a4b3e9a26 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -45,7 +45,7 @@ use crate::attributes::stability::{
 use crate::attributes::test_attrs::IgnoreParser;
 use crate::attributes::traits::{
     CoinductiveParser, ConstTraitParser, DenyExplicitImplParser, DoNotImplementViaObjectParser,
-    SkipDuringMethodDispatchParser, TypeConstParser,
+    SkipDuringMethodDispatchParser, SpecializationTraitParser, TypeConstParser,
 };
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
@@ -167,6 +167,7 @@ attribute_parsers!(
         Single<WithoutArgs<NonExhaustiveParser>>,
         Single<WithoutArgs<PassByValueParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
+        Single<WithoutArgs<SpecializationTraitParser>>,
         Single<WithoutArgs<StdInternalSymbolParser>>,
         Single<WithoutArgs<TrackCallerParser>>,
         Single<WithoutArgs<TypeConstParser>>,
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index e6d6c3fad26..7f3900e72be 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -880,7 +880,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     let specialization_kind =
         if attrs.iter().any(|attr| attr.has_name(sym::rustc_unsafe_specialization_marker)) {
             ty::trait_def::TraitSpecializationKind::Marker
-        } else if attrs.iter().any(|attr| attr.has_name(sym::rustc_specialization_trait)) {
+        } else if find_attr!(attrs, AttributeKind::SpecializationTrait(_)) {
             ty::trait_def::TraitSpecializationKind::AlwaysApplicable
         } else {
             ty::trait_def::TraitSpecializationKind::None
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 50a0366d9fe..7dbf3238215 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -287,6 +287,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_do_not_implement_via_object
                 | sym::rustc_coinductive
                 | sym::const_trait
+                | sym::rustc_specialization_trait
                 | sym::type_const
                 | sym::repr
                 | sym::align
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 0951c49de11..6e3ec5584d4 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -125,7 +125,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::Coinductive(attr_span)
                     | AttributeKind::ConstTrait(attr_span)
                     | AttributeKind::DenyExplicitImpl(attr_span)
-                    | AttributeKind::DoNotImplementViaObject(attr_span),
+                    | AttributeKind::DoNotImplementViaObject(attr_span)
+                    | AttributeKind::SpecializationTrait(attr_span),
                 ) => {
                     self.check_must_be_applied_to_trait(*attr_span, span, target);
                 }
-- 
cgit 1.4.1-3-g733a5


From a57a885abc342cf0fec0521da21b295f8694f75e Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 01:41:19 +0300
Subject: Port `#[rustc_unsafe_specialization_marker]` to the new attribute
 system

---
 compiler/rustc_attr_data_structures/src/attributes.rs     |  3 +++
 .../rustc_attr_data_structures/src/encode_cross_crate.rs  |  1 +
 compiler/rustc_attr_parsing/src/attributes/traits.rs      |  7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                |  2 ++
 compiler/rustc_hir_analysis/src/collect.rs                | 15 +++++++--------
 compiler/rustc_parse/src/validate_attr.rs                 |  1 +
 compiler/rustc_passes/src/check_attr.rs                   | 10 ++++++++--
 7 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index fe947c778b5..9d924023e72 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -365,6 +365,9 @@ pub enum AttributeKind {
     /// Represents `#[type_const]`.
     TypeConst(Span),
 
+    /// Represents `#[rustc_unsafe_specialization_marker]`.
+    UnsafeSpecializationMarker(Span),
+
     /// Represents `#[used]`
     Used { used_by: UsedBy, span: Span },
     // tidy-alphabetical-end
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 8833f6102db..5811cfa60c1 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -61,6 +61,7 @@ impl AttributeKind {
             TargetFeature(..) => No,
             TrackCaller(..) => Yes,
             TypeConst(..) => Yes,
+            UnsafeSpecializationMarker(..) => No,
             Used { .. } => No,
             // tidy-alphabetical-end
         }
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index d5aabea6823..a9e6f1f3a33 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -96,3 +96,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for SpecializationTraitParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::SpecializationTrait;
 }
+
+pub(crate) struct UnsafeSpecializationMarkerParser;
+impl<S: Stage> NoArgsAttributeParser<S> for UnsafeSpecializationMarkerParser {
+    const PATH: &[Symbol] = &[sym::rustc_unsafe_specialization_marker];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::UnsafeSpecializationMarker;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index f9a4b3e9a26..fe8ac2c532a 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -46,6 +46,7 @@ use crate::attributes::test_attrs::IgnoreParser;
 use crate::attributes::traits::{
     CoinductiveParser, ConstTraitParser, DenyExplicitImplParser, DoNotImplementViaObjectParser,
     SkipDuringMethodDispatchParser, SpecializationTraitParser, TypeConstParser,
+    UnsafeSpecializationMarkerParser,
 };
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
@@ -171,6 +172,7 @@ attribute_parsers!(
         Single<WithoutArgs<StdInternalSymbolParser>>,
         Single<WithoutArgs<TrackCallerParser>>,
         Single<WithoutArgs<TypeConstParser>>,
+        Single<WithoutArgs<UnsafeSpecializationMarkerParser>>,
         // tidy-alphabetical-end
     ];
 );
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 7f3900e72be..f0db98832d9 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -877,14 +877,13 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     )
     .unwrap_or([false; 2]);
 
-    let specialization_kind =
-        if attrs.iter().any(|attr| attr.has_name(sym::rustc_unsafe_specialization_marker)) {
-            ty::trait_def::TraitSpecializationKind::Marker
-        } else if find_attr!(attrs, AttributeKind::SpecializationTrait(_)) {
-            ty::trait_def::TraitSpecializationKind::AlwaysApplicable
-        } else {
-            ty::trait_def::TraitSpecializationKind::None
-        };
+    let specialization_kind = if find_attr!(attrs, AttributeKind::UnsafeSpecializationMarker(_)) {
+        ty::trait_def::TraitSpecializationKind::Marker
+    } else if find_attr!(attrs, AttributeKind::SpecializationTrait(_)) {
+        ty::trait_def::TraitSpecializationKind::AlwaysApplicable
+    } else {
+        ty::trait_def::TraitSpecializationKind::None
+    };
     let must_implement_one_of = attrs
         .iter()
         .find(|attr| attr.has_name(sym::rustc_must_implement_one_of))
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 7dbf3238215..6efa9edfa07 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -288,6 +288,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_coinductive
                 | sym::const_trait
                 | sym::rustc_specialization_trait
+                | sym::rustc_unsafe_specialization_marker
                 | sym::type_const
                 | sym::repr
                 | sym::align
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 6e3ec5584d4..7d30c36b463 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -125,11 +125,17 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::Coinductive(attr_span)
                     | AttributeKind::ConstTrait(attr_span)
                     | AttributeKind::DenyExplicitImpl(attr_span)
-                    | AttributeKind::DoNotImplementViaObject(attr_span)
-                    | AttributeKind::SpecializationTrait(attr_span),
+                    | AttributeKind::DoNotImplementViaObject(attr_span),
                 ) => {
                     self.check_must_be_applied_to_trait(*attr_span, span, target);
                 }
+                &Attribute::Parsed(
+                    AttributeKind::SpecializationTrait(attr_span)
+                    | AttributeKind::UnsafeSpecializationMarker(attr_span),
+                ) => {
+                    // FIXME(specialization): more validation is needed
+                    self.check_must_be_applied_to_trait(attr_span, span, target);
+                }
                 &Attribute::Parsed(AttributeKind::TypeConst(attr_span)) => {
                     self.check_type_const(hir_id, attr_span, target)
                 }
-- 
cgit 1.4.1-3-g733a5


From 12f6487d79199c660edfba58cfcdc34e717b9abc Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 01:49:26 +0300
Subject: Port `#[marker]` to the new attribute system

---
 .../rustc_attr_data_structures/src/attributes.rs   |  3 +++
 .../src/encode_cross_crate.rs                      |  1 +
 .../rustc_attr_parsing/src/attributes/traits.rs    |  7 +++++++
 compiler/rustc_attr_parsing/src/context.rs         |  3 ++-
 compiler/rustc_hir_analysis/src/collect.rs         |  2 +-
 compiler/rustc_parse/src/validate_attr.rs          |  1 +
 compiler/rustc_passes/src/check_attr.rs            | 14 +++++++-------
 tests/ui/attributes/malformed-attrs.stderr         | 15 +++++++++------
 .../marker-attribute-with-values.stderr            | 22 ++++++++++++++++------
 9 files changed, 47 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 9d924023e72..91eee14b8ea 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -294,6 +294,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_macro_transparency]`.
     MacroTransparency(Transparency),
 
+    /// Represents `#[marker]`.
+    Marker(Span),
+
     /// Represents [`#[may_dangle]`](https://std-dev-guide.rust-lang.org/tricky/may-dangle.html).
     MayDangle(Span),
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 5811cfa60c1..f326bbf41f2 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -40,6 +40,7 @@ impl AttributeKind {
             LinkSection { .. } => No,
             LoopMatch(..) => No,
             MacroTransparency(..) => Yes,
+            Marker(..) => No,
             MayDangle(..) => No,
             MustUse { .. } => Yes,
             Naked(..) => No,
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index a9e6f1f3a33..44b916b4cb3 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -103,3 +103,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for UnsafeSpecializationMarkerParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::UnsafeSpecializationMarker;
 }
+
+pub(crate) struct MarkerParser;
+impl<S: Stage> NoArgsAttributeParser<S> for MarkerParser {
+    const PATH: &[Symbol] = &[sym::marker];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::Marker;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index fe8ac2c532a..edfb013fe0c 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -45,7 +45,7 @@ use crate::attributes::stability::{
 use crate::attributes::test_attrs::IgnoreParser;
 use crate::attributes::traits::{
     CoinductiveParser, ConstTraitParser, DenyExplicitImplParser, DoNotImplementViaObjectParser,
-    SkipDuringMethodDispatchParser, SpecializationTraitParser, TypeConstParser,
+    MarkerParser, SkipDuringMethodDispatchParser, SpecializationTraitParser, TypeConstParser,
     UnsafeSpecializationMarkerParser,
 };
 use crate::attributes::transparency::TransparencyParser;
@@ -162,6 +162,7 @@ attribute_parsers!(
         Single<WithoutArgs<FfiConstParser>>,
         Single<WithoutArgs<FfiPureParser>>,
         Single<WithoutArgs<LoopMatchParser>>,
+        Single<WithoutArgs<MarkerParser>>,
         Single<WithoutArgs<MayDangleParser>>,
         Single<WithoutArgs<NoImplicitPreludeParser>>,
         Single<WithoutArgs<NoMangleParser>>,
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index f0db98832d9..b5c7bfeed9b 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -866,7 +866,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     }
 
     // Only regular traits can be marker.
-    let is_marker = !is_alias && attrs.iter().any(|attr| attr.has_name(sym::marker));
+    let is_marker = !is_alias && find_attr!(attrs, AttributeKind::Marker(_));
 
     let rustc_coinductive = find_attr!(attrs, AttributeKind::Coinductive(_));
     let is_fundamental = attrs.iter().any(|attr| attr.has_name(sym::fundamental));
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 6efa9edfa07..89670674042 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -289,6 +289,7 @@ pub fn check_builtin_meta_item(
                 | sym::const_trait
                 | sym::rustc_specialization_trait
                 | sym::rustc_unsafe_specialization_marker
+                | sym::marker
                 | sym::type_const
                 | sym::repr
                 | sym::align
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 7d30c36b463..7eedc748bd6 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -139,6 +139,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 &Attribute::Parsed(AttributeKind::TypeConst(attr_span)) => {
                     self.check_type_const(hir_id, attr_span, target)
                 }
+                &Attribute::Parsed(AttributeKind::Marker(attr_span)) => {
+                    self.check_marker(hir_id, attr_span, span, target)
+                }
                 Attribute::Parsed(AttributeKind::Confusables { first_span, .. }) => {
                     self.check_confusables(*first_span, target);
                 }
@@ -272,7 +275,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::no_sanitize, ..] => {
                             self.check_no_sanitize(attr, span, target)
                         }
-                        [sym::marker, ..] => self.check_marker(hir_id, attr, span, target),
                         [sym::thread_local, ..] => self.check_thread_local(attr, span, target),
                         [sym::doc, ..] => self.check_doc_attrs(
                             attr,
@@ -836,7 +838,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     }
 
     /// Checks if the `#[marker]` attribute on an `item` is valid.
-    fn check_marker(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
+    fn check_marker(&self, hir_id: HirId, attr_span: Span, span: Span, target: Target) {
         match target {
             Target::Trait => {}
             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
@@ -844,13 +846,11 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             // erroneously allowed it and some crates used it accidentally, to be compatible
             // with crates depending on them, we can't throw an error here.
             Target::Field | Target::Arm | Target::MacroDef => {
-                self.inline_attr_str_error_with_macro_def(hir_id, attr.span(), "marker");
+                self.inline_attr_str_error_with_macro_def(hir_id, attr_span, "marker");
             }
             _ => {
-                self.dcx().emit_err(errors::AttrShouldBeAppliedToTrait {
-                    attr_span: attr.span(),
-                    defn_span: span,
-                });
+                self.dcx()
+                    .emit_err(errors::AttrShouldBeAppliedToTrait { attr_span, defn_span: span });
             }
         }
     }
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index ef5dcf7b2a0..aef54248bb6 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -116,12 +116,6 @@ error: malformed `cfi_encoding` attribute input
 LL | #[cfi_encoding]
    | ^^^^^^^^^^^^^^^ help: must be of the form: `#[cfi_encoding = "encoding"]`
 
-error: malformed `marker` attribute input
-  --> $DIR/malformed-attrs.rs:155:1
-   |
-LL | #[marker = 3]
-   | ^^^^^^^^^^^^^ help: must be of the form: `#[marker]`
-
 error: malformed `fundamental` attribute input
   --> $DIR/malformed-attrs.rs:157:1
    |
@@ -522,6 +516,15 @@ LL | #[rustc_layout_scalar_valid_range_end]
    | expected this to be a list
    | help: must be of the form: `#[rustc_layout_scalar_valid_range_end(end)]`
 
+error[E0565]: malformed `marker` attribute input
+  --> $DIR/malformed-attrs.rs:155:1
+   |
+LL | #[marker = 3]
+   | ^^^^^^^^^---^
+   | |        |
+   | |        didn't expect any arguments here
+   | help: must be of the form: `#[marker]`
+
 error[E0565]: malformed `ffi_pure` attribute input
   --> $DIR/malformed-attrs.rs:165:5
    |
diff --git a/tests/ui/marker_trait_attr/marker-attribute-with-values.stderr b/tests/ui/marker_trait_attr/marker-attribute-with-values.stderr
index 6f9c9508e7e..9a2e5add37b 100644
--- a/tests/ui/marker_trait_attr/marker-attribute-with-values.stderr
+++ b/tests/ui/marker_trait_attr/marker-attribute-with-values.stderr
@@ -1,20 +1,30 @@
-error: malformed `marker` attribute input
+error[E0565]: malformed `marker` attribute input
   --> $DIR/marker-attribute-with-values.rs:3:1
    |
 LL | #[marker(always)]
-   | ^^^^^^^^^^^^^^^^^ help: must be of the form: `#[marker]`
+   | ^^^^^^^^--------^
+   | |       |
+   | |       didn't expect any arguments here
+   | help: must be of the form: `#[marker]`
 
-error: malformed `marker` attribute input
+error[E0565]: malformed `marker` attribute input
   --> $DIR/marker-attribute-with-values.rs:6:1
    |
 LL | #[marker("never")]
-   | ^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[marker]`
+   | ^^^^^^^^---------^
+   | |       |
+   | |       didn't expect any arguments here
+   | help: must be of the form: `#[marker]`
 
-error: malformed `marker` attribute input
+error[E0565]: malformed `marker` attribute input
   --> $DIR/marker-attribute-with-values.rs:9:1
    |
 LL | #[marker(key = "value")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[marker]`
+   | ^^^^^^^^---------------^
+   | |       |
+   | |       didn't expect any arguments here
+   | help: must be of the form: `#[marker]`
 
 error: aborting due to 3 previous errors
 
+For more information about this error, try `rustc --explain E0565`.
-- 
cgit 1.4.1-3-g733a5


From 507ebced1693e4671db3f059caf24d7a4a9c6d28 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 01:58:53 +0300
Subject: Port `#[fundamental]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs     |  3 +++
 .../rustc_attr_data_structures/src/encode_cross_crate.rs  |  1 +
 compiler/rustc_attr_parsing/src/attributes/traits.rs      |  7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                |  5 +++--
 compiler/rustc_hir_analysis/src/collect.rs                |  2 +-
 compiler/rustc_middle/src/ty/adt.rs                       |  3 +--
 compiler/rustc_parse/src/validate_attr.rs                 |  1 +
 compiler/rustc_passes/src/check_attr.rs                   |  4 +++-
 tests/ui/attributes/malformed-attrs.stderr                | 15 +++++++++------
 9 files changed, 29 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 91eee14b8ea..36a8bf87eee 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -272,6 +272,9 @@ pub enum AttributeKind {
     /// Represents `#[ffi_pure]`.
     FfiPure(Span),
 
+    /// Represents `#[fundamental]`.
+    Fundamental,
+
     /// Represents `#[ignore]`
     Ignore {
         span: Span,
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index f326bbf41f2..9747f85c128 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -34,6 +34,7 @@ impl AttributeKind {
             ExportStable => No,
             FfiConst(..) => No,
             FfiPure(..) => No,
+            Fundamental { .. } => Yes,
             Ignore { .. } => No,
             Inline(..) => No,
             LinkName { .. } => Yes,
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index 44b916b4cb3..0059698f4ad 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -110,3 +110,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for MarkerParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::Marker;
 }
+
+pub(crate) struct FundamentalParser;
+impl<S: Stage> NoArgsAttributeParser<S> for FundamentalParser {
+    const PATH: &[Symbol] = &[sym::fundamental];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::Fundamental;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index edfb013fe0c..cf7dfa8157b 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -45,8 +45,8 @@ use crate::attributes::stability::{
 use crate::attributes::test_attrs::IgnoreParser;
 use crate::attributes::traits::{
     CoinductiveParser, ConstTraitParser, DenyExplicitImplParser, DoNotImplementViaObjectParser,
-    MarkerParser, SkipDuringMethodDispatchParser, SpecializationTraitParser, TypeConstParser,
-    UnsafeSpecializationMarkerParser,
+    FundamentalParser, MarkerParser, SkipDuringMethodDispatchParser, SpecializationTraitParser,
+    TypeConstParser, UnsafeSpecializationMarkerParser,
 };
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
@@ -161,6 +161,7 @@ attribute_parsers!(
         Single<WithoutArgs<ExportStableParser>>,
         Single<WithoutArgs<FfiConstParser>>,
         Single<WithoutArgs<FfiPureParser>>,
+        Single<WithoutArgs<FundamentalParser>>,
         Single<WithoutArgs<LoopMatchParser>>,
         Single<WithoutArgs<MarkerParser>>,
         Single<WithoutArgs<MayDangleParser>>,
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index b5c7bfeed9b..415ff2d26bb 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -869,7 +869,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     let is_marker = !is_alias && find_attr!(attrs, AttributeKind::Marker(_));
 
     let rustc_coinductive = find_attr!(attrs, AttributeKind::Coinductive(_));
-    let is_fundamental = attrs.iter().any(|attr| attr.has_name(sym::fundamental));
+    let is_fundamental = find_attr!(attrs, AttributeKind::Fundamental);
 
     let [skip_array_during_method_dispatch, skip_boxed_slice_during_method_dispatch] = find_attr!(
         attrs,
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
index 44165b06f1c..275458fc85f 100644
--- a/compiler/rustc_middle/src/ty/adt.rs
+++ b/compiler/rustc_middle/src/ty/adt.rs
@@ -17,7 +17,6 @@ use rustc_index::{IndexSlice, IndexVec};
 use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_query_system::ich::StableHashingContext;
 use rustc_session::DataTypeKind;
-use rustc_span::sym;
 use rustc_type_ir::solve::AdtDestructorKind;
 use tracing::{debug, info, trace};
 
@@ -296,7 +295,7 @@ impl AdtDefData {
             flags |= AdtFlags::HAS_CTOR;
         }
 
-        if tcx.has_attr(did, sym::fundamental) {
+        if find_attr!(tcx.get_all_attrs(did), AttributeKind::Fundamental) {
             flags |= AdtFlags::IS_FUNDAMENTAL;
         }
         if tcx.is_lang_item(did, LangItem::PhantomData) {
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 89670674042..d415b3241c9 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -290,6 +290,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_specialization_trait
                 | sym::rustc_unsafe_specialization_marker
                 | sym::marker
+                | sym::fundamental
                 | sym::type_const
                 | sym::repr
                 | sym::align
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 7eedc748bd6..776939e6886 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -142,6 +142,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 &Attribute::Parsed(AttributeKind::Marker(attr_span)) => {
                     self.check_marker(hir_id, attr_span, span, target)
                 }
+                Attribute::Parsed(AttributeKind::Fundamental) => {
+                    // FIXME: add validation
+                }
                 Attribute::Parsed(AttributeKind::Confusables { first_span, .. }) => {
                     self.check_confusables(*first_span, target);
                 }
@@ -374,7 +377,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             | sym::prelude_import
                             | sym::panic_handler
                             | sym::allow_internal_unsafe
-                            | sym::fundamental
                             | sym::lang
                             | sym::needs_allocator
                             | sym::default_lib_allocator
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index aef54248bb6..be529df3a49 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -116,12 +116,6 @@ error: malformed `cfi_encoding` attribute input
 LL | #[cfi_encoding]
    | ^^^^^^^^^^^^^^^ help: must be of the form: `#[cfi_encoding = "encoding"]`
 
-error: malformed `fundamental` attribute input
-  --> $DIR/malformed-attrs.rs:157:1
-   |
-LL | #[fundamental()]
-   | ^^^^^^^^^^^^^^^^ help: must be of the form: `#[fundamental]`
-
 error: malformed `link_ordinal` attribute input
   --> $DIR/malformed-attrs.rs:167:5
    |
@@ -525,6 +519,15 @@ LL | #[marker = 3]
    | |        didn't expect any arguments here
    | help: must be of the form: `#[marker]`
 
+error[E0565]: malformed `fundamental` attribute input
+  --> $DIR/malformed-attrs.rs:157:1
+   |
+LL | #[fundamental()]
+   | ^^^^^^^^^^^^^--^
+   | |            |
+   | |            didn't expect any arguments here
+   | help: must be of the form: `#[fundamental]`
+
 error[E0565]: malformed `ffi_pure` attribute input
   --> $DIR/malformed-attrs.rs:165:5
    |
-- 
cgit 1.4.1-3-g733a5


From 1bdf70317165de715fd320042d6502aa25f5aabf Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 02:06:57 +0300
Subject: Port `#[rustc_paren_sugar]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs         | 3 +++
 compiler/rustc_attr_data_structures/src/encode_cross_crate.rs | 1 +
 compiler/rustc_attr_parsing/src/attributes/traits.rs          | 7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                    | 5 +++--
 compiler/rustc_hir_analysis/src/collect.rs                    | 2 +-
 compiler/rustc_parse/src/validate_attr.rs                     | 1 +
 compiler/rustc_passes/src/check_attr.rs                       | 5 +++--
 7 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 36a8bf87eee..de2bbcceac4 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -325,6 +325,9 @@ pub enum AttributeKind {
     /// Represents `#[optimize(size|speed)]`
     Optimize(OptimizeAttr, Span),
 
+    /// Represents `#[rustc_paren_sugar]`.
+    ParenSugar(Span),
+
     /// Represents `#[rustc_pass_by_value]` (used by the `rustc_pass_by_value` lint).
     PassByValue(Span),
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 9747f85c128..99b3ae9b9cd 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -49,6 +49,7 @@ impl AttributeKind {
             NoMangle(..) => No,
             NonExhaustive(..) => Yes,
             Optimize(..) => No,
+            ParenSugar(..) => No,
             PassByValue(..) => Yes,
             Path(..) => No,
             PubTransparent(..) => Yes,
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index 0059698f4ad..362625abe7d 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -117,3 +117,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for FundamentalParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::Fundamental;
 }
+
+pub(crate) struct ParenSugarParser;
+impl<S: Stage> NoArgsAttributeParser<S> for ParenSugarParser {
+    const PATH: &[Symbol] = &[sym::rustc_paren_sugar];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::ParenSugar;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index cf7dfa8157b..4d618c171c8 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -45,8 +45,8 @@ use crate::attributes::stability::{
 use crate::attributes::test_attrs::IgnoreParser;
 use crate::attributes::traits::{
     CoinductiveParser, ConstTraitParser, DenyExplicitImplParser, DoNotImplementViaObjectParser,
-    FundamentalParser, MarkerParser, SkipDuringMethodDispatchParser, SpecializationTraitParser,
-    TypeConstParser, UnsafeSpecializationMarkerParser,
+    FundamentalParser, MarkerParser, ParenSugarParser, SkipDuringMethodDispatchParser,
+    SpecializationTraitParser, TypeConstParser, UnsafeSpecializationMarkerParser,
 };
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
@@ -168,6 +168,7 @@ attribute_parsers!(
         Single<WithoutArgs<NoImplicitPreludeParser>>,
         Single<WithoutArgs<NoMangleParser>>,
         Single<WithoutArgs<NonExhaustiveParser>>,
+        Single<WithoutArgs<ParenSugarParser>>,
         Single<WithoutArgs<PassByValueParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
         Single<WithoutArgs<SpecializationTraitParser>>,
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 415ff2d26bb..431d99a572d 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -860,7 +860,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
         hir::Constness::NotConst
     };
 
-    let paren_sugar = attrs.iter().any(|attr| attr.has_name(sym::rustc_paren_sugar));
+    let paren_sugar = find_attr!(attrs, AttributeKind::ParenSugar(_));
     if paren_sugar && !tcx.features().unboxed_closures() {
         tcx.dcx().emit_err(errors::ParenSugarAttribute { span: item.span });
     }
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index d415b3241c9..ce7a7cd0a93 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -291,6 +291,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_unsafe_specialization_marker
                 | sym::marker
                 | sym::fundamental
+                | sym::rustc_paren_sugar
                 | sym::type_const
                 | sym::repr
                 | sym::align
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 776939e6886..567b0423d52 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -131,9 +131,10 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 }
                 &Attribute::Parsed(
                     AttributeKind::SpecializationTrait(attr_span)
-                    | AttributeKind::UnsafeSpecializationMarker(attr_span),
+                    | AttributeKind::UnsafeSpecializationMarker(attr_span)
+                    | AttributeKind::ParenSugar(attr_span),
                 ) => {
-                    // FIXME(specialization): more validation is needed
+                    // FIXME: more validation is needed
                     self.check_must_be_applied_to_trait(attr_span, span, target);
                 }
                 &Attribute::Parsed(AttributeKind::TypeConst(attr_span)) => {
-- 
cgit 1.4.1-3-g733a5


From a6bc8160d64df15ddf08fd9bdcc13d2c5f1028e0 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 23:41:07 +0300
Subject: Reorder attribute parsers in `traits.rs`

---
 .../rustc_attr_parsing/src/attributes/traits.rs    | 63 ++++++++++++----------
 1 file changed, 35 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index 362625abe7d..a0c2509639b 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -11,7 +11,6 @@ use crate::context::{AcceptContext, Stage};
 use crate::parser::ArgParser;
 
 pub(crate) struct SkipDuringMethodDispatchParser;
-
 impl<S: Stage> SingleAttributeParser<S> for SkipDuringMethodDispatchParser {
     const PATH: &[Symbol] = &[sym::rustc_skip_during_method_dispatch];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
@@ -55,11 +54,27 @@ impl<S: Stage> SingleAttributeParser<S> for SkipDuringMethodDispatchParser {
     }
 }
 
-pub(crate) struct ConstTraitParser;
-impl<S: Stage> NoArgsAttributeParser<S> for ConstTraitParser {
-    const PATH: &[Symbol] = &[sym::const_trait];
+pub(crate) struct ParenSugarParser;
+impl<S: Stage> NoArgsAttributeParser<S> for ParenSugarParser {
+    const PATH: &[Symbol] = &[sym::rustc_paren_sugar];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::ParenSugar;
+}
+
+pub(crate) struct TypeConstParser;
+impl<S: Stage> NoArgsAttributeParser<S> for TypeConstParser {
+    const PATH: &[Symbol] = &[sym::type_const];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::TypeConst;
+}
+
+// Markers
+
+pub(crate) struct MarkerParser;
+impl<S: Stage> NoArgsAttributeParser<S> for MarkerParser {
+    const PATH: &[Symbol] = &[sym::marker];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    const CREATE: fn(Span) -> AttributeKind = AttributeKind::ConstTrait;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::Marker;
 }
 
 pub(crate) struct DenyExplicitImplParser;
@@ -76,20 +91,17 @@ impl<S: Stage> NoArgsAttributeParser<S> for DoNotImplementViaObjectParser {
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::DoNotImplementViaObject;
 }
 
-pub(crate) struct CoinductiveParser;
-impl<S: Stage> NoArgsAttributeParser<S> for CoinductiveParser {
-    const PATH: &[Symbol] = &[sym::rustc_coinductive];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const CREATE: fn(Span) -> AttributeKind = AttributeKind::Coinductive;
-}
+// Const traits
 
-pub(crate) struct TypeConstParser;
-impl<S: Stage> NoArgsAttributeParser<S> for TypeConstParser {
-    const PATH: &[Symbol] = &[sym::type_const];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const CREATE: fn(Span) -> AttributeKind = AttributeKind::TypeConst;
+pub(crate) struct ConstTraitParser;
+impl<S: Stage> NoArgsAttributeParser<S> for ConstTraitParser {
+    const PATH: &[Symbol] = &[sym::const_trait];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::ConstTrait;
 }
 
+// Specialization
+
 pub(crate) struct SpecializationTraitParser;
 impl<S: Stage> NoArgsAttributeParser<S> for SpecializationTraitParser {
     const PATH: &[Symbol] = &[sym::rustc_specialization_trait];
@@ -104,11 +116,13 @@ impl<S: Stage> NoArgsAttributeParser<S> for UnsafeSpecializationMarkerParser {
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::UnsafeSpecializationMarker;
 }
 
-pub(crate) struct MarkerParser;
-impl<S: Stage> NoArgsAttributeParser<S> for MarkerParser {
-    const PATH: &[Symbol] = &[sym::marker];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    const CREATE: fn(Span) -> AttributeKind = AttributeKind::Marker;
+// Coherence
+
+pub(crate) struct CoinductiveParser;
+impl<S: Stage> NoArgsAttributeParser<S> for CoinductiveParser {
+    const PATH: &[Symbol] = &[sym::rustc_coinductive];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::Coinductive;
 }
 
 pub(crate) struct FundamentalParser;
@@ -117,10 +131,3 @@ impl<S: Stage> NoArgsAttributeParser<S> for FundamentalParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::Fundamental;
 }
-
-pub(crate) struct ParenSugarParser;
-impl<S: Stage> NoArgsAttributeParser<S> for ParenSugarParser {
-    const PATH: &[Symbol] = &[sym::rustc_paren_sugar];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const CREATE: fn(Span) -> AttributeKind = AttributeKind::ParenSugar;
-}
-- 
cgit 1.4.1-3-g733a5


From e9e64954e60ab92c839a98da16952a58196c3430 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Tue, 24 Jun 2025 23:53:39 +0300
Subject: Port `#[rustc_allow_incoherent_impl]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs         |  3 +++
 compiler/rustc_attr_data_structures/src/encode_cross_crate.rs |  1 +
 compiler/rustc_attr_parsing/src/attributes/traits.rs          |  7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                    |  8 +++++---
 compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs   | 11 +++++++++--
 compiler/rustc_parse/src/validate_attr.rs                     |  1 +
 compiler/rustc_passes/src/check_attr.rs                       | 10 +++++-----
 7 files changed, 31 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index de2bbcceac4..860a1ce593f 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -198,6 +198,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_allow_const_fn_unstable]`.
     AllowConstFnUnstable(ThinVec<Symbol>, Span),
 
+    /// Represents `#[rustc_allow_incoherent_impl]`.
+    AllowIncoherentImpl(Span),
+
     /// Represents `#[allow_internal_unstable]`.
     AllowInternalUnstable(ThinVec<(Symbol, Span)>, Span),
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 99b3ae9b9cd..36abbb171a5 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -15,6 +15,7 @@ impl AttributeKind {
             // tidy-alphabetical-start
             Align { .. } => No,
             AllowConstFnUnstable(..) => No,
+            AllowIncoherentImpl(..) => No,
             AllowInternalUnstable(..) => Yes,
             AsPtr(..) => Yes,
             BodyStability { .. } => No,
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index a0c2509639b..74673fdd3fb 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -125,6 +125,13 @@ impl<S: Stage> NoArgsAttributeParser<S> for CoinductiveParser {
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::Coinductive;
 }
 
+pub(crate) struct AllowIncoherentImplParser;
+impl<S: Stage> NoArgsAttributeParser<S> for AllowIncoherentImplParser {
+    const PATH: &[Symbol] = &[sym::rustc_allow_incoherent_impl];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::AllowIncoherentImpl;
+}
+
 pub(crate) struct FundamentalParser;
 impl<S: Stage> NoArgsAttributeParser<S> for FundamentalParser {
     const PATH: &[Symbol] = &[sym::fundamental];
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 4d618c171c8..db5ed13bc7d 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -44,9 +44,10 @@ use crate::attributes::stability::{
 };
 use crate::attributes::test_attrs::IgnoreParser;
 use crate::attributes::traits::{
-    CoinductiveParser, ConstTraitParser, DenyExplicitImplParser, DoNotImplementViaObjectParser,
-    FundamentalParser, MarkerParser, ParenSugarParser, SkipDuringMethodDispatchParser,
-    SpecializationTraitParser, TypeConstParser, UnsafeSpecializationMarkerParser,
+    AllowIncoherentImplParser, CoinductiveParser, ConstTraitParser, DenyExplicitImplParser,
+    DoNotImplementViaObjectParser, FundamentalParser, MarkerParser, ParenSugarParser,
+    SkipDuringMethodDispatchParser, SpecializationTraitParser, TypeConstParser,
+    UnsafeSpecializationMarkerParser,
 };
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
@@ -150,6 +151,7 @@ attribute_parsers!(
         Single<RustcObjectLifetimeDefaultParser>,
         Single<SkipDuringMethodDispatchParser>,
         Single<TransparencyParser>,
+        Single<WithoutArgs<AllowIncoherentImplParser>>,
         Single<WithoutArgs<AsPtrParser>>,
         Single<WithoutArgs<CoinductiveParser>>,
         Single<WithoutArgs<ColdParser>>,
diff --git a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
index bd25b4a3260..80bf13dc4b7 100644
--- a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
@@ -7,6 +7,7 @@
 //! `tcx.inherent_impls(def_id)`). That value, however,
 //! is computed by selecting an idea from this table.
 
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -85,7 +86,10 @@ impl<'tcx> InherentCollect<'tcx> {
             }
 
             for &impl_item in items {
-                if !self.tcx.has_attr(impl_item, sym::rustc_allow_incoherent_impl) {
+                if !find_attr!(
+                    self.tcx.get_all_attrs(impl_item),
+                    AttributeKind::AllowIncoherentImpl(_)
+                ) {
                     let impl_span = self.tcx.def_span(impl_def_id);
                     return Err(self.tcx.dcx().emit_err(errors::InherentTyOutsideRelevant {
                         span: impl_span,
@@ -116,7 +120,10 @@ impl<'tcx> InherentCollect<'tcx> {
         if !self.tcx.hir_rustc_coherence_is_core() {
             if self.tcx.features().rustc_attrs() {
                 for &impl_item in items {
-                    if !self.tcx.has_attr(impl_item, sym::rustc_allow_incoherent_impl) {
+                    if !find_attr!(
+                        self.tcx.get_all_attrs(impl_item),
+                        AttributeKind::AllowIncoherentImpl(_)
+                    ) {
                         let span = self.tcx.def_span(impl_def_id);
                         return Err(self.tcx.dcx().emit_err(errors::InherentTyOutsidePrimitive {
                             span,
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index ce7a7cd0a93..c500c9b4063 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -289,6 +289,7 @@ pub fn check_builtin_meta_item(
                 | sym::const_trait
                 | sym::rustc_specialization_trait
                 | sym::rustc_unsafe_specialization_marker
+                | sym::rustc_allow_incoherent_impl
                 | sym::marker
                 | sym::fundamental
                 | sym::rustc_paren_sugar
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 567b0423d52..5d2b6d3de39 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -146,6 +146,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 Attribute::Parsed(AttributeKind::Fundamental) => {
                     // FIXME: add validation
                 }
+                &Attribute::Parsed(AttributeKind::AllowIncoherentImpl(attr_span)) => {
+                    self.check_allow_incoherent_impl(attr_span, span, target)
+                }
                 Attribute::Parsed(AttributeKind::Confusables { first_span, .. }) => {
                     self.check_confusables(*first_span, target);
                 }
@@ -319,9 +322,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::rustc_must_implement_one_of, ..] => self.check_must_be_applied_to_trait(attr.span(), span, target),
                         [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target),
                         [sym::must_not_suspend, ..] => self.check_must_not_suspend(attr, span, target),
-                        [sym::rustc_allow_incoherent_impl, ..] => {
-                            self.check_allow_incoherent_impl(attr, span, target)
-                        }
                         [sym::rustc_has_incoherent_inherent_impls, ..] => {
                             self.check_has_incoherent_inherent_impls(attr, span, target)
                         }
@@ -1498,11 +1498,11 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    fn check_allow_incoherent_impl(&self, attr: &Attribute, span: Span, target: Target) {
+    fn check_allow_incoherent_impl(&self, attr_span: Span, span: Span, target: Target) {
         match target {
             Target::Method(MethodKind::Inherent) => {}
             _ => {
-                self.dcx().emit_err(errors::AllowIncoherentImpl { attr_span: attr.span(), span });
+                self.dcx().emit_err(errors::AllowIncoherentImpl { attr_span, span });
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From e584ed0de2150ad11b24ed75e954825fd5b273f9 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Wed, 25 Jun 2025 00:24:14 +0300
Subject: Port `#[rustc_coherence_is_core]` to the new attribute system

---
 compiler/rustc_attr_data_structures/src/attributes.rs         | 3 +++
 compiler/rustc_attr_data_structures/src/encode_cross_crate.rs | 1 +
 compiler/rustc_attr_parsing/src/attributes/traits.rs          | 7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                    | 7 ++++---
 compiler/rustc_middle/src/hir/map.rs                          | 5 +++--
 compiler/rustc_parse/src/validate_attr.rs                     | 1 +
 compiler/rustc_passes/src/check_attr.rs                       | 2 +-
 7 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 860a1ce593f..f61efcf2388 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -214,6 +214,9 @@ pub enum AttributeKind {
         span: Span,
     },
 
+    /// Represents `#[rustc_coherence_is_core]`.
+    CoherenceIsCore,
+
     /// Represents `#[rustc_coinductive]`.
     Coinductive(Span),
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 36abbb171a5..ad587523e03 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -19,6 +19,7 @@ impl AttributeKind {
             AllowInternalUnstable(..) => Yes,
             AsPtr(..) => Yes,
             BodyStability { .. } => No,
+            CoherenceIsCore => No,
             Coinductive(..) => No,
             Cold(..) => No,
             Confusables { .. } => Yes,
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index 74673fdd3fb..c202a0315a0 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -132,6 +132,13 @@ impl<S: Stage> NoArgsAttributeParser<S> for AllowIncoherentImplParser {
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::AllowIncoherentImpl;
 }
 
+pub(crate) struct CoherenceIsCoreParser;
+impl<S: Stage> NoArgsAttributeParser<S> for CoherenceIsCoreParser {
+    const PATH: &[Symbol] = &[sym::rustc_coherence_is_core];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::CoherenceIsCore;
+}
+
 pub(crate) struct FundamentalParser;
 impl<S: Stage> NoArgsAttributeParser<S> for FundamentalParser {
     const PATH: &[Symbol] = &[sym::fundamental];
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index db5ed13bc7d..cc10bb3098a 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -44,9 +44,9 @@ use crate::attributes::stability::{
 };
 use crate::attributes::test_attrs::IgnoreParser;
 use crate::attributes::traits::{
-    AllowIncoherentImplParser, CoinductiveParser, ConstTraitParser, DenyExplicitImplParser,
-    DoNotImplementViaObjectParser, FundamentalParser, MarkerParser, ParenSugarParser,
-    SkipDuringMethodDispatchParser, SpecializationTraitParser, TypeConstParser,
+    AllowIncoherentImplParser, CoherenceIsCoreParser, CoinductiveParser, ConstTraitParser,
+    DenyExplicitImplParser, DoNotImplementViaObjectParser, FundamentalParser, MarkerParser,
+    ParenSugarParser, SkipDuringMethodDispatchParser, SpecializationTraitParser, TypeConstParser,
     UnsafeSpecializationMarkerParser,
 };
 use crate::attributes::transparency::TransparencyParser;
@@ -153,6 +153,7 @@ attribute_parsers!(
         Single<TransparencyParser>,
         Single<WithoutArgs<AllowIncoherentImplParser>>,
         Single<WithoutArgs<AsPtrParser>>,
+        Single<WithoutArgs<CoherenceIsCoreParser>>,
         Single<WithoutArgs<CoinductiveParser>>,
         Single<WithoutArgs<ColdParser>>,
         Single<WithoutArgs<ConstContinueParser>>,
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index 291707878a3..84710e5e636 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -4,6 +4,7 @@
 
 use rustc_abi::ExternAbi;
 use rustc_ast::visit::{VisitorResult, walk_list};
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::svh::Svh;
@@ -15,7 +16,7 @@ use rustc_hir::intravisit::Visitor;
 use rustc_hir::*;
 use rustc_hir_pretty as pprust_hir;
 use rustc_span::def_id::StableCrateId;
-use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol, kw, sym, with_metavar_spans};
+use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol, kw, with_metavar_spans};
 
 use crate::hir::{ModuleItems, nested_filter};
 use crate::middle::debugger_visualizer::DebuggerVisualizerFile;
@@ -369,7 +370,7 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     pub fn hir_rustc_coherence_is_core(self) -> bool {
-        self.hir_krate_attrs().iter().any(|attr| attr.has_name(sym::rustc_coherence_is_core))
+        find_attr!(self.hir_krate_attrs(), AttributeKind::CoherenceIsCore)
     }
 
     pub fn hir_get_module(self, module: LocalModDefId) -> (&'tcx Mod<'tcx>, Span, HirId) {
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index c500c9b4063..bb5c1e0e653 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -290,6 +290,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_specialization_trait
                 | sym::rustc_unsafe_specialization_marker
                 | sym::rustc_allow_incoherent_impl
+                | sym::rustc_coherence_is_core
                 | sym::marker
                 | sym::fundamental
                 | sym::rustc_paren_sugar
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 5d2b6d3de39..2c95fead9e8 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -143,7 +143,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 &Attribute::Parsed(AttributeKind::Marker(attr_span)) => {
                     self.check_marker(hir_id, attr_span, span, target)
                 }
-                Attribute::Parsed(AttributeKind::Fundamental) => {
+                Attribute::Parsed(AttributeKind::Fundamental | AttributeKind::CoherenceIsCore) => {
                     // FIXME: add validation
                 }
                 &Attribute::Parsed(AttributeKind::AllowIncoherentImpl(attr_span)) => {
-- 
cgit 1.4.1-3-g733a5


From e391578abb374d533162ada0b8a5b03e43ef5bc0 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Wed, 9 Jul 2025 01:40:47 +0300
Subject: Use "Innermost" & "Outermost" terminology for `AttributeOrder`

---
 .../src/attributes/codegen_attrs.rs                |  4 +--
 .../src/attributes/deprecation.rs                  |  2 +-
 .../rustc_attr_parsing/src/attributes/dummy.rs     |  2 +-
 .../rustc_attr_parsing/src/attributes/inline.rs    |  4 +--
 .../src/attributes/link_attrs.rs                   |  4 +--
 compiler/rustc_attr_parsing/src/attributes/mod.rs  | 39 ++++++++--------------
 .../rustc_attr_parsing/src/attributes/must_use.rs  |  2 +-
 compiler/rustc_attr_parsing/src/attributes/path.rs |  2 +-
 .../src/attributes/rustc_internal.rs               |  6 ++--
 .../src/attributes/test_attrs.rs                   |  2 +-
 .../rustc_attr_parsing/src/attributes/traits.rs    |  2 +-
 .../src/attributes/transparency.rs                 |  2 +-
 12 files changed, 29 insertions(+), 42 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index cb3956d46a0..fdec09edaa1 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -15,7 +15,7 @@ pub(crate) struct OptimizeParser;
 
 impl<S: Stage> SingleAttributeParser<S> for OptimizeParser {
     const PATH: &[Symbol] = &[sym::optimize];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepLast;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(List: "size|speed|none");
 
@@ -56,7 +56,7 @@ pub(crate) struct ExportNameParser;
 
 impl<S: Stage> SingleAttributeParser<S> for ExportNameParser {
     const PATH: &[rustc_span::Symbol] = &[sym::export_name];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/deprecation.rs b/compiler/rustc_attr_parsing/src/attributes/deprecation.rs
index 702ad66f578..08cf1ab5d19 100644
--- a/compiler/rustc_attr_parsing/src/attributes/deprecation.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/deprecation.rs
@@ -36,7 +36,7 @@ fn get<S: Stage>(
 
 impl<S: Stage> SingleAttributeParser<S> for DeprecationParser {
     const PATH: &[Symbol] = &[sym::deprecated];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(
         Word,
diff --git a/compiler/rustc_attr_parsing/src/attributes/dummy.rs b/compiler/rustc_attr_parsing/src/attributes/dummy.rs
index 8a9b94fb1ff..e5e1c3bb6b6 100644
--- a/compiler/rustc_attr_parsing/src/attributes/dummy.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/dummy.rs
@@ -9,7 +9,7 @@ use crate::parser::ArgParser;
 pub(crate) struct DummyParser;
 impl<S: Stage> SingleAttributeParser<S> for DummyParser {
     const PATH: &[Symbol] = &[sym::rustc_dummy];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Ignore;
     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 11844f4cd95..fe812175218 100644
--- a/compiler/rustc_attr_parsing/src/attributes/inline.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/inline.rs
@@ -16,7 +16,7 @@ pub(crate) struct InlineParser;
 
 impl<S: Stage> SingleAttributeParser<S> for InlineParser {
     const PATH: &'static [Symbol] = &[sym::inline];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepLast;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(Word, List: "always|never");
 
@@ -57,7 +57,7 @@ pub(crate) struct RustcForceInlineParser;
 
 impl<S: Stage> SingleAttributeParser<S> for RustcForceInlineParser {
     const PATH: &'static [Symbol] = &[sym::rustc_force_inline];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepLast;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(Word, List: "reason", NameValueStr: "reason");
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
index 1a66eec870f..23a8e96482d 100644
--- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -14,7 +14,7 @@ pub(crate) struct LinkNameParser;
 
 impl<S: Stage> SingleAttributeParser<S> for LinkNameParser {
     const PATH: &[Symbol] = &[sym::link_name];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
 
@@ -36,7 +36,7 @@ pub(crate) struct LinkSectionParser;
 
 impl<S: Stage> SingleAttributeParser<S> for LinkSectionParser {
     const PATH: &[Symbol] = &[sym::link_section];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
index 0225b141336..68c716d1a99 100644
--- a/compiler/rustc_attr_parsing/src/attributes/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -140,7 +140,7 @@ impl<T: SingleAttributeParser<S>, S: Stage> AttributeParser<S> for Single<T, S>
             if let Some(pa) = T::convert(cx, args) {
                 match T::ATTRIBUTE_ORDER {
                     // keep the first and report immediately. ignore this attribute
-                    AttributeOrder::KeepFirst => {
+                    AttributeOrder::KeepInnermost => {
                         if let Some((_, unused)) = group.1 {
                             T::ON_DUPLICATE.exec::<T>(cx, cx.attr_span, unused);
                             return;
@@ -148,7 +148,7 @@ impl<T: SingleAttributeParser<S>, S: Stage> AttributeParser<S> for Single<T, S>
                     }
                     // keep the new one and warn about the previous,
                     // then replace
-                    AttributeOrder::KeepLast => {
+                    AttributeOrder::KeepOutermost => {
                         if let Some((_, used)) = group.1 {
                             T::ON_DUPLICATE.exec::<T>(cx, used, cx.attr_span);
                         }
@@ -165,9 +165,6 @@ impl<T: SingleAttributeParser<S>, S: Stage> AttributeParser<S> for Single<T, S>
     }
 }
 
-// FIXME(jdonszelmann): logic is implemented but the attribute parsers needing
-// them will be merged in another PR
-#[allow(unused)]
 pub(crate) enum OnDuplicate<S: Stage> {
     /// Give a default warning
     Warn,
@@ -213,39 +210,29 @@ impl<S: Stage> OnDuplicate<S> {
         }
     }
 }
-//
-// FIXME(jdonszelmann): logic is implemented but the attribute parsers needing
-// them will be merged in another PR
-#[allow(unused)]
+
 pub(crate) enum AttributeOrder {
-    /// Duplicates after the first attribute will be an error. I.e. only keep the lowest attribute.
+    /// 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 an error on all the attributes
+    /// 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")]
     /// ```
-    ///
-    /// This should be used where duplicates would be ignored, but carry extra
-    /// meaning that could cause confusion. For example, `#[stable(since="1.0")]
-    /// #[stable(since="2.0")]`, which version should be used for `stable`?
-    KeepFirst,
+    KeepInnermost,
 
-    /// Duplicates preceding the last instance of the attribute will be a
-    /// warning, with a note that this will be an error in the future.
+    /// 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 on all the attributes
-    /// below the higher one:
+    /// 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
     /// ```
-    ///
-    /// This is the same as `FutureWarnFollowing`, except the last attribute is
-    /// the one that is "used". Ideally these can eventually migrate to
-    /// `ErrorPreceding`.
-    KeepLast,
+    KeepOutermost,
 }
 
 /// An even simpler version of [`SingleAttributeParser`]:
@@ -271,7 +258,7 @@ impl<T: NoArgsAttributeParser<S>, S: Stage> Default for WithoutArgs<T, S> {
 
 impl<T: NoArgsAttributeParser<S>, S: Stage> SingleAttributeParser<S> for WithoutArgs<T, S> {
     const PATH: &[Symbol] = T::PATH;
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepLast;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = T::ON_DUPLICATE;
     const TEMPLATE: AttributeTemplate = template!(Word);
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/must_use.rs b/compiler/rustc_attr_parsing/src/attributes/must_use.rs
index b5eb85f68b4..e0a3e675509 100644
--- a/compiler/rustc_attr_parsing/src/attributes/must_use.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/must_use.rs
@@ -12,7 +12,7 @@ pub(crate) struct MustUseParser;
 
 impl<S: Stage> SingleAttributeParser<S> for MustUseParser {
     const PATH: &[Symbol] = &[sym::must_use];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepLast;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(Word, NameValueStr: "reason");
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/path.rs b/compiler/rustc_attr_parsing/src/attributes/path.rs
index 0dfbc9a9aa8..febb1b45a18 100644
--- a/compiler/rustc_attr_parsing/src/attributes/path.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/path.rs
@@ -10,7 +10,7 @@ pub(crate) struct PathParser;
 
 impl<S: Stage> SingleAttributeParser<S> for PathParser {
     const PATH: &[Symbol] = &[sym::path];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepLast;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "file");
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
index e6b6a6fe3c9..ec821cb11ce 100644
--- a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
@@ -11,7 +11,7 @@ pub(crate) struct RustcLayoutScalarValidRangeStart;
 
 impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeStart {
     const PATH: &'static [Symbol] = &[sym::rustc_layout_scalar_valid_range_start];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(List: "start");
 
@@ -25,7 +25,7 @@ pub(crate) struct RustcLayoutScalarValidRangeEnd;
 
 impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeEnd {
     const PATH: &'static [Symbol] = &[sym::rustc_layout_scalar_valid_range_end];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(List: "end");
 
@@ -62,7 +62,7 @@ pub(crate) struct RustcObjectLifetimeDefaultParser;
 
 impl<S: Stage> SingleAttributeParser<S> for RustcObjectLifetimeDefaultParser {
     const PATH: &[rustc_span::Symbol] = &[sym::rustc_object_lifetime_default];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(Word);
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs
index cea3ee52ff4..ee81f64860f 100644
--- a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs
@@ -11,7 +11,7 @@ pub(crate) struct IgnoreParser;
 
 impl<S: Stage> SingleAttributeParser<S> for IgnoreParser {
     const PATH: &[Symbol] = &[sym::ignore];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepLast;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
     const TEMPLATE: AttributeTemplate = template!(Word, NameValueStr: "reason");
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index 83a98c53c7f..c29dbf4d1e9 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -12,7 +12,7 @@ pub(crate) struct SkipDuringMethodDispatchParser;
 
 impl<S: Stage> SingleAttributeParser<S> for SkipDuringMethodDispatchParser {
     const PATH: &[Symbol] = &[sym::rustc_skip_during_method_dispatch];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
 
     const TEMPLATE: AttributeTemplate = template!(List: "array, boxed_slice");
diff --git a/compiler/rustc_attr_parsing/src/attributes/transparency.rs b/compiler/rustc_attr_parsing/src/attributes/transparency.rs
index ce5ceb9139a..c9fdc57cc06 100644
--- a/compiler/rustc_attr_parsing/src/attributes/transparency.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/transparency.rs
@@ -14,7 +14,7 @@ pub(crate) struct TransparencyParser;
 #[allow(rustc::diagnostic_outside_of_impl)]
 impl<S: Stage> SingleAttributeParser<S> for TransparencyParser {
     const PATH: &[Symbol] = &[sym::rustc_macro_transparency];
-    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+    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");
     });
-- 
cgit 1.4.1-3-g733a5


From 6fc5d4edda88d0dd28c45ccba1a1e217ddad11c4 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Mon, 7 Jul 2025 19:23:06 +0200
Subject: emit `.att_syntax` when global/naked asm use that option

---
 compiler/rustc_codegen_llvm/src/asm.rs  | 22 +++++++---
 tests/assembly/emit-intel-att-syntax.rs | 75 +++++++++++++++++++++++++++++++++
 2 files changed, 90 insertions(+), 7 deletions(-)
 create mode 100644 tests/assembly/emit-intel-att-syntax.rs

diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
index 9ddadcf16aa..a643a91141e 100644
--- a/compiler/rustc_codegen_llvm/src/asm.rs
+++ b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -384,15 +384,19 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
     ) {
         let asm_arch = self.tcx.sess.asm_arch.unwrap();
 
-        // Default to Intel syntax on x86
-        let intel_syntax = matches!(asm_arch, InlineAsmArch::X86 | InlineAsmArch::X86_64)
-            && !options.contains(InlineAsmOptions::ATT_SYNTAX);
-
         // Build the template string
         let mut template_str = String::new();
-        if intel_syntax {
-            template_str.push_str(".intel_syntax\n");
+
+        // On X86 platforms there are two assembly syntaxes. Rust uses intel by default,
+        // but AT&T can be specified explicitly.
+        if matches!(asm_arch, InlineAsmArch::X86 | InlineAsmArch::X86_64) {
+            if options.contains(InlineAsmOptions::ATT_SYNTAX) {
+                template_str.push_str(".att_syntax\n")
+            } else {
+                template_str.push_str(".intel_syntax\n")
+            }
         }
+
         for piece in template {
             match *piece {
                 InlineAsmTemplatePiece::String(ref s) => template_str.push_str(s),
@@ -431,7 +435,11 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
                 }
             }
         }
-        if intel_syntax {
+
+        // Just to play it safe, if intel was used, reset the assembly syntax to att.
+        if matches!(asm_arch, InlineAsmArch::X86 | InlineAsmArch::X86_64)
+            && !options.contains(InlineAsmOptions::ATT_SYNTAX)
+        {
             template_str.push_str("\n.att_syntax\n");
         }
 
diff --git a/tests/assembly/emit-intel-att-syntax.rs b/tests/assembly/emit-intel-att-syntax.rs
new file mode 100644
index 00000000000..7b479a0f79e
--- /dev/null
+++ b/tests/assembly/emit-intel-att-syntax.rs
@@ -0,0 +1,75 @@
+//@ assembly-output: emit-asm
+//@ revisions: att intel
+//@ [att] compile-flags: -Cllvm-args=-x86-asm-syntax=att
+//@ [intel] compile-flags: -Cllvm-args=-x86-asm-syntax=intel
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: naked_att:
+// intel-CHECK: mov rax, qword ptr [rdi]
+// intel-CHECK: ret
+// att-CHECK: movq (%rdi), %rax
+// att-CHECK: retq
+
+#[unsafe(naked)]
+#[unsafe(no_mangle)]
+extern "sysv64" fn naked_att() {
+    std::arch::naked_asm!(
+        "
+        movq (%rdi), %rax
+        retq
+        ",
+        options(att_syntax),
+    );
+}
+
+// CHECK-LABEL: naked_intel:
+// intel-CHECK: mov rax, rdi
+// intel-CHECK: ret
+// att-CHECK: movq (%rdi), %rax
+// att-CHECK: retq
+
+#[unsafe(naked)]
+#[unsafe(no_mangle)]
+extern "sysv64" fn naked_intel() {
+    std::arch::naked_asm!(
+        "
+        mov rax, rdi
+        ret
+        ",
+        options(),
+    );
+}
+
+// CHECK-LABEL: global_att:
+// intel-CHECK: mov rax, rdi
+// intel-CHECK: ret
+// att-CHECK: movq (%rdi), %rax
+// att-CHECK: retq
+
+core::arch::global_asm!(
+    "
+    .globl global_att
+    global_att:
+        movq (%rdi), %rax
+        retq
+    ",
+    options(att_syntax),
+);
+
+// CHECK-LABEL: global_intel:
+// intel-CHECK: mov rax, rdi
+// intel-CHECK: ret
+// att-CHECK: movq (%rdi), %rax
+// att-CHECK: retq
+
+core::arch::global_asm!(
+    "
+    .globl global_intel
+    global_intel:
+        mov rax, rdi
+        ret
+    ",
+    options(),
+);
-- 
cgit 1.4.1-3-g733a5


From c7ef03aeb7c33825e3d020c9e1791171e71cd445 Mon Sep 17 00:00:00 2001
From: Amogh Shivaram <ashivaram264@gmail.com>
Date: Tue, 8 Jul 2025 18:15:05 -0500
Subject: Apply effects to otherwise edge in dataflow analysis

---
 .../rustc_mir_dataflow/src/drop_flag_effects.rs    |  28 ++++--
 .../rustc_mir_dataflow/src/framework/direction.rs  |  11 ++-
 compiler/rustc_mir_dataflow/src/framework/mod.rs   |   1 +
 .../rustc_mir_dataflow/src/impls/initialized.rs    |  88 ++++++++++++-----
 .../rustc_mir_transform/src/elaborate_drops.rs     |   2 +
 .../rustc_mir_transform/src/remove_uninit_drops.rs |   1 +
 .../otherwise_drops.result_ok.ElaborateDrops.diff  | 108 +++++++++++++++++++++
 tests/mir-opt/otherwise_drops.rs                   |  13 +++
 ...ifetimes.foo.ScalarReplacementOfAggregates.diff |  11 +--
 9 files changed, 219 insertions(+), 44 deletions(-)
 create mode 100644 tests/mir-opt/otherwise_drops.result_ok.ElaborateDrops.diff
 create mode 100644 tests/mir-opt/otherwise_drops.rs

diff --git a/compiler/rustc_mir_dataflow/src/drop_flag_effects.rs b/compiler/rustc_mir_dataflow/src/drop_flag_effects.rs
index 496a342cf4c..c9c7fddae5a 100644
--- a/compiler/rustc_mir_dataflow/src/drop_flag_effects.rs
+++ b/compiler/rustc_mir_dataflow/src/drop_flag_effects.rs
@@ -1,5 +1,6 @@
 use rustc_abi::VariantIdx;
 use rustc_middle::mir::{self, Body, Location, Terminator, TerminatorKind};
+use smallvec::SmallVec;
 use tracing::debug;
 
 use super::move_paths::{InitKind, LookupResult, MoveData, MovePathIndex};
@@ -155,15 +156,28 @@ where
     }
 }
 
-/// Calls `handle_inactive_variant` for each descendant move path of `enum_place` that contains a
-/// `Downcast` to a variant besides the `active_variant`.
-///
-/// NOTE: If there are no move paths corresponding to an inactive variant,
-/// `handle_inactive_variant` will not be called for that variant.
+/// Indicates which variants are inactive at a `SwitchInt` edge by listing their `VariantIdx`s or
+/// specifying the single active variant's `VariantIdx`.
+pub(crate) enum InactiveVariants {
+    Inactives(SmallVec<[VariantIdx; 4]>),
+    Active(VariantIdx),
+}
+
+impl InactiveVariants {
+    fn contains(&self, variant_idx: VariantIdx) -> bool {
+        match self {
+            InactiveVariants::Inactives(inactives) => inactives.contains(&variant_idx),
+            InactiveVariants::Active(active) => variant_idx != *active,
+        }
+    }
+}
+
+/// Calls `handle_inactive_variant` for each child move path of `enum_place` corresponding to an
+/// inactive variant at a particular `SwitchInt` edge.
 pub(crate) fn on_all_inactive_variants<'tcx>(
     move_data: &MoveData<'tcx>,
     enum_place: mir::Place<'tcx>,
-    active_variant: VariantIdx,
+    inactive_variants: &InactiveVariants,
     mut handle_inactive_variant: impl FnMut(MovePathIndex),
 ) {
     let LookupResult::Exact(enum_mpi) = move_data.rev_lookup.find(enum_place.as_ref()) else {
@@ -182,7 +196,7 @@ pub(crate) fn on_all_inactive_variants<'tcx>(
             unreachable!();
         };
 
-        if variant_idx != active_variant {
+        if inactive_variants.contains(variant_idx) {
             on_all_children_bits(move_data, variant_mpi, |mpi| handle_inactive_variant(mpi));
         }
     }
diff --git a/compiler/rustc_mir_dataflow/src/framework/direction.rs b/compiler/rustc_mir_dataflow/src/framework/direction.rs
index e955e38ad10..cb647476db8 100644
--- a/compiler/rustc_mir_dataflow/src/framework/direction.rs
+++ b/compiler/rustc_mir_dataflow/src/framework/direction.rs
@@ -112,12 +112,13 @@ impl Direction for Backward {
                     propagate(pred, &tmp);
                 }
 
-                mir::TerminatorKind::SwitchInt { targets: _, ref discr } => {
+                mir::TerminatorKind::SwitchInt { ref targets, ref discr } => {
                     if let Some(mut data) = analysis.get_switch_int_data(block, discr) {
                         let mut tmp = analysis.bottom_value(body);
                         for &value in &body.basic_blocks.switch_sources()[&(block, pred)] {
                             tmp.clone_from(exit_state);
-                            analysis.apply_switch_int_edge_effect(&mut data, &mut tmp, value);
+                            analysis
+                                .apply_switch_int_edge_effect(&mut data, &mut tmp, value, targets);
                             propagate(pred, &tmp);
                         }
                     } else {
@@ -290,20 +291,20 @@ impl Direction for Forward {
                     for (value, target) in targets.iter() {
                         tmp.clone_from(exit_state);
                         let value = SwitchTargetValue::Normal(value);
-                        analysis.apply_switch_int_edge_effect(&mut data, &mut tmp, value);
+                        analysis.apply_switch_int_edge_effect(&mut data, &mut tmp, value, targets);
                         propagate(target, &tmp);
                     }
 
                     // Once we get to the final, "otherwise" branch, there is no need to preserve
                     // `exit_state`, so pass it directly to `apply_switch_int_edge_effect` to save
                     // a clone of the dataflow state.
-                    let otherwise = targets.otherwise();
                     analysis.apply_switch_int_edge_effect(
                         &mut data,
                         exit_state,
                         SwitchTargetValue::Otherwise,
+                        targets,
                     );
-                    propagate(otherwise, exit_state);
+                    propagate(targets.otherwise(), exit_state);
                 } else {
                     for target in targets.all_targets() {
                         propagate(*target, exit_state);
diff --git a/compiler/rustc_mir_dataflow/src/framework/mod.rs b/compiler/rustc_mir_dataflow/src/framework/mod.rs
index 9cadec100b5..b6a56036019 100644
--- a/compiler/rustc_mir_dataflow/src/framework/mod.rs
+++ b/compiler/rustc_mir_dataflow/src/framework/mod.rs
@@ -224,6 +224,7 @@ pub trait Analysis<'tcx> {
         _data: &mut Self::SwitchIntData,
         _state: &mut Self::Domain,
         _value: SwitchTargetValue,
+        _targets: &mir::SwitchTargets,
     ) {
         unreachable!();
     }
diff --git a/compiler/rustc_mir_dataflow/src/impls/initialized.rs b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
index 18165b0b9bd..085757f0fb6 100644
--- a/compiler/rustc_mir_dataflow/src/impls/initialized.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
@@ -9,9 +9,10 @@ use rustc_middle::mir::{
 };
 use rustc_middle::ty::util::Discr;
 use rustc_middle::ty::{self, TyCtxt};
+use smallvec::SmallVec;
 use tracing::{debug, instrument};
 
-use crate::drop_flag_effects::DropFlagState;
+use crate::drop_flag_effects::{DropFlagState, InactiveVariants};
 use crate::move_paths::{HasMoveData, InitIndex, InitKind, LookupResult, MoveData, MovePathIndex};
 use crate::{
     Analysis, GenKill, MaybeReachable, drop_flag_effects, drop_flag_effects_for_function_entry,
@@ -26,6 +27,12 @@ pub struct MaybePlacesSwitchIntData<'tcx> {
 }
 
 impl<'tcx> MaybePlacesSwitchIntData<'tcx> {
+    /// Creates a `SmallVec` mapping each target in `targets` to its `VariantIdx`.
+    fn variants(&mut self, targets: &mir::SwitchTargets) -> SmallVec<[VariantIdx; 4]> {
+        self.index = 0;
+        targets.all_values().iter().map(|value| self.next_discr(value.get())).collect()
+    }
+
     // The discriminant order in the `SwitchInt` targets should match the order yielded by
     // `AdtDef::discriminants`. We rely on this to match each discriminant in the targets to its
     // corresponding variant in linear time.
@@ -131,12 +138,26 @@ pub struct MaybeInitializedPlaces<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     body: &'a Body<'tcx>,
     move_data: &'a MoveData<'tcx>,
+    exclude_inactive_in_otherwise: bool,
     skip_unreachable_unwind: bool,
 }
 
 impl<'a, 'tcx> MaybeInitializedPlaces<'a, 'tcx> {
     pub fn new(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, move_data: &'a MoveData<'tcx>) -> Self {
-        MaybeInitializedPlaces { tcx, body, move_data, skip_unreachable_unwind: false }
+        MaybeInitializedPlaces {
+            tcx,
+            body,
+            move_data,
+            exclude_inactive_in_otherwise: false,
+            skip_unreachable_unwind: false,
+        }
+    }
+
+    /// Ensures definitely inactive variants are excluded from the set of initialized places for
+    /// blocks reached through an `otherwise` edge.
+    pub fn exclude_inactive_in_otherwise(mut self) -> Self {
+        self.exclude_inactive_in_otherwise = true;
+        self
     }
 
     pub fn skipping_unreachable_unwind(mut self) -> Self {
@@ -208,6 +229,7 @@ pub struct MaybeUninitializedPlaces<'a, 'tcx> {
     move_data: &'a MoveData<'tcx>,
 
     mark_inactive_variants_as_uninit: bool,
+    include_inactive_in_otherwise: bool,
     skip_unreachable_unwind: DenseBitSet<mir::BasicBlock>,
 }
 
@@ -218,6 +240,7 @@ impl<'a, 'tcx> MaybeUninitializedPlaces<'a, 'tcx> {
             body,
             move_data,
             mark_inactive_variants_as_uninit: false,
+            include_inactive_in_otherwise: false,
             skip_unreachable_unwind: DenseBitSet::new_empty(body.basic_blocks.len()),
         }
     }
@@ -232,6 +255,13 @@ impl<'a, 'tcx> MaybeUninitializedPlaces<'a, 'tcx> {
         self
     }
 
+    /// Ensures definitely inactive variants are included in the set of uninitialized places for
+    /// blocks reached through an `otherwise` edge.
+    pub fn include_inactive_in_otherwise(mut self) -> Self {
+        self.include_inactive_in_otherwise = true;
+        self
+    }
+
     pub fn skipping_unreachable_unwind(
         mut self,
         unreachable_unwind: DenseBitSet<mir::BasicBlock>,
@@ -431,17 +461,24 @@ impl<'tcx> Analysis<'tcx> for MaybeInitializedPlaces<'_, 'tcx> {
         data: &mut Self::SwitchIntData,
         state: &mut Self::Domain,
         value: SwitchTargetValue,
+        targets: &mir::SwitchTargets,
     ) {
-        if let SwitchTargetValue::Normal(value) = value {
-            // Kill all move paths that correspond to variants we know to be inactive along this
-            // particular outgoing edge of a `SwitchInt`.
-            drop_flag_effects::on_all_inactive_variants(
-                self.move_data,
-                data.enum_place,
-                data.next_discr(value),
-                |mpi| state.kill(mpi),
-            );
-        }
+        let inactive_variants = match value {
+            SwitchTargetValue::Normal(value) => InactiveVariants::Active(data.next_discr(value)),
+            SwitchTargetValue::Otherwise if self.exclude_inactive_in_otherwise => {
+                InactiveVariants::Inactives(data.variants(targets))
+            }
+            _ => return,
+        };
+
+        // Kill all move paths that correspond to variants we know to be inactive along this
+        // particular outgoing edge of a `SwitchInt`.
+        drop_flag_effects::on_all_inactive_variants(
+            self.move_data,
+            data.enum_place,
+            &inactive_variants,
+            |mpi| state.kill(mpi),
+        );
     }
 }
 
@@ -544,17 +581,24 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedPlaces<'_, 'tcx> {
         data: &mut Self::SwitchIntData,
         state: &mut Self::Domain,
         value: SwitchTargetValue,
+        targets: &mir::SwitchTargets,
     ) {
-        if let SwitchTargetValue::Normal(value) = value {
-            // Mark all move paths that correspond to variants other than this one as maybe
-            // uninitialized (in reality, they are *definitely* uninitialized).
-            drop_flag_effects::on_all_inactive_variants(
-                self.move_data,
-                data.enum_place,
-                data.next_discr(value),
-                |mpi| state.gen_(mpi),
-            );
-        }
+        let inactive_variants = match value {
+            SwitchTargetValue::Normal(value) => InactiveVariants::Active(data.next_discr(value)),
+            SwitchTargetValue::Otherwise if self.include_inactive_in_otherwise => {
+                InactiveVariants::Inactives(data.variants(targets))
+            }
+            _ => return,
+        };
+
+        // Mark all move paths that correspond to variants other than this one as maybe
+        // uninitialized (in reality, they are *definitely* uninitialized).
+        drop_flag_effects::on_all_inactive_variants(
+            self.move_data,
+            data.enum_place,
+            &inactive_variants,
+            |mpi| state.gen_(mpi),
+        );
     }
 }
 
diff --git a/compiler/rustc_mir_transform/src/elaborate_drops.rs b/compiler/rustc_mir_transform/src/elaborate_drops.rs
index 42c8cb0b906..b4fa2be1d00 100644
--- a/compiler/rustc_mir_transform/src/elaborate_drops.rs
+++ b/compiler/rustc_mir_transform/src/elaborate_drops.rs
@@ -62,12 +62,14 @@ impl<'tcx> crate::MirPass<'tcx> for ElaborateDrops {
             let env = MoveDataTypingEnv { move_data, typing_env };
 
             let mut inits = MaybeInitializedPlaces::new(tcx, body, &env.move_data)
+                .exclude_inactive_in_otherwise()
                 .skipping_unreachable_unwind()
                 .iterate_to_fixpoint(tcx, body, Some("elaborate_drops"))
                 .into_results_cursor(body);
             let dead_unwinds = compute_dead_unwinds(body, &mut inits);
 
             let uninits = MaybeUninitializedPlaces::new(tcx, body, &env.move_data)
+                .include_inactive_in_otherwise()
                 .mark_inactive_variants_as_uninit()
                 .skipping_unreachable_unwind(dead_unwinds)
                 .iterate_to_fixpoint(tcx, body, Some("elaborate_drops"))
diff --git a/compiler/rustc_mir_transform/src/remove_uninit_drops.rs b/compiler/rustc_mir_transform/src/remove_uninit_drops.rs
index 9044a88295c..25d6fa1bab9 100644
--- a/compiler/rustc_mir_transform/src/remove_uninit_drops.rs
+++ b/compiler/rustc_mir_transform/src/remove_uninit_drops.rs
@@ -22,6 +22,7 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveUninitDrops {
         let move_data = MoveData::gather_moves(body, tcx, |ty| ty.needs_drop(tcx, typing_env));
 
         let mut maybe_inits = MaybeInitializedPlaces::new(tcx, body, &move_data)
+            .exclude_inactive_in_otherwise()
             .iterate_to_fixpoint(tcx, body, Some("remove_uninit_drops"))
             .into_results_cursor(body);
 
diff --git a/tests/mir-opt/otherwise_drops.result_ok.ElaborateDrops.diff b/tests/mir-opt/otherwise_drops.result_ok.ElaborateDrops.diff
new file mode 100644
index 00000000000..9bd4db723d4
--- /dev/null
+++ b/tests/mir-opt/otherwise_drops.result_ok.ElaborateDrops.diff
@@ -0,0 +1,108 @@
+- // MIR for `result_ok` before ElaborateDrops
++ // MIR for `result_ok` after ElaborateDrops
+  
+  fn result_ok(_1: Result<String, ()>) -> Option<String> {
+      debug result => _1;
+      let mut _0: std::option::Option<std::string::String>;
+      let mut _2: isize;
+      let _3: std::string::String;
+      let mut _4: std::string::String;
++     let mut _5: bool;
++     let mut _6: isize;
++     let mut _7: isize;
+      scope 1 {
+          debug s => _3;
+      }
+  
+      bb0: {
++         _5 = const false;
++         _5 = const true;
+          PlaceMention(_1);
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [0: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          _0 = Option::<String>::None;
+          goto -> bb5;
+      }
+  
+      bb2: {
+          StorageLive(_3);
+          _3 = move ((_1 as Ok).0: std::string::String);
+          StorageLive(_4);
+          _4 = move _3;
+          _0 = Option::<String>::Some(move _4);
+-         drop(_4) -> [return: bb3, unwind: bb7];
++         goto -> bb3;
+      }
+  
+      bb3: {
+          StorageDead(_4);
+-         drop(_3) -> [return: bb4, unwind: bb8];
++         goto -> bb4;
+      }
+  
+      bb4: {
+          StorageDead(_3);
+          goto -> bb5;
+      }
+  
+      bb5: {
+-         drop(_1) -> [return: bb6, unwind: bb9];
++         goto -> bb16;
+      }
+  
+      bb6: {
+          return;
+      }
+  
+      bb7 (cleanup): {
+-         drop(_3) -> [return: bb8, unwind terminate(cleanup)];
++         goto -> bb8;
+      }
+  
+      bb8 (cleanup): {
+-         drop(_1) -> [return: bb9, unwind terminate(cleanup)];
++         goto -> bb9;
+      }
+  
+      bb9 (cleanup): {
+          resume;
++     }
++ 
++     bb10: {
++         goto -> bb6;
++     }
++ 
++     bb11 (cleanup): {
++         goto -> bb9;
++     }
++ 
++     bb12 (cleanup): {
++         goto -> bb9;
++     }
++ 
++     bb13: {
++         goto -> bb10;
++     }
++ 
++     bb14: {
++         goto -> bb10;
++     }
++ 
++     bb15 (cleanup): {
++         goto -> bb9;
++     }
++ 
++     bb16: {
++         _6 = discriminant(_1);
++         switchInt(move _6) -> [0: bb13, otherwise: bb14];
++     }
++ 
++     bb17 (cleanup): {
++         _7 = discriminant(_1);
++         switchInt(move _7) -> [0: bb11, otherwise: bb15];
+      }
+  }
+  
diff --git a/tests/mir-opt/otherwise_drops.rs b/tests/mir-opt/otherwise_drops.rs
new file mode 100644
index 00000000000..c4bc05b593c
--- /dev/null
+++ b/tests/mir-opt/otherwise_drops.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -C panic=abort
+//@ test-mir-pass: ElaborateDrops
+
+// Ensures there are no drops for the wildcard match arm.
+
+// EMIT_MIR otherwise_drops.result_ok.ElaborateDrops.diff
+fn result_ok(result: Result<String, ()>) -> Option<String> {
+    // CHECK-NOT: drop
+    match result {
+        Ok(s) => Some(s),
+        _ => None,
+    }
+}
diff --git a/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff
index e2d3c6c41b8..0d5fcf9ef14 100644
--- a/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff
+++ b/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff
@@ -96,7 +96,6 @@
   
       bb2: {
           StorageLive(_8);
-          _28 = const false;
           _8 = move ((_5 as Ok).0: std::boxed::Box<dyn std::fmt::Display>);
           StorageLive(_9);
           StorageLive(_10);
@@ -186,7 +185,7 @@
       bb9: {
           StorageDead(_6);
           _29 = discriminant(_5);
-          switchInt(move _29) -> [0: bb11, otherwise: bb13];
+          switchInt(move _29) -> [0: bb10, otherwise: bb11];
       }
   
       bb10: {
@@ -200,14 +199,6 @@
       }
   
       bb11: {
-          switchInt(copy _28) -> [0: bb10, otherwise: bb12];
-      }
-  
-      bb12: {
-          drop(((_5 as Ok).0: std::boxed::Box<dyn std::fmt::Display>)) -> [return: bb10, unwind unreachable];
-      }
-  
-      bb13: {
           drop(_5) -> [return: bb10, unwind unreachable];
       }
   }
-- 
cgit 1.4.1-3-g733a5


From ba4235bc855fedcf33b3b10496efaae55170ed4e Mon Sep 17 00:00:00 2001
From: Dillon Amburgey <dillona@dillona.com>
Date: Tue, 8 Jul 2025 18:45:36 -0500
Subject: fix: correct typo in attr_parsing_previously_accepted message key

---
 compiler/rustc_attr_parsing/messages.ftl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
index 8a709ea5d20..bec3a1e8a59 100644
--- a/compiler/rustc_attr_parsing/messages.ftl
+++ b/compiler/rustc_attr_parsing/messages.ftl
@@ -146,12 +146,12 @@ attr_parsing_unused_duplicate =
     unused attribute
     .suggestion = remove this attribute
     .note = attribute also specified here
-    .warn = {-passes_previously_accepted}
+    .warn = {-attr_parsing_previously_accepted}
 
 attr_parsing_unused_multiple =
     multiple `{$name}` attributes
     .suggestion = remove this attribute
     .note = attribute also specified here
 
--attr_parsing_perviously_accepted =
+-attr_parsing_previously_accepted =
     this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-- 
cgit 1.4.1-3-g733a5


From 87e7539fcdfa45b2aab618c044f888432c5d097d Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Tue, 8 Jul 2025 16:38:35 -0700
Subject: Disable docs for `compiler-builtins` and `sysroot`

Bootstrap already had a manual doc filter for the `sysroot` crate, but
other library crates keep themselves out of the public docs by setting
`[lib] doc = false` in their manifest. This seems like a better solution
to hide `compiler-builtins` docs, and removes the `sysroot` hack too.
---
 library/compiler-builtins/compiler-builtins/Cargo.toml | 2 ++
 library/sysroot/Cargo.toml                             | 4 ++++
 src/bootstrap/src/core/build_steps/doc.rs              | 4 ----
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/library/compiler-builtins/compiler-builtins/Cargo.toml b/library/compiler-builtins/compiler-builtins/Cargo.toml
index c5446cd76e3..3ccb05f73fb 100644
--- a/library/compiler-builtins/compiler-builtins/Cargo.toml
+++ b/library/compiler-builtins/compiler-builtins/Cargo.toml
@@ -19,6 +19,8 @@ links = "compiler-rt"
 bench = false
 doctest = false
 test = false
+# make sure this crate isn't included in public standard library docs
+doc = false
 
 [dependencies]
 core = { path = "../../core", optional = true }
diff --git a/library/sysroot/Cargo.toml b/library/sysroot/Cargo.toml
index 3adc0224971..514728887fb 100644
--- a/library/sysroot/Cargo.toml
+++ b/library/sysroot/Cargo.toml
@@ -5,6 +5,10 @@ name = "sysroot"
 version = "0.0.0"
 edition = "2024"
 
+[lib]
+# make sure this crate isn't included in public standard library docs
+doc = false
+
 # this is a dummy crate to ensure that all required crates appear in the sysroot
 [dependencies]
 proc_macro = { path = "../proc_macro", public = true }
diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index f7c4c5ad0bb..9e839b11c08 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -739,10 +739,6 @@ fn doc_std(
     }
 
     for krate in requested_crates {
-        if krate == "sysroot" {
-            // The sysroot crate is an implementation detail, don't include it in public docs.
-            continue;
-        }
         cargo.arg("-p").arg(krate);
     }
 
-- 
cgit 1.4.1-3-g733a5


From 3c7bf9fe01aacd7205c755cb898c94de68fcd1fd Mon Sep 17 00:00:00 2001
From: Nico Lehmann <nico.lehmannm@gmail.com>
Date: Tue, 8 Jul 2025 18:07:14 -0700
Subject: Expose nested bodies in rustc_borrowck::consumers

---
 compiler/rustc_borrowck/src/consumers.rs           | 81 +++++++++++++++-------
 compiler/rustc_borrowck/src/lib.rs                 | 43 +++++-------
 compiler/rustc_borrowck/src/nll.rs                 |  6 +-
 compiler/rustc_borrowck/src/root_cx.rs             | 13 +++-
 .../ui-fulldeps/auxiliary/obtain-borrowck-input.rs |  4 ++
 tests/ui-fulldeps/obtain-borrowck.rs               | 20 +++---
 tests/ui-fulldeps/obtain-borrowck.run.stdout       |  2 +
 7 files changed, 107 insertions(+), 62 deletions(-)

diff --git a/compiler/rustc_borrowck/src/consumers.rs b/compiler/rustc_borrowck/src/consumers.rs
index 1f087b09234..1c4ff5a6779 100644
--- a/compiler/rustc_borrowck/src/consumers.rs
+++ b/compiler/rustc_borrowck/src/consumers.rs
@@ -1,7 +1,9 @@
 //! This file provides API for compiler consumers.
 
+use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::LocalDefId;
 use rustc_index::IndexVec;
+use rustc_middle::bug;
 use rustc_middle::mir::{Body, Promoted};
 use rustc_middle::ty::TyCtxt;
 
@@ -17,7 +19,39 @@ pub use super::polonius::legacy::{
 pub use super::region_infer::RegionInferenceContext;
 use crate::{BorrowCheckRootCtxt, do_mir_borrowck};
 
-/// Options determining the output behavior of [`get_body_with_borrowck_facts`].
+/// Struct used during mir borrowck to collect bodies with facts for a typeck root and all
+/// its nested bodies.
+pub(crate) struct BorrowckConsumer<'tcx> {
+    options: ConsumerOptions,
+    bodies: FxHashMap<LocalDefId, BodyWithBorrowckFacts<'tcx>>,
+}
+
+impl<'tcx> BorrowckConsumer<'tcx> {
+    pub(crate) fn new(options: ConsumerOptions) -> Self {
+        Self { options, bodies: Default::default() }
+    }
+
+    pub(crate) fn insert_body(&mut self, def_id: LocalDefId, body: BodyWithBorrowckFacts<'tcx>) {
+        if self.bodies.insert(def_id, body).is_some() {
+            bug!("unexpected previous body for {def_id:?}");
+        }
+    }
+
+    /// Should the Polonius input facts be computed?
+    pub(crate) fn polonius_input(&self) -> bool {
+        matches!(
+            self.options,
+            ConsumerOptions::PoloniusInputFacts | ConsumerOptions::PoloniusOutputFacts
+        )
+    }
+
+    /// Should we run Polonius and collect the output facts?
+    pub(crate) fn polonius_output(&self) -> bool {
+        matches!(self.options, ConsumerOptions::PoloniusOutputFacts)
+    }
+}
+
+/// Options determining the output behavior of [`get_bodies_with_borrowck_facts`].
 ///
 /// If executing under `-Z polonius` the choice here has no effect, and everything as if
 /// [`PoloniusOutputFacts`](ConsumerOptions::PoloniusOutputFacts) had been selected
@@ -43,17 +77,6 @@ pub enum ConsumerOptions {
     PoloniusOutputFacts,
 }
 
-impl ConsumerOptions {
-    /// Should the Polonius input facts be computed?
-    pub(crate) fn polonius_input(&self) -> bool {
-        matches!(self, Self::PoloniusInputFacts | Self::PoloniusOutputFacts)
-    }
-    /// Should we run Polonius and collect the output facts?
-    pub(crate) fn polonius_output(&self) -> bool {
-        matches!(self, Self::PoloniusOutputFacts)
-    }
-}
-
 /// A `Body` with information computed by the borrow checker. This struct is
 /// intended to be consumed by compiler consumers.
 ///
@@ -82,25 +105,35 @@ pub struct BodyWithBorrowckFacts<'tcx> {
     pub output_facts: Option<Box<PoloniusOutput>>,
 }
 
-/// This function computes borrowck facts for the given body. The [`ConsumerOptions`]
-/// determine which facts are returned. This function makes a copy of the body because
-/// it needs to regenerate the region identifiers. It should never be invoked during a
-/// typical compilation session due to the unnecessary overhead of returning
-/// [`BodyWithBorrowckFacts`].
+/// This function computes borrowck facts for the given def id and all its nested bodies.
+/// It must be called with a typeck root which will then borrowck all nested bodies as well.
+/// The [`ConsumerOptions`] determine which facts are returned. This function makes a copy
+/// of the bodies because it needs to regenerate the region identifiers. It should never be
+/// invoked during a typical compilation session due to the unnecessary overhead of
+/// returning [`BodyWithBorrowckFacts`].
 ///
 /// Note:
-/// *   This function will panic if the required body was already stolen. This
+/// *   This function will panic if the required bodies were already stolen. This
 ///     can, for example, happen when requesting a body of a `const` function
 ///     because they are evaluated during typechecking. The panic can be avoided
 ///     by overriding the `mir_borrowck` query. You can find a complete example
-///     that shows how to do this at `tests/run-make/obtain-borrowck/`.
+///     that shows how to do this at `tests/ui-fulldeps/obtain-borrowck.rs`.
 ///
 /// *   Polonius is highly unstable, so expect regular changes in its signature or other details.
-pub fn get_body_with_borrowck_facts(
+pub fn get_bodies_with_borrowck_facts(
     tcx: TyCtxt<'_>,
-    def_id: LocalDefId,
+    root_def_id: LocalDefId,
     options: ConsumerOptions,
-) -> BodyWithBorrowckFacts<'_> {
-    let mut root_cx = BorrowCheckRootCtxt::new(tcx, def_id);
-    *do_mir_borrowck(&mut root_cx, def_id, Some(options)).1.unwrap()
+) -> FxHashMap<LocalDefId, BodyWithBorrowckFacts<'_>> {
+    let mut root_cx =
+        BorrowCheckRootCtxt::new(tcx, root_def_id, Some(BorrowckConsumer::new(options)));
+
+    // See comment in `rustc_borrowck::mir_borrowck`
+    let nested_bodies = tcx.nested_bodies_within(root_def_id);
+    for def_id in nested_bodies {
+        root_cx.get_or_insert_nested(def_id);
+    }
+
+    do_mir_borrowck(&mut root_cx, root_def_id);
+    root_cx.consumer.unwrap().bodies
 }
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 82b300dcb17..321b18c9b78 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -51,7 +51,7 @@ use smallvec::SmallVec;
 use tracing::{debug, instrument};
 
 use crate::borrow_set::{BorrowData, BorrowSet};
-use crate::consumers::{BodyWithBorrowckFacts, ConsumerOptions};
+use crate::consumers::BodyWithBorrowckFacts;
 use crate::dataflow::{BorrowIndex, Borrowck, BorrowckDomain, Borrows};
 use crate::diagnostics::{
     AccessKind, BorrowckDiagnosticsBuffer, IllegalMoveOriginKind, MoveError, RegionName,
@@ -124,7 +124,7 @@ fn mir_borrowck(
         let opaque_types = ConcreteOpaqueTypes(Default::default());
         Ok(tcx.arena.alloc(opaque_types))
     } else {
-        let mut root_cx = BorrowCheckRootCtxt::new(tcx, def);
+        let mut root_cx = BorrowCheckRootCtxt::new(tcx, def, None);
         // We need to manually borrowck all nested bodies from the HIR as
         // we do not generate MIR for dead code. Not doing so causes us to
         // never check closures in dead code.
@@ -134,7 +134,7 @@ fn mir_borrowck(
         }
 
         let PropagatedBorrowCheckResults { closure_requirements, used_mut_upvars } =
-            do_mir_borrowck(&mut root_cx, def, None).0;
+            do_mir_borrowck(&mut root_cx, def);
         debug_assert!(closure_requirements.is_none());
         debug_assert!(used_mut_upvars.is_empty());
         root_cx.finalize()
@@ -289,17 +289,12 @@ impl<'tcx> ClosureOutlivesSubjectTy<'tcx> {
 
 /// Perform the actual borrow checking.
 ///
-/// Use `consumer_options: None` for the default behavior of returning
-/// [`PropagatedBorrowCheckResults`] only. Otherwise, return [`BodyWithBorrowckFacts`]
-/// according to the given [`ConsumerOptions`].
-///
 /// For nested bodies this should only be called through `root_cx.get_or_insert_nested`.
 #[instrument(skip(root_cx), level = "debug")]
 fn do_mir_borrowck<'tcx>(
     root_cx: &mut BorrowCheckRootCtxt<'tcx>,
     def: LocalDefId,
-    consumer_options: Option<ConsumerOptions>,
-) -> (PropagatedBorrowCheckResults<'tcx>, Option<Box<BodyWithBorrowckFacts<'tcx>>>) {
+) -> PropagatedBorrowCheckResults<'tcx> {
     let tcx = root_cx.tcx;
     let infcx = BorrowckInferCtxt::new(tcx, def);
     let (input_body, promoted) = tcx.mir_promoted(def);
@@ -343,7 +338,6 @@ fn do_mir_borrowck<'tcx>(
         &location_table,
         &move_data,
         &borrow_set,
-        consumer_options,
     );
 
     // Dump MIR results into a file, if that is enabled. This lets us
@@ -483,23 +477,24 @@ fn do_mir_borrowck<'tcx>(
         used_mut_upvars: mbcx.used_mut_upvars,
     };
 
-    let body_with_facts = if consumer_options.is_some() {
-        Some(Box::new(BodyWithBorrowckFacts {
-            body: body_owned,
-            promoted,
-            borrow_set,
-            region_inference_context: regioncx,
-            location_table: polonius_input.as_ref().map(|_| location_table),
-            input_facts: polonius_input,
-            output_facts: polonius_output,
-        }))
-    } else {
-        None
-    };
+    if let Some(consumer) = &mut root_cx.consumer {
+        consumer.insert_body(
+            def,
+            BodyWithBorrowckFacts {
+                body: body_owned,
+                promoted,
+                borrow_set,
+                region_inference_context: regioncx,
+                location_table: polonius_input.as_ref().map(|_| location_table),
+                input_facts: polonius_input,
+                output_facts: polonius_output,
+            },
+        );
+    }
 
     debug!("do_mir_borrowck: result = {:#?}", result);
 
-    (result, body_with_facts)
+    result
 }
 
 fn get_flow_results<'a, 'tcx>(
diff --git a/compiler/rustc_borrowck/src/nll.rs b/compiler/rustc_borrowck/src/nll.rs
index af450507296..41f67e78930 100644
--- a/compiler/rustc_borrowck/src/nll.rs
+++ b/compiler/rustc_borrowck/src/nll.rs
@@ -18,7 +18,6 @@ use rustc_span::sym;
 use tracing::{debug, instrument};
 
 use crate::borrow_set::BorrowSet;
-use crate::consumers::ConsumerOptions;
 use crate::diagnostics::RegionErrors;
 use crate::handle_placeholders::compute_sccs_applying_placeholder_outlives_constraints;
 use crate::polonius::PoloniusDiagnosticsContext;
@@ -83,12 +82,11 @@ pub(crate) fn compute_regions<'tcx>(
     location_table: &PoloniusLocationTable,
     move_data: &MoveData<'tcx>,
     borrow_set: &BorrowSet<'tcx>,
-    consumer_options: Option<ConsumerOptions>,
 ) -> NllOutput<'tcx> {
     let is_polonius_legacy_enabled = infcx.tcx.sess.opts.unstable_opts.polonius.is_legacy_enabled();
-    let polonius_input = consumer_options.map(|c| c.polonius_input()).unwrap_or_default()
+    let polonius_input = root_cx.consumer.as_ref().map_or(false, |c| c.polonius_input())
         || is_polonius_legacy_enabled;
-    let polonius_output = consumer_options.map(|c| c.polonius_output()).unwrap_or_default()
+    let polonius_output = root_cx.consumer.as_ref().map_or(false, |c| c.polonius_output())
         || is_polonius_legacy_enabled;
     let mut polonius_facts =
         (polonius_input || PoloniusFacts::enabled(infcx.tcx)).then_some(PoloniusFacts::default());
diff --git a/compiler/rustc_borrowck/src/root_cx.rs b/compiler/rustc_borrowck/src/root_cx.rs
index 66b526fa02a..9b1d12aede5 100644
--- a/compiler/rustc_borrowck/src/root_cx.rs
+++ b/compiler/rustc_borrowck/src/root_cx.rs
@@ -6,6 +6,7 @@ use rustc_middle::ty::{OpaqueHiddenType, Ty, TyCtxt, TypeVisitableExt};
 use rustc_span::ErrorGuaranteed;
 use smallvec::SmallVec;
 
+use crate::consumers::BorrowckConsumer;
 use crate::{ClosureRegionRequirements, ConcreteOpaqueTypes, PropagatedBorrowCheckResults};
 
 /// The shared context used by both the root as well as all its nested
@@ -16,16 +17,24 @@ pub(super) struct BorrowCheckRootCtxt<'tcx> {
     concrete_opaque_types: ConcreteOpaqueTypes<'tcx>,
     nested_bodies: FxHashMap<LocalDefId, PropagatedBorrowCheckResults<'tcx>>,
     tainted_by_errors: Option<ErrorGuaranteed>,
+    /// This should be `None` during normal compilation. See [`crate::consumers`] for more
+    /// information on how this is used.
+    pub(crate) consumer: Option<BorrowckConsumer<'tcx>>,
 }
 
 impl<'tcx> BorrowCheckRootCtxt<'tcx> {
-    pub(super) fn new(tcx: TyCtxt<'tcx>, root_def_id: LocalDefId) -> BorrowCheckRootCtxt<'tcx> {
+    pub(super) fn new(
+        tcx: TyCtxt<'tcx>,
+        root_def_id: LocalDefId,
+        consumer: Option<BorrowckConsumer<'tcx>>,
+    ) -> BorrowCheckRootCtxt<'tcx> {
         BorrowCheckRootCtxt {
             tcx,
             root_def_id,
             concrete_opaque_types: Default::default(),
             nested_bodies: Default::default(),
             tainted_by_errors: None,
+            consumer,
         }
     }
 
@@ -71,7 +80,7 @@ impl<'tcx> BorrowCheckRootCtxt<'tcx> {
             self.root_def_id.to_def_id()
         );
         if !self.nested_bodies.contains_key(&def_id) {
-            let result = super::do_mir_borrowck(self, def_id, None).0;
+            let result = super::do_mir_borrowck(self, def_id);
             if let Some(prev) = self.nested_bodies.insert(def_id, result) {
                 bug!("unexpected previous nested body: {prev:?}");
             }
diff --git a/tests/ui-fulldeps/auxiliary/obtain-borrowck-input.rs b/tests/ui-fulldeps/auxiliary/obtain-borrowck-input.rs
index 7213e06792a..9cfc901eabe 100644
--- a/tests/ui-fulldeps/auxiliary/obtain-borrowck-input.rs
+++ b/tests/ui-fulldeps/auxiliary/obtain-borrowck-input.rs
@@ -28,6 +28,10 @@ const fn foo() -> usize {
     1
 }
 
+fn with_nested_body(opt: Option<i32>) -> Option<i32> {
+    opt.map(|x| x + 1)
+}
+
 fn main() {
     let bar: [Bar; foo()] = [Bar::new()];
     assert_eq!(bar[0].provided(), foo());
diff --git a/tests/ui-fulldeps/obtain-borrowck.rs b/tests/ui-fulldeps/obtain-borrowck.rs
index 84f6970c83a..08213fd7588 100644
--- a/tests/ui-fulldeps/obtain-borrowck.rs
+++ b/tests/ui-fulldeps/obtain-borrowck.rs
@@ -9,16 +9,17 @@
 
 //! This program implements a rustc driver that retrieves MIR bodies with
 //! borrowck information. This cannot be done in a straightforward way because
-//! `get_body_with_borrowck_facts`–the function for retrieving a MIR body with
-//! borrowck facts–can panic if the body is stolen before it is invoked.
+//! `get_bodies_with_borrowck_facts`–the function for retrieving MIR bodies with
+//! borrowck facts–can panic if the bodies are stolen before it is invoked.
 //! Therefore, the driver overrides `mir_borrowck` query (this is done in the
-//! `config` callback), which retrieves the body that is about to be borrow
-//! checked and stores it in a thread local `MIR_BODIES`. Then, `after_analysis`
+//! `config` callback), which retrieves the bodies that are about to be borrow
+//! checked and stores them in a thread local `MIR_BODIES`. Then, `after_analysis`
 //! callback triggers borrow checking of all MIR bodies by retrieving
 //! `optimized_mir` and pulls out the MIR bodies with the borrowck information
 //! from the thread local storage.
 
 extern crate rustc_borrowck;
+extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_hir;
 extern crate rustc_interface;
@@ -30,6 +31,7 @@ use std::collections::HashMap;
 use std::thread_local;
 
 use rustc_borrowck::consumers::{self, BodyWithBorrowckFacts, ConsumerOptions};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_driver::Compilation;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalDefId;
@@ -129,13 +131,15 @@ thread_local! {
 
 fn mir_borrowck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> ProvidedValue<'tcx> {
     let opts = ConsumerOptions::PoloniusInputFacts;
-    let body_with_facts = consumers::get_body_with_borrowck_facts(tcx, def_id, opts);
+    let bodies_with_facts = consumers::get_bodies_with_borrowck_facts(tcx, def_id, opts);
     // SAFETY: The reader casts the 'static lifetime to 'tcx before using it.
-    let body_with_facts: BodyWithBorrowckFacts<'static> =
-        unsafe { std::mem::transmute(body_with_facts) };
+    let bodies_with_facts: FxHashMap<LocalDefId, BodyWithBorrowckFacts<'static>> =
+        unsafe { std::mem::transmute(bodies_with_facts) };
     MIR_BODIES.with(|state| {
         let mut map = state.borrow_mut();
-        assert!(map.insert(def_id, body_with_facts).is_none());
+        for (def_id, body_with_facts) in bodies_with_facts {
+            assert!(map.insert(def_id, body_with_facts).is_none());
+        }
     });
     let mut providers = Providers::default();
     rustc_borrowck::provide(&mut providers);
diff --git a/tests/ui-fulldeps/obtain-borrowck.run.stdout b/tests/ui-fulldeps/obtain-borrowck.run.stdout
index e011622e6b2..09d3e50f42d 100644
--- a/tests/ui-fulldeps/obtain-borrowck.run.stdout
+++ b/tests/ui-fulldeps/obtain-borrowck.run.stdout
@@ -3,6 +3,8 @@ Bodies retrieved for:
 ::foo
 ::main
 ::main::{constant#0}
+::with_nested_body
+::with_nested_body::{closure#0}
 ::{impl#0}::new
 ::{impl#1}::provided
 ::{impl#1}::required
-- 
cgit 1.4.1-3-g733a5


From 663733584561320e07623205f2c2dfcf43c375c1 Mon Sep 17 00:00:00 2001
From: B I Mohammed Abbas <bimohammadabbas@gmail.com>
Date: Wed, 9 Jul 2025 09:54:08 +0530
Subject: Fix VxWorks build errors

---
 library/std/src/sys/fs/unix.rs         | 1 -
 library/std/src/sys/pal/unix/thread.rs | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index dc278274f00..b310db2dac4 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -1491,7 +1491,6 @@ impl File {
             target_os = "redox",
             target_os = "espidf",
             target_os = "horizon",
-            target_os = "vxworks",
             target_os = "nuttx",
         )))]
         let to_timespec = |time: Option<SystemTime>| match time {
diff --git a/library/std/src/sys/pal/unix/thread.rs b/library/std/src/sys/pal/unix/thread.rs
index 53f0d1eeda5..e4f5520d8a3 100644
--- a/library/std/src/sys/pal/unix/thread.rs
+++ b/library/std/src/sys/pal/unix/thread.rs
@@ -222,7 +222,7 @@ impl Thread {
 
     #[cfg(target_os = "vxworks")]
     pub fn set_name(name: &CStr) {
-        let mut name = truncate_cstr::<{ libc::VX_TASK_RENAME_LENGTH - 1 }>(name);
+        let mut name = truncate_cstr::<{ (libc::VX_TASK_RENAME_LENGTH - 1) as usize }>(name);
         let res = unsafe { libc::taskNameSet(libc::taskIdSelf(), name.as_mut_ptr()) };
         debug_assert_eq!(res, libc::OK);
     }
-- 
cgit 1.4.1-3-g733a5


From 6b8bc68a503e0b27828404270759ab3523b1c91a Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Wed, 9 Jul 2025 07:13:44 +0200
Subject: use a consistent (and recommended) invocation

./x is recommended over running ./x.py directly,
and is the more commonly-used invocation of bootstrap in the guide
---
 src/doc/rustc-dev-guide/src/autodiff/installation.md | 10 +++++-----
 src/doc/rustc-dev-guide/src/offload/installation.md  |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/autodiff/installation.md b/src/doc/rustc-dev-guide/src/autodiff/installation.md
index c9b28dc43a6..92e79b2f383 100644
--- a/src/doc/rustc-dev-guide/src/autodiff/installation.md
+++ b/src/doc/rustc-dev-guide/src/autodiff/installation.md
@@ -13,7 +13,7 @@ cd rust
 
 Afterwards you can build rustc using:
 ```bash
-./x.py build --stage 1 library
+./x build --stage 1 library
 ```
 
 Afterwards rustc toolchain link will allow you to use it through cargo:
@@ -25,10 +25,10 @@ rustup toolchain install nightly # enables -Z unstable-options
 You can then run our test cases:
 
 ```bash
-./x.py test --stage 1 tests/codegen/autodiff
-./x.py test --stage 1 tests/pretty/autodiff
-./x.py test --stage 1 tests/ui/autodiff
-./x.py test --stage 1 tests/ui/feature-gates/feature-gate-autodiff.rs
+./x test --stage 1 tests/codegen/autodiff
+./x test --stage 1 tests/pretty/autodiff
+./x test --stage 1 tests/ui/autodiff
+./x test --stage 1 tests/ui/feature-gates/feature-gate-autodiff.rs
 ```
 
 Autodiff is still experimental, so if you want to use it in your own projects, you will need to add `lto="fat"` to your Cargo.toml 
diff --git a/src/doc/rustc-dev-guide/src/offload/installation.md b/src/doc/rustc-dev-guide/src/offload/installation.md
index 2536af09a23..8cfec44ec8e 100644
--- a/src/doc/rustc-dev-guide/src/offload/installation.md
+++ b/src/doc/rustc-dev-guide/src/offload/installation.md
@@ -13,7 +13,7 @@ cd rust
 
 Afterwards you can build rustc using:
 ```bash
-./x.py build --stage 1 library
+./x build --stage 1 library
 ```
 
 Afterwards rustc toolchain link will allow you to use it through cargo:
@@ -40,7 +40,7 @@ This gives you a working LLVM build.
 ## Testing
 run
 ```
-./x.py test --stage 1 tests/codegen/gpu_offload
+./x test --stage 1 tests/codegen/gpu_offload
 ```
 
 ## Usage
-- 
cgit 1.4.1-3-g733a5


From 7b394d2650472866162adb1e3e775d7c43ed8854 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Wed, 9 Jul 2025 07:28:16 +0200
Subject: tweak some git clone commands

- --depth=1 is more useful for once-off uses, like on ci
- .git postfix on github repo url is not needed
---
 src/doc/rustc-dev-guide/src/autodiff/installation.md | 8 ++++----
 src/doc/rustc-dev-guide/src/offload/installation.md  | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/autodiff/installation.md b/src/doc/rustc-dev-guide/src/autodiff/installation.md
index 92e79b2f383..a550f6d233e 100644
--- a/src/doc/rustc-dev-guide/src/autodiff/installation.md
+++ b/src/doc/rustc-dev-guide/src/autodiff/installation.md
@@ -6,7 +6,7 @@ In the near future, `std::autodiff` should become available in nightly builds fo
 
 First you need to clone and configure the Rust repository:
 ```bash
-git clone --depth=1 git@github.com:rust-lang/rust.git
+git clone git@github.com:rust-lang/rust
 cd rust
 ./configure --enable-llvm-link-shared --enable-llvm-plugins --enable-llvm-enzyme --release-channel=nightly --enable-llvm-assertions --enable-clang --enable-lld --enable-option-checking --enable-ninja --disable-docs
 ```
@@ -45,7 +45,7 @@ apt install wget vim python3 git curl libssl-dev pkg-config lld ninja-build cmak
 ```
 Then build rustc in a slightly altered way:
 ```bash
-git clone --depth=1 https://github.com/rust-lang/rust.git
+git clone https://github.com/rust-lang/rust
 cd rust
 ./configure --enable-llvm-link-shared --enable-llvm-plugins --enable-llvm-enzyme --release-channel=nightly --enable-llvm-assertions --enable-clang --enable-lld --enable-option-checking --enable-ninja --disable-docs
 ./x dist
@@ -66,7 +66,7 @@ We recommend that approach, if you just want to use any of them and have no expe
 However, if you prefer to just build Enzyme without Rust, then these instructions might help.
 
 ```bash
-git clone --depth=1 git@github.com:llvm/llvm-project.git 
+git clone git@github.com:llvm/llvm-project
 cd llvm-project
 mkdir build
 cd build
@@ -77,7 +77,7 @@ ninja install
 This gives you a working LLVM build, now we can continue with building Enzyme.
 Leave the `llvm-project` folder, and execute the following commands:
 ```bash
-git clone git@github.com:EnzymeAD/Enzyme.git 
+git clone git@github.com:EnzymeAD/Enzyme
 cd Enzyme/enzyme
 mkdir build 
 cd build 
diff --git a/src/doc/rustc-dev-guide/src/offload/installation.md b/src/doc/rustc-dev-guide/src/offload/installation.md
index 8cfec44ec8e..1962314c70a 100644
--- a/src/doc/rustc-dev-guide/src/offload/installation.md
+++ b/src/doc/rustc-dev-guide/src/offload/installation.md
@@ -6,7 +6,7 @@ In the future, `std::offload` should become available in nightly builds for user
 
 First you need to clone and configure the Rust repository:
 ```bash
-git clone --depth=1 git@github.com:rust-lang/rust.git
+git clone git@github.com:rust-lang/rust
 cd rust
 ./configure --enable-llvm-link-shared --release-channel=nightly --enable-llvm-assertions --enable-offload --enable-enzyme --enable-clang --enable-lld --enable-option-checking --enable-ninja --disable-docs
 ```
@@ -26,7 +26,7 @@ rustup toolchain install nightly # enables -Z unstable-options
 
 ## Build instruction for LLVM itself
 ```bash
-git clone --depth=1 git@github.com:llvm/llvm-project.git 
+git clone git@github.com:llvm/llvm-project
 cd llvm-project
 mkdir build
 cd build
-- 
cgit 1.4.1-3-g733a5


From 15940b8beae3d6b9e06c239c81dd2d094f1ca9c0 Mon Sep 17 00:00:00 2001
From: Marcin Kolny <mkolny@amazon.com>
Date: Wed, 9 Jul 2025 07:40:01 +0100
Subject: Add a new maintainer to the wasm32-wasip1 target

---
 src/doc/rustc/src/platform-support/wasm32-wasip1.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip1.md b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
index 1e7447698bc..a8a9e550581 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip1.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
@@ -42,6 +42,7 @@ said since when this document was last updated those interested in maintaining
 this target are:
 
 [@alexcrichton](https://github.com/alexcrichton)
+[@loganek](https://github.com/loganek)
 
 ## Requirements
 
-- 
cgit 1.4.1-3-g733a5


From 566dc98d2a614288df7a961009edb992e4d59895 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Wed, 9 Jul 2025 09:47:37 +0200
Subject: Add `doc library` test for a no_std target

---
 src/bootstrap/src/core/builder/tests.rs | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index b1e8150a20f..cf0cb3a77b1 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1551,7 +1551,7 @@ mod snapshot {
     }
 
     #[test]
-    fn doc_library_no_std_target() {
+    fn doc_core_no_std_target() {
         let ctx = TestCtx::new();
         insta::assert_snapshot!(
             ctx.config("doc")
@@ -1564,6 +1564,21 @@ mod snapshot {
         [doc] std 1 <host> crates=[core]
         ");
     }
+
+    #[test]
+    fn doc_library_no_std_target() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("doc")
+                .path("library")
+                .override_target_no_std(&host_target())
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustdoc 0 <host>
+        [doc] std 1 <host> crates=[alloc,core]
+        ");
+    }
 }
 
 struct ExecutedSteps {
@@ -1574,6 +1589,7 @@ impl ExecutedSteps {
     fn render(&self) -> String {
         self.render_with(RenderConfig::default())
     }
+
     fn render_with(&self, config: RenderConfig) -> String {
         render_steps(&self.steps, config)
     }
-- 
cgit 1.4.1-3-g733a5


From 6c38d389f26faf36a3b674f802c37804f5442c0d Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Wed, 9 Jul 2025 10:26:36 +0200
Subject: Add doc cross-compilation test

---
 src/bootstrap/src/core/builder/tests.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index cf0cb3a77b1..9ca79131b8d 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1579,6 +1579,22 @@ mod snapshot {
         [doc] std 1 <host> crates=[alloc,core]
         ");
     }
+
+    #[test]
+    fn doc_library_no_std_target_cross_compile() {
+        let ctx = TestCtx::new();
+        insta::assert_snapshot!(
+            ctx.config("doc")
+                .path("library")
+                .targets(&[TEST_TRIPLE_1])
+                .override_target_no_std(TEST_TRIPLE_1)
+                .render_steps(), @r"
+        [build] llvm <host>
+        [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustdoc 0 <host>
+        [doc] std 1 <target1> crates=[alloc,core]
+        ");
+    }
 }
 
 struct ExecutedSteps {
-- 
cgit 1.4.1-3-g733a5


From 3bd0b8909ca743f8089d256d3a4443787f966315 Mon Sep 17 00:00:00 2001
From: Nia Espera <a5b6@riseup.net>
Date: Wed, 2 Jul 2025 02:55:41 +0200
Subject: various native-lib-trace-related fixups

Co-Authored-By: Ralf Jung <post@ralfj.de>
---
 src/tools/miri/src/alloc/isolated_alloc.rs         |  21 +-
 src/tools/miri/src/bin/miri.rs                     |  30 +-
 src/tools/miri/src/lib.rs                          |   8 +-
 src/tools/miri/src/shims/mod.rs                    |   4 +-
 src/tools/miri/src/shims/native_lib/mod.rs         |  96 ++++---
 src/tools/miri/src/shims/native_lib/trace/child.rs | 104 +++----
 .../miri/src/shims/native_lib/trace/messages.rs    |  47 +---
 src/tools/miri/src/shims/native_lib/trace/mod.rs   |   2 +
 .../miri/src/shims/native_lib/trace/parent.rs      | 304 +++++++++------------
 src/tools/miri/src/shims/native_lib/trace/stub.rs  |  34 +++
 10 files changed, 312 insertions(+), 338 deletions(-)
 create mode 100644 src/tools/miri/src/shims/native_lib/trace/stub.rs

diff --git a/src/tools/miri/src/alloc/isolated_alloc.rs b/src/tools/miri/src/alloc/isolated_alloc.rs
index a7bb9b4da75..7b2f1a3eebf 100644
--- a/src/tools/miri/src/alloc/isolated_alloc.rs
+++ b/src/tools/miri/src/alloc/isolated_alloc.rs
@@ -302,23 +302,20 @@ impl IsolatedAlloc {
         }
     }
 
-    /// Returns a vector of page addresses managed by the allocator.
-    pub fn pages(&self) -> Vec<usize> {
-        let mut pages: Vec<usize> =
-            self.page_ptrs.iter().map(|p| p.expose_provenance().get()).collect();
-        for (ptr, size) in self.huge_ptrs.iter() {
-            for i in 0..size / self.page_size {
-                pages.push(ptr.expose_provenance().get().strict_add(i * self.page_size));
-            }
-        }
-        pages
+    /// Returns a list of page addresses managed by the allocator.
+    pub fn pages(&self) -> impl Iterator<Item = usize> {
+        let pages = self.page_ptrs.iter().map(|p| p.expose_provenance().get());
+        pages.chain(self.huge_ptrs.iter().flat_map(|(ptr, size)| {
+            (0..size / self.page_size)
+                .map(|i| ptr.expose_provenance().get().strict_add(i * self.page_size))
+        }))
     }
 
     /// Protects all owned memory as `PROT_NONE`, preventing accesses.
     ///
     /// SAFETY: Accessing memory after this point will result in a segfault
     /// unless it is first unprotected.
-    pub unsafe fn prepare_ffi(&mut self) -> Result<(), nix::errno::Errno> {
+    pub unsafe fn start_ffi(&mut self) -> Result<(), nix::errno::Errno> {
         let prot = mman::ProtFlags::PROT_NONE;
         unsafe { self.mprotect(prot) }
     }
@@ -326,7 +323,7 @@ impl IsolatedAlloc {
     /// Deprotects all owned memory by setting it to RW. Erroring here is very
     /// likely unrecoverable, so it may panic if applying those permissions
     /// fails.
-    pub fn unprep_ffi(&mut self) {
+    pub fn end_ffi(&mut self) {
         let prot = mman::ProtFlags::PROT_READ | mman::ProtFlags::PROT_WRITE;
         unsafe {
             self.mprotect(prot).unwrap();
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index e3b579a4ac6..61cebedf081 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -233,8 +233,6 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
         } else {
             let return_code = miri::eval_entry(tcx, entry_def_id, entry_type, &config, None)
                 .unwrap_or_else(|| {
-                    //#[cfg(target_os = "linux")]
-                    //miri::native_lib::register_retcode_sv(rustc_driver::EXIT_FAILURE);
                     tcx.dcx().abort_if_errors();
                     rustc_driver::EXIT_FAILURE
                 });
@@ -337,6 +335,9 @@ impl rustc_driver::Callbacks for MiriBeRustCompilerCalls {
 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 code code.
+    #[cfg(target_os = "linux")]
+    miri::native_lib::register_retcode_sv(exit_code);
     std::process::exit(exit_code);
 }
 
@@ -355,6 +356,11 @@ fn run_compiler_and_exit(
     args: &[String],
     callbacks: &mut (dyn rustc_driver::Callbacks + Send),
 ) -> ! {
+    // Install the ctrlc handler that sets `rustc_const_eval::CTRL_C_RECEIVED`, even if
+    // MIRI_BE_RUSTC is set. We do this late so that when `native_lib::init_sv` is called,
+    // there are no other threads.
+    rustc_driver::install_ctrlc_handler();
+
     // Invoke compiler, catch any unwinding panics and handle return code.
     let exit_code =
         rustc_driver::catch_with_exit_code(move || rustc_driver::run_compiler(args, callbacks));
@@ -439,10 +445,6 @@ fn main() {
     let args = rustc_driver::catch_fatal_errors(|| rustc_driver::args::raw_args(&early_dcx))
         .unwrap_or_else(|_| std::process::exit(rustc_driver::EXIT_FAILURE));
 
-    // Install the ctrlc handler that sets `rustc_const_eval::CTRL_C_RECEIVED`, even if
-    // MIRI_BE_RUSTC is set.
-    rustc_driver::install_ctrlc_handler();
-
     // If the environment asks us to actually be rustc, then do that.
     if let Some(crate_kind) = env::var_os("MIRI_BE_RUSTC") {
         // Earliest rustc setup.
@@ -750,15 +752,15 @@ fn main() {
 
     debug!("rustc arguments: {:?}", rustc_args);
     debug!("crate arguments: {:?}", miri_config.args);
-    #[cfg(target_os = "linux")]
     if !miri_config.native_lib.is_empty() && miri_config.native_lib_enable_tracing {
-        // FIXME: This should display a diagnostic / warning on error
-        // SAFETY: If any other threads exist at this point (namely for the ctrlc
-        // handler), they will not interact with anything on the main rustc/Miri
-        // thread in an async-signal-unsafe way such as by accessing shared
-        // semaphores, etc.; the handler only calls `sleep()` and `exit()`, which
-        // are async-signal-safe, as is accessing atomics
-        //let _ = unsafe { miri::native_lib::init_sv() };
+        // SAFETY: No other threads are running
+        #[cfg(target_os = "linux")]
+        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\
+                Falling back to non-tracing native-lib mode."
+            );
+        }
     }
     run_compiler_and_exit(
         &rustc_args,
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 642b7ee9840..374f63a1660 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -96,10 +96,10 @@ pub use rustc_const_eval::interpret::{self, AllocMap, Provenance as _};
 use rustc_middle::{bug, span_bug};
 use tracing::{info, trace};
 
-//#[cfg(target_os = "linux")]
-//pub mod native_lib {
-//    pub use crate::shims::{init_sv, register_retcode_sv};
-//}
+#[cfg(target_os = "linux")]
+pub mod native_lib {
+    pub use crate::shims::{init_sv, register_retcode_sv};
+}
 
 // Type aliases that set the provenance parameter.
 pub type Pointer = interpret::Pointer<Option<machine::Provenance>>;
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index 60c0e289292..b08ab101e94 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -22,8 +22,8 @@ pub mod tls;
 pub mod unwind;
 
 pub use self::files::FdTable;
-//#[cfg(target_os = "linux")]
-//pub use self::native_lib::trace::{init_sv, register_retcode_sv};
+#[cfg(target_os = "linux")]
+pub use self::native_lib::trace::{init_sv, register_retcode_sv};
 pub use self::unix::{DirTable, EpollInterestTable};
 
 /// What needs to be done after emulating an item (a shim or an intrinsic) is done.
diff --git a/src/tools/miri/src/shims/native_lib/mod.rs b/src/tools/miri/src/shims/native_lib/mod.rs
index 9b30d8ce78b..d7432a7300e 100644
--- a/src/tools/miri/src/shims/native_lib/mod.rs
+++ b/src/tools/miri/src/shims/native_lib/mod.rs
@@ -1,9 +1,5 @@
 //! Implements calling functions from a native library.
 
-// FIXME: disabled since it fails to build on many targets.
-//#[cfg(target_os = "linux")]
-//pub mod trace;
-
 use std::ops::Deref;
 
 use libffi::high::call as ffi;
@@ -13,14 +9,55 @@ use rustc_middle::mir::interpret::Pointer;
 use rustc_middle::ty::{self as ty, IntTy, UintTy};
 use rustc_span::Symbol;
 
-//#[cfg(target_os = "linux")]
-//use self::trace::Supervisor;
+#[cfg_attr(
+    not(all(
+        target_os = "linux",
+        target_env = "gnu",
+        any(target_arch = "x86", target_arch = "x86_64")
+    )),
+    path = "trace/stub.rs"
+)]
+pub mod trace;
+
 use crate::*;
 
-//#[cfg(target_os = "linux")]
-//type CallResult<'tcx> = InterpResult<'tcx, (ImmTy<'tcx>, Option<self::trace::messages::MemEvents>)>;
-//#[cfg(not(target_os = "linux"))]
-type CallResult<'tcx> = InterpResult<'tcx, (ImmTy<'tcx>, Option<!>)>;
+/// The final results of an FFI trace, containing every relevant event detected
+/// by the tracer.
+#[allow(dead_code)]
+#[cfg_attr(target_os = "linux", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Debug)]
+pub struct MemEvents {
+    /// An list of memory accesses that occurred, in the order they occurred in.
+    pub acc_events: Vec<AccessEvent>,
+}
+
+/// A single memory access.
+#[allow(dead_code)]
+#[cfg_attr(target_os = "linux", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Debug)]
+pub enum AccessEvent {
+    /// A read may have occurred on this memory range.
+    /// Some instructions *may* read memory without *always* doing that,
+    /// so this can be an over-approximation.
+    /// The range info, however, is reliable if the access did happen.
+    Read(AccessRange),
+    /// A read may have occurred on this memory range.
+    /// Some instructions *may* write memory without *always* doing that,
+    /// so this can be an over-approximation.
+    /// The range info, however, is reliable if the access did happen.
+    Write(AccessRange),
+}
+
+/// The memory touched by a given access.
+#[allow(dead_code)]
+#[cfg_attr(target_os = "linux", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug)]
+pub struct AccessRange {
+    /// The base address in memory where an access occurred.
+    pub addr: usize,
+    /// The number of bytes affected from the base.
+    pub size: usize,
+}
 
 impl<'tcx> EvalContextExtPriv<'tcx> for crate::MiriInterpCx<'tcx> {}
 trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
@@ -31,18 +68,17 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         dest: &MPlaceTy<'tcx>,
         ptr: CodePtr,
         libffi_args: Vec<libffi::high::Arg<'a>>,
-    ) -> CallResult<'tcx> {
+    ) -> InterpResult<'tcx, (crate::ImmTy<'tcx>, Option<MemEvents>)> {
         let this = self.eval_context_mut();
-        //#[cfg(target_os = "linux")]
-        //let alloc = this.machine.allocator.as_ref().unwrap();
-
-        // SAFETY: We don't touch the machine memory past this point.
-        //#[cfg(target_os = "linux")]
-        //let (guard, stack_ptr) = unsafe { Supervisor::start_ffi(alloc) };
+        #[cfg(target_os = "linux")]
+        let alloc = this.machine.allocator.as_ref().unwrap();
+        #[cfg(not(target_os = "linux"))]
+        // Placeholder value.
+        let alloc = ();
 
-        // Call the function (`ptr`) with arguments `libffi_args`, and obtain the return value
-        // as the specified primitive integer type
-        let res = 'res: {
+        trace::Supervisor::do_ffi(alloc, || {
+            // Call the function (`ptr`) with arguments `libffi_args`, and obtain the return value
+            // as the specified primitive integer type
             let scalar = match dest.layout.ty.kind() {
                 // ints
                 ty::Int(IntTy::I8) => {
@@ -93,7 +129,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // have the output_type `Tuple([])`.
                 ty::Tuple(t_list) if (*t_list).deref().is_empty() => {
                     unsafe { ffi::call::<()>(ptr, libffi_args.as_slice()) };
-                    break 'res interp_ok(ImmTy::uninit(dest.layout));
+                    return interp_ok(ImmTy::uninit(dest.layout));
                 }
                 ty::RawPtr(..) => {
                     let x = unsafe { ffi::call::<*const ()>(ptr, libffi_args.as_slice()) };
@@ -101,23 +137,14 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     Scalar::from_pointer(ptr, this)
                 }
                 _ =>
-                    break 'res Err(err_unsup_format!(
+                    return Err(err_unsup_format!(
                         "unsupported return type for native call: {:?}",
                         link_name
                     ))
                     .into(),
             };
             interp_ok(ImmTy::from_scalar(scalar, dest.layout))
-        };
-
-        // SAFETY: We got the guard and stack pointer from start_ffi, and
-        // the allocator is the same
-        //#[cfg(target_os = "linux")]
-        //let events = unsafe { Supervisor::end_ffi(alloc, guard, stack_ptr) };
-        //#[cfg(not(target_os = "linux"))]
-        let events = None;
-
-        interp_ok((res?, events))
+        })
     }
 
     /// Get the pointer to the function of the specified name in the shared object file,
@@ -214,10 +241,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 if !this.machine.native_call_mem_warned.replace(true) {
                     // Newly set, so first time we get here.
                     this.emit_diagnostic(NonHaltingDiagnostic::NativeCallSharedMem {
-                        //#[cfg(target_os = "linux")]
-                        //tracing: self::trace::Supervisor::is_enabled(),
-                        //#[cfg(not(target_os = "linux"))]
-                        tracing: false,
+                        tracing: self::trace::Supervisor::is_enabled(),
                     });
                 }
 
diff --git a/src/tools/miri/src/shims/native_lib/trace/child.rs b/src/tools/miri/src/shims/native_lib/trace/child.rs
index 4961e875c77..de26cb0fe55 100644
--- a/src/tools/miri/src/shims/native_lib/trace/child.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/child.rs
@@ -4,12 +4,22 @@ use std::rc::Rc;
 use ipc_channel::ipc;
 use nix::sys::{ptrace, signal};
 use nix::unistd;
+use rustc_const_eval::interpret::InterpResult;
 
 use super::CALLBACK_STACK_SIZE;
-use super::messages::{Confirmation, MemEvents, StartFfiInfo, TraceRequest};
+use super::messages::{Confirmation, StartFfiInfo, TraceRequest};
 use super::parent::{ChildListener, sv_loop};
 use crate::alloc::isolated_alloc::IsolatedAlloc;
+use crate::shims::native_lib::MemEvents;
 
+/// A handle to the single, shared supervisor process across all `MiriMachine`s.
+/// Since it would be very difficult to trace multiple FFI calls in parallel, we
+/// need to ensure that either (a) only one `MiriMachine` is performing an FFI call
+/// at any given time, or (b) there are distinct supervisor and child processes for
+/// each machine. The former was chosen here.
+///
+/// This should only contain a `None` if the supervisor has not (yet) been initialised;
+/// otherwise, if `init_sv` was called and did not error, this will always be nonempty.
 static SUPERVISOR: std::sync::Mutex<Option<Supervisor>> = std::sync::Mutex::new(None);
 
 /// The main means of communication between the child and parent process,
@@ -34,32 +44,23 @@ impl Supervisor {
         SUPERVISOR.lock().unwrap().is_some()
     }
 
-    /// Begins preparations for doing an FFI call. This should be called at
-    /// the last possible moment before entering said call. `alloc` points to
-    /// the allocator which handed out the memory used for this machine.
-    ///
+    /// Performs an arbitrary FFI call, enabling tracing from the supervisor.
     /// As this locks the supervisor via a mutex, no other threads may enter FFI
-    /// until this one returns and its guard is dropped via `end_ffi`. The
-    /// pointer returned should be passed to `end_ffi` to avoid a memory leak.
-    ///
-    /// SAFETY: The resulting guard must be dropped *via `end_ffi`* immediately
-    /// after the desired call has concluded.
-    pub unsafe fn start_ffi(
+    /// until this function returns.
+    pub fn do_ffi<'tcx>(
         alloc: &Rc<RefCell<IsolatedAlloc>>,
-    ) -> (std::sync::MutexGuard<'static, Option<Supervisor>>, Option<*mut [u8; CALLBACK_STACK_SIZE]>)
-    {
+        f: impl FnOnce() -> InterpResult<'tcx, crate::ImmTy<'tcx>>,
+    ) -> InterpResult<'tcx, (crate::ImmTy<'tcx>, Option<MemEvents>)> {
         let mut sv_guard = SUPERVISOR.lock().unwrap();
-        // If the supervisor is not initialised for whatever reason, fast-fail.
-        // This might be desired behaviour, as even on platforms where ptracing
-        // is not implemented it enables us to enforce that only one FFI call
+        // If the supervisor is not initialised for whatever reason, fast-return.
+        // As a side-effect, even on platforms where ptracing
+        // is not implemented, we enforce that only one FFI call
         // happens at a time.
-        let Some(sv) = sv_guard.take() else {
-            return (sv_guard, None);
-        };
+        let Some(sv) = sv_guard.as_mut() else { return f().map(|v| (v, None)) };
 
         // Get pointers to all the pages the supervisor must allow accesses in
         // and prepare the callback stack.
-        let page_ptrs = alloc.borrow().pages();
+        let page_ptrs = alloc.borrow().pages().collect();
         let raw_stack_ptr: *mut [u8; CALLBACK_STACK_SIZE] =
             Box::leak(Box::new([0u8; CALLBACK_STACK_SIZE])).as_mut_ptr().cast();
         let stack_ptr = raw_stack_ptr.expose_provenance();
@@ -68,9 +69,9 @@ impl Supervisor {
         // SAFETY: We do not access machine memory past this point until the
         // supervisor is ready to allow it.
         unsafe {
-            if alloc.borrow_mut().prepare_ffi().is_err() {
+            if alloc.borrow_mut().start_ffi().is_err() {
                 // Don't mess up unwinding by maybe leaving the memory partly protected
-                alloc.borrow_mut().unprep_ffi();
+                alloc.borrow_mut().end_ffi();
                 panic!("Cannot protect memory for FFI call!");
             }
         }
@@ -82,27 +83,13 @@ impl Supervisor {
         // enforce an ordering for these events.
         sv.message_tx.send(TraceRequest::StartFfi(start_info)).unwrap();
         sv.confirm_rx.recv().unwrap();
-        *sv_guard = Some(sv);
         // We need to be stopped for the supervisor to be able to make certain
         // modifications to our memory - simply waiting on the recv() doesn't
         // count.
         signal::raise(signal::SIGSTOP).unwrap();
-        (sv_guard, Some(raw_stack_ptr))
-    }
 
-    /// Undoes FFI-related preparations, allowing Miri to continue as normal, then
-    /// gets the memory accesses and changes performed during the FFI call. Note
-    /// that this may include some spurious accesses done by `libffi` itself in
-    /// the process of executing the function call.
-    ///
-    /// SAFETY: The `sv_guard` and `raw_stack_ptr` passed must be the same ones
-    /// received by a prior call to `start_ffi`, and the allocator must be the
-    /// one passed to it also.
-    pub unsafe fn end_ffi(
-        alloc: &Rc<RefCell<IsolatedAlloc>>,
-        mut sv_guard: std::sync::MutexGuard<'static, Option<Supervisor>>,
-        raw_stack_ptr: Option<*mut [u8; CALLBACK_STACK_SIZE]>,
-    ) -> Option<MemEvents> {
+        let res = f();
+
         // We can't use IPC channels here to signal that FFI mode has ended,
         // since they might allocate memory which could get us stuck in a SIGTRAP
         // with no easy way out! While this could be worked around, it is much
@@ -113,42 +100,40 @@ impl Supervisor {
         signal::raise(signal::SIGUSR1).unwrap();
 
         // This is safe! It just sets memory to normal expected permissions.
-        alloc.borrow_mut().unprep_ffi();
+        alloc.borrow_mut().end_ffi();
 
-        // If this is `None`, then `raw_stack_ptr` is None and does not need to
-        // be deallocated (and there's no need to worry about the guard, since
-        // it contains nothing).
-        let sv = sv_guard.take()?;
         // SAFETY: Caller upholds that this pointer was allocated as a box with
         // this type.
         unsafe {
-            drop(Box::from_raw(raw_stack_ptr.unwrap()));
+            drop(Box::from_raw(raw_stack_ptr));
         }
         // On the off-chance something really weird happens, don't block forever.
-        let ret = sv
+        let events = sv
             .event_rx
             .try_recv_timeout(std::time::Duration::from_secs(5))
             .map_err(|e| {
                 match e {
                     ipc::TryRecvError::IpcError(_) => (),
                     ipc::TryRecvError::Empty =>
-                        eprintln!("Waiting for accesses from supervisor timed out!"),
+                        panic!("Waiting for accesses from supervisor timed out!"),
                 }
             })
             .ok();
-        // Do *not* leave the supervisor empty, or else we might get another fork...
-        *sv_guard = Some(sv);
-        ret
+
+        res.map(|v| (v, events))
     }
 }
 
 /// Initialises the supervisor process. If this function errors, then the
 /// supervisor process could not be created successfully; else, the caller
-/// is now the child process and can communicate via `start_ffi`/`end_ffi`,
-/// receiving back events through `get_events`.
+/// is now the child process and can communicate via `do_ffi`, receiving back
+/// events at the end.
 ///
 /// # Safety
-/// The invariants for `fork()` must be upheld by the caller.
+/// The invariants for `fork()` must be upheld by the caller, namely either:
+/// - Other threads do not exist, or;
+/// - If they do exist, either those threads or the resulting child process
+///   only ever act in [async-signal-safe](https://www.man7.org/linux/man-pages/man7/signal-safety.7.html) ways.
 pub unsafe fn init_sv() -> Result<(), SvInitError> {
     // FIXME: Much of this could be reimplemented via the mitosis crate if we upstream the
     // relevant missing bits.
@@ -191,8 +176,7 @@ pub unsafe fn init_sv() -> Result<(), SvInitError> {
                 // The child process is free to unwind, so we won't to avoid doubly freeing
                 // system resources.
                 let init = std::panic::catch_unwind(|| {
-                    let listener =
-                        ChildListener { message_rx, attached: false, override_retcode: None };
+                    let listener = ChildListener::new(message_rx, confirm_tx.clone());
                     // Trace as many things as possible, to be able to handle them as needed.
                     let options = ptrace::Options::PTRACE_O_TRACESYSGOOD
                         | ptrace::Options::PTRACE_O_TRACECLONE
@@ -218,7 +202,9 @@ pub unsafe fn init_sv() -> Result<(), SvInitError> {
                     // The "Ok" case means that we couldn't ptrace.
                     Ok(e) => return Err(e),
                     Err(p) => {
-                        eprintln!("Supervisor process panicked!\n{p:?}");
+                        eprintln!(
+                            "Supervisor process panicked!\n{p:?}\n\nTry running again without using the native-lib tracer."
+                        );
                         std::process::exit(1);
                     }
                 }
@@ -239,13 +225,11 @@ pub unsafe fn init_sv() -> Result<(), SvInitError> {
 }
 
 /// Instruct the supervisor process to return a particular code. Useful if for
-/// whatever reason this code fails to be intercepted normally. In the case of
-/// `abort_if_errors()` used in `bin/miri.rs`, the return code is erroneously
-/// given as a 0 if this is not used.
+/// whatever reason this code fails to be intercepted normally.
 pub fn register_retcode_sv(code: i32) {
     let mut sv_guard = SUPERVISOR.lock().unwrap();
-    if let Some(sv) = sv_guard.take() {
+    if let Some(sv) = sv_guard.as_mut() {
         sv.message_tx.send(TraceRequest::OverrideRetcode(code)).unwrap();
-        *sv_guard = Some(sv);
+        sv.confirm_rx.recv().unwrap();
     }
 }
diff --git a/src/tools/miri/src/shims/native_lib/trace/messages.rs b/src/tools/miri/src/shims/native_lib/trace/messages.rs
index 8a83dab5c09..1f9df556b57 100644
--- a/src/tools/miri/src/shims/native_lib/trace/messages.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/messages.rs
@@ -1,25 +1,28 @@
 //! Houses the types that are directly sent across the IPC channels.
 //!
-//! The overall structure of a traced FFI call, from the child process's POV, is
-//! as follows:
+//! When forking to initialise the supervisor during `init_sv`, the child raises
+//! a `SIGSTOP`; if the parent successfully ptraces the child, it will allow it
+//! to resume. Else, the child will be killed by the parent.
+//!
+//! After initialisation is done, the overall structure of a traced FFI call from
+//! the child process's POV is as follows:
 //! ```
 //! message_tx.send(TraceRequest::StartFfi);
-//! confirm_rx.recv();
+//! confirm_rx.recv(); // receives a `Confirmation`
 //! raise(SIGSTOP);
 //! /* do ffi call */
 //! raise(SIGUSR1); // morally equivalent to some kind of "TraceRequest::EndFfi"
-//! let events = event_rx.recv();
+//! let events = event_rx.recv(); // receives a `MemEvents`
 //! ```
 //! `TraceRequest::OverrideRetcode` can be sent at any point in the above, including
-//! before or after all of them.
+//! before or after all of them. `confirm_rx.recv()` is to be called after, to ensure
+//! that the child does not exit before the supervisor has registered the return code.
 //!
 //! NB: sending these events out of order, skipping steps, etc. will result in
 //! unspecified behaviour from the supervisor process, so use the abstractions
-//! in `super::child` (namely `start_ffi()` and `end_ffi()`) to handle this. It is
+//! in `super::child` (namely `do_ffi()`) to handle this. It is
 //! trivially easy to cause a deadlock or crash by messing this up!
 
-use std::ops::Range;
-
 /// An IPC request sent by the child process to the parent.
 ///
 /// The sender for this channel should live on the child process.
@@ -34,6 +37,8 @@ pub enum TraceRequest {
     StartFfi(StartFfiInfo),
     /// Manually overrides the code that the supervisor will return upon exiting.
     /// Once set, it is permanent. This can be called again to change the value.
+    ///
+    /// After sending this, the child must wait to receive a `Confirmation`.
     OverrideRetcode(i32),
 }
 
@@ -41,7 +46,7 @@ pub enum TraceRequest {
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
 pub struct StartFfiInfo {
     /// A vector of page addresses. These should have been automatically obtained
-    /// with `IsolatedAlloc::pages` and prepared with `IsolatedAlloc::prepare_ffi`.
+    /// with `IsolatedAlloc::pages` and prepared with `IsolatedAlloc::start_ffi`.
     pub page_ptrs: Vec<usize>,
     /// The address of an allocation that can serve as a temporary stack.
     /// This should be a leaked `Box<[u8; CALLBACK_STACK_SIZE]>` cast to an int.
@@ -54,27 +59,3 @@ pub struct StartFfiInfo {
 /// The sender for this channel should live on the parent process.
 #[derive(serde::Serialize, serde::Deserialize, Debug)]
 pub struct Confirmation;
-
-/// The final results of an FFI trace, containing every relevant event detected
-/// by the tracer. Sent by the supervisor after receiving a `SIGUSR1` signal.
-///
-/// The sender for this channel should live on the parent process.
-#[derive(serde::Serialize, serde::Deserialize, Debug)]
-pub struct MemEvents {
-    /// An ordered list of memory accesses that occurred. These should be assumed
-    /// to be overcautious; that is, if the size of an access is uncertain it is
-    /// pessimistically rounded up, and if the type (read/write/both) is uncertain
-    /// it is reported as whatever would be safest to assume; i.e. a read + maybe-write
-    /// becomes a read + write, etc.
-    pub acc_events: Vec<AccessEvent>,
-}
-
-/// A single memory access, conservatively overestimated
-/// in case of ambiguity.
-#[derive(serde::Serialize, serde::Deserialize, Debug)]
-pub enum AccessEvent {
-    /// A read may have occurred on no more than the specified address range.
-    Read(Range<usize>),
-    /// A write may have occurred on no more than the specified address range.
-    Write(Range<usize>),
-}
diff --git a/src/tools/miri/src/shims/native_lib/trace/mod.rs b/src/tools/miri/src/shims/native_lib/trace/mod.rs
index 174b06b3ac5..c8abacfb5e2 100644
--- a/src/tools/miri/src/shims/native_lib/trace/mod.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/mod.rs
@@ -5,4 +5,6 @@ mod parent;
 pub use self::child::{Supervisor, init_sv, register_retcode_sv};
 
 /// The size of the temporary stack we use for callbacks that the server executes in the client.
+/// This should be big enough that `mempr_on` and `mempr_off` can safely be jumped into with the
+/// stack pointer pointing to a "stack" of this size without overflowing it.
 const CALLBACK_STACK_SIZE: usize = 1024;
diff --git a/src/tools/miri/src/shims/native_lib/trace/parent.rs b/src/tools/miri/src/shims/native_lib/trace/parent.rs
index dfb0b35da69..fc4047eec51 100644
--- a/src/tools/miri/src/shims/native_lib/trace/parent.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/parent.rs
@@ -5,26 +5,17 @@ use nix::sys::{ptrace, signal, wait};
 use nix::unistd;
 
 use super::CALLBACK_STACK_SIZE;
-use super::messages::{AccessEvent, Confirmation, MemEvents, StartFfiInfo, TraceRequest};
+use super::messages::{Confirmation, StartFfiInfo, TraceRequest};
+use crate::shims::native_lib::{AccessEvent, AccessRange, MemEvents};
 
 /// The flags to use when calling `waitid()`.
-/// Since bitwise or on the nix version of these flags is implemented as a trait,
-/// this cannot be const directly so we do it this way.
 const WAIT_FLAGS: wait::WaitPidFlag =
-    wait::WaitPidFlag::from_bits_truncate(libc::WUNTRACED | libc::WEXITED);
-
-/// Arch-specific maximum size a single access might perform. x86 value is set
-/// assuming nothing bigger than AVX-512 is available.
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-const ARCH_MAX_ACCESS_SIZE: usize = 64;
-/// The largest arm64 simd instruction operates on 16 bytes.
-#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
-const ARCH_MAX_ACCESS_SIZE: usize = 16;
+    wait::WaitPidFlag::WUNTRACED.union(wait::WaitPidFlag::WEXITED);
 
 /// The default word size on a given platform, in bytes.
-#[cfg(any(target_arch = "x86", target_arch = "arm"))]
+#[cfg(target_arch = "x86")]
 const ARCH_WORD_SIZE: usize = 4;
-#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
+#[cfg(target_arch = "x86_64")]
 const ARCH_WORD_SIZE: usize = 8;
 
 /// The address of the page set to be edited, initialised to a sentinel null
@@ -53,39 +44,25 @@ trait ArchIndependentRegs {
 // It's fine / desirable behaviour for values to wrap here, we care about just
 // preserving the bit pattern.
 #[cfg(target_arch = "x86_64")]
-#[expect(clippy::as_conversions)]
 #[rustfmt::skip]
 impl ArchIndependentRegs for libc::user_regs_struct {
     #[inline]
-    fn ip(&self) -> usize { self.rip as _ }
+    fn ip(&self) -> usize { self.rip.try_into().unwrap() }
     #[inline]
-    fn set_ip(&mut self, ip: usize) { self.rip = ip as _ }
+    fn set_ip(&mut self, ip: usize) { self.rip = ip.try_into().unwrap() }
     #[inline]
-    fn set_sp(&mut self, sp: usize) { self.rsp = sp as _ }
+    fn set_sp(&mut self, sp: usize) { self.rsp = sp.try_into().unwrap() }
 }
 
 #[cfg(target_arch = "x86")]
-#[expect(clippy::as_conversions)]
 #[rustfmt::skip]
 impl ArchIndependentRegs for libc::user_regs_struct {
     #[inline]
-    fn ip(&self) -> usize { self.eip as _ }
+    fn ip(&self) -> usize { self.eip.try_into().unwrap() }
     #[inline]
-    fn set_ip(&mut self, ip: usize) { self.eip = ip as _ }
+    fn set_ip(&mut self, ip: usize) { self.eip = ip.try_into().unwrap() }
     #[inline]
-    fn set_sp(&mut self, sp: usize) { self.esp = sp as _ }
-}
-
-#[cfg(target_arch = "aarch64")]
-#[expect(clippy::as_conversions)]
-#[rustfmt::skip]
-impl ArchIndependentRegs for libc::user_regs_struct {
-    #[inline]
-    fn ip(&self) -> usize { self.pc as _ }
-    #[inline]
-    fn set_ip(&mut self, ip: usize) { self.pc = ip as _ }
-    #[inline]
-    fn set_sp(&mut self, sp: usize) { self.sp = sp as _ }
+    fn set_sp(&mut self, sp: usize) { self.esp = sp.try_into().unwrap() }
 }
 
 /// A unified event representing something happening on the child process. Wraps
@@ -109,11 +86,24 @@ pub enum ExecEvent {
 /// A listener for the FFI start info channel along with relevant state.
 pub struct ChildListener {
     /// The matching channel for the child's `Supervisor` struct.
-    pub message_rx: ipc::IpcReceiver<TraceRequest>,
+    message_rx: ipc::IpcReceiver<TraceRequest>,
+    /// ...
+    confirm_tx: ipc::IpcSender<Confirmation>,
     /// Whether an FFI call is currently ongoing.
-    pub attached: bool,
+    attached: bool,
     /// If `Some`, overrides the return code with the given value.
-    pub override_retcode: Option<i32>,
+    override_retcode: Option<i32>,
+    /// Last code obtained from a child exiting.
+    last_code: Option<i32>,
+}
+
+impl ChildListener {
+    pub fn new(
+        message_rx: ipc::IpcReceiver<TraceRequest>,
+        confirm_tx: ipc::IpcSender<Confirmation>,
+    ) -> Self {
+        Self { message_rx, confirm_tx, attached: false, override_retcode: None, last_code: None }
+    }
 }
 
 impl Iterator for ChildListener {
@@ -133,16 +123,10 @@ impl Iterator for ChildListener {
                 Ok(stat) =>
                     match stat {
                         // Child exited normally with a specific code set.
-                        wait::WaitStatus::Exited(_, code) => {
-                            let code = self.override_retcode.unwrap_or(code);
-                            return Some(ExecEvent::Died(Some(code)));
-                        }
+                        wait::WaitStatus::Exited(_, code) => self.last_code = Some(code),
                         // Child was killed by a signal, without giving a code.
-                        wait::WaitStatus::Signaled(_, _, _) =>
-                            return Some(ExecEvent::Died(self.override_retcode)),
-                        // Child entered a syscall. Since we're always technically
-                        // tracing, only pass this along if we're actively
-                        // monitoring the child.
+                        wait::WaitStatus::Signaled(_, _, _) => self.last_code = None,
+                        // Child entered or exited a syscall.
                         wait::WaitStatus::PtraceSyscall(pid) =>
                             if self.attached {
                                 return Some(ExecEvent::Syscall(pid));
@@ -179,10 +163,8 @@ impl Iterator for ChildListener {
                             },
                         _ => (),
                     },
-                // This case should only trigger if all children died and we
-                // somehow missed that, but it's best we not allow any room
-                // for deadlocks.
-                Err(_) => return Some(ExecEvent::Died(None)),
+                // This case should only trigger when all children died.
+                Err(_) => return Some(ExecEvent::Died(self.override_retcode.or(self.last_code))),
             }
 
             // Similarly, do a non-blocking poll of the IPC channel.
@@ -196,7 +178,10 @@ impl Iterator for ChildListener {
                             self.attached = true;
                             return Some(ExecEvent::Start(info));
                         },
-                    TraceRequest::OverrideRetcode(code) => self.override_retcode = Some(code),
+                    TraceRequest::OverrideRetcode(code) => {
+                        self.override_retcode = Some(code);
+                        self.confirm_tx.send(Confirmation).unwrap();
+                    }
                 }
             }
 
@@ -211,6 +196,12 @@ impl Iterator for ChildListener {
 #[derive(Debug)]
 pub struct ExecEnd(pub Option<i32>);
 
+/// Whether to call `ptrace::cont()` immediately. Used exclusively by `wait_for_signal`.
+enum InitialCont {
+    Yes,
+    No,
+}
+
 /// This is the main loop of the supervisor process. It runs in a separate
 /// process from the rest of Miri (but because we fork, addresses for anything
 /// created before the fork - like statics - are the same).
@@ -239,12 +230,12 @@ pub fn sv_loop(
     let mut curr_pid = init_pid;
 
     // There's an initial sigstop we need to deal with.
-    wait_for_signal(Some(curr_pid), signal::SIGSTOP, false)?;
+    wait_for_signal(Some(curr_pid), signal::SIGSTOP, InitialCont::No)?;
     ptrace::cont(curr_pid, None).unwrap();
 
     for evt in listener {
         match evt {
-            // start_ffi was called by the child, so prep memory.
+            // Child started ffi, so prep memory.
             ExecEvent::Start(ch_info) => {
                 // All the pages that the child process is "allowed to" access.
                 ch_pages = ch_info.page_ptrs;
@@ -252,17 +243,17 @@ pub fn sv_loop(
                 ch_stack = Some(ch_info.stack_ptr);
 
                 // We received the signal and are no longer in the main listener loop,
-                // so we can let the child move on to the end of start_ffi where it will
+                // so we can let the child move on to the end of the ffi prep where it will
                 // raise a SIGSTOP. We need it to be signal-stopped *and waited for* in
                 // order to do most ptrace operations!
                 confirm_tx.send(Confirmation).unwrap();
                 // We can't trust simply calling `Pid::this()` in the child process to give the right
                 // PID for us, so we get it this way.
-                curr_pid = wait_for_signal(None, signal::SIGSTOP, false).unwrap();
+                curr_pid = wait_for_signal(None, signal::SIGSTOP, InitialCont::No).unwrap();
 
                 ptrace::syscall(curr_pid, None).unwrap();
             }
-            // end_ffi was called by the child.
+            // Child wants to end tracing.
             ExecEvent::End => {
                 // Hand over the access info we traced.
                 event_tx.send(MemEvents { acc_events }).unwrap();
@@ -322,10 +313,6 @@ fn get_disasm() -> capstone::Capstone {
         {cs_pre.x86().mode(arch::x86::ArchMode::Mode64)}
         #[cfg(target_arch = "x86")]
         {cs_pre.x86().mode(arch::x86::ArchMode::Mode32)}
-        #[cfg(target_arch = "aarch64")]
-        {cs_pre.arm64().mode(arch::arm64::ArchMode::Arm)}
-        #[cfg(target_arch = "arm")]
-        {cs_pre.arm().mode(arch::arm::ArchMode::Arm)}
     }
     .detail(true)
     .build()
@@ -339,9 +326,9 @@ fn get_disasm() -> capstone::Capstone {
 fn wait_for_signal(
     pid: Option<unistd::Pid>,
     wait_signal: signal::Signal,
-    init_cont: bool,
+    init_cont: InitialCont,
 ) -> Result<unistd::Pid, ExecEnd> {
-    if init_cont {
+    if matches!(init_cont, InitialCont::Yes) {
         ptrace::cont(pid.unwrap(), None).unwrap();
     }
     // Repeatedly call `waitid` until we get the signal we want, or the process dies.
@@ -374,6 +361,74 @@ fn wait_for_signal(
     }
 }
 
+/// Add the memory events from `op` being executed while there is a memory access at `addr` to
+/// `acc_events`. Return whether this was a memory operand.
+fn capstone_find_events(
+    addr: usize,
+    op: &capstone::arch::ArchOperand,
+    acc_events: &mut Vec<AccessEvent>,
+) -> bool {
+    use capstone::prelude::*;
+    match op {
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        arch::ArchOperand::X86Operand(x86_operand) => {
+            match x86_operand.op_type {
+                // We only care about memory accesses
+                arch::x86::X86OperandType::Mem(_) => {
+                    let push = AccessRange { addr, size: x86_operand.size.into() };
+                    // It's called a "RegAccessType" but it also applies to memory
+                    let acc_ty = x86_operand.access.unwrap();
+                    // The same instruction might do both reads and writes, so potentially add both.
+                    // We do not know the order in which they happened, but writing and then reading
+                    // makes little sense so we put the read first. That is also the more
+                    // conservative choice.
+                    if acc_ty.is_readable() {
+                        acc_events.push(AccessEvent::Read(push.clone()));
+                    }
+                    if acc_ty.is_writable() {
+                        acc_events.push(AccessEvent::Write(push));
+                    }
+
+                    return true;
+                }
+                _ => (),
+            }
+        }
+        // FIXME: arm64
+        _ => unimplemented!(),
+    }
+
+    false
+}
+
+/// Extract the events from the given instruction.
+fn capstone_disassemble(
+    instr: &[u8],
+    addr: usize,
+    cs: &capstone::Capstone,
+    acc_events: &mut Vec<AccessEvent>,
+) -> capstone::CsResult<()> {
+    // The arch_detail is what we care about, but it relies on these temporaries
+    // that we can't drop. 0x1000 is the default base address for Captsone, and
+    // we're expecting 1 instruction.
+    let insns = cs.disasm_count(instr, 0x1000, 1)?;
+    let ins_detail = cs.insn_detail(&insns[0])?;
+    let arch_detail = ins_detail.arch_detail();
+
+    let mut found_mem_op = false;
+
+    for op in arch_detail.operands() {
+        if capstone_find_events(addr, &op, acc_events) {
+            if found_mem_op {
+                panic!("more than one memory operand found; we don't know which one accessed what");
+            }
+            found_mem_op = true;
+        }
+    }
+
+    Ok(())
+}
+
 /// Grabs the access that caused a segfault and logs it down if it's to our memory,
 /// or kills the child and returns the appropriate error otherwise.
 fn handle_segfault(
@@ -384,111 +439,6 @@ fn handle_segfault(
     cs: &capstone::Capstone,
     acc_events: &mut Vec<AccessEvent>,
 ) -> Result<(), ExecEnd> {
-    /// This is just here to not pollute the main namespace with `capstone::prelude::*`.
-    #[inline]
-    fn capstone_disassemble(
-        instr: &[u8],
-        addr: usize,
-        cs: &capstone::Capstone,
-        acc_events: &mut Vec<AccessEvent>,
-    ) -> capstone::CsResult<()> {
-        use capstone::prelude::*;
-
-        // The arch_detail is what we care about, but it relies on these temporaries
-        // that we can't drop. 0x1000 is the default base address for Captsone, and
-        // we're expecting 1 instruction.
-        let insns = cs.disasm_count(instr, 0x1000, 1)?;
-        let ins_detail = cs.insn_detail(&insns[0])?;
-        let arch_detail = ins_detail.arch_detail();
-
-        for op in arch_detail.operands() {
-            match op {
-                #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-                arch::ArchOperand::X86Operand(x86_operand) => {
-                    match x86_operand.op_type {
-                        // We only care about memory accesses
-                        arch::x86::X86OperandType::Mem(_) => {
-                            let push = addr..addr.strict_add(usize::from(x86_operand.size));
-                            // It's called a "RegAccessType" but it also applies to memory
-                            let acc_ty = x86_operand.access.unwrap();
-                            if acc_ty.is_readable() {
-                                acc_events.push(AccessEvent::Read(push.clone()));
-                            }
-                            if acc_ty.is_writable() {
-                                acc_events.push(AccessEvent::Write(push));
-                            }
-                        }
-                        _ => (),
-                    }
-                }
-                #[cfg(target_arch = "aarch64")]
-                arch::ArchOperand::Arm64Operand(arm64_operand) => {
-                    // Annoyingly, we don't always get the size here, so just be pessimistic for now.
-                    match arm64_operand.op_type {
-                        arch::arm64::Arm64OperandType::Mem(_) => {
-                            // B = 1 byte, H = 2 bytes, S = 4 bytes, D = 8 bytes, Q = 16 bytes.
-                            let size = match arm64_operand.vas {
-                                // Not an fp/simd instruction.
-                                arch::arm64::Arm64Vas::ARM64_VAS_INVALID => ARCH_WORD_SIZE,
-                                // 1 byte.
-                                arch::arm64::Arm64Vas::ARM64_VAS_1B => 1,
-                                // 2 bytes.
-                                arch::arm64::Arm64Vas::ARM64_VAS_1H => 2,
-                                // 4 bytes.
-                                arch::arm64::Arm64Vas::ARM64_VAS_4B
-                                | arch::arm64::Arm64Vas::ARM64_VAS_2H
-                                | arch::arm64::Arm64Vas::ARM64_VAS_1S => 4,
-                                // 8 bytes.
-                                arch::arm64::Arm64Vas::ARM64_VAS_8B
-                                | arch::arm64::Arm64Vas::ARM64_VAS_4H
-                                | arch::arm64::Arm64Vas::ARM64_VAS_2S
-                                | arch::arm64::Arm64Vas::ARM64_VAS_1D => 8,
-                                // 16 bytes.
-                                arch::arm64::Arm64Vas::ARM64_VAS_16B
-                                | arch::arm64::Arm64Vas::ARM64_VAS_8H
-                                | arch::arm64::Arm64Vas::ARM64_VAS_4S
-                                | arch::arm64::Arm64Vas::ARM64_VAS_2D
-                                | arch::arm64::Arm64Vas::ARM64_VAS_1Q => 16,
-                            };
-                            let push = addr..addr.strict_add(size);
-                            // FIXME: This now has access type info in the latest
-                            // git version of capstone because this pissed me off
-                            // and I added it. Change this when it updates.
-                            acc_events.push(AccessEvent::Read(push.clone()));
-                            acc_events.push(AccessEvent::Write(push));
-                        }
-                        _ => (),
-                    }
-                }
-                #[cfg(target_arch = "arm")]
-                arch::ArchOperand::ArmOperand(arm_operand) =>
-                    match arm_operand.op_type {
-                        arch::arm::ArmOperandType::Mem(_) => {
-                            // We don't get info on the size of the access, but
-                            // we're at least told if it's a vector instruction.
-                            let size = if arm_operand.vector_index.is_some() {
-                                ARCH_MAX_ACCESS_SIZE
-                            } else {
-                                ARCH_WORD_SIZE
-                            };
-                            let push = addr..addr.strict_add(size);
-                            let acc_ty = arm_operand.access.unwrap();
-                            if acc_ty.is_readable() {
-                                acc_events.push(AccessEvent::Read(push.clone()));
-                            }
-                            if acc_ty.is_writable() {
-                                acc_events.push(AccessEvent::Write(push));
-                            }
-                        }
-                        _ => (),
-                    },
-                _ => unimplemented!(),
-            }
-        }
-
-        Ok(())
-    }
-
     // Get information on what caused the segfault. This contains the address
     // that triggered it.
     let siginfo = ptrace::getsiginfo(pid).unwrap();
@@ -515,7 +465,7 @@ fn handle_segfault(
     //   global atomic variables. This is what we use the temporary callback stack for.
     // - Step 1 instruction
     // - Parse executed code to estimate size & type of access
-    // - Reprotect the memory by executing `mempr_on` in the child.
+    // - Reprotect the memory by executing `mempr_on` in the child, using the callback stack again.
     // - Continue
 
     // Ensure the stack is properly zeroed out!
@@ -552,7 +502,7 @@ fn handle_segfault(
     ptrace::setregs(pid, new_regs).unwrap();
 
     // Our mempr_* functions end with a raise(SIGSTOP).
-    wait_for_signal(Some(pid), signal::SIGSTOP, true)?;
+    wait_for_signal(Some(pid), signal::SIGSTOP, InitialCont::Yes)?;
 
     // Step 1 instruction.
     ptrace::setregs(pid, regs_bak).unwrap();
@@ -573,6 +523,12 @@ fn handle_segfault(
     let regs_bak = ptrace::getregs(pid).unwrap();
     new_regs = regs_bak;
     let ip_poststep = regs_bak.ip();
+
+    // Ensure that we've actually gone forwards.
+    assert!(ip_poststep > ip_prestep);
+    // But not by too much. 64 bytes should be "big enough" on ~any architecture.
+    assert!(ip_prestep.strict_add(64) > ip_poststep);
+
     // We need to do reads/writes in word-sized chunks.
     let diff = (ip_poststep.strict_sub(ip_prestep)).div_ceil(ARCH_WORD_SIZE);
     let instr = (ip_prestep..ip_prestep.strict_add(diff)).fold(vec![], |mut ret, ip| {
@@ -587,20 +543,14 @@ fn handle_segfault(
     });
 
     // Now figure out the size + type of access and log it down.
-    // This will mark down e.g. the same area being read multiple times,
-    // since it's more efficient to compress the accesses at the end.
-    if capstone_disassemble(&instr, addr, cs, acc_events).is_err() {
-        // Read goes first because we need to be pessimistic.
-        acc_events.push(AccessEvent::Read(addr..addr.strict_add(ARCH_MAX_ACCESS_SIZE)));
-        acc_events.push(AccessEvent::Write(addr..addr.strict_add(ARCH_MAX_ACCESS_SIZE)));
-    }
+    capstone_disassemble(&instr, addr, cs, acc_events).expect("Failed to disassemble instruction");
 
     // Reprotect everything and continue.
     #[expect(clippy::as_conversions)]
     new_regs.set_ip(mempr_on as usize);
     new_regs.set_sp(stack_ptr);
     ptrace::setregs(pid, new_regs).unwrap();
-    wait_for_signal(Some(pid), signal::SIGSTOP, true)?;
+    wait_for_signal(Some(pid), signal::SIGSTOP, InitialCont::Yes)?;
 
     ptrace::setregs(pid, regs_bak).unwrap();
     ptrace::syscall(pid, None).unwrap();
diff --git a/src/tools/miri/src/shims/native_lib/trace/stub.rs b/src/tools/miri/src/shims/native_lib/trace/stub.rs
new file mode 100644
index 00000000000..22787a6f6fa
--- /dev/null
+++ b/src/tools/miri/src/shims/native_lib/trace/stub.rs
@@ -0,0 +1,34 @@
+use rustc_const_eval::interpret::InterpResult;
+
+static SUPERVISOR: std::sync::Mutex<()> = std::sync::Mutex::new(());
+
+pub struct Supervisor;
+
+#[derive(Debug)]
+pub struct SvInitError;
+
+impl Supervisor {
+    #[inline(always)]
+    pub fn is_enabled() -> bool {
+        false
+    }
+
+    pub fn do_ffi<'tcx, T>(
+        _: T,
+        f: impl FnOnce() -> InterpResult<'tcx, crate::ImmTy<'tcx>>,
+    ) -> InterpResult<'tcx, (crate::ImmTy<'tcx>, Option<super::MemEvents>)> {
+        // We acquire the lock to ensure that no two FFI calls run concurrently.
+        let _g = SUPERVISOR.lock().unwrap();
+        f().map(|v| (v, None))
+    }
+}
+
+#[inline(always)]
+#[allow(dead_code, clippy::missing_safety_doc)]
+pub unsafe fn init_sv() -> Result<!, SvInitError> {
+    Err(SvInitError)
+}
+
+#[inline(always)]
+#[allow(dead_code)]
+pub fn register_retcode_sv<T>(_: T) {}
-- 
cgit 1.4.1-3-g733a5


From 43bc40f113e0e12e44b8aea3968ff6b9d7eb4582 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Tue, 8 Jul 2025 14:47:00 +0000
Subject: improve lint doc text

---
 compiler/rustc_lint/src/types.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index e41bc8f852e..fc9d795cb23 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -59,8 +59,7 @@ declare_lint! {
 }
 
 declare_lint! {
-    /// The `overflowing_literals` lint detects literal out of range for its
-    /// type.
+    /// The `overflowing_literals` lint detects literals out of range for their type.
     ///
     /// ### Example
     ///
@@ -72,9 +71,9 @@ declare_lint! {
     ///
     /// ### Explanation
     ///
-    /// It is usually a mistake to use a literal that overflows the type where
-    /// it is used. Either use a literal that is within range, or change the
-    /// type to be within the range of the literal.
+    /// It is usually a mistake to use a literal that overflows its type
+    /// Change either the literal or its type such that the literal is
+    /// within the range of its type.
     OVERFLOWING_LITERALS,
     Deny,
     "literal out of range for its type"
-- 
cgit 1.4.1-3-g733a5


From 86c6197b1acad00f68b7a135d297c4d2f208cc73 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Wed, 18 Jun 2025 16:46:57 +0200
Subject: Rename `compiler` to `build_compiler`

---
 src/bootstrap/src/core/build_steps/tool.rs | 61 +++++++++++++++---------------
 1 file changed, 31 insertions(+), 30 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 5de1b472d79..beb7e3810c0 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -41,7 +41,8 @@ pub enum ToolArtifactKind {
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 struct ToolBuild {
-    compiler: Compiler,
+    /// Compiler that will build this tool.
+    build_compiler: Compiler,
     target: TargetSelection,
     tool: &'static str,
     path: &'static str,
@@ -111,25 +112,25 @@ impl Step for ToolBuild {
         let mut tool = self.tool;
         let path = self.path;
 
-        let target_compiler = self.compiler;
-        self.compiler = if self.mode == Mode::ToolRustc {
-            get_tool_rustc_compiler(builder, self.compiler)
+        let target_compiler = self.build_compiler;
+        self.build_compiler = if self.mode == Mode::ToolRustc {
+            get_tool_rustc_compiler(builder, self.build_compiler)
         } else {
-            self.compiler
+            self.build_compiler
         };
 
         match self.mode {
             Mode::ToolRustc => {
                 // If compiler was forced, its artifacts should have been prepared earlier.
-                if !self.compiler.is_forced_compiler() {
-                    builder.std(self.compiler, self.compiler.host);
-                    builder.ensure(compile::Rustc::new(self.compiler, target));
+                if !self.build_compiler.is_forced_compiler() {
+                    builder.std(self.build_compiler, self.build_compiler.host);
+                    builder.ensure(compile::Rustc::new(self.build_compiler, target));
                 }
             }
             Mode::ToolStd => {
                 // If compiler was forced, its artifacts should have been prepared earlier.
-                if !self.compiler.is_forced_compiler() {
-                    builder.std(self.compiler, target)
+                if !self.build_compiler.is_forced_compiler() {
+                    builder.std(self.build_compiler, target);
                 }
             }
             Mode::ToolBootstrap => {} // uses downloaded stage0 compiler libs
@@ -151,7 +152,7 @@ impl Step for ToolBuild {
 
         let mut cargo = prepare_tool_cargo(
             builder,
-            self.compiler,
+            self.build_compiler,
             self.mode,
             target,
             Kind::Build,
@@ -173,7 +174,7 @@ impl Step for ToolBuild {
 
         // Rustc tools (miri, clippy, cargo, rustfmt, rust-analyzer)
         // could use the additional optimizations.
-        if self.mode == Mode::ToolRustc && is_lto_stage(&self.compiler) {
+        if self.mode == Mode::ToolRustc && is_lto_stage(&self.build_compiler) {
             let lto = match builder.config.rust_lto {
                 RustcLto::Off => Some("off"),
                 RustcLto::Thin => Some("thin"),
@@ -195,8 +196,8 @@ impl Step for ToolBuild {
             Kind::Build,
             self.mode,
             self.tool,
-            self.compiler.stage,
-            &self.compiler.host,
+            self.build_compiler.stage,
+            &self.build_compiler.host,
             &self.target,
         );
 
@@ -219,14 +220,14 @@ impl Step for ToolBuild {
             }
             let tool_path = match self.artifact_kind {
                 ToolArtifactKind::Binary => {
-                    copy_link_tool_bin(builder, self.compiler, self.target, self.mode, tool)
+                    copy_link_tool_bin(builder, self.build_compiler, self.target, self.mode, tool)
                 }
                 ToolArtifactKind::Library => builder
-                    .cargo_out(self.compiler, self.mode, self.target)
+                    .cargo_out(self.build_compiler, self.mode, self.target)
                     .join(format!("lib{tool}.rlib")),
             };
 
-            ToolBuildResult { tool_path, build_compiler: self.compiler, target_compiler }
+            ToolBuildResult { tool_path, build_compiler: self.build_compiler, target_compiler }
         }
     }
 }
@@ -450,7 +451,7 @@ macro_rules! bootstrap_tool {
                 let compiletest_wants_stage0 = $tool_name == "compiletest" && builder.config.compiletest_use_stage0_libtest;
 
                 builder.ensure(ToolBuild {
-                    compiler: self.compiler,
+                    build_compiler: self.compiler,
                     target: self.target,
                     tool: $tool_name,
                     mode: if is_unstable && !compiletest_wants_stage0 {
@@ -560,7 +561,7 @@ impl Step for RustcPerf {
         builder.require_submodule("src/tools/rustc-perf", None);
 
         let tool = ToolBuild {
-            compiler: self.compiler,
+            build_compiler: self.compiler,
             target: self.target,
             tool: "collector",
             mode: Mode::ToolBootstrap,
@@ -576,7 +577,7 @@ impl Step for RustcPerf {
         let res = builder.ensure(tool.clone());
         // We also need to symlink the `rustc-fake` binary to the corresponding directory,
         // because `collector` expects it in the same directory.
-        copy_link_tool_bin(builder, tool.compiler, tool.target, tool.mode, "rustc-fake");
+        copy_link_tool_bin(builder, tool.build_compiler, tool.target, tool.mode, "rustc-fake");
 
         res
     }
@@ -620,7 +621,7 @@ impl Step for ErrorIndex {
 
     fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
         builder.ensure(ToolBuild {
-            compiler: self.compiler,
+            build_compiler: self.compiler,
             target: self.compiler.host,
             tool: "error_index_generator",
             mode: Mode::ToolRustc,
@@ -656,7 +657,7 @@ impl Step for RemoteTestServer {
 
     fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
         builder.ensure(ToolBuild {
-            compiler: self.compiler,
+            build_compiler: self.compiler,
             target: self.target,
             tool: "remote-test-server",
             mode: Mode::ToolStd,
@@ -757,7 +758,7 @@ impl Step for Rustdoc {
 
         let ToolBuildResult { tool_path, build_compiler, target_compiler } =
             builder.ensure(ToolBuild {
-                compiler: target_compiler,
+                build_compiler: target_compiler,
                 target,
                 // Cargo adds a number of paths to the dylib search path on windows, which results in
                 // the wrong rustdoc being executed. To avoid the conflicting rustdocs, we name the "tool"
@@ -825,7 +826,7 @@ impl Step for Cargo {
         builder.build.require_submodule("src/tools/cargo", None);
 
         builder.ensure(ToolBuild {
-            compiler: self.compiler,
+            build_compiler: self.compiler,
             target: self.target,
             tool: "cargo",
             mode: Mode::ToolRustc,
@@ -873,7 +874,7 @@ impl Step for LldWrapper {
         let target = self.target_compiler.host;
 
         let tool_result = builder.ensure(ToolBuild {
-            compiler: self.build_compiler,
+            build_compiler: self.build_compiler,
             target,
             tool: "lld-wrapper",
             mode: Mode::ToolStd,
@@ -948,7 +949,7 @@ impl Step for RustAnalyzer {
 
     fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
         builder.ensure(ToolBuild {
-            compiler: self.compiler,
+            build_compiler: self.compiler,
             target: self.target,
             tool: "rust-analyzer",
             mode: Mode::ToolRustc,
@@ -993,7 +994,7 @@ impl Step for RustAnalyzerProcMacroSrv {
 
     fn run(self, builder: &Builder<'_>) -> Option<ToolBuildResult> {
         let tool_result = builder.ensure(ToolBuild {
-            compiler: self.compiler,
+            build_compiler: self.compiler,
             target: self.target,
             tool: "rust-analyzer-proc-macro-srv",
             mode: Mode::ToolRustc,
@@ -1051,7 +1052,7 @@ impl Step for LlvmBitcodeLinker {
     )]
     fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
         builder.ensure(ToolBuild {
-            compiler: self.build_compiler,
+            build_compiler: self.build_compiler,
             target: self.target,
             tool: "llvm-bitcode-linker",
             mode: Mode::ToolRustc,
@@ -1235,7 +1236,7 @@ fn run_tool_build_step(
 
     let ToolBuildResult { tool_path, build_compiler, target_compiler } =
         builder.ensure(ToolBuild {
-            compiler,
+            build_compiler: compiler,
             target,
             tool: tool_name,
             mode: Mode::ToolRustc,
@@ -1332,7 +1333,7 @@ impl Step for TestFloatParse {
         let compiler = builder.compiler(builder.top_stage, bootstrap_host);
 
         builder.ensure(ToolBuild {
-            compiler,
+            build_compiler: compiler,
             target: bootstrap_host,
             tool: "test-float-parse",
             mode: Mode::ToolStd,
-- 
cgit 1.4.1-3-g733a5


From 2fbc6427d3adbc883b2fce153586af76569c099b Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 8 Jul 2025 16:57:38 +0200
Subject: Add `Mode::ToolTarget`

---
 src/bootstrap/README.md                     |  2 +-
 src/bootstrap/src/core/build_steps/check.rs |  6 ++-
 src/bootstrap/src/core/build_steps/tool.rs  | 11 +++++
 src/bootstrap/src/core/builder/cargo.rs     | 55 ++++++++++++-----------
 src/bootstrap/src/core/builder/mod.rs       |  1 +
 src/bootstrap/src/lib.rs                    | 68 ++++++++++++++++++++++++-----
 6 files changed, 104 insertions(+), 39 deletions(-)

diff --git a/src/bootstrap/README.md b/src/bootstrap/README.md
index 6ce4c6d62fa..2965174b45b 100644
--- a/src/bootstrap/README.md
+++ b/src/bootstrap/README.md
@@ -105,7 +105,7 @@ build/
       debuginfo/
       ...
 
-    # Bootstrap host tools (which are always compiled with the stage0 compiler)
+    # Host tools (which are always compiled with the stage0 compiler)
     # are stored here.
     bootstrap-tools/
 
diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 0497bae86a1..bdaf8917dd9 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -4,7 +4,9 @@ use crate::core::build_steps::compile::{
     add_to_sysroot, run_cargo, rustc_cargo, rustc_cargo_env, std_cargo, std_crates_for_run_make,
 };
 use crate::core::build_steps::tool;
-use crate::core::build_steps::tool::{COMPILETEST_ALLOW_FEATURES, SourceType, prepare_tool_cargo};
+use crate::core::build_steps::tool::{
+    COMPILETEST_ALLOW_FEATURES, SourceType, get_tool_target_compiler, prepare_tool_cargo,
+};
 use crate::core::builder::{
     self, Alias, Builder, Kind, RunConfig, ShouldRun, Step, StepMetadata, crate_description,
 };
@@ -247,8 +249,10 @@ fn prepare_compiler_for_check(
     mode: Mode,
 ) -> Compiler {
     let host = builder.host_target;
+
     match mode {
         Mode::ToolBootstrap => builder.compiler(0, host),
+        Mode::ToolTarget => get_tool_target_compiler(builder, target),
         Mode::ToolStd => {
             // These tools require the local standard library to be checked
             let build_compiler = builder.compiler(builder.top_stage, host);
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index beb7e3810c0..9fac8df4ae8 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -365,6 +365,17 @@ pub(crate) fn get_tool_rustc_compiler(
     builder.compiler(target_compiler.stage.saturating_sub(1), builder.config.host_target)
 }
 
+/// Returns a compiler that is able to compile a `ToolTarget` tool for the given `target`.
+pub(crate) fn get_tool_target_compiler(builder: &Builder<'_>, target: TargetSelection) -> Compiler {
+    todo!("FIX");
+    if builder.host_target == target {
+        builder.compiler(0, builder.host_target)
+    } else {
+        // FIXME: should this be builder.top_stage to avoid rebuilds?
+        builder.compiler(1, target)
+    }
+}
+
 /// Links a built tool binary with the given `name` from the build directory to the
 /// tools directory.
 fn copy_link_tool_bin(
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index 065d7e45e0f..c6f3c876a6f 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -537,7 +537,7 @@ impl Builder<'_> {
             }
         }
 
-        let stage = if compiler.stage == 0 && self.local_rebuild {
+        let build_compiler_stage = if compiler.stage == 0 && self.local_rebuild {
             // Assume the local-rebuild rustc already has stage1 features.
             1
         } else {
@@ -545,15 +545,17 @@ impl Builder<'_> {
         };
 
         // We synthetically interpret a stage0 compiler used to build tools as a
-        // "raw" compiler in that it's the exact snapshot we download. Normally
-        // the stage0 build means it uses libraries build by the stage0
-        // compiler, but for tools we just use the precompiled libraries that
-        // we've downloaded
-        let use_snapshot = mode == Mode::ToolBootstrap;
-        assert!(!use_snapshot || stage == 0 || self.local_rebuild);
-
-        let maybe_sysroot = self.sysroot(compiler);
-        let sysroot = if use_snapshot { self.rustc_snapshot_sysroot() } else { &maybe_sysroot };
+        // "raw" compiler in that it's the exact snapshot we download. For things like
+        // ToolRustc, we would have to use the artificial stage0-sysroot compiler instead.
+        let use_snapshot =
+            mode == Mode::ToolBootstrap || (mode == Mode::ToolTarget && build_compiler_stage == 0);
+        assert!(!use_snapshot || build_compiler_stage == 0 || self.local_rebuild);
+
+        let sysroot = if use_snapshot {
+            self.rustc_snapshot_sysroot().to_path_buf()
+        } else {
+            self.sysroot(compiler)
+        };
         let libdir = self.rustc_libdir(compiler);
 
         let sysroot_str = sysroot.as_os_str().to_str().expect("sysroot should be UTF-8");
@@ -562,7 +564,7 @@ impl Builder<'_> {
         }
 
         let mut rustflags = Rustflags::new(target);
-        if stage != 0 {
+        if build_compiler_stage != 0 {
             if let Ok(s) = env::var("CARGOFLAGS_NOT_BOOTSTRAP") {
                 cargo.args(s.split_whitespace());
             }
@@ -604,7 +606,7 @@ impl Builder<'_> {
         // sysroot. Passing this cfg enables raw-dylib support instead, which makes the native
         // library unnecessary. This can be removed when windows-rs enables raw-dylib
         // unconditionally.
-        if let Mode::Rustc | Mode::ToolRustc | Mode::ToolBootstrap = mode {
+        if let Mode::Rustc | Mode::ToolRustc | Mode::ToolBootstrap | Mode::ToolTarget = mode {
             rustflags.arg("--cfg=windows_raw_dylib");
         }
 
@@ -657,7 +659,7 @@ impl Builder<'_> {
         // FIXME(rust-lang/cargo#5754) we shouldn't be using special command arguments
         // to the host invocation here, but rather Cargo should know what flags to pass rustc
         // itself.
-        if stage == 0 {
+        if build_compiler_stage == 0 {
             hostflags.arg("--cfg=bootstrap");
         }
 
@@ -666,7 +668,7 @@ impl Builder<'_> {
         // #71458.
         let mut rustdocflags = rustflags.clone();
         rustdocflags.propagate_cargo_env("RUSTDOCFLAGS");
-        if stage == 0 {
+        if build_compiler_stage == 0 {
             rustdocflags.env("RUSTDOCFLAGS_BOOTSTRAP");
         } else {
             rustdocflags.env("RUSTDOCFLAGS_NOT_BOOTSTRAP");
@@ -677,7 +679,7 @@ impl Builder<'_> {
         }
 
         match mode {
-            Mode::Std | Mode::ToolBootstrap | Mode::ToolStd => {}
+            Mode::Std | Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolTarget => {}
             Mode::Rustc | Mode::Codegen | Mode::ToolRustc => {
                 // Build proc macros both for the host and the target unless proc-macros are not
                 // supported by the target.
@@ -719,7 +721,7 @@ impl Builder<'_> {
         // feature on the rustc side.
         cargo.arg("-Zbinary-dep-depinfo");
         let allow_features = match mode {
-            Mode::ToolBootstrap | Mode::ToolStd => {
+            Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolTarget => {
                 // Restrict the allowed features so we don't depend on nightly
                 // accidentally.
                 //
@@ -827,7 +829,7 @@ impl Builder<'_> {
         cargo
             .env("RUSTBUILD_NATIVE_DIR", self.native_dir(target))
             .env("RUSTC_REAL", self.rustc(compiler))
-            .env("RUSTC_STAGE", stage.to_string())
+            .env("RUSTC_STAGE", build_compiler_stage.to_string())
             .env("RUSTC_SYSROOT", sysroot)
             .env("RUSTC_LIBDIR", libdir)
             .env("RUSTDOC", self.bootstrap_out.join("rustdoc"))
@@ -872,7 +874,7 @@ impl Builder<'_> {
         let debuginfo_level = match mode {
             Mode::Rustc | Mode::Codegen => self.config.rust_debuginfo_level_rustc,
             Mode::Std => self.config.rust_debuginfo_level_std,
-            Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolRustc => {
+            Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolRustc | Mode::ToolTarget => {
                 self.config.rust_debuginfo_level_tools
             }
         };
@@ -884,11 +886,10 @@ impl Builder<'_> {
             profile_var("DEBUG_ASSERTIONS"),
             match mode {
                 Mode::Std => self.config.std_debug_assertions,
-                Mode::Rustc => self.config.rustc_debug_assertions,
-                Mode::Codegen => self.config.rustc_debug_assertions,
-                Mode::ToolBootstrap => self.config.tools_debug_assertions,
-                Mode::ToolStd => self.config.tools_debug_assertions,
-                Mode::ToolRustc => self.config.tools_debug_assertions,
+                Mode::Rustc | Mode::Codegen => self.config.rustc_debug_assertions,
+                Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolRustc | Mode::ToolTarget => {
+                    self.config.tools_debug_assertions
+                }
             }
             .to_string(),
         );
@@ -959,7 +960,11 @@ impl Builder<'_> {
                     cargo.env("CFG_VIRTUAL_RUSTC_DEV_SOURCE_BASE_DIR", map_to);
                 }
             }
-            Mode::Std | Mode::ToolBootstrap | Mode::ToolRustc | Mode::ToolStd => {
+            Mode::Std
+            | Mode::ToolBootstrap
+            | Mode::ToolRustc
+            | Mode::ToolStd
+            | Mode::ToolTarget => {
                 if let Some(ref map_to) =
                     self.build.debuginfo_map_to(GitRepo::Rustc, RemapScheme::NonCompiler)
                 {
@@ -1274,7 +1279,7 @@ impl Builder<'_> {
             };
 
             if let Some(limit) = limit
-                && (stage == 0
+                && (build_compiler_stage == 0
                     || self.config.default_codegen_backend(target).unwrap_or_default() == "llvm")
             {
                 rustflags.arg(&format!("-Cllvm-args=-import-instr-limit={limit}"));
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 7464327fde9..e538c12df6d 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -959,6 +959,7 @@ impl<'a> Builder<'a> {
                 tool::RemoteTestServer,
                 tool::RemoteTestClient,
                 tool::RustInstaller,
+                tool::FeaturesStatusDump,
                 tool::Cargo,
                 tool::RustAnalyzer,
                 tool::RustAnalyzerProcMacroSrv,
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index ef5c28272b8..4ec0b089bac 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -253,12 +253,24 @@ pub enum Mode {
     /// These tools are intended to be only executed on the host system that
     /// invokes bootstrap, and they thus cannot be cross-compiled.
     ///
-    /// They are always built using the stage0 compiler, and typically they
+    /// They are always built using the stage0 compiler, and they
     /// can be compiled with stable Rust.
     ///
     /// These tools also essentially do not participate in staging.
     ToolBootstrap,
 
+    /// Build a cross-compilable helper tool. These tools do not depend on unstable features or
+    /// compiler internals, but they might be cross-compilable (so we cannot build them using the
+    /// stage0 compiler, unlike `ToolBootstrap`).
+    ///
+    /// Some of these tools are also shipped in our `dist` archives.
+    /// While we could compile them using the stage0 compiler when not cross-compiling, we instead
+    /// use the in-tree compiler (and std) to build them, so that we can ship e.g. std security
+    /// fixes and avoid depending fully on stage0 for the artifacts that we ship.
+    ///
+    /// This mode is used e.g. for linkers and linker tools invoked by rustc on its host target.
+    ToolTarget,
+
     /// Build a tool which uses the locally built std, placing output in the
     /// "stageN-tools" directory. Its usage is quite rare, mainly used by
     /// compiletest which needs libtest.
@@ -273,11 +285,21 @@ pub enum Mode {
 
 impl Mode {
     pub fn is_tool(&self) -> bool {
-        matches!(self, Mode::ToolBootstrap | Mode::ToolRustc | Mode::ToolStd)
+        match self {
+            Mode::ToolBootstrap | Mode::ToolRustc | Mode::ToolStd | Mode::ToolTarget => true,
+            Mode::Std | Mode::Codegen | Mode::Rustc => false,
+        }
     }
 
     pub fn must_support_dlopen(&self) -> bool {
-        matches!(self, Mode::Std | Mode::Codegen)
+        match self {
+            Mode::Std | Mode::Codegen => true,
+            Mode::ToolBootstrap
+            | Mode::ToolRustc
+            | Mode::ToolStd
+            | Mode::ToolTarget
+            | Mode::Rustc => false,
+        }
     }
 }
 
@@ -804,17 +826,39 @@ impl Build {
     /// stage when running with a particular host compiler.
     ///
     /// The mode indicates what the root directory is for.
-    fn stage_out(&self, compiler: Compiler, mode: Mode) -> PathBuf {
-        let suffix = match mode {
-            Mode::Std => "-std",
-            Mode::Rustc => "-rustc",
-            Mode::Codegen => "-codegen",
-            Mode::ToolBootstrap => {
-                return self.out.join(compiler.host).join("bootstrap-tools");
+    fn stage_out(&self, build_compiler: Compiler, mode: Mode) -> PathBuf {
+        use std::fmt::Write;
+
+        fn bootstrap_tool() -> (Option<u32>, &'static str) {
+            (None, "bootstrap-tools")
+        }
+        fn staged_tool(build_compiler: Compiler) -> (Option<u32>, &'static str) {
+            (Some(build_compiler.stage), "tools")
+        }
+
+        let (stage, suffix) = match mode {
+            Mode::Std => (Some(build_compiler.stage), "std"),
+            Mode::Rustc => (Some(build_compiler.stage), "rustc"),
+            Mode::Codegen => (Some(build_compiler.stage), "codegen"),
+            Mode::ToolBootstrap => bootstrap_tool(),
+            Mode::ToolStd | Mode::ToolRustc => (Some(build_compiler.stage), "tools"),
+            Mode::ToolTarget => {
+                // If we're not cross-compiling (the common case), share the target directory with
+                // bootstrap tools to reuse the build cache.
+                if build_compiler.stage == 0 {
+                    bootstrap_tool()
+                } else {
+                    staged_tool(build_compiler)
+                }
             }
-            Mode::ToolStd | Mode::ToolRustc => "-tools",
         };
-        self.out.join(compiler.host).join(format!("stage{}{}", compiler.stage, suffix))
+        let path = self.out.join(build_compiler.host);
+        let mut dir_name = String::new();
+        if let Some(stage) = stage {
+            write!(dir_name, "stage{stage}-").unwrap();
+        }
+        dir_name.push_str(suffix);
+        path.join(dir_name)
     }
 
     /// Returns the root output directory for all Cargo output in a given stage,
-- 
cgit 1.4.1-3-g733a5


From 6511ece1e37a975aa6e060ca56fdf31af8c04fb5 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 8 Jul 2025 17:00:41 +0200
Subject: Port `RemoteTestServer` to `ToolTarget`

---
 src/bootstrap/src/core/build_steps/check.rs |  4 ++--
 src/bootstrap/src/core/build_steps/test.rs  |  3 ++-
 src/bootstrap/src/core/build_steps/tool.rs  | 30 ++++++++++++++++-------------
 3 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index bdaf8917dd9..2ba4c37d9a7 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -5,7 +5,7 @@ use crate::core::build_steps::compile::{
 };
 use crate::core::build_steps::tool;
 use crate::core::build_steps::tool::{
-    COMPILETEST_ALLOW_FEATURES, SourceType, get_tool_target_compiler, prepare_tool_cargo,
+    COMPILETEST_ALLOW_FEATURES, SourceType, get_compiler_for_target, prepare_tool_cargo,
 };
 use crate::core::builder::{
     self, Alias, Builder, Kind, RunConfig, ShouldRun, Step, StepMetadata, crate_description,
@@ -252,7 +252,7 @@ fn prepare_compiler_for_check(
 
     match mode {
         Mode::ToolBootstrap => builder.compiler(0, host),
-        Mode::ToolTarget => get_tool_target_compiler(builder, target),
+        Mode::ToolTarget => get_compiler_for_target(builder, target),
         Mode::ToolStd => {
             // These tools require the local standard library to be checked
             let build_compiler = builder.compiler(builder.top_stage, host);
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 716bef3f38c..4acc609626e 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -2941,7 +2941,8 @@ impl Step for RemoteCopyLibs {
 
         builder.info(&format!("REMOTE copy libs to emulator ({target})"));
 
-        let remote_test_server = builder.ensure(tool::RemoteTestServer { compiler, target });
+        let remote_test_server =
+            builder.ensure(tool::RemoteTestServer { build_compiler: compiler, target });
 
         // Spawn the emulator and wait for it to come online
         let tool = builder.tool_exe(Tool::RemoteTestClient);
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 9fac8df4ae8..631d0438527 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -133,7 +133,7 @@ impl Step for ToolBuild {
                     builder.std(self.build_compiler, target);
                 }
             }
-            Mode::ToolBootstrap => {} // uses downloaded stage0 compiler libs
+            Mode::ToolBootstrap | Mode::ToolTarget => {} // uses downloaded stage0 compiler libs
             _ => panic!("unexpected Mode for tool build"),
         }
 
@@ -196,7 +196,7 @@ impl Step for ToolBuild {
             Kind::Build,
             self.mode,
             self.tool,
-            self.build_compiler.stage,
+            self.build_compiler.stage + 1,
             &self.build_compiler.host,
             &self.target,
         );
@@ -365,15 +365,15 @@ pub(crate) fn get_tool_rustc_compiler(
     builder.compiler(target_compiler.stage.saturating_sub(1), builder.config.host_target)
 }
 
-/// Returns a compiler that is able to compile a `ToolTarget` tool for the given `target`.
-pub(crate) fn get_tool_target_compiler(builder: &Builder<'_>, target: TargetSelection) -> Compiler {
-    todo!("FIX");
-    if builder.host_target == target {
+/// Returns the smallest stage compiler that is able to compile code for the given `target`.
+pub(crate) fn get_compiler_for_target(builder: &Builder<'_>, target: TargetSelection) -> Compiler {
+    let compiler = if builder.host_target == target {
         builder.compiler(0, builder.host_target)
     } else {
-        // FIXME: should this be builder.top_stage to avoid rebuilds?
-        builder.compiler(1, target)
-    }
+        builder.compiler(1, builder.host_target)
+    };
+    builder.std(compiler, target);
+    compiler
 }
 
 /// Links a built tool binary with the given `name` from the build directory to the
@@ -648,7 +648,7 @@ impl Step for ErrorIndex {
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct RemoteTestServer {
-    pub compiler: Compiler,
+    pub build_compiler: Compiler,
     pub target: TargetSelection,
 }
 
@@ -661,17 +661,17 @@ impl Step for RemoteTestServer {
 
     fn make_run(run: RunConfig<'_>) {
         run.builder.ensure(RemoteTestServer {
-            compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.host_target),
+            build_compiler: get_compiler_for_target(run.builder, run.target),
             target: run.target,
         });
     }
 
     fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
         builder.ensure(ToolBuild {
-            build_compiler: self.compiler,
+            build_compiler: self.build_compiler,
             target: self.target,
             tool: "remote-test-server",
-            mode: Mode::ToolStd,
+            mode: Mode::ToolTarget,
             path: "src/tools/remote-test-server",
             source_type: SourceType::InTree,
             extra_features: Vec::new(),
@@ -680,6 +680,10 @@ impl Step for RemoteTestServer {
             artifact_kind: ToolArtifactKind::Binary,
         })
     }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(StepMetadata::build("remote-test-server", self.target).built_by(self.build_compiler))
+    }
 }
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd)]
-- 
cgit 1.4.1-3-g733a5


From 89370e0240adf25216427e787787780bcb90156e Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 8 Jul 2025 17:16:14 +0200
Subject: Make `WasmComponentLd` a `ToolTarget` tool

---
 src/bootstrap/src/core/build_steps/check.rs   |   5 +-
 src/bootstrap/src/core/build_steps/compile.rs |  14 ++--
 src/bootstrap/src/core/build_steps/tool.rs    | 107 ++++++++++++++++++++++++--
 src/bootstrap/src/core/builder/mod.rs         |   1 +
 4 files changed, 111 insertions(+), 16 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 2ba4c37d9a7..d4d3b7a7bab 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -5,7 +5,8 @@ use crate::core::build_steps::compile::{
 };
 use crate::core::build_steps::tool;
 use crate::core::build_steps::tool::{
-    COMPILETEST_ALLOW_FEATURES, SourceType, get_compiler_for_target, prepare_tool_cargo,
+    COMPILETEST_ALLOW_FEATURES, SourceType, ToolTargetBuildMode, get_tool_target_compiler,
+    prepare_tool_cargo,
 };
 use crate::core::builder::{
     self, Alias, Builder, Kind, RunConfig, ShouldRun, Step, StepMetadata, crate_description,
@@ -252,7 +253,7 @@ fn prepare_compiler_for_check(
 
     match mode {
         Mode::ToolBootstrap => builder.compiler(0, host),
-        Mode::ToolTarget => get_compiler_for_target(builder, target),
+        Mode::ToolTarget => get_tool_target_compiler(builder, ToolTargetBuildMode::Build(target)),
         Mode::ToolStd => {
             // These tools require the local standard library to be checked
             let build_compiler = builder.compiler(builder.top_stage, host);
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 0587d21ecc2..60618942c82 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -2286,15 +2286,13 @@ impl Step for Assemble {
         }
 
         // In addition to `rust-lld` also install `wasm-component-ld` when
-        // LLD is enabled. This is a relatively small binary that primarily
-        // delegates to the `rust-lld` binary for linking and then runs
-        // logic to create the final binary. This is used by the
-        // `wasm32-wasip2` target of Rust.
+        // is enabled. This is used by the `wasm32-wasip2` target of Rust.
         if builder.tool_enabled("wasm-component-ld") {
-            let wasm_component = builder.ensure(crate::core::build_steps::tool::WasmComponentLd {
-                compiler: build_compiler,
-                target: target_compiler.host,
-            });
+            let wasm_component =
+                builder.ensure(crate::core::build_steps::tool::WasmComponentLd::for_compiler(
+                    builder,
+                    target_compiler,
+                ));
             builder.copy_link(
                 &wasm_component.tool_path,
                 &libdir_bin.join(wasm_component.tool_path.file_name().unwrap()),
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 631d0438527..2d3187274f2 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -365,12 +365,36 @@ pub(crate) fn get_tool_rustc_compiler(
     builder.compiler(target_compiler.stage.saturating_sub(1), builder.config.host_target)
 }
 
-/// Returns the smallest stage compiler that is able to compile code for the given `target`.
-pub(crate) fn get_compiler_for_target(builder: &Builder<'_>, target: TargetSelection) -> Compiler {
+/// Determines how to build a `ToolTarget`, i.e. which compiler should be used to compile it.
+/// The compiler stage is automatically auto-bumped if we need to cross-compile a stage 1 tool.
+pub enum ToolTargetBuildMode {
+    /// Build the tool using rustc that corresponds to the selected CLI stage.
+    Build(TargetSelection),
+    /// Build the tool so that it can be attached to the sysroot of the passed compiler.
+    /// Since we always dist stage 2+, the compiler that builds the tool in this case has to be
+    /// stage 1+.
+    Dist(Compiler),
+}
+
+/// Returns compiler that is able to compile a `ToolTarget` tool with the given `mode`.
+pub(crate) fn get_tool_target_compiler(
+    builder: &Builder<'_>,
+    mode: ToolTargetBuildMode,
+) -> Compiler {
+    let (target, min_build_compiler_stage) = match mode {
+        ToolTargetBuildMode::Build(target) => {
+            assert!(builder.top_stage > 0);
+            (target, builder.top_stage - 1)
+        }
+        ToolTargetBuildMode::Dist(target_compiler) => {
+            assert!(target_compiler.stage > 0);
+            (target_compiler.host, target_compiler.stage - 1)
+        }
+    };
     let compiler = if builder.host_target == target {
-        builder.compiler(0, builder.host_target)
+        builder.compiler(min_build_compiler_stage, builder.host_target)
     } else {
-        builder.compiler(1, builder.host_target)
+        builder.compiler(min_build_compiler_stage.max(1), builder.host_target)
     };
     builder.std(compiler, target);
     compiler
@@ -533,7 +557,6 @@ bootstrap_tool!(
     // rustdoc-gui-test has a crate dependency on compiletest, so it needs the same unstable features.
     RustdocGUITest, "src/tools/rustdoc-gui-test", "rustdoc-gui-test", is_unstable_tool = true, allow_features = COMPILETEST_ALLOW_FEATURES;
     CoverageDump, "src/tools/coverage-dump", "coverage-dump";
-    WasmComponentLd, "src/tools/wasm-component-ld", "wasm-component-ld", is_unstable_tool = true, allow_features = "min_specialization";
     UnicodeTableGenerator, "src/tools/unicode-table-generator", "unicode-table-generator";
     FeaturesStatusDump, "src/tools/features-status-dump", "features-status-dump";
     OptimizedDist, "src/tools/opt-dist", "opt-dist", submodules = &["src/tools/rustc-perf"];
@@ -661,7 +684,10 @@ impl Step for RemoteTestServer {
 
     fn make_run(run: RunConfig<'_>) {
         run.builder.ensure(RemoteTestServer {
-            build_compiler: get_compiler_for_target(run.builder, run.target),
+            build_compiler: get_tool_target_compiler(
+                run.builder,
+                ToolTargetBuildMode::Build(run.target),
+            ),
             target: run.target,
         });
     }
@@ -935,6 +961,75 @@ impl Step for LldWrapper {
     }
 }
 
+/// Builds the `wasm-component-ld` linker wrapper, which is shipped with rustc to be executed on the
+/// host platform where rustc runs.
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub struct WasmComponentLd {
+    build_compiler: Compiler,
+    target: TargetSelection,
+}
+
+impl WasmComponentLd {
+    /// Returns `WasmComponentLd` that should be **used** by the passed compiler.
+    pub fn for_compiler(builder: &Builder<'_>, target_compiler: Compiler) -> Self {
+        Self {
+            build_compiler: get_tool_target_compiler(
+                builder,
+                ToolTargetBuildMode::Dist(target_compiler),
+            ),
+            target: target_compiler.host,
+        }
+    }
+}
+
+impl Step for WasmComponentLd {
+    type Output = ToolBuildResult;
+
+    const ONLY_HOSTS: bool = true;
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.path("src/tools/wasm-component-ld")
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        run.builder.ensure(WasmComponentLd {
+            build_compiler: get_tool_target_compiler(
+                run.builder,
+                ToolTargetBuildMode::Build(run.target),
+            ),
+            target: run.target,
+        });
+    }
+
+    #[cfg_attr(
+        feature = "tracing",
+        instrument(
+            level = "debug",
+            name = "WasmComponentLd::run",
+            skip_all,
+            fields(build_compiler = ?self.build_compiler),
+        ),
+    )]
+    fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
+        builder.ensure(ToolBuild {
+            build_compiler: self.build_compiler,
+            target: self.target,
+            tool: "wasm-component-ld",
+            mode: Mode::ToolTarget,
+            path: "src/tools/wasm-component-ld",
+            source_type: SourceType::InTree,
+            extra_features: vec![],
+            allow_features: "min-specialization",
+            cargo_args: vec![],
+            artifact_kind: ToolArtifactKind::Binary,
+        })
+    }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(StepMetadata::build("WasmComponentLd", self.target).built_by(self.build_compiler))
+    }
+}
+
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct RustAnalyzer {
     pub compiler: Compiler,
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index e538c12df6d..65e9c3850e7 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -981,6 +981,7 @@ impl<'a> Builder<'a> {
                 tool::CoverageDump,
                 tool::LlvmBitcodeLinker,
                 tool::RustcPerf,
+                tool::WasmComponentLd
             ),
             Kind::Clippy => describe!(
                 clippy::Std,
-- 
cgit 1.4.1-3-g733a5


From c571b97778e554d5e01302016cb709a41362d34b Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 8 Jul 2025 17:19:38 +0200
Subject: Make `LldWrapper` a `ToolTarget` tool

---
 src/bootstrap/src/core/build_steps/compile.rs |  10 +--
 src/bootstrap/src/core/build_steps/tool.rs    | 115 ++++++++++++++++----------
 src/bootstrap/src/core/builder/mod.rs         |   3 +-
 3 files changed, 78 insertions(+), 50 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 60618942c82..9e60a04e69f 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -19,7 +19,7 @@ use serde_derive::Deserialize;
 use tracing::{instrument, span};
 
 use crate::core::build_steps::gcc::{Gcc, add_cg_gcc_cargo_flags};
-use crate::core::build_steps::tool::SourceType;
+use crate::core::build_steps::tool::{SourceType, copy_lld_artifacts};
 use crate::core::build_steps::{dist, llvm};
 use crate::core::builder;
 use crate::core::builder::{
@@ -2258,10 +2258,10 @@ impl Step for Assemble {
         copy_codegen_backends_to_sysroot(builder, build_compiler, target_compiler);
 
         if builder.config.lld_enabled {
-            builder.ensure(crate::core::build_steps::tool::LldWrapper {
-                build_compiler,
-                target_compiler,
-            });
+            let lld_wrapper = builder.ensure(
+                crate::core::build_steps::tool::LldWrapper::for_compiler(builder, target_compiler),
+            );
+            copy_lld_artifacts(builder, lld_wrapper, target_compiler);
         }
 
         if builder.config.llvm_enabled(target_compiler.host) && builder.config.llvm_tools_enabled {
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 2d3187274f2..fc7e0f81ad9 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -881,17 +881,50 @@ impl Step for Cargo {
     }
 }
 
+/// Represents a built LldWrapper, the `lld-wrapper` tool itself, and a directory
+/// containing a build of LLD.
+#[derive(Clone)]
+pub struct BuiltLldWrapper {
+    tool: ToolBuildResult,
+    lld_dir: PathBuf,
+}
+
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct LldWrapper {
     pub build_compiler: Compiler,
-    pub target_compiler: Compiler,
+    pub target: TargetSelection,
+}
+
+impl LldWrapper {
+    /// Returns `LldWrapper` that should be **used** by the passed compiler.
+    pub fn for_compiler(builder: &Builder<'_>, target_compiler: Compiler) -> Self {
+        Self {
+            build_compiler: get_tool_target_compiler(
+                builder,
+                ToolTargetBuildMode::Dist(target_compiler),
+            ),
+            target: target_compiler.host,
+        }
+    }
 }
 
 impl Step for LldWrapper {
-    type Output = ToolBuildResult;
+    type Output = BuiltLldWrapper;
+
+    const ONLY_HOSTS: bool = true;
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        run.never()
+        run.path("src/tools/lld-wrapper")
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        run.builder.ensure(LldWrapper {
+            build_compiler: get_tool_target_compiler(
+                run.builder,
+                ToolTargetBuildMode::Build(run.target),
+            ),
+            target: run.target,
+        });
     }
 
     #[cfg_attr(
@@ -900,25 +933,16 @@ impl Step for LldWrapper {
             level = "debug",
             name = "LldWrapper::run",
             skip_all,
-            fields(build_compiler = ?self.build_compiler, target_compiler = ?self.target_compiler),
+            fields(build_compiler = ?self.build_compiler),
         ),
     )]
-    fn run(self, builder: &Builder<'_>) -> ToolBuildResult {
-        if builder.config.dry_run() {
-            return ToolBuildResult {
-                tool_path: Default::default(),
-                build_compiler: self.build_compiler,
-                target_compiler: self.target_compiler,
-            };
-        }
-
-        let target = self.target_compiler.host;
-
-        let tool_result = builder.ensure(ToolBuild {
+    fn run(self, builder: &Builder<'_>) -> Self::Output {
+        let lld_dir = builder.ensure(llvm::Lld { target: self.target });
+        let tool = builder.ensure(ToolBuild {
             build_compiler: self.build_compiler,
-            target,
+            target: self.target,
             tool: "lld-wrapper",
-            mode: Mode::ToolStd,
+            mode: Mode::ToolTarget,
             path: "src/tools/lld-wrapper",
             source_type: SourceType::InTree,
             extra_features: Vec::new(),
@@ -926,38 +950,41 @@ impl Step for LldWrapper {
             cargo_args: Vec::new(),
             artifact_kind: ToolArtifactKind::Binary,
         });
+        BuiltLldWrapper { tool, lld_dir }
+    }
+
+    fn metadata(&self) -> Option<StepMetadata> {
+        Some(StepMetadata::build("LldWrapper", self.target).built_by(self.build_compiler))
+    }
+}
+
+pub(crate) fn copy_lld_artifacts(
+    builder: &Builder<'_>,
+    lld_wrapper: BuiltLldWrapper,
+    target_compiler: Compiler,
+) {
+    let target = target_compiler.host;
+
+    let libdir_bin = builder.sysroot_target_bindir(target_compiler, target);
+    t!(fs::create_dir_all(&libdir_bin));
 
-        let libdir_bin = builder.sysroot_target_bindir(self.target_compiler, target);
-        t!(fs::create_dir_all(&libdir_bin));
+    let src_exe = exe("lld", target);
+    let dst_exe = exe("rust-lld", target);
 
-        let lld_install = builder.ensure(llvm::Lld { target });
-        let src_exe = exe("lld", target);
-        let dst_exe = exe("rust-lld", target);
+    builder.copy_link(
+        &lld_wrapper.lld_dir.join("bin").join(src_exe),
+        &libdir_bin.join(dst_exe),
+        FileType::Executable,
+    );
+    let self_contained_lld_dir = libdir_bin.join("gcc-ld");
+    t!(fs::create_dir_all(&self_contained_lld_dir));
 
+    for name in crate::LLD_FILE_NAMES {
         builder.copy_link(
-            &lld_install.join("bin").join(src_exe),
-            &libdir_bin.join(dst_exe),
+            &lld_wrapper.tool.tool_path,
+            &self_contained_lld_dir.join(exe(name, target)),
             FileType::Executable,
         );
-        let self_contained_lld_dir = libdir_bin.join("gcc-ld");
-        t!(fs::create_dir_all(&self_contained_lld_dir));
-
-        for name in crate::LLD_FILE_NAMES {
-            builder.copy_link(
-                &tool_result.tool_path,
-                &self_contained_lld_dir.join(exe(name, target)),
-                FileType::Executable,
-            );
-        }
-
-        tool_result
-    }
-
-    fn metadata(&self) -> Option<StepMetadata> {
-        Some(
-            StepMetadata::build("LldWrapper", self.target_compiler.host)
-                .built_by(self.build_compiler),
-        )
     }
 }
 
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 65e9c3850e7..34737606020 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -981,7 +981,8 @@ impl<'a> Builder<'a> {
                 tool::CoverageDump,
                 tool::LlvmBitcodeLinker,
                 tool::RustcPerf,
-                tool::WasmComponentLd
+                tool::WasmComponentLd,
+                tool::LldWrapper
             ),
             Kind::Clippy => describe!(
                 clippy::Std,
-- 
cgit 1.4.1-3-g733a5


From d79e98c9baa3576bacbd74a0101e740b05a70801 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 8 Jul 2025 17:34:09 +0200
Subject: Extend dist extended tools test

---
 src/bootstrap/src/core/builder/tests.rs | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index bbcb58fca14..d095b09ac01 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1062,18 +1062,28 @@ mod snapshot {
     fn dist_extended() {
         let ctx = TestCtx::new();
         insta::assert_snapshot!(
-            ctx
-                .config("dist")
-                .args(&["--set", "build.extended=true"])
-                .render_steps(), @r"
+            ctx.config("dist")
+            .args(&[
+                "--set",
+                "build.extended=true",
+                "--set",
+                "rust.llvm-bitcode-linker=true",
+                "--set",
+                "rust.lld=true",
+            ])
+            .render_steps(), @r"
         [build] rustc 0 <host> -> UnstableBookGen 1 <host>
         [build] rustc 0 <host> -> Rustbook 1 <host>
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 0 <host> -> LldWrapper 1 <host>
         [build] rustc 0 <host> -> WasmComponentLd 1 <host>
+        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
+        [build] rustc 1 <host> -> LldWrapper 2 <host>
         [build] rustc 1 <host> -> WasmComponentLd 2 <host>
+        [build] rustc 2 <host> -> LlvmBitcodeLinker 3 <host>
         [build] rustdoc 1 <host>
         [doc] std 2 <host>
         [build] rustc 2 <host> -> std 2 <host>
@@ -1092,7 +1102,6 @@ mod snapshot {
         [build] rustc 0 <host> -> cargo-clippy 1 <host>
         [build] rustc 0 <host> -> miri 1 <host>
         [build] rustc 0 <host> -> cargo-miri 1 <host>
-        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
         ");
     }
 
-- 
cgit 1.4.1-3-g733a5


From 5933053aeb65f580116065869aaf5f0eaf35988e Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 8 Jul 2025 17:38:27 +0200
Subject: Make `LlvmBitcodeLinker` a `ToolTarget` tool

---
 src/bootstrap/src/core/build_steps/compile.rs | 25 +++++++++++++------------
 src/bootstrap/src/core/build_steps/dist.rs    | 18 +++++++-----------
 src/bootstrap/src/core/build_steps/install.rs |  2 +-
 src/bootstrap/src/core/build_steps/tool.rs    | 26 ++++++++++++++++++++------
 src/bootstrap/src/core/builder/tests.rs       | 15 ++++++++-------
 5 files changed, 49 insertions(+), 37 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 9e60a04e69f..6d9160236e3 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -2052,19 +2052,20 @@ impl Step for Assemble {
             }
         }
 
-        let maybe_install_llvm_bitcode_linker = |compiler| {
+        let maybe_install_llvm_bitcode_linker = || {
             if builder.config.llvm_bitcode_linker_enabled {
                 trace!("llvm-bitcode-linker enabled, installing");
-                let llvm_bitcode_linker =
-                    builder.ensure(crate::core::build_steps::tool::LlvmBitcodeLinker {
-                        build_compiler: compiler,
-                        target: target_compiler.host,
-                    });
+                let llvm_bitcode_linker = builder.ensure(
+                    crate::core::build_steps::tool::LlvmBitcodeLinker::for_compiler(
+                        builder,
+                        target_compiler,
+                    ),
+                );
 
                 // Copy the llvm-bitcode-linker to the self-contained binary directory
                 let bindir_self_contained = builder
-                    .sysroot(compiler)
-                    .join(format!("lib/rustlib/{}/bin/self-contained", compiler.host));
+                    .sysroot(target_compiler)
+                    .join(format!("lib/rustlib/{}/bin/self-contained", target_compiler.host));
                 let tool_exe = exe("llvm-bitcode-linker", target_compiler.host);
 
                 t!(fs::create_dir_all(&bindir_self_contained));
@@ -2091,9 +2092,9 @@ impl Step for Assemble {
                 builder.info(&format!("Creating a sysroot for stage{stage} compiler (use `rustup toolchain link 'name' build/host/stage{stage}`)", stage = target_compiler.stage));
             }
 
-            let mut precompiled_compiler = target_compiler;
-            precompiled_compiler.forced_compiler(true);
-            maybe_install_llvm_bitcode_linker(precompiled_compiler);
+            // FIXME: this is incomplete, we do not copy a bunch of other stuff to the downloaded
+            // sysroot...
+            maybe_install_llvm_bitcode_linker();
 
             return target_compiler;
         }
@@ -2300,7 +2301,7 @@ impl Step for Assemble {
             );
         }
 
-        maybe_install_llvm_bitcode_linker(target_compiler);
+        maybe_install_llvm_bitcode_linker();
 
         // Ensure that `libLLVM.so` ends up in the newly build compiler directory,
         // so that it can be found when the newly built `rustc` is run.
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index 8b2d65ace50..7d8825effc8 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -1575,7 +1575,10 @@ impl Step for Extended {
             compiler: builder.compiler(stage, target),
             backend: "cranelift".to_string(),
         });
-        add_component!("llvm-bitcode-linker" => LlvmBitcodeLinker {compiler, target});
+        add_component!("llvm-bitcode-linker" => LlvmBitcodeLinker {
+            target_compiler: compiler,
+            target
+        });
 
         let etc = builder.src.join("src/etc/installer");
 
@@ -2343,7 +2346,7 @@ impl Step for LlvmTools {
 
 #[derive(Debug, PartialOrd, Ord, Clone, Hash, PartialEq, Eq)]
 pub struct LlvmBitcodeLinker {
-    pub compiler: Compiler,
+    pub target_compiler: Compiler,
     pub target: TargetSelection,
 }
 
@@ -2359,23 +2362,16 @@ impl Step for LlvmBitcodeLinker {
 
     fn make_run(run: RunConfig<'_>) {
         run.builder.ensure(LlvmBitcodeLinker {
-            compiler: run.builder.compiler_for(
-                run.builder.top_stage,
-                run.builder.config.host_target,
-                run.target,
-            ),
+            target_compiler: run.builder.compiler(run.builder.top_stage, run.target),
             target: run.target,
         });
     }
 
     fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
-        let compiler = self.compiler;
         let target = self.target;
 
-        builder.ensure(compile::Rustc::new(compiler, target));
-
         let llbc_linker =
-            builder.ensure(tool::LlvmBitcodeLinker { build_compiler: compiler, target });
+            builder.ensure(tool::LlvmBitcodeLinker::for_compiler(builder, self.target_compiler));
 
         let self_contained_bin_dir = format!("lib/rustlib/{}/bin/self-contained", target.triple);
 
diff --git a/src/bootstrap/src/core/build_steps/install.rs b/src/bootstrap/src/core/build_steps/install.rs
index 4434d6658eb..285624916d1 100644
--- a/src/bootstrap/src/core/build_steps/install.rs
+++ b/src/bootstrap/src/core/build_steps/install.rs
@@ -287,7 +287,7 @@ install!((self, builder, _config),
         }
     };
     LlvmBitcodeLinker, alias = "llvm-bitcode-linker", Self::should_build(_config), only_hosts: true, {
-        if let Some(tarball) = builder.ensure(dist::LlvmBitcodeLinker { compiler: self.compiler, target: self.target }) {
+        if let Some(tarball) = builder.ensure(dist::LlvmBitcodeLinker { target_compiler: self.compiler, target: self.target }) {
             install_sh(builder, "llvm-bitcode-linker", self.compiler.stage, Some(self.target), &tarball);
         } else {
             builder.info(
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index fc7e0f81ad9..aa71574eef8 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -1159,8 +1159,21 @@ impl Step for RustAnalyzerProcMacroSrv {
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct LlvmBitcodeLinker {
-    pub build_compiler: Compiler,
-    pub target: TargetSelection,
+    build_compiler: Compiler,
+    target: TargetSelection,
+}
+
+impl LlvmBitcodeLinker {
+    /// Returns `LlvmBitcodeLinker` that should be **used** by the passed compiler.
+    pub fn for_compiler(builder: &Builder<'_>, target_compiler: Compiler) -> Self {
+        Self {
+            build_compiler: get_tool_target_compiler(
+                builder,
+                ToolTargetBuildMode::Dist(target_compiler),
+            ),
+            target: target_compiler.host,
+        }
+    }
 }
 
 impl Step for LlvmBitcodeLinker {
@@ -1176,9 +1189,10 @@ impl Step for LlvmBitcodeLinker {
 
     fn make_run(run: RunConfig<'_>) {
         run.builder.ensure(LlvmBitcodeLinker {
-            build_compiler: run
-                .builder
-                .compiler(run.builder.top_stage, run.builder.config.host_target),
+            build_compiler: get_tool_target_compiler(
+                run.builder,
+                ToolTargetBuildMode::Build(run.target),
+            ),
             target: run.target,
         });
     }
@@ -1192,7 +1206,7 @@ impl Step for LlvmBitcodeLinker {
             build_compiler: self.build_compiler,
             target: self.target,
             tool: "llvm-bitcode-linker",
-            mode: Mode::ToolRustc,
+            mode: Mode::ToolTarget,
             path: "src/tools/llvm-bitcode-linker",
             source_type: SourceType::InTree,
             extra_features: vec![],
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index d095b09ac01..4ca9ff98dee 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -769,11 +769,11 @@ mod snapshot {
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 0 <host> -> LldWrapper 1 <host>
-        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
+        [build] rustc 0 <host> -> LlvmBitcodeLinker 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustc 1 <host> -> LldWrapper 2 <host>
-        [build] rustc 2 <host> -> LlvmBitcodeLinker 3 <host>
+        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustdoc 1 <host>
         "
@@ -793,17 +793,17 @@ mod snapshot {
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 0 <host> -> LldWrapper 1 <host>
-        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
+        [build] rustc 0 <host> -> LlvmBitcodeLinker 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustc 1 <host> -> LldWrapper 2 <host>
-        [build] rustc 2 <host> -> LlvmBitcodeLinker 3 <host>
+        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
         [build] rustc 1 <host> -> std 1 <target1>
         [build] rustc 2 <host> -> std 2 <target1>
         [build] llvm <target1>
         [build] rustc 1 <host> -> rustc 2 <target1>
         [build] rustc 1 <host> -> LldWrapper 2 <target1>
-        [build] rustc 2 <target1> -> LlvmBitcodeLinker 3 <target1>
+        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <target1>
         [build] rustdoc 1 <target1>
         "
         );
@@ -1078,12 +1078,12 @@ mod snapshot {
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 0 <host> -> LldWrapper 1 <host>
         [build] rustc 0 <host> -> WasmComponentLd 1 <host>
-        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
+        [build] rustc 0 <host> -> LlvmBitcodeLinker 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustc 1 <host> -> LldWrapper 2 <host>
         [build] rustc 1 <host> -> WasmComponentLd 2 <host>
-        [build] rustc 2 <host> -> LlvmBitcodeLinker 3 <host>
+        [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
         [build] rustdoc 1 <host>
         [doc] std 2 <host>
         [build] rustc 2 <host> -> std 2 <host>
@@ -1293,6 +1293,7 @@ mod snapshot {
         [build] rustc 0 <host> -> miri 1 <target1>
         [build] rustc 0 <host> -> cargo-miri 1 <target1>
         [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <target1>
+        [build] rustc 0 <host> -> LlvmBitcodeLinker 1 <host>
         ");
     }
 
-- 
cgit 1.4.1-3-g733a5


From 8d58d5e800c0a52aef5194055c3e19e1bf345211 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Wed, 9 Jul 2025 20:02:36 +0800
Subject: Remove `run-make-support` CHANGELOG

Hopelessly outdated, and this support library is purely internal.
---
 src/tools/run-make-support/CHANGELOG.md | 83 ---------------------------------
 1 file changed, 83 deletions(-)
 delete mode 100644 src/tools/run-make-support/CHANGELOG.md

diff --git a/src/tools/run-make-support/CHANGELOG.md b/src/tools/run-make-support/CHANGELOG.md
deleted file mode 100644
index c1b7b618a92..00000000000
--- a/src/tools/run-make-support/CHANGELOG.md
+++ /dev/null
@@ -1,83 +0,0 @@
-# Changelog
-
-All notable changes to the `run_make_support` library should be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the support
-library should adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) even if it's
-not intended for public consumption (it's moreso to help internally, to help test writers track
-changes to the support library).
-
-This support library will probably never reach 1.0. Please bump the minor version in `Cargo.toml` if
-you make any breaking changes or other significant changes, or bump the patch version for bug fixes.
-
-## [0.2.0] - 2024-06-11
-
-### Added
-
-- Added `fs_wrapper` module which provides panic-on-fail helpers for their respective `std::fs`
-  counterparts, the motivation is to:
-    - Reduce littering `.unwrap()` or `.expect()` everywhere for fs operations
-    - Help the test writer avoid forgetting to check fs results (even though enforced by
-      `-Dunused_must_use`)
-    - Provide better panic messages by default
-- Added `path()` helper which creates a `Path` relative to `cwd()` (but is less noisy).
-
-### Changed
-
-- Marked many functions with `#[must_use]`, and rmake.rs are now compiled with `-Dunused_must_use`.
-
-## [0.1.0] - 2024-06-09
-
-### Changed
-
-- Use *drop bombs* to enforce that commands are executed; a command invocation will panic if it is
-  constructed but never executed. Execution methods `Command::{run, run_fail}` will defuse the drop
-  bomb.
-- Added `Command` helpers that forward to `std::process::Command` counterparts.
-
-### Removed
-
-- The `env_var` method which was incorrectly named and is `env_clear` underneath and is a footgun
-  from `impl_common_helpers`. For example, removing `TMPDIR` on Unix and `TMP`/`TEMP` breaks
-  `std::env::temp_dir` and wrecks anything using that, such as rustc's codgen.
-- Removed `Deref`/`DerefMut` for `run_make_support::Command` -> `std::process::Command` because it
-  causes a method chain like `htmldocck().arg().run()` to fail, because `arg()` resolves to
-  `std::process::Command` which also returns a `&mut std::process::Command`, causing the `run()` to
-  be not found.
-
-## [0.0.0] - 2024-06-09
-
-Consider this version to contain all changes made to the support library before we started to track
-changes in this changelog.
-
-### Added
-
-- Custom command wrappers around `std::process::Command` (`run_make_support::Command`) and custom
-  wrapper around `std::process::Output` (`CompletedProcess`) to make it more convenient to work with
-  commands and their output, and help avoid forgetting to check for exit status.
-    - `Command`: `set_stdin`, `run`, `run_fail`.
-    - `CompletedProcess`: `std{err,out}_utf8`, `status`, `assert_std{err,out}_{equals, contains,
-      not_contains}`, `assert_exit_code`.
-- `impl_common_helpers` macro to avoid repeating adding common convenience methods, including:
-    - Environment manipulation methods: `env`, `env_remove`
-    - Command argument providers: `arg`, `args`
-    - Common invocation inspection (of the command invocation up until `inspect` is called):
-      `inspect`
-    - Execution methods: `run` (for commands expected to succeed execution, exit status `0`) and
-      `run_fail` (for commands expected to fail execution, exit status non-zero).
-- Command wrappers around: `rustc`, `clang`, `cc`, `rustc`, `rustdoc`, `llvm-readobj`.
-- Thin helpers to construct `python` and `htmldocck` commands.
-- `run` and `run_fail` (like `Command::{run, run_fail}`) for running binaries, which sets suitable
-  env vars (like `LD_LIB_PATH` or equivalent, `TARGET_RPATH_ENV`, `PATH` on Windows).
-- Pseudo command `diff` which has similar functionality as the cli util but not the same API.
-- Convenience panic-on-fail helpers `env_var`, `env_var_os`, `cwd` for their `std::env` conterparts.
-- Convenience panic-on-fail helpers for reading respective env vars: `target`, `source_root`.
-- Platform check helpers: `is_windows`, `is_msvc`, `cygpath_windows`, `uname`.
-- fs helpers: `copy_dir_all`.
-- `recursive_diff` helper.
-- Generic `assert_not_contains` helper.
-- Scoped run-with-teardown helper `run_in_tmpdir` which is designed to run commands in a temporary
-  directory that is cleared when closure returns.
-- Helpers for constructing the name of binaries and libraries: `rust_lib_name`, `static_lib_name`,
-  `bin_name`, `dynamic_lib_name`.
-- Re-export libraries: `gimli`, `object`, `regex`, `wasmparsmer`.
-- 
cgit 1.4.1-3-g733a5


From ed520af279100728fd35df40cbf6353838cb7529 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Wed, 9 Jul 2025 20:05:13 +0800
Subject: Don't attempt to version `run-make-support`

Purely internal test support library.
---
 Cargo.lock                            | 2 +-
 src/tools/run-make-support/Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6d823c5b5a5..271a2f7962c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3214,7 +3214,7 @@ dependencies = [
 
 [[package]]
 name = "run_make_support"
-version = "0.2.0"
+version = "0.0.0"
 dependencies = [
  "bstr",
  "build_helper",
diff --git a/src/tools/run-make-support/Cargo.toml b/src/tools/run-make-support/Cargo.toml
index 3226f467ba4..95aedf7d080 100644
--- a/src/tools/run-make-support/Cargo.toml
+++ b/src/tools/run-make-support/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "run_make_support"
-version = "0.2.0"
+version = "0.0.0"
 edition = "2021"
 
 [dependencies]
-- 
cgit 1.4.1-3-g733a5


From e70493d06c1e4fbc56380efc8d179bd845b20061 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Wed, 9 Jul 2025 20:07:09 +0800
Subject: Bump `run-make-support` to Edition 2024

---
 src/tools/run-make-support/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/run-make-support/Cargo.toml b/src/tools/run-make-support/Cargo.toml
index 95aedf7d080..d01224eb56d 100644
--- a/src/tools/run-make-support/Cargo.toml
+++ b/src/tools/run-make-support/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "run_make_support"
 version = "0.0.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 bstr = "1.12"
-- 
cgit 1.4.1-3-g733a5


From fae15466aadd77e0369a893c7b962f7afbb86ff2 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Wed, 9 Jul 2025 20:10:32 +0800
Subject: Sort and document `run-make-support` dependencies

---
 src/tools/run-make-support/Cargo.toml | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/src/tools/run-make-support/Cargo.toml b/src/tools/run-make-support/Cargo.toml
index d01224eb56d..a4e7534137d 100644
--- a/src/tools/run-make-support/Cargo.toml
+++ b/src/tools/run-make-support/Cargo.toml
@@ -4,15 +4,24 @@ version = "0.0.0"
 edition = "2024"
 
 [dependencies]
+
+# These dependencies are either used to implement part of support library
+# functionality, or re-exported to test recipe programs via the support library,
+# or both.
+
+# tidy-alphabetical-start
 bstr = "1.12"
+gimli = "0.32"
+libc = "0.2"
 object = "0.37"
+regex = "1.11"
+serde_json = "1.0"
 similar = "2.7"
 wasmparser = { version = "0.219", default-features = false, features = ["std"] }
-regex = "1.11"
-gimli = "0.32"
+# tidy-alphabetical-end
+
+# Shared with bootstrap and compiletest
 build_helper = { path = "../../build_helper" }
-serde_json = "1.0"
-libc = "0.2"
 
 [lib]
 crate-type = ["lib", "dylib"]
-- 
cgit 1.4.1-3-g733a5


From 200f132367f2aada7aff45689e53448a69cd7ce3 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Wed, 9 Jul 2025 20:22:58 +0800
Subject: Massage `lib.rs` so it can be rustfmt'd

Even if the formatting isn't strictly "better", it at least allows
rustfmtting it automatically.
---
 src/tools/run-make-support/src/lib.rs | 108 +++++++++++++---------------------
 1 file changed, 42 insertions(+), 66 deletions(-)

diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
index 67d8c351a59..69054396229 100644
--- a/src/tools/run-make-support/src/lib.rs
+++ b/src/tools/run-make-support/src/lib.rs
@@ -3,9 +3,6 @@
 //! notably is built via cargo: this means that if your test wants some non-trivial utility, such
 //! as `object` or `wasmparser`, they can be re-exported and be made available through this library.
 
-// We want to control use declaration ordering and spacing (and preserve use group comments), so
-// skip rustfmt on this file.
-#![cfg_attr(rustfmt, rustfmt::skip)]
 #![warn(unreachable_pub)]
 
 mod command;
@@ -22,8 +19,8 @@ pub mod path_helpers;
 pub mod run;
 pub mod scoped_run;
 pub mod string;
-pub mod targets;
 pub mod symbols;
+pub mod targets;
 
 // Internally we call our fs-related support module as `fs`, but re-export its content as `rfs`
 // to tests to avoid colliding with commonly used `use std::fs;`.
@@ -36,77 +33,56 @@ pub mod rfs {
 }
 
 // Re-exports of third-party library crates.
-// tidy-alphabetical-start
-pub use bstr;
-pub use gimli;
-pub use libc;
-pub use object;
-pub use regex;
-pub use serde_json;
-pub use similar;
-pub use wasmparser;
-// tidy-alphabetical-end
+pub use {bstr, gimli, libc, object, regex, serde_json, similar, wasmparser};
 
-// Re-exports of external dependencies.
-pub use external_deps::{
-    cargo, c_build, c_cxx_compiler, clang, htmldocck, llvm, python, rustc, rustdoc
+// Helpers for building names of output artifacts that are potentially target-specific.
+pub use crate::artifact_names::{
+    bin_name, dynamic_lib_extension, dynamic_lib_name, msvc_import_dynamic_lib_name, rust_lib_name,
+    static_lib_name,
 };
-
-// These rely on external dependencies.
-pub use c_cxx_compiler::{Cc, Gcc, cc, cxx, extra_c_flags, extra_cxx_flags, gcc};
-pub use c_build::{
+pub use crate::assertion_helpers::{
+    assert_contains, assert_contains_regex, assert_count_is, assert_dirs_are_equal, assert_equals,
+    assert_not_contains, assert_not_contains_regex,
+};
+// `diff` is implemented in terms of the [similar] library.
+//
+// [similar]: https://github.com/mitsuhiko/similar
+pub use crate::diff::{Diff, diff};
+// Panic-on-fail [`std::env::var`] and [`std::env::var_os`] wrappers.
+pub use crate::env::{env_var, env_var_os, set_current_dir};
+pub use crate::external_deps::c_build::{
     build_native_dynamic_lib, build_native_static_lib, build_native_static_lib_cxx,
     build_native_static_lib_optimized,
 };
-pub use cargo::cargo;
-pub use clang::{clang, Clang};
-pub use htmldocck::htmldocck;
-pub use llvm::{
-    llvm_ar, llvm_bcanalyzer, llvm_dis, llvm_dwarfdump, llvm_filecheck, llvm_nm, llvm_objcopy,
-    llvm_objdump, llvm_profdata, llvm_readobj, LlvmAr, LlvmBcanalyzer, LlvmDis, LlvmDwarfdump,
-    LlvmFilecheck, LlvmNm, LlvmObjcopy, LlvmObjdump, LlvmProfdata, LlvmReadobj,
-};
-pub use python::python_command;
-pub use rustc::{bare_rustc, rustc, rustc_path, Rustc};
-pub use rustdoc::{bare_rustdoc, rustdoc, Rustdoc};
-
-/// [`diff`][mod@diff] is implemented in terms of the [similar] library.
-///
-/// [similar]: https://github.com/mitsuhiko/similar
-pub use diff::{diff, Diff};
-
-/// Panic-on-fail [`std::env::var`] and [`std::env::var_os`] wrappers.
-pub use env::{env_var, env_var_os, set_current_dir};
-
-/// Convenience helpers for running binaries and other commands.
-pub use run::{cmd, run, run_fail, run_with_args};
-
-/// Helpers for checking target information.
-pub use targets::{
-    apple_os, is_aix, is_darwin, is_msvc, is_windows, is_windows_gnu, is_windows_msvc, is_win7, llvm_components_contain,
-    target, uname,
+// Re-exports of external dependencies.
+pub use crate::external_deps::c_cxx_compiler::{
+    Cc, Gcc, cc, cxx, extra_c_flags, extra_cxx_flags, gcc,
 };
-
-/// Helpers for building names of output artifacts that are potentially target-specific.
-pub use artifact_names::{
-    bin_name, dynamic_lib_extension, dynamic_lib_name, msvc_import_dynamic_lib_name, rust_lib_name,
-    static_lib_name,
+pub use crate::external_deps::cargo::cargo;
+pub use crate::external_deps::clang::{Clang, clang};
+pub use crate::external_deps::htmldocck::htmldocck;
+pub use crate::external_deps::llvm::{
+    self, LlvmAr, LlvmBcanalyzer, LlvmDis, LlvmDwarfdump, LlvmFilecheck, LlvmNm, LlvmObjcopy,
+    LlvmObjdump, LlvmProfdata, LlvmReadobj, llvm_ar, llvm_bcanalyzer, llvm_dis, llvm_dwarfdump,
+    llvm_filecheck, llvm_nm, llvm_objcopy, llvm_objdump, llvm_profdata, llvm_readobj,
 };
-
-/// Path-related helpers.
-pub use path_helpers::{
+pub use crate::external_deps::python::python_command;
+pub use crate::external_deps::rustc::{self, Rustc, bare_rustc, rustc, rustc_path};
+pub use crate::external_deps::rustdoc::{Rustdoc, bare_rustdoc, rustdoc};
+// Path-related helpers.
+pub use crate::path_helpers::{
     build_root, cwd, filename_contains, filename_not_in_denylist, has_extension, has_prefix,
     has_suffix, not_contains, path, shallow_find_directories, shallow_find_files, source_root,
 };
-
-/// Helpers for scoped test execution where certain properties are attempted to be maintained.
-pub use scoped_run::{run_in_tmpdir, test_while_readonly};
-
-pub use assertion_helpers::{
-    assert_contains, assert_contains_regex, assert_count_is, assert_dirs_are_equal, assert_equals,
-    assert_not_contains, assert_not_contains_regex,
-};
-
-pub use string::{
+// Convenience helpers for running binaries and other commands.
+pub use crate::run::{cmd, run, run_fail, run_with_args};
+// Helpers for scoped test execution where certain properties are attempted to be maintained.
+pub use crate::scoped_run::{run_in_tmpdir, test_while_readonly};
+pub use crate::string::{
     count_regex_matches_in_files_with_extension, invalid_utf8_contains, invalid_utf8_not_contains,
 };
+// Helpers for checking target information.
+pub use crate::targets::{
+    apple_os, is_aix, is_darwin, is_msvc, is_win7, is_windows, is_windows_gnu, is_windows_msvc,
+    llvm_components_contain, target, uname,
+};
-- 
cgit 1.4.1-3-g733a5


From 7fc21278ec9720f71b491aa70c25e75f9150db5b Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 9 Jul 2025 14:10:35 +0200
Subject: bootstrap/miri: avoid rebuilds for test builds

---
 src/bootstrap/src/core/build_steps/tool.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 5de1b472d79..b7c1d123b4a 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -1140,6 +1140,7 @@ macro_rules! tool_extended {
             stable: $stable:expr
             $( , add_bins_to_sysroot: $add_bins_to_sysroot:expr )?
             $( , add_features: $add_features:expr )?
+            $( , cargo_args: $cargo_args:expr )?
             $( , )?
         }
     ) => {
@@ -1180,6 +1181,7 @@ macro_rules! tool_extended {
                     $path,
                     None $( .or(Some(&$add_bins_to_sysroot)) )?,
                     None $( .or(Some($add_features)) )?,
+                    None $( .or(Some($cargo_args)) )?,
                 )
             }
 
@@ -1219,6 +1221,7 @@ fn should_run_tool_build_step<'a>(
     )
 }
 
+#[expect(clippy::too_many_arguments)] // silence overeager clippy lint
 fn run_tool_build_step(
     builder: &Builder<'_>,
     compiler: Compiler,
@@ -1227,6 +1230,7 @@ fn run_tool_build_step(
     path: &'static str,
     add_bins_to_sysroot: Option<&[&str]>,
     add_features: Option<fn(&Builder<'_>, TargetSelection, &mut Vec<String>)>,
+    cargo_args: Option<&[&'static str]>,
 ) -> ToolBuildResult {
     let mut extra_features = Vec::new();
     if let Some(func) = add_features {
@@ -1243,7 +1247,7 @@ fn run_tool_build_step(
             extra_features,
             source_type: SourceType::InTree,
             allow_features: "",
-            cargo_args: vec![],
+            cargo_args: cargo_args.unwrap_or_default().iter().map(|s| String::from(*s)).collect(),
             artifact_kind: ToolArtifactKind::Binary,
         });
 
@@ -1294,7 +1298,9 @@ tool_extended!(Miri {
     path: "src/tools/miri",
     tool_name: "miri",
     stable: false,
-    add_bins_to_sysroot: ["miri"]
+    add_bins_to_sysroot: ["miri"],
+    // Avoid costly rebuilds by always including the tests.
+    cargo_args: &["--all-targets"],
 });
 tool_extended!(CargoMiri {
     path: "src/tools/miri/cargo-miri",
-- 
cgit 1.4.1-3-g733a5


From 7b39139d22d0d13ff6d31314537bd0acbf2cf563 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 9 Jul 2025 17:21:45 +0300
Subject: Don't hash the `SyntaxKind` in the ast id

There is no need to, it's already stored in the `kind`.
---
 .../crates/hir-def/src/item_tree/tests.rs          | 42 +++++++++++-----------
 .../hir-def/src/macro_expansion_tests/mbe.rs       | 22 ++++++------
 .../src/macro_expansion_tests/proc_macros.rs       |  6 ++--
 src/tools/rust-analyzer/crates/span/src/ast_id.rs  |  7 +---
 4 files changed, 36 insertions(+), 41 deletions(-)

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 5923b3ea491..91b42bef8f7 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
@@ -35,10 +35,10 @@ use a::{c, d::{e}};
             #![no_std]
             #![doc = " another file comment"]
 
-            // AstId: ExternCrate[5A82, 0]
+            // AstId: ExternCrate[070B, 0]
             pub(self) extern crate self as renamed;
 
-            // AstId: ExternCrate[7E1C, 0]
+            // AstId: ExternCrate[1EA5, 0]
             pub(in super) extern crate bli;
 
             // AstId: Use[0000, 0]
@@ -78,15 +78,15 @@ extern "C" {
             // AstId: ExternBlock[0000, 0]
             extern {
                 #[on_extern_type]
-                // AstId: TypeAlias[9FDF, 0]
+                // AstId: TypeAlias[A09C, 0]
                 pub(self) type ExType;
 
                 #[on_extern_static]
-                // AstId: Static[43C1, 0]
+                // AstId: Static[D85E, 0]
                 pub(self) static EX_STATIC = _;
 
                 #[on_extern_fn]
-                // AstId: Fn[452D, 0]
+                // AstId: Fn[B240, 0]
                 pub(self) fn ex_fn;
             }
         "#]],
@@ -124,20 +124,20 @@ enum E {
 }
         "#,
         expect![[r#"
-            // AstId: Struct[DFF3, 0]
+            // AstId: Struct[ED35, 0]
             pub(self) struct Unit;
 
             #[derive(Debug)]
-            // AstId: Struct[C7A1, 0]
+            // AstId: Struct[A47C, 0]
             pub(self) struct Struct { ... }
 
-            // AstId: Struct[DAC2, 0]
+            // AstId: Struct[C8C9, 0]
             pub(self) struct Tuple(...);
 
-            // AstId: Union[2DBB, 0]
+            // AstId: Union[2797, 0]
             pub(self) union Ize { ... }
 
-            // AstId: Enum[7FF8, 0]
+            // AstId: Enum[7D23, 0]
             pub(self) enum E { ... }
         "#]],
     );
@@ -162,18 +162,18 @@ trait Tr: SuperTrait + 'lifetime {
 }
         "#,
         expect![[r#"
-            // AstId: Static[B393, 0]
+            // AstId: Static[F7C1, 0]
             pub static ST = _;
 
-            // AstId: Const[B309, 0]
+            // AstId: Const[84BB, 0]
             pub(self) const _ = _;
 
             #[attr]
             #[inner_attr_in_fn]
-            // AstId: Fn[75E3, 0]
+            // AstId: Fn[BE8F, 0]
             pub(self) fn f;
 
-            // AstId: Trait[2998, 0]
+            // AstId: Trait[9320, 0]
             pub(self) trait Tr { ... }
         "#]],
     );
@@ -197,16 +197,16 @@ mod outline;
         expect![[r##"
             #[doc = " outer"]
             #[doc = " inner"]
-            // AstId: Module[CF93, 0]
+            // AstId: Module[03AE, 0]
             pub(self) mod inline {
                 // AstId: Use[0000, 0]
                 pub(self) use super::*;
 
-                // AstId: Fn[1B26, 0]
+                // AstId: Fn[2A78, 0]
                 pub(self) fn fn_in_module;
             }
 
-            // AstId: Module[8994, 0]
+            // AstId: Module[C08B, 0]
             pub(self) mod outline;
         "##]],
     );
@@ -225,13 +225,13 @@ pub macro m2() {}
 m!();
         "#,
         expect![[r#"
-            // AstId: MacroRules[88CE, 0]
+            // AstId: MacroRules[7E68, 0]
             macro_rules! m { ... }
 
-            // AstId: MacroDef[DC34, 0]
+            // AstId: MacroDef[1C1E, 0]
             pub macro m2 { ... }
 
-            // AstId: MacroCall[612F, 0], SyntaxContextId: ROOT2024, ExpandTo: Items
+            // AstId: MacroCall[7E68, 0], SyntaxContextId: ROOT2024, ExpandTo: Items
             m!(...);
         "#]],
     );
@@ -244,7 +244,7 @@ fn pub_self() {
 pub(self) struct S;
         "#,
         expect![[r#"
-            // AstId: Struct[42E2, 0]
+            // AstId: Struct[5024, 0]
             pub(self) struct S;
         "#]],
     )
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 c6d901ec93b..c489c1f7c1d 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 @@ macro_rules! f {
     };
 }
 
-struct#0:MacroRules[8C8E, 0]@58..64#14336# MyTraitMap2#0:MacroCall[D499, 0]@31..42#ROOT2024# {#0:MacroRules[8C8E, 0]@72..73#14336#
-    map#0:MacroRules[8C8E, 0]@86..89#14336#:#0:MacroRules[8C8E, 0]@89..90#14336# #0:MacroRules[8C8E, 0]@89..90#14336#::#0:MacroRules[8C8E, 0]@91..93#14336#std#0:MacroRules[8C8E, 0]@93..96#14336#::#0:MacroRules[8C8E, 0]@96..98#14336#collections#0:MacroRules[8C8E, 0]@98..109#14336#::#0:MacroRules[8C8E, 0]@109..111#14336#HashSet#0:MacroRules[8C8E, 0]@111..118#14336#<#0:MacroRules[8C8E, 0]@118..119#14336#(#0:MacroRules[8C8E, 0]@119..120#14336#)#0:MacroRules[8C8E, 0]@120..121#14336#>#0:MacroRules[8C8E, 0]@121..122#14336#,#0:MacroRules[8C8E, 0]@122..123#14336#
-}#0:MacroRules[8C8E, 0]@132..133#14336#
+struct#0:MacroRules[BE8F, 0]@58..64#14336# MyTraitMap2#0:MacroCall[BE8F, 0]@31..42#ROOT2024# {#0:MacroRules[BE8F, 0]@72..73#14336#
+    map#0:MacroRules[BE8F, 0]@86..89#14336#:#0:MacroRules[BE8F, 0]@89..90#14336# #0:MacroRules[BE8F, 0]@89..90#14336#::#0:MacroRules[BE8F, 0]@91..93#14336#std#0:MacroRules[BE8F, 0]@93..96#14336#::#0:MacroRules[BE8F, 0]@96..98#14336#collections#0:MacroRules[BE8F, 0]@98..109#14336#::#0:MacroRules[BE8F, 0]@109..111#14336#HashSet#0:MacroRules[BE8F, 0]@111..118#14336#<#0:MacroRules[BE8F, 0]@118..119#14336#(#0:MacroRules[BE8F, 0]@119..120#14336#)#0:MacroRules[BE8F, 0]@120..121#14336#>#0:MacroRules[BE8F, 0]@121..122#14336#,#0:MacroRules[BE8F, 0]@122..123#14336#
+}#0:MacroRules[BE8F, 0]@132..133#14336#
 "#]],
     );
 }
@@ -75,12 +75,12 @@ macro_rules! f {
     };
 }
 
-fn#0:MacroCall[D499, 0]@30..32#ROOT2024# main#0:MacroCall[D499, 0]@33..37#ROOT2024#(#0:MacroCall[D499, 0]@37..38#ROOT2024#)#0:MacroCall[D499, 0]@38..39#ROOT2024# {#0:MacroCall[D499, 0]@40..41#ROOT2024#
-    1#0:MacroCall[D499, 0]@50..51#ROOT2024#;#0:MacroCall[D499, 0]@51..52#ROOT2024#
-    1.0#0:MacroCall[D499, 0]@61..64#ROOT2024#;#0:MacroCall[D499, 0]@64..65#ROOT2024#
-    (#0:MacroCall[D499, 0]@74..75#ROOT2024#(#0:MacroCall[D499, 0]@75..76#ROOT2024#1#0:MacroCall[D499, 0]@76..77#ROOT2024#,#0:MacroCall[D499, 0]@77..78#ROOT2024# )#0:MacroCall[D499, 0]@78..79#ROOT2024#,#0:MacroCall[D499, 0]@79..80#ROOT2024# )#0:MacroCall[D499, 0]@80..81#ROOT2024#.#0:MacroCall[D499, 0]@81..82#ROOT2024#0#0:MacroCall[D499, 0]@82..85#ROOT2024#.#0:MacroCall[D499, 0]@82..85#ROOT2024#0#0:MacroCall[D499, 0]@82..85#ROOT2024#;#0:MacroCall[D499, 0]@85..86#ROOT2024#
-    let#0:MacroCall[D499, 0]@95..98#ROOT2024# x#0:MacroCall[D499, 0]@99..100#ROOT2024# =#0:MacroCall[D499, 0]@101..102#ROOT2024# 1#0:MacroCall[D499, 0]@103..104#ROOT2024#;#0:MacroCall[D499, 0]@104..105#ROOT2024#
-}#0:MacroCall[D499, 0]@110..111#ROOT2024#
+fn#0:MacroCall[BE8F, 0]@30..32#ROOT2024# main#0:MacroCall[BE8F, 0]@33..37#ROOT2024#(#0:MacroCall[BE8F, 0]@37..38#ROOT2024#)#0:MacroCall[BE8F, 0]@38..39#ROOT2024# {#0:MacroCall[BE8F, 0]@40..41#ROOT2024#
+    1#0:MacroCall[BE8F, 0]@50..51#ROOT2024#;#0:MacroCall[BE8F, 0]@51..52#ROOT2024#
+    1.0#0:MacroCall[BE8F, 0]@61..64#ROOT2024#;#0:MacroCall[BE8F, 0]@64..65#ROOT2024#
+    (#0:MacroCall[BE8F, 0]@74..75#ROOT2024#(#0:MacroCall[BE8F, 0]@75..76#ROOT2024#1#0:MacroCall[BE8F, 0]@76..77#ROOT2024#,#0:MacroCall[BE8F, 0]@77..78#ROOT2024# )#0:MacroCall[BE8F, 0]@78..79#ROOT2024#,#0:MacroCall[BE8F, 0]@79..80#ROOT2024# )#0:MacroCall[BE8F, 0]@80..81#ROOT2024#.#0:MacroCall[BE8F, 0]@81..82#ROOT2024#0#0:MacroCall[BE8F, 0]@82..85#ROOT2024#.#0:MacroCall[BE8F, 0]@82..85#ROOT2024#0#0:MacroCall[BE8F, 0]@82..85#ROOT2024#;#0:MacroCall[BE8F, 0]@85..86#ROOT2024#
+    let#0:MacroCall[BE8F, 0]@95..98#ROOT2024# x#0:MacroCall[BE8F, 0]@99..100#ROOT2024# =#0:MacroCall[BE8F, 0]@101..102#ROOT2024# 1#0:MacroCall[BE8F, 0]@103..104#ROOT2024#;#0:MacroCall[BE8F, 0]@104..105#ROOT2024#
+}#0:MacroCall[BE8F, 0]@110..111#ROOT2024#
 
 
 "#]],
@@ -171,7 +171,7 @@ fn main(foo: ()) {
     }
 
     fn main(foo: ()) {
-        /* error: unresolved macro unresolved */"helloworld!"#0:Fn[B9C7, 0]@236..321#ROOT2024#;
+        /* error: unresolved macro unresolved */"helloworld!"#0:Fn[15AE, 0]@236..321#ROOT2024#;
     }
 }
 
@@ -197,7 +197,7 @@ macro_rules! mk_struct {
 #[macro_use]
 mod foo;
 
-struct#1:MacroRules[E572, 0]@59..65#14336# Foo#0:MacroCall[BDD3, 0]@32..35#ROOT2024#(#1:MacroRules[E572, 0]@70..71#14336#u32#0:MacroCall[BDD3, 0]@41..44#ROOT2024#)#1:MacroRules[E572, 0]@74..75#14336#;#1:MacroRules[E572, 0]@75..76#14336#
+struct#1:MacroRules[DB0C, 0]@59..65#14336# Foo#0:MacroCall[DB0C, 0]@32..35#ROOT2024#(#1:MacroRules[DB0C, 0]@70..71#14336#u32#0:MacroCall[DB0C, 0]@41..44#ROOT2024#)#1:MacroRules[DB0C, 0]@74..75#14336#;#1:MacroRules[DB0C, 0]@75..76#14336#
 "#]],
     );
 }
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/proc_macros.rs b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/proc_macros.rs
index d5ae6f8d885..6952a9da101 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/proc_macros.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/macro_expansion_tests/proc_macros.rs
@@ -181,9 +181,9 @@ fn foo(&self) {
     self.0. 1;
 }
 
-fn#0:Fn[4D85, 0]@45..47#ROOT2024# foo#0:Fn[4D85, 0]@48..51#ROOT2024#(#0:Fn[4D85, 0]@51..52#ROOT2024#&#0:Fn[4D85, 0]@52..53#ROOT2024#self#0:Fn[4D85, 0]@53..57#ROOT2024# )#0:Fn[4D85, 0]@57..58#ROOT2024# {#0:Fn[4D85, 0]@59..60#ROOT2024#
-    self#0:Fn[4D85, 0]@65..69#ROOT2024# .#0:Fn[4D85, 0]@69..70#ROOT2024#0#0:Fn[4D85, 0]@70..71#ROOT2024#.#0:Fn[4D85, 0]@71..72#ROOT2024#1#0:Fn[4D85, 0]@73..74#ROOT2024#;#0:Fn[4D85, 0]@74..75#ROOT2024#
-}#0:Fn[4D85, 0]@76..77#ROOT2024#"#]],
+fn#0:Fn[8A31, 0]@45..47#ROOT2024# foo#0:Fn[8A31, 0]@48..51#ROOT2024#(#0:Fn[8A31, 0]@51..52#ROOT2024#&#0:Fn[8A31, 0]@52..53#ROOT2024#self#0:Fn[8A31, 0]@53..57#ROOT2024# )#0:Fn[8A31, 0]@57..58#ROOT2024# {#0:Fn[8A31, 0]@59..60#ROOT2024#
+    self#0:Fn[8A31, 0]@65..69#ROOT2024# .#0:Fn[8A31, 0]@69..70#ROOT2024#0#0:Fn[8A31, 0]@70..71#ROOT2024#.#0:Fn[8A31, 0]@71..72#ROOT2024#1#0:Fn[8A31, 0]@73..74#ROOT2024#;#0:Fn[8A31, 0]@74..75#ROOT2024#
+}#0:Fn[8A31, 0]@76..77#ROOT2024#"#]],
     );
 }
 
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 121d2e33243..c8b7efaf6d4 100644
--- a/src/tools/rust-analyzer/crates/span/src/ast_id.rs
+++ b/src/tools/rust-analyzer/crates/span/src/ast_id.rs
@@ -30,7 +30,7 @@ use std::{
 use la_arena::{Arena, Idx, RawIdx};
 use rustc_hash::{FxBuildHasher, FxHashMap};
 use syntax::{
-    AstNode, AstPtr, SyntaxKind, SyntaxNode, SyntaxNodePtr,
+    AstNode, AstPtr, SyntaxNode, SyntaxNodePtr,
     ast::{self, HasName},
     match_ast,
 };
@@ -278,7 +278,6 @@ impl<N> FileAstId<N> {
 
 #[derive(Hash)]
 struct ErasedHasNameFileAstId<'a> {
-    kind: SyntaxKind,
     name: &'a str,
 }
 
@@ -433,7 +432,6 @@ macro_rules! register_has_name_ast_id {
         )+
 
         fn has_name_ast_id(node: &SyntaxNode, index_map: &mut ErasedAstIdNextIndexMap) -> Option<ErasedFileAstId> {
-            let kind = node.kind();
             match_ast! {
                 match node {
                     $(
@@ -441,7 +439,6 @@ macro_rules! register_has_name_ast_id {
                             let name = node.$name_method();
                             let name = name.as_ref().map_or("", |it| it.text_non_mutable());
                             let result = ErasedHasNameFileAstId {
-                                kind,
                                 name,
                             };
                             Some(index_map.new_id(ErasedFileAstIdKind::$ident, result))
@@ -483,7 +480,6 @@ macro_rules! register_assoc_item_ast_id {
             index_map: &mut ErasedAstIdNextIndexMap,
             parent: Option<&ErasedFileAstId>,
         ) -> Option<ErasedFileAstId> {
-            let kind = node.kind();
             match_ast! {
                 match node {
                     $(
@@ -491,7 +487,6 @@ macro_rules! register_assoc_item_ast_id {
                             let name = $name_callback(node);
                             let name = name.as_ref().map_or("", |it| it.text_non_mutable());
                             let properties = ErasedHasNameFileAstId {
-                                kind,
                                 name,
                             };
                             let result = ErasedAssocItemFileAstId {
-- 
cgit 1.4.1-3-g733a5


From ebdd8598d4b08bc11436c5f3d4b1e338d5131a1c Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 9 Jul 2025 17:37:27 +0300
Subject: Differentiate between `asm!()`, `global_asm!()` and `naked_asm!()`,
 and make only `asm!()` unsafe

---
 .../crates/hir-def/src/expr_store/lower/asm.rs     | 13 +++++-
 src/tools/rust-analyzer/crates/hir-def/src/hir.rs  | 11 +++++
 .../src/macro_expansion_tests/builtin_fn_macro.rs  | 28 +++++++++++++
 .../crates/hir-expand/src/builtin/fn_macro.rs      | 34 ++++++++++++++-
 .../crates/hir-ty/src/diagnostics/unsafe_check.rs  |  9 +++-
 src/tools/rust-analyzer/crates/hir/src/lib.rs      |  3 +-
 .../rust-analyzer/crates/hir/src/semantics.rs      |  2 +-
 .../ide-diagnostics/src/handlers/missing_unsafe.rs | 15 +++++++
 .../crates/parser/src/grammar/expressions/atom.rs  | 18 +++++---
 .../crates/parser/src/syntax_kind/generated.rs     | 12 +++++-
 .../crates/parser/test_data/generated/runner.rs    |  2 +
 .../test_data/parser/inline/ok/asm_kinds.rast      | 49 ++++++++++++++++++++++
 .../parser/test_data/parser/inline/ok/asm_kinds.rs |  5 +++
 src/tools/rust-analyzer/crates/syntax/rust.ungram  |  3 +-
 .../crates/syntax/src/ast/generated/nodes.rs       |  8 ++++
 .../xtask/src/codegen/grammar/ast_src.rs           |  2 +
 16 files changed, 198 insertions(+), 16 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.rast
 create mode 100644 src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.rs

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/asm.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/asm.rs
index d36e5205c73..f1cb28d234b 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/asm.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/asm.rs
@@ -10,7 +10,7 @@ use tt::TextRange;
 
 use crate::{
     expr_store::lower::{ExprCollector, FxIndexSet},
-    hir::{AsmOperand, AsmOptions, Expr, ExprId, InlineAsm, InlineAsmRegOrRegClass},
+    hir::{AsmOperand, AsmOptions, Expr, ExprId, InlineAsm, InlineAsmKind, InlineAsmRegOrRegClass},
 };
 
 impl ExprCollector<'_> {
@@ -269,8 +269,17 @@ impl ExprCollector<'_> {
                     }
                 })
         };
+
+        let kind = if asm.global_asm_token().is_some() {
+            InlineAsmKind::GlobalAsm
+        } else if asm.naked_asm_token().is_some() {
+            InlineAsmKind::NakedAsm
+        } else {
+            InlineAsmKind::Asm
+        };
+
         let idx = self.alloc_expr(
-            Expr::InlineAsm(InlineAsm { operands: operands.into_boxed_slice(), options }),
+            Expr::InlineAsm(InlineAsm { operands: operands.into_boxed_slice(), options, kind }),
             syntax_ptr,
         );
         self.source_map
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/hir.rs b/src/tools/rust-analyzer/crates/hir-def/src/hir.rs
index 0fc7857d978..e70cd2cd6c5 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/hir.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/hir.rs
@@ -332,6 +332,17 @@ pub struct OffsetOf {
 pub struct InlineAsm {
     pub operands: Box<[(Option<Name>, AsmOperand)]>,
     pub options: AsmOptions,
+    pub kind: InlineAsmKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum InlineAsmKind {
+    /// `asm!()`.
+    Asm,
+    /// `global_asm!()`.
+    GlobalAsm,
+    /// `naked_asm!()`.
+    NakedAsm,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
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 293868df613..a48a6be4d84 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
@@ -28,6 +28,20 @@ fn test_asm_expand() {
         r#"
 #[rustc_builtin_macro]
 macro_rules! asm {() => {}}
+#[rustc_builtin_macro]
+macro_rules! global_asm {() => {}}
+#[rustc_builtin_macro]
+macro_rules! naked_asm {() => {}}
+
+// FIXME: This creates an error
+// global_asm! {
+//     ""
+// }
+
+#[unsafe(naked)]
+extern "C" fn foo() {
+    naked_asm!("");
+}
 
 fn main() {
     let i: u64 = 3;
@@ -45,6 +59,20 @@ fn main() {
         expect![[r##"
 #[rustc_builtin_macro]
 macro_rules! asm {() => {}}
+#[rustc_builtin_macro]
+macro_rules! global_asm {() => {}}
+#[rustc_builtin_macro]
+macro_rules! naked_asm {() => {}}
+
+// FIXME: This creates an error
+// global_asm! {
+//     ""
+// }
+
+#[unsafe(naked)]
+extern "C" fn foo() {
+    builtin #naked_asm ("");
+}
 
 fn main() {
     let i: u64 = 3;
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 800b40a9e7e..60fbc660652 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
@@ -125,8 +125,8 @@ register_builtin! {
     (assert, Assert) => assert_expand,
     (stringify, Stringify) => stringify_expand,
     (asm, Asm) => asm_expand,
-    (global_asm, GlobalAsm) => asm_expand,
-    (naked_asm, NakedAsm) => asm_expand,
+    (global_asm, GlobalAsm) => global_asm_expand,
+    (naked_asm, NakedAsm) => naked_asm_expand,
     (cfg, Cfg) => cfg_expand,
     (core_panic, CorePanic) => panic_expand,
     (std_panic, StdPanic) => panic_expand,
@@ -325,6 +325,36 @@ fn asm_expand(
     ExpandResult::ok(expanded)
 }
 
+fn global_asm_expand(
+    _db: &dyn ExpandDatabase,
+    _id: MacroCallId,
+    tt: &tt::TopSubtree,
+    span: Span,
+) -> ExpandResult<tt::TopSubtree> {
+    let mut tt = tt.clone();
+    tt.top_subtree_delimiter_mut().kind = tt::DelimiterKind::Parenthesis;
+    let pound = mk_pound(span);
+    let expanded = quote! {span =>
+        builtin #pound global_asm #tt
+    };
+    ExpandResult::ok(expanded)
+}
+
+fn naked_asm_expand(
+    _db: &dyn ExpandDatabase,
+    _id: MacroCallId,
+    tt: &tt::TopSubtree,
+    span: Span,
+) -> ExpandResult<tt::TopSubtree> {
+    let mut tt = tt.clone();
+    tt.top_subtree_delimiter_mut().kind = tt::DelimiterKind::Parenthesis;
+    let pound = mk_pound(span);
+    let expanded = quote! {span =>
+        builtin #pound naked_asm #tt
+    };
+    ExpandResult::ok(expanded)
+}
+
 fn cfg_expand(
     db: &dyn ExpandDatabase,
     id: MacroCallId,
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 20cf3c78115..84ab8436a68 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
@@ -7,7 +7,7 @@ use either::Either;
 use hir_def::{
     AdtId, DefWithBodyId, FieldId, FunctionId, VariantId,
     expr_store::{Body, path::Path},
-    hir::{AsmOperand, Expr, ExprId, ExprOrPatId, Pat, PatId, Statement, UnaryOp},
+    hir::{AsmOperand, Expr, ExprId, ExprOrPatId, InlineAsmKind, Pat, PatId, Statement, UnaryOp},
     resolver::{HasResolver, ResolveValueResult, Resolver, ValueNs},
     signatures::StaticFlags,
     type_ref::Rawness,
@@ -315,7 +315,12 @@ impl<'db> UnsafeVisitor<'db> {
                 self.inside_assignment = old_inside_assignment;
             }
             Expr::InlineAsm(asm) => {
-                self.on_unsafe_op(current.into(), UnsafetyReason::InlineAsm);
+                if asm.kind == InlineAsmKind::Asm {
+                    // `naked_asm!()` requires `unsafe` on the attribute (`#[unsafe(naked)]`),
+                    // and `global_asm!()` doesn't require it at all.
+                    self.on_unsafe_op(current.into(), UnsafetyReason::InlineAsm);
+                }
+
                 asm.operands.iter().for_each(|(_, op)| match op {
                     AsmOperand::In { expr, .. }
                     | AsmOperand::Out { expr: Some(expr), .. }
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index e8a18169712..55f0268db40 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -3220,7 +3220,8 @@ impl Macro {
         }
     }
 
-    pub fn is_asm_or_global_asm(&self, db: &dyn HirDatabase) -> bool {
+    /// Is this `asm!()`, or a variant of it (e.g. `global_asm!()`)?
+    pub fn is_asm_like(&self, db: &dyn HirDatabase) -> bool {
         match self.id {
             MacroId::Macro2Id(it) => {
                 matches!(it.lookup(db).expander, MacroExpander::BuiltIn(m) if m.is_asm())
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index 247bb693983..11dba1f379f 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -1776,7 +1776,7 @@ impl<'db> SemanticsImpl<'db> {
 
     pub fn is_unsafe_macro_call(&self, macro_call: &ast::MacroCall) -> bool {
         let Some(mac) = self.resolve_macro_call(macro_call) else { return false };
-        if mac.is_asm_or_global_asm(self.db) {
+        if mac.is_asm_like(self.db) {
             return true;
         }
 
diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs
index d8f6e813d80..17caf630182 100644
--- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs
+++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/handlers/missing_unsafe.rs
@@ -983,4 +983,19 @@ fn test() {
             "#,
         );
     }
+
+    #[test]
+    fn naked_asm_is_safe() {
+        check_diagnostics(
+            r#"
+#[rustc_builtin_macro]
+macro_rules! naked_asm { () => {} }
+
+#[unsafe(naked)]
+extern "C" fn naked() {
+    naked_asm!("");
+}
+        "#,
+        );
+    }
 }
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 8ed0fc6729f..b81a0261733 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
@@ -253,8 +253,7 @@ fn builtin_expr(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     let m = p.start();
     p.bump_remap(T![builtin]);
     p.bump(T![#]);
-    if p.at_contextual_kw(T![offset_of]) {
-        p.bump_remap(T![offset_of]);
+    if p.eat_contextual_kw(T![offset_of]) {
         p.expect(T!['(']);
         type_(p);
         p.expect(T![,]);
@@ -278,8 +277,7 @@ fn builtin_expr(p: &mut Parser<'_>) -> Option<CompletedMarker> {
             p.expect(T![')']);
         }
         Some(m.complete(p, OFFSET_OF_EXPR))
-    } else if p.at_contextual_kw(T![format_args]) {
-        p.bump_remap(T![format_args]);
+    } else if p.eat_contextual_kw(T![format_args]) {
         p.expect(T!['(']);
         expr(p);
         if p.eat(T![,]) {
@@ -302,7 +300,16 @@ fn builtin_expr(p: &mut Parser<'_>) -> Option<CompletedMarker> {
         }
         p.expect(T![')']);
         Some(m.complete(p, FORMAT_ARGS_EXPR))
-    } else if p.at_contextual_kw(T![asm]) {
+    } else if p.eat_contextual_kw(T![asm])
+        || p.eat_contextual_kw(T![global_asm])
+        || p.eat_contextual_kw(T![naked_asm])
+    {
+        // test asm_kinds
+        // fn foo() {
+        //     builtin#asm("");
+        //     builtin#global_asm("");
+        //     builtin#naked_asm("");
+        // }
         parse_asm_expr(p, m)
     } else {
         m.abandon(p);
@@ -322,7 +329,6 @@ fn builtin_expr(p: &mut Parser<'_>) -> Option<CompletedMarker> {
 //     );
 // }
 fn parse_asm_expr(p: &mut Parser<'_>, m: Marker) -> Option<CompletedMarker> {
-    p.bump_remap(T![asm]);
     p.expect(T!['(']);
     if expr(p).is_none() {
         p.err_and_bump("expected asm template");
diff --git a/src/tools/rust-analyzer/crates/parser/src/syntax_kind/generated.rs b/src/tools/rust-analyzer/crates/parser/src/syntax_kind/generated.rs
index f534546ea07..12a13caa4d9 100644
--- a/src/tools/rust-analyzer/crates/parser/src/syntax_kind/generated.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/syntax_kind/generated.rs
@@ -120,12 +120,14 @@ pub enum SyntaxKind {
     DYN_KW,
     FORMAT_ARGS_KW,
     GEN_KW,
+    GLOBAL_ASM_KW,
     INLATEOUT_KW,
     INOUT_KW,
     LABEL_KW,
     LATEOUT_KW,
     MACRO_RULES_KW,
     MAY_UNWIND_KW,
+    NAKED_ASM_KW,
     NOMEM_KW,
     NORETURN_KW,
     NOSTACK_KW,
@@ -599,12 +601,14 @@ impl SyntaxKind {
             DEFAULT_KW => "default",
             DYN_KW => "dyn",
             FORMAT_ARGS_KW => "format_args",
+            GLOBAL_ASM_KW => "global_asm",
             INLATEOUT_KW => "inlateout",
             INOUT_KW => "inout",
             LABEL_KW => "label",
             LATEOUT_KW => "lateout",
             MACRO_RULES_KW => "macro_rules",
             MAY_UNWIND_KW => "may_unwind",
+            NAKED_ASM_KW => "naked_asm",
             NOMEM_KW => "nomem",
             NORETURN_KW => "noreturn",
             NOSTACK_KW => "nostack",
@@ -699,12 +703,14 @@ impl SyntaxKind {
             DEFAULT_KW => true,
             DYN_KW if edition < Edition::Edition2018 => true,
             FORMAT_ARGS_KW => true,
+            GLOBAL_ASM_KW => true,
             INLATEOUT_KW => true,
             INOUT_KW => true,
             LABEL_KW => true,
             LATEOUT_KW => true,
             MACRO_RULES_KW => true,
             MAY_UNWIND_KW => true,
+            NAKED_ASM_KW => true,
             NOMEM_KW => true,
             NORETURN_KW => true,
             NOSTACK_KW => true,
@@ -787,12 +793,14 @@ impl SyntaxKind {
             DEFAULT_KW => true,
             DYN_KW if edition < Edition::Edition2018 => true,
             FORMAT_ARGS_KW => true,
+            GLOBAL_ASM_KW => true,
             INLATEOUT_KW => true,
             INOUT_KW => true,
             LABEL_KW => true,
             LATEOUT_KW => true,
             MACRO_RULES_KW => true,
             MAY_UNWIND_KW => true,
+            NAKED_ASM_KW => true,
             NOMEM_KW => true,
             NORETURN_KW => true,
             NOSTACK_KW => true,
@@ -938,12 +946,14 @@ impl SyntaxKind {
             "default" => DEFAULT_KW,
             "dyn" if edition < Edition::Edition2018 => DYN_KW,
             "format_args" => FORMAT_ARGS_KW,
+            "global_asm" => GLOBAL_ASM_KW,
             "inlateout" => INLATEOUT_KW,
             "inout" => INOUT_KW,
             "label" => LABEL_KW,
             "lateout" => LATEOUT_KW,
             "macro_rules" => MACRO_RULES_KW,
             "may_unwind" => MAY_UNWIND_KW,
+            "naked_asm" => NAKED_ASM_KW,
             "nomem" => NOMEM_KW,
             "noreturn" => NORETURN_KW,
             "nostack" => NOSTACK_KW,
@@ -998,7 +1008,7 @@ impl SyntaxKind {
     }
 }
 #[macro_export]
-macro_rules ! T_ { [$] => { $ crate :: SyntaxKind :: DOLLAR } ; [;] => { $ crate :: SyntaxKind :: SEMICOLON } ; [,] => { $ crate :: SyntaxKind :: COMMA } ; ['('] => { $ crate :: SyntaxKind :: L_PAREN } ; [')'] => { $ crate :: SyntaxKind :: R_PAREN } ; ['{'] => { $ crate :: SyntaxKind :: L_CURLY } ; ['}'] => { $ crate :: SyntaxKind :: R_CURLY } ; ['['] => { $ crate :: SyntaxKind :: L_BRACK } ; [']'] => { $ crate :: SyntaxKind :: R_BRACK } ; [<] => { $ crate :: SyntaxKind :: L_ANGLE } ; [>] => { $ crate :: SyntaxKind :: R_ANGLE } ; [@] => { $ crate :: SyntaxKind :: AT } ; [#] => { $ crate :: SyntaxKind :: POUND } ; [~] => { $ crate :: SyntaxKind :: TILDE } ; [?] => { $ crate :: SyntaxKind :: QUESTION } ; [&] => { $ crate :: SyntaxKind :: AMP } ; [|] => { $ crate :: SyntaxKind :: PIPE } ; [+] => { $ crate :: SyntaxKind :: PLUS } ; [*] => { $ crate :: SyntaxKind :: STAR } ; [/] => { $ crate :: SyntaxKind :: SLASH } ; [^] => { $ crate :: SyntaxKind :: CARET } ; [%] => { $ crate :: SyntaxKind :: PERCENT } ; [_] => { $ crate :: SyntaxKind :: UNDERSCORE } ; [.] => { $ crate :: SyntaxKind :: DOT } ; [..] => { $ crate :: SyntaxKind :: DOT2 } ; [...] => { $ crate :: SyntaxKind :: DOT3 } ; [..=] => { $ crate :: SyntaxKind :: DOT2EQ } ; [:] => { $ crate :: SyntaxKind :: COLON } ; [::] => { $ crate :: SyntaxKind :: COLON2 } ; [=] => { $ crate :: SyntaxKind :: EQ } ; [==] => { $ crate :: SyntaxKind :: EQ2 } ; [=>] => { $ crate :: SyntaxKind :: FAT_ARROW } ; [!] => { $ crate :: SyntaxKind :: BANG } ; [!=] => { $ crate :: SyntaxKind :: NEQ } ; [-] => { $ crate :: SyntaxKind :: MINUS } ; [->] => { $ crate :: SyntaxKind :: THIN_ARROW } ; [<=] => { $ crate :: SyntaxKind :: LTEQ } ; [>=] => { $ crate :: SyntaxKind :: GTEQ } ; [+=] => { $ crate :: SyntaxKind :: PLUSEQ } ; [-=] => { $ crate :: SyntaxKind :: MINUSEQ } ; [|=] => { $ crate :: SyntaxKind :: PIPEEQ } ; [&=] => { $ crate :: SyntaxKind :: AMPEQ } ; [^=] => { $ crate :: SyntaxKind :: CARETEQ } ; [/=] => { $ crate :: SyntaxKind :: SLASHEQ } ; [*=] => { $ crate :: SyntaxKind :: STAREQ } ; [%=] => { $ crate :: SyntaxKind :: PERCENTEQ } ; [&&] => { $ crate :: SyntaxKind :: AMP2 } ; [||] => { $ crate :: SyntaxKind :: PIPE2 } ; [<<] => { $ crate :: SyntaxKind :: SHL } ; [>>] => { $ crate :: SyntaxKind :: SHR } ; [<<=] => { $ crate :: SyntaxKind :: SHLEQ } ; [>>=] => { $ crate :: SyntaxKind :: SHREQ } ; [Self] => { $ crate :: SyntaxKind :: SELF_TYPE_KW } ; [abstract] => { $ crate :: SyntaxKind :: ABSTRACT_KW } ; [as] => { $ crate :: SyntaxKind :: AS_KW } ; [become] => { $ crate :: SyntaxKind :: BECOME_KW } ; [box] => { $ crate :: SyntaxKind :: BOX_KW } ; [break] => { $ crate :: SyntaxKind :: BREAK_KW } ; [const] => { $ crate :: SyntaxKind :: CONST_KW } ; [continue] => { $ crate :: SyntaxKind :: CONTINUE_KW } ; [crate] => { $ crate :: SyntaxKind :: CRATE_KW } ; [do] => { $ crate :: SyntaxKind :: DO_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [enum] => { $ crate :: SyntaxKind :: ENUM_KW } ; [extern] => { $ crate :: SyntaxKind :: EXTERN_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_KW } ; [final] => { $ crate :: SyntaxKind :: FINAL_KW } ; [fn] => { $ crate :: SyntaxKind :: FN_KW } ; [for] => { $ crate :: SyntaxKind :: FOR_KW } ; [if] => { $ crate :: SyntaxKind :: IF_KW } ; [impl] => { $ crate :: SyntaxKind :: IMPL_KW } ; [in] => { $ crate :: SyntaxKind :: IN_KW } ; [let] => { $ crate :: SyntaxKind :: LET_KW } ; [loop] => { $ crate :: SyntaxKind :: LOOP_KW } ; [macro] => { $ crate :: SyntaxKind :: MACRO_KW } ; [match] => { $ crate :: SyntaxKind :: MATCH_KW } ; [mod] => { $ crate :: SyntaxKind :: MOD_KW } ; [move] => { $ crate :: SyntaxKind :: MOVE_KW } ; [mut] => { $ crate :: SyntaxKind :: MUT_KW } ; [override] => { $ crate :: SyntaxKind :: OVERRIDE_KW } ; [priv] => { $ crate :: SyntaxKind :: PRIV_KW } ; [pub] => { $ crate :: SyntaxKind :: PUB_KW } ; [ref] => { $ crate :: SyntaxKind :: REF_KW } ; [return] => { $ crate :: SyntaxKind :: RETURN_KW } ; [self] => { $ crate :: SyntaxKind :: SELF_KW } ; [static] => { $ crate :: SyntaxKind :: STATIC_KW } ; [struct] => { $ crate :: SyntaxKind :: STRUCT_KW } ; [super] => { $ crate :: SyntaxKind :: SUPER_KW } ; [trait] => { $ crate :: SyntaxKind :: TRAIT_KW } ; [true] => { $ crate :: SyntaxKind :: TRUE_KW } ; [type] => { $ crate :: SyntaxKind :: TYPE_KW } ; [typeof] => { $ crate :: SyntaxKind :: TYPEOF_KW } ; [unsafe] => { $ crate :: SyntaxKind :: UNSAFE_KW } ; [unsized] => { $ crate :: SyntaxKind :: UNSIZED_KW } ; [use] => { $ crate :: SyntaxKind :: USE_KW } ; [virtual] => { $ crate :: SyntaxKind :: VIRTUAL_KW } ; [where] => { $ crate :: SyntaxKind :: WHERE_KW } ; [while] => { $ crate :: SyntaxKind :: WHILE_KW } ; [yield] => { $ crate :: SyntaxKind :: YIELD_KW } ; [asm] => { $ crate :: SyntaxKind :: ASM_KW } ; [att_syntax] => { $ crate :: SyntaxKind :: ATT_SYNTAX_KW } ; [auto] => { $ crate :: SyntaxKind :: AUTO_KW } ; [builtin] => { $ crate :: SyntaxKind :: BUILTIN_KW } ; [clobber_abi] => { $ crate :: SyntaxKind :: CLOBBER_ABI_KW } ; [default] => { $ crate :: SyntaxKind :: DEFAULT_KW } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [format_args] => { $ crate :: SyntaxKind :: FORMAT_ARGS_KW } ; [inlateout] => { $ crate :: SyntaxKind :: INLATEOUT_KW } ; [inout] => { $ crate :: SyntaxKind :: INOUT_KW } ; [label] => { $ crate :: SyntaxKind :: LABEL_KW } ; [lateout] => { $ crate :: SyntaxKind :: LATEOUT_KW } ; [macro_rules] => { $ crate :: SyntaxKind :: MACRO_RULES_KW } ; [may_unwind] => { $ crate :: SyntaxKind :: MAY_UNWIND_KW } ; [nomem] => { $ crate :: SyntaxKind :: NOMEM_KW } ; [noreturn] => { $ crate :: SyntaxKind :: NORETURN_KW } ; [nostack] => { $ crate :: SyntaxKind :: NOSTACK_KW } ; [offset_of] => { $ crate :: SyntaxKind :: OFFSET_OF_KW } ; [options] => { $ crate :: SyntaxKind :: OPTIONS_KW } ; [out] => { $ crate :: SyntaxKind :: OUT_KW } ; [preserves_flags] => { $ crate :: SyntaxKind :: PRESERVES_FLAGS_KW } ; [pure] => { $ crate :: SyntaxKind :: PURE_KW } ; [raw] => { $ crate :: SyntaxKind :: RAW_KW } ; [readonly] => { $ crate :: SyntaxKind :: READONLY_KW } ; [safe] => { $ crate :: SyntaxKind :: SAFE_KW } ; [sym] => { $ crate :: SyntaxKind :: SYM_KW } ; [union] => { $ crate :: SyntaxKind :: UNION_KW } ; [yeet] => { $ crate :: SyntaxKind :: YEET_KW } ; [async] => { $ crate :: SyntaxKind :: ASYNC_KW } ; [await] => { $ crate :: SyntaxKind :: AWAIT_KW } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [gen] => { $ crate :: SyntaxKind :: GEN_KW } ; [try] => { $ crate :: SyntaxKind :: TRY_KW } ; [lifetime_ident] => { $ crate :: SyntaxKind :: LIFETIME_IDENT } ; [int_number] => { $ crate :: SyntaxKind :: INT_NUMBER } ; [ident] => { $ crate :: SyntaxKind :: IDENT } ; [string] => { $ crate :: SyntaxKind :: STRING } ; [shebang] => { $ crate :: SyntaxKind :: SHEBANG } ; [frontmatter] => { $ crate :: SyntaxKind :: FRONTMATTER } ; }
+macro_rules ! T_ { [$] => { $ crate :: SyntaxKind :: DOLLAR } ; [;] => { $ crate :: SyntaxKind :: SEMICOLON } ; [,] => { $ crate :: SyntaxKind :: COMMA } ; ['('] => { $ crate :: SyntaxKind :: L_PAREN } ; [')'] => { $ crate :: SyntaxKind :: R_PAREN } ; ['{'] => { $ crate :: SyntaxKind :: L_CURLY } ; ['}'] => { $ crate :: SyntaxKind :: R_CURLY } ; ['['] => { $ crate :: SyntaxKind :: L_BRACK } ; [']'] => { $ crate :: SyntaxKind :: R_BRACK } ; [<] => { $ crate :: SyntaxKind :: L_ANGLE } ; [>] => { $ crate :: SyntaxKind :: R_ANGLE } ; [@] => { $ crate :: SyntaxKind :: AT } ; [#] => { $ crate :: SyntaxKind :: POUND } ; [~] => { $ crate :: SyntaxKind :: TILDE } ; [?] => { $ crate :: SyntaxKind :: QUESTION } ; [&] => { $ crate :: SyntaxKind :: AMP } ; [|] => { $ crate :: SyntaxKind :: PIPE } ; [+] => { $ crate :: SyntaxKind :: PLUS } ; [*] => { $ crate :: SyntaxKind :: STAR } ; [/] => { $ crate :: SyntaxKind :: SLASH } ; [^] => { $ crate :: SyntaxKind :: CARET } ; [%] => { $ crate :: SyntaxKind :: PERCENT } ; [_] => { $ crate :: SyntaxKind :: UNDERSCORE } ; [.] => { $ crate :: SyntaxKind :: DOT } ; [..] => { $ crate :: SyntaxKind :: DOT2 } ; [...] => { $ crate :: SyntaxKind :: DOT3 } ; [..=] => { $ crate :: SyntaxKind :: DOT2EQ } ; [:] => { $ crate :: SyntaxKind :: COLON } ; [::] => { $ crate :: SyntaxKind :: COLON2 } ; [=] => { $ crate :: SyntaxKind :: EQ } ; [==] => { $ crate :: SyntaxKind :: EQ2 } ; [=>] => { $ crate :: SyntaxKind :: FAT_ARROW } ; [!] => { $ crate :: SyntaxKind :: BANG } ; [!=] => { $ crate :: SyntaxKind :: NEQ } ; [-] => { $ crate :: SyntaxKind :: MINUS } ; [->] => { $ crate :: SyntaxKind :: THIN_ARROW } ; [<=] => { $ crate :: SyntaxKind :: LTEQ } ; [>=] => { $ crate :: SyntaxKind :: GTEQ } ; [+=] => { $ crate :: SyntaxKind :: PLUSEQ } ; [-=] => { $ crate :: SyntaxKind :: MINUSEQ } ; [|=] => { $ crate :: SyntaxKind :: PIPEEQ } ; [&=] => { $ crate :: SyntaxKind :: AMPEQ } ; [^=] => { $ crate :: SyntaxKind :: CARETEQ } ; [/=] => { $ crate :: SyntaxKind :: SLASHEQ } ; [*=] => { $ crate :: SyntaxKind :: STAREQ } ; [%=] => { $ crate :: SyntaxKind :: PERCENTEQ } ; [&&] => { $ crate :: SyntaxKind :: AMP2 } ; [||] => { $ crate :: SyntaxKind :: PIPE2 } ; [<<] => { $ crate :: SyntaxKind :: SHL } ; [>>] => { $ crate :: SyntaxKind :: SHR } ; [<<=] => { $ crate :: SyntaxKind :: SHLEQ } ; [>>=] => { $ crate :: SyntaxKind :: SHREQ } ; [Self] => { $ crate :: SyntaxKind :: SELF_TYPE_KW } ; [abstract] => { $ crate :: SyntaxKind :: ABSTRACT_KW } ; [as] => { $ crate :: SyntaxKind :: AS_KW } ; [become] => { $ crate :: SyntaxKind :: BECOME_KW } ; [box] => { $ crate :: SyntaxKind :: BOX_KW } ; [break] => { $ crate :: SyntaxKind :: BREAK_KW } ; [const] => { $ crate :: SyntaxKind :: CONST_KW } ; [continue] => { $ crate :: SyntaxKind :: CONTINUE_KW } ; [crate] => { $ crate :: SyntaxKind :: CRATE_KW } ; [do] => { $ crate :: SyntaxKind :: DO_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [enum] => { $ crate :: SyntaxKind :: ENUM_KW } ; [extern] => { $ crate :: SyntaxKind :: EXTERN_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_KW } ; [final] => { $ crate :: SyntaxKind :: FINAL_KW } ; [fn] => { $ crate :: SyntaxKind :: FN_KW } ; [for] => { $ crate :: SyntaxKind :: FOR_KW } ; [if] => { $ crate :: SyntaxKind :: IF_KW } ; [impl] => { $ crate :: SyntaxKind :: IMPL_KW } ; [in] => { $ crate :: SyntaxKind :: IN_KW } ; [let] => { $ crate :: SyntaxKind :: LET_KW } ; [loop] => { $ crate :: SyntaxKind :: LOOP_KW } ; [macro] => { $ crate :: SyntaxKind :: MACRO_KW } ; [match] => { $ crate :: SyntaxKind :: MATCH_KW } ; [mod] => { $ crate :: SyntaxKind :: MOD_KW } ; [move] => { $ crate :: SyntaxKind :: MOVE_KW } ; [mut] => { $ crate :: SyntaxKind :: MUT_KW } ; [override] => { $ crate :: SyntaxKind :: OVERRIDE_KW } ; [priv] => { $ crate :: SyntaxKind :: PRIV_KW } ; [pub] => { $ crate :: SyntaxKind :: PUB_KW } ; [ref] => { $ crate :: SyntaxKind :: REF_KW } ; [return] => { $ crate :: SyntaxKind :: RETURN_KW } ; [self] => { $ crate :: SyntaxKind :: SELF_KW } ; [static] => { $ crate :: SyntaxKind :: STATIC_KW } ; [struct] => { $ crate :: SyntaxKind :: STRUCT_KW } ; [super] => { $ crate :: SyntaxKind :: SUPER_KW } ; [trait] => { $ crate :: SyntaxKind :: TRAIT_KW } ; [true] => { $ crate :: SyntaxKind :: TRUE_KW } ; [type] => { $ crate :: SyntaxKind :: TYPE_KW } ; [typeof] => { $ crate :: SyntaxKind :: TYPEOF_KW } ; [unsafe] => { $ crate :: SyntaxKind :: UNSAFE_KW } ; [unsized] => { $ crate :: SyntaxKind :: UNSIZED_KW } ; [use] => { $ crate :: SyntaxKind :: USE_KW } ; [virtual] => { $ crate :: SyntaxKind :: VIRTUAL_KW } ; [where] => { $ crate :: SyntaxKind :: WHERE_KW } ; [while] => { $ crate :: SyntaxKind :: WHILE_KW } ; [yield] => { $ crate :: SyntaxKind :: YIELD_KW } ; [asm] => { $ crate :: SyntaxKind :: ASM_KW } ; [att_syntax] => { $ crate :: SyntaxKind :: ATT_SYNTAX_KW } ; [auto] => { $ crate :: SyntaxKind :: AUTO_KW } ; [builtin] => { $ crate :: SyntaxKind :: BUILTIN_KW } ; [clobber_abi] => { $ crate :: SyntaxKind :: CLOBBER_ABI_KW } ; [default] => { $ crate :: SyntaxKind :: DEFAULT_KW } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [format_args] => { $ crate :: SyntaxKind :: FORMAT_ARGS_KW } ; [global_asm] => { $ crate :: SyntaxKind :: GLOBAL_ASM_KW } ; [inlateout] => { $ crate :: SyntaxKind :: INLATEOUT_KW } ; [inout] => { $ crate :: SyntaxKind :: INOUT_KW } ; [label] => { $ crate :: SyntaxKind :: LABEL_KW } ; [lateout] => { $ crate :: SyntaxKind :: LATEOUT_KW } ; [macro_rules] => { $ crate :: SyntaxKind :: MACRO_RULES_KW } ; [may_unwind] => { $ crate :: SyntaxKind :: MAY_UNWIND_KW } ; [naked_asm] => { $ crate :: SyntaxKind :: NAKED_ASM_KW } ; [nomem] => { $ crate :: SyntaxKind :: NOMEM_KW } ; [noreturn] => { $ crate :: SyntaxKind :: NORETURN_KW } ; [nostack] => { $ crate :: SyntaxKind :: NOSTACK_KW } ; [offset_of] => { $ crate :: SyntaxKind :: OFFSET_OF_KW } ; [options] => { $ crate :: SyntaxKind :: OPTIONS_KW } ; [out] => { $ crate :: SyntaxKind :: OUT_KW } ; [preserves_flags] => { $ crate :: SyntaxKind :: PRESERVES_FLAGS_KW } ; [pure] => { $ crate :: SyntaxKind :: PURE_KW } ; [raw] => { $ crate :: SyntaxKind :: RAW_KW } ; [readonly] => { $ crate :: SyntaxKind :: READONLY_KW } ; [safe] => { $ crate :: SyntaxKind :: SAFE_KW } ; [sym] => { $ crate :: SyntaxKind :: SYM_KW } ; [union] => { $ crate :: SyntaxKind :: UNION_KW } ; [yeet] => { $ crate :: SyntaxKind :: YEET_KW } ; [async] => { $ crate :: SyntaxKind :: ASYNC_KW } ; [await] => { $ crate :: SyntaxKind :: AWAIT_KW } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [gen] => { $ crate :: SyntaxKind :: GEN_KW } ; [try] => { $ crate :: SyntaxKind :: TRY_KW } ; [lifetime_ident] => { $ crate :: SyntaxKind :: LIFETIME_IDENT } ; [int_number] => { $ crate :: SyntaxKind :: INT_NUMBER } ; [ident] => { $ crate :: SyntaxKind :: IDENT } ; [string] => { $ crate :: SyntaxKind :: STRING } ; [shebang] => { $ crate :: SyntaxKind :: SHEBANG } ; [frontmatter] => { $ crate :: SyntaxKind :: FRONTMATTER } ; }
 impl ::core::marker::Copy for SyntaxKind {}
 impl ::core::clone::Clone for SyntaxKind {
     #[inline]
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 6ec4192830b..8053d0b22d2 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
@@ -21,6 +21,8 @@ mod ok {
     #[test]
     fn asm_expr() { run_and_expect_no_errors("test_data/parser/inline/ok/asm_expr.rs"); }
     #[test]
+    fn asm_kinds() { run_and_expect_no_errors("test_data/parser/inline/ok/asm_kinds.rs"); }
+    #[test]
     fn asm_label() { run_and_expect_no_errors("test_data/parser/inline/ok/asm_label.rs"); }
     #[test]
     fn assoc_const_eq() {
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.rast
new file mode 100644
index 00000000000..fbf95d15f24
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.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 "\"\""
+            R_PAREN ")"
+          SEMICOLON ";"
+        WHITESPACE "\n    "
+        EXPR_STMT
+          ASM_EXPR
+            BUILTIN_KW "builtin"
+            POUND "#"
+            GLOBAL_ASM_KW "global_asm"
+            L_PAREN "("
+            LITERAL
+              STRING "\"\""
+            R_PAREN ")"
+          SEMICOLON ";"
+        WHITESPACE "\n    "
+        EXPR_STMT
+          ASM_EXPR
+            BUILTIN_KW "builtin"
+            POUND "#"
+            NAKED_ASM_KW "naked_asm"
+            L_PAREN "("
+            LITERAL
+              STRING "\"\""
+            R_PAREN ")"
+          SEMICOLON ";"
+        WHITESPACE "\n"
+        R_CURLY "}"
+  WHITESPACE "\n"
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.rs b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.rs
new file mode 100644
index 00000000000..9c03e9de689
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.rs
@@ -0,0 +1,5 @@
+fn foo() {
+    builtin#asm("");
+    builtin#global_asm("");
+    builtin#naked_asm("");
+}
diff --git a/src/tools/rust-analyzer/crates/syntax/rust.ungram b/src/tools/rust-analyzer/crates/syntax/rust.ungram
index 3f439472337..88ecbb0ef00 100644
--- a/src/tools/rust-analyzer/crates/syntax/rust.ungram
+++ b/src/tools/rust-analyzer/crates/syntax/rust.ungram
@@ -409,7 +409,8 @@ OffsetOfExpr =
 // global_asm := "global_asm!(" format_string *("," format_string) *("," operand) [","] ")"
 // format_string := STRING_LITERAL / RAW_STRING_LITERAL
 AsmExpr =
-  Attr* 'builtin' '#' 'asm' '(' template:(Expr (',' Expr)*) (AsmPiece (',' AsmPiece)*)? ','? ')'
+  Attr* 'builtin' '#' ( 'asm' | 'global_asm' | 'naked_asm' )
+  '(' template:(Expr (',' Expr)*) (AsmPiece (',' AsmPiece)*)? ','? ')'
 
 // operand_expr := expr / "_" / expr "=>" expr / expr "=>" "_"
 AsmOperandExpr = in_expr:Expr ('=>' out_expr:Expr)?
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 79a9f4da338..e1e331d653e 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
@@ -118,6 +118,14 @@ impl AsmExpr {
     pub fn asm_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![asm]) }
     #[inline]
     pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }
+    #[inline]
+    pub fn global_asm_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, T![global_asm])
+    }
+    #[inline]
+    pub fn naked_asm_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, T![naked_asm])
+    }
 }
 pub struct AsmLabel {
     pub(crate) syntax: SyntaxNode,
diff --git a/src/tools/rust-analyzer/xtask/src/codegen/grammar/ast_src.rs b/src/tools/rust-analyzer/xtask/src/codegen/grammar/ast_src.rs
index d8cbf894520..b9f570fe0e3 100644
--- a/src/tools/rust-analyzer/xtask/src/codegen/grammar/ast_src.rs
+++ b/src/tools/rust-analyzer/xtask/src/codegen/grammar/ast_src.rs
@@ -116,6 +116,8 @@ const CONTEXTUAL_KEYWORDS: &[&str] =
 // keywords we use for special macro expansions
 const CONTEXTUAL_BUILTIN_KEYWORDS: &[&str] = &[
     "asm",
+    "naked_asm",
+    "global_asm",
     "att_syntax",
     "builtin",
     "clobber_abi",
-- 
cgit 1.4.1-3-g733a5


From bf6d29d55847614e677e6c5d6060d2dc0b1ad47b Mon Sep 17 00:00:00 2001
From: usamoi <usamoi@outlook.com>
Date: Sat, 5 Jul 2025 02:07:29 +0800
Subject: use `--dynamic-list` for exporting executable symbols

---
 compiler/rustc_codegen_ssa/src/back/linker.rs | 41 ++++++++++++++++-----------
 tests/ui/linking/export-executable-symbols.rs | 30 ++++++++++++++++++++
 2 files changed, 55 insertions(+), 16 deletions(-)
 create mode 100644 tests/ui/linking/export-executable-symbols.rs

diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index 1896f63bd2d..e0a3ad55be0 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -800,9 +800,7 @@ impl<'a> Linker for GccLinker<'a> {
             return;
         }
 
-        let is_windows = self.sess.target.is_like_windows;
-        let path = tmpdir.join(if is_windows { "list.def" } else { "list" });
-
+        let path = tmpdir.join(if self.sess.target.is_like_windows { "list.def" } else { "list" });
         debug!("EXPORTED SYMBOLS:");
 
         if self.sess.target.is_like_darwin {
@@ -817,7 +815,8 @@ impl<'a> Linker for GccLinker<'a> {
             if let Err(error) = res {
                 self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
             }
-        } else if is_windows {
+            self.link_arg("-exported_symbols_list").link_arg(path);
+        } else if self.sess.target.is_like_windows {
             let res: io::Result<()> = try {
                 let mut f = File::create_buffered(&path)?;
 
@@ -835,6 +834,21 @@ impl<'a> Linker for GccLinker<'a> {
             if let Err(error) = res {
                 self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
             }
+            self.link_arg(path);
+        } else if crate_type == CrateType::Executable && !self.sess.target.is_like_solaris {
+            let res: io::Result<()> = try {
+                let mut f = File::create_buffered(&path)?;
+                writeln!(f, "{{")?;
+                for (sym, _) in symbols {
+                    debug!(sym);
+                    writeln!(f, "  {sym};")?;
+                }
+                writeln!(f, "}};")?;
+            };
+            if let Err(error) = res {
+                self.sess.dcx().emit_fatal(errors::VersionScriptWriteFailure { error });
+            }
+            self.link_arg("--dynamic-list").link_arg(path);
         } else {
             // Write an LD version script
             let res: io::Result<()> = try {
@@ -852,18 +866,13 @@ impl<'a> Linker for GccLinker<'a> {
             if let Err(error) = res {
                 self.sess.dcx().emit_fatal(errors::VersionScriptWriteFailure { error });
             }
-        }
-
-        if self.sess.target.is_like_darwin {
-            self.link_arg("-exported_symbols_list").link_arg(path);
-        } else if self.sess.target.is_like_solaris {
-            self.link_arg("-M").link_arg(path);
-        } else if is_windows {
-            self.link_arg(path);
-        } else {
-            let mut arg = OsString::from("--version-script=");
-            arg.push(path);
-            self.link_arg(arg).link_arg("--no-undefined-version");
+            if self.sess.target.is_like_solaris {
+                self.link_arg("-M").link_arg(path);
+            } else {
+                let mut arg = OsString::from("--version-script=");
+                arg.push(path);
+                self.link_arg(arg).link_arg("--no-undefined-version");
+            }
         }
     }
 
diff --git a/tests/ui/linking/export-executable-symbols.rs b/tests/ui/linking/export-executable-symbols.rs
new file mode 100644
index 00000000000..aea5527b6a1
--- /dev/null
+++ b/tests/ui/linking/export-executable-symbols.rs
@@ -0,0 +1,30 @@
+//@ run-pass
+//@ only-linux
+//@ only-gnu
+//@ compile-flags: -Zexport-executable-symbols
+//@ edition: 2024
+
+// Regression test for <https://github.com/rust-lang/rust/issues/101610>.
+
+#![feature(rustc_private)]
+
+extern crate libc;
+
+#[unsafe(no_mangle)]
+fn hack() -> u64 {
+    998244353
+}
+
+fn main() {
+    unsafe {
+        let handle = libc::dlopen(std::ptr::null(), libc::RTLD_NOW);
+        let ptr = libc::dlsym(handle, c"hack".as_ptr());
+        let ptr: Option<unsafe fn() -> u64> = std::mem::transmute(ptr);
+        if let Some(f) = ptr {
+            assert!(f() == 998244353);
+            println!("symbol `hack` is found successfully");
+        } else {
+            panic!("symbol `hack` is not found");
+        }
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 90653b0f5cbe567cee2489c0b71ce4ddd26c8f71 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 9 Jul 2025 18:55:27 +0300
Subject: Make `global_asm!()` work

Because apparently, we were not accepting inline asm in item position, completely breaking it.
---
 .../crates/hir-def/src/item_tree/lower.rs             |  2 ++
 .../src/macro_expansion_tests/builtin_fn_macro.rs     | 12 ++++--------
 .../rust-analyzer/crates/hir-def/src/resolver.rs      | 11 -----------
 .../rust-analyzer/crates/hir/src/source_analyzer.rs   |  8 +++++---
 .../crates/parser/src/grammar/expressions.rs          |  2 +-
 .../crates/parser/src/grammar/expressions/atom.rs     |  2 +-
 .../rust-analyzer/crates/parser/src/grammar/items.rs  | 13 +++++++++++++
 .../crates/parser/test_data/generated/runner.rs       |  2 ++
 .../parser/test_data/parser/inline/ok/asm_kinds.rast  | 19 +++++++++----------
 .../parser/test_data/parser/inline/ok/global_asm.rast | 10 ++++++++++
 .../parser/test_data/parser/inline/ok/global_asm.rs   |  1 +
 src/tools/rust-analyzer/crates/syntax/rust.ungram     |  1 +
 .../crates/syntax/src/ast/generated/nodes.rs          | 11 +++++++++--
 13 files changed, 58 insertions(+), 36 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/global_asm.rast
 create mode 100644 src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/global_asm.rs

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 f3273667158..5ab61c89394 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
@@ -143,6 +143,8 @@ impl<'a> Ctx<'a> {
             ast::Item::MacroRules(ast) => self.lower_macro_rules(ast)?.into(),
             ast::Item::MacroDef(ast) => self.lower_macro_def(ast)?.into(),
             ast::Item::ExternBlock(ast) => self.lower_extern_block(ast).into(),
+            // FIXME: Handle `global_asm!()`.
+            ast::Item::AsmExpr(_) => return None,
         };
         let attrs = RawAttrs::new(self.db, item, self.span_map());
         self.add_attrs(mod_item.ast_id(), attrs);
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 a48a6be4d84..1c3af47d522 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
@@ -33,10 +33,9 @@ macro_rules! global_asm {() => {}}
 #[rustc_builtin_macro]
 macro_rules! naked_asm {() => {}}
 
-// FIXME: This creates an error
-// global_asm! {
-//     ""
-// }
+global_asm! {
+    ""
+}
 
 #[unsafe(naked)]
 extern "C" fn foo() {
@@ -64,10 +63,7 @@ macro_rules! global_asm {() => {}}
 #[rustc_builtin_macro]
 macro_rules! naked_asm {() => {}}
 
-// FIXME: This creates an error
-// global_asm! {
-//     ""
-// }
+builtin #global_asm ("")
 
 #[unsafe(naked)]
 extern "C" fn foo() {
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 6f321980af4..316ad5dae69 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/resolver.rs
@@ -1052,17 +1052,6 @@ impl<'db> Scope<'db> {
     }
 }
 
-pub fn resolver_for_expr(
-    db: &dyn DefDatabase,
-    owner: DefWithBodyId,
-    expr_id: ExprId,
-) -> Resolver<'_> {
-    let r = owner.resolver(db);
-    let scopes = db.expr_scopes(owner);
-    let scope_id = scopes.scope_for(expr_id);
-    resolver_for_scope_(db, scopes, scope_id, r, owner)
-}
-
 pub fn resolver_for_scope(
     db: &dyn DefDatabase,
     owner: DefWithBodyId,
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 cbd472f87aa..536d3851e4f 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -1441,9 +1441,11 @@ fn scope_for(
 ) -> Option<ScopeId> {
     node.ancestors_with_macros(db)
         .take_while(|it| {
-            !ast::Item::can_cast(it.kind())
-                || ast::MacroCall::can_cast(it.kind())
-                || ast::Use::can_cast(it.kind())
+            let kind = it.kind();
+            !ast::Item::can_cast(kind)
+                || ast::MacroCall::can_cast(kind)
+                || ast::Use::can_cast(kind)
+                || ast::AsmExpr::can_cast(kind)
         })
         .filter_map(|it| it.map(ast::Expr::cast).transpose())
         .filter_map(|it| source_map.node_expr(it.as_ref())?.as_expr())
diff --git a/src/tools/rust-analyzer/crates/parser/src/grammar/expressions.rs b/src/tools/rust-analyzer/crates/parser/src/grammar/expressions.rs
index 0ac25da3294..2b4151e3b75 100644
--- a/src/tools/rust-analyzer/crates/parser/src/grammar/expressions.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/grammar/expressions.rs
@@ -4,7 +4,7 @@ use crate::grammar::attributes::ATTRIBUTE_FIRST;
 
 use super::*;
 
-pub(super) use atom::{EXPR_RECOVERY_SET, LITERAL_FIRST, literal};
+pub(super) use atom::{EXPR_RECOVERY_SET, LITERAL_FIRST, literal, parse_asm_expr};
 pub(crate) use atom::{block_expr, match_arm_list};
 
 #[derive(PartialEq, Eq)]
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 b81a0261733..a01021a9f76 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
@@ -328,7 +328,7 @@ fn builtin_expr(p: &mut Parser<'_>) -> Option<CompletedMarker> {
 //         tmp = out(reg) _,
 //     );
 // }
-fn parse_asm_expr(p: &mut Parser<'_>, m: Marker) -> Option<CompletedMarker> {
+pub(crate) fn parse_asm_expr(p: &mut Parser<'_>, m: Marker) -> Option<CompletedMarker> {
     p.expect(T!['(']);
     if expr(p).is_none() {
         p.err_and_bump("expected asm template");
diff --git a/src/tools/rust-analyzer/crates/parser/src/grammar/items.rs b/src/tools/rust-analyzer/crates/parser/src/grammar/items.rs
index b9f4866574a..8e551b0b961 100644
--- a/src/tools/rust-analyzer/crates/parser/src/grammar/items.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/grammar/items.rs
@@ -261,6 +261,19 @@ fn opt_item_without_modifiers(p: &mut Parser<'_>, m: Marker) -> Result<(), Marke
         T![const] if (la == IDENT || la == T![_] || la == T![mut]) => consts::konst(p, m),
         T![static] if (la == IDENT || la == T![_] || la == T![mut]) => consts::static_(p, m),
 
+        IDENT
+            if p.at_contextual_kw(T![builtin])
+                && p.nth_at(1, T![#])
+                && p.nth_at_contextual_kw(2, T![global_asm]) =>
+        {
+            p.bump_remap(T![builtin]);
+            p.bump(T![#]);
+            p.bump_remap(T![global_asm]);
+            // test global_asm
+            // builtin#global_asm("")
+            expressions::parse_asm_expr(p, m);
+        }
+
         _ => return Err(m),
     };
     Ok(())
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 8053d0b22d2..cef7b0ee239 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
@@ -300,6 +300,8 @@ mod ok {
         run_and_expect_no_errors("test_data/parser/inline/ok/generic_param_list.rs");
     }
     #[test]
+    fn global_asm() { run_and_expect_no_errors("test_data/parser/inline/ok/global_asm.rs"); }
+    #[test]
     fn half_open_range_pat() {
         run_and_expect_no_errors("test_data/parser/inline/ok/half_open_range_pat.rs");
     }
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.rast
index fbf95d15f24..c337d89aa50 100644
--- a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.rast
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/asm_kinds.rast
@@ -23,16 +23,15 @@ SOURCE_FILE
             R_PAREN ")"
           SEMICOLON ";"
         WHITESPACE "\n    "
-        EXPR_STMT
-          ASM_EXPR
-            BUILTIN_KW "builtin"
-            POUND "#"
-            GLOBAL_ASM_KW "global_asm"
-            L_PAREN "("
-            LITERAL
-              STRING "\"\""
-            R_PAREN ")"
-          SEMICOLON ";"
+        ASM_EXPR
+          BUILTIN_KW "builtin"
+          POUND "#"
+          GLOBAL_ASM_KW "global_asm"
+          L_PAREN "("
+          LITERAL
+            STRING "\"\""
+          R_PAREN ")"
+        SEMICOLON ";"
         WHITESPACE "\n    "
         EXPR_STMT
           ASM_EXPR
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/global_asm.rast b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/global_asm.rast
new file mode 100644
index 00000000000..5337c56be17
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/global_asm.rast
@@ -0,0 +1,10 @@
+SOURCE_FILE
+  ASM_EXPR
+    BUILTIN_KW "builtin"
+    POUND "#"
+    GLOBAL_ASM_KW "global_asm"
+    L_PAREN "("
+    LITERAL
+      STRING "\"\""
+    R_PAREN ")"
+  WHITESPACE "\n"
diff --git a/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/global_asm.rs b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/global_asm.rs
new file mode 100644
index 00000000000..967ce1f5fd9
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/parser/test_data/parser/inline/ok/global_asm.rs
@@ -0,0 +1 @@
+builtin#global_asm("")
diff --git a/src/tools/rust-analyzer/crates/syntax/rust.ungram b/src/tools/rust-analyzer/crates/syntax/rust.ungram
index 88ecbb0ef00..4cbc88cfb5e 100644
--- a/src/tools/rust-analyzer/crates/syntax/rust.ungram
+++ b/src/tools/rust-analyzer/crates/syntax/rust.ungram
@@ -158,6 +158,7 @@ Item =
 | TypeAlias
 | Union
 | Use
+| AsmExpr
 
 MacroRules =
   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 e1e331d653e..2b862465420 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
@@ -2095,6 +2095,7 @@ impl ast::HasAttrs for GenericParam {}
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Item {
+    AsmExpr(AsmExpr),
     Const(Const),
     Enum(Enum),
     ExternBlock(ExternBlock),
@@ -2114,7 +2115,6 @@ pub enum Item {
     Use(Use),
 }
 impl ast::HasAttrs for Item {}
-impl ast::HasDocComments for Item {}
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Pat {
@@ -8417,6 +8417,10 @@ impl AstNode for GenericParam {
         }
     }
 }
+impl From<AsmExpr> for Item {
+    #[inline]
+    fn from(node: AsmExpr) -> Item { Item::AsmExpr(node) }
+}
 impl From<Const> for Item {
     #[inline]
     fn from(node: Const) -> Item { Item::Const(node) }
@@ -8490,7 +8494,8 @@ impl AstNode for Item {
     fn can_cast(kind: SyntaxKind) -> bool {
         matches!(
             kind,
-            CONST
+            ASM_EXPR
+                | CONST
                 | ENUM
                 | EXTERN_BLOCK
                 | EXTERN_CRATE
@@ -8512,6 +8517,7 @@ impl AstNode for Item {
     #[inline]
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         let res = match syntax.kind() {
+            ASM_EXPR => Item::AsmExpr(AsmExpr { syntax }),
             CONST => Item::Const(Const { syntax }),
             ENUM => Item::Enum(Enum { syntax }),
             EXTERN_BLOCK => Item::ExternBlock(ExternBlock { syntax }),
@@ -8536,6 +8542,7 @@ impl AstNode for Item {
     #[inline]
     fn syntax(&self) -> &SyntaxNode {
         match self {
+            Item::AsmExpr(it) => &it.syntax,
             Item::Const(it) => &it.syntax,
             Item::Enum(it) => &it.syntax,
             Item::ExternBlock(it) => &it.syntax,
-- 
cgit 1.4.1-3-g733a5


From f3fc50b636df651034c2f9826d43cf56d0e46a10 Mon Sep 17 00:00:00 2001
From: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
Date: Thu, 10 Jul 2025 01:01:47 +0900
Subject: migrate `convert_named_struct_to_tuple_struct` assist to use
 'SyntaxEditor'

Signed-off-by: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
---
 .../src/handlers/convert_named_struct_to_tuple_struct.rs  | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 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 32c4ae2e869..8d27574eb2c 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
@@ -4,7 +4,8 @@ use itertools::Itertools;
 use syntax::{
     SyntaxKind,
     ast::{self, AstNode, HasAttrs, HasGenericParams, HasVisibility},
-    match_ast, ted,
+    match_ast,
+    syntax_editor::{Position, SyntaxEditor},
 };
 
 use crate::{AssistContext, AssistId, Assists, assist_context::SourceChangeBuilder};
@@ -97,11 +98,14 @@ fn edit_struct_def(
     // Note that we don't need to consider macro files in this function because this is
     // currently not triggered for struct definitions inside macro calls.
     let tuple_fields = record_fields.fields().filter_map(|f| {
-        let field = ast::make::tuple_field(f.visibility(), f.ty()?).clone_for_update();
-        ted::insert_all(
-            ted::Position::first_child_of(field.syntax()),
+        let field = ast::make::tuple_field(f.visibility(), f.ty()?);
+        let mut editor = SyntaxEditor::new(field.syntax().clone());
+        editor.insert_all(
+            Position::first_child_of(field.syntax()),
             f.attrs().map(|attr| attr.syntax().clone_subtree().clone_for_update().into()).collect(),
         );
+        let field_syntax = editor.finish().new_root().clone();
+        let field = ast::TupleField::cast(field_syntax)?;
         Some(field)
     });
     let tuple_fields = ast::make::tuple_field_list(tuple_fields);
@@ -1086,8 +1090,7 @@ pub struct $0Foo {
 }
 "#,
             r#"
-pub struct Foo(#[my_custom_attr]
-u32);
+pub struct Foo(#[my_custom_attr]u32);
 "#,
         );
     }
-- 
cgit 1.4.1-3-g733a5


From 803b4d262241b22a4dfe75fcec49eaf920e0816b Mon Sep 17 00:00:00 2001
From: Benoît du Garreau <benoit@dugarreau.fr>
Date: Wed, 9 Jul 2025 18:11:26 +0200
Subject: core: Remove `BorrowedCursor::init_ref` method

This method was not really useful: at no point one would only need to
read the initialized part of the cursor without mutating it.
---
 library/core/src/io/borrowed_buf.rs        | 10 ----------
 library/coretests/tests/io/borrowed_buf.rs |  4 +---
 library/std/src/io/mod.rs                  |  6 +++---
 3 files changed, 4 insertions(+), 16 deletions(-)

diff --git a/library/core/src/io/borrowed_buf.rs b/library/core/src/io/borrowed_buf.rs
index 854e03cf182..11ace041998 100644
--- a/library/core/src/io/borrowed_buf.rs
+++ b/library/core/src/io/borrowed_buf.rs
@@ -227,16 +227,6 @@ impl<'a> BorrowedCursor<'a> {
         self.buf.filled - self.start
     }
 
-    /// Returns a shared reference to the initialized portion of the cursor.
-    #[inline]
-    pub fn init_ref(&self) -> &[u8] {
-        // SAFETY: We only slice the initialized part of the buffer, which is always valid
-        unsafe {
-            let buf = self.buf.buf.get_unchecked(self.buf.filled..self.buf.init);
-            buf.assume_init_ref()
-        }
-    }
-
     /// Returns a mutable reference to the initialized portion of the cursor.
     #[inline]
     pub fn init_mut(&mut self) -> &mut [u8] {
diff --git a/library/coretests/tests/io/borrowed_buf.rs b/library/coretests/tests/io/borrowed_buf.rs
index fbd3864dcac..fe0e26f3e9d 100644
--- a/library/coretests/tests/io/borrowed_buf.rs
+++ b/library/coretests/tests/io/borrowed_buf.rs
@@ -61,7 +61,7 @@ fn clear() {
     assert_eq!(rbuf.filled().len(), 0);
     assert_eq!(rbuf.unfilled().capacity(), 16);
 
-    assert_eq!(rbuf.unfilled().init_ref(), [255; 16]);
+    assert_eq!(rbuf.unfilled().init_mut(), [255; 16]);
 }
 
 #[test]
@@ -142,7 +142,6 @@ fn cursor_set_init() {
     }
 
     assert_eq!(rbuf.init_len(), 8);
-    assert_eq!(rbuf.unfilled().init_ref().len(), 8);
     assert_eq!(rbuf.unfilled().init_mut().len(), 8);
     assert_eq!(rbuf.unfilled().uninit_mut().len(), 8);
     assert_eq!(unsafe { rbuf.unfilled().as_mut().len() }, 16);
@@ -160,7 +159,6 @@ fn cursor_set_init() {
     }
 
     assert_eq!(rbuf.init_len(), 12);
-    assert_eq!(rbuf.unfilled().init_ref().len(), 8);
     assert_eq!(rbuf.unfilled().init_mut().len(), 8);
     assert_eq!(rbuf.unfilled().uninit_mut().len(), 4);
     assert_eq!(unsafe { rbuf.unfilled().as_mut().len() }, 12);
diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
index 17c32d7a571..d351ee5e739 100644
--- a/library/std/src/io/mod.rs
+++ b/library/std/src/io/mod.rs
@@ -489,7 +489,7 @@ pub(crate) fn default_read_to_end<R: Read + ?Sized>(
             }
         };
 
-        let unfilled_but_initialized = cursor.init_ref().len();
+        let unfilled_but_initialized = cursor.init_mut().len();
         let bytes_read = cursor.written();
         let was_fully_initialized = read_buf.init_len() == buf_len;
 
@@ -3053,7 +3053,7 @@ impl<T: Read> Read for Take<T> {
             // The condition above guarantees that `self.limit` fits in `usize`.
             let limit = self.limit as usize;
 
-            let extra_init = cmp::min(limit, buf.init_ref().len());
+            let extra_init = cmp::min(limit, buf.init_mut().len());
 
             // SAFETY: no uninit data is written to ibuf
             let ibuf = unsafe { &mut buf.as_mut()[..limit] };
@@ -3068,7 +3068,7 @@ impl<T: Read> Read for Take<T> {
             let mut cursor = sliced_buf.unfilled();
             let result = self.inner.read_buf(cursor.reborrow());
 
-            let new_init = cursor.init_ref().len();
+            let new_init = cursor.init_mut().len();
             let filled = sliced_buf.len();
 
             // cursor / sliced_buf / ibuf must drop here
-- 
cgit 1.4.1-3-g733a5


From 34555f1b0b49e4fd944b2cb9c298f15b6b5da144 Mon Sep 17 00:00:00 2001
From: Benoît du Garreau <benoit@dugarreau.fr>
Date: Wed, 9 Jul 2025 18:11:26 +0200
Subject: core: Remove `BorrowedCursor::uninit_mut`

I assume that this method was there for completeness, but there is
hardly any useful use of it: the buffer it gave was not always connected
to the start of the cursor and its use required `unsafe` anyway to mark
the bytes as initialized.
---
 library/core/src/io/borrowed_buf.rs        | 13 +++----------
 library/coretests/tests/io/borrowed_buf.rs |  2 --
 2 files changed, 3 insertions(+), 12 deletions(-)

diff --git a/library/core/src/io/borrowed_buf.rs b/library/core/src/io/borrowed_buf.rs
index 11ace041998..bd468c9ee85 100644
--- a/library/core/src/io/borrowed_buf.rs
+++ b/library/core/src/io/borrowed_buf.rs
@@ -237,15 +237,6 @@ impl<'a> BorrowedCursor<'a> {
         }
     }
 
-    /// Returns a mutable reference to the uninitialized part of the cursor.
-    ///
-    /// It is safe to uninitialize any of these bytes.
-    #[inline]
-    pub fn uninit_mut(&mut self) -> &mut [MaybeUninit<u8>] {
-        // SAFETY: always in bounds
-        unsafe { self.buf.buf.get_unchecked_mut(self.buf.init..) }
-    }
-
     /// Returns a mutable reference to the whole cursor.
     ///
     /// # Safety
@@ -298,7 +289,9 @@ impl<'a> BorrowedCursor<'a> {
     /// Initializes all bytes in the cursor.
     #[inline]
     pub fn ensure_init(&mut self) -> &mut Self {
-        let uninit = self.uninit_mut();
+        // SAFETY: always in bounds and we never uninitialize these bytes.
+        let uninit = unsafe { self.buf.buf.get_unchecked_mut(self.buf.init..) };
+
         // SAFETY: 0 is a valid value for MaybeUninit<u8> and the length matches the allocation
         // since it is comes from a slice reference.
         unsafe {
diff --git a/library/coretests/tests/io/borrowed_buf.rs b/library/coretests/tests/io/borrowed_buf.rs
index fe0e26f3e9d..60829109d50 100644
--- a/library/coretests/tests/io/borrowed_buf.rs
+++ b/library/coretests/tests/io/borrowed_buf.rs
@@ -143,7 +143,6 @@ fn cursor_set_init() {
 
     assert_eq!(rbuf.init_len(), 8);
     assert_eq!(rbuf.unfilled().init_mut().len(), 8);
-    assert_eq!(rbuf.unfilled().uninit_mut().len(), 8);
     assert_eq!(unsafe { rbuf.unfilled().as_mut().len() }, 16);
 
     rbuf.unfilled().advance(4);
@@ -160,6 +159,5 @@ fn cursor_set_init() {
 
     assert_eq!(rbuf.init_len(), 12);
     assert_eq!(rbuf.unfilled().init_mut().len(), 8);
-    assert_eq!(rbuf.unfilled().uninit_mut().len(), 4);
     assert_eq!(unsafe { rbuf.unfilled().as_mut().len() }, 12);
 }
-- 
cgit 1.4.1-3-g733a5


From 65df66831f3fdb7f20a74e843a46bb90993221eb Mon Sep 17 00:00:00 2001
From: Benoît du Garreau <benoit@dugarreau.fr>
Date: Wed, 9 Jul 2025 18:11:27 +0200
Subject: core: Change `BorrowedCursor::written`'s origin

This enable removing the `start` field, so `BorrowedCursor` fits in a
single register. Because `written` is almost always used in difference
with another call, this changes nothing else in practice.
---
 library/core/src/io/borrowed_buf.rs        | 12 +++---------
 library/coretests/tests/io/borrowed_buf.rs |  2 +-
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/library/core/src/io/borrowed_buf.rs b/library/core/src/io/borrowed_buf.rs
index bd468c9ee85..b2f10d93b39 100644
--- a/library/core/src/io/borrowed_buf.rs
+++ b/library/core/src/io/borrowed_buf.rs
@@ -132,7 +132,6 @@ impl<'data> BorrowedBuf<'data> {
     #[inline]
     pub fn unfilled<'this>(&'this mut self) -> BorrowedCursor<'this> {
         BorrowedCursor {
-            start: self.filled,
             // SAFETY: we never assign into `BorrowedCursor::buf`, so treating its
             // lifetime covariantly is safe.
             buf: unsafe {
@@ -188,9 +187,6 @@ pub struct BorrowedCursor<'a> {
     // we create a `BorrowedCursor`. This is only safe if we never replace `buf` by assigning into
     // it, so don't do that!
     buf: &'a mut BorrowedBuf<'a>,
-    /// The length of the filled portion of the underlying buffer at the time of the cursor's
-    /// creation.
-    start: usize,
 }
 
 impl<'a> BorrowedCursor<'a> {
@@ -208,7 +204,6 @@ impl<'a> BorrowedCursor<'a> {
                     self.buf,
                 )
             },
-            start: self.start,
         }
     }
 
@@ -218,13 +213,12 @@ impl<'a> BorrowedCursor<'a> {
         self.buf.capacity() - self.buf.filled
     }
 
-    /// Returns the number of bytes written to this cursor since it was created from a `BorrowedBuf`.
+    /// Returns the number of bytes written to the `BorrowedBuf` this cursor was created from.
     ///
-    /// Note that if this cursor is a reborrowed clone of another, then the count returned is the
-    /// count written via either cursor, not the count since the cursor was reborrowed.
+    /// In particular, the count returned is shared by all reborrows of the cursor.
     #[inline]
     pub fn written(&self) -> usize {
-        self.buf.filled - self.start
+        self.buf.filled
     }
 
     /// Returns a mutable reference to the initialized portion of the cursor.
diff --git a/library/coretests/tests/io/borrowed_buf.rs b/library/coretests/tests/io/borrowed_buf.rs
index 60829109d50..869fc31fee9 100644
--- a/library/coretests/tests/io/borrowed_buf.rs
+++ b/library/coretests/tests/io/borrowed_buf.rs
@@ -124,7 +124,7 @@ fn reborrow_written() {
     assert_eq!(cursor2.written(), 32);
     assert_eq!(cursor.written(), 32);
 
-    assert_eq!(buf.unfilled().written(), 0);
+    assert_eq!(buf.unfilled().written(), 32);
     assert_eq!(buf.init_len(), 32);
     assert_eq!(buf.filled().len(), 32);
     let filled = buf.filled();
-- 
cgit 1.4.1-3-g733a5


From e4e9404ea24b92b1bdedc19117dbaa5f3c19510d Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 9 Jul 2025 19:19:51 +0300
Subject: Don't show `dyn` hint in a HRTB bound

---
 .../crates/ide/src/inlay_hints/implied_dyn_trait.rs   | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implied_dyn_trait.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implied_dyn_trait.rs
index cd01c075832..6fc534b9f0b 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implied_dyn_trait.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implied_dyn_trait.rs
@@ -17,8 +17,12 @@ pub(super) fn hints(
     let parent = path.syntax().parent()?;
     let range = match path {
         Either::Left(path) => {
-            let paren =
-                parent.ancestors().take_while(|it| ast::ParenType::can_cast(it.kind())).last();
+            let paren = parent
+                .ancestors()
+                .take_while(|it| {
+                    ast::ParenType::can_cast(it.kind()) || ast::ForType::can_cast(it.kind())
+                })
+                .last();
             let parent = paren.as_ref().and_then(|it| it.parent()).unwrap_or(parent);
             if ast::TypeBound::can_cast(parent.kind())
                 || ast::TypeAnchor::can_cast(parent.kind())
@@ -136,4 +140,15 @@ fn foo(
             "#]],
         );
     }
+
+    #[test]
+    fn hrtb_bound_does_not_add_dyn() {
+        check(
+            r#"
+//- minicore: fn
+fn test<F>(f: F) where F: for<'a> FnOnce(&'a i32) {}
+     // ^: Sized
+        "#,
+        );
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 46e95199b9a0d1e9800aa24b75b24d3434f55575 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 9 Jul 2025 19:29:11 +0300
Subject: Disable the `diagnostics_dont_block_typing` test on CI

It's failing to much. We need to fix it, but my changes are unlikely to be the cause.
---
 src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs b/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
index 59073af983b..1b940c70da6 100644
--- a/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
+++ b/src/tools/rust-analyzer/crates/rust-analyzer/tests/slow-tests/main.rs
@@ -880,7 +880,8 @@ fn main() {{}}
 
 #[test]
 fn diagnostics_dont_block_typing() {
-    if skip_slow_tests() {
+    if skip_slow_tests() || std::env::var("CI").is_ok() {
+        // FIXME: This test is failing too frequently (therefore we disable it on CI).
         return;
     }
 
-- 
cgit 1.4.1-3-g733a5


From 5339629b11901c2c1fbcb54fdb49afd4ed0b98ba Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Wed, 9 Jul 2025 18:30:32 +0200
Subject: Auto-add `S-waiting-on-author` when the PR is/switches to draft state

---
 triagebot.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 4e3dff219f1..006ed96cce9 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -535,6 +535,9 @@ trigger_files = [
 [autolabel."S-waiting-on-review"]
 new_pr = true
 
+[autolabel."S-waiting-on-author"]
+new_draft = true
+
 [autolabel."needs-triage"]
 new_issue = true
 exclude_labels = [
-- 
cgit 1.4.1-3-g733a5


From 5c0c794bee3b300e8da78ac3d90a26551c8665c3 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 9 Jul 2025 19:33:47 +0300
Subject: Put `dyn` inlay hints in their correct place in presence of
 parentheses

---
 .../crates/ide/src/inlay_hints/implied_dyn_trait.rs     | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implied_dyn_trait.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implied_dyn_trait.rs
index 6fc534b9f0b..0da1785234a 100644
--- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implied_dyn_trait.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/implied_dyn_trait.rs
@@ -38,7 +38,7 @@ pub(super) fn hints(
                 return None;
             }
             sema.resolve_trait(&path.path()?)?;
-            paren.map_or_else(|| path.syntax().text_range(), |it| it.text_range())
+            path.syntax().text_range()
         }
         Either::Right(dyn_) => {
             if dyn_.dyn_token().is_some() {
@@ -93,7 +93,7 @@ fn foo(_: &T,  _: for<'a> T) {}
 impl T {}
   // ^ dyn
 impl T for (T) {}
-        // ^^^ dyn
+         // ^ dyn
 impl T
 "#,
         );
@@ -116,7 +116,7 @@ fn foo(
     _: &mut (T + T)
     //       ^^^^^ dyn
     _: *mut (T),
-    //      ^^^ dyn
+    //       ^ dyn
 ) {}
 "#,
         );
@@ -151,4 +151,15 @@ fn test<F>(f: F) where F: for<'a> FnOnce(&'a i32) {}
         "#,
         );
     }
+
+    #[test]
+    fn with_parentheses() {
+        check(
+            r#"
+trait T {}
+fn foo(v: &(T)) {}
+         // ^ dyn
+        "#,
+        );
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 486ffda9dcd0d4ef0a09d81e6ce5f241e77526a1 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 12 Mar 2025 10:26:37 +0000
Subject: Add opaque TypeId handles for CTFE

---
 compiler/rustc_codegen_cranelift/src/constant.rs   | 13 ++++
 compiler/rustc_codegen_gcc/src/common.rs           | 10 ++-
 compiler/rustc_codegen_llvm/src/common.rs          | 18 +++--
 compiler/rustc_codegen_llvm/src/consts.rs          |  5 +-
 compiler/rustc_codegen_ssa/src/mir/operand.rs      |  2 +-
 compiler/rustc_const_eval/messages.ftl             |  2 +
 compiler/rustc_const_eval/src/errors.rs            |  6 +-
 .../rustc_const_eval/src/interpret/intrinsics.rs   | 79 +++++++++++++++++++-
 compiler/rustc_const_eval/src/interpret/memory.rs  | 30 +++++++-
 .../rustc_const_eval/src/interpret/projection.rs   |  6 +-
 .../rustc_const_eval/src/interpret/validity.rs     | 64 +++++++++--------
 compiler/rustc_hir/src/lang_items.rs               |  2 +
 compiler/rustc_hir_analysis/src/check/intrinsic.rs |  9 ++-
 compiler/rustc_middle/src/mir/interpret/error.rs   |  2 +
 compiler/rustc_middle/src/mir/interpret/mod.rs     | 33 +++++++--
 compiler/rustc_middle/src/mir/pretty.rs            |  1 +
 compiler/rustc_middle/src/ty/print/pretty.rs       |  1 +
 compiler/rustc_monomorphize/src/collector.rs       |  1 +
 compiler/rustc_passes/src/reachable.rs             |  1 +
 compiler/rustc_span/src/symbol.rs                  |  1 +
 compiler/stable_mir/src/mir/alloc.rs               |  3 +
 .../stable_mir/src/unstable/convert/stable/mir.rs  |  3 +
 library/core/Cargo.toml                            |  2 -
 library/core/src/any.rs                            | 84 +++++++++++++++-------
 library/core/src/intrinsics/mod.rs                 | 15 +++-
 library/coretests/tests/any.rs                     |  8 ---
 library/std/Cargo.toml                             |  2 -
 library/sysroot/Cargo.toml                         |  1 -
 tests/codegen/error-provide.rs                     |  6 +-
 tests/ui/const-generics/issues/issue-90318.rs      |  3 +-
 tests/ui/const-generics/issues/issue-90318.stderr  | 25 +------
 tests/ui/consts/const_cmp_type_id.rs               |  3 +-
 tests/ui/consts/const_cmp_type_id.stderr           | 20 +++---
 tests/ui/consts/const_transmute_type_id.rs         | 11 +++
 tests/ui/consts/const_transmute_type_id.stderr     | 12 ++++
 tests/ui/consts/const_transmute_type_id2.rs        | 14 ++++
 tests/ui/consts/const_transmute_type_id2.stderr    | 15 ++++
 tests/ui/consts/const_transmute_type_id3.rs        | 16 +++++
 tests/ui/consts/const_transmute_type_id3.stderr    | 15 ++++
 tests/ui/consts/const_transmute_type_id4.rs        | 16 +++++
 tests/ui/consts/const_transmute_type_id4.stderr    | 15 ++++
 tests/ui/consts/issue-73976-monomorphic.rs         |  2 +-
 tests/ui/consts/issue-73976-monomorphic.stderr     |  9 ---
 43 files changed, 438 insertions(+), 148 deletions(-)
 create mode 100644 tests/ui/consts/const_transmute_type_id.rs
 create mode 100644 tests/ui/consts/const_transmute_type_id.stderr
 create mode 100644 tests/ui/consts/const_transmute_type_id2.rs
 create mode 100644 tests/ui/consts/const_transmute_type_id2.stderr
 create mode 100644 tests/ui/consts/const_transmute_type_id3.rs
 create mode 100644 tests/ui/consts/const_transmute_type_id3.stderr
 create mode 100644 tests/ui/consts/const_transmute_type_id4.rs
 create mode 100644 tests/ui/consts/const_transmute_type_id4.stderr
 delete mode 100644 tests/ui/consts/issue-73976-monomorphic.stderr

diff --git a/compiler/rustc_codegen_cranelift/src/constant.rs b/compiler/rustc_codegen_cranelift/src/constant.rs
index ed06423b260..85adf0f3716 100644
--- a/compiler/rustc_codegen_cranelift/src/constant.rs
+++ b/compiler/rustc_codegen_cranelift/src/constant.rs
@@ -175,6 +175,13 @@ pub(crate) fn codegen_const_value<'tcx>(
                             fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
                         fx.bcx.ins().global_value(fx.pointer_type, local_data_id)
                     }
+                    GlobalAlloc::TypeId { .. } => {
+                        return CValue::const_val(
+                            fx,
+                            layout,
+                            ScalarInt::try_from_target_usize(offset.bytes(), fx.tcx).unwrap(),
+                        );
+                    }
                     GlobalAlloc::Static(def_id) => {
                         assert!(fx.tcx.is_static(def_id));
                         let data_id = data_id_for_static(
@@ -360,6 +367,7 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
                     GlobalAlloc::Memory(alloc) => alloc,
                     GlobalAlloc::Function { .. }
                     | GlobalAlloc::Static(_)
+                    | GlobalAlloc::TypeId { .. }
                     | GlobalAlloc::VTable(..) => {
                         unreachable!()
                     }
@@ -471,6 +479,11 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
                         .principal()
                         .map(|principal| tcx.instantiate_bound_regions_with_erased(principal)),
                 ),
+                GlobalAlloc::TypeId { .. } => {
+                    // Nothing to do, the bytes/offset of this pointer have already been written together with all other bytes,
+                    // so we just need to drop this provenance.
+                    continue;
+                }
                 GlobalAlloc::Static(def_id) => {
                     if tcx.codegen_fn_attrs(def_id).flags.contains(CodegenFnAttrFlags::THREAD_LOCAL)
                     {
diff --git a/compiler/rustc_codegen_gcc/src/common.rs b/compiler/rustc_codegen_gcc/src/common.rs
index 32713eb56c6..28848ca6184 100644
--- a/compiler/rustc_codegen_gcc/src/common.rs
+++ b/compiler/rustc_codegen_gcc/src/common.rs
@@ -1,7 +1,6 @@
 use gccjit::{LValue, RValue, ToRValue, Type};
-use rustc_abi as abi;
-use rustc_abi::HasDataLayout;
 use rustc_abi::Primitive::Pointer;
+use rustc_abi::{self as abi, HasDataLayout};
 use rustc_codegen_ssa::traits::{
     BaseTypeCodegenMethods, ConstCodegenMethods, MiscCodegenMethods, StaticCodegenMethods,
 };
@@ -282,6 +281,13 @@ impl<'gcc, 'tcx> ConstCodegenMethods for CodegenCx<'gcc, 'tcx> {
                         let init = self.const_data_from_alloc(alloc);
                         self.static_addr_of(init, alloc.inner().align, None)
                     }
+                    GlobalAlloc::TypeId { .. } => {
+                        let val = self.const_usize(offset.bytes());
+                        // This is still a variable of pointer type, even though we only use the provenance
+                        // of that pointer in CTFE and Miri. But to make LLVM's type system happy,
+                        // we need an int-to-ptr cast here (it doesn't matter at all which provenance that picks).
+                        return self.context.new_cast(None, val, ty);
+                    }
                     GlobalAlloc::Static(def_id) => {
                         assert!(self.tcx.is_static(def_id));
                         self.get_static(def_id).get_address(None)
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
index 92f38565eef..b9b5c776d86 100644
--- a/compiler/rustc_codegen_llvm/src/common.rs
+++ b/compiler/rustc_codegen_llvm/src/common.rs
@@ -3,9 +3,8 @@
 use std::borrow::Borrow;
 
 use libc::{c_char, c_uint};
-use rustc_abi as abi;
-use rustc_abi::HasDataLayout;
 use rustc_abi::Primitive::Pointer;
+use rustc_abi::{self as abi, HasDataLayout as _};
 use rustc_ast::Mutability;
 use rustc_codegen_ssa::common::TypeKind;
 use rustc_codegen_ssa::traits::*;
@@ -284,7 +283,8 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                                 self.const_bitcast(llval, llty)
                             };
                         } else {
-                            let init = const_alloc_to_llvm(self, alloc, /*static*/ false);
+                            let init =
+                                const_alloc_to_llvm(self, alloc.inner(), /*static*/ false);
                             let alloc = alloc.inner();
                             let value = match alloc.mutability {
                                 Mutability::Mut => self.static_addr_of_mut(init, alloc.align, None),
@@ -316,15 +316,19 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                                 }),
                             )))
                             .unwrap_memory();
-                        let init = const_alloc_to_llvm(self, alloc, /*static*/ false);
-                        let value = self.static_addr_of_impl(init, alloc.inner().align, None);
-                        value
+                        let init = const_alloc_to_llvm(self, alloc.inner(), /*static*/ false);
+                        self.static_addr_of_impl(init, alloc.inner().align, None)
                     }
                     GlobalAlloc::Static(def_id) => {
                         assert!(self.tcx.is_static(def_id));
                         assert!(!self.tcx.is_thread_local_static(def_id));
                         self.get_static(def_id)
                     }
+                    GlobalAlloc::TypeId { .. } => {
+                        // Drop the provenance, the offset contains the bytes of the hash
+                        let llval = self.const_usize(offset.bytes());
+                        return unsafe { llvm::LLVMConstIntToPtr(llval, llty) };
+                    }
                 };
                 let base_addr_space = global_alloc.address_space(self);
                 let llval = unsafe {
@@ -346,7 +350,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
     }
 
     fn const_data_from_alloc(&self, alloc: ConstAllocation<'_>) -> Self::Value {
-        const_alloc_to_llvm(self, alloc, /*static*/ false)
+        const_alloc_to_llvm(self, alloc.inner(), /*static*/ false)
     }
 
     fn const_ptr_byte_offset(&self, base_addr: Self::Value, offset: abi::Size) -> Self::Value {
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 28f5282c6b0..21524fd2eb8 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -27,10 +27,9 @@ use crate::{base, debuginfo};
 
 pub(crate) fn const_alloc_to_llvm<'ll>(
     cx: &CodegenCx<'ll, '_>,
-    alloc: ConstAllocation<'_>,
+    alloc: &Allocation,
     is_static: bool,
 ) -> &'ll Value {
-    let alloc = alloc.inner();
     // We expect that callers of const_alloc_to_llvm will instead directly codegen a pointer or
     // integer for any &ZST where the ZST is a constant (i.e. not a static). We should never be
     // producing empty LLVM allocations as they're just adding noise to binaries and forcing less
@@ -141,7 +140,7 @@ fn codegen_static_initializer<'ll, 'tcx>(
     def_id: DefId,
 ) -> Result<(&'ll Value, ConstAllocation<'tcx>), ErrorHandled> {
     let alloc = cx.tcx.eval_static_initializer(def_id)?;
-    Ok((const_alloc_to_llvm(cx, alloc, /*static*/ true), alloc))
+    Ok((const_alloc_to_llvm(cx, alloc.inner(), /*static*/ true), alloc))
 }
 
 fn set_global_alignment<'ll>(cx: &CodegenCx<'ll, '_>, gv: &'ll Value, mut align: Align) {
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index 2896dfd5463..a639803ea60 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -186,7 +186,7 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
         offset: Size,
     ) -> Self {
         let alloc_align = alloc.inner().align;
-        assert!(alloc_align >= layout.align.abi);
+        assert!(alloc_align >= layout.align.abi, "{alloc_align:?} < {:?}", layout.align.abi);
 
         let read_scalar = |start, size, s: abi::Scalar, ty| {
             match alloc.0.read_scalar(
diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index 22a1894ee72..b767ca9a3c2 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -78,6 +78,8 @@ const_eval_dealloc_kind_mismatch =
 
 const_eval_deref_function_pointer =
     accessing {$allocation} which contains a function
+const_eval_deref_typeid_pointer =
+    accessing {$allocation} which contains a `TypeId`
 const_eval_deref_vtable_pointer =
     accessing {$allocation} which contains a vtable
 const_eval_division_by_zero =
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index 9133a5fc8ef..49cd7138748 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -475,6 +475,7 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
             WriteToReadOnly(_) => const_eval_write_to_read_only,
             DerefFunctionPointer(_) => const_eval_deref_function_pointer,
             DerefVTablePointer(_) => const_eval_deref_vtable_pointer,
+            DerefTypeIdPointer(_) => const_eval_deref_typeid_pointer,
             InvalidBool(_) => const_eval_invalid_bool,
             InvalidChar(_) => const_eval_invalid_char,
             InvalidTag(_) => const_eval_invalid_tag,
@@ -588,7 +589,10 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
                 diag.arg("has", has.bytes());
                 diag.arg("msg", format!("{msg:?}"));
             }
-            WriteToReadOnly(alloc) | DerefFunctionPointer(alloc) | DerefVTablePointer(alloc) => {
+            WriteToReadOnly(alloc)
+            | DerefFunctionPointer(alloc)
+            | DerefVTablePointer(alloc)
+            | DerefTypeIdPointer(alloc) => {
                 diag.arg("allocation", alloc);
             }
             InvalidBool(b) => {
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 378ed6d0e10..ee5382af0b2 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -4,8 +4,10 @@
 
 use std::assert_matches::assert_matches;
 
-use rustc_abi::Size;
+use rustc_abi::{FieldIdx, Size};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
+use rustc_ast::Mutability;
+use rustc_middle::mir::interpret::{AllocId, AllocInit, alloc_range};
 use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{Ty, TyCtxt};
@@ -29,6 +31,37 @@ pub(crate) fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ConstAll
     tcx.mk_const_alloc(alloc)
 }
 
+pub(crate) fn alloc_type_id<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> AllocId {
+    let size = Size::from_bytes(16);
+    let align = tcx.data_layout.pointer_align();
+    let mut alloc = Allocation::new(size, *align, AllocInit::Uninit, ());
+    let ptr_size = tcx.data_layout.pointer_size();
+    let type_id_hash = tcx.type_id_hash(ty).as_u128();
+    alloc
+        .write_scalar(
+            &tcx,
+            alloc_range(Size::ZERO, Size::from_bytes(16)),
+            Scalar::from_u128(type_id_hash),
+        )
+        .unwrap();
+
+    // Give the first pointer-size bytes provenance that knows about the type id
+
+    let alloc_id = tcx.reserve_and_set_type_id_alloc(ty);
+    let offset = alloc
+        .read_scalar(&tcx, alloc_range(Size::ZERO, ptr_size), false)
+        .unwrap()
+        .to_target_usize(&tcx)
+        .unwrap();
+    let ptr = Pointer::new(alloc_id.into(), Size::from_bytes(offset));
+    let val = Scalar::from_pointer(ptr, &tcx);
+    alloc.write_scalar(&tcx, alloc_range(Size::ZERO, ptr_size), val).unwrap();
+
+    alloc.mutability = Mutability::Not;
+
+    tcx.reserve_and_set_memory_alloc(tcx.mk_const_alloc(alloc))
+}
+
 impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// Returns `true` if emulation happened.
     /// Here we implement the intrinsics that are common to all Miri instances; individual machines can add their own
@@ -63,10 +96,52 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             sym::type_id => {
                 let tp_ty = instance.args.type_at(0);
                 ensure_monomorphic_enough(tcx, tp_ty)?;
-                let val = ConstValue::from_u128(tcx.type_id_hash(tp_ty).as_u128());
+                let alloc_id = alloc_type_id(tcx, tp_ty);
+                let val = ConstValue::Indirect { alloc_id, offset: Size::ZERO };
                 let val = self.const_val_to_op(val, dest.layout.ty, Some(dest.layout))?;
                 self.copy_op(&val, dest)?;
             }
+            sym::type_id_eq => {
+                // Both operands are `TypeId`, which is a newtype around an array of pointers.
+                // Project until we have the array elements.
+                let a_fields = self.project_field(&args[0], FieldIdx::ZERO)?;
+                let b_fields = self.project_field(&args[1], FieldIdx::ZERO)?;
+
+                let mut a_fields = self.project_array_fields(&a_fields)?;
+                let mut b_fields = self.project_array_fields(&b_fields)?;
+
+                let (_idx, a) = a_fields
+                    .next(self)?
+                    .expect("we know the layout of TypeId has at least 2 array elements");
+                let a = self.deref_pointer(&a)?;
+                let (a, offset_a) = self.get_ptr_type_id(a.ptr())?;
+
+                let (_idx, b) = b_fields
+                    .next(self)?
+                    .expect("we know the layout of TypeId has at least 2 array elements");
+                let b = self.deref_pointer(&b)?;
+                let (b, offset_b) = self.get_ptr_type_id(b.ptr())?;
+
+                let provenance_matches = a == b;
+
+                let mut eq_id = offset_a == offset_b;
+
+                while let Some((_, a)) = a_fields.next(self)? {
+                    let (_, b) = b_fields.next(self)?.unwrap();
+
+                    let a = self.read_target_usize(&a)?;
+                    let b = self.read_target_usize(&b)?;
+                    eq_id &= a == b;
+                }
+
+                if !eq_id && provenance_matches {
+                    throw_ub_format!(
+                        "type_id_eq: one of the TypeId arguments is invalid, the hash does not match the type it represents"
+                    )
+                }
+
+                self.write_scalar(Scalar::from_bool(provenance_matches), dest)?;
+            }
             sym::variant_count => {
                 let tp_ty = instance.args.type_at(0);
                 let ty = match tp_ty.kind() {
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 524023b8104..bb301600135 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -15,9 +15,9 @@ use std::{fmt, ptr};
 use rustc_abi::{Align, HasDataLayout, Size};
 use rustc_ast::Mutability;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
-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::{
@@ -346,6 +346,13 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                         kind = "vtable",
                     )
                 }
+                Some(GlobalAlloc::TypeId { .. }) => {
+                    err_ub_custom!(
+                        fluent::const_eval_invalid_dealloc,
+                        alloc_id = alloc_id,
+                        kind = "typeid",
+                    )
+                }
                 Some(GlobalAlloc::Static(..) | GlobalAlloc::Memory(..)) => {
                     err_ub_custom!(
                         fluent::const_eval_invalid_dealloc,
@@ -615,6 +622,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             }
             Some(GlobalAlloc::Function { .. }) => throw_ub!(DerefFunctionPointer(id)),
             Some(GlobalAlloc::VTable(..)) => throw_ub!(DerefVTablePointer(id)),
+            Some(GlobalAlloc::TypeId { .. }) => throw_ub!(DerefTypeIdPointer(id)),
             None => throw_ub!(PointerUseAfterFree(id, CheckInAllocMsg::MemoryAccess)),
             Some(GlobalAlloc::Static(def_id)) => {
                 assert!(self.tcx.is_static(def_id));
@@ -896,7 +904,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             let (size, align) = global_alloc.size_and_align(*self.tcx, self.typing_env);
             let mutbl = global_alloc.mutability(*self.tcx, self.typing_env);
             let kind = match global_alloc {
-                GlobalAlloc::Static { .. } | GlobalAlloc::Memory { .. } => AllocKind::LiveData,
+                GlobalAlloc::TypeId { .. }
+                | GlobalAlloc::Static { .. }
+                | GlobalAlloc::Memory { .. } => AllocKind::LiveData,
                 GlobalAlloc::Function { .. } => bug!("We already checked function pointers above"),
                 GlobalAlloc::VTable { .. } => AllocKind::VTable,
             };
@@ -936,6 +946,19 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         }
     }
 
+    /// Takes a pointer that is the first chunk of a `TypeId` and return the type that its
+    /// provenance refers to, as well as the segment of the hash that this pointer covers.
+    pub fn get_ptr_type_id(
+        &self,
+        ptr: Pointer<Option<M::Provenance>>,
+    ) -> InterpResult<'tcx, (Ty<'tcx>, Size)> {
+        let (alloc_id, offset, _meta) = self.ptr_get_alloc_id(ptr, 0)?;
+        let GlobalAlloc::TypeId { ty } = self.tcx.global_alloc(alloc_id) else {
+            throw_ub_format!("type_id_eq: `TypeId` provenance is not a type id")
+        };
+        interp_ok((ty, offset))
+    }
+
     pub fn get_ptr_fn(
         &self,
         ptr: Pointer<Option<M::Provenance>>,
@@ -1197,6 +1220,9 @@ impl<'a, 'tcx, M: Machine<'tcx>> std::fmt::Debug for DumpAllocs<'a, 'tcx, M> {
                         Some(GlobalAlloc::VTable(ty, dyn_ty)) => {
                             write!(fmt, " (vtable: impl {dyn_ty} for {ty})")?;
                         }
+                        Some(GlobalAlloc::TypeId { ty }) => {
+                            write!(fmt, " (typeid for {ty})")?;
+                        }
                         Some(GlobalAlloc::Static(did)) => {
                             write!(fmt, " (static: {})", self.ecx.tcx.def_path_str(did))?;
                         }
diff --git a/compiler/rustc_const_eval/src/interpret/projection.rs b/compiler/rustc_const_eval/src/interpret/projection.rs
index 306697d4ec9..f72c4418081 100644
--- a/compiler/rustc_const_eval/src/interpret/projection.rs
+++ b/compiler/rustc_const_eval/src/interpret/projection.rs
@@ -296,7 +296,11 @@ where
         base: &'a P,
     ) -> InterpResult<'tcx, ArrayIterator<'a, 'tcx, M::Provenance, P>> {
         let abi::FieldsShape::Array { stride, .. } = base.layout().fields else {
-            span_bug!(self.cur_span(), "project_array_fields: expected an array layout");
+            span_bug!(
+                self.cur_span(),
+                "project_array_fields: expected an array layout, got {:#?}",
+                base.layout()
+            );
         };
         let len = base.len(self)?;
         let field_layout = base.layout().field(self, 0);
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index fc4d13af8c4..fc44490c96d 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -571,40 +571,42 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
                     let alloc_actual_mutbl =
                         global_alloc.mutability(*self.ecx.tcx, self.ecx.typing_env);
 
-                    if let GlobalAlloc::Static(did) = global_alloc {
-                        let DefKind::Static { nested, .. } = self.ecx.tcx.def_kind(did) else {
-                            bug!()
-                        };
-                        // Special handling for pointers to statics (irrespective of their type).
-                        assert!(!self.ecx.tcx.is_thread_local_static(did));
-                        assert!(self.ecx.tcx.is_static(did));
-                        // Mode-specific checks
-                        match ctfe_mode {
-                            CtfeValidationMode::Static { .. }
-                            | CtfeValidationMode::Promoted { .. } => {
-                                // We skip recursively checking other statics. These statics must be sound by
-                                // themselves, and the only way to get broken statics here is by using
-                                // unsafe code.
-                                // The reasons we don't check other statics is twofold. For one, in all
-                                // sound cases, the static was already validated on its own, and second, we
-                                // trigger cycle errors if we try to compute the value of the other static
-                                // and that static refers back to us (potentially through a promoted).
-                                // This could miss some UB, but that's fine.
-                                // We still walk nested allocations, as they are fundamentally part of this validation run.
-                                // This means we will also recurse into nested statics of *other*
-                                // statics, even though we do not recurse into other statics directly.
-                                // That's somewhat inconsistent but harmless.
-                                skip_recursive_check = !nested;
-                            }
-                            CtfeValidationMode::Const { .. } => {
-                                // If this is mutable memory or an `extern static`, there's no point in checking it -- we'd
-                                // just get errors trying to read the value.
-                                if alloc_actual_mutbl.is_mut() || self.ecx.tcx.is_foreign_item(did)
-                                {
-                                    skip_recursive_check = true;
+                    match global_alloc {
+                        GlobalAlloc::Static(did) => {
+                            let DefKind::Static { nested, .. } = self.ecx.tcx.def_kind(did) else {
+                                bug!()
+                            };
+                            assert!(!self.ecx.tcx.is_thread_local_static(did));
+                            assert!(self.ecx.tcx.is_static(did));
+                            match ctfe_mode {
+                                CtfeValidationMode::Static { .. }
+                                | CtfeValidationMode::Promoted { .. } => {
+                                    // We skip recursively checking other statics. These statics must be sound by
+                                    // themselves, and the only way to get broken statics here is by using
+                                    // unsafe code.
+                                    // The reasons we don't check other statics is twofold. For one, in all
+                                    // sound cases, the static was already validated on its own, and second, we
+                                    // trigger cycle errors if we try to compute the value of the other static
+                                    // and that static refers back to us (potentially through a promoted).
+                                    // This could miss some UB, but that's fine.
+                                    // We still walk nested allocations, as they are fundamentally part of this validation run.
+                                    // This means we will also recurse into nested statics of *other*
+                                    // statics, even though we do not recurse into other statics directly.
+                                    // That's somewhat inconsistent but harmless.
+                                    skip_recursive_check = !nested;
+                                }
+                                CtfeValidationMode::Const { .. } => {
+                                    // If this is mutable memory or an `extern static`, there's no point in checking it -- we'd
+                                    // just get errors trying to read the value.
+                                    if alloc_actual_mutbl.is_mut()
+                                        || self.ecx.tcx.is_foreign_item(did)
+                                    {
+                                        skip_recursive_check = true;
+                                    }
                                 }
                             }
                         }
+                        _ => (),
                     }
 
                     // If this allocation has size zero, there is no actual mutability here.
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index c11db63ba11..6347f1bfa71 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -274,6 +274,8 @@ language_item_table! {
     PartialOrd,              sym::partial_ord,         partial_ord_trait,          Target::Trait,          GenericRequirement::Exact(1);
     CVoid,                   sym::c_void,              c_void,                     Target::Enum,           GenericRequirement::None;
 
+    TypeId,                  sym::type_id,             type_id,                    Target::Struct,         GenericRequirement::None;
+
     // A number of panic-related lang items. The `panic` item corresponds to divide-by-zero and
     // various panic cases with `match`. The `panic_bounds_check` item is for indexing arrays.
     //
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index cebf7d1b532..e3532ade32f 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -93,6 +93,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::three_way_compare
         | sym::discriminant_value
         | sym::type_id
+        | sym::type_id_eq
         | sym::select_unpredictable
         | sym::cold_path
         | sym::ptr_guaranteed_cmp
@@ -220,7 +221,13 @@ pub(crate) fn check_intrinsic_type(
         sym::needs_drop => (1, 0, vec![], tcx.types.bool),
 
         sym::type_name => (1, 0, vec![], Ty::new_static_str(tcx)),
-        sym::type_id => (1, 0, vec![], tcx.types.u128),
+        sym::type_id => {
+            (1, 0, vec![], tcx.type_of(tcx.lang_items().type_id().unwrap()).instantiate_identity())
+        }
+        sym::type_id_eq => {
+            let type_id = tcx.type_of(tcx.lang_items().type_id().unwrap()).instantiate_identity();
+            (0, 0, vec![type_id, type_id], tcx.types.bool)
+        }
         sym::offset => (2, 0, vec![param(0), param(1)], param(0)),
         sym::arith_offset => (
             1,
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
index 8acb8fa9f80..71e0c943fbb 100644
--- a/compiler/rustc_middle/src/mir/interpret/error.rs
+++ b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -392,6 +392,8 @@ pub enum UndefinedBehaviorInfo<'tcx> {
     DerefFunctionPointer(AllocId),
     /// Trying to access the data behind a vtable pointer.
     DerefVTablePointer(AllocId),
+    /// Trying to access the actual type id.
+    DerefTypeIdPointer(AllocId),
     /// Using a non-boolean `u8` as bool.
     InvalidBool(u8),
     /// Using a non-character `u32` as character.
diff --git a/compiler/rustc_middle/src/mir/interpret/mod.rs b/compiler/rustc_middle/src/mir/interpret/mod.rs
index 0b2645013ba..bed99a4ff2a 100644
--- a/compiler/rustc_middle/src/mir/interpret/mod.rs
+++ b/compiler/rustc_middle/src/mir/interpret/mod.rs
@@ -103,6 +103,7 @@ enum AllocDiscriminant {
     Fn,
     VTable,
     Static,
+    Type,
 }
 
 pub fn specialized_encode_alloc_id<'tcx, E: TyEncoder<'tcx>>(
@@ -127,6 +128,11 @@ pub fn specialized_encode_alloc_id<'tcx, E: TyEncoder<'tcx>>(
             ty.encode(encoder);
             poly_trait_ref.encode(encoder);
         }
+        GlobalAlloc::TypeId { ty } => {
+            trace!("encoding {alloc_id:?} with {ty:#?}");
+            AllocDiscriminant::Type.encode(encoder);
+            ty.encode(encoder);
+        }
         GlobalAlloc::Static(did) => {
             assert!(!tcx.is_thread_local_static(did));
             // References to statics doesn't need to know about their allocations,
@@ -228,6 +234,12 @@ impl<'s> AllocDecodingSession<'s> {
                 trace!("decoded vtable alloc instance: {ty:?}, {poly_trait_ref:?}");
                 decoder.interner().reserve_and_set_vtable_alloc(ty, poly_trait_ref, CTFE_ALLOC_SALT)
             }
+            AllocDiscriminant::Type => {
+                trace!("creating typeid alloc ID");
+                let ty = Decodable::decode(decoder);
+                trace!("decoded typid: {ty:?}");
+                decoder.interner().reserve_and_set_type_id_alloc(ty)
+            }
             AllocDiscriminant::Static => {
                 trace!("creating extern static alloc ID");
                 let did = <DefId as Decodable<D>>::decode(decoder);
@@ -258,6 +270,9 @@ pub enum GlobalAlloc<'tcx> {
     Static(DefId),
     /// The alloc ID points to memory.
     Memory(ConstAllocation<'tcx>),
+    /// The first pointer-sized segment of a type id. On 64 bit systems, the 128 bit type id
+    /// is split into two segments, on 32 bit systems there are 4 segments, and so on.
+    TypeId { ty: Ty<'tcx> },
 }
 
 impl<'tcx> GlobalAlloc<'tcx> {
@@ -296,9 +311,10 @@ impl<'tcx> GlobalAlloc<'tcx> {
     pub fn address_space(&self, cx: &impl HasDataLayout) -> AddressSpace {
         match self {
             GlobalAlloc::Function { .. } => cx.data_layout().instruction_address_space,
-            GlobalAlloc::Static(..) | GlobalAlloc::Memory(..) | GlobalAlloc::VTable(..) => {
-                AddressSpace::ZERO
-            }
+            GlobalAlloc::TypeId { .. }
+            | GlobalAlloc::Static(..)
+            | GlobalAlloc::Memory(..)
+            | GlobalAlloc::VTable(..) => AddressSpace::ZERO,
         }
     }
 
@@ -334,7 +350,7 @@ impl<'tcx> GlobalAlloc<'tcx> {
                 }
             }
             GlobalAlloc::Memory(alloc) => alloc.inner().mutability,
-            GlobalAlloc::Function { .. } | GlobalAlloc::VTable(..) => {
+            GlobalAlloc::TypeId { .. } | GlobalAlloc::Function { .. } | GlobalAlloc::VTable(..) => {
                 // These are immutable.
                 Mutability::Not
             }
@@ -380,8 +396,10 @@ impl<'tcx> GlobalAlloc<'tcx> {
             GlobalAlloc::Function { .. } => (Size::ZERO, Align::ONE),
             GlobalAlloc::VTable(..) => {
                 // No data to be accessed here. But vtables are pointer-aligned.
-                return (Size::ZERO, tcx.data_layout.pointer_align().abi);
+                (Size::ZERO, tcx.data_layout.pointer_align().abi)
             }
+            // Fake allocation, there's nothing to access here
+            GlobalAlloc::TypeId { .. } => (Size::ZERO, Align::ONE),
         }
     }
 }
@@ -487,6 +505,11 @@ impl<'tcx> TyCtxt<'tcx> {
         self.reserve_and_set_dedup(GlobalAlloc::VTable(ty, dyn_ty), salt)
     }
 
+    /// Generates an [AllocId] for a [core::any::TypeId]. Will get deduplicated.
+    pub fn reserve_and_set_type_id_alloc(self, ty: Ty<'tcx>) -> AllocId {
+        self.reserve_and_set_dedup(GlobalAlloc::TypeId { ty }, 0)
+    }
+
     /// Interns the `Allocation` and return a new `AllocId`, even if there's already an identical
     /// `Allocation` with a different `AllocId`.
     /// Statics with identical content will still point to the same `Allocation`, i.e.,
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index e9f3fb6ac8d..8e403dfddae 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1621,6 +1621,7 @@ pub fn write_allocations<'tcx>(
             Some(GlobalAlloc::VTable(ty, dyn_ty)) => {
                 write!(w, " (vtable: impl {dyn_ty} for {ty})")?
             }
+            Some(GlobalAlloc::TypeId { ty }) => write!(w, " (typeid for {ty})")?,
             Some(GlobalAlloc::Static(did)) if !tcx.is_foreign_item(did) => {
                 write!(w, " (static: {}", tcx.def_path_str(did))?;
                 if body.phase <= MirPhase::Runtime(RuntimePhase::PostCleanup)
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 4e078847815..7c48a4b0885 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1773,6 +1773,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                         }
                         Some(GlobalAlloc::Function { .. }) => p!("<function>"),
                         Some(GlobalAlloc::VTable(..)) => p!("<vtable>"),
+                        Some(GlobalAlloc::TypeId { .. }) => p!("<typeid>"),
                         None => p!("<dangling pointer>"),
                     }
                     return Ok(());
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 131064f9832..91c8e64ce9a 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -1219,6 +1219,7 @@ fn collect_alloc<'tcx>(tcx: TyCtxt<'tcx>, alloc_id: AllocId, output: &mut MonoIt
             ));
             collect_alloc(tcx, alloc_id, output)
         }
+        GlobalAlloc::TypeId { .. } => {}
     }
 }
 
diff --git a/compiler/rustc_passes/src/reachable.rs b/compiler/rustc_passes/src/reachable.rs
index 7e15267a953..b49e8118fe3 100644
--- a/compiler/rustc_passes/src/reachable.rs
+++ b/compiler/rustc_passes/src/reachable.rs
@@ -325,6 +325,7 @@ impl<'tcx> ReachableContext<'tcx> {
                         self.visit(args);
                     }
                 }
+                GlobalAlloc::TypeId { ty, .. } => self.visit(ty),
                 GlobalAlloc::Memory(alloc) => self.propagate_from_alloc(alloc),
             }
         }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 09f01d8704e..4df91cc3429 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -2194,6 +2194,7 @@ symbols! {
         type_changing_struct_update,
         type_const,
         type_id,
+        type_id_eq,
         type_ir,
         type_ir_infer_ctxt_like,
         type_ir_inherent,
diff --git a/compiler/stable_mir/src/mir/alloc.rs b/compiler/stable_mir/src/mir/alloc.rs
index 0d45e59885c..9a94551f3ec 100644
--- a/compiler/stable_mir/src/mir/alloc.rs
+++ b/compiler/stable_mir/src/mir/alloc.rs
@@ -23,6 +23,9 @@ pub enum GlobalAlloc {
     Static(StaticDef),
     /// The alloc ID points to memory.
     Memory(Allocation),
+    /// The first pointer-sized segment of a type id. On 64 bit systems, the 128 bit type id
+    /// is split into two segments, on 32 bit systems there are 4 segments, and so on.
+    TypeId { ty: Ty },
 }
 
 impl From<AllocId> for GlobalAlloc {
diff --git a/compiler/stable_mir/src/unstable/convert/stable/mir.rs b/compiler/stable_mir/src/unstable/convert/stable/mir.rs
index f6f4706e40b..ad39fc37600 100644
--- a/compiler/stable_mir/src/unstable/convert/stable/mir.rs
+++ b/compiler/stable_mir/src/unstable/convert/stable/mir.rs
@@ -864,6 +864,9 @@ impl<'tcx> Stable<'tcx> for mir::interpret::GlobalAlloc<'tcx> {
             mir::interpret::GlobalAlloc::Memory(alloc) => {
                 GlobalAlloc::Memory(alloc.stable(tables, cx))
             }
+            mir::interpret::GlobalAlloc::TypeId { ty } => {
+                GlobalAlloc::TypeId { ty: ty.stable(tables, cx) }
+            }
         }
     }
 }
diff --git a/library/core/Cargo.toml b/library/core/Cargo.toml
index f88661ee001..3e34e03a61e 100644
--- a/library/core/Cargo.toml
+++ b/library/core/Cargo.toml
@@ -23,8 +23,6 @@ optimize_for_size = []
 # Make `RefCell` store additional debugging information, which is printed out when
 # a borrow error occurs
 debug_refcell = []
-# Make `TypeId` store a reference to the name of the type, so that it can print that name.
-debug_typeid = []
 
 [lints.rust.unexpected_cfgs]
 level = "warn"
diff --git a/library/core/src/any.rs b/library/core/src/any.rs
index 01dce114592..39cdf6efda0 100644
--- a/library/core/src/any.rs
+++ b/library/core/src/any.rs
@@ -707,19 +707,52 @@ impl dyn Any + Send + Sync {
 /// ```
 #[derive(Clone, Copy, Eq, PartialOrd, Ord)]
 #[stable(feature = "rust1", since = "1.0.0")]
+#[lang = "type_id"]
 pub struct TypeId {
-    // We avoid using `u128` because that imposes higher alignment requirements on many platforms.
-    // See issue #115620 for more information.
-    t: (u64, u64),
-    #[cfg(feature = "debug_typeid")]
-    name: &'static str,
+    /// This needs to be an array of pointers, since there is provenance
+    /// in the first array field. This provenance knows exactly which type
+    /// the TypeId actually is, allowing CTFE and miri to operate based off it.
+    /// At runtime all the pointers in the array contain bits of the hash, making
+    /// the entire `TypeId` actually just be a `u128` hash of the type.
+    pub(crate) data: [*const (); 16 / size_of::<*const ()>()],
 }
 
+// SAFETY: the raw pointer is always an integer
 #[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq for TypeId {
+unsafe impl Send for TypeId {}
+// SAFETY: the raw pointer is always an integer
+#[stable(feature = "rust1", since = "1.0.0")]
+unsafe impl Sync for TypeId {}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_const_unstable(feature = "const_type_id", issue = "77125")]
+impl const PartialEq for TypeId {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
-        self.t == other.t
+        #[cfg(miri)]
+        return crate::intrinsics::type_id_eq(*self, *other);
+        #[cfg(not(miri))]
+        {
+            let this = self;
+            crate::intrinsics::const_eval_select!(
+                @capture { this: &TypeId, other: &TypeId } -> bool:
+                if const {
+                    crate::intrinsics::type_id_eq(*this, *other)
+                } else {
+                    // Ideally we would just invoke `type_id_eq` unconditionally here,
+                    // but since we do not MIR inline intrinsics, because backends
+                    // may want to override them (and miri does!), MIR opts do not
+                    // clean up this call sufficiently for LLVM to turn repeated calls
+                    // of `TypeId` comparisons against one specific `TypeId` into
+                    // a lookup table.
+                    // SAFETY: We know that at runtime none of the bits have provenance and all bits
+                    // are initialized. So we can just convert the whole thing to a `u128` and compare that.
+                    unsafe {
+                        crate::mem::transmute::<_, u128>(*this) == crate::mem::transmute::<_, u128>(*other)
+                    }
+                }
+            )
+        }
     }
 }
 
@@ -742,19 +775,19 @@ impl TypeId {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_const_unstable(feature = "const_type_id", issue = "77125")]
     pub const fn of<T: ?Sized + 'static>() -> TypeId {
-        let t: u128 = const { intrinsics::type_id::<T>() };
-        let t1 = (t >> 64) as u64;
-        let t2 = t as u64;
-
-        TypeId {
-            t: (t1, t2),
-            #[cfg(feature = "debug_typeid")]
-            name: type_name::<T>(),
-        }
+        const { intrinsics::type_id::<T>() }
     }
 
     fn as_u128(self) -> u128 {
-        u128::from(self.t.0) << 64 | u128::from(self.t.1)
+        let mut bytes = [0; 16];
+
+        // This is a provenance-stripping memcpy.
+        for (i, chunk) in self.data.iter().copied().enumerate() {
+            let chunk = chunk.expose_provenance().to_ne_bytes();
+            let start = i * chunk.len();
+            bytes[start..(start + chunk.len())].copy_from_slice(&chunk);
+        }
+        u128::from_ne_bytes(bytes)
     }
 }
 
@@ -774,22 +807,19 @@ impl hash::Hash for TypeId {
         // - It is correct to do so -- only hashing a subset of `self` is still
         //   compatible with an `Eq` implementation that considers the entire
         //   value, as ours does.
-        self.t.1.hash(state);
+        let data =
+        // SAFETY: The `offset` stays in-bounds, it just moves the pointer to the 2nd half of the `TypeId`.
+        // Only the first ptr-sized chunk ever has provenance, so that second half is always
+        // fine to read at integer type.
+            unsafe { crate::ptr::read_unaligned(self.data.as_ptr().cast::<u64>().offset(1)) };
+        data.hash(state);
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl fmt::Debug for TypeId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        #[cfg(feature = "debug_typeid")]
-        {
-            write!(f, "TypeId({:#034x} = {})", self.as_u128(), self.name)?;
-        }
-        #[cfg(not(feature = "debug_typeid"))]
-        {
-            write!(f, "TypeId({:#034x})", self.as_u128())?;
-        }
-        Ok(())
+        write!(f, "TypeId({:#034x})", self.as_u128())
     }
 }
 
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 791d10eda6d..f5dcfeebed8 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2724,7 +2724,20 @@ pub const fn type_name<T: ?Sized>() -> &'static str;
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
-pub const fn type_id<T: ?Sized + 'static>() -> u128;
+pub const fn type_id<T: ?Sized + 'static>() -> crate::any::TypeId;
+
+/// Tests (at compile-time) if two [`crate::any::TypeId`] instances identify the
+/// same type. This is necessary because at const-eval time the actual discriminating
+/// data is opaque and cannot be inspected directly.
+///
+/// The stabilized version of this intrinsic is the [PartialEq] impl for [`core::any::TypeId`].
+#[rustc_nounwind]
+#[unstable(feature = "core_intrinsics", issue = "none")]
+#[rustc_intrinsic]
+#[rustc_do_not_const_check]
+pub const fn type_id_eq(a: crate::any::TypeId, b: crate::any::TypeId) -> bool {
+    a.data == b.data
+}
 
 /// Lowers in MIR to `Rvalue::Aggregate` with `AggregateKind::RawPtr`.
 ///
diff --git a/library/coretests/tests/any.rs b/library/coretests/tests/any.rs
index 117ef004238..25002617d0b 100644
--- a/library/coretests/tests/any.rs
+++ b/library/coretests/tests/any.rs
@@ -118,14 +118,6 @@ fn any_unsized() {
     is_any::<[i32]>();
 }
 
-#[cfg(feature = "debug_typeid")]
-#[test]
-fn debug_typeid_includes_name() {
-    let type_id = TypeId::of::<[usize; 2]>();
-    let debug_str = format!("{type_id:?}");
-    assert!(debug_str.ends_with("= [usize; 2])"), "{debug_str:?} did not match");
-}
-
 #[test]
 fn distinct_type_names() {
     // https://github.com/rust-lang/rust/issues/84666
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 3a75d316871..62ece4b6961 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -113,8 +113,6 @@ optimize_for_size = ["core/optimize_for_size", "alloc/optimize_for_size"]
 # Make `RefCell` store additional debugging information, which is printed out when
 # a borrow error occurs
 debug_refcell = ["core/debug_refcell"]
-# Make `TypeId` store a reference to the name of the type, so that it can print that name.
-debug_typeid = ["core/debug_typeid"]
 
 
 # Enable std_detect default features for stdarch/crates/std_detect:
diff --git a/library/sysroot/Cargo.toml b/library/sysroot/Cargo.toml
index 3adc0224971..c4937c36d4c 100644
--- a/library/sysroot/Cargo.toml
+++ b/library/sysroot/Cargo.toml
@@ -22,7 +22,6 @@ compiler-builtins-no-asm = ["std/compiler-builtins-no-asm"]
 compiler-builtins-no-f16-f128 = ["std/compiler-builtins-no-f16-f128"]
 compiler-builtins-mangled-names = ["std/compiler-builtins-mangled-names"]
 debug_refcell = ["std/debug_refcell"]
-debug_typeid = ["std/debug_typeid"]
 llvm-libunwind = ["std/llvm-libunwind"]
 system-llvm-libunwind = ["std/system-llvm-libunwind"]
 optimize_for_size = ["std/optimize_for_size"]
diff --git a/tests/codegen/error-provide.rs b/tests/codegen/error-provide.rs
index 25a66078fd4..7f091e34359 100644
--- a/tests/codegen/error-provide.rs
+++ b/tests/codegen/error-provide.rs
@@ -37,9 +37,9 @@ impl std::error::Error for MyError {
         // and eliminate redundant ones, rather than compare one-by-one.
 
         // CHECK-NEXT: start:
-        // CHECK-NEXT: %[[SCRUTINEE:[^ ]+]] = load i64, ptr
-        // CHECK-NEXT: switch i64 %[[SCRUTINEE]], label %{{.*}} [
-        // CHECK-COUNT-3: i64 {{.*}}, label %{{.*}}
+        // CHECK-NEXT: %[[SCRUTINEE:[^ ]+]] = load i128, ptr
+        // CHECK-NEXT: switch i128 %[[SCRUTINEE]], label %{{.*}} [
+        // CHECK-COUNT-3: i128 {{.*}}, label %{{.*}}
         // CHECK-NEXT: ]
         request
             .provide_ref::<MyBacktrace1>(&self.backtrace1)
diff --git a/tests/ui/const-generics/issues/issue-90318.rs b/tests/ui/const-generics/issues/issue-90318.rs
index 317ddad49cd..dfba90a5575 100644
--- a/tests/ui/const-generics/issues/issue-90318.rs
+++ b/tests/ui/const-generics/issues/issue-90318.rs
@@ -1,5 +1,6 @@
 #![feature(const_type_id)]
 #![feature(generic_const_exprs)]
+#![feature(const_trait_impl)]
 #![feature(core_intrinsics)]
 #![allow(incomplete_features)]
 
@@ -13,7 +14,6 @@ fn consume<T: 'static>(_val: T)
 where
     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
     //~^ ERROR overly complex generic constant
-    //~| ERROR: cannot call
 {
 }
 
@@ -21,7 +21,6 @@ fn test<T: 'static>()
 where
     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
     //~^ ERROR overly complex generic constant
-    //~| ERROR: cannot call
 {
 }
 
diff --git a/tests/ui/const-generics/issues/issue-90318.stderr b/tests/ui/const-generics/issues/issue-90318.stderr
index 9c7cb5ceb58..7031230db91 100644
--- a/tests/ui/const-generics/issues/issue-90318.stderr
+++ b/tests/ui/const-generics/issues/issue-90318.stderr
@@ -1,5 +1,5 @@
 error: overly complex generic constant
-  --> $DIR/issue-90318.rs:14:8
+  --> $DIR/issue-90318.rs:15:8
    |
 LL |     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
    |        ^^-----------------^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,26 +20,5 @@ LL |     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
    = help: consider moving this anonymous constant into a `const` function
    = note: this operation may be supported in the future
 
-error[E0015]: cannot call non-const operator in constants
-  --> $DIR/issue-90318.rs:14:10
-   |
-LL |     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: impl defined here, but it is not `const`
-  --> $SRC_DIR/core/src/any.rs:LL:COL
-   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: cannot call non-const operator in constants
-  --> $DIR/issue-90318.rs:22:10
-   |
-LL |     If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: impl defined here, but it is not `const`
-  --> $SRC_DIR/core/src/any.rs:LL:COL
-   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/const_cmp_type_id.rs b/tests/ui/consts/const_cmp_type_id.rs
index dca0615083a..def615bd92b 100644
--- a/tests/ui/consts/const_cmp_type_id.rs
+++ b/tests/ui/consts/const_cmp_type_id.rs
@@ -6,10 +6,9 @@ use std::any::TypeId;
 fn main() {
     const {
         assert!(TypeId::of::<u8>() == TypeId::of::<u8>());
-        //~^ ERROR the trait bound `TypeId: const PartialEq` is not satisfied
         assert!(TypeId::of::<()>() != TypeId::of::<u8>());
-        //~^ ERROR the trait bound `TypeId: const PartialEq` is not satisfied
         let _a = TypeId::of::<u8>() < TypeId::of::<u16>();
+        //~^ ERROR: cannot call non-const operator in constants
         // can't assert `_a` because it is not deterministic
         // FIXME(const_trait_impl) make it pass
     }
diff --git a/tests/ui/consts/const_cmp_type_id.stderr b/tests/ui/consts/const_cmp_type_id.stderr
index a8242a200ef..540eec5098b 100644
--- a/tests/ui/consts/const_cmp_type_id.stderr
+++ b/tests/ui/consts/const_cmp_type_id.stderr
@@ -1,15 +1,13 @@
-error[E0277]: the trait bound `TypeId: const PartialEq` is not satisfied
-  --> $DIR/const_cmp_type_id.rs:8:17
+error[E0015]: cannot call non-const operator in constants
+  --> $DIR/const_cmp_type_id.rs:10:18
    |
-LL |         assert!(TypeId::of::<u8>() == TypeId::of::<u8>());
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0277]: the trait bound `TypeId: const PartialEq` is not satisfied
-  --> $DIR/const_cmp_type_id.rs:10:17
+LL |         let _a = TypeId::of::<u8>() < TypeId::of::<u16>();
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-LL |         assert!(TypeId::of::<()>() != TypeId::of::<u8>());
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+note: impl defined here, but it is not `const`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to 2 previous errors
+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`.
diff --git a/tests/ui/consts/const_transmute_type_id.rs b/tests/ui/consts/const_transmute_type_id.rs
new file mode 100644
index 00000000000..56ead6a622b
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id.rs
@@ -0,0 +1,11 @@
+#![feature(const_type_id, const_trait_impl)]
+
+use std::any::TypeId;
+
+const _: () = {
+    let id = TypeId::of::<u8>();
+    let id: u8 = unsafe { (&raw const id).cast::<u8>().read() };
+    //~^ ERROR: unable to turn pointer into integer
+};
+
+fn main() {}
diff --git a/tests/ui/consts/const_transmute_type_id.stderr b/tests/ui/consts/const_transmute_type_id.stderr
new file mode 100644
index 00000000000..85bd4ea2736
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id.stderr
@@ -0,0 +1,12 @@
+error[E0080]: unable to turn pointer into integer
+  --> $DIR/const_transmute_type_id.rs:7:27
+   |
+LL |     let id: u8 = unsafe { (&raw const id).cast::<u8>().read() };
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `_` failed here
+   |
+   = 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: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const_transmute_type_id2.rs b/tests/ui/consts/const_transmute_type_id2.rs
new file mode 100644
index 00000000000..e29cf8171ac
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id2.rs
@@ -0,0 +1,14 @@
+//@ normalize-stderr: "0x(ff)+" -> "<u128::MAX>"
+
+#![feature(const_type_id, const_trait_impl)]
+
+use std::any::TypeId;
+
+const _: () = {
+    let a: TypeId = unsafe { std::mem::transmute(u128::MAX) };
+    let b: TypeId = unsafe { std::mem::transmute(u128::MAX) };
+    assert!(a == b);
+    //~^ ERROR: pointer must point to some allocation
+};
+
+fn main() {}
diff --git a/tests/ui/consts/const_transmute_type_id2.stderr b/tests/ui/consts/const_transmute_type_id2.stderr
new file mode 100644
index 00000000000..5646eb1257d
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id2.stderr
@@ -0,0 +1,15 @@
+error[E0080]: pointer not dereferenceable: pointer must point to some allocation, but got <u128::MAX>[noalloc] which is a dangling pointer (it has no provenance)
+  --> $DIR/const_transmute_type_id2.rs:10:13
+   |
+LL |     assert!(a == b);
+   |             ^^^^^^ evaluation of `_` failed inside this call
+   |
+note: inside `<TypeId as PartialEq>::eq`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+note: inside `<TypeId as PartialEq>::eq::compiletime`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+   = note: this error originates in the macro `$crate::intrinsics::const_eval_select` which comes from the expansion of the macro `crate::intrinsics::const_eval_select` (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 E0080`.
diff --git a/tests/ui/consts/const_transmute_type_id3.rs b/tests/ui/consts/const_transmute_type_id3.rs
new file mode 100644
index 00000000000..a870d6e7e80
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id3.rs
@@ -0,0 +1,16 @@
+#![feature(const_type_id, const_trait_impl)]
+
+use std::any::TypeId;
+
+const _: () = {
+    let a = TypeId::of::<()>();
+    let mut b = TypeId::of::<()>();
+    unsafe {
+        let ptr = &mut b as *mut TypeId as *mut usize;
+        std::ptr::write(ptr.offset(1), 999);
+    }
+    assert!(a == b);
+    //~^ ERROR: one of the TypeId arguments is invalid, the hash does not match the type it represents
+};
+
+fn main() {}
diff --git a/tests/ui/consts/const_transmute_type_id3.stderr b/tests/ui/consts/const_transmute_type_id3.stderr
new file mode 100644
index 00000000000..8cfdcfebaa4
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id3.stderr
@@ -0,0 +1,15 @@
+error[E0080]: type_id_eq: one of the TypeId arguments is invalid, the hash does not match the type it represents
+  --> $DIR/const_transmute_type_id3.rs:12:13
+   |
+LL |     assert!(a == b);
+   |             ^^^^^^ evaluation of `_` failed inside this call
+   |
+note: inside `<TypeId as PartialEq>::eq`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+note: inside `<TypeId as PartialEq>::eq::compiletime`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+   = note: this error originates in the macro `$crate::intrinsics::const_eval_select` which comes from the expansion of the macro `crate::intrinsics::const_eval_select` (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 E0080`.
diff --git a/tests/ui/consts/const_transmute_type_id4.rs b/tests/ui/consts/const_transmute_type_id4.rs
new file mode 100644
index 00000000000..bc71f961a51
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id4.rs
@@ -0,0 +1,16 @@
+#![feature(const_type_id, const_trait_impl)]
+
+use std::any::TypeId;
+
+const _: () = {
+    let a = TypeId::of::<()>();
+    let mut b = TypeId::of::<()>();
+    unsafe {
+        let ptr = &mut b as *mut TypeId as *mut *const ();
+        std::ptr::write(ptr.offset(0), main as fn() as *const ());
+    }
+    assert!(a == b);
+    //~^ ERROR: type_id_eq: `TypeId` provenance is not a type id
+};
+
+fn main() {}
diff --git a/tests/ui/consts/const_transmute_type_id4.stderr b/tests/ui/consts/const_transmute_type_id4.stderr
new file mode 100644
index 00000000000..b418a79d7f0
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id4.stderr
@@ -0,0 +1,15 @@
+error[E0080]: type_id_eq: `TypeId` provenance is not a type id
+  --> $DIR/const_transmute_type_id4.rs:12:13
+   |
+LL |     assert!(a == b);
+   |             ^^^^^^ evaluation of `_` failed inside this call
+   |
+note: inside `<TypeId as PartialEq>::eq`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+note: inside `<TypeId as PartialEq>::eq::compiletime`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+   = note: this error originates in the macro `$crate::intrinsics::const_eval_select` which comes from the expansion of the macro `crate::intrinsics::const_eval_select` (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 E0080`.
diff --git a/tests/ui/consts/issue-73976-monomorphic.rs b/tests/ui/consts/issue-73976-monomorphic.rs
index 561c1976051..3bfdb397afb 100644
--- a/tests/ui/consts/issue-73976-monomorphic.rs
+++ b/tests/ui/consts/issue-73976-monomorphic.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #110395
+//@ check-pass
 //
 // This test is complement to the test in issue-73976-polymorphic.rs.
 // In that test we ensure that polymorphic use of type_id and type_name in patterns
diff --git a/tests/ui/consts/issue-73976-monomorphic.stderr b/tests/ui/consts/issue-73976-monomorphic.stderr
deleted file mode 100644
index 367d5be09da..00000000000
--- a/tests/ui/consts/issue-73976-monomorphic.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0277]: the trait bound `TypeId: [const] PartialEq` is not satisfied
-  --> $DIR/issue-73976-monomorphic.rs:21:5
-   |
-LL |     GetTypeId::<T>::VALUE == GetTypeId::<usize>::VALUE
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 51084719cddaf35bbe82c3d9bab444fdb498c936 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Fri, 27 Jun 2025 15:14:21 +0000
Subject: Avoid creating a helper allocation for creating new `TypeId` values
 in the interpreter

---
 .../rustc_const_eval/src/interpret/intrinsics.rs   | 67 ++++++++++------------
 1 file changed, 29 insertions(+), 38 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index ee5382af0b2..1eba1f2f03c 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -6,8 +6,6 @@ use std::assert_matches::assert_matches;
 
 use rustc_abi::{FieldIdx, Size};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
-use rustc_ast::Mutability;
-use rustc_middle::mir::interpret::{AllocId, AllocInit, alloc_range};
 use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{Ty, TyCtxt};
@@ -30,39 +28,35 @@ pub(crate) fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ConstAll
     let alloc = Allocation::from_bytes_byte_aligned_immutable(path.into_bytes(), ());
     tcx.mk_const_alloc(alloc)
 }
-
-pub(crate) fn alloc_type_id<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> AllocId {
-    let size = Size::from_bytes(16);
-    let align = tcx.data_layout.pointer_align();
-    let mut alloc = Allocation::new(size, *align, AllocInit::Uninit, ());
-    let ptr_size = tcx.data_layout.pointer_size();
-    let type_id_hash = tcx.type_id_hash(ty).as_u128();
-    alloc
-        .write_scalar(
-            &tcx,
-            alloc_range(Size::ZERO, Size::from_bytes(16)),
-            Scalar::from_u128(type_id_hash),
-        )
-        .unwrap();
-
-    // Give the first pointer-size bytes provenance that knows about the type id
-
-    let alloc_id = tcx.reserve_and_set_type_id_alloc(ty);
-    let offset = alloc
-        .read_scalar(&tcx, alloc_range(Size::ZERO, ptr_size), false)
-        .unwrap()
-        .to_target_usize(&tcx)
-        .unwrap();
-    let ptr = Pointer::new(alloc_id.into(), Size::from_bytes(offset));
-    let val = Scalar::from_pointer(ptr, &tcx);
-    alloc.write_scalar(&tcx, alloc_range(Size::ZERO, ptr_size), val).unwrap();
-
-    alloc.mutability = Mutability::Not;
-
-    tcx.reserve_and_set_memory_alloc(tcx.mk_const_alloc(alloc))
-}
-
 impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
+    /// Generates a value of `TypeId` for `ty` in-place.
+    pub(crate) fn write_type_id(
+        &mut self,
+        ty: Ty<'tcx>,
+        dest: &PlaceTy<'tcx, M::Provenance>,
+    ) -> InterpResult<'tcx, ()> {
+        let tcx = self.tcx;
+        let type_id_hash = tcx.type_id_hash(ty).as_u128();
+        let op = self.const_val_to_op(
+            ConstValue::Scalar(Scalar::from_u128(type_id_hash)),
+            tcx.types.u128,
+            None,
+        )?;
+        self.copy_op_allow_transmute(&op, dest)?;
+
+        // Give the first pointer-size bytes provenance that knows about the type id.
+        // Here we rely on `TypeId` being a newtype around an array of pointers, so we
+        // first project to its only field and then the first array element.
+        let alloc_id = tcx.reserve_and_set_type_id_alloc(ty);
+        let first = self.project_field(dest, FieldIdx::ZERO)?;
+        let first = self.project_index(&first, 0)?;
+        let offset = self.read_scalar(&first)?.to_target_usize(&tcx)?;
+        let ptr = Pointer::new(alloc_id.into(), Size::from_bytes(offset));
+        let ptr = self.global_root_pointer(ptr)?;
+        let val = Scalar::from_pointer(ptr, &tcx);
+        self.write_scalar(val, &first)
+    }
+
     /// Returns `true` if emulation happened.
     /// Here we implement the intrinsics that are common to all Miri instances; individual machines can add their own
     /// intrinsic handling.
@@ -96,10 +90,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             sym::type_id => {
                 let tp_ty = instance.args.type_at(0);
                 ensure_monomorphic_enough(tcx, tp_ty)?;
-                let alloc_id = alloc_type_id(tcx, tp_ty);
-                let val = ConstValue::Indirect { alloc_id, offset: Size::ZERO };
-                let val = self.const_val_to_op(val, dest.layout.ty, Some(dest.layout))?;
-                self.copy_op(&val, dest)?;
+                self.write_type_id(tp_ty, dest)?;
             }
             sym::type_id_eq => {
                 // Both operands are `TypeId`, which is a newtype around an array of pointers.
-- 
cgit 1.4.1-3-g733a5


From 728017ea8f14e0cc343a6ded0e955868d628cc76 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 9 Jul 2025 17:06:39 +0000
Subject: Make AsyncDrop check that it's being implemented on a local ADT

---
 compiler/rustc_hir_analysis/messages.ftl           |  2 +-
 .../rustc_hir_analysis/src/coherence/builtin.rs    |  6 +++++-
 compiler/rustc_hir_analysis/src/errors.rs          |  1 +
 .../async-await/async-drop/foreign-fundamental.rs  | 21 +++++++++++++++++++
 .../async-drop/foreign-fundamental.stderr          | 24 ++++++++++++++++++++++
 tests/ui/error-codes/E0120.rs                      |  2 +-
 6 files changed, 53 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/async-await/async-drop/foreign-fundamental.rs
 create mode 100644 tests/ui/async-await/async-drop/foreign-fundamental.stderr

diff --git a/compiler/rustc_hir_analysis/messages.ftl b/compiler/rustc_hir_analysis/messages.ftl
index 529d3578985..0429b290476 100644
--- a/compiler/rustc_hir_analysis/messages.ftl
+++ b/compiler/rustc_hir_analysis/messages.ftl
@@ -158,7 +158,7 @@ hir_analysis_dispatch_from_dyn_zst = the trait `DispatchFromDyn` may only be imp
 hir_analysis_drop_impl_negative = negative `Drop` impls are not supported
 
 hir_analysis_drop_impl_on_wrong_item =
-    the `Drop` trait may only be implemented for local structs, enums, and unions
+    the `{$trait_}` trait may only be implemented for local structs, enums, and unions
     .label = must be a struct, enum, or union in the current crate
 
 hir_analysis_drop_impl_reservation = reservation `Drop` impls are not supported
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
index 8356a0af63c..27948f50a4a 100644
--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -37,6 +37,7 @@ pub(super) fn check_trait<'tcx>(
     let lang_items = tcx.lang_items();
     let checker = Checker { tcx, trait_def_id, impl_def_id, impl_header };
     checker.check(lang_items.drop_trait(), visit_implementation_of_drop)?;
+    checker.check(lang_items.async_drop_trait(), visit_implementation_of_drop)?;
     checker.check(lang_items.copy_trait(), visit_implementation_of_copy)?;
     checker.check(lang_items.const_param_ty_trait(), |checker| {
         visit_implementation_of_const_param_ty(checker, LangItem::ConstParamTy)
@@ -83,7 +84,10 @@ fn visit_implementation_of_drop(checker: &Checker<'_>) -> Result<(), ErrorGuaran
 
     let impl_ = tcx.hir_expect_item(impl_did).expect_impl();
 
-    Err(tcx.dcx().emit_err(errors::DropImplOnWrongItem { span: impl_.self_ty.span }))
+    Err(tcx.dcx().emit_err(errors::DropImplOnWrongItem {
+        span: impl_.self_ty.span,
+        trait_: tcx.item_name(checker.impl_header.trait_ref.skip_binder().def_id),
+    }))
 }
 
 fn visit_implementation_of_copy(checker: &Checker<'_>) -> Result<(), ErrorGuaranteed> {
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index c1c82839212..9e29e5f6473 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -205,6 +205,7 @@ pub(crate) struct DropImplOnWrongItem {
     #[primary_span]
     #[label]
     pub span: Span,
+    pub trait_: Symbol,
 }
 
 #[derive(Diagnostic)]
diff --git a/tests/ui/async-await/async-drop/foreign-fundamental.rs b/tests/ui/async-await/async-drop/foreign-fundamental.rs
new file mode 100644
index 00000000000..1c192fccd9f
--- /dev/null
+++ b/tests/ui/async-await/async-drop/foreign-fundamental.rs
@@ -0,0 +1,21 @@
+//@ edition: 2018
+
+#![feature(async_drop)]
+//~^ WARN the feature `async_drop` is incomplete
+
+use std::future::AsyncDrop;
+use std::pin::Pin;
+
+struct Foo;
+
+impl AsyncDrop for &Foo {
+    //~^ ERROR the `AsyncDrop` trait may only be implemented for
+    async fn drop(self: Pin<&mut Self>) {}
+}
+
+impl AsyncDrop for Pin<Foo> {
+    //~^ ERROR the `AsyncDrop` trait may only be implemented for
+    async fn drop(self: Pin<&mut Self>) {}
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/async-drop/foreign-fundamental.stderr b/tests/ui/async-await/async-drop/foreign-fundamental.stderr
new file mode 100644
index 00000000000..7b52329ac99
--- /dev/null
+++ b/tests/ui/async-await/async-drop/foreign-fundamental.stderr
@@ -0,0 +1,24 @@
+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
+   |
+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
+   |
+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
+
+For more information about this error, try `rustc --explain E0120`.
diff --git a/tests/ui/error-codes/E0120.rs b/tests/ui/error-codes/E0120.rs
index 35f544fddfb..4e5cc7d6833 100644
--- a/tests/ui/error-codes/E0120.rs
+++ b/tests/ui/error-codes/E0120.rs
@@ -1,4 +1,4 @@
-trait MyTrait { fn foo() {} }
+trait MyTrait { fn foo(&self) {} }
 
 impl Drop for dyn MyTrait {
               //~^ ERROR E0120
-- 
cgit 1.4.1-3-g733a5


From d8273d39978ed16528c9792f9c4a81cc596bf7f8 Mon Sep 17 00:00:00 2001
From: Ayush Singh <ayush@beagleboard.org>
Date: Mon, 7 Jul 2025 14:16:41 +0530
Subject: std: sys: net: uefi: tcp4: Add timeout support

- Implement timeout support for read, write and connect.
- A software implementation using Instant.

Signed-off-by: Ayush Singh <ayush@beagleboard.org>
---
 library/std/src/sys/net/connection/uefi/mod.rs  | 41 ++++++++++-----
 library/std/src/sys/net/connection/uefi/tcp.rs  | 13 ++---
 library/std/src/sys/net/connection/uefi/tcp4.rs | 68 ++++++++++++++++++++++---
 3 files changed, 97 insertions(+), 25 deletions(-)

diff --git a/library/std/src/sys/net/connection/uefi/mod.rs b/library/std/src/sys/net/connection/uefi/mod.rs
index 6835ba44ee2..884cbd4ac1d 100644
--- a/library/std/src/sys/net/connection/uefi/mod.rs
+++ b/library/std/src/sys/net/connection/uefi/mod.rs
@@ -1,37 +1,54 @@
 use crate::fmt;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut};
 use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
+use crate::sync::{Arc, Mutex};
 use crate::sys::unsupported;
 use crate::time::Duration;
 
 mod tcp;
 pub(crate) mod tcp4;
 
-pub struct TcpStream(tcp::Tcp);
+pub struct TcpStream {
+    inner: tcp::Tcp,
+    read_timeout: Arc<Mutex<Option<Duration>>>,
+    write_timeout: Arc<Mutex<Option<Duration>>>,
+}
 
 impl TcpStream {
     pub fn connect(addr: io::Result<&SocketAddr>) -> io::Result<TcpStream> {
-        tcp::Tcp::connect(addr?).map(Self)
+        let inner = tcp::Tcp::connect(addr?, None)?;
+        Ok(Self {
+            inner,
+            read_timeout: Arc::new(Mutex::new(None)),
+            write_timeout: Arc::new(Mutex::new(None)),
+        })
     }
 
-    pub fn connect_timeout(_: &SocketAddr, _: Duration) -> io::Result<TcpStream> {
-        unsupported()
+    pub fn connect_timeout(addr: &SocketAddr, timeout: Duration) -> io::Result<TcpStream> {
+        let inner = tcp::Tcp::connect(addr, Some(timeout))?;
+        Ok(Self {
+            inner,
+            read_timeout: Arc::new(Mutex::new(None)),
+            write_timeout: Arc::new(Mutex::new(None)),
+        })
     }
 
-    pub fn set_read_timeout(&self, _: Option<Duration>) -> io::Result<()> {
-        unsupported()
+    pub fn set_read_timeout(&self, t: Option<Duration>) -> io::Result<()> {
+        self.read_timeout.set(t).unwrap();
+        Ok(())
     }
 
-    pub fn set_write_timeout(&self, _: Option<Duration>) -> io::Result<()> {
-        unsupported()
+    pub fn set_write_timeout(&self, t: Option<Duration>) -> io::Result<()> {
+        self.write_timeout.set(t).unwrap();
+        Ok(())
     }
 
     pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
-        unsupported()
+        Ok(self.read_timeout.get_cloned().unwrap())
     }
 
     pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
-        unsupported()
+        Ok(self.write_timeout.get_cloned().unwrap())
     }
 
     pub fn peek(&self, _: &mut [u8]) -> io::Result<usize> {
@@ -39,7 +56,7 @@ impl TcpStream {
     }
 
     pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
-        self.0.read(buf)
+        self.inner.read(buf, self.read_timeout()?)
     }
 
     pub fn read_buf(&self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
@@ -56,7 +73,7 @@ impl TcpStream {
     }
 
     pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
-        self.0.write(buf)
+        self.inner.write(buf, self.write_timeout()?)
     }
 
     pub fn write_vectored(&self, buf: &[IoSlice<'_>]) -> io::Result<usize> {
diff --git a/library/std/src/sys/net/connection/uefi/tcp.rs b/library/std/src/sys/net/connection/uefi/tcp.rs
index 55b6dbf2490..1152f69446e 100644
--- a/library/std/src/sys/net/connection/uefi/tcp.rs
+++ b/library/std/src/sys/net/connection/uefi/tcp.rs
@@ -1,33 +1,34 @@
 use super::tcp4;
 use crate::io;
 use crate::net::SocketAddr;
+use crate::time::Duration;
 
 pub(crate) enum Tcp {
     V4(tcp4::Tcp4),
 }
 
 impl Tcp {
-    pub(crate) fn connect(addr: &SocketAddr) -> io::Result<Self> {
+    pub(crate) fn connect(addr: &SocketAddr, timeout: Option<Duration>) -> io::Result<Self> {
         match addr {
             SocketAddr::V4(x) => {
                 let temp = tcp4::Tcp4::new()?;
                 temp.configure(true, Some(x), None)?;
-                temp.connect()?;
+                temp.connect(timeout)?;
                 Ok(Tcp::V4(temp))
             }
             SocketAddr::V6(_) => todo!(),
         }
     }
 
-    pub(crate) fn write(&self, buf: &[u8]) -> io::Result<usize> {
+    pub(crate) fn write(&self, buf: &[u8], timeout: Option<Duration>) -> io::Result<usize> {
         match self {
-            Self::V4(client) => client.write(buf),
+            Self::V4(client) => client.write(buf, timeout),
         }
     }
 
-    pub(crate) fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+    pub(crate) fn read(&self, buf: &mut [u8], timeout: Option<Duration>) -> io::Result<usize> {
         match self {
-            Self::V4(client) => client.read(buf),
+            Self::V4(client) => client.read(buf, timeout),
         }
     }
 }
diff --git a/library/std/src/sys/net/connection/uefi/tcp4.rs b/library/std/src/sys/net/connection/uefi/tcp4.rs
index af1ba2be47a..6342718929a 100644
--- a/library/std/src/sys/net/connection/uefi/tcp4.rs
+++ b/library/std/src/sys/net/connection/uefi/tcp4.rs
@@ -6,6 +6,7 @@ use crate::net::SocketAddrV4;
 use crate::ptr::NonNull;
 use crate::sync::atomic::{AtomicBool, Ordering};
 use crate::sys::pal::helpers;
+use crate::time::{Duration, Instant};
 
 const TYPE_OF_SERVICE: u8 = 8;
 const TIME_TO_LIVE: u8 = 255;
@@ -66,7 +67,7 @@ impl Tcp4 {
         if r.is_error() { Err(crate::io::Error::from_raw_os_error(r.as_usize())) } else { Ok(()) }
     }
 
-    pub(crate) fn connect(&self) -> io::Result<()> {
+    pub(crate) fn connect(&self, timeout: Option<Duration>) -> io::Result<()> {
         let evt = unsafe { self.create_evt() }?;
         let completion_token =
             tcp4::CompletionToken { event: evt.as_ptr(), status: Status::SUCCESS };
@@ -79,7 +80,7 @@ impl Tcp4 {
             return Err(io::Error::from_raw_os_error(r.as_usize()));
         }
 
-        self.wait_for_flag();
+        unsafe { self.wait_or_cancel(timeout, &mut conn_token.completion_token) }?;
 
         if completion_token.status.is_error() {
             Err(io::Error::from_raw_os_error(completion_token.status.as_usize()))
@@ -88,7 +89,7 @@ impl Tcp4 {
         }
     }
 
-    pub(crate) fn write(&self, buf: &[u8]) -> io::Result<usize> {
+    pub(crate) fn write(&self, buf: &[u8], timeout: Option<Duration>) -> io::Result<usize> {
         let evt = unsafe { self.create_evt() }?;
         let completion_token =
             tcp4::CompletionToken { event: evt.as_ptr(), status: Status::SUCCESS };
@@ -119,7 +120,7 @@ impl Tcp4 {
             return Err(io::Error::from_raw_os_error(r.as_usize()));
         }
 
-        self.wait_for_flag();
+        unsafe { self.wait_or_cancel(timeout, &mut token.completion_token) }?;
 
         if completion_token.status.is_error() {
             Err(io::Error::from_raw_os_error(completion_token.status.as_usize()))
@@ -128,7 +129,7 @@ impl Tcp4 {
         }
     }
 
-    pub(crate) fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+    pub(crate) fn read(&self, buf: &mut [u8], timeout: Option<Duration>) -> io::Result<usize> {
         let evt = unsafe { self.create_evt() }?;
         let completion_token =
             tcp4::CompletionToken { event: evt.as_ptr(), status: Status::SUCCESS };
@@ -158,7 +159,7 @@ impl Tcp4 {
             return Err(io::Error::from_raw_os_error(r.as_usize()));
         }
 
-        self.wait_for_flag();
+        unsafe { self.wait_or_cancel(timeout, &mut token.completion_token) }?;
 
         if completion_token.status.is_error() {
             Err(io::Error::from_raw_os_error(completion_token.status.as_usize()))
@@ -167,6 +168,50 @@ impl Tcp4 {
         }
     }
 
+    /// Wait for an event to finish. This is checked by an atomic boolean that is supposed to be set
+    /// to true in the event callback.
+    ///
+    /// Optionally, allow specifying a timeout.
+    ///
+    /// If a timeout is provided, the operation (specified by its `EFI_TCP4_COMPLETION_TOKEN`) is
+    /// canceled and Error of kind TimedOut is returned.
+    ///
+    /// # SAFETY
+    ///
+    /// Pointer to a valid `EFI_TCP4_COMPLETION_TOKEN`
+    unsafe fn wait_or_cancel(
+        &self,
+        timeout: Option<Duration>,
+        token: *mut tcp4::CompletionToken,
+    ) -> io::Result<()> {
+        if !self.wait_for_flag(timeout) {
+            let _ = unsafe { self.cancel(token) };
+            return Err(io::Error::new(io::ErrorKind::TimedOut, "Operation Timed out"));
+        }
+
+        Ok(())
+    }
+
+    /// Abort an asynchronous connection, listen, transmission or receive request.
+    ///
+    /// If token is NULL, then all pending tokens issued by EFI_TCP4_PROTOCOL.Connect(),
+    /// EFI_TCP4_PROTOCOL.Accept(), EFI_TCP4_PROTOCOL.Transmit() or EFI_TCP4_PROTOCOL.Receive() are
+    /// aborted.
+    ///
+    /// # SAFETY
+    ///
+    /// Pointer to a valid `EFI_TCP4_COMPLETION_TOKEN` or NULL
+    unsafe fn cancel(&self, token: *mut tcp4::CompletionToken) -> io::Result<()> {
+        let protocol = self.protocol.as_ptr();
+
+        let r = unsafe { ((*protocol).cancel)(protocol, token) };
+        if r.is_error() {
+            return Err(io::Error::from_raw_os_error(r.as_usize()));
+        } else {
+            Ok(())
+        }
+    }
+
     unsafe fn create_evt(&self) -> io::Result<helpers::OwnedEvent> {
         self.flag.store(false, Ordering::Relaxed);
         helpers::OwnedEvent::new(
@@ -177,10 +222,19 @@ impl Tcp4 {
         )
     }
 
-    fn wait_for_flag(&self) {
+    fn wait_for_flag(&self, timeout: Option<Duration>) -> bool {
+        let start = Instant::now();
+
         while !self.flag.load(Ordering::Relaxed) {
             let _ = self.poll();
+            if let Some(t) = timeout {
+                if Instant::now().duration_since(start) >= t {
+                    return false;
+                }
+            }
         }
+
+        true
     }
 
     fn poll(&self) -> io::Result<()> {
-- 
cgit 1.4.1-3-g733a5


From 925789456aa0bb112d8ab2fe3f31f4f7317f463b Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 9 Jul 2025 18:12:31 +0200
Subject: miri: fix out-of-bounds error for ptrs with negative offsets

---
 compiler/rustc_const_eval/messages.ftl             | 27 ++++++++++++----------
 .../out_of_bounds_read_neg_offset.rs               |  6 +++++
 .../out_of_bounds_read_neg_offset.stderr           | 21 +++++++++++++++++
 .../intrinsics/ptr_offset_out_of_bounds_neg2.rs    |  6 +++++
 .../ptr_offset_out_of_bounds_neg2.stderr           | 20 ++++++++++++++++
 tests/ui/consts/offset_ub.rs                       | 14 +++++------
 tests/ui/consts/offset_ub.stderr                   |  6 ++---
 7 files changed, 78 insertions(+), 22 deletions(-)
 create mode 100644 src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read_neg_offset.rs
 create mode 100644 src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read_neg_offset.stderr
 create mode 100644 src/tools/miri/tests/fail/intrinsics/ptr_offset_out_of_bounds_neg2.rs
 create mode 100644 src/tools/miri/tests/fail/intrinsics/ptr_offset_out_of_bounds_neg2.stderr

diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index 22a1894ee72..dd12afb2853 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -294,19 +294,22 @@ const_eval_pointer_arithmetic_overflow =
     overflowing pointer arithmetic: the total offset in bytes does not fit in an `isize`
 
 const_eval_pointer_out_of_bounds =
-    {const_eval_bad_pointer_op_attempting}, but got {$pointer} which {$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
+    {const_eval_bad_pointer_op_attempting}, 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
                 }
-                [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
-            }
+        }
     }
 
 const_eval_pointer_use_after_free =
diff --git a/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read_neg_offset.rs b/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read_neg_offset.rs
new file mode 100644
index 00000000000..107a3db91d8
--- /dev/null
+++ b/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read_neg_offset.rs
@@ -0,0 +1,6 @@
+fn main() {
+    let v: Vec<u16> = vec![1, 2];
+    // This read is also misaligned. We make sure that the OOB message has priority.
+    let x = unsafe { *v.as_ptr().wrapping_byte_sub(5) }; //~ ERROR: before the beginning of the allocation
+    panic!("this should never print: {}", x);
+}
diff --git a/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read_neg_offset.stderr b/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read_neg_offset.stderr
new file mode 100644
index 00000000000..5c37caa1ebf
--- /dev/null
+++ b/src/tools/miri/tests/fail/dangling_pointers/out_of_bounds_read_neg_offset.stderr
@@ -0,0 +1,21 @@
+error: Undefined Behavior: memory access failed: attempting to access 2 bytes, but got ALLOC-0x5 which points to before the beginning of the allocation
+  --> tests/fail/dangling_pointers/out_of_bounds_read_neg_offset.rs:LL:CC
+   |
+LL |     let x = unsafe { *v.as_ptr().wrapping_byte_sub(5) };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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: ALLOC was allocated here:
+  --> tests/fail/dangling_pointers/out_of_bounds_read_neg_offset.rs:LL:CC
+   |
+LL |     let v: Vec<u16> = vec![1, 2];
+   |                       ^^^^^^^^^^
+   = note: BACKTRACE (of the first span):
+   = note: inside `main` at tests/fail/dangling_pointers/out_of_bounds_read_neg_offset.rs:LL:CC
+   = note: this error originates in the macro `vec` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+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/intrinsics/ptr_offset_out_of_bounds_neg2.rs b/src/tools/miri/tests/fail/intrinsics/ptr_offset_out_of_bounds_neg2.rs
new file mode 100644
index 00000000000..0085e2af367
--- /dev/null
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_out_of_bounds_neg2.rs
@@ -0,0 +1,6 @@
+fn main() {
+    let v = [0i8; 4];
+    let x = &v as *const i8;
+    let x = unsafe { x.wrapping_offset(-1).offset(-1) }; //~ERROR: before the beginning of the allocation
+    panic!("this should never print: {:?}", x);
+}
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_out_of_bounds_neg2.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_out_of_bounds_neg2.stderr
new file mode 100644
index 00000000000..495aaf8d40e
--- /dev/null
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_out_of_bounds_neg2.stderr
@@ -0,0 +1,20 @@
+error: Undefined Behavior: in-bounds pointer arithmetic failed: attempting to offset pointer by -1 bytes, but got ALLOC-0x1 which points to before the beginning of the allocation
+  --> tests/fail/intrinsics/ptr_offset_out_of_bounds_neg2.rs:LL:CC
+   |
+LL |     let x = unsafe { x.wrapping_offset(-1).offset(-1) };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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: ALLOC was allocated here:
+  --> tests/fail/intrinsics/ptr_offset_out_of_bounds_neg2.rs:LL:CC
+   |
+LL |     let v = [0i8; 4];
+   |         ^
+   = note: BACKTRACE (of the first span):
+   = note: inside `main` at tests/fail/intrinsics/ptr_offset_out_of_bounds_neg2.rs:LL:CC
+
+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/offset_ub.rs b/tests/ui/consts/offset_ub.rs
index 8c52586c485..98a50156a94 100644
--- a/tests/ui/consts/offset_ub.rs
+++ b/tests/ui/consts/offset_ub.rs
@@ -5,17 +5,17 @@ use std::ptr;
 //@ normalize-stderr: "\d+ bytes" -> "$$BYTES bytes"
 
 
-pub const BEFORE_START: *const u8 = unsafe { (&0u8 as *const u8).offset(-1) }; //~ ERROR
-pub const AFTER_END: *const u8 = unsafe { (&0u8 as *const u8).offset(2) }; //~ ERROR
-pub const AFTER_ARRAY: *const u8 = unsafe { [0u8; 100].as_ptr().offset(101) }; //~ ERROR
+pub const BEFORE_START: *const u8 = unsafe { (&0u8 as *const u8).offset(-1) }; //~ ERROR: is at the beginning of the allocation
+pub const AFTER_END: *const u8 = unsafe { (&0u8 as *const u8).offset(2) }; //~ ERROR: only 1 byte from the end of the allocation
+pub const AFTER_ARRAY: *const u8 = unsafe { [0u8; 100].as_ptr().offset(101) }; //~ ERROR: only 100 bytes from the end of the allocation
 
-pub const OVERFLOW: *const u16 = unsafe { [0u16; 1].as_ptr().offset(isize::MAX) }; //~ ERROR
-pub const UNDERFLOW: *const u16 = unsafe { [0u16; 1].as_ptr().offset(isize::MIN) }; //~ ERROR
+pub const OVERFLOW: *const u16 = unsafe { [0u16; 1].as_ptr().offset(isize::MAX) }; //~ ERROR: does not fit in an `isize`
+pub const UNDERFLOW: *const u16 = unsafe { [0u16; 1].as_ptr().offset(isize::MIN) }; //~ ERROR: does not fit in an `isize`
 pub const OVERFLOW_ADDRESS_SPACE: *const u8 = unsafe { (usize::MAX as *const u8).offset(2) }; //~ ERROR
 pub const UNDERFLOW_ADDRESS_SPACE: *const u8 = unsafe { (1 as *const u8).offset(-2) }; //~ ERROR
-pub const NEGATIVE_OFFSET: *const u8 = unsafe { [0u8; 1].as_ptr().wrapping_offset(-2).offset(-2) }; //~ ERROR
+pub const NEGATIVE_OFFSET: *const u8 = unsafe { [0u8; 1].as_ptr().wrapping_offset(-2).offset(-2) }; //~ ERROR: before the beginning of the allocation
 
-pub const ZERO_SIZED_ALLOC: *const u8 = unsafe { [0u8; 0].as_ptr().offset(1) }; //~ ERROR
+pub const ZERO_SIZED_ALLOC: *const u8 = unsafe { [0u8; 0].as_ptr().offset(1) }; //~ ERROR: at or beyond the end of the allocation
 pub const DANGLING: *const u8 = unsafe { ptr::NonNull::<u8>::dangling().as_ptr().offset(4) }; //~ ERROR
 
 // Make sure that we don't panic when computing abs(offset*size_of::<T>())
diff --git a/tests/ui/consts/offset_ub.stderr b/tests/ui/consts/offset_ub.stderr
index 255583ce91c..d92ca09223d 100644
--- a/tests/ui/consts/offset_ub.stderr
+++ b/tests/ui/consts/offset_ub.stderr
@@ -40,11 +40,11 @@ error[E0080]: in-bounds pointer arithmetic failed: attempting to offset pointer
 LL | pub const UNDERFLOW_ADDRESS_SPACE: *const u8 = unsafe { (1 as *const u8).offset(-2) };
    |                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `UNDERFLOW_ADDRESS_SPACE` failed here
 
-error[E0080]: in-bounds pointer arithmetic failed: attempting to offset pointer by -$BYTES bytes, but got ALLOC3-0x2 which is only $BYTES bytes from the beginning of the allocation
+error[E0080]: in-bounds pointer arithmetic failed: attempting to offset pointer by -$BYTES bytes, but got ALLOC3-0x2 which points to before the beginning of the allocation
   --> $DIR/offset_ub.rs:16:49
    |
-LL | pub const NEGATIVE_OFFSET: *const u8 = unsafe { [0u8; 1].as_ptr().wrapping_offset(-2).offset(-2) };
-   |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `NEGATIVE_OFFSET` failed here
+LL | ...*const u8 = unsafe { [0u8; 1].as_ptr().wrapping_offset(-2).offset(-2) };
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `NEGATIVE_OFFSET` failed here
 
 error[E0080]: in-bounds pointer arithmetic failed: attempting to offset pointer by 1 byte, but got ALLOC4 which is at or beyond the end of the allocation of size $BYTES bytes
   --> $DIR/offset_ub.rs:18:50
-- 
cgit 1.4.1-3-g733a5


From 29614643e41b6d21e9fdb5d57bfab0d6319bea5b Mon Sep 17 00:00:00 2001
From: FractalFir <fractalfirdev@gmail.com>
Date: Tue, 8 Jul 2025 21:36:05 +0200
Subject: Change the implementation of supports_parallel to signal tha cg_gcc
 is not thread safe.

---
 src/lib.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 45e81aea551..790e32a4bc6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -289,6 +289,10 @@ fn new_context<'gcc, 'tcx>(tcx: TyCtxt<'tcx>) -> Context<'gcc> {
 }
 
 impl ExtraBackendMethods for GccCodegenBackend {
+    fn supports_parallel(&self) -> bool {
+        false
+    }
+
     fn codegen_allocator(
         &self,
         tcx: TyCtxt<'_>,
@@ -357,8 +361,7 @@ impl Deref for SyncContext {
 }
 
 unsafe impl Send for SyncContext {}
-// FIXME(antoyo): that shouldn't be Sync. Parallel compilation is currently disabled with "-Zno-parallel-llvm".
-// TODO: disable it here by returning false in CodegenBackend::supports_parallel().
+// FIXME(antoyo): that shouldn't be Sync. Parallel compilation is currently disabled with "CodegenBackend::supports_parallel()".
 unsafe impl Sync for SyncContext {}
 
 impl WriteBackendMethods for GccCodegenBackend {
-- 
cgit 1.4.1-3-g733a5


From c246e06240deac5d7789d4d82734f2a6890eff6a Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 9 Jul 2025 21:30:22 +0300
Subject: Update MSRV to 1.88.0

---
 src/tools/rust-analyzer/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index d268ce5b0bb..c7b78ec7131 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -4,7 +4,7 @@ exclude = ["crates/proc-macro-srv/proc-macro-test/imp"]
 resolver = "2"
 
 [workspace.package]
-rust-version = "1.86"
+rust-version = "1.88"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 authors = ["rust-analyzer team"]
-- 
cgit 1.4.1-3-g733a5


From 63885243987a5df0e77ad0029961ebe8bd20cb18 Mon Sep 17 00:00:00 2001
From: FractalFir <fractalfirdev@gmail.com>
Date: Wed, 9 Jul 2025 20:22:44 +0200
Subject: Skip needlessly setting the default visibility on functions

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

diff --git a/src/mono_item.rs b/src/mono_item.rs
index 539e3ac8507..82faeec948c 100644
--- a/src/mono_item.rs
+++ b/src/mono_item.rs
@@ -64,7 +64,7 @@ impl<'gcc, 'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         if linkage != Linkage::Internal && self.tcx.is_compiler_builtins(LOCAL_CRATE) {
             #[cfg(feature = "master")]
             decl.add_attribute(FnAttribute::Visibility(gccjit::Visibility::Hidden));
-        } else {
+        } else if visibility != Visibility::Default {
             #[cfg(feature = "master")]
             decl.add_attribute(FnAttribute::Visibility(base::visibility_to_gcc(visibility)));
         }
-- 
cgit 1.4.1-3-g733a5


From 36f6f1e72d3c853117704b81a34a00a58142c52e Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Wed, 9 Jul 2025 21:43:20 +0300
Subject: Make `AsmExpr` have `AstId`

We need it because `global_asm!()` is an item. It's unfortunate that such thing can slip in and I see no way to automatically catch that, but thankfully analysis-stats on self has caught that.
---
 src/tools/rust-analyzer/crates/span/src/ast_id.rs | 39 +++++++++++++++++------
 1 file changed, 29 insertions(+), 10 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 c8b7efaf6d4..a9288ecd6fa 100644
--- a/src/tools/rust-analyzer/crates/span/src/ast_id.rs
+++ b/src/tools/rust-analyzer/crates/span/src/ast_id.rs
@@ -30,7 +30,7 @@ use std::{
 use la_arena::{Arena, Idx, RawIdx};
 use rustc_hash::{FxBuildHasher, FxHashMap};
 use syntax::{
-    AstNode, AstPtr, SyntaxNode, SyntaxNodePtr,
+    AstNode, AstPtr, SyntaxKind, SyntaxNode, SyntaxNodePtr,
     ast::{self, HasName},
     match_ast,
 };
@@ -92,6 +92,7 @@ impl fmt::Debug for ErasedFileAstId {
             Use,
             Impl,
             BlockExpr,
+            AsmExpr,
             Fixup,
         );
         if f.alternate() {
@@ -144,6 +145,10 @@ enum ErasedFileAstIdKind {
     Impl,
     /// Associated with [`BlockExprFileAstId`].
     BlockExpr,
+    // `global_asm!()` is an item, so we need to give it an `AstId`. So we give to all inline asm
+    // because incrementality is not a problem, they will always be the only item in the macro file,
+    // and memory usage also not because they're rare.
+    AsmExpr,
     /// Keep this last.
     Root,
 }
@@ -204,14 +209,17 @@ impl ErasedFileAstId {
             .or_else(|| extern_block_ast_id(node, index_map))
             .or_else(|| use_ast_id(node, index_map))
             .or_else(|| impl_ast_id(node, index_map))
+            .or_else(|| asm_expr_ast_id(node, index_map))
     }
 
     fn should_alloc(node: &SyntaxNode) -> bool {
-        should_alloc_has_name(node)
-            || should_alloc_assoc_item(node)
-            || ast::ExternBlock::can_cast(node.kind())
-            || ast::Use::can_cast(node.kind())
-            || ast::Impl::can_cast(node.kind())
+        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)
     }
 
     #[inline]
@@ -331,6 +339,19 @@ fn use_ast_id(
     }
 }
 
+impl AstIdNode for ast::AsmExpr {}
+
+fn asm_expr_ast_id(
+    node: &SyntaxNode,
+    index_map: &mut ErasedAstIdNextIndexMap,
+) -> Option<ErasedFileAstId> {
+    if ast::AsmExpr::can_cast(node.kind()) {
+        Some(index_map.new_id(ErasedFileAstIdKind::AsmExpr, ()))
+    } else {
+        None
+    }
+}
+
 impl AstIdNode for ast::Impl {}
 
 fn impl_ast_id(
@@ -449,8 +470,7 @@ macro_rules! register_has_name_ast_id {
             }
         }
 
-        fn should_alloc_has_name(node: &SyntaxNode) -> bool {
-            let kind = node.kind();
+        fn should_alloc_has_name(kind: SyntaxKind) -> bool {
             false $( || ast::$ident::can_cast(kind) )*
         }
     };
@@ -501,8 +521,7 @@ macro_rules! register_assoc_item_ast_id {
             }
         }
 
-        fn should_alloc_assoc_item(node: &SyntaxNode) -> bool {
-            let kind = node.kind();
+        fn should_alloc_assoc_item(kind: SyntaxKind) -> bool {
             false $( || ast::$ident::can_cast(kind) )*
         }
     };
-- 
cgit 1.4.1-3-g733a5


From 7e844720bdedc7b8bb4ed1d5414e557d7358e7df Mon Sep 17 00:00:00 2001
From: FractalFir <fractalfirdev@gmail.com>
Date: Tue, 8 Jul 2025 23:00:40 +0200
Subject: Inserted a local variable in volatile_load, to ensure reads don't
 move across blocks.

---
 src/builder.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/builder.rs b/src/builder.rs
index 100091692ba..e65eea6d599 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -980,7 +980,11 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
 
     fn volatile_load(&mut self, ty: Type<'gcc>, ptr: RValue<'gcc>) -> RValue<'gcc> {
         let ptr = self.context.new_cast(self.location, ptr, ty.make_volatile().make_pointer());
-        ptr.dereference(self.location).to_rvalue()
+        // (FractalFir): We insert a local here, to ensure this volatile load can't move across
+        // blocks.
+        let local = self.current_func().new_local(self.location, ty, "volatile_tmp");
+        self.block.add_assignment(self.location, local, ptr.dereference(self.location).to_rvalue());
+        local.to_rvalue()
     }
 
     fn atomic_load(
-- 
cgit 1.4.1-3-g733a5


From 425cd0f571b3888be81ebad295af8e3c903fb244 Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Wed, 9 Jul 2025 14:55:53 -0500
Subject: test: Verify frontmatter unpretty behavior

---
 tests/ui/unpretty/frontmatter.rs     | 10 ++++++++++
 tests/ui/unpretty/frontmatter.stdout |  7 +++++++
 2 files changed, 17 insertions(+)
 create mode 100644 tests/ui/unpretty/frontmatter.rs
 create mode 100644 tests/ui/unpretty/frontmatter.stdout

diff --git a/tests/ui/unpretty/frontmatter.rs b/tests/ui/unpretty/frontmatter.rs
new file mode 100644
index 00000000000..1971808e2a8
--- /dev/null
+++ b/tests/ui/unpretty/frontmatter.rs
@@ -0,0 +1,10 @@
+---
+---
+
+//@ compile-flags: -Zunpretty=normal
+//@ check-pass
+
+#![feature(frontmatter)]
+
+fn main() {
+}
diff --git a/tests/ui/unpretty/frontmatter.stdout b/tests/ui/unpretty/frontmatter.stdout
new file mode 100644
index 00000000000..9ad6bbbe577
--- /dev/null
+++ b/tests/ui/unpretty/frontmatter.stdout
@@ -0,0 +1,7 @@
+
+//@ compile-flags: -Zunpretty=normal
+//@ check-pass
+
+#![feature(frontmatter)]
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 65dc474d1ce75071dacd76480807abdf0beed830 Mon Sep 17 00:00:00 2001
From: Daniel Paoliello <danpao@microsoft.com>
Date: Wed, 9 Jul 2025 12:56:06 -0700
Subject: Update LLVM submodule

---
 src/llvm-project | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm-project b/src/llvm-project
index 9b1bf4cf041..99f0e053168 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 9b1bf4cf041c1c1fe62cf03891ac90431615e780
+Subproject commit 99f0e0531688a822a753cc585b7408b069cb6822
-- 
cgit 1.4.1-3-g733a5


From 7e2527d3ab306f30d17d381257683bb0418f8b9e Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 9 Jul 2025 14:58:44 -0500
Subject: triagebot.toml: ping lolbinarycat if tidy extra checks were modified

---
 triagebot.toml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 4e3dff219f1..e3099289181 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1080,6 +1080,10 @@ cc = ["@jieyouxu"]
 message = "The list of allowed third-party dependencies may have been modified! You must ensure that any new dependencies have compatible licenses before merging."
 cc = ["@davidtwco", "@wesleywiser"]
 
+[mentions."src/tools/tidy/src/ext_tool_checks.rs"]
+message = "`tidy` extra checks were modified."
+cc = ["@lolbinarycat"]
+
 [mentions."src/bootstrap/src/core/config"]
 message = """
 This PR modifies `src/bootstrap/src/core/config`.
-- 
cgit 1.4.1-3-g733a5


From 4c947984d64ae63a71c5441082a35309b9198fbf Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Wed, 9 Jul 2025 13:42:18 -0700
Subject: random: Add comment on `RandomSource::fill_bytes` about multiple
 calls

This allows efficient implementations for random sources that generate a
word at a time.
---
 library/core/src/random.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/library/core/src/random.rs b/library/core/src/random.rs
index 051fe260863..40338c3f4ac 100644
--- a/library/core/src/random.rs
+++ b/library/core/src/random.rs
@@ -7,6 +7,11 @@
 #[unstable(feature = "random", issue = "130703")]
 pub trait RandomSource {
     /// Fills `bytes` with random bytes.
+    ///
+    /// Note that calling `fill_bytes` multiple times is not equivalent to calling `fill_bytes` once
+    /// with a larger buffer. A `RandomSource` is allowed to return different bytes for those two
+    /// cases. For instance, this allows a `RandomSource` to generate a word at a time and throw
+    /// part of it away if not needed.
     fn fill_bytes(&mut self, bytes: &mut [u8]);
 }
 
-- 
cgit 1.4.1-3-g733a5


From 42472f26452505cb42477990e6450bed21b3a50d Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Wed, 9 Jul 2025 22:49:41 +0200
Subject: add missing word

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

diff --git a/src/doc/rustc-dev-guide/src/tests/misc.md b/src/doc/rustc-dev-guide/src/tests/misc.md
index c0288b3dd10..39f88174879 100644
--- a/src/doc/rustc-dev-guide/src/tests/misc.md
+++ b/src/doc/rustc-dev-guide/src/tests/misc.md
@@ -9,7 +9,7 @@ for testing:
 
 - `RUSTC_BOOTSTRAP=1` will "cheat" and bypass usual stability checking, allowing
   you to use unstable features and cli flags on a stable `rustc`.
-- `RUSTC_BOOTSTRAP=-1` will force a given `rustc` to pretend that is a stable
+- `RUSTC_BOOTSTRAP=-1` will force a given `rustc` to pretend it is a stable
   compiler, even if it's actually a nightly `rustc`. This is useful because some
   behaviors of the compiler (e.g. diagnostics) can differ depending on whether
   the compiler is nightly or not.
-- 
cgit 1.4.1-3-g733a5


From d99af0b77cde2cc7d13419d7ca9b244afbcd365f Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Wed, 9 Jul 2025 23:02:16 +0200
Subject: distcheck had only one possible invocation

That is, calling it an example is misleading
---
 src/doc/rustc-dev-guide/src/tests/intro.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/intro.md b/src/doc/rustc-dev-guide/src/tests/intro.md
index c55d60f4a5c..e97574f02de 100644
--- a/src/doc/rustc-dev-guide/src/tests/intro.md
+++ b/src/doc/rustc-dev-guide/src/tests/intro.md
@@ -116,7 +116,9 @@ This requires building all of the documentation, which might take a while.
 `distcheck` verifies that the source distribution tarball created by the build
 system will unpack, build, and run all tests.
 
-> Example: `./x test distcheck`
+```console
+./x test distcheck
+```
 
 ### Tool tests
 
-- 
cgit 1.4.1-3-g733a5


From 99fc05bb1830f6c6132ff7b1e48e2e655c863ad6 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Wed, 9 Jul 2025 23:03:37 +0200
Subject: do not invent a name

Nowhere else is this called "Dist check"
---
 src/doc/rustc-dev-guide/src/tests/intro.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/intro.md b/src/doc/rustc-dev-guide/src/tests/intro.md
index c55d60f4a5c..84f99e9461e 100644
--- a/src/doc/rustc-dev-guide/src/tests/intro.md
+++ b/src/doc/rustc-dev-guide/src/tests/intro.md
@@ -111,7 +111,7 @@ and it can be invoked so:
 
 This requires building all of the documentation, which might take a while.
 
-### Dist check
+### `distcheck`
 
 `distcheck` verifies that the source distribution tarball created by the build
 system will unpack, build, and run all tests.
-- 
cgit 1.4.1-3-g733a5


From b286bc3141936114edcc7d124b2488e63ef4eb6f Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Wed, 9 Jul 2025 23:18:32 +0200
Subject: fix aux-build failures

---
 tests/ui/imports/ambiguous-1.rs            |  5 ++++-
 tests/ui/imports/ambiguous-1.stderr        | 32 +++++++++++++++++++-----------
 tests/ui/imports/ambiguous-2.rs            |  3 +--
 tests/ui/imports/ambiguous-4-extern.rs     |  5 ++++-
 tests/ui/imports/ambiguous-4-extern.stderr | 32 +++++++++++++++++++-----------
 tests/ui/imports/ambiguous-4.rs            |  3 +--
 6 files changed, 50 insertions(+), 30 deletions(-)

diff --git a/tests/ui/imports/ambiguous-1.rs b/tests/ui/imports/ambiguous-1.rs
index dca26b17466..31f39eee62b 100644
--- a/tests/ui/imports/ambiguous-1.rs
+++ b/tests/ui/imports/ambiguous-1.rs
@@ -1,5 +1,8 @@
+//@ check-pass
 // https://github.com/rust-lang/rust/pull/112743#issuecomment-1601986883
 
+#![warn(ambiguous_glob_imports)]
+
 macro_rules! m {
     () => {
       pub fn id() {}
@@ -24,6 +27,6 @@ pub use openssl::*;
 
 fn main() {
     id();
-    //~^ ERROR `id` is ambiguous
+    //~^ WARNING `id` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
diff --git a/tests/ui/imports/ambiguous-1.stderr b/tests/ui/imports/ambiguous-1.stderr
index c4b7fc41932..04ff3a36c74 100644
--- a/tests/ui/imports/ambiguous-1.stderr
+++ b/tests/ui/imports/ambiguous-1.stderr
@@ -1,5 +1,5 @@
 warning: ambiguous glob re-exports
-  --> $DIR/ambiguous-1.rs:10:13
+  --> $DIR/ambiguous-1.rs:13:13
    |
 LL |     pub use self::evp::*;
    |             ^^^^^^^^^^^^ the name `id` in the value namespace is first re-exported here
@@ -9,8 +9,8 @@ LL |     pub use self::handwritten::*;
    |
    = note: `#[warn(ambiguous_glob_reexports)]` on by default
 
-error: `id` is ambiguous
-  --> $DIR/ambiguous-1.rs:26:5
+warning: `id` is ambiguous
+  --> $DIR/ambiguous-1.rs:29:5
    |
 LL |     id();
    |     ^^ ambiguous name
@@ -19,24 +19,28 @@ LL |     id();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `id` could refer to the function imported here
-  --> $DIR/ambiguous-1.rs:10:13
+  --> $DIR/ambiguous-1.rs:13:13
    |
 LL |     pub use self::evp::*;
    |             ^^^^^^^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
 note: `id` could also refer to the function imported here
-  --> $DIR/ambiguous-1.rs:12:13
+  --> $DIR/ambiguous-1.rs:15:13
    |
 LL |     pub use self::handwritten::*;
    |             ^^^^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
-   = note: `#[deny(ambiguous_glob_imports)]` on by default
+note: the lint level is defined here
+  --> $DIR/ambiguous-1.rs:4:9
+   |
+LL | #![warn(ambiguous_glob_imports)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 1 previous error; 1 warning emitted
+warning: 2 warnings emitted
 
 Future incompatibility report: Future breakage diagnostic:
-error: `id` is ambiguous
-  --> $DIR/ambiguous-1.rs:26:5
+warning: `id` is ambiguous
+  --> $DIR/ambiguous-1.rs:29:5
    |
 LL |     id();
    |     ^^ ambiguous name
@@ -45,16 +49,20 @@ LL |     id();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `id` could refer to the function imported here
-  --> $DIR/ambiguous-1.rs:10:13
+  --> $DIR/ambiguous-1.rs:13:13
    |
 LL |     pub use self::evp::*;
    |             ^^^^^^^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
 note: `id` could also refer to the function imported here
-  --> $DIR/ambiguous-1.rs:12:13
+  --> $DIR/ambiguous-1.rs:15:13
    |
 LL |     pub use self::handwritten::*;
    |             ^^^^^^^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
-   = note: `#[deny(ambiguous_glob_imports)]` on by default
+note: the lint level is defined here
+  --> $DIR/ambiguous-1.rs:4:9
+   |
+LL | #![warn(ambiguous_glob_imports)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/ui/imports/ambiguous-2.rs b/tests/ui/imports/ambiguous-2.rs
index cffdcb9d922..087431485ad 100644
--- a/tests/ui/imports/ambiguous-2.rs
+++ b/tests/ui/imports/ambiguous-2.rs
@@ -1,5 +1,4 @@
-//@ ignore-test
-// ^^ don't know how to change this test
+//@ check-pass
 //@ aux-build: ../ambiguous-1.rs
 // https://github.com/rust-lang/rust/pull/113099#issuecomment-1633574396
 
diff --git a/tests/ui/imports/ambiguous-4-extern.rs b/tests/ui/imports/ambiguous-4-extern.rs
index b70d0484801..bc856af852d 100644
--- a/tests/ui/imports/ambiguous-4-extern.rs
+++ b/tests/ui/imports/ambiguous-4-extern.rs
@@ -1,5 +1,8 @@
+//@ check-pass
 // https://github.com/rust-lang/rust/pull/112743#issuecomment-1601986883
 
+#![warn(ambiguous_glob_imports)]
+
 macro_rules! m {
     () => {
       pub fn id() {}
@@ -20,6 +23,6 @@ mod handwritten {
 
 fn main() {
     id();
-    //~^ ERROR `id` is ambiguous
+    //~^ WARNING `id` is ambiguous
     //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 }
diff --git a/tests/ui/imports/ambiguous-4-extern.stderr b/tests/ui/imports/ambiguous-4-extern.stderr
index 3e79c455c42..a9427ac0350 100644
--- a/tests/ui/imports/ambiguous-4-extern.stderr
+++ b/tests/ui/imports/ambiguous-4-extern.stderr
@@ -1,5 +1,5 @@
 warning: ambiguous glob re-exports
-  --> $DIR/ambiguous-4-extern.rs:9:9
+  --> $DIR/ambiguous-4-extern.rs:12:9
    |
 LL | pub use evp::*;
    |         ^^^^^^ the name `id` in the value namespace is first re-exported here
@@ -8,8 +8,8 @@ LL | pub use handwritten::*;
    |
    = note: `#[warn(ambiguous_glob_reexports)]` on by default
 
-error: `id` is ambiguous
-  --> $DIR/ambiguous-4-extern.rs:22:5
+warning: `id` is ambiguous
+  --> $DIR/ambiguous-4-extern.rs:25:5
    |
 LL |     id();
    |     ^^ ambiguous name
@@ -18,24 +18,28 @@ LL |     id();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `id` could refer to the function imported here
-  --> $DIR/ambiguous-4-extern.rs:9:9
+  --> $DIR/ambiguous-4-extern.rs:12:9
    |
 LL | pub use evp::*;
    |         ^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
 note: `id` could also refer to the function imported here
-  --> $DIR/ambiguous-4-extern.rs:10:9
+  --> $DIR/ambiguous-4-extern.rs:13:9
    |
 LL | pub use handwritten::*;
    |         ^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
-   = note: `#[deny(ambiguous_glob_imports)]` on by default
+note: the lint level is defined here
+  --> $DIR/ambiguous-4-extern.rs:4:9
+   |
+LL | #![warn(ambiguous_glob_imports)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 1 previous error; 1 warning emitted
+warning: 2 warnings emitted
 
 Future incompatibility report: Future breakage diagnostic:
-error: `id` is ambiguous
-  --> $DIR/ambiguous-4-extern.rs:22:5
+warning: `id` is ambiguous
+  --> $DIR/ambiguous-4-extern.rs:25:5
    |
 LL |     id();
    |     ^^ ambiguous name
@@ -44,16 +48,20 @@ LL |     id();
    = note: for more information, see issue #114095 <https://github.com/rust-lang/rust/issues/114095>
    = note: ambiguous because of multiple glob imports of a name in the same module
 note: `id` could refer to the function imported here
-  --> $DIR/ambiguous-4-extern.rs:9:9
+  --> $DIR/ambiguous-4-extern.rs:12:9
    |
 LL | pub use evp::*;
    |         ^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
 note: `id` could also refer to the function imported here
-  --> $DIR/ambiguous-4-extern.rs:10:9
+  --> $DIR/ambiguous-4-extern.rs:13:9
    |
 LL | pub use handwritten::*;
    |         ^^^^^^^^^^^^^^
    = help: consider adding an explicit import of `id` to disambiguate
-   = note: `#[deny(ambiguous_glob_imports)]` on by default
+note: the lint level is defined here
+  --> $DIR/ambiguous-4-extern.rs:4:9
+   |
+LL | #![warn(ambiguous_glob_imports)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/ui/imports/ambiguous-4.rs b/tests/ui/imports/ambiguous-4.rs
index e367c120adf..3a9a14bfb52 100644
--- a/tests/ui/imports/ambiguous-4.rs
+++ b/tests/ui/imports/ambiguous-4.rs
@@ -1,5 +1,4 @@
-//@ ignore-test
-// ^^ don't know how to change this test
+//@ check-pass
 //@ aux-build: ../ambiguous-4-extern.rs
 
 extern crate ambiguous_4_extern;
-- 
cgit 1.4.1-3-g733a5


From e9e31b1a932314e086b246fabb94623dda8fbafa Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Tue, 8 Jul 2025 23:52:20 +0200
Subject: MacroData in ResolverArenas + split macro_map into extern_macro_map
 and local_macro_map.

---
 compiler/rustc_resolve/src/build_reduced_graph.rs | 36 ++++++++++++-----------
 compiler/rustc_resolve/src/def_collector.rs       |  2 +-
 compiler/rustc_resolve/src/diagnostics.rs         |  9 ++++--
 compiler/rustc_resolve/src/lib.rs                 | 24 +++++++++++----
 compiler/rustc_resolve/src/macros.rs              |  8 ++---
 5 files changed, 50 insertions(+), 29 deletions(-)

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index f775cac149e..ef122deba4e 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -162,28 +162,30 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
-    pub(crate) fn get_macro(&mut self, res: Res) -> Option<&MacroData> {
+    pub(crate) fn get_macro(&self, res: Res) -> Option<&'ra MacroData> {
         match res {
             Res::Def(DefKind::Macro(..), def_id) => Some(self.get_macro_by_def_id(def_id)),
-            Res::NonMacroAttr(_) => Some(&self.non_macro_attr),
+            Res::NonMacroAttr(_) => Some(self.non_macro_attr),
             _ => None,
         }
     }
 
-    pub(crate) fn get_macro_by_def_id(&mut self, def_id: DefId) -> &MacroData {
-        if self.macro_map.contains_key(&def_id) {
-            return &self.macro_map[&def_id];
-        }
-
-        let loaded_macro = self.cstore().load_macro_untracked(def_id, self.tcx);
-        let macro_data = match loaded_macro {
-            LoadedMacro::MacroDef { def, ident, attrs, span, edition } => {
-                self.compile_macro(&def, ident, &attrs, span, ast::DUMMY_NODE_ID, edition)
-            }
-            LoadedMacro::ProcMacro(ext) => MacroData::new(Arc::new(ext)),
-        };
+    pub(crate) fn get_macro_by_def_id(&self, def_id: DefId) -> &'ra MacroData {
+        // Local macros are always compiled.
+        match def_id.as_local() {
+            Some(local_def_id) => self.local_macro_map[&local_def_id],
+            None => *self.extern_macro_map.borrow_mut().entry(def_id).or_insert_with(|| {
+                let loaded_macro = self.cstore().load_macro_untracked(def_id, self.tcx);
+                let macro_data = match loaded_macro {
+                    LoadedMacro::MacroDef { def, ident, attrs, span, edition } => {
+                        self.compile_macro(&def, ident, &attrs, span, ast::DUMMY_NODE_ID, edition)
+                    }
+                    LoadedMacro::ProcMacro(ext) => MacroData::new(Arc::new(ext)),
+                };
 
-        self.macro_map.entry(def_id).or_insert(macro_data)
+                self.arenas.alloc_macro(macro_data)
+            }),
+        }
     }
 
     pub(crate) fn build_reduced_graph(
@@ -1203,7 +1205,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
     fn insert_unused_macro(&mut self, ident: Ident, def_id: LocalDefId, node_id: NodeId) {
         if !ident.as_str().starts_with('_') {
             self.r.unused_macros.insert(def_id, (node_id, ident));
-            let nrules = self.r.macro_map[&def_id.to_def_id()].nrules;
+            let nrules = self.r.local_macro_map[&def_id].nrules;
             self.r.unused_macro_rules.insert(node_id, DenseBitSet::new_filled(nrules));
         }
     }
@@ -1222,7 +1224,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                     Some((macro_kind, ident, span)) => {
                         let res = Res::Def(DefKind::Macro(macro_kind), def_id.to_def_id());
                         let macro_data = MacroData::new(self.r.dummy_ext(macro_kind));
-                        self.r.macro_map.insert(def_id.to_def_id(), macro_data);
+                        self.r.new_local_macro(def_id, macro_data);
                         self.r.proc_macro_stubs.insert(def_id);
                         (res, ident, span, false)
                     }
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index 1e345b11c14..e2caf632dd2 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -165,7 +165,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
             self.create_def(i.id, i.kind.ident().map(|ident| ident.name), def_kind, i.span);
 
         if let Some(macro_data) = opt_macro_data {
-            self.resolver.macro_map.insert(def_id.to_def_id(), macro_data);
+            self.resolver.new_local_macro(def_id, macro_data);
         }
 
         self.with_parent(def_id, |this| {
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index c99bc747fd2..c4ff5770e76 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1669,9 +1669,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut all_attrs: UnordMap<Symbol, Vec<_>> = UnordMap::default();
         // We're collecting these in a hashmap, and handle ordering the output further down.
         #[allow(rustc::potential_query_instability)]
-        for (def_id, data) in &self.macro_map {
+        for (def_id, data) in self
+            .local_macro_map
+            .iter()
+            .map(|(local_id, data)| (local_id.to_def_id(), data))
+            .chain(self.extern_macro_map.borrow().iter().map(|(id, d)| (*id, d)))
+        {
             for helper_attr in &data.ext.helper_attrs {
-                let item_name = self.tcx.item_name(*def_id);
+                let item_name = self.tcx.item_name(def_id);
                 all_attrs.entry(*helper_attr).or_default().push(item_name);
                 if helper_attr == &ident.name {
                     derives.push(item_name);
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index f8ca20c568f..f6c56c9a46a 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -1128,10 +1128,12 @@ pub struct Resolver<'ra, 'tcx> {
     builtin_macros: FxHashMap<Symbol, SyntaxExtensionKind>,
     registered_tools: &'tcx RegisteredTools,
     macro_use_prelude: FxIndexMap<Symbol, NameBinding<'ra>>,
-    macro_map: FxHashMap<DefId, MacroData>,
+    local_macro_map: FxHashMap<LocalDefId, &'ra MacroData>,
+    /// Lazily populated cache of macros loaded from external crates.
+    extern_macro_map: RefCell<FxHashMap<DefId, &'ra MacroData>>,
     dummy_ext_bang: Arc<SyntaxExtension>,
     dummy_ext_derive: Arc<SyntaxExtension>,
-    non_macro_attr: MacroData,
+    non_macro_attr: &'ra MacroData,
     local_macro_def_scopes: FxHashMap<LocalDefId, Module<'ra>>,
     ast_transform_scopes: FxHashMap<LocalExpnId, Module<'ra>>,
     unused_macros: FxIndexMap<LocalDefId, (NodeId, Ident)>,
@@ -1241,6 +1243,7 @@ pub struct ResolverArenas<'ra> {
     imports: TypedArena<ImportData<'ra>>,
     name_resolutions: TypedArena<RefCell<NameResolution<'ra>>>,
     ast_paths: TypedArena<ast::Path>,
+    macros: TypedArena<MacroData>,
     dropless: DroplessArena,
 }
 
@@ -1298,6 +1301,9 @@ impl<'ra> ResolverArenas<'ra> {
     fn alloc_ast_paths(&'ra self, paths: &[ast::Path]) -> &'ra [ast::Path] {
         self.ast_paths.alloc_from_iter(paths.iter().cloned())
     }
+    fn alloc_macro(&'ra self, macro_data: MacroData) -> &'ra MacroData {
+        self.macros.alloc(macro_data)
+    }
     fn alloc_pattern_spans(&'ra self, spans: impl Iterator<Item = Span>) -> &'ra [Span] {
         self.dropless.alloc_from_iter(spans)
     }
@@ -1540,10 +1546,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             builtin_macros: Default::default(),
             registered_tools,
             macro_use_prelude: Default::default(),
-            macro_map: FxHashMap::default(),
+            local_macro_map: Default::default(),
+            extern_macro_map: Default::default(),
             dummy_ext_bang: Arc::new(SyntaxExtension::dummy_bang(edition)),
             dummy_ext_derive: Arc::new(SyntaxExtension::dummy_derive(edition)),
-            non_macro_attr: MacroData::new(Arc::new(SyntaxExtension::non_macro_attr(edition))),
+            non_macro_attr: arenas
+                .alloc_macro(MacroData::new(Arc::new(SyntaxExtension::non_macro_attr(edition)))),
             invocation_parent_scopes: Default::default(),
             output_macro_rules_scopes: Default::default(),
             macro_rules_scopes: Default::default(),
@@ -1616,6 +1624,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         )
     }
 
+    fn new_local_macro(&mut self, def_id: LocalDefId, macro_data: MacroData) -> &'ra MacroData {
+        let mac = self.arenas.alloc_macro(macro_data);
+        self.local_macro_map.insert(def_id, mac);
+        mac
+    }
+
     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");
@@ -1734,7 +1748,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         f(self, MacroNS);
     }
 
-    fn is_builtin_macro(&mut self, res: Res) -> bool {
+    fn is_builtin_macro(&self, res: Res) -> bool {
         self.get_macro(res).is_some_and(|macro_data| macro_data.ext.builtin_name.is_some())
     }
 
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index acbefe53422..c45d18900e2 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -354,8 +354,8 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
             if unused_arms.is_empty() {
                 continue;
             }
-            let def_id = self.local_def_id(node_id).to_def_id();
-            let m = &self.macro_map[&def_id];
+            let def_id = self.local_def_id(node_id);
+            let m = &self.local_macro_map[&def_id];
             let SyntaxExtensionKind::LegacyBang(ref ext) = m.ext.kind else {
                 continue;
             };
@@ -1132,7 +1132,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
-    pub(crate) fn check_reserved_macro_name(&mut self, ident: Ident, res: Res) {
+    pub(crate) fn check_reserved_macro_name(&self, ident: Ident, res: Res) {
         // Reserve some names that are not quite covered by the general check
         // performed on `Resolver::builtin_attrs`.
         if ident.name == sym::cfg || ident.name == sym::cfg_attr {
@@ -1148,7 +1148,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     ///
     /// Possibly replace its expander to a pre-defined one for built-in macros.
     pub(crate) fn compile_macro(
-        &mut self,
+        &self,
         macro_def: &ast::MacroDef,
         ident: Ident,
         attrs: &[rustc_hir::Attribute],
-- 
cgit 1.4.1-3-g733a5


From e56678378bd0ef967074ed6b07fc9ea7d9ce4070 Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Wed, 9 Jul 2025 17:49:05 +0200
Subject: Use reference for MacroRulesScopeRef instead of Interned.

---
 compiler/rustc_resolve/src/lib.rs    | 2 +-
 compiler/rustc_resolve/src/macros.rs | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index f6c56c9a46a..6e4c5ef1909 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -1290,7 +1290,7 @@ impl<'ra> ResolverArenas<'ra> {
         self.name_resolutions.alloc(Default::default())
     }
     fn alloc_macro_rules_scope(&'ra self, scope: MacroRulesScope<'ra>) -> MacroRulesScopeRef<'ra> {
-        Interned::new_unchecked(self.dropless.alloc(Cell::new(scope)))
+        self.dropless.alloc(Cell::new(scope))
     }
     fn alloc_macro_rules_binding(
         &'ra self,
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index c45d18900e2..89bbe8dad98 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -9,7 +9,6 @@ use rustc_ast::expand::StrippedCfgItem;
 use rustc_ast::{self as ast, Crate, NodeId, attr};
 use rustc_ast_pretty::pprust;
 use rustc_attr_data_structures::StabilityLevel;
-use rustc_data_structures::intern::Interned;
 use rustc_errors::{Applicability, DiagCtxtHandle, StashKey};
 use rustc_expand::base::{
     Annotatable, DeriveResolution, Indeterminate, ResolverExpand, SyntaxExtension,
@@ -80,7 +79,7 @@ pub(crate) enum MacroRulesScope<'ra> {
 /// This helps to avoid uncontrollable growth of `macro_rules!` scope chains,
 /// which usually grow linearly with the number of macro invocations
 /// in a module (including derives) and hurt performance.
-pub(crate) type MacroRulesScopeRef<'ra> = Interned<'ra, Cell<MacroRulesScope<'ra>>>;
+pub(crate) type MacroRulesScopeRef<'ra> = &'ra Cell<MacroRulesScope<'ra>>;
 
 /// Macro namespace is separated into two sub-namespaces, one for bang macros and
 /// one for attribute-like macros (attributes, derives).
-- 
cgit 1.4.1-3-g733a5


From 45a1e492b1adfc6f7664d1da736dff147e5c3168 Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Wed, 9 Jul 2025 16:40:22 -0500
Subject: feat(lexer): Allow including frontmatter with 'tokenize'

---
 compiler/rustc_ast_pretty/src/pprust/state.rs      |  2 +-
 compiler/rustc_lexer/src/lib.rs                    | 29 ++++++++++++++--------
 compiler/rustc_lexer/src/tests.rs                  |  3 ++-
 .../clippy_lints/src/undocumented_unsafe_blocks.rs |  4 +--
 .../src/utils/format_args_collector.rs             |  4 +--
 src/tools/clippy/clippy_utils/src/consts.rs        | 12 +++------
 src/tools/clippy/clippy_utils/src/hir_utils.rs     |  4 +--
 src/tools/clippy/clippy_utils/src/lib.rs           |  6 ++---
 src/tools/clippy/clippy_utils/src/source.rs        |  7 +++---
 .../rust-analyzer/crates/parser/src/lexed_str.rs   | 10 +++++---
 .../crates/proc-macro-srv/src/server_impl.rs       |  2 +-
 src/tools/rust-analyzer/crates/tt/src/lib.rs       |  2 +-
 12 files changed, 47 insertions(+), 38 deletions(-)

diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index aff98c63bcb..9d656253f72 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -120,7 +120,7 @@ fn gather_comments(sm: &SourceMap, path: FileName, src: String) -> Vec<Comment>
         pos += shebang_len;
     }
 
-    for token in rustc_lexer::tokenize(&text[pos..]) {
+    for token in rustc_lexer::tokenize(&text[pos..], rustc_lexer::FrontmatterAllowed::No) {
         let token_text = &text[pos..pos + token.len as usize];
         match token.kind {
             rustc_lexer::TokenKind::Whitespace => {
diff --git a/compiler/rustc_lexer/src/lib.rs b/compiler/rustc_lexer/src/lib.rs
index e30dbe80248..e80196ed567 100644
--- a/compiler/rustc_lexer/src/lib.rs
+++ b/compiler/rustc_lexer/src/lib.rs
@@ -273,14 +273,15 @@ pub fn strip_shebang(input: &str) -> Option<usize> {
     if let Some(input_tail) = input.strip_prefix("#!") {
         // Ok, this is a shebang but if the next non-whitespace token is `[`,
         // then it may be valid Rust code, so consider it Rust code.
-        let next_non_whitespace_token = tokenize(input_tail).map(|tok| tok.kind).find(|tok| {
-            !matches!(
-                tok,
-                TokenKind::Whitespace
-                    | TokenKind::LineComment { doc_style: None }
-                    | TokenKind::BlockComment { doc_style: None, .. }
-            )
-        });
+        let next_non_whitespace_token =
+            tokenize(input_tail, FrontmatterAllowed::No).map(|tok| tok.kind).find(|tok| {
+                !matches!(
+                    tok,
+                    TokenKind::Whitespace
+                        | TokenKind::LineComment { doc_style: None }
+                        | TokenKind::BlockComment { doc_style: None, .. }
+                )
+            });
         if next_non_whitespace_token != Some(TokenKind::OpenBracket) {
             // No other choice than to consider this a shebang.
             return Some(2 + input_tail.lines().next().unwrap_or_default().len());
@@ -303,8 +304,16 @@ pub fn validate_raw_str(input: &str, prefix_len: u32) -> Result<(), RawStrError>
 }
 
 /// Creates an iterator that produces tokens from the input string.
-pub fn tokenize(input: &str) -> impl Iterator<Item = Token> {
-    let mut cursor = Cursor::new(input, FrontmatterAllowed::No);
+///
+/// When parsing a full Rust document,
+/// first [`strip_shebang`] and then allow frontmatters with [`FrontmatterAllowed::Yes`].
+///
+/// When tokenizing a slice of a document, be sure to disallow frontmatters with [`FrontmatterAllowed::No`]
+pub fn tokenize(
+    input: &str,
+    frontmatter_allowed: FrontmatterAllowed,
+) -> impl Iterator<Item = Token> {
+    let mut cursor = Cursor::new(input, frontmatter_allowed);
     std::iter::from_fn(move || {
         let token = cursor.advance_token();
         if token.kind != TokenKind::Eof { Some(token) } else { None }
diff --git a/compiler/rustc_lexer/src/tests.rs b/compiler/rustc_lexer/src/tests.rs
index fc8d9b9d57b..a9fcb481759 100644
--- a/compiler/rustc_lexer/src/tests.rs
+++ b/compiler/rustc_lexer/src/tests.rs
@@ -125,7 +125,8 @@ fn test_valid_shebang() {
 }
 
 fn check_lexing(src: &str, expect: Expect) {
-    let actual: String = tokenize(src).map(|token| format!("{:?}\n", token)).collect();
+    let actual: String =
+        tokenize(src, FrontmatterAllowed::No).map(|token| format!("{:?}\n", token)).collect();
     expect.assert_eq(&actual)
 }
 
diff --git a/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs b/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
index 6cc4b589a72..8906e654c97 100644
--- a/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -9,7 +9,7 @@ use clippy_utils::visitors::{Descend, for_each_expr};
 use hir::HirId;
 use rustc_hir as hir;
 use rustc_hir::{Block, BlockCheckMode, ItemKind, Node, UnsafeSource};
-use rustc_lexer::{TokenKind, tokenize};
+use rustc_lexer::{FrontmatterAllowed, TokenKind, tokenize};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
 use rustc_span::{BytePos, Pos, RelativeBytePos, Span, SyntaxContext};
@@ -746,7 +746,7 @@ fn text_has_safety_comment(src: &str, line_starts: &[RelativeBytePos], start_pos
     loop {
         if line.starts_with("/*") {
             let src = &src[line_start..line_starts.last().unwrap().to_usize()];
-            let mut tokens = tokenize(src);
+            let mut tokens = tokenize(src, FrontmatterAllowed::No);
             return (src[..tokens.next().unwrap().len as usize]
                 .to_ascii_uppercase()
                 .contains("SAFETY:")
diff --git a/src/tools/clippy/clippy_lints/src/utils/format_args_collector.rs b/src/tools/clippy/clippy_lints/src/utils/format_args_collector.rs
index 8f314ce7a60..6629a67f78b 100644
--- a/src/tools/clippy/clippy_lints/src/utils/format_args_collector.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/format_args_collector.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::SpanRangeExt;
 use itertools::Itertools;
 use rustc_ast::{Crate, Expr, ExprKind, FormatArgs};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_lexer::{TokenKind, tokenize};
+use rustc_lexer::{FrontmatterAllowed, TokenKind, tokenize};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::impl_lint_pass;
 use rustc_span::{Span, hygiene};
@@ -82,7 +82,7 @@ fn has_span_from_proc_macro(cx: &EarlyContext<'_>, args: &FormatArgs) -> bool {
         .all(|sp| {
             sp.check_source_text(cx, |src| {
                 // text should be either `, name` or `, name =`
-                let mut iter = tokenize(src).filter(|t| {
+                let mut iter = tokenize(src, FrontmatterAllowed::No).filter(|t| {
                     !matches!(
                         t.kind,
                         TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace
diff --git a/src/tools/clippy/clippy_utils/src/consts.rs b/src/tools/clippy/clippy_utils/src/consts.rs
index ba0376e4d40..25afa12e95d 100644
--- a/src/tools/clippy/clippy_utils/src/consts.rs
+++ b/src/tools/clippy/clippy_utils/src/consts.rs
@@ -15,7 +15,7 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{
     BinOpKind, Block, ConstBlock, Expr, ExprKind, HirId, Item, ItemKind, Node, PatExpr, PatExprKind, QPath, UnOp,
 };
-use rustc_lexer::tokenize;
+use rustc_lexer::{FrontmatterAllowed, tokenize};
 use rustc_lint::LateContext;
 use rustc_middle::mir::ConstValue;
 use rustc_middle::mir::interpret::{Scalar, alloc_range};
@@ -304,9 +304,7 @@ pub fn lit_to_mir_constant<'tcx>(lit: &LitKind, ty: Option<Ty<'tcx>>) -> Constan
     match *lit {
         LitKind::Str(ref is, _) => Constant::Str(is.to_string()),
         LitKind::Byte(b) => Constant::Int(u128::from(b)),
-        LitKind::ByteStr(ref s, _) | LitKind::CStr(ref s, _) => {
-            Constant::Binary(s.as_byte_str().to_vec())
-        }
+        LitKind::ByteStr(ref s, _) | LitKind::CStr(ref s, _) => Constant::Binary(s.as_byte_str().to_vec()),
         LitKind::Char(c) => Constant::Char(c),
         LitKind::Int(n, _) => Constant::Int(n.get()),
         LitKind::Float(ref is, LitFloatType::Suffixed(fty)) => match fty {
@@ -568,9 +566,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
                 } else {
                     match &lit.node {
                         LitKind::Str(is, _) => Some(is.is_empty()),
-                        LitKind::ByteStr(s, _) | LitKind::CStr(s, _) => {
-                            Some(s.as_byte_str().is_empty())
-                        }
+                        LitKind::ByteStr(s, _) | LitKind::CStr(s, _) => Some(s.as_byte_str().is_empty()),
                         _ => None,
                     }
                 }
@@ -715,7 +711,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
                     && let Some(src) = src.as_str()
                 {
                     use rustc_lexer::TokenKind::{BlockComment, LineComment, OpenBrace, Semi, Whitespace};
-                    if !tokenize(src)
+                    if !tokenize(src, FrontmatterAllowed::No)
                         .map(|t| t.kind)
                         .filter(|t| !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. } | Semi))
                         .eq([OpenBrace])
diff --git a/src/tools/clippy/clippy_utils/src/hir_utils.rs b/src/tools/clippy/clippy_utils/src/hir_utils.rs
index 0ca494f16e3..6e8dccbccd5 100644
--- a/src/tools/clippy/clippy_utils/src/hir_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@ -12,7 +12,7 @@ use rustc_hir::{
     Pat, PatExpr, PatExprKind, PatField, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, StructTailExpr,
     TraitBoundModifiers, Ty, TyKind, TyPat, TyPatKind,
 };
-use rustc_lexer::{TokenKind, tokenize};
+use rustc_lexer::{FrontmatterAllowed, TokenKind, tokenize};
 use rustc_lint::LateContext;
 use rustc_middle::ty::TypeckResults;
 use rustc_span::{BytePos, ExpnKind, MacroKind, Symbol, SyntaxContext, sym};
@@ -686,7 +686,7 @@ fn reduce_exprkind<'hir>(cx: &LateContext<'_>, kind: &'hir ExprKind<'hir>) -> &'
             // `{}` => `()`
             ([], None)
                 if block.span.check_source_text(cx, |src| {
-                    tokenize(src)
+                    tokenize(src, FrontmatterAllowed::No)
                         .map(|t| t.kind)
                         .filter(|t| {
                             !matches!(
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index c01f0ffaac9..98b4c183b12 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -106,7 +106,7 @@ use rustc_hir::{
     Param, Pat, PatExpr, PatExprKind, PatKind, Path, PathSegment, QPath, Stmt, StmtKind, TraitFn, TraitItem,
     TraitItemKind, TraitRef, TyKind, UnOp, def,
 };
-use rustc_lexer::{TokenKind, tokenize};
+use rustc_lexer::{FrontmatterAllowed, TokenKind, tokenize};
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::hir::place::PlaceBase;
@@ -2764,7 +2764,7 @@ pub fn expr_use_ctxt<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'tcx>) -> ExprUseCtx
 /// Tokenizes the input while keeping the text associated with each token.
 pub fn tokenize_with_text(s: &str) -> impl Iterator<Item = (TokenKind, &str, InnerSpan)> {
     let mut pos = 0;
-    tokenize(s).map(move |t| {
+    tokenize(s, FrontmatterAllowed::No).map(move |t| {
         let end = pos + t.len;
         let range = pos as usize..end as usize;
         let inner = InnerSpan::new(range.start, range.end);
@@ -2779,7 +2779,7 @@ pub fn span_contains_comment(sm: &SourceMap, span: Span) -> bool {
     let Ok(snippet) = sm.span_to_snippet(span) else {
         return false;
     };
-    return tokenize(&snippet).any(|token| {
+    return tokenize(&snippet, FrontmatterAllowed::No).any(|token| {
         matches!(
             token.kind,
             TokenKind::BlockComment { .. } | TokenKind::LineComment { .. }
diff --git a/src/tools/clippy/clippy_utils/src/source.rs b/src/tools/clippy/clippy_utils/src/source.rs
index 7f2bf99daff..7d21336be1c 100644
--- a/src/tools/clippy/clippy_utils/src/source.rs
+++ b/src/tools/clippy/clippy_utils/src/source.rs
@@ -7,7 +7,7 @@ use std::sync::Arc;
 use rustc_ast::{LitKind, StrStyle};
 use rustc_errors::Applicability;
 use rustc_hir::{BlockCheckMode, Expr, ExprKind, UnsafeSource};
-use rustc_lexer::{LiteralKind, TokenKind, tokenize};
+use rustc_lexer::{FrontmatterAllowed, LiteralKind, TokenKind, tokenize};
 use rustc_lint::{EarlyContext, LateContext};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
@@ -277,7 +277,7 @@ fn map_range(
 }
 
 fn ends_with_line_comment_or_broken(text: &str) -> bool {
-    let Some(last) = tokenize(text).last() else {
+    let Some(last) = tokenize(text, FrontmatterAllowed::No).last() else {
         return false;
     };
     match last.kind {
@@ -310,7 +310,8 @@ fn with_leading_whitespace_inner(lines: &[RelativeBytePos], src: &str, range: Ra
         && ends_with_line_comment_or_broken(&start[prev_start..])
         && let next_line = lines.partition_point(|&pos| pos.to_usize() < range.end)
         && let next_start = lines.get(next_line).map_or(src.len(), |&x| x.to_usize())
-        && tokenize(src.get(range.end..next_start)?).any(|t| !matches!(t.kind, TokenKind::Whitespace))
+        && tokenize(src.get(range.end..next_start)?, FrontmatterAllowed::No)
+            .any(|t| !matches!(t.kind, TokenKind::Whitespace))
     {
         Some(range.start)
     } else {
diff --git a/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs b/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
index e6c92dec681..bff9acd78fa 100644
--- a/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
@@ -11,8 +11,8 @@
 use std::ops;
 
 use rustc_literal_escaper::{
-    EscapeError, Mode, unescape_byte, unescape_byte_str, unescape_c_str, unescape_char,
-    unescape_str,
+    unescape_byte, unescape_byte_str, unescape_c_str, unescape_char, unescape_str, EscapeError,
+    Mode,
 };
 
 use crate::{
@@ -44,7 +44,9 @@ impl<'a> LexedStr<'a> {
 
         // Re-create the tokenizer from scratch every token because `GuardedStrPrefix` is one token in the lexer
         // but we want to split it to two in edition <2024.
-        while let Some(token) = rustc_lexer::tokenize(&text[conv.offset..]).next() {
+        while let Some(token) =
+            rustc_lexer::tokenize(&text[conv.offset..], rustc_lexer::FrontmatterAllowed::No).next()
+        {
             let token_text = &text[conv.offset..][..token.len as usize];
 
             conv.extend_token(&token.kind, token_text);
@@ -58,7 +60,7 @@ impl<'a> LexedStr<'a> {
             return None;
         }
 
-        let token = rustc_lexer::tokenize(text).next()?;
+        let token = rustc_lexer::tokenize(text, rustc_lexer::FrontmatterAllowed::No).next()?;
         if token.len as usize != text.len() {
             return None;
         }
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl.rs b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl.rs
index dd576f23ae9..662f6257642 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl.rs
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/src/server_impl.rs
@@ -121,7 +121,7 @@ pub(super) fn literal_from_str<Span: Copy>(
     use proc_macro::bridge::LitKind;
     use rustc_lexer::{LiteralKind, Token, TokenKind};
 
-    let mut tokens = rustc_lexer::tokenize(s);
+    let mut tokens = rustc_lexer::tokenize(s, rustc_lexer::FrontmatterAllowed::No);
     let minus_or_lit = tokens.next().unwrap_or(Token { kind: TokenKind::Eof, len: 0 });
 
     let lit = if minus_or_lit.kind == TokenKind::Minus {
diff --git a/src/tools/rust-analyzer/crates/tt/src/lib.rs b/src/tools/rust-analyzer/crates/tt/src/lib.rs
index 14574a6456b..44123385c8c 100644
--- a/src/tools/rust-analyzer/crates/tt/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/tt/src/lib.rs
@@ -579,7 +579,7 @@ where
 {
     use rustc_lexer::LiteralKind;
 
-    let token = rustc_lexer::tokenize(text).next_tuple();
+    let token = rustc_lexer::tokenize(text, rustc_lexer::FrontmatterAllowed::No).next_tuple();
     let Some((rustc_lexer::Token {
         kind: rustc_lexer::TokenKind::Literal { kind, suffix_start },
         ..
-- 
cgit 1.4.1-3-g733a5


From 27fb02c947a3aec673364ee555c0c24d8215b7c7 Mon Sep 17 00:00:00 2001
From: Predrag Gruevski <obi1kenobi82@gmail.com>
Date: Wed, 9 Jul 2025 01:32:23 +0000
Subject: Add rustdoc JSON tests for `#[doc(hidden)]` handling of items.

---
 tests/rustdoc-json/visibility/doc_hidden_default.rs   | 19 +++++++++++++++++++
 .../rustdoc-json/visibility/doc_hidden_documented.rs  | 17 +++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 tests/rustdoc-json/visibility/doc_hidden_default.rs
 create mode 100644 tests/rustdoc-json/visibility/doc_hidden_documented.rs

diff --git a/tests/rustdoc-json/visibility/doc_hidden_default.rs b/tests/rustdoc-json/visibility/doc_hidden_default.rs
new file mode 100644
index 00000000000..3fa91b3c4ad
--- /dev/null
+++ b/tests/rustdoc-json/visibility/doc_hidden_default.rs
@@ -0,0 +1,19 @@
+#![no_std]
+
+// Without `--document-hidden-items`,
+// none of these items are present in rustdoc JSON.
+
+//@ !has "$.index[?(@.name=='func')]"
+#[doc(hidden)]
+pub fn func() {}
+
+//@ !has "$.index[?(@.name=='Unit')]"
+#[doc(hidden)]
+pub struct Unit;
+
+//@ !has "$.index[?(@.name=='hidden')]"
+#[doc(hidden)]
+pub mod hidden {
+    //@ !has "$.index[?(@.name=='Inner')]"
+    pub struct Inner;
+}
diff --git a/tests/rustdoc-json/visibility/doc_hidden_documented.rs b/tests/rustdoc-json/visibility/doc_hidden_documented.rs
new file mode 100644
index 00000000000..6e9ef48680b
--- /dev/null
+++ b/tests/rustdoc-json/visibility/doc_hidden_documented.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: --document-hidden-items
+#![no_std]
+
+//@ is "$.index[?(@.name=='func')].attrs" '["#[doc(hidden)]"]'
+#[doc(hidden)]
+pub fn func() {}
+
+//@ is "$.index[?(@.name=='Unit')].attrs" '["#[doc(hidden)]"]'
+#[doc(hidden)]
+pub struct Unit;
+
+//@ is "$.index[?(@.name=='hidden')].attrs" '["#[doc(hidden)]"]'
+#[doc(hidden)]
+pub mod hidden {
+    //@ is "$.index[?(@.name=='Inner')].attrs" '[]'
+    pub struct Inner;
+}
-- 
cgit 1.4.1-3-g733a5


From e7ef31d651be6aa8809933fabb793b98300b970f Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sat, 21 Jun 2025 01:01:20 -0400
Subject: mbe: Refactor diagnostics for invalid metavar expression syntax

Give a more user-friendly diagnostic about the following:

* Trailing tokens within braces, e.g. `${foo() extra}`
* Missing parentheses, e.g. `${foo}`
* Incorrect number of arguments, with a hint about correct usage.
---
 compiler/rustc_expand/messages.ftl                 |  21 +++
 compiler/rustc_expand/src/errors.rs                |  34 ++++
 compiler/rustc_expand/src/mbe/metavar_expr.rs      |  84 ++++++++--
 .../ui/macros/metavar-expressions/syntax-errors.rs |  31 ++--
 .../metavar-expressions/syntax-errors.stderr       | 186 ++++++++++-----------
 5 files changed, 234 insertions(+), 122 deletions(-)

diff --git a/compiler/rustc_expand/messages.ftl b/compiler/rustc_expand/messages.ftl
index 3fc0fa06191..7b8c1e076a0 100644
--- a/compiler/rustc_expand/messages.ftl
+++ b/compiler/rustc_expand/messages.ftl
@@ -133,6 +133,27 @@ expand_module_multiple_candidates =
 expand_must_repeat_once =
     this must repeat at least once
 
+expand_mve_extra_tokens =
+    unexpected trailing tokens
+    .label = for this metavariable expression
+    .range = the `{$name}` metavariable expression takes between {$min_or_exact_args} and {$max_args} arguments
+    .exact = the `{$name}` metavariable expression takes {$min_or_exact_args ->
+        [zero] no arguments
+        [one] a single argument
+        *[other] {$min_or_exact_args} arguments
+    }
+    .suggestion = try removing {$extra_count ->
+        [one] this token
+        *[other] these tokens
+    }
+
+expand_mve_missing_paren =
+    expected `(`
+    .label = for this this metavariable expression
+    .unexpected = unexpected token
+    .note = metavariable expressions use function-like parentheses syntax
+    .suggestion = try adding parentheses
+
 expand_mve_unrecognized_var =
     variable `{$key}` is not recognized in meta-variable expression
 
diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs
index fdbc65aff68..b56a2b043e7 100644
--- a/compiler/rustc_expand/src/errors.rs
+++ b/compiler/rustc_expand/src/errors.rs
@@ -496,6 +496,40 @@ pub(crate) use metavar_exprs::*;
 mod metavar_exprs {
     use super::*;
 
+    #[derive(Diagnostic, Default)]
+    #[diag(expand_mve_extra_tokens)]
+    pub(crate) struct MveExtraTokens {
+        #[primary_span]
+        #[suggestion(code = "", applicability = "machine-applicable")]
+        pub span: Span,
+        #[label]
+        pub ident_span: Span,
+        pub extra_count: usize,
+
+        // The rest is only used for specific diagnostics and can be default if neither
+        // `note` is `Some`.
+        #[note(expand_exact)]
+        pub exact_args_note: Option<()>,
+        #[note(expand_range)]
+        pub range_args_note: Option<()>,
+        pub min_or_exact_args: usize,
+        pub max_args: usize,
+        pub name: String,
+    }
+
+    #[derive(Diagnostic)]
+    #[note]
+    #[diag(expand_mve_missing_paren)]
+    pub(crate) struct MveMissingParen {
+        #[primary_span]
+        #[label]
+        pub ident_span: Span,
+        #[label(expand_unexpected)]
+        pub unexpected_span: Option<Span>,
+        #[suggestion(code = "( /* ... */ )", applicability = "has-placeholders")]
+        pub insert_span: Option<Span>,
+    }
+
     #[derive(Diagnostic)]
     #[diag(expand_mve_unrecognized_var)]
     pub(crate) struct MveUnrecognizedVar {
diff --git a/compiler/rustc_expand/src/mbe/metavar_expr.rs b/compiler/rustc_expand/src/mbe/metavar_expr.rs
index ffd3548019a..8f15b5794c7 100644
--- a/compiler/rustc_expand/src/mbe/metavar_expr.rs
+++ b/compiler/rustc_expand/src/mbe/metavar_expr.rs
@@ -7,6 +7,8 @@ use rustc_macros::{Decodable, Encodable};
 use rustc_session::parse::ParseSess;
 use rustc_span::{Ident, Span, Symbol};
 
+use crate::errors;
+
 pub(crate) const RAW_IDENT_ERR: &str = "`${concat(..)}` currently does not support raw identifiers";
 pub(crate) const UNSUPPORTED_CONCAT_ELEM_ERR: &str = "expected identifier or string literal";
 
@@ -40,11 +42,32 @@ impl MetaVarExpr {
     ) -> PResult<'psess, MetaVarExpr> {
         let mut iter = input.iter();
         let ident = parse_ident(&mut iter, psess, outer_span)?;
-        let Some(TokenTree::Delimited(.., Delimiter::Parenthesis, args)) = iter.next() else {
-            let msg = "meta-variable expression parameter must be wrapped in parentheses";
-            return Err(psess.dcx().struct_span_err(ident.span, msg));
+        let next = iter.next();
+        let Some(TokenTree::Delimited(.., Delimiter::Parenthesis, args)) = next else {
+            // No `()`; wrong or no delimiters. Point at a problematic span or a place to
+            // add parens if it makes sense.
+            let (unexpected_span, insert_span) = match next {
+                Some(TokenTree::Delimited(..)) => (None, None),
+                Some(tt) => (Some(tt.span()), None),
+                None => (None, Some(ident.span.shrink_to_hi())),
+            };
+            let err =
+                errors::MveMissingParen { ident_span: ident.span, unexpected_span, insert_span };
+            return Err(psess.dcx().create_err(err));
         };
-        check_trailing_token(&mut iter, psess)?;
+
+        // Ensure there are no trailing tokens in the braces, e.g. `${foo() extra}`
+        if iter.peek().is_some() {
+            let span = iter_span(&iter).expect("checked is_some above");
+            let err = errors::MveExtraTokens {
+                span,
+                ident_span: ident.span,
+                extra_count: iter.count(),
+                ..Default::default()
+            };
+            return Err(psess.dcx().create_err(err));
+        }
+
         let mut iter = args.iter();
         let rslt = match ident.as_str() {
             "concat" => parse_concat(&mut iter, psess, outer_span, ident.span)?,
@@ -67,7 +90,7 @@ impl MetaVarExpr {
                 return Err(err);
             }
         };
-        check_trailing_token(&mut iter, psess)?;
+        check_trailing_tokens(&mut iter, psess, ident)?;
         Ok(rslt)
     }
 
@@ -87,20 +110,51 @@ impl MetaVarExpr {
     }
 }
 
-// Checks if there are any remaining tokens. For example, `${ignore(ident ... a b c ...)}`
-fn check_trailing_token<'psess>(
+/// Checks if there are any remaining tokens (for example, `${ignore($valid, extra)}`) and create
+/// a diag with the correct arg count if so.
+fn check_trailing_tokens<'psess>(
     iter: &mut TokenStreamIter<'_>,
     psess: &'psess ParseSess,
+    ident: Ident,
 ) -> PResult<'psess, ()> {
-    if let Some(tt) = iter.next() {
-        let mut diag = psess
-            .dcx()
-            .struct_span_err(tt.span(), format!("unexpected token: {}", pprust::tt_to_string(tt)));
-        diag.span_note(tt.span(), "meta-variable expression must not have trailing tokens");
-        Err(diag)
-    } else {
-        Ok(())
+    if iter.peek().is_none() {
+        // All tokens consumed, as expected
+        return Ok(());
     }
+
+    // `None` for max indicates the arg count must be exact, `Some` indicates a range is accepted.
+    let (min_or_exact_args, max_args) = match ident.as_str() {
+        "concat" => panic!("concat takes unlimited tokens but didn't eat them all"),
+        "ignore" => (1, None),
+        // 1 or 2 args
+        "count" => (1, Some(2)),
+        // 0 or 1 arg
+        "index" => (0, Some(1)),
+        "len" => (0, Some(1)),
+        other => unreachable!("unknown MVEs should be rejected earlier (got `{other}`)"),
+    };
+
+    let err = errors::MveExtraTokens {
+        span: iter_span(iter).expect("checked is_none above"),
+        ident_span: ident.span,
+        extra_count: iter.count(),
+
+        exact_args_note: if max_args.is_some() { None } else { Some(()) },
+        range_args_note: if max_args.is_some() { Some(()) } else { None },
+        min_or_exact_args,
+        max_args: max_args.unwrap_or_default(),
+        name: ident.to_string(),
+    };
+    Err(psess.dcx().create_err(err))
+}
+
+/// Returns a span encompassing all tokens in the iterator if there is at least one item.
+fn iter_span(iter: &TokenStreamIter<'_>) -> Option<Span> {
+    let mut iter = iter.clone(); // cloning is cheap
+    let first_sp = iter.next()?.span();
+    let last_sp = iter.last().map(TokenTree::span).unwrap_or(first_sp);
+    let span = first_sp.with_hi(last_sp.hi());
+    Some(span)
 }
 
 /// Indicates what is placed in a `concat` parameter. For example, literals
diff --git a/tests/ui/macros/metavar-expressions/syntax-errors.rs b/tests/ui/macros/metavar-expressions/syntax-errors.rs
index 8fc76a74baa..a6eebdfa674 100644
--- a/tests/ui/macros/metavar-expressions/syntax-errors.rs
+++ b/tests/ui/macros/metavar-expressions/syntax-errors.rs
@@ -30,7 +30,7 @@ macro_rules! metavar_with_literal_suffix {
 
 macro_rules! mve_without_parens {
     ( $( $i:ident ),* ) => { ${ count } };
-    //~^ ERROR meta-variable expression parameter must be wrapped in parentheses
+    //~^ ERROR expected `(`
 }
 
 #[rustfmt::skip]
@@ -45,9 +45,14 @@ macro_rules! open_brackets_with_lit {
      //~^ ERROR expected identifier
  }
 
+macro_rules! mvs_missing_paren {
+    ( $( $i:ident ),* ) => { ${ count $i ($i) } };
+    //~^ ERROR expected `(`
+}
+
 macro_rules! mve_wrong_delim {
     ( $( $i:ident ),* ) => { ${ count{i} } };
-    //~^ ERROR meta-variable expression parameter must be wrapped in parentheses
+    //~^ ERROR expected `(`
 }
 
 macro_rules! invalid_metavar {
@@ -64,28 +69,30 @@ macro_rules! open_brackets_with_group {
 macro_rules! extra_garbage_after_metavar {
     ( $( $i:ident ),* ) => {
         ${count() a b c}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${count($i a b c)}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${count($i, 1 a b c)}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${count($i) a b c}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
 
         ${ignore($i) a b c}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${ignore($i a b c)}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
 
         ${index() a b c}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${index(1 a b c)}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
 
         ${index() a b c}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${index(1 a b c)}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
+        ${index(1, a b c)}
+        //~^ ERROR unexpected trailing tokens
     };
 }
 
diff --git a/tests/ui/macros/metavar-expressions/syntax-errors.stderr b/tests/ui/macros/metavar-expressions/syntax-errors.stderr
index 20d2358facc..f3c08f05e2a 100644
--- a/tests/ui/macros/metavar-expressions/syntax-errors.stderr
+++ b/tests/ui/macros/metavar-expressions/syntax-errors.stderr
@@ -40,164 +40,160 @@ error: only unsuffixes integer literals are supported in meta-variable expressio
 LL |     ( $( $i:ident ),* ) => { ${ index(1u32) } };
    |                                 ^^^^^
 
-error: meta-variable expression parameter must be wrapped in parentheses
+error: expected `(`
   --> $DIR/syntax-errors.rs:32:33
    |
 LL |     ( $( $i:ident ),* ) => { ${ count } };
-   |                                 ^^^^^
+   |                                 ^^^^^- help: try adding parentheses: `( /* ... */ )`
+   |                                 |
+   |                                 for this this metavariable expression
+   |
+   = note: metavariable expressions use function-like parentheses syntax
 
-error: meta-variable expression parameter must be wrapped in parentheses
+error: expected `(`
   --> $DIR/syntax-errors.rs:49:33
    |
+LL |     ( $( $i:ident ),* ) => { ${ count $i ($i) } };
+   |                                 ^^^^^ - unexpected token
+   |                                 |
+   |                                 for this this metavariable expression
+   |
+   = note: metavariable expressions use function-like parentheses syntax
+
+error: expected `(`
+  --> $DIR/syntax-errors.rs:54:33
+   |
 LL |     ( $( $i:ident ),* ) => { ${ count{i} } };
-   |                                 ^^^^^
+   |                                 ^^^^^ for this this metavariable expression
+   |
+   = note: metavariable expressions use function-like parentheses syntax
 
 error: expected identifier, found `123`
-  --> $DIR/syntax-errors.rs:54:23
+  --> $DIR/syntax-errors.rs:59:23
    |
 LL |     () => { ${ignore($123)} }
    |                       ^^^ help: try removing `123`
 
-error: unexpected token: a
-  --> $DIR/syntax-errors.rs:66:19
+error: unexpected trailing tokens
+  --> $DIR/syntax-errors.rs:71:19
    |
 LL |         ${count() a b c}
-   |                   ^
-   |
-note: meta-variable expression must not have trailing tokens
-  --> $DIR/syntax-errors.rs:66:19
-   |
-LL |         ${count() a b c}
-   |                   ^
+   |           -----   ^^^^^ help: try removing these tokens
+   |           |
+   |           for this metavariable expression
 
-error: unexpected token: a
-  --> $DIR/syntax-errors.rs:68:20
+error: unexpected trailing tokens
+  --> $DIR/syntax-errors.rs:73:20
    |
 LL |         ${count($i a b c)}
-   |                    ^
-   |
-note: meta-variable expression must not have trailing tokens
-  --> $DIR/syntax-errors.rs:68:20
+   |           -----    ^^^^^ help: try removing these tokens
+   |           |
+   |           for this metavariable expression
    |
-LL |         ${count($i a b c)}
-   |                    ^
+   = note: the `count` metavariable expression takes between 1 and 2 arguments
 
-error: unexpected token: a
-  --> $DIR/syntax-errors.rs:70:23
+error: unexpected trailing tokens
+  --> $DIR/syntax-errors.rs:75:23
    |
 LL |         ${count($i, 1 a b c)}
-   |                       ^
-   |
-note: meta-variable expression must not have trailing tokens
-  --> $DIR/syntax-errors.rs:70:23
+   |           -----       ^^^^^ help: try removing these tokens
+   |           |
+   |           for this metavariable expression
    |
-LL |         ${count($i, 1 a b c)}
-   |                       ^
+   = note: the `count` metavariable expression takes between 1 and 2 arguments
 
-error: unexpected token: a
-  --> $DIR/syntax-errors.rs:72:21
-   |
-LL |         ${count($i) a b c}
-   |                     ^
-   |
-note: meta-variable expression must not have trailing tokens
-  --> $DIR/syntax-errors.rs:72:21
+error: unexpected trailing tokens
+  --> $DIR/syntax-errors.rs:77:21
    |
 LL |         ${count($i) a b c}
-   |                     ^
+   |           -----     ^^^^^ help: try removing these tokens
+   |           |
+   |           for this metavariable expression
 
-error: unexpected token: a
-  --> $DIR/syntax-errors.rs:75:22
+error: unexpected trailing tokens
+  --> $DIR/syntax-errors.rs:80:22
    |
 LL |         ${ignore($i) a b c}
-   |                      ^
-   |
-note: meta-variable expression must not have trailing tokens
-  --> $DIR/syntax-errors.rs:75:22
-   |
-LL |         ${ignore($i) a b c}
-   |                      ^
+   |           ------     ^^^^^ help: try removing these tokens
+   |           |
+   |           for this metavariable expression
 
-error: unexpected token: a
-  --> $DIR/syntax-errors.rs:77:21
+error: unexpected trailing tokens
+  --> $DIR/syntax-errors.rs:82:21
    |
 LL |         ${ignore($i a b c)}
-   |                     ^
+   |           ------    ^^^^^ help: try removing these tokens
+   |           |
+   |           for this metavariable expression
    |
-note: meta-variable expression must not have trailing tokens
-  --> $DIR/syntax-errors.rs:77:21
-   |
-LL |         ${ignore($i a b c)}
-   |                     ^
+   = note: the `ignore` metavariable expression takes a single argument
 
-error: unexpected token: a
-  --> $DIR/syntax-errors.rs:80:19
-   |
-LL |         ${index() a b c}
-   |                   ^
-   |
-note: meta-variable expression must not have trailing tokens
-  --> $DIR/syntax-errors.rs:80:19
+error: unexpected trailing tokens
+  --> $DIR/syntax-errors.rs:85:19
    |
 LL |         ${index() a b c}
-   |                   ^
+   |           -----   ^^^^^ help: try removing these tokens
+   |           |
+   |           for this metavariable expression
 
-error: unexpected token: a
-  --> $DIR/syntax-errors.rs:82:19
+error: unexpected trailing tokens
+  --> $DIR/syntax-errors.rs:87:19
    |
 LL |         ${index(1 a b c)}
-   |                   ^
-   |
-note: meta-variable expression must not have trailing tokens
-  --> $DIR/syntax-errors.rs:82:19
+   |           -----   ^^^^^ help: try removing these tokens
+   |           |
+   |           for this metavariable expression
    |
-LL |         ${index(1 a b c)}
-   |                   ^
+   = note: the `index` metavariable expression takes between 0 and 1 arguments
 
-error: unexpected token: a
-  --> $DIR/syntax-errors.rs:85:19
+error: unexpected trailing tokens
+  --> $DIR/syntax-errors.rs:90:19
    |
 LL |         ${index() a b c}
-   |                   ^
-   |
-note: meta-variable expression must not have trailing tokens
-  --> $DIR/syntax-errors.rs:85:19
-   |
-LL |         ${index() a b c}
-   |                   ^
+   |           -----   ^^^^^ help: try removing these tokens
+   |           |
+   |           for this metavariable expression
 
-error: unexpected token: a
-  --> $DIR/syntax-errors.rs:87:19
+error: unexpected trailing tokens
+  --> $DIR/syntax-errors.rs:92:19
    |
 LL |         ${index(1 a b c)}
-   |                   ^
+   |           -----   ^^^^^ help: try removing these tokens
+   |           |
+   |           for this metavariable expression
    |
-note: meta-variable expression must not have trailing tokens
-  --> $DIR/syntax-errors.rs:87:19
+   = note: the `index` metavariable expression takes between 0 and 1 arguments
+
+error: unexpected trailing tokens
+  --> $DIR/syntax-errors.rs:94:18
    |
-LL |         ${index(1 a b c)}
-   |                   ^
+LL |         ${index(1, a b c)}
+   |           -----  ^^^^^^^ help: try removing these tokens
+   |           |
+   |           for this metavariable expression
+   |
+   = note: the `index` metavariable expression takes between 0 and 1 arguments
 
 error: meta-variable expression depth must be a literal
-  --> $DIR/syntax-errors.rs:94:33
+  --> $DIR/syntax-errors.rs:101:33
    |
 LL |     ( $( $i:ident ),* ) => { ${ index(IDX) } };
    |                                 ^^^^^
 
 error: meta-variables within meta-variable expressions must be referenced using a dollar sign
-  --> $DIR/syntax-errors.rs:100:11
+  --> $DIR/syntax-errors.rs:107:11
    |
 LL |         ${count(foo)}
    |           ^^^^^
 
 error: meta-variables within meta-variable expressions must be referenced using a dollar sign
-  --> $DIR/syntax-errors.rs:107:11
+  --> $DIR/syntax-errors.rs:114:11
    |
 LL |         ${ignore(bar)}
    |           ^^^^^^
 
 error: unrecognized meta-variable expression
-  --> $DIR/syntax-errors.rs:113:33
+  --> $DIR/syntax-errors.rs:120:33
    |
 LL |     ( $( $i:ident ),* ) => { ${ aaaaaaaaaaaaaa(i) } };
    |                                 ^^^^^^^^^^^^^^ help: supported expressions are count, ignore, index and len
@@ -215,10 +211,10 @@ LL |      () => { ${ "hi" } };
    |                 ^^^^ help: try removing `"hi"`
 
 error: expected identifier or string literal
-  --> $DIR/syntax-errors.rs:60:33
+  --> $DIR/syntax-errors.rs:65:33
    |
 LL |     ( $( $i:ident ),* ) => { ${ {} } };
    |                                 ^^
 
-error: aborting due to 25 previous errors
+error: aborting due to 27 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 87e981996fe47826a8f3a69e3d3cc73ec68dbf8d Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sat, 21 Jun 2025 02:59:14 -0400
Subject: mbe: Refactor the diagnostic for unrecognized metavariable
 expressions

Change to a structural diagnostic, update the valid list, and move the
valid list to a note.
---
 compiler/rustc_expand/messages.ftl                       |  5 +++++
 compiler/rustc_expand/src/errors.rs                      | 10 ++++++++++
 compiler/rustc_expand/src/mbe/metavar_expr.rs            | 14 +++++---------
 tests/ui/macros/metavar-expressions/syntax-errors.rs     |  2 +-
 tests/ui/macros/metavar-expressions/syntax-errors.stderr |  6 ++++--
 5 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_expand/messages.ftl b/compiler/rustc_expand/messages.ftl
index 7b8c1e076a0..89d6e62834d 100644
--- a/compiler/rustc_expand/messages.ftl
+++ b/compiler/rustc_expand/messages.ftl
@@ -154,6 +154,11 @@ expand_mve_missing_paren =
     .note = metavariable expressions use function-like parentheses syntax
     .suggestion = try adding parentheses
 
+expand_mve_unrecognized_expr =
+    unrecognized metavariable expression
+    .label = not a valid metavariable expression
+    .note = valid metavariable expressions are {$valid_expr_list}
+
 expand_mve_unrecognized_var =
     variable `{$key}` is not recognized in meta-variable expression
 
diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs
index b56a2b043e7..3ac5d213053 100644
--- a/compiler/rustc_expand/src/errors.rs
+++ b/compiler/rustc_expand/src/errors.rs
@@ -530,6 +530,16 @@ mod metavar_exprs {
         pub insert_span: Option<Span>,
     }
 
+    #[derive(Diagnostic)]
+    #[note]
+    #[diag(expand_mve_unrecognized_expr)]
+    pub(crate) struct MveUnrecognizedExpr {
+        #[primary_span]
+        #[label]
+        pub span: Span,
+        pub valid_expr_list: &'static str,
+    }
+
     #[derive(Diagnostic)]
     #[diag(expand_mve_unrecognized_var)]
     pub(crate) struct MveUnrecognizedVar {
diff --git a/compiler/rustc_expand/src/mbe/metavar_expr.rs b/compiler/rustc_expand/src/mbe/metavar_expr.rs
index 8f15b5794c7..d2b275ad20a 100644
--- a/compiler/rustc_expand/src/mbe/metavar_expr.rs
+++ b/compiler/rustc_expand/src/mbe/metavar_expr.rs
@@ -79,15 +79,11 @@ impl MetaVarExpr {
             "index" => MetaVarExpr::Index(parse_depth(&mut iter, psess, ident.span)?),
             "len" => MetaVarExpr::Len(parse_depth(&mut iter, psess, ident.span)?),
             _ => {
-                let err_msg = "unrecognized meta-variable expression";
-                let mut err = psess.dcx().struct_span_err(ident.span, err_msg);
-                err.span_suggestion(
-                    ident.span,
-                    "supported expressions are count, ignore, index and len",
-                    "",
-                    Applicability::MachineApplicable,
-                );
-                return Err(err);
+                let err = errors::MveUnrecognizedExpr {
+                    span: ident.span,
+                    valid_expr_list: "`count`, `ignore`, `index`, `len`, and `concat`",
+                };
+                return Err(psess.dcx().create_err(err));
             }
         };
         check_trailing_tokens(&mut iter, psess, ident)?;
diff --git a/tests/ui/macros/metavar-expressions/syntax-errors.rs b/tests/ui/macros/metavar-expressions/syntax-errors.rs
index a6eebdfa674..585ea4d5979 100644
--- a/tests/ui/macros/metavar-expressions/syntax-errors.rs
+++ b/tests/ui/macros/metavar-expressions/syntax-errors.rs
@@ -118,7 +118,7 @@ macro_rules! unknown_ignore_ident {
 
 macro_rules! unknown_metavar {
     ( $( $i:ident ),* ) => { ${ aaaaaaaaaaaaaa(i) } };
-    //~^ ERROR unrecognized meta-variable expression
+    //~^ ERROR unrecognized metavariable expression
 }
 
 fn main() {}
diff --git a/tests/ui/macros/metavar-expressions/syntax-errors.stderr b/tests/ui/macros/metavar-expressions/syntax-errors.stderr
index f3c08f05e2a..bf1c7673a6c 100644
--- a/tests/ui/macros/metavar-expressions/syntax-errors.stderr
+++ b/tests/ui/macros/metavar-expressions/syntax-errors.stderr
@@ -192,11 +192,13 @@ error: meta-variables within meta-variable expressions must be referenced using
 LL |         ${ignore(bar)}
    |           ^^^^^^
 
-error: unrecognized meta-variable expression
+error: unrecognized metavariable expression
   --> $DIR/syntax-errors.rs:120:33
    |
 LL |     ( $( $i:ident ),* ) => { ${ aaaaaaaaaaaaaa(i) } };
-   |                                 ^^^^^^^^^^^^^^ help: supported expressions are count, ignore, index and len
+   |                                 ^^^^^^^^^^^^^^ not a valid metavariable expression
+   |
+   = note: valid metavariable expressions are `count`, `ignore`, `index`, `len`, and `concat`
 
 error: expected identifier or string literal
   --> $DIR/syntax-errors.rs:38:14
-- 
cgit 1.4.1-3-g733a5


From 93db9e7ee01d61cb97b4f7b3d61903477910cae2 Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Sun, 29 Jun 2025 11:40:59 +0800
Subject: Remove uncessary parens in closure body with unused lint

---
 compiler/rustc_errors/src/emitter.rs               |  2 +-
 compiler/rustc_lint/src/unused.rs                  | 10 +++-
 compiler/rustc_parse/src/parser/item.rs            |  2 +-
 compiler/rustc_resolve/src/late/diagnostics.rs     |  3 +-
 library/core/src/unicode/unicode_data.rs           |  2 +-
 src/tools/clippy/clippy_lints/src/unused_async.rs  |  2 +-
 src/tools/clippy/clippy_utils/src/ty/mod.rs        |  4 +-
 src/tools/compiletest/src/runtest.rs               |  6 +++
 src/tools/test-float-parse/src/lib.rs              |  2 +-
 .../unicode-table-generator/src/range_search.rs    |  2 +-
 .../async-await/issues/issue-54752-async-block.rs  |  1 -
 .../issues/issue-54752-async-block.stderr          | 15 ------
 .../ui/lint/unused/closure-body-issue-136741.fixed | 36 +++++++++++++
 tests/ui/lint/unused/closure-body-issue-136741.rs  | 38 +++++++++++++
 .../lint/unused/closure-body-issue-136741.stderr   | 62 ++++++++++++++++++++++
 15 files changed, 160 insertions(+), 27 deletions(-)
 delete mode 100644 tests/ui/async-await/issues/issue-54752-async-block.stderr
 create mode 100644 tests/ui/lint/unused/closure-body-issue-136741.fixed
 create mode 100644 tests/ui/lint/unused/closure-body-issue-136741.rs
 create mode 100644 tests/ui/lint/unused/closure-body-issue-136741.stderr

diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs
index 2f398cea926..510f37f37e2 100644
--- a/compiler/rustc_errors/src/emitter.rs
+++ b/compiler/rustc_errors/src/emitter.rs
@@ -3526,7 +3526,7 @@ pub fn is_case_difference(sm: &SourceMap, suggested: &str, sp: Span) -> bool {
     // All the chars that differ in capitalization are confusable (above):
     let confusable = iter::zip(found.chars(), suggested.chars())
         .filter(|(f, s)| f != s)
-        .all(|(f, s)| (ascii_confusables.contains(&f) || ascii_confusables.contains(&s)));
+        .all(|(f, s)| ascii_confusables.contains(&f) || ascii_confusables.contains(&s));
     confusable && found.to_lowercase() == suggested.to_lowercase()
             // FIXME: We sometimes suggest the same thing we already have, which is a
             //        bug, but be defensive against that here.
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index d3942a1c816..a9eb1739f7f 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -1,7 +1,7 @@
 use std::iter;
 
 use rustc_ast::util::{classify, parser};
-use rustc_ast::{self as ast, ExprKind, HasAttrs as _, StmtKind};
+use rustc_ast::{self as ast, ExprKind, FnRetTy, HasAttrs as _, StmtKind};
 use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{MultiSpan, pluralize};
@@ -599,6 +599,7 @@ enum UnusedDelimsCtx {
     AnonConst,
     MatchArmExpr,
     IndexExpr,
+    ClosureBody,
 }
 
 impl From<UnusedDelimsCtx> for &'static str {
@@ -620,6 +621,7 @@ impl From<UnusedDelimsCtx> for &'static str {
             UnusedDelimsCtx::ArrayLenExpr | UnusedDelimsCtx::AnonConst => "const expression",
             UnusedDelimsCtx::MatchArmExpr => "match arm expression",
             UnusedDelimsCtx::IndexExpr => "index expression",
+            UnusedDelimsCtx::ClosureBody => "closure body",
         }
     }
 }
@@ -919,6 +921,11 @@ trait UnusedDelimLint {
                 let (args_to_check, ctx) = match *call_or_other {
                     Call(_, ref args) => (&args[..], UnusedDelimsCtx::FunctionArg),
                     MethodCall(ref call) => (&call.args[..], UnusedDelimsCtx::MethodArg),
+                    Closure(ref closure)
+                        if matches!(closure.fn_decl.output, FnRetTy::Default(_)) =>
+                    {
+                        (&[closure.body.clone()][..], UnusedDelimsCtx::ClosureBody)
+                    }
                     // actual catch-all arm
                     _ => {
                         return;
@@ -1508,6 +1515,7 @@ impl UnusedDelimLint for UnusedBraces {
                             && (ctx != UnusedDelimsCtx::AnonConst
                                 || (matches!(expr.kind, ast::ExprKind::Lit(_))
                                     && !expr.span.from_expansion()))
+                            && ctx != UnusedDelimsCtx::ClosureBody
                             && !cx.sess().source_map().is_multiline(value.span)
                             && value.attrs.is_empty()
                             && !value.span.from_expansion()
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index 9ed7124a11c..d6cc98d505c 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -2206,7 +2206,7 @@ impl<'a> Parser<'a> {
 
             if self.look_ahead(1, |t| *t == token::Bang) && self.look_ahead(2, |t| t.is_ident()) {
                 return IsMacroRulesItem::Yes { has_bang: true };
-            } else if self.look_ahead(1, |t| (t.is_ident())) {
+            } else if self.look_ahead(1, |t| t.is_ident()) {
                 // macro_rules foo
                 self.dcx().emit_err(errors::MacroRulesMissingBang {
                     span: macro_rules_span,
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index e015eb7a636..8114021510e 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -328,8 +328,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                 let module_did = mod_prefix.as_ref().and_then(Res::mod_def_id);
 
                 let mod_prefix =
-                    mod_prefix.map_or_else(String::new, |res| (format!("{} ", res.descr())));
-
+                    mod_prefix.map_or_else(String::new, |res| format!("{} ", res.descr()));
                 (mod_prefix, format!("`{}`", Segment::names_to_string(mod_path)), module_did, None)
             };
 
diff --git a/library/core/src/unicode/unicode_data.rs b/library/core/src/unicode/unicode_data.rs
index 25b9c6e0e0e..b57234bbee9 100644
--- a/library/core/src/unicode/unicode_data.rs
+++ b/library/core/src/unicode/unicode_data.rs
@@ -82,7 +82,7 @@ unsafe fn skip_search<const SOR: usize, const OFFSETS: usize>(
     let needle = needle as u32;
 
     let last_idx =
-        match short_offset_runs.binary_search_by_key(&(needle << 11), |header| (header.0 << 11)) {
+        match short_offset_runs.binary_search_by_key(&(needle << 11), |header| header.0 << 11) {
             Ok(idx) => idx + 1,
             Err(idx) => idx,
         };
diff --git a/src/tools/clippy/clippy_lints/src/unused_async.rs b/src/tools/clippy/clippy_lints/src/unused_async.rs
index 8ceaa3dc58e..e67afc7f5a8 100644
--- a/src/tools/clippy/clippy_lints/src/unused_async.rs
+++ b/src/tools/clippy/clippy_lints/src/unused_async.rs
@@ -169,7 +169,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
         let iter = self
             .unused_async_fns
             .iter()
-            .filter(|UnusedAsyncFn { def_id, .. }| (!self.async_fns_as_value.contains(def_id)));
+            .filter(|UnusedAsyncFn { def_id, .. }| !self.async_fns_as_value.contains(def_id));
 
         for fun in iter {
             span_lint_hir_and_then(
diff --git a/src/tools/clippy/clippy_utils/src/ty/mod.rs b/src/tools/clippy/clippy_utils/src/ty/mod.rs
index bffbcf073ab..fe208c032f4 100644
--- a/src/tools/clippy/clippy_utils/src/ty/mod.rs
+++ b/src/tools/clippy/clippy_utils/src/ty/mod.rs
@@ -889,7 +889,7 @@ impl AdtVariantInfo {
                     .enumerate()
                     .map(|(i, f)| (i, approx_ty_size(cx, f.ty(cx.tcx, subst))))
                     .collect::<Vec<_>>();
-                fields_size.sort_by(|(_, a_size), (_, b_size)| (a_size.cmp(b_size)));
+                fields_size.sort_by(|(_, a_size), (_, b_size)| a_size.cmp(b_size));
 
                 Self {
                     ind: i,
@@ -898,7 +898,7 @@ impl AdtVariantInfo {
                 }
             })
             .collect::<Vec<_>>();
-        variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
+        variants_size.sort_by(|a, b| b.size.cmp(&a.size));
         variants_size
     }
 }
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 3e879e0e4bb..933a32392bd 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -1777,6 +1777,12 @@ impl<'test> TestCx<'test> {
         // Allow tests to use internal features.
         rustc.args(&["-A", "internal_features"]);
 
+        // Allow tests to have unused parens and braces.
+        // Add #![deny(unused_parens, unused_braces)] to the test file if you want to
+        // test that these lints are working.
+        rustc.args(&["-A", "unused_parens"]);
+        rustc.args(&["-A", "unused_braces"]);
+
         if self.props.force_host {
             self.maybe_add_external_args(&mut rustc, &self.config.host_rustcflags);
             if !is_rustdoc {
diff --git a/src/tools/test-float-parse/src/lib.rs b/src/tools/test-float-parse/src/lib.rs
index 0bd4878f9a6..1321a3c3354 100644
--- a/src/tools/test-float-parse/src/lib.rs
+++ b/src/tools/test-float-parse/src/lib.rs
@@ -340,7 +340,7 @@ fn launch_tests(tests: &mut [TestInfo], cfg: &Config) -> Duration {
     for test in tests.iter_mut() {
         test.progress = Some(ui::Progress::new(test, &mut all_progress_bars));
         ui::set_panic_hook(&all_progress_bars);
-        ((test.launch)(test, cfg));
+        (test.launch)(test, cfg);
     }
 
     start.elapsed()
diff --git a/src/tools/unicode-table-generator/src/range_search.rs b/src/tools/unicode-table-generator/src/range_search.rs
index 02f9cf16d4d..4d1dd9b423b 100644
--- a/src/tools/unicode-table-generator/src/range_search.rs
+++ b/src/tools/unicode-table-generator/src/range_search.rs
@@ -80,7 +80,7 @@ unsafe fn skip_search<const SOR: usize, const OFFSETS: usize>(
     let needle = needle as u32;
 
     let last_idx =
-        match short_offset_runs.binary_search_by_key(&(needle << 11), |header| (header.0 << 11)) {
+        match short_offset_runs.binary_search_by_key(&(needle << 11), |header| header.0 << 11) {
             Ok(idx) => idx + 1,
             Err(idx) => idx,
         };
diff --git a/tests/ui/async-await/issues/issue-54752-async-block.rs b/tests/ui/async-await/issues/issue-54752-async-block.rs
index 452b6794bee..164c1885da1 100644
--- a/tests/ui/async-await/issues/issue-54752-async-block.rs
+++ b/tests/ui/async-await/issues/issue-54752-async-block.rs
@@ -4,4 +4,3 @@
 //@ pp-exact
 
 fn main() { let _a = (async { }); }
-//~^ WARNING unnecessary parentheses around assigned value
diff --git a/tests/ui/async-await/issues/issue-54752-async-block.stderr b/tests/ui/async-await/issues/issue-54752-async-block.stderr
deleted file mode 100644
index 8cc849dd985..00000000000
--- a/tests/ui/async-await/issues/issue-54752-async-block.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-warning: unnecessary parentheses around assigned value
-  --> $DIR/issue-54752-async-block.rs:6:22
-   |
-LL | fn main() { let _a = (async { }); }
-   |                      ^         ^
-   |
-   = note: `#[warn(unused_parens)]` on by default
-help: remove these parentheses
-   |
-LL - fn main() { let _a = (async { }); }
-LL + fn main() { let _a = async { }; }
-   |
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/lint/unused/closure-body-issue-136741.fixed b/tests/ui/lint/unused/closure-body-issue-136741.fixed
new file mode 100644
index 00000000000..2ded52544b9
--- /dev/null
+++ b/tests/ui/lint/unused/closure-body-issue-136741.fixed
@@ -0,0 +1,36 @@
+//@ run-rustfix
+// ignore-tidy-linelength
+#![deny(unused_parens)]
+#![deny(unused_braces)]
+
+fn long_expr_that_does_not_require_braces_long_expr_that_does_not_require_braces_long_expr_that_does_not_require_braces()
+{}
+
+fn func(f: impl FnOnce()) {
+    f()
+}
+
+pub fn main() {
+    let _closure = |x: i32, y: i32| { x * (x + (y * 2)) };
+    let _ = || 0 == 0; //~ ERROR unnecessary parentheses around closure body
+    let _ = (0..).find(|n| n % 2 == 0); //~ ERROR unnecessary parentheses around closure body
+    let _ = (0..).find(|n| {n % 2 == 0});
+
+    // multiple lines of code will not lint with braces
+    let _ = (0..).find(|n| {
+        n % 2 == 0
+    });
+
+    // multiple lines of code will lint with parentheses
+    let _ = (0..).find(|n| n % 2 == 0);
+
+    let _ = || {
+        _ = 0;
+        0 == 0 //~ ERROR unnecessary parentheses around block return value
+    };
+
+    // long expressions will not lint with braces
+    func(|| {
+        long_expr_that_does_not_require_braces_long_expr_that_does_not_require_braces_long_expr_that_does_not_require_braces()
+    })
+}
diff --git a/tests/ui/lint/unused/closure-body-issue-136741.rs b/tests/ui/lint/unused/closure-body-issue-136741.rs
new file mode 100644
index 00000000000..4eac981ec2e
--- /dev/null
+++ b/tests/ui/lint/unused/closure-body-issue-136741.rs
@@ -0,0 +1,38 @@
+//@ run-rustfix
+// ignore-tidy-linelength
+#![deny(unused_parens)]
+#![deny(unused_braces)]
+
+fn long_expr_that_does_not_require_braces_long_expr_that_does_not_require_braces_long_expr_that_does_not_require_braces()
+{}
+
+fn func(f: impl FnOnce()) {
+    f()
+}
+
+pub fn main() {
+    let _closure = |x: i32, y: i32| { x * (x + (y * 2)) };
+    let _ = || (0 == 0); //~ ERROR unnecessary parentheses around closure body
+    let _ = (0..).find(|n| (n % 2 == 0)); //~ ERROR unnecessary parentheses around closure body
+    let _ = (0..).find(|n| {n % 2 == 0});
+
+    // multiple lines of code will not lint with braces
+    let _ = (0..).find(|n| {
+        n % 2 == 0
+    });
+
+    // multiple lines of code will lint with parentheses
+    let _ = (0..).find(|n| ( //~ ERROR unnecessary parentheses around closure body
+        n % 2 == 0
+    ));
+
+    let _ = || {
+        _ = 0;
+        (0 == 0) //~ ERROR unnecessary parentheses around block return value
+    };
+
+    // long expressions will not lint with braces
+    func(|| {
+        long_expr_that_does_not_require_braces_long_expr_that_does_not_require_braces_long_expr_that_does_not_require_braces()
+    })
+}
diff --git a/tests/ui/lint/unused/closure-body-issue-136741.stderr b/tests/ui/lint/unused/closure-body-issue-136741.stderr
new file mode 100644
index 00000000000..2ea872c08c7
--- /dev/null
+++ b/tests/ui/lint/unused/closure-body-issue-136741.stderr
@@ -0,0 +1,62 @@
+error: unnecessary parentheses around closure body
+  --> $DIR/closure-body-issue-136741.rs:15:16
+   |
+LL |     let _ = || (0 == 0);
+   |                ^      ^
+   |
+note: the lint level is defined here
+  --> $DIR/closure-body-issue-136741.rs:3:9
+   |
+LL | #![deny(unused_parens)]
+   |         ^^^^^^^^^^^^^
+help: remove these parentheses
+   |
+LL -     let _ = || (0 == 0);
+LL +     let _ = || 0 == 0;
+   |
+
+error: unnecessary parentheses around closure body
+  --> $DIR/closure-body-issue-136741.rs:16:28
+   |
+LL |     let _ = (0..).find(|n| (n % 2 == 0));
+   |                            ^          ^
+   |
+help: remove these parentheses
+   |
+LL -     let _ = (0..).find(|n| (n % 2 == 0));
+LL +     let _ = (0..).find(|n| n % 2 == 0);
+   |
+
+error: unnecessary parentheses around closure body
+  --> $DIR/closure-body-issue-136741.rs:25:28
+   |
+LL |        let _ = (0..).find(|n| (
+   |  _____________________________^
+LL | |          n % 2 == 0
+   | | ________^__________^
+   | ||________|
+   |  |
+LL |  |     ));
+   |  |_____^
+   |
+help: remove these parentheses
+   |
+LL -     let _ = (0..).find(|n| (
+LL -         n % 2 == 0
+LL +     let _ = (0..).find(|n| n % 2 == 0);
+   |
+
+error: unnecessary parentheses around block return value
+  --> $DIR/closure-body-issue-136741.rs:31:9
+   |
+LL |         (0 == 0)
+   |         ^      ^
+   |
+help: remove these parentheses
+   |
+LL -         (0 == 0)
+LL +         0 == 0
+   |
+
+error: aborting due to 4 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 0a64bfd6858606fae0b112673d4a28b2d6f149f8 Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Sun, 29 Jun 2025 11:40:59 +0800
Subject: Remove uncessary parens in closure body with unused lint

---
 clippy_lints/src/unused_async.rs | 2 +-
 clippy_utils/src/ty/mod.rs       | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/unused_async.rs b/clippy_lints/src/unused_async.rs
index 8ceaa3dc58e..e67afc7f5a8 100644
--- a/clippy_lints/src/unused_async.rs
+++ b/clippy_lints/src/unused_async.rs
@@ -169,7 +169,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAsync {
         let iter = self
             .unused_async_fns
             .iter()
-            .filter(|UnusedAsyncFn { def_id, .. }| (!self.async_fns_as_value.contains(def_id)));
+            .filter(|UnusedAsyncFn { def_id, .. }| !self.async_fns_as_value.contains(def_id));
 
         for fun in iter {
             span_lint_hir_and_then(
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index bffbcf073ab..fe208c032f4 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -889,7 +889,7 @@ impl AdtVariantInfo {
                     .enumerate()
                     .map(|(i, f)| (i, approx_ty_size(cx, f.ty(cx.tcx, subst))))
                     .collect::<Vec<_>>();
-                fields_size.sort_by(|(_, a_size), (_, b_size)| (a_size.cmp(b_size)));
+                fields_size.sort_by(|(_, a_size), (_, b_size)| a_size.cmp(b_size));
 
                 Self {
                     ind: i,
@@ -898,7 +898,7 @@ impl AdtVariantInfo {
                 }
             })
             .collect::<Vec<_>>();
-        variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
+        variants_size.sort_by(|a, b| b.size.cmp(&a.size));
         variants_size
     }
 }
-- 
cgit 1.4.1-3-g733a5


From c2fad05856799670039fa1843452ee8fc404182d Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Thu, 10 Jul 2025 05:18:43 +0300
Subject: Put the expression stuff in the expression store behind an
 `Option<Box>`

And leave only the type stuff without it.

This is because most expression stores don't have anything but types (e.g. generics, fields, signatures) so this saves a lot of memory.

This saves 58mb on `analysis-stats .`.
---
 .../rust-analyzer/crates/hir-def/src/expr_store.rs | 405 +++++++++++++++------
 .../crates/hir-def/src/expr_store/body.rs          |   6 +-
 .../crates/hir-def/src/expr_store/lower.rs         | 139 ++++---
 .../crates/hir-def/src/expr_store/lower/asm.rs     |   2 +-
 .../hir-def/src/expr_store/lower/path/tests.rs     |   2 +-
 .../crates/hir-def/src/expr_store/pretty.rs        |   4 +-
 .../crates/hir-def/src/expr_store/scope.rs         |  13 +-
 .../crates/hir-def/src/expr_store/tests/body.rs    |  11 +-
 .../rust-analyzer/crates/hir-def/src/signatures.rs |  20 +-
 .../rust-analyzer/crates/hir-ty/src/consteval.rs   |   4 +-
 .../crates/hir-ty/src/diagnostics/decl_check.rs    |   5 +-
 .../crates/hir-ty/src/diagnostics/expr.rs          |   8 +-
 .../crates/hir-ty/src/diagnostics/match_check.rs   |   2 +-
 .../crates/hir-ty/src/diagnostics/unsafe_check.rs  |   6 +-
 .../crates/hir-ty/src/infer/mutability.rs          |   2 +-
 .../rust-analyzer/crates/hir-ty/src/infer/pat.rs   |   4 +-
 .../crates/hir-ty/src/layout/tests.rs              |   3 +-
 src/tools/rust-analyzer/crates/hir-ty/src/mir.rs   |   7 +-
 .../rust-analyzer/crates/hir-ty/src/mir/lower.rs   |  14 +-
 .../crates/hir-ty/src/mir/lower/as_place.rs        |   2 +-
 .../hir-ty/src/mir/lower/pattern_matching.rs       |   4 +-
 .../rust-analyzer/crates/hir-ty/src/mir/pretty.rs  |   2 +-
 src/tools/rust-analyzer/crates/hir-ty/src/tests.rs |   4 +-
 src/tools/rust-analyzer/crates/hir/src/lib.rs      |   2 +-
 .../rust-analyzer/crates/hir/src/semantics.rs      |   3 +-
 .../crates/hir/src/source_analyzer.rs              |  10 +-
 .../crates/ide/src/inlay_hints/implicit_drop.rs    |   2 +-
 .../crates/rust-analyzer/src/cli/analysis_stats.rs |   4 +-
 28 files changed, 419 insertions(+), 271 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 51612f341a1..d3dfc05eb29 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
@@ -22,6 +22,7 @@ use rustc_hash::FxHashMap;
 use smallvec::SmallVec;
 use span::{Edition, SyntaxContext};
 use syntax::{AstPtr, SyntaxNodePtr, ast};
+use thin_vec::ThinVec;
 use triomphe::Arc;
 use tt::TextRange;
 
@@ -93,17 +94,17 @@ pub type TypeSource = InFile<TypePtr>;
 pub type LifetimePtr = AstPtr<ast::Lifetime>;
 pub type LifetimeSource = InFile<LifetimePtr>;
 
+// 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)]
-pub struct ExpressionStore {
-    pub exprs: Arena<Expr>,
-    pub pats: Arena<Pat>,
-    pub bindings: Arena<Binding>,
-    pub labels: Arena<Label>,
-    pub types: Arena<TypeRef>,
-    pub lifetimes: Arena<LifetimeRef>,
+struct ExpressionOnlyStore {
+    exprs: Arena<Expr>,
+    pats: Arena<Pat>,
+    bindings: Arena<Binding>,
+    labels: Arena<Label>,
     /// Id of the closure/coroutine that owns the corresponding binding. If a binding is owned by the
     /// top level expression, it will not be listed in here.
-    pub binding_owners: FxHashMap<BindingId, ExprId>,
+    binding_owners: FxHashMap<BindingId, ExprId>,
     /// Block expressions in this store that may contain inner items.
     block_scopes: Box<[BlockId]>,
 
@@ -114,8 +115,15 @@ pub struct ExpressionStore {
     ident_hygiene: FxHashMap<ExprOrPatId, HygieneId>,
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub struct ExpressionStore {
+    expr_only: Option<Box<ExpressionOnlyStore>>,
+    pub types: Arena<TypeRef>,
+    pub lifetimes: Arena<LifetimeRef>,
+}
+
 #[derive(Debug, Eq, Default)]
-pub struct ExpressionStoreSourceMap {
+struct ExpressionOnlySourceMap {
     // 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).
     expr_map: FxHashMap<ExprSource, ExprOrPatId>,
@@ -127,12 +135,6 @@ pub struct ExpressionStoreSourceMap {
     label_map: FxHashMap<LabelSource, LabelId>,
     label_map_back: ArenaMap<LabelId, LabelSource>,
 
-    types_map_back: ArenaMap<TypeRefId, TypeSource>,
-    types_map: FxHashMap<TypeSource, TypeRefId>,
-
-    lifetime_map_back: ArenaMap<LifetimeRefId, LifetimeSource>,
-    lifetime_map: FxHashMap<LifetimeSource, LifetimeRefId>,
-
     binding_definitions:
         ArenaMap<BindingId, SmallVec<[PatId; 2 * size_of::<usize>() / size_of::<PatId>()]>>,
 
@@ -143,14 +145,17 @@ pub struct ExpressionStoreSourceMap {
 
     template_map: Option<Box<FormatTemplate>>,
 
-    pub expansions: FxHashMap<InFile<MacroCallPtr>, MacroCallId>,
+    expansions: FxHashMap<InFile<MacroCallPtr>, MacroCallId>,
 
     /// Diagnostics accumulated during lowering. These contain `AstPtr`s and so are stored in
     /// the source map (since they're just as volatile).
-    pub diagnostics: Vec<ExpressionStoreDiagnostics>,
+    //
+    // We store diagnostics on the `ExpressionOnlySourceMap` because diagnostics are rare (except
+    // maybe for cfgs, and they are also not common in type places).
+    diagnostics: ThinVec<ExpressionStoreDiagnostics>,
 }
 
-impl PartialEq for ExpressionStoreSourceMap {
+impl PartialEq for ExpressionOnlySourceMap {
     fn eq(&self, other: &Self) -> bool {
         // we only need to compare one of the two mappings
         // as the other is a reverse mapping and thus will compare
@@ -162,10 +167,6 @@ impl PartialEq for ExpressionStoreSourceMap {
             pat_map_back,
             label_map: _,
             label_map_back,
-            types_map_back,
-            types_map: _,
-            lifetime_map_back,
-            lifetime_map: _,
             // If this changed, our pattern data must have changed
             binding_definitions: _,
             // If this changed, our expression data must have changed
@@ -179,14 +180,40 @@ impl PartialEq for ExpressionStoreSourceMap {
         *expr_map_back == other.expr_map_back
             && *pat_map_back == other.pat_map_back
             && *label_map_back == other.label_map_back
-            && *types_map_back == other.types_map_back
-            && *lifetime_map_back == other.lifetime_map_back
             && *template_map == other.template_map
             && *expansions == other.expansions
             && *diagnostics == other.diagnostics
     }
 }
 
+#[derive(Debug, Eq, Default)]
+pub struct ExpressionStoreSourceMap {
+    expr_only: Option<Box<ExpressionOnlySourceMap>>,
+
+    types_map_back: ArenaMap<TypeRefId, TypeSource>,
+    types_map: FxHashMap<TypeSource, TypeRefId>,
+
+    lifetime_map_back: ArenaMap<LifetimeRefId, LifetimeSource>,
+    #[expect(
+        unused,
+        reason = "this is here for completeness, and maybe we'll need it in the future"
+    )]
+    lifetime_map: FxHashMap<LifetimeSource, LifetimeRefId>,
+}
+
+impl PartialEq for ExpressionStoreSourceMap {
+    fn eq(&self, other: &Self) -> bool {
+        // we only need to compare one of the two mappings
+        // as the other is a reverse mapping and thus will compare
+        // the same as normal mapping
+        let Self { expr_only, types_map_back, types_map: _, lifetime_map_back, lifetime_map: _ } =
+            self;
+        *expr_only == other.expr_only
+            && *types_map_back == other.types_map_back
+            && *lifetime_map_back == other.lifetime_map_back
+    }
+}
+
 /// The body of an item (function, const etc.).
 #[derive(Debug, Eq, PartialEq, Default)]
 pub struct ExpressionStoreBuilder {
@@ -199,6 +226,42 @@ pub struct ExpressionStoreBuilder {
     pub types: Arena<TypeRef>,
     block_scopes: Vec<BlockId>,
     ident_hygiene: FxHashMap<ExprOrPatId, HygieneId>,
+
+    // 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).
+    expr_map: FxHashMap<ExprSource, ExprOrPatId>,
+    expr_map_back: ArenaMap<ExprId, ExprOrPatSource>,
+
+    pat_map: FxHashMap<PatSource, ExprOrPatId>,
+    pat_map_back: ArenaMap<PatId, ExprOrPatSource>,
+
+    label_map: FxHashMap<LabelSource, LabelId>,
+    label_map_back: ArenaMap<LabelId, LabelSource>,
+
+    types_map_back: ArenaMap<TypeRefId, TypeSource>,
+    types_map: FxHashMap<TypeSource, TypeRefId>,
+
+    lifetime_map_back: ArenaMap<LifetimeRefId, LifetimeSource>,
+    lifetime_map: FxHashMap<LifetimeSource, LifetimeRefId>,
+
+    binding_definitions:
+        ArenaMap<BindingId, SmallVec<[PatId; 2 * size_of::<usize>() / size_of::<PatId>()]>>,
+
+    /// We don't create explicit nodes for record fields (`S { record_field: 92 }`).
+    /// Instead, we use id of expression (`92`) to identify the field.
+    field_map_back: FxHashMap<ExprId, FieldSource>,
+    pat_field_map_back: FxHashMap<PatId, PatFieldSource>,
+
+    template_map: Option<Box<FormatTemplate>>,
+
+    expansions: FxHashMap<InFile<MacroCallPtr>, MacroCallId>,
+
+    /// Diagnostics accumulated during lowering. These contain `AstPtr`s and so are stored in
+    /// the source map (since they're just as volatile).
+    //
+    // We store diagnostics on the `ExpressionOnlySourceMap` because diagnostics are rare (except
+    // maybe for cfgs, and they are also not common in type places).
+    pub(crate) diagnostics: Vec<ExpressionStoreDiagnostics>,
 }
 
 #[derive(Default, Debug, Eq, PartialEq)]
@@ -226,7 +289,7 @@ pub enum ExpressionStoreDiagnostics {
 }
 
 impl ExpressionStoreBuilder {
-    pub fn finish(self) -> ExpressionStore {
+    pub fn finish(self) -> (ExpressionStore, ExpressionStoreSourceMap) {
         let Self {
             block_scopes,
             mut exprs,
@@ -237,6 +300,23 @@ impl ExpressionStoreBuilder {
             mut ident_hygiene,
             mut types,
             mut lifetimes,
+
+            mut expr_map,
+            mut expr_map_back,
+            mut pat_map,
+            mut pat_map_back,
+            mut label_map,
+            mut label_map_back,
+            mut types_map_back,
+            mut types_map,
+            mut lifetime_map_back,
+            mut lifetime_map,
+            mut binding_definitions,
+            mut field_map_back,
+            mut pat_field_map_back,
+            mut template_map,
+            mut expansions,
+            diagnostics,
         } = self;
         exprs.shrink_to_fit();
         labels.shrink_to_fit();
@@ -247,24 +327,90 @@ impl ExpressionStoreBuilder {
         types.shrink_to_fit();
         lifetimes.shrink_to_fit();
 
-        ExpressionStore {
-            exprs,
-            pats,
-            bindings,
-            labels,
-            binding_owners,
-            types,
-            lifetimes,
-            block_scopes: block_scopes.into_boxed_slice(),
-            ident_hygiene,
+        expr_map.shrink_to_fit();
+        expr_map_back.shrink_to_fit();
+        pat_map.shrink_to_fit();
+        pat_map_back.shrink_to_fit();
+        label_map.shrink_to_fit();
+        label_map_back.shrink_to_fit();
+        types_map_back.shrink_to_fit();
+        types_map.shrink_to_fit();
+        lifetime_map_back.shrink_to_fit();
+        lifetime_map.shrink_to_fit();
+        binding_definitions.shrink_to_fit();
+        field_map_back.shrink_to_fit();
+        pat_field_map_back.shrink_to_fit();
+        if let Some(template_map) = &mut template_map {
+            let FormatTemplate {
+                format_args_to_captures,
+                asm_to_captures,
+                implicit_capture_to_source,
+            } = &mut **template_map;
+            format_args_to_captures.shrink_to_fit();
+            asm_to_captures.shrink_to_fit();
+            implicit_capture_to_source.shrink_to_fit();
         }
+        expansions.shrink_to_fit();
+
+        let has_exprs =
+            !exprs.is_empty() || !labels.is_empty() || !pats.is_empty() || !bindings.is_empty();
+
+        let store = {
+            let expr_only = if has_exprs {
+                Some(Box::new(ExpressionOnlyStore {
+                    exprs,
+                    pats,
+                    bindings,
+                    labels,
+                    binding_owners,
+                    block_scopes: block_scopes.into_boxed_slice(),
+                    ident_hygiene,
+                }))
+            } else {
+                None
+            };
+            ExpressionStore { expr_only, types, lifetimes }
+        };
+
+        let source_map = {
+            let expr_only = if has_exprs || !expansions.is_empty() || !diagnostics.is_empty() {
+                Some(Box::new(ExpressionOnlySourceMap {
+                    expr_map,
+                    expr_map_back,
+                    pat_map,
+                    pat_map_back,
+                    label_map,
+                    label_map_back,
+                    binding_definitions,
+                    field_map_back,
+                    pat_field_map_back,
+                    template_map,
+                    expansions,
+                    diagnostics: ThinVec::from_iter(diagnostics),
+                }))
+            } else {
+                None
+            };
+            ExpressionStoreSourceMap {
+                expr_only,
+                types_map_back,
+                types_map,
+                lifetime_map_back,
+                lifetime_map,
+            }
+        };
+
+        (store, source_map)
     }
 }
 
 impl ExpressionStore {
-    pub fn empty_singleton() -> Arc<Self> {
-        static EMPTY: LazyLock<Arc<ExpressionStore>> =
-            LazyLock::new(|| Arc::new(ExpressionStoreBuilder::default().finish()));
+    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()
     }
 
@@ -273,7 +419,12 @@ impl ExpressionStore {
         &'a self,
         db: &'a dyn DefDatabase,
     ) -> impl Iterator<Item = (BlockId, &'a DefMap)> + 'a {
-        self.block_scopes.iter().map(move |&block| (block, block_def_map(db, block)))
+        self.expr_only
+            .as_ref()
+            .map(|it| &*it.block_scopes)
+            .unwrap_or_default()
+            .iter()
+            .map(move |&block| (block, block_def_map(db, block)))
     }
 
     pub fn walk_bindings_in_pat(&self, pat_id: PatId, mut f: impl FnMut(BindingId)) {
@@ -320,7 +471,8 @@ impl ExpressionStore {
     }
 
     pub fn is_binding_upvar(&self, binding: BindingId, relative_to: ExprId) -> bool {
-        match self.binding_owners.get(&binding) {
+        let Some(expr_only) = &self.expr_only else { return false };
+        match expr_only.binding_owners.get(&binding) {
             Some(it) => {
                 // We assign expression ids in a way that outer closures will receive
                 // a lower id
@@ -330,6 +482,11 @@ impl ExpressionStore {
         }
     }
 
+    #[inline]
+    pub fn binding_owner(&self, id: BindingId) -> Option<ExprId> {
+        self.expr_only.as_ref()?.binding_owners.get(&id).copied()
+    }
+
     /// Walks the immediate children expressions and calls `f` for each child expression.
     ///
     /// Note that this does not walk const blocks.
@@ -601,16 +758,22 @@ impl ExpressionStore {
         });
     }
 
+    #[inline]
+    #[track_caller]
+    fn assert_expr_only(&self) -> &ExpressionOnlyStore {
+        self.expr_only.as_ref().expect("should have `ExpressionStore::expr_only`")
+    }
+
     fn binding_hygiene(&self, binding: BindingId) -> HygieneId {
-        self.bindings[binding].hygiene
+        self.assert_expr_only().bindings[binding].hygiene
     }
 
     pub fn expr_path_hygiene(&self, expr: ExprId) -> HygieneId {
-        self.ident_hygiene.get(&expr.into()).copied().unwrap_or(HygieneId::ROOT)
+        self.assert_expr_only().ident_hygiene.get(&expr.into()).copied().unwrap_or(HygieneId::ROOT)
     }
 
     pub fn pat_path_hygiene(&self, pat: PatId) -> HygieneId {
-        self.ident_hygiene.get(&pat.into()).copied().unwrap_or(HygieneId::ROOT)
+        self.assert_expr_only().ident_hygiene.get(&pat.into()).copied().unwrap_or(HygieneId::ROOT)
     }
 
     pub fn expr_or_pat_path_hygiene(&self, id: ExprOrPatId) -> HygieneId {
@@ -619,43 +782,72 @@ impl ExpressionStore {
             ExprOrPatId::PatId(id) => self.pat_path_hygiene(id),
         }
     }
+
+    #[inline]
+    pub fn exprs(&self) -> impl Iterator<Item = (ExprId, &Expr)> {
+        match &self.expr_only {
+            Some(it) => it.exprs.iter(),
+            None => const { &Arena::new() }.iter(),
+        }
+    }
+
+    #[inline]
+    pub fn pats(&self) -> impl Iterator<Item = (PatId, &Pat)> {
+        match &self.expr_only {
+            Some(it) => it.pats.iter(),
+            None => const { &Arena::new() }.iter(),
+        }
+    }
+
+    #[inline]
+    pub fn bindings(&self) -> impl Iterator<Item = (BindingId, &Binding)> {
+        match &self.expr_only {
+            Some(it) => it.bindings.iter(),
+            None => const { &Arena::new() }.iter(),
+        }
+    }
 }
 
 impl Index<ExprId> for ExpressionStore {
     type Output = Expr;
 
+    #[inline]
     fn index(&self, expr: ExprId) -> &Expr {
-        &self.exprs[expr]
+        &self.assert_expr_only().exprs[expr]
     }
 }
 
 impl Index<PatId> for ExpressionStore {
     type Output = Pat;
 
+    #[inline]
     fn index(&self, pat: PatId) -> &Pat {
-        &self.pats[pat]
+        &self.assert_expr_only().pats[pat]
     }
 }
 
 impl Index<LabelId> for ExpressionStore {
     type Output = Label;
 
+    #[inline]
     fn index(&self, label: LabelId) -> &Label {
-        &self.labels[label]
+        &self.assert_expr_only().labels[label]
     }
 }
 
 impl Index<BindingId> for ExpressionStore {
     type Output = Binding;
 
+    #[inline]
     fn index(&self, b: BindingId) -> &Binding {
-        &self.bindings[b]
+        &self.assert_expr_only().bindings[b]
     }
 }
 
 impl Index<TypeRefId> for ExpressionStore {
     type Output = TypeRef;
 
+    #[inline]
     fn index(&self, b: TypeRefId) -> &TypeRef {
         &self.types[b]
     }
@@ -664,6 +856,7 @@ impl Index<TypeRefId> for ExpressionStore {
 impl Index<LifetimeRefId> for ExpressionStore {
     type Output = LifetimeRef;
 
+    #[inline]
     fn index(&self, b: LifetimeRefId) -> &LifetimeRef {
         &self.lifetimes[b]
     }
@@ -684,12 +877,6 @@ impl Index<PathId> for ExpressionStore {
 // FIXME: Change `node_` prefix to something more reasonable.
 // Perhaps `expr_syntax` and `expr_id`?
 impl ExpressionStoreSourceMap {
-    pub fn empty_singleton() -> Arc<Self> {
-        static EMPTY: LazyLock<Arc<ExpressionStoreSourceMap>> =
-            LazyLock::new(|| Arc::new(ExpressionStoreSourceMap::default()));
-        EMPTY.clone()
-    }
-
     pub fn expr_or_pat_syntax(&self, id: ExprOrPatId) -> Result<ExprOrPatSource, SyntheticSyntax> {
         match id {
             ExprOrPatId::ExprId(id) => self.expr_syntax(id),
@@ -697,30 +884,46 @@ impl ExpressionStoreSourceMap {
         }
     }
 
+    #[inline]
+    fn expr_or_synthetic(&self) -> Result<&ExpressionOnlySourceMap, SyntheticSyntax> {
+        self.expr_only.as_deref().ok_or(SyntheticSyntax)
+    }
+
+    #[inline]
+    fn expr_only(&self) -> Option<&ExpressionOnlySourceMap> {
+        self.expr_only.as_deref()
+    }
+
+    #[inline]
+    #[track_caller]
+    fn assert_expr_only(&self) -> &ExpressionOnlySourceMap {
+        self.expr_only.as_ref().expect("should have `ExpressionStoreSourceMap::expr_only`")
+    }
+
     pub fn expr_syntax(&self, expr: ExprId) -> Result<ExprOrPatSource, SyntheticSyntax> {
-        self.expr_map_back.get(expr).cloned().ok_or(SyntheticSyntax)
+        self.expr_or_synthetic()?.expr_map_back.get(expr).cloned().ok_or(SyntheticSyntax)
     }
 
     pub fn node_expr(&self, node: InFile<&ast::Expr>) -> Option<ExprOrPatId> {
         let src = node.map(AstPtr::new);
-        self.expr_map.get(&src).cloned()
+        self.expr_only()?.expr_map.get(&src).cloned()
     }
 
     pub fn node_macro_file(&self, node: InFile<&ast::MacroCall>) -> Option<MacroCallId> {
         let src = node.map(AstPtr::new);
-        self.expansions.get(&src).cloned()
+        self.expr_only()?.expansions.get(&src).cloned()
     }
 
     pub fn macro_calls(&self) -> impl Iterator<Item = (InFile<MacroCallPtr>, MacroCallId)> + '_ {
-        self.expansions.iter().map(|(&a, &b)| (a, b))
+        self.expr_only().into_iter().flat_map(|it| it.expansions.iter().map(|(&a, &b)| (a, b)))
     }
 
     pub fn pat_syntax(&self, pat: PatId) -> Result<ExprOrPatSource, SyntheticSyntax> {
-        self.pat_map_back.get(pat).cloned().ok_or(SyntheticSyntax)
+        self.expr_or_synthetic()?.pat_map_back.get(pat).cloned().ok_or(SyntheticSyntax)
     }
 
     pub fn node_pat(&self, node: InFile<&ast::Pat>) -> Option<ExprOrPatId> {
-        self.pat_map.get(&node.map(AstPtr::new)).cloned()
+        self.expr_only()?.pat_map.get(&node.map(AstPtr::new)).cloned()
     }
 
     pub fn type_syntax(&self, id: TypeRefId) -> Result<TypeSource, SyntheticSyntax> {
@@ -732,49 +935,50 @@ impl ExpressionStoreSourceMap {
     }
 
     pub fn label_syntax(&self, label: LabelId) -> LabelSource {
-        self.label_map_back[label]
+        self.assert_expr_only().label_map_back[label]
     }
 
     pub fn patterns_for_binding(&self, binding: BindingId) -> &[PatId] {
-        self.binding_definitions.get(binding).map_or(&[], Deref::deref)
+        self.assert_expr_only().binding_definitions.get(binding).map_or(&[], Deref::deref)
     }
 
     pub fn node_label(&self, node: InFile<&ast::Label>) -> Option<LabelId> {
         let src = node.map(AstPtr::new);
-        self.label_map.get(&src).cloned()
+        self.expr_only()?.label_map.get(&src).cloned()
     }
 
     pub fn field_syntax(&self, expr: ExprId) -> FieldSource {
-        self.field_map_back[&expr]
+        self.assert_expr_only().field_map_back[&expr]
     }
 
     pub fn pat_field_syntax(&self, pat: PatId) -> PatFieldSource {
-        self.pat_field_map_back[&pat]
+        self.assert_expr_only().pat_field_map_back[&pat]
     }
 
     pub fn macro_expansion_expr(&self, node: InFile<&ast::MacroExpr>) -> Option<ExprOrPatId> {
         let src = node.map(AstPtr::new).map(AstPtr::upcast::<ast::MacroExpr>).map(AstPtr::upcast);
-        self.expr_map.get(&src).copied()
+        self.expr_only()?.expr_map.get(&src).copied()
     }
 
     pub fn expansions(&self) -> impl Iterator<Item = (&InFile<MacroCallPtr>, &MacroCallId)> {
-        self.expansions.iter()
+        self.expr_only().into_iter().flat_map(|it| it.expansions.iter())
     }
 
     pub fn expansion(&self, node: InFile<&ast::MacroCall>) -> Option<MacroCallId> {
-        self.expansions.get(&node.map(AstPtr::new)).copied()
+        self.expr_only()?.expansions.get(&node.map(AstPtr::new)).copied()
     }
 
     pub fn implicit_format_args(
         &self,
         node: InFile<&ast::FormatArgsExpr>,
     ) -> Option<(HygieneId, &[(syntax::TextRange, Name)])> {
+        let expr_only = self.expr_only()?;
         let src = node.map(AstPtr::new).map(AstPtr::upcast::<ast::Expr>);
-        let (hygiene, names) = self
+        let (hygiene, names) = expr_only
             .template_map
             .as_ref()?
             .format_args_to_captures
-            .get(&self.expr_map.get(&src)?.as_expr()?)?;
+            .get(&expr_only.expr_map.get(&src)?.as_expr()?)?;
         Some((*hygiene, &**names))
     }
 
@@ -782,67 +986,28 @@ impl ExpressionStoreSourceMap {
         &self,
         capture_expr: ExprId,
     ) -> Option<InFile<(ExprPtr, TextRange)>> {
-        self.template_map.as_ref()?.implicit_capture_to_source.get(&capture_expr).copied()
+        self.expr_only()?
+            .template_map
+            .as_ref()?
+            .implicit_capture_to_source
+            .get(&capture_expr)
+            .copied()
     }
 
     pub fn asm_template_args(
         &self,
         node: InFile<&ast::AsmExpr>,
     ) -> Option<(ExprId, &[Vec<(syntax::TextRange, usize)>])> {
+        let expr_only = self.expr_only()?;
         let src = node.map(AstPtr::new).map(AstPtr::upcast::<ast::Expr>);
-        let expr = self.expr_map.get(&src)?.as_expr()?;
-        Some(expr)
-            .zip(self.template_map.as_ref()?.asm_to_captures.get(&expr).map(std::ops::Deref::deref))
+        let expr = expr_only.expr_map.get(&src)?.as_expr()?;
+        Some(expr).zip(
+            expr_only.template_map.as_ref()?.asm_to_captures.get(&expr).map(std::ops::Deref::deref),
+        )
     }
 
     /// Get a reference to the source map's diagnostics.
     pub fn diagnostics(&self) -> &[ExpressionStoreDiagnostics] {
-        &self.diagnostics
-    }
-
-    fn shrink_to_fit(&mut self) {
-        let Self {
-            expr_map,
-            expr_map_back,
-            pat_map,
-            pat_map_back,
-            label_map,
-            label_map_back,
-            field_map_back,
-            pat_field_map_back,
-            expansions,
-            template_map,
-            diagnostics,
-            binding_definitions,
-            types_map,
-            types_map_back,
-            lifetime_map_back,
-            lifetime_map,
-        } = self;
-        if let Some(template_map) = template_map {
-            let FormatTemplate {
-                format_args_to_captures,
-                asm_to_captures,
-                implicit_capture_to_source,
-            } = &mut **template_map;
-            format_args_to_captures.shrink_to_fit();
-            asm_to_captures.shrink_to_fit();
-            implicit_capture_to_source.shrink_to_fit();
-        }
-        expr_map.shrink_to_fit();
-        expr_map_back.shrink_to_fit();
-        pat_map.shrink_to_fit();
-        pat_map_back.shrink_to_fit();
-        label_map.shrink_to_fit();
-        label_map_back.shrink_to_fit();
-        field_map_back.shrink_to_fit();
-        pat_field_map_back.shrink_to_fit();
-        expansions.shrink_to_fit();
-        diagnostics.shrink_to_fit();
-        binding_definitions.shrink_to_fit();
-        types_map.shrink_to_fit();
-        types_map_back.shrink_to_fit();
-        lifetime_map.shrink_to_fit();
-        lifetime_map_back.shrink_to_fit();
+        self.expr_only().map(|it| &*it.diagnostics).unwrap_or_default()
     }
 }
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 fb6d931e0e4..c955393b9cf 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
@@ -36,6 +36,7 @@ pub struct Body {
 impl ops::Deref for Body {
     type Target = ExpressionStore;
 
+    #[inline]
     fn deref(&self) -> &Self::Target {
         &self.store
     }
@@ -61,6 +62,7 @@ pub struct BodySourceMap {
 impl ops::Deref for BodySourceMap {
     type Target = ExpressionStoreSourceMap;
 
+    #[inline]
     fn deref(&self) -> &Self::Target {
         &self.store
     }
@@ -102,9 +104,7 @@ impl Body {
             }
         };
         let module = def.module(db);
-        let (body, mut source_map) =
-            lower_body(db, def, file_id, module, params, body, is_async_fn);
-        source_map.store.shrink_to_fit();
+        let (body, source_map) = lower_body(db, def, file_id, module, params, body, is_async_fn);
 
         (Arc::new(body), Arc::new(source_map))
     }
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 c0e51b338b4..4e877748ca2 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
@@ -121,14 +121,10 @@ pub(super) fn lower_body(
             params = (0..count).map(|_| collector.missing_pat()).collect();
         };
         let body_expr = collector.missing_expr();
+        let (store, source_map) = collector.store.finish();
         return (
-            Body {
-                store: collector.store.finish(),
-                params: params.into_boxed_slice(),
-                self_param,
-                body_expr,
-            },
-            BodySourceMap { self_param: source_map_self_param, store: collector.source_map },
+            Body { store, params: params.into_boxed_slice(), self_param, body_expr },
+            BodySourceMap { self_param: source_map_self_param, store: source_map },
         );
     }
 
@@ -171,14 +167,10 @@ pub(super) fn lower_body(
         },
     );
 
+    let (store, source_map) = collector.store.finish();
     (
-        Body {
-            store: collector.store.finish(),
-            params: params.into_boxed_slice(),
-            self_param,
-            body_expr,
-        },
-        BodySourceMap { self_param: source_map_self_param, store: collector.source_map },
+        Body { store, params: params.into_boxed_slice(), self_param, body_expr },
+        BodySourceMap { self_param: source_map_self_param, store: source_map },
     )
 }
 
@@ -190,7 +182,8 @@ pub(crate) fn lower_type_ref(
     let mut expr_collector = ExprCollector::new(db, module, type_ref.file_id);
     let type_ref =
         expr_collector.lower_type_ref_opt(type_ref.value, &mut ExprCollector::impl_trait_allocator);
-    (expr_collector.store.finish(), expr_collector.source_map, type_ref)
+    let (store, source_map) = expr_collector.store.finish();
+    (store, source_map, type_ref)
 }
 
 pub(crate) fn lower_generic_params(
@@ -205,7 +198,8 @@ pub(crate) fn lower_generic_params(
     let mut collector = generics::GenericParamsCollector::new(def);
     collector.lower(&mut expr_collector, param_list, where_clause);
     let params = collector.finish();
-    (Arc::new(expr_collector.store.finish()), params, expr_collector.source_map)
+    let (store, source_map) = expr_collector.store.finish();
+    (Arc::new(store), params, source_map)
 }
 
 pub(crate) fn lower_impl(
@@ -232,7 +226,8 @@ pub(crate) fn lower_impl(
         impl_syntax.value.where_clause(),
     );
     let params = collector.finish();
-    (expr_collector.store.finish(), expr_collector.source_map, self_ty, trait_, params)
+    let (store, source_map) = expr_collector.store.finish();
+    (store, source_map, self_ty, trait_, params)
 }
 
 pub(crate) fn lower_trait(
@@ -253,7 +248,8 @@ pub(crate) fn lower_trait(
         trait_syntax.value.where_clause(),
     );
     let params = collector.finish();
-    (expr_collector.store.finish(), expr_collector.source_map, params)
+    let (store, source_map) = expr_collector.store.finish();
+    (store, source_map, params)
 }
 
 pub(crate) fn lower_trait_alias(
@@ -274,7 +270,8 @@ pub(crate) fn lower_trait_alias(
         trait_syntax.value.where_clause(),
     );
     let params = collector.finish();
-    (expr_collector.store.finish(), expr_collector.source_map, params)
+    let (store, source_map) = expr_collector.store.finish();
+    (store, source_map, params)
 }
 
 pub(crate) fn lower_type_alias(
@@ -313,7 +310,8 @@ pub(crate) fn lower_type_alias(
         .value
         .ty()
         .map(|ty| expr_collector.lower_type_ref(ty, &mut ExprCollector::impl_trait_allocator));
-    (expr_collector.store.finish(), expr_collector.source_map, params, bounds, type_ref)
+    let (store, source_map) = expr_collector.store.finish();
+    (store, source_map, params, bounds, type_ref)
 }
 
 pub(crate) fn lower_function(
@@ -421,9 +419,10 @@ pub(crate) fn lower_function(
     } else {
         return_type
     };
+    let (store, source_map) = expr_collector.store.finish();
     (
-        expr_collector.store.finish(),
-        expr_collector.source_map,
+        store,
+        source_map,
         generics,
         params.into_boxed_slice(),
         return_type,
@@ -440,7 +439,6 @@ pub struct ExprCollector<'db> {
     local_def_map: &'db LocalDefMap,
     module: ModuleId,
     pub store: ExpressionStoreBuilder,
-    pub(crate) source_map: ExpressionStoreSourceMap,
 
     // state stuff
     // Prevent nested impl traits like `impl Foo<impl Bar>`.
@@ -551,7 +549,6 @@ impl ExprCollector<'_> {
             module,
             def_map,
             local_def_map,
-            source_map: ExpressionStoreSourceMap::default(),
             store: ExpressionStoreBuilder::default(),
             expander,
             current_try_block_label: None,
@@ -698,7 +695,7 @@ impl ExprCollector<'_> {
                     let id = self.collect_macro_call(mcall, macro_ptr, true, |this, expansion| {
                         this.lower_type_ref_opt(expansion, impl_trait_lower_fn)
                     });
-                    self.source_map.types_map.insert(src, id);
+                    self.store.types_map.insert(src, id);
                     return id;
                 }
                 None => TypeRef::Error,
@@ -732,8 +729,8 @@ impl ExprCollector<'_> {
     fn alloc_type_ref(&mut self, type_ref: TypeRef, node: TypePtr) -> TypeRefId {
         let id = self.store.types.alloc(type_ref);
         let ptr = self.expander.in_file(node);
-        self.source_map.types_map_back.insert(id, ptr);
-        self.source_map.types_map.insert(ptr, id);
+        self.store.types_map_back.insert(id, ptr);
+        self.store.types_map.insert(ptr, id);
         id
     }
 
@@ -744,8 +741,8 @@ impl ExprCollector<'_> {
     ) -> LifetimeRefId {
         let id = self.store.lifetimes.alloc(lifetime_ref);
         let ptr = self.expander.in_file(node);
-        self.source_map.lifetime_map_back.insert(id, ptr);
-        self.source_map.lifetime_map.insert(ptr, id);
+        self.store.lifetime_map_back.insert(id, ptr);
+        self.store.lifetime_map.insert(ptr, id);
         id
     }
 
@@ -1190,14 +1187,14 @@ impl ExprCollector<'_> {
             }
             ast::Expr::ContinueExpr(e) => {
                 let label = self.resolve_label(e.lifetime()).unwrap_or_else(|e| {
-                    self.source_map.diagnostics.push(e);
+                    self.store.diagnostics.push(e);
                     None
                 });
                 self.alloc_expr(Expr::Continue { label }, syntax_ptr)
             }
             ast::Expr::BreakExpr(e) => {
                 let label = self.resolve_label(e.lifetime()).unwrap_or_else(|e| {
-                    self.source_map.diagnostics.push(e);
+                    self.store.diagnostics.push(e);
                     None
                 });
                 let expr = e.expr().map(|e| self.collect_expr(e));
@@ -1207,7 +1204,7 @@ impl ExprCollector<'_> {
                 let inner = self.collect_expr_opt(e.expr());
                 // make the paren expr point to the inner expression as well for IDE resolution
                 let src = self.expander.in_file(syntax_ptr);
-                self.source_map.expr_map.insert(src, inner.into());
+                self.store.expr_map.insert(src, inner.into());
                 inner
             }
             ast::Expr::ReturnExpr(e) => {
@@ -1248,7 +1245,7 @@ impl ExprCollector<'_> {
                                 None => self.missing_expr(),
                             };
                             let src = self.expander.in_file(AstPtr::new(&field));
-                            self.source_map.field_map_back.insert(expr, src);
+                            self.store.field_map_back.insert(expr, src);
                             Some(RecordLitField { name, expr })
                         })
                         .collect();
@@ -1271,12 +1268,10 @@ impl ExprCollector<'_> {
             ast::Expr::AwaitExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 if let Awaitable::No(location) = self.is_lowering_awaitable_block() {
-                    self.source_map.diagnostics.push(
-                        ExpressionStoreDiagnostics::AwaitOutsideOfAsync {
-                            node: self.expander.in_file(AstPtr::new(&e)),
-                            location: location.to_string(),
-                        },
-                    );
+                    self.store.diagnostics.push(ExpressionStoreDiagnostics::AwaitOutsideOfAsync {
+                        node: self.expander.in_file(AstPtr::new(&e)),
+                        location: location.to_string(),
+                    });
                 }
                 self.alloc_expr(Expr::Await { expr }, syntax_ptr)
             }
@@ -1442,7 +1437,7 @@ impl ExprCollector<'_> {
                         // Make the macro-call point to its expanded expression so we can query
                         // semantics on syntax pointers to the macro
                         let src = self.expander.in_file(syntax_ptr);
-                        self.source_map.expr_map.insert(src, id.into());
+                        self.store.expr_map.insert(src, id.into());
                         id
                     }
                     None => self.alloc_expr(Expr::Missing, syntax_ptr),
@@ -1486,7 +1481,7 @@ impl ExprCollector<'_> {
             let expr = self.collect_expr(expr);
             // Do not use `alloc_pat_from_expr()` here, it will override the entry in `expr_map`.
             let id = self.store.pats.alloc(Pat::Expr(expr));
-            self.source_map.pat_map_back.insert(id, src);
+            self.store.pat_map_back.insert(id, src);
             id
         })
     }
@@ -1555,7 +1550,7 @@ impl ExprCollector<'_> {
                 let id = self.collect_macro_call(e, macro_ptr, true, |this, expansion| {
                     this.collect_expr_as_pat_opt(expansion)
                 });
-                self.source_map.expr_map.insert(src, id.into());
+                self.store.expr_map.insert(src, id.into());
                 id
             }
             ast::Expr::RecordExpr(e) => {
@@ -1576,7 +1571,7 @@ impl ExprCollector<'_> {
                         let pat = self.collect_expr_as_pat(field_expr);
                         let name = f.field_name()?.as_name();
                         let src = self.expander.in_file(AstPtr::new(&f).wrap_left());
-                        self.source_map.pat_field_map_back.insert(pat, src);
+                        self.store.pat_field_map_back.insert(pat, src);
                         Some(RecordFieldPat { name, pat })
                     })
                     .collect();
@@ -1622,7 +1617,7 @@ impl ExprCollector<'_> {
                         );
                         if let Either::Left(pat) = pat {
                             let src = this.expander.in_file(AstPtr::new(&expr).wrap_left());
-                            this.source_map.pat_map_back.insert(pat, src);
+                            this.store.pat_map_back.insert(pat, src);
                         }
                         pat
                     }
@@ -1968,7 +1963,7 @@ impl ExprCollector<'_> {
                     self.module.krate(),
                     resolver,
                     &mut |ptr, call| {
-                        _ = self.source_map.expansions.insert(ptr.map(|(it, _)| it), call);
+                        _ = self.store.expansions.insert(ptr.map(|(it, _)| it), call);
                     },
                 )
             }
@@ -1978,19 +1973,17 @@ impl ExprCollector<'_> {
             Ok(res) => res,
             Err(UnresolvedMacro { path }) => {
                 if record_diagnostics {
-                    self.source_map.diagnostics.push(
-                        ExpressionStoreDiagnostics::UnresolvedMacroCall {
-                            node: self.expander.in_file(syntax_ptr),
-                            path,
-                        },
-                    );
+                    self.store.diagnostics.push(ExpressionStoreDiagnostics::UnresolvedMacroCall {
+                        node: self.expander.in_file(syntax_ptr),
+                        path,
+                    });
                 }
                 return collector(self, None);
             }
         };
         if record_diagnostics {
             if let Some(err) = res.err {
-                self.source_map
+                self.store
                     .diagnostics
                     .push(ExpressionStoreDiagnostics::MacroError { node: macro_call_ptr, err });
             }
@@ -2001,7 +1994,7 @@ impl ExprCollector<'_> {
                 // Keep collecting even with expansion errors so we can provide completions and
                 // other services in incomplete macro expressions.
                 if let Some(macro_file) = self.expander.current_file_id().macro_file() {
-                    self.source_map.expansions.insert(macro_call_ptr, macro_file);
+                    self.store.expansions.insert(macro_call_ptr, macro_file);
                 }
 
                 if record_diagnostics {
@@ -2050,7 +2043,7 @@ impl ExprCollector<'_> {
             // Make the macro-call point to its expanded expression so we can query
             // semantics on syntax pointers to the macro
             let src = self.expander.in_file(syntax_ptr);
-            self.source_map.expr_map.insert(src, tail.into());
+            self.store.expr_map.insert(src, tail.into());
         })
     }
 
@@ -2361,7 +2354,7 @@ impl ExprCollector<'_> {
                         let pat = self.collect_pat(ast_pat, binding_list);
                         let name = f.field_name()?.as_name();
                         let src = self.expander.in_file(AstPtr::new(&f).wrap_right());
-                        self.source_map.pat_field_map_back.insert(pat, src);
+                        self.store.pat_field_map_back.insert(pat, src);
                         Some(RecordFieldPat { name, pat })
                     })
                     .collect();
@@ -2424,7 +2417,7 @@ impl ExprCollector<'_> {
                         self.collect_macro_call(call, macro_ptr, true, |this, expanded_pat| {
                             this.collect_pat_opt(expanded_pat, binding_list)
                         });
-                    self.source_map.pat_map.insert(src, pat.into());
+                    self.store.pat_map.insert(src, pat.into());
                     return pat;
                 }
                 None => Pat::Missing,
@@ -2515,7 +2508,7 @@ impl ExprCollector<'_> {
                             }
                         });
                     if let Some(pat) = pat.left() {
-                        self.source_map.pat_map.insert(src, pat.into());
+                        self.store.pat_map.insert(src, pat.into());
                     }
                     pat
                 }
@@ -2537,7 +2530,7 @@ impl ExprCollector<'_> {
         match enabled {
             Ok(()) => true,
             Err(cfg) => {
-                self.source_map.diagnostics.push(ExpressionStoreDiagnostics::InactiveCode {
+                self.store.diagnostics.push(ExpressionStoreDiagnostics::InactiveCode {
                     node: self.expander.in_file(SyntaxNodePtr::new(owner.syntax())),
                     cfg,
                     opts: self.cfg_options.clone(),
@@ -2548,7 +2541,7 @@ impl ExprCollector<'_> {
     }
 
     fn add_definition_to_binding(&mut self, binding_id: BindingId, pat_id: PatId) {
-        self.source_map.binding_definitions.entry(binding_id).or_default().push(pat_id);
+        self.store.binding_definitions.entry(binding_id).or_default().push(pat_id);
     }
 
     // region: labels
@@ -2724,7 +2717,7 @@ impl ExprCollector<'_> {
                     |name, range| {
                         let expr_id = self.alloc_expr_desugared(Expr::Path(Path::from(name)));
                         if let Some(range) = range {
-                            self.source_map
+                            self.store
                                 .template_map
                                 .get_or_insert_with(Default::default)
                                 .implicit_capture_to_source
@@ -2836,7 +2829,7 @@ impl ExprCollector<'_> {
             )
         };
 
-        self.source_map
+        self.store
             .template_map
             .get_or_insert_with(Default::default)
             .format_args_to_captures
@@ -3386,8 +3379,8 @@ impl ExprCollector<'_> {
     fn alloc_expr(&mut self, expr: Expr, ptr: ExprPtr) -> ExprId {
         let src = self.expander.in_file(ptr);
         let id = self.store.exprs.alloc(expr);
-        self.source_map.expr_map_back.insert(id, src.map(AstPtr::wrap_left));
-        self.source_map.expr_map.insert(src, id.into());
+        self.store.expr_map_back.insert(id, src.map(AstPtr::wrap_left));
+        self.store.expr_map.insert(src, id.into());
         id
     }
     // FIXME: desugared exprs don't have ptr, that's wrong and should be fixed.
@@ -3398,9 +3391,9 @@ impl ExprCollector<'_> {
     fn alloc_expr_desugared_with_ptr(&mut self, expr: Expr, ptr: ExprPtr) -> ExprId {
         let src = self.expander.in_file(ptr);
         let id = self.store.exprs.alloc(expr);
-        self.source_map.expr_map_back.insert(id, src.map(AstPtr::wrap_left));
+        self.store.expr_map_back.insert(id, src.map(AstPtr::wrap_left));
         // We intentionally don't fill this as it could overwrite a non-desugared entry
-        // self.source_map.expr_map.insert(src, id);
+        // self.store.expr_map.insert(src, id);
         id
     }
     fn missing_expr(&mut self) -> ExprId {
@@ -3423,24 +3416,24 @@ impl ExprCollector<'_> {
     fn alloc_pat_from_expr(&mut self, pat: Pat, ptr: ExprPtr) -> PatId {
         let src = self.expander.in_file(ptr);
         let id = self.store.pats.alloc(pat);
-        self.source_map.expr_map.insert(src, id.into());
-        self.source_map.pat_map_back.insert(id, src.map(AstPtr::wrap_left));
+        self.store.expr_map.insert(src, id.into());
+        self.store.pat_map_back.insert(id, src.map(AstPtr::wrap_left));
         id
     }
 
     fn alloc_expr_from_pat(&mut self, expr: Expr, ptr: PatPtr) -> ExprId {
         let src = self.expander.in_file(ptr);
         let id = self.store.exprs.alloc(expr);
-        self.source_map.pat_map.insert(src, id.into());
-        self.source_map.expr_map_back.insert(id, src.map(AstPtr::wrap_right));
+        self.store.pat_map.insert(src, id.into());
+        self.store.expr_map_back.insert(id, src.map(AstPtr::wrap_right));
         id
     }
 
     fn alloc_pat(&mut self, pat: Pat, ptr: PatPtr) -> PatId {
         let src = self.expander.in_file(ptr);
         let id = self.store.pats.alloc(pat);
-        self.source_map.pat_map_back.insert(id, src.map(AstPtr::wrap_right));
-        self.source_map.pat_map.insert(src, id.into());
+        self.store.pat_map_back.insert(id, src.map(AstPtr::wrap_right));
+        self.store.pat_map.insert(src, id.into());
         id
     }
     // FIXME: desugared pats don't have ptr, that's wrong and should be fixed somehow.
@@ -3454,8 +3447,8 @@ impl ExprCollector<'_> {
     fn alloc_label(&mut self, label: Label, ptr: LabelPtr) -> LabelId {
         let src = self.expander.in_file(ptr);
         let id = self.store.labels.alloc(label);
-        self.source_map.label_map_back.insert(id, src);
-        self.source_map.label_map.insert(src, id);
+        self.store.label_map_back.insert(id, src);
+        self.store.label_map.insert(src, id);
         id
     }
     // FIXME: desugared labels don't have ptr, that's wrong and should be fixed somehow.
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/asm.rs b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/asm.rs
index d36e5205c73..748bffc6a90 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/asm.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower/asm.rs
@@ -273,7 +273,7 @@ impl ExprCollector<'_> {
             Expr::InlineAsm(InlineAsm { operands: operands.into_boxed_slice(), options }),
             syntax_ptr,
         );
-        self.source_map
+        self.store
             .template_map
             .get_or_insert_with(Default::default)
             .asm_to_captures
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 8fd81c7b3df..f507841a91b 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
@@ -23,7 +23,7 @@ fn lower_path(path: ast::Path) -> (TestDB, ExpressionStore, Option<Path>) {
     let mut ctx =
         ExprCollector::new(&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();
+    let (store, _) = ctx.store.finish();
     (db, store, lowered_path)
 }
 
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 87bcd33ed7b..f1b011333d9 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
@@ -902,7 +902,7 @@ impl Printer<'_> {
                         let mut same_name = false;
                         if let Pat::Bind { id, subpat: None } = &self.store[arg.pat] {
                             if let Binding { name, mode: BindingAnnotation::Unannotated, .. } =
-                                &self.store.bindings[*id]
+                                &self.store.assert_expr_only().bindings[*id]
                             {
                                 if name.as_str() == field_name {
                                     same_name = true;
@@ -1063,7 +1063,7 @@ impl Printer<'_> {
     }
 
     fn print_binding(&mut self, id: BindingId) {
-        let Binding { name, mode, .. } = &self.store.bindings[id];
+        let Binding { name, mode, .. } = &self.store.assert_expr_only().bindings[id];
         let mode = match mode {
             BindingAnnotation::Unannotated => "",
             BindingAnnotation::Mutable => "mut ",
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 2dd0b9bdb86..1952dae9d71 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
@@ -106,7 +106,9 @@ impl ExprScopes {
         let mut scopes = ExprScopes {
             scopes: Arena::default(),
             scope_entries: Arena::default(),
-            scope_by_expr: ArenaMap::with_capacity(body.exprs.len()),
+            scope_by_expr: ArenaMap::with_capacity(
+                body.expr_only.as_ref().map_or(0, |it| it.exprs.len()),
+            ),
         };
         let mut root = scopes.root_scope();
         if let Some(self_param) = body.self_param {
@@ -179,7 +181,7 @@ impl ExprScopes {
         binding: BindingId,
         hygiene: HygieneId,
     ) {
-        let Binding { name, .. } = &store.bindings[binding];
+        let Binding { name, .. } = &store[binding];
         let entry = self.scope_entries.alloc(ScopeEntry { name: name.clone(), binding, hygiene });
         self.scopes[scope].entries =
             IdxRange::new_inclusive(self.scopes[scope].entries.start()..=entry);
@@ -251,7 +253,7 @@ fn compute_expr_scopes(
     scope: &mut ScopeId,
 ) {
     let make_label =
-        |label: &Option<LabelId>| label.map(|label| (label, store.labels[label].name.clone()));
+        |label: &Option<LabelId>| label.map(|label| (label, store[label].name.clone()));
 
     let compute_expr_scopes = |scopes: &mut ExprScopes, expr: ExprId, scope: &mut ScopeId| {
         compute_expr_scopes(expr, store, scopes, scope)
@@ -534,9 +536,8 @@ fn foo() {
         };
 
         let resolved = scopes.resolve_name_in_scope(expr_scope, &name_ref.as_name()).unwrap();
-        let pat_src = source_map
-            .pat_syntax(*source_map.binding_definitions[resolved.binding()].first().unwrap())
-            .unwrap();
+        let pat_src =
+            source_map.pat_syntax(source_map.patterns_for_binding(resolved.binding())[0]).unwrap();
 
         let local_name = pat_src.value.syntax_node_ptr().to_node(file.syntax());
         assert_eq!(local_name.text_range(), expected_name.syntax().text_range());
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 927e280d739..c31428be28f 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
@@ -508,9 +508,9 @@ fn f() {
 }
     "#,
     );
-    assert_eq!(body.bindings.len(), 1, "should have a binding for `B`");
+    assert_eq!(body.assert_expr_only().bindings.len(), 1, "should have a binding for `B`");
     assert_eq!(
-        body.bindings[BindingId::from_raw(RawIdx::from_u32(0))].name.as_str(),
+        body[BindingId::from_raw(RawIdx::from_u32(0))].name.as_str(),
         "B",
         "should have a binding for `B`",
     );
@@ -566,6 +566,7 @@ const fn f(x: i32) -> i32 {
     );
 
     let mtch_arms = body
+        .assert_expr_only()
         .exprs
         .iter()
         .find_map(|(_, expr)| {
@@ -578,10 +579,10 @@ const fn f(x: i32) -> i32 {
         .unwrap();
 
     let MatchArm { pat, .. } = mtch_arms[1];
-    match body.pats[pat] {
+    match body[pat] {
         Pat::Range { start, end } => {
-            let hir_start = &body.exprs[start.unwrap()];
-            let hir_end = &body.exprs[end.unwrap()];
+            let hir_start = &body[start.unwrap()];
+            let hir_end = &body[end.unwrap()];
 
             assert!(matches!(hir_start, Expr::Path { .. }));
             assert!(matches!(hir_end, Expr::Path { .. }));
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 1958eb6c6a1..92e610b36ac 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/signatures.rs
@@ -779,14 +779,10 @@ impl VariantFields {
                 Arc::new(VariantFields { fields, store: Arc::new(store), shape }),
                 Arc::new(source_map),
             ),
-            None => (
-                Arc::new(VariantFields {
-                    fields: Arena::default(),
-                    store: ExpressionStore::empty_singleton(),
-                    shape,
-                }),
-                ExpressionStoreSourceMap::empty_singleton(),
-            ),
+            None => {
+                let (store, source_map) = ExpressionStore::empty_singleton();
+                (Arc::new(VariantFields { fields: Arena::default(), store, shape }), source_map)
+            }
         }
     }
 
@@ -878,7 +874,7 @@ fn lower_fields<Field: ast::HasAttrs + ast::HasVisibility>(
                 idx += 1;
             }
             Err(cfg) => {
-                col.source_map.diagnostics.push(
+                col.store.diagnostics.push(
                     crate::expr_store::ExpressionStoreDiagnostics::InactiveCode {
                         node: InFile::new(fields.file_id, SyntaxNodePtr::new(field.syntax())),
                         cfg,
@@ -891,9 +887,9 @@ fn lower_fields<Field: ast::HasAttrs + ast::HasVisibility>(
     if !has_fields {
         return None;
     }
-    let store = col.store.finish();
+    let (store, source_map) = col.store.finish();
     arena.shrink_to_fit();
-    Some((arena, store, col.source_map))
+    Some((arena, store, source_map))
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -980,7 +976,7 @@ impl EnumVariants {
             if !matches!(variant.shape, FieldsShape::Unit) {
                 let body = db.body(v.into());
                 // A variant with explicit discriminant
-                if body.exprs[body.body_expr] != crate::hir::Expr::Missing {
+                if !matches!(body[body.body_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 24530a5f67c..14b9cd203f6 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/consteval.rs
@@ -281,7 +281,7 @@ pub(crate) fn const_eval_discriminant_variant(
     let def = variant_id.into();
     let body = db.body(def);
     let loc = variant_id.lookup(db);
-    if body.exprs[body.body_expr] == Expr::Missing {
+    if matches!(body[body.body_expr], Expr::Missing) {
         let prev_idx = loc.index.checked_sub(1);
         let value = match prev_idx {
             Some(prev_idx) => {
@@ -334,7 +334,7 @@ pub(crate) fn eval_to_const(
         // Type checking clousres need an isolated body (See the above FIXME). Bail out early to prevent panic.
         return unknown_const(infer[expr].clone());
     }
-    if let Expr::Path(p) = &ctx.body.exprs[expr] {
+    if let Expr::Path(p) = &ctx.body[expr] {
         let resolver = &ctx.resolver;
         if let Some(c) =
             path_to_const(db, resolver, p, mode, || ctx.generics(), debruijn, infer[expr].clone())
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 9c0f8f40080..40fe3073cf2 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
@@ -226,11 +226,10 @@ impl<'a> DeclValidator<'a> {
         let body = self.db.body(func.into());
         let edition = self.edition(func);
         let mut pats_replacements = body
-            .pats
-            .iter()
+            .pats()
             .filter_map(|(pat_id, pat)| match pat {
                 Pat::Bind { id, .. } => {
-                    let bind_name = &body.bindings[*id].name;
+                    let bind_name = &body[*id].name;
                     let mut suggested_text = to_lower_snake_case(bind_name.as_str())?;
                     if is_raw_identifier(&suggested_text, edition) {
                         suggested_text.insert_str(0, "r#");
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 5d56957be6d..5ae6bf6dffd 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
@@ -101,7 +101,7 @@ impl ExprValidator {
             self.check_for_trailing_return(body.body_expr, &body);
         }
 
-        for (id, expr) in body.exprs.iter() {
+        for (id, expr) in body.exprs() {
             if let Some((variant, missed_fields, true)) =
                 record_literal_missing_fields(db, &self.infer, id, expr)
             {
@@ -132,7 +132,7 @@ impl ExprValidator {
             }
         }
 
-        for (id, pat) in body.pats.iter() {
+        for (id, pat) in body.pats() {
             if let Some((variant, missed_fields, true)) =
                 record_pattern_missing_fields(db, &self.infer, id, pat)
             {
@@ -389,7 +389,7 @@ impl ExprValidator {
         if !self.validate_lints {
             return;
         }
-        match &body.exprs[body_expr] {
+        match &body[body_expr] {
             Expr::Block { statements, tail, .. } => {
                 let last_stmt = tail.or_else(|| match statements.last()? {
                     Statement::Expr { expr, .. } => Some(*expr),
@@ -428,7 +428,7 @@ impl ExprValidator {
             if else_branch.is_none() {
                 return;
             }
-            if let Expr::Block { statements, tail, .. } = &self.body.exprs[*then_branch] {
+            if let Expr::Block { statements, tail, .. } = &self.body[*then_branch] {
                 let last_then_expr = tail.or_else(|| match statements.last()? {
                     Statement::Expr { expr, .. } => Some(*expr),
                     _ => None,
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 0bce32a6778..539d2a43a5f 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
@@ -151,7 +151,7 @@ impl<'a> PatCtxt<'a> {
             hir_def::hir::Pat::Bind { id, subpat, .. } => {
                 let bm = self.infer.binding_modes[pat];
                 ty = &self.infer[id];
-                let name = &self.body.bindings[id].name;
+                let name = &self.body[id].name;
                 match (bm, ty.kind(Interner)) {
                     (BindingMode::Ref(_), TyKind::Ref(.., rty)) => ty = rty,
                     (BindingMode::Ref(_), _) => {
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 20cf3c78115..c6f092c4bb2 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
@@ -217,7 +217,7 @@ impl<'db> UnsafeVisitor<'db> {
     }
 
     fn walk_pat(&mut self, current: PatId) {
-        let pat = &self.body.pats[current];
+        let pat = &self.body[current];
 
         if self.inside_union_destructure {
             match pat {
@@ -264,7 +264,7 @@ impl<'db> UnsafeVisitor<'db> {
     }
 
     fn walk_expr(&mut self, current: ExprId) {
-        let expr = &self.body.exprs[current];
+        let expr = &self.body[current];
         let inside_assignment = mem::replace(&mut self.inside_assignment, false);
         match expr {
             &Expr::Call { callee, .. } => {
@@ -284,7 +284,7 @@ impl<'db> UnsafeVisitor<'db> {
                 self.resolver.reset_to_guard(guard);
             }
             Expr::Ref { expr, rawness: Rawness::RawPtr, mutability: _ } => {
-                match self.body.exprs[*expr] {
+                match self.body[*expr] {
                     // Do not report unsafe for `addr_of[_mut]!(EXTERN_OR_MUT_STATIC)`,
                     // see https://github.com/rust-lang/rust/pull/125834.
                     Expr::Path(_) => return,
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 d2eaf212365..3f7eba9dd18 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
@@ -273,7 +273,7 @@ impl InferenceContext<'_> {
     fn pat_bound_mutability(&self, pat: PatId) -> Mutability {
         let mut r = Mutability::Not;
         self.body.walk_bindings_in_pat(pat, |b| {
-            if self.body.bindings[b].mode == BindingAnnotation::RefMut {
+            if self.body[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 99d3b5c7a84..18288b718f7 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
@@ -459,7 +459,7 @@ impl InferenceContext<'_> {
         expected: &Ty,
         decl: Option<DeclContext>,
     ) -> Ty {
-        let Binding { mode, .. } = self.body.bindings[binding];
+        let Binding { mode, .. } = self.body[binding];
         let mode = if mode == BindingAnnotation::Unannotated {
             default_bm
         } else {
@@ -639,7 +639,7 @@ impl InferenceContext<'_> {
 pub(super) fn contains_explicit_ref_binding(body: &Body, pat_id: PatId) -> bool {
     let mut res = false;
     body.walk_pats(pat_id, &mut |pat| {
-        res |= matches!(body[pat], Pat::Bind { id, .. } if body.bindings[id].mode == BindingAnnotation::Ref);
+        res |= matches!(body[pat], Pat::Bind { id, .. } if body[id].mode == BindingAnnotation::Ref);
     });
     res
 }
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 cc7d74f4fb0..b3bc226ec93 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
@@ -119,8 +119,7 @@ fn eval_expr(
         .unwrap();
     let hir_body = db.body(function_id.into());
     let b = hir_body
-        .bindings
-        .iter()
+        .bindings()
         .find(|x| x.1.name.display_no_db(file_id.edition(&db)).to_smolstr() == "goal")
         .unwrap()
         .0;
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 bf80ed7967a..482b420279c 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/mir.rs
@@ -1212,10 +1212,9 @@ impl MirSpan {
         match *self {
             MirSpan::ExprId(expr) => matches!(body[expr], Expr::Ref { .. }),
             // FIXME: Figure out if this is correct wrt. match ergonomics.
-            MirSpan::BindingId(binding) => matches!(
-                body.bindings[binding].mode,
-                BindingAnnotation::Ref | BindingAnnotation::RefMut
-            ),
+            MirSpan::BindingId(binding) => {
+                matches!(body[binding].mode, BindingAnnotation::Ref | BindingAnnotation::RefMut)
+            }
             MirSpan::PatId(_) | MirSpan::SelfParam | MirSpan::Unknown => false,
         }
     }
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 845d6b8eae1..07d81472729 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
@@ -321,7 +321,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         current: BasicBlockId,
     ) -> Result<Option<(Operand, BasicBlockId)>> {
         if !self.has_adjustments(expr_id) {
-            if let Expr::Literal(l) = &self.body.exprs[expr_id] {
+            if let Expr::Literal(l) = &self.body[expr_id] {
                 let ty = self.expr_ty_without_adjust(expr_id);
                 return Ok(Some((self.lower_literal_to_operand(ty, l)?, current)));
             }
@@ -411,7 +411,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
         place: Place,
         mut current: BasicBlockId,
     ) -> Result<Option<BasicBlockId>> {
-        match &self.body.exprs[expr_id] {
+        match &self.body[expr_id] {
             Expr::OffsetOf(_) => {
                 not_supported!("builtin#offset_of")
             }
@@ -1374,7 +1374,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
     }
 
     fn lower_literal_or_const_to_operand(&mut self, ty: Ty, loc: &ExprId) -> Result<Operand> {
-        match &self.body.exprs[*loc] {
+        match &self.body[*loc] {
             Expr::Literal(l) => self.lower_literal_to_operand(ty, l),
             Expr::Path(c) => {
                 let owner = self.owner;
@@ -1850,7 +1850,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
             self.drop_scopes.last_mut().unwrap().locals.push(local_id);
             if let Pat::Bind { id, subpat: None } = self.body[it] {
                 if matches!(
-                    self.body.bindings[id].mode,
+                    self.body[id].mode,
                     BindingAnnotation::Unannotated | BindingAnnotation::Mutable
                 ) {
                     self.result.binding_locals.insert(id, local_id);
@@ -1859,7 +1859,7 @@ impl<'ctx> MirLowerCtx<'ctx> {
             local_id
         }));
         // and then rest of bindings
-        for (id, _) in self.body.bindings.iter() {
+        for (id, _) in self.body.bindings() {
             if !pick_binding(id) {
                 continue;
             }
@@ -2126,7 +2126,7 @@ pub fn mir_body_for_closure_query(
         .result
         .binding_locals
         .into_iter()
-        .filter(|it| ctx.body.binding_owners.get(&it.0).copied() == Some(expr))
+        .filter(|it| ctx.body.binding_owner(it.0) == Some(expr))
         .collect();
     if let Some(err) = err {
         return Err(MirLowerError::UnresolvedUpvar(err));
@@ -2191,7 +2191,7 @@ pub fn lower_to_mir(
     // 0 is return local
     ctx.result.locals.alloc(Local { ty: ctx.expr_ty_after_adjustments(root_expr) });
     let binding_picker = |b: BindingId| {
-        let owner = ctx.body.binding_owners.get(&b).copied();
+        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
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 e7bffead931..e074c2d558e 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
@@ -133,7 +133,7 @@ impl MirLowerCtx<'_> {
             }
             this.lower_expr_to_some_place_without_adjust(expr_id, current)
         };
-        match &self.body.exprs[expr_id] {
+        match &self.body[expr_id] {
             Expr::Path(p) => {
                 let resolver_guard =
                     self.resolver.update_to_inner_scope(self.db, self.owner, expr_id);
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 61c0685c48a..3325226b1d3 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
@@ -130,7 +130,7 @@ impl MirLowerCtx<'_> {
                 .collect::<Vec<_>>()
                 .into(),
         );
-        Ok(match &self.body.pats[pattern] {
+        Ok(match &self.body[pattern] {
             Pat::Missing => return Err(MirLowerError::IncompletePattern),
             Pat::Wild => (current, current_else),
             Pat::Tuple { args, ellipsis } => {
@@ -436,7 +436,7 @@ impl MirLowerCtx<'_> {
                     (next, Some(else_target))
                 }
             },
-            Pat::Lit(l) => match &self.body.exprs[*l] {
+            Pat::Lit(l) => match &self.body[*l] {
                 Expr::Literal(l) => {
                     if mode == MatchingMode::Check {
                         let c = self.lower_literal_to_operand(self.infer[pattern].clone(), l)?;
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 78a69cf4509..aad54f88438 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
@@ -219,7 +219,7 @@ impl<'a> MirPrettyCtx<'a> {
 
     fn local_name(&self, local: LocalId) -> LocalName {
         match self.local_to_binding.get(local) {
-            Some(b) => LocalName::Binding(self.hir_body.bindings[*b].name.clone(), local),
+            Some(b) => LocalName::Binding(self.hir_body[*b].name.clone(), local),
             None => LocalName::Unknown(local),
         }
     }
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 79754bc8a09..9605a0b4124 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/tests.rs
@@ -168,7 +168,7 @@ fn check_impl(
         let inference_result = db.infer(def);
 
         for (pat, mut ty) in inference_result.type_of_pat.iter() {
-            if let Pat::Bind { id, .. } = body.pats[pat] {
+            if let Pat::Bind { id, .. } = body[pat] {
                 ty = &inference_result.type_of_binding[id];
             }
             let node = match pat_node(&body_source_map, pat, &db) {
@@ -316,7 +316,7 @@ 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.pats[pat] {
+            if let Pat::Bind { id, .. } = body[pat] {
                 ty = &inference_result.type_of_binding[id];
             }
             let node = match body_source_map.pat_syntax(pat) {
diff --git a/src/tools/rust-analyzer/crates/hir/src/lib.rs b/src/tools/rust-analyzer/crates/hir/src/lib.rs
index e8a18169712..60be8e6e0fe 100644
--- a/src/tools/rust-analyzer/crates/hir/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/lib.rs
@@ -2034,7 +2034,7 @@ impl DefWithBody {
                     )
                 }
                 let mol = &borrowck_result.mutability_of_locals;
-                for (binding_id, binding_data) in body.bindings.iter() {
+                for (binding_id, binding_data) in body.bindings() {
                     if binding_data.problems.is_some() {
                         // We should report specific diagnostics for these problems, not `need-mut` and `unused-mut`.
                         continue;
diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
index 247bb693983..f046c7737fd 100644
--- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs
@@ -677,8 +677,7 @@ impl<'db> SemanticsImpl<'db> {
     pub fn rename_conflicts(&self, to_be_renamed: &Local, new_name: &Name) -> Vec<Local> {
         let body = self.db.body(to_be_renamed.parent);
         let resolver = to_be_renamed.parent.resolver(self.db);
-        let starting_expr =
-            body.binding_owners.get(&to_be_renamed.binding_id).copied().unwrap_or(body.body_expr);
+        let starting_expr = body.binding_owner(to_be_renamed.binding_id).unwrap_or(body.body_expr);
         let mut visitor = RenameConflictsVisitor {
             body: &body,
             conflicts: FxHashSet::default(),
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 cbd472f87aa..83fe34e6433 100644
--- a/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
+++ b/src/tools/rust-analyzer/crates/hir/src/source_analyzer.rs
@@ -242,11 +242,7 @@ impl<'db> SourceAnalyzer<'db> {
 
     fn binding_id_of_pat(&self, pat: &ast::IdentPat) -> Option<BindingId> {
         let pat_id = self.pat_id(&pat.clone().into())?;
-        if let Pat::Bind { id, .. } = self.store()?.pats[pat_id.as_pat()?] {
-            Some(id)
-        } else {
-            None
-        }
+        if let Pat::Bind { id, .. } = self.store()?[pat_id.as_pat()?] { Some(id) } else { None }
     }
 
     pub(crate) fn expr_adjustments(&self, expr: &ast::Expr) -> Option<&[Adjustment]> {
@@ -997,7 +993,7 @@ impl<'db> SourceAnalyzer<'db> {
         let parent_hir_path = path
             .parent_path()
             .and_then(|p| collector.lower_path(p, &mut ExprCollector::impl_trait_error_allocator));
-        let store = collector.store.finish();
+        let (store, _) = collector.store.finish();
 
         // Case where path is a qualifier of a use tree, e.g. foo::bar::{Baz, Qux} where we are
         // trying to resolve foo::bar.
@@ -1206,7 +1202,7 @@ impl<'db> SourceAnalyzer<'db> {
         let mut collector = ExprCollector::new(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();
+        let (store, _) = collector.store.finish();
         Some(resolve_hir_path_(
             db,
             &self.resolver,
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 bf4688e9d82..d0539abe282 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
@@ -92,7 +92,7 @@ pub(super) fn hints(
                 },
                 MirSpan::Unknown => continue,
             };
-            let binding = &hir.bindings[binding_idx];
+            let binding = &hir[binding_idx];
             let name = binding.name.display_no_db(display_target.edition).to_smolstr();
             if name.starts_with("<ra@") {
                 continue; // Ignore desugared variables
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 0ee01982fea..fc89f486f84 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
@@ -796,7 +796,7 @@ impl flags::AnalysisStats {
             // region:expressions
             let (previous_exprs, previous_unknown, previous_partially_unknown) =
                 (num_exprs, num_exprs_unknown, num_exprs_partially_unknown);
-            for (expr_id, _) in body.exprs.iter() {
+            for (expr_id, _) in body.exprs() {
                 let ty = &inference_result[expr_id];
                 num_exprs += 1;
                 let unknown_or_partial = if ty.is_unknown() {
@@ -901,7 +901,7 @@ impl flags::AnalysisStats {
             // region:patterns
             let (previous_pats, previous_unknown, previous_partially_unknown) =
                 (num_pats, num_pats_unknown, num_pats_partially_unknown);
-            for (pat_id, _) in body.pats.iter() {
+            for (pat_id, _) in body.pats() {
                 let ty = &inference_result[pat_id];
                 num_pats += 1;
                 let unknown_or_partial = if ty.is_unknown() {
-- 
cgit 1.4.1-3-g733a5


From b27392915632b4d754bcecbc7cbbd53c94830e5d Mon Sep 17 00:00:00 2001
From: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
Date: Thu, 10 Jul 2025 11:07:03 +0900
Subject: Migrate `convert_match_to_let_else` assist to use `SyntaxEditor`

Signed-off-by: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
---
 .../src/handlers/convert_match_to_let_else.rs      | 28 ++++++++++++----------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_match_to_let_else.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_match_to_let_else.rs
index efcbcef00e9..9126e869b9a 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_match_to_let_else.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_match_to_let_else.rs
@@ -1,8 +1,8 @@
 use ide_db::defs::{Definition, NameRefClass};
 use syntax::{
     AstNode, SyntaxNode,
-    ast::{self, HasName, Name},
-    ted,
+    ast::{self, HasName, Name, syntax_factory::SyntaxFactory},
+    syntax_editor::SyntaxEditor,
 };
 
 use crate::{
@@ -121,34 +121,36 @@ fn find_extracted_variable(ctx: &AssistContext<'_>, arm: &ast::MatchArm) -> Opti
 
 // Rename `extracted` with `binding` in `pat`.
 fn rename_variable(pat: &ast::Pat, extracted: &[Name], binding: ast::Pat) -> SyntaxNode {
-    let syntax = pat.syntax().clone_for_update();
+    let syntax = pat.syntax().clone_subtree();
+    let mut editor = SyntaxEditor::new(syntax.clone());
+    let make = SyntaxFactory::with_mappings();
     let extracted = extracted
         .iter()
-        .map(|e| syntax.covering_element(e.syntax().text_range()))
+        .map(|e| e.syntax().text_range() - pat.syntax().text_range().start())
+        .map(|r| syntax.covering_element(r))
         .collect::<Vec<_>>();
     for extracted_syntax in extracted {
         // If `extracted` variable is a record field, we should rename it to `binding`,
         // otherwise we just need to replace `extracted` with `binding`.
-
         if let Some(record_pat_field) =
             extracted_syntax.ancestors().find_map(ast::RecordPatField::cast)
         {
             if let Some(name_ref) = record_pat_field.field_name() {
-                ted::replace(
+                editor.replace(
                     record_pat_field.syntax(),
-                    ast::make::record_pat_field(
-                        ast::make::name_ref(&name_ref.text()),
-                        binding.clone(),
+                    make.record_pat_field(
+                        make.name_ref(&name_ref.text()),
+                        binding.clone_for_update(),
                     )
-                    .syntax()
-                    .clone_for_update(),
+                    .syntax(),
                 );
             }
         } else {
-            ted::replace(extracted_syntax, binding.clone().syntax().clone_for_update());
+            editor.replace(extracted_syntax, binding.syntax().clone_for_update());
         }
     }
-    syntax
+    editor.add_mappings(make.finish_with_mappings());
+    editor.finish().new_root().clone()
 }
 
 #[cfg(test)]
-- 
cgit 1.4.1-3-g733a5


From bc2001f15867b2e1496f8973a7eafb704e6fce2f Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 3 Jul 2025 15:18:57 -0400
Subject: Refactor nan tests

---
 library/coretests/tests/floats/f128.rs | 14 --------------
 library/coretests/tests/floats/f16.rs  | 14 --------------
 library/coretests/tests/floats/f32.rs  | 14 --------------
 library/coretests/tests/floats/f64.rs  | 14 --------------
 library/coretests/tests/floats/mod.rs  | 23 +++++++++++++++++++++++
 5 files changed, 23 insertions(+), 56 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index cf78e8796a0..38df09a91c1 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -55,20 +55,6 @@ fn test_num_f128() {
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_nan() {
-    let nan: f128 = f128::NAN;
-    assert!(nan.is_nan());
-    assert!(!nan.is_infinite());
-    assert!(!nan.is_finite());
-    assert!(nan.is_sign_positive());
-    assert!(!nan.is_sign_negative());
-    assert!(!nan.is_normal());
-    assert_eq!(Fp::Nan, nan.classify());
-    // Ensure the quiet bit is set.
-    assert!(nan.to_bits() & (1 << (f128::MANTISSA_DIGITS - 2)) != 0);
-}
-
 #[test]
 fn test_infinity() {
     let inf: f128 = f128::INFINITY;
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index 9e91b654304..f6749d796cc 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -51,20 +51,6 @@ fn test_num_f16() {
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_nan() {
-    let nan: f16 = f16::NAN;
-    assert!(nan.is_nan());
-    assert!(!nan.is_infinite());
-    assert!(!nan.is_finite());
-    assert!(nan.is_sign_positive());
-    assert!(!nan.is_sign_negative());
-    assert!(!nan.is_normal());
-    assert_eq!(Fp::Nan, nan.classify());
-    // Ensure the quiet bit is set.
-    assert!(nan.to_bits() & (1 << (f16::MANTISSA_DIGITS - 2)) != 0);
-}
-
 #[test]
 fn test_infinity() {
     let inf: f16 = f16::INFINITY;
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index d2724d12e39..f5d5723fea4 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -35,20 +35,6 @@ fn test_num_f32() {
     super::test_num(10f32, 2f32);
 }
 
-#[test]
-fn test_nan() {
-    let nan: f32 = f32::NAN;
-    assert!(nan.is_nan());
-    assert!(!nan.is_infinite());
-    assert!(!nan.is_finite());
-    assert!(!nan.is_normal());
-    assert!(nan.is_sign_positive());
-    assert!(!nan.is_sign_negative());
-    assert_eq!(Fp::Nan, nan.classify());
-    // Ensure the quiet bit is set.
-    assert!(nan.to_bits() & (1 << (f32::MANTISSA_DIGITS - 2)) != 0);
-}
-
 #[test]
 fn test_infinity() {
     let inf: f32 = f32::INFINITY;
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index b2b2393a527..34af87c241e 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -30,20 +30,6 @@ fn test_num_f64() {
     super::test_num(10f64, 2f64);
 }
 
-#[test]
-fn test_nan() {
-    let nan: f64 = f64::NAN;
-    assert!(nan.is_nan());
-    assert!(!nan.is_infinite());
-    assert!(!nan.is_finite());
-    assert!(!nan.is_normal());
-    assert!(nan.is_sign_positive());
-    assert!(!nan.is_sign_negative());
-    assert_eq!(Fp::Nan, nan.classify());
-    // Ensure the quiet bit is set.
-    assert!(nan.to_bits() & (1 << (f64::MANTISSA_DIGITS - 2)) != 0);
-}
-
 #[test]
 fn test_infinity() {
     let inf: f64 = f64::INFINITY;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 6b4f586fa9b..36743a7d6df 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -1,4 +1,5 @@
 use std::fmt;
+use std::num::FpCategory as Fp;
 use std::ops::{Add, Div, Mul, Rem, Sub};
 
 /// Set the default tolerance for float comparison based on the type.
@@ -187,6 +188,8 @@ macro_rules! float_test {
             mod const_ {
                 #[allow(unused)]
                 use super::Approx;
+                #[allow(unused)]
+                use std::num::FpCategory as Fp;
                 // Shadow the runtime versions of the macro with const-compatible versions.
                 #[allow(unused)]
                 use $crate::floats::{
@@ -250,6 +253,26 @@ mod f16;
 mod f32;
 mod f64;
 
+float_test! {
+    name: nan,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        assert!(nan.is_nan());
+        assert!(!nan.is_infinite());
+        assert!(!nan.is_finite());
+        assert!(!nan.is_normal());
+        assert!(nan.is_sign_positive());
+        assert!(!nan.is_sign_negative());
+        assert!(matches!(nan.classify(), Fp::Nan));
+        // Ensure the quiet bit is set.
+        assert!(nan.to_bits() & (1 << (Float::MANTISSA_DIGITS - 2)) != 0);
+    }
+}
+
 float_test! {
     name: min,
     attrs: {
-- 
cgit 1.4.1-3-g733a5


From e0f76871eddd0f1345eba7d09e5ab4812f8aa91d Mon Sep 17 00:00:00 2001
From: "LevitatingBusinessMan (Rein Fernhout)" <me@levitati.ng>
Date: Thu, 12 Jun 2025 02:34:15 +0200
Subject: rust: library: Add setsid method to CommandExt trait

Add a setsid method to the CommandExt trait so that callers can create
a process in a new session and process group whilst still using the
POSIX spawn fast path.

Co-Authored-By: Harvey Hunt <harveyhunt@fb.com>
---
 library/std/src/os/unix/process.rs               |  8 ++++
 library/std/src/sys/process/unix/common.rs       |  9 ++++
 library/std/src/sys/process/unix/common/tests.rs | 58 ++++++++++++++++++++++++
 library/std/src/sys/process/unix/unix.rs         | 14 ++++++
 4 files changed, 89 insertions(+)

diff --git a/library/std/src/os/unix/process.rs b/library/std/src/os/unix/process.rs
index 57ce3c5a4bf..baa922f75bc 100644
--- a/library/std/src/os/unix/process.rs
+++ b/library/std/src/os/unix/process.rs
@@ -210,6 +210,9 @@ pub trait CommandExt: Sealed {
     /// intentional difference from the underlying `chroot` system call.)
     #[unstable(feature = "process_chroot", issue = "141298")]
     fn chroot<P: AsRef<Path>>(&mut self, dir: P) -> &mut process::Command;
+
+    #[unstable(feature = "process_setsid", issue = "105376")]
+    fn setsid(&mut self, setsid: bool) -> &mut process::Command;
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -260,6 +263,11 @@ impl CommandExt for process::Command {
         self.as_inner_mut().chroot(dir.as_ref());
         self
     }
+
+    fn setsid(&mut self, setsid: bool) -> &mut process::Command {
+        self.as_inner_mut().setsid(setsid);
+        self
+    }
 }
 
 /// Unix-specific extensions to [`process::ExitStatus`] and
diff --git a/library/std/src/sys/process/unix/common.rs b/library/std/src/sys/process/unix/common.rs
index b6777b76668..6219be60caf 100644
--- a/library/std/src/sys/process/unix/common.rs
+++ b/library/std/src/sys/process/unix/common.rs
@@ -98,6 +98,7 @@ pub struct Command {
     #[cfg(target_os = "linux")]
     create_pidfd: bool,
     pgroup: Option<pid_t>,
+    setsid: bool,
 }
 
 // passed back to std::process with the pipes connected to the child, if any
@@ -185,6 +186,7 @@ impl Command {
             #[cfg(target_os = "linux")]
             create_pidfd: false,
             pgroup: None,
+            setsid: false,
         }
     }
 
@@ -220,6 +222,9 @@ impl Command {
             self.cwd(&OsStr::new("/"));
         }
     }
+    pub fn setsid(&mut self, setsid: bool) {
+        self.setsid = setsid;
+    }
 
     #[cfg(target_os = "linux")]
     pub fn create_pidfd(&mut self, val: bool) {
@@ -298,6 +303,10 @@ impl Command {
     pub fn get_chroot(&self) -> Option<&CStr> {
         self.chroot.as_deref()
     }
+    #[allow(dead_code)]
+    pub fn get_setsid(&self) -> bool {
+        self.setsid
+    }
 
     pub fn get_closures(&mut self) -> &mut Vec<Box<dyn FnMut() -> io::Result<()> + Send + Sync>> {
         &mut self.closures
diff --git a/library/std/src/sys/process/unix/common/tests.rs b/library/std/src/sys/process/unix/common/tests.rs
index e5c8dd6e341..5f71bf051f8 100644
--- a/library/std/src/sys/process/unix/common/tests.rs
+++ b/library/std/src/sys/process/unix/common/tests.rs
@@ -134,6 +134,64 @@ fn test_process_group_no_posix_spawn() {
     }
 }
 
+#[test]
+#[cfg_attr(
+    any(
+        // See test_process_mask
+        target_os = "macos",
+        target_arch = "arm",
+        target_arch = "aarch64",
+        target_arch = "riscv64",
+    ),
+    ignore
+)]
+fn test_setsid_posix_spawn() {
+    // Spawn a cat subprocess that's just going to hang since there is no I/O.
+    let mut cmd = Command::new(OsStr::new("cat"));
+    cmd.setsid(true);
+    cmd.stdin(Stdio::MakePipe);
+    cmd.stdout(Stdio::MakePipe);
+    let (mut cat, _pipes) = t!(cmd.spawn(Stdio::Null, true));
+
+    unsafe {
+        // Setsid will create a new session and process group, so check that
+        // we can kill the process group, which means there *is* one.
+        t!(cvt(libc::kill(-(cat.id() as libc::pid_t), libc::SIGINT)));
+
+        t!(cat.wait());
+    }
+}
+
+#[test]
+#[cfg_attr(
+    any(
+        // See test_process_mask
+        target_os = "macos",
+        target_arch = "arm",
+        target_arch = "aarch64",
+        target_arch = "riscv64",
+    ),
+    ignore
+)]
+fn test_setsid_no_posix_spawn() {
+    let mut cmd = Command::new(OsStr::new("cat"));
+    cmd.setsid(true);
+    cmd.stdin(Stdio::MakePipe);
+    cmd.stdout(Stdio::MakePipe);
+
+    unsafe {
+        // Same as above, create hang-y cat. This time, force using the non-posix_spawn path.
+        cmd.pre_exec(Box::new(|| Ok(()))); // pre_exec forces fork + exec rather than posix spawn.
+        let (mut cat, _pipes) = t!(cmd.spawn(Stdio::Null, true));
+
+        // Setsid will create a new session and process group, so check that
+        // we can kill the process group, which means there *is* one.
+        t!(cvt(libc::kill(-(cat.id() as libc::pid_t), libc::SIGINT)));
+
+        t!(cat.wait());
+    }
+}
+
 #[test]
 fn test_program_kind() {
     let vectors = &[
diff --git a/library/std/src/sys/process/unix/unix.rs b/library/std/src/sys/process/unix/unix.rs
index 4f595ac9a1c..9162573ba09 100644
--- a/library/std/src/sys/process/unix/unix.rs
+++ b/library/std/src/sys/process/unix/unix.rs
@@ -340,6 +340,10 @@ impl Command {
             cvt(libc::setpgid(0, pgroup))?;
         }
 
+        if self.get_setsid() {
+            cvt(libc::setsid())?;
+        }
+
         // emscripten has no signal support.
         #[cfg(not(target_os = "emscripten"))]
         {
@@ -741,6 +745,16 @@ impl Command {
                 flags |= libc::POSIX_SPAWN_SETSIGDEF;
             }
 
+            if self.get_setsid() {
+                cfg_if::cfg_if! {
+                    if #[cfg(all(target_os = "linux", target_env = "gnu"))] {
+                        flags |= libc::POSIX_SPAWN_SETSID;
+                    } else {
+                        return Ok(None);
+                    }
+                }
+            }
+
             cvt_nz(libc::posix_spawnattr_setflags(attrs.0.as_mut_ptr(), flags as _))?;
 
             // Make sure we synchronize access to the global `environ` resource
-- 
cgit 1.4.1-3-g733a5


From 04bb68ac869bc4d55bcb260398470b0c5eea4a40 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Wed, 9 Jul 2025 20:50:17 -0700
Subject: compiler: recomment `needs_fn_once_adapter_shim`

This requires digging up ffee9566bbd7728e6411e6094105d6905373255d
and reading the comments there to understand that the callee in
resolve_closure previously directly handled a function pointer value.
---
 compiler/rustc_middle/src/ty/instance.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index 21b7500e46f..d5767ca3786 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -991,18 +991,16 @@ fn needs_fn_once_adapter_shim(
             Ok(false)
         }
         (ty::ClosureKind::Fn, ty::ClosureKind::FnMut) => {
-            // The closure fn `llfn` is a `fn(&self, ...)`. We want a
-            // `fn(&mut self, ...)`. In fact, at codegen time, these are
-            // basically the same thing, so we can just return llfn.
+            // The closure fn is a `fn(&self, ...)`, but we want a `fn(&mut self, ...)`.
+            // At codegen time, these are basically the same, so we can just return the closure.
             Ok(false)
         }
         (ty::ClosureKind::Fn | ty::ClosureKind::FnMut, ty::ClosureKind::FnOnce) => {
-            // The closure fn `llfn` is a `fn(&self, ...)` or `fn(&mut
-            // self, ...)`. We want a `fn(self, ...)`. We can produce
-            // this by doing something like:
+            // The closure fn is a `fn(&self, ...)` or `fn(&mut self, ...)`, but
+            // we want a `fn(self, ...)`. We can produce this by doing something like:
             //
-            //     fn call_once(self, ...) { call_mut(&self, ...) }
-            //     fn call_once(mut self, ...) { call_mut(&mut self, ...) }
+            //     fn call_once(self, ...) { Fn::call(&self, ...) }
+            //     fn call_once(mut self, ...) { FnMut::call_mut(&mut self, ...) }
             //
             // These are both the same at codegen time.
             Ok(true)
-- 
cgit 1.4.1-3-g733a5


From e726c643e8319ee5eb2a8be45eb65f7600be2d5d Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Thu, 10 Jul 2025 04:58:14 +0000
Subject: Preparing for merge from rustc

---
 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 a9394819541..0af6b8c6fc7 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-688ea65df6a47866d0f72a00f1e18b47a7edf83b
+32cd9114712a24010b0583624dc52ac302194128
-- 
cgit 1.4.1-3-g733a5


From 5e940f581008dbc9b84aa1a8672a3c0a940da7be Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Thu, 10 Jul 2025 05:06:47 +0000
Subject: fmt

---
 src/tools/miri/src/machine.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 35399dbf4cb..7c4d394525b 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1828,7 +1828,9 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
 
     fn enter_trace_span(span: impl FnOnce() -> tracing::Span) -> impl EnteredTraceSpan {
         #[cfg(feature = "tracing")]
-        { span().entered() }
+        {
+            span().entered()
+        }
         #[cfg(not(feature = "tracing"))]
         {
             let _ = span; // so we avoid the "unused variable" warning
-- 
cgit 1.4.1-3-g733a5


From 9068133f2e297cfbdf874bebe4457cd587048ff7 Mon Sep 17 00:00:00 2001
From: Laurențiu Nicola <lnicola@dend.ro>
Date: Thu, 10 Jul 2025 08:24:53 +0300
Subject: Revert "remove `if-let` chains"

This reverts commit fcc81a38b3ed55447735f71e8d374fcb36c22f24.
---
 .../src/handlers/replace_is_method_with_if_let_method.rs    | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 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 62914ee7f38..5ef8ba46b9e 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
@@ -64,13 +64,12 @@ pub(crate) fn replace_is_method_with_if_let_method(
                     let pat = make.tuple_struct_pat(make.ident_path(text), [var_pat.into()]);
                     let let_expr = make.expr_let(pat.into(), receiver);
 
-                    if let Some(cap) = ctx.config.snippet_cap {
-                        if let Some(ast::Pat::TupleStructPat(pat)) = let_expr.pat() {
-                            if let Some(first_var) = pat.fields().next() {
-                                let placeholder = edit.make_placeholder_snippet(cap);
-                                editor.add_annotation(first_var.syntax(), placeholder);
-                            }
-                        }
+                    if let Some(cap) = ctx.config.snippet_cap
+                        && let Some(ast::Pat::TupleStructPat(pat)) = let_expr.pat()
+                        && let Some(first_var) = pat.fields().next()
+                    {
+                        let placeholder = edit.make_placeholder_snippet(cap);
+                        editor.add_annotation(first_var.syntax(), placeholder);
                     }
 
                     editor.replace(call_expr.syntax(), let_expr.syntax());
-- 
cgit 1.4.1-3-g733a5


From 58d7c2d5a760c1adfa4c3984eeb12787f5ad5b1d Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Wed, 9 Jul 2025 22:30:15 -0700
Subject: Make UB transmutes really UB in LLVM

Ralf suggested in <https://github.com/rust-lang/rust/pull/143410#discussion_r2184928123> that UB transmutes shouldn't be trapping, which happened for the one path that PR was changing, but there's another path as well, so this PR changes that other path to match.
---
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs | 12 +++++-------
 tests/codegen/intrinsics/transmute.rs        | 22 +++++++++++++---------
 2 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index cbbb0196890..1e3b76e5f93 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -236,14 +236,12 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             || operand.layout.is_uninhabited()
             || cast.is_uninhabited()
         {
-            if !operand.layout.is_uninhabited() {
-                // Since this is known statically and the input could have existed
-                // without already having hit UB, might as well trap for it.
-                bx.abort();
-            }
+            // We can't use unreachable because that's a terminator, and we
+            // need something that can be in the middle of a basic block.
+            bx.assume(bx.cx().const_bool(false));
 
-            // Because this transmute is UB, return something easy to generate,
-            // since it's fine that later uses of the value are probably UB.
+            // We still need to return a value of the appropriate type, but
+            // it's already UB so do the easiest thing available.
             return OperandValue::poison(bx, cast);
         }
 
diff --git a/tests/codegen/intrinsics/transmute.rs b/tests/codegen/intrinsics/transmute.rs
index e375724bc1b..36d6a2f722f 100644
--- a/tests/codegen/intrinsics/transmute.rs
+++ b/tests/codegen/intrinsics/transmute.rs
@@ -58,9 +58,9 @@ pub unsafe fn check_bigger_array(x: [u32; 3]) -> [u32; 7] {
 #[no_mangle]
 #[custom_mir(dialect = "runtime", phase = "optimized")]
 pub unsafe fn check_to_empty_array(x: [u32; 5]) -> [u32; 0] {
-    // CHECK-NOT: trap
-    // CHECK: call void @llvm.trap
-    // CHECK-NOT: trap
+    // CHECK-NOT: call
+    // CHECK: call void @llvm.assume(i1 false)
+    // CHECK-NOT: call
     mir! {
         {
             RET = CastTransmute(x);
@@ -88,9 +88,9 @@ pub unsafe fn check_from_empty_array(x: [u32; 0]) -> [u32; 5] {
 #[no_mangle]
 #[custom_mir(dialect = "runtime", phase = "optimized")]
 pub unsafe fn check_to_uninhabited(x: u16) {
-    // CHECK-NOT: trap
-    // CHECK: call void @llvm.trap
-    // CHECK-NOT: trap
+    // CHECK-NOT: call
+    // CHECK: call void @llvm.assume(i1 false)
+    // CHECK-NOT: call
     mir! {
         let temp: BigNever;
         {
@@ -104,6 +104,9 @@ pub unsafe fn check_to_uninhabited(x: u16) {
 #[no_mangle]
 #[custom_mir(dialect = "runtime", phase = "optimized")]
 pub unsafe fn check_from_uninhabited(x: BigNever) -> u16 {
+    // CHECK-NOT: call
+    // CHECK: call void @llvm.assume(i1 false)
+    // CHECK-NOT: call
     // CHECK: ret i16 poison
     mir! {
         {
@@ -401,9 +404,9 @@ pub unsafe fn check_issue_109992(x: ()) -> [(); 1] {
 pub unsafe fn check_unit_to_never(x: ()) {
     // This uses custom MIR to avoid MIR optimizations having removed ZST ops.
 
-    // CHECK-NOT: trap
-    // CHECK: call void @llvm.trap
-    // CHECK-NOT: trap
+    // CHECK-NOT: call
+    // CHECK: call void @llvm.assume(i1 false)
+    // CHECK-NOT: call
     mir! {
         let temp: ZstNever;
         {
@@ -420,6 +423,7 @@ pub unsafe fn check_unit_from_never(x: ZstNever) -> () {
     // This uses custom MIR to avoid MIR optimizations having removed ZST ops.
 
     // CHECK: start
+    // CHECK-NEXT: call void @llvm.assume(i1 false)
     // CHECK-NEXT: ret void
     mir! {
         {
-- 
cgit 1.4.1-3-g733a5


From 4dc954f88256314c4c03a4cb43eee838bc3762eb Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Thu, 10 Jul 2025 13:50:02 +0800
Subject: remove unnecessary parens in rust-analyzer

---
 src/tools/rust-analyzer/crates/rust-analyzer/src/cli/scip.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 d258c5d8191..37f83f6dee6 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
@@ -25,7 +25,7 @@ impl flags::Scip {
         eprintln!("Generating SCIP start...");
         let now = Instant::now();
 
-        let no_progress = &|s| (eprintln!("rust-analyzer: Loading {s}"));
+        let no_progress = &|s| eprintln!("rust-analyzer: Loading {s}");
         let root =
             vfs::AbsPathBuf::assert_utf8(std::env::current_dir()?.join(&self.path)).normalize();
 
-- 
cgit 1.4.1-3-g733a5


From 87a41210d4ec4f43a1e015dfea44ef3f686c9872 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Wed, 9 Jul 2025 20:29:51 +0800
Subject: Only provide `is_windows_msvc` to gate on windows-msvc

And not both `is_windows_msvc` and `is_msvc`.
---
 src/tools/run-make-support/src/artifact_names.rs   |  6 +++---
 .../run-make-support/src/external_deps/c_build.rs  | 23 +++++++++++-----------
 .../src/external_deps/c_cxx_compiler/cc.rs         |  6 +++---
 .../src/external_deps/c_cxx_compiler/extras.rs     |  6 +++---
 .../run-make-support/src/external_deps/rustc.rs    |  4 ++--
 src/tools/run-make-support/src/lib.rs              |  2 +-
 src/tools/run-make-support/src/linker.rs           |  4 ++--
 src/tools/run-make-support/src/targets.rs          | 12 +++--------
 8 files changed, 29 insertions(+), 34 deletions(-)

diff --git a/src/tools/run-make-support/src/artifact_names.rs b/src/tools/run-make-support/src/artifact_names.rs
index b0d588d3550..a889b30e145 100644
--- a/src/tools/run-make-support/src/artifact_names.rs
+++ b/src/tools/run-make-support/src/artifact_names.rs
@@ -2,7 +2,7 @@
 //! libraries which are target-dependent.
 
 use crate::target;
-use crate::targets::is_msvc;
+use crate::targets::is_windows_msvc;
 
 /// Construct the static library name based on the target.
 #[track_caller]
@@ -10,7 +10,7 @@ use crate::targets::is_msvc;
 pub fn static_lib_name(name: &str) -> String {
     assert!(!name.contains(char::is_whitespace), "static library name cannot contain whitespace");
 
-    if is_msvc() { format!("{name}.lib") } else { format!("lib{name}.a") }
+    if is_windows_msvc() { format!("{name}.lib") } else { format!("lib{name}.a") }
 }
 
 /// Construct the dynamic library name based on the target.
@@ -45,7 +45,7 @@ pub fn dynamic_lib_extension() -> &'static str {
 #[track_caller]
 #[must_use]
 pub fn msvc_import_dynamic_lib_name(name: &str) -> String {
-    assert!(is_msvc(), "this function is exclusive to MSVC");
+    assert!(is_windows_msvc(), "this function is exclusive to MSVC");
     assert!(!name.contains(char::is_whitespace), "import library name cannot contain whitespace");
 
     format!("{name}.dll.lib")
diff --git a/src/tools/run-make-support/src/external_deps/c_build.rs b/src/tools/run-make-support/src/external_deps/c_build.rs
index 9dd30713f95..ecbf5ba8fe0 100644
--- a/src/tools/run-make-support/src/external_deps/c_build.rs
+++ b/src/tools/run-make-support/src/external_deps/c_build.rs
@@ -4,7 +4,7 @@ use crate::artifact_names::{dynamic_lib_name, static_lib_name};
 use crate::external_deps::c_cxx_compiler::{cc, cxx};
 use crate::external_deps::llvm::llvm_ar;
 use crate::path_helpers::path;
-use crate::targets::{is_darwin, is_msvc, is_windows};
+use crate::targets::{is_darwin, is_windows, is_windows_msvc};
 
 // FIXME(Oneirical): These native build functions should take a Path-based generic.
 
@@ -24,12 +24,12 @@ pub fn build_native_static_lib_optimized(lib_name: &str) -> PathBuf {
 
 #[track_caller]
 fn build_native_static_lib_internal(lib_name: &str, optimzed: bool) -> PathBuf {
-    let obj_file = if is_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
+    let obj_file = if is_windows_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
     let src = format!("{lib_name}.c");
     let lib_path = static_lib_name(lib_name);
 
     let mut cc = cc();
-    if !is_msvc() {
+    if !is_windows_msvc() {
         cc.arg("-v");
     }
     if optimzed {
@@ -37,7 +37,7 @@ fn build_native_static_lib_internal(lib_name: &str, optimzed: bool) -> PathBuf {
     }
     cc.arg("-c").out_exe(&obj_file).input(src).optimize().run();
 
-    let obj_file = if is_msvc() {
+    let obj_file = if is_windows_msvc() {
         PathBuf::from(format!("{lib_name}.obj"))
     } else {
         PathBuf::from(format!("{lib_name}.o"))
@@ -50,16 +50,17 @@ fn build_native_static_lib_internal(lib_name: &str, optimzed: bool) -> PathBuf {
 /// [`std::env::consts::DLL_PREFIX`] and [`std::env::consts::DLL_EXTENSION`].
 #[track_caller]
 pub fn build_native_dynamic_lib(lib_name: &str) -> PathBuf {
-    let obj_file = if is_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
+    let obj_file = if is_windows_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
     let src = format!("{lib_name}.c");
     let lib_path = dynamic_lib_name(lib_name);
-    if is_msvc() {
+    if is_windows_msvc() {
         cc().arg("-c").out_exe(&obj_file).input(src).run();
     } else {
         cc().arg("-v").arg("-c").out_exe(&obj_file).input(src).run();
     };
-    let obj_file = if is_msvc() { format!("{lib_name}.obj") } else { format!("{lib_name}.o") };
-    if is_msvc() {
+    let obj_file =
+        if is_windows_msvc() { format!("{lib_name}.obj") } else { format!("{lib_name}.o") };
+    if is_windows_msvc() {
         let out_arg = format!("-out:{lib_path}");
         cc().input(&obj_file).args(&["-link", "-dll", &out_arg]).run();
     } else if is_darwin() {
@@ -79,15 +80,15 @@ pub fn build_native_dynamic_lib(lib_name: &str) -> PathBuf {
 /// Built from a C++ file.
 #[track_caller]
 pub fn build_native_static_lib_cxx(lib_name: &str) -> PathBuf {
-    let obj_file = if is_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
+    let obj_file = if is_windows_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
     let src = format!("{lib_name}.cpp");
     let lib_path = static_lib_name(lib_name);
-    if is_msvc() {
+    if is_windows_msvc() {
         cxx().arg("-EHs").arg("-c").out_exe(&obj_file).input(src).run();
     } else {
         cxx().arg("-c").out_exe(&obj_file).input(src).run();
     };
-    let obj_file = if is_msvc() {
+    let obj_file = if is_windows_msvc() {
         PathBuf::from(format!("{lib_name}.obj"))
     } else {
         PathBuf::from(format!("{lib_name}.o"))
diff --git a/src/tools/run-make-support/src/external_deps/c_cxx_compiler/cc.rs b/src/tools/run-make-support/src/external_deps/c_cxx_compiler/cc.rs
index 0e6d6ea6075..31469e669e1 100644
--- a/src/tools/run-make-support/src/external_deps/c_cxx_compiler/cc.rs
+++ b/src/tools/run-make-support/src/external_deps/c_cxx_compiler/cc.rs
@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use crate::command::Command;
-use crate::{env_var, is_msvc};
+use crate::{env_var, is_windows_msvc};
 
 /// Construct a new platform-specific C compiler invocation.
 ///
@@ -82,7 +82,7 @@ impl Cc {
     pub fn out_exe(&mut self, name: &str) -> &mut Self {
         let mut path = std::path::PathBuf::from(name);
 
-        if is_msvc() {
+        if is_windows_msvc() {
             path.set_extension("exe");
             let fe_path = path.clone();
             path.set_extension("");
@@ -108,7 +108,7 @@ impl Cc {
     /// Optimize the output.
     /// Equivalent to `-O3` for GNU-compatible linkers or `-O2` for MSVC linkers.
     pub fn optimize(&mut self) -> &mut Self {
-        if is_msvc() {
+        if is_windows_msvc() {
             self.cmd.arg("-O2");
         } else {
             self.cmd.arg("-O3");
diff --git a/src/tools/run-make-support/src/external_deps/c_cxx_compiler/extras.rs b/src/tools/run-make-support/src/external_deps/c_cxx_compiler/extras.rs
index c0317633873..ac7392641c0 100644
--- a/src/tools/run-make-support/src/external_deps/c_cxx_compiler/extras.rs
+++ b/src/tools/run-make-support/src/external_deps/c_cxx_compiler/extras.rs
@@ -1,9 +1,9 @@
-use crate::{is_msvc, is_win7, is_windows, uname};
+use crate::{is_win7, is_windows, is_windows_msvc, uname};
 
 /// `EXTRACFLAGS`
 pub fn extra_c_flags() -> Vec<&'static str> {
     if is_windows() {
-        if is_msvc() {
+        if is_windows_msvc() {
             let mut libs =
                 vec!["ws2_32.lib", "userenv.lib", "bcrypt.lib", "ntdll.lib", "synchronization.lib"];
             if is_win7() {
@@ -29,7 +29,7 @@ pub fn extra_c_flags() -> Vec<&'static str> {
 /// `EXTRACXXFLAGS`
 pub fn extra_cxx_flags() -> Vec<&'static str> {
     if is_windows() {
-        if is_msvc() { vec![] } else { vec!["-lstdc++"] }
+        if is_windows_msvc() { vec![] } else { vec!["-lstdc++"] }
     } else {
         match &uname()[..] {
             "Darwin" => vec!["-lc++"],
diff --git a/src/tools/run-make-support/src/external_deps/rustc.rs b/src/tools/run-make-support/src/external_deps/rustc.rs
index 72a1e062a38..1ea549ca7ea 100644
--- a/src/tools/run-make-support/src/external_deps/rustc.rs
+++ b/src/tools/run-make-support/src/external_deps/rustc.rs
@@ -6,7 +6,7 @@ use crate::command::Command;
 use crate::env::env_var;
 use crate::path_helpers::cwd;
 use crate::util::set_host_compiler_dylib_path;
-use crate::{is_aix, is_darwin, is_msvc, is_windows, target, uname};
+use crate::{is_aix, is_darwin, is_windows, is_windows_msvc, target, uname};
 
 /// Construct a new `rustc` invocation. This will automatically set the library
 /// search path as `-L cwd()`. Use [`bare_rustc`] to avoid this.
@@ -377,7 +377,7 @@ impl Rustc {
             // So we end up with the following hack: we link use static:-bundle to only
             // link the parts of libstdc++ that we actually use, which doesn't include
             // the dependency on the pthreads DLL.
-            if !is_msvc() {
+            if !is_windows_msvc() {
                 self.cmd.arg("-lstatic:-bundle=stdc++");
             };
         } else if is_darwin() {
diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
index 69054396229..29cd6c4ad15 100644
--- a/src/tools/run-make-support/src/lib.rs
+++ b/src/tools/run-make-support/src/lib.rs
@@ -83,6 +83,6 @@ pub use crate::string::{
 };
 // Helpers for checking target information.
 pub use crate::targets::{
-    apple_os, is_aix, is_darwin, is_msvc, is_win7, is_windows, is_windows_gnu, is_windows_msvc,
+    apple_os, is_aix, is_darwin, is_win7, is_windows, is_windows_gnu, is_windows_msvc,
     llvm_components_contain, target, uname,
 };
diff --git a/src/tools/run-make-support/src/linker.rs b/src/tools/run-make-support/src/linker.rs
index 89093cf0113..b2893ad88fe 100644
--- a/src/tools/run-make-support/src/linker.rs
+++ b/src/tools/run-make-support/src/linker.rs
@@ -1,6 +1,6 @@
 use regex::Regex;
 
-use crate::{Rustc, is_msvc};
+use crate::{Rustc, is_windows_msvc};
 
 /// Asserts that `rustc` uses LLD for linking when executed.
 pub fn assert_rustc_uses_lld(rustc: &mut Rustc) {
@@ -22,7 +22,7 @@ pub fn assert_rustc_doesnt_use_lld(rustc: &mut Rustc) {
 
 fn get_stderr_with_linker_messages(rustc: &mut Rustc) -> String {
     // lld-link is used if msvc, otherwise a gnu-compatible lld is used.
-    let linker_version_flag = if is_msvc() { "--version" } else { "-Wl,-v" };
+    let linker_version_flag = if is_windows_msvc() { "--version" } else { "-Wl,-v" };
 
     let output = rustc.arg("-Wlinker-messages").link_arg(linker_version_flag).run();
     output.stderr_utf8()
diff --git a/src/tools/run-make-support/src/targets.rs b/src/tools/run-make-support/src/targets.rs
index 1ab2e2ab2be..b20e12561fb 100644
--- a/src/tools/run-make-support/src/targets.rs
+++ b/src/tools/run-make-support/src/targets.rs
@@ -16,10 +16,10 @@ pub fn is_windows() -> bool {
     target().contains("windows")
 }
 
-/// Check if target uses msvc.
+/// Check if target is windows-msvc.
 #[must_use]
-pub fn is_msvc() -> bool {
-    target().contains("msvc")
+pub fn is_windows_msvc() -> bool {
+    target().ends_with("windows-msvc")
 }
 
 /// Check if target is windows-gnu.
@@ -28,12 +28,6 @@ pub fn is_windows_gnu() -> bool {
     target().ends_with("windows-gnu")
 }
 
-/// Check if target is windows-msvc.
-#[must_use]
-pub fn is_windows_msvc() -> bool {
-    target().ends_with("windows-msvc")
-}
-
 /// Check if target is win7.
 #[must_use]
 pub fn is_win7() -> bool {
-- 
cgit 1.4.1-3-g733a5


From 3f4f23af617171e2e03e867a61b952d56166143b Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Wed, 9 Jul 2025 20:29:33 +0800
Subject: Use `is_windows_msvc` instead of `is_msvc` in run-make tests

---
 tests/run-make/archive-duplicate-names/rmake.rs            | 8 ++++----
 tests/run-make/c-link-to-rust-dylib/rmake.rs               | 6 ++++--
 tests/run-make/c-unwind-abi-catch-lib-panic/rmake.rs       | 6 +++---
 tests/run-make/cdylib-dylib-linkage/rmake.rs               | 4 ++--
 tests/run-make/cdylib/rmake.rs                             | 4 ++--
 tests/run-make/compiler-rt-works-on-mingw/rmake.rs         | 2 +-
 tests/run-make/link-args-order/rmake.rs                    | 4 ++--
 tests/run-make/link-dedup/rmake.rs                         | 4 ++--
 tests/run-make/native-link-modifier-bundle/rmake.rs        | 4 ++--
 tests/run-make/native-link-modifier-whole-archive/rmake.rs | 6 +++---
 tests/run-make/pointer-auth-link-with-c/rmake.rs           | 6 +++---
 tests/run-make/print-native-static-libs/rmake.rs           | 6 +++---
 tests/run-make/raw-dylib-alt-calling-convention/rmake.rs   | 6 ++++--
 tests/run-make/raw-dylib-import-name-type/rmake.rs         | 4 ++--
 tests/run-make/raw-dylib-inline-cross-dylib/rmake.rs       | 4 ++--
 tests/run-make/raw-dylib-link-ordinal/rmake.rs             | 4 ++--
 tests/run-make/raw-dylib-stdcall-ordinal/rmake.rs          | 4 ++--
 tests/run-make/rlib-format-packed-bundled-libs/rmake.rs    | 6 +++---
 tests/run-make/split-debuginfo/rmake.rs                    | 6 +++---
 tests/run-make/static-dylib-by-default/rmake.rs            | 6 +++---
 tests/run-make/staticlib-dylib-linkage/rmake.rs            | 4 ++--
 tests/run-make/symbol-visibility/rmake.rs                  | 6 +++---
 22 files changed, 57 insertions(+), 53 deletions(-)

diff --git a/tests/run-make/archive-duplicate-names/rmake.rs b/tests/run-make/archive-duplicate-names/rmake.rs
index 62a35566199..0c352b3ae1b 100644
--- a/tests/run-make/archive-duplicate-names/rmake.rs
+++ b/tests/run-make/archive-duplicate-names/rmake.rs
@@ -6,7 +6,7 @@
 //@ ignore-cross-compile
 // Reason: the compiled binary is executed
 
-use run_make_support::{cc, is_msvc, llvm_ar, rfs, run, rustc};
+use run_make_support::{cc, is_windows_msvc, llvm_ar, rfs, run, rustc};
 
 fn main() {
     rfs::create_dir("a");
@@ -15,7 +15,7 @@ fn main() {
     compile_obj_force_foo("b", "bar");
     let mut ar = llvm_ar();
     ar.obj_to_ar().arg("libfoo.a");
-    if is_msvc() {
+    if is_windows_msvc() {
         ar.arg("a/foo.obj").arg("b/foo.obj").run();
     } else {
         ar.arg("a/foo.o").arg("b/foo.o").run();
@@ -27,9 +27,9 @@ fn main() {
 
 #[track_caller]
 pub fn compile_obj_force_foo(dir: &str, lib_name: &str) {
-    let obj_file = if is_msvc() { format!("{dir}/foo") } else { format!("{dir}/foo.o") };
+    let obj_file = if is_windows_msvc() { format!("{dir}/foo") } else { format!("{dir}/foo.o") };
     let src = format!("{lib_name}.c");
-    if is_msvc() {
+    if is_windows_msvc() {
         cc().arg("-c").out_exe(&obj_file).input(src).run();
     } else {
         cc().arg("-v").arg("-c").out_exe(&obj_file).input(src).run();
diff --git a/tests/run-make/c-link-to-rust-dylib/rmake.rs b/tests/run-make/c-link-to-rust-dylib/rmake.rs
index 3a48af8a366..ece0c81d2da 100644
--- a/tests/run-make/c-link-to-rust-dylib/rmake.rs
+++ b/tests/run-make/c-link-to-rust-dylib/rmake.rs
@@ -3,12 +3,14 @@
 
 //@ ignore-cross-compile
 
-use run_make_support::{cc, cwd, dynamic_lib_extension, is_msvc, rfs, run, run_fail, rustc};
+use run_make_support::{
+    cc, cwd, dynamic_lib_extension, is_windows_msvc, rfs, run, run_fail, rustc,
+};
 
 fn main() {
     rustc().input("foo.rs").run();
 
-    if is_msvc() {
+    if is_windows_msvc() {
         let lib = "foo.dll.lib";
 
         cc().input("bar.c").arg(lib).out_exe("bar").run();
diff --git a/tests/run-make/c-unwind-abi-catch-lib-panic/rmake.rs b/tests/run-make/c-unwind-abi-catch-lib-panic/rmake.rs
index 62e1748b6fb..ba5fe589acb 100644
--- a/tests/run-make/c-unwind-abi-catch-lib-panic/rmake.rs
+++ b/tests/run-make/c-unwind-abi-catch-lib-panic/rmake.rs
@@ -8,11 +8,11 @@
 //@ needs-unwind
 // Reason: this test exercises unwinding a panic
 
-use run_make_support::{cc, is_msvc, llvm_ar, run, rustc, static_lib_name};
+use run_make_support::{cc, is_windows_msvc, llvm_ar, run, rustc, static_lib_name};
 
 fn main() {
     // Compile `add.c` into an object file.
-    if is_msvc() {
+    if is_windows_msvc() {
         cc().arg("-c").out_exe("add").input("add.c").run();
     } else {
         cc().arg("-v").arg("-c").out_exe("add.o").input("add.c").run();
@@ -24,7 +24,7 @@ fn main() {
     rustc().emit("obj").input("panic.rs").run();
 
     // Now, create an archive using these two objects.
-    if is_msvc() {
+    if is_windows_msvc() {
         llvm_ar().obj_to_ar().args(&[&static_lib_name("add"), "add.obj", "panic.o"]).run();
     } else {
         llvm_ar().obj_to_ar().args(&[&static_lib_name("add"), "add.o", "panic.o"]).run();
diff --git a/tests/run-make/cdylib-dylib-linkage/rmake.rs b/tests/run-make/cdylib-dylib-linkage/rmake.rs
index a8fd8e2d168..3c145d9f99c 100644
--- a/tests/run-make/cdylib-dylib-linkage/rmake.rs
+++ b/tests/run-make/cdylib-dylib-linkage/rmake.rs
@@ -9,7 +9,7 @@
 
 use run_make_support::{
     bin_name, cc, dynamic_lib_extension, dynamic_lib_name, filename_contains, has_extension,
-    has_prefix, has_suffix, is_msvc, msvc_import_dynamic_lib_name, path, run, rustc,
+    has_prefix, has_suffix, is_windows_msvc, msvc_import_dynamic_lib_name, path, run, rustc,
     shallow_find_files, target,
 };
 
@@ -19,7 +19,7 @@ fn main() {
     let sysroot = rustc().print("sysroot").run().stdout_utf8();
     let sysroot = sysroot.trim();
     let target_sysroot = path(sysroot).join("lib/rustlib").join(target()).join("lib");
-    if is_msvc() {
+    if is_windows_msvc() {
         let mut libs = shallow_find_files(&target_sysroot, |path| {
             has_prefix(path, "libstd-") && has_suffix(path, ".dll.lib")
         });
diff --git a/tests/run-make/cdylib/rmake.rs b/tests/run-make/cdylib/rmake.rs
index 21b83d1b1a9..21fd8b486c4 100644
--- a/tests/run-make/cdylib/rmake.rs
+++ b/tests/run-make/cdylib/rmake.rs
@@ -10,13 +10,13 @@
 
 //@ ignore-cross-compile
 
-use run_make_support::{cc, cwd, dynamic_lib_name, is_msvc, rfs, run, rustc};
+use run_make_support::{cc, cwd, dynamic_lib_name, is_windows_msvc, rfs, run, rustc};
 
 fn main() {
     rustc().input("bar.rs").run();
     rustc().input("foo.rs").run();
 
-    if is_msvc() {
+    if is_windows_msvc() {
         cc().input("foo.c").arg("foo.dll.lib").out_exe("foo").run();
     } else {
         cc().input("foo.c").arg("-lfoo").library_search_path(cwd()).output("foo").run();
diff --git a/tests/run-make/compiler-rt-works-on-mingw/rmake.rs b/tests/run-make/compiler-rt-works-on-mingw/rmake.rs
index f1b41f96312..b15e56db1bb 100644
--- a/tests/run-make/compiler-rt-works-on-mingw/rmake.rs
+++ b/tests/run-make/compiler-rt-works-on-mingw/rmake.rs
@@ -5,7 +5,7 @@
 
 //@ only-windows-gnu
 
-use run_make_support::{cxx, is_msvc, llvm_ar, run, rustc, static_lib_name};
+use run_make_support::{cxx, llvm_ar, run, rustc, static_lib_name};
 
 fn main() {
     cxx().input("foo.cpp").arg("-c").out_exe("foo.o").run();
diff --git a/tests/run-make/link-args-order/rmake.rs b/tests/run-make/link-args-order/rmake.rs
index 7a67c12f74c..e3c730bfec5 100644
--- a/tests/run-make/link-args-order/rmake.rs
+++ b/tests/run-make/link-args-order/rmake.rs
@@ -6,10 +6,10 @@
 // checks that linker arguments remain intact and in the order they were originally passed in.
 // See https://github.com/rust-lang/rust/pull/70665
 
-use run_make_support::{is_msvc, rustc};
+use run_make_support::{is_windows_msvc, rustc};
 
 fn main() {
-    let linker = if is_msvc() { "msvc" } else { "ld" };
+    let linker = if is_windows_msvc() { "msvc" } else { "ld" };
 
     rustc()
         .input("empty.rs")
diff --git a/tests/run-make/link-dedup/rmake.rs b/tests/run-make/link-dedup/rmake.rs
index 874e6e0083b..84fdf87e9c7 100644
--- a/tests/run-make/link-dedup/rmake.rs
+++ b/tests/run-make/link-dedup/rmake.rs
@@ -9,7 +9,7 @@
 
 use std::fmt::Write;
 
-use run_make_support::{is_msvc, rustc, target};
+use run_make_support::{is_windows_msvc, rustc, target};
 
 fn main() {
     rustc().input("depa.rs").run();
@@ -32,7 +32,7 @@ fn main() {
 fn needle_from_libs(libs: &[&str]) -> String {
     let mut needle = String::new();
     for lib in libs {
-        if is_msvc() {
+        if is_windows_msvc() {
             needle.write_fmt(format_args!(r#""{lib}.lib" "#)).unwrap();
         } else if target().contains("wasm") {
             needle.write_fmt(format_args!(r#""-l" "{lib}" "#)).unwrap();
diff --git a/tests/run-make/native-link-modifier-bundle/rmake.rs b/tests/run-make/native-link-modifier-bundle/rmake.rs
index 058b66b15f1..64ee7733498 100644
--- a/tests/run-make/native-link-modifier-bundle/rmake.rs
+++ b/tests/run-make/native-link-modifier-bundle/rmake.rs
@@ -20,7 +20,7 @@
 // Reason: cross-compilation fails to export native symbols
 
 use run_make_support::{
-    build_native_static_lib, dynamic_lib_name, is_msvc, llvm_nm, rust_lib_name, rustc,
+    build_native_static_lib, dynamic_lib_name, is_windows_msvc, llvm_nm, rust_lib_name, rustc,
     static_lib_name,
 };
 
@@ -60,7 +60,7 @@ fn main() {
         .assert_stdout_contains_regex("U _*native_func");
 
     // This part of the test does not function on Windows MSVC - no symbols are printed.
-    if !is_msvc() {
+    if !is_windows_msvc() {
         // Build a cdylib, `native-staticlib` will not appear on the linker line because it was
         // bundled previously. The cdylib will contain the `native_func` symbol in the end.
         rustc()
diff --git a/tests/run-make/native-link-modifier-whole-archive/rmake.rs b/tests/run-make/native-link-modifier-whole-archive/rmake.rs
index b8b814043e5..90b0203e278 100644
--- a/tests/run-make/native-link-modifier-whole-archive/rmake.rs
+++ b/tests/run-make/native-link-modifier-whole-archive/rmake.rs
@@ -10,11 +10,11 @@
 // Reason: compiling C++ code does not work well when cross-compiling
 // plus, the compiled binary is executed
 
-use run_make_support::{cxx, is_msvc, llvm_ar, run, run_with_args, rustc, static_lib_name};
+use run_make_support::{cxx, is_windows_msvc, llvm_ar, run, run_with_args, rustc, static_lib_name};
 
 fn main() {
     let mut cxx = cxx();
-    if is_msvc() {
+    if is_windows_msvc() {
         cxx.arg("-EHs");
     }
     cxx.input("c_static_lib_with_constructor.cpp")
@@ -24,7 +24,7 @@ fn main() {
 
     let mut llvm_ar = llvm_ar();
     llvm_ar.obj_to_ar();
-    if is_msvc() {
+    if is_windows_msvc() {
         llvm_ar
             .output_input(
                 static_lib_name("c_static_lib_with_constructor"),
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 7b6dff10eae..a4d7454e575 100644
--- a/tests/run-make/pointer-auth-link-with-c/rmake.rs
+++ b/tests/run-make/pointer-auth-link-with-c/rmake.rs
@@ -9,7 +9,7 @@
 //@ ignore-cross-compile
 // Reason: the compiled binary is executed
 
-use run_make_support::{build_native_static_lib, cc, is_msvc, llvm_ar, run, rustc};
+use run_make_support::{build_native_static_lib, cc, is_windows_msvc, llvm_ar, run, rustc};
 
 fn main() {
     build_native_static_lib("test");
@@ -21,7 +21,7 @@ fn main() {
         .input("test.c")
         .arg("-mbranch-protection=bti+pac-ret+leaf")
         .run();
-    let obj_file = if is_msvc() { "test.obj" } else { "test" };
+    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,leaf").input("test.rs").run();
     run("test");
@@ -33,7 +33,7 @@ fn main() {
     //     .input("test.c")
     //     .arg("-mbranch-protection=bti+pac-ret+pc+leaf")
     //     .run();
-    // let obj_file = if is_msvc() { "test.obj" } else { "test" };
+    // 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();
     // run("test");
diff --git a/tests/run-make/print-native-static-libs/rmake.rs b/tests/run-make/print-native-static-libs/rmake.rs
index a51ac934c72..4502c874cae 100644
--- a/tests/run-make/print-native-static-libs/rmake.rs
+++ b/tests/run-make/print-native-static-libs/rmake.rs
@@ -12,7 +12,7 @@
 //@ ignore-cross-compile
 //@ ignore-wasm
 
-use run_make_support::{is_msvc, rustc};
+use run_make_support::{is_windows_msvc, rustc};
 
 fn main() {
     // build supporting crate
@@ -41,9 +41,9 @@ fn main() {
             ($lib:literal in $args:ident) => {{
                 let lib = format!(
                     "{}{}{}",
-                    if !is_msvc() { "-l" } else { "" },
+                    if !is_windows_msvc() { "-l" } else { "" },
                     $lib,
-                    if !is_msvc() { "" } else { ".lib" },
+                    if !is_windows_msvc() { "" } else { ".lib" },
                 );
                 let found = $args.contains(&&*lib);
                 assert!(found, "unable to find lib `{}` in those linker args: {:?}", lib, $args);
diff --git a/tests/run-make/raw-dylib-alt-calling-convention/rmake.rs b/tests/run-make/raw-dylib-alt-calling-convention/rmake.rs
index 1a1622f2754..0843c6beae8 100644
--- a/tests/run-make/raw-dylib-alt-calling-convention/rmake.rs
+++ b/tests/run-make/raw-dylib-alt-calling-convention/rmake.rs
@@ -9,7 +9,9 @@
 //@ only-x86
 //@ only-windows
 
-use run_make_support::{build_native_dynamic_lib, diff, is_msvc, run, run_with_args, rustc};
+use run_make_support::{
+    build_native_dynamic_lib, diff, is_windows_msvc, run, run_with_args, rustc,
+};
 
 fn main() {
     rustc()
@@ -21,7 +23,7 @@ fn main() {
     build_native_dynamic_lib("extern");
     let out = run("driver").stdout_utf8();
     diff().expected_file("output.txt").actual_text("actual", out).normalize(r#"\r"#, "").run();
-    if is_msvc() {
+    if is_windows_msvc() {
         let out_msvc = run_with_args("driver", &["true"]).stdout_utf8();
         diff()
             .expected_file("output.msvc.txt")
diff --git a/tests/run-make/raw-dylib-import-name-type/rmake.rs b/tests/run-make/raw-dylib-import-name-type/rmake.rs
index 13a2c99150e..71f255ab39f 100644
--- a/tests/run-make/raw-dylib-import-name-type/rmake.rs
+++ b/tests/run-make/raw-dylib-import-name-type/rmake.rs
@@ -11,14 +11,14 @@
 //@ only-windows
 // Reason: this test specifically exercises a 32bit Windows calling convention.
 
-use run_make_support::{cc, diff, is_msvc, run, rustc};
+use run_make_support::{cc, diff, is_windows_msvc, run, rustc};
 
 // NOTE: build_native_dynamic lib is not used, as the special `def` files
 // must be passed to the CC compiler.
 
 fn main() {
     rustc().crate_type("bin").input("driver.rs").run();
-    if is_msvc() {
+    if is_windows_msvc() {
         cc().arg("-c").out_exe("extern").input("extern.c").run();
         cc().input("extern.obj")
             .arg("extern.msvc.def")
diff --git a/tests/run-make/raw-dylib-inline-cross-dylib/rmake.rs b/tests/run-make/raw-dylib-inline-cross-dylib/rmake.rs
index 6e3b31a0cdb..a167e8198a7 100644
--- a/tests/run-make/raw-dylib-inline-cross-dylib/rmake.rs
+++ b/tests/run-make/raw-dylib-inline-cross-dylib/rmake.rs
@@ -7,7 +7,7 @@
 
 //@ only-windows
 
-use run_make_support::{cc, diff, is_msvc, llvm_objdump, run, rustc};
+use run_make_support::{cc, diff, is_windows_msvc, llvm_objdump, run, rustc};
 
 fn main() {
     rustc()
@@ -31,7 +31,7 @@ fn main() {
         .assert_stdout_not_contains("inline_library_function")
         // Make sure we do find an import to the functions we expect to be imported.
         .assert_stdout_contains("library_function");
-    if is_msvc() {
+    if is_windows_msvc() {
         cc().arg("-c").out_exe("extern_1").input("extern_1.c").run();
         cc().arg("-c").out_exe("extern_2").input("extern_2.c").run();
         cc().input("extern_1.obj")
diff --git a/tests/run-make/raw-dylib-link-ordinal/rmake.rs b/tests/run-make/raw-dylib-link-ordinal/rmake.rs
index b52181ae3f9..43274b9765b 100644
--- a/tests/run-make/raw-dylib-link-ordinal/rmake.rs
+++ b/tests/run-make/raw-dylib-link-ordinal/rmake.rs
@@ -11,7 +11,7 @@
 
 //@ only-windows
 
-use run_make_support::{cc, diff, is_msvc, run, rustc};
+use run_make_support::{cc, diff, is_windows_msvc, run, rustc};
 
 // NOTE: build_native_dynamic lib is not used, as the special `def` files
 // must be passed to the CC compiler.
@@ -19,7 +19,7 @@ use run_make_support::{cc, diff, is_msvc, run, rustc};
 fn main() {
     rustc().crate_type("lib").crate_name("raw_dylib_test").input("lib.rs").run();
     rustc().crate_type("bin").input("driver.rs").run();
-    if is_msvc() {
+    if is_windows_msvc() {
         cc().arg("-c").out_exe("exporter").input("exporter.c").run();
         cc().input("exporter.obj")
             .arg("exporter.def")
diff --git a/tests/run-make/raw-dylib-stdcall-ordinal/rmake.rs b/tests/run-make/raw-dylib-stdcall-ordinal/rmake.rs
index 320ea1520d8..f898cc0f8c8 100644
--- a/tests/run-make/raw-dylib-stdcall-ordinal/rmake.rs
+++ b/tests/run-make/raw-dylib-stdcall-ordinal/rmake.rs
@@ -10,7 +10,7 @@
 //@ only-windows
 // Reason: this test specifically exercises a 32bit Windows calling convention.
 
-use run_make_support::{cc, diff, is_msvc, run, rustc};
+use run_make_support::{cc, diff, is_windows_msvc, run, rustc};
 
 // NOTE: build_native_dynamic lib is not used, as the special `def` files
 // must be passed to the CC compiler.
@@ -18,7 +18,7 @@ use run_make_support::{cc, diff, is_msvc, run, rustc};
 fn main() {
     rustc().crate_type("lib").crate_name("raw_dylib_test").input("lib.rs").run();
     rustc().crate_type("bin").input("driver.rs").run();
-    if is_msvc() {
+    if is_windows_msvc() {
         cc().arg("-c").out_exe("exporter").input("exporter.c").run();
         cc().input("exporter.obj")
             .arg("exporter-msvc.def")
diff --git a/tests/run-make/rlib-format-packed-bundled-libs/rmake.rs b/tests/run-make/rlib-format-packed-bundled-libs/rmake.rs
index ff0438a6b72..f0929a3ee85 100644
--- a/tests/run-make/rlib-format-packed-bundled-libs/rmake.rs
+++ b/tests/run-make/rlib-format-packed-bundled-libs/rmake.rs
@@ -8,8 +8,8 @@
 // Reason: cross-compilation fails to export native symbols
 
 use run_make_support::{
-    bin_name, build_native_static_lib, cwd, filename_contains, is_msvc, llvm_ar, llvm_nm, rfs,
-    rust_lib_name, rustc, shallow_find_files,
+    bin_name, build_native_static_lib, cwd, filename_contains, is_windows_msvc, llvm_ar, llvm_nm,
+    rfs, rust_lib_name, rustc, shallow_find_files,
 };
 
 fn main() {
@@ -74,7 +74,7 @@ fn main() {
         .assert_stdout_contains_regex("native_dep_1.*native_dep_2.*native_dep_3");
 
     // The binary "main" will not contain any symbols on MSVC.
-    if !is_msvc() {
+    if !is_windows_msvc() {
         llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f1");
         llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f2");
         llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f3");
diff --git a/tests/run-make/split-debuginfo/rmake.rs b/tests/run-make/split-debuginfo/rmake.rs
index 530a5d119f1..e8de5aed172 100644
--- a/tests/run-make/split-debuginfo/rmake.rs
+++ b/tests/run-make/split-debuginfo/rmake.rs
@@ -61,8 +61,8 @@ use std::collections::BTreeSet;
 
 use run_make_support::rustc::Rustc;
 use run_make_support::{
-    cwd, has_extension, is_darwin, is_msvc, is_windows, llvm_dwarfdump, run_in_tmpdir, rustc,
-    shallow_find_directories, shallow_find_files, uname,
+    cwd, has_extension, is_darwin, is_windows, is_windows_msvc, llvm_dwarfdump, run_in_tmpdir,
+    rustc, shallow_find_directories, shallow_find_files, uname,
 };
 
 /// `-C debuginfo`. See <https://doc.rust-lang.org/rustc/codegen-options/index.html#debuginfo>.
@@ -1296,7 +1296,7 @@ fn main() {
     // identify which combination isn't exercised with a 6-layers nested for loop iterating through
     // each of the cli flag enum variants.
 
-    if is_msvc() {
+    if is_windows_msvc() {
         // FIXME: the windows-msvc test coverage is sparse at best.
 
         windows_msvc_tests::split_debuginfo(SplitDebuginfo::Off, DebuginfoLevel::Unspecified);
diff --git a/tests/run-make/static-dylib-by-default/rmake.rs b/tests/run-make/static-dylib-by-default/rmake.rs
index 133210c74e7..b1160c63297 100644
--- a/tests/run-make/static-dylib-by-default/rmake.rs
+++ b/tests/run-make/static-dylib-by-default/rmake.rs
@@ -9,7 +9,7 @@
 // Reason: the compiled binary is executed
 
 use run_make_support::{
-    cc, cwd, dynamic_lib_name, extra_c_flags, has_extension, is_msvc, rfs, run, rustc,
+    cc, cwd, dynamic_lib_name, extra_c_flags, has_extension, is_windows_msvc, rfs, run, rustc,
     shallow_find_files,
 };
 
@@ -22,13 +22,13 @@ fn main() {
     // bar.dll.exp // export library for the dylib
     // msvc's underlying link.exe requires the import library for the dynamic library as input.
     // That is why the library is bar.dll.lib, not bar.dll.
-    let library = if is_msvc() { "bar.dll.lib" } else { &dynamic_lib_name("bar") };
+    let library = if is_windows_msvc() { "bar.dll.lib" } else { &dynamic_lib_name("bar") };
     cc().input("main.c").out_exe("main").arg(library).args(extra_c_flags()).run();
     for rlib in shallow_find_files(cwd(), |path| has_extension(path, "rlib")) {
         rfs::remove_file(rlib);
     }
     rfs::remove_file(dynamic_lib_name("foo"));
-    if is_msvc() {
+    if is_windows_msvc() {
         rfs::remove_file("foo.dll.lib");
     }
     run("main");
diff --git a/tests/run-make/staticlib-dylib-linkage/rmake.rs b/tests/run-make/staticlib-dylib-linkage/rmake.rs
index 8dd1ac0ffbd..9582ca19831 100644
--- a/tests/run-make/staticlib-dylib-linkage/rmake.rs
+++ b/tests/run-make/staticlib-dylib-linkage/rmake.rs
@@ -9,7 +9,7 @@
 //@ ignore-wasm
 // Reason: WASM does not support dynamic libraries
 
-use run_make_support::{cc, is_msvc, regex, run, rustc, static_lib_name};
+use run_make_support::{cc, is_windows_msvc, regex, run, rustc, static_lib_name};
 
 fn main() {
     rustc().arg("-Cprefer-dynamic").input("bar.rs").run();
@@ -27,7 +27,7 @@ fn main() {
     let (_, native_link_args) = libs.split_once("note: native-static-libs: ").unwrap();
     // divide the command-line arguments in a vec
     let mut native_link_args = native_link_args.split(' ').collect::<Vec<&str>>();
-    if is_msvc() {
+    if is_windows_msvc() {
         // For MSVC pass the arguments on to the linker.
         native_link_args.insert(0, "-link");
     }
diff --git a/tests/run-make/symbol-visibility/rmake.rs b/tests/run-make/symbol-visibility/rmake.rs
index 49c8e87707b..e3d276d6da8 100644
--- a/tests/run-make/symbol-visibility/rmake.rs
+++ b/tests/run-make/symbol-visibility/rmake.rs
@@ -9,7 +9,7 @@
 // See https://github.com/rust-lang/rust/issues/37530
 
 use run_make_support::object::read::Object;
-use run_make_support::{bin_name, dynamic_lib_name, is_msvc, object, regex, rfs, rustc};
+use run_make_support::{bin_name, dynamic_lib_name, is_windows_msvc, object, regex, rfs, rustc};
 
 fn main() {
     let cdylib_name = dynamic_lib_name("a_cdylib");
@@ -64,7 +64,7 @@ fn main() {
     );
 
     // FIXME(nbdd0121): This is broken in MinGW, see https://github.com/rust-lang/rust/pull/95604#issuecomment-1101564032
-    if is_msvc() {
+    if is_windows_msvc() {
         // Check that an executable does not export any dynamic symbols
         symbols_check(&exe_name, SymbolCheckType::StrSymbol("public_c_function_from_rlib"), false);
         symbols_check(
@@ -130,7 +130,7 @@ fn main() {
     );
 
     // FIXME(nbdd0121): This is broken in MinGW, see https://github.com/rust-lang/rust/pull/95604#issuecomment-1101564032
-    if is_msvc() {
+    if is_windows_msvc() {
         // Check that an executable does not export any dynamic symbols
         symbols_check(&exe_name, SymbolCheckType::StrSymbol("public_c_function_from_rlib"), false);
         symbols_check(
-- 
cgit 1.4.1-3-g733a5


From 3e675f4c5085df8ae19392e6de2caef7cb336f27 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Wed, 9 Jul 2025 22:25:03 +0200
Subject: Fix `--skip-std-check-if-no-download-rustc`

Since https://github.com/rust-lang/rust/pull/143048, we now explicitly set the build compiler for `check::Std`, which caused it to be built before we checked `--skip-std-check-if-no-download-rustc`. So I moved the check earlier to `make_run`, which resolves it.

I also added a regression test for this. Sadly we can't really test for the positive case easily (when download-ci-rustc is enabled), but we can test the negative cases, where it is disabled.
---
 src/bootstrap/src/core/build_steps/check.rs | 14 +++++++-------
 src/bootstrap/src/core/builder/tests.rs     | 24 ++++++++++++++++++++++++
 2 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 0497bae86a1..0cc4628310a 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -47,6 +47,13 @@ impl Step for Std {
     }
 
     fn make_run(run: RunConfig<'_>) {
+        if !run.builder.download_rustc() && run.builder.config.skip_std_check_if_no_download_rustc {
+            eprintln!(
+                "WARNING: `--skip-std-check-if-no-download-rustc` flag was passed and `rust.download-rustc` is not available. Skipping."
+            );
+            return;
+        }
+
         let crates = std_crates_for_run_make(&run);
         run.builder.ensure(Std {
             build_compiler: prepare_compiler_for_check(run.builder, run.target, Mode::Std),
@@ -56,13 +63,6 @@ impl Step for Std {
     }
 
     fn run(self, builder: &Builder<'_>) {
-        if !builder.download_rustc() && builder.config.skip_std_check_if_no_download_rustc {
-            eprintln!(
-                "WARNING: `--skip-std-check-if-no-download-rustc` flag was passed and `rust.download-rustc` is not available. Skipping."
-            );
-            return;
-        }
-
         let build_compiler = self.build_compiler;
         let stage = build_compiler.stage;
         let target = self.target;
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index bbcb58fca14..75cc5e01ec9 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1439,6 +1439,30 @@ mod snapshot {
         ");
     }
 
+    /// Make sure that we don't check library when download-rustc is disabled
+    /// when `--skip-std-check-if-no-download-rustc` was passed.
+    #[test]
+    fn check_library_skip_without_download_rustc() {
+        let ctx = TestCtx::new();
+        let args = ["--set", "rust.download-rustc=false", "--skip-std-check-if-no-download-rustc"];
+        insta::assert_snapshot!(
+            ctx.config("check")
+                .paths(&["library"])
+                .args(&args)
+                .render_steps(), @"");
+
+        insta::assert_snapshot!(
+            ctx.config("check")
+                .paths(&["library", "compiler"])
+                .args(&args)
+                .render_steps(), @r"
+        [build] llvm <host>
+        [check] rustc 0 <host> -> rustc 1 <host>
+        [check] rustc 0 <host> -> cranelift 1 <host>
+        [check] rustc 0 <host> -> gcc 1 <host>
+        ");
+    }
+
     #[test]
     fn check_miri_no_explicit_stage() {
         let ctx = TestCtx::new();
-- 
cgit 1.4.1-3-g733a5


From 17b240e04f8d14e5563b6afb2ed3b842f87d1c78 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 10 Jul 2025 08:33:05 +0200
Subject: silence clippy

---
 src/tools/miri/src/machine.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 7c4d394525b..9c077e5b7b6 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1832,6 +1832,7 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
             span().entered()
         }
         #[cfg(not(feature = "tracing"))]
+        #[expect(clippy::unused_unit)]
         {
             let _ = span; // so we avoid the "unused variable" warning
             ()
-- 
cgit 1.4.1-3-g733a5


From 84eeca2e2fc40bb8d6641846f18af9d8fc6a9681 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Thu, 10 Jul 2025 07:27:41 +0000
Subject: Make some "safe" llvm ops actually sound

---
 compiler/rustc_codegen_llvm/src/back/write.rs       |  2 +-
 compiler/rustc_codegen_llvm/src/builder/autodiff.rs |  2 +-
 compiler/rustc_codegen_llvm/src/consts.rs           |  2 +-
 compiler/rustc_codegen_llvm/src/llvm/mod.rs         | 10 ++++++----
 4 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index bde6a9cf4bc..506286fc255 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -1182,7 +1182,7 @@ fn create_msvc_imps(
         .filter_map(|val| {
             // Exclude some symbols that we know are not Rust symbols.
             let name = llvm::get_value_name(val);
-            if ignored(name) { None } else { Some((val, name)) }
+            if ignored(&name) { None } else { Some((val, name)) }
         })
         .map(move |(val, name)| {
             let mut imp_name = prefix.as_bytes().to_vec();
diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index b07d9a5cfca..5afb9a60d42 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -306,7 +306,7 @@ fn generate_enzyme_call<'ll>(
     // add outer_fn name to ad_name to make it unique, in case users apply autodiff to multiple
     // functions. Unwrap will only panic, if LLVM gave us an invalid string.
     let name = llvm::get_value_name(outer_fn);
-    let outer_fn_name = std::str::from_utf8(name).unwrap();
+    let outer_fn_name = std::str::from_utf8(&name).unwrap();
     ad_name.push_str(outer_fn_name);
 
     // Let us assume the user wrote the following function square:
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 28f5282c6b0..9c5008e0304 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -430,7 +430,7 @@ impl<'ll> CodegenCx<'ll, '_> {
                 // specific rules on what can be cast. So instead of adding a new way to
                 // generate static initializers that match the static's type, we picked
                 // the easier option and retroactively change the type of the static item itself.
-                let name = llvm::get_value_name(g).to_vec();
+                let name = llvm::get_value_name(g);
                 llvm::set_value_name(g, b"");
 
                 let linkage = llvm::get_linkage(g);
diff --git a/compiler/rustc_codegen_llvm/src/llvm/mod.rs b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
index 661174a80df..3fc83fca352 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
@@ -211,7 +211,7 @@ pub(crate) fn SetFunctionCallConv(fn_: &Value, cc: CallConv) {
 // function.
 // For more details on COMDAT sections see e.g., https://www.airs.com/blog/archives/52
 pub(crate) fn SetUniqueComdat(llmod: &Module, val: &Value) {
-    let name_buf = get_value_name(val).to_vec();
+    let name_buf = get_value_name(val);
     let name =
         CString::from_vec_with_nul(name_buf).or_else(|buf| CString::new(buf.into_bytes())).unwrap();
     set_comdat(llmod, val, &name);
@@ -319,12 +319,14 @@ pub(crate) fn get_param(llfn: &Value, index: c_uint) -> &Value {
     }
 }
 
-/// Safe wrapper for `LLVMGetValueName2` into a byte slice
-pub(crate) fn get_value_name(value: &Value) -> &[u8] {
+/// Safe wrapper for `LLVMGetValueName2`
+/// Needs to allocate the value, because `set_value_name` will invalidate
+/// the pointer.
+pub(crate) fn get_value_name(value: &Value) -> Vec<u8> {
     unsafe {
         let mut len = 0;
         let data = LLVMGetValueName2(value, &mut len);
-        std::slice::from_raw_parts(data.cast(), len)
+        std::slice::from_raw_parts(data.cast(), len).to_vec()
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 9681786409c2135643f0d614eceb669d03741ef7 Mon Sep 17 00:00:00 2001
From: Tomasz Miąsko <tomasz.miasko@gmail.com>
Date: Mon, 7 Jul 2025 21:49:20 +0200
Subject: Propagate from borrowed locals in CopyProp

---
 compiler/rustc_mir_transform/src/ssa.rs            |  26 +--
 ...rrowed_local.borrowed.CopyProp.panic-abort.diff |   5 +-
 ...rowed_local.borrowed.CopyProp.panic-unwind.diff |   5 +-
 tests/mir-opt/copy-prop/borrowed_local.rs          |   3 +-
 .../copy-prop/write_to_borrowed.main.CopyProp.diff |   5 +-
 tests/mir-opt/copy-prop/write_to_borrowed.rs       |   3 +-
 ...lter.variant_a-{closure#0}.PreCodegen.after.mir | 192 +++++++++------------
 7 files changed, 97 insertions(+), 142 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/ssa.rs b/compiler/rustc_mir_transform/src/ssa.rs
index d3b4b99e932..cd9a7f4a39d 100644
--- a/compiler/rustc_mir_transform/src/ssa.rs
+++ b/compiler/rustc_mir_transform/src/ssa.rs
@@ -293,10 +293,6 @@ impl<'tcx> Visitor<'tcx> for SsaVisitor<'_, 'tcx> {
 fn compute_copy_classes(ssa: &mut SsaLocals, body: &Body<'_>) {
     let mut direct_uses = std::mem::take(&mut ssa.direct_uses);
     let mut copies = IndexVec::from_fn_n(|l| l, body.local_decls.len());
-    // We must not unify two locals that are borrowed. But this is fine if one is borrowed and
-    // the other is not. This bitset is keyed by *class head* and contains whether any member of
-    // the class is borrowed.
-    let mut borrowed_classes = ssa.borrowed_locals().clone();
 
     for (local, rvalue, _) in ssa.assignments(body) {
         let (Rvalue::Use(Operand::Copy(place) | Operand::Move(place))
@@ -322,8 +318,12 @@ fn compute_copy_classes(ssa: &mut SsaLocals, body: &Body<'_>) {
         // visited before `local`, and we just have to copy the representing local.
         let head = copies[rhs];
 
-        // Do not unify borrowed locals.
-        if borrowed_classes.contains(local) || borrowed_classes.contains(head) {
+        // When propagating from `head` to `local` we need to ensure that changes to the address
+        // are not observable, so at most one the locals involved can be borrowed. Additionally, we
+        // need to ensure that the definition of `head` dominates all uses of `local`. When `local`
+        // is borrowed, there might exist an indirect use of `local` that isn't dominated by the
+        // definition, so we have to reject copy propagation.
+        if ssa.borrowed_locals().contains(local) {
             continue;
         }
 
@@ -339,21 +339,14 @@ fn compute_copy_classes(ssa: &mut SsaLocals, body: &Body<'_>) {
                     *h = RETURN_PLACE;
                 }
             }
-            if borrowed_classes.contains(head) {
-                borrowed_classes.insert(RETURN_PLACE);
-            }
         } else {
             copies[local] = head;
-            if borrowed_classes.contains(local) {
-                borrowed_classes.insert(head);
-            }
         }
         direct_uses[rhs] -= 1;
     }
 
     debug!(?copies);
     debug!(?direct_uses);
-    debug!(?borrowed_classes);
 
     // Invariant: `copies` must point to the head of an equivalence class.
     #[cfg(debug_assertions)]
@@ -362,13 +355,6 @@ fn compute_copy_classes(ssa: &mut SsaLocals, body: &Body<'_>) {
     }
     debug_assert_eq!(copies[RETURN_PLACE], RETURN_PLACE);
 
-    // Invariant: `borrowed_classes` must be true if any member of the class is borrowed.
-    #[cfg(debug_assertions)]
-    for &head in copies.iter() {
-        let any_borrowed = ssa.borrowed_locals.iter().any(|l| copies[l] == head);
-        assert_eq!(borrowed_classes.contains(head), any_borrowed);
-    }
-
     ssa.direct_uses = direct_uses;
     ssa.copy_classes = copies;
 }
diff --git a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff
index 285cd0f6527..40e8c06f357 100644
--- a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff
@@ -7,13 +7,14 @@
       let mut _3: &T;
   
       bb0: {
-          _2 = copy _1;
+-         _2 = copy _1;
           _3 = &_1;
           _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
-          _0 = opaque::<T>(copy _2) -> [return: bb2, unwind unreachable];
+-         _0 = opaque::<T>(copy _2) -> [return: bb2, unwind unreachable];
++         _0 = opaque::<T>(copy _1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
diff --git a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff
index f189615ea95..d09c96c0f2b 100644
--- a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff
@@ -7,13 +7,14 @@
       let mut _3: &T;
   
       bb0: {
-          _2 = copy _1;
+-         _2 = copy _1;
           _3 = &_1;
           _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind continue];
       }
   
       bb1: {
-          _0 = opaque::<T>(copy _2) -> [return: bb2, unwind continue];
+-         _0 = opaque::<T>(copy _2) -> [return: bb2, unwind continue];
++         _0 = opaque::<T>(copy _1) -> [return: bb2, unwind continue];
       }
   
       bb2: {
diff --git a/tests/mir-opt/copy-prop/borrowed_local.rs b/tests/mir-opt/copy-prop/borrowed_local.rs
index 68cdc57483a..08c46fea5f0 100644
--- a/tests/mir-opt/copy-prop/borrowed_local.rs
+++ b/tests/mir-opt/copy-prop/borrowed_local.rs
@@ -50,11 +50,10 @@ fn compare_address() -> bool {
 fn borrowed<T: Copy + Freeze>(x: T) -> bool {
     // CHECK-LABEL: fn borrowed(
     // CHECK: bb0: {
-    // CHECK-NEXT: _2 = copy _1;
     // CHECK-NEXT: _3 = &_1;
     // CHECK-NEXT: _0 = opaque::<&T>(copy _3)
     // CHECK: bb1: {
-    // CHECK-NEXT: _0 = opaque::<T>(copy _2)
+    // CHECK-NEXT: _0 = opaque::<T>(copy _1)
     mir! {
         {
             let a = x;
diff --git a/tests/mir-opt/copy-prop/write_to_borrowed.main.CopyProp.diff b/tests/mir-opt/copy-prop/write_to_borrowed.main.CopyProp.diff
index baa71501047..eab06b1ba1e 100644
--- a/tests/mir-opt/copy-prop/write_to_borrowed.main.CopyProp.diff
+++ b/tests/mir-opt/copy-prop/write_to_borrowed.main.CopyProp.diff
@@ -16,10 +16,11 @@
           _3 = const 'b';
           _5 = copy _3;
           _6 = &_3;
-          _4 = copy _5;
+-         _4 = copy _5;
           (*_1) = copy (*_6);
           _6 = &_5;
-          _7 = dump_var::<char>(copy _4) -> [return: bb1, unwind unreachable];
+-         _7 = dump_var::<char>(copy _4) -> [return: bb1, unwind unreachable];
++         _7 = dump_var::<char>(copy _5) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/copy-prop/write_to_borrowed.rs b/tests/mir-opt/copy-prop/write_to_borrowed.rs
index 05aa2fba18d..06e617b8bfb 100644
--- a/tests/mir-opt/copy-prop/write_to_borrowed.rs
+++ b/tests/mir-opt/copy-prop/write_to_borrowed.rs
@@ -27,13 +27,12 @@ fn main() {
             _5 = _3;
             // CHECK-NEXT: _6 = &_3;
             _6 = &_3;
-            // CHECK-NEXT: _4 = copy _5;
             _4 = _5;
             // CHECK-NEXT: (*_1) = copy (*_6);
             *_1 = *_6;
             // CHECK-NEXT: _6 = &_5;
             _6 = &_5;
-            // CHECK-NEXT: _7 = dump_var::<char>(copy _4)
+            // CHECK-NEXT: _7 = dump_var::<char>(copy _5)
             Call(_7 = dump_var(_4), ReturnTo(bb1), UnwindUnreachable())
         }
         bb1 = { Return() }
diff --git a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir
index 97036745009..cbdd194afd3 100644
--- a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir
@@ -10,18 +10,18 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
     let mut _8: &&usize;
     let _9: &usize;
     let mut _10: &&usize;
-    let mut _15: bool;
+    let mut _13: bool;
+    let mut _14: &&usize;
+    let _15: &usize;
     let mut _16: &&usize;
-    let _17: &usize;
-    let mut _18: &&usize;
+    let mut _19: bool;
+    let mut _20: &&usize;
+    let _21: &usize;
+    let mut _22: &&usize;
     let mut _23: bool;
     let mut _24: &&usize;
     let _25: &usize;
     let mut _26: &&usize;
-    let mut _29: bool;
-    let mut _30: &&usize;
-    let _31: &usize;
-    let mut _32: &&usize;
     scope 1 {
         debug a => _4;
         debug b => _5;
@@ -30,47 +30,39 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         scope 2 (inlined std::cmp::impls::<impl PartialOrd for &usize>::le) {
             debug self => _8;
             debug other => _10;
-            let mut _11: &usize;
-            let mut _12: &usize;
             scope 3 (inlined std::cmp::impls::<impl PartialOrd for usize>::le) {
-                debug self => _11;
-                debug other => _12;
-                let mut _13: usize;
-                let mut _14: usize;
+                debug self => _4;
+                debug other => _6;
+                let mut _11: usize;
+                let mut _12: usize;
             }
         }
         scope 4 (inlined std::cmp::impls::<impl PartialOrd for &usize>::le) {
-            debug self => _16;
-            debug other => _18;
-            let mut _19: &usize;
-            let mut _20: &usize;
+            debug self => _14;
+            debug other => _16;
             scope 5 (inlined std::cmp::impls::<impl PartialOrd for usize>::le) {
-                debug self => _19;
-                debug other => _20;
-                let mut _21: usize;
-                let mut _22: usize;
+                debug self => _7;
+                debug other => _5;
+                let mut _17: usize;
+                let mut _18: usize;
             }
         }
         scope 6 (inlined std::cmp::impls::<impl PartialOrd for &usize>::le) {
-            debug self => _24;
-            debug other => _26;
-            let mut _27: &usize;
-            let mut _28: &usize;
+            debug self => _20;
+            debug other => _22;
             scope 7 (inlined std::cmp::impls::<impl PartialOrd for usize>::le) {
-                debug self => _27;
-                debug other => _28;
+                debug self => _6;
+                debug other => _4;
             }
         }
         scope 8 (inlined std::cmp::impls::<impl PartialOrd for &usize>::le) {
-            debug self => _30;
-            debug other => _32;
-            let mut _33: &usize;
-            let mut _34: &usize;
+            debug self => _24;
+            debug other => _26;
             scope 9 (inlined std::cmp::impls::<impl PartialOrd for usize>::le) {
-                debug self => _33;
-                debug other => _34;
-                let mut _35: usize;
-                let mut _36: usize;
+                debug self => _5;
+                debug other => _7;
+                let mut _27: usize;
+                let mut _28: usize;
             }
         }
     }
@@ -81,23 +73,17 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         _5 = &((*_3).1: usize);
         _6 = &((*_3).2: usize);
         _7 = &((*_3).3: usize);
-        StorageLive(_15);
+        StorageLive(_13);
         StorageLive(_8);
         _8 = &_4;
         StorageLive(_10);
         StorageLive(_9);
         _9 = copy _6;
         _10 = &_9;
-        StorageLive(_11);
-        StorageLive(_12);
-        _11 = copy _4;
-        _12 = copy _6;
-        _13 = copy ((*_3).0: usize);
-        _14 = copy ((*_3).2: usize);
-        _15 = Le(copy _13, copy _14);
-        StorageDead(_12);
-        StorageDead(_11);
-        switchInt(move _15) -> [0: bb1, otherwise: bb2];
+        _11 = copy ((*_3).0: usize);
+        _12 = copy ((*_3).2: usize);
+        _13 = Le(copy _11, copy _12);
+        switchInt(move _13) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
@@ -111,107 +97,89 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         StorageDead(_9);
         StorageDead(_10);
         StorageDead(_8);
-        StorageLive(_23);
+        StorageLive(_19);
+        StorageLive(_14);
+        _14 = &_7;
         StorageLive(_16);
-        _16 = &_7;
-        StorageLive(_18);
+        StorageLive(_15);
+        _15 = copy _5;
+        _16 = &_15;
         StorageLive(_17);
-        _17 = copy _5;
-        _18 = &_17;
-        StorageLive(_19);
-        StorageLive(_20);
-        _19 = copy _7;
-        _20 = copy _5;
-        StorageLive(_21);
-        _21 = copy ((*_3).3: usize);
-        StorageLive(_22);
-        _22 = copy ((*_3).1: usize);
-        _23 = Le(move _21, move _22);
-        StorageDead(_22);
-        StorageDead(_21);
-        StorageDead(_20);
-        StorageDead(_19);
-        switchInt(move _23) -> [0: bb3, otherwise: bb8];
+        _17 = copy ((*_3).3: usize);
+        StorageLive(_18);
+        _18 = copy ((*_3).1: usize);
+        _19 = Le(move _17, move _18);
+        StorageDead(_18);
+        StorageDead(_17);
+        switchInt(move _19) -> [0: bb3, otherwise: bb8];
     }
 
     bb3: {
-        StorageDead(_17);
-        StorageDead(_18);
+        StorageDead(_15);
         StorageDead(_16);
+        StorageDead(_14);
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_29);
-        StorageLive(_24);
-        _24 = &_6;
-        StorageLive(_26);
-        StorageLive(_25);
-        _25 = copy _4;
-        _26 = &_25;
-        StorageLive(_27);
-        StorageLive(_28);
-        _27 = copy _6;
-        _28 = copy _4;
-        _29 = Le(copy _14, copy _13);
-        StorageDead(_28);
-        StorageDead(_27);
-        switchInt(move _29) -> [0: bb5, otherwise: bb6];
+        StorageLive(_23);
+        StorageLive(_20);
+        _20 = &_6;
+        StorageLive(_22);
+        StorageLive(_21);
+        _21 = copy _4;
+        _22 = &_21;
+        _23 = Le(copy _12, copy _11);
+        switchInt(move _23) -> [0: bb5, otherwise: bb6];
     }
 
     bb5: {
-        StorageDead(_25);
-        StorageDead(_26);
-        StorageDead(_24);
+        StorageDead(_21);
+        StorageDead(_22);
+        StorageDead(_20);
         _0 = const false;
         goto -> bb7;
     }
 
     bb6: {
+        StorageDead(_21);
+        StorageDead(_22);
+        StorageDead(_20);
+        StorageLive(_24);
+        _24 = &_5;
+        StorageLive(_26);
+        StorageLive(_25);
+        _25 = copy _7;
+        _26 = &_25;
+        StorageLive(_27);
+        _27 = copy ((*_3).1: usize);
+        StorageLive(_28);
+        _28 = copy ((*_3).3: usize);
+        _0 = Le(move _27, move _28);
+        StorageDead(_28);
+        StorageDead(_27);
         StorageDead(_25);
         StorageDead(_26);
         StorageDead(_24);
-        StorageLive(_30);
-        _30 = &_5;
-        StorageLive(_32);
-        StorageLive(_31);
-        _31 = copy _7;
-        _32 = &_31;
-        StorageLive(_33);
-        StorageLive(_34);
-        _33 = copy _5;
-        _34 = copy _7;
-        StorageLive(_35);
-        _35 = copy ((*_3).1: usize);
-        StorageLive(_36);
-        _36 = copy ((*_3).3: usize);
-        _0 = Le(move _35, move _36);
-        StorageDead(_36);
-        StorageDead(_35);
-        StorageDead(_34);
-        StorageDead(_33);
-        StorageDead(_31);
-        StorageDead(_32);
-        StorageDead(_30);
         goto -> bb7;
     }
 
     bb7: {
-        StorageDead(_29);
+        StorageDead(_23);
         goto -> bb9;
     }
 
     bb8: {
-        StorageDead(_17);
-        StorageDead(_18);
+        StorageDead(_15);
         StorageDead(_16);
+        StorageDead(_14);
         _0 = const true;
         goto -> bb9;
     }
 
     bb9: {
-        StorageDead(_23);
-        StorageDead(_15);
+        StorageDead(_19);
+        StorageDead(_13);
         return;
     }
 }
-- 
cgit 1.4.1-3-g733a5


From f6d38909b4984a172023a555b7faf3d11b87c9de Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 22:17:22 +0200
Subject: Add documentation about subtree sync

---
 library/compiler-builtins/CONTRIBUTING.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/library/compiler-builtins/CONTRIBUTING.md b/library/compiler-builtins/CONTRIBUTING.md
index 9f67cfc3157..9ae4f893c60 100644
--- a/library/compiler-builtins/CONTRIBUTING.md
+++ b/library/compiler-builtins/CONTRIBUTING.md
@@ -165,3 +165,12 @@ cargo bench --no-default-features \
 
 [`iai-callgrind-runner`]: https://crates.io/crates/iai-callgrind-runner
 [Valgrind]: https://valgrind.org/
+
+## Subtree synchronization
+
+`compiler-builtins` is included as a [Josh subtree] in the main compiler
+repository (`rust-lang/rust`). You can find a guide on how to create synchronization
+(pull and push) PRs at the [`rustc-dev-guide` page].
+
+[Josh subtree]: https://rustc-dev-guide.rust-lang.org/external-repos.html#josh-subtrees
+[`rustc-dev-guide` page]: https://rustc-dev-guide.rust-lang.org/external-repos.html#synchronizing-a-josh-subtree
-- 
cgit 1.4.1-3-g733a5


From f1ae43f14d2b1737b71fc14c20b1242a74d66c2b Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Thu, 10 Jul 2025 09:56:59 +0200
Subject: Mention that compiler-builtins is now using `rustc-josh-sync`

---
 src/doc/rustc-dev-guide/src/external-repos.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/external-repos.md b/src/doc/rustc-dev-guide/src/external-repos.md
index 0f7322357b9..68986a0bc68 100644
--- a/src/doc/rustc-dev-guide/src/external-repos.md
+++ b/src/doc/rustc-dev-guide/src/external-repos.md
@@ -44,7 +44,7 @@ implement a new tool feature or test, that should happen in one collective rustc
     * `miri` ([sync guide](https://github.com/rust-lang/miri/blob/master/CONTRIBUTING.md#advanced-topic-syncing-with-the-rustc-repo))
     * `rust-analyzer` ([sync script](https://github.com/rust-lang/rust-analyzer/blob/2e13684be123eca7181aa48e043e185d8044a84a/xtask/src/release.rs#L147))
     * `rustc-dev-guide` ([josh sync](#synchronizing-a-josh-subtree))
-    * `compiler-builtins`
+    * `compiler-builtins` ([josh sync](#synchronizing-a-josh-subtree))
     * `stdarch` ([josh sync](#synchronizing-a-josh-subtree))
 
 ### Josh subtrees
@@ -56,6 +56,7 @@ The [josh] tool is an alternative to git subtrees, which manages git history in
 We use a dedicated tool called [`rustc-josh-sync`][josh-sync] for performing Josh subtree updates.
 Currently, we are migrating Josh repositories to it. So far, it is used in:
 
+- compiler-builtins
 - rustc-dev-guide
 - stdarch
 
-- 
cgit 1.4.1-3-g733a5


From c6bedc1bf9752c482e7a2fd58e24c7569fb58555 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Thu, 10 Jul 2025 10:02:39 +0200
Subject: Migrate rustc-pull to CI workflow from `josh-sync`

---
 .../.github/workflows/rustc-pull.yml               | 111 ++-------------------
 1 file changed, 9 insertions(+), 102 deletions(-)

diff --git a/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml b/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
index 7190fc733db..ad570ee4595 100644
--- a/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
+++ b/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
@@ -9,105 +9,12 @@ on:
 jobs:
   pull:
     if: github.repository == 'rust-lang/rustc-dev-guide'
-    runs-on: ubuntu-latest
-    outputs:
-      pr_url: ${{ steps.update-pr.outputs.pr_url }}
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          # We need the full history for josh to work
-          fetch-depth: '0'
-      - name: Install stable Rust toolchain
-        run: rustup update stable
-      - uses: Swatinem/rust-cache@v2
-        with:
-          # Cache the josh directory with checked out rustc
-          cache-directories: "/home/runner/.cache/rustc-josh"
-      - name: Install rustc-josh-sync
-        run: cargo install --locked --git https://github.com/rust-lang/josh-sync
-      - name: Setup bot git name and email
-        run: |
-          git config --global user.name 'The rustc-dev-guide Cronjob Bot'
-          git config --global user.email 'github-actions@github.com'
-      - name: Perform rustc-pull
-        id: rustc-pull
-        # Turn off -e to disable early exit
-        shell: bash {0}
-        run: |
-          rustc-josh-sync pull
-          exitcode=$?
-
-          # If no pull was performed, we want to mark this job as successful,
-          # but we do not want to perform the follow-up steps.
-          if [ $exitcode -eq 0 ]; then
-            echo "pull_result=pull-finished" >> $GITHUB_OUTPUT
-          elif [ $exitcode -eq 2 ]; then
-            echo "pull_result=skipped" >> $GITHUB_OUTPUT
-            exitcode=0
-          fi
-
-          exit ${exitcode}
-      - name: Push changes to a branch
-        if: ${{ steps.rustc-pull.outputs.pull_result == 'pull-finished' }}
-        run: |
-          # Update a sticky branch that is used only for rustc pulls
-          BRANCH="rustc-pull"
-          git switch -c $BRANCH
-          git push -u origin $BRANCH --force
-      - name: Create pull request
-        id: update-pr
-        if: ${{ steps.rustc-pull.outputs.pull_result == 'pull-finished' }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          # Check if an open pull request for an rustc pull update already exists
-          # If it does, the previous push has just updated it
-          # If not, we create it now
-          RESULT=`gh pr list --author github-actions[bot] --state open -q 'map(select(.title=="Rustc pull update")) | length' --json title`
-          if [[ "$RESULT" -eq 0 ]]; then
-            echo "Creating new pull request"
-            PR_URL=`gh pr create -B master --title 'Rustc pull update' --body 'Latest update from rustc.'`
-            echo "pr_url=$PR_URL" >> $GITHUB_OUTPUT
-          else
-            PR_URL=`gh pr list --author github-actions[bot] --state open -q 'map(select(.title=="Rustc pull update")) | .[0].url' --json url,title`
-            echo "Updating pull request ${PR_URL}"
-            echo "pr_url=$PR_URL" >> $GITHUB_OUTPUT
-          fi
-  send-zulip-message:
-    needs: [pull]
-    if: ${{ !cancelled() }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Compute message
-        id: create-message
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          if [ "${{ needs.pull.result }}" == "failure" ]; then
-            WORKFLOW_URL="${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
-            echo "message=Rustc pull sync failed. Check out the [workflow URL]($WORKFLOW_URL)." >> $GITHUB_OUTPUT
-          else
-            CREATED_AT=`gh pr list --author github-actions[bot] --state open -q 'map(select(.title=="Rustc pull update")) | .[0].createdAt' --json createdAt,title`
-            PR_URL=`gh pr list --author github-actions[bot] --state open -q 'map(select(.title=="Rustc pull update")) | .[0].url' --json url,title`
-            week_ago=$(date +%F -d '7 days ago')
-
-            # If there is an open PR that is at least a week old, post a message about it
-            if [[ -n $DATE_GH && $DATE_GH < $week_ago ]]; then
-              echo "message=A PR with a Rustc pull has been opened for more a week. Check out the [PR](${PR_URL})." >> $GITHUB_OUTPUT
-            fi
-          fi
-      - name: Send a Zulip message about updated PR
-        if: ${{ steps.create-message.outputs.message != '' }}
-        uses: zulip/github-actions-zulip/send-message@e4c8f27c732ba9bd98ac6be0583096dea82feea5
-        with:
-          api-key: ${{ secrets.ZULIP_API_TOKEN }}
-          email: "rustc-dev-guide-gha-notif-bot@rust-lang.zulipchat.com"
-          organization-url: "https://rust-lang.zulipchat.com"
-          to: 196385
-          type: "stream"
-          topic: "Subtree sync automation"
-          content: ${{ steps.create-message.outputs.message }}
+    uses: rust-lang/josh-sync/.github/workflows/rustc-pull.yml@main
+    with:
+      zulip-stream-id: 196385
+      zulip-bot-email:  "rustc-dev-guide-gha-notif-bot@rust-lang.zulipchat.com"
+      pr-base-branch: master
+      branch-name: rustc-pull
+    secrets:
+      zulip-api-token: ${{ secrets.ZULIP_API_TOKEN }}
+      token: ${{ secrets.GITHUB_TOKEN }}
-- 
cgit 1.4.1-3-g733a5


From b6920519e32fee78a19e281ce3a3f84744c6527a Mon Sep 17 00:00:00 2001
From: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
Date: Thu, 10 Jul 2025 18:11:32 +0900
Subject: Migrate `generate_impl` assist to use `SyntaxEditor`

---
 .../ide-assists/src/handlers/generate_impl.rs      | 25 ++++++++++++++--------
 1 file changed, 16 insertions(+), 9 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 2862e6d5afb..14601ca0207 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,14 +1,14 @@
 use syntax::{
     ast::{self, AstNode, HasName, edit_in_place::Indent, make},
-    ted,
+    syntax_editor::{Position, SyntaxEditor},
 };
 
 use crate::{AssistContext, AssistId, Assists, utils};
 
-fn insert_impl(impl_: ast::Impl, nominal: &ast::Adt) {
+fn insert_impl(editor: &mut SyntaxEditor, impl_: &ast::Impl, nominal: &ast::Adt) {
     let indent = nominal.indent_level();
-    ted::insert_all_raw(
-        ted::Position::after(nominal.syntax()),
+    editor.insert_all(
+        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(),
@@ -51,14 +51,17 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext<'_>) -> Optio
             // Generate the impl
             let impl_ = utils::generate_impl(&nominal);
 
+            let mut editor = edit.make_editor(nominal.syntax());
             // Add a tabstop after the left curly brace
             if let Some(cap) = ctx.config.snippet_cap {
                 if let Some(l_curly) = impl_.assoc_item_list().and_then(|it| it.l_curly_token()) {
-                    edit.add_tabstop_after_token(cap, l_curly);
+                    let tabstop = edit.make_tabstop_after(cap);
+                    editor.add_annotation(l_curly, tabstop);
                 }
             }
 
-            insert_impl(impl_, &edit.make_mut(nominal));
+            insert_impl(&mut editor, &impl_, &nominal);
+            edit.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
 }
@@ -97,18 +100,22 @@ pub(crate) fn generate_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>) ->
             // Generate the impl
             let impl_ = utils::generate_trait_impl_intransitive(&nominal, make::ty_placeholder());
 
+            let mut editor = edit.make_editor(nominal.syntax());
             // Make the trait type a placeholder snippet
             if let Some(cap) = ctx.config.snippet_cap {
                 if let Some(trait_) = impl_.trait_() {
-                    edit.add_placeholder_snippet(cap, trait_);
+                    let placeholder = edit.make_placeholder_snippet(cap);
+                    editor.add_annotation(trait_.syntax(), placeholder);
                 }
 
                 if let Some(l_curly) = impl_.assoc_item_list().and_then(|it| it.l_curly_token()) {
-                    edit.add_tabstop_after_token(cap, l_curly);
+                    let tabstop = edit.make_tabstop_after(cap);
+                    editor.add_annotation(l_curly, tabstop);
                 }
             }
 
-            insert_impl(impl_, &edit.make_mut(nominal));
+            insert_impl(&mut editor, &impl_, &nominal);
+            edit.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
 }
-- 
cgit 1.4.1-3-g733a5


From 086b13d170b9207cc7d726048517a8cd5acc096d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 7 Jul 2025 17:28:19 +0200
Subject: Add regression test for #143107

---
 tests/rustdoc/reexport/merge-glob-and-non-glob.rs | 41 +++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 tests/rustdoc/reexport/merge-glob-and-non-glob.rs

diff --git a/tests/rustdoc/reexport/merge-glob-and-non-glob.rs b/tests/rustdoc/reexport/merge-glob-and-non-glob.rs
new file mode 100644
index 00000000000..ff67859cb39
--- /dev/null
+++ b/tests/rustdoc/reexport/merge-glob-and-non-glob.rs
@@ -0,0 +1,41 @@
+// This test ensures that if an item is inlined from two different `use`,
+// then it will use attributes from both of them.
+// This is a regression test for <https://github.com/rust-lang/rust/issues/143107>.
+
+#![feature(no_core)]
+#![no_core]
+#![no_std]
+#![crate_name = "foo"]
+
+// First we ensure we only have two items.
+//@ has 'foo/index.html'
+//@ count - '//dl[@class="item-table"]/dt' 2
+// We should also only have one section (Structs).
+//@ count - '//h2[@class="section-header"]' 1
+// We now check the short docs.
+//@ has - '//dl[@class="item-table"]/dd' 'Foobar Blob'
+//@ has - '//dl[@class="item-table"]/dd' 'Tarte Tatin'
+
+//@ has 'foo/struct.Foo.html'
+//@ has - '//*[@class="docblock"]' 'Foobar Blob'
+
+//@ has 'foo/struct.Another.html'
+//@ has - '//*[@class="docblock"]' 'Tarte Tatin'
+
+mod raw {
+    /// Blob
+    pub struct Foo;
+
+    /// Tatin
+    pub struct Another;
+}
+
+/// Foobar
+pub use raw::Foo;
+
+// Glob reexport attributes are ignored.
+/// Baz
+pub use raw::*;
+
+/// Tarte
+pub use raw::Another as Another;
-- 
cgit 1.4.1-3-g733a5


From 205587b37e8598b2123a803de2df076ef501706d Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Thu, 10 Jul 2025 10:10:55 +0200
Subject: Rename `for_compiler` to `for_use_by_compiler`

---
 src/bootstrap/src/core/build_steps/compile.rs | 17 ++++++++++-------
 src/bootstrap/src/core/build_steps/dist.rs    |  4 ++--
 src/bootstrap/src/core/build_steps/tool.rs    |  6 +++---
 3 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 6d9160236e3..d1285340cd6 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -2056,7 +2056,7 @@ impl Step for Assemble {
             if builder.config.llvm_bitcode_linker_enabled {
                 trace!("llvm-bitcode-linker enabled, installing");
                 let llvm_bitcode_linker = builder.ensure(
-                    crate::core::build_steps::tool::LlvmBitcodeLinker::for_compiler(
+                    crate::core::build_steps::tool::LlvmBitcodeLinker::for_use_by_compiler(
                         builder,
                         target_compiler,
                     ),
@@ -2259,9 +2259,11 @@ impl Step for Assemble {
         copy_codegen_backends_to_sysroot(builder, build_compiler, target_compiler);
 
         if builder.config.lld_enabled {
-            let lld_wrapper = builder.ensure(
-                crate::core::build_steps::tool::LldWrapper::for_compiler(builder, target_compiler),
-            );
+            let lld_wrapper =
+                builder.ensure(crate::core::build_steps::tool::LldWrapper::for_use_by_compiler(
+                    builder,
+                    target_compiler,
+                ));
             copy_lld_artifacts(builder, lld_wrapper, target_compiler);
         }
 
@@ -2289,11 +2291,12 @@ impl Step for Assemble {
         // In addition to `rust-lld` also install `wasm-component-ld` when
         // is enabled. This is used by the `wasm32-wasip2` target of Rust.
         if builder.tool_enabled("wasm-component-ld") {
-            let wasm_component =
-                builder.ensure(crate::core::build_steps::tool::WasmComponentLd::for_compiler(
+            let wasm_component = builder.ensure(
+                crate::core::build_steps::tool::WasmComponentLd::for_use_by_compiler(
                     builder,
                     target_compiler,
-                ));
+                ),
+            );
             builder.copy_link(
                 &wasm_component.tool_path,
                 &libdir_bin.join(wasm_component.tool_path.file_name().unwrap()),
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index 7d8825effc8..af17a69302b 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -2370,8 +2370,8 @@ impl Step for LlvmBitcodeLinker {
     fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
         let target = self.target;
 
-        let llbc_linker =
-            builder.ensure(tool::LlvmBitcodeLinker::for_compiler(builder, self.target_compiler));
+        let llbc_linker = builder
+            .ensure(tool::LlvmBitcodeLinker::for_use_by_compiler(builder, self.target_compiler));
 
         let self_contained_bin_dir = format!("lib/rustlib/{}/bin/self-contained", target.triple);
 
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index aa71574eef8..daa47db76b0 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -897,7 +897,7 @@ pub struct LldWrapper {
 
 impl LldWrapper {
     /// Returns `LldWrapper` that should be **used** by the passed compiler.
-    pub fn for_compiler(builder: &Builder<'_>, target_compiler: Compiler) -> Self {
+    pub fn for_use_by_compiler(builder: &Builder<'_>, target_compiler: Compiler) -> Self {
         Self {
             build_compiler: get_tool_target_compiler(
                 builder,
@@ -998,7 +998,7 @@ pub struct WasmComponentLd {
 
 impl WasmComponentLd {
     /// Returns `WasmComponentLd` that should be **used** by the passed compiler.
-    pub fn for_compiler(builder: &Builder<'_>, target_compiler: Compiler) -> Self {
+    pub fn for_use_by_compiler(builder: &Builder<'_>, target_compiler: Compiler) -> Self {
         Self {
             build_compiler: get_tool_target_compiler(
                 builder,
@@ -1165,7 +1165,7 @@ pub struct LlvmBitcodeLinker {
 
 impl LlvmBitcodeLinker {
     /// Returns `LlvmBitcodeLinker` that should be **used** by the passed compiler.
-    pub fn for_compiler(builder: &Builder<'_>, target_compiler: Compiler) -> Self {
+    pub fn for_use_by_compiler(builder: &Builder<'_>, target_compiler: Compiler) -> Self {
         Self {
             build_compiler: get_tool_target_compiler(
                 builder,
-- 
cgit 1.4.1-3-g733a5


From 85c286aaa839d61c25398cce5aa3b1889e5861c4 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Thu, 10 Jul 2025 10:12:55 +0200
Subject: Clarify `get_tool_target_compiler`

---
 src/bootstrap/src/core/build_steps/tool.rs | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index daa47db76b0..caaaaad845d 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -381,20 +381,26 @@ pub(crate) fn get_tool_target_compiler(
     builder: &Builder<'_>,
     mode: ToolTargetBuildMode,
 ) -> Compiler {
-    let (target, min_build_compiler_stage) = match mode {
+    let (target, build_compiler_stage) = match mode {
         ToolTargetBuildMode::Build(target) => {
             assert!(builder.top_stage > 0);
+            // If we want to build a stage N tool, we need to compile it with stage N-1 rustc
             (target, builder.top_stage - 1)
         }
         ToolTargetBuildMode::Dist(target_compiler) => {
             assert!(target_compiler.stage > 0);
+            // If we want to dist a stage N rustc, we want to attach stage N tool to it.
+            // And to build that tool, we need to compile it with stage N-1 rustc
             (target_compiler.host, target_compiler.stage - 1)
         }
     };
+
     let compiler = if builder.host_target == target {
-        builder.compiler(min_build_compiler_stage, builder.host_target)
+        builder.compiler(build_compiler_stage, builder.host_target)
     } else {
-        builder.compiler(min_build_compiler_stage.max(1), builder.host_target)
+        // If we are cross-compiling a stage 1 tool, we cannot do that with a stage 0 compiler,
+        // so we auto-bump the tool's stage to 2.
+        builder.compiler(build_compiler_stage.max(1), builder.host_target)
     };
     builder.std(compiler, target);
     compiler
-- 
cgit 1.4.1-3-g733a5


From 81a6f189408b71b452a9804818f2cd50d2ed9108 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Wed, 9 Jul 2025 15:24:28 +0500
Subject: added error for invalid char cast

---
 compiler/rustc_lint/messages.ftl         |   7 ++
 compiler/rustc_lint/src/lints.rs         |  14 ++++
 compiler/rustc_lint/src/types/literal.rs |  42 ++++++++---
 tests/ui/cast/cast-char.rs               |  56 +++++++++++++-
 tests/ui/cast/cast-char.stderr           | 124 +++++++++++++++++++++++++++++--
 5 files changed, 222 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 8d9f2385b71..5d07afdaf17 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -440,6 +440,7 @@ lint_invalid_asm_label_named = avoid using named labels in inline assembly
     .help = only local labels of the form `<number>:` should be used in inline asm
     .note = see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 lint_invalid_asm_label_no_span = the label may be declared in the expansion of a macro
+
 lint_invalid_crate_type_value = invalid `crate_type` value
     .suggestion = did you mean
 
@@ -790,6 +791,9 @@ lint_supertrait_as_deref_target = this `Deref` implementation is covered by an i
     .label2 = target type is a supertrait of `{$self_ty}`
     .help = consider removing this implementation or replacing it with a method instead
 
+lint_surrogate_char_cast = surrogate values are not valid for `char`
+    .note = `0xD800..=0xDFFF` are reserved for Unicode surrogates and are not valid `char` values
+
 lint_suspicious_double_ref_clone =
     using `.clone()` on a double reference, which returns `{$ty}` instead of cloning the inner type
 
@@ -799,6 +803,9 @@ lint_suspicious_double_ref_deref =
 lint_symbol_intern_string_literal = using `Symbol::intern` on a string literal
     .help = consider adding the symbol to `compiler/rustc_span/src/symbol.rs`
 
+lint_too_large_char_cast = value exceeds maximum `char` value
+    .note = maximum valid `char` value is `0x10FFFF`
+
 lint_trailing_semi_macro = trailing semicolon in macro used in expression position
     .note1 = macro invocations at the end of a block are treated as expressions
     .note2 = to ignore the value produced by the macro, add a semicolon after the invocation of `{$name}`
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 21148833eaf..19989cbcce6 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -1746,6 +1746,20 @@ pub(crate) struct OverflowingLiteral<'a> {
     pub lit: String,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(lint_surrogate_char_cast)]
+#[note]
+pub(crate) struct SurrogateCharCast {
+    pub literal: u128,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_too_large_char_cast)]
+#[note]
+pub(crate) struct TooLargeCharCast {
+    pub literal: u128,
+}
+
 #[derive(LintDiagnostic)]
 #[diag(lint_uses_power_alignment)]
 pub(crate) struct UsesPowerAlignment;
diff --git a/compiler/rustc_lint/src/types/literal.rs b/compiler/rustc_lint/src/types/literal.rs
index d44f45177bd..2bac58ba23d 100644
--- a/compiler/rustc_lint/src/types/literal.rs
+++ b/compiler/rustc_lint/src/types/literal.rs
@@ -12,7 +12,7 @@ use crate::context::LintContext;
 use crate::lints::{
     OnlyCastu8ToChar, OverflowingBinHex, OverflowingBinHexSign, OverflowingBinHexSignBitSub,
     OverflowingBinHexSub, OverflowingInt, OverflowingIntHelp, OverflowingLiteral, OverflowingUInt,
-    RangeEndpointOutOfRange, UseInclusiveRange,
+    RangeEndpointOutOfRange, SurrogateCharCast, TooLargeCharCast, UseInclusiveRange,
 };
 use crate::types::{OVERFLOWING_LITERALS, TypeLimits};
 
@@ -38,12 +38,18 @@ fn lint_overflowing_range_endpoint<'tcx>(
 
     // We only want to handle exclusive (`..`) ranges,
     // which are represented as `ExprKind::Struct`.
-    let Node::ExprField(field) = cx.tcx.parent_hir_node(hir_id) else { return false };
-    let Node::Expr(struct_expr) = cx.tcx.parent_hir_node(field.hir_id) else { return false };
+    let Node::ExprField(field) = cx.tcx.parent_hir_node(hir_id) else {
+        return false;
+    };
+    let Node::Expr(struct_expr) = cx.tcx.parent_hir_node(field.hir_id) else {
+        return false;
+    };
     if !is_range_literal(struct_expr) {
         return false;
     };
-    let ExprKind::Struct(_, [start, end], _) = &struct_expr.kind else { return false };
+    let ExprKind::Struct(_, [start, end], _) = &struct_expr.kind else {
+        return false;
+    };
 
     // We can suggest using an inclusive range
     // (`..=`) instead only if it is the `end` that is
@@ -61,7 +67,9 @@ fn lint_overflowing_range_endpoint<'tcx>(
     };
 
     let sub_sugg = if span.lo() == lit_span.lo() {
-        let Ok(start) = cx.sess().source_map().span_to_snippet(start.span) else { return false };
+        let Ok(start) = cx.sess().source_map().span_to_snippet(start.span) else {
+            return false;
+        };
         UseInclusiveRange::WithoutParen {
             sugg: struct_expr.span.shrink_to_lo().to(lit_span.shrink_to_hi()),
             start,
@@ -316,11 +324,25 @@ fn lint_uint_literal<'tcx>(
             match par_e.kind {
                 hir::ExprKind::Cast(..) => {
                     if let ty::Char = cx.typeck_results().expr_ty(par_e).kind() {
-                        cx.emit_span_lint(
-                            OVERFLOWING_LITERALS,
-                            par_e.span,
-                            OnlyCastu8ToChar { span: par_e.span, literal: lit_val },
-                        );
+                        if lit_val > 0x10FFFF {
+                            cx.emit_span_lint(
+                                OVERFLOWING_LITERALS,
+                                par_e.span,
+                                TooLargeCharCast { literal: lit_val },
+                            );
+                        } else if (0xD800..=0xDFFF).contains(&lit_val) {
+                            cx.emit_span_lint(
+                                OVERFLOWING_LITERALS,
+                                par_e.span,
+                                SurrogateCharCast { literal: lit_val },
+                            );
+                        } else {
+                            cx.emit_span_lint(
+                                OVERFLOWING_LITERALS,
+                                par_e.span,
+                                OnlyCastu8ToChar { span: par_e.span, literal: lit_val },
+                            );
+                        }
                         return;
                     }
                 }
diff --git a/tests/ui/cast/cast-char.rs b/tests/ui/cast/cast-char.rs
index 9634ed56f7b..5bf05072253 100644
--- a/tests/ui/cast/cast-char.rs
+++ b/tests/ui/cast/cast-char.rs
@@ -1,10 +1,58 @@
 #![deny(overflowing_literals)]
 
 fn main() {
-    const XYZ: char = 0x1F888 as char;
+    // Valid cases - should suggest char literal
+
+    // u8 range (0-255)
+    const VALID_U8_1: char = 0x41 as char; // 'A'
+    const VALID_U8_2: char = 0xFF as char; // maximum u8
+    const VALID_U8_3: char = 0x00 as char; // minimum u8
+
+    // Valid Unicode in lower range [0x0, 0xD7FF]
+    const VALID_LOW_1: char = 0x1000 as char; // 4096
+    //~^ ERROR: only `u8` can be cast into `char`
+    const VALID_LOW_2: char = 0xD7FF as char; // last valid in lower range
+    //~^ ERROR: only `u8` can be cast into `char`
+    const VALID_LOW_3: char = 0x0500 as char; // cyrillic range
+    //~^ ERROR: only `u8` can be cast into `char`
+
+    // Valid Unicode in upper range [0xE000, 0x10FFFF]
+    const VALID_HIGH_1: char = 0xE000 as char; // first valid in upper range
+    //~^ ERROR only `u8` can be cast into `char`
+    const VALID_HIGH_2: char = 0x1F888 as char; // 129160 - example from issue
+    //~^ ERROR only `u8` can be cast into `char`
+    const VALID_HIGH_3: char = 0x10FFFF as char; // maximum valid Unicode
+    //~^ ERROR only `u8` can be cast into `char`
+    const VALID_HIGH_4: char = 0xFFFD as char; // replacement character
+    //~^ ERROR only `u8` can be cast into `char`
+    const VALID_HIGH_5: char = 0x1F600 as char; // emoji
+    //~^ ERROR only `u8` can be cast into `char`
+
+    // Invalid cases - should show InvalidCharCast
+
+    // Surrogate range [0xD800, 0xDFFF] - reserved for UTF-16
+    const INVALID_SURROGATE_1: char = 0xD800 as char; // first surrogate
+    //~^ ERROR: surrogate values are not valid
+    const INVALID_SURROGATE_2: char = 0xDFFF as char; // last surrogate
+    //~^ ERROR: surrogate values are not valid
+    const INVALID_SURROGATE_3: char = 0xDB00 as char; // middle of surrogate range
+    //~^ ERROR: surrogate values are not valid
+
+    // Too large values (> 0x10FFFF)
+    const INVALID_TOO_BIG_1: char = 0x110000 as char; // one more than maximum
+    //~^ ERROR: value exceeds maximum `char` value
+    const INVALID_TOO_BIG_2: char = 0xEF8888 as char; // example from issue
+    //~^ ERROR: value exceeds maximum `char` value
+    const INVALID_TOO_BIG_3: char = 0x1FFFFF as char; // much larger
+    //~^ ERROR: value exceeds maximum `char` value
+    const INVALID_TOO_BIG_4: char = 0xFFFFFF as char; // 24-bit maximum
+    //~^ ERROR: value exceeds maximum `char` value
+
+    // Boundary cases
+    const BOUNDARY_1: char = 0xD7FE as char; // valid, before surrogate
+    //~^ ERROR only `u8` can be cast into `char`
+    const BOUNDARY_2: char = 0xE001 as char; // valid, after surrogate
     //~^ ERROR only `u8` can be cast into `char`
-    const XY: char = 129160 as char;
+    const BOUNDARY_3: char = 0x10FFFE as char; // valid, near maximum
     //~^ ERROR only `u8` can be cast into `char`
-    const ZYX: char = '\u{01F888}';
-    println!("{}", XYZ);
 }
diff --git a/tests/ui/cast/cast-char.stderr b/tests/ui/cast/cast-char.stderr
index 211937c9d6f..a8d0b3b04b0 100644
--- a/tests/ui/cast/cast-char.stderr
+++ b/tests/ui/cast/cast-char.stderr
@@ -1,8 +1,8 @@
 error: only `u8` can be cast into `char`
-  --> $DIR/cast-char.rs:4:23
+  --> $DIR/cast-char.rs:12:31
    |
-LL |     const XYZ: char = 0x1F888 as char;
-   |                       ^^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{1F888}'`
+LL |     const VALID_LOW_1: char = 0x1000 as char; // 4096
+   |                               ^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{1000}'`
    |
 note: the lint level is defined here
   --> $DIR/cast-char.rs:1:9
@@ -11,10 +11,120 @@ LL | #![deny(overflowing_literals)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: only `u8` can be cast into `char`
-  --> $DIR/cast-char.rs:6:22
+  --> $DIR/cast-char.rs:14:31
    |
-LL |     const XY: char = 129160 as char;
-   |                      ^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{1F888}'`
+LL |     const VALID_LOW_2: char = 0xD7FF as char; // last valid in lower range
+   |                               ^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{D7FF}'`
 
-error: aborting due to 2 previous errors
+error: only `u8` can be cast into `char`
+  --> $DIR/cast-char.rs:16:31
+   |
+LL |     const VALID_LOW_3: char = 0x0500 as char; // cyrillic range
+   |                               ^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{500}'`
+
+error: only `u8` can be cast into `char`
+  --> $DIR/cast-char.rs:20:32
+   |
+LL |     const VALID_HIGH_1: char = 0xE000 as char; // first valid in upper range
+   |                                ^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{E000}'`
+
+error: only `u8` can be cast into `char`
+  --> $DIR/cast-char.rs:22:32
+   |
+LL |     const VALID_HIGH_2: char = 0x1F888 as char; // 129160 - example from issue
+   |                                ^^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{1F888}'`
+
+error: only `u8` can be cast into `char`
+  --> $DIR/cast-char.rs:24:32
+   |
+LL |     const VALID_HIGH_3: char = 0x10FFFF as char; // maximum valid Unicode
+   |                                ^^^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{10FFFF}'`
+
+error: only `u8` can be cast into `char`
+  --> $DIR/cast-char.rs:26:32
+   |
+LL |     const VALID_HIGH_4: char = 0xFFFD as char; // replacement character
+   |                                ^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{FFFD}'`
+
+error: only `u8` can be cast into `char`
+  --> $DIR/cast-char.rs:28:32
+   |
+LL |     const VALID_HIGH_5: char = 0x1F600 as char; // emoji
+   |                                ^^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{1F600}'`
+
+error: surrogate values are not valid for `char`
+  --> $DIR/cast-char.rs:34:39
+   |
+LL |     const INVALID_SURROGATE_1: char = 0xD800 as char; // first surrogate
+   |                                       ^^^^^^^^^^^^^^
+   |
+   = note: `0xD800..=0xDFFF` are reserved for Unicode surrogates and are not valid `char` values
+
+error: surrogate values are not valid for `char`
+  --> $DIR/cast-char.rs:36:39
+   |
+LL |     const INVALID_SURROGATE_2: char = 0xDFFF as char; // last surrogate
+   |                                       ^^^^^^^^^^^^^^
+   |
+   = note: `0xD800..=0xDFFF` are reserved for Unicode surrogates and are not valid `char` values
+
+error: surrogate values are not valid for `char`
+  --> $DIR/cast-char.rs:38:39
+   |
+LL |     const INVALID_SURROGATE_3: char = 0xDB00 as char; // middle of surrogate range
+   |                                       ^^^^^^^^^^^^^^
+   |
+   = note: `0xD800..=0xDFFF` are reserved for Unicode surrogates and are not valid `char` values
+
+error: value exceeds maximum `char` value
+  --> $DIR/cast-char.rs:42:37
+   |
+LL |     const INVALID_TOO_BIG_1: char = 0x110000 as char; // one more than maximum
+   |                                     ^^^^^^^^^^^^^^^^
+   |
+   = note: maximum valid `char` value is `0x10FFFF`
+
+error: value exceeds maximum `char` value
+  --> $DIR/cast-char.rs:44:37
+   |
+LL |     const INVALID_TOO_BIG_2: char = 0xEF8888 as char; // example from issue
+   |                                     ^^^^^^^^^^^^^^^^
+   |
+   = note: maximum valid `char` value is `0x10FFFF`
+
+error: value exceeds maximum `char` value
+  --> $DIR/cast-char.rs:46:37
+   |
+LL |     const INVALID_TOO_BIG_3: char = 0x1FFFFF as char; // much larger
+   |                                     ^^^^^^^^^^^^^^^^
+   |
+   = note: maximum valid `char` value is `0x10FFFF`
+
+error: value exceeds maximum `char` value
+  --> $DIR/cast-char.rs:48:37
+   |
+LL |     const INVALID_TOO_BIG_4: char = 0xFFFFFF as char; // 24-bit maximum
+   |                                     ^^^^^^^^^^^^^^^^
+   |
+   = note: maximum valid `char` value is `0x10FFFF`
+
+error: only `u8` can be cast into `char`
+  --> $DIR/cast-char.rs:52:30
+   |
+LL |     const BOUNDARY_1: char = 0xD7FE as char; // valid, before surrogate
+   |                              ^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{D7FE}'`
+
+error: only `u8` can be cast into `char`
+  --> $DIR/cast-char.rs:54:30
+   |
+LL |     const BOUNDARY_2: char = 0xE001 as char; // valid, after surrogate
+   |                              ^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{E001}'`
+
+error: only `u8` can be cast into `char`
+  --> $DIR/cast-char.rs:56:30
+   |
+LL |     const BOUNDARY_3: char = 0x10FFFE as char; // valid, near maximum
+   |                              ^^^^^^^^^^^^^^^^ help: use a `char` literal instead: `'\u{10FFFE}'`
+
+error: aborting due to 18 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f5c73a14ff113f5923f7c3bb9cc6f6eec5c5ac50 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Thu, 10 Jul 2025 18:16:30 +0530
Subject: change cachekey to CommandFingerprint and change related API's and
 add start time to deferred execution

---
 src/bootstrap/src/utils/exec.rs | 53 ++++++++++++++++++++++++++---------------
 1 file changed, 34 insertions(+), 19 deletions(-)

diff --git a/src/bootstrap/src/utils/exec.rs b/src/bootstrap/src/utils/exec.rs
index 487077835ac..bdb369e41fa 100644
--- a/src/bootstrap/src/utils/exec.rs
+++ b/src/bootstrap/src/utils/exec.rs
@@ -65,7 +65,7 @@ impl OutputMode {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Default)]
-pub struct CommandCacheKey {
+pub struct CommandFingerprint {
     program: OsString,
     args: Vec<OsString>,
     envs: Vec<(OsString, Option<OsString>)>,
@@ -244,12 +244,9 @@ impl<'a> BootstrapCommand {
         }
     }
 
-    pub fn cache_key(&self) -> Option<CommandCacheKey> {
-        if !self.should_cache {
-            return None;
-        }
+    pub fn fingerprint(&self) -> CommandFingerprint {
         let command = &self.command;
-        Some(CommandCacheKey {
+        CommandFingerprint {
             program: command.get_program().into(),
             args: command.get_args().map(OsStr::to_os_string).collect(),
             envs: command
@@ -257,7 +254,7 @@ impl<'a> BootstrapCommand {
                 .map(|(k, v)| (k.to_os_string(), v.map(|val| val.to_os_string())))
                 .collect(),
             cwd: command.get_current_dir().map(Path::to_path_buf),
-        })
+        }
     }
 }
 
@@ -435,7 +432,7 @@ pub struct ExecutionContext {
 
 #[derive(Default)]
 pub struct CommandCache {
-    cache: Mutex<HashMap<CommandCacheKey, CommandOutput>>,
+    cache: Mutex<HashMap<CommandFingerprint, CommandOutput>>,
 }
 
 enum CommandState<'a> {
@@ -446,7 +443,8 @@ enum CommandState<'a> {
         stdout: OutputMode,
         stderr: OutputMode,
         executed_at: &'a Location<'a>,
-        cache_key: Option<CommandCacheKey>,
+        fingerprint: CommandFingerprint,
+        start_time: Instant,
     },
 }
 
@@ -454,6 +452,8 @@ pub struct StreamingCommand {
     child: Child,
     pub stdout: Option<ChildStdout>,
     pub stderr: Option<ChildStderr>,
+    fingerprint: CommandFingerprint,
+    start_time: Instant,
 }
 
 #[must_use]
@@ -462,11 +462,11 @@ pub struct DeferredCommand<'a> {
 }
 
 impl CommandCache {
-    pub fn get(&self, key: &CommandCacheKey) -> Option<CommandOutput> {
+    pub fn get(&self, key: &CommandFingerprint) -> Option<CommandOutput> {
         self.cache.lock().unwrap().get(key).cloned()
     }
 
-    pub fn insert(&self, key: CommandCacheKey, output: CommandOutput) {
+    pub fn insert(&self, key: CommandFingerprint, output: CommandOutput) {
         self.cache.lock().unwrap().insert(key, output);
     }
 }
@@ -539,10 +539,9 @@ impl ExecutionContext {
         stdout: OutputMode,
         stderr: OutputMode,
     ) -> DeferredCommand<'a> {
-        let cache_key = command.cache_key();
+        let fingerprint = command.fingerprint();
 
-        if let Some(cached_output) = cache_key.as_ref().and_then(|key| self.command_cache.get(key))
-        {
+        if let Some(cached_output) = self.command_cache.get(&fingerprint) {
             command.mark_as_executed();
             self.verbose(|| println!("Cache hit: {command:?}"));
             return DeferredCommand { state: CommandState::Cached(cached_output) };
@@ -559,7 +558,8 @@ impl ExecutionContext {
                     stdout,
                     stderr,
                     executed_at,
-                    cache_key,
+                    fingerprint,
+                    start_time: Instant::now(),
                 },
             };
         }
@@ -575,6 +575,8 @@ impl ExecutionContext {
         cmd.stdout(stdout.stdio());
         cmd.stderr(stderr.stdio());
 
+        let start_time = Instant::now();
+
         let child = cmd.spawn();
 
         DeferredCommand {
@@ -584,7 +586,8 @@ impl ExecutionContext {
                 stdout,
                 stderr,
                 executed_at,
-                cache_key,
+                fingerprint,
+                start_time,
             },
         }
     }
@@ -638,6 +641,8 @@ impl ExecutionContext {
         if !command.run_in_dry_run && self.dry_run() {
             return None;
         }
+        let start_time = Instant::now();
+        let fingerprint = command.fingerprint();
         let cmd = &mut command.command;
         cmd.stdout(stdout.stdio());
         cmd.stderr(stderr.stdio());
@@ -669,16 +674,26 @@ impl<'a> DeferredCommand<'a> {
     pub fn wait_for_output(self, exec_ctx: impl AsRef<ExecutionContext>) -> CommandOutput {
         match self.state {
             CommandState::Cached(output) => output,
-            CommandState::Deferred { process, command, stdout, stderr, executed_at, cache_key } => {
+            CommandState::Deferred {
+                process,
+                command,
+                stdout,
+                stderr,
+                executed_at,
+                fingerprint,
+                start_time,
+            } => {
                 let exec_ctx = exec_ctx.as_ref();
 
                 let output =
                     Self::finish_process(process, command, stdout, stderr, executed_at, exec_ctx);
 
                 if (!exec_ctx.dry_run() || command.run_in_dry_run)
-                    && let (Some(cache_key), Some(_)) = (&cache_key, output.status())
+                    && output.status().is_some()
+                    && command.should_cache
                 {
-                    exec_ctx.command_cache.insert(cache_key.clone(), output.clone());
+                    exec_ctx.command_cache.insert(fingerprint.clone(), output.clone());
+                    exec_ctx.profiler.record_execution(fingerprint.clone(), start_time);
                 }
 
                 output
-- 
cgit 1.4.1-3-g733a5


From 5e0c19782888d63cf28fc3cd0ca9960be759071a Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Thu, 10 Jul 2025 18:17:21 +0530
Subject: add commandProfiler to bootstrap execution context

---
 src/bootstrap/src/utils/exec.rs | 155 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 154 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/utils/exec.rs b/src/bootstrap/src/utils/exec.rs
index bdb369e41fa..bffa5abb53b 100644
--- a/src/bootstrap/src/utils/exec.rs
+++ b/src/bootstrap/src/utils/exec.rs
@@ -10,13 +10,17 @@
 use std::collections::HashMap;
 use std::ffi::{OsStr, OsString};
 use std::fmt::{Debug, Formatter};
+use std::fs::File;
 use std::hash::Hash;
+use std::io::{BufWriter, Write};
 use std::panic::Location;
 use std::path::Path;
+use std::process;
 use std::process::{
     Child, ChildStderr, ChildStdout, Command, CommandArgs, CommandEnvs, ExitStatus, Output, Stdio,
 };
 use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
 
 use build_helper::ci::CiEnv;
 use build_helper::drop_bomb::DropBomb;
@@ -72,6 +76,150 @@ pub struct CommandFingerprint {
     cwd: Option<PathBuf>,
 }
 
+impl FormatShortCmd for CommandFingerprint {
+    fn format_short_cmd(&self) -> String {
+        let program = Path::new(&self.program);
+        let mut line = vec![program.file_name().unwrap().to_str().unwrap().to_owned()];
+        line.extend(self.args.iter().map(|arg| arg.to_string_lossy().into_owned()));
+        line.extend(self.cwd.iter().map(|p| p.to_string_lossy().into_owned()));
+        line.join(" ")
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct CommandProfile {
+    pub traces: Vec<ExecutionTrace>,
+}
+
+#[derive(Default)]
+pub struct CommandProfiler {
+    stats: Mutex<HashMap<CommandFingerprint, CommandProfile>>,
+}
+
+impl CommandProfiler {
+    pub fn record_execution(&self, key: CommandFingerprint, start_time: Instant) {
+        let mut stats = self.stats.lock().unwrap();
+        let entry = stats.entry(key).or_default();
+        entry.traces.push(ExecutionTrace::Executed { duration: start_time.elapsed() });
+    }
+
+    pub fn record_cache_hit(&self, key: CommandFingerprint) {
+        let mut stats = self.stats.lock().unwrap();
+        let entry = stats.entry(key).or_default();
+        entry.traces.push(ExecutionTrace::CacheHit);
+    }
+
+    pub fn report_summary(&self, start_time: Instant) {
+        let pid = process::id();
+        let filename = format!("bootstrap-profile-{pid}.txt");
+
+        let file = match File::create(&filename) {
+            Ok(f) => f,
+            Err(e) => {
+                eprintln!("Failed to create profiler output file: {e}");
+                return;
+            }
+        };
+
+        let mut writer = BufWriter::new(file);
+        let stats = self.stats.lock().unwrap();
+
+        let mut entries: Vec<_> = stats
+            .iter()
+            .map(|(key, profile)| {
+                let max_duration = profile
+                    .traces
+                    .iter()
+                    .filter_map(|trace| match trace {
+                        ExecutionTrace::Executed { duration, .. } => Some(*duration),
+                        _ => None,
+                    })
+                    .max();
+
+                (key, profile, max_duration)
+            })
+            .collect();
+
+        entries.sort_by(|a, b| b.2.cmp(&a.2));
+
+        let total_bootstrap_duration = start_time.elapsed();
+
+        let total_fingerprints = entries.len();
+        let mut total_cache_hits = 0;
+        let mut total_execution_duration = Duration::ZERO;
+        let mut total_saved_duration = Duration::ZERO;
+
+        for (key, profile, max_duration) in &entries {
+            writeln!(writer, "Command: {:?}", key.format_short_cmd()).unwrap();
+
+            let mut hits = 0;
+            let mut runs = 0;
+            let mut command_total_duration = Duration::ZERO;
+
+            for trace in &profile.traces {
+                match trace {
+                    ExecutionTrace::CacheHit => {
+                        hits += 1;
+                    }
+                    ExecutionTrace::Executed { duration, .. } => {
+                        runs += 1;
+                        command_total_duration += *duration;
+                    }
+                }
+            }
+
+            total_cache_hits += hits;
+            total_execution_duration += command_total_duration;
+            // This makes sense only in our current setup, where:
+            // - If caching is enabled, we record the timing for the initial execution,
+            //   and all subsequent runs will be cache hits.
+            // - If caching is disabled or unused, there will be no cache hits,
+            //   and we'll record timings for all executions.
+            total_saved_duration += command_total_duration * hits as u32;
+
+            let command_vs_bootstrap = if total_bootstrap_duration > Duration::ZERO {
+                100.0 * command_total_duration.as_secs_f64()
+                    / total_bootstrap_duration.as_secs_f64()
+            } else {
+                0.0
+            };
+
+            let duration_str = match max_duration {
+                Some(d) => format!("{d:.2?}"),
+                None => "-".into(),
+            };
+
+            writeln!(
+                writer,
+                "Summary: {runs} run(s), {hits} hit(s), max_duration={duration_str} total_duration: {command_total_duration:.2?} ({command_vs_bootstrap:.2?}% of total)\n"
+            )
+            .unwrap();
+        }
+
+        let overhead_time = total_bootstrap_duration
+            .checked_sub(total_execution_duration)
+            .unwrap_or(Duration::ZERO);
+
+        writeln!(writer, "\n=== Aggregated Summary ===").unwrap();
+        writeln!(writer, "Total unique commands (fingerprints): {total_fingerprints}").unwrap();
+        writeln!(writer, "Total time spent in command executions: {total_execution_duration:.2?}")
+            .unwrap();
+        writeln!(writer, "Total bootstrap time: {total_bootstrap_duration:.2?}").unwrap();
+        writeln!(writer, "Time spent outside command executions: {overhead_time:.2?}").unwrap();
+        writeln!(writer, "Total cache hits: {total_cache_hits}").unwrap();
+        writeln!(writer, "Estimated time saved due to cache hits: {total_saved_duration:.2?}")
+            .unwrap();
+
+        println!("Command profiler report saved to {filename}");
+    }
+}
+
+#[derive(Clone)]
+pub enum ExecutionTrace {
+    CacheHit,
+    Executed { duration: Duration },
+}
+
 /// Wrapper around `std::process::Command`.
 ///
 /// By default, the command will exit bootstrap if it fails.
@@ -399,7 +547,6 @@ impl Default for CommandOutput {
 
 /// Helper trait to format both Command and BootstrapCommand as a short execution line,
 /// without all the other details (e.g. environment variables).
-#[cfg(feature = "tracing")]
 pub trait FormatShortCmd {
     fn format_short_cmd(&self) -> String;
 }
@@ -428,6 +575,7 @@ pub struct ExecutionContext {
     pub fail_fast: bool,
     delayed_failures: Arc<Mutex<Vec<String>>>,
     command_cache: Arc<CommandCache>,
+    profiler: Arc<CommandProfiler>,
 }
 
 #[derive(Default)]
@@ -483,6 +631,10 @@ impl ExecutionContext {
         }
     }
 
+    pub fn profiler(&self) -> &CommandProfiler {
+        &self.profiler
+    }
+
     pub fn get_dry_run(&self) -> &DryRun {
         &self.dry_run
     }
@@ -544,6 +696,7 @@ impl ExecutionContext {
         if let Some(cached_output) = self.command_cache.get(&fingerprint) {
             command.mark_as_executed();
             self.verbose(|| println!("Cache hit: {command:?}"));
+            self.profiler.record_cache_hit(fingerprint);
             return DeferredCommand { state: CommandState::Cached(cached_output) };
         }
 
-- 
cgit 1.4.1-3-g733a5


From 13c31d445e3ce7b5749dbdb88d18e465f9a7e027 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Thu, 10 Jul 2025 18:18:22 +0530
Subject: update streaming to record its execution via commandprofiler

---
 src/bootstrap/src/core/build_steps/compile.rs |  2 +-
 src/bootstrap/src/utils/exec.rs               | 12 +++++++++---
 src/bootstrap/src/utils/render_tests.rs       |  2 +-
 3 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 0587d21ecc2..05965ecc170 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -2576,7 +2576,7 @@ pub fn stream_cargo(
     }
 
     // Make sure Cargo actually succeeded after we read all of its stdout.
-    let status = t!(streaming_command.wait());
+    let status = t!(streaming_command.wait(&builder.config.exec_ctx));
     if builder.is_verbose() && !status.success() {
         eprintln!(
             "command did not execute successfully: {cmd:?}\n\
diff --git a/src/bootstrap/src/utils/exec.rs b/src/bootstrap/src/utils/exec.rs
index bffa5abb53b..c5bafda88c4 100644
--- a/src/bootstrap/src/utils/exec.rs
+++ b/src/bootstrap/src/utils/exec.rs
@@ -807,7 +807,7 @@ impl ExecutionContext {
 
         let stdout = child.stdout.take();
         let stderr = child.stderr.take();
-        Some(StreamingCommand { child, stdout, stderr })
+        Some(StreamingCommand { child, stdout, stderr, fingerprint, start_time })
     }
 }
 
@@ -818,8 +818,14 @@ impl AsRef<ExecutionContext> for ExecutionContext {
 }
 
 impl StreamingCommand {
-    pub fn wait(mut self) -> Result<ExitStatus, std::io::Error> {
-        self.child.wait()
+    pub fn wait(
+        mut self,
+        exec_ctx: impl AsRef<ExecutionContext>,
+    ) -> Result<ExitStatus, std::io::Error> {
+        let exec_ctx = exec_ctx.as_ref();
+        let output = self.child.wait();
+        exec_ctx.profiler().record_execution(self.fingerprint, self.start_time);
+        output
     }
 }
 
diff --git a/src/bootstrap/src/utils/render_tests.rs b/src/bootstrap/src/utils/render_tests.rs
index 934699d736b..40006aca5c5 100644
--- a/src/bootstrap/src/utils/render_tests.rs
+++ b/src/bootstrap/src/utils/render_tests.rs
@@ -63,7 +63,7 @@ fn run_tests(builder: &Builder<'_>, cmd: &mut BootstrapCommand, stream: bool) ->
         renderer.render_all();
     }
 
-    let status = streaming_command.wait().unwrap();
+    let status = streaming_command.wait(&builder.config.exec_ctx).unwrap();
     if !status.success() && builder.is_verbose() {
         println!(
             "\n\ncommand did not execute successfully: {cmd:?}\n\
-- 
cgit 1.4.1-3-g733a5


From 75b454b3206d6213f4015ecc77b40fd48eadd6cf Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Thu, 10 Jul 2025 18:18:49 +0530
Subject: expose report summary via build

---
 src/bootstrap/src/lib.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index ef5c28272b8..d9a4da8f3cc 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -22,7 +22,7 @@ use std::collections::{BTreeSet, HashMap, HashSet};
 use std::fmt::Display;
 use std::path::{Path, PathBuf};
 use std::sync::OnceLock;
-use std::time::SystemTime;
+use std::time::{Instant, SystemTime};
 use std::{env, fs, io, str};
 
 use build_helper::ci::gha;
@@ -1928,6 +1928,10 @@ to download LLVM rather than building it.
     pub fn exec_ctx(&self) -> &ExecutionContext {
         &self.config.exec_ctx
     }
+
+    pub fn report_summary(&self, start_time: Instant) {
+        self.config.exec_ctx.profiler().report_summary(start_time);
+    }
 }
 
 impl AsRef<ExecutionContext> for Build {
-- 
cgit 1.4.1-3-g733a5


From eac1ed5b74b9835ac9c7b1a91f23f3bf7707e5dd Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Thu, 10 Jul 2025 18:20:17 +0530
Subject: enable report summary when BOOTSTRAP_PROFILE is set

---
 src/bootstrap/src/bin/main.rs | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/bin/main.rs b/src/bootstrap/src/bin/main.rs
index e1862a451f2..181d71f63c2 100644
--- a/src/bootstrap/src/bin/main.rs
+++ b/src/bootstrap/src/bin/main.rs
@@ -8,6 +8,7 @@
 use std::fs::{self, OpenOptions};
 use std::io::{self, BufRead, BufReader, IsTerminal, Write};
 use std::str::FromStr;
+use std::time::Instant;
 use std::{env, process};
 
 use bootstrap::{
@@ -17,11 +18,17 @@ use bootstrap::{
 #[cfg(feature = "tracing")]
 use tracing::instrument;
 
+fn is_bootstrap_profiling_enabled() -> bool {
+    env::var("BOOTSTRAP_PROFILE").is_ok_and(|v| v == "1")
+}
+
 #[cfg_attr(feature = "tracing", instrument(level = "trace", name = "main"))]
 fn main() {
     #[cfg(feature = "tracing")]
     let _guard = setup_tracing();
 
+    let start_time = Instant::now();
+
     let args = env::args().skip(1).collect::<Vec<_>>();
 
     if Flags::try_parse_verbose_help(&args) {
@@ -96,7 +103,8 @@ fn main() {
     let out_dir = config.out.clone();
 
     debug!("creating new build based on config");
-    Build::new(config).build();
+    let mut build = Build::new(config);
+    build.build();
 
     if suggest_setup {
         println!("WARNING: you have not made a `bootstrap.toml`");
@@ -147,6 +155,10 @@ fn main() {
             t!(file.write_all(lines.join("\n").as_bytes()));
         }
     }
+
+    if is_bootstrap_profiling_enabled() {
+        build.report_summary(start_time);
+    }
 }
 
 fn check_version(config: &Config) -> Option<String> {
@@ -226,7 +238,7 @@ fn setup_tracing() -> impl Drop {
     let mut chrome_layer = tracing_chrome::ChromeLayerBuilder::new().include_args(true);
 
     // Writes the Chrome profile to trace-<unix-timestamp>.json if enabled
-    if !env::var("BOOTSTRAP_PROFILE").is_ok_and(|v| v == "1") {
+    if !is_bootstrap_profiling_enabled() {
         chrome_layer = chrome_layer.writer(io::sink());
     }
 
-- 
cgit 1.4.1-3-g733a5


From 7de11749d2a20b54e334c1ef8e2ad19d65406424 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Thu, 10 Jul 2025 18:23:23 +0530
Subject: update rust-dev-guide to point about new command execution summary
 report under bootstrap profiling section

---
 .../src/building/bootstrapping/debugging-bootstrap.md         | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/building/bootstrapping/debugging-bootstrap.md b/src/doc/rustc-dev-guide/src/building/bootstrapping/debugging-bootstrap.md
index ed267850401..c9c0d64a604 100644
--- a/src/doc/rustc-dev-guide/src/building/bootstrapping/debugging-bootstrap.md
+++ b/src/doc/rustc-dev-guide/src/building/bootstrapping/debugging-bootstrap.md
@@ -168,10 +168,17 @@ For `#[instrument]`, it's recommended to:
 
 ### Profiling bootstrap
 
-You can use the `COMMAND` tracing target to trace execution of most commands spawned by bootstrap. If you also use the `BOOTSTRAP_PROFILE=1` environment variable, bootstrap will generate a Chrome JSON trace file, which can be visualized in Chrome's `chrome://tracing` page or on https://ui.perfetto.dev.
+You can set the `BOOTSTRAP_PROFILE=1` environment variable to enable command execution profiling during bootstrap. This generates:
+
+* A Chrome trace file (for visualization in `chrome://tracing` or [Perfetto](https://ui.perfetto.dev)) if tracing is enabled via `BOOTSTRAP_TRACING=COMMAND=trace`
+* A plain-text summary file, `bootstrap-profile-{pid}.txt`, listing all commands sorted by execution time (slowest first), along with cache hits and working directories
+
+Note: the `.txt` report is always generated when `BOOTSTRAP_PROFILE=1` is set — tracing is not required.
+
+Example usage:
 
 ```bash
-$ BOOTSTRAP_TRACING=COMMAND=trace BOOTSTRAP_PROFILE=1 ./x build library
+$ BOOTSTRAP_PROFILE=1 BOOTSTRAP_TRACING=COMMAND=trace ./x build library
 ```
 
 ### rust-analyzer integration?
-- 
cgit 1.4.1-3-g733a5


From 7632c55abb307730a0ec461a9bd43dd05d1c0724 Mon Sep 17 00:00:00 2001
From: b-naber <bn263@gmx.de>
Date: Thu, 10 Jul 2025 14:07:12 +0200
Subject: extract single_import_can_define_name and
 finalize_glob_module_binding

---
 compiler/rustc_resolve/src/ident.rs | 261 ++++++++++++++++++++----------------
 1 file changed, 143 insertions(+), 118 deletions(-)

diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 68fbe48ebcb..558cbef0014 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -13,7 +13,7 @@ use rustc_span::{Ident, Span, kw, sym};
 use tracing::{debug, instrument};
 
 use crate::errors::{ParamKindInEnumDiscriminant, ParamKindInNonTrivialAnonConst};
-use crate::imports::Import;
+use crate::imports::{Import, NameResolution};
 use crate::late::{ConstantHasGenerics, NoConstantGenericsReason, PathSource, Rib, RibKind};
 use crate::macros::{MacroRulesScope, sub_namespace_match};
 use crate::{
@@ -37,7 +37,7 @@ impl From<UsePrelude> for bool {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 enum Shadowing {
     Restricted,
     Unrestricted,
@@ -879,53 +879,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             .into_iter()
             .find_map(|binding| if binding == ignore_binding { None } else { binding });
 
-        if let Some(Finalize { path_span, report_private, used, root_span, .. }) = finalize {
-            let Some(binding) = binding else {
-                return Err((Determined, Weak::No));
-            };
-
-            if !self.is_accessible_from(binding.vis, parent_scope.module) {
-                if report_private {
-                    self.privacy_errors.push(PrivacyError {
-                        ident,
-                        binding,
-                        dedup_span: path_span,
-                        outermost_res: None,
-                        parent_scope: *parent_scope,
-                        single_nested: path_span != root_span,
-                    });
-                } else {
-                    return Err((Determined, Weak::No));
-                }
-            }
-
-            // Forbid expanded shadowing to avoid time travel.
-            if let Some(shadowed_glob) = resolution.shadowed_glob
-                && shadowing == Shadowing::Restricted
-                && binding.expansion != LocalExpnId::ROOT
-                && binding.res() != shadowed_glob.res()
-            {
-                self.ambiguity_errors.push(AmbiguityError {
-                    kind: AmbiguityKind::GlobVsExpanded,
-                    ident,
-                    b1: binding,
-                    b2: shadowed_glob,
-                    warning: false,
-                    misc1: AmbiguityErrorMisc::None,
-                    misc2: AmbiguityErrorMisc::None,
-                });
-            }
-
-            if shadowing == Shadowing::Unrestricted
-                && binding.expansion != LocalExpnId::ROOT
-                && let NameBindingKind::Import { import, .. } = binding.kind
-                && matches!(import.kind, ImportKind::MacroExport)
-            {
-                self.macro_expanded_macro_export_errors.insert((path_span, binding.span));
-            }
-
-            self.record_use(ident, binding, used);
-            return Ok(binding);
+        if let Some(finalize) = finalize {
+            return self.finalize_module_binding(
+                ident,
+                binding,
+                resolution.shadowed_glob,
+                parent_scope,
+                finalize,
+                shadowing,
+            );
         }
 
         let check_usable = |this: &mut Self, binding: NameBinding<'ra>| {
@@ -944,75 +906,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         // Check if one of single imports can still define the name,
         // if it can then our result is not determined and can be invalidated.
-        for single_import in &resolution.single_imports {
-            if ignore_import == Some(*single_import) {
-                // This branch handles a cycle in single imports.
-                //
-                // For example:
-                // ```
-                // use a::b;
-                // use b as a;
-                // ```
-                // 1. Record `use a::b` as the `ignore_import` and attempt to locate `a` in the
-                //    current module.
-                // 2. Encounter the import `use b as a`, which is a `single_import` for `a`,
-                //    and try to find `b` in the current module.
-                // 3. Re-encounter the `use a::b` import since it's a `single_import` of `b`.
-                //    This leads to entering this branch.
-                continue;
-            }
-            if !self.is_accessible_from(single_import.vis, parent_scope.module) {
-                continue;
-            }
-            if let Some(ignored) = ignore_binding
-                && let NameBindingKind::Import { import, .. } = ignored.kind
-                && import == *single_import
-            {
-                // Ignore not just the binding itself, but if it has a shadowed_glob,
-                // ignore that, too, because this loop is supposed to only process
-                // named imports.
-                continue;
-            }
-
-            let Some(module) = single_import.imported_module.get() else {
-                return Err((Undetermined, Weak::No));
-            };
-            let ImportKind::Single { source, target, target_bindings, .. } = &single_import.kind
-            else {
-                unreachable!();
-            };
-            if source != target {
-                // This branch allows the binding to be defined or updated later if the target name
-                // can hide the source.
-                if target_bindings.iter().all(|binding| binding.get().is_none()) {
-                    // None of the target bindings are available, so we can't determine
-                    // if this binding is correct or not.
-                    // See more details in #124840
-                    return Err((Undetermined, Weak::No));
-                } else if target_bindings[ns].get().is_none() && binding.is_some() {
-                    // `binding.is_some()` avoids the condition where the binding
-                    // truly doesn't exist in this namespace and should return `Err(Determined)`.
-                    return Err((Undetermined, Weak::No));
-                }
-            }
-
-            match self.resolve_ident_in_module(
-                module,
-                *source,
-                ns,
-                &single_import.parent_scope,
-                None,
-                ignore_binding,
-                ignore_import,
-            ) {
-                Err((Determined, _)) => continue,
-                Ok(binding)
-                    if !self.is_accessible_from(binding.vis, single_import.parent_scope.module) =>
-                {
-                    continue;
-                }
-                Ok(_) | Err((Undetermined, _)) => return Err((Undetermined, Weak::No)),
-            }
+        if self.single_import_can_define_name(
+            &resolution,
+            binding,
+            ns,
+            ignore_import,
+            ignore_binding,
+            parent_scope,
+        ) {
+            return Err((Undetermined, Weak::No));
         }
 
         // So we have a resolution that's from a glob import. This resolution is determined
@@ -1101,6 +1003,129 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         Err((Determined, Weak::No))
     }
 
+    fn finalize_module_binding(
+        &mut self,
+        ident: Ident,
+        binding: Option<NameBinding<'ra>>,
+        shadowed_glob: Option<NameBinding<'ra>>,
+        parent_scope: &ParentScope<'ra>,
+        finalize: Finalize,
+        shadowing: Shadowing,
+    ) -> Result<NameBinding<'ra>, (Determinacy, Weak)> {
+        let Finalize { path_span, report_private, used, root_span, .. } = finalize;
+
+        let Some(binding) = binding else {
+            return Err((Determined, Weak::No));
+        };
+
+        if !self.is_accessible_from(binding.vis, parent_scope.module) {
+            if report_private {
+                self.privacy_errors.push(PrivacyError {
+                    ident,
+                    binding,
+                    dedup_span: path_span,
+                    outermost_res: None,
+                    parent_scope: *parent_scope,
+                    single_nested: path_span != root_span,
+                });
+            } else {
+                return Err((Determined, Weak::No));
+            }
+        }
+
+        // Forbid expanded shadowing to avoid time travel.
+        if let Some(shadowed_glob) = shadowed_glob
+            && shadowing == Shadowing::Restricted
+            && binding.expansion != LocalExpnId::ROOT
+            && binding.res() != shadowed_glob.res()
+        {
+            self.ambiguity_errors.push(AmbiguityError {
+                kind: AmbiguityKind::GlobVsExpanded,
+                ident,
+                b1: binding,
+                b2: shadowed_glob,
+                warning: false,
+                misc1: AmbiguityErrorMisc::None,
+                misc2: AmbiguityErrorMisc::None,
+            });
+        }
+
+        if shadowing == Shadowing::Unrestricted
+            && binding.expansion != LocalExpnId::ROOT
+            && let NameBindingKind::Import { import, .. } = binding.kind
+            && matches!(import.kind, ImportKind::MacroExport)
+        {
+            self.macro_expanded_macro_export_errors.insert((path_span, binding.span));
+        }
+
+        self.record_use(ident, binding, used);
+        return Ok(binding);
+    }
+
+    // Checks if a single import can define the `Ident` corresponding to `binding`.
+    // This is used to check whether we can definitively accept a glob as a resolution.
+    fn single_import_can_define_name(
+        &mut self,
+        resolution: &NameResolution<'ra>,
+        binding: Option<NameBinding<'ra>>,
+        ns: Namespace,
+        ignore_import: Option<Import<'ra>>,
+        ignore_binding: Option<NameBinding<'ra>>,
+        parent_scope: &ParentScope<'ra>,
+    ) -> bool {
+        for single_import in &resolution.single_imports {
+            if ignore_import == Some(*single_import) {
+                continue;
+            }
+            if !self.is_accessible_from(single_import.vis, parent_scope.module) {
+                continue;
+            }
+            if let Some(ignored) = ignore_binding
+                && let NameBindingKind::Import { import, .. } = ignored.kind
+                && import == *single_import
+            {
+                continue;
+            }
+
+            let Some(module) = single_import.imported_module.get() else {
+                return true;
+            };
+            let ImportKind::Single { source, target, target_bindings, .. } = &single_import.kind
+            else {
+                unreachable!();
+            };
+            if source != target {
+                if target_bindings.iter().all(|binding| binding.get().is_none()) {
+                    return true;
+                } else if target_bindings[ns].get().is_none() && binding.is_some() {
+                    return true;
+                }
+            }
+
+            match self.resolve_ident_in_module(
+                module,
+                *source,
+                ns,
+                &single_import.parent_scope,
+                None,
+                ignore_binding,
+                ignore_import,
+            ) {
+                Err((Determined, _)) => continue,
+                Ok(binding)
+                    if !self.is_accessible_from(binding.vis, single_import.parent_scope.module) =>
+                {
+                    continue;
+                }
+                Ok(_) | Err((Undetermined, _)) => {
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
+
     /// Validate a local resolution (from ribs).
     #[instrument(level = "debug", skip(self, all_ribs))]
     fn validate_res_from_ribs(
-- 
cgit 1.4.1-3-g733a5


From 3ad95cccf9b3af7e527869a1eb130217971b7a57 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Tue, 1 Jul 2025 21:46:28 +0500
Subject: cleaned up some tests

---
 tests/ui/auto-traits/auto-traits-type-parameter    | 36 --------
 tests/ui/auto-traits/auto-traits-type-parameter.rs | 37 +++++++++
 tests/ui/auxiliary/typeid-intrinsic-aux1.rs        | 29 -------
 tests/ui/auxiliary/typeid-intrinsic-aux2.rs        | 29 -------
 tests/ui/consts/const-eval-array-len-in-impl.rs    |  4 +-
 .../ui/consts/const-eval-array-len-in-impl.stderr  |  2 +-
 .../let-binding-tuple-destructuring.rs             |  2 +
 .../lifetimes/any-lifetime-escape-higher-rank.rs   | 12 ++-
 tests/ui/limits/type-length-limit-enforcement.rs   | 16 ++--
 .../ui/limits/type-length-limit-enforcement.stderr |  4 +-
 .../macro-fragment-ident-underscore-error.rs       |  7 +-
 .../macro-fragment-ident-underscore-error.stderr   |  6 +-
 .../struct-type-and-function-name-coexistence.rs   | 13 ++-
 .../integer-literal-method-call-underscore.rs      |  6 +-
 tests/ui/ptr_ops/ptr-write-bool-representation.rs  |  7 ++
 tests/ui/ptr_ops/raw-pointer-type-basic.rs         | 15 +++-
 .../ui/try-trait/try-operator-expansion-hygiene.rs | 16 ++--
 .../ui/try-trait/try-operator-various-contexts.rs  | 35 ++++----
 .../type-inference-none-in-generic-ref.rs          |  6 +-
 .../type-inference-none-in-generic-ref.stderr      |  2 +-
 .../type-inference-unconstrained-none.rs           |  2 +-
 .../type-inference-unconstrained-none.stderr       |  2 +-
 tests/ui/type/auxiliary/typeid-consistency-aux1.rs | 29 +++++++
 tests/ui/type/auxiliary/typeid-consistency-aux2.rs | 29 +++++++
 tests/ui/type/type-name-basic.rs                   |  7 +-
 tests/ui/type/typeid-consistency-comprehensive.rs  | 97 ----------------------
 tests/ui/type/typeid-consistency.rs                | 94 +++++++++++++++++++++
 .../basic-underscore-lifetime-elision.rs           |  8 +-
 28 files changed, 299 insertions(+), 253 deletions(-)
 delete mode 100644 tests/ui/auto-traits/auto-traits-type-parameter
 create mode 100644 tests/ui/auto-traits/auto-traits-type-parameter.rs
 delete mode 100644 tests/ui/auxiliary/typeid-intrinsic-aux1.rs
 delete mode 100644 tests/ui/auxiliary/typeid-intrinsic-aux2.rs
 create mode 100644 tests/ui/type/auxiliary/typeid-consistency-aux1.rs
 create mode 100644 tests/ui/type/auxiliary/typeid-consistency-aux2.rs
 delete mode 100644 tests/ui/type/typeid-consistency-comprehensive.rs
 create mode 100644 tests/ui/type/typeid-consistency.rs

diff --git a/tests/ui/auto-traits/auto-traits-type-parameter b/tests/ui/auto-traits/auto-traits-type-parameter
deleted file mode 100644
index 83d81c0d833..00000000000
--- a/tests/ui/auto-traits/auto-traits-type-parameter
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ run-pass
-
-#![allow(non_camel_case_types)]
-#![allow(dead_code)]
-
-fn p_foo<T>(_pinned: T) { }
-fn s_foo<T>(_shared: T) { }
-fn u_foo<T:Send>(_unique: T) { }
-
-struct r {
-  i: isize,
-}
-
-impl Drop for r {
-    fn drop(&mut self) {}
-}
-
-fn r(i:isize) -> r {
-    r {
-        i: i
-    }
-}
-
-pub fn main() {
-    p_foo(r(10));
-
-    p_foo::<Box<_>>(Box::new(r(10)));
-    p_foo::<Box<_>>(Box::new(10));
-    p_foo(10);
-
-    s_foo::<Box<_>>(Box::new(10));
-    s_foo(10);
-
-    u_foo::<Box<_>>(Box::new(10));
-    u_foo(10);
-}
diff --git a/tests/ui/auto-traits/auto-traits-type-parameter.rs b/tests/ui/auto-traits/auto-traits-type-parameter.rs
new file mode 100644
index 00000000000..0c448f58996
--- /dev/null
+++ b/tests/ui/auto-traits/auto-traits-type-parameter.rs
@@ -0,0 +1,37 @@
+//! Checks how type parameters interact with auto-traits like `Send` and `Sync` with implicit
+//! bounds
+
+//@ run-pass
+
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]
+
+fn p_foo<T>(_pinned: T) {}
+fn s_foo<T>(_shared: T) {}
+fn u_foo<T: Send>(_unique: T) {}
+
+struct r {
+    i: isize,
+}
+
+impl Drop for r {
+    fn drop(&mut self) {}
+}
+
+fn r(i: isize) -> r {
+    r { i }
+}
+
+pub fn main() {
+    p_foo(r(10));
+
+    p_foo::<Box<_>>(Box::new(r(10)));
+    p_foo::<Box<_>>(Box::new(10));
+    p_foo(10);
+
+    s_foo::<Box<_>>(Box::new(10));
+    s_foo(10);
+
+    u_foo::<Box<_>>(Box::new(10));
+    u_foo(10);
+}
diff --git a/tests/ui/auxiliary/typeid-intrinsic-aux1.rs b/tests/ui/auxiliary/typeid-intrinsic-aux1.rs
deleted file mode 100644
index a028008c6ae..00000000000
--- a/tests/ui/auxiliary/typeid-intrinsic-aux1.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use std::any::{Any, TypeId};
-
-pub struct A;
-pub struct B(Option<A>);
-pub struct C(Option<isize>);
-pub struct D(Option<&'static str>);
-pub struct E(Result<&'static str, isize>);
-
-pub type F = Option<isize>;
-pub type G = usize;
-pub type H = &'static str;
-pub type I = Box<dyn Fn()>;
-pub type I32Iterator = dyn Iterator<Item=i32>;
-pub type U32Iterator = dyn Iterator<Item=u32>;
-
-pub fn id_A() -> TypeId { TypeId::of::<A>() }
-pub fn id_B() -> TypeId { TypeId::of::<B>() }
-pub fn id_C() -> TypeId { TypeId::of::<C>() }
-pub fn id_D() -> TypeId { TypeId::of::<D>() }
-pub fn id_E() -> TypeId { TypeId::of::<E>() }
-pub fn id_F() -> TypeId { TypeId::of::<F>() }
-pub fn id_G() -> TypeId { TypeId::of::<G>() }
-pub fn id_H() -> TypeId { TypeId::of::<H>() }
-pub fn id_I() -> TypeId { TypeId::of::<I>() }
-
-pub fn foo<T: Any>() -> TypeId { TypeId::of::<T>() }
-
-pub fn id_i32_iterator() -> TypeId { TypeId::of::<I32Iterator>() }
-pub fn id_u32_iterator() -> TypeId { TypeId::of::<U32Iterator>() }
diff --git a/tests/ui/auxiliary/typeid-intrinsic-aux2.rs b/tests/ui/auxiliary/typeid-intrinsic-aux2.rs
deleted file mode 100644
index a028008c6ae..00000000000
--- a/tests/ui/auxiliary/typeid-intrinsic-aux2.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use std::any::{Any, TypeId};
-
-pub struct A;
-pub struct B(Option<A>);
-pub struct C(Option<isize>);
-pub struct D(Option<&'static str>);
-pub struct E(Result<&'static str, isize>);
-
-pub type F = Option<isize>;
-pub type G = usize;
-pub type H = &'static str;
-pub type I = Box<dyn Fn()>;
-pub type I32Iterator = dyn Iterator<Item=i32>;
-pub type U32Iterator = dyn Iterator<Item=u32>;
-
-pub fn id_A() -> TypeId { TypeId::of::<A>() }
-pub fn id_B() -> TypeId { TypeId::of::<B>() }
-pub fn id_C() -> TypeId { TypeId::of::<C>() }
-pub fn id_D() -> TypeId { TypeId::of::<D>() }
-pub fn id_E() -> TypeId { TypeId::of::<E>() }
-pub fn id_F() -> TypeId { TypeId::of::<F>() }
-pub fn id_G() -> TypeId { TypeId::of::<G>() }
-pub fn id_H() -> TypeId { TypeId::of::<H>() }
-pub fn id_I() -> TypeId { TypeId::of::<I>() }
-
-pub fn foo<T: Any>() -> TypeId { TypeId::of::<T>() }
-
-pub fn id_i32_iterator() -> TypeId { TypeId::of::<I32Iterator>() }
-pub fn id_u32_iterator() -> TypeId { TypeId::of::<U32Iterator>() }
diff --git a/tests/ui/consts/const-eval-array-len-in-impl.rs b/tests/ui/consts/const-eval-array-len-in-impl.rs
index 6c545913dd9..0373274770d 100644
--- a/tests/ui/consts/const-eval-array-len-in-impl.rs
+++ b/tests/ui/consts/const-eval-array-len-in-impl.rs
@@ -1,4 +1,6 @@
-// https://github.com/rust-lang/rust/issues/49208
+//! This checks that compiler correctly evaluate constant array lengths within trait `impl` headers.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/49208>.
 
 trait Foo {
     fn foo();
diff --git a/tests/ui/consts/const-eval-array-len-in-impl.stderr b/tests/ui/consts/const-eval-array-len-in-impl.stderr
index 43cc377006e..faff7aa3ff7 100644
--- a/tests/ui/consts/const-eval-array-len-in-impl.stderr
+++ b/tests/ui/consts/const-eval-array-len-in-impl.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `[(); 0]: Foo` is not satisfied
-  --> $DIR/unevaluated_fixed_size_array_len.rs:12:6
+  --> $DIR/const-eval-array-len-in-impl.rs:14:6
    |
 LL |     <[(); 0] as Foo>::foo()
    |      ^^^^^^^ the trait `Foo` is not implemented for `[(); 0]`
diff --git a/tests/ui/destructuring-assignment/let-binding-tuple-destructuring.rs b/tests/ui/destructuring-assignment/let-binding-tuple-destructuring.rs
index 3d0e79632bb..f62fae86219 100644
--- a/tests/ui/destructuring-assignment/let-binding-tuple-destructuring.rs
+++ b/tests/ui/destructuring-assignment/let-binding-tuple-destructuring.rs
@@ -1,3 +1,5 @@
+//! Checks basic multiple variable declaration using tuple destructuring in a `let` binding.
+
 //@ run-pass
 
 pub fn main() {
diff --git a/tests/ui/lifetimes/any-lifetime-escape-higher-rank.rs b/tests/ui/lifetimes/any-lifetime-escape-higher-rank.rs
index 7b0c7b53940..f9f38ee532d 100644
--- a/tests/ui/lifetimes/any-lifetime-escape-higher-rank.rs
+++ b/tests/ui/lifetimes/any-lifetime-escape-higher-rank.rs
@@ -1,11 +1,15 @@
+//! Checks that `std::any::Any` cannot be used to circumvent lifetime rules
+//! with higher-rank types.
+
 //@ run-pass
-// Test that we can't ignore lifetimes by going through Any.
 
 use std::any::Any;
 
 struct Foo<'a>(&'a str);
 
-fn good(s: &String) -> Foo<'_> { Foo(s) }
+fn good(s: &String) -> Foo<'_> {
+    Foo(s)
+}
 
 fn bad1(s: String) -> Option<&'static str> {
     let a: Box<dyn Any> = Box::new(good as fn(&String) -> Foo);
@@ -17,7 +21,9 @@ trait AsStr<'a, 'b> {
 }
 
 impl<'a> AsStr<'a, 'a> for String {
-   fn get(&'a self) -> &'a str { self }
+    fn get(&'a self) -> &'a str {
+        self
+    }
 }
 
 fn bad2(s: String) -> Option<&'static str> {
diff --git a/tests/ui/limits/type-length-limit-enforcement.rs b/tests/ui/limits/type-length-limit-enforcement.rs
index 87f5ffd76d7..3b34d6eb5c8 100644
--- a/tests/ui/limits/type-length-limit-enforcement.rs
+++ b/tests/ui/limits/type-length-limit-enforcement.rs
@@ -1,17 +1,19 @@
-//@ build-fail
+//~ ERROR reached the type-length limit
+
+//! Checks the enforcement of the type-length limit
+//! and its configurability via `#![type_length_limit]`.
+
 //@ compile-flags: -Copt-level=0 -Zenforce-type-length-limit
-//~^^ ERROR reached the type-length limit
 
-// Test that the type length limit can be changed.
-// The exact type depends on optimizations, so disable them.
+//@ build-fail
 
 #![allow(dead_code)]
-#![type_length_limit="8"]
+#![type_length_limit = "8"]
 
 macro_rules! link {
     ($id:ident, $t:ty) => {
         pub type $id = ($t, $t, $t);
-    }
+    };
 }
 
 link! { A1, B1 }
@@ -26,7 +28,7 @@ link! { D, E }
 link! { E, F }
 link! { F, G<Option<i32>, Option<i32>> }
 
-pub struct G<T, K>(std::marker::PhantomData::<(T, K)>);
+pub struct G<T, K>(std::marker::PhantomData<(T, K)>);
 
 fn main() {
     drop::<Option<A>>(None);
diff --git a/tests/ui/limits/type-length-limit-enforcement.stderr b/tests/ui/limits/type-length-limit-enforcement.stderr
index 198d133c08c..516230ae832 100644
--- a/tests/ui/limits/type-length-limit-enforcement.stderr
+++ b/tests/ui/limits/type-length-limit-enforcement.stderr
@@ -1,11 +1,11 @@
 error: reached the type-length limit while instantiating `std::mem::drop::<Option<((((..., ..., ...), ..., ...), ..., ...), ..., ...)>>`
-  --> $DIR/type_length_limit.rs:32:5
+  --> $DIR/type-length-limit-enforcement.rs:34:5
    |
 LL |     drop::<Option<A>>(None);
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: consider adding a `#![type_length_limit="4010"]` attribute to your crate
-   = note: the full type name has been written to '$TEST_BUILD_DIR/type_length_limit.long-type.txt'
+   = note: the full type name has been written to '$TEST_BUILD_DIR/type-length-limit-enforcement.long-type.txt'
 
 error: reached the type-length limit while instantiating `<{closure@rt::lang_start<()>::{closure#0}} as FnMut<()>>::call_mut`
    |
diff --git a/tests/ui/macros/macro-fragment-ident-underscore-error.rs b/tests/ui/macros/macro-fragment-ident-underscore-error.rs
index 77ec70d43d5..882dd167adc 100644
--- a/tests/ui/macros/macro-fragment-ident-underscore-error.rs
+++ b/tests/ui/macros/macro-fragment-ident-underscore-error.rs
@@ -1,7 +1,10 @@
+//! Verifies that the reserved underscore `_` cannot be used as an `ident` fragment specifier
+//! within a macro pattern, as it leads to a compilation error.
+
 macro_rules! identity {
-    ($i: ident) => (
+    ($i: ident) => {
         $i
-    )
+    };
 }
 
 fn main() {
diff --git a/tests/ui/macros/macro-fragment-ident-underscore-error.stderr b/tests/ui/macros/macro-fragment-ident-underscore-error.stderr
index 0c3f980cf6c..929e4624e4b 100644
--- a/tests/ui/macros/macro-fragment-ident-underscore-error.stderr
+++ b/tests/ui/macros/macro-fragment-ident-underscore-error.stderr
@@ -1,5 +1,5 @@
 error: no rules expected reserved identifier `_`
-  --> $DIR/underscore-ident-matcher.rs:8:19
+  --> $DIR/macro-fragment-ident-underscore-error.rs:11:19
    |
 LL | macro_rules! identity {
    | --------------------- when calling this macro
@@ -8,9 +8,9 @@ LL |     let identity!(_) = 10;
    |                   ^ no rules expected this token in macro call
    |
 note: while trying to match meta-variable `$i:ident`
-  --> $DIR/underscore-ident-matcher.rs:2:6
+  --> $DIR/macro-fragment-ident-underscore-error.rs:5:6
    |
-LL |     ($i: ident) => (
+LL |     ($i: ident) => {
    |      ^^^^^^^^^
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/namespace/struct-type-and-function-name-coexistence.rs b/tests/ui/namespace/struct-type-and-function-name-coexistence.rs
index 31dc684a214..8d5ab3781b5 100644
--- a/tests/ui/namespace/struct-type-and-function-name-coexistence.rs
+++ b/tests/ui/namespace/struct-type-and-function-name-coexistence.rs
@@ -1,7 +1,14 @@
 //@ run-pass
 
-struct A { a: isize }
+struct A {
+    a: isize,
+}
 
-fn a(a: A) -> isize { return a.a; }
+fn a(a: A) -> isize {
+    return a.a;
+}
 
-pub fn main() { let x: A = A {a: 1}; assert_eq!(a(x), 1); }
+pub fn main() {
+    let x: A = A { a: 1 };
+    assert_eq!(a(x), 1);
+}
diff --git a/tests/ui/parser/integer-literal-method-call-underscore.rs b/tests/ui/parser/integer-literal-method-call-underscore.rs
index d9eb21894e8..9e4abf28cba 100644
--- a/tests/ui/parser/integer-literal-method-call-underscore.rs
+++ b/tests/ui/parser/integer-literal-method-call-underscore.rs
@@ -1,6 +1,10 @@
+//! Checks that methods with names starting with an underscore (`_`) can be
+//! successfully called directly on integer literals, confirming the correct
+//! parsing of such expressions where the underscore is part of the method identifier.
+
 //@ run-pass
 
-trait Tr : Sized {
+trait Tr: Sized {
     fn _method_on_numbers(self) {}
 }
 
diff --git a/tests/ui/ptr_ops/ptr-write-bool-representation.rs b/tests/ui/ptr_ops/ptr-write-bool-representation.rs
index 4eb25329223..3dfc3e51ab2 100644
--- a/tests/ui/ptr_ops/ptr-write-bool-representation.rs
+++ b/tests/ui/ptr_ops/ptr-write-bool-representation.rs
@@ -1,3 +1,10 @@
+//! Validates the correct behavior of writing a `bool` value using `std::ptr::write`.
+//!
+//! This test addresses historical concerns regarding the internal representation of `bool`
+//! (e.g., as `i1` in LLVM versus its byte-aligned memory layout) and checks that
+//! `ptr::write` correctly handles this type without issues, confirming its memory
+//! behavior is as expected.
+
 //@ run-pass
 
 use std::ptr;
diff --git a/tests/ui/ptr_ops/raw-pointer-type-basic.rs b/tests/ui/ptr_ops/raw-pointer-type-basic.rs
index 5c8ed344ab3..349e8e67909 100644
--- a/tests/ui/ptr_ops/raw-pointer-type-basic.rs
+++ b/tests/ui/ptr_ops/raw-pointer-type-basic.rs
@@ -1,9 +1,18 @@
+//! Checks the basic usage of raw pointers (`*const isize`) as function argument and return types.
+
 //@ run-pass
 
 #![allow(dead_code)]
 
-fn f(a: *const isize) -> *const isize { return a; }
+fn f(a: *const isize) -> *const isize {
+    return a;
+}
 
-fn g(a: *const isize) -> *const isize { let b = f(a); return b; }
+fn g(a: *const isize) -> *const isize {
+    let b = f(a);
+    return b;
+}
 
-pub fn main() { return; }
+pub fn main() {
+    return;
+}
diff --git a/tests/ui/try-trait/try-operator-expansion-hygiene.rs b/tests/ui/try-trait/try-operator-expansion-hygiene.rs
index 20538e094c6..b6f4e533d8d 100644
--- a/tests/ui/try-trait/try-operator-expansion-hygiene.rs
+++ b/tests/ui/try-trait/try-operator-expansion-hygiene.rs
@@ -1,16 +1,14 @@
+//! This test verifies that the `?` operator expansion is hygienic,
+//! i.e., it's not affected by other `val` and `err` bindings that may be in scope.
+//!
+//! Note: Prior to the Try trait stabilization, `expr?` expanded to a match
+//! with `val` and `err` bindings. The current implementation uses Try::branch()
+//! but this test remains relevant for hygiene verification.
+
 //@ run-pass
 
 #![allow(non_upper_case_globals)]
 #![allow(dead_code)]
-// `expr?` expands to:
-//
-// match expr {
-//     Ok(val) => val,
-//     Err(err) => return Err(From::from(err)),
-// }
-//
-// This test verifies that the expansion is hygienic, i.e., it's not affected by other `val` and
-// `err` bindings that may be in scope.
 
 use std::num::ParseIntError;
 
diff --git a/tests/ui/try-trait/try-operator-various-contexts.rs b/tests/ui/try-trait/try-operator-various-contexts.rs
index b9978204557..41c3679c96f 100644
--- a/tests/ui/try-trait/try-operator-various-contexts.rs
+++ b/tests/ui/try-trait/try-operator-various-contexts.rs
@@ -1,9 +1,11 @@
+//! Checks the functionality of the `?` operator in various syntactic contexts.
+
 //@ run-pass
 
 #![allow(dead_code)]
 
 use std::fs::File;
-use std::io::{Read, self};
+use std::io::{self, Read};
 use std::num::ParseIntError;
 use std::str::FromStr;
 
@@ -35,7 +37,9 @@ fn on_path() -> Result<i32, ParseIntError> {
 
 fn on_macro() -> Result<i32, ParseIntError> {
     macro_rules! id {
-        ($e:expr) => { $e }
+        ($e:expr) => {
+            $e
+        };
     }
 
     Ok(id!("7".parse::<i32>())?)
@@ -50,11 +54,14 @@ fn on_parens() -> Result<i32, ParseIntError> {
 fn on_block() -> Result<i32, ParseIntError> {
     let x = "9".parse::<i32>();
 
-    Ok({x}?)
+    Ok({ x }?)
 }
 
 fn on_field() -> Result<i32, ParseIntError> {
-    struct Pair<A, B> { a: A, b: B }
+    struct Pair<A, B> {
+        a: A,
+        b: B,
+    }
 
     let x = Pair { a: "10".parse::<i32>(), b: 0 };
 
@@ -89,7 +96,9 @@ fn on_index() -> Result<i32, ParseIntError> {
 }
 
 fn on_args() -> Result<i32, ParseIntError> {
-    fn sub(x: i32, y: i32) -> i32 { x - y }
+    fn sub(x: i32, y: i32) -> i32 {
+        x - y
+    }
 
     let x = "20".parse();
     let y = "21".parse();
@@ -98,19 +107,11 @@ fn on_args() -> Result<i32, ParseIntError> {
 }
 
 fn on_if() -> Result<i32, ParseIntError> {
-    Ok(if true {
-        "22".parse::<i32>()
-    } else {
-        "23".parse::<i32>()
-    }?)
+    Ok(if true { "22".parse::<i32>() } else { "23".parse::<i32>() }?)
 }
 
 fn on_if_let() -> Result<i32, ParseIntError> {
-    Ok(if let Ok(..) = "24".parse::<i32>() {
-        "25".parse::<i32>()
-    } else {
-        "26".parse::<i32>()
-    }?)
+    Ok(if let Ok(..) = "24".parse::<i32>() { "25".parse::<i32>() } else { "26".parse::<i32>() }?)
 }
 
 fn on_match() -> Result<i32, ParseIntError> {
@@ -121,7 +122,9 @@ fn on_match() -> Result<i32, ParseIntError> {
 }
 
 fn tight_binding() -> Result<bool, ()> {
-    fn ok<T>(x: T) -> Result<T, ()> { Ok(x) }
+    fn ok<T>(x: T) -> Result<T, ()> {
+        Ok(x)
+    }
 
     let x = ok(true);
     Ok(!x?)
diff --git a/tests/ui/type-inference/type-inference-none-in-generic-ref.rs b/tests/ui/type-inference/type-inference-none-in-generic-ref.rs
index 473ca954b23..9c1b7c19e3d 100644
--- a/tests/ui/type-inference/type-inference-none-in-generic-ref.rs
+++ b/tests/ui/type-inference/type-inference-none-in-generic-ref.rs
@@ -1,5 +1,7 @@
-struct S<'a, T:'a> {
-    o: &'a Option<T>
+//! Checks that unconstrained `None` is rejected through references and generics
+
+struct S<'a, T: 'a> {
+    o: &'a Option<T>,
 }
 
 fn main() {
diff --git a/tests/ui/type-inference/type-inference-none-in-generic-ref.stderr b/tests/ui/type-inference/type-inference-none-in-generic-ref.stderr
index 72fd0202f4e..d671c189b37 100644
--- a/tests/ui/type-inference/type-inference-none-in-generic-ref.stderr
+++ b/tests/ui/type-inference/type-inference-none-in-generic-ref.stderr
@@ -1,5 +1,5 @@
 error[E0282]: type annotations needed
-  --> $DIR/unconstrained-ref.rs:6:5
+  --> $DIR/type-inference-none-in-generic-ref.rs:8:5
    |
 LL |     S { o: &None };
    |     ^^^^^^^^^^^^^^ cannot infer type of the type parameter `T` declared on the struct `S`
diff --git a/tests/ui/type-inference/type-inference-unconstrained-none.rs b/tests/ui/type-inference/type-inference-unconstrained-none.rs
index e180b3163d4..38a506763c7 100644
--- a/tests/ui/type-inference/type-inference-unconstrained-none.rs
+++ b/tests/ui/type-inference/type-inference-unconstrained-none.rs
@@ -1,4 +1,4 @@
-// Issue #5062
+//! Regression test for <https://github.com/rust-lang/rust/issues/5062>.
 
 fn main() {
     None; //~ ERROR type annotations needed [E0282]
diff --git a/tests/ui/type-inference/type-inference-unconstrained-none.stderr b/tests/ui/type-inference/type-inference-unconstrained-none.stderr
index 4af6f412e5b..80572b845e8 100644
--- a/tests/ui/type-inference/type-inference-unconstrained-none.stderr
+++ b/tests/ui/type-inference/type-inference-unconstrained-none.stderr
@@ -1,5 +1,5 @@
 error[E0282]: type annotations needed
-  --> $DIR/unconstrained-none.rs:4:5
+  --> $DIR/type-inference-unconstrained-none.rs:4:5
    |
 LL |     None;
    |     ^^^^ cannot infer type of the type parameter `T` declared on the enum `Option`
diff --git a/tests/ui/type/auxiliary/typeid-consistency-aux1.rs b/tests/ui/type/auxiliary/typeid-consistency-aux1.rs
new file mode 100644
index 00000000000..a028008c6ae
--- /dev/null
+++ b/tests/ui/type/auxiliary/typeid-consistency-aux1.rs
@@ -0,0 +1,29 @@
+use std::any::{Any, TypeId};
+
+pub struct A;
+pub struct B(Option<A>);
+pub struct C(Option<isize>);
+pub struct D(Option<&'static str>);
+pub struct E(Result<&'static str, isize>);
+
+pub type F = Option<isize>;
+pub type G = usize;
+pub type H = &'static str;
+pub type I = Box<dyn Fn()>;
+pub type I32Iterator = dyn Iterator<Item=i32>;
+pub type U32Iterator = dyn Iterator<Item=u32>;
+
+pub fn id_A() -> TypeId { TypeId::of::<A>() }
+pub fn id_B() -> TypeId { TypeId::of::<B>() }
+pub fn id_C() -> TypeId { TypeId::of::<C>() }
+pub fn id_D() -> TypeId { TypeId::of::<D>() }
+pub fn id_E() -> TypeId { TypeId::of::<E>() }
+pub fn id_F() -> TypeId { TypeId::of::<F>() }
+pub fn id_G() -> TypeId { TypeId::of::<G>() }
+pub fn id_H() -> TypeId { TypeId::of::<H>() }
+pub fn id_I() -> TypeId { TypeId::of::<I>() }
+
+pub fn foo<T: Any>() -> TypeId { TypeId::of::<T>() }
+
+pub fn id_i32_iterator() -> TypeId { TypeId::of::<I32Iterator>() }
+pub fn id_u32_iterator() -> TypeId { TypeId::of::<U32Iterator>() }
diff --git a/tests/ui/type/auxiliary/typeid-consistency-aux2.rs b/tests/ui/type/auxiliary/typeid-consistency-aux2.rs
new file mode 100644
index 00000000000..a028008c6ae
--- /dev/null
+++ b/tests/ui/type/auxiliary/typeid-consistency-aux2.rs
@@ -0,0 +1,29 @@
+use std::any::{Any, TypeId};
+
+pub struct A;
+pub struct B(Option<A>);
+pub struct C(Option<isize>);
+pub struct D(Option<&'static str>);
+pub struct E(Result<&'static str, isize>);
+
+pub type F = Option<isize>;
+pub type G = usize;
+pub type H = &'static str;
+pub type I = Box<dyn Fn()>;
+pub type I32Iterator = dyn Iterator<Item=i32>;
+pub type U32Iterator = dyn Iterator<Item=u32>;
+
+pub fn id_A() -> TypeId { TypeId::of::<A>() }
+pub fn id_B() -> TypeId { TypeId::of::<B>() }
+pub fn id_C() -> TypeId { TypeId::of::<C>() }
+pub fn id_D() -> TypeId { TypeId::of::<D>() }
+pub fn id_E() -> TypeId { TypeId::of::<E>() }
+pub fn id_F() -> TypeId { TypeId::of::<F>() }
+pub fn id_G() -> TypeId { TypeId::of::<G>() }
+pub fn id_H() -> TypeId { TypeId::of::<H>() }
+pub fn id_I() -> TypeId { TypeId::of::<I>() }
+
+pub fn foo<T: Any>() -> TypeId { TypeId::of::<T>() }
+
+pub fn id_i32_iterator() -> TypeId { TypeId::of::<I32Iterator>() }
+pub fn id_u32_iterator() -> TypeId { TypeId::of::<U32Iterator>() }
diff --git a/tests/ui/type/type-name-basic.rs b/tests/ui/type/type-name-basic.rs
index 068a42606c2..9381cb82578 100644
--- a/tests/ui/type/type-name-basic.rs
+++ b/tests/ui/type/type-name-basic.rs
@@ -1,3 +1,6 @@
+//! Checks the basic functionality of `std::any::type_name` for primitive types
+//! and simple generic structs.
+
 //@ run-pass
 
 #![allow(dead_code)]
@@ -5,10 +8,10 @@
 use std::any::type_name;
 
 struct Foo<T> {
-    x: T
+    x: T,
 }
 
 pub fn main() {
     assert_eq!(type_name::<isize>(), "isize");
-    assert_eq!(type_name::<Foo<usize>>(), "tydesc_name::Foo<usize>");
+    assert_eq!(type_name::<Foo<usize>>(), "type_name_basic::Foo<usize>");
 }
diff --git a/tests/ui/type/typeid-consistency-comprehensive.rs b/tests/ui/type/typeid-consistency-comprehensive.rs
deleted file mode 100644
index 7c4fb3f95a9..00000000000
--- a/tests/ui/type/typeid-consistency-comprehensive.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-//@ run-pass
-
-#![allow(deprecated)]
-//@ aux-build:typeid-intrinsic-aux1.rs
-//@ aux-build:typeid-intrinsic-aux2.rs
-
-#![feature(core_intrinsics)]
-
-extern crate typeid_intrinsic_aux1 as other1;
-extern crate typeid_intrinsic_aux2 as other2;
-
-use std::hash::{SipHasher, Hasher, Hash};
-use std::any::TypeId;
-
-struct A;
-struct Test;
-
-pub fn main() {
-    assert_eq!(TypeId::of::<other1::A>(), other1::id_A());
-    assert_eq!(TypeId::of::<other1::B>(), other1::id_B());
-    assert_eq!(TypeId::of::<other1::C>(), other1::id_C());
-    assert_eq!(TypeId::of::<other1::D>(), other1::id_D());
-    assert_eq!(TypeId::of::<other1::E>(), other1::id_E());
-    assert_eq!(TypeId::of::<other1::F>(), other1::id_F());
-    assert_eq!(TypeId::of::<other1::G>(), other1::id_G());
-    assert_eq!(TypeId::of::<other1::H>(), other1::id_H());
-    assert_eq!(TypeId::of::<other1::I>(), other1::id_I());
-
-    assert_eq!(TypeId::of::<other2::A>(), other2::id_A());
-    assert_eq!(TypeId::of::<other2::B>(), other2::id_B());
-    assert_eq!(TypeId::of::<other2::C>(), other2::id_C());
-    assert_eq!(TypeId::of::<other2::D>(), other2::id_D());
-    assert_eq!(TypeId::of::<other2::E>(), other2::id_E());
-    assert_eq!(TypeId::of::<other2::F>(), other2::id_F());
-    assert_eq!(TypeId::of::<other2::G>(), other2::id_G());
-    assert_eq!(TypeId::of::<other2::H>(), other2::id_H());
-    assert_eq!(TypeId::of::<other1::I>(), other2::id_I());
-
-    assert_eq!(other1::id_F(), other2::id_F());
-    assert_eq!(other1::id_G(), other2::id_G());
-    assert_eq!(other1::id_H(), other2::id_H());
-    assert_eq!(other1::id_I(), other2::id_I());
-
-    assert_eq!(TypeId::of::<isize>(), other2::foo::<isize>());
-    assert_eq!(TypeId::of::<isize>(), other1::foo::<isize>());
-    assert_eq!(other2::foo::<isize>(), other1::foo::<isize>());
-    assert_eq!(TypeId::of::<A>(), other2::foo::<A>());
-    assert_eq!(TypeId::of::<A>(), other1::foo::<A>());
-    assert_eq!(other2::foo::<A>(), other1::foo::<A>());
-
-    // sanity test of TypeId
-    let (a, b, c) = (TypeId::of::<usize>(), TypeId::of::<&'static str>(),
-                     TypeId::of::<Test>());
-    let (d, e, f) = (TypeId::of::<usize>(), TypeId::of::<&'static str>(),
-                     TypeId::of::<Test>());
-
-    assert!(a != b);
-    assert!(a != c);
-    assert!(b != c);
-
-    assert_eq!(a, d);
-    assert_eq!(b, e);
-    assert_eq!(c, f);
-
-    // check it has a hash
-    let (a, b) = (TypeId::of::<usize>(), TypeId::of::<usize>());
-
-    let mut s1 = SipHasher::new();
-    a.hash(&mut s1);
-    let mut s2 = SipHasher::new();
-    b.hash(&mut s2);
-
-    assert_eq!(s1.finish(), s2.finish());
-
-    // Check projections
-
-    assert_eq!(TypeId::of::<other1::I32Iterator>(), other1::id_i32_iterator());
-    assert_eq!(TypeId::of::<other1::U32Iterator>(), other1::id_u32_iterator());
-    assert_eq!(other1::id_i32_iterator(), other2::id_i32_iterator());
-    assert_eq!(other1::id_u32_iterator(), other2::id_u32_iterator());
-    assert_ne!(other1::id_i32_iterator(), other1::id_u32_iterator());
-    assert_ne!(TypeId::of::<other1::I32Iterator>(), TypeId::of::<other1::U32Iterator>());
-
-    // Check fn pointer against collisions
-    assert_ne!(
-        TypeId::of::<fn(fn(A) -> A) -> A>(),
-        TypeId::of::<fn(fn() -> A, A) -> A>()
-    );
-    assert_ne!(
-        TypeId::of::<for<'a> fn(&'a i32) -> &'a i32>(),
-        TypeId::of::<for<'a> fn(&'a i32) -> &'static i32>()
-    );
-    assert_ne!(
-        TypeId::of::<for<'a, 'b> fn(&'a i32, &'b i32) -> &'a i32>(),
-        TypeId::of::<for<'a, 'b> fn(&'b i32, &'a i32) -> &'a i32>()
-    );
-}
diff --git a/tests/ui/type/typeid-consistency.rs b/tests/ui/type/typeid-consistency.rs
new file mode 100644
index 00000000000..67ee1b6d839
--- /dev/null
+++ b/tests/ui/type/typeid-consistency.rs
@@ -0,0 +1,94 @@
+//! Checks the correctness and consistency of `std::any::TypeId::of`.
+
+//@ run-pass
+
+#![allow(deprecated)]
+#![feature(core_intrinsics)]
+
+//@ aux-build:typeid-consistency-aux1.rs
+//@ aux-build:typeid-consistency-aux2.rs
+
+extern crate typeid_consistency_aux1 as other1;
+extern crate typeid_consistency_aux2 as other2;
+
+use std::any::TypeId;
+use std::hash::{Hash, Hasher, SipHasher};
+
+struct A;
+struct Test;
+
+pub fn main() {
+    assert_eq!(TypeId::of::<other1::A>(), other1::id_A());
+    assert_eq!(TypeId::of::<other1::B>(), other1::id_B());
+    assert_eq!(TypeId::of::<other1::C>(), other1::id_C());
+    assert_eq!(TypeId::of::<other1::D>(), other1::id_D());
+    assert_eq!(TypeId::of::<other1::E>(), other1::id_E());
+    assert_eq!(TypeId::of::<other1::F>(), other1::id_F());
+    assert_eq!(TypeId::of::<other1::G>(), other1::id_G());
+    assert_eq!(TypeId::of::<other1::H>(), other1::id_H());
+    assert_eq!(TypeId::of::<other1::I>(), other1::id_I());
+
+    assert_eq!(TypeId::of::<other2::A>(), other2::id_A());
+    assert_eq!(TypeId::of::<other2::B>(), other2::id_B());
+    assert_eq!(TypeId::of::<other2::C>(), other2::id_C());
+    assert_eq!(TypeId::of::<other2::D>(), other2::id_D());
+    assert_eq!(TypeId::of::<other2::E>(), other2::id_E());
+    assert_eq!(TypeId::of::<other2::F>(), other2::id_F());
+    assert_eq!(TypeId::of::<other2::G>(), other2::id_G());
+    assert_eq!(TypeId::of::<other2::H>(), other2::id_H());
+    assert_eq!(TypeId::of::<other2::I>(), other2::id_I());
+
+    assert_eq!(other1::id_F(), other2::id_F());
+    assert_eq!(other1::id_G(), other2::id_G());
+    assert_eq!(other1::id_H(), other2::id_H());
+    assert_eq!(other1::id_I(), other2::id_I());
+
+    assert_eq!(TypeId::of::<isize>(), other2::foo::<isize>());
+    assert_eq!(TypeId::of::<isize>(), other1::foo::<isize>());
+    assert_eq!(other2::foo::<isize>(), other1::foo::<isize>());
+    assert_eq!(TypeId::of::<A>(), other2::foo::<A>());
+    assert_eq!(TypeId::of::<A>(), other1::foo::<A>());
+    assert_eq!(other2::foo::<A>(), other1::foo::<A>());
+
+    // sanity test of TypeId
+    let (a, b, c) = (TypeId::of::<usize>(), TypeId::of::<&'static str>(), TypeId::of::<Test>());
+    let (d, e, f) = (TypeId::of::<usize>(), TypeId::of::<&'static str>(), TypeId::of::<Test>());
+
+    assert!(a != b);
+    assert!(a != c);
+    assert!(b != c);
+
+    assert_eq!(a, d);
+    assert_eq!(b, e);
+    assert_eq!(c, f);
+
+    // check it has a hash
+    let (a, b) = (TypeId::of::<usize>(), TypeId::of::<usize>());
+
+    let mut s1 = SipHasher::new();
+    a.hash(&mut s1);
+    let mut s2 = SipHasher::new();
+    b.hash(&mut s2);
+
+    assert_eq!(s1.finish(), s2.finish());
+
+    // Check projections
+
+    assert_eq!(TypeId::of::<other1::I32Iterator>(), other1::id_i32_iterator());
+    assert_eq!(TypeId::of::<other1::U32Iterator>(), other1::id_u32_iterator());
+    assert_eq!(other1::id_i32_iterator(), other2::id_i32_iterator());
+    assert_eq!(other1::id_u32_iterator(), other2::id_u32_iterator());
+    assert_ne!(other1::id_i32_iterator(), other1::id_u32_iterator());
+    assert_ne!(TypeId::of::<other1::I32Iterator>(), TypeId::of::<other1::U32Iterator>());
+
+    // Check fn pointer against collisions
+    assert_ne!(TypeId::of::<fn(fn(A) -> A) -> A>(), TypeId::of::<fn(fn() -> A, A) -> A>());
+    assert_ne!(
+        TypeId::of::<for<'a> fn(&'a i32) -> &'a i32>(),
+        TypeId::of::<for<'a> fn(&'a i32) -> &'static i32>()
+    );
+    assert_ne!(
+        TypeId::of::<for<'a, 'b> fn(&'a i32, &'b i32) -> &'a i32>(),
+        TypeId::of::<for<'a, 'b> fn(&'b i32, &'a i32) -> &'a i32>()
+    );
+}
diff --git a/tests/ui/underscore-lifetime/basic-underscore-lifetime-elision.rs b/tests/ui/underscore-lifetime/basic-underscore-lifetime-elision.rs
index a372851f9cf..a2e3c8e26d4 100644
--- a/tests/ui/underscore-lifetime/basic-underscore-lifetime-elision.rs
+++ b/tests/ui/underscore-lifetime/basic-underscore-lifetime-elision.rs
@@ -1,6 +1,9 @@
+//! Checks the correct usage and behavior of the anonymous lifetime `'_` (underscore lifetime)
+
 //@ run-pass
 
 #![allow(dead_code, mismatched_lifetime_syntaxes)]
+
 struct Foo<'a>(&'a u8);
 
 fn foo(x: &u8) -> Foo<'_> {
@@ -31,8 +34,5 @@ fn main() {
     let _ = foo2(x);
     let _ = foo3(x);
     foo4(Foo(x));
-    let _ = foo5(Foo2 {
-        a: x,
-        b: &6,
-    });
+    let _ = foo5(Foo2 { a: x, b: &6 });
 }
-- 
cgit 1.4.1-3-g733a5


From 259512e3b6a920b1e1eb6034fbc738e7b9815337 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Tue, 1 Jul 2025 23:37:49 +0500
Subject: cleaned up some tests

---
 tests/ui/allocator/weak-uninhabited-type.rs        |  8 +++-
 .../underscore-prefixed-function-argument.rs       | 12 +++---
 .../ownership-struct-update-moved-error.rs         | 16 ++++----
 .../ownership-struct-update-moved-error.stderr     | 12 +++---
 tests/ui/closures/no-capture-closure-call.rs       |  2 +
 .../box-drop-unused-value-statement-regression.rs  | 14 +++----
 tests/ui/hashmap/hashset-enum-variant.rs           | 13 +++---
 tests/ui/io-checks/write-macro-error.rs            | 13 ++++--
 .../lang-item-unknown-definition-error.rs          |  4 +-
 .../lang-item-unknown-definition-error.stderr      |  2 +-
 tests/ui/modules/module-qualified-paths-basic.rs   | 15 +++++--
 tests/ui/modules/module-use-nested-groups.rs       |  2 +
 .../primitive-type-module-deprecated-paths.rs      |  7 ++--
 .../ui/modules/use-keyword-reexport-type-alias.rs  | 10 +++--
 .../unary-negation-unsigned-integer-error.rs       |  2 +
 .../unary-negation-unsigned-integer-error.stderr   |  6 +--
 tests/ui/panics/unwind-force-no-unwind-tables.rs   | 15 +++++--
 tests/ui/process/process-spawn-failure.rs          | 47 ++++++++++++++--------
 tests/ui/process/windows-exit-code-still-active.rs | 24 +++++------
 .../diverging-expressions-unreachable-code.rs      | 20 ++++-----
 .../unreachable-code-diverging-expressions.rs      | 10 +++--
 tests/ui/traits/virtual-call-parameter-handling.rs |  6 ++-
 tests/ui/type/unit-type-basic-usages.rs            | 18 ++++-----
 tests/ui/type/usize-no-generic-arguments.rs        |  2 +
 tests/ui/type/usize-no-generic-arguments.stderr    |  2 +-
 tests/ui/unsafe/maybe-uninit-zero-sized-types.rs   |  7 +++-
 26 files changed, 177 insertions(+), 112 deletions(-)

diff --git a/tests/ui/allocator/weak-uninhabited-type.rs b/tests/ui/allocator/weak-uninhabited-type.rs
index ce7d5786b41..74258eedc6a 100644
--- a/tests/ui/allocator/weak-uninhabited-type.rs
+++ b/tests/ui/allocator/weak-uninhabited-type.rs
@@ -1,7 +1,13 @@
+//! Checks that `Weak` pointers can be created with an empty enum type parameter.
+//! And generic `Weak` handles zero-variant enums without error.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/48493>
+
 //@ run-pass
 
+enum Void {}
+
 fn main() {
-    enum Void {}
     let _ = std::rc::Weak::<Void>::new();
     let _ = std::sync::Weak::<Void>::new();
 }
diff --git a/tests/ui/binding/underscore-prefixed-function-argument.rs b/tests/ui/binding/underscore-prefixed-function-argument.rs
index 2014e0d23d8..e5b2ec1b5f0 100644
--- a/tests/ui/binding/underscore-prefixed-function-argument.rs
+++ b/tests/ui/binding/underscore-prefixed-function-argument.rs
@@ -1,11 +1,13 @@
-//@ run-pass
+//! Test that argument names starting with `_` are usable.
 
-fn good(_a: &isize) {
-}
+//@ run-pass
 
-// unnamed argument &isize is now parse x: &isize
+fn good(_a: &isize) {}
 
-fn called<F>(_f: F) where F: FnOnce(&isize) {
+fn called<F>(_f: F)
+where
+    F: FnOnce(&isize),
+{
 }
 
 pub fn main() {
diff --git a/tests/ui/borrowck/ownership-struct-update-moved-error.rs b/tests/ui/borrowck/ownership-struct-update-moved-error.rs
index ee1a77eb9a4..62fc1f42969 100644
--- a/tests/ui/borrowck/ownership-struct-update-moved-error.rs
+++ b/tests/ui/borrowck/ownership-struct-update-moved-error.rs
@@ -1,17 +1,19 @@
-struct Mine{
+//! Checks borrow after move error when using `self` consuming method with struct update syntax.
+
+struct Mine {
     test: String,
-    other_val: isize
+    other_val: isize,
 }
 
-impl Mine{
-    fn make_string_bar(mut self) -> Mine{
+impl Mine {
+    fn make_string_bar(mut self) -> Mine {
         self.test = "Bar".to_string();
         self
     }
 }
 
-fn main(){
-    let start = Mine{test:"Foo".to_string(), other_val:0};
-    let end = Mine{other_val:1, ..start.make_string_bar()};
+fn main() {
+    let start = Mine { test: "Foo".to_string(), other_val: 0 };
+    let end = Mine { other_val: 1, ..start.make_string_bar() };
     println!("{}", start.test); //~ ERROR borrow of moved value: `start`
 }
diff --git a/tests/ui/borrowck/ownership-struct-update-moved-error.stderr b/tests/ui/borrowck/ownership-struct-update-moved-error.stderr
index 34b501f8ec8..83cfc7bb412 100644
--- a/tests/ui/borrowck/ownership-struct-update-moved-error.stderr
+++ b/tests/ui/borrowck/ownership-struct-update-moved-error.stderr
@@ -1,17 +1,17 @@
 error[E0382]: borrow of moved value: `start`
-  --> $DIR/walk-struct-literal-with.rs:16:20
+  --> $DIR/ownership-struct-update-moved-error.rs:18:20
    |
-LL |     let start = Mine{test:"Foo".to_string(), other_val:0};
+LL |     let start = Mine { test: "Foo".to_string(), other_val: 0 };
    |         ----- move occurs because `start` has type `Mine`, which does not implement the `Copy` trait
-LL |     let end = Mine{other_val:1, ..start.make_string_bar()};
-   |                                         ----------------- `start` moved due to this method call
+LL |     let end = Mine { other_val: 1, ..start.make_string_bar() };
+   |                                            ----------------- `start` moved due to this method call
 LL |     println!("{}", start.test);
    |                    ^^^^^^^^^^ value borrowed here after move
    |
 note: `Mine::make_string_bar` takes ownership of the receiver `self`, which moves `start`
-  --> $DIR/walk-struct-literal-with.rs:7:28
+  --> $DIR/ownership-struct-update-moved-error.rs:9:28
    |
-LL |     fn make_string_bar(mut self) -> Mine{
+LL |     fn make_string_bar(mut self) -> Mine {
    |                            ^^^^
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/closures/no-capture-closure-call.rs b/tests/ui/closures/no-capture-closure-call.rs
index 5f42bcbe280..29e5ac635b4 100644
--- a/tests/ui/closures/no-capture-closure-call.rs
+++ b/tests/ui/closures/no-capture-closure-call.rs
@@ -1,3 +1,5 @@
+//! Sanity check for no capture closures
+
 //@ run-pass
 
 pub fn main() {
diff --git a/tests/ui/drop/box-drop-unused-value-statement-regression.rs b/tests/ui/drop/box-drop-unused-value-statement-regression.rs
index 3d5eff2c48d..43865e08444 100644
--- a/tests/ui/drop/box-drop-unused-value-statement-regression.rs
+++ b/tests/ui/drop/box-drop-unused-value-statement-regression.rs
@@ -1,12 +1,12 @@
-//@ run-pass
-// Issue #3878
-// Issue Name: Unused move causes a crash
-// Abstract: zero-fill to block after drop
-
+//! Regression test for a crash caused by an "unsused move"
+//! (specifically, a variable bound to a `Box` used as a statement)
+//! leading to incorrect memory zero-filling after drop.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/3878>.
 
-#![allow(path_statements)]
+//@ run-pass
 
 pub fn main() {
     let y: Box<_> = Box::new(1);
-    y;
+    drop(y);
 }
diff --git a/tests/ui/hashmap/hashset-enum-variant.rs b/tests/ui/hashmap/hashset-enum-variant.rs
index 5795cc527cf..39a59d3a39b 100644
--- a/tests/ui/hashmap/hashset-enum-variant.rs
+++ b/tests/ui/hashmap/hashset-enum-variant.rs
@@ -1,26 +1,27 @@
+//! Check for correct initialization of `HashSet` with enums. This is a regression test for a
+//! codegen bug that caused the `HashSet` to appear as if it contained one of each enum variant.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/42918>
+
 //@ run-pass
-//
-#![allow(dead_code)]
 //@ compile-flags: -O
 
+#![allow(dead_code)]
+
 use std::collections::HashSet;
 
 #[derive(PartialEq, Debug, Hash, Eq, Clone, PartialOrd, Ord)]
 enum MyEnum {
     E0,
-
     E1,
-
     E2,
     E3,
     E4,
-
     E5,
     E6,
     E7,
 }
 
-
 fn main() {
     use MyEnum::*;
     let s: HashSet<_> = [E4, E1].iter().cloned().collect();
diff --git a/tests/ui/io-checks/write-macro-error.rs b/tests/ui/io-checks/write-macro-error.rs
index b48fa3f11cc..857ea0024e1 100644
--- a/tests/ui/io-checks/write-macro-error.rs
+++ b/tests/ui/io-checks/write-macro-error.rs
@@ -1,3 +1,6 @@
+//! Tests that errors from both the writer (`Write::write`) and formatter (`Display::fmt`)
+//! are correctly propagated: writer errors return `Err`, formatter errors cause panics.
+
 //@ run-pass
 //@ needs-unwind
 
@@ -24,7 +27,9 @@ impl Write for ErrorWriter {
         Err(Error::new(WRITER_ERROR, "not connected"))
     }
 
-    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
 }
 
 fn main() {
@@ -37,7 +42,8 @@ fn main() {
     let err = res.expect_err("formatter error did not lead to panic").downcast::<&str>().unwrap();
     assert!(
         err.contains("formatting trait implementation returned an error"),
-        "unexpected panic: {}", err
+        "unexpected panic: {}",
+        err
     );
 
     // Writer error when there's some string before the first `{}`
@@ -50,6 +56,7 @@ fn main() {
     let err = res.expect_err("formatter error did not lead to panic").downcast::<&str>().unwrap();
     assert!(
         err.contains("formatting trait implementation returned an error"),
-        "unexpected panic: {}", err
+        "unexpected panic: {}",
+        err
     );
 }
diff --git a/tests/ui/lang-items/lang-item-unknown-definition-error.rs b/tests/ui/lang-items/lang-item-unknown-definition-error.rs
index ce206d20358..22812128c2d 100644
--- a/tests/ui/lang-items/lang-item-unknown-definition-error.rs
+++ b/tests/ui/lang-items/lang-item-unknown-definition-error.rs
@@ -1,9 +1,11 @@
+//! Checks that compiler prevernt attempting to define an unrecognized or unknown lang item
+
 #![allow(unused)]
 #![feature(lang_items)]
 
 #[lang = "foo"]
 fn bar() -> ! {
-//~^^ ERROR definition of an unknown lang item: `foo`
+    //~^^ ERROR definition of an unknown lang item: `foo`
     loop {}
 }
 
diff --git a/tests/ui/lang-items/lang-item-unknown-definition-error.stderr b/tests/ui/lang-items/lang-item-unknown-definition-error.stderr
index 832f1342418..3b939757ac2 100644
--- a/tests/ui/lang-items/lang-item-unknown-definition-error.stderr
+++ b/tests/ui/lang-items/lang-item-unknown-definition-error.stderr
@@ -1,5 +1,5 @@
 error[E0522]: definition of an unknown lang item: `foo`
-  --> $DIR/unknown-language-item.rs:4:1
+  --> $DIR/lang-item-unknown-definition-error.rs:6:1
    |
 LL | #[lang = "foo"]
    | ^^^^^^^^^^^^^^^ definition of unknown lang item `foo`
diff --git a/tests/ui/modules/module-qualified-paths-basic.rs b/tests/ui/modules/module-qualified-paths-basic.rs
index d948ffc1520..c02f6060caa 100644
--- a/tests/ui/modules/module-qualified-paths-basic.rs
+++ b/tests/ui/modules/module-qualified-paths-basic.rs
@@ -1,11 +1,20 @@
+//! Checks that functions from different modules are accessible via their fully-qualified paths.
+
 //@ run-pass
 
 mod foo {
-    pub fn x() -> isize { return 1; }
+    pub fn x() -> isize {
+        return 1;
+    }
 }
 
 mod bar {
-    pub fn y() -> isize { return 1; }
+    pub fn y() -> isize {
+        return 1;
+    }
 }
 
-pub fn main() { foo::x(); bar::y(); }
+pub fn main() {
+    foo::x();
+    bar::y();
+}
diff --git a/tests/ui/modules/module-use-nested-groups.rs b/tests/ui/modules/module-use-nested-groups.rs
index c5d66a86935..84d1f9141a8 100644
--- a/tests/ui/modules/module-use-nested-groups.rs
+++ b/tests/ui/modules/module-use-nested-groups.rs
@@ -1,3 +1,5 @@
+//! Checks complex `use` syntax and availability of types across nested modules.
+
 //@ run-pass
 
 mod a {
diff --git a/tests/ui/modules/primitive-type-module-deprecated-paths.rs b/tests/ui/modules/primitive-type-module-deprecated-paths.rs
index 6e8c7053c57..5c9d2a616b3 100644
--- a/tests/ui/modules/primitive-type-module-deprecated-paths.rs
+++ b/tests/ui/modules/primitive-type-module-deprecated-paths.rs
@@ -1,9 +1,10 @@
+//! Make sure the module level constants are still there and accessible even after
+//! the corresponding associated constants have been added, and later stabilized.
+
 //@ run-pass
 
-// Make sure the module level constants are still there and accessible even after
-// the corresponding associated constants have been added, and later stabilized.
 #![allow(deprecated, deprecated_in_future)]
-use std::{u16, f32};
+use std::{f32, u16};
 
 fn main() {
     let _ = u16::MAX;
diff --git a/tests/ui/modules/use-keyword-reexport-type-alias.rs b/tests/ui/modules/use-keyword-reexport-type-alias.rs
index 4f3d1ee500d..c62bd9687ae 100644
--- a/tests/ui/modules/use-keyword-reexport-type-alias.rs
+++ b/tests/ui/modules/use-keyword-reexport-type-alias.rs
@@ -1,18 +1,20 @@
+//! Checks module re-exports, aliasing with `pub use`,
+//! and calling private methods via `Self` in an impl block.
+
 //@ run-pass
 
 #![allow(unused_variables)]
 pub struct A;
 
 mod test {
-    pub use super :: A;
-
-    pub use self :: A as B;
+    pub use self::A as B;
+    pub use super::A;
 }
 
 impl A {
     fn f() {}
     fn g() {
-        Self :: f()
+        Self::f()
     }
 }
 
diff --git a/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs
index 943c7f79742..4325c8b111b 100644
--- a/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs
+++ b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs
@@ -1,3 +1,5 @@
+//! This test ensures that the unary negation operator (`-`) cannot be applied to unsigned ints
+
 fn main() {
     let x = -1 as usize; //~ ERROR: cannot apply unary operator `-`
     let x = (-1) as usize; //~ ERROR: cannot apply unary operator `-`
diff --git a/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr
index 0bedbc1accd..4ce870ded9f 100644
--- a/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr
+++ b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr
@@ -1,5 +1,5 @@
 error[E0600]: cannot apply unary operator `-` to type `usize`
-  --> $DIR/unsigned-literal-negation.rs:2:13
+  --> $DIR/unary-negation-unsigned-integer-error.rs:4:13
    |
 LL |     let x = -1 as usize;
    |             ^^ cannot apply unary operator `-`
@@ -12,7 +12,7 @@ LL +     let x = usize::MAX;
    |
 
 error[E0600]: cannot apply unary operator `-` to type `usize`
-  --> $DIR/unsigned-literal-negation.rs:3:13
+  --> $DIR/unary-negation-unsigned-integer-error.rs:5:13
    |
 LL |     let x = (-1) as usize;
    |             ^^^^ cannot apply unary operator `-`
@@ -25,7 +25,7 @@ LL +     let x = usize::MAX;
    |
 
 error[E0600]: cannot apply unary operator `-` to type `u32`
-  --> $DIR/unsigned-literal-negation.rs:4:18
+  --> $DIR/unary-negation-unsigned-integer-error.rs:6:18
    |
 LL |     let x: u32 = -1;
    |                  ^^ cannot apply unary operator `-`
diff --git a/tests/ui/panics/unwind-force-no-unwind-tables.rs b/tests/ui/panics/unwind-force-no-unwind-tables.rs
index fb8082e3188..2226e4dd03e 100644
--- a/tests/ui/panics/unwind-force-no-unwind-tables.rs
+++ b/tests/ui/panics/unwind-force-no-unwind-tables.rs
@@ -1,3 +1,7 @@
+//! This test checks that Rust's unwinding mechanism correctly executes `Drop`
+//! implementations during stack unwinding, even when unwind tables (`uwtable`)
+//! are explicitly disabled via `-C force-unwind-tables=n`.
+
 //@ run-pass
 //@ needs-unwind
 //@ ignore-windows target requires uwtable
@@ -26,9 +30,12 @@ fn increase(count: &mut u8) {
 
 fn main() {
     let mut count = 0;
-    assert!(panic::catch_unwind(AssertUnwindSafe(
-        #[inline(never)]
-        || increase(&mut count)
-    )).is_err());
+    assert!(
+        panic::catch_unwind(AssertUnwindSafe(
+            #[inline(never)]
+            || increase(&mut count)
+        ))
+        .is_err()
+    );
     assert_eq!(count, 1);
 }
diff --git a/tests/ui/process/process-spawn-failure.rs b/tests/ui/process/process-spawn-failure.rs
index 4a7f2bee9d9..0950b044c97 100644
--- a/tests/ui/process/process-spawn-failure.rs
+++ b/tests/ui/process/process-spawn-failure.rs
@@ -1,3 +1,9 @@
+//! Tests that repeatedly spawning a failing command does not create zombie processes.
+//! Spawns a deliberately invalid command multiple times, verifies each spawn fails,
+//! then uses `ps` (on Unix) to detect any leftover zombie (defunct) child processes.
+//! Checks Rust's process spawning cleans up resources properly.
+//! Skipped on platforms without `ps` utility.
+
 //@ run-pass
 //@ needs-subprocess
 //@ ignore-vxworks no 'ps'
@@ -36,35 +42,42 @@ fn find_zombies() {
     // the PPID column contains a "-" for the respective process.
     // Filter out any lines that have a "-" as the PPID as the PPID is
     // expected to be an integer.
-    let filtered_ps: Vec<_> = ps_output
-        .lines()
-        .filter(|line| line.split_whitespace().nth(1) != Some("-"))
-        .collect();
+    let filtered_ps: Vec<_> =
+        ps_output.lines().filter(|line| line.split_whitespace().nth(1) != Some("-")).collect();
 
     for (line_no, line) in filtered_ps.into_iter().enumerate() {
-        if 0 < line_no && 0 < line.len() &&
-           my_pid == line.split(' ').filter(|w| 0 < w.len()).nth(1)
-                         .expect("1st column should be PPID")
-                         .parse().ok()
-                         .expect("PPID string into integer") &&
-           line.contains("defunct") {
+        if 0 < line_no
+            && 0 < line.len()
+            && my_pid
+                == line
+                    .split(' ')
+                    .filter(|w| 0 < w.len())
+                    .nth(1)
+                    .expect("1st column should be PPID")
+                    .parse()
+                    .ok()
+                    .expect("PPID string into integer")
+            && line.contains("defunct")
+        {
             panic!("Zombie child {}", line);
         }
     }
 }
 
 #[cfg(windows)]
-fn find_zombies() { }
+fn find_zombies() {}
 
 fn main() {
     let too_long = format!("/NoSuchCommand{:0300}", 0u8);
 
-    let _failures = (0..100).map(|_| {
-        let mut cmd = Command::new(&too_long);
-        let failed = cmd.spawn();
-        assert!(failed.is_err(), "Make sure the command fails to spawn(): {:?}", cmd);
-        failed
-    }).collect::<Vec<_>>();
+    let _failures = (0..100)
+        .map(|_| {
+            let mut cmd = Command::new(&too_long);
+            let failed = cmd.spawn();
+            assert!(failed.is_err(), "Make sure the command fails to spawn(): {:?}", cmd);
+            failed
+        })
+        .collect::<Vec<_>>();
 
     find_zombies();
     // then _failures goes out of scope
diff --git a/tests/ui/process/windows-exit-code-still-active.rs b/tests/ui/process/windows-exit-code-still-active.rs
index e016343f8ba..e661a4f6adc 100644
--- a/tests/ui/process/windows-exit-code-still-active.rs
+++ b/tests/ui/process/windows-exit-code-still-active.rs
@@ -1,23 +1,21 @@
+//! On Windows the GetExitCodeProcess API is used to get the exit code of a
+//! process, but it's easy to mistake a process exiting with the code 259 as
+//! "still running" because this is the value of the STILL_ACTIVE constant. Make
+//! sure we handle this case in the standard library and correctly report the
+//! status.
+//!
+//! Note that this is disabled on unix as processes exiting with 259 will have
+//! their exit status truncated to 3 (only the lower 8 bits are used).
+
 //@ run-pass
-// On Windows the GetExitCodeProcess API is used to get the exit code of a
-// process, but it's easy to mistake a process exiting with the code 259 as
-// "still running" because this is the value of the STILL_ACTIVE constant. Make
-// sure we handle this case in the standard library and correctly report the
-// status.
-//
-// Note that this is disabled on unix as processes exiting with 259 will have
-// their exit status truncated to 3 (only the lower 8 bits are used).
 
 #[cfg(windows)]
 fn main() {
-    use std::process::{self, Command};
     use std::env;
+    use std::process::{self, Command};
 
     if env::args().len() == 1 {
-        let status = Command::new(env::current_exe().unwrap())
-                             .arg("foo")
-                             .status()
-                             .unwrap();
+        let status = Command::new(env::current_exe().unwrap()).arg("foo").status().unwrap();
         assert_eq!(status.code(), Some(259));
     } else {
         process::exit(259);
diff --git a/tests/ui/reachable/diverging-expressions-unreachable-code.rs b/tests/ui/reachable/diverging-expressions-unreachable-code.rs
index 9c5f7c8f451..bb56987775f 100644
--- a/tests/ui/reachable/diverging-expressions-unreachable-code.rs
+++ b/tests/ui/reachable/diverging-expressions-unreachable-code.rs
@@ -3,17 +3,17 @@
 #![allow(unused_must_use)]
 #![allow(unreachable_code)]
 
-#![allow(unused_variables)]
-#![allow(dead_code)]
-
-fn id(x: bool) -> bool { x }
-
-fn call_id() {
-    let c = panic!();
-    id(c);
+fn _id(x: bool) -> bool {
+    x
 }
 
-fn call_id_3() { id(return) && id(return); }
+fn _call_id() {
+    let _c = panic!();
+    _id(_c);
+}
 
-pub fn main() {
+fn _call_id_3() {
+    _id(return) && _id(return);
 }
+
+pub fn main() {}
diff --git a/tests/ui/reachable/unreachable-code-diverging-expressions.rs b/tests/ui/reachable/unreachable-code-diverging-expressions.rs
index 0c46a38d73f..00676418002 100644
--- a/tests/ui/reachable/unreachable-code-diverging-expressions.rs
+++ b/tests/ui/reachable/unreachable-code-diverging-expressions.rs
@@ -26,9 +26,13 @@ fn call_id_3() {
 
 fn ret_guard() {
     match 2 {
-      x if (return) => { x; }
-      x if let true = return => { x; }
-      _ => {}
+        x if (return) => {
+            x;
+        }
+        x if let true = return => {
+            x;
+        }
+        _ => {}
     }
 }
 
diff --git a/tests/ui/traits/virtual-call-parameter-handling.rs b/tests/ui/traits/virtual-call-parameter-handling.rs
index e80bd5768a4..71ed459d15a 100644
--- a/tests/ui/traits/virtual-call-parameter-handling.rs
+++ b/tests/ui/traits/virtual-call-parameter-handling.rs
@@ -1,5 +1,7 @@
-//! Regression test for https://github.com/rust-lang/rust/issues/137646.
-//! The parameter value at all calls to `check` should be `(1, 1, 1)`.
+//! This test checks the correct parameter handling during virtual method calls
+//! through a `dyn Trait` object.
+//!
+//! Regression test for: <https://github.com/rust-lang/rust/issues/137646>
 
 //@ run-pass
 
diff --git a/tests/ui/type/unit-type-basic-usages.rs b/tests/ui/type/unit-type-basic-usages.rs
index 04404fc3f5e..c3ee8067f59 100644
--- a/tests/ui/type/unit-type-basic-usages.rs
+++ b/tests/ui/type/unit-type-basic-usages.rs
@@ -1,16 +1,14 @@
-//@ run-pass
-
-#![allow(unused_assignments)]
-#![allow(unknown_lints)]
+//! Checks the basic usage of unit type
 
-#![allow(unused_variables)]
-#![allow(dead_assignment)]
+//@ run-pass
 
-fn f(u: ()) { return u; }
+fn f(u: ()) {
+    u
+}
 
 pub fn main() {
     let u1: () = ();
-    let mut u2: () = f(u1);
-    u2 = ();
-    return ();
+    let mut _u2: () = f(u1);
+    _u2 = ();
+    ()
 }
diff --git a/tests/ui/type/usize-no-generic-arguments.rs b/tests/ui/type/usize-no-generic-arguments.rs
index 4ab80d944a5..d4d1eea757c 100644
--- a/tests/ui/type/usize-no-generic-arguments.rs
+++ b/tests/ui/type/usize-no-generic-arguments.rs
@@ -1,3 +1,5 @@
+//! Sanity test that primitives cannot have const generics.
+
 fn foo() {
     let x: usize<foo>; //~ ERROR const arguments are not allowed on builtin type `usize`
 }
diff --git a/tests/ui/type/usize-no-generic-arguments.stderr b/tests/ui/type/usize-no-generic-arguments.stderr
index 9c081a287ed..f1f3456461f 100644
--- a/tests/ui/type/usize-no-generic-arguments.stderr
+++ b/tests/ui/type/usize-no-generic-arguments.stderr
@@ -1,5 +1,5 @@
 error[E0109]: const arguments are not allowed on builtin type `usize`
-  --> $DIR/usize-generic-argument-parent.rs:2:18
+  --> $DIR/usize-no-generic-arguments.rs:4:18
    |
 LL |     let x: usize<foo>;
    |            ----- ^^^ const argument not allowed
diff --git a/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs b/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs
index 82474d873b7..e587ca554fe 100644
--- a/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs
+++ b/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs
@@ -1,6 +1,9 @@
-//@ build-pass
-// Test the uninit() construct returning various empty types.
+//! This test checks that ZSTs can be safely initialized from
+//! `MaybeUninit::uninit().assume_init()` and `std::mem::uninitialized()`
+//! (which is deprecated). This is safe because ZSTs inherently
+//! require no actual memory initialization, as they occupy no memory.
 
+//@ build-pass
 
 use std::mem::MaybeUninit;
 
-- 
cgit 1.4.1-3-g733a5


From 61b172a34c94108d013a2d352901b4a5a06ad9ee Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Tue, 8 Jul 2025 18:10:58 -0600
Subject: test: Make one multi suggestion test unicode

---
 tests/ui/suggestions/multi-suggestion.ascii.stderr | 130 +++++++++++++++++++++
 tests/ui/suggestions/multi-suggestion.rs           |  22 ++++
 .../ui/suggestions/multi-suggestion.unicode.stderr | 130 +++++++++++++++++++++
 3 files changed, 282 insertions(+)
 create mode 100644 tests/ui/suggestions/multi-suggestion.ascii.stderr
 create mode 100644 tests/ui/suggestions/multi-suggestion.rs
 create mode 100644 tests/ui/suggestions/multi-suggestion.unicode.stderr

diff --git a/tests/ui/suggestions/multi-suggestion.ascii.stderr b/tests/ui/suggestions/multi-suggestion.ascii.stderr
new file mode 100644
index 00000000000..b6c7b9ed6df
--- /dev/null
+++ b/tests/ui/suggestions/multi-suggestion.ascii.stderr
@@ -0,0 +1,130 @@
+error[E0423]: expected function, tuple struct or tuple variant, found struct `std::collections::HashMap`
+  --> $DIR/multi-suggestion.rs:17:13
+   |
+LL |     let _ = std::collections::HashMap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
+   |
+   = note: `std::collections::HashMap` defined here
+   |
+help: you might have meant to use an associated function to build this type
+   |
+LL |     let _ = std::collections::HashMap::new();
+   |                                      +++++
+LL -     let _ = std::collections::HashMap();
+LL +     let _ = std::collections::HashMap::with_capacity(_);
+   |
+LL -     let _ = std::collections::HashMap();
+LL +     let _ = std::collections::HashMap::with_hasher(_);
+   |
+LL -     let _ = std::collections::HashMap();
+LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+   |
+help: consider using the `Default` trait
+   |
+LL |     let _ = <std::collections::HashMap as std::default::Default>::default();
+   |             +                          ++++++++++++++++++++++++++++++++++
+
+error[E0423]: cannot initialize a tuple struct which contains private fields
+  --> $DIR/multi-suggestion.rs:11:19
+   |
+LL |         wtf: Some(Box(U {
+   |                   ^^^
+   |
+note: constructor is not visible here due to private fields
+  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+   |
+   = note: private field
+   |
+   = note: private field
+help: you might have meant to use an associated function to build this type
+   |
+LL -         wtf: Some(Box(U {
+LL -             wtf: None,
+LL -             x: (),
+LL -         })),
+LL +         wtf: Some(Box::new(_)),
+   |
+LL -         wtf: Some(Box(U {
+LL -             wtf: None,
+LL -             x: (),
+LL -         })),
+LL +         wtf: Some(Box::new_uninit()),
+   |
+LL -         wtf: Some(Box(U {
+LL -             wtf: None,
+LL -             x: (),
+LL -         })),
+LL +         wtf: Some(Box::new_zeroed()),
+   |
+LL -         wtf: Some(Box(U {
+LL -             wtf: None,
+LL -             x: (),
+LL -         })),
+LL +         wtf: Some(Box::new_in(_, _)),
+   |
+     and 12 other candidates
+help: consider using the `Default` trait
+   |
+LL -         wtf: Some(Box(U {
+LL +         wtf: Some(<Box as std::default::Default>::default()),
+   |
+
+error: cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+  --> $DIR/multi-suggestion.rs:19:13
+   |
+LL |     let _ = std::collections::HashMap {};
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: private field `base` that was not provided
+help: you might have meant to use an associated function to build this type
+   |
+LL -     let _ = std::collections::HashMap {};
+LL +     let _ = std::collections::HashMap::new();
+   |
+LL -     let _ = std::collections::HashMap {};
+LL +     let _ = std::collections::HashMap::with_capacity(_);
+   |
+LL -     let _ = std::collections::HashMap {};
+LL +     let _ = std::collections::HashMap::with_hasher(_);
+   |
+LL -     let _ = std::collections::HashMap {};
+LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+   |
+help: consider using the `Default` trait
+   |
+LL -     let _ = std::collections::HashMap {};
+LL +     let _ = <std::collections::HashMap as std::default::Default>::default();
+   |
+
+error: cannot construct `Box<_, _>` with struct literal syntax due to private fields
+  --> $DIR/multi-suggestion.rs:21:13
+   |
+LL |     let _ = Box {};
+   |             ^^^
+   |
+   = note: private fields `0` and `1` that were not provided
+help: you might have meant to use an associated function to build this type
+   |
+LL -     let _ = Box {};
+LL +     let _ = Box::new(_);
+   |
+LL -     let _ = Box {};
+LL +     let _ = Box::new_uninit();
+   |
+LL -     let _ = Box {};
+LL +     let _ = Box::new_zeroed();
+   |
+LL -     let _ = Box {};
+LL +     let _ = Box::new_in(_, _);
+   |
+     and 12 other candidates
+help: consider using the `Default` trait
+   |
+LL -     let _ = Box {};
+LL +     let _ = <Box as std::default::Default>::default();
+   |
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0423`.
diff --git a/tests/ui/suggestions/multi-suggestion.rs b/tests/ui/suggestions/multi-suggestion.rs
new file mode 100644
index 00000000000..99d2407aa21
--- /dev/null
+++ b/tests/ui/suggestions/multi-suggestion.rs
@@ -0,0 +1,22 @@
+//@ revisions: ascii unicode
+//@[unicode] compile-flags: -Zunstable-options --error-format=human-unicode
+
+#![allow(dead_code)]
+struct U <T> {
+    wtf: Option<Box<U<T>>>,
+    x: T,
+}
+fn main() {
+    U {
+        wtf: Some(Box(U { //[ascii]~ ERROR cannot initialize a tuple struct which contains private fields
+            wtf: None,
+            x: (),
+        })),
+        x: ()
+    };
+    let _ = std::collections::HashMap();
+    //[ascii]~^ ERROR expected function, tuple struct or tuple variant, found struct `std::collections::HashMap`
+    let _ = std::collections::HashMap {};
+    //[ascii]~^ ERROR cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+    let _ = Box {}; //[ascii]~ ERROR cannot construct `Box<_, _>` with struct literal syntax due to private fields
+}
diff --git a/tests/ui/suggestions/multi-suggestion.unicode.stderr b/tests/ui/suggestions/multi-suggestion.unicode.stderr
new file mode 100644
index 00000000000..e0933606de0
--- /dev/null
+++ b/tests/ui/suggestions/multi-suggestion.unicode.stderr
@@ -0,0 +1,130 @@
+error[E0423]: expected function, tuple struct or tuple variant, found struct `std::collections::HashMap`
+   ╭▸ $DIR/multi-suggestion.rs:17:13
+   │
+LL │     let _ = std::collections::HashMap();
+   │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   ╭▸ $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
+   │
+   ╰ note: `std::collections::HashMap` defined here
+   ╰╴
+help: you might have meant to use an associated function to build this type
+   ╭╴
+LL │     let _ = std::collections::HashMap::new();
+   ├╴                                     +++++
+LL -     let _ = std::collections::HashMap();
+LL +     let _ = std::collections::HashMap::with_capacity(_);
+   ├╴
+LL -     let _ = std::collections::HashMap();
+LL +     let _ = std::collections::HashMap::with_hasher(_);
+   ├╴
+LL -     let _ = std::collections::HashMap();
+LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+   ╰╴
+help: consider using the `Default` trait
+   ╭╴
+LL │     let _ = <std::collections::HashMap as std::default::Default>::default();
+   ╰╴            +                          ++++++++++++++++++++++++++++++++++
+
+error[E0423]: cannot initialize a tuple struct which contains private fields
+   ╭▸ $DIR/multi-suggestion.rs:11:19
+   │
+LL │         wtf: Some(Box(U {
+   │                   ━━━
+   ╰╴
+note: constructor is not visible here due to private fields
+   ╭▸ $SRC_DIR/alloc/src/boxed.rs:LL:COL
+   │
+   ╰ note: private field
+   │
+   ╰ note: private field
+help: you might have meant to use an associated function to build this type
+   ╭╴
+LL -         wtf: Some(Box(U {
+LL -             wtf: None,
+LL -             x: (),
+LL -         })),
+LL +         wtf: Some(Box::new(_)),
+   ├╴
+LL -         wtf: Some(Box(U {
+LL -             wtf: None,
+LL -             x: (),
+LL -         })),
+LL +         wtf: Some(Box::new_uninit()),
+   ├╴
+LL -         wtf: Some(Box(U {
+LL -             wtf: None,
+LL -             x: (),
+LL -         })),
+LL +         wtf: Some(Box::new_zeroed()),
+   ├╴
+LL -         wtf: Some(Box(U {
+LL -             wtf: None,
+LL -             x: (),
+LL -         })),
+LL +         wtf: Some(Box::new_in(_, _)),
+   ╰╴
+     and 12 other candidates
+help: consider using the `Default` trait
+   ╭╴
+LL -         wtf: Some(Box(U {
+LL +         wtf: Some(<Box as std::default::Default>::default()),
+   ╰╴
+
+error: cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+   ╭▸ $DIR/multi-suggestion.rs:19:13
+   │
+LL │     let _ = std::collections::HashMap {};
+   │             ━━━━━━━━━━━━━━━━━━━━━━━━━
+   │
+   ╰ note: private field `base` that was not provided
+help: you might have meant to use an associated function to build this type
+   ╭╴
+LL -     let _ = std::collections::HashMap {};
+LL +     let _ = std::collections::HashMap::new();
+   ├╴
+LL -     let _ = std::collections::HashMap {};
+LL +     let _ = std::collections::HashMap::with_capacity(_);
+   ├╴
+LL -     let _ = std::collections::HashMap {};
+LL +     let _ = std::collections::HashMap::with_hasher(_);
+   ├╴
+LL -     let _ = std::collections::HashMap {};
+LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+   ╰╴
+help: consider using the `Default` trait
+   ╭╴
+LL -     let _ = std::collections::HashMap {};
+LL +     let _ = <std::collections::HashMap as std::default::Default>::default();
+   ╰╴
+
+error: cannot construct `Box<_, _>` with struct literal syntax due to private fields
+   ╭▸ $DIR/multi-suggestion.rs:21:13
+   │
+LL │     let _ = Box {};
+   │             ━━━
+   │
+   ╰ note: private fields `0` and `1` that were not provided
+help: you might have meant to use an associated function to build this type
+   ╭╴
+LL -     let _ = Box {};
+LL +     let _ = Box::new(_);
+   ├╴
+LL -     let _ = Box {};
+LL +     let _ = Box::new_uninit();
+   ├╴
+LL -     let _ = Box {};
+LL +     let _ = Box::new_zeroed();
+   ├╴
+LL -     let _ = Box {};
+LL +     let _ = Box::new_in(_, _);
+   ╰╴
+     and 12 other candidates
+help: consider using the `Default` trait
+   ╭╴
+LL -     let _ = Box {};
+LL +     let _ = <Box as std::default::Default>::default();
+   ╰╴
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0423`.
-- 
cgit 1.4.1-3-g733a5


From d67bf6095a9a3f278a223a20b316c235360c1c90 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Tue, 1 Jul 2025 19:09:45 -0600
Subject: chore: Improve how the other suggestions message gets rendered

---
 compiler/rustc_errors/src/emitter.rs                             | 9 +++++++--
 .../associated-types-in-ambiguous-context.stderr                 | 2 +-
 tests/ui/const-generics/issues/issue-82956.stderr                | 2 +-
 .../ui/did_you_mean/issue-56028-there-is-an-enum-variant.stderr  | 4 ++--
 tests/ui/impl-trait/call_method_without_import.no_import.stderr  | 2 +-
 tests/ui/imports/issue-56125.stderr                              | 2 +-
 tests/ui/lint/use_suggestion_json.stderr                         | 2 +-
 tests/ui/privacy/suggest-box-new.stderr                          | 4 ++--
 tests/ui/rust-2018/issue-52202-use-suggestions.stderr            | 2 +-
 tests/ui/suggestions/multi-suggestion.ascii.stderr               | 4 ++--
 tests/ui/suggestions/multi-suggestion.unicode.stderr             | 8 ++++----
 tests/ui/suggestions/too-many-field-suggestions.stderr           | 4 ++--
 12 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs
index 2f398cea926..1b581f93736 100644
--- a/compiler/rustc_errors/src/emitter.rs
+++ b/compiler/rustc_errors/src/emitter.rs
@@ -2446,17 +2446,22 @@ impl HumanEmitter {
                     | DisplaySuggestion::Underline => row_num - 1,
                     DisplaySuggestion::None => row_num,
                 };
-                self.draw_col_separator_end(&mut buffer, row, max_line_num_len + 1);
+                if other_suggestions > 0 {
+                    self.draw_col_separator_no_space(&mut buffer, row, max_line_num_len + 1);
+                } else {
+                    self.draw_col_separator_end(&mut buffer, row, max_line_num_len + 1);
+                }
                 row_num = row + 1;
             }
         }
         if other_suggestions > 0 {
+            self.draw_note_separator(&mut buffer, row_num, max_line_num_len + 1, false);
             let msg = format!(
                 "and {} other candidate{}",
                 other_suggestions,
                 pluralize!(other_suggestions)
             );
-            buffer.puts(row_num, max_line_num_len + 3, &msg, Style::NoStyle);
+            buffer.append(row_num, &msg, Style::NoStyle);
         }
 
         emit_to_destination(&buffer.render(), level, &mut self.dst, self.short_message)?;
diff --git a/tests/ui/associated-types/associated-types-in-ambiguous-context.stderr b/tests/ui/associated-types/associated-types-in-ambiguous-context.stderr
index a7647cf26aa..71a1360cb5a 100644
--- a/tests/ui/associated-types/associated-types-in-ambiguous-context.stderr
+++ b/tests/ui/associated-types/associated-types-in-ambiguous-context.stderr
@@ -42,7 +42,7 @@ LL + type X = <CString as Deref>::Target;
 LL - type X = std::ops::Deref::Target;
 LL + type X = <IoSlice<'_> as Deref>::Target;
    |
-     and N other candidates
+   = and N other candidates
 
 error[E0223]: ambiguous associated type
   --> $DIR/associated-types-in-ambiguous-context.rs:13:23
diff --git a/tests/ui/const-generics/issues/issue-82956.stderr b/tests/ui/const-generics/issues/issue-82956.stderr
index 5e380eea81c..fd93e5122a5 100644
--- a/tests/ui/const-generics/issues/issue-82956.stderr
+++ b/tests/ui/const-generics/issues/issue-82956.stderr
@@ -14,7 +14,7 @@ LL + use std::collections::btree_map::IntoIter;
    |
 LL + use std::collections::btree_set::IntoIter;
    |
-     and 9 other candidates
+   = and 9 other candidates
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/did_you_mean/issue-56028-there-is-an-enum-variant.stderr b/tests/ui/did_you_mean/issue-56028-there-is-an-enum-variant.stderr
index 927f9e842e6..12965800a02 100644
--- a/tests/ui/did_you_mean/issue-56028-there-is-an-enum-variant.stderr
+++ b/tests/ui/did_you_mean/issue-56028-there-is-an-enum-variant.stderr
@@ -18,7 +18,7 @@ LL + fn setup() -> Determine { Set }
 LL - fn setup() -> Set { Set }
 LL + fn setup() -> PutDown { Set }
    |
-     and 3 other candidates
+   = and 3 other candidates
 
 error[E0425]: cannot find value `Set` in this scope
   --> $DIR/issue-56028-there-is-an-enum-variant.rs:9:21
@@ -36,7 +36,7 @@ LL + use Determine::Set;
    |
 LL + use PutDown::Set;
    |
-     and 3 other candidates
+   = and 3 other candidates
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/impl-trait/call_method_without_import.no_import.stderr b/tests/ui/impl-trait/call_method_without_import.no_import.stderr
index 72982b695bb..e59409ea27e 100644
--- a/tests/ui/impl-trait/call_method_without_import.no_import.stderr
+++ b/tests/ui/impl-trait/call_method_without_import.no_import.stderr
@@ -30,7 +30,7 @@ LL + use std::fmt::Display;
    |
 LL + use std::fmt::LowerExp;
    |
-     and 5 other candidates
+   = and 5 other candidates
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/imports/issue-56125.stderr b/tests/ui/imports/issue-56125.stderr
index 81336d51df4..371130facf9 100644
--- a/tests/ui/imports/issue-56125.stderr
+++ b/tests/ui/imports/issue-56125.stderr
@@ -18,7 +18,7 @@ LL +     use ::issue_56125::issue_56125;
 LL -     use empty::issue_56125;
 LL +     use ::issue_56125::last_segment::issue_56125;
    |
-     and 1 other candidate
+   = and 1 other candidate
 
 error[E0659]: `issue_56125` is ambiguous
   --> $DIR/issue-56125.rs:6:9
diff --git a/tests/ui/lint/use_suggestion_json.stderr b/tests/ui/lint/use_suggestion_json.stderr
index 0d4304e2e2e..558c2260fce 100644
--- a/tests/ui/lint/use_suggestion_json.stderr
+++ b/tests/ui/lint/use_suggestion_json.stderr
@@ -419,7 +419,7 @@ mod foo {
 \u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m
 \u001b[0m\u001b[1m\u001b[38;5;12mLL\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[38;5;10m+ use std::collections::hash_map::Iter;\u001b[0m
 \u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m
-\u001b[0m     and 9 other candidates\u001b[0m
+\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m= \u001b[0m\u001b[0mand 9 other candidates\u001b[0m
 
 "
 }
diff --git a/tests/ui/privacy/suggest-box-new.stderr b/tests/ui/privacy/suggest-box-new.stderr
index b651348de29..6c47b52c9de 100644
--- a/tests/ui/privacy/suggest-box-new.stderr
+++ b/tests/ui/privacy/suggest-box-new.stderr
@@ -63,7 +63,7 @@ LL -             x: (),
 LL -         })),
 LL +         wtf: Some(Box::new_in(_, _)),
    |
-     and 12 other candidates
+   = and 12 other candidates
 help: consider using the `Default` trait
    |
 LL -         wtf: Some(Box(U {
@@ -118,7 +118,7 @@ LL +     let _ = Box::new_zeroed();
 LL -     let _ = Box {};
 LL +     let _ = Box::new_in(_, _);
    |
-     and 12 other candidates
+   = and 12 other candidates
 help: consider using the `Default` trait
    |
 LL -     let _ = Box {};
diff --git a/tests/ui/rust-2018/issue-52202-use-suggestions.stderr b/tests/ui/rust-2018/issue-52202-use-suggestions.stderr
index ee1a336ea98..0eb1d46637b 100644
--- a/tests/ui/rust-2018/issue-52202-use-suggestions.stderr
+++ b/tests/ui/rust-2018/issue-52202-use-suggestions.stderr
@@ -14,7 +14,7 @@ LL + use std::collections::hash_map::Drain;
    |
 LL + use std::collections::hash_set::Drain;
    |
-     and 3 other candidates
+   = and 3 other candidates
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/multi-suggestion.ascii.stderr b/tests/ui/suggestions/multi-suggestion.ascii.stderr
index b6c7b9ed6df..f2a146fbd52 100644
--- a/tests/ui/suggestions/multi-suggestion.ascii.stderr
+++ b/tests/ui/suggestions/multi-suggestion.ascii.stderr
@@ -63,7 +63,7 @@ LL -             x: (),
 LL -         })),
 LL +         wtf: Some(Box::new_in(_, _)),
    |
-     and 12 other candidates
+   = and 12 other candidates
 help: consider using the `Default` trait
    |
 LL -         wtf: Some(Box(U {
@@ -118,7 +118,7 @@ LL +     let _ = Box::new_zeroed();
 LL -     let _ = Box {};
 LL +     let _ = Box::new_in(_, _);
    |
-     and 12 other candidates
+   = and 12 other candidates
 help: consider using the `Default` trait
    |
 LL -     let _ = Box {};
diff --git a/tests/ui/suggestions/multi-suggestion.unicode.stderr b/tests/ui/suggestions/multi-suggestion.unicode.stderr
index e0933606de0..69df481579b 100644
--- a/tests/ui/suggestions/multi-suggestion.unicode.stderr
+++ b/tests/ui/suggestions/multi-suggestion.unicode.stderr
@@ -62,8 +62,8 @@ LL -             wtf: None,
 LL -             x: (),
 LL -         })),
 LL +         wtf: Some(Box::new_in(_, _)),
-   ╰╴
-     and 12 other candidates
+   │
+   ╰ and 12 other candidates
 help: consider using the `Default` trait
    ╭╴
 LL -         wtf: Some(Box(U {
@@ -117,8 +117,8 @@ LL +     let _ = Box::new_zeroed();
    ├╴
 LL -     let _ = Box {};
 LL +     let _ = Box::new_in(_, _);
-   ╰╴
-     and 12 other candidates
+   │
+   ╰ and 12 other candidates
 help: consider using the `Default` trait
    ╭╴
 LL -     let _ = Box {};
diff --git a/tests/ui/suggestions/too-many-field-suggestions.stderr b/tests/ui/suggestions/too-many-field-suggestions.stderr
index ac5c8cb60cc..0cb0c8bec07 100644
--- a/tests/ui/suggestions/too-many-field-suggestions.stderr
+++ b/tests/ui/suggestions/too-many-field-suggestions.stderr
@@ -17,7 +17,7 @@ LL |     t.a2.bar();
    |       +++
 LL |     t.a3.bar();
    |       +++
-     and 6 other candidates
+   = and 6 other candidates
 
 error[E0609]: no field `field` on type `Thing`
   --> $DIR/too-many-field-suggestions.rs:26:7
@@ -35,7 +35,7 @@ LL |     t.a2.field;
    |       +++
 LL |     t.a3.field;
    |       +++
-     and 6 other candidates
+   = and 6 other candidates
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 8d0e0c6d6fae36283c11535dcb88b52baf286fc5 Mon Sep 17 00:00:00 2001
From: Nia Espera <a5b6@riseup.net>
Date: Tue, 8 Jul 2025 10:47:01 +0200
Subject: interpret/allocation: expose init + write_wildcards on a range

---
 compiler/rustc_const_eval/src/interpret/memory.rs  |  2 +-
 .../rustc_middle/src/mir/interpret/allocation.rs   | 33 ++++++++++------------
 .../src/mir/interpret/allocation/provenance_map.rs | 28 ++++++++++++++----
 src/tools/miri/src/shims/native_lib/mod.rs         |  7 +++--
 4 files changed, 42 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 524023b8104..6053534266f 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -1472,7 +1472,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             dest_alloc
                 .write_uninit(&tcx, dest_range)
                 .map_err(|e| e.to_interp_error(dest_alloc_id))?;
-            // We can forget about the provenance, this is all not initialized anyway.
+            // `write_uninit` also resets the provenance, so we are done.
             return interp_ok(());
         }
 
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation.rs b/compiler/rustc_middle/src/mir/interpret/allocation.rs
index f039849d1bb..133111ff15d 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation.rs
@@ -101,6 +101,8 @@ pub struct Allocation<Prov: Provenance = CtfeProvenance, Extra = (), Bytes = Box
     /// at the given offset.
     provenance: ProvenanceMap<Prov>,
     /// Denotes which part of this allocation is initialized.
+    ///
+    /// Invariant: the uninitialized parts have no provenance.
     init_mask: InitMask,
     /// The alignment of the allocation to detect unaligned reads.
     /// (`Align` guarantees that this is a power of two.)
@@ -796,24 +798,19 @@ impl<Prov: Provenance, Extra, Bytes: AllocBytes> Allocation<Prov, Extra, Bytes>
         Ok(())
     }
 
-    /// Initialize all previously uninitialized bytes in the entire allocation, and set
-    /// provenance of everything to `Wildcard`. Before calling this, make sure all
-    /// provenance in this allocation is exposed!
-    pub fn prepare_for_native_access(&mut self) {
-        let full_range = AllocRange { start: Size::ZERO, size: Size::from_bytes(self.len()) };
-        // Overwrite uninitialized bytes with 0, to ensure we don't leak whatever their value happens to be.
-        for chunk in self.init_mask.range_as_init_chunks(full_range) {
-            if !chunk.is_init() {
-                let uninit_bytes = &mut self.bytes
-                    [chunk.range().start.bytes_usize()..chunk.range().end.bytes_usize()];
-                uninit_bytes.fill(0);
-            }
-        }
-        // Mark everything as initialized now.
-        self.mark_init(full_range, true);
-
-        // Set provenance of all bytes to wildcard.
-        self.provenance.write_wildcards(self.len());
+    /// Mark all bytes in the given range as initialised and reset the provenance
+    /// to wildcards. This entirely breaks the normal mechanisms for tracking
+    /// initialisation and is only provided for Miri operating in native-lib
+    /// mode. UB will be missed if the underlying bytes were not actually written to.
+    ///
+    /// If `range` is `None`, defaults to performing this on the whole allocation.
+    pub fn process_native_write(&mut self, cx: &impl HasDataLayout, range: Option<AllocRange>) {
+        let range = range.unwrap_or_else(|| AllocRange {
+            start: Size::ZERO,
+            size: Size::from_bytes(self.len()),
+        });
+        self.mark_init(range, true);
+        self.provenance.write_wildcards(cx, range);
     }
 
     /// Remove all provenance in the given memory range.
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
index 9c6e1664386..119d4be64e6 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
@@ -212,21 +212,37 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
         Ok(())
     }
 
-    /// Overwrites all provenance in the allocation with wildcard provenance.
+    /// Overwrites all provenance in the given range with wildcard provenance.
+    /// Pointers partially overwritten will have their provenances preserved
+    /// bytewise on their remaining bytes.
     ///
     /// Provided for usage in Miri and panics otherwise.
-    pub fn write_wildcards(&mut self, alloc_size: usize) {
+    pub fn write_wildcards(&mut self, cx: &impl HasDataLayout, range: AllocRange) {
         assert!(
             Prov::OFFSET_IS_ADDR,
             "writing wildcard provenance is not supported when `OFFSET_IS_ADDR` is false"
         );
         let wildcard = Prov::WILDCARD.unwrap();
 
-        // Remove all pointer provenances, then write wildcards into the whole byte range.
-        self.ptrs.clear();
-        let last = Size::from_bytes(alloc_size);
         let bytes = self.bytes.get_or_insert_with(Box::default);
-        for offset in Size::ZERO..last {
+
+        // Remove pointer provenances that overlap with the range, then readd the edge ones bytewise.
+        let ptr_range = Self::adjusted_range_ptrs(range, cx);
+        let ptrs = self.ptrs.range(ptr_range.clone());
+        if let Some((offset, prov)) = ptrs.first() {
+            for byte_ofs in *offset..range.start {
+                bytes.insert(byte_ofs, *prov);
+            }
+        }
+        if let Some((offset, prov)) = ptrs.last() {
+            for byte_ofs in range.end()..*offset + cx.data_layout().pointer_size() {
+                bytes.insert(byte_ofs, *prov);
+            }
+        }
+        self.ptrs.remove_range(ptr_range);
+
+        // Overwrite bytewise provenance.
+        for offset in range.start..range.end() {
             bytes.insert(offset, wildcard);
         }
     }
diff --git a/src/tools/miri/src/shims/native_lib/mod.rs b/src/tools/miri/src/shims/native_lib/mod.rs
index 9b30d8ce78b..02c3bde036d 100644
--- a/src/tools/miri/src/shims/native_lib/mod.rs
+++ b/src/tools/miri/src/shims/native_lib/mod.rs
@@ -231,7 +231,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             .collect::<Vec<libffi::high::Arg<'_>>>();
 
         // Prepare all exposed memory (both previously exposed, and just newly exposed since a
-        // pointer was passed as argument).
+        // pointer was passed as argument). Uninitialised memory is left as-is, but any data
+        // exposed this way is garbage anyway.
         this.visit_reachable_allocs(this.exposed_allocs(), |this, alloc_id, info| {
             // If there is no data behind this pointer, skip this.
             if !matches!(info.kind, AllocKind::LiveData) {
@@ -251,8 +252,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
             // Prepare for possible write from native code if mutable.
             if info.mutbl.is_mut() {
-                let alloc = &mut this.get_alloc_raw_mut(alloc_id)?.0;
-                alloc.prepare_for_native_access();
+                let (alloc, cx) = this.get_alloc_raw_mut(alloc_id)?;
+                alloc.process_native_write(&cx.tcx, None);
                 // Also expose *mutable* provenance for the interpreter-level allocation.
                 std::hint::black_box(alloc.get_bytes_unchecked_raw_mut().expose_provenance());
             }
-- 
cgit 1.4.1-3-g733a5


From df53b3dc04950d980bd28ec4b04f48cd0cd01237 Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Thu, 10 Jul 2025 10:25:29 -0500
Subject: test(lexer): Add frontmatter unit test

---
 compiler/rustc_lexer/src/tests.rs | 86 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 84 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_lexer/src/tests.rs b/compiler/rustc_lexer/src/tests.rs
index a9fcb481759..a7357ba38c8 100644
--- a/compiler/rustc_lexer/src/tests.rs
+++ b/compiler/rustc_lexer/src/tests.rs
@@ -124,9 +124,9 @@ fn test_valid_shebang() {
     assert_eq!(strip_shebang(input), None);
 }
 
-fn check_lexing(src: &str, expect: Expect) {
+fn check_lexing(src: &str, frontmatter_allowed: FrontmatterAllowed, expect: Expect) {
     let actual: String =
-        tokenize(src, FrontmatterAllowed::No).map(|token| format!("{:?}\n", token)).collect();
+        tokenize(src, frontmatter_allowed).map(|token| format!("{:?}\n", token)).collect();
     expect.assert_eq(&actual)
 }
 
@@ -134,6 +134,7 @@ fn check_lexing(src: &str, expect: Expect) {
 fn smoke_test() {
     check_lexing(
         "/* my source file */ fn main() { println!(\"zebra\"); }\n",
+        FrontmatterAllowed::No,
         expect![[r#"
             Token { kind: BlockComment { doc_style: None, terminated: true }, len: 20 }
             Token { kind: Whitespace, len: 1 }
@@ -172,6 +173,7 @@ fn comment_flavors() {
 /** outer doc block */
 /*! inner doc block */
 ",
+        FrontmatterAllowed::No,
         expect![[r#"
             Token { kind: Whitespace, len: 1 }
             Token { kind: LineComment { doc_style: None }, len: 7 }
@@ -200,6 +202,7 @@ fn comment_flavors() {
 fn nested_block_comments() {
     check_lexing(
         "/* /* */ */'a'",
+        FrontmatterAllowed::No,
         expect![[r#"
             Token { kind: BlockComment { doc_style: None, terminated: true }, len: 11 }
             Token { kind: Literal { kind: Char { terminated: true }, suffix_start: 3 }, len: 3 }
@@ -211,6 +214,7 @@ fn nested_block_comments() {
 fn characters() {
     check_lexing(
         "'a' ' ' '\\n'",
+        FrontmatterAllowed::No,
         expect![[r#"
             Token { kind: Literal { kind: Char { terminated: true }, suffix_start: 3 }, len: 3 }
             Token { kind: Whitespace, len: 1 }
@@ -225,6 +229,7 @@ fn characters() {
 fn lifetime() {
     check_lexing(
         "'abc",
+        FrontmatterAllowed::No,
         expect![[r#"
             Token { kind: Lifetime { starts_with_number: false }, len: 4 }
         "#]],
@@ -235,6 +240,7 @@ fn lifetime() {
 fn raw_string() {
     check_lexing(
         "r###\"\"#a\\b\x00c\"\"###",
+        FrontmatterAllowed::No,
         expect![[r#"
             Token { kind: Literal { kind: RawStr { n_hashes: Some(3) }, suffix_start: 17 }, len: 17 }
         "#]],
@@ -258,6 +264,7 @@ b"a"
 r###"raw"###suffix
 br###"raw"###suffix
 "####,
+        FrontmatterAllowed::No,
         expect![[r#"
             Token { kind: Whitespace, len: 1 }
             Token { kind: Literal { kind: Char { terminated: true }, suffix_start: 3 }, len: 3 }
@@ -287,3 +294,78 @@ br###"raw"###suffix
         "#]],
     )
 }
+
+#[test]
+fn frontmatter_allowed() {
+    check_lexing(
+        r#"
+---cargo
+[dependencies]
+clap = "4"
+---
+
+fn main() {}
+"#,
+        FrontmatterAllowed::Yes,
+        expect![[r#"
+            Token { kind: Whitespace, len: 1 }
+            Token { kind: Frontmatter { has_invalid_preceding_whitespace: false, invalid_infostring: false }, len: 38 }
+            Token { kind: Whitespace, len: 2 }
+            Token { kind: Ident, len: 2 }
+            Token { kind: Whitespace, len: 1 }
+            Token { kind: Ident, len: 4 }
+            Token { kind: OpenParen, len: 1 }
+            Token { kind: CloseParen, len: 1 }
+            Token { kind: Whitespace, len: 1 }
+            Token { kind: OpenBrace, len: 1 }
+            Token { kind: CloseBrace, len: 1 }
+            Token { kind: Whitespace, len: 1 }
+        "#]],
+    )
+}
+
+#[test]
+fn frontmatter_disallowed() {
+    check_lexing(
+        r#"
+---cargo
+[dependencies]
+clap = "4"
+---
+
+fn main() {}
+"#,
+        FrontmatterAllowed::No,
+        expect![[r#"
+            Token { kind: Whitespace, len: 1 }
+            Token { kind: Minus, len: 1 }
+            Token { kind: Minus, len: 1 }
+            Token { kind: Minus, len: 1 }
+            Token { kind: Ident, len: 5 }
+            Token { kind: Whitespace, len: 1 }
+            Token { kind: OpenBracket, len: 1 }
+            Token { kind: Ident, len: 12 }
+            Token { kind: CloseBracket, len: 1 }
+            Token { kind: Whitespace, len: 1 }
+            Token { kind: Ident, len: 4 }
+            Token { kind: Whitespace, len: 1 }
+            Token { kind: Eq, len: 1 }
+            Token { kind: Whitespace, len: 1 }
+            Token { kind: Literal { kind: Str { terminated: true }, suffix_start: 3 }, len: 3 }
+            Token { kind: Whitespace, len: 1 }
+            Token { kind: Minus, len: 1 }
+            Token { kind: Minus, len: 1 }
+            Token { kind: Minus, len: 1 }
+            Token { kind: Whitespace, len: 2 }
+            Token { kind: Ident, len: 2 }
+            Token { kind: Whitespace, len: 1 }
+            Token { kind: Ident, len: 4 }
+            Token { kind: OpenParen, len: 1 }
+            Token { kind: CloseParen, len: 1 }
+            Token { kind: Whitespace, len: 1 }
+            Token { kind: OpenBrace, len: 1 }
+            Token { kind: CloseBrace, len: 1 }
+            Token { kind: Whitespace, len: 1 }
+        "#]],
+    )
+}
-- 
cgit 1.4.1-3-g733a5


From a11ee5614c052d6339c56c2673780468c96dbc16 Mon Sep 17 00:00:00 2001
From: Ed Page <eopage@gmail.com>
Date: Wed, 9 Jul 2025 15:35:52 -0500
Subject: fix: Include frontmatter in -Zunpretty output

In the implementation (#140035), this was left as an open question for
the tracking issue (#136889).  My assumption is that this should be
carried over.

Thankfully, either way, `-Zunpretty` is unstable and we can always
change it even if we stabilize frontmatter.
---
 compiler/rustc_ast_pretty/src/pprust/state.rs | 10 +++++++++-
 tests/ui/unpretty/frontmatter.stdout          |  2 ++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 9d656253f72..def0cb74d29 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -120,7 +120,7 @@ fn gather_comments(sm: &SourceMap, path: FileName, src: String) -> Vec<Comment>
         pos += shebang_len;
     }
 
-    for token in rustc_lexer::tokenize(&text[pos..], rustc_lexer::FrontmatterAllowed::No) {
+    for token in rustc_lexer::tokenize(&text[pos..], rustc_lexer::FrontmatterAllowed::Yes) {
         let token_text = &text[pos..pos + token.len as usize];
         match token.kind {
             rustc_lexer::TokenKind::Whitespace => {
@@ -171,6 +171,14 @@ fn gather_comments(sm: &SourceMap, path: FileName, src: String) -> Vec<Comment>
                     })
                 }
             }
+            rustc_lexer::TokenKind::Frontmatter { .. } => {
+                code_to_the_left = false;
+                comments.push(Comment {
+                    style: CommentStyle::Isolated,
+                    lines: vec![token_text.to_string()],
+                    pos: start_bpos + BytePos(pos as u32),
+                });
+            }
             _ => {
                 code_to_the_left = true;
             }
diff --git a/tests/ui/unpretty/frontmatter.stdout b/tests/ui/unpretty/frontmatter.stdout
index 9ad6bbbe577..2ccbb1b2582 100644
--- a/tests/ui/unpretty/frontmatter.stdout
+++ b/tests/ui/unpretty/frontmatter.stdout
@@ -1,3 +1,5 @@
+---
+---
 
 //@ compile-flags: -Zunpretty=normal
 //@ check-pass
-- 
cgit 1.4.1-3-g733a5


From 889582e704e516ab22a685711ef593a98fd9021a Mon Sep 17 00:00:00 2001
From: Mu001999 <mu001999@outlook.com>
Date: Sun, 6 Jul 2025 14:07:25 +0800
Subject: Check assoc consts and tys later like assoc fns

---
 compiler/rustc_passes/src/dead.rs                  | 70 ++++++++++++++--------
 .../equality-unused-issue-126729.rs                | 44 ++++++++++++++
 tests/ui/const-generics/cross_crate_complex.rs     |  1 +
 .../generic-associated-types/missing-bounds.fixed  |  2 +
 .../ui/generic-associated-types/missing-bounds.rs  |  2 +
 .../generic-associated-types/missing-bounds.stderr | 18 +++---
 .../dead-code/unused-trait-with-assoc-const.rs     | 13 ++++
 .../dead-code/unused-trait-with-assoc-const.stderr | 20 +++++++
 .../lint/dead-code/unused-trait-with-assoc-ty.rs   | 11 ++++
 .../dead-code/unused-trait-with-assoc-ty.stderr    | 20 +++++++
 tests/ui/pattern/issue-22546.rs                    |  2 +-
 tests/ui/pattern/issue-22546.stderr                | 10 ----
 12 files changed, 169 insertions(+), 44 deletions(-)
 create mode 100644 tests/ui/associated-consts/equality-unused-issue-126729.rs
 create mode 100644 tests/ui/lint/dead-code/unused-trait-with-assoc-const.rs
 create mode 100644 tests/ui/lint/dead-code/unused-trait-with-assoc-const.stderr
 create mode 100644 tests/ui/lint/dead-code/unused-trait-with-assoc-ty.rs
 create mode 100644 tests/ui/lint/dead-code/unused-trait-with-assoc-ty.stderr
 delete mode 100644 tests/ui/pattern/issue-22546.stderr

diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
index cdfd1a2b07e..35d6f22fd3b 100644
--- a/compiler/rustc_passes/src/dead.rs
+++ b/compiler/rustc_passes/src/dead.rs
@@ -18,7 +18,7 @@ use rustc_hir::{self as hir, ImplItem, ImplItemKind, Node, PatKind, QPath, TyKin
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::middle::privacy::Level;
 use rustc_middle::query::Providers;
-use rustc_middle::ty::{self, TyCtxt};
+use rustc_middle::ty::{self, AssocTag, TyCtxt};
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint::builtin::DEAD_CODE;
 use rustc_session::lint::{self, LintExpectationId};
@@ -115,7 +115,10 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
 
     fn handle_res(&mut self, res: Res) {
         match res {
-            Res::Def(DefKind::Const | DefKind::AssocConst | DefKind::TyAlias, def_id) => {
+            Res::Def(
+                DefKind::Const | DefKind::AssocConst | DefKind::AssocTy | DefKind::TyAlias,
+                def_id,
+            ) => {
                 self.check_def_id(def_id);
             }
             _ if self.in_pat => {}
@@ -482,7 +485,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
     ) -> bool {
         let trait_def_id = match self.tcx.def_kind(local_def_id) {
             // assoc impl items of traits are live if the corresponding trait items are live
-            DefKind::AssocFn => self
+            DefKind::AssocConst | DefKind::AssocTy | DefKind::AssocFn => self
                 .tcx
                 .associated_item(local_def_id)
                 .trait_item_def_id
@@ -647,6 +650,31 @@ impl<'tcx> Visitor<'tcx> for MarkSymbolVisitor<'tcx> {
 
         self.in_pat = in_pat;
     }
+
+    fn visit_trait_ref(&mut self, t: &'tcx hir::TraitRef<'tcx>) {
+        if let Some(trait_def_id) = t.path.res.opt_def_id()
+            && let Some(segment) = t.path.segments.last()
+            && let Some(args) = segment.args
+        {
+            for constraint in args.constraints {
+                if let Some(local_def_id) = self
+                    .tcx
+                    .associated_items(trait_def_id)
+                    .find_by_ident_and_kind(
+                        self.tcx,
+                        constraint.ident,
+                        AssocTag::Const,
+                        trait_def_id,
+                    )
+                    .and_then(|item| item.def_id.as_local())
+                {
+                    self.worklist.push((local_def_id, ComesFromAllowExpect::No));
+                }
+            }
+        }
+
+        intravisit::walk_trait_ref(self, t);
+    }
 }
 
 fn has_allow_dead_code_or_lang_attr(
@@ -744,18 +772,12 @@ fn check_item<'tcx>(
                 {
                     worklist.push((local_def_id, comes_from_allow));
                 } else if of_trait {
-                    // FIXME: This condition can be removed
-                    // if we support dead check for assoc consts and tys.
-                    if !matches!(tcx.def_kind(local_def_id), DefKind::AssocFn) {
-                        worklist.push((local_def_id, ComesFromAllowExpect::No));
-                    } else {
-                        // We only care about associated items of traits,
-                        // because they cannot be visited directly,
-                        // so we later mark them as live if their corresponding traits
-                        // or trait items and self types are both live,
-                        // but inherent associated items can be visited and marked directly.
-                        unsolved_items.push((id, local_def_id));
-                    }
+                    // We only care about associated items of traits,
+                    // because they cannot be visited directly,
+                    // so we later mark them as live if their corresponding traits
+                    // or trait items and self types are both live,
+                    // but inherent associated items can be visited and marked directly.
+                    unsolved_items.push((id, local_def_id));
                 }
             }
         }
@@ -791,15 +813,14 @@ fn check_trait_item(
     worklist: &mut Vec<(LocalDefId, ComesFromAllowExpect)>,
     id: hir::TraitItemId,
 ) {
-    use hir::TraitItemKind::{Const, Fn};
-    if matches!(tcx.def_kind(id.owner_id), DefKind::AssocConst | DefKind::AssocFn) {
-        let trait_item = tcx.hir_trait_item(id);
-        if matches!(trait_item.kind, Const(_, Some(_)) | Fn(..))
-            && let Some(comes_from_allow) =
-                has_allow_dead_code_or_lang_attr(tcx, trait_item.owner_id.def_id)
-        {
-            worklist.push((trait_item.owner_id.def_id, comes_from_allow));
-        }
+    use hir::TraitItemKind::{Const, Fn, Type};
+
+    let trait_item = tcx.hir_trait_item(id);
+    if matches!(trait_item.kind, Const(_, Some(_)) | Type(_, Some(_)) | Fn(..))
+        && let Some(comes_from_allow) =
+            has_allow_dead_code_or_lang_attr(tcx, trait_item.owner_id.def_id)
+    {
+        worklist.push((trait_item.owner_id.def_id, comes_from_allow));
     }
 }
 
@@ -1163,6 +1184,7 @@ impl<'tcx> DeadVisitor<'tcx> {
         }
         match self.tcx.def_kind(def_id) {
             DefKind::AssocConst
+            | DefKind::AssocTy
             | DefKind::AssocFn
             | DefKind::Fn
             | DefKind::Static { .. }
diff --git a/tests/ui/associated-consts/equality-unused-issue-126729.rs b/tests/ui/associated-consts/equality-unused-issue-126729.rs
new file mode 100644
index 00000000000..1482b874b9d
--- /dev/null
+++ b/tests/ui/associated-consts/equality-unused-issue-126729.rs
@@ -0,0 +1,44 @@
+//@ check-pass
+
+#![feature(associated_const_equality)]
+#![deny(dead_code)]
+
+trait Tr {
+    const I: i32;
+}
+
+impl Tr for () {
+    const I: i32 = 1;
+}
+
+fn foo() -> impl Tr<I = 1> {}
+
+trait Tr2 {
+    const J: i32;
+    const K: i32;
+}
+
+impl Tr2 for () {
+    const J: i32 = 1;
+    const K: i32 = 1;
+}
+
+fn foo2() -> impl Tr2<J = 1, K = 1> {}
+
+mod t {
+    pub trait Tr3 {
+        const L: i32;
+    }
+
+    impl Tr3 for () {
+        const L: i32 = 1;
+    }
+}
+
+fn foo3() -> impl t::Tr3<L = 1> {}
+
+fn main() {
+    foo();
+    foo2();
+    foo3();
+}
diff --git a/tests/ui/const-generics/cross_crate_complex.rs b/tests/ui/const-generics/cross_crate_complex.rs
index d13b69aa0cf..b44d889f5e9 100644
--- a/tests/ui/const-generics/cross_crate_complex.rs
+++ b/tests/ui/const-generics/cross_crate_complex.rs
@@ -11,6 +11,7 @@ async fn foo() {
     async_in_foo(async_out_foo::<4>().await).await;
 }
 
+#[allow(dead_code)]
 struct Faz<const N: usize>;
 
 impl<const N: usize> Foo<N> for Faz<N> {}
diff --git a/tests/ui/generic-associated-types/missing-bounds.fixed b/tests/ui/generic-associated-types/missing-bounds.fixed
index 703d3c1e0fb..15cdd44d7f1 100644
--- a/tests/ui/generic-associated-types/missing-bounds.fixed
+++ b/tests/ui/generic-associated-types/missing-bounds.fixed
@@ -1,5 +1,7 @@
 //@ run-rustfix
 
+#![allow(dead_code)]
+
 use std::ops::Add;
 
 struct A<B>(B);
diff --git a/tests/ui/generic-associated-types/missing-bounds.rs b/tests/ui/generic-associated-types/missing-bounds.rs
index f40b4228873..dad111c8c15 100644
--- a/tests/ui/generic-associated-types/missing-bounds.rs
+++ b/tests/ui/generic-associated-types/missing-bounds.rs
@@ -1,5 +1,7 @@
 //@ run-rustfix
 
+#![allow(dead_code)]
+
 use std::ops::Add;
 
 struct A<B>(B);
diff --git a/tests/ui/generic-associated-types/missing-bounds.stderr b/tests/ui/generic-associated-types/missing-bounds.stderr
index 13e4d249876..97b88c26e3b 100644
--- a/tests/ui/generic-associated-types/missing-bounds.stderr
+++ b/tests/ui/generic-associated-types/missing-bounds.stderr
@@ -1,5 +1,5 @@
 error: equality constraints are not yet supported in `where` clauses
-  --> $DIR/missing-bounds.rs:37:33
+  --> $DIR/missing-bounds.rs:39:33
    |
 LL | impl<B: Add> Add for E<B> where <B as Add>::Output = B {
    |                                 ^^^^^^^^^^^^^^^^^^^^^^ not supported
@@ -12,7 +12,7 @@ LL + impl<B: Add> Add for E<B> where B: Add<Output = B> {
    |
 
 error[E0308]: mismatched types
-  --> $DIR/missing-bounds.rs:11:11
+  --> $DIR/missing-bounds.rs:13:11
    |
 LL | impl<B> Add for A<B> where B: Add {
    |      - expected this type parameter
@@ -25,14 +25,14 @@ LL |         A(self.0 + rhs.0)
    = note: expected type parameter `B`
              found associated type `<B as Add>::Output`
 help: the type constructed contains `<B as Add>::Output` due to the type of the argument passed
-  --> $DIR/missing-bounds.rs:11:9
+  --> $DIR/missing-bounds.rs:13:9
    |
 LL |         A(self.0 + rhs.0)
    |         ^^--------------^
    |           |
    |           this argument influences the type of `A`
 note: tuple struct defined here
-  --> $DIR/missing-bounds.rs:5:8
+  --> $DIR/missing-bounds.rs:7:8
    |
 LL | struct A<B>(B);
    |        ^
@@ -42,7 +42,7 @@ LL | impl<B> Add for A<B> where B: Add<Output = B> {
    |                                  ++++++++++++
 
 error[E0308]: mismatched types
-  --> $DIR/missing-bounds.rs:21:14
+  --> $DIR/missing-bounds.rs:23:14
    |
 LL | impl<B: Add> Add for C<B> {
    |      - expected this type parameter
@@ -55,7 +55,7 @@ LL |         Self(self.0 + rhs.0)
    = note: expected type parameter `B`
              found associated type `<B as Add>::Output`
 note: tuple struct defined here
-  --> $DIR/missing-bounds.rs:15:8
+  --> $DIR/missing-bounds.rs:17:8
    |
 LL | struct C<B>(B);
    |        ^
@@ -65,7 +65,7 @@ LL | impl<B: Add<Output = B>> Add for C<B> {
    |            ++++++++++++
 
 error[E0369]: cannot add `B` to `B`
-  --> $DIR/missing-bounds.rs:31:21
+  --> $DIR/missing-bounds.rs:33:21
    |
 LL |         Self(self.0 + rhs.0)
    |              ------ ^ ----- B
@@ -78,7 +78,7 @@ LL | impl<B: std::ops::Add<Output = B>> Add for D<B> {
    |       +++++++++++++++++++++++++++
 
 error[E0308]: mismatched types
-  --> $DIR/missing-bounds.rs:42:14
+  --> $DIR/missing-bounds.rs:44:14
    |
 LL | impl<B: Add> Add for E<B> where <B as Add>::Output = B {
    |      - expected this type parameter
@@ -91,7 +91,7 @@ LL |         Self(self.0 + rhs.0)
    = note: expected type parameter `B`
              found associated type `<B as Add>::Output`
 note: tuple struct defined here
-  --> $DIR/missing-bounds.rs:35:8
+  --> $DIR/missing-bounds.rs:37:8
    |
 LL | struct E<B>(B);
    |        ^
diff --git a/tests/ui/lint/dead-code/unused-trait-with-assoc-const.rs b/tests/ui/lint/dead-code/unused-trait-with-assoc-const.rs
new file mode 100644
index 00000000000..8259e932c64
--- /dev/null
+++ b/tests/ui/lint/dead-code/unused-trait-with-assoc-const.rs
@@ -0,0 +1,13 @@
+#![deny(dead_code)]
+
+trait Tr { //~ ERROR trait `Tr` is never used
+    const I: Self;
+}
+
+struct Foo; //~ ERROR struct `Foo` is never constructed
+
+impl Tr for Foo {
+    const I: Self = Foo;
+}
+
+fn main() {}
diff --git a/tests/ui/lint/dead-code/unused-trait-with-assoc-const.stderr b/tests/ui/lint/dead-code/unused-trait-with-assoc-const.stderr
new file mode 100644
index 00000000000..ec894210f71
--- /dev/null
+++ b/tests/ui/lint/dead-code/unused-trait-with-assoc-const.stderr
@@ -0,0 +1,20 @@
+error: trait `Tr` is never used
+  --> $DIR/unused-trait-with-assoc-const.rs:3:7
+   |
+LL | trait Tr {
+   |       ^^
+   |
+note: the lint level is defined here
+  --> $DIR/unused-trait-with-assoc-const.rs:1:9
+   |
+LL | #![deny(dead_code)]
+   |         ^^^^^^^^^
+
+error: struct `Foo` is never constructed
+  --> $DIR/unused-trait-with-assoc-const.rs:7:8
+   |
+LL | struct Foo;
+   |        ^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.rs b/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.rs
new file mode 100644
index 00000000000..e8116d83ebf
--- /dev/null
+++ b/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.rs
@@ -0,0 +1,11 @@
+#![deny(dead_code)]
+
+struct T1; //~ ERROR struct `T1` is never constructed
+
+trait Foo { type Unused; } //~ ERROR trait `Foo` is never used
+impl Foo for T1 { type Unused = Self; }
+
+pub trait Bar { type Used; }
+impl Bar for T1 { type Used = Self; }
+
+fn main() {}
diff --git a/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.stderr b/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.stderr
new file mode 100644
index 00000000000..ab73c640634
--- /dev/null
+++ b/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.stderr
@@ -0,0 +1,20 @@
+error: struct `T1` is never constructed
+  --> $DIR/unused-trait-with-assoc-ty.rs:3:8
+   |
+LL | struct T1;
+   |        ^^
+   |
+note: the lint level is defined here
+  --> $DIR/unused-trait-with-assoc-ty.rs:1:9
+   |
+LL | #![deny(dead_code)]
+   |         ^^^^^^^^^
+
+error: trait `Foo` is never used
+  --> $DIR/unused-trait-with-assoc-ty.rs:5:7
+   |
+LL | trait Foo { type Unused; }
+   |       ^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/pattern/issue-22546.rs b/tests/ui/pattern/issue-22546.rs
index 81908017b4e..cf128d185df 100644
--- a/tests/ui/pattern/issue-22546.rs
+++ b/tests/ui/pattern/issue-22546.rs
@@ -15,7 +15,7 @@ impl<T: std::fmt::Display> Foo<T> {
     }
 }
 
-trait Tr { //~ WARN trait `Tr` is never used
+trait Tr {
     type U;
 }
 
diff --git a/tests/ui/pattern/issue-22546.stderr b/tests/ui/pattern/issue-22546.stderr
deleted file mode 100644
index e067a95e422..00000000000
--- a/tests/ui/pattern/issue-22546.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-warning: trait `Tr` is never used
-  --> $DIR/issue-22546.rs:18:7
-   |
-LL | trait Tr {
-   |       ^^
-   |
-   = note: `#[warn(dead_code)]` on by default
-
-warning: 1 warning emitted
-
-- 
cgit 1.4.1-3-g733a5


From f5fc8727dbbf8c9e93bb0822b2e5bfa77dbd0208 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Thu, 10 Jul 2025 09:17:28 -0700
Subject: Add `BuilderMethods::unreachable_nonterminator`

So places that need `unreachable` but in the middle of a basic block can call that instead of figuring out the best way to do it.
---
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs     |  8 ++---
 compiler/rustc_codegen_ssa/src/traits/builder.rs | 10 ++++++
 tests/codegen/intrinsics/transmute.rs            | 41 ++++++++++++------------
 3 files changed, 32 insertions(+), 27 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index 1e3b76e5f93..bf3b1e73b94 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -207,9 +207,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         {
             // These cases are all UB to actually hit, so don't emit code for them.
             // (The size mismatches are reachable via `transmute_unchecked`.)
-            // We can't use unreachable because that's a terminator, and we
-            // need something that can be in the middle of a basic block.
-            bx.assume(bx.cx().const_bool(false))
+            bx.unreachable_nonterminator();
         } else {
             // Since in this path we have a place anyway, we can store or copy to it,
             // making sure we use the destination place's alignment even if the
@@ -236,9 +234,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             || operand.layout.is_uninhabited()
             || cast.is_uninhabited()
         {
-            // We can't use unreachable because that's a terminator, and we
-            // need something that can be in the middle of a basic block.
-            bx.assume(bx.cx().const_bool(false));
+            bx.unreachable_nonterminator();
 
             // We still need to return a value of the appropriate type, but
             // it's already UB so do the easiest thing available.
diff --git a/compiler/rustc_codegen_ssa/src/traits/builder.rs b/compiler/rustc_codegen_ssa/src/traits/builder.rs
index 9d367748c2a..0f1358ee508 100644
--- a/compiler/rustc_codegen_ssa/src/traits/builder.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/builder.rs
@@ -136,6 +136,16 @@ pub trait BuilderMethods<'a, 'tcx>:
     ) -> Self::Value;
     fn unreachable(&mut self);
 
+    /// Like [`Self::unreachable`], but for use in the middle of a basic block.
+    fn unreachable_nonterminator(&mut self) {
+        // This is the preferred LLVM incantation for this per
+        // https://llvm.org/docs/Frontend/PerformanceTips.html#other-things-to-consider
+        // Other backends may override if they have a better way.
+        let const_true = self.cx().const_bool(true);
+        let poison_ptr = self.const_poison(self.cx().type_ptr());
+        self.store(const_true, poison_ptr, Align::ONE);
+    }
+
     fn add(&mut self, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
     fn fadd(&mut self, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
     fn fadd_fast(&mut self, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
diff --git a/tests/codegen/intrinsics/transmute.rs b/tests/codegen/intrinsics/transmute.rs
index 36d6a2f722f..c9a1cd58af3 100644
--- a/tests/codegen/intrinsics/transmute.rs
+++ b/tests/codegen/intrinsics/transmute.rs
@@ -29,28 +29,28 @@ pub struct Aggregate8(u8);
 // CHECK-LABEL: @check_bigger_size(
 #[no_mangle]
 pub unsafe fn check_bigger_size(x: u16) -> u32 {
-    // CHECK: call void @llvm.assume(i1 false)
+    // CHECK: store i1 true, ptr poison, align 1
     transmute_unchecked(x)
 }
 
 // CHECK-LABEL: @check_smaller_size(
 #[no_mangle]
 pub unsafe fn check_smaller_size(x: u32) -> u16 {
-    // CHECK: call void @llvm.assume(i1 false)
+    // CHECK: store i1 true, ptr poison, align 1
     transmute_unchecked(x)
 }
 
 // CHECK-LABEL: @check_smaller_array(
 #[no_mangle]
 pub unsafe fn check_smaller_array(x: [u32; 7]) -> [u32; 3] {
-    // CHECK: call void @llvm.assume(i1 false)
+    // CHECK: store i1 true, ptr poison, align 1
     transmute_unchecked(x)
 }
 
 // CHECK-LABEL: @check_bigger_array(
 #[no_mangle]
 pub unsafe fn check_bigger_array(x: [u32; 3]) -> [u32; 7] {
-    // CHECK: call void @llvm.assume(i1 false)
+    // CHECK: store i1 true, ptr poison, align 1
     transmute_unchecked(x)
 }
 
@@ -58,9 +58,9 @@ pub unsafe fn check_bigger_array(x: [u32; 3]) -> [u32; 7] {
 #[no_mangle]
 #[custom_mir(dialect = "runtime", phase = "optimized")]
 pub unsafe fn check_to_empty_array(x: [u32; 5]) -> [u32; 0] {
-    // CHECK-NOT: call
-    // CHECK: call void @llvm.assume(i1 false)
-    // CHECK-NOT: call
+    // CHECK: start
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
+    // CHECK-NEXT: ret void
     mir! {
         {
             RET = CastTransmute(x);
@@ -73,9 +73,9 @@ pub unsafe fn check_to_empty_array(x: [u32; 5]) -> [u32; 0] {
 #[no_mangle]
 #[custom_mir(dialect = "runtime", phase = "optimized")]
 pub unsafe fn check_from_empty_array(x: [u32; 0]) -> [u32; 5] {
-    // CHECK-NOT: call
-    // CHECK: call void @llvm.assume(i1 false)
-    // CHECK-NOT: call
+    // CHECK: start
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
+    // CHECK-NEXT: ret void
     mir! {
         {
             RET = CastTransmute(x);
@@ -88,9 +88,9 @@ pub unsafe fn check_from_empty_array(x: [u32; 0]) -> [u32; 5] {
 #[no_mangle]
 #[custom_mir(dialect = "runtime", phase = "optimized")]
 pub unsafe fn check_to_uninhabited(x: u16) {
-    // CHECK-NOT: call
-    // CHECK: call void @llvm.assume(i1 false)
-    // CHECK-NOT: call
+    // CHECK: start
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
+    // CHECK-NEXT: ret void
     mir! {
         let temp: BigNever;
         {
@@ -104,10 +104,9 @@ pub unsafe fn check_to_uninhabited(x: u16) {
 #[no_mangle]
 #[custom_mir(dialect = "runtime", phase = "optimized")]
 pub unsafe fn check_from_uninhabited(x: BigNever) -> u16 {
-    // CHECK-NOT: call
-    // CHECK: call void @llvm.assume(i1 false)
-    // CHECK-NOT: call
-    // CHECK: ret i16 poison
+    // CHECK: start
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
+    // CHECK-NEXT: ret i16 poison
     mir! {
         {
             RET = CastTransmute(x);
@@ -404,9 +403,9 @@ pub unsafe fn check_issue_109992(x: ()) -> [(); 1] {
 pub unsafe fn check_unit_to_never(x: ()) {
     // This uses custom MIR to avoid MIR optimizations having removed ZST ops.
 
-    // CHECK-NOT: call
-    // CHECK: call void @llvm.assume(i1 false)
-    // CHECK-NOT: call
+    // CHECK: start
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
+    // CHECK-NEXT: ret void
     mir! {
         let temp: ZstNever;
         {
@@ -423,7 +422,7 @@ pub unsafe fn check_unit_from_never(x: ZstNever) -> () {
     // This uses custom MIR to avoid MIR optimizations having removed ZST ops.
 
     // CHECK: start
-    // CHECK-NEXT: call void @llvm.assume(i1 false)
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
     // CHECK-NEXT: ret void
     mir! {
         {
-- 
cgit 1.4.1-3-g733a5


From e6bb6442a9029633cc53db546880c05acb6734a1 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Thu, 10 Jul 2025 19:19:59 +0200
Subject: Remove `min-specialization` feature from `WasmComponentLd`

---
 src/bootstrap/src/core/build_steps/tool.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index caaaaad845d..df89eb1da20 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -1052,7 +1052,7 @@ impl Step for WasmComponentLd {
             path: "src/tools/wasm-component-ld",
             source_type: SourceType::InTree,
             extra_features: vec![],
-            allow_features: "min-specialization",
+            allow_features: "",
             cargo_args: vec![],
             artifact_kind: ToolArtifactKind::Binary,
         })
-- 
cgit 1.4.1-3-g733a5


From 7dfc3e9af45ad54832c083baf0d2d0ca8e0d979a Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Thu, 10 Jul 2025 17:15:42 +0000
Subject: Rework borrowing suggestions to use `Expr` instead of just `Span`

In the suggestion machinery for borrowing expressions and types, always use the available obligation `Span` to find the appropriate `Expr` to perform appropriateness checks no the `ExprKind` instead of on the textual snippet corresponding to the `Span`.

Unify the logic for the case where `&` *and* `&mut` are appropriate with the logic for only one of those cases.

Handle the case when `S::foo()` should have been `<&S>::foo()` (instead of suggesting the prior `&S::foo()`.
---
 .../src/error_reporting/traits/suggestions.rs      | 228 +++++++++++----------
 ...nst-size_of_val-align_of_val-extern-type.stderr |  20 +-
 tests/ui/derives/deriving-copyclone.stderr         |  30 ++-
 tests/ui/extern/unsized-extern-derefmove.stderr    |   8 +-
 tests/ui/for/issue-20605.current.stderr            |   9 +-
 tests/ui/for/issue-20605.next.stderr               |   9 +-
 ...bitrary_self_types_generic_over_receiver.stderr |  16 +-
 .../imm-ref-trait-object-literal.stderr            |  10 +-
 tests/ui/suggestions/issue-104961.stderr           |  10 +-
 tests/ui/suggestions/issue-62843.stderr            |  10 +-
 tests/ui/suggestions/issue-84973-2.stderr          |  10 +-
 tests/ui/suggestions/issue-84973-negative.stderr   |  10 +-
 tests/ui/suggestions/issue-84973.stderr            |  10 +-
 ...est-adding-reference-to-trait-assoc-item.stderr |  20 +-
 .../suggest-imm-mut-trait-implementations.stderr   |  20 +-
 .../negated-auto-traits-error.stderr               |  10 +-
 16 files changed, 217 insertions(+), 213 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 3e64573aa03..8c9eb41568f 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -1321,7 +1321,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             let imm_ref_self_ty_satisfies_pred = mk_result(trait_pred_and_imm_ref);
             let mut_ref_self_ty_satisfies_pred = mk_result(trait_pred_and_mut_ref);
 
-            let (ref_inner_ty_satisfies_pred, ref_inner_ty_mut) =
+            let (ref_inner_ty_satisfies_pred, ref_inner_ty_is_mut) =
                 if let ObligationCauseCode::WhereClauseInExpr(..) = obligation.cause.code()
                     && let ty::Ref(_, ty, mutability) = old_pred.self_ty().skip_binder().kind()
                 {
@@ -1333,117 +1333,139 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     (false, false)
                 };
 
-            if imm_ref_self_ty_satisfies_pred
-                || mut_ref_self_ty_satisfies_pred
-                || ref_inner_ty_satisfies_pred
-            {
-                if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
-                    // We don't want a borrowing suggestion on the fields in structs,
-                    // ```
-                    // struct Foo {
-                    //  the_foos: Vec<Foo>
-                    // }
-                    // ```
-                    if !matches!(
-                        span.ctxt().outer_expn_data().kind,
-                        ExpnKind::Root | ExpnKind::Desugaring(DesugaringKind::ForLoop)
-                    ) {
-                        return false;
-                    }
-                    if snippet.starts_with('&') {
-                        // This is already a literal borrow and the obligation is failing
-                        // somewhere else in the obligation chain. Do not suggest non-sense.
-                        return false;
-                    }
-                    // We have a very specific type of error, where just borrowing this argument
-                    // might solve the problem. In cases like this, the important part is the
-                    // original type obligation, not the last one that failed, which is arbitrary.
-                    // Because of this, we modify the error to refer to the original obligation and
-                    // return early in the caller.
-
-                    let msg = format!(
-                        "the trait bound `{}` is not satisfied",
-                        self.tcx.short_string(old_pred, err.long_ty_path()),
-                    );
-                    let self_ty_str =
-                        self.tcx.short_string(old_pred.self_ty().skip_binder(), err.long_ty_path());
-                    if has_custom_message {
-                        err.note(msg);
-                    } else {
-                        err.messages = vec![(rustc_errors::DiagMessage::from(msg), Style::NoStyle)];
-                    }
-                    err.span_label(
-                        span,
-                        format!(
-                            "the trait `{}` is not implemented for `{self_ty_str}`",
-                            old_pred.print_modifiers_and_trait_path()
-                        ),
-                    );
+            let is_immut = imm_ref_self_ty_satisfies_pred
+                || (ref_inner_ty_satisfies_pred && !ref_inner_ty_is_mut);
+            let is_mut = mut_ref_self_ty_satisfies_pred || ref_inner_ty_is_mut;
+            if !is_immut && !is_mut {
+                return false;
+            }
+            let Ok(_snippet) = self.tcx.sess.source_map().span_to_snippet(span) else {
+                return false;
+            };
+            // We don't want a borrowing suggestion on the fields in structs
+            // ```
+            // #[derive(Clone)]
+            // struct Foo {
+            //     the_foos: Vec<Foo>
+            // }
+            // ```
+            if !matches!(
+                span.ctxt().outer_expn_data().kind,
+                ExpnKind::Root | ExpnKind::Desugaring(DesugaringKind::ForLoop)
+            ) {
+                return false;
+            }
+            // We have a very specific type of error, where just borrowing this argument
+            // might solve the problem. In cases like this, the important part is the
+            // original type obligation, not the last one that failed, which is arbitrary.
+            // Because of this, we modify the error to refer to the original obligation and
+            // return early in the caller.
 
-                    if imm_ref_self_ty_satisfies_pred && mut_ref_self_ty_satisfies_pred {
-                        err.span_suggestions(
-                            span.shrink_to_lo(),
-                            "consider borrowing here",
-                            ["&".to_string(), "&mut ".to_string()],
-                            Applicability::MaybeIncorrect,
-                        );
-                    } else {
-                        let is_mut = mut_ref_self_ty_satisfies_pred || ref_inner_ty_mut;
-                        let sugg_prefix = format!("&{}", if is_mut { "mut " } else { "" });
-                        let sugg_msg = format!(
-                            "consider{} borrowing here",
-                            if is_mut { " mutably" } else { "" }
-                        );
+            let mut label = || {
+                let msg = format!(
+                    "the trait bound `{}` is not satisfied",
+                    self.tcx.short_string(old_pred, err.long_ty_path()),
+                );
+                let self_ty_str =
+                    self.tcx.short_string(old_pred.self_ty().skip_binder(), err.long_ty_path());
+                if has_custom_message {
+                    err.note(msg);
+                } else {
+                    err.messages = vec![(rustc_errors::DiagMessage::from(msg), Style::NoStyle)];
+                }
+                err.span_label(
+                    span,
+                    format!(
+                        "the trait `{}` is not implemented for `{self_ty_str}`",
+                        old_pred.print_modifiers_and_trait_path()
+                    ),
+                );
+            };
 
-                        // Issue #109436, we need to add parentheses properly for method calls
-                        // for example, `foo.into()` should be `(&foo).into()`
-                        if let Some(_) =
-                            self.tcx.sess.source_map().span_look_ahead(span, ".", Some(50))
-                        {
-                            err.multipart_suggestion_verbose(
-                                sugg_msg,
-                                vec![
-                                    (span.shrink_to_lo(), format!("({sugg_prefix}")),
-                                    (span.shrink_to_hi(), ")".to_string()),
-                                ],
-                                Applicability::MaybeIncorrect,
-                            );
-                            return true;
-                        }
+            let mut sugg_prefixes = vec![];
+            if is_immut {
+                sugg_prefixes.push("&");
+            }
+            if is_mut {
+                sugg_prefixes.push("&mut ");
+            }
+            let sugg_msg = format!(
+                "consider{} borrowing here",
+                if is_mut && !is_immut { " mutably" } else { "" },
+            );
 
-                        // Issue #104961, we need to add parentheses properly for compound expressions
-                        // for example, `x.starts_with("hi".to_string() + "you")`
-                        // should be `x.starts_with(&("hi".to_string() + "you"))`
-                        let Some(body) = self.tcx.hir_maybe_body_owned_by(obligation.cause.body_id)
-                        else {
-                            return false;
-                        };
-                        let mut expr_finder = FindExprBySpan::new(span, self.tcx);
-                        expr_finder.visit_expr(body.value);
-                        let Some(expr) = expr_finder.result else {
-                            return false;
-                        };
-                        let needs_parens = expr_needs_parens(expr);
+            // Issue #104961, we need to add parentheses properly for compound expressions
+            // for example, `x.starts_with("hi".to_string() + "you")`
+            // should be `x.starts_with(&("hi".to_string() + "you"))`
+            let Some(body) = self.tcx.hir_maybe_body_owned_by(obligation.cause.body_id) else {
+                return false;
+            };
+            let mut expr_finder = FindExprBySpan::new(span, self.tcx);
+            expr_finder.visit_expr(body.value);
 
-                        let span = if needs_parens { span } else { span.shrink_to_lo() };
-                        let suggestions = if !needs_parens {
-                            vec![(span.shrink_to_lo(), sugg_prefix)]
-                        } else {
+            if let Some(ty) = expr_finder.ty_result {
+                if let hir::Node::Expr(expr) = self.tcx.parent_hir_node(ty.hir_id)
+                    && let hir::ExprKind::Path(hir::QPath::TypeRelative(_, _)) = expr.kind
+                    && ty.span == span
+                {
+                    // We've encountered something like `str::from("")`, where the intended code
+                    // was likely `<&str>::from("")`. #143393.
+                    label();
+                    err.multipart_suggestions(
+                        sugg_msg,
+                        sugg_prefixes.into_iter().map(|sugg_prefix| {
                             vec![
-                                (span.shrink_to_lo(), format!("{sugg_prefix}(")),
-                                (span.shrink_to_hi(), ")".to_string()),
+                                (span.shrink_to_lo(), format!("<{sugg_prefix}")),
+                                (span.shrink_to_hi(), ">".to_string()),
                             ]
-                        };
-                        err.multipart_suggestion_verbose(
-                            sugg_msg,
-                            suggestions,
-                            Applicability::MaybeIncorrect,
-                        );
-                    }
+                        }),
+                        Applicability::MaybeIncorrect,
+                    );
                     return true;
                 }
+                return false;
             }
-            return false;
+            let Some(expr) = expr_finder.result else {
+                return false;
+            };
+            if let hir::ExprKind::AddrOf(_, _, _) = expr.kind {
+                return false;
+            }
+            let needs_parens_post = expr_needs_parens(expr);
+            let needs_parens_pre = match self.tcx.parent_hir_node(expr.hir_id) {
+                Node::Expr(e)
+                    if let hir::ExprKind::MethodCall(_, base, _, _) = e.kind
+                        && base.hir_id == expr.hir_id =>
+                {
+                    true
+                }
+                _ => false,
+            };
+
+            label();
+            let suggestions = sugg_prefixes.into_iter().map(|sugg_prefix| {
+                match (needs_parens_pre, needs_parens_post) {
+                    (false, false) => vec![(span.shrink_to_lo(), sugg_prefix.to_string())],
+                    // We have something like `foo.bar()`, where we want to bororw foo, so we need
+                    // to suggest `(&mut foo).bar()`.
+                    (false, true) => vec![
+                        (span.shrink_to_lo(), format!("{sugg_prefix}(")),
+                        (span.shrink_to_hi(), ")".to_string()),
+                    ],
+                    // Issue #109436, we need to add parentheses properly for method calls
+                    // for example, `foo.into()` should be `(&foo).into()`
+                    (true, false) => vec![
+                        (span.shrink_to_lo(), format!("({sugg_prefix}")),
+                        (span.shrink_to_hi(), ")".to_string()),
+                    ],
+                    (true, true) => vec![
+                        (span.shrink_to_lo(), format!("({sugg_prefix}(")),
+                        (span.shrink_to_hi(), "))".to_string()),
+                    ],
+                }
+            });
+            err.multipart_suggestions(sugg_msg, suggestions, Applicability::MaybeIncorrect);
+            return true;
         };
 
         if let ObligationCauseCode::ImplDerived(cause) = &*code {
diff --git a/tests/ui/consts/const-size_of_val-align_of_val-extern-type.stderr b/tests/ui/consts/const-size_of_val-align_of_val-extern-type.stderr
index 6d6bc157771..825b9e94158 100644
--- a/tests/ui/consts/const-size_of_val-align_of_val-extern-type.stderr
+++ b/tests/ui/consts/const-size_of_val-align_of_val-extern-type.stderr
@@ -2,25 +2,37 @@ error[E0277]: the size for values of type `Opaque` cannot be known
   --> $DIR/const-size_of_val-align_of_val-extern-type.rs:10:43
    |
 LL | const _SIZE: usize = unsafe { size_of_val(&4 as *const i32 as *const Opaque) };
-   |                               ----------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a known size
+   |                               ----------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `MetaSized` is not implemented for `Opaque`
    |                               |
    |                               required by a bound introduced by this call
    |
-   = help: the trait `MetaSized` is not implemented for `Opaque`
+   = note: the trait bound `Opaque: MetaSized` is not satisfied
 note: required by a bound in `std::intrinsics::size_of_val`
   --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
+help: consider borrowing here
+   |
+LL | const _SIZE: usize = unsafe { size_of_val(&(&4 as *const i32 as *const Opaque)) };
+   |                                           ++                                 +
+LL | const _SIZE: usize = unsafe { size_of_val(&mut (&4 as *const i32 as *const Opaque)) };
+   |                                           ++++++                                 +
 
 error[E0277]: the size for values of type `Opaque` cannot be known
   --> $DIR/const-size_of_val-align_of_val-extern-type.rs:12:45
    |
 LL | const _ALIGN: usize = unsafe { align_of_val(&4 as *const i32 as *const Opaque) };
-   |                                ------------ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a known size
+   |                                ------------ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `MetaSized` is not implemented for `Opaque`
    |                                |
    |                                required by a bound introduced by this call
    |
-   = help: the trait `MetaSized` is not implemented for `Opaque`
+   = note: the trait bound `Opaque: MetaSized` is not satisfied
 note: required by a bound in `std::intrinsics::align_of_val`
   --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
+help: consider borrowing here
+   |
+LL | const _ALIGN: usize = unsafe { align_of_val(&(&4 as *const i32 as *const Opaque)) };
+   |                                             ++                                 +
+LL | const _ALIGN: usize = unsafe { align_of_val(&mut (&4 as *const i32 as *const Opaque)) };
+   |                                             ++++++                                 +
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/derives/deriving-copyclone.stderr b/tests/ui/derives/deriving-copyclone.stderr
index befff880280..707a63ba28d 100644
--- a/tests/ui/derives/deriving-copyclone.stderr
+++ b/tests/ui/derives/deriving-copyclone.stderr
@@ -2,8 +2,10 @@ error[E0277]: the trait bound `B<C>: Copy` is not satisfied
   --> $DIR/deriving-copyclone.rs:31:26
    |
 LL |     is_copy(B { a: 1, b: C });
-   |     -------              ^ the trait `Copy` is not implemented for `B<C>`
-   |     |
+   |     -------              ^
+   |     |                    |
+   |     |                    the trait `Copy` is not implemented for `B<C>`
+   |     |                    help: consider borrowing here: `&`
    |     required by a bound introduced by this call
    |
 note: required for `B<C>` to implement `Copy`
@@ -16,17 +18,15 @@ note: required by a bound in `is_copy`
    |
 LL | fn is_copy<T: Copy>(_: T) {}
    |               ^^^^ required by this bound in `is_copy`
-help: consider borrowing here
-   |
-LL |     is_copy(B { a: 1, b: &C });
-   |                          +
 
 error[E0277]: the trait bound `B<C>: Clone` is not satisfied
   --> $DIR/deriving-copyclone.rs:32:27
    |
 LL |     is_clone(B { a: 1, b: C });
-   |     --------              ^ the trait `Clone` is not implemented for `B<C>`
-   |     |
+   |     --------              ^
+   |     |                     |
+   |     |                     the trait `Clone` is not implemented for `B<C>`
+   |     |                     help: consider borrowing here: `&`
    |     required by a bound introduced by this call
    |
 note: required for `B<C>` to implement `Clone`
@@ -39,17 +39,15 @@ note: required by a bound in `is_clone`
    |
 LL | fn is_clone<T: Clone>(_: T) {}
    |                ^^^^^ required by this bound in `is_clone`
-help: consider borrowing here
-   |
-LL |     is_clone(B { a: 1, b: &C });
-   |                           +
 
 error[E0277]: the trait bound `B<D>: Copy` is not satisfied
   --> $DIR/deriving-copyclone.rs:35:26
    |
 LL |     is_copy(B { a: 1, b: D });
-   |     -------              ^ the trait `Copy` is not implemented for `B<D>`
-   |     |
+   |     -------              ^
+   |     |                    |
+   |     |                    the trait `Copy` is not implemented for `B<D>`
+   |     |                    help: consider borrowing here: `&`
    |     required by a bound introduced by this call
    |
 note: required for `B<D>` to implement `Copy`
@@ -62,10 +60,6 @@ note: required by a bound in `is_copy`
    |
 LL | fn is_copy<T: Copy>(_: T) {}
    |               ^^^^ required by this bound in `is_copy`
-help: consider borrowing here
-   |
-LL |     is_copy(B { a: 1, b: &D });
-   |                          +
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/extern/unsized-extern-derefmove.stderr b/tests/ui/extern/unsized-extern-derefmove.stderr
index d6be76a9d62..a9efc2e66e3 100644
--- a/tests/ui/extern/unsized-extern-derefmove.stderr
+++ b/tests/ui/extern/unsized-extern-derefmove.stderr
@@ -21,10 +21,10 @@ note: required by a bound in `Box::<T>::from_raw`
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
 help: consider borrowing here
    |
-LL |     Box::from_raw(&0 as *mut _)
-   |                   +
-LL |     Box::from_raw(&mut 0 as *mut _)
-   |                   ++++
+LL |     Box::from_raw(&(0 as *mut _))
+   |                   ++           +
+LL |     Box::from_raw(&mut (0 as *mut _))
+   |                   ++++++           +
 
 error[E0277]: the size for values of type `Device` cannot be known
   --> $DIR/unsized-extern-derefmove.rs:11:5
diff --git a/tests/ui/for/issue-20605.current.stderr b/tests/ui/for/issue-20605.current.stderr
index 1a66cb41464..289dca289ae 100644
--- a/tests/ui/for/issue-20605.current.stderr
+++ b/tests/ui/for/issue-20605.current.stderr
@@ -2,14 +2,13 @@ error[E0277]: `dyn Iterator<Item = &'a mut u8>` is not an iterator
   --> $DIR/issue-20605.rs:6:17
    |
 LL |     for item in *things { *item = 0 }
-   |                 ^^^^^^^ the trait `IntoIterator` is not implemented for `dyn Iterator<Item = &'a mut u8>`
+   |                 -^^^^^^
+   |                 |
+   |                 the trait `IntoIterator` is not implemented for `dyn Iterator<Item = &'a mut u8>`
+   |                 help: consider mutably borrowing here: `&mut`
    |
    = note: the trait bound `dyn Iterator<Item = &'a mut u8>: IntoIterator` is not satisfied
    = note: required for `dyn Iterator<Item = &'a mut u8>` to implement `IntoIterator`
-help: consider mutably borrowing here
-   |
-LL |     for item in &mut *things { *item = 0 }
-   |                 ++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/for/issue-20605.next.stderr b/tests/ui/for/issue-20605.next.stderr
index 1a66cb41464..289dca289ae 100644
--- a/tests/ui/for/issue-20605.next.stderr
+++ b/tests/ui/for/issue-20605.next.stderr
@@ -2,14 +2,13 @@ error[E0277]: `dyn Iterator<Item = &'a mut u8>` is not an iterator
   --> $DIR/issue-20605.rs:6:17
    |
 LL |     for item in *things { *item = 0 }
-   |                 ^^^^^^^ the trait `IntoIterator` is not implemented for `dyn Iterator<Item = &'a mut u8>`
+   |                 -^^^^^^
+   |                 |
+   |                 the trait `IntoIterator` is not implemented for `dyn Iterator<Item = &'a mut u8>`
+   |                 help: consider mutably borrowing here: `&mut`
    |
    = note: the trait bound `dyn Iterator<Item = &'a mut u8>: IntoIterator` is not satisfied
    = note: required for `dyn Iterator<Item = &'a mut u8>` to implement `IntoIterator`
-help: consider mutably borrowing here
-   |
-LL |     for item in &mut *things { *item = 0 }
-   |                 ++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/self/arbitrary_self_types_generic_over_receiver.stderr b/tests/ui/self/arbitrary_self_types_generic_over_receiver.stderr
index 2da3925341e..7a3d8b43c2e 100644
--- a/tests/ui/self/arbitrary_self_types_generic_over_receiver.stderr
+++ b/tests/ui/self/arbitrary_self_types_generic_over_receiver.stderr
@@ -30,10 +30,10 @@ LL |     fn a(self: impl Receiver<Target=Self>) -> u32 {
    |                     ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Foo::a`
 help: consider borrowing here
    |
-LL |     &foo.a();
-   |     +
-LL |     &mut foo.a();
-   |     ++++
+LL |     (&foo).a();
+   |     ++   +
+LL |     (&mut foo).a();
+   |     +++++    +
 
 error[E0277]: the trait bound `Foo: Deref` is not satisfied
   --> $DIR/arbitrary_self_types_generic_over_receiver.rs:21:9
@@ -48,10 +48,10 @@ LL |     fn b(self: impl Deref<Target=Self>) -> u32 {
    |                     ^^^^^^^^^^^^^^^^^^ required by this bound in `Foo::b`
 help: consider borrowing here
    |
-LL |     &foo.b();
-   |     +
-LL |     &mut foo.b();
-   |     ++++
+LL |     (&foo).b();
+   |     ++   +
+LL |     (&mut foo).b();
+   |     +++++    +
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/suggestions/imm-ref-trait-object-literal.stderr b/tests/ui/suggestions/imm-ref-trait-object-literal.stderr
index 4b770d572c5..62f1c03e9aa 100644
--- a/tests/ui/suggestions/imm-ref-trait-object-literal.stderr
+++ b/tests/ui/suggestions/imm-ref-trait-object-literal.stderr
@@ -21,8 +21,10 @@ error[E0277]: the trait bound `S: Trait` is not satisfied
   --> $DIR/imm-ref-trait-object-literal.rs:13:7
    |
 LL |   foo(s);
-   |   --- ^ the trait `Trait` is not implemented for `S`
-   |   |
+   |   --- ^
+   |   |   |
+   |   |   the trait `Trait` is not implemented for `S`
+   |   |   help: consider mutably borrowing here: `&mut`
    |   required by a bound introduced by this call
    |
 note: required by a bound in `foo`
@@ -30,10 +32,6 @@ note: required by a bound in `foo`
    |
 LL | fn foo<X: Trait>(_: X) {}
    |           ^^^^^ required by this bound in `foo`
-help: consider mutably borrowing here
-   |
-LL |   foo(&mut s);
-   |       ++++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/issue-104961.stderr b/tests/ui/suggestions/issue-104961.stderr
index 0d229e6dada..6f02c125cad 100644
--- a/tests/ui/suggestions/issue-104961.stderr
+++ b/tests/ui/suggestions/issue-104961.stderr
@@ -18,17 +18,15 @@ error[E0277]: the trait bound `String: Pattern` is not satisfied
   --> $DIR/issue-104961.rs:9:19
    |
 LL |     x.starts_with("hi".to_string())
-   |       ----------- ^^^^^^^^^^^^^^^^ the trait `Pattern` is not implemented for `String`
-   |       |
+   |       ----------- -^^^^^^^^^^^^^^^
+   |       |           |
+   |       |           the trait `Pattern` is not implemented for `String`
+   |       |           help: consider borrowing here: `&`
    |       required by a bound introduced by this call
    |
    = note: required for `String` to implement `Pattern`
 note: required by a bound in `core::str::<impl str>::starts_with`
   --> $SRC_DIR/core/src/str/mod.rs:LL:COL
-help: consider borrowing here
-   |
-LL |     x.starts_with(&"hi".to_string())
-   |                   +
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/issue-62843.stderr b/tests/ui/suggestions/issue-62843.stderr
index c3c0360b3a9..c3480a8e396 100644
--- a/tests/ui/suggestions/issue-62843.stderr
+++ b/tests/ui/suggestions/issue-62843.stderr
@@ -2,17 +2,15 @@ error[E0277]: the trait bound `String: Pattern` is not satisfied
   --> $DIR/issue-62843.rs:4:32
    |
 LL |     println!("{:?}", line.find(pattern));
-   |                           ---- ^^^^^^^ the trait `Pattern` is not implemented for `String`
-   |                           |
+   |                           ---- -^^^^^^
+   |                           |    |
+   |                           |    the trait `Pattern` is not implemented for `String`
+   |                           |    help: consider borrowing here: `&`
    |                           required by a bound introduced by this call
    |
    = note: required for `String` to implement `Pattern`
 note: required by a bound in `core::str::<impl str>::find`
   --> $SRC_DIR/core/src/str/mod.rs:LL:COL
-help: consider borrowing here
-   |
-LL |     println!("{:?}", line.find(&pattern));
-   |                                +
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/issue-84973-2.stderr b/tests/ui/suggestions/issue-84973-2.stderr
index 74995a0500a..914307008ef 100644
--- a/tests/ui/suggestions/issue-84973-2.stderr
+++ b/tests/ui/suggestions/issue-84973-2.stderr
@@ -2,8 +2,10 @@ error[E0277]: the trait bound `i32: Tr` is not satisfied
   --> $DIR/issue-84973-2.rs:11:9
    |
 LL |     foo(a);
-   |     --- ^ the trait `Tr` is not implemented for `i32`
-   |     |
+   |     --- ^
+   |     |   |
+   |     |   the trait `Tr` is not implemented for `i32`
+   |     |   help: consider mutably borrowing here: `&mut`
    |     required by a bound introduced by this call
    |
 note: required by a bound in `foo`
@@ -11,10 +13,6 @@ note: required by a bound in `foo`
    |
 LL | fn foo<T: Tr>(i: T) {}
    |           ^^ required by this bound in `foo`
-help: consider mutably borrowing here
-   |
-LL |     foo(&mut a);
-   |         ++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/issue-84973-negative.stderr b/tests/ui/suggestions/issue-84973-negative.stderr
index ce838bce09e..e3e6296890f 100644
--- a/tests/ui/suggestions/issue-84973-negative.stderr
+++ b/tests/ui/suggestions/issue-84973-negative.stderr
@@ -17,8 +17,10 @@ error[E0277]: the trait bound `f32: Tr` is not satisfied
   --> $DIR/issue-84973-negative.rs:11:9
    |
 LL |     bar(b);
-   |     --- ^ the trait `Tr` is not implemented for `f32`
-   |     |
+   |     --- ^
+   |     |   |
+   |     |   the trait `Tr` is not implemented for `f32`
+   |     |   help: consider borrowing here: `&`
    |     required by a bound introduced by this call
    |
 note: required by a bound in `bar`
@@ -26,10 +28,6 @@ note: required by a bound in `bar`
    |
 LL | fn bar<T: Tr>(t: T) {}
    |           ^^ required by this bound in `bar`
-help: consider borrowing here
-   |
-LL |     bar(&b);
-   |         +
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/issue-84973.stderr b/tests/ui/suggestions/issue-84973.stderr
index c5e1958e030..5ca91c544db 100644
--- a/tests/ui/suggestions/issue-84973.stderr
+++ b/tests/ui/suggestions/issue-84973.stderr
@@ -2,8 +2,10 @@ error[E0277]: the trait bound `Fancy: SomeTrait` is not satisfied
   --> $DIR/issue-84973.rs:6:24
    |
 LL |     let o = Other::new(f);
-   |             ---------- ^ the trait `SomeTrait` is not implemented for `Fancy`
-   |             |
+   |             ---------- ^
+   |             |          |
+   |             |          the trait `SomeTrait` is not implemented for `Fancy`
+   |             |          help: consider borrowing here: `&`
    |             required by a bound introduced by this call
    |
 note: required by a bound in `Other::<'a, G>::new`
@@ -14,10 +16,6 @@ LL |     G: SomeTrait,
 LL | {
 LL |     pub fn new(g: G) -> Self {
    |            --- required by a bound in this associated function
-help: consider borrowing here
-   |
-LL |     let o = Other::new(&f);
-   |                        +
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/suggest-adding-reference-to-trait-assoc-item.stderr b/tests/ui/suggestions/suggest-adding-reference-to-trait-assoc-item.stderr
index 485015a98f2..146d6705243 100644
--- a/tests/ui/suggestions/suggest-adding-reference-to-trait-assoc-item.stderr
+++ b/tests/ui/suggestions/suggest-adding-reference-to-trait-assoc-item.stderr
@@ -2,23 +2,19 @@ error[E0277]: the trait bound `&mut usize: Default` is not satisfied
   --> $DIR/suggest-adding-reference-to-trait-assoc-item.rs:13:9
    |
 LL |     foo(Default::default());
-   |         ^^^^^^^^^^^^^^^^^^ the trait `Default` is not implemented for `&mut usize`
-   |
-help: consider mutably borrowing here
-   |
-LL |     foo(&mut Default::default());
-   |         ++++
+   |         -^^^^^^^^^^^^^^^^^
+   |         |
+   |         the trait `Default` is not implemented for `&mut usize`
+   |         help: consider mutably borrowing here: `&mut`
 
 error[E0277]: the trait bound `&usize: Default` is not satisfied
   --> $DIR/suggest-adding-reference-to-trait-assoc-item.rs:14:9
    |
 LL |     bar(Default::default());
-   |         ^^^^^^^^^^^^^^^^^^ the trait `Default` is not implemented for `&usize`
-   |
-help: consider borrowing here
-   |
-LL |     bar(&Default::default());
-   |         +
+   |         -^^^^^^^^^^^^^^^^^
+   |         |
+   |         the trait `Default` is not implemented for `&usize`
+   |         help: consider borrowing here: `&`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/suggest-imm-mut-trait-implementations.stderr b/tests/ui/suggestions/suggest-imm-mut-trait-implementations.stderr
index f2eb651eaa4..b3a0c68450e 100644
--- a/tests/ui/suggestions/suggest-imm-mut-trait-implementations.stderr
+++ b/tests/ui/suggestions/suggest-imm-mut-trait-implementations.stderr
@@ -22,8 +22,10 @@ error[E0277]: the trait bound `B: Trait` is not satisfied
   --> $DIR/suggest-imm-mut-trait-implementations.rs:21:9
    |
 LL |     foo(b);
-   |     --- ^ the trait `Trait` is not implemented for `B`
-   |     |
+   |     --- ^
+   |     |   |
+   |     |   the trait `Trait` is not implemented for `B`
+   |     |   help: consider borrowing here: `&`
    |     required by a bound introduced by this call
    |
 note: required by a bound in `foo`
@@ -31,17 +33,15 @@ note: required by a bound in `foo`
    |
 LL | fn foo<X: Trait>(_: X) {}
    |           ^^^^^ required by this bound in `foo`
-help: consider borrowing here
-   |
-LL |     foo(&b);
-   |         +
 
 error[E0277]: the trait bound `C: Trait` is not satisfied
   --> $DIR/suggest-imm-mut-trait-implementations.rs:22:9
    |
 LL |     foo(c);
-   |     --- ^ the trait `Trait` is not implemented for `C`
-   |     |
+   |     --- ^
+   |     |   |
+   |     |   the trait `Trait` is not implemented for `C`
+   |     |   help: consider mutably borrowing here: `&mut`
    |     required by a bound introduced by this call
    |
 note: required by a bound in `foo`
@@ -49,10 +49,6 @@ note: required by a bound in `foo`
    |
 LL | fn foo<X: Trait>(_: X) {}
    |           ^^^^^ required by this bound in `foo`
-help: consider mutably borrowing here
-   |
-LL |     foo(&mut c);
-   |         ++++
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/traits/negative-impls/negated-auto-traits-error.stderr b/tests/ui/traits/negative-impls/negated-auto-traits-error.stderr
index 8f5b937e586..cc5ca471788 100644
--- a/tests/ui/traits/negative-impls/negated-auto-traits-error.stderr
+++ b/tests/ui/traits/negative-impls/negated-auto-traits-error.stderr
@@ -61,8 +61,10 @@ error[E0277]: `dummy2::TestType` cannot be sent between threads safely
   --> $DIR/negated-auto-traits-error.rs:48:13
    |
 LL |     is_send(Box::new(TestType));
-   |     ------- ^^^^^^^^^^^^^^^^^^ the trait `Send` is not implemented for `Unique<dummy2::TestType>`
-   |     |
+   |     ------- -^^^^^^^^^^^^^^^^^
+   |     |       |
+   |     |       the trait `Send` is not implemented for `Unique<dummy2::TestType>`
+   |     |       help: consider borrowing here: `&`
    |     required by a bound introduced by this call
    |
    = note: the trait bound `Unique<dummy2::TestType>: Send` is not satisfied
@@ -74,10 +76,6 @@ note: required by a bound in `is_send`
    |
 LL | fn is_send<T: Send>(_: T) {}
    |               ^^^^ required by this bound in `is_send`
-help: consider borrowing here
-   |
-LL |     is_send(&Box::new(TestType));
-   |             +
 
 error[E0277]: `dummy3::TestType` cannot be sent between threads safely
   --> $DIR/negated-auto-traits-error.rs:56:13
-- 
cgit 1.4.1-3-g733a5


From 0674eca2f0c4ac45b7cf1a66fd4df44dfc603e7e Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Thu, 10 Jul 2025 17:21:59 +0000
Subject: Make `Diag::multipart_suggestions` always verbose

---
 compiler/rustc_errors/src/diagnostic.rs            |  2 +-
 tests/ui/derives/deriving-copyclone.stderr         | 30 +++++++++++++---------
 tests/ui/for/issue-20605.current.stderr            |  9 ++++---
 tests/ui/for/issue-20605.next.stderr               |  9 ++++---
 .../in-trait/default-body-type-err-2.stderr        |  9 ++++---
 tests/ui/inference/deref-suggestion.stderr         |  9 ++++---
 .../typo-in-repeat-expr-issue-80173.stderr         |  9 ++++---
 tests/ui/static/bad-const-type.stderr              |  9 ++++---
 .../imm-ref-trait-object-literal.stderr            | 10 +++++---
 tests/ui/suggestions/issue-104961.stderr           | 10 +++++---
 tests/ui/suggestions/issue-52820.stderr            | 11 +++++---
 tests/ui/suggestions/issue-53692.stderr            | 23 +++++++++++------
 tests/ui/suggestions/issue-59819.stderr            | 10 +++++---
 tests/ui/suggestions/issue-62843.stderr            | 10 +++++---
 tests/ui/suggestions/issue-83943.stderr            |  9 ++++---
 tests/ui/suggestions/issue-84973-2.stderr          | 10 +++++---
 tests/ui/suggestions/issue-84973-negative.stderr   | 10 +++++---
 tests/ui/suggestions/issue-84973.stderr            | 10 +++++---
 ...ggest-removal-of-conversion-method-calls.stderr |  9 ++++---
 ...est-adding-reference-to-trait-assoc-item.stderr | 20 +++++++++------
 .../suggest-imm-mut-trait-implementations.stderr   | 20 +++++++++------
 tests/ui/switched-expectations.stderr              |  9 ++++---
 .../negated-auto-traits-error.stderr               | 10 +++++---
 tests/ui/typeck/conversion-methods.stderr          | 30 +++++++++++++++-------
 24 files changed, 187 insertions(+), 110 deletions(-)

diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index 5746c28a2ab..a128f8d31a1 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -1165,7 +1165,7 @@ impl<'a, G: EmissionGuarantee> Diag<'a, G> {
         self.push_suggestion(CodeSuggestion {
             substitutions,
             msg: self.subdiagnostic_message_to_diagnostic_message(msg),
-            style: SuggestionStyle::ShowCode,
+            style: SuggestionStyle::ShowAlways,
             applicability,
         });
         self
diff --git a/tests/ui/derives/deriving-copyclone.stderr b/tests/ui/derives/deriving-copyclone.stderr
index 707a63ba28d..befff880280 100644
--- a/tests/ui/derives/deriving-copyclone.stderr
+++ b/tests/ui/derives/deriving-copyclone.stderr
@@ -2,10 +2,8 @@ error[E0277]: the trait bound `B<C>: Copy` is not satisfied
   --> $DIR/deriving-copyclone.rs:31:26
    |
 LL |     is_copy(B { a: 1, b: C });
-   |     -------              ^
-   |     |                    |
-   |     |                    the trait `Copy` is not implemented for `B<C>`
-   |     |                    help: consider borrowing here: `&`
+   |     -------              ^ the trait `Copy` is not implemented for `B<C>`
+   |     |
    |     required by a bound introduced by this call
    |
 note: required for `B<C>` to implement `Copy`
@@ -18,15 +16,17 @@ note: required by a bound in `is_copy`
    |
 LL | fn is_copy<T: Copy>(_: T) {}
    |               ^^^^ required by this bound in `is_copy`
+help: consider borrowing here
+   |
+LL |     is_copy(B { a: 1, b: &C });
+   |                          +
 
 error[E0277]: the trait bound `B<C>: Clone` is not satisfied
   --> $DIR/deriving-copyclone.rs:32:27
    |
 LL |     is_clone(B { a: 1, b: C });
-   |     --------              ^
-   |     |                     |
-   |     |                     the trait `Clone` is not implemented for `B<C>`
-   |     |                     help: consider borrowing here: `&`
+   |     --------              ^ the trait `Clone` is not implemented for `B<C>`
+   |     |
    |     required by a bound introduced by this call
    |
 note: required for `B<C>` to implement `Clone`
@@ -39,15 +39,17 @@ note: required by a bound in `is_clone`
    |
 LL | fn is_clone<T: Clone>(_: T) {}
    |                ^^^^^ required by this bound in `is_clone`
+help: consider borrowing here
+   |
+LL |     is_clone(B { a: 1, b: &C });
+   |                           +
 
 error[E0277]: the trait bound `B<D>: Copy` is not satisfied
   --> $DIR/deriving-copyclone.rs:35:26
    |
 LL |     is_copy(B { a: 1, b: D });
-   |     -------              ^
-   |     |                    |
-   |     |                    the trait `Copy` is not implemented for `B<D>`
-   |     |                    help: consider borrowing here: `&`
+   |     -------              ^ the trait `Copy` is not implemented for `B<D>`
+   |     |
    |     required by a bound introduced by this call
    |
 note: required for `B<D>` to implement `Copy`
@@ -60,6 +62,10 @@ note: required by a bound in `is_copy`
    |
 LL | fn is_copy<T: Copy>(_: T) {}
    |               ^^^^ required by this bound in `is_copy`
+help: consider borrowing here
+   |
+LL |     is_copy(B { a: 1, b: &D });
+   |                          +
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/for/issue-20605.current.stderr b/tests/ui/for/issue-20605.current.stderr
index 289dca289ae..1a66cb41464 100644
--- a/tests/ui/for/issue-20605.current.stderr
+++ b/tests/ui/for/issue-20605.current.stderr
@@ -2,13 +2,14 @@ error[E0277]: `dyn Iterator<Item = &'a mut u8>` is not an iterator
   --> $DIR/issue-20605.rs:6:17
    |
 LL |     for item in *things { *item = 0 }
-   |                 -^^^^^^
-   |                 |
-   |                 the trait `IntoIterator` is not implemented for `dyn Iterator<Item = &'a mut u8>`
-   |                 help: consider mutably borrowing here: `&mut`
+   |                 ^^^^^^^ the trait `IntoIterator` is not implemented for `dyn Iterator<Item = &'a mut u8>`
    |
    = note: the trait bound `dyn Iterator<Item = &'a mut u8>: IntoIterator` is not satisfied
    = note: required for `dyn Iterator<Item = &'a mut u8>` to implement `IntoIterator`
+help: consider mutably borrowing here
+   |
+LL |     for item in &mut *things { *item = 0 }
+   |                 ++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/for/issue-20605.next.stderr b/tests/ui/for/issue-20605.next.stderr
index 289dca289ae..1a66cb41464 100644
--- a/tests/ui/for/issue-20605.next.stderr
+++ b/tests/ui/for/issue-20605.next.stderr
@@ -2,13 +2,14 @@ error[E0277]: `dyn Iterator<Item = &'a mut u8>` is not an iterator
   --> $DIR/issue-20605.rs:6:17
    |
 LL |     for item in *things { *item = 0 }
-   |                 -^^^^^^
-   |                 |
-   |                 the trait `IntoIterator` is not implemented for `dyn Iterator<Item = &'a mut u8>`
-   |                 help: consider mutably borrowing here: `&mut`
+   |                 ^^^^^^^ the trait `IntoIterator` is not implemented for `dyn Iterator<Item = &'a mut u8>`
    |
    = note: the trait bound `dyn Iterator<Item = &'a mut u8>: IntoIterator` is not satisfied
    = note: required for `dyn Iterator<Item = &'a mut u8>` to implement `IntoIterator`
+help: consider mutably borrowing here
+   |
+LL |     for item in &mut *things { *item = 0 }
+   |                 ++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/in-trait/default-body-type-err-2.stderr b/tests/ui/impl-trait/in-trait/default-body-type-err-2.stderr
index 856c92217b9..4c429624e0b 100644
--- a/tests/ui/impl-trait/in-trait/default-body-type-err-2.stderr
+++ b/tests/ui/impl-trait/in-trait/default-body-type-err-2.stderr
@@ -4,9 +4,12 @@ error[E0308]: mismatched types
 LL |     async fn woopsie_async(&self) -> String {
    |                                      ------ expected `String` because of return type
 LL |         42
-   |         ^^- help: try using a conversion method: `.to_string()`
-   |         |
-   |         expected `String`, found integer
+   |         ^^ expected `String`, found integer
+   |
+help: try using a conversion method
+   |
+LL |         42.to_string()
+   |           ++++++++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/inference/deref-suggestion.stderr b/tests/ui/inference/deref-suggestion.stderr
index 8ccd28198af..027902a9f31 100644
--- a/tests/ui/inference/deref-suggestion.stderr
+++ b/tests/ui/inference/deref-suggestion.stderr
@@ -2,9 +2,8 @@ error[E0308]: mismatched types
   --> $DIR/deref-suggestion.rs:8:9
    |
 LL |     foo(s);
-   |     --- ^- help: try using a conversion method: `.to_string()`
-   |     |   |
-   |     |   expected `String`, found `&String`
+   |     --- ^ expected `String`, found `&String`
+   |     |
    |     arguments to this function are incorrect
    |
 note: function defined here
@@ -12,6 +11,10 @@ note: function defined here
    |
 LL | fn foo(_: String) {}
    |    ^^^ ---------
+help: try using a conversion method
+   |
+LL |     foo(s.to_string());
+   |          ++++++++++++
 
 error[E0308]: mismatched types
   --> $DIR/deref-suggestion.rs:14:10
diff --git a/tests/ui/repeat-expr/typo-in-repeat-expr-issue-80173.stderr b/tests/ui/repeat-expr/typo-in-repeat-expr-issue-80173.stderr
index ce2022374f7..9f31a731fed 100644
--- a/tests/ui/repeat-expr/typo-in-repeat-expr-issue-80173.stderr
+++ b/tests/ui/repeat-expr/typo-in-repeat-expr-issue-80173.stderr
@@ -38,9 +38,12 @@ error[E0308]: mismatched types
   --> $DIR/typo-in-repeat-expr-issue-80173.rs:32:29
    |
 LL |     let e = [String::new(), 10];
-   |                             ^^- help: try using a conversion method: `.to_string()`
-   |                             |
-   |                             expected `String`, found integer
+   |                             ^^ expected `String`, found integer
+   |
+help: try using a conversion method
+   |
+LL |     let e = [String::new(), 10.to_string()];
+   |                               ++++++++++++
 
 error[E0308]: mismatched types
   --> $DIR/typo-in-repeat-expr-issue-80173.rs:36:19
diff --git a/tests/ui/static/bad-const-type.stderr b/tests/ui/static/bad-const-type.stderr
index 807cd2f7a25..8573a11ef29 100644
--- a/tests/ui/static/bad-const-type.stderr
+++ b/tests/ui/static/bad-const-type.stderr
@@ -2,9 +2,12 @@ error[E0308]: mismatched types
   --> $DIR/bad-const-type.rs:1:20
    |
 LL | static i: String = 10;
-   |                    ^^- help: try using a conversion method: `.to_string()`
-   |                    |
-   |                    expected `String`, found integer
+   |                    ^^ expected `String`, found integer
+   |
+help: try using a conversion method
+   |
+LL | static i: String = 10.to_string();
+   |                      ++++++++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/imm-ref-trait-object-literal.stderr b/tests/ui/suggestions/imm-ref-trait-object-literal.stderr
index 62f1c03e9aa..4b770d572c5 100644
--- a/tests/ui/suggestions/imm-ref-trait-object-literal.stderr
+++ b/tests/ui/suggestions/imm-ref-trait-object-literal.stderr
@@ -21,10 +21,8 @@ error[E0277]: the trait bound `S: Trait` is not satisfied
   --> $DIR/imm-ref-trait-object-literal.rs:13:7
    |
 LL |   foo(s);
-   |   --- ^
-   |   |   |
-   |   |   the trait `Trait` is not implemented for `S`
-   |   |   help: consider mutably borrowing here: `&mut`
+   |   --- ^ the trait `Trait` is not implemented for `S`
+   |   |
    |   required by a bound introduced by this call
    |
 note: required by a bound in `foo`
@@ -32,6 +30,10 @@ note: required by a bound in `foo`
    |
 LL | fn foo<X: Trait>(_: X) {}
    |           ^^^^^ required by this bound in `foo`
+help: consider mutably borrowing here
+   |
+LL |   foo(&mut s);
+   |       ++++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/issue-104961.stderr b/tests/ui/suggestions/issue-104961.stderr
index 6f02c125cad..0d229e6dada 100644
--- a/tests/ui/suggestions/issue-104961.stderr
+++ b/tests/ui/suggestions/issue-104961.stderr
@@ -18,15 +18,17 @@ error[E0277]: the trait bound `String: Pattern` is not satisfied
   --> $DIR/issue-104961.rs:9:19
    |
 LL |     x.starts_with("hi".to_string())
-   |       ----------- -^^^^^^^^^^^^^^^
-   |       |           |
-   |       |           the trait `Pattern` is not implemented for `String`
-   |       |           help: consider borrowing here: `&`
+   |       ----------- ^^^^^^^^^^^^^^^^ the trait `Pattern` is not implemented for `String`
+   |       |
    |       required by a bound introduced by this call
    |
    = note: required for `String` to implement `Pattern`
 note: required by a bound in `core::str::<impl str>::starts_with`
   --> $SRC_DIR/core/src/str/mod.rs:LL:COL
+help: consider borrowing here
+   |
+LL |     x.starts_with(&"hi".to_string())
+   |                   +
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/issue-52820.stderr b/tests/ui/suggestions/issue-52820.stderr
index a67d7501417..de2c9542f61 100644
--- a/tests/ui/suggestions/issue-52820.stderr
+++ b/tests/ui/suggestions/issue-52820.stderr
@@ -13,10 +13,13 @@ error[E0308]: mismatched types
   --> $DIR/issue-52820.rs:13:17
    |
 LL |         brains: guts.clone(),
-   |                 ^^^^^-----^^
-   |                 |    |
-   |                 |    help: try using a conversion method: `to_string`
-   |                 expected `String`, found `&str`
+   |                 ^^^^^^^^^^^^ expected `String`, found `&str`
+   |
+help: try using a conversion method
+   |
+LL -         brains: guts.clone(),
+LL +         brains: guts.to_string(),
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/issue-53692.stderr b/tests/ui/suggestions/issue-53692.stderr
index 469a538411f..10ebb30a5b2 100644
--- a/tests/ui/suggestions/issue-53692.stderr
+++ b/tests/ui/suggestions/issue-53692.stderr
@@ -2,24 +2,31 @@ error[E0308]: mismatched types
   --> $DIR/issue-53692.rs:7:33
    |
 LL |     let items_clone: Vec<i32> = ref_items.clone();
-   |                      --------   ^^^^^^^^^^-----^^
-   |                      |          |         |
-   |                      |          |         help: try using a conversion method: `to_vec`
-   |                      |          expected `Vec<i32>`, found `&[i32]`
+   |                      --------   ^^^^^^^^^^^^^^^^^ expected `Vec<i32>`, found `&[i32]`
+   |                      |
    |                      expected due to this
    |
    = note: expected struct `Vec<i32>`
            found reference `&[i32]`
+help: try using a conversion method
+   |
+LL -     let items_clone: Vec<i32> = ref_items.clone();
+LL +     let items_clone: Vec<i32> = ref_items.to_vec();
+   |
 
 error[E0308]: mismatched types
   --> $DIR/issue-53692.rs:14:26
    |
 LL |     let string: String = s.clone();
-   |                 ------   ^^-----^^
-   |                 |        | |
-   |                 |        | help: try using a conversion method: `to_string`
-   |                 |        expected `String`, found `&str`
+   |                 ------   ^^^^^^^^^ expected `String`, found `&str`
+   |                 |
    |                 expected due to this
+   |
+help: try using a conversion method
+   |
+LL -     let string: String = s.clone();
+LL +     let string: String = s.to_string();
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/issue-59819.stderr b/tests/ui/suggestions/issue-59819.stderr
index 43acf9549c2..ab91961192f 100644
--- a/tests/ui/suggestions/issue-59819.stderr
+++ b/tests/ui/suggestions/issue-59819.stderr
@@ -28,10 +28,14 @@ error[E0308]: mismatched types
   --> $DIR/issue-59819.rs:34:21
    |
 LL |     let g: String = f;
-   |            ------   ^- help: try using a conversion method: `.to_string()`
-   |            |        |
-   |            |        expected `String`, found `Bar`
+   |            ------   ^ expected `String`, found `Bar`
+   |            |
    |            expected due to this
+   |
+help: try using a conversion method
+   |
+LL |     let g: String = f.to_string();
+   |                      ++++++++++++
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/suggestions/issue-62843.stderr b/tests/ui/suggestions/issue-62843.stderr
index c3480a8e396..c3c0360b3a9 100644
--- a/tests/ui/suggestions/issue-62843.stderr
+++ b/tests/ui/suggestions/issue-62843.stderr
@@ -2,15 +2,17 @@ error[E0277]: the trait bound `String: Pattern` is not satisfied
   --> $DIR/issue-62843.rs:4:32
    |
 LL |     println!("{:?}", line.find(pattern));
-   |                           ---- -^^^^^^
-   |                           |    |
-   |                           |    the trait `Pattern` is not implemented for `String`
-   |                           |    help: consider borrowing here: `&`
+   |                           ---- ^^^^^^^ the trait `Pattern` is not implemented for `String`
+   |                           |
    |                           required by a bound introduced by this call
    |
    = note: required for `String` to implement `Pattern`
 note: required by a bound in `core::str::<impl str>::find`
   --> $SRC_DIR/core/src/str/mod.rs:LL:COL
+help: consider borrowing here
+   |
+LL |     println!("{:?}", line.find(&pattern));
+   |                                +
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/issue-83943.stderr b/tests/ui/suggestions/issue-83943.stderr
index 1a085368485..e714a126f4a 100644
--- a/tests/ui/suggestions/issue-83943.stderr
+++ b/tests/ui/suggestions/issue-83943.stderr
@@ -6,11 +6,14 @@ LL | |         "A".to_string()
    | |         --------------- expected because of this
 LL | |     } else {
 LL | |         "B"
-   | |         ^^^- help: try using a conversion method: `.to_string()`
-   | |         |
-   | |         expected `String`, found `&str`
+   | |         ^^^ expected `String`, found `&str`
 LL | |     };
    | |_____- `if` and `else` have incompatible types
+   |
+help: try using a conversion method
+   |
+LL |         "B".to_string()
+   |            ++++++++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/issue-84973-2.stderr b/tests/ui/suggestions/issue-84973-2.stderr
index 914307008ef..74995a0500a 100644
--- a/tests/ui/suggestions/issue-84973-2.stderr
+++ b/tests/ui/suggestions/issue-84973-2.stderr
@@ -2,10 +2,8 @@ error[E0277]: the trait bound `i32: Tr` is not satisfied
   --> $DIR/issue-84973-2.rs:11:9
    |
 LL |     foo(a);
-   |     --- ^
-   |     |   |
-   |     |   the trait `Tr` is not implemented for `i32`
-   |     |   help: consider mutably borrowing here: `&mut`
+   |     --- ^ the trait `Tr` is not implemented for `i32`
+   |     |
    |     required by a bound introduced by this call
    |
 note: required by a bound in `foo`
@@ -13,6 +11,10 @@ note: required by a bound in `foo`
    |
 LL | fn foo<T: Tr>(i: T) {}
    |           ^^ required by this bound in `foo`
+help: consider mutably borrowing here
+   |
+LL |     foo(&mut a);
+   |         ++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/issue-84973-negative.stderr b/tests/ui/suggestions/issue-84973-negative.stderr
index e3e6296890f..ce838bce09e 100644
--- a/tests/ui/suggestions/issue-84973-negative.stderr
+++ b/tests/ui/suggestions/issue-84973-negative.stderr
@@ -17,10 +17,8 @@ error[E0277]: the trait bound `f32: Tr` is not satisfied
   --> $DIR/issue-84973-negative.rs:11:9
    |
 LL |     bar(b);
-   |     --- ^
-   |     |   |
-   |     |   the trait `Tr` is not implemented for `f32`
-   |     |   help: consider borrowing here: `&`
+   |     --- ^ the trait `Tr` is not implemented for `f32`
+   |     |
    |     required by a bound introduced by this call
    |
 note: required by a bound in `bar`
@@ -28,6 +26,10 @@ note: required by a bound in `bar`
    |
 LL | fn bar<T: Tr>(t: T) {}
    |           ^^ required by this bound in `bar`
+help: consider borrowing here
+   |
+LL |     bar(&b);
+   |         +
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/issue-84973.stderr b/tests/ui/suggestions/issue-84973.stderr
index 5ca91c544db..c5e1958e030 100644
--- a/tests/ui/suggestions/issue-84973.stderr
+++ b/tests/ui/suggestions/issue-84973.stderr
@@ -2,10 +2,8 @@ error[E0277]: the trait bound `Fancy: SomeTrait` is not satisfied
   --> $DIR/issue-84973.rs:6:24
    |
 LL |     let o = Other::new(f);
-   |             ---------- ^
-   |             |          |
-   |             |          the trait `SomeTrait` is not implemented for `Fancy`
-   |             |          help: consider borrowing here: `&`
+   |             ---------- ^ the trait `SomeTrait` is not implemented for `Fancy`
+   |             |
    |             required by a bound introduced by this call
    |
 note: required by a bound in `Other::<'a, G>::new`
@@ -16,6 +14,10 @@ LL |     G: SomeTrait,
 LL | {
 LL |     pub fn new(g: G) -> Self {
    |            --- required by a bound in this associated function
+help: consider borrowing here
+   |
+LL |     let o = Other::new(&f);
+   |                        +
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/only-suggest-removal-of-conversion-method-calls.stderr b/tests/ui/suggestions/only-suggest-removal-of-conversion-method-calls.stderr
index c721ceb1146..ed94ebd27ff 100644
--- a/tests/ui/suggestions/only-suggest-removal-of-conversion-method-calls.stderr
+++ b/tests/ui/suggestions/only-suggest-removal-of-conversion-method-calls.stderr
@@ -5,9 +5,12 @@ LL | fn get_name() -> String {
    |                  ------ expected `String` because of return type
 ...
 LL |     your_name.trim()
-   |     ^^^^^^^^^^^^^^^^- help: try using a conversion method: `.to_string()`
-   |     |
-   |     expected `String`, found `&str`
+   |     ^^^^^^^^^^^^^^^^ expected `String`, found `&str`
+   |
+help: try using a conversion method
+   |
+LL |     your_name.trim().to_string()
+   |                     ++++++++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/suggest-adding-reference-to-trait-assoc-item.stderr b/tests/ui/suggestions/suggest-adding-reference-to-trait-assoc-item.stderr
index 146d6705243..485015a98f2 100644
--- a/tests/ui/suggestions/suggest-adding-reference-to-trait-assoc-item.stderr
+++ b/tests/ui/suggestions/suggest-adding-reference-to-trait-assoc-item.stderr
@@ -2,19 +2,23 @@ error[E0277]: the trait bound `&mut usize: Default` is not satisfied
   --> $DIR/suggest-adding-reference-to-trait-assoc-item.rs:13:9
    |
 LL |     foo(Default::default());
-   |         -^^^^^^^^^^^^^^^^^
-   |         |
-   |         the trait `Default` is not implemented for `&mut usize`
-   |         help: consider mutably borrowing here: `&mut`
+   |         ^^^^^^^^^^^^^^^^^^ the trait `Default` is not implemented for `&mut usize`
+   |
+help: consider mutably borrowing here
+   |
+LL |     foo(&mut Default::default());
+   |         ++++
 
 error[E0277]: the trait bound `&usize: Default` is not satisfied
   --> $DIR/suggest-adding-reference-to-trait-assoc-item.rs:14:9
    |
 LL |     bar(Default::default());
-   |         -^^^^^^^^^^^^^^^^^
-   |         |
-   |         the trait `Default` is not implemented for `&usize`
-   |         help: consider borrowing here: `&`
+   |         ^^^^^^^^^^^^^^^^^^ the trait `Default` is not implemented for `&usize`
+   |
+help: consider borrowing here
+   |
+LL |     bar(&Default::default());
+   |         +
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/suggestions/suggest-imm-mut-trait-implementations.stderr b/tests/ui/suggestions/suggest-imm-mut-trait-implementations.stderr
index b3a0c68450e..f2eb651eaa4 100644
--- a/tests/ui/suggestions/suggest-imm-mut-trait-implementations.stderr
+++ b/tests/ui/suggestions/suggest-imm-mut-trait-implementations.stderr
@@ -22,10 +22,8 @@ error[E0277]: the trait bound `B: Trait` is not satisfied
   --> $DIR/suggest-imm-mut-trait-implementations.rs:21:9
    |
 LL |     foo(b);
-   |     --- ^
-   |     |   |
-   |     |   the trait `Trait` is not implemented for `B`
-   |     |   help: consider borrowing here: `&`
+   |     --- ^ the trait `Trait` is not implemented for `B`
+   |     |
    |     required by a bound introduced by this call
    |
 note: required by a bound in `foo`
@@ -33,15 +31,17 @@ note: required by a bound in `foo`
    |
 LL | fn foo<X: Trait>(_: X) {}
    |           ^^^^^ required by this bound in `foo`
+help: consider borrowing here
+   |
+LL |     foo(&b);
+   |         +
 
 error[E0277]: the trait bound `C: Trait` is not satisfied
   --> $DIR/suggest-imm-mut-trait-implementations.rs:22:9
    |
 LL |     foo(c);
-   |     --- ^
-   |     |   |
-   |     |   the trait `Trait` is not implemented for `C`
-   |     |   help: consider mutably borrowing here: `&mut`
+   |     --- ^ the trait `Trait` is not implemented for `C`
+   |     |
    |     required by a bound introduced by this call
    |
 note: required by a bound in `foo`
@@ -49,6 +49,10 @@ note: required by a bound in `foo`
    |
 LL | fn foo<X: Trait>(_: X) {}
    |           ^^^^^ required by this bound in `foo`
+help: consider mutably borrowing here
+   |
+LL |     foo(&mut c);
+   |         ++++
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/switched-expectations.stderr b/tests/ui/switched-expectations.stderr
index cc576747400..e235c2da1f7 100644
--- a/tests/ui/switched-expectations.stderr
+++ b/tests/ui/switched-expectations.stderr
@@ -2,9 +2,12 @@ error[E0308]: mismatched types
   --> $DIR/switched-expectations.rs:3:30
    |
 LL |     let ref string: String = var;
-   |                              ^^^- help: try using a conversion method: `.to_string()`
-   |                              |
-   |                              expected `String`, found `i32`
+   |                              ^^^ expected `String`, found `i32`
+   |
+help: try using a conversion method
+   |
+LL |     let ref string: String = var.to_string();
+   |                                 ++++++++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/negative-impls/negated-auto-traits-error.stderr b/tests/ui/traits/negative-impls/negated-auto-traits-error.stderr
index cc5ca471788..8f5b937e586 100644
--- a/tests/ui/traits/negative-impls/negated-auto-traits-error.stderr
+++ b/tests/ui/traits/negative-impls/negated-auto-traits-error.stderr
@@ -61,10 +61,8 @@ error[E0277]: `dummy2::TestType` cannot be sent between threads safely
   --> $DIR/negated-auto-traits-error.rs:48:13
    |
 LL |     is_send(Box::new(TestType));
-   |     ------- -^^^^^^^^^^^^^^^^^
-   |     |       |
-   |     |       the trait `Send` is not implemented for `Unique<dummy2::TestType>`
-   |     |       help: consider borrowing here: `&`
+   |     ------- ^^^^^^^^^^^^^^^^^^ the trait `Send` is not implemented for `Unique<dummy2::TestType>`
+   |     |
    |     required by a bound introduced by this call
    |
    = note: the trait bound `Unique<dummy2::TestType>: Send` is not satisfied
@@ -76,6 +74,10 @@ note: required by a bound in `is_send`
    |
 LL | fn is_send<T: Send>(_: T) {}
    |               ^^^^ required by this bound in `is_send`
+help: consider borrowing here
+   |
+LL |     is_send(&Box::new(TestType));
+   |             +
 
 error[E0277]: `dummy3::TestType` cannot be sent between threads safely
   --> $DIR/negated-auto-traits-error.rs:56:13
diff --git a/tests/ui/typeck/conversion-methods.stderr b/tests/ui/typeck/conversion-methods.stderr
index a9b5078ccdd..fa8928f1454 100644
--- a/tests/ui/typeck/conversion-methods.stderr
+++ b/tests/ui/typeck/conversion-methods.stderr
@@ -2,28 +2,40 @@ error[E0308]: mismatched types
   --> $DIR/conversion-methods.rs:5:41
    |
 LL |     let _tis_an_instants_play: String = "'Tis a fond Ambush—";
-   |                                ------   ^^^^^^^^^^^^^^^^^^^^^- help: try using a conversion method: `.to_string()`
-   |                                |        |
-   |                                |        expected `String`, found `&str`
+   |                                ------   ^^^^^^^^^^^^^^^^^^^^^ expected `String`, found `&str`
+   |                                |
    |                                expected due to this
+   |
+help: try using a conversion method
+   |
+LL |     let _tis_an_instants_play: String = "'Tis a fond Ambush—".to_string();
+   |                                                              ++++++++++++
 
 error[E0308]: mismatched types
   --> $DIR/conversion-methods.rs:6:40
    |
 LL |     let _just_to_make_bliss: PathBuf = Path::new("/ern/her/own/surprise");
-   |                              -------   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^- help: try using a conversion method: `.to_path_buf()`
-   |                              |         |
-   |                              |         expected `PathBuf`, found `&Path`
+   |                              -------   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `PathBuf`, found `&Path`
+   |                              |
    |                              expected due to this
+   |
+help: try using a conversion method
+   |
+LL |     let _just_to_make_bliss: PathBuf = Path::new("/ern/her/own/surprise").to_path_buf();
+   |                                                                          ++++++++++++++
 
 error[E0308]: mismatched types
   --> $DIR/conversion-methods.rs:9:40
    |
 LL |     let _but_should_the_play: String = 2; // Perhaps surprisingly, we suggest .to_string() here
-   |                               ------   ^- help: try using a conversion method: `.to_string()`
-   |                               |        |
-   |                               |        expected `String`, found integer
+   |                               ------   ^ expected `String`, found integer
+   |                               |
    |                               expected due to this
+   |
+help: try using a conversion method
+   |
+LL |     let _but_should_the_play: String = 2.to_string(); // Perhaps surprisingly, we suggest .to_string() here
+   |                                         ++++++++++++
 
 error[E0308]: mismatched types
   --> $DIR/conversion-methods.rs:12:47
-- 
cgit 1.4.1-3-g733a5


From d6924441cd2b49678fcaf7cdee4e4a0263b7bdbf Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Thu, 10 Jul 2025 17:34:39 +0000
Subject: Update test

---
 .../dont-suggest-borrowing-existing-borrow.fixed   | 14 +++++-
 .../dont-suggest-borrowing-existing-borrow.rs      | 12 ++++-
 .../dont-suggest-borrowing-existing-borrow.stderr  | 58 ++++++++++++++++++----
 3 files changed, 70 insertions(+), 14 deletions(-)

diff --git a/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.fixed b/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.fixed
index 95fd920dec2..00b92b42bb5 100644
--- a/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.fixed
+++ b/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.fixed
@@ -4,14 +4,24 @@ struct S;
 trait Trait {
     fn foo() {}
 }
-impl Trait for &S {}
 impl Trait for &mut S {}
+trait Trait2 {
+    fn bar() {}
+}
+impl Trait2 for &S {}
+impl Trait2 for &mut S {}
 fn main() {
     let _ = <&str>::from("value");
     //~^ ERROR the trait bound `str: From<_>` is not satisfied
     //~| ERROR the size for values of type `str` cannot be known at compilation time
     let _ = <&mut S>::foo();
     //~^ ERROR the trait bound `S: Trait` is not satisfied
-    let _ = <&S>::foo();
+    let _ = <&mut S>::foo();
+    //~^ ERROR the trait bound `S: Trait` is not satisfied
+    let _ = <&mut S>::foo();
     //~^ ERROR the trait bound `S: Trait` is not satisfied
+    let _ = <&mut S>::bar();
+    //~^ ERROR the trait bound `S: Trait2` is not satisfied
+    let _ = <&S>::bar();
+    //~^ ERROR the trait bound `S: Trait2` is not satisfied
 }
diff --git a/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.rs b/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.rs
index f79d2465062..3059ccdffb4 100644
--- a/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.rs
+++ b/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.rs
@@ -4,8 +4,12 @@ struct S;
 trait Trait {
     fn foo() {}
 }
-impl Trait for &S {}
 impl Trait for &mut S {}
+trait Trait2 {
+    fn bar() {}
+}
+impl Trait2 for &S {}
+impl Trait2 for &mut S {}
 fn main() {
     let _ = &str::from("value");
     //~^ ERROR the trait bound `str: From<_>` is not satisfied
@@ -14,4 +18,10 @@ fn main() {
     //~^ ERROR the trait bound `S: Trait` is not satisfied
     let _ = &S::foo();
     //~^ ERROR the trait bound `S: Trait` is not satisfied
+    let _ = S::foo();
+    //~^ ERROR the trait bound `S: Trait` is not satisfied
+    let _ = &mut S::bar();
+    //~^ ERROR the trait bound `S: Trait2` is not satisfied
+    let _ = &S::bar();
+    //~^ ERROR the trait bound `S: Trait2` is not satisfied
 }
diff --git a/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.stderr b/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.stderr
index ac96ec76da7..c2e2fe941a6 100644
--- a/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.stderr
+++ b/tests/ui/suggestions/dont-suggest-borrowing-existing-borrow.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `str: From<_>` is not satisfied
-  --> $DIR/dont-suggest-borrowing-existing-borrow.rs:10:14
+  --> $DIR/dont-suggest-borrowing-existing-borrow.rs:14:14
    |
 LL |     let _ = &str::from("value");
    |              ^^^ the trait `From<_>` is not implemented for `str`
@@ -17,35 +17,71 @@ LL |     let _ = <&str>::from("value");
    |             +    +
 
 error[E0277]: the trait bound `S: Trait` is not satisfied
-  --> $DIR/dont-suggest-borrowing-existing-borrow.rs:13:18
+  --> $DIR/dont-suggest-borrowing-existing-borrow.rs:17:18
    |
 LL |     let _ = &mut S::foo();
    |                  ^ the trait `Trait` is not implemented for `S`
    |
-   = help: the following other types implement trait `Trait`:
-             &S
-             &mut S
+   = help: the trait `Trait` is implemented for `&mut S`
 help: you likely meant to call the associated function `foo` for type `&mut S`, but the code as written calls associated function `foo` on type `S`
    |
 LL |     let _ = <&mut S>::foo();
    |             +      +
 
 error[E0277]: the trait bound `S: Trait` is not satisfied
-  --> $DIR/dont-suggest-borrowing-existing-borrow.rs:15:14
+  --> $DIR/dont-suggest-borrowing-existing-borrow.rs:19:14
    |
 LL |     let _ = &S::foo();
    |              ^ the trait `Trait` is not implemented for `S`
    |
-   = help: the following other types implement trait `Trait`:
+   = help: the trait `Trait` is implemented for `&mut S`
+help: you likely meant to call the associated function `foo` for type `&S`, but the code as written calls associated function `foo` on type `S`
+   |
+LL -     let _ = &S::foo();
+LL +     let _ = <&mut S>::foo();
+   |
+
+error[E0277]: the trait bound `S: Trait` is not satisfied
+  --> $DIR/dont-suggest-borrowing-existing-borrow.rs:21:13
+   |
+LL |     let _ = S::foo();
+   |             ^ the trait `Trait` is not implemented for `S`
+   |
+help: consider mutably borrowing here
+   |
+LL |     let _ = <&mut S>::foo();
+   |             +++++  +
+
+error[E0277]: the trait bound `S: Trait2` is not satisfied
+  --> $DIR/dont-suggest-borrowing-existing-borrow.rs:23:18
+   |
+LL |     let _ = &mut S::bar();
+   |                  ^ the trait `Trait2` is not implemented for `S`
+   |
+   = help: the following other types implement trait `Trait2`:
              &S
              &mut S
-help: you likely meant to call the associated function `foo` for type `&S`, but the code as written calls associated function `foo` on type `S`
+help: you likely meant to call the associated function `bar` for type `&mut S`, but the code as written calls associated function `bar` on type `S`
+   |
+LL |     let _ = <&mut S>::bar();
+   |             +      +
+
+error[E0277]: the trait bound `S: Trait2` is not satisfied
+  --> $DIR/dont-suggest-borrowing-existing-borrow.rs:25:14
+   |
+LL |     let _ = &S::bar();
+   |              ^ the trait `Trait2` is not implemented for `S`
+   |
+   = help: the following other types implement trait `Trait2`:
+             &S
+             &mut S
+help: you likely meant to call the associated function `bar` for type `&S`, but the code as written calls associated function `bar` on type `S`
    |
-LL |     let _ = <&S>::foo();
+LL |     let _ = <&S>::bar();
    |             +  +
 
 error[E0277]: the size for values of type `str` cannot be known at compilation time
-  --> $DIR/dont-suggest-borrowing-existing-borrow.rs:10:14
+  --> $DIR/dont-suggest-borrowing-existing-borrow.rs:14:14
    |
 LL |     let _ = &str::from("value");
    |              ^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
@@ -53,6 +89,6 @@ LL |     let _ = &str::from("value");
    = help: the trait `Sized` is not implemented for `str`
    = note: the return type of a function must have a statically known size
 
-error: aborting due to 4 previous errors
+error: aborting due to 7 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 341f12df67946faf630e6a656f12e504e9721d44 Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Thu, 10 Jul 2025 19:49:32 +0200
Subject: Properly track the depth when expanding free alias types

---
 compiler/rustc_middle/src/ty/util.rs       |  6 ++++--
 tests/ui/lazy-type-alias/deep-expansion.rs | 20 ++++++++++++++++++++
 2 files changed, 24 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/lazy-type-alias/deep-expansion.rs

diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 69b8be3d9cb..fd80d85f198 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -1052,9 +1052,11 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for FreeAliasTypeExpander<'tcx> {
         }
 
         self.depth += 1;
-        ensure_sufficient_stack(|| {
+        let ty = ensure_sufficient_stack(|| {
             self.tcx.type_of(alias.def_id).instantiate(self.tcx, alias.args).fold_with(self)
-        })
+        });
+        self.depth -= 1;
+        ty
     }
 
     fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
diff --git a/tests/ui/lazy-type-alias/deep-expansion.rs b/tests/ui/lazy-type-alias/deep-expansion.rs
new file mode 100644
index 00000000000..c4461abdb81
--- /dev/null
+++ b/tests/ui/lazy-type-alias/deep-expansion.rs
@@ -0,0 +1,20 @@
+// In several type analysis passes we employ a specialized expansion procedure.
+// This procedure used to incorrectly track expansion depth (growing much faster
+// than normalization depth) resulting in its internal assertion triggering.
+//
+// issue: <https://github.com/rust-lang/rust/issues/142419>
+//@ check-pass
+#![feature(lazy_type_alias)]
+#![expect(incomplete_features)]
+
+type T0 = (T1, T1, T1, T1);
+type T1 = (T2, T2, T2, T2);
+type T2 = (T3, T3, T3, T3);
+type T3 = (T4, T4, T4, T4);
+type T4 = (T5, T5, T5, T5);
+type T5 = (T6, T6, T6, T6);
+type T6 = (T7, T7, T7, T7);
+type T7 = ();
+
+fn accept(_: T0) {}
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From b9af6670d882c4d5f71f760c4efaceec2c849030 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 10 Jul 2025 20:01:15 +0200
Subject: Bump nightly version -> 2025-07-10

---
 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 649748d1534..645b644d9f4 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-2025-06-26
+nightly-2025-07-10
 ```
 <!-- end autogenerated nightly -->
 
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 124756a3600..f46e079db3f 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2025-06-26"
+channel = "nightly-2025-07-10"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"
-- 
cgit 1.4.1-3-g733a5


From 69fca569eb0bd4b777fbb970477e561efa62a6dd Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 10 Jul 2025 20:25:57 +0200
Subject: Update Cargo.lock

---
 Cargo.lock | 80 +++++++++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 58 insertions(+), 22 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 271a2f7962c..549818eecb0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -569,22 +569,16 @@ dependencies = [
  "color-print",
  "declare_clippy_lint",
  "filetime",
- "futures",
- "if_chain",
  "itertools",
- "parking_lot",
  "pulldown-cmark",
- "quote",
  "regex",
  "rustc_tools_util 0.4.2",
  "serde",
  "serde_json",
- "syn 2.0.104",
  "tempfile",
- "termize 0.1.1",
- "tokio",
+ "termize",
  "toml 0.7.8",
- "ui_test",
+ "ui_test 0.30.2",
  "walkdir",
 ]
 
@@ -642,6 +636,21 @@ dependencies = [
  "rustc-semver",
 ]
 
+[[package]]
+name = "clippy_test_deps"
+version = "0.1.0"
+dependencies = [
+ "futures",
+ "if_chain",
+ "itertools",
+ "parking_lot",
+ "quote",
+ "regex",
+ "serde",
+ "syn 2.0.104",
+ "tokio",
+]
+
 [[package]]
 name = "clippy_utils"
 version = "0.1.90"
@@ -2409,7 +2418,7 @@ dependencies = [
  "smallvec",
  "tempfile",
  "tikv-jemalloc-sys",
- "ui_test",
+ "ui_test 0.29.2",
 ]
 
 [[package]]
@@ -3773,7 +3782,7 @@ dependencies = [
  "serde",
  "serde_json",
  "termcolor",
- "termize 0.2.0",
+ "termize",
  "tracing",
  "windows 0.61.3",
 ]
@@ -4536,7 +4545,7 @@ dependencies = [
  "rustc_serialize",
  "rustc_span",
  "rustc_target",
- "termize 0.2.0",
+ "termize",
  "tracing",
  "windows 0.61.3",
 ]
@@ -5067,6 +5076,17 @@ dependencies = [
  "color-eyre",
 ]
 
+[[package]]
+name = "spanned"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c92d4b0c055fde758f086eb4a6e73410247df8a3837fd606d2caeeaf72aa566d"
+dependencies = [
+ "anyhow",
+ "bstr",
+ "color-eyre",
+]
+
 [[package]]
 name = "spdx-expression"
 version = "0.5.2"
@@ -5305,16 +5325,6 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "termize"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1706be6b564323ce7092f5f7e6b118a14c8ef7ed0e69c8c5329c914a9f101295"
-dependencies = [
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "termize"
 version = "0.2.0"
@@ -5726,7 +5736,33 @@ dependencies = [
  "rustfix",
  "serde",
  "serde_json",
- "spanned",
+ "spanned 0.3.0",
+]
+
+[[package]]
+name = "ui_test"
+version = "0.30.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b56a6897cc4bb6f8daf1939b0b39cd9645856997f46f4d0b3e3cb7122dfe9251"
+dependencies = [
+ "annotate-snippets 0.11.5",
+ "anyhow",
+ "bstr",
+ "cargo-platform",
+ "cargo_metadata 0.18.1",
+ "color-eyre",
+ "colored",
+ "comma",
+ "crossbeam-channel",
+ "indicatif",
+ "levenshtein",
+ "prettydiff",
+ "regex",
+ "rustc_version",
+ "rustfix",
+ "serde",
+ "serde_json",
+ "spanned 0.4.1",
 ]
 
 [[package]]
-- 
cgit 1.4.1-3-g733a5


From c629a450d650f478bde8fffca92a0da7b0701316 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 10 Jul 2025 20:35:35 +0200
Subject: Add clippy_test_deps to workspace member of repo

---
 Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Cargo.toml b/Cargo.toml
index 6d3425f4115..9890027d098 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,6 +13,7 @@ members = [
   "src/tools/cargotest",
   "src/tools/clippy",
   "src/tools/clippy/clippy_dev",
+  "src/tools/clippy/clippy_test_deps",
   "src/tools/collect-license-metadata",
   "src/tools/compiletest",
   "src/tools/coverage-dump",
-- 
cgit 1.4.1-3-g733a5


From a8663770c96c3be6d3a42bb84f2e377921628c1e Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Thu, 10 Jul 2025 21:04:40 +0200
Subject: Add target maintainer information for aarch64-unknown-linux-musl

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 src/doc/rustc/src/SUMMARY.md                       |  1 +
 src/doc/rustc/src/platform-support.md              |  2 +-
 .../platform-support/aarch64-unknown-linux-musl.md | 49 ++++++++++++++++++++++
 3 files changed, 51 insertions(+), 1 deletion(-)
 create mode 100644 src/doc/rustc/src/platform-support/aarch64-unknown-linux-musl.md

diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index e1742631f63..7c688e32bc0 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -46,6 +46,7 @@
     - [\*-apple-watchos](platform-support/apple-watchos.md)
     - [\*-apple-visionos](platform-support/apple-visionos.md)
     - [aarch64-nintendo-switch-freestanding](platform-support/aarch64-nintendo-switch-freestanding.md)
+    - [aarch64-unknown-linux-musl](platform-support/aarch64-unknown-linux-musl.md)
     - [amdgcn-amd-amdhsa](platform-support/amdgcn-amd-amdhsa.md)
     - [armeb-unknown-linux-gnueabi](platform-support/armeb-unknown-linux-gnueabi.md)
     - [arm-none-eabi](platform-support/arm-none-eabi.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index ed01de4c1c3..65b70630153 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -90,7 +90,7 @@ target | notes
 -------|-------
 [`aarch64-pc-windows-gnullvm`](platform-support/windows-gnullvm.md) | ARM64 MinGW (Windows 10+), LLVM ABI
 [`aarch64-pc-windows-msvc`](platform-support/windows-msvc.md) | ARM64 Windows MSVC
-`aarch64-unknown-linux-musl` | ARM64 Linux with musl 1.2.3
+[`aarch64-unknown-linux-musl`](platform-support/aarch64-unknown-linux-musl.md) | ARM64 Linux with musl 1.2.3
 [`aarch64-unknown-linux-ohos`](platform-support/openharmony.md) | ARM64 OpenHarmony
 `arm-unknown-linux-gnueabi` | Armv6 Linux (kernel 3.2+, glibc 2.17)
 `arm-unknown-linux-gnueabihf` | Armv6 Linux, hardfloat (kernel 3.2+, glibc 2.17)
diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-linux-musl.md b/src/doc/rustc/src/platform-support/aarch64-unknown-linux-musl.md
new file mode 100644
index 00000000000..5d9a552e460
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-linux-musl.md
@@ -0,0 +1,49 @@
+# aarch64-unknown-linux-musl
+
+**Tier: 2**
+
+Target for 64-bit little endian ARMv8-A Linux programs using musl libc.
+
+## Target maintainers
+
+[@Gelbpunkt](https://github.com/Gelbpunkt)
+[@famfo](https://github.com/famfo)
+
+## Requirements
+
+Building the target itself requires a 64-bit little endian ARMv8-A compiler
+that is supported by `cc-rs`.
+
+## Building the target
+
+The target can be built by enabling it for a `rustc` build.
+
+```toml
+[build]
+target = ["aarch64-unknown-linux-musl"]
+```
+
+Make sure your C compiler is included in `$PATH`, then add it to the
+`bootstrap.toml`:
+
+```toml
+[target.aarch64-unknown-linux-musl]
+cc = "aarch64-linux-musl-gcc"
+cxx = "aarch64-linux-musl-g++"
+ar = "aarch64-linux-musl-ar"
+linker = "aarch64-linux-musl-gcc"
+```
+
+## Building Rust programs
+
+This target is distributed through `rustup`, and otherwise requires no
+special configuration.
+
+## Cross-compilation
+
+This target can be cross-compiled from any host.
+
+## Testing
+
+This target can be tested as normal with `x.py` on a 64-bit little endian
+ARMv8-A host or via QEMU emulation.
-- 
cgit 1.4.1-3-g733a5


From e6a8a133bfae61fd03cfd2d65ed3673c10997846 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Fri, 11 Jul 2025 00:08:24 +0300
Subject: Fix display of `use<>` syntax

---
 src/tools/rust-analyzer/crates/hir-ty/src/display.rs | 1 +
 1 file changed, 1 insertion(+)

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 810fe76f231..61d62650453 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -2328,6 +2328,7 @@ impl HirDisplayWithExpressionStore for TypeBound {
                 store[*path].hir_fmt(f, store)
             }
             TypeBound::Use(args) => {
+                write!(f, "use<")?;
                 let edition = f.edition();
                 let last = args.len().saturating_sub(1);
                 for (idx, arg) in args.iter().enumerate() {
-- 
cgit 1.4.1-3-g733a5


From 0e00ba127bd9babd88d488060fd85ff9b840a80e Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Thu, 10 Jul 2025 17:50:49 -0400
Subject: Upgrade dependencies to the latest version

This picks up a fix in `rustc_apfloat` [1] that resolves a problem with
`fma`.

[1]: https://github.com/rust-lang/rustc_apfloat/releases/tag/rustc_apfloat-v0.2.3%2Bllvm-462a31f5a5ab
---
 library/compiler-builtins/builtins-test/Cargo.toml        | 2 +-
 library/compiler-builtins/crates/libm-macros/Cargo.toml   | 2 +-
 library/compiler-builtins/crates/musl-math-sys/Cargo.toml | 2 +-
 library/compiler-builtins/libm-test/Cargo.toml            | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/library/compiler-builtins/builtins-test/Cargo.toml b/library/compiler-builtins/builtins-test/Cargo.toml
index 093d4633f87..4607342cd5b 100644
--- a/library/compiler-builtins/builtins-test/Cargo.toml
+++ b/library/compiler-builtins/builtins-test/Cargo.toml
@@ -12,7 +12,7 @@ license = "MIT AND Apache-2.0 WITH LLVM-exception AND (MIT OR Apache-2.0)"
 # `xoshiro128**` is used for its quality, size, and speed at generating `u32` shift amounts.
 rand_xoshiro = "0.7"
 # To compare float builtins against
-rustc_apfloat = "0.2.2"
+rustc_apfloat = "0.2.3"
 # Really a dev dependency, but dev dependencies can't be optional
 iai-callgrind = { version = "0.14.1", optional = true }
 
diff --git a/library/compiler-builtins/crates/libm-macros/Cargo.toml b/library/compiler-builtins/crates/libm-macros/Cargo.toml
index 6bbf47784ff..100a8d0ec30 100644
--- a/library/compiler-builtins/crates/libm-macros/Cargo.toml
+++ b/library/compiler-builtins/crates/libm-macros/Cargo.toml
@@ -12,7 +12,7 @@ proc-macro = true
 heck = "0.5.0"
 proc-macro2 = "1.0.95"
 quote = "1.0.40"
-syn = { version = "2.0.101", features = ["full", "extra-traits", "visit-mut"] }
+syn = { version = "2.0.104", features = ["full", "extra-traits", "visit-mut"] }
 
 [lints.rust]
 # Values used during testing
diff --git a/library/compiler-builtins/crates/musl-math-sys/Cargo.toml b/library/compiler-builtins/crates/musl-math-sys/Cargo.toml
index 3b88117343b..39f6fa9065b 100644
--- a/library/compiler-builtins/crates/musl-math-sys/Cargo.toml
+++ b/library/compiler-builtins/crates/musl-math-sys/Cargo.toml
@@ -11,4 +11,4 @@ license = "MIT OR Apache-2.0"
 libm = { path = "../../libm" }
 
 [build-dependencies]
-cc = "1.2.25"
+cc = "1.2.29"
diff --git a/library/compiler-builtins/libm-test/Cargo.toml b/library/compiler-builtins/libm-test/Cargo.toml
index 05fcc3234e0..e577288c9c9 100644
--- a/library/compiler-builtins/libm-test/Cargo.toml
+++ b/library/compiler-builtins/libm-test/Cargo.toml
@@ -32,7 +32,7 @@ anyhow = "1.0.98"
 # This is not directly used but is required so we can enable `gmp-mpfr-sys/force-cross`.
 gmp-mpfr-sys = { version = "1.6.5", optional = true, default-features = false }
 iai-callgrind = { version = "0.14.1", optional = true }
-indicatif = { version = "0.17.11", default-features = false }
+indicatif = { version = "0.18.0", default-features = false }
 libm = { path = "../libm", features = ["unstable-public-internals"] }
 libm-macros = { path = "../crates/libm-macros" }
 musl-math-sys = { path = "../crates/musl-math-sys", optional = true }
-- 
cgit 1.4.1-3-g733a5


From f5c9403551435781afd651d62cb700eb4e81321e Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Thu, 10 Jul 2025 17:55:08 -0400
Subject: Upgrade `iai-callgrind` to 0.15

Pick up the latest version of iai-callgrind, which includes some output
improvements.

Changelog: https://github.com/iai-callgrind/iai-callgrind/releases
---
 library/compiler-builtins/builtins-test/Cargo.toml | 2 +-
 library/compiler-builtins/ci/bench-icount.sh       | 2 +-
 library/compiler-builtins/libm-test/Cargo.toml     | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/compiler-builtins/builtins-test/Cargo.toml b/library/compiler-builtins/builtins-test/Cargo.toml
index 4607342cd5b..00a9d8579d1 100644
--- a/library/compiler-builtins/builtins-test/Cargo.toml
+++ b/library/compiler-builtins/builtins-test/Cargo.toml
@@ -14,7 +14,7 @@ rand_xoshiro = "0.7"
 # To compare float builtins against
 rustc_apfloat = "0.2.3"
 # Really a dev dependency, but dev dependencies can't be optional
-iai-callgrind = { version = "0.14.1", optional = true }
+iai-callgrind = { version = "0.15.2", optional = true }
 
 [dependencies.compiler_builtins]
 path = "../builtins-shim"
diff --git a/library/compiler-builtins/ci/bench-icount.sh b/library/compiler-builtins/ci/bench-icount.sh
index d2baebb52d8..12228b9da97 100755
--- a/library/compiler-builtins/ci/bench-icount.sh
+++ b/library/compiler-builtins/ci/bench-icount.sh
@@ -28,7 +28,7 @@ function run_icount_benchmarks() {
 
     iai_args=(
         "--home" "$(pwd)/$iai_home"
-        "--regression=ir=5.0"
+        "--callgrind-limits=ir=5.0"
         "--save-summary"
     )
 
diff --git a/library/compiler-builtins/libm-test/Cargo.toml b/library/compiler-builtins/libm-test/Cargo.toml
index e577288c9c9..0af6b0c1da5 100644
--- a/library/compiler-builtins/libm-test/Cargo.toml
+++ b/library/compiler-builtins/libm-test/Cargo.toml
@@ -31,7 +31,7 @@ short-benchmarks = []
 anyhow = "1.0.98"
 # This is not directly used but is required so we can enable `gmp-mpfr-sys/force-cross`.
 gmp-mpfr-sys = { version = "1.6.5", optional = true, default-features = false }
-iai-callgrind = { version = "0.14.1", optional = true }
+iai-callgrind = { version = "0.15.2", optional = true }
 indicatif = { version = "0.18.0", default-features = false }
 libm = { path = "../libm", features = ["unstable-public-internals"] }
 libm-macros = { path = "../crates/libm-macros" }
-- 
cgit 1.4.1-3-g733a5


From a7bf5c4fa2d83669511e88657c194edaec82a872 Mon Sep 17 00:00:00 2001
From: mejrs <59372212+mejrs@users.noreply.github.com>
Date: Fri, 11 Jul 2025 01:24:24 +0200
Subject: Split up the `unknown_or_malformed_diagnostic_attributes` lint

---
 compiler/rustc_lint/src/lib.rs                     |   8 ++
 compiler/rustc_lint_defs/src/builtin.rs            | 101 ++++++++++++++++++---
 compiler/rustc_passes/src/check_attr.rs            |  11 ++-
 compiler/rustc_resolve/src/macros.rs               |   4 +-
 .../src/error_reporting/traits/on_unimplemented.rs |  16 ++--
 .../traits/on_unimplemented_format.rs              |   8 +-
 src/tools/lint-docs/src/groups.rs                  |   4 +
 tests/ui/attributes/malformed-attrs.stderr         |   2 +-
 .../deny_malformed_attribute.stderr                |   1 +
 .../does_not_acccept_args.current.stderr           |   2 +-
 .../does_not_acccept_args.next.stderr              |   2 +-
 .../incorrect-locations.current.stderr             |   2 +-
 .../incorrect-locations.next.stderr                |   2 +-
 tests/ui/diagnostic_namespace/multiline_spans.rs   |  16 ++--
 .../ui/diagnostic_namespace/multiline_spans.stderr |   1 +
 .../non_existing_attributes_accepted.stderr        |   2 +-
 .../on_unimplemented/broken_format.rs              |  12 +--
 .../on_unimplemented/broken_format.stderr          |   2 +-
 ..._options_of_the_internal_rustc_attribute.stderr |   4 +-
 ...do_not_fail_parsing_on_invalid_options_1.stderr |   4 +-
 ...ted_options_and_continue_to_use_fallback.stderr |   2 +-
 .../on_unimplemented/on_impl_trait.stderr          |   2 +-
 .../report_warning_on_duplicated_options.stderr    |   2 +-
 tests/ui/diagnostic_namespace/suggest_typos.rs     |   2 +-
 tests/ui/diagnostic_namespace/suggest_typos.stderr |   4 +-
 25 files changed, 157 insertions(+), 59 deletions(-)

diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index 48982bda0a0..419124d5144 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -339,6 +339,14 @@ fn register_builtins(store: &mut LintStore) {
 
     add_lint_group!("deprecated_safe", DEPRECATED_SAFE_2024);
 
+    add_lint_group!(
+        "unknown_or_malformed_diagnostic_attributes",
+        MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+        MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
+        MISPLACED_DIAGNOSTIC_ATTRIBUTES,
+        UNKNOWN_DIAGNOSTIC_ATTRIBUTES
+    );
+
     // Register renamed and removed lints.
     store.register_renamed("single_use_lifetime", "single_use_lifetimes");
     store.register_renamed("elided_lifetime_in_path", "elided_lifetimes_in_paths");
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index b37548b281c..5669e6ba13f 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -63,7 +63,10 @@ declare_lint_pass! {
         LOSSY_PROVENANCE_CASTS,
         MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
         MACRO_USE_EXTERN_CRATE,
+        MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+        MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
         META_VARIABLE_MISUSE,
+        MISPLACED_DIAGNOSTIC_ATTRIBUTES,
         MISSING_ABI,
         MISSING_UNSAFE_ON_EXTERN,
         MUST_NOT_SUSPEND,
@@ -112,8 +115,8 @@ declare_lint_pass! {
         UNFULFILLED_LINT_EXPECTATIONS,
         UNINHABITED_STATIC,
         UNKNOWN_CRATE_TYPES,
+        UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
         UNKNOWN_LINTS,
-        UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
         UNNAMEABLE_TEST_ITEMS,
         UNNAMEABLE_TYPES,
         UNREACHABLE_CODE,
@@ -4284,31 +4287,105 @@ declare_lint! {
 }
 
 declare_lint! {
-    /// The `unknown_or_malformed_diagnostic_attributes` lint detects unrecognized or otherwise malformed
-    /// diagnostic attributes.
+    /// The `malformed_diagnostic_attributes` lint detects malformed diagnostic attributes.
     ///
     /// ### Example
     ///
     /// ```rust
-    /// #![feature(diagnostic_namespace)]
-    /// #[diagnostic::does_not_exist]
-    /// struct Foo;
+    /// #[diagnostic::do_not_recommend(message = "message")]
+    /// trait Trait {}
     /// ```
     ///
     /// {{produces}}
     ///
+    /// ### Explanation
+    ///
+    /// It is usually a mistake to use options or syntax that is not supported. Check the spelling,
+    /// and check the diagnostic attribute listing for the correct name and syntax. Also consider if
+    /// you are using an old version of the compiler; perhaps the option or syntax is only available
+    /// in a newer version. See the [reference] for a list of diagnostic attributes and the syntax
+    /// of each.
+    ///
+    /// [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace
+    pub MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+    Warn,
+    "detects malformed diagnostic attributes",
+}
+
+declare_lint! {
+    /// The `misplaced_diagnostic_attributes` lint detects wrongly placed diagnostic attributes.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// #[diagnostic::do_not_recommend]
+    /// struct NotUserFacing;
+    /// ```
+    ///
+    /// {{produces}}
     ///
     /// ### Explanation
     ///
-    /// It is usually a mistake to specify a diagnostic attribute that does not exist. Check
-    /// the spelling, and check the diagnostic attribute listing for the correct name. Also
-    /// consider if you are using an old version of the compiler, and the attribute
-    /// is only available in a newer version.
-    pub UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+    /// It is usually a mistake to specify a diagnostic attribute on an item it is not meant for.
+    /// For example, `#[diagnostic::do_not_recommend]` can only be placed on trait implementations,
+    /// and does nothing if placed elsewhere. See the [reference] for a list of diagnostic
+    /// attributes and their correct positions.
+    ///
+    /// [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace
+    pub MISPLACED_DIAGNOSTIC_ATTRIBUTES,
     Warn,
-    "unrecognized or malformed diagnostic attribute",
+    "detects diagnostic attributes that are placed on the wrong item",
 }
 
+declare_lint! {
+    /// The `unknown_diagnostic_attributes` lint detects unknown diagnostic attributes.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// #[diagnostic::does_not_exist]
+    /// struct Thing;
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// It is usually a mistake to specify a diagnostic attribute that does not exist. Check the
+    /// spelling, and check the diagnostic attribute listing for the correct name. Also consider if
+    /// you are using an old version of the compiler and the attribute is only available in a newer
+    /// version. See the [reference] for the list of diagnostic attributes.
+    ///
+    /// [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace
+    pub UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
+    Warn,
+    "detects unknown diagnostic attributes",
+}
+
+declare_lint! {
+    /// The `malformed_diagnostic_format_literals` lint detects malformed diagnostic format
+    /// literals.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// #[diagnostic::on_unimplemented(message = "{Self}} does not implement `Trait`")]
+    /// trait Trait {}
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// The `#[diagnostic::on_unimplemented]` attribute accepts string literal values that are
+    /// similar to `format!`'s string literal. See the [reference] for details on what is permitted
+    /// in this string literal.
+    ///
+    /// [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace
+    pub MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
+    Warn,
+    "detects diagnostic attribute with malformed diagnostic format literals",
+}
 declare_lint! {
     /// The `ambiguous_glob_imports` lint detects glob imports that should report ambiguity
     /// errors, but previously didn't do that due to rustc bugs.
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 9e4e78c1db6..87d66fcc7b6 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -33,7 +33,7 @@ use rustc_session::config::CrateType;
 use rustc_session::lint;
 use rustc_session::lint::builtin::{
     CONFLICTING_REPR_HINTS, INVALID_DOC_ATTRIBUTES, INVALID_MACRO_EXPORT_ARGUMENTS,
-    UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES, UNUSED_ATTRIBUTES,
+    MALFORMED_DIAGNOSTIC_ATTRIBUTES, MISPLACED_DIAGNOSTIC_ATTRIBUTES, UNUSED_ATTRIBUTES,
 };
 use rustc_session::parse::feature_err;
 use rustc_span::edition::Edition;
@@ -442,7 +442,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         );
     }
 
-    /// Checks if `#[diagnostic::do_not_recommend]` is applied on a trait impl.
+    /// Checks if `#[diagnostic::do_not_recommend]` is applied on a trait impl and that it has no
+    /// arguments.
     fn check_do_not_recommend(
         &self,
         attr_span: Span,
@@ -459,7 +460,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             )
         {
             self.tcx.emit_node_span_lint(
-                UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                MISPLACED_DIAGNOSTIC_ATTRIBUTES,
                 hir_id,
                 attr_span,
                 errors::IncorrectDoNotRecommendLocation,
@@ -467,7 +468,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
         if !attr.is_word() {
             self.tcx.emit_node_span_lint(
-                UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                 hir_id,
                 attr_span,
                 errors::DoNotRecommendDoesNotExpectArgs,
@@ -479,7 +480,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     fn check_diagnostic_on_unimplemented(&self, attr_span: Span, hir_id: HirId, target: Target) {
         if !matches!(target, Target::Trait) {
             self.tcx.emit_node_span_lint(
-                UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                MISPLACED_DIAGNOSTIC_ATTRIBUTES,
                 hir_id,
                 attr_span,
                 DiagnosticOnUnimplementedOnlyForTraits,
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index acbefe53422..f878b26d4e8 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -25,7 +25,7 @@ use rustc_middle::middle::stability;
 use rustc_middle::ty::{RegisteredTools, TyCtxt, Visibility};
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{
-    LEGACY_DERIVE_HELPERS, OUT_OF_SCOPE_MACRO_CALLS, UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+    LEGACY_DERIVE_HELPERS, OUT_OF_SCOPE_MACRO_CALLS, UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
     UNUSED_MACRO_RULES, UNUSED_MACROS,
 };
 use rustc_session::parse::feature_err;
@@ -690,7 +690,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             );
 
             self.tcx.sess.psess.buffer_lint(
-                UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
                 attribute.span(),
                 node_id,
                 BuiltinLintDiag::UnknownDiagnosticAttribute { span: attribute.span(), typo_name },
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 a52dbedfe1e..2344bc79f21 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
@@ -11,7 +11,9 @@ use rustc_macros::LintDiagnostic;
 use rustc_middle::bug;
 use rustc_middle::ty::print::PrintTraitRefExt;
 use rustc_middle::ty::{self, GenericArgsRef, GenericParamDef, GenericParamDefKind, TyCtxt};
-use rustc_session::lint::builtin::UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES;
+use rustc_session::lint::builtin::{
+    MALFORMED_DIAGNOSTIC_ATTRIBUTES, MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
+};
 use rustc_span::{Span, Symbol, sym};
 use tracing::{debug, info};
 
@@ -382,7 +384,7 @@ impl IgnoredDiagnosticOption {
         if let (Some(new_item), Some(old_item)) = (new, old) {
             if let Some(item_def_id) = item_def_id.as_local() {
                 tcx.emit_node_span_lint(
-                    UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                    MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                     tcx.local_def_id_to_hir_id(item_def_id),
                     new_item,
                     IgnoredDiagnosticOption { span: new_item, prev_span: old_item, option_name },
@@ -533,7 +535,7 @@ impl<'tcx> OnUnimplementedDirective {
             if is_diagnostic_namespace_variant {
                 if let Some(def_id) = item_def_id.as_local() {
                     tcx.emit_node_span_lint(
-                        UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                        MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                         tcx.local_def_id_to_hir_id(def_id),
                         vec![item.span()],
                         MalformedOnUnimplementedAttrLint::new(item.span()),
@@ -689,7 +691,7 @@ impl<'tcx> OnUnimplementedDirective {
 
                 if let Some(item_def_id) = item_def_id.as_local() {
                     tcx.emit_node_span_lint(
-                        UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                        MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                         tcx.local_def_id_to_hir_id(item_def_id),
                         report_span,
                         MalformedOnUnimplementedAttrLint::new(report_span),
@@ -702,7 +704,7 @@ impl<'tcx> OnUnimplementedDirective {
                 Attribute::Unparsed(p) if !matches!(p.args, AttrArgs::Empty) => {
                     if let Some(item_def_id) = item_def_id.as_local() {
                         tcx.emit_node_span_lint(
-                            UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                            MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                             tcx.local_def_id_to_hir_id(item_def_id),
                             attr.span(),
                             MalformedOnUnimplementedAttrLint::new(attr.span()),
@@ -712,7 +714,7 @@ impl<'tcx> OnUnimplementedDirective {
                 _ => {
                     if let Some(item_def_id) = item_def_id.as_local() {
                         tcx.emit_node_span_lint(
-                            UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                            MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                             tcx.local_def_id_to_hir_id(item_def_id),
                             attr.span(),
                             MissingOptionsForOnUnimplementedAttr,
@@ -859,7 +861,7 @@ impl<'tcx> OnUnimplementedFormatString {
                 if self.is_diagnostic_namespace_variant {
                     if let Some(trait_def_id) = trait_def_id.as_local() {
                         tcx.emit_node_span_lint(
-                            UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                            MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
                             tcx.local_def_id_to_hir_id(trait_def_id),
                             self.span,
                             WrappedParserError { description: e.description, label: e.label },
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented_format.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented_format.rs
index 3e8b906fa93..1954f8a1f63 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented_format.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented_format.rs
@@ -7,7 +7,7 @@ use rustc_middle::ty::{GenericParamDefKind, TyCtxt};
 use rustc_parse_format::{
     Argument, FormatSpec, ParseError, ParseMode, Parser, Piece as RpfPiece, Position,
 };
-use rustc_session::lint::builtin::UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES;
+use rustc_session::lint::builtin::MALFORMED_DIAGNOSTIC_FORMAT_LITERALS;
 use rustc_span::def_id::DefId;
 use rustc_span::{InnerSpan, Span, Symbol, kw, sym};
 
@@ -69,7 +69,7 @@ impl FormatWarning {
                 let this = tcx.item_ident(item_def_id);
                 if let Some(item_def_id) = item_def_id.as_local() {
                     tcx.emit_node_span_lint(
-                        UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                        MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
                         tcx.local_def_id_to_hir_id(item_def_id),
                         span,
                         UnknownFormatParameterForOnUnimplementedAttr {
@@ -82,7 +82,7 @@ impl FormatWarning {
             FormatWarning::PositionalArgument { span, .. } => {
                 if let Some(item_def_id) = item_def_id.as_local() {
                     tcx.emit_node_span_lint(
-                        UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                        MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
                         tcx.local_def_id_to_hir_id(item_def_id),
                         span,
                         DisallowedPositionalArgument,
@@ -92,7 +92,7 @@ impl FormatWarning {
             FormatWarning::InvalidSpecifier { span, .. } => {
                 if let Some(item_def_id) = item_def_id.as_local() {
                     tcx.emit_node_span_lint(
-                        UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                        MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
                         tcx.local_def_id_to_hir_id(item_def_id),
                         span,
                         InvalidFormatSpecifier,
diff --git a/src/tools/lint-docs/src/groups.rs b/src/tools/lint-docs/src/groups.rs
index 78d4f87ed0d..a24fbbc0cea 100644
--- a/src/tools/lint-docs/src/groups.rs
+++ b/src/tools/lint-docs/src/groups.rs
@@ -26,6 +26,10 @@ static GROUP_DESCRIPTIONS: &[(&str, &str)] = &[
         "Lints that detect identifiers which will be come keywords in later editions",
     ),
     ("deprecated-safe", "Lints for functions which were erroneously marked as safe in the past"),
+    (
+        "unknown-or-malformed-diagnostic-attributes",
+        "detects unknown or malformed diagnostic attributes",
+    ),
 ];
 
 type LintGroups = BTreeMap<String, BTreeSet<String>>;
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index 2f7bf50ead5..70fc646aa51 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -576,7 +576,7 @@ warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
 LL | #[diagnostic::do_not_recommend()]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(malformed_diagnostic_attributes)]` on by default
 
 warning: missing options for `on_unimplemented` attribute
   --> $DIR/malformed-attrs.rs:138:1
diff --git a/tests/ui/diagnostic_namespace/deny_malformed_attribute.stderr b/tests/ui/diagnostic_namespace/deny_malformed_attribute.stderr
index 32be9db5317..5c0a437aad8 100644
--- a/tests/ui/diagnostic_namespace/deny_malformed_attribute.stderr
+++ b/tests/ui/diagnostic_namespace/deny_malformed_attribute.stderr
@@ -9,6 +9,7 @@ note: the lint level is defined here
    |
 LL | #![deny(unknown_or_malformed_diagnostic_attributes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `#[deny(unknown_diagnostic_attributes)]` implied by `#[deny(unknown_or_malformed_diagnostic_attributes)]`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/does_not_acccept_args.current.stderr b/tests/ui/diagnostic_namespace/do_not_recommend/does_not_acccept_args.current.stderr
index 8a478a5c733..9d1556ee0c1 100644
--- a/tests/ui/diagnostic_namespace/do_not_recommend/does_not_acccept_args.current.stderr
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/does_not_acccept_args.current.stderr
@@ -4,7 +4,7 @@ warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
 LL | #[diagnostic::do_not_recommend(not_accepted)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(malformed_diagnostic_attributes)]` on by default
 
 warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
   --> $DIR/does_not_acccept_args.rs:15:1
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/does_not_acccept_args.next.stderr b/tests/ui/diagnostic_namespace/do_not_recommend/does_not_acccept_args.next.stderr
index 8a478a5c733..9d1556ee0c1 100644
--- a/tests/ui/diagnostic_namespace/do_not_recommend/does_not_acccept_args.next.stderr
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/does_not_acccept_args.next.stderr
@@ -4,7 +4,7 @@ warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
 LL | #[diagnostic::do_not_recommend(not_accepted)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(malformed_diagnostic_attributes)]` on by default
 
 warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
   --> $DIR/does_not_acccept_args.rs:15:1
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.current.stderr b/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.current.stderr
index e348f0c8902..29ffbb5bf18 100644
--- a/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.current.stderr
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.current.stderr
@@ -4,7 +4,7 @@ warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implement
 LL | #[diagnostic::do_not_recommend]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(misplaced_diagnostic_attributes)]` on by default
 
 warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
   --> $DIR/incorrect-locations.rs:11:1
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.next.stderr b/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.next.stderr
index e348f0c8902..29ffbb5bf18 100644
--- a/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.next.stderr
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.next.stderr
@@ -4,7 +4,7 @@ warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implement
 LL | #[diagnostic::do_not_recommend]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(misplaced_diagnostic_attributes)]` on by default
 
 warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
   --> $DIR/incorrect-locations.rs:11:1
diff --git a/tests/ui/diagnostic_namespace/multiline_spans.rs b/tests/ui/diagnostic_namespace/multiline_spans.rs
index 994dd9fd011..e0876b19df0 100644
--- a/tests/ui/diagnostic_namespace/multiline_spans.rs
+++ b/tests/ui/diagnostic_namespace/multiline_spans.rs
@@ -5,17 +5,17 @@
 #[diagnostic::on_unimplemented(message = "here is a big \
                                          multiline string \
                                          {unknown}")]
-//~^ ERROR there is no parameter `unknown` on trait `MultiLine` [unknown_or_malformed_diagnostic_attributes]
+//~^ ERROR there is no parameter `unknown` on trait `MultiLine` [malformed_diagnostic_format_literals]
 pub trait MultiLine {}
 
 #[diagnostic::on_unimplemented(message = "here is a big \
                                          multiline string {unknown}")]
-//~^ ERROR there is no parameter `unknown` on trait `MultiLine2` [unknown_or_malformed_diagnostic_attributes]
+//~^ ERROR there is no parameter `unknown` on trait `MultiLine2` [malformed_diagnostic_format_literals]
 pub trait MultiLine2 {}
 
 #[diagnostic::on_unimplemented(message = "here is a big \
     multiline string {unknown}")]
-//~^ ERROR there is no parameter `unknown` on trait `MultiLine3` [unknown_or_malformed_diagnostic_attributes]
+//~^ ERROR there is no parameter `unknown` on trait `MultiLine3` [malformed_diagnostic_format_literals]
 pub trait MultiLine3 {}
 
 
@@ -25,23 +25,23 @@ pub trait MultiLine3 {}
                                 \
                                                 \
     multiline string {unknown}")]
-//~^ ERROR there is no parameter `unknown` on trait `MultiLine4` [unknown_or_malformed_diagnostic_attributes]
+//~^ ERROR there is no parameter `unknown` on trait `MultiLine4` [malformed_diagnostic_format_literals]
 pub trait MultiLine4 {}
 
 #[diagnostic::on_unimplemented(message = "here is a big \
                                          multiline string \
                                          {Self:+}")]
-//~^ ERROR invalid format specifier [unknown_or_malformed_diagnostic_attributes]
+//~^ ERROR invalid format specifier [malformed_diagnostic_format_literals]
 pub trait MultiLineFmt {}
 
 #[diagnostic::on_unimplemented(message = "here is a big \
                                          multiline string {Self:X}")]
-//~^ ERROR invalid format specifier [unknown_or_malformed_diagnostic_attributes]
+//~^ ERROR invalid format specifier [malformed_diagnostic_format_literals]
 pub trait MultiLineFmt2 {}
 
 #[diagnostic::on_unimplemented(message = "here is a big \
     multiline string {Self:#}")]
-//~^ ERROR invalid format specifier [unknown_or_malformed_diagnostic_attributes]
+//~^ ERROR invalid format specifier [malformed_diagnostic_format_literals]
 pub trait MultiLineFmt3 {}
 
 
@@ -51,5 +51,5 @@ pub trait MultiLineFmt3 {}
                                 \
                                                 \
     multiline string {Self:?}")]
-//~^ ERROR invalid format specifier [unknown_or_malformed_diagnostic_attributes]
+//~^ ERROR invalid format specifier [malformed_diagnostic_format_literals]
 pub trait MultiLineFmt4 {}
diff --git a/tests/ui/diagnostic_namespace/multiline_spans.stderr b/tests/ui/diagnostic_namespace/multiline_spans.stderr
index 894bfe3d90a..0e4bb864b96 100644
--- a/tests/ui/diagnostic_namespace/multiline_spans.stderr
+++ b/tests/ui/diagnostic_namespace/multiline_spans.stderr
@@ -10,6 +10,7 @@ note: the lint level is defined here
    |
 LL | #![deny(unknown_or_malformed_diagnostic_attributes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `#[deny(malformed_diagnostic_format_literals)]` implied by `#[deny(unknown_or_malformed_diagnostic_attributes)]`
 
 error: there is no parameter `unknown` on trait `MultiLine2`
   --> $DIR/multiline_spans.rs:12:60
diff --git a/tests/ui/diagnostic_namespace/non_existing_attributes_accepted.stderr b/tests/ui/diagnostic_namespace/non_existing_attributes_accepted.stderr
index 753077b365e..4f9b7ba2bcf 100644
--- a/tests/ui/diagnostic_namespace/non_existing_attributes_accepted.stderr
+++ b/tests/ui/diagnostic_namespace/non_existing_attributes_accepted.stderr
@@ -4,7 +4,7 @@ warning: unknown diagnostic attribute
 LL | #[diagnostic::non_existing_attribute]
    |               ^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(unknown_diagnostic_attributes)]` on by default
 
 warning: unknown diagnostic attribute
   --> $DIR/non_existing_attributes_accepted.rs:8:15
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/broken_format.rs b/tests/ui/diagnostic_namespace/on_unimplemented/broken_format.rs
index 4762d9e793f..82c2db7e26d 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/broken_format.rs
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/broken_format.rs
@@ -12,8 +12,8 @@ trait ImportantTrait2 {}
 #[diagnostic::on_unimplemented(message = "Test {1:}")]
 //~^WARN positional format arguments are not allowed here
 //~|WARN positional format arguments are not allowed here
-//~|WARN invalid format specifier [unknown_or_malformed_diagnostic_attributes]
-//~|WARN invalid format specifier [unknown_or_malformed_diagnostic_attributes]
+//~|WARN invalid format specifier [malformed_diagnostic_format_literals]
+//~|WARN invalid format specifier [malformed_diagnostic_format_literals]
 trait ImportantTrait3 {}
 
 #[diagnostic::on_unimplemented(message = "Test {Self:123}")]
@@ -22,13 +22,13 @@ trait ImportantTrait3 {}
 trait ImportantTrait4 {}
 
 #[diagnostic::on_unimplemented(message = "Test {Self:!}")]
-//~^WARN invalid format specifier [unknown_or_malformed_diagnostic_attributes]
-//~|WARN invalid format specifier [unknown_or_malformed_diagnostic_attributes]
+//~^WARN invalid format specifier [malformed_diagnostic_format_literals]
+//~|WARN invalid format specifier [malformed_diagnostic_format_literals]
 trait ImportantTrait5 {}
 
 #[diagnostic::on_unimplemented(message = "Test {Self:}")]
-//~^WARN invalid format specifier [unknown_or_malformed_diagnostic_attributes]
-//~|WARN invalid format specifier [unknown_or_malformed_diagnostic_attributes]
+//~^WARN invalid format specifier [malformed_diagnostic_format_literals]
+//~|WARN invalid format specifier [malformed_diagnostic_format_literals]
 trait ImportantTrait6 {}
 
 
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/broken_format.stderr b/tests/ui/diagnostic_namespace/on_unimplemented/broken_format.stderr
index 2670d0630f7..5002122f8b7 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/broken_format.stderr
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/broken_format.stderr
@@ -4,7 +4,7 @@ warning: unmatched `}` found
 LL | #[diagnostic::on_unimplemented(message = "{{Test } thing")]
    |                                          ^^^^^^^^^^^^^^^^
    |
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(malformed_diagnostic_format_literals)]` on by default
 
 warning: positional format arguments are not allowed here
   --> $DIR/broken_format.rs:7:49
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 8dace7d9052..42f4bc0d8b0 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
@@ -4,7 +4,7 @@ warning: `#[diagnostic::on_unimplemented]` can only be applied to trait definiti
 LL | #[diagnostic::on_unimplemented(message = "Not allowed to apply it on a impl")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(misplaced_diagnostic_attributes)]` on by default
 
 warning: malformed `on_unimplemented` attribute
   --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:6:5
@@ -13,6 +13,7 @@ LL |     on(Self = "&str"),
    |     ^^^^^^^^^^^^^^^^^ invalid option found here
    |
    = help: only `message`, `note` and `label` are allowed as options
+   = note: `#[warn(malformed_diagnostic_attributes)]` on by default
 
 warning: malformed `on_unimplemented` attribute
   --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:12:5
@@ -45,6 +46,7 @@ LL |     message = "{from_desugaring}{direct}{cause}{integral}{integer}",
    |                 ^^^^^^^^^^^^^^^
    |
    = help: expect either a generic argument name or `{Self}` as format argument
+   = note: `#[warn(malformed_diagnostic_format_literals)]` on by default
 
 warning: there is no parameter `direct` on trait `Baz`
   --> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:34
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/do_not_fail_parsing_on_invalid_options_1.stderr b/tests/ui/diagnostic_namespace/on_unimplemented/do_not_fail_parsing_on_invalid_options_1.stderr
index 80790dc3f79..85d74fb8955 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/do_not_fail_parsing_on_invalid_options_1.stderr
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/do_not_fail_parsing_on_invalid_options_1.stderr
@@ -4,7 +4,7 @@ warning: `#[diagnostic::on_unimplemented]` can only be applied to trait definiti
 LL | #[diagnostic::on_unimplemented(message = "Baz")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(misplaced_diagnostic_attributes)]` on by default
 
 warning: malformed `on_unimplemented` attribute
   --> $DIR/do_not_fail_parsing_on_invalid_options_1.rs:3:32
@@ -13,6 +13,7 @@ LL | #[diagnostic::on_unimplemented(unsupported = "foo")]
    |                                ^^^^^^^^^^^^^^^^^^^ invalid option found here
    |
    = help: only `message`, `note` and `label` are allowed as options
+   = note: `#[warn(malformed_diagnostic_attributes)]` on by default
 
 warning: malformed `on_unimplemented` attribute
   --> $DIR/do_not_fail_parsing_on_invalid_options_1.rs:12:50
@@ -61,6 +62,7 @@ LL | #[diagnostic::on_unimplemented(message = "{DoesNotExist}")]
    |                                            ^^^^^^^^^^^^
    |
    = help: expect either a generic argument name or `{Self}` as format argument
+   = note: `#[warn(malformed_diagnostic_format_literals)]` on by default
 
 warning: malformed `on_unimplemented` attribute
   --> $DIR/do_not_fail_parsing_on_invalid_options_1.rs:3:32
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/ignore_unsupported_options_and_continue_to_use_fallback.stderr b/tests/ui/diagnostic_namespace/on_unimplemented/ignore_unsupported_options_and_continue_to_use_fallback.stderr
index e00846da77b..86fe75a62de 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/ignore_unsupported_options_and_continue_to_use_fallback.stderr
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/ignore_unsupported_options_and_continue_to_use_fallback.stderr
@@ -5,7 +5,7 @@ LL |     if(Self = "()"),
    |     ^^^^^^^^^^^^^^^ invalid option found here
    |
    = help: only `message`, `note` and `label` are allowed as options
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(malformed_diagnostic_attributes)]` on by default
 
 warning: `message` is ignored due to previous definition of `message`
   --> $DIR/ignore_unsupported_options_and_continue_to_use_fallback.rs:10:32
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/on_impl_trait.stderr b/tests/ui/diagnostic_namespace/on_unimplemented/on_impl_trait.stderr
index 5eee6478922..69433f91543 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/on_impl_trait.stderr
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/on_impl_trait.stderr
@@ -4,7 +4,7 @@ warning: `#[diagnostic::on_unimplemented]` can only be applied to trait definiti
 LL | #[diagnostic::on_unimplemented(message = "blah", label = "blah", note = "blah")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(misplaced_diagnostic_attributes)]` on by default
 
 error[E0277]: the trait bound `{integer}: Alias` is not satisfied
   --> $DIR/on_impl_trait.rs:16:9
diff --git a/tests/ui/diagnostic_namespace/on_unimplemented/report_warning_on_duplicated_options.stderr b/tests/ui/diagnostic_namespace/on_unimplemented/report_warning_on_duplicated_options.stderr
index feafe2cee76..d2e121b61a6 100644
--- a/tests/ui/diagnostic_namespace/on_unimplemented/report_warning_on_duplicated_options.stderr
+++ b/tests/ui/diagnostic_namespace/on_unimplemented/report_warning_on_duplicated_options.stderr
@@ -7,7 +7,7 @@ LL |     message = "first message",
 LL |     message = "second message",
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ `message` is already declared here
    |
-   = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+   = note: `#[warn(malformed_diagnostic_attributes)]` on by default
 
 warning: `label` is ignored due to previous definition of `label`
   --> $DIR/report_warning_on_duplicated_options.rs:11:5
diff --git a/tests/ui/diagnostic_namespace/suggest_typos.rs b/tests/ui/diagnostic_namespace/suggest_typos.rs
index 8d1dc6f59da..37a1c79bb08 100644
--- a/tests/ui/diagnostic_namespace/suggest_typos.rs
+++ b/tests/ui/diagnostic_namespace/suggest_typos.rs
@@ -1,5 +1,5 @@
 //@ reference: attributes.diagnostic.namespace.unknown-invalid-syntax
-#![deny(unknown_or_malformed_diagnostic_attributes)]
+#![deny(unknown_diagnostic_attributes)]
 
 #[diagnostic::onunimplemented]
 //~^ERROR unknown diagnostic attribute
diff --git a/tests/ui/diagnostic_namespace/suggest_typos.stderr b/tests/ui/diagnostic_namespace/suggest_typos.stderr
index 1f19fd4bbcf..c1177945ea6 100644
--- a/tests/ui/diagnostic_namespace/suggest_typos.stderr
+++ b/tests/ui/diagnostic_namespace/suggest_typos.stderr
@@ -7,8 +7,8 @@ LL | #[diagnostic::onunimplemented]
 note: the lint level is defined here
   --> $DIR/suggest_typos.rs:2:9
    |
-LL | #![deny(unknown_or_malformed_diagnostic_attributes)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(unknown_diagnostic_attributes)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: an attribute with a similar name exists
    |
 LL | #[diagnostic::on_unimplemented]
-- 
cgit 1.4.1-3-g733a5


From ed96f00682c8c170c7fd680eef9bd6c2021669f9 Mon Sep 17 00:00:00 2001
From: Fluid <90795031+fluiderson@users.noreply.github.com>
Date: Fri, 11 Jul 2025 02:27:39 +0300
Subject: fix typos in function names in the `target_feature` test

---
 tests/rustdoc-json/attrs/target_feature.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/rustdoc-json/attrs/target_feature.rs b/tests/rustdoc-json/attrs/target_feature.rs
index 80262d8e332..5c8aeb84ee3 100644
--- a/tests/rustdoc-json/attrs/target_feature.rs
+++ b/tests/rustdoc-json/attrs/target_feature.rs
@@ -6,17 +6,17 @@
 pub fn test1() {}
 
 //@ is "$.index[?(@.name=='test2')].attrs" '["#[target_feature(enable=\"avx\", enable=\"avx2\")]"]'
-//@ is "$.index[?(@.name=='test1')].inner.function.header.is_unsafe" false
+//@ is "$.index[?(@.name=='test2')].inner.function.header.is_unsafe" false
 #[target_feature(enable = "avx,avx2")]
 pub fn test2() {}
 
 //@ is "$.index[?(@.name=='test3')].attrs" '["#[target_feature(enable=\"avx\", enable=\"avx2\")]"]'
-//@ is "$.index[?(@.name=='test1')].inner.function.header.is_unsafe" false
+//@ is "$.index[?(@.name=='test3')].inner.function.header.is_unsafe" false
 #[target_feature(enable = "avx", enable = "avx2")]
 pub fn test3() {}
 
 //@ is "$.index[?(@.name=='test4')].attrs" '["#[target_feature(enable=\"avx\", enable=\"avx2\", enable=\"avx512f\")]"]'
-//@ is "$.index[?(@.name=='test1')].inner.function.header.is_unsafe" false
+//@ is "$.index[?(@.name=='test4')].inner.function.header.is_unsafe" false
 #[target_feature(enable = "avx", enable = "avx2,avx512f")]
 pub fn test4() {}
 
-- 
cgit 1.4.1-3-g733a5


From 506ea9a4f1024f10d88e2010aa9ed8dd8af0e1ef Mon Sep 17 00:00:00 2001
From: asahi-myzk <miyakinoko3@gmail.com>
Date: Fri, 11 Jul 2025 09:59:40 +0900
Subject: update cargo_metadata to 0.21.0

---
 src/tools/rust-analyzer/Cargo.lock | 39 ++++++++++++++++++++++++++++++++++----
 src/tools/rust-analyzer/Cargo.toml |  2 +-
 2 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 7432a82080d..53682c4b8bb 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -153,6 +153,22 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "cargo-util-schemas"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dc1a6f7b5651af85774ae5a34b4e8be397d9cf4bc063b7e6dbd99a841837830"
+dependencies = [
+ "semver",
+ "serde",
+ "serde-untagged",
+ "serde-value",
+ "thiserror 2.0.12",
+ "toml",
+ "unicode-xid",
+ "url",
+]
+
 [[package]]
 name = "cargo_metadata"
 version = "0.20.0"
@@ -161,7 +177,22 @@ checksum = "4f7835cfc6135093070e95eb2b53e5d9b5c403dc3a6be6040ee026270aa82502"
 dependencies = [
  "camino",
  "cargo-platform",
- "cargo-util-schemas",
+ "cargo-util-schemas 0.2.0",
+ "semver",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.12",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cfca2aaa699835ba88faf58a06342a314a950d2b9686165e038286c30316868"
+dependencies = [
+ "camino",
+ "cargo-platform",
+ "cargo-util-schemas 0.8.2",
  "semver",
  "serde",
  "serde_json",
@@ -1599,7 +1630,7 @@ dependencies = [
 name = "proc-macro-test"
 version = "0.0.0"
 dependencies = [
- "cargo_metadata",
+ "cargo_metadata 0.20.0",
 ]
 
 [[package]]
@@ -1640,7 +1671,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "base-db",
- "cargo_metadata",
+ "cargo_metadata 0.21.0",
  "cfg",
  "expect-test",
  "intern",
@@ -1855,7 +1886,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "base64",
- "cargo_metadata",
+ "cargo_metadata 0.21.0",
  "cfg",
  "crossbeam-channel",
  "dirs",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index c7b78ec7131..e6d1efb58b7 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -106,7 +106,7 @@ lsp-server = { version = "0.7.8" }
 anyhow = "1.0.98"
 arrayvec = "0.7.6"
 bitflags = "2.9.1"
-cargo_metadata = "0.20.0"
+cargo_metadata = "0.21.0"
 camino = "1.1.10"
 chalk-solve = { version = "0.103.0", default-features = false }
 chalk-ir = "0.103.0"
-- 
cgit 1.4.1-3-g733a5


From 3c11029acef45da169dd6713c48e9fdd98d606b5 Mon Sep 17 00:00:00 2001
From: Colten <70793703+ColtenOuO@users.noreply.github.com>
Date: Wed, 9 Jul 2025 01:59:03 +0800
Subject: docs: clarify “dag” in std::sys_common doc comment
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 library/std/src/sys_common/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/sys_common/mod.rs b/library/std/src/sys_common/mod.rs
index b7f4656fa37..cce88d936b7 100644
--- a/library/std/src/sys_common/mod.rs
+++ b/library/std/src/sys_common/mod.rs
@@ -11,7 +11,7 @@
 //! This is because `sys_common` not only contains platform-independent code,
 //! but also code that is shared between the different platforms in `sys`.
 //! Ideally all that shared code should be moved to `sys::common`,
-//! and the dependencies between `std`, `sys_common` and `sys` all would form a dag.
+//! and the dependencies between `std`, `sys_common` and `sys` all would form a DAG.
 //! Progress on this is tracked in #84187.
 
 #![allow(missing_docs)]
-- 
cgit 1.4.1-3-g733a5


From 28612748f61767c20c93da45156fc4ebde604dc1 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 11 Jul 2025 05:03:22 +0000
Subject: x: clippy fixes

---
 src/tools/x/src/main.rs | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/tools/x/src/main.rs b/src/tools/x/src/main.rs
index b288cfcd5be..8c5735014df 100644
--- a/src/tools/x/src/main.rs
+++ b/src/tools/x/src/main.rs
@@ -89,7 +89,7 @@ fn exec_or_status(command: &mut Command) -> io::Result<ExitStatus> {
 fn handle_result(result: io::Result<ExitStatus>, cmd: Command) {
     match result {
         Err(error) => {
-            eprintln!("Failed to invoke `{:?}`: {}", cmd, error);
+            eprintln!("Failed to invoke `{cmd:?}`: {error}");
         }
         Ok(status) => {
             process::exit(status.code().unwrap_or(1));
@@ -98,13 +98,10 @@ fn handle_result(result: io::Result<ExitStatus>, cmd: Command) {
 }
 
 fn main() {
-    match env::args().skip(1).next().as_deref() {
-        Some("--wrapper-version") => {
-            let version = env!("CARGO_PKG_VERSION");
-            println!("{}", version);
-            return;
-        }
-        _ => {}
+    if env::args().nth(1).is_some_and(|s| s == "--wrapper-version") {
+        let version = env!("CARGO_PKG_VERSION");
+        println!("{version}");
+        return;
     }
     let current = match env::current_dir() {
         Ok(dir) => dir,
-- 
cgit 1.4.1-3-g733a5


From b87a1b1297c2786e49133e274c2e9f7b793320e0 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 11 Jul 2025 05:14:24 +0000
Subject: x: move to edition 2024

---
 src/tools/x/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/x/Cargo.toml b/src/tools/x/Cargo.toml
index 84a42ca36ef..c59f5ff52a0 100644
--- a/src/tools/x/Cargo.toml
+++ b/src/tools/x/Cargo.toml
@@ -2,5 +2,5 @@
 name = "x"
 version = "0.1.1"
 description = "Run x.py slightly more conveniently"
-edition = "2021"
+edition = "2024"
 publish = false
-- 
cgit 1.4.1-3-g733a5


From dcf965d65271c76b3cb73e53b91147905f811f34 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 11 Jul 2025 05:29:05 +0000
Subject: x: use let-else

---
 src/tools/x/src/main.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/tools/x/src/main.rs b/src/tools/x/src/main.rs
index 8c5735014df..93167141d34 100644
--- a/src/tools/x/src/main.rs
+++ b/src/tools/x/src/main.rs
@@ -19,15 +19,14 @@ const PYTHON2: &str = "python2";
 const PYTHON3: &str = "python3";
 
 fn python() -> &'static str {
-    let val = match env::var_os("PATH") {
-        Some(val) => val,
-        None => return PYTHON,
+    let Some(path) = env::var_os("PATH") else {
+        return PYTHON;
     };
 
     let mut python2 = false;
     let mut python3 = false;
 
-    for dir in env::split_paths(&val) {
+    for dir in env::split_paths(&path) {
         // `python` should always take precedence over python2 / python3 if it exists
         if dir.join(PYTHON).with_extension(EXE_EXTENSION).exists() {
             return PYTHON;
@@ -103,6 +102,7 @@ fn main() {
         println!("{version}");
         return;
     }
+
     let current = match env::current_dir() {
         Ok(dir) => dir,
         Err(err) => {
@@ -110,7 +110,6 @@ fn main() {
             process::exit(1);
         }
     };
-
     for dir in current.ancestors() {
         let candidate = dir.join("x.py");
         if candidate.exists() {
-- 
cgit 1.4.1-3-g733a5


From ef5c209df3b8557e29af0482f2eeb004ff265621 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Wed, 9 Jul 2025 15:36:35 +0000
Subject: tidy: clippy fixes

---
 src/tools/tidy/src/alphabetical.rs                  |  2 +-
 src/tools/tidy/src/bins.rs                          | 11 +++--------
 src/tools/tidy/src/deps.rs                          |  2 +-
 src/tools/tidy/src/error_codes.rs                   | 20 ++++++++------------
 src/tools/tidy/src/ext_tool_checks.rs               | 16 ++++++++--------
 src/tools/tidy/src/extdeps.rs                       |  2 +-
 src/tools/tidy/src/features.rs                      | 21 +++++++++------------
 src/tools/tidy/src/features/version.rs              |  2 +-
 src/tools/tidy/src/features/version/tests.rs        |  4 ++--
 src/tools/tidy/src/fluent_alphabetical.rs           |  2 +-
 src/tools/tidy/src/fluent_period.rs                 |  4 ++--
 src/tools/tidy/src/fluent_used.rs                   |  4 ++--
 src/tools/tidy/src/gcc_submodule.rs                 |  7 ++++---
 src/tools/tidy/src/mir_opt_tests.rs                 |  2 +-
 src/tools/tidy/src/pal.rs                           |  2 +-
 src/tools/tidy/src/rustdoc_gui_tests.rs             |  2 +-
 src/tools/tidy/src/rustdoc_js.rs                    |  2 +-
 src/tools/tidy/src/rustdoc_json.rs                  |  2 +-
 src/tools/tidy/src/rustdoc_templates.rs             |  4 ++--
 src/tools/tidy/src/style.rs                         | 15 +++++++--------
 src/tools/tidy/src/target_specific_tests.rs         | 11 ++++-------
 .../src/tests_revision_unpaired_stdout_stderr.rs    | 12 ++++++------
 src/tools/tidy/src/ui_tests.rs                      |  7 +++----
 src/tools/tidy/src/unstable_book.rs                 |  4 ++--
 src/tools/tidy/src/walk.rs                          |  4 ++--
 src/tools/tidy/src/x_version.rs                     | 10 +++++-----
 26 files changed, 79 insertions(+), 95 deletions(-)

diff --git a/src/tools/tidy/src/alphabetical.rs b/src/tools/tidy/src/alphabetical.rs
index 141083290c6..9ddce725106 100644
--- a/src/tools/tidy/src/alphabetical.rs
+++ b/src/tools/tidy/src/alphabetical.rs
@@ -103,7 +103,7 @@ fn check_section<'a>(
 
         let prev_line_trimmed_lowercase = prev_line.trim_start_matches(' ');
 
-        if version_sort(&trimmed_line, &prev_line_trimmed_lowercase).is_lt() {
+        if version_sort(trimmed_line, prev_line_trimmed_lowercase).is_lt() {
             tidy_error_ext!(err, bad, "{file}:{}: line not in alphabetical order", idx + 1);
         }
 
diff --git a/src/tools/tidy/src/bins.rs b/src/tools/tidy/src/bins.rs
index 9b78ba75a05..a18f549844b 100644
--- a/src/tools/tidy/src/bins.rs
+++ b/src/tools/tidy/src/bins.rs
@@ -75,7 +75,7 @@ mod os_impl {
                         return ReadOnlyFs;
                     }
 
-                    panic!("unable to create temporary file `{:?}`: {:?}", path, e);
+                    panic!("unable to create temporary file `{path:?}`: {e:?}");
                 }
             }
         }
@@ -83,12 +83,7 @@ mod os_impl {
         for &source_dir in sources {
             match check_dir(source_dir) {
                 Unsupported => return false,
-                ReadOnlyFs => {
-                    return match check_dir(output) {
-                        Supported => true,
-                        _ => false,
-                    };
-                }
+                ReadOnlyFs => return matches!(check_dir(output), Supported),
                 _ => {}
             }
         }
@@ -139,7 +134,7 @@ mod os_impl {
                     return;
                 }
 
-                if t!(is_executable(&file), file) {
+                if t!(is_executable(file), file) {
                     let rel_path = file.strip_prefix(path).unwrap();
                     let git_friendly_path = rel_path.to_str().unwrap().replace("\\", "/");
 
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index bf813d2131e..f43f5eae9a5 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -624,7 +624,7 @@ fn check_proc_macro_dep_list(root: &Path, cargo: &Path, bless: bool, bad: &mut b
     let is_proc_macro_pkg = |pkg: &Package| pkg.targets.iter().any(|target| target.is_proc_macro());
 
     let mut proc_macro_deps = HashSet::new();
-    for pkg in metadata.packages.iter().filter(|pkg| is_proc_macro_pkg(*pkg)) {
+    for pkg in metadata.packages.iter().filter(|pkg| is_proc_macro_pkg(pkg)) {
         deps_of(&metadata, &pkg.id, &mut proc_macro_deps);
     }
     // Remove the proc-macro crates themselves
diff --git a/src/tools/tidy/src/error_codes.rs b/src/tools/tidy/src/error_codes.rs
index bb61412f678..65aa89fe801 100644
--- a/src/tools/tidy/src/error_codes.rs
+++ b/src/tools/tidy/src/error_codes.rs
@@ -119,8 +119,7 @@ fn extract_error_codes(root_path: &Path, errors: &mut Vec<String>) -> Vec<String
             let Some(split_line) = split_line else {
                 errors.push(format!(
                     "{path}:{line_index}: Expected a line with the format `Eabcd: abcd, \
-                    but got \"{}\" without a `:` delimiter",
-                    line,
+                    but got \"{line}\" without a `:` delimiter",
                 ));
                 continue;
             };
@@ -129,10 +128,8 @@ fn extract_error_codes(root_path: &Path, errors: &mut Vec<String>) -> Vec<String
 
             // If this is a duplicate of another error code, emit a fatal error.
             if error_codes.contains(&err_code) {
-                errors.push(format!(
-                    "{path}:{line_index}: Found duplicate error code: `{}`",
-                    err_code
-                ));
+                errors
+                    .push(format!("{path}:{line_index}: Found duplicate error code: `{err_code}`"));
                 continue;
             }
 
@@ -145,8 +142,7 @@ fn extract_error_codes(root_path: &Path, errors: &mut Vec<String>) -> Vec<String
             let Some(rest) = rest else {
                 errors.push(format!(
                     "{path}:{line_index}: Expected a line with the format `Eabcd: abcd, \
-                    but got \"{}\" without a `,` delimiter",
-                    line,
+                    but got \"{line}\" without a `,` delimiter",
                 ));
                 continue;
             };
@@ -209,7 +205,7 @@ fn check_error_codes_docs(
         }
 
         let (found_code_example, found_proper_doctest, emit_ignore_warning, no_longer_emitted) =
-            check_explanation_has_doctest(&contents, &err_code);
+            check_explanation_has_doctest(contents, err_code);
 
         if emit_ignore_warning {
             verbose_print!(
@@ -232,7 +228,7 @@ fn check_error_codes_docs(
             return;
         }
 
-        let test_ignored = IGNORE_DOCTEST_CHECK.contains(&&err_code);
+        let test_ignored = IGNORE_DOCTEST_CHECK.contains(&err_code);
 
         // Check that the explanation has a doctest, and if it shouldn't, that it doesn't
         if !found_proper_doctest && !test_ignored {
@@ -300,7 +296,7 @@ fn check_error_codes_tests(
     let tests_path = root_path.join(Path::new(ERROR_TESTS_PATH));
 
     for code in error_codes {
-        let test_path = tests_path.join(format!("{}.stderr", code));
+        let test_path = tests_path.join(format!("{code}.stderr"));
 
         if !test_path.exists() && !IGNORE_UI_TEST_CHECK.contains(&code.as_str()) {
             verbose_print!(
@@ -388,7 +384,7 @@ fn check_error_codes_used(
 
                     if !error_codes.contains(&error_code) {
                         // This error code isn't properly defined, we must error.
-                        errors.push(format!("Error code `{}` is used in the compiler but not defined and documented in `compiler/rustc_error_codes/src/lib.rs`.", error_code));
+                        errors.push(format!("Error code `{error_code}` is used in the compiler but not defined and documented in `compiler/rustc_error_codes/src/lib.rs`."));
                         continue;
                     }
 
diff --git a/src/tools/tidy/src/ext_tool_checks.rs b/src/tools/tidy/src/ext_tool_checks.rs
index baab46752a5..381ea44fd46 100644
--- a/src/tools/tidy/src/ext_tool_checks.rs
+++ b/src/tools/tidy/src/ext_tool_checks.rs
@@ -64,8 +64,8 @@ fn check_impl(
     extra_checks: Option<&str>,
     pos_args: &[String],
 ) -> Result<(), Error> {
-    let show_diff = std::env::var("TIDY_PRINT_DIFF")
-        .map_or(false, |v| v.eq_ignore_ascii_case("true") || v == "1");
+    let show_diff =
+        std::env::var("TIDY_PRINT_DIFF").is_ok_and(|v| v.eq_ignore_ascii_case("true") || v == "1");
 
     // Split comma-separated args up
     let lint_args = match extra_checks {
@@ -141,7 +141,7 @@ fn check_impl(
             );
         }
         // Rethrow error
-        let _ = res?;
+        res?;
     }
 
     if python_fmt {
@@ -173,7 +173,7 @@ fn check_impl(
         }
 
         // Rethrow error
-        let _ = res?;
+        res?;
     }
 
     if cpp_fmt {
@@ -244,7 +244,7 @@ fn check_impl(
             }
         }
         // Rethrow error
-        let _ = res?;
+        res?;
     }
 
     if shell_lint {
@@ -286,8 +286,8 @@ fn run_ruff(
     file_args: &[&OsStr],
     ruff_args: &[&OsStr],
 ) -> Result<(), Error> {
-    let mut cfg_args_ruff = cfg_args.into_iter().copied().collect::<Vec<_>>();
-    let mut file_args_ruff = file_args.into_iter().copied().collect::<Vec<_>>();
+    let mut cfg_args_ruff = cfg_args.to_vec();
+    let mut file_args_ruff = file_args.to_vec();
 
     let mut cfg_path = root_path.to_owned();
     cfg_path.extend(RUFF_CONFIG_PATH);
@@ -305,7 +305,7 @@ fn run_ruff(
         file_args_ruff.push(root_path.as_os_str());
     }
 
-    let mut args: Vec<&OsStr> = ruff_args.into_iter().copied().collect();
+    let mut args: Vec<&OsStr> = ruff_args.to_vec();
     args.extend(merge_args(&cfg_args_ruff, &file_args_ruff));
     py_runner(py_path, true, None, "ruff", &args)
 }
diff --git a/src/tools/tidy/src/extdeps.rs b/src/tools/tidy/src/extdeps.rs
index 55f937aeacf..bc217a55cc1 100644
--- a/src/tools/tidy/src/extdeps.rs
+++ b/src/tools/tidy/src/extdeps.rs
@@ -41,7 +41,7 @@ pub fn check(root: &Path, bad: &mut bool) {
             let source = line.split_once('=').unwrap().1.trim();
 
             // Ensure source is allowed.
-            if !ALLOWED_SOURCES.contains(&&*source) {
+            if !ALLOWED_SOURCES.contains(&source) {
                 tidy_error!(bad, "invalid source: {}", source);
             }
         }
diff --git a/src/tools/tidy/src/features.rs b/src/tools/tidy/src/features.rs
index 6093e7fd263..e83b47e1380 100644
--- a/src/tools/tidy/src/features.rs
+++ b/src/tools/tidy/src/features.rs
@@ -125,8 +125,8 @@ pub fn check(
                 let gate_test_str = "gate-test-";
 
                 let feature_name = match line.find(gate_test_str) {
-                    // NB: the `splitn` always succeeds, even if the delimiter is not present.
-                    Some(i) => line[i + gate_test_str.len()..].splitn(2, ' ').next().unwrap(),
+                    // `split` always contains at least 1 element, even if the delimiter is not present.
+                    Some(i) => line[i + gate_test_str.len()..].split(' ').next().unwrap(),
                     None => continue,
                 };
                 match features.get_mut(feature_name) {
@@ -135,16 +135,14 @@ pub fn check(
                             err(&format!(
                                 "The file is already marked as gate test \
                                       through its name, no need for a \
-                                      'gate-test-{}' comment",
-                                feature_name
+                                      'gate-test-{feature_name}' comment"
                             ));
                         }
                         f.has_gate_test = true;
                     }
                     None => {
                         err(&format!(
-                            "gate-test test found referencing a nonexistent feature '{}'",
-                            feature_name
+                            "gate-test test found referencing a nonexistent feature '{feature_name}'"
                         ));
                     }
                 }
@@ -170,8 +168,7 @@ pub fn check(
         );
         println!(
             "Hint: If you already have such a test and don't want to rename it,\
-                \n      you can also add a // gate-test-{} line to the test file.",
-            name
+                \n      you can also add a // gate-test-{name} line to the test file."
         );
     }
 
@@ -231,7 +228,7 @@ pub fn check(
 fn get_version_and_channel(src_path: &Path) -> (Version, String) {
     let version_str = t!(std::fs::read_to_string(src_path.join("version")));
     let version_str = version_str.trim();
-    let version = t!(std::str::FromStr::from_str(&version_str).map_err(|e| format!("{e:?}")));
+    let version = t!(std::str::FromStr::from_str(version_str).map_err(|e| format!("{e:?}")));
     let channel_str = t!(std::fs::read_to_string(src_path.join("ci").join("channel")));
     (version, channel_str.trim().to_owned())
 }
@@ -468,7 +465,7 @@ fn get_and_check_lib_features(
     map_lib_features(base_src_path, &mut |res, file, line| match res {
         Ok((name, f)) => {
             let mut check_features = |f: &Feature, list: &Features, display: &str| {
-                if let Some(ref s) = list.get(name) {
+                if let Some(s) = list.get(name) {
                     if f.tracking_issue != s.tracking_issue && f.level != Status::Accepted {
                         tidy_error!(
                             bad,
@@ -483,7 +480,7 @@ fn get_and_check_lib_features(
                     }
                 }
             };
-            check_features(&f, &lang_features, "corresponding lang feature");
+            check_features(&f, lang_features, "corresponding lang feature");
             check_features(&f, &lib_features, "previous");
             lib_features.insert(name.to_owned(), f);
         }
@@ -543,7 +540,7 @@ fn map_lib_features(
                     continue;
                 }
 
-                if let Some((ref name, ref mut f)) = becoming_feature {
+                if let Some((name, ref mut f)) = becoming_feature {
                     if f.tracking_issue.is_none() {
                         f.tracking_issue = find_attr_val(line, "issue").and_then(handle_issue_none);
                     }
diff --git a/src/tools/tidy/src/features/version.rs b/src/tools/tidy/src/features/version.rs
index 6a902e80f8e..0e0629a48e2 100644
--- a/src/tools/tidy/src/features/version.rs
+++ b/src/tools/tidy/src/features/version.rs
@@ -20,7 +20,7 @@ impl fmt::Display for Version {
             Version::Explicit { parts } => {
                 f.pad(&format!("{}.{}.{}", parts[0], parts[1], parts[2]))
             }
-            Version::CurrentPlaceholder => f.pad(&format!("CURRENT")),
+            Version::CurrentPlaceholder => f.pad("CURRENT"),
         }
     }
 }
diff --git a/src/tools/tidy/src/features/version/tests.rs b/src/tools/tidy/src/features/version/tests.rs
index 7701dce2df1..453ba40586e 100644
--- a/src/tools/tidy/src/features/version/tests.rs
+++ b/src/tools/tidy/src/features/version/tests.rs
@@ -33,6 +33,6 @@ fn test_to_string() {
 
     assert_eq!(v_1_0_0.to_string(), "1.0.0");
     assert_eq!(v_1_32_1.to_string(), "1.32.1");
-    assert_eq!(format!("{:<8}", v_1_32_1), "1.32.1  ");
-    assert_eq!(format!("{:>8}", v_1_32_1), "  1.32.1");
+    assert_eq!(format!("{v_1_32_1:<8}"), "1.32.1  ");
+    assert_eq!(format!("{v_1_32_1:>8}"), "  1.32.1");
 }
diff --git a/src/tools/tidy/src/fluent_alphabetical.rs b/src/tools/tidy/src/fluent_alphabetical.rs
index 6f154b92eff..8853681d4fb 100644
--- a/src/tools/tidy/src/fluent_alphabetical.rs
+++ b/src/tools/tidy/src/fluent_alphabetical.rs
@@ -104,7 +104,7 @@ pub fn check(path: &Path, bless: bool, bad: &mut bool) {
                 if sorted != contents {
                     let mut f =
                         OpenOptions::new().write(true).truncate(true).open(ent.path()).unwrap();
-                    f.write(sorted.as_bytes()).unwrap();
+                    f.write_all(sorted.as_bytes()).unwrap();
                 }
             } else {
                 check_alphabetic(
diff --git a/src/tools/tidy/src/fluent_period.rs b/src/tools/tidy/src/fluent_period.rs
index 6a136e5aec6..85c1ef6166a 100644
--- a/src/tools/tidy/src/fluent_period.rs
+++ b/src/tools/tidy/src/fluent_period.rs
@@ -37,7 +37,7 @@ fn check_period(filename: &str, contents: &str, bad: &mut bool) {
                 if let Some(PatternElement::TextElement { value }) = pat.elements.last() {
                     // We don't care about ellipses.
                     if value.ends_with(".") && !value.ends_with("...") {
-                        let ll = find_line(contents, *value);
+                        let ll = find_line(contents, value);
                         let name = m.id.name;
                         tidy_error!(bad, "{filename}:{ll}: message `{name}` ends in a period");
                     }
@@ -52,7 +52,7 @@ fn check_period(filename: &str, contents: &str, bad: &mut bool) {
 
                 if let Some(PatternElement::TextElement { value }) = attr.value.elements.last() {
                     if value.ends_with(".") && !value.ends_with("...") {
-                        let ll = find_line(contents, *value);
+                        let ll = find_line(contents, value);
                         let name = attr.id.name;
                         tidy_error!(bad, "{filename}:{ll}: attr `{name}` ends in a period");
                     }
diff --git a/src/tools/tidy/src/fluent_used.rs b/src/tools/tidy/src/fluent_used.rs
index ab56b5f0b0e..12fafd9a7ff 100644
--- a/src/tools/tidy/src/fluent_used.rs
+++ b/src/tools/tidy/src/fluent_used.rs
@@ -13,8 +13,8 @@ fn filter_used_messages(
     // we don't just check messages never appear in Rust files,
     // because messages can be used as parts of other fluent messages in Fluent files,
     // so we do checking messages appear only once in all Rust and Fluent files.
-    let mut matches = static_regex!(r"\w+").find_iter(contents);
-    while let Some(name) = matches.next() {
+    let matches = static_regex!(r"\w+").find_iter(contents);
+    for name in matches {
         if let Some((name, filename)) = msgs_not_appeared_yet.remove_entry(name.as_str()) {
             // if one msg appears for the first time,
             // remove it from `msgs_not_appeared_yet` and insert it into `msgs_appeared_only_once`.
diff --git a/src/tools/tidy/src/gcc_submodule.rs b/src/tools/tidy/src/gcc_submodule.rs
index 952ebe9e0cf..5d726c3ea48 100644
--- a/src/tools/tidy/src/gcc_submodule.rs
+++ b/src/tools/tidy/src/gcc_submodule.rs
@@ -7,7 +7,9 @@ use std::process::Command;
 pub fn check(root_path: &Path, compiler_path: &Path, bad: &mut bool) {
     let cg_gcc_version_path = compiler_path.join("rustc_codegen_gcc/libgccjit.version");
     let cg_gcc_version = std::fs::read_to_string(&cg_gcc_version_path)
-        .expect(&format!("Cannot read GCC version from {}", cg_gcc_version_path.display()))
+        .unwrap_or_else(|_| {
+            panic!("Cannot read GCC version from {}", cg_gcc_version_path.display())
+        })
         .trim()
         .to_string();
 
@@ -27,14 +29,13 @@ pub fn check(root_path: &Path, compiler_path: &Path, bad: &mut bool) {
     //  e607be166673a8de9fc07f6f02c60426e556c5f2 src/gcc (master-e607be166673a8de9fc07f6f02c60426e556c5f2.e607be)
     // +e607be166673a8de9fc07f6f02c60426e556c5f2 src/gcc (master-e607be166673a8de9fc07f6f02c60426e556c5f2.e607be)
     let git_output = String::from_utf8_lossy(&git_output.stdout)
-        .trim()
         .split_whitespace()
         .next()
         .unwrap_or_default()
         .to_string();
 
     // The SHA can start with + if the submodule is modified or - if it is not checked out.
-    let gcc_submodule_sha = git_output.trim_start_matches(&['+', '-']);
+    let gcc_submodule_sha = git_output.trim_start_matches(['+', '-']);
     if gcc_submodule_sha != cg_gcc_version {
         *bad = true;
         eprintln!(
diff --git a/src/tools/tidy/src/mir_opt_tests.rs b/src/tools/tidy/src/mir_opt_tests.rs
index bb0d8150be4..1efe71b1687 100644
--- a/src/tools/tidy/src/mir_opt_tests.rs
+++ b/src/tools/tidy/src/mir_opt_tests.rs
@@ -49,7 +49,7 @@ fn check_unused_files(path: &Path, bless: bool, bad: &mut bool) {
 }
 
 fn check_dash_files(path: &Path, bless: bool, bad: &mut bool) {
-    for file in walkdir::WalkDir::new(&path.join("mir-opt"))
+    for file in walkdir::WalkDir::new(path.join("mir-opt"))
         .into_iter()
         .filter_map(Result::ok)
         .filter(|e| e.file_type().is_file())
diff --git a/src/tools/tidy/src/pal.rs b/src/tools/tidy/src/pal.rs
index 9b915e0f737..b7d4a331891 100644
--- a/src/tools/tidy/src/pal.rs
+++ b/src/tools/tidy/src/pal.rs
@@ -86,7 +86,7 @@ pub fn check(path: &Path, bad: &mut bool) {
             return;
         }
 
-        check_cfgs(contents, &file, bad, &mut saw_target_arch, &mut saw_cfg_bang);
+        check_cfgs(contents, file, bad, &mut saw_target_arch, &mut saw_cfg_bang);
     });
 
     assert!(saw_target_arch);
diff --git a/src/tools/tidy/src/rustdoc_gui_tests.rs b/src/tools/tidy/src/rustdoc_gui_tests.rs
index 91776bc989e..3b995f219d2 100644
--- a/src/tools/tidy/src/rustdoc_gui_tests.rs
+++ b/src/tools/tidy/src/rustdoc_gui_tests.rs
@@ -5,7 +5,7 @@ use std::path::Path;
 pub fn check(path: &Path, bad: &mut bool) {
     crate::walk::walk(
         &path.join("rustdoc-gui"),
-        |p, is_dir| !is_dir && p.extension().map_or(true, |e| e != "goml"),
+        |p, is_dir| !is_dir && p.extension().is_none_or(|e| e != "goml"),
         &mut |entry, content| {
             for line in content.lines() {
                 if !line.starts_with("// ") {
diff --git a/src/tools/tidy/src/rustdoc_js.rs b/src/tools/tidy/src/rustdoc_js.rs
index 5e924544f0d..5737fcbafc0 100644
--- a/src/tools/tidy/src/rustdoc_js.rs
+++ b/src/tools/tidy/src/rustdoc_js.rs
@@ -88,7 +88,7 @@ pub fn check(librustdoc_path: &Path, tools_path: &Path, src_path: &Path, bad: &m
     let mut files_to_check = Vec::new();
     walk_no_read(
         &[&librustdoc_path.join("html/static/js")],
-        |path, is_dir| is_dir || !path.extension().is_some_and(|ext| ext == OsStr::new("js")),
+        |path, is_dir| is_dir || path.extension().is_none_or(|ext| ext != OsStr::new("js")),
         &mut |path: &DirEntry| {
             files_to_check.push(path.path().into());
         },
diff --git a/src/tools/tidy/src/rustdoc_json.rs b/src/tools/tidy/src/rustdoc_json.rs
index 19b8e79ec33..722e1ebd0ca 100644
--- a/src/tools/tidy/src/rustdoc_json.rs
+++ b/src/tools/tidy/src/rustdoc_json.rs
@@ -20,7 +20,7 @@ pub fn check(src_path: &Path, ci_info: &crate::CiInfo, bad: &mut bool) {
         return;
     }
     // Then we check that if `FORMAT_VERSION` was updated, the `Latest feature:` was also updated.
-    match crate::git_diff(&base_commit, src_path.join("rustdoc-json-types")) {
+    match crate::git_diff(base_commit, src_path.join("rustdoc-json-types")) {
         Some(output) => {
             let mut format_version_updated = false;
             let mut latest_feature_comment_updated = false;
diff --git a/src/tools/tidy/src/rustdoc_templates.rs b/src/tools/tidy/src/rustdoc_templates.rs
index 2173dbf7e74..dca3e8d9d25 100644
--- a/src/tools/tidy/src/rustdoc_templates.rs
+++ b/src/tools/tidy/src/rustdoc_templates.rs
@@ -14,7 +14,7 @@ const TAGS: &[(&str, &str)] = &[("{#", "#}"), ("{%", "%}"), ("{{", "}}")];
 pub fn check(librustdoc_path: &Path, bad: &mut bool) {
     walk(
         &librustdoc_path.join("html/templates"),
-        |path, is_dir| is_dir || !path.extension().is_some_and(|ext| ext == OsStr::new("html")),
+        |path, is_dir| is_dir || path.extension().is_none_or(|ext| ext != OsStr::new("html")),
         &mut |path: &DirEntry, file_content: &str| {
             let mut lines = file_content.lines().enumerate().peekable();
 
@@ -23,7 +23,7 @@ pub fn check(librustdoc_path: &Path, bad: &mut bool) {
                 if let Some(need_next_line_check) = TAGS.iter().find_map(|(tag, end_tag)| {
                     // We first check if the line ends with a jinja tag.
                     if !line.ends_with(end_tag) {
-                        return None;
+                        None
                     // Then we check if this a comment tag.
                     } else if *tag != "{#" {
                         return Some(false);
diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs
index 2237eac200d..8dde4618ce5 100644
--- a/src/tools/tidy/src/style.rs
+++ b/src/tools/tidy/src/style.rs
@@ -94,10 +94,9 @@ fn generate_problems<'a>(
     letter_digit: &'a FxHashMap<char, char>,
 ) -> impl Iterator<Item = u32> + 'a {
     consts.iter().flat_map(move |const_value| {
-        let problem =
-            letter_digit.iter().fold(format!("{:X}", const_value), |acc, (key, value)| {
-                acc.replace(&value.to_string(), &key.to_string())
-            });
+        let problem = letter_digit.iter().fold(format!("{const_value:X}"), |acc, (key, value)| {
+            acc.replace(&value.to_string(), &key.to_string())
+        });
         let indexes: Vec<usize> = problem
             .chars()
             .enumerate()
@@ -341,7 +340,7 @@ fn is_unexplained_ignore(extension: &str, line: &str) -> bool {
 
 pub fn check(path: &Path, bad: &mut bool) {
     fn skip(path: &Path, is_dir: bool) -> bool {
-        if path.file_name().map_or(false, |name| name.to_string_lossy().starts_with(".#")) {
+        if path.file_name().is_some_and(|name| name.to_string_lossy().starts_with(".#")) {
             // vim or emacs temporary file
             return true;
         }
@@ -358,12 +357,12 @@ pub fn check(path: &Path, bad: &mut bool) {
         let extensions = ["rs", "py", "js", "sh", "c", "cpp", "h", "md", "css", "ftl", "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().map_or(true, |ext| !extensions.iter().any(|e| ext == OsStr::new(e))) {
+        if path.extension().is_none_or(|ext| !extensions.iter().any(|e| ext == OsStr::new(e))) {
             return true;
         }
 
         // We only check CSS files in rustdoc.
-        path.extension().map_or(false, |e| e == "css") && !is_in(path, "src", "librustdoc")
+        path.extension().is_some_and(|e| e == "css") && !is_in(path, "src", "librustdoc")
     }
 
     // This creates a RegexSet as regex contains performance optimizations to be able to deal with these over
@@ -435,7 +434,7 @@ pub fn check(path: &Path, bad: &mut bool) {
             mut skip_copyright,
             mut skip_dbg,
             mut skip_odd_backticks,
-        ] = contains_ignore_directives(&path_str, can_contain, &contents, CONFIGURABLE_CHECKS);
+        ] = contains_ignore_directives(&path_str, can_contain, contents, CONFIGURABLE_CHECKS);
         let mut leading_new_lines = false;
         let mut trailing_new_lines = 0;
         let mut lines = 0;
diff --git a/src/tools/tidy/src/target_specific_tests.rs b/src/tools/tidy/src/target_specific_tests.rs
index a66ccd37070..1a6fd3eaf2d 100644
--- a/src/tools/tidy/src/target_specific_tests.rs
+++ b/src/tools/tidy/src/target_specific_tests.rs
@@ -30,10 +30,9 @@ pub fn check(tests_path: &Path, bad: &mut bool) {
                         comp_vec.push(component);
                     }
                 }
-            } else if directive.starts_with(COMPILE_FLAGS_HEADER) {
-                let compile_flags = &directive[COMPILE_FLAGS_HEADER.len()..];
+            } else if let Some(compile_flags) = directive.strip_prefix(COMPILE_FLAGS_HEADER) {
                 if let Some((_, v)) = compile_flags.split_once("--target") {
-                    let v = v.trim_start_matches(|c| c == ' ' || c == '=');
+                    let v = v.trim_start_matches([' ', '=']);
                     let v = if v == "{{target}}" { Some((v, v)) } else { v.split_once("-") };
                     if let Some((arch, _)) = v {
                         let info = header_map.entry(revision).or_insert(RevisionInfo::default());
@@ -57,15 +56,13 @@ pub fn check(tests_path: &Path, bad: &mut bool) {
                 (None, None) => {}
                 (Some(_), None) => {
                     eprintln!(
-                        "{}: revision {} should specify `{}` as it has `--target` set",
-                        file, rev, LLVM_COMPONENTS_HEADER
+                        "{file}: revision {rev} should specify `{LLVM_COMPONENTS_HEADER}` as it has `--target` set"
                     );
                     *bad = true;
                 }
                 (None, Some(_)) => {
                     eprintln!(
-                        "{}: revision {} should not specify `{}` as it doesn't need `--target`",
-                        file, rev, LLVM_COMPONENTS_HEADER
+                        "{file}: revision {rev} should not specify `{LLVM_COMPONENTS_HEADER}` as it doesn't need `--target`"
                     );
                     *bad = true;
                 }
diff --git a/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs b/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs
index ee92d302db3..02412b6f190 100644
--- a/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs
+++ b/src/tools/tidy/src/tests_revision_unpaired_stdout_stderr.rs
@@ -38,7 +38,7 @@ pub fn check(tests_path: impl AsRef<Path>, bad: &mut bool) {
 
             let sibling_path = sibling.path();
 
-            let Some(ext) = sibling_path.extension().map(OsStr::to_str).flatten() else {
+            let Some(ext) = sibling_path.extension().and_then(OsStr::to_str) else {
                 continue;
             };
 
@@ -84,7 +84,7 @@ pub fn check(tests_path: impl AsRef<Path>, bad: &mut bool) {
                 }
             });
 
-            let Some(test_name) = test.file_stem().map(OsStr::to_str).flatten() else {
+            let Some(test_name) = test.file_stem().and_then(OsStr::to_str) else {
                 continue;
             };
 
@@ -102,9 +102,9 @@ pub fn check(tests_path: impl AsRef<Path>, bad: &mut bool) {
         // of the form: `test-name.revision.compare_mode.extension`, but our only concern is
         // `test-name.revision` and `extension`.
         for sibling in files_under_inspection.iter().filter(|f| {
-            f.extension().map(OsStr::to_str).flatten().is_some_and(|ext| EXTENSIONS.contains(&ext))
+            f.extension().and_then(OsStr::to_str).is_some_and(|ext| EXTENSIONS.contains(&ext))
         }) {
-            let Some(filename) = sibling.file_name().map(OsStr::to_str).flatten() else {
+            let Some(filename) = sibling.file_name().and_then(OsStr::to_str) else {
                 continue;
             };
 
@@ -131,10 +131,10 @@ pub fn check(tests_path: impl AsRef<Path>, bad: &mut bool) {
                 }
                 [_, _] => return,
                 [_, found_revision, .., extension] => {
-                    if !IGNORES.contains(&found_revision)
+                    if !IGNORES.contains(found_revision)
                         && !expected_revisions.contains(*found_revision)
                         // This is from `//@ stderr-per-bitwidth`
-                        && !(*extension == "stderr" && ["32bit", "64bit"].contains(&found_revision))
+                        && !(*extension == "stderr" && ["32bit", "64bit"].contains(found_revision))
                     {
                         // Found some unexpected revision-esque component that is not a known
                         // compare-mode or expected revision.
diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs
index 53226fcb80e..4411f40d377 100644
--- a/src/tools/tidy/src/ui_tests.rs
+++ b/src/tools/tidy/src/ui_tests.rs
@@ -57,7 +57,7 @@ const EXTENSION_EXCEPTION_PATHS: &[&str] = &[
 fn check_entries(tests_path: &Path, bad: &mut bool) {
     let mut directories: HashMap<PathBuf, u32> = HashMap::new();
 
-    for dir in Walk::new(&tests_path.join("ui")) {
+    for dir in Walk::new(tests_path.join("ui")) {
         if let Ok(entry) = dir {
             let parent = entry.path().parent().unwrap().to_path_buf();
             *directories.entry(parent).or_default() += 1;
@@ -99,7 +99,7 @@ pub fn check(root_path: &Path, bless: bool, bad: &mut bool) {
 "#;
 
     let path = &root_path.join("tests");
-    check_entries(&path, bad);
+    check_entries(path, bad);
 
     // the list of files in ui tests that are allowed to start with `issue-XXXX`
     // BTreeSet because we would like a stable ordering so --bless works
@@ -109,13 +109,12 @@ pub fn check(root_path: &Path, bless: bool, bad: &mut bool) {
         .strip_prefix(issues_txt_header)
         .unwrap()
         .lines()
-        .map(|line| {
+        .inspect(|&line| {
             if prev_line > line {
                 is_sorted = false;
             }
 
             prev_line = line;
-            line
         })
         .collect();
 
diff --git a/src/tools/tidy/src/unstable_book.rs b/src/tools/tidy/src/unstable_book.rs
index a2453a6c960..9dc9d42d466 100644
--- a/src/tools/tidy/src/unstable_book.rs
+++ b/src/tools/tidy/src/unstable_book.rs
@@ -38,7 +38,7 @@ fn dir_entry_is_file(dir_entry: &fs::DirEntry) -> bool {
 pub fn collect_unstable_feature_names(features: &Features) -> BTreeSet<String> {
     features
         .iter()
-        .filter(|&(_, ref f)| f.level == Status::Unstable)
+        .filter(|&(_, f)| f.level == Status::Unstable)
         .map(|(name, _)| name.replace('_', "-"))
         .collect()
 }
@@ -90,7 +90,7 @@ pub fn check(path: &Path, features: CollectedFeatures, bad: &mut bool) {
     let lib_features = features
         .lib
         .into_iter()
-        .filter(|&(ref name, _)| !lang_features.contains_key(name))
+        .filter(|(name, _)| !lang_features.contains_key(name))
         .collect::<Features>();
 
     // Library features
diff --git a/src/tools/tidy/src/walk.rs b/src/tools/tidy/src/walk.rs
index c2c9eb8d250..7825ebeb5ba 100644
--- a/src/tools/tidy/src/walk.rs
+++ b/src/tools/tidy/src/walk.rs
@@ -66,7 +66,7 @@ pub fn walk_many(
             Ok(s) => s,
             Err(_) => return, // skip this file
         };
-        f(&entry, &contents_str);
+        f(entry, contents_str);
     });
 }
 
@@ -83,7 +83,7 @@ pub(crate) fn walk_no_read(
         !skip(e.path(), e.file_type().map(|ft| ft.is_dir()).unwrap_or(false))
     });
     for entry in walker.build().flatten() {
-        if entry.file_type().map_or(true, |kind| kind.is_dir() || kind.is_symlink()) {
+        if entry.file_type().is_none_or(|kind| kind.is_dir() || kind.is_symlink()) {
             continue;
         }
         f(&entry);
diff --git a/src/tools/tidy/src/x_version.rs b/src/tools/tidy/src/x_version.rs
index 489343561e1..6a5e9eca813 100644
--- a/src/tools/tidy/src/x_version.rs
+++ b/src/tools/tidy/src/x_version.rs
@@ -26,7 +26,7 @@ pub fn check(root: &Path, cargo: &Path, bad: &mut bool) {
                     // Check this is the rust-lang/rust x tool installation since it should be
                     // installed at a path containing `src/tools/x`.
                     if let Some(path) = iter.next() {
-                        if path.contains(&"src/tools/x") {
+                        if path.contains("src/tools/x") {
                             let version = version.strip_prefix("v").unwrap();
                             installed = Some(Version::parse(version).unwrap());
                             break;
@@ -42,15 +42,15 @@ pub fn check(root: &Path, cargo: &Path, bad: &mut bool) {
 
         if let Some(expected) = get_x_wrapper_version(root, cargo) {
             if installed < expected {
-                return println!(
+                println!(
                     "Current version of x is {installed}, but the latest version is {expected}\nConsider updating to the newer version of x by running `cargo install --path src/tools/x`"
-                );
+                )
             }
         } else {
-            return tidy_error!(
+            tidy_error!(
                 bad,
                 "Unable to parse the latest version of `x` at `src/tools/x/Cargo.toml`"
-            );
+            )
         }
     } else {
         tidy_error!(bad, "failed to check version of `x`: {}", cargo_list.status)
-- 
cgit 1.4.1-3-g733a5


From a4e994ea43671bfe2065aed3a19a20fa04427750 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Thu, 10 Jul 2025 07:44:24 +0000
Subject: tidy: simplify fluent file extension checking

---
 src/tools/tidy/src/fluent_alphabetical.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/tidy/src/fluent_alphabetical.rs b/src/tools/tidy/src/fluent_alphabetical.rs
index 8853681d4fb..48d14a37514 100644
--- a/src/tools/tidy/src/fluent_alphabetical.rs
+++ b/src/tools/tidy/src/fluent_alphabetical.rs
@@ -13,8 +13,8 @@ fn message() -> &'static Regex {
     static_regex!(r#"(?m)^([a-zA-Z0-9_]+)\s*=\s*"#)
 }
 
-fn filter_fluent(path: &Path) -> bool {
-    if let Some(ext) = path.extension() { ext.to_str() != Some("ftl") } else { true }
+fn is_fluent(path: &Path) -> bool {
+    path.extension().is_some_and(|ext| ext == "flt")
 }
 
 fn check_alphabetic(
@@ -92,7 +92,7 @@ pub fn check(path: &Path, bless: bool, bad: &mut bool) {
     let mut all_defined_msgs = HashMap::new();
     walk(
         path,
-        |path, is_dir| filter_dirs(path) || (!is_dir && filter_fluent(path)),
+        |path, is_dir| filter_dirs(path) || (!is_dir && !is_fluent(path)),
         &mut |ent, contents| {
             if bless {
                 let sorted = sort_messages(
-- 
cgit 1.4.1-3-g733a5


From 9bd4c90cafa65d6aee8295d776af314098f33bcc Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Thu, 10 Jul 2025 08:14:05 +0000
Subject: tidy: move to edition 2024

---
 src/tools/tidy/Cargo.toml  | 2 +-
 src/tools/tidy/src/main.rs | 9 +++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/tools/tidy/Cargo.toml b/src/tools/tidy/Cargo.toml
index 4835c220210..d995106ae02 100644
--- a/src/tools/tidy/Cargo.toml
+++ b/src/tools/tidy/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "tidy"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 autobins = false
 
 [dependencies]
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index 1eb5485f2b8..a67f7a511b5 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -15,11 +15,12 @@ use std::{env, process};
 use tidy::*;
 
 fn main() {
-    // Running Cargo will read the libstd Cargo.toml
+    // Enable nightly, because Cargo will read the libstd Cargo.toml
     // which uses the unstable `public-dependency` feature.
-    //
-    // `setenv` might not be thread safe, so run it before using multiple threads.
-    env::set_var("RUSTC_BOOTSTRAP", "1");
+    // SAFETY: no other threads have been spawned
+    unsafe {
+        env::set_var("RUSTC_BOOTSTRAP", "1");
+    }
 
     let root_path: PathBuf = env::args_os().nth(1).expect("need path to root of repo").into();
     let cargo: PathBuf = env::args_os().nth(2).expect("need path to cargo").into();
-- 
cgit 1.4.1-3-g733a5


From 6356faf84873abb465d46bb86f14eb3147d7e3b6 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Thu, 10 Jul 2025 08:19:59 +0000
Subject: tidy: use flatten instead of manual flatten

---
 src/tools/tidy/src/ui_tests.rs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs
index 4411f40d377..5552f858e52 100644
--- a/src/tools/tidy/src/ui_tests.rs
+++ b/src/tools/tidy/src/ui_tests.rs
@@ -57,11 +57,9 @@ const EXTENSION_EXCEPTION_PATHS: &[&str] = &[
 fn check_entries(tests_path: &Path, bad: &mut bool) {
     let mut directories: HashMap<PathBuf, u32> = HashMap::new();
 
-    for dir in Walk::new(tests_path.join("ui")) {
-        if let Ok(entry) = dir {
-            let parent = entry.path().parent().unwrap().to_path_buf();
-            *directories.entry(parent).or_default() += 1;
-        }
+    for entry in Walk::new(tests_path.join("ui")).flatten() {
+        let parent = entry.path().parent().unwrap().to_path_buf();
+        *directories.entry(parent).or_default() += 1;
     }
 
     let (mut max, mut max_issues) = (0, 0);
-- 
cgit 1.4.1-3-g733a5


From 8bf88a262328224b1c6058dc75b37af1ed786e6c Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Thu, 10 Jul 2025 08:28:16 +0000
Subject: tidy: use write_all

---
 src/tools/tidy/src/ui_tests.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs
index 5552f858e52..b1ace74e5bd 100644
--- a/src/tools/tidy/src/ui_tests.rs
+++ b/src/tools/tidy/src/ui_tests.rs
@@ -200,7 +200,7 @@ pub fn check(root_path: &Path, bless: bool, bad: &mut bool) {
         // so we don't bork things on panic or a contributor using Ctrl+C
         let blessed_issues_path = tidy_src.join("issues_blessed.txt");
         let mut blessed_issues_txt = fs::File::create(&blessed_issues_path).unwrap();
-        blessed_issues_txt.write(issues_txt_header.as_bytes()).unwrap();
+        blessed_issues_txt.write_all(issues_txt_header.as_bytes()).unwrap();
         // If we changed paths to use the OS separator, reassert Unix chauvinism for blessing.
         for filename in allowed_issue_names.difference(&remaining_issue_names) {
             writeln!(blessed_issues_txt, "{filename}").unwrap();
-- 
cgit 1.4.1-3-g733a5


From 011d4aa81f1d20b4923a01c7162caa5f0042b8ba Mon Sep 17 00:00:00 2001
From: Tomasz Miąsko <tomasz.miasko@gmail.com>
Date: Fri, 11 Jul 2025 08:10:16 +0200
Subject: Call `get_switch_int_data` on a block with SwitchInt terminator

Fix a mix-up of a block with its predecessors in handling of SwitchInt
edge effects for backward analysis. Note that this functionality is
currently unused, so change has no practical impact.
---
 compiler/rustc_mir_dataflow/src/framework/direction.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_mir_dataflow/src/framework/direction.rs b/compiler/rustc_mir_dataflow/src/framework/direction.rs
index cb647476db8..bba652656dd 100644
--- a/compiler/rustc_mir_dataflow/src/framework/direction.rs
+++ b/compiler/rustc_mir_dataflow/src/framework/direction.rs
@@ -113,7 +113,7 @@ impl Direction for Backward {
                 }
 
                 mir::TerminatorKind::SwitchInt { ref targets, ref discr } => {
-                    if let Some(mut data) = analysis.get_switch_int_data(block, discr) {
+                    if let Some(mut data) = analysis.get_switch_int_data(pred, discr) {
                         let mut tmp = analysis.bottom_value(body);
                         for &value in &body.basic_blocks.switch_sources()[&(block, pred)] {
                             tmp.clone_from(exit_state);
-- 
cgit 1.4.1-3-g733a5


From ba3b7a7d9c5908633c26145e78166b0d97e518ad Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 11 Jul 2025 07:15:20 +0000
Subject: build-helper: clippy fixes

---
 src/build_helper/src/ci.rs      |  2 +-
 src/build_helper/src/git.rs     | 32 ++++++++++++++++----------------
 src/build_helper/src/metrics.rs |  2 +-
 src/build_helper/src/util.rs    | 15 +++++++--------
 4 files changed, 25 insertions(+), 26 deletions(-)

diff --git a/src/build_helper/src/ci.rs b/src/build_helper/src/ci.rs
index 9d114c70a67..b5e70eb84cc 100644
--- a/src/build_helper/src/ci.rs
+++ b/src/build_helper/src/ci.rs
@@ -9,7 +9,7 @@ pub enum CiEnv {
 impl CiEnv {
     /// Obtains the current CI environment.
     pub fn current() -> CiEnv {
-        if std::env::var("GITHUB_ACTIONS").map_or(false, |e| e == "true") {
+        if std::env::var("GITHUB_ACTIONS").is_ok_and(|e| e == "true") {
             CiEnv::GitHubActions
         } else {
             CiEnv::None
diff --git a/src/build_helper/src/git.rs b/src/build_helper/src/git.rs
index 9d1195aadf8..cbefb836c00 100644
--- a/src/build_helper/src/git.rs
+++ b/src/build_helper/src/git.rs
@@ -13,7 +13,7 @@ pub struct GitConfig<'a> {
 pub fn output_result(cmd: &mut Command) -> Result<String, String> {
     let output = match cmd.stderr(Stdio::inherit()).output() {
         Ok(status) => status,
-        Err(e) => return Err(format!("failed to run command: {:?}: {}", cmd, e)),
+        Err(e) => return Err(format!("failed to run command: {cmd:?}: {e}")),
     };
     if !output.status.success() {
         return Err(format!(
@@ -62,22 +62,22 @@ pub enum PathFreshness {
 /// The function behaves differently in CI and outside CI.
 ///
 /// - Outside CI, we want to find out if `target_paths` were modified in some local commit on
-/// top of the latest upstream commit that is available in local git history.
-/// If not, we try to find the most recent upstream commit (which we assume are commits
-/// made by bors) that modified `target_paths`.
-/// We don't want to simply take the latest master commit to avoid changing the output of
-/// this function frequently after rebasing on the latest master branch even if `target_paths`
-/// were not modified upstream in the meantime. In that case we would be redownloading CI
-/// artifacts unnecessarily.
+///   top of the latest upstream commit that is available in local git history.
+///   If not, we try to find the most recent upstream commit (which we assume are commits
+///   made by bors) that modified `target_paths`.
+///   We don't want to simply take the latest master commit to avoid changing the output of
+///   this function frequently after rebasing on the latest master branch even if `target_paths`
+///   were not modified upstream in the meantime. In that case we would be redownloading CI
+///   artifacts unnecessarily.
 ///
 /// - In CI, we use a shallow clone of depth 2, i.e., we fetch only a single parent commit
-/// (which will be the most recent bors merge commit) and do not have access
-/// to the full git history. Luckily, we only need to distinguish between two situations:
-/// 1) The current PR made modifications to `target_paths`.
-/// In that case, a build is typically necessary.
-/// 2) The current PR did not make modifications to `target_paths`.
-/// In that case we simply take the latest upstream commit, because on CI there is no need to avoid
-/// redownloading.
+///   (which will be the most recent bors merge commit) and do not have access
+///   to the full git history. Luckily, we only need to distinguish between two situations:
+///   1) The current PR made modifications to `target_paths`.
+///      In that case, a build is typically necessary.
+///   2) The current PR did not make modifications to `target_paths`.
+///      In that case we simply take the latest upstream commit, because on CI there is no need to avoid
+///      redownloading.
 pub fn check_path_modifications(
     git_dir: &Path,
     config: &GitConfig<'_>,
@@ -232,7 +232,7 @@ pub fn get_closest_upstream_commit(
         "--author-date-order",
         &format!("--author={}", config.git_merge_commit_email),
         "-n1",
-        &base,
+        base,
     ]);
 
     let output = output_result(&mut git)?.trim().to_owned();
diff --git a/src/build_helper/src/metrics.rs b/src/build_helper/src/metrics.rs
index 8b82e62a327..07157e36415 100644
--- a/src/build_helper/src/metrics.rs
+++ b/src/build_helper/src/metrics.rs
@@ -141,7 +141,7 @@ impl BuildStep {
                 } => {
                     let full_name = format!("{parent_name}-{kind}");
                     let children: Vec<_> =
-                        children.into_iter().filter_map(|s| parse(s, &full_name)).collect();
+                        children.iter().filter_map(|s| parse(s, &full_name)).collect();
                     let children_duration = children.iter().map(|c| c.duration).sum::<Duration>();
                     Some(BuildStep {
                         r#type: kind.to_string(),
diff --git a/src/build_helper/src/util.rs b/src/build_helper/src/util.rs
index 80dd6813d13..a8355f774e9 100644
--- a/src/build_helper/src/util.rs
+++ b/src/build_helper/src/util.rs
@@ -18,29 +18,28 @@ macro_rules! exit {
 pub fn detail_exit(code: i32, is_test: bool) -> ! {
     // if in test and code is an error code, panic with status code provided
     if is_test {
-        panic!("status code: {}", code);
+        panic!("status code: {code}");
     } else {
-        // otherwise,exit with provided status code
+        // otherwise, exit with provided status code
         std::process::exit(code);
     }
 }
 
 pub fn fail(s: &str) -> ! {
-    eprintln!("\n\n{}\n\n", s);
+    eprintln!("\n\n{s}\n\n");
     detail_exit(1, cfg!(test));
 }
 
 pub fn try_run(cmd: &mut Command, print_cmd_on_fail: bool) -> Result<(), ()> {
     let status = match cmd.status() {
         Ok(status) => status,
-        Err(e) => fail(&format!("failed to execute command: {:?}\nerror: {}", cmd, e)),
+        Err(e) => fail(&format!("failed to execute command: {cmd:?}\nerror: {e}")),
     };
     if !status.success() {
         if print_cmd_on_fail {
             println!(
-                "\n\ncommand did not execute successfully: {:?}\n\
-                 expected success, got: {}\n\n",
-                cmd, status
+                "\n\ncommand did not execute successfully: {cmd:?}\n\
+                 expected success, got: {status}\n\n"
             );
         }
         Err(())
@@ -60,7 +59,7 @@ pub fn parse_gitmodules(target_dir: &Path) -> Vec<String> {
     for line in BufReader::new(file).lines().map_while(Result::ok) {
         let line = line.trim();
         if line.starts_with("path") {
-            let actual_path = line.split(' ').last().expect("Couldn't get value of path");
+            let actual_path = line.split(' ').next_back().expect("Couldn't get value of path");
             submodules_paths.push(actual_path.to_owned());
         }
     }
-- 
cgit 1.4.1-3-g733a5


From 1b9d64d87605ef426f9d9f76e59010c39f6b79ad Mon Sep 17 00:00:00 2001
From: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
Date: Thu, 10 Jul 2025 18:42:18 +0900
Subject: Migrate `remove_dbg` assist to use `SyntaxEditor`

---
 .../crates/ide-assists/src/handlers/remove_dbg.rs  | 87 +++++++++++-----------
 1 file changed, 44 insertions(+), 43 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs
index 52ace03f3cf..9356d02706c 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/remove_dbg.rs
@@ -1,8 +1,9 @@
 use itertools::Itertools;
 use syntax::{
-    Edition, NodeOrToken, SyntaxElement, T, TextRange, TextSize,
-    ast::{self, AstNode, AstToken, make},
-    match_ast, ted,
+    Edition, NodeOrToken, SyntaxNode, SyntaxToken, T,
+    ast::{self, AstNode, make},
+    match_ast,
+    syntax_editor::{Position, SyntaxEditor},
 };
 
 use crate::{AssistContext, AssistId, Assists};
@@ -40,21 +41,23 @@ pub(crate) fn remove_dbg(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
 
     let replacements =
         macro_calls.into_iter().filter_map(compute_dbg_replacement).collect::<Vec<_>>();
-
-    acc.add(
-        AssistId::quick_fix("remove_dbg"),
-        "Remove dbg!()",
-        replacements.iter().map(|&(range, _)| range).reduce(|acc, range| acc.cover(range))?,
-        |builder| {
-            for (range, expr) in replacements {
-                if let Some(expr) = expr {
-                    builder.replace(range, expr.to_string());
-                } else {
-                    builder.delete(range);
-                }
+    let target = replacements
+        .iter()
+        .flat_map(|(node_or_token, _)| node_or_token.iter())
+        .map(|t| t.text_range())
+        .reduce(|acc, range| acc.cover(range))?;
+    acc.add(AssistId::quick_fix("remove_dbg"), "Remove dbg!()", target, |builder| {
+        let mut editor = builder.make_editor(ctx.source_file().syntax());
+        for (range, expr) in replacements {
+            if let Some(expr) = expr {
+                editor.insert(Position::before(range[0].clone()), expr.syntax().clone_for_update());
+            }
+            for node_or_token in range {
+                editor.delete(node_or_token);
             }
-        },
-    )
+        }
+        builder.add_file_edits(ctx.vfs_file_id(), editor);
+    })
 }
 
 /// Returns `None` when either
@@ -63,7 +66,9 @@ pub(crate) fn remove_dbg(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
 /// - (`macro_expr` has no parent - is that possible?)
 ///
 /// Returns `Some(_, None)` when the macro call should just be removed.
-fn compute_dbg_replacement(macro_expr: ast::MacroExpr) -> Option<(TextRange, Option<ast::Expr>)> {
+fn compute_dbg_replacement(
+    macro_expr: ast::MacroExpr,
+) -> Option<(Vec<NodeOrToken<SyntaxNode, SyntaxToken>>, Option<ast::Expr>)> {
     let macro_call = macro_expr.macro_call()?;
     let tt = macro_call.token_tree()?;
     let r_delim = NodeOrToken::Token(tt.right_delimiter_token()?);
@@ -88,22 +93,22 @@ fn compute_dbg_replacement(macro_expr: ast::MacroExpr) -> Option<(TextRange, Opt
             match_ast! {
                 match parent {
                     ast::StmtList(_) => {
-                        let range = macro_expr.syntax().text_range();
-                        let range = match whitespace_start(macro_expr.syntax().prev_sibling_or_token()) {
-                            Some(start) => range.cover_offset(start),
-                            None => range,
-                        };
-                        (range, None)
+                        let mut replace = vec![macro_expr.syntax().clone().into()];
+                        if let Some(prev_sibling) = macro_expr.syntax().prev_sibling_or_token()
+                            && prev_sibling.kind() == syntax::SyntaxKind::WHITESPACE {
+                                replace.push(prev_sibling);
+                        }
+                        (replace, None)
                     },
                     ast::ExprStmt(it) => {
-                        let range = it.syntax().text_range();
-                        let range = match whitespace_start(it.syntax().prev_sibling_or_token()) {
-                            Some(start) => range.cover_offset(start),
-                            None => range,
-                        };
-                        (range, None)
+                        let mut replace = vec![it.syntax().clone().into()];
+                        if let Some(prev_sibling) = it.syntax().prev_sibling_or_token()
+                            && prev_sibling.kind() == syntax::SyntaxKind::WHITESPACE {
+                                replace.push(prev_sibling);
+                        }
+                        (replace, None)
                     },
-                    _ => (macro_call.syntax().text_range(), Some(make::ext::expr_unit())),
+                    _ => (vec![macro_call.syntax().clone().into()], Some(make::ext::expr_unit())),
                 }
             }
         }
@@ -147,13 +152,13 @@ fn compute_dbg_replacement(macro_expr: ast::MacroExpr) -> Option<(TextRange, Opt
             };
             let expr = replace_nested_dbgs(expr.clone());
             let expr = if wrap { make::expr_paren(expr).into() } else { expr.clone_subtree() };
-            (macro_call.syntax().text_range(), Some(expr))
+            (vec![macro_call.syntax().clone().into()], Some(expr))
         }
         // dbg!(expr0, expr1, ...)
         exprs => {
             let exprs = exprs.iter().cloned().map(replace_nested_dbgs);
             let expr = make::expr_tuple(exprs);
-            (macro_call.syntax().text_range(), Some(expr.into()))
+            (vec![macro_call.syntax().clone().into()], Some(expr.into()))
         }
     })
 }
@@ -178,8 +183,8 @@ fn replace_nested_dbgs(expanded: ast::Expr) -> ast::Expr {
         return replaced;
     }
 
-    let expanded = expanded.clone_for_update();
-
+    let expanded = expanded.clone_subtree();
+    let mut editor = SyntaxEditor::new(expanded.syntax().clone());
     // We need to collect to avoid mutation during traversal.
     let macro_exprs: Vec<_> =
         expanded.syntax().descendants().filter_map(ast::MacroExpr::cast).collect();
@@ -191,17 +196,13 @@ fn replace_nested_dbgs(expanded: ast::Expr) -> ast::Expr {
         };
 
         if let Some(expr) = expr_opt {
-            ted::replace(mac.syntax(), expr.syntax().clone_for_update());
+            editor.replace(mac.syntax(), expr.syntax().clone_for_update());
         } else {
-            ted::remove(mac.syntax());
+            editor.delete(mac.syntax());
         }
     }
-
-    expanded
-}
-
-fn whitespace_start(it: Option<SyntaxElement>) -> Option<TextSize> {
-    Some(it?.into_token().and_then(ast::Whitespace::cast)?.syntax().text_range().start())
+    let expanded_syntax = editor.finish().new_root().clone();
+    ast::Expr::cast(expanded_syntax).unwrap()
 }
 
 #[cfg(test)]
-- 
cgit 1.4.1-3-g733a5


From 39f7707feac629defbd5a0cc9e2a1f7c18e843ea Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Wed, 9 Jul 2025 20:53:13 -0700
Subject: compiler: comment on some call-related codegen fn in cg_ssa

Partially documents the situation due to LLVM CFI.
---
 compiler/rustc_codegen_ssa/src/traits/builder.rs   | 23 +++++++++++++++++++++-
 compiler/rustc_codegen_ssa/src/traits/intrinsic.rs |  8 +++++++-
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/traits/builder.rs b/compiler/rustc_codegen_ssa/src/traits/builder.rs
index 9d367748c2a..829b8899398 100644
--- a/compiler/rustc_codegen_ssa/src/traits/builder.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/builder.rs
@@ -555,12 +555,33 @@ pub trait BuilderMethods<'a, 'tcx>:
     /// Called for `StorageDead`
     fn lifetime_end(&mut self, ptr: Self::Value, size: Size);
 
+    /// "Finally codegen the call"
+    ///
+    /// ## Arguments
+    ///
+    /// The `fn_attrs`, `fn_abi`, and `instance` arguments are Options because they are advisory.
+    /// They relate to optional codegen enhancements like LLVM CFI, and do not affect ABI per se.
+    /// Any ABI-related transformations should be handled by different, earlier stages of codegen.
+    /// For instance, in the caller of `BuilderMethods::call`.
+    ///
+    /// This means that a codegen backend which disregards `fn_attrs`, `fn_abi`, and `instance`
+    /// should still do correct codegen, and code should not be miscompiled if they are omitted.
+    /// It is not a miscompilation in this sense if it fails to run under CFI, other sanitizers, or
+    /// in the context of other compiler-enhanced security features.
+    ///
+    /// The typical case that they are None is during the codegen of intrinsics and lang-items,
+    /// as those are "fake functions" with only a trivial ABI if any, et cetera.
+    ///
+    /// ## Return
+    ///
+    /// Must return the value the function will return so it can be written to the destination,
+    /// assuming the function does not explicitly pass the destination as a pointer in `args`.
     fn call(
         &mut self,
         llty: Self::Type,
         fn_attrs: Option<&CodegenFnAttrs>,
         fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>,
-        llfn: Self::Value,
+        fn_val: Self::Value,
         args: &[Self::Value],
         funclet: Option<&Self::Funclet>,
         instance: Option<Instance<'tcx>>,
diff --git a/compiler/rustc_codegen_ssa/src/traits/intrinsic.rs b/compiler/rustc_codegen_ssa/src/traits/intrinsic.rs
index 7d0c6be4c65..c5ecf43046c 100644
--- a/compiler/rustc_codegen_ssa/src/traits/intrinsic.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/intrinsic.rs
@@ -6,16 +6,22 @@ use crate::mir::operand::OperandRef;
 use crate::mir::place::PlaceRef;
 
 pub trait IntrinsicCallBuilderMethods<'tcx>: BackendTypes {
+    /// Higher-level interface to emitting calls to intrinsics
+    ///
     /// Remember to add all intrinsics here, in `compiler/rustc_hir_analysis/src/check/mod.rs`,
     /// and in `library/core/src/intrinsics.rs`; if you need access to any LLVM intrinsics,
     /// add them to `compiler/rustc_codegen_llvm/src/context.rs`.
     /// Returns `Err` if another instance should be called instead. This is used to invoke
     /// intrinsic default bodies in case an intrinsic is not implemented by the backend.
+    ///
+    /// NOTE: allowed to call [`BuilderMethods::call`]
+    ///
+    /// [`BuilderMethods::call`]: super::builder::BuilderMethods::call
     fn codegen_intrinsic_call(
         &mut self,
         instance: ty::Instance<'tcx>,
         args: &[OperandRef<'tcx, Self::Value>],
-        result: PlaceRef<'tcx, Self::Value>,
+        result_dest: PlaceRef<'tcx, Self::Value>,
         span: Span,
     ) -> Result<(), ty::Instance<'tcx>>;
 
-- 
cgit 1.4.1-3-g733a5


From e681d1a9731897951ea4c2d68c7d8f4a322b9904 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Fri, 11 Jul 2025 08:17:58 +0000
Subject: constify `From` and `Into`

---
 library/core/src/convert/mod.rs                    | 29 +++++++++++++++------
 tests/ui/specialization/issue-111232.rs            |  9 +++++++
 tests/ui/specialization/issue-111232.stderr        |  9 ++++---
 .../non-const-op-in-closure-in-const.rs            |  4 +--
 .../non-const-op-in-closure-in-const.stderr        | 30 ----------------------
 5 files changed, 38 insertions(+), 43 deletions(-)
 delete mode 100644 tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr

diff --git a/library/core/src/convert/mod.rs b/library/core/src/convert/mod.rs
index 7132e712ec5..38381dbdf23 100644
--- a/library/core/src/convert/mod.rs
+++ b/library/core/src/convert/mod.rs
@@ -445,6 +445,8 @@ pub trait AsMut<T: PointeeSized>: PointeeSized {
 #[rustc_diagnostic_item = "Into"]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(search_unbox)]
+#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[const_trait]
 pub trait Into<T>: Sized {
     /// Converts this type into the (usually inferred) input type.
     #[must_use]
@@ -580,6 +582,8 @@ pub trait Into<T>: Sized {
     note = "to coerce a `{T}` into a `{Self}`, use `&*` as a prefix",
 ))]
 #[doc(search_unbox)]
+#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[const_trait]
 pub trait From<T>: Sized {
     /// Converts to this type from the input type.
     #[rustc_diagnostic_item = "from_fn"]
@@ -607,6 +611,8 @@ pub trait From<T>: Sized {
 /// [`Into`], see there for details.
 #[rustc_diagnostic_item = "TryInto"]
 #[stable(feature = "try_from", since = "1.34.0")]
+#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[const_trait]
 pub trait TryInto<T>: Sized {
     /// The type returned in the event of a conversion error.
     #[stable(feature = "try_from", since = "1.34.0")]
@@ -685,6 +691,8 @@ pub trait TryInto<T>: Sized {
 /// [`try_from`]: TryFrom::try_from
 #[rustc_diagnostic_item = "TryFrom"]
 #[stable(feature = "try_from", since = "1.34.0")]
+#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+#[const_trait]
 pub trait TryFrom<T>: Sized {
     /// The type returned in the event of a conversion error.
     #[stable(feature = "try_from", since = "1.34.0")]
@@ -754,9 +762,10 @@ where
 
 // From implies Into
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, U> Into<U> for T
+#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+impl<T, U> const Into<U> for T
 where
-    U: From<T>,
+    U: ~const From<T>,
 {
     /// Calls `U::from(self)`.
     ///
@@ -771,7 +780,8 @@ where
 
 // From (and thus Into) is reflexive
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> From<T> for T {
+#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+impl<T> const From<T> for T {
     /// Returns the argument unchanged.
     #[inline(always)]
     fn from(t: T) -> T {
@@ -787,7 +797,8 @@ impl<T> From<T> for T {
 #[stable(feature = "convert_infallible", since = "1.34.0")]
 #[rustc_reservation_impl = "permitting this impl would forbid us from adding \
                             `impl<T> From<!> for T` later; see rust-lang/rust#64715 for details"]
-impl<T> From<!> for T {
+#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+impl<T> const From<!> for T {
     fn from(t: !) -> T {
         t
     }
@@ -795,9 +806,10 @@ impl<T> From<!> for T {
 
 // TryFrom implies TryInto
 #[stable(feature = "try_from", since = "1.34.0")]
-impl<T, U> TryInto<U> for T
+#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+impl<T, U> const TryInto<U> for T
 where
-    U: TryFrom<T>,
+    U: ~const TryFrom<T>,
 {
     type Error = U::Error;
 
@@ -810,9 +822,10 @@ where
 // Infallible conversions are semantically equivalent to fallible conversions
 // with an uninhabited error type.
 #[stable(feature = "try_from", since = "1.34.0")]
-impl<T, U> TryFrom<U> for T
+#[rustc_const_unstable(feature = "const_from", issue = "143773")]
+impl<T, U> const TryFrom<U> for T
 where
-    U: Into<T>,
+    U: ~const Into<T>,
 {
     type Error = Infallible;
 
diff --git a/tests/ui/specialization/issue-111232.rs b/tests/ui/specialization/issue-111232.rs
index 3ed3c580e6d..fa00f01886f 100644
--- a/tests/ui/specialization/issue-111232.rs
+++ b/tests/ui/specialization/issue-111232.rs
@@ -1,4 +1,13 @@
 #![feature(min_specialization)]
+#![feature(const_trait_impl)]
+
+trait From<T> {
+    fn from(t: T) -> Self;
+}
+
+impl<T> From<T> for T {
+    fn from(t: T) -> T { t }
+}
 
 struct S;
 
diff --git a/tests/ui/specialization/issue-111232.stderr b/tests/ui/specialization/issue-111232.stderr
index ed392e4f915..5f169f0bb36 100644
--- a/tests/ui/specialization/issue-111232.stderr
+++ b/tests/ui/specialization/issue-111232.stderr
@@ -1,10 +1,13 @@
 error[E0520]: `from` specializes an item from a parent `impl`, but that item is not marked `default`
-  --> $DIR/issue-111232.rs:6:5
+  --> $DIR/issue-111232.rs:15:5
    |
+LL | impl<T> From<T> for T {
+   | --------------------- parent `impl` is here
+...
 LL |     fn from(s: S) -> S {
-   |     ^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^ cannot specialize default item `from`
    |
-   = note: parent implementation is in crate `core`
+   = note: to specialize, `from` in the parent `impl` must be marked `default`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.rs b/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.rs
index 86e3e5f769f..d5f80acc15b 100644
--- a/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.rs
+++ b/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.rs
@@ -1,6 +1,6 @@
-//@ known-bug: #110395
+#![feature(const_trait_impl, const_from)]
 
-#![feature(const_trait_impl)]
+//@ check-pass
 
 #[const_trait]
 trait Convert<T> {
diff --git a/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr b/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr
deleted file mode 100644
index e7f10e73c69..00000000000
--- a/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr
+++ /dev/null
@@ -1,30 +0,0 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/non-const-op-in-closure-in-const.rs:10:44
-   |
-LL | impl<A, B> const Convert<B> for A where B: [const] From<A> {
-   |                                            ^^^^^^^ can't be applied to `From`
-   |
-note: `From` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/convert/mod.rs:LL:COL
-
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/non-const-op-in-closure-in-const.rs:10:44
-   |
-LL | impl<A, B> const Convert<B> for A where B: [const] From<A> {
-   |                                            ^^^^^^^ can't be applied to `From`
-   |
-note: `From` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
-  --> $SRC_DIR/core/src/convert/mod.rs:LL:COL
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0015]: cannot call non-const associated function `<B as From<A>>::from` in constant functions
-  --> $DIR/non-const-op-in-closure-in-const.rs:12:9
-   |
-LL |         B::from(self)
-   |         ^^^^^^^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0015`.
-- 
cgit 1.4.1-3-g733a5


From 5b6d661039116ea573652393938061a9a2a2c586 Mon Sep 17 00:00:00 2001
From: Tomasz Miąsko <tomasz.miasko@gmail.com>
Date: Fri, 11 Jul 2025 08:43:16 +0200
Subject: Remove support for SwitchInt edge effects in backward dataflow
 analyses

Those effects are untested and unused. Remove them along with
the implementation of `BasicBlocks::switch_sources`.
---
 compiler/rustc_middle/src/mir/basic_blocks.rs      | 40 +---------------------
 .../rustc_mir_dataflow/src/framework/direction.rs  | 15 ++++----
 2 files changed, 7 insertions(+), 48 deletions(-)

diff --git a/compiler/rustc_middle/src/mir/basic_blocks.rs b/compiler/rustc_middle/src/mir/basic_blocks.rs
index d0dbf64dc59..0d2e23609ce 100644
--- a/compiler/rustc_middle/src/mir/basic_blocks.rs
+++ b/compiler/rustc_middle/src/mir/basic_blocks.rs
@@ -1,6 +1,5 @@
 use std::sync::OnceLock;
 
-use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::graph;
 use rustc_data_structures::graph::dominators::{Dominators, dominators};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
@@ -10,7 +9,7 @@ use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use smallvec::SmallVec;
 
 use crate::mir::traversal::Postorder;
-use crate::mir::{BasicBlock, BasicBlockData, START_BLOCK, Terminator, TerminatorKind};
+use crate::mir::{BasicBlock, BasicBlockData, START_BLOCK};
 
 #[derive(Clone, TyEncodable, TyDecodable, Debug, HashStable, TypeFoldable, TypeVisitable)]
 pub struct BasicBlocks<'tcx> {
@@ -21,15 +20,6 @@ pub struct BasicBlocks<'tcx> {
 // Typically 95%+ of basic blocks have 4 or fewer predecessors.
 type Predecessors = IndexVec<BasicBlock, SmallVec<[BasicBlock; 4]>>;
 
-/// Each `(target, switch)` entry in the map contains a list of switch values
-/// that lead to a `target` block from a `switch` block.
-///
-/// Note: this type is currently never instantiated, because it's only used for
-/// `BasicBlocks::switch_sources`, which is only called by backwards analyses
-/// that do `SwitchInt` handling, and we don't have any of those, not even in
-/// tests. See #95120 and #94576.
-type SwitchSources = FxHashMap<(BasicBlock, BasicBlock), SmallVec<[SwitchTargetValue; 1]>>;
-
 #[derive(Debug, Clone, Copy)]
 pub enum SwitchTargetValue {
     // A normal switch value.
@@ -41,7 +31,6 @@ pub enum SwitchTargetValue {
 #[derive(Clone, Default, Debug)]
 struct Cache {
     predecessors: OnceLock<Predecessors>,
-    switch_sources: OnceLock<SwitchSources>,
     reverse_postorder: OnceLock<Vec<BasicBlock>>,
     dominators: OnceLock<Dominators<BasicBlock>>,
 }
@@ -86,33 +75,6 @@ impl<'tcx> BasicBlocks<'tcx> {
         })
     }
 
-    /// Returns info about switch values that lead from one block to another
-    /// block. See `SwitchSources`.
-    #[inline]
-    pub fn switch_sources(&self) -> &SwitchSources {
-        self.cache.switch_sources.get_or_init(|| {
-            let mut switch_sources: SwitchSources = FxHashMap::default();
-            for (bb, data) in self.basic_blocks.iter_enumerated() {
-                if let Some(Terminator {
-                    kind: TerminatorKind::SwitchInt { targets, .. }, ..
-                }) = &data.terminator
-                {
-                    for (value, target) in targets.iter() {
-                        switch_sources
-                            .entry((target, bb))
-                            .or_default()
-                            .push(SwitchTargetValue::Normal(value));
-                    }
-                    switch_sources
-                        .entry((targets.otherwise(), bb))
-                        .or_default()
-                        .push(SwitchTargetValue::Otherwise);
-                }
-            }
-            switch_sources
-        })
-    }
-
     /// Returns mutable reference to basic blocks. Invalidates CFG cache.
     #[inline]
     pub fn as_mut(&mut self) -> &mut IndexVec<BasicBlock, BasicBlockData<'tcx>> {
diff --git a/compiler/rustc_mir_dataflow/src/framework/direction.rs b/compiler/rustc_mir_dataflow/src/framework/direction.rs
index bba652656dd..79c0db7d728 100644
--- a/compiler/rustc_mir_dataflow/src/framework/direction.rs
+++ b/compiler/rustc_mir_dataflow/src/framework/direction.rs
@@ -1,5 +1,6 @@
 use std::ops::RangeInclusive;
 
+use rustc_middle::bug;
 use rustc_middle::mir::{
     self, BasicBlock, CallReturnPlaces, Location, SwitchTargetValue, TerminatorEdges,
 };
@@ -112,15 +113,11 @@ impl Direction for Backward {
                     propagate(pred, &tmp);
                 }
 
-                mir::TerminatorKind::SwitchInt { ref targets, ref discr } => {
-                    if let Some(mut data) = analysis.get_switch_int_data(pred, discr) {
-                        let mut tmp = analysis.bottom_value(body);
-                        for &value in &body.basic_blocks.switch_sources()[&(block, pred)] {
-                            tmp.clone_from(exit_state);
-                            analysis
-                                .apply_switch_int_edge_effect(&mut data, &mut tmp, value, targets);
-                            propagate(pred, &tmp);
-                        }
+                mir::TerminatorKind::SwitchInt { ref discr, .. } => {
+                    if let Some(_data) = analysis.get_switch_int_data(pred, discr) {
+                        bug!(
+                            "SwitchInt edge effects are unsupported in backward dataflow analyses"
+                        );
                     } else {
                         propagate(pred, exit_state)
                     }
-- 
cgit 1.4.1-3-g733a5


From 074846289a4f69d8057bc3ee7789728f560e1ec8 Mon Sep 17 00:00:00 2001
From: Huang Qi <huangqi3@xiaomi.com>
Date: Fri, 11 Jul 2025 17:31:08 +0800
Subject: std: move NuttX to use arc4random for random number generation

* Move `target_os = "nuttx"` from unix_legacy to arc4random section
* This aligns NuttX with other POSIX-compliant systems that support arc4random
* Improves random number generation quality on NuttX by using the system's
  built-in arc4random implementation instead of legacy fallback methods

NuttX supports arc4random_buf which provides better entropy and security
compared to the legacy random number generation methods.

Signed-off-by: Huang Qi <huangqi3@xiaomi.com>
---
 library/std/src/sys/random/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/sys/random/mod.rs b/library/std/src/sys/random/mod.rs
index 013e886a99b..fc85797dcc2 100644
--- a/library/std/src/sys/random/mod.rs
+++ b/library/std/src/sys/random/mod.rs
@@ -20,6 +20,7 @@ cfg_if::cfg_if! {
         target_os = "rtems",
         target_os = "solaris",
         target_os = "vita",
+        target_os = "nuttx",
     ))] {
         mod arc4random;
         pub use arc4random::fill_bytes;
@@ -44,7 +45,6 @@ cfg_if::cfg_if! {
         target_os = "hurd",
         target_os = "l4re",
         target_os = "nto",
-        target_os = "nuttx",
     ))] {
         mod unix_legacy;
         pub use unix_legacy::fill_bytes;
-- 
cgit 1.4.1-3-g733a5


From 7ad30cc619b4c0b7b2b9f30fd8f0c20ab053cb16 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Fri, 11 Jul 2025 09:55:05 +0000
Subject: Some const_trait_impl test cleanups

---
 tests/ui/traits/const-traits/const-drop.rs       | 2 --
 tests/ui/traits/const-traits/issue-102985.rs     | 5 +----
 tests/ui/traits/const-traits/issue-102985.stderr | 2 +-
 tests/ui/traits/const-traits/issue-88155.rs      | 5 +----
 tests/ui/traits/const-traits/issue-88155.stderr  | 2 +-
 5 files changed, 4 insertions(+), 12 deletions(-)

diff --git a/tests/ui/traits/const-traits/const-drop.rs b/tests/ui/traits/const-traits/const-drop.rs
index 5df3a77f73a..dc985a8f620 100644
--- a/tests/ui/traits/const-traits/const-drop.rs
+++ b/tests/ui/traits/const-traits/const-drop.rs
@@ -17,12 +17,10 @@ impl<'a> const Drop for S<'a> {
 }
 
 const fn a<T: [const] Destruct>(_: T) {}
-//FIXME ~^ ERROR destructor of
 
 const fn b() -> u8 {
     let mut c = 0;
     let _ = S(&mut c);
-    //FIXME ~^ ERROR destructor of
     a(S(&mut c));
     c
 }
diff --git a/tests/ui/traits/const-traits/issue-102985.rs b/tests/ui/traits/const-traits/issue-102985.rs
index e5394ddd688..ebab6566d4b 100644
--- a/tests/ui/traits/const-traits/issue-102985.rs
+++ b/tests/ui/traits/const-traits/issue-102985.rs
@@ -1,12 +1,9 @@
-//@ known-bug: #110395
 #![feature(const_trait_impl)]
 
 struct Bug {
     inner: [(); match || 1 {
         n => n(),
-        //FIXME ~^ ERROR the trait bound
-        //FIXME ~| ERROR the trait bound
-        //FIXME ~| ERROR cannot call non-const closure in constants
+        //~^ ERROR cannot call non-const closure in constants
     }],
 }
 
diff --git a/tests/ui/traits/const-traits/issue-102985.stderr b/tests/ui/traits/const-traits/issue-102985.stderr
index 7c5c5acf207..8588dc17e70 100644
--- a/tests/ui/traits/const-traits/issue-102985.stderr
+++ b/tests/ui/traits/const-traits/issue-102985.stderr
@@ -1,5 +1,5 @@
 error[E0015]: cannot call non-const closure in constants
-  --> $DIR/issue-102985.rs:6:14
+  --> $DIR/issue-102985.rs:5:14
    |
 LL |         n => n(),
    |              ^^^
diff --git a/tests/ui/traits/const-traits/issue-88155.rs b/tests/ui/traits/const-traits/issue-88155.rs
index a26128a6ecc..a642e1101c7 100644
--- a/tests/ui/traits/const-traits/issue-88155.rs
+++ b/tests/ui/traits/const-traits/issue-88155.rs
@@ -1,5 +1,3 @@
-//@ known-bug: #110395
-
 #![feature(const_trait_impl)]
 
 pub trait A {
@@ -8,8 +6,7 @@ pub trait A {
 
 pub const fn foo<T: A>() -> bool {
     T::assoc()
-    //FIXME ~^ ERROR the trait bound
-    //FIXME ~| ERROR cannot call non-const function
+    //~^ ERROR cannot call non-const associated function
 }
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/issue-88155.stderr b/tests/ui/traits/const-traits/issue-88155.stderr
index 2e140ac9ff6..96a3c4187f5 100644
--- a/tests/ui/traits/const-traits/issue-88155.stderr
+++ b/tests/ui/traits/const-traits/issue-88155.stderr
@@ -1,5 +1,5 @@
 error[E0015]: cannot call non-const associated function `<T as A>::assoc` in constant functions
-  --> $DIR/issue-88155.rs:10:5
+  --> $DIR/issue-88155.rs:8:5
    |
 LL |     T::assoc()
    |     ^^^^^^^^^^
-- 
cgit 1.4.1-3-g733a5


From 13b1e4030aecb24b5a78cfa44594641e7d49b4b6 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Fri, 11 Jul 2025 03:57:19 -0700
Subject: More discriminant codegen tests

These are from 139729, updated to pass on master.
---
 tests/codegen/enum/enum-discriminant-eq.rs | 231 ++++++++++++++++++++++
 tests/codegen/enum/enum-match.rs           | 307 +++++++++++++++++++++++++++++
 2 files changed, 538 insertions(+)
 create mode 100644 tests/codegen/enum/enum-discriminant-eq.rs

diff --git a/tests/codegen/enum/enum-discriminant-eq.rs b/tests/codegen/enum/enum-discriminant-eq.rs
new file mode 100644
index 00000000000..fd6f3499cb1
--- /dev/null
+++ b/tests/codegen/enum/enum-discriminant-eq.rs
@@ -0,0 +1,231 @@
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+//@ min-llvm-version: 20
+//@ only-64bit
+
+// The `derive(PartialEq)` on enums with field-less variants compares discriminants,
+// so make sure we emit that in some reasonable way.
+
+#![crate_type = "lib"]
+#![feature(ascii_char)]
+#![feature(core_intrinsics)]
+#![feature(repr128)]
+
+use std::ascii::Char as AC;
+use std::cmp::Ordering;
+use std::intrinsics::discriminant_value;
+use std::num::NonZero;
+
+// A type that's bigger than `isize`, unlike the usual cases that have small tags.
+#[repr(u128)]
+pub enum Giant {
+    Two = 2,
+    Three = 3,
+    Four = 4,
+}
+
+#[unsafe(no_mangle)]
+pub fn opt_bool_eq_discr(a: Option<bool>, b: Option<bool>) -> bool {
+    // CHECK-LABEL: @opt_bool_eq_discr(
+    // CHECK: %[[A:.+]] = icmp ne i8 %a, 2
+    // CHECK: %[[B:.+]] = icmp eq i8 %b, 2
+    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
+    // CHECK: ret i1 %[[R]]
+
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn opt_ord_eq_discr(a: Option<Ordering>, b: Option<Ordering>) -> bool {
+    // CHECK-LABEL: @opt_ord_eq_discr(
+    // CHECK: %[[A:.+]] = icmp ne i8 %a, 2
+    // CHECK: %[[B:.+]] = icmp eq i8 %b, 2
+    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
+    // CHECK: ret i1 %[[R]]
+
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn opt_nz32_eq_discr(a: Option<NonZero<u32>>, b: Option<NonZero<u32>>) -> bool {
+    // CHECK-LABEL: @opt_nz32_eq_discr(
+    // CHECK: %[[A:.+]] = icmp ne i32 %a, 0
+    // CHECK: %[[B:.+]] = icmp eq i32 %b, 0
+    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
+    // CHECK: ret i1 %[[R]]
+
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn opt_ac_eq_discr(a: Option<AC>, b: Option<AC>) -> bool {
+    // CHECK-LABEL: @opt_ac_eq_discr(
+    // CHECK: %[[A:.+]] = icmp ne i8 %a, -128
+    // CHECK: %[[B:.+]] = icmp eq i8 %b, -128
+    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
+    // CHECK: ret i1 %[[R]]
+
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn opt_giant_eq_discr(a: Option<Giant>, b: Option<Giant>) -> bool {
+    // CHECK-LABEL: @opt_giant_eq_discr(
+    // CHECK: %[[A:.+]] = icmp ne i128 %a, 1
+    // CHECK: %[[B:.+]] = icmp eq i128 %b, 1
+    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
+    // CHECK: ret i1 %[[R]]
+
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+pub enum Mid<T> {
+    Before,
+    Thing(T),
+    After,
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_bool_eq_discr(a: Mid<bool>, b: Mid<bool>) -> bool {
+    // CHECK-LABEL: @mid_bool_eq_discr(
+
+    // CHECK: %[[A_REL_DISCR:.+]] = add nsw i8 %a, -2
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp ult i8 %[[A_REL_DISCR]], 3
+    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %[[A_REL_DISCR]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
+    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
+
+    // CHECK: %[[B_REL_DISCR:.+]] = add nsw i8 %b, -2
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp ult i8 %[[B_REL_DISCR]], 3
+    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %[[B_REL_DISCR]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
+    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
+
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_ord_eq_discr(a: Mid<Ordering>, b: Mid<Ordering>) -> bool {
+    // CHECK-LABEL: @mid_ord_eq_discr(
+
+    // CHECK: %[[A_REL_DISCR:.+]] = add nsw i8 %a, -2
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp ult i8 %[[A_REL_DISCR]], 3
+    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %[[A_REL_DISCR]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
+    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
+
+    // CHECK: %[[B_REL_DISCR:.+]] = add nsw i8 %b, -2
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp ult i8 %[[B_REL_DISCR]], 3
+    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %[[B_REL_DISCR]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
+    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
+
+    // CHECK: %[[R:.+]] = icmp eq i8 %[[A_DISCR]], %[[B_DISCR]]
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_nz32_eq_discr(a: Mid<NonZero<u32>>, b: Mid<NonZero<u32>>) -> bool {
+    // CHECK-LABEL: @mid_nz32_eq_discr(
+    // CHECK: %[[R:.+]] = icmp eq i32 %a.0, %b.0
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_ac_eq_discr(a: Mid<AC>, b: Mid<AC>) -> bool {
+    // CHECK-LABEL: @mid_ac_eq_discr(
+
+    // CHECK: %[[A_REL_DISCR:.+]] = xor i8 %a, -128
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp ult i8 %[[A_REL_DISCR]], 3
+    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %a, -127
+    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
+    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
+
+    // CHECK: %[[B_REL_DISCR:.+]] = xor i8 %b, -128
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp ult i8 %[[B_REL_DISCR]], 3
+    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %b, -127
+    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
+    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
+
+    // CHECK: %[[R:.+]] = icmp eq i8 %[[A_DISCR]], %[[B_DISCR]]
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+// FIXME: This should be improved once our LLVM fork picks up the fix for
+// <https://github.com/llvm/llvm-project/issues/134024>
+#[unsafe(no_mangle)]
+pub fn mid_giant_eq_discr(a: Mid<Giant>, b: Mid<Giant>) -> bool {
+    // CHECK-LABEL: @mid_giant_eq_discr(
+
+    // CHECK: %[[A_REL_DISCR_WIDE:.+]] = add nsw i128 %a, -5
+    // CHECK: %[[A_REL_DISCR:.+]] = trunc nsw i128 %[[A_REL_DISCR_WIDE]] to i64
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp ult i128 %[[A_REL_DISCR_WIDE]], 3
+    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i128 %[[A_REL_DISCR_WIDE]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
+    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i64 %[[A_REL_DISCR]], i64 1
+
+    // CHECK: %[[B_REL_DISCR_WIDE:.+]] = add nsw i128 %b, -5
+    // CHECK: %[[B_REL_DISCR:.+]] = trunc nsw i128 %[[B_REL_DISCR_WIDE]] to i64
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp ult i128 %[[B_REL_DISCR_WIDE]], 3
+    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i128 %[[B_REL_DISCR_WIDE]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
+    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i64 %[[B_REL_DISCR]], i64 1
+
+    // CHECK: %[[R:.+]] = icmp eq i64 %[[A_DISCR]], %[[B_DISCR]]
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+// In niche-encoded enums, testing for the untagged variant should optimize to a
+// straight-forward comparison looking for the natural range of the payload value.
+// FIXME: A bunch don't, though.
+
+#[unsafe(no_mangle)]
+pub fn mid_bool_is_thing(a: Mid<bool>) -> bool {
+    // CHECK-LABEL: @mid_bool_is_thing(
+
+    // CHECK: %[[REL_DISCR:.+]] = add nsw i8 %a, -2
+    // CHECK: %[[R:.+]] = icmp ugt i8 %[[REL_DISCR]], 2
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == 1
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_ord_is_thing(a: Mid<Ordering>) -> bool {
+    // CHECK-LABEL: @mid_ord_is_thing(
+    // CHECK: %[[REL_DISCR:.+]] = add nsw i8 %a, -2
+    // CHECK: %[[R:.+]] = icmp ugt i8 %[[REL_DISCR]], 2
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == 1
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_nz32_is_thing(a: Mid<NonZero<u32>>) -> bool {
+    // CHECK-LABEL: @mid_nz32_is_thing(
+    // CHECK: %[[R:.+]] = icmp eq i32 %a.0, 1
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == 1
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_ac_is_thing(a: Mid<AC>) -> bool {
+    // CHECK-LABEL: @mid_ac_is_thing(
+    // CHECK: %[[R:.+]] = icmp sgt i8 %a, -1
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == 1
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_giant_is_thing(a: Mid<Giant>) -> bool {
+    // CHECK-LABEL: @mid_giant_is_thing(
+    // CHECK: %[[REL_DISCR_WIDE:.+]] = add nsw i128 %a, -5
+    // CHECK: %[[REL_DISCR:.+]] = trunc nsw i128 %[[REL_DISCR_WIDE]] to i64
+    // CHECK: %[[NOT_NICHE:.+]] = icmp ugt i128 %[[REL_DISCR_WIDE]], 2
+    // CHECK: %[[IS_MID_VARIANT:.+]] = icmp eq i64 %[[REL_DISCR]], 1
+    // CHECK: %[[R:.+]] = select i1 %[[NOT_NICHE]], i1 true, i1 %[[IS_MID_VARIANT]]
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == 1
+}
diff --git a/tests/codegen/enum/enum-match.rs b/tests/codegen/enum/enum-match.rs
index 98635008d06..9725e64def6 100644
--- a/tests/codegen/enum/enum-match.rs
+++ b/tests/codegen/enum/enum-match.rs
@@ -471,3 +471,310 @@ pub fn match5(e: HugeVariantIndex) -> u8 {
         Possible259 => 100,
     }
 }
+
+// Make an enum where the niche tags wrap both as signed and as unsigned, to hit
+// the most-fallback case where there's just nothing smart to do.
+
+pub enum E10Through65 {
+    D10 = 10,
+    D11 = 11,
+    D12 = 12,
+    D13 = 13,
+    D14 = 14,
+    D15 = 15,
+    D16 = 16,
+    D17 = 17,
+    D18 = 18,
+    D19 = 19,
+    D20 = 20,
+    D21 = 21,
+    D22 = 22,
+    D23 = 23,
+    D24 = 24,
+    D25 = 25,
+    D26 = 26,
+    D27 = 27,
+    D28 = 28,
+    D29 = 29,
+    D30 = 30,
+    D31 = 31,
+    D32 = 32,
+    D33 = 33,
+    D34 = 34,
+    D35 = 35,
+    D36 = 36,
+    D37 = 37,
+    D38 = 38,
+    D39 = 39,
+    D40 = 40,
+    D41 = 41,
+    D42 = 42,
+    D43 = 43,
+    D44 = 44,
+    D45 = 45,
+    D46 = 46,
+    D47 = 47,
+    D48 = 48,
+    D49 = 49,
+    D50 = 50,
+    D51 = 51,
+    D52 = 52,
+    D53 = 53,
+    D54 = 54,
+    D55 = 55,
+    D56 = 56,
+    D57 = 57,
+    D58 = 58,
+    D59 = 59,
+    D60 = 60,
+    D61 = 61,
+    D62 = 62,
+    D63 = 63,
+    D64 = 64,
+    D65 = 65,
+}
+
+pub enum Tricky {
+    Untagged(E10Through65),
+    V001,
+    V002,
+    V003,
+    V004,
+    V005,
+    V006,
+    V007,
+    V008,
+    V009,
+    V010,
+    V011,
+    V012,
+    V013,
+    V014,
+    V015,
+    V016,
+    V017,
+    V018,
+    V019,
+    V020,
+    V021,
+    V022,
+    V023,
+    V024,
+    V025,
+    V026,
+    V027,
+    V028,
+    V029,
+    V030,
+    V031,
+    V032,
+    V033,
+    V034,
+    V035,
+    V036,
+    V037,
+    V038,
+    V039,
+    V040,
+    V041,
+    V042,
+    V043,
+    V044,
+    V045,
+    V046,
+    V047,
+    V048,
+    V049,
+    V050,
+    V051,
+    V052,
+    V053,
+    V054,
+    V055,
+    V056,
+    V057,
+    V058,
+    V059,
+    V060,
+    V061,
+    V062,
+    V063,
+    V064,
+    V065,
+    V066,
+    V067,
+    V068,
+    V069,
+    V070,
+    V071,
+    V072,
+    V073,
+    V074,
+    V075,
+    V076,
+    V077,
+    V078,
+    V079,
+    V080,
+    V081,
+    V082,
+    V083,
+    V084,
+    V085,
+    V086,
+    V087,
+    V088,
+    V089,
+    V090,
+    V091,
+    V092,
+    V093,
+    V094,
+    V095,
+    V096,
+    V097,
+    V098,
+    V099,
+    V100,
+    V101,
+    V102,
+    V103,
+    V104,
+    V105,
+    V106,
+    V107,
+    V108,
+    V109,
+    V110,
+    V111,
+    V112,
+    V113,
+    V114,
+    V115,
+    V116,
+    V117,
+    V118,
+    V119,
+    V120,
+    V121,
+    V122,
+    V123,
+    V124,
+    V125,
+    V126,
+    V127,
+    V128,
+    V129,
+    V130,
+    V131,
+    V132,
+    V133,
+    V134,
+    V135,
+    V136,
+    V137,
+    V138,
+    V139,
+    V140,
+    V141,
+    V142,
+    V143,
+    V144,
+    V145,
+    V146,
+    V147,
+    V148,
+    V149,
+    V150,
+    V151,
+    V152,
+    V153,
+    V154,
+    V155,
+    V156,
+    V157,
+    V158,
+    V159,
+    V160,
+    V161,
+    V162,
+    V163,
+    V164,
+    V165,
+    V166,
+    V167,
+    V168,
+    V169,
+    V170,
+    V171,
+    V172,
+    V173,
+    V174,
+    V175,
+    V176,
+    V177,
+    V178,
+    V179,
+    V180,
+    V181,
+    V182,
+    V183,
+    V184,
+    V185,
+    V186,
+    V187,
+    V188,
+    V189,
+    V190,
+    V191,
+    V192,
+    V193,
+    V194,
+    V195,
+    V196,
+    V197,
+    V198,
+    V199,
+    V200,
+}
+
+const _: () = assert!(std::intrinsics::discriminant_value(&Tricky::V100) == 100);
+
+// CHECK-LABEL: define noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @discriminant6(i8 noundef %e)
+// CHECK-NEXT: start:
+// CHECK-NEXT: %[[REL_VAR:.+]] = add i8 %e, -66
+// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp ult i8 %[[REL_VAR]], -56
+// CHECK-NEXT: %[[TAGGED_DISCR:.+]] = add i8 %e, -65
+// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i8 %[[TAGGED_DISCR]], i8 0
+// CHECK-NEXT: ret i8 %[[DISCR]]
+#[no_mangle]
+pub fn discriminant6(e: Tricky) -> u8 {
+    std::intrinsics::discriminant_value(&e) as _
+}
+
+// Case from <https://github.com/rust-lang/rust/issues/104519>,
+// where sign-extension is important.
+
+pub enum OpenResult {
+    Ok(()),
+    Err(()),
+    TransportErr(TransportErr),
+}
+
+#[repr(i32)]
+pub enum TransportErr {
+    UnknownMethod = -2,
+}
+
+#[no_mangle]
+pub fn match7(result: OpenResult) -> u8 {
+    // CHECK-LABEL: define 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
+    // CHECK-NEXT: ret i8 %[[RET]]
+    match result {
+        OpenResult::Ok(()) => 0,
+        _ => 1,
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 120c9fcb86bfde65b562ba4e957ef7003108d6ae Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 11 Jul 2025 19:58:22 +0800
Subject: Disambiguate between rustc vs std having debug assertions

Additionally, `NO_DEBUG_ASSERTIONS` is set by CI that threads through to
the `./configure` script, which is somewhat fragile and "spooky action
at a distance". Instead, use env vars controlled by compiletest, whose
debug assertion info comes from bootstrap.
---
 src/tools/compiletest/src/runtest/run_make.rs | 13 +++++++++++++
 src/tools/run-make-support/src/env.rs         | 15 ++++++++++++---
 2 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/src/tools/compiletest/src/runtest/run_make.rs b/src/tools/compiletest/src/runtest/run_make.rs
index 60e8e16e25e..c8d5190c039 100644
--- a/src/tools/compiletest/src/runtest/run_make.rs
+++ b/src/tools/compiletest/src/runtest/run_make.rs
@@ -225,6 +225,19 @@ impl TestCx<'_> {
             cmd.env("RUNNER", runner);
         }
 
+        // Guard against externally-set env vars.
+        cmd.env_remove("__RUSTC_DEBUG_ASSERTIONS_ENABLED");
+        if self.config.with_rustc_debug_assertions {
+            // Used for `run_make_support::env::rustc_debug_assertions_enabled`.
+            cmd.env("__RUSTC_DEBUG_ASSERTIONS_ENABLED", "1");
+        }
+
+        cmd.env_remove("__STD_DEBUG_ASSERTIONS_ENABLED");
+        if self.config.with_std_debug_assertions {
+            // Used for `run_make_support::env::std_debug_assertions_enabled`.
+            cmd.env("__STD_DEBUG_ASSERTIONS_ENABLED", "1");
+        }
+
         // We don't want RUSTFLAGS set from the outside to interfere with
         // compiler flags set in the test cases:
         cmd.env_remove("RUSTFLAGS");
diff --git a/src/tools/run-make-support/src/env.rs b/src/tools/run-make-support/src/env.rs
index 9acbb16d73e..cf1a6f7351a 100644
--- a/src/tools/run-make-support/src/env.rs
+++ b/src/tools/run-make-support/src/env.rs
@@ -18,11 +18,20 @@ pub fn env_var_os(name: &str) -> OsString {
     }
 }
 
-/// Check if `NO_DEBUG_ASSERTIONS` is set (usually this may be set in CI jobs).
+/// Check if staged `rustc`-under-test was built with debug assertions.
 #[track_caller]
 #[must_use]
-pub fn no_debug_assertions() -> bool {
-    std::env::var_os("NO_DEBUG_ASSERTIONS").is_some()
+pub fn rustc_debug_assertions_enabled() -> bool {
+    // Note: we assume this env var is set when the test recipe is being executed.
+    std::env::var_os("__RUSTC_DEBUG_ASSERTIONS_ENABLED").is_some()
+}
+
+/// Check if staged `std`-under-test was built with debug assertions.
+#[track_caller]
+#[must_use]
+pub fn std_debug_assertions_enabled() -> bool {
+    // Note: we assume this env var is set when the test recipe is being executed.
+    std::env::var_os("__STD_DEBUG_ASSERTIONS_ENABLED").is_some()
 }
 
 /// A wrapper around [`std::env::set_current_dir`] which includes the directory
-- 
cgit 1.4.1-3-g733a5


From 33e69623bae7cee0e1706cc64f81edee8a4283d9 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 11 Jul 2025 20:01:42 +0800
Subject: Fix std debug assertions gate in `fmt-write-boat`

The test itself is still broken, but fix this gating separately first.
---
 tests/run-make/fmt-write-bloat/rmake.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/run-make/fmt-write-bloat/rmake.rs b/tests/run-make/fmt-write-bloat/rmake.rs
index 3348651d501..af6ff6c2983 100644
--- a/tests/run-make/fmt-write-bloat/rmake.rs
+++ b/tests/run-make/fmt-write-bloat/rmake.rs
@@ -18,7 +18,7 @@
 //@ ignore-cross-compile
 
 use run_make_support::artifact_names::bin_name;
-use run_make_support::env::no_debug_assertions;
+use run_make_support::env::std_debug_assertions_enabled;
 use run_make_support::rustc;
 use run_make_support::symbols::any_symbol_contains;
 
@@ -26,7 +26,7 @@ fn main() {
     rustc().input("main.rs").opt().run();
     // panic machinery identifiers, these should not appear in the final binary
     let mut panic_syms = vec!["panic_bounds_check", "Debug"];
-    if no_debug_assertions() {
+    if std_debug_assertions_enabled() {
         // if debug assertions are allowed, we need to allow these,
         // otherwise, add them to the list of symbols to deny.
         panic_syms.extend_from_slice(&["panicking", "panic_fmt", "pad_integral", "Display"]);
-- 
cgit 1.4.1-3-g733a5


From 3fe3edbcdeec70580471ec20b444e2c71a67c58a Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 11 Jul 2025 12:23:56 +0000
Subject: Add --compile-time-deps argument for x check

This reduces the amount of time it takes to do the x check for
rust-analyzer analysis from 12m16s to 3m34s when the bootstrap compiler
is already downloaded.
---
 src/bootstrap/src/core/build_steps/check.rs   | 12 +++++++
 src/bootstrap/src/core/build_steps/compile.rs |  5 +++
 src/bootstrap/src/core/build_steps/setup.rs   |  4 +++
 src/bootstrap/src/core/config/config.rs       | 10 ++++++
 src/bootstrap/src/core/config/flags.rs        |  3 ++
 src/etc/completions/x.fish                    | 25 ++++++++++++++-
 src/etc/completions/x.ps1                     | 23 ++++++++++++++
 src/etc/completions/x.py.fish                 | 25 ++++++++++++++-
 src/etc/completions/x.py.ps1                  | 23 ++++++++++++++
 src/etc/completions/x.py.sh                   | 46 +++++++++++++--------------
 src/etc/completions/x.py.zsh                  | 23 ++++++++++++++
 src/etc/completions/x.sh                      | 46 +++++++++++++--------------
 src/etc/completions/x.zsh                     | 23 ++++++++++++++
 src/etc/rust_analyzer_eglot.el                |  3 +-
 src/etc/rust_analyzer_helix.toml              |  1 +
 src/etc/rust_analyzer_settings.json           |  3 +-
 src/etc/rust_analyzer_zed.json                |  2 +-
 17 files changed, 226 insertions(+), 51 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 0cc4628310a..3278b55305c 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -54,6 +54,11 @@ impl Step for Std {
             return;
         }
 
+        if run.builder.config.compile_time_deps {
+            // libstd doesn't have any important build scripts and can't have any proc macros
+            return;
+        }
+
         let crates = std_crates_for_run_make(&run);
         run.builder.ensure(Std {
             build_compiler: prepare_compiler_for_check(run.builder, run.target, Mode::Std),
@@ -250,6 +255,13 @@ fn prepare_compiler_for_check(
     match mode {
         Mode::ToolBootstrap => builder.compiler(0, host),
         Mode::ToolStd => {
+            if builder.config.compile_time_deps {
+                // When --compile-time-deps is passed, we can't use any rustc
+                // other than the bootstrap compiler. Luckily build scripts and
+                // proc macros for tools are unlikely to need nightly.
+                return builder.compiler(0, host);
+            }
+
             // These tools require the local standard library to be checked
             let build_compiler = builder.compiler(builder.top_stage, host);
 
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 1282a89a5e4..6fb7b7e71e9 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -2542,6 +2542,11 @@ pub fn stream_cargo(
     }
     cmd.arg("--message-format").arg(message_format);
 
+    if builder.config.compile_time_deps {
+        cmd.arg("-Zunstable-options");
+        cmd.arg("--compile-time-deps");
+    }
+
     for arg in tail_args {
         cmd.arg(arg);
     }
diff --git a/src/bootstrap/src/core/build_steps/setup.rs b/src/bootstrap/src/core/build_steps/setup.rs
index 37fc85518e0..9f9af1d9abe 100644
--- a/src/bootstrap/src/core/build_steps/setup.rs
+++ b/src/bootstrap/src/core/build_steps/setup.rs
@@ -586,12 +586,14 @@ Select which editor you would like to set up [default: None]: ";
                 "b5dd299b93dca3ceeb9b335f929293cb3d4bf4977866fbe7ceeac2a8a9f99088",
                 "631c837b0e98ae35fd48b0e5f743b1ca60adadf2d0a2b23566ba25df372cf1a9",
                 "080955765db84bb6cbf178879f489c4e2369397626a6ecb3debedb94a9d0b3ce",
+                "f501475c6654187091c924ae26187fa5791d74d4a8ab3fb61fbbe4c0275aade1",
             ],
             EditorKind::Helix => &[
                 "2d3069b8cf1b977e5d4023965eb6199597755e6c96c185ed5f2854f98b83d233",
                 "6736d61409fbebba0933afd2e4c44ff2f97c1cb36cf0299a7f4a7819b8775040",
                 "f252dcc30ca85a193a699581e5e929d5bd6c19d40d7a7ade5e257a9517a124a5",
                 "198c195ed0c070d15907b279b8b4ea96198ca71b939f5376454f3d636ab54da5",
+                "1c43ead340b20792b91d02b08494ee68708e7e09f56b6766629b4b72079208f1",
             ],
             EditorKind::Vim | EditorKind::VsCode => &[
                 "ea67e259dedf60d4429b6c349a564ffcd1563cf41c920a856d1f5b16b4701ac8",
@@ -607,12 +609,14 @@ Select which editor you would like to set up [default: None]: ";
                 "e53e9129ca5ee5dcbd6ec8b68c2d87376474eb154992deba3c6d9ab1703e0717",
                 "f954316090936c7e590c253ca9d524008375882fa13c5b41d7e2547a896ff893",
                 "701b73751efd7abd6487f2c79348dab698af7ac4427b79fa3d2087c867144b12",
+                "a61df796c0c007cb6512127330564e49e57d558dec715703916a928b072a1054",
             ],
             EditorKind::Zed => &[
                 "bbce727c269d1bd0c98afef4d612eb4ce27aea3c3a8968c5f10b31affbc40b6c",
                 "a5380cf5dd9328731aecc5dfb240d16dac46ed272126b9728006151ef42f5909",
                 "2e96bf0d443852b12f016c8fc9840ab3d0a2b4fe0b0fb3a157e8d74d5e7e0e26",
                 "4fadd4c87389a601a27db0d3d74a142fa3a2e656ae78982e934dbe24bee32ad6",
+                "f0bb3d23ab1a49175ab0ef5c4071af95bb03d01d460776cdb716d91333443382",
             ],
         }
     }
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 59693dc3e4c..0039d44785c 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -110,6 +110,7 @@ pub struct Config {
     pub include_default_paths: bool,
     pub rustc_error_format: Option<String>,
     pub json_output: bool,
+    pub compile_time_deps: bool,
     pub test_compare_mode: bool,
     pub color: Color,
     pub patch_binaries_for_nix: Option<bool>,
@@ -421,6 +422,7 @@ impl Config {
             jobs: flags_jobs,
             warnings: flags_warnings,
             json_output: flags_json_output,
+            compile_time_deps: flags_compile_time_deps,
             color: flags_color,
             bypass_bootstrap_lock: flags_bypass_bootstrap_lock,
             rust_profile_generate: flags_rust_profile_generate,
@@ -468,6 +470,7 @@ impl Config {
         config.include_default_paths = flags_include_default_paths;
         config.rustc_error_format = flags_rustc_error_format;
         config.json_output = flags_json_output;
+        config.compile_time_deps = flags_compile_time_deps;
         config.on_fail = flags_on_fail;
         config.cmd = flags_cmd;
         config.incremental = flags_incremental;
@@ -1064,6 +1067,13 @@ impl Config {
             _ => {}
         }
 
+        if config.compile_time_deps && !matches!(config.cmd, Subcommand::Check { .. }) {
+            eprintln!(
+                "WARNING: Can't use --compile-time-deps with any subcommand other than check."
+            );
+            exit!(1);
+        }
+
         // CI should always run stage 2 builds, unless it specifically states otherwise
         #[cfg(not(test))]
         if flags_stage.is_none() && config.is_running_on_ci {
diff --git a/src/bootstrap/src/core/config/flags.rs b/src/bootstrap/src/core/config/flags.rs
index 19e0d3413bb..4ac58a06c32 100644
--- a/src/bootstrap/src/core/config/flags.rs
+++ b/src/bootstrap/src/core/config/flags.rs
@@ -132,6 +132,9 @@ pub struct Flags {
     #[arg(global = true, long)]
     /// use message-format=json
     pub json_output: bool,
+    #[arg(global = true, long)]
+    /// use --compile-time-deps
+    pub compile_time_deps: bool,
 
     #[arg(global = true, long, value_name = "STYLE")]
     #[arg(value_enum, default_value_t = Color::Auto)]
diff --git a/src/etc/completions/x.fish b/src/etc/completions/x.fish
index 3009dd85e93..b58f8aaa2b8 100644
--- a/src/etc/completions/x.fish
+++ b/src/etc/completions/x.fish
@@ -1,6 +1,6 @@
 # Print an optspec for argparse to handle cmd's options that are independent of any subcommand.
 function __fish_x_global_optspecs
-	string join \n v/verbose i/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= j/jobs= warnings= json-output 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 h/help
+	string join \n v/verbose i/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= j/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 h/help
 end
 
 function __fish_x_needs_command
@@ -52,6 +52,7 @@ complete -c x -n "__fish_x_needs_command" -l include-default-paths -d 'include d
 complete -c x -n "__fish_x_needs_command" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_needs_command" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_needs_command" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_needs_command" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_needs_command" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_needs_command" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_needs_command" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -103,6 +104,7 @@ complete -c x -n "__fish_x_using_subcommand build" -l include-default-paths -d '
 complete -c x -n "__fish_x_using_subcommand build" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand build" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand build" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand build" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand build" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand build" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand build" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -138,6 +140,7 @@ complete -c x -n "__fish_x_using_subcommand check" -l include-default-paths -d '
 complete -c x -n "__fish_x_using_subcommand check" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand check" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand check" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand check" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand check" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand check" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand check" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -179,6 +182,7 @@ complete -c x -n "__fish_x_using_subcommand clippy" -l include-default-paths -d
 complete -c x -n "__fish_x_using_subcommand clippy" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand clippy" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand clippy" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand clippy" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand clippy" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand clippy" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand clippy" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -213,6 +217,7 @@ complete -c x -n "__fish_x_using_subcommand fix" -l include-default-paths -d 'in
 complete -c x -n "__fish_x_using_subcommand fix" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand fix" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand fix" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand fix" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand fix" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand fix" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand fix" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -249,6 +254,7 @@ complete -c x -n "__fish_x_using_subcommand fmt" -l include-default-paths -d 'in
 complete -c x -n "__fish_x_using_subcommand fmt" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand fmt" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand fmt" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand fmt" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand fmt" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand fmt" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand fmt" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -285,6 +291,7 @@ complete -c x -n "__fish_x_using_subcommand doc" -l include-default-paths -d 'in
 complete -c x -n "__fish_x_using_subcommand doc" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand doc" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand doc" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand doc" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand doc" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand doc" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand doc" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -333,6 +340,7 @@ complete -c x -n "__fish_x_using_subcommand test" -l include-default-paths -d 'i
 complete -c x -n "__fish_x_using_subcommand test" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand test" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand test" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand test" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand test" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand test" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand test" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -371,6 +379,7 @@ complete -c x -n "__fish_x_using_subcommand miri" -l include-default-paths -d 'i
 complete -c x -n "__fish_x_using_subcommand miri" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand miri" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand miri" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand miri" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand miri" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand miri" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand miri" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -406,6 +415,7 @@ complete -c x -n "__fish_x_using_subcommand bench" -l include-default-paths -d '
 complete -c x -n "__fish_x_using_subcommand bench" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand bench" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand bench" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand bench" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand bench" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand bench" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand bench" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -441,6 +451,7 @@ complete -c x -n "__fish_x_using_subcommand clean" -l include-default-paths -d '
 complete -c x -n "__fish_x_using_subcommand clean" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand clean" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand clean" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand clean" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand clean" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand clean" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand clean" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -475,6 +486,7 @@ complete -c x -n "__fish_x_using_subcommand dist" -l include-default-paths -d 'i
 complete -c x -n "__fish_x_using_subcommand dist" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand dist" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand dist" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand dist" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand dist" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand dist" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand dist" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -509,6 +521,7 @@ complete -c x -n "__fish_x_using_subcommand install" -l include-default-paths -d
 complete -c x -n "__fish_x_using_subcommand install" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand install" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand install" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand install" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand install" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand install" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand install" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -544,6 +557,7 @@ complete -c x -n "__fish_x_using_subcommand run" -l include-default-paths -d 'in
 complete -c x -n "__fish_x_using_subcommand run" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand run" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand run" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand run" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand run" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand run" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand run" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -578,6 +592,7 @@ complete -c x -n "__fish_x_using_subcommand setup" -l include-default-paths -d '
 complete -c x -n "__fish_x_using_subcommand setup" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand setup" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand setup" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand setup" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand setup" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand setup" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand setup" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -613,6 +628,7 @@ complete -c x -n "__fish_x_using_subcommand suggest" -l include-default-paths -d
 complete -c x -n "__fish_x_using_subcommand suggest" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand suggest" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand suggest" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand suggest" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand suggest" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand suggest" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand suggest" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -649,6 +665,7 @@ complete -c x -n "__fish_x_using_subcommand vendor" -l include-default-paths -d
 complete -c x -n "__fish_x_using_subcommand vendor" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand vendor" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand vendor" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand vendor" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand vendor" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand vendor" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand vendor" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -683,6 +700,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -725,6 +743,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_fro
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -762,6 +781,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_fro
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -799,6 +819,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_fro
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -836,6 +857,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_fro
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -870,6 +892,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_fro
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l json-output -d 'use message-format=json'
+complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l enable-bolt-settings -d 'Enable BOLT link flags'
diff --git a/src/etc/completions/x.ps1 b/src/etc/completions/x.ps1
index 8002ec31592..0f61801277c 100644
--- a/src/etc/completions/x.ps1
+++ b/src/etc/completions/x.ps1
@@ -52,6 +52,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -110,6 +111,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -152,6 +154,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -200,6 +203,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -241,6 +245,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -284,6 +289,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -327,6 +333,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -382,6 +389,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -427,6 +435,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -469,6 +478,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -511,6 +521,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -552,6 +563,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -593,6 +605,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -635,6 +648,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -676,6 +690,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -718,6 +733,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -761,6 +777,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -802,6 +819,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -851,6 +869,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -895,6 +914,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -939,6 +959,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -983,6 +1004,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -1024,6 +1046,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
diff --git a/src/etc/completions/x.py.fish b/src/etc/completions/x.py.fish
index 4766a5ee0c7..126bbe154f0 100644
--- a/src/etc/completions/x.py.fish
+++ b/src/etc/completions/x.py.fish
@@ -1,6 +1,6 @@
 # Print an optspec for argparse to handle cmd's options that are independent of any subcommand.
 function __fish_x.py_global_optspecs
-	string join \n v/verbose i/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= j/jobs= warnings= json-output 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 h/help
+	string join \n v/verbose i/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= j/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 h/help
 end
 
 function __fish_x.py_needs_command
@@ -52,6 +52,7 @@ complete -c x.py -n "__fish_x.py_needs_command" -l include-default-paths -d 'inc
 complete -c x.py -n "__fish_x.py_needs_command" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_needs_command" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_needs_command" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_needs_command" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_needs_command" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_needs_command" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_needs_command" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -103,6 +104,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand build" -l include-default-path
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -138,6 +140,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand check" -l include-default-path
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -179,6 +182,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l include-default-pat
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -213,6 +217,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand fix" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -249,6 +254,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -285,6 +291,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand doc" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -333,6 +340,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand test" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -371,6 +379,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand miri" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -406,6 +415,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand bench" -l include-default-path
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -441,6 +451,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand clean" -l include-default-path
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -475,6 +486,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand dist" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -509,6 +521,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand install" -l include-default-pa
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -544,6 +557,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand run" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -578,6 +592,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand setup" -l include-default-path
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -613,6 +628,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l include-default-pa
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -649,6 +665,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l include-default-pat
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -683,6 +700,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subc
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -725,6 +743,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcomma
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -762,6 +781,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcomma
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -799,6 +819,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcomma
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -836,6 +857,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcomma
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -870,6 +892,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcomma
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l compile-time-deps -d 'use --compile-time-deps'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l enable-bolt-settings -d 'Enable BOLT link flags'
diff --git a/src/etc/completions/x.py.ps1 b/src/etc/completions/x.py.ps1
index 1aff3c433b4..6302265f60f 100644
--- a/src/etc/completions/x.py.ps1
+++ b/src/etc/completions/x.py.ps1
@@ -52,6 +52,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -110,6 +111,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -152,6 +154,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -200,6 +203,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -241,6 +245,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -284,6 +289,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -327,6 +333,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -382,6 +389,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -427,6 +435,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -469,6 +478,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -511,6 +521,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -552,6 +563,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -593,6 +605,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -635,6 +648,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -676,6 +690,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -718,6 +733,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -761,6 +777,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -802,6 +819,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -851,6 +869,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -895,6 +914,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -939,6 +959,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -983,6 +1004,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -1024,6 +1046,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
diff --git a/src/etc/completions/x.py.sh b/src/etc/completions/x.py.sh
index fe4ed5c915f..8f13de282fb 100644
--- a/src/etc/completions/x.py.sh
+++ b/src/etc/completions/x.py.sh
@@ -85,7 +85,7 @@ _x.py() {
 
     case "${cmd}" in
         x.py)
-            opts="-v -i -j -h --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 --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]... build check clippy fix fmt doc test miri bench clean dist install run setup suggest vendor perf"
+            opts="-v -i -j -h --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]... build check clippy fix fmt doc test miri bench clean dist install run setup suggest vendor perf"
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -271,7 +271,7 @@ _x.py() {
             return 0
             ;;
         x.py__bench)
-            opts="-v -i -j -h --test-args --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 --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 --test-args --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
@@ -461,7 +461,7 @@ _x.py() {
             return 0
             ;;
         x.py__build)
-            opts="-v -i -j -h --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 --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 --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
@@ -647,7 +647,7 @@ _x.py() {
             return 0
             ;;
         x.py__check)
-            opts="-v -i -j -h --all-targets --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 --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 --all-targets --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
@@ -833,7 +833,7 @@ _x.py() {
             return 0
             ;;
         x.py__clean)
-            opts="-v -i -j -h --all --stage --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --keep-stage --keep-stage-std --src --jobs --warnings --json-output --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 --all --stage --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --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
@@ -1016,7 +1016,7 @@ _x.py() {
             return 0
             ;;
         x.py__clippy)
-            opts="-A -D -W -F -v -i -j -h --fix --allow-dirty --allow-staged --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 --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="-A -D -W -F -v -i -j -h --fix --allow-dirty --allow-staged --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
@@ -1218,7 +1218,7 @@ _x.py() {
             return 0
             ;;
         x.py__dist)
-            opts="-v -i -j -h --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 --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 --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
@@ -1404,7 +1404,7 @@ _x.py() {
             return 0
             ;;
         x.py__doc)
-            opts="-v -i -j -h --open --json --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 --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 --open --json --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
@@ -1590,7 +1590,7 @@ _x.py() {
             return 0
             ;;
         x.py__fix)
-            opts="-v -i -j -h --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 --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 --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
@@ -1776,7 +1776,7 @@ _x.py() {
             return 0
             ;;
         x.py__fmt)
-            opts="-v -i -j -h --check --all --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 --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 --check --all --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
@@ -1962,7 +1962,7 @@ _x.py() {
             return 0
             ;;
         x.py__install)
-            opts="-v -i -j -h --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 --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 --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
@@ -2148,7 +2148,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 --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 --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]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -2338,7 +2338,7 @@ _x.py() {
             return 0
             ;;
         x.py__perf)
-            opts="-v -i -j -h --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 --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]... eprintln samply cachegrind benchmark compare"
+            opts="-v -i -j -h --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]... eprintln samply cachegrind benchmark compare"
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -2524,7 +2524,7 @@ _x.py() {
             return 0
             ;;
         x.py__perf__benchmark)
-            opts="-v -i -j -h --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 --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 <benchmark-id> [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 <benchmark-id> [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -2722,7 +2722,7 @@ _x.py() {
             return 0
             ;;
         x.py__perf__cachegrind)
-            opts="-v -i -j -h --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 --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 --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 3 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -2920,7 +2920,7 @@ _x.py() {
             return 0
             ;;
         x.py__perf__compare)
-            opts="-v -i -j -h --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 --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 <BASE> <MODIFIED> [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --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 <BASE> <MODIFIED> [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3106,7 +3106,7 @@ _x.py() {
             return 0
             ;;
         x.py__perf__eprintln)
-            opts="-v -i -j -h --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 --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 --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 3 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3304,7 +3304,7 @@ _x.py() {
             return 0
             ;;
         x.py__perf__samply)
-            opts="-v -i -j -h --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 --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 --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 3 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3502,7 +3502,7 @@ _x.py() {
             return 0
             ;;
         x.py__run)
-            opts="-v -i -j -h --args --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 --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 --args --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
@@ -3692,7 +3692,7 @@ _x.py() {
             return 0
             ;;
         x.py__setup)
-            opts="-v -i -j -h --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 --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 [<PROFILE>|hook|editor|link] [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --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 [<PROFILE>|hook|editor|link] [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3878,7 +3878,7 @@ _x.py() {
             return 0
             ;;
         x.py__suggest)
-            opts="-v -i -j -h --run --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 --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 --run --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
@@ -4064,7 +4064,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 --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 --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 --no-doc --doc --bless --extra-checks --force-rerun --only-modified --compare-mode --pass --run --rustfix-coverage --no-capture --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
@@ -4274,7 +4274,7 @@ _x.py() {
             return 0
             ;;
         x.py__vendor)
-            opts="-v -i -j -h --sync --versioned-dirs --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 --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 --sync --versioned-dirs --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 77f995c1704..ef9dac5ef45 100644
--- a/src/etc/completions/x.py.zsh
+++ b/src/etc/completions/x.py.zsh
@@ -46,6 +46,7 @@ _x.py() {
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -97,6 +98,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -141,6 +143,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -191,6 +194,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -234,6 +238,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -279,6 +284,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -324,6 +330,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -381,6 +388,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -428,6 +436,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -472,6 +481,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -516,6 +526,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -559,6 +570,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -602,6 +614,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -646,6 +659,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -689,6 +703,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -734,6 +749,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -779,6 +795,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -822,6 +839,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -877,6 +895,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -923,6 +942,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -969,6 +989,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -1015,6 +1036,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -1059,6 +1081,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
diff --git a/src/etc/completions/x.sh b/src/etc/completions/x.sh
index 105fc668e8e..f6ecf4cebf4 100644
--- a/src/etc/completions/x.sh
+++ b/src/etc/completions/x.sh
@@ -85,7 +85,7 @@ _x() {
 
     case "${cmd}" in
         x)
-            opts="-v -i -j -h --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 --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]... build check clippy fix fmt doc test miri bench clean dist install run setup suggest vendor perf"
+            opts="-v -i -j -h --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]... build check clippy fix fmt doc test miri bench clean dist install run setup suggest vendor perf"
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -271,7 +271,7 @@ _x() {
             return 0
             ;;
         x__bench)
-            opts="-v -i -j -h --test-args --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 --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 --test-args --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
@@ -461,7 +461,7 @@ _x() {
             return 0
             ;;
         x__build)
-            opts="-v -i -j -h --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 --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 --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
@@ -647,7 +647,7 @@ _x() {
             return 0
             ;;
         x__check)
-            opts="-v -i -j -h --all-targets --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 --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 --all-targets --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
@@ -833,7 +833,7 @@ _x() {
             return 0
             ;;
         x__clean)
-            opts="-v -i -j -h --all --stage --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --keep-stage --keep-stage-std --src --jobs --warnings --json-output --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 --all --stage --verbose --incremental --config --build-dir --build --host --target --exclude --skip --include-default-paths --rustc-error-format --on-fail --dry-run --dump-bootstrap-shims --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
@@ -1016,7 +1016,7 @@ _x() {
             return 0
             ;;
         x__clippy)
-            opts="-A -D -W -F -v -i -j -h --fix --allow-dirty --allow-staged --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 --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="-A -D -W -F -v -i -j -h --fix --allow-dirty --allow-staged --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
@@ -1218,7 +1218,7 @@ _x() {
             return 0
             ;;
         x__dist)
-            opts="-v -i -j -h --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 --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 --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
@@ -1404,7 +1404,7 @@ _x() {
             return 0
             ;;
         x__doc)
-            opts="-v -i -j -h --open --json --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 --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 --open --json --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
@@ -1590,7 +1590,7 @@ _x() {
             return 0
             ;;
         x__fix)
-            opts="-v -i -j -h --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 --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 --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
@@ -1776,7 +1776,7 @@ _x() {
             return 0
             ;;
         x__fmt)
-            opts="-v -i -j -h --check --all --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 --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 --check --all --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
@@ -1962,7 +1962,7 @@ _x() {
             return 0
             ;;
         x__install)
-            opts="-v -i -j -h --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 --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 --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
@@ -2148,7 +2148,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 --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 --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]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -2338,7 +2338,7 @@ _x() {
             return 0
             ;;
         x__perf)
-            opts="-v -i -j -h --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 --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]... eprintln samply cachegrind benchmark compare"
+            opts="-v -i -j -h --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]... eprintln samply cachegrind benchmark compare"
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -2524,7 +2524,7 @@ _x() {
             return 0
             ;;
         x__perf__benchmark)
-            opts="-v -i -j -h --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 --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 <benchmark-id> [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 <benchmark-id> [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -2722,7 +2722,7 @@ _x() {
             return 0
             ;;
         x__perf__cachegrind)
-            opts="-v -i -j -h --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 --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 --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 3 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -2920,7 +2920,7 @@ _x() {
             return 0
             ;;
         x__perf__compare)
-            opts="-v -i -j -h --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 --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 <BASE> <MODIFIED> [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --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 <BASE> <MODIFIED> [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3106,7 +3106,7 @@ _x() {
             return 0
             ;;
         x__perf__eprintln)
-            opts="-v -i -j -h --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 --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 --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 3 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3304,7 +3304,7 @@ _x() {
             return 0
             ;;
         x__perf__samply)
-            opts="-v -i -j -h --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 --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 --include --exclude --scenarios --profiles --verbose --incremental --config --build-dir --build --host --target --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 3 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3502,7 +3502,7 @@ _x() {
             return 0
             ;;
         x__run)
-            opts="-v -i -j -h --args --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 --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 --args --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
@@ -3692,7 +3692,7 @@ _x() {
             return 0
             ;;
         x__setup)
-            opts="-v -i -j -h --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 --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 [<PROFILE>|hook|editor|link] [PATHS]... [ARGS]..."
+            opts="-v -i -j -h --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 [<PROFILE>|hook|editor|link] [PATHS]... [ARGS]..."
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3878,7 +3878,7 @@ _x() {
             return 0
             ;;
         x__suggest)
-            opts="-v -i -j -h --run --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 --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 --run --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
@@ -4064,7 +4064,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 --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 --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 --no-doc --doc --bless --extra-checks --force-rerun --only-modified --compare-mode --pass --run --rustfix-coverage --no-capture --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
@@ -4274,7 +4274,7 @@ _x() {
             return 0
             ;;
         x__vendor)
-            opts="-v -i -j -h --sync --versioned-dirs --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 --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 --sync --versioned-dirs --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 6c6d7b3f49f..c12e6f3ebae 100644
--- a/src/etc/completions/x.zsh
+++ b/src/etc/completions/x.zsh
@@ -46,6 +46,7 @@ _x() {
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -97,6 +98,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -141,6 +143,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -191,6 +194,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -234,6 +238,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -279,6 +284,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -324,6 +330,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -381,6 +388,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -428,6 +436,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -472,6 +481,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -516,6 +526,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -559,6 +570,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -602,6 +614,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -646,6 +659,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -689,6 +703,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -734,6 +749,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -779,6 +795,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -822,6 +839,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -877,6 +895,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -923,6 +942,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -969,6 +989,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -1015,6 +1036,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -1059,6 +1081,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
+'--compile-time-deps[use --compile-time-deps]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
diff --git a/src/etc/rust_analyzer_eglot.el b/src/etc/rust_analyzer_eglot.el
index 3cb229cd98c..3151cb1a6e7 100644
--- a/src/etc/rust_analyzer_eglot.el
+++ b/src/etc/rust_analyzer_eglot.el
@@ -23,7 +23,8 @@
                                                   :overrideCommand ["python3"
                                                                     "x.py"
                                                                     "check"
-                                                                    "--json-output"])
+                                                                    "--json-output"
+                                                                    "--compile-time-deps"])]
                                         :sysrootSrc "./library"
                                         :extraEnv (:RUSTC_BOOTSTRAP "1"))
                  :rustc ( :source "./Cargo.toml" )))))))
diff --git a/src/etc/rust_analyzer_helix.toml b/src/etc/rust_analyzer_helix.toml
index 1a6a14991ec..8c1782a1abc 100644
--- a/src/etc/rust_analyzer_helix.toml
+++ b/src/etc/rust_analyzer_helix.toml
@@ -59,4 +59,5 @@ overrideCommand = [
     "--json-output",
     "--build-dir",
     "build/rust-analyzer",
+    "--compile-time-deps"
 ]
diff --git a/src/etc/rust_analyzer_settings.json b/src/etc/rust_analyzer_settings.json
index a960cc01732..b31169857c5 100644
--- a/src/etc/rust_analyzer_settings.json
+++ b/src/etc/rust_analyzer_settings.json
@@ -27,7 +27,8 @@
         "python3",
         "x.py",
         "check",
-        "--json-output"
+        "--json-output",
+        "--compile-time-deps"
     ],
     "rust-analyzer.cargo.sysrootSrc": "./library",
     "rust-analyzer.rustc.source": "./Cargo.toml",
diff --git a/src/etc/rust_analyzer_zed.json b/src/etc/rust_analyzer_zed.json
index 27fc524e9b5..7eace92500e 100644
--- a/src/etc/rust_analyzer_zed.json
+++ b/src/etc/rust_analyzer_zed.json
@@ -7,7 +7,7 @@
             "enable": true,
             "invocationLocation": "root",
             "invocationStrategy": "once",
-            "overrideCommand": ["python3", "x.py", "check", "--json-output"]
+            "overrideCommand": ["python3", "x.py", "check", "--json-output", "--compile-time-deps"]
           },
           "extraEnv": {
             "RUSTC_BOOTSTRAP": "1"
-- 
cgit 1.4.1-3-g733a5


From 34426dce3d05e2e5c8c7116809291403ba4cbc00 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Fri, 11 Jul 2025 15:04:13 +0200
Subject: Fix fallback for CI_JOB_NAME

If CI_JOB_NAME is not specified, it's supposed to fall back to
the image name, which is `$image`, not `$IMAGE`.

Failing to set the correct CI_JOB_NAME causes failures when running
`dist-ohos-*` images locally.
---
 src/ci/docker/run.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ci/docker/run.sh b/src/ci/docker/run.sh
index 4e69fb2f370..da7d084d48d 100755
--- a/src/ci/docker/run.sh
+++ b/src/ci/docker/run.sh
@@ -361,7 +361,7 @@ docker \
   --env TOOLSTATE_REPO \
   --env TOOLSTATE_PUBLISH \
   --env RUST_CI_OVERRIDE_RELEASE_CHANNEL \
-  --env CI_JOB_NAME="${CI_JOB_NAME-$IMAGE}" \
+  --env CI_JOB_NAME="${CI_JOB_NAME-$image}" \
   --env CI_JOB_DOC_URL="${CI_JOB_DOC_URL}" \
   --env BASE_COMMIT="$BASE_COMMIT" \
   --env DIST_TRY_BUILD \
-- 
cgit 1.4.1-3-g733a5


From 87958ad68314daa784e93db4462afc0c079bd3a8 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 11 Jul 2025 13:32:03 +0000
Subject: Avoid building C++ for rustc_llvm with --compile-time-deps

This saves about 30s.
---
 compiler/rustc/Cargo.toml              | 1 +
 compiler/rustc_codegen_llvm/Cargo.toml | 3 +++
 compiler/rustc_driver_impl/Cargo.toml  | 1 +
 compiler/rustc_interface/Cargo.toml    | 1 +
 compiler/rustc_llvm/Cargo.toml         | 4 ++++
 compiler/rustc_llvm/build.rs           | 4 ++++
 src/bootstrap/src/lib.rs               | 3 +++
 7 files changed, 17 insertions(+)

diff --git a/compiler/rustc/Cargo.toml b/compiler/rustc/Cargo.toml
index f4caa3ef769..99414d6264e 100644
--- a/compiler/rustc/Cargo.toml
+++ b/compiler/rustc/Cargo.toml
@@ -27,6 +27,7 @@ features = ['unprefixed_malloc_on_supported_platforms']
 
 [features]
 # tidy-alphabetical-start
+check_only = ['rustc_driver_impl/check_only']
 jemalloc = ['dep:tikv-jemalloc-sys']
 llvm = ['rustc_driver_impl/llvm']
 max_level_info = ['rustc_driver_impl/max_level_info']
diff --git a/compiler/rustc_codegen_llvm/Cargo.toml b/compiler/rustc_codegen_llvm/Cargo.toml
index 88efc8ac96b..5ab22f8fc4d 100644
--- a/compiler/rustc_codegen_llvm/Cargo.toml
+++ b/compiler/rustc_codegen_llvm/Cargo.toml
@@ -43,3 +43,6 @@ serde_json = "1"
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 tracing = "0.1"
 # tidy-alphabetical-end
+
+[features]
+check_only = ["rustc_llvm/check_only"]
diff --git a/compiler/rustc_driver_impl/Cargo.toml b/compiler/rustc_driver_impl/Cargo.toml
index 1971d06aad6..ce26aa449d9 100644
--- a/compiler/rustc_driver_impl/Cargo.toml
+++ b/compiler/rustc_driver_impl/Cargo.toml
@@ -72,6 +72,7 @@ ctrlc = "3.4.4"
 
 [features]
 # tidy-alphabetical-start
+check_only = ['rustc_interface/check_only']
 llvm = ['rustc_interface/llvm']
 max_level_info = ['rustc_log/max_level_info']
 rustc_randomized_layouts = [
diff --git a/compiler/rustc_interface/Cargo.toml b/compiler/rustc_interface/Cargo.toml
index a72a7958787..473ac5e0cea 100644
--- a/compiler/rustc_interface/Cargo.toml
+++ b/compiler/rustc_interface/Cargo.toml
@@ -56,5 +56,6 @@ rustc_abi = { path = "../rustc_abi" }
 
 [features]
 # tidy-alphabetical-start
+check_only = ['rustc_codegen_llvm?/check_only']
 llvm = ['dep:rustc_codegen_llvm']
 # tidy-alphabetical-end
diff --git a/compiler/rustc_llvm/Cargo.toml b/compiler/rustc_llvm/Cargo.toml
index 061562b2ec5..39de4783238 100644
--- a/compiler/rustc_llvm/Cargo.toml
+++ b/compiler/rustc_llvm/Cargo.toml
@@ -14,3 +14,7 @@ libc = "0.2.73"
 # pinned `cc` in `rustc_codegen_ssa` if you update `cc` here.
 cc = "=1.2.16"
 # tidy-alphabetical-end
+
+[features]
+# Used by ./x.py check --compile-time-deps to skip building C++ code
+check_only = []
diff --git a/compiler/rustc_llvm/build.rs b/compiler/rustc_llvm/build.rs
index 9a6549379d3..069b684ad09 100644
--- a/compiler/rustc_llvm/build.rs
+++ b/compiler/rustc_llvm/build.rs
@@ -106,6 +106,10 @@ fn output(cmd: &mut Command) -> String {
 }
 
 fn main() {
+    if cfg!(feature = "check_only") {
+        return;
+    }
+
     for component in REQUIRED_COMPONENTS.iter().chain(OPTIONAL_COMPONENTS.iter()) {
         println!("cargo:rustc-check-cfg=cfg(llvm_component,values(\"{component}\"))");
     }
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index d9a4da8f3cc..bf7369525a4 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -775,6 +775,9 @@ impl Build {
         if self.config.rust_randomize_layout && check("rustc_randomized_layouts") {
             features.push("rustc_randomized_layouts");
         }
+        if self.config.compile_time_deps && kind == Kind::Check {
+            features.push("check_only");
+        }
 
         // 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
-- 
cgit 1.4.1-3-g733a5


From 1a28fb8b7b06b25834ef8fb4295cdd2ade1f6da7 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 11 Jul 2025 15:51:42 +0200
Subject: Update sysinfo version to `0.36.0`

---
 Cargo.lock                    | 4 ++--
 src/bootstrap/Cargo.lock      | 8 ++++----
 src/bootstrap/Cargo.toml      | 2 +-
 src/tools/opt-dist/Cargo.toml | 2 +-
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 271a2f7962c..65718ce4433 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5230,9 +5230,9 @@ dependencies = [
 
 [[package]]
 name = "sysinfo"
-version = "0.35.2"
+version = "0.36.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c3ffa3e4ff2b324a57f7aeb3c349656c7b127c3c189520251a648102a92496e"
+checksum = "aab138f5c1bb35231de19049060a87977ad23e04f2303e953bc5c2947ac7dec4"
 dependencies = [
  "libc",
  "objc2-core-foundation",
diff --git a/src/bootstrap/Cargo.lock b/src/bootstrap/Cargo.lock
index 2434a278d55..e091c94eb53 100644
--- a/src/bootstrap/Cargo.lock
+++ b/src/bootstrap/Cargo.lock
@@ -386,9 +386,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.172"
+version = "0.2.174"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
 
 [[package]]
 name = "libredox"
@@ -730,9 +730,9 @@ dependencies = [
 
 [[package]]
 name = "sysinfo"
-version = "0.35.0"
+version = "0.36.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b897c8ea620e181c7955369a31be5f48d9a9121cb59fd33ecef9ff2a34323422"
+checksum = "aab138f5c1bb35231de19049060a87977ad23e04f2303e953bc5c2947ac7dec4"
 dependencies = [
  "libc",
  "memchr",
diff --git a/src/bootstrap/Cargo.toml b/src/bootstrap/Cargo.toml
index 073cebdcae2..8dc41d1dec6 100644
--- a/src/bootstrap/Cargo.toml
+++ b/src/bootstrap/Cargo.toml
@@ -58,7 +58,7 @@ walkdir = "2.4"
 xz2 = "0.1"
 
 # Dependencies needed by the build-metrics feature
-sysinfo = { version = "0.35.0", default-features = false, optional = true, features = ["system"] }
+sysinfo = { version = "0.36.0", default-features = false, optional = true, features = ["system"] }
 
 # Dependencies needed by the `tracing` feature
 tracing = { version = "0.1", optional = true, features = ["attributes"] }
diff --git a/src/tools/opt-dist/Cargo.toml b/src/tools/opt-dist/Cargo.toml
index dfa884bc3f7..2ed3fbac709 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.35.0", default-features = false, features = ["disk"] }
+sysinfo = { version = "0.36.0", default-features = false, features = ["disk"] }
 fs_extra = "1"
 camino = "1"
 tar = "0.4"
-- 
cgit 1.4.1-3-g733a5


From ae1075b9eeffade3064809adb02ad5bafc13fd46 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Fri, 11 Jul 2025 13:54:44 +0000
Subject: Update description for flag

---
 src/bootstrap/src/core/config/flags.rs |  2 +-
 src/etc/completions/x.fish             | 46 +++++++++++++++++-----------------
 src/etc/completions/x.ps1              | 46 +++++++++++++++++-----------------
 src/etc/completions/x.py.fish          | 46 +++++++++++++++++-----------------
 src/etc/completions/x.py.ps1           | 46 +++++++++++++++++-----------------
 src/etc/completions/x.py.zsh           | 46 +++++++++++++++++-----------------
 src/etc/completions/x.zsh              | 46 +++++++++++++++++-----------------
 7 files changed, 139 insertions(+), 139 deletions(-)

diff --git a/src/bootstrap/src/core/config/flags.rs b/src/bootstrap/src/core/config/flags.rs
index 4ac58a06c32..155b6f58758 100644
--- a/src/bootstrap/src/core/config/flags.rs
+++ b/src/bootstrap/src/core/config/flags.rs
@@ -133,7 +133,7 @@ pub struct Flags {
     /// use message-format=json
     pub json_output: bool,
     #[arg(global = true, long)]
-    /// use --compile-time-deps
+    /// only build proc-macros and build scripts (for rust-analyzer)
     pub compile_time_deps: bool,
 
     #[arg(global = true, long, value_name = "STYLE")]
diff --git a/src/etc/completions/x.fish b/src/etc/completions/x.fish
index b58f8aaa2b8..d3da1f353e2 100644
--- a/src/etc/completions/x.fish
+++ b/src/etc/completions/x.fish
@@ -52,7 +52,7 @@ complete -c x -n "__fish_x_needs_command" -l include-default-paths -d 'include d
 complete -c x -n "__fish_x_needs_command" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_needs_command" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_needs_command" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_needs_command" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_needs_command" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_needs_command" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_needs_command" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_needs_command" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -104,7 +104,7 @@ complete -c x -n "__fish_x_using_subcommand build" -l include-default-paths -d '
 complete -c x -n "__fish_x_using_subcommand build" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand build" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand build" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand build" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand build" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand build" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand build" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand build" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -140,7 +140,7 @@ complete -c x -n "__fish_x_using_subcommand check" -l include-default-paths -d '
 complete -c x -n "__fish_x_using_subcommand check" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand check" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand check" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand check" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand check" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand check" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand check" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand check" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -182,7 +182,7 @@ complete -c x -n "__fish_x_using_subcommand clippy" -l include-default-paths -d
 complete -c x -n "__fish_x_using_subcommand clippy" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand clippy" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand clippy" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand clippy" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand clippy" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand clippy" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand clippy" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand clippy" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -217,7 +217,7 @@ complete -c x -n "__fish_x_using_subcommand fix" -l include-default-paths -d 'in
 complete -c x -n "__fish_x_using_subcommand fix" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand fix" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand fix" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand fix" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand fix" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand fix" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand fix" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand fix" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -254,7 +254,7 @@ complete -c x -n "__fish_x_using_subcommand fmt" -l include-default-paths -d 'in
 complete -c x -n "__fish_x_using_subcommand fmt" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand fmt" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand fmt" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand fmt" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand fmt" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand fmt" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand fmt" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand fmt" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -291,7 +291,7 @@ complete -c x -n "__fish_x_using_subcommand doc" -l include-default-paths -d 'in
 complete -c x -n "__fish_x_using_subcommand doc" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand doc" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand doc" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand doc" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand doc" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand doc" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand doc" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand doc" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -340,7 +340,7 @@ complete -c x -n "__fish_x_using_subcommand test" -l include-default-paths -d 'i
 complete -c x -n "__fish_x_using_subcommand test" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand test" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand test" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand test" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand test" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand test" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand test" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand test" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -379,7 +379,7 @@ complete -c x -n "__fish_x_using_subcommand miri" -l include-default-paths -d 'i
 complete -c x -n "__fish_x_using_subcommand miri" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand miri" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand miri" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand miri" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand miri" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand miri" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand miri" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand miri" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -415,7 +415,7 @@ complete -c x -n "__fish_x_using_subcommand bench" -l include-default-paths -d '
 complete -c x -n "__fish_x_using_subcommand bench" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand bench" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand bench" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand bench" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand bench" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand bench" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand bench" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand bench" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -451,7 +451,7 @@ complete -c x -n "__fish_x_using_subcommand clean" -l include-default-paths -d '
 complete -c x -n "__fish_x_using_subcommand clean" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand clean" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand clean" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand clean" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand clean" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand clean" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand clean" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand clean" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -486,7 +486,7 @@ complete -c x -n "__fish_x_using_subcommand dist" -l include-default-paths -d 'i
 complete -c x -n "__fish_x_using_subcommand dist" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand dist" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand dist" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand dist" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand dist" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand dist" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand dist" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand dist" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -521,7 +521,7 @@ complete -c x -n "__fish_x_using_subcommand install" -l include-default-paths -d
 complete -c x -n "__fish_x_using_subcommand install" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand install" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand install" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand install" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand install" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand install" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand install" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand install" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -557,7 +557,7 @@ complete -c x -n "__fish_x_using_subcommand run" -l include-default-paths -d 'in
 complete -c x -n "__fish_x_using_subcommand run" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand run" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand run" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand run" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand run" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand run" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand run" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand run" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -592,7 +592,7 @@ complete -c x -n "__fish_x_using_subcommand setup" -l include-default-paths -d '
 complete -c x -n "__fish_x_using_subcommand setup" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand setup" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand setup" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand setup" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand setup" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand setup" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand setup" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand setup" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -628,7 +628,7 @@ complete -c x -n "__fish_x_using_subcommand suggest" -l include-default-paths -d
 complete -c x -n "__fish_x_using_subcommand suggest" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand suggest" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand suggest" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand suggest" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand suggest" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand suggest" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand suggest" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand suggest" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -665,7 +665,7 @@ complete -c x -n "__fish_x_using_subcommand vendor" -l include-default-paths -d
 complete -c x -n "__fish_x_using_subcommand vendor" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand vendor" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand vendor" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand vendor" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand vendor" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand vendor" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand vendor" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand vendor" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -700,7 +700,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -743,7 +743,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_fro
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -781,7 +781,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_fro
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from samply" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -819,7 +819,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_fro
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -857,7 +857,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_fro
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -892,7 +892,7 @@ complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_fro
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x -n "__fish_x_using_subcommand perf; and __fish_seen_subcommand_from compare" -l enable-bolt-settings -d 'Enable BOLT link flags'
diff --git a/src/etc/completions/x.ps1 b/src/etc/completions/x.ps1
index 0f61801277c..b5b59c58bba 100644
--- a/src/etc/completions/x.ps1
+++ b/src/etc/completions/x.ps1
@@ -52,7 +52,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -111,7 +111,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -154,7 +154,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -203,7 +203,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -245,7 +245,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -289,7 +289,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -333,7 +333,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -389,7 +389,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -435,7 +435,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -478,7 +478,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -521,7 +521,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -563,7 +563,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -605,7 +605,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -648,7 +648,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -690,7 +690,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -733,7 +733,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -777,7 +777,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -819,7 +819,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -869,7 +869,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -914,7 +914,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -959,7 +959,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -1004,7 +1004,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -1046,7 +1046,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
diff --git a/src/etc/completions/x.py.fish b/src/etc/completions/x.py.fish
index 126bbe154f0..da7680a879d 100644
--- a/src/etc/completions/x.py.fish
+++ b/src/etc/completions/x.py.fish
@@ -52,7 +52,7 @@ complete -c x.py -n "__fish_x.py_needs_command" -l include-default-paths -d 'inc
 complete -c x.py -n "__fish_x.py_needs_command" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_needs_command" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_needs_command" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_needs_command" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_needs_command" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_needs_command" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_needs_command" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_needs_command" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -104,7 +104,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand build" -l include-default-path
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand build" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -140,7 +140,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand check" -l include-default-path
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand check" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand check" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -182,7 +182,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l include-default-pat
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -217,7 +217,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand fix" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand fix" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand fix" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -254,7 +254,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -291,7 +291,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand doc" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand doc" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -340,7 +340,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand test" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand test" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -379,7 +379,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand miri" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand miri" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand miri" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -415,7 +415,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand bench" -l include-default-path
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand bench" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand bench" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -451,7 +451,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand clean" -l include-default-path
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand clean" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand clean" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -486,7 +486,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand dist" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand dist" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand dist" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -521,7 +521,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand install" -l include-default-pa
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand install" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand install" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -557,7 +557,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand run" -l include-default-paths
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand run" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand run" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -592,7 +592,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand setup" -l include-default-path
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand setup" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -628,7 +628,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l include-default-pa
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -665,7 +665,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l include-default-pat
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -700,7 +700,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subc
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and not __fish_seen_subcommand_from eprintln samply cachegrind benchmark compare" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -743,7 +743,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcomma
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from eprintln" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -781,7 +781,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcomma
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from samply" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -819,7 +819,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcomma
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from cachegrind" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -857,7 +857,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcomma
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from benchmark" -l enable-bolt-settings -d 'Enable BOLT link flags'
@@ -892,7 +892,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcomma
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l dry-run -d 'dry run; don\'t build anything'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l compile-time-deps -d 'use --compile-time-deps'
+complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
 complete -c x.py -n "__fish_x.py_using_subcommand perf; and __fish_seen_subcommand_from compare" -l enable-bolt-settings -d 'Enable BOLT link flags'
diff --git a/src/etc/completions/x.py.ps1 b/src/etc/completions/x.py.ps1
index 6302265f60f..3fc8e7d5bbd 100644
--- a/src/etc/completions/x.py.ps1
+++ b/src/etc/completions/x.py.ps1
@@ -52,7 +52,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -111,7 +111,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -154,7 +154,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -203,7 +203,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -245,7 +245,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -289,7 +289,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -333,7 +333,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -389,7 +389,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -435,7 +435,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -478,7 +478,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -521,7 +521,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -563,7 +563,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -605,7 +605,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -648,7 +648,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -690,7 +690,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -733,7 +733,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -777,7 +777,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -819,7 +819,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -869,7 +869,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -914,7 +914,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -959,7 +959,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -1004,7 +1004,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
@@ -1046,7 +1046,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
             [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
             [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'use --compile-time-deps')
+            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
             [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
             [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
             [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
diff --git a/src/etc/completions/x.py.zsh b/src/etc/completions/x.py.zsh
index ef9dac5ef45..60ce9002116 100644
--- a/src/etc/completions/x.py.zsh
+++ b/src/etc/completions/x.py.zsh
@@ -46,7 +46,7 @@ _x.py() {
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -98,7 +98,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -143,7 +143,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -194,7 +194,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -238,7 +238,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -284,7 +284,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -330,7 +330,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -388,7 +388,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -436,7 +436,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -481,7 +481,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -526,7 +526,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -570,7 +570,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -614,7 +614,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -659,7 +659,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -703,7 +703,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -749,7 +749,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -795,7 +795,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -839,7 +839,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -895,7 +895,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -942,7 +942,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -989,7 +989,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -1036,7 +1036,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -1081,7 +1081,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
diff --git a/src/etc/completions/x.zsh b/src/etc/completions/x.zsh
index c12e6f3ebae..452a26fef07 100644
--- a/src/etc/completions/x.zsh
+++ b/src/etc/completions/x.zsh
@@ -46,7 +46,7 @@ _x() {
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -98,7 +98,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -143,7 +143,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -194,7 +194,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -238,7 +238,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -284,7 +284,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -330,7 +330,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -388,7 +388,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -436,7 +436,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -481,7 +481,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -526,7 +526,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -570,7 +570,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -614,7 +614,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -659,7 +659,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -703,7 +703,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -749,7 +749,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -795,7 +795,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -839,7 +839,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -895,7 +895,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -942,7 +942,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -989,7 +989,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -1036,7 +1036,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
@@ -1081,7 +1081,7 @@ _arguments "${_arguments_options[@]}" : \
 '--dry-run[dry run; don'\''t build anything]' \
 '--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
 '--json-output[use message-format=json]' \
-'--compile-time-deps[use --compile-time-deps]' \
+'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
 '--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
 '--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
 '--enable-bolt-settings[Enable BOLT link flags]' \
-- 
cgit 1.4.1-3-g733a5


From 28af50075724bd1fa94b7e147b1e230534a70ab9 Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Fri, 11 Jul 2025 15:20:03 +0200
Subject: Opaque type collection: Guard against endlessly recursing free alias
 types

---
 compiler/rustc_ty_utils/src/opaque_types.rs            | 11 +++++++----
 .../opaq-ty-collection-infinite-recur.rs               | 18 ++++++++++++++++++
 .../opaq-ty-collection-infinite-recur.stderr           | 11 +++++++++++
 3 files changed, 36 insertions(+), 4 deletions(-)
 create mode 100644 tests/ui/lazy-type-alias/opaq-ty-collection-infinite-recur.rs
 create mode 100644 tests/ui/lazy-type-alias/opaq-ty-collection-infinite-recur.stderr

diff --git a/compiler/rustc_ty_utils/src/opaque_types.rs b/compiler/rustc_ty_utils/src/opaque_types.rs
index 3b313edea6f..4a7263d0ccd 100644
--- a/compiler/rustc_ty_utils/src/opaque_types.rs
+++ b/compiler/rustc_ty_utils/src/opaque_types.rs
@@ -223,7 +223,10 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for OpaqueTypeCollector<'tcx> {
             }
             // Skips type aliases, as they are meant to be transparent.
             // FIXME(type_alias_impl_trait): can we require mentioning nested type aliases explicitly?
-            ty::Alias(ty::Free, alias_ty) if alias_ty.def_id.is_local() => {
+            ty::Alias(ty::Free, alias_ty) if let Some(def_id) = alias_ty.def_id.as_local() => {
+                if !self.seen.insert(def_id) {
+                    return;
+                }
                 self.tcx
                     .type_of(alias_ty.def_id)
                     .instantiate(self.tcx, alias_ty.args)
@@ -256,16 +259,16 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for OpaqueTypeCollector<'tcx> {
                                 return;
                             }
 
-                            let impl_args = alias_ty.args.rebase_onto(
+                            let alias_args = alias_ty.args.rebase_onto(
                                 self.tcx,
                                 impl_trait_ref.def_id,
                                 ty::GenericArgs::identity_for_item(self.tcx, parent),
                             );
 
-                            if self.tcx.check_args_compatible(assoc.def_id, impl_args) {
+                            if self.tcx.check_args_compatible(assoc.def_id, alias_args) {
                                 self.tcx
                                     .type_of(assoc.def_id)
-                                    .instantiate(self.tcx, impl_args)
+                                    .instantiate(self.tcx, alias_args)
                                     .visit_with(self);
                                 return;
                             } else {
diff --git a/tests/ui/lazy-type-alias/opaq-ty-collection-infinite-recur.rs b/tests/ui/lazy-type-alias/opaq-ty-collection-infinite-recur.rs
new file mode 100644
index 00000000000..34803c8c103
--- /dev/null
+++ b/tests/ui/lazy-type-alias/opaq-ty-collection-infinite-recur.rs
@@ -0,0 +1,18 @@
+// The opaque type collector used to expand free alias types (in situ) without guarding against
+// endlessly recursing aliases which lead to the compiler overflowing its stack in certain
+// situations.
+//
+// In most situations we wouldn't even reach the collector when there's an overflow because we
+// would've already bailed out early during the item's wfcheck due to the normalization failure.
+//
+// In the case below however, while collecting the opaque types defined by the AnonConst, we
+// descend into its nested items (here: type alias `Recur`) to acquire their opaque types --
+// meaning we get there before we wfcheck `Recur`.
+//
+// issue: <https://github.com/rust-lang/rust/issues/131994>
+#![feature(lazy_type_alias)]
+#![expect(incomplete_features)]
+
+struct Hold([(); { type Recur = Recur; 0 }]); //~ ERROR overflow normalizing the type alias `Recur`
+
+fn main() {}
diff --git a/tests/ui/lazy-type-alias/opaq-ty-collection-infinite-recur.stderr b/tests/ui/lazy-type-alias/opaq-ty-collection-infinite-recur.stderr
new file mode 100644
index 00000000000..e93fcd03a96
--- /dev/null
+++ b/tests/ui/lazy-type-alias/opaq-ty-collection-infinite-recur.stderr
@@ -0,0 +1,11 @@
+error[E0275]: overflow normalizing the type alias `Recur`
+  --> $DIR/opaq-ty-collection-infinite-recur.rs:16:20
+   |
+LL | struct Hold([(); { type Recur = Recur; 0 }]);
+   |                    ^^^^^^^^^^
+   |
+   = 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`.
-- 
cgit 1.4.1-3-g733a5


From 5a9030840db3399c664035617cb0e3db7f132f8a Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Fri, 11 Jul 2025 23:10:03 +0900
Subject: fix: Normalize projection types before calculating memory maps

---
 .../rust-analyzer/crates/hir-ty/src/mir/eval.rs    | 14 +++++---
 .../rust-analyzer/crates/ide/src/hover/tests.rs    | 38 ++++++++++++++++++++++
 2 files changed, 47 insertions(+), 5 deletions(-)

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 1ec55a82092..829771f4c4f 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
@@ -31,8 +31,8 @@ use syntax::{SyntaxNodePtr, TextRange};
 use triomphe::Arc;
 
 use crate::{
-    CallableDefId, ClosureId, ComplexMemoryMap, Const, ConstData, ConstScalar, FnDefId, Interner,
-    MemoryMap, Substitution, ToChalk, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind,
+    AliasTy, CallableDefId, ClosureId, ComplexMemoryMap, Const, ConstData, ConstScalar, FnDefId,
+    Interner, MemoryMap, Substitution, ToChalk, TraitEnvironment, Ty, TyBuilder, TyExt, TyKind,
     consteval::{ConstEvalError, intern_const_scalar, try_const_usize},
     db::{HirDatabase, InternedClosure},
     display::{ClosureStyle, DisplayTarget, HirDisplay},
@@ -2195,7 +2195,7 @@ impl Evaluator<'_> {
                         }
                     }
                 }
-                chalk_ir::TyKind::Array(inner, len) => {
+                TyKind::Array(inner, len) => {
                     let len = match try_const_usize(this.db, len) {
                         Some(it) => it as usize,
                         None => not_supported!("non evaluatable array len in patching addresses"),
@@ -2213,7 +2213,7 @@ impl Evaluator<'_> {
                         )?;
                     }
                 }
-                chalk_ir::TyKind::Tuple(_, subst) => {
+                TyKind::Tuple(_, subst) => {
                     let layout = this.layout(ty)?;
                     for (id, ty) in subst.iter(Interner).enumerate() {
                         let ty = ty.assert_ty_ref(Interner); // Tuple only has type argument
@@ -2229,7 +2229,7 @@ impl Evaluator<'_> {
                         )?;
                     }
                 }
-                chalk_ir::TyKind::Adt(adt, subst) => match adt.0 {
+                TyKind::Adt(adt, subst) => match adt.0 {
                     AdtId::StructId(s) => {
                         let data = s.fields(this.db);
                         let layout = this.layout(ty)?;
@@ -2280,6 +2280,10 @@ impl Evaluator<'_> {
                     }
                     AdtId::UnionId(_) => (),
                 },
+                TyKind::Alias(AliasTy::Projection(proj)) => {
+                    let ty = this.db.normalize_projection(proj.clone(), this.trait_env.clone());
+                    rec(this, bytes, &ty, locals, mm, stack_depth_limit - 1)?;
+                }
                 _ => (),
             }
             Ok(())
diff --git a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
index c3afd7da2df..c5480217a91 100644
--- a/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/hover/tests.rs
@@ -10985,3 +10985,41 @@ fn has_docs$0() {}
         "#]],
     );
 }
+
+#[test]
+fn regression_20225() {
+    check(
+        r#"
+//- minicore: coerce_unsized
+trait Trait {
+    type Type<'a, T: ?Sized + 'a>;
+}
+
+enum Borrowed {}
+
+impl Trait for Borrowed {
+    type Type<'a, T: ?Sized + 'a> = &'a T;
+}
+
+enum Enum<'a, T: Trait + 'a> {
+    Variant1(T::Type<'a, [Enum<'a, T>]>),
+    Variant2,
+}
+
+impl Enum<'_, Borrowed> {
+    const CONSTANT$0: Self = Self::Variant1(&[Self::Variant2]);
+}
+    "#,
+        expect![[r#"
+            *CONSTANT*
+
+            ```rust
+            ra_test_fixture::Enum
+            ```
+
+            ```rust
+            const CONSTANT: Self = Variant1(&[Variant2])
+            ```
+        "#]],
+    );
+}
-- 
cgit 1.4.1-3-g733a5


From cfb66e5e88a4f5333b328df0b6363ded674f92b4 Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 10 Jul 2025 05:53:40 -0400
Subject: Consolidate infinity tests

---
 library/coretests/tests/floats/f128.rs | 12 ------------
 library/coretests/tests/floats/f16.rs  | 12 ------------
 library/coretests/tests/floats/f32.rs  | 12 ------------
 library/coretests/tests/floats/f64.rs  | 12 ------------
 library/coretests/tests/floats/mod.rs  | 18 ++++++++++++++++++
 5 files changed, 18 insertions(+), 48 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index 38df09a91c1..1b7ac82c1e9 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -55,18 +55,6 @@ fn test_num_f128() {
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_infinity() {
-    let inf: f128 = f128::INFINITY;
-    assert!(inf.is_infinite());
-    assert!(!inf.is_finite());
-    assert!(inf.is_sign_positive());
-    assert!(!inf.is_sign_negative());
-    assert!(!inf.is_nan());
-    assert!(!inf.is_normal());
-    assert_eq!(Fp::Infinite, inf.classify());
-}
-
 #[test]
 fn test_neg_infinity() {
     let neg_inf: f128 = f128::NEG_INFINITY;
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index f6749d796cc..e69fe4d70bc 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -51,18 +51,6 @@ fn test_num_f16() {
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_infinity() {
-    let inf: f16 = f16::INFINITY;
-    assert!(inf.is_infinite());
-    assert!(!inf.is_finite());
-    assert!(inf.is_sign_positive());
-    assert!(!inf.is_sign_negative());
-    assert!(!inf.is_nan());
-    assert!(!inf.is_normal());
-    assert_eq!(Fp::Infinite, inf.classify());
-}
-
 #[test]
 fn test_neg_infinity() {
     let neg_inf: f16 = f16::NEG_INFINITY;
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index f5d5723fea4..1efa8b3fdd5 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -35,18 +35,6 @@ fn test_num_f32() {
     super::test_num(10f32, 2f32);
 }
 
-#[test]
-fn test_infinity() {
-    let inf: f32 = f32::INFINITY;
-    assert!(inf.is_infinite());
-    assert!(!inf.is_finite());
-    assert!(inf.is_sign_positive());
-    assert!(!inf.is_sign_negative());
-    assert!(!inf.is_nan());
-    assert!(!inf.is_normal());
-    assert_eq!(Fp::Infinite, inf.classify());
-}
-
 #[test]
 fn test_neg_infinity() {
     let neg_inf: f32 = f32::NEG_INFINITY;
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index 34af87c241e..9771abd2fe3 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -30,18 +30,6 @@ fn test_num_f64() {
     super::test_num(10f64, 2f64);
 }
 
-#[test]
-fn test_infinity() {
-    let inf: f64 = f64::INFINITY;
-    assert!(inf.is_infinite());
-    assert!(!inf.is_finite());
-    assert!(inf.is_sign_positive());
-    assert!(!inf.is_sign_negative());
-    assert!(!inf.is_nan());
-    assert!(!inf.is_normal());
-    assert_eq!(Fp::Infinite, inf.classify());
-}
-
 #[test]
 fn test_neg_infinity() {
     let neg_inf: f64 = f64::NEG_INFINITY;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 36743a7d6df..9fe74090f15 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -273,6 +273,24 @@ float_test! {
     }
 }
 
+float_test! {
+    name: infinity,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let inf: Float = Float::INFINITY;
+        assert!(inf.is_infinite());
+        assert!(!inf.is_finite());
+        assert!(inf.is_sign_positive());
+        assert!(!inf.is_sign_negative());
+        assert!(!inf.is_nan());
+        assert!(!inf.is_normal());
+        assert!(matches!(inf.classify(), Fp::Infinite));
+    }
+}
+
 float_test! {
     name: min,
     attrs: {
-- 
cgit 1.4.1-3-g733a5


From c5e67b48ef0b073c07a57557d0dd205c099fc56e Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 10 Jul 2025 10:20:28 -0400
Subject: Consolidate test_num tests

---
 library/coretests/tests/floats/f128.rs | 15 ----------
 library/coretests/tests/floats/f16.rs  |  5 ----
 library/coretests/tests/floats/f32.rs  |  5 ----
 library/coretests/tests/floats/f64.rs  |  5 ----
 library/coretests/tests/floats/mod.rs  | 53 +++++++++++++++++++++-------------
 library/coretests/tests/lib.rs         |  1 +
 6 files changed, 34 insertions(+), 50 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index 1b7ac82c1e9..508d30963a5 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -1,7 +1,6 @@
 // FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
 #![cfg(target_has_reliable_f128)]
 
-use core::ops::{Add, Div, Mul, Sub};
 use std::f128::consts;
 use std::num::FpCategory as Fp;
 
@@ -38,20 +37,6 @@ const NAN_MASK1: u128 = 0x0000aaaaaaaaaaaaaaaaaaaaaaaaaaaa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
 
-#[test]
-fn test_num_f128() {
-    // FIXME(f16_f128): replace with a `test_num` call once the required `fmodl`/`fmodf128`
-    // function is available on all platforms.
-    let ten = 10f128;
-    let two = 2f128;
-    assert_biteq!(ten.add(two), ten + two);
-    assert_biteq!(ten.sub(two), ten - two);
-    assert_biteq!(ten.mul(two), ten * two);
-    assert_biteq!(ten.div(two), ten / two);
-    #[cfg(any(miri, target_has_reliable_f128_math))]
-    assert_biteq!(core::ops::Rem::rem(ten, two), ten % two);
-}
-
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index e69fe4d70bc..426411f6737 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -43,11 +43,6 @@ const NAN_MASK1: u16 = 0x02aa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u16 = 0x0155;
 
-#[test]
-fn test_num_f16() {
-    super::test_num(10f16, 2f16);
-}
-
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index 1efa8b3fdd5..4fe21975d41 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -30,11 +30,6 @@ const NAN_MASK2: u32 = 0x0055_5555;
 /// They serve as a way to get an idea of the real precision of floating point operations on different platforms.
 const APPROX_DELTA: f32 = if cfg!(miri) { 1e-4 } else { 1e-6 };
 
-#[test]
-fn test_num_f32() {
-    super::test_num(10f32, 2f32);
-}
-
 #[test]
 fn test_neg_infinity() {
     let neg_inf: f32 = f32::NEG_INFINITY;
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index 9771abd2fe3..7016f3643c8 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -25,11 +25,6 @@ const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
 
-#[test]
-fn test_num_f64() {
-    super::test_num(10f64, 2f64);
-}
-
 #[test]
 fn test_neg_infinity() {
     let neg_inf: f64 = f64::NEG_INFINITY;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 9fe74090f15..a746e4bf40d 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -1,4 +1,3 @@
-use std::fmt;
 use std::num::FpCategory as Fp;
 use std::ops::{Add, Div, Mul, Rem, Sub};
 
@@ -190,6 +189,8 @@ macro_rules! float_test {
                 use super::Approx;
                 #[allow(unused)]
                 use std::num::FpCategory as Fp;
+                #[allow(unused)]
+                use std::ops::{Add, Div, Mul, Rem, Sub};
                 // Shadow the runtime versions of the macro with const-compatible versions.
                 #[allow(unused)]
                 use $crate::floats::{
@@ -229,30 +230,42 @@ macro_rules! float_test {
     };
 }
 
-/// Helper function for testing numeric operations
-pub fn test_num<T>(ten: T, two: T)
-where
-    T: PartialEq
-        + Add<Output = T>
-        + Sub<Output = T>
-        + Mul<Output = T>
-        + Div<Output = T>
-        + Rem<Output = T>
-        + fmt::Debug
-        + Copy,
-{
-    assert_eq!(ten.add(two), ten + two);
-    assert_eq!(ten.sub(two), ten - two);
-    assert_eq!(ten.mul(two), ten * two);
-    assert_eq!(ten.div(two), ten / two);
-    assert_eq!(ten.rem(two), ten % two);
-}
-
 mod f128;
 mod f16;
 mod f32;
 mod f64;
 
+float_test! {
+    name: num,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let two: Float = 2.0;
+        let ten: Float = 10.0;
+        assert_biteq!(ten.add(two), ten + two);
+        assert_biteq!(ten.sub(two), ten - two);
+        assert_biteq!(ten.mul(two), ten * two);
+        assert_biteq!(ten.div(two), ten / two);
+    }
+}
+
+// FIXME(f16_f128): merge into `num` once the required `fmodl`/`fmodf128` function is available on
+// all platforms.
+float_test! {
+    name: num_rem,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16_math))],
+        f128: #[cfg(any(miri, target_has_reliable_f128_math))],
+    },
+    test<Float> {
+        let two: Float = 2.0;
+        let ten: Float = 10.0;
+        assert_biteq!(ten.rem(two), ten % two);
+    }
+}
+
 float_test! {
     name: nan,
     attrs: {
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index fdef736c0c0..e2249bd7f6a 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -20,6 +20,7 @@
 #![feature(const_destruct)]
 #![feature(const_eval_select)]
 #![feature(const_float_round_methods)]
+#![feature(const_ops)]
 #![feature(const_ref_cell)]
 #![feature(const_trait_impl)]
 #![feature(core_float_math)]
-- 
cgit 1.4.1-3-g733a5


From c2e6b39474beacf2be7313326f0a06e3d7f85f04 Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 10 Jul 2025 10:10:39 -0400
Subject: Consolidate neg_infinity tests

---
 library/coretests/tests/floats/f128.rs | 12 ------------
 library/coretests/tests/floats/f16.rs  | 12 ------------
 library/coretests/tests/floats/f32.rs  | 12 ------------
 library/coretests/tests/floats/f64.rs  | 12 ------------
 library/coretests/tests/floats/mod.rs  | 18 ++++++++++++++++++
 5 files changed, 18 insertions(+), 48 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index 508d30963a5..db6441df32b 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -40,18 +40,6 @@ const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_neg_infinity() {
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    assert!(neg_inf.is_infinite());
-    assert!(!neg_inf.is_finite());
-    assert!(!neg_inf.is_sign_positive());
-    assert!(neg_inf.is_sign_negative());
-    assert!(!neg_inf.is_nan());
-    assert!(!neg_inf.is_normal());
-    assert_eq!(Fp::Infinite, neg_inf.classify());
-}
-
 #[test]
 fn test_zero() {
     let zero: f128 = 0.0f128;
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index 426411f6737..051737c34c3 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -46,18 +46,6 @@ const NAN_MASK2: u16 = 0x0155;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_neg_infinity() {
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    assert!(neg_inf.is_infinite());
-    assert!(!neg_inf.is_finite());
-    assert!(!neg_inf.is_sign_positive());
-    assert!(neg_inf.is_sign_negative());
-    assert!(!neg_inf.is_nan());
-    assert!(!neg_inf.is_normal());
-    assert_eq!(Fp::Infinite, neg_inf.classify());
-}
-
 #[test]
 fn test_zero() {
     let zero: f16 = 0.0f16;
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index 4fe21975d41..0cf9ef042a0 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -30,18 +30,6 @@ const NAN_MASK2: u32 = 0x0055_5555;
 /// They serve as a way to get an idea of the real precision of floating point operations on different platforms.
 const APPROX_DELTA: f32 = if cfg!(miri) { 1e-4 } else { 1e-6 };
 
-#[test]
-fn test_neg_infinity() {
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    assert!(neg_inf.is_infinite());
-    assert!(!neg_inf.is_finite());
-    assert!(!neg_inf.is_sign_positive());
-    assert!(neg_inf.is_sign_negative());
-    assert!(!neg_inf.is_nan());
-    assert!(!neg_inf.is_normal());
-    assert_eq!(Fp::Infinite, neg_inf.classify());
-}
-
 #[test]
 fn test_zero() {
     let zero: f32 = 0.0f32;
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index 7016f3643c8..1e995d77e3c 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -25,18 +25,6 @@ const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
 
-#[test]
-fn test_neg_infinity() {
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    assert!(neg_inf.is_infinite());
-    assert!(!neg_inf.is_finite());
-    assert!(!neg_inf.is_sign_positive());
-    assert!(neg_inf.is_sign_negative());
-    assert!(!neg_inf.is_nan());
-    assert!(!neg_inf.is_normal());
-    assert_eq!(Fp::Infinite, neg_inf.classify());
-}
-
 #[test]
 fn test_zero() {
     let zero: f64 = 0.0f64;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index a746e4bf40d..ed30aae4411 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -304,6 +304,24 @@ float_test! {
     }
 }
 
+float_test! {
+    name: neg_infinity,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let neg_inf: Float = Float::NEG_INFINITY;
+        assert!(neg_inf.is_infinite());
+        assert!(!neg_inf.is_finite());
+        assert!(!neg_inf.is_sign_positive());
+        assert!(neg_inf.is_sign_negative());
+        assert!(!neg_inf.is_nan());
+        assert!(!neg_inf.is_normal());
+        assert!(matches!(neg_inf.classify(), Fp::Infinite));
+    }
+}
+
 float_test! {
     name: min,
     attrs: {
-- 
cgit 1.4.1-3-g733a5


From 0c01322ec6578644108fb66b279f18f3d5382368 Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 10 Jul 2025 10:26:39 -0400
Subject: Consolidate zero tests

---
 library/coretests/tests/floats/f128.rs | 13 -------------
 library/coretests/tests/floats/f16.rs  | 13 -------------
 library/coretests/tests/floats/f32.rs  | 13 -------------
 library/coretests/tests/floats/f64.rs  | 13 -------------
 library/coretests/tests/floats/mod.rs  | 19 +++++++++++++++++++
 5 files changed, 19 insertions(+), 52 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index db6441df32b..85e9bfef125 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -40,19 +40,6 @@ const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_zero() {
-    let zero: f128 = 0.0f128;
-    assert_biteq!(0.0, zero);
-    assert!(!zero.is_infinite());
-    assert!(zero.is_finite());
-    assert!(zero.is_sign_positive());
-    assert!(!zero.is_sign_negative());
-    assert!(!zero.is_nan());
-    assert!(!zero.is_normal());
-    assert_eq!(Fp::Zero, zero.classify());
-}
-
 #[test]
 fn test_neg_zero() {
     let neg_zero: f128 = -0.0;
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index 051737c34c3..fced642eb13 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -46,19 +46,6 @@ const NAN_MASK2: u16 = 0x0155;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_zero() {
-    let zero: f16 = 0.0f16;
-    assert_biteq!(0.0, zero);
-    assert!(!zero.is_infinite());
-    assert!(zero.is_finite());
-    assert!(zero.is_sign_positive());
-    assert!(!zero.is_sign_negative());
-    assert!(!zero.is_nan());
-    assert!(!zero.is_normal());
-    assert_eq!(Fp::Zero, zero.classify());
-}
-
 #[test]
 fn test_neg_zero() {
     let neg_zero: f16 = -0.0;
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index 0cf9ef042a0..23e98a9589c 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -30,19 +30,6 @@ const NAN_MASK2: u32 = 0x0055_5555;
 /// They serve as a way to get an idea of the real precision of floating point operations on different platforms.
 const APPROX_DELTA: f32 = if cfg!(miri) { 1e-4 } else { 1e-6 };
 
-#[test]
-fn test_zero() {
-    let zero: f32 = 0.0f32;
-    assert_biteq!(0.0, zero);
-    assert!(!zero.is_infinite());
-    assert!(zero.is_finite());
-    assert!(zero.is_sign_positive());
-    assert!(!zero.is_sign_negative());
-    assert!(!zero.is_nan());
-    assert!(!zero.is_normal());
-    assert_eq!(Fp::Zero, zero.classify());
-}
-
 #[test]
 fn test_neg_zero() {
     let neg_zero: f32 = -0.0;
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index 1e995d77e3c..739ff8a7aa7 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -25,19 +25,6 @@ const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
 
-#[test]
-fn test_zero() {
-    let zero: f64 = 0.0f64;
-    assert_biteq!(0.0, zero);
-    assert!(!zero.is_infinite());
-    assert!(zero.is_finite());
-    assert!(zero.is_sign_positive());
-    assert!(!zero.is_sign_negative());
-    assert!(!zero.is_nan());
-    assert!(!zero.is_normal());
-    assert_eq!(Fp::Zero, zero.classify());
-}
-
 #[test]
 fn test_neg_zero() {
     let neg_zero: f64 = -0.0;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index ed30aae4411..75dbe4a9d6d 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -322,6 +322,25 @@ float_test! {
     }
 }
 
+float_test! {
+    name: zero,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let zero: Float = 0.0;
+        assert_biteq!(0.0, zero);
+        assert!(!zero.is_infinite());
+        assert!(zero.is_finite());
+        assert!(zero.is_sign_positive());
+        assert!(!zero.is_sign_negative());
+        assert!(!zero.is_nan());
+        assert!(!zero.is_normal());
+        assert!(matches!(zero.classify(), Fp::Zero));
+    }
+}
+
 float_test! {
     name: min,
     attrs: {
-- 
cgit 1.4.1-3-g733a5


From fc01eed02444e412761ac1b5b723d45f443800fb Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 10 Jul 2025 10:31:29 -0400
Subject: Consolidate negative zero tests

---
 library/coretests/tests/floats/f128.rs | 14 --------------
 library/coretests/tests/floats/f16.rs  | 14 --------------
 library/coretests/tests/floats/f32.rs  | 14 --------------
 library/coretests/tests/floats/f64.rs  | 14 --------------
 library/coretests/tests/floats/mod.rs  | 20 ++++++++++++++++++++
 5 files changed, 20 insertions(+), 56 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index 85e9bfef125..dbf4d6df636 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -40,20 +40,6 @@ const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_neg_zero() {
-    let neg_zero: f128 = -0.0;
-    assert_eq!(0.0, neg_zero);
-    assert_biteq!(-0.0, neg_zero);
-    assert!(!neg_zero.is_infinite());
-    assert!(neg_zero.is_finite());
-    assert!(!neg_zero.is_sign_positive());
-    assert!(neg_zero.is_sign_negative());
-    assert!(!neg_zero.is_nan());
-    assert!(!neg_zero.is_normal());
-    assert_eq!(Fp::Zero, neg_zero.classify());
-}
-
 #[test]
 fn test_one() {
     let one: f128 = 1.0f128;
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index fced642eb13..15ab57f8e7e 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -46,20 +46,6 @@ const NAN_MASK2: u16 = 0x0155;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_neg_zero() {
-    let neg_zero: f16 = -0.0;
-    assert_eq!(0.0, neg_zero);
-    assert_biteq!(-0.0, neg_zero);
-    assert!(!neg_zero.is_infinite());
-    assert!(neg_zero.is_finite());
-    assert!(!neg_zero.is_sign_positive());
-    assert!(neg_zero.is_sign_negative());
-    assert!(!neg_zero.is_nan());
-    assert!(!neg_zero.is_normal());
-    assert_eq!(Fp::Zero, neg_zero.classify());
-}
-
 #[test]
 fn test_one() {
     let one: f16 = 1.0f16;
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index 23e98a9589c..935bfa8b273 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -30,20 +30,6 @@ const NAN_MASK2: u32 = 0x0055_5555;
 /// They serve as a way to get an idea of the real precision of floating point operations on different platforms.
 const APPROX_DELTA: f32 = if cfg!(miri) { 1e-4 } else { 1e-6 };
 
-#[test]
-fn test_neg_zero() {
-    let neg_zero: f32 = -0.0;
-    assert_eq!(0.0, neg_zero);
-    assert_biteq!(-0.0, neg_zero);
-    assert!(!neg_zero.is_infinite());
-    assert!(neg_zero.is_finite());
-    assert!(!neg_zero.is_sign_positive());
-    assert!(neg_zero.is_sign_negative());
-    assert!(!neg_zero.is_nan());
-    assert!(!neg_zero.is_normal());
-    assert_eq!(Fp::Zero, neg_zero.classify());
-}
-
 #[test]
 fn test_one() {
     let one: f32 = 1.0f32;
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index 739ff8a7aa7..d3637dfd9d6 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -25,20 +25,6 @@ const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
 
-#[test]
-fn test_neg_zero() {
-    let neg_zero: f64 = -0.0;
-    assert_eq!(0.0, neg_zero);
-    assert_biteq!(-0.0, neg_zero);
-    assert!(!neg_zero.is_infinite());
-    assert!(neg_zero.is_finite());
-    assert!(!neg_zero.is_sign_positive());
-    assert!(neg_zero.is_sign_negative());
-    assert!(!neg_zero.is_nan());
-    assert!(!neg_zero.is_normal());
-    assert_eq!(Fp::Zero, neg_zero.classify());
-}
-
 #[test]
 fn test_one() {
     let one: f64 = 1.0f64;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 75dbe4a9d6d..006f51488dd 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -341,6 +341,26 @@ float_test! {
     }
 }
 
+float_test! {
+    name: neg_zero,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let neg_zero: Float = -0.0;
+        assert!(0.0 == neg_zero);
+        assert_biteq!(-0.0, neg_zero);
+        assert!(!neg_zero.is_infinite());
+        assert!(neg_zero.is_finite());
+        assert!(!neg_zero.is_sign_positive());
+        assert!(neg_zero.is_sign_negative());
+        assert!(!neg_zero.is_nan());
+        assert!(!neg_zero.is_normal());
+        assert!(matches!(neg_zero.classify(), Fp::Zero));
+    }
+}
+
 float_test! {
     name: min,
     attrs: {
-- 
cgit 1.4.1-3-g733a5


From 868020e0594969356d1c41831c84fe68f7b514f0 Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 10 Jul 2025 10:40:10 -0400
Subject: Consolidate one tests

---
 library/coretests/tests/floats/f128.rs | 13 -------------
 library/coretests/tests/floats/f16.rs  | 13 -------------
 library/coretests/tests/floats/f32.rs  | 13 -------------
 library/coretests/tests/floats/f64.rs  | 13 -------------
 library/coretests/tests/floats/mod.rs  | 19 +++++++++++++++++++
 5 files changed, 19 insertions(+), 52 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index dbf4d6df636..289752673fe 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -40,19 +40,6 @@ const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_one() {
-    let one: f128 = 1.0f128;
-    assert_biteq!(1.0, one);
-    assert!(!one.is_infinite());
-    assert!(one.is_finite());
-    assert!(one.is_sign_positive());
-    assert!(!one.is_sign_negative());
-    assert!(!one.is_nan());
-    assert!(one.is_normal());
-    assert_eq!(Fp::Normal, one.classify());
-}
-
 #[test]
 fn test_is_nan() {
     let nan: f128 = f128::NAN;
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index 15ab57f8e7e..3435630a4ff 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -46,19 +46,6 @@ const NAN_MASK2: u16 = 0x0155;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_one() {
-    let one: f16 = 1.0f16;
-    assert_biteq!(1.0, one);
-    assert!(!one.is_infinite());
-    assert!(one.is_finite());
-    assert!(one.is_sign_positive());
-    assert!(!one.is_sign_negative());
-    assert!(!one.is_nan());
-    assert!(one.is_normal());
-    assert_eq!(Fp::Normal, one.classify());
-}
-
 #[test]
 fn test_is_nan() {
     let nan: f16 = f16::NAN;
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index 935bfa8b273..5b1151aca9f 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -30,19 +30,6 @@ const NAN_MASK2: u32 = 0x0055_5555;
 /// They serve as a way to get an idea of the real precision of floating point operations on different platforms.
 const APPROX_DELTA: f32 = if cfg!(miri) { 1e-4 } else { 1e-6 };
 
-#[test]
-fn test_one() {
-    let one: f32 = 1.0f32;
-    assert_biteq!(1.0, one);
-    assert!(!one.is_infinite());
-    assert!(one.is_finite());
-    assert!(one.is_sign_positive());
-    assert!(!one.is_sign_negative());
-    assert!(!one.is_nan());
-    assert!(one.is_normal());
-    assert_eq!(Fp::Normal, one.classify());
-}
-
 #[test]
 fn test_is_nan() {
     let nan: f32 = f32::NAN;
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index d3637dfd9d6..7473fc07dbe 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -25,19 +25,6 @@ const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
 
-#[test]
-fn test_one() {
-    let one: f64 = 1.0f64;
-    assert_biteq!(1.0, one);
-    assert!(!one.is_infinite());
-    assert!(one.is_finite());
-    assert!(one.is_sign_positive());
-    assert!(!one.is_sign_negative());
-    assert!(!one.is_nan());
-    assert!(one.is_normal());
-    assert_eq!(Fp::Normal, one.classify());
-}
-
 #[test]
 fn test_is_nan() {
     let nan: f64 = f64::NAN;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 006f51488dd..abe827b6988 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -361,6 +361,25 @@ float_test! {
     }
 }
 
+float_test! {
+    name: one,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let one: Float = 1.0;
+        assert_biteq!(1.0, one);
+        assert!(!one.is_infinite());
+        assert!(one.is_finite());
+        assert!(one.is_sign_positive());
+        assert!(!one.is_sign_negative());
+        assert!(!one.is_nan());
+        assert!(one.is_normal());
+        assert!(matches!(one.classify(), Fp::Normal));
+    }
+}
+
 float_test! {
     name: min,
     attrs: {
-- 
cgit 1.4.1-3-g733a5


From 1b8904c0c59a1790f38d2ddc05f4c3416030e07e Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 10 Jul 2025 10:42:48 -0400
Subject: Consolidate is_nan

---
 library/coretests/tests/floats/f128.rs | 13 -------------
 library/coretests/tests/floats/f16.rs  | 13 -------------
 library/coretests/tests/floats/f32.rs  | 13 -------------
 library/coretests/tests/floats/f64.rs  | 13 -------------
 library/coretests/tests/floats/mod.rs  | 22 ++++++++++++++++++++++
 5 files changed, 22 insertions(+), 52 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index 289752673fe..6a987494a6a 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -40,19 +40,6 @@ const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_is_nan() {
-    let nan: f128 = f128::NAN;
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    assert!(nan.is_nan());
-    assert!(!0.0f128.is_nan());
-    assert!(!5.3f128.is_nan());
-    assert!(!(-10.732f128).is_nan());
-    assert!(!inf.is_nan());
-    assert!(!neg_inf.is_nan());
-}
-
 #[test]
 fn test_is_infinite() {
     let nan: f128 = f128::NAN;
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index 3435630a4ff..dec371a7de9 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -46,19 +46,6 @@ const NAN_MASK2: u16 = 0x0155;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_is_nan() {
-    let nan: f16 = f16::NAN;
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    assert!(nan.is_nan());
-    assert!(!0.0f16.is_nan());
-    assert!(!5.3f16.is_nan());
-    assert!(!(-10.732f16).is_nan());
-    assert!(!inf.is_nan());
-    assert!(!neg_inf.is_nan());
-}
-
 #[test]
 fn test_is_infinite() {
     let nan: f16 = f16::NAN;
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index 5b1151aca9f..5ca6a633a97 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -30,19 +30,6 @@ const NAN_MASK2: u32 = 0x0055_5555;
 /// They serve as a way to get an idea of the real precision of floating point operations on different platforms.
 const APPROX_DELTA: f32 = if cfg!(miri) { 1e-4 } else { 1e-6 };
 
-#[test]
-fn test_is_nan() {
-    let nan: f32 = f32::NAN;
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    assert!(nan.is_nan());
-    assert!(!0.0f32.is_nan());
-    assert!(!5.3f32.is_nan());
-    assert!(!(-10.732f32).is_nan());
-    assert!(!inf.is_nan());
-    assert!(!neg_inf.is_nan());
-}
-
 #[test]
 fn test_is_infinite() {
     let nan: f32 = f32::NAN;
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index 7473fc07dbe..6dd18b25527 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -25,19 +25,6 @@ const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
 
-#[test]
-fn test_is_nan() {
-    let nan: f64 = f64::NAN;
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    assert!(nan.is_nan());
-    assert!(!0.0f64.is_nan());
-    assert!(!5.3f64.is_nan());
-    assert!(!(-10.732f64).is_nan());
-    assert!(!inf.is_nan());
-    assert!(!neg_inf.is_nan());
-}
-
 #[test]
 fn test_is_infinite() {
     let nan: f64 = f64::NAN;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index abe827b6988..613557975a2 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -380,6 +380,28 @@ float_test! {
     }
 }
 
+float_test! {
+    name: is_nan,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        let zero: Float = 0.0;
+        let pos: Float = 5.3;
+        let neg: Float = -10.732;
+        assert!(nan.is_nan());
+        assert!(!zero.is_nan());
+        assert!(!pos.is_nan());
+        assert!(!neg.is_nan());
+        assert!(!inf.is_nan());
+        assert!(!neg_inf.is_nan());
+    }
+}
+
 float_test! {
     name: min,
     attrs: {
-- 
cgit 1.4.1-3-g733a5


From e3d83679cb1a921fd50ee70dee15e57c6529abed Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 10 Jul 2025 10:49:48 -0400
Subject: Consolidate is_infinite tests

---
 library/coretests/tests/floats/f128.rs | 13 -------------
 library/coretests/tests/floats/f16.rs  | 13 -------------
 library/coretests/tests/floats/f32.rs  | 13 -------------
 library/coretests/tests/floats/f64.rs  | 13 -------------
 library/coretests/tests/floats/mod.rs  | 22 ++++++++++++++++++++++
 5 files changed, 22 insertions(+), 52 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index 6a987494a6a..7ed17731a81 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -40,19 +40,6 @@ const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_is_infinite() {
-    let nan: f128 = f128::NAN;
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    assert!(!nan.is_infinite());
-    assert!(inf.is_infinite());
-    assert!(neg_inf.is_infinite());
-    assert!(!0.0f128.is_infinite());
-    assert!(!42.8f128.is_infinite());
-    assert!(!(-109.2f128).is_infinite());
-}
-
 #[test]
 fn test_is_finite() {
     let nan: f128 = f128::NAN;
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index dec371a7de9..ac972200c3d 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -46,19 +46,6 @@ const NAN_MASK2: u16 = 0x0155;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_is_infinite() {
-    let nan: f16 = f16::NAN;
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    assert!(!nan.is_infinite());
-    assert!(inf.is_infinite());
-    assert!(neg_inf.is_infinite());
-    assert!(!0.0f16.is_infinite());
-    assert!(!42.8f16.is_infinite());
-    assert!(!(-109.2f16).is_infinite());
-}
-
 #[test]
 fn test_is_finite() {
     let nan: f16 = f16::NAN;
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index 5ca6a633a97..d6a34ba2ac6 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -30,19 +30,6 @@ const NAN_MASK2: u32 = 0x0055_5555;
 /// They serve as a way to get an idea of the real precision of floating point operations on different platforms.
 const APPROX_DELTA: f32 = if cfg!(miri) { 1e-4 } else { 1e-6 };
 
-#[test]
-fn test_is_infinite() {
-    let nan: f32 = f32::NAN;
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    assert!(!nan.is_infinite());
-    assert!(inf.is_infinite());
-    assert!(neg_inf.is_infinite());
-    assert!(!0.0f32.is_infinite());
-    assert!(!42.8f32.is_infinite());
-    assert!(!(-109.2f32).is_infinite());
-}
-
 #[test]
 fn test_is_finite() {
     let nan: f32 = f32::NAN;
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index 6dd18b25527..cb3c57140e9 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -25,19 +25,6 @@ const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
 
-#[test]
-fn test_is_infinite() {
-    let nan: f64 = f64::NAN;
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    assert!(!nan.is_infinite());
-    assert!(inf.is_infinite());
-    assert!(neg_inf.is_infinite());
-    assert!(!0.0f64.is_infinite());
-    assert!(!42.8f64.is_infinite());
-    assert!(!(-109.2f64).is_infinite());
-}
-
 #[test]
 fn test_is_finite() {
     let nan: f64 = f64::NAN;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 613557975a2..3f6fe91d36e 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -402,6 +402,28 @@ float_test! {
     }
 }
 
+float_test! {
+    name: is_infinite,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        let zero: Float = 0.0;
+        let pos: Float = 42.8;
+        let neg: Float = -109.2;
+        assert!(!nan.is_infinite());
+        assert!(inf.is_infinite());
+        assert!(neg_inf.is_infinite());
+        assert!(!zero.is_infinite());
+        assert!(!pos.is_infinite());
+        assert!(!neg.is_infinite());
+    }
+}
+
 float_test! {
     name: min,
     attrs: {
-- 
cgit 1.4.1-3-g733a5


From 7dd2811b2af5beb2962d58d2f9f9b78e815a2576 Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 10 Jul 2025 10:53:48 -0400
Subject: Consolidate is_finite tests

---
 library/coretests/tests/floats/f128.rs | 13 -------------
 library/coretests/tests/floats/f16.rs  | 13 -------------
 library/coretests/tests/floats/f32.rs  | 13 -------------
 library/coretests/tests/floats/f64.rs  | 13 -------------
 library/coretests/tests/floats/mod.rs  | 22 ++++++++++++++++++++++
 5 files changed, 22 insertions(+), 52 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index 7ed17731a81..160fe0380a7 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -40,19 +40,6 @@ const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_is_finite() {
-    let nan: f128 = f128::NAN;
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    assert!(!nan.is_finite());
-    assert!(!inf.is_finite());
-    assert!(!neg_inf.is_finite());
-    assert!(0.0f128.is_finite());
-    assert!(42.8f128.is_finite());
-    assert!((-109.2f128).is_finite());
-}
-
 #[test]
 fn test_is_normal() {
     let nan: f128 = f128::NAN;
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index ac972200c3d..1b62278a9a3 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -46,19 +46,6 @@ const NAN_MASK2: u16 = 0x0155;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_is_finite() {
-    let nan: f16 = f16::NAN;
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    assert!(!nan.is_finite());
-    assert!(!inf.is_finite());
-    assert!(!neg_inf.is_finite());
-    assert!(0.0f16.is_finite());
-    assert!(42.8f16.is_finite());
-    assert!((-109.2f16).is_finite());
-}
-
 #[test]
 fn test_is_normal() {
     let nan: f16 = f16::NAN;
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index d6a34ba2ac6..0aa95235fde 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -30,19 +30,6 @@ const NAN_MASK2: u32 = 0x0055_5555;
 /// They serve as a way to get an idea of the real precision of floating point operations on different platforms.
 const APPROX_DELTA: f32 = if cfg!(miri) { 1e-4 } else { 1e-6 };
 
-#[test]
-fn test_is_finite() {
-    let nan: f32 = f32::NAN;
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    assert!(!nan.is_finite());
-    assert!(!inf.is_finite());
-    assert!(!neg_inf.is_finite());
-    assert!(0.0f32.is_finite());
-    assert!(42.8f32.is_finite());
-    assert!((-109.2f32).is_finite());
-}
-
 #[test]
 fn test_is_normal() {
     let nan: f32 = f32::NAN;
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index cb3c57140e9..9f30afb1fe1 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -25,19 +25,6 @@ const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
 
-#[test]
-fn test_is_finite() {
-    let nan: f64 = f64::NAN;
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    assert!(!nan.is_finite());
-    assert!(!inf.is_finite());
-    assert!(!neg_inf.is_finite());
-    assert!(0.0f64.is_finite());
-    assert!(42.8f64.is_finite());
-    assert!((-109.2f64).is_finite());
-}
-
 #[test]
 fn test_is_normal() {
     let nan: f64 = f64::NAN;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 3f6fe91d36e..b8ec82f75b8 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -424,6 +424,28 @@ float_test! {
     }
 }
 
+float_test! {
+    name: is_finite,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        let zero: Float = 0.0;
+        let pos: Float = 42.8;
+        let neg: Float = -109.2;
+        assert!(!nan.is_finite());
+        assert!(!inf.is_finite());
+        assert!(!neg_inf.is_finite());
+        assert!(zero.is_finite());
+        assert!(pos.is_finite());
+        assert!(neg.is_finite());
+    }
+}
+
 float_test! {
     name: min,
     attrs: {
-- 
cgit 1.4.1-3-g733a5


From d2c1900086a057359bf6ae0f8a5b8f658fbc8bce Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 10 Jul 2025 10:20:45 -0400
Subject: Consolidate is_normal tests

---
 library/coretests/tests/floats/f128.rs | 17 ---------
 library/coretests/tests/floats/f16.rs  | 17 ---------
 library/coretests/tests/floats/f32.rs  | 17 ---------
 library/coretests/tests/floats/f64.rs  | 17 ---------
 library/coretests/tests/floats/mod.rs  | 65 ++++++++++++++++++++++++++--------
 5 files changed, 51 insertions(+), 82 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index 160fe0380a7..b741906a6e9 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -40,23 +40,6 @@ const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_is_normal() {
-    let nan: f128 = f128::NAN;
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    let zero: f128 = 0.0f128;
-    let neg_zero: f128 = -0.0;
-    assert!(!nan.is_normal());
-    assert!(!inf.is_normal());
-    assert!(!neg_inf.is_normal());
-    assert!(!zero.is_normal());
-    assert!(!neg_zero.is_normal());
-    assert!(1f128.is_normal());
-    assert!(1e-4931f128.is_normal());
-    assert!(!1e-4932f128.is_normal());
-}
-
 #[test]
 fn test_classify() {
     let nan: f128 = f128::NAN;
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index 1b62278a9a3..da6414fc244 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -46,23 +46,6 @@ const NAN_MASK2: u16 = 0x0155;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_is_normal() {
-    let nan: f16 = f16::NAN;
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    let zero: f16 = 0.0f16;
-    let neg_zero: f16 = -0.0;
-    assert!(!nan.is_normal());
-    assert!(!inf.is_normal());
-    assert!(!neg_inf.is_normal());
-    assert!(!zero.is_normal());
-    assert!(!neg_zero.is_normal());
-    assert!(1f16.is_normal());
-    assert!(1e-4f16.is_normal());
-    assert!(!1e-5f16.is_normal());
-}
-
 #[test]
 fn test_classify() {
     let nan: f16 = f16::NAN;
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index 0aa95235fde..3464930b72f 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -30,23 +30,6 @@ const NAN_MASK2: u32 = 0x0055_5555;
 /// They serve as a way to get an idea of the real precision of floating point operations on different platforms.
 const APPROX_DELTA: f32 = if cfg!(miri) { 1e-4 } else { 1e-6 };
 
-#[test]
-fn test_is_normal() {
-    let nan: f32 = f32::NAN;
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    let zero: f32 = 0.0f32;
-    let neg_zero: f32 = -0.0;
-    assert!(!nan.is_normal());
-    assert!(!inf.is_normal());
-    assert!(!neg_inf.is_normal());
-    assert!(!zero.is_normal());
-    assert!(!neg_zero.is_normal());
-    assert!(1f32.is_normal());
-    assert!(1e-37f32.is_normal());
-    assert!(!1e-38f32.is_normal());
-}
-
 #[test]
 fn test_classify() {
     let nan: f32 = f32::NAN;
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index 9f30afb1fe1..917dae1b6c6 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -25,23 +25,6 @@ const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
 
-#[test]
-fn test_is_normal() {
-    let nan: f64 = f64::NAN;
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    let zero: f64 = 0.0f64;
-    let neg_zero: f64 = -0.0;
-    assert!(!nan.is_normal());
-    assert!(!inf.is_normal());
-    assert!(!neg_inf.is_normal());
-    assert!(!zero.is_normal());
-    assert!(!neg_zero.is_normal());
-    assert!(1f64.is_normal());
-    assert!(1e-307f64.is_normal());
-    assert!(!1e-308f64.is_normal());
-}
-
 #[test]
 fn test_classify() {
     let nan: f64 = f64::NAN;
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index b8ec82f75b8..b1686514a12 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -1,27 +1,40 @@
 use std::num::FpCategory as Fp;
 use std::ops::{Add, Div, Mul, Rem, Sub};
 
-/// Set the default tolerance for float comparison based on the type.
-trait Approx {
-    const LIM: Self;
+trait TestableFloat {
+    /// Set the default tolerance for float comparison based on the type.
+    const APPROX: Self;
+    const MIN_POSITIVE_NORMAL: Self;
+    const MAX_SUBNORMAL: Self;
 }
 
-impl Approx for f16 {
-    const LIM: Self = 1e-3;
+impl TestableFloat for f16 {
+    const APPROX: Self = 1e-3;
+    const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
+    const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
 }
-impl Approx for f32 {
-    const LIM: Self = 1e-6;
+
+impl TestableFloat for f32 {
+    const APPROX: Self = 1e-6;
+    const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
+    const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
 }
-impl Approx for f64 {
-    const LIM: Self = 1e-6;
+
+impl TestableFloat for f64 {
+    const APPROX: Self = 1e-6;
+    const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
+    const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
 }
-impl Approx for f128 {
-    const LIM: Self = 1e-9;
+
+impl TestableFloat for f128 {
+    const APPROX: Self = 1e-9;
+    const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
+    const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
 }
 
 /// Determine the tolerance for values of the argument type.
-const fn lim_for_ty<T: Approx + Copy>(_x: T) -> T {
-    T::LIM
+const fn lim_for_ty<T: TestableFloat + Copy>(_x: T) -> T {
+    T::APPROX
 }
 
 // We have runtime ("rt") and const versions of these macros.
@@ -186,7 +199,7 @@ macro_rules! float_test {
             $( $( #[$const_meta] )+ )?
             mod const_ {
                 #[allow(unused)]
-                use super::Approx;
+                use super::TestableFloat;
                 #[allow(unused)]
                 use std::num::FpCategory as Fp;
                 #[allow(unused)]
@@ -446,6 +459,30 @@ float_test! {
     }
 }
 
+float_test! {
+    name: is_normal,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+        f128: #[cfg(any(miri, target_has_reliable_f128))],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        let zero: Float = 0.0;
+        let neg_zero: Float = -0.0;
+        let one : Float = 1.0;
+        assert!(!nan.is_normal());
+        assert!(!inf.is_normal());
+        assert!(!neg_inf.is_normal());
+        assert!(!zero.is_normal());
+        assert!(!neg_zero.is_normal());
+        assert!(one.is_normal());
+        assert!(Float::MIN_POSITIVE_NORMAL.is_normal());
+        assert!(!Float::MAX_SUBNORMAL.is_normal());
+    }
+}
+
 float_test! {
     name: min,
     attrs: {
-- 
cgit 1.4.1-3-g733a5


From 79769f2d5babdfc8ca0c88045fdedcf312a3d83d Mon Sep 17 00:00:00 2001
From: Roger Curley <rocurley@gmail.com>
Date: Thu, 10 Jul 2025 12:08:14 -0400
Subject: Consolidate classify tests

---
 library/coretests/tests/floats/f128.rs | 18 ------------------
 library/coretests/tests/floats/f16.rs  | 18 ------------------
 library/coretests/tests/floats/f32.rs  | 18 ------------------
 library/coretests/tests/floats/f64.rs  | 17 -----------------
 library/coretests/tests/floats/mod.rs  | 23 +++++++++++++++++++++++
 5 files changed, 23 insertions(+), 71 deletions(-)

diff --git a/library/coretests/tests/floats/f128.rs b/library/coretests/tests/floats/f128.rs
index b741906a6e9..36d6a20a944 100644
--- a/library/coretests/tests/floats/f128.rs
+++ b/library/coretests/tests/floats/f128.rs
@@ -2,7 +2,6 @@
 #![cfg(target_has_reliable_f128)]
 
 use std::f128::consts;
-use std::num::FpCategory as Fp;
 
 use super::{assert_approx_eq, assert_biteq};
 
@@ -40,23 +39,6 @@ const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_classify() {
-    let nan: f128 = f128::NAN;
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    let zero: f128 = 0.0f128;
-    let neg_zero: f128 = -0.0;
-    assert_eq!(nan.classify(), Fp::Nan);
-    assert_eq!(inf.classify(), Fp::Infinite);
-    assert_eq!(neg_inf.classify(), Fp::Infinite);
-    assert_eq!(zero.classify(), Fp::Zero);
-    assert_eq!(neg_zero.classify(), Fp::Zero);
-    assert_eq!(1f128.classify(), Fp::Normal);
-    assert_eq!(1e-4931f128.classify(), Fp::Normal);
-    assert_eq!(1e-4932f128.classify(), Fp::Subnormal);
-}
-
 #[test]
 #[cfg(any(miri, target_has_reliable_f128_math))]
 fn test_abs() {
diff --git a/library/coretests/tests/floats/f16.rs b/library/coretests/tests/floats/f16.rs
index da6414fc244..351c008a37b 100644
--- a/library/coretests/tests/floats/f16.rs
+++ b/library/coretests/tests/floats/f16.rs
@@ -2,7 +2,6 @@
 #![cfg(target_has_reliable_f16)]
 
 use std::f16::consts;
-use std::num::FpCategory as Fp;
 
 use super::{assert_approx_eq, assert_biteq};
 
@@ -46,23 +45,6 @@ const NAN_MASK2: u16 = 0x0155;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-fn test_classify() {
-    let nan: f16 = f16::NAN;
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    let zero: f16 = 0.0f16;
-    let neg_zero: f16 = -0.0;
-    assert_eq!(nan.classify(), Fp::Nan);
-    assert_eq!(inf.classify(), Fp::Infinite);
-    assert_eq!(neg_inf.classify(), Fp::Infinite);
-    assert_eq!(zero.classify(), Fp::Zero);
-    assert_eq!(neg_zero.classify(), Fp::Zero);
-    assert_eq!(1f16.classify(), Fp::Normal);
-    assert_eq!(1e-4f16.classify(), Fp::Normal);
-    assert_eq!(1e-5f16.classify(), Fp::Subnormal);
-}
-
 #[test]
 #[cfg(any(miri, target_has_reliable_f16_math))]
 fn test_abs() {
diff --git a/library/coretests/tests/floats/f32.rs b/library/coretests/tests/floats/f32.rs
index 3464930b72f..267b0e4e294 100644
--- a/library/coretests/tests/floats/f32.rs
+++ b/library/coretests/tests/floats/f32.rs
@@ -1,6 +1,5 @@
 use core::f32;
 use core::f32::consts;
-use core::num::FpCategory as Fp;
 
 use super::{assert_approx_eq, assert_biteq};
 
@@ -30,23 +29,6 @@ const NAN_MASK2: u32 = 0x0055_5555;
 /// They serve as a way to get an idea of the real precision of floating point operations on different platforms.
 const APPROX_DELTA: f32 = if cfg!(miri) { 1e-4 } else { 1e-6 };
 
-#[test]
-fn test_classify() {
-    let nan: f32 = f32::NAN;
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    let zero: f32 = 0.0f32;
-    let neg_zero: f32 = -0.0;
-    assert_eq!(nan.classify(), Fp::Nan);
-    assert_eq!(inf.classify(), Fp::Infinite);
-    assert_eq!(neg_inf.classify(), Fp::Infinite);
-    assert_eq!(zero.classify(), Fp::Zero);
-    assert_eq!(neg_zero.classify(), Fp::Zero);
-    assert_eq!(1f32.classify(), Fp::Normal);
-    assert_eq!(1e-37f32.classify(), Fp::Normal);
-    assert_eq!(1e-38f32.classify(), Fp::Subnormal);
-}
-
 #[test]
 fn test_abs() {
     assert_biteq!(f32::INFINITY.abs(), f32::INFINITY);
diff --git a/library/coretests/tests/floats/f64.rs b/library/coretests/tests/floats/f64.rs
index 917dae1b6c6..735b7a76515 100644
--- a/library/coretests/tests/floats/f64.rs
+++ b/library/coretests/tests/floats/f64.rs
@@ -1,6 +1,5 @@
 use core::f64;
 use core::f64::consts;
-use core::num::FpCategory as Fp;
 
 use super::{assert_approx_eq, assert_biteq};
 
@@ -25,22 +24,6 @@ const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
 /// Second pattern over the mantissa
 const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
 
-#[test]
-fn test_classify() {
-    let nan: f64 = f64::NAN;
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    let zero: f64 = 0.0f64;
-    let neg_zero: f64 = -0.0;
-    assert_eq!(nan.classify(), Fp::Nan);
-    assert_eq!(inf.classify(), Fp::Infinite);
-    assert_eq!(neg_inf.classify(), Fp::Infinite);
-    assert_eq!(zero.classify(), Fp::Zero);
-    assert_eq!(neg_zero.classify(), Fp::Zero);
-    assert_eq!(1e-307f64.classify(), Fp::Normal);
-    assert_eq!(1e-308f64.classify(), Fp::Subnormal);
-}
-
 #[test]
 fn test_abs() {
     assert_biteq!(f64::INFINITY.abs(), f64::INFINITY);
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index b1686514a12..43431bba695 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -483,6 +483,29 @@ float_test! {
     }
 }
 
+float_test! {
+    name: classify,
+    attrs: {
+        f16: #[cfg(any(miri, target_has_reliable_f16))],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        let zero: Float = 0.0;
+        let neg_zero: Float = -0.0;
+        let one: Float = 1.0;
+        assert!(matches!(nan.classify(), Fp::Nan));
+        assert!(matches!(inf.classify(), Fp::Infinite));
+        assert!(matches!(neg_inf.classify(), Fp::Infinite));
+        assert!(matches!(zero.classify(), Fp::Zero));
+        assert!(matches!(neg_zero.classify(), Fp::Zero));
+        assert!(matches!(one.classify(), Fp::Normal));
+        assert!(matches!(Float::MIN_POSITIVE_NORMAL.classify(), Fp::Normal));
+        assert!(matches!(Float::MAX_SUBNORMAL.classify(), Fp::Subnormal));
+    }
+}
+
 float_test! {
     name: min,
     attrs: {
-- 
cgit 1.4.1-3-g733a5


From f15dfa85cc77df29b40c6b68328780c9075e09c2 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Fri, 11 Jul 2025 23:44:49 +0900
Subject: Add a memory map bound check assertion on rendering const slice

---
 src/tools/rust-analyzer/crates/hir-ty/src/display.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

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 61d62650453..b3760e3a382 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -795,6 +795,14 @@ fn render_const_scalar(
                 let Some(bytes) = memory_map.get(addr, size_one * count) else {
                     return f.write_str("<ref-data-not-available>");
                 };
+                let expected_len = count * size_one;
+                if bytes.len() < expected_len {
+                    never!(
+                        "Memory map size is too small. Expected {expected_len}, got {}",
+                        bytes.len(),
+                    );
+                    return f.write_str("<layout-error>");
+                }
                 f.write_str("&[")?;
                 let mut first = true;
                 for i in 0..count {
-- 
cgit 1.4.1-3-g733a5


From 2f05fa6fffb857c08edd0af2dc69f05fa1f02703 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Fri, 11 Jul 2025 17:02:24 +0200
Subject: Fix ICE for parsed attributes with longer path not handled by
 CheckAttrVisitor

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>
---
 Cargo.lock                                          |  1 +
 compiler/rustc_attr_parsing/src/context.rs          |  5 +++++
 compiler/rustc_passes/Cargo.toml                    |  1 +
 compiler/rustc_passes/src/check_attr.rs             | 11 ++++++++++-
 tests/ui/attributes/builtin-attribute-prefix.rs     |  8 ++++++++
 tests/ui/attributes/builtin-attribute-prefix.stderr | 15 +++++++++++++++
 6 files changed, 40 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/attributes/builtin-attribute-prefix.rs
 create mode 100644 tests/ui/attributes/builtin-attribute-prefix.stderr

diff --git a/Cargo.lock b/Cargo.lock
index 271a2f7962c..98a78b8495b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4349,6 +4349,7 @@ dependencies = [
  "rustc_ast_lowering",
  "rustc_ast_pretty",
  "rustc_attr_data_structures",
+ "rustc_attr_parsing",
  "rustc_data_structures",
  "rustc_errors",
  "rustc_expand",
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index dbe1a5b2ad0..737fe6ba081 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -718,6 +718,11 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         attributes
     }
 
+    /// Returns whether there is a parser for an attribute with this name
+    pub fn is_parsed_attribute(path: &[Symbol]) -> bool {
+        Late::parsers().0.contains_key(path)
+    }
+
     fn lower_attr_args(&self, args: &ast::AttrArgs, lower_span: impl Fn(Span) -> Span) -> AttrArgs {
         match args {
             ast::AttrArgs::Empty => AttrArgs::Empty,
diff --git a/compiler/rustc_passes/Cargo.toml b/compiler/rustc_passes/Cargo.toml
index b9167489076..503fc98da76 100644
--- a/compiler/rustc_passes/Cargo.toml
+++ b/compiler/rustc_passes/Cargo.toml
@@ -10,6 +10,7 @@ rustc_ast = { path = "../rustc_ast" }
 rustc_ast_lowering = { path = "../rustc_ast_lowering" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_attr_data_structures = { path = "../rustc_attr_data_structures" }
+rustc_attr_parsing = { path = "../rustc_attr_parsing" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_expand = { path = "../rustc_expand" }
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 0aa6a2b41cf..3a22b19683c 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -7,10 +7,12 @@
 
 use std::cell::Cell;
 use std::collections::hash_map::Entry;
+use std::slice;
 
 use rustc_abi::{Align, ExternAbi, Size};
 use rustc_ast::{AttrStyle, LitKind, MetaItemInner, MetaItemKind, ast};
 use rustc_attr_data_structures::{AttributeKind, InlineAttr, ReprAttr, find_attr};
+use rustc_attr_parsing::{AttributeParser, Late};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Applicability, DiagCtxtHandle, IntoDiagArg, MultiSpan, StashKey};
 use rustc_feature::{AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute};
@@ -373,11 +375,18 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             | sym::custom_mir,
                             ..
                         ] => {}
-                        [name, ..] => {
+                        [name, rest@..] => {
                             match BUILTIN_ATTRIBUTE_MAP.get(name) {
                                 // checked below
                                 Some(BuiltinAttribute { type_: AttributeType::CrateLevel, .. }) => {}
                                 Some(_) => {
+                                    if rest.len() > 0 && AttributeParser::<Late>::is_parsed_attribute(slice::from_ref(name)) {
+                                        // Check if we tried to use a builtin attribute as an attribute namespace, like `#[must_use::skip]`.
+                                        // This check is here to solve https://github.com/rust-lang/rust/issues/137590
+                                        // An error is already produced for this case elsewhere
+                                        continue
+                                    }
+
                                     // FIXME: differentiate between unstable and internal attributes just
                                     // like we do with features instead of just accepting `rustc_`
                                     // attributes by name. That should allow trimming the above list, too.
diff --git a/tests/ui/attributes/builtin-attribute-prefix.rs b/tests/ui/attributes/builtin-attribute-prefix.rs
new file mode 100644
index 00000000000..d184c6d008d
--- /dev/null
+++ b/tests/ui/attributes/builtin-attribute-prefix.rs
@@ -0,0 +1,8 @@
+// Regression test for https://github.com/rust-lang/rust/issues/143789
+#[must_use::skip]
+//~^ ERROR failed to resolve: use of unresolved module or unlinked crate `must_use`
+fn main() { }
+
+// Regression test for https://github.com/rust-lang/rust/issues/137590
+struct S(#[stable::skip] u8, u16, u32);
+//~^ ERROR failed to resolve: use of unresolved module or unlinked crate `stable`
diff --git a/tests/ui/attributes/builtin-attribute-prefix.stderr b/tests/ui/attributes/builtin-attribute-prefix.stderr
new file mode 100644
index 00000000000..a16080c003f
--- /dev/null
+++ b/tests/ui/attributes/builtin-attribute-prefix.stderr
@@ -0,0 +1,15 @@
+error[E0433]: failed to resolve: use of unresolved module or unlinked crate `stable`
+  --> $DIR/builtin-attribute-prefix.rs:7:12
+   |
+LL | struct S(#[stable::skip] u8, u16, u32);
+   |            ^^^^^^ use of unresolved module or unlinked crate `stable`
+
+error[E0433]: failed to resolve: use of unresolved module or unlinked crate `must_use`
+  --> $DIR/builtin-attribute-prefix.rs:2:3
+   |
+LL | #[must_use::skip]
+   |   ^^^^^^^^ use of unresolved module or unlinked crate `must_use`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0433`.
-- 
cgit 1.4.1-3-g733a5


From cdbe44d8069d2f352c6dea560574a6fa9d9df5ae Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Fri, 11 Jul 2025 20:33:36 +0530
Subject: Use short command method directly from fingerprint

---
 src/bootstrap/src/utils/tracing.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bootstrap/src/utils/tracing.rs b/src/bootstrap/src/utils/tracing.rs
index 99849341dc3..58d127dfb79 100644
--- a/src/bootstrap/src/utils/tracing.rs
+++ b/src/bootstrap/src/utils/tracing.rs
@@ -58,7 +58,7 @@ macro_rules! trace_cmd {
                 target: "COMMAND",
                 ::tracing::Level::TRACE,
                 "executing command",
-                cmd = $cmd.format_short_cmd(),
+                cmd = $cmd.fingerprint().format_short_cmd(),
                 full_cmd = ?$cmd
             ).entered()
         }
-- 
cgit 1.4.1-3-g733a5


From 0c81bf80e031ec000ddaab1578cc39a40364a54d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 11 Jul 2025 17:35:57 +0200
Subject: fix PartialEq const feature name and const_cmp tracking issue

---
 library/core/src/cmp.rs                                      | 12 ++++++------
 tests/ui/const-generics/issues/issue-90318.rs                |  2 +-
 tests/ui/consts/const_cmp_type_id.rs                         |  2 +-
 tests/ui/consts/const_transmute_type_id.rs                   |  2 +-
 tests/ui/consts/const_transmute_type_id2.rs                  |  2 +-
 tests/ui/consts/const_transmute_type_id3.rs                  |  2 +-
 tests/ui/consts/const_transmute_type_id4.rs                  |  2 +-
 tests/ui/consts/issue-73976-monomorphic.rs                   |  1 +
 tests/ui/consts/issue-90870.rs                               |  6 +++---
 tests/ui/consts/issue-90870.stderr                           | 12 ++++++------
 tests/ui/traits/const-traits/call-const-trait-method-pass.rs |  2 +-
 tests/ui/traits/const-traits/call-generic-in-impl.rs         |  2 +-
 tests/ui/traits/const-traits/call-generic-method-chain.rs    |  2 +-
 .../ui/traits/const-traits/call-generic-method-dup-bound.rs  |  2 +-
 tests/ui/traits/const-traits/call-generic-method-fail.rs     |  2 +-
 tests/ui/traits/const-traits/call-generic-method-pass.rs     |  2 +-
 .../const-traits/const_derives/derive-const-with-params.rs   |  2 +-
 17 files changed, 29 insertions(+), 28 deletions(-)

diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index b1ca3701fa5..03b120fbf0c 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -248,7 +248,7 @@ use crate::ops::ControlFlow;
 )]
 #[rustc_diagnostic_item = "PartialEq"]
 #[const_trait]
-#[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 pub trait PartialEq<Rhs: PointeeSized = Self>: PointeeSized {
     /// Tests for `self` and `other` values to be equal, and is used by `==`.
     #[must_use]
@@ -1809,7 +1809,7 @@ mod impls {
     macro_rules! partial_eq_impl {
         ($($t:ty)*) => ($(
             #[stable(feature = "rust1", since = "1.0.0")]
-            #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
+            #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
             impl const PartialEq for $t {
                 #[inline]
                 fn eq(&self, other: &Self) -> bool { *self == *other }
@@ -2017,7 +2017,7 @@ mod impls {
     // & pointers
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     impl<A: PointeeSized, B: PointeeSized> const PartialEq<&B> for &A
     where
         A: ~const PartialEq<B>,
@@ -2089,7 +2089,7 @@ mod impls {
     // &mut pointers
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     impl<A: PointeeSized, B: PointeeSized> const PartialEq<&mut B> for &mut A
     where
         A: ~const PartialEq<B>,
@@ -2159,7 +2159,7 @@ mod impls {
     impl<A: PointeeSized> Eq for &mut A where A: Eq {}
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     impl<A: PointeeSized, B: PointeeSized> const PartialEq<&mut B> for &A
     where
         A: ~const PartialEq<B>,
@@ -2175,7 +2175,7 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_cmp", issue = "92391")]
+    #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     impl<A: PointeeSized, B: PointeeSized> const PartialEq<&B> for &mut A
     where
         A: ~const PartialEq<B>,
diff --git a/tests/ui/const-generics/issues/issue-90318.rs b/tests/ui/const-generics/issues/issue-90318.rs
index dfba90a5575..239171217eb 100644
--- a/tests/ui/const-generics/issues/issue-90318.rs
+++ b/tests/ui/const-generics/issues/issue-90318.rs
@@ -1,6 +1,6 @@
 #![feature(const_type_id)]
 #![feature(generic_const_exprs)]
-#![feature(const_trait_impl)]
+#![feature(const_trait_impl, const_cmp)]
 #![feature(core_intrinsics)]
 #![allow(incomplete_features)]
 
diff --git a/tests/ui/consts/const_cmp_type_id.rs b/tests/ui/consts/const_cmp_type_id.rs
index def615bd92b..db2d50f4d22 100644
--- a/tests/ui/consts/const_cmp_type_id.rs
+++ b/tests/ui/consts/const_cmp_type_id.rs
@@ -1,5 +1,5 @@
 //@ compile-flags: -Znext-solver
-#![feature(const_type_id, const_trait_impl)]
+#![feature(const_type_id, const_trait_impl, const_cmp)]
 
 use std::any::TypeId;
 
diff --git a/tests/ui/consts/const_transmute_type_id.rs b/tests/ui/consts/const_transmute_type_id.rs
index 56ead6a622b..a2d4cf37830 100644
--- a/tests/ui/consts/const_transmute_type_id.rs
+++ b/tests/ui/consts/const_transmute_type_id.rs
@@ -1,4 +1,4 @@
-#![feature(const_type_id, const_trait_impl)]
+#![feature(const_type_id, const_trait_impl, const_cmp)]
 
 use std::any::TypeId;
 
diff --git a/tests/ui/consts/const_transmute_type_id2.rs b/tests/ui/consts/const_transmute_type_id2.rs
index e29cf8171ac..3ceb2b942b0 100644
--- a/tests/ui/consts/const_transmute_type_id2.rs
+++ b/tests/ui/consts/const_transmute_type_id2.rs
@@ -1,6 +1,6 @@
 //@ normalize-stderr: "0x(ff)+" -> "<u128::MAX>"
 
-#![feature(const_type_id, const_trait_impl)]
+#![feature(const_type_id, const_trait_impl, const_cmp)]
 
 use std::any::TypeId;
 
diff --git a/tests/ui/consts/const_transmute_type_id3.rs b/tests/ui/consts/const_transmute_type_id3.rs
index a870d6e7e80..ed5ff769701 100644
--- a/tests/ui/consts/const_transmute_type_id3.rs
+++ b/tests/ui/consts/const_transmute_type_id3.rs
@@ -1,4 +1,4 @@
-#![feature(const_type_id, const_trait_impl)]
+#![feature(const_type_id, const_trait_impl, const_cmp)]
 
 use std::any::TypeId;
 
diff --git a/tests/ui/consts/const_transmute_type_id4.rs b/tests/ui/consts/const_transmute_type_id4.rs
index bc71f961a51..22a607e9e0e 100644
--- a/tests/ui/consts/const_transmute_type_id4.rs
+++ b/tests/ui/consts/const_transmute_type_id4.rs
@@ -1,4 +1,4 @@
-#![feature(const_type_id, const_trait_impl)]
+#![feature(const_type_id, const_trait_impl, const_cmp)]
 
 use std::any::TypeId;
 
diff --git a/tests/ui/consts/issue-73976-monomorphic.rs b/tests/ui/consts/issue-73976-monomorphic.rs
index 3bfdb397afb..5f364cd995e 100644
--- a/tests/ui/consts/issue-73976-monomorphic.rs
+++ b/tests/ui/consts/issue-73976-monomorphic.rs
@@ -8,6 +8,7 @@
 #![feature(const_type_id)]
 #![feature(const_type_name)]
 #![feature(const_trait_impl)]
+#![feature(const_cmp)]
 
 use std::any::{self, TypeId};
 
diff --git a/tests/ui/consts/issue-90870.rs b/tests/ui/consts/issue-90870.rs
index f807ae75ee5..053763b9f89 100644
--- a/tests/ui/consts/issue-90870.rs
+++ b/tests/ui/consts/issue-90870.rs
@@ -3,9 +3,9 @@
 #![allow(dead_code)]
 
 const fn f(a: &u8, b: &u8) -> bool {
-    //~^ HELP: add `#![feature(const_trait_impl)]` to the crate attributes to enable
-    //~| HELP: add `#![feature(const_trait_impl)]` to the crate attributes to enable
-    //~| HELP: add `#![feature(const_trait_impl)]` to the crate attributes to enable
+    //~^ HELP: add `#![feature(const_cmp)]` to the crate attributes to enable
+    //~| HELP: add `#![feature(const_cmp)]` to the crate attributes to enable
+    //~| HELP: add `#![feature(const_cmp)]` to the crate attributes to enable
     a == b
     //~^ ERROR: cannot call conditionally-const operator in constant functions
     //~| ERROR: `PartialEq` is not yet stable as a const trait
diff --git a/tests/ui/consts/issue-90870.stderr b/tests/ui/consts/issue-90870.stderr
index 8d6f21fd82f..60993f25864 100644
--- a/tests/ui/consts/issue-90870.stderr
+++ b/tests/ui/consts/issue-90870.stderr
@@ -19,9 +19,9 @@ error: `PartialEq` is not yet stable as a const trait
 LL |     a == b
    |     ^^^^^^
    |
-help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
+help: add `#![feature(const_cmp)]` to the crate attributes to enable
    |
-LL + #![feature(const_trait_impl)]
+LL + #![feature(const_cmp)]
    |
 
 error[E0658]: cannot call conditionally-const operator in constant functions
@@ -45,9 +45,9 @@ error: `PartialEq` is not yet stable as a const trait
 LL |     a == b
    |     ^^^^^^
    |
-help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
+help: add `#![feature(const_cmp)]` to the crate attributes to enable
    |
-LL + #![feature(const_trait_impl)]
+LL + #![feature(const_cmp)]
    |
 
 error[E0658]: cannot call conditionally-const operator in constant functions
@@ -71,9 +71,9 @@ error: `PartialEq` is not yet stable as a const trait
 LL |         if l == r {
    |            ^^^^^^
    |
-help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
+help: add `#![feature(const_cmp)]` to the crate attributes to enable
    |
-LL + #![feature(const_trait_impl)]
+LL + #![feature(const_cmp)]
    |
 
 error: aborting due to 6 previous errors
diff --git a/tests/ui/traits/const-traits/call-const-trait-method-pass.rs b/tests/ui/traits/const-traits/call-const-trait-method-pass.rs
index d66a11490c5..2d9c2ca0861 100644
--- a/tests/ui/traits/const-traits/call-const-trait-method-pass.rs
+++ b/tests/ui/traits/const-traits/call-const-trait-method-pass.rs
@@ -1,4 +1,4 @@
-#![feature(const_trait_impl, const_ops)]
+#![feature(const_trait_impl, const_ops, const_cmp)]
 //@ check-pass
 
 struct Int(i32);
diff --git a/tests/ui/traits/const-traits/call-generic-in-impl.rs b/tests/ui/traits/const-traits/call-generic-in-impl.rs
index f38590fa3c0..72fc80c50e0 100644
--- a/tests/ui/traits/const-traits/call-generic-in-impl.rs
+++ b/tests/ui/traits/const-traits/call-generic-in-impl.rs
@@ -1,5 +1,5 @@
 //@ check-pass
-#![feature(const_trait_impl)]
+#![feature(const_trait_impl, const_cmp)]
 
 #[const_trait]
 trait MyPartialEq {
diff --git a/tests/ui/traits/const-traits/call-generic-method-chain.rs b/tests/ui/traits/const-traits/call-generic-method-chain.rs
index 1ad71c424a3..db053b48079 100644
--- a/tests/ui/traits/const-traits/call-generic-method-chain.rs
+++ b/tests/ui/traits/const-traits/call-generic-method-chain.rs
@@ -3,7 +3,7 @@
 //@ compile-flags: -Znext-solver
 //@ check-pass
 
-#![feature(const_trait_impl)]
+#![feature(const_trait_impl, const_cmp)]
 
 struct S;
 
diff --git a/tests/ui/traits/const-traits/call-generic-method-dup-bound.rs b/tests/ui/traits/const-traits/call-generic-method-dup-bound.rs
index 58f293b5ac5..5913cbf8a21 100644
--- a/tests/ui/traits/const-traits/call-generic-method-dup-bound.rs
+++ b/tests/ui/traits/const-traits/call-generic-method-dup-bound.rs
@@ -1,7 +1,7 @@
 //@ compile-flags: -Znext-solver
 //@ check-pass
 
-#![feature(const_trait_impl)]
+#![feature(const_trait_impl, const_cmp)]
 
 struct S;
 
diff --git a/tests/ui/traits/const-traits/call-generic-method-fail.rs b/tests/ui/traits/const-traits/call-generic-method-fail.rs
index 4528f3b122f..6744176d40a 100644
--- a/tests/ui/traits/const-traits/call-generic-method-fail.rs
+++ b/tests/ui/traits/const-traits/call-generic-method-fail.rs
@@ -1,5 +1,5 @@
 //@ compile-flags: -Znext-solver
-#![feature(const_trait_impl)]
+#![feature(const_trait_impl, const_cmp)]
 
 pub const fn equals_self<T: PartialEq>(t: &T) -> bool {
     *t == *t
diff --git a/tests/ui/traits/const-traits/call-generic-method-pass.rs b/tests/ui/traits/const-traits/call-generic-method-pass.rs
index aa52a7b9e47..01c5860c8ec 100644
--- a/tests/ui/traits/const-traits/call-generic-method-pass.rs
+++ b/tests/ui/traits/const-traits/call-generic-method-pass.rs
@@ -3,7 +3,7 @@
 //@ compile-flags: -Znext-solver
 //@ check-pass
 
-#![feature(const_trait_impl)]
+#![feature(const_trait_impl, const_cmp)]
 
 struct S;
 
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-with-params.rs b/tests/ui/traits/const-traits/const_derives/derive-const-with-params.rs
index b39f97b5938..bbc0faee10f 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-with-params.rs
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-with-params.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 
 #![feature(derive_const)]
-#![feature(const_trait_impl)]
+#![feature(const_trait_impl, const_cmp)]
 
 #[derive_const(PartialEq)]
 pub struct Reverse<T>(T);
-- 
cgit 1.4.1-3-g733a5


From b94083e87fcbacaf9d76176742d2fe984b5aaae4 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 11 Jul 2025 17:57:46 +0200
Subject: fix const_ops tracking issue

---
 library/core/src/ops/arith.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/library/core/src/ops/arith.rs b/library/core/src/ops/arith.rs
index e53c128efe0..7d44b1733b9 100644
--- a/library/core/src/ops/arith.rs
+++ b/library/core/src/ops/arith.rs
@@ -65,7 +65,7 @@
 /// ```
 #[lang = "add"]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+#[rustc_const_unstable(feature = "const_ops", issue = "143802")]
 #[rustc_on_unimplemented(
     on(all(Self = "{integer}", Rhs = "{float}"), message = "cannot add a float to an integer",),
     on(all(Self = "{float}", Rhs = "{integer}"), message = "cannot add an integer to a float",),
@@ -96,7 +96,7 @@ pub trait Add<Rhs = Self> {
 macro_rules! add_impl {
     ($($t:ty)*) => ($(
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+        #[rustc_const_unstable(feature = "const_ops", issue = "143802")]
         impl const Add for $t {
             type Output = $t;
 
@@ -179,7 +179,7 @@ add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128
 /// ```
 #[lang = "sub"]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+#[rustc_const_unstable(feature = "const_ops", issue = "143802")]
 #[rustc_on_unimplemented(
     message = "cannot subtract `{Rhs}` from `{Self}`",
     label = "no implementation for `{Self} - {Rhs}`",
@@ -208,7 +208,7 @@ pub trait Sub<Rhs = Self> {
 macro_rules! sub_impl {
     ($($t:ty)*) => ($(
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+        #[rustc_const_unstable(feature = "const_ops", issue = "143802")]
         impl const Sub for $t {
             type Output = $t;
 
@@ -313,7 +313,7 @@ sub_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128
 /// ```
 #[lang = "mul"]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+#[rustc_const_unstable(feature = "const_ops", issue = "143802")]
 #[diagnostic::on_unimplemented(
     message = "cannot multiply `{Self}` by `{Rhs}`",
     label = "no implementation for `{Self} * {Rhs}`"
@@ -341,7 +341,7 @@ pub trait Mul<Rhs = Self> {
 macro_rules! mul_impl {
     ($($t:ty)*) => ($(
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+        #[rustc_const_unstable(feature = "const_ops", issue = "143802")]
         impl const Mul for $t {
             type Output = $t;
 
@@ -450,7 +450,7 @@ mul_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128
 /// ```
 #[lang = "div"]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+#[rustc_const_unstable(feature = "const_ops", issue = "143802")]
 #[diagnostic::on_unimplemented(
     message = "cannot divide `{Self}` by `{Rhs}`",
     label = "no implementation for `{Self} / {Rhs}`"
@@ -484,7 +484,7 @@ macro_rules! div_impl_integer {
         ///
         #[doc = $panic]
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+        #[rustc_const_unstable(feature = "const_ops", issue = "143802")]
         impl const Div for $t {
             type Output = $t;
 
@@ -505,7 +505,7 @@ div_impl_integer! {
 macro_rules! div_impl_float {
     ($($t:ty)*) => ($(
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+        #[rustc_const_unstable(feature = "const_ops", issue = "143802")]
         impl const Div for $t {
             type Output = $t;
 
@@ -556,7 +556,7 @@ div_impl_float! { f16 f32 f64 f128 }
 /// ```
 #[lang = "rem"]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+#[rustc_const_unstable(feature = "const_ops", issue = "143802")]
 #[diagnostic::on_unimplemented(
     message = "cannot calculate the remainder of `{Self}` divided by `{Rhs}`",
     label = "no implementation for `{Self} % {Rhs}`"
@@ -590,7 +590,7 @@ macro_rules! rem_impl_integer {
         ///
         #[doc = $panic]
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+        #[rustc_const_unstable(feature = "const_ops", issue = "143802")]
         impl const Rem for $t {
             type Output = $t;
 
@@ -626,7 +626,7 @@ macro_rules! rem_impl_float {
         /// assert_eq!(x % y, remainder);
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
+        #[rustc_const_unstable(feature = "const_ops", issue = "143802")]
         impl const Rem for $t {
             type Output = $t;
 
-- 
cgit 1.4.1-3-g733a5


From d004abb4d3d7a4c50c54ffb3c4f227ff0d689f03 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Fri, 11 Jul 2025 20:36:13 +0530
Subject: remove format short command and push format short command method
 inside fingerprint impl

---
 src/bootstrap/src/utils/exec.rs    | 29 ++++-------------------------
 src/bootstrap/src/utils/tracing.rs |  2 --
 2 files changed, 4 insertions(+), 27 deletions(-)

diff --git a/src/bootstrap/src/utils/exec.rs b/src/bootstrap/src/utils/exec.rs
index c5bafda88c4..ebc18f11a05 100644
--- a/src/bootstrap/src/utils/exec.rs
+++ b/src/bootstrap/src/utils/exec.rs
@@ -76,8 +76,10 @@ pub struct CommandFingerprint {
     cwd: Option<PathBuf>,
 }
 
-impl FormatShortCmd for CommandFingerprint {
-    fn format_short_cmd(&self) -> String {
+impl CommandFingerprint {
+    /// Helper method to format both Command and BootstrapCommand as a short execution line,
+    /// without all the other details (e.g. environment variables).
+    pub fn format_short_cmd(&self) -> String {
         let program = Path::new(&self.program);
         let mut line = vec![program.file_name().unwrap().to_str().unwrap().to_owned()];
         line.extend(self.args.iter().map(|arg| arg.to_string_lossy().into_owned()));
@@ -545,29 +547,6 @@ impl Default for CommandOutput {
     }
 }
 
-/// Helper trait to format both Command and BootstrapCommand as a short execution line,
-/// without all the other details (e.g. environment variables).
-pub trait FormatShortCmd {
-    fn format_short_cmd(&self) -> String;
-}
-
-#[cfg(feature = "tracing")]
-impl FormatShortCmd for BootstrapCommand {
-    fn format_short_cmd(&self) -> String {
-        self.command.format_short_cmd()
-    }
-}
-
-#[cfg(feature = "tracing")]
-impl FormatShortCmd for Command {
-    fn format_short_cmd(&self) -> String {
-        let program = Path::new(self.get_program());
-        let mut line = vec![program.file_name().unwrap().to_str().unwrap()];
-        line.extend(self.get_args().map(|arg| arg.to_str().unwrap()));
-        line.join(" ")
-    }
-}
-
 #[derive(Clone, Default)]
 pub struct ExecutionContext {
     dry_run: DryRun,
diff --git a/src/bootstrap/src/utils/tracing.rs b/src/bootstrap/src/utils/tracing.rs
index 58d127dfb79..109407bc5f2 100644
--- a/src/bootstrap/src/utils/tracing.rs
+++ b/src/bootstrap/src/utils/tracing.rs
@@ -52,8 +52,6 @@ macro_rules! error {
 macro_rules! trace_cmd {
     ($cmd:expr) => {
         {
-            use $crate::utils::exec::FormatShortCmd;
-
             ::tracing::span!(
                 target: "COMMAND",
                 ::tracing::Level::TRACE,
-- 
cgit 1.4.1-3-g733a5


From 2268e069c0e6effc5ee17ea37b95e444e0773759 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 11 Jul 2025 13:01:45 -0400
Subject: Update cargo

---
 src/tools/cargo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/cargo b/src/tools/cargo
index 930b4f62cfc..eabb4cd923d 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 930b4f62cfcd1f0eabdb30a56d91bf6844b739bf
+Subproject commit eabb4cd923deb73e714f7ad3f5234d68ca284dbe
-- 
cgit 1.4.1-3-g733a5


From 5e203851f7203d5ad4298d54c50008f24a34b793 Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Wed, 9 Jul 2025 14:25:23 -0700
Subject: random: Provide a `Distribution<T>` trait

This will let people make calls like random(1..=6), and allows for
future expansion to non-uniform distributions, as well as
floating-point.

For now, this is only implemented for `RangeFull`, to get the interface
in place. Subsequent commits will implement it for other range types.
---
 library/core/src/primitive_docs.rs |  2 --
 library/core/src/random.rs         | 47 ++++++++++++++++----------------------
 library/core/src/tuple.rs          | 11 ---------
 library/std/src/random.rs          | 24 ++++++-------------
 4 files changed, 27 insertions(+), 57 deletions(-)

diff --git a/library/core/src/primitive_docs.rs b/library/core/src/primitive_docs.rs
index 2c77c55745b..5bd80149a1d 100644
--- a/library/core/src/primitive_docs.rs
+++ b/library/core/src/primitive_docs.rs
@@ -1081,13 +1081,11 @@ mod prim_str {}
 /// * [`Debug`]
 /// * [`Default`]
 /// * [`Hash`]
-/// * [`Random`]
 /// * [`From<[T; N]>`][from]
 ///
 /// [from]: convert::From
 /// [`Debug`]: fmt::Debug
 /// [`Hash`]: hash::Hash
-/// [`Random`]: random::Random
 ///
 /// The following traits are implemented for tuples of any length. These traits have
 /// implementations that are automatically generated by the compiler, so are not limited by
diff --git a/library/core/src/random.rs b/library/core/src/random.rs
index 40338c3f4ac..8a51fb289d8 100644
--- a/library/core/src/random.rs
+++ b/library/core/src/random.rs
@@ -1,7 +1,6 @@
 //! Random value generation.
-//!
-//! The [`Random`] trait allows generating a random value for a type using a
-//! given [`RandomSource`].
+
+use crate::range::RangeFull;
 
 /// A source of randomness.
 #[unstable(feature = "random", issue = "130703")]
@@ -15,39 +14,33 @@ pub trait RandomSource {
     fn fill_bytes(&mut self, bytes: &mut [u8]);
 }
 
-/// A trait for getting a random value for a type.
-///
-/// **Warning:** Be careful when manipulating random values! The
-/// [`random`](Random::random) method on integers samples them with a uniform
-/// distribution, so a value of 1 is just as likely as [`i32::MAX`]. By using
-/// modulo operations, some of the resulting values can become more likely than
-/// others. Use audited crates when in doubt.
+/// A trait representing a distribution of random values for a type.
 #[unstable(feature = "random", issue = "130703")]
-pub trait Random: Sized {
-    /// Generates a random value.
-    fn random(source: &mut (impl RandomSource + ?Sized)) -> Self;
+pub trait Distribution<T> {
+    /// Samples a random value from the distribution, using the specified random source.
+    fn sample(&self, source: &mut (impl RandomSource + ?Sized)) -> T;
+}
+
+impl<T, DT: Distribution<T>> Distribution<T> for &DT {
+    fn sample(&self, source: &mut (impl RandomSource + ?Sized)) -> T {
+        (*self).sample(source)
+    }
 }
 
-impl Random for bool {
-    fn random(source: &mut (impl RandomSource + ?Sized)) -> Self {
-        u8::random(source) & 1 == 1
+impl Distribution<bool> for RangeFull {
+    fn sample(&self, source: &mut (impl RandomSource + ?Sized)) -> bool {
+        let byte: u8 = RangeFull.sample(source);
+        byte & 1 == 1
     }
 }
 
 macro_rules! impl_primitive {
     ($t:ty) => {
-        impl Random for $t {
-            /// Generates a random value.
-            ///
-            /// **Warning:** Be careful when manipulating the resulting value! This
-            /// method samples according to a uniform distribution, so a value of 1 is
-            /// just as likely as [`MAX`](Self::MAX). By using modulo operations, some
-            /// values can become more likely than others. Use audited crates when in
-            /// doubt.
-            fn random(source: &mut (impl RandomSource + ?Sized)) -> Self {
-                let mut bytes = (0 as Self).to_ne_bytes();
+        impl Distribution<$t> for RangeFull {
+            fn sample(&self, source: &mut (impl RandomSource + ?Sized)) -> $t {
+                let mut bytes = (0 as $t).to_ne_bytes();
                 source.fill_bytes(&mut bytes);
-                Self::from_ne_bytes(bytes)
+                <$t>::from_ne_bytes(bytes)
             }
         }
     };
diff --git a/library/core/src/tuple.rs b/library/core/src/tuple.rs
index 9cf08e74ff6..23a0a6877df 100644
--- a/library/core/src/tuple.rs
+++ b/library/core/src/tuple.rs
@@ -3,7 +3,6 @@
 use crate::cmp::Ordering::{self, *};
 use crate::marker::{ConstParamTy_, StructuralPartialEq, UnsizedConstParamTy};
 use crate::ops::ControlFlow::{self, Break, Continue};
-use crate::random::{Random, RandomSource};
 
 // Recursive macro for implementing n-ary tuple functions and operations
 //
@@ -131,16 +130,6 @@ macro_rules! tuple_impls {
             }
         }
 
-        maybe_tuple_doc! {
-            $($T)+ @
-            #[unstable(feature = "random", issue = "130703")]
-            impl<$($T: Random),+> Random for ($($T,)+) {
-                fn random(source: &mut (impl RandomSource + ?Sized)) -> Self {
-                    ($({ let x: $T = Random::random(source); x},)+)
-                }
-            }
-        }
-
         maybe_tuple_doc! {
             $($T)+ @
             #[stable(feature = "array_tuple_conv", since = "1.71.0")]
diff --git a/library/std/src/random.rs b/library/std/src/random.rs
index e7d4ab81df0..3994c5cfaf6 100644
--- a/library/std/src/random.rs
+++ b/library/std/src/random.rs
@@ -1,7 +1,4 @@
 //! Random value generation.
-//!
-//! The [`Random`] trait allows generating a random value for a type using a
-//! given [`RandomSource`].
 
 #[unstable(feature = "random", issue = "130703")]
 pub use core::random::*;
@@ -68,18 +65,11 @@ impl RandomSource for DefaultRandomSource {
     }
 }
 
-/// Generates a random value with the default random source.
+/// Generates a random value from a distribution, using the default random source.
 ///
-/// This is a convenience function for `T::random(&mut DefaultRandomSource)` and
-/// will sample according to the same distribution as the underlying [`Random`]
-/// trait implementation. See [`DefaultRandomSource`] for more information about
-/// how randomness is sourced.
-///
-/// **Warning:** Be careful when manipulating random values! The
-/// [`random`](Random::random) method on integers samples them with a uniform
-/// distribution, so a value of 1 is just as likely as [`i32::MAX`]. By using
-/// modulo operations, some of the resulting values can become more likely than
-/// others. Use audited crates when in doubt.
+/// This is a convenience function for `dist.sample(&mut DefaultRandomSource)` and will sample
+/// according to the same distribution as the underlying [`Distribution`] trait implementation. See
+/// [`DefaultRandomSource`] for more information about how randomness is sourced.
 ///
 /// # Examples
 ///
@@ -89,7 +79,7 @@ impl RandomSource for DefaultRandomSource {
 ///
 /// use std::random::random;
 ///
-/// let bits: u128 = random();
+/// let bits: u128 = random(..);
 /// let g1 = (bits >> 96) as u32;
 /// let g2 = (bits >> 80) as u16;
 /// let g3 = (0x4000 | (bits >> 64) & 0x0fff) as u16;
@@ -101,6 +91,6 @@ impl RandomSource for DefaultRandomSource {
 ///
 /// [version 4/variant 1 UUID]: https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)
 #[unstable(feature = "random", issue = "130703")]
-pub fn random<T: Random>() -> T {
-    T::random(&mut DefaultRandomSource)
+pub fn random<T>(dist: impl Distribution<T>) -> T {
+    dist.sample(&mut DefaultRandomSource)
 }
-- 
cgit 1.4.1-3-g733a5


From 900aa00584d58bf771b4d1b227be2ff453426234 Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Fri, 11 Jul 2025 11:13:47 -0700
Subject: Update miri for change to random API

---
 src/tools/miri/tests/pass/shims/random.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/tests/pass/shims/random.rs b/src/tools/miri/tests/pass/shims/random.rs
index ae75ebdcd3f..2a5c8993662 100644
--- a/src/tools/miri/tests/pass/shims/random.rs
+++ b/src/tools/miri/tests/pass/shims/random.rs
@@ -1,5 +1,5 @@
 #![feature(random)]
 
 fn main() {
-    let _x: i32 = std::random::random();
+    let _x: i32 = std::random::random(..);
 }
-- 
cgit 1.4.1-3-g733a5


From 7803c25deaa3f330a952a18c7c3d5ea3850e9ff7 Mon Sep 17 00:00:00 2001
From: lolbinarycat <binarycat@envs.net>
Date: Fri, 11 Jul 2025 13:39:39 -0500
Subject: directives.md: build-aux-docs does not work with aux-crate

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

diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index 839076b809d..63aa08c389c 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -59,7 +59,7 @@ not be exhaustive. Directives can generally be found by browsing the
 | `aux-crate`           | Like `aux-build` but makes available as extern prelude                                                | All except `run-make` | `<extern_prelude_name>=<path/to/aux/file.rs>` |
 | `aux-codegen-backend` | Similar to `aux-build` but pass the compiled dylib to `-Zcodegen-backend` when building the main file | `ui-fulldeps`         | Path to codegen backend file                  |
 | `proc-macro`          | Similar to `aux-build`, but for aux forces host and don't use `-Cprefer-dynamic`[^pm].                | All except `run-make` | Path to auxiliary proc-macro `.rs` file       |
-| `build-aux-docs`      | Build docs for auxiliaries as well                                                                    | All except `run-make` | N/A                                           |
+| `build-aux-docs`      | Build docs for auxiliaries as well.  Note that this only works with `aux-build`, not `aux-crate`.     | All except `run-make` | N/A                                           |
 
 [^pm]: please see the Auxiliary proc-macro section in the
     [compiletest](./compiletest.md) chapter for specifics.
-- 
cgit 1.4.1-3-g733a5


From 3751e133bca55dbec521ccb36132fa0bdbf10b88 Mon Sep 17 00:00:00 2001
From: okaneco <47607823+okaneco@users.noreply.github.com>
Date: Sat, 5 Jul 2025 22:26:40 -0400
Subject: slice: Mark `rotate_left`, `rotate_right` unstably const

---
 library/core/src/slice/mod.rs    |  6 ++++--
 library/core/src/slice/rotate.rs | 24 +++++++++++++++++-------
 2 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index dc09ba8d788..7df717751f5 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -3668,7 +3668,8 @@ impl<T> [T] {
     /// assert_eq!(a, ['a', 'c', 'd', 'e', 'b', 'f']);
     /// ```
     #[stable(feature = "slice_rotate", since = "1.26.0")]
-    pub fn rotate_left(&mut self, mid: usize) {
+    #[rustc_const_unstable(feature = "const_slice_rotate", issue = "143812")]
+    pub const fn rotate_left(&mut self, mid: usize) {
         assert!(mid <= self.len());
         let k = self.len() - mid;
         let p = self.as_mut_ptr();
@@ -3713,7 +3714,8 @@ impl<T> [T] {
     /// assert_eq!(a, ['a', 'e', 'b', 'c', 'd', 'f']);
     /// ```
     #[stable(feature = "slice_rotate", since = "1.26.0")]
-    pub fn rotate_right(&mut self, k: usize) {
+    #[rustc_const_unstable(feature = "const_slice_rotate", issue = "143812")]
+    pub const fn rotate_right(&mut self, k: usize) {
         assert!(k <= self.len());
         let mid = self.len() - k;
         let p = self.as_mut_ptr();
diff --git a/library/core/src/slice/rotate.rs b/library/core/src/slice/rotate.rs
index 80178f297ea..b3b64422884 100644
--- a/library/core/src/slice/rotate.rs
+++ b/library/core/src/slice/rotate.rs
@@ -1,5 +1,5 @@
 use crate::mem::{MaybeUninit, SizedTypeProperties};
-use crate::{cmp, ptr};
+use crate::ptr;
 
 type BufType = [usize; 32];
 
@@ -11,7 +11,7 @@ type BufType = [usize; 32];
 ///
 /// The specified range must be valid for reading and writing.
 #[inline]
-pub(super) unsafe fn ptr_rotate<T>(left: usize, mid: *mut T, right: usize) {
+pub(super) const unsafe fn ptr_rotate<T>(left: usize, mid: *mut T, right: usize) {
     if T::IS_ZST {
         return;
     }
@@ -21,7 +21,8 @@ pub(super) unsafe fn ptr_rotate<T>(left: usize, mid: *mut T, right: usize) {
     }
     // `T` is not a zero-sized type, so it's okay to divide by its size.
     if !cfg!(feature = "optimize_for_size")
-        && cmp::min(left, right) <= size_of::<BufType>() / size_of::<T>()
+        // FIXME(const-hack): Use cmp::min when available in const
+        && const_min(left, right) <= size_of::<BufType>() / size_of::<T>()
     {
         // SAFETY: guaranteed by the caller
         unsafe { ptr_rotate_memmove(left, mid, right) };
@@ -45,7 +46,7 @@ pub(super) unsafe fn ptr_rotate<T>(left: usize, mid: *mut T, right: usize) {
 ///
 /// The specified range must be valid for reading and writing.
 #[inline]
-unsafe fn ptr_rotate_memmove<T>(left: usize, mid: *mut T, right: usize) {
+const unsafe fn ptr_rotate_memmove<T>(left: usize, mid: *mut T, right: usize) {
     // The `[T; 0]` here is to ensure this is appropriately aligned for T
     let mut rawarray = MaybeUninit::<(BufType, [T; 0])>::uninit();
     let buf = rawarray.as_mut_ptr() as *mut T;
@@ -117,7 +118,7 @@ unsafe fn ptr_rotate_memmove<T>(left: usize, mid: *mut T, right: usize) {
 ///
 /// The specified range must be valid for reading and writing.
 #[inline]
-unsafe fn ptr_rotate_gcd<T>(left: usize, mid: *mut T, right: usize) {
+const unsafe fn ptr_rotate_gcd<T>(left: usize, mid: *mut T, right: usize) {
     // Algorithm 2
     // Microbenchmarks indicate that the average performance for random shifts is better all
     // the way until about `left + right == 32`, but the worst case performance breaks even
@@ -175,7 +176,9 @@ unsafe fn ptr_rotate_gcd<T>(left: usize, mid: *mut T, right: usize) {
         }
     }
     // finish the chunk with more rounds
-    for start in 1..gcd {
+    // FIXME(const-hack): Use `for start in 1..gcd` when available in const
+    let mut start = 1;
+    while start < gcd {
         // SAFETY: `gcd` is at most equal to `right` so all values in `1..gcd` are valid for
         // reading and writing as per the function's safety contract, see [long-safety-expl]
         // above
@@ -201,6 +204,8 @@ unsafe fn ptr_rotate_gcd<T>(left: usize, mid: *mut T, right: usize) {
                 i += right;
             }
         }
+
+        start += 1;
     }
 }
 
@@ -222,7 +227,7 @@ unsafe fn ptr_rotate_gcd<T>(left: usize, mid: *mut T, right: usize) {
 ///
 /// The specified range must be valid for reading and writing.
 #[inline]
-unsafe fn ptr_rotate_swap<T>(mut left: usize, mut mid: *mut T, mut right: usize) {
+const unsafe fn ptr_rotate_swap<T>(mut left: usize, mut mid: *mut T, mut right: usize) {
     loop {
         if left >= right {
             // Algorithm 3
@@ -265,3 +270,8 @@ unsafe fn ptr_rotate_swap<T>(mut left: usize, mut mid: *mut T, mut right: usize)
         }
     }
 }
+
+// FIXME(const-hack): Use cmp::min when available in const
+const fn const_min(left: usize, right: usize) -> usize {
+    if right < left { right } else { left }
+}
-- 
cgit 1.4.1-3-g733a5


From 507fd38a3fd2121d4a39df6fcf14eb50f868d471 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 11 Jul 2025 13:56:18 -0500
Subject: htmldocck: better error messages for negative raw directives

---
 src/etc/htmldocck.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/etc/htmldocck.py b/src/etc/htmldocck.py
index 1806e2be9bb..ddbd256a0d8 100755
--- a/src/etc/htmldocck.py
+++ b/src/etc/htmldocck.py
@@ -564,10 +564,14 @@ def check_command(c, cache):
             # hasraw/matchesraw <path> <pat> = string test
             elif len(c.args) == 2 and "raw" in c.cmd:
                 cerr = "`PATTERN` did not match"
+                if c.negated:
+                    cerr = "`PATTERN` unexpectedly matched"
                 ret = check_string(cache.get_file(c.args[0]), c.args[1], regexp)
             # has/matches <path> <pat> <match> = XML tree test
             elif len(c.args) == 3 and "raw" not in c.cmd:
                 cerr = "`XPATH PATTERN` did not match"
+                if c.negated:
+                    cerr = "`XPATH PATTERN` unexpectedly matched"
                 ret = get_nb_matching_elements(cache, c, regexp, True) != 0
             else:
                 raise InvalidCheck("Invalid number of {} arguments".format(c.cmd))
-- 
cgit 1.4.1-3-g733a5


From 0528cc9638a93ec72e6b1161536b42b5aeb874cd Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 11 Jul 2025 22:43:02 +0200
Subject: Access `wasi_sdk_path` instead of reading environment variable in
 bootstrap

---
 src/bootstrap/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index d9a4da8f3cc..9906dca4288 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -1318,7 +1318,7 @@ impl Build {
         if let Some(path) = configured {
             return Some(path.join("lib").join(target.to_string()));
         }
-        let mut env_root = PathBuf::from(std::env::var_os("WASI_SDK_PATH")?);
+        let mut env_root = self.wasi_sdk_path.clone()?;
         env_root.push("share");
         env_root.push("wasi-sysroot");
         env_root.push("lib");
-- 
cgit 1.4.1-3-g733a5


From 5d7db7e16ec5af85c39138dd7c669bc2219d1507 Mon Sep 17 00:00:00 2001
From: nazo6 <git@nazo6.dev>
Date: Sat, 12 Jul 2025 10:59:19 +0900
Subject: Fixed a core crate compilation failure when enabling the
 `optimize_for_size` feature on some targets

---
 library/core/src/fmt/num.rs | 8 ++++----
 library/core/src/lib.rs     | 1 +
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/library/core/src/fmt/num.rs b/library/core/src/fmt/num.rs
index e1381ace441..7d41ae45093 100644
--- a/library/core/src/fmt/num.rs
+++ b/library/core/src/fmt/num.rs
@@ -358,7 +358,7 @@ macro_rules! impl_Display {
                 }
                 #[cfg(feature = "optimize_for_size")]
                 {
-                    offset = _inner_slow_integer_to_str(self.unsigned_abs().$conv_fn(), &mut buf.buf);
+                    offset = ${concat(_inner_slow_integer_to_str, $gen_name)}(self.unsigned_abs().$conv_fn(), &mut buf.buf);
                 }
                 // Only difference between signed and unsigned are these 4 lines.
                 if self < 0 {
@@ -401,7 +401,7 @@ macro_rules! impl_Display {
                 }
                 #[cfg(feature = "optimize_for_size")]
                 {
-                    offset = _inner_slow_integer_to_str(self.$conv_fn(), &mut buf.buf);
+                    offset = ${concat(_inner_slow_integer_to_str, $gen_name)}(self.$conv_fn(), &mut buf.buf);
                 }
                 // SAFETY: Starting from `offset`, all elements of the slice have been set.
                 unsafe { slice_buffer_to_str(&buf.buf, offset) }
@@ -412,7 +412,7 @@ macro_rules! impl_Display {
         )*
 
         #[cfg(feature = "optimize_for_size")]
-        fn _inner_slow_integer_to_str(mut n: $u, buf: &mut [MaybeUninit::<u8>]) -> usize {
+        fn ${concat(_inner_slow_integer_to_str, $gen_name)}(mut n: $u, buf: &mut [MaybeUninit::<u8>]) -> usize {
             let mut curr = buf.len();
 
             // SAFETY: To show that it's OK to copy into `buf_ptr`, notice that at the beginning
@@ -437,7 +437,7 @@ macro_rules! impl_Display {
             const MAX_DEC_N: usize = $u::MAX.ilog(10) as usize + 1;
             let mut buf = [MaybeUninit::<u8>::uninit(); MAX_DEC_N];
 
-            let offset = _inner_slow_integer_to_str(n, &mut buf);
+            let offset = ${concat(_inner_slow_integer_to_str, $gen_name)}(n, &mut buf);
             // SAFETY: Starting from `offset`, all elements of the slice have been set.
             let buf_slice = unsafe { slice_buffer_to_str(&buf, offset) };
             f.pad_integral(is_nonnegative, "", buf_slice)
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 2f701171505..e08edde3b38 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -160,6 +160,7 @@
 #![feature(lang_items)]
 #![feature(link_llvm_intrinsics)]
 #![feature(macro_metavar_expr)]
+#![feature(macro_metavar_expr_concat)]
 #![feature(marker_trait_attr)]
 #![feature(min_specialization)]
 #![feature(multiple_supertrait_upcastable)]
-- 
cgit 1.4.1-3-g733a5


From bccc32bf791d7a0f5ccb0f345223548b9ae98844 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 12 Jul 2025 08:55:17 +0200
Subject: readme: update strict provenance link

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

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index b05acff72b5..7816ce1ac56 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -342,9 +342,9 @@ environment variable. We first document the most relevant and most commonly used
   is enabled (the default), this is also used to emulate system entropy. The default seed is 0. You
   can increase test coverage by running Miri multiple times with different seeds.
 * `-Zmiri-strict-provenance` enables [strict
-  provenance](https://github.com/rust-lang/rust/issues/95228) checking in Miri. This means that
-  casting an integer to a pointer will stop execution because the provenance of the pointer
-  cannot be determined.
+  provenance](https://doc.rust-lang.org/nightly/std/ptr/index.html#strict-provenance) checking in
+  Miri. This means that casting an integer to a pointer will stop execution because the provenance
+  of the pointer cannot be determined.
 * `-Zmiri-symbolic-alignment-check` makes the alignment check more strict.  By default, alignment is
   checked by casting the pointer to an integer, and making sure that is a multiple of the alignment.
   This can lead to cases where a program passes the alignment check by pure chance, because things
-- 
cgit 1.4.1-3-g733a5


From b0e4c3594f4d52ffde5281bae752e5ff05bd029c Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 12 Jul 2025 09:39:29 +0200
Subject: ./x test miri: fix cleaning the miri_ui directory

---
 src/bootstrap/src/core/build_steps/test.rs | 9 +++++++--
 src/tools/miri/tests/ui.rs                 | 2 ++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 716bef3f38c..5dbfd522844 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -556,8 +556,13 @@ impl Step for Miri {
         // Miri has its own "target dir" for ui test dependencies. Make sure it gets cleared when
         // the sysroot gets rebuilt, to avoid "found possibly newer version of crate `std`" errors.
         if !builder.config.dry_run() {
-            let ui_test_dep_dir =
-                builder.stage_out(miri.build_compiler, Mode::ToolStd).join("miri_ui");
+            // This has to match `CARGO_TARGET_TMPDIR` in Miri's `ui.rs`.
+            // This means we need `host` here as that's the target `ui.rs` is built for.
+            let ui_test_dep_dir = builder
+                .stage_out(miri.build_compiler, Mode::ToolStd)
+                .join(host)
+                .join("tmp")
+                .join("miri_ui");
             // The mtime of `miri_sysroot` changes when the sysroot gets rebuilt (also see
             // <https://github.com/RalfJung/rustc-build-sysroot/commit/10ebcf60b80fe2c3dc765af0ff19fdc0da4b7466>).
             // We can hence use that directly as a signal to clear the ui test dir.
diff --git a/src/tools/miri/tests/ui.rs b/src/tools/miri/tests/ui.rs
index 5239f8338ee..43f855d57dd 100644
--- a/src/tools/miri/tests/ui.rs
+++ b/src/tools/miri/tests/ui.rs
@@ -97,6 +97,8 @@ fn miri_config(
     let mut config = Config {
         target: Some(target.to_owned()),
         program,
+        // When changing this, remember to also adjust the logic in bootstrap, in Miri's test step,
+        // that deletes the `miri_ui` dir when it needs a rebuild.
         out_dir: PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("miri_ui"),
         threads: std::env::var("MIRI_TEST_THREADS")
             .ok()
-- 
cgit 1.4.1-3-g733a5


From 33668c1b0e02c6c6f8d195bc6545ceef5297cc87 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 5 Jul 2025 15:35:26 +0800
Subject: Remove outdated debugger version warning

---
 src/tools/compiletest/src/debuggers.rs | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/src/tools/compiletest/src/debuggers.rs b/src/tools/compiletest/src/debuggers.rs
index 0edc3d82d4f..8afe3289fa4 100644
--- a/src/tools/compiletest/src/debuggers.rs
+++ b/src/tools/compiletest/src/debuggers.rs
@@ -51,17 +51,6 @@ pub(crate) fn configure_gdb(config: &Config) -> Option<Arc<Config>> {
 pub(crate) fn configure_lldb(config: &Config) -> Option<Arc<Config>> {
     config.lldb_python_dir.as_ref()?;
 
-    // FIXME: this is super old
-    if let Some(350) = config.lldb_version {
-        println!(
-            "WARNING: The used version of LLDB (350) has a \
-             known issue that breaks debuginfo tests. See \
-             issue #32520 for more information. Skipping all \
-             LLDB-based tests!",
-        );
-        return None;
-    }
-
     Some(Arc::new(Config { debugger: Some(Debugger::Lldb), ..config.clone() }))
 }
 
-- 
cgit 1.4.1-3-g733a5


From 832b6273bdc5bbbe22d7274a5c424d818fad0ef8 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 12 Jul 2025 15:57:40 +0800
Subject: Move `string_enum` to `util` module

---
 src/tools/compiletest/src/common.rs | 46 ++-----------------------------------
 src/tools/compiletest/src/tests.rs  |  6 +----
 src/tools/compiletest/src/util.rs   | 39 +++++++++++++++++++++++++++++++
 3 files changed, 42 insertions(+), 49 deletions(-)

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 7122746fa87..bbc002a9b87 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -1,8 +1,7 @@
 use std::collections::{BTreeSet, HashMap, HashSet};
+use std::iter;
 use std::process::Command;
-use std::str::FromStr;
 use std::sync::OnceLock;
-use std::{fmt, iter};
 
 use build_helper::git::GitConfig;
 use camino::{Utf8Path, Utf8PathBuf};
@@ -12,48 +11,7 @@ use serde::de::{Deserialize, Deserializer, Error as _};
 pub use self::Mode::*;
 use crate::executor::{ColorConfig, OutputFormat};
 use crate::fatal;
-use crate::util::{Utf8PathBufExt, add_dylib_path};
-
-macro_rules! string_enum {
-    ($(#[$meta:meta])* $vis:vis enum $name:ident { $($variant:ident => $repr:expr,)* }) => {
-        $(#[$meta])*
-        $vis enum $name {
-            $($variant,)*
-        }
-
-        impl $name {
-            $vis const VARIANTS: &'static [Self] = &[$(Self::$variant,)*];
-            $vis const STR_VARIANTS: &'static [&'static str] = &[$(Self::$variant.to_str(),)*];
-
-            $vis const fn to_str(&self) -> &'static str {
-                match self {
-                    $(Self::$variant => $repr,)*
-                }
-            }
-        }
-
-        impl fmt::Display for $name {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                fmt::Display::fmt(self.to_str(), f)
-            }
-        }
-
-        impl FromStr for $name {
-            type Err = String;
-
-            fn from_str(s: &str) -> Result<Self, Self::Err> {
-                match s {
-                    $($repr => Ok(Self::$variant),)*
-                    _ => Err(format!(concat!("unknown `", stringify!($name), "` variant: `{}`"), s)),
-                }
-            }
-        }
-    }
-}
-
-// Make the macro visible outside of this module, for tests.
-#[cfg(test)]
-pub(crate) use string_enum;
+use crate::util::{Utf8PathBufExt, add_dylib_path, string_enum};
 
 string_enum! {
     #[derive(Clone, Copy, PartialEq, Debug)]
diff --git a/src/tools/compiletest/src/tests.rs b/src/tools/compiletest/src/tests.rs
index e3e4a81755d..174ec9381f6 100644
--- a/src/tools/compiletest/src/tests.rs
+++ b/src/tools/compiletest/src/tests.rs
@@ -67,11 +67,7 @@ fn is_test_test() {
 
 #[test]
 fn string_enums() {
-    // These imports are needed for the macro-generated code
-    use std::fmt;
-    use std::str::FromStr;
-
-    crate::common::string_enum! {
+    crate::util::string_enum! {
         #[derive(Clone, Copy, Debug, PartialEq)]
         enum Animal {
             Cat => "meow",
diff --git a/src/tools/compiletest/src/util.rs b/src/tools/compiletest/src/util.rs
index 202582bea8c..fb047548c45 100644
--- a/src/tools/compiletest/src/util.rs
+++ b/src/tools/compiletest/src/util.rs
@@ -104,3 +104,42 @@ macro_rules! static_regex {
     }};
 }
 pub(crate) use static_regex;
+
+macro_rules! string_enum {
+    ($(#[$meta:meta])* $vis:vis enum $name:ident { $($variant:ident => $repr:expr,)* }) => {
+        $(#[$meta])*
+        $vis enum $name {
+            $($variant,)*
+        }
+
+        impl $name {
+            $vis const VARIANTS: &'static [Self] = &[$(Self::$variant,)*];
+            $vis const STR_VARIANTS: &'static [&'static str] = &[$(Self::$variant.to_str(),)*];
+
+            $vis const fn to_str(&self) -> &'static str {
+                match self {
+                    $(Self::$variant => $repr,)*
+                }
+            }
+        }
+
+        impl ::std::fmt::Display for $name {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+                ::std::fmt::Display::fmt(self.to_str(), f)
+            }
+        }
+
+        impl ::std::str::FromStr for $name {
+            type Err = String;
+
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    $($repr => Ok(Self::$variant),)*
+                    _ => Err(format!(concat!("unknown `", stringify!($name), "` variant: `{}`"), s)),
+                }
+            }
+        }
+    }
+}
+
+pub(crate) use string_enum;
-- 
cgit 1.4.1-3-g733a5


From b4dfd51bac242deca51442355784274beb16bd43 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 12 Jul 2025 15:59:16 +0800
Subject: Do not allow defaults for `Mode` and `Config`

They do not have sensible defaults, and it is crucial that we get them
right.
---
 src/tools/compiletest/src/common.rs | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index bbc002a9b87..943e800e72c 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -34,12 +34,6 @@ string_enum! {
     }
 }
 
-impl Default for Mode {
-    fn default() -> Self {
-        Mode::Ui
-    }
-}
-
 impl Mode {
     pub fn aux_dir_disambiguator(self) -> &'static str {
         // Pretty-printing tests could run concurrently, and if they do,
@@ -151,7 +145,7 @@ pub enum Sanitizer {
 ///
 /// FIXME: audit these options to make sure we are not hashing less than necessary for build stamp
 /// (for changed test detection).
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Clone)]
 pub struct Config {
     /// Some test [`Mode`]s support [snapshot testing], where a *reference snapshot* of outputs (of
     /// `stdout`, `stderr`, or other form of artifacts) can be compared to the *actual output*.
-- 
cgit 1.4.1-3-g733a5


From 4aad9ab8aa7c6ee692453a9544c696f03e281dbd Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 12 Jul 2025 16:02:05 +0800
Subject: Rename `Mode` to `TestMode`

It is *critical* that we maintain clear nomenclature in `compiletest`.
We have many types of "modes" in `compiletest` -- pass modes, coverage
modes, compare modes, you name it. `Mode` is also a *super* general
term. Rename it to `TestMode` to leave no room for such ambiguity.

As a follow-up, I also intend to introduce an enum for `TestSuite`, then
rid of all usage of glob re-exported `TestMode::*` enum variants -- many
test suites share the same name as the test mode.
---
 src/tools/compiletest/src/common.rs           | 24 ++++++++---------
 src/tools/compiletest/src/directives.rs       | 38 +++++++++++++--------------
 src/tools/compiletest/src/directives/tests.rs |  4 +--
 src/tools/compiletest/src/lib.rs              | 20 +++++++-------
 src/tools/compiletest/src/runtest.rs          |  2 +-
 src/tools/rustdoc-gui-test/src/main.rs        |  2 +-
 6 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 943e800e72c..d621ee8de4f 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -8,14 +8,14 @@ use camino::{Utf8Path, Utf8PathBuf};
 use semver::Version;
 use serde::de::{Deserialize, Deserializer, Error as _};
 
-pub use self::Mode::*;
+pub use self::TestMode::*;
 use crate::executor::{ColorConfig, OutputFormat};
 use crate::fatal;
 use crate::util::{Utf8PathBufExt, add_dylib_path, string_enum};
 
 string_enum! {
     #[derive(Clone, Copy, PartialEq, Debug)]
-    pub enum Mode {
+    pub enum TestMode {
         Pretty => "pretty",
         DebugInfo => "debuginfo",
         Codegen => "codegen",
@@ -34,7 +34,7 @@ string_enum! {
     }
 }
 
-impl Mode {
+impl TestMode {
     pub fn aux_dir_disambiguator(self) -> &'static str {
         // Pretty-printing tests could run concurrently, and if they do,
         // they need to keep their output segregated.
@@ -147,7 +147,7 @@ pub enum Sanitizer {
 /// (for changed test detection).
 #[derive(Debug, Clone)]
 pub struct Config {
-    /// Some test [`Mode`]s support [snapshot testing], where a *reference snapshot* of outputs (of
+    /// Some [`TestMode`]s support [snapshot testing], where a *reference snapshot* of outputs (of
     /// `stdout`, `stderr`, or other form of artifacts) can be compared to the *actual output*.
     ///
     /// This option can be set to `true` to update the *reference snapshots* in-place, otherwise
@@ -269,20 +269,20 @@ pub struct Config {
     /// FIXME: reconsider this string; this is hashed for test build stamp.
     pub stage_id: String,
 
-    /// The test [`Mode`]. E.g. [`Mode::Ui`]. Each test mode can correspond to one or more test
+    /// The [`TestMode`]. E.g. [`TestMode::Ui`]. Each test mode can correspond to one or more test
     /// suites.
     ///
     /// FIXME: stop using stringly-typed test suites!
-    pub mode: Mode,
+    pub mode: TestMode,
 
     /// The test suite.
     ///
-    /// Example: `tests/ui/` is the "UI" test *suite*, which happens to also be of the [`Mode::Ui`]
-    /// test *mode*.
+    /// Example: `tests/ui/` is the "UI" test *suite*, which happens to also be of the
+    /// [`TestMode::Ui`] test *mode*.
     ///
     /// Note that the same test directory (e.g. `tests/coverage/`) may correspond to multiple test
-    /// modes, e.g. `tests/coverage/` can be run under both [`Mode::CoverageRun`] and
-    /// [`Mode::CoverageMap`].
+    /// modes, e.g. `tests/coverage/` can be run under both [`TestMode::CoverageRun`] and
+    /// [`TestMode::CoverageMap`].
     ///
     /// FIXME: stop using stringly-typed test suites!
     pub suite: String,
@@ -538,8 +538,8 @@ pub struct Config {
     // Configuration for various run-make tests frobbing things like C compilers or querying about
     // various LLVM component information.
     //
-    // FIXME: this really should be better packaged together.
-    // FIXME: these need better docs, e.g. for *host*, or for *target*?
+    // FIXME: this really should be better packaged together. FIXME: these need better docs, e.g.
+    // for *host*, or for *target*?
     pub cc: String,
     pub cxx: String,
     pub cflags: String,
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index a6242cf0c22..ddd04376082 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -9,7 +9,7 @@ use camino::{Utf8Path, Utf8PathBuf};
 use semver::Version;
 use tracing::*;
 
-use crate::common::{Config, Debugger, FailMode, Mode, PassMode};
+use crate::common::{Config, Debugger, FailMode, PassMode, TestMode};
 use crate::debuggers::{extract_cdb_version, extract_gdb_version};
 use crate::directives::auxiliary::{AuxProps, parse_and_update_aux};
 use crate::directives::needs::CachedNeedsConditions;
@@ -328,7 +328,7 @@ impl TestProps {
         props.exec_env.push(("RUSTC".to_string(), config.rustc_path.to_string()));
 
         match (props.pass_mode, props.fail_mode) {
-            (None, None) if config.mode == Mode::Ui => props.fail_mode = Some(FailMode::Check),
+            (None, None) if config.mode == TestMode::Ui => props.fail_mode = Some(FailMode::Check),
             (Some(_), Some(_)) => panic!("cannot use a *-fail and *-pass mode together"),
             _ => {}
         }
@@ -609,11 +609,11 @@ impl TestProps {
             self.failure_status = Some(101);
         }
 
-        if config.mode == Mode::Incremental {
+        if config.mode == TestMode::Incremental {
             self.incremental = true;
         }
 
-        if config.mode == Mode::Crashes {
+        if config.mode == TestMode::Crashes {
             // we don't want to pollute anything with backtrace-files
             // also turn off backtraces in order to save some execution
             // time on the tests; we only need to know IF it crashes
@@ -641,11 +641,11 @@ impl TestProps {
     fn update_fail_mode(&mut self, ln: &str, config: &Config) {
         let check_ui = |mode: &str| {
             // Mode::Crashes may need build-fail in order to trigger llvm errors or stack overflows
-            if config.mode != Mode::Ui && config.mode != Mode::Crashes {
+            if config.mode != TestMode::Ui && config.mode != TestMode::Crashes {
                 panic!("`{}-fail` directive is only supported in UI tests", mode);
             }
         };
-        if config.mode == Mode::Ui && config.parse_name_directive(ln, "compile-fail") {
+        if config.mode == TestMode::Ui && config.parse_name_directive(ln, "compile-fail") {
             panic!("`compile-fail` directive is useless in UI tests");
         }
         let fail_mode = if config.parse_name_directive(ln, "check-fail") {
@@ -669,10 +669,10 @@ impl TestProps {
 
     fn update_pass_mode(&mut self, ln: &str, revision: Option<&str>, config: &Config) {
         let check_no_run = |s| match (config.mode, s) {
-            (Mode::Ui, _) => (),
-            (Mode::Crashes, _) => (),
-            (Mode::Codegen, "build-pass") => (),
-            (Mode::Incremental, _) => {
+            (TestMode::Ui, _) => (),
+            (TestMode::Crashes, _) => (),
+            (TestMode::Codegen, "build-pass") => (),
+            (TestMode::Incremental, _) => {
                 if revision.is_some() && !self.revisions.iter().all(|r| r.starts_with("cfail")) {
                     panic!("`{s}` directive is only supported in `cfail` incremental tests")
                 }
@@ -715,7 +715,7 @@ impl TestProps {
     pub fn update_add_core_stubs(&mut self, ln: &str, config: &Config) {
         let add_core_stubs = config.parse_name_directive(ln, directives::ADD_CORE_STUBS);
         if add_core_stubs {
-            if !matches!(config.mode, Mode::Ui | Mode::Codegen | Mode::Assembly) {
+            if !matches!(config.mode, TestMode::Ui | TestMode::Codegen | TestMode::Assembly) {
                 panic!(
                     "`add-core-stubs` is currently only supported for ui, codegen and assembly test modes"
                 );
@@ -833,7 +833,7 @@ pub(crate) struct CheckDirectiveResult<'ln> {
 
 pub(crate) fn check_directive<'a>(
     directive_ln: &'a str,
-    mode: Mode,
+    mode: TestMode,
     original_line: &str,
 ) -> CheckDirectiveResult<'a> {
     let (directive_name, post) = directive_ln.split_once([':', ' ']).unwrap_or((directive_ln, ""));
@@ -842,11 +842,11 @@ pub(crate) fn check_directive<'a>(
     let is_known = |s: &str| {
         KNOWN_DIRECTIVE_NAMES.contains(&s)
             || match mode {
-                Mode::Rustdoc | Mode::RustdocJson => {
+                TestMode::Rustdoc | TestMode::RustdocJson => {
                     original_line.starts_with("//@")
                         && match mode {
-                            Mode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,
-                            Mode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
+                            TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,
+                            TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
                             _ => unreachable!(),
                         }
                         .contains(&s)
@@ -868,7 +868,7 @@ pub(crate) fn check_directive<'a>(
 const COMPILETEST_DIRECTIVE_PREFIX: &str = "//@";
 
 fn iter_directives(
-    mode: Mode,
+    mode: TestMode,
     _suite: &str,
     poisoned: &mut bool,
     testfile: &Utf8Path,
@@ -883,7 +883,7 @@ fn iter_directives(
     // 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 == Mode::CoverageRun {
+    if mode == TestMode::CoverageRun {
         let extra_directives: &[&str] = &[
             "needs-profiler-runtime",
             // FIXME(pietroalbini): this test currently does not work on cross-compiled targets
@@ -964,7 +964,7 @@ impl Config {
             ["CHECK", "COM", "NEXT", "SAME", "EMPTY", "NOT", "COUNT", "DAG", "LABEL"];
 
         if let Some(raw) = self.parse_name_value_directive(line, "revisions") {
-            if self.mode == Mode::RunMake {
+            if self.mode == TestMode::RunMake {
                 panic!("`run-make` tests do not support revisions: {}", testfile);
             }
 
@@ -981,7 +981,7 @@ impl Config {
                     );
                 }
 
-                if matches!(self.mode, Mode::Assembly | Mode::Codegen | Mode::MirOpt)
+                if matches!(self.mode, TestMode::Assembly | TestMode::Codegen | TestMode::MirOpt)
                     && FILECHECK_FORBIDDEN_REVISION_NAMES.contains(&revision)
                 {
                     panic!(
diff --git a/src/tools/compiletest/src/directives/tests.rs b/src/tools/compiletest/src/directives/tests.rs
index d4570f82677..9c5751b416b 100644
--- a/src/tools/compiletest/src/directives/tests.rs
+++ b/src/tools/compiletest/src/directives/tests.rs
@@ -7,7 +7,7 @@ use super::{
     DirectivesCache, EarlyProps, extract_llvm_version, extract_version_range, iter_directives,
     parse_normalize_rule,
 };
-use crate::common::{Config, Debugger, Mode};
+use crate::common::{Config, Debugger, TestMode};
 use crate::executor::{CollectedTestDesc, ShouldPanic};
 
 fn make_test_description<R: Read>(
@@ -785,7 +785,7 @@ fn threads_support() {
 
 fn run_path(poisoned: &mut bool, path: &Utf8Path, buf: &[u8]) {
     let rdr = std::io::Cursor::new(&buf);
-    iter_directives(Mode::Ui, "ui", poisoned, path, rdr, &mut |_| {});
+    iter_directives(TestMode::Ui, "ui", poisoned, path, rdr, &mut |_| {});
 }
 
 #[test]
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 9819079e284..be82f8cb480 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -39,8 +39,8 @@ use walkdir::WalkDir;
 
 use self::directives::{EarlyProps, make_test_description};
 use crate::common::{
-    CompareMode, Config, Debugger, Mode, PassMode, TestPaths, UI_EXTENSIONS, expected_output_path,
-    output_base_dir, output_relative_path,
+    CompareMode, Config, Debugger, PassMode, TestMode, TestPaths, UI_EXTENSIONS,
+    expected_output_path, output_base_dir, output_relative_path,
 };
 use crate::directives::DirectivesCache;
 use crate::executor::{CollectedTest, ColorConfig, OutputFormat};
@@ -268,7 +268,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
     let with_rustc_debug_assertions = matches.opt_present("with-rustc-debug-assertions");
     let with_std_debug_assertions = matches.opt_present("with-std-debug-assertions");
     let mode = matches.opt_str("mode").unwrap().parse().expect("invalid mode");
-    let has_html_tidy = if mode == Mode::Rustdoc {
+    let has_html_tidy = if mode == TestMode::Rustdoc {
         Command::new("tidy")
             .arg("--version")
             .stdout(Stdio::null())
@@ -279,7 +279,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
         false
     };
     let has_enzyme = matches.opt_present("has-enzyme");
-    let filters = if mode == Mode::RunMake {
+    let filters = if mode == TestMode::RunMake {
         matches
             .free
             .iter()
@@ -545,7 +545,7 @@ pub fn run_tests(config: Arc<Config>) {
     unsafe { env::set_var("TARGET", &config.target) };
 
     let mut configs = Vec::new();
-    if let Mode::DebugInfo = config.mode {
+    if let TestMode::DebugInfo = config.mode {
         // Debugging emscripten code doesn't make sense today
         if !config.target.contains("emscripten") {
             match config.debugger {
@@ -783,7 +783,7 @@ fn collect_tests_from_dir(
     }
 
     // For run-make tests, a "test file" is actually a directory that contains an `rmake.rs`.
-    if cx.config.mode == Mode::RunMake {
+    if cx.config.mode == TestMode::RunMake {
         let mut collector = TestCollector::new();
         if dir.join("rmake.rs").exists() {
             let paths = TestPaths {
@@ -869,7 +869,7 @@ fn make_test(cx: &TestCollectorCx, collector: &mut TestCollector, testpaths: &Te
     // For run-make tests, each "test file" is actually a _directory_ containing an `rmake.rs`. But
     // for the purposes of directive parsing, we want to look at that recipe file, not the directory
     // itself.
-    let test_path = if cx.config.mode == Mode::RunMake {
+    let test_path = if cx.config.mode == TestMode::RunMake {
         testpaths.file.join("rmake.rs")
     } else {
         testpaths.file.clone()
@@ -884,7 +884,7 @@ fn make_test(cx: &TestCollectorCx, collector: &mut TestCollector, testpaths: &Te
     // - Incremental tests inherently can't run their revisions in parallel, so
     //   we treat them like non-revisioned tests here. Incremental revisions are
     //   handled internally by `runtest::run` instead.
-    let revisions = if early_props.revisions.is_empty() || cx.config.mode == Mode::Incremental {
+    let revisions = if early_props.revisions.is_empty() || cx.config.mode == TestMode::Incremental {
         vec![None]
     } else {
         early_props.revisions.iter().map(|r| Some(r.as_str())).collect()
@@ -1116,11 +1116,11 @@ fn check_for_overlapping_test_paths(found_path_stems: &HashSet<Utf8PathBuf>) {
 }
 
 pub fn early_config_check(config: &Config) {
-    if !config.has_html_tidy && config.mode == Mode::Rustdoc {
+    if !config.has_html_tidy && config.mode == TestMode::Rustdoc {
         warning!("`tidy` (html-tidy.org) is not installed; diffs will not be generated");
     }
 
-    if !config.profiler_runtime && config.mode == Mode::CoverageRun {
+    if !config.profiler_runtime && config.mode == TestMode::CoverageRun {
         let actioned = if config.bless { "blessed" } else { "checked" };
         warning!("profiler runtime is not available, so `.coverage` files won't be {actioned}");
         help!("try setting `profiler = true` in the `[build]` section of `bootstrap.toml`");
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 933a32392bd..dcfd15ad191 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -349,7 +349,7 @@ impl<'test> TestCx<'test> {
             if proc_res.status.success() {
                 {
                     self.error(&format!("{} test did not emit an error", self.config.mode));
-                    if self.config.mode == crate::common::Mode::Ui {
+                    if self.config.mode == crate::common::TestMode::Ui {
                         println!("note: by default, ui tests are expected not to compile");
                     }
                     proc_res.fatal(None, || ());
diff --git a/src/tools/rustdoc-gui-test/src/main.rs b/src/tools/rustdoc-gui-test/src/main.rs
index 6461f38f527..dd9be8d5e7d 100644
--- a/src/tools/rustdoc-gui-test/src/main.rs
+++ b/src/tools/rustdoc-gui-test/src/main.rs
@@ -114,7 +114,7 @@ If you want to install the `browser-ui-test` dependency, run `npm install browse
             if let Some(librs) = find_librs(entry.path()) {
                 let compiletest_c = compiletest::common::Config {
                     edition: None,
-                    mode: compiletest::common::Mode::Rustdoc,
+                    mode: compiletest::common::TestMode::Rustdoc,
                     ..Default::default()
                 };
 
-- 
cgit 1.4.1-3-g733a5


From b9ae117199fd70b860088105aaaca94582eac8a4 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 12 Jul 2025 16:17:10 +0800
Subject: Do not glob-reexport `TestMode` variants

I would like to introduce `TestSuite` over stringly-typed test suite
names, and some test suite names are the same as test modes, which can
make this very confusing.
---
 src/tools/compiletest/src/common.rs     |   5 +-
 src/tools/compiletest/src/directives.rs |   2 +-
 src/tools/compiletest/src/runtest.rs    | 111 ++++++++++++++++++--------------
 3 files changed, 65 insertions(+), 53 deletions(-)

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index d621ee8de4f..f3a5b4145fd 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -8,7 +8,6 @@ use camino::{Utf8Path, Utf8PathBuf};
 use semver::Version;
 use serde::de::{Deserialize, Deserializer, Error as _};
 
-pub use self::TestMode::*;
 use crate::executor::{ColorConfig, OutputFormat};
 use crate::fatal;
 use crate::util::{Utf8PathBufExt, add_dylib_path, string_enum};
@@ -39,7 +38,7 @@ impl TestMode {
         // Pretty-printing tests could run concurrently, and if they do,
         // they need to keep their output segregated.
         match self {
-            Pretty => ".pretty",
+            TestMode::Pretty => ".pretty",
             _ => "",
         }
     }
@@ -48,7 +47,7 @@ impl TestMode {
         // Coverage tests use the same test files for multiple test modes,
         // so each mode should have a separate output directory.
         match self {
-            CoverageMap | CoverageRun => self.to_str(),
+            TestMode::CoverageMap | TestMode::CoverageRun => self.to_str(),
             _ => "",
         }
     }
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index ddd04376082..7fadb4dae2a 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -1443,7 +1443,7 @@ pub(crate) fn make_test_description<R: Read>(
     // since we run the pretty printer across all tests by default.
     // If desired, we could add a `should-fail-pretty` annotation.
     let should_panic = match config.mode {
-        crate::common::Pretty => ShouldPanic::No,
+        TestMode::Pretty => ShouldPanic::No,
         _ if should_fail => ShouldPanic::Yes,
         _ => ShouldPanic::No,
     };
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index dcfd15ad191..12111e9c6ef 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -16,11 +16,10 @@ use regex::{Captures, Regex};
 use tracing::*;
 
 use crate::common::{
-    Assembly, Codegen, CodegenUnits, CompareMode, Config, CoverageMap, CoverageRun, Crashes,
-    DebugInfo, Debugger, FailMode, Incremental, MirOpt, PassMode, Pretty, RunMake, Rustdoc,
-    RustdocJs, RustdocJson, TestPaths, UI_EXTENSIONS, UI_FIXED, UI_RUN_STDERR, UI_RUN_STDOUT,
-    UI_STDERR, UI_STDOUT, UI_SVG, UI_WINDOWS_SVG, Ui, expected_output_path, incremental_dir,
-    output_base_dir, output_base_name, output_testname_unique,
+    CompareMode, Config, Debugger, FailMode, PassMode, TestMode, TestPaths, UI_EXTENSIONS,
+    UI_FIXED, UI_RUN_STDERR, UI_RUN_STDOUT, UI_STDERR, UI_STDOUT, UI_SVG, UI_WINDOWS_SVG,
+    expected_output_path, incremental_dir, output_base_dir, output_base_name,
+    output_testname_unique,
 };
 use crate::compute_diff::{DiffLine, make_diff, write_diff, write_filtered_diff};
 use crate::directives::TestProps;
@@ -154,7 +153,7 @@ pub fn run(config: Arc<Config>, testpaths: &TestPaths, revision: Option<&str>) {
         cx.init_incremental_test();
     }
 
-    if config.mode == Incremental {
+    if config.mode == TestMode::Incremental {
         // Incremental tests are special because they cannot be run in
         // parallel.
         assert!(!props.revisions.is_empty(), "Incremental tests require revisions.");
@@ -203,7 +202,7 @@ pub fn compute_stamp_hash(config: &Config) -> String {
         None => {}
     }
 
-    if let Ui = config.mode {
+    if config.mode == TestMode::Ui {
         config.force_pass_mode.hash(&mut hash);
     }
 
@@ -251,25 +250,28 @@ impl<'test> TestCx<'test> {
     /// Code executed for each revision in turn (or, if there are no
     /// revisions, exactly once, with revision == None).
     fn run_revision(&self) {
-        if self.props.should_ice && self.config.mode != Incremental && self.config.mode != Crashes {
+        if self.props.should_ice
+            && self.config.mode != TestMode::Incremental
+            && self.config.mode != TestMode::Crashes
+        {
             self.fatal("cannot use should-ice in a test that is not cfail");
         }
         match self.config.mode {
-            Pretty => self.run_pretty_test(),
-            DebugInfo => self.run_debuginfo_test(),
-            Codegen => self.run_codegen_test(),
-            Rustdoc => self.run_rustdoc_test(),
-            RustdocJson => self.run_rustdoc_json_test(),
-            CodegenUnits => self.run_codegen_units_test(),
-            Incremental => self.run_incremental_test(),
-            RunMake => self.run_rmake_test(),
-            Ui => self.run_ui_test(),
-            MirOpt => self.run_mir_opt_test(),
-            Assembly => self.run_assembly_test(),
-            RustdocJs => self.run_rustdoc_js_test(),
-            CoverageMap => self.run_coverage_map_test(), // see self::coverage
-            CoverageRun => self.run_coverage_run_test(), // see self::coverage
-            Crashes => self.run_crash_test(),
+            TestMode::Pretty => self.run_pretty_test(),
+            TestMode::DebugInfo => self.run_debuginfo_test(),
+            TestMode::Codegen => self.run_codegen_test(),
+            TestMode::Rustdoc => self.run_rustdoc_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(),
         }
     }
 
@@ -279,9 +281,13 @@ impl<'test> TestCx<'test> {
 
     fn should_run(&self, pm: Option<PassMode>) -> WillExecute {
         let test_should_run = match self.config.mode {
-            Ui if pm == Some(PassMode::Run) || self.props.fail_mode == Some(FailMode::Run) => true,
-            MirOpt if pm == Some(PassMode::Run) => true,
-            Ui | MirOpt => false,
+            TestMode::Ui
+                if pm == Some(PassMode::Run) || self.props.fail_mode == Some(FailMode::Run) =>
+            {
+                true
+            }
+            TestMode::MirOpt if pm == Some(PassMode::Run) => true,
+            TestMode::Ui | TestMode::MirOpt => false,
             mode => panic!("unimplemented for mode {:?}", mode),
         };
         if test_should_run { self.run_if_enabled() } else { WillExecute::No }
@@ -293,17 +299,17 @@ impl<'test> TestCx<'test> {
 
     fn should_run_successfully(&self, pm: Option<PassMode>) -> bool {
         match self.config.mode {
-            Ui | MirOpt => pm == Some(PassMode::Run),
+            TestMode::Ui | TestMode::MirOpt => pm == Some(PassMode::Run),
             mode => panic!("unimplemented for mode {:?}", mode),
         }
     }
 
     fn should_compile_successfully(&self, pm: Option<PassMode>) -> bool {
         match self.config.mode {
-            RustdocJs => true,
-            Ui => pm.is_some() || self.props.fail_mode > Some(FailMode::Build),
-            Crashes => false,
-            Incremental => {
+            TestMode::RustdocJs => true,
+            TestMode::Ui => pm.is_some() || self.props.fail_mode > Some(FailMode::Build),
+            TestMode::Crashes => false,
+            TestMode::Incremental => {
                 let revision =
                     self.revision.expect("incremental tests require a list of revisions");
                 if revision.starts_with("cpass")
@@ -892,7 +898,9 @@ impl<'test> TestCx<'test> {
 
     fn should_emit_metadata(&self, pm: Option<PassMode>) -> Emit {
         match (pm, self.props.fail_mode, self.config.mode) {
-            (Some(PassMode::Check), ..) | (_, Some(FailMode::Check), Ui) => Emit::Metadata,
+            (Some(PassMode::Check), ..) | (_, Some(FailMode::Check), TestMode::Ui) => {
+                Emit::Metadata
+            }
             _ => Emit::None,
         }
     }
@@ -926,7 +934,7 @@ impl<'test> TestCx<'test> {
         };
 
         let allow_unused = match self.config.mode {
-            Ui => {
+            TestMode::Ui => {
                 // UI tests tend to have tons of unused code as
                 // it's just testing various pieces of the compile, but we don't
                 // want to actually assert warnings about all this code. Instead
@@ -1021,7 +1029,7 @@ impl<'test> TestCx<'test> {
             .args(&self.props.compile_flags)
             .args(&self.props.doc_flags);
 
-        if self.config.mode == RustdocJson {
+        if self.config.mode == TestMode::RustdocJson {
             rustdoc.arg("--output-format").arg("json").arg("-Zunstable-options");
         }
 
@@ -1372,7 +1380,7 @@ impl<'test> TestCx<'test> {
             || self.is_vxworks_pure_static()
             || self.config.target.contains("bpf")
             || !self.config.target_cfg().dynamic_linking
-            || matches!(self.config.mode, CoverageMap | CoverageRun)
+            || matches!(self.config.mode, TestMode::CoverageMap | TestMode::CoverageRun)
         {
             // We primarily compile all auxiliary libraries as dynamic libraries
             // to avoid code size bloat and large binaries as much as possible
@@ -1562,14 +1570,14 @@ impl<'test> TestCx<'test> {
                 rustc.args(&["-Z", "incremental-verify-ich"]);
             }
 
-            if self.config.mode == CodegenUnits {
+            if self.config.mode == TestMode::CodegenUnits {
                 rustc.args(&["-Z", "human_readable_cgu_names"]);
             }
         }
 
         if self.config.optimize_tests && !is_rustdoc {
             match self.config.mode {
-                Ui => {
+                TestMode::Ui => {
                     // If optimize-tests is true we still only want to optimize tests that actually get
                     // executed and that don't specify their own optimization levels.
                     // Note: aux libs don't have a pass-mode, so they won't get optimized
@@ -1585,8 +1593,8 @@ impl<'test> TestCx<'test> {
                         rustc.arg("-O");
                     }
                 }
-                DebugInfo => { /* debuginfo tests must be unoptimized */ }
-                CoverageMap | CoverageRun => {
+                TestMode::DebugInfo => { /* debuginfo tests must be unoptimized */ }
+                TestMode::CoverageMap | TestMode::CoverageRun => {
                     // Coverage mappings and coverage reports are affected by
                     // optimization level, so they ignore the optimize-tests
                     // setting and set an optimization level in their mode's
@@ -1607,7 +1615,7 @@ impl<'test> TestCx<'test> {
         };
 
         match self.config.mode {
-            Incremental => {
+            TestMode::Incremental => {
                 // If we are extracting and matching errors in the new
                 // fashion, then you want JSON mode. Old-skool error
                 // patterns still match the raw compiler output.
@@ -1620,7 +1628,7 @@ impl<'test> TestCx<'test> {
                 rustc.arg("-Zui-testing");
                 rustc.arg("-Zdeduplicate-diagnostics=no");
             }
-            Ui => {
+            TestMode::Ui => {
                 if !self.props.compile_flags.iter().any(|s| s.starts_with("--error-format")) {
                     rustc.args(&["--error-format", "json"]);
                     rustc.args(&["--json", "future-incompat"]);
@@ -1633,7 +1641,7 @@ impl<'test> TestCx<'test> {
                 // FIXME: use this for other modes too, for perf?
                 rustc.arg("-Cstrip=debuginfo");
             }
-            MirOpt => {
+            TestMode::MirOpt => {
                 // We check passes under test to minimize the mir-opt test dump
                 // if files_for_miropt_test parses the passes, we dump only those passes
                 // otherwise we conservatively pass -Zdump-mir=all
@@ -1663,7 +1671,7 @@ impl<'test> TestCx<'test> {
 
                 set_mir_dump_dir(&mut rustc);
             }
-            CoverageMap => {
+            TestMode::CoverageMap => {
                 rustc.arg("-Cinstrument-coverage");
                 // These tests only compile to LLVM IR, so they don't need the
                 // profiler runtime to be present.
@@ -1673,23 +1681,28 @@ impl<'test> TestCx<'test> {
                 // by `compile-flags`.
                 rustc.arg("-Copt-level=2");
             }
-            CoverageRun => {
+            TestMode::CoverageRun => {
                 rustc.arg("-Cinstrument-coverage");
                 // Coverage reports are sometimes sensitive to optimizations,
                 // and the current snapshots assume `opt-level=2` unless
                 // overridden by `compile-flags`.
                 rustc.arg("-Copt-level=2");
             }
-            Assembly | Codegen => {
+            TestMode::Assembly | TestMode::Codegen => {
                 rustc.arg("-Cdebug-assertions=no");
             }
-            Crashes => {
+            TestMode::Crashes => {
                 set_mir_dump_dir(&mut rustc);
             }
-            CodegenUnits => {
+            TestMode::CodegenUnits => {
                 rustc.arg("-Zprint-mono-items");
             }
-            Pretty | DebugInfo | Rustdoc | RustdocJson | RunMake | RustdocJs => {
+            TestMode::Pretty
+            | TestMode::DebugInfo
+            | TestMode::Rustdoc
+            | TestMode::RustdocJson
+            | TestMode::RunMake
+            | TestMode::RustdocJs => {
                 // do not use JSON output
             }
         }
@@ -1962,7 +1975,7 @@ impl<'test> TestCx<'test> {
     /// The revision, ignored for incremental compilation since it wants all revisions in
     /// the same directory.
     fn safe_revision(&self) -> Option<&str> {
-        if self.config.mode == Incremental { None } else { self.revision }
+        if self.config.mode == TestMode::Incremental { None } else { self.revision }
     }
 
     /// Gets the absolute path to the directory where all output for the given
-- 
cgit 1.4.1-3-g733a5


From 73edfe7b7395aad2ee55c57cabc8cee9edfbf462 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 12 Jul 2025 11:08:30 +0200
Subject: clippy: fix test filtering when TESTNAME is empty

---
 src/bootstrap/src/core/build_steps/test.rs |  4 ++--
 src/tools/clippy/tests/compile-test.rs     | 11 ++++++++++-
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 716bef3f38c..18e169bb2f0 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -680,9 +680,9 @@ impl Step for CargoMiri {
                 cargo.arg("--doc");
             }
         }
-
-        // Finally, pass test-args and run everything.
         cargo.arg("--").args(builder.config.test_args());
+
+        // Finally, run everything.
         let mut cargo = BootstrapCommand::from(cargo);
         {
             let _guard = builder.msg_sysroot_tool(Kind::Test, stage, "cargo-miri", host, target);
diff --git a/src/tools/clippy/tests/compile-test.rs b/src/tools/clippy/tests/compile-test.rs
index cefe654fef6..a7f38275a60 100644
--- a/src/tools/clippy/tests/compile-test.rs
+++ b/src/tools/clippy/tests/compile-test.rs
@@ -144,8 +144,17 @@ impl TestContext {
         let target_dir = PathBuf::from(var_os("CARGO_TARGET_DIR").unwrap_or_else(|| "target".into()));
         let mut config = Config {
             output_conflict_handling: error_on_output_conflict,
+            // Pre-fill filters with TESTNAME; will be later extended with `self.args`.
             filter_files: env::var("TESTNAME")
-                .map(|filters| filters.split(',').map(str::to_string).collect())
+                .map(|filters| {
+                    filters
+                        .split(',')
+                        // Make sure that if TESTNAME is empty we produce the empty list here,
+                        // not a list containing an empty string.
+                        .filter(|s| !s.is_empty())
+                        .map(str::to_string)
+                        .collect()
+                })
                 .unwrap_or_default(),
             target: None,
             bless_command: Some(if IS_RUSTC_TEST_SUITE {
-- 
cgit 1.4.1-3-g733a5


From acbbc18599e5b14abb9ec1226b611fcfe4f85bb3 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Sat, 12 Jul 2025 14:52:34 +0530
Subject: fix span for deferred command execution

---
 src/bootstrap/src/utils/exec.rs | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/bootstrap/src/utils/exec.rs b/src/bootstrap/src/utils/exec.rs
index c5bafda88c4..453a4b056b2 100644
--- a/src/bootstrap/src/utils/exec.rs
+++ b/src/bootstrap/src/utils/exec.rs
@@ -593,6 +593,8 @@ enum CommandState<'a> {
         executed_at: &'a Location<'a>,
         fingerprint: CommandFingerprint,
         start_time: Instant,
+        #[cfg(feature = "tracing")]
+        _span_guard: tracing::span::EnteredSpan,
     },
 }
 
@@ -693,6 +695,9 @@ impl ExecutionContext {
     ) -> DeferredCommand<'a> {
         let fingerprint = command.fingerprint();
 
+        #[cfg(feature = "tracing")]
+        let span_guard = trace_cmd!(command);
+
         if let Some(cached_output) = self.command_cache.get(&fingerprint) {
             command.mark_as_executed();
             self.verbose(|| println!("Cache hit: {command:?}"));
@@ -713,13 +718,12 @@ impl ExecutionContext {
                     executed_at,
                     fingerprint,
                     start_time: Instant::now(),
+                    #[cfg(feature = "tracing")]
+                    _span_guard: span_guard,
                 },
             };
         }
 
-        #[cfg(feature = "tracing")]
-        let _run_span = trace_cmd!(command);
-
         self.verbose(|| {
             println!("running: {command:?} (created at {created_at}, executed at {executed_at})")
         });
@@ -741,6 +745,8 @@ impl ExecutionContext {
                 executed_at,
                 fingerprint,
                 start_time,
+                #[cfg(feature = "tracing")]
+                _span_guard: span_guard,
             },
         }
     }
@@ -841,6 +847,7 @@ impl<'a> DeferredCommand<'a> {
                 executed_at,
                 fingerprint,
                 start_time,
+                ..
             } => {
                 let exec_ctx = exec_ctx.as_ref();
 
-- 
cgit 1.4.1-3-g733a5


From 57ee3f206ce78a5f361efbca54e58dcc799d13f0 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Sat, 12 Jul 2025 14:55:30 +0530
Subject: add span to streaming command execution flow

---
 src/bootstrap/src/utils/exec.rs | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/utils/exec.rs b/src/bootstrap/src/utils/exec.rs
index 453a4b056b2..1568c6f1524 100644
--- a/src/bootstrap/src/utils/exec.rs
+++ b/src/bootstrap/src/utils/exec.rs
@@ -604,6 +604,8 @@ pub struct StreamingCommand {
     pub stderr: Option<ChildStderr>,
     fingerprint: CommandFingerprint,
     start_time: Instant,
+    #[cfg(feature = "tracing")]
+    _span_guard: tracing::span::EnteredSpan,
 }
 
 #[must_use]
@@ -800,6 +802,10 @@ impl ExecutionContext {
         if !command.run_in_dry_run && self.dry_run() {
             return None;
         }
+
+        #[cfg(feature = "tracing")]
+        let span_guard = trace_cmd!(command);
+
         let start_time = Instant::now();
         let fingerprint = command.fingerprint();
         let cmd = &mut command.command;
@@ -813,7 +819,15 @@ impl ExecutionContext {
 
         let stdout = child.stdout.take();
         let stderr = child.stderr.take();
-        Some(StreamingCommand { child, stdout, stderr, fingerprint, start_time })
+        Some(StreamingCommand {
+            child,
+            stdout,
+            stderr,
+            fingerprint,
+            start_time,
+            #[cfg(feature = "tracing")]
+            _span_guard: span_guard,
+        })
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From a0a8e806041d08dc8877571ebd1bdab115a060ad Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 12 Jul 2025 10:37:55 +0200
Subject: fix clippy_test_deps workspace handling

---
 Cargo.lock                                   | 154 --------
 Cargo.toml                                   |   1 -
 src/tools/clippy/clippy_test_deps/Cargo.lock | 505 +++++++++++++++++++++++++++
 src/tools/clippy/clippy_test_deps/Cargo.toml |   3 +
 src/tools/miri/test_dependencies/Cargo.toml  |   1 +
 5 files changed, 509 insertions(+), 155 deletions(-)
 create mode 100644 src/tools/clippy/clippy_test_deps/Cargo.lock

diff --git a/Cargo.lock b/Cargo.lock
index 549818eecb0..43b36305ef3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -351,12 +351,6 @@ version = "0.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e"
 
-[[package]]
-name = "bytes"
-version = "1.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
-
 [[package]]
 name = "camino"
 version = "1.1.10"
@@ -636,21 +630,6 @@ dependencies = [
  "rustc-semver",
 ]
 
-[[package]]
-name = "clippy_test_deps"
-version = "0.1.0"
-dependencies = [
- "futures",
- "if_chain",
- "itertools",
- "parking_lot",
- "quote",
- "regex",
- "serde",
- "syn 2.0.104",
- "tokio",
-]
-
 [[package]]
 name = "clippy_utils"
 version = "0.1.90"
@@ -1331,95 +1310,6 @@ dependencies = [
  "new_debug_unreachable",
 ]
 
-[[package]]
-name = "futures"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-executor",
- "futures-io",
- "futures-sink",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-channel"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
-dependencies = [
- "futures-core",
- "futures-sink",
-]
-
-[[package]]
-name = "futures-core"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
-
-[[package]]
-name = "futures-executor"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
-dependencies = [
- "futures-core",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-io"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
-
-[[package]]
-name = "futures-macro"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "futures-sink"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
-
-[[package]]
-name = "futures-task"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
-
-[[package]]
-name = "futures-util"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-macro",
- "futures-sink",
- "futures-task",
- "memchr",
- "pin-project-lite",
- "pin-utils",
- "slab",
-]
-
 [[package]]
 name = "generate-copyright"
 version = "0.1.0"
@@ -1857,12 +1747,6 @@ dependencies = [
  "icu_properties",
 ]
 
-[[package]]
-name = "if_chain"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb56e1aa765b4b4f3aadfab769793b7087bb03a4ea4920644a6d238e2df5b9ed"
-
 [[package]]
 name = "ignore"
 version = "0.4.23"
@@ -1956,17 +1840,6 @@ dependencies = [
  "unic-langid",
 ]
 
-[[package]]
-name = "io-uring"
-version = "0.7.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b86e202f00093dcba4275d4636b93ef9dd75d025ae560d2521b45ea28ab49013"
-dependencies = [
- "bitflags",
- "cfg-if",
- "libc",
-]
-
 [[package]]
 name = "ipc-channel"
 version = "0.19.0"
@@ -2877,12 +2750,6 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
-[[package]]
-name = "pin-utils"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
-
 [[package]]
 name = "pkg-config"
 version = "0.3.32"
@@ -5044,12 +4911,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
-[[package]]
-name = "slab"
-version = "0.4.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
-
 [[package]]
 name = "smallvec"
 version = "1.15.1"
@@ -5490,21 +5351,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
-[[package]]
-name = "tokio"
-version = "1.46.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cc3a2344dafbe23a245241fe8b09735b521110d30fcefbbd5feb1797ca35d17"
-dependencies = [
- "backtrace",
- "bytes",
- "io-uring",
- "libc",
- "mio",
- "pin-project-lite",
- "slab",
-]
-
 [[package]]
 name = "toml"
 version = "0.5.11"
diff --git a/Cargo.toml b/Cargo.toml
index 9890027d098..6d3425f4115 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,6 @@ members = [
   "src/tools/cargotest",
   "src/tools/clippy",
   "src/tools/clippy/clippy_dev",
-  "src/tools/clippy/clippy_test_deps",
   "src/tools/collect-license-metadata",
   "src/tools/compiletest",
   "src/tools/coverage-dump",
diff --git a/src/tools/clippy/clippy_test_deps/Cargo.lock b/src/tools/clippy/clippy_test_deps/Cargo.lock
new file mode 100644
index 00000000000..a591dae3a1a
--- /dev/null
+++ b/src/tools/clippy/clippy_test_deps/Cargo.lock
@@ -0,0 +1,505 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "addr2line"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
+dependencies = [
+ "gimli",
+]
+
+[[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.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "backtrace"
+version = "0.3.75"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6806a6321ec58106fea15becdad98371e28d92ccbc7c8f1b3b6dd724fe8f1002"
+dependencies = [
+ "addr2line",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+ "windows-targets",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
+
+[[package]]
+name = "bytes"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
+
+[[package]]
+name = "clippy_test_deps"
+version = "0.1.0"
+dependencies = [
+ "futures",
+ "if_chain",
+ "itertools",
+ "parking_lot",
+ "quote",
+ "regex",
+ "serde",
+ "syn",
+ "tokio",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-util"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "gimli"
+version = "0.31.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
+
+[[package]]
+name = "if_chain"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb56e1aa765b4b4f3aadfab769793b7087bb03a4ea4920644a6d238e2df5b9ed"
+
+[[package]]
+name = "io-uring"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b86e202f00093dcba4275d4636b93ef9dd75d025ae560d2521b45ea28ab49013"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.174"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+
+[[package]]
+name = "lock_api"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+]
+
+[[package]]
+name = "mio"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys",
+]
+
+[[package]]
+name = "object"
+version = "0.36.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-targets",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d04b7d0ee6b4a0207a0a7adb104d23ecb0b47d6beae7152d0fa34b692b29fd6"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "989e6739f80c4ad5b13e0fd7fe89531180375b18520cc8c82080e4dc4035b84f"
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "serde"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "syn"
+version = "2.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tokio"
+version = "1.46.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc3a2344dafbe23a245241fe8b09735b521110d30fcefbbd5feb1797ca35d17"
+dependencies = [
+ "backtrace",
+ "bytes",
+ "io-uring",
+ "libc",
+ "mio",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "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.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
diff --git a/src/tools/clippy/clippy_test_deps/Cargo.toml b/src/tools/clippy/clippy_test_deps/Cargo.toml
index f41334f0ade..a23ffcaf2f9 100644
--- a/src/tools/clippy/clippy_test_deps/Cargo.toml
+++ b/src/tools/clippy/clippy_test_deps/Cargo.toml
@@ -15,3 +15,6 @@ futures = "0.3"
 parking_lot = "0.12"
 tokio = { version = "1", features = ["io-util"] }
 itertools = "0.12"
+
+# Make sure we are not part of the rustc workspace.
+[workspace]
diff --git a/src/tools/miri/test_dependencies/Cargo.toml b/src/tools/miri/test_dependencies/Cargo.toml
index fa833b51fa3..35555723f5d 100644
--- a/src/tools/miri/test_dependencies/Cargo.toml
+++ b/src/tools/miri/test_dependencies/Cargo.toml
@@ -34,4 +34,5 @@ windows-sys = { version = "0.59", features = [
     "Wdk_Storage_FileSystem",
 ] }
 
+# Make sure we are not part of the rustc workspace.
 [workspace]
-- 
cgit 1.4.1-3-g733a5


From b703451b34cfb4a51b8c1900bc98c851d2593cd5 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 12 Jul 2025 12:11:54 +0200
Subject: refine comment
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Jakub Beránek <berykubik@gmail.com>
---
 src/bootstrap/src/core/build_steps/tool.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index b7c1d123b4a..02241b3e697 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -1299,7 +1299,7 @@ tool_extended!(Miri {
     tool_name: "miri",
     stable: false,
     add_bins_to_sysroot: ["miri"],
-    // Avoid costly rebuilds by always including the tests.
+    // Always compile also tests when building miri. Otherwise feature unification can cause rebuilds between building and testing miri.
     cargo_args: &["--all-targets"],
 });
 tool_extended!(CargoMiri {
-- 
cgit 1.4.1-3-g733a5


From 6f8a7f00005c8b1c13c0fc0f903f0f0013530c14 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 12 Jul 2025 18:59:23 +0800
Subject: Make rustdoc-gui-test dummy compiletest config purpose explicit

---
 src/tools/compiletest/src/common.rs    | 101 +++++++++++++++++++++++++++++++++
 src/tools/rustdoc-gui-test/src/main.rs |   6 +-
 2 files changed, 102 insertions(+), 5 deletions(-)

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index f3a5b4145fd..849f44031b7 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -604,6 +604,107 @@ pub struct Config {
 }
 
 impl Config {
+    /// Incomplete config intended for `src/tools/rustdoc-gui-test` **only** as
+    /// `src/tools/rustdoc-gui-test` wants to reuse `compiletest`'s directive -> test property
+    /// handling for `//@ {compile,run}-flags`, do not use for any other purpose.
+    ///
+    /// FIXME(#143827): this setup feels very hacky. It so happens that `tests/rustdoc-gui/`
+    /// **only** uses `//@ {compile,run}-flags` for now and not any directives that actually rely on
+    /// info that is assumed available in a fully populated [`Config`].
+    pub fn incomplete_for_rustdoc_gui_test() -> Config {
+        // FIXME(#143827): spelling this out intentionally, because this is questionable.
+        //
+        // For instance, `//@ ignore-stage1` will not work at all.
+        Config {
+            mode: TestMode::Rustdoc,
+
+            // Dummy values.
+            edition: Default::default(),
+            bless: Default::default(),
+            fail_fast: Default::default(),
+            compile_lib_path: Utf8PathBuf::default(),
+            run_lib_path: Utf8PathBuf::default(),
+            rustc_path: Utf8PathBuf::default(),
+            cargo_path: Default::default(),
+            stage0_rustc_path: Default::default(),
+            rustdoc_path: Default::default(),
+            coverage_dump_path: Default::default(),
+            python: Default::default(),
+            jsondocck_path: Default::default(),
+            jsondoclint_path: Default::default(),
+            llvm_filecheck: Default::default(),
+            llvm_bin_dir: Default::default(),
+            run_clang_based_tests_with: Default::default(),
+            src_root: Utf8PathBuf::default(),
+            src_test_suite_root: Utf8PathBuf::default(),
+            build_root: Utf8PathBuf::default(),
+            build_test_suite_root: Utf8PathBuf::default(),
+            sysroot_base: Utf8PathBuf::default(),
+            stage: Default::default(),
+            stage_id: String::default(),
+            suite: Default::default(),
+            debugger: Default::default(),
+            run_ignored: Default::default(),
+            with_rustc_debug_assertions: Default::default(),
+            with_std_debug_assertions: Default::default(),
+            filters: Default::default(),
+            skip: Default::default(),
+            filter_exact: Default::default(),
+            force_pass_mode: Default::default(),
+            run: Default::default(),
+            runner: Default::default(),
+            host_rustcflags: Default::default(),
+            target_rustcflags: Default::default(),
+            rust_randomized_layout: Default::default(),
+            optimize_tests: Default::default(),
+            target: Default::default(),
+            host: Default::default(),
+            cdb: Default::default(),
+            cdb_version: Default::default(),
+            gdb: Default::default(),
+            gdb_version: Default::default(),
+            lldb_version: Default::default(),
+            llvm_version: Default::default(),
+            system_llvm: Default::default(),
+            android_cross_path: Default::default(),
+            adb_path: Default::default(),
+            adb_test_dir: Default::default(),
+            adb_device_status: Default::default(),
+            lldb_python_dir: Default::default(),
+            verbose: Default::default(),
+            format: Default::default(),
+            color: Default::default(),
+            remote_test_client: Default::default(),
+            compare_mode: Default::default(),
+            rustfix_coverage: Default::default(),
+            has_html_tidy: Default::default(),
+            has_enzyme: Default::default(),
+            channel: Default::default(),
+            git_hash: Default::default(),
+            cc: Default::default(),
+            cxx: Default::default(),
+            cflags: Default::default(),
+            cxxflags: Default::default(),
+            ar: Default::default(),
+            target_linker: Default::default(),
+            host_linker: Default::default(),
+            llvm_components: Default::default(),
+            nodejs: Default::default(),
+            npm: Default::default(),
+            force_rerun: Default::default(),
+            only_modified: Default::default(),
+            target_cfgs: Default::default(),
+            builtin_cfg_names: Default::default(),
+            supported_crate_types: Default::default(),
+            nocapture: Default::default(),
+            nightly_branch: Default::default(),
+            git_merge_commit_email: Default::default(),
+            profiler_runtime: Default::default(),
+            diff_command: Default::default(),
+            minicore_path: Default::default(),
+        }
+    }
+
     /// FIXME: this run scheme is... confusing.
     pub fn run_enabled(&self) -> bool {
         self.run.unwrap_or_else(|| {
diff --git a/src/tools/rustdoc-gui-test/src/main.rs b/src/tools/rustdoc-gui-test/src/main.rs
index dd9be8d5e7d..0e35861fbf7 100644
--- a/src/tools/rustdoc-gui-test/src/main.rs
+++ b/src/tools/rustdoc-gui-test/src/main.rs
@@ -112,11 +112,7 @@ If you want to install the `browser-ui-test` dependency, run `npm install browse
                 .current_dir(path);
 
             if let Some(librs) = find_librs(entry.path()) {
-                let compiletest_c = compiletest::common::Config {
-                    edition: None,
-                    mode: compiletest::common::TestMode::Rustdoc,
-                    ..Default::default()
-                };
+                let compiletest_c = compiletest::common::Config::incomplete_for_rustdoc_gui_test();
 
                 let test_props = TestProps::from_file(
                     &camino::Utf8PathBuf::try_from(librs).unwrap(),
-- 
cgit 1.4.1-3-g733a5


From d5bcfb334b616e01c3589ba7b1697c7ebc47a024 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Fri, 11 Jul 2025 05:07:37 -0700
Subject: Simplify codegen for niche-encoded variant tests

---
 compiler/rustc_abi/src/lib.rs                 | 35 +++++++++++-
 compiler/rustc_codegen_ssa/src/mir/operand.rs | 77 +++++++++++++++++----------
 tests/codegen/enum/enum-discriminant-eq.rs    | 42 ++++++---------
 tests/codegen/enum/enum-match.rs              | 19 ++++---
 4 files changed, 110 insertions(+), 63 deletions(-)

diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index de4b5a46c81..5bd73502d98 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -43,7 +43,7 @@ use std::fmt;
 #[cfg(feature = "nightly")]
 use std::iter::Step;
 use std::num::{NonZeroUsize, ParseIntError};
-use std::ops::{Add, AddAssign, Deref, Mul, RangeInclusive, Sub};
+use std::ops::{Add, AddAssign, Deref, Mul, RangeFull, RangeInclusive, Sub};
 use std::str::FromStr;
 
 use bitflags::bitflags;
@@ -1391,12 +1391,45 @@ impl WrappingRange {
     }
 
     /// Returns `true` if `size` completely fills the range.
+    ///
+    /// Note that this is *not* the same as `self == WrappingRange::full(size)`.
+    /// Niche calculations can produce full ranges which are not the canonical one;
+    /// for example `Option<NonZero<u16>>` gets `valid_range: (..=0) | (1..)`.
     #[inline]
     fn is_full_for(&self, size: Size) -> bool {
         let max_value = size.unsigned_int_max();
         debug_assert!(self.start <= max_value && self.end <= max_value);
         self.start == (self.end.wrapping_add(1) & max_value)
     }
+
+    /// Checks whether this range is considered non-wrapping when the values are
+    /// interpreted as *unsigned* numbers of width `size`.
+    ///
+    /// Returns `Ok(true)` if there's no wrap-around, `Ok(false)` if there is,
+    /// and `Err(..)` if the range is full so it depends how you think about it.
+    #[inline]
+    pub fn no_unsigned_wraparound(&self, size: Size) -> Result<bool, RangeFull> {
+        if self.is_full_for(size) { Err(..) } else { Ok(self.start <= self.end) }
+    }
+
+    /// Checks whether this range is considered non-wrapping when the values are
+    /// interpreted as *signed* numbers of width `size`.
+    ///
+    /// This is heavily dependent on the `size`, as `100..=200` does wrap when
+    /// interpreted as `i8`, but doesn't when interpreted as `i16`.
+    ///
+    /// Returns `Ok(true)` if there's no wrap-around, `Ok(false)` if there is,
+    /// and `Err(..)` if the range is full so it depends how you think about it.
+    #[inline]
+    pub fn no_signed_wraparound(&self, size: Size) -> Result<bool, RangeFull> {
+        if self.is_full_for(size) {
+            Err(..)
+        } else {
+            let start: i128 = size.sign_extend(self.start);
+            let end: i128 = size.sign_extend(self.end);
+            Ok(start <= end)
+        }
+    }
 }
 
 impl fmt::Debug for WrappingRange {
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index b0d191528a8..9910cb5469f 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -486,6 +486,7 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
                 // value and the variant index match, since that's all `Niche` can encode.
 
                 let relative_max = niche_variants.end().as_u32() - niche_variants.start().as_u32();
+                let niche_start_const = bx.cx().const_uint_big(tag_llty, niche_start);
 
                 // We have a subrange `niche_start..=niche_end` inside `range`.
                 // If the value of the tag is inside this subrange, it's a
@@ -511,35 +512,44 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
                     // } else {
                     //     untagged_variant
                     // }
-                    let niche_start = bx.cx().const_uint_big(tag_llty, niche_start);
-                    let is_niche = bx.icmp(IntPredicate::IntEQ, tag, niche_start);
+                    let is_niche = bx.icmp(IntPredicate::IntEQ, tag, niche_start_const);
                     let tagged_discr =
                         bx.cx().const_uint(cast_to, niche_variants.start().as_u32() as u64);
                     (is_niche, tagged_discr, 0)
                 } else {
                     // The special cases don't apply, so we'll have to go with
                     // the general algorithm.
-                    let relative_discr = bx.sub(tag, bx.cx().const_uint_big(tag_llty, niche_start));
+
+                    let tag_range = tag_scalar.valid_range(&dl);
+                    let tag_size = tag_scalar.size(&dl);
+                    let niche_end = u128::from(relative_max).wrapping_add(niche_start);
+                    let niche_end = tag_size.truncate(niche_end);
+
+                    let relative_discr = bx.sub(tag, niche_start_const);
                     let cast_tag = bx.intcast(relative_discr, cast_to, false);
-                    let is_niche = bx.icmp(
-                        IntPredicate::IntULE,
-                        relative_discr,
-                        bx.cx().const_uint(tag_llty, relative_max as u64),
-                    );
-
-                    // Thanks to parameter attributes and load metadata, LLVM already knows
-                    // the general valid range of the tag. It's possible, though, for there
-                    // to be an impossible value *in the middle*, which those ranges don't
-                    // communicate, so it's worth an `assume` to let the optimizer know.
-                    if niche_variants.contains(&untagged_variant)
-                        && bx.cx().sess().opts.optimize != OptLevel::No
-                    {
-                        let impossible =
-                            u64::from(untagged_variant.as_u32() - niche_variants.start().as_u32());
-                        let impossible = bx.cx().const_uint(tag_llty, impossible);
-                        let ne = bx.icmp(IntPredicate::IntNE, relative_discr, impossible);
-                        bx.assume(ne);
-                    }
+                    let is_niche = if tag_range.no_unsigned_wraparound(tag_size) == Ok(true) {
+                        if niche_start == tag_range.start {
+                            let niche_end_const = bx.cx().const_uint_big(tag_llty, niche_end);
+                            bx.icmp(IntPredicate::IntULE, tag, niche_end_const)
+                        } else {
+                            assert_eq!(niche_end, tag_range.end);
+                            bx.icmp(IntPredicate::IntUGE, tag, niche_start_const)
+                        }
+                    } else if tag_range.no_signed_wraparound(tag_size) == Ok(true) {
+                        if niche_start == tag_range.start {
+                            let niche_end_const = bx.cx().const_uint_big(tag_llty, niche_end);
+                            bx.icmp(IntPredicate::IntSLE, tag, niche_end_const)
+                        } else {
+                            assert_eq!(niche_end, tag_range.end);
+                            bx.icmp(IntPredicate::IntSGE, tag, niche_start_const)
+                        }
+                    } else {
+                        bx.icmp(
+                            IntPredicate::IntULE,
+                            relative_discr,
+                            bx.cx().const_uint(tag_llty, relative_max as u64),
+                        )
+                    };
 
                     (is_niche, cast_tag, niche_variants.start().as_u32() as u128)
                 };
@@ -550,11 +560,24 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
                     bx.add(tagged_discr, bx.cx().const_uint_big(cast_to, delta))
                 };
 
-                let discr = bx.select(
-                    is_niche,
-                    tagged_discr,
-                    bx.cx().const_uint(cast_to, untagged_variant.as_u32() as u64),
-                );
+                let untagged_variant_const =
+                    bx.cx().const_uint(cast_to, u64::from(untagged_variant.as_u32()));
+
+                // Thanks to parameter attributes and load metadata, LLVM already knows
+                // the general valid range of the tag. It's possible, though, for there
+                // to be an impossible value *in the middle*, which those ranges don't
+                // communicate, so it's worth an `assume` to let the optimizer know.
+                // Most importantly, this means when optimizing a variant test like
+                // `SELECT(is_niche, complex, CONST) == CONST` it's ok to simplify that
+                // to `!is_niche` because the `complex` part can't possibly match.
+                if niche_variants.contains(&untagged_variant)
+                    && bx.cx().sess().opts.optimize != OptLevel::No
+                {
+                    let ne = bx.icmp(IntPredicate::IntNE, tagged_discr, untagged_variant_const);
+                    bx.assume(ne);
+                }
+
+                let discr = bx.select(is_niche, tagged_discr, untagged_variant_const);
 
                 // In principle we could insert assumes on the possible range of `discr`, but
                 // currently in LLVM this isn't worth it because the original `tag` will
diff --git a/tests/codegen/enum/enum-discriminant-eq.rs b/tests/codegen/enum/enum-discriminant-eq.rs
index fd6f3499cb1..0494c5f551b 100644
--- a/tests/codegen/enum/enum-discriminant-eq.rs
+++ b/tests/codegen/enum/enum-discriminant-eq.rs
@@ -89,13 +89,13 @@ pub fn mid_bool_eq_discr(a: Mid<bool>, b: Mid<bool>) -> bool {
     // CHECK-LABEL: @mid_bool_eq_discr(
 
     // CHECK: %[[A_REL_DISCR:.+]] = add nsw i8 %a, -2
-    // CHECK: %[[A_IS_NICHE:.+]] = icmp ult i8 %[[A_REL_DISCR]], 3
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp samesign ugt i8 %a, 1
     // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %[[A_REL_DISCR]], 1
     // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
     // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
 
     // CHECK: %[[B_REL_DISCR:.+]] = add nsw i8 %b, -2
-    // CHECK: %[[B_IS_NICHE:.+]] = icmp ult i8 %[[B_REL_DISCR]], 3
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp samesign ugt i8 %b, 1
     // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %[[B_REL_DISCR]], 1
     // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
     // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
@@ -109,13 +109,13 @@ pub fn mid_ord_eq_discr(a: Mid<Ordering>, b: Mid<Ordering>) -> bool {
     // CHECK-LABEL: @mid_ord_eq_discr(
 
     // CHECK: %[[A_REL_DISCR:.+]] = add nsw i8 %a, -2
-    // CHECK: %[[A_IS_NICHE:.+]] = icmp ult i8 %[[A_REL_DISCR]], 3
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp sgt i8 %a, 1
     // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %[[A_REL_DISCR]], 1
     // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
     // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
 
     // CHECK: %[[B_REL_DISCR:.+]] = add nsw i8 %b, -2
-    // CHECK: %[[B_IS_NICHE:.+]] = icmp ult i8 %[[B_REL_DISCR]], 3
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp sgt i8 %b, 1
     // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %[[B_REL_DISCR]], 1
     // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
     // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
@@ -138,13 +138,13 @@ pub fn mid_ac_eq_discr(a: Mid<AC>, b: Mid<AC>) -> bool {
     // CHECK-LABEL: @mid_ac_eq_discr(
 
     // CHECK: %[[A_REL_DISCR:.+]] = xor i8 %a, -128
-    // CHECK: %[[A_IS_NICHE:.+]] = icmp ult i8 %[[A_REL_DISCR]], 3
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp slt i8 %a, 0
     // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %a, -127
     // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
     // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
 
     // CHECK: %[[B_REL_DISCR:.+]] = xor i8 %b, -128
-    // CHECK: %[[B_IS_NICHE:.+]] = icmp ult i8 %[[B_REL_DISCR]], 3
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp slt i8 %b, 0
     // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %b, -127
     // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
     // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
@@ -160,17 +160,17 @@ pub fn mid_ac_eq_discr(a: Mid<AC>, b: Mid<AC>) -> bool {
 pub fn mid_giant_eq_discr(a: Mid<Giant>, b: Mid<Giant>) -> bool {
     // CHECK-LABEL: @mid_giant_eq_discr(
 
-    // CHECK: %[[A_REL_DISCR_WIDE:.+]] = add nsw i128 %a, -5
-    // CHECK: %[[A_REL_DISCR:.+]] = trunc nsw i128 %[[A_REL_DISCR_WIDE]] to i64
-    // CHECK: %[[A_IS_NICHE:.+]] = icmp ult i128 %[[A_REL_DISCR_WIDE]], 3
-    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i128 %[[A_REL_DISCR_WIDE]], 1
+    // CHECK: %[[A_TRUNC:.+]] = trunc nuw nsw i128 %a to i64
+    // CHECK: %[[A_REL_DISCR:.+]] = add nsw i64 %[[A_TRUNC]], -5
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp samesign ugt i128 %a, 4
+    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i64 %[[A_REL_DISCR]], 1
     // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
     // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i64 %[[A_REL_DISCR]], i64 1
 
-    // CHECK: %[[B_REL_DISCR_WIDE:.+]] = add nsw i128 %b, -5
-    // CHECK: %[[B_REL_DISCR:.+]] = trunc nsw i128 %[[B_REL_DISCR_WIDE]] to i64
-    // CHECK: %[[B_IS_NICHE:.+]] = icmp ult i128 %[[B_REL_DISCR_WIDE]], 3
-    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i128 %[[B_REL_DISCR_WIDE]], 1
+    // CHECK: %[[B_TRUNC:.+]] = trunc nuw nsw i128 %b to i64
+    // CHECK: %[[B_REL_DISCR:.+]] = add nsw i64 %[[B_TRUNC]], -5
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp samesign ugt i128 %b, 4
+    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i64 %[[B_REL_DISCR]], 1
     // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
     // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i64 %[[B_REL_DISCR]], i64 1
 
@@ -181,14 +181,11 @@ pub fn mid_giant_eq_discr(a: Mid<Giant>, b: Mid<Giant>) -> bool {
 
 // In niche-encoded enums, testing for the untagged variant should optimize to a
 // straight-forward comparison looking for the natural range of the payload value.
-// FIXME: A bunch don't, though.
 
 #[unsafe(no_mangle)]
 pub fn mid_bool_is_thing(a: Mid<bool>) -> bool {
     // CHECK-LABEL: @mid_bool_is_thing(
-
-    // CHECK: %[[REL_DISCR:.+]] = add nsw i8 %a, -2
-    // CHECK: %[[R:.+]] = icmp ugt i8 %[[REL_DISCR]], 2
+    // CHECK: %[[R:.+]] = icmp samesign ult i8 %a, 2
     // CHECK: ret i1 %[[R]]
     discriminant_value(&a) == 1
 }
@@ -196,8 +193,7 @@ pub fn mid_bool_is_thing(a: Mid<bool>) -> bool {
 #[unsafe(no_mangle)]
 pub fn mid_ord_is_thing(a: Mid<Ordering>) -> bool {
     // CHECK-LABEL: @mid_ord_is_thing(
-    // CHECK: %[[REL_DISCR:.+]] = add nsw i8 %a, -2
-    // CHECK: %[[R:.+]] = icmp ugt i8 %[[REL_DISCR]], 2
+    // CHECK: %[[R:.+]] = icmp slt i8 %a, 2
     // CHECK: ret i1 %[[R]]
     discriminant_value(&a) == 1
 }
@@ -221,11 +217,7 @@ pub fn mid_ac_is_thing(a: Mid<AC>) -> bool {
 #[unsafe(no_mangle)]
 pub fn mid_giant_is_thing(a: Mid<Giant>) -> bool {
     // CHECK-LABEL: @mid_giant_is_thing(
-    // CHECK: %[[REL_DISCR_WIDE:.+]] = add nsw i128 %a, -5
-    // CHECK: %[[REL_DISCR:.+]] = trunc nsw i128 %[[REL_DISCR_WIDE]] to i64
-    // CHECK: %[[NOT_NICHE:.+]] = icmp ugt i128 %[[REL_DISCR_WIDE]], 2
-    // CHECK: %[[IS_MID_VARIANT:.+]] = icmp eq i64 %[[REL_DISCR]], 1
-    // CHECK: %[[R:.+]] = select i1 %[[NOT_NICHE]], i1 true, i1 %[[IS_MID_VARIANT]]
+    // CHECK: %[[R:.+]] = icmp samesign ult i128 %a, 5
     // CHECK: ret i1 %[[R]]
     discriminant_value(&a) == 1
 }
diff --git a/tests/codegen/enum/enum-match.rs b/tests/codegen/enum/enum-match.rs
index 9725e64def6..57db44ec74e 100644
--- a/tests/codegen/enum/enum-match.rs
+++ b/tests/codegen/enum/enum-match.rs
@@ -41,7 +41,7 @@ pub enum Enum1 {
 // CHECK-NEXT: start:
 // CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
 // CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
-// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp ult i8 %[[REL_VAR]], 2
+// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp{{( samesign)?}} ugt i8 %0, 1
 // CHECK-NEXT: %[[NICHE_DISCR:.+]] = add nuw nsw i64 %[[REL_VAR_WIDE]], 1
 // CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i64 %[[NICHE_DISCR]], i64 0
 // CHECK-NEXT: switch i64 %[[DISCR]]
@@ -148,10 +148,10 @@ pub enum MiddleNiche {
 // CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 -?[0-9]+, -?[0-9]+\))?}} i8 @match4(i8{{.+}}%0)
 // CHECK-NEXT: start:
 // CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
-// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp ult i8 %[[REL_VAR]], 5
 // CHECK-NEXT: %[[NOT_IMPOSSIBLE:.+]] = icmp ne i8 %[[REL_VAR]], 2
 // CHECK-NEXT: call void @llvm.assume(i1 %[[NOT_IMPOSSIBLE]])
-// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i8 %[[REL_VAR]], i8 2
+// CHECK-NEXT: %[[NOT_NICHE:.+]] = icmp{{( samesign)?}} ult i8 %0, 2
+// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[NOT_NICHE]], i8 2, i8 %[[REL_VAR]]
 // CHECK-NEXT: switch i8 %[[DISCR]]
 #[no_mangle]
 pub fn match4(e: MiddleNiche) -> u8 {
@@ -167,11 +167,10 @@ pub fn match4(e: MiddleNiche) -> u8 {
 
 // CHECK-LABEL: define{{.+}}i1 @match4_is_c(i8{{.+}}%e)
 // CHECK-NEXT: start
-// CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %e, -2
-// CHECK-NEXT: %[[NOT_NICHE:.+]] = icmp ugt i8 %[[REL_VAR]], 4
-// CHECK-NEXT: %[[NOT_IMPOSSIBLE:.+]] = icmp ne i8 %[[REL_VAR]], 2
+// CHECK-NEXT: %[[NOT_IMPOSSIBLE:.+]] = icmp ne i8 %e, 4
 // CHECK-NEXT: call void @llvm.assume(i1 %[[NOT_IMPOSSIBLE]])
-// CHECK-NEXT: ret i1 %[[NOT_NICHE]]
+// CHECK-NEXT: %[[IS_C:.+]] = icmp{{( samesign)?}} ult i8 %e, 2
+// CHECK-NEXT: ret i1 %[[IS_C]]
 #[no_mangle]
 pub fn match4_is_c(e: MiddleNiche) -> bool {
     // Before #139098, this couldn't optimize out the `select` because it looked
@@ -453,10 +452,10 @@ pub enum HugeVariantIndex {
 // CHECK-NEXT: start:
 // CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
 // CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
-// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp ult i8 %[[REL_VAR]], 3
-// CHECK-NEXT: %[[NOT_IMPOSSIBLE:.+]] = icmp ne i8 %[[REL_VAR]], 1
-// CHECK-NEXT: call void @llvm.assume(i1 %[[NOT_IMPOSSIBLE]])
+// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp{{( samesign)?}} ugt i8 %0, 1
 // CHECK-NEXT: %[[NICHE_DISCR:.+]] = add nuw nsw i64 %[[REL_VAR_WIDE]], 257
+// CHECK-NEXT: %[[NOT_IMPOSSIBLE:.+]] = icmp ne i64 %[[NICHE_DISCR]], 258
+// CHECK-NEXT: call void @llvm.assume(i1 %[[NOT_IMPOSSIBLE]])
 // CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i64 %[[NICHE_DISCR]], i64 258
 // CHECK-NEXT: switch i64 %[[DISCR]],
 // CHECK-NEXT:   i64 257,
-- 
cgit 1.4.1-3-g733a5


From ccc302baa0478d02d950dd2c7455a5ea19136e66 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sat, 12 Jul 2025 12:33:55 +0000
Subject: Move --compile-time-deps

---
 src/bootstrap/src/core/build_steps/compile.rs | 5 -----
 src/bootstrap/src/core/builder/cargo.rs       | 6 ++++++
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 6fb7b7e71e9..1282a89a5e4 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -2542,11 +2542,6 @@ pub fn stream_cargo(
     }
     cmd.arg("--message-format").arg(message_format);
 
-    if builder.config.compile_time_deps {
-        cmd.arg("-Zunstable-options");
-        cmd.arg("--compile-time-deps");
-    }
-
     for arg in tail_args {
         cmd.arg(arg);
     }
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index 065d7e45e0f..d5a290d804c 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -747,6 +747,12 @@ impl Builder<'_> {
         // Make cargo emit diagnostics relative to the rustc src dir.
         cargo.arg(format!("-Zroot-dir={}", self.src.display()));
 
+        if self.config.compile_time_deps {
+            // Build only build scripts and proc-macros for rust-analyzer when requested.
+            cargo.arg("-Zunstable-options");
+            cargo.arg("--compile-time-deps");
+        }
+
         // FIXME: Temporary fix for https://github.com/rust-lang/cargo/issues/3005
         // Force cargo to output binaries with disambiguating hashes in the name
         let mut metadata = if compiler.stage == 0 {
-- 
cgit 1.4.1-3-g733a5


From 10bec8f7ded3ba2fec95e177122f02653d32399a Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sat, 12 Jul 2025 12:37:03 +0000
Subject: Add change_tracker.rs entry

---
 src/bootstrap/src/utils/change_tracker.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 29591edc9cc..c5d460ac55b 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -466,4 +466,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Info,
         summary: "The --extra-checks flag now supports prefixing any check with `auto:` to only run it if relevant files are modified",
     },
+    ChangeInfo {
+        change_id: 143785,
+        severity: ChangeSeverity::Info,
+        summary: "A --compile-time-deps flag has been added to reduce the time it takes rust-analyzer to start",
+    },
 ];
-- 
cgit 1.4.1-3-g733a5


From 9ed5378cfd5b6a34000fe5218f94bd14976c3de7 Mon Sep 17 00:00:00 2001
From: b-naber <bn263@gmx.de>
Date: Fri, 11 Jul 2025 10:57:54 +0200
Subject: replace binding and shadowed_glob on NameResolution with
 non_glob_binding and glob_binding

---
 compiler/rustc_resolve/src/check_unused.rs     |  2 +-
 compiler/rustc_resolve/src/diagnostics.rs      |  4 +-
 compiler/rustc_resolve/src/ident.rs            |  4 +-
 compiler/rustc_resolve/src/imports.rs          | 85 +++++++++++++++-----------
 compiler/rustc_resolve/src/late.rs             |  6 +-
 compiler/rustc_resolve/src/late/diagnostics.rs | 29 +++++----
 compiler/rustc_resolve/src/lib.rs              |  2 +-
 7 files changed, 77 insertions(+), 55 deletions(-)

diff --git a/compiler/rustc_resolve/src/check_unused.rs b/compiler/rustc_resolve/src/check_unused.rs
index 2e870c47f8e..81ee02ac3c7 100644
--- a/compiler/rustc_resolve/src/check_unused.rs
+++ b/compiler/rustc_resolve/src/check_unused.rs
@@ -511,7 +511,7 @@ impl Resolver<'_, '_> {
             for (_key, resolution) in self.resolutions(*module).borrow().iter() {
                 let resolution = resolution.borrow();
 
-                if let Some(binding) = resolution.binding
+                if let Some(binding) = resolution.best_binding()
                     && let NameBindingKind::Import { import, .. } = binding.kind
                     && let ImportKind::Single { id, .. } = import.kind
                 {
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index c4ff5770e76..b2f16fb1dfb 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1440,7 +1440,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         |(key, name_resolution)| {
                             if key.ns == TypeNS
                                 && key.ident == ident
-                                && let Some(binding) = name_resolution.borrow().binding
+                                && let Some(binding) = name_resolution.borrow().best_binding()
                             {
                                 match binding.res() {
                                     // No disambiguation needed if the identically named item we
@@ -1494,7 +1494,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     return None;
                 };
                 for (_, resolution) in this.resolutions(m).borrow().iter() {
-                    let Some(binding) = resolution.borrow().binding else {
+                    let Some(binding) = resolution.borrow().best_binding() else {
                         continue;
                     };
                     let Res::Def(DefKind::Macro(MacroKind::Derive | MacroKind::Attr), def_id) =
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 558cbef0014..20fe382ee67 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -875,7 +875,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // binding if it exists. What we really want here is having two separate scopes in
         // a module - one for non-globs and one for globs, but until that's done use this
         // hack to avoid inconsistent resolution ICEs during import validation.
-        let binding = [resolution.binding, resolution.shadowed_glob]
+        let binding = [resolution.non_glob_binding, resolution.glob_binding]
             .into_iter()
             .find_map(|binding| if binding == ignore_binding { None } else { binding });
 
@@ -883,7 +883,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             return self.finalize_module_binding(
                 ident,
                 binding,
-                resolution.shadowed_glob,
+                if resolution.non_glob_binding.is_some() { resolution.glob_binding } else { None },
                 parent_scope,
                 finalize,
                 shadowing,
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 2e81b54b136..e2bb05c9d3f 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -242,15 +242,16 @@ pub(crate) struct NameResolution<'ra> {
     /// Single imports that may define the name in the namespace.
     /// Imports are arena-allocated, so it's ok to use pointers as keys.
     pub single_imports: FxIndexSet<Import<'ra>>,
-    /// The least shadowable known binding for this name, or None if there are no known bindings.
-    pub binding: Option<NameBinding<'ra>>,
-    pub shadowed_glob: Option<NameBinding<'ra>>,
+    /// The non-glob binding for this name, if it is known to exist.
+    pub non_glob_binding: Option<NameBinding<'ra>>,
+    /// The glob binding for this name, if it is known to exist.
+    pub glob_binding: Option<NameBinding<'ra>>,
 }
 
 impl<'ra> NameResolution<'ra> {
     /// Returns the binding for the name if it is known or None if it not known.
     pub(crate) fn binding(&self) -> Option<NameBinding<'ra>> {
-        self.binding.and_then(|binding| {
+        self.best_binding().and_then(|binding| {
             if !binding.is_glob_import() || self.single_imports.is_empty() {
                 Some(binding)
             } else {
@@ -258,6 +259,10 @@ impl<'ra> NameResolution<'ra> {
             }
         })
     }
+
+    pub(crate) fn best_binding(&self) -> Option<NameBinding<'ra>> {
+        self.non_glob_binding.or(self.glob_binding)
+    }
 }
 
 /// An error that may be transformed into a diagnostic later. Used to combine multiple unresolved
@@ -338,69 +343,71 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         self.check_reserved_macro_name(key.ident, res);
         self.set_binding_parent_module(binding, module);
         self.update_resolution(module, key, warn_ambiguity, |this, resolution| {
-            if let Some(old_binding) = resolution.binding {
+            if let Some(old_binding) = resolution.best_binding() {
                 if res == Res::Err && old_binding.res() != Res::Err {
                     // Do not override real bindings with `Res::Err`s from error recovery.
                     return Ok(());
                 }
                 match (old_binding.is_glob_import(), binding.is_glob_import()) {
                     (true, true) => {
+                        let (glob_binding, old_glob_binding) = (binding, old_binding);
                         // FIXME: remove `!binding.is_ambiguity_recursive()` after delete the warning ambiguity.
                         if !binding.is_ambiguity_recursive()
                             && let NameBindingKind::Import { import: old_import, .. } =
-                                old_binding.kind
-                            && let NameBindingKind::Import { import, .. } = binding.kind
+                                old_glob_binding.kind
+                            && let NameBindingKind::Import { import, .. } = glob_binding.kind
                             && old_import == import
                         {
-                            // We should replace the `old_binding` with `binding` regardless
-                            // of whether they has same resolution or not when they are
-                            // imported from the same glob-import statement.
-                            resolution.binding = Some(binding);
-                        } else if res != old_binding.res() {
-                            resolution.binding = Some(this.new_ambiguity_binding(
+                            // When imported from the same glob-import statement, we should replace
+                            // `old_glob_binding` with `glob_binding`, regardless of whether
+                            // they have the same resolution or not.
+                            resolution.glob_binding = Some(glob_binding);
+                        } else if res != old_glob_binding.res() {
+                            resolution.glob_binding = Some(this.new_ambiguity_binding(
                                 AmbiguityKind::GlobVsGlob,
-                                old_binding,
-                                binding,
+                                old_glob_binding,
+                                glob_binding,
                                 warn_ambiguity,
                             ));
                         } else if !old_binding.vis.is_at_least(binding.vis, this.tcx) {
                             // We are glob-importing the same item but with greater visibility.
-                            resolution.binding = Some(binding);
+                            resolution.glob_binding = Some(glob_binding);
                         } else if binding.is_ambiguity_recursive() {
-                            resolution.binding = Some(this.new_warn_ambiguity_binding(binding));
+                            resolution.glob_binding =
+                                Some(this.new_warn_ambiguity_binding(glob_binding));
                         }
                     }
                     (old_glob @ true, false) | (old_glob @ false, true) => {
-                        let (glob_binding, nonglob_binding) =
+                        let (glob_binding, non_glob_binding) =
                             if old_glob { (old_binding, binding) } else { (binding, old_binding) };
                         if key.ns == MacroNS
-                            && nonglob_binding.expansion != LocalExpnId::ROOT
-                            && glob_binding.res() != nonglob_binding.res()
+                            && non_glob_binding.expansion != LocalExpnId::ROOT
+                            && glob_binding.res() != non_glob_binding.res()
                         {
-                            resolution.binding = Some(this.new_ambiguity_binding(
+                            resolution.non_glob_binding = Some(this.new_ambiguity_binding(
                                 AmbiguityKind::GlobVsExpanded,
-                                nonglob_binding,
+                                non_glob_binding,
                                 glob_binding,
                                 false,
                             ));
                         } else {
-                            resolution.binding = Some(nonglob_binding);
+                            resolution.non_glob_binding = Some(non_glob_binding);
                         }
 
-                        if let Some(old_shadowed_glob) = resolution.shadowed_glob {
-                            assert!(old_shadowed_glob.is_glob_import());
-                            if glob_binding.res() != old_shadowed_glob.res() {
-                                resolution.shadowed_glob = Some(this.new_ambiguity_binding(
+                        if let Some(old_glob_binding) = resolution.glob_binding {
+                            assert!(old_glob_binding.is_glob_import());
+                            if glob_binding.res() != old_glob_binding.res() {
+                                resolution.glob_binding = Some(this.new_ambiguity_binding(
                                     AmbiguityKind::GlobVsGlob,
-                                    old_shadowed_glob,
+                                    old_glob_binding,
                                     glob_binding,
                                     false,
                                 ));
-                            } else if !old_shadowed_glob.vis.is_at_least(binding.vis, this.tcx) {
-                                resolution.shadowed_glob = Some(glob_binding);
+                            } else if !old_glob_binding.vis.is_at_least(binding.vis, this.tcx) {
+                                resolution.glob_binding = Some(glob_binding);
                             }
                         } else {
-                            resolution.shadowed_glob = Some(glob_binding);
+                            resolution.glob_binding = Some(glob_binding);
                         }
                     }
                     (false, false) => {
@@ -408,7 +415,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     }
                 }
             } else {
-                resolution.binding = Some(binding);
+                if binding.is_glob_import() {
+                    resolution.glob_binding = Some(binding);
+                } else {
+                    resolution.non_glob_binding = Some(binding);
+                }
             }
 
             Ok(())
@@ -628,7 +639,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             for (key, resolution) in self.resolutions(*module).borrow().iter() {
                 let resolution = resolution.borrow();
 
-                let Some(binding) = resolution.binding else { continue };
+                let Some(binding) = resolution.best_binding() else { continue };
 
                 if let NameBindingKind::Import { import, .. } = binding.kind
                     && let Some((amb_binding, _)) = binding.ambiguity
@@ -648,7 +659,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     );
                 }
 
-                if let Some(glob_binding) = resolution.shadowed_glob {
+                if let Some(glob_binding) = resolution.glob_binding
+                    && resolution.non_glob_binding.is_some()
+                {
                     if binding.res() != Res::Err
                         && glob_binding.res() != Res::Err
                         && let NameBindingKind::Import { import: glob_import, .. } =
@@ -1179,7 +1192,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             return None;
                         } // Never suggest the same name
                         match *resolution.borrow() {
-                            NameResolution { binding: Some(name_binding), .. } => {
+                            ref resolution
+                                if let Some(name_binding) = resolution.best_binding() =>
+                            {
                                 match name_binding.kind {
                                     NameBindingKind::Import { binding, .. } => {
                                         match binding.kind {
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 08629090bb1..44a567f7810 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -3437,7 +3437,8 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         };
         ident.span.normalize_to_macros_2_0_and_adjust(module.expansion);
         let key = BindingKey::new(ident, ns);
-        let mut binding = self.r.resolution(module, key).try_borrow().ok().and_then(|r| r.binding);
+        let mut binding =
+            self.r.resolution(module, key).try_borrow().ok().and_then(|r| r.best_binding());
         debug!(?binding);
         if binding.is_none() {
             // We could not find the trait item in the correct namespace.
@@ -3448,7 +3449,8 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 _ => ns,
             };
             let key = BindingKey::new(ident, ns);
-            binding = self.r.resolution(module, key).try_borrow().ok().and_then(|r| r.binding);
+            binding =
+                self.r.resolution(module, key).try_borrow().ok().and_then(|r| r.best_binding());
             debug!(?binding);
         }
 
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index 8114021510e..b669796bb02 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -880,8 +880,10 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
     fn lookup_doc_alias_name(&mut self, path: &[Segment], ns: Namespace) -> Option<(DefId, Ident)> {
         let find_doc_alias_name = |r: &mut Resolver<'ra, '_>, m: Module<'ra>, item_name: Symbol| {
             for resolution in r.resolutions(m).borrow().values() {
-                let Some(did) =
-                    resolution.borrow().binding.and_then(|binding| binding.res().opt_def_id())
+                let Some(did) = resolution
+                    .borrow()
+                    .best_binding()
+                    .and_then(|binding| binding.res().opt_def_id())
                 else {
                     continue;
                 };
@@ -1464,15 +1466,16 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                 self.resolve_path(mod_path, None, None)
             {
                 let resolutions = self.r.resolutions(module).borrow();
-                let targets: Vec<_> =
-                    resolutions
-                        .iter()
-                        .filter_map(|(key, resolution)| {
-                            resolution.borrow().binding.map(|binding| binding.res()).and_then(
-                                |res| if filter_fn(res) { Some((key, res)) } else { None },
-                            )
-                        })
-                        .collect();
+                let targets: Vec<_> = resolutions
+                    .iter()
+                    .filter_map(|(key, resolution)| {
+                        resolution
+                            .borrow()
+                            .best_binding()
+                            .map(|binding| binding.res())
+                            .and_then(|res| if filter_fn(res) { Some((key, res)) } else { None })
+                    })
+                    .collect();
                 if let [target] = targets.as_slice() {
                     return Some(TypoSuggestion::single_item_from_ident(target.0.ident, target.1));
                 }
@@ -2305,7 +2308,9 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
         let targets = resolutions
             .borrow()
             .iter()
-            .filter_map(|(key, res)| res.borrow().binding.map(|binding| (key, binding.res())))
+            .filter_map(|(key, res)| {
+                res.borrow().best_binding().map(|binding| (key, binding.res()))
+            })
             .filter(|(_, res)| match (kind, res) {
                 (AssocItemKind::Const(..), Res::Def(DefKind::AssocConst, _)) => true,
                 (AssocItemKind::Fn(_), Res::Def(DefKind::AssocFn, _)) => true,
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 6e4c5ef1909..f9b12afe0f2 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -641,7 +641,7 @@ impl<'ra> Module<'ra> {
         F: FnMut(&mut R, Ident, Namespace, NameBinding<'ra>),
     {
         for (key, name_resolution) in resolver.as_mut().resolutions(self).borrow().iter() {
-            if let Some(binding) = name_resolution.borrow().binding {
+            if let Some(binding) = name_resolution.borrow().best_binding() {
                 f(resolver, key.ident, key.ns, binding);
             }
         }
-- 
cgit 1.4.1-3-g733a5


From a9a238ba5b298857dc2999d8ed5b10e70eafe196 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Sat, 12 Jul 2025 19:23:58 +0530
Subject: explicitly drop span_guard in wait_for_output

---
 src/bootstrap/src/utils/exec.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/utils/exec.rs b/src/bootstrap/src/utils/exec.rs
index 1568c6f1524..9f7f3224f2b 100644
--- a/src/bootstrap/src/utils/exec.rs
+++ b/src/bootstrap/src/utils/exec.rs
@@ -861,13 +861,17 @@ impl<'a> DeferredCommand<'a> {
                 executed_at,
                 fingerprint,
                 start_time,
-                ..
+                #[cfg(feature = "tracing")]
+                _span_guard,
             } => {
                 let exec_ctx = exec_ctx.as_ref();
 
                 let output =
                     Self::finish_process(process, command, stdout, stderr, executed_at, exec_ctx);
 
+                #[cfg(feature = "tracing")]
+                drop(_span_guard);
+
                 if (!exec_ctx.dry_run() || command.run_in_dry_run)
                     && output.status().is_some()
                     && command.should_cache
-- 
cgit 1.4.1-3-g733a5


From 0bb092a93fa32ac5d68fdeb4fc0482705a25247b Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Sat, 12 Jul 2025 10:28:44 -0400
Subject: Fix building the sysroot

---
 build_system/build_sysroot/Cargo.lock | 502 ----------------------------------
 build_system/build_sysroot/Cargo.toml |  39 ---
 build_system/build_sysroot/lib.rs     |   1 -
 build_system/src/build.rs             |  35 +--
 build_system/src/utils.rs             |  13 -
 5 files changed, 10 insertions(+), 580 deletions(-)
 delete mode 100644 build_system/build_sysroot/Cargo.lock
 delete mode 100644 build_system/build_sysroot/Cargo.toml
 delete mode 100644 build_system/build_sysroot/lib.rs

diff --git a/build_system/build_sysroot/Cargo.lock b/build_system/build_sysroot/Cargo.lock
deleted file mode 100644
index 0c75977ee79..00000000000
--- a/build_system/build_sysroot/Cargo.lock
+++ /dev/null
@@ -1,502 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "addr2line"
-version = "0.24.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
-dependencies = [
- "compiler_builtins",
- "gimli",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "adler2"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "alloc"
-version = "0.0.0"
-dependencies = [
- "compiler_builtins",
- "core",
-]
-
-[[package]]
-name = "alloctests"
-version = "0.0.0"
-dependencies = [
- "rand",
- "rand_xorshift",
-]
-
-[[package]]
-name = "cc"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1aeb932158bd710538c73702db6945cb68a8fb08c519e6e12706b94263b36db8"
-dependencies = [
- "shlex",
-]
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "compiler_builtins"
-version = "0.1.160"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6376049cfa92c0aa8b9ac95fae22184b981c658208d4ed8a1dc553cd83612895"
-dependencies = [
- "cc",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "core"
-version = "0.0.0"
-
-[[package]]
-name = "coretests"
-version = "0.0.0"
-dependencies = [
- "rand",
- "rand_xorshift",
-]
-
-[[package]]
-name = "dlmalloc"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cff88b751e7a276c4ab0e222c3f355190adc6dde9ce39c851db39da34990df7"
-dependencies = [
- "cfg-if",
- "compiler_builtins",
- "libc",
- "rustc-std-workspace-core",
- "windows-sys",
-]
-
-[[package]]
-name = "fortanix-sgx-abi"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57cafc2274c10fab234f176b25903ce17e690fca7597090d50880e047a0389c5"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "getopts"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
-dependencies = [
- "rustc-std-workspace-core",
- "rustc-std-workspace-std",
- "unicode-width",
-]
-
-[[package]]
-name = "gimli"
-version = "0.31.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.15.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84b26c544d002229e640969970a2e74021aadf6e2f96372b9c58eff97de08eb3"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "hermit-abi"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f154ce46856750ed433c8649605bf7ed2de3bc35fd9d2a9f30cddd873c80cb08"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.172"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
-dependencies = [
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "memchr"
-version = "2.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "miniz_oxide"
-version = "0.8.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3be647b768db090acb35d5ec5db2b0e1f1de11133ca123b9eacf5137868f892a"
-dependencies = [
- "adler2",
- "compiler_builtins",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "object"
-version = "0.36.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
-dependencies = [
- "compiler_builtins",
- "memchr",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "panic_abort"
-version = "0.0.0"
-dependencies = [
- "alloc",
- "compiler_builtins",
- "core",
- "libc",
-]
-
-[[package]]
-name = "panic_unwind"
-version = "0.0.0"
-dependencies = [
- "alloc",
- "cfg-if",
- "compiler_builtins",
- "core",
- "libc",
- "unwind",
-]
-
-[[package]]
-name = "proc_macro"
-version = "0.0.0"
-dependencies = [
- "core",
- "rustc-literal-escaper",
- "std",
-]
-
-[[package]]
-name = "profiler_builtins"
-version = "0.0.0"
-dependencies = [
- "cc",
-]
-
-[[package]]
-name = "r-efi"
-version = "5.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "r-efi-alloc"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e43c53ff1a01d423d1cb762fd991de07d32965ff0ca2e4f80444ac7804198203"
-dependencies = [
- "compiler_builtins",
- "r-efi",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "rand"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
-dependencies = [
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
-
-[[package]]
-name = "rand_xorshift"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
-dependencies = [
- "rand_core",
-]
-
-[[package]]
-name = "rustc-demangle"
-version = "0.1.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "rustc-literal-escaper"
-version = "0.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0041b6238913c41fe704213a4a9329e2f685a156d1781998128b4149c230ad04"
-dependencies = [
- "rustc-std-workspace-std",
-]
-
-[[package]]
-name = "rustc-std-workspace-alloc"
-version = "1.99.0"
-dependencies = [
- "alloc",
-]
-
-[[package]]
-name = "rustc-std-workspace-core"
-version = "1.99.0"
-dependencies = [
- "core",
-]
-
-[[package]]
-name = "rustc-std-workspace-std"
-version = "1.99.0"
-dependencies = [
- "std",
-]
-
-[[package]]
-name = "shlex"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
-
-[[package]]
-name = "std"
-version = "0.0.0"
-dependencies = [
- "addr2line",
- "alloc",
- "cfg-if",
- "compiler_builtins",
- "core",
- "dlmalloc",
- "fortanix-sgx-abi",
- "hashbrown",
- "hermit-abi",
- "libc",
- "miniz_oxide",
- "object",
- "panic_abort",
- "panic_unwind",
- "r-efi",
- "r-efi-alloc",
- "rand",
- "rand_xorshift",
- "rustc-demangle",
- "std_detect",
- "unwind",
- "wasi",
- "windows-targets 0.0.0",
-]
-
-[[package]]
-name = "std_detect"
-version = "0.1.5"
-dependencies = [
- "cfg-if",
- "compiler_builtins",
- "libc",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "sysroot"
-version = "0.0.0"
-dependencies = [
- "proc_macro",
- "profiler_builtins",
- "std",
- "test",
-]
-
-[[package]]
-name = "test"
-version = "0.0.0"
-dependencies = [
- "core",
- "getopts",
- "libc",
- "std",
-]
-
-[[package]]
-name = "unicode-width"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-core",
- "rustc-std-workspace-std",
-]
-
-[[package]]
-name = "unwind"
-version = "0.0.0"
-dependencies = [
- "cfg-if",
- "compiler_builtins",
- "core",
- "libc",
- "unwinding",
-]
-
-[[package]]
-name = "unwinding"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8393f2782b6060a807337ff353780c1ca15206f9ba2424df18cb6e733bd7b345"
-dependencies = [
- "compiler_builtins",
- "gimli",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-dependencies = [
- "compiler_builtins",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.59.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
-dependencies = [
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.0.0"
-
-[[package]]
-name = "windows-targets"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
-dependencies = [
- "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.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
diff --git a/build_system/build_sysroot/Cargo.toml b/build_system/build_sysroot/Cargo.toml
deleted file mode 100644
index 29a3bcec304..00000000000
--- a/build_system/build_sysroot/Cargo.toml
+++ /dev/null
@@ -1,39 +0,0 @@
-[package]
-authors = ["rustc_codegen_gcc devs"]
-name = "sysroot"
-version = "0.0.0"
-resolver = "2"
-
-[dependencies]
-core = { path = "./sysroot_src/library/core" }
-compiler_builtins = { path = "./sysroot_src/library/compiler-builtins/compiler-builtins" }
-alloc = { path = "./sysroot_src/library/alloc" }
-std = { path = "./sysroot_src/library/std", features = ["panic_unwind", "backtrace"] }
-test = { path = "./sysroot_src/library/test" }
-proc_macro = { path = "./sysroot_src/library/proc_macro" }
-
-[patch.crates-io]
-rustc-std-workspace-core = { path = "./sysroot_src/library/rustc-std-workspace-core" }
-rustc-std-workspace-alloc = { path = "./sysroot_src/library/rustc-std-workspace-alloc" }
-rustc-std-workspace-std = { path = "./sysroot_src/library/rustc-std-workspace-std" }
-compiler_builtins = { path = "./sysroot_src/library/compiler-builtins/compiler-builtins" }
-
-# For compiler-builtins we always use a high number of codegen units.
-# The goal here is to place every single intrinsic into its own object
-# file to avoid symbol clashes with the system libgcc if possible. Note
-# that this number doesn't actually produce this many object files, we
-# just don't create more than this number of object files.
-#
-# It's a bit of a bummer that we have to pass this here, unfortunately.
-# Ideally this would be specified through an env var to Cargo so Cargo
-# knows how many CGUs are for this specific crate, but for now
-# per-crate configuration isn't specifiable in the environment.
-[profile.dev.package.compiler_builtins]
-codegen-units = 10000
-
-[profile.release.package.compiler_builtins]
-codegen-units = 10000
-
-[profile.release]
-debug = "limited"
-#lto = "fat" # TODO(antoyo): re-enable when the failing LTO tests regarding proc-macros are fixed.
diff --git a/build_system/build_sysroot/lib.rs b/build_system/build_sysroot/lib.rs
deleted file mode 100644
index 0c9ac1ac8e4..00000000000
--- a/build_system/build_sysroot/lib.rs
+++ /dev/null
@@ -1 +0,0 @@
-#![no_std]
diff --git a/build_system/src/build.rs b/build_system/src/build.rs
index ecc4c1b2fe2..8c09ea3ba42 100644
--- a/build_system/src/build.rs
+++ b/build_system/src/build.rs
@@ -5,7 +5,7 @@ use std::path::Path;
 
 use crate::config::{Channel, ConfigInfo};
 use crate::utils::{
-    copy_file, create_dir, get_sysroot_dir, run_command, run_command_with_output_and_env, walk_dir,
+    create_dir, get_sysroot_dir, run_command, run_command_with_output_and_env, walk_dir,
 };
 
 #[derive(Default)]
@@ -53,11 +53,11 @@ impl BuildArg {
     }
 }
 
-fn cleanup_sysroot_previous_build(start_dir: &Path) {
+fn cleanup_sysroot_previous_build(library_dir: &Path) {
     // Cleanup for previous run
     // Clean target dir except for build scripts and incremental cache
     let _ = walk_dir(
-        start_dir.join("target"),
+        library_dir.join("target"),
         &mut |dir: &Path| {
             for top in &["debug", "release"] {
                 let _ = fs::remove_dir_all(dir.join(top).join("build"));
@@ -96,30 +96,14 @@ fn cleanup_sysroot_previous_build(start_dir: &Path) {
         false,
     );
 
-    let _ = fs::remove_file(start_dir.join("Cargo.lock"));
-    let _ = fs::remove_file(start_dir.join("test_target/Cargo.lock"));
-    let _ = fs::remove_dir_all(start_dir.join("sysroot"));
-}
-
-pub fn create_build_sysroot_content(start_dir: &Path) -> Result<(), String> {
-    if !start_dir.is_dir() {
-        create_dir(start_dir)?;
-    }
-    copy_file("build_system/build_sysroot/Cargo.toml", start_dir.join("Cargo.toml"))?;
-    copy_file("build_system/build_sysroot/Cargo.lock", start_dir.join("Cargo.lock"))?;
-
-    let src_dir = start_dir.join("src");
-    if !src_dir.is_dir() {
-        create_dir(&src_dir)?;
-    }
-    copy_file("build_system/build_sysroot/lib.rs", start_dir.join("src/lib.rs"))
+    let _ = fs::remove_file(library_dir.join("Cargo.lock"));
 }
 
 pub fn build_sysroot(env: &HashMap<String, String>, config: &ConfigInfo) -> Result<(), String> {
     let start_dir = get_sysroot_dir();
 
-    cleanup_sysroot_previous_build(&start_dir);
-    create_build_sysroot_content(&start_dir)?;
+    let library_dir = start_dir.join("sysroot_src").join("library");
+    cleanup_sysroot_previous_build(&library_dir);
 
     // Builds libs
     let mut rustflags = env.get("RUSTFLAGS").cloned().unwrap_or_default();
@@ -159,7 +143,8 @@ pub fn build_sysroot(env: &HashMap<String, String>, config: &ConfigInfo) -> Resu
 
     let mut env = env.clone();
     env.insert("RUSTFLAGS".to_string(), rustflags);
-    run_command_with_output_and_env(&args, Some(&start_dir), Some(&env))?;
+    let sysroot_dir = library_dir.join("sysroot");
+    run_command_with_output_and_env(&args, Some(&sysroot_dir), Some(&env))?;
 
     // Copy files to sysroot
     let sysroot_path = start_dir.join(format!("sysroot/lib/rustlib/{}/lib/", config.target_triple));
@@ -169,7 +154,7 @@ pub fn build_sysroot(env: &HashMap<String, String>, config: &ConfigInfo) -> Resu
         run_command(&[&"cp", &"-r", &dir_to_copy, &sysroot_path], None).map(|_| ())
     };
     walk_dir(
-        start_dir.join(format!("target/{}/{}/deps", config.target_triple, channel)),
+        library_dir.join(format!("target/{}/{}/deps", config.target_triple, channel)),
         &mut copier.clone(),
         &mut copier,
         false,
@@ -178,7 +163,7 @@ pub fn build_sysroot(env: &HashMap<String, String>, config: &ConfigInfo) -> Resu
     // Copy the source files to the sysroot (Rust for Linux needs this).
     let sysroot_src_path = start_dir.join("sysroot/lib/rustlib/src/rust");
     create_dir(&sysroot_src_path)?;
-    run_command(&[&"cp", &"-r", &start_dir.join("sysroot_src/library/"), &sysroot_src_path], None)?;
+    run_command(&[&"cp", &"-r", &library_dir, &sysroot_src_path], None)?;
 
     Ok(())
 }
diff --git a/build_system/src/utils.rs b/build_system/src/utils.rs
index d77707d5f17..fc948c54b24 100644
--- a/build_system/src/utils.rs
+++ b/build_system/src/utils.rs
@@ -303,19 +303,6 @@ pub fn create_dir<P: AsRef<Path>>(path: P) -> Result<(), String> {
     })
 }
 
-pub fn copy_file<F: AsRef<Path>, T: AsRef<Path>>(from: F, to: T) -> Result<(), String> {
-    fs::copy(&from, &to)
-        .map_err(|error| {
-            format!(
-                "Failed to copy file `{}` into `{}`: {:?}",
-                from.as_ref().display(),
-                to.as_ref().display(),
-                error
-            )
-        })
-        .map(|_| ())
-}
-
 /// This function differs from `git_clone` in how it handles *where* the repository will be cloned.
 /// In `git_clone`, it is cloned in the provided path. In this function, the path you provide is
 /// the parent folder. So if you pass "a" as folder and try to clone "b.git", it will be cloned into
-- 
cgit 1.4.1-3-g733a5


From 1954034e3472d2c8c8229e029e92b81db5809f9c Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Sat, 12 Jul 2025 10:44:48 -0400
Subject: Comment test that cannot be fixed currently

---
 build_system/src/build.rs        |  2 --
 example/mini_core_hello_world.rs | 17 ++++++++++++-----
 2 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/build_system/src/build.rs b/build_system/src/build.rs
index 8c09ea3ba42..4033ffe0694 100644
--- a/build_system/src/build.rs
+++ b/build_system/src/build.rs
@@ -95,8 +95,6 @@ fn cleanup_sysroot_previous_build(library_dir: &Path) {
         &mut |_| Ok(()),
         false,
     );
-
-    let _ = fs::remove_file(library_dir.join("Cargo.lock"));
 }
 
 pub fn build_sysroot(env: &HashMap<String, String>, config: &ConfigInfo) -> Result<(), String> {
diff --git a/example/mini_core_hello_world.rs b/example/mini_core_hello_world.rs
index 6b6f71edaf8..092fd6a7640 100644
--- a/example/mini_core_hello_world.rs
+++ b/example/mini_core_hello_world.rs
@@ -6,7 +6,7 @@
 )]
 #![no_core]
 #![allow(dead_code, internal_features, non_camel_case_types)]
-#![rustfmt::skip]
+#![cfg_attr(rustfmt, rustfmt_skip)]
 
 extern crate mini_core;
 
@@ -198,10 +198,17 @@ fn main() {
         assert_eq!(intrinsics::align_of::<u16>() as u8, 2);
         assert_eq!(intrinsics::align_of_val(&a) as u8, intrinsics::align_of::<&str>() as u8);
 
-        assert!(!const { intrinsics::needs_drop::<u8>() });
-        assert!(!const { intrinsics::needs_drop::<[u8]>() });
-        assert!(const { intrinsics::needs_drop::<NoisyDrop>() });
-        assert!(const { intrinsics::needs_drop::<NoisyDropUnsized>() });
+        /*
+         * TODO: re-enable in the next sync.
+        let u8_needs_drop = const { intrinsics::needs_drop::<u8>() };
+        assert!(!u8_needs_drop);
+        let slice_needs_drop = const { intrinsics::needs_drop::<[u8]>() };
+        assert!(!slice_needs_drop);
+        let noisy_drop = const { intrinsics::needs_drop::<NoisyDrop>() };
+        assert!(noisy_drop);
+        let noisy_unsized_drop = const { intrinsics::needs_drop::<NoisyDropUnsized>() };
+        assert!(noisy_unsized_drop);
+        */
 
         Unique {
             pointer: 0 as *const &str,
-- 
cgit 1.4.1-3-g733a5


From 8011058d90eb79a4ca0727fc1c2f62f77a964a19 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 12 Jul 2025 23:12:15 +0800
Subject: Make it clearer which key-values belong to which autolabel

---
 triagebot.toml | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/triagebot.toml b/triagebot.toml
index 9f8ea2dad52..ca6770b10fa 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -216,7 +216,6 @@ trigger_files = [
 exclude_labels = [
     "T-*",
 ]
-
 trigger_labels = [
     "A-rustdoc-json",
     "A-rustdoc-type-layout",
@@ -265,7 +264,6 @@ trigger_labels = [
     "A-rustdoc-ui",
     "A-rustdoc-js",
 ]
-
 trigger_files = [
     "src/librustdoc/html/",
     "tests/rustdoc/",
@@ -281,7 +279,6 @@ trigger_files = [
     "tests/rustdoc-js/",
     "tests/rustdoc-js-std",
 ]
-
 trigger_labels = [
     "A-type-based-search",
 ]
@@ -311,20 +308,17 @@ trigger_files = [
 exclude_labels = [
     "T-*",
 ]
-
 trigger_labels = [
     "D-*",
     "A-diagnostics",
 ]
 
 [autolabel."A-diagnostics"]
-
 trigger_labels = [
     "D-*",
 ]
 
 [autolabel."A-lints"]
-
 trigger_labels = [
     "L-*",
 ]
-- 
cgit 1.4.1-3-g733a5


From 869c0e729b5220d7dfdb32f63fb9f4f84e2a09be Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 12 Jul 2025 23:13:46 +0800
Subject: Hoist the more "special" autolabels to the start of the section

---
 triagebot.toml | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/triagebot.toml b/triagebot.toml
index ca6770b10fa..a534e1dceb1 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -171,6 +171,19 @@ adjusting release notes. Could you take a look if available? Thanks <3
 [prioritize]
 label = "I-prioritize"
 
+[autolabel."S-waiting-on-review"]
+new_pr = true
+
+[autolabel."S-waiting-on-author"]
+new_draft = true
+
+[autolabel."needs-triage"]
+new_issue = true
+exclude_labels = [
+    "C-tracking-issue",
+    "A-diagnostics",
+]
+
 [autolabel."I-prioritize"]
 trigger_labels = [
     "regression-untriaged",
@@ -526,19 +539,6 @@ trigger_files = [
     "src/version"
 ]
 
-[autolabel."S-waiting-on-review"]
-new_pr = true
-
-[autolabel."S-waiting-on-author"]
-new_draft = true
-
-[autolabel."needs-triage"]
-new_issue = true
-exclude_labels = [
-    "C-tracking-issue",
-    "A-diagnostics",
-]
-
 [autolabel."WG-trait-system-refactor"]
 trigger_files = [
     "compiler/rustc_next_trait_solver",
-- 
cgit 1.4.1-3-g733a5


From 977e7d4e11f126b38742b04691431d0b2a48af68 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 12 Jul 2025 23:15:19 +0800
Subject: Label clippy changes with `T-clippy` team label

---
 triagebot.toml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index a534e1dceb1..125617fce74 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -594,6 +594,10 @@ trigger_files = [
     "compiler/rustc_codegen_llvm",
 ]
 
+[autolabel."T-clippy"]
+trigger_files = [
+    "src/tools/clippy",
+]
 
 # ------------------------------------------------------------------------------
 # Prioritization and team nominations
-- 
cgit 1.4.1-3-g733a5


From e3fc6e53481904a972b1096ecc8c8ea547b822ee Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Wed, 9 Jul 2025 14:35:34 +0200
Subject: merge source and target bindings into single field

---
 compiler/rustc_resolve/src/build_reduced_graph.rs |  18 +-
 compiler/rustc_resolve/src/ident.rs               |   7 +-
 compiler/rustc_resolve/src/imports.rs             | 227 +++++++++++-----------
 compiler/rustc_resolve/src/lib.rs                 |   7 +
 4 files changed, 123 insertions(+), 136 deletions(-)

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index ef122deba4e..6979d89a8e7 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -32,10 +32,9 @@ use crate::def_collector::collect_definitions;
 use crate::imports::{ImportData, ImportKind};
 use crate::macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
 use crate::{
-    BindingKey, Determinacy, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind,
-    ModuleOrUniformRoot, NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult,
-    ResolutionError, Resolver, ResolverArenas, Segment, ToNameBinding, Used, VisResolutionError,
-    errors,
+    BindingKey, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind, ModuleOrUniformRoot,
+    NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult, ResolutionError,
+    Resolver, ResolverArenas, Segment, ToNameBinding, Used, VisResolutionError, errors,
 };
 
 type Res = def::Res<NodeId>;
@@ -620,16 +619,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 let kind = ImportKind::Single {
                     source: source.ident,
                     target: ident,
-                    source_bindings: PerNS {
-                        type_ns: Cell::new(Err(Determinacy::Undetermined)),
-                        value_ns: Cell::new(Err(Determinacy::Undetermined)),
-                        macro_ns: Cell::new(Err(Determinacy::Undetermined)),
-                    },
-                    target_bindings: PerNS {
-                        type_ns: Cell::new(None),
-                        value_ns: Cell::new(None),
-                        macro_ns: Cell::new(None),
-                    },
+                    bindings: Default::default(),
                     type_ns_only,
                     nested,
                     id,
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 558cbef0014..6772632b84e 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -1090,14 +1090,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let Some(module) = single_import.imported_module.get() else {
                 return true;
             };
-            let ImportKind::Single { source, target, target_bindings, .. } = &single_import.kind
-            else {
+            let ImportKind::Single { source, target, bindings, .. } = &single_import.kind else {
                 unreachable!();
             };
             if source != target {
-                if target_bindings.iter().all(|binding| binding.get().is_none()) {
+                if bindings.iter().all(|binding| binding.get().binding().is_none()) {
                     return true;
-                } else if target_bindings[ns].get().is_none() && binding.is_some() {
+                } else if bindings[ns].get().binding().is_none() && binding.is_some() {
                     return true;
                 }
             }
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 2e81b54b136..720614b90c2 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -24,7 +24,6 @@ use rustc_span::{Ident, Span, Symbol, kw, sym};
 use smallvec::SmallVec;
 use tracing::debug;
 
-use crate::Determinacy::{self, *};
 use crate::Namespace::*;
 use crate::diagnostics::{DiagMode, Suggestion, import_candidates};
 use crate::errors::{
@@ -33,13 +32,30 @@ use crate::errors::{
     ConsiderAddingMacroExport, ConsiderMarkingAsPub,
 };
 use crate::{
-    AmbiguityError, AmbiguityKind, BindingKey, Finalize, ImportSuggestion, Module,
+    AmbiguityError, AmbiguityKind, BindingKey, Determinacy, Finalize, ImportSuggestion, Module,
     ModuleOrUniformRoot, NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult,
     PerNS, ResolutionError, Resolver, ScopeSet, Segment, Used, module_to_string, names_to_string,
 };
 
 type Res = def::Res<NodeId>;
 
+/// A [`NameBinding`] in the process of being resolved.
+#[derive(Clone, Copy, Default, PartialEq)]
+pub(crate) enum PendingBinding<'ra> {
+    Ready(Option<NameBinding<'ra>>),
+    #[default]
+    Pending,
+}
+
+impl<'ra> PendingBinding<'ra> {
+    pub(crate) fn binding(self) -> Option<NameBinding<'ra>> {
+        match self {
+            PendingBinding::Ready(binding) => binding,
+            PendingBinding::Pending => None,
+        }
+    }
+}
+
 /// Contains data for specific kinds of imports.
 #[derive(Clone)]
 pub(crate) enum ImportKind<'ra> {
@@ -49,10 +65,8 @@ pub(crate) enum ImportKind<'ra> {
         /// `target` in `use prefix::source as target`.
         /// It will directly use `source` when the format is `use prefix::source`.
         target: Ident,
-        /// Bindings to which `source` refers to.
-        source_bindings: PerNS<Cell<Result<NameBinding<'ra>, Determinacy>>>,
-        /// Bindings introduced by `target`.
-        target_bindings: PerNS<Cell<Option<NameBinding<'ra>>>>,
+        /// Bindings introduced by the import.
+        bindings: PerNS<Cell<PendingBinding<'ra>>>,
         /// `true` for `...::{self [as target]}` imports, `false` otherwise.
         type_ns_only: bool,
         /// Did this import result from a nested import? ie. `use foo::{bar, baz};`
@@ -96,26 +110,14 @@ impl<'ra> std::fmt::Debug for ImportKind<'ra> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         use ImportKind::*;
         match self {
-            Single {
-                source,
-                target,
-                source_bindings,
-                target_bindings,
-                type_ns_only,
-                nested,
-                id,
-            } => f
+            Single { source, target, bindings, type_ns_only, nested, id, .. } => f
                 .debug_struct("Single")
                 .field("source", source)
                 .field("target", target)
                 // Ignore the nested bindings to avoid an infinite loop while printing.
                 .field(
-                    "source_bindings",
-                    &source_bindings.clone().map(|b| b.into_inner().map(|_| format_args!(".."))),
-                )
-                .field(
-                    "target_bindings",
-                    &target_bindings.clone().map(|b| b.into_inner().map(|_| format_args!(".."))),
+                    "bindings",
+                    &bindings.clone().map(|b| b.into_inner().binding().map(|_| format_args!(".."))),
                 )
                 .field("type_ns_only", type_ns_only)
                 .field("nested", nested)
@@ -491,8 +493,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     // Define a dummy resolution containing a `Res::Err` as a placeholder for a failed
     // or indeterminate resolution, also mark such failed imports as used to avoid duplicate diagnostics.
     fn import_dummy_binding(&mut self, import: Import<'ra>, is_indeterminate: bool) {
-        if let ImportKind::Single { target, ref target_bindings, .. } = import.kind {
-            if !(is_indeterminate || target_bindings.iter().all(|binding| binding.get().is_none()))
+        if let ImportKind::Single { target, ref bindings, .. } = import.kind {
+            if !(is_indeterminate
+                || bindings.iter().all(|binding| binding.get().binding().is_none()))
             {
                 return; // Has resolution, do not create the dummy binding
             }
@@ -567,10 +570,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             glob_error |= import.is_glob();
 
-            if let ImportKind::Single { source, ref source_bindings, .. } = import.kind
+            if let ImportKind::Single { source, ref bindings, .. } = import.kind
                 && source.name == kw::SelfLower
                 // Silence `unresolved import` error if E0429 is already emitted
-                && let Err(Determined) = source_bindings.value_ns.get()
+                && let PendingBinding::Ready(None) = bindings.value_ns.get()
             {
                 continue;
             }
@@ -819,15 +822,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         };
 
         import.imported_module.set(Some(module));
-        let (source, target, source_bindings, target_bindings, type_ns_only) = match import.kind {
-            ImportKind::Single {
-                source,
-                target,
-                ref source_bindings,
-                ref target_bindings,
-                type_ns_only,
-                ..
-            } => (source, target, source_bindings, target_bindings, type_ns_only),
+        let (source, target, bindings, type_ns_only) = match import.kind {
+            ImportKind::Single { source, target, ref bindings, type_ns_only, .. } => {
+                (source, target, bindings, type_ns_only)
+            }
             ImportKind::Glob { .. } => {
                 self.resolve_glob_import(import);
                 return 0;
@@ -838,21 +836,18 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut indeterminate_count = 0;
         self.per_ns(|this, ns| {
             if !type_ns_only || ns == TypeNS {
-                if let Err(Undetermined) = source_bindings[ns].get() {
-                    let binding = this.maybe_resolve_ident_in_module(
-                        module,
-                        source,
-                        ns,
-                        &import.parent_scope,
-                        Some(import),
-                    );
-                    source_bindings[ns].set(binding);
-                } else {
+                if bindings[ns].get() != PendingBinding::Pending {
                     return;
                 };
-
+                let binding_result = this.maybe_resolve_ident_in_module(
+                    module,
+                    source,
+                    ns,
+                    &import.parent_scope,
+                    Some(import),
+                );
                 let parent = import.parent_scope.module;
-                match source_bindings[ns].get() {
+                let binding = match binding_result {
                     Ok(binding) => {
                         if binding.is_assoc_item()
                             && !this.tcx.features().import_trait_associated_functions()
@@ -865,12 +860,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             )
                             .emit();
                         }
-
+                        // We need the `target`, `source` can be extracted.
                         let imported_binding = this.import(binding, import);
-                        target_bindings[ns].set(Some(imported_binding));
                         this.define(parent, target, ns, imported_binding);
+                        PendingBinding::Ready(Some(imported_binding))
                     }
-                    Err(Determined) => {
+                    Err(Determinacy::Determined) => {
                         // Don't update the resolution for underscores, because it was never added.
                         if target.name != kw::Underscore {
                             let key = BindingKey::new(target, ns);
@@ -878,9 +873,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 resolution.single_imports.swap_remove(&import);
                             });
                         }
+                        PendingBinding::Ready(None)
                     }
-                    Err(Undetermined) => indeterminate_count += 1,
-                }
+                    Err(Determinacy::Undetermined) => {
+                        indeterminate_count += 1;
+                        PendingBinding::Pending
+                    }
+                };
+                bindings[ns].set(binding);
             }
         });
 
@@ -893,7 +893,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     /// consolidate multiple unresolved import errors into a single diagnostic.
     fn finalize_import(&mut self, import: Import<'ra>) -> Option<UnresolvedImportError> {
         let ignore_binding = match &import.kind {
-            ImportKind::Single { target_bindings, .. } => target_bindings[TypeNS].get(),
+            ImportKind::Single { bindings, .. } => bindings[TypeNS].get().binding(),
             _ => None,
         };
         let ambiguity_errors_len =
@@ -1011,60 +1011,53 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             PathResult::Indeterminate => unreachable!(),
         };
 
-        let (ident, target, source_bindings, target_bindings, type_ns_only, import_id) =
-            match import.kind {
-                ImportKind::Single {
-                    source,
-                    target,
-                    ref source_bindings,
-                    ref target_bindings,
-                    type_ns_only,
-                    id,
-                    ..
-                } => (source, target, source_bindings, target_bindings, type_ns_only, id),
-                ImportKind::Glob { is_prelude, ref max_vis, id } => {
-                    if import.module_path.len() <= 1 {
-                        // HACK(eddyb) `lint_if_path_starts_with_module` needs at least
-                        // 2 segments, so the `resolve_path` above won't trigger it.
-                        let mut full_path = import.module_path.clone();
-                        full_path.push(Segment::from_ident(Ident::dummy()));
-                        self.lint_if_path_starts_with_module(Some(finalize), &full_path, None);
-                    }
+        let (ident, target, bindings, type_ns_only, import_id) = match import.kind {
+            ImportKind::Single { source, target, ref bindings, type_ns_only, id, .. } => {
+                (source, target, bindings, type_ns_only, id)
+            }
+            ImportKind::Glob { is_prelude, ref max_vis, id } => {
+                if import.module_path.len() <= 1 {
+                    // HACK(eddyb) `lint_if_path_starts_with_module` needs at least
+                    // 2 segments, so the `resolve_path` above won't trigger it.
+                    let mut full_path = import.module_path.clone();
+                    full_path.push(Segment::from_ident(Ident::dummy()));
+                    self.lint_if_path_starts_with_module(Some(finalize), &full_path, None);
+                }
 
-                    if let ModuleOrUniformRoot::Module(module) = module
-                        && module == import.parent_scope.module
-                    {
-                        // Importing a module into itself is not allowed.
-                        return Some(UnresolvedImportError {
+                if let ModuleOrUniformRoot::Module(module) = module
+                    && module == import.parent_scope.module
+                {
+                    // Importing a module into itself is not allowed.
+                    return Some(UnresolvedImportError {
+                        span: import.span,
+                        label: Some(String::from("cannot glob-import a module into itself")),
+                        note: None,
+                        suggestion: None,
+                        candidates: None,
+                        segment: None,
+                        module: None,
+                    });
+                }
+                if !is_prelude
+                    && let Some(max_vis) = max_vis.get()
+                    && !max_vis.is_at_least(import.vis, self.tcx)
+                {
+                    let def_id = self.local_def_id(id);
+                    self.lint_buffer.buffer_lint(
+                        UNUSED_IMPORTS,
+                        id,
+                        import.span,
+                        BuiltinLintDiag::RedundantImportVisibility {
+                            max_vis: max_vis.to_string(def_id, self.tcx),
+                            import_vis: import.vis.to_string(def_id, self.tcx),
                             span: import.span,
-                            label: Some(String::from("cannot glob-import a module into itself")),
-                            note: None,
-                            suggestion: None,
-                            candidates: None,
-                            segment: None,
-                            module: None,
-                        });
-                    }
-                    if !is_prelude
-                        && let Some(max_vis) = max_vis.get()
-                        && !max_vis.is_at_least(import.vis, self.tcx)
-                    {
-                        let def_id = self.local_def_id(id);
-                        self.lint_buffer.buffer_lint(
-                            UNUSED_IMPORTS,
-                            id,
-                            import.span,
-                            BuiltinLintDiag::RedundantImportVisibility {
-                                max_vis: max_vis.to_string(def_id, self.tcx),
-                                import_vis: import.vis.to_string(def_id, self.tcx),
-                                span: import.span,
-                            },
-                        );
-                    }
-                    return None;
+                        },
+                    );
                 }
-                _ => unreachable!(),
-            };
+                return None;
+            }
+            _ => unreachable!(),
+        };
 
         if self.privacy_errors.len() != privacy_errors_len {
             // Get the Res for the last element, so that we can point to alternative ways of
@@ -1095,17 +1088,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     ns,
                     &import.parent_scope,
                     Some(Finalize { report_private: false, ..finalize }),
-                    target_bindings[ns].get(),
+                    bindings[ns].get().binding(),
                     Some(import),
                 );
 
                 match binding {
                     Ok(binding) => {
                         // Consistency checks, analogous to `finalize_macro_resolutions`.
-                        let initial_res = source_bindings[ns].get().map(|initial_binding| {
+                        let initial_res = bindings[ns].get().binding().map(|binding| {
+                            let initial_binding = binding.import_source();
                             all_ns_err = false;
-                            if let Some(target_binding) = target_bindings[ns].get()
-                                && target.name == kw::Underscore
+                            if target.name == kw::Underscore
                                 && initial_binding.is_extern_crate()
                                 && !initial_binding.is_import()
                             {
@@ -1114,7 +1107,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 } else {
                                     Used::Other
                                 };
-                                this.record_use(ident, target_binding, used);
+                                this.record_use(ident, binding, used);
                             }
                             initial_binding.res()
                         });
@@ -1126,7 +1119,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 .span_delayed_bug(import.span, "some error happened for an import");
                             return;
                         }
-                        if let Ok(initial_res) = initial_res {
+                        if let Some(initial_res) = initial_res {
                             if res != initial_res {
                                 span_bug!(import.span, "inconsistent resolution for an import");
                             }
@@ -1269,7 +1262,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut any_successful_reexport = false;
         let mut crate_private_reexport = false;
         self.per_ns(|this, ns| {
-            let Ok(binding) = source_bindings[ns].get() else {
+            let Some(binding) = bindings[ns].get().binding().map(|b| b.import_source()) else {
                 return;
             };
 
@@ -1340,7 +1333,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let mut full_path = import.module_path.clone();
             full_path.push(Segment::from_ident(ident));
             self.per_ns(|this, ns| {
-                if let Ok(binding) = source_bindings[ns].get() {
+                if let Some(binding) = bindings[ns].get().binding().map(|b| b.import_source()) {
                     this.lint_if_path_starts_with_module(Some(finalize), &full_path, Some(binding));
                 }
             });
@@ -1350,7 +1343,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // this may resolve to either a value or a type, but for documentation
         // purposes it's good enough to just favor one over the other.
         self.per_ns(|this, ns| {
-            if let Ok(binding) = source_bindings[ns].get() {
+            if let Some(binding) = bindings[ns].get().binding().map(|b| b.import_source()) {
                 this.import_res_map.entry(import_id).or_default()[ns] = Some(binding.res());
             }
         });
@@ -1361,10 +1354,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
     pub(crate) fn check_for_redundant_imports(&mut self, import: Import<'ra>) -> bool {
         // This function is only called for single imports.
-        let ImportKind::Single {
-            source, target, ref source_bindings, ref target_bindings, id, ..
-        } = import.kind
-        else {
+        let ImportKind::Single { source, target, ref bindings, id, .. } = import.kind else {
             unreachable!()
         };
 
@@ -1391,7 +1381,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut is_redundant = true;
         let mut redundant_span = PerNS { value_ns: None, type_ns: None, macro_ns: None };
         self.per_ns(|this, ns| {
-            if is_redundant && let Ok(binding) = source_bindings[ns].get() {
+            let binding = bindings[ns].get().binding().map(|b| b.import_source());
+            if is_redundant && let Some(binding) = binding {
                 if binding.res() == Res::Err {
                     return;
                 }
@@ -1402,7 +1393,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     &import.parent_scope,
                     None,
                     false,
-                    target_bindings[ns].get(),
+                    bindings[ns].get().binding(),
                     None,
                 ) {
                     Ok(other_binding) => {
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 6e4c5ef1909..0c642592fa0 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -891,6 +891,13 @@ impl<'ra> NameBindingData<'ra> {
         }
     }
 
+    fn import_source(&self) -> NameBinding<'ra> {
+        match self.kind {
+            NameBindingKind::Import { binding, .. } => binding,
+            _ => unreachable!(),
+        }
+    }
+
     fn is_ambiguity_recursive(&self) -> bool {
         self.ambiguity.is_some()
             || match self.kind {
-- 
cgit 1.4.1-3-g733a5


From 01f434675b2768ba4913e54ccbaf580bf25041ed Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 12 Jul 2025 23:47:59 +0800
Subject: Fix assoc type where clause position

---
 .../src/completions/item_list/trait_impl.rs        | 53 ++++++++++++++++++++--
 .../crates/ide-completion/src/tests/item_list.rs   | 27 +++++++++++
 2 files changed, 75 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/completions/item_list/trait_impl.rs b/src/tools/rust-analyzer/crates/ide-completion/src/completions/item_list/trait_impl.rs
index 092219a058a..975c2f02259 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/completions/item_list/trait_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/completions/item_list/trait_impl.rs
@@ -37,6 +37,7 @@ use ide_db::{
     SymbolKind, documentation::HasDocs, path_transform::PathTransform,
     syntax_helpers::prettify_macro_expansion, traits::get_missing_assoc_items,
 };
+use syntax::ast::HasGenericParams;
 use syntax::{
     AstNode, SmolStr, SyntaxElement, SyntaxKind, T, TextRange, ToSmolStr,
     ast::{self, HasGenericArgs, HasTypeBounds, edit_in_place::AttrsOwnerEdit, make},
@@ -388,6 +389,12 @@ fn add_type_alias_impl(
             {
                 end
             } else if let Some(end) = transformed_ty.eq_token().map(|tok| tok.text_range().start())
+            {
+                end
+            } else if let Some(end) = transformed_ty
+                .where_clause()
+                .and_then(|wc| wc.where_token())
+                .map(|tok| tok.text_range().start())
             {
                 end
             } else if let Some(end) =
@@ -400,17 +407,29 @@ fn add_type_alias_impl(
 
             let len = end - start;
             let mut decl = transformed_ty.syntax().text().slice(..len).to_string();
-            if !decl.ends_with(' ') {
-                decl.push(' ');
-            }
-            decl.push_str("= ");
+            decl.truncate(decl.trim_end().len());
+            decl.push_str(" = ");
+
+            let wc = transformed_ty
+                .where_clause()
+                .map(|wc| {
+                    let ws = wc
+                        .where_token()
+                        .and_then(|it| it.prev_token())
+                        .filter(|token| token.kind() == SyntaxKind::WHITESPACE)
+                        .map(|token| token.to_string())
+                        .unwrap_or_else(|| " ".into());
+                    format!("{ws}{wc}")
+                })
+                .unwrap_or_default();
 
             match ctx.config.snippet_cap {
                 Some(cap) => {
-                    let snippet = format!("{decl}$0;");
+                    let snippet = format!("{decl}$0{wc};");
                     item.snippet_edit(cap, TextEdit::replace(replacement_range, snippet));
                 }
                 None => {
+                    decl.push_str(&wc);
                     item.text_edit(TextEdit::replace(replacement_range, decl));
                 }
             };
@@ -1437,6 +1456,30 @@ trait Tr<'b> {
 impl<'b> Tr<'b> for () {
     type Ty<'a: 'b, T: Copy, const C: usize> = $0;
 }
+"#,
+        );
+    }
+    #[test]
+    fn includes_where_clause() {
+        check_edit(
+            "type Ty",
+            r#"
+trait Tr {
+    type Ty where Self: Copy;
+}
+
+impl Tr for () {
+    $0
+}
+"#,
+            r#"
+trait Tr {
+    type Ty where Self: Copy;
+}
+
+impl Tr for () {
+    type Ty = $0 where Self: Copy;
+}
 "#,
         );
     }
diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/tests/item_list.rs b/src/tools/rust-analyzer/crates/ide-completion/src/tests/item_list.rs
index 179d6693602..ac32649d4ff 100644
--- a/src/tools/rust-analyzer/crates/ide-completion/src/tests/item_list.rs
+++ b/src/tools/rust-analyzer/crates/ide-completion/src/tests/item_list.rs
@@ -458,6 +458,33 @@ type O = $0;
         r"
 struct A;
 trait B {
+type O<'a>
+where
+Self: 'a;
+}
+impl B for A {
+$0
+}
+",
+        r#"
+struct A;
+trait B {
+type O<'a>
+where
+Self: 'a;
+}
+impl B for A {
+type O<'a> = $0
+where
+Self: 'a;
+}
+"#,
+    );
+    check_edit(
+        "type O",
+        r"
+struct A;
+trait B {
 type O: ?Sized = u32;
 }
 impl B for A {
-- 
cgit 1.4.1-3-g733a5


From ef82007ed7b7833e3efdec0d80712849048c5c1f Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Fri, 11 Jul 2025 12:01:11 +0200
Subject: Port `#[automatically_derived]` to the new attribute parsing
 infrastructure

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>
---
 compiler/rustc_ast/src/attr/mod.rs                         |  5 +++++
 compiler/rustc_attr_data_structures/src/attributes.rs      |  3 +++
 .../rustc_attr_data_structures/src/encode_cross_crate.rs   |  1 +
 compiler/rustc_attr_parsing/src/attributes/lint_helpers.rs |  7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                 |  5 ++++-
 compiler/rustc_hir/src/hir.rs                              |  6 ++++++
 compiler/rustc_lint/src/default_could_be_derived.rs        |  3 ++-
 compiler/rustc_lint/src/levels.rs                          |  2 +-
 compiler/rustc_middle/src/ty/mod.rs                        |  4 ++--
 compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs  |  6 ++++--
 compiler/rustc_parse/src/validate_attr.rs                  |  1 +
 compiler/rustc_passes/src/check_attr.rs                    | 14 ++++++++++----
 compiler/rustc_passes/src/liveness.rs                      |  4 ++--
 13 files changed, 48 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_ast/src/attr/mod.rs b/compiler/rustc_ast/src/attr/mod.rs
index 44865c493b3..4348a4bb120 100644
--- a/compiler/rustc_ast/src/attr/mod.rs
+++ b/compiler/rustc_ast/src/attr/mod.rs
@@ -217,6 +217,10 @@ impl AttributeExt for Attribute {
             _ => None,
         }
     }
+
+    fn is_automatically_derived_attr(&self) -> bool {
+        self.has_name(sym::automatically_derived)
+    }
 }
 
 impl Attribute {
@@ -810,6 +814,7 @@ pub trait AttributeExt: Debug {
             .iter()
             .any(|kind| self.has_name(*kind))
     }
+    fn is_automatically_derived_attr(&self) -> bool;
 
     /// Returns the documentation and its kind if this is a doc comment or a sugared doc comment.
     /// * `///doc` returns `Some(("doc", CommentKind::Line))`.
diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index f61efcf2388..41a9e8feaaf 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -207,6 +207,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_as_ptr]` (used by the `dangling_pointers_from_temporaries` lint).
     AsPtr(Span),
 
+    /// Represents `#[automatically_derived]`
+    AutomaticallyDerived(Span),
+
     /// Represents `#[rustc_default_body_unstable]`.
     BodyStability {
         stability: DefaultBodyStability,
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index ad587523e03..b92f0ade3d3 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -18,6 +18,7 @@ impl AttributeKind {
             AllowIncoherentImpl(..) => No,
             AllowInternalUnstable(..) => Yes,
             AsPtr(..) => Yes,
+            AutomaticallyDerived(..) => Yes,
             BodyStability { .. } => No,
             CoherenceIsCore => No,
             Coinductive(..) => No,
diff --git a/compiler/rustc_attr_parsing/src/attributes/lint_helpers.rs b/compiler/rustc_attr_parsing/src/attributes/lint_helpers.rs
index 8ad98c8d1d4..0eceff53e8b 100644
--- a/compiler/rustc_attr_parsing/src/attributes/lint_helpers.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/lint_helpers.rs
@@ -24,3 +24,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for PassByValueParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::PassByValue;
 }
+
+pub(crate) struct AutomaticallyDerivedParser;
+impl<S: Stage> NoArgsAttributeParser<S> for AutomaticallyDerivedParser {
+    const PATH: &[Symbol] = &[sym::automatically_derived];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::AutomaticallyDerived;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index cc10bb3098a..0b34fe0a592 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -27,7 +27,9 @@ use crate::attributes::link_attrs::{
     ExportStableParser, FfiConstParser, FfiPureParser, LinkNameParser, LinkSectionParser,
     StdInternalSymbolParser,
 };
-use crate::attributes::lint_helpers::{AsPtrParser, PassByValueParser, PubTransparentParser};
+use crate::attributes::lint_helpers::{
+    AsPtrParser, AutomaticallyDerivedParser, PassByValueParser, PubTransparentParser,
+};
 use crate::attributes::loop_match::{ConstContinueParser, LoopMatchParser};
 use crate::attributes::must_use::MustUseParser;
 use crate::attributes::no_implicit_prelude::NoImplicitPreludeParser;
@@ -153,6 +155,7 @@ attribute_parsers!(
         Single<TransparencyParser>,
         Single<WithoutArgs<AllowIncoherentImplParser>>,
         Single<WithoutArgs<AsPtrParser>>,
+        Single<WithoutArgs<AutomaticallyDerivedParser>>,
         Single<WithoutArgs<CoherenceIsCoreParser>>,
         Single<WithoutArgs<CoinductiveParser>>,
         Single<WithoutArgs<ColdParser>>,
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 0f6f81d7964..f655a7e11f0 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1304,6 +1304,7 @@ impl AttributeExt for Attribute {
             Attribute::Parsed(AttributeKind::DocComment { span, .. }) => *span,
             Attribute::Parsed(AttributeKind::MayDangle(span)) => *span,
             Attribute::Parsed(AttributeKind::Ignore { span, .. }) => *span,
+            Attribute::Parsed(AttributeKind::AutomaticallyDerived(span)) => *span,
             a => panic!("can't get the span of an arbitrary parsed attribute: {a:?}"),
         }
     }
@@ -1334,6 +1335,11 @@ impl AttributeExt for Attribute {
             _ => None,
         }
     }
+
+    fn is_automatically_derived_attr(&self) -> bool {
+        matches!(self, Attribute::Parsed(AttributeKind::AutomaticallyDerived(..)))
+    }
+
     #[inline]
     fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)> {
         match &self {
diff --git a/compiler/rustc_lint/src/default_could_be_derived.rs b/compiler/rustc_lint/src/default_could_be_derived.rs
index 0bc772d081f..b5fc083a095 100644
--- a/compiler/rustc_lint/src/default_could_be_derived.rs
+++ b/compiler/rustc_lint/src/default_could_be_derived.rs
@@ -1,3 +1,4 @@
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Applicability, Diag};
 use rustc_hir as hir;
@@ -62,7 +63,7 @@ impl<'tcx> LateLintPass<'tcx> for DefaultCouldBeDerived {
         let hir::ImplItemKind::Fn(_sig, body_id) = impl_item.kind else { return };
         let assoc = cx.tcx.associated_item(impl_item.owner_id);
         let parent = assoc.container_id(cx.tcx);
-        if cx.tcx.has_attr(parent, sym::automatically_derived) {
+        if find_attr!(cx.tcx.get_all_attrs(parent), AttributeKind::AutomaticallyDerived(..)) {
             // We don't care about what `#[derive(Default)]` produces in this lint.
             return;
         }
diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs
index c72f8571153..16eeb89207b 100644
--- a/compiler/rustc_lint/src/levels.rs
+++ b/compiler/rustc_lint/src/levels.rs
@@ -644,7 +644,7 @@ impl<'s, P: LintLevelsProvider> LintLevelsBuilder<'s, P> {
     ) {
         let sess = self.sess;
         for (attr_index, attr) in attrs.iter().enumerate() {
-            if attr.has_name(sym::automatically_derived) {
+            if attr.is_automatically_derived_attr() {
                 self.insert(
                     LintId::of(SINGLE_USE_LIFETIMES),
                     LevelAndSource {
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 0177a95498b..5dbdff76bee 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -28,7 +28,7 @@ use rustc_abi::{Align, FieldIdx, Integer, IntegerType, ReprFlags, ReprOptions, V
 use rustc_ast::expand::StrippedCfgItem;
 use rustc_ast::node_id::NodeMap;
 pub use rustc_ast_ir::{Movability, Mutability, try_visit};
-use rustc_attr_data_structures::AttributeKind;
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_data_structures::intern::Interned;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
@@ -2031,7 +2031,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
     /// Check if the given `DefId` is `#\[automatically_derived\]`.
     pub fn is_automatically_derived(self, def_id: DefId) -> bool {
-        self.has_attr(def_id, sym::automatically_derived)
+        find_attr!(self.get_all_attrs(def_id), AttributeKind::AutomaticallyDerived(..))
     }
 
     /// Looks up the span of `impl_did` if the impl is local; otherwise returns `Err`
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 6d617d43c2a..91fcbb9390f 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
@@ -2,6 +2,7 @@ use core::ops::ControlFlow;
 
 use rustc_abi::{FieldIdx, VariantIdx};
 use rustc_apfloat::Float;
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Diag;
 use rustc_hir as hir;
@@ -15,7 +16,7 @@ use rustc_middle::ty::{
 };
 use rustc_middle::{mir, span_bug};
 use rustc_span::def_id::DefId;
-use rustc_span::{DUMMY_SP, Span, sym};
+use rustc_span::{DUMMY_SP, Span};
 use rustc_trait_selection::traits::ObligationCause;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
 use tracing::{debug, instrument, trace};
@@ -495,7 +496,8 @@ fn type_has_partial_eq_impl<'tcx>(
     let mut structural_peq = false;
     let mut impl_def_id = None;
     for def_id in tcx.non_blanket_impls_for_ty(partial_eq_trait_id, ty) {
-        automatically_derived = tcx.has_attr(def_id, sym::automatically_derived);
+        automatically_derived =
+            find_attr!(tcx.get_all_attrs(def_id), AttributeKind::AutomaticallyDerived(..));
         impl_def_id = Some(def_id);
     }
     for _ in tcx.non_blanket_impls_for_ty(structural_partial_eq_trait_id, ty) {
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index bb5c1e0e653..3e80af82bef 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -316,6 +316,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_layout_scalar_valid_range_start
                 | sym::rustc_layout_scalar_valid_range_end
                 | sym::no_implicit_prelude
+                | sym::automatically_derived
         ) {
             return;
         }
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2c95fead9e8..0924d877263 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -152,6 +152,14 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 Attribute::Parsed(AttributeKind::Confusables { first_span, .. }) => {
                     self.check_confusables(*first_span, target);
                 }
+                Attribute::Parsed(AttributeKind::AutomaticallyDerived(attr_span)) => self
+                    .check_generic_attr(
+                        hir_id,
+                        sym::automatically_derived,
+                        *attr_span,
+                        target,
+                        Target::Impl,
+                    ),
                 Attribute::Parsed(
                     AttributeKind::Stability { span, .. }
                     | AttributeKind::ConstStability { span, .. },
@@ -335,9 +343,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::should_panic, ..] => {
                             self.check_generic_attr_unparsed(hir_id, attr, target, Target::Fn)
                         }
-                        [sym::automatically_derived, ..] => {
-                            self.check_generic_attr_unparsed(hir_id, attr, target, Target::Impl)
-                        }
                         [sym::proc_macro, ..] => {
                             self.check_proc_macro(hir_id, target, ProcMacroKind::FunctionLike)
                         }
@@ -2814,7 +2819,6 @@ fn check_invalid_crate_level_attr(tcx: TyCtxt<'_>, attrs: &[Attribute]) {
     // resolution for the attribute macro error.
     const ATTRS_TO_CHECK: &[Symbol] = &[
         sym::macro_export,
-        sym::automatically_derived,
         sym::rustc_main,
         sym::derive,
         sym::test,
@@ -2837,6 +2841,8 @@ fn check_invalid_crate_level_attr(tcx: TyCtxt<'_>, attrs: &[Attribute]) {
             (*first_attr_span, sym::repr)
         } else if let Attribute::Parsed(AttributeKind::Path(.., span)) = attr {
             (*span, sym::path)
+        } else if let Attribute::Parsed(AttributeKind::AutomaticallyDerived(span)) = attr {
+            (*span, sym::automatically_derived)
         } else {
             continue;
         };
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index 3088e189c20..7350c6a5a82 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -97,7 +97,7 @@ use rustc_middle::query::Providers;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{self, RootVariableMinCaptureList, Ty, TyCtxt};
 use rustc_session::lint;
-use rustc_span::{BytePos, Span, Symbol, sym};
+use rustc_span::{BytePos, Span, Symbol};
 use tracing::{debug, instrument};
 
 use self::LiveNodeKind::*;
@@ -140,7 +140,7 @@ fn check_liveness(tcx: TyCtxt<'_>, def_id: LocalDefId) {
     // Don't run unused pass for #[derive()]
     let parent = tcx.local_parent(def_id);
     if let DefKind::Impl { .. } = tcx.def_kind(parent)
-        && tcx.has_attr(parent, sym::automatically_derived)
+        && find_attr!(tcx.get_all_attrs(parent), AttributeKind::AutomaticallyDerived(..))
     {
         return;
     }
-- 
cgit 1.4.1-3-g733a5


From a1cfca3d074fda4ca475bbbf1fe0100b2464cada Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Fri, 11 Jul 2025 12:01:26 +0200
Subject: Fix clippy & rustdoc-json

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>
---
 src/librustdoc/clean/types.rs                                         | 3 +++
 src/tools/clippy/clippy_lints/src/format_args.rs                      | 3 ++-
 .../clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs  | 2 +-
 src/tools/clippy/clippy_utils/src/lib.rs                              | 4 ++--
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index a05aab22f1e..3ecd41db2dd 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -796,6 +796,9 @@ impl Item {
                             }
                             Some(format!("#[target_feature({output})]"))
                         }
+                        hir::Attribute::Parsed(AttributeKind::AutomaticallyDerived(..)) => {
+                            Some("#[automatically_derived]".to_string())
+                        }
                         _ => Some({
                             let mut s = rustc_hir_pretty::attribute_to_string(&tcx, attr);
                             assert_eq!(s.pop(), Some('\n'));
diff --git a/src/tools/clippy/clippy_lints/src/format_args.rs b/src/tools/clippy/clippy_lints/src/format_args.rs
index 0c39aae9ca9..16c58ecb455 100644
--- a/src/tools/clippy/clippy_lints/src/format_args.rs
+++ b/src/tools/clippy/clippy_lints/src/format_args.rs
@@ -30,6 +30,7 @@ use rustc_span::edition::Edition::Edition2021;
 use rustc_span::{Span, Symbol, sym};
 use rustc_trait_selection::infer::TyCtxtInferExt;
 use rustc_trait_selection::traits::{Obligation, ObligationCause, Selection, SelectionContext};
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -656,7 +657,7 @@ impl<'tcx> FormatArgsExpr<'_, 'tcx> {
                     };
                     let selection = SelectionContext::new(&infcx).select(&obligation);
                     let derived = if let Ok(Some(Selection::UserDefined(data))) = selection {
-                        tcx.has_attr(data.impl_def_id, sym::automatically_derived)
+                        find_attr!(tcx.get_all_attrs(data.impl_def_id), AttributeKind::AutomaticallyDerived(..))
                     } else {
                         false
                     };
diff --git a/src/tools/clippy/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs b/src/tools/clippy/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs
index a1dacd359a0..88b099c477f 100644
--- a/src/tools/clippy/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs
+++ b/src/tools/clippy/clippy_lints_internal/src/derive_deserialize_allowing_unknown.rs
@@ -88,7 +88,7 @@ impl<'tcx> LateLintPass<'tcx> for DeriveDeserializeAllowingUnknown {
         }
 
         // Is it derived?
-        if !cx.tcx.has_attr(item.owner_id, sym::automatically_derived) {
+        if !find_attr!(cx.tcx.get_all_attrs(item.owner_id), AttributeKind::AutomaticallyDerived(..)) {
             return;
         }
 
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index 98b4c183b12..36b91b9c43c 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -1784,9 +1784,9 @@ pub fn in_automatically_derived(tcx: TyCtxt<'_>, id: HirId) -> bool {
     tcx.hir_parent_owner_iter(id)
         .filter(|(_, node)| matches!(node, OwnerNode::Item(item) if matches!(item.kind, ItemKind::Impl(_))))
         .any(|(id, _)| {
-            has_attr(
+            find_attr!(
                 tcx.hir_attrs(tcx.local_def_id_to_hir_id(id.def_id)),
-                sym::automatically_derived,
+                AttributeKind::AutomaticallyDerived(..)
             )
         })
 }
-- 
cgit 1.4.1-3-g733a5


From 68066b90b84b52fa4907c12e708b8418317e2a5d Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Fri, 11 Jul 2025 12:01:36 +0200
Subject: Update uitest stderrs

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>
---
 tests/ui/attributes/malformed-attrs.stderr         | 15 ++++++-----
 ...ssue-43106-gating-of-builtin-attrs-error.stderr | 30 +++++++++++-----------
 tests/ui/lint/unused/unused-attr-duplicate.stderr  | 24 ++++++++---------
 3 files changed, 36 insertions(+), 33 deletions(-)

diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index be529df3a49..6da08b3b56f 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -164,12 +164,6 @@ error: malformed `debugger_visualizer` attribute input
 LL | #[debugger_visualizer]
    | ^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[debugger_visualizer(natvis_file = "...", gdb_script_file = "...")]`
 
-error: malformed `automatically_derived` attribute input
-  --> $DIR/malformed-attrs.rs:191:1
-   |
-LL | #[automatically_derived = 18]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[automatically_derived]`
-
 error: malformed `thread_local` attribute input
   --> $DIR/malformed-attrs.rs:203:1
    |
@@ -546,6 +540,15 @@ LL |     #[unsafe(ffi_const = 1)]
    |     |                  didn't expect any arguments here
    |     help: must be of the form: `#[ffi_const]`
 
+error[E0565]: malformed `automatically_derived` attribute input
+  --> $DIR/malformed-attrs.rs:191:1
+   |
+LL | #[automatically_derived = 18]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^----^
+   | |                       |
+   | |                       didn't expect any arguments here
+   | help: must be of the form: `#[automatically_derived]`
+
 error[E0565]: malformed `non_exhaustive` attribute input
   --> $DIR/malformed-attrs.rs:197:1
    |
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 49c666f498f..4cba54bf67c 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
@@ -121,21 +121,6 @@ LL - #![rustc_main]
 LL + #[rustc_main]
    |
 
-error: `automatically_derived` attribute cannot be used at crate level
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:23:1
-   |
-LL | #![automatically_derived]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^
-...
-LL | mod inline {
-   |     ------ the inner attribute doesn't annotate this module
-   |
-help: perhaps you meant to use an outer attribute
-   |
-LL - #![automatically_derived]
-LL + #[automatically_derived]
-   |
-
 error: `repr` attribute cannot be used at crate level
   --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:19:1
    |
@@ -166,6 +151,21 @@ LL - #![path = "3800"]
 LL + #[path = "3800"]
    |
 
+error: `automatically_derived` attribute cannot be used at crate level
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:23:1
+   |
+LL | #![automatically_derived]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+LL | mod inline {
+   |     ------ the inner attribute doesn't annotate this module
+   |
+help: perhaps you meant to use an outer attribute
+   |
+LL - #![automatically_derived]
+LL + #[automatically_derived]
+   |
+
 error[E0518]: attribute should be applied to function or closure
   --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:42:17
    |
diff --git a/tests/ui/lint/unused/unused-attr-duplicate.stderr b/tests/ui/lint/unused/unused-attr-duplicate.stderr
index 2310c12c80b..6db6af823f4 100644
--- a/tests/ui/lint/unused/unused-attr-duplicate.stderr
+++ b/tests/ui/lint/unused/unused-attr-duplicate.stderr
@@ -40,18 +40,6 @@ LL | #[should_panic]
    | ^^^^^^^^^^^^^^^
    = 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:70:1
-   |
-LL | #[automatically_derived]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:69:1
-   |
-LL | #[automatically_derived]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: unused attribute
   --> $DIR/unused-attr-duplicate.rs:14:1
    |
@@ -190,6 +178,18 @@ note: attribute also specified here
 LL | #[non_exhaustive]
    | ^^^^^^^^^^^^^^^^^
 
+error: unused attribute
+  --> $DIR/unused-attr-duplicate.rs:70:1
+   |
+LL | #[automatically_derived]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/unused-attr-duplicate.rs:69:1
+   |
+LL | #[automatically_derived]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: unused attribute
   --> $DIR/unused-attr-duplicate.rs:74:1
    |
-- 
cgit 1.4.1-3-g733a5


From da6c099dcc2c60b636db102b4085f517c3ed4ecc Mon Sep 17 00:00:00 2001
From: Hayashi Mikihiro <34ttrweoewiwe28@gmail.com>
Date: Sun, 13 Jul 2025 02:03:56 +0900
Subject: remove `remove_default`

---
 .../src/handlers/generate_default_from_new.rs      | 15 +++++----
 .../rust-analyzer/crates/ide-assists/src/utils.rs  | 30 ++++++++----------
 .../crates/syntax/src/ast/edit_in_place.rs         | 36 ----------------------
 3 files changed, 19 insertions(+), 62 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 79a78ab3698..47233fb399d 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 ide_db::famous_defs::FamousDefs;
 use stdx::format_to;
 use syntax::{
     AstNode,
-    ast::{self, HasGenericParams, HasName, Impl, make},
+    ast::{self, HasGenericParams, HasName, HasTypeBounds, Impl, make},
 };
 
 use crate::{
@@ -88,20 +88,19 @@ fn generate_trait_impl_text_from_impl(
     let generic_params = impl_.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().map(|param| {
+        let ty_or_const_params = generic_params.type_or_const_params().filter_map(|param| {
             // remove defaults since they can't be specified in impls
-            match param {
+            let param = match param {
                 ast::TypeOrConstParam::Type(param) => {
-                    let param = param.clone_for_update();
-                    param.remove_default();
+                    let param = make::type_param(param.name()?, param.type_bound_list());
                     ast::GenericParam::TypeParam(param)
                 }
                 ast::TypeOrConstParam::Const(param) => {
-                    let param = param.clone_for_update();
-                    param.remove_default();
+                    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))
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 87a4c2ef758..b1606fb7ba7 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -594,12 +594,10 @@ fn generate_impl_text_inner(
     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().map(|param| {
-            match param {
+        let ty_or_const_params = generic_params.type_or_const_params().filter_map(|param| {
+            let param = match param {
                 ast::TypeOrConstParam::Type(param) => {
-                    let param = param.clone_for_update();
                     // remove defaults since they can't be specified in impls
-                    param.remove_default();
                     let mut bounds =
                         param.type_bound_list().map_or_else(Vec::new, |it| it.bounds().collect());
                     if let Some(trait_) = trait_text {
@@ -610,17 +608,16 @@ fn generate_impl_text_inner(
                         }
                     };
                     // `{ty_param}: {bounds}`
-                    let param =
-                        make::type_param(param.name().unwrap(), make::type_bound_list(bounds));
+                    let param = make::type_param(param.name()?, make::type_bound_list(bounds));
                     ast::GenericParam::TypeParam(param)
                 }
                 ast::TypeOrConstParam::Const(param) => {
-                    let param = param.clone_for_update();
                     // remove defaults since they can't be specified in impls
-                    param.remove_default();
+                    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))
@@ -695,12 +692,10 @@ fn generate_impl_inner(
     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().map(|param| {
-            match param {
+        let ty_or_const_params = generic_params.type_or_const_params().filter_map(|param| {
+            let param = match param {
                 ast::TypeOrConstParam::Type(param) => {
-                    let param = param.clone_for_update();
                     // remove defaults since they can't be specified in impls
-                    param.remove_default();
                     let mut bounds =
                         param.type_bound_list().map_or_else(Vec::new, |it| it.bounds().collect());
                     if let Some(trait_) = &trait_ {
@@ -711,17 +706,16 @@ fn generate_impl_inner(
                         }
                     };
                     // `{ty_param}: {bounds}`
-                    let param =
-                        make::type_param(param.name().unwrap(), make::type_bound_list(bounds));
+                    let param = make::type_param(param.name()?, make::type_bound_list(bounds));
                     ast::GenericParam::TypeParam(param)
                 }
                 ast::TypeOrConstParam::Const(param) => {
-                    let param = param.clone_for_update();
                     // remove defaults since they can't be specified in impls
-                    param.remove_default();
+                    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))
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 e60243f2c91..e902516471d 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
@@ -406,42 +406,6 @@ impl ast::WhereClause {
     }
 }
 
-impl ast::TypeParam {
-    pub fn remove_default(&self) {
-        if let Some((eq, last)) = self
-            .syntax()
-            .children_with_tokens()
-            .find(|it| it.kind() == T![=])
-            .zip(self.syntax().last_child_or_token())
-        {
-            ted::remove_all(eq..=last);
-
-            // remove any trailing ws
-            if let Some(last) = self.syntax().last_token().filter(|it| it.kind() == WHITESPACE) {
-                last.detach();
-            }
-        }
-    }
-}
-
-impl ast::ConstParam {
-    pub fn remove_default(&self) {
-        if let Some((eq, last)) = self
-            .syntax()
-            .children_with_tokens()
-            .find(|it| it.kind() == T![=])
-            .zip(self.syntax().last_child_or_token())
-        {
-            ted::remove_all(eq..=last);
-
-            // remove any trailing ws
-            if let Some(last) = self.syntax().last_token().filter(|it| it.kind() == WHITESPACE) {
-                last.detach();
-            }
-        }
-    }
-}
-
 pub trait Removable: AstNode {
     fn remove(&self);
 }
-- 
cgit 1.4.1-3-g733a5


From dc6c3300fcf520b2931355e922caa66758becb71 Mon Sep 17 00:00:00 2001
From: bohan <bohan-zhang@foxmail.com>
Date: Fri, 11 Jul 2025 20:11:49 +0800
Subject: compute all rpitit of a trait

---
 compiler/rustc_middle/src/query/mod.rs             |   6 ++
 compiler/rustc_ty_utils/src/assoc.rs               | 112 ++++++++++-----------
 .../rpitit-duplicate-associated-fn-with-nested.rs  |  13 +++
 ...itit-duplicate-associated-fn-with-nested.stderr |  23 ++++-
 4 files changed, 97 insertions(+), 57 deletions(-)

diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 9af5683ff75..49c36a3ff16 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1091,6 +1091,12 @@ rustc_queries! {
         separate_provide_extern
     }
 
+    query associated_types_for_impl_traits_in_trait(trait_id: DefId) -> &'tcx DefIdMap<&'tcx [DefId]> {
+        arena_cache
+        desc { |tcx| "creating associated items for trait `{}`", tcx.def_path_str(trait_id) }
+        separate_provide_extern
+    }
+
     /// Given an `impl_id`, return the trait it implements along with some header information.
     /// Return `None` if this is an inherent impl.
     query impl_trait_header(impl_id: DefId) -> Option<ty::ImplTraitHeader<'tcx>> {
diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index 6a9461f2b43..c9fbc8b0233 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -1,3 +1,6 @@
+use std::collections::hash_map::Entry;
+
+use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId};
@@ -6,12 +9,14 @@ use rustc_hir::intravisit::{self, Visitor};
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{self, ImplTraitInTraitData, TyCtxt};
 use rustc_middle::{bug, span_bug};
+use rustc_span::Symbol;
 
 pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers {
         associated_item,
         associated_item_def_ids,
         associated_items,
+        associated_types_for_impl_traits_in_trait,
         associated_types_for_impl_traits_in_associated_fn,
         impl_item_implementor_ids,
         ..*providers
@@ -163,10 +168,12 @@ struct RPITVisitor<'tcx> {
     synthetics: Vec<LocalDefId>,
     data: DefPathData,
     disambiguator: DisambiguatorState,
+    depth: u32,
 }
 
 impl<'tcx> Visitor<'tcx> for RPITVisitor<'tcx> {
     fn visit_opaque_ty(&mut self, opaque: &'tcx hir::OpaqueTy<'tcx>) -> Self::Result {
+        self.depth += 1;
         self.synthetics.push(associated_type_for_impl_trait_in_trait(
             self.tcx,
             opaque.def_id,
@@ -177,17 +184,6 @@ impl<'tcx> Visitor<'tcx> for RPITVisitor<'tcx> {
     }
 }
 
-struct DisambiguatorIdxVisitor {
-    depth: u32,
-}
-
-impl<'tcx> Visitor<'tcx> for DisambiguatorIdxVisitor {
-    fn visit_opaque_ty(&mut self, opaque: &'tcx hir::OpaqueTy<'tcx>) -> Self::Result {
-        self.depth += 1;
-        intravisit::walk_opaque_ty(self, opaque)
-    }
-}
-
 /// Given an `fn_def_id` of a trait or a trait implementation:
 ///
 /// if `fn_def_id` is a function defined inside a trait, then it synthesizes
@@ -205,51 +201,7 @@ fn associated_types_for_impl_traits_in_associated_fn(
 
     match tcx.def_kind(parent_def_id) {
         DefKind::Trait => {
-            if let Some(output) = tcx.hir_get_fn_output(fn_def_id) {
-                let def_path_id = |def_id: LocalDefId| tcx.item_name(def_id.to_def_id());
-                let def_path_data = def_path_id(fn_def_id);
-
-                let (.., trait_item_refs) = tcx.hir_expect_item(parent_def_id).expect_trait();
-                // The purpose of `disambiguator_idx` is to ensure there are
-                // no duplicate `def_id` in certain cases, such as:
-                // ```
-                // trait Foo {
-                //     fn bar() -> impl Trait;
-                //     fn bar() -> impl Trait;
-                //              // ~~~~~~~~~~ It will generate the same ID if we don’t disambiguate it.
-                // }
-                // ```
-                let disambiguator_idx = trait_item_refs
-                    .iter()
-                    .take_while(|item| item.id.owner_id.def_id != fn_def_id)
-                    .filter(|item| {
-                        matches!(item.kind, hir::AssocItemKind::Fn { .. })
-                            && def_path_id(item.id.owner_id.def_id) == def_path_data
-                    })
-                    .last()
-                    .map(|item| {
-                        let output = tcx.hir_get_fn_output(item.id.owner_id.def_id).unwrap();
-                        let mut visitor = DisambiguatorIdxVisitor { depth: 0 };
-                        visitor.visit_fn_ret_ty(output);
-                        tcx.def_key(item.id.owner_id.def_id).disambiguated_data.disambiguator
-                            + visitor.depth
-                    })
-                    .unwrap_or_default();
-
-                let data = DefPathData::AnonAssocTy(def_path_data);
-                let mut visitor = RPITVisitor {
-                    tcx,
-                    synthetics: vec![],
-                    data,
-                    disambiguator: DisambiguatorState::with(parent_def_id, data, disambiguator_idx),
-                };
-                visitor.visit_fn_ret_ty(output);
-                tcx.arena.alloc_from_iter(
-                    visitor.synthetics.into_iter().map(|def_id| def_id.to_def_id()),
-                )
-            } else {
-                &[]
-            }
+            tcx.associated_types_for_impl_traits_in_trait(parent_def_id)[&fn_def_id.to_def_id()]
         }
 
         DefKind::Impl { .. } => {
@@ -274,6 +226,54 @@ fn associated_types_for_impl_traits_in_associated_fn(
     }
 }
 
+fn associated_types_for_impl_traits_in_trait<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    trait_id: LocalDefId,
+) -> DefIdMap<&'tcx [DefId]> {
+    let (.., trait_item_refs) = tcx.hir_expect_item(trait_id).expect_trait();
+
+    let mut disambiguator_idx_map = FxHashMap::default();
+    let find_disambiguator_idx = |map: &mut FxHashMap<Symbol, u32>, name| match map.entry(name) {
+        Entry::Occupied(occ) => *occ.get() + 1,
+        Entry::Vacant(vac) => {
+            vac.insert(0);
+            0
+        }
+    };
+    let update_disambiguator_idx = |map: &mut FxHashMap<Symbol, u32>, name, offset: u32| {
+        *map.get_mut(&name).unwrap() += offset
+    };
+
+    trait_item_refs
+        .iter()
+        .filter_map(move |item| {
+            if !matches!(item.kind, hir::AssocItemKind::Fn { .. }) {
+                return None;
+            }
+            let fn_def_id = item.id.owner_id.def_id;
+            let Some(output) = tcx.hir_get_fn_output(fn_def_id) else {
+                return Some((fn_def_id.to_def_id(), &[] as &[DefId]));
+            };
+            let def_name = tcx.item_name(fn_def_id.to_def_id());
+            let disambiguator_idx = find_disambiguator_idx(&mut disambiguator_idx_map, def_name);
+            let data = DefPathData::AnonAssocTy(def_name);
+            let mut visitor = RPITVisitor {
+                tcx,
+                synthetics: vec![],
+                data,
+                depth: 0,
+                disambiguator: DisambiguatorState::with(trait_id, data, disambiguator_idx),
+            };
+            visitor.visit_fn_ret_ty(output);
+            update_disambiguator_idx(&mut disambiguator_idx_map, def_name, visitor.depth);
+            let defs = tcx
+                .arena
+                .alloc_from_iter(visitor.synthetics.into_iter().map(|def_id| def_id.to_def_id()));
+            Some((fn_def_id.to_def_id(), defs))
+        })
+        .collect()
+}
+
 /// Given an `opaque_ty_def_id` corresponding to an `impl Trait` in an associated
 /// function from a trait, synthesize an associated type for that `impl Trait`
 /// that inherits properties that we infer from the method and the opaque type.
diff --git a/tests/ui/impl-trait/in-trait/rpitit-duplicate-associated-fn-with-nested.rs b/tests/ui/impl-trait/in-trait/rpitit-duplicate-associated-fn-with-nested.rs
index e3dc22c1992..9c9cef24a96 100644
--- a/tests/ui/impl-trait/in-trait/rpitit-duplicate-associated-fn-with-nested.rs
+++ b/tests/ui/impl-trait/in-trait/rpitit-duplicate-associated-fn-with-nested.rs
@@ -43,4 +43,17 @@ trait Qux {
     //~^^^^ ERROR: the name `foo` is defined multiple times
 }
 
+trait T0<T> {
+    type Target;
+}
+trait T1<T> {}
+
+trait X {
+    fn a() -> impl T0<(), Target = impl T1<()>>;
+    fn a() -> impl T0<(), Target = impl T1<()>>;
+    //~^ ERROR the name `a` is defined multiple times
+    fn a() -> impl T0<(), Target = impl T1<()>>;
+    //~^ ERROR the name `a` is defined multiple times
+}
+
 fn main() {}
diff --git a/tests/ui/impl-trait/in-trait/rpitit-duplicate-associated-fn-with-nested.stderr b/tests/ui/impl-trait/in-trait/rpitit-duplicate-associated-fn-with-nested.stderr
index f4e73dc1798..8356f94f2aa 100644
--- a/tests/ui/impl-trait/in-trait/rpitit-duplicate-associated-fn-with-nested.stderr
+++ b/tests/ui/impl-trait/in-trait/rpitit-duplicate-associated-fn-with-nested.stderr
@@ -44,6 +44,27 @@ LL | |         >;
    |
    = note: `foo` must be defined only once in the value namespace of this trait
 
-error: aborting due to 4 previous errors
+error[E0428]: the name `a` is defined multiple times
+  --> $DIR/rpitit-duplicate-associated-fn-with-nested.rs:53:5
+   |
+LL |     fn a() -> impl T0<(), Target = impl T1<()>>;
+   |     -------------------------------------------- previous definition of the value `a` here
+LL |     fn a() -> impl T0<(), Target = impl T1<()>>;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `a` redefined here
+   |
+   = note: `a` must be defined only once in the value namespace of this trait
+
+error[E0428]: the name `a` is defined multiple times
+  --> $DIR/rpitit-duplicate-associated-fn-with-nested.rs:55:5
+   |
+LL |     fn a() -> impl T0<(), Target = impl T1<()>>;
+   |     -------------------------------------------- previous definition of the value `a` here
+...
+LL |     fn a() -> impl T0<(), Target = impl T1<()>>;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `a` redefined here
+   |
+   = note: `a` must be defined only once in the value namespace of this trait
+
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0428`.
-- 
cgit 1.4.1-3-g733a5


From 47e15d90e13b5238117971298a3573ddebd87a40 Mon Sep 17 00:00:00 2001
From: bohan <bohan-zhang@foxmail.com>
Date: Sun, 13 Jul 2025 02:52:03 +0800
Subject: query RPITIT in a trait or impl

---
 .../src/check/compare_impl_item.rs                 |   6 +-
 compiler/rustc_hir_analysis/src/check/wfcheck.rs   |   6 +-
 .../rustc_hir_analysis/src/hir_ty_lowering/mod.rs  |   4 +-
 .../src/rmeta/decoder/cstore_impl.rs               |   2 +-
 compiler/rustc_metadata/src/rmeta/encoder.rs       |  17 +-
 compiler/rustc_metadata/src/rmeta/mod.rs           |   2 +-
 compiler/rustc_middle/src/query/mod.rs             |  16 +-
 compiler/rustc_middle/src/ty/assoc.rs              |  21 ++
 compiler/rustc_middle/src/ty/mod.rs                |   3 +-
 compiler/rustc_middle/src/ty/parameterized.rs      |   1 +
 compiler/rustc_ty_utils/src/assoc.rs               | 216 ++++++++++-----------
 11 files changed, 143 insertions(+), 151 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index 87db80f2423..379ce69bdea 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -15,6 +15,7 @@ use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::{
     self, BottomUpFolder, GenericArgs, GenericParamDefKind, Ty, TyCtxt, TypeFoldable, TypeFolder,
     TypeSuperFoldable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode, Upcast,
+    associated_types_for_impl_traits_in_associated_fn,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::{DUMMY_SP, Span};
@@ -757,7 +758,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
     // returning `-> Missing<impl Sized>`, that gets converted to `-> {type error}`,
     // and when walking through the signature we end up never collecting the def id
     // of the `impl Sized`. Insert that here, so we don't ICE later.
-    for assoc_item in tcx.associated_types_for_impl_traits_in_associated_fn(trait_m.def_id) {
+    for assoc_item in associated_types_for_impl_traits_in_associated_fn(tcx, trait_m.def_id) {
         if !remapped_types.contains_key(assoc_item) {
             remapped_types.insert(
                 *assoc_item,
@@ -2448,8 +2449,7 @@ fn param_env_with_gat_bounds<'tcx>(
                     ty::ImplTraitInTraitData::Impl { fn_def_id }
                     | ty::ImplTraitInTraitData::Trait { fn_def_id, .. },
                 ),
-        } => tcx
-            .associated_types_for_impl_traits_in_associated_fn(fn_def_id)
+        } => associated_types_for_impl_traits_in_associated_fn(tcx, fn_def_id)
             .iter()
             .map(|def_id| tcx.associated_item(*def_id))
             .collect(),
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 428d627ad6f..3d3fdd899d3 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -20,7 +20,7 @@ use rustc_middle::ty::trait_def::TraitSpecializationKind;
 use rustc_middle::ty::{
     self, AdtKind, GenericArgKind, GenericArgs, GenericParamDefKind, Ty, TyCtxt, TypeFlags,
     TypeFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode,
-    Upcast,
+    Upcast, associated_types_for_impl_traits_in_associated_fn,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::parse::feature_err;
@@ -326,7 +326,9 @@ pub(crate) fn check_trait_item<'tcx>(
     let mut res = Ok(());
 
     if matches!(tcx.def_kind(def_id), DefKind::AssocFn) {
-        for &assoc_ty_def_id in tcx.associated_types_for_impl_traits_in_associated_fn(def_id) {
+        for &assoc_ty_def_id in
+            associated_types_for_impl_traits_in_associated_fn(tcx, def_id.to_def_id())
+        {
             res = res.and(check_associated_item(tcx, assoc_ty_def_id.expect_local()));
         }
     }
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 20d165897e2..ae56f0c5160 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -40,7 +40,7 @@ use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::ty::print::PrintPolyTraitRefExt as _;
 use rustc_middle::ty::{
     self, Const, GenericArgKind, GenericArgsRef, GenericParamDefKind, Ty, TyCtxt, TypeVisitableExt,
-    TypingMode, Upcast, fold_regions,
+    TypingMode, Upcast, associated_types_for_impl_traits_in_associated_fn, fold_regions,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint::builtin::AMBIGUOUS_ASSOCIATED_ITEMS;
@@ -2602,7 +2602,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         // do a linear search to map this to the synthetic associated type that
         // it will be lowered to.
         let def_id = if let Some(parent_def_id) = in_trait {
-            *tcx.associated_types_for_impl_traits_in_associated_fn(parent_def_id)
+            *associated_types_for_impl_traits_in_associated_fn(tcx, parent_def_id.to_def_id())
                 .iter()
                 .find(|rpitit| match tcx.opt_rpitit_info(**rpitit) {
                     Some(ty::ImplTraitInTraitData::Trait { opaque_def_id, .. }) => {
diff --git a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
index 6943d4198df..19954459cb5 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
@@ -326,7 +326,7 @@ provide! { tcx, def_id, other, cdata,
             .process_decoded(tcx, || panic!("{def_id:?} does not have trait_impl_trait_tys")))
     }
 
-    associated_types_for_impl_traits_in_associated_fn => { table_defaulted_array }
+    associated_types_for_impl_traits_in_trait_or_impl => { table }
 
     visibility => { cdata.get_visibility(def_id.index) }
     adt_def => { cdata.get_adt_def(def_id.index, tcx) }
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index b0ec605a85f..b50453cb0df 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1382,17 +1382,6 @@ fn should_encode_const(def_kind: DefKind) -> bool {
     }
 }
 
-fn should_encode_fn_impl_trait_in_trait<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool {
-    if let Some(assoc_item) = tcx.opt_associated_item(def_id)
-        && assoc_item.container == ty::AssocItemContainer::Trait
-        && assoc_item.is_fn()
-    {
-        true
-    } else {
-        false
-    }
-}
-
 impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
     fn encode_attrs(&mut self, def_id: LocalDefId) {
         let tcx = self.tcx;
@@ -1617,9 +1606,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             {
                 record!(self.tables.trait_impl_trait_tys[def_id] <- table);
             }
-            if should_encode_fn_impl_trait_in_trait(tcx, def_id) {
-                let table = tcx.associated_types_for_impl_traits_in_associated_fn(def_id);
-                record_defaulted_array!(self.tables.associated_types_for_impl_traits_in_associated_fn[def_id] <- table);
+            if let DefKind::Impl { .. } | DefKind::Trait = def_kind {
+                let table = tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id);
+                record!(self.tables.associated_types_for_impl_traits_in_trait_or_impl[def_id] <- table);
             }
         }
 
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
index a962a787a42..213090d7d47 100644
--- a/compiler/rustc_metadata/src/rmeta/mod.rs
+++ b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -403,7 +403,6 @@ define_tables! {
     explicit_implied_predicates_of: Table<DefIndex, LazyArray<(ty::Clause<'static>, Span)>>,
     explicit_implied_const_bounds: Table<DefIndex, LazyArray<(ty::PolyTraitRef<'static>, Span)>>,
     inherent_impls: Table<DefIndex, LazyArray<DefIndex>>,
-    associated_types_for_impl_traits_in_associated_fn: Table<DefIndex, LazyArray<DefId>>,
     opt_rpitit_info: Table<DefIndex, Option<LazyValue<ty::ImplTraitInTraitData>>>,
     // Reexported names are not associated with individual `DefId`s,
     // e.g. a glob import can introduce a lot of names, all with the same `DefId`.
@@ -482,6 +481,7 @@ define_tables! {
     assumed_wf_types_for_rpitit: Table<DefIndex, LazyArray<(Ty<'static>, Span)>>,
     opaque_ty_origin: Table<DefIndex, LazyValue<hir::OpaqueTyOrigin<DefId>>>,
     anon_const_kind: Table<DefIndex, LazyValue<ty::AnonConstKind>>,
+    associated_types_for_impl_traits_in_trait_or_impl: Table<DefIndex, LazyValue<ty::AssocTyForImplTraitInTraitOrImpl>>,
 }
 
 #[derive(TyEncodable, TyDecodable)]
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 49c36a3ff16..3da6c6f5fe1 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1079,21 +1079,9 @@ rustc_queries! {
         desc { |tcx| "comparing impl items against trait for `{}`", tcx.def_path_str(impl_id) }
     }
 
-    /// Given `fn_def_id` of a trait or of an impl that implements a given trait:
-    /// if `fn_def_id` is the def id of a function defined inside a trait, then it creates and returns
-    /// the associated items that correspond to each impl trait in return position for that trait.
-    /// if `fn_def_id` is the def id of a function defined inside an impl that implements a trait, then it
-    /// creates and returns the associated items that correspond to each impl trait in return position
-    /// of the implemented trait.
-    query associated_types_for_impl_traits_in_associated_fn(fn_def_id: DefId) -> &'tcx [DefId] {
-        desc { |tcx| "creating associated items for opaque types returned by `{}`", tcx.def_path_str(fn_def_id) }
-        cache_on_disk_if { fn_def_id.is_local() }
-        separate_provide_extern
-    }
-
-    query associated_types_for_impl_traits_in_trait(trait_id: DefId) -> &'tcx DefIdMap<&'tcx [DefId]> {
+    query associated_types_for_impl_traits_in_trait_or_impl(did: DefId) -> &'tcx ty::AssocTyForImplTraitInTraitOrImpl {
         arena_cache
-        desc { |tcx| "creating associated items for trait `{}`", tcx.def_path_str(trait_id) }
+        desc { |tcx| "creating rpitit for `{}`", tcx.def_path_str(did) }
         separate_provide_extern
     }
 
diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs
index 344a81f5e24..99714171c72 100644
--- a/compiler/rustc_middle/src/ty/assoc.rs
+++ b/compiler/rustc_middle/src/ty/assoc.rs
@@ -1,4 +1,5 @@
 use rustc_attr_data_structures::{AttributeKind, find_attr};
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sorted_map::SortedIndexMultiMap;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Namespace};
@@ -285,3 +286,23 @@ impl AssocItems {
             .find(|item| tcx.hygienic_eq(ident, item.ident(tcx), parent_def_id))
     }
 }
+
+#[derive(Debug, Clone, PartialEq, Encodable, Decodable, HashStable)]
+pub struct AssocTyForImplTraitInTraitOrImpl(pub FxIndexMap<DefId, Vec<DefId>>);
+
+/// Given an `fn_def_id` of a trait or a trait implementation:
+///
+/// if `fn_def_id` is a function defined inside a trait, then it synthesizes
+/// a new def id corresponding to a new associated type for each return-
+/// position `impl Trait` in the signature.
+///
+/// if `fn_def_id` is a function inside of an impl, then for each synthetic
+/// associated type generated for the corresponding trait function described
+/// above, synthesize a corresponding associated type in the impl.
+pub fn associated_types_for_impl_traits_in_associated_fn(
+    tcx: TyCtxt<'_>,
+    fn_def_id: DefId,
+) -> &'_ [DefId] {
+    let parent_def_id = tcx.parent(fn_def_id);
+    &tcx.associated_types_for_impl_traits_in_trait_or_impl(parent_def_id).0[&fn_def_id]
+}
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 0177a95498b..e1b11e4f54a 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2194,8 +2194,7 @@ impl<'tcx> TyCtxt<'tcx> {
             return false;
         };
 
-        return !self
-            .associated_types_for_impl_traits_in_associated_fn(trait_item_def_id)
+        return !associated_types_for_impl_traits_in_associated_fn(self, trait_item_def_id)
             .is_empty();
     }
 }
diff --git a/compiler/rustc_middle/src/ty/parameterized.rs b/compiler/rustc_middle/src/ty/parameterized.rs
index 3858778bfc8..88f6e717af4 100644
--- a/compiler/rustc_middle/src/ty/parameterized.rs
+++ b/compiler/rustc_middle/src/ty/parameterized.rs
@@ -67,6 +67,7 @@ trivially_parameterized_over_tcx! {
     crate::mir::ConstQualifs,
     ty::AsyncDestructor,
     ty::AssocItemContainer,
+    ty::AssocTyForImplTraitInTraitOrImpl,
     ty::Asyncness,
     ty::AnonConstKind,
     ty::DeducedParamAttrs,
diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index c9fbc8b0233..400158496b5 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -1,13 +1,13 @@
 use std::collections::hash_map::Entry;
 
-use rustc_data_structures::fx::FxHashMap;
-use rustc_hir as hir;
+use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId};
 use rustc_hir::definitions::{DefPathData, DisambiguatorState};
 use rustc_hir::intravisit::{self, Visitor};
+use rustc_hir::{self as hir, ItemKind};
 use rustc_middle::query::Providers;
-use rustc_middle::ty::{self, ImplTraitInTraitData, TyCtxt};
+use rustc_middle::ty::{self, AssocTyForImplTraitInTraitOrImpl, ImplTraitInTraitData, TyCtxt};
 use rustc_middle::{bug, span_bug};
 use rustc_span::Symbol;
 
@@ -16,8 +16,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         associated_item,
         associated_item_def_ids,
         associated_items,
-        associated_types_for_impl_traits_in_trait,
-        associated_types_for_impl_traits_in_associated_fn,
+        associated_types_for_impl_traits_in_trait_or_impl,
         impl_item_implementor_ids,
         ..*providers
     };
@@ -28,24 +27,17 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &[DefId] {
     match item.kind {
         hir::ItemKind::Trait(.., trait_item_refs) => {
             // We collect RPITITs for each trait method's return type and create a
-            // corresponding associated item using associated_types_for_impl_traits_in_associated_fn
+            // corresponding associated item using associated_types_for_impl_traits_in_trait_or_impl
             // query.
             tcx.arena.alloc_from_iter(
                 trait_item_refs
                     .iter()
                     .map(|trait_item_ref| trait_item_ref.id.owner_id.to_def_id())
                     .chain(
-                        trait_item_refs
-                            .iter()
-                            .filter(|trait_item_ref| {
-                                matches!(trait_item_ref.kind, hir::AssocItemKind::Fn { .. })
-                            })
-                            .flat_map(|trait_item_ref| {
-                                let trait_fn_def_id = trait_item_ref.id.owner_id.def_id.to_def_id();
-                                tcx.associated_types_for_impl_traits_in_associated_fn(
-                                    trait_fn_def_id,
-                                )
-                            })
+                        tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id)
+                            .0
+                            .values()
+                            .flatten()
                             .copied(),
                     ),
             )
@@ -53,25 +45,17 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &[DefId] {
         hir::ItemKind::Impl(impl_) => {
             // We collect RPITITs for each trait method's return type, on the impl side too and
             // create a corresponding associated item using
-            // associated_types_for_impl_traits_in_associated_fn query.
+            // associated_types_for_impl_traits_in_trait_or_impl query.
             tcx.arena.alloc_from_iter(
                 impl_
                     .items
                     .iter()
                     .map(|impl_item_ref| impl_item_ref.id.owner_id.to_def_id())
                     .chain(impl_.of_trait.iter().flat_map(|_| {
-                        impl_
-                            .items
-                            .iter()
-                            .filter(|impl_item_ref| {
-                                matches!(impl_item_ref.kind, hir::AssocItemKind::Fn { .. })
-                            })
-                            .flat_map(|impl_item_ref| {
-                                let impl_fn_def_id = impl_item_ref.id.owner_id.def_id.to_def_id();
-                                tcx.associated_types_for_impl_traits_in_associated_fn(
-                                    impl_fn_def_id,
-                                )
-                            })
+                        tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id)
+                            .0
+                            .values()
+                            .flatten()
                             .copied()
                     })),
             )
@@ -184,94 +168,102 @@ impl<'tcx> Visitor<'tcx> for RPITVisitor<'tcx> {
     }
 }
 
-/// Given an `fn_def_id` of a trait or a trait implementation:
-///
-/// if `fn_def_id` is a function defined inside a trait, then it synthesizes
-/// a new def id corresponding to a new associated type for each return-
-/// position `impl Trait` in the signature.
-///
-/// if `fn_def_id` is a function inside of an impl, then for each synthetic
-/// associated type generated for the corresponding trait function described
-/// above, synthesize a corresponding associated type in the impl.
-fn associated_types_for_impl_traits_in_associated_fn(
-    tcx: TyCtxt<'_>,
-    fn_def_id: LocalDefId,
-) -> &'_ [DefId] {
-    let parent_def_id = tcx.local_parent(fn_def_id);
+fn associated_types_for_impl_traits_in_trait_or_impl<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    def_id: LocalDefId,
+) -> AssocTyForImplTraitInTraitOrImpl {
+    let item = tcx.hir_expect_item(def_id);
+    match item.kind {
+        ItemKind::Trait(.., trait_item_refs) => {
+            let mut disambiguator_idx_map = FxHashMap::default();
+            let find_disambiguator_idx =
+                |map: &mut FxHashMap<Symbol, u32>, name| match map.entry(name) {
+                    Entry::Occupied(occ) => *occ.get() + 1,
+                    Entry::Vacant(vac) => {
+                        vac.insert(0);
+                        0
+                    }
+                };
+            let update_disambiguator_idx = |map: &mut FxHashMap<Symbol, u32>, name, offset: u32| {
+                *map.get_mut(&name).unwrap() += offset
+            };
 
-    match tcx.def_kind(parent_def_id) {
-        DefKind::Trait => {
-            tcx.associated_types_for_impl_traits_in_trait(parent_def_id)[&fn_def_id.to_def_id()]
+            ty::AssocTyForImplTraitInTraitOrImpl(
+                trait_item_refs
+                    .iter()
+                    .filter_map(move |item| {
+                        if !matches!(item.kind, hir::AssocItemKind::Fn { .. }) {
+                            return None;
+                        }
+                        let fn_def_id = item.id.owner_id.def_id;
+                        let Some(output) = tcx.hir_get_fn_output(fn_def_id) else {
+                            return Some((fn_def_id.to_def_id(), vec![]));
+                        };
+                        let def_name = tcx.item_name(fn_def_id.to_def_id());
+                        let disambiguator_idx =
+                            find_disambiguator_idx(&mut disambiguator_idx_map, def_name);
+                        let data = DefPathData::AnonAssocTy(def_name);
+                        let mut visitor = RPITVisitor {
+                            tcx,
+                            synthetics: vec![],
+                            data,
+                            depth: 0,
+                            disambiguator: DisambiguatorState::with(
+                                def_id,
+                                data,
+                                disambiguator_idx,
+                            ),
+                        };
+                        visitor.visit_fn_ret_ty(output);
+                        update_disambiguator_idx(
+                            &mut disambiguator_idx_map,
+                            def_name,
+                            visitor.depth,
+                        );
+                        let defs = visitor
+                            .synthetics
+                            .into_iter()
+                            .map(|def_id| def_id.to_def_id())
+                            .collect::<Vec<_>>();
+                        Some((fn_def_id.to_def_id(), defs))
+                    })
+                    .collect::<FxIndexMap<_, _>>(),
+            )
         }
-
-        DefKind::Impl { .. } => {
-            let Some(trait_fn_def_id) = tcx.associated_item(fn_def_id).trait_item_def_id else {
-                return &[];
+        ItemKind::Impl(impl_) => {
+            let Some(trait_did) = tcx.impl_trait_ref(def_id).map(|t| t.skip_binder().def_id) else {
+                return ty::AssocTyForImplTraitInTraitOrImpl(Default::default());
             };
-            tcx.arena.alloc_from_iter(
-                tcx.associated_types_for_impl_traits_in_associated_fn(trait_fn_def_id).iter().map(
-                    move |&trait_assoc_def_id| {
-                        associated_type_for_impl_trait_in_impl(tcx, trait_assoc_def_id, fn_def_id)
-                            .to_def_id()
-                    },
-                ),
+            let in_trait_def = tcx.associated_types_for_impl_traits_in_trait_or_impl(trait_did);
+            ty::AssocTyForImplTraitInTraitOrImpl(
+                impl_
+                    .items
+                    .iter()
+                    .filter_map(|item| {
+                        if !matches!(item.kind, hir::AssocItemKind::Fn { .. }) {
+                            return None;
+                        }
+                        let did = item.id.owner_id.def_id.to_def_id();
+                        let Some(trait_item_def_id) = item.trait_item_def_id else {
+                            return Some((did, vec![]));
+                        };
+                        let iter = in_trait_def.0[&trait_item_def_id].iter().map(|&id| {
+                            associated_type_for_impl_trait_in_impl(tcx, id, item.id.owner_id.def_id)
+                                .to_def_id()
+                        });
+                        Some((did, iter.collect()))
+                    })
+                    .collect::<FxIndexMap<_, _>>(),
             )
         }
-
-        def_kind => bug!(
-            "associated_types_for_impl_traits_in_associated_fn: {:?} should be Trait or Impl but is {:?}",
-            parent_def_id,
-            def_kind
-        ),
-    }
-}
-
-fn associated_types_for_impl_traits_in_trait<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    trait_id: LocalDefId,
-) -> DefIdMap<&'tcx [DefId]> {
-    let (.., trait_item_refs) = tcx.hir_expect_item(trait_id).expect_trait();
-
-    let mut disambiguator_idx_map = FxHashMap::default();
-    let find_disambiguator_idx = |map: &mut FxHashMap<Symbol, u32>, name| match map.entry(name) {
-        Entry::Occupied(occ) => *occ.get() + 1,
-        Entry::Vacant(vac) => {
-            vac.insert(0);
-            0
+        _ => {
+            bug!(
+                "associated_types_for_impl_traits_in_trait_or_impl: {:?} should be Trait or Impl but is {:?}",
+                def_id,
+                tcx.def_kind(def_id)
+            )
         }
-    };
-    let update_disambiguator_idx = |map: &mut FxHashMap<Symbol, u32>, name, offset: u32| {
-        *map.get_mut(&name).unwrap() += offset
-    };
-
-    trait_item_refs
-        .iter()
-        .filter_map(move |item| {
-            if !matches!(item.kind, hir::AssocItemKind::Fn { .. }) {
-                return None;
-            }
-            let fn_def_id = item.id.owner_id.def_id;
-            let Some(output) = tcx.hir_get_fn_output(fn_def_id) else {
-                return Some((fn_def_id.to_def_id(), &[] as &[DefId]));
-            };
-            let def_name = tcx.item_name(fn_def_id.to_def_id());
-            let disambiguator_idx = find_disambiguator_idx(&mut disambiguator_idx_map, def_name);
-            let data = DefPathData::AnonAssocTy(def_name);
-            let mut visitor = RPITVisitor {
-                tcx,
-                synthetics: vec![],
-                data,
-                depth: 0,
-                disambiguator: DisambiguatorState::with(trait_id, data, disambiguator_idx),
-            };
-            visitor.visit_fn_ret_ty(output);
-            update_disambiguator_idx(&mut disambiguator_idx_map, def_name, visitor.depth);
-            let defs = tcx
-                .arena
-                .alloc_from_iter(visitor.synthetics.into_iter().map(|def_id| def_id.to_def_id()));
-            Some((fn_def_id.to_def_id(), defs))
-        })
-        .collect()
+    }
 }
 
 /// Given an `opaque_ty_def_id` corresponding to an `impl Trait` in an associated
-- 
cgit 1.4.1-3-g733a5


From 47b8a32ca311e2c441f4e7d747bfd75f0045baa1 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Tue, 1 Jul 2025 20:20:14 +0500
Subject: moved tests

---
 .../super-let-lifetime-and-drop.borrowck.stderr    | 174 +++++++++++++
 tests/ui/borrowck/super-let-lifetime-and-drop.rs   | 286 +++++++++++++++++++++
 tests/ui/cast/cast-enum-to-primitive-error.fixed   |  20 ++
 tests/ui/cast/cast-enum-to-primitive-error.rs      |  20 ++
 tests/ui/cast/cast-enum-to-primitive-error.stderr  |  16 ++
 tests/ui/cast/coercion-as-explicit-cast.rs         |  62 +++++
 tests/ui/cast/coercion-as-explicit-cast.stderr     |  12 +
 tests/ui/generics/generic-enum-errors.rs           |   6 +
 tests/ui/generics/generic-enum-errors.stderr       |  29 +++
 tests/ui/modules/module-super-access.rs            |  15 ++
 tests/ui/modules/super-at-crate-root.rs            |   4 +
 tests/ui/modules/super-at-crate-root.stderr        |   9 +
 tests/ui/parser/syntactic-trailing-commas.rs       |  34 +++
 tests/ui/ptr_ops/ptr-swap-basic.rs                 |  10 +
 tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs   |  43 ++++
 .../recursion/recursion-tail-call-no-arg-leak.rs   |   8 +
 tests/ui/recursion/recursion-tail-cps.rs           |  17 ++
 tests/ui/super-at-top-level.rs                     |   4 -
 tests/ui/super-at-top-level.stderr                 |   9 -
 tests/ui/super-let.borrowck.stderr                 | 174 -------------
 tests/ui/super-let.rs                              | 286 ---------------------
 tests/ui/super.rs                                  |  15 --
 tests/ui/svh-add-nothing.rs                        |  13 -
 tests/ui/svh/svh-no-api-change-no-recompile.rs     |  13 +
 tests/ui/swap-1.rs                                 |  10 -
 tests/ui/swap-overlapping.rs                       |  43 ----
 tests/ui/switched-expectations.rs                  |   4 -
 tests/ui/switched-expectations.stderr              |  14 -
 tests/ui/tag-type-args.rs                          |   6 -
 tests/ui/tag-type-args.stderr                      |  29 ---
 tests/ui/tag-variant-cast-non-nullary.fixed        |  20 --
 tests/ui/tag-variant-cast-non-nullary.rs           |  20 --
 tests/ui/tag-variant-cast-non-nullary.stderr       |  16 --
 tests/ui/tail-call-arg-leak.rs                     |   8 -
 tests/ui/tail-cps.rs                               |  17 --
 tests/ui/tail-typeck.rs                            |   5 -
 tests/ui/tail-typeck.stderr                        |  16 --
 tests/ui/trailing-comma.rs                         |  34 ---
 tests/ui/trait-method-number-parameters.rs         |  13 -
 tests/ui/trait-method-number-parameters.stderr     |  13 -
 tests/ui/traits/trait-method-signature-mismatch.rs |  13 +
 .../traits/trait-method-signature-mismatch.stderr  |  13 +
 .../ui/traits/tryfrominterror-result-comparison.rs |  12 +
 tests/ui/transmute-equal-assoc-types.rs            |  11 -
 tests/ui/transmute-non-immediate-to-immediate.rs   |  10 -
 tests/ui/transmute/transmute-array-to-scalar.rs    |  10 +
 .../ui/transmute/transmute-same-associated-type.rs |  11 +
 tests/ui/trivial_casts-rpass.rs                    |  62 -----
 tests/ui/trivial_casts-rpass.stderr                |  12 -
 tests/ui/try-from-int-error-partial-eq.rs          |  12 -
 tests/ui/typeck/mismatched-types-ref-binding.rs    |   4 +
 .../ui/typeck/mismatched-types-ref-binding.stderr  |  14 +
 tests/ui/typeck/tail-return-type-mismatch.rs       |   5 +
 tests/ui/typeck/tail-return-type-mismatch.stderr   |  16 ++
 54 files changed, 876 insertions(+), 876 deletions(-)
 create mode 100644 tests/ui/borrowck/super-let-lifetime-and-drop.borrowck.stderr
 create mode 100644 tests/ui/borrowck/super-let-lifetime-and-drop.rs
 create mode 100644 tests/ui/cast/cast-enum-to-primitive-error.fixed
 create mode 100644 tests/ui/cast/cast-enum-to-primitive-error.rs
 create mode 100644 tests/ui/cast/cast-enum-to-primitive-error.stderr
 create mode 100644 tests/ui/cast/coercion-as-explicit-cast.rs
 create mode 100644 tests/ui/cast/coercion-as-explicit-cast.stderr
 create mode 100644 tests/ui/generics/generic-enum-errors.rs
 create mode 100644 tests/ui/generics/generic-enum-errors.stderr
 create mode 100644 tests/ui/modules/module-super-access.rs
 create mode 100644 tests/ui/modules/super-at-crate-root.rs
 create mode 100644 tests/ui/modules/super-at-crate-root.stderr
 create mode 100644 tests/ui/parser/syntactic-trailing-commas.rs
 create mode 100644 tests/ui/ptr_ops/ptr-swap-basic.rs
 create mode 100644 tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs
 create mode 100644 tests/ui/recursion/recursion-tail-call-no-arg-leak.rs
 create mode 100644 tests/ui/recursion/recursion-tail-cps.rs
 delete mode 100644 tests/ui/super-at-top-level.rs
 delete mode 100644 tests/ui/super-at-top-level.stderr
 delete mode 100644 tests/ui/super-let.borrowck.stderr
 delete mode 100644 tests/ui/super-let.rs
 delete mode 100644 tests/ui/super.rs
 delete mode 100644 tests/ui/svh-add-nothing.rs
 create mode 100644 tests/ui/svh/svh-no-api-change-no-recompile.rs
 delete mode 100644 tests/ui/swap-1.rs
 delete mode 100644 tests/ui/swap-overlapping.rs
 delete mode 100644 tests/ui/switched-expectations.rs
 delete mode 100644 tests/ui/switched-expectations.stderr
 delete mode 100644 tests/ui/tag-type-args.rs
 delete mode 100644 tests/ui/tag-type-args.stderr
 delete mode 100644 tests/ui/tag-variant-cast-non-nullary.fixed
 delete mode 100644 tests/ui/tag-variant-cast-non-nullary.rs
 delete mode 100644 tests/ui/tag-variant-cast-non-nullary.stderr
 delete mode 100644 tests/ui/tail-call-arg-leak.rs
 delete mode 100644 tests/ui/tail-cps.rs
 delete mode 100644 tests/ui/tail-typeck.rs
 delete mode 100644 tests/ui/tail-typeck.stderr
 delete mode 100644 tests/ui/trailing-comma.rs
 delete mode 100644 tests/ui/trait-method-number-parameters.rs
 delete mode 100644 tests/ui/trait-method-number-parameters.stderr
 create mode 100644 tests/ui/traits/trait-method-signature-mismatch.rs
 create mode 100644 tests/ui/traits/trait-method-signature-mismatch.stderr
 create mode 100644 tests/ui/traits/tryfrominterror-result-comparison.rs
 delete mode 100644 tests/ui/transmute-equal-assoc-types.rs
 delete mode 100644 tests/ui/transmute-non-immediate-to-immediate.rs
 create mode 100644 tests/ui/transmute/transmute-array-to-scalar.rs
 create mode 100644 tests/ui/transmute/transmute-same-associated-type.rs
 delete mode 100644 tests/ui/trivial_casts-rpass.rs
 delete mode 100644 tests/ui/trivial_casts-rpass.stderr
 delete mode 100644 tests/ui/try-from-int-error-partial-eq.rs
 create mode 100644 tests/ui/typeck/mismatched-types-ref-binding.rs
 create mode 100644 tests/ui/typeck/mismatched-types-ref-binding.stderr
 create mode 100644 tests/ui/typeck/tail-return-type-mismatch.rs
 create mode 100644 tests/ui/typeck/tail-return-type-mismatch.stderr

diff --git a/tests/ui/borrowck/super-let-lifetime-and-drop.borrowck.stderr b/tests/ui/borrowck/super-let-lifetime-and-drop.borrowck.stderr
new file mode 100644
index 00000000000..7fe0b47ed57
--- /dev/null
+++ b/tests/ui/borrowck/super-let-lifetime-and-drop.borrowck.stderr
@@ -0,0 +1,174 @@
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:30:28
+   |
+LL |             super let b = DropMe(&mut x);
+   |                                  ------ `x` is borrowed here
+...
+LL |         #[cfg(borrowck)] { x = true; }
+   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
+...
+LL |     }
+   |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
+
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:46:28
+   |
+LL |             super let b = &DropMe(&mut x);
+   |                            --------------
+   |                            |      |
+   |                            |      `x` is borrowed here
+   |                            a temporary with access to the borrow is created here ...
+...
+LL |         #[cfg(borrowck)] { x = true; }
+   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
+...
+LL |     }
+   |     - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
+
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:64:32
+   |
+LL |             super let b = identity(&DropMe(&mut x));
+   |                                     --------------
+   |                                     |      |
+   |                                     |      `x` is borrowed here
+   |                                     a temporary with access to the borrow is created here ...
+LL |             #[cfg(borrowck)] { x = true; }
+   |                                ^^^^^^^^ `x` is assigned to here but it was already borrowed
+...
+LL |         };
+   |          - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
+
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:87:36
+   |
+LL |                 super let b = identity(&DropMe(&mut x));
+   |                                         --------------
+   |                                         |      |
+   |                                         |      `x` is borrowed here
+   |                                         a temporary with access to the borrow is created here ...
+...
+LL |                 #[cfg(borrowck)] { x = true; }
+   |                                    ^^^^^^^^ `x` is assigned to here but it was already borrowed
+...
+LL |         ));
+   |           - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
+
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:107:28
+   |
+LL |                 super let b = DropMe(&mut x);
+   |                                      ------ `x` is borrowed here
+...
+LL |         #[cfg(borrowck)] { x = true; }
+   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
+...
+LL |     }
+   |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
+
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:125:28
+   |
+LL |             super let b = DropMe(&mut x);
+   |                                  ------ `x` is borrowed here
+...
+LL |         #[cfg(borrowck)] { x = true; }
+   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
+...
+LL |     }
+   |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
+
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:143:28
+   |
+LL |             super let b = DropMe(&mut x);
+   |                                  ------ `x` is borrowed here
+...
+LL |         #[cfg(borrowck)] { x = true; }
+   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
+...
+LL |     }
+   |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
+
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:159:28
+   |
+LL |             b = DropMe(&mut x);
+   |                        ------ `x` is borrowed here
+...
+LL |         #[cfg(borrowck)] { x = true; }
+   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
+LL |         drop(a);
+   |              - borrow later used here
+
+error[E0716]: temporary value dropped while borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:172:33
+   |
+LL |         #[cfg(borrowck)] { a = &String::from("asdf"); };
+   |                                 ^^^^^^^^^^^^^^^^^^^^- temporary value is freed at the end of this statement
+   |                                 |
+   |                                 creates a temporary value which is freed while still in use
+...
+LL |         let _ = a;
+   |                 - borrow later used here
+   |
+   = note: consider using a `let` binding to create a longer lived value
+
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:206:28
+   |
+LL |                     super let d = &DropMe(&mut x);
+   |                                    --------------
+   |                                    |      |
+   |                                    |      `x` is borrowed here
+   |                                    a temporary with access to the borrow is created here ...
+...
+LL |         #[cfg(borrowck)] { x = true; }
+   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
+...
+LL |     }
+   |     - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
+
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:227:32
+   |
+LL |                     super let d = identity(&DropMe(&mut x));
+   |                                             --------------
+   |                                             |      |
+   |                                             |      `x` is borrowed here
+   |                                             a temporary with access to the borrow is created here ...
+...
+LL |             #[cfg(borrowck)] { x = true; }
+   |                                ^^^^^^^^ `x` is assigned to here but it was already borrowed
+...
+LL |         };
+   |          - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
+
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:246:28
+   |
+LL |             super let b = DropMe(&mut x);
+   |                                  ------ `x` is borrowed here
+...
+LL |         #[cfg(borrowck)] { x = true; }
+   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
+...
+LL |     }
+   |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
+
+error[E0506]: cannot assign to `x` because it is borrowed
+  --> $DIR/super-let-lifetime-and-drop.rs:263:28
+   |
+LL |             let dropme = Some(DropMe(&mut x));
+   |                                      ------ `x` is borrowed here
+...
+LL |         #[cfg(borrowck)] { x = true; }
+   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
+...
+LL |     }
+   |     - borrow might be used here, when `x` is dropped and runs the `Drop` code for type `DropMe`
+
+error: aborting due to 13 previous errors
+
+Some errors have detailed explanations: E0506, E0716.
+For more information about an error, try `rustc --explain E0506`.
diff --git a/tests/ui/borrowck/super-let-lifetime-and-drop.rs b/tests/ui/borrowck/super-let-lifetime-and-drop.rs
new file mode 100644
index 00000000000..380470f792f
--- /dev/null
+++ b/tests/ui/borrowck/super-let-lifetime-and-drop.rs
@@ -0,0 +1,286 @@
+// Check in two ways:
+// - borrowck: Check with borrow checking errors when things are alive and dead.
+// - runtime: Check with a mutable bool if things are dropped on time.
+//
+//@ revisions: runtime borrowck
+//@ [runtime] run-pass
+//@ [borrowck] check-fail
+
+#![allow(dropping_references)]
+#![feature(super_let, stmt_expr_attributes)]
+
+use std::convert::identity;
+
+struct DropMe<'a>(&'a mut bool);
+
+impl Drop for DropMe<'_> {
+    fn drop(&mut self) {
+        *self.0 = true;
+    }
+}
+
+// Check that a super let variable lives as long as the result of a block.
+fn extended_variable() {
+    let mut x = false;
+    {
+        let a = {
+            super let b = DropMe(&mut x);
+            &b
+        };
+        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+        drop(a);
+        // DropMe is still alive here...
+    }
+    // ... but not here.
+    assert_eq!(x, true) // ok
+}
+
+// Check that the init expression of a super let is subject to (temporary) lifetime extension.
+fn extended_temporary() {
+    let mut x = false;
+    {
+        let a = {
+            super let b = &DropMe(&mut x);
+            b
+        };
+        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+        drop(a);
+        // DropMe is still alive here...
+    }
+    // ... but not here.
+    assert_eq!(x, true); // ok
+}
+
+// Check that even non-extended temporaries live until the end of the block,
+// but (unlike extended temporaries) not beyond that.
+//
+// This is necessary for things like select(pin!(identity(&temp()))) to work.
+fn non_extended() {
+    let mut x = false;
+    {
+        let _a = {
+            // Use identity() to supress temporary lifetime extension.
+            super let b = identity(&DropMe(&mut x));
+            #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+            b
+            // DropMe is still alive here...
+        };
+        // ... but not here.
+        assert_eq!(x, true); // ok
+    }
+}
+
+// Check that even non-extended temporaries live until the end of the block,
+// but (unlike extended temporaries) not beyond that.
+//
+// This is necessary for things like select(pin!(identity(&temp()))) to work.
+fn non_extended_in_expression() {
+    let mut x = false;
+    {
+        identity((
+            {
+                // Use identity() to supress temporary lifetime extension.
+                super let b = identity(&DropMe(&mut x));
+                b
+            },
+            {
+                #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+                // DropMe is still alive here...
+            }
+        ));
+        // ... but not here.
+        assert_eq!(x, true); // ok
+    }
+}
+
+// Check `super let` in a match arm.
+fn match_arm() {
+    let mut x = false;
+    {
+        let a = match Some(123) {
+            Some(_) => {
+                super let b = DropMe(&mut x);
+                &b
+            }
+            None => unreachable!(),
+        };
+        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+        drop(a);
+        // DropMe is still alive here...
+    }
+    // ... but not here.
+    assert_eq!(x, true); // ok
+}
+
+// Check `super let` in an if body.
+fn if_body() {
+    let mut x = false;
+    {
+        let a = if true {
+            super let b = DropMe(&mut x);
+            &b
+        } else {
+            unreachable!()
+        };
+        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+        drop(a);
+        // DropMe is still alive here...
+    }
+    // ... but not here.
+    assert_eq!(x, true); // ok
+}
+
+// Check `super let` in an else body.
+fn else_body() {
+    let mut x = false;
+    {
+        let a = if false {
+            unreachable!()
+        } else {
+            super let b = DropMe(&mut x);
+            &b
+        };
+        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+        drop(a);
+        // DropMe is still alive here...
+    }
+    // ... but not here.
+    assert_eq!(x, true); // ok
+}
+
+fn without_initializer() {
+    let mut x = false;
+    {
+        let a = {
+            super let b;
+            b = DropMe(&mut x);
+            b
+        };
+        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+        drop(a);
+        // DropMe is still alive here...
+    }
+    // ... but not here.
+    assert_eq!(x, true);
+}
+
+// Assignment isn't special, even when assigning to a `super let` variable.
+fn assignment() {
+    let mut x = false;
+    {
+        super let a;
+        #[cfg(borrowck)] { a = &String::from("asdf"); }; //[borrowck]~ ERROR dropped while borrowed
+        #[cfg(runtime)] { a = drop(&DropMe(&mut x)); } // Temporary dropped at the `;` as usual.
+        assert_eq!(x, true);
+        let _ = a;
+    }
+}
+
+// `super let mut` should work just fine.
+fn mutable() {
+    let mut x = false;
+    {
+        let a = {
+            super let mut b = None;
+            &mut b
+        };
+        *a = Some(DropMe(&mut x));
+    }
+    assert_eq!(x, true);
+}
+
+// Temporary lifetime extension should recurse through `super let`s.
+fn multiple_levels() {
+    let mut x = false;
+    {
+        let a = {
+            super let b = {
+                super let c = {
+                    super let d = &DropMe(&mut x);
+                    d
+                };
+                c
+            };
+            b
+        };
+        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+        drop(a);
+        // DropMe is still alive here...
+    }
+    // ... but not here.
+    assert_eq!(x, true);
+}
+
+// Non-extended temporaries should be dropped at the
+// end of the first parent statement that isn't `super`.
+fn multiple_levels_but_no_extension() {
+    let mut x = false;
+    {
+        let _a = {
+            super let b = {
+                super let c = {
+                    super let d = identity(&DropMe(&mut x));
+                    d
+                };
+                c
+            };
+            #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+            b
+            // DropMe is still alive here...
+        };
+        // ... but not here.
+        assert_eq!(x, true);
+    }
+}
+
+// Check for potential weird interactions with `let else`.
+fn super_let_and_let_else() {
+    let mut x = false;
+    {
+        let a = 'a: {
+            let Some(_) = Some(123) else { unreachable!() };
+            super let b = DropMe(&mut x);
+            let None = Some(123) else { break 'a &b };
+            unreachable!()
+        };
+        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+        // DropMe is still alive here...
+        drop(a);
+    }
+    // ... but not here.
+    assert_eq!(x, true);
+}
+
+// Check if `super let .. else ..;` works.
+fn super_let_else() {
+    let mut x = false;
+    {
+        let a = {
+            let dropme = Some(DropMe(&mut x));
+            super let Some(x) = dropme else { unreachable!() };
+            &x
+        };
+        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
+        // DropMe is still alive here...
+        drop(a);
+    }
+    // ... but not here.
+    assert_eq!(x, true);
+}
+
+fn main() {
+    extended_variable();
+    extended_temporary();
+    non_extended();
+    non_extended_in_expression();
+    match_arm();
+    if_body();
+    else_body();
+    without_initializer();
+    assignment();
+    mutable();
+    multiple_levels();
+    multiple_levels_but_no_extension();
+    super_let_and_let_else();
+    super_let_else();
+}
diff --git a/tests/ui/cast/cast-enum-to-primitive-error.fixed b/tests/ui/cast/cast-enum-to-primitive-error.fixed
new file mode 100644
index 00000000000..7e22116b955
--- /dev/null
+++ b/tests/ui/cast/cast-enum-to-primitive-error.fixed
@@ -0,0 +1,20 @@
+//@ run-rustfix
+#![allow(dead_code, unused_variables)]
+enum NonNullary {
+    Nullary,
+    Other(isize),
+}
+
+impl From<NonNullary> for isize {
+    fn from(val: NonNullary) -> isize {
+        match val {
+            NonNullary::Nullary => 0,
+            NonNullary::Other(i) => i,
+        }
+    }
+}
+
+fn main() {
+    let v = NonNullary::Nullary;
+    let val = isize::from(v); //~ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
+}
diff --git a/tests/ui/cast/cast-enum-to-primitive-error.rs b/tests/ui/cast/cast-enum-to-primitive-error.rs
new file mode 100644
index 00000000000..1a64cf1933d
--- /dev/null
+++ b/tests/ui/cast/cast-enum-to-primitive-error.rs
@@ -0,0 +1,20 @@
+//@ run-rustfix
+#![allow(dead_code, unused_variables)]
+enum NonNullary {
+    Nullary,
+    Other(isize),
+}
+
+impl From<NonNullary> for isize {
+    fn from(val: NonNullary) -> isize {
+        match val {
+            NonNullary::Nullary => 0,
+            NonNullary::Other(i) => i,
+        }
+    }
+}
+
+fn main() {
+    let v = NonNullary::Nullary;
+    let val = v as isize; //~ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
+}
diff --git a/tests/ui/cast/cast-enum-to-primitive-error.stderr b/tests/ui/cast/cast-enum-to-primitive-error.stderr
new file mode 100644
index 00000000000..8ec1c5f11ec
--- /dev/null
+++ b/tests/ui/cast/cast-enum-to-primitive-error.stderr
@@ -0,0 +1,16 @@
+error[E0605]: non-primitive cast: `NonNullary` as `isize`
+  --> $DIR/tag-variant-cast-non-nullary.rs:19:15
+   |
+LL |     let val = v as isize;
+   |               ^^^^^^^^^^ an `as` expression can be used to convert enum types to numeric types only if the enum type is unit-only or field-less
+   |
+   = note: see https://doc.rust-lang.org/reference/items/enumerations.html#casting for more information
+help: consider using the `From` trait instead
+   |
+LL -     let val = v as isize;
+LL +     let val = isize::from(v);
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/cast/coercion-as-explicit-cast.rs b/tests/ui/cast/coercion-as-explicit-cast.rs
new file mode 100644
index 00000000000..701e2f6166f
--- /dev/null
+++ b/tests/ui/cast/coercion-as-explicit-cast.rs
@@ -0,0 +1,62 @@
+//@ run-pass
+// Test that all coercions can actually be done using casts (modulo the lints).
+
+#![allow(trivial_casts, trivial_numeric_casts)]
+
+trait Foo {
+    fn foo(&self) {} //~ WARN method `foo` is never used
+}
+
+pub struct Bar;
+
+impl Foo for Bar {}
+
+pub fn main() {
+    // Numeric
+    let _ = 42_i32 as i32;
+    let _ = 42_u8 as u8;
+
+    // & to * pointers
+    let x: &u32 = &42;
+    let _ = x as *const u32;
+
+    let x: &mut u32 = &mut 42;
+    let _ = x as *mut u32;
+
+    // unsize array
+    let x: &[u32; 3] = &[42, 43, 44];
+    let _ = x as &[u32];
+    let _ = x as *const [u32];
+
+    let x: &mut [u32; 3] = &mut [42, 43, 44];
+    let _ = x as &mut [u32];
+    let _ = x as *mut [u32];
+
+    let x: Box<[u32; 3]> = Box::new([42, 43, 44]);
+    let _ = x as Box<[u32]>;
+
+    // unsize trait
+    let x: &Bar = &Bar;
+    let _ = x as &dyn Foo;
+    let _ = x as *const dyn Foo;
+
+    let x: &mut Bar = &mut Bar;
+    let _ = x as &mut dyn Foo;
+    let _ = x as *mut dyn Foo;
+
+    let x: Box<Bar> = Box::new(Bar);
+    let _ = x as Box<dyn Foo>;
+
+    // functions
+    fn baz(_x: i32) {}
+    let _ = &baz as &dyn Fn(i32);
+    let x = |_x: i32| {};
+    let _ = &x as &dyn Fn(i32);
+}
+
+// subtyping
+pub fn test_subtyping<'a, 'b: 'a>(a: &'a Bar, b: &'b Bar) {
+    let _ = a as &'a Bar;
+    let _ = b as &'a Bar;
+    let _ = b as &'b Bar;
+}
diff --git a/tests/ui/cast/coercion-as-explicit-cast.stderr b/tests/ui/cast/coercion-as-explicit-cast.stderr
new file mode 100644
index 00000000000..74698b61ab4
--- /dev/null
+++ b/tests/ui/cast/coercion-as-explicit-cast.stderr
@@ -0,0 +1,12 @@
+warning: method `foo` is never used
+  --> $DIR/trivial_casts-rpass.rs:7:8
+   |
+LL | trait Foo {
+   |       --- method in this trait
+LL |     fn foo(&self) {}
+   |        ^^^
+   |
+   = note: `#[warn(dead_code)]` on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/generics/generic-enum-errors.rs b/tests/ui/generics/generic-enum-errors.rs
new file mode 100644
index 00000000000..75a54927443
--- /dev/null
+++ b/tests/ui/generics/generic-enum-errors.rs
@@ -0,0 +1,6 @@
+enum Quux<T> { Bar }
+//~^ ERROR: parameter `T` is never used
+
+fn foo(c: Quux) { assert!((false)); } //~ ERROR missing generics for enum `Quux`
+
+fn main() { panic!(); }
diff --git a/tests/ui/generics/generic-enum-errors.stderr b/tests/ui/generics/generic-enum-errors.stderr
new file mode 100644
index 00000000000..def13832e1a
--- /dev/null
+++ b/tests/ui/generics/generic-enum-errors.stderr
@@ -0,0 +1,29 @@
+error[E0392]: type parameter `T` is never used
+  --> $DIR/tag-type-args.rs:1:11
+   |
+LL | enum Quux<T> { Bar }
+   |           ^ 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[E0107]: missing generics for enum `Quux`
+  --> $DIR/tag-type-args.rs:4:11
+   |
+LL | fn foo(c: Quux) { assert!((false)); }
+   |           ^^^^ expected 1 generic argument
+   |
+note: enum defined here, with 1 generic parameter: `T`
+  --> $DIR/tag-type-args.rs:1:6
+   |
+LL | enum Quux<T> { Bar }
+   |      ^^^^ -
+help: add missing generic argument
+   |
+LL | fn foo(c: Quux<T>) { assert!((false)); }
+   |               +++
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0107, E0392.
+For more information about an error, try `rustc --explain E0107`.
diff --git a/tests/ui/modules/module-super-access.rs b/tests/ui/modules/module-super-access.rs
new file mode 100644
index 00000000000..69aff4f98e0
--- /dev/null
+++ b/tests/ui/modules/module-super-access.rs
@@ -0,0 +1,15 @@
+//@ run-pass
+
+#![allow(dead_code)]
+
+pub mod a {
+    pub fn f() {}
+    pub mod b {
+        fn g() {
+            super::f();
+        }
+    }
+}
+
+pub fn main() {
+}
diff --git a/tests/ui/modules/super-at-crate-root.rs b/tests/ui/modules/super-at-crate-root.rs
new file mode 100644
index 00000000000..e4d587bc9ef
--- /dev/null
+++ b/tests/ui/modules/super-at-crate-root.rs
@@ -0,0 +1,4 @@
+use super::f; //~ ERROR there are too many leading `super` keywords
+
+fn main() {
+}
diff --git a/tests/ui/modules/super-at-crate-root.stderr b/tests/ui/modules/super-at-crate-root.stderr
new file mode 100644
index 00000000000..4dce81fbef4
--- /dev/null
+++ b/tests/ui/modules/super-at-crate-root.stderr
@@ -0,0 +1,9 @@
+error[E0433]: failed to resolve: there are too many leading `super` keywords
+  --> $DIR/super-at-top-level.rs:1:5
+   |
+LL | use super::f;
+   |     ^^^^^ there are too many leading `super` keywords
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/parser/syntactic-trailing-commas.rs b/tests/ui/parser/syntactic-trailing-commas.rs
new file mode 100644
index 00000000000..53b76fb6037
--- /dev/null
+++ b/tests/ui/parser/syntactic-trailing-commas.rs
@@ -0,0 +1,34 @@
+//@ run-pass
+
+fn f<T,>(_: T,) {}
+
+struct Foo<T,>(#[allow(dead_code)] T);
+
+struct Bar;
+
+impl Bar {
+    fn f(_: isize,) {}
+    fn g(self, _: isize,) {}
+    fn h(self,) {}
+}
+
+enum Baz {
+    Qux(#[allow(dead_code)] isize,),
+}
+
+#[allow(unused,)]
+pub fn main() {
+    f::<isize,>(0,);
+    let (_, _,) = (1, 1,);
+    let [_, _,] = [1, 1,];
+    let [_, _, .., _,] = [1, 1, 1, 1,];
+    let [_, _, _, ..,] = [1, 1, 1, 1,];
+
+    let x: Foo<isize,> = Foo::<isize,>(1);
+
+    Bar::f(0,);
+    Bar.g(0,);
+    Bar.h();
+
+    let x = Baz::Qux(1,);
+}
diff --git a/tests/ui/ptr_ops/ptr-swap-basic.rs b/tests/ui/ptr_ops/ptr-swap-basic.rs
new file mode 100644
index 00000000000..b104c3ade42
--- /dev/null
+++ b/tests/ui/ptr_ops/ptr-swap-basic.rs
@@ -0,0 +1,10 @@
+//@ run-pass
+
+use std::mem::swap;
+
+pub fn main() {
+    let mut x = 3; let mut y = 7;
+    swap(&mut x, &mut y);
+    assert_eq!(x, 7);
+    assert_eq!(y, 3);
+}
diff --git a/tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs b/tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs
new file mode 100644
index 00000000000..38d5a8109d1
--- /dev/null
+++ b/tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs
@@ -0,0 +1,43 @@
+//@ run-pass
+
+#![allow(dead_code)]
+// Issue #5041 - avoid overlapping memcpy when src and dest of a swap are the same
+
+
+use std::ptr;
+
+pub fn main() {
+    let mut test = TestDescAndFn {
+        desc: TestDesc {
+            name: TestName::DynTestName("test".to_string()),
+            should_fail: false
+        },
+        testfn: TestFn::DynTestFn(22),
+    };
+    do_swap(&mut test);
+}
+
+fn do_swap(test: &mut TestDescAndFn) {
+    unsafe {
+        ptr::swap(test, test);
+    }
+}
+
+pub enum TestName {
+    DynTestName(String)
+}
+
+pub enum TestFn {
+    DynTestFn(isize),
+    DynBenchFn(isize),
+}
+
+pub struct TestDesc {
+    name: TestName,
+    should_fail: bool
+}
+
+pub struct TestDescAndFn {
+    desc: TestDesc,
+    testfn: TestFn,
+}
diff --git a/tests/ui/recursion/recursion-tail-call-no-arg-leak.rs b/tests/ui/recursion/recursion-tail-call-no-arg-leak.rs
new file mode 100644
index 00000000000..234924307c3
--- /dev/null
+++ b/tests/ui/recursion/recursion-tail-call-no-arg-leak.rs
@@ -0,0 +1,8 @@
+//@ run-pass
+// use of tail calls causes arg slot leaks, issue #160.
+
+fn inner(dummy: String, b: bool) { if b { return inner(dummy, false); } }
+
+pub fn main() {
+    inner("hi".to_string(), true);
+}
diff --git a/tests/ui/recursion/recursion-tail-cps.rs b/tests/ui/recursion/recursion-tail-cps.rs
new file mode 100644
index 00000000000..fe99dadf795
--- /dev/null
+++ b/tests/ui/recursion/recursion-tail-cps.rs
@@ -0,0 +1,17 @@
+//@ run-pass
+
+fn checktrue(rs: bool) -> bool { assert!(rs); return true; }
+
+pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }
+
+fn evenk(n: isize, k: fn(bool) -> bool) -> bool {
+    println!("evenk");
+    println!("{}", n);
+    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
+}
+
+fn oddk(n: isize, k: fn(bool) -> bool) -> bool {
+    println!("oddk");
+    println!("{}", n);
+    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
+}
diff --git a/tests/ui/super-at-top-level.rs b/tests/ui/super-at-top-level.rs
deleted file mode 100644
index e4d587bc9ef..00000000000
--- a/tests/ui/super-at-top-level.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-use super::f; //~ ERROR there are too many leading `super` keywords
-
-fn main() {
-}
diff --git a/tests/ui/super-at-top-level.stderr b/tests/ui/super-at-top-level.stderr
deleted file mode 100644
index 4dce81fbef4..00000000000
--- a/tests/ui/super-at-top-level.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0433]: failed to resolve: there are too many leading `super` keywords
-  --> $DIR/super-at-top-level.rs:1:5
-   |
-LL | use super::f;
-   |     ^^^^^ there are too many leading `super` keywords
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/super-let.borrowck.stderr b/tests/ui/super-let.borrowck.stderr
deleted file mode 100644
index 01ef29d8758..00000000000
--- a/tests/ui/super-let.borrowck.stderr
+++ /dev/null
@@ -1,174 +0,0 @@
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:30:28
-   |
-LL |             super let b = DropMe(&mut x);
-   |                                  ------ `x` is borrowed here
-...
-LL |         #[cfg(borrowck)] { x = true; }
-   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
-...
-LL |     }
-   |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
-
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:46:28
-   |
-LL |             super let b = &DropMe(&mut x);
-   |                            --------------
-   |                            |      |
-   |                            |      `x` is borrowed here
-   |                            a temporary with access to the borrow is created here ...
-...
-LL |         #[cfg(borrowck)] { x = true; }
-   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
-...
-LL |     }
-   |     - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
-
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:64:32
-   |
-LL |             super let b = identity(&DropMe(&mut x));
-   |                                     --------------
-   |                                     |      |
-   |                                     |      `x` is borrowed here
-   |                                     a temporary with access to the borrow is created here ...
-LL |             #[cfg(borrowck)] { x = true; }
-   |                                ^^^^^^^^ `x` is assigned to here but it was already borrowed
-...
-LL |         };
-   |          - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
-
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:87:36
-   |
-LL |                 super let b = identity(&DropMe(&mut x));
-   |                                         --------------
-   |                                         |      |
-   |                                         |      `x` is borrowed here
-   |                                         a temporary with access to the borrow is created here ...
-...
-LL |                 #[cfg(borrowck)] { x = true; }
-   |                                    ^^^^^^^^ `x` is assigned to here but it was already borrowed
-...
-LL |         ));
-   |           - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
-
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:107:28
-   |
-LL |                 super let b = DropMe(&mut x);
-   |                                      ------ `x` is borrowed here
-...
-LL |         #[cfg(borrowck)] { x = true; }
-   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
-...
-LL |     }
-   |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
-
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:125:28
-   |
-LL |             super let b = DropMe(&mut x);
-   |                                  ------ `x` is borrowed here
-...
-LL |         #[cfg(borrowck)] { x = true; }
-   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
-...
-LL |     }
-   |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
-
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:143:28
-   |
-LL |             super let b = DropMe(&mut x);
-   |                                  ------ `x` is borrowed here
-...
-LL |         #[cfg(borrowck)] { x = true; }
-   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
-...
-LL |     }
-   |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
-
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:159:28
-   |
-LL |             b = DropMe(&mut x);
-   |                        ------ `x` is borrowed here
-...
-LL |         #[cfg(borrowck)] { x = true; }
-   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
-LL |         drop(a);
-   |              - borrow later used here
-
-error[E0716]: temporary value dropped while borrowed
-  --> $DIR/super-let.rs:172:33
-   |
-LL |         #[cfg(borrowck)] { a = &String::from("asdf"); };
-   |                                 ^^^^^^^^^^^^^^^^^^^^- temporary value is freed at the end of this statement
-   |                                 |
-   |                                 creates a temporary value which is freed while still in use
-...
-LL |         let _ = a;
-   |                 - borrow later used here
-   |
-   = note: consider using a `let` binding to create a longer lived value
-
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:206:28
-   |
-LL |                     super let d = &DropMe(&mut x);
-   |                                    --------------
-   |                                    |      |
-   |                                    |      `x` is borrowed here
-   |                                    a temporary with access to the borrow is created here ...
-...
-LL |         #[cfg(borrowck)] { x = true; }
-   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
-...
-LL |     }
-   |     - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
-
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:227:32
-   |
-LL |                     super let d = identity(&DropMe(&mut x));
-   |                                             --------------
-   |                                             |      |
-   |                                             |      `x` is borrowed here
-   |                                             a temporary with access to the borrow is created here ...
-...
-LL |             #[cfg(borrowck)] { x = true; }
-   |                                ^^^^^^^^ `x` is assigned to here but it was already borrowed
-...
-LL |         };
-   |          - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
-
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:246:28
-   |
-LL |             super let b = DropMe(&mut x);
-   |                                  ------ `x` is borrowed here
-...
-LL |         #[cfg(borrowck)] { x = true; }
-   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
-...
-LL |     }
-   |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
-
-error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:263:28
-   |
-LL |             let dropme = Some(DropMe(&mut x));
-   |                                      ------ `x` is borrowed here
-...
-LL |         #[cfg(borrowck)] { x = true; }
-   |                            ^^^^^^^^ `x` is assigned to here but it was already borrowed
-...
-LL |     }
-   |     - borrow might be used here, when `x` is dropped and runs the `Drop` code for type `DropMe`
-
-error: aborting due to 13 previous errors
-
-Some errors have detailed explanations: E0506, E0716.
-For more information about an error, try `rustc --explain E0506`.
diff --git a/tests/ui/super-let.rs b/tests/ui/super-let.rs
deleted file mode 100644
index 380470f792f..00000000000
--- a/tests/ui/super-let.rs
+++ /dev/null
@@ -1,286 +0,0 @@
-// Check in two ways:
-// - borrowck: Check with borrow checking errors when things are alive and dead.
-// - runtime: Check with a mutable bool if things are dropped on time.
-//
-//@ revisions: runtime borrowck
-//@ [runtime] run-pass
-//@ [borrowck] check-fail
-
-#![allow(dropping_references)]
-#![feature(super_let, stmt_expr_attributes)]
-
-use std::convert::identity;
-
-struct DropMe<'a>(&'a mut bool);
-
-impl Drop for DropMe<'_> {
-    fn drop(&mut self) {
-        *self.0 = true;
-    }
-}
-
-// Check that a super let variable lives as long as the result of a block.
-fn extended_variable() {
-    let mut x = false;
-    {
-        let a = {
-            super let b = DropMe(&mut x);
-            &b
-        };
-        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-        drop(a);
-        // DropMe is still alive here...
-    }
-    // ... but not here.
-    assert_eq!(x, true) // ok
-}
-
-// Check that the init expression of a super let is subject to (temporary) lifetime extension.
-fn extended_temporary() {
-    let mut x = false;
-    {
-        let a = {
-            super let b = &DropMe(&mut x);
-            b
-        };
-        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-        drop(a);
-        // DropMe is still alive here...
-    }
-    // ... but not here.
-    assert_eq!(x, true); // ok
-}
-
-// Check that even non-extended temporaries live until the end of the block,
-// but (unlike extended temporaries) not beyond that.
-//
-// This is necessary for things like select(pin!(identity(&temp()))) to work.
-fn non_extended() {
-    let mut x = false;
-    {
-        let _a = {
-            // Use identity() to supress temporary lifetime extension.
-            super let b = identity(&DropMe(&mut x));
-            #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-            b
-            // DropMe is still alive here...
-        };
-        // ... but not here.
-        assert_eq!(x, true); // ok
-    }
-}
-
-// Check that even non-extended temporaries live until the end of the block,
-// but (unlike extended temporaries) not beyond that.
-//
-// This is necessary for things like select(pin!(identity(&temp()))) to work.
-fn non_extended_in_expression() {
-    let mut x = false;
-    {
-        identity((
-            {
-                // Use identity() to supress temporary lifetime extension.
-                super let b = identity(&DropMe(&mut x));
-                b
-            },
-            {
-                #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-                // DropMe is still alive here...
-            }
-        ));
-        // ... but not here.
-        assert_eq!(x, true); // ok
-    }
-}
-
-// Check `super let` in a match arm.
-fn match_arm() {
-    let mut x = false;
-    {
-        let a = match Some(123) {
-            Some(_) => {
-                super let b = DropMe(&mut x);
-                &b
-            }
-            None => unreachable!(),
-        };
-        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-        drop(a);
-        // DropMe is still alive here...
-    }
-    // ... but not here.
-    assert_eq!(x, true); // ok
-}
-
-// Check `super let` in an if body.
-fn if_body() {
-    let mut x = false;
-    {
-        let a = if true {
-            super let b = DropMe(&mut x);
-            &b
-        } else {
-            unreachable!()
-        };
-        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-        drop(a);
-        // DropMe is still alive here...
-    }
-    // ... but not here.
-    assert_eq!(x, true); // ok
-}
-
-// Check `super let` in an else body.
-fn else_body() {
-    let mut x = false;
-    {
-        let a = if false {
-            unreachable!()
-        } else {
-            super let b = DropMe(&mut x);
-            &b
-        };
-        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-        drop(a);
-        // DropMe is still alive here...
-    }
-    // ... but not here.
-    assert_eq!(x, true); // ok
-}
-
-fn without_initializer() {
-    let mut x = false;
-    {
-        let a = {
-            super let b;
-            b = DropMe(&mut x);
-            b
-        };
-        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-        drop(a);
-        // DropMe is still alive here...
-    }
-    // ... but not here.
-    assert_eq!(x, true);
-}
-
-// Assignment isn't special, even when assigning to a `super let` variable.
-fn assignment() {
-    let mut x = false;
-    {
-        super let a;
-        #[cfg(borrowck)] { a = &String::from("asdf"); }; //[borrowck]~ ERROR dropped while borrowed
-        #[cfg(runtime)] { a = drop(&DropMe(&mut x)); } // Temporary dropped at the `;` as usual.
-        assert_eq!(x, true);
-        let _ = a;
-    }
-}
-
-// `super let mut` should work just fine.
-fn mutable() {
-    let mut x = false;
-    {
-        let a = {
-            super let mut b = None;
-            &mut b
-        };
-        *a = Some(DropMe(&mut x));
-    }
-    assert_eq!(x, true);
-}
-
-// Temporary lifetime extension should recurse through `super let`s.
-fn multiple_levels() {
-    let mut x = false;
-    {
-        let a = {
-            super let b = {
-                super let c = {
-                    super let d = &DropMe(&mut x);
-                    d
-                };
-                c
-            };
-            b
-        };
-        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-        drop(a);
-        // DropMe is still alive here...
-    }
-    // ... but not here.
-    assert_eq!(x, true);
-}
-
-// Non-extended temporaries should be dropped at the
-// end of the first parent statement that isn't `super`.
-fn multiple_levels_but_no_extension() {
-    let mut x = false;
-    {
-        let _a = {
-            super let b = {
-                super let c = {
-                    super let d = identity(&DropMe(&mut x));
-                    d
-                };
-                c
-            };
-            #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-            b
-            // DropMe is still alive here...
-        };
-        // ... but not here.
-        assert_eq!(x, true);
-    }
-}
-
-// Check for potential weird interactions with `let else`.
-fn super_let_and_let_else() {
-    let mut x = false;
-    {
-        let a = 'a: {
-            let Some(_) = Some(123) else { unreachable!() };
-            super let b = DropMe(&mut x);
-            let None = Some(123) else { break 'a &b };
-            unreachable!()
-        };
-        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-        // DropMe is still alive here...
-        drop(a);
-    }
-    // ... but not here.
-    assert_eq!(x, true);
-}
-
-// Check if `super let .. else ..;` works.
-fn super_let_else() {
-    let mut x = false;
-    {
-        let a = {
-            let dropme = Some(DropMe(&mut x));
-            super let Some(x) = dropme else { unreachable!() };
-            &x
-        };
-        #[cfg(borrowck)] { x = true; } //[borrowck]~ ERROR borrowed
-        // DropMe is still alive here...
-        drop(a);
-    }
-    // ... but not here.
-    assert_eq!(x, true);
-}
-
-fn main() {
-    extended_variable();
-    extended_temporary();
-    non_extended();
-    non_extended_in_expression();
-    match_arm();
-    if_body();
-    else_body();
-    without_initializer();
-    assignment();
-    mutable();
-    multiple_levels();
-    multiple_levels_but_no_extension();
-    super_let_and_let_else();
-    super_let_else();
-}
diff --git a/tests/ui/super.rs b/tests/ui/super.rs
deleted file mode 100644
index 69aff4f98e0..00000000000
--- a/tests/ui/super.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ run-pass
-
-#![allow(dead_code)]
-
-pub mod a {
-    pub fn f() {}
-    pub mod b {
-        fn g() {
-            super::f();
-        }
-    }
-}
-
-pub fn main() {
-}
diff --git a/tests/ui/svh-add-nothing.rs b/tests/ui/svh-add-nothing.rs
deleted file mode 100644
index 6e4b9fa7f4c..00000000000
--- a/tests/ui/svh-add-nothing.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ run-pass
-// note that these aux-build directives must be in this order
-//@ aux-build:svh-a-base.rs
-//@ aux-build:svh-b.rs
-//@ aux-build:svh-a-base.rs
-
-
-extern crate a;
-extern crate b;
-
-fn main() {
-    b::foo()
-}
diff --git a/tests/ui/svh/svh-no-api-change-no-recompile.rs b/tests/ui/svh/svh-no-api-change-no-recompile.rs
new file mode 100644
index 00000000000..6e4b9fa7f4c
--- /dev/null
+++ b/tests/ui/svh/svh-no-api-change-no-recompile.rs
@@ -0,0 +1,13 @@
+//@ run-pass
+// note that these aux-build directives must be in this order
+//@ aux-build:svh-a-base.rs
+//@ aux-build:svh-b.rs
+//@ aux-build:svh-a-base.rs
+
+
+extern crate a;
+extern crate b;
+
+fn main() {
+    b::foo()
+}
diff --git a/tests/ui/swap-1.rs b/tests/ui/swap-1.rs
deleted file mode 100644
index b104c3ade42..00000000000
--- a/tests/ui/swap-1.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ run-pass
-
-use std::mem::swap;
-
-pub fn main() {
-    let mut x = 3; let mut y = 7;
-    swap(&mut x, &mut y);
-    assert_eq!(x, 7);
-    assert_eq!(y, 3);
-}
diff --git a/tests/ui/swap-overlapping.rs b/tests/ui/swap-overlapping.rs
deleted file mode 100644
index 38d5a8109d1..00000000000
--- a/tests/ui/swap-overlapping.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//@ run-pass
-
-#![allow(dead_code)]
-// Issue #5041 - avoid overlapping memcpy when src and dest of a swap are the same
-
-
-use std::ptr;
-
-pub fn main() {
-    let mut test = TestDescAndFn {
-        desc: TestDesc {
-            name: TestName::DynTestName("test".to_string()),
-            should_fail: false
-        },
-        testfn: TestFn::DynTestFn(22),
-    };
-    do_swap(&mut test);
-}
-
-fn do_swap(test: &mut TestDescAndFn) {
-    unsafe {
-        ptr::swap(test, test);
-    }
-}
-
-pub enum TestName {
-    DynTestName(String)
-}
-
-pub enum TestFn {
-    DynTestFn(isize),
-    DynBenchFn(isize),
-}
-
-pub struct TestDesc {
-    name: TestName,
-    should_fail: bool
-}
-
-pub struct TestDescAndFn {
-    desc: TestDesc,
-    testfn: TestFn,
-}
diff --git a/tests/ui/switched-expectations.rs b/tests/ui/switched-expectations.rs
deleted file mode 100644
index c5bc84de54c..00000000000
--- a/tests/ui/switched-expectations.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-fn main() {
-    let var = 10i32;
-    let ref string: String = var; //~ ERROR mismatched types [E0308]
-}
diff --git a/tests/ui/switched-expectations.stderr b/tests/ui/switched-expectations.stderr
deleted file mode 100644
index e235c2da1f7..00000000000
--- a/tests/ui/switched-expectations.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/switched-expectations.rs:3:30
-   |
-LL |     let ref string: String = var;
-   |                              ^^^ expected `String`, found `i32`
-   |
-help: try using a conversion method
-   |
-LL |     let ref string: String = var.to_string();
-   |                                 ++++++++++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/tag-type-args.rs b/tests/ui/tag-type-args.rs
deleted file mode 100644
index 75a54927443..00000000000
--- a/tests/ui/tag-type-args.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-enum Quux<T> { Bar }
-//~^ ERROR: parameter `T` is never used
-
-fn foo(c: Quux) { assert!((false)); } //~ ERROR missing generics for enum `Quux`
-
-fn main() { panic!(); }
diff --git a/tests/ui/tag-type-args.stderr b/tests/ui/tag-type-args.stderr
deleted file mode 100644
index def13832e1a..00000000000
--- a/tests/ui/tag-type-args.stderr
+++ /dev/null
@@ -1,29 +0,0 @@
-error[E0392]: type parameter `T` is never used
-  --> $DIR/tag-type-args.rs:1:11
-   |
-LL | enum Quux<T> { Bar }
-   |           ^ 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[E0107]: missing generics for enum `Quux`
-  --> $DIR/tag-type-args.rs:4:11
-   |
-LL | fn foo(c: Quux) { assert!((false)); }
-   |           ^^^^ expected 1 generic argument
-   |
-note: enum defined here, with 1 generic parameter: `T`
-  --> $DIR/tag-type-args.rs:1:6
-   |
-LL | enum Quux<T> { Bar }
-   |      ^^^^ -
-help: add missing generic argument
-   |
-LL | fn foo(c: Quux<T>) { assert!((false)); }
-   |               +++
-
-error: aborting due to 2 previous errors
-
-Some errors have detailed explanations: E0107, E0392.
-For more information about an error, try `rustc --explain E0107`.
diff --git a/tests/ui/tag-variant-cast-non-nullary.fixed b/tests/ui/tag-variant-cast-non-nullary.fixed
deleted file mode 100644
index 7e22116b955..00000000000
--- a/tests/ui/tag-variant-cast-non-nullary.fixed
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ run-rustfix
-#![allow(dead_code, unused_variables)]
-enum NonNullary {
-    Nullary,
-    Other(isize),
-}
-
-impl From<NonNullary> for isize {
-    fn from(val: NonNullary) -> isize {
-        match val {
-            NonNullary::Nullary => 0,
-            NonNullary::Other(i) => i,
-        }
-    }
-}
-
-fn main() {
-    let v = NonNullary::Nullary;
-    let val = isize::from(v); //~ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
-}
diff --git a/tests/ui/tag-variant-cast-non-nullary.rs b/tests/ui/tag-variant-cast-non-nullary.rs
deleted file mode 100644
index 1a64cf1933d..00000000000
--- a/tests/ui/tag-variant-cast-non-nullary.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ run-rustfix
-#![allow(dead_code, unused_variables)]
-enum NonNullary {
-    Nullary,
-    Other(isize),
-}
-
-impl From<NonNullary> for isize {
-    fn from(val: NonNullary) -> isize {
-        match val {
-            NonNullary::Nullary => 0,
-            NonNullary::Other(i) => i,
-        }
-    }
-}
-
-fn main() {
-    let v = NonNullary::Nullary;
-    let val = v as isize; //~ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
-}
diff --git a/tests/ui/tag-variant-cast-non-nullary.stderr b/tests/ui/tag-variant-cast-non-nullary.stderr
deleted file mode 100644
index 8ec1c5f11ec..00000000000
--- a/tests/ui/tag-variant-cast-non-nullary.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error[E0605]: non-primitive cast: `NonNullary` as `isize`
-  --> $DIR/tag-variant-cast-non-nullary.rs:19:15
-   |
-LL |     let val = v as isize;
-   |               ^^^^^^^^^^ an `as` expression can be used to convert enum types to numeric types only if the enum type is unit-only or field-less
-   |
-   = note: see https://doc.rust-lang.org/reference/items/enumerations.html#casting for more information
-help: consider using the `From` trait instead
-   |
-LL -     let val = v as isize;
-LL +     let val = isize::from(v);
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0605`.
diff --git a/tests/ui/tail-call-arg-leak.rs b/tests/ui/tail-call-arg-leak.rs
deleted file mode 100644
index 234924307c3..00000000000
--- a/tests/ui/tail-call-arg-leak.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ run-pass
-// use of tail calls causes arg slot leaks, issue #160.
-
-fn inner(dummy: String, b: bool) { if b { return inner(dummy, false); } }
-
-pub fn main() {
-    inner("hi".to_string(), true);
-}
diff --git a/tests/ui/tail-cps.rs b/tests/ui/tail-cps.rs
deleted file mode 100644
index fe99dadf795..00000000000
--- a/tests/ui/tail-cps.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ run-pass
-
-fn checktrue(rs: bool) -> bool { assert!(rs); return true; }
-
-pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }
-
-fn evenk(n: isize, k: fn(bool) -> bool) -> bool {
-    println!("evenk");
-    println!("{}", n);
-    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
-}
-
-fn oddk(n: isize, k: fn(bool) -> bool) -> bool {
-    println!("oddk");
-    println!("{}", n);
-    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
-}
diff --git a/tests/ui/tail-typeck.rs b/tests/ui/tail-typeck.rs
deleted file mode 100644
index 1deb43c9496..00000000000
--- a/tests/ui/tail-typeck.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn f() -> isize { return g(); } //~ ERROR mismatched types
-
-fn g() -> usize { return 0; }
-
-fn main() { let y = f(); }
diff --git a/tests/ui/tail-typeck.stderr b/tests/ui/tail-typeck.stderr
deleted file mode 100644
index 3cfbfa0fb56..00000000000
--- a/tests/ui/tail-typeck.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/tail-typeck.rs:1:26
-   |
-LL | fn f() -> isize { return g(); }
-   |           -----          ^^^ expected `isize`, found `usize`
-   |           |
-   |           expected `isize` because of return type
-   |
-help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
-   |
-LL | fn f() -> isize { return g().try_into().unwrap(); }
-   |                             ++++++++++++++++++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/trailing-comma.rs b/tests/ui/trailing-comma.rs
deleted file mode 100644
index 53b76fb6037..00000000000
--- a/tests/ui/trailing-comma.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//@ run-pass
-
-fn f<T,>(_: T,) {}
-
-struct Foo<T,>(#[allow(dead_code)] T);
-
-struct Bar;
-
-impl Bar {
-    fn f(_: isize,) {}
-    fn g(self, _: isize,) {}
-    fn h(self,) {}
-}
-
-enum Baz {
-    Qux(#[allow(dead_code)] isize,),
-}
-
-#[allow(unused,)]
-pub fn main() {
-    f::<isize,>(0,);
-    let (_, _,) = (1, 1,);
-    let [_, _,] = [1, 1,];
-    let [_, _, .., _,] = [1, 1, 1, 1,];
-    let [_, _, _, ..,] = [1, 1, 1, 1,];
-
-    let x: Foo<isize,> = Foo::<isize,>(1);
-
-    Bar::f(0,);
-    Bar.g(0,);
-    Bar.h();
-
-    let x = Baz::Qux(1,);
-}
diff --git a/tests/ui/trait-method-number-parameters.rs b/tests/ui/trait-method-number-parameters.rs
deleted file mode 100644
index 719005d6643..00000000000
--- a/tests/ui/trait-method-number-parameters.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-trait Foo {
-    fn foo(&mut self, x: i32, y: i32) -> i32;
-}
-
-impl Foo for i32 {
-    fn foo(
-        &mut self, //~ ERROR
-        x: i32,
-    ) {
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/trait-method-number-parameters.stderr b/tests/ui/trait-method-number-parameters.stderr
deleted file mode 100644
index cf9b4f2ae79..00000000000
--- a/tests/ui/trait-method-number-parameters.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error[E0050]: method `foo` has 2 parameters but the declaration in trait `Foo::foo` has 3
-  --> $DIR/trait-method-number-parameters.rs:7:9
-   |
-LL |       fn foo(&mut self, x: i32, y: i32) -> i32;
-   |              ------------------------- trait requires 3 parameters
-...
-LL | /         &mut self,
-LL | |         x: i32,
-   | |______________^ expected 3 parameters, found 2
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0050`.
diff --git a/tests/ui/traits/trait-method-signature-mismatch.rs b/tests/ui/traits/trait-method-signature-mismatch.rs
new file mode 100644
index 00000000000..719005d6643
--- /dev/null
+++ b/tests/ui/traits/trait-method-signature-mismatch.rs
@@ -0,0 +1,13 @@
+trait Foo {
+    fn foo(&mut self, x: i32, y: i32) -> i32;
+}
+
+impl Foo for i32 {
+    fn foo(
+        &mut self, //~ ERROR
+        x: i32,
+    ) {
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/traits/trait-method-signature-mismatch.stderr b/tests/ui/traits/trait-method-signature-mismatch.stderr
new file mode 100644
index 00000000000..cf9b4f2ae79
--- /dev/null
+++ b/tests/ui/traits/trait-method-signature-mismatch.stderr
@@ -0,0 +1,13 @@
+error[E0050]: method `foo` has 2 parameters but the declaration in trait `Foo::foo` has 3
+  --> $DIR/trait-method-number-parameters.rs:7:9
+   |
+LL |       fn foo(&mut self, x: i32, y: i32) -> i32;
+   |              ------------------------- trait requires 3 parameters
+...
+LL | /         &mut self,
+LL | |         x: i32,
+   | |______________^ expected 3 parameters, found 2
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0050`.
diff --git a/tests/ui/traits/tryfrominterror-result-comparison.rs b/tests/ui/traits/tryfrominterror-result-comparison.rs
new file mode 100644
index 00000000000..66a78b3f842
--- /dev/null
+++ b/tests/ui/traits/tryfrominterror-result-comparison.rs
@@ -0,0 +1,12 @@
+//@ run-pass
+
+#![allow(unused_must_use)]
+
+use std::convert::TryFrom;
+use std::num::TryFromIntError;
+
+fn main() {
+    let x: u32 = 125;
+    let y: Result<u8, TryFromIntError> = u8::try_from(x);
+    y == Ok(125);
+}
diff --git a/tests/ui/transmute-equal-assoc-types.rs b/tests/ui/transmute-equal-assoc-types.rs
deleted file mode 100644
index 526f4ebbffa..00000000000
--- a/tests/ui/transmute-equal-assoc-types.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ check-pass
-
-trait Foo {
-    type Bar;
-}
-
-unsafe fn noop<F: Foo>(foo: F::Bar) -> F::Bar {
-    ::std::mem::transmute(foo)
-}
-
-fn main() {}
diff --git a/tests/ui/transmute-non-immediate-to-immediate.rs b/tests/ui/transmute-non-immediate-to-immediate.rs
deleted file mode 100644
index d99bbcc600f..00000000000
--- a/tests/ui/transmute-non-immediate-to-immediate.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ run-pass
-// Issue #7988
-// Transmuting non-immediate type to immediate type
-
-
-pub fn main() {
-    unsafe {
-        ::std::mem::transmute::<[isize; 1],isize>([1])
-    };
-}
diff --git a/tests/ui/transmute/transmute-array-to-scalar.rs b/tests/ui/transmute/transmute-array-to-scalar.rs
new file mode 100644
index 00000000000..d99bbcc600f
--- /dev/null
+++ b/tests/ui/transmute/transmute-array-to-scalar.rs
@@ -0,0 +1,10 @@
+//@ run-pass
+// Issue #7988
+// Transmuting non-immediate type to immediate type
+
+
+pub fn main() {
+    unsafe {
+        ::std::mem::transmute::<[isize; 1],isize>([1])
+    };
+}
diff --git a/tests/ui/transmute/transmute-same-associated-type.rs b/tests/ui/transmute/transmute-same-associated-type.rs
new file mode 100644
index 00000000000..526f4ebbffa
--- /dev/null
+++ b/tests/ui/transmute/transmute-same-associated-type.rs
@@ -0,0 +1,11 @@
+//@ check-pass
+
+trait Foo {
+    type Bar;
+}
+
+unsafe fn noop<F: Foo>(foo: F::Bar) -> F::Bar {
+    ::std::mem::transmute(foo)
+}
+
+fn main() {}
diff --git a/tests/ui/trivial_casts-rpass.rs b/tests/ui/trivial_casts-rpass.rs
deleted file mode 100644
index 701e2f6166f..00000000000
--- a/tests/ui/trivial_casts-rpass.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-//@ run-pass
-// Test that all coercions can actually be done using casts (modulo the lints).
-
-#![allow(trivial_casts, trivial_numeric_casts)]
-
-trait Foo {
-    fn foo(&self) {} //~ WARN method `foo` is never used
-}
-
-pub struct Bar;
-
-impl Foo for Bar {}
-
-pub fn main() {
-    // Numeric
-    let _ = 42_i32 as i32;
-    let _ = 42_u8 as u8;
-
-    // & to * pointers
-    let x: &u32 = &42;
-    let _ = x as *const u32;
-
-    let x: &mut u32 = &mut 42;
-    let _ = x as *mut u32;
-
-    // unsize array
-    let x: &[u32; 3] = &[42, 43, 44];
-    let _ = x as &[u32];
-    let _ = x as *const [u32];
-
-    let x: &mut [u32; 3] = &mut [42, 43, 44];
-    let _ = x as &mut [u32];
-    let _ = x as *mut [u32];
-
-    let x: Box<[u32; 3]> = Box::new([42, 43, 44]);
-    let _ = x as Box<[u32]>;
-
-    // unsize trait
-    let x: &Bar = &Bar;
-    let _ = x as &dyn Foo;
-    let _ = x as *const dyn Foo;
-
-    let x: &mut Bar = &mut Bar;
-    let _ = x as &mut dyn Foo;
-    let _ = x as *mut dyn Foo;
-
-    let x: Box<Bar> = Box::new(Bar);
-    let _ = x as Box<dyn Foo>;
-
-    // functions
-    fn baz(_x: i32) {}
-    let _ = &baz as &dyn Fn(i32);
-    let x = |_x: i32| {};
-    let _ = &x as &dyn Fn(i32);
-}
-
-// subtyping
-pub fn test_subtyping<'a, 'b: 'a>(a: &'a Bar, b: &'b Bar) {
-    let _ = a as &'a Bar;
-    let _ = b as &'a Bar;
-    let _ = b as &'b Bar;
-}
diff --git a/tests/ui/trivial_casts-rpass.stderr b/tests/ui/trivial_casts-rpass.stderr
deleted file mode 100644
index 74698b61ab4..00000000000
--- a/tests/ui/trivial_casts-rpass.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-warning: method `foo` is never used
-  --> $DIR/trivial_casts-rpass.rs:7:8
-   |
-LL | trait Foo {
-   |       --- method in this trait
-LL |     fn foo(&self) {}
-   |        ^^^
-   |
-   = note: `#[warn(dead_code)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/try-from-int-error-partial-eq.rs b/tests/ui/try-from-int-error-partial-eq.rs
deleted file mode 100644
index 66a78b3f842..00000000000
--- a/tests/ui/try-from-int-error-partial-eq.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ run-pass
-
-#![allow(unused_must_use)]
-
-use std::convert::TryFrom;
-use std::num::TryFromIntError;
-
-fn main() {
-    let x: u32 = 125;
-    let y: Result<u8, TryFromIntError> = u8::try_from(x);
-    y == Ok(125);
-}
diff --git a/tests/ui/typeck/mismatched-types-ref-binding.rs b/tests/ui/typeck/mismatched-types-ref-binding.rs
new file mode 100644
index 00000000000..c5bc84de54c
--- /dev/null
+++ b/tests/ui/typeck/mismatched-types-ref-binding.rs
@@ -0,0 +1,4 @@
+fn main() {
+    let var = 10i32;
+    let ref string: String = var; //~ ERROR mismatched types [E0308]
+}
diff --git a/tests/ui/typeck/mismatched-types-ref-binding.stderr b/tests/ui/typeck/mismatched-types-ref-binding.stderr
new file mode 100644
index 00000000000..e235c2da1f7
--- /dev/null
+++ b/tests/ui/typeck/mismatched-types-ref-binding.stderr
@@ -0,0 +1,14 @@
+error[E0308]: mismatched types
+  --> $DIR/switched-expectations.rs:3:30
+   |
+LL |     let ref string: String = var;
+   |                              ^^^ expected `String`, found `i32`
+   |
+help: try using a conversion method
+   |
+LL |     let ref string: String = var.to_string();
+   |                                 ++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/typeck/tail-return-type-mismatch.rs b/tests/ui/typeck/tail-return-type-mismatch.rs
new file mode 100644
index 00000000000..1deb43c9496
--- /dev/null
+++ b/tests/ui/typeck/tail-return-type-mismatch.rs
@@ -0,0 +1,5 @@
+fn f() -> isize { return g(); } //~ ERROR mismatched types
+
+fn g() -> usize { return 0; }
+
+fn main() { let y = f(); }
diff --git a/tests/ui/typeck/tail-return-type-mismatch.stderr b/tests/ui/typeck/tail-return-type-mismatch.stderr
new file mode 100644
index 00000000000..3cfbfa0fb56
--- /dev/null
+++ b/tests/ui/typeck/tail-return-type-mismatch.stderr
@@ -0,0 +1,16 @@
+error[E0308]: mismatched types
+  --> $DIR/tail-typeck.rs:1:26
+   |
+LL | fn f() -> isize { return g(); }
+   |           -----          ^^^ expected `isize`, found `usize`
+   |           |
+   |           expected `isize` because of return type
+   |
+help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
+   |
+LL | fn f() -> isize { return g().try_into().unwrap(); }
+   |                             ++++++++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
-- 
cgit 1.4.1-3-g733a5


From 98934707eb7824cd48ee3889d4570c1406c39ba4 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Tue, 1 Jul 2025 20:20:14 +0500
Subject: cleaned up some tests

Additionally, remove unused `tests/ui/auxiliary/svh-*` crates that are duplicates of `tests/ui/svh/auxiliary/svh-*`.
---
 tests/ui/auxiliary/svh-a-base.rs                   | 25 ----------------------
 tests/ui/auxiliary/svh-b.rs                        | 13 -----------
 tests/ui/cast/cast-enum-to-primitive-error.fixed   |  9 +++++++-
 tests/ui/cast/cast-enum-to-primitive-error.rs      |  9 +++++++-
 tests/ui/cast/cast-enum-to-primitive-error.stderr  |  2 +-
 tests/ui/cast/coercion-as-explicit-cast.rs         |  4 +++-
 tests/ui/cast/coercion-as-explicit-cast.stderr     |  2 +-
 tests/ui/generics/generic-enum-errors.rs           | 17 +++++++++++----
 tests/ui/generics/generic-enum-errors.stderr       | 14 ++++++------
 tests/ui/modules/module-super-access.rs            |  7 +++---
 tests/ui/modules/super-at-crate-root.rs            |  6 ++++--
 tests/ui/modules/super-at-crate-root.stderr        |  2 +-
 tests/ui/parser/syntactic-trailing-commas.rs       |  8 +++++++
 tests/ui/ptr_ops/ptr-swap-basic.rs                 |  6 +++++-
 tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs   | 16 +++++++-------
 .../recursion/recursion-tail-call-no-arg-leak.rs   | 11 ++++++++--
 tests/ui/recursion/recursion-tail-cps.rs           | 25 ++++++++++++++++++----
 tests/ui/svh/svh-no-api-change-no-recompile.rs     | 11 ++++++++--
 tests/ui/traits/trait-method-signature-mismatch.rs |  7 +++++-
 .../traits/trait-method-signature-mismatch.stderr  |  2 +-
 .../ui/traits/tryfrominterror-result-comparison.rs |  9 +++++++-
 tests/ui/transmute/transmute-array-to-scalar.rs    | 14 +++++++-----
 .../ui/transmute/transmute-same-associated-type.rs |  2 ++
 tests/ui/typeck/mismatched-types-ref-binding.rs    |  4 ++++
 .../ui/typeck/mismatched-types-ref-binding.stderr  |  2 +-
 tests/ui/typeck/tail-return-type-mismatch.rs       | 15 ++++++++++---
 tests/ui/typeck/tail-return-type-mismatch.stderr   | 14 ++++++------
 27 files changed, 160 insertions(+), 96 deletions(-)
 delete mode 100644 tests/ui/auxiliary/svh-a-base.rs
 delete mode 100644 tests/ui/auxiliary/svh-b.rs

diff --git a/tests/ui/auxiliary/svh-a-base.rs b/tests/ui/auxiliary/svh-a-base.rs
deleted file mode 100644
index 36b41fc818f..00000000000
--- a/tests/ui/auxiliary/svh-a-base.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//! The `svh-a-*.rs` files are all deviations from the base file
-//! svh-a-base.rs with some difference (usually in `fn foo`) that
-//! should not affect the strict version hash (SVH) computation
-//! (#14132).
-
-#![crate_name = "a"]
-
-macro_rules! three {
-    () => { 3 }
-}
-
-pub trait U {}
-pub trait V {}
-impl U for () {}
-impl V for () {}
-
-static A_CONSTANT : isize = 2;
-
-pub fn foo<T:U>(_: isize) -> isize {
-    3
-}
-
-pub fn an_unused_name() -> isize {
-    4
-}
diff --git a/tests/ui/auxiliary/svh-b.rs b/tests/ui/auxiliary/svh-b.rs
deleted file mode 100644
index 57029f70888..00000000000
--- a/tests/ui/auxiliary/svh-b.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//! This is a client of the `a` crate defined in `svn-a-base.rs`. The
-//! rpass and cfail tests (such as `run-pass/svh-add-comment.rs`) use
-//! it by swapping in a different object code library crate built from
-//! some variant of `svn-a-base.rs`, and then we are checking if the
-//! compiler properly ignores or accepts the change, based on whether
-//! the change could affect the downstream crate content or not
-//! (#14132).
-
-#![crate_name = "b"]
-
-extern crate a;
-
-pub fn foo() { assert_eq!(a::foo::<()>(0), 3); }
diff --git a/tests/ui/cast/cast-enum-to-primitive-error.fixed b/tests/ui/cast/cast-enum-to-primitive-error.fixed
index 7e22116b955..4d447c81ac9 100644
--- a/tests/ui/cast/cast-enum-to-primitive-error.fixed
+++ b/tests/ui/cast/cast-enum-to-primitive-error.fixed
@@ -1,5 +1,10 @@
+//! This test verifies that a direct non-primitive cast from an enum to an integer type
+//! is correctly disallowed, even when a `From` implementation exists for that enum.
+
 //@ run-rustfix
+
 #![allow(dead_code, unused_variables)]
+
 enum NonNullary {
     Nullary,
     Other(isize),
@@ -16,5 +21,7 @@ impl From<NonNullary> for isize {
 
 fn main() {
     let v = NonNullary::Nullary;
-    let val = isize::from(v); //~ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
+    let val = isize::from(v);
+    //~^ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
+    //~| HELP consider using the `From` trait instead
 }
diff --git a/tests/ui/cast/cast-enum-to-primitive-error.rs b/tests/ui/cast/cast-enum-to-primitive-error.rs
index 1a64cf1933d..fdbe63b9bc7 100644
--- a/tests/ui/cast/cast-enum-to-primitive-error.rs
+++ b/tests/ui/cast/cast-enum-to-primitive-error.rs
@@ -1,5 +1,10 @@
+//! This test verifies that a direct non-primitive cast from an enum to an integer type
+//! is correctly disallowed, even when a `From` implementation exists for that enum.
+
 //@ run-rustfix
+
 #![allow(dead_code, unused_variables)]
+
 enum NonNullary {
     Nullary,
     Other(isize),
@@ -16,5 +21,7 @@ impl From<NonNullary> for isize {
 
 fn main() {
     let v = NonNullary::Nullary;
-    let val = v as isize; //~ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
+    let val = v as isize;
+    //~^ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
+    //~| HELP consider using the `From` trait instead
 }
diff --git a/tests/ui/cast/cast-enum-to-primitive-error.stderr b/tests/ui/cast/cast-enum-to-primitive-error.stderr
index 8ec1c5f11ec..692e5c19e06 100644
--- a/tests/ui/cast/cast-enum-to-primitive-error.stderr
+++ b/tests/ui/cast/cast-enum-to-primitive-error.stderr
@@ -1,5 +1,5 @@
 error[E0605]: non-primitive cast: `NonNullary` as `isize`
-  --> $DIR/tag-variant-cast-non-nullary.rs:19:15
+  --> $DIR/cast-enum-to-primitive-error.rs:24:15
    |
 LL |     let val = v as isize;
    |               ^^^^^^^^^^ an `as` expression can be used to convert enum types to numeric types only if the enum type is unit-only or field-less
diff --git a/tests/ui/cast/coercion-as-explicit-cast.rs b/tests/ui/cast/coercion-as-explicit-cast.rs
index 701e2f6166f..b99f5d93478 100644
--- a/tests/ui/cast/coercion-as-explicit-cast.rs
+++ b/tests/ui/cast/coercion-as-explicit-cast.rs
@@ -1,5 +1,7 @@
+//! This test checks that various forms of "trivial" casts and coercions
+//! can be explicitly performed using the `as` keyword without compilation errors.
+
 //@ run-pass
-// Test that all coercions can actually be done using casts (modulo the lints).
 
 #![allow(trivial_casts, trivial_numeric_casts)]
 
diff --git a/tests/ui/cast/coercion-as-explicit-cast.stderr b/tests/ui/cast/coercion-as-explicit-cast.stderr
index 74698b61ab4..d66298c7d44 100644
--- a/tests/ui/cast/coercion-as-explicit-cast.stderr
+++ b/tests/ui/cast/coercion-as-explicit-cast.stderr
@@ -1,5 +1,5 @@
 warning: method `foo` is never used
-  --> $DIR/trivial_casts-rpass.rs:7:8
+  --> $DIR/coercion-as-explicit-cast.rs:9:8
    |
 LL | trait Foo {
    |       --- method in this trait
diff --git a/tests/ui/generics/generic-enum-errors.rs b/tests/ui/generics/generic-enum-errors.rs
index 75a54927443..111f5635168 100644
--- a/tests/ui/generics/generic-enum-errors.rs
+++ b/tests/ui/generics/generic-enum-errors.rs
@@ -1,6 +1,15 @@
-enum Quux<T> { Bar }
-//~^ ERROR: parameter `T` is never used
+//! This test checks that unused generics are rejected by compiler
 
-fn foo(c: Quux) { assert!((false)); } //~ ERROR missing generics for enum `Quux`
+enum Quux<T> {
+    //~^ ERROR: parameter `T` is never used
+    Bar,
+}
 
-fn main() { panic!(); }
+fn foo(c: Quux) {
+    //~^ ERROR missing generics for enum `Quux`
+    assert!((false));
+}
+
+fn main() {
+    panic!();
+}
diff --git a/tests/ui/generics/generic-enum-errors.stderr b/tests/ui/generics/generic-enum-errors.stderr
index def13832e1a..47a8badbd5d 100644
--- a/tests/ui/generics/generic-enum-errors.stderr
+++ b/tests/ui/generics/generic-enum-errors.stderr
@@ -1,26 +1,26 @@
 error[E0392]: type parameter `T` is never used
-  --> $DIR/tag-type-args.rs:1:11
+  --> $DIR/generic-enum-errors.rs:3:11
    |
-LL | enum Quux<T> { Bar }
+LL | enum Quux<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[E0107]: missing generics for enum `Quux`
-  --> $DIR/tag-type-args.rs:4:11
+  --> $DIR/generic-enum-errors.rs:8:11
    |
-LL | fn foo(c: Quux) { assert!((false)); }
+LL | fn foo(c: Quux) {
    |           ^^^^ expected 1 generic argument
    |
 note: enum defined here, with 1 generic parameter: `T`
-  --> $DIR/tag-type-args.rs:1:6
+  --> $DIR/generic-enum-errors.rs:3:6
    |
-LL | enum Quux<T> { Bar }
+LL | enum Quux<T> {
    |      ^^^^ -
 help: add missing generic argument
    |
-LL | fn foo(c: Quux<T>) { assert!((false)); }
+LL | fn foo(c: Quux<T>) {
    |               +++
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/modules/module-super-access.rs b/tests/ui/modules/module-super-access.rs
index 69aff4f98e0..8acba607f6c 100644
--- a/tests/ui/modules/module-super-access.rs
+++ b/tests/ui/modules/module-super-access.rs
@@ -1,3 +1,5 @@
+//! Check path resolution using `super`
+
 //@ run-pass
 
 #![allow(dead_code)]
@@ -6,10 +8,9 @@ pub mod a {
     pub fn f() {}
     pub mod b {
         fn g() {
-            super::f();
+            super::f(); // Accessing `f` from module `a` (parent of `b`)
         }
     }
 }
 
-pub fn main() {
-}
+pub fn main() {}
diff --git a/tests/ui/modules/super-at-crate-root.rs b/tests/ui/modules/super-at-crate-root.rs
index e4d587bc9ef..d605dc0cccb 100644
--- a/tests/ui/modules/super-at-crate-root.rs
+++ b/tests/ui/modules/super-at-crate-root.rs
@@ -1,4 +1,6 @@
+//! Check that `super` keyword used at the crate root (top-level) results in a compilation error
+//! as there is no parent module to resolve.
+
 use super::f; //~ ERROR there are too many leading `super` keywords
 
-fn main() {
-}
+fn main() {}
diff --git a/tests/ui/modules/super-at-crate-root.stderr b/tests/ui/modules/super-at-crate-root.stderr
index 4dce81fbef4..02798708864 100644
--- a/tests/ui/modules/super-at-crate-root.stderr
+++ b/tests/ui/modules/super-at-crate-root.stderr
@@ -1,5 +1,5 @@
 error[E0433]: failed to resolve: there are too many leading `super` keywords
-  --> $DIR/super-at-top-level.rs:1:5
+  --> $DIR/super-at-crate-root.rs:4:5
    |
 LL | use super::f;
    |     ^^^^^ there are too many leading `super` keywords
diff --git a/tests/ui/parser/syntactic-trailing-commas.rs b/tests/ui/parser/syntactic-trailing-commas.rs
index 53b76fb6037..ba688dffb3c 100644
--- a/tests/ui/parser/syntactic-trailing-commas.rs
+++ b/tests/ui/parser/syntactic-trailing-commas.rs
@@ -1,3 +1,11 @@
+//! Checks trailing commas are accepted in various places:
+//! - Generic parameters in function and struct definitions.
+//! - Function and method arguments.
+//! - Tuple and array literal expressions.
+//! - Tuple and array destructuring patterns, including those with `..`.
+//! - Enum variant declarations.
+//! - Attributes.
+
 //@ run-pass
 
 fn f<T,>(_: T,) {}
diff --git a/tests/ui/ptr_ops/ptr-swap-basic.rs b/tests/ui/ptr_ops/ptr-swap-basic.rs
index b104c3ade42..ce230feeb32 100644
--- a/tests/ui/ptr_ops/ptr-swap-basic.rs
+++ b/tests/ui/ptr_ops/ptr-swap-basic.rs
@@ -1,9 +1,13 @@
+//! Check the basic functionality of `std::mem::swap` to ensure it correctly
+//! exchanges the values of two mutable variables.
+
 //@ run-pass
 
 use std::mem::swap;
 
 pub fn main() {
-    let mut x = 3; let mut y = 7;
+    let mut x = 3;
+    let mut y = 7;
     swap(&mut x, &mut y);
     assert_eq!(x, 7);
     assert_eq!(y, 3);
diff --git a/tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs b/tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs
index 38d5a8109d1..8f05e937d59 100644
--- a/tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs
+++ b/tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs
@@ -1,17 +1,17 @@
+//! Check that `std::ptr::swap` behaves correctly when the source and destination
+//! pointers refer to the same memory location, avoiding issues like overlapping `memcpy`.
+//!
+//! Regression test: <https://github.com/rust-lang/rust/issues/5041>
+
 //@ run-pass
 
 #![allow(dead_code)]
-// Issue #5041 - avoid overlapping memcpy when src and dest of a swap are the same
-
 
 use std::ptr;
 
 pub fn main() {
     let mut test = TestDescAndFn {
-        desc: TestDesc {
-            name: TestName::DynTestName("test".to_string()),
-            should_fail: false
-        },
+        desc: TestDesc { name: TestName::DynTestName("test".to_string()), should_fail: false },
         testfn: TestFn::DynTestFn(22),
     };
     do_swap(&mut test);
@@ -24,7 +24,7 @@ fn do_swap(test: &mut TestDescAndFn) {
 }
 
 pub enum TestName {
-    DynTestName(String)
+    DynTestName(String),
 }
 
 pub enum TestFn {
@@ -34,7 +34,7 @@ pub enum TestFn {
 
 pub struct TestDesc {
     name: TestName,
-    should_fail: bool
+    should_fail: bool,
 }
 
 pub struct TestDescAndFn {
diff --git a/tests/ui/recursion/recursion-tail-call-no-arg-leak.rs b/tests/ui/recursion/recursion-tail-call-no-arg-leak.rs
index 234924307c3..fe10b890700 100644
--- a/tests/ui/recursion/recursion-tail-call-no-arg-leak.rs
+++ b/tests/ui/recursion/recursion-tail-call-no-arg-leak.rs
@@ -1,7 +1,14 @@
+//! This test verifies that tail call optimization does not lead to argument slot leaks.
+//!
+//! Regression test for: <https://github.com/rust-lang/rust/issues/160>
+
 //@ run-pass
-// use of tail calls causes arg slot leaks, issue #160.
 
-fn inner(dummy: String, b: bool) { if b { return inner(dummy, false); } }
+fn inner(dummy: String, b: bool) {
+    if b {
+        return inner(dummy, false);
+    }
+}
 
 pub fn main() {
     inner("hi".to_string(), true);
diff --git a/tests/ui/recursion/recursion-tail-cps.rs b/tests/ui/recursion/recursion-tail-cps.rs
index fe99dadf795..9014be0ce98 100644
--- a/tests/ui/recursion/recursion-tail-cps.rs
+++ b/tests/ui/recursion/recursion-tail-cps.rs
@@ -1,17 +1,34 @@
+//! Verify that mutually recursive functions use CPS to avoid overflowing the stack.
+
 //@ run-pass
 
-fn checktrue(rs: bool) -> bool { assert!(rs); return true; }
+fn checktrue(rs: bool) -> bool {
+    assert!(rs);
+    return true;
+}
 
-pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }
+pub fn main() {
+    let k = checktrue;
+    evenk(42, k);
+    oddk(45, k);
+}
 
 fn evenk(n: isize, k: fn(bool) -> bool) -> bool {
     println!("evenk");
     println!("{}", n);
-    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
+    if n == 0 {
+        return k(true);
+    } else {
+        return oddk(n - 1, k);
+    }
 }
 
 fn oddk(n: isize, k: fn(bool) -> bool) -> bool {
     println!("oddk");
     println!("{}", n);
-    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
+    if n == 0 {
+        return k(false);
+    } else {
+        return evenk(n - 1, k);
+    }
 }
diff --git a/tests/ui/svh/svh-no-api-change-no-recompile.rs b/tests/ui/svh/svh-no-api-change-no-recompile.rs
index 6e4b9fa7f4c..d4b8ac77444 100644
--- a/tests/ui/svh/svh-no-api-change-no-recompile.rs
+++ b/tests/ui/svh/svh-no-api-change-no-recompile.rs
@@ -1,10 +1,17 @@
+//! This test verifies that the Signature Version Hash (SVH) system correctly identifies
+//! when changes to an auxiliary crate do not affect its public API.
+//!
+//! Specifically, it checks that adding non-public items to a crate does not alter
+//! its SVH, preventing unnecessary recompilations of dependent crates.
+
 //@ run-pass
-// note that these aux-build directives must be in this order
+
+// Note that these aux-build directives must be in this order
+
 //@ aux-build:svh-a-base.rs
 //@ aux-build:svh-b.rs
 //@ aux-build:svh-a-base.rs
 
-
 extern crate a;
 extern crate b;
 
diff --git a/tests/ui/traits/trait-method-signature-mismatch.rs b/tests/ui/traits/trait-method-signature-mismatch.rs
index 719005d6643..118aff69e4e 100644
--- a/tests/ui/traits/trait-method-signature-mismatch.rs
+++ b/tests/ui/traits/trait-method-signature-mismatch.rs
@@ -1,10 +1,15 @@
+//! This test verifies that implementing a trait method with a signature that does not
+//! exactly match its declaration in the trait results in a compilation error.
+//! Specifically, it checks for errors when the number of parameters or the return type
+//! in the `impl` differs from the trait definition.
+
 trait Foo {
     fn foo(&mut self, x: i32, y: i32) -> i32;
 }
 
 impl Foo for i32 {
     fn foo(
-        &mut self, //~ ERROR
+        &mut self, //~ ERROR method `foo` has 2 parameters but the declaration
         x: i32,
     ) {
     }
diff --git a/tests/ui/traits/trait-method-signature-mismatch.stderr b/tests/ui/traits/trait-method-signature-mismatch.stderr
index cf9b4f2ae79..c7a77aa7aba 100644
--- a/tests/ui/traits/trait-method-signature-mismatch.stderr
+++ b/tests/ui/traits/trait-method-signature-mismatch.stderr
@@ -1,5 +1,5 @@
 error[E0050]: method `foo` has 2 parameters but the declaration in trait `Foo::foo` has 3
-  --> $DIR/trait-method-number-parameters.rs:7:9
+  --> $DIR/trait-method-signature-mismatch.rs:12:9
    |
 LL |       fn foo(&mut self, x: i32, y: i32) -> i32;
    |              ------------------------- trait requires 3 parameters
diff --git a/tests/ui/traits/tryfrominterror-result-comparison.rs b/tests/ui/traits/tryfrominterror-result-comparison.rs
index 66a78b3f842..8a2741e9058 100644
--- a/tests/ui/traits/tryfrominterror-result-comparison.rs
+++ b/tests/ui/traits/tryfrominterror-result-comparison.rs
@@ -1,12 +1,19 @@
+//! This test verifies that `std::num::TryFromIntError` correctly implements `PartialEq`,
+//! allowing `Result<T, TryFromIntError>` values to be compared for equality using `==`.
+//! It specifically checks a successful numeric conversion scenario where the `Result::Ok`
+//! variant is compared, ensuring that the comparison yields the expected boolean result.
+
 //@ run-pass
 
-#![allow(unused_must_use)]
+#![allow(unused_must_use)] // Allow ignoring the result of the comparison for the test's purpose
 
 use std::convert::TryFrom;
 use std::num::TryFromIntError;
 
 fn main() {
     let x: u32 = 125;
+    // Attempt to convert u32 to u8, which should succeed as 125 fits in u8.
     let y: Result<u8, TryFromIntError> = u8::try_from(x);
+    // Verify that the Result can be correctly compared with an Ok value.
     y == Ok(125);
 }
diff --git a/tests/ui/transmute/transmute-array-to-scalar.rs b/tests/ui/transmute/transmute-array-to-scalar.rs
index d99bbcc600f..cd6dbb040c8 100644
--- a/tests/ui/transmute/transmute-array-to-scalar.rs
+++ b/tests/ui/transmute/transmute-array-to-scalar.rs
@@ -1,10 +1,14 @@
-//@ run-pass
-// Issue #7988
-// Transmuting non-immediate type to immediate type
+//! Verify transmuting from a single-element array to a scalar is allowed.
+//!
+//! Regression test: <https://github.com/rust-lang/rust/issues/7988>
 
+//@ run-pass
 
 pub fn main() {
     unsafe {
-        ::std::mem::transmute::<[isize; 1],isize>([1])
-    };
+        // Transmute a single-element array `[1]` (which might be treated as a "non-immediate" type)
+        // to a scalar `isize` (an "immediate" type).
+        // This is safe because `[isize; 1]` and `isize` have the same size and alignment.
+        ::std::mem::transmute::<[isize; 1], isize>([1]);
+    }
 }
diff --git a/tests/ui/transmute/transmute-same-associated-type.rs b/tests/ui/transmute/transmute-same-associated-type.rs
index 526f4ebbffa..8bc452c6df4 100644
--- a/tests/ui/transmute/transmute-same-associated-type.rs
+++ b/tests/ui/transmute/transmute-same-associated-type.rs
@@ -1,3 +1,5 @@
+//! Verify transmuting is allowed when `Src` and `Dst` are the same associated type.
+
 //@ check-pass
 
 trait Foo {
diff --git a/tests/ui/typeck/mismatched-types-ref-binding.rs b/tests/ui/typeck/mismatched-types-ref-binding.rs
index c5bc84de54c..baf9056dfeb 100644
--- a/tests/ui/typeck/mismatched-types-ref-binding.rs
+++ b/tests/ui/typeck/mismatched-types-ref-binding.rs
@@ -1,3 +1,7 @@
+//! Check that a `mismatched types` error (E0308) is correctly reported when attempting to
+//! bind a reference to an `i32` to a reference to a `String`.
+//! Ensure `ref` bindings report a mismatched type error.
+
 fn main() {
     let var = 10i32;
     let ref string: String = var; //~ ERROR mismatched types [E0308]
diff --git a/tests/ui/typeck/mismatched-types-ref-binding.stderr b/tests/ui/typeck/mismatched-types-ref-binding.stderr
index e235c2da1f7..c08e5d2a60b 100644
--- a/tests/ui/typeck/mismatched-types-ref-binding.stderr
+++ b/tests/ui/typeck/mismatched-types-ref-binding.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/switched-expectations.rs:3:30
+  --> $DIR/mismatched-types-ref-binding.rs:7:30
    |
 LL |     let ref string: String = var;
    |                              ^^^ expected `String`, found `i32`
diff --git a/tests/ui/typeck/tail-return-type-mismatch.rs b/tests/ui/typeck/tail-return-type-mismatch.rs
index 1deb43c9496..fa0d205ad82 100644
--- a/tests/ui/typeck/tail-return-type-mismatch.rs
+++ b/tests/ui/typeck/tail-return-type-mismatch.rs
@@ -1,5 +1,14 @@
-fn f() -> isize { return g(); } //~ ERROR mismatched types
+//! Test for type mismatch error when returning `usize` from `isize` function.
 
-fn g() -> usize { return 0; }
+fn f() -> isize {
+    return g();
+    //~^ ERROR mismatched types [E0308]
+}
 
-fn main() { let y = f(); }
+fn g() -> usize {
+    return 0;
+}
+
+fn main() {
+    let y = f();
+}
diff --git a/tests/ui/typeck/tail-return-type-mismatch.stderr b/tests/ui/typeck/tail-return-type-mismatch.stderr
index 3cfbfa0fb56..36da65d0304 100644
--- a/tests/ui/typeck/tail-return-type-mismatch.stderr
+++ b/tests/ui/typeck/tail-return-type-mismatch.stderr
@@ -1,15 +1,15 @@
 error[E0308]: mismatched types
-  --> $DIR/tail-typeck.rs:1:26
+  --> $DIR/tail-return-type-mismatch.rs:4:12
    |
-LL | fn f() -> isize { return g(); }
-   |           -----          ^^^ expected `isize`, found `usize`
-   |           |
-   |           expected `isize` because of return type
+LL | fn f() -> isize {
+   |           ----- expected `isize` because of return type
+LL |     return g();
+   |            ^^^ expected `isize`, found `usize`
    |
 help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
    |
-LL | fn f() -> isize { return g().try_into().unwrap(); }
-   |                             ++++++++++++++++++++
+LL |     return g().try_into().unwrap();
+   |               ++++++++++++++++++++
 
 error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From 736bfa12de73155633261ca6682b9d5e72d32c6d Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 12 Jul 2025 19:31:15 +0000
Subject: Clean up implementation of RPITIT assoc item lowering

---
 .../src/check/compare_impl_item.rs                 |   6 +-
 compiler/rustc_hir_analysis/src/check/wfcheck.rs   |   4 +-
 .../rustc_hir_analysis/src/hir_ty_lowering/mod.rs  |   4 +-
 compiler/rustc_metadata/src/rmeta/mod.rs           |   2 +-
 compiler/rustc_middle/src/query/mod.rs             |   6 +-
 compiler/rustc_middle/src/ty/assoc.rs              |  36 ++--
 compiler/rustc_middle/src/ty/mod.rs                |   3 +-
 compiler/rustc_middle/src/ty/parameterized.rs      |   5 +-
 compiler/rustc_ty_utils/src/assoc.rs               | 190 ++++++++-------------
 9 files changed, 110 insertions(+), 146 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index 379ce69bdea..87db80f2423 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -15,7 +15,6 @@ use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::{
     self, BottomUpFolder, GenericArgs, GenericParamDefKind, Ty, TyCtxt, TypeFoldable, TypeFolder,
     TypeSuperFoldable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode, Upcast,
-    associated_types_for_impl_traits_in_associated_fn,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::{DUMMY_SP, Span};
@@ -758,7 +757,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
     // returning `-> Missing<impl Sized>`, that gets converted to `-> {type error}`,
     // and when walking through the signature we end up never collecting the def id
     // of the `impl Sized`. Insert that here, so we don't ICE later.
-    for assoc_item in associated_types_for_impl_traits_in_associated_fn(tcx, trait_m.def_id) {
+    for assoc_item in tcx.associated_types_for_impl_traits_in_associated_fn(trait_m.def_id) {
         if !remapped_types.contains_key(assoc_item) {
             remapped_types.insert(
                 *assoc_item,
@@ -2449,7 +2448,8 @@ fn param_env_with_gat_bounds<'tcx>(
                     ty::ImplTraitInTraitData::Impl { fn_def_id }
                     | ty::ImplTraitInTraitData::Trait { fn_def_id, .. },
                 ),
-        } => associated_types_for_impl_traits_in_associated_fn(tcx, fn_def_id)
+        } => tcx
+            .associated_types_for_impl_traits_in_associated_fn(fn_def_id)
             .iter()
             .map(|def_id| tcx.associated_item(*def_id))
             .collect(),
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 3d3fdd899d3..607028f4d9a 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -20,7 +20,7 @@ use rustc_middle::ty::trait_def::TraitSpecializationKind;
 use rustc_middle::ty::{
     self, AdtKind, GenericArgKind, GenericArgs, GenericParamDefKind, Ty, TyCtxt, TypeFlags,
     TypeFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode,
-    Upcast, associated_types_for_impl_traits_in_associated_fn,
+    Upcast,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::parse::feature_err;
@@ -327,7 +327,7 @@ pub(crate) fn check_trait_item<'tcx>(
 
     if matches!(tcx.def_kind(def_id), DefKind::AssocFn) {
         for &assoc_ty_def_id in
-            associated_types_for_impl_traits_in_associated_fn(tcx, def_id.to_def_id())
+            tcx.associated_types_for_impl_traits_in_associated_fn(def_id.to_def_id())
         {
             res = res.and(check_associated_item(tcx, assoc_ty_def_id.expect_local()));
         }
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 ae56f0c5160..a5bd7c1a34a 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -40,7 +40,7 @@ use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::ty::print::PrintPolyTraitRefExt as _;
 use rustc_middle::ty::{
     self, Const, GenericArgKind, GenericArgsRef, GenericParamDefKind, Ty, TyCtxt, TypeVisitableExt,
-    TypingMode, Upcast, associated_types_for_impl_traits_in_associated_fn, fold_regions,
+    TypingMode, Upcast, fold_regions,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint::builtin::AMBIGUOUS_ASSOCIATED_ITEMS;
@@ -2602,7 +2602,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         // do a linear search to map this to the synthetic associated type that
         // it will be lowered to.
         let def_id = if let Some(parent_def_id) = in_trait {
-            *associated_types_for_impl_traits_in_associated_fn(tcx, parent_def_id.to_def_id())
+            *tcx.associated_types_for_impl_traits_in_associated_fn(parent_def_id.to_def_id())
                 .iter()
                 .find(|rpitit| match tcx.opt_rpitit_info(**rpitit) {
                     Some(ty::ImplTraitInTraitData::Trait { opaque_def_id, .. }) => {
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
index 213090d7d47..8347626080e 100644
--- a/compiler/rustc_metadata/src/rmeta/mod.rs
+++ b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -481,7 +481,7 @@ define_tables! {
     assumed_wf_types_for_rpitit: Table<DefIndex, LazyArray<(Ty<'static>, Span)>>,
     opaque_ty_origin: Table<DefIndex, LazyValue<hir::OpaqueTyOrigin<DefId>>>,
     anon_const_kind: Table<DefIndex, LazyValue<ty::AnonConstKind>>,
-    associated_types_for_impl_traits_in_trait_or_impl: Table<DefIndex, LazyValue<ty::AssocTyForImplTraitInTraitOrImpl>>,
+    associated_types_for_impl_traits_in_trait_or_impl: Table<DefIndex, LazyValue<DefIdMap<Vec<DefId>>>>,
 }
 
 #[derive(TyEncodable, TyDecodable)]
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 3da6c6f5fe1..842d118449a 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1079,9 +1079,11 @@ rustc_queries! {
         desc { |tcx| "comparing impl items against trait for `{}`", tcx.def_path_str(impl_id) }
     }
 
-    query associated_types_for_impl_traits_in_trait_or_impl(did: DefId) -> &'tcx ty::AssocTyForImplTraitInTraitOrImpl {
+    /// Given the `item_def_id` of a trait or impl, return a mapping from associated fn def id
+    /// to its associated type items that correspond to the RPITITs in its signature.
+    query associated_types_for_impl_traits_in_trait_or_impl(item_def_id: DefId) -> &'tcx DefIdMap<Vec<DefId>> {
         arena_cache
-        desc { |tcx| "creating rpitit for `{}`", tcx.def_path_str(did) }
+        desc { |tcx| "synthesizing RPITIT items for the opaque types for methods in `{}`", tcx.def_path_str(item_def_id) }
         separate_provide_extern
     }
 
diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs
index 99714171c72..9534d45e495 100644
--- a/compiler/rustc_middle/src/ty/assoc.rs
+++ b/compiler/rustc_middle/src/ty/assoc.rs
@@ -1,5 +1,4 @@
 use rustc_attr_data_structures::{AttributeKind, find_attr};
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sorted_map::SortedIndexMultiMap;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Namespace};
@@ -287,22 +286,21 @@ impl AssocItems {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Encodable, Decodable, HashStable)]
-pub struct AssocTyForImplTraitInTraitOrImpl(pub FxIndexMap<DefId, Vec<DefId>>);
-
-/// Given an `fn_def_id` of a trait or a trait implementation:
-///
-/// if `fn_def_id` is a function defined inside a trait, then it synthesizes
-/// a new def id corresponding to a new associated type for each return-
-/// position `impl Trait` in the signature.
-///
-/// if `fn_def_id` is a function inside of an impl, then for each synthetic
-/// associated type generated for the corresponding trait function described
-/// above, synthesize a corresponding associated type in the impl.
-pub fn associated_types_for_impl_traits_in_associated_fn(
-    tcx: TyCtxt<'_>,
-    fn_def_id: DefId,
-) -> &'_ [DefId] {
-    let parent_def_id = tcx.parent(fn_def_id);
-    &tcx.associated_types_for_impl_traits_in_trait_or_impl(parent_def_id).0[&fn_def_id]
+impl<'tcx> TyCtxt<'tcx> {
+    /// Given an `fn_def_id` of a trait or a trait implementation:
+    ///
+    /// if `fn_def_id` is a function defined inside a trait, then it synthesizes
+    /// a new def id corresponding to a new associated type for each return-
+    /// position `impl Trait` in the signature.
+    ///
+    /// if `fn_def_id` is a function inside of an impl, then for each synthetic
+    /// associated type generated for the corresponding trait function described
+    /// above, synthesize a corresponding associated type in the impl.
+    pub fn associated_types_for_impl_traits_in_associated_fn(
+        self,
+        fn_def_id: DefId,
+    ) -> &'tcx [DefId] {
+        let parent_def_id = self.parent(fn_def_id);
+        &self.associated_types_for_impl_traits_in_trait_or_impl(parent_def_id)[&fn_def_id]
+    }
 }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index e1b11e4f54a..0177a95498b 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2194,7 +2194,8 @@ impl<'tcx> TyCtxt<'tcx> {
             return false;
         };
 
-        return !associated_types_for_impl_traits_in_associated_fn(self, trait_item_def_id)
+        return !self
+            .associated_types_for_impl_traits_in_associated_fn(trait_item_def_id)
             .is_empty();
     }
 }
diff --git a/compiler/rustc_middle/src/ty/parameterized.rs b/compiler/rustc_middle/src/ty/parameterized.rs
index 88f6e717af4..3d601fc0533 100644
--- a/compiler/rustc_middle/src/ty/parameterized.rs
+++ b/compiler/rustc_middle/src/ty/parameterized.rs
@@ -23,6 +23,10 @@ impl<A: ParameterizedOverTcx, B: ParameterizedOverTcx> ParameterizedOverTcx for
     type Value<'tcx> = (A::Value<'tcx>, B::Value<'tcx>);
 }
 
+impl<T: ParameterizedOverTcx> ParameterizedOverTcx for Vec<T> {
+    type Value<'tcx> = Vec<T::Value<'tcx>>;
+}
+
 impl<I: Idx + 'static, T: ParameterizedOverTcx> ParameterizedOverTcx for IndexVec<I, T> {
     type Value<'tcx> = IndexVec<I, T::Value<'tcx>>;
 }
@@ -67,7 +71,6 @@ trivially_parameterized_over_tcx! {
     crate::mir::ConstQualifs,
     ty::AsyncDestructor,
     ty::AssocItemContainer,
-    ty::AssocTyForImplTraitInTraitOrImpl,
     ty::Asyncness,
     ty::AnonConstKind,
     ty::DeducedParamAttrs,
diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index 400158496b5..66c44f72f4e 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -1,15 +1,11 @@
-use std::collections::hash_map::Entry;
-
-use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId};
 use rustc_hir::definitions::{DefPathData, DisambiguatorState};
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{self as hir, ItemKind};
 use rustc_middle::query::Providers;
-use rustc_middle::ty::{self, AssocTyForImplTraitInTraitOrImpl, ImplTraitInTraitData, TyCtxt};
+use rustc_middle::ty::{self, ImplTraitInTraitData, TyCtxt};
 use rustc_middle::{bug, span_bug};
-use rustc_span::Symbol;
 
 pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers {
@@ -26,39 +22,28 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &[DefId] {
     let item = tcx.hir_expect_item(def_id);
     match item.kind {
         hir::ItemKind::Trait(.., trait_item_refs) => {
-            // We collect RPITITs for each trait method's return type and create a
-            // corresponding associated item using associated_types_for_impl_traits_in_trait_or_impl
+            // We collect RPITITs for each trait method's return type and create a corresponding
+            // associated item using the associated_types_for_impl_traits_in_trait_or_impl
             // query.
-            tcx.arena.alloc_from_iter(
-                trait_item_refs
-                    .iter()
-                    .map(|trait_item_ref| trait_item_ref.id.owner_id.to_def_id())
-                    .chain(
-                        tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id)
-                            .0
-                            .values()
-                            .flatten()
-                            .copied(),
-                    ),
-            )
+            let rpitit_items = tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id);
+            tcx.arena.alloc_from_iter(trait_item_refs.iter().flat_map(|trait_item_ref| {
+                let item_def_id = trait_item_ref.id.owner_id.to_def_id();
+                [item_def_id]
+                    .into_iter()
+                    .chain(rpitit_items.get(&item_def_id).into_iter().flatten().copied())
+            }))
         }
         hir::ItemKind::Impl(impl_) => {
             // We collect RPITITs for each trait method's return type, on the impl side too and
             // create a corresponding associated item using
             // associated_types_for_impl_traits_in_trait_or_impl query.
-            tcx.arena.alloc_from_iter(
-                impl_
-                    .items
-                    .iter()
-                    .map(|impl_item_ref| impl_item_ref.id.owner_id.to_def_id())
-                    .chain(impl_.of_trait.iter().flat_map(|_| {
-                        tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id)
-                            .0
-                            .values()
-                            .flatten()
-                            .copied()
-                    })),
-            )
+            let rpitit_items = tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id);
+            tcx.arena.alloc_from_iter(impl_.items.iter().flat_map(|impl_item_ref| {
+                let item_def_id = impl_item_ref.id.owner_id.to_def_id();
+                [item_def_id]
+                    .into_iter()
+                    .chain(rpitit_items.get(&item_def_id).into_iter().flatten().copied())
+            }))
         }
         _ => span_bug!(item.span, "associated_item_def_ids: not impl or trait"),
     }
@@ -147,15 +132,15 @@ fn associated_item_from_impl_item_ref(impl_item_ref: &hir::ImplItemRef) -> ty::A
         container: ty::AssocItemContainer::Impl,
     }
 }
-struct RPITVisitor<'tcx> {
+struct RPITVisitor<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     synthetics: Vec<LocalDefId>,
     data: DefPathData,
-    disambiguator: DisambiguatorState,
+    disambiguator: &'a mut DisambiguatorState,
     depth: u32,
 }
 
-impl<'tcx> Visitor<'tcx> for RPITVisitor<'tcx> {
+impl<'tcx> Visitor<'tcx> for RPITVisitor<'_, 'tcx> {
     fn visit_opaque_ty(&mut self, opaque: &'tcx hir::OpaqueTy<'tcx>) -> Self::Result {
         self.depth += 1;
         self.synthetics.push(associated_type_for_impl_trait_in_trait(
@@ -171,90 +156,64 @@ impl<'tcx> Visitor<'tcx> for RPITVisitor<'tcx> {
 fn associated_types_for_impl_traits_in_trait_or_impl<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
-) -> AssocTyForImplTraitInTraitOrImpl {
+) -> DefIdMap<Vec<DefId>> {
     let item = tcx.hir_expect_item(def_id);
+    let disambiguator = &mut DisambiguatorState::new();
     match item.kind {
-        ItemKind::Trait(.., trait_item_refs) => {
-            let mut disambiguator_idx_map = FxHashMap::default();
-            let find_disambiguator_idx =
-                |map: &mut FxHashMap<Symbol, u32>, name| match map.entry(name) {
-                    Entry::Occupied(occ) => *occ.get() + 1,
-                    Entry::Vacant(vac) => {
-                        vac.insert(0);
-                        0
-                    }
+        ItemKind::Trait(.., trait_item_refs) => trait_item_refs
+            .iter()
+            .filter_map(move |item| {
+                if !matches!(item.kind, hir::AssocItemKind::Fn { .. }) {
+                    return None;
+                }
+                let fn_def_id = item.id.owner_id.def_id;
+                let Some(output) = tcx.hir_get_fn_output(fn_def_id) else {
+                    return Some((fn_def_id.to_def_id(), vec![]));
                 };
-            let update_disambiguator_idx = |map: &mut FxHashMap<Symbol, u32>, name, offset: u32| {
-                *map.get_mut(&name).unwrap() += offset
-            };
-
-            ty::AssocTyForImplTraitInTraitOrImpl(
-                trait_item_refs
-                    .iter()
-                    .filter_map(move |item| {
-                        if !matches!(item.kind, hir::AssocItemKind::Fn { .. }) {
-                            return None;
-                        }
-                        let fn_def_id = item.id.owner_id.def_id;
-                        let Some(output) = tcx.hir_get_fn_output(fn_def_id) else {
-                            return Some((fn_def_id.to_def_id(), vec![]));
-                        };
-                        let def_name = tcx.item_name(fn_def_id.to_def_id());
-                        let disambiguator_idx =
-                            find_disambiguator_idx(&mut disambiguator_idx_map, def_name);
-                        let data = DefPathData::AnonAssocTy(def_name);
-                        let mut visitor = RPITVisitor {
-                            tcx,
-                            synthetics: vec![],
-                            data,
-                            depth: 0,
-                            disambiguator: DisambiguatorState::with(
-                                def_id,
-                                data,
-                                disambiguator_idx,
-                            ),
-                        };
-                        visitor.visit_fn_ret_ty(output);
-                        update_disambiguator_idx(
-                            &mut disambiguator_idx_map,
-                            def_name,
-                            visitor.depth,
-                        );
-                        let defs = visitor
-                            .synthetics
-                            .into_iter()
-                            .map(|def_id| def_id.to_def_id())
-                            .collect::<Vec<_>>();
-                        Some((fn_def_id.to_def_id(), defs))
-                    })
-                    .collect::<FxIndexMap<_, _>>(),
-            )
-        }
+                let def_name = tcx.item_name(fn_def_id.to_def_id());
+                let data = DefPathData::AnonAssocTy(def_name);
+                let mut visitor =
+                    RPITVisitor { tcx, synthetics: vec![], data, depth: 0, disambiguator };
+                visitor.visit_fn_ret_ty(output);
+                let defs = visitor
+                    .synthetics
+                    .into_iter()
+                    .map(|def_id| def_id.to_def_id())
+                    .collect::<Vec<_>>();
+                Some((fn_def_id.to_def_id(), defs))
+            })
+            .collect(),
         ItemKind::Impl(impl_) => {
-            let Some(trait_did) = tcx.impl_trait_ref(def_id).map(|t| t.skip_binder().def_id) else {
-                return ty::AssocTyForImplTraitInTraitOrImpl(Default::default());
+            let Some(trait_ref) = impl_.of_trait else {
+                return Default::default();
             };
-            let in_trait_def = tcx.associated_types_for_impl_traits_in_trait_or_impl(trait_did);
-            ty::AssocTyForImplTraitInTraitOrImpl(
-                impl_
-                    .items
-                    .iter()
-                    .filter_map(|item| {
-                        if !matches!(item.kind, hir::AssocItemKind::Fn { .. }) {
-                            return None;
-                        }
-                        let did = item.id.owner_id.def_id.to_def_id();
-                        let Some(trait_item_def_id) = item.trait_item_def_id else {
-                            return Some((did, vec![]));
-                        };
-                        let iter = in_trait_def.0[&trait_item_def_id].iter().map(|&id| {
-                            associated_type_for_impl_trait_in_impl(tcx, id, item.id.owner_id.def_id)
-                                .to_def_id()
-                        });
-                        Some((did, iter.collect()))
-                    })
-                    .collect::<FxIndexMap<_, _>>(),
-            )
+            let Some(trait_def_id) = trait_ref.trait_def_id() else {
+                return Default::default();
+            };
+            let in_trait_def = tcx.associated_types_for_impl_traits_in_trait_or_impl(trait_def_id);
+            impl_
+                .items
+                .iter()
+                .filter_map(|item| {
+                    if !matches!(item.kind, hir::AssocItemKind::Fn { .. }) {
+                        return None;
+                    }
+                    let did = item.id.owner_id.def_id.to_def_id();
+                    let Some(trait_item_def_id) = item.trait_item_def_id else {
+                        return Some((did, vec![]));
+                    };
+                    let iter = in_trait_def[&trait_item_def_id].iter().map(|&id| {
+                        associated_type_for_impl_trait_in_impl(
+                            tcx,
+                            id,
+                            item.id.owner_id.def_id,
+                            disambiguator,
+                        )
+                        .to_def_id()
+                    });
+                    Some((did, iter.collect()))
+                })
+                .collect()
         }
         _ => {
             bug!(
@@ -336,6 +295,7 @@ fn associated_type_for_impl_trait_in_impl(
     tcx: TyCtxt<'_>,
     trait_assoc_def_id: DefId,
     impl_fn_def_id: LocalDefId,
+    disambiguator: &mut DisambiguatorState,
 ) -> LocalDefId {
     let impl_local_def_id = tcx.local_parent(impl_fn_def_id);
 
@@ -358,7 +318,7 @@ fn associated_type_for_impl_trait_in_impl(
         None,
         DefKind::AssocTy,
         Some(data),
-        &mut DisambiguatorState::with(impl_local_def_id, data, disambiguated_data.disambiguator),
+        disambiguator,
     );
 
     let local_def_id = impl_assoc_ty.def_id();
-- 
cgit 1.4.1-3-g733a5


From 7a1593c597ba733260db2d17ddad8fd11db7ad29 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Sat, 12 Jul 2025 22:30:19 +0200
Subject: Add CI workflow for automatically performing subtree sync pulls

This CI workflow will run the https://github.com/rust-lang/josh-sync
tool on Mondays and Thursdays. It will try to do a pull (sync stdarch
changes from rust-lang/rust into this repository). When it runs, three
things can happen:
- There are no rustc changes to be pulled, the bot does nothing.
- There are some new changes to be pulled. In that case, the bot will
either open or update an existing PR titled "Rustc pull update" on this
repository with the changes. After the PR is merged, we should ideally
do the opposite sync (push) manually.
- The pull fails (usually because of a merge conflict), or the bot
determines that a pull PR has been opened for more than a week without
being merged. In that case, it will post a ping to
https://rust-lang.zulipchat.com/#narrow/channel/219381-t-libs/topic/compiler-builtins.20subtree.20sync.20automation/with/528482375.
---
 .../.github/workflows/rustc-pull.yml               | 23 ++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 library/compiler-builtins/.github/workflows/rustc-pull.yml

diff --git a/library/compiler-builtins/.github/workflows/rustc-pull.yml b/library/compiler-builtins/.github/workflows/rustc-pull.yml
new file mode 100644
index 00000000000..ba698492e42
--- /dev/null
+++ b/library/compiler-builtins/.github/workflows/rustc-pull.yml
@@ -0,0 +1,23 @@
+# Perform a subtree sync (pull) using the josh-sync tool once every few days (or on demand).
+name: rustc-pull
+
+on:
+  workflow_dispatch:
+  schedule:
+    # Run at 04:00 UTC every Monday and Thursday
+    - cron: '0 4 * * 1,4'
+
+jobs:
+  pull:
+    if: github.repository == 'rust-lang/compiler-builtins'
+    uses: rust-lang/josh-sync/.github/workflows/rustc-pull.yml@main
+    with:
+      # https://rust-lang.zulipchat.com/#narrow/channel/219381-t-libs/topic/compiler-builtins.20subtree.20sync.20automation/with/528482375
+      zulip-stream-id: 219381
+      zulip-topic: 'compiler-builtins subtree sync automation'
+      zulip-bot-email:  "compiler-builtins-ci-bot@rust-lang.zulipchat.com"
+      pr-base-branch: master
+      branch-name: rustc-pull
+    secrets:
+      zulip-api-token: ${{ secrets.ZULIP_API_TOKEN }}
+      token: ${{ secrets.GITHUB_TOKEN }}
-- 
cgit 1.4.1-3-g733a5


From 93e0074aca1601132a12f7bb143e42824e21e1ce Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Sat, 12 Jul 2025 22:41:45 +0200
Subject: Tell triagebot to reopen bot PRs to run CI on them

---
 library/compiler-builtins/triagebot.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/library/compiler-builtins/triagebot.toml b/library/compiler-builtins/triagebot.toml
index ecc05da0195..715be27fc65 100644
--- a/library/compiler-builtins/triagebot.toml
+++ b/library/compiler-builtins/triagebot.toml
@@ -19,3 +19,6 @@ check-commits = false
 # Enable issue transfers within the org
 # Documentation at: https://forge.rust-lang.org/triagebot/transfer.html
 [transfer]
+
+# Automatically close and reopen PRs made by bots to run CI on them
+[bot-pull-requests]
-- 
cgit 1.4.1-3-g733a5


From 86349e31dde1f9aa5a8a519ff0213c5461f7f4d7 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Sat, 12 Jul 2025 22:53:51 +0200
Subject: Port `#[omit_gdb_pretty_printer_section]` to the new attribute
 parsing infrastructure

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>
---
 compiler/rustc_attr_data_structures/src/attributes.rs     |  3 +++
 .../rustc_attr_data_structures/src/encode_cross_crate.rs  |  1 +
 .../rustc_attr_parsing/src/attributes/codegen_attrs.rs    |  8 ++++++++
 compiler/rustc_attr_parsing/src/context.rs                |  5 +++--
 compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs          |  5 ++---
 compiler/rustc_parse/src/validate_attr.rs                 |  1 +
 compiler/rustc_passes/src/check_attr.rs                   |  4 ++--
 tests/ui/attributes/malformed-attrs.stderr                | 15 +++++++++------
 8 files changed, 29 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index f61efcf2388..2e2d1fd5f30 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -328,6 +328,9 @@ pub enum AttributeKind {
     /// Represents `#[non_exhaustive]`
     NonExhaustive(Span),
 
+    /// Represents `#[omit_gdb_pretty_printer_section]`
+    OmitGdbPrettyPrinterSection,
+
     /// Represents `#[optimize(size|speed)]`
     Optimize(OptimizeAttr, Span),
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index ad587523e03..342e995541f 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -50,6 +50,7 @@ impl AttributeKind {
             NoImplicitPrelude(..) => No,
             NoMangle(..) => No,
             NonExhaustive(..) => Yes,
+            OmitGdbPrettyPrinterSection => No,
             Optimize(..) => No,
             ParenSugar(..) => No,
             PassByValue(..) => Yes,
diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index fdec09edaa1..34d9b048348 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -334,3 +334,11 @@ impl<S: Stage> CombineAttributeParser<S> for TargetFeatureParser {
         features
     }
 }
+
+pub(crate) struct OmitGdbPrettyPrinterSectionParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for OmitGdbPrettyPrinterSectionParser {
+    const PATH: &[Symbol] = &[sym::omit_gdb_pretty_printer_section];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::OmitGdbPrettyPrinterSection;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index cc10bb3098a..ca0834972f7 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -16,8 +16,8 @@ use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
 
 use crate::attributes::allow_unstable::{AllowConstFnUnstableParser, AllowInternalUnstableParser};
 use crate::attributes::codegen_attrs::{
-    ColdParser, ExportNameParser, NakedParser, NoMangleParser, OptimizeParser, TargetFeatureParser,
-    TrackCallerParser, UsedParser,
+    ColdParser, ExportNameParser, NakedParser, NoMangleParser, OmitGdbPrettyPrinterSectionParser,
+    OptimizeParser, TargetFeatureParser, TrackCallerParser, UsedParser,
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::deprecation::DeprecationParser;
@@ -171,6 +171,7 @@ attribute_parsers!(
         Single<WithoutArgs<NoImplicitPreludeParser>>,
         Single<WithoutArgs<NoMangleParser>>,
         Single<WithoutArgs<NonExhaustiveParser>>,
+        Single<WithoutArgs<OmitGdbPrettyPrinterSectionParser>>,
         Single<WithoutArgs<ParenSugarParser>>,
         Single<WithoutArgs<PassByValueParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
index 8f0948b8183..49ee96a41d6 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
@@ -1,13 +1,12 @@
 // .debug_gdb_scripts binary section.
 
-use rustc_ast::attr;
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_codegen_ssa::base::collect_debugger_visualizers_transitive;
 use rustc_codegen_ssa::traits::*;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_middle::bug;
 use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerType;
 use rustc_session::config::{CrateType, DebugInfo};
-use rustc_span::sym;
 
 use crate::builder::Builder;
 use crate::common::CodegenCx;
@@ -87,7 +86,7 @@ pub(crate) fn get_or_insert_gdb_debug_scripts_section_global<'ll>(
 
 pub(crate) fn needs_gdb_debug_scripts_section(cx: &CodegenCx<'_, '_>) -> bool {
     let omit_gdb_pretty_printer_section =
-        attr::contains_name(cx.tcx.hir_krate_attrs(), sym::omit_gdb_pretty_printer_section);
+        find_attr!(cx.tcx.hir_krate_attrs(), AttributeKind::OmitGdbPrettyPrinterSection);
 
     // To ensure the section `__rustc_debug_gdb_scripts_section__` will not create
     // ODR violations at link time, this section will not be emitted for rlibs since
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index bb5c1e0e653..422c0982234 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -305,6 +305,7 @@ pub fn check_builtin_meta_item(
                 | sym::naked
                 | sym::no_mangle
                 | sym::non_exhaustive
+                | sym::omit_gdb_pretty_printer_section
                 | sym::path
                 | sym::ignore
                 | sym::must_use
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2c95fead9e8..912513e88a7 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -240,7 +240,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     AttributeKind::BodyStability { .. }
                     | AttributeKind::ConstStabilityIndirect
                     | AttributeKind::MacroTransparency(_)
-                    | AttributeKind::Dummy,
+                    | AttributeKind::Dummy
+                    | AttributeKind::OmitGdbPrettyPrinterSection,
                 ) => { /* do nothing  */ }
                 Attribute::Parsed(AttributeKind::AsPtr(attr_span)) => {
                     self.check_applied_to_fn_or_method(hir_id, *attr_span, span, target)
@@ -369,7 +370,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             // need to be fixed
                             | sym::cfi_encoding // FIXME(cfi_encoding)
                             | sym::pointee // FIXME(derive_coerce_pointee)
-                            | sym::omit_gdb_pretty_printer_section // FIXME(omit_gdb_pretty_printer_section)
                             | sym::instruction_set // broken on stable!!!
                             | sym::windows_subsystem // broken on stable!!!
                             | sym::patchable_function_entry // FIXME(patchable_function_entry)
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index be529df3a49..b8a71be18fc 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -22,12 +22,6 @@ error[E0463]: can't find crate for `wloop`
 LL | extern crate wloop;
    | ^^^^^^^^^^^^^^^^^^^ can't find crate
 
-error: malformed `omit_gdb_pretty_printer_section` attribute input
-  --> $DIR/malformed-attrs.rs:26:1
-   |
-LL | #![omit_gdb_pretty_printer_section = 1]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#![omit_gdb_pretty_printer_section]`
-
 error: malformed `windows_subsystem` attribute input
   --> $DIR/malformed-attrs.rs:29:1
    |
@@ -283,6 +277,15 @@ LL | #[debugger_visualizer]
    = note: OR
    = note: expected: `gdb_script_file = "..."`
 
+error[E0565]: malformed `omit_gdb_pretty_printer_section` attribute input
+  --> $DIR/malformed-attrs.rs:26:1
+   |
+LL | #![omit_gdb_pretty_printer_section = 1]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---^
+   | |                                  |
+   | |                                  didn't expect any arguments here
+   | help: must be of the form: `#[omit_gdb_pretty_printer_section]`
+
 error[E0539]: malformed `export_name` attribute input
   --> $DIR/malformed-attrs.rs:32:1
    |
-- 
cgit 1.4.1-3-g733a5


From a5ab6829c6f5c484dc68fdc7ab86057ad1941643 Mon Sep 17 00:00:00 2001
From: Jana Dönszelmann <jana@donsz.nl>
Date: Sun, 13 Jul 2025 08:13:38 +0200
Subject: warn on align on fields to avoid breaking changes

---
 compiler/rustc_passes/messages.ftl      |  4 ++++
 compiler/rustc_passes/src/check_attr.rs | 28 ++++++++++++++++++++++------
 compiler/rustc_passes/src/errors.rs     |  8 ++++++++
 3 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 46c21dcf67b..a472c528360 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -17,6 +17,10 @@ passes_align_attr_application =
     `#[align(...)]` should be applied to a function item
     .label = not a function item
 
+passes_align_on_fields =
+    attribute should be applied to a function or method
+    .warn = {-passes_previously_accepted}
+
 passes_align_should_be_repr_align =
     `#[align(...)]` is not supported on {$item} items
     .suggestion = use `#[repr(align(...))]` instead
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 86f10f33589..9aab3195539 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -43,6 +43,7 @@ use rustc_trait_selection::infer::{TyCtxtInferExt, ValuePairs};
 use rustc_trait_selection::traits::ObligationCtxt;
 use tracing::debug;
 
+use crate::errors::AlignOnFields;
 use crate::{errors, fluent_generated as fluent};
 
 #[derive(LintDiagnostic)]
@@ -197,8 +198,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 Attribute::Parsed(AttributeKind::ExportName { span: attr_span, .. }) => {
                     self.check_export_name(hir_id, *attr_span, span, target)
                 }
-                Attribute::Parsed(AttributeKind::Align { align, span: repr_span }) => {
-                    self.check_align(span, target, *align, *repr_span)
+                Attribute::Parsed(AttributeKind::Align { align, span: attr_span }) => {
+                    self.check_align(span, hir_id, target, *align, *attr_span)
                 }
                 Attribute::Parsed(AttributeKind::LinkSection { span: attr_span, .. }) => {
                     self.check_link_section(hir_id, *attr_span, span, target)
@@ -1933,22 +1934,37 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     }
 
     /// Checks if the `#[align]` attributes on `item` are valid.
-    fn check_align(&self, span: Span, target: Target, align: Align, repr_span: Span) {
+    fn check_align(
+        &self,
+        span: Span,
+        hir_id: HirId,
+        target: Target,
+        align: Align,
+        attr_span: Span,
+    ) {
         match target {
             Target::Fn | Target::Method(_) | Target::ForeignFn => {}
+            Target::Field => {
+                self.tcx.emit_node_span_lint(
+                    UNUSED_ATTRIBUTES,
+                    hir_id,
+                    attr_span,
+                    AlignOnFields { span },
+                );
+            }
             Target::Struct | Target::Union | Target::Enum => {
                 self.dcx().emit_err(errors::AlignShouldBeReprAlign {
-                    span: repr_span,
+                    span: attr_span,
                     item: target.name(),
                     align_bytes: align.bytes(),
                 });
             }
             _ => {
-                self.dcx().emit_err(errors::AlignAttrApplication { hint_span: repr_span, span });
+                self.dcx().emit_err(errors::AlignAttrApplication { hint_span: attr_span, span });
             }
         }
 
-        self.check_align_value(align, repr_span);
+        self.check_align_value(align, attr_span);
     }
 
     /// Checks if the `#[repr]` attributes on `item` are valid.
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 4ad615a2abf..093a2b38804 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -604,6 +604,14 @@ pub(crate) struct NoMangle {
     pub span: Span,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(passes_align_on_fields)]
+#[warning]
+pub(crate) struct AlignOnFields {
+    #[label]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(passes_repr_conflicting, code = E0566)]
 pub(crate) struct ReprConflicting {
-- 
cgit 1.4.1-3-g733a5


From afeed5067762d0a087744bda528cc3c95cb81e9a Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 12 Jul 2025 20:10:36 +0800
Subject: Adjust `run_make_support::symbols` helpers

Massage the `symbols` helpers to fill out {match all, match any} x
{substring match, exact match}:

|           | Substring match                        | Exact match                   |
|-----------|----------------------------------------|-------------------------------|
| Match any | `object_contains_any_symbol_substring` | `object_contains_any_symbol`  |
| Match all | `object_contains_all_symbol_substring` | `object_contains_all_symbols` |

As part of this, rename `any_symbol_contains` to
`object_contains_any_symbol_substring` for accuracy.
---
 src/tools/run-make-support/src/symbols.rs          | 184 ++++++++++++++++++---
 .../compiletest-self-test/symbols-helpers/rmake.rs |  92 +++++++++++
 .../symbols-helpers/sample.rs                      |  13 ++
 3 files changed, 264 insertions(+), 25 deletions(-)
 create mode 100644 tests/run-make/compiletest-self-test/symbols-helpers/rmake.rs
 create mode 100644 tests/run-make/compiletest-self-test/symbols-helpers/sample.rs

diff --git a/src/tools/run-make-support/src/symbols.rs b/src/tools/run-make-support/src/symbols.rs
index e4d244e14a4..0e11360bd5a 100644
--- a/src/tools/run-make-support/src/symbols.rs
+++ b/src/tools/run-make-support/src/symbols.rs
@@ -1,6 +1,7 @@
+use std::collections::BTreeSet;
 use std::path::Path;
 
-use object::{self, Object, ObjectSymbol, SymbolIterator};
+use object::{self, Object, ObjectSymbol};
 
 /// Given an [`object::File`], find the exported dynamic symbol names via
 /// [`object::Object::exports`]. This does not distinguish between which section the symbols appear
@@ -14,47 +15,180 @@ pub fn exported_dynamic_symbol_names<'file>(file: &'file object::File<'file>) ->
         .collect()
 }
 
-/// Iterate through the symbols in an object file. See [`object::Object::symbols`].
+/// Check an object file's symbols for any matching **substrings**. That is, if an object file
+/// contains a symbol named `hello_world`, it will be matched against a provided `substrings` of
+/// `["hello", "bar"]`.
+///
+/// Returns `true` if **any** of the symbols found in the object file at `path` contain a
+/// **substring** listed in `substrings`.
 ///
 /// Panics if `path` is not a valid object file readable by the current user or if `path` cannot be
 /// parsed as a recognized object file.
+///
+/// # Platform-specific behavior
+///
+/// On Windows MSVC, the binary (e.g. `main.exe`) does not contain the symbols, but in the separate
+/// PDB file instead. Furthermore, you will need to use [`crate::llvm::llvm_pdbutil`] as `object`
+/// crate does not handle PDB files.
 #[track_caller]
-pub fn with_symbol_iter<P, F, R>(path: P, func: F) -> R
+pub fn object_contains_any_symbol_substring<P, S>(path: P, substrings: &[S]) -> bool
 where
     P: AsRef<Path>,
-    F: FnOnce(&mut SymbolIterator<'_, '_>) -> R,
+    S: AsRef<str>,
 {
     let path = path.as_ref();
     let blob = crate::fs::read(path);
-    let f = object::File::parse(&*blob)
+    let obj = object::File::parse(&*blob)
         .unwrap_or_else(|e| panic!("failed to parse `{}`: {e}", path.display()));
-    let mut iter = f.symbols();
-    func(&mut iter)
+    let substrings = substrings.iter().map(|s| s.as_ref()).collect::<Vec<_>>();
+    for sym in obj.symbols() {
+        for substring in &substrings {
+            if sym.name_bytes().unwrap().windows(substring.len()).any(|x| x == substring.as_bytes())
+            {
+                return true;
+            }
+        }
+    }
+    false
 }
 
-/// Check an object file's symbols for substrings.
+/// Check an object file's symbols for any exact matches against those provided in
+/// `candidate_symbols`.
 ///
-/// Returns `true` if any of the symbols found in the object file at `path` contain a substring
-/// listed in `substrings`.
+/// Returns `true` if **any** of the symbols found in the object file at `path` contain an **exact
+/// match** against those listed in `candidate_symbols`. Take care to account for (1) platform
+/// differences and (2) calling convention and symbol decorations differences.
 ///
 /// Panics if `path` is not a valid object file readable by the current user or if `path` cannot be
 /// parsed as a recognized object file.
+///
+/// # Platform-specific behavior
+///
+/// See [`object_contains_any_symbol_substring`].
 #[track_caller]
-pub fn any_symbol_contains(path: impl AsRef<Path>, substrings: &[&str]) -> bool {
-    with_symbol_iter(path, |syms| {
-        for sym in syms {
-            for substring in substrings {
-                if sym
-                    .name_bytes()
-                    .unwrap()
-                    .windows(substring.len())
-                    .any(|x| x == substring.as_bytes())
-                {
-                    eprintln!("{:?} contains {}", sym, substring);
-                    return true;
-                }
+pub fn object_contains_any_symbol<P, S>(path: P, candidate_symbols: &[S]) -> bool
+where
+    P: AsRef<Path>,
+    S: AsRef<str>,
+{
+    let path = path.as_ref();
+    let blob = crate::fs::read(path);
+    let obj = object::File::parse(&*blob)
+        .unwrap_or_else(|e| panic!("failed to parse `{}`: {e}", path.display()));
+    let candidate_symbols = candidate_symbols.iter().map(|s| s.as_ref()).collect::<Vec<_>>();
+    for sym in obj.symbols() {
+        for candidate_symbol in &candidate_symbols {
+            if sym.name_bytes().unwrap() == candidate_symbol.as_bytes() {
+                return true;
             }
         }
-        false
-    })
+    }
+    false
+}
+
+#[derive(Debug, PartialEq)]
+pub enum ContainsAllSymbolSubstringsOutcome<'a> {
+    Ok,
+    MissingSymbolSubstrings(BTreeSet<&'a str>),
+}
+
+/// Check an object file's symbols for presence of all of provided **substrings**. That is, if an
+/// object file contains symbols `["hello", "goodbye", "world"]`, it will be matched against a list
+/// of `substrings` of `["he", "go"]`. In this case, `he` is a substring of `hello`, and `go` is a
+/// substring of `goodbye`, so each of `substrings` was found.
+///
+/// Returns `true` if **all** `substrings` were present in the names of symbols for the given object
+/// file (as substrings of symbol names).
+///
+/// Panics if `path` is not a valid object file readable by the current user or if `path` cannot be
+/// parsed as a recognized object file.
+///
+/// # Platform-specific behavior
+///
+/// See [`object_contains_any_symbol_substring`].
+#[track_caller]
+pub fn object_contains_all_symbol_substring<'s, P, S>(
+    path: P,
+    substrings: &'s [S],
+) -> ContainsAllSymbolSubstringsOutcome<'s>
+where
+    P: AsRef<Path>,
+    S: AsRef<str>,
+{
+    let path = path.as_ref();
+    let blob = crate::fs::read(path);
+    let obj = object::File::parse(&*blob)
+        .unwrap_or_else(|e| panic!("failed to parse `{}`: {e}", path.display()));
+    let substrings = substrings.iter().map(|s| s.as_ref());
+    let mut unmatched_symbol_substrings = BTreeSet::from_iter(substrings);
+    unmatched_symbol_substrings.retain(|unmatched_symbol_substring| {
+        for sym in obj.symbols() {
+            if sym
+                .name_bytes()
+                .unwrap()
+                .windows(unmatched_symbol_substring.len())
+                .any(|x| x == unmatched_symbol_substring.as_bytes())
+            {
+                return false;
+            }
+        }
+
+        true
+    });
+
+    if unmatched_symbol_substrings.is_empty() {
+        ContainsAllSymbolSubstringsOutcome::Ok
+    } else {
+        ContainsAllSymbolSubstringsOutcome::MissingSymbolSubstrings(unmatched_symbol_substrings)
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum ContainsAllSymbolsOutcome<'a> {
+    Ok,
+    MissingSymbols(BTreeSet<&'a str>),
+}
+
+/// Check an object file contains all symbols provided in `candidate_symbols`.
+///
+/// Returns `true` if **all** of the symbols in `candidate_symbols` are found within the object file
+/// at `path` by **exact match**. Take care to account for (1) platform differences and (2) calling
+/// convention and symbol decorations differences.
+///
+/// Panics if `path` is not a valid object file readable by the current user or if `path` cannot be
+/// parsed as a recognized object file.
+///
+/// # Platform-specific behavior
+///
+/// See [`object_contains_any_symbol_substring`].
+#[track_caller]
+pub fn object_contains_all_symbols<P, S>(
+    path: P,
+    candidate_symbols: &[S],
+) -> ContainsAllSymbolsOutcome<'_>
+where
+    P: AsRef<Path>,
+    S: AsRef<str>,
+{
+    let path = path.as_ref();
+    let blob = crate::fs::read(path);
+    let obj = object::File::parse(&*blob)
+        .unwrap_or_else(|e| panic!("failed to parse `{}`: {e}", path.display()));
+    let candidate_symbols = candidate_symbols.iter().map(|s| s.as_ref());
+    let mut unmatched_symbols = BTreeSet::from_iter(candidate_symbols);
+    unmatched_symbols.retain(|unmatched_symbol| {
+        for sym in obj.symbols() {
+            if sym.name_bytes().unwrap() == unmatched_symbol.as_bytes() {
+                return false;
+            }
+        }
+
+        true
+    });
+
+    if unmatched_symbols.is_empty() {
+        ContainsAllSymbolsOutcome::Ok
+    } else {
+        ContainsAllSymbolsOutcome::MissingSymbols(unmatched_symbols)
+    }
 }
diff --git a/tests/run-make/compiletest-self-test/symbols-helpers/rmake.rs b/tests/run-make/compiletest-self-test/symbols-helpers/rmake.rs
new file mode 100644
index 00000000000..73826214aac
--- /dev/null
+++ b/tests/run-make/compiletest-self-test/symbols-helpers/rmake.rs
@@ -0,0 +1,92 @@
+//! `run_make_support::symbols` helpers self test.
+
+// Only intended as a basic smoke test, does not try to account for platform or calling convention
+// specific symbol decorations.
+//@ only-x86_64-unknown-linux-gnu
+//@ ignore-cross-compile
+
+use std::collections::BTreeSet;
+
+use object::{Object, ObjectSymbol};
+use run_make_support::symbols::{
+    ContainsAllSymbolSubstringsOutcome, ContainsAllSymbolsOutcome,
+    object_contains_all_symbol_substring, object_contains_all_symbols, object_contains_any_symbol,
+    object_contains_any_symbol_substring,
+};
+use run_make_support::{object, rfs, rust_lib_name, rustc};
+
+fn main() {
+    rustc().input("sample.rs").emit("obj").edition("2024").run();
+
+    // `sample.rs` has two `no_mangle` functions, `eszett` and `beta`, in addition to `main`.
+    //
+    // These two symbol names and the test substrings used below are carefully picked to make sure
+    // they do not overlap with `sample` and contain non-hex characters, to avoid accidentally
+    // matching against CGU names like `sample.dad0f15d00c84e70-cgu.0`.
+
+    let obj_filename = "sample.o";
+    let blob = rfs::read(obj_filename);
+    let obj = object::File::parse(&*blob).unwrap();
+    eprintln!("found symbols:");
+    for sym in obj.symbols() {
+        eprintln!("symbol = {}", sym.name().unwrap());
+    }
+
+    // `hello` contains `hel`
+    assert!(object_contains_any_symbol_substring(obj_filename, &["zett"]));
+    assert!(object_contains_any_symbol_substring(obj_filename, &["zett", "does_not_exist"]));
+    assert!(!object_contains_any_symbol_substring(obj_filename, &["does_not_exist"]));
+
+    assert!(object_contains_any_symbol(obj_filename, &["eszett"]));
+    assert!(object_contains_any_symbol(obj_filename, &["eszett", "beta"]));
+    assert!(!object_contains_any_symbol(obj_filename, &["zett"]));
+    assert!(!object_contains_any_symbol(obj_filename, &["does_not_exist"]));
+
+    assert_eq!(
+        object_contains_all_symbol_substring(obj_filename, &["zett"]),
+        ContainsAllSymbolSubstringsOutcome::Ok
+    );
+    assert_eq!(
+        object_contains_all_symbol_substring(obj_filename, &["zett", "bet"]),
+        ContainsAllSymbolSubstringsOutcome::Ok
+    );
+    assert_eq!(
+        object_contains_all_symbol_substring(obj_filename, &["does_not_exist"]),
+        ContainsAllSymbolSubstringsOutcome::MissingSymbolSubstrings(BTreeSet::from([
+            "does_not_exist"
+        ]))
+    );
+    assert_eq!(
+        object_contains_all_symbol_substring(obj_filename, &["zett", "does_not_exist"]),
+        ContainsAllSymbolSubstringsOutcome::MissingSymbolSubstrings(BTreeSet::from([
+            "does_not_exist"
+        ]))
+    );
+    assert_eq!(
+        object_contains_all_symbol_substring(obj_filename, &["zett", "bet", "does_not_exist"]),
+        ContainsAllSymbolSubstringsOutcome::MissingSymbolSubstrings(BTreeSet::from([
+            "does_not_exist"
+        ]))
+    );
+
+    assert_eq!(
+        object_contains_all_symbols(obj_filename, &["eszett"]),
+        ContainsAllSymbolsOutcome::Ok
+    );
+    assert_eq!(
+        object_contains_all_symbols(obj_filename, &["eszett", "beta"]),
+        ContainsAllSymbolsOutcome::Ok
+    );
+    assert_eq!(
+        object_contains_all_symbols(obj_filename, &["zett"]),
+        ContainsAllSymbolsOutcome::MissingSymbols(BTreeSet::from(["zett"]))
+    );
+    assert_eq!(
+        object_contains_all_symbols(obj_filename, &["zett", "beta"]),
+        ContainsAllSymbolsOutcome::MissingSymbols(BTreeSet::from(["zett"]))
+    );
+    assert_eq!(
+        object_contains_all_symbols(obj_filename, &["does_not_exist"]),
+        ContainsAllSymbolsOutcome::MissingSymbols(BTreeSet::from(["does_not_exist"]))
+    );
+}
diff --git a/tests/run-make/compiletest-self-test/symbols-helpers/sample.rs b/tests/run-make/compiletest-self-test/symbols-helpers/sample.rs
new file mode 100644
index 00000000000..3566d299766
--- /dev/null
+++ b/tests/run-make/compiletest-self-test/symbols-helpers/sample.rs
@@ -0,0 +1,13 @@
+#![crate_type = "lib"]
+
+#[unsafe(no_mangle)]
+pub extern "C" fn eszett() -> i8 {
+    42
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn beta() -> u32 {
+    1
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 1d0cbc6816cbc3cf069a9970a09666ed5b4aafdf Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sat, 12 Jul 2025 21:16:46 +0800
Subject: Update `run-make` tests to use adjusted `symbols` helpers

---
 tests/run-make/fmt-write-bloat/rmake.rs | 4 ++--
 tests/run-make/used/rmake.rs            | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/run-make/fmt-write-bloat/rmake.rs b/tests/run-make/fmt-write-bloat/rmake.rs
index 3348651d501..b78e8f49683 100644
--- a/tests/run-make/fmt-write-bloat/rmake.rs
+++ b/tests/run-make/fmt-write-bloat/rmake.rs
@@ -20,7 +20,7 @@
 use run_make_support::artifact_names::bin_name;
 use run_make_support::env::no_debug_assertions;
 use run_make_support::rustc;
-use run_make_support::symbols::any_symbol_contains;
+use run_make_support::symbols::object_contains_any_symbol_substring;
 
 fn main() {
     rustc().input("main.rs").opt().run();
@@ -31,5 +31,5 @@ fn main() {
         // otherwise, add them to the list of symbols to deny.
         panic_syms.extend_from_slice(&["panicking", "panic_fmt", "pad_integral", "Display"]);
     }
-    assert!(!any_symbol_contains(bin_name("main"), &panic_syms));
+    assert!(!object_contains_any_symbol_substring(bin_name("main"), &panic_syms));
 }
diff --git a/tests/run-make/used/rmake.rs b/tests/run-make/used/rmake.rs
index bcdb84132d3..456321e2f56 100644
--- a/tests/run-make/used/rmake.rs
+++ b/tests/run-make/used/rmake.rs
@@ -8,9 +8,9 @@
 // https://rust-lang.github.io/rfcs/2386-used.html
 
 use run_make_support::rustc;
-use run_make_support::symbols::any_symbol_contains;
+use run_make_support::symbols::object_contains_any_symbol_substring;
 
 fn main() {
     rustc().opt_level("3").emit("obj").input("used.rs").run();
-    assert!(any_symbol_contains("used.o", &["FOO"]));
+    assert!(object_contains_any_symbol_substring("used.o", &["FOO"]));
 }
-- 
cgit 1.4.1-3-g733a5


From 0ba392c9bd7ab9f535455cc4c371f7537ec4b56c Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Sun, 13 Jul 2025 15:45:56 +0800
Subject: Update LLVM to 20.1.8

---
 .gitmodules      | 2 +-
 src/llvm-project | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.gitmodules b/.gitmodules
index 3426b1bc8db..439fde6d766 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -25,7 +25,7 @@
 [submodule "src/llvm-project"]
 	path = src/llvm-project
 	url = https://github.com/rust-lang/llvm-project.git
-	branch = rustc/20.1-2025-02-13
+	branch = rustc/20.1-2025-07-13
 	shallow = true
 [submodule "src/doc/embedded-book"]
 	path = src/doc/embedded-book
diff --git a/src/llvm-project b/src/llvm-project
index 99f0e053168..d3c793b0256 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 99f0e0531688a822a753cc585b7408b069cb6822
+Subproject commit d3c793b025645a4565ac59aceb30d2d116ff1a41
-- 
cgit 1.4.1-3-g733a5


From 10866f46172e92a7949dca2e5a52b8c444a5b082 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Sun, 13 Jul 2025 15:51:32 +0800
Subject: Fix typo in `std::vec`

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 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 c8341750f4d..a4741f30fa5 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -3695,7 +3695,7 @@ impl<T, A: Allocator> Vec<T, A> {
     /// This is optimal if:
     ///
     /// * The tail (elements in the vector after `range`) is empty,
-    /// * or `replace_with` yields fewer or equal elements than `range`’s length
+    /// * or `replace_with` yields fewer or equal elements than `range`'s length
     /// * or the lower bound of its `size_hint()` is exact.
     ///
     /// Otherwise, a temporary vector is allocated and the tail is moved twice.
-- 
cgit 1.4.1-3-g733a5


From 1cab09ed9c582e7804bd0f9a6ead61129bb537d5 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Sun, 13 Jul 2025 16:06:53 +0800
Subject: `std::vec`: Upgrade `debug_assert` to UB check in `set_len`

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 library/alloc/src/lib.rs     | 1 +
 library/alloc/src/vec/mod.rs | 8 ++++++--
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 4290bb7a8a9..947df24d44f 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -153,6 +153,7 @@
 #![feature(try_trait_v2)]
 #![feature(try_with_capacity)]
 #![feature(tuple_trait)]
+#![feature(ub_checks)]
 #![feature(unicode_internals)]
 #![feature(unsize)]
 #![feature(unwrap_infallible)]
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index a4741f30fa5..da3d3596d19 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -64,7 +64,7 @@ use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties};
 use core::ops::{self, Index, IndexMut, Range, RangeBounds};
 use core::ptr::{self, NonNull};
 use core::slice::{self, SliceIndex};
-use core::{fmt, intrinsics};
+use core::{fmt, intrinsics, ub_checks};
 
 #[stable(feature = "extract_if", since = "1.87.0")]
 pub use self::extract_if::ExtractIf;
@@ -1950,7 +1950,11 @@ impl<T, A: Allocator> Vec<T, A> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub unsafe fn set_len(&mut self, new_len: usize) {
-        debug_assert!(new_len <= self.capacity());
+        ub_checks::assert_unsafe_precondition!(
+            check_library_ub,
+            "Vec::set_len requires that new_len <= capacity()",
+            (new_len: usize = new_len, capacity: usize = self.capacity()) => new_len <= capacity
+        );
 
         self.len = new_len;
     }
-- 
cgit 1.4.1-3-g733a5


From 090c177003272da7d2d3b04702f35261d3952b72 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Sun, 13 Jul 2025 16:17:43 +0800
Subject: std::vec: Add UB check in `from_raw_parts_in`

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 library/alloc/src/vec/mod.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index da3d3596d19..6d44681fb28 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -1058,6 +1058,11 @@ impl<T, A: Allocator> Vec<T, A> {
     #[inline]
     #[unstable(feature = "allocator_api", issue = "32838")]
     pub unsafe fn from_raw_parts_in(ptr: *mut T, length: usize, capacity: usize, alloc: A) -> Self {
+        ub_checks::assert_unsafe_precondition!(
+            check_library_ub,
+            "Vec::from_raw_parts_in requires that length <= capacity",
+            (length: usize = length, capacity: usize = capacity) => length <= capacity
+        );
         unsafe { Vec { buf: RawVec::from_raw_parts_in(ptr, capacity, alloc), len: length } }
     }
 
-- 
cgit 1.4.1-3-g733a5


From 48caa5f8897263da935ebdc2bbec8a95b5d3d025 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Sun, 13 Jul 2025 16:18:56 +0800
Subject: std::vec: Add UB check in `from_parts_in`

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 library/alloc/src/vec/mod.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 6d44681fb28..50f8cc375bf 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -1179,6 +1179,11 @@ impl<T, A: Allocator> Vec<T, A> {
     #[unstable(feature = "allocator_api", reason = "new API", issue = "32838")]
     // #[unstable(feature = "box_vec_non_null", issue = "130364")]
     pub unsafe fn from_parts_in(ptr: NonNull<T>, length: usize, capacity: usize, alloc: A) -> Self {
+        ub_checks::assert_unsafe_precondition!(
+            check_library_ub,
+            "Vec::from_parts_in requires that length <= capacity",
+            (length: usize = length, capacity: usize = capacity) => length <= capacity
+        );
         unsafe { Vec { buf: RawVec::from_nonnull_in(ptr, capacity, alloc), len: length } }
     }
 
-- 
cgit 1.4.1-3-g733a5


From f58accb8f370a0a9e89548f2d890bd09ede3e613 Mon Sep 17 00:00:00 2001
From: usamoi <usamoi@outlook.com>
Date: Sun, 13 Jul 2025 00:12:33 +0800
Subject: pass --gc-sections if -Zexport-executable-symbols is enabled and
 improve tests

---
 compiler/rustc_codegen_ssa/src/back/link.rs       |  9 +++----
 tests/run-make/export-executable-symbols/rmake.rs | 25 +++++++++----------
 tests/ui/linking/export-executable-symbols.rs     | 29 +++++++++++++++++++----
 3 files changed, 40 insertions(+), 23 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index b46773396fc..ae148287a60 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -2542,12 +2542,9 @@ fn add_order_independent_options(
         // sections to ensure we have all the data for PGO.
         let keep_metadata =
             crate_type == CrateType::Dylib || sess.opts.cg.profile_generate.enabled();
-        if crate_type != CrateType::Executable || !sess.opts.unstable_opts.export_executable_symbols
-        {
-            cmd.gc_sections(keep_metadata);
-        } else {
-            cmd.no_gc_sections();
-        }
+        cmd.gc_sections(keep_metadata);
+    } else {
+        cmd.no_gc_sections();
     }
 
     cmd.set_output_kind(link_output_kind, crate_type, out_filename);
diff --git a/tests/run-make/export-executable-symbols/rmake.rs b/tests/run-make/export-executable-symbols/rmake.rs
index 884c7362822..c602a43f957 100644
--- a/tests/run-make/export-executable-symbols/rmake.rs
+++ b/tests/run-make/export-executable-symbols/rmake.rs
@@ -4,20 +4,21 @@
 // symbol.
 // See https://github.com/rust-lang/rust/pull/85673
 
-//@ only-unix
-// Reason: the export-executable-symbols flag only works on Unix
-// due to hardcoded platform-specific implementation
-// (See #85673)
-//@ ignore-cross-compile
 //@ ignore-wasm
 
-use run_make_support::{bin_name, llvm_readobj, rustc};
+use run_make_support::object::Object;
+use run_make_support::{bin_name, is_darwin, object, rustc};
 
 fn main() {
-    rustc().arg("-Zexport-executable-symbols").input("main.rs").crate_type("bin").run();
-    llvm_readobj()
-        .symbols()
-        .input(bin_name("main"))
-        .run()
-        .assert_stdout_contains("exported_symbol");
+    rustc()
+        .arg("-Ctarget-feature=-crt-static")
+        .arg("-Zexport-executable-symbols")
+        .input("main.rs")
+        .crate_type("bin")
+        .run();
+    let name: &[u8] = if is_darwin() { b"_exported_symbol" } else { b"exported_symbol" };
+    let contents = std::fs::read(bin_name("main")).unwrap();
+    let object = object::File::parse(contents.as_slice()).unwrap();
+    let found = object.exports().unwrap().iter().any(|x| x.name() == name);
+    assert!(found);
 }
diff --git a/tests/ui/linking/export-executable-symbols.rs b/tests/ui/linking/export-executable-symbols.rs
index aea5527b6a1..edaf312f192 100644
--- a/tests/ui/linking/export-executable-symbols.rs
+++ b/tests/ui/linking/export-executable-symbols.rs
@@ -1,22 +1,21 @@
 //@ run-pass
-//@ only-linux
-//@ only-gnu
-//@ compile-flags: -Zexport-executable-symbols
+//@ compile-flags: -Ctarget-feature=-crt-static -Zexport-executable-symbols
+//@ ignore-wasm
 //@ edition: 2024
 
 // Regression test for <https://github.com/rust-lang/rust/issues/101610>.
 
 #![feature(rustc_private)]
 
-extern crate libc;
-
 #[unsafe(no_mangle)]
 fn hack() -> u64 {
     998244353
 }
 
 fn main() {
+    #[cfg(unix)]
     unsafe {
+        extern crate libc;
         let handle = libc::dlopen(std::ptr::null(), libc::RTLD_NOW);
         let ptr = libc::dlsym(handle, c"hack".as_ptr());
         let ptr: Option<unsafe fn() -> u64> = std::mem::transmute(ptr);
@@ -27,4 +26,24 @@ fn main() {
             panic!("symbol `hack` is not found");
         }
     }
+    #[cfg(windows)]
+    unsafe {
+        type PCSTR = *const u8;
+        type HMODULE = *mut core::ffi::c_void;
+        type FARPROC = Option<unsafe extern "system" fn() -> isize>;
+        #[link(name = "kernel32", kind = "raw-dylib")]
+        unsafe extern "system" {
+            fn GetModuleHandleA(lpmodulename: PCSTR) -> HMODULE;
+            fn GetProcAddress(hmodule: HMODULE, lpprocname: PCSTR) -> FARPROC;
+        }
+        let handle = GetModuleHandleA(std::ptr::null_mut());
+        let ptr = GetProcAddress(handle, b"hack\0".as_ptr());
+        let ptr: Option<unsafe fn() -> u64> = std::mem::transmute(ptr);
+        if let Some(f) = ptr {
+            assert!(f() == 998244353);
+            println!("symbol `hack` is found successfully");
+        } else {
+            panic!("symbol `hack` is not found");
+        }
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 7f2064e0803b27c781c8773ce82f243d9f58976e Mon Sep 17 00:00:00 2001
From: Andrey Nikolaev <gvozdvmozgu@gmail.com>
Date: Sun, 13 Jul 2025 05:43:05 -0400
Subject: remove now useless `[allow(unused_lifetimes)]`

---
 src/tools/rust-analyzer/crates/hir-def/src/nameres.rs | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs b/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
index 0837308d5b6..5030585147d 100644
--- a/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
+++ b/src/tools/rust-analyzer/crates/hir-def/src/nameres.rs
@@ -373,19 +373,14 @@ pub fn crate_def_map(db: &dyn DefDatabase, crate_id: Crate) -> &DefMap {
     crate_local_def_map(db, crate_id).def_map(db)
 }
 
-#[allow(unused_lifetimes)]
-mod __ {
-    use super::*;
-    #[salsa_macros::tracked]
-    pub(crate) struct DefMapPair<'db> {
-        #[tracked]
-        #[returns(ref)]
-        pub(crate) def_map: DefMap,
-        #[returns(ref)]
-        pub(crate) local: LocalDefMap,
-    }
+#[salsa_macros::tracked]
+pub(crate) struct DefMapPair<'db> {
+    #[tracked]
+    #[returns(ref)]
+    pub(crate) def_map: DefMap,
+    #[returns(ref)]
+    pub(crate) local: LocalDefMap,
 }
-pub(crate) use __::DefMapPair;
 
 #[salsa_macros::tracked(returns(ref))]
 pub(crate) fn crate_local_def_map(db: &dyn DefDatabase, crate_id: Crate) -> DefMapPair<'_> {
-- 
cgit 1.4.1-3-g733a5


From 75561c446afb63444e9b192563d46eccf7051c61 Mon Sep 17 00:00:00 2001
From: Anne Stijns <anstijns@gmail.com>
Date: Sun, 29 Jun 2025 23:39:09 +0200
Subject: Port `#[link_ordinal]` to the new attribute parsing infrastructure.

---
 .../rustc_attr_data_structures/src/attributes.rs   |  3 ++
 .../src/encode_cross_crate.rs                      |  1 +
 compiler/rustc_attr_parsing/messages.ftl           |  3 ++
 .../src/attributes/link_attrs.rs                   | 39 +++++++++++++++--
 .../src/attributes/rustc_internal.rs               | 34 +++------------
 compiler/rustc_attr_parsing/src/context.rs         | 36 ++++++++++++++--
 .../rustc_attr_parsing/src/session_diagnostics.rs  |  9 ++++
 compiler/rustc_codegen_ssa/messages.ftl            |  6 ---
 compiler/rustc_codegen_ssa/src/codegen_attrs.rs    | 49 ++--------------------
 compiler/rustc_codegen_ssa/src/errors.rs           | 16 -------
 compiler/rustc_metadata/src/native_libs.rs         | 10 ++---
 compiler/rustc_parse/src/validate_attr.rs          |  1 +
 compiler/rustc_passes/src/check_attr.rs            | 10 +++--
 tests/ui/attributes/malformed-attrs.stderr         | 15 ++++---
 .../windows/link-ordinal-invalid-format.rs         |  4 +-
 .../windows/link-ordinal-invalid-format.stderr     | 19 +++++----
 .../windows/link-ordinal-missing-argument.rs       |  6 ++-
 .../windows/link-ordinal-missing-argument.stderr   | 21 ++++++----
 .../windows/link-ordinal-too-many-arguments.rs     |  6 ++-
 .../windows/link-ordinal-too-many-arguments.stderr | 21 ++++++----
 20 files changed, 159 insertions(+), 150 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index f61efcf2388..abe7fb77e84 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -294,6 +294,9 @@ pub enum AttributeKind {
     /// Represents `#[link_name]`.
     LinkName { name: Symbol, span: Span },
 
+    /// Represents `#[link_ordinal]`.
+    LinkOrdinal { ordinal: u16, span: Span },
+
     /// Represents [`#[link_section]`](https://doc.rust-lang.org/reference/abi.html#the-link_section-attribute)
     LinkSection { name: Symbol, span: Span },
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index ad587523e03..b7653881a78 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -40,6 +40,7 @@ impl AttributeKind {
             Ignore { .. } => No,
             Inline(..) => No,
             LinkName { .. } => Yes,
+            LinkOrdinal { .. } => No,
             LinkSection { .. } => No,
             LoopMatch(..) => No,
             MacroTransparency(..) => Yes,
diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
index bec3a1e8a59..8d0ead63a8d 100644
--- a/compiler/rustc_attr_parsing/messages.ftl
+++ b/compiler/rustc_attr_parsing/messages.ftl
@@ -78,6 +78,9 @@ attr_parsing_invalid_repr_hint_no_value =
 attr_parsing_invalid_since =
     'since' must be a Rust version number, such as "1.31.0"
 
+attr_parsing_link_ordinal_out_of_range = ordinal value in `link_ordinal` is too large: `{$ordinal}`
+    .note = the value may not exceed `u16::MAX`
+
 attr_parsing_missing_feature =
     missing 'feature'
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
index 23a8e96482d..960cebd8925 100644
--- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -1,14 +1,14 @@
 use rustc_attr_data_structures::AttributeKind;
-use rustc_attr_data_structures::AttributeKind::{LinkName, LinkSection};
+use rustc_attr_data_structures::AttributeKind::{LinkName, LinkOrdinal, LinkSection};
 use rustc_feature::{AttributeTemplate, template};
 use rustc_span::{Span, Symbol, sym};
 
 use crate::attributes::{
     AttributeOrder, NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
 };
-use crate::context::{AcceptContext, Stage};
+use crate::context::{AcceptContext, Stage, parse_single_integer};
 use crate::parser::ArgParser;
-use crate::session_diagnostics::NullOnLinkSection;
+use crate::session_diagnostics::{LinkOrdinalOutOfRange, NullOnLinkSection};
 
 pub(crate) struct LinkNameParser;
 
@@ -87,3 +87,36 @@ impl<S: Stage> NoArgsAttributeParser<S> for StdInternalSymbolParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::StdInternalSymbol;
 }
+
+pub(crate) struct LinkOrdinalParser;
+
+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 TEMPLATE: AttributeTemplate = template!(List: "ordinal");
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let ordinal = parse_single_integer(cx, args)?;
+
+        // According to the table at
+        // https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#import-header, the
+        // ordinal must fit into 16 bits. Similarly, the Ordinal field in COFFShortExport (defined
+        // in llvm/include/llvm/Object/COFFImportFile.h), which we use to communicate import
+        // information to LLVM for `#[link(kind = "raw-dylib"_])`, is also defined to be uint16_t.
+        //
+        // FIXME: should we allow an ordinal of 0?  The MSVC toolchain has inconsistent support for
+        // this: both LINK.EXE and LIB.EXE signal errors and abort when given a .DEF file that
+        // specifies a zero ordinal. However, llvm-dlltool is perfectly happy to generate an import
+        // library for such a .DEF file, and MSVC's LINK.EXE is also perfectly happy to consume an
+        // import library produced by LLVM with an ordinal of 0, and it generates an .EXE.  (I
+        // don't know yet if the resulting EXE runs, as I haven't yet built the necessary DLL --
+        // see earlier comment about LINK.EXE failing.)
+        let Ok(ordinal) = ordinal.try_into() else {
+            cx.emit_err(LinkOrdinalOutOfRange { span: cx.attr_span, ordinal });
+            return None;
+        };
+
+        Some(LinkOrdinal { ordinal, span: cx.attr_span })
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
index ec821cb11ce..7ca951dc0bb 100644
--- a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
@@ -1,10 +1,9 @@
-use rustc_ast::LitKind;
 use rustc_attr_data_structures::AttributeKind;
 use rustc_feature::{AttributeTemplate, template};
 use rustc_span::{Symbol, sym};
 
 use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
-use crate::context::{AcceptContext, Stage};
+use crate::context::{AcceptContext, Stage, parse_single_integer};
 use crate::parser::ArgParser;
 
 pub(crate) struct RustcLayoutScalarValidRangeStart;
@@ -16,8 +15,8 @@ impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeStart {
     const TEMPLATE: AttributeTemplate = template!(List: "start");
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
-        parse_rustc_layout_scalar_valid_range(cx, args)
-            .map(|n| AttributeKind::RustcLayoutScalarValidRangeStart(n, cx.attr_span))
+        parse_single_integer(cx, args)
+            .map(|n| AttributeKind::RustcLayoutScalarValidRangeStart(Box::new(n), cx.attr_span))
     }
 }
 
@@ -30,34 +29,11 @@ impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeEnd {
     const TEMPLATE: AttributeTemplate = template!(List: "end");
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
-        parse_rustc_layout_scalar_valid_range(cx, args)
-            .map(|n| AttributeKind::RustcLayoutScalarValidRangeEnd(n, cx.attr_span))
+        parse_single_integer(cx, args)
+            .map(|n| AttributeKind::RustcLayoutScalarValidRangeEnd(Box::new(n), cx.attr_span))
     }
 }
 
-fn parse_rustc_layout_scalar_valid_range<S: Stage>(
-    cx: &mut AcceptContext<'_, '_, S>,
-    args: &ArgParser<'_>,
-) -> Option<Box<u128>> {
-    let Some(list) = args.list() else {
-        cx.expected_list(cx.attr_span);
-        return None;
-    };
-    let Some(single) = list.single() else {
-        cx.expected_single_argument(list.span);
-        return None;
-    };
-    let Some(lit) = single.lit() else {
-        cx.expected_integer_literal(single.span());
-        return None;
-    };
-    let LitKind::Int(num, _ty) = lit.kind else {
-        cx.expected_integer_literal(single.span());
-        return None;
-    };
-    Some(Box::new(num.0))
-}
-
 pub(crate) struct RustcObjectLifetimeDefaultParser;
 
 impl<S: Stage> SingleAttributeParser<S> for RustcObjectLifetimeDefaultParser {
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index cc10bb3098a..854212f6e5d 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -5,7 +5,7 @@ use std::ops::{Deref, DerefMut};
 use std::sync::LazyLock;
 
 use private::Sealed;
-use rustc_ast::{self as ast, MetaItemLit, NodeId};
+use rustc_ast::{self as ast, LitKind, MetaItemLit, NodeId};
 use rustc_attr_data_structures::AttributeKind;
 use rustc_attr_data_structures::lints::{AttributeLint, AttributeLintKind};
 use rustc_errors::{DiagCtxtHandle, Diagnostic};
@@ -24,8 +24,8 @@ use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::dummy::DummyParser;
 use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
 use crate::attributes::link_attrs::{
-    ExportStableParser, FfiConstParser, FfiPureParser, LinkNameParser, LinkSectionParser,
-    StdInternalSymbolParser,
+    ExportStableParser, FfiConstParser, FfiPureParser, LinkNameParser, LinkOrdinalParser,
+    LinkSectionParser, StdInternalSymbolParser,
 };
 use crate::attributes::lint_helpers::{AsPtrParser, PassByValueParser, PubTransparentParser};
 use crate::attributes::loop_match::{ConstContinueParser, LoopMatchParser};
@@ -141,6 +141,7 @@ attribute_parsers!(
         Single<IgnoreParser>,
         Single<InlineParser>,
         Single<LinkNameParser>,
+        Single<LinkOrdinalParser>,
         Single<LinkSectionParser>,
         Single<MustUseParser>,
         Single<OptimizeParser>,
@@ -767,3 +768,32 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         }
     }
 }
+
+/// Parse a single integer.
+///
+/// Used by attributes that take a single integer as argument, such as
+/// `#[link_ordinal]` and `#[rustc_layout_scalar_valid_range_start]`.
+/// `cx` is the context given to the attribute.
+/// `args` is the parser for the attribute arguments.
+pub(crate) fn parse_single_integer<S: Stage>(
+    cx: &mut AcceptContext<'_, '_, S>,
+    args: &ArgParser<'_>,
+) -> Option<u128> {
+    let Some(list) = args.list() else {
+        cx.expected_list(cx.attr_span);
+        return None;
+    };
+    let Some(single) = list.single() else {
+        cx.expected_single_argument(list.span);
+        return None;
+    };
+    let Some(lit) = single.lit() else {
+        cx.expected_integer_literal(single.span());
+        return None;
+    };
+    let LitKind::Int(num, _ty) = lit.kind else {
+        cx.expected_integer_literal(single.span());
+        return None;
+    };
+    Some(num.0)
+}
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index 28f6786f37f..8a240639d75 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -514,6 +514,15 @@ pub(crate) struct NakedFunctionIncompatibleAttribute {
     pub attr: String,
 }
 
+#[derive(Diagnostic)]
+#[diag(attr_parsing_link_ordinal_out_of_range)]
+#[note]
+pub(crate) struct LinkOrdinalOutOfRange {
+    #[primary_span]
+    pub span: Span,
+    pub ordinal: u128,
+}
+
 pub(crate) enum AttributeParseErrorReason {
     ExpectedNoArgs,
     ExpectedStringLiteral { byte_string: Option<Span> },
diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index 63e9005da45..c7bd6ffd1f2 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -80,9 +80,6 @@ codegen_ssa_ignoring_emit_path = ignoring emit path because multiple .{$extensio
 
 codegen_ssa_ignoring_output = ignoring -o because multiple .{$extension} files were produced
 
-codegen_ssa_illegal_link_ordinal_format = illegal ordinal format in `link_ordinal`
-    .note = an unsuffixed integer value, e.g., `1`, is expected
-
 codegen_ssa_incorrect_cgu_reuse_type =
     CGU-reuse for `{$cgu_user_name}` is `{$actual_reuse}` but should be {$at_least ->
     [one] {"at least "}
@@ -93,9 +90,6 @@ codegen_ssa_insufficient_vs_code_product = VS Code is a different product, and i
 
 codegen_ssa_invalid_instruction_set = invalid instruction set specified
 
-codegen_ssa_invalid_link_ordinal_nargs = incorrect number of arguments to `#[link_ordinal]`
-    .note = the attribute requires exactly one argument
-
 codegen_ssa_invalid_literal_value = invalid literal value
     .label = value must be an integer between `0` and `255`
 
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 85d01d4f938..dd49db26689 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -116,6 +116,10 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                 AttributeKind::Naked(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED,
                 AttributeKind::Align { align, .. } => codegen_fn_attrs.alignment = Some(*align),
                 AttributeKind::LinkName { name, .. } => codegen_fn_attrs.link_name = Some(*name),
+                AttributeKind::LinkOrdinal { ordinal, span } => {
+                    codegen_fn_attrs.link_ordinal = Some(*ordinal);
+                    link_ordinal_span = Some(*span);
+                }
                 AttributeKind::LinkSection { name, .. } => {
                     codegen_fn_attrs.link_section = Some(*name)
                 }
@@ -250,12 +254,6 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                     }
                 }
             }
-            sym::link_ordinal => {
-                link_ordinal_span = Some(attr.span());
-                if let ordinal @ Some(_) = check_link_ordinal(tcx, attr) {
-                    codegen_fn_attrs.link_ordinal = ordinal;
-                }
-            }
             sym::no_sanitize => {
                 no_sanitize_span = Some(attr.span());
                 if let Some(list) = attr.meta_item_list() {
@@ -568,45 +566,6 @@ fn inherited_align<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option<Align> {
     tcx.codegen_fn_attrs(opt_trait_item(tcx, def_id)?).alignment
 }
 
-fn check_link_ordinal(tcx: TyCtxt<'_>, attr: &hir::Attribute) -> Option<u16> {
-    use rustc_ast::{LitIntType, LitKind, MetaItemLit};
-    let meta_item_list = attr.meta_item_list()?;
-    let [sole_meta_list] = &meta_item_list[..] else {
-        tcx.dcx().emit_err(errors::InvalidLinkOrdinalNargs { span: attr.span() });
-        return None;
-    };
-    if let Some(MetaItemLit { kind: LitKind::Int(ordinal, LitIntType::Unsuffixed), .. }) =
-        sole_meta_list.lit()
-    {
-        // According to the table at
-        // https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#import-header, the
-        // ordinal must fit into 16 bits. Similarly, the Ordinal field in COFFShortExport (defined
-        // in llvm/include/llvm/Object/COFFImportFile.h), which we use to communicate import
-        // information to LLVM for `#[link(kind = "raw-dylib"_])`, is also defined to be uint16_t.
-        //
-        // FIXME: should we allow an ordinal of 0?  The MSVC toolchain has inconsistent support for
-        // this: both LINK.EXE and LIB.EXE signal errors and abort when given a .DEF file that
-        // specifies a zero ordinal. However, llvm-dlltool is perfectly happy to generate an import
-        // library for such a .DEF file, and MSVC's LINK.EXE is also perfectly happy to consume an
-        // import library produced by LLVM with an ordinal of 0, and it generates an .EXE.  (I
-        // don't know yet if the resulting EXE runs, as I haven't yet built the necessary DLL --
-        // see earlier comment about LINK.EXE failing.)
-        if *ordinal <= u16::MAX as u128 {
-            Some(ordinal.get() as u16)
-        } else {
-            let msg = format!("ordinal value in `link_ordinal` is too large: `{ordinal}`");
-            tcx.dcx()
-                .struct_span_err(attr.span(), msg)
-                .with_note("the value may not exceed `u16::MAX`")
-                .emit();
-            None
-        }
-    } else {
-        tcx.dcx().emit_err(errors::InvalidLinkOrdinalFormat { span: attr.span() });
-        None
-    }
-}
-
 fn check_link_name_xor_ordinal(
     tcx: TyCtxt<'_>,
     codegen_fn_attrs: &CodegenFnAttrs,
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index e042fe1f819..9040915b6af 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -1108,22 +1108,6 @@ pub(crate) struct InvalidNoSanitize {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(codegen_ssa_invalid_link_ordinal_nargs)]
-#[note]
-pub(crate) struct InvalidLinkOrdinalNargs {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(Diagnostic)]
-#[diag(codegen_ssa_illegal_link_ordinal_format)]
-#[note]
-pub(crate) struct InvalidLinkOrdinalFormat {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_target_feature_safe_trait)]
 pub(crate) struct TargetFeatureSafeTrait {
diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
index f10d71f4c65..4d276f814ef 100644
--- a/compiler/rustc_metadata/src/native_libs.rs
+++ b/compiler/rustc_metadata/src/native_libs.rs
@@ -3,6 +3,7 @@ use std::path::{Path, PathBuf};
 
 use rustc_abi::ExternAbi;
 use rustc_ast::CRATE_NODE_ID;
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_attr_parsing as attr;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_middle::query::LocalCrate;
@@ -496,14 +497,9 @@ impl<'tcx> Collector<'tcx> {
                 }
                 _ => {
                     for &child_item in foreign_items {
-                        if self.tcx.def_kind(child_item).has_codegen_attrs()
-                            && self.tcx.codegen_fn_attrs(child_item).link_ordinal.is_some()
+                        if let Some(span) = find_attr!(self.tcx.get_all_attrs(child_item), AttributeKind::LinkOrdinal {span, ..} => *span)
                         {
-                            let link_ordinal_attr =
-                                self.tcx.get_attr(child_item, sym::link_ordinal).unwrap();
-                            sess.dcx().emit_err(errors::LinkOrdinalRawDylib {
-                                span: link_ordinal_attr.span(),
-                            });
+                            sess.dcx().emit_err(errors::LinkOrdinalRawDylib { span });
                         }
                     }
 
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index bb5c1e0e653..03d4b64b823 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -310,6 +310,7 @@ pub fn check_builtin_meta_item(
                 | sym::must_use
                 | sym::track_caller
                 | sym::link_name
+                | sym::link_ordinal
                 | sym::export_name
                 | sym::rustc_macro_transparency
                 | sym::link_section
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2c95fead9e8..0d8973bce4b 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -248,6 +248,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 Attribute::Parsed(AttributeKind::LinkName { span: attr_span, name }) => {
                     self.check_link_name(hir_id, *attr_span, *name, span, target)
                 }
+                Attribute::Parsed(AttributeKind::LinkOrdinal { span: attr_span, .. }) => {
+                    self.check_link_ordinal(*attr_span, span, target)
+                }
                 Attribute::Parsed(AttributeKind::MayDangle(attr_span)) => {
                     self.check_may_dangle(hir_id, *attr_span)
                 }
@@ -325,7 +328,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::rustc_has_incoherent_inherent_impls, ..] => {
                             self.check_has_incoherent_inherent_impls(attr, span, target)
                         }
-                        [sym::link_ordinal, ..] => self.check_link_ordinal(attr, span, target),
+                        [sym::ffi_pure, ..] => self.check_ffi_pure(attr.span(), attrs, target),
+                        [sym::ffi_const, ..] => self.check_ffi_const(attr.span(), target),
                         [sym::link, ..] => self.check_link(hir_id, attr, span, target),
                         [sym::macro_use, ..] | [sym::macro_escape, ..] => {
                             self.check_macro_use(hir_id, attr, target)
@@ -2248,11 +2252,11 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    fn check_link_ordinal(&self, attr: &Attribute, _span: Span, target: Target) {
+    fn check_link_ordinal(&self, attr_span: Span, _span: Span, target: Target) {
         match target {
             Target::ForeignFn | Target::ForeignStatic => {}
             _ => {
-                self.dcx().emit_err(errors::LinkOrdinal { attr_span: attr.span() });
+                self.dcx().emit_err(errors::LinkOrdinal { attr_span });
             }
         }
     }
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index be529df3a49..f2696671002 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -116,12 +116,6 @@ error: malformed `cfi_encoding` attribute input
 LL | #[cfi_encoding]
    | ^^^^^^^^^^^^^^^ help: must be of the form: `#[cfi_encoding = "encoding"]`
 
-error: malformed `link_ordinal` attribute input
-  --> $DIR/malformed-attrs.rs:167:5
-   |
-LL |     #[link_ordinal]
-   |     ^^^^^^^^^^^^^^^ help: must be of the form: `#[link_ordinal(ordinal)]`
-
 error: malformed `linkage` attribute input
   --> $DIR/malformed-attrs.rs:173:5
    |
@@ -537,6 +531,15 @@ LL |     #[unsafe(ffi_pure = 1)]
    |     |                 didn't expect any arguments here
    |     help: must be of the form: `#[ffi_pure]`
 
+error[E0539]: malformed `link_ordinal` attribute input
+  --> $DIR/malformed-attrs.rs:167:5
+   |
+LL |     #[link_ordinal]
+   |     ^^^^^^^^^^^^^^^
+   |     |
+   |     expected this to be a list
+   |     help: must be of the form: `#[link_ordinal(ordinal)]`
+
 error[E0565]: malformed `ffi_const` attribute input
   --> $DIR/malformed-attrs.rs:171:5
    |
diff --git a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-invalid-format.rs b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-invalid-format.rs
index 9b7e8d70743..87b4999c5f9 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-invalid-format.rs
+++ b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-invalid-format.rs
@@ -1,10 +1,10 @@
 #[link(name = "foo")]
 extern "C" {
     #[link_ordinal("JustMonika")]
-    //~^ ERROR illegal ordinal format in `link_ordinal`
+    //~^ ERROR malformed `link_ordinal` attribute input
     fn foo();
     #[link_ordinal("JustMonika")]
-    //~^ ERROR illegal ordinal format in `link_ordinal`
+    //~^ ERROR malformed `link_ordinal` attribute input
     static mut imported_variable: i32;
 }
 
diff --git a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-invalid-format.stderr b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-invalid-format.stderr
index 6341e57a0be..ffae30aabcc 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-invalid-format.stderr
+++ b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-invalid-format.stderr
@@ -1,18 +1,21 @@
-error: illegal ordinal format in `link_ordinal`
+error[E0539]: malformed `link_ordinal` attribute input
   --> $DIR/link-ordinal-invalid-format.rs:3:5
    |
 LL |     #[link_ordinal("JustMonika")]
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: an unsuffixed integer value, e.g., `1`, is expected
+   |     ^^^^^^^^^^^^^^^------------^^
+   |     |              |
+   |     |              expected an integer literal here
+   |     help: must be of the form: `#[link_ordinal(ordinal)]`
 
-error: illegal ordinal format in `link_ordinal`
+error[E0539]: malformed `link_ordinal` attribute input
   --> $DIR/link-ordinal-invalid-format.rs:6:5
    |
 LL |     #[link_ordinal("JustMonika")]
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: an unsuffixed integer value, e.g., `1`, is expected
+   |     ^^^^^^^^^^^^^^^------------^^
+   |     |              |
+   |     |              expected an integer literal here
+   |     help: must be of the form: `#[link_ordinal(ordinal)]`
 
 error: aborting due to 2 previous errors
 
+For more information about this error, try `rustc --explain E0539`.
diff --git a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-missing-argument.rs b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-missing-argument.rs
index 6b8cd49566d..2a8b9ebacf7 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-missing-argument.rs
+++ b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-missing-argument.rs
@@ -1,10 +1,12 @@
 #[link(name = "foo")]
 extern "C" {
     #[link_ordinal()]
-    //~^ ERROR incorrect number of arguments to `#[link_ordinal]`
+    //~^ ERROR malformed `link_ordinal` attribute input
+    //~| NOTE  expected a single argument
     fn foo();
     #[link_ordinal()]
-    //~^ ERROR incorrect number of arguments to `#[link_ordinal]`
+    //~^ ERROR malformed `link_ordinal` attribute input
+    //~| NOTE  expected a single argument
     static mut imported_variable: i32;
 }
 
diff --git a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-missing-argument.stderr b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-missing-argument.stderr
index 1b04bb228e7..c6b8a18d03a 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-missing-argument.stderr
+++ b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-missing-argument.stderr
@@ -1,18 +1,21 @@
-error: incorrect number of arguments to `#[link_ordinal]`
+error[E0805]: malformed `link_ordinal` attribute input
   --> $DIR/link-ordinal-missing-argument.rs:3:5
    |
 LL |     #[link_ordinal()]
-   |     ^^^^^^^^^^^^^^^^^
-   |
-   = note: the attribute requires exactly one argument
+   |     ^^^^^^^^^^^^^^--^
+   |     |             |
+   |     |             expected a single argument here
+   |     help: must be of the form: `#[link_ordinal(ordinal)]`
 
-error: incorrect number of arguments to `#[link_ordinal]`
-  --> $DIR/link-ordinal-missing-argument.rs:6:5
+error[E0805]: malformed `link_ordinal` attribute input
+  --> $DIR/link-ordinal-missing-argument.rs:7:5
    |
 LL |     #[link_ordinal()]
-   |     ^^^^^^^^^^^^^^^^^
-   |
-   = note: the attribute requires exactly one argument
+   |     ^^^^^^^^^^^^^^--^
+   |     |             |
+   |     |             expected a single argument here
+   |     help: must be of the form: `#[link_ordinal(ordinal)]`
 
 error: aborting due to 2 previous errors
 
+For more information about this error, try `rustc --explain E0805`.
diff --git a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-too-many-arguments.rs b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-too-many-arguments.rs
index 9988115fd8b..ddf9583352f 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-too-many-arguments.rs
+++ b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-too-many-arguments.rs
@@ -1,10 +1,12 @@
 #[link(name = "foo")]
 extern "C" {
     #[link_ordinal(3, 4)]
-    //~^ ERROR incorrect number of arguments to `#[link_ordinal]`
+    //~^ ERROR malformed `link_ordinal` attribute input
+    //~| NOTE  expected a single argument
     fn foo();
     #[link_ordinal(3, 4)]
-    //~^ ERROR incorrect number of arguments to `#[link_ordinal]`
+    //~^ ERROR malformed `link_ordinal` attribute input
+    //~| NOTE  expected a single argument
     static mut imported_variable: i32;
 }
 
diff --git a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-too-many-arguments.stderr b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-too-many-arguments.stderr
index d5ce8aff34f..7d63304f598 100644
--- a/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-too-many-arguments.stderr
+++ b/tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-too-many-arguments.stderr
@@ -1,18 +1,21 @@
-error: incorrect number of arguments to `#[link_ordinal]`
+error[E0805]: malformed `link_ordinal` attribute input
   --> $DIR/link-ordinal-too-many-arguments.rs:3:5
    |
 LL |     #[link_ordinal(3, 4)]
-   |     ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: the attribute requires exactly one argument
+   |     ^^^^^^^^^^^^^^------^
+   |     |             |
+   |     |             expected a single argument here
+   |     help: must be of the form: `#[link_ordinal(ordinal)]`
 
-error: incorrect number of arguments to `#[link_ordinal]`
-  --> $DIR/link-ordinal-too-many-arguments.rs:6:5
+error[E0805]: malformed `link_ordinal` attribute input
+  --> $DIR/link-ordinal-too-many-arguments.rs:7:5
    |
 LL |     #[link_ordinal(3, 4)]
-   |     ^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: the attribute requires exactly one argument
+   |     ^^^^^^^^^^^^^^------^
+   |     |             |
+   |     |             expected a single argument here
+   |     help: must be of the form: `#[link_ordinal(ordinal)]`
 
 error: aborting due to 2 previous errors
 
+For more information about this error, try `rustc --explain E0805`.
-- 
cgit 1.4.1-3-g733a5


From 377aa764aacabbf32c1d0e91312071660b14c919 Mon Sep 17 00:00:00 2001
From: Josh Triplett <josh@joshtriplett.org>
Date: Sun, 13 Jul 2025 02:54:27 -0700
Subject: Attempt to fix up SGX for random API updates

---
 library/std/src/sys/pal/sgx/abi/usercalls/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/std/src/sys/pal/sgx/abi/usercalls/mod.rs b/library/std/src/sys/pal/sgx/abi/usercalls/mod.rs
index cbdaf439b28..dea44124f45 100644
--- a/library/std/src/sys/pal/sgx/abi/usercalls/mod.rs
+++ b/library/std/src/sys/pal/sgx/abi/usercalls/mod.rs
@@ -2,7 +2,7 @@ use crate::cmp;
 use crate::io::{
     BorrowedCursor, Error as IoError, ErrorKind, IoSlice, IoSliceMut, Result as IoResult,
 };
-use crate::random::{DefaultRandomSource, Random};
+use crate::random::random;
 use crate::time::{Duration, Instant};
 
 pub(crate) mod alloc;
@@ -179,7 +179,7 @@ pub fn wait(event_mask: u64, mut timeout: u64) -> IoResult<u64> {
         // trusted to ensure accurate timeouts.
         if let Ok(timeout_signed) = i64::try_from(timeout) {
             let tenth = timeout_signed / 10;
-            let deviation = i64::random(&mut DefaultRandomSource).checked_rem(tenth).unwrap_or(0);
+            let deviation = random::<i64>(..).checked_rem(tenth).unwrap_or(0);
             timeout = timeout_signed.saturating_add(deviation) as _;
         }
     }
-- 
cgit 1.4.1-3-g733a5


From a2d41393365df0c0c9f728de7f79b8f0d4e14ef2 Mon Sep 17 00:00:00 2001
From: Orson Peters <orsonpeters@gmail.com>
Date: Sun, 13 Jul 2025 12:16:40 +0200
Subject: Use zero for initialized Once state

---
 library/std/src/sys/sync/once/futex.rs | 8 ++++----
 library/std/src/sys/sync/once/queue.rs | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/library/std/src/sys/sync/once/futex.rs b/library/std/src/sys/sync/once/futex.rs
index 539f0fe89ea..827bbf014cd 100644
--- a/library/std/src/sys/sync/once/futex.rs
+++ b/library/std/src/sys/sync/once/futex.rs
@@ -8,16 +8,16 @@ use crate::sys::futex::{Futex, Primitive, futex_wait, futex_wake_all};
 // This means we only need one atomic value with 4 states:
 
 /// No initialization has run yet, and no thread is currently using the Once.
-const INCOMPLETE: Primitive = 0;
+const INCOMPLETE: Primitive = 3;
 /// Some thread has previously attempted to initialize the Once, but it panicked,
 /// so the Once is now poisoned. There are no other threads currently accessing
 /// this Once.
-const POISONED: Primitive = 1;
+const POISONED: Primitive = 2;
 /// Some thread is currently attempting to run initialization. It may succeed,
 /// so all future threads need to wait for it to finish.
-const RUNNING: Primitive = 2;
+const RUNNING: Primitive = 1;
 /// Initialization has completed and all future calls should finish immediately.
-const COMPLETE: Primitive = 3;
+const COMPLETE: Primitive = 0;
 
 // An additional bit indicates whether there are waiting threads:
 
diff --git a/library/std/src/sys/sync/once/queue.rs b/library/std/src/sys/sync/once/queue.rs
index 6a2ab0dcf1b..7bebb6696a8 100644
--- a/library/std/src/sys/sync/once/queue.rs
+++ b/library/std/src/sys/sync/once/queue.rs
@@ -75,10 +75,10 @@ pub struct OnceState {
 
 // Four states that a Once can be in, encoded into the lower bits of
 // `state_and_queue` in the Once structure.
-const INCOMPLETE: usize = 0x0;
-const POISONED: usize = 0x1;
-const RUNNING: usize = 0x2;
-const COMPLETE: usize = 0x3;
+const INCOMPLETE: usize = 0x3;
+const POISONED: usize = 0x2;
+const RUNNING: usize = 0x1;
+const COMPLETE: usize = 0x0;
 
 // Mask to learn about the state. All other bits are the queue of waiters if
 // this is in the RUNNING state.
-- 
cgit 1.4.1-3-g733a5


From f041962694875c0f0a33f8a5e27fd00597042169 Mon Sep 17 00:00:00 2001
From: Orson Peters <orsonpeters@gmail.com>
Date: Sun, 13 Jul 2025 12:37:34 +0200
Subject: Add comment why we use zero for COMPLETE

---
 library/std/src/sys/sync/once/futex.rs | 2 ++
 library/std/src/sys/sync/once/queue.rs | 3 ++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/library/std/src/sys/sync/once/futex.rs b/library/std/src/sys/sync/once/futex.rs
index 827bbf014cd..407fdcebcf5 100644
--- a/library/std/src/sys/sync/once/futex.rs
+++ b/library/std/src/sys/sync/once/futex.rs
@@ -17,6 +17,8 @@ const POISONED: Primitive = 2;
 /// so all future threads need to wait for it to finish.
 const RUNNING: Primitive = 1;
 /// Initialization has completed and all future calls should finish immediately.
+/// By choosing this state as the all-zero state the `is_completed` check can be
+/// a bit faster on some platforms.
 const COMPLETE: Primitive = 0;
 
 // An additional bit indicates whether there are waiting threads:
diff --git a/library/std/src/sys/sync/once/queue.rs b/library/std/src/sys/sync/once/queue.rs
index 7bebb6696a8..49e15d65f25 100644
--- a/library/std/src/sys/sync/once/queue.rs
+++ b/library/std/src/sys/sync/once/queue.rs
@@ -74,7 +74,8 @@ pub struct OnceState {
 }
 
 // Four states that a Once can be in, encoded into the lower bits of
-// `state_and_queue` in the Once structure.
+// `state_and_queue` in the Once structure. By choosing COMPLETE as the all-zero
+// state the `is_completed` check can be a bit faster on some platforms.
 const INCOMPLETE: usize = 0x3;
 const POISONED: usize = 0x2;
 const RUNNING: usize = 0x1;
-- 
cgit 1.4.1-3-g733a5


From 3689b80b75bb400e740897ec83e64be332098c0d Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Fri, 4 Jul 2025 23:56:16 +0200
Subject: make `cfg_select` a builtin macro

---
 compiler/rustc_builtin_macros/messages.ftl      |  6 ++
 compiler/rustc_builtin_macros/src/cfg_select.rs | 63 +++++++++++++++++++++
 compiler/rustc_builtin_macros/src/errors.rs     | 18 ++++++
 compiler/rustc_builtin_macros/src/lib.rs        |  2 +
 compiler/rustc_expand/src/base.rs               | 20 +++++++
 compiler/rustc_expand/src/mbe/macro_rules.rs    | 65 +++++++++++++---------
 compiler/rustc_parse/src/parser/cfg_select.rs   | 73 +++++++++++++++++++++++++
 compiler/rustc_parse/src/parser/mod.rs          |  6 +-
 compiler/rustc_span/src/symbol.rs               |  1 +
 library/core/src/macros/mod.rs                  | 26 ++-------
 library/coretests/tests/macros.rs               | 15 ++++-
 tests/auxiliary/minicore.rs                     |  4 ++
 tests/ui/macros/cfg_select.rs                   | 27 +++++++++
 tests/ui/macros/cfg_select.stderr               | 25 +++++++++
 14 files changed, 299 insertions(+), 52 deletions(-)
 create mode 100644 compiler/rustc_builtin_macros/src/cfg_select.rs
 create mode 100644 compiler/rustc_parse/src/parser/cfg_select.rs
 create mode 100644 tests/ui/macros/cfg_select.rs
 create mode 100644 tests/ui/macros/cfg_select.stderr

diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
index 3594c7ec210..183927edb02 100644
--- a/compiler/rustc_builtin_macros/messages.ftl
+++ b/compiler/rustc_builtin_macros/messages.ftl
@@ -81,6 +81,12 @@ builtin_macros_cfg_accessible_literal_path = `cfg_accessible` path cannot be a l
 builtin_macros_cfg_accessible_multiple_paths = multiple `cfg_accessible` paths are specified
 builtin_macros_cfg_accessible_unspecified_path = `cfg_accessible` path is not specified
 
+builtin_macros_cfg_select_no_matches = none of the rules in this `cfg_select` evaluated to true
+
+builtin_macros_cfg_select_unreachable = unreachable rule
+    .label = always matches
+    .label2 = this rules is never reached
+
 builtin_macros_coerce_pointee_requires_maybe_sized = `derive(CoercePointee)` requires `{$name}` to be marked `?Sized`
 
 builtin_macros_coerce_pointee_requires_one_field = `CoercePointee` can only be derived on `struct`s with at least one field
diff --git a/compiler/rustc_builtin_macros/src/cfg_select.rs b/compiler/rustc_builtin_macros/src/cfg_select.rs
new file mode 100644
index 00000000000..2dc387d5866
--- /dev/null
+++ b/compiler/rustc_builtin_macros/src/cfg_select.rs
@@ -0,0 +1,63 @@
+use rustc_ast::tokenstream::TokenStream;
+use rustc_attr_parsing as attr;
+use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
+use rustc_parse::parser::cfg_select::{CfgSelectBranches, CfgSelectRule, parse_cfg_select};
+use rustc_span::{Ident, Span, sym};
+
+use crate::errors::{CfgSelectNoMatches, CfgSelectUnreachable};
+
+/// Selects the first arm whose rule evaluates to true.
+fn select_arm(ecx: &ExtCtxt<'_>, branches: CfgSelectBranches) -> Option<(TokenStream, Span)> {
+    for (cfg, tt, arm_span) in branches.reachable {
+        if attr::cfg_matches(
+            &cfg,
+            &ecx.sess,
+            ecx.current_expansion.lint_node_id,
+            Some(ecx.ecfg.features),
+        ) {
+            return Some((tt, arm_span));
+        }
+    }
+
+    branches.wildcard.map(|(_, tt, span)| (tt, span))
+}
+
+pub(super) fn expand_cfg_select<'cx>(
+    ecx: &'cx mut ExtCtxt<'_>,
+    sp: Span,
+    tts: TokenStream,
+) -> MacroExpanderResult<'cx> {
+    ExpandResult::Ready(match parse_cfg_select(&mut ecx.new_parser_from_tts(tts)) {
+        Ok(branches) => {
+            if let Some((underscore, _, _)) = branches.wildcard {
+                // Warn for every unreachable rule. We store the fully parsed branch for rustfmt.
+                for (rule, _, _) in &branches.unreachable {
+                    let span = match rule {
+                        CfgSelectRule::Wildcard(underscore) => underscore.span,
+                        CfgSelectRule::Cfg(cfg) => cfg.span(),
+                    };
+                    let err = CfgSelectUnreachable { span, wildcard_span: underscore.span };
+                    ecx.dcx().emit_warn(err);
+                }
+            }
+
+            if let Some((tts, arm_span)) = select_arm(ecx, branches) {
+                return ExpandResult::from_tts(
+                    ecx,
+                    tts,
+                    sp,
+                    arm_span,
+                    Ident::with_dummy_span(sym::cfg_select),
+                );
+            } else {
+                // Emit a compiler error when none of the rules matched.
+                let guar = ecx.dcx().emit_err(CfgSelectNoMatches { span: sp });
+                DummyResult::any(sp, guar)
+            }
+        }
+        Err(err) => {
+            let guar = err.emit();
+            DummyResult::any(sp, guar)
+        }
+    })
+}
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
index a5ee7349fc6..6bcf4d3e0a2 100644
--- a/compiler/rustc_builtin_macros/src/errors.rs
+++ b/compiler/rustc_builtin_macros/src/errors.rs
@@ -954,3 +954,21 @@ pub(crate) struct AsmExpectedOther {
     pub(crate) span: Span,
     pub(crate) is_inline_asm: bool,
 }
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_cfg_select_no_matches)]
+pub(crate) struct CfgSelectNoMatches {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_cfg_select_unreachable)]
+pub(crate) struct CfgSelectUnreachable {
+    #[primary_span]
+    #[label(builtin_macros_label2)]
+    pub span: Span,
+
+    #[label]
+    pub wildcard_span: Span,
+}
diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs
index 6bf590df5c9..7bc448a9acb 100644
--- a/compiler/rustc_builtin_macros/src/lib.rs
+++ b/compiler/rustc_builtin_macros/src/lib.rs
@@ -33,6 +33,7 @@ mod autodiff;
 mod cfg;
 mod cfg_accessible;
 mod cfg_eval;
+mod cfg_select;
 mod compile_error;
 mod concat;
 mod concat_bytes;
@@ -79,6 +80,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         asm: asm::expand_asm,
         assert: assert::expand_assert,
         cfg: cfg::expand_cfg,
+        cfg_select: cfg_select::expand_cfg_select,
         column: source_util::expand_column,
         compile_error: compile_error::expand_compile_error,
         concat: concat::expand_concat,
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index d6d89808839..757a7e1c8e7 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -34,6 +34,7 @@ use thin_vec::ThinVec;
 use crate::base::ast::MetaItemInner;
 use crate::errors;
 use crate::expand::{self, AstFragment, Invocation};
+use crate::mbe::macro_rules::ParserAnyMacro;
 use crate::module::DirOwnership;
 use crate::stats::MacroStat;
 
@@ -262,6 +263,25 @@ impl<T, U> ExpandResult<T, U> {
     }
 }
 
+impl<'cx> MacroExpanderResult<'cx> {
+    /// Creates a [`MacroExpanderResult::Ready`] from a [`TokenStream`].
+    ///
+    /// The `TokenStream` is forwarded without any expansion.
+    pub fn from_tts(
+        cx: &'cx mut ExtCtxt<'_>,
+        tts: TokenStream,
+        site_span: Span,
+        arm_span: Span,
+        macro_ident: Ident,
+    ) -> Self {
+        // 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);
+        ExpandResult::Ready(Box::new(parser))
+    }
+}
+
 pub trait MultiItemModifier {
     /// `meta_item` is the attribute, and `item` is the item being modified.
     fn expand(
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 89547088f50..2d792355b27 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -96,6 +96,30 @@ impl<'a> ParserAnyMacro<'a> {
         ensure_complete_parse(parser, &path, kind.name(), site_span);
         fragment
     }
+
+    #[instrument(skip(cx, tts))]
+    pub(crate) fn from_tts<'cx>(
+        cx: &'cx mut ExtCtxt<'a>,
+        tts: TokenStream,
+        site_span: Span,
+        arm_span: Span,
+        is_local: bool,
+        macro_ident: Ident,
+    ) -> Self {
+        Self {
+            parser: Parser::new(&cx.sess.psess, tts, None),
+
+            // Pass along the original expansion site and the name of the macro
+            // so we can print a useful error message if the parse of the expanded
+            // macro leaves unparsed tokens.
+            site_span,
+            macro_ident,
+            lint_node_id: cx.current_expansion.lint_node_id,
+            is_trailing_mac: cx.current_expansion.is_trailing_mac,
+            arm_span,
+            is_local,
+        }
+    }
 }
 
 pub(super) struct MacroRule {
@@ -207,9 +231,6 @@ fn expand_macro<'cx>(
     rules: &[MacroRule],
 ) -> Box<dyn MacResult + 'cx> {
     let psess = &cx.sess.psess;
-    // Macros defined in the current crate have a real node id,
-    // whereas macros from an external crate have a dummy id.
-    let is_local = node_id != DUMMY_NODE_ID;
 
     if cx.trace_macros() {
         let msg = format!("expanding `{}! {{ {} }}`", name, pprust::tts_to_string(&arg));
@@ -220,7 +241,7 @@ fn expand_macro<'cx>(
     let try_success_result = try_match_macro(psess, name, &arg, rules, &mut NoopTracker);
 
     match try_success_result {
-        Ok((i, rule, named_matches)) => {
+        Ok((rule_index, rule, named_matches)) => {
             let mbe::TokenTree::Delimited(rhs_span, _, ref rhs) = rule.rhs else {
                 cx.dcx().span_bug(sp, "malformed macro rhs");
             };
@@ -241,27 +262,13 @@ fn expand_macro<'cx>(
                 trace_macros_note(&mut cx.expansions, sp, msg);
             }
 
-            let p = Parser::new(psess, tts, None);
-
+            let is_local = is_defined_in_current_crate(node_id);
             if is_local {
-                cx.resolver.record_macro_rule_usage(node_id, i);
+                cx.resolver.record_macro_rule_usage(node_id, rule_index);
             }
 
-            // Let the context choose how to interpret the result.
-            // Weird, but useful for X-macros.
-            Box::new(ParserAnyMacro {
-                parser: p,
-
-                // Pass along the original expansion site and the name of the macro
-                // so we can print a useful error message if the parse of the expanded
-                // macro leaves unparsed tokens.
-                site_span: sp,
-                macro_ident: name,
-                lint_node_id: cx.current_expansion.lint_node_id,
-                is_trailing_mac: cx.current_expansion.is_trailing_mac,
-                arm_span,
-                is_local,
-            })
+            // 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))
         }
         Err(CanRetry::No(guar)) => {
             debug!("Will not retry matching as an error was emitted already");
@@ -373,9 +380,9 @@ pub fn compile_declarative_macro(
     node_id: NodeId,
     edition: Edition,
 ) -> (SyntaxExtension, usize) {
-    let is_local = node_id != DUMMY_NODE_ID;
     let mk_syn_ext = |expander| {
         let kind = SyntaxExtensionKind::LegacyBang(expander);
+        let is_local = is_defined_in_current_crate(node_id);
         SyntaxExtension::new(sess, kind, span, Vec::new(), edition, ident.name, attrs, is_local)
     };
     let dummy_syn_ext = |guar| (mk_syn_ext(Arc::new(DummyExpander(guar))), 0);
@@ -439,7 +446,7 @@ pub fn compile_declarative_macro(
     }
 
     // Return the number of rules for unused rule linting, if this is a local macro.
-    let nrules = if is_local { rules.len() } else { 0 };
+    let nrules = if is_defined_in_current_crate(node_id) { rules.len() } else { 0 };
 
     let expander =
         Arc::new(MacroRulesMacroExpander { name: ident, span, node_id, transparency, rules });
@@ -1034,9 +1041,7 @@ fn check_matcher_core<'tt>(
                     // definition of this macro_rules, not while (re)parsing
                     // the macro when compiling another crate that is using the
                     // macro. (See #86567.)
-                    // Macros defined in the current crate have a real node id,
-                    // whereas macros from an external crate have a dummy id.
-                    if node_id != DUMMY_NODE_ID
+                    if is_defined_in_current_crate(node_id)
                         && matches!(kind, NonterminalKind::Pat(PatParam { inferred: true }))
                         && matches!(
                             next_token,
@@ -1296,6 +1301,12 @@ fn quoted_tt_to_string(tt: &mbe::TokenTree) -> String {
     }
 }
 
+fn is_defined_in_current_crate(node_id: NodeId) -> bool {
+    // Macros defined in the current crate have a real node id,
+    // whereas macros from an external crate have a dummy id.
+    node_id != DUMMY_NODE_ID
+}
+
 pub(super) fn parser_from_cx(
     psess: &ParseSess,
     mut tts: TokenStream,
diff --git a/compiler/rustc_parse/src/parser/cfg_select.rs b/compiler/rustc_parse/src/parser/cfg_select.rs
new file mode 100644
index 00000000000..24a05afff4a
--- /dev/null
+++ b/compiler/rustc_parse/src/parser/cfg_select.rs
@@ -0,0 +1,73 @@
+use rustc_ast::token::Token;
+use rustc_ast::tokenstream::{TokenStream, TokenTree};
+use rustc_ast::{MetaItemInner, token};
+use rustc_errors::PResult;
+use rustc_span::Span;
+
+use crate::exp;
+use crate::parser::Parser;
+
+pub enum CfgSelectRule {
+    Cfg(MetaItemInner),
+    Wildcard(Token),
+}
+
+#[derive(Default)]
+pub struct CfgSelectBranches {
+    /// All the conditional branches.
+    pub reachable: Vec<(MetaItemInner, TokenStream, Span)>,
+    /// The first wildcard `_ => { ... }` branch.
+    pub wildcard: Option<(Token, TokenStream, Span)>,
+    /// All branches after the first wildcard, including further wildcards.
+    /// These branches are kept for formatting.
+    pub unreachable: Vec<(CfgSelectRule, TokenStream, Span)>,
+}
+
+/// Parses a `TokenTree` that must be of the form `{ /* ... */ }`, and returns a `TokenStream` where
+/// the surrounding braces are stripped.
+fn parse_token_tree<'a>(p: &mut Parser<'a>) -> PResult<'a, TokenStream> {
+    // Generate an error if the `=>` is not followed by `{`.
+    if p.token != token::OpenBrace {
+        p.expect(exp!(OpenBrace))?;
+    }
+
+    // Strip the outer '{' and '}'.
+    match p.parse_token_tree() {
+        TokenTree::Token(..) => unreachable!("because of the expect above"),
+        TokenTree::Delimited(.., tts) => Ok(tts),
+    }
+}
+
+pub fn parse_cfg_select<'a>(p: &mut Parser<'a>) -> PResult<'a, CfgSelectBranches> {
+    let mut branches = CfgSelectBranches::default();
+
+    while p.token != token::Eof {
+        if p.eat_keyword(exp!(Underscore)) {
+            let underscore = p.prev_token;
+            p.expect(exp!(FatArrow))?;
+
+            let tts = parse_token_tree(p)?;
+            let span = underscore.span.to(p.token.span);
+
+            match branches.wildcard {
+                None => branches.wildcard = Some((underscore, tts, span)),
+                Some(_) => {
+                    branches.unreachable.push((CfgSelectRule::Wildcard(underscore), tts, span))
+                }
+            }
+        } else {
+            let meta_item = p.parse_meta_item_inner()?;
+            p.expect(exp!(FatArrow))?;
+
+            let tts = parse_token_tree(p)?;
+            let span = meta_item.span().to(p.token.span);
+
+            match branches.wildcard {
+                None => branches.reachable.push((meta_item, tts, span)),
+                Some(_) => branches.unreachable.push((CfgSelectRule::Cfg(meta_item), tts, span)),
+            }
+        }
+    }
+
+    Ok(branches)
+}
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index cfc0399b0ca..bc939b8f5a7 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -1,4 +1,3 @@
-pub mod asm;
 pub mod attr;
 mod attr_wrapper;
 mod diagnostics;
@@ -12,6 +11,11 @@ mod stmt;
 pub mod token_type;
 mod ty;
 
+// Parsers for non-functionlike builtin macros are defined in rustc_parse so they can be used by
+// both rustc_builtin_macros and rustfmt.
+pub mod asm;
+pub mod cfg_select;
+
 use std::assert_matches::debug_assert_matches;
 use std::{fmt, mem, slice};
 
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 09f01d8704e..930c245168a 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -624,6 +624,7 @@ symbols! {
         cfg_relocation_model,
         cfg_sanitize,
         cfg_sanitizer_cfi,
+        cfg_select,
         cfg_target_abi,
         cfg_target_compact,
         cfg_target_feature,
diff --git a/library/core/src/macros/mod.rs b/library/core/src/macros/mod.rs
index 8035dccc632..6b9cbb06435 100644
--- a/library/core/src/macros/mod.rs
+++ b/library/core/src/macros/mod.rs
@@ -230,32 +230,16 @@ pub macro assert_matches {
 /// ```
 /// #![feature(cfg_select)]
 ///
-/// let _some_string = cfg_select! {{
+/// let _some_string = cfg_select! {
 ///     unix => { "With great power comes great electricity bills" }
 ///     _ => { "Behind every successful diet is an unwatched pizza" }
-/// }};
+/// };
 /// ```
 #[unstable(feature = "cfg_select", issue = "115585")]
 #[rustc_diagnostic_item = "cfg_select"]
-#[rustc_macro_transparency = "semitransparent"]
-pub macro cfg_select {
-    ({ $($tt:tt)* }) => {{
-        $crate::cfg_select! { $($tt)* }
-    }},
-    (_ => { $($output:tt)* }) => {
-        $($output)*
-    },
-    (
-        $cfg:meta => $output:tt
-        $($( $rest:tt )+)?
-    ) => {
-        #[cfg($cfg)]
-        $crate::cfg_select! { _ => $output }
-        $(
-            #[cfg(not($cfg))]
-            $crate::cfg_select! { $($rest)+ }
-        )?
-    },
+#[rustc_builtin_macro]
+pub macro cfg_select($($tt:tt)*) {
+    /* compiler built-in */
 }
 
 /// Asserts that a boolean expression is `true` at runtime.
diff --git a/library/coretests/tests/macros.rs b/library/coretests/tests/macros.rs
index d220e628d73..1c6aa90dfbc 100644
--- a/library/coretests/tests/macros.rs
+++ b/library/coretests/tests/macros.rs
@@ -48,11 +48,12 @@ fn matches_leading_pipe() {
 fn cfg_select_basic() {
     cfg_select! {
         target_pointer_width = "64" => { fn f0_() -> bool { true }}
+        _ => {}
     }
 
     cfg_select! {
         unix => { fn f1_() -> bool { true } }
-        any(target_os = "macos", target_os = "linux") => { fn f1_() -> bool { false }}
+        _ => { fn f1_() -> bool { false }}
     }
 
     cfg_select! {
@@ -70,6 +71,8 @@ fn cfg_select_basic() {
 
     #[cfg(unix)]
     assert!(f1_());
+    #[cfg(not(unix))]
+    assert!(!f1_());
 
     #[cfg(target_pointer_width = "32")]
     assert!(!f2_());
@@ -183,6 +186,12 @@ fn _accepts_expressions() -> i32 {
     }
 }
 
+fn _accepts_only_wildcard() -> i32 {
+    cfg_select! {
+        _ => { 1 }
+    }
+}
+
 // The current implementation expands to a macro call, which allows the use of expression
 // statements.
 fn _allows_stmt_expr_attributes() {
@@ -195,12 +204,12 @@ fn _allows_stmt_expr_attributes() {
 }
 
 fn _expression() {
-    let _ = cfg_select!({
+    let _ = cfg_select!(
         windows => {
             " XP"
         }
         _ => {
             ""
         }
-    });
+    );
 }
diff --git a/tests/auxiliary/minicore.rs b/tests/auxiliary/minicore.rs
index 392ad1cee14..47dadd51ce0 100644
--- a/tests/auxiliary/minicore.rs
+++ b/tests/auxiliary/minicore.rs
@@ -142,6 +142,10 @@ pub macro naked_asm("assembly template", $(operands,)* $(options($(option),*))?)
 pub macro global_asm("assembly template", $(operands,)* $(options($(option),*))?) {
     /* compiler built-in */
 }
+#[rustc_builtin_macro]
+pub macro cfg_select($($tt:tt)*) {
+    /* compiler built-in */
+}
 
 #[rustc_builtin_macro]
 #[macro_export]
diff --git a/tests/ui/macros/cfg_select.rs b/tests/ui/macros/cfg_select.rs
new file mode 100644
index 00000000000..a4d94836a09
--- /dev/null
+++ b/tests/ui/macros/cfg_select.rs
@@ -0,0 +1,27 @@
+#![feature(cfg_select)]
+#![crate_type = "lib"]
+
+fn print() {
+    println!(cfg_select! {
+        unix => { "unix" }
+        _ => { "not unix" }
+    });
+}
+
+fn arm_rhs_must_be_in_braces() -> i32 {
+    cfg_select! {
+        true => 1
+        //~^ ERROR: expected `{`, found `1`
+    }
+}
+
+cfg_select! {
+    _ => {}
+    true => {}
+    //~^ WARN unreachable rule
+}
+
+cfg_select! {
+    //~^ ERROR none of the rules in this `cfg_select` evaluated to true
+    false => {}
+}
diff --git a/tests/ui/macros/cfg_select.stderr b/tests/ui/macros/cfg_select.stderr
new file mode 100644
index 00000000000..fef5e95a6bc
--- /dev/null
+++ b/tests/ui/macros/cfg_select.stderr
@@ -0,0 +1,25 @@
+error: expected `{`, found `1`
+  --> $DIR/cfg_select.rs:13:17
+   |
+LL |         true => 1
+   |                 ^ expected `{`
+
+warning: unreachable rule
+  --> $DIR/cfg_select.rs:20:5
+   |
+LL |     _ => {}
+   |     - always matches
+LL |     true => {}
+   |     ^^^^ this rules is never reached
+
+error: none of the rules in this `cfg_select` evaluated to true
+  --> $DIR/cfg_select.rs:24:1
+   |
+LL | / cfg_select! {
+LL | |
+LL | |     false => {}
+LL | | }
+   | |_^
+
+error: aborting due to 2 previous errors; 1 warning emitted
+
-- 
cgit 1.4.1-3-g733a5


From a3c90b69af76589cc9840bbfd95e6267e531dc92 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Sun, 13 Jul 2025 14:38:33 +0200
Subject: Run bootstrap tests sooner in the `x test` pipeline

---
 src/bootstrap/src/core/builder/mod.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 4d606953d99..7115c5a1cbe 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -1044,6 +1044,7 @@ impl<'a> Builder<'a> {
             Kind::Test => describe!(
                 crate::core::build_steps::toolstate::ToolStateCheck,
                 test::Tidy,
+                test::Bootstrap,
                 test::Ui,
                 test::Crashes,
                 test::Coverage,
@@ -1098,8 +1099,6 @@ impl<'a> Builder<'a> {
                 test::RustInstaller,
                 test::TestFloatParse,
                 test::CollectLicenseMetadata,
-                // Run bootstrap close to the end as it's unlikely to fail
-                test::Bootstrap,
                 // Run run-make last, since these won't pass without make on Windows
                 test::RunMake,
             ),
-- 
cgit 1.4.1-3-g733a5


From ad6e587e838b1197596063f7efca1c65978a985e Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sun, 13 Jul 2025 13:23:58 +0000
Subject: Remove usused depth.

---
 compiler/rustc_ty_utils/src/assoc.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index 66c44f72f4e..d71e8982871 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -137,12 +137,10 @@ struct RPITVisitor<'a, 'tcx> {
     synthetics: Vec<LocalDefId>,
     data: DefPathData,
     disambiguator: &'a mut DisambiguatorState,
-    depth: u32,
 }
 
 impl<'tcx> Visitor<'tcx> for RPITVisitor<'_, 'tcx> {
     fn visit_opaque_ty(&mut self, opaque: &'tcx hir::OpaqueTy<'tcx>) -> Self::Result {
-        self.depth += 1;
         self.synthetics.push(associated_type_for_impl_trait_in_trait(
             self.tcx,
             opaque.def_id,
@@ -172,8 +170,7 @@ fn associated_types_for_impl_traits_in_trait_or_impl<'tcx>(
                 };
                 let def_name = tcx.item_name(fn_def_id.to_def_id());
                 let data = DefPathData::AnonAssocTy(def_name);
-                let mut visitor =
-                    RPITVisitor { tcx, synthetics: vec![], data, depth: 0, disambiguator };
+                let mut visitor = RPITVisitor { tcx, synthetics: vec![], data, disambiguator };
                 visitor.visit_fn_ret_ty(output);
                 let defs = visitor
                     .synthetics
-- 
cgit 1.4.1-3-g733a5


From 50ca0c6ab8eb742c88ed24018ff78973a1f68d37 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sun, 13 Jul 2025 13:43:10 +0000
Subject: Delegation: self parameter must be named exactly `self`.

---
 compiler/rustc_ast_lowering/src/delegation.rs | 40 ++++++++++++++++++++++-----
 1 file changed, 33 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index 42d25b512f5..a8a8b2d6e1b 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -47,6 +47,7 @@ use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def_id::DefId;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{Asyncness, ResolverAstLowering};
+use rustc_span::symbol::kw;
 use rustc_span::{Ident, Span, Symbol};
 use {rustc_ast as ast, rustc_hir as hir};
 
@@ -101,10 +102,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let sig_id = self.get_delegation_sig_id(item_id, delegation.id, span, is_in_trait_impl);
         match sig_id {
             Ok(sig_id) => {
+                let is_method = self.is_method(sig_id, span);
                 let (param_count, c_variadic) = self.param_count(sig_id);
                 let decl = self.lower_delegation_decl(sig_id, param_count, c_variadic, span);
                 let sig = self.lower_delegation_sig(sig_id, decl, span);
-                let body_id = self.lower_delegation_body(delegation, param_count, span);
+                let body_id = self.lower_delegation_body(delegation, is_method, param_count, span);
                 let ident = self.lower_ident(delegation.ident);
                 let generics = self.lower_delegation_generics(span);
                 DelegationResults { body_id, sig, ident, generics }
@@ -234,10 +236,21 @@ impl<'hir> LoweringContext<'_, 'hir> {
         hir::FnSig { decl, header, span }
     }
 
-    fn generate_param(&mut self, idx: usize, span: Span) -> (hir::Param<'hir>, NodeId) {
+    fn generate_param(
+        &mut self,
+        is_method: bool,
+        idx: usize,
+        span: Span,
+    ) -> (hir::Param<'hir>, NodeId) {
         let pat_node_id = self.next_node_id();
         let pat_id = self.lower_node_id(pat_node_id);
-        let ident = Ident::with_dummy_span(Symbol::intern(&format!("arg{idx}")));
+        // FIXME(cjgillot) AssocItem currently relies on self parameter being exactly named `self`.
+        let name = if is_method && idx == 0 {
+            kw::SelfLower
+        } else {
+            Symbol::intern(&format!("arg{idx}"))
+        };
+        let ident = Ident::with_dummy_span(name);
         let pat = self.arena.alloc(hir::Pat {
             hir_id: pat_id,
             kind: hir::PatKind::Binding(hir::BindingMode::NONE, pat_id, ident, None),
@@ -248,9 +261,21 @@ impl<'hir> LoweringContext<'_, 'hir> {
         (hir::Param { hir_id: self.next_id(), pat, ty_span: span, span }, pat_node_id)
     }
 
-    fn generate_arg(&mut self, idx: usize, param_id: HirId, span: Span) -> hir::Expr<'hir> {
+    fn generate_arg(
+        &mut self,
+        is_method: bool,
+        idx: usize,
+        param_id: HirId,
+        span: Span,
+    ) -> hir::Expr<'hir> {
+        // FIXME(cjgillot) AssocItem currently relies on self parameter being exactly named `self`.
+        let name = if is_method && idx == 0 {
+            kw::SelfLower
+        } else {
+            Symbol::intern(&format!("arg{idx}"))
+        };
         let segments = self.arena.alloc_from_iter(iter::once(hir::PathSegment {
-            ident: Ident::with_dummy_span(Symbol::intern(&format!("arg{idx}"))),
+            ident: Ident::with_dummy_span(name),
             hir_id: self.next_id(),
             res: Res::Local(param_id),
             args: None,
@@ -264,6 +289,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_delegation_body(
         &mut self,
         delegation: &Delegation,
+        is_method: bool,
         param_count: usize,
         span: Span,
     ) -> BodyId {
@@ -274,7 +300,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             let mut args: Vec<hir::Expr<'_>> = Vec::with_capacity(param_count);
 
             for idx in 0..param_count {
-                let (param, pat_node_id) = this.generate_param(idx, span);
+                let (param, pat_node_id) = this.generate_param(is_method, idx, span);
                 parameters.push(param);
 
                 let arg = if let Some(block) = block
@@ -290,7 +316,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     this.ident_and_label_to_local_id.insert(pat_node_id, param.pat.hir_id.local_id);
                     this.lower_target_expr(&block)
                 } else {
-                    this.generate_arg(idx, param.pat.hir_id, span)
+                    this.generate_arg(is_method, idx, param.pat.hir_id, span)
                 };
                 args.push(arg);
             }
-- 
cgit 1.4.1-3-g733a5


From 3ecd03bdfd8da8464e2e381523adb15d60975254 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sun, 13 Jul 2025 13:31:16 +0000
Subject: Move trait_item_def_id from ImplItemRef to ImplItem.

---
 compiler/rustc_ast_lowering/src/index.rs |   2 +-
 compiler/rustc_ast_lowering/src/item.rs  |  10 +--
 compiler/rustc_hir/src/hir.rs            |   6 +-
 compiler/rustc_hir/src/intravisit.rs     |   3 +-
 compiler/rustc_ty_utils/src/assoc.rs     | 113 ++++++++++++++-----------------
 tests/ui/stats/input-stats.stderr        |   4 +-
 6 files changed, 64 insertions(+), 74 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/index.rs b/compiler/rustc_ast_lowering/src/index.rs
index 956cb580d10..db67ce8dc16 100644
--- a/compiler/rustc_ast_lowering/src/index.rs
+++ b/compiler/rustc_ast_lowering/src/index.rs
@@ -392,7 +392,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
     fn visit_impl_item_ref(&mut self, ii: &'hir ImplItemRef) {
         // Do not visit the duplicate information in ImplItemRef. We want to
         // map the actual nodes, not the duplicate ones in the *Ref.
-        let ImplItemRef { id, ident: _, kind: _, span: _, trait_item_def_id: _ } = *ii;
+        let ImplItemRef { id, ident: _, kind: _, span: _ } = *ii;
 
         self.visit_nested_impl_item(id);
     }
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index bdcb750ba26..b2a69c7c00f 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -1128,6 +1128,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
             span: self.lower_span(i.span),
             defaultness,
             has_delayed_lints: !self.delayed_lints.is_empty(),
+            trait_item_def_id: self
+                .resolver
+                .get_partial_res(i.id)
+                .map(|r| r.expect_full_res().opt_def_id())
+                .unwrap_or(None),
         };
         self.arena.alloc(item)
     }
@@ -1157,11 +1162,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     panic!("macros should have been expanded by now")
                 }
             },
-            trait_item_def_id: self
-                .resolver
-                .get_partial_res(i.id)
-                .map(|r| r.expect_full_res().opt_def_id())
-                .unwrap_or(None),
         }
     }
 
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 0f6f81d7964..c57a8e648fb 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -3172,6 +3172,8 @@ pub struct ImplItem<'hir> {
     pub span: Span,
     pub vis_span: Span,
     pub has_delayed_lints: bool,
+    /// When we are in a trait impl, link to the trait-item's id.
+    pub trait_item_def_id: Option<DefId>,
 }
 
 impl<'hir> ImplItem<'hir> {
@@ -4429,8 +4431,6 @@ pub struct ImplItemRef {
     pub ident: Ident,
     pub kind: AssocItemKind,
     pub span: Span,
-    /// When we are in a trait impl, link to the trait-item's id.
-    pub trait_item_def_id: Option<DefId>,
 }
 
 #[derive(Copy, Clone, PartialEq, Debug, HashStable_Generic)]
@@ -4969,7 +4969,7 @@ mod size_asserts {
     static_assert_size!(GenericBound<'_>, 64);
     static_assert_size!(Generics<'_>, 56);
     static_assert_size!(Impl<'_>, 80);
-    static_assert_size!(ImplItem<'_>, 88);
+    static_assert_size!(ImplItem<'_>, 96);
     static_assert_size!(ImplItemKind<'_>, 40);
     static_assert_size!(Item<'_>, 88);
     static_assert_size!(ItemKind<'_>, 64);
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index 1bb8f7ad894..c40a6b081ef 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -1271,6 +1271,7 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(
         span: _,
         vis_span: _,
         has_delayed_lints: _,
+        trait_item_def_id: _,
     } = *impl_item;
 
     try_visit!(visitor.visit_ident(ident));
@@ -1306,7 +1307,7 @@ pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(
     visitor: &mut V,
     impl_item_ref: &'v ImplItemRef,
 ) -> V::Result {
-    let ImplItemRef { id, ident, ref kind, span: _, trait_item_def_id: _ } = *impl_item_ref;
+    let ImplItemRef { id, ident, ref kind, span: _ } = *impl_item_ref;
     try_visit!(visitor.visit_nested_impl_item(id));
     try_visit!(visitor.visit_ident(ident));
     visitor.visit_associated_item_kind(kind)
diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index d71e8982871..d27f749762f 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -6,6 +6,8 @@ use rustc_hir::{self as hir, ItemKind};
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{self, ImplTraitInTraitData, TyCtxt};
 use rustc_middle::{bug, span_bug};
+use rustc_span::Ident;
+use rustc_span::symbol::kw;
 
 pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers {
@@ -66,46 +68,33 @@ fn impl_item_implementor_ids(tcx: TyCtxt<'_>, impl_id: DefId) -> DefIdMap<DefId>
 }
 
 fn associated_item(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::AssocItem {
-    let id = tcx.local_def_id_to_hir_id(def_id);
-    let parent_def_id = tcx.hir_get_parent_item(id);
-    let parent_item = tcx.hir_expect_item(parent_def_id.def_id);
-    match parent_item.kind {
-        hir::ItemKind::Impl(impl_) => {
-            if let Some(impl_item_ref) = impl_.items.iter().find(|i| i.id.owner_id.def_id == def_id)
-            {
-                let assoc_item = associated_item_from_impl_item_ref(impl_item_ref);
-                debug_assert_eq!(assoc_item.def_id.expect_local(), def_id);
-                return assoc_item;
-            }
-        }
-
-        hir::ItemKind::Trait(.., trait_item_refs) => {
-            if let Some(trait_item_ref) =
-                trait_item_refs.iter().find(|i| i.id.owner_id.def_id == def_id)
-            {
-                let assoc_item = associated_item_from_trait_item_ref(trait_item_ref);
-                debug_assert_eq!(assoc_item.def_id.expect_local(), def_id);
-                return assoc_item;
-            }
-        }
-
-        _ => {}
-    }
+    let assoc_item = match tcx.hir_node_by_def_id(def_id) {
+        hir::Node::TraitItem(ti) => associated_item_from_trait_item(tcx, ti),
+        hir::Node::ImplItem(ii) => associated_item_from_impl_item(tcx, ii),
+        node => span_bug!(tcx.def_span(def_id), "impl item or item not found: {:?}", node,),
+    };
+    debug_assert_eq!(assoc_item.def_id.expect_local(), def_id);
+    assoc_item
+}
 
-    span_bug!(
-        parent_item.span,
-        "unexpected parent of trait or impl item or item not found: {:?}",
-        parent_item.kind
-    )
+fn fn_has_self_parameter(tcx: TyCtxt<'_>, owner_id: hir::OwnerId) -> bool {
+    matches!(tcx.fn_arg_idents(owner_id.def_id), [Some(Ident { name: kw::SelfLower, .. }), ..])
 }
 
-fn associated_item_from_trait_item_ref(trait_item_ref: &hir::TraitItemRef) -> ty::AssocItem {
-    let owner_id = trait_item_ref.id.owner_id;
-    let name = trait_item_ref.ident.name;
-    let kind = match trait_item_ref.kind {
-        hir::AssocItemKind::Const => ty::AssocKind::Const { name },
-        hir::AssocItemKind::Fn { has_self } => ty::AssocKind::Fn { name, has_self },
-        hir::AssocItemKind::Type => ty::AssocKind::Type { data: ty::AssocTypeData::Normal(name) },
+fn associated_item_from_trait_item(
+    tcx: TyCtxt<'_>,
+    trait_item: &hir::TraitItem<'_>,
+) -> ty::AssocItem {
+    let owner_id = trait_item.owner_id;
+    let name = trait_item.ident.name;
+    let kind = match trait_item.kind {
+        hir::TraitItemKind::Const { .. } => ty::AssocKind::Const { name },
+        hir::TraitItemKind::Fn { .. } => {
+            ty::AssocKind::Fn { name, has_self: fn_has_self_parameter(tcx, owner_id) }
+        }
+        hir::TraitItemKind::Type { .. } => {
+            ty::AssocKind::Type { data: ty::AssocTypeData::Normal(name) }
+        }
     };
 
     ty::AssocItem {
@@ -116,19 +105,23 @@ fn associated_item_from_trait_item_ref(trait_item_ref: &hir::TraitItemRef) -> ty
     }
 }
 
-fn associated_item_from_impl_item_ref(impl_item_ref: &hir::ImplItemRef) -> ty::AssocItem {
-    let def_id = impl_item_ref.id.owner_id;
-    let name = impl_item_ref.ident.name;
-    let kind = match impl_item_ref.kind {
-        hir::AssocItemKind::Const => ty::AssocKind::Const { name },
-        hir::AssocItemKind::Fn { has_self } => ty::AssocKind::Fn { name, has_self },
-        hir::AssocItemKind::Type => ty::AssocKind::Type { data: ty::AssocTypeData::Normal(name) },
+fn associated_item_from_impl_item(tcx: TyCtxt<'_>, impl_item: &hir::ImplItem<'_>) -> ty::AssocItem {
+    let owner_id = impl_item.owner_id;
+    let name = impl_item.ident.name;
+    let kind = match impl_item.kind {
+        hir::ImplItemKind::Const { .. } => ty::AssocKind::Const { name },
+        hir::ImplItemKind::Fn { .. } => {
+            ty::AssocKind::Fn { name, has_self: fn_has_self_parameter(tcx, owner_id) }
+        }
+        hir::ImplItemKind::Type { .. } => {
+            ty::AssocKind::Type { data: ty::AssocTypeData::Normal(name) }
+        }
     };
 
     ty::AssocItem {
         kind,
-        def_id: def_id.to_def_id(),
-        trait_item_def_id: impl_item_ref.trait_item_def_id,
+        def_id: owner_id.to_def_id(),
+        trait_item_def_id: impl_item.trait_item_def_id,
         container: ty::AssocItemContainer::Impl,
     }
 }
@@ -196,17 +189,13 @@ fn associated_types_for_impl_traits_in_trait_or_impl<'tcx>(
                         return None;
                     }
                     let did = item.id.owner_id.def_id.to_def_id();
+                    let item = tcx.hir_impl_item(item.id);
                     let Some(trait_item_def_id) = item.trait_item_def_id else {
                         return Some((did, vec![]));
                     };
                     let iter = in_trait_def[&trait_item_def_id].iter().map(|&id| {
-                        associated_type_for_impl_trait_in_impl(
-                            tcx,
-                            id,
-                            item.id.owner_id.def_id,
-                            disambiguator,
-                        )
-                        .to_def_id()
+                        associated_type_for_impl_trait_in_impl(tcx, id, item, disambiguator)
+                            .to_def_id()
                     });
                     Some((did, iter.collect()))
                 })
@@ -285,20 +274,20 @@ fn associated_type_for_impl_trait_in_trait(
 
 /// Given an `trait_assoc_def_id` corresponding to an associated item synthesized
 /// from an `impl Trait` in an associated function from a trait, and an
-/// `impl_fn_def_id` that represents an implementation of the associated function
+/// `impl_fn` that represents an implementation of the associated function
 /// that the `impl Trait` comes from, synthesize an associated type for that `impl Trait`
 /// that inherits properties that we infer from the method and the associated type.
 fn associated_type_for_impl_trait_in_impl(
     tcx: TyCtxt<'_>,
     trait_assoc_def_id: DefId,
-    impl_fn_def_id: LocalDefId,
+    impl_fn: &hir::ImplItem<'_>,
     disambiguator: &mut DisambiguatorState,
 ) -> LocalDefId {
-    let impl_local_def_id = tcx.local_parent(impl_fn_def_id);
+    let impl_local_def_id = tcx.local_parent(impl_fn.owner_id.def_id);
 
-    let decl = tcx.hir_node_by_def_id(impl_fn_def_id).fn_decl().expect("expected decl");
-    let span = match decl.output {
-        hir::FnRetTy::DefaultReturn(_) => tcx.def_span(impl_fn_def_id),
+    let hir::ImplItemKind::Fn(fn_sig, _) = impl_fn.kind else { bug!("expected decl") };
+    let span = match fn_sig.decl.output {
+        hir::FnRetTy::DefaultReturn(_) => tcx.def_span(impl_fn.owner_id),
         hir::FnRetTy::Return(ty) => ty.span,
     };
 
@@ -329,7 +318,7 @@ fn associated_type_for_impl_trait_in_impl(
     impl_assoc_ty.associated_item(ty::AssocItem {
         kind: ty::AssocKind::Type {
             data: ty::AssocTypeData::Rpitit(ImplTraitInTraitData::Impl {
-                fn_def_id: impl_fn_def_id.to_def_id(),
+                fn_def_id: impl_fn.owner_id.to_def_id(),
             }),
         },
         def_id,
@@ -338,10 +327,10 @@ fn associated_type_for_impl_trait_in_impl(
     });
 
     // Copy visility of the containing function.
-    impl_assoc_ty.visibility(tcx.visibility(impl_fn_def_id));
+    impl_assoc_ty.visibility(tcx.visibility(impl_fn.owner_id));
 
     // Copy defaultness of the containing function.
-    impl_assoc_ty.defaultness(tcx.defaultness(impl_fn_def_id));
+    impl_assoc_ty.defaultness(tcx.defaultness(impl_fn.owner_id));
 
     // Copy generics_of the trait's associated item but the impl as the parent.
     // FIXME: This may be detrimental to diagnostics, as we resolve the early-bound vars
diff --git a/tests/ui/stats/input-stats.stderr b/tests/ui/stats/input-stats.stderr
index eb038bbcaf1..7c92044ef5f 100644
--- a/tests/ui/stats/input-stats.stderr
+++ b/tests/ui/stats/input-stats.stderr
@@ -107,17 +107,17 @@ hir-stats WherePredicate            72 (NN.N%)             3            24
 hir-stats - BoundPredicate            72 (NN.N%)             3
 hir-stats Local                     72 (NN.N%)             1            72
 hir-stats InlineAsm                 72 (NN.N%)             1            72
-hir-stats ImplItemRef               72 (NN.N%)             2            36
 hir-stats Body                      72 (NN.N%)             3            24
 hir-stats Param                     64 (NN.N%)             2            32
 hir-stats GenericArg                64 (NN.N%)             4            16
 hir-stats - Type                      16 (NN.N%)             1
 hir-stats - Lifetime                  48 (NN.N%)             3
 hir-stats TraitItemRef              56 (NN.N%)             2            28
+hir-stats ImplItemRef               56 (NN.N%)             2            28
 hir-stats ExprField                 40 (NN.N%)             1            40
 hir-stats Mod                       32 (NN.N%)             1            32
 hir-stats Lifetime                  28 (NN.N%)             1            28
 hir-stats ForeignItemRef            24 (NN.N%)             1            24
 hir-stats ----------------------------------------------------------------
-hir-stats Total                  8_716                   173
+hir-stats Total                  8_700                   173
 hir-stats ================================================================
-- 
cgit 1.4.1-3-g733a5


From 277b0ecf3493a89818a4008afbb36ae4e77c1024 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sun, 13 Jul 2025 13:42:02 +0000
Subject: Remove hir::AssocItemKind.

---
 compiler/rustc_ast_lowering/src/delegation.rs      |  15 ---
 compiler/rustc_ast_lowering/src/index.rs           |   4 +-
 compiler/rustc_ast_lowering/src/item.rs            |  49 +------
 .../src/diagnostics/mutability_errors.rs           |  46 +++----
 compiler/rustc_hir/src/hir.rs                      |   9 --
 compiler/rustc_hir/src/intravisit.rs               |  20 +--
 compiler/rustc_hir_analysis/src/collect.rs         |   2 +-
 compiler/rustc_lint/src/builtin.rs                 |  75 +++++------
 compiler/rustc_middle/src/ty/assoc.rs              |  10 ++
 compiler/rustc_passes/src/check_attr.rs            |   8 +-
 compiler/rustc_passes/src/dead.rs                  |   2 +-
 compiler/rustc_privacy/src/lib.rs                  | 148 +++++++++------------
 .../src/error_reporting/infer/note_and_explain.rs  |  64 +++------
 compiler/rustc_ty_utils/src/assoc.rs               |   4 +-
 .../src/arbitrary_source_item_ordering.rs          |  26 ++--
 src/tools/clippy/clippy_lints/src/escape.rs        |  22 ++-
 .../src/functions/renamed_function_params.rs       |  15 +--
 .../clippy/clippy_lints/src/infallible_try_from.rs |  39 +++---
 src/tools/clippy/clippy_lints/src/len_zero.rs      |  20 +--
 .../clippy_lints/src/missing_trait_methods.rs      |   7 +-
 .../clippy/clippy_lints/src/new_without_default.rs |  19 ++-
 .../clippy/clippy_lints/src/same_name_method.rs    |  32 ++---
 src/tools/clippy/tests/ui/same_name_method.stderr  |  16 +--
 .../defaults-in-other-trait-items.stderr           |   6 +-
 .../defaults-specialization.stderr                 |   6 +-
 tests/ui/associated-types/issue-26681.stderr       |   2 +-
 tests/ui/generics/export-name-on-generics.stderr   |  34 ++---
 tests/ui/generics/generic-no-mangle.stderr         |  34 ++---
 tests/ui/lint/suggestions.stderr                   |   6 +-
 .../specialization-default-types.current.stderr    |   2 +-
 .../specialization-default-types.next.stderr       |   2 +-
 tests/ui/stats/input-stats.stderr                  |   6 +-
 32 files changed, 294 insertions(+), 456 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index a8a8b2d6e1b..9bfcd232221 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -62,21 +62,6 @@ pub(crate) struct DelegationResults<'hir> {
 }
 
 impl<'hir> LoweringContext<'_, 'hir> {
-    /// Defines whether the delegatee is an associated function whose first parameter is `self`.
-    pub(crate) fn delegatee_is_method(
-        &self,
-        item_id: NodeId,
-        path_id: NodeId,
-        span: Span,
-        is_in_trait_impl: bool,
-    ) -> bool {
-        let sig_id = self.get_delegation_sig_id(item_id, path_id, span, is_in_trait_impl);
-        let Ok(sig_id) = sig_id else {
-            return false;
-        };
-        self.is_method(sig_id, span)
-    }
-
     fn is_method(&self, def_id: DefId, span: Span) -> bool {
         match self.tcx.def_kind(def_id) {
             DefKind::Fn => false,
diff --git a/compiler/rustc_ast_lowering/src/index.rs b/compiler/rustc_ast_lowering/src/index.rs
index db67ce8dc16..a86fa49755b 100644
--- a/compiler/rustc_ast_lowering/src/index.rs
+++ b/compiler/rustc_ast_lowering/src/index.rs
@@ -384,7 +384,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
     fn visit_trait_item_ref(&mut self, ii: &'hir TraitItemRef) {
         // Do not visit the duplicate information in TraitItemRef. We want to
         // map the actual nodes, not the duplicate ones in the *Ref.
-        let TraitItemRef { id, ident: _, kind: _, span: _ } = *ii;
+        let TraitItemRef { id, ident: _, span: _ } = *ii;
 
         self.visit_nested_trait_item(id);
     }
@@ -392,7 +392,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
     fn visit_impl_item_ref(&mut self, ii: &'hir ImplItemRef) {
         // Do not visit the duplicate information in ImplItemRef. We want to
         // map the actual nodes, not the duplicate ones in the *Ref.
-        let ImplItemRef { id, ident: _, kind: _, span: _ } = *ii;
+        let ImplItemRef { id, ident: _, span: _ } = *ii;
 
         self.visit_nested_impl_item(id);
     }
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index b2a69c7c00f..5043995e6b9 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -393,11 +393,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         (trait_ref, lowered_ty)
                     });
 
-                let new_impl_items = self.arena.alloc_from_iter(
-                    impl_items
-                        .iter()
-                        .map(|item| self.lower_impl_item_ref(item, trait_ref.is_some())),
-                );
+                let new_impl_items = self
+                    .arena
+                    .alloc_from_iter(impl_items.iter().map(|item| self.lower_impl_item_ref(item)));
 
                 // `defaultness.has_value()` is never called for an `impl`, always `true` in order
                 // to not cause an assertion failure inside the `lower_defaultness` function.
@@ -973,30 +971,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_trait_item_ref(&mut self, i: &AssocItem) -> hir::TraitItemRef {
-        let (ident, kind) = match &i.kind {
-            AssocItemKind::Const(box ConstItem { ident, .. }) => {
-                (*ident, hir::AssocItemKind::Const)
-            }
-            AssocItemKind::Type(box TyAlias { ident, .. }) => (*ident, hir::AssocItemKind::Type),
-            AssocItemKind::Fn(box Fn { ident, sig, .. }) => {
-                (*ident, hir::AssocItemKind::Fn { has_self: sig.decl.has_self() })
-            }
-            AssocItemKind::Delegation(box delegation) => (
-                delegation.ident,
-                hir::AssocItemKind::Fn {
-                    has_self: self.delegatee_is_method(i.id, delegation.id, i.span, false),
-                },
-            ),
-            AssocItemKind::MacCall(..) | AssocItemKind::DelegationMac(..) => {
-                panic!("macros should have been expanded by now")
-            }
-        };
         let id = hir::TraitItemId { owner_id: self.owner_id(i.id) };
         hir::TraitItemRef {
             id,
-            ident: self.lower_ident(ident),
+            ident: self.lower_ident(i.kind.ident().unwrap()),
             span: self.lower_span(i.span),
-            kind,
         }
     }
 
@@ -1137,31 +1116,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.arena.alloc(item)
     }
 
-    fn lower_impl_item_ref(&mut self, i: &AssocItem, is_in_trait_impl: bool) -> hir::ImplItemRef {
+    fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemRef {
         hir::ImplItemRef {
             id: hir::ImplItemId { owner_id: self.owner_id(i.id) },
             // `unwrap` is safe because `AssocItemKind::{MacCall,DelegationMac}` are the only
             // assoc item kinds without an identifier and they cannot reach here.
             ident: self.lower_ident(i.kind.ident().unwrap()),
             span: self.lower_span(i.span),
-            kind: match &i.kind {
-                AssocItemKind::Const(..) => hir::AssocItemKind::Const,
-                AssocItemKind::Type(..) => hir::AssocItemKind::Type,
-                AssocItemKind::Fn(box Fn { sig, .. }) => {
-                    hir::AssocItemKind::Fn { has_self: sig.decl.has_self() }
-                }
-                AssocItemKind::Delegation(box delegation) => hir::AssocItemKind::Fn {
-                    has_self: self.delegatee_is_method(
-                        i.id,
-                        delegation.id,
-                        i.span,
-                        is_in_trait_impl,
-                    ),
-                },
-                AssocItemKind::MacCall(..) | AssocItemKind::DelegationMac(..) => {
-                    panic!("macros should have been expanded by now")
-                }
-            },
         }
     }
 
diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index 7c69baba62e..a06540f8325 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -681,46 +681,30 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             return (false, false, None);
         }
         let my_def = self.body.source.def_id();
-        let my_hir = self.infcx.tcx.local_def_id_to_hir_id(my_def.as_local().unwrap());
         let Some(td) =
             self.infcx.tcx.impl_of_method(my_def).and_then(|x| self.infcx.tcx.trait_id_of_impl(x))
         else {
             return (false, false, None);
         };
+
+        let implemented_trait_item = self.infcx.tcx.associated_item(my_def).trait_item_def_id;
+
         (
             true,
             td.is_local(),
-            td.as_local().and_then(|tld| match self.infcx.tcx.hir_node_by_def_id(tld) {
-                Node::Item(hir::Item {
-                    kind: hir::ItemKind::Trait(_, _, _, _, _, items), ..
-                }) => {
-                    let mut f_in_trait_opt = None;
-                    for hir::TraitItemRef { id: fi, kind: k, .. } in *items {
-                        let hi = fi.hir_id();
-                        if !matches!(k, hir::AssocItemKind::Fn { .. }) {
-                            continue;
-                        }
-                        if self.infcx.tcx.hir_name(hi) != self.infcx.tcx.hir_name(my_hir) {
-                            continue;
-                        }
-                        f_in_trait_opt = Some(hi);
-                        break;
-                    }
-                    f_in_trait_opt.and_then(|f_in_trait| {
-                        if let Node::TraitItem(ti) = self.infcx.tcx.hir_node(f_in_trait)
-                            && let hir::TraitItemKind::Fn(sig, _) = ti.kind
-                            && let Some(ty) = sig.decl.inputs.get(local.index() - 1)
-                            && let hir::TyKind::Ref(_, mut_ty) = ty.kind
-                            && let hir::Mutability::Not = mut_ty.mutbl
-                            && sig.decl.implicit_self.has_implicit_self()
-                        {
-                            Some(ty.span)
-                        } else {
-                            None
-                        }
-                    })
+            implemented_trait_item.and_then(|f_in_trait| {
+                let f_in_trait = f_in_trait.as_local()?;
+                if let Node::TraitItem(ti) = self.infcx.tcx.hir_node_by_def_id(f_in_trait)
+                    && let hir::TraitItemKind::Fn(sig, _) = ti.kind
+                    && let Some(ty) = sig.decl.inputs.get(local.index() - 1)
+                    && let hir::TyKind::Ref(_, mut_ty) = ty.kind
+                    && let hir::Mutability::Not = mut_ty.mutbl
+                    && sig.decl.implicit_self.has_implicit_self()
+                {
+                    Some(ty.span)
+                } else {
+                    None
                 }
-                _ => None,
             }),
         )
     }
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index c57a8e648fb..8531003c6ac 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -4415,7 +4415,6 @@ impl ItemKind<'_> {
 pub struct TraitItemRef {
     pub id: TraitItemId,
     pub ident: Ident,
-    pub kind: AssocItemKind,
     pub span: Span,
 }
 
@@ -4429,17 +4428,9 @@ pub struct TraitItemRef {
 pub struct ImplItemRef {
     pub id: ImplItemId,
     pub ident: Ident,
-    pub kind: AssocItemKind,
     pub span: Span,
 }
 
-#[derive(Copy, Clone, PartialEq, Debug, HashStable_Generic)]
-pub enum AssocItemKind {
-    Const,
-    Fn { has_self: bool },
-    Type,
-}
-
 // The bodies for items are stored "out of line", in a separate
 // hashmap in the `Crate`. Here we just record the hir-id of the item
 // so it can fetched later.
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index c40a6b081ef..e5a60fb5d31 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -499,9 +499,6 @@ pub trait Visitor<'v>: Sized {
     fn visit_attribute(&mut self, _attr: &'v Attribute) -> Self::Result {
         Self::Result::output()
     }
-    fn visit_associated_item_kind(&mut self, kind: &'v AssocItemKind) -> Self::Result {
-        walk_associated_item_kind(self, kind)
-    }
     fn visit_defaultness(&mut self, defaultness: &'v Defaultness) -> Self::Result {
         walk_defaultness(self, defaultness)
     }
@@ -1252,10 +1249,9 @@ pub fn walk_trait_item_ref<'v, V: Visitor<'v>>(
     visitor: &mut V,
     trait_item_ref: &'v TraitItemRef,
 ) -> V::Result {
-    let TraitItemRef { id, ident, ref kind, span: _ } = *trait_item_ref;
+    let TraitItemRef { id, ident, span: _ } = *trait_item_ref;
     try_visit!(visitor.visit_nested_trait_item(id));
-    try_visit!(visitor.visit_ident(ident));
-    visitor.visit_associated_item_kind(kind)
+    visitor.visit_ident(ident)
 }
 
 pub fn walk_impl_item<'v, V: Visitor<'v>>(
@@ -1307,10 +1303,9 @@ pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(
     visitor: &mut V,
     impl_item_ref: &'v ImplItemRef,
 ) -> V::Result {
-    let ImplItemRef { id, ident, ref kind, span: _ } = *impl_item_ref;
+    let ImplItemRef { id, ident, span: _ } = *impl_item_ref;
     try_visit!(visitor.visit_nested_impl_item(id));
-    try_visit!(visitor.visit_ident(ident));
-    visitor.visit_associated_item_kind(kind)
+    visitor.visit_ident(ident)
 }
 
 pub fn walk_trait_ref<'v, V: Visitor<'v>>(
@@ -1484,13 +1479,6 @@ pub fn walk_assoc_item_constraint<'v, V: Visitor<'v>>(
     V::Result::output()
 }
 
-pub fn walk_associated_item_kind<'v, V: Visitor<'v>>(_: &mut V, _: &'v AssocItemKind) -> V::Result {
-    // No visitable content here: this fn exists so you can call it if
-    // the right thing to do, should content be added in the future,
-    // would be to walk it.
-    V::Result::output()
-}
-
 pub fn walk_defaultness<'v, V: Visitor<'v>>(_: &mut V, _: &'v Defaultness) -> V::Result {
     // No visitable content here: this fn exists so you can call it if
     // the right thing to do, should content be added in the future,
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 431d99a572d..50b0146d80c 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -914,7 +914,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
                 let item = items.iter().find(|item| item.ident == *ident);
 
                 match item {
-                    Some(item) if matches!(item.kind, hir::AssocItemKind::Fn { .. }) => {
+                    Some(item) if matches!(tcx.def_kind(item.id.owner_id), DefKind::AssocFn) => {
                         if !tcx.defaultness(item.id.owner_id).has_value() {
                             tcx.dcx().emit_err(errors::FunctionNotHaveDefaultImplementation {
                                 span: item.span,
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 172f3372483..255ff56f62b 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -28,7 +28,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
 use rustc_hir::intravisit::FnKind as HirFnKind;
-use rustc_hir::{Body, FnDecl, GenericParamKind, PatKind, PredicateOrigin};
+use rustc_hir::{Body, FnDecl, PatKind, PredicateOrigin};
 use rustc_middle::bug;
 use rustc_middle::lint::LevelAndSource;
 use rustc_middle::ty::layout::LayoutOf;
@@ -952,36 +952,34 @@ declare_lint! {
 
 declare_lint_pass!(InvalidNoMangleItems => [NO_MANGLE_CONST_ITEMS, NO_MANGLE_GENERIC_ITEMS]);
 
+impl InvalidNoMangleItems {
+    fn check_no_mangle_on_generic_fn(
+        &self,
+        cx: &LateContext<'_>,
+        attr_span: Span,
+        def_id: LocalDefId,
+    ) {
+        let generics = cx.tcx.generics_of(def_id);
+        if generics.requires_monomorphization(cx.tcx) {
+            cx.emit_span_lint(
+                NO_MANGLE_GENERIC_ITEMS,
+                cx.tcx.def_span(def_id),
+                BuiltinNoMangleGeneric { suggestion: attr_span },
+            );
+        }
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for InvalidNoMangleItems {
     fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {
         let attrs = cx.tcx.hir_attrs(it.hir_id());
-        let check_no_mangle_on_generic_fn = |attr_span: Span,
-                                             impl_generics: Option<&hir::Generics<'_>>,
-                                             generics: &hir::Generics<'_>,
-                                             span| {
-            for param in
-                generics.params.iter().chain(impl_generics.map(|g| g.params).into_iter().flatten())
-            {
-                match param.kind {
-                    GenericParamKind::Lifetime { .. } => {}
-                    GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => {
-                        cx.emit_span_lint(
-                            NO_MANGLE_GENERIC_ITEMS,
-                            span,
-                            BuiltinNoMangleGeneric { suggestion: attr_span },
-                        );
-                        break;
-                    }
-                }
-            }
-        };
         match it.kind {
-            hir::ItemKind::Fn { generics, .. } => {
+            hir::ItemKind::Fn { .. } => {
                 if let Some(attr_span) =
                     find_attr!(attrs, AttributeKind::ExportName {span, ..} => *span)
                         .or_else(|| find_attr!(attrs, AttributeKind::NoMangle(span) => *span))
                 {
-                    check_no_mangle_on_generic_fn(attr_span, None, generics, it.span);
+                    self.check_no_mangle_on_generic_fn(cx, attr_span, it.owner_id.def_id);
                 }
             }
             hir::ItemKind::Const(..) => {
@@ -1006,24 +1004,19 @@ impl<'tcx> LateLintPass<'tcx> for InvalidNoMangleItems {
                     );
                 }
             }
-            hir::ItemKind::Impl(hir::Impl { generics, items, .. }) => {
-                for it in *items {
-                    if let hir::AssocItemKind::Fn { .. } = it.kind {
-                        let attrs = cx.tcx.hir_attrs(it.id.hir_id());
-                        if let Some(attr_span) =
-                            find_attr!(attrs, AttributeKind::ExportName {span, ..} => *span)
-                                .or_else(
-                                    || find_attr!(attrs, AttributeKind::NoMangle(span) => *span),
-                                )
-                        {
-                            check_no_mangle_on_generic_fn(
-                                attr_span,
-                                Some(generics),
-                                cx.tcx.hir_get_generics(it.id.owner_id.def_id).unwrap(),
-                                it.span,
-                            );
-                        }
-                    }
+            _ => {}
+        }
+    }
+
+    fn check_impl_item(&mut self, cx: &LateContext<'_>, it: &hir::ImplItem<'_>) {
+        let attrs = cx.tcx.hir_attrs(it.hir_id());
+        match it.kind {
+            hir::ImplItemKind::Fn { .. } => {
+                if let Some(attr_span) =
+                    find_attr!(attrs, AttributeKind::ExportName {span, ..} => *span)
+                        .or_else(|| find_attr!(attrs, AttributeKind::NoMangle(span) => *span))
+                {
+                    self.check_no_mangle_on_generic_fn(cx, attr_span, it.owner_id.def_id);
                 }
             }
             _ => {}
diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs
index 9534d45e495..1d15e4de7b6 100644
--- a/compiler/rustc_middle/src/ty/assoc.rs
+++ b/compiler/rustc_middle/src/ty/assoc.rs
@@ -257,6 +257,16 @@ impl AssocItems {
         self.items.get_by_key(Some(name))
     }
 
+    /// Returns the associated item with the given identifier and `AssocKind`, if one exists.
+    /// The identifier is ignoring hygiene. This is meant to be used for lints and diagnostics.
+    pub fn filter_by_name_unhygienic_and_kind(
+        &self,
+        name: Symbol,
+        assoc_tag: AssocTag,
+    ) -> impl '_ + Iterator<Item = &ty::AssocItem> {
+        self.filter_by_name_unhygienic(name).filter(move |item| item.as_tag() == assoc_tag)
+    }
+
     /// Returns the associated item with the given identifier and `AssocKind`, if one exists.
     /// The identifier is matched hygienically.
     pub fn find_by_ident_and_kind(
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 9a96749f3e7..38f82de9184 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -20,8 +20,8 @@ use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalModDefId;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{
-    self as hir, self, AssocItemKind, Attribute, CRATE_HIR_ID, CRATE_OWNER_ID, FnSig, ForeignItem,
-    HirId, Item, ItemKind, MethodKind, Safety, Target, TraitItem,
+    self as hir, self, Attribute, CRATE_HIR_ID, CRATE_OWNER_ID, FnSig, ForeignItem, HirId, Item,
+    ItemKind, MethodKind, Safety, Target, TraitItem,
 };
 use rustc_macros::LintDiagnostic;
 use rustc_middle::hir::nested_filter;
@@ -1151,7 +1151,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 if generics.params.len() != 0 => {}
             ItemKind::Trait(_, _, _, generics, _, items)
                 if generics.params.len() != 0
-                    || items.iter().any(|item| matches!(item.kind, AssocItemKind::Type)) => {}
+                    || items.iter().any(|item| {
+                        matches!(self.tcx.def_kind(item.id.owner_id), DefKind::AssocTy)
+                    }) => {}
             ItemKind::TyAlias(_, generics, _) if generics.params.len() != 0 => {}
             _ => {
                 self.dcx().emit_err(errors::DocSearchUnboxInvalid { span: meta.span() });
diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
index cdfd1a2b07e..1fd7cc25524 100644
--- a/compiler/rustc_passes/src/dead.rs
+++ b/compiler/rustc_passes/src/dead.rs
@@ -415,7 +415,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
                 hir::ItemKind::Trait(.., trait_item_refs) => {
                     // mark assoc ty live if the trait is live
                     for trait_item in trait_item_refs {
-                        if matches!(trait_item.kind, hir::AssocItemKind::Type) {
+                        if matches!(self.tcx.def_kind(trait_item.id.owner_id), DefKind::AssocTy) {
                             self.check_def_id(trait_item.id.owner_id.to_def_id());
                         }
                     }
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index 963f4c77d80..a7453a659c9 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -26,7 +26,7 @@ use rustc_errors::{MultiSpan, listify};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId, LocalModDefId};
 use rustc_hir::intravisit::{self, InferKind, Visitor};
-use rustc_hir::{AmbigArg, AssocItemKind, ForeignItemKind, ItemId, ItemKind, PatKind};
+use rustc_hir::{AmbigArg, ForeignItemKind, ItemId, ItemKind, PatKind};
 use rustc_middle::middle::privacy::{EffectiveVisibilities, EffectiveVisibility, Level};
 use rustc_middle::query::Providers;
 use rustc_middle::ty::print::PrintTraitRefExt as _;
@@ -678,7 +678,7 @@ impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
                         let mut reach = self.reach(trait_item_ref.id.owner_id.def_id, item_ev);
                         reach.generics().predicates();
 
-                        if trait_item_ref.kind == AssocItemKind::Type
+                        if let DefKind::AssocTy = tcx.def_kind(trait_item_ref.id.owner_id)
                             && !tcx.defaultness(trait_item_ref.id.owner_id).has_value()
                         {
                             // No type to visit.
@@ -1576,16 +1576,15 @@ impl<'tcx> PrivateItemsInPublicInterfacesChecker<'_, 'tcx> {
 
     fn check_assoc_item(
         &self,
-        def_id: LocalDefId,
-        assoc_item_kind: AssocItemKind,
+        item: &ty::AssocItem,
         vis: ty::Visibility,
         effective_vis: Option<EffectiveVisibility>,
     ) {
-        let mut check = self.check(def_id, vis, effective_vis);
+        let mut check = self.check(item.def_id.expect_local(), vis, effective_vis);
 
-        let (check_ty, is_assoc_ty) = match assoc_item_kind {
-            AssocItemKind::Const | AssocItemKind::Fn { .. } => (true, false),
-            AssocItemKind::Type => (self.tcx.defaultness(def_id).has_value(), true),
+        let (check_ty, is_assoc_ty) = match item.kind {
+            ty::AssocKind::Const { .. } | ty::AssocKind::Fn { .. } => (true, false),
+            ty::AssocKind::Type { .. } => (item.defaultness(self.tcx).has_value(), true),
         };
 
         check.in_assoc_ty = is_assoc_ty;
@@ -1619,30 +1618,20 @@ impl<'tcx> PrivateItemsInPublicInterfacesChecker<'_, 'tcx> {
                 self.check(def_id, item_visibility, effective_vis).generics().bounds();
             }
             DefKind::Trait => {
-                let item = tcx.hir_item(id);
-                if let hir::ItemKind::Trait(.., trait_item_refs) = item.kind {
-                    self.check_unnameable(item.owner_id.def_id, effective_vis);
+                self.check_unnameable(def_id, effective_vis);
 
-                    self.check(item.owner_id.def_id, item_visibility, effective_vis)
-                        .generics()
-                        .predicates();
+                self.check(def_id, item_visibility, effective_vis).generics().predicates();
 
-                    for trait_item_ref in trait_item_refs {
-                        self.check_assoc_item(
-                            trait_item_ref.id.owner_id.def_id,
-                            trait_item_ref.kind,
+                for assoc_item in tcx.associated_items(id.owner_id).in_definition_order() {
+                    self.check_assoc_item(assoc_item, item_visibility, effective_vis);
+
+                    if assoc_item.is_type() {
+                        self.check(
+                            assoc_item.def_id.expect_local(),
                             item_visibility,
                             effective_vis,
-                        );
-
-                        if let AssocItemKind::Type = trait_item_ref.kind {
-                            self.check(
-                                trait_item_ref.id.owner_id.def_id,
-                                item_visibility,
-                                effective_vis,
-                            )
-                            .bounds();
-                        }
+                        )
+                        .bounds();
                     }
                 }
             }
@@ -1714,69 +1703,52 @@ impl<'tcx> PrivateItemsInPublicInterfacesChecker<'_, 'tcx> {
             // Subitems of inherent impls have their own publicity.
             // A trait impl is public when both its type and its trait are public
             // Subitems of trait impls have inherited publicity.
-            DefKind::Impl { .. } => {
-                let item = tcx.hir_item(id);
-                if let hir::ItemKind::Impl(impl_) = item.kind {
-                    let impl_vis = ty::Visibility::of_impl::<false>(
-                        item.owner_id.def_id,
-                        tcx,
-                        &Default::default(),
-                    );
+            DefKind::Impl { of_trait } => {
+                let impl_vis = ty::Visibility::of_impl::<false>(def_id, tcx, &Default::default());
 
-                    // We are using the non-shallow version here, unlike when building the
-                    // effective visisibilities table to avoid large number of false positives.
-                    // For example in
-                    //
-                    // impl From<Priv> for Pub {
-                    //     fn from(_: Priv) -> Pub {...}
-                    // }
-                    //
-                    // lints shouldn't be emitted even if `from` effective visibility
-                    // is larger than `Priv` nominal visibility and if `Priv` can leak
-                    // in some scenarios due to type inference.
-                    let impl_ev = EffectiveVisibility::of_impl::<false>(
-                        item.owner_id.def_id,
-                        tcx,
-                        self.effective_visibilities,
-                    );
+                // We are using the non-shallow version here, unlike when building the
+                // effective visisibilities table to avoid large number of false positives.
+                // For example in
+                //
+                // impl From<Priv> for Pub {
+                //     fn from(_: Priv) -> Pub {...}
+                // }
+                //
+                // lints shouldn't be emitted even if `from` effective visibility
+                // is larger than `Priv` nominal visibility and if `Priv` can leak
+                // in some scenarios due to type inference.
+                let impl_ev =
+                    EffectiveVisibility::of_impl::<false>(def_id, tcx, self.effective_visibilities);
+
+                let mut check = self.check(def_id, impl_vis, Some(impl_ev));
+
+                // Generics and predicates of trait impls are intentionally not checked
+                // for private components (#90586).
+                if !of_trait {
+                    check.generics().predicates();
+                }
 
-                    let mut check = self.check(item.owner_id.def_id, impl_vis, Some(impl_ev));
-                    // Generics and predicates of trait impls are intentionally not checked
-                    // for private components (#90586).
-                    if impl_.of_trait.is_none() {
-                        check.generics().predicates();
-                    }
-                    // Skip checking private components in associated types, due to lack of full
-                    // normalization they produce very ridiculous false positives.
-                    // FIXME: Remove this when full normalization is implemented.
-                    check.skip_assoc_tys = true;
-                    check.ty().trait_ref();
-
-                    for impl_item_ref in impl_.items {
-                        let impl_item_vis = if impl_.of_trait.is_none() {
-                            min(
-                                tcx.local_visibility(impl_item_ref.id.owner_id.def_id),
-                                impl_vis,
-                                tcx,
-                            )
-                        } else {
-                            impl_vis
-                        };
+                // Skip checking private components in associated types, due to lack of full
+                // normalization they produce very ridiculous false positives.
+                // FIXME: Remove this when full normalization is implemented.
+                check.skip_assoc_tys = true;
+                check.ty().trait_ref();
 
-                        let impl_item_ev = if impl_.of_trait.is_none() {
-                            self.get(impl_item_ref.id.owner_id.def_id)
-                                .map(|ev| ev.min(impl_ev, self.tcx))
-                        } else {
-                            Some(impl_ev)
-                        };
-
-                        self.check_assoc_item(
-                            impl_item_ref.id.owner_id.def_id,
-                            impl_item_ref.kind,
-                            impl_item_vis,
-                            impl_item_ev,
-                        );
-                    }
+                for assoc_item in tcx.associated_items(id.owner_id).in_definition_order() {
+                    let impl_item_vis = if !of_trait {
+                        min(tcx.local_visibility(assoc_item.def_id.expect_local()), impl_vis, tcx)
+                    } else {
+                        impl_vis
+                    };
+
+                    let impl_item_ev = if !of_trait {
+                        self.get(assoc_item.def_id.expect_local())
+                            .map(|ev| ev.min(impl_ev, self.tcx))
+                    } else {
+                        Some(impl_ev)
+                    };
+
+                    self.check_assoc_item(assoc_item, impl_item_vis, impl_item_ev);
                 }
             }
             _ => {}
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 bff5e9128cb..db35c988bf7 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
@@ -841,54 +841,32 @@ fn foo(&self) -> Self::T { String::new() }
 
         let param_env = tcx.param_env(body_owner_def_id);
 
-        match item {
-            hir::Node::Item(hir::Item { kind: hir::ItemKind::Trait(.., items), .. }) => {
-                // FIXME: account for `#![feature(specialization)]`
-                for item in &items[..] {
-                    match item.kind {
-                        hir::AssocItemKind::Type => {
-                            // FIXME: account for returning some type in a trait fn impl that has
-                            // an assoc type as a return type (#72076).
-                            if let hir::Defaultness::Default { has_value: true } =
-                                tcx.defaultness(item.id.owner_id)
-                            {
-                                let assoc_ty = tcx.type_of(item.id.owner_id).instantiate_identity();
-                                if self.infcx.can_eq(param_env, assoc_ty, found) {
-                                    diag.span_label(
-                                        item.span,
-                                        "associated type defaults can't be assumed inside the \
-                                            trait defining them",
-                                    );
-                                    return true;
-                                }
-                            }
+        if let DefKind::Trait | DefKind::Impl { .. } = tcx.def_kind(parent_id) {
+            let assoc_items = tcx.associated_items(parent_id);
+            // FIXME: account for `#![feature(specialization)]`
+            for assoc_item in assoc_items.in_definition_order() {
+                if assoc_item.is_type()
+                    // FIXME: account for returning some type in a trait fn impl that has
+                    // an assoc type as a return type (#72076).
+                    && let hir::Defaultness::Default { has_value: true } = assoc_item.defaultness(tcx)
+                    && let assoc_ty = tcx.type_of(assoc_item.def_id).instantiate_identity()
+                    && self.infcx.can_eq(param_env, assoc_ty, found)
+                {
+                    let msg = match assoc_item.container {
+                        ty::AssocItemContainer::Trait => {
+                            "associated type defaults can't be assumed inside the \
+                                            trait defining them"
                         }
-                        _ => {}
-                    }
-                }
-            }
-            hir::Node::Item(hir::Item {
-                kind: hir::ItemKind::Impl(hir::Impl { items, .. }),
-                ..
-            }) => {
-                for item in &items[..] {
-                    if let hir::AssocItemKind::Type = item.kind {
-                        let assoc_ty = tcx.type_of(item.id.owner_id).instantiate_identity();
-                        if let hir::Defaultness::Default { has_value: true } =
-                            tcx.defaultness(item.id.owner_id)
-                            && self.infcx.can_eq(param_env, assoc_ty, found)
-                        {
-                            diag.span_label(
-                                item.span,
-                                "associated type is `default` and may be overridden",
-                            );
-                            return true;
+                        ty::AssocItemContainer::Impl => {
+                            "associated type is `default` and may be overridden"
                         }
-                    }
+                    };
+                    diag.span_label(tcx.def_span(assoc_item.def_id), msg);
+                    return true;
                 }
             }
-            _ => {}
         }
+
         false
     }
 
diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index d27f749762f..fecc56091b9 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -154,7 +154,7 @@ fn associated_types_for_impl_traits_in_trait_or_impl<'tcx>(
         ItemKind::Trait(.., trait_item_refs) => trait_item_refs
             .iter()
             .filter_map(move |item| {
-                if !matches!(item.kind, hir::AssocItemKind::Fn { .. }) {
+                if !matches!(tcx.def_kind(item.id.owner_id), DefKind::AssocFn) {
                     return None;
                 }
                 let fn_def_id = item.id.owner_id.def_id;
@@ -185,7 +185,7 @@ fn associated_types_for_impl_traits_in_trait_or_impl<'tcx>(
                 .items
                 .iter()
                 .filter_map(|item| {
-                    if !matches!(item.kind, hir::AssocItemKind::Fn { .. }) {
+                    if !matches!(tcx.def_kind(item.id.owner_id), DefKind::AssocFn) {
                         return None;
                     }
                     let did = item.id.owner_id.def_id.to_def_id();
diff --git a/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs b/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs
index 8b6bfaebbe5..ee8da707a80 100644
--- a/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs
+++ b/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs
@@ -8,9 +8,10 @@ use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::is_cfg_test;
 use rustc_attr_data_structures::AttributeKind;
 use rustc_hir::{
-    AssocItemKind, Attribute, FieldDef, HirId, ImplItemRef, IsAuto, Item, ItemKind, Mod, QPath, TraitItemRef, TyKind,
+    Attribute, FieldDef, HirId, ImplItemRef, IsAuto, Item, ItemKind, Mod, OwnerId, QPath, TraitItemRef, TyKind,
     Variant, VariantData,
 };
+use rustc_middle::ty::AssocKind;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
 
@@ -315,9 +316,9 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
                     }
 
                     if let Some(cur_t) = cur_t {
-                        let cur_t_kind = convert_assoc_item_kind(cur_t.kind);
+                        let cur_t_kind = convert_assoc_item_kind(cx, cur_t.id.owner_id);
                         let cur_t_kind_index = self.assoc_types_order.index_of(&cur_t_kind);
-                        let item_kind = convert_assoc_item_kind(item.kind);
+                        let item_kind = convert_assoc_item_kind(cx,item.id.owner_id);
                         let item_kind_index = self.assoc_types_order.index_of(&item_kind);
 
                         if cur_t_kind == item_kind && cur_t.ident.name.as_str() > item.ident.name.as_str() {
@@ -338,9 +339,9 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
                     }
 
                     if let Some(cur_t) = cur_t {
-                        let cur_t_kind = convert_assoc_item_kind(cur_t.kind);
+                        let cur_t_kind = convert_assoc_item_kind(cx, cur_t.id.owner_id);
                         let cur_t_kind_index = self.assoc_types_order.index_of(&cur_t_kind);
-                        let item_kind = convert_assoc_item_kind(item.kind);
+                        let item_kind = convert_assoc_item_kind(cx, item.id.owner_id);
                         let item_kind_index = self.assoc_types_order.index_of(&item_kind);
 
                         if cur_t_kind == item_kind && cur_t.ident.name.as_str() > item.ident.name.as_str() {
@@ -458,18 +459,19 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
     }
 }
 
-/// Converts a [`rustc_hir::AssocItemKind`] to a
-/// [`SourceItemOrderingTraitAssocItemKind`].
+/// Converts a [`ty::AssocKind`] to a [`SourceItemOrderingTraitAssocItemKind`].
 ///
 /// This is implemented here because `rustc_hir` is not a dependency of
 /// `clippy_config`.
-fn convert_assoc_item_kind(value: AssocItemKind) -> SourceItemOrderingTraitAssocItemKind {
+fn convert_assoc_item_kind(cx: &LateContext<'_>, owner_id: OwnerId) -> SourceItemOrderingTraitAssocItemKind {
+    let kind = cx.tcx.associated_item(owner_id.def_id).kind;
+
     #[allow(clippy::enum_glob_use)] // Very local glob use for legibility.
     use SourceItemOrderingTraitAssocItemKind::*;
-    match value {
-        AssocItemKind::Const => Const,
-        AssocItemKind::Type => Type,
-        AssocItemKind::Fn { .. } => Fn,
+    match kind {
+        AssocKind::Const{..} => Const,
+        AssocKind::Type {..}=> Type,
+        AssocKind::Fn { .. } => Fn,
     }
 }
 
diff --git a/src/tools/clippy/clippy_lints/src/escape.rs b/src/tools/clippy/clippy_lints/src/escape.rs
index 2cb3b32babe..db2fea1aae9 100644
--- a/src/tools/clippy/clippy_lints/src/escape.rs
+++ b/src/tools/clippy/clippy_lints/src/escape.rs
@@ -1,7 +1,8 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_hir;
 use rustc_abi::ExternAbi;
-use rustc_hir::{AssocItemKind, Body, FnDecl, HirId, HirIdSet, Impl, ItemKind, Node, Pat, PatKind, intravisit};
+use rustc_hir::{Body, FnDecl, HirId, HirIdSet, Node, Pat, PatKind, intravisit};
+use rustc_hir::def::DefKind;
 use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir::FakeReadCause;
@@ -84,23 +85,18 @@ impl<'tcx> LateLintPass<'tcx> for BoxedLocal {
             .def_id;
 
         let mut trait_self_ty = None;
-        if let Node::Item(item) = cx.tcx.hir_node_by_def_id(parent_id) {
+        match cx.tcx.def_kind(parent_id) {
             // If the method is an impl for a trait, don't warn.
-            if let ItemKind::Impl(Impl { of_trait: Some(_), .. }) = item.kind {
-                return;
+            DefKind::Impl { of_trait: true } => {
+                return
             }
 
             // find `self` ty for this trait if relevant
-            if let ItemKind::Trait(_, _, _, _, _, items) = item.kind {
-                for trait_item in items {
-                    if trait_item.id.owner_id.def_id == fn_def_id
-                        // be sure we have `self` parameter in this function
-                        && trait_item.kind == (AssocItemKind::Fn { has_self: true })
-                    {
-                        trait_self_ty = Some(TraitRef::identity(cx.tcx, trait_item.id.owner_id.to_def_id()).self_ty());
-                    }
-                }
+            DefKind::Trait => {
+                trait_self_ty = Some(TraitRef::identity(cx.tcx, parent_id.to_def_id()).self_ty());
             }
+
+            _ => {}
         }
 
         let mut v = EscapeDelegate {
diff --git a/src/tools/clippy/clippy_lints/src/functions/renamed_function_params.rs b/src/tools/clippy/clippy_lints/src/functions/renamed_function_params.rs
index 2d22bb157a9..0d6191f2c97 100644
--- a/src/tools/clippy/clippy_lints/src/functions/renamed_function_params.rs
+++ b/src/tools/clippy/clippy_lints/src/functions/renamed_function_params.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::{Applicability, MultiSpan};
 use rustc_hir::def_id::{DefId, DefIdSet};
 use rustc_hir::hir_id::OwnerId;
-use rustc_hir::{Impl, ImplItem, ImplItemKind, ImplItemRef, ItemKind, Node, TraitRef};
+use rustc_hir::{Impl, ImplItem, ImplItemKind, ItemKind, Node, TraitRef};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 use rustc_span::symbol::{Ident, kw};
@@ -15,11 +15,10 @@ pub(super) fn check_impl_item(cx: &LateContext<'_>, item: &ImplItem<'_>, ignored
         && let parent_node = cx.tcx.parent_hir_node(item.hir_id())
         && let Node::Item(parent_item) = parent_node
         && let ItemKind::Impl(Impl {
-            items,
             of_trait: Some(trait_ref),
             ..
         }) = &parent_item.kind
-        && let Some(did) = trait_item_def_id_of_impl(items, item.owner_id)
+        && let Some(did) = trait_item_def_id_of_impl(cx, item.owner_id)
         && !is_from_ignored_trait(trait_ref, ignored_traits)
     {
         let mut param_idents_iter = cx.tcx.hir_body_param_idents(body_id);
@@ -93,14 +92,8 @@ impl RenamedFnArgs {
 }
 
 /// Get the [`trait_item_def_id`](ImplItemRef::trait_item_def_id) of a relevant impl item.
-fn trait_item_def_id_of_impl(items: &[ImplItemRef], target: OwnerId) -> Option<DefId> {
-    items.iter().find_map(|item| {
-        if item.id.owner_id == target {
-            item.trait_item_def_id
-        } else {
-            None
-        }
-    })
+fn trait_item_def_id_of_impl(cx: &LateContext<'_>, target: OwnerId) -> Option<DefId> {
+    cx.tcx.associated_item(target).trait_item_def_id
 }
 
 fn is_from_ignored_trait(of_trait: &TraitRef<'_>, ignored_traits: &DefIdSet) -> bool {
diff --git a/src/tools/clippy/clippy_lints/src/infallible_try_from.rs b/src/tools/clippy/clippy_lints/src/infallible_try_from.rs
index b54c289fa7e..e79fcec6e6a 100644
--- a/src/tools/clippy/clippy_lints/src/infallible_try_from.rs
+++ b/src/tools/clippy/clippy_lints/src/infallible_try_from.rs
@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::sym;
 use rustc_errors::MultiSpan;
-use rustc_hir::{AssocItemKind, Item, ItemKind};
+use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::AssocTag;
 use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
@@ -51,25 +52,23 @@ impl<'tcx> LateLintPass<'tcx> for InfallibleTryFrom {
         if !cx.tcx.is_diagnostic_item(sym::TryFrom, trait_def_id) {
             return;
         }
-        for ii in imp.items {
-            if ii.kind == AssocItemKind::Type {
-                let ii = cx.tcx.hir_impl_item(ii.id);
-                if ii.ident.name != sym::Error {
-                    continue;
-                }
-                let ii_ty = ii.expect_type();
-                let ii_ty_span = ii_ty.span;
-                let ii_ty = clippy_utils::ty::ty_from_hir_ty(cx, ii_ty);
-                if !ii_ty.is_inhabited_from(cx.tcx, ii.owner_id.to_def_id(), cx.typing_env()) {
-                    let mut span = MultiSpan::from_span(cx.tcx.def_span(item.owner_id.to_def_id()));
-                    span.push_span_label(ii_ty_span, "infallible error type");
-                    span_lint(
-                        cx,
-                        INFALLIBLE_TRY_FROM,
-                        span,
-                        "infallible TryFrom impl; consider implementing From, instead",
-                    );
-                }
+        for ii in cx.tcx.associated_items(item.owner_id.def_id)
+            .filter_by_name_unhygienic_and_kind(sym::Error, AssocTag::Type)
+        {
+            let ii_ty = cx.tcx.type_of(ii.def_id).instantiate_identity();
+            if !ii_ty.is_inhabited_from(cx.tcx, ii.def_id, cx.typing_env()) {
+                let mut span = MultiSpan::from_span(cx.tcx.def_span(item.owner_id.to_def_id()));
+                let ii_ty_span = cx.tcx.hir_node_by_def_id(ii.def_id.expect_local())
+                    .expect_impl_item()
+                    .expect_type()
+                    .span;
+                span.push_span_label(ii_ty_span, "infallible error type");
+                span_lint(
+                    cx,
+                    INFALLIBLE_TRY_FROM,
+                    span,
+                    "infallible TryFrom impl; consider implementing From, instead",
+                );
             }
         }
     }
diff --git a/src/tools/clippy/clippy_lints/src/len_zero.rs b/src/tools/clippy/clippy_lints/src/len_zero.rs
index aded31971ce..896aa64fcdb 100644
--- a/src/tools/clippy/clippy_lints/src/len_zero.rs
+++ b/src/tools/clippy/clippy_lints/src/len_zero.rs
@@ -10,7 +10,7 @@ use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::{DefId, DefIdSet};
 use rustc_hir::{
-    AssocItemKind, BinOpKind, Expr, ExprKind, FnRetTy, GenericArg, GenericBound, HirId, ImplItem, ImplItemKind,
+    BinOpKind, Expr, ExprKind, FnRetTy, GenericArg, GenericBound, HirId, ImplItem, ImplItemKind,
     ImplicitSelfKind, Item, ItemKind, Mutability, Node, OpaqueTyOrigin, PatExprKind, PatKind, PathSegment, PrimTy,
     QPath, TraitItemRef, TyKind,
 };
@@ -18,6 +18,7 @@ use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, FnSig, Ty};
 use rustc_session::declare_lint_pass;
 use rustc_span::source_map::Spanned;
+use rustc_span::symbol::kw;
 use rustc_span::{Ident, Span, Symbol};
 use rustc_trait_selection::traits::supertrait_def_ids;
 
@@ -267,19 +268,10 @@ fn span_without_enclosing_paren(cx: &LateContext<'_>, span: Span) -> Span {
 fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, ident: Ident, trait_items: &[TraitItemRef]) {
     fn is_named_self(cx: &LateContext<'_>, item: &TraitItemRef, name: Symbol) -> bool {
         item.ident.name == name
-            && if let AssocItemKind::Fn { has_self } = item.kind {
-                has_self && {
-                    cx.tcx
-                        .fn_sig(item.id.owner_id)
-                        .skip_binder()
-                        .inputs()
-                        .skip_binder()
-                        .len()
-                        == 1
-                }
-            } else {
-                false
-            }
+            && matches!(
+                cx.tcx.fn_arg_idents(item.id.owner_id),
+                [Some(Ident { name: kw::SelfLower, .. })],
+            )
     }
 
     // fill the set with current and super traits
diff --git a/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs b/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs
index e266c36b6e7..fa61d0fa11a 100644
--- a/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_trait_methods.rs
@@ -61,15 +61,14 @@ impl<'tcx> LateLintPass<'tcx> for MissingTraitMethods {
         if !is_lint_allowed(cx, MISSING_TRAIT_METHODS, item.hir_id())
             && span_is_local(item.span)
             && let ItemKind::Impl(Impl {
-                items,
                 of_trait: Some(trait_ref),
                 ..
             }) = item.kind
             && let Some(trait_id) = trait_ref.trait_def_id()
         {
-            let trait_item_ids: DefIdSet = items
-                .iter()
-                .filter_map(|impl_item| impl_item.trait_item_def_id)
+            let trait_item_ids: DefIdSet = cx.tcx.associated_items(item.owner_id)
+                .in_definition_order()
+                .filter_map(|assoc_item| assoc_item.trait_item_def_id)
                 .collect();
 
             for assoc in cx
diff --git a/src/tools/clippy/clippy_lints/src/new_without_default.rs b/src/tools/clippy/clippy_lints/src/new_without_default.rs
index 4b73a4455f5..3b86f1d1f59 100644
--- a/src/tools/clippy/clippy_lints/src/new_without_default.rs
+++ b/src/tools/clippy/clippy_lints/src/new_without_default.rs
@@ -6,6 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::HirIdSet;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::ty::AssocKind;
 use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
@@ -61,18 +62,18 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
             of_trait: None,
             generics,
             self_ty: impl_self_ty,
-            items,
             ..
         }) = item.kind
         {
-            for assoc_item in *items {
-                if assoc_item.kind == (hir::AssocItemKind::Fn { has_self: false }) {
-                    let impl_item = cx.tcx.hir_impl_item(assoc_item.id);
+            for assoc_item in cx.tcx.associated_items(item.owner_id.def_id)
+                .filter_by_name_unhygienic(sym::new)
+            {
+                if let AssocKind::Fn { has_self: false, .. } = assoc_item.kind {
+                    let impl_item = cx.tcx.hir_node_by_def_id(assoc_item.def_id.expect_local()).expect_impl_item();
                     if impl_item.span.in_external_macro(cx.sess().source_map()) {
                         return;
                     }
                     if let hir::ImplItemKind::Fn(ref sig, _) = impl_item.kind {
-                        let name = impl_item.ident.name;
                         let id = impl_item.owner_id;
                         if sig.header.is_unsafe() {
                             // can't be implemented for unsafe new
@@ -88,11 +89,9 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             return;
                         }
                         if sig.decl.inputs.is_empty()
-                            && name == sym::new
                             && cx.effective_visibilities.is_reachable(impl_item.owner_id.def_id)
-                            && let self_def_id = cx.tcx.hir_get_parent_item(id.into())
-                            && let self_ty = cx.tcx.type_of(self_def_id).instantiate_identity()
-                            && self_ty == return_ty(cx, id)
+                            && let self_ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
+                            && self_ty == return_ty(cx, impl_item.owner_id)
                             && let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default)
                         {
                             if self.impling_types.is_none() {
@@ -111,7 +110,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             // Check if a Default implementation exists for the Self type, regardless of
                             // generics
                             if let Some(ref impling_types) = self.impling_types
-                                && let self_def = cx.tcx.type_of(self_def_id).instantiate_identity()
+                                && let self_def = cx.tcx.type_of(item.owner_id).instantiate_identity()
                                 && let Some(self_def) = self_def.ty_adt_def()
                                 && let Some(self_local_did) = self_def.did().as_local()
                                 && let self_id = cx.tcx.local_def_id_to_hir_id(self_local_did)
diff --git a/src/tools/clippy/clippy_lints/src/same_name_method.rs b/src/tools/clippy/clippy_lints/src/same_name_method.rs
index 226e8ff6adb..85fde780e68 100644
--- a/src/tools/clippy/clippy_lints/src/same_name_method.rs
+++ b/src/tools/clippy/clippy_lints/src/same_name_method.rs
@@ -3,7 +3,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{HirId, Impl, ItemKind, Node, Path, QPath, TraitRef, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::AssocItem;
+use rustc_middle::ty::{AssocKind, AssocItem};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 use rustc_span::symbol::Symbol;
@@ -54,7 +54,6 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
             if matches!(cx.tcx.def_kind(id.owner_id), DefKind::Impl { .. })
                 && let item = cx.tcx.hir_item(id)
                 && let ItemKind::Impl(Impl {
-                    items,
                     of_trait,
                     self_ty,
                     ..
@@ -115,13 +114,11 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                             }
                         };
 
-                        for impl_item_ref in (*items)
-                            .iter()
-                            .filter(|impl_item_ref| matches!(impl_item_ref.kind, rustc_hir::AssocItemKind::Fn { .. }))
-                        {
-                            let method_name = impl_item_ref.ident.name;
-                            methods_in_trait.remove(&method_name);
-                            check_trait_method(method_name, impl_item_ref.span);
+                        for assoc_item in cx.tcx.associated_items(id.owner_id).in_definition_order() {
+                            if let AssocKind::Fn { name, .. } = assoc_item.kind {
+                                methods_in_trait.remove(&name);
+                                check_trait_method(name, cx.tcx.def_span(assoc_item.def_id));
+                            }
                         }
 
                         for method_name in methods_in_trait {
@@ -129,14 +126,11 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                         }
                     },
                     None => {
-                        for impl_item_ref in (*items)
-                            .iter()
-                            .filter(|impl_item_ref| matches!(impl_item_ref.kind, rustc_hir::AssocItemKind::Fn { .. }))
-                        {
-                            let method_name = impl_item_ref.ident.name;
-                            let impl_span = impl_item_ref.span;
-                            let hir_id = impl_item_ref.id.hir_id();
-                            if let Some(trait_spans) = existing_name.trait_methods.get(&method_name) {
+                        for assoc_item in cx.tcx.associated_items(id.owner_id).in_definition_order() {
+                            let AssocKind::Fn { name, .. } = assoc_item.kind else { continue };
+                            let impl_span = cx.tcx.def_span(assoc_item.def_id);
+                            let hir_id = cx.tcx.local_def_id_to_hir_id(assoc_item.def_id.expect_local());
+                            if let Some(trait_spans) = existing_name.trait_methods.get(&name) {
                                 span_lint_hir_and_then(
                                     cx,
                                     SAME_NAME_METHOD,
@@ -148,12 +142,12 @@ impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
                                         // iterate on trait_spans?
                                         diag.span_note(
                                             trait_spans[0],
-                                            format!("existing `{method_name}` defined here"),
+                                            format!("existing `{name}` defined here"),
                                         );
                                     },
                                 );
                             }
-                            existing_name.impl_methods.insert(method_name, (impl_span, hir_id));
+                            existing_name.impl_methods.insert(name, (impl_span, hir_id));
                         }
                     },
                 }
diff --git a/src/tools/clippy/tests/ui/same_name_method.stderr b/src/tools/clippy/tests/ui/same_name_method.stderr
index b2624ac4d26..bf7456d80e2 100644
--- a/src/tools/clippy/tests/ui/same_name_method.stderr
+++ b/src/tools/clippy/tests/ui/same_name_method.stderr
@@ -2,13 +2,13 @@ error: method's name is the same as an existing method in a trait
   --> tests/ui/same_name_method.rs:20:13
    |
 LL |             fn foo() {}
-   |             ^^^^^^^^^^^
+   |             ^^^^^^^^
    |
 note: existing `foo` defined here
   --> tests/ui/same_name_method.rs:25:13
    |
 LL |             fn foo() {}
-   |             ^^^^^^^^^^^
+   |             ^^^^^^^^
    = note: `-D clippy::same-name-method` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::same_name_method)]`
 
@@ -16,7 +16,7 @@ error: method's name is the same as an existing method in a trait
   --> tests/ui/same_name_method.rs:35:13
    |
 LL |             fn clone() {}
-   |             ^^^^^^^^^^^^^
+   |             ^^^^^^^^^^
    |
 note: existing `clone` defined here
   --> tests/ui/same_name_method.rs:31:18
@@ -28,19 +28,19 @@ error: method's name is the same as an existing method in a trait
   --> tests/ui/same_name_method.rs:46:13
    |
 LL |             fn foo() {}
-   |             ^^^^^^^^^^^
+   |             ^^^^^^^^
    |
 note: existing `foo` defined here
   --> tests/ui/same_name_method.rs:51:13
    |
 LL |             fn foo() {}
-   |             ^^^^^^^^^^^
+   |             ^^^^^^^^
 
 error: method's name is the same as an existing method in a trait
   --> tests/ui/same_name_method.rs:61:13
    |
 LL |             fn foo() {}
-   |             ^^^^^^^^^^^
+   |             ^^^^^^^^
    |
 note: existing `foo` defined here
   --> tests/ui/same_name_method.rs:65:9
@@ -52,7 +52,7 @@ error: method's name is the same as an existing method in a trait
   --> tests/ui/same_name_method.rs:74:13
    |
 LL |             fn foo() {}
-   |             ^^^^^^^^^^^
+   |             ^^^^^^^^
    |
 note: existing `foo` defined here
   --> tests/ui/same_name_method.rs:79:9
@@ -64,7 +64,7 @@ error: method's name is the same as an existing method in a trait
   --> tests/ui/same_name_method.rs:74:13
    |
 LL |             fn foo() {}
-   |             ^^^^^^^^^^^
+   |             ^^^^^^^^
    |
 note: existing `foo` defined here
   --> tests/ui/same_name_method.rs:81:9
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 bdcfadd3955..56abd6ebf73 100644
--- a/tests/ui/associated-types/defaults-in-other-trait-items.stderr
+++ b/tests/ui/associated-types/defaults-in-other-trait-items.stderr
@@ -2,7 +2,7 @@ error[E0308]: mismatched types
   --> $DIR/defaults-in-other-trait-items.rs:9:13
    |
 LL |     type A = ();
-   |     ------------ associated type defaults can't be assumed inside the trait defining them
+   |     ------ associated type defaults can't be assumed inside the trait defining them
 ...
 LL |         let () = p;
    |             ^^   - this expression has type `<Self as Tr>::A`
@@ -16,7 +16,7 @@ error[E0308]: mismatched types
   --> $DIR/defaults-in-other-trait-items.rs:36:25
    |
 LL |     type Ty = u8;
-   |     ------------- associated type defaults can't be assumed inside the trait defining them
+   |     ------- associated type defaults can't be assumed inside the trait defining them
 ...
 LL |     const C: Self::Ty = 0u8;
    |                         ^^^ expected associated type, found `u8`
@@ -28,7 +28,7 @@ error[E0308]: mismatched types
   --> $DIR/defaults-in-other-trait-items.rs:54:9
    |
 LL |     type Res = isize;
-   |     ----------------- associated type defaults can't be assumed inside the trait defining them
+   |     -------- associated type defaults can't be assumed inside the trait defining them
 LL |
 LL |     fn infer_me_correctly() -> Self::Res {
    |                                --------- expected `<Self as Trait>::Res` because of return type
diff --git a/tests/ui/associated-types/defaults-specialization.stderr b/tests/ui/associated-types/defaults-specialization.stderr
index fd2a1a0c2d1..7d19ac85982 100644
--- a/tests/ui/associated-types/defaults-specialization.stderr
+++ b/tests/ui/associated-types/defaults-specialization.stderr
@@ -31,7 +31,7 @@ error[E0053]: method `make` has an incompatible type for trait
   --> $DIR/defaults-specialization.rs:35:18
    |
 LL |     default type Ty = bool;
-   |     ----------------------- associated type is `default` and may be overridden
+   |     --------------- associated type is `default` and may be overridden
 LL |
 LL |     fn make() -> bool { true }
    |                  ^^^^ expected associated type, found `bool`
@@ -53,7 +53,7 @@ error[E0308]: mismatched types
   --> $DIR/defaults-specialization.rs:10:9
    |
 LL |     type Ty = u8;
-   |     ------------- associated type defaults can't be assumed inside the trait defining them
+   |     ------- associated type defaults can't be assumed inside the trait defining them
 LL |
 LL |     fn make() -> Self::Ty {
    |                  -------- expected `<Self as Tr>::Ty` because of return type
@@ -80,7 +80,7 @@ error[E0308]: mismatched types
   --> $DIR/defaults-specialization.rs:44:29
    |
 LL |     default type Ty = bool;
-   |     ----------------------- associated type is `default` and may be overridden
+   |     --------------- associated type is `default` and may be overridden
 LL |
 LL |     fn make() -> Self::Ty { true }
    |                  --------   ^^^^ expected associated type, found `bool`
diff --git a/tests/ui/associated-types/issue-26681.stderr b/tests/ui/associated-types/issue-26681.stderr
index b64bcee07f0..5fb1a4ef3f5 100644
--- a/tests/ui/associated-types/issue-26681.stderr
+++ b/tests/ui/associated-types/issue-26681.stderr
@@ -2,7 +2,7 @@ error[E0308]: mismatched types
   --> $DIR/issue-26681.rs:17:39
    |
 LL |     type Fv: Foo = u8;
-   |     ------------------ associated type defaults can't be assumed inside the trait defining them
+   |     ------------ 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
    |
diff --git a/tests/ui/generics/export-name-on-generics.stderr b/tests/ui/generics/export-name-on-generics.stderr
index 7bc7b8ca559..e08b2b1c8f3 100644
--- a/tests/ui/generics/export-name-on-generics.stderr
+++ b/tests/ui/generics/export-name-on-generics.stderr
@@ -4,7 +4,7 @@ error: functions generic over types or consts must be mangled
 LL | #[export_name = "foo"]
    | ---------------------- help: remove this attribute
 LL | pub fn foo<T>() {}
-   | ^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/export-name-on-generics.rs:3:9
@@ -18,7 +18,7 @@ error: functions generic over types or consts must be mangled
 LL | #[export_name = "bar"]
    | ---------------------- help: remove this attribute
 LL | pub extern "C" fn bar<T>() {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:21:5
@@ -26,7 +26,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "foo"]
    |     ---------------------- help: remove this attribute
 LL |     pub fn foo<T>() {}
-   |     ^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:24:5
@@ -34,7 +34,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "bar"]
    |     ---------------------- help: remove this attribute
 LL |     pub extern "C" fn bar<T>() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:42:5
@@ -42,7 +42,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "foo"]
    |     ---------------------- help: remove this attribute
 LL |     fn foo<T>() {}
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:45:5
@@ -50,7 +50,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "bar"]
    |     ---------------------- help: remove this attribute
 LL |     extern "C" fn bar<T>() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:64:5
@@ -58,7 +58,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "foo"]
    |     ---------------------- help: remove this attribute
 LL |     fn foo() {}
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:67:5
@@ -66,7 +66,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "foo2"]
    |     ----------------------- help: remove this attribute
 LL |     fn foo2<U>() {}
-   |     ^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:70:5
@@ -74,7 +74,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "baz"]
    |     ---------------------- help: remove this attribute
 LL |     extern "C" fn bar() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:73:5
@@ -82,7 +82,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "baz"]
    |     ---------------------- help: remove this attribute
 LL |     fn baz(x: &i32) -> &i32 { x }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:76:5
@@ -90,7 +90,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "qux"]
    |     ---------------------- help: remove this attribute
 LL |     fn qux<'a>(x: &'a i32) -> &i32 { x }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:83:5
@@ -98,7 +98,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "foo"]
    |     ---------------------- help: remove this attribute
 LL |     pub fn foo() {}
-   |     ^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:86:5
@@ -106,7 +106,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "bar"]
    |     ---------------------- help: remove this attribute
 LL |     pub extern "C" fn bar() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:89:5
@@ -114,7 +114,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "baz"]
    |     ---------------------- help: remove this attribute
 LL |     pub fn baz<U>() {}
-   |     ^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:105:5
@@ -122,7 +122,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "foo"]
    |     ---------------------- help: remove this attribute
 LL |     fn foo() {}
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:108:5
@@ -130,7 +130,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "bar"]
    |     ---------------------- help: remove this attribute
 LL |     extern "C" fn bar() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/export-name-on-generics.rs:111:5
@@ -138,7 +138,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[export_name = "baz"]
    |     ---------------------- help: remove this attribute
 LL |     fn baz<U>() {}
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^
 
 error: aborting due to 17 previous errors
 
diff --git a/tests/ui/generics/generic-no-mangle.stderr b/tests/ui/generics/generic-no-mangle.stderr
index adfddbe9ca7..39fbe4dd76d 100644
--- a/tests/ui/generics/generic-no-mangle.stderr
+++ b/tests/ui/generics/generic-no-mangle.stderr
@@ -4,7 +4,7 @@ error: functions generic over types or consts must be mangled
 LL | #[no_mangle]
    | ------------ help: remove this attribute
 LL | pub fn foo<T>() {}
-   | ^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/generic-no-mangle.rs:3:9
@@ -18,7 +18,7 @@ error: functions generic over types or consts must be mangled
 LL | #[no_mangle]
    | ------------ help: remove this attribute
 LL | pub extern "C" fn bar<T>() {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:21:5
@@ -26,7 +26,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     pub fn foo<T>() {}
-   |     ^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:24:5
@@ -34,7 +34,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     pub extern "C" fn bar<T>() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:42:5
@@ -42,7 +42,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     fn foo<T>() {}
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:45:5
@@ -50,7 +50,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     extern "C" fn bar<T>() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:64:5
@@ -58,7 +58,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     fn foo() {}
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:67:5
@@ -66,7 +66,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     fn foo2<U>() {}
-   |     ^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:70:5
@@ -74,7 +74,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     extern "C" fn bar() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:73:5
@@ -82,7 +82,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     fn baz(x: &i32) -> &i32 { x }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:76:5
@@ -90,7 +90,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     fn qux<'a>(x: &'a i32) -> &i32 { x }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:83:5
@@ -98,7 +98,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     pub fn foo() {}
-   |     ^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:86:5
@@ -106,7 +106,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     pub extern "C" fn bar() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:89:5
@@ -114,7 +114,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     pub fn baz<U>() {}
-   |     ^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:105:5
@@ -122,7 +122,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     fn foo() {}
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:108:5
@@ -130,7 +130,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     extern "C" fn bar() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^
 
 error: functions generic over types or consts must be mangled
   --> $DIR/generic-no-mangle.rs:111:5
@@ -138,7 +138,7 @@ error: functions generic over types or consts must be mangled
 LL |     #[no_mangle]
    |     ------------ help: remove this attribute
 LL |     fn baz<U>() {}
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^
 
 error: aborting due to 17 previous errors
 
diff --git a/tests/ui/lint/suggestions.stderr b/tests/ui/lint/suggestions.stderr
index a4871ead74b..c35e92f5980 100644
--- a/tests/ui/lint/suggestions.stderr
+++ b/tests/ui/lint/suggestions.stderr
@@ -65,7 +65,7 @@ LL | #[no_mangle]
    | ------------ help: remove this attribute
 LL |
 LL | pub fn defiant<T>(_t: T) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(no_mangle_generic_items)]` on by default
 
@@ -89,7 +89,7 @@ warning: functions generic over types or consts must be mangled
   --> $DIR/suggestions.rs:26:18
    |
 LL |     #[no_mangle] pub fn val_jean<T>() {}
-   |     ------------ ^^^^^^^^^^^^^^^^^^^^^^^
+   |     ------------ ^^^^^^^^^^^^^^^^^^^^
    |     |
    |     help: remove this attribute
 
@@ -105,7 +105,7 @@ warning: functions generic over types or consts must be mangled
   --> $DIR/suggestions.rs:35:18
    |
 LL |     #[no_mangle] pub(crate) fn crossfield<T>() {}
-   |     ------------ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ------------ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |     |
    |     help: remove this attribute
 
diff --git a/tests/ui/specialization/specialization-default-types.current.stderr b/tests/ui/specialization/specialization-default-types.current.stderr
index 67477f9a6d5..09689681740 100644
--- a/tests/ui/specialization/specialization-default-types.current.stderr
+++ b/tests/ui/specialization/specialization-default-types.current.stderr
@@ -12,7 +12,7 @@ error[E0308]: mismatched types
   --> $DIR/specialization-default-types.rs:19:9
    |
 LL |     default type Output = Box<T>;
-   |     ----------------------------- associated type is `default` and may be overridden
+   |     ------------------- associated type is `default` and may be overridden
 LL |     default fn generate(self) -> Self::Output {
    |                                  ------------ expected `<T as Example>::Output` because of return type
 LL |         Box::new(self)
diff --git a/tests/ui/specialization/specialization-default-types.next.stderr b/tests/ui/specialization/specialization-default-types.next.stderr
index 4f7c4765446..1535c6473bd 100644
--- a/tests/ui/specialization/specialization-default-types.next.stderr
+++ b/tests/ui/specialization/specialization-default-types.next.stderr
@@ -12,7 +12,7 @@ error[E0308]: mismatched types
   --> $DIR/specialization-default-types.rs:19:9
    |
 LL |     default type Output = Box<T>;
-   |     ----------------------------- associated type is `default` and may be overridden
+   |     ------------------- associated type is `default` and may be overridden
 LL |     default fn generate(self) -> Self::Output {
    |                                  ------------ expected `<T as Example>::Output` because of return type
 LL |         Box::new(self)
diff --git a/tests/ui/stats/input-stats.stderr b/tests/ui/stats/input-stats.stderr
index 7c92044ef5f..7b3acdeb207 100644
--- a/tests/ui/stats/input-stats.stderr
+++ b/tests/ui/stats/input-stats.stderr
@@ -112,12 +112,12 @@ hir-stats Param                     64 (NN.N%)             2            32
 hir-stats GenericArg                64 (NN.N%)             4            16
 hir-stats - Type                      16 (NN.N%)             1
 hir-stats - Lifetime                  48 (NN.N%)             3
-hir-stats TraitItemRef              56 (NN.N%)             2            28
-hir-stats ImplItemRef               56 (NN.N%)             2            28
+hir-stats TraitItemRef              48 (NN.N%)             2            24
+hir-stats ImplItemRef               48 (NN.N%)             2            24
 hir-stats ExprField                 40 (NN.N%)             1            40
 hir-stats Mod                       32 (NN.N%)             1            32
 hir-stats Lifetime                  28 (NN.N%)             1            28
 hir-stats ForeignItemRef            24 (NN.N%)             1            24
 hir-stats ----------------------------------------------------------------
-hir-stats Total                  8_700                   173
+hir-stats Total                  8_684                   173
 hir-stats ================================================================
-- 
cgit 1.4.1-3-g733a5


From 36bc0948e0a67f5aeb2a1d997acf4cd94d948fa9 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 3 Jul 2025 09:09:26 +0000
Subject: Generalize TyCtxt::item_name.

---
 compiler/rustc_hir_analysis/src/check/intrinsic.rs       |  4 ++--
 compiler/rustc_middle/src/ty/mod.rs                      | 12 ++++++++----
 compiler/rustc_middle/src/ty/util.rs                     |  2 +-
 compiler/rustc_mir_build/src/thir/pattern/check_match.rs |  2 +-
 compiler/rustc_passes/src/abi_test.rs                    |  4 ++--
 5 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index e3532ade32f..dcab6ef1c5a 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -59,7 +59,7 @@ fn equate_intrinsic_type<'tcx>(
 
 /// Returns the unsafety of the given intrinsic.
 fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hir::Safety {
-    let is_in_list = match tcx.item_name(intrinsic_id.into()) {
+    let is_in_list = match tcx.item_name(intrinsic_id) {
         // When adding a new intrinsic to this list,
         // it's usually worth updating that intrinsic's documentation
         // to note that it's safe to call, since
@@ -144,7 +144,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
             tcx.def_span(intrinsic_id),
             DiagMessage::from(format!(
                 "intrinsic safety mismatch between list of intrinsics within the compiler and core library intrinsics for intrinsic `{}`",
-                tcx.item_name(intrinsic_id.into())
+                tcx.item_name(intrinsic_id)
             )
         )).emit();
     }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 0177a95498b..9df44bbc15e 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1590,7 +1590,8 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     /// Look up the name of a definition across crates. This does not look at HIR.
-    pub fn opt_item_name(self, def_id: DefId) -> Option<Symbol> {
+    pub fn opt_item_name(self, def_id: impl IntoQueryParam<DefId>) -> Option<Symbol> {
+        let def_id = def_id.into_query_param();
         if let Some(cnum) = def_id.as_crate_root() {
             Some(self.crate_name(cnum))
         } else {
@@ -1610,7 +1611,8 @@ impl<'tcx> TyCtxt<'tcx> {
     /// [`opt_item_name`] instead.
     ///
     /// [`opt_item_name`]: Self::opt_item_name
-    pub fn item_name(self, id: DefId) -> Symbol {
+    pub fn item_name(self, id: impl IntoQueryParam<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));
         })
@@ -1619,7 +1621,8 @@ impl<'tcx> TyCtxt<'tcx> {
     /// 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: DefId) -> Option<Ident> {
+    pub fn opt_item_ident(self, def_id: impl IntoQueryParam<DefId>) -> Option<Ident> {
+        let def_id = def_id.into_query_param();
         let def = self.opt_item_name(def_id)?;
         let span = self
             .def_ident_span(def_id)
@@ -1630,7 +1633,8 @@ impl<'tcx> TyCtxt<'tcx> {
     /// 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: DefId) -> Ident {
+    pub fn item_ident(self, def_id: impl IntoQueryParam<DefId>) -> Ident {
+        let def_id = def_id.into_query_param();
         self.opt_item_ident(def_id).unwrap_or_else(|| {
             bug!("item_ident: no name for {:?}", self.def_path(def_id));
         })
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index fd80d85f198..174892c6f4d 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -1683,7 +1683,7 @@ pub fn intrinsic_raw(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ty::Intrinsi
             _ => true,
         };
         Some(ty::IntrinsicDef {
-            name: tcx.item_name(def_id.into()),
+            name: tcx.item_name(def_id),
             must_be_overridden,
             const_stable: tcx.has_attr(def_id, sym::rustc_intrinsic_const_stable_indirect),
         })
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 a49bfc1b8f4..7f47754f6bc 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -1084,7 +1084,7 @@ fn find_fallback_pattern_typo<'tcx>(
                 && infcx.can_eq(param_env, ty, cx.tcx.type_of(item.owner_id).instantiate_identity())
             {
                 // Look for local consts.
-                let item_name = cx.tcx.item_name(item.owner_id.into());
+                let item_name = cx.tcx.item_name(item.owner_id);
                 let vis = cx.tcx.visibility(item.owner_id);
                 if vis.is_accessible_from(parent, cx.tcx) {
                     accessible.push(item_name);
diff --git a/compiler/rustc_passes/src/abi_test.rs b/compiler/rustc_passes/src/abi_test.rs
index b139ed6a66c..0ac42f03eb2 100644
--- a/compiler/rustc_passes/src/abi_test.rs
+++ b/compiler/rustc_passes/src/abi_test.rs
@@ -79,7 +79,7 @@ fn dump_abi_of_fn_item(tcx: TyCtxt<'_>, item_def_id: LocalDefId, attr: &Attribut
     for meta_item in meta_items {
         match meta_item.name() {
             Some(sym::debug) => {
-                let fn_name = tcx.item_name(item_def_id.into());
+                let fn_name = tcx.item_name(item_def_id);
                 tcx.dcx().emit_err(AbiOf {
                     span: tcx.def_span(item_def_id),
                     fn_name,
@@ -135,7 +135,7 @@ fn dump_abi_of_fn_type(tcx: TyCtxt<'_>, item_def_id: LocalDefId, attr: &Attribut
                     item_def_id,
                 );
 
-                let fn_name = tcx.item_name(item_def_id.into());
+                let fn_name = tcx.item_name(item_def_id);
                 tcx.dcx().emit_err(AbiOf { span, fn_name, fn_abi: format!("{:#?}", abi) });
             }
             Some(sym::assert_eq) => {
-- 
cgit 1.4.1-3-g733a5


From 5bd3841668f43626b89c9295de960cc7e2a3c2aa Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 3 Jul 2025 09:32:11 +0000
Subject: Retire hir::ForeignItemRef.

---
 compiler/rustc_ast_lowering/src/index.rs       |  8 ++-----
 compiler/rustc_ast_lowering/src/item.rs        | 10 ++-------
 compiler/rustc_hir/src/hir.rs                  | 17 ++-------------
 compiler/rustc_hir/src/intravisit.rs           | 13 ++++-------
 compiler/rustc_hir_analysis/src/check/check.rs | 30 ++++++++++++++------------
 compiler/rustc_hir_pretty/src/lib.rs           |  4 ++--
 compiler/rustc_metadata/src/foreign_modules.rs |  2 +-
 compiler/rustc_passes/src/input_stats.rs       |  6 +++---
 compiler/rustc_privacy/src/lib.rs              |  8 +++----
 src/librustdoc/visit_ast.rs                    |  4 ++--
 tests/ui/stats/input-stats.stderr              |  4 ++--
 11 files changed, 40 insertions(+), 66 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/index.rs b/compiler/rustc_ast_lowering/src/index.rs
index a86fa49755b..2fc8f95689f 100644
--- a/compiler/rustc_ast_lowering/src/index.rs
+++ b/compiler/rustc_ast_lowering/src/index.rs
@@ -397,12 +397,8 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         self.visit_nested_impl_item(id);
     }
 
-    fn visit_foreign_item_ref(&mut self, fi: &'hir ForeignItemRef) {
-        // Do not visit the duplicate information in ForeignItemRef. We want to
-        // map the actual nodes, not the duplicate ones in the *Ref.
-        let ForeignItemRef { id, ident: _, span: _ } = *fi;
-
-        self.visit_nested_foreign_item(id);
+    fn visit_foreign_item_ref(&mut self, id: &'hir ForeignItemId) {
+        self.visit_nested_foreign_item(*id);
     }
 
     fn visit_where_predicate(&mut self, predicate: &'hir WherePredicate<'hir>) {
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 5043995e6b9..253e0c04c4d 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -704,14 +704,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.arena.alloc(item)
     }
 
-    fn lower_foreign_item_ref(&mut self, i: &ForeignItem) -> hir::ForeignItemRef {
-        hir::ForeignItemRef {
-            id: hir::ForeignItemId { owner_id: self.owner_id(i.id) },
-            // `unwrap` is safe because `ForeignItemKind::MacCall` is the only foreign item kind
-            // without an identifier and it cannot reach here.
-            ident: self.lower_ident(i.kind.ident().unwrap()),
-            span: self.lower_span(i.span),
-        }
+    fn lower_foreign_item_ref(&mut self, i: &ForeignItem) -> hir::ForeignItemId {
+        hir::ForeignItemId { owner_id: self.owner_id(i.id) }
     }
 
     fn lower_variant(&mut self, item_kind: &ItemKind, v: &Variant) -> hir::Variant<'hir> {
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 8531003c6ac..cdd1547fc60 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -4138,7 +4138,7 @@ impl<'hir> Item<'hir> {
 
         expect_mod, (Ident, &'hir Mod<'hir>), ItemKind::Mod(ident, m), (*ident, m);
 
-        expect_foreign_mod, (ExternAbi, &'hir [ForeignItemRef]),
+        expect_foreign_mod, (ExternAbi, &'hir [ForeignItemId]),
             ItemKind::ForeignMod { abi, items }, (*abi, items);
 
         expect_global_asm, &'hir InlineAsm<'hir>, ItemKind::GlobalAsm { asm, .. }, asm;
@@ -4315,7 +4315,7 @@ pub enum ItemKind<'hir> {
     /// A module.
     Mod(Ident, &'hir Mod<'hir>),
     /// An external module, e.g. `extern { .. }`.
-    ForeignMod { abi: ExternAbi, items: &'hir [ForeignItemRef] },
+    ForeignMod { abi: ExternAbi, items: &'hir [ForeignItemId] },
     /// Module-level inline assembly (from `global_asm!`).
     GlobalAsm {
         asm: &'hir InlineAsm<'hir>,
@@ -4447,19 +4447,6 @@ impl ForeignItemId {
     }
 }
 
-/// A reference from a foreign block to one of its items. This
-/// contains the item's ID, naturally, but also the item's name and
-/// some other high-level details (like whether it is an associated
-/// type or method, and whether it is public). This allows other
-/// passes to find the impl they want without loading the ID (which
-/// means fewer edges in the incremental compilation graph).
-#[derive(Debug, Clone, Copy, HashStable_Generic)]
-pub struct ForeignItemRef {
-    pub id: ForeignItemId,
-    pub ident: Ident,
-    pub span: Span,
-}
-
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub struct ForeignItem<'hir> {
     pub ident: Ident,
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index e5a60fb5d31..552f17e0950 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -441,8 +441,8 @@ pub trait Visitor<'v>: Sized {
     fn visit_impl_item(&mut self, ii: &'v ImplItem<'v>) -> Self::Result {
         walk_impl_item(self, ii)
     }
-    fn visit_foreign_item_ref(&mut self, ii: &'v ForeignItemRef) -> Self::Result {
-        walk_foreign_item_ref(self, ii)
+    fn visit_foreign_item_ref(&mut self, ii: &'v ForeignItemId) -> Self::Result {
+        walk_foreign_item_ref(self, *ii)
     }
     fn visit_impl_item_ref(&mut self, ii: &'v ImplItemRef) -> Self::Result {
         walk_impl_item_ref(self, ii)
@@ -1290,13 +1290,8 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(
     }
 }
 
-pub fn walk_foreign_item_ref<'v, V: Visitor<'v>>(
-    visitor: &mut V,
-    foreign_item_ref: &'v ForeignItemRef,
-) -> V::Result {
-    let ForeignItemRef { id, ident, span: _ } = *foreign_item_ref;
-    try_visit!(visitor.visit_nested_foreign_item(id));
-    visitor.visit_ident(ident)
+pub fn walk_foreign_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, id: ForeignItemId) -> V::Result {
+    visitor.visit_nested_foreign_item(id)
 }
 
 pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index f4bbf03f0c2..70fbb8a543e 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -930,8 +930,8 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
 
             check_abi(tcx, it.hir_id(), it.span, abi);
 
-            for item in items {
-                let def_id = item.id.owner_id.def_id;
+            for &item in items {
+                let def_id = item.owner_id.def_id;
 
                 let generics = tcx.generics_of(def_id);
                 let own_counts = generics.own_counts();
@@ -943,13 +943,14 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
                         (0, _) => ("const", "consts", None),
                         _ => ("type or const", "types or consts", None),
                     };
+                    let span = tcx.def_span(def_id);
                     struct_span_code_err!(
                         tcx.dcx(),
-                        item.span,
+                        span,
                         E0044,
                         "foreign items may not have {kinds} parameters",
                     )
-                    .with_span_label(item.span, format!("can't have {kinds} parameters"))
+                    .with_span_label(span, format!("can't have {kinds} parameters"))
                     .with_help(
                         // FIXME: once we start storing spans for type arguments, turn this
                         // into a suggestion.
@@ -963,22 +964,23 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
                     .emit();
                 }
 
-                let item = tcx.hir_foreign_item(item.id);
-                tcx.ensure_ok().generics_of(item.owner_id);
-                tcx.ensure_ok().type_of(item.owner_id);
-                tcx.ensure_ok().predicates_of(item.owner_id);
+                tcx.ensure_ok().generics_of(def_id);
+                tcx.ensure_ok().type_of(def_id);
+                tcx.ensure_ok().predicates_of(def_id);
                 if tcx.is_conditionally_const(def_id) {
                     tcx.ensure_ok().explicit_implied_const_bounds(def_id);
                     tcx.ensure_ok().const_conditions(def_id);
                 }
-                match item.kind {
-                    hir::ForeignItemKind::Fn(sig, ..) => {
-                        tcx.ensure_ok().codegen_fn_attrs(item.owner_id);
-                        tcx.ensure_ok().fn_sig(item.owner_id);
+                match tcx.def_kind(def_id) {
+                    DefKind::Fn => {
+                        tcx.ensure_ok().codegen_fn_attrs(def_id);
+                        tcx.ensure_ok().fn_sig(def_id);
+                        let item = tcx.hir_foreign_item(item);
+                        let hir::ForeignItemKind::Fn(sig, ..) = item.kind else { bug!() };
                         require_c_abi_if_c_variadic(tcx, sig.decl, abi, item.span);
                     }
-                    hir::ForeignItemKind::Static(..) => {
-                        tcx.ensure_ok().codegen_fn_attrs(item.owner_id);
+                    DefKind::Static { .. } => {
+                        tcx.ensure_ok().codegen_fn_attrs(def_id);
                     }
                     _ => (),
                 }
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index 3a525021f6f..42adbd922a0 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -654,8 +654,8 @@ impl<'a> State<'a> {
                 let (cb, ib) = self.head("extern");
                 self.word_nbsp(abi.to_string());
                 self.bopen(ib);
-                for item in items {
-                    self.ann.nested(self, Nested::ForeignItem(item.id));
+                for &foreign_item in items {
+                    self.ann.nested(self, Nested::ForeignItem(foreign_item));
                 }
                 self.bclose(item.span, cb);
             }
diff --git a/compiler/rustc_metadata/src/foreign_modules.rs b/compiler/rustc_metadata/src/foreign_modules.rs
index 24689ea61d0..8a6b2027083 100644
--- a/compiler/rustc_metadata/src/foreign_modules.rs
+++ b/compiler/rustc_metadata/src/foreign_modules.rs
@@ -19,7 +19,7 @@ pub(crate) fn collect(tcx: TyCtxt<'_>, LocalCrate: LocalCrate) -> FxIndexMap<Def
         let item = tcx.hir_item(id);
 
         if let hir::ItemKind::ForeignMod { abi, items } = item.kind {
-            let foreign_items = items.iter().map(|it| it.id.owner_id.to_def_id()).collect();
+            let foreign_items = items.iter().map(|it| it.owner_id.to_def_id()).collect();
             modules.insert(def_id, ForeignModule { def_id, abi, foreign_items });
         }
     }
diff --git a/compiler/rustc_passes/src/input_stats.rs b/compiler/rustc_passes/src/input_stats.rs
index e38c7b2cbf1..9451d946669 100644
--- a/compiler/rustc_passes/src/input_stats.rs
+++ b/compiler/rustc_passes/src/input_stats.rs
@@ -480,9 +480,9 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
         hir_visit::walk_impl_item(self, ii)
     }
 
-    fn visit_foreign_item_ref(&mut self, fi: &'v hir::ForeignItemRef) {
-        self.record("ForeignItemRef", Some(fi.id.hir_id()), fi);
-        hir_visit::walk_foreign_item_ref(self, fi)
+    fn visit_foreign_item_ref(&mut self, fi: &'v hir::ForeignItemId) {
+        self.record("ForeignItemId", Some(fi.hir_id()), fi);
+        hir_visit::walk_foreign_item_ref(self, *fi)
     }
 
     fn visit_impl_item_ref(&mut self, ii: &'v hir::ImplItemRef) {
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index a7453a659c9..6f8b7a1209e 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -755,8 +755,8 @@ impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
             }
             hir::ItemKind::ForeignMod { items, .. } => {
                 for foreign_item in items {
-                    if let Some(foreign_item_ev) = self.get(foreign_item.id.owner_id.def_id) {
-                        self.reach(foreign_item.id.owner_id.def_id, foreign_item_ev)
+                    if let Some(foreign_item_ev) = self.get(foreign_item.owner_id.def_id) {
+                        self.reach(foreign_item.owner_id.def_id, foreign_item_ev)
                             .generics()
                             .predicates()
                             .ty();
@@ -1658,8 +1658,8 @@ impl<'tcx> PrivateItemsInPublicInterfacesChecker<'_, 'tcx> {
             DefKind::ForeignMod => {
                 let item = tcx.hir_item(id);
                 if let hir::ItemKind::ForeignMod { items, .. } = item.kind {
-                    for foreign_item in items {
-                        let foreign_item = tcx.hir_foreign_item(foreign_item.id);
+                    for &foreign_item in items {
+                        let foreign_item = tcx.hir_foreign_item(foreign_item);
 
                         let ev = self.get(foreign_item.owner_id.def_id);
                         let vis = tcx.local_visibility(foreign_item.owner_id.def_id);
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index 2784d7c761a..9058277d72e 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -469,8 +469,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
 
         match item.kind {
             hir::ItemKind::ForeignMod { items, .. } => {
-                for item in items {
-                    let item = tcx.hir_foreign_item(item.id);
+                for &item in items {
+                    let item = tcx.hir_foreign_item(item);
                     self.visit_foreign_item_inner(item, None, None);
                 }
             }
diff --git a/tests/ui/stats/input-stats.stderr b/tests/ui/stats/input-stats.stderr
index 7b3acdeb207..e03ac0de54f 100644
--- a/tests/ui/stats/input-stats.stderr
+++ b/tests/ui/stats/input-stats.stderr
@@ -117,7 +117,7 @@ hir-stats ImplItemRef               48 (NN.N%)             2            24
 hir-stats ExprField                 40 (NN.N%)             1            40
 hir-stats Mod                       32 (NN.N%)             1            32
 hir-stats Lifetime                  28 (NN.N%)             1            28
-hir-stats ForeignItemRef            24 (NN.N%)             1            24
+hir-stats ForeignItemId              4 (NN.N%)             1             4
 hir-stats ----------------------------------------------------------------
-hir-stats Total                  8_684                   173
+hir-stats Total                  8_664                   173
 hir-stats ================================================================
-- 
cgit 1.4.1-3-g733a5


From 21fd82adbcaf322973ca6edb28a801be755a2225 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Wed, 2 Jul 2025 20:15:28 +0000
Subject: Retire hir::*ItemRef.

---
 compiler/rustc_ast_lowering/src/index.rs           | 16 ++----
 compiler/rustc_ast_lowering/src/item.rs            | 19 ++----
 compiler/rustc_hir/src/hir.rs                      | 32 +----------
 compiler/rustc_hir/src/intravisit.rs               | 26 +++------
 compiler/rustc_hir_analysis/src/collect.rs         | 21 +++----
 compiler/rustc_hir_pretty/src/lib.rs               |  8 +--
 .../rustc_lint/src/deref_into_dyn_supertrait.rs    | 16 ++++--
 compiler/rustc_passes/src/check_attr.rs            |  2 +-
 compiler/rustc_passes/src/dead.rs                  |  4 +-
 compiler/rustc_passes/src/input_stats.rs           | 12 ++--
 compiler/rustc_passes/src/stability.rs             |  9 ++-
 compiler/rustc_privacy/src/lib.rs                  | 10 ++--
 .../src/error_reporting/traits/ambiguity.rs        | 16 ++----
 compiler/rustc_trait_selection/src/traits/wf.rs    |  4 +-
 compiler/rustc_ty_utils/src/assoc.rs               | 14 ++---
 src/librustdoc/clean/inline.rs                     |  2 +-
 src/librustdoc/clean/mod.rs                        |  4 +-
 .../src/arbitrary_source_item_ordering.rs          | 67 ++++++++++++----------
 .../clippy/clippy_lints/src/derivable_impls.rs     |  2 +-
 src/tools/clippy/clippy_lints/src/empty_drop.rs    |  2 +-
 .../clippy/clippy_lints/src/fallible_impl_from.rs  | 64 ++++++++++-----------
 .../clippy/clippy_lints/src/from_over_into.rs      |  8 +--
 .../clippy/clippy_lints/src/implicit_hasher.rs     |  2 +-
 .../clippy_lints/src/iter_without_into_iter.rs     | 13 ++---
 src/tools/clippy/clippy_lints/src/len_zero.rs      | 10 ++--
 src/tools/clippy/clippy_lints/src/lifetimes.rs     |  2 +-
 .../clippy_lints/src/missing_fields_in_debug.rs    | 11 ++--
 .../clippy/clippy_lints/src/missing_inline.rs      |  8 +--
 .../clippy/clippy_lints/src/partialeq_ne_impl.rs   |  6 +-
 src/tools/clippy/clippy_lints/src/serde_api.rs     |  6 +-
 src/tools/clippy/clippy_utils/src/paths.rs         | 28 ++++-----
 .../ordering_mixed.default.stderr                  |  8 +--
 .../ordering_mixed.default_exp.stderr              |  8 +--
 .../ordering_mixed.ord_within.stderr               |  8 +--
 .../ordering_mixed_var_1.var_1.stderr              | 14 ++---
 .../ordering_only_impl.only_impl.stderr            |  8 +--
 .../ordering_only_trait.only_trait.stderr          |  4 +-
 src/tools/clippy/tests/ui/partialeq_ne_impl.stderr |  8 +--
 src/tools/clippy/tests/ui/serde.stderr             |  5 +-
 tests/ui/associated-consts/issue-58022.stderr      |  2 +-
 tests/ui/associated-consts/issue-63496.stderr      |  4 +-
 tests/ui/associated-item/issue-48027.stderr        |  2 +-
 tests/ui/consts/issue-54954.stderr                 | 11 ++--
 tests/ui/error-codes/E0790.stderr                  |  4 +-
 .../feature-gates/feature-gate-async-drop.stderr   |  2 +-
 tests/ui/lint/lint-stability.stderr                |  2 +-
 tests/ui/stats/input-stats.stderr                  |  6 +-
 tests/ui/suggestions/issue-104327.stderr           |  2 +-
 .../rustc_must_implement_one_of_misuse.stderr      |  4 +-
 .../deref-upcast-shadowing-lint.stderr             |  2 +-
 .../migrate-lint-deny-regions.stderr               |  2 +-
 .../migrate-lint-different-substs.stderr           |  2 +-
 52 files changed, 244 insertions(+), 308 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/index.rs b/compiler/rustc_ast_lowering/src/index.rs
index 2fc8f95689f..1ef64f5a352 100644
--- a/compiler/rustc_ast_lowering/src/index.rs
+++ b/compiler/rustc_ast_lowering/src/index.rs
@@ -381,20 +381,12 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         })
     }
 
-    fn visit_trait_item_ref(&mut self, ii: &'hir TraitItemRef) {
-        // Do not visit the duplicate information in TraitItemRef. We want to
-        // map the actual nodes, not the duplicate ones in the *Ref.
-        let TraitItemRef { id, ident: _, span: _ } = *ii;
-
-        self.visit_nested_trait_item(id);
+    fn visit_trait_item_ref(&mut self, id: &'hir TraitItemId) {
+        self.visit_nested_trait_item(*id);
     }
 
-    fn visit_impl_item_ref(&mut self, ii: &'hir ImplItemRef) {
-        // Do not visit the duplicate information in ImplItemRef. We want to
-        // map the actual nodes, not the duplicate ones in the *Ref.
-        let ImplItemRef { id, ident: _, span: _ } = *ii;
-
-        self.visit_nested_impl_item(id);
+    fn visit_impl_item_ref(&mut self, id: &'hir ImplItemId) {
+        self.visit_nested_impl_item(*id);
     }
 
     fn visit_foreign_item_ref(&mut self, id: &'hir ForeignItemId) {
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 253e0c04c4d..9d40a7386f6 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -964,13 +964,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.arena.alloc(item)
     }
 
-    fn lower_trait_item_ref(&mut self, i: &AssocItem) -> hir::TraitItemRef {
-        let id = hir::TraitItemId { owner_id: self.owner_id(i.id) };
-        hir::TraitItemRef {
-            id,
-            ident: self.lower_ident(i.kind.ident().unwrap()),
-            span: self.lower_span(i.span),
-        }
+    fn lower_trait_item_ref(&mut self, i: &AssocItem) -> hir::TraitItemId {
+        hir::TraitItemId { owner_id: self.owner_id(i.id) }
     }
 
     /// Construct `ExprKind::Err` for the given `span`.
@@ -1110,14 +1105,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.arena.alloc(item)
     }
 
-    fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemRef {
-        hir::ImplItemRef {
-            id: hir::ImplItemId { owner_id: self.owner_id(i.id) },
-            // `unwrap` is safe because `AssocItemKind::{MacCall,DelegationMac}` are the only
-            // assoc item kinds without an identifier and they cannot reach here.
-            ident: self.lower_ident(i.kind.ident().unwrap()),
-            span: self.lower_span(i.span),
-        }
+    fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemId {
+        hir::ImplItemId { owner_id: self.owner_id(i.id) }
     }
 
     fn lower_defaultness(
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index cdd1547fc60..80e07af8a46 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -4162,7 +4162,7 @@ impl<'hir> Item<'hir> {
                 Ident,
                 &'hir Generics<'hir>,
                 GenericBounds<'hir>,
-                &'hir [TraitItemRef]
+                &'hir [TraitItemId]
             ),
             ItemKind::Trait(is_auto, safety, ident, generics, bounds, items),
             (*is_auto, *safety, *ident, generics, bounds, items);
@@ -4335,7 +4335,7 @@ pub enum ItemKind<'hir> {
     /// A union definition, e.g., `union Foo<A, B> {x: A, y: B}`.
     Union(Ident, &'hir Generics<'hir>, VariantData<'hir>),
     /// A trait definition.
-    Trait(IsAuto, Safety, Ident, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]),
+    Trait(IsAuto, Safety, Ident, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemId]),
     /// A trait alias.
     TraitAlias(Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
 
@@ -4362,7 +4362,7 @@ pub struct Impl<'hir> {
     pub of_trait: Option<TraitRef<'hir>>,
 
     pub self_ty: &'hir Ty<'hir>,
-    pub items: &'hir [ImplItemRef],
+    pub items: &'hir [ImplItemId],
 }
 
 impl ItemKind<'_> {
@@ -4405,32 +4405,6 @@ impl ItemKind<'_> {
     }
 }
 
-/// A reference from an trait to one of its associated items. This
-/// contains the item's id, naturally, but also the item's name and
-/// some other high-level details (like whether it is an associated
-/// type or method, and whether it is public). This allows other
-/// passes to find the impl they want without loading the ID (which
-/// means fewer edges in the incremental compilation graph).
-#[derive(Debug, Clone, Copy, HashStable_Generic)]
-pub struct TraitItemRef {
-    pub id: TraitItemId,
-    pub ident: Ident,
-    pub span: Span,
-}
-
-/// A reference from an impl to one of its associated items. This
-/// contains the item's ID, naturally, but also the item's name and
-/// some other high-level details (like whether it is an associated
-/// type or method, and whether it is public). This allows other
-/// passes to find the impl they want without loading the ID (which
-/// means fewer edges in the incremental compilation graph).
-#[derive(Debug, Clone, Copy, HashStable_Generic)]
-pub struct ImplItemRef {
-    pub id: ImplItemId,
-    pub ident: Ident,
-    pub span: Span,
-}
-
 // The bodies for items are stored "out of line", in a separate
 // hashmap in the `Crate`. Here we just record the hir-id of the item
 // so it can fetched later.
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index 552f17e0950..3edb94c28da 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -435,8 +435,8 @@ pub trait Visitor<'v>: Sized {
     fn visit_trait_item(&mut self, ti: &'v TraitItem<'v>) -> Self::Result {
         walk_trait_item(self, ti)
     }
-    fn visit_trait_item_ref(&mut self, ii: &'v TraitItemRef) -> Self::Result {
-        walk_trait_item_ref(self, ii)
+    fn visit_trait_item_ref(&mut self, ii: &'v TraitItemId) -> Self::Result {
+        walk_trait_item_ref(self, *ii)
     }
     fn visit_impl_item(&mut self, ii: &'v ImplItem<'v>) -> Self::Result {
         walk_impl_item(self, ii)
@@ -444,8 +444,8 @@ pub trait Visitor<'v>: Sized {
     fn visit_foreign_item_ref(&mut self, ii: &'v ForeignItemId) -> Self::Result {
         walk_foreign_item_ref(self, *ii)
     }
-    fn visit_impl_item_ref(&mut self, ii: &'v ImplItemRef) -> Self::Result {
-        walk_impl_item_ref(self, ii)
+    fn visit_impl_item_ref(&mut self, ii: &'v ImplItemId) -> Self::Result {
+        walk_impl_item_ref(self, *ii)
     }
     fn visit_trait_ref(&mut self, t: &'v TraitRef<'v>) -> Self::Result {
         walk_trait_ref(self, t)
@@ -1245,13 +1245,8 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(
     V::Result::output()
 }
 
-pub fn walk_trait_item_ref<'v, V: Visitor<'v>>(
-    visitor: &mut V,
-    trait_item_ref: &'v TraitItemRef,
-) -> V::Result {
-    let TraitItemRef { id, ident, span: _ } = *trait_item_ref;
-    try_visit!(visitor.visit_nested_trait_item(id));
-    visitor.visit_ident(ident)
+pub fn walk_trait_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, id: TraitItemId) -> V::Result {
+    visitor.visit_nested_trait_item(id)
 }
 
 pub fn walk_impl_item<'v, V: Visitor<'v>>(
@@ -1294,13 +1289,8 @@ pub fn walk_foreign_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, id: ForeignIte
     visitor.visit_nested_foreign_item(id)
 }
 
-pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(
-    visitor: &mut V,
-    impl_item_ref: &'v ImplItemRef,
-) -> V::Result {
-    let ImplItemRef { id, ident, span: _ } = *impl_item_ref;
-    try_visit!(visitor.visit_nested_impl_item(id));
-    visitor.visit_ident(ident)
+pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, id: ImplItemId) -> V::Result {
+    visitor.visit_nested_impl_item(id)
 }
 
 pub fn walk_trait_ref<'v, V: Visitor<'v>>(
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 50b0146d80c..28a8758178f 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -844,11 +844,9 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::AdtDef<'_> {
 fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     let item = tcx.hir_expect_item(def_id);
 
-    let (is_alias, is_auto, safety, items) = match item.kind {
-        hir::ItemKind::Trait(is_auto, safety, .., items) => {
-            (false, is_auto == hir::IsAuto::Yes, safety, items)
-        }
-        hir::ItemKind::TraitAlias(..) => (true, false, hir::Safety::Safe, &[][..]),
+    let (is_alias, is_auto, safety) = match item.kind {
+        hir::ItemKind::Trait(is_auto, safety, ..) => (false, is_auto == hir::IsAuto::Yes, safety),
+        hir::ItemKind::TraitAlias(..) => (true, false, hir::Safety::Safe),
         _ => span_bug!(item.span, "trait_def_of_item invoked on non-trait"),
     };
 
@@ -911,13 +909,16 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
         // functions in the trait with default implementations
         .and_then(|(list, attr_span)| {
             let errors = list.iter().filter_map(|ident| {
-                let item = items.iter().find(|item| item.ident == *ident);
+                let item = tcx
+                    .associated_items(def_id)
+                    .filter_by_name_unhygienic(ident.name)
+                    .find(|item| item.ident(tcx) == *ident);
 
                 match item {
-                    Some(item) if matches!(tcx.def_kind(item.id.owner_id), DefKind::AssocFn) => {
-                        if !tcx.defaultness(item.id.owner_id).has_value() {
+                    Some(item) if matches!(item.kind, ty::AssocKind::Fn { .. }) => {
+                        if !item.defaultness(tcx).has_value() {
                             tcx.dcx().emit_err(errors::FunctionNotHaveDefaultImplementation {
-                                span: item.span,
+                                span: tcx.def_span(item.def_id),
                                 note_span: attr_span,
                             });
 
@@ -928,7 +929,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
                     }
                     Some(item) => {
                         tcx.dcx().emit_err(errors::MustImplementNotFunction {
-                            span: item.span,
+                            span: tcx.def_span(item.def_id),
                             span_note: errors::MustImplementNotFunctionSpanNote { span: attr_span },
                             note: errors::MustImplementNotFunctionNote {},
                         });
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index 42adbd922a0..2c13c9ef438 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -730,8 +730,8 @@ impl<'a> State<'a> {
 
                 self.space();
                 self.bopen(ib);
-                for impl_item in items {
-                    self.ann.nested(self, Nested::ImplItem(impl_item.id));
+                for &impl_item in items {
+                    self.ann.nested(self, Nested::ImplItem(impl_item));
                 }
                 self.bclose(item.span, cb);
             }
@@ -746,8 +746,8 @@ impl<'a> State<'a> {
                 self.print_where_clause(generics);
                 self.word(" ");
                 self.bopen(ib);
-                for trait_item in trait_items {
-                    self.ann.nested(self, Nested::TraitItem(trait_item.id));
+                for &trait_item in trait_items {
+                    self.ann.nested(self, Nested::TraitItem(trait_item));
                 }
                 self.bclose(item.span, cb);
             }
diff --git a/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs b/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
index 5989ef9519c..dd16117db1c 100644
--- a/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
+++ b/compiler/rustc_lint/src/deref_into_dyn_supertrait.rs
@@ -1,7 +1,7 @@
 use rustc_hir::{self as hir, LangItem};
 use rustc_middle::ty;
 use rustc_session::{declare_lint, declare_lint_pass};
-use rustc_span::sym;
+use rustc_span::{Ident, sym};
 use rustc_trait_selection::traits::supertraits;
 
 use crate::lints::{SupertraitAsDerefTarget, SupertraitAsDerefTargetLabel};
@@ -79,11 +79,15 @@ impl<'tcx> LateLintPass<'tcx> for DerefIntoDynSupertrait {
             // erase regions in self type for better diagnostic presentation
             let (self_ty, target_principal, supertrait_principal) =
                 tcx.erase_regions((self_ty, target_principal, supertrait_principal));
-            let label2 = impl_
-                .items
-                .iter()
-                .find_map(|i| (i.ident.name == sym::Target).then_some(i.span))
-                .map(|label| SupertraitAsDerefTargetLabel { label });
+            let label2 = tcx
+                .associated_items(item.owner_id)
+                .find_by_ident_and_kind(
+                    tcx,
+                    Ident::with_dummy_span(sym::Target),
+                    ty::AssocTag::Type,
+                    item.owner_id.to_def_id(),
+                )
+                .map(|label| SupertraitAsDerefTargetLabel { label: tcx.def_span(label.def_id) });
             let span = tcx.def_span(item.owner_id.def_id);
             cx.emit_span_lint(
                 DEREF_INTO_DYN_SUPERTRAIT,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 38f82de9184..e7af615a715 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1152,7 +1152,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             ItemKind::Trait(_, _, _, generics, _, items)
                 if generics.params.len() != 0
                     || items.iter().any(|item| {
-                        matches!(self.tcx.def_kind(item.id.owner_id), DefKind::AssocTy)
+                        matches!(self.tcx.def_kind(item.owner_id), DefKind::AssocTy)
                     }) => {}
             ItemKind::TyAlias(_, generics, _) if generics.params.len() != 0 => {}
             _ => {
diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
index 1fd7cc25524..948a901e091 100644
--- a/compiler/rustc_passes/src/dead.rs
+++ b/compiler/rustc_passes/src/dead.rs
@@ -415,8 +415,8 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
                 hir::ItemKind::Trait(.., trait_item_refs) => {
                     // mark assoc ty live if the trait is live
                     for trait_item in trait_item_refs {
-                        if matches!(self.tcx.def_kind(trait_item.id.owner_id), DefKind::AssocTy) {
-                            self.check_def_id(trait_item.id.owner_id.to_def_id());
+                        if matches!(self.tcx.def_kind(trait_item.owner_id), DefKind::AssocTy) {
+                            self.check_def_id(trait_item.owner_id.to_def_id());
                         }
                     }
                     intravisit::walk_item(self, item)
diff --git a/compiler/rustc_passes/src/input_stats.rs b/compiler/rustc_passes/src/input_stats.rs
index 9451d946669..6ee325dce03 100644
--- a/compiler/rustc_passes/src/input_stats.rs
+++ b/compiler/rustc_passes/src/input_stats.rs
@@ -467,9 +467,9 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
         hir_visit::walk_trait_item(self, ti)
     }
 
-    fn visit_trait_item_ref(&mut self, ti: &'v hir::TraitItemRef) {
-        self.record("TraitItemRef", Some(ti.id.hir_id()), ti);
-        hir_visit::walk_trait_item_ref(self, ti)
+    fn visit_trait_item_ref(&mut self, ti: &'v hir::TraitItemId) {
+        self.record("TraitItemId", Some(ti.hir_id()), ti);
+        hir_visit::walk_trait_item_ref(self, *ti)
     }
 
     fn visit_impl_item(&mut self, ii: &'v hir::ImplItem<'v>) {
@@ -485,9 +485,9 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
         hir_visit::walk_foreign_item_ref(self, *fi)
     }
 
-    fn visit_impl_item_ref(&mut self, ii: &'v hir::ImplItemRef) {
-        self.record("ImplItemRef", Some(ii.id.hir_id()), ii);
-        hir_visit::walk_impl_item_ref(self, ii)
+    fn visit_impl_item_ref(&mut self, ii: &'v hir::ImplItemId) {
+        self.record("ImplItemId", Some(ii.hir_id()), ii);
+        hir_visit::walk_impl_item_ref(self, *ii)
     }
 
     fn visit_param_bound(&mut self, b: &'v hir::GenericBound<'v>) {
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index a30655d32a7..adda94fda8f 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -880,11 +880,16 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                 }
 
                 for impl_item_ref in *items {
-                    let impl_item = self.tcx.associated_item(impl_item_ref.id.owner_id);
+                    let impl_item = self.tcx.associated_item(impl_item_ref.owner_id);
 
                     if let Some(def_id) = impl_item.trait_item_def_id {
                         // Pass `None` to skip deprecation warnings.
-                        self.tcx.check_stability(def_id, None, impl_item_ref.span, None);
+                        self.tcx.check_stability(
+                            def_id,
+                            None,
+                            self.tcx.def_span(impl_item_ref.owner_id),
+                            None,
+                        );
                     }
                 }
             }
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index 6f8b7a1209e..ab2433234aa 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -672,14 +672,14 @@ impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
                     self.reach(item.owner_id.def_id, item_ev).generics().predicates();
 
                     for trait_item_ref in trait_item_refs {
-                        self.update(trait_item_ref.id.owner_id.def_id, item_ev, Level::Reachable);
+                        self.update(trait_item_ref.owner_id.def_id, item_ev, Level::Reachable);
 
                         let tcx = self.tcx;
-                        let mut reach = self.reach(trait_item_ref.id.owner_id.def_id, item_ev);
+                        let mut reach = self.reach(trait_item_ref.owner_id.def_id, item_ev);
                         reach.generics().predicates();
 
-                        if let DefKind::AssocTy = tcx.def_kind(trait_item_ref.id.owner_id)
-                            && !tcx.defaultness(trait_item_ref.id.owner_id).has_value()
+                        if let DefKind::AssocTy = tcx.def_kind(trait_item_ref.owner_id)
+                            && !tcx.defaultness(trait_item_ref.owner_id).has_value()
                         {
                             // No type to visit.
                         } else {
@@ -715,7 +715,7 @@ impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
                 self.reach(item.owner_id.def_id, item_ev).generics().predicates().ty().trait_ref();
 
                 for impl_item_ref in impl_.items {
-                    let def_id = impl_item_ref.id.owner_id.def_id;
+                    let def_id = impl_item_ref.owner_id.def_id;
                     let max_vis =
                         impl_.of_trait.is_none().then(|| self.tcx.local_visibility(def_id));
                     self.update_eff_vis(def_id, item_ev, max_vis, Level::Direct);
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 a8ba1baf6b9..712e88300ff 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
@@ -362,7 +362,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         && self.tcx.trait_of_item(*item_id) == Some(*trait_id)
                         && let None = self.tainted_by_errors()
                     {
-                        let (verb, noun) = match self.tcx.associated_item(item_id).kind {
+                        let assoc_item = self.tcx.associated_item(item_id);
+                        let (verb, noun) = match assoc_item.kind {
                             ty::AssocKind::Const { .. } => ("refer to the", "constant"),
                             ty::AssocKind::Fn { .. } => ("call", "function"),
                             // This is already covered by E0223, but this following single match
@@ -381,17 +382,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         );
                         err.code(E0790);
 
-                        if let Some(local_def_id) = data.trait_ref.def_id.as_local()
-                            && let hir::Node::Item(hir::Item {
-                                kind: hir::ItemKind::Trait(_, _, trait_ident, _, _, trait_item_refs),
-                                ..
-                            }) = self.tcx.hir_node_by_def_id(local_def_id)
-                            && let Some(method_ref) = trait_item_refs
-                                .iter()
-                                .find(|item_ref| item_ref.ident == *assoc_item_ident)
-                        {
+                        if item_id.is_local() {
+                            let trait_ident = self.tcx.item_name(*trait_id);
                             err.span_label(
-                                method_ref.span,
+                                self.tcx.def_span(*item_id),
                                 format!("`{trait_ident}::{assoc_item_ident}` defined here"),
                             );
                         }
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index d4e6a23f0eb..fed9f254cdf 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -288,9 +288,9 @@ fn extend_cause_with_original_assoc_item_obligation<'tcx>(
             && let Some(&impl_item_id) =
                 tcx.impl_item_implementor_ids(impl_def_id).get(&projection_ty.def_id)
             && let Some(impl_item) =
-                items.iter().find(|item| item.id.owner_id.to_def_id() == impl_item_id)
+                items.iter().find(|item| item.owner_id.to_def_id() == impl_item_id)
         {
-            Some(tcx.hir_impl_item(impl_item.id).expect_type().span)
+            Some(tcx.hir_impl_item(*impl_item).expect_type().span)
         } else {
             None
         }
diff --git a/compiler/rustc_ty_utils/src/assoc.rs b/compiler/rustc_ty_utils/src/assoc.rs
index fecc56091b9..37cb64511c7 100644
--- a/compiler/rustc_ty_utils/src/assoc.rs
+++ b/compiler/rustc_ty_utils/src/assoc.rs
@@ -29,7 +29,7 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &[DefId] {
             // query.
             let rpitit_items = tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id);
             tcx.arena.alloc_from_iter(trait_item_refs.iter().flat_map(|trait_item_ref| {
-                let item_def_id = trait_item_ref.id.owner_id.to_def_id();
+                let item_def_id = trait_item_ref.owner_id.to_def_id();
                 [item_def_id]
                     .into_iter()
                     .chain(rpitit_items.get(&item_def_id).into_iter().flatten().copied())
@@ -41,7 +41,7 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &[DefId] {
             // associated_types_for_impl_traits_in_trait_or_impl query.
             let rpitit_items = tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id);
             tcx.arena.alloc_from_iter(impl_.items.iter().flat_map(|impl_item_ref| {
-                let item_def_id = impl_item_ref.id.owner_id.to_def_id();
+                let item_def_id = impl_item_ref.owner_id.to_def_id();
                 [item_def_id]
                     .into_iter()
                     .chain(rpitit_items.get(&item_def_id).into_iter().flatten().copied())
@@ -154,10 +154,10 @@ fn associated_types_for_impl_traits_in_trait_or_impl<'tcx>(
         ItemKind::Trait(.., trait_item_refs) => trait_item_refs
             .iter()
             .filter_map(move |item| {
-                if !matches!(tcx.def_kind(item.id.owner_id), DefKind::AssocFn) {
+                if !matches!(tcx.def_kind(item.owner_id), DefKind::AssocFn) {
                     return None;
                 }
-                let fn_def_id = item.id.owner_id.def_id;
+                let fn_def_id = item.owner_id.def_id;
                 let Some(output) = tcx.hir_get_fn_output(fn_def_id) else {
                     return Some((fn_def_id.to_def_id(), vec![]));
                 };
@@ -185,11 +185,11 @@ fn associated_types_for_impl_traits_in_trait_or_impl<'tcx>(
                 .items
                 .iter()
                 .filter_map(|item| {
-                    if !matches!(tcx.def_kind(item.id.owner_id), DefKind::AssocFn) {
+                    if !matches!(tcx.def_kind(item.owner_id), DefKind::AssocFn) {
                         return None;
                     }
-                    let did = item.id.owner_id.def_id.to_def_id();
-                    let item = tcx.hir_impl_item(item.id);
+                    let did = item.owner_id.def_id.to_def_id();
+                    let item = tcx.hir_impl_item(*item);
                     let Some(trait_item_def_id) = item.trait_item_def_id else {
                         return Some((did, vec![]));
                     };
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index 37b012d6d0d..9603399f235 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -499,7 +499,7 @@ pub(crate) fn build_impl(
             impl_
                 .items
                 .iter()
-                .map(|item| tcx.hir_impl_item(item.id))
+                .map(|&item| tcx.hir_impl_item(item))
                 .filter(|item| {
                     // Filter out impl items whose corresponding trait item has `doc(hidden)`
                     // not to document such impl items.
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index e6f7aef02c0..e7a1f4d8397 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2867,7 +2867,7 @@ fn clean_maybe_renamed_item<'tcx>(
             ItemKind::Trait(_, _, _, generics, bounds, item_ids) => {
                 let items = item_ids
                     .iter()
-                    .map(|ti| clean_trait_item(cx.tcx.hir_trait_item(ti.id), cx))
+                    .map(|&ti| clean_trait_item(cx.tcx.hir_trait_item(ti), cx))
                     .collect();
 
                 TraitItem(Box::new(Trait {
@@ -2910,7 +2910,7 @@ fn clean_impl<'tcx>(
     let items = impl_
         .items
         .iter()
-        .map(|ii| clean_impl_item(tcx.hir_impl_item(ii.id), cx))
+        .map(|&ii| clean_impl_item(tcx.hir_impl_item(ii), cx))
         .collect::<Vec<_>>();
 
     // If this impl block is an implementation of the Deref trait, then we
diff --git a/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs b/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs
index ee8da707a80..3a2bad6187c 100644
--- a/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs
+++ b/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs
@@ -8,12 +8,13 @@ use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::is_cfg_test;
 use rustc_attr_data_structures::AttributeKind;
 use rustc_hir::{
-    Attribute, FieldDef, HirId, ImplItemRef, IsAuto, Item, ItemKind, Mod, OwnerId, QPath, TraitItemRef, TyKind,
+    Attribute, FieldDef, HirId, IsAuto, ImplItemId, Item, ItemKind, Mod, OwnerId, QPath, TraitItemId, TyKind,
     Variant, VariantData,
 };
 use rustc_middle::ty::AssocKind;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
+use rustc_span::Ident;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -195,22 +196,22 @@ impl ArbitrarySourceItemOrdering {
     }
 
     /// Produces a linting warning for incorrectly ordered impl items.
-    fn lint_impl_item<T: LintContext>(&self, cx: &T, item: &ImplItemRef, before_item: &ImplItemRef) {
+    fn lint_impl_item(&self, cx: &LateContext<'_>, item: ImplItemId, before_item: ImplItemId) {
         span_lint_and_note(
             cx,
             ARBITRARY_SOURCE_ITEM_ORDERING,
-            item.span,
+            cx.tcx.def_span(item.owner_id),
             format!(
                 "incorrect ordering of impl items (defined order: {:?})",
                 self.assoc_types_order
             ),
-            Some(before_item.span),
-            format!("should be placed before `{}`", before_item.ident.name),
+            Some(cx.tcx.def_span(before_item.owner_id)),
+            format!("should be placed before `{}`", cx.tcx.item_name(before_item.owner_id)),
         );
     }
 
     /// Produces a linting warning for incorrectly ordered item members.
-    fn lint_member_name<T: LintContext>(cx: &T, ident: &rustc_span::Ident, before_ident: &rustc_span::Ident) {
+    fn lint_member_name<T: LintContext>(cx: &T, ident: Ident, before_ident: Ident) {
         span_lint_and_note(
             cx,
             ARBITRARY_SOURCE_ITEM_ORDERING,
@@ -221,7 +222,7 @@ impl ArbitrarySourceItemOrdering {
         );
     }
 
-    fn lint_member_item<T: LintContext>(cx: &T, item: &Item<'_>, before_item: &Item<'_>, msg: &'static str) {
+    fn lint_member_item(cx: &LateContext<'_>, item: &Item<'_>, before_item: &Item<'_>, msg: &'static str) {
         let span = if let Some(ident) = item.kind.ident() {
             ident.span
         } else {
@@ -246,17 +247,17 @@ impl ArbitrarySourceItemOrdering {
     }
 
     /// Produces a linting warning for incorrectly ordered trait items.
-    fn lint_trait_item<T: LintContext>(&self, cx: &T, item: &TraitItemRef, before_item: &TraitItemRef) {
+    fn lint_trait_item(&self, cx: &LateContext<'_>, item: TraitItemId, before_item: TraitItemId) {
         span_lint_and_note(
             cx,
             ARBITRARY_SOURCE_ITEM_ORDERING,
-            item.span,
+            cx.tcx.def_span(item.owner_id),
             format!(
                 "incorrect ordering of trait items (defined order: {:?})",
                 self.assoc_types_order
             ),
-            Some(before_item.span),
-            format!("should be placed before `{}`", before_item.ident.name),
+            Some(cx.tcx.def_span(before_item.owner_id)),
+            format!("should be placed before `{}`", cx.tcx.item_name(before_item.owner_id)),
         );
     }
 }
@@ -284,7 +285,7 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
                         && cur_v.ident.name.as_str() > variant.ident.name.as_str()
                         && cur_v.span != variant.span
                     {
-                        Self::lint_member_name(cx, &variant.ident, &cur_v.ident);
+                        Self::lint_member_name(cx, variant.ident, cur_v.ident);
                     }
                     cur_v = Some(variant);
                 }
@@ -300,7 +301,7 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
                         && cur_f.ident.name.as_str() > field.ident.name.as_str()
                         && cur_f.span != field.span
                     {
-                        Self::lint_member_name(cx, &field.ident, &cur_f.ident);
+                        Self::lint_member_name(cx, field.ident, cur_f.ident);
                     }
                     cur_f = Some(field);
                 }
@@ -308,49 +309,53 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
             ItemKind::Trait(is_auto, _safety, _ident, _generics, _generic_bounds, item_ref)
                 if self.enable_ordering_for_trait && *is_auto == IsAuto::No =>
             {
-                let mut cur_t: Option<&TraitItemRef> = None;
+                let mut cur_t: Option<(TraitItemId, Ident)> = None;
 
-                for item in *item_ref {
-                    if item.span.in_external_macro(cx.sess().source_map()) {
+                for &item in *item_ref {
+                    let span = cx.tcx.def_span(item.owner_id);
+                    let ident = cx.tcx.item_ident(item.owner_id);
+                    if span.in_external_macro(cx.sess().source_map()) {
                         continue;
                     }
 
-                    if let Some(cur_t) = cur_t {
-                        let cur_t_kind = convert_assoc_item_kind(cx, cur_t.id.owner_id);
+                    if let Some((cur_t, cur_ident)) = cur_t {
+                        let cur_t_kind = convert_assoc_item_kind(cx, cur_t.owner_id);
                         let cur_t_kind_index = self.assoc_types_order.index_of(&cur_t_kind);
-                        let item_kind = convert_assoc_item_kind(cx,item.id.owner_id);
+                        let item_kind = convert_assoc_item_kind(cx, item.owner_id);
                         let item_kind_index = self.assoc_types_order.index_of(&item_kind);
 
-                        if cur_t_kind == item_kind && cur_t.ident.name.as_str() > item.ident.name.as_str() {
-                            Self::lint_member_name(cx, &item.ident, &cur_t.ident);
+                        if cur_t_kind == item_kind && cur_ident.name.as_str() > ident.name.as_str() {
+                            Self::lint_member_name(cx, ident, cur_ident);
                         } else if cur_t_kind_index > item_kind_index {
                             self.lint_trait_item(cx, item, cur_t);
                         }
                     }
-                    cur_t = Some(item);
+                    cur_t = Some((item, ident));
                 }
             },
             ItemKind::Impl(trait_impl) if self.enable_ordering_for_impl => {
-                let mut cur_t: Option<&ImplItemRef> = None;
+                let mut cur_t: Option<(ImplItemId, Ident)> = None;
 
-                for item in trait_impl.items {
-                    if item.span.in_external_macro(cx.sess().source_map()) {
+                for &item in trait_impl.items {
+                    let span = cx.tcx.def_span(item.owner_id);
+                    let ident = cx.tcx.item_ident(item.owner_id);
+                    if span.in_external_macro(cx.sess().source_map()) {
                         continue;
                     }
 
-                    if let Some(cur_t) = cur_t {
-                        let cur_t_kind = convert_assoc_item_kind(cx, cur_t.id.owner_id);
+                    if let Some((cur_t, cur_ident)) = cur_t {
+                        let cur_t_kind = convert_assoc_item_kind(cx, cur_t.owner_id);
                         let cur_t_kind_index = self.assoc_types_order.index_of(&cur_t_kind);
-                        let item_kind = convert_assoc_item_kind(cx, item.id.owner_id);
+                        let item_kind = convert_assoc_item_kind(cx, item.owner_id);
                         let item_kind_index = self.assoc_types_order.index_of(&item_kind);
 
-                        if cur_t_kind == item_kind && cur_t.ident.name.as_str() > item.ident.name.as_str() {
-                            Self::lint_member_name(cx, &item.ident, &cur_t.ident);
+                        if cur_t_kind == item_kind && cur_ident.name.as_str() > ident.name.as_str() {
+                            Self::lint_member_name(cx, ident, cur_ident);
                         } else if cur_t_kind_index > item_kind_index {
                             self.lint_impl_item(cx, item, cur_t);
                         }
                     }
-                    cur_t = Some(item);
+                    cur_t = Some((item, ident));
                 }
             },
             _ => {}, // Catch-all for `ItemKinds` that don't have fields.
diff --git a/src/tools/clippy/clippy_lints/src/derivable_impls.rs b/src/tools/clippy/clippy_lints/src/derivable_impls.rs
index 10331b3855b..0a481ddcd12 100644
--- a/src/tools/clippy/clippy_lints/src/derivable_impls.rs
+++ b/src/tools/clippy/clippy_lints/src/derivable_impls.rs
@@ -192,7 +192,7 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
             && !item.span.from_expansion()
             && let Some(def_id) = trait_ref.trait_def_id()
             && cx.tcx.is_diagnostic_item(sym::Default, def_id)
-            && let impl_item_hir = child.id.hir_id()
+            && let impl_item_hir = child.hir_id()
             && let Node::ImplItem(impl_item) = cx.tcx.hir_node(impl_item_hir)
             && let ImplItemKind::Fn(_, b) = &impl_item.kind
             && let Body { value: func_expr, .. } = cx.tcx.hir_body(*b)
diff --git a/src/tools/clippy/clippy_lints/src/empty_drop.rs b/src/tools/clippy/clippy_lints/src/empty_drop.rs
index d557a36c7ac..4e948701da4 100644
--- a/src/tools/clippy/clippy_lints/src/empty_drop.rs
+++ b/src/tools/clippy/clippy_lints/src/empty_drop.rs
@@ -41,7 +41,7 @@ impl LateLintPass<'_> for EmptyDrop {
             ..
         }) = item.kind
             && trait_ref.trait_def_id() == cx.tcx.lang_items().drop_trait()
-            && let impl_item_hir = child.id.hir_id()
+            && let impl_item_hir = child.hir_id()
             && let Node::ImplItem(impl_item) = cx.tcx.hir_node(impl_item_hir)
             && let ImplItemKind::Fn(_, b) = &impl_item.kind
             && let Body { value: func_expr, .. } = cx.tcx.hir_body(*b)
diff --git a/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs b/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs
index 68d0cd19c8a..552cd721f4e 100644
--- a/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs
+++ b/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs
@@ -52,20 +52,20 @@ declare_lint_pass!(FallibleImplFrom => [FALLIBLE_IMPL_FROM]);
 impl<'tcx> LateLintPass<'tcx> for FallibleImplFrom {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         // check for `impl From<???> for ..`
-        if let hir::ItemKind::Impl(impl_) = &item.kind
+        if let hir::ItemKind::Impl(_) = &item.kind
             && let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id)
             && cx
                 .tcx
                 .is_diagnostic_item(sym::From, impl_trait_ref.skip_binder().def_id)
         {
-            lint_impl_body(cx, item.span, impl_.items);
+            lint_impl_body(cx, item.owner_id, item.span);
         }
     }
 }
 
-fn lint_impl_body(cx: &LateContext<'_>, impl_span: Span, impl_items: &[hir::ImplItemRef]) {
+fn lint_impl_body(cx: &LateContext<'_>, item_def_id: hir::OwnerId, impl_span: Span) {
     use rustc_hir::intravisit::{self, Visitor};
-    use rustc_hir::{Expr, ImplItemKind};
+    use rustc_hir::Expr;
 
     struct FindPanicUnwrap<'a, 'tcx> {
         lcx: &'a LateContext<'tcx>,
@@ -96,35 +96,35 @@ fn lint_impl_body(cx: &LateContext<'_>, impl_span: Span, impl_items: &[hir::Impl
         }
     }
 
-    for impl_item in impl_items {
-        if impl_item.ident.name == sym::from
-            && let ImplItemKind::Fn(_, body_id) = cx.tcx.hir_impl_item(impl_item.id).kind
-        {
-            // check the body for `begin_panic` or `unwrap`
-            let body = cx.tcx.hir_body(body_id);
-            let mut fpu = FindPanicUnwrap {
-                lcx: cx,
-                typeck_results: cx.tcx.typeck(impl_item.id.owner_id.def_id),
-                result: Vec::new(),
-            };
-            fpu.visit_expr(body.value);
+    for impl_item in cx.tcx.associated_items(item_def_id)
+        .filter_by_name_unhygienic_and_kind(sym::from, ty::AssocTag::Fn)
+    {
+        let impl_item_def_id= impl_item.def_id.expect_local();
 
-            // if we've found one, lint
-            if !fpu.result.is_empty() {
-                span_lint_and_then(
-                    cx,
-                    FALLIBLE_IMPL_FROM,
-                    impl_span,
-                    "consider implementing `TryFrom` instead",
-                    move |diag| {
-                        diag.help(
-                            "`From` is intended for infallible conversions only. \
-                            Use `TryFrom` if there's a possibility for the conversion to fail",
-                        );
-                        diag.span_note(fpu.result, "potential failure(s)");
-                    },
-                );
-            }
+        // check the body for `begin_panic` or `unwrap`
+        let body = cx.tcx.hir_body_owned_by(impl_item_def_id);
+        let mut fpu = FindPanicUnwrap {
+            lcx: cx,
+            typeck_results: cx.tcx.typeck(impl_item_def_id),
+            result: Vec::new(),
+        };
+        fpu.visit_expr(body.value);
+
+        // if we've found one, lint
+        if !fpu.result.is_empty() {
+            span_lint_and_then(
+                cx,
+                FALLIBLE_IMPL_FROM,
+                impl_span,
+                "consider implementing `TryFrom` instead",
+                move |diag| {
+                    diag.help(
+                        "`From` is intended for infallible conversions only. \
+                        Use `TryFrom` if there's a possibility for the conversion to fail",
+                    );
+                    diag.span_note(fpu.result, "potential failure(s)");
+                },
+            );
         }
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/from_over_into.rs b/src/tools/clippy/clippy_lints/src/from_over_into.rs
index be887b03ae4..85b40ba7419 100644
--- a/src/tools/clippy/clippy_lints/src/from_over_into.rs
+++ b/src/tools/clippy/clippy_lints/src/from_over_into.rs
@@ -9,7 +9,7 @@ use clippy_utils::source::SpanRangeExt;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{Visitor, walk_path};
 use rustc_hir::{
-    FnRetTy, GenericArg, GenericArgs, HirId, Impl, ImplItemKind, ImplItemRef, Item, ItemKind, PatKind, Path,
+    FnRetTy, GenericArg, GenericArgs, HirId, Impl, ImplItemKind, ImplItemId, Item, ItemKind, PatKind, Path,
     PathSegment, Ty, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
@@ -102,7 +102,7 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
                         middle_trait_ref.self_ty()
                     );
                     if let Some(suggestions) =
-                        convert_to_from(cx, into_trait_seg, target_ty.as_unambig_ty(), self_ty, impl_item_ref)
+                        convert_to_from(cx, into_trait_seg, target_ty.as_unambig_ty(), self_ty, *impl_item_ref)
                     {
                         diag.multipart_suggestion(message, suggestions, Applicability::MachineApplicable);
                     } else {
@@ -164,14 +164,14 @@ fn convert_to_from(
     into_trait_seg: &PathSegment<'_>,
     target_ty: &Ty<'_>,
     self_ty: &Ty<'_>,
-    impl_item_ref: &ImplItemRef,
+    impl_item_ref: ImplItemId,
 ) -> Option<Vec<(Span, String)>> {
     if !target_ty.find_self_aliases().is_empty() {
         // It's tricky to expand self-aliases correctly, we'll ignore it to not cause a
         // bad suggestion/fix.
         return None;
     }
-    let impl_item = cx.tcx.hir_impl_item(impl_item_ref.id);
+    let impl_item = cx.tcx.hir_impl_item(impl_item_ref);
     let ImplItemKind::Fn(ref sig, body_id) = impl_item.kind else {
         return None;
     };
diff --git a/src/tools/clippy/clippy_lints/src/implicit_hasher.rs b/src/tools/clippy/clippy_lints/src/implicit_hasher.rs
index cab7a9fb709..b3c90f364e8 100644
--- a/src/tools/clippy/clippy_lints/src/implicit_hasher.rs
+++ b/src/tools/clippy/clippy_lints/src/implicit_hasher.rs
@@ -130,7 +130,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
                     });
 
                     let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
-                    for item in impl_.items.iter().map(|item| cx.tcx.hir_impl_item(item.id)) {
+                    for item in impl_.items.iter().map(|&item| cx.tcx.hir_impl_item(item)) {
                         ctr_vis.visit_impl_item(item);
                     }
 
diff --git a/src/tools/clippy/clippy_lints/src/iter_without_into_iter.rs b/src/tools/clippy/clippy_lints/src/iter_without_into_iter.rs
index 900b20aa9cf..03038f0ab49 100644
--- a/src/tools/clippy/clippy_lints/src/iter_without_into_iter.rs
+++ b/src/tools/clippy/clippy_lints/src/iter_without_into_iter.rs
@@ -139,13 +139,12 @@ impl LateLintPass<'_> for IterWithoutIntoIter {
                 // We can't check inherent impls for slices, but we know that they have an `iter(_mut)` method
                 ty.peel_refs().is_slice() || get_adt_inherent_method(cx, ty, expected_method_name).is_some()
             })
-            && let Some(iter_assoc_span) = imp.items.iter().find_map(|item| {
-                if item.ident.name == sym::IntoIter {
-                    Some(cx.tcx.hir_impl_item(item.id).expect_type().span)
-                } else {
-                    None
-                }
-            })
+            && let Some(iter_assoc_span) = cx.tcx.associated_items(item.owner_id)
+                .filter_by_name_unhygienic_and_kind(sym::IntoIter, ty::AssocTag::Type)
+                .next()
+                .map(|assoc_item| {
+                    cx.tcx.hir_node_by_def_id(assoc_item.def_id.expect_local()).expect_impl_item().expect_type().span
+                })
             && is_ty_exported(cx, ty)
         {
             span_lint_and_then(
diff --git a/src/tools/clippy/clippy_lints/src/len_zero.rs b/src/tools/clippy/clippy_lints/src/len_zero.rs
index 896aa64fcdb..d32017a8b41 100644
--- a/src/tools/clippy/clippy_lints/src/len_zero.rs
+++ b/src/tools/clippy/clippy_lints/src/len_zero.rs
@@ -12,7 +12,7 @@ use rustc_hir::def_id::{DefId, DefIdSet};
 use rustc_hir::{
     BinOpKind, Expr, ExprKind, FnRetTy, GenericArg, GenericBound, HirId, ImplItem, ImplItemKind,
     ImplicitSelfKind, Item, ItemKind, Mutability, Node, OpaqueTyOrigin, PatExprKind, PatKind, PathSegment, PrimTy,
-    QPath, TraitItemRef, TyKind,
+    QPath, TraitItemId, TyKind,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, FnSig, Ty};
@@ -265,11 +265,11 @@ fn span_without_enclosing_paren(cx: &LateContext<'_>, span: Span) -> Span {
     }
 }
 
-fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, ident: Ident, trait_items: &[TraitItemRef]) {
-    fn is_named_self(cx: &LateContext<'_>, item: &TraitItemRef, name: Symbol) -> bool {
-        item.ident.name == name
+fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, ident: Ident, trait_items: &[TraitItemId]) {
+    fn is_named_self(cx: &LateContext<'_>, item: &TraitItemId, name: Symbol) -> bool {
+        cx.tcx.item_name(item.owner_id) == name
             && matches!(
-                cx.tcx.fn_arg_idents(item.id.owner_id),
+                cx.tcx.fn_arg_idents(item.owner_id),
                 [Some(Ident { name: kw::SelfLower, .. })],
             )
     }
diff --git a/src/tools/clippy/clippy_lints/src/lifetimes.rs b/src/tools/clippy/clippy_lints/src/lifetimes.rs
index caf17c10484..35c9d2fd4eb 100644
--- a/src/tools/clippy/clippy_lints/src/lifetimes.rs
+++ b/src/tools/clippy/clippy_lints/src/lifetimes.rs
@@ -716,7 +716,7 @@ fn report_extra_impl_lifetimes<'tcx>(cx: &LateContext<'tcx>, impl_: &'tcx Impl<'
         walk_trait_ref(&mut checker, trait_ref);
     }
     walk_unambig_ty(&mut checker, impl_.self_ty);
-    for item in impl_.items {
+    for &item in impl_.items {
         walk_impl_item_ref(&mut checker, item);
     }
 
diff --git a/src/tools/clippy/clippy_lints/src/missing_fields_in_debug.rs b/src/tools/clippy/clippy_lints/src/missing_fields_in_debug.rs
index d4d33029dbd..760ecf07589 100644
--- a/src/tools/clippy/clippy_lints/src/missing_fields_in_debug.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_fields_in_debug.rs
@@ -8,7 +8,7 @@ use rustc_ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{
-    Block, Expr, ExprKind, Impl, ImplItem, ImplItemKind, Item, ItemKind, LangItem, Node, QPath, TyKind, VariantData,
+    Block, Expr, ExprKind, Impl, Item, ItemKind, LangItem, Node, QPath, TyKind, VariantData,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{Ty, TypeckResults};
@@ -200,7 +200,7 @@ fn check_struct<'tcx>(
 impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         // is this an `impl Debug for X` block?
-        if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), self_ty, items, .. }) = item.kind
+        if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), self_ty, .. }) = item.kind
             && let Res::Def(DefKind::Trait, trait_def_id) = trait_ref.path.res
             && let TyKind::Path(QPath::Resolved(_, self_path)) = &self_ty.kind
             // make sure that the self type is either a struct, an enum or a union
@@ -212,9 +212,8 @@ impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
             && !cx.tcx.is_automatically_derived(item.owner_id.to_def_id())
             && !item.span.from_expansion()
             // find `Debug::fmt` function
-            && let Some(fmt_item) = items.iter().find(|i| i.ident.name == sym::fmt)
-            && let ImplItem { kind: ImplItemKind::Fn(_, body_id), .. } = cx.tcx.hir_impl_item(fmt_item.id)
-            && let body = cx.tcx.hir_body(*body_id)
+            && let Some(fmt_item) = cx.tcx.associated_items(item.owner_id).filter_by_name_unhygienic(sym::fmt).next()
+            && let body = cx.tcx.hir_body_owned_by(fmt_item.def_id.expect_local())
             && let ExprKind::Block(block, _) = body.value.kind
             // inspect `self`
             && let self_ty = cx.tcx.type_of(self_path_did).skip_binder().peel_refs()
@@ -222,7 +221,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug {
             && let Some(self_def_id) = self_adt.did().as_local()
             && let Node::Item(self_item) = cx.tcx.hir_node_by_def_id(self_def_id)
             // NB: can't call cx.typeck_results() as we are not in a body
-            && let typeck_results = cx.tcx.typeck_body(*body_id)
+            && let typeck_results = cx.tcx.typeck_body(body.id())
             && should_lint(cx, typeck_results, block)
             // we intentionally only lint structs, see lint description
             && let ItemKind::Struct(_, _, data) = &self_item.kind
diff --git a/src/tools/clippy/clippy_lints/src/missing_inline.rs b/src/tools/clippy/clippy_lints/src/missing_inline.rs
index 25c95d23436..329f7193437 100644
--- a/src/tools/clippy/clippy_lints/src/missing_inline.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_inline.rs
@@ -104,16 +104,16 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
             hir::ItemKind::Trait(ref _is_auto, ref _unsafe, _ident, _generics, _bounds, trait_items) => {
                 // note: we need to check if the trait is exported so we can't use
                 // `LateLintPass::check_trait_item` here.
-                for tit in trait_items {
-                    let tit_ = cx.tcx.hir_trait_item(tit.id);
+                for &tit in trait_items {
+                    let tit_ = cx.tcx.hir_trait_item(tit);
                     match tit_.kind {
                         hir::TraitItemKind::Const(..) | hir::TraitItemKind::Type(..) => {},
                         hir::TraitItemKind::Fn(..) => {
-                            if cx.tcx.defaultness(tit.id.owner_id).has_value() {
+                            if cx.tcx.defaultness(tit.owner_id).has_value() {
                                 // trait method with default body needs inline in case
                                 // an impl is not provided
                                 let desc = "a default trait method";
-                                let item = cx.tcx.hir_trait_item(tit.id);
+                                let item = cx.tcx.hir_trait_item(tit);
                                 let attrs = cx.tcx.hir_attrs(item.hir_id());
                                 check_missing_inline_attrs(cx, attrs, item.span, desc);
                             }
diff --git a/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs b/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs
index 8eaf65e6306..301b2cd4bf2 100644
--- a/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs
+++ b/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs
@@ -43,12 +43,12 @@ impl<'tcx> LateLintPass<'tcx> for PartialEqNeImpl {
             && trait_ref.path.res.def_id() == eq_trait
         {
             for impl_item in *impl_items {
-                if impl_item.ident.name == sym::ne {
+                if cx.tcx.item_name(impl_item.owner_id) == sym::ne {
                     span_lint_hir(
                         cx,
                         PARTIALEQ_NE_IMPL,
-                        impl_item.id.hir_id(),
-                        impl_item.span,
+                        impl_item.hir_id(),
+                        cx.tcx.def_span(impl_item.owner_id),
                         "re-implementing `PartialEq::ne` is unnecessary",
                     );
                 }
diff --git a/src/tools/clippy/clippy_lints/src/serde_api.rs b/src/tools/clippy/clippy_lints/src/serde_api.rs
index b36a5d6d502..2de22e4b6a3 100644
--- a/src/tools/clippy/clippy_lints/src/serde_api.rs
+++ b/src/tools/clippy/clippy_lints/src/serde_api.rs
@@ -36,9 +36,9 @@ impl<'tcx> LateLintPass<'tcx> for SerdeApi {
                 let mut seen_str = None;
                 let mut seen_string = None;
                 for item in *items {
-                    match item.ident.name {
-                        sym::visit_str => seen_str = Some(item.span),
-                        sym::visit_string => seen_string = Some(item.span),
+                    match cx.tcx.item_name(item.owner_id) {
+                        sym::visit_str => seen_str = Some(cx.tcx.def_span(item.owner_id)),
+                        sym::visit_string => seen_string = Some(cx.tcx.def_span(item.owner_id)),
                         _ => {},
                     }
                 }
diff --git a/src/tools/clippy/clippy_utils/src/paths.rs b/src/tools/clippy/clippy_utils/src/paths.rs
index 8bbcb220210..c681806517a 100644
--- a/src/tools/clippy/clippy_utils/src/paths.rs
+++ b/src/tools/clippy/clippy_utils/src/paths.rs
@@ -10,7 +10,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def::Namespace::{MacroNS, TypeNS, ValueNS};
 use rustc_hir::def::{DefKind, Namespace, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
-use rustc_hir::{ImplItemRef, ItemKind, Node, OwnerId, TraitItemRef, UseKind};
+use rustc_hir::{ItemKind, Node, UseKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::fast_reject::SimplifiedType;
 use rustc_middle::ty::{FloatTy, IntTy, Ty, TyCtxt, UintTy};
@@ -284,14 +284,6 @@ fn local_item_child_by_name(tcx: TyCtxt<'_>, local_id: LocalDefId, ns: PathNS, n
         _ => return None,
     };
 
-    let res = |ident: Ident, owner_id: OwnerId| {
-        if ident.name == name && ns.matches(tcx.def_kind(owner_id).ns()) {
-            Some(owner_id.to_def_id())
-        } else {
-            None
-        }
-    };
-
     match item_kind {
         ItemKind::Mod(_, r#mod) => r#mod.item_ids.iter().find_map(|&item_id| {
             let item = tcx.hir_item(item_id);
@@ -307,17 +299,19 @@ fn local_item_child_by_name(tcx: TyCtxt<'_>, local_id: LocalDefId, ns: PathNS, n
                 } else {
                     None
                 }
+            } else if let Some(ident) = item.kind.ident()
+                && ident.name == name
+                && ns.matches(tcx.def_kind(item.owner_id).ns())
+            {
+                Some(item.owner_id.to_def_id())
             } else {
-                res(item.kind.ident()?, item_id.owner_id)
+                None
             }
         }),
-        ItemKind::Impl(r#impl) => r#impl
-            .items
-            .iter()
-            .find_map(|&ImplItemRef { ident, id, .. }| res(ident, id.owner_id)),
-        ItemKind::Trait(.., trait_item_refs) => trait_item_refs
-            .iter()
-            .find_map(|&TraitItemRef { ident, id, .. }| res(ident, id.owner_id)),
+        ItemKind::Impl(..) | ItemKind::Trait(..)
+            => tcx.associated_items(local_id).filter_by_name_unhygienic(name)
+                .find(|assoc_item| ns.matches(Some(assoc_item.namespace())))
+                .map(|assoc_item| assoc_item.def_id),
         _ => None,
     }
 }
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default.stderr b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default.stderr
index a3c35a31c33..87e4b0c5c7d 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default.stderr
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default.stderr
@@ -136,13 +136,13 @@ error: incorrect ordering of trait items (defined order: [Const, Type, Fn])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:155:5
    |
 LL |     const A: bool;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:153:5
    |
 LL |     type SomeType;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: incorrect ordering of items (must be alphabetically ordered)
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:171:11
@@ -172,13 +172,13 @@ error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:189:5
    |
 LL |     const A: bool = false;
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:187:5
    |
 LL |     type SomeType = ();
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: aborting due to 15 previous errors
 
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default_exp.stderr b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default_exp.stderr
index a3c35a31c33..87e4b0c5c7d 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default_exp.stderr
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default_exp.stderr
@@ -136,13 +136,13 @@ error: incorrect ordering of trait items (defined order: [Const, Type, Fn])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:155:5
    |
 LL |     const A: bool;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:153:5
    |
 LL |     type SomeType;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: incorrect ordering of items (must be alphabetically ordered)
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:171:11
@@ -172,13 +172,13 @@ error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:189:5
    |
 LL |     const A: bool = false;
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:187:5
    |
 LL |     type SomeType = ();
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: aborting due to 15 previous errors
 
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.ord_within.stderr b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.ord_within.stderr
index 3fdd706fc62..40505e2a1c4 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.ord_within.stderr
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.ord_within.stderr
@@ -211,13 +211,13 @@ error: incorrect ordering of trait items (defined order: [Const, Type, Fn])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:155:5
    |
 LL |     const A: bool;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:153:5
    |
 LL |     type SomeType;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: incorrect ordering of items (must be alphabetically ordered)
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:171:11
@@ -247,13 +247,13 @@ error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:189:5
    |
 LL |     const A: bool = false;
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:187:5
    |
 LL |     type SomeType = ();
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: incorrect ordering of items (must be alphabetically ordered)
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:207:11
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.var_1.stderr b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.var_1.stderr
index 730f12c38a0..d8db2243d41 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.var_1.stderr
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.var_1.stderr
@@ -28,25 +28,25 @@ error: incorrect ordering of impl items (defined order: [Fn, Type, Const])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:119:5
    |
 LL |     type SomeType = ();
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
 note: should be placed before `A`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:117:5
    |
 LL |     const A: bool = false;
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: incorrect ordering of impl items (defined order: [Fn, Type, Const])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:122:5
    |
 LL |     fn a() {}
-   |     ^^^^^^^^^
+   |     ^^^^^^
    |
 note: should be placed before `SomeType`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:119:5
    |
 LL |     type SomeType = ();
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: incorrect ordering of items (must be alphabetically ordered)
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:149:8
@@ -76,13 +76,13 @@ error: incorrect ordering of trait items (defined order: [Fn, Type, Const])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:163:5
    |
 LL |     type SomeType;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
 note: should be placed before `A`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:161:5
    |
 LL |     const A: bool;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: incorrect ordering of trait items (defined order: [Fn, Type, Const])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:166:5
@@ -94,7 +94,7 @@ note: should be placed before `SomeType`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:163:5
    |
 LL |     type SomeType;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: aborting due to 8 previous errors
 
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.only_impl.stderr b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.only_impl.stderr
index 77596ba2394..7f6bddf8005 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.only_impl.stderr
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.only_impl.stderr
@@ -16,25 +16,25 @@ error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:46:5
    |
 LL |     type SomeType = i8;
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
 note: should be placed before `a`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:43:5
    |
 LL |     fn a() {}
-   |     ^^^^^^^^^
+   |     ^^^^^^
 
 error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:49:5
    |
 LL |     const A: bool = true;
-   |     ^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:46:5
    |
 LL |     type SomeType = i8;
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: aborting due to 3 previous errors
 
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.only_trait.stderr b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.only_trait.stderr
index 3d903330be8..a7cff238b78 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.only_trait.stderr
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.only_trait.stderr
@@ -28,13 +28,13 @@ error: incorrect ordering of trait items (defined order: [Const, Type, Fn])
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:45:5
    |
 LL |     const A: bool;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
   --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:43:5
    |
 LL |     type SomeType;
-   |     ^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: aborting due to 3 previous errors
 
diff --git a/src/tools/clippy/tests/ui/partialeq_ne_impl.stderr b/src/tools/clippy/tests/ui/partialeq_ne_impl.stderr
index dc01a375060..0f700654f7c 100644
--- a/src/tools/clippy/tests/ui/partialeq_ne_impl.stderr
+++ b/src/tools/clippy/tests/ui/partialeq_ne_impl.stderr
@@ -1,12 +1,8 @@
 error: re-implementing `PartialEq::ne` is unnecessary
   --> tests/ui/partialeq_ne_impl.rs:9:5
    |
-LL | /     fn ne(&self, _: &Foo) -> bool {
-LL | |
-LL | |
-LL | |         false
-LL | |     }
-   | |_____^
+LL |     fn ne(&self, _: &Foo) -> bool {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::partialeq-ne-impl` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::partialeq_ne_impl)]`
diff --git a/src/tools/clippy/tests/ui/serde.stderr b/src/tools/clippy/tests/ui/serde.stderr
index eb6b7c6b0c3..652248e3578 100644
--- a/src/tools/clippy/tests/ui/serde.stderr
+++ b/src/tools/clippy/tests/ui/serde.stderr
@@ -5,10 +5,7 @@ LL | /     fn visit_string<E>(self, _v: String) -> Result<Self::Value, E>
 LL | |
 LL | |     where
 LL | |         E: serde::de::Error,
-LL | |     {
-LL | |         unimplemented!()
-LL | |     }
-   | |_____^
+   | |____________________________^
    |
    = note: `-D clippy::serde-api-misuse` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::serde_api_misuse)]`
diff --git a/tests/ui/associated-consts/issue-58022.stderr b/tests/ui/associated-consts/issue-58022.stderr
index 37cb162b2b2..5d57e01d6f5 100644
--- a/tests/ui/associated-consts/issue-58022.stderr
+++ b/tests/ui/associated-consts/issue-58022.stderr
@@ -16,7 +16,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
   --> $DIR/issue-58022.rs:4:25
    |
 LL |     const SIZE: usize;
-   |     ------------------ `Foo::SIZE` defined here
+   |     ----------------- `Foo::SIZE` defined here
 LL |
 LL |     fn new(slice: &[u8; Foo::SIZE]) -> Self;
    |                         ^^^^^^^^^ cannot refer to the associated constant of trait
diff --git a/tests/ui/associated-consts/issue-63496.stderr b/tests/ui/associated-consts/issue-63496.stderr
index f2a4e01adea..bdd2769afc8 100644
--- a/tests/ui/associated-consts/issue-63496.stderr
+++ b/tests/ui/associated-consts/issue-63496.stderr
@@ -2,7 +2,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
   --> $DIR/issue-63496.rs:4:21
    |
 LL |     const C: usize;
-   |     --------------- `A::C` defined here
+   |     -------------- `A::C` defined here
 LL |
 LL |     fn f() -> ([u8; A::C], [u8; A::C]);
    |                     ^^^^ cannot refer to the associated constant of trait
@@ -11,7 +11,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
   --> $DIR/issue-63496.rs:4:33
    |
 LL |     const C: usize;
-   |     --------------- `A::C` defined here
+   |     -------------- `A::C` defined here
 LL |
 LL |     fn f() -> ([u8; A::C], [u8; A::C]);
    |                                 ^^^^ cannot refer to the associated constant of trait
diff --git a/tests/ui/associated-item/issue-48027.stderr b/tests/ui/associated-item/issue-48027.stderr
index 513961e2bd0..e5c1ced9341 100644
--- a/tests/ui/associated-item/issue-48027.stderr
+++ b/tests/ui/associated-item/issue-48027.stderr
@@ -18,7 +18,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
   --> $DIR/issue-48027.rs:3:32
    |
 LL |     const X: usize;
-   |     --------------- `Bar::X` defined here
+   |     -------------- `Bar::X` defined here
 LL |     fn return_n(&self) -> [u8; Bar::X];
    |                                ^^^^^^ cannot refer to the associated constant of trait
 
diff --git a/tests/ui/consts/issue-54954.stderr b/tests/ui/consts/issue-54954.stderr
index b8c983eb7b8..2ef3abcf760 100644
--- a/tests/ui/consts/issue-54954.stderr
+++ b/tests/ui/consts/issue-54954.stderr
@@ -10,14 +10,11 @@ LL |     const fn const_val<T: Sized>() -> usize {
 error[E0790]: cannot call associated function on trait without specifying the corresponding `impl` type
   --> $DIR/issue-54954.rs:1:24
    |
-LL |   const ARR_LEN: usize = Tt::const_val::<[i8; 123]>();
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot call associated function of trait
+LL | const ARR_LEN: usize = Tt::const_val::<[i8; 123]>();
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot call associated function of trait
 ...
-LL | /     const fn const_val<T: Sized>() -> usize {
-LL | |
-LL | |         core::mem::size_of::<T>()
-LL | |     }
-   | |_____- `Tt::const_val` defined here
+LL |     const fn const_val<T: Sized>() -> usize {
+   |     --------------------------------------- `Tt::const_val` defined here
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/error-codes/E0790.stderr b/tests/ui/error-codes/E0790.stderr
index 106554b2425..93c43020768 100644
--- a/tests/ui/error-codes/E0790.stderr
+++ b/tests/ui/error-codes/E0790.stderr
@@ -16,7 +16,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
   --> $DIR/E0790.rs:21:17
    |
 LL |         const MY_ASSOC_CONST: ();
-   |         ------------------------- `MyTrait::MY_ASSOC_CONST` defined here
+   |         ------------------------ `MyTrait::MY_ASSOC_CONST` defined here
 ...
 LL |         let _ = MyTrait::MY_ASSOC_CONST;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^ cannot refer to the associated constant of trait
@@ -44,7 +44,7 @@ error[E0790]: cannot refer to the associated constant on trait without specifyin
   --> $DIR/E0790.rs:30:13
    |
 LL |         const MY_ASSOC_CONST: ();
-   |         ------------------------- `MyTrait::MY_ASSOC_CONST` defined here
+   |         ------------------------ `MyTrait::MY_ASSOC_CONST` defined here
 ...
 LL |     let _ = inner::MyTrait::MY_ASSOC_CONST;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot refer to the associated constant of trait
diff --git a/tests/ui/feature-gates/feature-gate-async-drop.stderr b/tests/ui/feature-gates/feature-gate-async-drop.stderr
index e795c3a3422..80f6228a16f 100644
--- a/tests/ui/feature-gates/feature-gate-async-drop.stderr
+++ b/tests/ui/feature-gates/feature-gate-async-drop.stderr
@@ -12,7 +12,7 @@ error[E0658]: use of unstable library feature `async_drop`
   --> $DIR/feature-gate-async-drop.rs:13:5
    |
 LL |     async fn drop(self: Pin<&mut Self>) {}
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #126482 <https://github.com/rust-lang/rust/issues/126482> for more information
    = help: add `#![feature(async_drop)]` to the crate attributes to enable
diff --git a/tests/ui/lint/lint-stability.stderr b/tests/ui/lint/lint-stability.stderr
index a22fce70a4a..fd57908a77b 100644
--- a/tests/ui/lint/lint-stability.stderr
+++ b/tests/ui/lint/lint-stability.stderr
@@ -290,7 +290,7 @@ error[E0658]: use of unstable library feature `unstable_test_feature`
   --> $DIR/lint-stability.rs:179:9
    |
 LL |         fn trait_unstable(&self) {}
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: add `#![feature(unstable_test_feature)]` 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/stats/input-stats.stderr b/tests/ui/stats/input-stats.stderr
index e03ac0de54f..72a9820bb64 100644
--- a/tests/ui/stats/input-stats.stderr
+++ b/tests/ui/stats/input-stats.stderr
@@ -112,12 +112,12 @@ hir-stats Param                     64 (NN.N%)             2            32
 hir-stats GenericArg                64 (NN.N%)             4            16
 hir-stats - Type                      16 (NN.N%)             1
 hir-stats - Lifetime                  48 (NN.N%)             3
-hir-stats TraitItemRef              48 (NN.N%)             2            24
-hir-stats ImplItemRef               48 (NN.N%)             2            24
 hir-stats ExprField                 40 (NN.N%)             1            40
 hir-stats Mod                       32 (NN.N%)             1            32
 hir-stats Lifetime                  28 (NN.N%)             1            28
+hir-stats TraitItemId                8 (NN.N%)             2             4
+hir-stats ImplItemId                 8 (NN.N%)             2             4
 hir-stats ForeignItemId              4 (NN.N%)             1             4
 hir-stats ----------------------------------------------------------------
-hir-stats Total                  8_664                   173
+hir-stats Total                  8_584                   173
 hir-stats ================================================================
diff --git a/tests/ui/suggestions/issue-104327.stderr b/tests/ui/suggestions/issue-104327.stderr
index 1bad82d471e..4515fe223c7 100644
--- a/tests/ui/suggestions/issue-104327.stderr
+++ b/tests/ui/suggestions/issue-104327.stderr
@@ -2,7 +2,7 @@ error[E0790]: cannot call associated function on trait without specifying the co
   --> $DIR/issue-104327.rs:10:5
    |
 LL |     fn f() {}
-   |     --------- `Foo::f` defined here
+   |     ------ `Foo::f` defined here
 ...
 LL |     Foo::f();
    |     ^^^^^^^^ cannot call associated function of trait
diff --git a/tests/ui/traits/default-method/rustc_must_implement_one_of_misuse.stderr b/tests/ui/traits/default-method/rustc_must_implement_one_of_misuse.stderr
index 38e692521ca..cf197d035b3 100644
--- a/tests/ui/traits/default-method/rustc_must_implement_one_of_misuse.stderr
+++ b/tests/ui/traits/default-method/rustc_must_implement_one_of_misuse.stderr
@@ -50,7 +50,7 @@ error: not a function
   --> $DIR/rustc_must_implement_one_of_misuse.rs:26:5
    |
 LL |     const A: u8 = 1;
-   |     ^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^
    |
 note: required by this annotation
   --> $DIR/rustc_must_implement_one_of_misuse.rs:24:1
@@ -63,7 +63,7 @@ error: not a function
   --> $DIR/rustc_must_implement_one_of_misuse.rs:28:5
    |
 LL |     type B;
-   |     ^^^^^^^
+   |     ^^^^^^
    |
 note: required by this annotation
   --> $DIR/rustc_must_implement_one_of_misuse.rs:24:1
diff --git a/tests/ui/traits/trait-upcasting/deref-upcast-shadowing-lint.stderr b/tests/ui/traits/trait-upcasting/deref-upcast-shadowing-lint.stderr
index 0d7f957a50e..6744899e951 100644
--- a/tests/ui/traits/trait-upcasting/deref-upcast-shadowing-lint.stderr
+++ b/tests/ui/traits/trait-upcasting/deref-upcast-shadowing-lint.stderr
@@ -5,7 +5,7 @@ LL | impl<'a> Deref for dyn Foo + 'a {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dyn Foo` implements `Deref<Target = dyn Bar<u32>>` which conflicts with supertrait `Bar<i32>`
 LL |
 LL |     type Target = dyn Bar<u32> + 'a;
-   |     -------------------------------- target type is a supertrait of `dyn Foo`
+   |     ----------- target type is a supertrait of `dyn Foo`
    |
 note: the lint level is defined here
   --> $DIR/deref-upcast-shadowing-lint.rs:2:9
diff --git a/tests/ui/traits/trait-upcasting/migrate-lint-deny-regions.stderr b/tests/ui/traits/trait-upcasting/migrate-lint-deny-regions.stderr
index 806c57e44a2..0d43563e1ab 100644
--- a/tests/ui/traits/trait-upcasting/migrate-lint-deny-regions.stderr
+++ b/tests/ui/traits/trait-upcasting/migrate-lint-deny-regions.stderr
@@ -5,7 +5,7 @@ LL | impl<'a> Deref for dyn Foo<'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dyn Foo<'_>` implements `Deref<Target = dyn Bar<'_>>` which conflicts with supertrait `Bar<'_>`
 LL |
 LL |     type Target = dyn Bar<'a>;
-   |     -------------------------- target type is a supertrait of `dyn Foo<'_>`
+   |     ----------- target type is a supertrait of `dyn Foo<'_>`
    |
 note: the lint level is defined here
   --> $DIR/migrate-lint-deny-regions.rs:2:9
diff --git a/tests/ui/traits/trait-upcasting/migrate-lint-different-substs.stderr b/tests/ui/traits/trait-upcasting/migrate-lint-different-substs.stderr
index 86cff5233ff..a483e98efea 100644
--- a/tests/ui/traits/trait-upcasting/migrate-lint-different-substs.stderr
+++ b/tests/ui/traits/trait-upcasting/migrate-lint-different-substs.stderr
@@ -5,7 +5,7 @@ LL | impl<'a> Deref for dyn Foo + 'a {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `dyn Foo` implements `Deref<Target = dyn Bar<u32>>` which conflicts with supertrait `Bar<i32>`
 LL |
 LL |     type Target = dyn Bar<u32> + 'a;
-   |     -------------------------------- target type is a supertrait of `dyn Foo`
+   |     ----------- target type is a supertrait of `dyn Foo`
    |
 note: the lint level is defined here
   --> $DIR/migrate-lint-different-substs.rs:2:9
-- 
cgit 1.4.1-3-g733a5


From 27127e342d28ebeb0734916ada6979b6938fb532 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 3 Jul 2025 13:12:04 +0000
Subject: Bless incremental tests.

---
 tests/incremental/hashes/inherent_impls.rs | 2 +-
 tests/incremental/hashes/trait_impls.rs    | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/incremental/hashes/inherent_impls.rs b/tests/incremental/hashes/inherent_impls.rs
index caea394977a..044c3d2b86c 100644
--- a/tests/incremental/hashes/inherent_impls.rs
+++ b/tests/incremental/hashes/inherent_impls.rs
@@ -150,7 +150,7 @@ impl Foo {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes")]
+#[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
 #[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes")]
 #[rustc_clean(cfg="cfail6")]
diff --git a/tests/incremental/hashes/trait_impls.rs b/tests/incremental/hashes/trait_impls.rs
index 8faf6806b90..a89b5b3e782 100644
--- a/tests/incremental/hashes/trait_impls.rs
+++ b/tests/incremental/hashes/trait_impls.rs
@@ -141,7 +141,7 @@ pub trait ChangeMethodSelfnessTrait {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail2")]
+#[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
 #[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
@@ -179,7 +179,7 @@ pub trait RemoveMethodSelfnessTrait {
 }
 
 #[cfg(not(any(cfail1,cfail4)))]
-#[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail2")]
+#[rustc_clean(cfg="cfail2")]
 #[rustc_clean(cfg="cfail3")]
 #[rustc_clean(except="opt_hir_owner_nodes", cfg="cfail5")]
 #[rustc_clean(cfg="cfail6")]
-- 
cgit 1.4.1-3-g733a5


From 25794b14c14eda96612dfc26253699589febe05e Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Sat, 12 Jul 2025 19:36:22 +0200
Subject: Compiletest: Simplify {Html,Json}DocCk directive handling

---
 .../src/rustdoc-internals/rustdoc-test-suite.md    |   3 +
 src/etc/htmldocck.py                               |  55 +---
 src/tools/compiletest/src/directive-list.rs        | 260 ------------------
 src/tools/compiletest/src/directives.rs            | 300 +++++++++++++++++++--
 src/tools/compiletest/src/runtest/rustdoc.rs       |   2 +-
 src/tools/compiletest/src/runtest/rustdoc_json.rs  |   2 +-
 src/tools/jsondocck/src/directive.rs               |  15 +-
 src/tools/jsondocck/src/main.rs                    |  16 +-
 8 files changed, 294 insertions(+), 359 deletions(-)
 delete mode 100644 src/tools/compiletest/src/directive-list.rs

diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md
index b05318ce9e6..4f44cf1701c 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md
@@ -55,6 +55,9 @@ Similar to shell commands,
 directives can extend across multiple lines if their last char is `\`.
 In this case, the start of the next line should be `//`, with no `@`.
 
+Similar to compiletest directives, besides a space you can also use a colon `:` to separate
+the directive name and the arguments, however a space is preferred for HtmlDocCk directives.
+
 Use the special string `{{channel}}` in XPaths, `PATTERN` arguments and [snapshot files](#snapshot)
 if you'd like to refer to the URL `https://doc.rust-lang.org/CHANNEL` where `CHANNEL` refers to the
 current release channel (e.g, `stable` or `nightly`).
diff --git a/src/etc/htmldocck.py b/src/etc/htmldocck.py
index ddbd256a0d8..72975cc6206 100755
--- a/src/etc/htmldocck.py
+++ b/src/etc/htmldocck.py
@@ -147,48 +147,17 @@ def concat_multi_lines(f):
         print_err(lineno, line, "Trailing backslash at the end of the file")
 
 
-def get_known_directive_names():
-    def filter_line(line):
-        line = line.strip()
-        return line.startswith('"') and (line.endswith('",') or line.endswith('"'))
-
-    # Equivalent to `src/tools/compiletest/src/header.rs` constant of the same name.
-    with open(
-        os.path.join(
-            # We go back to `src`.
-            os.path.dirname(os.path.dirname(__file__)),
-            "tools/compiletest/src/directive-list.rs",
-        ),
-        "r",
-        encoding="utf8",
-    ) as fd:
-        content = fd.read()
-        return [
-            line.strip().replace('",', "").replace('"', "")
-            for line in content.split("\n")
-            if filter_line(line)
-        ]
-
-
-# To prevent duplicating the list of commmands between `compiletest` and `htmldocck`, we put
-# it into a common file which is included in rust code and parsed here.
-# FIXME: This setup is temporary until we figure out how to improve this situation.
-#        See <https://github.com/rust-lang/rust/issues/125813#issuecomment-2141953780>.
-KNOWN_DIRECTIVE_NAMES = get_known_directive_names()
-
 LINE_PATTERN = re.compile(
     r"""
     //@\s+
-    (?P<negated>!?)(?P<cmd>[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*)
-    (?P<args>.*)$
+    (?P<negated>!?)(?P<cmd>.+?)
+    (?:[\s:](?P<args>.*))?$
 """,
     re.X | re.UNICODE,
 )
 
 DEPRECATED_LINE_PATTERN = re.compile(
-    r"""
-    //\s+@
-""",
+    r"//\s+@",
     re.X | re.UNICODE,
 )
 
@@ -209,12 +178,7 @@ def get_commands(template):
 
             cmd = m.group("cmd")
             negated = m.group("negated") == "!"
-            if not negated and cmd in KNOWN_DIRECTIVE_NAMES:
-                continue
-            args = m.group("args")
-            if args and not args[:1].isspace():
-                print_err(lineno, line, "Invalid template syntax")
-                continue
+            args = m.group("args") or ""
             try:
                 args = shlex.split(args)
             except UnicodeEncodeError:
@@ -636,14 +600,11 @@ def check_command(c, cache):
             else:
                 raise InvalidCheck("Invalid number of {} arguments".format(c.cmd))
 
-        elif c.cmd == "valid-html":
-            raise InvalidCheck("Unimplemented valid-html")
-
-        elif c.cmd == "valid-links":
-            raise InvalidCheck("Unimplemented valid-links")
-
         else:
-            raise InvalidCheck("Unrecognized {}".format(c.cmd))
+            # Ignore unknown directives as they might be compiletest directives
+            # since they share the same `//@` prefix by convention. In any case,
+            # compiletest rejects unknown directives for us.
+            return
 
         if ret == c.negated:
             raise FailedCheck(cerr)
diff --git a/src/tools/compiletest/src/directive-list.rs b/src/tools/compiletest/src/directive-list.rs
deleted file mode 100644
index adf2a7bffef..00000000000
--- a/src/tools/compiletest/src/directive-list.rs
+++ /dev/null
@@ -1,260 +0,0 @@
-/// This was originally generated by collecting directives from ui tests and then extracting their
-/// directive names. This is **not** an exhaustive list of all possible directives. Instead, this is
-/// a best-effort approximation for diagnostics. Add new directives to this list when needed.
-const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
-    // tidy-alphabetical-start
-    "add-core-stubs",
-    "assembly-output",
-    "aux-bin",
-    "aux-build",
-    "aux-codegen-backend",
-    "aux-crate",
-    "build-aux-docs",
-    "build-fail",
-    "build-pass",
-    "check-fail",
-    "check-pass",
-    "check-run-results",
-    "check-stdout",
-    "check-test-line-numbers-match",
-    "compile-flags",
-    "doc-flags",
-    "dont-check-compiler-stderr",
-    "dont-check-compiler-stdout",
-    "dont-check-failure-status",
-    "dont-require-annotations",
-    "edition",
-    "error-pattern",
-    "exact-llvm-major-version",
-    "exec-env",
-    "failure-status",
-    "filecheck-flags",
-    "forbid-output",
-    "force-host",
-    "ignore-16bit",
-    "ignore-32bit",
-    "ignore-64bit",
-    "ignore-aarch64",
-    "ignore-aarch64-pc-windows-msvc",
-    "ignore-aarch64-unknown-linux-gnu",
-    "ignore-aix",
-    "ignore-android",
-    "ignore-apple",
-    "ignore-arm",
-    "ignore-arm-unknown-linux-gnueabi",
-    "ignore-arm-unknown-linux-gnueabihf",
-    "ignore-arm-unknown-linux-musleabi",
-    "ignore-arm-unknown-linux-musleabihf",
-    "ignore-auxiliary",
-    "ignore-avr",
-    "ignore-beta",
-    "ignore-cdb",
-    "ignore-compare-mode-next-solver",
-    "ignore-compare-mode-polonius",
-    "ignore-coverage-map",
-    "ignore-coverage-run",
-    "ignore-cross-compile",
-    "ignore-eabi",
-    "ignore-elf",
-    "ignore-emscripten",
-    "ignore-endian-big",
-    "ignore-enzyme",
-    "ignore-freebsd",
-    "ignore-fuchsia",
-    "ignore-gdb",
-    "ignore-gdb-version",
-    "ignore-gnu",
-    "ignore-haiku",
-    "ignore-horizon",
-    "ignore-i686-pc-windows-gnu",
-    "ignore-i686-pc-windows-msvc",
-    "ignore-illumos",
-    "ignore-ios",
-    "ignore-linux",
-    "ignore-lldb",
-    "ignore-llvm-version",
-    "ignore-loongarch32",
-    "ignore-loongarch64",
-    "ignore-macabi",
-    "ignore-macos",
-    "ignore-msp430",
-    "ignore-msvc",
-    "ignore-musl",
-    "ignore-netbsd",
-    "ignore-nightly",
-    "ignore-none",
-    "ignore-nto",
-    "ignore-nvptx64",
-    "ignore-nvptx64-nvidia-cuda",
-    "ignore-openbsd",
-    "ignore-pass",
-    "ignore-powerpc",
-    "ignore-remote",
-    "ignore-riscv64",
-    "ignore-rustc-debug-assertions",
-    "ignore-rustc_abi-x86-sse2",
-    "ignore-s390x",
-    "ignore-sgx",
-    "ignore-sparc64",
-    "ignore-spirv",
-    "ignore-stable",
-    "ignore-stage1",
-    "ignore-stage2",
-    "ignore-std-debug-assertions",
-    "ignore-test",
-    "ignore-thumb",
-    "ignore-thumbv8m.base-none-eabi",
-    "ignore-thumbv8m.main-none-eabi",
-    "ignore-tvos",
-    "ignore-unix",
-    "ignore-unknown",
-    "ignore-uwp",
-    "ignore-visionos",
-    "ignore-vxworks",
-    "ignore-wasi",
-    "ignore-wasm",
-    "ignore-wasm32",
-    "ignore-wasm32-bare",
-    "ignore-wasm64",
-    "ignore-watchos",
-    "ignore-windows",
-    "ignore-windows-gnu",
-    "ignore-windows-msvc",
-    "ignore-x32",
-    "ignore-x86",
-    "ignore-x86_64",
-    "ignore-x86_64-apple-darwin",
-    "ignore-x86_64-pc-windows-gnu",
-    "ignore-x86_64-unknown-linux-gnu",
-    "incremental",
-    "known-bug",
-    "llvm-cov-flags",
-    "max-llvm-major-version",
-    "min-cdb-version",
-    "min-gdb-version",
-    "min-lldb-version",
-    "min-llvm-version",
-    "min-system-llvm-version",
-    "needs-asm-support",
-    "needs-crate-type",
-    "needs-deterministic-layouts",
-    "needs-dlltool",
-    "needs-dynamic-linking",
-    "needs-enzyme",
-    "needs-force-clang-based-tests",
-    "needs-git-hash",
-    "needs-llvm-components",
-    "needs-llvm-zstd",
-    "needs-profiler-runtime",
-    "needs-relocation-model-pic",
-    "needs-run-enabled",
-    "needs-rust-lld",
-    "needs-rustc-debug-assertions",
-    "needs-sanitizer-address",
-    "needs-sanitizer-cfi",
-    "needs-sanitizer-dataflow",
-    "needs-sanitizer-hwaddress",
-    "needs-sanitizer-kcfi",
-    "needs-sanitizer-leak",
-    "needs-sanitizer-memory",
-    "needs-sanitizer-memtag",
-    "needs-sanitizer-safestack",
-    "needs-sanitizer-shadow-call-stack",
-    "needs-sanitizer-support",
-    "needs-sanitizer-thread",
-    "needs-std-debug-assertions",
-    "needs-subprocess",
-    "needs-symlink",
-    "needs-target-has-atomic",
-    "needs-target-std",
-    "needs-threads",
-    "needs-unwind",
-    "needs-wasmtime",
-    "needs-xray",
-    "no-auto-check-cfg",
-    "no-prefer-dynamic",
-    "normalize-stderr",
-    "normalize-stderr-32bit",
-    "normalize-stderr-64bit",
-    "normalize-stdout",
-    "only-16bit",
-    "only-32bit",
-    "only-64bit",
-    "only-aarch64",
-    "only-aarch64-apple-darwin",
-    "only-aarch64-unknown-linux-gnu",
-    "only-apple",
-    "only-arm",
-    "only-avr",
-    "only-beta",
-    "only-bpf",
-    "only-cdb",
-    "only-dist",
-    "only-elf",
-    "only-emscripten",
-    "only-gnu",
-    "only-i686-pc-windows-gnu",
-    "only-i686-pc-windows-msvc",
-    "only-i686-unknown-linux-gnu",
-    "only-ios",
-    "only-linux",
-    "only-loongarch32",
-    "only-loongarch64",
-    "only-loongarch64-unknown-linux-gnu",
-    "only-macos",
-    "only-mips",
-    "only-mips64",
-    "only-msp430",
-    "only-msvc",
-    "only-nightly",
-    "only-nvptx64",
-    "only-powerpc",
-    "only-riscv64",
-    "only-rustc_abi-x86-sse2",
-    "only-s390x",
-    "only-sparc",
-    "only-sparc64",
-    "only-stable",
-    "only-thumb",
-    "only-tvos",
-    "only-unix",
-    "only-visionos",
-    "only-wasm32",
-    "only-wasm32-bare",
-    "only-wasm32-wasip1",
-    "only-watchos",
-    "only-windows",
-    "only-windows-gnu",
-    "only-windows-msvc",
-    "only-x86",
-    "only-x86_64",
-    "only-x86_64-apple-darwin",
-    "only-x86_64-fortanix-unknown-sgx",
-    "only-x86_64-pc-windows-gnu",
-    "only-x86_64-pc-windows-msvc",
-    "only-x86_64-unknown-linux-gnu",
-    "pp-exact",
-    "pretty-compare-only",
-    "pretty-mode",
-    "proc-macro",
-    "reference",
-    "regex-error-pattern",
-    "remap-src-base",
-    "revisions",
-    "run-fail",
-    "run-flags",
-    "run-pass",
-    "run-rustfix",
-    "rustc-env",
-    "rustfix-only-machine-applicable",
-    "should-fail",
-    "should-ice",
-    "stderr-per-bitwidth",
-    "test-mir-pass",
-    "unique-doc-out-dir",
-    "unset-exec-env",
-    "unset-rustc-env",
-    // Used by the tidy check `unknown_revision`.
-    "unused-revision-names",
-    // tidy-alphabetical-end
-];
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 7fadb4dae2a..215793fe947 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -765,11 +765,266 @@ fn line_directive<'line>(
     Some(DirectiveLine { line_number, revision, raw_directive })
 }
 
-// To prevent duplicating the list of directives between `compiletest`,`htmldocck` and `jsondocck`,
-// we put it into a common file which is included in rust code and parsed here.
-// FIXME: This setup is temporary until we figure out how to improve this situation.
-//        See <https://github.com/rust-lang/rust/issues/125813#issuecomment-2141953780>.
-include!("directive-list.rs");
+/// This was originally generated by collecting directives from ui tests and then extracting their
+/// directive names. This is **not** an exhaustive list of all possible directives. Instead, this is
+/// a best-effort approximation for diagnostics. Add new directives to this list when needed.
+const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
+    // tidy-alphabetical-start
+    "add-core-stubs",
+    "assembly-output",
+    "aux-bin",
+    "aux-build",
+    "aux-codegen-backend",
+    "aux-crate",
+    "build-aux-docs",
+    "build-fail",
+    "build-pass",
+    "check-fail",
+    "check-pass",
+    "check-run-results",
+    "check-stdout",
+    "check-test-line-numbers-match",
+    "compile-flags",
+    "doc-flags",
+    "dont-check-compiler-stderr",
+    "dont-check-compiler-stdout",
+    "dont-check-failure-status",
+    "dont-require-annotations",
+    "edition",
+    "error-pattern",
+    "exact-llvm-major-version",
+    "exec-env",
+    "failure-status",
+    "filecheck-flags",
+    "forbid-output",
+    "force-host",
+    "ignore-16bit",
+    "ignore-32bit",
+    "ignore-64bit",
+    "ignore-aarch64",
+    "ignore-aarch64-pc-windows-msvc",
+    "ignore-aarch64-unknown-linux-gnu",
+    "ignore-aix",
+    "ignore-android",
+    "ignore-apple",
+    "ignore-arm",
+    "ignore-arm-unknown-linux-gnueabi",
+    "ignore-arm-unknown-linux-gnueabihf",
+    "ignore-arm-unknown-linux-musleabi",
+    "ignore-arm-unknown-linux-musleabihf",
+    "ignore-auxiliary",
+    "ignore-avr",
+    "ignore-beta",
+    "ignore-cdb",
+    "ignore-compare-mode-next-solver",
+    "ignore-compare-mode-polonius",
+    "ignore-coverage-map",
+    "ignore-coverage-run",
+    "ignore-cross-compile",
+    "ignore-eabi",
+    "ignore-elf",
+    "ignore-emscripten",
+    "ignore-endian-big",
+    "ignore-enzyme",
+    "ignore-freebsd",
+    "ignore-fuchsia",
+    "ignore-gdb",
+    "ignore-gdb-version",
+    "ignore-gnu",
+    "ignore-haiku",
+    "ignore-horizon",
+    "ignore-i686-pc-windows-gnu",
+    "ignore-i686-pc-windows-msvc",
+    "ignore-illumos",
+    "ignore-ios",
+    "ignore-linux",
+    "ignore-lldb",
+    "ignore-llvm-version",
+    "ignore-loongarch32",
+    "ignore-loongarch64",
+    "ignore-macabi",
+    "ignore-macos",
+    "ignore-msp430",
+    "ignore-msvc",
+    "ignore-musl",
+    "ignore-netbsd",
+    "ignore-nightly",
+    "ignore-none",
+    "ignore-nto",
+    "ignore-nvptx64",
+    "ignore-nvptx64-nvidia-cuda",
+    "ignore-openbsd",
+    "ignore-pass",
+    "ignore-powerpc",
+    "ignore-remote",
+    "ignore-riscv64",
+    "ignore-rustc-debug-assertions",
+    "ignore-rustc_abi-x86-sse2",
+    "ignore-s390x",
+    "ignore-sgx",
+    "ignore-sparc64",
+    "ignore-spirv",
+    "ignore-stable",
+    "ignore-stage1",
+    "ignore-stage2",
+    "ignore-std-debug-assertions",
+    "ignore-test",
+    "ignore-thumb",
+    "ignore-thumbv8m.base-none-eabi",
+    "ignore-thumbv8m.main-none-eabi",
+    "ignore-tvos",
+    "ignore-unix",
+    "ignore-unknown",
+    "ignore-uwp",
+    "ignore-visionos",
+    "ignore-vxworks",
+    "ignore-wasi",
+    "ignore-wasm",
+    "ignore-wasm32",
+    "ignore-wasm32-bare",
+    "ignore-wasm64",
+    "ignore-watchos",
+    "ignore-windows",
+    "ignore-windows-gnu",
+    "ignore-windows-msvc",
+    "ignore-x32",
+    "ignore-x86",
+    "ignore-x86_64",
+    "ignore-x86_64-apple-darwin",
+    "ignore-x86_64-pc-windows-gnu",
+    "ignore-x86_64-unknown-linux-gnu",
+    "incremental",
+    "known-bug",
+    "llvm-cov-flags",
+    "max-llvm-major-version",
+    "min-cdb-version",
+    "min-gdb-version",
+    "min-lldb-version",
+    "min-llvm-version",
+    "min-system-llvm-version",
+    "needs-asm-support",
+    "needs-crate-type",
+    "needs-deterministic-layouts",
+    "needs-dlltool",
+    "needs-dynamic-linking",
+    "needs-enzyme",
+    "needs-force-clang-based-tests",
+    "needs-git-hash",
+    "needs-llvm-components",
+    "needs-llvm-zstd",
+    "needs-profiler-runtime",
+    "needs-relocation-model-pic",
+    "needs-run-enabled",
+    "needs-rust-lld",
+    "needs-rustc-debug-assertions",
+    "needs-sanitizer-address",
+    "needs-sanitizer-cfi",
+    "needs-sanitizer-dataflow",
+    "needs-sanitizer-hwaddress",
+    "needs-sanitizer-kcfi",
+    "needs-sanitizer-leak",
+    "needs-sanitizer-memory",
+    "needs-sanitizer-memtag",
+    "needs-sanitizer-safestack",
+    "needs-sanitizer-shadow-call-stack",
+    "needs-sanitizer-support",
+    "needs-sanitizer-thread",
+    "needs-std-debug-assertions",
+    "needs-subprocess",
+    "needs-symlink",
+    "needs-target-has-atomic",
+    "needs-target-std",
+    "needs-threads",
+    "needs-unwind",
+    "needs-wasmtime",
+    "needs-xray",
+    "no-auto-check-cfg",
+    "no-prefer-dynamic",
+    "normalize-stderr",
+    "normalize-stderr-32bit",
+    "normalize-stderr-64bit",
+    "normalize-stdout",
+    "only-16bit",
+    "only-32bit",
+    "only-64bit",
+    "only-aarch64",
+    "only-aarch64-apple-darwin",
+    "only-aarch64-unknown-linux-gnu",
+    "only-apple",
+    "only-arm",
+    "only-avr",
+    "only-beta",
+    "only-bpf",
+    "only-cdb",
+    "only-dist",
+    "only-elf",
+    "only-emscripten",
+    "only-gnu",
+    "only-i686-pc-windows-gnu",
+    "only-i686-pc-windows-msvc",
+    "only-i686-unknown-linux-gnu",
+    "only-ios",
+    "only-linux",
+    "only-loongarch32",
+    "only-loongarch64",
+    "only-loongarch64-unknown-linux-gnu",
+    "only-macos",
+    "only-mips",
+    "only-mips64",
+    "only-msp430",
+    "only-msvc",
+    "only-nightly",
+    "only-nvptx64",
+    "only-powerpc",
+    "only-riscv64",
+    "only-rustc_abi-x86-sse2",
+    "only-s390x",
+    "only-sparc",
+    "only-sparc64",
+    "only-stable",
+    "only-thumb",
+    "only-tvos",
+    "only-unix",
+    "only-visionos",
+    "only-wasm32",
+    "only-wasm32-bare",
+    "only-wasm32-wasip1",
+    "only-watchos",
+    "only-windows",
+    "only-windows-gnu",
+    "only-windows-msvc",
+    "only-x86",
+    "only-x86_64",
+    "only-x86_64-apple-darwin",
+    "only-x86_64-fortanix-unknown-sgx",
+    "only-x86_64-pc-windows-gnu",
+    "only-x86_64-pc-windows-msvc",
+    "only-x86_64-unknown-linux-gnu",
+    "pp-exact",
+    "pretty-compare-only",
+    "pretty-mode",
+    "proc-macro",
+    "reference",
+    "regex-error-pattern",
+    "remap-src-base",
+    "revisions",
+    "run-fail",
+    "run-flags",
+    "run-pass",
+    "run-rustfix",
+    "rustc-env",
+    "rustfix-only-machine-applicable",
+    "should-fail",
+    "should-ice",
+    "stderr-per-bitwidth",
+    "test-mir-pass",
+    "unique-doc-out-dir",
+    "unset-exec-env",
+    "unset-rustc-env",
+    // Used by the tidy check `unknown_revision`.
+    "unused-revision-names",
+    // tidy-alphabetical-end
+];
 
 const KNOWN_HTMLDOCCK_DIRECTIVE_NAMES: &[&str] = &[
     "count",
@@ -834,35 +1089,26 @@ pub(crate) struct CheckDirectiveResult<'ln> {
 pub(crate) fn check_directive<'a>(
     directive_ln: &'a str,
     mode: TestMode,
-    original_line: &str,
 ) -> CheckDirectiveResult<'a> {
     let (directive_name, post) = directive_ln.split_once([':', ' ']).unwrap_or((directive_ln, ""));
 
+    let is_known_directive = KNOWN_DIRECTIVE_NAMES.contains(&directive_name)
+        || match mode {
+            TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
+            TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES.contains(&directive_name),
+            _ => false,
+        };
+
     let trailing = post.trim().split_once(' ').map(|(pre, _)| pre).unwrap_or(post);
-    let is_known = |s: &str| {
-        KNOWN_DIRECTIVE_NAMES.contains(&s)
-            || match mode {
-                TestMode::Rustdoc | TestMode::RustdocJson => {
-                    original_line.starts_with("//@")
-                        && match mode {
-                            TestMode::Rustdoc => KNOWN_HTMLDOCCK_DIRECTIVE_NAMES,
-                            TestMode::RustdocJson => KNOWN_JSONDOCCK_DIRECTIVE_NAMES,
-                            _ => unreachable!(),
-                        }
-                        .contains(&s)
-                }
-                _ => false,
-            }
-    };
     let trailing_directive = {
         // 1. is the directive name followed by a space? (to exclude `:`)
-        matches!(directive_ln.get(directive_name.len()..), Some(s) if s.starts_with(' '))
+        directive_ln.get(directive_name.len()..).is_some_and(|s| s.starts_with(' '))
             // 2. is what is after that directive also a directive (ex: "only-x86 only-arm")
-            && is_known(trailing)
+            && KNOWN_DIRECTIVE_NAMES.contains(&trailing)
     }
     .then_some(trailing);
 
-    CheckDirectiveResult { is_known_directive: is_known(&directive_name), trailing_directive }
+    CheckDirectiveResult { is_known_directive, trailing_directive }
 }
 
 const COMPILETEST_DIRECTIVE_PREFIX: &str = "//@";
@@ -914,9 +1160,9 @@ fn iter_directives(
         };
 
         // Perform unknown directive check on Rust files.
-        if testfile.extension().map(|e| e == "rs").unwrap_or(false) {
+        if testfile.extension() == Some("rs") {
             let CheckDirectiveResult { is_known_directive, trailing_directive } =
-                check_directive(directive_line.raw_directive, mode, ln);
+                check_directive(directive_line.raw_directive, mode);
 
             if !is_known_directive {
                 *poisoned = true;
@@ -936,7 +1182,7 @@ fn iter_directives(
                     "{testfile}:{line_number}: detected trailing compiletest test directive `{}`",
                     trailing_directive,
                 );
-                help!("put the trailing directive in it's own line: `//@ {}`", trailing_directive);
+                help!("put the trailing directive in its own line: `//@ {}`", trailing_directive);
 
                 return;
             }
diff --git a/src/tools/compiletest/src/runtest/rustdoc.rs b/src/tools/compiletest/src/runtest/rustdoc.rs
index 637ea833357..236f021ce82 100644
--- a/src/tools/compiletest/src/runtest/rustdoc.rs
+++ b/src/tools/compiletest/src/runtest/rustdoc.rs
@@ -4,7 +4,7 @@ use super::{TestCx, remove_and_create_dir_all};
 
 impl TestCx<'_> {
     pub(super) fn run_rustdoc_test(&self) {
-        assert!(self.revision.is_none(), "revisions not relevant here");
+        assert!(self.revision.is_none(), "revisions not supported in this test suite");
 
         let out_dir = self.output_base_dir();
         remove_and_create_dir_all(&out_dir).unwrap_or_else(|e| {
diff --git a/src/tools/compiletest/src/runtest/rustdoc_json.rs b/src/tools/compiletest/src/runtest/rustdoc_json.rs
index 9f88faca892..4f35efedfde 100644
--- a/src/tools/compiletest/src/runtest/rustdoc_json.rs
+++ b/src/tools/compiletest/src/runtest/rustdoc_json.rs
@@ -6,7 +6,7 @@ impl TestCx<'_> {
     pub(super) fn run_rustdoc_json_test(&self) {
         //FIXME: Add bless option.
 
-        assert!(self.revision.is_none(), "revisions not relevant here");
+        assert!(self.revision.is_none(), "revisions not supported in this test suite");
 
         let out_dir = self.output_base_dir();
         remove_and_create_dir_all(&out_dir).unwrap_or_else(|e| {
diff --git a/src/tools/jsondocck/src/directive.rs b/src/tools/jsondocck/src/directive.rs
index fdb2fa6dbbe..c52c1686660 100644
--- a/src/tools/jsondocck/src/directive.rs
+++ b/src/tools/jsondocck/src/directive.rs
@@ -105,13 +105,10 @@ impl DirectiveKind {
                 [_path, value] => Self::HasNotValue { value: value.clone() },
                 _ => panic!("`//@ !has` must have 2 or 3 arguments, but got {args:?}"),
             },
-            // Ignore compiletest directives, like //@ edition
-            (_, false) if KNOWN_DIRECTIVE_NAMES.contains(&directive_name) => {
-                return None;
-            }
-            _ => {
-                panic!("Invalid directive `//@ {}{directive_name}`", if negated { "!" } else { "" })
-            }
+            // Ignore unknown directives as they might be compiletest directives
+            // since they share the same `//@` prefix by convention. In any case,
+            // compiletest rejects unknown directives for us.
+            _ => return None,
         };
 
         Some((kind, &args[0]))
@@ -216,10 +213,6 @@ fn get_one<'a>(matches: &[&'a Value]) -> Result<&'a Value, String> {
     }
 }
 
-// FIXME: This setup is temporary until we figure out how to improve this situation.
-//        See <https://github.com/rust-lang/rust/issues/125813#issuecomment-2141953780>.
-include!(concat!(env!("CARGO_MANIFEST_DIR"), "/../compiletest/src/directive-list.rs"));
-
 fn string_to_value<'a>(s: &str, cache: &'a Cache) -> Cow<'a, Value> {
     if s.starts_with("$") {
         Cow::Borrowed(&cache.variables.get(&s[1..]).unwrap_or_else(|| {
diff --git a/src/tools/jsondocck/src/main.rs b/src/tools/jsondocck/src/main.rs
index d84be4d3a3a..c3487565c23 100644
--- a/src/tools/jsondocck/src/main.rs
+++ b/src/tools/jsondocck/src/main.rs
@@ -47,8 +47,8 @@ static LINE_PATTERN: LazyLock<Regex> = LazyLock::new(|| {
         ^\s*
         //@\s+
         (?P<negated>!?)
-        (?P<directive>[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*)
-        (?P<args>.*)$
+        (?P<directive>.+?)
+        (?:[\s:](?P<args>.*))?$
     "#,
     )
     .ignore_whitespace(true)
@@ -58,15 +58,7 @@ static LINE_PATTERN: LazyLock<Regex> = LazyLock::new(|| {
 });
 
 static DEPRECATED_LINE_PATTERN: LazyLock<Regex> = LazyLock::new(|| {
-    RegexBuilder::new(
-        r#"
-        //\s+@
-    "#,
-    )
-    .ignore_whitespace(true)
-    .unicode(true)
-    .build()
-    .unwrap()
+    RegexBuilder::new(r"//\s+@").ignore_whitespace(true).unicode(true).build().unwrap()
 });
 
 fn print_err(msg: &str, lineno: usize) {
@@ -94,7 +86,7 @@ fn get_directives(template: &str) -> Result<Vec<Directive>, ()> {
 
         let negated = &cap["negated"] == "!";
 
-        let args_str = &cap["args"];
+        let args_str = cap.name("args").map(|m| m.as_str()).unwrap_or_default();
         let Some(args) = shlex::split(args_str) else {
             print_err(&format!("Invalid arguments to shlex::split: `{args_str}`",), lineno);
             errors = true;
-- 
cgit 1.4.1-3-g733a5


From 6b02597ed3dc7a7c3581960ca6afae575f6c691e Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Sun, 13 Jul 2025 16:21:25 +0800
Subject: update issue number for `const_trait_impl`

---
 compiler/rustc_feature/src/unstable.rs                   |  2 +-
 compiler/rustc_passes/messages.ftl                       |  2 +-
 library/alloc/src/string.rs                              |  2 +-
 library/alloc/src/vec/mod.rs                             |  2 +-
 library/core/src/cell.rs                                 |  8 ++++----
 library/core/src/default.rs                              |  4 ++--
 library/core/src/iter/sources/empty.rs                   |  2 +-
 library/core/src/marker.rs                               |  2 +-
 library/core/src/ops/function.rs                         | 16 ++++++++--------
 library/core/src/option.rs                               |  2 +-
 library/core/src/ptr/alignment.rs                        |  2 +-
 library/core/src/slice/mod.rs                            |  4 ++--
 library/core/src/str/mod.rs                              |  4 ++--
 src/librustdoc/html/render/mod.rs                        |  4 ++--
 .../rust-analyzer/crates/ide-db/src/generated/lints.rs   |  4 ++--
 .../const-super-trait-nightly-disabled.stderr            |  4 ++--
 .../const-super-trait-stable-disabled.stderr             |  4 ++--
 tests/ui/consts/issue-90870.stderr                       |  6 +++---
 .../impl-trait/precise-capturing/bound-modifiers.stderr  |  2 +-
 tests/ui/traits/const-traits/cross-crate.stock.stderr    |  2 +-
 tests/ui/traits/const-traits/cross-crate.stocknc.stderr  |  2 +-
 tests/ui/traits/const-traits/feature-gate.stock.stderr   | 12 ++++++------
 .../macro-bare-trait-objects-const-trait-bounds.stderr   |  2 +-
 ...macro-const-trait-bound-theoretical-regression.stderr |  4 ++--
 .../ui/traits/const-traits/staged-api-user-crate.stderr  |  2 +-
 tests/ui/traits/const-traits/staged-api.stderr           |  4 ++--
 tests/ui/traits/const-traits/std-impl-gate.stock.stderr  |  2 +-
 .../traits/const-traits/super-traits-fail-3.nnn.stderr   |  4 ++--
 .../traits/const-traits/super-traits-fail-3.nny.stderr   |  4 ++--
 .../traits/const-traits/super-traits-fail-3.nyn.stderr   | 10 +++++-----
 .../traits/const-traits/super-traits-fail-3.nyy.stderr   | 10 +++++-----
 31 files changed, 67 insertions(+), 67 deletions(-)

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index efd8bde71d7..e985e04ba33 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -444,7 +444,7 @@ declare_features! (
     /// Be more precise when looking for live drops in a const context.
     (unstable, const_precise_live_drops, "1.46.0", Some(73255)),
     /// Allows `impl const Trait for T` syntax.
-    (unstable, const_trait_impl, "1.42.0", Some(67792)),
+    (unstable, const_trait_impl, "1.42.0", Some(143874)),
     /// Allows the `?` operator in const contexts.
     (unstable, const_try, "1.56.0", Some(74935)),
     /// Allows use of contracts attributes.
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 46c21dcf67b..0b857b0d693 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -700,7 +700,7 @@ passes_trait_impl_const_stability_mismatch_trait_unstable = ...but the trait is
 
 passes_trait_impl_const_stable =
     trait implementations cannot be const stable yet
-    .note = see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+    .note = see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
 
 passes_transparent_incompatible =
     transparent {$target} cannot have other repr hints
diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs
index 58baa07bc17..a189c00a6b6 100644
--- a/library/alloc/src/string.rs
+++ b/library/alloc/src/string.rs
@@ -2611,7 +2611,7 @@ impl_eq! { Cow<'a, str>, &'b str }
 impl_eq! { Cow<'a, str>, String }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl const Default for String {
     /// Creates an empty `String`.
     #[inline]
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 9dac58bac4f..1df6ab672ea 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -3895,7 +3895,7 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl<T> const Default for Vec<T> {
     /// Creates an empty `Vec<T>`.
     ///
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index c53a2b2beb4..d6d1bf2effa 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -333,7 +333,7 @@ impl<T: Copy> Clone for Cell<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl<T: ~const Default> const Default for Cell<T> {
     /// Creates a `Cell<T>`, with the `Default` value for T.
     #[inline]
@@ -1324,7 +1324,7 @@ impl<T: Clone> Clone for RefCell<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl<T: ~const Default> const Default for RefCell<T> {
     /// Creates a `RefCell<T>`, with the `Default` value for T.
     #[inline]
@@ -2332,7 +2332,7 @@ impl<T: ?Sized> UnsafeCell<T> {
 }
 
 #[stable(feature = "unsafe_cell_default", since = "1.10.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl<T: ~const Default> const Default for UnsafeCell<T> {
     /// Creates an `UnsafeCell`, with the `Default` value for T.
     fn default() -> UnsafeCell<T> {
@@ -2437,7 +2437,7 @@ impl<T: ?Sized> SyncUnsafeCell<T> {
 }
 
 #[unstable(feature = "sync_unsafe_cell", issue = "95439")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl<T: ~const Default> const Default for SyncUnsafeCell<T> {
     /// Creates an `SyncUnsafeCell`, with the `Default` value for T.
     fn default() -> SyncUnsafeCell<T> {
diff --git a/library/core/src/default.rs b/library/core/src/default.rs
index 4d108b0c18e..897267968aa 100644
--- a/library/core/src/default.rs
+++ b/library/core/src/default.rs
@@ -104,7 +104,7 @@ use crate::ascii::Char as AsciiChar;
 #[rustc_diagnostic_item = "Default"]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[const_trait]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 pub trait Default: Sized {
     /// Returns the "default value" for a type.
     ///
@@ -151,7 +151,7 @@ pub macro Default($item:item) {
 macro_rules! default_impl {
     ($t:ty, $v:expr, $doc:tt) => {
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_default", issue = "67792")]
+        #[rustc_const_unstable(feature = "const_default", issue = "143894")]
         impl const Default for $t {
             #[inline(always)]
             #[doc = $doc]
diff --git a/library/core/src/iter/sources/empty.rs b/library/core/src/iter/sources/empty.rs
index 309962ab70c..1844c76e5df 100644
--- a/library/core/src/iter/sources/empty.rs
+++ b/library/core/src/iter/sources/empty.rs
@@ -81,7 +81,7 @@ impl<T> Clone for Empty<T> {
 // not #[derive] because that adds a Default bound on T,
 // which isn't necessary.
 #[stable(feature = "iter_empty", since = "1.2.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl<T> const Default for Empty<T> {
     fn default() -> Empty<T> {
         Empty(marker::PhantomData)
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index 6531d3ec766..45277a1c82d 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -863,7 +863,7 @@ impl<T: PointeeSized> Clone for PhantomData<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl<T: PointeeSized> const Default for PhantomData<T> {
     fn default() -> Self {
         Self
diff --git a/library/core/src/ops/function.rs b/library/core/src/ops/function.rs
index 763b60d88e5..efc751a094d 100644
--- a/library/core/src/ops/function.rs
+++ b/library/core/src/ops/function.rs
@@ -73,7 +73,7 @@ use crate::marker::Tuple;
 #[fundamental] // so that regex can rely that `&str: !FnMut`
 #[must_use = "closures are lazy and do nothing unless called"]
 #[const_trait]
-#[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+#[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
 pub trait Fn<Args: Tuple>: FnMut<Args> {
     /// Performs the call operation.
     #[unstable(feature = "fn_traits", issue = "29625")]
@@ -161,7 +161,7 @@ pub trait Fn<Args: Tuple>: FnMut<Args> {
 #[fundamental] // so that regex can rely that `&str: !FnMut`
 #[must_use = "closures are lazy and do nothing unless called"]
 #[const_trait]
-#[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+#[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
 pub trait FnMut<Args: Tuple>: FnOnce<Args> {
     /// Performs the call operation.
     #[unstable(feature = "fn_traits", issue = "29625")]
@@ -241,7 +241,7 @@ pub trait FnMut<Args: Tuple>: FnOnce<Args> {
 #[fundamental] // so that regex can rely that `&str: !FnMut`
 #[must_use = "closures are lazy and do nothing unless called"]
 #[const_trait]
-#[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+#[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
 pub trait FnOnce<Args: Tuple> {
     /// The returned type after the call operator is used.
     #[lang = "fn_once_output"]
@@ -257,7 +257,7 @@ mod impls {
     use crate::marker::Tuple;
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+    #[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
     impl<A: Tuple, F: ?Sized> const Fn<A> for &F
     where
         F: ~const Fn<A>,
@@ -268,7 +268,7 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+    #[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
     impl<A: Tuple, F: ?Sized> const FnMut<A> for &F
     where
         F: ~const Fn<A>,
@@ -279,7 +279,7 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+    #[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
     impl<A: Tuple, F: ?Sized> const FnOnce<A> for &F
     where
         F: ~const Fn<A>,
@@ -292,7 +292,7 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+    #[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
     impl<A: Tuple, F: ?Sized> const FnMut<A> for &mut F
     where
         F: ~const FnMut<A>,
@@ -303,7 +303,7 @@ mod impls {
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_trait_impl", issue = "67792")]
+    #[rustc_const_unstable(feature = "const_trait_impl", issue = "143874")]
     impl<A: Tuple, F: ?Sized> const FnOnce<A> for &mut F
     where
         F: ~const FnMut<A>,
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 4ede273feda..9f432758a66 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -2112,7 +2112,7 @@ where
 impl<T> crate::clone::UseCloned for Option<T> where T: crate::clone::UseCloned {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl<T> const Default for Option<T> {
     /// Returns [`None`][Option::None].
     ///
diff --git a/library/core/src/ptr/alignment.rs b/library/core/src/ptr/alignment.rs
index 304cde05af9..6d473a4bd56 100644
--- a/library/core/src/ptr/alignment.rs
+++ b/library/core/src/ptr/alignment.rs
@@ -230,7 +230,7 @@ impl hash::Hash for Alignment {
 
 /// Returns [`Alignment::MIN`], which is valid for any type.
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl const Default for Alignment {
     fn default() -> Alignment {
         Alignment::MIN
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index db31bd2bbfb..85a4d757e65 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -5190,7 +5190,7 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl<T> const Default for &[T] {
     /// Creates an empty slice.
     fn default() -> Self {
@@ -5199,7 +5199,7 @@ impl<T> const Default for &[T] {
 }
 
 #[stable(feature = "mut_slice_default", since = "1.5.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl<T> const Default for &mut [T] {
     /// Creates a mutable empty slice.
     fn default() -> Self {
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index 32a22988175..fba3436496e 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -3072,7 +3072,7 @@ impl AsRef<[u8]> for str {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl const Default for &str {
     /// Creates an empty str
     #[inline]
@@ -3082,7 +3082,7 @@ impl const Default for &str {
 }
 
 #[stable(feature = "default_mut_str", since = "1.28.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl const Default for &mut str {
     /// Creates an empty mutable str
     #[inline]
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 6a1fad06ae3..70f3f54e4c0 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -980,7 +980,7 @@ fn assoc_method(
     let name = meth.name.as_ref().unwrap();
     let vis = visibility_print_with_space(meth, cx).to_string();
     let defaultness = print_default_space(meth.is_default());
-    // FIXME: Once https://github.com/rust-lang/rust/issues/67792 is implemented, we can remove
+    // FIXME: Once https://github.com/rust-lang/rust/issues/143874 is implemented, we can remove
     // this condition.
     let constness = match render_mode {
         RenderMode::Normal => print_constness_with_space(
@@ -2152,7 +2152,7 @@ fn render_rightside(
     let tcx = cx.tcx();
 
     fmt::from_fn(move |w| {
-        // FIXME: Once https://github.com/rust-lang/rust/issues/67792 is implemented, we can remove
+        // FIXME: Once https://github.com/rust-lang/rust/issues/143874 is implemented, we can remove
         // this condition.
         let const_stability = match render_mode {
             RenderMode::Normal => item.const_stability(tcx),
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 de8a42979bb..f9eb44d03ab 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
@@ -4711,9 +4711,9 @@ The tracking issue for this feature is: [#133668]
         label: "const_trait_impl",
         description: r##"# `const_trait_impl`
 
-The tracking issue for this feature is: [#67792]
+The tracking issue for this feature is: [#143874]
 
-[#67792]: https://github.com/rust-lang/rust/issues/67792
+[#143874]: https://github.com/rust-lang/rust/issues/143874
 
 ------------------------
 "##,
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
index be3de580983..5ce815b9aed 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
@@ -16,7 +16,7 @@ error[E0658]: const trait impls are experimental
 LL | trait Bar: ~const Foo {}
    |            ^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -26,7 +26,7 @@ error[E0658]: const trait impls are experimental
 LL | const fn foo<T: ~const Bar>(x: &T) {
    |                 ^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
index a23793580f7..3dc147e076f 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
@@ -16,7 +16,7 @@ error[E0658]: const trait impls are experimental
 7 | trait Bar: ~const Foo {}
   |            ^^^^^^
   |
-  = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+  = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
 
 error[E0658]: const trait impls are experimental
  --> const-super-trait.rs:9:17
@@ -24,7 +24,7 @@ error[E0658]: const trait impls are experimental
 9 | const fn foo<T: ~const Bar>(x: &T) {
   |                 ^^^^^^
   |
-  = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+  = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
 
 error: `[const]` can only be applied to `#[const_trait]` traits
  --> const-super-trait.rs:7:12
diff --git a/tests/ui/consts/issue-90870.stderr b/tests/ui/consts/issue-90870.stderr
index 60993f25864..c5a78531026 100644
--- a/tests/ui/consts/issue-90870.stderr
+++ b/tests/ui/consts/issue-90870.stderr
@@ -5,7 +5,7 @@ LL |     a == b
    |     ^^^^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 help: consider dereferencing here
@@ -31,7 +31,7 @@ LL |     a == b
    |     ^^^^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 help: consider dereferencing here
@@ -57,7 +57,7 @@ LL |         if l == r {
    |            ^^^^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 help: consider dereferencing here
diff --git a/tests/ui/impl-trait/precise-capturing/bound-modifiers.stderr b/tests/ui/impl-trait/precise-capturing/bound-modifiers.stderr
index d4b5b47b41b..deab31c251f 100644
--- a/tests/ui/impl-trait/precise-capturing/bound-modifiers.stderr
+++ b/tests/ui/impl-trait/precise-capturing/bound-modifiers.stderr
@@ -63,7 +63,7 @@ error[E0658]: const trait impls are experimental
 LL | fn constness() -> impl Sized + const use<> {}
    |                                ^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/ui/traits/const-traits/cross-crate.stock.stderr b/tests/ui/traits/const-traits/cross-crate.stock.stderr
index 7cdde5a079f..44a60c99ae9 100644
--- a/tests/ui/traits/const-traits/cross-crate.stock.stderr
+++ b/tests/ui/traits/const-traits/cross-crate.stock.stderr
@@ -5,7 +5,7 @@ LL |     Const.func();
    |           ^^^^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/ui/traits/const-traits/cross-crate.stocknc.stderr b/tests/ui/traits/const-traits/cross-crate.stocknc.stderr
index fb47bf9169f..766c20aa821 100644
--- a/tests/ui/traits/const-traits/cross-crate.stocknc.stderr
+++ b/tests/ui/traits/const-traits/cross-crate.stocknc.stderr
@@ -13,7 +13,7 @@ LL |     Const.func();
    |           ^^^^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/ui/traits/const-traits/feature-gate.stock.stderr b/tests/ui/traits/const-traits/feature-gate.stock.stderr
index f9d966f0362..f3ba3039a23 100644
--- a/tests/ui/traits/const-traits/feature-gate.stock.stderr
+++ b/tests/ui/traits/const-traits/feature-gate.stock.stderr
@@ -4,7 +4,7 @@ error[E0658]: const trait impls are experimental
 LL | impl const T for S {}
    |      ^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -14,7 +14,7 @@ error[E0658]: const trait impls are experimental
 LL | const fn f<A: [const] T>() {}
    |               ^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -24,7 +24,7 @@ error[E0658]: const trait impls are experimental
 LL | fn g<A: const T>() {}
    |         ^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -34,7 +34,7 @@ error[E0658]: const trait impls are experimental
 LL | discard! { impl [const] T }
    |                 ^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -44,7 +44,7 @@ error[E0658]: const trait impls are experimental
 LL | discard! { impl const T }
    |                 ^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -54,7 +54,7 @@ error[E0658]: `const_trait` is a temporary placeholder for marking a trait that
 LL | #[const_trait]
    | ^^^^^^^^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.stderr b/tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.stderr
index bc0e48112b9..a4e77154b17 100644
--- a/tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.stderr
+++ b/tests/ui/traits/const-traits/macro-bare-trait-objects-const-trait-bounds.stderr
@@ -13,7 +13,7 @@ error[E0658]: const trait impls are experimental
 LL | check! { [const] Trait }
    |           ^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.stderr b/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.stderr
index 5dd648554c9..b500e4858d1 100644
--- a/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.stderr
+++ b/tests/ui/traits/const-traits/macro-const-trait-bound-theoretical-regression.stderr
@@ -26,7 +26,7 @@ error[E0658]: const trait impls are experimental
 LL | demo! { impl const Trait }
    |              ^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -36,7 +36,7 @@ error[E0658]: const trait impls are experimental
 LL | demo! { dyn const Trait }
    |             ^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/ui/traits/const-traits/staged-api-user-crate.stderr b/tests/ui/traits/const-traits/staged-api-user-crate.stderr
index 8ac83770cf7..81611da9e74 100644
--- a/tests/ui/traits/const-traits/staged-api-user-crate.stderr
+++ b/tests/ui/traits/const-traits/staged-api-user-crate.stderr
@@ -5,7 +5,7 @@ LL |     Unstable::func();
    |     ^^^^^^^^^^^^^^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/ui/traits/const-traits/staged-api.stderr b/tests/ui/traits/const-traits/staged-api.stderr
index 4756c490cb1..3e85834eb94 100644
--- a/tests/ui/traits/const-traits/staged-api.stderr
+++ b/tests/ui/traits/const-traits/staged-api.stderr
@@ -21,7 +21,7 @@ error: trait implementations cannot be const stable yet
 LL | impl const U for u16 {}
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
 
 error: const stability on the impl does not match the const stability on the trait
   --> $DIR/staged-api.rs:102:1
@@ -46,7 +46,7 @@ error: trait implementations cannot be const stable yet
 LL | impl const S for u16 {}
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
 
 error: const stability on the impl does not match the const stability on the trait
   --> $DIR/staged-api.rs:117:1
diff --git a/tests/ui/traits/const-traits/std-impl-gate.stock.stderr b/tests/ui/traits/const-traits/std-impl-gate.stock.stderr
index 1fa71e41a98..261f68bebdb 100644
--- a/tests/ui/traits/const-traits/std-impl-gate.stock.stderr
+++ b/tests/ui/traits/const-traits/std-impl-gate.stock.stderr
@@ -5,7 +5,7 @@ LL |     Default::default()
    |     ^^^^^^^^^^^^^^^^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
index eb1beb41e37..3f48375dd04 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
@@ -16,7 +16,7 @@ error[E0658]: const trait impls are experimental
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -26,7 +26,7 @@ error[E0658]: const trait impls are experimental
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
index eb1beb41e37..3f48375dd04 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
@@ -16,7 +16,7 @@ error[E0658]: const trait impls are experimental
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -26,7 +26,7 @@ error[E0658]: const trait impls are experimental
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nyn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nyn.stderr
index 7c465731a99..b00ad706a5f 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nyn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nyn.stderr
@@ -4,7 +4,7 @@ error[E0658]: const trait impls are experimental
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -14,7 +14,7 @@ error[E0658]: const trait impls are experimental
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -24,7 +24,7 @@ error[E0658]: `const_trait` is a temporary placeholder for marking a trait that
 LL | #[cfg_attr(any(yyy, yyn, nyy, nyn), const_trait)]
    |                                     ^^^^^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -34,7 +34,7 @@ error[E0658]: `const_trait` is a temporary placeholder for marking a trait that
 LL | #[cfg_attr(any(yyy, yny, nyy, nyn), const_trait)]
    |                                     ^^^^^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -45,7 +45,7 @@ LL |     x.a();
    |       ^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nyy.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nyy.stderr
index 7c465731a99..b00ad706a5f 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nyy.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nyy.stderr
@@ -4,7 +4,7 @@ error[E0658]: const trait impls are experimental
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -14,7 +14,7 @@ error[E0658]: const trait impls are experimental
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -24,7 +24,7 @@ error[E0658]: `const_trait` is a temporary placeholder for marking a trait that
 LL | #[cfg_attr(any(yyy, yyn, nyy, nyn), const_trait)]
    |                                     ^^^^^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -34,7 +34,7 @@ error[E0658]: `const_trait` is a temporary placeholder for marking a trait that
 LL | #[cfg_attr(any(yyy, yny, nyy, nyn), const_trait)]
    |                                     ^^^^^^^^^^^
    |
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
@@ -45,7 +45,7 @@ LL |     x.a();
    |       ^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+   = 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
 
-- 
cgit 1.4.1-3-g733a5


From ef726a4cef26710fb190d9a179f7be62be16e95c Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 13 Jul 2025 15:47:17 +0000
Subject: Ensure proper item queries for assoc tys

---
 compiler/rustc_hir_analysis/src/check/check.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index f4bbf03f0c2..604add6ffb9 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -889,8 +889,6 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
             tcx.ensure_ok().predicates_of(def_id);
             tcx.ensure_ok().explicit_item_bounds(def_id);
             tcx.ensure_ok().explicit_item_self_bounds(def_id);
-            tcx.ensure_ok().item_bounds(def_id);
-            tcx.ensure_ok().item_self_bounds(def_id);
             if tcx.is_conditionally_const(def_id) {
                 tcx.ensure_ok().explicit_implied_const_bounds(def_id);
                 tcx.ensure_ok().const_conditions(def_id);
@@ -1042,8 +1040,12 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
             let has_type = match assoc_item.container {
                 ty::AssocItemContainer::Impl => true,
                 ty::AssocItemContainer::Trait => {
-                    tcx.ensure_ok().item_bounds(def_id);
-                    tcx.ensure_ok().item_self_bounds(def_id);
+                    tcx.ensure_ok().explicit_item_bounds(def_id);
+                    tcx.ensure_ok().explicit_item_self_bounds(def_id);
+                    if tcx.is_conditionally_const(def_id) {
+                        tcx.ensure_ok().explicit_implied_const_bounds(def_id);
+                        tcx.ensure_ok().const_conditions(def_id);
+                    }
                     res = res.and(check_trait_item(tcx, def_id));
                     assoc_item.defaultness(tcx).has_value()
                 }
-- 
cgit 1.4.1-3-g733a5


From 549a5d8b2843cff903a872ffa682f34d74bb341a Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 13 Jul 2025 16:23:20 +0000
Subject: Dont collect assoc ty item bounds from trait where clause for host
 effect predicates

---
 .../rustc_hir_analysis/src/collect/item_bounds.rs  | 56 +++++++++++++---------
 tests/crashes/133275-1.rs                          | 13 -----
 tests/crashes/133275-2.rs                          | 15 ------
 .../const-traits/const-assoc-bound-in-trait-wc.rs  | 13 +++++
 4 files changed, 47 insertions(+), 50 deletions(-)
 delete mode 100644 tests/crashes/133275-1.rs
 delete mode 100644 tests/crashes/133275-2.rs
 create mode 100644 tests/ui/traits/const-traits/const-assoc-bound-in-trait-wc.rs

diff --git a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
index e51ef46afb7..7e3fb5448f6 100644
--- a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
+++ b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
@@ -38,12 +38,13 @@ fn associated_type_bounds<'tcx>(
         let icx = ItemCtxt::new(tcx, assoc_item_def_id);
         let mut bounds = Vec::new();
         icx.lowerer().lower_bounds(item_ty, hir_bounds, &mut bounds, ty::List::empty(), filter);
-        // Implicit bounds are added to associated types unless a `?Trait` bound is found
+
         match filter {
             PredicateFilter::All
             | PredicateFilter::SelfOnly
             | PredicateFilter::SelfTraitThatDefines(_)
             | PredicateFilter::SelfAndAssociatedTypeBounds => {
+                // Implicit bounds are added to associated types unless a `?Trait` bound is found.
                 icx.lowerer().add_sizedness_bounds(
                     &mut bounds,
                     item_ty,
@@ -53,37 +54,48 @@ fn associated_type_bounds<'tcx>(
                     span,
                 );
                 icx.lowerer().add_default_traits(&mut bounds, item_ty, hir_bounds, None, span);
+
+                // Also collect `where Self::Assoc: Trait` from the parent trait's where clauses.
+                let trait_def_id = tcx.local_parent(assoc_item_def_id);
+                let trait_predicates = tcx.trait_explicit_predicates_and_bounds(trait_def_id);
+
+                let item_trait_ref =
+                    ty::TraitRef::identity(tcx, tcx.parent(assoc_item_def_id.to_def_id()));
+                bounds.extend(trait_predicates.predicates.iter().copied().filter_map(
+                    |(clause, span)| {
+                        remap_gat_vars_and_recurse_into_nested_projections(
+                            tcx,
+                            filter,
+                            item_trait_ref,
+                            assoc_item_def_id,
+                            span,
+                            clause,
+                        )
+                    },
+                ));
             }
             // `ConstIfConst` is only interested in `[const]` bounds.
-            PredicateFilter::ConstIfConst | PredicateFilter::SelfConstIfConst => {}
+            PredicateFilter::ConstIfConst | PredicateFilter::SelfConstIfConst => {
+                // FIXME(const_trait_impl): We *could* uplift the
+                // `where Self::Assoc: [const] Trait` bounds from the parent trait
+                // here too, but we'd need to split `const_conditions` into two
+                // queries (like we do for `trait_explicit_predicates_and_bounds`)
+                // since we need to also filter the predicates *out* of the const
+                // conditions or they lead to cycles in the trait solver when
+                // utilizing these bounds. For now, let's do nothing.
+            }
         }
 
-        let trait_def_id = tcx.local_parent(assoc_item_def_id);
-        let trait_predicates = tcx.trait_explicit_predicates_and_bounds(trait_def_id);
-
-        let item_trait_ref = ty::TraitRef::identity(tcx, tcx.parent(assoc_item_def_id.to_def_id()));
-        let bounds_from_parent =
-            trait_predicates.predicates.iter().copied().filter_map(|(clause, span)| {
-                remap_gat_vars_and_recurse_into_nested_projections(
-                    tcx,
-                    filter,
-                    item_trait_ref,
-                    assoc_item_def_id,
-                    span,
-                    clause,
-                )
-            });
-
-        let all_bounds = tcx.arena.alloc_from_iter(bounds.into_iter().chain(bounds_from_parent));
+        let bounds = tcx.arena.alloc_from_iter(bounds);
         debug!(
             "associated_type_bounds({}) = {:?}",
             tcx.def_path_str(assoc_item_def_id.to_def_id()),
-            all_bounds
+            bounds
         );
 
-        assert_only_contains_predicates_from(filter, all_bounds, item_ty);
+        assert_only_contains_predicates_from(filter, bounds, item_ty);
 
-        all_bounds
+        bounds
     })
 }
 
diff --git a/tests/crashes/133275-1.rs b/tests/crashes/133275-1.rs
deleted file mode 100644
index 73c04f5d6e4..00000000000
--- a/tests/crashes/133275-1.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ known-bug: #133275
-#![feature(const_trait_impl)]
-#![feature(associated_type_defaults)]
-
-#[const_trait]
-trait Foo3<T>
-where
-    Self::Baz: Clone,
-{
-    type Baz = T;
-}
-
-pub fn main() {}
diff --git a/tests/crashes/133275-2.rs b/tests/crashes/133275-2.rs
deleted file mode 100644
index a774b3cdb69..00000000000
--- a/tests/crashes/133275-2.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ known-bug: #133275
-#![feature(const_trait_impl)]
-#[const_trait]
-pub trait Owo<X = <IntEnum as Uwu>::T> {}
-
-#[const_trait]
-trait Foo3<T>
-where
-    Self::Bar: Clone,
-    Self::Baz: Clone,
-{
-    type Bar = Vec<Self::Baz>;
-    type Baz = T;
-    //~^ ERROR the trait bound `T: Clone` is not satisfied
-}
diff --git a/tests/ui/traits/const-traits/const-assoc-bound-in-trait-wc.rs b/tests/ui/traits/const-traits/const-assoc-bound-in-trait-wc.rs
new file mode 100644
index 00000000000..81acce65f2a
--- /dev/null
+++ b/tests/ui/traits/const-traits/const-assoc-bound-in-trait-wc.rs
@@ -0,0 +1,13 @@
+//@ check-pass
+
+#![feature(const_clone)]
+#![feature(const_trait_impl)]
+
+#[const_trait]
+trait A where Self::Target: [const] Clone {
+    type Target;
+}
+
+const fn foo<T>() where T: [const] A {}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 8daf98b6236bed2db074b8e8beb7e3225201b71a Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 13 Jul 2025 16:26:13 +0000
Subject: Imply always-const host effects the same as any other item bound

---
 .../rustc_hir_analysis/src/collect/item_bounds.rs     |  1 +
 tests/ui/traits/const-traits/imply-always-const.rs    | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 tests/ui/traits/const-traits/imply-always-const.rs

diff --git a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
index 7e3fb5448f6..548ba343aae 100644
--- a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
+++ b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs
@@ -124,6 +124,7 @@ fn remap_gat_vars_and_recurse_into_nested_projections<'tcx>(
         ty::ClauseKind::Trait(tr) => tr.self_ty(),
         ty::ClauseKind::Projection(proj) => proj.projection_term.self_ty(),
         ty::ClauseKind::TypeOutlives(outlives) => outlives.0,
+        ty::ClauseKind::HostEffect(host) => host.self_ty(),
         _ => return None,
     };
 
diff --git a/tests/ui/traits/const-traits/imply-always-const.rs b/tests/ui/traits/const-traits/imply-always-const.rs
new file mode 100644
index 00000000000..f6cab0681ec
--- /dev/null
+++ b/tests/ui/traits/const-traits/imply-always-const.rs
@@ -0,0 +1,19 @@
+//@ check-pass
+
+#![feature(const_trait_impl)]
+
+#[const_trait]
+trait A where Self::Assoc: const B {
+    type Assoc;
+}
+
+#[const_trait]
+trait B {}
+
+fn needs_b<T: const B>() {}
+
+fn test<T: A>() {
+    needs_b::<T::Assoc>();
+}
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From c2c9aad3f69515019a849e3c5451e7a1482febb0 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 13 Jul 2025 19:20:05 +0000
Subject: Make sure that users don't take region obligations in a snapshot

---
 compiler/rustc_infer/src/infer/outlives/obligations.rs | 1 +
 compiler/rustc_infer/src/infer/snapshot/undo_log.rs    | 4 +++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_infer/src/infer/outlives/obligations.rs b/compiler/rustc_infer/src/infer/outlives/obligations.rs
index f272052aaa5..43504bd77c1 100644
--- a/compiler/rustc_infer/src/infer/outlives/obligations.rs
+++ b/compiler/rustc_infer/src/infer/outlives/obligations.rs
@@ -166,6 +166,7 @@ impl<'tcx> InferCtxt<'tcx> {
 
     /// Trait queries just want to pass back type obligations "as is"
     pub fn take_registered_region_obligations(&self) -> Vec<TypeOutlivesConstraint<'tcx>> {
+        assert!(!self.in_snapshot(), "cannot take registered region obligations in a snapshot");
         std::mem::take(&mut self.inner.borrow_mut().region_obligations)
     }
 
diff --git a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
index 6193f35f3eb..34e649afedc 100644
--- a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
+++ b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
@@ -1,3 +1,4 @@
+use std::assert_matches::assert_matches;
 use std::marker::PhantomData;
 
 use rustc_data_structures::undo_log::{Rollback, UndoLogs};
@@ -73,7 +74,8 @@ impl<'tcx> Rollback<UndoLog<'tcx>> for InferCtxtInner<'tcx> {
             }
             UndoLog::ProjectionCache(undo) => self.projection_cache.reverse(undo),
             UndoLog::PushTypeOutlivesConstraint => {
-                self.region_obligations.pop();
+                let popped = self.region_obligations.pop();
+                assert_matches!(popped, Some(_), "pushed region constraint but could not pop it");
             }
         }
     }
-- 
cgit 1.4.1-3-g733a5


From f6f2f83043001592f656fa988ef6015694d52ee9 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 13 Jul 2025 19:22:09 +0000
Subject: Simplify make_query_region_constraints

---
 .../src/type_check/constraint_conversion.rs        |  3 +++
 .../src/infer/canonical/query_response.rs          | 22 ++++++++++------------
 .../rustc_trait_selection/src/solve/delegate.rs    |  8 +-------
 .../src/traits/query/type_op/custom.rs             |  5 +----
 4 files changed, 15 insertions(+), 23 deletions(-)

diff --git a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
index 8ed552cfa4f..ca636a8c999 100644
--- a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
+++ b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
@@ -159,6 +159,9 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
                     }
 
                     GenericArgKind::Type(mut t1) => {
+                        // Scraped constraints may have had inference vars.
+                        t1 = self.infcx.resolve_vars_if_possible(t1);
+
                         // Normalize the type we receive from a `TypeOutlives` obligation
                         // in the new trait solver.
                         if infcx.next_trait_solver() {
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index 008ef690008..d5d49e3188a 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -13,7 +13,6 @@ use std::iter;
 use rustc_index::{Idx, IndexVec};
 use rustc_middle::arena::ArenaAllocatable;
 use rustc_middle::bug;
-use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::ty::{self, BoundVar, GenericArg, GenericArgKind, Ty, TyCtxt, TypeFoldable};
 use tracing::{debug, instrument};
 
@@ -23,7 +22,9 @@ use crate::infer::canonical::{
     QueryRegionConstraints, QueryResponse,
 };
 use crate::infer::region_constraints::{Constraint, RegionConstraintData};
-use crate::infer::{DefineOpaqueTypes, InferCtxt, InferOk, InferResult, SubregionOrigin};
+use crate::infer::{
+    DefineOpaqueTypes, InferCtxt, InferOk, InferResult, SubregionOrigin, TypeOutlivesConstraint,
+};
 use crate::traits::query::NoSolution;
 use crate::traits::{ObligationCause, PredicateObligations, ScrubbedTraitError, TraitEngine};
 
@@ -117,13 +118,7 @@ impl<'tcx> InferCtxt<'tcx> {
         let region_obligations = self.take_registered_region_obligations();
         debug!(?region_obligations);
         let region_constraints = self.with_region_constraints(|region_constraints| {
-            make_query_region_constraints(
-                tcx,
-                region_obligations
-                    .iter()
-                    .map(|r_o| (r_o.sup_type, r_o.sub_region, r_o.origin.to_constraint_category())),
-                region_constraints,
-            )
+            make_query_region_constraints(tcx, region_obligations, region_constraints)
         });
         debug!(?region_constraints);
 
@@ -570,7 +565,7 @@ impl<'tcx> InferCtxt<'tcx> {
 /// creates query region constraints.
 pub fn make_query_region_constraints<'tcx>(
     tcx: TyCtxt<'tcx>,
-    outlives_obligations: impl Iterator<Item = (Ty<'tcx>, ty::Region<'tcx>, ConstraintCategory<'tcx>)>,
+    outlives_obligations: Vec<TypeOutlivesConstraint<'tcx>>,
     region_constraints: &RegionConstraintData<'tcx>,
 ) -> QueryRegionConstraints<'tcx> {
     let RegionConstraintData { constraints, verifys } = region_constraints;
@@ -599,8 +594,11 @@ pub fn make_query_region_constraints<'tcx>(
             };
             (constraint, origin.to_constraint_category())
         })
-        .chain(outlives_obligations.map(|(ty, r, constraint_category)| {
-            (ty::OutlivesPredicate(ty.into(), r), constraint_category)
+        .chain(outlives_obligations.into_iter().map(|obl| {
+            (
+                ty::OutlivesPredicate(obl.sup_type.into(), obl.sub_region),
+                obl.origin.to_constraint_category(),
+            )
         }))
         .collect();
 
diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
index d22529d56a4..1a24254d57f 100644
--- a/compiler/rustc_trait_selection/src/solve/delegate.rs
+++ b/compiler/rustc_trait_selection/src/solve/delegate.rs
@@ -213,13 +213,7 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
         // inside of a `probe` whenever we have multiple choices inside of the solver.
         let region_obligations = self.0.inner.borrow().region_obligations().to_owned();
         let region_constraints = self.0.with_region_constraints(|region_constraints| {
-            make_query_region_constraints(
-                self.tcx,
-                region_obligations
-                    .iter()
-                    .map(|r_o| (r_o.sup_type, r_o.sub_region, r_o.origin.to_constraint_category())),
-                region_constraints,
-            )
+            make_query_region_constraints(self.tcx, region_obligations, region_constraints)
         });
 
         let mut seen = FxHashSet::default();
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
index 18010603286..3b549244431 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
@@ -103,10 +103,7 @@ where
     let region_constraint_data = infcx.take_and_reset_region_constraints();
     let region_constraints = query_response::make_query_region_constraints(
         infcx.tcx,
-        region_obligations
-            .iter()
-            .map(|r_o| (r_o.sup_type, r_o.sub_region, r_o.origin.to_constraint_category()))
-            .map(|(ty, r, cc)| (infcx.resolve_vars_if_possible(ty), r, cc)),
+        region_obligations,
         &region_constraint_data,
     );
 
-- 
cgit 1.4.1-3-g733a5


From 56a82a2402e369ba999e88de125e27014f975f17 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Sun, 13 Jul 2025 16:14:30 -0400
Subject: Fix empty backtrace

---
 build_system/src/build.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/build_system/src/build.rs b/build_system/src/build.rs
index 4033ffe0694..94b40319f4a 100644
--- a/build_system/src/build.rs
+++ b/build_system/src/build.rs
@@ -139,6 +139,9 @@ pub fn build_sysroot(env: &HashMap<String, String>, config: &ConfigInfo) -> Resu
         rustflags.push_str(&cg_rustflags);
     }
 
+    args.push(&"--features");
+    args.push(&"backtrace");
+
     let mut env = env.clone();
     env.insert("RUSTFLAGS".to_string(), rustflags);
     let sysroot_dir = library_dir.join("sysroot");
-- 
cgit 1.4.1-3-g733a5


From 623609e7132b80425e8661c9753bce78cab49bce Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Sun, 13 Jul 2025 16:34:14 -0400
Subject: Ignore failing test

---
 tests/failing-ui-tests.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/failing-ui-tests.txt b/tests/failing-ui-tests.txt
index 544d0bfc710..6979c04d534 100644
--- a/tests/failing-ui-tests.txt
+++ b/tests/failing-ui-tests.txt
@@ -80,3 +80,5 @@ tests/ui/uninhabited/uninhabited-transparent-return-abi.rs
 tests/ui/coroutine/panic-drops-resume.rs
 tests/ui/coroutine/panic-drops.rs
 tests/ui/coroutine/panic-safe.rs
+tests/ui/process/nofile-limit.rs
+tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
-- 
cgit 1.4.1-3-g733a5


From b01bbe06cc2fea18957895f2722d687b00efcbd7 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Sun, 13 Jul 2025 16:36:41 -0400
Subject: Fix no-f16-f128 feature name

---
 .github/workflows/m68k.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/m68k.yml b/.github/workflows/m68k.yml
index 4b67360df9d..176ee8628b0 100644
--- a/.github/workflows/m68k.yml
+++ b/.github/workflows/m68k.yml
@@ -82,14 +82,14 @@ jobs:
     - name: Build sample project with target defined as JSON spec
       run: |
         ./y.sh prepare --only-libcore --cross
-        ./y.sh build --sysroot --features compiler_builtins/no-f16-f128 --target-triple m68k-unknown-linux-gnu --target ${{ github.workspace }}/target_specs/m68k-unknown-linux-gnu.json
+        ./y.sh build --sysroot --features compiler-builtins-no-f16-f128 --target-triple m68k-unknown-linux-gnu --target ${{ github.workspace }}/target_specs/m68k-unknown-linux-gnu.json
         CG_RUSTFLAGS="-Clinker=m68k-unknown-linux-gnu-gcc" ./y.sh cargo build --manifest-path=./tests/hello-world/Cargo.toml --target ${{ github.workspace }}/target_specs/m68k-unknown-linux-gnu.json
         ./y.sh clean all
 
     - name: Build
       run: |
         ./y.sh prepare --only-libcore --cross
-        ./y.sh build --sysroot --features compiler_builtins/no-f16-f128 --target-triple m68k-unknown-linux-gnu
+        ./y.sh build --sysroot --features compiler-builtins-no-f16-f128 --target-triple m68k-unknown-linux-gnu
         ./y.sh test --mini-tests --target-triple m68k-unknown-linux-gnu
         CG_GCC_TEST_TARGET=m68k-unknown-linux-gnu ./y.sh test --cargo-tests --target-triple m68k-unknown-linux-gnu
         ./y.sh clean all
@@ -102,7 +102,7 @@ jobs:
 
     - name: Run tests
       run: |
-        ./y.sh test --target-triple m68k-unknown-linux-gnu --release --clean --build-sysroot --sysroot-features compiler_builtins/no-f16-f128 ${{ matrix.commands }}
+        ./y.sh test --target-triple m68k-unknown-linux-gnu --release --clean --build-sysroot --sysroot-features compiler-builtins-no-f16-f128 ${{ matrix.commands }}
 
     - name: Run Hello World!
       run: |
-- 
cgit 1.4.1-3-g733a5


From b0ab2bf68efae0b1ccaa2a1ed643083d94756bae Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Sun, 13 Jul 2025 16:14:50 -0400
Subject: Fix LTO test

---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 1d8eaf9a141..b0c552751e3 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -78,7 +78,7 @@ jobs:
     - name: Run tests
       run: |
         # FIXME(antoyo): we cannot enable LTO for stdarch tests currently because of some failing LTO tests using proc-macros.
-        echo -n 'lto = "fat"' >> build_system/build_sysroot/Cargo.toml
+        printf '[profile.release]\nlto = "fat"\n' >> build/build_sysroot/sysroot_src/library/sysroot/Cargo.toml
         EMBED_LTO_BITCODE=1 ./y.sh test --release --clean --release-sysroot --build-sysroot --keep-lto-tests ${{ matrix.commands }}
 
     - name: Run y.sh cargo build
-- 
cgit 1.4.1-3-g733a5


From 6760cd2859db68d47d62089d9805d860fb37d518 Mon Sep 17 00:00:00 2001
From: René Kijewski <rene.kijewski@fu-berlin.de>
Date: Sun, 13 Jul 2025 22:33:49 +0200
Subject: core: make `str::split_at_unchecked()` inline

This PR adds `#[inline]` to the method `str::split_at_unchecked()`.
This is done for two reasons:

1. The method is tiny, e.g. on AMD-64 (<https://godbolt.org/z/ba68fdfxn>):

   ```asm
   movq    %rdi, %rax
   subq    %rcx, %rdx
   movq    %rsi, (%rdi)
   addq    %rcx, %rsi
   movq    %rcx, 8(%rdi)
   movq    %rsi, 16(%rdi)
   movq    %rdx, 24(%rdi)
   retq
   ```

2. More importantly, inlining the method enables further automatic
   optimizations. E.g. if you split at index 3, then in the compiler
   (rustc, llvm or both) knows that this code cannot fail, and the
   panicking path is omitted in the generated code:

   ```rust
   pub fn punctuation(i: &str) -> Result<(), ()> {
       const THREE_CHARS: &[[u8; 3]] = &[*b"<<=", *b">>=", *b"...", *b"..="];

       if let Some((head, _)) = i.split_at_checked(3)
           && THREE_CHARS.contains(&head.as_bytes().try_into().unwrap())
       {
           Ok(())
       } else {
           Err(())
       }
   }
   ```

   <details>
   <summary>Without PR</summary>

   <https://play.rust-lang.org/?version=stable&mode=release&edition=2024&gist=0234de8158f467eebd73286f20d6e27a>

   ```asm
   playground::punctuation:
           subq    $40, %rsp
           movq    %rsi, %rdx
           movq    %rdi, %rsi
           movb    $1, %al
           cmpq    $3, %rdx
           ja      .LBB2_2
           je      .LBB2_3
   .LBB2_11:
           addq    $40, %rsp
           retq
   .LBB2_2:
           cmpb    $-64, 3(%rsi)
           jl      .LBB2_11
   .LBB2_3:
           leaq    8(%rsp), %rdi
           movl    $3, %ecx
           callq   *core::str::<impl str>::split_at_unchecked@GOTPCREL(%rip)
           movq    8(%rsp), %rcx
           movb    $1, %al
           testq   %rcx, %rcx
           je      .LBB2_11
           cmpq    $3, 16(%rsp)
           jne     .LBB2_12
           movzwl  (%rcx), %edx
           movzbl  2(%rcx), %ecx
           shll    $16, %ecx
           orl     %edx, %ecx
           cmpl    $4013115, %ecx
           jg      .LBB2_8
           cmpl    $3026478, %ecx
           je      .LBB2_10
           cmpl    $4009518, %ecx
           je      .LBB2_10
           jmp     .LBB2_11
   .LBB2_8:
           cmpl    $4013630, %ecx
           je      .LBB2_10
           cmpl    $4013116, %ecx
           jne     .LBB2_11
   .LBB2_10:
           xorl    %eax, %eax
           addq    $40, %rsp
           retq
   .LBB2_12:
           leaq    .Lanon.d98a7fbb86d10a97c24516e267466134.2(%rip), %rdi
           leaq    .Lanon.d98a7fbb86d10a97c24516e267466134.1(%rip), %rcx
           leaq    .Lanon.d98a7fbb86d10a97c24516e267466134.6(%rip), %r8
           leaq    7(%rsp), %rdx
           movl    $43, %esi
           callq   *core::result::unwrap_failed@GOTPCREL(%rip)
   ```
   </details>

   <details>
   <summary>With PR</summary>

   <https://play.rust-lang.org/?version=stable&mode=release&edition=2024&gist=5d4058c79ce0f6cb1a434190427d2055>

   ```asm
   playground::punctuation:
           movb    $1, %al
           cmpq    $3, %rsi
           ja      .LBB0_2
           je      .LBB0_3
   .LBB0_9:
           retq
   .LBB0_2:
           cmpb    $-64, 3(%rdi)
           jl      .LBB0_9
   .LBB0_3:
           movzwl  (%rdi), %eax
           movzbl  2(%rdi), %ecx
           shll    $16, %ecx
           orl     %eax, %ecx
           movb    $1, %al
           cmpl    $4013115, %ecx
           jg      .LBB0_6
           cmpl    $3026478, %ecx
           je      .LBB0_8
           cmpl    $4009518, %ecx
           je      .LBB0_8
           jmp     .LBB0_9
   .LBB0_6:
           cmpl    $4013630, %ecx
           je      .LBB0_8
           cmpl    $4013116, %ecx
           jne     .LBB0_9
   .LBB0_8:
           xorl    %eax, %eax
           retq
   ```
   </details>
---
 library/core/src/str/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index 32a22988175..b1ce643e87c 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -952,6 +952,7 @@ impl str {
     ///
     /// The caller must ensure that `mid` is a valid byte offset from the start
     /// of the string and falls on the boundary of a UTF-8 code point.
+    #[inline]
     const unsafe fn split_at_unchecked(&self, mid: usize) -> (&str, &str) {
         let len = self.len();
         let ptr = self.as_ptr();
-- 
cgit 1.4.1-3-g733a5


From b7d024b05622702df0b8f0eb7d67c9e7b534b9ea Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Mon, 14 Jul 2025 02:18:24 +0500
Subject: moved tests

---
 tests/ui/darwin-ld64.rs                            | 24 -------------
 .../ui/deduplicate-diagnostics.deduplicate.stderr  | 15 ---------
 tests/ui/deduplicate-diagnostics.duplicate.stderr  | 39 ----------------------
 tests/ui/deduplicate-diagnostics.rs                | 11 ------
 .../deduplicate-diagnostics.deduplicate.stderr     | 15 +++++++++
 .../deduplicate-diagnostics.duplicate.stderr       | 39 ++++++++++++++++++++++
 .../ui/diagnostic-flags/deduplicate-diagnostics.rs | 11 ++++++
 tests/ui/fmt/println-debug-different-types.rs      | 13 ++++++++
 tests/ui/lexical-scopes.rs                         | 13 --------
 tests/ui/lexical-scopes.stderr                     | 22 ------------
 tests/ui/linking/ld64-cross-compilation.rs         | 24 +++++++++++++
 tests/ui/log-poly.rs                               | 13 --------
 tests/ui/shadowed/shadowing-generic-item.rs        | 13 ++++++++
 tests/ui/shadowed/shadowing-generic-item.stderr    | 22 ++++++++++++
 tests/ui/struct-ctor-mangling.rs                   | 14 --------
 .../ui/symbol-names/struct-constructor-mangling.rs | 14 ++++++++
 16 files changed, 151 insertions(+), 151 deletions(-)
 delete mode 100644 tests/ui/darwin-ld64.rs
 delete mode 100644 tests/ui/deduplicate-diagnostics.deduplicate.stderr
 delete mode 100644 tests/ui/deduplicate-diagnostics.duplicate.stderr
 delete mode 100644 tests/ui/deduplicate-diagnostics.rs
 create mode 100644 tests/ui/diagnostic-flags/deduplicate-diagnostics.deduplicate.stderr
 create mode 100644 tests/ui/diagnostic-flags/deduplicate-diagnostics.duplicate.stderr
 create mode 100644 tests/ui/diagnostic-flags/deduplicate-diagnostics.rs
 create mode 100644 tests/ui/fmt/println-debug-different-types.rs
 delete mode 100644 tests/ui/lexical-scopes.rs
 delete mode 100644 tests/ui/lexical-scopes.stderr
 create mode 100644 tests/ui/linking/ld64-cross-compilation.rs
 delete mode 100644 tests/ui/log-poly.rs
 create mode 100644 tests/ui/shadowed/shadowing-generic-item.rs
 create mode 100644 tests/ui/shadowed/shadowing-generic-item.stderr
 delete mode 100644 tests/ui/struct-ctor-mangling.rs
 create mode 100644 tests/ui/symbol-names/struct-constructor-mangling.rs

diff --git a/tests/ui/darwin-ld64.rs b/tests/ui/darwin-ld64.rs
deleted file mode 100644
index 75acc07a002..00000000000
--- a/tests/ui/darwin-ld64.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Ccodegen-units=256 -Clink-arg=-ld_classic
-//@ run-pass
-//@ only-x86_64-apple-darwin
-
-// This is a regression test for https://github.com/rust-lang/rust/issues/140686.
-// Although this is a ld64(ld-classic) bug, we still need to support it
-// due to cross-compilation and support for older Xcode.
-
-fn main() {
-    let dst: Vec<u8> = Vec::new();
-    let len = broken_func(std::hint::black_box(2), dst);
-    assert_eq!(len, 8);
-}
-
-#[inline(never)]
-pub fn broken_func(version: usize, mut dst: Vec<u8>) -> usize {
-    match version {
-        1 => dst.extend_from_slice(b"aaaaaaaa"),
-        2 => dst.extend_from_slice(b"bbbbbbbb"),
-        3 => dst.extend_from_slice(b"bbbbbbbb"),
-        _ => panic!(),
-    }
-    dst.len()
-}
diff --git a/tests/ui/deduplicate-diagnostics.deduplicate.stderr b/tests/ui/deduplicate-diagnostics.deduplicate.stderr
deleted file mode 100644
index 5df2c687bdd..00000000000
--- a/tests/ui/deduplicate-diagnostics.deduplicate.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0452]: malformed lint attribute input
-  --> $DIR/deduplicate-diagnostics.rs:8:8
-   |
-LL | #[deny("literal")]
-   |        ^^^^^^^^^ bad attribute argument
-
-error: cannot find derive macro `Unresolved` in this scope
-  --> $DIR/deduplicate-diagnostics.rs:4:10
-   |
-LL | #[derive(Unresolved)]
-   |          ^^^^^^^^^^
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0452`.
diff --git a/tests/ui/deduplicate-diagnostics.duplicate.stderr b/tests/ui/deduplicate-diagnostics.duplicate.stderr
deleted file mode 100644
index 48e2ba7b86a..00000000000
--- a/tests/ui/deduplicate-diagnostics.duplicate.stderr
+++ /dev/null
@@ -1,39 +0,0 @@
-error[E0452]: malformed lint attribute input
-  --> $DIR/deduplicate-diagnostics.rs:8:8
-   |
-LL | #[deny("literal")]
-   |        ^^^^^^^^^ bad attribute argument
-
-error: cannot find derive macro `Unresolved` in this scope
-  --> $DIR/deduplicate-diagnostics.rs:4:10
-   |
-LL | #[derive(Unresolved)]
-   |          ^^^^^^^^^^
-
-error: cannot find derive macro `Unresolved` in this scope
-  --> $DIR/deduplicate-diagnostics.rs:4:10
-   |
-LL | #[derive(Unresolved)]
-   |          ^^^^^^^^^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0452]: malformed lint attribute input
-  --> $DIR/deduplicate-diagnostics.rs:8:8
-   |
-LL | #[deny("literal")]
-   |        ^^^^^^^^^ bad attribute argument
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0452]: malformed lint attribute input
-  --> $DIR/deduplicate-diagnostics.rs:8:8
-   |
-LL | #[deny("literal")]
-   |        ^^^^^^^^^ bad attribute argument
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 5 previous errors
-
-For more information about this error, try `rustc --explain E0452`.
diff --git a/tests/ui/deduplicate-diagnostics.rs b/tests/ui/deduplicate-diagnostics.rs
deleted file mode 100644
index 299c1f5f461..00000000000
--- a/tests/ui/deduplicate-diagnostics.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ revisions: duplicate deduplicate
-//@[deduplicate] compile-flags: -Z deduplicate-diagnostics=yes
-
-#[derive(Unresolved)] //~ ERROR cannot find derive macro `Unresolved` in this scope
-                      //[duplicate]~| ERROR cannot find derive macro `Unresolved` in this scope
-struct S;
-
-#[deny("literal")] //~ ERROR malformed lint attribute input
-                   //[duplicate]~| ERROR malformed lint attribute input
-                   //[duplicate]~| ERROR malformed lint attribute input
-fn main() {}
diff --git a/tests/ui/diagnostic-flags/deduplicate-diagnostics.deduplicate.stderr b/tests/ui/diagnostic-flags/deduplicate-diagnostics.deduplicate.stderr
new file mode 100644
index 00000000000..5df2c687bdd
--- /dev/null
+++ b/tests/ui/diagnostic-flags/deduplicate-diagnostics.deduplicate.stderr
@@ -0,0 +1,15 @@
+error[E0452]: malformed lint attribute input
+  --> $DIR/deduplicate-diagnostics.rs:8:8
+   |
+LL | #[deny("literal")]
+   |        ^^^^^^^^^ bad attribute argument
+
+error: cannot find derive macro `Unresolved` in this scope
+  --> $DIR/deduplicate-diagnostics.rs:4:10
+   |
+LL | #[derive(Unresolved)]
+   |          ^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0452`.
diff --git a/tests/ui/diagnostic-flags/deduplicate-diagnostics.duplicate.stderr b/tests/ui/diagnostic-flags/deduplicate-diagnostics.duplicate.stderr
new file mode 100644
index 00000000000..48e2ba7b86a
--- /dev/null
+++ b/tests/ui/diagnostic-flags/deduplicate-diagnostics.duplicate.stderr
@@ -0,0 +1,39 @@
+error[E0452]: malformed lint attribute input
+  --> $DIR/deduplicate-diagnostics.rs:8:8
+   |
+LL | #[deny("literal")]
+   |        ^^^^^^^^^ bad attribute argument
+
+error: cannot find derive macro `Unresolved` in this scope
+  --> $DIR/deduplicate-diagnostics.rs:4:10
+   |
+LL | #[derive(Unresolved)]
+   |          ^^^^^^^^^^
+
+error: cannot find derive macro `Unresolved` in this scope
+  --> $DIR/deduplicate-diagnostics.rs:4:10
+   |
+LL | #[derive(Unresolved)]
+   |          ^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0452]: malformed lint attribute input
+  --> $DIR/deduplicate-diagnostics.rs:8:8
+   |
+LL | #[deny("literal")]
+   |        ^^^^^^^^^ bad attribute argument
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0452]: malformed lint attribute input
+  --> $DIR/deduplicate-diagnostics.rs:8:8
+   |
+LL | #[deny("literal")]
+   |        ^^^^^^^^^ bad attribute argument
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0452`.
diff --git a/tests/ui/diagnostic-flags/deduplicate-diagnostics.rs b/tests/ui/diagnostic-flags/deduplicate-diagnostics.rs
new file mode 100644
index 00000000000..299c1f5f461
--- /dev/null
+++ b/tests/ui/diagnostic-flags/deduplicate-diagnostics.rs
@@ -0,0 +1,11 @@
+//@ revisions: duplicate deduplicate
+//@[deduplicate] compile-flags: -Z deduplicate-diagnostics=yes
+
+#[derive(Unresolved)] //~ ERROR cannot find derive macro `Unresolved` in this scope
+                      //[duplicate]~| ERROR cannot find derive macro `Unresolved` in this scope
+struct S;
+
+#[deny("literal")] //~ ERROR malformed lint attribute input
+                   //[duplicate]~| ERROR malformed lint attribute input
+                   //[duplicate]~| ERROR malformed lint attribute input
+fn main() {}
diff --git a/tests/ui/fmt/println-debug-different-types.rs b/tests/ui/fmt/println-debug-different-types.rs
new file mode 100644
index 00000000000..64994a55817
--- /dev/null
+++ b/tests/ui/fmt/println-debug-different-types.rs
@@ -0,0 +1,13 @@
+//@ run-pass
+
+#[derive(Debug)]
+enum Numbers {
+    Three
+}
+
+pub fn main() {
+    println!("{:?}", 1);
+    println!("{:?}", 2.0f64);
+    println!("{:?}", Numbers::Three);
+    println!("{:?}", vec![4]);
+}
diff --git a/tests/ui/lexical-scopes.rs b/tests/ui/lexical-scopes.rs
deleted file mode 100644
index 46cfdf1efa8..00000000000
--- a/tests/ui/lexical-scopes.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-struct T { i: i32 }
-fn f<T>() {
-    let t = T { i: 0 }; //~ ERROR expected struct, variant or union type, found type parameter `T`
-}
-
-mod Foo {
-    pub fn f() {}
-}
-fn g<Foo>() {
-    Foo::f(); //~ ERROR no function or associated item named `f`
-}
-
-fn main() {}
diff --git a/tests/ui/lexical-scopes.stderr b/tests/ui/lexical-scopes.stderr
deleted file mode 100644
index f0eaa1a5c64..00000000000
--- a/tests/ui/lexical-scopes.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error[E0574]: expected struct, variant or union type, found type parameter `T`
-  --> $DIR/lexical-scopes.rs:3:13
-   |
-LL | struct T { i: i32 }
-   |        - you might have meant to refer to this struct
-LL | fn f<T>() {
-   |      - found this type parameter
-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
-  --> $DIR/lexical-scopes.rs:10:10
-   |
-LL | fn g<Foo>() {
-   |      --- function or associated item `f` not found for this type parameter
-LL |     Foo::f();
-   |          ^ function or associated item not found in `Foo`
-
-error: aborting due to 2 previous errors
-
-Some errors have detailed explanations: E0574, E0599.
-For more information about an error, try `rustc --explain E0574`.
diff --git a/tests/ui/linking/ld64-cross-compilation.rs b/tests/ui/linking/ld64-cross-compilation.rs
new file mode 100644
index 00000000000..75acc07a002
--- /dev/null
+++ b/tests/ui/linking/ld64-cross-compilation.rs
@@ -0,0 +1,24 @@
+//@ compile-flags: -Copt-level=3 -Ccodegen-units=256 -Clink-arg=-ld_classic
+//@ run-pass
+//@ only-x86_64-apple-darwin
+
+// This is a regression test for https://github.com/rust-lang/rust/issues/140686.
+// Although this is a ld64(ld-classic) bug, we still need to support it
+// due to cross-compilation and support for older Xcode.
+
+fn main() {
+    let dst: Vec<u8> = Vec::new();
+    let len = broken_func(std::hint::black_box(2), dst);
+    assert_eq!(len, 8);
+}
+
+#[inline(never)]
+pub fn broken_func(version: usize, mut dst: Vec<u8>) -> usize {
+    match version {
+        1 => dst.extend_from_slice(b"aaaaaaaa"),
+        2 => dst.extend_from_slice(b"bbbbbbbb"),
+        3 => dst.extend_from_slice(b"bbbbbbbb"),
+        _ => panic!(),
+    }
+    dst.len()
+}
diff --git a/tests/ui/log-poly.rs b/tests/ui/log-poly.rs
deleted file mode 100644
index 64994a55817..00000000000
--- a/tests/ui/log-poly.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ run-pass
-
-#[derive(Debug)]
-enum Numbers {
-    Three
-}
-
-pub fn main() {
-    println!("{:?}", 1);
-    println!("{:?}", 2.0f64);
-    println!("{:?}", Numbers::Three);
-    println!("{:?}", vec![4]);
-}
diff --git a/tests/ui/shadowed/shadowing-generic-item.rs b/tests/ui/shadowed/shadowing-generic-item.rs
new file mode 100644
index 00000000000..46cfdf1efa8
--- /dev/null
+++ b/tests/ui/shadowed/shadowing-generic-item.rs
@@ -0,0 +1,13 @@
+struct T { i: i32 }
+fn f<T>() {
+    let t = T { i: 0 }; //~ ERROR expected struct, variant or union type, found type parameter `T`
+}
+
+mod Foo {
+    pub fn f() {}
+}
+fn g<Foo>() {
+    Foo::f(); //~ ERROR no function or associated item named `f`
+}
+
+fn main() {}
diff --git a/tests/ui/shadowed/shadowing-generic-item.stderr b/tests/ui/shadowed/shadowing-generic-item.stderr
new file mode 100644
index 00000000000..f0eaa1a5c64
--- /dev/null
+++ b/tests/ui/shadowed/shadowing-generic-item.stderr
@@ -0,0 +1,22 @@
+error[E0574]: expected struct, variant or union type, found type parameter `T`
+  --> $DIR/lexical-scopes.rs:3:13
+   |
+LL | struct T { i: i32 }
+   |        - you might have meant to refer to this struct
+LL | fn f<T>() {
+   |      - found this type parameter
+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
+  --> $DIR/lexical-scopes.rs:10:10
+   |
+LL | fn g<Foo>() {
+   |      --- function or associated item `f` not found for this type parameter
+LL |     Foo::f();
+   |          ^ function or associated item not found in `Foo`
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0574, E0599.
+For more information about an error, try `rustc --explain E0574`.
diff --git a/tests/ui/struct-ctor-mangling.rs b/tests/ui/struct-ctor-mangling.rs
deleted file mode 100644
index f32cbb7aaae..00000000000
--- a/tests/ui/struct-ctor-mangling.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ run-pass
-
-fn size_of_val<T>(_: &T) -> usize {
-    std::mem::size_of::<T>()
-}
-
-struct Foo(#[allow(dead_code)] i64);
-
-// Test that the (symbol) mangling of `Foo` (the `struct` type) and that of
-// `typeof Foo` (the function type of the `struct` constructor) don't collide.
-fn main() {
-    size_of_val(&Foo(0));
-    size_of_val(&Foo);
-}
diff --git a/tests/ui/symbol-names/struct-constructor-mangling.rs b/tests/ui/symbol-names/struct-constructor-mangling.rs
new file mode 100644
index 00000000000..f32cbb7aaae
--- /dev/null
+++ b/tests/ui/symbol-names/struct-constructor-mangling.rs
@@ -0,0 +1,14 @@
+//@ run-pass
+
+fn size_of_val<T>(_: &T) -> usize {
+    std::mem::size_of::<T>()
+}
+
+struct Foo(#[allow(dead_code)] i64);
+
+// Test that the (symbol) mangling of `Foo` (the `struct` type) and that of
+// `typeof Foo` (the function type of the `struct` constructor) don't collide.
+fn main() {
+    size_of_val(&Foo(0));
+    size_of_val(&Foo);
+}
-- 
cgit 1.4.1-3-g733a5


From f5485e55644cea6395fb2196b915dee1b48f6427 Mon Sep 17 00:00:00 2001
From: Nik Revenco <pm@nikrev.com>
Date: Sun, 13 Jul 2025 23:24:27 +0100
Subject: docs(alloc::fmt): Make `type` optional, instead of matching the empty
 string

---
 library/alloc/src/fmt.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/alloc/src/fmt.rs b/library/alloc/src/fmt.rs
index 30f42050ac8..d0ba9c39886 100644
--- a/library/alloc/src/fmt.rs
+++ b/library/alloc/src/fmt.rs
@@ -348,13 +348,13 @@
 //! format := '{' [ argument ] [ ':' format_spec ] [ ws ] * '}'
 //! argument := integer | identifier
 //!
-//! format_spec := [[fill]align][sign]['#']['0'][width]['.' precision]type
+//! format_spec := [[fill]align][sign]['#']['0'][width]['.' precision][type]
 //! fill := character
 //! align := '<' | '^' | '>'
 //! sign := '+' | '-'
 //! width := count
 //! precision := count | '*'
-//! type := '' | '?' | 'x?' | 'X?' | identifier
+//! type := '?' | 'x?' | 'X?' | identifier
 //! count := parameter | integer
 //! parameter := argument '$'
 //! ```
-- 
cgit 1.4.1-3-g733a5


From dbeb05cd2addf012e6c1e1ddea00a5e6fb8ca609 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Mon, 14 Jul 2025 05:00:14 +0000
Subject: Preparing for merge from rustc

---
 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 0af6b8c6fc7..adf3f7389c6 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-32cd9114712a24010b0583624dc52ac302194128
+9c3064e131f4939cc95a29bb11413c49bbda1491
-- 
cgit 1.4.1-3-g733a5


From 500b743f7ef8e38a0ad6154493a84c53e06ea888 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Sun, 13 Jul 2025 12:11:37 +0200
Subject: tests: Test line debuginfo for linebreaked function parameters

---
 .../fn-parameters-on-different-lines-debuginfo.rs  | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 tests/codegen/fn-parameters-on-different-lines-debuginfo.rs

diff --git a/tests/codegen/fn-parameters-on-different-lines-debuginfo.rs b/tests/codegen/fn-parameters-on-different-lines-debuginfo.rs
new file mode 100644
index 00000000000..2097567f322
--- /dev/null
+++ b/tests/codegen/fn-parameters-on-different-lines-debuginfo.rs
@@ -0,0 +1,22 @@
+//! Make sure that line debuginfo of function parameters are correct even if
+//! they are not on the same line. Regression test for
+// <https://github.com/rust-lang/rust/issues/45010>.
+
+//@ compile-flags: -g -Copt-level=0
+
+#[rustfmt::skip] // Having parameters on different lines is crucial for this test.
+pub fn foo(
+    x_parameter_not_in_std: i32,
+    y_parameter_not_in_std: i32,
+) -> i32 {
+    x_parameter_not_in_std + y_parameter_not_in_std
+}
+
+fn main() {
+    foo(42, 43); // Ensure `wasm32-wasip1` keeps `foo()` (even if `-Copt-level=0`)
+}
+
+// CHECK: !DILocalVariable(name: "x_parameter_not_in_std", arg: 1,
+// CHECK-SAME: line: 9
+// CHECK: !DILocalVariable(name: "y_parameter_not_in_std", arg: 2,
+// CHECK-SAME: line: 10
-- 
cgit 1.4.1-3-g733a5


From 1cac8cbde98e7b15ad24fc96af4864cdd67b9c30 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Mon, 14 Jul 2025 03:39:24 +0800
Subject: Add test array-type-no-semi.rs

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 tests/ui/parser/recover/array-type-no-semi.rs     | 18 ++++++++
 tests/ui/parser/recover/array-type-no-semi.stderr | 56 +++++++++++++++++++++++
 2 files changed, 74 insertions(+)
 create mode 100644 tests/ui/parser/recover/array-type-no-semi.rs
 create mode 100644 tests/ui/parser/recover/array-type-no-semi.stderr

diff --git a/tests/ui/parser/recover/array-type-no-semi.rs b/tests/ui/parser/recover/array-type-no-semi.rs
new file mode 100644
index 00000000000..ae5efbaf36c
--- /dev/null
+++ b/tests/ui/parser/recover/array-type-no-semi.rs
@@ -0,0 +1,18 @@
+// when the next token is not a semicolon,
+// we should suggest to use semicolon if recovery is allowed
+// See issue #143828
+
+fn main() {
+    let x = 5;
+    let b: [i32, 5];
+    //~^ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
+    //~| ERROR expected value, found builtin type `i32` [E0423]
+    let a: [i32, ];
+    //~^ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
+    //~| ERROR expected value, found builtin type `i32` [E0423]
+    let c: [i32, x];
+    //~^ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
+    //~| ERROR expected value, found builtin type `i32` [E0423]
+    let e: [i32 5];
+    //~^ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `5`
+}
diff --git a/tests/ui/parser/recover/array-type-no-semi.stderr b/tests/ui/parser/recover/array-type-no-semi.stderr
new file mode 100644
index 00000000000..84b7282b4fe
--- /dev/null
+++ b/tests/ui/parser/recover/array-type-no-semi.stderr
@@ -0,0 +1,56 @@
+error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
+  --> $DIR/array-type-no-semi.rs:7:16
+   |
+LL |     let b: [i32, 5];
+   |          -     ^ expected one of 7 possible tokens
+   |          |
+   |          while parsing the type for `b`
+   |          help: use `=` if you meant to assign
+
+error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
+  --> $DIR/array-type-no-semi.rs:10:16
+   |
+LL |     let a: [i32, ];
+   |          -     ^ expected one of 7 possible tokens
+   |          |
+   |          while parsing the type for `a`
+   |          help: use `=` if you meant to assign
+
+error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
+  --> $DIR/array-type-no-semi.rs:13:16
+   |
+LL |     let c: [i32, x];
+   |          -     ^ expected one of 7 possible tokens
+   |          |
+   |          while parsing the type for `c`
+   |          help: use `=` if you meant to assign
+
+error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `5`
+  --> $DIR/array-type-no-semi.rs:16:17
+   |
+LL |     let e: [i32 5];
+   |          -      ^ expected one of 7 possible tokens
+   |          |
+   |          while parsing the type for `e`
+
+error[E0423]: expected value, found builtin type `i32`
+  --> $DIR/array-type-no-semi.rs:7:13
+   |
+LL |     let b: [i32, 5];
+   |             ^^^ not a value
+
+error[E0423]: expected value, found builtin type `i32`
+  --> $DIR/array-type-no-semi.rs:10:13
+   |
+LL |     let a: [i32, ];
+   |             ^^^ not a value
+
+error[E0423]: expected value, found builtin type `i32`
+  --> $DIR/array-type-no-semi.rs:13:13
+   |
+LL |     let c: [i32, x];
+   |             ^^^ not a value
+
+error: aborting due to 7 previous errors
+
+For more information about this error, try `rustc --explain E0423`.
-- 
cgit 1.4.1-3-g733a5


From 937ef9381c45e9cad5fc31bdc85224b7f6e13df1 Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Thu, 10 Jul 2025 14:33:32 +0200
Subject: Bootstrap's `tool.TOOL_NAME.features` now works on any subcommand

---
 src/bootstrap/src/core/build_steps/tool.rs | 30 +++++++++++++++---------------
 src/bootstrap/src/utils/change_tracker.rs  |  5 +++++
 2 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 5de1b472d79..e3a0ab212a3 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -136,19 +136,6 @@ impl Step for ToolBuild {
             _ => panic!("unexpected Mode for tool build"),
         }
 
-        // build.tool.TOOL_NAME.features in bootstrap.toml allows specifying which features to
-        // enable for a specific tool. `extra_features` instead is not controlled by the toml and
-        // provides features that are always enabled for a specific tool (e.g. "in-rust-tree" for
-        // rust-analyzer). Finally, `prepare_tool_cargo` might add more features to adapt the build
-        // to the chosen flags (e.g. "all-static" for cargo if `cargo_native_static` is true).
-        let mut features = builder
-            .config
-            .tool
-            .get(self.tool)
-            .and_then(|tool| tool.features.clone())
-            .unwrap_or_default();
-        features.extend(self.extra_features.clone());
-
         let mut cargo = prepare_tool_cargo(
             builder,
             self.compiler,
@@ -157,7 +144,7 @@ impl Step for ToolBuild {
             Kind::Build,
             path,
             self.source_type,
-            &features,
+            &self.extra_features,
         );
 
         // The stage0 compiler changes infrequently and does not directly depend on code
@@ -244,7 +231,8 @@ pub fn prepare_tool_cargo(
 ) -> CargoCommand {
     let mut cargo = builder::Cargo::new(builder, compiler, mode, source_type, target, cmd_kind);
 
-    let dir = builder.src.join(path);
+    let path = PathBuf::from(path);
+    let dir = builder.src.join(&path);
     cargo.arg("--manifest-path").arg(dir.join("Cargo.toml"));
 
     let mut features = extra_features.to_vec();
@@ -261,6 +249,18 @@ pub fn prepare_tool_cargo(
         }
     }
 
+    // build.tool.TOOL_NAME.features in bootstrap.toml allows specifying which features to enable
+    // for a specific tool. `extra_features` instead is not controlled by the toml and provides
+    // features that are always enabled for a specific tool (e.g. "in-rust-tree" for rust-analyzer).
+    // Finally, `prepare_tool_cargo` above here might add more features to adapt the build
+    // to the chosen flags (e.g. "all-static" for cargo if `cargo_native_static` is true).
+    builder
+        .config
+        .tool
+        .iter()
+        .filter(|(tool_name, _)| path.ends_with(tool_name))
+        .for_each(|(_, tool)| features.extend(tool.features.clone().unwrap_or_default()));
+
     // clippy tests need to know about the stage sysroot. Set them consistently while building to
     // avoid rebuilding when running tests.
     cargo.env("SYSROOT", builder.sysroot(compiler));
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index c5d460ac55b..1f6ed8129da 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -471,4 +471,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Info,
         summary: "A --compile-time-deps flag has been added to reduce the time it takes rust-analyzer to start",
     },
+    ChangeInfo {
+        change_id: 143733,
+        severity: ChangeSeverity::Info,
+        summary: "Option `tool.TOOL_NAME.features` now works on any subcommand, not just `build`.",
+    },
 ];
-- 
cgit 1.4.1-3-g733a5


From b3ed03529fe7c846c6a7e6ef7382439a0ce4247e Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Sun, 13 Jul 2025 08:46:49 +0200
Subject: Only compare tool name to apply features to

---
 src/bootstrap/src/core/build_steps/tool.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index e3a0ab212a3..8271be1675f 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -9,6 +9,7 @@
 //! Each Rust tool **MUST** utilize `ToolBuild` inside their `Step` logic,
 //! return `ToolBuildResult` and should never prepare `cargo` invocations manually.
 
+use std::ffi::OsStr;
 use std::path::PathBuf;
 use std::{env, fs};
 
@@ -258,7 +259,7 @@ pub fn prepare_tool_cargo(
         .config
         .tool
         .iter()
-        .filter(|(tool_name, _)| path.ends_with(tool_name))
+        .filter(|(tool_name, _)| path.file_name().and_then(OsStr::to_str) == Some(tool_name))
         .for_each(|(_, tool)| features.extend(tool.features.clone().unwrap_or_default()));
 
     // clippy tests need to know about the stage sysroot. Set them consistently while building to
-- 
cgit 1.4.1-3-g733a5


From 940aa204086ad4efa3b5151b1363610c9ccf28d9 Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Sun, 13 Jul 2025 08:47:38 +0200
Subject: Add comment about features not part of "extra-features"

---
 bootstrap.example.toml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/bootstrap.example.toml b/bootstrap.example.toml
index b59f112bdfb..73e93ccbe42 100644
--- a/bootstrap.example.toml
+++ b/bootstrap.example.toml
@@ -392,7 +392,8 @@
 # For example, to build Miri with tracing support, use `tool.miri.features = ["tracing"]`
 #
 # The default value for the `features` array is `[]`. However, please note that other flags in
-# `bootstrap.toml` might influence the features enabled for some tools.
+# `bootstrap.toml` might influence the features enabled for some tools. Also, enabling features
+# in tools which are not part of the internal "extra-features" preset might not always work.
 #build.tool.TOOL_NAME.features = [FEATURE1, FEATURE2]
 
 # Verbosity level: 0 == not verbose, 1 == verbose, 2 == very verbose, 3 == print environment variables on each rustc invocation
-- 
cgit 1.4.1-3-g733a5


From 6080c75d6293c3271c9f0b419e17e67fc57b7b02 Mon Sep 17 00:00:00 2001
From: "Tim (Theemathas) Chirananthavat" <theemathas@gmail.com>
Date: Mon, 14 Jul 2025 15:01:58 +0700
Subject: Change "allocated object" to "allocation".

These seem like they were missed in <https://github.com/rust-lang/rust/pull/141224>
---
 library/core/src/intrinsics/mod.rs  | 2 +-
 library/core/src/ptr/docs/add.md    | 2 +-
 library/core/src/ptr/docs/offset.md | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index c2e4b751c65..1ece3d9bd5e 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -910,7 +910,7 @@ pub const unsafe fn arith_offset<T>(dst: *const T, offset: isize) -> *const T;
 /// # Safety
 ///
 /// - `index < PtrMetadata(slice_ptr)`, so the indexing is in-bounds for the slice
-/// - the resulting offsetting is in-bounds of the allocated object, which is
+/// - the resulting offsetting is in-bounds of the allocation, which is
 ///   always the case for references, but needs to be upheld manually for pointers
 #[rustc_nounwind]
 #[rustc_intrinsic]
diff --git a/library/core/src/ptr/docs/add.md b/library/core/src/ptr/docs/add.md
index ae7c7785684..6e2e87f5f81 100644
--- a/library/core/src/ptr/docs/add.md
+++ b/library/core/src/ptr/docs/add.md
@@ -19,7 +19,7 @@ If any of the following conditions are violated, the result is Undefined Behavio
 bounds of that allocation. In particular, this range must not "wrap around" the edge
 of the address space.
 
-Allocated objects can never be larger than `isize::MAX` bytes, so if the computed offset
+Allocations can never be larger than `isize::MAX` bytes, so if the computed offset
 stays in bounds of the allocation, it is guaranteed to satisfy the first requirement.
 This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always
 safe.
diff --git a/library/core/src/ptr/docs/offset.md b/library/core/src/ptr/docs/offset.md
index f2e335a79a5..f04f5606ab2 100644
--- a/library/core/src/ptr/docs/offset.md
+++ b/library/core/src/ptr/docs/offset.md
@@ -16,7 +16,7 @@ bounds of that allocation. In particular, this range must not "wrap around" the
 of the address space. Note that "range" here refers to a half-open range as usual in Rust,
 i.e., `self..result` for non-negative offsets and `result..self` for negative offsets.
 
-Allocated objects can never be larger than `isize::MAX` bytes, so if the computed offset
+Allocations can never be larger than `isize::MAX` bytes, so if the computed offset
 stays in bounds of the allocation, it is guaranteed to satisfy the first requirement.
 This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always
 safe.
-- 
cgit 1.4.1-3-g733a5


From 90660f4d5068772bf48340a871be9b7a20a06419 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Mon, 14 Jul 2025 08:19:58 +0000
Subject: tiercheck: clippy fixes

---
 src/tools/tier-check/src/main.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/tools/tier-check/src/main.rs b/src/tools/tier-check/src/main.rs
index 91b96117db0..6c27a2ec442 100644
--- a/src/tools/tier-check/src/main.rs
+++ b/src/tools/tier-check/src/main.rs
@@ -25,29 +25,27 @@ fn main() {
     let doc_targets: HashSet<_> = doc_targets_md
         .lines()
         .filter(|line| line.starts_with(&['`', '['][..]) && line.contains('|'))
-        .map(|line| line.split('`').skip(1).next().expect("expected target code span"))
+        .map(|line| line.split('`').nth(1).expect("expected target code span"))
         .collect();
 
     let missing: Vec<_> = target_list.difference(&doc_targets).collect();
     let extra: Vec<_> = doc_targets.difference(&target_list).collect();
     for target in &missing {
         eprintln!(
-            "error: target `{}` is missing from {}\n\
-            If this is a new target, please add it to {}.",
-            target, filename, src
+            "error: target `{target}` is missing from {filename}\n\
+            If this is a new target, please add it to {src}."
         );
     }
     for target in &extra {
         eprintln!(
-            "error: target `{}` is in {}, but does not appear in the rustc target list\n\
-            If the target has been removed, please edit {} and remove the target.",
-            target, filename, src
+            "error: target `{target}` is in {filename}, but does not appear in the rustc target list\n\
+            If the target has been removed, please edit {src} and remove the target."
         );
     }
     // Check target names for unwanted characters like `.` that can cause problems e.g. in Cargo.
     // See also Tier 3 target policy.
     // If desired, target names can ignore this check.
-    let ignore_target_names = vec![
+    let ignore_target_names = [
         "thumbv8m.base-none-eabi",
         "thumbv8m.main-none-eabi",
         "thumbv8m.main-none-eabihf",
-- 
cgit 1.4.1-3-g733a5


From d3d51b4fdbd6854da015f501e6566ca17cb023e5 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 9 Jul 2025 09:12:42 +0000
Subject: Avoid a bunch of unnecessary `unsafe` blocks in cg_llvm

---
 compiler/rustc_codegen_llvm/src/back/write.rs      | 77 ++++++++++------------
 compiler/rustc_codegen_llvm/src/common.rs          |  8 +--
 compiler/rustc_codegen_llvm/src/consts.rs          | 12 ++--
 compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs   |  2 +-
 .../rustc_codegen_llvm/src/debuginfo/metadata.rs   |  2 +-
 compiler/rustc_codegen_llvm/src/declare.rs         |  2 +-
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs        |  6 +-
 compiler/rustc_codegen_llvm/src/llvm/mod.rs        | 10 +--
 8 files changed, 54 insertions(+), 65 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index 506286fc255..313bf6d20a6 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -879,9 +879,7 @@ pub(crate) fn codegen(
                     .generic_activity_with_arg("LLVM_module_codegen_embed_bitcode", &*module.name);
                 let thin_bc =
                     module.thin_lto_buffer.as_deref().expect("cannot find embedded bitcode");
-                unsafe {
-                    embed_bitcode(cgcx, llcx, llmod, &config.bc_cmdline, &thin_bc);
-                }
+                embed_bitcode(cgcx, llcx, llmod, &config.bc_cmdline, &thin_bc);
             }
         }
 
@@ -945,7 +943,7 @@ pub(crate) fn codegen(
             // binaries. So we must clone the module to produce the asm output
             // if we are also producing object code.
             let llmod = if let EmitObj::ObjectCode(_) = config.emit_obj {
-                unsafe { llvm::LLVMCloneModule(llmod) }
+                llvm::LLVMCloneModule(llmod)
             } else {
                 llmod
             };
@@ -1073,7 +1071,7 @@ pub(crate) fn bitcode_section_name(cgcx: &CodegenContext<LlvmCodegenBackend>) ->
 }
 
 /// Embed the bitcode of an LLVM module for LTO in the LLVM module itself.
-unsafe fn embed_bitcode(
+fn embed_bitcode(
     cgcx: &CodegenContext<LlvmCodegenBackend>,
     llcx: &llvm::Context,
     llmod: &llvm::Module,
@@ -1115,43 +1113,40 @@ unsafe fn embed_bitcode(
     // Unfortunately, LLVM provides no way to set custom section flags. For ELF
     // and COFF we emit the sections using module level inline assembly for that
     // reason (see issue #90326 for historical background).
-    unsafe {
-        if cgcx.target_is_like_darwin
-            || cgcx.target_is_like_aix
-            || cgcx.target_arch == "wasm32"
-            || cgcx.target_arch == "wasm64"
-        {
-            // We don't need custom section flags, create LLVM globals.
-            let llconst = common::bytes_in_context(llcx, bitcode);
-            let llglobal =
-                llvm::add_global(llmod, common::val_ty(llconst), c"rustc.embedded.module");
-            llvm::set_initializer(llglobal, llconst);
-
-            llvm::set_section(llglobal, bitcode_section_name(cgcx));
-            llvm::set_linkage(llglobal, llvm::Linkage::PrivateLinkage);
-            llvm::LLVMSetGlobalConstant(llglobal, llvm::True);
-
-            let llconst = common::bytes_in_context(llcx, cmdline.as_bytes());
-            let llglobal =
-                llvm::add_global(llmod, common::val_ty(llconst), c"rustc.embedded.cmdline");
-            llvm::set_initializer(llglobal, llconst);
-            let section = if cgcx.target_is_like_darwin {
-                c"__LLVM,__cmdline"
-            } else if cgcx.target_is_like_aix {
-                c".info"
-            } else {
-                c".llvmcmd"
-            };
-            llvm::set_section(llglobal, section);
-            llvm::set_linkage(llglobal, llvm::Linkage::PrivateLinkage);
+
+    if cgcx.target_is_like_darwin
+        || cgcx.target_is_like_aix
+        || cgcx.target_arch == "wasm32"
+        || cgcx.target_arch == "wasm64"
+    {
+        // We don't need custom section flags, create LLVM globals.
+        let llconst = common::bytes_in_context(llcx, bitcode);
+        let llglobal = llvm::add_global(llmod, common::val_ty(llconst), c"rustc.embedded.module");
+        llvm::set_initializer(llglobal, llconst);
+
+        llvm::set_section(llglobal, bitcode_section_name(cgcx));
+        llvm::set_linkage(llglobal, llvm::Linkage::PrivateLinkage);
+        llvm::LLVMSetGlobalConstant(llglobal, llvm::True);
+
+        let llconst = common::bytes_in_context(llcx, cmdline.as_bytes());
+        let llglobal = llvm::add_global(llmod, common::val_ty(llconst), c"rustc.embedded.cmdline");
+        llvm::set_initializer(llglobal, llconst);
+        let section = if cgcx.target_is_like_darwin {
+            c"__LLVM,__cmdline"
+        } else if cgcx.target_is_like_aix {
+            c".info"
         } else {
-            // We need custom section flags, so emit module-level inline assembly.
-            let section_flags = if cgcx.is_pe_coff { "n" } else { "e" };
-            let asm = create_section_with_flags_asm(".llvmbc", section_flags, bitcode);
-            llvm::append_module_inline_asm(llmod, &asm);
-            let asm = create_section_with_flags_asm(".llvmcmd", section_flags, cmdline.as_bytes());
-            llvm::append_module_inline_asm(llmod, &asm);
-        }
+            c".llvmcmd"
+        };
+        llvm::set_section(llglobal, section);
+        llvm::set_linkage(llglobal, llvm::Linkage::PrivateLinkage);
+    } else {
+        // We need custom section flags, so emit module-level inline assembly.
+        let section_flags = if cgcx.is_pe_coff { "n" } else { "e" };
+        let asm = create_section_with_flags_asm(".llvmbc", section_flags, bitcode);
+        llvm::append_module_inline_asm(llmod, &asm);
+        let asm = create_section_with_flags_asm(".llvmcmd", section_flags, cmdline.as_bytes());
+        llvm::append_module_inline_asm(llmod, &asm);
     }
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
index b9b5c776d86..f9ab96b5789 100644
--- a/compiler/rustc_codegen_llvm/src/common.rs
+++ b/compiler/rustc_codegen_llvm/src/common.rs
@@ -215,10 +215,10 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                 bug!("symbol `{}` is already defined", sym);
             });
             llvm::set_initializer(g, sc);
-            unsafe {
-                llvm::LLVMSetGlobalConstant(g, True);
-                llvm::LLVMSetUnnamedAddress(g, llvm::UnnamedAddr::Global);
-            }
+
+            llvm::set_global_constant(g, true);
+            llvm::set_unnamed_address(g, llvm::UnnamedAddr::Global);
+
             llvm::set_linkage(g, llvm::Linkage::InternalLinkage);
             // Cast to default address space if globals are in a different addrspace
             let g = self.const_pointercast(g, self.type_ptr());
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 5deddb3ed98..070a9b64486 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -19,11 +19,10 @@ use tracing::{debug, instrument, trace};
 
 use crate::common::{AsCCharPtr, CodegenCx};
 use crate::errors::SymbolAlreadyDefined;
-use crate::llvm::{self, True};
 use crate::type_::Type;
 use crate::type_of::LayoutLlvmExt;
 use crate::value::Value;
-use crate::{base, debuginfo};
+use crate::{base, debuginfo, llvm};
 
 pub(crate) fn const_alloc_to_llvm<'ll>(
     cx: &CodegenCx<'ll, '_>,
@@ -247,7 +246,7 @@ impl<'ll> CodegenCx<'ll, '_> {
         };
         llvm::set_initializer(gv, cv);
         set_global_alignment(self, gv, align);
-        llvm::SetUnnamedAddress(gv, llvm::UnnamedAddr::Global);
+        llvm::set_unnamed_address(gv, llvm::UnnamedAddr::Global);
         gv
     }
 
@@ -272,9 +271,8 @@ impl<'ll> CodegenCx<'ll, '_> {
             return gv;
         }
         let gv = self.static_addr_of_mut(cv, align, kind);
-        unsafe {
-            llvm::LLVMSetGlobalConstant(gv, True);
-        }
+        llvm::set_global_constant(gv, true);
+
         self.const_globals.borrow_mut().insert(cv, gv);
         gv
     }
@@ -465,7 +463,7 @@ impl<'ll> CodegenCx<'ll, '_> {
 
             // Forward the allocation's mutability (picked by the const interner) to LLVM.
             if alloc.mutability.is_not() {
-                llvm::LLVMSetGlobalConstant(g, llvm::True);
+                llvm::set_global_constant(g, true);
             }
 
             debuginfo::build_global_var_di_node(self, def_id, g);
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
index 8f0948b8183..3e04dac6cd6 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
@@ -75,7 +75,7 @@ pub(crate) fn get_or_insert_gdb_debug_scripts_section_global<'ll>(
             llvm::set_section(section_var, c".debug_gdb_scripts");
             llvm::set_initializer(section_var, cx.const_bytes(section_contents));
             llvm::LLVMSetGlobalConstant(section_var, llvm::True);
-            llvm::LLVMSetUnnamedAddress(section_var, llvm::UnnamedAddr::Global);
+            llvm::set_unnamed_address(section_var, llvm::UnnamedAddr::Global);
             llvm::set_linkage(section_var, llvm::Linkage::LinkOnceODRLinkage);
             // This should make sure that the whole section is not larger than
             // the string it contains. Otherwise we get a warning from GDB.
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 9b4736e50e6..1a50fb5823b 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -1630,7 +1630,7 @@ pub(crate) fn create_vtable_di_node<'ll, 'tcx>(
     // When full debuginfo is enabled, we want to try and prevent vtables from being
     // merged. Otherwise debuggers will have a hard time mapping from dyn pointer
     // to concrete type.
-    llvm::SetUnnamedAddress(vtable, llvm::UnnamedAddr::No);
+    llvm::set_unnamed_address(vtable, llvm::UnnamedAddr::No);
 
     let vtable_name =
         compute_debuginfo_vtable_name(cx.tcx, ty, poly_trait_ref, VTableNameKind::GlobalVariable);
diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs
index 2419ec1f888..710032c774b 100644
--- a/compiler/rustc_codegen_llvm/src/declare.rs
+++ b/compiler/rustc_codegen_llvm/src/declare.rs
@@ -49,7 +49,7 @@ pub(crate) fn declare_simple_fn<'ll>(
     };
 
     llvm::SetFunctionCallConv(llfn, callconv);
-    llvm::SetUnnamedAddress(llfn, unnamed);
+    llvm::set_unnamed_address(llfn, unnamed);
     llvm::set_visibility(llfn, visibility);
 
     llfn
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 5c34ab2e304..2af57e22cd5 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1009,7 +1009,7 @@ unsafe extern "C" {
         ModuleID: *const c_char,
         C: &Context,
     ) -> &Module;
-    pub(crate) fn LLVMCloneModule(M: &Module) -> &Module;
+    pub(crate) safe fn LLVMCloneModule(M: &Module) -> &Module;
 
     /// Data layout. See Module::getDataLayout.
     pub(crate) fn LLVMGetDataLayoutStr(M: &Module) -> *const c_char;
@@ -1179,7 +1179,7 @@ unsafe extern "C" {
     pub(crate) fn LLVMIsThreadLocal(GlobalVar: &Value) -> Bool;
     pub(crate) fn LLVMSetThreadLocalMode(GlobalVar: &Value, Mode: ThreadLocalMode);
     pub(crate) fn LLVMIsGlobalConstant(GlobalVar: &Value) -> Bool;
-    pub(crate) fn LLVMSetGlobalConstant(GlobalVar: &Value, IsConstant: Bool);
+    pub(crate) safe fn LLVMSetGlobalConstant(GlobalVar: &Value, IsConstant: Bool);
     pub(crate) safe fn LLVMSetTailCall(CallInst: &Value, IsTailCall: Bool);
 
     // Operations on attributes
@@ -1718,7 +1718,7 @@ unsafe extern "C" {
 
     pub(crate) safe fn LLVMMetadataAsValue<'a>(C: &'a Context, MD: &'a Metadata) -> &'a Value;
 
-    pub(crate) fn LLVMSetUnnamedAddress(Global: &Value, UnnamedAddr: UnnamedAddr);
+    pub(crate) safe fn LLVMSetUnnamedAddress(Global: &Value, UnnamedAddr: UnnamedAddr);
 
     pub(crate) fn LLVMIsAConstantInt(value_ref: &Value) -> Option<&ConstantInt>;
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm/mod.rs b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
index 3fc83fca352..154ba4fd690 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
@@ -217,10 +217,8 @@ pub(crate) fn SetUniqueComdat(llmod: &Module, val: &Value) {
     set_comdat(llmod, val, &name);
 }
 
-pub(crate) fn SetUnnamedAddress(global: &Value, unnamed: UnnamedAddr) {
-    unsafe {
-        LLVMSetUnnamedAddress(global, unnamed);
-    }
+pub(crate) fn set_unnamed_address(global: &Value, unnamed: UnnamedAddr) {
+    LLVMSetUnnamedAddress(global, unnamed);
 }
 
 pub(crate) fn set_thread_local_mode(global: &Value, mode: ThreadLocalMode) {
@@ -260,9 +258,7 @@ pub(crate) fn set_initializer(llglobal: &Value, constant_val: &Value) {
 }
 
 pub(crate) fn set_global_constant(llglobal: &Value, is_constant: bool) {
-    unsafe {
-        LLVMSetGlobalConstant(llglobal, if is_constant { ffi::True } else { ffi::False });
-    }
+    LLVMSetGlobalConstant(llglobal, if is_constant { ffi::True } else { ffi::False });
 }
 
 pub(crate) fn get_linkage(llglobal: &Value) -> Linkage {
-- 
cgit 1.4.1-3-g733a5


From e574fef728605089da8144960348469896751c3c Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 9 Jul 2025 09:23:05 +0000
Subject: Shrink some `unsafe` blocks in cg_llvm

---
 compiler/rustc_codegen_llvm/src/builder.rs   |  13 +-
 compiler/rustc_codegen_llvm/src/consts.rs    | 251 +++++++++++++--------------
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs  |   8 +-
 compiler/rustc_codegen_llvm/src/mono_item.rs |   4 +-
 4 files changed, 137 insertions(+), 139 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 9c3b866aa3c..7304460c493 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -637,17 +637,16 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         } else if place.layout.is_llvm_immediate() {
             let mut const_llval = None;
             let llty = place.layout.llvm_type(self);
-            unsafe {
-                if let Some(global) = llvm::LLVMIsAGlobalVariable(place.val.llval) {
-                    if llvm::LLVMIsGlobalConstant(global) == llvm::True {
-                        if let Some(init) = llvm::LLVMGetInitializer(global) {
-                            if self.val_ty(init) == llty {
-                                const_llval = Some(init);
-                            }
+            if let Some(global) = llvm::LLVMIsAGlobalVariable(place.val.llval) {
+                if llvm::LLVMIsGlobalConstant(global) == llvm::True {
+                    if let Some(init) = llvm::LLVMGetInitializer(global) {
+                        if self.val_ty(init) == llty {
+                            const_llval = Some(init);
                         }
                     }
                 }
             }
+
             let llval = const_llval.unwrap_or_else(|| {
                 let load = self.load(llty, place.val.llval, place.val.align);
                 if let abi::BackendRepr::Scalar(scalar) = place.layout.backend_repr {
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 070a9b64486..27f6a119727 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -396,149 +396,148 @@ impl<'ll> CodegenCx<'ll, '_> {
     }
 
     fn codegen_static_item(&mut self, def_id: DefId) {
-        unsafe {
-            assert!(
-                llvm::LLVMGetInitializer(
-                    self.instances.borrow().get(&Instance::mono(self.tcx, def_id)).unwrap()
-                )
-                .is_none()
-            );
-            let attrs = self.tcx.codegen_fn_attrs(def_id);
+        assert!(
+            llvm::LLVMGetInitializer(
+                self.instances.borrow().get(&Instance::mono(self.tcx, def_id)).unwrap()
+            )
+            .is_none()
+        );
+        let attrs = self.tcx.codegen_fn_attrs(def_id);
 
-            let Ok((v, alloc)) = codegen_static_initializer(self, def_id) else {
-                // Error has already been reported
-                return;
-            };
-            let alloc = alloc.inner();
+        let Ok((v, alloc)) = codegen_static_initializer(self, def_id) else {
+            // Error has already been reported
+            return;
+        };
+        let alloc = alloc.inner();
 
-            let val_llty = self.val_ty(v);
+        let val_llty = self.val_ty(v);
 
-            let g = self.get_static_inner(def_id, val_llty);
-            let llty = self.get_type_of_global(g);
+        let g = self.get_static_inner(def_id, val_llty);
+        let llty = self.get_type_of_global(g);
 
-            let g = if val_llty == llty {
-                g
-            } else {
-                // codegen_static_initializer creates the global value just from the
-                // `Allocation` data by generating one big struct value that is just
-                // all the bytes and pointers after each other. This will almost never
-                // match the type that the static was declared with. Unfortunately
-                // we can't just LLVMConstBitCast our way out of it because that has very
-                // specific rules on what can be cast. So instead of adding a new way to
-                // generate static initializers that match the static's type, we picked
-                // the easier option and retroactively change the type of the static item itself.
-                let name = llvm::get_value_name(g);
-                llvm::set_value_name(g, b"");
-
-                let linkage = llvm::get_linkage(g);
-                let visibility = llvm::get_visibility(g);
-
-                let new_g = llvm::LLVMRustGetOrInsertGlobal(
-                    self.llmod,
-                    name.as_c_char_ptr(),
-                    name.len(),
-                    val_llty,
-                );
-
-                llvm::set_linkage(new_g, linkage);
-                llvm::set_visibility(new_g, visibility);
-
-                // The old global has had its name removed but is returned by
-                // get_static since it is in the instance cache. Provide an
-                // alternative lookup that points to the new global so that
-                // global_asm! can compute the correct mangled symbol name
-                // for the global.
-                self.renamed_statics.borrow_mut().insert(def_id, new_g);
-
-                // To avoid breaking any invariants, we leave around the old
-                // global for the moment; we'll replace all references to it
-                // with the new global later. (See base::codegen_backend.)
-                self.statics_to_rauw.borrow_mut().push((g, new_g));
-                new_g
-            };
-            set_global_alignment(self, g, alloc.align);
-            llvm::set_initializer(g, v);
-
-            self.assume_dso_local(g, true);
-
-            // Forward the allocation's mutability (picked by the const interner) to LLVM.
-            if alloc.mutability.is_not() {
-                llvm::set_global_constant(g, true);
-            }
+        let g = if val_llty == llty {
+            g
+        } else {
+            // codegen_static_initializer creates the global value just from the
+            // `Allocation` data by generating one big struct value that is just
+            // all the bytes and pointers after each other. This will almost never
+            // match the type that the static was declared with. Unfortunately
+            // we can't just LLVMConstBitCast our way out of it because that has very
+            // specific rules on what can be cast. So instead of adding a new way to
+            // generate static initializers that match the static's type, we picked
+            // the easier option and retroactively change the type of the static item itself.
+            let name = String::from_utf8(llvm::get_value_name(g))
+                .expect("we declare our statics with a utf8-valid name");
+            llvm::set_value_name(g, b"");
+
+            let linkage = llvm::get_linkage(g);
+            let visibility = llvm::get_visibility(g);
+
+            let new_g = self.declare_global(&name, val_llty);
+
+            llvm::set_linkage(new_g, linkage);
+            llvm::set_visibility(new_g, visibility);
+
+            // The old global has had its name removed but is returned by
+            // get_static since it is in the instance cache. Provide an
+            // alternative lookup that points to the new global so that
+            // global_asm! can compute the correct mangled symbol name
+            // for the global.
+            self.renamed_statics.borrow_mut().insert(def_id, new_g);
+
+            // To avoid breaking any invariants, we leave around the old
+            // global for the moment; we'll replace all references to it
+            // with the new global later. (See base::codegen_backend.)
+            self.statics_to_rauw.borrow_mut().push((g, new_g));
+            new_g
+        };
+        set_global_alignment(self, g, alloc.align);
+        llvm::set_initializer(g, v);
 
-            debuginfo::build_global_var_di_node(self, def_id, g);
+        self.assume_dso_local(g, true);
 
-            if attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL) {
-                llvm::set_thread_local_mode(g, self.tls_model);
-            }
+        // Forward the allocation's mutability (picked by the const interner) to LLVM.
+        if alloc.mutability.is_not() {
+            llvm::set_global_constant(g, true);
+        }
 
-            // Wasm statics with custom link sections get special treatment as they
-            // go into custom sections of the wasm executable. The exception to this
-            // is the `.init_array` section which are treated specially by the wasm linker.
-            if self.tcx.sess.target.is_like_wasm
-                && attrs
-                    .link_section
-                    .map(|link_section| !link_section.as_str().starts_with(".init_array"))
-                    .unwrap_or(true)
-            {
-                if let Some(section) = attrs.link_section {
-                    let section = llvm::LLVMMDStringInContext2(
+        debuginfo::build_global_var_di_node(self, def_id, g);
+
+        if attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL) {
+            llvm::set_thread_local_mode(g, self.tls_model);
+        }
+
+        // Wasm statics with custom link sections get special treatment as they
+        // go into custom sections of the wasm executable. The exception to this
+        // is the `.init_array` section which are treated specially by the wasm linker.
+        if self.tcx.sess.target.is_like_wasm
+            && attrs
+                .link_section
+                .map(|link_section| !link_section.as_str().starts_with(".init_array"))
+                .unwrap_or(true)
+        {
+            if let Some(section) = attrs.link_section {
+                let section = unsafe {
+                    llvm::LLVMMDStringInContext2(
                         self.llcx,
                         section.as_str().as_c_char_ptr(),
                         section.as_str().len(),
-                    );
-                    assert!(alloc.provenance().ptrs().is_empty());
-
-                    // The `inspect` method is okay here because we checked for provenance, and
-                    // because we are doing this access to inspect the final interpreter state (not
-                    // as part of the interpreter execution).
-                    let bytes =
-                        alloc.inspect_with_uninit_and_ptr_outside_interpreter(0..alloc.len());
-                    let alloc =
-                        llvm::LLVMMDStringInContext2(self.llcx, bytes.as_c_char_ptr(), bytes.len());
-                    let data = [section, alloc];
-                    let meta = llvm::LLVMMDNodeInContext2(self.llcx, data.as_ptr(), data.len());
-                    let val = self.get_metadata_value(meta);
+                    )
+                };
+                assert!(alloc.provenance().ptrs().is_empty());
+
+                // The `inspect` method is okay here because we checked for provenance, and
+                // because we are doing this access to inspect the final interpreter state (not
+                // as part of the interpreter execution).
+                let bytes = alloc.inspect_with_uninit_and_ptr_outside_interpreter(0..alloc.len());
+                let alloc = unsafe {
+                    llvm::LLVMMDStringInContext2(self.llcx, bytes.as_c_char_ptr(), bytes.len())
+                };
+                let data = [section, alloc];
+                let meta =
+                    unsafe { llvm::LLVMMDNodeInContext2(self.llcx, data.as_ptr(), data.len()) };
+                let val = self.get_metadata_value(meta);
+                unsafe {
                     llvm::LLVMAddNamedMetadataOperand(
                         self.llmod,
                         c"wasm.custom_sections".as_ptr(),
                         val,
-                    );
-                }
-            } else {
-                base::set_link_section(g, attrs);
+                    )
+                };
             }
+        } else {
+            base::set_link_section(g, attrs);
+        }
 
-            base::set_variable_sanitizer_attrs(g, attrs);
-
-            if attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER) {
-                // `USED` and `USED_LINKER` can't be used together.
-                assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER));
-
-                // The semantics of #[used] in Rust only require the symbol to make it into the
-                // object file. It is explicitly allowed for the linker to strip the symbol if it
-                // is dead, which means we are allowed to use `llvm.compiler.used` instead of
-                // `llvm.used` here.
-                //
-                // Additionally, https://reviews.llvm.org/D97448 in LLVM 13 started emitting unique
-                // sections with SHF_GNU_RETAIN flag for llvm.used symbols, which may trigger bugs
-                // in the handling of `.init_array` (the static constructor list) in versions of
-                // the gold linker (prior to the one released with binutils 2.36).
-                //
-                // That said, we only ever emit these when `#[used(compiler)]` is explicitly
-                // requested. This is to avoid similar breakage on other targets, in particular
-                // MachO targets have *their* static constructor lists broken if `llvm.compiler.used`
-                // is emitted rather than `llvm.used`. However, that check happens when assigning
-                // the `CodegenFnAttrFlags` in the `codegen_fn_attrs` query, so we don't need to
-                // take care of it here.
-                self.add_compiler_used_global(g);
-            }
-            if attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER) {
-                // `USED` and `USED_LINKER` can't be used together.
-                assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER));
+        base::set_variable_sanitizer_attrs(g, attrs);
+
+        if attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER) {
+            // `USED` and `USED_LINKER` can't be used together.
+            assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER));
+
+            // The semantics of #[used] in Rust only require the symbol to make it into the
+            // object file. It is explicitly allowed for the linker to strip the symbol if it
+            // is dead, which means we are allowed to use `llvm.compiler.used` instead of
+            // `llvm.used` here.
+            //
+            // Additionally, https://reviews.llvm.org/D97448 in LLVM 13 started emitting unique
+            // sections with SHF_GNU_RETAIN flag for llvm.used symbols, which may trigger bugs
+            // in the handling of `.init_array` (the static constructor list) in versions of
+            // the gold linker (prior to the one released with binutils 2.36).
+            //
+            // That said, we only ever emit these when `#[used(compiler)]` is explicitly
+            // requested. This is to avoid similar breakage on other targets, in particular
+            // MachO targets have *their* static constructor lists broken if `llvm.compiler.used`
+            // is emitted rather than `llvm.used`. However, that check happens when assigning
+            // the `CodegenFnAttrFlags` in the `codegen_fn_attrs` query, so we don't need to
+            // take care of it here.
+            self.add_compiler_used_global(g);
+        }
+        if attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER) {
+            // `USED` and `USED_LINKER` can't be used together.
+            assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER));
 
-                self.add_used_global(g);
-            }
+            self.add_used_global(g);
         }
     }
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 2af57e22cd5..0b1e632cbc4 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1168,17 +1168,17 @@ unsafe extern "C" {
     pub(crate) fn LLVMGlobalGetValueType(Global: &Value) -> &Type;
 
     // Operations on global variables
-    pub(crate) fn LLVMIsAGlobalVariable(GlobalVar: &Value) -> Option<&Value>;
+    pub(crate) safe fn LLVMIsAGlobalVariable(GlobalVar: &Value) -> Option<&Value>;
     pub(crate) fn LLVMAddGlobal<'a>(M: &'a Module, Ty: &'a Type, Name: *const c_char) -> &'a Value;
     pub(crate) fn LLVMGetNamedGlobal(M: &Module, Name: *const c_char) -> Option<&Value>;
     pub(crate) fn LLVMGetFirstGlobal(M: &Module) -> Option<&Value>;
     pub(crate) fn LLVMGetNextGlobal(GlobalVar: &Value) -> Option<&Value>;
     pub(crate) fn LLVMDeleteGlobal(GlobalVar: &Value);
-    pub(crate) fn LLVMGetInitializer(GlobalVar: &Value) -> Option<&Value>;
+    pub(crate) safe fn LLVMGetInitializer(GlobalVar: &Value) -> Option<&Value>;
     pub(crate) fn LLVMSetInitializer<'a>(GlobalVar: &'a Value, ConstantVal: &'a Value);
-    pub(crate) fn LLVMIsThreadLocal(GlobalVar: &Value) -> Bool;
+    pub(crate) safe fn LLVMIsThreadLocal(GlobalVar: &Value) -> Bool;
     pub(crate) fn LLVMSetThreadLocalMode(GlobalVar: &Value, Mode: ThreadLocalMode);
-    pub(crate) fn LLVMIsGlobalConstant(GlobalVar: &Value) -> Bool;
+    pub(crate) safe fn LLVMIsGlobalConstant(GlobalVar: &Value) -> Bool;
     pub(crate) safe fn LLVMSetGlobalConstant(GlobalVar: &Value, IsConstant: Bool);
     pub(crate) safe fn LLVMSetTailCall(CallInst: &Value, IsTailCall: Bool);
 
diff --git a/compiler/rustc_codegen_llvm/src/mono_item.rs b/compiler/rustc_codegen_llvm/src/mono_item.rs
index 3f38e1e191b..8f70270f203 100644
--- a/compiler/rustc_codegen_llvm/src/mono_item.rs
+++ b/compiler/rustc_codegen_llvm/src/mono_item.rs
@@ -131,8 +131,8 @@ impl CodegenCx<'_, '_> {
         }
 
         // Thread-local variables generally don't support copy relocations.
-        let is_thread_local_var = unsafe { llvm::LLVMIsAGlobalVariable(llval) }
-            .is_some_and(|v| unsafe { llvm::LLVMIsThreadLocal(v) } == llvm::True);
+        let is_thread_local_var = llvm::LLVMIsAGlobalVariable(llval)
+            .is_some_and(|v| llvm::LLVMIsThreadLocal(v) == llvm::True);
         if is_thread_local_var {
             return false;
         }
-- 
cgit 1.4.1-3-g733a5


From b9baf63f99bbdf69571e26fca907af032c416591 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 9 Jul 2025 09:31:58 +0000
Subject: Merge `typeid_metadata` and `create_metadata`

---
 compiler/rustc_codegen_llvm/src/builder.rs          |  2 +-
 compiler/rustc_codegen_llvm/src/builder/autodiff.rs | 16 ++++++++--------
 compiler/rustc_codegen_llvm/src/context.rs          |  7 ++++---
 compiler/rustc_codegen_llvm/src/type_.rs            | 10 ++++------
 4 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 7304460c493..4c5bc8430cc 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -1720,7 +1720,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
             } else {
                 cfi::typeid_for_fnabi(self.tcx, fn_abi, options)
             };
-            let typeid_metadata = self.cx.typeid_metadata(typeid).unwrap();
+            let typeid_metadata = self.cx.create_metadata(typeid);
             let dbg_loc = self.get_dbg_loc();
 
             // Test whether the function pointer is associated with the type identifier using the
diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index 5afb9a60d42..9383903fd02 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -76,12 +76,12 @@ fn match_args_from_caller_to_enzyme<'ll>(
         outer_pos = 1;
     }
 
-    let enzyme_const = cx.create_metadata("enzyme_const".to_string()).unwrap();
-    let enzyme_out = cx.create_metadata("enzyme_out".to_string()).unwrap();
-    let enzyme_dup = cx.create_metadata("enzyme_dup".to_string()).unwrap();
-    let enzyme_dupv = cx.create_metadata("enzyme_dupv".to_string()).unwrap();
-    let enzyme_dupnoneed = cx.create_metadata("enzyme_dupnoneed".to_string()).unwrap();
-    let enzyme_dupnoneedv = cx.create_metadata("enzyme_dupnoneedv".to_string()).unwrap();
+    let enzyme_const = cx.create_metadata("enzyme_const".to_string());
+    let enzyme_out = cx.create_metadata("enzyme_out".to_string());
+    let enzyme_dup = cx.create_metadata("enzyme_dup".to_string());
+    let enzyme_dupv = cx.create_metadata("enzyme_dupv".to_string());
+    let enzyme_dupnoneed = cx.create_metadata("enzyme_dupnoneed".to_string());
+    let enzyme_dupnoneedv = cx.create_metadata("enzyme_dupnoneedv".to_string());
 
     while activity_pos < inputs.len() {
         let diff_activity = inputs[activity_pos as usize];
@@ -378,12 +378,12 @@ fn generate_enzyme_call<'ll>(
         let mut args = Vec::with_capacity(num_args as usize + 1);
         args.push(fn_to_diff);
 
-        let enzyme_primal_ret = cx.create_metadata("enzyme_primal_return".to_string()).unwrap();
+        let enzyme_primal_ret = cx.create_metadata("enzyme_primal_return".to_string());
         if matches!(attrs.ret_activity, DiffActivity::Dual | DiffActivity::Active) {
             args.push(cx.get_metadata_value(enzyme_primal_ret));
         }
         if attrs.width > 1 {
-            let enzyme_width = cx.create_metadata("enzyme_width".to_string()).unwrap();
+            let enzyme_width = cx.create_metadata("enzyme_width".to_string());
             args.push(cx.get_metadata_value(enzyme_width));
             args.push(cx.get_const_int(cx.type_i64(), attrs.width as u64));
         }
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 90582e23b04..5616c4d4e45 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -473,6 +473,7 @@ pub(crate) unsafe fn create_module<'ll>(
     #[allow(clippy::option_env_unwrap)]
     let rustc_producer =
         format!("rustc version {}", option_env!("CFG_VERSION").expect("CFG_VERSION"));
+
     let name_metadata = unsafe {
         llvm::LLVMMDStringInContext2(
             llcx,
@@ -698,10 +699,10 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
         }
     }
 
-    pub(crate) fn create_metadata(&self, name: String) -> Option<&'ll Metadata> {
-        Some(unsafe {
+    pub(crate) fn create_metadata(&self, name: String) -> &'ll Metadata {
+        unsafe {
             llvm::LLVMMDStringInContext2(self.llcx(), name.as_ptr() as *const c_char, name.len())
-        })
+        }
     }
 
     pub(crate) fn get_functions(&self) -> Vec<&'ll Value> {
diff --git a/compiler/rustc_codegen_llvm/src/type_.rs b/compiler/rustc_codegen_llvm/src/type_.rs
index ee472e75ed4..5b19ca91e4d 100644
--- a/compiler/rustc_codegen_llvm/src/type_.rs
+++ b/compiler/rustc_codegen_llvm/src/type_.rs
@@ -2,7 +2,7 @@ use std::borrow::Borrow;
 use std::hash::{Hash, Hasher};
 use std::{fmt, ptr};
 
-use libc::{c_char, c_uint};
+use libc::c_uint;
 use rustc_abi::{AddressSpace, Align, Integer, Reg, Size};
 use rustc_codegen_ssa::common::TypeKind;
 use rustc_codegen_ssa::traits::*;
@@ -299,7 +299,7 @@ impl<'ll, 'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 
 impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     fn add_type_metadata(&self, function: &'ll Value, typeid: String) {
-        let typeid_metadata = self.typeid_metadata(typeid).unwrap();
+        let typeid_metadata = self.create_metadata(typeid);
         unsafe {
             let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata];
             llvm::LLVMRustGlobalAddMetadata(
@@ -311,7 +311,7 @@ impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     }
 
     fn set_type_metadata(&self, function: &'ll Value, typeid: String) {
-        let typeid_metadata = self.typeid_metadata(typeid).unwrap();
+        let typeid_metadata = self.create_metadata(typeid);
         unsafe {
             let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata];
             llvm::LLVMGlobalSetMetadata(
@@ -323,9 +323,7 @@ impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
     }
 
     fn typeid_metadata(&self, typeid: String) -> Option<&'ll Metadata> {
-        Some(unsafe {
-            llvm::LLVMMDStringInContext2(self.llcx, typeid.as_ptr() as *const c_char, typeid.len())
-        })
+        Some(self.create_metadata(typeid))
     }
 
     fn add_kcfi_type_metadata(&self, function: &'ll Value, kcfi_typeid: u32) {
-- 
cgit 1.4.1-3-g733a5


From 56d22cd29ff6d3ea1fa8972462ad94792960b1ef Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 9 Jul 2025 09:36:19 +0000
Subject: Use context methods instead of directly calling FFI

---
 compiler/rustc_codegen_llvm/src/builder.rs            |  4 +---
 compiler/rustc_codegen_llvm/src/consts.rs             |  8 +-------
 compiler/rustc_codegen_llvm/src/context.rs            | 14 +++++---------
 compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs |  8 ++------
 4 files changed, 9 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 4c5bc8430cc..3c64cb79d5e 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -303,9 +303,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
 
         let id_str = "branch_weights";
-        let id = unsafe {
-            llvm::LLVMMDStringInContext2(self.cx.llcx, id_str.as_ptr().cast(), id_str.len())
-        };
+        let id = self.cx.create_metadata(id_str.into());
 
         // For switch instructions with 2 targets, the `llvm.expect` intrinsic is used.
         // This function handles switch instructions with more than 2 targets and it needs to
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 27f6a119727..40e686b253c 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -477,13 +477,7 @@ impl<'ll> CodegenCx<'ll, '_> {
                 .unwrap_or(true)
         {
             if let Some(section) = attrs.link_section {
-                let section = unsafe {
-                    llvm::LLVMMDStringInContext2(
-                        self.llcx,
-                        section.as_str().as_c_char_ptr(),
-                        section.as_str().len(),
-                    )
-                };
+                let section = self.create_metadata(section.as_str().into());
                 assert!(alloc.provenance().ptrs().is_empty());
 
                 // The `inspect` method is okay here because we checked for provenance, and
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 5616c4d4e45..51ba3fb8089 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -34,7 +34,6 @@ use smallvec::SmallVec;
 
 use crate::back::write::to_llvm_code_model;
 use crate::callee::get_fn;
-use crate::common::AsCCharPtr;
 use crate::debuginfo::metadata::apply_vcall_visibility_metadata;
 use crate::llvm::Metadata;
 use crate::type_::Type;
@@ -169,6 +168,8 @@ pub(crate) unsafe fn create_module<'ll>(
     let mod_name = SmallCStr::new(mod_name);
     let llmod = unsafe { llvm::LLVMModuleCreateWithNameInContext(mod_name.as_ptr(), llcx) };
 
+    let cx = SimpleCx::new(llmod, llcx, tcx.data_layout.pointer_size());
+
     let mut target_data_layout = sess.target.data_layout.to_string();
     let llvm_version = llvm_util::get_version();
 
@@ -474,18 +475,13 @@ pub(crate) unsafe fn create_module<'ll>(
     let rustc_producer =
         format!("rustc version {}", option_env!("CFG_VERSION").expect("CFG_VERSION"));
 
-    let name_metadata = unsafe {
-        llvm::LLVMMDStringInContext2(
-            llcx,
-            rustc_producer.as_c_char_ptr(),
-            rustc_producer.as_bytes().len(),
-        )
-    };
+    let name_metadata = cx.create_metadata(rustc_producer);
+
     unsafe {
         llvm::LLVMAddNamedMetadataOperand(
             llmod,
             c"llvm.ident".as_ptr(),
-            &llvm::LLVMMetadataAsValue(llcx, llvm::LLVMMDNodeInContext2(llcx, &name_metadata, 1)),
+            &cx.get_metadata_value(llvm::LLVMMDNodeInContext2(llcx, &name_metadata, 1)),
         );
     }
 
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 1a50fb5823b..3fdf4e19d58 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::{iter, ptr};
 
-use libc::{c_char, c_longlong, c_uint};
+use libc::{c_longlong, c_uint};
 use rustc_abi::{Align, Size};
 use rustc_codegen_ssa::debuginfo::type_names::{VTableNameKind, cpp_like_debuginfo};
 use rustc_codegen_ssa::traits::*;
@@ -1582,13 +1582,9 @@ pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
     };
 
     let trait_ref_typeid = typeid_for_trait_ref(cx.tcx, trait_ref);
+    let typeid = cx.create_metadata(trait_ref_typeid);
 
     unsafe {
-        let typeid = llvm::LLVMMDStringInContext2(
-            cx.llcx,
-            trait_ref_typeid.as_ptr() as *const c_char,
-            trait_ref_typeid.as_bytes().len(),
-        );
         let v = [llvm::LLVMValueAsMetadata(cx.const_usize(0)), typeid];
         llvm::LLVMRustGlobalAddMetadata(
             vtable,
-- 
cgit 1.4.1-3-g733a5


From 7f95f042677f86df55da58cdebe9ce31a1e928a8 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 9 Jul 2025 09:48:46 +0000
Subject: Eliminate all direct uses of LLVMMDStringInContext2

---
 compiler/rustc_codegen_llvm/src/builder.rs            |  5 ++---
 compiler/rustc_codegen_llvm/src/builder/autodiff.rs   | 16 ++++++++--------
 compiler/rustc_codegen_llvm/src/consts.rs             |  8 +++-----
 compiler/rustc_codegen_llvm/src/context.rs            |  4 ++--
 compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs |  2 +-
 compiler/rustc_codegen_llvm/src/declare.rs            |  4 ++--
 compiler/rustc_codegen_llvm/src/type_.rs              |  6 +++---
 compiler/rustc_codegen_ssa/src/meth.rs                |  3 ++-
 compiler/rustc_codegen_ssa/src/traits/type_.rs        |  6 +++---
 9 files changed, 26 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 3c64cb79d5e..514923ad6f3 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -302,8 +302,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
             return;
         }
 
-        let id_str = "branch_weights";
-        let id = self.cx.create_metadata(id_str.into());
+        let id = self.cx.create_metadata(b"branch_weights");
 
         // For switch instructions with 2 targets, the `llvm.expect` intrinsic is used.
         // This function handles switch instructions with more than 2 targets and it needs to
@@ -1718,7 +1717,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
             } else {
                 cfi::typeid_for_fnabi(self.tcx, fn_abi, options)
             };
-            let typeid_metadata = self.cx.create_metadata(typeid);
+            let typeid_metadata = self.cx.create_metadata(typeid.as_bytes());
             let dbg_loc = self.get_dbg_loc();
 
             // Test whether the function pointer is associated with the type identifier using the
diff --git a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
index 9383903fd02..dff68472847 100644
--- a/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
+++ b/compiler/rustc_codegen_llvm/src/builder/autodiff.rs
@@ -76,12 +76,12 @@ fn match_args_from_caller_to_enzyme<'ll>(
         outer_pos = 1;
     }
 
-    let enzyme_const = cx.create_metadata("enzyme_const".to_string());
-    let enzyme_out = cx.create_metadata("enzyme_out".to_string());
-    let enzyme_dup = cx.create_metadata("enzyme_dup".to_string());
-    let enzyme_dupv = cx.create_metadata("enzyme_dupv".to_string());
-    let enzyme_dupnoneed = cx.create_metadata("enzyme_dupnoneed".to_string());
-    let enzyme_dupnoneedv = cx.create_metadata("enzyme_dupnoneedv".to_string());
+    let enzyme_const = cx.create_metadata(b"enzyme_const");
+    let enzyme_out = cx.create_metadata(b"enzyme_out");
+    let enzyme_dup = cx.create_metadata(b"enzyme_dup");
+    let enzyme_dupv = cx.create_metadata(b"enzyme_dupv");
+    let enzyme_dupnoneed = cx.create_metadata(b"enzyme_dupnoneed");
+    let enzyme_dupnoneedv = cx.create_metadata(b"enzyme_dupnoneedv");
 
     while activity_pos < inputs.len() {
         let diff_activity = inputs[activity_pos as usize];
@@ -378,12 +378,12 @@ fn generate_enzyme_call<'ll>(
         let mut args = Vec::with_capacity(num_args as usize + 1);
         args.push(fn_to_diff);
 
-        let enzyme_primal_ret = cx.create_metadata("enzyme_primal_return".to_string());
+        let enzyme_primal_ret = cx.create_metadata(b"enzyme_primal_return");
         if matches!(attrs.ret_activity, DiffActivity::Dual | DiffActivity::Active) {
             args.push(cx.get_metadata_value(enzyme_primal_ret));
         }
         if attrs.width > 1 {
-            let enzyme_width = cx.create_metadata("enzyme_width".to_string());
+            let enzyme_width = cx.create_metadata(b"enzyme_width");
             args.push(cx.get_metadata_value(enzyme_width));
             args.push(cx.get_const_int(cx.type_i64(), attrs.width as u64));
         }
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 40e686b253c..0b96b63bc85 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -17,7 +17,7 @@ use rustc_middle::ty::{self, Instance};
 use rustc_middle::{bug, span_bug};
 use tracing::{debug, instrument, trace};
 
-use crate::common::{AsCCharPtr, CodegenCx};
+use crate::common::CodegenCx;
 use crate::errors::SymbolAlreadyDefined;
 use crate::type_::Type;
 use crate::type_of::LayoutLlvmExt;
@@ -477,16 +477,14 @@ impl<'ll> CodegenCx<'ll, '_> {
                 .unwrap_or(true)
         {
             if let Some(section) = attrs.link_section {
-                let section = self.create_metadata(section.as_str().into());
+                let section = self.create_metadata(section.as_str().as_bytes());
                 assert!(alloc.provenance().ptrs().is_empty());
 
                 // The `inspect` method is okay here because we checked for provenance, and
                 // because we are doing this access to inspect the final interpreter state (not
                 // as part of the interpreter execution).
                 let bytes = alloc.inspect_with_uninit_and_ptr_outside_interpreter(0..alloc.len());
-                let alloc = unsafe {
-                    llvm::LLVMMDStringInContext2(self.llcx, bytes.as_c_char_ptr(), bytes.len())
-                };
+                let alloc = self.create_metadata(bytes);
                 let data = [section, alloc];
                 let meta =
                     unsafe { llvm::LLVMMDNodeInContext2(self.llcx, data.as_ptr(), data.len()) };
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 51ba3fb8089..6a23becaa96 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -475,7 +475,7 @@ pub(crate) unsafe fn create_module<'ll>(
     let rustc_producer =
         format!("rustc version {}", option_env!("CFG_VERSION").expect("CFG_VERSION"));
 
-    let name_metadata = cx.create_metadata(rustc_producer);
+    let name_metadata = cx.create_metadata(rustc_producer.as_bytes());
 
     unsafe {
         llvm::LLVMAddNamedMetadataOperand(
@@ -695,7 +695,7 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
         }
     }
 
-    pub(crate) fn create_metadata(&self, name: String) -> &'ll Metadata {
+    pub(crate) fn create_metadata(&self, name: &[u8]) -> &'ll Metadata {
         unsafe {
             llvm::LLVMMDStringInContext2(self.llcx(), name.as_ptr() as *const c_char, name.len())
         }
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 3fdf4e19d58..0e9dbfba658 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -1582,7 +1582,7 @@ pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
     };
 
     let trait_ref_typeid = typeid_for_trait_ref(cx.tcx, trait_ref);
-    let typeid = cx.create_metadata(trait_ref_typeid);
+    let typeid = cx.create_metadata(trait_ref_typeid.as_bytes());
 
     unsafe {
         let v = [llvm::LLVMValueAsMetadata(cx.const_usize(0)), typeid];
diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs
index 710032c774b..eb75716d768 100644
--- a/compiler/rustc_codegen_llvm/src/declare.rs
+++ b/compiler/rustc_codegen_llvm/src/declare.rs
@@ -176,7 +176,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
                 {
                     let typeid = cfi::typeid_for_instance(self.tcx, instance, options);
                     if typeids.insert(typeid.clone()) {
-                        self.add_type_metadata(llfn, typeid);
+                        self.add_type_metadata(llfn, typeid.as_bytes());
                     }
                 }
             } else {
@@ -189,7 +189,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
                 .map(cfi::TypeIdOptions::from_iter)
                 {
                     let typeid = cfi::typeid_for_fnabi(self.tcx, fn_abi, options);
-                    self.add_type_metadata(llfn, typeid);
+                    self.add_type_metadata(llfn, typeid.as_bytes());
                 }
             }
         }
diff --git a/compiler/rustc_codegen_llvm/src/type_.rs b/compiler/rustc_codegen_llvm/src/type_.rs
index 5b19ca91e4d..89365503138 100644
--- a/compiler/rustc_codegen_llvm/src/type_.rs
+++ b/compiler/rustc_codegen_llvm/src/type_.rs
@@ -298,7 +298,7 @@ impl<'ll, 'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 }
 
 impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
-    fn add_type_metadata(&self, function: &'ll Value, typeid: String) {
+    fn add_type_metadata(&self, function: &'ll Value, typeid: &[u8]) {
         let typeid_metadata = self.create_metadata(typeid);
         unsafe {
             let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata];
@@ -310,7 +310,7 @@ impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         }
     }
 
-    fn set_type_metadata(&self, function: &'ll Value, typeid: String) {
+    fn set_type_metadata(&self, function: &'ll Value, typeid: &[u8]) {
         let typeid_metadata = self.create_metadata(typeid);
         unsafe {
             let v = [llvm::LLVMValueAsMetadata(self.const_usize(0)), typeid_metadata];
@@ -322,7 +322,7 @@ impl<'ll, 'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         }
     }
 
-    fn typeid_metadata(&self, typeid: String) -> Option<&'ll Metadata> {
+    fn typeid_metadata(&self, typeid: &[u8]) -> Option<&'ll Metadata> {
         Some(self.create_metadata(typeid))
     }
 
diff --git a/compiler/rustc_codegen_ssa/src/meth.rs b/compiler/rustc_codegen_ssa/src/meth.rs
index 2aa5c3c27ea..34ad35a729b 100644
--- a/compiler/rustc_codegen_ssa/src/meth.rs
+++ b/compiler/rustc_codegen_ssa/src/meth.rs
@@ -139,7 +139,8 @@ pub(crate) fn load_vtable<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         && bx.cx().sess().lto() == Lto::Fat
     {
         if let Some(trait_ref) = dyn_trait_in_self(bx.tcx(), ty) {
-            let typeid = bx.typeid_metadata(typeid_for_trait_ref(bx.tcx(), trait_ref)).unwrap();
+            let typeid =
+                bx.typeid_metadata(typeid_for_trait_ref(bx.tcx(), trait_ref).as_bytes()).unwrap();
             let func = bx.type_checked_load(llvtable, vtable_byte_offset, typeid);
             return func;
         } else if nonnull {
diff --git a/compiler/rustc_codegen_ssa/src/traits/type_.rs b/compiler/rustc_codegen_ssa/src/traits/type_.rs
index dcd9e25b2c9..32c24965e1b 100644
--- a/compiler/rustc_codegen_ssa/src/traits/type_.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/type_.rs
@@ -154,9 +154,9 @@ pub trait LayoutTypeCodegenMethods<'tcx>: BackendTypes {
 // For backends that support CFI using type membership (i.e., testing whether a given pointer is
 // associated with a type identifier).
 pub trait TypeMembershipCodegenMethods<'tcx>: BackendTypes {
-    fn add_type_metadata(&self, _function: Self::Function, _typeid: String) {}
-    fn set_type_metadata(&self, _function: Self::Function, _typeid: String) {}
-    fn typeid_metadata(&self, _typeid: String) -> Option<Self::Metadata> {
+    fn add_type_metadata(&self, _function: Self::Function, _typeid: &[u8]) {}
+    fn set_type_metadata(&self, _function: Self::Function, _typeid: &[u8]) {}
+    fn typeid_metadata(&self, _typeid: &[u8]) -> Option<Self::Metadata> {
         None
     }
     fn add_kcfi_type_metadata(&self, _function: Self::Function, _typeid: u32) {}
-- 
cgit 1.4.1-3-g733a5


From 39059f61812d487ea7e7e1df3a1034aac05379a8 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Mon, 14 Jul 2025 08:30:27 +0000
Subject: tiercheck: edition 2024

---
 src/tools/tier-check/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/tier-check/Cargo.toml b/src/tools/tier-check/Cargo.toml
index 3f08165a3fc..a34f9447fab 100644
--- a/src/tools/tier-check/Cargo.toml
+++ b/src/tools/tier-check/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "tier-check"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-- 
cgit 1.4.1-3-g733a5


From eef08a3f440967d72bf0e8ef8f3c7571abb64738 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Thu, 10 Jul 2025 14:55:07 +0000
Subject: Give all bytes of TypeId provenance

---
 .../rustc_const_eval/src/interpret/intrinsics.rs   | 68 ++++++++++++----------
 tests/ui/consts/const_transmute_type_id3.rs        |  5 +-
 tests/ui/consts/const_transmute_type_id3.stderr    |  4 +-
 tests/ui/consts/const_transmute_type_id5.rs        | 21 +++++++
 tests/ui/consts/const_transmute_type_id5.stderr    | 15 +++++
 5 files changed, 79 insertions(+), 34 deletions(-)
 create mode 100644 tests/ui/consts/const_transmute_type_id5.rs
 create mode 100644 tests/ui/consts/const_transmute_type_id5.stderr

diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 1eba1f2f03c..22d29eda913 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -44,17 +44,21 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         )?;
         self.copy_op_allow_transmute(&op, dest)?;
 
-        // Give the first pointer-size bytes provenance that knows about the type id.
+        // Give the each pointer-sized chunk provenance that knows about the type id.
         // Here we rely on `TypeId` being a newtype around an array of pointers, so we
-        // first project to its only field and then the first array element.
+        // first project to its only field and then the array elements.
         let alloc_id = tcx.reserve_and_set_type_id_alloc(ty);
         let first = self.project_field(dest, FieldIdx::ZERO)?;
-        let first = self.project_index(&first, 0)?;
-        let offset = self.read_scalar(&first)?.to_target_usize(&tcx)?;
-        let ptr = Pointer::new(alloc_id.into(), Size::from_bytes(offset));
-        let ptr = self.global_root_pointer(ptr)?;
-        let val = Scalar::from_pointer(ptr, &tcx);
-        self.write_scalar(val, &first)
+        let mut elem_iter = self.project_array_fields(&first)?;
+        while let Some((_, elem)) = elem_iter.next(self)? {
+            // Decorate this part of the hash with provenance; leave the integer part unchanged.
+            let hash_fragment = self.read_scalar(&elem)?.to_target_usize(&tcx)?;
+            let ptr = Pointer::new(alloc_id.into(), Size::from_bytes(hash_fragment));
+            let ptr = self.global_root_pointer(ptr)?;
+            let val = Scalar::from_pointer(ptr, &tcx);
+            self.write_scalar(val, &elem)?;
+        }
+        interp_ok(())
     }
 
     /// Returns `true` if emulation happened.
@@ -101,34 +105,36 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 let mut a_fields = self.project_array_fields(&a_fields)?;
                 let mut b_fields = self.project_array_fields(&b_fields)?;
 
-                let (_idx, a) = a_fields
-                    .next(self)?
-                    .expect("we know the layout of TypeId has at least 2 array elements");
-                let a = self.deref_pointer(&a)?;
-                let (a, offset_a) = self.get_ptr_type_id(a.ptr())?;
-
-                let (_idx, b) = b_fields
-                    .next(self)?
-                    .expect("we know the layout of TypeId has at least 2 array elements");
-                let b = self.deref_pointer(&b)?;
-                let (b, offset_b) = self.get_ptr_type_id(b.ptr())?;
+                let mut provenance_a = None;
+                let mut provenance_b = None;
+                let mut provenance_matches = true;
 
-                let provenance_matches = a == b;
+                while let Some((i, a)) = a_fields.next(self)? {
+                    let (_, b) = b_fields.next(self)?.unwrap();
 
-                let mut eq_id = offset_a == offset_b;
+                    let a = self.deref_pointer(&a)?;
+                    let (a, offset_a) = self.get_ptr_type_id(a.ptr())?;
 
-                while let Some((_, a)) = a_fields.next(self)? {
-                    let (_, b) = b_fields.next(self)?.unwrap();
+                    let b = self.deref_pointer(&b)?;
+                    let (b, offset_b) = self.get_ptr_type_id(b.ptr())?;
 
-                    let a = self.read_target_usize(&a)?;
-                    let b = self.read_target_usize(&b)?;
-                    eq_id &= a == b;
-                }
+                    if *provenance_a.get_or_insert(a) != a {
+                        throw_ub_format!(
+                            "type_id_eq: the first TypeId argument is invalid, the provenance of chunk {i} does not match the first chunk's"
+                        )
+                    }
+                    if *provenance_b.get_or_insert(b) != b {
+                        throw_ub_format!(
+                            "type_id_eq: the second TypeId argument is invalid, the provenance of chunk {i} does not match the first chunk's"
+                        )
+                    }
+                    provenance_matches &= a == b;
 
-                if !eq_id && provenance_matches {
-                    throw_ub_format!(
-                        "type_id_eq: one of the TypeId arguments is invalid, the hash does not match the type it represents"
-                    )
+                    if offset_a != offset_b && provenance_matches {
+                        throw_ub_format!(
+                            "type_id_eq: one of the TypeId arguments is invalid, chunk {i} of the hash does not match the type it represents"
+                        )
+                    }
                 }
 
                 self.write_scalar(Scalar::from_bool(provenance_matches), dest)?;
diff --git a/tests/ui/consts/const_transmute_type_id3.rs b/tests/ui/consts/const_transmute_type_id3.rs
index ed5ff769701..f1bb8cddf77 100644
--- a/tests/ui/consts/const_transmute_type_id3.rs
+++ b/tests/ui/consts/const_transmute_type_id3.rs
@@ -1,3 +1,6 @@
+//! Test that all bytes of a TypeId must have the
+//! TypeId marker provenance.
+
 #![feature(const_type_id, const_trait_impl, const_cmp)]
 
 use std::any::TypeId;
@@ -10,7 +13,7 @@ const _: () = {
         std::ptr::write(ptr.offset(1), 999);
     }
     assert!(a == b);
-    //~^ ERROR: one of the TypeId arguments is invalid, the hash does not match the type it represents
+    //~^ ERROR: pointer must point to some allocation
 };
 
 fn main() {}
diff --git a/tests/ui/consts/const_transmute_type_id3.stderr b/tests/ui/consts/const_transmute_type_id3.stderr
index 8cfdcfebaa4..e731f496652 100644
--- a/tests/ui/consts/const_transmute_type_id3.stderr
+++ b/tests/ui/consts/const_transmute_type_id3.stderr
@@ -1,5 +1,5 @@
-error[E0080]: type_id_eq: one of the TypeId arguments is invalid, the hash does not match the type it represents
-  --> $DIR/const_transmute_type_id3.rs:12:13
+error[E0080]: pointer not dereferenceable: pointer must point to some allocation, but got 0x3e7[noalloc] which is a dangling pointer (it has no provenance)
+  --> $DIR/const_transmute_type_id3.rs:15:13
    |
 LL |     assert!(a == b);
    |             ^^^^^^ evaluation of `_` failed inside this call
diff --git a/tests/ui/consts/const_transmute_type_id5.rs b/tests/ui/consts/const_transmute_type_id5.rs
new file mode 100644
index 00000000000..0a9ba01e0dd
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id5.rs
@@ -0,0 +1,21 @@
+//! Test that we require an equal TypeId to have the same integer
+//! part, even if the provenance matches.
+
+#![feature(const_type_id, const_trait_impl, const_cmp)]
+
+use std::any::TypeId;
+
+const _: () = {
+    let a = TypeId::of::<()>();
+    let mut b = TypeId::of::<()>();
+    unsafe {
+        let ptr = &mut b as *mut TypeId as *mut *const ();
+        // Copy the ptr at index 0 to index 1
+        let val = std::ptr::read(ptr);
+        std::ptr::write(ptr.offset(1), val);
+    }
+    assert!(a == b);
+    //~^ ERROR: type_id_eq: one of the TypeId arguments is invalid, chunk 1 of the hash does not match the type it represents
+};
+
+fn main() {}
diff --git a/tests/ui/consts/const_transmute_type_id5.stderr b/tests/ui/consts/const_transmute_type_id5.stderr
new file mode 100644
index 00000000000..59823fcc1c9
--- /dev/null
+++ b/tests/ui/consts/const_transmute_type_id5.stderr
@@ -0,0 +1,15 @@
+error[E0080]: type_id_eq: one of the TypeId arguments is invalid, chunk 1 of the hash does not match the type it represents
+  --> $DIR/const_transmute_type_id5.rs:17:13
+   |
+LL |     assert!(a == b);
+   |             ^^^^^^ evaluation of `_` failed inside this call
+   |
+note: inside `<TypeId as PartialEq>::eq`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+note: inside `<TypeId as PartialEq>::eq::compiletime`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+   = note: this error originates in the macro `$crate::intrinsics::const_eval_select` which comes from the expansion of the macro `crate::intrinsics::const_eval_select` (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 E0080`.
-- 
cgit 1.4.1-3-g733a5


From 19fccacd4a58a63065443de9f68be921a8a6bcc6 Mon Sep 17 00:00:00 2001
From: "fuder.eth" <vtljgrinkiv@gmail.com>
Date: Sun, 13 Jul 2025 22:11:39 +0200
Subject: Update SUMMARY.md

Update README.md
---
 tests/mir-opt/pre-codegen/README.md | 2 +-
 tests/ui/SUMMARY.md                 | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/mir-opt/pre-codegen/README.md b/tests/mir-opt/pre-codegen/README.md
index a338c18e09e..f0598703cd9 100644
--- a/tests/mir-opt/pre-codegen/README.md
+++ b/tests/mir-opt/pre-codegen/README.md
@@ -1,3 +1,3 @@
-The goal of this directory is to track the quality of MIR that is given to codegen in a standard `-O` condiguration.
+The goal of this directory is to track the quality of MIR that is given to codegen in a standard `-O` configuration.
 
 As such, feel free to `--bless` whatever changes you get here, so long as doing so doesn't add substantially more MIR.
diff --git a/tests/ui/SUMMARY.md b/tests/ui/SUMMARY.md
index 8de74d41f39..1aeb0fcfbea 100644
--- a/tests/ui/SUMMARY.md
+++ b/tests/ui/SUMMARY.md
@@ -410,7 +410,7 @@ These tests revolve around command-line flags which change the way error/warning
 
 ## `tests/ui/diagnostic_namespace/`
 
-Exercises `#[diagnostic::*]` namespaced attributes. See [RFC 3368 Diagnostic attribute namepsace](https://github.com/rust-lang/rfcs/blob/master/text/3368-diagnostic-attribute-namespace.md).
+Exercises `#[diagnostic::*]` namespaced attributes. See [RFC 3368 Diagnostic attribute namespace](https://github.com/rust-lang/rfcs/blob/master/text/3368-diagnostic-attribute-namespace.md).
 
 ## `tests/ui/diagnostic-width/`: `--diagnostic-width`
 
-- 
cgit 1.4.1-3-g733a5


From 6598c61725abb0e8179b8a5fab7a0ed1f7fcaf5f Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Sat, 12 Jul 2025 15:28:50 +0000
Subject: rename `stable_mir` to `rustc_public`, and `rustc_smir` to
 `rustc_public_bridge`

---
 Cargo.lock                                         |   66 +-
 compiler/rustc/Cargo.toml                          |    8 +-
 compiler/rustc_driver_impl/Cargo.toml              |    2 +-
 compiler/rustc_driver_impl/src/pretty.rs           |    2 +-
 compiler/rustc_public/Cargo.toml                   |   24 +
 compiler/rustc_public/README.md                    |   46 +
 compiler/rustc_public/rust-toolchain.toml          |    3 +
 compiler/rustc_public/src/abi.rs                   |  493 ++++++
 compiler/rustc_public/src/alloc.rs                 |   76 +
 compiler/rustc_public/src/compiler_interface.rs    | 1099 +++++++++++++
 compiler/rustc_public/src/crate_def.rs             |  174 ++
 compiler/rustc_public/src/error.rs                 |   91 ++
 compiler/rustc_public/src/lib.rs                   |  302 ++++
 compiler/rustc_public/src/mir.rs                   |    8 +
 compiler/rustc_public/src/mir/alloc.rs             |   90 ++
 compiler/rustc_public/src/mir/body.rs              | 1127 +++++++++++++
 compiler/rustc_public/src/mir/mono.rs              |  305 ++++
 compiler/rustc_public/src/mir/pretty.rs            |  469 ++++++
 compiler/rustc_public/src/mir/visit.rs             |  588 +++++++
 compiler/rustc_public/src/rustc_internal/mod.rs    |  270 ++++
 compiler/rustc_public/src/rustc_internal/pretty.rs |   21 +
 compiler/rustc_public/src/target.rs                |   60 +
 compiler/rustc_public/src/ty.rs                    | 1655 ++++++++++++++++++++
 .../rustc_public/src/unstable/convert/internal.rs  |  823 ++++++++++
 compiler/rustc_public/src/unstable/convert/mod.rs  |  110 ++
 .../src/unstable/convert/stable/abi.rs             |  410 +++++
 .../src/unstable/convert/stable/mir.rs             |  936 +++++++++++
 .../src/unstable/convert/stable/mod.rs             |   95 ++
 .../rustc_public/src/unstable/convert/stable/ty.rs | 1139 ++++++++++++++
 .../rustc_public/src/unstable/internal_cx/mod.rs   |   93 ++
 .../src/unstable/internal_cx/traits.rs             |   31 +
 compiler/rustc_public/src/unstable/mod.rs          |  124 ++
 compiler/rustc_public/src/visitor.rs               |  224 +++
 compiler/rustc_public_bridge/.gitignore            |    1 +
 compiler/rustc_public_bridge/Cargo.toml            |   16 +
 compiler/rustc_public_bridge/src/alloc.rs          |  101 ++
 compiler/rustc_public_bridge/src/bridge.rs         |   59 +
 compiler/rustc_public_bridge/src/builder.rs        |   77 +
 compiler/rustc_public_bridge/src/context/impls.rs  |  759 +++++++++
 compiler/rustc_public_bridge/src/context/mod.rs    |   79 +
 compiler/rustc_public_bridge/src/context/traits.rs |   21 +
 compiler/rustc_public_bridge/src/lib.rs            |  305 ++++
 compiler/rustc_smir/.gitignore                     |    1 -
 compiler/rustc_smir/Cargo.toml                     |   16 -
 compiler/rustc_smir/src/alloc.rs                   |  101 --
 compiler/rustc_smir/src/bridge.rs                  |   59 -
 compiler/rustc_smir/src/builder.rs                 |   77 -
 compiler/rustc_smir/src/context/impls.rs           |  759 ---------
 compiler/rustc_smir/src/context/mod.rs             |   79 -
 compiler/rustc_smir/src/context/traits.rs          |   21 -
 compiler/rustc_smir/src/lib.rs                     |  305 ----
 compiler/stable_mir/Cargo.toml                     |   24 -
 compiler/stable_mir/README.md                      |   46 -
 compiler/stable_mir/rust-toolchain.toml            |    3 -
 compiler/stable_mir/src/abi.rs                     |  493 ------
 compiler/stable_mir/src/alloc.rs                   |   76 -
 compiler/stable_mir/src/compiler_interface.rs      | 1099 -------------
 compiler/stable_mir/src/crate_def.rs               |  174 --
 compiler/stable_mir/src/error.rs                   |   91 --
 compiler/stable_mir/src/lib.rs                     |  300 ----
 compiler/stable_mir/src/mir.rs                     |    8 -
 compiler/stable_mir/src/mir/alloc.rs               |   90 --
 compiler/stable_mir/src/mir/body.rs                | 1127 -------------
 compiler/stable_mir/src/mir/mono.rs                |  305 ----
 compiler/stable_mir/src/mir/pretty.rs              |  469 ------
 compiler/stable_mir/src/mir/visit.rs               |  588 -------
 compiler/stable_mir/src/rustc_internal/mod.rs      |  270 ----
 compiler/stable_mir/src/rustc_internal/pretty.rs   |   21 -
 compiler/stable_mir/src/target.rs                  |   60 -
 compiler/stable_mir/src/ty.rs                      | 1655 --------------------
 .../stable_mir/src/unstable/convert/internal.rs    |  823 ----------
 compiler/stable_mir/src/unstable/convert/mod.rs    |  110 --
 .../stable_mir/src/unstable/convert/stable/abi.rs  |  410 -----
 .../stable_mir/src/unstable/convert/stable/mir.rs  |  936 -----------
 .../stable_mir/src/unstable/convert/stable/mod.rs  |   95 --
 .../stable_mir/src/unstable/convert/stable/ty.rs   | 1139 --------------
 .../stable_mir/src/unstable/internal_cx/mod.rs     |   93 --
 .../stable_mir/src/unstable/internal_cx/traits.rs  |   31 -
 compiler/stable_mir/src/unstable/mod.rs            |  124 --
 compiler/stable_mir/src/visitor.rs                 |  224 ---
 src/bootstrap/src/core/build_steps/compile.rs      |    6 +-
 tests/ui-fulldeps/stable-mir/check_abi.rs          |   22 +-
 tests/ui-fulldeps/stable-mir/check_allocation.rs   |   20 +-
 tests/ui-fulldeps/stable-mir/check_assoc_items.rs  |    8 +-
 tests/ui-fulldeps/stable-mir/check_attribute.rs    |    8 +-
 tests/ui-fulldeps/stable-mir/check_binop.rs        |   12 +-
 .../ui-fulldeps/stable-mir/check_coroutine_body.rs |    8 +-
 tests/ui-fulldeps/stable-mir/check_crate_defs.rs   |    8 +-
 tests/ui-fulldeps/stable-mir/check_def_ty.rs       |   10 +-
 tests/ui-fulldeps/stable-mir/check_defs.rs         |   10 +-
 tests/ui-fulldeps/stable-mir/check_foreign.rs      |    4 +-
 tests/ui-fulldeps/stable-mir/check_instance.rs     |    8 +-
 tests/ui-fulldeps/stable-mir/check_intrinsics.rs   |   12 +-
 tests/ui-fulldeps/stable-mir/check_item_kind.rs    |    6 +-
 .../ui-fulldeps/stable-mir/check_normalization.rs  |    6 +-
 .../ui-fulldeps/stable-mir/check_trait_queries.rs  |   10 +-
 tests/ui-fulldeps/stable-mir/check_transform.rs    |   16 +-
 tests/ui-fulldeps/stable-mir/check_ty_fold.rs      |    8 +-
 tests/ui-fulldeps/stable-mir/check_variant.rs      |   12 +-
 .../ui-fulldeps/stable-mir/closure-generic-body.rs |    8 +-
 tests/ui-fulldeps/stable-mir/closure_body.rs       |    8 +-
 tests/ui-fulldeps/stable-mir/compilation-result.rs |    8 +-
 tests/ui-fulldeps/stable-mir/crate-info.rs         |   68 +-
 tests/ui-fulldeps/stable-mir/projections.rs        |   32 +-
 tests/ui-fulldeps/stable-mir/smir_internal.rs      |    6 +-
 tests/ui-fulldeps/stable-mir/smir_serde.rs         |    8 +-
 tests/ui-fulldeps/stable-mir/smir_visitor.rs       |   12 +-
 triagebot.toml                                     |    8 +-
 108 files changed, 12523 insertions(+), 12513 deletions(-)
 create mode 100644 compiler/rustc_public/Cargo.toml
 create mode 100644 compiler/rustc_public/README.md
 create mode 100644 compiler/rustc_public/rust-toolchain.toml
 create mode 100644 compiler/rustc_public/src/abi.rs
 create mode 100644 compiler/rustc_public/src/alloc.rs
 create mode 100644 compiler/rustc_public/src/compiler_interface.rs
 create mode 100644 compiler/rustc_public/src/crate_def.rs
 create mode 100644 compiler/rustc_public/src/error.rs
 create mode 100644 compiler/rustc_public/src/lib.rs
 create mode 100644 compiler/rustc_public/src/mir.rs
 create mode 100644 compiler/rustc_public/src/mir/alloc.rs
 create mode 100644 compiler/rustc_public/src/mir/body.rs
 create mode 100644 compiler/rustc_public/src/mir/mono.rs
 create mode 100644 compiler/rustc_public/src/mir/pretty.rs
 create mode 100644 compiler/rustc_public/src/mir/visit.rs
 create mode 100644 compiler/rustc_public/src/rustc_internal/mod.rs
 create mode 100644 compiler/rustc_public/src/rustc_internal/pretty.rs
 create mode 100644 compiler/rustc_public/src/target.rs
 create mode 100644 compiler/rustc_public/src/ty.rs
 create mode 100644 compiler/rustc_public/src/unstable/convert/internal.rs
 create mode 100644 compiler/rustc_public/src/unstable/convert/mod.rs
 create mode 100644 compiler/rustc_public/src/unstable/convert/stable/abi.rs
 create mode 100644 compiler/rustc_public/src/unstable/convert/stable/mir.rs
 create mode 100644 compiler/rustc_public/src/unstable/convert/stable/mod.rs
 create mode 100644 compiler/rustc_public/src/unstable/convert/stable/ty.rs
 create mode 100644 compiler/rustc_public/src/unstable/internal_cx/mod.rs
 create mode 100644 compiler/rustc_public/src/unstable/internal_cx/traits.rs
 create mode 100644 compiler/rustc_public/src/unstable/mod.rs
 create mode 100644 compiler/rustc_public/src/visitor.rs
 create mode 100644 compiler/rustc_public_bridge/.gitignore
 create mode 100644 compiler/rustc_public_bridge/Cargo.toml
 create mode 100644 compiler/rustc_public_bridge/src/alloc.rs
 create mode 100644 compiler/rustc_public_bridge/src/bridge.rs
 create mode 100644 compiler/rustc_public_bridge/src/builder.rs
 create mode 100644 compiler/rustc_public_bridge/src/context/impls.rs
 create mode 100644 compiler/rustc_public_bridge/src/context/mod.rs
 create mode 100644 compiler/rustc_public_bridge/src/context/traits.rs
 create mode 100644 compiler/rustc_public_bridge/src/lib.rs
 delete mode 100644 compiler/rustc_smir/.gitignore
 delete mode 100644 compiler/rustc_smir/Cargo.toml
 delete mode 100644 compiler/rustc_smir/src/alloc.rs
 delete mode 100644 compiler/rustc_smir/src/bridge.rs
 delete mode 100644 compiler/rustc_smir/src/builder.rs
 delete mode 100644 compiler/rustc_smir/src/context/impls.rs
 delete mode 100644 compiler/rustc_smir/src/context/mod.rs
 delete mode 100644 compiler/rustc_smir/src/context/traits.rs
 delete mode 100644 compiler/rustc_smir/src/lib.rs
 delete mode 100644 compiler/stable_mir/Cargo.toml
 delete mode 100644 compiler/stable_mir/README.md
 delete mode 100644 compiler/stable_mir/rust-toolchain.toml
 delete mode 100644 compiler/stable_mir/src/abi.rs
 delete mode 100644 compiler/stable_mir/src/alloc.rs
 delete mode 100644 compiler/stable_mir/src/compiler_interface.rs
 delete mode 100644 compiler/stable_mir/src/crate_def.rs
 delete mode 100644 compiler/stable_mir/src/error.rs
 delete mode 100644 compiler/stable_mir/src/lib.rs
 delete mode 100644 compiler/stable_mir/src/mir.rs
 delete mode 100644 compiler/stable_mir/src/mir/alloc.rs
 delete mode 100644 compiler/stable_mir/src/mir/body.rs
 delete mode 100644 compiler/stable_mir/src/mir/mono.rs
 delete mode 100644 compiler/stable_mir/src/mir/pretty.rs
 delete mode 100644 compiler/stable_mir/src/mir/visit.rs
 delete mode 100644 compiler/stable_mir/src/rustc_internal/mod.rs
 delete mode 100644 compiler/stable_mir/src/rustc_internal/pretty.rs
 delete mode 100644 compiler/stable_mir/src/target.rs
 delete mode 100644 compiler/stable_mir/src/ty.rs
 delete mode 100644 compiler/stable_mir/src/unstable/convert/internal.rs
 delete mode 100644 compiler/stable_mir/src/unstable/convert/mod.rs
 delete mode 100644 compiler/stable_mir/src/unstable/convert/stable/abi.rs
 delete mode 100644 compiler/stable_mir/src/unstable/convert/stable/mir.rs
 delete mode 100644 compiler/stable_mir/src/unstable/convert/stable/mod.rs
 delete mode 100644 compiler/stable_mir/src/unstable/convert/stable/ty.rs
 delete mode 100644 compiler/stable_mir/src/unstable/internal_cx/mod.rs
 delete mode 100644 compiler/stable_mir/src/unstable/internal_cx/traits.rs
 delete mode 100644 compiler/stable_mir/src/unstable/mod.rs
 delete mode 100644 compiler/stable_mir/src/visitor.rs

diff --git a/Cargo.lock b/Cargo.lock
index a6c36b4bdfa..d5357ac4758 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3271,8 +3271,8 @@ dependencies = [
  "rustc_codegen_ssa",
  "rustc_driver",
  "rustc_driver_impl",
- "rustc_smir",
- "stable_mir",
+ "rustc_public",
+ "rustc_public_bridge",
  "tikv-jemalloc-sys",
 ]
 
@@ -3709,6 +3709,7 @@ dependencies = [
  "rustc_passes",
  "rustc_pattern_analysis",
  "rustc_privacy",
+ "rustc_public",
  "rustc_query_system",
  "rustc_resolve",
  "rustc_session",
@@ -3718,7 +3719,6 @@ dependencies = [
  "rustc_ty_utils",
  "serde_json",
  "shlex",
- "stable_mir",
  "tracing",
  "windows 0.61.3",
 ]
@@ -4415,6 +4415,36 @@ dependencies = [
  "rustc-literal-escaper",
 ]
 
+[[package]]
+name = "rustc_public"
+version = "0.1.0-preview"
+dependencies = [
+ "rustc_abi",
+ "rustc_hir",
+ "rustc_middle",
+ "rustc_public_bridge",
+ "rustc_session",
+ "rustc_span",
+ "rustc_target",
+ "scoped-tls",
+ "serde",
+ "tracing",
+]
+
+[[package]]
+name = "rustc_public_bridge"
+version = "0.0.0"
+dependencies = [
+ "rustc_abi",
+ "rustc_data_structures",
+ "rustc_hir",
+ "rustc_hir_pretty",
+ "rustc_middle",
+ "rustc_session",
+ "rustc_span",
+ "rustc_target",
+]
+
 [[package]]
 name = "rustc_query_impl"
 version = "0.0.0"
@@ -4542,20 +4572,6 @@ dependencies = [
  "windows 0.61.3",
 ]
 
-[[package]]
-name = "rustc_smir"
-version = "0.0.0"
-dependencies = [
- "rustc_abi",
- "rustc_data_structures",
- "rustc_hir",
- "rustc_hir_pretty",
- "rustc_middle",
- "rustc_session",
- "rustc_span",
- "rustc_target",
-]
-
 [[package]]
 name = "rustc_span"
 version = "0.0.0"
@@ -5103,22 +5119,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
-[[package]]
-name = "stable_mir"
-version = "0.1.0-preview"
-dependencies = [
- "rustc_abi",
- "rustc_hir",
- "rustc_middle",
- "rustc_session",
- "rustc_smir",
- "rustc_span",
- "rustc_target",
- "scoped-tls",
- "serde",
- "tracing",
-]
-
 [[package]]
 name = "stacker"
 version = "0.1.21"
diff --git a/compiler/rustc/Cargo.toml b/compiler/rustc/Cargo.toml
index 99414d6264e..3ca75235446 100644
--- a/compiler/rustc/Cargo.toml
+++ b/compiler/rustc/Cargo.toml
@@ -13,11 +13,11 @@ rustc_codegen_ssa = { path = "../rustc_codegen_ssa" }
 rustc_driver = { path = "../rustc_driver" }
 rustc_driver_impl = { path = "../rustc_driver_impl" }
 
-# Make sure rustc_smir ends up in the sysroot, because this
-# crate is intended to be used by stable MIR consumers, which are not in-tree.
-rustc_smir = { path = "../rustc_smir" }
+rustc_public = { path = "../rustc_public" }
 
-stable_mir = { path = "../stable_mir" }
+# Make sure rustc_public_bridge ends up in the sysroot, because this
+# crate is intended to be used by stable MIR consumers, which are not in-tree.
+rustc_public_bridge = { path = "../rustc_public_bridge" }
 # tidy-alphabetical-end
 
 [dependencies.tikv-jemalloc-sys]
diff --git a/compiler/rustc_driver_impl/Cargo.toml b/compiler/rustc_driver_impl/Cargo.toml
index ce26aa449d9..0d6b49607eb 100644
--- a/compiler/rustc_driver_impl/Cargo.toml
+++ b/compiler/rustc_driver_impl/Cargo.toml
@@ -41,6 +41,7 @@ rustc_parse = { path = "../rustc_parse" }
 rustc_passes = { path = "../rustc_passes" }
 rustc_pattern_analysis = { path = "../rustc_pattern_analysis" }
 rustc_privacy = { path = "../rustc_privacy" }
+rustc_public = { path = "../rustc_public", features = ["rustc_internal"] }
 rustc_query_system = { path = "../rustc_query_system" }
 rustc_resolve = { path = "../rustc_resolve" }
 rustc_session = { path = "../rustc_session" }
@@ -50,7 +51,6 @@ rustc_trait_selection = { path = "../rustc_trait_selection" }
 rustc_ty_utils = { path = "../rustc_ty_utils" }
 serde_json = "1.0.59"
 shlex = "1.0"
-stable_mir = { path = "../stable_mir", features = ["rustc_internal"] }
 tracing = { version = "0.1.35" }
 # tidy-alphabetical-end
 
diff --git a/compiler/rustc_driver_impl/src/pretty.rs b/compiler/rustc_driver_impl/src/pretty.rs
index 688307a941f..1604b704033 100644
--- a/compiler/rustc_driver_impl/src/pretty.rs
+++ b/compiler/rustc_driver_impl/src/pretty.rs
@@ -8,10 +8,10 @@ use rustc_middle::bug;
 use rustc_middle::mir::{write_mir_graphviz, write_mir_pretty};
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_mir_build::thir::print::{thir_flat, thir_tree};
+use rustc_public::rustc_internal::pretty::write_smir_pretty;
 use rustc_session::Session;
 use rustc_session::config::{OutFileName, PpHirMode, PpMode, PpSourceMode};
 use rustc_span::{FileName, Ident};
-use stable_mir::rustc_internal::pretty::write_smir_pretty;
 use tracing::debug;
 use {rustc_ast as ast, rustc_hir_pretty as pprust_hir};
 
diff --git a/compiler/rustc_public/Cargo.toml b/compiler/rustc_public/Cargo.toml
new file mode 100644
index 00000000000..fa782166e4f
--- /dev/null
+++ b/compiler/rustc_public/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "rustc_public"
+version = "0.1.0-preview"
+edition = "2024"
+
+[dependencies]
+# tidy-alphabetical-start
+rustc_abi = { path = "../rustc_abi" }
+rustc_hir = { path = "../rustc_hir" }
+rustc_middle = { path = "../rustc_middle" }
+rustc_public_bridge = { path = "../rustc_public_bridge" }
+rustc_session = { path = "../rustc_session" }
+rustc_span = { path = "../rustc_span" }
+rustc_target = { path = "../rustc_target" }
+scoped-tls = "1.0"
+serde = { version = "1.0.125", features = [ "derive" ] }
+tracing = "0.1"
+# tidy-alphabetical-end
+
+[features]
+# Provides access to APIs that expose internals of the rust compiler.
+# APIs enabled by this feature are unstable. They can be removed or modified
+# at any point and they are not included in the crate's semantic versioning.
+rustc_internal = []
diff --git a/compiler/rustc_public/README.md b/compiler/rustc_public/README.md
new file mode 100644
index 00000000000..ab2546e377a
--- /dev/null
+++ b/compiler/rustc_public/README.md
@@ -0,0 +1,46 @@
+This crate is currently developed in-tree together with the compiler.
+
+Our goal is to start publishing `stable_mir` into crates.io.
+Until then, users will use this as any other rustc crate, by installing
+the rustup component `rustc-dev`, and declaring `stable-mir` as an external crate.
+
+See the StableMIR ["Getting Started"](https://rust-lang.github.io/project-stable-mir/getting-started.html)
+guide for more information.
+
+## Stable MIR Design
+
+The stable-mir will follow a similar approach to proc-macro2. Its
+implementation is split between two main crates:
+
+- `stable_mir`: Public crate, to be published on crates.io, which will contain
+the stable data structure as well as calls to `rustc_smir` APIs. The
+translation between stable and internal constructs will also be done in this crate,
+however, this is currently implemented in the `rustc_smir` crate.[^translation].
+- `rustc_smir`: This crate implements the public APIs to the compiler.
+It is responsible for gathering all the information requested, and providing
+the data in its unstable form.
+
+[^translation]: This is currently implemented in the `rustc_smir` crate,
+but we are working to change that.
+
+I.e.,
+tools will depend on `stable_mir` crate,
+which will invoke the compiler using APIs defined in `rustc_smir`.
+
+I.e.:
+
+```
+    ┌──────────────────────────────────┐           ┌──────────────────────────────────┐
+    │   External Tool     ┌──────────┐ │           │ ┌──────────┐   Rust Compiler     │
+    │                     │          │ │           │ │          │                     │
+    │                     │stable_mir| │           │ │rustc_smir│                     │
+    │                     │          │ ├──────────►| │          │                     │
+    │                     │          │ │◄──────────┤ │          │                     │
+    │                     │          │ │           │ │          │                     │
+    │                     │          │ │           │ │          │                     │
+    │                     └──────────┘ │           │ └──────────┘                     │
+    └──────────────────────────────────┘           └──────────────────────────────────┘
+```
+
+More details can be found here:
+https://hackmd.io/XhnYHKKuR6-LChhobvlT-g?view
diff --git a/compiler/rustc_public/rust-toolchain.toml b/compiler/rustc_public/rust-toolchain.toml
new file mode 100644
index 00000000000..d75e8e33b1c
--- /dev/null
+++ b/compiler/rustc_public/rust-toolchain.toml
@@ -0,0 +1,3 @@
+[toolchain]
+channel = "nightly-2023-06-14"
+components = [ "rustfmt", "rustc-dev" ]
diff --git a/compiler/rustc_public/src/abi.rs b/compiler/rustc_public/src/abi.rs
new file mode 100644
index 00000000000..7b0882caf1b
--- /dev/null
+++ b/compiler/rustc_public/src/abi.rs
@@ -0,0 +1,493 @@
+use std::fmt::{self, Debug};
+use std::num::NonZero;
+use std::ops::RangeInclusive;
+
+use serde::Serialize;
+
+use crate::compiler_interface::with;
+use crate::mir::FieldIdx;
+use crate::target::{MachineInfo, MachineSize as Size};
+use crate::ty::{Align, Ty, VariantIdx};
+use crate::{Error, Opaque, error};
+
+/// A function ABI definition.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub struct FnAbi {
+    /// The types of each argument.
+    pub args: Vec<ArgAbi>,
+
+    /// The expected return type.
+    pub ret: ArgAbi,
+
+    /// The count of non-variadic arguments.
+    ///
+    /// Should only be different from `args.len()` when a function is a C variadic function.
+    pub fixed_count: u32,
+
+    /// The ABI convention.
+    pub conv: CallConvention,
+
+    /// Whether this is a variadic C function,
+    pub c_variadic: bool,
+}
+
+/// Information about the ABI of a function's argument, or return value.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub struct ArgAbi {
+    pub ty: Ty,
+    pub layout: Layout,
+    pub mode: PassMode,
+}
+
+/// How a function argument should be passed in to the target function.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub enum PassMode {
+    /// Ignore the argument.
+    ///
+    /// The argument is either uninhabited or a ZST.
+    Ignore,
+    /// Pass the argument directly.
+    ///
+    /// The argument has a layout abi of `Scalar` or `Vector`.
+    Direct(Opaque),
+    /// Pass a pair's elements directly in two arguments.
+    ///
+    /// The argument has a layout abi of `ScalarPair`.
+    Pair(Opaque, Opaque),
+    /// Pass the argument after casting it.
+    Cast { pad_i32: bool, cast: Opaque },
+    /// Pass the argument indirectly via a hidden pointer.
+    Indirect { attrs: Opaque, meta_attrs: Opaque, on_stack: bool },
+}
+
+/// The layout of a type, alongside the type itself.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub struct TyAndLayout {
+    pub ty: Ty,
+    pub layout: Layout,
+}
+
+/// The layout of a type in memory.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub struct LayoutShape {
+    /// The fields location within the layout
+    pub fields: FieldsShape,
+
+    /// Encodes information about multi-variant layouts.
+    /// Even with `Multiple` variants, a layout still has its own fields! Those are then
+    /// shared between all variants.
+    ///
+    /// To access all fields of this layout, both `fields` and the fields of the active variant
+    /// must be taken into account.
+    pub variants: VariantsShape,
+
+    /// The `abi` defines how this data is passed between functions.
+    pub abi: ValueAbi,
+
+    /// The ABI mandated alignment in bytes.
+    pub abi_align: Align,
+
+    /// The size of this layout in bytes.
+    pub size: Size,
+}
+
+impl LayoutShape {
+    /// Returns `true` if the layout corresponds to an unsized type.
+    #[inline]
+    pub fn is_unsized(&self) -> bool {
+        self.abi.is_unsized()
+    }
+
+    #[inline]
+    pub fn is_sized(&self) -> bool {
+        !self.abi.is_unsized()
+    }
+
+    /// Returns `true` if the type is sized and a 1-ZST (meaning it has size 0 and alignment 1).
+    pub fn is_1zst(&self) -> bool {
+        self.is_sized() && self.size.bits() == 0 && self.abi_align == 1
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub struct Layout(usize);
+
+impl Layout {
+    pub fn shape(self) -> LayoutShape {
+        with(|cx| cx.layout_shape(self))
+    }
+}
+
+impl crate::IndexedVal for Layout {
+    fn to_val(index: usize) -> Self {
+        Layout(index)
+    }
+    fn to_index(&self) -> usize {
+        self.0
+    }
+}
+
+/// Describes how the fields of a type are shaped in memory.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub enum FieldsShape {
+    /// Scalar primitives and `!`, which never have fields.
+    Primitive,
+
+    /// All fields start at no offset. The `usize` is the field count.
+    Union(NonZero<usize>),
+
+    /// Array/vector-like placement, with all fields of identical types.
+    Array { stride: Size, count: u64 },
+
+    /// Struct-like placement, with precomputed offsets.
+    ///
+    /// Fields are guaranteed to not overlap, but note that gaps
+    /// before, between and after all the fields are NOT always
+    /// padding, and as such their contents may not be discarded.
+    /// For example, enum variants leave a gap at the start,
+    /// where the discriminant field in the enum layout goes.
+    Arbitrary {
+        /// Offsets for the first byte of each field,
+        /// ordered to match the source definition order.
+        /// I.e.: It follows the same order as [super::ty::VariantDef::fields()].
+        /// This vector does not go in increasing order.
+        offsets: Vec<Size>,
+    },
+}
+
+impl FieldsShape {
+    pub fn fields_by_offset_order(&self) -> Vec<FieldIdx> {
+        match self {
+            FieldsShape::Primitive => vec![],
+            FieldsShape::Union(_) | FieldsShape::Array { .. } => (0..self.count()).collect(),
+            FieldsShape::Arbitrary { offsets, .. } => {
+                let mut indices = (0..offsets.len()).collect::<Vec<_>>();
+                indices.sort_by_key(|idx| offsets[*idx]);
+                indices
+            }
+        }
+    }
+
+    pub fn count(&self) -> usize {
+        match self {
+            FieldsShape::Primitive => 0,
+            FieldsShape::Union(count) => count.get(),
+            FieldsShape::Array { count, .. } => *count as usize,
+            FieldsShape::Arbitrary { offsets, .. } => offsets.len(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub enum VariantsShape {
+    /// A type with no valid variants. Must be uninhabited.
+    Empty,
+
+    /// Single enum variants, structs/tuples, unions, and all non-ADTs.
+    Single { index: VariantIdx },
+
+    /// Enum-likes with more than one inhabited variant: each variant comes with
+    /// a *discriminant* (usually the same as the variant index but the user can
+    /// assign explicit discriminant values). That discriminant is encoded
+    /// as a *tag* on the machine. The layout of each variant is
+    /// a struct, and they all have space reserved for the tag.
+    /// For enums, the tag is the sole field of the layout.
+    Multiple {
+        tag: Scalar,
+        tag_encoding: TagEncoding,
+        tag_field: usize,
+        variants: Vec<LayoutShape>,
+    },
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub enum TagEncoding {
+    /// The tag directly stores the discriminant, but possibly with a smaller layout
+    /// (so converting the tag to the discriminant can require sign extension).
+    Direct,
+
+    /// Niche (values invalid for a type) encoding the discriminant:
+    /// Discriminant and variant index coincide.
+    /// The variant `untagged_variant` contains a niche at an arbitrary
+    /// offset (field `tag_field` of the enum), which for a variant with
+    /// discriminant `d` is set to
+    /// `(d - niche_variants.start).wrapping_add(niche_start)`.
+    ///
+    /// For example, `Option<(usize, &T)>`  is represented such that
+    /// `None` has a null pointer for the second tuple field, and
+    /// `Some` is the identity function (with a non-null reference).
+    Niche {
+        untagged_variant: VariantIdx,
+        niche_variants: RangeInclusive<VariantIdx>,
+        niche_start: u128,
+    },
+}
+
+/// Describes how values of the type are passed by target ABIs,
+/// in terms of categories of C types there are ABI rules for.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub enum ValueAbi {
+    Scalar(Scalar),
+    ScalarPair(Scalar, Scalar),
+    Vector {
+        element: Scalar,
+        count: u64,
+    },
+    Aggregate {
+        /// If true, the size is exact, otherwise it's only a lower bound.
+        sized: bool,
+    },
+}
+
+impl ValueAbi {
+    /// Returns `true` if the layout corresponds to an unsized type.
+    pub fn is_unsized(&self) -> bool {
+        match *self {
+            ValueAbi::Scalar(_) | ValueAbi::ScalarPair(..) | ValueAbi::Vector { .. } => false,
+            ValueAbi::Aggregate { sized } => !sized,
+        }
+    }
+}
+
+/// Information about one scalar component of a Rust type.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Serialize)]
+pub enum Scalar {
+    Initialized {
+        /// The primitive type used to represent this value.
+        value: Primitive,
+        /// The range that represents valid values.
+        /// The range must be valid for the `primitive` size.
+        valid_range: WrappingRange,
+    },
+    Union {
+        /// Unions never have niches, so there is no `valid_range`.
+        /// Even for unions, we need to use the correct registers for the kind of
+        /// values inside the union, so we keep the `Primitive` type around.
+        /// It is also used to compute the size of the scalar.
+        value: Primitive,
+    },
+}
+
+impl Scalar {
+    pub fn has_niche(&self, target: &MachineInfo) -> bool {
+        match self {
+            Scalar::Initialized { value, valid_range } => {
+                !valid_range.is_full(value.size(target)).unwrap()
+            }
+            Scalar::Union { .. } => false,
+        }
+    }
+}
+
+/// Fundamental unit of memory access and layout.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Serialize)]
+pub enum Primitive {
+    /// The `bool` is the signedness of the `Integer` type.
+    ///
+    /// One would think we would not care about such details this low down,
+    /// but some ABIs are described in terms of C types and ISAs where the
+    /// integer arithmetic is done on {sign,zero}-extended registers, e.g.
+    /// a negative integer passed by zero-extension will appear positive in
+    /// the callee, and most operations on it will produce the wrong values.
+    Int {
+        length: IntegerLength,
+        signed: bool,
+    },
+    Float {
+        length: FloatLength,
+    },
+    Pointer(AddressSpace),
+}
+
+impl Primitive {
+    pub fn size(self, target: &MachineInfo) -> Size {
+        match self {
+            Primitive::Int { length, .. } => Size::from_bits(length.bits()),
+            Primitive::Float { length } => Size::from_bits(length.bits()),
+            Primitive::Pointer(_) => target.pointer_width,
+        }
+    }
+}
+
+/// Enum representing the existing integer lengths.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
+pub enum IntegerLength {
+    I8,
+    I16,
+    I32,
+    I64,
+    I128,
+}
+
+/// Enum representing the existing float lengths.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
+pub enum FloatLength {
+    F16,
+    F32,
+    F64,
+    F128,
+}
+
+impl IntegerLength {
+    pub fn bits(self) -> usize {
+        match self {
+            IntegerLength::I8 => 8,
+            IntegerLength::I16 => 16,
+            IntegerLength::I32 => 32,
+            IntegerLength::I64 => 64,
+            IntegerLength::I128 => 128,
+        }
+    }
+}
+
+impl FloatLength {
+    pub fn bits(self) -> usize {
+        match self {
+            FloatLength::F16 => 16,
+            FloatLength::F32 => 32,
+            FloatLength::F64 => 64,
+            FloatLength::F128 => 128,
+        }
+    }
+}
+
+/// An identifier that specifies the address space that some operation
+/// should operate on. Special address spaces have an effect on code generation,
+/// depending on the target and the address spaces it implements.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
+pub struct AddressSpace(pub u32);
+
+impl AddressSpace {
+    /// The default address space, corresponding to data space.
+    pub const DATA: Self = AddressSpace(0);
+}
+
+/// Inclusive wrap-around range of valid values (bitwise representation), that is, if
+/// start > end, it represents `start..=MAX`, followed by `0..=end`.
+///
+/// That is, for an i8 primitive, a range of `254..=2` means following
+/// sequence:
+///
+///    254 (-2), 255 (-1), 0, 1, 2
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize)]
+pub struct WrappingRange {
+    pub start: u128,
+    pub end: u128,
+}
+
+impl WrappingRange {
+    /// Returns `true` if `size` completely fills the range.
+    #[inline]
+    pub fn is_full(&self, size: Size) -> Result<bool, Error> {
+        let Some(max_value) = size.unsigned_int_max() else {
+            return Err(error!("Expected size <= 128 bits, but found {} instead", size.bits()));
+        };
+        if self.start <= max_value && self.end <= max_value {
+            Ok(self.start == (self.end.wrapping_add(1) & max_value))
+        } else {
+            Err(error!("Range `{self:?}` out of bounds for size `{}` bits.", size.bits()))
+        }
+    }
+
+    /// Returns `true` if `v` is contained in the range.
+    #[inline(always)]
+    pub fn contains(&self, v: u128) -> bool {
+        if self.wraps_around() {
+            self.start <= v || v <= self.end
+        } else {
+            self.start <= v && v <= self.end
+        }
+    }
+
+    /// Returns `true` if the range wraps around.
+    /// I.e., the range represents the union of `self.start..=MAX` and `0..=self.end`.
+    /// Returns `false` if this is a non-wrapping range, i.e.: `self.start..=self.end`.
+    #[inline]
+    pub fn wraps_around(&self) -> bool {
+        self.start > self.end
+    }
+}
+
+impl Debug for WrappingRange {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.start > self.end {
+            write!(fmt, "(..={}) | ({}..)", self.end, self.start)?;
+        } else {
+            write!(fmt, "{}..={}", self.start, self.end)?;
+        }
+        Ok(())
+    }
+}
+
+/// General language calling conventions.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub enum CallConvention {
+    C,
+    Rust,
+
+    Cold,
+    PreserveMost,
+    PreserveAll,
+
+    Custom,
+
+    // Target-specific calling conventions.
+    ArmAapcs,
+    CCmseNonSecureCall,
+    CCmseNonSecureEntry,
+
+    Msp430Intr,
+
+    PtxKernel,
+
+    GpuKernel,
+
+    X86Fastcall,
+    X86Intr,
+    X86Stdcall,
+    X86ThisCall,
+    X86VectorCall,
+
+    X86_64SysV,
+    X86_64Win64,
+
+    AvrInterrupt,
+    AvrNonBlockingInterrupt,
+
+    RiscvInterrupt,
+}
+
+#[non_exhaustive]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
+pub struct ReprFlags {
+    pub is_simd: bool,
+    pub is_c: bool,
+    pub is_transparent: bool,
+    pub is_linear: bool,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
+pub enum IntegerType {
+    /// Pointer-sized integer type, i.e. `isize` and `usize`.
+    Pointer {
+        /// Signedness. e.g. `true` for `isize`
+        is_signed: bool,
+    },
+    /// Fixed-sized integer type, e.g. `i8`, `u32`, `i128`.
+    Fixed {
+        /// Length of this integer type. e.g. `IntegerLength::I8` for `u8`.
+        length: IntegerLength,
+        /// Signedness. e.g. `false` for `u8`
+        is_signed: bool,
+    },
+}
+
+/// Representation options provided by the user
+#[non_exhaustive]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
+pub struct ReprOptions {
+    pub int: Option<IntegerType>,
+    pub align: Option<Align>,
+    pub pack: Option<Align>,
+    pub flags: ReprFlags,
+}
diff --git a/compiler/rustc_public/src/alloc.rs b/compiler/rustc_public/src/alloc.rs
new file mode 100644
index 00000000000..d2db6c08bbc
--- /dev/null
+++ b/compiler/rustc_public/src/alloc.rs
@@ -0,0 +1,76 @@
+//! Memory allocation implementation for StableMIR.
+//!
+//! This module is responsible for constructing stable components.
+//! All operations requiring rustc queries must be delegated
+//! to `rustc_public_bridge::alloc` to maintain stability guarantees.
+
+use rustc_abi::Align;
+use rustc_middle::mir::ConstValue;
+use rustc_middle::mir::interpret::AllocRange;
+use rustc_public_bridge::bridge::SmirError;
+use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::{Tables, alloc};
+
+use super::Error;
+use super::compiler_interface::BridgeTys;
+use super::mir::Mutability;
+use super::ty::{Allocation, ProvenanceMap};
+use super::unstable::Stable;
+
+/// Creates new empty `Allocation` from given `Align`.
+fn new_empty_allocation(align: Align) -> Allocation {
+    Allocation {
+        bytes: Vec::new(),
+        provenance: ProvenanceMap { ptrs: Vec::new() },
+        align: align.bytes(),
+        mutability: Mutability::Not,
+    }
+}
+
+// We need this method instead of a Stable implementation
+// because we need to get `Ty` of the const we are trying to create, to do that
+// we need to have access to `ConstantKind` but we can't access that inside Stable impl.
+#[allow(rustc::usage_of_qualified_ty)]
+pub(crate) fn new_allocation<'tcx>(
+    ty: rustc_middle::ty::Ty<'tcx>,
+    const_value: ConstValue<'tcx>,
+    tables: &mut Tables<'tcx, BridgeTys>,
+    cx: &SmirCtxt<'tcx, BridgeTys>,
+) -> Allocation {
+    try_new_allocation(ty, const_value, tables, cx)
+        .unwrap_or_else(|_| panic!("Failed to convert: {const_value:?} to {ty:?}"))
+}
+
+#[allow(rustc::usage_of_qualified_ty)]
+pub(crate) fn try_new_allocation<'tcx>(
+    ty: rustc_middle::ty::Ty<'tcx>,
+    const_value: ConstValue<'tcx>,
+    tables: &mut Tables<'tcx, BridgeTys>,
+    cx: &SmirCtxt<'tcx, BridgeTys>,
+) -> Result<Allocation, Error> {
+    let layout = alloc::create_ty_and_layout(cx, ty).map_err(|e| Error::from_internal(e))?;
+    match const_value {
+        ConstValue::Scalar(scalar) => {
+            alloc::try_new_scalar(layout, scalar, cx).map(|alloc| alloc.stable(tables, cx))
+        }
+        ConstValue::ZeroSized => Ok(new_empty_allocation(layout.align.abi)),
+        ConstValue::Slice { data, meta } => {
+            alloc::try_new_slice(layout, data, meta, cx).map(|alloc| alloc.stable(tables, cx))
+        }
+        ConstValue::Indirect { alloc_id, offset } => {
+            let alloc = alloc::try_new_indirect(alloc_id, cx);
+            use rustc_public_bridge::context::SmirAllocRange;
+            Ok(allocation_filter(&alloc.0, cx.alloc_range(offset, layout.size), tables, cx))
+        }
+    }
+}
+
+/// Creates an `Allocation` only from information within the `AllocRange`.
+pub(super) fn allocation_filter<'tcx>(
+    alloc: &rustc_middle::mir::interpret::Allocation,
+    alloc_range: AllocRange,
+    tables: &mut Tables<'tcx, BridgeTys>,
+    cx: &SmirCtxt<'tcx, BridgeTys>,
+) -> Allocation {
+    alloc::allocation_filter(alloc, alloc_range, tables, cx)
+}
diff --git a/compiler/rustc_public/src/compiler_interface.rs b/compiler/rustc_public/src/compiler_interface.rs
new file mode 100644
index 00000000000..d15438c2b80
--- /dev/null
+++ b/compiler/rustc_public/src/compiler_interface.rs
@@ -0,0 +1,1099 @@
+//! Define the interface with the Rust compiler.
+//!
+//! StableMIR users should not use any of the items in this module directly.
+//! These APIs have no stability guarantee.
+
+use std::cell::Cell;
+
+use rustc_hir::def::DefKind;
+use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::{Bridge, SmirContainer};
+use tracing::debug;
+
+use crate::abi::{FnAbi, Layout, LayoutShape, ReprOptions};
+use crate::crate_def::Attribute;
+use crate::mir::alloc::{AllocId, GlobalAlloc};
+use crate::mir::mono::{Instance, InstanceDef, StaticDef};
+use crate::mir::{BinOp, Body, Place, UnOp};
+use crate::target::{MachineInfo, MachineSize};
+use crate::ty::{
+    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,
+};
+use crate::unstable::{RustcInternal, Stable, new_item_kind};
+use crate::{
+    AssocItems, Crate, CrateDef, CrateItem, CrateItems, CrateNum, DefId, Error, Filename,
+    ImplTraitDecls, ItemKind, Symbol, TraitDecls, alloc, mir,
+};
+
+pub struct BridgeTys;
+
+impl Bridge for BridgeTys {
+    type DefId = crate::DefId;
+    type AllocId = crate::mir::alloc::AllocId;
+    type Span = crate::ty::Span;
+    type Ty = crate::ty::Ty;
+    type InstanceDef = crate::mir::mono::InstanceDef;
+    type TyConstId = crate::ty::TyConstId;
+    type MirConstId = crate::ty::MirConstId;
+    type Layout = crate::abi::Layout;
+
+    type Error = crate::Error;
+    type CrateItem = crate::CrateItem;
+    type AdtDef = crate::ty::AdtDef;
+    type ForeignModuleDef = crate::ty::ForeignModuleDef;
+    type ForeignDef = crate::ty::ForeignDef;
+    type FnDef = crate::ty::FnDef;
+    type ClosureDef = crate::ty::ClosureDef;
+    type CoroutineDef = crate::ty::CoroutineDef;
+    type CoroutineClosureDef = crate::ty::CoroutineClosureDef;
+    type AliasDef = crate::ty::AliasDef;
+    type ParamDef = crate::ty::ParamDef;
+    type BrNamedDef = crate::ty::BrNamedDef;
+    type TraitDef = crate::ty::TraitDef;
+    type GenericDef = crate::ty::GenericDef;
+    type ConstDef = crate::ty::ConstDef;
+    type ImplDef = crate::ty::ImplDef;
+    type RegionDef = crate::ty::RegionDef;
+    type CoroutineWitnessDef = crate::ty::CoroutineWitnessDef;
+    type AssocDef = crate::ty::AssocDef;
+    type OpaqueDef = crate::ty::OpaqueDef;
+    type Prov = crate::ty::Prov;
+    type StaticDef = crate::mir::mono::StaticDef;
+
+    type Allocation = crate::ty::Allocation;
+}
+
+/// Stable public API for querying compiler information.
+///
+/// All queries are delegated to [`rustc_public_bridge::context::SmirCtxt`] that provides
+/// similar APIs but based on internal rustc constructs.
+///
+/// Do not use this directly. This is currently used in the macro expansion.
+pub(crate) trait SmirInterface {
+    fn entry_fn(&self) -> Option<CrateItem>;
+    /// Retrieve all items of the local crate that have a MIR associated with them.
+    fn all_local_items(&self) -> CrateItems;
+    /// Retrieve the body of a function.
+    /// This function will panic if the body is not available.
+    fn mir_body(&self, item: DefId) -> mir::Body;
+    /// Check whether the body of a function is available.
+    fn has_body(&self, item: DefId) -> bool;
+    fn foreign_modules(&self, crate_num: CrateNum) -> Vec<ForeignModuleDef>;
+
+    /// Retrieve all functions defined in this crate.
+    fn crate_functions(&self, crate_num: CrateNum) -> Vec<FnDef>;
+
+    /// Retrieve all static items defined in this crate.
+    fn crate_statics(&self, crate_num: CrateNum) -> Vec<StaticDef>;
+    fn foreign_module(&self, mod_def: ForeignModuleDef) -> ForeignModule;
+    fn foreign_items(&self, mod_def: ForeignModuleDef) -> Vec<ForeignDef>;
+    fn all_trait_decls(&self) -> TraitDecls;
+    fn trait_decls(&self, crate_num: CrateNum) -> TraitDecls;
+    fn trait_decl(&self, trait_def: &TraitDef) -> TraitDecl;
+    fn all_trait_impls(&self) -> ImplTraitDecls;
+    fn trait_impls(&self, crate_num: CrateNum) -> ImplTraitDecls;
+    fn trait_impl(&self, trait_impl: &ImplDef) -> ImplTrait;
+    fn generics_of(&self, def_id: DefId) -> Generics;
+    fn predicates_of(&self, def_id: DefId) -> GenericPredicates;
+    fn explicit_predicates_of(&self, def_id: DefId) -> GenericPredicates;
+
+    /// Get information about the local crate.
+    fn local_crate(&self) -> Crate;
+    /// Retrieve a list of all external crates.
+    fn external_crates(&self) -> Vec<Crate>;
+
+    /// Find a crate with the given name.
+    fn find_crates(&self, name: &str) -> Vec<Crate>;
+
+    /// Returns the name of given `DefId`
+    fn def_name(&self, def_id: DefId, trimmed: bool) -> Symbol;
+
+    /// Return registered tool attributes with the given attribute name.
+    ///
+    /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool
+    /// attributes will simply return an empty list.
+    ///
+    /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`.
+    /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`.
+    fn tool_attrs(&self, def_id: DefId, attr: &[Symbol]) -> Vec<Attribute>;
+
+    /// Get all tool attributes of a definition.
+    fn all_tool_attrs(&self, def_id: DefId) -> Vec<Attribute>;
+
+    /// Returns printable, human readable form of `Span`
+    fn span_to_string(&self, span: Span) -> String;
+
+    /// Return filename from given `Span`, for diagnostic purposes
+    fn get_filename(&self, span: &Span) -> Filename;
+
+    /// Return lines corresponding to this `Span`
+    fn get_lines(&self, span: &Span) -> LineInfo;
+
+    /// Returns the `kind` of given `DefId`
+    fn item_kind(&self, item: CrateItem) -> ItemKind;
+
+    /// Returns whether this is a foreign item.
+    fn is_foreign_item(&self, item: DefId) -> bool;
+
+    /// Returns the kind of a given foreign item.
+    fn foreign_item_kind(&self, def: ForeignDef) -> ForeignItemKind;
+
+    /// Returns the kind of a given algebraic data type
+    fn adt_kind(&self, def: AdtDef) -> AdtKind;
+
+    /// Returns if the ADT is a box.
+    fn adt_is_box(&self, def: AdtDef) -> bool;
+
+    /// Returns whether this ADT is simd.
+    fn adt_is_simd(&self, def: AdtDef) -> bool;
+
+    /// Returns whether this definition is a C string.
+    fn adt_is_cstr(&self, def: AdtDef) -> bool;
+
+    /// Returns the representation options for this ADT.
+    fn adt_repr(&self, def: AdtDef) -> ReprOptions;
+
+    /// Retrieve the function signature for the given generic arguments.
+    fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig;
+
+    /// Retrieve the intrinsic definition if the item corresponds one.
+    fn intrinsic(&self, item: DefId) -> Option<IntrinsicDef>;
+
+    /// Retrieve the plain function name of an intrinsic.
+    fn intrinsic_name(&self, def: IntrinsicDef) -> Symbol;
+
+    /// Retrieve the closure signature for the given generic arguments.
+    fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig;
+
+    /// The number of variants in this ADT.
+    fn adt_variants_len(&self, def: AdtDef) -> usize;
+
+    /// Discriminant for a given variant index of AdtDef.
+    fn adt_discr_for_variant(&self, adt: AdtDef, variant: VariantIdx) -> Discr;
+
+    /// Discriminant for a given variand index and args of a coroutine.
+    fn coroutine_discr_for_variant(
+        &self,
+        coroutine: CoroutineDef,
+        args: &GenericArgs,
+        variant: VariantIdx,
+    ) -> Discr;
+
+    /// The name of a variant.
+    fn variant_name(&self, def: VariantDef) -> Symbol;
+    fn variant_fields(&self, def: VariantDef) -> Vec<FieldDef>;
+
+    /// Evaluate constant as a target usize.
+    fn eval_target_usize(&self, cnst: &MirConst) -> Result<u64, Error>;
+    fn eval_target_usize_ty(&self, cnst: &TyConst) -> Result<u64, Error>;
+
+    /// Create a new zero-sized constant.
+    fn try_new_const_zst(&self, ty: Ty) -> Result<MirConst, Error>;
+
+    /// Create a new constant that represents the given string value.
+    fn new_const_str(&self, value: &str) -> MirConst;
+
+    /// Create a new constant that represents the given boolean value.
+    fn new_const_bool(&self, value: bool) -> MirConst;
+
+    /// Create a new constant that represents the given value.
+    fn try_new_const_uint(&self, value: u128, uint_ty: UintTy) -> Result<MirConst, Error>;
+    fn try_new_ty_const_uint(&self, value: u128, uint_ty: UintTy) -> Result<TyConst, Error>;
+
+    /// Create a new type from the given kind.
+    fn new_rigid_ty(&self, kind: RigidTy) -> Ty;
+
+    /// Create a new box type, `Box<T>`, for the given inner type `T`.
+    fn new_box_ty(&self, ty: Ty) -> Ty;
+
+    /// Returns the type of given crate item.
+    fn def_ty(&self, item: DefId) -> Ty;
+
+    /// Returns the type of given definition instantiated with the given arguments.
+    fn def_ty_with_args(&self, item: DefId, args: &GenericArgs) -> Ty;
+
+    /// Returns literal value of a const as a string.
+    fn mir_const_pretty(&self, cnst: &MirConst) -> String;
+
+    /// `Span` of an item
+    fn span_of_an_item(&self, def_id: DefId) -> Span;
+
+    fn ty_const_pretty(&self, ct: TyConstId) -> String;
+
+    /// Obtain the representation of a type.
+    fn ty_pretty(&self, ty: Ty) -> String;
+
+    /// Obtain the kind of a type.
+    fn ty_kind(&self, ty: Ty) -> TyKind;
+
+    // Get the discriminant Ty for this Ty if there's one.
+    fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> Ty;
+
+    /// Get the body of an Instance which is already monomorphized.
+    fn instance_body(&self, instance: InstanceDef) -> Option<Body>;
+
+    /// Get the instance type with generic instantiations applied and lifetimes erased.
+    fn instance_ty(&self, instance: InstanceDef) -> Ty;
+
+    /// Get the instantiation types.
+    fn instance_args(&self, def: InstanceDef) -> GenericArgs;
+
+    /// Get the instance.
+    fn instance_def_id(&self, instance: InstanceDef) -> DefId;
+
+    /// Get the instance mangled name.
+    fn instance_mangled_name(&self, instance: InstanceDef) -> Symbol;
+
+    /// Check if this is an empty DropGlue shim.
+    fn is_empty_drop_shim(&self, def: InstanceDef) -> bool;
+
+    /// Convert a non-generic crate item into an instance.
+    /// This function will panic if the item is generic.
+    fn mono_instance(&self, def_id: DefId) -> Instance;
+
+    /// Item requires monomorphization.
+    fn requires_monomorphization(&self, def_id: DefId) -> bool;
+
+    /// Resolve an instance from the given function definition and generic arguments.
+    fn resolve_instance(&self, def: FnDef, args: &GenericArgs) -> Option<Instance>;
+
+    /// Resolve an instance for drop_in_place for the given type.
+    fn resolve_drop_in_place(&self, ty: Ty) -> Instance;
+
+    /// Resolve instance for a function pointer.
+    fn resolve_for_fn_ptr(&self, def: FnDef, args: &GenericArgs) -> Option<Instance>;
+
+    /// Resolve instance for a closure with the requested type.
+    fn resolve_closure(
+        &self,
+        def: ClosureDef,
+        args: &GenericArgs,
+        kind: ClosureKind,
+    ) -> Option<Instance>;
+
+    /// Evaluate a static's initializer.
+    fn eval_static_initializer(&self, def: StaticDef) -> Result<Allocation, Error>;
+
+    /// Try to evaluate an instance into a constant.
+    fn eval_instance(&self, def: InstanceDef, const_ty: Ty) -> Result<Allocation, Error>;
+
+    /// Retrieve global allocation for the given allocation ID.
+    fn global_alloc(&self, id: AllocId) -> GlobalAlloc;
+
+    /// Retrieve the id for the virtual table.
+    fn vtable_allocation(&self, global_alloc: &GlobalAlloc) -> Option<AllocId>;
+    fn krate(&self, def_id: DefId) -> Crate;
+    fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol;
+
+    /// Return information about the target machine.
+    fn target_info(&self) -> MachineInfo;
+
+    /// Get an instance ABI.
+    fn instance_abi(&self, def: InstanceDef) -> Result<FnAbi, Error>;
+
+    /// Get the ABI of a function pointer.
+    fn fn_ptr_abi(&self, fn_ptr: PolyFnSig) -> Result<FnAbi, Error>;
+
+    /// Get the layout of a type.
+    fn ty_layout(&self, ty: Ty) -> Result<Layout, Error>;
+
+    /// Get the layout shape.
+    fn layout_shape(&self, id: Layout) -> LayoutShape;
+
+    /// Get a debug string representation of a place.
+    fn place_pretty(&self, place: &Place) -> String;
+
+    /// Get the resulting type of binary operation.
+    fn binop_ty(&self, bin_op: BinOp, rhs: Ty, lhs: Ty) -> Ty;
+
+    /// Get the resulting type of unary operation.
+    fn unop_ty(&self, un_op: UnOp, arg: Ty) -> Ty;
+
+    /// Get all associated items of a definition.
+    fn associated_items(&self, def_id: DefId) -> AssocItems;
+}
+
+impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> {
+    fn entry_fn(&self) -> Option<CrateItem> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = cx.entry_fn();
+        Some(tables.crate_item(did?))
+    }
+
+    /// Retrieve all items of the local crate that have a MIR associated with them.
+    fn all_local_items(&self) -> CrateItems {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.all_local_items().iter().map(|did| tables.crate_item(*did)).collect()
+    }
+
+    /// Retrieve the body of a function.
+    /// This function will panic if the body is not available.
+    fn mir_body(&self, item: DefId) -> mir::Body {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[item];
+        cx.mir_body(did).stable(&mut *tables, cx)
+    }
+
+    /// Check whether the body of a function is available.
+    fn has_body(&self, item: DefId) -> bool {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let def = item.internal(&mut *tables, cx.tcx);
+        cx.has_body(def)
+    }
+
+    fn foreign_modules(&self, crate_num: CrateNum) -> Vec<ForeignModuleDef> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.foreign_modules(crate_num.internal(&mut *tables, cx.tcx))
+            .iter()
+            .map(|did| tables.foreign_module_def(*did))
+            .collect()
+    }
+
+    /// Retrieve all functions defined in this crate.
+    fn crate_functions(&self, crate_num: CrateNum) -> Vec<FnDef> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let krate = crate_num.internal(&mut *tables, cx.tcx);
+        cx.crate_functions(krate).iter().map(|did| tables.fn_def(*did)).collect()
+    }
+
+    /// Retrieve all static items defined in this crate.
+    fn crate_statics(&self, crate_num: CrateNum) -> Vec<StaticDef> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let krate = crate_num.internal(&mut *tables, cx.tcx);
+        cx.crate_statics(krate).iter().map(|did| tables.static_def(*did)).collect()
+    }
+
+    fn foreign_module(&self, mod_def: ForeignModuleDef) -> ForeignModule {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[mod_def.def_id()];
+        cx.foreign_module(did).stable(&mut *tables, cx)
+    }
+
+    fn foreign_items(&self, mod_def: ForeignModuleDef) -> Vec<ForeignDef> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[mod_def.def_id()];
+        cx.foreign_items(did).iter().map(|did| tables.foreign_def(*did)).collect()
+    }
+
+    fn all_trait_decls(&self) -> TraitDecls {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.all_trait_decls().map(|did| tables.trait_def(did)).collect()
+    }
+
+    fn trait_decls(&self, crate_num: CrateNum) -> TraitDecls {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let krate = crate_num.internal(&mut *tables, cx.tcx);
+        cx.trait_decls(krate).iter().map(|did| tables.trait_def(*did)).collect()
+    }
+
+    fn trait_decl(&self, trait_def: &TraitDef) -> TraitDecl {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[trait_def.0];
+        cx.trait_decl(did).stable(&mut *tables, cx)
+    }
+
+    fn all_trait_impls(&self) -> ImplTraitDecls {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.all_trait_impls().iter().map(|did| tables.impl_def(*did)).collect()
+    }
+
+    fn trait_impls(&self, crate_num: CrateNum) -> ImplTraitDecls {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let krate = crate_num.internal(&mut *tables, cx.tcx);
+        cx.trait_impls(krate).iter().map(|did| tables.impl_def(*did)).collect()
+    }
+
+    fn trait_impl(&self, trait_impl: &ImplDef) -> ImplTrait {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[trait_impl.0];
+        cx.trait_impl(did).stable(&mut *tables, cx)
+    }
+
+    fn generics_of(&self, def_id: DefId) -> Generics {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[def_id];
+        cx.generics_of(did).stable(&mut *tables, cx)
+    }
+
+    fn predicates_of(&self, def_id: DefId) -> GenericPredicates {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[def_id];
+        let (parent, kinds) = cx.predicates_of(did);
+        crate::ty::GenericPredicates {
+            parent: parent.map(|did| tables.trait_def(did)),
+            predicates: kinds
+                .iter()
+                .map(|(kind, span)| (kind.stable(&mut *tables, cx), span.stable(&mut *tables, cx)))
+                .collect(),
+        }
+    }
+
+    fn explicit_predicates_of(&self, def_id: DefId) -> GenericPredicates {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[def_id];
+        let (parent, kinds) = cx.explicit_predicates_of(did);
+        crate::ty::GenericPredicates {
+            parent: parent.map(|did| tables.trait_def(did)),
+            predicates: kinds
+                .iter()
+                .map(|(kind, span)| (kind.stable(&mut *tables, cx), span.stable(&mut *tables, cx)))
+                .collect(),
+        }
+    }
+
+    /// Get information about the local crate.
+    fn local_crate(&self) -> Crate {
+        let cx = &*self.cx.borrow();
+        smir_crate(cx, cx.local_crate_num())
+    }
+
+    /// Retrieve a list of all external crates.
+    fn external_crates(&self) -> Vec<Crate> {
+        let cx = &*self.cx.borrow();
+        cx.external_crates().iter().map(|crate_num| smir_crate(cx, *crate_num)).collect()
+    }
+
+    /// Find a crate with the given name.
+    fn find_crates(&self, name: &str) -> Vec<Crate> {
+        let cx = &*self.cx.borrow();
+        cx.find_crates(name).iter().map(|crate_num| smir_crate(cx, *crate_num)).collect()
+    }
+
+    /// Returns the name of given `DefId`.
+    fn def_name(&self, def_id: DefId, trimmed: bool) -> Symbol {
+        let tables = self.tables.borrow();
+        let cx = &*self.cx.borrow();
+        let did = tables[def_id];
+        cx.def_name(did, trimmed)
+    }
+
+    /// Return registered tool attributes with the given attribute name.
+    ///
+    /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool
+    /// attributes will simply return an empty list.
+    ///
+    /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`.
+    /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`.
+    fn tool_attrs(&self, def_id: DefId, attr: &[Symbol]) -> Vec<Attribute> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[def_id];
+        cx.tool_attrs(did, attr)
+            .into_iter()
+            .map(|(attr_str, span)| Attribute::new(attr_str, span.stable(&mut *tables, cx)))
+            .collect()
+    }
+
+    /// Get all tool attributes of a definition.
+    fn all_tool_attrs(&self, def_id: DefId) -> Vec<Attribute> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[def_id];
+        cx.all_tool_attrs(did)
+            .into_iter()
+            .map(|(attr_str, span)| Attribute::new(attr_str, span.stable(&mut *tables, cx)))
+            .collect()
+    }
+
+    /// Returns printable, human readable form of `Span`.
+    fn span_to_string(&self, span: Span) -> String {
+        let tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let sp = tables.spans[span];
+        cx.span_to_string(sp)
+    }
+
+    /// Return filename from given `Span`, for diagnostic purposes.
+    fn get_filename(&self, span: &Span) -> Filename {
+        let tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let sp = tables.spans[*span];
+        cx.get_filename(sp)
+    }
+
+    /// Return lines corresponding to this `Span`.
+    fn get_lines(&self, span: &Span) -> LineInfo {
+        let tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let sp = tables.spans[*span];
+        let lines = cx.get_lines(sp);
+        LineInfo::from(lines)
+    }
+
+    /// Returns the `kind` of given `DefId`.
+    fn item_kind(&self, item: CrateItem) -> ItemKind {
+        let tables = self.tables.borrow();
+        let cx = &*self.cx.borrow();
+        let did = tables[item.0];
+        new_item_kind(cx.def_kind(did))
+    }
+
+    /// Returns whether this is a foreign item.
+    fn is_foreign_item(&self, item: DefId) -> bool {
+        let tables = self.tables.borrow();
+        let cx = &*self.cx.borrow();
+        let did = tables[item];
+        cx.is_foreign_item(did)
+    }
+
+    /// Returns the kind of a given foreign item.
+    fn foreign_item_kind(&self, def: ForeignDef) -> ForeignItemKind {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let def_id = tables[def.def_id()];
+        let def_kind = cx.foreign_item_kind(def_id);
+        match def_kind {
+            DefKind::Fn => ForeignItemKind::Fn(tables.fn_def(def_id)),
+            DefKind::Static { .. } => ForeignItemKind::Static(tables.static_def(def_id)),
+            DefKind::ForeignTy => {
+                use rustc_public_bridge::context::SmirTy;
+                ForeignItemKind::Type(tables.intern_ty(cx.new_foreign(def_id)))
+            }
+            def_kind => unreachable!("Unexpected kind for a foreign item: {:?}", def_kind),
+        }
+    }
+
+    /// Returns the kind of a given algebraic data type.
+    fn adt_kind(&self, def: AdtDef) -> AdtKind {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.adt_kind(def.internal(&mut *tables, cx.tcx)).stable(&mut *tables, cx)
+    }
+
+    /// Returns if the ADT is a box.
+    fn adt_is_box(&self, def: AdtDef) -> bool {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.adt_is_box(def.internal(&mut *tables, cx.tcx))
+    }
+
+    /// Returns whether this ADT is simd.
+    fn adt_is_simd(&self, def: AdtDef) -> bool {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.adt_is_simd(def.internal(&mut *tables, cx.tcx))
+    }
+
+    /// Returns whether this definition is a C string.
+    fn adt_is_cstr(&self, def: AdtDef) -> bool {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.adt_is_cstr(def.0.internal(&mut *tables, cx.tcx))
+    }
+
+    /// Returns the representation options for this ADT
+    fn adt_repr(&self, def: AdtDef) -> ReprOptions {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.adt_repr(def.internal(&mut *tables, cx.tcx)).stable(&mut *tables, cx)
+    }
+
+    /// Retrieve the function signature for the given generic arguments.
+    fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let def_id = def.0.internal(&mut *tables, cx.tcx);
+        let args_ref = args.internal(&mut *tables, cx.tcx);
+        cx.fn_sig(def_id, args_ref).stable(&mut *tables, cx)
+    }
+
+    /// Retrieve the intrinsic definition if the item corresponds one.
+    fn intrinsic(&self, item: DefId) -> Option<IntrinsicDef> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let def_id = item.internal(&mut *tables, cx.tcx);
+        cx.intrinsic(def_id).map(|_| IntrinsicDef(item))
+    }
+
+    /// Retrieve the plain function name of an intrinsic.
+    fn intrinsic_name(&self, def: IntrinsicDef) -> Symbol {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let def_id = def.0.internal(&mut *tables, cx.tcx);
+        cx.intrinsic_name(def_id)
+    }
+
+    /// Retrieve the closure signature for the given generic arguments.
+    fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let args_ref = args.internal(&mut *tables, cx.tcx);
+        cx.closure_sig(args_ref).stable(&mut *tables, cx)
+    }
+
+    /// The number of variants in this ADT.
+    fn adt_variants_len(&self, def: AdtDef) -> usize {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.adt_variants_len(def.internal(&mut *tables, cx.tcx))
+    }
+
+    /// Discriminant for a given variant index of AdtDef.
+    fn adt_discr_for_variant(&self, adt: AdtDef, variant: VariantIdx) -> Discr {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.adt_discr_for_variant(
+            adt.internal(&mut *tables, cx.tcx),
+            variant.internal(&mut *tables, cx.tcx),
+        )
+        .stable(&mut *tables, cx)
+    }
+
+    /// Discriminant for a given variand index and args of a coroutine.
+    fn coroutine_discr_for_variant(
+        &self,
+        coroutine: CoroutineDef,
+        args: &GenericArgs,
+        variant: VariantIdx,
+    ) -> Discr {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let tcx = cx.tcx;
+        let def = coroutine.def_id().internal(&mut *tables, tcx);
+        let args_ref = args.internal(&mut *tables, tcx);
+        cx.coroutine_discr_for_variant(def, args_ref, variant.internal(&mut *tables, tcx))
+            .stable(&mut *tables, cx)
+    }
+
+    /// The name of a variant.
+    fn variant_name(&self, def: VariantDef) -> Symbol {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.variant_name(def.internal(&mut *tables, cx.tcx))
+    }
+
+    fn variant_fields(&self, def: VariantDef) -> Vec<FieldDef> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        def.internal(&mut *tables, cx.tcx)
+            .fields
+            .iter()
+            .map(|f| f.stable(&mut *tables, cx))
+            .collect()
+    }
+
+    /// Evaluate constant as a target usize.
+    fn eval_target_usize(&self, mir_const: &MirConst) -> Result<u64, Error> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let cnst = mir_const.internal(&mut *tables, cx.tcx);
+        cx.eval_target_usize(cnst)
+    }
+
+    fn eval_target_usize_ty(&self, ty_const: &TyConst) -> Result<u64, Error> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let cnst = ty_const.internal(&mut *tables, cx.tcx);
+        cx.eval_target_usize_ty(cnst)
+    }
+
+    /// Create a new zero-sized constant.
+    fn try_new_const_zst(&self, ty: Ty) -> Result<MirConst, Error> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let ty_internal = ty.internal(&mut *tables, cx.tcx);
+        cx.try_new_const_zst(ty_internal).map(|cnst| cnst.stable(&mut *tables, cx))
+    }
+
+    /// Create a new constant that represents the given string value.
+    fn new_const_str(&self, value: &str) -> MirConst {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.new_const_str(value).stable(&mut *tables, cx)
+    }
+
+    /// Create a new constant that represents the given boolean value.
+    fn new_const_bool(&self, value: bool) -> MirConst {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.new_const_bool(value).stable(&mut *tables, cx)
+    }
+
+    /// Create a new constant that represents the given value.
+    fn try_new_const_uint(&self, value: u128, uint_ty: UintTy) -> Result<MirConst, Error> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let ty = cx.ty_new_uint(uint_ty.internal(&mut *tables, cx.tcx));
+        cx.try_new_const_uint(value, ty).map(|cnst| cnst.stable(&mut *tables, cx))
+    }
+
+    fn try_new_ty_const_uint(&self, value: u128, uint_ty: UintTy) -> Result<TyConst, Error> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let ty = cx.ty_new_uint(uint_ty.internal(&mut *tables, cx.tcx));
+        cx.try_new_ty_const_uint(value, ty).map(|cnst| cnst.stable(&mut *tables, cx))
+    }
+
+    /// Create a new type from the given kind.
+    fn new_rigid_ty(&self, kind: RigidTy) -> Ty {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let internal_kind = kind.internal(&mut *tables, cx.tcx);
+        cx.new_rigid_ty(internal_kind).stable(&mut *tables, cx)
+    }
+
+    /// Create a new box type, `Box<T>`, for the given inner type `T`.
+    fn new_box_ty(&self, ty: Ty) -> Ty {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let inner = ty.internal(&mut *tables, cx.tcx);
+        cx.new_box_ty(inner).stable(&mut *tables, cx)
+    }
+
+    /// Returns the type of given crate item.
+    fn def_ty(&self, item: DefId) -> Ty {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let inner = item.internal(&mut *tables, cx.tcx);
+        cx.def_ty(inner).stable(&mut *tables, cx)
+    }
+
+    /// Returns the type of given definition instantiated with the given arguments.
+    fn def_ty_with_args(&self, item: DefId, args: &GenericArgs) -> Ty {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let inner = item.internal(&mut *tables, cx.tcx);
+        let args_ref = args.internal(&mut *tables, cx.tcx);
+        cx.def_ty_with_args(inner, args_ref).stable(&mut *tables, cx)
+    }
+
+    /// Returns literal value of a const as a string.
+    fn mir_const_pretty(&self, cnst: &MirConst) -> String {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cnst.internal(&mut *tables, cx.tcx).to_string()
+    }
+
+    /// `Span` of an item.
+    fn span_of_an_item(&self, def_id: DefId) -> Span {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[def_id];
+        cx.span_of_an_item(did).stable(&mut *tables, cx)
+    }
+
+    fn ty_const_pretty(&self, ct: TyConstId) -> String {
+        let tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.ty_const_pretty(tables.ty_consts[ct])
+    }
+
+    /// Obtain the representation of a type.
+    fn ty_pretty(&self, ty: Ty) -> String {
+        let tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.ty_pretty(tables.types[ty])
+    }
+
+    /// Obtain the kind of a type.
+    fn ty_kind(&self, ty: Ty) -> TyKind {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        cx.ty_kind(tables.types[ty]).stable(&mut *tables, cx)
+    }
+
+    /// Get the discriminant Ty for this Ty if there's one.
+    fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> Ty {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let internal_kind = ty.internal(&mut *tables, cx.tcx);
+        cx.rigid_ty_discriminant_ty(internal_kind).stable(&mut *tables, cx)
+    }
+
+    /// Get the body of an Instance which is already monomorphized.
+    fn instance_body(&self, instance: InstanceDef) -> Option<Body> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let instance = tables.instances[instance];
+        cx.instance_body(instance).map(|body| body.stable(&mut *tables, cx))
+    }
+
+    /// Get the instance type with generic instantiations applied and lifetimes erased.
+    fn instance_ty(&self, instance: InstanceDef) -> Ty {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let instance = tables.instances[instance];
+        cx.instance_ty(instance).stable(&mut *tables, cx)
+    }
+
+    /// Get the instantiation types.
+    fn instance_args(&self, def: InstanceDef) -> GenericArgs {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let instance = tables.instances[def];
+        cx.instance_args(instance).stable(&mut *tables, cx)
+    }
+
+    /// Get the instance.
+    fn instance_def_id(&self, instance: InstanceDef) -> DefId {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let instance = tables.instances[instance];
+        cx.instance_def_id(instance, &mut *tables)
+    }
+
+    /// Get the instance mangled name.
+    fn instance_mangled_name(&self, instance: InstanceDef) -> Symbol {
+        let tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let instance = tables.instances[instance];
+        cx.instance_mangled_name(instance)
+    }
+
+    /// Check if this is an empty DropGlue shim.
+    fn is_empty_drop_shim(&self, def: InstanceDef) -> bool {
+        let tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let instance = tables.instances[def];
+        cx.is_empty_drop_shim(instance)
+    }
+
+    /// Convert a non-generic crate item into an instance.
+    /// This function will panic if the item is generic.
+    fn mono_instance(&self, def_id: DefId) -> Instance {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[def_id];
+        cx.mono_instance(did).stable(&mut *tables, cx)
+    }
+
+    /// Item requires monomorphization.
+    fn requires_monomorphization(&self, def_id: DefId) -> bool {
+        let tables = self.tables.borrow();
+        let cx = &*self.cx.borrow();
+        let did = tables[def_id];
+        cx.requires_monomorphization(did)
+    }
+
+    /// Resolve an instance from the given function definition and generic arguments.
+    fn resolve_instance(&self, def: FnDef, args: &GenericArgs) -> Option<Instance> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let def_id = def.0.internal(&mut *tables, cx.tcx);
+        let args_ref = args.internal(&mut *tables, cx.tcx);
+        cx.resolve_instance(def_id, args_ref).map(|inst| inst.stable(&mut *tables, cx))
+    }
+
+    /// Resolve an instance for drop_in_place for the given type.
+    fn resolve_drop_in_place(&self, ty: Ty) -> Instance {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let internal_ty = ty.internal(&mut *tables, cx.tcx);
+
+        cx.resolve_drop_in_place(internal_ty).stable(&mut *tables, cx)
+    }
+
+    /// Resolve instance for a function pointer.
+    fn resolve_for_fn_ptr(&self, def: FnDef, args: &GenericArgs) -> Option<Instance> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let def_id = def.0.internal(&mut *tables, cx.tcx);
+        let args_ref = args.internal(&mut *tables, cx.tcx);
+        cx.resolve_for_fn_ptr(def_id, args_ref).stable(&mut *tables, cx)
+    }
+
+    /// Resolve instance for a closure with the requested type.
+    fn resolve_closure(
+        &self,
+        def: ClosureDef,
+        args: &GenericArgs,
+        kind: ClosureKind,
+    ) -> Option<Instance> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let def_id = def.0.internal(&mut *tables, cx.tcx);
+        let args_ref = args.internal(&mut *tables, cx.tcx);
+        let closure_kind = kind.internal(&mut *tables, cx.tcx);
+        cx.resolve_closure(def_id, args_ref, closure_kind).map(|inst| inst.stable(&mut *tables, cx))
+    }
+
+    /// Evaluate a static's initializer.
+    fn eval_static_initializer(&self, def: StaticDef) -> Result<Allocation, Error> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let def_id = def.0.internal(&mut *tables, cx.tcx);
+
+        cx.eval_static_initializer(def_id).stable(&mut *tables, cx)
+    }
+
+    /// Try to evaluate an instance into a constant.
+    fn eval_instance(&self, def: InstanceDef, const_ty: Ty) -> Result<Allocation, Error> {
+        let mut tables = self.tables.borrow_mut();
+        let instance = tables.instances[def];
+        let cx = &*self.cx.borrow();
+        let const_ty = const_ty.internal(&mut *tables, cx.tcx);
+        cx.eval_instance(instance)
+            .map(|const_val| alloc::try_new_allocation(const_ty, const_val, &mut *tables, cx))
+            .map_err(|e| e.stable(&mut *tables, cx))?
+    }
+
+    /// Retrieve global allocation for the given allocation ID.
+    fn global_alloc(&self, id: AllocId) -> GlobalAlloc {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let alloc_id = id.internal(&mut *tables, cx.tcx);
+        cx.global_alloc(alloc_id).stable(&mut *tables, cx)
+    }
+
+    /// Retrieve the id for the virtual table.
+    fn vtable_allocation(&self, global_alloc: &GlobalAlloc) -> Option<AllocId> {
+        let mut tables = self.tables.borrow_mut();
+        let GlobalAlloc::VTable(ty, trait_ref) = global_alloc else {
+            return None;
+        };
+        let cx = &*self.cx.borrow();
+        let ty = ty.internal(&mut *tables, cx.tcx);
+        let trait_ref = trait_ref.internal(&mut *tables, cx.tcx);
+        let alloc_id = cx.vtable_allocation(ty, trait_ref);
+        Some(alloc_id.stable(&mut *tables, cx))
+    }
+
+    fn krate(&self, def_id: DefId) -> Crate {
+        let tables = self.tables.borrow();
+        let cx = &*self.cx.borrow();
+        smir_crate(cx, tables[def_id].krate)
+    }
+
+    fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol {
+        let tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let instance = tables.instances[def];
+        cx.instance_name(instance, trimmed)
+    }
+
+    /// Return information about the target machine.
+    fn target_info(&self) -> MachineInfo {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        MachineInfo {
+            endian: cx.target_endian().stable(&mut *tables, cx),
+            pointer_width: MachineSize::from_bits(cx.target_pointer_size()),
+        }
+    }
+
+    /// Get an instance ABI.
+    fn instance_abi(&self, def: InstanceDef) -> Result<FnAbi, Error> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let instance = tables.instances[def];
+        cx.instance_abi(instance).map(|fn_abi| fn_abi.stable(&mut *tables, cx))
+    }
+
+    /// Get the ABI of a function pointer.
+    fn fn_ptr_abi(&self, fn_ptr: PolyFnSig) -> Result<FnAbi, Error> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let sig = fn_ptr.internal(&mut *tables, cx.tcx);
+        cx.fn_ptr_abi(sig).map(|fn_abi| fn_abi.stable(&mut *tables, cx))
+    }
+
+    /// Get the layout of a type.
+    fn ty_layout(&self, ty: Ty) -> Result<Layout, Error> {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let internal_ty = ty.internal(&mut *tables, cx.tcx);
+        cx.ty_layout(internal_ty).map(|layout| layout.stable(&mut *tables, cx))
+    }
+
+    /// Get the layout shape.
+    fn layout_shape(&self, id: Layout) -> LayoutShape {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        id.internal(&mut *tables, cx.tcx).0.stable(&mut *tables, cx)
+    }
+
+    /// Get a debug string representation of a place.
+    fn place_pretty(&self, place: &Place) -> String {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+
+        format!("{:?}", place.internal(&mut *tables, cx.tcx))
+    }
+
+    /// Get the resulting type of binary operation.
+    fn binop_ty(&self, bin_op: BinOp, rhs: Ty, lhs: Ty) -> Ty {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let rhs_internal = rhs.internal(&mut *tables, cx.tcx);
+        let lhs_internal = lhs.internal(&mut *tables, cx.tcx);
+        let bin_op_internal = bin_op.internal(&mut *tables, cx.tcx);
+        cx.binop_ty(bin_op_internal, rhs_internal, lhs_internal).stable(&mut *tables, cx)
+    }
+
+    /// Get the resulting type of unary operation.
+    fn unop_ty(&self, un_op: UnOp, arg: Ty) -> Ty {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let un_op = un_op.internal(&mut *tables, cx.tcx);
+        let arg = arg.internal(&mut *tables, cx.tcx);
+        cx.unop_ty(un_op, arg).stable(&mut *tables, cx)
+    }
+
+    /// Get all associated items of a definition.
+    fn associated_items(&self, def_id: DefId) -> AssocItems {
+        let mut tables = self.tables.borrow_mut();
+        let cx = &*self.cx.borrow();
+        let did = tables[def_id];
+        cx.associated_items(did).iter().map(|assoc| assoc.stable(&mut *tables, cx)).collect()
+    }
+}
+
+// A thread local variable that stores a pointer to [`SmirInterface`].
+scoped_tls::scoped_thread_local!(static TLV: Cell<*const ()>);
+
+pub(crate) fn run<F, T>(interface: &dyn SmirInterface, f: F) -> Result<T, Error>
+where
+    F: FnOnce() -> T,
+{
+    if TLV.is_set() {
+        Err(Error::from("StableMIR already running"))
+    } else {
+        let ptr: *const () = (&raw const interface) as _;
+        TLV.set(&Cell::new(ptr), || Ok(f()))
+    }
+}
+
+/// Execute the given function with access the [`SmirInterface`].
+///
+/// I.e., This function will load the current interface and calls a function with it.
+/// Do not nest these, as that will ICE.
+pub(crate) fn with<R>(f: impl FnOnce(&dyn SmirInterface) -> R) -> R {
+    assert!(TLV.is_set());
+    TLV.with(|tlv| {
+        let ptr = tlv.get();
+        assert!(!ptr.is_null());
+        f(unsafe { *(ptr as *const &dyn SmirInterface) })
+    })
+}
+
+fn smir_crate<'tcx>(
+    cx: &SmirCtxt<'tcx, BridgeTys>,
+    crate_num: rustc_span::def_id::CrateNum,
+) -> Crate {
+    let name = cx.crate_name(crate_num);
+    let is_local = cx.crate_is_local(crate_num);
+    let id = cx.crate_num_id(crate_num);
+    debug!(?name, ?crate_num, "smir_crate");
+    Crate { id, name, is_local }
+}
diff --git a/compiler/rustc_public/src/crate_def.rs b/compiler/rustc_public/src/crate_def.rs
new file mode 100644
index 00000000000..75228135e4c
--- /dev/null
+++ b/compiler/rustc_public/src/crate_def.rs
@@ -0,0 +1,174 @@
+//! Module that define a common trait for things that represent a crate definition,
+//! such as, a function, a trait, an enum, and any other definitions.
+
+use serde::Serialize;
+
+use crate::ty::{GenericArgs, Span, Ty};
+use crate::{AssocItems, Crate, Symbol, with};
+
+/// A unique identification number for each item accessible for the current compilation unit.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize)]
+pub struct DefId(pub(crate) usize);
+
+impl DefId {
+    /// Return fully qualified name of this definition
+    pub fn name(&self) -> Symbol {
+        with(|cx| cx.def_name(*self, false))
+    }
+
+    /// Return a trimmed name of this definition.
+    ///
+    /// This can be used to print more user friendly diagnostic messages.
+    ///
+    /// If a symbol name can only be imported from one place for a type, and as
+    /// long as it was not glob-imported anywhere in the current crate, we trim its
+    /// path and print only the name.
+    ///
+    /// For example, this function may shorten `std::vec::Vec` to just `Vec`,
+    /// as long as there is no other `Vec` importable anywhere.
+    pub fn trimmed_name(&self) -> Symbol {
+        with(|cx| cx.def_name(*self, true))
+    }
+}
+
+/// A trait for retrieving information about a particular definition.
+///
+/// Implementors must provide the implementation of `def_id` which will be used to retrieve
+/// information about a crate's definition.
+pub trait CrateDef {
+    /// Retrieve the unique identifier for the current definition.
+    fn def_id(&self) -> DefId;
+
+    /// Return the fully qualified name of the current definition.
+    ///
+    /// See [`DefId::name`] for more details
+    fn name(&self) -> Symbol {
+        self.def_id().name()
+    }
+
+    /// Return a trimmed name of this definition.
+    ///
+    /// See [`DefId::trimmed_name`] for more details
+    fn trimmed_name(&self) -> Symbol {
+        self.def_id().trimmed_name()
+    }
+
+    /// Return information about the crate where this definition is declared.
+    ///
+    /// This will return the crate number and its name.
+    fn krate(&self) -> Crate {
+        let def_id = self.def_id();
+        with(|cx| cx.krate(def_id))
+    }
+
+    /// Return the span of this definition.
+    fn span(&self) -> Span {
+        let def_id = self.def_id();
+        with(|cx| cx.span_of_an_item(def_id))
+    }
+
+    /// Return registered tool attributes with the given attribute name.
+    ///
+    /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool
+    /// attributes will simply return an empty list.
+    ///
+    /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`.
+    /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`.
+    fn tool_attrs(&self, attr: &[Symbol]) -> Vec<Attribute> {
+        let def_id = self.def_id();
+        with(|cx| cx.tool_attrs(def_id, attr))
+    }
+
+    /// Return all tool attributes of this definition.
+    fn all_tool_attrs(&self) -> Vec<Attribute> {
+        let def_id = self.def_id();
+        with(|cx| cx.all_tool_attrs(def_id))
+    }
+}
+
+/// A trait that can be used to retrieve a definition's type.
+///
+/// Note that not every CrateDef has a type `Ty`. They should not implement this trait.
+pub trait CrateDefType: CrateDef {
+    /// Returns the type of this crate item.
+    fn ty(&self) -> Ty {
+        with(|cx| cx.def_ty(self.def_id()))
+    }
+
+    /// Retrieve the type of this definition by instantiating and normalizing it with `args`.
+    ///
+    /// This will panic if instantiation fails.
+    fn ty_with_args(&self, args: &GenericArgs) -> Ty {
+        with(|cx| cx.def_ty_with_args(self.def_id(), args))
+    }
+}
+
+/// A trait for retrieving all items from a definition within a crate.
+pub trait CrateDefItems: CrateDef {
+    /// Retrieve all associated items from a definition.
+    fn associated_items(&self) -> AssocItems {
+        with(|cx| cx.associated_items(self.def_id()))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Attribute {
+    value: String,
+    span: Span,
+}
+
+impl Attribute {
+    pub fn new(value: String, span: Span) -> Attribute {
+        Attribute { value, span }
+    }
+
+    /// Get the span of this attribute.
+    pub fn span(&self) -> Span {
+        self.span
+    }
+
+    /// Get the string representation of this attribute.
+    pub fn as_str(&self) -> &str {
+        &self.value
+    }
+}
+
+macro_rules! crate_def {
+    ( $(#[$attr:meta])*
+      $vis:vis $name:ident $(;)?
+    ) => {
+        $(#[$attr])*
+        #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+        $vis struct $name(pub DefId);
+
+        impl CrateDef for $name {
+            fn def_id(&self) -> DefId {
+                self.0
+            }
+        }
+    };
+}
+
+macro_rules! crate_def_with_ty {
+    ( $(#[$attr:meta])*
+      $vis:vis $name:ident $(;)?
+    ) => {
+        $(#[$attr])*
+        #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+        $vis struct $name(pub DefId);
+
+        impl CrateDef for $name {
+            fn def_id(&self) -> DefId {
+                self.0
+            }
+        }
+
+        impl CrateDefType for $name {}
+    };
+}
+
+macro_rules! impl_crate_def_items {
+    ( $name:ident $(;)? ) => {
+        impl CrateDefItems for $name {}
+    };
+}
diff --git a/compiler/rustc_public/src/error.rs b/compiler/rustc_public/src/error.rs
new file mode 100644
index 00000000000..bc2124d1716
--- /dev/null
+++ b/compiler/rustc_public/src/error.rs
@@ -0,0 +1,91 @@
+//! When things go wrong, we need some error handling.
+//! There are a few different types of errors in StableMIR:
+//!
+//! - [CompilerError]: This represents errors that can be raised when invoking the compiler.
+//! - [Error]: Generic error that represents the reason why a request that could not be fulfilled.
+
+use std::fmt::{Debug, Display, Formatter};
+use std::{fmt, io};
+
+use rustc_public_bridge::bridge::SmirError;
+
+macro_rules! error {
+     ($fmt: literal $(,)?) => { Error(format!($fmt)) };
+     ($fmt: literal, $($arg:tt)*) => { Error(format!($fmt, $($arg)*)) };
+}
+
+pub(crate) use error;
+
+/// An error type used to represent an error that has already been reported by the compiler.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum CompilerError<T> {
+    /// Compilation failed, either due to normal errors or ICE.
+    Failed,
+    /// Compilation was interrupted.
+    Interrupted(T),
+    /// Compilation skipped. This happens when users invoke rustc to retrieve information such as
+    /// --version.
+    Skipped,
+}
+
+/// A generic error to represent an API request that cannot be fulfilled.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error(pub(crate) String);
+
+impl SmirError for Error {
+    fn new(msg: String) -> Self {
+        Self(msg)
+    }
+
+    fn from_internal<T: Debug>(err: T) -> Self {
+        Self(format!("{err:?}"))
+    }
+}
+
+impl From<&str> for Error {
+    fn from(value: &str) -> Self {
+        Self(value.into())
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl<T> Display for CompilerError<T>
+where
+    T: Display,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            CompilerError::Failed => write!(f, "Compilation Failed"),
+            CompilerError::Interrupted(reason) => write!(f, "Compilation Interrupted: {reason}"),
+            CompilerError::Skipped => write!(f, "Compilation Skipped"),
+        }
+    }
+}
+
+impl<T> Debug for CompilerError<T>
+where
+    T: Debug,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            CompilerError::Failed => write!(f, "Compilation Failed"),
+            CompilerError::Interrupted(reason) => write!(f, "Compilation Interrupted: {reason:?}"),
+            CompilerError::Skipped => write!(f, "Compilation Skipped"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl<T> std::error::Error for CompilerError<T> where T: Display + Debug {}
+
+impl From<io::Error> for Error {
+    fn from(value: io::Error) -> Self {
+        Error(value.to_string())
+    }
+}
diff --git a/compiler/rustc_public/src/lib.rs b/compiler/rustc_public/src/lib.rs
new file mode 100644
index 00000000000..e320c4eca71
--- /dev/null
+++ b/compiler/rustc_public/src/lib.rs
@@ -0,0 +1,302 @@
+//! The WIP public interface to rustc internals.
+//!
+//! For more information see <https://github.com/rust-lang/project-stable-mir>
+//!
+//! # Note
+//!
+//! This API is still completely unstable and subject to change.
+
+#![allow(rustc::usage_of_ty_tykind)]
+#![doc(
+    html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/",
+    test(attr(allow(unused_variables), deny(warnings)))
+)]
+#![feature(sized_hierarchy)]
+//!
+//! This crate shall contain all type definitions and APIs that we expect third-party tools to invoke to
+//! interact with the compiler.
+//!
+//! The goal is to eventually be published on
+//! [crates.io](https://crates.io).
+
+use std::fmt::Debug;
+use std::{fmt, io};
+
+pub(crate) use rustc_public_bridge::IndexedVal;
+use rustc_public_bridge::Tables;
+use rustc_public_bridge::context::SmirCtxt;
+/// Export the rustc_internal APIs. Note that this module has no stability
+/// guarantees and it is not taken into account for semver.
+#[cfg(feature = "rustc_internal")]
+pub mod rustc_internal;
+use serde::Serialize;
+
+use crate::compiler_interface::with;
+pub use crate::crate_def::{CrateDef, CrateDefItems, CrateDefType, DefId};
+pub use crate::error::*;
+use crate::mir::mono::StaticDef;
+use crate::mir::{Body, Mutability};
+use crate::ty::{AssocItem, FnDef, ForeignModuleDef, ImplDef, ProvenanceMap, Span, TraitDef, Ty};
+use crate::unstable::Stable;
+
+pub mod abi;
+mod alloc;
+pub(crate) mod unstable;
+#[macro_use]
+pub mod crate_def;
+pub mod compiler_interface;
+#[macro_use]
+pub mod error;
+pub mod mir;
+pub mod target;
+pub mod ty;
+pub mod visitor;
+
+/// Use String for now but we should replace it.
+pub type Symbol = String;
+
+/// The number that identifies a crate.
+pub type CrateNum = usize;
+
+impl Debug for DefId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("DefId").field("id", &self.0).field("name", &self.name()).finish()
+    }
+}
+
+impl IndexedVal for DefId {
+    fn to_val(index: usize) -> Self {
+        DefId(index)
+    }
+
+    fn to_index(&self) -> usize {
+        self.0
+    }
+}
+
+/// A list of crate items.
+pub type CrateItems = Vec<CrateItem>;
+
+/// A list of trait decls.
+pub type TraitDecls = Vec<TraitDef>;
+
+/// A list of impl trait decls.
+pub type ImplTraitDecls = Vec<ImplDef>;
+
+/// A list of associated items.
+pub type AssocItems = Vec<AssocItem>;
+
+/// Holds information about a crate.
+#[derive(Clone, PartialEq, Eq, Debug, Serialize)]
+pub struct Crate {
+    pub id: CrateNum,
+    pub name: Symbol,
+    pub is_local: bool,
+}
+
+impl Crate {
+    /// The list of foreign modules in this crate.
+    pub fn foreign_modules(&self) -> Vec<ForeignModuleDef> {
+        with(|cx| cx.foreign_modules(self.id))
+    }
+
+    /// The list of traits declared in this crate.
+    pub fn trait_decls(&self) -> TraitDecls {
+        with(|cx| cx.trait_decls(self.id))
+    }
+
+    /// The list of trait implementations in this crate.
+    pub fn trait_impls(&self) -> ImplTraitDecls {
+        with(|cx| cx.trait_impls(self.id))
+    }
+
+    /// Return a list of function definitions from this crate independent on their visibility.
+    pub fn fn_defs(&self) -> Vec<FnDef> {
+        with(|cx| cx.crate_functions(self.id))
+    }
+
+    /// Return a list of static items defined in this crate independent on their visibility.
+    pub fn statics(&self) -> Vec<StaticDef> {
+        with(|cx| cx.crate_statics(self.id))
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, Serialize)]
+pub enum ItemKind {
+    Fn,
+    Static,
+    Const,
+    Ctor(CtorKind),
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, Serialize)]
+pub enum CtorKind {
+    Const,
+    Fn,
+}
+
+pub type Filename = String;
+
+crate_def_with_ty! {
+    /// Holds information about an item in a crate.
+    #[derive(Serialize)]
+    pub CrateItem;
+}
+
+impl CrateItem {
+    /// This will return the body of an item or panic if it's not available.
+    pub fn expect_body(&self) -> mir::Body {
+        with(|cx| cx.mir_body(self.0))
+    }
+
+    /// Return the body of an item if available.
+    pub fn body(&self) -> Option<mir::Body> {
+        with(|cx| cx.has_body(self.0).then(|| cx.mir_body(self.0)))
+    }
+
+    /// Check if a body is available for this item.
+    pub fn has_body(&self) -> bool {
+        with(|cx| cx.has_body(self.0))
+    }
+
+    pub fn span(&self) -> Span {
+        with(|cx| cx.span_of_an_item(self.0))
+    }
+
+    pub fn kind(&self) -> ItemKind {
+        with(|cx| cx.item_kind(*self))
+    }
+
+    pub fn requires_monomorphization(&self) -> bool {
+        with(|cx| cx.requires_monomorphization(self.0))
+    }
+
+    pub fn ty(&self) -> Ty {
+        with(|cx| cx.def_ty(self.0))
+    }
+
+    pub fn is_foreign_item(&self) -> bool {
+        with(|cx| cx.is_foreign_item(self.0))
+    }
+
+    /// Emit MIR for this item body.
+    pub fn emit_mir<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
+        self.body()
+            .ok_or_else(|| io::Error::other(format!("No body found for `{}`", self.name())))?
+            .dump(w, &self.name())
+    }
+}
+
+/// Return the function where execution starts if the current
+/// crate defines that. This is usually `main`, but could be
+/// `start` if the crate is a no-std crate.
+pub fn entry_fn() -> Option<CrateItem> {
+    with(|cx| cx.entry_fn())
+}
+
+/// Access to the local crate.
+pub fn local_crate() -> Crate {
+    with(|cx| cx.local_crate())
+}
+
+/// Try to find a crate or crates if multiple crates exist from given name.
+pub fn find_crates(name: &str) -> Vec<Crate> {
+    with(|cx| cx.find_crates(name))
+}
+
+/// Try to find a crate with the given name.
+pub fn external_crates() -> Vec<Crate> {
+    with(|cx| cx.external_crates())
+}
+
+/// Retrieve all items in the local crate that have a MIR associated with them.
+pub fn all_local_items() -> CrateItems {
+    with(|cx| cx.all_local_items())
+}
+
+pub fn all_trait_decls() -> TraitDecls {
+    with(|cx| cx.all_trait_decls())
+}
+
+pub fn all_trait_impls() -> ImplTraitDecls {
+    with(|cx| cx.all_trait_impls())
+}
+
+/// A type that provides internal information but that can still be used for debug purpose.
+#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
+pub struct Opaque(String);
+
+impl std::fmt::Display for Opaque {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl std::fmt::Debug for Opaque {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+pub fn opaque<T: Debug>(value: &T) -> Opaque {
+    Opaque(format!("{value:?}"))
+}
+
+macro_rules! bridge_impl {
+    ($name: ident, $ty: ty) => {
+        impl rustc_public_bridge::bridge::$name<compiler_interface::BridgeTys> for $ty {
+            fn new(def: crate::DefId) -> Self {
+                Self(def)
+            }
+        }
+    };
+}
+
+bridge_impl!(CrateItem, crate::CrateItem);
+bridge_impl!(AdtDef, crate::ty::AdtDef);
+bridge_impl!(ForeignModuleDef, crate::ty::ForeignModuleDef);
+bridge_impl!(ForeignDef, crate::ty::ForeignDef);
+bridge_impl!(FnDef, crate::ty::FnDef);
+bridge_impl!(ClosureDef, crate::ty::ClosureDef);
+bridge_impl!(CoroutineDef, crate::ty::CoroutineDef);
+bridge_impl!(CoroutineClosureDef, crate::ty::CoroutineClosureDef);
+bridge_impl!(AliasDef, crate::ty::AliasDef);
+bridge_impl!(ParamDef, crate::ty::ParamDef);
+bridge_impl!(BrNamedDef, crate::ty::BrNamedDef);
+bridge_impl!(TraitDef, crate::ty::TraitDef);
+bridge_impl!(GenericDef, crate::ty::GenericDef);
+bridge_impl!(ConstDef, crate::ty::ConstDef);
+bridge_impl!(ImplDef, crate::ty::ImplDef);
+bridge_impl!(RegionDef, crate::ty::RegionDef);
+bridge_impl!(CoroutineWitnessDef, crate::ty::CoroutineWitnessDef);
+bridge_impl!(AssocDef, crate::ty::AssocDef);
+bridge_impl!(OpaqueDef, crate::ty::OpaqueDef);
+bridge_impl!(StaticDef, crate::mir::mono::StaticDef);
+
+impl rustc_public_bridge::bridge::Prov<compiler_interface::BridgeTys> for crate::ty::Prov {
+    fn new(aid: crate::mir::alloc::AllocId) -> Self {
+        Self(aid)
+    }
+}
+
+impl rustc_public_bridge::bridge::Allocation<compiler_interface::BridgeTys>
+    for crate::ty::Allocation
+{
+    fn new<'tcx>(
+        bytes: Vec<Option<u8>>,
+        ptrs: Vec<(usize, rustc_middle::mir::interpret::AllocId)>,
+        align: u64,
+        mutability: rustc_middle::mir::Mutability,
+        tables: &mut Tables<'tcx, compiler_interface::BridgeTys>,
+        cx: &SmirCtxt<'tcx, compiler_interface::BridgeTys>,
+    ) -> Self {
+        Self {
+            bytes,
+            provenance: ProvenanceMap {
+                ptrs: ptrs.iter().map(|(i, aid)| (*i, tables.prov(*aid))).collect(),
+            },
+            align,
+            mutability: mutability.stable(tables, cx),
+        }
+    }
+}
diff --git a/compiler/rustc_public/src/mir.rs b/compiler/rustc_public/src/mir.rs
new file mode 100644
index 00000000000..413b5152bb3
--- /dev/null
+++ b/compiler/rustc_public/src/mir.rs
@@ -0,0 +1,8 @@
+pub mod alloc;
+mod body;
+pub mod mono;
+pub mod pretty;
+pub mod visit;
+
+pub use body::*;
+pub use visit::{MirVisitor, MutMirVisitor};
diff --git a/compiler/rustc_public/src/mir/alloc.rs b/compiler/rustc_public/src/mir/alloc.rs
new file mode 100644
index 00000000000..9a94551f3ec
--- /dev/null
+++ b/compiler/rustc_public/src/mir/alloc.rs
@@ -0,0 +1,90 @@
+//! This module provides methods to retrieve allocation information, such as static variables.
+
+use std::io::Read;
+
+use serde::Serialize;
+
+use crate::mir::mono::{Instance, StaticDef};
+use crate::target::{Endian, MachineInfo};
+use crate::ty::{Allocation, Binder, ExistentialTraitRef, Ty};
+use crate::{Error, IndexedVal, with};
+
+/// An allocation in the SMIR global memory can be either a function pointer,
+/// a static, or a "real" allocation with some data in it.
+#[derive(Debug, Clone, Eq, PartialEq, Serialize)]
+pub enum GlobalAlloc {
+    /// The alloc ID is used as a function pointer.
+    Function(Instance),
+    /// This alloc ID points to a symbolic (not-reified) vtable.
+    /// The `None` trait ref is used to represent auto traits.
+    VTable(Ty, Option<Binder<ExistentialTraitRef>>),
+    /// The alloc ID points to a "lazy" static variable that did not get computed (yet).
+    /// This is also used to break the cycle in recursive statics.
+    Static(StaticDef),
+    /// The alloc ID points to memory.
+    Memory(Allocation),
+    /// The first pointer-sized segment of a type id. On 64 bit systems, the 128 bit type id
+    /// is split into two segments, on 32 bit systems there are 4 segments, and so on.
+    TypeId { ty: Ty },
+}
+
+impl From<AllocId> for GlobalAlloc {
+    fn from(value: AllocId) -> Self {
+        with(|cx| cx.global_alloc(value))
+    }
+}
+
+impl GlobalAlloc {
+    /// Retrieve the allocation id for a global allocation if it exists.
+    ///
+    /// For `[GlobalAlloc::VTable]`, this will return the allocation for the VTable of the given
+    /// type for the optional trait if the type implements the trait.
+    ///
+    /// This method will always return `None` for allocations other than `[GlobalAlloc::VTable]`.
+    pub fn vtable_allocation(&self) -> Option<AllocId> {
+        with(|cx| cx.vtable_allocation(self))
+    }
+}
+
+/// A unique identification number for each provenance
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
+pub struct AllocId(usize);
+
+impl IndexedVal for AllocId {
+    fn to_val(index: usize) -> Self {
+        AllocId(index)
+    }
+    fn to_index(&self) -> usize {
+        self.0
+    }
+}
+
+/// Utility function used to read an allocation data into a unassigned integer.
+pub(crate) fn read_target_uint(mut bytes: &[u8]) -> Result<u128, Error> {
+    let mut buf = [0u8; size_of::<u128>()];
+    match MachineInfo::target_endianness() {
+        Endian::Little => {
+            bytes.read_exact(&mut buf[..bytes.len()])?;
+            Ok(u128::from_le_bytes(buf))
+        }
+        Endian::Big => {
+            bytes.read_exact(&mut buf[16 - bytes.len()..])?;
+            Ok(u128::from_be_bytes(buf))
+        }
+    }
+}
+
+/// Utility function used to read an allocation data into an assigned integer.
+pub(crate) fn read_target_int(mut bytes: &[u8]) -> Result<i128, Error> {
+    let mut buf = [0u8; size_of::<i128>()];
+    match MachineInfo::target_endianness() {
+        Endian::Little => {
+            bytes.read_exact(&mut buf[..bytes.len()])?;
+            Ok(i128::from_le_bytes(buf))
+        }
+        Endian::Big => {
+            bytes.read_exact(&mut buf[16 - bytes.len()..])?;
+            Ok(i128::from_be_bytes(buf))
+        }
+    }
+}
diff --git a/compiler/rustc_public/src/mir/body.rs b/compiler/rustc_public/src/mir/body.rs
new file mode 100644
index 00000000000..28a7aa6e758
--- /dev/null
+++ b/compiler/rustc_public/src/mir/body.rs
@@ -0,0 +1,1127 @@
+use std::io;
+
+use serde::Serialize;
+
+use crate::compiler_interface::with;
+use crate::mir::pretty::function_body;
+use crate::ty::{
+    AdtDef, ClosureDef, CoroutineClosureDef, CoroutineDef, GenericArgs, MirConst, Movability,
+    Region, RigidTy, Ty, TyConst, TyKind, VariantIdx,
+};
+use crate::{Error, Opaque, Span, Symbol};
+
+/// The SMIR representation of a single function.
+#[derive(Clone, Debug, Serialize)]
+pub struct Body {
+    pub blocks: Vec<BasicBlock>,
+
+    /// Declarations of locals within the function.
+    ///
+    /// The first local is the return value pointer, followed by `arg_count`
+    /// locals for the function arguments, followed by any user-declared
+    /// variables and temporaries.
+    pub(super) locals: LocalDecls,
+
+    /// The number of arguments this function takes.
+    pub(super) arg_count: usize,
+
+    /// Debug information pertaining to user variables, including captures.
+    pub var_debug_info: Vec<VarDebugInfo>,
+
+    /// Mark an argument (which must be a tuple) as getting passed as its individual components.
+    ///
+    /// This is used for the "rust-call" ABI such as closures.
+    pub(super) spread_arg: Option<Local>,
+
+    /// The span that covers the entire function body.
+    pub span: Span,
+}
+
+pub type BasicBlockIdx = usize;
+
+impl Body {
+    /// Constructs a `Body`.
+    ///
+    /// A constructor is required to build a `Body` from outside the crate
+    /// because the `arg_count` and `locals` fields are private.
+    pub fn new(
+        blocks: Vec<BasicBlock>,
+        locals: LocalDecls,
+        arg_count: usize,
+        var_debug_info: Vec<VarDebugInfo>,
+        spread_arg: Option<Local>,
+        span: Span,
+    ) -> Self {
+        // If locals doesn't contain enough entries, it can lead to panics in
+        // `ret_local`, `arg_locals`, and `inner_locals`.
+        assert!(
+            locals.len() > arg_count,
+            "A Body must contain at least a local for the return value and each of the function's arguments"
+        );
+        Self { blocks, locals, arg_count, var_debug_info, spread_arg, span }
+    }
+
+    /// Return local that holds this function's return value.
+    pub fn ret_local(&self) -> &LocalDecl {
+        &self.locals[RETURN_LOCAL]
+    }
+
+    /// Locals in `self` that correspond to this function's arguments.
+    pub fn arg_locals(&self) -> &[LocalDecl] {
+        &self.locals[1..][..self.arg_count]
+    }
+
+    /// Inner locals for this function. These are the locals that are
+    /// neither the return local nor the argument locals.
+    pub fn inner_locals(&self) -> &[LocalDecl] {
+        &self.locals[self.arg_count + 1..]
+    }
+
+    /// Returns a mutable reference to the local that holds this function's return value.
+    pub(crate) fn ret_local_mut(&mut self) -> &mut LocalDecl {
+        &mut self.locals[RETURN_LOCAL]
+    }
+
+    /// Returns a mutable slice of locals corresponding to this function's arguments.
+    pub(crate) fn arg_locals_mut(&mut self) -> &mut [LocalDecl] {
+        &mut self.locals[1..][..self.arg_count]
+    }
+
+    /// Returns a mutable slice of inner locals for this function.
+    /// Inner locals are those that are neither the return local nor the argument locals.
+    pub(crate) fn inner_locals_mut(&mut self) -> &mut [LocalDecl] {
+        &mut self.locals[self.arg_count + 1..]
+    }
+
+    /// Convenience function to get all the locals in this function.
+    ///
+    /// Locals are typically accessed via the more specific methods `ret_local`,
+    /// `arg_locals`, and `inner_locals`.
+    pub fn locals(&self) -> &[LocalDecl] {
+        &self.locals
+    }
+
+    /// Get the local declaration for this local.
+    pub fn local_decl(&self, local: Local) -> Option<&LocalDecl> {
+        self.locals.get(local)
+    }
+
+    /// Get an iterator for all local declarations.
+    pub fn local_decls(&self) -> impl Iterator<Item = (Local, &LocalDecl)> {
+        self.locals.iter().enumerate()
+    }
+
+    /// Emit the body using the provided name for the signature.
+    pub fn dump<W: io::Write>(&self, w: &mut W, fn_name: &str) -> io::Result<()> {
+        function_body(w, self, fn_name)
+    }
+
+    pub fn spread_arg(&self) -> Option<Local> {
+        self.spread_arg
+    }
+}
+
+type LocalDecls = Vec<LocalDecl>;
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct LocalDecl {
+    pub ty: Ty,
+    pub span: Span,
+    pub mutability: Mutability,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Serialize)]
+pub struct BasicBlock {
+    pub statements: Vec<Statement>,
+    pub terminator: Terminator,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct Terminator {
+    pub kind: TerminatorKind,
+    pub span: Span,
+}
+
+impl Terminator {
+    pub fn successors(&self) -> Successors {
+        self.kind.successors()
+    }
+}
+
+pub type Successors = Vec<BasicBlockIdx>;
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum TerminatorKind {
+    Goto {
+        target: BasicBlockIdx,
+    },
+    SwitchInt {
+        discr: Operand,
+        targets: SwitchTargets,
+    },
+    Resume,
+    Abort,
+    Return,
+    Unreachable,
+    Drop {
+        place: Place,
+        target: BasicBlockIdx,
+        unwind: UnwindAction,
+    },
+    Call {
+        func: Operand,
+        args: Vec<Operand>,
+        destination: Place,
+        target: Option<BasicBlockIdx>,
+        unwind: UnwindAction,
+    },
+    Assert {
+        cond: Operand,
+        expected: bool,
+        msg: AssertMessage,
+        target: BasicBlockIdx,
+        unwind: UnwindAction,
+    },
+    InlineAsm {
+        template: String,
+        operands: Vec<InlineAsmOperand>,
+        options: String,
+        line_spans: String,
+        destination: Option<BasicBlockIdx>,
+        unwind: UnwindAction,
+    },
+}
+
+impl TerminatorKind {
+    pub fn successors(&self) -> Successors {
+        use self::TerminatorKind::*;
+        match *self {
+            Call { target: Some(t), unwind: UnwindAction::Cleanup(u), .. }
+            | Drop { target: t, unwind: UnwindAction::Cleanup(u), .. }
+            | Assert { target: t, unwind: UnwindAction::Cleanup(u), .. }
+            | InlineAsm { destination: Some(t), unwind: UnwindAction::Cleanup(u), .. } => {
+                vec![t, u]
+            }
+            Goto { target: t }
+            | Call { target: None, unwind: UnwindAction::Cleanup(t), .. }
+            | Call { target: Some(t), unwind: _, .. }
+            | Drop { target: t, unwind: _, .. }
+            | Assert { target: t, unwind: _, .. }
+            | InlineAsm { destination: None, unwind: UnwindAction::Cleanup(t), .. }
+            | InlineAsm { destination: Some(t), unwind: _, .. } => {
+                vec![t]
+            }
+
+            Return
+            | Resume
+            | Abort
+            | Unreachable
+            | Call { target: None, unwind: _, .. }
+            | InlineAsm { destination: None, unwind: _, .. } => {
+                vec![]
+            }
+            SwitchInt { ref targets, .. } => targets.all_targets(),
+        }
+    }
+
+    pub fn unwind(&self) -> Option<&UnwindAction> {
+        match *self {
+            TerminatorKind::Goto { .. }
+            | TerminatorKind::Return
+            | TerminatorKind::Unreachable
+            | TerminatorKind::Resume
+            | TerminatorKind::Abort
+            | TerminatorKind::SwitchInt { .. } => None,
+            TerminatorKind::Call { ref unwind, .. }
+            | TerminatorKind::Assert { ref unwind, .. }
+            | TerminatorKind::Drop { ref unwind, .. }
+            | TerminatorKind::InlineAsm { ref unwind, .. } => Some(unwind),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct InlineAsmOperand {
+    pub in_value: Option<Operand>,
+    pub out_place: Option<Place>,
+    // This field has a raw debug representation of MIR's InlineAsmOperand.
+    // For now we care about place/operand + the rest in a debug format.
+    pub raw_rpr: String,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum UnwindAction {
+    Continue,
+    Unreachable,
+    Terminate,
+    Cleanup(BasicBlockIdx),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum AssertMessage {
+    BoundsCheck { len: Operand, index: Operand },
+    Overflow(BinOp, Operand, Operand),
+    OverflowNeg(Operand),
+    DivisionByZero(Operand),
+    RemainderByZero(Operand),
+    ResumedAfterReturn(CoroutineKind),
+    ResumedAfterPanic(CoroutineKind),
+    ResumedAfterDrop(CoroutineKind),
+    MisalignedPointerDereference { required: Operand, found: Operand },
+    NullPointerDereference,
+    InvalidEnumConstruction(Operand),
+}
+
+impl AssertMessage {
+    pub fn description(&self) -> Result<&'static str, Error> {
+        match self {
+            AssertMessage::Overflow(BinOp::Add, _, _) => Ok("attempt to add with overflow"),
+            AssertMessage::Overflow(BinOp::Sub, _, _) => Ok("attempt to subtract with overflow"),
+            AssertMessage::Overflow(BinOp::Mul, _, _) => Ok("attempt to multiply with overflow"),
+            AssertMessage::Overflow(BinOp::Div, _, _) => Ok("attempt to divide with overflow"),
+            AssertMessage::Overflow(BinOp::Rem, _, _) => {
+                Ok("attempt to calculate the remainder with overflow")
+            }
+            AssertMessage::OverflowNeg(_) => Ok("attempt to negate with overflow"),
+            AssertMessage::Overflow(BinOp::Shr, _, _) => Ok("attempt to shift right with overflow"),
+            AssertMessage::Overflow(BinOp::Shl, _, _) => Ok("attempt to shift left with overflow"),
+            AssertMessage::Overflow(op, _, _) => Err(error!("`{:?}` cannot overflow", op)),
+            AssertMessage::DivisionByZero(_) => Ok("attempt to divide by zero"),
+            AssertMessage::RemainderByZero(_) => {
+                Ok("attempt to calculate the remainder with a divisor of zero")
+            }
+            AssertMessage::ResumedAfterReturn(CoroutineKind::Coroutine(_)) => {
+                Ok("coroutine resumed after completion")
+            }
+            AssertMessage::ResumedAfterReturn(CoroutineKind::Desugared(
+                CoroutineDesugaring::Async,
+                _,
+            )) => Ok("`async fn` resumed after completion"),
+            AssertMessage::ResumedAfterReturn(CoroutineKind::Desugared(
+                CoroutineDesugaring::Gen,
+                _,
+            )) => Ok("`async gen fn` resumed after completion"),
+            AssertMessage::ResumedAfterReturn(CoroutineKind::Desugared(
+                CoroutineDesugaring::AsyncGen,
+                _,
+            )) => Ok("`gen fn` should just keep returning `AssertMessage::None` after completion"),
+            AssertMessage::ResumedAfterPanic(CoroutineKind::Coroutine(_)) => {
+                Ok("coroutine resumed after panicking")
+            }
+            AssertMessage::ResumedAfterPanic(CoroutineKind::Desugared(
+                CoroutineDesugaring::Async,
+                _,
+            )) => Ok("`async fn` resumed after panicking"),
+            AssertMessage::ResumedAfterPanic(CoroutineKind::Desugared(
+                CoroutineDesugaring::Gen,
+                _,
+            )) => Ok("`async gen fn` resumed after panicking"),
+            AssertMessage::ResumedAfterPanic(CoroutineKind::Desugared(
+                CoroutineDesugaring::AsyncGen,
+                _,
+            )) => Ok("`gen fn` should just keep returning `AssertMessage::None` after panicking"),
+
+            AssertMessage::ResumedAfterDrop(CoroutineKind::Coroutine(_)) => {
+                Ok("coroutine resumed after async drop")
+            }
+            AssertMessage::ResumedAfterDrop(CoroutineKind::Desugared(
+                CoroutineDesugaring::Async,
+                _,
+            )) => Ok("`async fn` resumed after async drop"),
+            AssertMessage::ResumedAfterDrop(CoroutineKind::Desugared(
+                CoroutineDesugaring::Gen,
+                _,
+            )) => Ok("`async gen fn` resumed after async drop"),
+            AssertMessage::ResumedAfterDrop(CoroutineKind::Desugared(
+                CoroutineDesugaring::AsyncGen,
+                _,
+            )) => Ok("`gen fn` should just keep returning `AssertMessage::None` after async drop"),
+
+            AssertMessage::BoundsCheck { .. } => Ok("index out of bounds"),
+            AssertMessage::MisalignedPointerDereference { .. } => {
+                Ok("misaligned pointer dereference")
+            }
+            AssertMessage::NullPointerDereference => Ok("null pointer dereference occurred"),
+            AssertMessage::InvalidEnumConstruction(_) => {
+                Ok("trying to construct an enum from an invalid value")
+            }
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum BinOp {
+    Add,
+    AddUnchecked,
+    Sub,
+    SubUnchecked,
+    Mul,
+    MulUnchecked,
+    Div,
+    Rem,
+    BitXor,
+    BitAnd,
+    BitOr,
+    Shl,
+    ShlUnchecked,
+    Shr,
+    ShrUnchecked,
+    Eq,
+    Lt,
+    Le,
+    Ne,
+    Ge,
+    Gt,
+    Cmp,
+    Offset,
+}
+
+impl BinOp {
+    /// Return the type of this operation for the given input Ty.
+    /// This function does not perform type checking, and it currently doesn't handle SIMD.
+    pub fn ty(&self, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
+        with(|ctx| ctx.binop_ty(*self, lhs_ty, rhs_ty))
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum UnOp {
+    Not,
+    Neg,
+    PtrMetadata,
+}
+
+impl UnOp {
+    /// Return the type of this operation for the given input Ty.
+    /// This function does not perform type checking, and it currently doesn't handle SIMD.
+    pub fn ty(&self, arg_ty: Ty) -> Ty {
+        with(|ctx| ctx.unop_ty(*self, arg_ty))
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum CoroutineKind {
+    Desugared(CoroutineDesugaring, CoroutineSource),
+    Coroutine(Movability),
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum CoroutineSource {
+    Block,
+    Closure,
+    Fn,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum CoroutineDesugaring {
+    Async,
+
+    Gen,
+
+    AsyncGen,
+}
+
+pub(crate) type LocalDefId = Opaque;
+/// The rustc coverage data structures are heavily tied to internal details of the
+/// coverage implementation that are likely to change, and are unlikely to be
+/// useful to third-party tools for the foreseeable future.
+pub(crate) type Coverage = Opaque;
+
+/// The FakeReadCause describes the type of pattern why a FakeRead statement exists.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum FakeReadCause {
+    ForMatchGuard,
+    ForMatchedPlace(LocalDefId),
+    ForGuardBinding,
+    ForLet(LocalDefId),
+    ForIndex,
+}
+
+/// Describes what kind of retag is to be performed
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Serialize)]
+pub enum RetagKind {
+    FnEntry,
+    TwoPhase,
+    Raw,
+    Default,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Serialize)]
+pub enum Variance {
+    Covariant,
+    Invariant,
+    Contravariant,
+    Bivariant,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct CopyNonOverlapping {
+    pub src: Operand,
+    pub dst: Operand,
+    pub count: Operand,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum NonDivergingIntrinsic {
+    Assume(Operand),
+    CopyNonOverlapping(CopyNonOverlapping),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct Statement {
+    pub kind: StatementKind,
+    pub span: Span,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum StatementKind {
+    Assign(Place, Rvalue),
+    FakeRead(FakeReadCause, Place),
+    SetDiscriminant { place: Place, variant_index: VariantIdx },
+    Deinit(Place),
+    StorageLive(Local),
+    StorageDead(Local),
+    Retag(RetagKind, Place),
+    PlaceMention(Place),
+    AscribeUserType { place: Place, projections: UserTypeProjection, variance: Variance },
+    Coverage(Coverage),
+    Intrinsic(NonDivergingIntrinsic),
+    ConstEvalCounter,
+    Nop,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum Rvalue {
+    /// Creates a pointer with the indicated mutability to the place.
+    ///
+    /// This is generated by pointer casts like `&v as *const _` or raw address of expressions like
+    /// `&raw v` or `addr_of!(v)`.
+    AddressOf(RawPtrKind, Place),
+
+    /// Creates an aggregate value, like a tuple or struct.
+    ///
+    /// This is needed because dataflow analysis needs to distinguish
+    /// `dest = Foo { x: ..., y: ... }` from `dest.x = ...; dest.y = ...;` in the case that `Foo`
+    /// has a destructor.
+    ///
+    /// Disallowed after deaggregation for all aggregate kinds except `Array` and `Coroutine`. After
+    /// coroutine lowering, `Coroutine` aggregate kinds are disallowed too.
+    Aggregate(AggregateKind, Vec<Operand>),
+
+    /// * `Offset` has the same semantics as `<*const T>::offset`, except that the second
+    ///   parameter may be a `usize` as well.
+    /// * The comparison operations accept `bool`s, `char`s, signed or unsigned integers, floats,
+    ///   raw pointers, or function pointers and return a `bool`. The types of the operands must be
+    ///   matching, up to the usual caveat of the lifetimes in function pointers.
+    /// * Left and right shift operations accept signed or unsigned integers not necessarily of the
+    ///   same type and return a value of the same type as their LHS. Like in Rust, the RHS is
+    ///   truncated as needed.
+    /// * The `Bit*` operations accept signed integers, unsigned integers, or bools with matching
+    ///   types and return a value of that type.
+    /// * The remaining operations accept signed integers, unsigned integers, or floats with
+    ///   matching types and return a value of that type.
+    BinaryOp(BinOp, Operand, Operand),
+
+    /// Performs essentially all of the casts that can be performed via `as`.
+    ///
+    /// This allows for casts from/to a variety of types.
+    Cast(CastKind, Operand, Ty),
+
+    /// Same as `BinaryOp`, but yields `(T, bool)` with a `bool` indicating an error condition.
+    ///
+    /// For addition, subtraction, and multiplication on integers the error condition is set when
+    /// the infinite precision result would not be equal to the actual result.
+    CheckedBinaryOp(BinOp, Operand, Operand),
+
+    /// A CopyForDeref is equivalent to a read from a place.
+    /// When such a read happens, it is guaranteed that the only use of the returned value is a
+    /// deref operation, immediately followed by one or more projections.
+    CopyForDeref(Place),
+
+    /// Computes the discriminant of the place, returning it as an integer.
+    /// Returns zero for types without discriminant.
+    ///
+    /// The validity requirements for the underlying value are undecided for this rvalue, see
+    /// [#91095]. Note too that the value of the discriminant is not the same thing as the
+    /// variant index;
+    ///
+    /// [#91095]: https://github.com/rust-lang/rust/issues/91095
+    Discriminant(Place),
+
+    /// Yields the length of the place, as a `usize`.
+    ///
+    /// If the type of the place is an array, this is the array length. For slices (`[T]`, not
+    /// `&[T]`) this accesses the place's metadata to determine the length. This rvalue is
+    /// ill-formed for places of other types.
+    Len(Place),
+
+    /// Creates a reference to the place.
+    Ref(Region, BorrowKind, Place),
+
+    /// Creates an array where each element is the value of the operand.
+    ///
+    /// This is the cause of a bug in the case where the repetition count is zero because the value
+    /// is not dropped, see [#74836].
+    ///
+    /// Corresponds to source code like `[x; 32]`.
+    ///
+    /// [#74836]: https://github.com/rust-lang/rust/issues/74836
+    Repeat(Operand, TyConst),
+
+    /// Transmutes a `*mut u8` into shallow-initialized `Box<T>`.
+    ///
+    /// This is different from a normal transmute because dataflow analysis will treat the box as
+    /// initialized but its content as uninitialized. Like other pointer casts, this in general
+    /// affects alias analysis.
+    ShallowInitBox(Operand, Ty),
+
+    /// Creates a pointer/reference to the given thread local.
+    ///
+    /// The yielded type is a `*mut T` if the static is mutable, otherwise if the static is extern a
+    /// `*const T`, and if neither of those apply a `&T`.
+    ///
+    /// **Note:** This is a runtime operation that actually executes code and is in this sense more
+    /// like a function call. Also, eliminating dead stores of this rvalue causes `fn main() {}` to
+    /// SIGILL for some reason that I (JakobDegen) never got a chance to look into.
+    ///
+    /// **Needs clarification**: Are there weird additional semantics here related to the runtime
+    /// nature of this operation?
+    ThreadLocalRef(crate::CrateItem),
+
+    /// Computes a value as described by the operation.
+    NullaryOp(NullOp, Ty),
+
+    /// Exactly like `BinaryOp`, but less operands.
+    ///
+    /// Also does two's-complement arithmetic. Negation requires a signed integer or a float;
+    /// bitwise not requires a signed integer, unsigned integer, or bool. Both operation kinds
+    /// return a value with the same type as their operand.
+    UnaryOp(UnOp, Operand),
+
+    /// Yields the operand unchanged
+    Use(Operand),
+}
+
+impl Rvalue {
+    pub fn ty(&self, locals: &[LocalDecl]) -> Result<Ty, Error> {
+        match self {
+            Rvalue::Use(operand) => operand.ty(locals),
+            Rvalue::Repeat(operand, count) => {
+                Ok(Ty::new_array_with_const_len(operand.ty(locals)?, count.clone()))
+            }
+            Rvalue::ThreadLocalRef(did) => Ok(did.ty()),
+            Rvalue::Ref(reg, bk, place) => {
+                let place_ty = place.ty(locals)?;
+                Ok(Ty::new_ref(reg.clone(), place_ty, bk.to_mutable_lossy()))
+            }
+            Rvalue::AddressOf(mutability, place) => {
+                let place_ty = place.ty(locals)?;
+                Ok(Ty::new_ptr(place_ty, mutability.to_mutable_lossy()))
+            }
+            Rvalue::Len(..) => Ok(Ty::usize_ty()),
+            Rvalue::Cast(.., ty) => Ok(*ty),
+            Rvalue::BinaryOp(op, lhs, rhs) => {
+                let lhs_ty = lhs.ty(locals)?;
+                let rhs_ty = rhs.ty(locals)?;
+                Ok(op.ty(lhs_ty, rhs_ty))
+            }
+            Rvalue::CheckedBinaryOp(op, lhs, rhs) => {
+                let lhs_ty = lhs.ty(locals)?;
+                let rhs_ty = rhs.ty(locals)?;
+                let ty = op.ty(lhs_ty, rhs_ty);
+                Ok(Ty::new_tuple(&[ty, Ty::bool_ty()]))
+            }
+            Rvalue::UnaryOp(op, operand) => {
+                let arg_ty = operand.ty(locals)?;
+                Ok(op.ty(arg_ty))
+            }
+            Rvalue::Discriminant(place) => {
+                let place_ty = place.ty(locals)?;
+                place_ty
+                    .kind()
+                    .discriminant_ty()
+                    .ok_or_else(|| error!("Expected a `RigidTy` but found: {place_ty:?}"))
+            }
+            Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..), _) => {
+                Ok(Ty::usize_ty())
+            }
+            Rvalue::NullaryOp(NullOp::ContractChecks, _)
+            | Rvalue::NullaryOp(NullOp::UbChecks, _) => Ok(Ty::bool_ty()),
+            Rvalue::Aggregate(ak, ops) => match *ak {
+                AggregateKind::Array(ty) => Ty::try_new_array(ty, ops.len() as u64),
+                AggregateKind::Tuple => Ok(Ty::new_tuple(
+                    &ops.iter().map(|op| op.ty(locals)).collect::<Result<Vec<_>, _>>()?,
+                )),
+                AggregateKind::Adt(def, _, ref args, _, _) => Ok(def.ty_with_args(args)),
+                AggregateKind::Closure(def, ref args) => Ok(Ty::new_closure(def, args.clone())),
+                AggregateKind::Coroutine(def, ref args, mov) => {
+                    Ok(Ty::new_coroutine(def, args.clone(), mov))
+                }
+                AggregateKind::CoroutineClosure(def, ref args) => {
+                    Ok(Ty::new_coroutine_closure(def, args.clone()))
+                }
+                AggregateKind::RawPtr(ty, mutability) => Ok(Ty::new_ptr(ty, mutability)),
+            },
+            Rvalue::ShallowInitBox(_, ty) => Ok(Ty::new_box(*ty)),
+            Rvalue::CopyForDeref(place) => place.ty(locals),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum AggregateKind {
+    Array(Ty),
+    Tuple,
+    Adt(AdtDef, VariantIdx, GenericArgs, Option<UserTypeAnnotationIndex>, Option<FieldIdx>),
+    Closure(ClosureDef, GenericArgs),
+    // FIXME(rustc_public): Movability here is redundant
+    Coroutine(CoroutineDef, GenericArgs, Movability),
+    CoroutineClosure(CoroutineClosureDef, GenericArgs),
+    RawPtr(Ty, Mutability),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum Operand {
+    Copy(Place),
+    Move(Place),
+    Constant(ConstOperand),
+}
+
+#[derive(Clone, Eq, PartialEq, Serialize)]
+pub struct Place {
+    pub local: Local,
+    /// projection out of a place (access a field, deref a pointer, etc)
+    pub projection: Vec<ProjectionElem>,
+}
+
+impl From<Local> for Place {
+    fn from(local: Local) -> Self {
+        Place { local, projection: vec![] }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct ConstOperand {
+    pub span: Span,
+    pub user_ty: Option<UserTypeAnnotationIndex>,
+    pub const_: MirConst,
+}
+
+/// Debug information pertaining to a user variable.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct VarDebugInfo {
+    /// The variable name.
+    pub name: Symbol,
+
+    /// Source info of the user variable, including the scope
+    /// within which the variable is visible (to debuginfo).
+    pub source_info: SourceInfo,
+
+    /// The user variable's data is split across several fragments,
+    /// each described by a `VarDebugInfoFragment`.
+    pub composite: Option<VarDebugInfoFragment>,
+
+    /// Where the data for this user variable is to be found.
+    pub value: VarDebugInfoContents,
+
+    /// When present, indicates what argument number this variable is in the function that it
+    /// originated from (starting from 1). Note, if MIR inlining is enabled, then this is the
+    /// argument number in the original function before it was inlined.
+    pub argument_index: Option<u16>,
+}
+
+impl VarDebugInfo {
+    /// Return a local variable if this info is related to one.
+    pub fn local(&self) -> Option<Local> {
+        match &self.value {
+            VarDebugInfoContents::Place(place) if place.projection.is_empty() => Some(place.local),
+            VarDebugInfoContents::Place(_) | VarDebugInfoContents::Const(_) => None,
+        }
+    }
+
+    /// Return a constant if this info is related to one.
+    pub fn constant(&self) -> Option<&ConstOperand> {
+        match &self.value {
+            VarDebugInfoContents::Place(_) => None,
+            VarDebugInfoContents::Const(const_op) => Some(const_op),
+        }
+    }
+}
+
+pub type SourceScope = u32;
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct SourceInfo {
+    pub span: Span,
+    pub scope: SourceScope,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct VarDebugInfoFragment {
+    pub ty: Ty,
+    pub projection: Vec<ProjectionElem>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum VarDebugInfoContents {
+    Place(Place),
+    Const(ConstOperand),
+}
+
+// In MIR ProjectionElem is parameterized on the second Field argument and the Index argument. This
+// is so it can be used for both Places (for which the projection elements are of type
+// ProjectionElem<Local, Ty>) and user-provided type annotations (for which the projection elements
+// are of type ProjectionElem<(), ()>). In SMIR we don't need this generality, so we just use
+// ProjectionElem for Places.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum ProjectionElem {
+    /// Dereference projections (e.g. `*_1`) project to the address referenced by the base place.
+    Deref,
+
+    /// A field projection (e.g., `f` in `_1.f`) project to a field in the base place. The field is
+    /// referenced by source-order index rather than the name of the field. The fields type is also
+    /// given.
+    Field(FieldIdx, Ty),
+
+    /// Index into a slice/array. The value of the index is computed at runtime using the `V`
+    /// argument.
+    ///
+    /// Note that this does not also dereference, and so it does not exactly correspond to slice
+    /// indexing in Rust. In other words, in the below Rust code:
+    ///
+    /// ```rust
+    /// let x = &[1, 2, 3, 4];
+    /// let i = 2;
+    /// x[i];
+    /// ```
+    ///
+    /// The `x[i]` is turned into a `Deref` followed by an `Index`, not just an `Index`. The same
+    /// thing is true of the `ConstantIndex` and `Subslice` projections below.
+    Index(Local),
+
+    /// Index into a slice/array given by offsets.
+    ///
+    /// These indices are generated by slice patterns. Easiest to explain by example:
+    ///
+    /// ```ignore (illustrative)
+    /// [X, _, .._, _, _] => { offset: 0, min_length: 4, from_end: false },
+    /// [_, X, .._, _, _] => { offset: 1, min_length: 4, from_end: false },
+    /// [_, _, .._, X, _] => { offset: 2, min_length: 4, from_end: true },
+    /// [_, _, .._, _, X] => { offset: 1, min_length: 4, from_end: true },
+    /// ```
+    ConstantIndex {
+        /// index or -index (in Python terms), depending on from_end
+        offset: u64,
+        /// The thing being indexed must be at least this long -- otherwise, the
+        /// projection is UB.
+        ///
+        /// For arrays this is always the exact length.
+        min_length: u64,
+        /// Counting backwards from end? This is always false when indexing an
+        /// array.
+        from_end: bool,
+    },
+
+    /// Projects a slice from the base place.
+    ///
+    /// These indices are generated by slice patterns. If `from_end` is true, this represents
+    /// `slice[from..slice.len() - to]`. Otherwise it represents `array[from..to]`.
+    Subslice {
+        from: u64,
+        to: u64,
+        /// Whether `to` counts from the start or end of the array/slice.
+        from_end: bool,
+    },
+
+    /// "Downcast" to a variant of an enum or a coroutine.
+    Downcast(VariantIdx),
+
+    /// Like an explicit cast from an opaque type to a concrete type, but without
+    /// requiring an intermediate variable.
+    OpaqueCast(Ty),
+
+    /// A `Subtype(T)` projection is applied to any `StatementKind::Assign` where
+    /// type of lvalue doesn't match the type of rvalue, the primary goal is making subtyping
+    /// explicit during optimizations and codegen.
+    ///
+    /// This projection doesn't impact the runtime behavior of the program except for potentially changing
+    /// some type metadata of the interpreter or codegen backend.
+    Subtype(Ty),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct UserTypeProjection {
+    pub base: UserTypeAnnotationIndex,
+
+    pub projection: Opaque,
+}
+
+pub type Local = usize;
+
+pub const RETURN_LOCAL: Local = 0;
+
+/// The source-order index of a field in a variant.
+///
+/// For example, in the following types,
+/// ```ignore(illustrative)
+/// enum Demo1 {
+///    Variant0 { a: bool, b: i32 },
+///    Variant1 { c: u8, d: u64 },
+/// }
+/// struct Demo2 { e: u8, f: u16, g: u8 }
+/// ```
+/// `a`'s `FieldIdx` is `0`,
+/// `b`'s `FieldIdx` is `1`,
+/// `c`'s `FieldIdx` is `0`, and
+/// `g`'s `FieldIdx` is `2`.
+pub type FieldIdx = usize;
+
+type UserTypeAnnotationIndex = usize;
+
+/// The possible branch sites of a [TerminatorKind::SwitchInt].
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct SwitchTargets {
+    /// The conditional branches where the first element represents the value that guards this
+    /// branch, and the second element is the branch target.
+    branches: Vec<(u128, BasicBlockIdx)>,
+    /// The `otherwise` branch which will be taken in case none of the conditional branches are
+    /// satisfied.
+    otherwise: BasicBlockIdx,
+}
+
+impl SwitchTargets {
+    /// All possible targets including the `otherwise` target.
+    pub fn all_targets(&self) -> Successors {
+        self.branches.iter().map(|(_, target)| *target).chain(Some(self.otherwise)).collect()
+    }
+
+    /// The `otherwise` branch target.
+    pub fn otherwise(&self) -> BasicBlockIdx {
+        self.otherwise
+    }
+
+    /// The conditional targets which are only taken if the pattern matches the given value.
+    pub fn branches(&self) -> impl Iterator<Item = (u128, BasicBlockIdx)> {
+        self.branches.iter().copied()
+    }
+
+    /// The number of targets including `otherwise`.
+    pub fn len(&self) -> usize {
+        self.branches.len() + 1
+    }
+
+    /// Create a new SwitchTargets from the given branches and `otherwise` target.
+    pub fn new(branches: Vec<(u128, BasicBlockIdx)>, otherwise: BasicBlockIdx) -> SwitchTargets {
+        SwitchTargets { branches, otherwise }
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum BorrowKind {
+    /// Data must be immutable and is aliasable.
+    Shared,
+
+    /// An immutable, aliasable borrow that is discarded after borrow-checking. Can behave either
+    /// like a normal shared borrow or like a special shallow borrow (see [`FakeBorrowKind`]).
+    Fake(FakeBorrowKind),
+
+    /// Data is mutable and not aliasable.
+    Mut {
+        /// `true` if this borrow arose from method-call auto-ref
+        kind: MutBorrowKind,
+    },
+}
+
+impl BorrowKind {
+    pub fn to_mutable_lossy(self) -> Mutability {
+        match self {
+            BorrowKind::Mut { .. } => Mutability::Mut,
+            BorrowKind::Shared => Mutability::Not,
+            // FIXME: There's no type corresponding to a shallow borrow, so use `&` as an approximation.
+            BorrowKind::Fake(_) => Mutability::Not,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum RawPtrKind {
+    Mut,
+    Const,
+    FakeForPtrMetadata,
+}
+
+impl RawPtrKind {
+    pub fn to_mutable_lossy(self) -> Mutability {
+        match self {
+            RawPtrKind::Mut { .. } => Mutability::Mut,
+            RawPtrKind::Const => Mutability::Not,
+            // FIXME: There's no type corresponding to a shallow borrow, so use `&` as an approximation.
+            RawPtrKind::FakeForPtrMetadata => Mutability::Not,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum MutBorrowKind {
+    Default,
+    TwoPhaseBorrow,
+    ClosureCapture,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum FakeBorrowKind {
+    /// A shared (deep) borrow. Data must be immutable and is aliasable.
+    Deep,
+    /// The immediately borrowed place must be immutable, but projections from
+    /// it don't need to be. This is used to prevent match guards from replacing
+    /// the scrutinee. For example, a fake borrow of `a.b` doesn't
+    /// conflict with a mutable borrow of `a.b.c`.
+    Shallow,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub enum Mutability {
+    Not,
+    Mut,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum Safety {
+    Safe,
+    Unsafe,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum PointerCoercion {
+    /// Go from a fn-item type to a fn-pointer type.
+    ReifyFnPointer,
+
+    /// Go from a safe fn pointer to an unsafe fn pointer.
+    UnsafeFnPointer,
+
+    /// Go from a non-capturing closure to a fn pointer or an unsafe fn pointer.
+    /// It cannot convert a closure that requires unsafe.
+    ClosureFnPointer(Safety),
+
+    /// Go from a mut raw pointer to a const raw pointer.
+    MutToConstPointer,
+
+    /// Go from `*const [T; N]` to `*const T`
+    ArrayToPointer,
+
+    /// Unsize a pointer/reference value, e.g., `&[T; n]` to
+    /// `&[T]`. Note that the source could be a thin or wide pointer.
+    /// This will do things like convert thin pointers to wide
+    /// pointers, or convert structs containing thin pointers to
+    /// structs containing wide pointers, or convert between wide
+    /// pointers.
+    Unsize,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum CastKind {
+    // FIXME(smir-rename): rename this to PointerExposeProvenance
+    PointerExposeAddress,
+    PointerWithExposedProvenance,
+    PointerCoercion(PointerCoercion),
+    IntToInt,
+    FloatToInt,
+    FloatToFloat,
+    IntToFloat,
+    PtrToPtr,
+    FnPtrToPtr,
+    Transmute,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum NullOp {
+    /// Returns the size of a value of that type.
+    SizeOf,
+    /// Returns the minimum alignment of a type.
+    AlignOf,
+    /// Returns the offset of a field.
+    OffsetOf(Vec<(VariantIdx, FieldIdx)>),
+    /// cfg!(ub_checks), but at codegen time
+    UbChecks,
+    /// cfg!(contract_checks), but at codegen time
+    ContractChecks,
+}
+
+impl Operand {
+    /// Get the type of an operand relative to the local declaration.
+    ///
+    /// In order to retrieve the correct type, the `locals` argument must match the list of all
+    /// locals from the function body where this operand originates from.
+    ///
+    /// Errors indicate a malformed operand or incompatible locals list.
+    pub fn ty(&self, locals: &[LocalDecl]) -> Result<Ty, Error> {
+        match self {
+            Operand::Copy(place) | Operand::Move(place) => place.ty(locals),
+            Operand::Constant(c) => Ok(c.ty()),
+        }
+    }
+}
+
+impl ConstOperand {
+    pub fn ty(&self) -> Ty {
+        self.const_.ty()
+    }
+}
+
+impl Place {
+    /// Resolve down the chain of projections to get the type referenced at the end of it.
+    /// E.g.:
+    /// Calling `ty()` on `var.field` should return the type of `field`.
+    ///
+    /// In order to retrieve the correct type, the `locals` argument must match the list of all
+    /// locals from the function body where this place originates from.
+    pub fn ty(&self, locals: &[LocalDecl]) -> Result<Ty, Error> {
+        self.projection.iter().try_fold(locals[self.local].ty, |place_ty, elem| elem.ty(place_ty))
+    }
+}
+
+impl ProjectionElem {
+    /// Get the expected type after applying this projection to a given place type.
+    pub fn ty(&self, place_ty: Ty) -> Result<Ty, Error> {
+        let ty = place_ty;
+        match &self {
+            ProjectionElem::Deref => Self::deref_ty(ty),
+            ProjectionElem::Field(_idx, fty) => Ok(*fty),
+            ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } => Self::index_ty(ty),
+            ProjectionElem::Subslice { from, to, from_end } => {
+                Self::subslice_ty(ty, *from, *to, *from_end)
+            }
+            ProjectionElem::Downcast(_) => Ok(ty),
+            ProjectionElem::OpaqueCast(ty) | ProjectionElem::Subtype(ty) => Ok(*ty),
+        }
+    }
+
+    fn index_ty(ty: Ty) -> Result<Ty, Error> {
+        ty.kind().builtin_index().ok_or_else(|| error!("Cannot index non-array type: {ty:?}"))
+    }
+
+    fn subslice_ty(ty: Ty, from: u64, to: u64, from_end: bool) -> Result<Ty, Error> {
+        let ty_kind = ty.kind();
+        match ty_kind {
+            TyKind::RigidTy(RigidTy::Slice(..)) => Ok(ty),
+            TyKind::RigidTy(RigidTy::Array(inner, _)) if !from_end => Ty::try_new_array(
+                inner,
+                to.checked_sub(from).ok_or_else(|| error!("Subslice overflow: {from}..{to}"))?,
+            ),
+            TyKind::RigidTy(RigidTy::Array(inner, size)) => {
+                let size = size.eval_target_usize()?;
+                let len = size - from - to;
+                Ty::try_new_array(inner, len)
+            }
+            _ => Err(Error(format!("Cannot subslice non-array type: `{ty_kind:?}`"))),
+        }
+    }
+
+    fn deref_ty(ty: Ty) -> Result<Ty, Error> {
+        let deref_ty = ty
+            .kind()
+            .builtin_deref(true)
+            .ok_or_else(|| error!("Cannot dereference type: {ty:?}"))?;
+        Ok(deref_ty.ty)
+    }
+}
diff --git a/compiler/rustc_public/src/mir/mono.rs b/compiler/rustc_public/src/mir/mono.rs
new file mode 100644
index 00000000000..c85f0fa36f7
--- /dev/null
+++ b/compiler/rustc_public/src/mir/mono.rs
@@ -0,0 +1,305 @@
+use std::fmt::{Debug, Formatter};
+use std::io;
+
+use rustc_public_bridge::bridge::SmirError;
+use serde::Serialize;
+
+use crate::abi::FnAbi;
+use crate::crate_def::CrateDef;
+use crate::mir::Body;
+use crate::ty::{Allocation, ClosureDef, ClosureKind, FnDef, GenericArgs, Ty};
+use crate::{CrateItem, DefId, Error, IndexedVal, ItemKind, Opaque, Symbol, with};
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub enum MonoItem {
+    Fn(Instance),
+    Static(StaticDef),
+    GlobalAsm(Opaque),
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Serialize)]
+pub struct Instance {
+    /// The type of instance.
+    pub kind: InstanceKind,
+    /// An ID used to get the instance definition from the compiler.
+    /// Do not use this field directly.
+    pub def: InstanceDef,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub enum InstanceKind {
+    /// A user defined item.
+    Item,
+    /// A compiler intrinsic function.
+    Intrinsic,
+    /// A virtual function definition stored in a VTable.
+    /// The `idx` field indicates the position in the VTable for this instance.
+    Virtual { idx: usize },
+    /// A compiler generated shim.
+    Shim,
+}
+
+impl Instance {
+    /// Get the arguments this instance was instantiated with.
+    pub fn args(&self) -> GenericArgs {
+        with(|cx| cx.instance_args(self.def))
+    }
+
+    /// Get the body of an Instance.
+    ///
+    /// The body will be eagerly monomorphized and all constants will already be evaluated.
+    ///
+    /// This method will return the intrinsic fallback body if one was defined.
+    pub fn body(&self) -> Option<Body> {
+        with(|context| context.instance_body(self.def))
+    }
+
+    /// Check whether this instance has a body available.
+    ///
+    /// For intrinsics with fallback body, this will return `true`. It is up to the user to decide
+    /// whether to specialize the intrinsic or to use its fallback body.
+    ///
+    /// For more information on fallback body, see <https://github.com/rust-lang/rust/issues/93145>.
+    ///
+    /// This call is much cheaper than `instance.body().is_some()`, since it doesn't try to build
+    /// the StableMIR body.
+    pub fn has_body(&self) -> bool {
+        with(|cx| cx.has_body(self.def.def_id()))
+    }
+
+    pub fn is_foreign_item(&self) -> bool {
+        with(|cx| cx.is_foreign_item(self.def.def_id()))
+    }
+
+    /// Get the instance type with generic instantiations applied and lifetimes erased.
+    pub fn ty(&self) -> Ty {
+        with(|context| context.instance_ty(self.def))
+    }
+
+    /// Retrieve information about this instance binary interface.
+    pub fn fn_abi(&self) -> Result<FnAbi, Error> {
+        with(|cx| cx.instance_abi(self.def))
+    }
+
+    /// Retrieve the instance's mangled name used for calling the given instance.
+    ///
+    /// This will also look up the correct name of instances from upstream crates.
+    pub fn mangled_name(&self) -> Symbol {
+        with(|context| context.instance_mangled_name(self.def))
+    }
+
+    /// Retrieve the instance name for diagnostic messages.
+    ///
+    /// This will return the specialized name, e.g., `std::vec::Vec<u8>::new`.
+    pub fn name(&self) -> Symbol {
+        with(|context| context.instance_name(self.def, false))
+    }
+
+    /// Return a trimmed name of the given instance including its args.
+    ///
+    /// If a symbol name can only be imported from one place for a type, and as
+    /// long as it was not glob-imported anywhere in the current crate, we trim its
+    /// path and print only the name.
+    pub fn trimmed_name(&self) -> Symbol {
+        with(|context| context.instance_name(self.def, true))
+    }
+
+    /// Retrieve the plain intrinsic name of an instance if it's an intrinsic.
+    ///
+    /// The plain name does not include type arguments (as `trimmed_name` does),
+    /// which is more convenient to match with intrinsic symbols.
+    pub fn intrinsic_name(&self) -> Option<Symbol> {
+        match self.kind {
+            InstanceKind::Intrinsic => {
+                Some(with(|context| context.intrinsic(self.def.def_id()).unwrap().fn_name()))
+            }
+            InstanceKind::Item | InstanceKind::Virtual { .. } | InstanceKind::Shim => None,
+        }
+    }
+
+    /// Resolve an instance starting from a function definition and generic arguments.
+    pub fn resolve(def: FnDef, args: &GenericArgs) -> Result<Instance, Error> {
+        with(|context| {
+            context
+                .resolve_instance(def, args)
+                .ok_or_else(|| Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`")))
+        })
+    }
+
+    /// Resolve the drop in place for a given type.
+    pub fn resolve_drop_in_place(ty: Ty) -> Instance {
+        with(|cx| cx.resolve_drop_in_place(ty))
+    }
+
+    /// Resolve an instance for a given function pointer.
+    pub fn resolve_for_fn_ptr(def: FnDef, args: &GenericArgs) -> Result<Instance, Error> {
+        with(|context| {
+            context
+                .resolve_for_fn_ptr(def, args)
+                .ok_or_else(|| Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`")))
+        })
+    }
+
+    /// Resolve a closure with the expected kind.
+    pub fn resolve_closure(
+        def: ClosureDef,
+        args: &GenericArgs,
+        kind: ClosureKind,
+    ) -> Result<Instance, Error> {
+        with(|context| {
+            context
+                .resolve_closure(def, args, kind)
+                .ok_or_else(|| Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`")))
+        })
+    }
+
+    /// Check whether this instance is an empty shim.
+    ///
+    /// Allow users to check if this shim can be ignored when called directly.
+    ///
+    /// We have decided not to export different types of Shims to StableMIR users, however, this
+    /// is a query that can be very helpful for users when processing DropGlue.
+    ///
+    /// When generating code for a Drop terminator, users can ignore an empty drop glue.
+    /// These shims are only needed to generate a valid Drop call done via VTable.
+    pub fn is_empty_shim(&self) -> bool {
+        self.kind == InstanceKind::Shim && with(|cx| cx.is_empty_drop_shim(self.def))
+    }
+
+    /// Try to constant evaluate the instance into a constant with the given type.
+    ///
+    /// This can be used to retrieve a constant that represents an intrinsic return such as
+    /// `type_id`.
+    pub fn try_const_eval(&self, const_ty: Ty) -> Result<Allocation, Error> {
+        with(|cx| cx.eval_instance(self.def, const_ty))
+    }
+
+    /// Emit the body of this instance if it has one.
+    pub fn emit_mir<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
+        if let Some(body) = self.body() { body.dump(w, &self.name()) } else { Ok(()) }
+    }
+}
+
+impl Debug for Instance {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Instance")
+            .field("kind", &self.kind)
+            .field("def", &self.mangled_name())
+            .field("args", &self.args())
+            .finish()
+    }
+}
+
+/// Try to convert a crate item into an instance.
+/// The item cannot be generic in order to be converted into an instance.
+impl TryFrom<CrateItem> for Instance {
+    type Error = crate::Error;
+
+    fn try_from(item: CrateItem) -> Result<Self, Self::Error> {
+        with(|context| {
+            let def_id = item.def_id();
+            if !context.requires_monomorphization(def_id) {
+                Ok(context.mono_instance(def_id))
+            } else {
+                Err(Error::new("Item requires monomorphization".to_string()))
+            }
+        })
+    }
+}
+
+/// Try to convert an instance into a crate item.
+/// Only user defined instances can be converted.
+impl TryFrom<Instance> for CrateItem {
+    type Error = crate::Error;
+
+    fn try_from(value: Instance) -> Result<Self, Self::Error> {
+        with(|context| {
+            if value.kind == InstanceKind::Item && context.has_body(value.def.def_id()) {
+                Ok(CrateItem(context.instance_def_id(value.def)))
+            } else {
+                Err(Error::new(format!("Item kind `{:?}` cannot be converted", value.kind)))
+            }
+        })
+    }
+}
+
+impl From<Instance> for MonoItem {
+    fn from(value: Instance) -> Self {
+        MonoItem::Fn(value)
+    }
+}
+
+impl From<StaticDef> for MonoItem {
+    fn from(value: StaticDef) -> Self {
+        MonoItem::Static(value)
+    }
+}
+
+impl From<StaticDef> for CrateItem {
+    fn from(value: StaticDef) -> Self {
+        CrateItem(value.0)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
+pub struct InstanceDef(usize);
+
+impl CrateDef for InstanceDef {
+    fn def_id(&self) -> DefId {
+        with(|context| context.instance_def_id(*self))
+    }
+}
+
+crate_def! {
+    /// Holds information about a static variable definition.
+    #[derive(Serialize)]
+    pub StaticDef;
+}
+
+impl TryFrom<CrateItem> for StaticDef {
+    type Error = crate::Error;
+
+    fn try_from(value: CrateItem) -> Result<Self, Self::Error> {
+        if matches!(value.kind(), ItemKind::Static) {
+            Ok(StaticDef(value.0))
+        } else {
+            Err(Error::new(format!("Expected a static item, but found: {value:?}")))
+        }
+    }
+}
+
+impl TryFrom<Instance> for StaticDef {
+    type Error = crate::Error;
+
+    fn try_from(value: Instance) -> Result<Self, Self::Error> {
+        StaticDef::try_from(CrateItem::try_from(value)?)
+    }
+}
+
+impl From<StaticDef> for Instance {
+    fn from(value: StaticDef) -> Self {
+        // A static definition should always be convertible to an instance.
+        with(|cx| cx.mono_instance(value.def_id()))
+    }
+}
+
+impl StaticDef {
+    /// Return the type of this static definition.
+    pub fn ty(&self) -> Ty {
+        with(|cx| cx.def_ty(self.0))
+    }
+
+    /// Evaluate a static's initializer, returning the allocation of the initializer's memory.
+    pub fn eval_initializer(&self) -> Result<Allocation, Error> {
+        with(|cx| cx.eval_static_initializer(*self))
+    }
+}
+
+impl IndexedVal for InstanceDef {
+    fn to_val(index: usize) -> Self {
+        InstanceDef(index)
+    }
+    fn to_index(&self) -> usize {
+        self.0
+    }
+}
diff --git a/compiler/rustc_public/src/mir/pretty.rs b/compiler/rustc_public/src/mir/pretty.rs
new file mode 100644
index 00000000000..f496d80053e
--- /dev/null
+++ b/compiler/rustc_public/src/mir/pretty.rs
@@ -0,0 +1,469 @@
+//! Implement methods to pretty print stable MIR body.
+use std::fmt::Debug;
+use std::io::Write;
+use std::{fmt, io, iter};
+
+use fmt::{Display, Formatter};
+
+use super::{AggregateKind, AssertMessage, BinOp, BorrowKind, FakeBorrowKind, TerminatorKind};
+use crate::mir::{
+    Operand, Place, RawPtrKind, Rvalue, StatementKind, UnwindAction, VarDebugInfoContents,
+};
+use crate::ty::{AdtKind, AssocKind, MirConst, Ty, TyConst};
+use crate::{Body, CrateDef, IndexedVal, Mutability, with};
+
+impl Display for Ty {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        with(|ctx| write!(f, "{}", ctx.ty_pretty(*self)))
+    }
+}
+
+impl Display for AssocKind {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            AssocKind::Fn { has_self: true, .. } => write!(f, "method"),
+            AssocKind::Fn { has_self: false, .. } => write!(f, "associated function"),
+            AssocKind::Const { .. } => write!(f, "associated const"),
+            AssocKind::Type { .. } => write!(f, "associated type"),
+        }
+    }
+}
+
+impl Debug for Place {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        with(|ctx| write!(f, "{}", ctx.place_pretty(self)))
+    }
+}
+
+pub(crate) fn function_body<W: Write>(writer: &mut W, body: &Body, name: &str) -> io::Result<()> {
+    write!(writer, "fn {name}(")?;
+    let mut sep = "";
+    for (index, local) in body.arg_locals().iter().enumerate() {
+        write!(writer, "{}_{}: {}", sep, index + 1, local.ty)?;
+        sep = ", ";
+    }
+    write!(writer, ")")?;
+
+    let return_local = body.ret_local();
+    writeln!(writer, " -> {} {{", return_local.ty)?;
+
+    body.locals().iter().enumerate().try_for_each(|(index, local)| -> io::Result<()> {
+        if index == 0 || index > body.arg_count {
+            writeln!(writer, "    let {}_{}: {};", pretty_mut(local.mutability), index, local.ty)
+        } else {
+            Ok(())
+        }
+    })?;
+
+    body.var_debug_info.iter().try_for_each(|info| {
+        let content = match &info.value {
+            VarDebugInfoContents::Place(place) => {
+                format!("{place:?}")
+            }
+            VarDebugInfoContents::Const(constant) => pretty_mir_const(&constant.const_),
+        };
+        writeln!(writer, "    debug {} => {};", info.name, content)
+    })?;
+
+    body.blocks
+        .iter()
+        .enumerate()
+        .map(|(index, block)| -> io::Result<()> {
+            writeln!(writer, "    bb{index}: {{")?;
+            let _ = block
+                .statements
+                .iter()
+                .map(|statement| -> io::Result<()> {
+                    pretty_statement(writer, &statement.kind)?;
+                    Ok(())
+                })
+                .collect::<Vec<_>>();
+            pretty_terminator(writer, &block.terminator.kind)?;
+            writeln!(writer, "    }}").unwrap();
+            Ok(())
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    writeln!(writer, "}}")?;
+    Ok(())
+}
+
+fn pretty_statement<W: Write>(writer: &mut W, statement: &StatementKind) -> io::Result<()> {
+    const INDENT: &str = "        ";
+    match statement {
+        StatementKind::Assign(place, rval) => {
+            write!(writer, "{INDENT}{place:?} = ")?;
+            pretty_rvalue(writer, rval)?;
+            writeln!(writer, ";")
+        }
+        // FIXME: Add rest of the statements
+        StatementKind::FakeRead(cause, place) => {
+            writeln!(writer, "{INDENT}FakeRead({cause:?}, {place:?});")
+        }
+        StatementKind::SetDiscriminant { place, variant_index } => {
+            writeln!(writer, "{INDENT}discriminant({place:?} = {};", variant_index.to_index())
+        }
+        StatementKind::Deinit(place) => writeln!(writer, "Deinit({place:?};"),
+        StatementKind::StorageLive(local) => {
+            writeln!(writer, "{INDENT}StorageLive(_{local});")
+        }
+        StatementKind::StorageDead(local) => {
+            writeln!(writer, "{INDENT}StorageDead(_{local});")
+        }
+        StatementKind::Retag(kind, place) => writeln!(writer, "Retag({kind:?}, {place:?});"),
+        StatementKind::PlaceMention(place) => {
+            writeln!(writer, "{INDENT}PlaceMention({place:?};")
+        }
+        StatementKind::ConstEvalCounter => {
+            writeln!(writer, "{INDENT}ConstEvalCounter;")
+        }
+        StatementKind::Nop => writeln!(writer, "{INDENT}nop;"),
+        StatementKind::AscribeUserType { .. }
+        | StatementKind::Coverage(_)
+        | StatementKind::Intrinsic(_) => {
+            // FIX-ME: Make them pretty.
+            writeln!(writer, "{INDENT}{statement:?};")
+        }
+    }
+}
+
+fn pretty_terminator<W: Write>(writer: &mut W, terminator: &TerminatorKind) -> io::Result<()> {
+    pretty_terminator_head(writer, terminator)?;
+    let successors = terminator.successors();
+    let successor_count = successors.len();
+    let labels = pretty_successor_labels(terminator);
+
+    let show_unwind = !matches!(terminator.unwind(), None | Some(UnwindAction::Cleanup(_)));
+    let fmt_unwind = |w: &mut W| -> io::Result<()> {
+        write!(w, "unwind ")?;
+        match terminator.unwind() {
+            None | Some(UnwindAction::Cleanup(_)) => unreachable!(),
+            Some(UnwindAction::Continue) => write!(w, "continue"),
+            Some(UnwindAction::Unreachable) => write!(w, "unreachable"),
+            Some(UnwindAction::Terminate) => write!(w, "terminate"),
+        }
+    };
+
+    match (successor_count, show_unwind) {
+        (0, false) => {}
+        (0, true) => {
+            write!(writer, " -> ")?;
+            fmt_unwind(writer)?;
+        }
+        (1, false) => write!(writer, " -> bb{:?}", successors[0])?,
+        _ => {
+            write!(writer, " -> [")?;
+            for (i, target) in successors.iter().enumerate() {
+                if i > 0 {
+                    write!(writer, ", ")?;
+                }
+                write!(writer, "{}: bb{:?}", labels[i], target)?;
+            }
+            if show_unwind {
+                write!(writer, ", ")?;
+                fmt_unwind(writer)?;
+            }
+            write!(writer, "]")?;
+        }
+    };
+
+    writeln!(writer, ";")
+}
+
+fn pretty_terminator_head<W: Write>(writer: &mut W, terminator: &TerminatorKind) -> io::Result<()> {
+    use self::TerminatorKind::*;
+    const INDENT: &str = "        ";
+    match terminator {
+        Goto { .. } => write!(writer, "{INDENT}goto"),
+        SwitchInt { discr, .. } => {
+            write!(writer, "{INDENT}switchInt({})", pretty_operand(discr))
+        }
+        Resume => write!(writer, "{INDENT}resume"),
+        Abort => write!(writer, "{INDENT}abort"),
+        Return => write!(writer, "{INDENT}return"),
+        Unreachable => write!(writer, "{INDENT}unreachable"),
+        Drop { place, .. } => write!(writer, "{INDENT}drop({place:?})"),
+        Call { func, args, destination, .. } => {
+            write!(writer, "{INDENT}{:?} = {}(", destination, pretty_operand(func))?;
+            let mut args_iter = args.iter();
+            args_iter.next().map_or(Ok(()), |arg| write!(writer, "{}", pretty_operand(arg)))?;
+            args_iter.try_for_each(|arg| write!(writer, ", {}", pretty_operand(arg)))?;
+            write!(writer, ")")
+        }
+        Assert { cond, expected, msg, target: _, unwind: _ } => {
+            write!(writer, "{INDENT}assert(")?;
+            if !expected {
+                write!(writer, "!")?;
+            }
+            write!(writer, "{}, ", pretty_operand(cond))?;
+            pretty_assert_message(writer, msg)?;
+            write!(writer, ")")
+        }
+        InlineAsm { .. } => write!(writer, "{INDENT}InlineAsm"),
+    }
+}
+
+fn pretty_successor_labels(terminator: &TerminatorKind) -> Vec<String> {
+    use self::TerminatorKind::*;
+    match terminator {
+        Call { target: None, unwind: UnwindAction::Cleanup(_), .. }
+        | InlineAsm { destination: None, .. } => vec!["unwind".into()],
+        Resume | Abort | Return | Unreachable | Call { target: None, unwind: _, .. } => vec![],
+        Goto { .. } => vec!["".to_string()],
+        SwitchInt { targets, .. } => targets
+            .branches()
+            .map(|(val, _target)| format!("{val}"))
+            .chain(iter::once("otherwise".into()))
+            .collect(),
+        Drop { unwind: UnwindAction::Cleanup(_), .. } => vec!["return".into(), "unwind".into()],
+        Call { target: Some(_), unwind: UnwindAction::Cleanup(_), .. } => {
+            vec!["return".into(), "unwind".into()]
+        }
+        Drop { unwind: _, .. } | Call { target: Some(_), unwind: _, .. } => vec!["return".into()],
+        Assert { unwind: UnwindAction::Cleanup(_), .. } => {
+            vec!["success".into(), "unwind".into()]
+        }
+        Assert { unwind: _, .. } => vec!["success".into()],
+        InlineAsm { destination: Some(_), .. } => vec!["goto".into(), "unwind".into()],
+    }
+}
+
+fn pretty_assert_message<W: Write>(writer: &mut W, msg: &AssertMessage) -> io::Result<()> {
+    match msg {
+        AssertMessage::BoundsCheck { len, index } => {
+            let pretty_len = pretty_operand(len);
+            let pretty_index = pretty_operand(index);
+            write!(
+                writer,
+                "\"index out of bounds: the length is {{}} but the index is {{}}\", {pretty_len}, {pretty_index}"
+            )
+        }
+        AssertMessage::Overflow(BinOp::Add, l, r) => {
+            let pretty_l = pretty_operand(l);
+            let pretty_r = pretty_operand(r);
+            write!(
+                writer,
+                "\"attempt to compute `{{}} + {{}}`, which would overflow\", {pretty_l}, {pretty_r}"
+            )
+        }
+        AssertMessage::Overflow(BinOp::Sub, l, r) => {
+            let pretty_l = pretty_operand(l);
+            let pretty_r = pretty_operand(r);
+            write!(
+                writer,
+                "\"attempt to compute `{{}} - {{}}`, which would overflow\", {pretty_l}, {pretty_r}"
+            )
+        }
+        AssertMessage::Overflow(BinOp::Mul, l, r) => {
+            let pretty_l = pretty_operand(l);
+            let pretty_r = pretty_operand(r);
+            write!(
+                writer,
+                "\"attempt to compute `{{}} * {{}}`, which would overflow\", {pretty_l}, {pretty_r}"
+            )
+        }
+        AssertMessage::Overflow(BinOp::Div, l, r) => {
+            let pretty_l = pretty_operand(l);
+            let pretty_r = pretty_operand(r);
+            write!(
+                writer,
+                "\"attempt to compute `{{}} / {{}}`, which would overflow\", {pretty_l}, {pretty_r}"
+            )
+        }
+        AssertMessage::Overflow(BinOp::Rem, l, r) => {
+            let pretty_l = pretty_operand(l);
+            let pretty_r = pretty_operand(r);
+            write!(
+                writer,
+                "\"attempt to compute `{{}} % {{}}`, which would overflow\", {pretty_l}, {pretty_r}"
+            )
+        }
+        AssertMessage::Overflow(BinOp::Shr, _, r) => {
+            let pretty_r = pretty_operand(r);
+            write!(writer, "\"attempt to shift right by `{{}}`, which would overflow\", {pretty_r}")
+        }
+        AssertMessage::Overflow(BinOp::Shl, _, r) => {
+            let pretty_r = pretty_operand(r);
+            write!(writer, "\"attempt to shift left by `{{}}`, which would overflow\", {pretty_r}")
+        }
+        AssertMessage::Overflow(op, _, _) => unreachable!("`{:?}` cannot overflow", op),
+        AssertMessage::OverflowNeg(op) => {
+            let pretty_op = pretty_operand(op);
+            write!(writer, "\"attempt to negate `{{}}`, which would overflow\", {pretty_op}")
+        }
+        AssertMessage::DivisionByZero(op) => {
+            let pretty_op = pretty_operand(op);
+            write!(writer, "\"attempt to divide `{{}}` by zero\", {pretty_op}")
+        }
+        AssertMessage::RemainderByZero(op) => {
+            let pretty_op = pretty_operand(op);
+            write!(
+                writer,
+                "\"attempt to calculate the remainder of `{{}}` with a divisor of zero\", {pretty_op}"
+            )
+        }
+        AssertMessage::MisalignedPointerDereference { required, found } => {
+            let pretty_required = pretty_operand(required);
+            let pretty_found = pretty_operand(found);
+            write!(
+                writer,
+                "\"misaligned pointer dereference: address must be a multiple of {{}} but is {{}}\",{pretty_required}, {pretty_found}"
+            )
+        }
+        AssertMessage::NullPointerDereference => {
+            write!(writer, "\"null pointer dereference occurred\"")
+        }
+        AssertMessage::InvalidEnumConstruction(op) => {
+            let pretty_op = pretty_operand(op);
+            write!(writer, "\"trying to construct an enum from an invalid value {{}}\",{pretty_op}")
+        }
+        AssertMessage::ResumedAfterReturn(_)
+        | AssertMessage::ResumedAfterPanic(_)
+        | AssertMessage::ResumedAfterDrop(_) => {
+            write!(writer, "{}", msg.description().unwrap())
+        }
+    }
+}
+
+fn pretty_operand(operand: &Operand) -> String {
+    match operand {
+        Operand::Copy(copy) => {
+            format!("{copy:?}")
+        }
+        Operand::Move(mv) => {
+            format!("move {mv:?}")
+        }
+        Operand::Constant(cnst) => pretty_mir_const(&cnst.const_),
+    }
+}
+
+fn pretty_mir_const(literal: &MirConst) -> String {
+    with(|cx| cx.mir_const_pretty(literal))
+}
+
+fn pretty_ty_const(ct: &TyConst) -> String {
+    with(|cx| cx.ty_const_pretty(ct.id))
+}
+
+fn pretty_rvalue<W: Write>(writer: &mut W, rval: &Rvalue) -> io::Result<()> {
+    match rval {
+        Rvalue::AddressOf(mutability, place) => {
+            write!(writer, "&raw {} {:?}", pretty_raw_ptr_kind(*mutability), place)
+        }
+        Rvalue::Aggregate(aggregate_kind, operands) => {
+            // FIXME: Add pretty_aggregate function that returns a pretty string
+            pretty_aggregate(writer, aggregate_kind, operands)
+        }
+        Rvalue::BinaryOp(bin, op1, op2) => {
+            write!(writer, "{:?}({}, {})", bin, pretty_operand(op1), pretty_operand(op2))
+        }
+        Rvalue::Cast(_, op, ty) => {
+            write!(writer, "{} as {}", pretty_operand(op), ty)
+        }
+        Rvalue::CheckedBinaryOp(bin, op1, op2) => {
+            write!(writer, "Checked{:?}({}, {})", bin, pretty_operand(op1), pretty_operand(op2))
+        }
+        Rvalue::CopyForDeref(deref) => {
+            write!(writer, "CopyForDeref({deref:?})")
+        }
+        Rvalue::Discriminant(place) => {
+            write!(writer, "discriminant({place:?})")
+        }
+        Rvalue::Len(len) => {
+            write!(writer, "len({len:?})")
+        }
+        Rvalue::Ref(_, borrowkind, place) => {
+            let kind = match borrowkind {
+                BorrowKind::Shared => "&",
+                BorrowKind::Fake(FakeBorrowKind::Deep) => "&fake ",
+                BorrowKind::Fake(FakeBorrowKind::Shallow) => "&fake shallow ",
+                BorrowKind::Mut { .. } => "&mut ",
+            };
+            write!(writer, "{kind}{place:?}")
+        }
+        Rvalue::Repeat(op, cnst) => {
+            write!(writer, "[{}; {}]", pretty_operand(op), pretty_ty_const(cnst))
+        }
+        Rvalue::ShallowInitBox(_, _) => Ok(()),
+        Rvalue::ThreadLocalRef(item) => {
+            write!(writer, "thread_local_ref{item:?}")
+        }
+        Rvalue::NullaryOp(nul, ty) => {
+            write!(writer, "{nul:?}::<{ty}>() \" \"")
+        }
+        Rvalue::UnaryOp(un, op) => {
+            write!(writer, "{:?}({})", un, pretty_operand(op))
+        }
+        Rvalue::Use(op) => write!(writer, "{}", pretty_operand(op)),
+    }
+}
+
+fn pretty_aggregate<W: Write>(
+    writer: &mut W,
+    aggregate_kind: &AggregateKind,
+    operands: &Vec<Operand>,
+) -> io::Result<()> {
+    let suffix = match aggregate_kind {
+        AggregateKind::Array(_) => {
+            write!(writer, "[")?;
+            "]"
+        }
+        AggregateKind::Tuple => {
+            write!(writer, "(")?;
+            ")"
+        }
+        AggregateKind::Adt(def, var, _, _, _) => {
+            if def.kind() == AdtKind::Enum {
+                write!(writer, "{}::{}", def.name(), def.variant(*var).unwrap().name())?;
+            } else {
+                write!(writer, "{}", def.variant(*var).unwrap().name())?;
+            }
+            if operands.is_empty() {
+                return Ok(());
+            }
+            // FIXME: Change this once we have CtorKind in StableMIR.
+            write!(writer, "(")?;
+            ")"
+        }
+        AggregateKind::Closure(def, _) => {
+            write!(writer, "{{closure@{}}}(", def.span().diagnostic())?;
+            ")"
+        }
+        AggregateKind::Coroutine(def, _, _) => {
+            write!(writer, "{{coroutine@{}}}(", def.span().diagnostic())?;
+            ")"
+        }
+        AggregateKind::CoroutineClosure(def, _) => {
+            write!(writer, "{{coroutine-closure@{}}}(", def.span().diagnostic())?;
+            ")"
+        }
+        AggregateKind::RawPtr(ty, mutability) => {
+            write!(
+                writer,
+                "*{} {ty} from (",
+                if *mutability == Mutability::Mut { "mut" } else { "const" }
+            )?;
+            ")"
+        }
+    };
+    let mut separator = "";
+    for op in operands {
+        write!(writer, "{}{}", separator, pretty_operand(op))?;
+        separator = ", ";
+    }
+    write!(writer, "{suffix}")
+}
+
+fn pretty_mut(mutability: Mutability) -> &'static str {
+    match mutability {
+        Mutability::Not => " ",
+        Mutability::Mut => "mut ",
+    }
+}
+
+fn pretty_raw_ptr_kind(kind: RawPtrKind) -> &'static str {
+    match kind {
+        RawPtrKind::Const => "const",
+        RawPtrKind::Mut => "mut",
+        RawPtrKind::FakeForPtrMetadata => "const (fake)",
+    }
+}
diff --git a/compiler/rustc_public/src/mir/visit.rs b/compiler/rustc_public/src/mir/visit.rs
new file mode 100644
index 00000000000..7dc99d1d1e1
--- /dev/null
+++ b/compiler/rustc_public/src/mir/visit.rs
@@ -0,0 +1,588 @@
+//! # The Stable MIR Visitor
+//!
+//! ## Overview
+//!
+//! We currently only support an immutable visitor.
+//! The structure of this visitor is similar to the ones internal to `rustc`,
+//! and it follows the following conventions:
+//!
+//! For every mir item, the trait has a `visit_<item>` and a `super_<item>` method.
+//! - `visit_<item>`, by default, calls `super_<item>`
+//! - `super_<item>`, by default, destructures the `<item>` and calls `visit_<sub_item>` for
+//!   all sub-items that compose the original item.
+//!
+//! In order to implement a visitor, override the `visit_*` methods for the types you are
+//! interested in analyzing, and invoke (within that method call)
+//! `self.super_*` to continue to the traverse.
+//! Avoid calling `super` methods in other circumstances.
+//!
+//! For the most part, we do not destructure things external to the
+//! MIR, e.g., types, spans, etc, but simply visit them and stop.
+//! This avoids duplication with other visitors like `TypeFoldable`.
+//!
+//! ## Updating
+//!
+//! The code is written in a very deliberate style intended to minimize
+//! the chance of things being overlooked.
+//!
+//! Use pattern matching to reference fields and ensure that all
+//! matches are exhaustive.
+//!
+//! For this to work, ALL MATCHES MUST BE EXHAUSTIVE IN FIELDS AND VARIANTS.
+//! That means you never write `..` to skip over fields, nor do you write `_`
+//! to skip over variants in a `match`.
+//!
+//! The only place that `_` is acceptable is to match a field (or
+//! variant argument) that does not require visiting.
+
+use crate::mir::*;
+use crate::ty::{GenericArgs, MirConst, Region, Ty, TyConst};
+use crate::{Error, Opaque, Span};
+
+macro_rules! make_mir_visitor {
+    ($visitor_trait_name:ident, $($mutability:ident)?) => {
+        pub trait $visitor_trait_name {
+            fn visit_body(&mut self, body: &$($mutability)? Body) {
+                self.super_body(body)
+            }
+
+            fn visit_basic_block(&mut self, bb: &$($mutability)? BasicBlock) {
+                self.super_basic_block(bb)
+            }
+
+            fn visit_ret_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
+                self.super_ret_decl(local, decl)
+            }
+
+            fn visit_arg_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
+                self.super_arg_decl(local, decl)
+            }
+
+            fn visit_local_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
+                self.super_local_decl(local, decl)
+            }
+
+            fn visit_statement(&mut self, stmt: &$($mutability)? Statement, location: Location) {
+                self.super_statement(stmt, location)
+            }
+
+            fn visit_terminator(&mut self, term: &$($mutability)? Terminator, location: Location) {
+                self.super_terminator(term, location)
+            }
+
+            fn visit_span(&mut self, span: &$($mutability)? Span) {
+                self.super_span(span)
+            }
+
+            fn visit_place(&mut self, place: &$($mutability)? Place, ptx: PlaceContext, location: Location) {
+                self.super_place(place, ptx, location)
+            }
+
+            visit_place_fns!($($mutability)?);
+
+            fn visit_local(&mut self, local: &$($mutability)? Local, ptx: PlaceContext, location: Location) {
+                let _ = (local, ptx, location);
+            }
+
+            fn visit_rvalue(&mut self, rvalue: &$($mutability)? Rvalue, location: Location) {
+                self.super_rvalue(rvalue, location)
+            }
+
+            fn visit_operand(&mut self, operand: &$($mutability)? Operand, location: Location) {
+                self.super_operand(operand, location)
+            }
+
+            fn visit_user_type_projection(&mut self, projection: &$($mutability)? UserTypeProjection) {
+                self.super_user_type_projection(projection)
+            }
+
+            fn visit_ty(&mut self, ty: &$($mutability)? Ty, location: Location) {
+                let _ = location;
+                self.super_ty(ty)
+            }
+
+            fn visit_const_operand(&mut self, constant: &$($mutability)? ConstOperand, location: Location) {
+                self.super_const_operand(constant, location)
+            }
+
+            fn visit_mir_const(&mut self, constant: &$($mutability)? MirConst, location: Location) {
+                self.super_mir_const(constant, location)
+            }
+
+            fn visit_ty_const(&mut self, constant: &$($mutability)? TyConst, location: Location) {
+                let _ = location;
+                self.super_ty_const(constant)
+            }
+
+            fn visit_region(&mut self, region: &$($mutability)? Region, location: Location) {
+                let _ = location;
+                self.super_region(region)
+            }
+
+            fn visit_args(&mut self, args: &$($mutability)? GenericArgs, location: Location) {
+                let _ = location;
+                self.super_args(args)
+            }
+
+            fn visit_assert_msg(&mut self, msg: &$($mutability)? AssertMessage, location: Location) {
+                self.super_assert_msg(msg, location)
+            }
+
+            fn visit_var_debug_info(&mut self, var_debug_info: &$($mutability)? VarDebugInfo) {
+                self.super_var_debug_info(var_debug_info);
+            }
+
+            fn super_body(&mut self, body: &$($mutability)? Body) {
+                super_body!(self, body, $($mutability)?);
+            }
+
+            fn super_basic_block(&mut self, bb: &$($mutability)? BasicBlock) {
+                let BasicBlock { statements, terminator } = bb;
+                for stmt in statements {
+                    self.visit_statement(stmt, Location(stmt.span));
+                }
+                self.visit_terminator(terminator, Location(terminator.span));
+            }
+
+            fn super_local_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
+                let _ = local;
+                let LocalDecl { ty, span, .. } = decl;
+                self.visit_ty(ty, Location(*span));
+            }
+
+            fn super_ret_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
+                self.super_local_decl(local, decl)
+            }
+
+            fn super_arg_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
+                self.super_local_decl(local, decl)
+            }
+
+            fn super_statement(&mut self, stmt: &$($mutability)? Statement, location: Location) {
+                let Statement { kind, span } = stmt;
+                self.visit_span(span);
+                match kind {
+                    StatementKind::Assign(place, rvalue) => {
+                        self.visit_place(place, PlaceContext::MUTATING, location);
+                        self.visit_rvalue(rvalue, location);
+                    }
+                    StatementKind::FakeRead(_, place) | StatementKind::PlaceMention(place) => {
+                        self.visit_place(place, PlaceContext::NON_MUTATING, location);
+                    }
+                    StatementKind::SetDiscriminant { place, .. }
+                    | StatementKind::Deinit(place)
+                    | StatementKind::Retag(_, place) => {
+                        self.visit_place(place, PlaceContext::MUTATING, location);
+                    }
+                    StatementKind::StorageLive(local) | StatementKind::StorageDead(local) => {
+                        self.visit_local(local, PlaceContext::NON_USE, location);
+                    }
+                    StatementKind::AscribeUserType { place, projections, variance: _ } => {
+                        self.visit_place(place, PlaceContext::NON_USE, location);
+                        self.visit_user_type_projection(projections);
+                    }
+                    StatementKind::Coverage(coverage) => visit_opaque(coverage),
+                    StatementKind::Intrinsic(intrisic) => match intrisic {
+                        NonDivergingIntrinsic::Assume(operand) => {
+                            self.visit_operand(operand, location);
+                        }
+                        NonDivergingIntrinsic::CopyNonOverlapping(CopyNonOverlapping {
+                            src,
+                            dst,
+                            count,
+                        }) => {
+                            self.visit_operand(src, location);
+                            self.visit_operand(dst, location);
+                            self.visit_operand(count, location);
+                        }
+                    },
+                    StatementKind::ConstEvalCounter | StatementKind::Nop => {}
+                }
+            }
+
+            fn super_terminator(&mut self, term: &$($mutability)? Terminator, location: Location) {
+                let Terminator { kind, span } = term;
+                self.visit_span(span);
+                match kind {
+                    TerminatorKind::Goto { .. }
+                    | TerminatorKind::Resume
+                    | TerminatorKind::Abort
+                    | TerminatorKind::Unreachable => {}
+                    TerminatorKind::Assert { cond, expected: _, msg, target: _, unwind: _ } => {
+                        self.visit_operand(cond, location);
+                        self.visit_assert_msg(msg, location);
+                    }
+                    TerminatorKind::Drop { place, target: _, unwind: _ } => {
+                        self.visit_place(place, PlaceContext::MUTATING, location);
+                    }
+                    TerminatorKind::Call { func, args, destination, target: _, unwind: _ } => {
+                        self.visit_operand(func, location);
+                        for arg in args {
+                            self.visit_operand(arg, location);
+                        }
+                        self.visit_place(destination, PlaceContext::MUTATING, location);
+                    }
+                    TerminatorKind::InlineAsm { operands, .. } => {
+                        for op in operands {
+                            let InlineAsmOperand { in_value, out_place, raw_rpr: _ } = op;
+                            if let Some(input) = in_value {
+                                self.visit_operand(input, location);
+                            }
+                            if let Some(output) = out_place {
+                                self.visit_place(output, PlaceContext::MUTATING, location);
+                            }
+                        }
+                    }
+                    TerminatorKind::Return => {
+                        let $($mutability)? local = RETURN_LOCAL;
+                        self.visit_local(&$($mutability)? local, PlaceContext::NON_MUTATING, location);
+                    }
+                    TerminatorKind::SwitchInt { discr, targets: _ } => {
+                        self.visit_operand(discr, location);
+                    }
+                }
+            }
+
+            fn super_span(&mut self, span: &$($mutability)? Span) {
+                let _ = span;
+            }
+
+            fn super_rvalue(&mut self, rvalue: &$($mutability)? Rvalue, location: Location) {
+                match rvalue {
+                    Rvalue::AddressOf(mutability, place) => {
+                        let pcx = PlaceContext { is_mut: *mutability == RawPtrKind::Mut };
+                        self.visit_place(place, pcx, location);
+                    }
+                    Rvalue::Aggregate(_, operands) => {
+                        for op in operands {
+                            self.visit_operand(op, location);
+                        }
+                    }
+                    Rvalue::BinaryOp(_, lhs, rhs) | Rvalue::CheckedBinaryOp(_, lhs, rhs) => {
+                        self.visit_operand(lhs, location);
+                        self.visit_operand(rhs, location);
+                    }
+                    Rvalue::Cast(_, op, ty) => {
+                        self.visit_operand(op, location);
+                        self.visit_ty(ty, location);
+                    }
+                    Rvalue::CopyForDeref(place) | Rvalue::Discriminant(place) | Rvalue::Len(place) => {
+                        self.visit_place(place, PlaceContext::NON_MUTATING, location);
+                    }
+                    Rvalue::Ref(region, kind, place) => {
+                        self.visit_region(region, location);
+                        let pcx = PlaceContext { is_mut: matches!(kind, BorrowKind::Mut { .. }) };
+                        self.visit_place(place, pcx, location);
+                    }
+                    Rvalue::Repeat(op, constant) => {
+                        self.visit_operand(op, location);
+                        self.visit_ty_const(constant, location);
+                    }
+                    Rvalue::ShallowInitBox(op, ty) => {
+                        self.visit_ty(ty, location);
+                        self.visit_operand(op, location)
+                    }
+                    Rvalue::ThreadLocalRef(_) => {}
+                    Rvalue::NullaryOp(_, ty) => {
+                        self.visit_ty(ty, location);
+                    }
+                    Rvalue::UnaryOp(_, op) | Rvalue::Use(op) => {
+                        self.visit_operand(op, location);
+                    }
+                }
+            }
+
+            fn super_operand(&mut self, operand: &$($mutability)? Operand, location: Location) {
+                match operand {
+                    Operand::Copy(place) | Operand::Move(place) => {
+                        self.visit_place(place, PlaceContext::NON_MUTATING, location)
+                    }
+                    Operand::Constant(constant) => {
+                        self.visit_const_operand(constant, location);
+                    }
+                }
+            }
+
+            fn super_user_type_projection(&mut self, projection: &$($mutability)? UserTypeProjection) {
+                // This is a no-op on mir::Visitor.
+                let _ = projection;
+            }
+
+            fn super_ty(&mut self, ty: &$($mutability)? Ty) {
+                let _ = ty;
+            }
+
+            fn super_const_operand(&mut self, constant: &$($mutability)? ConstOperand, location: Location) {
+                let ConstOperand { span, user_ty: _, const_ } = constant;
+                self.visit_span(span);
+                self.visit_mir_const(const_, location);
+            }
+
+            fn super_mir_const(&mut self, constant: &$($mutability)? MirConst, location: Location) {
+                let MirConst { kind: _, ty, id: _ } = constant;
+                self.visit_ty(ty, location);
+            }
+
+            fn super_ty_const(&mut self, constant: &$($mutability)? TyConst) {
+                let _ = constant;
+            }
+
+            fn super_region(&mut self, region: &$($mutability)? Region) {
+                let _ = region;
+            }
+
+            fn super_args(&mut self, args: &$($mutability)? GenericArgs) {
+                let _ = args;
+            }
+
+            fn super_var_debug_info(&mut self, var_debug_info: &$($mutability)? VarDebugInfo) {
+                let VarDebugInfo { source_info, composite, value, name: _, argument_index: _ } =
+                    var_debug_info;
+                self.visit_span(&$($mutability)? source_info.span);
+                let location = Location(source_info.span);
+                if let Some(composite) = composite {
+                    self.visit_ty(&$($mutability)? composite.ty, location);
+                }
+                match value {
+                    VarDebugInfoContents::Place(place) => {
+                        self.visit_place(place, PlaceContext::NON_USE, location);
+                    }
+                    VarDebugInfoContents::Const(constant) => {
+                        self.visit_mir_const(&$($mutability)? constant.const_, location);
+                    }
+                }
+            }
+
+            fn super_assert_msg(&mut self, msg: &$($mutability)? AssertMessage, location: Location) {
+                match msg {
+                    AssertMessage::BoundsCheck { len, index } => {
+                        self.visit_operand(len, location);
+                        self.visit_operand(index, location);
+                    }
+                    AssertMessage::Overflow(_, left, right) => {
+                        self.visit_operand(left, location);
+                        self.visit_operand(right, location);
+                    }
+                    AssertMessage::OverflowNeg(op)
+                    | AssertMessage::DivisionByZero(op)
+                    | AssertMessage::RemainderByZero(op)
+                    | AssertMessage::InvalidEnumConstruction(op) => {
+                        self.visit_operand(op, location);
+                    }
+                    AssertMessage::ResumedAfterReturn(_)
+                    | AssertMessage::ResumedAfterPanic(_)
+                    | AssertMessage::NullPointerDereference
+                    | AssertMessage::ResumedAfterDrop(_) => {
+                        //nothing to visit
+                    }
+                    AssertMessage::MisalignedPointerDereference { required, found } => {
+                        self.visit_operand(required, location);
+                        self.visit_operand(found, location);
+                    }
+                }
+            }
+        }
+    };
+}
+
+macro_rules! super_body {
+    ($self:ident, $body:ident, mut) => {
+        for bb in $body.blocks.iter_mut() {
+            $self.visit_basic_block(bb);
+        }
+
+        $self.visit_ret_decl(RETURN_LOCAL, $body.ret_local_mut());
+
+        for (idx, arg) in $body.arg_locals_mut().iter_mut().enumerate() {
+            $self.visit_arg_decl(idx + 1, arg)
+        }
+
+        let local_start = $body.arg_count + 1;
+        for (idx, arg) in $body.inner_locals_mut().iter_mut().enumerate() {
+            $self.visit_local_decl(idx + local_start, arg)
+        }
+
+        for info in $body.var_debug_info.iter_mut() {
+            $self.visit_var_debug_info(info);
+        }
+
+        $self.visit_span(&mut $body.span)
+    };
+
+    ($self:ident, $body:ident, ) => {
+        let Body { blocks, locals: _, arg_count, var_debug_info, spread_arg: _, span } = $body;
+
+        for bb in blocks {
+            $self.visit_basic_block(bb);
+        }
+
+        $self.visit_ret_decl(RETURN_LOCAL, $body.ret_local());
+
+        for (idx, arg) in $body.arg_locals().iter().enumerate() {
+            $self.visit_arg_decl(idx + 1, arg)
+        }
+
+        let local_start = arg_count + 1;
+        for (idx, arg) in $body.inner_locals().iter().enumerate() {
+            $self.visit_local_decl(idx + local_start, arg)
+        }
+
+        for info in var_debug_info.iter() {
+            $self.visit_var_debug_info(info);
+        }
+
+        $self.visit_span(span)
+    };
+}
+
+macro_rules! visit_place_fns {
+    (mut) => {
+        fn super_place(&mut self, place: &mut Place, ptx: PlaceContext, location: Location) {
+            self.visit_local(&mut place.local, ptx, location);
+
+            for elem in place.projection.iter_mut() {
+                self.visit_projection_elem(elem, ptx, location);
+            }
+        }
+
+        // We don't have to replicate the `process_projection()` like we did in
+        // `rustc_middle::mir::visit.rs` here because the `projection` field in `Place`
+        // of Stable-MIR is not an immutable borrow, unlike in `Place` of MIR.
+        fn visit_projection_elem(
+            &mut self,
+            elem: &mut ProjectionElem,
+            ptx: PlaceContext,
+            location: Location,
+        ) {
+            self.super_projection_elem(elem, ptx, location)
+        }
+
+        fn super_projection_elem(
+            &mut self,
+            elem: &mut ProjectionElem,
+            ptx: PlaceContext,
+            location: Location,
+        ) {
+            match elem {
+                ProjectionElem::Deref => {}
+                ProjectionElem::Field(_idx, ty) => self.visit_ty(ty, location),
+                ProjectionElem::Index(local) => self.visit_local(local, ptx, location),
+                ProjectionElem::ConstantIndex { offset: _, min_length: _, from_end: _ } => {}
+                ProjectionElem::Subslice { from: _, to: _, from_end: _ } => {}
+                ProjectionElem::Downcast(_idx) => {}
+                ProjectionElem::OpaqueCast(ty) => self.visit_ty(ty, location),
+                ProjectionElem::Subtype(ty) => self.visit_ty(ty, location),
+            }
+        }
+    };
+
+    () => {
+        fn super_place(&mut self, place: &Place, ptx: PlaceContext, location: Location) {
+            self.visit_local(&place.local, ptx, location);
+
+            for (idx, elem) in place.projection.iter().enumerate() {
+                let place_ref =
+                    PlaceRef { local: place.local, projection: &place.projection[..idx] };
+                self.visit_projection_elem(place_ref, elem, ptx, location);
+            }
+        }
+
+        fn visit_projection_elem<'a>(
+            &mut self,
+            place_ref: PlaceRef<'a>,
+            elem: &ProjectionElem,
+            ptx: PlaceContext,
+            location: Location,
+        ) {
+            let _ = place_ref;
+            self.super_projection_elem(elem, ptx, location);
+        }
+
+        fn super_projection_elem(
+            &mut self,
+            elem: &ProjectionElem,
+            ptx: PlaceContext,
+            location: Location,
+        ) {
+            match elem {
+                ProjectionElem::Deref => {}
+                ProjectionElem::Field(_idx, ty) => self.visit_ty(ty, location),
+                ProjectionElem::Index(local) => self.visit_local(local, ptx, location),
+                ProjectionElem::ConstantIndex { offset: _, min_length: _, from_end: _ } => {}
+                ProjectionElem::Subslice { from: _, to: _, from_end: _ } => {}
+                ProjectionElem::Downcast(_idx) => {}
+                ProjectionElem::OpaqueCast(ty) => self.visit_ty(ty, location),
+                ProjectionElem::Subtype(ty) => self.visit_ty(ty, location),
+            }
+        }
+    };
+}
+
+make_mir_visitor!(MirVisitor,);
+make_mir_visitor!(MutMirVisitor, mut);
+
+/// This function is a no-op that gets used to ensure this visitor is kept up-to-date.
+///
+/// The idea is that whenever we replace an Opaque type by a real type, the compiler will fail
+/// when trying to invoke `visit_opaque`.
+///
+/// If you are here because your compilation is broken, replace the failing call to `visit_opaque()`
+/// by a `visit_<CONSTRUCT>` for your construct.
+fn visit_opaque(_: &Opaque) {}
+
+/// The location of a statement / terminator in the code and the CFG.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct Location(Span);
+
+impl Location {
+    pub fn span(&self) -> Span {
+        self.0
+    }
+}
+
+/// Location of the statement at the given index for a given basic block. Assumes that `stmt_idx`
+/// and `bb_idx` are valid for a given body.
+pub fn statement_location(body: &Body, bb_idx: &BasicBlockIdx, stmt_idx: usize) -> Location {
+    let bb = &body.blocks[*bb_idx];
+    let stmt = &bb.statements[stmt_idx];
+    Location(stmt.span)
+}
+
+/// Location of the terminator for a given basic block. Assumes that `bb_idx` is valid for a given
+/// body.
+pub fn terminator_location(body: &Body, bb_idx: &BasicBlockIdx) -> Location {
+    let bb = &body.blocks[*bb_idx];
+    let terminator = &bb.terminator;
+    Location(terminator.span)
+}
+
+/// Reference to a place used to represent a partial projection.
+pub struct PlaceRef<'a> {
+    pub local: Local,
+    pub projection: &'a [ProjectionElem],
+}
+
+impl PlaceRef<'_> {
+    /// Get the type of this place.
+    pub fn ty(&self, locals: &[LocalDecl]) -> Result<Ty, Error> {
+        self.projection.iter().try_fold(locals[self.local].ty, |place_ty, elem| elem.ty(place_ty))
+    }
+}
+
+/// Information about a place's usage.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct PlaceContext {
+    /// Whether the access is mutable or not. Keep this private so we can increment the type in a
+    /// backward compatible manner.
+    is_mut: bool,
+}
+
+impl PlaceContext {
+    const MUTATING: Self = PlaceContext { is_mut: true };
+    const NON_MUTATING: Self = PlaceContext { is_mut: false };
+    const NON_USE: Self = PlaceContext { is_mut: false };
+
+    pub fn is_mutating(&self) -> bool {
+        self.is_mut
+    }
+}
diff --git a/compiler/rustc_public/src/rustc_internal/mod.rs b/compiler/rustc_public/src/rustc_internal/mod.rs
new file mode 100644
index 00000000000..5d7c8256d5b
--- /dev/null
+++ b/compiler/rustc_public/src/rustc_internal/mod.rs
@@ -0,0 +1,270 @@
+//! Module that implements the bridge between Stable MIR and internal compiler MIR.
+//!
+//! For that, we define APIs that will temporarily be public to 3P that exposes rustc internal APIs
+//! until stable MIR is complete.
+
+use std::cell::{Cell, RefCell};
+
+use rustc_middle::ty::TyCtxt;
+use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::{Bridge, SmirContainer, Tables};
+use rustc_span::def_id::CrateNum;
+use scoped_tls::scoped_thread_local;
+
+use crate::Error;
+use crate::unstable::{RustcInternal, Stable};
+
+pub mod pretty;
+
+/// Convert an internal Rust compiler item into its stable counterpart, if one exists.
+///
+/// # Warning
+///
+/// This function is unstable, and its behavior may change at any point.
+/// E.g.: Items that were previously supported, may no longer be supported, or its translation may
+/// change.
+///
+/// # Panics
+///
+/// This function will panic if StableMIR has not been properly initialized.
+pub fn stable<'tcx, S: Stable<'tcx>>(item: S) -> S::T {
+    with_container(|tables, cx| item.stable(tables, cx))
+}
+
+/// Convert a stable item into its internal Rust compiler counterpart, if one exists.
+///
+/// # Warning
+///
+/// This function is unstable, and it's behavior may change at any point.
+/// Not every stable item can be converted to an internal one.
+/// Furthermore, items that were previously supported, may no longer be supported in newer versions.
+///
+/// # Panics
+///
+/// This function will panic if StableMIR has not been properly initialized.
+pub fn internal<'tcx, S>(tcx: TyCtxt<'tcx>, item: S) -> S::T<'tcx>
+where
+    S: RustcInternal,
+{
+    // The tcx argument ensures that the item won't outlive the type context.
+    // See https://github.com/rust-lang/rust/pull/120128/commits/9aace6723572438a94378451793ca37deb768e72
+    // for more details.
+    with_container(|tables, _| item.internal(tables, tcx))
+}
+
+pub fn crate_num(item: &crate::Crate) -> CrateNum {
+    item.id.into()
+}
+
+// A thread local variable that stores a pointer to the tables mapping between TyCtxt
+// datastructures and stable MIR datastructures
+scoped_thread_local! (static TLV: Cell<*const ()>);
+
+pub(crate) fn init<'tcx, F, T, B: Bridge>(container: &SmirContainer<'tcx, B>, f: F) -> T
+where
+    F: FnOnce() -> T,
+{
+    assert!(!TLV.is_set());
+    let ptr = container as *const _ as *const ();
+    TLV.set(&Cell::new(ptr), || f())
+}
+
+/// Loads the current context and calls a function with it.
+/// Do not nest these, as that will ICE.
+pub(crate) fn with_container<R, B: Bridge>(
+    f: impl for<'tcx> FnOnce(&mut Tables<'tcx, B>, &SmirCtxt<'tcx, B>) -> R,
+) -> R {
+    assert!(TLV.is_set());
+    TLV.with(|tlv| {
+        let ptr = tlv.get();
+        assert!(!ptr.is_null());
+        let container = ptr as *const SmirContainer<'_, B>;
+        let mut tables = unsafe { (*container).tables.borrow_mut() };
+        let cx = unsafe { (*container).cx.borrow() };
+        f(&mut *tables, &*cx)
+    })
+}
+
+pub fn run<F, T>(tcx: TyCtxt<'_>, f: F) -> Result<T, Error>
+where
+    F: FnOnce() -> T,
+{
+    let smir_cx = RefCell::new(SmirCtxt::new(tcx));
+    let container = SmirContainer { tables: RefCell::new(Tables::default()), cx: smir_cx };
+
+    crate::compiler_interface::run(&container, || init(&container, f))
+}
+
+/// Instantiate and run the compiler with the provided arguments and callback.
+///
+/// The callback will be invoked after the compiler ran all its analyses, but before code generation.
+/// Note that this macro accepts two different formats for the callback:
+/// 1. An ident that resolves to a function that accepts no argument and returns `ControlFlow<B, C>`
+/// ```ignore(needs-extern-crate)
+/// # extern crate rustc_driver;
+/// # extern crate rustc_interface;
+/// # extern crate rustc_middle;
+/// # #[macro_use]
+/// # extern crate rustc_public;
+/// #
+/// # fn main() {
+/// #   use std::ops::ControlFlow;
+/// #   use rustc_public::CompilerError;
+///     fn analyze_code() -> ControlFlow<(), ()> {
+///         // Your code goes in here.
+/// #       ControlFlow::Continue(())
+///     }
+/// #   let args = &["--verbose".to_string()];
+///     let result = run!(args, analyze_code);
+/// #   assert_eq!(result, Err(CompilerError::Skipped))
+/// # }
+/// ```
+/// 2. A closure expression:
+/// ```ignore(needs-extern-crate)
+/// # extern crate rustc_driver;
+/// # extern crate rustc_interface;
+/// # extern crate rustc_middle;
+/// # #[macro_use]
+/// # extern crate rustc_public;
+/// #
+/// # fn main() {
+/// #   use std::ops::ControlFlow;
+/// #   use rustc_public::CompilerError;
+///     fn analyze_code(extra_args: Vec<String>) -> ControlFlow<(), ()> {
+/// #       let _ = extra_args;
+///         // Your code goes in here.
+/// #       ControlFlow::Continue(())
+///     }
+/// #   let args = &["--verbose".to_string()];
+/// #   let extra_args = vec![];
+///     let result = run!(args, || analyze_code(extra_args));
+/// #   assert_eq!(result, Err(CompilerError::Skipped))
+/// # }
+/// ```
+#[macro_export]
+macro_rules! run {
+    ($args:expr, $callback_fn:ident) => {
+        run_driver!($args, || $callback_fn())
+    };
+    ($args:expr, $callback:expr) => {
+        run_driver!($args, $callback)
+    };
+}
+
+/// Instantiate and run the compiler with the provided arguments and callback.
+///
+/// This is similar to `run` but it invokes the callback with the compiler's `TyCtxt`,
+/// which can be used to invoke internal APIs.
+#[macro_export]
+macro_rules! run_with_tcx {
+    ($args:expr, $callback_fn:ident) => {
+        run_driver!($args, |tcx| $callback_fn(tcx), with_tcx)
+    };
+    ($args:expr, $callback:expr) => {
+        run_driver!($args, $callback, with_tcx)
+    };
+}
+
+/// Optionally include an ident. This is needed due to macro hygiene.
+#[macro_export]
+#[doc(hidden)]
+macro_rules! optional {
+    (with_tcx $ident:ident) => {
+        $ident
+    };
+}
+
+/// Prefer using [run!] and [run_with_tcx] instead.
+///
+/// This macro implements the instantiation of a StableMIR driver, and it will invoke
+/// the given callback after the compiler analyses.
+///
+/// The third argument determines whether the callback requires `tcx` as an argument.
+#[macro_export]
+#[doc(hidden)]
+macro_rules! run_driver {
+    ($args:expr, $callback:expr $(, $with_tcx:ident)?) => {{
+        use rustc_driver::{Callbacks, Compilation, run_compiler};
+        use rustc_middle::ty::TyCtxt;
+        use rustc_interface::interface;
+        use rustc_public::rustc_internal;
+        use rustc_public::CompilerError;
+        use std::ops::ControlFlow;
+
+        pub struct StableMir<B = (), C = (), F = fn($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C>>
+        where
+            B: Send,
+            C: Send,
+            F: FnOnce($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
+        {
+            callback: Option<F>,
+            result: Option<ControlFlow<B, C>>,
+        }
+
+        impl<B, C, F> StableMir<B, C, F>
+        where
+            B: Send,
+            C: Send,
+            F: FnOnce($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
+        {
+            /// Creates a new `StableMir` instance, with given test_function and arguments.
+            pub fn new(callback: F) -> Self {
+                StableMir { callback: Some(callback), result: None }
+            }
+
+            /// Runs the compiler against given target and tests it with `test_function`
+            pub fn run(&mut self, args: &[String]) -> Result<C, CompilerError<B>> {
+                let compiler_result = rustc_driver::catch_fatal_errors(|| -> interface::Result::<()> {
+                    run_compiler(&args, self);
+                    Ok(())
+                });
+                match (compiler_result, self.result.take()) {
+                    (Ok(Ok(())), Some(ControlFlow::Continue(value))) => Ok(value),
+                    (Ok(Ok(())), Some(ControlFlow::Break(value))) => {
+                        Err(CompilerError::Interrupted(value))
+                    }
+                    (Ok(Ok(_)), None) => Err(CompilerError::Skipped),
+                    // Two cases here:
+                    // - `run` finished normally and returned `Err`
+                    // - `run` panicked with `FatalErr`
+                    // You might think that normal compile errors cause the former, and
+                    // ICEs cause the latter. But some normal compiler errors also cause
+                    // the latter. So we can't meaningfully distinguish them, and group
+                    // them together.
+                    (Ok(Err(_)), _) | (Err(_), _) => Err(CompilerError::Failed),
+                }
+            }
+        }
+
+        impl<B, C, F> Callbacks for StableMir<B, C, F>
+        where
+            B: Send,
+            C: Send,
+            F: FnOnce($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
+        {
+            /// Called after analysis. Return value instructs the compiler whether to
+            /// continue the compilation afterwards (defaults to `Compilation::Continue`)
+            fn after_analysis<'tcx>(
+                &mut self,
+                _compiler: &interface::Compiler,
+                tcx: TyCtxt<'tcx>,
+            ) -> Compilation {
+                if let Some(callback) = self.callback.take() {
+                    rustc_internal::run(tcx, || {
+                        self.result = Some(callback($(optional!($with_tcx tcx))?));
+                    })
+                    .unwrap();
+                    if self.result.as_ref().is_some_and(|val| val.is_continue()) {
+                        Compilation::Continue
+                    } else {
+                        Compilation::Stop
+                    }
+                } else {
+                    Compilation::Continue
+                }
+            }
+        }
+
+        StableMir::new($callback).run($args)
+    }};
+}
diff --git a/compiler/rustc_public/src/rustc_internal/pretty.rs b/compiler/rustc_public/src/rustc_internal/pretty.rs
new file mode 100644
index 00000000000..28c5280fe04
--- /dev/null
+++ b/compiler/rustc_public/src/rustc_internal/pretty.rs
@@ -0,0 +1,21 @@
+use std::io;
+
+use rustc_middle::ty::TyCtxt;
+
+use super::run;
+
+pub fn write_smir_pretty<'tcx, W: io::Write>(tcx: TyCtxt<'tcx>, w: &mut W) -> io::Result<()> {
+    writeln!(
+        w,
+        "// WARNING: This is highly experimental output it's intended for stable-mir developers only."
+    )?;
+    writeln!(
+        w,
+        "// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir."
+    )?;
+    let _ = run(tcx, || {
+        let items = crate::all_local_items();
+        let _ = items.iter().map(|item| -> io::Result<()> { item.emit_mir(w) }).collect::<Vec<_>>();
+    });
+    Ok(())
+}
diff --git a/compiler/rustc_public/src/target.rs b/compiler/rustc_public/src/target.rs
new file mode 100644
index 00000000000..32c3a2a9122
--- /dev/null
+++ b/compiler/rustc_public/src/target.rs
@@ -0,0 +1,60 @@
+//! Provide information about the machine that this is being compiled into.
+
+use serde::Serialize;
+
+use crate::compiler_interface::with;
+
+/// The properties of the target machine being compiled into.
+#[derive(Clone, PartialEq, Eq, Serialize)]
+pub struct MachineInfo {
+    pub endian: Endian,
+    pub pointer_width: MachineSize,
+}
+
+impl MachineInfo {
+    pub fn target() -> MachineInfo {
+        with(|cx| cx.target_info())
+    }
+
+    pub fn target_endianness() -> Endian {
+        with(|cx| cx.target_info().endian)
+    }
+
+    pub fn target_pointer_width() -> MachineSize {
+        with(|cx| cx.target_info().pointer_width)
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Serialize)]
+pub enum Endian {
+    Little,
+    Big,
+}
+
+/// Represent the size of a component.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
+pub struct MachineSize {
+    num_bits: usize,
+}
+
+impl MachineSize {
+    #[inline(always)]
+    pub fn bytes(self) -> usize {
+        self.num_bits / 8
+    }
+
+    #[inline(always)]
+    pub fn bits(self) -> usize {
+        self.num_bits
+    }
+
+    #[inline(always)]
+    pub fn from_bits(num_bits: usize) -> MachineSize {
+        MachineSize { num_bits }
+    }
+
+    #[inline]
+    pub fn unsigned_int_max(self) -> Option<u128> {
+        (self.num_bits <= 128).then(|| u128::MAX >> (128 - self.bits()))
+    }
+}
diff --git a/compiler/rustc_public/src/ty.rs b/compiler/rustc_public/src/ty.rs
new file mode 100644
index 00000000000..bc67a2f987d
--- /dev/null
+++ b/compiler/rustc_public/src/ty.rs
@@ -0,0 +1,1655 @@
+use std::fmt::{self, Debug, Display, Formatter};
+use std::ops::Range;
+
+use serde::Serialize;
+
+use super::abi::ReprOptions;
+use super::mir::{Body, Mutability, Safety};
+use super::{DefId, Error, Symbol, with};
+use crate::abi::{FnAbi, Layout};
+use crate::crate_def::{CrateDef, CrateDefItems, CrateDefType};
+use crate::mir::alloc::{AllocId, read_target_int, read_target_uint};
+use crate::mir::mono::StaticDef;
+use crate::target::MachineInfo;
+use crate::{Filename, IndexedVal, Opaque};
+
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Serialize)]
+pub struct Ty(usize);
+
+impl Debug for Ty {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Ty").field("id", &self.0).field("kind", &self.kind()).finish()
+    }
+}
+
+/// Constructors for `Ty`.
+impl Ty {
+    /// Create a new type from a given kind.
+    pub fn from_rigid_kind(kind: RigidTy) -> Ty {
+        with(|cx| cx.new_rigid_ty(kind))
+    }
+
+    /// Create a new array type.
+    pub fn try_new_array(elem_ty: Ty, size: u64) -> Result<Ty, Error> {
+        Ok(Ty::from_rigid_kind(RigidTy::Array(elem_ty, TyConst::try_from_target_usize(size)?)))
+    }
+
+    /// Create a new array type from Const length.
+    pub fn new_array_with_const_len(elem_ty: Ty, len: TyConst) -> Ty {
+        Ty::from_rigid_kind(RigidTy::Array(elem_ty, len))
+    }
+
+    /// Create a new pointer type.
+    pub fn new_ptr(pointee_ty: Ty, mutability: Mutability) -> Ty {
+        Ty::from_rigid_kind(RigidTy::RawPtr(pointee_ty, mutability))
+    }
+
+    /// Create a new reference type.
+    pub fn new_ref(reg: Region, pointee_ty: Ty, mutability: Mutability) -> Ty {
+        Ty::from_rigid_kind(RigidTy::Ref(reg, pointee_ty, mutability))
+    }
+
+    /// Create a new pointer type.
+    pub fn new_tuple(tys: &[Ty]) -> Ty {
+        Ty::from_rigid_kind(RigidTy::Tuple(Vec::from(tys)))
+    }
+
+    /// Create a new closure type.
+    pub fn new_closure(def: ClosureDef, args: GenericArgs) -> Ty {
+        Ty::from_rigid_kind(RigidTy::Closure(def, args))
+    }
+
+    /// Create a new coroutine type.
+    pub fn new_coroutine(def: CoroutineDef, args: GenericArgs, mov: Movability) -> Ty {
+        Ty::from_rigid_kind(RigidTy::Coroutine(def, args, mov))
+    }
+
+    /// Create a new closure type.
+    pub fn new_coroutine_closure(def: CoroutineClosureDef, args: GenericArgs) -> Ty {
+        Ty::from_rigid_kind(RigidTy::CoroutineClosure(def, args))
+    }
+
+    /// Create a new box type that represents `Box<T>`, for the given inner type `T`.
+    pub fn new_box(inner_ty: Ty) -> Ty {
+        with(|cx| cx.new_box_ty(inner_ty))
+    }
+
+    /// Create a type representing `usize`.
+    pub fn usize_ty() -> Ty {
+        Ty::from_rigid_kind(RigidTy::Uint(UintTy::Usize))
+    }
+
+    /// Create a type representing `bool`.
+    pub fn bool_ty() -> Ty {
+        Ty::from_rigid_kind(RigidTy::Bool)
+    }
+
+    /// Create a type representing a signed integer.
+    pub fn signed_ty(inner: IntTy) -> Ty {
+        Ty::from_rigid_kind(RigidTy::Int(inner))
+    }
+
+    /// Create a type representing an unsigned integer.
+    pub fn unsigned_ty(inner: UintTy) -> Ty {
+        Ty::from_rigid_kind(RigidTy::Uint(inner))
+    }
+
+    /// Get a type layout.
+    pub fn layout(self) -> Result<Layout, Error> {
+        with(|cx| cx.ty_layout(self))
+    }
+}
+
+impl Ty {
+    pub fn kind(&self) -> TyKind {
+        with(|context| context.ty_kind(*self))
+    }
+}
+
+/// Represents a pattern in the type system
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum Pattern {
+    Range { start: Option<TyConst>, end: Option<TyConst>, include_end: bool },
+}
+
+/// Represents a constant in the type system
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct TyConst {
+    pub(crate) kind: TyConstKind,
+    pub id: TyConstId,
+}
+
+impl TyConst {
+    pub fn new(kind: TyConstKind, id: TyConstId) -> TyConst {
+        Self { kind, id }
+    }
+
+    /// Retrieve the constant kind.
+    pub fn kind(&self) -> &TyConstKind {
+        &self.kind
+    }
+
+    /// Creates an interned usize constant.
+    pub fn try_from_target_usize(val: u64) -> Result<Self, Error> {
+        with(|cx| cx.try_new_ty_const_uint(val.into(), UintTy::Usize))
+    }
+
+    /// Try to evaluate to a target `usize`.
+    pub fn eval_target_usize(&self) -> Result<u64, Error> {
+        with(|cx| cx.eval_target_usize_ty(self))
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum TyConstKind {
+    Param(ParamConst),
+    Bound(DebruijnIndex, BoundVar),
+    Unevaluated(ConstDef, GenericArgs),
+
+    // FIXME: These should be a valtree
+    Value(Ty, Allocation),
+    ZSTValue(Ty),
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct TyConstId(usize);
+
+/// Represents a constant in MIR
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct MirConst {
+    /// The constant kind.
+    pub(crate) kind: ConstantKind,
+    /// The constant type.
+    pub(crate) ty: Ty,
+    /// Used for internal tracking of the internal constant.
+    pub id: MirConstId,
+}
+
+impl MirConst {
+    /// Build a constant. Note that this should only be used by the compiler.
+    pub fn new(kind: ConstantKind, ty: Ty, id: MirConstId) -> MirConst {
+        MirConst { kind, ty, id }
+    }
+
+    /// Retrieve the constant kind.
+    pub fn kind(&self) -> &ConstantKind {
+        &self.kind
+    }
+
+    /// Get the constant type.
+    pub fn ty(&self) -> Ty {
+        self.ty
+    }
+
+    /// Try to evaluate to a target `usize`.
+    pub fn eval_target_usize(&self) -> Result<u64, Error> {
+        with(|cx| cx.eval_target_usize(self))
+    }
+
+    /// Create a constant that represents a new zero-sized constant of type T.
+    /// Fails if the type is not a ZST or if it doesn't have a known size.
+    pub fn try_new_zero_sized(ty: Ty) -> Result<MirConst, Error> {
+        with(|cx| cx.try_new_const_zst(ty))
+    }
+
+    /// Build a new constant that represents the given string.
+    ///
+    /// Note that there is no guarantee today about duplication of the same constant.
+    /// I.e.: Calling this function multiple times with the same argument may or may not return
+    /// the same allocation.
+    pub fn from_str(value: &str) -> MirConst {
+        with(|cx| cx.new_const_str(value))
+    }
+
+    /// Build a new constant that represents the given boolean value.
+    pub fn from_bool(value: bool) -> MirConst {
+        with(|cx| cx.new_const_bool(value))
+    }
+
+    /// Build a new constant that represents the given unsigned integer.
+    pub fn try_from_uint(value: u128, uint_ty: UintTy) -> Result<MirConst, Error> {
+        with(|cx| cx.try_new_const_uint(value, uint_ty))
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+pub struct MirConstId(usize);
+
+type Ident = Opaque;
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct Region {
+    pub kind: RegionKind,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum RegionKind {
+    ReEarlyParam(EarlyParamRegion),
+    ReBound(DebruijnIndex, BoundRegion),
+    ReStatic,
+    RePlaceholder(Placeholder<BoundRegion>),
+    ReErased,
+}
+
+pub(crate) type DebruijnIndex = u32;
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct EarlyParamRegion {
+    pub index: u32,
+    pub name: Symbol,
+}
+
+pub(crate) type BoundVar = u32;
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct BoundRegion {
+    pub var: BoundVar,
+    pub kind: BoundRegionKind,
+}
+
+pub(crate) type UniverseIndex = u32;
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct Placeholder<T> {
+    pub universe: UniverseIndex,
+    pub bound: T,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Serialize)]
+pub struct Span(usize);
+
+impl Debug for Span {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Span")
+            .field("id", &self.0)
+            .field("repr", &with(|cx| cx.span_to_string(*self)))
+            .finish()
+    }
+}
+
+impl Span {
+    /// Return filename for diagnostic purposes
+    pub fn get_filename(&self) -> Filename {
+        with(|c| c.get_filename(self))
+    }
+
+    /// Return lines that correspond to this `Span`
+    pub fn get_lines(&self) -> LineInfo {
+        with(|c| c.get_lines(self))
+    }
+
+    /// Return the span location to be printed in diagnostic messages.
+    ///
+    /// This may leak local file paths and should not be used to build artifacts that may be
+    /// distributed.
+    pub fn diagnostic(&self) -> String {
+        with(|c| c.span_to_string(*self))
+    }
+}
+
+#[derive(Clone, Copy, Debug, Serialize)]
+/// Information you get from `Span` in a struct form.
+/// Line and col start from 1.
+pub struct LineInfo {
+    pub start_line: usize,
+    pub start_col: usize,
+    pub end_line: usize,
+    pub end_col: usize,
+}
+
+impl LineInfo {
+    pub fn from(lines: (usize, usize, usize, usize)) -> Self {
+        LineInfo { start_line: lines.0, start_col: lines.1, end_line: lines.2, end_col: lines.3 }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum TyKind {
+    RigidTy(RigidTy),
+    Alias(AliasKind, AliasTy),
+    Param(ParamTy),
+    Bound(usize, BoundTy),
+}
+
+impl TyKind {
+    pub fn rigid(&self) -> Option<&RigidTy> {
+        if let TyKind::RigidTy(inner) = self { Some(inner) } else { None }
+    }
+
+    #[inline]
+    pub fn is_unit(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Tuple(data)) if data.is_empty())
+    }
+
+    #[inline]
+    pub fn is_bool(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Bool))
+    }
+
+    #[inline]
+    pub fn is_char(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Char))
+    }
+
+    #[inline]
+    pub fn is_trait(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Dynamic(_, _, DynKind::Dyn)))
+    }
+
+    #[inline]
+    pub fn is_enum(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Adt(def, _)) if def.kind() == AdtKind::Enum)
+    }
+
+    #[inline]
+    pub fn is_struct(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Adt(def, _)) if def.kind() == AdtKind::Struct)
+    }
+
+    #[inline]
+    pub fn is_union(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Adt(def, _)) if def.kind() == AdtKind::Union)
+    }
+
+    #[inline]
+    pub fn is_adt(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Adt(..)))
+    }
+
+    #[inline]
+    pub fn is_ref(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Ref(..)))
+    }
+
+    #[inline]
+    pub fn is_fn(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::FnDef(..)))
+    }
+
+    #[inline]
+    pub fn is_fn_ptr(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::FnPtr(..)))
+    }
+
+    #[inline]
+    pub fn is_primitive(&self) -> bool {
+        matches!(
+            self,
+            TyKind::RigidTy(
+                RigidTy::Bool
+                    | RigidTy::Char
+                    | RigidTy::Int(_)
+                    | RigidTy::Uint(_)
+                    | RigidTy::Float(_)
+            )
+        )
+    }
+
+    #[inline]
+    pub fn is_float(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Float(_)))
+    }
+
+    #[inline]
+    pub fn is_integral(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Int(_) | RigidTy::Uint(_)))
+    }
+
+    #[inline]
+    pub fn is_numeric(&self) -> bool {
+        self.is_integral() || self.is_float()
+    }
+
+    #[inline]
+    pub fn is_signed(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Int(_)))
+    }
+
+    #[inline]
+    pub fn is_str(&self) -> bool {
+        *self == TyKind::RigidTy(RigidTy::Str)
+    }
+
+    #[inline]
+    pub fn is_cstr(&self) -> bool {
+        let TyKind::RigidTy(RigidTy::Adt(def, _)) = self else {
+            return false;
+        };
+        with(|cx| cx.adt_is_cstr(*def))
+    }
+
+    #[inline]
+    pub fn is_slice(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Slice(_)))
+    }
+
+    #[inline]
+    pub fn is_array(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Array(..)))
+    }
+
+    #[inline]
+    pub fn is_mutable_ptr(&self) -> bool {
+        matches!(
+            self,
+            TyKind::RigidTy(RigidTy::RawPtr(_, Mutability::Mut))
+                | TyKind::RigidTy(RigidTy::Ref(_, _, Mutability::Mut))
+        )
+    }
+
+    #[inline]
+    pub fn is_raw_ptr(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::RawPtr(..)))
+    }
+
+    /// Tests if this is any kind of primitive pointer type (reference, raw pointer, fn pointer).
+    #[inline]
+    pub fn is_any_ptr(&self) -> bool {
+        self.is_ref() || self.is_raw_ptr() || self.is_fn_ptr()
+    }
+
+    #[inline]
+    pub fn is_coroutine(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Coroutine(..)))
+    }
+
+    #[inline]
+    pub fn is_closure(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Closure(..)))
+    }
+
+    #[inline]
+    pub fn is_box(&self) -> bool {
+        match self {
+            TyKind::RigidTy(RigidTy::Adt(def, _)) => def.is_box(),
+            _ => false,
+        }
+    }
+
+    #[inline]
+    pub fn is_simd(&self) -> bool {
+        matches!(self, TyKind::RigidTy(RigidTy::Adt(def, _)) if def.is_simd())
+    }
+
+    pub fn trait_principal(&self) -> Option<Binder<ExistentialTraitRef>> {
+        if let TyKind::RigidTy(RigidTy::Dynamic(predicates, _, _)) = self {
+            if let Some(Binder { value: ExistentialPredicate::Trait(trait_ref), bound_vars }) =
+                predicates.first()
+            {
+                Some(Binder { value: trait_ref.clone(), bound_vars: bound_vars.clone() })
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
+    /// Returns the type of `ty[i]` for builtin types.
+    pub fn builtin_index(&self) -> Option<Ty> {
+        match self.rigid()? {
+            RigidTy::Array(ty, _) | RigidTy::Slice(ty) => Some(*ty),
+            _ => None,
+        }
+    }
+
+    /// Returns the type and mutability of `*ty` for builtin types.
+    ///
+    /// The parameter `explicit` indicates if this is an *explicit* dereference.
+    /// Some types -- notably raw ptrs -- can only be dereferenced explicitly.
+    pub fn builtin_deref(&self, explicit: bool) -> Option<TypeAndMut> {
+        match self.rigid()? {
+            RigidTy::Adt(def, args) if def.is_box() => {
+                Some(TypeAndMut { ty: *args.0.first()?.ty()?, mutability: Mutability::Not })
+            }
+            RigidTy::Ref(_, ty, mutability) => {
+                Some(TypeAndMut { ty: *ty, mutability: *mutability })
+            }
+            RigidTy::RawPtr(ty, mutability) if explicit => {
+                Some(TypeAndMut { ty: *ty, mutability: *mutability })
+            }
+            _ => None,
+        }
+    }
+
+    /// Get the function signature for function like types (Fn, FnPtr, and Closure)
+    pub fn fn_sig(&self) -> Option<PolyFnSig> {
+        match self {
+            TyKind::RigidTy(RigidTy::FnDef(def, args)) => Some(with(|cx| cx.fn_sig(*def, args))),
+            TyKind::RigidTy(RigidTy::FnPtr(sig)) => Some(sig.clone()),
+            TyKind::RigidTy(RigidTy::Closure(_def, args)) => Some(with(|cx| cx.closure_sig(args))),
+            _ => None,
+        }
+    }
+
+    /// Get the discriminant type for this type.
+    pub fn discriminant_ty(&self) -> Option<Ty> {
+        self.rigid().map(|ty| with(|cx| cx.rigid_ty_discriminant_ty(ty)))
+    }
+
+    /// Deconstruct a function type if this is one.
+    pub fn fn_def(&self) -> Option<(FnDef, &GenericArgs)> {
+        if let TyKind::RigidTy(RigidTy::FnDef(def, args)) = self {
+            Some((*def, args))
+        } else {
+            None
+        }
+    }
+}
+
+pub struct TypeAndMut {
+    pub ty: Ty,
+    pub mutability: Mutability,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum RigidTy {
+    Bool,
+    Char,
+    Int(IntTy),
+    Uint(UintTy),
+    Float(FloatTy),
+    Adt(AdtDef, GenericArgs),
+    Foreign(ForeignDef),
+    Str,
+    Array(Ty, TyConst),
+    Pat(Ty, Pattern),
+    Slice(Ty),
+    RawPtr(Ty, Mutability),
+    Ref(Region, Ty, Mutability),
+    FnDef(FnDef, GenericArgs),
+    FnPtr(PolyFnSig),
+    Closure(ClosureDef, GenericArgs),
+    // FIXME(rustc_public): Movability here is redundant
+    Coroutine(CoroutineDef, GenericArgs, Movability),
+    CoroutineClosure(CoroutineClosureDef, GenericArgs),
+    Dynamic(Vec<Binder<ExistentialPredicate>>, Region, DynKind),
+    Never,
+    Tuple(Vec<Ty>),
+    CoroutineWitness(CoroutineWitnessDef, GenericArgs),
+}
+
+impl RigidTy {
+    /// Get the discriminant type for this type.
+    pub fn discriminant_ty(&self) -> Ty {
+        with(|cx| cx.rigid_ty_discriminant_ty(self))
+    }
+}
+
+impl From<RigidTy> for TyKind {
+    fn from(value: RigidTy) -> Self {
+        TyKind::RigidTy(value)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+pub enum IntTy {
+    Isize,
+    I8,
+    I16,
+    I32,
+    I64,
+    I128,
+}
+
+impl IntTy {
+    pub fn num_bytes(self) -> usize {
+        match self {
+            IntTy::Isize => MachineInfo::target_pointer_width().bytes(),
+            IntTy::I8 => 1,
+            IntTy::I16 => 2,
+            IntTy::I32 => 4,
+            IntTy::I64 => 8,
+            IntTy::I128 => 16,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+pub enum UintTy {
+    Usize,
+    U8,
+    U16,
+    U32,
+    U64,
+    U128,
+}
+
+impl UintTy {
+    pub fn num_bytes(self) -> usize {
+        match self {
+            UintTy::Usize => MachineInfo::target_pointer_width().bytes(),
+            UintTy::U8 => 1,
+            UintTy::U16 => 2,
+            UintTy::U32 => 4,
+            UintTy::U64 => 8,
+            UintTy::U128 => 16,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+pub enum FloatTy {
+    F16,
+    F32,
+    F64,
+    F128,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+pub enum Movability {
+    Static,
+    Movable,
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub ForeignModuleDef;
+}
+
+impl ForeignModuleDef {
+    pub fn module(&self) -> ForeignModule {
+        with(|cx| cx.foreign_module(*self))
+    }
+}
+
+pub struct ForeignModule {
+    pub def_id: ForeignModuleDef,
+    pub abi: Abi,
+}
+
+impl ForeignModule {
+    pub fn items(&self) -> Vec<ForeignDef> {
+        with(|cx| cx.foreign_items(self.def_id))
+    }
+}
+
+crate_def_with_ty! {
+    /// Hold information about a ForeignItem in a crate.
+    #[derive(Serialize)]
+    pub ForeignDef;
+}
+
+impl ForeignDef {
+    pub fn kind(&self) -> ForeignItemKind {
+        with(|cx| cx.foreign_item_kind(*self))
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
+pub enum ForeignItemKind {
+    Fn(FnDef),
+    Static(StaticDef),
+    Type(Ty),
+}
+
+crate_def_with_ty! {
+    /// Hold information about a function definition in a crate.
+    #[derive(Serialize)]
+    pub FnDef;
+}
+
+impl FnDef {
+    // Get the function body if available.
+    pub fn body(&self) -> Option<Body> {
+        with(|ctx| ctx.has_body(self.0).then(|| ctx.mir_body(self.0)))
+    }
+
+    // Check if the function body is available.
+    pub fn has_body(&self) -> bool {
+        with(|ctx| ctx.has_body(self.0))
+    }
+
+    /// Get the information of the intrinsic if this function is a definition of one.
+    pub fn as_intrinsic(&self) -> Option<IntrinsicDef> {
+        with(|cx| cx.intrinsic(self.def_id()))
+    }
+
+    /// Check if the function is an intrinsic.
+    #[inline]
+    pub fn is_intrinsic(&self) -> bool {
+        self.as_intrinsic().is_some()
+    }
+
+    /// Get the function signature for this function definition.
+    pub fn fn_sig(&self) -> PolyFnSig {
+        let kind = self.ty().kind();
+        kind.fn_sig().unwrap()
+    }
+}
+
+crate_def_with_ty! {
+    #[derive(Serialize)]
+    pub IntrinsicDef;
+}
+
+impl IntrinsicDef {
+    /// Returns the plain name of the intrinsic.
+    /// e.g., `transmute` for `core::intrinsics::transmute`.
+    pub fn fn_name(&self) -> Symbol {
+        with(|cx| cx.intrinsic_name(*self))
+    }
+
+    /// Returns whether the intrinsic has no meaningful body and all backends
+    /// need to shim all calls to it.
+    pub fn must_be_overridden(&self) -> bool {
+        with(|cx| !cx.has_body(self.0))
+    }
+}
+
+impl From<IntrinsicDef> for FnDef {
+    fn from(def: IntrinsicDef) -> Self {
+        FnDef(def.0)
+    }
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub ClosureDef;
+}
+
+impl ClosureDef {
+    /// Retrieves the body of the closure definition. Returns None if the body
+    /// isn't available.
+    pub fn body(&self) -> Option<Body> {
+        with(|ctx| ctx.has_body(self.0).then(|| ctx.mir_body(self.0)))
+    }
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub CoroutineDef;
+}
+
+impl CoroutineDef {
+    /// Retrieves the body of the coroutine definition. Returns None if the body
+    /// isn't available.
+    pub fn body(&self) -> Option<Body> {
+        with(|cx| cx.has_body(self.0).then(|| cx.mir_body(self.0)))
+    }
+
+    pub fn discriminant_for_variant(&self, args: &GenericArgs, idx: VariantIdx) -> Discr {
+        with(|cx| cx.coroutine_discr_for_variant(*self, args, idx))
+    }
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub CoroutineClosureDef;
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub ParamDef;
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub BrNamedDef;
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub AdtDef;
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
+pub enum AdtKind {
+    Enum,
+    Union,
+    Struct,
+}
+
+impl AdtDef {
+    pub fn kind(&self) -> AdtKind {
+        with(|cx| cx.adt_kind(*self))
+    }
+
+    /// Retrieve the type of this Adt.
+    pub fn ty(&self) -> Ty {
+        with(|cx| cx.def_ty(self.0))
+    }
+
+    /// Retrieve the type of this Adt by instantiating and normalizing it with the given arguments.
+    ///
+    /// This will assume the type can be instantiated with these arguments.
+    pub fn ty_with_args(&self, args: &GenericArgs) -> Ty {
+        with(|cx| cx.def_ty_with_args(self.0, args))
+    }
+
+    pub fn is_box(&self) -> bool {
+        with(|cx| cx.adt_is_box(*self))
+    }
+
+    pub fn is_simd(&self) -> bool {
+        with(|cx| cx.adt_is_simd(*self))
+    }
+
+    /// The number of variants in this ADT.
+    pub fn num_variants(&self) -> usize {
+        with(|cx| cx.adt_variants_len(*self))
+    }
+
+    /// Retrieve the variants in this ADT.
+    pub fn variants(&self) -> Vec<VariantDef> {
+        self.variants_iter().collect()
+    }
+
+    /// Iterate over the variants in this ADT.
+    pub fn variants_iter(&self) -> impl Iterator<Item = VariantDef> {
+        (0..self.num_variants())
+            .map(|idx| VariantDef { idx: VariantIdx::to_val(idx), adt_def: *self })
+    }
+
+    pub fn variant(&self, idx: VariantIdx) -> Option<VariantDef> {
+        (idx.to_index() < self.num_variants()).then_some(VariantDef { idx, adt_def: *self })
+    }
+
+    pub fn repr(&self) -> ReprOptions {
+        with(|cx| cx.adt_repr(*self))
+    }
+
+    pub fn discriminant_for_variant(&self, idx: VariantIdx) -> Discr {
+        with(|cx| cx.adt_discr_for_variant(*self, idx))
+    }
+}
+
+pub struct Discr {
+    pub val: u128,
+    pub ty: Ty,
+}
+
+/// Definition of a variant, which can be either a struct / union field or an enum variant.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
+pub struct VariantDef {
+    /// The variant index.
+    ///
+    /// ## Warning
+    /// Do not access this field directly!
+    pub idx: VariantIdx,
+    /// The data type where this variant comes from.
+    /// For now, we use this to retrieve information about the variant itself so we don't need to
+    /// cache more information.
+    ///
+    /// ## Warning
+    /// Do not access this field directly!
+    pub adt_def: AdtDef,
+}
+
+impl VariantDef {
+    pub fn name(&self) -> Symbol {
+        with(|cx| cx.variant_name(*self))
+    }
+
+    /// Retrieve all the fields in this variant.
+    // We expect user to cache this and use it directly since today it is expensive to generate all
+    // fields name.
+    pub fn fields(&self) -> Vec<FieldDef> {
+        with(|cx| cx.variant_fields(*self))
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct FieldDef {
+    /// The field definition.
+    ///
+    /// ## Warning
+    /// Do not access this field directly! This is public for the compiler to have access to it.
+    pub def: DefId,
+
+    /// The field name.
+    pub name: Symbol,
+}
+
+impl FieldDef {
+    /// Retrieve the type of this field instantiating and normalizing it with the given arguments.
+    ///
+    /// This will assume the type can be instantiated with these arguments.
+    pub fn ty_with_args(&self, args: &GenericArgs) -> Ty {
+        with(|cx| cx.def_ty_with_args(self.def, args))
+    }
+
+    /// Retrieve the type of this field.
+    pub fn ty(&self) -> Ty {
+        with(|cx| cx.def_ty(self.def))
+    }
+}
+
+impl Display for AdtKind {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            AdtKind::Enum => "enum",
+            AdtKind::Union => "union",
+            AdtKind::Struct => "struct",
+        })
+    }
+}
+
+impl AdtKind {
+    pub fn is_enum(&self) -> bool {
+        matches!(self, AdtKind::Enum)
+    }
+
+    pub fn is_struct(&self) -> bool {
+        matches!(self, AdtKind::Struct)
+    }
+
+    pub fn is_union(&self) -> bool {
+        matches!(self, AdtKind::Union)
+    }
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub AliasDef;
+}
+
+crate_def! {
+    /// A trait's definition.
+    #[derive(Serialize)]
+    pub TraitDef;
+}
+
+impl_crate_def_items! {
+    TraitDef;
+}
+
+impl TraitDef {
+    pub fn declaration(trait_def: &TraitDef) -> TraitDecl {
+        with(|cx| cx.trait_decl(trait_def))
+    }
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub GenericDef;
+}
+
+crate_def_with_ty! {
+    #[derive(Serialize)]
+    pub ConstDef;
+}
+
+crate_def! {
+    /// A trait impl definition.
+    #[derive(Serialize)]
+    pub ImplDef;
+}
+
+impl_crate_def_items! {
+    ImplDef;
+}
+
+impl ImplDef {
+    /// Retrieve information about this implementation.
+    pub fn trait_impl(&self) -> ImplTrait {
+        with(|cx| cx.trait_impl(self))
+    }
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub RegionDef;
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub CoroutineWitnessDef;
+}
+
+/// A list of generic arguments.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct GenericArgs(pub Vec<GenericArgKind>);
+
+impl std::ops::Index<ParamTy> for GenericArgs {
+    type Output = Ty;
+
+    fn index(&self, index: ParamTy) -> &Self::Output {
+        self.0[index.index as usize].expect_ty()
+    }
+}
+
+impl std::ops::Index<ParamConst> for GenericArgs {
+    type Output = TyConst;
+
+    fn index(&self, index: ParamConst) -> &Self::Output {
+        self.0[index.index as usize].expect_const()
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum GenericArgKind {
+    Lifetime(Region),
+    Type(Ty),
+    Const(TyConst),
+}
+
+impl GenericArgKind {
+    /// Panic if this generic argument is not a type, otherwise
+    /// return the type.
+    #[track_caller]
+    pub fn expect_ty(&self) -> &Ty {
+        match self {
+            GenericArgKind::Type(ty) => ty,
+            _ => panic!("{self:?}"),
+        }
+    }
+
+    /// Panic if this generic argument is not a const, otherwise
+    /// return the const.
+    #[track_caller]
+    pub fn expect_const(&self) -> &TyConst {
+        match self {
+            GenericArgKind::Const(c) => c,
+            _ => panic!("{self:?}"),
+        }
+    }
+
+    /// Return the generic argument type if applicable, otherwise return `None`.
+    pub fn ty(&self) -> Option<&Ty> {
+        match self {
+            GenericArgKind::Type(ty) => Some(ty),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum TermKind {
+    Type(Ty),
+    Const(TyConst),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum AliasKind {
+    Projection,
+    Inherent,
+    Opaque,
+    Free,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct AliasTy {
+    pub def_id: AliasDef,
+    pub args: GenericArgs,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct AliasTerm {
+    pub def_id: AliasDef,
+    pub args: GenericArgs,
+}
+
+pub type PolyFnSig = Binder<FnSig>;
+
+impl PolyFnSig {
+    /// Compute a `FnAbi` suitable for indirect calls, i.e. to `fn` pointers.
+    ///
+    /// NB: this doesn't handle virtual calls - those should use `Instance::fn_abi`
+    /// instead, where the instance is an `InstanceKind::Virtual`.
+    pub fn fn_ptr_abi(self) -> Result<FnAbi, Error> {
+        with(|cx| cx.fn_ptr_abi(self))
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct FnSig {
+    pub inputs_and_output: Vec<Ty>,
+    pub c_variadic: bool,
+    pub safety: Safety,
+    pub abi: Abi,
+}
+
+impl FnSig {
+    pub fn output(&self) -> Ty {
+        self.inputs_and_output[self.inputs_and_output.len() - 1]
+    }
+
+    pub fn inputs(&self) -> &[Ty] {
+        &self.inputs_and_output[..self.inputs_and_output.len() - 1]
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Serialize)]
+pub enum Abi {
+    Rust,
+    C { unwind: bool },
+    Cdecl { unwind: bool },
+    Stdcall { unwind: bool },
+    Fastcall { unwind: bool },
+    Vectorcall { unwind: bool },
+    Thiscall { unwind: bool },
+    Aapcs { unwind: bool },
+    Win64 { unwind: bool },
+    SysV64 { unwind: bool },
+    PtxKernel,
+    Msp430Interrupt,
+    X86Interrupt,
+    GpuKernel,
+    EfiApi,
+    AvrInterrupt,
+    AvrNonBlockingInterrupt,
+    CCmseNonSecureCall,
+    CCmseNonSecureEntry,
+    System { unwind: bool },
+    RustCall,
+    Unadjusted,
+    RustCold,
+    RiscvInterruptM,
+    RiscvInterruptS,
+    RustInvalid,
+    Custom,
+}
+
+/// A binder represents a possibly generic type and its bound vars.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct Binder<T> {
+    pub value: T,
+    pub bound_vars: Vec<BoundVariableKind>,
+}
+
+impl<T> Binder<T> {
+    /// Create a new binder with the given bound vars.
+    pub fn bind_with_vars(value: T, bound_vars: Vec<BoundVariableKind>) -> Self {
+        Binder { value, bound_vars }
+    }
+
+    /// Create a new binder with no bounded variable.
+    pub fn dummy(value: T) -> Self {
+        Binder { value, bound_vars: vec![] }
+    }
+
+    pub fn skip_binder(self) -> T {
+        self.value
+    }
+
+    pub fn map_bound_ref<F, U>(&self, f: F) -> Binder<U>
+    where
+        F: FnOnce(&T) -> U,
+    {
+        let Binder { value, bound_vars } = self;
+        let new_value = f(value);
+        Binder { value: new_value, bound_vars: bound_vars.clone() }
+    }
+
+    pub fn map_bound<F, U>(self, f: F) -> Binder<U>
+    where
+        F: FnOnce(T) -> U,
+    {
+        let Binder { value, bound_vars } = self;
+        let new_value = f(value);
+        Binder { value: new_value, bound_vars }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct EarlyBinder<T> {
+    pub value: T,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum BoundVariableKind {
+    Ty(BoundTyKind),
+    Region(BoundRegionKind),
+    Const,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Serialize)]
+pub enum BoundTyKind {
+    Anon,
+    Param(ParamDef, String),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum BoundRegionKind {
+    BrAnon,
+    BrNamed(BrNamedDef, String),
+    BrEnv,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum DynKind {
+    Dyn,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum ExistentialPredicate {
+    Trait(ExistentialTraitRef),
+    Projection(ExistentialProjection),
+    AutoTrait(TraitDef),
+}
+
+/// An existential reference to a trait where `Self` is not included.
+///
+/// The `generic_args` will include any other known argument.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct ExistentialTraitRef {
+    pub def_id: TraitDef,
+    pub generic_args: GenericArgs,
+}
+
+impl Binder<ExistentialTraitRef> {
+    pub fn with_self_ty(&self, self_ty: Ty) -> Binder<TraitRef> {
+        self.map_bound_ref(|trait_ref| trait_ref.with_self_ty(self_ty))
+    }
+}
+
+impl ExistentialTraitRef {
+    pub fn with_self_ty(&self, self_ty: Ty) -> TraitRef {
+        TraitRef::new(self.def_id, self_ty, &self.generic_args)
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct ExistentialProjection {
+    pub def_id: TraitDef,
+    pub generic_args: GenericArgs,
+    pub term: TermKind,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct ParamTy {
+    pub index: u32,
+    pub name: String,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct BoundTy {
+    pub var: usize,
+    pub kind: BoundTyKind,
+}
+
+pub type Bytes = Vec<Option<u8>>;
+
+/// Size in bytes.
+pub type Size = usize;
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
+pub struct Prov(pub AllocId);
+
+pub type Align = u64;
+pub type Promoted = u32;
+pub type InitMaskMaterialized = Vec<u64>;
+
+/// Stores the provenance information of pointers stored in memory.
+#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize)]
+pub struct ProvenanceMap {
+    /// Provenance in this map applies from the given offset for an entire pointer-size worth of
+    /// bytes. Two entries in this map are always at least a pointer size apart.
+    pub ptrs: Vec<(Size, Prov)>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize)]
+pub struct Allocation {
+    pub bytes: Bytes,
+    pub provenance: ProvenanceMap,
+    pub align: Align,
+    pub mutability: Mutability,
+}
+
+impl Allocation {
+    /// Get a vector of bytes for an Allocation that has been fully initialized
+    pub fn raw_bytes(&self) -> Result<Vec<u8>, Error> {
+        self.bytes
+            .iter()
+            .copied()
+            .collect::<Option<Vec<_>>>()
+            .ok_or_else(|| error!("Found uninitialized bytes: `{:?}`", self.bytes))
+    }
+
+    /// Read a uint value from the specified range.
+    pub fn read_partial_uint(&self, range: Range<usize>) -> Result<u128, Error> {
+        if range.end - range.start > 16 {
+            return Err(error!("Allocation is bigger than largest integer"));
+        }
+        if range.end > self.bytes.len() {
+            return Err(error!(
+                "Range is out of bounds. Allocation length is `{}`, but requested range `{:?}`",
+                self.bytes.len(),
+                range
+            ));
+        }
+        let raw = self.bytes[range]
+            .iter()
+            .copied()
+            .collect::<Option<Vec<_>>>()
+            .ok_or_else(|| error!("Found uninitialized bytes: `{:?}`", self.bytes))?;
+        read_target_uint(&raw)
+    }
+
+    /// Read this allocation and try to convert it to an unassigned integer.
+    pub fn read_uint(&self) -> Result<u128, Error> {
+        if self.bytes.len() > 16 {
+            return Err(error!("Allocation is bigger than largest integer"));
+        }
+        let raw = self.raw_bytes()?;
+        read_target_uint(&raw)
+    }
+
+    /// Read this allocation and try to convert it to a signed integer.
+    pub fn read_int(&self) -> Result<i128, Error> {
+        if self.bytes.len() > 16 {
+            return Err(error!("Allocation is bigger than largest integer"));
+        }
+        let raw = self.raw_bytes()?;
+        read_target_int(&raw)
+    }
+
+    /// Read this allocation and try to convert it to a boolean.
+    pub fn read_bool(&self) -> Result<bool, Error> {
+        match self.read_int()? {
+            0 => Ok(false),
+            1 => Ok(true),
+            val => Err(error!("Unexpected value for bool: `{val}`")),
+        }
+    }
+
+    /// Read this allocation as a pointer and return whether it represents a `null` pointer.
+    pub fn is_null(&self) -> Result<bool, Error> {
+        let len = self.bytes.len();
+        let ptr_len = MachineInfo::target_pointer_width().bytes();
+        if len != ptr_len {
+            return Err(error!("Expected width of pointer (`{ptr_len}`), but found: `{len}`"));
+        }
+        Ok(self.read_uint()? == 0 && self.provenance.ptrs.is_empty())
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum ConstantKind {
+    Ty(TyConst),
+    Allocated(Allocation),
+    Unevaluated(UnevaluatedConst),
+    Param(ParamConst),
+    /// Store ZST constants.
+    /// We have to special handle these constants since its type might be generic.
+    ZeroSized,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct ParamConst {
+    pub index: u32,
+    pub name: String,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct UnevaluatedConst {
+    pub def: ConstDef,
+    pub args: GenericArgs,
+    pub promoted: Option<Promoted>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+pub enum TraitSpecializationKind {
+    None,
+    Marker,
+    AlwaysApplicable,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct TraitDecl {
+    pub def_id: TraitDef,
+    pub safety: Safety,
+    pub paren_sugar: bool,
+    pub has_auto_impl: bool,
+    pub is_marker: bool,
+    pub is_coinductive: bool,
+    pub skip_array_during_method_dispatch: bool,
+    pub skip_boxed_slice_during_method_dispatch: bool,
+    pub specialization_kind: TraitSpecializationKind,
+    pub must_implement_one_of: Option<Vec<Ident>>,
+    pub implement_via_object: bool,
+    pub deny_explicit_impl: bool,
+}
+
+impl TraitDecl {
+    pub fn generics_of(&self) -> Generics {
+        with(|cx| cx.generics_of(self.def_id.0))
+    }
+
+    pub fn predicates_of(&self) -> GenericPredicates {
+        with(|cx| cx.predicates_of(self.def_id.0))
+    }
+
+    pub fn explicit_predicates_of(&self) -> GenericPredicates {
+        with(|cx| cx.explicit_predicates_of(self.def_id.0))
+    }
+}
+
+pub type ImplTrait = EarlyBinder<TraitRef>;
+
+/// A complete reference to a trait, i.e., one where `Self` is known.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct TraitRef {
+    pub def_id: TraitDef,
+    /// The generic arguments for this definition.
+    /// The first element must always be type, and it represents `Self`.
+    args: GenericArgs,
+}
+
+impl TraitRef {
+    pub fn new(def_id: TraitDef, self_ty: Ty, gen_args: &GenericArgs) -> TraitRef {
+        let mut args = vec![GenericArgKind::Type(self_ty)];
+        args.extend_from_slice(&gen_args.0);
+        TraitRef { def_id, args: GenericArgs(args) }
+    }
+
+    pub fn try_new(def_id: TraitDef, args: GenericArgs) -> Result<TraitRef, ()> {
+        match &args.0[..] {
+            [GenericArgKind::Type(_), ..] => Ok(TraitRef { def_id, args }),
+            _ => Err(()),
+        }
+    }
+
+    pub fn args(&self) -> &GenericArgs {
+        &self.args
+    }
+
+    pub fn self_ty(&self) -> Ty {
+        let GenericArgKind::Type(self_ty) = self.args.0[0] else {
+            panic!("Self must be a type, but found: {:?}", self.args.0[0])
+        };
+        self_ty
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct Generics {
+    pub parent: Option<GenericDef>,
+    pub parent_count: usize,
+    pub params: Vec<GenericParamDef>,
+    pub param_def_id_to_index: Vec<(GenericDef, u32)>,
+    pub has_self: bool,
+    pub has_late_bound_regions: Option<Span>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum GenericParamDefKind {
+    Lifetime,
+    Type { has_default: bool, synthetic: bool },
+    Const { has_default: bool },
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct GenericParamDef {
+    pub name: super::Symbol,
+    pub def_id: GenericDef,
+    pub index: u32,
+    pub pure_wrt_drop: bool,
+    pub kind: GenericParamDefKind,
+}
+
+pub struct GenericPredicates {
+    pub parent: Option<TraitDef>,
+    pub predicates: Vec<(PredicateKind, Span)>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum PredicateKind {
+    Clause(ClauseKind),
+    DynCompatible(TraitDef),
+    SubType(SubtypePredicate),
+    Coerce(CoercePredicate),
+    ConstEquate(TyConst, TyConst),
+    Ambiguous,
+    AliasRelate(TermKind, TermKind, AliasRelationDirection),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum ClauseKind {
+    Trait(TraitPredicate),
+    RegionOutlives(RegionOutlivesPredicate),
+    TypeOutlives(TypeOutlivesPredicate),
+    Projection(ProjectionPredicate),
+    ConstArgHasType(TyConst, Ty),
+    WellFormed(TermKind),
+    ConstEvaluatable(TyConst),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum ClosureKind {
+    Fn,
+    FnMut,
+    FnOnce,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct SubtypePredicate {
+    pub a: Ty,
+    pub b: Ty,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct CoercePredicate {
+    pub a: Ty,
+    pub b: Ty,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum AliasRelationDirection {
+    Equate,
+    Subtype,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct TraitPredicate {
+    pub trait_ref: TraitRef,
+    pub polarity: PredicatePolarity,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct OutlivesPredicate<A, B>(pub A, pub B);
+
+pub type RegionOutlivesPredicate = OutlivesPredicate<Region, Region>;
+pub type TypeOutlivesPredicate = OutlivesPredicate<Ty, Region>;
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct ProjectionPredicate {
+    pub projection_term: AliasTerm,
+    pub term: TermKind,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum ImplPolarity {
+    Positive,
+    Negative,
+    Reservation,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum PredicatePolarity {
+    Positive,
+    Negative,
+}
+
+macro_rules! index_impl {
+    ($name:ident) => {
+        impl crate::IndexedVal for $name {
+            fn to_val(index: usize) -> Self {
+                $name(index)
+            }
+            fn to_index(&self) -> usize {
+                self.0
+            }
+        }
+    };
+}
+
+index_impl!(TyConstId);
+index_impl!(MirConstId);
+index_impl!(Ty);
+index_impl!(Span);
+
+/// The source-order index of a variant in a type.
+///
+/// For example, in the following types,
+/// ```ignore(illustrative)
+/// enum Demo1 {
+///    Variant0 { a: bool, b: i32 },
+///    Variant1 { c: u8, d: u64 },
+/// }
+/// struct Demo2 { e: u8, f: u16, g: u8 }
+/// ```
+/// `a` is in the variant with the `VariantIdx` of `0`,
+/// `c` is in the variant with the `VariantIdx` of `1`, and
+/// `g` is in the variant with the `VariantIdx` of `0`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
+pub struct VariantIdx(usize);
+
+index_impl!(VariantIdx);
+
+crate_def! {
+    /// Hold information about an Opaque definition, particularly useful in `RPITIT`.
+    #[derive(Serialize)]
+    pub OpaqueDef;
+}
+
+crate_def! {
+    #[derive(Serialize)]
+    pub AssocDef;
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub struct AssocItem {
+    pub def_id: AssocDef,
+    pub kind: AssocKind,
+    pub container: AssocItemContainer,
+
+    /// If this is an item in an impl of a trait then this is the `DefId` of
+    /// the associated item on the trait that this implements.
+    pub trait_item_def_id: Option<AssocDef>,
+}
+
+#[derive(Clone, PartialEq, Debug, Eq, Serialize)]
+pub enum AssocTypeData {
+    Normal(Symbol),
+    /// The associated type comes from an RPITIT. It has no name, and the
+    /// `ImplTraitInTraitData` provides additional information about its
+    /// source.
+    Rpitit(ImplTraitInTraitData),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum AssocKind {
+    Const { name: Symbol },
+    Fn { name: Symbol, has_self: bool },
+    Type { data: AssocTypeData },
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub enum AssocItemContainer {
+    Trait,
+    Impl,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
+pub enum ImplTraitInTraitData {
+    Trait { fn_def_id: FnDef, opaque_def_id: OpaqueDef },
+    Impl { fn_def_id: FnDef },
+}
+
+impl AssocItem {
+    pub fn is_impl_trait_in_trait(&self) -> bool {
+        matches!(self.kind, AssocKind::Type { data: AssocTypeData::Rpitit(_) })
+    }
+}
diff --git a/compiler/rustc_public/src/unstable/convert/internal.rs b/compiler/rustc_public/src/unstable/convert/internal.rs
new file mode 100644
index 00000000000..8a6238413b0
--- /dev/null
+++ b/compiler/rustc_public/src/unstable/convert/internal.rs
@@ -0,0 +1,823 @@
+//! Module containing the translation from stable mir constructs to the rustc counterpart.
+//!
+//! This module will only include a few constructs to allow users to invoke internal rustc APIs
+//! due to incomplete stable coverage.
+
+// Prefer importing rustc_public over internal rustc constructs to make this file more readable.
+
+use rustc_middle::ty::{self as rustc_ty, Const as InternalConst, Ty as InternalTy};
+use rustc_public_bridge::Tables;
+
+use crate::abi::Layout;
+use crate::compiler_interface::BridgeTys;
+use crate::mir::alloc::AllocId;
+use crate::mir::mono::{Instance, MonoItem, StaticDef};
+use crate::mir::{BinOp, Mutability, Place, ProjectionElem, RawPtrKind, Safety, UnOp};
+use crate::ty::{
+    Abi, AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind, DynKind,
+    ExistentialPredicate, ExistentialProjection, ExistentialTraitRef, FloatTy, FnSig,
+    GenericArgKind, GenericArgs, IntTy, MirConst, Movability, Pattern, Region, RigidTy, Span,
+    TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx,
+};
+use crate::unstable::{InternalCx, RustcInternal};
+use crate::{CrateItem, CrateNum, DefId, IndexedVal};
+
+impl RustcInternal for CrateItem {
+    type T<'tcx> = rustc_span::def_id::DefId;
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        self.0.internal(tables, tcx)
+    }
+}
+
+impl RustcInternal for CrateNum {
+    type T<'tcx> = rustc_span::def_id::CrateNum;
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        rustc_span::def_id::CrateNum::from_usize(*self)
+    }
+}
+
+impl RustcInternal for DefId {
+    type T<'tcx> = rustc_span::def_id::DefId;
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        tcx.lift(tables.def_ids[*self]).unwrap()
+    }
+}
+
+impl RustcInternal for GenericArgs {
+    type T<'tcx> = rustc_ty::GenericArgsRef<'tcx>;
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        InternalCx::mk_args_from_iter(tcx, self.0.iter().map(|arg| arg.internal(tables, tcx)))
+    }
+}
+
+impl RustcInternal for GenericArgKind {
+    type T<'tcx> = rustc_ty::GenericArg<'tcx>;
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        let arg: rustc_ty::GenericArg<'tcx> = match self {
+            GenericArgKind::Lifetime(reg) => reg.internal(tables, tcx).into(),
+            GenericArgKind::Type(ty) => ty.internal(tables, tcx).into(),
+            GenericArgKind::Const(cnst) => cnst.internal(tables, tcx).into(),
+        };
+        tcx.lift(arg).unwrap()
+    }
+}
+
+impl RustcInternal for Region {
+    type T<'tcx> = rustc_ty::Region<'tcx>;
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        // Cannot recover region. Use erased for now.
+        tcx.lifetimes_re_erased()
+    }
+}
+
+impl RustcInternal for Ty {
+    type T<'tcx> = InternalTy<'tcx>;
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        tcx.lift(tables.types[*self]).unwrap()
+    }
+}
+
+impl RustcInternal for TyConst {
+    type T<'tcx> = InternalConst<'tcx>;
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        tcx.lift(tables.ty_consts[self.id]).unwrap()
+    }
+}
+
+impl RustcInternal for Pattern {
+    type T<'tcx> = rustc_ty::Pattern<'tcx>;
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        tcx.mk_pat(match self {
+            Pattern::Range { start, end, include_end: _ } => rustc_ty::PatternKind::Range {
+                start: start.as_ref().unwrap().internal(tables, tcx),
+                end: end.as_ref().unwrap().internal(tables, tcx),
+            },
+        })
+    }
+}
+
+impl RustcInternal for RigidTy {
+    type T<'tcx> = rustc_ty::TyKind<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            RigidTy::Bool => rustc_ty::TyKind::Bool,
+            RigidTy::Char => rustc_ty::TyKind::Char,
+            RigidTy::Int(int_ty) => rustc_ty::TyKind::Int(int_ty.internal(tables, tcx)),
+            RigidTy::Uint(uint_ty) => rustc_ty::TyKind::Uint(uint_ty.internal(tables, tcx)),
+            RigidTy::Float(float_ty) => rustc_ty::TyKind::Float(float_ty.internal(tables, tcx)),
+            RigidTy::Never => rustc_ty::TyKind::Never,
+            RigidTy::Array(ty, cnst) => {
+                rustc_ty::TyKind::Array(ty.internal(tables, tcx), cnst.internal(tables, tcx))
+            }
+            RigidTy::Pat(ty, pat) => {
+                rustc_ty::TyKind::Pat(ty.internal(tables, tcx), pat.internal(tables, tcx))
+            }
+            RigidTy::Adt(def, args) => {
+                rustc_ty::TyKind::Adt(def.internal(tables, tcx), args.internal(tables, tcx))
+            }
+            RigidTy::Str => rustc_ty::TyKind::Str,
+            RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables, tcx)),
+            RigidTy::RawPtr(ty, mutability) => {
+                rustc_ty::TyKind::RawPtr(ty.internal(tables, tcx), mutability.internal(tables, tcx))
+            }
+            RigidTy::Ref(region, ty, mutability) => rustc_ty::TyKind::Ref(
+                region.internal(tables, tcx),
+                ty.internal(tables, tcx),
+                mutability.internal(tables, tcx),
+            ),
+            RigidTy::Foreign(def) => rustc_ty::TyKind::Foreign(def.0.internal(tables, tcx)),
+            RigidTy::FnDef(def, args) => {
+                rustc_ty::TyKind::FnDef(def.0.internal(tables, tcx), args.internal(tables, tcx))
+            }
+            RigidTy::FnPtr(sig) => {
+                let (sig_tys, hdr) = sig.internal(tables, tcx).split();
+                rustc_ty::TyKind::FnPtr(sig_tys, hdr)
+            }
+            RigidTy::Closure(def, args) => {
+                rustc_ty::TyKind::Closure(def.0.internal(tables, tcx), args.internal(tables, tcx))
+            }
+            RigidTy::Coroutine(def, args, _mov) => {
+                rustc_ty::TyKind::Coroutine(def.0.internal(tables, tcx), args.internal(tables, tcx))
+            }
+            RigidTy::CoroutineClosure(def, args) => rustc_ty::TyKind::CoroutineClosure(
+                def.0.internal(tables, tcx),
+                args.internal(tables, tcx),
+            ),
+            RigidTy::CoroutineWitness(def, args) => rustc_ty::TyKind::CoroutineWitness(
+                def.0.internal(tables, tcx),
+                args.internal(tables, tcx),
+            ),
+            RigidTy::Dynamic(predicate, region, dyn_kind) => rustc_ty::TyKind::Dynamic(
+                tcx.mk_poly_existential_predicates(&predicate.internal(tables, tcx)),
+                region.internal(tables, tcx),
+                dyn_kind.internal(tables, tcx),
+            ),
+            RigidTy::Tuple(tys) => {
+                rustc_ty::TyKind::Tuple(tcx.mk_type_list(&tys.internal(tables, tcx)))
+            }
+        }
+    }
+}
+
+impl RustcInternal for IntTy {
+    type T<'tcx> = rustc_ty::IntTy;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            IntTy::Isize => rustc_ty::IntTy::Isize,
+            IntTy::I8 => rustc_ty::IntTy::I8,
+            IntTy::I16 => rustc_ty::IntTy::I16,
+            IntTy::I32 => rustc_ty::IntTy::I32,
+            IntTy::I64 => rustc_ty::IntTy::I64,
+            IntTy::I128 => rustc_ty::IntTy::I128,
+        }
+    }
+}
+
+impl RustcInternal for UintTy {
+    type T<'tcx> = rustc_ty::UintTy;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            UintTy::Usize => rustc_ty::UintTy::Usize,
+            UintTy::U8 => rustc_ty::UintTy::U8,
+            UintTy::U16 => rustc_ty::UintTy::U16,
+            UintTy::U32 => rustc_ty::UintTy::U32,
+            UintTy::U64 => rustc_ty::UintTy::U64,
+            UintTy::U128 => rustc_ty::UintTy::U128,
+        }
+    }
+}
+
+impl RustcInternal for FloatTy {
+    type T<'tcx> = rustc_ty::FloatTy;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            FloatTy::F16 => rustc_ty::FloatTy::F16,
+            FloatTy::F32 => rustc_ty::FloatTy::F32,
+            FloatTy::F64 => rustc_ty::FloatTy::F64,
+            FloatTy::F128 => rustc_ty::FloatTy::F128,
+        }
+    }
+}
+
+impl RustcInternal for Mutability {
+    type T<'tcx> = rustc_ty::Mutability;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            Mutability::Not => rustc_ty::Mutability::Not,
+            Mutability::Mut => rustc_ty::Mutability::Mut,
+        }
+    }
+}
+
+impl RustcInternal for Movability {
+    type T<'tcx> = rustc_ty::Movability;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            Movability::Static => rustc_ty::Movability::Static,
+            Movability::Movable => rustc_ty::Movability::Movable,
+        }
+    }
+}
+
+impl RustcInternal for RawPtrKind {
+    type T<'tcx> = rustc_middle::mir::RawPtrKind;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            RawPtrKind::Mut => rustc_middle::mir::RawPtrKind::Mut,
+            RawPtrKind::Const => rustc_middle::mir::RawPtrKind::Const,
+            RawPtrKind::FakeForPtrMetadata => rustc_middle::mir::RawPtrKind::FakeForPtrMetadata,
+        }
+    }
+}
+
+impl RustcInternal for FnSig {
+    type T<'tcx> = rustc_ty::FnSig<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        tcx.lift(rustc_ty::FnSig {
+            inputs_and_output: tcx.mk_type_list(&self.inputs_and_output.internal(tables, tcx)),
+            c_variadic: self.c_variadic,
+            safety: self.safety.internal(tables, tcx),
+            abi: self.abi.internal(tables, tcx),
+        })
+        .unwrap()
+    }
+}
+
+impl RustcInternal for VariantIdx {
+    type T<'tcx> = rustc_abi::VariantIdx;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        rustc_abi::VariantIdx::from(self.to_index())
+    }
+}
+
+impl RustcInternal for VariantDef {
+    type T<'tcx> = &'tcx rustc_ty::VariantDef;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        self.adt_def.internal(tables, tcx).variant(self.idx.internal(tables, tcx))
+    }
+}
+
+impl RustcInternal for MirConst {
+    type T<'tcx> = rustc_middle::mir::Const<'tcx>;
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        let constant = tables.mir_consts[self.id];
+        match constant {
+            rustc_middle::mir::Const::Ty(ty, ct) => {
+                rustc_middle::mir::Const::Ty(tcx.lift(ty).unwrap(), tcx.lift(ct).unwrap())
+            }
+            rustc_middle::mir::Const::Unevaluated(uneval, ty) => {
+                rustc_middle::mir::Const::Unevaluated(
+                    tcx.lift(uneval).unwrap(),
+                    tcx.lift(ty).unwrap(),
+                )
+            }
+            rustc_middle::mir::Const::Val(const_val, ty) => {
+                rustc_middle::mir::Const::Val(tcx.lift(const_val).unwrap(), tcx.lift(ty).unwrap())
+            }
+        }
+    }
+}
+
+impl RustcInternal for MonoItem {
+    type T<'tcx> = rustc_middle::mir::mono::MonoItem<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        use rustc_middle::mir::mono as rustc_mono;
+        match self {
+            MonoItem::Fn(instance) => rustc_mono::MonoItem::Fn(instance.internal(tables, tcx)),
+            MonoItem::Static(def) => rustc_mono::MonoItem::Static(def.internal(tables, tcx)),
+            MonoItem::GlobalAsm(_) => {
+                unimplemented!()
+            }
+        }
+    }
+}
+
+impl RustcInternal for Instance {
+    type T<'tcx> = rustc_ty::Instance<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        tcx.lift(tables.instances[self.def]).unwrap()
+    }
+}
+
+impl RustcInternal for StaticDef {
+    type T<'tcx> = rustc_span::def_id::DefId;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        self.0.internal(tables, tcx)
+    }
+}
+
+#[allow(rustc::usage_of_qualified_ty)]
+impl<T> RustcInternal for Binder<T>
+where
+    T: RustcInternal,
+    for<'tcx> T::T<'tcx>: rustc_ty::TypeVisitable<rustc_ty::TyCtxt<'tcx>>,
+{
+    type T<'tcx> = rustc_ty::Binder<'tcx, T::T<'tcx>>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        rustc_ty::Binder::bind_with_vars(
+            self.value.internal(tables, tcx),
+            tcx.mk_bound_variable_kinds_from_iter(
+                self.bound_vars.iter().map(|bound| bound.internal(tables, tcx)),
+            ),
+        )
+    }
+}
+
+impl RustcInternal for BoundVariableKind {
+    type T<'tcx> = rustc_ty::BoundVariableKind;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            BoundVariableKind::Ty(kind) => rustc_ty::BoundVariableKind::Ty(match kind {
+                BoundTyKind::Anon => rustc_ty::BoundTyKind::Anon,
+                BoundTyKind::Param(def, _symbol) => {
+                    rustc_ty::BoundTyKind::Param(def.0.internal(tables, tcx))
+                }
+            }),
+            BoundVariableKind::Region(kind) => rustc_ty::BoundVariableKind::Region(match kind {
+                BoundRegionKind::BrAnon => rustc_ty::BoundRegionKind::Anon,
+                BoundRegionKind::BrNamed(def, _symbol) => {
+                    rustc_ty::BoundRegionKind::Named(def.0.internal(tables, tcx))
+                }
+                BoundRegionKind::BrEnv => rustc_ty::BoundRegionKind::ClosureEnv,
+            }),
+            BoundVariableKind::Const => rustc_ty::BoundVariableKind::Const,
+        }
+    }
+}
+
+impl RustcInternal for DynKind {
+    type T<'tcx> = rustc_ty::DynKind;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            DynKind::Dyn => rustc_ty::DynKind::Dyn,
+        }
+    }
+}
+
+impl RustcInternal for ExistentialPredicate {
+    type T<'tcx> = rustc_ty::ExistentialPredicate<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            ExistentialPredicate::Trait(trait_ref) => {
+                rustc_ty::ExistentialPredicate::Trait(trait_ref.internal(tables, tcx))
+            }
+            ExistentialPredicate::Projection(proj) => {
+                rustc_ty::ExistentialPredicate::Projection(proj.internal(tables, tcx))
+            }
+            ExistentialPredicate::AutoTrait(trait_def) => {
+                rustc_ty::ExistentialPredicate::AutoTrait(trait_def.0.internal(tables, tcx))
+            }
+        }
+    }
+}
+
+impl RustcInternal for ExistentialProjection {
+    type T<'tcx> = rustc_ty::ExistentialProjection<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        use crate::unstable::internal_cx::SmirExistentialProjection;
+        tcx.new_from_args(
+            self.def_id.0.internal(tables, tcx),
+            self.generic_args.internal(tables, tcx),
+            self.term.internal(tables, tcx),
+        )
+    }
+}
+
+impl RustcInternal for TermKind {
+    type T<'tcx> = rustc_ty::Term<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            TermKind::Type(ty) => ty.internal(tables, tcx).into(),
+            TermKind::Const(cnst) => cnst.internal(tables, tcx).into(),
+        }
+    }
+}
+
+impl RustcInternal for ExistentialTraitRef {
+    type T<'tcx> = rustc_ty::ExistentialTraitRef<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        use crate::unstable::internal_cx::SmirExistentialTraitRef;
+        tcx.new_from_args(
+            self.def_id.0.internal(tables, tcx),
+            self.generic_args.internal(tables, tcx),
+        )
+    }
+}
+
+impl RustcInternal for TraitRef {
+    type T<'tcx> = rustc_ty::TraitRef<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        use crate::unstable::internal_cx::SmirTraitRef;
+        tcx.new_from_args(self.def_id.0.internal(tables, tcx), self.args().internal(tables, tcx))
+    }
+}
+
+impl RustcInternal for AllocId {
+    type T<'tcx> = rustc_middle::mir::interpret::AllocId;
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        tcx.lift(tables.alloc_ids[*self]).unwrap()
+    }
+}
+
+impl RustcInternal for ClosureKind {
+    type T<'tcx> = rustc_ty::ClosureKind;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            ClosureKind::Fn => rustc_ty::ClosureKind::Fn,
+            ClosureKind::FnMut => rustc_ty::ClosureKind::FnMut,
+            ClosureKind::FnOnce => rustc_ty::ClosureKind::FnOnce,
+        }
+    }
+}
+
+impl RustcInternal for AdtDef {
+    type T<'tcx> = rustc_ty::AdtDef<'tcx>;
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        InternalCx::adt_def(tcx, self.0.internal(tables, tcx))
+    }
+}
+
+impl RustcInternal for Abi {
+    type T<'tcx> = rustc_abi::ExternAbi;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match *self {
+            Abi::Rust => rustc_abi::ExternAbi::Rust,
+            Abi::C { unwind } => rustc_abi::ExternAbi::C { unwind },
+            Abi::Cdecl { unwind } => rustc_abi::ExternAbi::Cdecl { unwind },
+            Abi::Stdcall { unwind } => rustc_abi::ExternAbi::Stdcall { unwind },
+            Abi::Fastcall { unwind } => rustc_abi::ExternAbi::Fastcall { unwind },
+            Abi::Vectorcall { unwind } => rustc_abi::ExternAbi::Vectorcall { unwind },
+            Abi::Thiscall { unwind } => rustc_abi::ExternAbi::Thiscall { unwind },
+            Abi::Aapcs { unwind } => rustc_abi::ExternAbi::Aapcs { unwind },
+            Abi::CCmseNonSecureCall => rustc_abi::ExternAbi::CmseNonSecureCall,
+            Abi::CCmseNonSecureEntry => rustc_abi::ExternAbi::CmseNonSecureEntry,
+            Abi::Win64 { unwind } => rustc_abi::ExternAbi::Win64 { unwind },
+            Abi::SysV64 { unwind } => rustc_abi::ExternAbi::SysV64 { unwind },
+            Abi::PtxKernel => rustc_abi::ExternAbi::PtxKernel,
+            Abi::Msp430Interrupt => rustc_abi::ExternAbi::Msp430Interrupt,
+            Abi::X86Interrupt => rustc_abi::ExternAbi::X86Interrupt,
+            Abi::GpuKernel => rustc_abi::ExternAbi::GpuKernel,
+            Abi::EfiApi => rustc_abi::ExternAbi::EfiApi,
+            Abi::AvrInterrupt => rustc_abi::ExternAbi::AvrInterrupt,
+            Abi::AvrNonBlockingInterrupt => rustc_abi::ExternAbi::AvrNonBlockingInterrupt,
+            Abi::System { unwind } => rustc_abi::ExternAbi::System { unwind },
+            Abi::RustCall => rustc_abi::ExternAbi::RustCall,
+            Abi::Unadjusted => rustc_abi::ExternAbi::Unadjusted,
+            Abi::RustCold => rustc_abi::ExternAbi::RustCold,
+            Abi::RustInvalid => rustc_abi::ExternAbi::RustInvalid,
+            Abi::RiscvInterruptM => rustc_abi::ExternAbi::RiscvInterruptM,
+            Abi::RiscvInterruptS => rustc_abi::ExternAbi::RiscvInterruptS,
+            Abi::Custom => rustc_abi::ExternAbi::Custom,
+        }
+    }
+}
+
+impl RustcInternal for Safety {
+    type T<'tcx> = rustc_hir::Safety;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            Safety::Unsafe => rustc_hir::Safety::Unsafe,
+            Safety::Safe => rustc_hir::Safety::Safe,
+        }
+    }
+}
+impl RustcInternal for Span {
+    type T<'tcx> = rustc_span::Span;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        tables.spans[*self]
+    }
+}
+
+impl RustcInternal for Layout {
+    type T<'tcx> = rustc_abi::Layout<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        tcx.lift(tables.layouts[*self]).unwrap()
+    }
+}
+
+impl RustcInternal for Place {
+    type T<'tcx> = rustc_middle::mir::Place<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        rustc_middle::mir::Place {
+            local: rustc_middle::mir::Local::from_usize(self.local),
+            projection: tcx.mk_place_elems(&self.projection.internal(tables, tcx)),
+        }
+    }
+}
+
+impl RustcInternal for ProjectionElem {
+    type T<'tcx> = rustc_middle::mir::PlaceElem<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            ProjectionElem::Deref => rustc_middle::mir::PlaceElem::Deref,
+            ProjectionElem::Field(idx, ty) => {
+                rustc_middle::mir::PlaceElem::Field((*idx).into(), ty.internal(tables, tcx))
+            }
+            ProjectionElem::Index(idx) => rustc_middle::mir::PlaceElem::Index((*idx).into()),
+            ProjectionElem::ConstantIndex { offset, min_length, from_end } => {
+                rustc_middle::mir::PlaceElem::ConstantIndex {
+                    offset: *offset,
+                    min_length: *min_length,
+                    from_end: *from_end,
+                }
+            }
+            ProjectionElem::Subslice { from, to, from_end } => {
+                rustc_middle::mir::PlaceElem::Subslice { from: *from, to: *to, from_end: *from_end }
+            }
+            ProjectionElem::Downcast(idx) => {
+                rustc_middle::mir::PlaceElem::Downcast(None, idx.internal(tables, tcx))
+            }
+            ProjectionElem::OpaqueCast(ty) => {
+                rustc_middle::mir::PlaceElem::OpaqueCast(ty.internal(tables, tcx))
+            }
+            ProjectionElem::Subtype(ty) => {
+                rustc_middle::mir::PlaceElem::Subtype(ty.internal(tables, tcx))
+            }
+        }
+    }
+}
+
+impl RustcInternal for BinOp {
+    type T<'tcx> = rustc_middle::mir::BinOp;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            BinOp::Add => rustc_middle::mir::BinOp::Add,
+            BinOp::AddUnchecked => rustc_middle::mir::BinOp::AddUnchecked,
+            BinOp::Sub => rustc_middle::mir::BinOp::Sub,
+            BinOp::SubUnchecked => rustc_middle::mir::BinOp::SubUnchecked,
+            BinOp::Mul => rustc_middle::mir::BinOp::Mul,
+            BinOp::MulUnchecked => rustc_middle::mir::BinOp::MulUnchecked,
+            BinOp::Div => rustc_middle::mir::BinOp::Div,
+            BinOp::Rem => rustc_middle::mir::BinOp::Rem,
+            BinOp::BitXor => rustc_middle::mir::BinOp::BitXor,
+            BinOp::BitAnd => rustc_middle::mir::BinOp::BitAnd,
+            BinOp::BitOr => rustc_middle::mir::BinOp::BitOr,
+            BinOp::Shl => rustc_middle::mir::BinOp::Shl,
+            BinOp::ShlUnchecked => rustc_middle::mir::BinOp::ShlUnchecked,
+            BinOp::Shr => rustc_middle::mir::BinOp::Shr,
+            BinOp::ShrUnchecked => rustc_middle::mir::BinOp::ShrUnchecked,
+            BinOp::Eq => rustc_middle::mir::BinOp::Eq,
+            BinOp::Lt => rustc_middle::mir::BinOp::Lt,
+            BinOp::Le => rustc_middle::mir::BinOp::Le,
+            BinOp::Ne => rustc_middle::mir::BinOp::Ne,
+            BinOp::Ge => rustc_middle::mir::BinOp::Ge,
+            BinOp::Gt => rustc_middle::mir::BinOp::Gt,
+            BinOp::Cmp => rustc_middle::mir::BinOp::Cmp,
+            BinOp::Offset => rustc_middle::mir::BinOp::Offset,
+        }
+    }
+}
+
+impl RustcInternal for UnOp {
+    type T<'tcx> = rustc_middle::mir::UnOp;
+
+    fn internal<'tcx>(
+        &self,
+        _tables: &mut Tables<'_, BridgeTys>,
+        _tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        match self {
+            UnOp::Not => rustc_middle::mir::UnOp::Not,
+            UnOp::Neg => rustc_middle::mir::UnOp::Neg,
+            UnOp::PtrMetadata => rustc_middle::mir::UnOp::PtrMetadata,
+        }
+    }
+}
+
+impl<T> RustcInternal for &T
+where
+    T: RustcInternal,
+{
+    type T<'tcx> = T::T<'tcx>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        (*self).internal(tables, tcx)
+    }
+}
+
+impl<T> RustcInternal for Option<T>
+where
+    T: RustcInternal,
+{
+    type T<'tcx> = Option<T::T<'tcx>>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        self.as_ref().map(|inner| inner.internal(tables, tcx))
+    }
+}
+
+impl<T> RustcInternal for Vec<T>
+where
+    T: RustcInternal,
+{
+    type T<'tcx> = Vec<T::T<'tcx>>;
+
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx> {
+        self.iter().map(|e| e.internal(tables, tcx)).collect()
+    }
+}
diff --git a/compiler/rustc_public/src/unstable/convert/mod.rs b/compiler/rustc_public/src/unstable/convert/mod.rs
new file mode 100644
index 00000000000..85a71e09c3e
--- /dev/null
+++ b/compiler/rustc_public/src/unstable/convert/mod.rs
@@ -0,0 +1,110 @@
+//! This module holds the logic to convert rustc internal ADTs into stable mir ADTs.
+//!
+//! The conversion from stable to internal is not meant to be complete,
+//! and it should be added as when needed to be passed as input to rustc_public_bridge functions.
+//!
+//! For contributors, please make sure to avoid calling rustc's internal functions and queries.
+//! These should be done via `rustc_public_bridge` APIs, but it's possible to access ADT fields directly.
+
+use std::ops::RangeInclusive;
+
+use rustc_public_bridge::Tables;
+use rustc_public_bridge::context::SmirCtxt;
+
+use super::Stable;
+use crate::compiler_interface::BridgeTys;
+
+mod internal;
+mod stable;
+
+impl<'tcx, T> Stable<'tcx> for &T
+where
+    T: Stable<'tcx>,
+{
+    type T = T::T;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        (*self).stable(tables, cx)
+    }
+}
+
+impl<'tcx, T> Stable<'tcx> for Option<T>
+where
+    T: Stable<'tcx>,
+{
+    type T = Option<T::T>;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        self.as_ref().map(|value| value.stable(tables, cx))
+    }
+}
+
+impl<'tcx, T, E> Stable<'tcx> for Result<T, E>
+where
+    T: Stable<'tcx>,
+    E: Stable<'tcx>,
+{
+    type T = Result<T::T, E::T>;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            Ok(val) => Ok(val.stable(tables, cx)),
+            Err(error) => Err(error.stable(tables, cx)),
+        }
+    }
+}
+
+impl<'tcx, T> Stable<'tcx> for &[T]
+where
+    T: Stable<'tcx>,
+{
+    type T = Vec<T::T>;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        self.iter().map(|e| e.stable(tables, cx)).collect()
+    }
+}
+
+impl<'tcx, T, U> Stable<'tcx> for (T, U)
+where
+    T: Stable<'tcx>,
+    U: Stable<'tcx>,
+{
+    type T = (T::T, U::T);
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        (self.0.stable(tables, cx), self.1.stable(tables, cx))
+    }
+}
+
+impl<'tcx, T> Stable<'tcx> for RangeInclusive<T>
+where
+    T: Stable<'tcx>,
+{
+    type T = RangeInclusive<T::T>;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        RangeInclusive::new(self.start().stable(tables, cx), self.end().stable(tables, cx))
+    }
+}
diff --git a/compiler/rustc_public/src/unstable/convert/stable/abi.rs b/compiler/rustc_public/src/unstable/convert/stable/abi.rs
new file mode 100644
index 00000000000..40a8bf614e1
--- /dev/null
+++ b/compiler/rustc_public/src/unstable/convert/stable/abi.rs
@@ -0,0 +1,410 @@
+//! Conversion of internal Rust compiler `rustc_target` and `rustc_abi` items to stable ones.
+
+#![allow(rustc::usage_of_qualified_ty)]
+
+use rustc_abi::{ArmCall, CanonAbi, InterruptKind, X86Call};
+use rustc_middle::ty;
+use rustc_public_bridge::Tables;
+use rustc_public_bridge::context::SmirCtxt;
+use rustc_target::callconv;
+
+use crate::abi::{
+    AddressSpace, ArgAbi, CallConvention, FieldsShape, FloatLength, FnAbi, IntegerLength,
+    IntegerType, Layout, LayoutShape, PassMode, Primitive, ReprFlags, ReprOptions, Scalar,
+    TagEncoding, TyAndLayout, ValueAbi, VariantsShape, WrappingRange,
+};
+use crate::compiler_interface::BridgeTys;
+use crate::target::MachineSize as Size;
+use crate::ty::{Align, VariantIdx};
+use crate::unstable::Stable;
+use crate::{IndexedVal, opaque};
+
+impl<'tcx> Stable<'tcx> for rustc_abi::VariantIdx {
+    type T = VariantIdx;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        VariantIdx::to_val(self.as_usize())
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::Endian {
+    type T = crate::target::Endian;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            rustc_abi::Endian::Little => crate::target::Endian::Little,
+            rustc_abi::Endian::Big => crate::target::Endian::Big,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::TyAndLayout<'tcx, ty::Ty<'tcx>> {
+    type T = TyAndLayout;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        TyAndLayout { ty: self.ty.stable(tables, cx), layout: self.layout.stable(tables, cx) }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::Layout<'tcx> {
+    type T = Layout;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        tables.layout_id(cx.lift(*self).unwrap())
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::LayoutData<rustc_abi::FieldIdx, rustc_abi::VariantIdx> {
+    type T = LayoutShape;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        LayoutShape {
+            fields: self.fields.stable(tables, cx),
+            variants: self.variants.stable(tables, cx),
+            abi: self.backend_repr.stable(tables, cx),
+            abi_align: self.align.abi.stable(tables, cx),
+            size: self.size.stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for callconv::FnAbi<'tcx, ty::Ty<'tcx>> {
+    type T = FnAbi;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        assert!(self.args.len() >= self.fixed_count as usize);
+        assert!(!self.c_variadic || matches!(self.conv, CanonAbi::C));
+        FnAbi {
+            args: self.args.as_ref().stable(tables, cx),
+            ret: self.ret.stable(tables, cx),
+            fixed_count: self.fixed_count,
+            conv: self.conv.stable(tables, cx),
+            c_variadic: self.c_variadic,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for callconv::ArgAbi<'tcx, ty::Ty<'tcx>> {
+    type T = ArgAbi;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        ArgAbi {
+            ty: self.layout.ty.stable(tables, cx),
+            layout: self.layout.layout.stable(tables, cx),
+            mode: self.mode.stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for CanonAbi {
+    type T = CallConvention;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            CanonAbi::C => CallConvention::C,
+            CanonAbi::Rust => CallConvention::Rust,
+            CanonAbi::RustCold => CallConvention::Cold,
+            CanonAbi::Custom => CallConvention::Custom,
+            CanonAbi::Arm(arm_call) => match arm_call {
+                ArmCall::Aapcs => CallConvention::ArmAapcs,
+                ArmCall::CCmseNonSecureCall => CallConvention::CCmseNonSecureCall,
+                ArmCall::CCmseNonSecureEntry => CallConvention::CCmseNonSecureEntry,
+            },
+            CanonAbi::GpuKernel => CallConvention::GpuKernel,
+            CanonAbi::Interrupt(interrupt_kind) => match interrupt_kind {
+                InterruptKind::Avr => CallConvention::AvrInterrupt,
+                InterruptKind::AvrNonBlocking => CallConvention::AvrNonBlockingInterrupt,
+                InterruptKind::Msp430 => CallConvention::Msp430Intr,
+                InterruptKind::RiscvMachine | InterruptKind::RiscvSupervisor => {
+                    CallConvention::RiscvInterrupt
+                }
+                InterruptKind::X86 => CallConvention::X86Intr,
+            },
+            CanonAbi::X86(x86_call) => match x86_call {
+                X86Call::Fastcall => CallConvention::X86Fastcall,
+                X86Call::Stdcall => CallConvention::X86Stdcall,
+                X86Call::SysV64 => CallConvention::X86_64SysV,
+                X86Call::Thiscall => CallConvention::X86ThisCall,
+                X86Call::Vectorcall => CallConvention::X86VectorCall,
+                X86Call::Win64 => CallConvention::X86_64Win64,
+            },
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for callconv::PassMode {
+    type T = PassMode;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            callconv::PassMode::Ignore => PassMode::Ignore,
+            callconv::PassMode::Direct(attr) => PassMode::Direct(opaque(attr)),
+            callconv::PassMode::Pair(first, second) => {
+                PassMode::Pair(opaque(first), opaque(second))
+            }
+            callconv::PassMode::Cast { pad_i32, cast } => {
+                PassMode::Cast { pad_i32: *pad_i32, cast: opaque(cast) }
+            }
+            callconv::PassMode::Indirect { attrs, meta_attrs, on_stack } => PassMode::Indirect {
+                attrs: opaque(attrs),
+                meta_attrs: opaque(meta_attrs),
+                on_stack: *on_stack,
+            },
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape<rustc_abi::FieldIdx> {
+    type T = FieldsShape;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            rustc_abi::FieldsShape::Primitive => FieldsShape::Primitive,
+            rustc_abi::FieldsShape::Union(count) => FieldsShape::Union(*count),
+            rustc_abi::FieldsShape::Array { stride, count } => {
+                FieldsShape::Array { stride: stride.stable(tables, cx), count: *count }
+            }
+            rustc_abi::FieldsShape::Arbitrary { offsets, .. } => {
+                FieldsShape::Arbitrary { offsets: offsets.iter().as_slice().stable(tables, cx) }
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::Variants<rustc_abi::FieldIdx, rustc_abi::VariantIdx> {
+    type T = VariantsShape;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            rustc_abi::Variants::Single { index } => {
+                VariantsShape::Single { index: index.stable(tables, cx) }
+            }
+            rustc_abi::Variants::Empty => VariantsShape::Empty,
+            rustc_abi::Variants::Multiple { tag, tag_encoding, tag_field, variants } => {
+                VariantsShape::Multiple {
+                    tag: tag.stable(tables, cx),
+                    tag_encoding: tag_encoding.stable(tables, cx),
+                    tag_field: tag_field.stable(tables, cx),
+                    variants: variants.iter().as_slice().stable(tables, cx),
+                }
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::TagEncoding<rustc_abi::VariantIdx> {
+    type T = TagEncoding;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            rustc_abi::TagEncoding::Direct => TagEncoding::Direct,
+            rustc_abi::TagEncoding::Niche { untagged_variant, niche_variants, niche_start } => {
+                TagEncoding::Niche {
+                    untagged_variant: untagged_variant.stable(tables, cx),
+                    niche_variants: niche_variants.stable(tables, cx),
+                    niche_start: *niche_start,
+                }
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::BackendRepr {
+    type T = ValueAbi;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match *self {
+            rustc_abi::BackendRepr::Scalar(scalar) => ValueAbi::Scalar(scalar.stable(tables, cx)),
+            rustc_abi::BackendRepr::ScalarPair(first, second) => {
+                ValueAbi::ScalarPair(first.stable(tables, cx), second.stable(tables, cx))
+            }
+            rustc_abi::BackendRepr::SimdVector { element, count } => {
+                ValueAbi::Vector { element: element.stable(tables, cx), count }
+            }
+            rustc_abi::BackendRepr::Memory { sized } => ValueAbi::Aggregate { sized },
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::Size {
+    type T = Size;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        Size::from_bits(self.bits_usize())
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::Align {
+    type T = Align;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        self.bytes()
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::Scalar {
+    type T = Scalar;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            rustc_abi::Scalar::Initialized { value, valid_range } => Scalar::Initialized {
+                value: value.stable(tables, cx),
+                valid_range: valid_range.stable(tables, cx),
+            },
+            rustc_abi::Scalar::Union { value } => Scalar::Union { value: value.stable(tables, cx) },
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::Primitive {
+    type T = Primitive;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            rustc_abi::Primitive::Int(length, signed) => {
+                Primitive::Int { length: length.stable(tables, cx), signed: *signed }
+            }
+            rustc_abi::Primitive::Float(length) => {
+                Primitive::Float { length: length.stable(tables, cx) }
+            }
+            rustc_abi::Primitive::Pointer(space) => Primitive::Pointer(space.stable(tables, cx)),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::AddressSpace {
+    type T = AddressSpace;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        AddressSpace(self.0)
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::Integer {
+    type T = IntegerLength;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            rustc_abi::Integer::I8 => IntegerLength::I8,
+            rustc_abi::Integer::I16 => IntegerLength::I16,
+            rustc_abi::Integer::I32 => IntegerLength::I32,
+            rustc_abi::Integer::I64 => IntegerLength::I64,
+            rustc_abi::Integer::I128 => IntegerLength::I128,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::Float {
+    type T = FloatLength;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            rustc_abi::Float::F16 => FloatLength::F16,
+            rustc_abi::Float::F32 => FloatLength::F32,
+            rustc_abi::Float::F64 => FloatLength::F64,
+            rustc_abi::Float::F128 => FloatLength::F128,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::WrappingRange {
+    type T = WrappingRange;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        WrappingRange { start: self.start, end: self.end }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::ReprFlags {
+    type T = ReprFlags;
+
+    fn stable<'cx>(
+        &self,
+        _tables: &mut Tables<'cx, BridgeTys>,
+        _cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        ReprFlags {
+            is_simd: self.intersects(Self::IS_SIMD),
+            is_c: self.intersects(Self::IS_C),
+            is_transparent: self.intersects(Self::IS_TRANSPARENT),
+            is_linear: self.intersects(Self::IS_LINEAR),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::IntegerType {
+    type T = IntegerType;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            rustc_abi::IntegerType::Pointer(signed) => IntegerType::Pointer { is_signed: *signed },
+            rustc_abi::IntegerType::Fixed(integer, signed) => {
+                IntegerType::Fixed { length: integer.stable(tables, cx), is_signed: *signed }
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::ReprOptions {
+    type T = ReprOptions;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        ReprOptions {
+            int: self.int.map(|int| int.stable(tables, cx)),
+            align: self.align.map(|align| align.stable(tables, cx)),
+            pack: self.pack.map(|pack| pack.stable(tables, cx)),
+            flags: self.flags.stable(tables, cx),
+        }
+    }
+}
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
new file mode 100644
index 00000000000..bd7d4807152
--- /dev/null
+++ b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
@@ -0,0 +1,936 @@
+//! Conversion of internal Rust compiler `mir` items to stable ones.
+
+use rustc_middle::mir::mono::MonoItem;
+use rustc_middle::{bug, mir};
+use rustc_public_bridge::Tables;
+use rustc_public_bridge::bridge::SmirError;
+use rustc_public_bridge::context::SmirCtxt;
+
+use crate::compiler_interface::BridgeTys;
+use crate::mir::alloc::GlobalAlloc;
+use crate::mir::{ConstOperand, Statement, UserTypeProjection, VarDebugInfoFragment};
+use crate::ty::{Allocation, ConstantKind, MirConst};
+use crate::unstable::Stable;
+use crate::{Error, alloc, opaque};
+
+impl<'tcx> Stable<'tcx> for mir::Body<'tcx> {
+    type T = crate::mir::Body;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        crate::mir::Body::new(
+            self.basic_blocks
+                .iter()
+                .map(|block| crate::mir::BasicBlock {
+                    terminator: block.terminator().stable(tables, cx),
+                    statements: block
+                        .statements
+                        .iter()
+                        .map(|statement| statement.stable(tables, cx))
+                        .collect(),
+                })
+                .collect(),
+            self.local_decls
+                .iter()
+                .map(|decl| crate::mir::LocalDecl {
+                    ty: decl.ty.stable(tables, cx),
+                    span: decl.source_info.span.stable(tables, cx),
+                    mutability: decl.mutability.stable(tables, cx),
+                })
+                .collect(),
+            self.arg_count,
+            self.var_debug_info.iter().map(|info| info.stable(tables, cx)).collect(),
+            self.spread_arg.stable(tables, cx),
+            self.span.stable(tables, cx),
+        )
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::VarDebugInfo<'tcx> {
+    type T = crate::mir::VarDebugInfo;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        crate::mir::VarDebugInfo {
+            name: self.name.to_string(),
+            source_info: self.source_info.stable(tables, cx),
+            composite: self.composite.as_ref().map(|composite| composite.stable(tables, cx)),
+            value: self.value.stable(tables, cx),
+            argument_index: self.argument_index,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::Statement<'tcx> {
+    type T = crate::mir::Statement;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        Statement {
+            kind: self.kind.stable(tables, cx),
+            span: self.source_info.span.stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::SourceInfo {
+    type T = crate::mir::SourceInfo;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        crate::mir::SourceInfo { span: self.span.stable(tables, cx), scope: self.scope.into() }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::VarDebugInfoFragment<'tcx> {
+    type T = crate::mir::VarDebugInfoFragment;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        VarDebugInfoFragment {
+            ty: self.ty.stable(tables, cx),
+            projection: self.projection.iter().map(|e| e.stable(tables, cx)).collect(),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::VarDebugInfoContents<'tcx> {
+    type T = crate::mir::VarDebugInfoContents;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            mir::VarDebugInfoContents::Place(place) => {
+                crate::mir::VarDebugInfoContents::Place(place.stable(tables, cx))
+            }
+            mir::VarDebugInfoContents::Const(const_operand) => {
+                let op = ConstOperand {
+                    span: const_operand.span.stable(tables, cx),
+                    user_ty: const_operand.user_ty.map(|index| index.as_usize()),
+                    const_: const_operand.const_.stable(tables, cx),
+                };
+                crate::mir::VarDebugInfoContents::Const(op)
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::StatementKind<'tcx> {
+    type T = crate::mir::StatementKind;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            mir::StatementKind::Assign(assign) => crate::mir::StatementKind::Assign(
+                assign.0.stable(tables, cx),
+                assign.1.stable(tables, cx),
+            ),
+            mir::StatementKind::FakeRead(fake_read_place) => crate::mir::StatementKind::FakeRead(
+                fake_read_place.0.stable(tables, cx),
+                fake_read_place.1.stable(tables, cx),
+            ),
+            mir::StatementKind::SetDiscriminant { place, variant_index } => {
+                crate::mir::StatementKind::SetDiscriminant {
+                    place: place.as_ref().stable(tables, cx),
+                    variant_index: variant_index.stable(tables, cx),
+                }
+            }
+            mir::StatementKind::Deinit(place) => {
+                crate::mir::StatementKind::Deinit(place.stable(tables, cx))
+            }
+
+            mir::StatementKind::StorageLive(place) => {
+                crate::mir::StatementKind::StorageLive(place.stable(tables, cx))
+            }
+
+            mir::StatementKind::StorageDead(place) => {
+                crate::mir::StatementKind::StorageDead(place.stable(tables, cx))
+            }
+            mir::StatementKind::Retag(retag, place) => {
+                crate::mir::StatementKind::Retag(retag.stable(tables, cx), place.stable(tables, cx))
+            }
+            mir::StatementKind::PlaceMention(place) => {
+                crate::mir::StatementKind::PlaceMention(place.stable(tables, cx))
+            }
+            mir::StatementKind::AscribeUserType(place_projection, variance) => {
+                crate::mir::StatementKind::AscribeUserType {
+                    place: place_projection.as_ref().0.stable(tables, cx),
+                    projections: place_projection.as_ref().1.stable(tables, cx),
+                    variance: variance.stable(tables, cx),
+                }
+            }
+            mir::StatementKind::Coverage(coverage) => {
+                crate::mir::StatementKind::Coverage(opaque(coverage))
+            }
+            mir::StatementKind::Intrinsic(intrinstic) => {
+                crate::mir::StatementKind::Intrinsic(intrinstic.stable(tables, cx))
+            }
+            mir::StatementKind::ConstEvalCounter => crate::mir::StatementKind::ConstEvalCounter,
+            // BackwardIncompatibleDropHint has no semantics, so it is translated to Nop.
+            mir::StatementKind::BackwardIncompatibleDropHint { .. } => {
+                crate::mir::StatementKind::Nop
+            }
+            mir::StatementKind::Nop => crate::mir::StatementKind::Nop,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> {
+    type T = crate::mir::Rvalue;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::mir::Rvalue::*;
+        match self {
+            Use(op) => crate::mir::Rvalue::Use(op.stable(tables, cx)),
+            Repeat(op, len) => {
+                let len = len.stable(tables, cx);
+                crate::mir::Rvalue::Repeat(op.stable(tables, cx), len)
+            }
+            Ref(region, kind, place) => crate::mir::Rvalue::Ref(
+                region.stable(tables, cx),
+                kind.stable(tables, cx),
+                place.stable(tables, cx),
+            ),
+            ThreadLocalRef(def_id) => {
+                crate::mir::Rvalue::ThreadLocalRef(tables.crate_item(*def_id))
+            }
+            RawPtr(mutability, place) => crate::mir::Rvalue::AddressOf(
+                mutability.stable(tables, cx),
+                place.stable(tables, cx),
+            ),
+            Len(place) => crate::mir::Rvalue::Len(place.stable(tables, cx)),
+            Cast(cast_kind, op, ty) => crate::mir::Rvalue::Cast(
+                cast_kind.stable(tables, cx),
+                op.stable(tables, cx),
+                ty.stable(tables, cx),
+            ),
+            BinaryOp(bin_op, ops) => {
+                if let Some(bin_op) = bin_op.overflowing_to_wrapping() {
+                    crate::mir::Rvalue::CheckedBinaryOp(
+                        bin_op.stable(tables, cx),
+                        ops.0.stable(tables, cx),
+                        ops.1.stable(tables, cx),
+                    )
+                } else {
+                    crate::mir::Rvalue::BinaryOp(
+                        bin_op.stable(tables, cx),
+                        ops.0.stable(tables, cx),
+                        ops.1.stable(tables, cx),
+                    )
+                }
+            }
+            NullaryOp(null_op, ty) => {
+                crate::mir::Rvalue::NullaryOp(null_op.stable(tables, cx), ty.stable(tables, cx))
+            }
+            UnaryOp(un_op, op) => {
+                crate::mir::Rvalue::UnaryOp(un_op.stable(tables, cx), op.stable(tables, cx))
+            }
+            Discriminant(place) => crate::mir::Rvalue::Discriminant(place.stable(tables, cx)),
+            Aggregate(agg_kind, operands) => {
+                let operands = operands.iter().map(|op| op.stable(tables, cx)).collect();
+                crate::mir::Rvalue::Aggregate(agg_kind.stable(tables, cx), operands)
+            }
+            ShallowInitBox(op, ty) => {
+                crate::mir::Rvalue::ShallowInitBox(op.stable(tables, cx), ty.stable(tables, cx))
+            }
+            CopyForDeref(place) => crate::mir::Rvalue::CopyForDeref(place.stable(tables, cx)),
+            WrapUnsafeBinder(..) => todo!("FIXME(unsafe_binders):"),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::Mutability {
+    type T = crate::mir::Mutability;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_hir::Mutability::*;
+        match *self {
+            Not => crate::mir::Mutability::Not,
+            Mut => crate::mir::Mutability::Mut,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::RawPtrKind {
+    type T = crate::mir::RawPtrKind;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use mir::RawPtrKind::*;
+        match *self {
+            Const => crate::mir::RawPtrKind::Const,
+            Mut => crate::mir::RawPtrKind::Mut,
+            FakeForPtrMetadata => crate::mir::RawPtrKind::FakeForPtrMetadata,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::BorrowKind {
+    type T = crate::mir::BorrowKind;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::mir::BorrowKind::*;
+        match *self {
+            Shared => crate::mir::BorrowKind::Shared,
+            Fake(kind) => crate::mir::BorrowKind::Fake(kind.stable(tables, cx)),
+            Mut { kind } => crate::mir::BorrowKind::Mut { kind: kind.stable(tables, cx) },
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::MutBorrowKind {
+    type T = crate::mir::MutBorrowKind;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_middle::mir::MutBorrowKind::*;
+        match *self {
+            Default => crate::mir::MutBorrowKind::Default,
+            TwoPhaseBorrow => crate::mir::MutBorrowKind::TwoPhaseBorrow,
+            ClosureCapture => crate::mir::MutBorrowKind::ClosureCapture,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::FakeBorrowKind {
+    type T = crate::mir::FakeBorrowKind;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_middle::mir::FakeBorrowKind::*;
+        match *self {
+            Deep => crate::mir::FakeBorrowKind::Deep,
+            Shallow => crate::mir::FakeBorrowKind::Shallow,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::NullOp<'tcx> {
+    type T = crate::mir::NullOp;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::mir::NullOp::*;
+        match self {
+            SizeOf => crate::mir::NullOp::SizeOf,
+            AlignOf => crate::mir::NullOp::AlignOf,
+            OffsetOf(indices) => crate::mir::NullOp::OffsetOf(
+                indices.iter().map(|idx| idx.stable(tables, cx)).collect(),
+            ),
+            UbChecks => crate::mir::NullOp::UbChecks,
+            ContractChecks => crate::mir::NullOp::ContractChecks,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::CastKind {
+    type T = crate::mir::CastKind;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::mir::CastKind::*;
+        match self {
+            PointerExposeProvenance => crate::mir::CastKind::PointerExposeAddress,
+            PointerWithExposedProvenance => crate::mir::CastKind::PointerWithExposedProvenance,
+            PointerCoercion(c, _) => crate::mir::CastKind::PointerCoercion(c.stable(tables, cx)),
+            IntToInt => crate::mir::CastKind::IntToInt,
+            FloatToInt => crate::mir::CastKind::FloatToInt,
+            FloatToFloat => crate::mir::CastKind::FloatToFloat,
+            IntToFloat => crate::mir::CastKind::IntToFloat,
+            PtrToPtr => crate::mir::CastKind::PtrToPtr,
+            FnPtrToPtr => crate::mir::CastKind::FnPtrToPtr,
+            Transmute => crate::mir::CastKind::Transmute,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::FakeReadCause {
+    type T = crate::mir::FakeReadCause;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_middle::mir::FakeReadCause::*;
+        match self {
+            ForMatchGuard => crate::mir::FakeReadCause::ForMatchGuard,
+            ForMatchedPlace(local_def_id) => {
+                crate::mir::FakeReadCause::ForMatchedPlace(opaque(local_def_id))
+            }
+            ForGuardBinding => crate::mir::FakeReadCause::ForGuardBinding,
+            ForLet(local_def_id) => crate::mir::FakeReadCause::ForLet(opaque(local_def_id)),
+            ForIndex => crate::mir::FakeReadCause::ForIndex,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::Operand<'tcx> {
+    type T = crate::mir::Operand;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::mir::Operand::*;
+        match self {
+            Copy(place) => crate::mir::Operand::Copy(place.stable(tables, cx)),
+            Move(place) => crate::mir::Operand::Move(place.stable(tables, cx)),
+            Constant(c) => crate::mir::Operand::Constant(c.stable(tables, cx)),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::ConstOperand<'tcx> {
+    type T = crate::mir::ConstOperand;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        crate::mir::ConstOperand {
+            span: self.span.stable(tables, cx),
+            user_ty: self.user_ty.map(|u| u.as_usize()).or(None),
+            const_: self.const_.stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::Place<'tcx> {
+    type T = crate::mir::Place;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        crate::mir::Place {
+            local: self.local.as_usize(),
+            projection: self.projection.iter().map(|e| e.stable(tables, cx)).collect(),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::PlaceElem<'tcx> {
+    type T = crate::mir::ProjectionElem;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::mir::ProjectionElem::*;
+        match self {
+            Deref => crate::mir::ProjectionElem::Deref,
+            Field(idx, ty) => {
+                crate::mir::ProjectionElem::Field(idx.stable(tables, cx), ty.stable(tables, cx))
+            }
+            Index(local) => crate::mir::ProjectionElem::Index(local.stable(tables, cx)),
+            ConstantIndex { offset, min_length, from_end } => {
+                crate::mir::ProjectionElem::ConstantIndex {
+                    offset: *offset,
+                    min_length: *min_length,
+                    from_end: *from_end,
+                }
+            }
+            Subslice { from, to, from_end } => {
+                crate::mir::ProjectionElem::Subslice { from: *from, to: *to, from_end: *from_end }
+            }
+            // MIR includes an `Option<Symbol>` argument for `Downcast` that is the name of the
+            // variant, used for printing MIR. However this information should also be accessible
+            // via a lookup using the `VariantIdx`. The `Option<Symbol>` argument is therefore
+            // dropped when converting to Stable MIR. A brief justification for this decision can be
+            // found at https://github.com/rust-lang/rust/pull/117517#issuecomment-1811683486
+            Downcast(_, idx) => crate::mir::ProjectionElem::Downcast(idx.stable(tables, cx)),
+            OpaqueCast(ty) => crate::mir::ProjectionElem::OpaqueCast(ty.stable(tables, cx)),
+            Subtype(ty) => crate::mir::ProjectionElem::Subtype(ty.stable(tables, cx)),
+            UnwrapUnsafeBinder(..) => todo!("FIXME(unsafe_binders):"),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::UserTypeProjection {
+    type T = crate::mir::UserTypeProjection;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        UserTypeProjection { base: self.base.as_usize(), projection: opaque(&self.projs) }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::Local {
+    type T = crate::mir::Local;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        self.as_usize()
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::RetagKind {
+    type T = crate::mir::RetagKind;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_middle::mir::RetagKind;
+        match self {
+            RetagKind::FnEntry => crate::mir::RetagKind::FnEntry,
+            RetagKind::TwoPhase => crate::mir::RetagKind::TwoPhase,
+            RetagKind::Raw => crate::mir::RetagKind::Raw,
+            RetagKind::Default => crate::mir::RetagKind::Default,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::UnwindAction {
+    type T = crate::mir::UnwindAction;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_middle::mir::UnwindAction;
+        match self {
+            UnwindAction::Continue => crate::mir::UnwindAction::Continue,
+            UnwindAction::Unreachable => crate::mir::UnwindAction::Unreachable,
+            UnwindAction::Terminate(_) => crate::mir::UnwindAction::Terminate,
+            UnwindAction::Cleanup(bb) => crate::mir::UnwindAction::Cleanup(bb.as_usize()),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::NonDivergingIntrinsic<'tcx> {
+    type T = crate::mir::NonDivergingIntrinsic;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::mir::NonDivergingIntrinsic;
+
+        use crate::mir::CopyNonOverlapping;
+        match self {
+            NonDivergingIntrinsic::Assume(op) => {
+                crate::mir::NonDivergingIntrinsic::Assume(op.stable(tables, cx))
+            }
+            NonDivergingIntrinsic::CopyNonOverlapping(copy_non_overlapping) => {
+                crate::mir::NonDivergingIntrinsic::CopyNonOverlapping(CopyNonOverlapping {
+                    src: copy_non_overlapping.src.stable(tables, cx),
+                    dst: copy_non_overlapping.dst.stable(tables, cx),
+                    count: copy_non_overlapping.count.stable(tables, cx),
+                })
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::AssertMessage<'tcx> {
+    type T = crate::mir::AssertMessage;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::mir::AssertKind;
+        match self {
+            AssertKind::BoundsCheck { len, index } => crate::mir::AssertMessage::BoundsCheck {
+                len: len.stable(tables, cx),
+                index: index.stable(tables, cx),
+            },
+            AssertKind::Overflow(bin_op, op1, op2) => crate::mir::AssertMessage::Overflow(
+                bin_op.stable(tables, cx),
+                op1.stable(tables, cx),
+                op2.stable(tables, cx),
+            ),
+            AssertKind::OverflowNeg(op) => {
+                crate::mir::AssertMessage::OverflowNeg(op.stable(tables, cx))
+            }
+            AssertKind::DivisionByZero(op) => {
+                crate::mir::AssertMessage::DivisionByZero(op.stable(tables, cx))
+            }
+            AssertKind::RemainderByZero(op) => {
+                crate::mir::AssertMessage::RemainderByZero(op.stable(tables, cx))
+            }
+            AssertKind::ResumedAfterReturn(coroutine) => {
+                crate::mir::AssertMessage::ResumedAfterReturn(coroutine.stable(tables, cx))
+            }
+            AssertKind::ResumedAfterPanic(coroutine) => {
+                crate::mir::AssertMessage::ResumedAfterPanic(coroutine.stable(tables, cx))
+            }
+            AssertKind::ResumedAfterDrop(coroutine) => {
+                crate::mir::AssertMessage::ResumedAfterDrop(coroutine.stable(tables, cx))
+            }
+            AssertKind::MisalignedPointerDereference { required, found } => {
+                crate::mir::AssertMessage::MisalignedPointerDereference {
+                    required: required.stable(tables, cx),
+                    found: found.stable(tables, cx),
+                }
+            }
+            AssertKind::NullPointerDereference => crate::mir::AssertMessage::NullPointerDereference,
+            AssertKind::InvalidEnumConstruction(source) => {
+                crate::mir::AssertMessage::InvalidEnumConstruction(source.stable(tables, cx))
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::BinOp {
+    type T = crate::mir::BinOp;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_middle::mir::BinOp;
+        match self {
+            BinOp::Add => crate::mir::BinOp::Add,
+            BinOp::AddUnchecked => crate::mir::BinOp::AddUnchecked,
+            BinOp::AddWithOverflow => bug!("AddWithOverflow should have been translated already"),
+            BinOp::Sub => crate::mir::BinOp::Sub,
+            BinOp::SubUnchecked => crate::mir::BinOp::SubUnchecked,
+            BinOp::SubWithOverflow => bug!("AddWithOverflow should have been translated already"),
+            BinOp::Mul => crate::mir::BinOp::Mul,
+            BinOp::MulUnchecked => crate::mir::BinOp::MulUnchecked,
+            BinOp::MulWithOverflow => bug!("AddWithOverflow should have been translated already"),
+            BinOp::Div => crate::mir::BinOp::Div,
+            BinOp::Rem => crate::mir::BinOp::Rem,
+            BinOp::BitXor => crate::mir::BinOp::BitXor,
+            BinOp::BitAnd => crate::mir::BinOp::BitAnd,
+            BinOp::BitOr => crate::mir::BinOp::BitOr,
+            BinOp::Shl => crate::mir::BinOp::Shl,
+            BinOp::ShlUnchecked => crate::mir::BinOp::ShlUnchecked,
+            BinOp::Shr => crate::mir::BinOp::Shr,
+            BinOp::ShrUnchecked => crate::mir::BinOp::ShrUnchecked,
+            BinOp::Eq => crate::mir::BinOp::Eq,
+            BinOp::Lt => crate::mir::BinOp::Lt,
+            BinOp::Le => crate::mir::BinOp::Le,
+            BinOp::Ne => crate::mir::BinOp::Ne,
+            BinOp::Ge => crate::mir::BinOp::Ge,
+            BinOp::Gt => crate::mir::BinOp::Gt,
+            BinOp::Cmp => crate::mir::BinOp::Cmp,
+            BinOp::Offset => crate::mir::BinOp::Offset,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::UnOp {
+    type T = crate::mir::UnOp;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_middle::mir::UnOp;
+        match self {
+            UnOp::Not => crate::mir::UnOp::Not,
+            UnOp::Neg => crate::mir::UnOp::Neg,
+            UnOp::PtrMetadata => crate::mir::UnOp::PtrMetadata,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::AggregateKind<'tcx> {
+    type T = crate::mir::AggregateKind;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            mir::AggregateKind::Array(ty) => {
+                crate::mir::AggregateKind::Array(ty.stable(tables, cx))
+            }
+            mir::AggregateKind::Tuple => crate::mir::AggregateKind::Tuple,
+            mir::AggregateKind::Adt(def_id, var_idx, generic_arg, user_ty_index, field_idx) => {
+                crate::mir::AggregateKind::Adt(
+                    tables.adt_def(*def_id),
+                    var_idx.stable(tables, cx),
+                    generic_arg.stable(tables, cx),
+                    user_ty_index.map(|idx| idx.index()),
+                    field_idx.map(|idx| idx.index()),
+                )
+            }
+            mir::AggregateKind::Closure(def_id, generic_arg) => crate::mir::AggregateKind::Closure(
+                tables.closure_def(*def_id),
+                generic_arg.stable(tables, cx),
+            ),
+            mir::AggregateKind::Coroutine(def_id, generic_arg) => {
+                crate::mir::AggregateKind::Coroutine(
+                    tables.coroutine_def(*def_id),
+                    generic_arg.stable(tables, cx),
+                    cx.coroutine_movability(*def_id).stable(tables, cx),
+                )
+            }
+            mir::AggregateKind::CoroutineClosure(def_id, generic_args) => {
+                crate::mir::AggregateKind::CoroutineClosure(
+                    tables.coroutine_closure_def(*def_id),
+                    generic_args.stable(tables, cx),
+                )
+            }
+            mir::AggregateKind::RawPtr(ty, mutability) => crate::mir::AggregateKind::RawPtr(
+                ty.stable(tables, cx),
+                mutability.stable(tables, cx),
+            ),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::InlineAsmOperand<'tcx> {
+    type T = crate::mir::InlineAsmOperand;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::mir::InlineAsmOperand;
+
+        let (in_value, out_place) = match self {
+            InlineAsmOperand::In { value, .. } => (Some(value.stable(tables, cx)), None),
+            InlineAsmOperand::Out { place, .. } => {
+                (None, place.map(|place| place.stable(tables, cx)))
+            }
+            InlineAsmOperand::InOut { in_value, out_place, .. } => {
+                (Some(in_value.stable(tables, cx)), out_place.map(|place| place.stable(tables, cx)))
+            }
+            InlineAsmOperand::Const { .. }
+            | InlineAsmOperand::SymFn { .. }
+            | InlineAsmOperand::SymStatic { .. }
+            | InlineAsmOperand::Label { .. } => (None, None),
+        };
+
+        crate::mir::InlineAsmOperand { in_value, out_place, raw_rpr: format!("{self:?}") }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
+    type T = crate::mir::Terminator;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::mir::Terminator;
+        Terminator {
+            kind: self.kind.stable(tables, cx),
+            span: self.source_info.span.stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> {
+    type T = crate::mir::TerminatorKind;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::mir::TerminatorKind;
+        match self {
+            mir::TerminatorKind::Goto { target } => {
+                TerminatorKind::Goto { target: target.as_usize() }
+            }
+            mir::TerminatorKind::SwitchInt { discr, targets } => TerminatorKind::SwitchInt {
+                discr: discr.stable(tables, cx),
+                targets: {
+                    let branches = targets.iter().map(|(val, target)| (val, target.as_usize()));
+                    crate::mir::SwitchTargets::new(
+                        branches.collect(),
+                        targets.otherwise().as_usize(),
+                    )
+                },
+            },
+            mir::TerminatorKind::UnwindResume => TerminatorKind::Resume,
+            mir::TerminatorKind::UnwindTerminate(_) => TerminatorKind::Abort,
+            mir::TerminatorKind::Return => TerminatorKind::Return,
+            mir::TerminatorKind::Unreachable => TerminatorKind::Unreachable,
+            mir::TerminatorKind::Drop {
+                place,
+                target,
+                unwind,
+                replace: _,
+                drop: _,
+                async_fut: _,
+            } => TerminatorKind::Drop {
+                place: place.stable(tables, cx),
+                target: target.as_usize(),
+                unwind: unwind.stable(tables, cx),
+            },
+            mir::TerminatorKind::Call {
+                func,
+                args,
+                destination,
+                target,
+                unwind,
+                call_source: _,
+                fn_span: _,
+            } => TerminatorKind::Call {
+                func: func.stable(tables, cx),
+                args: args.iter().map(|arg| arg.node.stable(tables, cx)).collect(),
+                destination: destination.stable(tables, cx),
+                target: target.map(|t| t.as_usize()),
+                unwind: unwind.stable(tables, cx),
+            },
+            mir::TerminatorKind::TailCall { func: _, args: _, fn_span: _ } => todo!(),
+            mir::TerminatorKind::Assert { cond, expected, msg, target, unwind } => {
+                TerminatorKind::Assert {
+                    cond: cond.stable(tables, cx),
+                    expected: *expected,
+                    msg: msg.stable(tables, cx),
+                    target: target.as_usize(),
+                    unwind: unwind.stable(tables, cx),
+                }
+            }
+            mir::TerminatorKind::InlineAsm {
+                asm_macro: _,
+                template,
+                operands,
+                options,
+                line_spans,
+                targets,
+                unwind,
+            } => TerminatorKind::InlineAsm {
+                template: format!("{template:?}"),
+                operands: operands.iter().map(|operand| operand.stable(tables, cx)).collect(),
+                options: format!("{options:?}"),
+                line_spans: format!("{line_spans:?}"),
+                // FIXME: Figure out how to do labels in SMIR
+                destination: targets.first().map(|d| d.as_usize()),
+                unwind: unwind.stable(tables, cx),
+            },
+            mir::TerminatorKind::Yield { .. }
+            | mir::TerminatorKind::CoroutineDrop
+            | mir::TerminatorKind::FalseEdge { .. }
+            | mir::TerminatorKind::FalseUnwind { .. } => unreachable!(),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::interpret::ConstAllocation<'tcx> {
+    type T = Allocation;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        self.inner().stable(tables, cx)
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::interpret::Allocation {
+    type T = crate::ty::Allocation;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_public_bridge::context::SmirAllocRange;
+        alloc::allocation_filter(
+            self,
+            cx.alloc_range(rustc_abi::Size::ZERO, self.size()),
+            tables,
+            cx,
+        )
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::interpret::AllocId {
+    type T = crate::mir::alloc::AllocId;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        _: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        tables.create_alloc_id(*self)
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::interpret::GlobalAlloc<'tcx> {
+    type T = GlobalAlloc;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            mir::interpret::GlobalAlloc::Function { instance, .. } => {
+                GlobalAlloc::Function(instance.stable(tables, cx))
+            }
+            mir::interpret::GlobalAlloc::VTable(ty, dyn_ty) => {
+                // FIXME: Should we record the whole vtable?
+                GlobalAlloc::VTable(ty.stable(tables, cx), dyn_ty.principal().stable(tables, cx))
+            }
+            mir::interpret::GlobalAlloc::Static(def) => {
+                GlobalAlloc::Static(tables.static_def(*def))
+            }
+            mir::interpret::GlobalAlloc::Memory(alloc) => {
+                GlobalAlloc::Memory(alloc.stable(tables, cx))
+            }
+            mir::interpret::GlobalAlloc::TypeId { ty } => {
+                GlobalAlloc::TypeId { ty: ty.stable(tables, cx) }
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_middle::mir::Const<'tcx> {
+    type T = crate::ty::MirConst;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let id = tables.intern_mir_const(cx.lift(*self).unwrap());
+        match *self {
+            mir::Const::Ty(ty, c) => MirConst::new(
+                crate::ty::ConstantKind::Ty(c.stable(tables, cx)),
+                ty.stable(tables, cx),
+                id,
+            ),
+            mir::Const::Unevaluated(unev_const, ty) => {
+                let kind = crate::ty::ConstantKind::Unevaluated(crate::ty::UnevaluatedConst {
+                    def: tables.const_def(unev_const.def),
+                    args: unev_const.args.stable(tables, cx),
+                    promoted: unev_const.promoted.map(|u| u.as_u32()),
+                });
+                let ty = ty.stable(tables, cx);
+                MirConst::new(kind, ty, id)
+            }
+            mir::Const::Val(mir::ConstValue::ZeroSized, ty) => {
+                let ty = ty.stable(tables, cx);
+                MirConst::new(ConstantKind::ZeroSized, ty, id)
+            }
+            mir::Const::Val(val, ty) => {
+                let ty = cx.lift(ty).unwrap();
+                let val = cx.lift(val).unwrap();
+                let kind = ConstantKind::Allocated(alloc::new_allocation(ty, val, tables, cx));
+                let ty = ty.stable(tables, cx);
+                MirConst::new(kind, ty, id)
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for mir::interpret::ErrorHandled {
+    type T = Error;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        Error::new(format!("{self:?}"))
+    }
+}
+
+impl<'tcx> Stable<'tcx> for MonoItem<'tcx> {
+    type T = crate::mir::mono::MonoItem;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::mir::mono::MonoItem as StableMonoItem;
+        match self {
+            MonoItem::Fn(instance) => StableMonoItem::Fn(instance.stable(tables, cx)),
+            MonoItem::Static(def_id) => StableMonoItem::Static(tables.static_def(*def_id)),
+            MonoItem::GlobalAsm(item_id) => StableMonoItem::GlobalAsm(opaque(item_id)),
+        }
+    }
+}
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mod.rs b/compiler/rustc_public/src/unstable/convert/stable/mod.rs
new file mode 100644
index 00000000000..ea78ca50eb3
--- /dev/null
+++ b/compiler/rustc_public/src/unstable/convert/stable/mod.rs
@@ -0,0 +1,95 @@
+//! Conversion of internal Rust compiler items to stable ones.
+
+use rustc_abi::FieldIdx;
+use rustc_public_bridge::Tables;
+use rustc_public_bridge::context::SmirCtxt;
+
+use super::Stable;
+use crate::compiler_interface::BridgeTys;
+
+mod abi;
+mod mir;
+mod ty;
+
+impl<'tcx> Stable<'tcx> for rustc_hir::Safety {
+    type T = crate::mir::Safety;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            rustc_hir::Safety::Unsafe => crate::mir::Safety::Unsafe,
+            rustc_hir::Safety::Safe => crate::mir::Safety::Safe,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for FieldIdx {
+    type T = usize;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        self.as_usize()
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineSource {
+    type T = crate::mir::CoroutineSource;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_hir::CoroutineSource;
+        match self {
+            CoroutineSource::Block => crate::mir::CoroutineSource::Block,
+            CoroutineSource::Closure => crate::mir::CoroutineSource::Closure,
+            CoroutineSource::Fn => crate::mir::CoroutineSource::Fn,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineKind {
+    type T = crate::mir::CoroutineKind;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_hir::{CoroutineDesugaring, CoroutineKind};
+        match *self {
+            CoroutineKind::Desugared(CoroutineDesugaring::Async, source) => {
+                crate::mir::CoroutineKind::Desugared(
+                    crate::mir::CoroutineDesugaring::Async,
+                    source.stable(tables, cx),
+                )
+            }
+            CoroutineKind::Desugared(CoroutineDesugaring::Gen, source) => {
+                crate::mir::CoroutineKind::Desugared(
+                    crate::mir::CoroutineDesugaring::Gen,
+                    source.stable(tables, cx),
+                )
+            }
+            CoroutineKind::Coroutine(movability) => {
+                crate::mir::CoroutineKind::Coroutine(movability.stable(tables, cx))
+            }
+            CoroutineKind::Desugared(CoroutineDesugaring::AsyncGen, source) => {
+                crate::mir::CoroutineKind::Desugared(
+                    crate::mir::CoroutineDesugaring::AsyncGen,
+                    source.stable(tables, cx),
+                )
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_span::Symbol {
+    type T = crate::Symbol;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        self.to_string()
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_span::Span {
+    type T = crate::ty::Span;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        _: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        tables.create_span(*self)
+    }
+}
diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
new file mode 100644
index 00000000000..75c29788787
--- /dev/null
+++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
@@ -0,0 +1,1139 @@
+//! Conversion of internal Rust compiler `ty` items to stable ones.
+
+use rustc_middle::ty::Ty;
+use rustc_middle::{bug, mir, ty};
+use rustc_public_bridge::Tables;
+use rustc_public_bridge::context::SmirCtxt;
+
+use crate::alloc;
+use crate::compiler_interface::BridgeTys;
+use crate::ty::{
+    AdtKind, FloatTy, GenericArgs, GenericParamDef, IntTy, Region, RigidTy, TyKind, UintTy,
+};
+use crate::unstable::Stable;
+
+impl<'tcx> Stable<'tcx> for ty::AliasTyKind {
+    type T = crate::ty::AliasKind;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            ty::Projection => crate::ty::AliasKind::Projection,
+            ty::Inherent => crate::ty::AliasKind::Inherent,
+            ty::Opaque => crate::ty::AliasKind::Opaque,
+            ty::Free => crate::ty::AliasKind::Free,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::AliasTy<'tcx> {
+    type T = crate::ty::AliasTy;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let ty::AliasTy { args, def_id, .. } = self;
+        crate::ty::AliasTy { def_id: tables.alias_def(*def_id), args: args.stable(tables, cx) }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::AliasTerm<'tcx> {
+    type T = crate::ty::AliasTerm;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let ty::AliasTerm { args, def_id, .. } = self;
+        crate::ty::AliasTerm { def_id: tables.alias_def(*def_id), args: args.stable(tables, cx) }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::DynKind {
+    type T = crate::ty::DynKind;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            ty::Dyn => crate::ty::DynKind::Dyn,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::ExistentialPredicate<'tcx> {
+    type T = crate::ty::ExistentialPredicate;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::ExistentialPredicate::*;
+        match self {
+            ty::ExistentialPredicate::Trait(existential_trait_ref) => {
+                Trait(existential_trait_ref.stable(tables, cx))
+            }
+            ty::ExistentialPredicate::Projection(existential_projection) => {
+                Projection(existential_projection.stable(tables, cx))
+            }
+            ty::ExistentialPredicate::AutoTrait(def_id) => AutoTrait(tables.trait_def(*def_id)),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::ExistentialTraitRef<'tcx> {
+    type T = crate::ty::ExistentialTraitRef;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let ty::ExistentialTraitRef { def_id, args, .. } = self;
+        crate::ty::ExistentialTraitRef {
+            def_id: tables.trait_def(*def_id),
+            generic_args: args.stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::TermKind<'tcx> {
+    type T = crate::ty::TermKind;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::TermKind;
+        match self {
+            ty::TermKind::Ty(ty) => TermKind::Type(ty.stable(tables, cx)),
+            ty::TermKind::Const(cnst) => {
+                let cnst = cnst.stable(tables, cx);
+                TermKind::Const(cnst)
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::ExistentialProjection<'tcx> {
+    type T = crate::ty::ExistentialProjection;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let ty::ExistentialProjection { def_id, args, term, .. } = self;
+        crate::ty::ExistentialProjection {
+            def_id: tables.trait_def(*def_id),
+            generic_args: args.stable(tables, cx),
+            term: term.kind().stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::adjustment::PointerCoercion {
+    type T = crate::mir::PointerCoercion;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::ty::adjustment::PointerCoercion;
+        match self {
+            PointerCoercion::ReifyFnPointer => crate::mir::PointerCoercion::ReifyFnPointer,
+            PointerCoercion::UnsafeFnPointer => crate::mir::PointerCoercion::UnsafeFnPointer,
+            PointerCoercion::ClosureFnPointer(safety) => {
+                crate::mir::PointerCoercion::ClosureFnPointer(safety.stable(tables, cx))
+            }
+            PointerCoercion::MutToConstPointer => crate::mir::PointerCoercion::MutToConstPointer,
+            PointerCoercion::ArrayToPointer => crate::mir::PointerCoercion::ArrayToPointer,
+            PointerCoercion::Unsize => crate::mir::PointerCoercion::Unsize,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::UserTypeAnnotationIndex {
+    type T = usize;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        self.as_usize()
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::AdtKind {
+    type T = AdtKind;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            ty::AdtKind::Struct => AdtKind::Struct,
+            ty::AdtKind::Union => AdtKind::Union,
+            ty::AdtKind::Enum => AdtKind::Enum,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::FieldDef {
+    type T = crate::ty::FieldDef;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        crate::ty::FieldDef {
+            def: tables.create_def_id(self.did),
+            name: self.name.stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::GenericArgs<'tcx> {
+    type T = crate::ty::GenericArgs;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        GenericArgs(self.iter().map(|arg| arg.kind().stable(tables, cx)).collect())
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::GenericArgKind<'tcx> {
+    type T = crate::ty::GenericArgKind;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::GenericArgKind;
+        match self {
+            ty::GenericArgKind::Lifetime(region) => {
+                GenericArgKind::Lifetime(region.stable(tables, cx))
+            }
+            ty::GenericArgKind::Type(ty) => GenericArgKind::Type(ty.stable(tables, cx)),
+            ty::GenericArgKind::Const(cnst) => GenericArgKind::Const(cnst.stable(tables, cx)),
+        }
+    }
+}
+
+impl<'tcx, S, V> Stable<'tcx> for ty::Binder<'tcx, S>
+where
+    S: Stable<'tcx, T = V>,
+{
+    type T = crate::ty::Binder<V>;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::Binder;
+
+        Binder {
+            value: self.as_ref().skip_binder().stable(tables, cx),
+            bound_vars: self
+                .bound_vars()
+                .iter()
+                .map(|bound_var| bound_var.stable(tables, cx))
+                .collect(),
+        }
+    }
+}
+
+impl<'tcx, S, V> Stable<'tcx> for ty::EarlyBinder<'tcx, S>
+where
+    S: Stable<'tcx, T = V>,
+{
+    type T = crate::ty::EarlyBinder<V>;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::EarlyBinder;
+
+        EarlyBinder { value: self.as_ref().skip_binder().stable(tables, cx) }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::FnSig<'tcx> {
+    type T = crate::ty::FnSig;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::FnSig;
+
+        FnSig {
+            inputs_and_output: self
+                .inputs_and_output
+                .iter()
+                .map(|ty| ty.stable(tables, cx))
+                .collect(),
+            c_variadic: self.c_variadic,
+            safety: self.safety.stable(tables, cx),
+            abi: self.abi.stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::BoundTyKind {
+    type T = crate::ty::BoundTyKind;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::BoundTyKind;
+
+        match self {
+            ty::BoundTyKind::Anon => BoundTyKind::Anon,
+            ty::BoundTyKind::Param(def_id) => {
+                BoundTyKind::Param(tables.param_def(*def_id), cx.tcx.item_name(*def_id).to_string())
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::BoundRegionKind {
+    type T = crate::ty::BoundRegionKind;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::BoundRegionKind;
+
+        match self {
+            ty::BoundRegionKind::Anon => BoundRegionKind::BrAnon,
+            ty::BoundRegionKind::Named(def_id) => BoundRegionKind::BrNamed(
+                tables.br_named_def(*def_id),
+                cx.tcx.item_name(*def_id).to_string(),
+            ),
+            ty::BoundRegionKind::ClosureEnv => BoundRegionKind::BrEnv,
+            ty::BoundRegionKind::NamedAnon(_) => bug!("only used for pretty printing"),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::BoundVariableKind {
+    type T = crate::ty::BoundVariableKind;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::BoundVariableKind;
+
+        match self {
+            ty::BoundVariableKind::Ty(bound_ty_kind) => {
+                BoundVariableKind::Ty(bound_ty_kind.stable(tables, cx))
+            }
+            ty::BoundVariableKind::Region(bound_region_kind) => {
+                BoundVariableKind::Region(bound_region_kind.stable(tables, cx))
+            }
+            ty::BoundVariableKind::Const => BoundVariableKind::Const,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::IntTy {
+    type T = IntTy;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            ty::IntTy::Isize => IntTy::Isize,
+            ty::IntTy::I8 => IntTy::I8,
+            ty::IntTy::I16 => IntTy::I16,
+            ty::IntTy::I32 => IntTy::I32,
+            ty::IntTy::I64 => IntTy::I64,
+            ty::IntTy::I128 => IntTy::I128,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::UintTy {
+    type T = UintTy;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            ty::UintTy::Usize => UintTy::Usize,
+            ty::UintTy::U8 => UintTy::U8,
+            ty::UintTy::U16 => UintTy::U16,
+            ty::UintTy::U32 => UintTy::U32,
+            ty::UintTy::U64 => UintTy::U64,
+            ty::UintTy::U128 => UintTy::U128,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::FloatTy {
+    type T = FloatTy;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            ty::FloatTy::F16 => FloatTy::F16,
+            ty::FloatTy::F32 => FloatTy::F32,
+            ty::FloatTy::F64 => FloatTy::F64,
+            ty::FloatTy::F128 => FloatTy::F128,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for Ty<'tcx> {
+    type T = crate::ty::Ty;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        tables.intern_ty(cx.lift(*self).unwrap())
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> {
+    type T = crate::ty::TyKind;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match self {
+            ty::Bool => TyKind::RigidTy(RigidTy::Bool),
+            ty::Char => TyKind::RigidTy(RigidTy::Char),
+            ty::Int(int_ty) => TyKind::RigidTy(RigidTy::Int(int_ty.stable(tables, cx))),
+            ty::Uint(uint_ty) => TyKind::RigidTy(RigidTy::Uint(uint_ty.stable(tables, cx))),
+            ty::Float(float_ty) => TyKind::RigidTy(RigidTy::Float(float_ty.stable(tables, cx))),
+            ty::Adt(adt_def, generic_args) => TyKind::RigidTy(RigidTy::Adt(
+                tables.adt_def(adt_def.did()),
+                generic_args.stable(tables, cx),
+            )),
+            ty::Foreign(def_id) => TyKind::RigidTy(RigidTy::Foreign(tables.foreign_def(*def_id))),
+            ty::Str => TyKind::RigidTy(RigidTy::Str),
+            ty::Array(ty, constant) => {
+                TyKind::RigidTy(RigidTy::Array(ty.stable(tables, cx), constant.stable(tables, cx)))
+            }
+            ty::Pat(ty, pat) => {
+                TyKind::RigidTy(RigidTy::Pat(ty.stable(tables, cx), pat.stable(tables, cx)))
+            }
+            ty::Slice(ty) => TyKind::RigidTy(RigidTy::Slice(ty.stable(tables, cx))),
+            ty::RawPtr(ty, mutbl) => {
+                TyKind::RigidTy(RigidTy::RawPtr(ty.stable(tables, cx), mutbl.stable(tables, cx)))
+            }
+            ty::Ref(region, ty, mutbl) => TyKind::RigidTy(RigidTy::Ref(
+                region.stable(tables, cx),
+                ty.stable(tables, cx),
+                mutbl.stable(tables, cx),
+            )),
+            ty::FnDef(def_id, generic_args) => TyKind::RigidTy(RigidTy::FnDef(
+                tables.fn_def(*def_id),
+                generic_args.stable(tables, cx),
+            )),
+            ty::FnPtr(sig_tys, hdr) => {
+                TyKind::RigidTy(RigidTy::FnPtr(sig_tys.with(*hdr).stable(tables, cx)))
+            }
+            // FIXME(unsafe_binders):
+            ty::UnsafeBinder(_) => todo!(),
+            ty::Dynamic(existential_predicates, region, dyn_kind) => {
+                TyKind::RigidTy(RigidTy::Dynamic(
+                    existential_predicates
+                        .iter()
+                        .map(|existential_predicate| existential_predicate.stable(tables, cx))
+                        .collect(),
+                    region.stable(tables, cx),
+                    dyn_kind.stable(tables, cx),
+                ))
+            }
+            ty::Closure(def_id, generic_args) => TyKind::RigidTy(RigidTy::Closure(
+                tables.closure_def(*def_id),
+                generic_args.stable(tables, cx),
+            )),
+            ty::CoroutineClosure(..) => todo!("FIXME(async_closures): Lower these to SMIR"),
+            ty::Coroutine(def_id, generic_args) => TyKind::RigidTy(RigidTy::Coroutine(
+                tables.coroutine_def(*def_id),
+                generic_args.stable(tables, cx),
+                cx.coroutine_movability(*def_id).stable(tables, cx),
+            )),
+            ty::Never => TyKind::RigidTy(RigidTy::Never),
+            ty::Tuple(fields) => TyKind::RigidTy(RigidTy::Tuple(
+                fields.iter().map(|ty| ty.stable(tables, cx)).collect(),
+            )),
+            ty::Alias(alias_kind, alias_ty) => {
+                TyKind::Alias(alias_kind.stable(tables, cx), alias_ty.stable(tables, cx))
+            }
+            ty::Param(param_ty) => TyKind::Param(param_ty.stable(tables, cx)),
+            ty::Bound(debruijn_idx, bound_ty) => {
+                TyKind::Bound(debruijn_idx.as_usize(), bound_ty.stable(tables, cx))
+            }
+            ty::CoroutineWitness(def_id, args) => TyKind::RigidTy(RigidTy::CoroutineWitness(
+                tables.coroutine_witness_def(*def_id),
+                args.stable(tables, cx),
+            )),
+            ty::Placeholder(..) | ty::Infer(_) | ty::Error(_) => {
+                unreachable!();
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::Pattern<'tcx> {
+    type T = crate::ty::Pattern;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        match **self {
+            ty::PatternKind::Range { start, end } => crate::ty::Pattern::Range {
+                // FIXME(SMIR): update data structures to not have an Option here anymore
+                start: Some(start.stable(tables, cx)),
+                end: Some(end.stable(tables, cx)),
+                include_end: true,
+            },
+            ty::PatternKind::Or(_) => todo!(),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::Const<'tcx> {
+    type T = crate::ty::TyConst;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let ct = cx.lift(*self).unwrap();
+        let kind = match ct.kind() {
+            ty::ConstKind::Value(cv) => {
+                let const_val = cx.valtree_to_const_val(cv);
+                if matches!(const_val, mir::ConstValue::ZeroSized) {
+                    crate::ty::TyConstKind::ZSTValue(cv.ty.stable(tables, cx))
+                } else {
+                    crate::ty::TyConstKind::Value(
+                        cv.ty.stable(tables, cx),
+                        alloc::new_allocation(cv.ty, const_val, tables, cx),
+                    )
+                }
+            }
+            ty::ConstKind::Param(param) => crate::ty::TyConstKind::Param(param.stable(tables, cx)),
+            ty::ConstKind::Unevaluated(uv) => crate::ty::TyConstKind::Unevaluated(
+                tables.const_def(uv.def),
+                uv.args.stable(tables, cx),
+            ),
+            ty::ConstKind::Error(_) => unreachable!(),
+            ty::ConstKind::Infer(_) => unreachable!(),
+            ty::ConstKind::Bound(_, _) => unimplemented!(),
+            ty::ConstKind::Placeholder(_) => unimplemented!(),
+            ty::ConstKind::Expr(_) => unimplemented!(),
+        };
+        let id = tables.intern_ty_const(ct);
+        crate::ty::TyConst::new(kind, id)
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::ParamConst {
+    type T = crate::ty::ParamConst;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use crate::ty::ParamConst;
+        ParamConst { index: self.index, name: self.name.to_string() }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::ParamTy {
+    type T = crate::ty::ParamTy;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use crate::ty::ParamTy;
+        ParamTy { index: self.index, name: self.name.to_string() }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::BoundTy {
+    type T = crate::ty::BoundTy;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::BoundTy;
+        BoundTy { var: self.var.as_usize(), kind: self.kind.stable(tables, cx) }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::trait_def::TraitSpecializationKind {
+    type T = crate::ty::TraitSpecializationKind;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use crate::ty::TraitSpecializationKind;
+
+        match self {
+            ty::trait_def::TraitSpecializationKind::None => TraitSpecializationKind::None,
+            ty::trait_def::TraitSpecializationKind::Marker => TraitSpecializationKind::Marker,
+            ty::trait_def::TraitSpecializationKind::AlwaysApplicable => {
+                TraitSpecializationKind::AlwaysApplicable
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::TraitDef {
+    type T = crate::ty::TraitDecl;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::opaque;
+        use crate::ty::TraitDecl;
+
+        TraitDecl {
+            def_id: tables.trait_def(self.def_id),
+            safety: self.safety.stable(tables, cx),
+            paren_sugar: self.paren_sugar,
+            has_auto_impl: self.has_auto_impl,
+            is_marker: self.is_marker,
+            is_coinductive: self.is_coinductive,
+            skip_array_during_method_dispatch: self.skip_array_during_method_dispatch,
+            skip_boxed_slice_during_method_dispatch: self.skip_boxed_slice_during_method_dispatch,
+            specialization_kind: self.specialization_kind.stable(tables, cx),
+            must_implement_one_of: self
+                .must_implement_one_of
+                .as_ref()
+                .map(|idents| idents.iter().map(|ident| opaque(ident)).collect()),
+            implement_via_object: self.implement_via_object,
+            deny_explicit_impl: self.deny_explicit_impl,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::TraitRef<'tcx> {
+    type T = crate::ty::TraitRef;
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::TraitRef;
+
+        TraitRef::try_new(tables.trait_def(self.def_id), self.args.stable(tables, cx)).unwrap()
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::Generics {
+    type T = crate::ty::Generics;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::Generics;
+
+        let params: Vec<_> = self.own_params.iter().map(|param| param.stable(tables, cx)).collect();
+        let param_def_id_to_index =
+            params.iter().map(|param| (param.def_id, param.index)).collect();
+
+        Generics {
+            parent: self.parent.map(|did| tables.generic_def(did)),
+            parent_count: self.parent_count,
+            params,
+            param_def_id_to_index,
+            has_self: self.has_self,
+            has_late_bound_regions: self
+                .has_late_bound_regions
+                .as_ref()
+                .map(|late_bound_regions| late_bound_regions.stable(tables, cx)),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDefKind {
+    type T = crate::ty::GenericParamDefKind;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use crate::ty::GenericParamDefKind;
+        match self {
+            ty::GenericParamDefKind::Lifetime => GenericParamDefKind::Lifetime,
+            ty::GenericParamDefKind::Type { has_default, synthetic } => {
+                GenericParamDefKind::Type { has_default: *has_default, synthetic: *synthetic }
+            }
+            ty::GenericParamDefKind::Const { has_default, synthetic: _ } => {
+                GenericParamDefKind::Const { has_default: *has_default }
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDef {
+    type T = crate::ty::GenericParamDef;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        GenericParamDef {
+            name: self.name.to_string(),
+            def_id: tables.generic_def(self.def_id),
+            index: self.index,
+            pure_wrt_drop: self.pure_wrt_drop,
+            kind: self.kind.stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::PredicateKind<'tcx> {
+    type T = crate::ty::PredicateKind;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::ty::PredicateKind;
+        match self {
+            PredicateKind::Clause(clause_kind) => {
+                crate::ty::PredicateKind::Clause(clause_kind.stable(tables, cx))
+            }
+            PredicateKind::DynCompatible(did) => {
+                crate::ty::PredicateKind::DynCompatible(tables.trait_def(*did))
+            }
+            PredicateKind::Subtype(subtype_predicate) => {
+                crate::ty::PredicateKind::SubType(subtype_predicate.stable(tables, cx))
+            }
+            PredicateKind::Coerce(coerce_predicate) => {
+                crate::ty::PredicateKind::Coerce(coerce_predicate.stable(tables, cx))
+            }
+            PredicateKind::ConstEquate(a, b) => {
+                crate::ty::PredicateKind::ConstEquate(a.stable(tables, cx), b.stable(tables, cx))
+            }
+            PredicateKind::Ambiguous => crate::ty::PredicateKind::Ambiguous,
+            PredicateKind::NormalizesTo(_pred) => unimplemented!(),
+            PredicateKind::AliasRelate(a, b, alias_relation_direction) => {
+                crate::ty::PredicateKind::AliasRelate(
+                    a.kind().stable(tables, cx),
+                    b.kind().stable(tables, cx),
+                    alias_relation_direction.stable(tables, cx),
+                )
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> {
+    type T = crate::ty::ClauseKind;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use rustc_middle::ty::ClauseKind;
+        match *self {
+            ClauseKind::Trait(trait_object) => {
+                crate::ty::ClauseKind::Trait(trait_object.stable(tables, cx))
+            }
+            ClauseKind::RegionOutlives(region_outlives) => {
+                crate::ty::ClauseKind::RegionOutlives(region_outlives.stable(tables, cx))
+            }
+            ClauseKind::TypeOutlives(type_outlives) => {
+                let ty::OutlivesPredicate::<_, _>(a, b) = type_outlives;
+                crate::ty::ClauseKind::TypeOutlives(crate::ty::OutlivesPredicate(
+                    a.stable(tables, cx),
+                    b.stable(tables, cx),
+                ))
+            }
+            ClauseKind::Projection(projection_predicate) => {
+                crate::ty::ClauseKind::Projection(projection_predicate.stable(tables, cx))
+            }
+            ClauseKind::ConstArgHasType(const_, ty) => crate::ty::ClauseKind::ConstArgHasType(
+                const_.stable(tables, cx),
+                ty.stable(tables, cx),
+            ),
+            ClauseKind::WellFormed(term) => {
+                crate::ty::ClauseKind::WellFormed(term.kind().stable(tables, cx))
+            }
+            ClauseKind::ConstEvaluatable(const_) => {
+                crate::ty::ClauseKind::ConstEvaluatable(const_.stable(tables, cx))
+            }
+            ClauseKind::HostEffect(..) => {
+                todo!()
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::ClosureKind {
+    type T = crate::ty::ClosureKind;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_middle::ty::ClosureKind::*;
+        match self {
+            Fn => crate::ty::ClosureKind::Fn,
+            FnMut => crate::ty::ClosureKind::FnMut,
+            FnOnce => crate::ty::ClosureKind::FnOnce,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::SubtypePredicate<'tcx> {
+    type T = crate::ty::SubtypePredicate;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let ty::SubtypePredicate { a, b, a_is_expected: _ } = self;
+        crate::ty::SubtypePredicate { a: a.stable(tables, cx), b: b.stable(tables, cx) }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::CoercePredicate<'tcx> {
+    type T = crate::ty::CoercePredicate;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let ty::CoercePredicate { a, b } = self;
+        crate::ty::CoercePredicate { a: a.stable(tables, cx), b: b.stable(tables, cx) }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::AliasRelationDirection {
+    type T = crate::ty::AliasRelationDirection;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_middle::ty::AliasRelationDirection::*;
+        match self {
+            Equate => crate::ty::AliasRelationDirection::Equate,
+            Subtype => crate::ty::AliasRelationDirection::Subtype,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::TraitPredicate<'tcx> {
+    type T = crate::ty::TraitPredicate;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let ty::TraitPredicate { trait_ref, polarity } = self;
+        crate::ty::TraitPredicate {
+            trait_ref: trait_ref.stable(tables, cx),
+            polarity: polarity.stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx, T> Stable<'tcx> for ty::OutlivesPredicate<'tcx, T>
+where
+    T: Stable<'tcx>,
+{
+    type T = crate::ty::OutlivesPredicate<T::T, Region>;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let ty::OutlivesPredicate(a, b) = self;
+        crate::ty::OutlivesPredicate(a.stable(tables, cx), b.stable(tables, cx))
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::ProjectionPredicate<'tcx> {
+    type T = crate::ty::ProjectionPredicate;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let ty::ProjectionPredicate { projection_term, term } = self;
+        crate::ty::ProjectionPredicate {
+            projection_term: projection_term.stable(tables, cx),
+            term: term.kind().stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::ImplPolarity {
+    type T = crate::ty::ImplPolarity;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_middle::ty::ImplPolarity::*;
+        match self {
+            Positive => crate::ty::ImplPolarity::Positive,
+            Negative => crate::ty::ImplPolarity::Negative,
+            Reservation => crate::ty::ImplPolarity::Reservation,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::PredicatePolarity {
+    type T = crate::ty::PredicatePolarity;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_middle::ty::PredicatePolarity::*;
+        match self {
+            Positive => crate::ty::PredicatePolarity::Positive,
+            Negative => crate::ty::PredicatePolarity::Negative,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::Region<'tcx> {
+    type T = crate::ty::Region;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        Region { kind: self.kind().stable(tables, cx) }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::RegionKind<'tcx> {
+    type T = crate::ty::RegionKind;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::{BoundRegion, EarlyParamRegion, RegionKind};
+        match self {
+            ty::ReEarlyParam(early_reg) => RegionKind::ReEarlyParam(EarlyParamRegion {
+                index: early_reg.index,
+                name: early_reg.name.to_string(),
+            }),
+            ty::ReBound(db_index, bound_reg) => RegionKind::ReBound(
+                db_index.as_u32(),
+                BoundRegion {
+                    var: bound_reg.var.as_u32(),
+                    kind: bound_reg.kind.stable(tables, cx),
+                },
+            ),
+            ty::ReStatic => RegionKind::ReStatic,
+            ty::RePlaceholder(place_holder) => RegionKind::RePlaceholder(crate::ty::Placeholder {
+                universe: place_holder.universe.as_u32(),
+                bound: BoundRegion {
+                    var: place_holder.bound.var.as_u32(),
+                    kind: place_holder.bound.kind.stable(tables, cx),
+                },
+            }),
+            ty::ReErased => RegionKind::ReErased,
+            _ => unreachable!("{self:?}"),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::Instance<'tcx> {
+    type T = crate::mir::mono::Instance;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        let def = tables.instance_def(cx.lift(*self).unwrap());
+        let kind = match self.def {
+            ty::InstanceKind::Item(..) => crate::mir::mono::InstanceKind::Item,
+            ty::InstanceKind::Intrinsic(..) => crate::mir::mono::InstanceKind::Intrinsic,
+            ty::InstanceKind::Virtual(_def_id, idx) => {
+                crate::mir::mono::InstanceKind::Virtual { idx }
+            }
+            ty::InstanceKind::VTableShim(..)
+            | ty::InstanceKind::ReifyShim(..)
+            | ty::InstanceKind::FnPtrAddrShim(..)
+            | ty::InstanceKind::ClosureOnceShim { .. }
+            | ty::InstanceKind::ConstructCoroutineInClosureShim { .. }
+            | ty::InstanceKind::ThreadLocalShim(..)
+            | ty::InstanceKind::DropGlue(..)
+            | ty::InstanceKind::CloneShim(..)
+            | ty::InstanceKind::FnPtrShim(..)
+            | ty::InstanceKind::FutureDropPollShim(..)
+            | ty::InstanceKind::AsyncDropGlue(..)
+            | ty::InstanceKind::AsyncDropGlueCtorShim(..) => crate::mir::mono::InstanceKind::Shim,
+        };
+        crate::mir::mono::Instance { def, kind }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::Variance {
+    type T = crate::mir::Variance;
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            ty::Bivariant => crate::mir::Variance::Bivariant,
+            ty::Contravariant => crate::mir::Variance::Contravariant,
+            ty::Covariant => crate::mir::Variance::Covariant,
+            ty::Invariant => crate::mir::Variance::Invariant,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::Movability {
+    type T = crate::ty::Movability;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        match self {
+            ty::Movability::Static => crate::ty::Movability::Static,
+            ty::Movability::Movable => crate::ty::Movability::Movable,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_abi::ExternAbi {
+    type T = crate::ty::Abi;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use rustc_abi::ExternAbi;
+
+        use crate::ty::Abi;
+        match *self {
+            ExternAbi::Rust => Abi::Rust,
+            ExternAbi::C { unwind } => Abi::C { unwind },
+            ExternAbi::Cdecl { unwind } => Abi::Cdecl { unwind },
+            ExternAbi::Stdcall { unwind } => Abi::Stdcall { unwind },
+            ExternAbi::Fastcall { unwind } => Abi::Fastcall { unwind },
+            ExternAbi::Vectorcall { unwind } => Abi::Vectorcall { unwind },
+            ExternAbi::Thiscall { unwind } => Abi::Thiscall { unwind },
+            ExternAbi::Aapcs { unwind } => Abi::Aapcs { unwind },
+            ExternAbi::Win64 { unwind } => Abi::Win64 { unwind },
+            ExternAbi::SysV64 { unwind } => Abi::SysV64 { unwind },
+            ExternAbi::PtxKernel => Abi::PtxKernel,
+            ExternAbi::GpuKernel => Abi::GpuKernel,
+            ExternAbi::Msp430Interrupt => Abi::Msp430Interrupt,
+            ExternAbi::X86Interrupt => Abi::X86Interrupt,
+            ExternAbi::EfiApi => Abi::EfiApi,
+            ExternAbi::AvrInterrupt => Abi::AvrInterrupt,
+            ExternAbi::AvrNonBlockingInterrupt => Abi::AvrNonBlockingInterrupt,
+            ExternAbi::CmseNonSecureCall => Abi::CCmseNonSecureCall,
+            ExternAbi::CmseNonSecureEntry => Abi::CCmseNonSecureEntry,
+            ExternAbi::System { unwind } => Abi::System { unwind },
+            ExternAbi::RustCall => Abi::RustCall,
+            ExternAbi::Unadjusted => Abi::Unadjusted,
+            ExternAbi::RustCold => Abi::RustCold,
+            ExternAbi::RustInvalid => Abi::RustInvalid,
+            ExternAbi::RiscvInterruptM => Abi::RiscvInterruptM,
+            ExternAbi::RiscvInterruptS => Abi::RiscvInterruptS,
+            ExternAbi::Custom => Abi::Custom,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_session::cstore::ForeignModule {
+    type T = crate::ty::ForeignModule;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        crate::ty::ForeignModule {
+            def_id: tables.foreign_module_def(self.def_id),
+            abi: self.abi.stable(tables, cx),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::AssocKind {
+    type T = crate::ty::AssocKind;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::{AssocKind, AssocTypeData};
+        match *self {
+            ty::AssocKind::Const { name } => AssocKind::Const { name: name.to_string() },
+            ty::AssocKind::Fn { name, has_self } => {
+                AssocKind::Fn { name: name.to_string(), has_self }
+            }
+            ty::AssocKind::Type { data } => AssocKind::Type {
+                data: match data {
+                    ty::AssocTypeData::Normal(name) => AssocTypeData::Normal(name.to_string()),
+                    ty::AssocTypeData::Rpitit(rpitit) => {
+                        AssocTypeData::Rpitit(rpitit.stable(tables, cx))
+                    }
+                },
+            },
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::AssocItemContainer {
+    type T = crate::ty::AssocItemContainer;
+
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+        use crate::ty::AssocItemContainer;
+        match self {
+            ty::AssocItemContainer::Trait => AssocItemContainer::Trait,
+            ty::AssocItemContainer::Impl => AssocItemContainer::Impl,
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::AssocItem {
+    type T = crate::ty::AssocItem;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        crate::ty::AssocItem {
+            def_id: tables.assoc_def(self.def_id),
+            kind: self.kind.stable(tables, cx),
+            container: self.container.stable(tables, cx),
+            trait_item_def_id: self.trait_item_def_id.map(|did| tables.assoc_def(did)),
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for ty::ImplTraitInTraitData {
+    type T = crate::ty::ImplTraitInTraitData;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        _: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        use crate::ty::ImplTraitInTraitData;
+        match self {
+            ty::ImplTraitInTraitData::Trait { fn_def_id, opaque_def_id } => {
+                ImplTraitInTraitData::Trait {
+                    fn_def_id: tables.fn_def(*fn_def_id),
+                    opaque_def_id: tables.opaque_def(*opaque_def_id),
+                }
+            }
+            ty::ImplTraitInTraitData::Impl { fn_def_id } => {
+                ImplTraitInTraitData::Impl { fn_def_id: tables.fn_def(*fn_def_id) }
+            }
+        }
+    }
+}
+
+impl<'tcx> Stable<'tcx> for rustc_middle::ty::util::Discr<'tcx> {
+    type T = crate::ty::Discr;
+
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T {
+        crate::ty::Discr { val: self.val, ty: self.ty.stable(tables, cx) }
+    }
+}
diff --git a/compiler/rustc_public/src/unstable/internal_cx/mod.rs b/compiler/rustc_public/src/unstable/internal_cx/mod.rs
new file mode 100644
index 00000000000..6b0a06e304c
--- /dev/null
+++ b/compiler/rustc_public/src/unstable/internal_cx/mod.rs
@@ -0,0 +1,93 @@
+//! Implementation of InternalCx.
+
+use rustc_middle::ty::{List, Ty, TyCtxt};
+use rustc_middle::{mir, ty};
+pub(crate) use traits::*;
+
+use super::InternalCx;
+
+pub(crate) mod traits;
+
+impl<'tcx, T: InternalCx<'tcx>> SmirExistentialProjection<'tcx> for T {
+    fn new_from_args(
+        &self,
+        def_id: rustc_span::def_id::DefId,
+        args: ty::GenericArgsRef<'tcx>,
+        term: ty::Term<'tcx>,
+    ) -> ty::ExistentialProjection<'tcx> {
+        ty::ExistentialProjection::new_from_args(self.tcx(), def_id, args, term)
+    }
+}
+
+impl<'tcx, T: InternalCx<'tcx>> SmirExistentialTraitRef<'tcx> for T {
+    fn new_from_args(
+        &self,
+        trait_def_id: rustc_span::def_id::DefId,
+        args: ty::GenericArgsRef<'tcx>,
+    ) -> ty::ExistentialTraitRef<'tcx> {
+        ty::ExistentialTraitRef::new_from_args(self.tcx(), trait_def_id, args)
+    }
+}
+
+impl<'tcx, T: InternalCx<'tcx>> SmirTraitRef<'tcx> for T {
+    fn new_from_args(
+        &self,
+        trait_def_id: rustc_span::def_id::DefId,
+        args: ty::GenericArgsRef<'tcx>,
+    ) -> ty::TraitRef<'tcx> {
+        ty::TraitRef::new_from_args(self.tcx(), trait_def_id, args)
+    }
+}
+
+impl<'tcx> InternalCx<'tcx> for TyCtxt<'tcx> {
+    fn tcx(self) -> TyCtxt<'tcx> {
+        self
+    }
+
+    fn lift<T: ty::Lift<TyCtxt<'tcx>>>(self, value: T) -> Option<T::Lifted> {
+        TyCtxt::lift(self, value)
+    }
+
+    fn mk_args_from_iter<I, T>(self, iter: I) -> T::Output
+    where
+        I: Iterator<Item = T>,
+        T: ty::CollectAndApply<ty::GenericArg<'tcx>, ty::GenericArgsRef<'tcx>>,
+    {
+        TyCtxt::mk_args_from_iter(self, iter)
+    }
+
+    fn mk_pat(self, v: ty::PatternKind<'tcx>) -> ty::Pattern<'tcx> {
+        TyCtxt::mk_pat(self, v)
+    }
+
+    fn mk_poly_existential_predicates(
+        self,
+        eps: &[ty::PolyExistentialPredicate<'tcx>],
+    ) -> &'tcx List<ty::PolyExistentialPredicate<'tcx>> {
+        TyCtxt::mk_poly_existential_predicates(self, eps)
+    }
+
+    fn mk_type_list(self, v: &[Ty<'tcx>]) -> &'tcx List<Ty<'tcx>> {
+        TyCtxt::mk_type_list(self, v)
+    }
+
+    fn lifetimes_re_erased(self) -> ty::Region<'tcx> {
+        self.lifetimes.re_erased
+    }
+
+    fn mk_bound_variable_kinds_from_iter<I, T>(self, iter: I) -> T::Output
+    where
+        I: Iterator<Item = T>,
+        T: ty::CollectAndApply<ty::BoundVariableKind, &'tcx List<ty::BoundVariableKind>>,
+    {
+        TyCtxt::mk_bound_variable_kinds_from_iter(self, iter)
+    }
+
+    fn mk_place_elems(self, v: &[mir::PlaceElem<'tcx>]) -> &'tcx List<mir::PlaceElem<'tcx>> {
+        TyCtxt::mk_place_elems(self, v)
+    }
+
+    fn adt_def(self, def_id: rustc_hir::def_id::DefId) -> ty::AdtDef<'tcx> {
+        self.adt_def(def_id)
+    }
+}
diff --git a/compiler/rustc_public/src/unstable/internal_cx/traits.rs b/compiler/rustc_public/src/unstable/internal_cx/traits.rs
new file mode 100644
index 00000000000..da443cd78f1
--- /dev/null
+++ b/compiler/rustc_public/src/unstable/internal_cx/traits.rs
@@ -0,0 +1,31 @@
+//! A set of traits that define a stable interface to rustc's internals.
+//!
+//! These traits are primarily used to clarify the behavior of different
+//! functions that share the same name across various contexts.
+
+use rustc_middle::ty;
+
+pub(crate) trait SmirExistentialProjection<'tcx> {
+    fn new_from_args(
+        &self,
+        def_id: rustc_span::def_id::DefId,
+        args: ty::GenericArgsRef<'tcx>,
+        term: ty::Term<'tcx>,
+    ) -> ty::ExistentialProjection<'tcx>;
+}
+
+pub(crate) trait SmirExistentialTraitRef<'tcx> {
+    fn new_from_args(
+        &self,
+        trait_def_id: rustc_span::def_id::DefId,
+        args: ty::GenericArgsRef<'tcx>,
+    ) -> ty::ExistentialTraitRef<'tcx>;
+}
+
+pub(crate) trait SmirTraitRef<'tcx> {
+    fn new_from_args(
+        &self,
+        trait_def_id: rustc_span::def_id::DefId,
+        args: ty::GenericArgsRef<'tcx>,
+    ) -> ty::TraitRef<'tcx>;
+}
diff --git a/compiler/rustc_public/src/unstable/mod.rs b/compiler/rustc_public/src/unstable/mod.rs
new file mode 100644
index 00000000000..ce7c41a64fa
--- /dev/null
+++ b/compiler/rustc_public/src/unstable/mod.rs
@@ -0,0 +1,124 @@
+//! Module that collects the things that have no stability guarantees.
+//!
+//! We want to keep StableMIR definitions and logic separate from
+//! any sort of conversion and usage of internal rustc code. So we
+//! restrict the usage of internal items to be inside this module.
+
+use std::marker::PointeeSized;
+
+use rustc_hir::def::DefKind;
+use rustc_middle::ty::{List, Ty, TyCtxt};
+use rustc_middle::{mir, ty};
+use rustc_public_bridge::Tables;
+use rustc_public_bridge::context::SmirCtxt;
+
+use super::compiler_interface::BridgeTys;
+use crate::{CtorKind, ItemKind};
+
+pub(crate) mod convert;
+mod internal_cx;
+
+/// Trait that defines the methods that are fine to call from [`RustcInternal`].
+///
+/// This trait is only for [`RustcInternal`]. Any other other access to rustc's internals
+/// should go through [`rustc_public_bridge::context::SmirCtxt`].
+pub trait InternalCx<'tcx>: Copy + Clone {
+    fn tcx(self) -> TyCtxt<'tcx>;
+
+    fn lift<T: ty::Lift<TyCtxt<'tcx>>>(self, value: T) -> Option<T::Lifted>;
+
+    fn mk_args_from_iter<I, T>(self, iter: I) -> T::Output
+    where
+        I: Iterator<Item = T>,
+        T: ty::CollectAndApply<ty::GenericArg<'tcx>, ty::GenericArgsRef<'tcx>>;
+
+    fn mk_pat(self, v: ty::PatternKind<'tcx>) -> ty::Pattern<'tcx>;
+
+    fn mk_poly_existential_predicates(
+        self,
+        eps: &[ty::PolyExistentialPredicate<'tcx>],
+    ) -> &'tcx List<ty::PolyExistentialPredicate<'tcx>>;
+
+    fn mk_type_list(self, v: &[Ty<'tcx>]) -> &'tcx List<Ty<'tcx>>;
+
+    fn lifetimes_re_erased(self) -> ty::Region<'tcx>;
+
+    fn mk_bound_variable_kinds_from_iter<I, T>(self, iter: I) -> T::Output
+    where
+        I: Iterator<Item = T>,
+        T: ty::CollectAndApply<ty::BoundVariableKind, &'tcx List<ty::BoundVariableKind>>;
+
+    fn mk_place_elems(self, v: &[mir::PlaceElem<'tcx>]) -> &'tcx List<mir::PlaceElem<'tcx>>;
+
+    fn adt_def(self, def_id: rustc_hir::def_id::DefId) -> ty::AdtDef<'tcx>;
+}
+
+/// Trait used to convert between an internal MIR type to a Stable MIR type.
+///
+/// This trait is currently exposed to users so they can have interoperability between internal MIR
+/// and StableMIR constructs. However, they should be used seldom and they have no influence
+/// in this crate semver.
+#[doc(hidden)]
+pub trait Stable<'tcx>: PointeeSized {
+    /// The stable representation of the type implementing Stable.
+    type T;
+    /// Converts an object to the equivalent Stable MIR representation.
+    fn stable<'cx>(
+        &self,
+        tables: &mut Tables<'cx, BridgeTys>,
+        cx: &SmirCtxt<'cx, BridgeTys>,
+    ) -> Self::T;
+}
+
+/// Trait used to translate a stable construct to its rustc counterpart.
+///
+/// This is basically a mirror of [Stable].
+///
+/// This trait is currently exposed to users so they can have interoperability between internal MIR
+/// and StableMIR constructs. They should be used seldom as they have no stability guarantees.
+#[doc(hidden)]
+pub trait RustcInternal {
+    type T<'tcx>;
+    fn internal<'tcx>(
+        &self,
+        tables: &mut Tables<'_, BridgeTys>,
+        tcx: impl InternalCx<'tcx>,
+    ) -> Self::T<'tcx>;
+}
+
+pub(crate) fn new_item_kind(kind: DefKind) -> ItemKind {
+    match kind {
+        DefKind::Mod
+        | DefKind::Struct
+        | DefKind::Union
+        | DefKind::Enum
+        | DefKind::Variant
+        | DefKind::Trait
+        | DefKind::TyAlias
+        | DefKind::ForeignTy
+        | DefKind::TraitAlias
+        | DefKind::AssocTy
+        | DefKind::TyParam
+        | DefKind::ConstParam
+        | DefKind::Macro(_)
+        | DefKind::ExternCrate
+        | DefKind::Use
+        | DefKind::ForeignMod
+        | DefKind::OpaqueTy
+        | DefKind::Field
+        | DefKind::LifetimeParam
+        | DefKind::Impl { .. }
+        | DefKind::GlobalAsm => {
+            unreachable!("Not a valid item kind: {kind:?}");
+        }
+        DefKind::Closure | DefKind::AssocFn | DefKind::Fn | DefKind::SyntheticCoroutineBody => {
+            ItemKind::Fn
+        }
+        DefKind::Const | DefKind::InlineConst | DefKind::AssocConst | DefKind::AnonConst => {
+            ItemKind::Const
+        }
+        DefKind::Static { .. } => ItemKind::Static,
+        DefKind::Ctor(_, rustc_hir::def::CtorKind::Const) => ItemKind::Ctor(CtorKind::Const),
+        DefKind::Ctor(_, rustc_hir::def::CtorKind::Fn) => ItemKind::Ctor(CtorKind::Fn),
+    }
+}
diff --git a/compiler/rustc_public/src/visitor.rs b/compiler/rustc_public/src/visitor.rs
new file mode 100644
index 00000000000..45e2a815470
--- /dev/null
+++ b/compiler/rustc_public/src/visitor.rs
@@ -0,0 +1,224 @@
+use std::ops::ControlFlow;
+
+use super::ty::{
+    Allocation, Binder, ConstDef, ExistentialPredicate, FnSig, GenericArgKind, GenericArgs,
+    MirConst, Promoted, Region, RigidTy, TermKind, Ty, UnevaluatedConst,
+};
+use crate::Opaque;
+use crate::ty::TyConst;
+
+pub trait Visitor: Sized {
+    type Break;
+    fn visit_ty(&mut self, ty: &Ty) -> ControlFlow<Self::Break> {
+        ty.super_visit(self)
+    }
+    fn visit_const(&mut self, c: &TyConst) -> ControlFlow<Self::Break> {
+        c.super_visit(self)
+    }
+    fn visit_reg(&mut self, reg: &Region) -> ControlFlow<Self::Break> {
+        reg.super_visit(self)
+    }
+}
+
+pub trait Visitable {
+    fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        self.super_visit(visitor)
+    }
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break>;
+}
+
+impl Visitable for Ty {
+    fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        visitor.visit_ty(self)
+    }
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        match self.kind() {
+            super::ty::TyKind::RigidTy(ty) => ty.visit(visitor)?,
+            super::ty::TyKind::Alias(_, alias) => alias.args.visit(visitor)?,
+            super::ty::TyKind::Param(_) | super::ty::TyKind::Bound(_, _) => {}
+        }
+        ControlFlow::Continue(())
+    }
+}
+
+impl Visitable for TyConst {
+    fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        visitor.visit_const(self)
+    }
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        match &self.kind {
+            super::ty::TyConstKind::Param(_) | super::ty::TyConstKind::Bound(_, _) => {}
+            super::ty::TyConstKind::Unevaluated(_, args) => args.visit(visitor)?,
+            super::ty::TyConstKind::Value(ty, alloc) => {
+                alloc.visit(visitor)?;
+                ty.visit(visitor)?;
+            }
+            super::ty::TyConstKind::ZSTValue(ty) => ty.visit(visitor)?,
+        }
+        ControlFlow::Continue(())
+    }
+}
+
+impl Visitable for MirConst {
+    fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        self.super_visit(visitor)
+    }
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        match &self.kind() {
+            super::ty::ConstantKind::Ty(ct) => ct.visit(visitor)?,
+            super::ty::ConstantKind::Allocated(alloc) => alloc.visit(visitor)?,
+            super::ty::ConstantKind::Unevaluated(uv) => uv.visit(visitor)?,
+            super::ty::ConstantKind::Param(_) | super::ty::ConstantKind::ZeroSized => {}
+        }
+        self.ty().visit(visitor)
+    }
+}
+
+impl Visitable for Opaque {
+    fn super_visit<V: Visitor>(&self, _visitor: &mut V) -> ControlFlow<V::Break> {
+        ControlFlow::Continue(())
+    }
+}
+
+impl Visitable for Allocation {
+    fn super_visit<V: Visitor>(&self, _visitor: &mut V) -> ControlFlow<V::Break> {
+        ControlFlow::Continue(())
+    }
+}
+
+impl Visitable for UnevaluatedConst {
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        let UnevaluatedConst { def, args, promoted } = self;
+        def.visit(visitor)?;
+        args.visit(visitor)?;
+        promoted.visit(visitor)
+    }
+}
+
+impl Visitable for ConstDef {
+    fn super_visit<V: Visitor>(&self, _visitor: &mut V) -> ControlFlow<V::Break> {
+        ControlFlow::Continue(())
+    }
+}
+
+impl<T: Visitable> Visitable for Option<T> {
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        match self {
+            Some(val) => val.visit(visitor),
+            None => ControlFlow::Continue(()),
+        }
+    }
+}
+
+impl Visitable for Promoted {
+    fn super_visit<V: Visitor>(&self, _visitor: &mut V) -> ControlFlow<V::Break> {
+        ControlFlow::Continue(())
+    }
+}
+
+impl Visitable for GenericArgs {
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        self.0.visit(visitor)
+    }
+}
+
+impl Visitable for Region {
+    fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        visitor.visit_reg(self)
+    }
+
+    fn super_visit<V: Visitor>(&self, _: &mut V) -> ControlFlow<V::Break> {
+        ControlFlow::Continue(())
+    }
+}
+
+impl Visitable for GenericArgKind {
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        match self {
+            GenericArgKind::Lifetime(lt) => lt.visit(visitor),
+            GenericArgKind::Type(t) => t.visit(visitor),
+            GenericArgKind::Const(c) => c.visit(visitor),
+        }
+    }
+}
+
+impl Visitable for RigidTy {
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        match self {
+            RigidTy::Bool
+            | RigidTy::Char
+            | RigidTy::Int(_)
+            | RigidTy::Uint(_)
+            | RigidTy::Float(_)
+            | RigidTy::Never
+            | RigidTy::Foreign(_)
+            | RigidTy::Str => ControlFlow::Continue(()),
+            RigidTy::Array(t, c) => {
+                t.visit(visitor)?;
+                c.visit(visitor)
+            }
+            RigidTy::Pat(t, _p) => t.visit(visitor),
+            RigidTy::Slice(inner) => inner.visit(visitor),
+            RigidTy::RawPtr(ty, _) => ty.visit(visitor),
+            RigidTy::Ref(reg, ty, _) => {
+                reg.visit(visitor)?;
+                ty.visit(visitor)
+            }
+            RigidTy::Adt(_, args)
+            | RigidTy::Closure(_, args)
+            | RigidTy::Coroutine(_, args, _)
+            | RigidTy::CoroutineWitness(_, args)
+            | RigidTy::CoroutineClosure(_, args)
+            | RigidTy::FnDef(_, args) => args.visit(visitor),
+            RigidTy::FnPtr(sig) => sig.visit(visitor),
+            RigidTy::Dynamic(pred, r, _) => {
+                pred.visit(visitor)?;
+                r.visit(visitor)
+            }
+            RigidTy::Tuple(fields) => fields.visit(visitor),
+        }
+    }
+}
+
+impl<T: Visitable> Visitable for Vec<T> {
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        for arg in self {
+            arg.visit(visitor)?;
+        }
+        ControlFlow::Continue(())
+    }
+}
+
+impl<T: Visitable> Visitable for Binder<T> {
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        self.value.visit(visitor)
+    }
+}
+
+impl Visitable for ExistentialPredicate {
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        match self {
+            ExistentialPredicate::Trait(tr) => tr.generic_args.visit(visitor),
+            ExistentialPredicate::Projection(p) => {
+                p.term.visit(visitor)?;
+                p.generic_args.visit(visitor)
+            }
+            ExistentialPredicate::AutoTrait(_) => ControlFlow::Continue(()),
+        }
+    }
+}
+
+impl Visitable for TermKind {
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        match self {
+            TermKind::Type(t) => t.visit(visitor),
+            TermKind::Const(c) => c.visit(visitor),
+        }
+    }
+}
+
+impl Visitable for FnSig {
+    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+        self.inputs_and_output.visit(visitor)
+    }
+}
diff --git a/compiler/rustc_public_bridge/.gitignore b/compiler/rustc_public_bridge/.gitignore
new file mode 100644
index 00000000000..eb5a316cbd1
--- /dev/null
+++ b/compiler/rustc_public_bridge/.gitignore
@@ -0,0 +1 @@
+target
diff --git a/compiler/rustc_public_bridge/Cargo.toml b/compiler/rustc_public_bridge/Cargo.toml
new file mode 100644
index 00000000000..918de4a393c
--- /dev/null
+++ b/compiler/rustc_public_bridge/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "rustc_public_bridge"
+version = "0.0.0"
+edition = "2024"
+
+[dependencies]
+# tidy-alphabetical-start
+rustc_abi = { path = "../rustc_abi" }
+rustc_data_structures = { path = "../rustc_data_structures" }
+rustc_hir = { path = "../rustc_hir" }
+rustc_hir_pretty = { path = "../rustc_hir_pretty" }
+rustc_middle = { path = "../rustc_middle" }
+rustc_session = { path = "../rustc_session" }
+rustc_span = { path = "../rustc_span" }
+rustc_target = { path = "../rustc_target" }
+# tidy-alphabetical-end
diff --git a/compiler/rustc_public_bridge/src/alloc.rs b/compiler/rustc_public_bridge/src/alloc.rs
new file mode 100644
index 00000000000..23bbaddce06
--- /dev/null
+++ b/compiler/rustc_public_bridge/src/alloc.rs
@@ -0,0 +1,101 @@
+//! Internal memory allocator implementation for StableMIR.
+//!
+//! This module handles all direct interactions with rustc queries and performs
+//! the actual memory allocations. The stable interface in `rustc_public::alloc`
+//! delegates all query-related operations to this implementation.
+
+use rustc_abi::{Size, TyAndLayout};
+use rustc_middle::mir::interpret::{
+    AllocId, AllocInit, AllocRange, Allocation, ConstAllocation, Pointer, Scalar, alloc_range,
+};
+use rustc_middle::ty::{Ty, layout};
+
+use super::{SmirCtxt, Tables};
+use crate::bridge::Allocation as _;
+use crate::{Bridge, SmirError};
+
+pub fn create_ty_and_layout<'tcx, B: Bridge>(
+    cx: &SmirCtxt<'tcx, B>,
+    ty: Ty<'tcx>,
+) -> Result<TyAndLayout<'tcx, Ty<'tcx>>, &'tcx layout::LayoutError<'tcx>> {
+    use crate::context::SmirTypingEnv;
+    cx.tcx.layout_of(cx.fully_monomorphized().as_query_input(ty))
+}
+
+pub fn try_new_scalar<'tcx, B: Bridge>(
+    layout: TyAndLayout<'tcx, Ty<'tcx>>,
+    scalar: Scalar,
+    cx: &SmirCtxt<'tcx, B>,
+) -> Result<Allocation, B::Error> {
+    let size = scalar.size();
+    let mut allocation = Allocation::new(size, layout.align.abi, AllocInit::Uninit, ());
+    allocation
+        .write_scalar(&cx.tcx, alloc_range(Size::ZERO, size), scalar)
+        .map_err(|e| B::Error::from_internal(e))?;
+
+    Ok(allocation)
+}
+
+pub fn try_new_slice<'tcx, B: Bridge>(
+    layout: TyAndLayout<'tcx, Ty<'tcx>>,
+    data: ConstAllocation<'tcx>,
+    meta: u64,
+    cx: &SmirCtxt<'tcx, B>,
+) -> Result<Allocation, B::Error> {
+    let alloc_id = cx.tcx.reserve_and_set_memory_alloc(data);
+    let ptr = Pointer::new(alloc_id.into(), Size::ZERO);
+    let scalar_ptr = Scalar::from_pointer(ptr, &cx.tcx);
+    let scalar_meta: Scalar = Scalar::from_target_usize(meta, &cx.tcx);
+    let mut allocation = Allocation::new(layout.size, layout.align.abi, AllocInit::Uninit, ());
+    let ptr_size = cx.tcx.data_layout.pointer_size();
+    allocation
+        .write_scalar(&cx.tcx, alloc_range(Size::ZERO, ptr_size), scalar_ptr)
+        .map_err(|e| B::Error::from_internal(e))?;
+    allocation
+        .write_scalar(&cx.tcx, alloc_range(ptr_size, scalar_meta.size()), scalar_meta)
+        .map_err(|e| B::Error::from_internal(e))?;
+
+    Ok(allocation)
+}
+
+pub fn try_new_indirect<'tcx, B: Bridge>(
+    alloc_id: AllocId,
+    cx: &SmirCtxt<'tcx, B>,
+) -> ConstAllocation<'tcx> {
+    let alloc = cx.tcx.global_alloc(alloc_id).unwrap_memory();
+
+    alloc
+}
+
+/// Creates an `Allocation` only from information within the `AllocRange`.
+pub fn allocation_filter<'tcx, B: Bridge>(
+    alloc: &rustc_middle::mir::interpret::Allocation,
+    alloc_range: AllocRange,
+    tables: &mut Tables<'tcx, B>,
+    cx: &SmirCtxt<'tcx, B>,
+) -> B::Allocation {
+    let mut bytes: Vec<Option<u8>> = alloc
+        .inspect_with_uninit_and_ptr_outside_interpreter(
+            alloc_range.start.bytes_usize()..alloc_range.end().bytes_usize(),
+        )
+        .iter()
+        .copied()
+        .map(Some)
+        .collect();
+    for (i, b) in bytes.iter_mut().enumerate() {
+        if !alloc.init_mask().get(Size::from_bytes(i + alloc_range.start.bytes_usize())) {
+            *b = None;
+        }
+    }
+    let mut ptrs = Vec::new();
+    for (offset, prov) in alloc
+        .provenance()
+        .ptrs()
+        .iter()
+        .filter(|a| a.0 >= alloc_range.start && a.0 <= alloc_range.end())
+    {
+        ptrs.push((offset.bytes_usize() - alloc_range.start.bytes_usize(), prov.alloc_id()));
+    }
+
+    B::Allocation::new(bytes, ptrs, alloc.align.bytes(), alloc.mutability, tables, cx)
+}
diff --git a/compiler/rustc_public_bridge/src/bridge.rs b/compiler/rustc_public_bridge/src/bridge.rs
new file mode 100644
index 00000000000..379a8da5df9
--- /dev/null
+++ b/compiler/rustc_public_bridge/src/bridge.rs
@@ -0,0 +1,59 @@
+//! Defines a set of traits that is used for abstracting
+//! rustc_public's components that are needed in rustc_public_bridge.
+//!
+//! These traits are really useful when programming
+//! in rustc_public-agnostic settings.
+
+use std::fmt::Debug;
+
+use super::context::SmirCtxt;
+use super::{Bridge, Tables};
+
+pub trait SmirError {
+    fn new(msg: String) -> Self;
+    fn from_internal<T: Debug>(err: T) -> Self;
+}
+
+pub trait Prov<B: Bridge> {
+    fn new(aid: B::AllocId) -> Self;
+}
+
+pub trait Allocation<B: Bridge> {
+    fn new<'tcx>(
+        bytes: Vec<Option<u8>>,
+        ptrs: Vec<(usize, rustc_middle::mir::interpret::AllocId)>,
+        align: u64,
+        mutability: rustc_middle::mir::Mutability,
+        tables: &mut Tables<'tcx, B>,
+        cx: &SmirCtxt<'tcx, B>,
+    ) -> Self;
+}
+
+macro_rules! make_bridge_trait {
+    ($name:ident) => {
+        pub trait $name<B: Bridge> {
+            fn new(did: B::DefId) -> Self;
+        }
+    };
+}
+
+make_bridge_trait!(CrateItem);
+make_bridge_trait!(AdtDef);
+make_bridge_trait!(ForeignModuleDef);
+make_bridge_trait!(ForeignDef);
+make_bridge_trait!(FnDef);
+make_bridge_trait!(ClosureDef);
+make_bridge_trait!(CoroutineDef);
+make_bridge_trait!(CoroutineClosureDef);
+make_bridge_trait!(AliasDef);
+make_bridge_trait!(ParamDef);
+make_bridge_trait!(BrNamedDef);
+make_bridge_trait!(TraitDef);
+make_bridge_trait!(GenericDef);
+make_bridge_trait!(ConstDef);
+make_bridge_trait!(ImplDef);
+make_bridge_trait!(RegionDef);
+make_bridge_trait!(CoroutineWitnessDef);
+make_bridge_trait!(AssocDef);
+make_bridge_trait!(OpaqueDef);
+make_bridge_trait!(StaticDef);
diff --git a/compiler/rustc_public_bridge/src/builder.rs b/compiler/rustc_public_bridge/src/builder.rs
new file mode 100644
index 00000000000..2141053d09a
--- /dev/null
+++ b/compiler/rustc_public_bridge/src/builder.rs
@@ -0,0 +1,77 @@
+//! Logic required to produce a monomorphic stable body.
+//!
+//! We first retrieve and monomorphize the rustc body representation, i.e., we generate a
+//! monomorphic body using internal representation.
+//! After that, we convert the internal representation into a stable one.
+
+use rustc_hir::def::DefKind;
+use rustc_middle::mir;
+use rustc_middle::mir::visit::MutVisitor;
+use rustc_middle::ty::{self, TyCtxt};
+
+/// Builds a monomorphic body for a given instance.
+pub(crate) struct BodyBuilder<'tcx> {
+    tcx: TyCtxt<'tcx>,
+    instance: ty::Instance<'tcx>,
+}
+
+impl<'tcx> BodyBuilder<'tcx> {
+    pub(crate) fn new(tcx: TyCtxt<'tcx>, instance: ty::Instance<'tcx>) -> Self {
+        let instance = match instance.def {
+            // To get the fallback body of an intrinsic, we need to convert it to an item.
+            ty::InstanceKind::Intrinsic(def_id) => ty::Instance::new_raw(def_id, instance.args),
+            _ => instance,
+        };
+        BodyBuilder { tcx, instance }
+    }
+
+    /// Build a stable monomorphic body for a given instance based on the MIR body.
+    ///
+    /// All constants are also evaluated.
+    pub(crate) fn build(mut self) -> mir::Body<'tcx> {
+        let body = self.tcx.instance_mir(self.instance.def).clone();
+        let mono_body = if !self.instance.args.is_empty()
+            // Without the `generic_const_exprs` feature gate, anon consts in signatures do not
+            // get generic parameters. Which is wrong, but also not a problem without
+            // generic_const_exprs
+            || self.tcx.def_kind(self.instance.def_id()) != DefKind::AnonConst
+        {
+            let mut mono_body = self.instance.instantiate_mir_and_normalize_erasing_regions(
+                self.tcx,
+                ty::TypingEnv::fully_monomorphized(),
+                ty::EarlyBinder::bind(body),
+            );
+            self.visit_body(&mut mono_body);
+            mono_body
+        } else {
+            // Already monomorphic.
+            body
+        };
+
+        mono_body
+    }
+}
+
+impl<'tcx> MutVisitor<'tcx> for BodyBuilder<'tcx> {
+    fn visit_const_operand(
+        &mut self,
+        constant: &mut mir::ConstOperand<'tcx>,
+        location: mir::Location,
+    ) {
+        let const_ = constant.const_;
+        let val = match const_.eval(self.tcx, ty::TypingEnv::fully_monomorphized(), constant.span) {
+            Ok(v) => v,
+            Err(mir::interpret::ErrorHandled::Reported(..)) => return,
+            Err(mir::interpret::ErrorHandled::TooGeneric(..)) => {
+                unreachable!("Failed to evaluate instance constant: {:?}", const_)
+            }
+        };
+        let ty = constant.ty();
+        constant.const_ = mir::Const::Val(val, ty);
+        self.super_const_operand(constant, location);
+    }
+
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+}
diff --git a/compiler/rustc_public_bridge/src/context/impls.rs b/compiler/rustc_public_bridge/src/context/impls.rs
new file mode 100644
index 00000000000..fdefad2821b
--- /dev/null
+++ b/compiler/rustc_public_bridge/src/context/impls.rs
@@ -0,0 +1,759 @@
+//! Implementation of StableMIR Context.
+
+#![allow(rustc::usage_of_qualified_ty)]
+
+use std::iter;
+
+use rustc_abi::{Endian, Layout, ReprOptions};
+use rustc_hir::def::DefKind;
+use rustc_hir::{Attribute, LangItem};
+use rustc_middle::mir::interpret::{AllocId, ConstAllocation, ErrorHandled, GlobalAlloc, Scalar};
+use rustc_middle::mir::{BinOp, Body, Const as MirConst, ConstValue, UnOp};
+use rustc_middle::ty::layout::{FnAbiOf, LayoutOf};
+use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths};
+use rustc_middle::ty::util::Discr;
+use rustc_middle::ty::{
+    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,
+};
+use rustc_middle::{mir, ty};
+use rustc_session::cstore::ForeignModule;
+use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE};
+use rustc_span::{FileNameDisplayPreference, Span, Symbol};
+use rustc_target::callconv::FnAbi;
+
+use super::{SmirAllocRange, SmirCtxt, SmirTy, SmirTypingEnv};
+use crate::builder::BodyBuilder;
+use crate::{Bridge, SmirError, Tables, filter_def_ids};
+
+impl<'tcx, B: Bridge> SmirTy<'tcx> for SmirCtxt<'tcx, B> {
+    fn new_foreign(&self, def_id: DefId) -> ty::Ty<'tcx> {
+        ty::Ty::new_foreign(self.tcx, def_id)
+    }
+}
+
+impl<'tcx, B: Bridge> SmirTypingEnv<'tcx> for SmirCtxt<'tcx, B> {
+    fn fully_monomorphized(&self) -> ty::TypingEnv<'tcx> {
+        ty::TypingEnv::fully_monomorphized()
+    }
+}
+
+impl<'tcx, B: Bridge> SmirAllocRange<'tcx> for SmirCtxt<'tcx, B> {
+    fn alloc_range(
+        &self,
+        offset: rustc_abi::Size,
+        size: rustc_abi::Size,
+    ) -> mir::interpret::AllocRange {
+        rustc_middle::mir::interpret::alloc_range(offset, size)
+    }
+}
+
+impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
+    pub fn lift<T: ty::Lift<TyCtxt<'tcx>>>(&self, value: T) -> Option<T::Lifted> {
+        self.tcx.lift(value)
+    }
+
+    pub fn adt_def(&self, def_id: DefId) -> AdtDef<'tcx> {
+        self.tcx.adt_def(def_id)
+    }
+
+    pub fn coroutine_movability(&self, def_id: DefId) -> ty::Movability {
+        self.tcx.coroutine_movability(def_id)
+    }
+
+    pub fn valtree_to_const_val(&self, key: ty::Value<'tcx>) -> ConstValue<'tcx> {
+        self.tcx.valtree_to_const_val(key)
+    }
+
+    /// Return whether the instance as a body available.
+    ///
+    /// Items and intrinsics may have a body available from its definition.
+    /// Shims body may be generated depending on their type.
+    pub(crate) fn instance_has_body(&self, instance: Instance<'tcx>) -> bool {
+        let def_id = instance.def_id();
+        self.item_has_body(def_id)
+            || !matches!(
+                instance.def,
+                ty::InstanceKind::Virtual(..)
+                    | ty::InstanceKind::Intrinsic(..)
+                    | ty::InstanceKind::Item(..)
+            )
+    }
+
+    /// Return whether the item has a body defined by the user.
+    ///
+    /// Note that intrinsics may have a placeholder body that shouldn't be used in practice.
+    /// In StableMIR, we handle this case as if the body is not available.
+    pub(crate) fn item_has_body(&self, def_id: DefId) -> bool {
+        let must_override = if let Some(intrinsic) = self.tcx.intrinsic(def_id) {
+            intrinsic.must_be_overridden
+        } else {
+            false
+        };
+        !must_override && self.tcx.is_mir_available(def_id)
+    }
+
+    fn filter_fn_def(&self, def_id: DefId) -> Option<DefId> {
+        if matches!(self.tcx.def_kind(def_id), DefKind::Fn | DefKind::AssocFn) {
+            Some(def_id)
+        } else {
+            None
+        }
+    }
+
+    fn filter_static_def(&self, def_id: DefId) -> Option<DefId> {
+        matches!(self.tcx.def_kind(def_id), DefKind::Static { .. }).then(|| def_id)
+    }
+
+    pub fn target_endian(&self) -> Endian {
+        self.tcx.data_layout.endian
+    }
+
+    pub fn target_pointer_size(&self) -> usize {
+        self.tcx.data_layout.pointer_size().bits().try_into().unwrap()
+    }
+
+    pub fn entry_fn(&self) -> Option<DefId> {
+        Some(self.tcx.entry_fn(())?.0)
+    }
+
+    /// Retrieve all items of the local crate that have a MIR associated with them.
+    pub fn all_local_items(&self) -> Vec<DefId> {
+        self.tcx.mir_keys(()).iter().map(|item| item.to_def_id()).collect()
+    }
+
+    /// Retrieve the body of a function.
+    /// This function will panic if the body is not available.
+    pub fn mir_body(&self, item: DefId) -> &'tcx Body<'tcx> {
+        self.tcx.instance_mir(InstanceKind::Item(item))
+    }
+
+    /// Check whether the body of a function is available.
+    pub fn has_body(&self, def: DefId) -> bool {
+        self.item_has_body(def)
+    }
+
+    pub fn foreign_modules(&self, crate_num: CrateNum) -> Vec<DefId> {
+        self.tcx.foreign_modules(crate_num).keys().map(|mod_def_id| *mod_def_id).collect()
+    }
+
+    /// Retrieve all functions defined in this crate.
+    pub fn crate_functions(&self, crate_num: CrateNum) -> Vec<DefId> {
+        filter_def_ids(self.tcx, crate_num, |def_id| self.filter_fn_def(def_id))
+    }
+
+    /// Retrieve all static items defined in this crate.
+    pub fn crate_statics(&self, crate_num: CrateNum) -> Vec<DefId> {
+        filter_def_ids(self.tcx, crate_num, |def_id| self.filter_static_def(def_id))
+    }
+
+    pub fn foreign_module(&self, mod_def: DefId) -> &ForeignModule {
+        self.tcx.foreign_modules(mod_def.krate).get(&mod_def).unwrap()
+    }
+
+    pub fn foreign_items(&self, mod_def: DefId) -> Vec<DefId> {
+        self.tcx
+            .foreign_modules(mod_def.krate)
+            .get(&mod_def)
+            .unwrap()
+            .foreign_items
+            .iter()
+            .map(|item_def| *item_def)
+            .collect()
+    }
+
+    pub fn all_trait_decls(&self) -> impl Iterator<Item = DefId> {
+        self.tcx.all_traits_including_private()
+    }
+
+    pub fn trait_decls(&self, crate_num: CrateNum) -> Vec<DefId> {
+        self.tcx.traits(crate_num).iter().map(|trait_def_id| *trait_def_id).collect()
+    }
+
+    pub fn trait_decl(&self, trait_def: DefId) -> &'tcx TraitDef {
+        self.tcx.trait_def(trait_def)
+    }
+
+    pub fn all_trait_impls(&self) -> Vec<DefId> {
+        iter::once(LOCAL_CRATE)
+            .chain(self.tcx.crates(()).iter().copied())
+            .flat_map(|cnum| self.tcx.trait_impls_in_crate(cnum).iter())
+            .map(|impl_def_id| *impl_def_id)
+            .collect()
+    }
+
+    pub fn trait_impls(&self, crate_num: CrateNum) -> Vec<DefId> {
+        self.tcx.trait_impls_in_crate(crate_num).iter().map(|impl_def_id| *impl_def_id).collect()
+    }
+
+    pub fn trait_impl(&self, impl_def: DefId) -> EarlyBinder<'tcx, TraitRef<'tcx>> {
+        self.tcx.impl_trait_ref(impl_def).unwrap()
+    }
+
+    pub fn generics_of(&self, def_id: DefId) -> &'tcx ty::Generics {
+        self.tcx.generics_of(def_id)
+    }
+
+    pub fn predicates_of(
+        &self,
+        def_id: DefId,
+    ) -> (Option<DefId>, Vec<(ty::PredicateKind<'tcx>, Span)>) {
+        let ty::GenericPredicates { parent, predicates } = self.tcx.predicates_of(def_id);
+        (
+            parent,
+            predicates
+                .iter()
+                .map(|(clause, span)| (clause.as_predicate().kind().skip_binder(), *span))
+                .collect(),
+        )
+    }
+
+    pub fn explicit_predicates_of(
+        &self,
+        def_id: DefId,
+    ) -> (Option<DefId>, Vec<(ty::PredicateKind<'tcx>, Span)>) {
+        let ty::GenericPredicates { parent, predicates } = self.tcx.explicit_predicates_of(def_id);
+        (
+            parent,
+            predicates
+                .iter()
+                .map(|(clause, span)| (clause.as_predicate().kind().skip_binder(), *span))
+                .collect(),
+        )
+    }
+
+    pub fn crate_name(&self, crate_num: CrateNum) -> String {
+        self.tcx.crate_name(crate_num).to_string()
+    }
+
+    pub fn crate_is_local(&self, crate_num: CrateNum) -> bool {
+        crate_num == LOCAL_CRATE
+    }
+
+    pub fn crate_num_id(&self, crate_num: CrateNum) -> usize {
+        crate_num.into()
+    }
+
+    pub fn local_crate_num(&self) -> CrateNum {
+        LOCAL_CRATE
+    }
+
+    /// Retrieve a list of all external crates.
+    pub fn external_crates(&self) -> Vec<CrateNum> {
+        self.tcx.crates(()).iter().map(|crate_num| *crate_num).collect()
+    }
+
+    /// Find a crate with the given name.
+    pub fn find_crates(&self, name: &str) -> Vec<CrateNum> {
+        let crates: Vec<CrateNum> = [LOCAL_CRATE]
+            .iter()
+            .chain(self.tcx.crates(()).iter())
+            .filter_map(|crate_num| {
+                let crate_name = self.tcx.crate_name(*crate_num).to_string();
+                (name == crate_name).then(|| *crate_num)
+            })
+            .collect();
+        crates
+    }
+
+    /// Returns the name of given `DefId`.
+    pub fn def_name(&self, def_id: DefId, trimmed: bool) -> String {
+        if trimmed {
+            with_forced_trimmed_paths!(self.tcx.def_path_str(def_id))
+        } else {
+            with_no_trimmed_paths!(self.tcx.def_path_str(def_id))
+        }
+    }
+
+    /// Return registered tool attributes with the given attribute name.
+    ///
+    /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool
+    /// attributes will simply return an empty list.
+    ///
+    /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`.
+    /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`.
+    pub fn tool_attrs(&self, def_id: DefId, attr: &[String]) -> Vec<(String, Span)> {
+        let attr_name: Vec<_> = attr.iter().map(|seg| Symbol::intern(&seg)).collect();
+        self.tcx
+            .get_attrs_by_path(def_id, &attr_name)
+            .filter_map(|attribute| {
+                if let Attribute::Unparsed(u) = attribute {
+                    let attr_str = rustc_hir_pretty::attribute_to_string(&self.tcx, attribute);
+                    Some((attr_str, u.span))
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
+    /// Get all tool attributes of a definition.
+    pub fn all_tool_attrs(&self, did: DefId) -> Vec<(String, Span)> {
+        let attrs_iter = if let Some(did) = did.as_local() {
+            self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(did)).iter()
+        } else {
+            self.tcx.attrs_for_def(did).iter()
+        };
+        attrs_iter
+            .filter_map(|attribute| {
+                if let Attribute::Unparsed(u) = attribute {
+                    let attr_str = rustc_hir_pretty::attribute_to_string(&self.tcx, attribute);
+                    Some((attr_str, u.span))
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
+    /// Returns printable, human readable form of `Span`.
+    pub fn span_to_string(&self, span: Span) -> String {
+        self.tcx.sess.source_map().span_to_diagnostic_string(span)
+    }
+
+    /// Return filename from given `Span`, for diagnostic purposes.
+    pub fn get_filename(&self, span: Span) -> String {
+        self.tcx
+            .sess
+            .source_map()
+            .span_to_filename(span)
+            .display(FileNameDisplayPreference::Local)
+            .to_string()
+    }
+
+    /// Return lines corresponding to this `Span`.
+    pub fn get_lines(&self, span: Span) -> (usize, usize, usize, usize) {
+        let lines = &self.tcx.sess.source_map().span_to_location_info(span);
+        (lines.1, lines.2, lines.3, lines.4)
+    }
+
+    /// Returns the `kind` of given `DefId`.
+    pub fn def_kind(&self, item: DefId) -> DefKind {
+        self.tcx.def_kind(item)
+    }
+
+    /// Returns whether this is a foreign item.
+    pub fn is_foreign_item(&self, item: DefId) -> bool {
+        self.tcx.is_foreign_item(item)
+    }
+
+    /// Returns the kind of a given foreign item.
+    pub fn foreign_item_kind(&self, def_id: DefId) -> DefKind {
+        self.tcx.def_kind(def_id)
+    }
+
+    /// Returns the kind of a given algebraic data type.
+    pub fn adt_kind(&self, def: AdtDef<'tcx>) -> AdtKind {
+        def.adt_kind()
+    }
+
+    /// Returns if the ADT is a box.
+    pub fn adt_is_box(&self, def: AdtDef<'tcx>) -> bool {
+        def.is_box()
+    }
+
+    /// Returns whether this ADT is simd.
+    pub fn adt_is_simd(&self, def: AdtDef<'tcx>) -> bool {
+        def.repr().simd()
+    }
+
+    /// Returns whether this definition is a C string.
+    pub fn adt_is_cstr(&self, def_id: DefId) -> bool {
+        self.tcx.is_lang_item(def_id, LangItem::CStr)
+    }
+
+    /// Returns the representation options for this ADT.
+    pub fn adt_repr(&self, def: AdtDef<'tcx>) -> ReprOptions {
+        def.repr()
+    }
+
+    /// Retrieve the function signature for the given generic arguments.
+    pub fn fn_sig(
+        &self,
+        def_id: DefId,
+        args_ref: GenericArgsRef<'tcx>,
+    ) -> Binder<'tcx, FnSig<'tcx>> {
+        let sig = self.tcx.fn_sig(def_id).instantiate(self.tcx, args_ref);
+        sig
+    }
+
+    /// Retrieve the intrinsic definition if the item corresponds one.
+    pub fn intrinsic(&self, def_id: DefId) -> Option<IntrinsicDef> {
+        let intrinsic = self.tcx.intrinsic_raw(def_id);
+        intrinsic
+    }
+
+    /// Retrieve the plain function name of an intrinsic.
+    pub fn intrinsic_name(&self, def_id: DefId) -> String {
+        self.tcx.intrinsic(def_id).unwrap().name.to_string()
+    }
+
+    /// Retrieve the closure signature for the given generic arguments.
+    pub fn closure_sig(&self, args_ref: GenericArgsRef<'tcx>) -> Binder<'tcx, FnSig<'tcx>> {
+        args_ref.as_closure().sig()
+    }
+
+    /// The number of variants in this ADT.
+    pub fn adt_variants_len(&self, def: AdtDef<'tcx>) -> usize {
+        def.variants().len()
+    }
+
+    /// Discriminant for a given variant index of AdtDef.
+    pub fn adt_discr_for_variant(
+        &self,
+        adt: AdtDef<'tcx>,
+        variant: rustc_abi::VariantIdx,
+    ) -> Discr<'tcx> {
+        adt.discriminant_for_variant(self.tcx, variant)
+    }
+
+    /// Discriminant for a given variand index and args of a coroutine.
+    pub fn coroutine_discr_for_variant(
+        &self,
+        coroutine: DefId,
+        args: GenericArgsRef<'tcx>,
+        variant: rustc_abi::VariantIdx,
+    ) -> Discr<'tcx> {
+        args.as_coroutine().discriminant_for_variant(coroutine, self.tcx, variant)
+    }
+
+    /// The name of a variant.
+    pub fn variant_name(&self, def: &'tcx VariantDef) -> String {
+        def.name.to_string()
+    }
+
+    /// Evaluate constant as a target usize.
+    pub fn eval_target_usize(&self, cnst: MirConst<'tcx>) -> Result<u64, B::Error> {
+        use crate::context::SmirTypingEnv;
+        cnst.try_eval_target_usize(self.tcx, self.fully_monomorphized())
+            .ok_or_else(|| B::Error::new(format!("Const `{cnst:?}` cannot be encoded as u64")))
+    }
+
+    pub fn eval_target_usize_ty(&self, cnst: ty::Const<'tcx>) -> Result<u64, B::Error> {
+        cnst.try_to_target_usize(self.tcx)
+            .ok_or_else(|| B::Error::new(format!("Const `{cnst:?}` cannot be encoded as u64")))
+    }
+
+    pub fn try_new_const_zst(&self, ty_internal: Ty<'tcx>) -> Result<MirConst<'tcx>, B::Error> {
+        let size = self
+            .tcx
+            .layout_of(self.fully_monomorphized().as_query_input(ty_internal))
+            .map_err(|err| {
+                B::Error::new(format!(
+                    "Cannot create a zero-sized constant for type `{ty_internal}`: {err}"
+                ))
+            })?
+            .size;
+        if size.bytes() != 0 {
+            return Err(B::Error::new(format!(
+                "Cannot create a zero-sized constant for type `{ty_internal}`: \
+                Type `{ty_internal}` has {} bytes",
+                size.bytes()
+            )));
+        }
+
+        Ok(MirConst::Ty(ty_internal, self.const_zero_sized(ty_internal)))
+    }
+
+    pub fn const_zero_sized(&self, ty_internal: Ty<'tcx>) -> ty::Const<'tcx> {
+        ty::Const::zero_sized(self.tcx, ty_internal)
+    }
+
+    /// Create a new constant that represents the given string value.
+    pub fn new_const_str(&self, value: &str) -> MirConst<'tcx> {
+        let ty = Ty::new_static_str(self.tcx);
+        let bytes = value.as_bytes();
+        let valtree = ValTree::from_raw_bytes(self.tcx, bytes);
+        let cv = ty::Value { ty, valtree };
+        let val = self.tcx.valtree_to_const_val(cv);
+        MirConst::from_value(val, ty)
+    }
+
+    /// Create a new constant that represents the given boolean value.
+    pub fn new_const_bool(&self, value: bool) -> MirConst<'tcx> {
+        MirConst::from_bool(self.tcx, value)
+    }
+
+    pub fn try_new_const_uint(
+        &self,
+        value: u128,
+        ty_internal: Ty<'tcx>,
+    ) -> Result<MirConst<'tcx>, B::Error> {
+        let size = self
+            .tcx
+            .layout_of(self.fully_monomorphized().as_query_input(ty_internal))
+            .unwrap()
+            .size;
+        let scalar = ScalarInt::try_from_uint(value, size).ok_or_else(|| {
+            B::Error::new(format!("Value overflow: cannot convert `{value}` to `{ty_internal}`."))
+        })?;
+        Ok(self.mir_const_from_scalar(Scalar::Int(scalar), ty_internal))
+    }
+
+    pub fn try_new_ty_const_uint(
+        &self,
+        value: u128,
+        ty_internal: Ty<'tcx>,
+    ) -> Result<ty::Const<'tcx>, B::Error> {
+        let size = self
+            .tcx
+            .layout_of(self.fully_monomorphized().as_query_input(ty_internal))
+            .unwrap()
+            .size;
+        let scalar = ScalarInt::try_from_uint(value, size).ok_or_else(|| {
+            B::Error::new(format!("Value overflow: cannot convert `{value}` to `{ty_internal}`."))
+        })?;
+
+        Ok(self.ty_const_new_value(ValTree::from_scalar_int(self.tcx, scalar), ty_internal))
+    }
+
+    pub fn ty_new_uint(&self, ty: UintTy) -> Ty<'tcx> {
+        Ty::new_uint(self.tcx, ty)
+    }
+
+    pub fn mir_const_from_scalar(&self, s: Scalar, ty: Ty<'tcx>) -> MirConst<'tcx> {
+        MirConst::from_scalar(self.tcx, s, ty)
+    }
+
+    pub fn ty_const_new_value(&self, valtree: ValTree<'tcx>, ty: Ty<'tcx>) -> ty::Const<'tcx> {
+        ty::Const::new_value(self.tcx, valtree, ty)
+    }
+
+    pub fn ty_valtree_from_scalar_int(&self, i: ScalarInt) -> ValTree<'tcx> {
+        ValTree::from_scalar_int(self.tcx, i)
+    }
+
+    /// Create a new type from the given kind.
+    pub fn new_rigid_ty(&self, internal_kind: TyKind<'tcx>) -> Ty<'tcx> {
+        self.tcx.mk_ty_from_kind(internal_kind)
+    }
+
+    /// Create a new box type, `Box<T>`, for the given inner type `T`.
+    pub fn new_box_ty(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
+        ty::Ty::new_box(self.tcx, ty)
+    }
+
+    /// Returns the type of given crate item.
+    pub fn def_ty(&self, item: DefId) -> Ty<'tcx> {
+        self.tcx.type_of(item).instantiate_identity()
+    }
+
+    /// Returns the type of given definition instantiated with the given arguments.
+    pub fn def_ty_with_args(&self, item: DefId, args_ref: GenericArgsRef<'tcx>) -> Ty<'tcx> {
+        let def_ty = self.tcx.type_of(item);
+        self.tcx.instantiate_and_normalize_erasing_regions(
+            args_ref,
+            self.fully_monomorphized(),
+            def_ty,
+        )
+    }
+
+    /// `Span` of an item.
+    pub fn span_of_an_item(&self, def_id: DefId) -> Span {
+        self.tcx.def_span(def_id)
+    }
+
+    pub fn ty_const_pretty(&self, ct: ty::Const<'tcx>) -> String {
+        ct.to_string()
+    }
+
+    /// Obtain the representation of a type.
+    pub fn ty_pretty(&self, ty: Ty<'tcx>) -> String {
+        ty.to_string()
+    }
+
+    /// Obtain the kind of a type.
+    pub fn ty_kind(&self, ty: Ty<'tcx>) -> &'tcx TyKind<'tcx> {
+        ty.kind()
+    }
+
+    /// Get the discriminant Ty for this Ty if there's one.
+    pub fn rigid_ty_discriminant_ty(&self, internal_kind: TyKind<'tcx>) -> Ty<'tcx> {
+        let internal_ty = self.tcx.mk_ty_from_kind(internal_kind);
+        internal_ty.discriminant_ty(self.tcx)
+    }
+
+    /// Get the body of an Instance which is already monomorphized.
+    pub fn instance_body(&self, instance: ty::Instance<'tcx>) -> Option<Body<'tcx>> {
+        self.instance_has_body(instance).then(|| BodyBuilder::new(self.tcx, instance).build())
+    }
+
+    /// Get the instance type with generic instantiations applied and lifetimes erased.
+    pub fn instance_ty(&self, instance: ty::Instance<'tcx>) -> Ty<'tcx> {
+        assert!(!instance.has_non_region_param(), "{instance:?} needs further instantiation");
+        instance.ty(self.tcx, self.fully_monomorphized())
+    }
+
+    /// Get the instantiation types.
+    pub fn instance_args(&self, instance: ty::Instance<'tcx>) -> GenericArgsRef<'tcx> {
+        instance.args
+    }
+
+    /// Get an instance ABI.
+    pub fn instance_abi(
+        &self,
+        instance: ty::Instance<'tcx>,
+    ) -> Result<&FnAbi<'tcx, Ty<'tcx>>, B::Error> {
+        Ok(self.fn_abi_of_instance(instance, List::empty())?)
+    }
+
+    /// Get the ABI of a function pointer.
+    pub fn fn_ptr_abi(&self, sig: PolyFnSig<'tcx>) -> Result<&FnAbi<'tcx, Ty<'tcx>>, B::Error> {
+        Ok(self.fn_abi_of_fn_ptr(sig, List::empty())?)
+    }
+
+    /// Get the instance.
+    pub fn instance_def_id(
+        &self,
+        instances: ty::Instance<'tcx>,
+        tables: &mut Tables<'_, B>,
+    ) -> B::DefId {
+        let def_id = instances.def_id();
+        tables.create_def_id(def_id)
+    }
+
+    /// Get the instance mangled name.
+    pub fn instance_mangled_name(&self, instance: ty::Instance<'tcx>) -> String {
+        self.tcx.symbol_name(instance).name.to_string()
+    }
+
+    /// Check if this is an empty DropGlue shim.
+    pub fn is_empty_drop_shim(&self, instance: ty::Instance<'tcx>) -> bool {
+        matches!(instance.def, ty::InstanceKind::DropGlue(_, None))
+    }
+
+    /// Convert a non-generic crate item into an instance.
+    /// This function will panic if the item is generic.
+    pub fn mono_instance(&self, def_id: DefId) -> Instance<'tcx> {
+        Instance::mono(self.tcx, def_id)
+    }
+
+    /// Item requires monomorphization.
+    pub fn requires_monomorphization(&self, def_id: DefId) -> bool {
+        let generics = self.tcx.generics_of(def_id);
+        let result = generics.requires_monomorphization(self.tcx);
+        result
+    }
+
+    /// Resolve an instance from the given function definition and generic arguments.
+    pub fn resolve_instance(
+        &self,
+        def_id: DefId,
+        args_ref: GenericArgsRef<'tcx>,
+    ) -> Option<Instance<'tcx>> {
+        match Instance::try_resolve(self.tcx, self.fully_monomorphized(), def_id, args_ref) {
+            Ok(Some(instance)) => Some(instance),
+            Ok(None) | Err(_) => None,
+        }
+    }
+
+    /// Resolve an instance for drop_in_place for the given type.
+    pub fn resolve_drop_in_place(&self, internal_ty: Ty<'tcx>) -> Instance<'tcx> {
+        let instance = Instance::resolve_drop_in_place(self.tcx, internal_ty);
+        instance
+    }
+
+    /// Resolve instance for a function pointer.
+    pub fn resolve_for_fn_ptr(
+        &self,
+        def_id: DefId,
+        args_ref: GenericArgsRef<'tcx>,
+    ) -> Option<Instance<'tcx>> {
+        Instance::resolve_for_fn_ptr(self.tcx, self.fully_monomorphized(), def_id, args_ref)
+    }
+
+    /// Resolve instance for a closure with the requested type.
+    pub fn resolve_closure(
+        &self,
+        def_id: DefId,
+        args_ref: GenericArgsRef<'tcx>,
+        closure_kind: ClosureKind,
+    ) -> Option<Instance<'tcx>> {
+        Some(Instance::resolve_closure(self.tcx, def_id, args_ref, closure_kind))
+    }
+
+    /// Try to evaluate an instance into a constant.
+    pub fn eval_instance(
+        &self,
+        instance: ty::Instance<'tcx>,
+    ) -> Result<ConstValue<'tcx>, ErrorHandled> {
+        self.tcx.const_eval_instance(
+            self.fully_monomorphized(),
+            instance,
+            self.tcx.def_span(instance.def_id()),
+        )
+    }
+
+    /// Evaluate a static's initializer.
+    pub fn eval_static_initializer(
+        &self,
+        def_id: DefId,
+    ) -> Result<ConstAllocation<'tcx>, ErrorHandled> {
+        self.tcx.eval_static_initializer(def_id)
+    }
+
+    /// Retrieve global allocation for the given allocation ID.
+    pub fn global_alloc(&self, alloc_id: AllocId) -> GlobalAlloc<'tcx> {
+        self.tcx.global_alloc(alloc_id)
+    }
+
+    /// Retrieve the id for the virtual table.
+    pub fn vtable_allocation(
+        &self,
+        ty: Ty<'tcx>,
+        trait_ref: Option<Binder<'tcx, ExistentialTraitRef<'tcx>>>,
+    ) -> AllocId {
+        let alloc_id = self.tcx.vtable_allocation((
+            ty,
+            trait_ref.map(|principal| self.tcx.instantiate_bound_regions_with_erased(principal)),
+        ));
+        alloc_id
+    }
+
+    /// Retrieve the instance name for diagnostic messages.
+    ///
+    /// This will return the specialized name, e.g., `Vec<char>::new`.
+    pub fn instance_name(&self, instance: ty::Instance<'tcx>, trimmed: bool) -> String {
+        if trimmed {
+            with_forced_trimmed_paths!(
+                self.tcx.def_path_str_with_args(instance.def_id(), instance.args)
+            )
+        } else {
+            with_no_trimmed_paths!(
+                self.tcx.def_path_str_with_args(instance.def_id(), instance.args)
+            )
+        }
+    }
+
+    /// Get the layout of a type.
+    pub fn ty_layout(&self, ty: Ty<'tcx>) -> Result<Layout<'tcx>, B::Error> {
+        let layout = self.layout_of(ty)?.layout;
+        Ok(layout)
+    }
+
+    /// Get the resulting type of binary operation.
+    pub fn binop_ty(&self, bin_op: BinOp, rhs: Ty<'tcx>, lhs: Ty<'tcx>) -> Ty<'tcx> {
+        bin_op.ty(self.tcx, rhs, lhs)
+    }
+
+    /// Get the resulting type of unary operation.
+    pub fn unop_ty(&self, un_op: UnOp, arg: Ty<'tcx>) -> Ty<'tcx> {
+        un_op.ty(self.tcx, arg)
+    }
+
+    /// Get all associated items of a definition.
+    pub fn associated_items(&self, def_id: DefId) -> Vec<AssocItem> {
+        let assoc_items = if self.tcx.is_trait_alias(def_id) {
+            Vec::new()
+        } else {
+            self.tcx
+                .associated_item_def_ids(def_id)
+                .iter()
+                .map(|did| self.tcx.associated_item(*did))
+                .collect()
+        };
+        assoc_items
+    }
+}
diff --git a/compiler/rustc_public_bridge/src/context/mod.rs b/compiler/rustc_public_bridge/src/context/mod.rs
new file mode 100644
index 00000000000..da20be2a4b3
--- /dev/null
+++ b/compiler/rustc_public_bridge/src/context/mod.rs
@@ -0,0 +1,79 @@
+//! Implementation of StableMIR Context.
+
+#![allow(rustc::usage_of_qualified_ty)]
+
+use std::marker::PhantomData;
+
+use rustc_abi::HasDataLayout;
+use rustc_middle::ty;
+use rustc_middle::ty::layout::{FnAbiOfHelpers, HasTyCtxt, HasTypingEnv, LayoutOfHelpers};
+use rustc_middle::ty::{Ty, TyCtxt};
+
+use crate::{Bridge, SmirError};
+
+mod impls;
+mod traits;
+
+pub use traits::*;
+
+/// Provides direct access to rustc's internal queries.
+///
+/// `SmirInterface` must go through
+/// this context to obtain rustc-level information.
+pub struct SmirCtxt<'tcx, B: Bridge> {
+    pub tcx: TyCtxt<'tcx>,
+    _marker: PhantomData<B>,
+}
+
+impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
+    pub fn new(tcx: TyCtxt<'tcx>) -> Self {
+        Self { tcx, _marker: Default::default() }
+    }
+}
+
+/// Implement error handling for extracting function ABI information.
+impl<'tcx, B: Bridge> FnAbiOfHelpers<'tcx> for SmirCtxt<'tcx, B> {
+    type FnAbiOfResult = Result<&'tcx rustc_target::callconv::FnAbi<'tcx, Ty<'tcx>>, B::Error>;
+
+    #[inline]
+    fn handle_fn_abi_err(
+        &self,
+        err: ty::layout::FnAbiError<'tcx>,
+        _span: rustc_span::Span,
+        fn_abi_request: ty::layout::FnAbiRequest<'tcx>,
+    ) -> B::Error {
+        B::Error::new(format!("Failed to get ABI for `{fn_abi_request:?}`: {err:?}"))
+    }
+}
+
+impl<'tcx, B: Bridge> LayoutOfHelpers<'tcx> for SmirCtxt<'tcx, B> {
+    type LayoutOfResult = Result<ty::layout::TyAndLayout<'tcx>, B::Error>;
+
+    #[inline]
+    fn handle_layout_err(
+        &self,
+        err: ty::layout::LayoutError<'tcx>,
+        _span: rustc_span::Span,
+        ty: Ty<'tcx>,
+    ) -> B::Error {
+        B::Error::new(format!("Failed to get layout for `{ty}`: {err}"))
+    }
+}
+
+impl<'tcx, B: Bridge> HasTypingEnv<'tcx> for SmirCtxt<'tcx, B> {
+    fn typing_env(&self) -> ty::TypingEnv<'tcx> {
+        ty::TypingEnv::fully_monomorphized()
+    }
+}
+
+impl<'tcx, B: Bridge> HasTyCtxt<'tcx> for SmirCtxt<'tcx, B> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+}
+
+impl<'tcx, B: Bridge> HasDataLayout for SmirCtxt<'tcx, B> {
+    fn data_layout(&self) -> &rustc_abi::TargetDataLayout {
+        self.tcx.data_layout()
+    }
+}
diff --git a/compiler/rustc_public_bridge/src/context/traits.rs b/compiler/rustc_public_bridge/src/context/traits.rs
new file mode 100644
index 00000000000..8483bee4aad
--- /dev/null
+++ b/compiler/rustc_public_bridge/src/context/traits.rs
@@ -0,0 +1,21 @@
+//! A set of traits that define a stable interface to rustc's internals.
+//!
+//! These traits abstract rustc's internal APIs, allowing StableMIR to maintain a stable
+//! interface regardless of internal compiler changes.
+
+use rustc_middle::mir::interpret::AllocRange;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+use rustc_span::def_id::DefId;
+
+pub trait SmirTy<'tcx> {
+    fn new_foreign(&self, def_id: DefId) -> Ty<'tcx>;
+}
+
+pub trait SmirTypingEnv<'tcx> {
+    fn fully_monomorphized(&self) -> ty::TypingEnv<'tcx>;
+}
+
+pub trait SmirAllocRange<'tcx> {
+    fn alloc_range(&self, offset: rustc_abi::Size, size: rustc_abi::Size) -> AllocRange;
+}
diff --git a/compiler/rustc_public_bridge/src/lib.rs b/compiler/rustc_public_bridge/src/lib.rs
new file mode 100644
index 00000000000..652a8093a87
--- /dev/null
+++ b/compiler/rustc_public_bridge/src/lib.rs
@@ -0,0 +1,305 @@
+//! Crate that implements what will become the rustc side of Stable MIR.
+//!
+//! This crate is responsible for building Stable MIR components from internal components.
+//!
+//! This crate is not intended to be invoked directly by users.
+//! This crate is the public API of rustc that will be invoked by the `rustc_public` crate.
+//!
+//! For more information see <https://github.com/rust-lang/project-stable-mir>
+//!
+//! # Note
+//!
+//! This API is still completely unstable and subject to change.
+
+// tidy-alphabetical-start
+#![allow(internal_features)]
+#![allow(rustc::usage_of_ty_tykind)]
+#![doc(
+    html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/",
+    test(attr(allow(unused_variables), deny(warnings)))
+)]
+#![doc(rust_logo)]
+#![feature(rustdoc_internals)]
+#![feature(sized_hierarchy)]
+// tidy-alphabetical-end
+
+use std::cell::RefCell;
+use std::fmt::Debug;
+use std::hash::Hash;
+use std::ops::Index;
+
+use bridge::*;
+use context::SmirCtxt;
+use rustc_data_structures::fx::{self, FxIndexMap};
+use rustc_middle::mir;
+use rustc_middle::mir::interpret::AllocId;
+use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_span::Span;
+use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE};
+
+pub mod alloc;
+pub mod bridge;
+mod builder;
+pub mod context;
+
+#[deprecated(note = "please use `rustc_public::rustc_internal` instead")]
+pub mod rustc_internal {}
+
+/// A container which is used for TLS.
+pub struct SmirContainer<'tcx, B: Bridge> {
+    pub tables: RefCell<Tables<'tcx, B>>,
+    pub cx: RefCell<SmirCtxt<'tcx, B>>,
+}
+
+pub struct Tables<'tcx, B: Bridge> {
+    pub def_ids: IndexMap<DefId, B::DefId>,
+    pub alloc_ids: IndexMap<AllocId, B::AllocId>,
+    pub spans: IndexMap<rustc_span::Span, B::Span>,
+    pub types: IndexMap<Ty<'tcx>, B::Ty>,
+    pub instances: IndexMap<ty::Instance<'tcx>, B::InstanceDef>,
+    pub ty_consts: IndexMap<ty::Const<'tcx>, B::TyConstId>,
+    pub mir_consts: IndexMap<mir::Const<'tcx>, B::MirConstId>,
+    pub layouts: IndexMap<rustc_abi::Layout<'tcx>, B::Layout>,
+}
+
+impl<'tcx, B: Bridge> Default for Tables<'tcx, B> {
+    fn default() -> Self {
+        Self {
+            def_ids: IndexMap::default(),
+            alloc_ids: IndexMap::default(),
+            spans: IndexMap::default(),
+            types: IndexMap::default(),
+            instances: IndexMap::default(),
+            ty_consts: IndexMap::default(),
+            mir_consts: IndexMap::default(),
+            layouts: IndexMap::default(),
+        }
+    }
+}
+
+impl<'tcx, B: Bridge> Index<B::DefId> for Tables<'tcx, B> {
+    type Output = DefId;
+
+    #[inline(always)]
+    fn index(&self, index: B::DefId) -> &Self::Output {
+        &self.def_ids[index]
+    }
+}
+
+impl<'tcx, B: Bridge> Tables<'tcx, B> {
+    pub fn intern_ty(&mut self, ty: Ty<'tcx>) -> B::Ty {
+        self.types.create_or_fetch(ty)
+    }
+
+    pub fn intern_ty_const(&mut self, ct: ty::Const<'tcx>) -> B::TyConstId {
+        self.ty_consts.create_or_fetch(ct)
+    }
+
+    pub fn intern_mir_const(&mut self, constant: mir::Const<'tcx>) -> B::MirConstId {
+        self.mir_consts.create_or_fetch(constant)
+    }
+
+    pub fn create_def_id(&mut self, did: DefId) -> B::DefId {
+        self.def_ids.create_or_fetch(did)
+    }
+
+    pub fn create_alloc_id(&mut self, aid: AllocId) -> B::AllocId {
+        self.alloc_ids.create_or_fetch(aid)
+    }
+
+    pub fn create_span(&mut self, span: Span) -> B::Span {
+        self.spans.create_or_fetch(span)
+    }
+
+    pub fn instance_def(&mut self, instance: ty::Instance<'tcx>) -> B::InstanceDef {
+        self.instances.create_or_fetch(instance)
+    }
+
+    pub fn layout_id(&mut self, layout: rustc_abi::Layout<'tcx>) -> B::Layout {
+        self.layouts.create_or_fetch(layout)
+    }
+
+    pub fn crate_item(&mut self, did: rustc_span::def_id::DefId) -> B::CrateItem {
+        B::CrateItem::new(self.create_def_id(did))
+    }
+
+    pub fn adt_def(&mut self, did: rustc_span::def_id::DefId) -> B::AdtDef {
+        B::AdtDef::new(self.create_def_id(did))
+    }
+
+    pub fn foreign_module_def(&mut self, did: rustc_span::def_id::DefId) -> B::ForeignModuleDef {
+        B::ForeignModuleDef::new(self.create_def_id(did))
+    }
+
+    pub fn foreign_def(&mut self, did: rustc_span::def_id::DefId) -> B::ForeignDef {
+        B::ForeignDef::new(self.create_def_id(did))
+    }
+
+    pub fn fn_def(&mut self, did: rustc_span::def_id::DefId) -> B::FnDef {
+        B::FnDef::new(self.create_def_id(did))
+    }
+
+    pub fn closure_def(&mut self, did: rustc_span::def_id::DefId) -> B::ClosureDef {
+        B::ClosureDef::new(self.create_def_id(did))
+    }
+
+    pub fn coroutine_def(&mut self, did: rustc_span::def_id::DefId) -> B::CoroutineDef {
+        B::CoroutineDef::new(self.create_def_id(did))
+    }
+
+    pub fn coroutine_closure_def(
+        &mut self,
+        did: rustc_span::def_id::DefId,
+    ) -> B::CoroutineClosureDef {
+        B::CoroutineClosureDef::new(self.create_def_id(did))
+    }
+
+    pub fn alias_def(&mut self, did: rustc_span::def_id::DefId) -> B::AliasDef {
+        B::AliasDef::new(self.create_def_id(did))
+    }
+
+    pub fn param_def(&mut self, did: rustc_span::def_id::DefId) -> B::ParamDef {
+        B::ParamDef::new(self.create_def_id(did))
+    }
+
+    pub fn br_named_def(&mut self, did: rustc_span::def_id::DefId) -> B::BrNamedDef {
+        B::BrNamedDef::new(self.create_def_id(did))
+    }
+
+    pub fn trait_def(&mut self, did: rustc_span::def_id::DefId) -> B::TraitDef {
+        B::TraitDef::new(self.create_def_id(did))
+    }
+
+    pub fn generic_def(&mut self, did: rustc_span::def_id::DefId) -> B::GenericDef {
+        B::GenericDef::new(self.create_def_id(did))
+    }
+
+    pub fn const_def(&mut self, did: rustc_span::def_id::DefId) -> B::ConstDef {
+        B::ConstDef::new(self.create_def_id(did))
+    }
+
+    pub fn impl_def(&mut self, did: rustc_span::def_id::DefId) -> B::ImplDef {
+        B::ImplDef::new(self.create_def_id(did))
+    }
+
+    pub fn region_def(&mut self, did: rustc_span::def_id::DefId) -> B::RegionDef {
+        B::RegionDef::new(self.create_def_id(did))
+    }
+
+    pub fn coroutine_witness_def(
+        &mut self,
+        did: rustc_span::def_id::DefId,
+    ) -> B::CoroutineWitnessDef {
+        B::CoroutineWitnessDef::new(self.create_def_id(did))
+    }
+
+    pub fn assoc_def(&mut self, did: rustc_span::def_id::DefId) -> B::AssocDef {
+        B::AssocDef::new(self.create_def_id(did))
+    }
+
+    pub fn opaque_def(&mut self, did: rustc_span::def_id::DefId) -> B::OpaqueDef {
+        B::OpaqueDef::new(self.create_def_id(did))
+    }
+
+    pub fn prov(&mut self, aid: rustc_middle::mir::interpret::AllocId) -> B::Prov {
+        B::Prov::new(self.create_alloc_id(aid))
+    }
+
+    pub fn static_def(&mut self, did: rustc_span::def_id::DefId) -> B::StaticDef {
+        B::StaticDef::new(self.create_def_id(did))
+    }
+}
+
+/// A trait defining types that are used to emulate StableMIR components, which is really
+/// useful when programming in rustc_public-agnostic settings.
+pub trait Bridge: Sized {
+    type DefId: Copy + Debug + PartialEq + IndexedVal;
+    type AllocId: Copy + Debug + PartialEq + IndexedVal;
+    type Span: Copy + Debug + PartialEq + IndexedVal;
+    type Ty: Copy + Debug + PartialEq + IndexedVal;
+    type InstanceDef: Copy + Debug + PartialEq + IndexedVal;
+    type TyConstId: Copy + Debug + PartialEq + IndexedVal;
+    type MirConstId: Copy + Debug + PartialEq + IndexedVal;
+    type Layout: Copy + Debug + PartialEq + IndexedVal;
+
+    type Error: SmirError;
+    type CrateItem: CrateItem<Self>;
+    type AdtDef: AdtDef<Self>;
+    type ForeignModuleDef: ForeignModuleDef<Self>;
+    type ForeignDef: ForeignDef<Self>;
+    type FnDef: FnDef<Self>;
+    type ClosureDef: ClosureDef<Self>;
+    type CoroutineDef: CoroutineDef<Self>;
+    type CoroutineClosureDef: CoroutineClosureDef<Self>;
+    type AliasDef: AliasDef<Self>;
+    type ParamDef: ParamDef<Self>;
+    type BrNamedDef: BrNamedDef<Self>;
+    type TraitDef: TraitDef<Self>;
+    type GenericDef: GenericDef<Self>;
+    type ConstDef: ConstDef<Self>;
+    type ImplDef: ImplDef<Self>;
+    type RegionDef: RegionDef<Self>;
+    type CoroutineWitnessDef: CoroutineWitnessDef<Self>;
+    type AssocDef: AssocDef<Self>;
+    type OpaqueDef: OpaqueDef<Self>;
+    type Prov: Prov<Self>;
+    type StaticDef: StaticDef<Self>;
+
+    type Allocation: Allocation<Self>;
+}
+
+pub trait IndexedVal {
+    fn to_val(index: usize) -> Self;
+
+    fn to_index(&self) -> usize;
+}
+
+/// Similar to rustc's `FxIndexMap`, `IndexMap` with extra
+/// safety features added.
+pub struct IndexMap<K, V> {
+    index_map: fx::FxIndexMap<K, V>,
+}
+
+impl<K, V> Default for IndexMap<K, V> {
+    fn default() -> Self {
+        Self { index_map: FxIndexMap::default() }
+    }
+}
+
+impl<K: PartialEq + Hash + Eq, V: Copy + Debug + PartialEq + IndexedVal> IndexMap<K, V> {
+    pub fn create_or_fetch(&mut self, key: K) -> V {
+        let len = self.index_map.len();
+        let v = self.index_map.entry(key).or_insert(V::to_val(len));
+        *v
+    }
+}
+
+impl<K: PartialEq + Hash + Eq, V: Copy + Debug + PartialEq + IndexedVal> Index<V>
+    for IndexMap<K, V>
+{
+    type Output = K;
+
+    fn index(&self, index: V) -> &Self::Output {
+        let (k, v) = self.index_map.get_index(index.to_index()).unwrap();
+        assert_eq!(*v, index, "Provided value doesn't match with indexed value");
+        k
+    }
+}
+
+/// Iterate over the definitions of the given crate.
+pub(crate) fn filter_def_ids<F, T>(tcx: TyCtxt<'_>, krate: CrateNum, mut func: F) -> Vec<T>
+where
+    F: FnMut(DefId) -> Option<T>,
+{
+    if krate == LOCAL_CRATE {
+        tcx.iter_local_def_id().filter_map(|did| func(did.to_def_id())).collect()
+    } else {
+        let num_definitions = tcx.num_extern_def_ids(krate);
+        (0..num_definitions)
+            .filter_map(move |i| {
+                let def_id = DefId { krate, index: rustc_span::def_id::DefIndex::from_usize(i) };
+                func(def_id)
+            })
+            .collect()
+    }
+}
diff --git a/compiler/rustc_smir/.gitignore b/compiler/rustc_smir/.gitignore
deleted file mode 100644
index eb5a316cbd1..00000000000
--- a/compiler/rustc_smir/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-target
diff --git a/compiler/rustc_smir/Cargo.toml b/compiler/rustc_smir/Cargo.toml
deleted file mode 100644
index b7ea478f731..00000000000
--- a/compiler/rustc_smir/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "rustc_smir"
-version = "0.0.0"
-edition = "2024"
-
-[dependencies]
-# tidy-alphabetical-start
-rustc_abi = { path = "../rustc_abi" }
-rustc_data_structures = { path = "../rustc_data_structures" }
-rustc_hir = { path = "../rustc_hir" }
-rustc_hir_pretty = { path = "../rustc_hir_pretty" }
-rustc_middle = { path = "../rustc_middle" }
-rustc_session = { path = "../rustc_session" }
-rustc_span = { path = "../rustc_span" }
-rustc_target = { path = "../rustc_target" }
-# tidy-alphabetical-end
diff --git a/compiler/rustc_smir/src/alloc.rs b/compiler/rustc_smir/src/alloc.rs
deleted file mode 100644
index fd3cf24edb5..00000000000
--- a/compiler/rustc_smir/src/alloc.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-//! Internal memory allocator implementation for StableMIR.
-//!
-//! This module handles all direct interactions with rustc queries and performs
-//! the actual memory allocations. The stable interface in `stable_mir::alloc`
-//! delegates all query-related operations to this implementation.
-
-use rustc_abi::{Size, TyAndLayout};
-use rustc_middle::mir::interpret::{
-    AllocId, AllocInit, AllocRange, Allocation, ConstAllocation, Pointer, Scalar, alloc_range,
-};
-use rustc_middle::ty::{Ty, layout};
-
-use super::{SmirCtxt, Tables};
-use crate::bridge::Allocation as _;
-use crate::{Bridge, SmirError};
-
-pub fn create_ty_and_layout<'tcx, B: Bridge>(
-    cx: &SmirCtxt<'tcx, B>,
-    ty: Ty<'tcx>,
-) -> Result<TyAndLayout<'tcx, Ty<'tcx>>, &'tcx layout::LayoutError<'tcx>> {
-    use crate::context::SmirTypingEnv;
-    cx.tcx.layout_of(cx.fully_monomorphized().as_query_input(ty))
-}
-
-pub fn try_new_scalar<'tcx, B: Bridge>(
-    layout: TyAndLayout<'tcx, Ty<'tcx>>,
-    scalar: Scalar,
-    cx: &SmirCtxt<'tcx, B>,
-) -> Result<Allocation, B::Error> {
-    let size = scalar.size();
-    let mut allocation = Allocation::new(size, layout.align.abi, AllocInit::Uninit, ());
-    allocation
-        .write_scalar(&cx.tcx, alloc_range(Size::ZERO, size), scalar)
-        .map_err(|e| B::Error::from_internal(e))?;
-
-    Ok(allocation)
-}
-
-pub fn try_new_slice<'tcx, B: Bridge>(
-    layout: TyAndLayout<'tcx, Ty<'tcx>>,
-    data: ConstAllocation<'tcx>,
-    meta: u64,
-    cx: &SmirCtxt<'tcx, B>,
-) -> Result<Allocation, B::Error> {
-    let alloc_id = cx.tcx.reserve_and_set_memory_alloc(data);
-    let ptr = Pointer::new(alloc_id.into(), Size::ZERO);
-    let scalar_ptr = Scalar::from_pointer(ptr, &cx.tcx);
-    let scalar_meta: Scalar = Scalar::from_target_usize(meta, &cx.tcx);
-    let mut allocation = Allocation::new(layout.size, layout.align.abi, AllocInit::Uninit, ());
-    let ptr_size = cx.tcx.data_layout.pointer_size();
-    allocation
-        .write_scalar(&cx.tcx, alloc_range(Size::ZERO, ptr_size), scalar_ptr)
-        .map_err(|e| B::Error::from_internal(e))?;
-    allocation
-        .write_scalar(&cx.tcx, alloc_range(ptr_size, scalar_meta.size()), scalar_meta)
-        .map_err(|e| B::Error::from_internal(e))?;
-
-    Ok(allocation)
-}
-
-pub fn try_new_indirect<'tcx, B: Bridge>(
-    alloc_id: AllocId,
-    cx: &SmirCtxt<'tcx, B>,
-) -> ConstAllocation<'tcx> {
-    let alloc = cx.tcx.global_alloc(alloc_id).unwrap_memory();
-
-    alloc
-}
-
-/// Creates an `Allocation` only from information within the `AllocRange`.
-pub fn allocation_filter<'tcx, B: Bridge>(
-    alloc: &rustc_middle::mir::interpret::Allocation,
-    alloc_range: AllocRange,
-    tables: &mut Tables<'tcx, B>,
-    cx: &SmirCtxt<'tcx, B>,
-) -> B::Allocation {
-    let mut bytes: Vec<Option<u8>> = alloc
-        .inspect_with_uninit_and_ptr_outside_interpreter(
-            alloc_range.start.bytes_usize()..alloc_range.end().bytes_usize(),
-        )
-        .iter()
-        .copied()
-        .map(Some)
-        .collect();
-    for (i, b) in bytes.iter_mut().enumerate() {
-        if !alloc.init_mask().get(Size::from_bytes(i + alloc_range.start.bytes_usize())) {
-            *b = None;
-        }
-    }
-    let mut ptrs = Vec::new();
-    for (offset, prov) in alloc
-        .provenance()
-        .ptrs()
-        .iter()
-        .filter(|a| a.0 >= alloc_range.start && a.0 <= alloc_range.end())
-    {
-        ptrs.push((offset.bytes_usize() - alloc_range.start.bytes_usize(), prov.alloc_id()));
-    }
-
-    B::Allocation::new(bytes, ptrs, alloc.align.bytes(), alloc.mutability, tables, cx)
-}
diff --git a/compiler/rustc_smir/src/bridge.rs b/compiler/rustc_smir/src/bridge.rs
deleted file mode 100644
index a31eb93d0e8..00000000000
--- a/compiler/rustc_smir/src/bridge.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//! Defines a set of traits that is used for abstracting
-//! stable_mir's components that are needed in rustc_smir.
-//!
-//! These traits are really useful when programming
-//! in stable_mir-agnostic settings.
-
-use std::fmt::Debug;
-
-use super::context::SmirCtxt;
-use super::{Bridge, Tables};
-
-pub trait SmirError {
-    fn new(msg: String) -> Self;
-    fn from_internal<T: Debug>(err: T) -> Self;
-}
-
-pub trait Prov<B: Bridge> {
-    fn new(aid: B::AllocId) -> Self;
-}
-
-pub trait Allocation<B: Bridge> {
-    fn new<'tcx>(
-        bytes: Vec<Option<u8>>,
-        ptrs: Vec<(usize, rustc_middle::mir::interpret::AllocId)>,
-        align: u64,
-        mutability: rustc_middle::mir::Mutability,
-        tables: &mut Tables<'tcx, B>,
-        cx: &SmirCtxt<'tcx, B>,
-    ) -> Self;
-}
-
-macro_rules! make_bridge_trait {
-    ($name:ident) => {
-        pub trait $name<B: Bridge> {
-            fn new(did: B::DefId) -> Self;
-        }
-    };
-}
-
-make_bridge_trait!(CrateItem);
-make_bridge_trait!(AdtDef);
-make_bridge_trait!(ForeignModuleDef);
-make_bridge_trait!(ForeignDef);
-make_bridge_trait!(FnDef);
-make_bridge_trait!(ClosureDef);
-make_bridge_trait!(CoroutineDef);
-make_bridge_trait!(CoroutineClosureDef);
-make_bridge_trait!(AliasDef);
-make_bridge_trait!(ParamDef);
-make_bridge_trait!(BrNamedDef);
-make_bridge_trait!(TraitDef);
-make_bridge_trait!(GenericDef);
-make_bridge_trait!(ConstDef);
-make_bridge_trait!(ImplDef);
-make_bridge_trait!(RegionDef);
-make_bridge_trait!(CoroutineWitnessDef);
-make_bridge_trait!(AssocDef);
-make_bridge_trait!(OpaqueDef);
-make_bridge_trait!(StaticDef);
diff --git a/compiler/rustc_smir/src/builder.rs b/compiler/rustc_smir/src/builder.rs
deleted file mode 100644
index 2141053d09a..00000000000
--- a/compiler/rustc_smir/src/builder.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-//! Logic required to produce a monomorphic stable body.
-//!
-//! We first retrieve and monomorphize the rustc body representation, i.e., we generate a
-//! monomorphic body using internal representation.
-//! After that, we convert the internal representation into a stable one.
-
-use rustc_hir::def::DefKind;
-use rustc_middle::mir;
-use rustc_middle::mir::visit::MutVisitor;
-use rustc_middle::ty::{self, TyCtxt};
-
-/// Builds a monomorphic body for a given instance.
-pub(crate) struct BodyBuilder<'tcx> {
-    tcx: TyCtxt<'tcx>,
-    instance: ty::Instance<'tcx>,
-}
-
-impl<'tcx> BodyBuilder<'tcx> {
-    pub(crate) fn new(tcx: TyCtxt<'tcx>, instance: ty::Instance<'tcx>) -> Self {
-        let instance = match instance.def {
-            // To get the fallback body of an intrinsic, we need to convert it to an item.
-            ty::InstanceKind::Intrinsic(def_id) => ty::Instance::new_raw(def_id, instance.args),
-            _ => instance,
-        };
-        BodyBuilder { tcx, instance }
-    }
-
-    /// Build a stable monomorphic body for a given instance based on the MIR body.
-    ///
-    /// All constants are also evaluated.
-    pub(crate) fn build(mut self) -> mir::Body<'tcx> {
-        let body = self.tcx.instance_mir(self.instance.def).clone();
-        let mono_body = if !self.instance.args.is_empty()
-            // Without the `generic_const_exprs` feature gate, anon consts in signatures do not
-            // get generic parameters. Which is wrong, but also not a problem without
-            // generic_const_exprs
-            || self.tcx.def_kind(self.instance.def_id()) != DefKind::AnonConst
-        {
-            let mut mono_body = self.instance.instantiate_mir_and_normalize_erasing_regions(
-                self.tcx,
-                ty::TypingEnv::fully_monomorphized(),
-                ty::EarlyBinder::bind(body),
-            );
-            self.visit_body(&mut mono_body);
-            mono_body
-        } else {
-            // Already monomorphic.
-            body
-        };
-
-        mono_body
-    }
-}
-
-impl<'tcx> MutVisitor<'tcx> for BodyBuilder<'tcx> {
-    fn visit_const_operand(
-        &mut self,
-        constant: &mut mir::ConstOperand<'tcx>,
-        location: mir::Location,
-    ) {
-        let const_ = constant.const_;
-        let val = match const_.eval(self.tcx, ty::TypingEnv::fully_monomorphized(), constant.span) {
-            Ok(v) => v,
-            Err(mir::interpret::ErrorHandled::Reported(..)) => return,
-            Err(mir::interpret::ErrorHandled::TooGeneric(..)) => {
-                unreachable!("Failed to evaluate instance constant: {:?}", const_)
-            }
-        };
-        let ty = constant.ty();
-        constant.const_ = mir::Const::Val(val, ty);
-        self.super_const_operand(constant, location);
-    }
-
-    fn tcx(&self) -> TyCtxt<'tcx> {
-        self.tcx
-    }
-}
diff --git a/compiler/rustc_smir/src/context/impls.rs b/compiler/rustc_smir/src/context/impls.rs
deleted file mode 100644
index fdefad2821b..00000000000
--- a/compiler/rustc_smir/src/context/impls.rs
+++ /dev/null
@@ -1,759 +0,0 @@
-//! Implementation of StableMIR Context.
-
-#![allow(rustc::usage_of_qualified_ty)]
-
-use std::iter;
-
-use rustc_abi::{Endian, Layout, ReprOptions};
-use rustc_hir::def::DefKind;
-use rustc_hir::{Attribute, LangItem};
-use rustc_middle::mir::interpret::{AllocId, ConstAllocation, ErrorHandled, GlobalAlloc, Scalar};
-use rustc_middle::mir::{BinOp, Body, Const as MirConst, ConstValue, UnOp};
-use rustc_middle::ty::layout::{FnAbiOf, LayoutOf};
-use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths};
-use rustc_middle::ty::util::Discr;
-use rustc_middle::ty::{
-    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,
-};
-use rustc_middle::{mir, ty};
-use rustc_session::cstore::ForeignModule;
-use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE};
-use rustc_span::{FileNameDisplayPreference, Span, Symbol};
-use rustc_target::callconv::FnAbi;
-
-use super::{SmirAllocRange, SmirCtxt, SmirTy, SmirTypingEnv};
-use crate::builder::BodyBuilder;
-use crate::{Bridge, SmirError, Tables, filter_def_ids};
-
-impl<'tcx, B: Bridge> SmirTy<'tcx> for SmirCtxt<'tcx, B> {
-    fn new_foreign(&self, def_id: DefId) -> ty::Ty<'tcx> {
-        ty::Ty::new_foreign(self.tcx, def_id)
-    }
-}
-
-impl<'tcx, B: Bridge> SmirTypingEnv<'tcx> for SmirCtxt<'tcx, B> {
-    fn fully_monomorphized(&self) -> ty::TypingEnv<'tcx> {
-        ty::TypingEnv::fully_monomorphized()
-    }
-}
-
-impl<'tcx, B: Bridge> SmirAllocRange<'tcx> for SmirCtxt<'tcx, B> {
-    fn alloc_range(
-        &self,
-        offset: rustc_abi::Size,
-        size: rustc_abi::Size,
-    ) -> mir::interpret::AllocRange {
-        rustc_middle::mir::interpret::alloc_range(offset, size)
-    }
-}
-
-impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
-    pub fn lift<T: ty::Lift<TyCtxt<'tcx>>>(&self, value: T) -> Option<T::Lifted> {
-        self.tcx.lift(value)
-    }
-
-    pub fn adt_def(&self, def_id: DefId) -> AdtDef<'tcx> {
-        self.tcx.adt_def(def_id)
-    }
-
-    pub fn coroutine_movability(&self, def_id: DefId) -> ty::Movability {
-        self.tcx.coroutine_movability(def_id)
-    }
-
-    pub fn valtree_to_const_val(&self, key: ty::Value<'tcx>) -> ConstValue<'tcx> {
-        self.tcx.valtree_to_const_val(key)
-    }
-
-    /// Return whether the instance as a body available.
-    ///
-    /// Items and intrinsics may have a body available from its definition.
-    /// Shims body may be generated depending on their type.
-    pub(crate) fn instance_has_body(&self, instance: Instance<'tcx>) -> bool {
-        let def_id = instance.def_id();
-        self.item_has_body(def_id)
-            || !matches!(
-                instance.def,
-                ty::InstanceKind::Virtual(..)
-                    | ty::InstanceKind::Intrinsic(..)
-                    | ty::InstanceKind::Item(..)
-            )
-    }
-
-    /// Return whether the item has a body defined by the user.
-    ///
-    /// Note that intrinsics may have a placeholder body that shouldn't be used in practice.
-    /// In StableMIR, we handle this case as if the body is not available.
-    pub(crate) fn item_has_body(&self, def_id: DefId) -> bool {
-        let must_override = if let Some(intrinsic) = self.tcx.intrinsic(def_id) {
-            intrinsic.must_be_overridden
-        } else {
-            false
-        };
-        !must_override && self.tcx.is_mir_available(def_id)
-    }
-
-    fn filter_fn_def(&self, def_id: DefId) -> Option<DefId> {
-        if matches!(self.tcx.def_kind(def_id), DefKind::Fn | DefKind::AssocFn) {
-            Some(def_id)
-        } else {
-            None
-        }
-    }
-
-    fn filter_static_def(&self, def_id: DefId) -> Option<DefId> {
-        matches!(self.tcx.def_kind(def_id), DefKind::Static { .. }).then(|| def_id)
-    }
-
-    pub fn target_endian(&self) -> Endian {
-        self.tcx.data_layout.endian
-    }
-
-    pub fn target_pointer_size(&self) -> usize {
-        self.tcx.data_layout.pointer_size().bits().try_into().unwrap()
-    }
-
-    pub fn entry_fn(&self) -> Option<DefId> {
-        Some(self.tcx.entry_fn(())?.0)
-    }
-
-    /// Retrieve all items of the local crate that have a MIR associated with them.
-    pub fn all_local_items(&self) -> Vec<DefId> {
-        self.tcx.mir_keys(()).iter().map(|item| item.to_def_id()).collect()
-    }
-
-    /// Retrieve the body of a function.
-    /// This function will panic if the body is not available.
-    pub fn mir_body(&self, item: DefId) -> &'tcx Body<'tcx> {
-        self.tcx.instance_mir(InstanceKind::Item(item))
-    }
-
-    /// Check whether the body of a function is available.
-    pub fn has_body(&self, def: DefId) -> bool {
-        self.item_has_body(def)
-    }
-
-    pub fn foreign_modules(&self, crate_num: CrateNum) -> Vec<DefId> {
-        self.tcx.foreign_modules(crate_num).keys().map(|mod_def_id| *mod_def_id).collect()
-    }
-
-    /// Retrieve all functions defined in this crate.
-    pub fn crate_functions(&self, crate_num: CrateNum) -> Vec<DefId> {
-        filter_def_ids(self.tcx, crate_num, |def_id| self.filter_fn_def(def_id))
-    }
-
-    /// Retrieve all static items defined in this crate.
-    pub fn crate_statics(&self, crate_num: CrateNum) -> Vec<DefId> {
-        filter_def_ids(self.tcx, crate_num, |def_id| self.filter_static_def(def_id))
-    }
-
-    pub fn foreign_module(&self, mod_def: DefId) -> &ForeignModule {
-        self.tcx.foreign_modules(mod_def.krate).get(&mod_def).unwrap()
-    }
-
-    pub fn foreign_items(&self, mod_def: DefId) -> Vec<DefId> {
-        self.tcx
-            .foreign_modules(mod_def.krate)
-            .get(&mod_def)
-            .unwrap()
-            .foreign_items
-            .iter()
-            .map(|item_def| *item_def)
-            .collect()
-    }
-
-    pub fn all_trait_decls(&self) -> impl Iterator<Item = DefId> {
-        self.tcx.all_traits_including_private()
-    }
-
-    pub fn trait_decls(&self, crate_num: CrateNum) -> Vec<DefId> {
-        self.tcx.traits(crate_num).iter().map(|trait_def_id| *trait_def_id).collect()
-    }
-
-    pub fn trait_decl(&self, trait_def: DefId) -> &'tcx TraitDef {
-        self.tcx.trait_def(trait_def)
-    }
-
-    pub fn all_trait_impls(&self) -> Vec<DefId> {
-        iter::once(LOCAL_CRATE)
-            .chain(self.tcx.crates(()).iter().copied())
-            .flat_map(|cnum| self.tcx.trait_impls_in_crate(cnum).iter())
-            .map(|impl_def_id| *impl_def_id)
-            .collect()
-    }
-
-    pub fn trait_impls(&self, crate_num: CrateNum) -> Vec<DefId> {
-        self.tcx.trait_impls_in_crate(crate_num).iter().map(|impl_def_id| *impl_def_id).collect()
-    }
-
-    pub fn trait_impl(&self, impl_def: DefId) -> EarlyBinder<'tcx, TraitRef<'tcx>> {
-        self.tcx.impl_trait_ref(impl_def).unwrap()
-    }
-
-    pub fn generics_of(&self, def_id: DefId) -> &'tcx ty::Generics {
-        self.tcx.generics_of(def_id)
-    }
-
-    pub fn predicates_of(
-        &self,
-        def_id: DefId,
-    ) -> (Option<DefId>, Vec<(ty::PredicateKind<'tcx>, Span)>) {
-        let ty::GenericPredicates { parent, predicates } = self.tcx.predicates_of(def_id);
-        (
-            parent,
-            predicates
-                .iter()
-                .map(|(clause, span)| (clause.as_predicate().kind().skip_binder(), *span))
-                .collect(),
-        )
-    }
-
-    pub fn explicit_predicates_of(
-        &self,
-        def_id: DefId,
-    ) -> (Option<DefId>, Vec<(ty::PredicateKind<'tcx>, Span)>) {
-        let ty::GenericPredicates { parent, predicates } = self.tcx.explicit_predicates_of(def_id);
-        (
-            parent,
-            predicates
-                .iter()
-                .map(|(clause, span)| (clause.as_predicate().kind().skip_binder(), *span))
-                .collect(),
-        )
-    }
-
-    pub fn crate_name(&self, crate_num: CrateNum) -> String {
-        self.tcx.crate_name(crate_num).to_string()
-    }
-
-    pub fn crate_is_local(&self, crate_num: CrateNum) -> bool {
-        crate_num == LOCAL_CRATE
-    }
-
-    pub fn crate_num_id(&self, crate_num: CrateNum) -> usize {
-        crate_num.into()
-    }
-
-    pub fn local_crate_num(&self) -> CrateNum {
-        LOCAL_CRATE
-    }
-
-    /// Retrieve a list of all external crates.
-    pub fn external_crates(&self) -> Vec<CrateNum> {
-        self.tcx.crates(()).iter().map(|crate_num| *crate_num).collect()
-    }
-
-    /// Find a crate with the given name.
-    pub fn find_crates(&self, name: &str) -> Vec<CrateNum> {
-        let crates: Vec<CrateNum> = [LOCAL_CRATE]
-            .iter()
-            .chain(self.tcx.crates(()).iter())
-            .filter_map(|crate_num| {
-                let crate_name = self.tcx.crate_name(*crate_num).to_string();
-                (name == crate_name).then(|| *crate_num)
-            })
-            .collect();
-        crates
-    }
-
-    /// Returns the name of given `DefId`.
-    pub fn def_name(&self, def_id: DefId, trimmed: bool) -> String {
-        if trimmed {
-            with_forced_trimmed_paths!(self.tcx.def_path_str(def_id))
-        } else {
-            with_no_trimmed_paths!(self.tcx.def_path_str(def_id))
-        }
-    }
-
-    /// Return registered tool attributes with the given attribute name.
-    ///
-    /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool
-    /// attributes will simply return an empty list.
-    ///
-    /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`.
-    /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`.
-    pub fn tool_attrs(&self, def_id: DefId, attr: &[String]) -> Vec<(String, Span)> {
-        let attr_name: Vec<_> = attr.iter().map(|seg| Symbol::intern(&seg)).collect();
-        self.tcx
-            .get_attrs_by_path(def_id, &attr_name)
-            .filter_map(|attribute| {
-                if let Attribute::Unparsed(u) = attribute {
-                    let attr_str = rustc_hir_pretty::attribute_to_string(&self.tcx, attribute);
-                    Some((attr_str, u.span))
-                } else {
-                    None
-                }
-            })
-            .collect()
-    }
-
-    /// Get all tool attributes of a definition.
-    pub fn all_tool_attrs(&self, did: DefId) -> Vec<(String, Span)> {
-        let attrs_iter = if let Some(did) = did.as_local() {
-            self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(did)).iter()
-        } else {
-            self.tcx.attrs_for_def(did).iter()
-        };
-        attrs_iter
-            .filter_map(|attribute| {
-                if let Attribute::Unparsed(u) = attribute {
-                    let attr_str = rustc_hir_pretty::attribute_to_string(&self.tcx, attribute);
-                    Some((attr_str, u.span))
-                } else {
-                    None
-                }
-            })
-            .collect()
-    }
-
-    /// Returns printable, human readable form of `Span`.
-    pub fn span_to_string(&self, span: Span) -> String {
-        self.tcx.sess.source_map().span_to_diagnostic_string(span)
-    }
-
-    /// Return filename from given `Span`, for diagnostic purposes.
-    pub fn get_filename(&self, span: Span) -> String {
-        self.tcx
-            .sess
-            .source_map()
-            .span_to_filename(span)
-            .display(FileNameDisplayPreference::Local)
-            .to_string()
-    }
-
-    /// Return lines corresponding to this `Span`.
-    pub fn get_lines(&self, span: Span) -> (usize, usize, usize, usize) {
-        let lines = &self.tcx.sess.source_map().span_to_location_info(span);
-        (lines.1, lines.2, lines.3, lines.4)
-    }
-
-    /// Returns the `kind` of given `DefId`.
-    pub fn def_kind(&self, item: DefId) -> DefKind {
-        self.tcx.def_kind(item)
-    }
-
-    /// Returns whether this is a foreign item.
-    pub fn is_foreign_item(&self, item: DefId) -> bool {
-        self.tcx.is_foreign_item(item)
-    }
-
-    /// Returns the kind of a given foreign item.
-    pub fn foreign_item_kind(&self, def_id: DefId) -> DefKind {
-        self.tcx.def_kind(def_id)
-    }
-
-    /// Returns the kind of a given algebraic data type.
-    pub fn adt_kind(&self, def: AdtDef<'tcx>) -> AdtKind {
-        def.adt_kind()
-    }
-
-    /// Returns if the ADT is a box.
-    pub fn adt_is_box(&self, def: AdtDef<'tcx>) -> bool {
-        def.is_box()
-    }
-
-    /// Returns whether this ADT is simd.
-    pub fn adt_is_simd(&self, def: AdtDef<'tcx>) -> bool {
-        def.repr().simd()
-    }
-
-    /// Returns whether this definition is a C string.
-    pub fn adt_is_cstr(&self, def_id: DefId) -> bool {
-        self.tcx.is_lang_item(def_id, LangItem::CStr)
-    }
-
-    /// Returns the representation options for this ADT.
-    pub fn adt_repr(&self, def: AdtDef<'tcx>) -> ReprOptions {
-        def.repr()
-    }
-
-    /// Retrieve the function signature for the given generic arguments.
-    pub fn fn_sig(
-        &self,
-        def_id: DefId,
-        args_ref: GenericArgsRef<'tcx>,
-    ) -> Binder<'tcx, FnSig<'tcx>> {
-        let sig = self.tcx.fn_sig(def_id).instantiate(self.tcx, args_ref);
-        sig
-    }
-
-    /// Retrieve the intrinsic definition if the item corresponds one.
-    pub fn intrinsic(&self, def_id: DefId) -> Option<IntrinsicDef> {
-        let intrinsic = self.tcx.intrinsic_raw(def_id);
-        intrinsic
-    }
-
-    /// Retrieve the plain function name of an intrinsic.
-    pub fn intrinsic_name(&self, def_id: DefId) -> String {
-        self.tcx.intrinsic(def_id).unwrap().name.to_string()
-    }
-
-    /// Retrieve the closure signature for the given generic arguments.
-    pub fn closure_sig(&self, args_ref: GenericArgsRef<'tcx>) -> Binder<'tcx, FnSig<'tcx>> {
-        args_ref.as_closure().sig()
-    }
-
-    /// The number of variants in this ADT.
-    pub fn adt_variants_len(&self, def: AdtDef<'tcx>) -> usize {
-        def.variants().len()
-    }
-
-    /// Discriminant for a given variant index of AdtDef.
-    pub fn adt_discr_for_variant(
-        &self,
-        adt: AdtDef<'tcx>,
-        variant: rustc_abi::VariantIdx,
-    ) -> Discr<'tcx> {
-        adt.discriminant_for_variant(self.tcx, variant)
-    }
-
-    /// Discriminant for a given variand index and args of a coroutine.
-    pub fn coroutine_discr_for_variant(
-        &self,
-        coroutine: DefId,
-        args: GenericArgsRef<'tcx>,
-        variant: rustc_abi::VariantIdx,
-    ) -> Discr<'tcx> {
-        args.as_coroutine().discriminant_for_variant(coroutine, self.tcx, variant)
-    }
-
-    /// The name of a variant.
-    pub fn variant_name(&self, def: &'tcx VariantDef) -> String {
-        def.name.to_string()
-    }
-
-    /// Evaluate constant as a target usize.
-    pub fn eval_target_usize(&self, cnst: MirConst<'tcx>) -> Result<u64, B::Error> {
-        use crate::context::SmirTypingEnv;
-        cnst.try_eval_target_usize(self.tcx, self.fully_monomorphized())
-            .ok_or_else(|| B::Error::new(format!("Const `{cnst:?}` cannot be encoded as u64")))
-    }
-
-    pub fn eval_target_usize_ty(&self, cnst: ty::Const<'tcx>) -> Result<u64, B::Error> {
-        cnst.try_to_target_usize(self.tcx)
-            .ok_or_else(|| B::Error::new(format!("Const `{cnst:?}` cannot be encoded as u64")))
-    }
-
-    pub fn try_new_const_zst(&self, ty_internal: Ty<'tcx>) -> Result<MirConst<'tcx>, B::Error> {
-        let size = self
-            .tcx
-            .layout_of(self.fully_monomorphized().as_query_input(ty_internal))
-            .map_err(|err| {
-                B::Error::new(format!(
-                    "Cannot create a zero-sized constant for type `{ty_internal}`: {err}"
-                ))
-            })?
-            .size;
-        if size.bytes() != 0 {
-            return Err(B::Error::new(format!(
-                "Cannot create a zero-sized constant for type `{ty_internal}`: \
-                Type `{ty_internal}` has {} bytes",
-                size.bytes()
-            )));
-        }
-
-        Ok(MirConst::Ty(ty_internal, self.const_zero_sized(ty_internal)))
-    }
-
-    pub fn const_zero_sized(&self, ty_internal: Ty<'tcx>) -> ty::Const<'tcx> {
-        ty::Const::zero_sized(self.tcx, ty_internal)
-    }
-
-    /// Create a new constant that represents the given string value.
-    pub fn new_const_str(&self, value: &str) -> MirConst<'tcx> {
-        let ty = Ty::new_static_str(self.tcx);
-        let bytes = value.as_bytes();
-        let valtree = ValTree::from_raw_bytes(self.tcx, bytes);
-        let cv = ty::Value { ty, valtree };
-        let val = self.tcx.valtree_to_const_val(cv);
-        MirConst::from_value(val, ty)
-    }
-
-    /// Create a new constant that represents the given boolean value.
-    pub fn new_const_bool(&self, value: bool) -> MirConst<'tcx> {
-        MirConst::from_bool(self.tcx, value)
-    }
-
-    pub fn try_new_const_uint(
-        &self,
-        value: u128,
-        ty_internal: Ty<'tcx>,
-    ) -> Result<MirConst<'tcx>, B::Error> {
-        let size = self
-            .tcx
-            .layout_of(self.fully_monomorphized().as_query_input(ty_internal))
-            .unwrap()
-            .size;
-        let scalar = ScalarInt::try_from_uint(value, size).ok_or_else(|| {
-            B::Error::new(format!("Value overflow: cannot convert `{value}` to `{ty_internal}`."))
-        })?;
-        Ok(self.mir_const_from_scalar(Scalar::Int(scalar), ty_internal))
-    }
-
-    pub fn try_new_ty_const_uint(
-        &self,
-        value: u128,
-        ty_internal: Ty<'tcx>,
-    ) -> Result<ty::Const<'tcx>, B::Error> {
-        let size = self
-            .tcx
-            .layout_of(self.fully_monomorphized().as_query_input(ty_internal))
-            .unwrap()
-            .size;
-        let scalar = ScalarInt::try_from_uint(value, size).ok_or_else(|| {
-            B::Error::new(format!("Value overflow: cannot convert `{value}` to `{ty_internal}`."))
-        })?;
-
-        Ok(self.ty_const_new_value(ValTree::from_scalar_int(self.tcx, scalar), ty_internal))
-    }
-
-    pub fn ty_new_uint(&self, ty: UintTy) -> Ty<'tcx> {
-        Ty::new_uint(self.tcx, ty)
-    }
-
-    pub fn mir_const_from_scalar(&self, s: Scalar, ty: Ty<'tcx>) -> MirConst<'tcx> {
-        MirConst::from_scalar(self.tcx, s, ty)
-    }
-
-    pub fn ty_const_new_value(&self, valtree: ValTree<'tcx>, ty: Ty<'tcx>) -> ty::Const<'tcx> {
-        ty::Const::new_value(self.tcx, valtree, ty)
-    }
-
-    pub fn ty_valtree_from_scalar_int(&self, i: ScalarInt) -> ValTree<'tcx> {
-        ValTree::from_scalar_int(self.tcx, i)
-    }
-
-    /// Create a new type from the given kind.
-    pub fn new_rigid_ty(&self, internal_kind: TyKind<'tcx>) -> Ty<'tcx> {
-        self.tcx.mk_ty_from_kind(internal_kind)
-    }
-
-    /// Create a new box type, `Box<T>`, for the given inner type `T`.
-    pub fn new_box_ty(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
-        ty::Ty::new_box(self.tcx, ty)
-    }
-
-    /// Returns the type of given crate item.
-    pub fn def_ty(&self, item: DefId) -> Ty<'tcx> {
-        self.tcx.type_of(item).instantiate_identity()
-    }
-
-    /// Returns the type of given definition instantiated with the given arguments.
-    pub fn def_ty_with_args(&self, item: DefId, args_ref: GenericArgsRef<'tcx>) -> Ty<'tcx> {
-        let def_ty = self.tcx.type_of(item);
-        self.tcx.instantiate_and_normalize_erasing_regions(
-            args_ref,
-            self.fully_monomorphized(),
-            def_ty,
-        )
-    }
-
-    /// `Span` of an item.
-    pub fn span_of_an_item(&self, def_id: DefId) -> Span {
-        self.tcx.def_span(def_id)
-    }
-
-    pub fn ty_const_pretty(&self, ct: ty::Const<'tcx>) -> String {
-        ct.to_string()
-    }
-
-    /// Obtain the representation of a type.
-    pub fn ty_pretty(&self, ty: Ty<'tcx>) -> String {
-        ty.to_string()
-    }
-
-    /// Obtain the kind of a type.
-    pub fn ty_kind(&self, ty: Ty<'tcx>) -> &'tcx TyKind<'tcx> {
-        ty.kind()
-    }
-
-    /// Get the discriminant Ty for this Ty if there's one.
-    pub fn rigid_ty_discriminant_ty(&self, internal_kind: TyKind<'tcx>) -> Ty<'tcx> {
-        let internal_ty = self.tcx.mk_ty_from_kind(internal_kind);
-        internal_ty.discriminant_ty(self.tcx)
-    }
-
-    /// Get the body of an Instance which is already monomorphized.
-    pub fn instance_body(&self, instance: ty::Instance<'tcx>) -> Option<Body<'tcx>> {
-        self.instance_has_body(instance).then(|| BodyBuilder::new(self.tcx, instance).build())
-    }
-
-    /// Get the instance type with generic instantiations applied and lifetimes erased.
-    pub fn instance_ty(&self, instance: ty::Instance<'tcx>) -> Ty<'tcx> {
-        assert!(!instance.has_non_region_param(), "{instance:?} needs further instantiation");
-        instance.ty(self.tcx, self.fully_monomorphized())
-    }
-
-    /// Get the instantiation types.
-    pub fn instance_args(&self, instance: ty::Instance<'tcx>) -> GenericArgsRef<'tcx> {
-        instance.args
-    }
-
-    /// Get an instance ABI.
-    pub fn instance_abi(
-        &self,
-        instance: ty::Instance<'tcx>,
-    ) -> Result<&FnAbi<'tcx, Ty<'tcx>>, B::Error> {
-        Ok(self.fn_abi_of_instance(instance, List::empty())?)
-    }
-
-    /// Get the ABI of a function pointer.
-    pub fn fn_ptr_abi(&self, sig: PolyFnSig<'tcx>) -> Result<&FnAbi<'tcx, Ty<'tcx>>, B::Error> {
-        Ok(self.fn_abi_of_fn_ptr(sig, List::empty())?)
-    }
-
-    /// Get the instance.
-    pub fn instance_def_id(
-        &self,
-        instances: ty::Instance<'tcx>,
-        tables: &mut Tables<'_, B>,
-    ) -> B::DefId {
-        let def_id = instances.def_id();
-        tables.create_def_id(def_id)
-    }
-
-    /// Get the instance mangled name.
-    pub fn instance_mangled_name(&self, instance: ty::Instance<'tcx>) -> String {
-        self.tcx.symbol_name(instance).name.to_string()
-    }
-
-    /// Check if this is an empty DropGlue shim.
-    pub fn is_empty_drop_shim(&self, instance: ty::Instance<'tcx>) -> bool {
-        matches!(instance.def, ty::InstanceKind::DropGlue(_, None))
-    }
-
-    /// Convert a non-generic crate item into an instance.
-    /// This function will panic if the item is generic.
-    pub fn mono_instance(&self, def_id: DefId) -> Instance<'tcx> {
-        Instance::mono(self.tcx, def_id)
-    }
-
-    /// Item requires monomorphization.
-    pub fn requires_monomorphization(&self, def_id: DefId) -> bool {
-        let generics = self.tcx.generics_of(def_id);
-        let result = generics.requires_monomorphization(self.tcx);
-        result
-    }
-
-    /// Resolve an instance from the given function definition and generic arguments.
-    pub fn resolve_instance(
-        &self,
-        def_id: DefId,
-        args_ref: GenericArgsRef<'tcx>,
-    ) -> Option<Instance<'tcx>> {
-        match Instance::try_resolve(self.tcx, self.fully_monomorphized(), def_id, args_ref) {
-            Ok(Some(instance)) => Some(instance),
-            Ok(None) | Err(_) => None,
-        }
-    }
-
-    /// Resolve an instance for drop_in_place for the given type.
-    pub fn resolve_drop_in_place(&self, internal_ty: Ty<'tcx>) -> Instance<'tcx> {
-        let instance = Instance::resolve_drop_in_place(self.tcx, internal_ty);
-        instance
-    }
-
-    /// Resolve instance for a function pointer.
-    pub fn resolve_for_fn_ptr(
-        &self,
-        def_id: DefId,
-        args_ref: GenericArgsRef<'tcx>,
-    ) -> Option<Instance<'tcx>> {
-        Instance::resolve_for_fn_ptr(self.tcx, self.fully_monomorphized(), def_id, args_ref)
-    }
-
-    /// Resolve instance for a closure with the requested type.
-    pub fn resolve_closure(
-        &self,
-        def_id: DefId,
-        args_ref: GenericArgsRef<'tcx>,
-        closure_kind: ClosureKind,
-    ) -> Option<Instance<'tcx>> {
-        Some(Instance::resolve_closure(self.tcx, def_id, args_ref, closure_kind))
-    }
-
-    /// Try to evaluate an instance into a constant.
-    pub fn eval_instance(
-        &self,
-        instance: ty::Instance<'tcx>,
-    ) -> Result<ConstValue<'tcx>, ErrorHandled> {
-        self.tcx.const_eval_instance(
-            self.fully_monomorphized(),
-            instance,
-            self.tcx.def_span(instance.def_id()),
-        )
-    }
-
-    /// Evaluate a static's initializer.
-    pub fn eval_static_initializer(
-        &self,
-        def_id: DefId,
-    ) -> Result<ConstAllocation<'tcx>, ErrorHandled> {
-        self.tcx.eval_static_initializer(def_id)
-    }
-
-    /// Retrieve global allocation for the given allocation ID.
-    pub fn global_alloc(&self, alloc_id: AllocId) -> GlobalAlloc<'tcx> {
-        self.tcx.global_alloc(alloc_id)
-    }
-
-    /// Retrieve the id for the virtual table.
-    pub fn vtable_allocation(
-        &self,
-        ty: Ty<'tcx>,
-        trait_ref: Option<Binder<'tcx, ExistentialTraitRef<'tcx>>>,
-    ) -> AllocId {
-        let alloc_id = self.tcx.vtable_allocation((
-            ty,
-            trait_ref.map(|principal| self.tcx.instantiate_bound_regions_with_erased(principal)),
-        ));
-        alloc_id
-    }
-
-    /// Retrieve the instance name for diagnostic messages.
-    ///
-    /// This will return the specialized name, e.g., `Vec<char>::new`.
-    pub fn instance_name(&self, instance: ty::Instance<'tcx>, trimmed: bool) -> String {
-        if trimmed {
-            with_forced_trimmed_paths!(
-                self.tcx.def_path_str_with_args(instance.def_id(), instance.args)
-            )
-        } else {
-            with_no_trimmed_paths!(
-                self.tcx.def_path_str_with_args(instance.def_id(), instance.args)
-            )
-        }
-    }
-
-    /// Get the layout of a type.
-    pub fn ty_layout(&self, ty: Ty<'tcx>) -> Result<Layout<'tcx>, B::Error> {
-        let layout = self.layout_of(ty)?.layout;
-        Ok(layout)
-    }
-
-    /// Get the resulting type of binary operation.
-    pub fn binop_ty(&self, bin_op: BinOp, rhs: Ty<'tcx>, lhs: Ty<'tcx>) -> Ty<'tcx> {
-        bin_op.ty(self.tcx, rhs, lhs)
-    }
-
-    /// Get the resulting type of unary operation.
-    pub fn unop_ty(&self, un_op: UnOp, arg: Ty<'tcx>) -> Ty<'tcx> {
-        un_op.ty(self.tcx, arg)
-    }
-
-    /// Get all associated items of a definition.
-    pub fn associated_items(&self, def_id: DefId) -> Vec<AssocItem> {
-        let assoc_items = if self.tcx.is_trait_alias(def_id) {
-            Vec::new()
-        } else {
-            self.tcx
-                .associated_item_def_ids(def_id)
-                .iter()
-                .map(|did| self.tcx.associated_item(*did))
-                .collect()
-        };
-        assoc_items
-    }
-}
diff --git a/compiler/rustc_smir/src/context/mod.rs b/compiler/rustc_smir/src/context/mod.rs
deleted file mode 100644
index da20be2a4b3..00000000000
--- a/compiler/rustc_smir/src/context/mod.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-//! Implementation of StableMIR Context.
-
-#![allow(rustc::usage_of_qualified_ty)]
-
-use std::marker::PhantomData;
-
-use rustc_abi::HasDataLayout;
-use rustc_middle::ty;
-use rustc_middle::ty::layout::{FnAbiOfHelpers, HasTyCtxt, HasTypingEnv, LayoutOfHelpers};
-use rustc_middle::ty::{Ty, TyCtxt};
-
-use crate::{Bridge, SmirError};
-
-mod impls;
-mod traits;
-
-pub use traits::*;
-
-/// Provides direct access to rustc's internal queries.
-///
-/// `SmirInterface` must go through
-/// this context to obtain rustc-level information.
-pub struct SmirCtxt<'tcx, B: Bridge> {
-    pub tcx: TyCtxt<'tcx>,
-    _marker: PhantomData<B>,
-}
-
-impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
-    pub fn new(tcx: TyCtxt<'tcx>) -> Self {
-        Self { tcx, _marker: Default::default() }
-    }
-}
-
-/// Implement error handling for extracting function ABI information.
-impl<'tcx, B: Bridge> FnAbiOfHelpers<'tcx> for SmirCtxt<'tcx, B> {
-    type FnAbiOfResult = Result<&'tcx rustc_target::callconv::FnAbi<'tcx, Ty<'tcx>>, B::Error>;
-
-    #[inline]
-    fn handle_fn_abi_err(
-        &self,
-        err: ty::layout::FnAbiError<'tcx>,
-        _span: rustc_span::Span,
-        fn_abi_request: ty::layout::FnAbiRequest<'tcx>,
-    ) -> B::Error {
-        B::Error::new(format!("Failed to get ABI for `{fn_abi_request:?}`: {err:?}"))
-    }
-}
-
-impl<'tcx, B: Bridge> LayoutOfHelpers<'tcx> for SmirCtxt<'tcx, B> {
-    type LayoutOfResult = Result<ty::layout::TyAndLayout<'tcx>, B::Error>;
-
-    #[inline]
-    fn handle_layout_err(
-        &self,
-        err: ty::layout::LayoutError<'tcx>,
-        _span: rustc_span::Span,
-        ty: Ty<'tcx>,
-    ) -> B::Error {
-        B::Error::new(format!("Failed to get layout for `{ty}`: {err}"))
-    }
-}
-
-impl<'tcx, B: Bridge> HasTypingEnv<'tcx> for SmirCtxt<'tcx, B> {
-    fn typing_env(&self) -> ty::TypingEnv<'tcx> {
-        ty::TypingEnv::fully_monomorphized()
-    }
-}
-
-impl<'tcx, B: Bridge> HasTyCtxt<'tcx> for SmirCtxt<'tcx, B> {
-    fn tcx(&self) -> TyCtxt<'tcx> {
-        self.tcx
-    }
-}
-
-impl<'tcx, B: Bridge> HasDataLayout for SmirCtxt<'tcx, B> {
-    fn data_layout(&self) -> &rustc_abi::TargetDataLayout {
-        self.tcx.data_layout()
-    }
-}
diff --git a/compiler/rustc_smir/src/context/traits.rs b/compiler/rustc_smir/src/context/traits.rs
deleted file mode 100644
index 8483bee4aad..00000000000
--- a/compiler/rustc_smir/src/context/traits.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! A set of traits that define a stable interface to rustc's internals.
-//!
-//! These traits abstract rustc's internal APIs, allowing StableMIR to maintain a stable
-//! interface regardless of internal compiler changes.
-
-use rustc_middle::mir::interpret::AllocRange;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
-use rustc_span::def_id::DefId;
-
-pub trait SmirTy<'tcx> {
-    fn new_foreign(&self, def_id: DefId) -> Ty<'tcx>;
-}
-
-pub trait SmirTypingEnv<'tcx> {
-    fn fully_monomorphized(&self) -> ty::TypingEnv<'tcx>;
-}
-
-pub trait SmirAllocRange<'tcx> {
-    fn alloc_range(&self, offset: rustc_abi::Size, size: rustc_abi::Size) -> AllocRange;
-}
diff --git a/compiler/rustc_smir/src/lib.rs b/compiler/rustc_smir/src/lib.rs
deleted file mode 100644
index fbebf98df7d..00000000000
--- a/compiler/rustc_smir/src/lib.rs
+++ /dev/null
@@ -1,305 +0,0 @@
-//! Crate that implements what will become the rustc side of Stable MIR.
-//!
-//! This crate is responsible for building Stable MIR components from internal components.
-//!
-//! This crate is not intended to be invoked directly by users.
-//! This crate is the public API of rustc that will be invoked by the `stable_mir` crate.
-//!
-//! For more information see <https://github.com/rust-lang/project-stable-mir>
-//!
-//! # Note
-//!
-//! This API is still completely unstable and subject to change.
-
-// tidy-alphabetical-start
-#![allow(internal_features)]
-#![allow(rustc::usage_of_ty_tykind)]
-#![doc(
-    html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/",
-    test(attr(allow(unused_variables), deny(warnings)))
-)]
-#![doc(rust_logo)]
-#![feature(rustdoc_internals)]
-#![feature(sized_hierarchy)]
-// tidy-alphabetical-end
-
-use std::cell::RefCell;
-use std::fmt::Debug;
-use std::hash::Hash;
-use std::ops::Index;
-
-use bridge::*;
-use context::SmirCtxt;
-use rustc_data_structures::fx::{self, FxIndexMap};
-use rustc_middle::mir;
-use rustc_middle::mir::interpret::AllocId;
-use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_span::Span;
-use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE};
-
-pub mod alloc;
-pub mod bridge;
-mod builder;
-pub mod context;
-
-#[deprecated(note = "please use `stable_mir::rustc_internal` instead")]
-pub mod rustc_internal {}
-
-/// A container which is used for TLS.
-pub struct SmirContainer<'tcx, B: Bridge> {
-    pub tables: RefCell<Tables<'tcx, B>>,
-    pub cx: RefCell<SmirCtxt<'tcx, B>>,
-}
-
-pub struct Tables<'tcx, B: Bridge> {
-    pub def_ids: IndexMap<DefId, B::DefId>,
-    pub alloc_ids: IndexMap<AllocId, B::AllocId>,
-    pub spans: IndexMap<rustc_span::Span, B::Span>,
-    pub types: IndexMap<Ty<'tcx>, B::Ty>,
-    pub instances: IndexMap<ty::Instance<'tcx>, B::InstanceDef>,
-    pub ty_consts: IndexMap<ty::Const<'tcx>, B::TyConstId>,
-    pub mir_consts: IndexMap<mir::Const<'tcx>, B::MirConstId>,
-    pub layouts: IndexMap<rustc_abi::Layout<'tcx>, B::Layout>,
-}
-
-impl<'tcx, B: Bridge> Default for Tables<'tcx, B> {
-    fn default() -> Self {
-        Self {
-            def_ids: IndexMap::default(),
-            alloc_ids: IndexMap::default(),
-            spans: IndexMap::default(),
-            types: IndexMap::default(),
-            instances: IndexMap::default(),
-            ty_consts: IndexMap::default(),
-            mir_consts: IndexMap::default(),
-            layouts: IndexMap::default(),
-        }
-    }
-}
-
-impl<'tcx, B: Bridge> Index<B::DefId> for Tables<'tcx, B> {
-    type Output = DefId;
-
-    #[inline(always)]
-    fn index(&self, index: B::DefId) -> &Self::Output {
-        &self.def_ids[index]
-    }
-}
-
-impl<'tcx, B: Bridge> Tables<'tcx, B> {
-    pub fn intern_ty(&mut self, ty: Ty<'tcx>) -> B::Ty {
-        self.types.create_or_fetch(ty)
-    }
-
-    pub fn intern_ty_const(&mut self, ct: ty::Const<'tcx>) -> B::TyConstId {
-        self.ty_consts.create_or_fetch(ct)
-    }
-
-    pub fn intern_mir_const(&mut self, constant: mir::Const<'tcx>) -> B::MirConstId {
-        self.mir_consts.create_or_fetch(constant)
-    }
-
-    pub fn create_def_id(&mut self, did: DefId) -> B::DefId {
-        self.def_ids.create_or_fetch(did)
-    }
-
-    pub fn create_alloc_id(&mut self, aid: AllocId) -> B::AllocId {
-        self.alloc_ids.create_or_fetch(aid)
-    }
-
-    pub fn create_span(&mut self, span: Span) -> B::Span {
-        self.spans.create_or_fetch(span)
-    }
-
-    pub fn instance_def(&mut self, instance: ty::Instance<'tcx>) -> B::InstanceDef {
-        self.instances.create_or_fetch(instance)
-    }
-
-    pub fn layout_id(&mut self, layout: rustc_abi::Layout<'tcx>) -> B::Layout {
-        self.layouts.create_or_fetch(layout)
-    }
-
-    pub fn crate_item(&mut self, did: rustc_span::def_id::DefId) -> B::CrateItem {
-        B::CrateItem::new(self.create_def_id(did))
-    }
-
-    pub fn adt_def(&mut self, did: rustc_span::def_id::DefId) -> B::AdtDef {
-        B::AdtDef::new(self.create_def_id(did))
-    }
-
-    pub fn foreign_module_def(&mut self, did: rustc_span::def_id::DefId) -> B::ForeignModuleDef {
-        B::ForeignModuleDef::new(self.create_def_id(did))
-    }
-
-    pub fn foreign_def(&mut self, did: rustc_span::def_id::DefId) -> B::ForeignDef {
-        B::ForeignDef::new(self.create_def_id(did))
-    }
-
-    pub fn fn_def(&mut self, did: rustc_span::def_id::DefId) -> B::FnDef {
-        B::FnDef::new(self.create_def_id(did))
-    }
-
-    pub fn closure_def(&mut self, did: rustc_span::def_id::DefId) -> B::ClosureDef {
-        B::ClosureDef::new(self.create_def_id(did))
-    }
-
-    pub fn coroutine_def(&mut self, did: rustc_span::def_id::DefId) -> B::CoroutineDef {
-        B::CoroutineDef::new(self.create_def_id(did))
-    }
-
-    pub fn coroutine_closure_def(
-        &mut self,
-        did: rustc_span::def_id::DefId,
-    ) -> B::CoroutineClosureDef {
-        B::CoroutineClosureDef::new(self.create_def_id(did))
-    }
-
-    pub fn alias_def(&mut self, did: rustc_span::def_id::DefId) -> B::AliasDef {
-        B::AliasDef::new(self.create_def_id(did))
-    }
-
-    pub fn param_def(&mut self, did: rustc_span::def_id::DefId) -> B::ParamDef {
-        B::ParamDef::new(self.create_def_id(did))
-    }
-
-    pub fn br_named_def(&mut self, did: rustc_span::def_id::DefId) -> B::BrNamedDef {
-        B::BrNamedDef::new(self.create_def_id(did))
-    }
-
-    pub fn trait_def(&mut self, did: rustc_span::def_id::DefId) -> B::TraitDef {
-        B::TraitDef::new(self.create_def_id(did))
-    }
-
-    pub fn generic_def(&mut self, did: rustc_span::def_id::DefId) -> B::GenericDef {
-        B::GenericDef::new(self.create_def_id(did))
-    }
-
-    pub fn const_def(&mut self, did: rustc_span::def_id::DefId) -> B::ConstDef {
-        B::ConstDef::new(self.create_def_id(did))
-    }
-
-    pub fn impl_def(&mut self, did: rustc_span::def_id::DefId) -> B::ImplDef {
-        B::ImplDef::new(self.create_def_id(did))
-    }
-
-    pub fn region_def(&mut self, did: rustc_span::def_id::DefId) -> B::RegionDef {
-        B::RegionDef::new(self.create_def_id(did))
-    }
-
-    pub fn coroutine_witness_def(
-        &mut self,
-        did: rustc_span::def_id::DefId,
-    ) -> B::CoroutineWitnessDef {
-        B::CoroutineWitnessDef::new(self.create_def_id(did))
-    }
-
-    pub fn assoc_def(&mut self, did: rustc_span::def_id::DefId) -> B::AssocDef {
-        B::AssocDef::new(self.create_def_id(did))
-    }
-
-    pub fn opaque_def(&mut self, did: rustc_span::def_id::DefId) -> B::OpaqueDef {
-        B::OpaqueDef::new(self.create_def_id(did))
-    }
-
-    pub fn prov(&mut self, aid: rustc_middle::mir::interpret::AllocId) -> B::Prov {
-        B::Prov::new(self.create_alloc_id(aid))
-    }
-
-    pub fn static_def(&mut self, did: rustc_span::def_id::DefId) -> B::StaticDef {
-        B::StaticDef::new(self.create_def_id(did))
-    }
-}
-
-/// A trait defining types that are used to emulate StableMIR components, which is really
-/// useful when programming in stable_mir-agnostic settings.
-pub trait Bridge: Sized {
-    type DefId: Copy + Debug + PartialEq + IndexedVal;
-    type AllocId: Copy + Debug + PartialEq + IndexedVal;
-    type Span: Copy + Debug + PartialEq + IndexedVal;
-    type Ty: Copy + Debug + PartialEq + IndexedVal;
-    type InstanceDef: Copy + Debug + PartialEq + IndexedVal;
-    type TyConstId: Copy + Debug + PartialEq + IndexedVal;
-    type MirConstId: Copy + Debug + PartialEq + IndexedVal;
-    type Layout: Copy + Debug + PartialEq + IndexedVal;
-
-    type Error: SmirError;
-    type CrateItem: CrateItem<Self>;
-    type AdtDef: AdtDef<Self>;
-    type ForeignModuleDef: ForeignModuleDef<Self>;
-    type ForeignDef: ForeignDef<Self>;
-    type FnDef: FnDef<Self>;
-    type ClosureDef: ClosureDef<Self>;
-    type CoroutineDef: CoroutineDef<Self>;
-    type CoroutineClosureDef: CoroutineClosureDef<Self>;
-    type AliasDef: AliasDef<Self>;
-    type ParamDef: ParamDef<Self>;
-    type BrNamedDef: BrNamedDef<Self>;
-    type TraitDef: TraitDef<Self>;
-    type GenericDef: GenericDef<Self>;
-    type ConstDef: ConstDef<Self>;
-    type ImplDef: ImplDef<Self>;
-    type RegionDef: RegionDef<Self>;
-    type CoroutineWitnessDef: CoroutineWitnessDef<Self>;
-    type AssocDef: AssocDef<Self>;
-    type OpaqueDef: OpaqueDef<Self>;
-    type Prov: Prov<Self>;
-    type StaticDef: StaticDef<Self>;
-
-    type Allocation: Allocation<Self>;
-}
-
-pub trait IndexedVal {
-    fn to_val(index: usize) -> Self;
-
-    fn to_index(&self) -> usize;
-}
-
-/// Similar to rustc's `FxIndexMap`, `IndexMap` with extra
-/// safety features added.
-pub struct IndexMap<K, V> {
-    index_map: fx::FxIndexMap<K, V>,
-}
-
-impl<K, V> Default for IndexMap<K, V> {
-    fn default() -> Self {
-        Self { index_map: FxIndexMap::default() }
-    }
-}
-
-impl<K: PartialEq + Hash + Eq, V: Copy + Debug + PartialEq + IndexedVal> IndexMap<K, V> {
-    pub fn create_or_fetch(&mut self, key: K) -> V {
-        let len = self.index_map.len();
-        let v = self.index_map.entry(key).or_insert(V::to_val(len));
-        *v
-    }
-}
-
-impl<K: PartialEq + Hash + Eq, V: Copy + Debug + PartialEq + IndexedVal> Index<V>
-    for IndexMap<K, V>
-{
-    type Output = K;
-
-    fn index(&self, index: V) -> &Self::Output {
-        let (k, v) = self.index_map.get_index(index.to_index()).unwrap();
-        assert_eq!(*v, index, "Provided value doesn't match with indexed value");
-        k
-    }
-}
-
-/// Iterate over the definitions of the given crate.
-pub(crate) fn filter_def_ids<F, T>(tcx: TyCtxt<'_>, krate: CrateNum, mut func: F) -> Vec<T>
-where
-    F: FnMut(DefId) -> Option<T>,
-{
-    if krate == LOCAL_CRATE {
-        tcx.iter_local_def_id().filter_map(|did| func(did.to_def_id())).collect()
-    } else {
-        let num_definitions = tcx.num_extern_def_ids(krate);
-        (0..num_definitions)
-            .filter_map(move |i| {
-                let def_id = DefId { krate, index: rustc_span::def_id::DefIndex::from_usize(i) };
-                func(def_id)
-            })
-            .collect()
-    }
-}
diff --git a/compiler/stable_mir/Cargo.toml b/compiler/stable_mir/Cargo.toml
deleted file mode 100644
index 6777abce01d..00000000000
--- a/compiler/stable_mir/Cargo.toml
+++ /dev/null
@@ -1,24 +0,0 @@
-[package]
-name = "stable_mir"
-version = "0.1.0-preview"
-edition = "2024"
-
-[dependencies]
-# tidy-alphabetical-start
-rustc_abi = { path = "../rustc_abi" }
-rustc_hir = { path = "../rustc_hir" }
-rustc_middle = { path = "../rustc_middle" }
-rustc_session = { path = "../rustc_session" }
-rustc_smir = { path = "../rustc_smir" }
-rustc_span = { path = "../rustc_span" }
-rustc_target = { path = "../rustc_target" }
-scoped-tls = "1.0"
-serde = { version = "1.0.125", features = [ "derive" ] }
-tracing = "0.1"
-# tidy-alphabetical-end
-
-[features]
-# Provides access to APIs that expose internals of the rust compiler.
-# APIs enabled by this feature are unstable. They can be removed or modified
-# at any point and they are not included in the crate's semantic versioning.
-rustc_internal = []
diff --git a/compiler/stable_mir/README.md b/compiler/stable_mir/README.md
deleted file mode 100644
index ab2546e377a..00000000000
--- a/compiler/stable_mir/README.md
+++ /dev/null
@@ -1,46 +0,0 @@
-This crate is currently developed in-tree together with the compiler.
-
-Our goal is to start publishing `stable_mir` into crates.io.
-Until then, users will use this as any other rustc crate, by installing
-the rustup component `rustc-dev`, and declaring `stable-mir` as an external crate.
-
-See the StableMIR ["Getting Started"](https://rust-lang.github.io/project-stable-mir/getting-started.html)
-guide for more information.
-
-## Stable MIR Design
-
-The stable-mir will follow a similar approach to proc-macro2. Its
-implementation is split between two main crates:
-
-- `stable_mir`: Public crate, to be published on crates.io, which will contain
-the stable data structure as well as calls to `rustc_smir` APIs. The
-translation between stable and internal constructs will also be done in this crate,
-however, this is currently implemented in the `rustc_smir` crate.[^translation].
-- `rustc_smir`: This crate implements the public APIs to the compiler.
-It is responsible for gathering all the information requested, and providing
-the data in its unstable form.
-
-[^translation]: This is currently implemented in the `rustc_smir` crate,
-but we are working to change that.
-
-I.e.,
-tools will depend on `stable_mir` crate,
-which will invoke the compiler using APIs defined in `rustc_smir`.
-
-I.e.:
-
-```
-    ┌──────────────────────────────────┐           ┌──────────────────────────────────┐
-    │   External Tool     ┌──────────┐ │           │ ┌──────────┐   Rust Compiler     │
-    │                     │          │ │           │ │          │                     │
-    │                     │stable_mir| │           │ │rustc_smir│                     │
-    │                     │          │ ├──────────►| │          │                     │
-    │                     │          │ │◄──────────┤ │          │                     │
-    │                     │          │ │           │ │          │                     │
-    │                     │          │ │           │ │          │                     │
-    │                     └──────────┘ │           │ └──────────┘                     │
-    └──────────────────────────────────┘           └──────────────────────────────────┘
-```
-
-More details can be found here:
-https://hackmd.io/XhnYHKKuR6-LChhobvlT-g?view
diff --git a/compiler/stable_mir/rust-toolchain.toml b/compiler/stable_mir/rust-toolchain.toml
deleted file mode 100644
index d75e8e33b1c..00000000000
--- a/compiler/stable_mir/rust-toolchain.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-[toolchain]
-channel = "nightly-2023-06-14"
-components = [ "rustfmt", "rustc-dev" ]
diff --git a/compiler/stable_mir/src/abi.rs b/compiler/stable_mir/src/abi.rs
deleted file mode 100644
index 7b0882caf1b..00000000000
--- a/compiler/stable_mir/src/abi.rs
+++ /dev/null
@@ -1,493 +0,0 @@
-use std::fmt::{self, Debug};
-use std::num::NonZero;
-use std::ops::RangeInclusive;
-
-use serde::Serialize;
-
-use crate::compiler_interface::with;
-use crate::mir::FieldIdx;
-use crate::target::{MachineInfo, MachineSize as Size};
-use crate::ty::{Align, Ty, VariantIdx};
-use crate::{Error, Opaque, error};
-
-/// A function ABI definition.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct FnAbi {
-    /// The types of each argument.
-    pub args: Vec<ArgAbi>,
-
-    /// The expected return type.
-    pub ret: ArgAbi,
-
-    /// The count of non-variadic arguments.
-    ///
-    /// Should only be different from `args.len()` when a function is a C variadic function.
-    pub fixed_count: u32,
-
-    /// The ABI convention.
-    pub conv: CallConvention,
-
-    /// Whether this is a variadic C function,
-    pub c_variadic: bool,
-}
-
-/// Information about the ABI of a function's argument, or return value.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct ArgAbi {
-    pub ty: Ty,
-    pub layout: Layout,
-    pub mode: PassMode,
-}
-
-/// How a function argument should be passed in to the target function.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub enum PassMode {
-    /// Ignore the argument.
-    ///
-    /// The argument is either uninhabited or a ZST.
-    Ignore,
-    /// Pass the argument directly.
-    ///
-    /// The argument has a layout abi of `Scalar` or `Vector`.
-    Direct(Opaque),
-    /// Pass a pair's elements directly in two arguments.
-    ///
-    /// The argument has a layout abi of `ScalarPair`.
-    Pair(Opaque, Opaque),
-    /// Pass the argument after casting it.
-    Cast { pad_i32: bool, cast: Opaque },
-    /// Pass the argument indirectly via a hidden pointer.
-    Indirect { attrs: Opaque, meta_attrs: Opaque, on_stack: bool },
-}
-
-/// The layout of a type, alongside the type itself.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct TyAndLayout {
-    pub ty: Ty,
-    pub layout: Layout,
-}
-
-/// The layout of a type in memory.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct LayoutShape {
-    /// The fields location within the layout
-    pub fields: FieldsShape,
-
-    /// Encodes information about multi-variant layouts.
-    /// Even with `Multiple` variants, a layout still has its own fields! Those are then
-    /// shared between all variants.
-    ///
-    /// To access all fields of this layout, both `fields` and the fields of the active variant
-    /// must be taken into account.
-    pub variants: VariantsShape,
-
-    /// The `abi` defines how this data is passed between functions.
-    pub abi: ValueAbi,
-
-    /// The ABI mandated alignment in bytes.
-    pub abi_align: Align,
-
-    /// The size of this layout in bytes.
-    pub size: Size,
-}
-
-impl LayoutShape {
-    /// Returns `true` if the layout corresponds to an unsized type.
-    #[inline]
-    pub fn is_unsized(&self) -> bool {
-        self.abi.is_unsized()
-    }
-
-    #[inline]
-    pub fn is_sized(&self) -> bool {
-        !self.abi.is_unsized()
-    }
-
-    /// Returns `true` if the type is sized and a 1-ZST (meaning it has size 0 and alignment 1).
-    pub fn is_1zst(&self) -> bool {
-        self.is_sized() && self.size.bits() == 0 && self.abi_align == 1
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct Layout(usize);
-
-impl Layout {
-    pub fn shape(self) -> LayoutShape {
-        with(|cx| cx.layout_shape(self))
-    }
-}
-
-impl crate::IndexedVal for Layout {
-    fn to_val(index: usize) -> Self {
-        Layout(index)
-    }
-    fn to_index(&self) -> usize {
-        self.0
-    }
-}
-
-/// Describes how the fields of a type are shaped in memory.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub enum FieldsShape {
-    /// Scalar primitives and `!`, which never have fields.
-    Primitive,
-
-    /// All fields start at no offset. The `usize` is the field count.
-    Union(NonZero<usize>),
-
-    /// Array/vector-like placement, with all fields of identical types.
-    Array { stride: Size, count: u64 },
-
-    /// Struct-like placement, with precomputed offsets.
-    ///
-    /// Fields are guaranteed to not overlap, but note that gaps
-    /// before, between and after all the fields are NOT always
-    /// padding, and as such their contents may not be discarded.
-    /// For example, enum variants leave a gap at the start,
-    /// where the discriminant field in the enum layout goes.
-    Arbitrary {
-        /// Offsets for the first byte of each field,
-        /// ordered to match the source definition order.
-        /// I.e.: It follows the same order as [super::ty::VariantDef::fields()].
-        /// This vector does not go in increasing order.
-        offsets: Vec<Size>,
-    },
-}
-
-impl FieldsShape {
-    pub fn fields_by_offset_order(&self) -> Vec<FieldIdx> {
-        match self {
-            FieldsShape::Primitive => vec![],
-            FieldsShape::Union(_) | FieldsShape::Array { .. } => (0..self.count()).collect(),
-            FieldsShape::Arbitrary { offsets, .. } => {
-                let mut indices = (0..offsets.len()).collect::<Vec<_>>();
-                indices.sort_by_key(|idx| offsets[*idx]);
-                indices
-            }
-        }
-    }
-
-    pub fn count(&self) -> usize {
-        match self {
-            FieldsShape::Primitive => 0,
-            FieldsShape::Union(count) => count.get(),
-            FieldsShape::Array { count, .. } => *count as usize,
-            FieldsShape::Arbitrary { offsets, .. } => offsets.len(),
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub enum VariantsShape {
-    /// A type with no valid variants. Must be uninhabited.
-    Empty,
-
-    /// Single enum variants, structs/tuples, unions, and all non-ADTs.
-    Single { index: VariantIdx },
-
-    /// Enum-likes with more than one inhabited variant: each variant comes with
-    /// a *discriminant* (usually the same as the variant index but the user can
-    /// assign explicit discriminant values). That discriminant is encoded
-    /// as a *tag* on the machine. The layout of each variant is
-    /// a struct, and they all have space reserved for the tag.
-    /// For enums, the tag is the sole field of the layout.
-    Multiple {
-        tag: Scalar,
-        tag_encoding: TagEncoding,
-        tag_field: usize,
-        variants: Vec<LayoutShape>,
-    },
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub enum TagEncoding {
-    /// The tag directly stores the discriminant, but possibly with a smaller layout
-    /// (so converting the tag to the discriminant can require sign extension).
-    Direct,
-
-    /// Niche (values invalid for a type) encoding the discriminant:
-    /// Discriminant and variant index coincide.
-    /// The variant `untagged_variant` contains a niche at an arbitrary
-    /// offset (field `tag_field` of the enum), which for a variant with
-    /// discriminant `d` is set to
-    /// `(d - niche_variants.start).wrapping_add(niche_start)`.
-    ///
-    /// For example, `Option<(usize, &T)>`  is represented such that
-    /// `None` has a null pointer for the second tuple field, and
-    /// `Some` is the identity function (with a non-null reference).
-    Niche {
-        untagged_variant: VariantIdx,
-        niche_variants: RangeInclusive<VariantIdx>,
-        niche_start: u128,
-    },
-}
-
-/// Describes how values of the type are passed by target ABIs,
-/// in terms of categories of C types there are ABI rules for.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub enum ValueAbi {
-    Scalar(Scalar),
-    ScalarPair(Scalar, Scalar),
-    Vector {
-        element: Scalar,
-        count: u64,
-    },
-    Aggregate {
-        /// If true, the size is exact, otherwise it's only a lower bound.
-        sized: bool,
-    },
-}
-
-impl ValueAbi {
-    /// Returns `true` if the layout corresponds to an unsized type.
-    pub fn is_unsized(&self) -> bool {
-        match *self {
-            ValueAbi::Scalar(_) | ValueAbi::ScalarPair(..) | ValueAbi::Vector { .. } => false,
-            ValueAbi::Aggregate { sized } => !sized,
-        }
-    }
-}
-
-/// Information about one scalar component of a Rust type.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Serialize)]
-pub enum Scalar {
-    Initialized {
-        /// The primitive type used to represent this value.
-        value: Primitive,
-        /// The range that represents valid values.
-        /// The range must be valid for the `primitive` size.
-        valid_range: WrappingRange,
-    },
-    Union {
-        /// Unions never have niches, so there is no `valid_range`.
-        /// Even for unions, we need to use the correct registers for the kind of
-        /// values inside the union, so we keep the `Primitive` type around.
-        /// It is also used to compute the size of the scalar.
-        value: Primitive,
-    },
-}
-
-impl Scalar {
-    pub fn has_niche(&self, target: &MachineInfo) -> bool {
-        match self {
-            Scalar::Initialized { value, valid_range } => {
-                !valid_range.is_full(value.size(target)).unwrap()
-            }
-            Scalar::Union { .. } => false,
-        }
-    }
-}
-
-/// Fundamental unit of memory access and layout.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Serialize)]
-pub enum Primitive {
-    /// The `bool` is the signedness of the `Integer` type.
-    ///
-    /// One would think we would not care about such details this low down,
-    /// but some ABIs are described in terms of C types and ISAs where the
-    /// integer arithmetic is done on {sign,zero}-extended registers, e.g.
-    /// a negative integer passed by zero-extension will appear positive in
-    /// the callee, and most operations on it will produce the wrong values.
-    Int {
-        length: IntegerLength,
-        signed: bool,
-    },
-    Float {
-        length: FloatLength,
-    },
-    Pointer(AddressSpace),
-}
-
-impl Primitive {
-    pub fn size(self, target: &MachineInfo) -> Size {
-        match self {
-            Primitive::Int { length, .. } => Size::from_bits(length.bits()),
-            Primitive::Float { length } => Size::from_bits(length.bits()),
-            Primitive::Pointer(_) => target.pointer_width,
-        }
-    }
-}
-
-/// Enum representing the existing integer lengths.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
-pub enum IntegerLength {
-    I8,
-    I16,
-    I32,
-    I64,
-    I128,
-}
-
-/// Enum representing the existing float lengths.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
-pub enum FloatLength {
-    F16,
-    F32,
-    F64,
-    F128,
-}
-
-impl IntegerLength {
-    pub fn bits(self) -> usize {
-        match self {
-            IntegerLength::I8 => 8,
-            IntegerLength::I16 => 16,
-            IntegerLength::I32 => 32,
-            IntegerLength::I64 => 64,
-            IntegerLength::I128 => 128,
-        }
-    }
-}
-
-impl FloatLength {
-    pub fn bits(self) -> usize {
-        match self {
-            FloatLength::F16 => 16,
-            FloatLength::F32 => 32,
-            FloatLength::F64 => 64,
-            FloatLength::F128 => 128,
-        }
-    }
-}
-
-/// An identifier that specifies the address space that some operation
-/// should operate on. Special address spaces have an effect on code generation,
-/// depending on the target and the address spaces it implements.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
-pub struct AddressSpace(pub u32);
-
-impl AddressSpace {
-    /// The default address space, corresponding to data space.
-    pub const DATA: Self = AddressSpace(0);
-}
-
-/// Inclusive wrap-around range of valid values (bitwise representation), that is, if
-/// start > end, it represents `start..=MAX`, followed by `0..=end`.
-///
-/// That is, for an i8 primitive, a range of `254..=2` means following
-/// sequence:
-///
-///    254 (-2), 255 (-1), 0, 1, 2
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize)]
-pub struct WrappingRange {
-    pub start: u128,
-    pub end: u128,
-}
-
-impl WrappingRange {
-    /// Returns `true` if `size` completely fills the range.
-    #[inline]
-    pub fn is_full(&self, size: Size) -> Result<bool, Error> {
-        let Some(max_value) = size.unsigned_int_max() else {
-            return Err(error!("Expected size <= 128 bits, but found {} instead", size.bits()));
-        };
-        if self.start <= max_value && self.end <= max_value {
-            Ok(self.start == (self.end.wrapping_add(1) & max_value))
-        } else {
-            Err(error!("Range `{self:?}` out of bounds for size `{}` bits.", size.bits()))
-        }
-    }
-
-    /// Returns `true` if `v` is contained in the range.
-    #[inline(always)]
-    pub fn contains(&self, v: u128) -> bool {
-        if self.wraps_around() {
-            self.start <= v || v <= self.end
-        } else {
-            self.start <= v && v <= self.end
-        }
-    }
-
-    /// Returns `true` if the range wraps around.
-    /// I.e., the range represents the union of `self.start..=MAX` and `0..=self.end`.
-    /// Returns `false` if this is a non-wrapping range, i.e.: `self.start..=self.end`.
-    #[inline]
-    pub fn wraps_around(&self) -> bool {
-        self.start > self.end
-    }
-}
-
-impl Debug for WrappingRange {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.start > self.end {
-            write!(fmt, "(..={}) | ({}..)", self.end, self.start)?;
-        } else {
-            write!(fmt, "{}..={}", self.start, self.end)?;
-        }
-        Ok(())
-    }
-}
-
-/// General language calling conventions.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub enum CallConvention {
-    C,
-    Rust,
-
-    Cold,
-    PreserveMost,
-    PreserveAll,
-
-    Custom,
-
-    // Target-specific calling conventions.
-    ArmAapcs,
-    CCmseNonSecureCall,
-    CCmseNonSecureEntry,
-
-    Msp430Intr,
-
-    PtxKernel,
-
-    GpuKernel,
-
-    X86Fastcall,
-    X86Intr,
-    X86Stdcall,
-    X86ThisCall,
-    X86VectorCall,
-
-    X86_64SysV,
-    X86_64Win64,
-
-    AvrInterrupt,
-    AvrNonBlockingInterrupt,
-
-    RiscvInterrupt,
-}
-
-#[non_exhaustive]
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
-pub struct ReprFlags {
-    pub is_simd: bool,
-    pub is_c: bool,
-    pub is_transparent: bool,
-    pub is_linear: bool,
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
-pub enum IntegerType {
-    /// Pointer-sized integer type, i.e. `isize` and `usize`.
-    Pointer {
-        /// Signedness. e.g. `true` for `isize`
-        is_signed: bool,
-    },
-    /// Fixed-sized integer type, e.g. `i8`, `u32`, `i128`.
-    Fixed {
-        /// Length of this integer type. e.g. `IntegerLength::I8` for `u8`.
-        length: IntegerLength,
-        /// Signedness. e.g. `false` for `u8`
-        is_signed: bool,
-    },
-}
-
-/// Representation options provided by the user
-#[non_exhaustive]
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
-pub struct ReprOptions {
-    pub int: Option<IntegerType>,
-    pub align: Option<Align>,
-    pub pack: Option<Align>,
-    pub flags: ReprFlags,
-}
diff --git a/compiler/stable_mir/src/alloc.rs b/compiler/stable_mir/src/alloc.rs
deleted file mode 100644
index 349b83231e3..00000000000
--- a/compiler/stable_mir/src/alloc.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-//! Memory allocation implementation for StableMIR.
-//!
-//! This module is responsible for constructing stable components.
-//! All operations requiring rustc queries must be delegated
-//! to `rustc_smir::alloc` to maintain stability guarantees.
-
-use rustc_abi::Align;
-use rustc_middle::mir::ConstValue;
-use rustc_middle::mir::interpret::AllocRange;
-use rustc_smir::bridge::SmirError;
-use rustc_smir::context::SmirCtxt;
-use rustc_smir::{Tables, alloc};
-
-use super::Error;
-use super::compiler_interface::BridgeTys;
-use super::mir::Mutability;
-use super::ty::{Allocation, ProvenanceMap};
-use super::unstable::Stable;
-
-/// Creates new empty `Allocation` from given `Align`.
-fn new_empty_allocation(align: Align) -> Allocation {
-    Allocation {
-        bytes: Vec::new(),
-        provenance: ProvenanceMap { ptrs: Vec::new() },
-        align: align.bytes(),
-        mutability: Mutability::Not,
-    }
-}
-
-// We need this method instead of a Stable implementation
-// because we need to get `Ty` of the const we are trying to create, to do that
-// we need to have access to `ConstantKind` but we can't access that inside Stable impl.
-#[allow(rustc::usage_of_qualified_ty)]
-pub(crate) fn new_allocation<'tcx>(
-    ty: rustc_middle::ty::Ty<'tcx>,
-    const_value: ConstValue<'tcx>,
-    tables: &mut Tables<'tcx, BridgeTys>,
-    cx: &SmirCtxt<'tcx, BridgeTys>,
-) -> Allocation {
-    try_new_allocation(ty, const_value, tables, cx)
-        .unwrap_or_else(|_| panic!("Failed to convert: {const_value:?} to {ty:?}"))
-}
-
-#[allow(rustc::usage_of_qualified_ty)]
-pub(crate) fn try_new_allocation<'tcx>(
-    ty: rustc_middle::ty::Ty<'tcx>,
-    const_value: ConstValue<'tcx>,
-    tables: &mut Tables<'tcx, BridgeTys>,
-    cx: &SmirCtxt<'tcx, BridgeTys>,
-) -> Result<Allocation, Error> {
-    let layout = alloc::create_ty_and_layout(cx, ty).map_err(|e| Error::from_internal(e))?;
-    match const_value {
-        ConstValue::Scalar(scalar) => {
-            alloc::try_new_scalar(layout, scalar, cx).map(|alloc| alloc.stable(tables, cx))
-        }
-        ConstValue::ZeroSized => Ok(new_empty_allocation(layout.align.abi)),
-        ConstValue::Slice { data, meta } => {
-            alloc::try_new_slice(layout, data, meta, cx).map(|alloc| alloc.stable(tables, cx))
-        }
-        ConstValue::Indirect { alloc_id, offset } => {
-            let alloc = alloc::try_new_indirect(alloc_id, cx);
-            use rustc_smir::context::SmirAllocRange;
-            Ok(allocation_filter(&alloc.0, cx.alloc_range(offset, layout.size), tables, cx))
-        }
-    }
-}
-
-/// Creates an `Allocation` only from information within the `AllocRange`.
-pub(super) fn allocation_filter<'tcx>(
-    alloc: &rustc_middle::mir::interpret::Allocation,
-    alloc_range: AllocRange,
-    tables: &mut Tables<'tcx, BridgeTys>,
-    cx: &SmirCtxt<'tcx, BridgeTys>,
-) -> Allocation {
-    alloc::allocation_filter(alloc, alloc_range, tables, cx)
-}
diff --git a/compiler/stable_mir/src/compiler_interface.rs b/compiler/stable_mir/src/compiler_interface.rs
deleted file mode 100644
index 50c2f02e6ad..00000000000
--- a/compiler/stable_mir/src/compiler_interface.rs
+++ /dev/null
@@ -1,1099 +0,0 @@
-//! Define the interface with the Rust compiler.
-//!
-//! StableMIR users should not use any of the items in this module directly.
-//! These APIs have no stability guarantee.
-
-use std::cell::Cell;
-
-use rustc_hir::def::DefKind;
-use rustc_smir::context::SmirCtxt;
-use rustc_smir::{Bridge, SmirContainer};
-use tracing::debug;
-
-use crate::abi::{FnAbi, Layout, LayoutShape, ReprOptions};
-use crate::crate_def::Attribute;
-use crate::mir::alloc::{AllocId, GlobalAlloc};
-use crate::mir::mono::{Instance, InstanceDef, StaticDef};
-use crate::mir::{BinOp, Body, Place, UnOp};
-use crate::target::{MachineInfo, MachineSize};
-use crate::ty::{
-    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,
-};
-use crate::unstable::{RustcInternal, Stable, new_item_kind};
-use crate::{
-    AssocItems, Crate, CrateDef, CrateItem, CrateItems, CrateNum, DefId, Error, Filename,
-    ImplTraitDecls, ItemKind, Symbol, TraitDecls, alloc, mir,
-};
-
-pub struct BridgeTys;
-
-impl Bridge for BridgeTys {
-    type DefId = crate::DefId;
-    type AllocId = crate::mir::alloc::AllocId;
-    type Span = crate::ty::Span;
-    type Ty = crate::ty::Ty;
-    type InstanceDef = crate::mir::mono::InstanceDef;
-    type TyConstId = crate::ty::TyConstId;
-    type MirConstId = crate::ty::MirConstId;
-    type Layout = crate::abi::Layout;
-
-    type Error = crate::Error;
-    type CrateItem = crate::CrateItem;
-    type AdtDef = crate::ty::AdtDef;
-    type ForeignModuleDef = crate::ty::ForeignModuleDef;
-    type ForeignDef = crate::ty::ForeignDef;
-    type FnDef = crate::ty::FnDef;
-    type ClosureDef = crate::ty::ClosureDef;
-    type CoroutineDef = crate::ty::CoroutineDef;
-    type CoroutineClosureDef = crate::ty::CoroutineClosureDef;
-    type AliasDef = crate::ty::AliasDef;
-    type ParamDef = crate::ty::ParamDef;
-    type BrNamedDef = crate::ty::BrNamedDef;
-    type TraitDef = crate::ty::TraitDef;
-    type GenericDef = crate::ty::GenericDef;
-    type ConstDef = crate::ty::ConstDef;
-    type ImplDef = crate::ty::ImplDef;
-    type RegionDef = crate::ty::RegionDef;
-    type CoroutineWitnessDef = crate::ty::CoroutineWitnessDef;
-    type AssocDef = crate::ty::AssocDef;
-    type OpaqueDef = crate::ty::OpaqueDef;
-    type Prov = crate::ty::Prov;
-    type StaticDef = crate::mir::mono::StaticDef;
-
-    type Allocation = crate::ty::Allocation;
-}
-
-/// Stable public API for querying compiler information.
-///
-/// All queries are delegated to [`rustc_smir::context::SmirCtxt`] that provides
-/// similar APIs but based on internal rustc constructs.
-///
-/// Do not use this directly. This is currently used in the macro expansion.
-pub(crate) trait SmirInterface {
-    fn entry_fn(&self) -> Option<CrateItem>;
-    /// Retrieve all items of the local crate that have a MIR associated with them.
-    fn all_local_items(&self) -> CrateItems;
-    /// Retrieve the body of a function.
-    /// This function will panic if the body is not available.
-    fn mir_body(&self, item: DefId) -> mir::Body;
-    /// Check whether the body of a function is available.
-    fn has_body(&self, item: DefId) -> bool;
-    fn foreign_modules(&self, crate_num: CrateNum) -> Vec<ForeignModuleDef>;
-
-    /// Retrieve all functions defined in this crate.
-    fn crate_functions(&self, crate_num: CrateNum) -> Vec<FnDef>;
-
-    /// Retrieve all static items defined in this crate.
-    fn crate_statics(&self, crate_num: CrateNum) -> Vec<StaticDef>;
-    fn foreign_module(&self, mod_def: ForeignModuleDef) -> ForeignModule;
-    fn foreign_items(&self, mod_def: ForeignModuleDef) -> Vec<ForeignDef>;
-    fn all_trait_decls(&self) -> TraitDecls;
-    fn trait_decls(&self, crate_num: CrateNum) -> TraitDecls;
-    fn trait_decl(&self, trait_def: &TraitDef) -> TraitDecl;
-    fn all_trait_impls(&self) -> ImplTraitDecls;
-    fn trait_impls(&self, crate_num: CrateNum) -> ImplTraitDecls;
-    fn trait_impl(&self, trait_impl: &ImplDef) -> ImplTrait;
-    fn generics_of(&self, def_id: DefId) -> Generics;
-    fn predicates_of(&self, def_id: DefId) -> GenericPredicates;
-    fn explicit_predicates_of(&self, def_id: DefId) -> GenericPredicates;
-
-    /// Get information about the local crate.
-    fn local_crate(&self) -> Crate;
-    /// Retrieve a list of all external crates.
-    fn external_crates(&self) -> Vec<Crate>;
-
-    /// Find a crate with the given name.
-    fn find_crates(&self, name: &str) -> Vec<Crate>;
-
-    /// Returns the name of given `DefId`
-    fn def_name(&self, def_id: DefId, trimmed: bool) -> Symbol;
-
-    /// Return registered tool attributes with the given attribute name.
-    ///
-    /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool
-    /// attributes will simply return an empty list.
-    ///
-    /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`.
-    /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`.
-    fn tool_attrs(&self, def_id: DefId, attr: &[Symbol]) -> Vec<Attribute>;
-
-    /// Get all tool attributes of a definition.
-    fn all_tool_attrs(&self, def_id: DefId) -> Vec<Attribute>;
-
-    /// Returns printable, human readable form of `Span`
-    fn span_to_string(&self, span: Span) -> String;
-
-    /// Return filename from given `Span`, for diagnostic purposes
-    fn get_filename(&self, span: &Span) -> Filename;
-
-    /// Return lines corresponding to this `Span`
-    fn get_lines(&self, span: &Span) -> LineInfo;
-
-    /// Returns the `kind` of given `DefId`
-    fn item_kind(&self, item: CrateItem) -> ItemKind;
-
-    /// Returns whether this is a foreign item.
-    fn is_foreign_item(&self, item: DefId) -> bool;
-
-    /// Returns the kind of a given foreign item.
-    fn foreign_item_kind(&self, def: ForeignDef) -> ForeignItemKind;
-
-    /// Returns the kind of a given algebraic data type
-    fn adt_kind(&self, def: AdtDef) -> AdtKind;
-
-    /// Returns if the ADT is a box.
-    fn adt_is_box(&self, def: AdtDef) -> bool;
-
-    /// Returns whether this ADT is simd.
-    fn adt_is_simd(&self, def: AdtDef) -> bool;
-
-    /// Returns whether this definition is a C string.
-    fn adt_is_cstr(&self, def: AdtDef) -> bool;
-
-    /// Returns the representation options for this ADT.
-    fn adt_repr(&self, def: AdtDef) -> ReprOptions;
-
-    /// Retrieve the function signature for the given generic arguments.
-    fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig;
-
-    /// Retrieve the intrinsic definition if the item corresponds one.
-    fn intrinsic(&self, item: DefId) -> Option<IntrinsicDef>;
-
-    /// Retrieve the plain function name of an intrinsic.
-    fn intrinsic_name(&self, def: IntrinsicDef) -> Symbol;
-
-    /// Retrieve the closure signature for the given generic arguments.
-    fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig;
-
-    /// The number of variants in this ADT.
-    fn adt_variants_len(&self, def: AdtDef) -> usize;
-
-    /// Discriminant for a given variant index of AdtDef.
-    fn adt_discr_for_variant(&self, adt: AdtDef, variant: VariantIdx) -> Discr;
-
-    /// Discriminant for a given variand index and args of a coroutine.
-    fn coroutine_discr_for_variant(
-        &self,
-        coroutine: CoroutineDef,
-        args: &GenericArgs,
-        variant: VariantIdx,
-    ) -> Discr;
-
-    /// The name of a variant.
-    fn variant_name(&self, def: VariantDef) -> Symbol;
-    fn variant_fields(&self, def: VariantDef) -> Vec<FieldDef>;
-
-    /// Evaluate constant as a target usize.
-    fn eval_target_usize(&self, cnst: &MirConst) -> Result<u64, Error>;
-    fn eval_target_usize_ty(&self, cnst: &TyConst) -> Result<u64, Error>;
-
-    /// Create a new zero-sized constant.
-    fn try_new_const_zst(&self, ty: Ty) -> Result<MirConst, Error>;
-
-    /// Create a new constant that represents the given string value.
-    fn new_const_str(&self, value: &str) -> MirConst;
-
-    /// Create a new constant that represents the given boolean value.
-    fn new_const_bool(&self, value: bool) -> MirConst;
-
-    /// Create a new constant that represents the given value.
-    fn try_new_const_uint(&self, value: u128, uint_ty: UintTy) -> Result<MirConst, Error>;
-    fn try_new_ty_const_uint(&self, value: u128, uint_ty: UintTy) -> Result<TyConst, Error>;
-
-    /// Create a new type from the given kind.
-    fn new_rigid_ty(&self, kind: RigidTy) -> Ty;
-
-    /// Create a new box type, `Box<T>`, for the given inner type `T`.
-    fn new_box_ty(&self, ty: Ty) -> Ty;
-
-    /// Returns the type of given crate item.
-    fn def_ty(&self, item: DefId) -> Ty;
-
-    /// Returns the type of given definition instantiated with the given arguments.
-    fn def_ty_with_args(&self, item: DefId, args: &GenericArgs) -> Ty;
-
-    /// Returns literal value of a const as a string.
-    fn mir_const_pretty(&self, cnst: &MirConst) -> String;
-
-    /// `Span` of an item
-    fn span_of_an_item(&self, def_id: DefId) -> Span;
-
-    fn ty_const_pretty(&self, ct: TyConstId) -> String;
-
-    /// Obtain the representation of a type.
-    fn ty_pretty(&self, ty: Ty) -> String;
-
-    /// Obtain the kind of a type.
-    fn ty_kind(&self, ty: Ty) -> TyKind;
-
-    // Get the discriminant Ty for this Ty if there's one.
-    fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> Ty;
-
-    /// Get the body of an Instance which is already monomorphized.
-    fn instance_body(&self, instance: InstanceDef) -> Option<Body>;
-
-    /// Get the instance type with generic instantiations applied and lifetimes erased.
-    fn instance_ty(&self, instance: InstanceDef) -> Ty;
-
-    /// Get the instantiation types.
-    fn instance_args(&self, def: InstanceDef) -> GenericArgs;
-
-    /// Get the instance.
-    fn instance_def_id(&self, instance: InstanceDef) -> DefId;
-
-    /// Get the instance mangled name.
-    fn instance_mangled_name(&self, instance: InstanceDef) -> Symbol;
-
-    /// Check if this is an empty DropGlue shim.
-    fn is_empty_drop_shim(&self, def: InstanceDef) -> bool;
-
-    /// Convert a non-generic crate item into an instance.
-    /// This function will panic if the item is generic.
-    fn mono_instance(&self, def_id: DefId) -> Instance;
-
-    /// Item requires monomorphization.
-    fn requires_monomorphization(&self, def_id: DefId) -> bool;
-
-    /// Resolve an instance from the given function definition and generic arguments.
-    fn resolve_instance(&self, def: FnDef, args: &GenericArgs) -> Option<Instance>;
-
-    /// Resolve an instance for drop_in_place for the given type.
-    fn resolve_drop_in_place(&self, ty: Ty) -> Instance;
-
-    /// Resolve instance for a function pointer.
-    fn resolve_for_fn_ptr(&self, def: FnDef, args: &GenericArgs) -> Option<Instance>;
-
-    /// Resolve instance for a closure with the requested type.
-    fn resolve_closure(
-        &self,
-        def: ClosureDef,
-        args: &GenericArgs,
-        kind: ClosureKind,
-    ) -> Option<Instance>;
-
-    /// Evaluate a static's initializer.
-    fn eval_static_initializer(&self, def: StaticDef) -> Result<Allocation, Error>;
-
-    /// Try to evaluate an instance into a constant.
-    fn eval_instance(&self, def: InstanceDef, const_ty: Ty) -> Result<Allocation, Error>;
-
-    /// Retrieve global allocation for the given allocation ID.
-    fn global_alloc(&self, id: AllocId) -> GlobalAlloc;
-
-    /// Retrieve the id for the virtual table.
-    fn vtable_allocation(&self, global_alloc: &GlobalAlloc) -> Option<AllocId>;
-    fn krate(&self, def_id: DefId) -> Crate;
-    fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol;
-
-    /// Return information about the target machine.
-    fn target_info(&self) -> MachineInfo;
-
-    /// Get an instance ABI.
-    fn instance_abi(&self, def: InstanceDef) -> Result<FnAbi, Error>;
-
-    /// Get the ABI of a function pointer.
-    fn fn_ptr_abi(&self, fn_ptr: PolyFnSig) -> Result<FnAbi, Error>;
-
-    /// Get the layout of a type.
-    fn ty_layout(&self, ty: Ty) -> Result<Layout, Error>;
-
-    /// Get the layout shape.
-    fn layout_shape(&self, id: Layout) -> LayoutShape;
-
-    /// Get a debug string representation of a place.
-    fn place_pretty(&self, place: &Place) -> String;
-
-    /// Get the resulting type of binary operation.
-    fn binop_ty(&self, bin_op: BinOp, rhs: Ty, lhs: Ty) -> Ty;
-
-    /// Get the resulting type of unary operation.
-    fn unop_ty(&self, un_op: UnOp, arg: Ty) -> Ty;
-
-    /// Get all associated items of a definition.
-    fn associated_items(&self, def_id: DefId) -> AssocItems;
-}
-
-impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> {
-    fn entry_fn(&self) -> Option<CrateItem> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = cx.entry_fn();
-        Some(tables.crate_item(did?))
-    }
-
-    /// Retrieve all items of the local crate that have a MIR associated with them.
-    fn all_local_items(&self) -> CrateItems {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.all_local_items().iter().map(|did| tables.crate_item(*did)).collect()
-    }
-
-    /// Retrieve the body of a function.
-    /// This function will panic if the body is not available.
-    fn mir_body(&self, item: DefId) -> mir::Body {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[item];
-        cx.mir_body(did).stable(&mut *tables, cx)
-    }
-
-    /// Check whether the body of a function is available.
-    fn has_body(&self, item: DefId) -> bool {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let def = item.internal(&mut *tables, cx.tcx);
-        cx.has_body(def)
-    }
-
-    fn foreign_modules(&self, crate_num: CrateNum) -> Vec<ForeignModuleDef> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.foreign_modules(crate_num.internal(&mut *tables, cx.tcx))
-            .iter()
-            .map(|did| tables.foreign_module_def(*did))
-            .collect()
-    }
-
-    /// Retrieve all functions defined in this crate.
-    fn crate_functions(&self, crate_num: CrateNum) -> Vec<FnDef> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let krate = crate_num.internal(&mut *tables, cx.tcx);
-        cx.crate_functions(krate).iter().map(|did| tables.fn_def(*did)).collect()
-    }
-
-    /// Retrieve all static items defined in this crate.
-    fn crate_statics(&self, crate_num: CrateNum) -> Vec<StaticDef> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let krate = crate_num.internal(&mut *tables, cx.tcx);
-        cx.crate_statics(krate).iter().map(|did| tables.static_def(*did)).collect()
-    }
-
-    fn foreign_module(&self, mod_def: ForeignModuleDef) -> ForeignModule {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[mod_def.def_id()];
-        cx.foreign_module(did).stable(&mut *tables, cx)
-    }
-
-    fn foreign_items(&self, mod_def: ForeignModuleDef) -> Vec<ForeignDef> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[mod_def.def_id()];
-        cx.foreign_items(did).iter().map(|did| tables.foreign_def(*did)).collect()
-    }
-
-    fn all_trait_decls(&self) -> TraitDecls {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.all_trait_decls().map(|did| tables.trait_def(did)).collect()
-    }
-
-    fn trait_decls(&self, crate_num: CrateNum) -> TraitDecls {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let krate = crate_num.internal(&mut *tables, cx.tcx);
-        cx.trait_decls(krate).iter().map(|did| tables.trait_def(*did)).collect()
-    }
-
-    fn trait_decl(&self, trait_def: &TraitDef) -> TraitDecl {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[trait_def.0];
-        cx.trait_decl(did).stable(&mut *tables, cx)
-    }
-
-    fn all_trait_impls(&self) -> ImplTraitDecls {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.all_trait_impls().iter().map(|did| tables.impl_def(*did)).collect()
-    }
-
-    fn trait_impls(&self, crate_num: CrateNum) -> ImplTraitDecls {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let krate = crate_num.internal(&mut *tables, cx.tcx);
-        cx.trait_impls(krate).iter().map(|did| tables.impl_def(*did)).collect()
-    }
-
-    fn trait_impl(&self, trait_impl: &ImplDef) -> ImplTrait {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[trait_impl.0];
-        cx.trait_impl(did).stable(&mut *tables, cx)
-    }
-
-    fn generics_of(&self, def_id: DefId) -> Generics {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[def_id];
-        cx.generics_of(did).stable(&mut *tables, cx)
-    }
-
-    fn predicates_of(&self, def_id: DefId) -> GenericPredicates {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[def_id];
-        let (parent, kinds) = cx.predicates_of(did);
-        crate::ty::GenericPredicates {
-            parent: parent.map(|did| tables.trait_def(did)),
-            predicates: kinds
-                .iter()
-                .map(|(kind, span)| (kind.stable(&mut *tables, cx), span.stable(&mut *tables, cx)))
-                .collect(),
-        }
-    }
-
-    fn explicit_predicates_of(&self, def_id: DefId) -> GenericPredicates {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[def_id];
-        let (parent, kinds) = cx.explicit_predicates_of(did);
-        crate::ty::GenericPredicates {
-            parent: parent.map(|did| tables.trait_def(did)),
-            predicates: kinds
-                .iter()
-                .map(|(kind, span)| (kind.stable(&mut *tables, cx), span.stable(&mut *tables, cx)))
-                .collect(),
-        }
-    }
-
-    /// Get information about the local crate.
-    fn local_crate(&self) -> Crate {
-        let cx = &*self.cx.borrow();
-        smir_crate(cx, cx.local_crate_num())
-    }
-
-    /// Retrieve a list of all external crates.
-    fn external_crates(&self) -> Vec<Crate> {
-        let cx = &*self.cx.borrow();
-        cx.external_crates().iter().map(|crate_num| smir_crate(cx, *crate_num)).collect()
-    }
-
-    /// Find a crate with the given name.
-    fn find_crates(&self, name: &str) -> Vec<Crate> {
-        let cx = &*self.cx.borrow();
-        cx.find_crates(name).iter().map(|crate_num| smir_crate(cx, *crate_num)).collect()
-    }
-
-    /// Returns the name of given `DefId`.
-    fn def_name(&self, def_id: DefId, trimmed: bool) -> Symbol {
-        let tables = self.tables.borrow();
-        let cx = &*self.cx.borrow();
-        let did = tables[def_id];
-        cx.def_name(did, trimmed)
-    }
-
-    /// Return registered tool attributes with the given attribute name.
-    ///
-    /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool
-    /// attributes will simply return an empty list.
-    ///
-    /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`.
-    /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`.
-    fn tool_attrs(&self, def_id: DefId, attr: &[Symbol]) -> Vec<Attribute> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[def_id];
-        cx.tool_attrs(did, attr)
-            .into_iter()
-            .map(|(attr_str, span)| Attribute::new(attr_str, span.stable(&mut *tables, cx)))
-            .collect()
-    }
-
-    /// Get all tool attributes of a definition.
-    fn all_tool_attrs(&self, def_id: DefId) -> Vec<Attribute> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[def_id];
-        cx.all_tool_attrs(did)
-            .into_iter()
-            .map(|(attr_str, span)| Attribute::new(attr_str, span.stable(&mut *tables, cx)))
-            .collect()
-    }
-
-    /// Returns printable, human readable form of `Span`.
-    fn span_to_string(&self, span: Span) -> String {
-        let tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let sp = tables.spans[span];
-        cx.span_to_string(sp)
-    }
-
-    /// Return filename from given `Span`, for diagnostic purposes.
-    fn get_filename(&self, span: &Span) -> Filename {
-        let tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let sp = tables.spans[*span];
-        cx.get_filename(sp)
-    }
-
-    /// Return lines corresponding to this `Span`.
-    fn get_lines(&self, span: &Span) -> LineInfo {
-        let tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let sp = tables.spans[*span];
-        let lines = cx.get_lines(sp);
-        LineInfo::from(lines)
-    }
-
-    /// Returns the `kind` of given `DefId`.
-    fn item_kind(&self, item: CrateItem) -> ItemKind {
-        let tables = self.tables.borrow();
-        let cx = &*self.cx.borrow();
-        let did = tables[item.0];
-        new_item_kind(cx.def_kind(did))
-    }
-
-    /// Returns whether this is a foreign item.
-    fn is_foreign_item(&self, item: DefId) -> bool {
-        let tables = self.tables.borrow();
-        let cx = &*self.cx.borrow();
-        let did = tables[item];
-        cx.is_foreign_item(did)
-    }
-
-    /// Returns the kind of a given foreign item.
-    fn foreign_item_kind(&self, def: ForeignDef) -> ForeignItemKind {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let def_id = tables[def.def_id()];
-        let def_kind = cx.foreign_item_kind(def_id);
-        match def_kind {
-            DefKind::Fn => ForeignItemKind::Fn(tables.fn_def(def_id)),
-            DefKind::Static { .. } => ForeignItemKind::Static(tables.static_def(def_id)),
-            DefKind::ForeignTy => {
-                use rustc_smir::context::SmirTy;
-                ForeignItemKind::Type(tables.intern_ty(cx.new_foreign(def_id)))
-            }
-            def_kind => unreachable!("Unexpected kind for a foreign item: {:?}", def_kind),
-        }
-    }
-
-    /// Returns the kind of a given algebraic data type.
-    fn adt_kind(&self, def: AdtDef) -> AdtKind {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.adt_kind(def.internal(&mut *tables, cx.tcx)).stable(&mut *tables, cx)
-    }
-
-    /// Returns if the ADT is a box.
-    fn adt_is_box(&self, def: AdtDef) -> bool {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.adt_is_box(def.internal(&mut *tables, cx.tcx))
-    }
-
-    /// Returns whether this ADT is simd.
-    fn adt_is_simd(&self, def: AdtDef) -> bool {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.adt_is_simd(def.internal(&mut *tables, cx.tcx))
-    }
-
-    /// Returns whether this definition is a C string.
-    fn adt_is_cstr(&self, def: AdtDef) -> bool {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.adt_is_cstr(def.0.internal(&mut *tables, cx.tcx))
-    }
-
-    /// Returns the representation options for this ADT
-    fn adt_repr(&self, def: AdtDef) -> ReprOptions {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.adt_repr(def.internal(&mut *tables, cx.tcx)).stable(&mut *tables, cx)
-    }
-
-    /// Retrieve the function signature for the given generic arguments.
-    fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let def_id = def.0.internal(&mut *tables, cx.tcx);
-        let args_ref = args.internal(&mut *tables, cx.tcx);
-        cx.fn_sig(def_id, args_ref).stable(&mut *tables, cx)
-    }
-
-    /// Retrieve the intrinsic definition if the item corresponds one.
-    fn intrinsic(&self, item: DefId) -> Option<IntrinsicDef> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let def_id = item.internal(&mut *tables, cx.tcx);
-        cx.intrinsic(def_id).map(|_| IntrinsicDef(item))
-    }
-
-    /// Retrieve the plain function name of an intrinsic.
-    fn intrinsic_name(&self, def: IntrinsicDef) -> Symbol {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let def_id = def.0.internal(&mut *tables, cx.tcx);
-        cx.intrinsic_name(def_id)
-    }
-
-    /// Retrieve the closure signature for the given generic arguments.
-    fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let args_ref = args.internal(&mut *tables, cx.tcx);
-        cx.closure_sig(args_ref).stable(&mut *tables, cx)
-    }
-
-    /// The number of variants in this ADT.
-    fn adt_variants_len(&self, def: AdtDef) -> usize {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.adt_variants_len(def.internal(&mut *tables, cx.tcx))
-    }
-
-    /// Discriminant for a given variant index of AdtDef.
-    fn adt_discr_for_variant(&self, adt: AdtDef, variant: VariantIdx) -> Discr {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.adt_discr_for_variant(
-            adt.internal(&mut *tables, cx.tcx),
-            variant.internal(&mut *tables, cx.tcx),
-        )
-        .stable(&mut *tables, cx)
-    }
-
-    /// Discriminant for a given variand index and args of a coroutine.
-    fn coroutine_discr_for_variant(
-        &self,
-        coroutine: CoroutineDef,
-        args: &GenericArgs,
-        variant: VariantIdx,
-    ) -> Discr {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let tcx = cx.tcx;
-        let def = coroutine.def_id().internal(&mut *tables, tcx);
-        let args_ref = args.internal(&mut *tables, tcx);
-        cx.coroutine_discr_for_variant(def, args_ref, variant.internal(&mut *tables, tcx))
-            .stable(&mut *tables, cx)
-    }
-
-    /// The name of a variant.
-    fn variant_name(&self, def: VariantDef) -> Symbol {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.variant_name(def.internal(&mut *tables, cx.tcx))
-    }
-
-    fn variant_fields(&self, def: VariantDef) -> Vec<FieldDef> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        def.internal(&mut *tables, cx.tcx)
-            .fields
-            .iter()
-            .map(|f| f.stable(&mut *tables, cx))
-            .collect()
-    }
-
-    /// Evaluate constant as a target usize.
-    fn eval_target_usize(&self, mir_const: &MirConst) -> Result<u64, Error> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let cnst = mir_const.internal(&mut *tables, cx.tcx);
-        cx.eval_target_usize(cnst)
-    }
-
-    fn eval_target_usize_ty(&self, ty_const: &TyConst) -> Result<u64, Error> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let cnst = ty_const.internal(&mut *tables, cx.tcx);
-        cx.eval_target_usize_ty(cnst)
-    }
-
-    /// Create a new zero-sized constant.
-    fn try_new_const_zst(&self, ty: Ty) -> Result<MirConst, Error> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let ty_internal = ty.internal(&mut *tables, cx.tcx);
-        cx.try_new_const_zst(ty_internal).map(|cnst| cnst.stable(&mut *tables, cx))
-    }
-
-    /// Create a new constant that represents the given string value.
-    fn new_const_str(&self, value: &str) -> MirConst {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.new_const_str(value).stable(&mut *tables, cx)
-    }
-
-    /// Create a new constant that represents the given boolean value.
-    fn new_const_bool(&self, value: bool) -> MirConst {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.new_const_bool(value).stable(&mut *tables, cx)
-    }
-
-    /// Create a new constant that represents the given value.
-    fn try_new_const_uint(&self, value: u128, uint_ty: UintTy) -> Result<MirConst, Error> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let ty = cx.ty_new_uint(uint_ty.internal(&mut *tables, cx.tcx));
-        cx.try_new_const_uint(value, ty).map(|cnst| cnst.stable(&mut *tables, cx))
-    }
-
-    fn try_new_ty_const_uint(&self, value: u128, uint_ty: UintTy) -> Result<TyConst, Error> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let ty = cx.ty_new_uint(uint_ty.internal(&mut *tables, cx.tcx));
-        cx.try_new_ty_const_uint(value, ty).map(|cnst| cnst.stable(&mut *tables, cx))
-    }
-
-    /// Create a new type from the given kind.
-    fn new_rigid_ty(&self, kind: RigidTy) -> Ty {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let internal_kind = kind.internal(&mut *tables, cx.tcx);
-        cx.new_rigid_ty(internal_kind).stable(&mut *tables, cx)
-    }
-
-    /// Create a new box type, `Box<T>`, for the given inner type `T`.
-    fn new_box_ty(&self, ty: Ty) -> Ty {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let inner = ty.internal(&mut *tables, cx.tcx);
-        cx.new_box_ty(inner).stable(&mut *tables, cx)
-    }
-
-    /// Returns the type of given crate item.
-    fn def_ty(&self, item: DefId) -> Ty {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let inner = item.internal(&mut *tables, cx.tcx);
-        cx.def_ty(inner).stable(&mut *tables, cx)
-    }
-
-    /// Returns the type of given definition instantiated with the given arguments.
-    fn def_ty_with_args(&self, item: DefId, args: &GenericArgs) -> Ty {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let inner = item.internal(&mut *tables, cx.tcx);
-        let args_ref = args.internal(&mut *tables, cx.tcx);
-        cx.def_ty_with_args(inner, args_ref).stable(&mut *tables, cx)
-    }
-
-    /// Returns literal value of a const as a string.
-    fn mir_const_pretty(&self, cnst: &MirConst) -> String {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cnst.internal(&mut *tables, cx.tcx).to_string()
-    }
-
-    /// `Span` of an item.
-    fn span_of_an_item(&self, def_id: DefId) -> Span {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[def_id];
-        cx.span_of_an_item(did).stable(&mut *tables, cx)
-    }
-
-    fn ty_const_pretty(&self, ct: TyConstId) -> String {
-        let tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.ty_const_pretty(tables.ty_consts[ct])
-    }
-
-    /// Obtain the representation of a type.
-    fn ty_pretty(&self, ty: Ty) -> String {
-        let tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.ty_pretty(tables.types[ty])
-    }
-
-    /// Obtain the kind of a type.
-    fn ty_kind(&self, ty: Ty) -> TyKind {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        cx.ty_kind(tables.types[ty]).stable(&mut *tables, cx)
-    }
-
-    /// Get the discriminant Ty for this Ty if there's one.
-    fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> Ty {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let internal_kind = ty.internal(&mut *tables, cx.tcx);
-        cx.rigid_ty_discriminant_ty(internal_kind).stable(&mut *tables, cx)
-    }
-
-    /// Get the body of an Instance which is already monomorphized.
-    fn instance_body(&self, instance: InstanceDef) -> Option<Body> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let instance = tables.instances[instance];
-        cx.instance_body(instance).map(|body| body.stable(&mut *tables, cx))
-    }
-
-    /// Get the instance type with generic instantiations applied and lifetimes erased.
-    fn instance_ty(&self, instance: InstanceDef) -> Ty {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let instance = tables.instances[instance];
-        cx.instance_ty(instance).stable(&mut *tables, cx)
-    }
-
-    /// Get the instantiation types.
-    fn instance_args(&self, def: InstanceDef) -> GenericArgs {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let instance = tables.instances[def];
-        cx.instance_args(instance).stable(&mut *tables, cx)
-    }
-
-    /// Get the instance.
-    fn instance_def_id(&self, instance: InstanceDef) -> DefId {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let instance = tables.instances[instance];
-        cx.instance_def_id(instance, &mut *tables)
-    }
-
-    /// Get the instance mangled name.
-    fn instance_mangled_name(&self, instance: InstanceDef) -> Symbol {
-        let tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let instance = tables.instances[instance];
-        cx.instance_mangled_name(instance)
-    }
-
-    /// Check if this is an empty DropGlue shim.
-    fn is_empty_drop_shim(&self, def: InstanceDef) -> bool {
-        let tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let instance = tables.instances[def];
-        cx.is_empty_drop_shim(instance)
-    }
-
-    /// Convert a non-generic crate item into an instance.
-    /// This function will panic if the item is generic.
-    fn mono_instance(&self, def_id: DefId) -> Instance {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[def_id];
-        cx.mono_instance(did).stable(&mut *tables, cx)
-    }
-
-    /// Item requires monomorphization.
-    fn requires_monomorphization(&self, def_id: DefId) -> bool {
-        let tables = self.tables.borrow();
-        let cx = &*self.cx.borrow();
-        let did = tables[def_id];
-        cx.requires_monomorphization(did)
-    }
-
-    /// Resolve an instance from the given function definition and generic arguments.
-    fn resolve_instance(&self, def: FnDef, args: &GenericArgs) -> Option<Instance> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let def_id = def.0.internal(&mut *tables, cx.tcx);
-        let args_ref = args.internal(&mut *tables, cx.tcx);
-        cx.resolve_instance(def_id, args_ref).map(|inst| inst.stable(&mut *tables, cx))
-    }
-
-    /// Resolve an instance for drop_in_place for the given type.
-    fn resolve_drop_in_place(&self, ty: Ty) -> Instance {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let internal_ty = ty.internal(&mut *tables, cx.tcx);
-
-        cx.resolve_drop_in_place(internal_ty).stable(&mut *tables, cx)
-    }
-
-    /// Resolve instance for a function pointer.
-    fn resolve_for_fn_ptr(&self, def: FnDef, args: &GenericArgs) -> Option<Instance> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let def_id = def.0.internal(&mut *tables, cx.tcx);
-        let args_ref = args.internal(&mut *tables, cx.tcx);
-        cx.resolve_for_fn_ptr(def_id, args_ref).stable(&mut *tables, cx)
-    }
-
-    /// Resolve instance for a closure with the requested type.
-    fn resolve_closure(
-        &self,
-        def: ClosureDef,
-        args: &GenericArgs,
-        kind: ClosureKind,
-    ) -> Option<Instance> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let def_id = def.0.internal(&mut *tables, cx.tcx);
-        let args_ref = args.internal(&mut *tables, cx.tcx);
-        let closure_kind = kind.internal(&mut *tables, cx.tcx);
-        cx.resolve_closure(def_id, args_ref, closure_kind).map(|inst| inst.stable(&mut *tables, cx))
-    }
-
-    /// Evaluate a static's initializer.
-    fn eval_static_initializer(&self, def: StaticDef) -> Result<Allocation, Error> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let def_id = def.0.internal(&mut *tables, cx.tcx);
-
-        cx.eval_static_initializer(def_id).stable(&mut *tables, cx)
-    }
-
-    /// Try to evaluate an instance into a constant.
-    fn eval_instance(&self, def: InstanceDef, const_ty: Ty) -> Result<Allocation, Error> {
-        let mut tables = self.tables.borrow_mut();
-        let instance = tables.instances[def];
-        let cx = &*self.cx.borrow();
-        let const_ty = const_ty.internal(&mut *tables, cx.tcx);
-        cx.eval_instance(instance)
-            .map(|const_val| alloc::try_new_allocation(const_ty, const_val, &mut *tables, cx))
-            .map_err(|e| e.stable(&mut *tables, cx))?
-    }
-
-    /// Retrieve global allocation for the given allocation ID.
-    fn global_alloc(&self, id: AllocId) -> GlobalAlloc {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let alloc_id = id.internal(&mut *tables, cx.tcx);
-        cx.global_alloc(alloc_id).stable(&mut *tables, cx)
-    }
-
-    /// Retrieve the id for the virtual table.
-    fn vtable_allocation(&self, global_alloc: &GlobalAlloc) -> Option<AllocId> {
-        let mut tables = self.tables.borrow_mut();
-        let GlobalAlloc::VTable(ty, trait_ref) = global_alloc else {
-            return None;
-        };
-        let cx = &*self.cx.borrow();
-        let ty = ty.internal(&mut *tables, cx.tcx);
-        let trait_ref = trait_ref.internal(&mut *tables, cx.tcx);
-        let alloc_id = cx.vtable_allocation(ty, trait_ref);
-        Some(alloc_id.stable(&mut *tables, cx))
-    }
-
-    fn krate(&self, def_id: DefId) -> Crate {
-        let tables = self.tables.borrow();
-        let cx = &*self.cx.borrow();
-        smir_crate(cx, tables[def_id].krate)
-    }
-
-    fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol {
-        let tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let instance = tables.instances[def];
-        cx.instance_name(instance, trimmed)
-    }
-
-    /// Return information about the target machine.
-    fn target_info(&self) -> MachineInfo {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        MachineInfo {
-            endian: cx.target_endian().stable(&mut *tables, cx),
-            pointer_width: MachineSize::from_bits(cx.target_pointer_size()),
-        }
-    }
-
-    /// Get an instance ABI.
-    fn instance_abi(&self, def: InstanceDef) -> Result<FnAbi, Error> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let instance = tables.instances[def];
-        cx.instance_abi(instance).map(|fn_abi| fn_abi.stable(&mut *tables, cx))
-    }
-
-    /// Get the ABI of a function pointer.
-    fn fn_ptr_abi(&self, fn_ptr: PolyFnSig) -> Result<FnAbi, Error> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let sig = fn_ptr.internal(&mut *tables, cx.tcx);
-        cx.fn_ptr_abi(sig).map(|fn_abi| fn_abi.stable(&mut *tables, cx))
-    }
-
-    /// Get the layout of a type.
-    fn ty_layout(&self, ty: Ty) -> Result<Layout, Error> {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let internal_ty = ty.internal(&mut *tables, cx.tcx);
-        cx.ty_layout(internal_ty).map(|layout| layout.stable(&mut *tables, cx))
-    }
-
-    /// Get the layout shape.
-    fn layout_shape(&self, id: Layout) -> LayoutShape {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        id.internal(&mut *tables, cx.tcx).0.stable(&mut *tables, cx)
-    }
-
-    /// Get a debug string representation of a place.
-    fn place_pretty(&self, place: &Place) -> String {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-
-        format!("{:?}", place.internal(&mut *tables, cx.tcx))
-    }
-
-    /// Get the resulting type of binary operation.
-    fn binop_ty(&self, bin_op: BinOp, rhs: Ty, lhs: Ty) -> Ty {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let rhs_internal = rhs.internal(&mut *tables, cx.tcx);
-        let lhs_internal = lhs.internal(&mut *tables, cx.tcx);
-        let bin_op_internal = bin_op.internal(&mut *tables, cx.tcx);
-        cx.binop_ty(bin_op_internal, rhs_internal, lhs_internal).stable(&mut *tables, cx)
-    }
-
-    /// Get the resulting type of unary operation.
-    fn unop_ty(&self, un_op: UnOp, arg: Ty) -> Ty {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let un_op = un_op.internal(&mut *tables, cx.tcx);
-        let arg = arg.internal(&mut *tables, cx.tcx);
-        cx.unop_ty(un_op, arg).stable(&mut *tables, cx)
-    }
-
-    /// Get all associated items of a definition.
-    fn associated_items(&self, def_id: DefId) -> AssocItems {
-        let mut tables = self.tables.borrow_mut();
-        let cx = &*self.cx.borrow();
-        let did = tables[def_id];
-        cx.associated_items(did).iter().map(|assoc| assoc.stable(&mut *tables, cx)).collect()
-    }
-}
-
-// A thread local variable that stores a pointer to [`SmirInterface`].
-scoped_tls::scoped_thread_local!(static TLV: Cell<*const ()>);
-
-pub(crate) fn run<F, T>(interface: &dyn SmirInterface, f: F) -> Result<T, Error>
-where
-    F: FnOnce() -> T,
-{
-    if TLV.is_set() {
-        Err(Error::from("StableMIR already running"))
-    } else {
-        let ptr: *const () = (&raw const interface) as _;
-        TLV.set(&Cell::new(ptr), || Ok(f()))
-    }
-}
-
-/// Execute the given function with access the [`SmirInterface`].
-///
-/// I.e., This function will load the current interface and calls a function with it.
-/// Do not nest these, as that will ICE.
-pub(crate) fn with<R>(f: impl FnOnce(&dyn SmirInterface) -> R) -> R {
-    assert!(TLV.is_set());
-    TLV.with(|tlv| {
-        let ptr = tlv.get();
-        assert!(!ptr.is_null());
-        f(unsafe { *(ptr as *const &dyn SmirInterface) })
-    })
-}
-
-fn smir_crate<'tcx>(
-    cx: &SmirCtxt<'tcx, BridgeTys>,
-    crate_num: rustc_span::def_id::CrateNum,
-) -> Crate {
-    let name = cx.crate_name(crate_num);
-    let is_local = cx.crate_is_local(crate_num);
-    let id = cx.crate_num_id(crate_num);
-    debug!(?name, ?crate_num, "smir_crate");
-    Crate { id, name, is_local }
-}
diff --git a/compiler/stable_mir/src/crate_def.rs b/compiler/stable_mir/src/crate_def.rs
deleted file mode 100644
index 75228135e4c..00000000000
--- a/compiler/stable_mir/src/crate_def.rs
+++ /dev/null
@@ -1,174 +0,0 @@
-//! Module that define a common trait for things that represent a crate definition,
-//! such as, a function, a trait, an enum, and any other definitions.
-
-use serde::Serialize;
-
-use crate::ty::{GenericArgs, Span, Ty};
-use crate::{AssocItems, Crate, Symbol, with};
-
-/// A unique identification number for each item accessible for the current compilation unit.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize)]
-pub struct DefId(pub(crate) usize);
-
-impl DefId {
-    /// Return fully qualified name of this definition
-    pub fn name(&self) -> Symbol {
-        with(|cx| cx.def_name(*self, false))
-    }
-
-    /// Return a trimmed name of this definition.
-    ///
-    /// This can be used to print more user friendly diagnostic messages.
-    ///
-    /// If a symbol name can only be imported from one place for a type, and as
-    /// long as it was not glob-imported anywhere in the current crate, we trim its
-    /// path and print only the name.
-    ///
-    /// For example, this function may shorten `std::vec::Vec` to just `Vec`,
-    /// as long as there is no other `Vec` importable anywhere.
-    pub fn trimmed_name(&self) -> Symbol {
-        with(|cx| cx.def_name(*self, true))
-    }
-}
-
-/// A trait for retrieving information about a particular definition.
-///
-/// Implementors must provide the implementation of `def_id` which will be used to retrieve
-/// information about a crate's definition.
-pub trait CrateDef {
-    /// Retrieve the unique identifier for the current definition.
-    fn def_id(&self) -> DefId;
-
-    /// Return the fully qualified name of the current definition.
-    ///
-    /// See [`DefId::name`] for more details
-    fn name(&self) -> Symbol {
-        self.def_id().name()
-    }
-
-    /// Return a trimmed name of this definition.
-    ///
-    /// See [`DefId::trimmed_name`] for more details
-    fn trimmed_name(&self) -> Symbol {
-        self.def_id().trimmed_name()
-    }
-
-    /// Return information about the crate where this definition is declared.
-    ///
-    /// This will return the crate number and its name.
-    fn krate(&self) -> Crate {
-        let def_id = self.def_id();
-        with(|cx| cx.krate(def_id))
-    }
-
-    /// Return the span of this definition.
-    fn span(&self) -> Span {
-        let def_id = self.def_id();
-        with(|cx| cx.span_of_an_item(def_id))
-    }
-
-    /// Return registered tool attributes with the given attribute name.
-    ///
-    /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool
-    /// attributes will simply return an empty list.
-    ///
-    /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`.
-    /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`.
-    fn tool_attrs(&self, attr: &[Symbol]) -> Vec<Attribute> {
-        let def_id = self.def_id();
-        with(|cx| cx.tool_attrs(def_id, attr))
-    }
-
-    /// Return all tool attributes of this definition.
-    fn all_tool_attrs(&self) -> Vec<Attribute> {
-        let def_id = self.def_id();
-        with(|cx| cx.all_tool_attrs(def_id))
-    }
-}
-
-/// A trait that can be used to retrieve a definition's type.
-///
-/// Note that not every CrateDef has a type `Ty`. They should not implement this trait.
-pub trait CrateDefType: CrateDef {
-    /// Returns the type of this crate item.
-    fn ty(&self) -> Ty {
-        with(|cx| cx.def_ty(self.def_id()))
-    }
-
-    /// Retrieve the type of this definition by instantiating and normalizing it with `args`.
-    ///
-    /// This will panic if instantiation fails.
-    fn ty_with_args(&self, args: &GenericArgs) -> Ty {
-        with(|cx| cx.def_ty_with_args(self.def_id(), args))
-    }
-}
-
-/// A trait for retrieving all items from a definition within a crate.
-pub trait CrateDefItems: CrateDef {
-    /// Retrieve all associated items from a definition.
-    fn associated_items(&self) -> AssocItems {
-        with(|cx| cx.associated_items(self.def_id()))
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Attribute {
-    value: String,
-    span: Span,
-}
-
-impl Attribute {
-    pub fn new(value: String, span: Span) -> Attribute {
-        Attribute { value, span }
-    }
-
-    /// Get the span of this attribute.
-    pub fn span(&self) -> Span {
-        self.span
-    }
-
-    /// Get the string representation of this attribute.
-    pub fn as_str(&self) -> &str {
-        &self.value
-    }
-}
-
-macro_rules! crate_def {
-    ( $(#[$attr:meta])*
-      $vis:vis $name:ident $(;)?
-    ) => {
-        $(#[$attr])*
-        #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
-        $vis struct $name(pub DefId);
-
-        impl CrateDef for $name {
-            fn def_id(&self) -> DefId {
-                self.0
-            }
-        }
-    };
-}
-
-macro_rules! crate_def_with_ty {
-    ( $(#[$attr:meta])*
-      $vis:vis $name:ident $(;)?
-    ) => {
-        $(#[$attr])*
-        #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
-        $vis struct $name(pub DefId);
-
-        impl CrateDef for $name {
-            fn def_id(&self) -> DefId {
-                self.0
-            }
-        }
-
-        impl CrateDefType for $name {}
-    };
-}
-
-macro_rules! impl_crate_def_items {
-    ( $name:ident $(;)? ) => {
-        impl CrateDefItems for $name {}
-    };
-}
diff --git a/compiler/stable_mir/src/error.rs b/compiler/stable_mir/src/error.rs
deleted file mode 100644
index 702134b0c4c..00000000000
--- a/compiler/stable_mir/src/error.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-//! When things go wrong, we need some error handling.
-//! There are a few different types of errors in StableMIR:
-//!
-//! - [CompilerError]: This represents errors that can be raised when invoking the compiler.
-//! - [Error]: Generic error that represents the reason why a request that could not be fulfilled.
-
-use std::fmt::{Debug, Display, Formatter};
-use std::{fmt, io};
-
-use rustc_smir::bridge::SmirError;
-
-macro_rules! error {
-     ($fmt: literal $(,)?) => { Error(format!($fmt)) };
-     ($fmt: literal, $($arg:tt)*) => { Error(format!($fmt, $($arg)*)) };
-}
-
-pub(crate) use error;
-
-/// An error type used to represent an error that has already been reported by the compiler.
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub enum CompilerError<T> {
-    /// Compilation failed, either due to normal errors or ICE.
-    Failed,
-    /// Compilation was interrupted.
-    Interrupted(T),
-    /// Compilation skipped. This happens when users invoke rustc to retrieve information such as
-    /// --version.
-    Skipped,
-}
-
-/// A generic error to represent an API request that cannot be fulfilled.
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Error(pub(crate) String);
-
-impl SmirError for Error {
-    fn new(msg: String) -> Self {
-        Self(msg)
-    }
-
-    fn from_internal<T: Debug>(err: T) -> Self {
-        Self(format!("{err:?}"))
-    }
-}
-
-impl From<&str> for Error {
-    fn from(value: &str) -> Self {
-        Self(value.into())
-    }
-}
-
-impl Display for Error {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        Display::fmt(&self.0, f)
-    }
-}
-
-impl<T> Display for CompilerError<T>
-where
-    T: Display,
-{
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            CompilerError::Failed => write!(f, "Compilation Failed"),
-            CompilerError::Interrupted(reason) => write!(f, "Compilation Interrupted: {reason}"),
-            CompilerError::Skipped => write!(f, "Compilation Skipped"),
-        }
-    }
-}
-
-impl<T> Debug for CompilerError<T>
-where
-    T: Debug,
-{
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            CompilerError::Failed => write!(f, "Compilation Failed"),
-            CompilerError::Interrupted(reason) => write!(f, "Compilation Interrupted: {reason:?}"),
-            CompilerError::Skipped => write!(f, "Compilation Skipped"),
-        }
-    }
-}
-
-impl std::error::Error for Error {}
-
-impl<T> std::error::Error for CompilerError<T> where T: Display + Debug {}
-
-impl From<io::Error> for Error {
-    fn from(value: io::Error) -> Self {
-        Error(value.to_string())
-    }
-}
diff --git a/compiler/stable_mir/src/lib.rs b/compiler/stable_mir/src/lib.rs
deleted file mode 100644
index 0a2e4e71afc..00000000000
--- a/compiler/stable_mir/src/lib.rs
+++ /dev/null
@@ -1,300 +0,0 @@
-//! The WIP stable interface to rustc internals.
-//!
-//! For more information see <https://github.com/rust-lang/project-stable-mir>
-//!
-//! # Note
-//!
-//! This API is still completely unstable and subject to change.
-
-#![allow(rustc::usage_of_ty_tykind)]
-#![doc(
-    html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/",
-    test(attr(allow(unused_variables), deny(warnings)))
-)]
-#![feature(sized_hierarchy)]
-//!
-//! This crate shall contain all type definitions and APIs that we expect third-party tools to invoke to
-//! interact with the compiler.
-//!
-//! The goal is to eventually be published on
-//! [crates.io](https://crates.io).
-
-use std::fmt::Debug;
-use std::{fmt, io};
-
-pub(crate) use rustc_smir::IndexedVal;
-use rustc_smir::Tables;
-use rustc_smir::context::SmirCtxt;
-/// Export the rustc_internal APIs. Note that this module has no stability
-/// guarantees and it is not taken into account for semver.
-#[cfg(feature = "rustc_internal")]
-pub mod rustc_internal;
-use serde::Serialize;
-
-use crate::compiler_interface::with;
-pub use crate::crate_def::{CrateDef, CrateDefItems, CrateDefType, DefId};
-pub use crate::error::*;
-use crate::mir::mono::StaticDef;
-use crate::mir::{Body, Mutability};
-use crate::ty::{AssocItem, FnDef, ForeignModuleDef, ImplDef, ProvenanceMap, Span, TraitDef, Ty};
-use crate::unstable::Stable;
-
-pub mod abi;
-mod alloc;
-pub(crate) mod unstable;
-#[macro_use]
-pub mod crate_def;
-pub mod compiler_interface;
-#[macro_use]
-pub mod error;
-pub mod mir;
-pub mod target;
-pub mod ty;
-pub mod visitor;
-
-/// Use String for now but we should replace it.
-pub type Symbol = String;
-
-/// The number that identifies a crate.
-pub type CrateNum = usize;
-
-impl Debug for DefId {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("DefId").field("id", &self.0).field("name", &self.name()).finish()
-    }
-}
-
-impl IndexedVal for DefId {
-    fn to_val(index: usize) -> Self {
-        DefId(index)
-    }
-
-    fn to_index(&self) -> usize {
-        self.0
-    }
-}
-
-/// A list of crate items.
-pub type CrateItems = Vec<CrateItem>;
-
-/// A list of trait decls.
-pub type TraitDecls = Vec<TraitDef>;
-
-/// A list of impl trait decls.
-pub type ImplTraitDecls = Vec<ImplDef>;
-
-/// A list of associated items.
-pub type AssocItems = Vec<AssocItem>;
-
-/// Holds information about a crate.
-#[derive(Clone, PartialEq, Eq, Debug, Serialize)]
-pub struct Crate {
-    pub id: CrateNum,
-    pub name: Symbol,
-    pub is_local: bool,
-}
-
-impl Crate {
-    /// The list of foreign modules in this crate.
-    pub fn foreign_modules(&self) -> Vec<ForeignModuleDef> {
-        with(|cx| cx.foreign_modules(self.id))
-    }
-
-    /// The list of traits declared in this crate.
-    pub fn trait_decls(&self) -> TraitDecls {
-        with(|cx| cx.trait_decls(self.id))
-    }
-
-    /// The list of trait implementations in this crate.
-    pub fn trait_impls(&self) -> ImplTraitDecls {
-        with(|cx| cx.trait_impls(self.id))
-    }
-
-    /// Return a list of function definitions from this crate independent on their visibility.
-    pub fn fn_defs(&self) -> Vec<FnDef> {
-        with(|cx| cx.crate_functions(self.id))
-    }
-
-    /// Return a list of static items defined in this crate independent on their visibility.
-    pub fn statics(&self) -> Vec<StaticDef> {
-        with(|cx| cx.crate_statics(self.id))
-    }
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, Serialize)]
-pub enum ItemKind {
-    Fn,
-    Static,
-    Const,
-    Ctor(CtorKind),
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, Serialize)]
-pub enum CtorKind {
-    Const,
-    Fn,
-}
-
-pub type Filename = String;
-
-crate_def_with_ty! {
-    /// Holds information about an item in a crate.
-    #[derive(Serialize)]
-    pub CrateItem;
-}
-
-impl CrateItem {
-    /// This will return the body of an item or panic if it's not available.
-    pub fn expect_body(&self) -> mir::Body {
-        with(|cx| cx.mir_body(self.0))
-    }
-
-    /// Return the body of an item if available.
-    pub fn body(&self) -> Option<mir::Body> {
-        with(|cx| cx.has_body(self.0).then(|| cx.mir_body(self.0)))
-    }
-
-    /// Check if a body is available for this item.
-    pub fn has_body(&self) -> bool {
-        with(|cx| cx.has_body(self.0))
-    }
-
-    pub fn span(&self) -> Span {
-        with(|cx| cx.span_of_an_item(self.0))
-    }
-
-    pub fn kind(&self) -> ItemKind {
-        with(|cx| cx.item_kind(*self))
-    }
-
-    pub fn requires_monomorphization(&self) -> bool {
-        with(|cx| cx.requires_monomorphization(self.0))
-    }
-
-    pub fn ty(&self) -> Ty {
-        with(|cx| cx.def_ty(self.0))
-    }
-
-    pub fn is_foreign_item(&self) -> bool {
-        with(|cx| cx.is_foreign_item(self.0))
-    }
-
-    /// Emit MIR for this item body.
-    pub fn emit_mir<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
-        self.body()
-            .ok_or_else(|| io::Error::other(format!("No body found for `{}`", self.name())))?
-            .dump(w, &self.name())
-    }
-}
-
-/// Return the function where execution starts if the current
-/// crate defines that. This is usually `main`, but could be
-/// `start` if the crate is a no-std crate.
-pub fn entry_fn() -> Option<CrateItem> {
-    with(|cx| cx.entry_fn())
-}
-
-/// Access to the local crate.
-pub fn local_crate() -> Crate {
-    with(|cx| cx.local_crate())
-}
-
-/// Try to find a crate or crates if multiple crates exist from given name.
-pub fn find_crates(name: &str) -> Vec<Crate> {
-    with(|cx| cx.find_crates(name))
-}
-
-/// Try to find a crate with the given name.
-pub fn external_crates() -> Vec<Crate> {
-    with(|cx| cx.external_crates())
-}
-
-/// Retrieve all items in the local crate that have a MIR associated with them.
-pub fn all_local_items() -> CrateItems {
-    with(|cx| cx.all_local_items())
-}
-
-pub fn all_trait_decls() -> TraitDecls {
-    with(|cx| cx.all_trait_decls())
-}
-
-pub fn all_trait_impls() -> ImplTraitDecls {
-    with(|cx| cx.all_trait_impls())
-}
-
-/// A type that provides internal information but that can still be used for debug purpose.
-#[derive(Clone, PartialEq, Eq, Hash, Serialize)]
-pub struct Opaque(String);
-
-impl std::fmt::Display for Opaque {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl std::fmt::Debug for Opaque {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-pub fn opaque<T: Debug>(value: &T) -> Opaque {
-    Opaque(format!("{value:?}"))
-}
-
-macro_rules! bridge_impl {
-    ($name: ident, $ty: ty) => {
-        impl rustc_smir::bridge::$name<compiler_interface::BridgeTys> for $ty {
-            fn new(def: crate::DefId) -> Self {
-                Self(def)
-            }
-        }
-    };
-}
-
-bridge_impl!(CrateItem, crate::CrateItem);
-bridge_impl!(AdtDef, crate::ty::AdtDef);
-bridge_impl!(ForeignModuleDef, crate::ty::ForeignModuleDef);
-bridge_impl!(ForeignDef, crate::ty::ForeignDef);
-bridge_impl!(FnDef, crate::ty::FnDef);
-bridge_impl!(ClosureDef, crate::ty::ClosureDef);
-bridge_impl!(CoroutineDef, crate::ty::CoroutineDef);
-bridge_impl!(CoroutineClosureDef, crate::ty::CoroutineClosureDef);
-bridge_impl!(AliasDef, crate::ty::AliasDef);
-bridge_impl!(ParamDef, crate::ty::ParamDef);
-bridge_impl!(BrNamedDef, crate::ty::BrNamedDef);
-bridge_impl!(TraitDef, crate::ty::TraitDef);
-bridge_impl!(GenericDef, crate::ty::GenericDef);
-bridge_impl!(ConstDef, crate::ty::ConstDef);
-bridge_impl!(ImplDef, crate::ty::ImplDef);
-bridge_impl!(RegionDef, crate::ty::RegionDef);
-bridge_impl!(CoroutineWitnessDef, crate::ty::CoroutineWitnessDef);
-bridge_impl!(AssocDef, crate::ty::AssocDef);
-bridge_impl!(OpaqueDef, crate::ty::OpaqueDef);
-bridge_impl!(StaticDef, crate::mir::mono::StaticDef);
-
-impl rustc_smir::bridge::Prov<compiler_interface::BridgeTys> for crate::ty::Prov {
-    fn new(aid: crate::mir::alloc::AllocId) -> Self {
-        Self(aid)
-    }
-}
-
-impl rustc_smir::bridge::Allocation<compiler_interface::BridgeTys> for crate::ty::Allocation {
-    fn new<'tcx>(
-        bytes: Vec<Option<u8>>,
-        ptrs: Vec<(usize, rustc_middle::mir::interpret::AllocId)>,
-        align: u64,
-        mutability: rustc_middle::mir::Mutability,
-        tables: &mut Tables<'tcx, compiler_interface::BridgeTys>,
-        cx: &SmirCtxt<'tcx, compiler_interface::BridgeTys>,
-    ) -> Self {
-        Self {
-            bytes,
-            provenance: ProvenanceMap {
-                ptrs: ptrs.iter().map(|(i, aid)| (*i, tables.prov(*aid))).collect(),
-            },
-            align,
-            mutability: mutability.stable(tables, cx),
-        }
-    }
-}
diff --git a/compiler/stable_mir/src/mir.rs b/compiler/stable_mir/src/mir.rs
deleted file mode 100644
index 413b5152bb3..00000000000
--- a/compiler/stable_mir/src/mir.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-pub mod alloc;
-mod body;
-pub mod mono;
-pub mod pretty;
-pub mod visit;
-
-pub use body::*;
-pub use visit::{MirVisitor, MutMirVisitor};
diff --git a/compiler/stable_mir/src/mir/alloc.rs b/compiler/stable_mir/src/mir/alloc.rs
deleted file mode 100644
index 9a94551f3ec..00000000000
--- a/compiler/stable_mir/src/mir/alloc.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-//! This module provides methods to retrieve allocation information, such as static variables.
-
-use std::io::Read;
-
-use serde::Serialize;
-
-use crate::mir::mono::{Instance, StaticDef};
-use crate::target::{Endian, MachineInfo};
-use crate::ty::{Allocation, Binder, ExistentialTraitRef, Ty};
-use crate::{Error, IndexedVal, with};
-
-/// An allocation in the SMIR global memory can be either a function pointer,
-/// a static, or a "real" allocation with some data in it.
-#[derive(Debug, Clone, Eq, PartialEq, Serialize)]
-pub enum GlobalAlloc {
-    /// The alloc ID is used as a function pointer.
-    Function(Instance),
-    /// This alloc ID points to a symbolic (not-reified) vtable.
-    /// The `None` trait ref is used to represent auto traits.
-    VTable(Ty, Option<Binder<ExistentialTraitRef>>),
-    /// The alloc ID points to a "lazy" static variable that did not get computed (yet).
-    /// This is also used to break the cycle in recursive statics.
-    Static(StaticDef),
-    /// The alloc ID points to memory.
-    Memory(Allocation),
-    /// The first pointer-sized segment of a type id. On 64 bit systems, the 128 bit type id
-    /// is split into two segments, on 32 bit systems there are 4 segments, and so on.
-    TypeId { ty: Ty },
-}
-
-impl From<AllocId> for GlobalAlloc {
-    fn from(value: AllocId) -> Self {
-        with(|cx| cx.global_alloc(value))
-    }
-}
-
-impl GlobalAlloc {
-    /// Retrieve the allocation id for a global allocation if it exists.
-    ///
-    /// For `[GlobalAlloc::VTable]`, this will return the allocation for the VTable of the given
-    /// type for the optional trait if the type implements the trait.
-    ///
-    /// This method will always return `None` for allocations other than `[GlobalAlloc::VTable]`.
-    pub fn vtable_allocation(&self) -> Option<AllocId> {
-        with(|cx| cx.vtable_allocation(self))
-    }
-}
-
-/// A unique identification number for each provenance
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
-pub struct AllocId(usize);
-
-impl IndexedVal for AllocId {
-    fn to_val(index: usize) -> Self {
-        AllocId(index)
-    }
-    fn to_index(&self) -> usize {
-        self.0
-    }
-}
-
-/// Utility function used to read an allocation data into a unassigned integer.
-pub(crate) fn read_target_uint(mut bytes: &[u8]) -> Result<u128, Error> {
-    let mut buf = [0u8; size_of::<u128>()];
-    match MachineInfo::target_endianness() {
-        Endian::Little => {
-            bytes.read_exact(&mut buf[..bytes.len()])?;
-            Ok(u128::from_le_bytes(buf))
-        }
-        Endian::Big => {
-            bytes.read_exact(&mut buf[16 - bytes.len()..])?;
-            Ok(u128::from_be_bytes(buf))
-        }
-    }
-}
-
-/// Utility function used to read an allocation data into an assigned integer.
-pub(crate) fn read_target_int(mut bytes: &[u8]) -> Result<i128, Error> {
-    let mut buf = [0u8; size_of::<i128>()];
-    match MachineInfo::target_endianness() {
-        Endian::Little => {
-            bytes.read_exact(&mut buf[..bytes.len()])?;
-            Ok(i128::from_le_bytes(buf))
-        }
-        Endian::Big => {
-            bytes.read_exact(&mut buf[16 - bytes.len()..])?;
-            Ok(i128::from_be_bytes(buf))
-        }
-    }
-}
diff --git a/compiler/stable_mir/src/mir/body.rs b/compiler/stable_mir/src/mir/body.rs
deleted file mode 100644
index a9fe3607232..00000000000
--- a/compiler/stable_mir/src/mir/body.rs
+++ /dev/null
@@ -1,1127 +0,0 @@
-use std::io;
-
-use serde::Serialize;
-
-use crate::compiler_interface::with;
-use crate::mir::pretty::function_body;
-use crate::ty::{
-    AdtDef, ClosureDef, CoroutineClosureDef, CoroutineDef, GenericArgs, MirConst, Movability,
-    Region, RigidTy, Ty, TyConst, TyKind, VariantIdx,
-};
-use crate::{Error, Opaque, Span, Symbol};
-
-/// The SMIR representation of a single function.
-#[derive(Clone, Debug, Serialize)]
-pub struct Body {
-    pub blocks: Vec<BasicBlock>,
-
-    /// Declarations of locals within the function.
-    ///
-    /// The first local is the return value pointer, followed by `arg_count`
-    /// locals for the function arguments, followed by any user-declared
-    /// variables and temporaries.
-    pub(super) locals: LocalDecls,
-
-    /// The number of arguments this function takes.
-    pub(super) arg_count: usize,
-
-    /// Debug information pertaining to user variables, including captures.
-    pub var_debug_info: Vec<VarDebugInfo>,
-
-    /// Mark an argument (which must be a tuple) as getting passed as its individual components.
-    ///
-    /// This is used for the "rust-call" ABI such as closures.
-    pub(super) spread_arg: Option<Local>,
-
-    /// The span that covers the entire function body.
-    pub span: Span,
-}
-
-pub type BasicBlockIdx = usize;
-
-impl Body {
-    /// Constructs a `Body`.
-    ///
-    /// A constructor is required to build a `Body` from outside the crate
-    /// because the `arg_count` and `locals` fields are private.
-    pub fn new(
-        blocks: Vec<BasicBlock>,
-        locals: LocalDecls,
-        arg_count: usize,
-        var_debug_info: Vec<VarDebugInfo>,
-        spread_arg: Option<Local>,
-        span: Span,
-    ) -> Self {
-        // If locals doesn't contain enough entries, it can lead to panics in
-        // `ret_local`, `arg_locals`, and `inner_locals`.
-        assert!(
-            locals.len() > arg_count,
-            "A Body must contain at least a local for the return value and each of the function's arguments"
-        );
-        Self { blocks, locals, arg_count, var_debug_info, spread_arg, span }
-    }
-
-    /// Return local that holds this function's return value.
-    pub fn ret_local(&self) -> &LocalDecl {
-        &self.locals[RETURN_LOCAL]
-    }
-
-    /// Locals in `self` that correspond to this function's arguments.
-    pub fn arg_locals(&self) -> &[LocalDecl] {
-        &self.locals[1..][..self.arg_count]
-    }
-
-    /// Inner locals for this function. These are the locals that are
-    /// neither the return local nor the argument locals.
-    pub fn inner_locals(&self) -> &[LocalDecl] {
-        &self.locals[self.arg_count + 1..]
-    }
-
-    /// Returns a mutable reference to the local that holds this function's return value.
-    pub(crate) fn ret_local_mut(&mut self) -> &mut LocalDecl {
-        &mut self.locals[RETURN_LOCAL]
-    }
-
-    /// Returns a mutable slice of locals corresponding to this function's arguments.
-    pub(crate) fn arg_locals_mut(&mut self) -> &mut [LocalDecl] {
-        &mut self.locals[1..][..self.arg_count]
-    }
-
-    /// Returns a mutable slice of inner locals for this function.
-    /// Inner locals are those that are neither the return local nor the argument locals.
-    pub(crate) fn inner_locals_mut(&mut self) -> &mut [LocalDecl] {
-        &mut self.locals[self.arg_count + 1..]
-    }
-
-    /// Convenience function to get all the locals in this function.
-    ///
-    /// Locals are typically accessed via the more specific methods `ret_local`,
-    /// `arg_locals`, and `inner_locals`.
-    pub fn locals(&self) -> &[LocalDecl] {
-        &self.locals
-    }
-
-    /// Get the local declaration for this local.
-    pub fn local_decl(&self, local: Local) -> Option<&LocalDecl> {
-        self.locals.get(local)
-    }
-
-    /// Get an iterator for all local declarations.
-    pub fn local_decls(&self) -> impl Iterator<Item = (Local, &LocalDecl)> {
-        self.locals.iter().enumerate()
-    }
-
-    /// Emit the body using the provided name for the signature.
-    pub fn dump<W: io::Write>(&self, w: &mut W, fn_name: &str) -> io::Result<()> {
-        function_body(w, self, fn_name)
-    }
-
-    pub fn spread_arg(&self) -> Option<Local> {
-        self.spread_arg
-    }
-}
-
-type LocalDecls = Vec<LocalDecl>;
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct LocalDecl {
-    pub ty: Ty,
-    pub span: Span,
-    pub mutability: Mutability,
-}
-
-#[derive(Clone, PartialEq, Eq, Debug, Serialize)]
-pub struct BasicBlock {
-    pub statements: Vec<Statement>,
-    pub terminator: Terminator,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct Terminator {
-    pub kind: TerminatorKind,
-    pub span: Span,
-}
-
-impl Terminator {
-    pub fn successors(&self) -> Successors {
-        self.kind.successors()
-    }
-}
-
-pub type Successors = Vec<BasicBlockIdx>;
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum TerminatorKind {
-    Goto {
-        target: BasicBlockIdx,
-    },
-    SwitchInt {
-        discr: Operand,
-        targets: SwitchTargets,
-    },
-    Resume,
-    Abort,
-    Return,
-    Unreachable,
-    Drop {
-        place: Place,
-        target: BasicBlockIdx,
-        unwind: UnwindAction,
-    },
-    Call {
-        func: Operand,
-        args: Vec<Operand>,
-        destination: Place,
-        target: Option<BasicBlockIdx>,
-        unwind: UnwindAction,
-    },
-    Assert {
-        cond: Operand,
-        expected: bool,
-        msg: AssertMessage,
-        target: BasicBlockIdx,
-        unwind: UnwindAction,
-    },
-    InlineAsm {
-        template: String,
-        operands: Vec<InlineAsmOperand>,
-        options: String,
-        line_spans: String,
-        destination: Option<BasicBlockIdx>,
-        unwind: UnwindAction,
-    },
-}
-
-impl TerminatorKind {
-    pub fn successors(&self) -> Successors {
-        use self::TerminatorKind::*;
-        match *self {
-            Call { target: Some(t), unwind: UnwindAction::Cleanup(u), .. }
-            | Drop { target: t, unwind: UnwindAction::Cleanup(u), .. }
-            | Assert { target: t, unwind: UnwindAction::Cleanup(u), .. }
-            | InlineAsm { destination: Some(t), unwind: UnwindAction::Cleanup(u), .. } => {
-                vec![t, u]
-            }
-            Goto { target: t }
-            | Call { target: None, unwind: UnwindAction::Cleanup(t), .. }
-            | Call { target: Some(t), unwind: _, .. }
-            | Drop { target: t, unwind: _, .. }
-            | Assert { target: t, unwind: _, .. }
-            | InlineAsm { destination: None, unwind: UnwindAction::Cleanup(t), .. }
-            | InlineAsm { destination: Some(t), unwind: _, .. } => {
-                vec![t]
-            }
-
-            Return
-            | Resume
-            | Abort
-            | Unreachable
-            | Call { target: None, unwind: _, .. }
-            | InlineAsm { destination: None, unwind: _, .. } => {
-                vec![]
-            }
-            SwitchInt { ref targets, .. } => targets.all_targets(),
-        }
-    }
-
-    pub fn unwind(&self) -> Option<&UnwindAction> {
-        match *self {
-            TerminatorKind::Goto { .. }
-            | TerminatorKind::Return
-            | TerminatorKind::Unreachable
-            | TerminatorKind::Resume
-            | TerminatorKind::Abort
-            | TerminatorKind::SwitchInt { .. } => None,
-            TerminatorKind::Call { ref unwind, .. }
-            | TerminatorKind::Assert { ref unwind, .. }
-            | TerminatorKind::Drop { ref unwind, .. }
-            | TerminatorKind::InlineAsm { ref unwind, .. } => Some(unwind),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct InlineAsmOperand {
-    pub in_value: Option<Operand>,
-    pub out_place: Option<Place>,
-    // This field has a raw debug representation of MIR's InlineAsmOperand.
-    // For now we care about place/operand + the rest in a debug format.
-    pub raw_rpr: String,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum UnwindAction {
-    Continue,
-    Unreachable,
-    Terminate,
-    Cleanup(BasicBlockIdx),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum AssertMessage {
-    BoundsCheck { len: Operand, index: Operand },
-    Overflow(BinOp, Operand, Operand),
-    OverflowNeg(Operand),
-    DivisionByZero(Operand),
-    RemainderByZero(Operand),
-    ResumedAfterReturn(CoroutineKind),
-    ResumedAfterPanic(CoroutineKind),
-    ResumedAfterDrop(CoroutineKind),
-    MisalignedPointerDereference { required: Operand, found: Operand },
-    NullPointerDereference,
-    InvalidEnumConstruction(Operand),
-}
-
-impl AssertMessage {
-    pub fn description(&self) -> Result<&'static str, Error> {
-        match self {
-            AssertMessage::Overflow(BinOp::Add, _, _) => Ok("attempt to add with overflow"),
-            AssertMessage::Overflow(BinOp::Sub, _, _) => Ok("attempt to subtract with overflow"),
-            AssertMessage::Overflow(BinOp::Mul, _, _) => Ok("attempt to multiply with overflow"),
-            AssertMessage::Overflow(BinOp::Div, _, _) => Ok("attempt to divide with overflow"),
-            AssertMessage::Overflow(BinOp::Rem, _, _) => {
-                Ok("attempt to calculate the remainder with overflow")
-            }
-            AssertMessage::OverflowNeg(_) => Ok("attempt to negate with overflow"),
-            AssertMessage::Overflow(BinOp::Shr, _, _) => Ok("attempt to shift right with overflow"),
-            AssertMessage::Overflow(BinOp::Shl, _, _) => Ok("attempt to shift left with overflow"),
-            AssertMessage::Overflow(op, _, _) => Err(error!("`{:?}` cannot overflow", op)),
-            AssertMessage::DivisionByZero(_) => Ok("attempt to divide by zero"),
-            AssertMessage::RemainderByZero(_) => {
-                Ok("attempt to calculate the remainder with a divisor of zero")
-            }
-            AssertMessage::ResumedAfterReturn(CoroutineKind::Coroutine(_)) => {
-                Ok("coroutine resumed after completion")
-            }
-            AssertMessage::ResumedAfterReturn(CoroutineKind::Desugared(
-                CoroutineDesugaring::Async,
-                _,
-            )) => Ok("`async fn` resumed after completion"),
-            AssertMessage::ResumedAfterReturn(CoroutineKind::Desugared(
-                CoroutineDesugaring::Gen,
-                _,
-            )) => Ok("`async gen fn` resumed after completion"),
-            AssertMessage::ResumedAfterReturn(CoroutineKind::Desugared(
-                CoroutineDesugaring::AsyncGen,
-                _,
-            )) => Ok("`gen fn` should just keep returning `AssertMessage::None` after completion"),
-            AssertMessage::ResumedAfterPanic(CoroutineKind::Coroutine(_)) => {
-                Ok("coroutine resumed after panicking")
-            }
-            AssertMessage::ResumedAfterPanic(CoroutineKind::Desugared(
-                CoroutineDesugaring::Async,
-                _,
-            )) => Ok("`async fn` resumed after panicking"),
-            AssertMessage::ResumedAfterPanic(CoroutineKind::Desugared(
-                CoroutineDesugaring::Gen,
-                _,
-            )) => Ok("`async gen fn` resumed after panicking"),
-            AssertMessage::ResumedAfterPanic(CoroutineKind::Desugared(
-                CoroutineDesugaring::AsyncGen,
-                _,
-            )) => Ok("`gen fn` should just keep returning `AssertMessage::None` after panicking"),
-
-            AssertMessage::ResumedAfterDrop(CoroutineKind::Coroutine(_)) => {
-                Ok("coroutine resumed after async drop")
-            }
-            AssertMessage::ResumedAfterDrop(CoroutineKind::Desugared(
-                CoroutineDesugaring::Async,
-                _,
-            )) => Ok("`async fn` resumed after async drop"),
-            AssertMessage::ResumedAfterDrop(CoroutineKind::Desugared(
-                CoroutineDesugaring::Gen,
-                _,
-            )) => Ok("`async gen fn` resumed after async drop"),
-            AssertMessage::ResumedAfterDrop(CoroutineKind::Desugared(
-                CoroutineDesugaring::AsyncGen,
-                _,
-            )) => Ok("`gen fn` should just keep returning `AssertMessage::None` after async drop"),
-
-            AssertMessage::BoundsCheck { .. } => Ok("index out of bounds"),
-            AssertMessage::MisalignedPointerDereference { .. } => {
-                Ok("misaligned pointer dereference")
-            }
-            AssertMessage::NullPointerDereference => Ok("null pointer dereference occurred"),
-            AssertMessage::InvalidEnumConstruction(_) => {
-                Ok("trying to construct an enum from an invalid value")
-            }
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum BinOp {
-    Add,
-    AddUnchecked,
-    Sub,
-    SubUnchecked,
-    Mul,
-    MulUnchecked,
-    Div,
-    Rem,
-    BitXor,
-    BitAnd,
-    BitOr,
-    Shl,
-    ShlUnchecked,
-    Shr,
-    ShrUnchecked,
-    Eq,
-    Lt,
-    Le,
-    Ne,
-    Ge,
-    Gt,
-    Cmp,
-    Offset,
-}
-
-impl BinOp {
-    /// Return the type of this operation for the given input Ty.
-    /// This function does not perform type checking, and it currently doesn't handle SIMD.
-    pub fn ty(&self, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
-        with(|ctx| ctx.binop_ty(*self, lhs_ty, rhs_ty))
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum UnOp {
-    Not,
-    Neg,
-    PtrMetadata,
-}
-
-impl UnOp {
-    /// Return the type of this operation for the given input Ty.
-    /// This function does not perform type checking, and it currently doesn't handle SIMD.
-    pub fn ty(&self, arg_ty: Ty) -> Ty {
-        with(|ctx| ctx.unop_ty(*self, arg_ty))
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum CoroutineKind {
-    Desugared(CoroutineDesugaring, CoroutineSource),
-    Coroutine(Movability),
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum CoroutineSource {
-    Block,
-    Closure,
-    Fn,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum CoroutineDesugaring {
-    Async,
-
-    Gen,
-
-    AsyncGen,
-}
-
-pub(crate) type LocalDefId = Opaque;
-/// The rustc coverage data structures are heavily tied to internal details of the
-/// coverage implementation that are likely to change, and are unlikely to be
-/// useful to third-party tools for the foreseeable future.
-pub(crate) type Coverage = Opaque;
-
-/// The FakeReadCause describes the type of pattern why a FakeRead statement exists.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum FakeReadCause {
-    ForMatchGuard,
-    ForMatchedPlace(LocalDefId),
-    ForGuardBinding,
-    ForLet(LocalDefId),
-    ForIndex,
-}
-
-/// Describes what kind of retag is to be performed
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Serialize)]
-pub enum RetagKind {
-    FnEntry,
-    TwoPhase,
-    Raw,
-    Default,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Serialize)]
-pub enum Variance {
-    Covariant,
-    Invariant,
-    Contravariant,
-    Bivariant,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct CopyNonOverlapping {
-    pub src: Operand,
-    pub dst: Operand,
-    pub count: Operand,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum NonDivergingIntrinsic {
-    Assume(Operand),
-    CopyNonOverlapping(CopyNonOverlapping),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct Statement {
-    pub kind: StatementKind,
-    pub span: Span,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum StatementKind {
-    Assign(Place, Rvalue),
-    FakeRead(FakeReadCause, Place),
-    SetDiscriminant { place: Place, variant_index: VariantIdx },
-    Deinit(Place),
-    StorageLive(Local),
-    StorageDead(Local),
-    Retag(RetagKind, Place),
-    PlaceMention(Place),
-    AscribeUserType { place: Place, projections: UserTypeProjection, variance: Variance },
-    Coverage(Coverage),
-    Intrinsic(NonDivergingIntrinsic),
-    ConstEvalCounter,
-    Nop,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum Rvalue {
-    /// Creates a pointer with the indicated mutability to the place.
-    ///
-    /// This is generated by pointer casts like `&v as *const _` or raw address of expressions like
-    /// `&raw v` or `addr_of!(v)`.
-    AddressOf(RawPtrKind, Place),
-
-    /// Creates an aggregate value, like a tuple or struct.
-    ///
-    /// This is needed because dataflow analysis needs to distinguish
-    /// `dest = Foo { x: ..., y: ... }` from `dest.x = ...; dest.y = ...;` in the case that `Foo`
-    /// has a destructor.
-    ///
-    /// Disallowed after deaggregation for all aggregate kinds except `Array` and `Coroutine`. After
-    /// coroutine lowering, `Coroutine` aggregate kinds are disallowed too.
-    Aggregate(AggregateKind, Vec<Operand>),
-
-    /// * `Offset` has the same semantics as `<*const T>::offset`, except that the second
-    ///   parameter may be a `usize` as well.
-    /// * The comparison operations accept `bool`s, `char`s, signed or unsigned integers, floats,
-    ///   raw pointers, or function pointers and return a `bool`. The types of the operands must be
-    ///   matching, up to the usual caveat of the lifetimes in function pointers.
-    /// * Left and right shift operations accept signed or unsigned integers not necessarily of the
-    ///   same type and return a value of the same type as their LHS. Like in Rust, the RHS is
-    ///   truncated as needed.
-    /// * The `Bit*` operations accept signed integers, unsigned integers, or bools with matching
-    ///   types and return a value of that type.
-    /// * The remaining operations accept signed integers, unsigned integers, or floats with
-    ///   matching types and return a value of that type.
-    BinaryOp(BinOp, Operand, Operand),
-
-    /// Performs essentially all of the casts that can be performed via `as`.
-    ///
-    /// This allows for casts from/to a variety of types.
-    Cast(CastKind, Operand, Ty),
-
-    /// Same as `BinaryOp`, but yields `(T, bool)` with a `bool` indicating an error condition.
-    ///
-    /// For addition, subtraction, and multiplication on integers the error condition is set when
-    /// the infinite precision result would not be equal to the actual result.
-    CheckedBinaryOp(BinOp, Operand, Operand),
-
-    /// A CopyForDeref is equivalent to a read from a place.
-    /// When such a read happens, it is guaranteed that the only use of the returned value is a
-    /// deref operation, immediately followed by one or more projections.
-    CopyForDeref(Place),
-
-    /// Computes the discriminant of the place, returning it as an integer.
-    /// Returns zero for types without discriminant.
-    ///
-    /// The validity requirements for the underlying value are undecided for this rvalue, see
-    /// [#91095]. Note too that the value of the discriminant is not the same thing as the
-    /// variant index;
-    ///
-    /// [#91095]: https://github.com/rust-lang/rust/issues/91095
-    Discriminant(Place),
-
-    /// Yields the length of the place, as a `usize`.
-    ///
-    /// If the type of the place is an array, this is the array length. For slices (`[T]`, not
-    /// `&[T]`) this accesses the place's metadata to determine the length. This rvalue is
-    /// ill-formed for places of other types.
-    Len(Place),
-
-    /// Creates a reference to the place.
-    Ref(Region, BorrowKind, Place),
-
-    /// Creates an array where each element is the value of the operand.
-    ///
-    /// This is the cause of a bug in the case where the repetition count is zero because the value
-    /// is not dropped, see [#74836].
-    ///
-    /// Corresponds to source code like `[x; 32]`.
-    ///
-    /// [#74836]: https://github.com/rust-lang/rust/issues/74836
-    Repeat(Operand, TyConst),
-
-    /// Transmutes a `*mut u8` into shallow-initialized `Box<T>`.
-    ///
-    /// This is different from a normal transmute because dataflow analysis will treat the box as
-    /// initialized but its content as uninitialized. Like other pointer casts, this in general
-    /// affects alias analysis.
-    ShallowInitBox(Operand, Ty),
-
-    /// Creates a pointer/reference to the given thread local.
-    ///
-    /// The yielded type is a `*mut T` if the static is mutable, otherwise if the static is extern a
-    /// `*const T`, and if neither of those apply a `&T`.
-    ///
-    /// **Note:** This is a runtime operation that actually executes code and is in this sense more
-    /// like a function call. Also, eliminating dead stores of this rvalue causes `fn main() {}` to
-    /// SIGILL for some reason that I (JakobDegen) never got a chance to look into.
-    ///
-    /// **Needs clarification**: Are there weird additional semantics here related to the runtime
-    /// nature of this operation?
-    ThreadLocalRef(crate::CrateItem),
-
-    /// Computes a value as described by the operation.
-    NullaryOp(NullOp, Ty),
-
-    /// Exactly like `BinaryOp`, but less operands.
-    ///
-    /// Also does two's-complement arithmetic. Negation requires a signed integer or a float;
-    /// bitwise not requires a signed integer, unsigned integer, or bool. Both operation kinds
-    /// return a value with the same type as their operand.
-    UnaryOp(UnOp, Operand),
-
-    /// Yields the operand unchanged
-    Use(Operand),
-}
-
-impl Rvalue {
-    pub fn ty(&self, locals: &[LocalDecl]) -> Result<Ty, Error> {
-        match self {
-            Rvalue::Use(operand) => operand.ty(locals),
-            Rvalue::Repeat(operand, count) => {
-                Ok(Ty::new_array_with_const_len(operand.ty(locals)?, count.clone()))
-            }
-            Rvalue::ThreadLocalRef(did) => Ok(did.ty()),
-            Rvalue::Ref(reg, bk, place) => {
-                let place_ty = place.ty(locals)?;
-                Ok(Ty::new_ref(reg.clone(), place_ty, bk.to_mutable_lossy()))
-            }
-            Rvalue::AddressOf(mutability, place) => {
-                let place_ty = place.ty(locals)?;
-                Ok(Ty::new_ptr(place_ty, mutability.to_mutable_lossy()))
-            }
-            Rvalue::Len(..) => Ok(Ty::usize_ty()),
-            Rvalue::Cast(.., ty) => Ok(*ty),
-            Rvalue::BinaryOp(op, lhs, rhs) => {
-                let lhs_ty = lhs.ty(locals)?;
-                let rhs_ty = rhs.ty(locals)?;
-                Ok(op.ty(lhs_ty, rhs_ty))
-            }
-            Rvalue::CheckedBinaryOp(op, lhs, rhs) => {
-                let lhs_ty = lhs.ty(locals)?;
-                let rhs_ty = rhs.ty(locals)?;
-                let ty = op.ty(lhs_ty, rhs_ty);
-                Ok(Ty::new_tuple(&[ty, Ty::bool_ty()]))
-            }
-            Rvalue::UnaryOp(op, operand) => {
-                let arg_ty = operand.ty(locals)?;
-                Ok(op.ty(arg_ty))
-            }
-            Rvalue::Discriminant(place) => {
-                let place_ty = place.ty(locals)?;
-                place_ty
-                    .kind()
-                    .discriminant_ty()
-                    .ok_or_else(|| error!("Expected a `RigidTy` but found: {place_ty:?}"))
-            }
-            Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..), _) => {
-                Ok(Ty::usize_ty())
-            }
-            Rvalue::NullaryOp(NullOp::ContractChecks, _)
-            | Rvalue::NullaryOp(NullOp::UbChecks, _) => Ok(Ty::bool_ty()),
-            Rvalue::Aggregate(ak, ops) => match *ak {
-                AggregateKind::Array(ty) => Ty::try_new_array(ty, ops.len() as u64),
-                AggregateKind::Tuple => Ok(Ty::new_tuple(
-                    &ops.iter().map(|op| op.ty(locals)).collect::<Result<Vec<_>, _>>()?,
-                )),
-                AggregateKind::Adt(def, _, ref args, _, _) => Ok(def.ty_with_args(args)),
-                AggregateKind::Closure(def, ref args) => Ok(Ty::new_closure(def, args.clone())),
-                AggregateKind::Coroutine(def, ref args, mov) => {
-                    Ok(Ty::new_coroutine(def, args.clone(), mov))
-                }
-                AggregateKind::CoroutineClosure(def, ref args) => {
-                    Ok(Ty::new_coroutine_closure(def, args.clone()))
-                }
-                AggregateKind::RawPtr(ty, mutability) => Ok(Ty::new_ptr(ty, mutability)),
-            },
-            Rvalue::ShallowInitBox(_, ty) => Ok(Ty::new_box(*ty)),
-            Rvalue::CopyForDeref(place) => place.ty(locals),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum AggregateKind {
-    Array(Ty),
-    Tuple,
-    Adt(AdtDef, VariantIdx, GenericArgs, Option<UserTypeAnnotationIndex>, Option<FieldIdx>),
-    Closure(ClosureDef, GenericArgs),
-    // FIXME(stable_mir): Movability here is redundant
-    Coroutine(CoroutineDef, GenericArgs, Movability),
-    CoroutineClosure(CoroutineClosureDef, GenericArgs),
-    RawPtr(Ty, Mutability),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum Operand {
-    Copy(Place),
-    Move(Place),
-    Constant(ConstOperand),
-}
-
-#[derive(Clone, Eq, PartialEq, Serialize)]
-pub struct Place {
-    pub local: Local,
-    /// projection out of a place (access a field, deref a pointer, etc)
-    pub projection: Vec<ProjectionElem>,
-}
-
-impl From<Local> for Place {
-    fn from(local: Local) -> Self {
-        Place { local, projection: vec![] }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct ConstOperand {
-    pub span: Span,
-    pub user_ty: Option<UserTypeAnnotationIndex>,
-    pub const_: MirConst,
-}
-
-/// Debug information pertaining to a user variable.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct VarDebugInfo {
-    /// The variable name.
-    pub name: Symbol,
-
-    /// Source info of the user variable, including the scope
-    /// within which the variable is visible (to debuginfo).
-    pub source_info: SourceInfo,
-
-    /// The user variable's data is split across several fragments,
-    /// each described by a `VarDebugInfoFragment`.
-    pub composite: Option<VarDebugInfoFragment>,
-
-    /// Where the data for this user variable is to be found.
-    pub value: VarDebugInfoContents,
-
-    /// When present, indicates what argument number this variable is in the function that it
-    /// originated from (starting from 1). Note, if MIR inlining is enabled, then this is the
-    /// argument number in the original function before it was inlined.
-    pub argument_index: Option<u16>,
-}
-
-impl VarDebugInfo {
-    /// Return a local variable if this info is related to one.
-    pub fn local(&self) -> Option<Local> {
-        match &self.value {
-            VarDebugInfoContents::Place(place) if place.projection.is_empty() => Some(place.local),
-            VarDebugInfoContents::Place(_) | VarDebugInfoContents::Const(_) => None,
-        }
-    }
-
-    /// Return a constant if this info is related to one.
-    pub fn constant(&self) -> Option<&ConstOperand> {
-        match &self.value {
-            VarDebugInfoContents::Place(_) => None,
-            VarDebugInfoContents::Const(const_op) => Some(const_op),
-        }
-    }
-}
-
-pub type SourceScope = u32;
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct SourceInfo {
-    pub span: Span,
-    pub scope: SourceScope,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct VarDebugInfoFragment {
-    pub ty: Ty,
-    pub projection: Vec<ProjectionElem>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum VarDebugInfoContents {
-    Place(Place),
-    Const(ConstOperand),
-}
-
-// In MIR ProjectionElem is parameterized on the second Field argument and the Index argument. This
-// is so it can be used for both Places (for which the projection elements are of type
-// ProjectionElem<Local, Ty>) and user-provided type annotations (for which the projection elements
-// are of type ProjectionElem<(), ()>). In SMIR we don't need this generality, so we just use
-// ProjectionElem for Places.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum ProjectionElem {
-    /// Dereference projections (e.g. `*_1`) project to the address referenced by the base place.
-    Deref,
-
-    /// A field projection (e.g., `f` in `_1.f`) project to a field in the base place. The field is
-    /// referenced by source-order index rather than the name of the field. The fields type is also
-    /// given.
-    Field(FieldIdx, Ty),
-
-    /// Index into a slice/array. The value of the index is computed at runtime using the `V`
-    /// argument.
-    ///
-    /// Note that this does not also dereference, and so it does not exactly correspond to slice
-    /// indexing in Rust. In other words, in the below Rust code:
-    ///
-    /// ```rust
-    /// let x = &[1, 2, 3, 4];
-    /// let i = 2;
-    /// x[i];
-    /// ```
-    ///
-    /// The `x[i]` is turned into a `Deref` followed by an `Index`, not just an `Index`. The same
-    /// thing is true of the `ConstantIndex` and `Subslice` projections below.
-    Index(Local),
-
-    /// Index into a slice/array given by offsets.
-    ///
-    /// These indices are generated by slice patterns. Easiest to explain by example:
-    ///
-    /// ```ignore (illustrative)
-    /// [X, _, .._, _, _] => { offset: 0, min_length: 4, from_end: false },
-    /// [_, X, .._, _, _] => { offset: 1, min_length: 4, from_end: false },
-    /// [_, _, .._, X, _] => { offset: 2, min_length: 4, from_end: true },
-    /// [_, _, .._, _, X] => { offset: 1, min_length: 4, from_end: true },
-    /// ```
-    ConstantIndex {
-        /// index or -index (in Python terms), depending on from_end
-        offset: u64,
-        /// The thing being indexed must be at least this long -- otherwise, the
-        /// projection is UB.
-        ///
-        /// For arrays this is always the exact length.
-        min_length: u64,
-        /// Counting backwards from end? This is always false when indexing an
-        /// array.
-        from_end: bool,
-    },
-
-    /// Projects a slice from the base place.
-    ///
-    /// These indices are generated by slice patterns. If `from_end` is true, this represents
-    /// `slice[from..slice.len() - to]`. Otherwise it represents `array[from..to]`.
-    Subslice {
-        from: u64,
-        to: u64,
-        /// Whether `to` counts from the start or end of the array/slice.
-        from_end: bool,
-    },
-
-    /// "Downcast" to a variant of an enum or a coroutine.
-    Downcast(VariantIdx),
-
-    /// Like an explicit cast from an opaque type to a concrete type, but without
-    /// requiring an intermediate variable.
-    OpaqueCast(Ty),
-
-    /// A `Subtype(T)` projection is applied to any `StatementKind::Assign` where
-    /// type of lvalue doesn't match the type of rvalue, the primary goal is making subtyping
-    /// explicit during optimizations and codegen.
-    ///
-    /// This projection doesn't impact the runtime behavior of the program except for potentially changing
-    /// some type metadata of the interpreter or codegen backend.
-    Subtype(Ty),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct UserTypeProjection {
-    pub base: UserTypeAnnotationIndex,
-
-    pub projection: Opaque,
-}
-
-pub type Local = usize;
-
-pub const RETURN_LOCAL: Local = 0;
-
-/// The source-order index of a field in a variant.
-///
-/// For example, in the following types,
-/// ```ignore(illustrative)
-/// enum Demo1 {
-///    Variant0 { a: bool, b: i32 },
-///    Variant1 { c: u8, d: u64 },
-/// }
-/// struct Demo2 { e: u8, f: u16, g: u8 }
-/// ```
-/// `a`'s `FieldIdx` is `0`,
-/// `b`'s `FieldIdx` is `1`,
-/// `c`'s `FieldIdx` is `0`, and
-/// `g`'s `FieldIdx` is `2`.
-pub type FieldIdx = usize;
-
-type UserTypeAnnotationIndex = usize;
-
-/// The possible branch sites of a [TerminatorKind::SwitchInt].
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct SwitchTargets {
-    /// The conditional branches where the first element represents the value that guards this
-    /// branch, and the second element is the branch target.
-    branches: Vec<(u128, BasicBlockIdx)>,
-    /// The `otherwise` branch which will be taken in case none of the conditional branches are
-    /// satisfied.
-    otherwise: BasicBlockIdx,
-}
-
-impl SwitchTargets {
-    /// All possible targets including the `otherwise` target.
-    pub fn all_targets(&self) -> Successors {
-        self.branches.iter().map(|(_, target)| *target).chain(Some(self.otherwise)).collect()
-    }
-
-    /// The `otherwise` branch target.
-    pub fn otherwise(&self) -> BasicBlockIdx {
-        self.otherwise
-    }
-
-    /// The conditional targets which are only taken if the pattern matches the given value.
-    pub fn branches(&self) -> impl Iterator<Item = (u128, BasicBlockIdx)> {
-        self.branches.iter().copied()
-    }
-
-    /// The number of targets including `otherwise`.
-    pub fn len(&self) -> usize {
-        self.branches.len() + 1
-    }
-
-    /// Create a new SwitchTargets from the given branches and `otherwise` target.
-    pub fn new(branches: Vec<(u128, BasicBlockIdx)>, otherwise: BasicBlockIdx) -> SwitchTargets {
-        SwitchTargets { branches, otherwise }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum BorrowKind {
-    /// Data must be immutable and is aliasable.
-    Shared,
-
-    /// An immutable, aliasable borrow that is discarded after borrow-checking. Can behave either
-    /// like a normal shared borrow or like a special shallow borrow (see [`FakeBorrowKind`]).
-    Fake(FakeBorrowKind),
-
-    /// Data is mutable and not aliasable.
-    Mut {
-        /// `true` if this borrow arose from method-call auto-ref
-        kind: MutBorrowKind,
-    },
-}
-
-impl BorrowKind {
-    pub fn to_mutable_lossy(self) -> Mutability {
-        match self {
-            BorrowKind::Mut { .. } => Mutability::Mut,
-            BorrowKind::Shared => Mutability::Not,
-            // FIXME: There's no type corresponding to a shallow borrow, so use `&` as an approximation.
-            BorrowKind::Fake(_) => Mutability::Not,
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum RawPtrKind {
-    Mut,
-    Const,
-    FakeForPtrMetadata,
-}
-
-impl RawPtrKind {
-    pub fn to_mutable_lossy(self) -> Mutability {
-        match self {
-            RawPtrKind::Mut { .. } => Mutability::Mut,
-            RawPtrKind::Const => Mutability::Not,
-            // FIXME: There's no type corresponding to a shallow borrow, so use `&` as an approximation.
-            RawPtrKind::FakeForPtrMetadata => Mutability::Not,
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum MutBorrowKind {
-    Default,
-    TwoPhaseBorrow,
-    ClosureCapture,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum FakeBorrowKind {
-    /// A shared (deep) borrow. Data must be immutable and is aliasable.
-    Deep,
-    /// The immediately borrowed place must be immutable, but projections from
-    /// it don't need to be. This is used to prevent match guards from replacing
-    /// the scrutinee. For example, a fake borrow of `a.b` doesn't
-    /// conflict with a mutable borrow of `a.b.c`.
-    Shallow,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub enum Mutability {
-    Not,
-    Mut,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum Safety {
-    Safe,
-    Unsafe,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum PointerCoercion {
-    /// Go from a fn-item type to a fn-pointer type.
-    ReifyFnPointer,
-
-    /// Go from a safe fn pointer to an unsafe fn pointer.
-    UnsafeFnPointer,
-
-    /// Go from a non-capturing closure to a fn pointer or an unsafe fn pointer.
-    /// It cannot convert a closure that requires unsafe.
-    ClosureFnPointer(Safety),
-
-    /// Go from a mut raw pointer to a const raw pointer.
-    MutToConstPointer,
-
-    /// Go from `*const [T; N]` to `*const T`
-    ArrayToPointer,
-
-    /// Unsize a pointer/reference value, e.g., `&[T; n]` to
-    /// `&[T]`. Note that the source could be a thin or wide pointer.
-    /// This will do things like convert thin pointers to wide
-    /// pointers, or convert structs containing thin pointers to
-    /// structs containing wide pointers, or convert between wide
-    /// pointers.
-    Unsize,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum CastKind {
-    // FIXME(smir-rename): rename this to PointerExposeProvenance
-    PointerExposeAddress,
-    PointerWithExposedProvenance,
-    PointerCoercion(PointerCoercion),
-    IntToInt,
-    FloatToInt,
-    FloatToFloat,
-    IntToFloat,
-    PtrToPtr,
-    FnPtrToPtr,
-    Transmute,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum NullOp {
-    /// Returns the size of a value of that type.
-    SizeOf,
-    /// Returns the minimum alignment of a type.
-    AlignOf,
-    /// Returns the offset of a field.
-    OffsetOf(Vec<(VariantIdx, FieldIdx)>),
-    /// cfg!(ub_checks), but at codegen time
-    UbChecks,
-    /// cfg!(contract_checks), but at codegen time
-    ContractChecks,
-}
-
-impl Operand {
-    /// Get the type of an operand relative to the local declaration.
-    ///
-    /// In order to retrieve the correct type, the `locals` argument must match the list of all
-    /// locals from the function body where this operand originates from.
-    ///
-    /// Errors indicate a malformed operand or incompatible locals list.
-    pub fn ty(&self, locals: &[LocalDecl]) -> Result<Ty, Error> {
-        match self {
-            Operand::Copy(place) | Operand::Move(place) => place.ty(locals),
-            Operand::Constant(c) => Ok(c.ty()),
-        }
-    }
-}
-
-impl ConstOperand {
-    pub fn ty(&self) -> Ty {
-        self.const_.ty()
-    }
-}
-
-impl Place {
-    /// Resolve down the chain of projections to get the type referenced at the end of it.
-    /// E.g.:
-    /// Calling `ty()` on `var.field` should return the type of `field`.
-    ///
-    /// In order to retrieve the correct type, the `locals` argument must match the list of all
-    /// locals from the function body where this place originates from.
-    pub fn ty(&self, locals: &[LocalDecl]) -> Result<Ty, Error> {
-        self.projection.iter().try_fold(locals[self.local].ty, |place_ty, elem| elem.ty(place_ty))
-    }
-}
-
-impl ProjectionElem {
-    /// Get the expected type after applying this projection to a given place type.
-    pub fn ty(&self, place_ty: Ty) -> Result<Ty, Error> {
-        let ty = place_ty;
-        match &self {
-            ProjectionElem::Deref => Self::deref_ty(ty),
-            ProjectionElem::Field(_idx, fty) => Ok(*fty),
-            ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } => Self::index_ty(ty),
-            ProjectionElem::Subslice { from, to, from_end } => {
-                Self::subslice_ty(ty, *from, *to, *from_end)
-            }
-            ProjectionElem::Downcast(_) => Ok(ty),
-            ProjectionElem::OpaqueCast(ty) | ProjectionElem::Subtype(ty) => Ok(*ty),
-        }
-    }
-
-    fn index_ty(ty: Ty) -> Result<Ty, Error> {
-        ty.kind().builtin_index().ok_or_else(|| error!("Cannot index non-array type: {ty:?}"))
-    }
-
-    fn subslice_ty(ty: Ty, from: u64, to: u64, from_end: bool) -> Result<Ty, Error> {
-        let ty_kind = ty.kind();
-        match ty_kind {
-            TyKind::RigidTy(RigidTy::Slice(..)) => Ok(ty),
-            TyKind::RigidTy(RigidTy::Array(inner, _)) if !from_end => Ty::try_new_array(
-                inner,
-                to.checked_sub(from).ok_or_else(|| error!("Subslice overflow: {from}..{to}"))?,
-            ),
-            TyKind::RigidTy(RigidTy::Array(inner, size)) => {
-                let size = size.eval_target_usize()?;
-                let len = size - from - to;
-                Ty::try_new_array(inner, len)
-            }
-            _ => Err(Error(format!("Cannot subslice non-array type: `{ty_kind:?}`"))),
-        }
-    }
-
-    fn deref_ty(ty: Ty) -> Result<Ty, Error> {
-        let deref_ty = ty
-            .kind()
-            .builtin_deref(true)
-            .ok_or_else(|| error!("Cannot dereference type: {ty:?}"))?;
-        Ok(deref_ty.ty)
-    }
-}
diff --git a/compiler/stable_mir/src/mir/mono.rs b/compiler/stable_mir/src/mir/mono.rs
deleted file mode 100644
index c54fcecac9f..00000000000
--- a/compiler/stable_mir/src/mir/mono.rs
+++ /dev/null
@@ -1,305 +0,0 @@
-use std::fmt::{Debug, Formatter};
-use std::io;
-
-use rustc_smir::bridge::SmirError;
-use serde::Serialize;
-
-use crate::abi::FnAbi;
-use crate::crate_def::CrateDef;
-use crate::mir::Body;
-use crate::ty::{Allocation, ClosureDef, ClosureKind, FnDef, GenericArgs, Ty};
-use crate::{CrateItem, DefId, Error, IndexedVal, ItemKind, Opaque, Symbol, with};
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub enum MonoItem {
-    Fn(Instance),
-    Static(StaticDef),
-    GlobalAsm(Opaque),
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Serialize)]
-pub struct Instance {
-    /// The type of instance.
-    pub kind: InstanceKind,
-    /// An ID used to get the instance definition from the compiler.
-    /// Do not use this field directly.
-    pub def: InstanceDef,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub enum InstanceKind {
-    /// A user defined item.
-    Item,
-    /// A compiler intrinsic function.
-    Intrinsic,
-    /// A virtual function definition stored in a VTable.
-    /// The `idx` field indicates the position in the VTable for this instance.
-    Virtual { idx: usize },
-    /// A compiler generated shim.
-    Shim,
-}
-
-impl Instance {
-    /// Get the arguments this instance was instantiated with.
-    pub fn args(&self) -> GenericArgs {
-        with(|cx| cx.instance_args(self.def))
-    }
-
-    /// Get the body of an Instance.
-    ///
-    /// The body will be eagerly monomorphized and all constants will already be evaluated.
-    ///
-    /// This method will return the intrinsic fallback body if one was defined.
-    pub fn body(&self) -> Option<Body> {
-        with(|context| context.instance_body(self.def))
-    }
-
-    /// Check whether this instance has a body available.
-    ///
-    /// For intrinsics with fallback body, this will return `true`. It is up to the user to decide
-    /// whether to specialize the intrinsic or to use its fallback body.
-    ///
-    /// For more information on fallback body, see <https://github.com/rust-lang/rust/issues/93145>.
-    ///
-    /// This call is much cheaper than `instance.body().is_some()`, since it doesn't try to build
-    /// the StableMIR body.
-    pub fn has_body(&self) -> bool {
-        with(|cx| cx.has_body(self.def.def_id()))
-    }
-
-    pub fn is_foreign_item(&self) -> bool {
-        with(|cx| cx.is_foreign_item(self.def.def_id()))
-    }
-
-    /// Get the instance type with generic instantiations applied and lifetimes erased.
-    pub fn ty(&self) -> Ty {
-        with(|context| context.instance_ty(self.def))
-    }
-
-    /// Retrieve information about this instance binary interface.
-    pub fn fn_abi(&self) -> Result<FnAbi, Error> {
-        with(|cx| cx.instance_abi(self.def))
-    }
-
-    /// Retrieve the instance's mangled name used for calling the given instance.
-    ///
-    /// This will also look up the correct name of instances from upstream crates.
-    pub fn mangled_name(&self) -> Symbol {
-        with(|context| context.instance_mangled_name(self.def))
-    }
-
-    /// Retrieve the instance name for diagnostic messages.
-    ///
-    /// This will return the specialized name, e.g., `std::vec::Vec<u8>::new`.
-    pub fn name(&self) -> Symbol {
-        with(|context| context.instance_name(self.def, false))
-    }
-
-    /// Return a trimmed name of the given instance including its args.
-    ///
-    /// If a symbol name can only be imported from one place for a type, and as
-    /// long as it was not glob-imported anywhere in the current crate, we trim its
-    /// path and print only the name.
-    pub fn trimmed_name(&self) -> Symbol {
-        with(|context| context.instance_name(self.def, true))
-    }
-
-    /// Retrieve the plain intrinsic name of an instance if it's an intrinsic.
-    ///
-    /// The plain name does not include type arguments (as `trimmed_name` does),
-    /// which is more convenient to match with intrinsic symbols.
-    pub fn intrinsic_name(&self) -> Option<Symbol> {
-        match self.kind {
-            InstanceKind::Intrinsic => {
-                Some(with(|context| context.intrinsic(self.def.def_id()).unwrap().fn_name()))
-            }
-            InstanceKind::Item | InstanceKind::Virtual { .. } | InstanceKind::Shim => None,
-        }
-    }
-
-    /// Resolve an instance starting from a function definition and generic arguments.
-    pub fn resolve(def: FnDef, args: &GenericArgs) -> Result<Instance, Error> {
-        with(|context| {
-            context
-                .resolve_instance(def, args)
-                .ok_or_else(|| Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`")))
-        })
-    }
-
-    /// Resolve the drop in place for a given type.
-    pub fn resolve_drop_in_place(ty: Ty) -> Instance {
-        with(|cx| cx.resolve_drop_in_place(ty))
-    }
-
-    /// Resolve an instance for a given function pointer.
-    pub fn resolve_for_fn_ptr(def: FnDef, args: &GenericArgs) -> Result<Instance, Error> {
-        with(|context| {
-            context
-                .resolve_for_fn_ptr(def, args)
-                .ok_or_else(|| Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`")))
-        })
-    }
-
-    /// Resolve a closure with the expected kind.
-    pub fn resolve_closure(
-        def: ClosureDef,
-        args: &GenericArgs,
-        kind: ClosureKind,
-    ) -> Result<Instance, Error> {
-        with(|context| {
-            context
-                .resolve_closure(def, args, kind)
-                .ok_or_else(|| Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`")))
-        })
-    }
-
-    /// Check whether this instance is an empty shim.
-    ///
-    /// Allow users to check if this shim can be ignored when called directly.
-    ///
-    /// We have decided not to export different types of Shims to StableMIR users, however, this
-    /// is a query that can be very helpful for users when processing DropGlue.
-    ///
-    /// When generating code for a Drop terminator, users can ignore an empty drop glue.
-    /// These shims are only needed to generate a valid Drop call done via VTable.
-    pub fn is_empty_shim(&self) -> bool {
-        self.kind == InstanceKind::Shim && with(|cx| cx.is_empty_drop_shim(self.def))
-    }
-
-    /// Try to constant evaluate the instance into a constant with the given type.
-    ///
-    /// This can be used to retrieve a constant that represents an intrinsic return such as
-    /// `type_id`.
-    pub fn try_const_eval(&self, const_ty: Ty) -> Result<Allocation, Error> {
-        with(|cx| cx.eval_instance(self.def, const_ty))
-    }
-
-    /// Emit the body of this instance if it has one.
-    pub fn emit_mir<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
-        if let Some(body) = self.body() { body.dump(w, &self.name()) } else { Ok(()) }
-    }
-}
-
-impl Debug for Instance {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Instance")
-            .field("kind", &self.kind)
-            .field("def", &self.mangled_name())
-            .field("args", &self.args())
-            .finish()
-    }
-}
-
-/// Try to convert a crate item into an instance.
-/// The item cannot be generic in order to be converted into an instance.
-impl TryFrom<CrateItem> for Instance {
-    type Error = crate::Error;
-
-    fn try_from(item: CrateItem) -> Result<Self, Self::Error> {
-        with(|context| {
-            let def_id = item.def_id();
-            if !context.requires_monomorphization(def_id) {
-                Ok(context.mono_instance(def_id))
-            } else {
-                Err(Error::new("Item requires monomorphization".to_string()))
-            }
-        })
-    }
-}
-
-/// Try to convert an instance into a crate item.
-/// Only user defined instances can be converted.
-impl TryFrom<Instance> for CrateItem {
-    type Error = crate::Error;
-
-    fn try_from(value: Instance) -> Result<Self, Self::Error> {
-        with(|context| {
-            if value.kind == InstanceKind::Item && context.has_body(value.def.def_id()) {
-                Ok(CrateItem(context.instance_def_id(value.def)))
-            } else {
-                Err(Error::new(format!("Item kind `{:?}` cannot be converted", value.kind)))
-            }
-        })
-    }
-}
-
-impl From<Instance> for MonoItem {
-    fn from(value: Instance) -> Self {
-        MonoItem::Fn(value)
-    }
-}
-
-impl From<StaticDef> for MonoItem {
-    fn from(value: StaticDef) -> Self {
-        MonoItem::Static(value)
-    }
-}
-
-impl From<StaticDef> for CrateItem {
-    fn from(value: StaticDef) -> Self {
-        CrateItem(value.0)
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct InstanceDef(usize);
-
-impl CrateDef for InstanceDef {
-    fn def_id(&self) -> DefId {
-        with(|context| context.instance_def_id(*self))
-    }
-}
-
-crate_def! {
-    /// Holds information about a static variable definition.
-    #[derive(Serialize)]
-    pub StaticDef;
-}
-
-impl TryFrom<CrateItem> for StaticDef {
-    type Error = crate::Error;
-
-    fn try_from(value: CrateItem) -> Result<Self, Self::Error> {
-        if matches!(value.kind(), ItemKind::Static) {
-            Ok(StaticDef(value.0))
-        } else {
-            Err(Error::new(format!("Expected a static item, but found: {value:?}")))
-        }
-    }
-}
-
-impl TryFrom<Instance> for StaticDef {
-    type Error = crate::Error;
-
-    fn try_from(value: Instance) -> Result<Self, Self::Error> {
-        StaticDef::try_from(CrateItem::try_from(value)?)
-    }
-}
-
-impl From<StaticDef> for Instance {
-    fn from(value: StaticDef) -> Self {
-        // A static definition should always be convertible to an instance.
-        with(|cx| cx.mono_instance(value.def_id()))
-    }
-}
-
-impl StaticDef {
-    /// Return the type of this static definition.
-    pub fn ty(&self) -> Ty {
-        with(|cx| cx.def_ty(self.0))
-    }
-
-    /// Evaluate a static's initializer, returning the allocation of the initializer's memory.
-    pub fn eval_initializer(&self) -> Result<Allocation, Error> {
-        with(|cx| cx.eval_static_initializer(*self))
-    }
-}
-
-impl IndexedVal for InstanceDef {
-    fn to_val(index: usize) -> Self {
-        InstanceDef(index)
-    }
-    fn to_index(&self) -> usize {
-        self.0
-    }
-}
diff --git a/compiler/stable_mir/src/mir/pretty.rs b/compiler/stable_mir/src/mir/pretty.rs
deleted file mode 100644
index f496d80053e..00000000000
--- a/compiler/stable_mir/src/mir/pretty.rs
+++ /dev/null
@@ -1,469 +0,0 @@
-//! Implement methods to pretty print stable MIR body.
-use std::fmt::Debug;
-use std::io::Write;
-use std::{fmt, io, iter};
-
-use fmt::{Display, Formatter};
-
-use super::{AggregateKind, AssertMessage, BinOp, BorrowKind, FakeBorrowKind, TerminatorKind};
-use crate::mir::{
-    Operand, Place, RawPtrKind, Rvalue, StatementKind, UnwindAction, VarDebugInfoContents,
-};
-use crate::ty::{AdtKind, AssocKind, MirConst, Ty, TyConst};
-use crate::{Body, CrateDef, IndexedVal, Mutability, with};
-
-impl Display for Ty {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        with(|ctx| write!(f, "{}", ctx.ty_pretty(*self)))
-    }
-}
-
-impl Display for AssocKind {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            AssocKind::Fn { has_self: true, .. } => write!(f, "method"),
-            AssocKind::Fn { has_self: false, .. } => write!(f, "associated function"),
-            AssocKind::Const { .. } => write!(f, "associated const"),
-            AssocKind::Type { .. } => write!(f, "associated type"),
-        }
-    }
-}
-
-impl Debug for Place {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        with(|ctx| write!(f, "{}", ctx.place_pretty(self)))
-    }
-}
-
-pub(crate) fn function_body<W: Write>(writer: &mut W, body: &Body, name: &str) -> io::Result<()> {
-    write!(writer, "fn {name}(")?;
-    let mut sep = "";
-    for (index, local) in body.arg_locals().iter().enumerate() {
-        write!(writer, "{}_{}: {}", sep, index + 1, local.ty)?;
-        sep = ", ";
-    }
-    write!(writer, ")")?;
-
-    let return_local = body.ret_local();
-    writeln!(writer, " -> {} {{", return_local.ty)?;
-
-    body.locals().iter().enumerate().try_for_each(|(index, local)| -> io::Result<()> {
-        if index == 0 || index > body.arg_count {
-            writeln!(writer, "    let {}_{}: {};", pretty_mut(local.mutability), index, local.ty)
-        } else {
-            Ok(())
-        }
-    })?;
-
-    body.var_debug_info.iter().try_for_each(|info| {
-        let content = match &info.value {
-            VarDebugInfoContents::Place(place) => {
-                format!("{place:?}")
-            }
-            VarDebugInfoContents::Const(constant) => pretty_mir_const(&constant.const_),
-        };
-        writeln!(writer, "    debug {} => {};", info.name, content)
-    })?;
-
-    body.blocks
-        .iter()
-        .enumerate()
-        .map(|(index, block)| -> io::Result<()> {
-            writeln!(writer, "    bb{index}: {{")?;
-            let _ = block
-                .statements
-                .iter()
-                .map(|statement| -> io::Result<()> {
-                    pretty_statement(writer, &statement.kind)?;
-                    Ok(())
-                })
-                .collect::<Vec<_>>();
-            pretty_terminator(writer, &block.terminator.kind)?;
-            writeln!(writer, "    }}").unwrap();
-            Ok(())
-        })
-        .collect::<Result<Vec<_>, _>>()?;
-    writeln!(writer, "}}")?;
-    Ok(())
-}
-
-fn pretty_statement<W: Write>(writer: &mut W, statement: &StatementKind) -> io::Result<()> {
-    const INDENT: &str = "        ";
-    match statement {
-        StatementKind::Assign(place, rval) => {
-            write!(writer, "{INDENT}{place:?} = ")?;
-            pretty_rvalue(writer, rval)?;
-            writeln!(writer, ";")
-        }
-        // FIXME: Add rest of the statements
-        StatementKind::FakeRead(cause, place) => {
-            writeln!(writer, "{INDENT}FakeRead({cause:?}, {place:?});")
-        }
-        StatementKind::SetDiscriminant { place, variant_index } => {
-            writeln!(writer, "{INDENT}discriminant({place:?} = {};", variant_index.to_index())
-        }
-        StatementKind::Deinit(place) => writeln!(writer, "Deinit({place:?};"),
-        StatementKind::StorageLive(local) => {
-            writeln!(writer, "{INDENT}StorageLive(_{local});")
-        }
-        StatementKind::StorageDead(local) => {
-            writeln!(writer, "{INDENT}StorageDead(_{local});")
-        }
-        StatementKind::Retag(kind, place) => writeln!(writer, "Retag({kind:?}, {place:?});"),
-        StatementKind::PlaceMention(place) => {
-            writeln!(writer, "{INDENT}PlaceMention({place:?};")
-        }
-        StatementKind::ConstEvalCounter => {
-            writeln!(writer, "{INDENT}ConstEvalCounter;")
-        }
-        StatementKind::Nop => writeln!(writer, "{INDENT}nop;"),
-        StatementKind::AscribeUserType { .. }
-        | StatementKind::Coverage(_)
-        | StatementKind::Intrinsic(_) => {
-            // FIX-ME: Make them pretty.
-            writeln!(writer, "{INDENT}{statement:?};")
-        }
-    }
-}
-
-fn pretty_terminator<W: Write>(writer: &mut W, terminator: &TerminatorKind) -> io::Result<()> {
-    pretty_terminator_head(writer, terminator)?;
-    let successors = terminator.successors();
-    let successor_count = successors.len();
-    let labels = pretty_successor_labels(terminator);
-
-    let show_unwind = !matches!(terminator.unwind(), None | Some(UnwindAction::Cleanup(_)));
-    let fmt_unwind = |w: &mut W| -> io::Result<()> {
-        write!(w, "unwind ")?;
-        match terminator.unwind() {
-            None | Some(UnwindAction::Cleanup(_)) => unreachable!(),
-            Some(UnwindAction::Continue) => write!(w, "continue"),
-            Some(UnwindAction::Unreachable) => write!(w, "unreachable"),
-            Some(UnwindAction::Terminate) => write!(w, "terminate"),
-        }
-    };
-
-    match (successor_count, show_unwind) {
-        (0, false) => {}
-        (0, true) => {
-            write!(writer, " -> ")?;
-            fmt_unwind(writer)?;
-        }
-        (1, false) => write!(writer, " -> bb{:?}", successors[0])?,
-        _ => {
-            write!(writer, " -> [")?;
-            for (i, target) in successors.iter().enumerate() {
-                if i > 0 {
-                    write!(writer, ", ")?;
-                }
-                write!(writer, "{}: bb{:?}", labels[i], target)?;
-            }
-            if show_unwind {
-                write!(writer, ", ")?;
-                fmt_unwind(writer)?;
-            }
-            write!(writer, "]")?;
-        }
-    };
-
-    writeln!(writer, ";")
-}
-
-fn pretty_terminator_head<W: Write>(writer: &mut W, terminator: &TerminatorKind) -> io::Result<()> {
-    use self::TerminatorKind::*;
-    const INDENT: &str = "        ";
-    match terminator {
-        Goto { .. } => write!(writer, "{INDENT}goto"),
-        SwitchInt { discr, .. } => {
-            write!(writer, "{INDENT}switchInt({})", pretty_operand(discr))
-        }
-        Resume => write!(writer, "{INDENT}resume"),
-        Abort => write!(writer, "{INDENT}abort"),
-        Return => write!(writer, "{INDENT}return"),
-        Unreachable => write!(writer, "{INDENT}unreachable"),
-        Drop { place, .. } => write!(writer, "{INDENT}drop({place:?})"),
-        Call { func, args, destination, .. } => {
-            write!(writer, "{INDENT}{:?} = {}(", destination, pretty_operand(func))?;
-            let mut args_iter = args.iter();
-            args_iter.next().map_or(Ok(()), |arg| write!(writer, "{}", pretty_operand(arg)))?;
-            args_iter.try_for_each(|arg| write!(writer, ", {}", pretty_operand(arg)))?;
-            write!(writer, ")")
-        }
-        Assert { cond, expected, msg, target: _, unwind: _ } => {
-            write!(writer, "{INDENT}assert(")?;
-            if !expected {
-                write!(writer, "!")?;
-            }
-            write!(writer, "{}, ", pretty_operand(cond))?;
-            pretty_assert_message(writer, msg)?;
-            write!(writer, ")")
-        }
-        InlineAsm { .. } => write!(writer, "{INDENT}InlineAsm"),
-    }
-}
-
-fn pretty_successor_labels(terminator: &TerminatorKind) -> Vec<String> {
-    use self::TerminatorKind::*;
-    match terminator {
-        Call { target: None, unwind: UnwindAction::Cleanup(_), .. }
-        | InlineAsm { destination: None, .. } => vec!["unwind".into()],
-        Resume | Abort | Return | Unreachable | Call { target: None, unwind: _, .. } => vec![],
-        Goto { .. } => vec!["".to_string()],
-        SwitchInt { targets, .. } => targets
-            .branches()
-            .map(|(val, _target)| format!("{val}"))
-            .chain(iter::once("otherwise".into()))
-            .collect(),
-        Drop { unwind: UnwindAction::Cleanup(_), .. } => vec!["return".into(), "unwind".into()],
-        Call { target: Some(_), unwind: UnwindAction::Cleanup(_), .. } => {
-            vec!["return".into(), "unwind".into()]
-        }
-        Drop { unwind: _, .. } | Call { target: Some(_), unwind: _, .. } => vec!["return".into()],
-        Assert { unwind: UnwindAction::Cleanup(_), .. } => {
-            vec!["success".into(), "unwind".into()]
-        }
-        Assert { unwind: _, .. } => vec!["success".into()],
-        InlineAsm { destination: Some(_), .. } => vec!["goto".into(), "unwind".into()],
-    }
-}
-
-fn pretty_assert_message<W: Write>(writer: &mut W, msg: &AssertMessage) -> io::Result<()> {
-    match msg {
-        AssertMessage::BoundsCheck { len, index } => {
-            let pretty_len = pretty_operand(len);
-            let pretty_index = pretty_operand(index);
-            write!(
-                writer,
-                "\"index out of bounds: the length is {{}} but the index is {{}}\", {pretty_len}, {pretty_index}"
-            )
-        }
-        AssertMessage::Overflow(BinOp::Add, l, r) => {
-            let pretty_l = pretty_operand(l);
-            let pretty_r = pretty_operand(r);
-            write!(
-                writer,
-                "\"attempt to compute `{{}} + {{}}`, which would overflow\", {pretty_l}, {pretty_r}"
-            )
-        }
-        AssertMessage::Overflow(BinOp::Sub, l, r) => {
-            let pretty_l = pretty_operand(l);
-            let pretty_r = pretty_operand(r);
-            write!(
-                writer,
-                "\"attempt to compute `{{}} - {{}}`, which would overflow\", {pretty_l}, {pretty_r}"
-            )
-        }
-        AssertMessage::Overflow(BinOp::Mul, l, r) => {
-            let pretty_l = pretty_operand(l);
-            let pretty_r = pretty_operand(r);
-            write!(
-                writer,
-                "\"attempt to compute `{{}} * {{}}`, which would overflow\", {pretty_l}, {pretty_r}"
-            )
-        }
-        AssertMessage::Overflow(BinOp::Div, l, r) => {
-            let pretty_l = pretty_operand(l);
-            let pretty_r = pretty_operand(r);
-            write!(
-                writer,
-                "\"attempt to compute `{{}} / {{}}`, which would overflow\", {pretty_l}, {pretty_r}"
-            )
-        }
-        AssertMessage::Overflow(BinOp::Rem, l, r) => {
-            let pretty_l = pretty_operand(l);
-            let pretty_r = pretty_operand(r);
-            write!(
-                writer,
-                "\"attempt to compute `{{}} % {{}}`, which would overflow\", {pretty_l}, {pretty_r}"
-            )
-        }
-        AssertMessage::Overflow(BinOp::Shr, _, r) => {
-            let pretty_r = pretty_operand(r);
-            write!(writer, "\"attempt to shift right by `{{}}`, which would overflow\", {pretty_r}")
-        }
-        AssertMessage::Overflow(BinOp::Shl, _, r) => {
-            let pretty_r = pretty_operand(r);
-            write!(writer, "\"attempt to shift left by `{{}}`, which would overflow\", {pretty_r}")
-        }
-        AssertMessage::Overflow(op, _, _) => unreachable!("`{:?}` cannot overflow", op),
-        AssertMessage::OverflowNeg(op) => {
-            let pretty_op = pretty_operand(op);
-            write!(writer, "\"attempt to negate `{{}}`, which would overflow\", {pretty_op}")
-        }
-        AssertMessage::DivisionByZero(op) => {
-            let pretty_op = pretty_operand(op);
-            write!(writer, "\"attempt to divide `{{}}` by zero\", {pretty_op}")
-        }
-        AssertMessage::RemainderByZero(op) => {
-            let pretty_op = pretty_operand(op);
-            write!(
-                writer,
-                "\"attempt to calculate the remainder of `{{}}` with a divisor of zero\", {pretty_op}"
-            )
-        }
-        AssertMessage::MisalignedPointerDereference { required, found } => {
-            let pretty_required = pretty_operand(required);
-            let pretty_found = pretty_operand(found);
-            write!(
-                writer,
-                "\"misaligned pointer dereference: address must be a multiple of {{}} but is {{}}\",{pretty_required}, {pretty_found}"
-            )
-        }
-        AssertMessage::NullPointerDereference => {
-            write!(writer, "\"null pointer dereference occurred\"")
-        }
-        AssertMessage::InvalidEnumConstruction(op) => {
-            let pretty_op = pretty_operand(op);
-            write!(writer, "\"trying to construct an enum from an invalid value {{}}\",{pretty_op}")
-        }
-        AssertMessage::ResumedAfterReturn(_)
-        | AssertMessage::ResumedAfterPanic(_)
-        | AssertMessage::ResumedAfterDrop(_) => {
-            write!(writer, "{}", msg.description().unwrap())
-        }
-    }
-}
-
-fn pretty_operand(operand: &Operand) -> String {
-    match operand {
-        Operand::Copy(copy) => {
-            format!("{copy:?}")
-        }
-        Operand::Move(mv) => {
-            format!("move {mv:?}")
-        }
-        Operand::Constant(cnst) => pretty_mir_const(&cnst.const_),
-    }
-}
-
-fn pretty_mir_const(literal: &MirConst) -> String {
-    with(|cx| cx.mir_const_pretty(literal))
-}
-
-fn pretty_ty_const(ct: &TyConst) -> String {
-    with(|cx| cx.ty_const_pretty(ct.id))
-}
-
-fn pretty_rvalue<W: Write>(writer: &mut W, rval: &Rvalue) -> io::Result<()> {
-    match rval {
-        Rvalue::AddressOf(mutability, place) => {
-            write!(writer, "&raw {} {:?}", pretty_raw_ptr_kind(*mutability), place)
-        }
-        Rvalue::Aggregate(aggregate_kind, operands) => {
-            // FIXME: Add pretty_aggregate function that returns a pretty string
-            pretty_aggregate(writer, aggregate_kind, operands)
-        }
-        Rvalue::BinaryOp(bin, op1, op2) => {
-            write!(writer, "{:?}({}, {})", bin, pretty_operand(op1), pretty_operand(op2))
-        }
-        Rvalue::Cast(_, op, ty) => {
-            write!(writer, "{} as {}", pretty_operand(op), ty)
-        }
-        Rvalue::CheckedBinaryOp(bin, op1, op2) => {
-            write!(writer, "Checked{:?}({}, {})", bin, pretty_operand(op1), pretty_operand(op2))
-        }
-        Rvalue::CopyForDeref(deref) => {
-            write!(writer, "CopyForDeref({deref:?})")
-        }
-        Rvalue::Discriminant(place) => {
-            write!(writer, "discriminant({place:?})")
-        }
-        Rvalue::Len(len) => {
-            write!(writer, "len({len:?})")
-        }
-        Rvalue::Ref(_, borrowkind, place) => {
-            let kind = match borrowkind {
-                BorrowKind::Shared => "&",
-                BorrowKind::Fake(FakeBorrowKind::Deep) => "&fake ",
-                BorrowKind::Fake(FakeBorrowKind::Shallow) => "&fake shallow ",
-                BorrowKind::Mut { .. } => "&mut ",
-            };
-            write!(writer, "{kind}{place:?}")
-        }
-        Rvalue::Repeat(op, cnst) => {
-            write!(writer, "[{}; {}]", pretty_operand(op), pretty_ty_const(cnst))
-        }
-        Rvalue::ShallowInitBox(_, _) => Ok(()),
-        Rvalue::ThreadLocalRef(item) => {
-            write!(writer, "thread_local_ref{item:?}")
-        }
-        Rvalue::NullaryOp(nul, ty) => {
-            write!(writer, "{nul:?}::<{ty}>() \" \"")
-        }
-        Rvalue::UnaryOp(un, op) => {
-            write!(writer, "{:?}({})", un, pretty_operand(op))
-        }
-        Rvalue::Use(op) => write!(writer, "{}", pretty_operand(op)),
-    }
-}
-
-fn pretty_aggregate<W: Write>(
-    writer: &mut W,
-    aggregate_kind: &AggregateKind,
-    operands: &Vec<Operand>,
-) -> io::Result<()> {
-    let suffix = match aggregate_kind {
-        AggregateKind::Array(_) => {
-            write!(writer, "[")?;
-            "]"
-        }
-        AggregateKind::Tuple => {
-            write!(writer, "(")?;
-            ")"
-        }
-        AggregateKind::Adt(def, var, _, _, _) => {
-            if def.kind() == AdtKind::Enum {
-                write!(writer, "{}::{}", def.name(), def.variant(*var).unwrap().name())?;
-            } else {
-                write!(writer, "{}", def.variant(*var).unwrap().name())?;
-            }
-            if operands.is_empty() {
-                return Ok(());
-            }
-            // FIXME: Change this once we have CtorKind in StableMIR.
-            write!(writer, "(")?;
-            ")"
-        }
-        AggregateKind::Closure(def, _) => {
-            write!(writer, "{{closure@{}}}(", def.span().diagnostic())?;
-            ")"
-        }
-        AggregateKind::Coroutine(def, _, _) => {
-            write!(writer, "{{coroutine@{}}}(", def.span().diagnostic())?;
-            ")"
-        }
-        AggregateKind::CoroutineClosure(def, _) => {
-            write!(writer, "{{coroutine-closure@{}}}(", def.span().diagnostic())?;
-            ")"
-        }
-        AggregateKind::RawPtr(ty, mutability) => {
-            write!(
-                writer,
-                "*{} {ty} from (",
-                if *mutability == Mutability::Mut { "mut" } else { "const" }
-            )?;
-            ")"
-        }
-    };
-    let mut separator = "";
-    for op in operands {
-        write!(writer, "{}{}", separator, pretty_operand(op))?;
-        separator = ", ";
-    }
-    write!(writer, "{suffix}")
-}
-
-fn pretty_mut(mutability: Mutability) -> &'static str {
-    match mutability {
-        Mutability::Not => " ",
-        Mutability::Mut => "mut ",
-    }
-}
-
-fn pretty_raw_ptr_kind(kind: RawPtrKind) -> &'static str {
-    match kind {
-        RawPtrKind::Const => "const",
-        RawPtrKind::Mut => "mut",
-        RawPtrKind::FakeForPtrMetadata => "const (fake)",
-    }
-}
diff --git a/compiler/stable_mir/src/mir/visit.rs b/compiler/stable_mir/src/mir/visit.rs
deleted file mode 100644
index 7dc99d1d1e1..00000000000
--- a/compiler/stable_mir/src/mir/visit.rs
+++ /dev/null
@@ -1,588 +0,0 @@
-//! # The Stable MIR Visitor
-//!
-//! ## Overview
-//!
-//! We currently only support an immutable visitor.
-//! The structure of this visitor is similar to the ones internal to `rustc`,
-//! and it follows the following conventions:
-//!
-//! For every mir item, the trait has a `visit_<item>` and a `super_<item>` method.
-//! - `visit_<item>`, by default, calls `super_<item>`
-//! - `super_<item>`, by default, destructures the `<item>` and calls `visit_<sub_item>` for
-//!   all sub-items that compose the original item.
-//!
-//! In order to implement a visitor, override the `visit_*` methods for the types you are
-//! interested in analyzing, and invoke (within that method call)
-//! `self.super_*` to continue to the traverse.
-//! Avoid calling `super` methods in other circumstances.
-//!
-//! For the most part, we do not destructure things external to the
-//! MIR, e.g., types, spans, etc, but simply visit them and stop.
-//! This avoids duplication with other visitors like `TypeFoldable`.
-//!
-//! ## Updating
-//!
-//! The code is written in a very deliberate style intended to minimize
-//! the chance of things being overlooked.
-//!
-//! Use pattern matching to reference fields and ensure that all
-//! matches are exhaustive.
-//!
-//! For this to work, ALL MATCHES MUST BE EXHAUSTIVE IN FIELDS AND VARIANTS.
-//! That means you never write `..` to skip over fields, nor do you write `_`
-//! to skip over variants in a `match`.
-//!
-//! The only place that `_` is acceptable is to match a field (or
-//! variant argument) that does not require visiting.
-
-use crate::mir::*;
-use crate::ty::{GenericArgs, MirConst, Region, Ty, TyConst};
-use crate::{Error, Opaque, Span};
-
-macro_rules! make_mir_visitor {
-    ($visitor_trait_name:ident, $($mutability:ident)?) => {
-        pub trait $visitor_trait_name {
-            fn visit_body(&mut self, body: &$($mutability)? Body) {
-                self.super_body(body)
-            }
-
-            fn visit_basic_block(&mut self, bb: &$($mutability)? BasicBlock) {
-                self.super_basic_block(bb)
-            }
-
-            fn visit_ret_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
-                self.super_ret_decl(local, decl)
-            }
-
-            fn visit_arg_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
-                self.super_arg_decl(local, decl)
-            }
-
-            fn visit_local_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
-                self.super_local_decl(local, decl)
-            }
-
-            fn visit_statement(&mut self, stmt: &$($mutability)? Statement, location: Location) {
-                self.super_statement(stmt, location)
-            }
-
-            fn visit_terminator(&mut self, term: &$($mutability)? Terminator, location: Location) {
-                self.super_terminator(term, location)
-            }
-
-            fn visit_span(&mut self, span: &$($mutability)? Span) {
-                self.super_span(span)
-            }
-
-            fn visit_place(&mut self, place: &$($mutability)? Place, ptx: PlaceContext, location: Location) {
-                self.super_place(place, ptx, location)
-            }
-
-            visit_place_fns!($($mutability)?);
-
-            fn visit_local(&mut self, local: &$($mutability)? Local, ptx: PlaceContext, location: Location) {
-                let _ = (local, ptx, location);
-            }
-
-            fn visit_rvalue(&mut self, rvalue: &$($mutability)? Rvalue, location: Location) {
-                self.super_rvalue(rvalue, location)
-            }
-
-            fn visit_operand(&mut self, operand: &$($mutability)? Operand, location: Location) {
-                self.super_operand(operand, location)
-            }
-
-            fn visit_user_type_projection(&mut self, projection: &$($mutability)? UserTypeProjection) {
-                self.super_user_type_projection(projection)
-            }
-
-            fn visit_ty(&mut self, ty: &$($mutability)? Ty, location: Location) {
-                let _ = location;
-                self.super_ty(ty)
-            }
-
-            fn visit_const_operand(&mut self, constant: &$($mutability)? ConstOperand, location: Location) {
-                self.super_const_operand(constant, location)
-            }
-
-            fn visit_mir_const(&mut self, constant: &$($mutability)? MirConst, location: Location) {
-                self.super_mir_const(constant, location)
-            }
-
-            fn visit_ty_const(&mut self, constant: &$($mutability)? TyConst, location: Location) {
-                let _ = location;
-                self.super_ty_const(constant)
-            }
-
-            fn visit_region(&mut self, region: &$($mutability)? Region, location: Location) {
-                let _ = location;
-                self.super_region(region)
-            }
-
-            fn visit_args(&mut self, args: &$($mutability)? GenericArgs, location: Location) {
-                let _ = location;
-                self.super_args(args)
-            }
-
-            fn visit_assert_msg(&mut self, msg: &$($mutability)? AssertMessage, location: Location) {
-                self.super_assert_msg(msg, location)
-            }
-
-            fn visit_var_debug_info(&mut self, var_debug_info: &$($mutability)? VarDebugInfo) {
-                self.super_var_debug_info(var_debug_info);
-            }
-
-            fn super_body(&mut self, body: &$($mutability)? Body) {
-                super_body!(self, body, $($mutability)?);
-            }
-
-            fn super_basic_block(&mut self, bb: &$($mutability)? BasicBlock) {
-                let BasicBlock { statements, terminator } = bb;
-                for stmt in statements {
-                    self.visit_statement(stmt, Location(stmt.span));
-                }
-                self.visit_terminator(terminator, Location(terminator.span));
-            }
-
-            fn super_local_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
-                let _ = local;
-                let LocalDecl { ty, span, .. } = decl;
-                self.visit_ty(ty, Location(*span));
-            }
-
-            fn super_ret_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
-                self.super_local_decl(local, decl)
-            }
-
-            fn super_arg_decl(&mut self, local: Local, decl: &$($mutability)? LocalDecl) {
-                self.super_local_decl(local, decl)
-            }
-
-            fn super_statement(&mut self, stmt: &$($mutability)? Statement, location: Location) {
-                let Statement { kind, span } = stmt;
-                self.visit_span(span);
-                match kind {
-                    StatementKind::Assign(place, rvalue) => {
-                        self.visit_place(place, PlaceContext::MUTATING, location);
-                        self.visit_rvalue(rvalue, location);
-                    }
-                    StatementKind::FakeRead(_, place) | StatementKind::PlaceMention(place) => {
-                        self.visit_place(place, PlaceContext::NON_MUTATING, location);
-                    }
-                    StatementKind::SetDiscriminant { place, .. }
-                    | StatementKind::Deinit(place)
-                    | StatementKind::Retag(_, place) => {
-                        self.visit_place(place, PlaceContext::MUTATING, location);
-                    }
-                    StatementKind::StorageLive(local) | StatementKind::StorageDead(local) => {
-                        self.visit_local(local, PlaceContext::NON_USE, location);
-                    }
-                    StatementKind::AscribeUserType { place, projections, variance: _ } => {
-                        self.visit_place(place, PlaceContext::NON_USE, location);
-                        self.visit_user_type_projection(projections);
-                    }
-                    StatementKind::Coverage(coverage) => visit_opaque(coverage),
-                    StatementKind::Intrinsic(intrisic) => match intrisic {
-                        NonDivergingIntrinsic::Assume(operand) => {
-                            self.visit_operand(operand, location);
-                        }
-                        NonDivergingIntrinsic::CopyNonOverlapping(CopyNonOverlapping {
-                            src,
-                            dst,
-                            count,
-                        }) => {
-                            self.visit_operand(src, location);
-                            self.visit_operand(dst, location);
-                            self.visit_operand(count, location);
-                        }
-                    },
-                    StatementKind::ConstEvalCounter | StatementKind::Nop => {}
-                }
-            }
-
-            fn super_terminator(&mut self, term: &$($mutability)? Terminator, location: Location) {
-                let Terminator { kind, span } = term;
-                self.visit_span(span);
-                match kind {
-                    TerminatorKind::Goto { .. }
-                    | TerminatorKind::Resume
-                    | TerminatorKind::Abort
-                    | TerminatorKind::Unreachable => {}
-                    TerminatorKind::Assert { cond, expected: _, msg, target: _, unwind: _ } => {
-                        self.visit_operand(cond, location);
-                        self.visit_assert_msg(msg, location);
-                    }
-                    TerminatorKind::Drop { place, target: _, unwind: _ } => {
-                        self.visit_place(place, PlaceContext::MUTATING, location);
-                    }
-                    TerminatorKind::Call { func, args, destination, target: _, unwind: _ } => {
-                        self.visit_operand(func, location);
-                        for arg in args {
-                            self.visit_operand(arg, location);
-                        }
-                        self.visit_place(destination, PlaceContext::MUTATING, location);
-                    }
-                    TerminatorKind::InlineAsm { operands, .. } => {
-                        for op in operands {
-                            let InlineAsmOperand { in_value, out_place, raw_rpr: _ } = op;
-                            if let Some(input) = in_value {
-                                self.visit_operand(input, location);
-                            }
-                            if let Some(output) = out_place {
-                                self.visit_place(output, PlaceContext::MUTATING, location);
-                            }
-                        }
-                    }
-                    TerminatorKind::Return => {
-                        let $($mutability)? local = RETURN_LOCAL;
-                        self.visit_local(&$($mutability)? local, PlaceContext::NON_MUTATING, location);
-                    }
-                    TerminatorKind::SwitchInt { discr, targets: _ } => {
-                        self.visit_operand(discr, location);
-                    }
-                }
-            }
-
-            fn super_span(&mut self, span: &$($mutability)? Span) {
-                let _ = span;
-            }
-
-            fn super_rvalue(&mut self, rvalue: &$($mutability)? Rvalue, location: Location) {
-                match rvalue {
-                    Rvalue::AddressOf(mutability, place) => {
-                        let pcx = PlaceContext { is_mut: *mutability == RawPtrKind::Mut };
-                        self.visit_place(place, pcx, location);
-                    }
-                    Rvalue::Aggregate(_, operands) => {
-                        for op in operands {
-                            self.visit_operand(op, location);
-                        }
-                    }
-                    Rvalue::BinaryOp(_, lhs, rhs) | Rvalue::CheckedBinaryOp(_, lhs, rhs) => {
-                        self.visit_operand(lhs, location);
-                        self.visit_operand(rhs, location);
-                    }
-                    Rvalue::Cast(_, op, ty) => {
-                        self.visit_operand(op, location);
-                        self.visit_ty(ty, location);
-                    }
-                    Rvalue::CopyForDeref(place) | Rvalue::Discriminant(place) | Rvalue::Len(place) => {
-                        self.visit_place(place, PlaceContext::NON_MUTATING, location);
-                    }
-                    Rvalue::Ref(region, kind, place) => {
-                        self.visit_region(region, location);
-                        let pcx = PlaceContext { is_mut: matches!(kind, BorrowKind::Mut { .. }) };
-                        self.visit_place(place, pcx, location);
-                    }
-                    Rvalue::Repeat(op, constant) => {
-                        self.visit_operand(op, location);
-                        self.visit_ty_const(constant, location);
-                    }
-                    Rvalue::ShallowInitBox(op, ty) => {
-                        self.visit_ty(ty, location);
-                        self.visit_operand(op, location)
-                    }
-                    Rvalue::ThreadLocalRef(_) => {}
-                    Rvalue::NullaryOp(_, ty) => {
-                        self.visit_ty(ty, location);
-                    }
-                    Rvalue::UnaryOp(_, op) | Rvalue::Use(op) => {
-                        self.visit_operand(op, location);
-                    }
-                }
-            }
-
-            fn super_operand(&mut self, operand: &$($mutability)? Operand, location: Location) {
-                match operand {
-                    Operand::Copy(place) | Operand::Move(place) => {
-                        self.visit_place(place, PlaceContext::NON_MUTATING, location)
-                    }
-                    Operand::Constant(constant) => {
-                        self.visit_const_operand(constant, location);
-                    }
-                }
-            }
-
-            fn super_user_type_projection(&mut self, projection: &$($mutability)? UserTypeProjection) {
-                // This is a no-op on mir::Visitor.
-                let _ = projection;
-            }
-
-            fn super_ty(&mut self, ty: &$($mutability)? Ty) {
-                let _ = ty;
-            }
-
-            fn super_const_operand(&mut self, constant: &$($mutability)? ConstOperand, location: Location) {
-                let ConstOperand { span, user_ty: _, const_ } = constant;
-                self.visit_span(span);
-                self.visit_mir_const(const_, location);
-            }
-
-            fn super_mir_const(&mut self, constant: &$($mutability)? MirConst, location: Location) {
-                let MirConst { kind: _, ty, id: _ } = constant;
-                self.visit_ty(ty, location);
-            }
-
-            fn super_ty_const(&mut self, constant: &$($mutability)? TyConst) {
-                let _ = constant;
-            }
-
-            fn super_region(&mut self, region: &$($mutability)? Region) {
-                let _ = region;
-            }
-
-            fn super_args(&mut self, args: &$($mutability)? GenericArgs) {
-                let _ = args;
-            }
-
-            fn super_var_debug_info(&mut self, var_debug_info: &$($mutability)? VarDebugInfo) {
-                let VarDebugInfo { source_info, composite, value, name: _, argument_index: _ } =
-                    var_debug_info;
-                self.visit_span(&$($mutability)? source_info.span);
-                let location = Location(source_info.span);
-                if let Some(composite) = composite {
-                    self.visit_ty(&$($mutability)? composite.ty, location);
-                }
-                match value {
-                    VarDebugInfoContents::Place(place) => {
-                        self.visit_place(place, PlaceContext::NON_USE, location);
-                    }
-                    VarDebugInfoContents::Const(constant) => {
-                        self.visit_mir_const(&$($mutability)? constant.const_, location);
-                    }
-                }
-            }
-
-            fn super_assert_msg(&mut self, msg: &$($mutability)? AssertMessage, location: Location) {
-                match msg {
-                    AssertMessage::BoundsCheck { len, index } => {
-                        self.visit_operand(len, location);
-                        self.visit_operand(index, location);
-                    }
-                    AssertMessage::Overflow(_, left, right) => {
-                        self.visit_operand(left, location);
-                        self.visit_operand(right, location);
-                    }
-                    AssertMessage::OverflowNeg(op)
-                    | AssertMessage::DivisionByZero(op)
-                    | AssertMessage::RemainderByZero(op)
-                    | AssertMessage::InvalidEnumConstruction(op) => {
-                        self.visit_operand(op, location);
-                    }
-                    AssertMessage::ResumedAfterReturn(_)
-                    | AssertMessage::ResumedAfterPanic(_)
-                    | AssertMessage::NullPointerDereference
-                    | AssertMessage::ResumedAfterDrop(_) => {
-                        //nothing to visit
-                    }
-                    AssertMessage::MisalignedPointerDereference { required, found } => {
-                        self.visit_operand(required, location);
-                        self.visit_operand(found, location);
-                    }
-                }
-            }
-        }
-    };
-}
-
-macro_rules! super_body {
-    ($self:ident, $body:ident, mut) => {
-        for bb in $body.blocks.iter_mut() {
-            $self.visit_basic_block(bb);
-        }
-
-        $self.visit_ret_decl(RETURN_LOCAL, $body.ret_local_mut());
-
-        for (idx, arg) in $body.arg_locals_mut().iter_mut().enumerate() {
-            $self.visit_arg_decl(idx + 1, arg)
-        }
-
-        let local_start = $body.arg_count + 1;
-        for (idx, arg) in $body.inner_locals_mut().iter_mut().enumerate() {
-            $self.visit_local_decl(idx + local_start, arg)
-        }
-
-        for info in $body.var_debug_info.iter_mut() {
-            $self.visit_var_debug_info(info);
-        }
-
-        $self.visit_span(&mut $body.span)
-    };
-
-    ($self:ident, $body:ident, ) => {
-        let Body { blocks, locals: _, arg_count, var_debug_info, spread_arg: _, span } = $body;
-
-        for bb in blocks {
-            $self.visit_basic_block(bb);
-        }
-
-        $self.visit_ret_decl(RETURN_LOCAL, $body.ret_local());
-
-        for (idx, arg) in $body.arg_locals().iter().enumerate() {
-            $self.visit_arg_decl(idx + 1, arg)
-        }
-
-        let local_start = arg_count + 1;
-        for (idx, arg) in $body.inner_locals().iter().enumerate() {
-            $self.visit_local_decl(idx + local_start, arg)
-        }
-
-        for info in var_debug_info.iter() {
-            $self.visit_var_debug_info(info);
-        }
-
-        $self.visit_span(span)
-    };
-}
-
-macro_rules! visit_place_fns {
-    (mut) => {
-        fn super_place(&mut self, place: &mut Place, ptx: PlaceContext, location: Location) {
-            self.visit_local(&mut place.local, ptx, location);
-
-            for elem in place.projection.iter_mut() {
-                self.visit_projection_elem(elem, ptx, location);
-            }
-        }
-
-        // We don't have to replicate the `process_projection()` like we did in
-        // `rustc_middle::mir::visit.rs` here because the `projection` field in `Place`
-        // of Stable-MIR is not an immutable borrow, unlike in `Place` of MIR.
-        fn visit_projection_elem(
-            &mut self,
-            elem: &mut ProjectionElem,
-            ptx: PlaceContext,
-            location: Location,
-        ) {
-            self.super_projection_elem(elem, ptx, location)
-        }
-
-        fn super_projection_elem(
-            &mut self,
-            elem: &mut ProjectionElem,
-            ptx: PlaceContext,
-            location: Location,
-        ) {
-            match elem {
-                ProjectionElem::Deref => {}
-                ProjectionElem::Field(_idx, ty) => self.visit_ty(ty, location),
-                ProjectionElem::Index(local) => self.visit_local(local, ptx, location),
-                ProjectionElem::ConstantIndex { offset: _, min_length: _, from_end: _ } => {}
-                ProjectionElem::Subslice { from: _, to: _, from_end: _ } => {}
-                ProjectionElem::Downcast(_idx) => {}
-                ProjectionElem::OpaqueCast(ty) => self.visit_ty(ty, location),
-                ProjectionElem::Subtype(ty) => self.visit_ty(ty, location),
-            }
-        }
-    };
-
-    () => {
-        fn super_place(&mut self, place: &Place, ptx: PlaceContext, location: Location) {
-            self.visit_local(&place.local, ptx, location);
-
-            for (idx, elem) in place.projection.iter().enumerate() {
-                let place_ref =
-                    PlaceRef { local: place.local, projection: &place.projection[..idx] };
-                self.visit_projection_elem(place_ref, elem, ptx, location);
-            }
-        }
-
-        fn visit_projection_elem<'a>(
-            &mut self,
-            place_ref: PlaceRef<'a>,
-            elem: &ProjectionElem,
-            ptx: PlaceContext,
-            location: Location,
-        ) {
-            let _ = place_ref;
-            self.super_projection_elem(elem, ptx, location);
-        }
-
-        fn super_projection_elem(
-            &mut self,
-            elem: &ProjectionElem,
-            ptx: PlaceContext,
-            location: Location,
-        ) {
-            match elem {
-                ProjectionElem::Deref => {}
-                ProjectionElem::Field(_idx, ty) => self.visit_ty(ty, location),
-                ProjectionElem::Index(local) => self.visit_local(local, ptx, location),
-                ProjectionElem::ConstantIndex { offset: _, min_length: _, from_end: _ } => {}
-                ProjectionElem::Subslice { from: _, to: _, from_end: _ } => {}
-                ProjectionElem::Downcast(_idx) => {}
-                ProjectionElem::OpaqueCast(ty) => self.visit_ty(ty, location),
-                ProjectionElem::Subtype(ty) => self.visit_ty(ty, location),
-            }
-        }
-    };
-}
-
-make_mir_visitor!(MirVisitor,);
-make_mir_visitor!(MutMirVisitor, mut);
-
-/// This function is a no-op that gets used to ensure this visitor is kept up-to-date.
-///
-/// The idea is that whenever we replace an Opaque type by a real type, the compiler will fail
-/// when trying to invoke `visit_opaque`.
-///
-/// If you are here because your compilation is broken, replace the failing call to `visit_opaque()`
-/// by a `visit_<CONSTRUCT>` for your construct.
-fn visit_opaque(_: &Opaque) {}
-
-/// The location of a statement / terminator in the code and the CFG.
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub struct Location(Span);
-
-impl Location {
-    pub fn span(&self) -> Span {
-        self.0
-    }
-}
-
-/// Location of the statement at the given index for a given basic block. Assumes that `stmt_idx`
-/// and `bb_idx` are valid for a given body.
-pub fn statement_location(body: &Body, bb_idx: &BasicBlockIdx, stmt_idx: usize) -> Location {
-    let bb = &body.blocks[*bb_idx];
-    let stmt = &bb.statements[stmt_idx];
-    Location(stmt.span)
-}
-
-/// Location of the terminator for a given basic block. Assumes that `bb_idx` is valid for a given
-/// body.
-pub fn terminator_location(body: &Body, bb_idx: &BasicBlockIdx) -> Location {
-    let bb = &body.blocks[*bb_idx];
-    let terminator = &bb.terminator;
-    Location(terminator.span)
-}
-
-/// Reference to a place used to represent a partial projection.
-pub struct PlaceRef<'a> {
-    pub local: Local,
-    pub projection: &'a [ProjectionElem],
-}
-
-impl PlaceRef<'_> {
-    /// Get the type of this place.
-    pub fn ty(&self, locals: &[LocalDecl]) -> Result<Ty, Error> {
-        self.projection.iter().try_fold(locals[self.local].ty, |place_ty, elem| elem.ty(place_ty))
-    }
-}
-
-/// Information about a place's usage.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct PlaceContext {
-    /// Whether the access is mutable or not. Keep this private so we can increment the type in a
-    /// backward compatible manner.
-    is_mut: bool,
-}
-
-impl PlaceContext {
-    const MUTATING: Self = PlaceContext { is_mut: true };
-    const NON_MUTATING: Self = PlaceContext { is_mut: false };
-    const NON_USE: Self = PlaceContext { is_mut: false };
-
-    pub fn is_mutating(&self) -> bool {
-        self.is_mut
-    }
-}
diff --git a/compiler/stable_mir/src/rustc_internal/mod.rs b/compiler/stable_mir/src/rustc_internal/mod.rs
deleted file mode 100644
index c1ed03ade75..00000000000
--- a/compiler/stable_mir/src/rustc_internal/mod.rs
+++ /dev/null
@@ -1,270 +0,0 @@
-//! Module that implements the bridge between Stable MIR and internal compiler MIR.
-//!
-//! For that, we define APIs that will temporarily be public to 3P that exposes rustc internal APIs
-//! until stable MIR is complete.
-
-use std::cell::{Cell, RefCell};
-
-use rustc_middle::ty::TyCtxt;
-use rustc_smir::context::SmirCtxt;
-use rustc_smir::{Bridge, SmirContainer, Tables};
-use rustc_span::def_id::CrateNum;
-use scoped_tls::scoped_thread_local;
-
-use crate::Error;
-use crate::unstable::{RustcInternal, Stable};
-
-pub mod pretty;
-
-/// Convert an internal Rust compiler item into its stable counterpart, if one exists.
-///
-/// # Warning
-///
-/// This function is unstable, and its behavior may change at any point.
-/// E.g.: Items that were previously supported, may no longer be supported, or its translation may
-/// change.
-///
-/// # Panics
-///
-/// This function will panic if StableMIR has not been properly initialized.
-pub fn stable<'tcx, S: Stable<'tcx>>(item: S) -> S::T {
-    with_container(|tables, cx| item.stable(tables, cx))
-}
-
-/// Convert a stable item into its internal Rust compiler counterpart, if one exists.
-///
-/// # Warning
-///
-/// This function is unstable, and it's behavior may change at any point.
-/// Not every stable item can be converted to an internal one.
-/// Furthermore, items that were previously supported, may no longer be supported in newer versions.
-///
-/// # Panics
-///
-/// This function will panic if StableMIR has not been properly initialized.
-pub fn internal<'tcx, S>(tcx: TyCtxt<'tcx>, item: S) -> S::T<'tcx>
-where
-    S: RustcInternal,
-{
-    // The tcx argument ensures that the item won't outlive the type context.
-    // See https://github.com/rust-lang/rust/pull/120128/commits/9aace6723572438a94378451793ca37deb768e72
-    // for more details.
-    with_container(|tables, _| item.internal(tables, tcx))
-}
-
-pub fn crate_num(item: &crate::Crate) -> CrateNum {
-    item.id.into()
-}
-
-// A thread local variable that stores a pointer to the tables mapping between TyCtxt
-// datastructures and stable MIR datastructures
-scoped_thread_local! (static TLV: Cell<*const ()>);
-
-pub(crate) fn init<'tcx, F, T, B: Bridge>(container: &SmirContainer<'tcx, B>, f: F) -> T
-where
-    F: FnOnce() -> T,
-{
-    assert!(!TLV.is_set());
-    let ptr = container as *const _ as *const ();
-    TLV.set(&Cell::new(ptr), || f())
-}
-
-/// Loads the current context and calls a function with it.
-/// Do not nest these, as that will ICE.
-pub(crate) fn with_container<R, B: Bridge>(
-    f: impl for<'tcx> FnOnce(&mut Tables<'tcx, B>, &SmirCtxt<'tcx, B>) -> R,
-) -> R {
-    assert!(TLV.is_set());
-    TLV.with(|tlv| {
-        let ptr = tlv.get();
-        assert!(!ptr.is_null());
-        let container = ptr as *const SmirContainer<'_, B>;
-        let mut tables = unsafe { (*container).tables.borrow_mut() };
-        let cx = unsafe { (*container).cx.borrow() };
-        f(&mut *tables, &*cx)
-    })
-}
-
-pub fn run<F, T>(tcx: TyCtxt<'_>, f: F) -> Result<T, Error>
-where
-    F: FnOnce() -> T,
-{
-    let smir_cx = RefCell::new(SmirCtxt::new(tcx));
-    let container = SmirContainer { tables: RefCell::new(Tables::default()), cx: smir_cx };
-
-    crate::compiler_interface::run(&container, || init(&container, f))
-}
-
-/// Instantiate and run the compiler with the provided arguments and callback.
-///
-/// The callback will be invoked after the compiler ran all its analyses, but before code generation.
-/// Note that this macro accepts two different formats for the callback:
-/// 1. An ident that resolves to a function that accepts no argument and returns `ControlFlow<B, C>`
-/// ```ignore(needs-extern-crate)
-/// # extern crate rustc_driver;
-/// # extern crate rustc_interface;
-/// # extern crate rustc_middle;
-/// # #[macro_use]
-/// # extern crate stable_mir;
-/// #
-/// # fn main() {
-/// #   use std::ops::ControlFlow;
-/// #   use stable_mir::CompilerError;
-///     fn analyze_code() -> ControlFlow<(), ()> {
-///         // Your code goes in here.
-/// #       ControlFlow::Continue(())
-///     }
-/// #   let args = &["--verbose".to_string()];
-///     let result = run!(args, analyze_code);
-/// #   assert_eq!(result, Err(CompilerError::Skipped))
-/// # }
-/// ```
-/// 2. A closure expression:
-/// ```ignore(needs-extern-crate)
-/// # extern crate rustc_driver;
-/// # extern crate rustc_interface;
-/// # extern crate rustc_middle;
-/// # #[macro_use]
-/// # extern crate stable_mir;
-/// #
-/// # fn main() {
-/// #   use std::ops::ControlFlow;
-/// #   use stable_mir::CompilerError;
-///     fn analyze_code(extra_args: Vec<String>) -> ControlFlow<(), ()> {
-/// #       let _ = extra_args;
-///         // Your code goes in here.
-/// #       ControlFlow::Continue(())
-///     }
-/// #   let args = &["--verbose".to_string()];
-/// #   let extra_args = vec![];
-///     let result = run!(args, || analyze_code(extra_args));
-/// #   assert_eq!(result, Err(CompilerError::Skipped))
-/// # }
-/// ```
-#[macro_export]
-macro_rules! run {
-    ($args:expr, $callback_fn:ident) => {
-        run_driver!($args, || $callback_fn())
-    };
-    ($args:expr, $callback:expr) => {
-        run_driver!($args, $callback)
-    };
-}
-
-/// Instantiate and run the compiler with the provided arguments and callback.
-///
-/// This is similar to `run` but it invokes the callback with the compiler's `TyCtxt`,
-/// which can be used to invoke internal APIs.
-#[macro_export]
-macro_rules! run_with_tcx {
-    ($args:expr, $callback_fn:ident) => {
-        run_driver!($args, |tcx| $callback_fn(tcx), with_tcx)
-    };
-    ($args:expr, $callback:expr) => {
-        run_driver!($args, $callback, with_tcx)
-    };
-}
-
-/// Optionally include an ident. This is needed due to macro hygiene.
-#[macro_export]
-#[doc(hidden)]
-macro_rules! optional {
-    (with_tcx $ident:ident) => {
-        $ident
-    };
-}
-
-/// Prefer using [run!] and [run_with_tcx] instead.
-///
-/// This macro implements the instantiation of a StableMIR driver, and it will invoke
-/// the given callback after the compiler analyses.
-///
-/// The third argument determines whether the callback requires `tcx` as an argument.
-#[macro_export]
-#[doc(hidden)]
-macro_rules! run_driver {
-    ($args:expr, $callback:expr $(, $with_tcx:ident)?) => {{
-        use rustc_driver::{Callbacks, Compilation, run_compiler};
-        use rustc_middle::ty::TyCtxt;
-        use rustc_interface::interface;
-        use stable_mir::rustc_internal;
-        use stable_mir::CompilerError;
-        use std::ops::ControlFlow;
-
-        pub struct StableMir<B = (), C = (), F = fn($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C>>
-        where
-            B: Send,
-            C: Send,
-            F: FnOnce($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
-        {
-            callback: Option<F>,
-            result: Option<ControlFlow<B, C>>,
-        }
-
-        impl<B, C, F> StableMir<B, C, F>
-        where
-            B: Send,
-            C: Send,
-            F: FnOnce($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
-        {
-            /// Creates a new `StableMir` instance, with given test_function and arguments.
-            pub fn new(callback: F) -> Self {
-                StableMir { callback: Some(callback), result: None }
-            }
-
-            /// Runs the compiler against given target and tests it with `test_function`
-            pub fn run(&mut self, args: &[String]) -> Result<C, CompilerError<B>> {
-                let compiler_result = rustc_driver::catch_fatal_errors(|| -> interface::Result::<()> {
-                    run_compiler(&args, self);
-                    Ok(())
-                });
-                match (compiler_result, self.result.take()) {
-                    (Ok(Ok(())), Some(ControlFlow::Continue(value))) => Ok(value),
-                    (Ok(Ok(())), Some(ControlFlow::Break(value))) => {
-                        Err(CompilerError::Interrupted(value))
-                    }
-                    (Ok(Ok(_)), None) => Err(CompilerError::Skipped),
-                    // Two cases here:
-                    // - `run` finished normally and returned `Err`
-                    // - `run` panicked with `FatalErr`
-                    // You might think that normal compile errors cause the former, and
-                    // ICEs cause the latter. But some normal compiler errors also cause
-                    // the latter. So we can't meaningfully distinguish them, and group
-                    // them together.
-                    (Ok(Err(_)), _) | (Err(_), _) => Err(CompilerError::Failed),
-                }
-            }
-        }
-
-        impl<B, C, F> Callbacks for StableMir<B, C, F>
-        where
-            B: Send,
-            C: Send,
-            F: FnOnce($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
-        {
-            /// Called after analysis. Return value instructs the compiler whether to
-            /// continue the compilation afterwards (defaults to `Compilation::Continue`)
-            fn after_analysis<'tcx>(
-                &mut self,
-                _compiler: &interface::Compiler,
-                tcx: TyCtxt<'tcx>,
-            ) -> Compilation {
-                if let Some(callback) = self.callback.take() {
-                    rustc_internal::run(tcx, || {
-                        self.result = Some(callback($(optional!($with_tcx tcx))?));
-                    })
-                    .unwrap();
-                    if self.result.as_ref().is_some_and(|val| val.is_continue()) {
-                        Compilation::Continue
-                    } else {
-                        Compilation::Stop
-                    }
-                } else {
-                    Compilation::Continue
-                }
-            }
-        }
-
-        StableMir::new($callback).run($args)
-    }};
-}
diff --git a/compiler/stable_mir/src/rustc_internal/pretty.rs b/compiler/stable_mir/src/rustc_internal/pretty.rs
deleted file mode 100644
index 28c5280fe04..00000000000
--- a/compiler/stable_mir/src/rustc_internal/pretty.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use std::io;
-
-use rustc_middle::ty::TyCtxt;
-
-use super::run;
-
-pub fn write_smir_pretty<'tcx, W: io::Write>(tcx: TyCtxt<'tcx>, w: &mut W) -> io::Result<()> {
-    writeln!(
-        w,
-        "// WARNING: This is highly experimental output it's intended for stable-mir developers only."
-    )?;
-    writeln!(
-        w,
-        "// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir."
-    )?;
-    let _ = run(tcx, || {
-        let items = crate::all_local_items();
-        let _ = items.iter().map(|item| -> io::Result<()> { item.emit_mir(w) }).collect::<Vec<_>>();
-    });
-    Ok(())
-}
diff --git a/compiler/stable_mir/src/target.rs b/compiler/stable_mir/src/target.rs
deleted file mode 100644
index 32c3a2a9122..00000000000
--- a/compiler/stable_mir/src/target.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//! Provide information about the machine that this is being compiled into.
-
-use serde::Serialize;
-
-use crate::compiler_interface::with;
-
-/// The properties of the target machine being compiled into.
-#[derive(Clone, PartialEq, Eq, Serialize)]
-pub struct MachineInfo {
-    pub endian: Endian,
-    pub pointer_width: MachineSize,
-}
-
-impl MachineInfo {
-    pub fn target() -> MachineInfo {
-        with(|cx| cx.target_info())
-    }
-
-    pub fn target_endianness() -> Endian {
-        with(|cx| cx.target_info().endian)
-    }
-
-    pub fn target_pointer_width() -> MachineSize {
-        with(|cx| cx.target_info().pointer_width)
-    }
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, Serialize)]
-pub enum Endian {
-    Little,
-    Big,
-}
-
-/// Represent the size of a component.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
-pub struct MachineSize {
-    num_bits: usize,
-}
-
-impl MachineSize {
-    #[inline(always)]
-    pub fn bytes(self) -> usize {
-        self.num_bits / 8
-    }
-
-    #[inline(always)]
-    pub fn bits(self) -> usize {
-        self.num_bits
-    }
-
-    #[inline(always)]
-    pub fn from_bits(num_bits: usize) -> MachineSize {
-        MachineSize { num_bits }
-    }
-
-    #[inline]
-    pub fn unsigned_int_max(self) -> Option<u128> {
-        (self.num_bits <= 128).then(|| u128::MAX >> (128 - self.bits()))
-    }
-}
diff --git a/compiler/stable_mir/src/ty.rs b/compiler/stable_mir/src/ty.rs
deleted file mode 100644
index 87d31cf9713..00000000000
--- a/compiler/stable_mir/src/ty.rs
+++ /dev/null
@@ -1,1655 +0,0 @@
-use std::fmt::{self, Debug, Display, Formatter};
-use std::ops::Range;
-
-use serde::Serialize;
-
-use super::abi::ReprOptions;
-use super::mir::{Body, Mutability, Safety};
-use super::{DefId, Error, Symbol, with};
-use crate::abi::{FnAbi, Layout};
-use crate::crate_def::{CrateDef, CrateDefItems, CrateDefType};
-use crate::mir::alloc::{AllocId, read_target_int, read_target_uint};
-use crate::mir::mono::StaticDef;
-use crate::target::MachineInfo;
-use crate::{Filename, IndexedVal, Opaque};
-
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Serialize)]
-pub struct Ty(usize);
-
-impl Debug for Ty {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Ty").field("id", &self.0).field("kind", &self.kind()).finish()
-    }
-}
-
-/// Constructors for `Ty`.
-impl Ty {
-    /// Create a new type from a given kind.
-    pub fn from_rigid_kind(kind: RigidTy) -> Ty {
-        with(|cx| cx.new_rigid_ty(kind))
-    }
-
-    /// Create a new array type.
-    pub fn try_new_array(elem_ty: Ty, size: u64) -> Result<Ty, Error> {
-        Ok(Ty::from_rigid_kind(RigidTy::Array(elem_ty, TyConst::try_from_target_usize(size)?)))
-    }
-
-    /// Create a new array type from Const length.
-    pub fn new_array_with_const_len(elem_ty: Ty, len: TyConst) -> Ty {
-        Ty::from_rigid_kind(RigidTy::Array(elem_ty, len))
-    }
-
-    /// Create a new pointer type.
-    pub fn new_ptr(pointee_ty: Ty, mutability: Mutability) -> Ty {
-        Ty::from_rigid_kind(RigidTy::RawPtr(pointee_ty, mutability))
-    }
-
-    /// Create a new reference type.
-    pub fn new_ref(reg: Region, pointee_ty: Ty, mutability: Mutability) -> Ty {
-        Ty::from_rigid_kind(RigidTy::Ref(reg, pointee_ty, mutability))
-    }
-
-    /// Create a new pointer type.
-    pub fn new_tuple(tys: &[Ty]) -> Ty {
-        Ty::from_rigid_kind(RigidTy::Tuple(Vec::from(tys)))
-    }
-
-    /// Create a new closure type.
-    pub fn new_closure(def: ClosureDef, args: GenericArgs) -> Ty {
-        Ty::from_rigid_kind(RigidTy::Closure(def, args))
-    }
-
-    /// Create a new coroutine type.
-    pub fn new_coroutine(def: CoroutineDef, args: GenericArgs, mov: Movability) -> Ty {
-        Ty::from_rigid_kind(RigidTy::Coroutine(def, args, mov))
-    }
-
-    /// Create a new closure type.
-    pub fn new_coroutine_closure(def: CoroutineClosureDef, args: GenericArgs) -> Ty {
-        Ty::from_rigid_kind(RigidTy::CoroutineClosure(def, args))
-    }
-
-    /// Create a new box type that represents `Box<T>`, for the given inner type `T`.
-    pub fn new_box(inner_ty: Ty) -> Ty {
-        with(|cx| cx.new_box_ty(inner_ty))
-    }
-
-    /// Create a type representing `usize`.
-    pub fn usize_ty() -> Ty {
-        Ty::from_rigid_kind(RigidTy::Uint(UintTy::Usize))
-    }
-
-    /// Create a type representing `bool`.
-    pub fn bool_ty() -> Ty {
-        Ty::from_rigid_kind(RigidTy::Bool)
-    }
-
-    /// Create a type representing a signed integer.
-    pub fn signed_ty(inner: IntTy) -> Ty {
-        Ty::from_rigid_kind(RigidTy::Int(inner))
-    }
-
-    /// Create a type representing an unsigned integer.
-    pub fn unsigned_ty(inner: UintTy) -> Ty {
-        Ty::from_rigid_kind(RigidTy::Uint(inner))
-    }
-
-    /// Get a type layout.
-    pub fn layout(self) -> Result<Layout, Error> {
-        with(|cx| cx.ty_layout(self))
-    }
-}
-
-impl Ty {
-    pub fn kind(&self) -> TyKind {
-        with(|context| context.ty_kind(*self))
-    }
-}
-
-/// Represents a pattern in the type system
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum Pattern {
-    Range { start: Option<TyConst>, end: Option<TyConst>, include_end: bool },
-}
-
-/// Represents a constant in the type system
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct TyConst {
-    pub(crate) kind: TyConstKind,
-    pub id: TyConstId,
-}
-
-impl TyConst {
-    pub fn new(kind: TyConstKind, id: TyConstId) -> TyConst {
-        Self { kind, id }
-    }
-
-    /// Retrieve the constant kind.
-    pub fn kind(&self) -> &TyConstKind {
-        &self.kind
-    }
-
-    /// Creates an interned usize constant.
-    pub fn try_from_target_usize(val: u64) -> Result<Self, Error> {
-        with(|cx| cx.try_new_ty_const_uint(val.into(), UintTy::Usize))
-    }
-
-    /// Try to evaluate to a target `usize`.
-    pub fn eval_target_usize(&self) -> Result<u64, Error> {
-        with(|cx| cx.eval_target_usize_ty(self))
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum TyConstKind {
-    Param(ParamConst),
-    Bound(DebruijnIndex, BoundVar),
-    Unevaluated(ConstDef, GenericArgs),
-
-    // FIXME: These should be a valtree
-    Value(Ty, Allocation),
-    ZSTValue(Ty),
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct TyConstId(usize);
-
-/// Represents a constant in MIR
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct MirConst {
-    /// The constant kind.
-    pub(crate) kind: ConstantKind,
-    /// The constant type.
-    pub(crate) ty: Ty,
-    /// Used for internal tracking of the internal constant.
-    pub id: MirConstId,
-}
-
-impl MirConst {
-    /// Build a constant. Note that this should only be used by the compiler.
-    pub fn new(kind: ConstantKind, ty: Ty, id: MirConstId) -> MirConst {
-        MirConst { kind, ty, id }
-    }
-
-    /// Retrieve the constant kind.
-    pub fn kind(&self) -> &ConstantKind {
-        &self.kind
-    }
-
-    /// Get the constant type.
-    pub fn ty(&self) -> Ty {
-        self.ty
-    }
-
-    /// Try to evaluate to a target `usize`.
-    pub fn eval_target_usize(&self) -> Result<u64, Error> {
-        with(|cx| cx.eval_target_usize(self))
-    }
-
-    /// Create a constant that represents a new zero-sized constant of type T.
-    /// Fails if the type is not a ZST or if it doesn't have a known size.
-    pub fn try_new_zero_sized(ty: Ty) -> Result<MirConst, Error> {
-        with(|cx| cx.try_new_const_zst(ty))
-    }
-
-    /// Build a new constant that represents the given string.
-    ///
-    /// Note that there is no guarantee today about duplication of the same constant.
-    /// I.e.: Calling this function multiple times with the same argument may or may not return
-    /// the same allocation.
-    pub fn from_str(value: &str) -> MirConst {
-        with(|cx| cx.new_const_str(value))
-    }
-
-    /// Build a new constant that represents the given boolean value.
-    pub fn from_bool(value: bool) -> MirConst {
-        with(|cx| cx.new_const_bool(value))
-    }
-
-    /// Build a new constant that represents the given unsigned integer.
-    pub fn try_from_uint(value: u128, uint_ty: UintTy) -> Result<MirConst, Error> {
-        with(|cx| cx.try_new_const_uint(value, uint_ty))
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
-pub struct MirConstId(usize);
-
-type Ident = Opaque;
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct Region {
-    pub kind: RegionKind,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum RegionKind {
-    ReEarlyParam(EarlyParamRegion),
-    ReBound(DebruijnIndex, BoundRegion),
-    ReStatic,
-    RePlaceholder(Placeholder<BoundRegion>),
-    ReErased,
-}
-
-pub(crate) type DebruijnIndex = u32;
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct EarlyParamRegion {
-    pub index: u32,
-    pub name: Symbol,
-}
-
-pub(crate) type BoundVar = u32;
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct BoundRegion {
-    pub var: BoundVar,
-    pub kind: BoundRegionKind,
-}
-
-pub(crate) type UniverseIndex = u32;
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct Placeholder<T> {
-    pub universe: UniverseIndex,
-    pub bound: T,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Serialize)]
-pub struct Span(usize);
-
-impl Debug for Span {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Span")
-            .field("id", &self.0)
-            .field("repr", &with(|cx| cx.span_to_string(*self)))
-            .finish()
-    }
-}
-
-impl Span {
-    /// Return filename for diagnostic purposes
-    pub fn get_filename(&self) -> Filename {
-        with(|c| c.get_filename(self))
-    }
-
-    /// Return lines that correspond to this `Span`
-    pub fn get_lines(&self) -> LineInfo {
-        with(|c| c.get_lines(self))
-    }
-
-    /// Return the span location to be printed in diagnostic messages.
-    ///
-    /// This may leak local file paths and should not be used to build artifacts that may be
-    /// distributed.
-    pub fn diagnostic(&self) -> String {
-        with(|c| c.span_to_string(*self))
-    }
-}
-
-#[derive(Clone, Copy, Debug, Serialize)]
-/// Information you get from `Span` in a struct form.
-/// Line and col start from 1.
-pub struct LineInfo {
-    pub start_line: usize,
-    pub start_col: usize,
-    pub end_line: usize,
-    pub end_col: usize,
-}
-
-impl LineInfo {
-    pub fn from(lines: (usize, usize, usize, usize)) -> Self {
-        LineInfo { start_line: lines.0, start_col: lines.1, end_line: lines.2, end_col: lines.3 }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum TyKind {
-    RigidTy(RigidTy),
-    Alias(AliasKind, AliasTy),
-    Param(ParamTy),
-    Bound(usize, BoundTy),
-}
-
-impl TyKind {
-    pub fn rigid(&self) -> Option<&RigidTy> {
-        if let TyKind::RigidTy(inner) = self { Some(inner) } else { None }
-    }
-
-    #[inline]
-    pub fn is_unit(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Tuple(data)) if data.is_empty())
-    }
-
-    #[inline]
-    pub fn is_bool(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Bool))
-    }
-
-    #[inline]
-    pub fn is_char(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Char))
-    }
-
-    #[inline]
-    pub fn is_trait(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Dynamic(_, _, DynKind::Dyn)))
-    }
-
-    #[inline]
-    pub fn is_enum(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Adt(def, _)) if def.kind() == AdtKind::Enum)
-    }
-
-    #[inline]
-    pub fn is_struct(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Adt(def, _)) if def.kind() == AdtKind::Struct)
-    }
-
-    #[inline]
-    pub fn is_union(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Adt(def, _)) if def.kind() == AdtKind::Union)
-    }
-
-    #[inline]
-    pub fn is_adt(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Adt(..)))
-    }
-
-    #[inline]
-    pub fn is_ref(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Ref(..)))
-    }
-
-    #[inline]
-    pub fn is_fn(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::FnDef(..)))
-    }
-
-    #[inline]
-    pub fn is_fn_ptr(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::FnPtr(..)))
-    }
-
-    #[inline]
-    pub fn is_primitive(&self) -> bool {
-        matches!(
-            self,
-            TyKind::RigidTy(
-                RigidTy::Bool
-                    | RigidTy::Char
-                    | RigidTy::Int(_)
-                    | RigidTy::Uint(_)
-                    | RigidTy::Float(_)
-            )
-        )
-    }
-
-    #[inline]
-    pub fn is_float(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Float(_)))
-    }
-
-    #[inline]
-    pub fn is_integral(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Int(_) | RigidTy::Uint(_)))
-    }
-
-    #[inline]
-    pub fn is_numeric(&self) -> bool {
-        self.is_integral() || self.is_float()
-    }
-
-    #[inline]
-    pub fn is_signed(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Int(_)))
-    }
-
-    #[inline]
-    pub fn is_str(&self) -> bool {
-        *self == TyKind::RigidTy(RigidTy::Str)
-    }
-
-    #[inline]
-    pub fn is_cstr(&self) -> bool {
-        let TyKind::RigidTy(RigidTy::Adt(def, _)) = self else {
-            return false;
-        };
-        with(|cx| cx.adt_is_cstr(*def))
-    }
-
-    #[inline]
-    pub fn is_slice(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Slice(_)))
-    }
-
-    #[inline]
-    pub fn is_array(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Array(..)))
-    }
-
-    #[inline]
-    pub fn is_mutable_ptr(&self) -> bool {
-        matches!(
-            self,
-            TyKind::RigidTy(RigidTy::RawPtr(_, Mutability::Mut))
-                | TyKind::RigidTy(RigidTy::Ref(_, _, Mutability::Mut))
-        )
-    }
-
-    #[inline]
-    pub fn is_raw_ptr(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::RawPtr(..)))
-    }
-
-    /// Tests if this is any kind of primitive pointer type (reference, raw pointer, fn pointer).
-    #[inline]
-    pub fn is_any_ptr(&self) -> bool {
-        self.is_ref() || self.is_raw_ptr() || self.is_fn_ptr()
-    }
-
-    #[inline]
-    pub fn is_coroutine(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Coroutine(..)))
-    }
-
-    #[inline]
-    pub fn is_closure(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Closure(..)))
-    }
-
-    #[inline]
-    pub fn is_box(&self) -> bool {
-        match self {
-            TyKind::RigidTy(RigidTy::Adt(def, _)) => def.is_box(),
-            _ => false,
-        }
-    }
-
-    #[inline]
-    pub fn is_simd(&self) -> bool {
-        matches!(self, TyKind::RigidTy(RigidTy::Adt(def, _)) if def.is_simd())
-    }
-
-    pub fn trait_principal(&self) -> Option<Binder<ExistentialTraitRef>> {
-        if let TyKind::RigidTy(RigidTy::Dynamic(predicates, _, _)) = self {
-            if let Some(Binder { value: ExistentialPredicate::Trait(trait_ref), bound_vars }) =
-                predicates.first()
-            {
-                Some(Binder { value: trait_ref.clone(), bound_vars: bound_vars.clone() })
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }
-
-    /// Returns the type of `ty[i]` for builtin types.
-    pub fn builtin_index(&self) -> Option<Ty> {
-        match self.rigid()? {
-            RigidTy::Array(ty, _) | RigidTy::Slice(ty) => Some(*ty),
-            _ => None,
-        }
-    }
-
-    /// Returns the type and mutability of `*ty` for builtin types.
-    ///
-    /// The parameter `explicit` indicates if this is an *explicit* dereference.
-    /// Some types -- notably raw ptrs -- can only be dereferenced explicitly.
-    pub fn builtin_deref(&self, explicit: bool) -> Option<TypeAndMut> {
-        match self.rigid()? {
-            RigidTy::Adt(def, args) if def.is_box() => {
-                Some(TypeAndMut { ty: *args.0.first()?.ty()?, mutability: Mutability::Not })
-            }
-            RigidTy::Ref(_, ty, mutability) => {
-                Some(TypeAndMut { ty: *ty, mutability: *mutability })
-            }
-            RigidTy::RawPtr(ty, mutability) if explicit => {
-                Some(TypeAndMut { ty: *ty, mutability: *mutability })
-            }
-            _ => None,
-        }
-    }
-
-    /// Get the function signature for function like types (Fn, FnPtr, and Closure)
-    pub fn fn_sig(&self) -> Option<PolyFnSig> {
-        match self {
-            TyKind::RigidTy(RigidTy::FnDef(def, args)) => Some(with(|cx| cx.fn_sig(*def, args))),
-            TyKind::RigidTy(RigidTy::FnPtr(sig)) => Some(sig.clone()),
-            TyKind::RigidTy(RigidTy::Closure(_def, args)) => Some(with(|cx| cx.closure_sig(args))),
-            _ => None,
-        }
-    }
-
-    /// Get the discriminant type for this type.
-    pub fn discriminant_ty(&self) -> Option<Ty> {
-        self.rigid().map(|ty| with(|cx| cx.rigid_ty_discriminant_ty(ty)))
-    }
-
-    /// Deconstruct a function type if this is one.
-    pub fn fn_def(&self) -> Option<(FnDef, &GenericArgs)> {
-        if let TyKind::RigidTy(RigidTy::FnDef(def, args)) = self {
-            Some((*def, args))
-        } else {
-            None
-        }
-    }
-}
-
-pub struct TypeAndMut {
-    pub ty: Ty,
-    pub mutability: Mutability,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum RigidTy {
-    Bool,
-    Char,
-    Int(IntTy),
-    Uint(UintTy),
-    Float(FloatTy),
-    Adt(AdtDef, GenericArgs),
-    Foreign(ForeignDef),
-    Str,
-    Array(Ty, TyConst),
-    Pat(Ty, Pattern),
-    Slice(Ty),
-    RawPtr(Ty, Mutability),
-    Ref(Region, Ty, Mutability),
-    FnDef(FnDef, GenericArgs),
-    FnPtr(PolyFnSig),
-    Closure(ClosureDef, GenericArgs),
-    // FIXME(stable_mir): Movability here is redundant
-    Coroutine(CoroutineDef, GenericArgs, Movability),
-    CoroutineClosure(CoroutineClosureDef, GenericArgs),
-    Dynamic(Vec<Binder<ExistentialPredicate>>, Region, DynKind),
-    Never,
-    Tuple(Vec<Ty>),
-    CoroutineWitness(CoroutineWitnessDef, GenericArgs),
-}
-
-impl RigidTy {
-    /// Get the discriminant type for this type.
-    pub fn discriminant_ty(&self) -> Ty {
-        with(|cx| cx.rigid_ty_discriminant_ty(self))
-    }
-}
-
-impl From<RigidTy> for TyKind {
-    fn from(value: RigidTy) -> Self {
-        TyKind::RigidTy(value)
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
-pub enum IntTy {
-    Isize,
-    I8,
-    I16,
-    I32,
-    I64,
-    I128,
-}
-
-impl IntTy {
-    pub fn num_bytes(self) -> usize {
-        match self {
-            IntTy::Isize => MachineInfo::target_pointer_width().bytes(),
-            IntTy::I8 => 1,
-            IntTy::I16 => 2,
-            IntTy::I32 => 4,
-            IntTy::I64 => 8,
-            IntTy::I128 => 16,
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
-pub enum UintTy {
-    Usize,
-    U8,
-    U16,
-    U32,
-    U64,
-    U128,
-}
-
-impl UintTy {
-    pub fn num_bytes(self) -> usize {
-        match self {
-            UintTy::Usize => MachineInfo::target_pointer_width().bytes(),
-            UintTy::U8 => 1,
-            UintTy::U16 => 2,
-            UintTy::U32 => 4,
-            UintTy::U64 => 8,
-            UintTy::U128 => 16,
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
-pub enum FloatTy {
-    F16,
-    F32,
-    F64,
-    F128,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
-pub enum Movability {
-    Static,
-    Movable,
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub ForeignModuleDef;
-}
-
-impl ForeignModuleDef {
-    pub fn module(&self) -> ForeignModule {
-        with(|cx| cx.foreign_module(*self))
-    }
-}
-
-pub struct ForeignModule {
-    pub def_id: ForeignModuleDef,
-    pub abi: Abi,
-}
-
-impl ForeignModule {
-    pub fn items(&self) -> Vec<ForeignDef> {
-        with(|cx| cx.foreign_items(self.def_id))
-    }
-}
-
-crate_def_with_ty! {
-    /// Hold information about a ForeignItem in a crate.
-    #[derive(Serialize)]
-    pub ForeignDef;
-}
-
-impl ForeignDef {
-    pub fn kind(&self) -> ForeignItemKind {
-        with(|cx| cx.foreign_item_kind(*self))
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
-pub enum ForeignItemKind {
-    Fn(FnDef),
-    Static(StaticDef),
-    Type(Ty),
-}
-
-crate_def_with_ty! {
-    /// Hold information about a function definition in a crate.
-    #[derive(Serialize)]
-    pub FnDef;
-}
-
-impl FnDef {
-    // Get the function body if available.
-    pub fn body(&self) -> Option<Body> {
-        with(|ctx| ctx.has_body(self.0).then(|| ctx.mir_body(self.0)))
-    }
-
-    // Check if the function body is available.
-    pub fn has_body(&self) -> bool {
-        with(|ctx| ctx.has_body(self.0))
-    }
-
-    /// Get the information of the intrinsic if this function is a definition of one.
-    pub fn as_intrinsic(&self) -> Option<IntrinsicDef> {
-        with(|cx| cx.intrinsic(self.def_id()))
-    }
-
-    /// Check if the function is an intrinsic.
-    #[inline]
-    pub fn is_intrinsic(&self) -> bool {
-        self.as_intrinsic().is_some()
-    }
-
-    /// Get the function signature for this function definition.
-    pub fn fn_sig(&self) -> PolyFnSig {
-        let kind = self.ty().kind();
-        kind.fn_sig().unwrap()
-    }
-}
-
-crate_def_with_ty! {
-    #[derive(Serialize)]
-    pub IntrinsicDef;
-}
-
-impl IntrinsicDef {
-    /// Returns the plain name of the intrinsic.
-    /// e.g., `transmute` for `core::intrinsics::transmute`.
-    pub fn fn_name(&self) -> Symbol {
-        with(|cx| cx.intrinsic_name(*self))
-    }
-
-    /// Returns whether the intrinsic has no meaningful body and all backends
-    /// need to shim all calls to it.
-    pub fn must_be_overridden(&self) -> bool {
-        with(|cx| !cx.has_body(self.0))
-    }
-}
-
-impl From<IntrinsicDef> for FnDef {
-    fn from(def: IntrinsicDef) -> Self {
-        FnDef(def.0)
-    }
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub ClosureDef;
-}
-
-impl ClosureDef {
-    /// Retrieves the body of the closure definition. Returns None if the body
-    /// isn't available.
-    pub fn body(&self) -> Option<Body> {
-        with(|ctx| ctx.has_body(self.0).then(|| ctx.mir_body(self.0)))
-    }
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub CoroutineDef;
-}
-
-impl CoroutineDef {
-    /// Retrieves the body of the coroutine definition. Returns None if the body
-    /// isn't available.
-    pub fn body(&self) -> Option<Body> {
-        with(|cx| cx.has_body(self.0).then(|| cx.mir_body(self.0)))
-    }
-
-    pub fn discriminant_for_variant(&self, args: &GenericArgs, idx: VariantIdx) -> Discr {
-        with(|cx| cx.coroutine_discr_for_variant(*self, args, idx))
-    }
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub CoroutineClosureDef;
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub ParamDef;
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub BrNamedDef;
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub AdtDef;
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
-pub enum AdtKind {
-    Enum,
-    Union,
-    Struct,
-}
-
-impl AdtDef {
-    pub fn kind(&self) -> AdtKind {
-        with(|cx| cx.adt_kind(*self))
-    }
-
-    /// Retrieve the type of this Adt.
-    pub fn ty(&self) -> Ty {
-        with(|cx| cx.def_ty(self.0))
-    }
-
-    /// Retrieve the type of this Adt by instantiating and normalizing it with the given arguments.
-    ///
-    /// This will assume the type can be instantiated with these arguments.
-    pub fn ty_with_args(&self, args: &GenericArgs) -> Ty {
-        with(|cx| cx.def_ty_with_args(self.0, args))
-    }
-
-    pub fn is_box(&self) -> bool {
-        with(|cx| cx.adt_is_box(*self))
-    }
-
-    pub fn is_simd(&self) -> bool {
-        with(|cx| cx.adt_is_simd(*self))
-    }
-
-    /// The number of variants in this ADT.
-    pub fn num_variants(&self) -> usize {
-        with(|cx| cx.adt_variants_len(*self))
-    }
-
-    /// Retrieve the variants in this ADT.
-    pub fn variants(&self) -> Vec<VariantDef> {
-        self.variants_iter().collect()
-    }
-
-    /// Iterate over the variants in this ADT.
-    pub fn variants_iter(&self) -> impl Iterator<Item = VariantDef> {
-        (0..self.num_variants())
-            .map(|idx| VariantDef { idx: VariantIdx::to_val(idx), adt_def: *self })
-    }
-
-    pub fn variant(&self, idx: VariantIdx) -> Option<VariantDef> {
-        (idx.to_index() < self.num_variants()).then_some(VariantDef { idx, adt_def: *self })
-    }
-
-    pub fn repr(&self) -> ReprOptions {
-        with(|cx| cx.adt_repr(*self))
-    }
-
-    pub fn discriminant_for_variant(&self, idx: VariantIdx) -> Discr {
-        with(|cx| cx.adt_discr_for_variant(*self, idx))
-    }
-}
-
-pub struct Discr {
-    pub val: u128,
-    pub ty: Ty,
-}
-
-/// Definition of a variant, which can be either a struct / union field or an enum variant.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct VariantDef {
-    /// The variant index.
-    ///
-    /// ## Warning
-    /// Do not access this field directly!
-    pub idx: VariantIdx,
-    /// The data type where this variant comes from.
-    /// For now, we use this to retrieve information about the variant itself so we don't need to
-    /// cache more information.
-    ///
-    /// ## Warning
-    /// Do not access this field directly!
-    pub adt_def: AdtDef,
-}
-
-impl VariantDef {
-    pub fn name(&self) -> Symbol {
-        with(|cx| cx.variant_name(*self))
-    }
-
-    /// Retrieve all the fields in this variant.
-    // We expect user to cache this and use it directly since today it is expensive to generate all
-    // fields name.
-    pub fn fields(&self) -> Vec<FieldDef> {
-        with(|cx| cx.variant_fields(*self))
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct FieldDef {
-    /// The field definition.
-    ///
-    /// ## Warning
-    /// Do not access this field directly! This is public for the compiler to have access to it.
-    pub def: DefId,
-
-    /// The field name.
-    pub name: Symbol,
-}
-
-impl FieldDef {
-    /// Retrieve the type of this field instantiating and normalizing it with the given arguments.
-    ///
-    /// This will assume the type can be instantiated with these arguments.
-    pub fn ty_with_args(&self, args: &GenericArgs) -> Ty {
-        with(|cx| cx.def_ty_with_args(self.def, args))
-    }
-
-    /// Retrieve the type of this field.
-    pub fn ty(&self) -> Ty {
-        with(|cx| cx.def_ty(self.def))
-    }
-}
-
-impl Display for AdtKind {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_str(match self {
-            AdtKind::Enum => "enum",
-            AdtKind::Union => "union",
-            AdtKind::Struct => "struct",
-        })
-    }
-}
-
-impl AdtKind {
-    pub fn is_enum(&self) -> bool {
-        matches!(self, AdtKind::Enum)
-    }
-
-    pub fn is_struct(&self) -> bool {
-        matches!(self, AdtKind::Struct)
-    }
-
-    pub fn is_union(&self) -> bool {
-        matches!(self, AdtKind::Union)
-    }
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub AliasDef;
-}
-
-crate_def! {
-    /// A trait's definition.
-    #[derive(Serialize)]
-    pub TraitDef;
-}
-
-impl_crate_def_items! {
-    TraitDef;
-}
-
-impl TraitDef {
-    pub fn declaration(trait_def: &TraitDef) -> TraitDecl {
-        with(|cx| cx.trait_decl(trait_def))
-    }
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub GenericDef;
-}
-
-crate_def_with_ty! {
-    #[derive(Serialize)]
-    pub ConstDef;
-}
-
-crate_def! {
-    /// A trait impl definition.
-    #[derive(Serialize)]
-    pub ImplDef;
-}
-
-impl_crate_def_items! {
-    ImplDef;
-}
-
-impl ImplDef {
-    /// Retrieve information about this implementation.
-    pub fn trait_impl(&self) -> ImplTrait {
-        with(|cx| cx.trait_impl(self))
-    }
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub RegionDef;
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub CoroutineWitnessDef;
-}
-
-/// A list of generic arguments.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct GenericArgs(pub Vec<GenericArgKind>);
-
-impl std::ops::Index<ParamTy> for GenericArgs {
-    type Output = Ty;
-
-    fn index(&self, index: ParamTy) -> &Self::Output {
-        self.0[index.index as usize].expect_ty()
-    }
-}
-
-impl std::ops::Index<ParamConst> for GenericArgs {
-    type Output = TyConst;
-
-    fn index(&self, index: ParamConst) -> &Self::Output {
-        self.0[index.index as usize].expect_const()
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum GenericArgKind {
-    Lifetime(Region),
-    Type(Ty),
-    Const(TyConst),
-}
-
-impl GenericArgKind {
-    /// Panic if this generic argument is not a type, otherwise
-    /// return the type.
-    #[track_caller]
-    pub fn expect_ty(&self) -> &Ty {
-        match self {
-            GenericArgKind::Type(ty) => ty,
-            _ => panic!("{self:?}"),
-        }
-    }
-
-    /// Panic if this generic argument is not a const, otherwise
-    /// return the const.
-    #[track_caller]
-    pub fn expect_const(&self) -> &TyConst {
-        match self {
-            GenericArgKind::Const(c) => c,
-            _ => panic!("{self:?}"),
-        }
-    }
-
-    /// Return the generic argument type if applicable, otherwise return `None`.
-    pub fn ty(&self) -> Option<&Ty> {
-        match self {
-            GenericArgKind::Type(ty) => Some(ty),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum TermKind {
-    Type(Ty),
-    Const(TyConst),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum AliasKind {
-    Projection,
-    Inherent,
-    Opaque,
-    Free,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct AliasTy {
-    pub def_id: AliasDef,
-    pub args: GenericArgs,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct AliasTerm {
-    pub def_id: AliasDef,
-    pub args: GenericArgs,
-}
-
-pub type PolyFnSig = Binder<FnSig>;
-
-impl PolyFnSig {
-    /// Compute a `FnAbi` suitable for indirect calls, i.e. to `fn` pointers.
-    ///
-    /// NB: this doesn't handle virtual calls - those should use `Instance::fn_abi`
-    /// instead, where the instance is an `InstanceKind::Virtual`.
-    pub fn fn_ptr_abi(self) -> Result<FnAbi, Error> {
-        with(|cx| cx.fn_ptr_abi(self))
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct FnSig {
-    pub inputs_and_output: Vec<Ty>,
-    pub c_variadic: bool,
-    pub safety: Safety,
-    pub abi: Abi,
-}
-
-impl FnSig {
-    pub fn output(&self) -> Ty {
-        self.inputs_and_output[self.inputs_and_output.len() - 1]
-    }
-
-    pub fn inputs(&self) -> &[Ty] {
-        &self.inputs_and_output[..self.inputs_and_output.len() - 1]
-    }
-}
-
-#[derive(Clone, PartialEq, Eq, Debug, Serialize)]
-pub enum Abi {
-    Rust,
-    C { unwind: bool },
-    Cdecl { unwind: bool },
-    Stdcall { unwind: bool },
-    Fastcall { unwind: bool },
-    Vectorcall { unwind: bool },
-    Thiscall { unwind: bool },
-    Aapcs { unwind: bool },
-    Win64 { unwind: bool },
-    SysV64 { unwind: bool },
-    PtxKernel,
-    Msp430Interrupt,
-    X86Interrupt,
-    GpuKernel,
-    EfiApi,
-    AvrInterrupt,
-    AvrNonBlockingInterrupt,
-    CCmseNonSecureCall,
-    CCmseNonSecureEntry,
-    System { unwind: bool },
-    RustCall,
-    Unadjusted,
-    RustCold,
-    RiscvInterruptM,
-    RiscvInterruptS,
-    RustInvalid,
-    Custom,
-}
-
-/// A binder represents a possibly generic type and its bound vars.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct Binder<T> {
-    pub value: T,
-    pub bound_vars: Vec<BoundVariableKind>,
-}
-
-impl<T> Binder<T> {
-    /// Create a new binder with the given bound vars.
-    pub fn bind_with_vars(value: T, bound_vars: Vec<BoundVariableKind>) -> Self {
-        Binder { value, bound_vars }
-    }
-
-    /// Create a new binder with no bounded variable.
-    pub fn dummy(value: T) -> Self {
-        Binder { value, bound_vars: vec![] }
-    }
-
-    pub fn skip_binder(self) -> T {
-        self.value
-    }
-
-    pub fn map_bound_ref<F, U>(&self, f: F) -> Binder<U>
-    where
-        F: FnOnce(&T) -> U,
-    {
-        let Binder { value, bound_vars } = self;
-        let new_value = f(value);
-        Binder { value: new_value, bound_vars: bound_vars.clone() }
-    }
-
-    pub fn map_bound<F, U>(self, f: F) -> Binder<U>
-    where
-        F: FnOnce(T) -> U,
-    {
-        let Binder { value, bound_vars } = self;
-        let new_value = f(value);
-        Binder { value: new_value, bound_vars }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct EarlyBinder<T> {
-    pub value: T,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum BoundVariableKind {
-    Ty(BoundTyKind),
-    Region(BoundRegionKind),
-    Const,
-}
-
-#[derive(Clone, PartialEq, Eq, Debug, Serialize)]
-pub enum BoundTyKind {
-    Anon,
-    Param(ParamDef, String),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum BoundRegionKind {
-    BrAnon,
-    BrNamed(BrNamedDef, String),
-    BrEnv,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum DynKind {
-    Dyn,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum ExistentialPredicate {
-    Trait(ExistentialTraitRef),
-    Projection(ExistentialProjection),
-    AutoTrait(TraitDef),
-}
-
-/// An existential reference to a trait where `Self` is not included.
-///
-/// The `generic_args` will include any other known argument.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct ExistentialTraitRef {
-    pub def_id: TraitDef,
-    pub generic_args: GenericArgs,
-}
-
-impl Binder<ExistentialTraitRef> {
-    pub fn with_self_ty(&self, self_ty: Ty) -> Binder<TraitRef> {
-        self.map_bound_ref(|trait_ref| trait_ref.with_self_ty(self_ty))
-    }
-}
-
-impl ExistentialTraitRef {
-    pub fn with_self_ty(&self, self_ty: Ty) -> TraitRef {
-        TraitRef::new(self.def_id, self_ty, &self.generic_args)
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct ExistentialProjection {
-    pub def_id: TraitDef,
-    pub generic_args: GenericArgs,
-    pub term: TermKind,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct ParamTy {
-    pub index: u32,
-    pub name: String,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct BoundTy {
-    pub var: usize,
-    pub kind: BoundTyKind,
-}
-
-pub type Bytes = Vec<Option<u8>>;
-
-/// Size in bytes.
-pub type Size = usize;
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
-pub struct Prov(pub AllocId);
-
-pub type Align = u64;
-pub type Promoted = u32;
-pub type InitMaskMaterialized = Vec<u64>;
-
-/// Stores the provenance information of pointers stored in memory.
-#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize)]
-pub struct ProvenanceMap {
-    /// Provenance in this map applies from the given offset for an entire pointer-size worth of
-    /// bytes. Two entries in this map are always at least a pointer size apart.
-    pub ptrs: Vec<(Size, Prov)>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize)]
-pub struct Allocation {
-    pub bytes: Bytes,
-    pub provenance: ProvenanceMap,
-    pub align: Align,
-    pub mutability: Mutability,
-}
-
-impl Allocation {
-    /// Get a vector of bytes for an Allocation that has been fully initialized
-    pub fn raw_bytes(&self) -> Result<Vec<u8>, Error> {
-        self.bytes
-            .iter()
-            .copied()
-            .collect::<Option<Vec<_>>>()
-            .ok_or_else(|| error!("Found uninitialized bytes: `{:?}`", self.bytes))
-    }
-
-    /// Read a uint value from the specified range.
-    pub fn read_partial_uint(&self, range: Range<usize>) -> Result<u128, Error> {
-        if range.end - range.start > 16 {
-            return Err(error!("Allocation is bigger than largest integer"));
-        }
-        if range.end > self.bytes.len() {
-            return Err(error!(
-                "Range is out of bounds. Allocation length is `{}`, but requested range `{:?}`",
-                self.bytes.len(),
-                range
-            ));
-        }
-        let raw = self.bytes[range]
-            .iter()
-            .copied()
-            .collect::<Option<Vec<_>>>()
-            .ok_or_else(|| error!("Found uninitialized bytes: `{:?}`", self.bytes))?;
-        read_target_uint(&raw)
-    }
-
-    /// Read this allocation and try to convert it to an unassigned integer.
-    pub fn read_uint(&self) -> Result<u128, Error> {
-        if self.bytes.len() > 16 {
-            return Err(error!("Allocation is bigger than largest integer"));
-        }
-        let raw = self.raw_bytes()?;
-        read_target_uint(&raw)
-    }
-
-    /// Read this allocation and try to convert it to a signed integer.
-    pub fn read_int(&self) -> Result<i128, Error> {
-        if self.bytes.len() > 16 {
-            return Err(error!("Allocation is bigger than largest integer"));
-        }
-        let raw = self.raw_bytes()?;
-        read_target_int(&raw)
-    }
-
-    /// Read this allocation and try to convert it to a boolean.
-    pub fn read_bool(&self) -> Result<bool, Error> {
-        match self.read_int()? {
-            0 => Ok(false),
-            1 => Ok(true),
-            val => Err(error!("Unexpected value for bool: `{val}`")),
-        }
-    }
-
-    /// Read this allocation as a pointer and return whether it represents a `null` pointer.
-    pub fn is_null(&self) -> Result<bool, Error> {
-        let len = self.bytes.len();
-        let ptr_len = MachineInfo::target_pointer_width().bytes();
-        if len != ptr_len {
-            return Err(error!("Expected width of pointer (`{ptr_len}`), but found: `{len}`"));
-        }
-        Ok(self.read_uint()? == 0 && self.provenance.ptrs.is_empty())
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum ConstantKind {
-    Ty(TyConst),
-    Allocated(Allocation),
-    Unevaluated(UnevaluatedConst),
-    Param(ParamConst),
-    /// Store ZST constants.
-    /// We have to special handle these constants since its type might be generic.
-    ZeroSized,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct ParamConst {
-    pub index: u32,
-    pub name: String,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct UnevaluatedConst {
-    pub def: ConstDef,
-    pub args: GenericArgs,
-    pub promoted: Option<Promoted>,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
-pub enum TraitSpecializationKind {
-    None,
-    Marker,
-    AlwaysApplicable,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct TraitDecl {
-    pub def_id: TraitDef,
-    pub safety: Safety,
-    pub paren_sugar: bool,
-    pub has_auto_impl: bool,
-    pub is_marker: bool,
-    pub is_coinductive: bool,
-    pub skip_array_during_method_dispatch: bool,
-    pub skip_boxed_slice_during_method_dispatch: bool,
-    pub specialization_kind: TraitSpecializationKind,
-    pub must_implement_one_of: Option<Vec<Ident>>,
-    pub implement_via_object: bool,
-    pub deny_explicit_impl: bool,
-}
-
-impl TraitDecl {
-    pub fn generics_of(&self) -> Generics {
-        with(|cx| cx.generics_of(self.def_id.0))
-    }
-
-    pub fn predicates_of(&self) -> GenericPredicates {
-        with(|cx| cx.predicates_of(self.def_id.0))
-    }
-
-    pub fn explicit_predicates_of(&self) -> GenericPredicates {
-        with(|cx| cx.explicit_predicates_of(self.def_id.0))
-    }
-}
-
-pub type ImplTrait = EarlyBinder<TraitRef>;
-
-/// A complete reference to a trait, i.e., one where `Self` is known.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct TraitRef {
-    pub def_id: TraitDef,
-    /// The generic arguments for this definition.
-    /// The first element must always be type, and it represents `Self`.
-    args: GenericArgs,
-}
-
-impl TraitRef {
-    pub fn new(def_id: TraitDef, self_ty: Ty, gen_args: &GenericArgs) -> TraitRef {
-        let mut args = vec![GenericArgKind::Type(self_ty)];
-        args.extend_from_slice(&gen_args.0);
-        TraitRef { def_id, args: GenericArgs(args) }
-    }
-
-    pub fn try_new(def_id: TraitDef, args: GenericArgs) -> Result<TraitRef, ()> {
-        match &args.0[..] {
-            [GenericArgKind::Type(_), ..] => Ok(TraitRef { def_id, args }),
-            _ => Err(()),
-        }
-    }
-
-    pub fn args(&self) -> &GenericArgs {
-        &self.args
-    }
-
-    pub fn self_ty(&self) -> Ty {
-        let GenericArgKind::Type(self_ty) = self.args.0[0] else {
-            panic!("Self must be a type, but found: {:?}", self.args.0[0])
-        };
-        self_ty
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct Generics {
-    pub parent: Option<GenericDef>,
-    pub parent_count: usize,
-    pub params: Vec<GenericParamDef>,
-    pub param_def_id_to_index: Vec<(GenericDef, u32)>,
-    pub has_self: bool,
-    pub has_late_bound_regions: Option<Span>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum GenericParamDefKind {
-    Lifetime,
-    Type { has_default: bool, synthetic: bool },
-    Const { has_default: bool },
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct GenericParamDef {
-    pub name: super::Symbol,
-    pub def_id: GenericDef,
-    pub index: u32,
-    pub pure_wrt_drop: bool,
-    pub kind: GenericParamDefKind,
-}
-
-pub struct GenericPredicates {
-    pub parent: Option<TraitDef>,
-    pub predicates: Vec<(PredicateKind, Span)>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum PredicateKind {
-    Clause(ClauseKind),
-    DynCompatible(TraitDef),
-    SubType(SubtypePredicate),
-    Coerce(CoercePredicate),
-    ConstEquate(TyConst, TyConst),
-    Ambiguous,
-    AliasRelate(TermKind, TermKind, AliasRelationDirection),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum ClauseKind {
-    Trait(TraitPredicate),
-    RegionOutlives(RegionOutlivesPredicate),
-    TypeOutlives(TypeOutlivesPredicate),
-    Projection(ProjectionPredicate),
-    ConstArgHasType(TyConst, Ty),
-    WellFormed(TermKind),
-    ConstEvaluatable(TyConst),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum ClosureKind {
-    Fn,
-    FnMut,
-    FnOnce,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct SubtypePredicate {
-    pub a: Ty,
-    pub b: Ty,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct CoercePredicate {
-    pub a: Ty,
-    pub b: Ty,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum AliasRelationDirection {
-    Equate,
-    Subtype,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct TraitPredicate {
-    pub trait_ref: TraitRef,
-    pub polarity: PredicatePolarity,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct OutlivesPredicate<A, B>(pub A, pub B);
-
-pub type RegionOutlivesPredicate = OutlivesPredicate<Region, Region>;
-pub type TypeOutlivesPredicate = OutlivesPredicate<Ty, Region>;
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct ProjectionPredicate {
-    pub projection_term: AliasTerm,
-    pub term: TermKind,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum ImplPolarity {
-    Positive,
-    Negative,
-    Reservation,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum PredicatePolarity {
-    Positive,
-    Negative,
-}
-
-macro_rules! index_impl {
-    ($name:ident) => {
-        impl crate::IndexedVal for $name {
-            fn to_val(index: usize) -> Self {
-                $name(index)
-            }
-            fn to_index(&self) -> usize {
-                self.0
-            }
-        }
-    };
-}
-
-index_impl!(TyConstId);
-index_impl!(MirConstId);
-index_impl!(Ty);
-index_impl!(Span);
-
-/// The source-order index of a variant in a type.
-///
-/// For example, in the following types,
-/// ```ignore(illustrative)
-/// enum Demo1 {
-///    Variant0 { a: bool, b: i32 },
-///    Variant1 { c: u8, d: u64 },
-/// }
-/// struct Demo2 { e: u8, f: u16, g: u8 }
-/// ```
-/// `a` is in the variant with the `VariantIdx` of `0`,
-/// `c` is in the variant with the `VariantIdx` of `1`, and
-/// `g` is in the variant with the `VariantIdx` of `0`.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct VariantIdx(usize);
-
-index_impl!(VariantIdx);
-
-crate_def! {
-    /// Hold information about an Opaque definition, particularly useful in `RPITIT`.
-    #[derive(Serialize)]
-    pub OpaqueDef;
-}
-
-crate_def! {
-    #[derive(Serialize)]
-    pub AssocDef;
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub struct AssocItem {
-    pub def_id: AssocDef,
-    pub kind: AssocKind,
-    pub container: AssocItemContainer,
-
-    /// If this is an item in an impl of a trait then this is the `DefId` of
-    /// the associated item on the trait that this implements.
-    pub trait_item_def_id: Option<AssocDef>,
-}
-
-#[derive(Clone, PartialEq, Debug, Eq, Serialize)]
-pub enum AssocTypeData {
-    Normal(Symbol),
-    /// The associated type comes from an RPITIT. It has no name, and the
-    /// `ImplTraitInTraitData` provides additional information about its
-    /// source.
-    Rpitit(ImplTraitInTraitData),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum AssocKind {
-    Const { name: Symbol },
-    Fn { name: Symbol, has_self: bool },
-    Type { data: AssocTypeData },
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum AssocItemContainer {
-    Trait,
-    Impl,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, Serialize)]
-pub enum ImplTraitInTraitData {
-    Trait { fn_def_id: FnDef, opaque_def_id: OpaqueDef },
-    Impl { fn_def_id: FnDef },
-}
-
-impl AssocItem {
-    pub fn is_impl_trait_in_trait(&self) -> bool {
-        matches!(self.kind, AssocKind::Type { data: AssocTypeData::Rpitit(_) })
-    }
-}
diff --git a/compiler/stable_mir/src/unstable/convert/internal.rs b/compiler/stable_mir/src/unstable/convert/internal.rs
deleted file mode 100644
index 04b2e572621..00000000000
--- a/compiler/stable_mir/src/unstable/convert/internal.rs
+++ /dev/null
@@ -1,823 +0,0 @@
-//! Module containing the translation from stable mir constructs to the rustc counterpart.
-//!
-//! This module will only include a few constructs to allow users to invoke internal rustc APIs
-//! due to incomplete stable coverage.
-
-// Prefer importing stable_mir over internal rustc constructs to make this file more readable.
-
-use rustc_middle::ty::{self as rustc_ty, Const as InternalConst, Ty as InternalTy};
-use rustc_smir::Tables;
-
-use crate::abi::Layout;
-use crate::compiler_interface::BridgeTys;
-use crate::mir::alloc::AllocId;
-use crate::mir::mono::{Instance, MonoItem, StaticDef};
-use crate::mir::{BinOp, Mutability, Place, ProjectionElem, RawPtrKind, Safety, UnOp};
-use crate::ty::{
-    Abi, AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind, DynKind,
-    ExistentialPredicate, ExistentialProjection, ExistentialTraitRef, FloatTy, FnSig,
-    GenericArgKind, GenericArgs, IntTy, MirConst, Movability, Pattern, Region, RigidTy, Span,
-    TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx,
-};
-use crate::unstable::{InternalCx, RustcInternal};
-use crate::{CrateItem, CrateNum, DefId, IndexedVal};
-
-impl RustcInternal for CrateItem {
-    type T<'tcx> = rustc_span::def_id::DefId;
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        self.0.internal(tables, tcx)
-    }
-}
-
-impl RustcInternal for CrateNum {
-    type T<'tcx> = rustc_span::def_id::CrateNum;
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        rustc_span::def_id::CrateNum::from_usize(*self)
-    }
-}
-
-impl RustcInternal for DefId {
-    type T<'tcx> = rustc_span::def_id::DefId;
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        tcx.lift(tables.def_ids[*self]).unwrap()
-    }
-}
-
-impl RustcInternal for GenericArgs {
-    type T<'tcx> = rustc_ty::GenericArgsRef<'tcx>;
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        InternalCx::mk_args_from_iter(tcx, self.0.iter().map(|arg| arg.internal(tables, tcx)))
-    }
-}
-
-impl RustcInternal for GenericArgKind {
-    type T<'tcx> = rustc_ty::GenericArg<'tcx>;
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        let arg: rustc_ty::GenericArg<'tcx> = match self {
-            GenericArgKind::Lifetime(reg) => reg.internal(tables, tcx).into(),
-            GenericArgKind::Type(ty) => ty.internal(tables, tcx).into(),
-            GenericArgKind::Const(cnst) => cnst.internal(tables, tcx).into(),
-        };
-        tcx.lift(arg).unwrap()
-    }
-}
-
-impl RustcInternal for Region {
-    type T<'tcx> = rustc_ty::Region<'tcx>;
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        // Cannot recover region. Use erased for now.
-        tcx.lifetimes_re_erased()
-    }
-}
-
-impl RustcInternal for Ty {
-    type T<'tcx> = InternalTy<'tcx>;
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        tcx.lift(tables.types[*self]).unwrap()
-    }
-}
-
-impl RustcInternal for TyConst {
-    type T<'tcx> = InternalConst<'tcx>;
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        tcx.lift(tables.ty_consts[self.id]).unwrap()
-    }
-}
-
-impl RustcInternal for Pattern {
-    type T<'tcx> = rustc_ty::Pattern<'tcx>;
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        tcx.mk_pat(match self {
-            Pattern::Range { start, end, include_end: _ } => rustc_ty::PatternKind::Range {
-                start: start.as_ref().unwrap().internal(tables, tcx),
-                end: end.as_ref().unwrap().internal(tables, tcx),
-            },
-        })
-    }
-}
-
-impl RustcInternal for RigidTy {
-    type T<'tcx> = rustc_ty::TyKind<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            RigidTy::Bool => rustc_ty::TyKind::Bool,
-            RigidTy::Char => rustc_ty::TyKind::Char,
-            RigidTy::Int(int_ty) => rustc_ty::TyKind::Int(int_ty.internal(tables, tcx)),
-            RigidTy::Uint(uint_ty) => rustc_ty::TyKind::Uint(uint_ty.internal(tables, tcx)),
-            RigidTy::Float(float_ty) => rustc_ty::TyKind::Float(float_ty.internal(tables, tcx)),
-            RigidTy::Never => rustc_ty::TyKind::Never,
-            RigidTy::Array(ty, cnst) => {
-                rustc_ty::TyKind::Array(ty.internal(tables, tcx), cnst.internal(tables, tcx))
-            }
-            RigidTy::Pat(ty, pat) => {
-                rustc_ty::TyKind::Pat(ty.internal(tables, tcx), pat.internal(tables, tcx))
-            }
-            RigidTy::Adt(def, args) => {
-                rustc_ty::TyKind::Adt(def.internal(tables, tcx), args.internal(tables, tcx))
-            }
-            RigidTy::Str => rustc_ty::TyKind::Str,
-            RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables, tcx)),
-            RigidTy::RawPtr(ty, mutability) => {
-                rustc_ty::TyKind::RawPtr(ty.internal(tables, tcx), mutability.internal(tables, tcx))
-            }
-            RigidTy::Ref(region, ty, mutability) => rustc_ty::TyKind::Ref(
-                region.internal(tables, tcx),
-                ty.internal(tables, tcx),
-                mutability.internal(tables, tcx),
-            ),
-            RigidTy::Foreign(def) => rustc_ty::TyKind::Foreign(def.0.internal(tables, tcx)),
-            RigidTy::FnDef(def, args) => {
-                rustc_ty::TyKind::FnDef(def.0.internal(tables, tcx), args.internal(tables, tcx))
-            }
-            RigidTy::FnPtr(sig) => {
-                let (sig_tys, hdr) = sig.internal(tables, tcx).split();
-                rustc_ty::TyKind::FnPtr(sig_tys, hdr)
-            }
-            RigidTy::Closure(def, args) => {
-                rustc_ty::TyKind::Closure(def.0.internal(tables, tcx), args.internal(tables, tcx))
-            }
-            RigidTy::Coroutine(def, args, _mov) => {
-                rustc_ty::TyKind::Coroutine(def.0.internal(tables, tcx), args.internal(tables, tcx))
-            }
-            RigidTy::CoroutineClosure(def, args) => rustc_ty::TyKind::CoroutineClosure(
-                def.0.internal(tables, tcx),
-                args.internal(tables, tcx),
-            ),
-            RigidTy::CoroutineWitness(def, args) => rustc_ty::TyKind::CoroutineWitness(
-                def.0.internal(tables, tcx),
-                args.internal(tables, tcx),
-            ),
-            RigidTy::Dynamic(predicate, region, dyn_kind) => rustc_ty::TyKind::Dynamic(
-                tcx.mk_poly_existential_predicates(&predicate.internal(tables, tcx)),
-                region.internal(tables, tcx),
-                dyn_kind.internal(tables, tcx),
-            ),
-            RigidTy::Tuple(tys) => {
-                rustc_ty::TyKind::Tuple(tcx.mk_type_list(&tys.internal(tables, tcx)))
-            }
-        }
-    }
-}
-
-impl RustcInternal for IntTy {
-    type T<'tcx> = rustc_ty::IntTy;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            IntTy::Isize => rustc_ty::IntTy::Isize,
-            IntTy::I8 => rustc_ty::IntTy::I8,
-            IntTy::I16 => rustc_ty::IntTy::I16,
-            IntTy::I32 => rustc_ty::IntTy::I32,
-            IntTy::I64 => rustc_ty::IntTy::I64,
-            IntTy::I128 => rustc_ty::IntTy::I128,
-        }
-    }
-}
-
-impl RustcInternal for UintTy {
-    type T<'tcx> = rustc_ty::UintTy;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            UintTy::Usize => rustc_ty::UintTy::Usize,
-            UintTy::U8 => rustc_ty::UintTy::U8,
-            UintTy::U16 => rustc_ty::UintTy::U16,
-            UintTy::U32 => rustc_ty::UintTy::U32,
-            UintTy::U64 => rustc_ty::UintTy::U64,
-            UintTy::U128 => rustc_ty::UintTy::U128,
-        }
-    }
-}
-
-impl RustcInternal for FloatTy {
-    type T<'tcx> = rustc_ty::FloatTy;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            FloatTy::F16 => rustc_ty::FloatTy::F16,
-            FloatTy::F32 => rustc_ty::FloatTy::F32,
-            FloatTy::F64 => rustc_ty::FloatTy::F64,
-            FloatTy::F128 => rustc_ty::FloatTy::F128,
-        }
-    }
-}
-
-impl RustcInternal for Mutability {
-    type T<'tcx> = rustc_ty::Mutability;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            Mutability::Not => rustc_ty::Mutability::Not,
-            Mutability::Mut => rustc_ty::Mutability::Mut,
-        }
-    }
-}
-
-impl RustcInternal for Movability {
-    type T<'tcx> = rustc_ty::Movability;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            Movability::Static => rustc_ty::Movability::Static,
-            Movability::Movable => rustc_ty::Movability::Movable,
-        }
-    }
-}
-
-impl RustcInternal for RawPtrKind {
-    type T<'tcx> = rustc_middle::mir::RawPtrKind;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            RawPtrKind::Mut => rustc_middle::mir::RawPtrKind::Mut,
-            RawPtrKind::Const => rustc_middle::mir::RawPtrKind::Const,
-            RawPtrKind::FakeForPtrMetadata => rustc_middle::mir::RawPtrKind::FakeForPtrMetadata,
-        }
-    }
-}
-
-impl RustcInternal for FnSig {
-    type T<'tcx> = rustc_ty::FnSig<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        tcx.lift(rustc_ty::FnSig {
-            inputs_and_output: tcx.mk_type_list(&self.inputs_and_output.internal(tables, tcx)),
-            c_variadic: self.c_variadic,
-            safety: self.safety.internal(tables, tcx),
-            abi: self.abi.internal(tables, tcx),
-        })
-        .unwrap()
-    }
-}
-
-impl RustcInternal for VariantIdx {
-    type T<'tcx> = rustc_abi::VariantIdx;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        rustc_abi::VariantIdx::from(self.to_index())
-    }
-}
-
-impl RustcInternal for VariantDef {
-    type T<'tcx> = &'tcx rustc_ty::VariantDef;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        self.adt_def.internal(tables, tcx).variant(self.idx.internal(tables, tcx))
-    }
-}
-
-impl RustcInternal for MirConst {
-    type T<'tcx> = rustc_middle::mir::Const<'tcx>;
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        let constant = tables.mir_consts[self.id];
-        match constant {
-            rustc_middle::mir::Const::Ty(ty, ct) => {
-                rustc_middle::mir::Const::Ty(tcx.lift(ty).unwrap(), tcx.lift(ct).unwrap())
-            }
-            rustc_middle::mir::Const::Unevaluated(uneval, ty) => {
-                rustc_middle::mir::Const::Unevaluated(
-                    tcx.lift(uneval).unwrap(),
-                    tcx.lift(ty).unwrap(),
-                )
-            }
-            rustc_middle::mir::Const::Val(const_val, ty) => {
-                rustc_middle::mir::Const::Val(tcx.lift(const_val).unwrap(), tcx.lift(ty).unwrap())
-            }
-        }
-    }
-}
-
-impl RustcInternal for MonoItem {
-    type T<'tcx> = rustc_middle::mir::mono::MonoItem<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        use rustc_middle::mir::mono as rustc_mono;
-        match self {
-            MonoItem::Fn(instance) => rustc_mono::MonoItem::Fn(instance.internal(tables, tcx)),
-            MonoItem::Static(def) => rustc_mono::MonoItem::Static(def.internal(tables, tcx)),
-            MonoItem::GlobalAsm(_) => {
-                unimplemented!()
-            }
-        }
-    }
-}
-
-impl RustcInternal for Instance {
-    type T<'tcx> = rustc_ty::Instance<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        tcx.lift(tables.instances[self.def]).unwrap()
-    }
-}
-
-impl RustcInternal for StaticDef {
-    type T<'tcx> = rustc_span::def_id::DefId;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        self.0.internal(tables, tcx)
-    }
-}
-
-#[allow(rustc::usage_of_qualified_ty)]
-impl<T> RustcInternal for Binder<T>
-where
-    T: RustcInternal,
-    for<'tcx> T::T<'tcx>: rustc_ty::TypeVisitable<rustc_ty::TyCtxt<'tcx>>,
-{
-    type T<'tcx> = rustc_ty::Binder<'tcx, T::T<'tcx>>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        rustc_ty::Binder::bind_with_vars(
-            self.value.internal(tables, tcx),
-            tcx.mk_bound_variable_kinds_from_iter(
-                self.bound_vars.iter().map(|bound| bound.internal(tables, tcx)),
-            ),
-        )
-    }
-}
-
-impl RustcInternal for BoundVariableKind {
-    type T<'tcx> = rustc_ty::BoundVariableKind;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            BoundVariableKind::Ty(kind) => rustc_ty::BoundVariableKind::Ty(match kind {
-                BoundTyKind::Anon => rustc_ty::BoundTyKind::Anon,
-                BoundTyKind::Param(def, _symbol) => {
-                    rustc_ty::BoundTyKind::Param(def.0.internal(tables, tcx))
-                }
-            }),
-            BoundVariableKind::Region(kind) => rustc_ty::BoundVariableKind::Region(match kind {
-                BoundRegionKind::BrAnon => rustc_ty::BoundRegionKind::Anon,
-                BoundRegionKind::BrNamed(def, _symbol) => {
-                    rustc_ty::BoundRegionKind::Named(def.0.internal(tables, tcx))
-                }
-                BoundRegionKind::BrEnv => rustc_ty::BoundRegionKind::ClosureEnv,
-            }),
-            BoundVariableKind::Const => rustc_ty::BoundVariableKind::Const,
-        }
-    }
-}
-
-impl RustcInternal for DynKind {
-    type T<'tcx> = rustc_ty::DynKind;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            DynKind::Dyn => rustc_ty::DynKind::Dyn,
-        }
-    }
-}
-
-impl RustcInternal for ExistentialPredicate {
-    type T<'tcx> = rustc_ty::ExistentialPredicate<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            ExistentialPredicate::Trait(trait_ref) => {
-                rustc_ty::ExistentialPredicate::Trait(trait_ref.internal(tables, tcx))
-            }
-            ExistentialPredicate::Projection(proj) => {
-                rustc_ty::ExistentialPredicate::Projection(proj.internal(tables, tcx))
-            }
-            ExistentialPredicate::AutoTrait(trait_def) => {
-                rustc_ty::ExistentialPredicate::AutoTrait(trait_def.0.internal(tables, tcx))
-            }
-        }
-    }
-}
-
-impl RustcInternal for ExistentialProjection {
-    type T<'tcx> = rustc_ty::ExistentialProjection<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        use crate::unstable::internal_cx::SmirExistentialProjection;
-        tcx.new_from_args(
-            self.def_id.0.internal(tables, tcx),
-            self.generic_args.internal(tables, tcx),
-            self.term.internal(tables, tcx),
-        )
-    }
-}
-
-impl RustcInternal for TermKind {
-    type T<'tcx> = rustc_ty::Term<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            TermKind::Type(ty) => ty.internal(tables, tcx).into(),
-            TermKind::Const(cnst) => cnst.internal(tables, tcx).into(),
-        }
-    }
-}
-
-impl RustcInternal for ExistentialTraitRef {
-    type T<'tcx> = rustc_ty::ExistentialTraitRef<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        use crate::unstable::internal_cx::SmirExistentialTraitRef;
-        tcx.new_from_args(
-            self.def_id.0.internal(tables, tcx),
-            self.generic_args.internal(tables, tcx),
-        )
-    }
-}
-
-impl RustcInternal for TraitRef {
-    type T<'tcx> = rustc_ty::TraitRef<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        use crate::unstable::internal_cx::SmirTraitRef;
-        tcx.new_from_args(self.def_id.0.internal(tables, tcx), self.args().internal(tables, tcx))
-    }
-}
-
-impl RustcInternal for AllocId {
-    type T<'tcx> = rustc_middle::mir::interpret::AllocId;
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        tcx.lift(tables.alloc_ids[*self]).unwrap()
-    }
-}
-
-impl RustcInternal for ClosureKind {
-    type T<'tcx> = rustc_ty::ClosureKind;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            ClosureKind::Fn => rustc_ty::ClosureKind::Fn,
-            ClosureKind::FnMut => rustc_ty::ClosureKind::FnMut,
-            ClosureKind::FnOnce => rustc_ty::ClosureKind::FnOnce,
-        }
-    }
-}
-
-impl RustcInternal for AdtDef {
-    type T<'tcx> = rustc_ty::AdtDef<'tcx>;
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        InternalCx::adt_def(tcx, self.0.internal(tables, tcx))
-    }
-}
-
-impl RustcInternal for Abi {
-    type T<'tcx> = rustc_abi::ExternAbi;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match *self {
-            Abi::Rust => rustc_abi::ExternAbi::Rust,
-            Abi::C { unwind } => rustc_abi::ExternAbi::C { unwind },
-            Abi::Cdecl { unwind } => rustc_abi::ExternAbi::Cdecl { unwind },
-            Abi::Stdcall { unwind } => rustc_abi::ExternAbi::Stdcall { unwind },
-            Abi::Fastcall { unwind } => rustc_abi::ExternAbi::Fastcall { unwind },
-            Abi::Vectorcall { unwind } => rustc_abi::ExternAbi::Vectorcall { unwind },
-            Abi::Thiscall { unwind } => rustc_abi::ExternAbi::Thiscall { unwind },
-            Abi::Aapcs { unwind } => rustc_abi::ExternAbi::Aapcs { unwind },
-            Abi::CCmseNonSecureCall => rustc_abi::ExternAbi::CmseNonSecureCall,
-            Abi::CCmseNonSecureEntry => rustc_abi::ExternAbi::CmseNonSecureEntry,
-            Abi::Win64 { unwind } => rustc_abi::ExternAbi::Win64 { unwind },
-            Abi::SysV64 { unwind } => rustc_abi::ExternAbi::SysV64 { unwind },
-            Abi::PtxKernel => rustc_abi::ExternAbi::PtxKernel,
-            Abi::Msp430Interrupt => rustc_abi::ExternAbi::Msp430Interrupt,
-            Abi::X86Interrupt => rustc_abi::ExternAbi::X86Interrupt,
-            Abi::GpuKernel => rustc_abi::ExternAbi::GpuKernel,
-            Abi::EfiApi => rustc_abi::ExternAbi::EfiApi,
-            Abi::AvrInterrupt => rustc_abi::ExternAbi::AvrInterrupt,
-            Abi::AvrNonBlockingInterrupt => rustc_abi::ExternAbi::AvrNonBlockingInterrupt,
-            Abi::System { unwind } => rustc_abi::ExternAbi::System { unwind },
-            Abi::RustCall => rustc_abi::ExternAbi::RustCall,
-            Abi::Unadjusted => rustc_abi::ExternAbi::Unadjusted,
-            Abi::RustCold => rustc_abi::ExternAbi::RustCold,
-            Abi::RustInvalid => rustc_abi::ExternAbi::RustInvalid,
-            Abi::RiscvInterruptM => rustc_abi::ExternAbi::RiscvInterruptM,
-            Abi::RiscvInterruptS => rustc_abi::ExternAbi::RiscvInterruptS,
-            Abi::Custom => rustc_abi::ExternAbi::Custom,
-        }
-    }
-}
-
-impl RustcInternal for Safety {
-    type T<'tcx> = rustc_hir::Safety;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            Safety::Unsafe => rustc_hir::Safety::Unsafe,
-            Safety::Safe => rustc_hir::Safety::Safe,
-        }
-    }
-}
-impl RustcInternal for Span {
-    type T<'tcx> = rustc_span::Span;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        tables.spans[*self]
-    }
-}
-
-impl RustcInternal for Layout {
-    type T<'tcx> = rustc_abi::Layout<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        tcx.lift(tables.layouts[*self]).unwrap()
-    }
-}
-
-impl RustcInternal for Place {
-    type T<'tcx> = rustc_middle::mir::Place<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        rustc_middle::mir::Place {
-            local: rustc_middle::mir::Local::from_usize(self.local),
-            projection: tcx.mk_place_elems(&self.projection.internal(tables, tcx)),
-        }
-    }
-}
-
-impl RustcInternal for ProjectionElem {
-    type T<'tcx> = rustc_middle::mir::PlaceElem<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            ProjectionElem::Deref => rustc_middle::mir::PlaceElem::Deref,
-            ProjectionElem::Field(idx, ty) => {
-                rustc_middle::mir::PlaceElem::Field((*idx).into(), ty.internal(tables, tcx))
-            }
-            ProjectionElem::Index(idx) => rustc_middle::mir::PlaceElem::Index((*idx).into()),
-            ProjectionElem::ConstantIndex { offset, min_length, from_end } => {
-                rustc_middle::mir::PlaceElem::ConstantIndex {
-                    offset: *offset,
-                    min_length: *min_length,
-                    from_end: *from_end,
-                }
-            }
-            ProjectionElem::Subslice { from, to, from_end } => {
-                rustc_middle::mir::PlaceElem::Subslice { from: *from, to: *to, from_end: *from_end }
-            }
-            ProjectionElem::Downcast(idx) => {
-                rustc_middle::mir::PlaceElem::Downcast(None, idx.internal(tables, tcx))
-            }
-            ProjectionElem::OpaqueCast(ty) => {
-                rustc_middle::mir::PlaceElem::OpaqueCast(ty.internal(tables, tcx))
-            }
-            ProjectionElem::Subtype(ty) => {
-                rustc_middle::mir::PlaceElem::Subtype(ty.internal(tables, tcx))
-            }
-        }
-    }
-}
-
-impl RustcInternal for BinOp {
-    type T<'tcx> = rustc_middle::mir::BinOp;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            BinOp::Add => rustc_middle::mir::BinOp::Add,
-            BinOp::AddUnchecked => rustc_middle::mir::BinOp::AddUnchecked,
-            BinOp::Sub => rustc_middle::mir::BinOp::Sub,
-            BinOp::SubUnchecked => rustc_middle::mir::BinOp::SubUnchecked,
-            BinOp::Mul => rustc_middle::mir::BinOp::Mul,
-            BinOp::MulUnchecked => rustc_middle::mir::BinOp::MulUnchecked,
-            BinOp::Div => rustc_middle::mir::BinOp::Div,
-            BinOp::Rem => rustc_middle::mir::BinOp::Rem,
-            BinOp::BitXor => rustc_middle::mir::BinOp::BitXor,
-            BinOp::BitAnd => rustc_middle::mir::BinOp::BitAnd,
-            BinOp::BitOr => rustc_middle::mir::BinOp::BitOr,
-            BinOp::Shl => rustc_middle::mir::BinOp::Shl,
-            BinOp::ShlUnchecked => rustc_middle::mir::BinOp::ShlUnchecked,
-            BinOp::Shr => rustc_middle::mir::BinOp::Shr,
-            BinOp::ShrUnchecked => rustc_middle::mir::BinOp::ShrUnchecked,
-            BinOp::Eq => rustc_middle::mir::BinOp::Eq,
-            BinOp::Lt => rustc_middle::mir::BinOp::Lt,
-            BinOp::Le => rustc_middle::mir::BinOp::Le,
-            BinOp::Ne => rustc_middle::mir::BinOp::Ne,
-            BinOp::Ge => rustc_middle::mir::BinOp::Ge,
-            BinOp::Gt => rustc_middle::mir::BinOp::Gt,
-            BinOp::Cmp => rustc_middle::mir::BinOp::Cmp,
-            BinOp::Offset => rustc_middle::mir::BinOp::Offset,
-        }
-    }
-}
-
-impl RustcInternal for UnOp {
-    type T<'tcx> = rustc_middle::mir::UnOp;
-
-    fn internal<'tcx>(
-        &self,
-        _tables: &mut Tables<'_, BridgeTys>,
-        _tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        match self {
-            UnOp::Not => rustc_middle::mir::UnOp::Not,
-            UnOp::Neg => rustc_middle::mir::UnOp::Neg,
-            UnOp::PtrMetadata => rustc_middle::mir::UnOp::PtrMetadata,
-        }
-    }
-}
-
-impl<T> RustcInternal for &T
-where
-    T: RustcInternal,
-{
-    type T<'tcx> = T::T<'tcx>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        (*self).internal(tables, tcx)
-    }
-}
-
-impl<T> RustcInternal for Option<T>
-where
-    T: RustcInternal,
-{
-    type T<'tcx> = Option<T::T<'tcx>>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        self.as_ref().map(|inner| inner.internal(tables, tcx))
-    }
-}
-
-impl<T> RustcInternal for Vec<T>
-where
-    T: RustcInternal,
-{
-    type T<'tcx> = Vec<T::T<'tcx>>;
-
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx> {
-        self.iter().map(|e| e.internal(tables, tcx)).collect()
-    }
-}
diff --git a/compiler/stable_mir/src/unstable/convert/mod.rs b/compiler/stable_mir/src/unstable/convert/mod.rs
deleted file mode 100644
index aad92325861..00000000000
--- a/compiler/stable_mir/src/unstable/convert/mod.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-//! This module holds the logic to convert rustc internal ADTs into stable mir ADTs.
-//!
-//! The conversion from stable to internal is not meant to be complete,
-//! and it should be added as when needed to be passed as input to rustc_smir functions.
-//!
-//! For contributors, please make sure to avoid calling rustc's internal functions and queries.
-//! These should be done via `rustc_smir` APIs, but it's possible to access ADT fields directly.
-
-use std::ops::RangeInclusive;
-
-use rustc_smir::Tables;
-use rustc_smir::context::SmirCtxt;
-
-use super::Stable;
-use crate::compiler_interface::BridgeTys;
-
-mod internal;
-mod stable;
-
-impl<'tcx, T> Stable<'tcx> for &T
-where
-    T: Stable<'tcx>,
-{
-    type T = T::T;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        (*self).stable(tables, cx)
-    }
-}
-
-impl<'tcx, T> Stable<'tcx> for Option<T>
-where
-    T: Stable<'tcx>,
-{
-    type T = Option<T::T>;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        self.as_ref().map(|value| value.stable(tables, cx))
-    }
-}
-
-impl<'tcx, T, E> Stable<'tcx> for Result<T, E>
-where
-    T: Stable<'tcx>,
-    E: Stable<'tcx>,
-{
-    type T = Result<T::T, E::T>;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            Ok(val) => Ok(val.stable(tables, cx)),
-            Err(error) => Err(error.stable(tables, cx)),
-        }
-    }
-}
-
-impl<'tcx, T> Stable<'tcx> for &[T]
-where
-    T: Stable<'tcx>,
-{
-    type T = Vec<T::T>;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        self.iter().map(|e| e.stable(tables, cx)).collect()
-    }
-}
-
-impl<'tcx, T, U> Stable<'tcx> for (T, U)
-where
-    T: Stable<'tcx>,
-    U: Stable<'tcx>,
-{
-    type T = (T::T, U::T);
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        (self.0.stable(tables, cx), self.1.stable(tables, cx))
-    }
-}
-
-impl<'tcx, T> Stable<'tcx> for RangeInclusive<T>
-where
-    T: Stable<'tcx>,
-{
-    type T = RangeInclusive<T::T>;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        RangeInclusive::new(self.start().stable(tables, cx), self.end().stable(tables, cx))
-    }
-}
diff --git a/compiler/stable_mir/src/unstable/convert/stable/abi.rs b/compiler/stable_mir/src/unstable/convert/stable/abi.rs
deleted file mode 100644
index 8fdaa69c305..00000000000
--- a/compiler/stable_mir/src/unstable/convert/stable/abi.rs
+++ /dev/null
@@ -1,410 +0,0 @@
-//! Conversion of internal Rust compiler `rustc_target` and `rustc_abi` items to stable ones.
-
-#![allow(rustc::usage_of_qualified_ty)]
-
-use rustc_abi::{ArmCall, CanonAbi, InterruptKind, X86Call};
-use rustc_middle::ty;
-use rustc_smir::Tables;
-use rustc_smir::context::SmirCtxt;
-use rustc_target::callconv;
-
-use crate::abi::{
-    AddressSpace, ArgAbi, CallConvention, FieldsShape, FloatLength, FnAbi, IntegerLength,
-    IntegerType, Layout, LayoutShape, PassMode, Primitive, ReprFlags, ReprOptions, Scalar,
-    TagEncoding, TyAndLayout, ValueAbi, VariantsShape, WrappingRange,
-};
-use crate::compiler_interface::BridgeTys;
-use crate::target::MachineSize as Size;
-use crate::ty::{Align, VariantIdx};
-use crate::unstable::Stable;
-use crate::{IndexedVal, opaque};
-
-impl<'tcx> Stable<'tcx> for rustc_abi::VariantIdx {
-    type T = VariantIdx;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        VariantIdx::to_val(self.as_usize())
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::Endian {
-    type T = crate::target::Endian;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            rustc_abi::Endian::Little => crate::target::Endian::Little,
-            rustc_abi::Endian::Big => crate::target::Endian::Big,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::TyAndLayout<'tcx, ty::Ty<'tcx>> {
-    type T = TyAndLayout;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        TyAndLayout { ty: self.ty.stable(tables, cx), layout: self.layout.stable(tables, cx) }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::Layout<'tcx> {
-    type T = Layout;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        tables.layout_id(cx.lift(*self).unwrap())
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::LayoutData<rustc_abi::FieldIdx, rustc_abi::VariantIdx> {
-    type T = LayoutShape;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        LayoutShape {
-            fields: self.fields.stable(tables, cx),
-            variants: self.variants.stable(tables, cx),
-            abi: self.backend_repr.stable(tables, cx),
-            abi_align: self.align.abi.stable(tables, cx),
-            size: self.size.stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for callconv::FnAbi<'tcx, ty::Ty<'tcx>> {
-    type T = FnAbi;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        assert!(self.args.len() >= self.fixed_count as usize);
-        assert!(!self.c_variadic || matches!(self.conv, CanonAbi::C));
-        FnAbi {
-            args: self.args.as_ref().stable(tables, cx),
-            ret: self.ret.stable(tables, cx),
-            fixed_count: self.fixed_count,
-            conv: self.conv.stable(tables, cx),
-            c_variadic: self.c_variadic,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for callconv::ArgAbi<'tcx, ty::Ty<'tcx>> {
-    type T = ArgAbi;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        ArgAbi {
-            ty: self.layout.ty.stable(tables, cx),
-            layout: self.layout.layout.stable(tables, cx),
-            mode: self.mode.stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for CanonAbi {
-    type T = CallConvention;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            CanonAbi::C => CallConvention::C,
-            CanonAbi::Rust => CallConvention::Rust,
-            CanonAbi::RustCold => CallConvention::Cold,
-            CanonAbi::Custom => CallConvention::Custom,
-            CanonAbi::Arm(arm_call) => match arm_call {
-                ArmCall::Aapcs => CallConvention::ArmAapcs,
-                ArmCall::CCmseNonSecureCall => CallConvention::CCmseNonSecureCall,
-                ArmCall::CCmseNonSecureEntry => CallConvention::CCmseNonSecureEntry,
-            },
-            CanonAbi::GpuKernel => CallConvention::GpuKernel,
-            CanonAbi::Interrupt(interrupt_kind) => match interrupt_kind {
-                InterruptKind::Avr => CallConvention::AvrInterrupt,
-                InterruptKind::AvrNonBlocking => CallConvention::AvrNonBlockingInterrupt,
-                InterruptKind::Msp430 => CallConvention::Msp430Intr,
-                InterruptKind::RiscvMachine | InterruptKind::RiscvSupervisor => {
-                    CallConvention::RiscvInterrupt
-                }
-                InterruptKind::X86 => CallConvention::X86Intr,
-            },
-            CanonAbi::X86(x86_call) => match x86_call {
-                X86Call::Fastcall => CallConvention::X86Fastcall,
-                X86Call::Stdcall => CallConvention::X86Stdcall,
-                X86Call::SysV64 => CallConvention::X86_64SysV,
-                X86Call::Thiscall => CallConvention::X86ThisCall,
-                X86Call::Vectorcall => CallConvention::X86VectorCall,
-                X86Call::Win64 => CallConvention::X86_64Win64,
-            },
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for callconv::PassMode {
-    type T = PassMode;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            callconv::PassMode::Ignore => PassMode::Ignore,
-            callconv::PassMode::Direct(attr) => PassMode::Direct(opaque(attr)),
-            callconv::PassMode::Pair(first, second) => {
-                PassMode::Pair(opaque(first), opaque(second))
-            }
-            callconv::PassMode::Cast { pad_i32, cast } => {
-                PassMode::Cast { pad_i32: *pad_i32, cast: opaque(cast) }
-            }
-            callconv::PassMode::Indirect { attrs, meta_attrs, on_stack } => PassMode::Indirect {
-                attrs: opaque(attrs),
-                meta_attrs: opaque(meta_attrs),
-                on_stack: *on_stack,
-            },
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape<rustc_abi::FieldIdx> {
-    type T = FieldsShape;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            rustc_abi::FieldsShape::Primitive => FieldsShape::Primitive,
-            rustc_abi::FieldsShape::Union(count) => FieldsShape::Union(*count),
-            rustc_abi::FieldsShape::Array { stride, count } => {
-                FieldsShape::Array { stride: stride.stable(tables, cx), count: *count }
-            }
-            rustc_abi::FieldsShape::Arbitrary { offsets, .. } => {
-                FieldsShape::Arbitrary { offsets: offsets.iter().as_slice().stable(tables, cx) }
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::Variants<rustc_abi::FieldIdx, rustc_abi::VariantIdx> {
-    type T = VariantsShape;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            rustc_abi::Variants::Single { index } => {
-                VariantsShape::Single { index: index.stable(tables, cx) }
-            }
-            rustc_abi::Variants::Empty => VariantsShape::Empty,
-            rustc_abi::Variants::Multiple { tag, tag_encoding, tag_field, variants } => {
-                VariantsShape::Multiple {
-                    tag: tag.stable(tables, cx),
-                    tag_encoding: tag_encoding.stable(tables, cx),
-                    tag_field: tag_field.stable(tables, cx),
-                    variants: variants.iter().as_slice().stable(tables, cx),
-                }
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::TagEncoding<rustc_abi::VariantIdx> {
-    type T = TagEncoding;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            rustc_abi::TagEncoding::Direct => TagEncoding::Direct,
-            rustc_abi::TagEncoding::Niche { untagged_variant, niche_variants, niche_start } => {
-                TagEncoding::Niche {
-                    untagged_variant: untagged_variant.stable(tables, cx),
-                    niche_variants: niche_variants.stable(tables, cx),
-                    niche_start: *niche_start,
-                }
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::BackendRepr {
-    type T = ValueAbi;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match *self {
-            rustc_abi::BackendRepr::Scalar(scalar) => ValueAbi::Scalar(scalar.stable(tables, cx)),
-            rustc_abi::BackendRepr::ScalarPair(first, second) => {
-                ValueAbi::ScalarPair(first.stable(tables, cx), second.stable(tables, cx))
-            }
-            rustc_abi::BackendRepr::SimdVector { element, count } => {
-                ValueAbi::Vector { element: element.stable(tables, cx), count }
-            }
-            rustc_abi::BackendRepr::Memory { sized } => ValueAbi::Aggregate { sized },
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::Size {
-    type T = Size;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        Size::from_bits(self.bits_usize())
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::Align {
-    type T = Align;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        self.bytes()
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::Scalar {
-    type T = Scalar;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            rustc_abi::Scalar::Initialized { value, valid_range } => Scalar::Initialized {
-                value: value.stable(tables, cx),
-                valid_range: valid_range.stable(tables, cx),
-            },
-            rustc_abi::Scalar::Union { value } => Scalar::Union { value: value.stable(tables, cx) },
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::Primitive {
-    type T = Primitive;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            rustc_abi::Primitive::Int(length, signed) => {
-                Primitive::Int { length: length.stable(tables, cx), signed: *signed }
-            }
-            rustc_abi::Primitive::Float(length) => {
-                Primitive::Float { length: length.stable(tables, cx) }
-            }
-            rustc_abi::Primitive::Pointer(space) => Primitive::Pointer(space.stable(tables, cx)),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::AddressSpace {
-    type T = AddressSpace;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        AddressSpace(self.0)
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::Integer {
-    type T = IntegerLength;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            rustc_abi::Integer::I8 => IntegerLength::I8,
-            rustc_abi::Integer::I16 => IntegerLength::I16,
-            rustc_abi::Integer::I32 => IntegerLength::I32,
-            rustc_abi::Integer::I64 => IntegerLength::I64,
-            rustc_abi::Integer::I128 => IntegerLength::I128,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::Float {
-    type T = FloatLength;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            rustc_abi::Float::F16 => FloatLength::F16,
-            rustc_abi::Float::F32 => FloatLength::F32,
-            rustc_abi::Float::F64 => FloatLength::F64,
-            rustc_abi::Float::F128 => FloatLength::F128,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::WrappingRange {
-    type T = WrappingRange;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        WrappingRange { start: self.start, end: self.end }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::ReprFlags {
-    type T = ReprFlags;
-
-    fn stable<'cx>(
-        &self,
-        _tables: &mut Tables<'cx, BridgeTys>,
-        _cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        ReprFlags {
-            is_simd: self.intersects(Self::IS_SIMD),
-            is_c: self.intersects(Self::IS_C),
-            is_transparent: self.intersects(Self::IS_TRANSPARENT),
-            is_linear: self.intersects(Self::IS_LINEAR),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::IntegerType {
-    type T = IntegerType;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            rustc_abi::IntegerType::Pointer(signed) => IntegerType::Pointer { is_signed: *signed },
-            rustc_abi::IntegerType::Fixed(integer, signed) => {
-                IntegerType::Fixed { length: integer.stable(tables, cx), is_signed: *signed }
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::ReprOptions {
-    type T = ReprOptions;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        ReprOptions {
-            int: self.int.map(|int| int.stable(tables, cx)),
-            align: self.align.map(|align| align.stable(tables, cx)),
-            pack: self.pack.map(|pack| pack.stable(tables, cx)),
-            flags: self.flags.stable(tables, cx),
-        }
-    }
-}
diff --git a/compiler/stable_mir/src/unstable/convert/stable/mir.rs b/compiler/stable_mir/src/unstable/convert/stable/mir.rs
deleted file mode 100644
index ad39fc37600..00000000000
--- a/compiler/stable_mir/src/unstable/convert/stable/mir.rs
+++ /dev/null
@@ -1,936 +0,0 @@
-//! Conversion of internal Rust compiler `mir` items to stable ones.
-
-use rustc_middle::mir::mono::MonoItem;
-use rustc_middle::{bug, mir};
-use rustc_smir::Tables;
-use rustc_smir::bridge::SmirError;
-use rustc_smir::context::SmirCtxt;
-
-use crate::compiler_interface::BridgeTys;
-use crate::mir::alloc::GlobalAlloc;
-use crate::mir::{ConstOperand, Statement, UserTypeProjection, VarDebugInfoFragment};
-use crate::ty::{Allocation, ConstantKind, MirConst};
-use crate::unstable::Stable;
-use crate::{Error, alloc, opaque};
-
-impl<'tcx> Stable<'tcx> for mir::Body<'tcx> {
-    type T = crate::mir::Body;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        crate::mir::Body::new(
-            self.basic_blocks
-                .iter()
-                .map(|block| crate::mir::BasicBlock {
-                    terminator: block.terminator().stable(tables, cx),
-                    statements: block
-                        .statements
-                        .iter()
-                        .map(|statement| statement.stable(tables, cx))
-                        .collect(),
-                })
-                .collect(),
-            self.local_decls
-                .iter()
-                .map(|decl| crate::mir::LocalDecl {
-                    ty: decl.ty.stable(tables, cx),
-                    span: decl.source_info.span.stable(tables, cx),
-                    mutability: decl.mutability.stable(tables, cx),
-                })
-                .collect(),
-            self.arg_count,
-            self.var_debug_info.iter().map(|info| info.stable(tables, cx)).collect(),
-            self.spread_arg.stable(tables, cx),
-            self.span.stable(tables, cx),
-        )
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::VarDebugInfo<'tcx> {
-    type T = crate::mir::VarDebugInfo;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        crate::mir::VarDebugInfo {
-            name: self.name.to_string(),
-            source_info: self.source_info.stable(tables, cx),
-            composite: self.composite.as_ref().map(|composite| composite.stable(tables, cx)),
-            value: self.value.stable(tables, cx),
-            argument_index: self.argument_index,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::Statement<'tcx> {
-    type T = crate::mir::Statement;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        Statement {
-            kind: self.kind.stable(tables, cx),
-            span: self.source_info.span.stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::SourceInfo {
-    type T = crate::mir::SourceInfo;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        crate::mir::SourceInfo { span: self.span.stable(tables, cx), scope: self.scope.into() }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::VarDebugInfoFragment<'tcx> {
-    type T = crate::mir::VarDebugInfoFragment;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        VarDebugInfoFragment {
-            ty: self.ty.stable(tables, cx),
-            projection: self.projection.iter().map(|e| e.stable(tables, cx)).collect(),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::VarDebugInfoContents<'tcx> {
-    type T = crate::mir::VarDebugInfoContents;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            mir::VarDebugInfoContents::Place(place) => {
-                crate::mir::VarDebugInfoContents::Place(place.stable(tables, cx))
-            }
-            mir::VarDebugInfoContents::Const(const_operand) => {
-                let op = ConstOperand {
-                    span: const_operand.span.stable(tables, cx),
-                    user_ty: const_operand.user_ty.map(|index| index.as_usize()),
-                    const_: const_operand.const_.stable(tables, cx),
-                };
-                crate::mir::VarDebugInfoContents::Const(op)
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::StatementKind<'tcx> {
-    type T = crate::mir::StatementKind;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            mir::StatementKind::Assign(assign) => crate::mir::StatementKind::Assign(
-                assign.0.stable(tables, cx),
-                assign.1.stable(tables, cx),
-            ),
-            mir::StatementKind::FakeRead(fake_read_place) => crate::mir::StatementKind::FakeRead(
-                fake_read_place.0.stable(tables, cx),
-                fake_read_place.1.stable(tables, cx),
-            ),
-            mir::StatementKind::SetDiscriminant { place, variant_index } => {
-                crate::mir::StatementKind::SetDiscriminant {
-                    place: place.as_ref().stable(tables, cx),
-                    variant_index: variant_index.stable(tables, cx),
-                }
-            }
-            mir::StatementKind::Deinit(place) => {
-                crate::mir::StatementKind::Deinit(place.stable(tables, cx))
-            }
-
-            mir::StatementKind::StorageLive(place) => {
-                crate::mir::StatementKind::StorageLive(place.stable(tables, cx))
-            }
-
-            mir::StatementKind::StorageDead(place) => {
-                crate::mir::StatementKind::StorageDead(place.stable(tables, cx))
-            }
-            mir::StatementKind::Retag(retag, place) => {
-                crate::mir::StatementKind::Retag(retag.stable(tables, cx), place.stable(tables, cx))
-            }
-            mir::StatementKind::PlaceMention(place) => {
-                crate::mir::StatementKind::PlaceMention(place.stable(tables, cx))
-            }
-            mir::StatementKind::AscribeUserType(place_projection, variance) => {
-                crate::mir::StatementKind::AscribeUserType {
-                    place: place_projection.as_ref().0.stable(tables, cx),
-                    projections: place_projection.as_ref().1.stable(tables, cx),
-                    variance: variance.stable(tables, cx),
-                }
-            }
-            mir::StatementKind::Coverage(coverage) => {
-                crate::mir::StatementKind::Coverage(opaque(coverage))
-            }
-            mir::StatementKind::Intrinsic(intrinstic) => {
-                crate::mir::StatementKind::Intrinsic(intrinstic.stable(tables, cx))
-            }
-            mir::StatementKind::ConstEvalCounter => crate::mir::StatementKind::ConstEvalCounter,
-            // BackwardIncompatibleDropHint has no semantics, so it is translated to Nop.
-            mir::StatementKind::BackwardIncompatibleDropHint { .. } => {
-                crate::mir::StatementKind::Nop
-            }
-            mir::StatementKind::Nop => crate::mir::StatementKind::Nop,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> {
-    type T = crate::mir::Rvalue;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::mir::Rvalue::*;
-        match self {
-            Use(op) => crate::mir::Rvalue::Use(op.stable(tables, cx)),
-            Repeat(op, len) => {
-                let len = len.stable(tables, cx);
-                crate::mir::Rvalue::Repeat(op.stable(tables, cx), len)
-            }
-            Ref(region, kind, place) => crate::mir::Rvalue::Ref(
-                region.stable(tables, cx),
-                kind.stable(tables, cx),
-                place.stable(tables, cx),
-            ),
-            ThreadLocalRef(def_id) => {
-                crate::mir::Rvalue::ThreadLocalRef(tables.crate_item(*def_id))
-            }
-            RawPtr(mutability, place) => crate::mir::Rvalue::AddressOf(
-                mutability.stable(tables, cx),
-                place.stable(tables, cx),
-            ),
-            Len(place) => crate::mir::Rvalue::Len(place.stable(tables, cx)),
-            Cast(cast_kind, op, ty) => crate::mir::Rvalue::Cast(
-                cast_kind.stable(tables, cx),
-                op.stable(tables, cx),
-                ty.stable(tables, cx),
-            ),
-            BinaryOp(bin_op, ops) => {
-                if let Some(bin_op) = bin_op.overflowing_to_wrapping() {
-                    crate::mir::Rvalue::CheckedBinaryOp(
-                        bin_op.stable(tables, cx),
-                        ops.0.stable(tables, cx),
-                        ops.1.stable(tables, cx),
-                    )
-                } else {
-                    crate::mir::Rvalue::BinaryOp(
-                        bin_op.stable(tables, cx),
-                        ops.0.stable(tables, cx),
-                        ops.1.stable(tables, cx),
-                    )
-                }
-            }
-            NullaryOp(null_op, ty) => {
-                crate::mir::Rvalue::NullaryOp(null_op.stable(tables, cx), ty.stable(tables, cx))
-            }
-            UnaryOp(un_op, op) => {
-                crate::mir::Rvalue::UnaryOp(un_op.stable(tables, cx), op.stable(tables, cx))
-            }
-            Discriminant(place) => crate::mir::Rvalue::Discriminant(place.stable(tables, cx)),
-            Aggregate(agg_kind, operands) => {
-                let operands = operands.iter().map(|op| op.stable(tables, cx)).collect();
-                crate::mir::Rvalue::Aggregate(agg_kind.stable(tables, cx), operands)
-            }
-            ShallowInitBox(op, ty) => {
-                crate::mir::Rvalue::ShallowInitBox(op.stable(tables, cx), ty.stable(tables, cx))
-            }
-            CopyForDeref(place) => crate::mir::Rvalue::CopyForDeref(place.stable(tables, cx)),
-            WrapUnsafeBinder(..) => todo!("FIXME(unsafe_binders):"),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::Mutability {
-    type T = crate::mir::Mutability;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_hir::Mutability::*;
-        match *self {
-            Not => crate::mir::Mutability::Not,
-            Mut => crate::mir::Mutability::Mut,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::RawPtrKind {
-    type T = crate::mir::RawPtrKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use mir::RawPtrKind::*;
-        match *self {
-            Const => crate::mir::RawPtrKind::Const,
-            Mut => crate::mir::RawPtrKind::Mut,
-            FakeForPtrMetadata => crate::mir::RawPtrKind::FakeForPtrMetadata,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::BorrowKind {
-    type T = crate::mir::BorrowKind;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::mir::BorrowKind::*;
-        match *self {
-            Shared => crate::mir::BorrowKind::Shared,
-            Fake(kind) => crate::mir::BorrowKind::Fake(kind.stable(tables, cx)),
-            Mut { kind } => crate::mir::BorrowKind::Mut { kind: kind.stable(tables, cx) },
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::MutBorrowKind {
-    type T = crate::mir::MutBorrowKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_middle::mir::MutBorrowKind::*;
-        match *self {
-            Default => crate::mir::MutBorrowKind::Default,
-            TwoPhaseBorrow => crate::mir::MutBorrowKind::TwoPhaseBorrow,
-            ClosureCapture => crate::mir::MutBorrowKind::ClosureCapture,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::FakeBorrowKind {
-    type T = crate::mir::FakeBorrowKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_middle::mir::FakeBorrowKind::*;
-        match *self {
-            Deep => crate::mir::FakeBorrowKind::Deep,
-            Shallow => crate::mir::FakeBorrowKind::Shallow,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::NullOp<'tcx> {
-    type T = crate::mir::NullOp;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::mir::NullOp::*;
-        match self {
-            SizeOf => crate::mir::NullOp::SizeOf,
-            AlignOf => crate::mir::NullOp::AlignOf,
-            OffsetOf(indices) => crate::mir::NullOp::OffsetOf(
-                indices.iter().map(|idx| idx.stable(tables, cx)).collect(),
-            ),
-            UbChecks => crate::mir::NullOp::UbChecks,
-            ContractChecks => crate::mir::NullOp::ContractChecks,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::CastKind {
-    type T = crate::mir::CastKind;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::mir::CastKind::*;
-        match self {
-            PointerExposeProvenance => crate::mir::CastKind::PointerExposeAddress,
-            PointerWithExposedProvenance => crate::mir::CastKind::PointerWithExposedProvenance,
-            PointerCoercion(c, _) => crate::mir::CastKind::PointerCoercion(c.stable(tables, cx)),
-            IntToInt => crate::mir::CastKind::IntToInt,
-            FloatToInt => crate::mir::CastKind::FloatToInt,
-            FloatToFloat => crate::mir::CastKind::FloatToFloat,
-            IntToFloat => crate::mir::CastKind::IntToFloat,
-            PtrToPtr => crate::mir::CastKind::PtrToPtr,
-            FnPtrToPtr => crate::mir::CastKind::FnPtrToPtr,
-            Transmute => crate::mir::CastKind::Transmute,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::FakeReadCause {
-    type T = crate::mir::FakeReadCause;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_middle::mir::FakeReadCause::*;
-        match self {
-            ForMatchGuard => crate::mir::FakeReadCause::ForMatchGuard,
-            ForMatchedPlace(local_def_id) => {
-                crate::mir::FakeReadCause::ForMatchedPlace(opaque(local_def_id))
-            }
-            ForGuardBinding => crate::mir::FakeReadCause::ForGuardBinding,
-            ForLet(local_def_id) => crate::mir::FakeReadCause::ForLet(opaque(local_def_id)),
-            ForIndex => crate::mir::FakeReadCause::ForIndex,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::Operand<'tcx> {
-    type T = crate::mir::Operand;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::mir::Operand::*;
-        match self {
-            Copy(place) => crate::mir::Operand::Copy(place.stable(tables, cx)),
-            Move(place) => crate::mir::Operand::Move(place.stable(tables, cx)),
-            Constant(c) => crate::mir::Operand::Constant(c.stable(tables, cx)),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::ConstOperand<'tcx> {
-    type T = crate::mir::ConstOperand;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        crate::mir::ConstOperand {
-            span: self.span.stable(tables, cx),
-            user_ty: self.user_ty.map(|u| u.as_usize()).or(None),
-            const_: self.const_.stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::Place<'tcx> {
-    type T = crate::mir::Place;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        crate::mir::Place {
-            local: self.local.as_usize(),
-            projection: self.projection.iter().map(|e| e.stable(tables, cx)).collect(),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::PlaceElem<'tcx> {
-    type T = crate::mir::ProjectionElem;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::mir::ProjectionElem::*;
-        match self {
-            Deref => crate::mir::ProjectionElem::Deref,
-            Field(idx, ty) => {
-                crate::mir::ProjectionElem::Field(idx.stable(tables, cx), ty.stable(tables, cx))
-            }
-            Index(local) => crate::mir::ProjectionElem::Index(local.stable(tables, cx)),
-            ConstantIndex { offset, min_length, from_end } => {
-                crate::mir::ProjectionElem::ConstantIndex {
-                    offset: *offset,
-                    min_length: *min_length,
-                    from_end: *from_end,
-                }
-            }
-            Subslice { from, to, from_end } => {
-                crate::mir::ProjectionElem::Subslice { from: *from, to: *to, from_end: *from_end }
-            }
-            // MIR includes an `Option<Symbol>` argument for `Downcast` that is the name of the
-            // variant, used for printing MIR. However this information should also be accessible
-            // via a lookup using the `VariantIdx`. The `Option<Symbol>` argument is therefore
-            // dropped when converting to Stable MIR. A brief justification for this decision can be
-            // found at https://github.com/rust-lang/rust/pull/117517#issuecomment-1811683486
-            Downcast(_, idx) => crate::mir::ProjectionElem::Downcast(idx.stable(tables, cx)),
-            OpaqueCast(ty) => crate::mir::ProjectionElem::OpaqueCast(ty.stable(tables, cx)),
-            Subtype(ty) => crate::mir::ProjectionElem::Subtype(ty.stable(tables, cx)),
-            UnwrapUnsafeBinder(..) => todo!("FIXME(unsafe_binders):"),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::UserTypeProjection {
-    type T = crate::mir::UserTypeProjection;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        UserTypeProjection { base: self.base.as_usize(), projection: opaque(&self.projs) }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::Local {
-    type T = crate::mir::Local;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        self.as_usize()
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::RetagKind {
-    type T = crate::mir::RetagKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_middle::mir::RetagKind;
-        match self {
-            RetagKind::FnEntry => crate::mir::RetagKind::FnEntry,
-            RetagKind::TwoPhase => crate::mir::RetagKind::TwoPhase,
-            RetagKind::Raw => crate::mir::RetagKind::Raw,
-            RetagKind::Default => crate::mir::RetagKind::Default,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::UnwindAction {
-    type T = crate::mir::UnwindAction;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_middle::mir::UnwindAction;
-        match self {
-            UnwindAction::Continue => crate::mir::UnwindAction::Continue,
-            UnwindAction::Unreachable => crate::mir::UnwindAction::Unreachable,
-            UnwindAction::Terminate(_) => crate::mir::UnwindAction::Terminate,
-            UnwindAction::Cleanup(bb) => crate::mir::UnwindAction::Cleanup(bb.as_usize()),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::NonDivergingIntrinsic<'tcx> {
-    type T = crate::mir::NonDivergingIntrinsic;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::mir::NonDivergingIntrinsic;
-
-        use crate::mir::CopyNonOverlapping;
-        match self {
-            NonDivergingIntrinsic::Assume(op) => {
-                crate::mir::NonDivergingIntrinsic::Assume(op.stable(tables, cx))
-            }
-            NonDivergingIntrinsic::CopyNonOverlapping(copy_non_overlapping) => {
-                crate::mir::NonDivergingIntrinsic::CopyNonOverlapping(CopyNonOverlapping {
-                    src: copy_non_overlapping.src.stable(tables, cx),
-                    dst: copy_non_overlapping.dst.stable(tables, cx),
-                    count: copy_non_overlapping.count.stable(tables, cx),
-                })
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::AssertMessage<'tcx> {
-    type T = crate::mir::AssertMessage;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::mir::AssertKind;
-        match self {
-            AssertKind::BoundsCheck { len, index } => crate::mir::AssertMessage::BoundsCheck {
-                len: len.stable(tables, cx),
-                index: index.stable(tables, cx),
-            },
-            AssertKind::Overflow(bin_op, op1, op2) => crate::mir::AssertMessage::Overflow(
-                bin_op.stable(tables, cx),
-                op1.stable(tables, cx),
-                op2.stable(tables, cx),
-            ),
-            AssertKind::OverflowNeg(op) => {
-                crate::mir::AssertMessage::OverflowNeg(op.stable(tables, cx))
-            }
-            AssertKind::DivisionByZero(op) => {
-                crate::mir::AssertMessage::DivisionByZero(op.stable(tables, cx))
-            }
-            AssertKind::RemainderByZero(op) => {
-                crate::mir::AssertMessage::RemainderByZero(op.stable(tables, cx))
-            }
-            AssertKind::ResumedAfterReturn(coroutine) => {
-                crate::mir::AssertMessage::ResumedAfterReturn(coroutine.stable(tables, cx))
-            }
-            AssertKind::ResumedAfterPanic(coroutine) => {
-                crate::mir::AssertMessage::ResumedAfterPanic(coroutine.stable(tables, cx))
-            }
-            AssertKind::ResumedAfterDrop(coroutine) => {
-                crate::mir::AssertMessage::ResumedAfterDrop(coroutine.stable(tables, cx))
-            }
-            AssertKind::MisalignedPointerDereference { required, found } => {
-                crate::mir::AssertMessage::MisalignedPointerDereference {
-                    required: required.stable(tables, cx),
-                    found: found.stable(tables, cx),
-                }
-            }
-            AssertKind::NullPointerDereference => crate::mir::AssertMessage::NullPointerDereference,
-            AssertKind::InvalidEnumConstruction(source) => {
-                crate::mir::AssertMessage::InvalidEnumConstruction(source.stable(tables, cx))
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::BinOp {
-    type T = crate::mir::BinOp;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_middle::mir::BinOp;
-        match self {
-            BinOp::Add => crate::mir::BinOp::Add,
-            BinOp::AddUnchecked => crate::mir::BinOp::AddUnchecked,
-            BinOp::AddWithOverflow => bug!("AddWithOverflow should have been translated already"),
-            BinOp::Sub => crate::mir::BinOp::Sub,
-            BinOp::SubUnchecked => crate::mir::BinOp::SubUnchecked,
-            BinOp::SubWithOverflow => bug!("AddWithOverflow should have been translated already"),
-            BinOp::Mul => crate::mir::BinOp::Mul,
-            BinOp::MulUnchecked => crate::mir::BinOp::MulUnchecked,
-            BinOp::MulWithOverflow => bug!("AddWithOverflow should have been translated already"),
-            BinOp::Div => crate::mir::BinOp::Div,
-            BinOp::Rem => crate::mir::BinOp::Rem,
-            BinOp::BitXor => crate::mir::BinOp::BitXor,
-            BinOp::BitAnd => crate::mir::BinOp::BitAnd,
-            BinOp::BitOr => crate::mir::BinOp::BitOr,
-            BinOp::Shl => crate::mir::BinOp::Shl,
-            BinOp::ShlUnchecked => crate::mir::BinOp::ShlUnchecked,
-            BinOp::Shr => crate::mir::BinOp::Shr,
-            BinOp::ShrUnchecked => crate::mir::BinOp::ShrUnchecked,
-            BinOp::Eq => crate::mir::BinOp::Eq,
-            BinOp::Lt => crate::mir::BinOp::Lt,
-            BinOp::Le => crate::mir::BinOp::Le,
-            BinOp::Ne => crate::mir::BinOp::Ne,
-            BinOp::Ge => crate::mir::BinOp::Ge,
-            BinOp::Gt => crate::mir::BinOp::Gt,
-            BinOp::Cmp => crate::mir::BinOp::Cmp,
-            BinOp::Offset => crate::mir::BinOp::Offset,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::UnOp {
-    type T = crate::mir::UnOp;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_middle::mir::UnOp;
-        match self {
-            UnOp::Not => crate::mir::UnOp::Not,
-            UnOp::Neg => crate::mir::UnOp::Neg,
-            UnOp::PtrMetadata => crate::mir::UnOp::PtrMetadata,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::AggregateKind<'tcx> {
-    type T = crate::mir::AggregateKind;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            mir::AggregateKind::Array(ty) => {
-                crate::mir::AggregateKind::Array(ty.stable(tables, cx))
-            }
-            mir::AggregateKind::Tuple => crate::mir::AggregateKind::Tuple,
-            mir::AggregateKind::Adt(def_id, var_idx, generic_arg, user_ty_index, field_idx) => {
-                crate::mir::AggregateKind::Adt(
-                    tables.adt_def(*def_id),
-                    var_idx.stable(tables, cx),
-                    generic_arg.stable(tables, cx),
-                    user_ty_index.map(|idx| idx.index()),
-                    field_idx.map(|idx| idx.index()),
-                )
-            }
-            mir::AggregateKind::Closure(def_id, generic_arg) => crate::mir::AggregateKind::Closure(
-                tables.closure_def(*def_id),
-                generic_arg.stable(tables, cx),
-            ),
-            mir::AggregateKind::Coroutine(def_id, generic_arg) => {
-                crate::mir::AggregateKind::Coroutine(
-                    tables.coroutine_def(*def_id),
-                    generic_arg.stable(tables, cx),
-                    cx.coroutine_movability(*def_id).stable(tables, cx),
-                )
-            }
-            mir::AggregateKind::CoroutineClosure(def_id, generic_args) => {
-                crate::mir::AggregateKind::CoroutineClosure(
-                    tables.coroutine_closure_def(*def_id),
-                    generic_args.stable(tables, cx),
-                )
-            }
-            mir::AggregateKind::RawPtr(ty, mutability) => crate::mir::AggregateKind::RawPtr(
-                ty.stable(tables, cx),
-                mutability.stable(tables, cx),
-            ),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::InlineAsmOperand<'tcx> {
-    type T = crate::mir::InlineAsmOperand;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::mir::InlineAsmOperand;
-
-        let (in_value, out_place) = match self {
-            InlineAsmOperand::In { value, .. } => (Some(value.stable(tables, cx)), None),
-            InlineAsmOperand::Out { place, .. } => {
-                (None, place.map(|place| place.stable(tables, cx)))
-            }
-            InlineAsmOperand::InOut { in_value, out_place, .. } => {
-                (Some(in_value.stable(tables, cx)), out_place.map(|place| place.stable(tables, cx)))
-            }
-            InlineAsmOperand::Const { .. }
-            | InlineAsmOperand::SymFn { .. }
-            | InlineAsmOperand::SymStatic { .. }
-            | InlineAsmOperand::Label { .. } => (None, None),
-        };
-
-        crate::mir::InlineAsmOperand { in_value, out_place, raw_rpr: format!("{self:?}") }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
-    type T = crate::mir::Terminator;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::mir::Terminator;
-        Terminator {
-            kind: self.kind.stable(tables, cx),
-            span: self.source_info.span.stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> {
-    type T = crate::mir::TerminatorKind;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::mir::TerminatorKind;
-        match self {
-            mir::TerminatorKind::Goto { target } => {
-                TerminatorKind::Goto { target: target.as_usize() }
-            }
-            mir::TerminatorKind::SwitchInt { discr, targets } => TerminatorKind::SwitchInt {
-                discr: discr.stable(tables, cx),
-                targets: {
-                    let branches = targets.iter().map(|(val, target)| (val, target.as_usize()));
-                    crate::mir::SwitchTargets::new(
-                        branches.collect(),
-                        targets.otherwise().as_usize(),
-                    )
-                },
-            },
-            mir::TerminatorKind::UnwindResume => TerminatorKind::Resume,
-            mir::TerminatorKind::UnwindTerminate(_) => TerminatorKind::Abort,
-            mir::TerminatorKind::Return => TerminatorKind::Return,
-            mir::TerminatorKind::Unreachable => TerminatorKind::Unreachable,
-            mir::TerminatorKind::Drop {
-                place,
-                target,
-                unwind,
-                replace: _,
-                drop: _,
-                async_fut: _,
-            } => TerminatorKind::Drop {
-                place: place.stable(tables, cx),
-                target: target.as_usize(),
-                unwind: unwind.stable(tables, cx),
-            },
-            mir::TerminatorKind::Call {
-                func,
-                args,
-                destination,
-                target,
-                unwind,
-                call_source: _,
-                fn_span: _,
-            } => TerminatorKind::Call {
-                func: func.stable(tables, cx),
-                args: args.iter().map(|arg| arg.node.stable(tables, cx)).collect(),
-                destination: destination.stable(tables, cx),
-                target: target.map(|t| t.as_usize()),
-                unwind: unwind.stable(tables, cx),
-            },
-            mir::TerminatorKind::TailCall { func: _, args: _, fn_span: _ } => todo!(),
-            mir::TerminatorKind::Assert { cond, expected, msg, target, unwind } => {
-                TerminatorKind::Assert {
-                    cond: cond.stable(tables, cx),
-                    expected: *expected,
-                    msg: msg.stable(tables, cx),
-                    target: target.as_usize(),
-                    unwind: unwind.stable(tables, cx),
-                }
-            }
-            mir::TerminatorKind::InlineAsm {
-                asm_macro: _,
-                template,
-                operands,
-                options,
-                line_spans,
-                targets,
-                unwind,
-            } => TerminatorKind::InlineAsm {
-                template: format!("{template:?}"),
-                operands: operands.iter().map(|operand| operand.stable(tables, cx)).collect(),
-                options: format!("{options:?}"),
-                line_spans: format!("{line_spans:?}"),
-                // FIXME: Figure out how to do labels in SMIR
-                destination: targets.first().map(|d| d.as_usize()),
-                unwind: unwind.stable(tables, cx),
-            },
-            mir::TerminatorKind::Yield { .. }
-            | mir::TerminatorKind::CoroutineDrop
-            | mir::TerminatorKind::FalseEdge { .. }
-            | mir::TerminatorKind::FalseUnwind { .. } => unreachable!(),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::interpret::ConstAllocation<'tcx> {
-    type T = Allocation;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        self.inner().stable(tables, cx)
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::interpret::Allocation {
-    type T = crate::ty::Allocation;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_smir::context::SmirAllocRange;
-        alloc::allocation_filter(
-            self,
-            cx.alloc_range(rustc_abi::Size::ZERO, self.size()),
-            tables,
-            cx,
-        )
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::interpret::AllocId {
-    type T = crate::mir::alloc::AllocId;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        _: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        tables.create_alloc_id(*self)
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::interpret::GlobalAlloc<'tcx> {
-    type T = GlobalAlloc;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            mir::interpret::GlobalAlloc::Function { instance, .. } => {
-                GlobalAlloc::Function(instance.stable(tables, cx))
-            }
-            mir::interpret::GlobalAlloc::VTable(ty, dyn_ty) => {
-                // FIXME: Should we record the whole vtable?
-                GlobalAlloc::VTable(ty.stable(tables, cx), dyn_ty.principal().stable(tables, cx))
-            }
-            mir::interpret::GlobalAlloc::Static(def) => {
-                GlobalAlloc::Static(tables.static_def(*def))
-            }
-            mir::interpret::GlobalAlloc::Memory(alloc) => {
-                GlobalAlloc::Memory(alloc.stable(tables, cx))
-            }
-            mir::interpret::GlobalAlloc::TypeId { ty } => {
-                GlobalAlloc::TypeId { ty: ty.stable(tables, cx) }
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_middle::mir::Const<'tcx> {
-    type T = crate::ty::MirConst;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let id = tables.intern_mir_const(cx.lift(*self).unwrap());
-        match *self {
-            mir::Const::Ty(ty, c) => MirConst::new(
-                crate::ty::ConstantKind::Ty(c.stable(tables, cx)),
-                ty.stable(tables, cx),
-                id,
-            ),
-            mir::Const::Unevaluated(unev_const, ty) => {
-                let kind = crate::ty::ConstantKind::Unevaluated(crate::ty::UnevaluatedConst {
-                    def: tables.const_def(unev_const.def),
-                    args: unev_const.args.stable(tables, cx),
-                    promoted: unev_const.promoted.map(|u| u.as_u32()),
-                });
-                let ty = ty.stable(tables, cx);
-                MirConst::new(kind, ty, id)
-            }
-            mir::Const::Val(mir::ConstValue::ZeroSized, ty) => {
-                let ty = ty.stable(tables, cx);
-                MirConst::new(ConstantKind::ZeroSized, ty, id)
-            }
-            mir::Const::Val(val, ty) => {
-                let ty = cx.lift(ty).unwrap();
-                let val = cx.lift(val).unwrap();
-                let kind = ConstantKind::Allocated(alloc::new_allocation(ty, val, tables, cx));
-                let ty = ty.stable(tables, cx);
-                MirConst::new(kind, ty, id)
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for mir::interpret::ErrorHandled {
-    type T = Error;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        Error::new(format!("{self:?}"))
-    }
-}
-
-impl<'tcx> Stable<'tcx> for MonoItem<'tcx> {
-    type T = crate::mir::mono::MonoItem;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::mir::mono::MonoItem as StableMonoItem;
-        match self {
-            MonoItem::Fn(instance) => StableMonoItem::Fn(instance.stable(tables, cx)),
-            MonoItem::Static(def_id) => StableMonoItem::Static(tables.static_def(*def_id)),
-            MonoItem::GlobalAsm(item_id) => StableMonoItem::GlobalAsm(opaque(item_id)),
-        }
-    }
-}
diff --git a/compiler/stable_mir/src/unstable/convert/stable/mod.rs b/compiler/stable_mir/src/unstable/convert/stable/mod.rs
deleted file mode 100644
index e7f14bbdfc8..00000000000
--- a/compiler/stable_mir/src/unstable/convert/stable/mod.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-//! Conversion of internal Rust compiler items to stable ones.
-
-use rustc_abi::FieldIdx;
-use rustc_smir::Tables;
-use rustc_smir::context::SmirCtxt;
-
-use super::Stable;
-use crate::compiler_interface::BridgeTys;
-
-mod abi;
-mod mir;
-mod ty;
-
-impl<'tcx> Stable<'tcx> for rustc_hir::Safety {
-    type T = crate::mir::Safety;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            rustc_hir::Safety::Unsafe => crate::mir::Safety::Unsafe,
-            rustc_hir::Safety::Safe => crate::mir::Safety::Safe,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for FieldIdx {
-    type T = usize;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        self.as_usize()
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineSource {
-    type T = crate::mir::CoroutineSource;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_hir::CoroutineSource;
-        match self {
-            CoroutineSource::Block => crate::mir::CoroutineSource::Block,
-            CoroutineSource::Closure => crate::mir::CoroutineSource::Closure,
-            CoroutineSource::Fn => crate::mir::CoroutineSource::Fn,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineKind {
-    type T = crate::mir::CoroutineKind;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_hir::{CoroutineDesugaring, CoroutineKind};
-        match *self {
-            CoroutineKind::Desugared(CoroutineDesugaring::Async, source) => {
-                crate::mir::CoroutineKind::Desugared(
-                    crate::mir::CoroutineDesugaring::Async,
-                    source.stable(tables, cx),
-                )
-            }
-            CoroutineKind::Desugared(CoroutineDesugaring::Gen, source) => {
-                crate::mir::CoroutineKind::Desugared(
-                    crate::mir::CoroutineDesugaring::Gen,
-                    source.stable(tables, cx),
-                )
-            }
-            CoroutineKind::Coroutine(movability) => {
-                crate::mir::CoroutineKind::Coroutine(movability.stable(tables, cx))
-            }
-            CoroutineKind::Desugared(CoroutineDesugaring::AsyncGen, source) => {
-                crate::mir::CoroutineKind::Desugared(
-                    crate::mir::CoroutineDesugaring::AsyncGen,
-                    source.stable(tables, cx),
-                )
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_span::Symbol {
-    type T = crate::Symbol;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        self.to_string()
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_span::Span {
-    type T = crate::ty::Span;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        _: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        tables.create_span(*self)
-    }
-}
diff --git a/compiler/stable_mir/src/unstable/convert/stable/ty.rs b/compiler/stable_mir/src/unstable/convert/stable/ty.rs
deleted file mode 100644
index 366f7ea01d4..00000000000
--- a/compiler/stable_mir/src/unstable/convert/stable/ty.rs
+++ /dev/null
@@ -1,1139 +0,0 @@
-//! Conversion of internal Rust compiler `ty` items to stable ones.
-
-use rustc_middle::ty::Ty;
-use rustc_middle::{bug, mir, ty};
-use rustc_smir::Tables;
-use rustc_smir::context::SmirCtxt;
-
-use crate::alloc;
-use crate::compiler_interface::BridgeTys;
-use crate::ty::{
-    AdtKind, FloatTy, GenericArgs, GenericParamDef, IntTy, Region, RigidTy, TyKind, UintTy,
-};
-use crate::unstable::Stable;
-
-impl<'tcx> Stable<'tcx> for ty::AliasTyKind {
-    type T = crate::ty::AliasKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            ty::Projection => crate::ty::AliasKind::Projection,
-            ty::Inherent => crate::ty::AliasKind::Inherent,
-            ty::Opaque => crate::ty::AliasKind::Opaque,
-            ty::Free => crate::ty::AliasKind::Free,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::AliasTy<'tcx> {
-    type T = crate::ty::AliasTy;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let ty::AliasTy { args, def_id, .. } = self;
-        crate::ty::AliasTy { def_id: tables.alias_def(*def_id), args: args.stable(tables, cx) }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::AliasTerm<'tcx> {
-    type T = crate::ty::AliasTerm;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let ty::AliasTerm { args, def_id, .. } = self;
-        crate::ty::AliasTerm { def_id: tables.alias_def(*def_id), args: args.stable(tables, cx) }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::DynKind {
-    type T = crate::ty::DynKind;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            ty::Dyn => crate::ty::DynKind::Dyn,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::ExistentialPredicate<'tcx> {
-    type T = crate::ty::ExistentialPredicate;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::ExistentialPredicate::*;
-        match self {
-            ty::ExistentialPredicate::Trait(existential_trait_ref) => {
-                Trait(existential_trait_ref.stable(tables, cx))
-            }
-            ty::ExistentialPredicate::Projection(existential_projection) => {
-                Projection(existential_projection.stable(tables, cx))
-            }
-            ty::ExistentialPredicate::AutoTrait(def_id) => AutoTrait(tables.trait_def(*def_id)),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::ExistentialTraitRef<'tcx> {
-    type T = crate::ty::ExistentialTraitRef;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let ty::ExistentialTraitRef { def_id, args, .. } = self;
-        crate::ty::ExistentialTraitRef {
-            def_id: tables.trait_def(*def_id),
-            generic_args: args.stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::TermKind<'tcx> {
-    type T = crate::ty::TermKind;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::TermKind;
-        match self {
-            ty::TermKind::Ty(ty) => TermKind::Type(ty.stable(tables, cx)),
-            ty::TermKind::Const(cnst) => {
-                let cnst = cnst.stable(tables, cx);
-                TermKind::Const(cnst)
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::ExistentialProjection<'tcx> {
-    type T = crate::ty::ExistentialProjection;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let ty::ExistentialProjection { def_id, args, term, .. } = self;
-        crate::ty::ExistentialProjection {
-            def_id: tables.trait_def(*def_id),
-            generic_args: args.stable(tables, cx),
-            term: term.kind().stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::adjustment::PointerCoercion {
-    type T = crate::mir::PointerCoercion;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::ty::adjustment::PointerCoercion;
-        match self {
-            PointerCoercion::ReifyFnPointer => crate::mir::PointerCoercion::ReifyFnPointer,
-            PointerCoercion::UnsafeFnPointer => crate::mir::PointerCoercion::UnsafeFnPointer,
-            PointerCoercion::ClosureFnPointer(safety) => {
-                crate::mir::PointerCoercion::ClosureFnPointer(safety.stable(tables, cx))
-            }
-            PointerCoercion::MutToConstPointer => crate::mir::PointerCoercion::MutToConstPointer,
-            PointerCoercion::ArrayToPointer => crate::mir::PointerCoercion::ArrayToPointer,
-            PointerCoercion::Unsize => crate::mir::PointerCoercion::Unsize,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::UserTypeAnnotationIndex {
-    type T = usize;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        self.as_usize()
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::AdtKind {
-    type T = AdtKind;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            ty::AdtKind::Struct => AdtKind::Struct,
-            ty::AdtKind::Union => AdtKind::Union,
-            ty::AdtKind::Enum => AdtKind::Enum,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::FieldDef {
-    type T = crate::ty::FieldDef;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        crate::ty::FieldDef {
-            def: tables.create_def_id(self.did),
-            name: self.name.stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::GenericArgs<'tcx> {
-    type T = crate::ty::GenericArgs;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        GenericArgs(self.iter().map(|arg| arg.kind().stable(tables, cx)).collect())
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::GenericArgKind<'tcx> {
-    type T = crate::ty::GenericArgKind;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::GenericArgKind;
-        match self {
-            ty::GenericArgKind::Lifetime(region) => {
-                GenericArgKind::Lifetime(region.stable(tables, cx))
-            }
-            ty::GenericArgKind::Type(ty) => GenericArgKind::Type(ty.stable(tables, cx)),
-            ty::GenericArgKind::Const(cnst) => GenericArgKind::Const(cnst.stable(tables, cx)),
-        }
-    }
-}
-
-impl<'tcx, S, V> Stable<'tcx> for ty::Binder<'tcx, S>
-where
-    S: Stable<'tcx, T = V>,
-{
-    type T = crate::ty::Binder<V>;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::Binder;
-
-        Binder {
-            value: self.as_ref().skip_binder().stable(tables, cx),
-            bound_vars: self
-                .bound_vars()
-                .iter()
-                .map(|bound_var| bound_var.stable(tables, cx))
-                .collect(),
-        }
-    }
-}
-
-impl<'tcx, S, V> Stable<'tcx> for ty::EarlyBinder<'tcx, S>
-where
-    S: Stable<'tcx, T = V>,
-{
-    type T = crate::ty::EarlyBinder<V>;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::EarlyBinder;
-
-        EarlyBinder { value: self.as_ref().skip_binder().stable(tables, cx) }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::FnSig<'tcx> {
-    type T = crate::ty::FnSig;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::FnSig;
-
-        FnSig {
-            inputs_and_output: self
-                .inputs_and_output
-                .iter()
-                .map(|ty| ty.stable(tables, cx))
-                .collect(),
-            c_variadic: self.c_variadic,
-            safety: self.safety.stable(tables, cx),
-            abi: self.abi.stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::BoundTyKind {
-    type T = crate::ty::BoundTyKind;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::BoundTyKind;
-
-        match self {
-            ty::BoundTyKind::Anon => BoundTyKind::Anon,
-            ty::BoundTyKind::Param(def_id) => {
-                BoundTyKind::Param(tables.param_def(*def_id), cx.tcx.item_name(*def_id).to_string())
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::BoundRegionKind {
-    type T = crate::ty::BoundRegionKind;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::BoundRegionKind;
-
-        match self {
-            ty::BoundRegionKind::Anon => BoundRegionKind::BrAnon,
-            ty::BoundRegionKind::Named(def_id) => BoundRegionKind::BrNamed(
-                tables.br_named_def(*def_id),
-                cx.tcx.item_name(*def_id).to_string(),
-            ),
-            ty::BoundRegionKind::ClosureEnv => BoundRegionKind::BrEnv,
-            ty::BoundRegionKind::NamedAnon(_) => bug!("only used for pretty printing"),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::BoundVariableKind {
-    type T = crate::ty::BoundVariableKind;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::BoundVariableKind;
-
-        match self {
-            ty::BoundVariableKind::Ty(bound_ty_kind) => {
-                BoundVariableKind::Ty(bound_ty_kind.stable(tables, cx))
-            }
-            ty::BoundVariableKind::Region(bound_region_kind) => {
-                BoundVariableKind::Region(bound_region_kind.stable(tables, cx))
-            }
-            ty::BoundVariableKind::Const => BoundVariableKind::Const,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::IntTy {
-    type T = IntTy;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            ty::IntTy::Isize => IntTy::Isize,
-            ty::IntTy::I8 => IntTy::I8,
-            ty::IntTy::I16 => IntTy::I16,
-            ty::IntTy::I32 => IntTy::I32,
-            ty::IntTy::I64 => IntTy::I64,
-            ty::IntTy::I128 => IntTy::I128,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::UintTy {
-    type T = UintTy;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            ty::UintTy::Usize => UintTy::Usize,
-            ty::UintTy::U8 => UintTy::U8,
-            ty::UintTy::U16 => UintTy::U16,
-            ty::UintTy::U32 => UintTy::U32,
-            ty::UintTy::U64 => UintTy::U64,
-            ty::UintTy::U128 => UintTy::U128,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::FloatTy {
-    type T = FloatTy;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            ty::FloatTy::F16 => FloatTy::F16,
-            ty::FloatTy::F32 => FloatTy::F32,
-            ty::FloatTy::F64 => FloatTy::F64,
-            ty::FloatTy::F128 => FloatTy::F128,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for Ty<'tcx> {
-    type T = crate::ty::Ty;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        tables.intern_ty(cx.lift(*self).unwrap())
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> {
-    type T = crate::ty::TyKind;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match self {
-            ty::Bool => TyKind::RigidTy(RigidTy::Bool),
-            ty::Char => TyKind::RigidTy(RigidTy::Char),
-            ty::Int(int_ty) => TyKind::RigidTy(RigidTy::Int(int_ty.stable(tables, cx))),
-            ty::Uint(uint_ty) => TyKind::RigidTy(RigidTy::Uint(uint_ty.stable(tables, cx))),
-            ty::Float(float_ty) => TyKind::RigidTy(RigidTy::Float(float_ty.stable(tables, cx))),
-            ty::Adt(adt_def, generic_args) => TyKind::RigidTy(RigidTy::Adt(
-                tables.adt_def(adt_def.did()),
-                generic_args.stable(tables, cx),
-            )),
-            ty::Foreign(def_id) => TyKind::RigidTy(RigidTy::Foreign(tables.foreign_def(*def_id))),
-            ty::Str => TyKind::RigidTy(RigidTy::Str),
-            ty::Array(ty, constant) => {
-                TyKind::RigidTy(RigidTy::Array(ty.stable(tables, cx), constant.stable(tables, cx)))
-            }
-            ty::Pat(ty, pat) => {
-                TyKind::RigidTy(RigidTy::Pat(ty.stable(tables, cx), pat.stable(tables, cx)))
-            }
-            ty::Slice(ty) => TyKind::RigidTy(RigidTy::Slice(ty.stable(tables, cx))),
-            ty::RawPtr(ty, mutbl) => {
-                TyKind::RigidTy(RigidTy::RawPtr(ty.stable(tables, cx), mutbl.stable(tables, cx)))
-            }
-            ty::Ref(region, ty, mutbl) => TyKind::RigidTy(RigidTy::Ref(
-                region.stable(tables, cx),
-                ty.stable(tables, cx),
-                mutbl.stable(tables, cx),
-            )),
-            ty::FnDef(def_id, generic_args) => TyKind::RigidTy(RigidTy::FnDef(
-                tables.fn_def(*def_id),
-                generic_args.stable(tables, cx),
-            )),
-            ty::FnPtr(sig_tys, hdr) => {
-                TyKind::RigidTy(RigidTy::FnPtr(sig_tys.with(*hdr).stable(tables, cx)))
-            }
-            // FIXME(unsafe_binders):
-            ty::UnsafeBinder(_) => todo!(),
-            ty::Dynamic(existential_predicates, region, dyn_kind) => {
-                TyKind::RigidTy(RigidTy::Dynamic(
-                    existential_predicates
-                        .iter()
-                        .map(|existential_predicate| existential_predicate.stable(tables, cx))
-                        .collect(),
-                    region.stable(tables, cx),
-                    dyn_kind.stable(tables, cx),
-                ))
-            }
-            ty::Closure(def_id, generic_args) => TyKind::RigidTy(RigidTy::Closure(
-                tables.closure_def(*def_id),
-                generic_args.stable(tables, cx),
-            )),
-            ty::CoroutineClosure(..) => todo!("FIXME(async_closures): Lower these to SMIR"),
-            ty::Coroutine(def_id, generic_args) => TyKind::RigidTy(RigidTy::Coroutine(
-                tables.coroutine_def(*def_id),
-                generic_args.stable(tables, cx),
-                cx.coroutine_movability(*def_id).stable(tables, cx),
-            )),
-            ty::Never => TyKind::RigidTy(RigidTy::Never),
-            ty::Tuple(fields) => TyKind::RigidTy(RigidTy::Tuple(
-                fields.iter().map(|ty| ty.stable(tables, cx)).collect(),
-            )),
-            ty::Alias(alias_kind, alias_ty) => {
-                TyKind::Alias(alias_kind.stable(tables, cx), alias_ty.stable(tables, cx))
-            }
-            ty::Param(param_ty) => TyKind::Param(param_ty.stable(tables, cx)),
-            ty::Bound(debruijn_idx, bound_ty) => {
-                TyKind::Bound(debruijn_idx.as_usize(), bound_ty.stable(tables, cx))
-            }
-            ty::CoroutineWitness(def_id, args) => TyKind::RigidTy(RigidTy::CoroutineWitness(
-                tables.coroutine_witness_def(*def_id),
-                args.stable(tables, cx),
-            )),
-            ty::Placeholder(..) | ty::Infer(_) | ty::Error(_) => {
-                unreachable!();
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::Pattern<'tcx> {
-    type T = crate::ty::Pattern;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        match **self {
-            ty::PatternKind::Range { start, end } => crate::ty::Pattern::Range {
-                // FIXME(SMIR): update data structures to not have an Option here anymore
-                start: Some(start.stable(tables, cx)),
-                end: Some(end.stable(tables, cx)),
-                include_end: true,
-            },
-            ty::PatternKind::Or(_) => todo!(),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::Const<'tcx> {
-    type T = crate::ty::TyConst;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let ct = cx.lift(*self).unwrap();
-        let kind = match ct.kind() {
-            ty::ConstKind::Value(cv) => {
-                let const_val = cx.valtree_to_const_val(cv);
-                if matches!(const_val, mir::ConstValue::ZeroSized) {
-                    crate::ty::TyConstKind::ZSTValue(cv.ty.stable(tables, cx))
-                } else {
-                    crate::ty::TyConstKind::Value(
-                        cv.ty.stable(tables, cx),
-                        alloc::new_allocation(cv.ty, const_val, tables, cx),
-                    )
-                }
-            }
-            ty::ConstKind::Param(param) => crate::ty::TyConstKind::Param(param.stable(tables, cx)),
-            ty::ConstKind::Unevaluated(uv) => crate::ty::TyConstKind::Unevaluated(
-                tables.const_def(uv.def),
-                uv.args.stable(tables, cx),
-            ),
-            ty::ConstKind::Error(_) => unreachable!(),
-            ty::ConstKind::Infer(_) => unreachable!(),
-            ty::ConstKind::Bound(_, _) => unimplemented!(),
-            ty::ConstKind::Placeholder(_) => unimplemented!(),
-            ty::ConstKind::Expr(_) => unimplemented!(),
-        };
-        let id = tables.intern_ty_const(ct);
-        crate::ty::TyConst::new(kind, id)
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::ParamConst {
-    type T = crate::ty::ParamConst;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use crate::ty::ParamConst;
-        ParamConst { index: self.index, name: self.name.to_string() }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::ParamTy {
-    type T = crate::ty::ParamTy;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use crate::ty::ParamTy;
-        ParamTy { index: self.index, name: self.name.to_string() }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::BoundTy {
-    type T = crate::ty::BoundTy;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::BoundTy;
-        BoundTy { var: self.var.as_usize(), kind: self.kind.stable(tables, cx) }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::trait_def::TraitSpecializationKind {
-    type T = crate::ty::TraitSpecializationKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use crate::ty::TraitSpecializationKind;
-
-        match self {
-            ty::trait_def::TraitSpecializationKind::None => TraitSpecializationKind::None,
-            ty::trait_def::TraitSpecializationKind::Marker => TraitSpecializationKind::Marker,
-            ty::trait_def::TraitSpecializationKind::AlwaysApplicable => {
-                TraitSpecializationKind::AlwaysApplicable
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::TraitDef {
-    type T = crate::ty::TraitDecl;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::opaque;
-        use crate::ty::TraitDecl;
-
-        TraitDecl {
-            def_id: tables.trait_def(self.def_id),
-            safety: self.safety.stable(tables, cx),
-            paren_sugar: self.paren_sugar,
-            has_auto_impl: self.has_auto_impl,
-            is_marker: self.is_marker,
-            is_coinductive: self.is_coinductive,
-            skip_array_during_method_dispatch: self.skip_array_during_method_dispatch,
-            skip_boxed_slice_during_method_dispatch: self.skip_boxed_slice_during_method_dispatch,
-            specialization_kind: self.specialization_kind.stable(tables, cx),
-            must_implement_one_of: self
-                .must_implement_one_of
-                .as_ref()
-                .map(|idents| idents.iter().map(|ident| opaque(ident)).collect()),
-            implement_via_object: self.implement_via_object,
-            deny_explicit_impl: self.deny_explicit_impl,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::TraitRef<'tcx> {
-    type T = crate::ty::TraitRef;
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::TraitRef;
-
-        TraitRef::try_new(tables.trait_def(self.def_id), self.args.stable(tables, cx)).unwrap()
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::Generics {
-    type T = crate::ty::Generics;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::Generics;
-
-        let params: Vec<_> = self.own_params.iter().map(|param| param.stable(tables, cx)).collect();
-        let param_def_id_to_index =
-            params.iter().map(|param| (param.def_id, param.index)).collect();
-
-        Generics {
-            parent: self.parent.map(|did| tables.generic_def(did)),
-            parent_count: self.parent_count,
-            params,
-            param_def_id_to_index,
-            has_self: self.has_self,
-            has_late_bound_regions: self
-                .has_late_bound_regions
-                .as_ref()
-                .map(|late_bound_regions| late_bound_regions.stable(tables, cx)),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDefKind {
-    type T = crate::ty::GenericParamDefKind;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use crate::ty::GenericParamDefKind;
-        match self {
-            ty::GenericParamDefKind::Lifetime => GenericParamDefKind::Lifetime,
-            ty::GenericParamDefKind::Type { has_default, synthetic } => {
-                GenericParamDefKind::Type { has_default: *has_default, synthetic: *synthetic }
-            }
-            ty::GenericParamDefKind::Const { has_default, synthetic: _ } => {
-                GenericParamDefKind::Const { has_default: *has_default }
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDef {
-    type T = crate::ty::GenericParamDef;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        GenericParamDef {
-            name: self.name.to_string(),
-            def_id: tables.generic_def(self.def_id),
-            index: self.index,
-            pure_wrt_drop: self.pure_wrt_drop,
-            kind: self.kind.stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::PredicateKind<'tcx> {
-    type T = crate::ty::PredicateKind;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::ty::PredicateKind;
-        match self {
-            PredicateKind::Clause(clause_kind) => {
-                crate::ty::PredicateKind::Clause(clause_kind.stable(tables, cx))
-            }
-            PredicateKind::DynCompatible(did) => {
-                crate::ty::PredicateKind::DynCompatible(tables.trait_def(*did))
-            }
-            PredicateKind::Subtype(subtype_predicate) => {
-                crate::ty::PredicateKind::SubType(subtype_predicate.stable(tables, cx))
-            }
-            PredicateKind::Coerce(coerce_predicate) => {
-                crate::ty::PredicateKind::Coerce(coerce_predicate.stable(tables, cx))
-            }
-            PredicateKind::ConstEquate(a, b) => {
-                crate::ty::PredicateKind::ConstEquate(a.stable(tables, cx), b.stable(tables, cx))
-            }
-            PredicateKind::Ambiguous => crate::ty::PredicateKind::Ambiguous,
-            PredicateKind::NormalizesTo(_pred) => unimplemented!(),
-            PredicateKind::AliasRelate(a, b, alias_relation_direction) => {
-                crate::ty::PredicateKind::AliasRelate(
-                    a.kind().stable(tables, cx),
-                    b.kind().stable(tables, cx),
-                    alias_relation_direction.stable(tables, cx),
-                )
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> {
-    type T = crate::ty::ClauseKind;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use rustc_middle::ty::ClauseKind;
-        match *self {
-            ClauseKind::Trait(trait_object) => {
-                crate::ty::ClauseKind::Trait(trait_object.stable(tables, cx))
-            }
-            ClauseKind::RegionOutlives(region_outlives) => {
-                crate::ty::ClauseKind::RegionOutlives(region_outlives.stable(tables, cx))
-            }
-            ClauseKind::TypeOutlives(type_outlives) => {
-                let ty::OutlivesPredicate::<_, _>(a, b) = type_outlives;
-                crate::ty::ClauseKind::TypeOutlives(crate::ty::OutlivesPredicate(
-                    a.stable(tables, cx),
-                    b.stable(tables, cx),
-                ))
-            }
-            ClauseKind::Projection(projection_predicate) => {
-                crate::ty::ClauseKind::Projection(projection_predicate.stable(tables, cx))
-            }
-            ClauseKind::ConstArgHasType(const_, ty) => crate::ty::ClauseKind::ConstArgHasType(
-                const_.stable(tables, cx),
-                ty.stable(tables, cx),
-            ),
-            ClauseKind::WellFormed(term) => {
-                crate::ty::ClauseKind::WellFormed(term.kind().stable(tables, cx))
-            }
-            ClauseKind::ConstEvaluatable(const_) => {
-                crate::ty::ClauseKind::ConstEvaluatable(const_.stable(tables, cx))
-            }
-            ClauseKind::HostEffect(..) => {
-                todo!()
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::ClosureKind {
-    type T = crate::ty::ClosureKind;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_middle::ty::ClosureKind::*;
-        match self {
-            Fn => crate::ty::ClosureKind::Fn,
-            FnMut => crate::ty::ClosureKind::FnMut,
-            FnOnce => crate::ty::ClosureKind::FnOnce,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::SubtypePredicate<'tcx> {
-    type T = crate::ty::SubtypePredicate;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let ty::SubtypePredicate { a, b, a_is_expected: _ } = self;
-        crate::ty::SubtypePredicate { a: a.stable(tables, cx), b: b.stable(tables, cx) }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::CoercePredicate<'tcx> {
-    type T = crate::ty::CoercePredicate;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let ty::CoercePredicate { a, b } = self;
-        crate::ty::CoercePredicate { a: a.stable(tables, cx), b: b.stable(tables, cx) }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::AliasRelationDirection {
-    type T = crate::ty::AliasRelationDirection;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_middle::ty::AliasRelationDirection::*;
-        match self {
-            Equate => crate::ty::AliasRelationDirection::Equate,
-            Subtype => crate::ty::AliasRelationDirection::Subtype,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::TraitPredicate<'tcx> {
-    type T = crate::ty::TraitPredicate;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let ty::TraitPredicate { trait_ref, polarity } = self;
-        crate::ty::TraitPredicate {
-            trait_ref: trait_ref.stable(tables, cx),
-            polarity: polarity.stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx, T> Stable<'tcx> for ty::OutlivesPredicate<'tcx, T>
-where
-    T: Stable<'tcx>,
-{
-    type T = crate::ty::OutlivesPredicate<T::T, Region>;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let ty::OutlivesPredicate(a, b) = self;
-        crate::ty::OutlivesPredicate(a.stable(tables, cx), b.stable(tables, cx))
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::ProjectionPredicate<'tcx> {
-    type T = crate::ty::ProjectionPredicate;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let ty::ProjectionPredicate { projection_term, term } = self;
-        crate::ty::ProjectionPredicate {
-            projection_term: projection_term.stable(tables, cx),
-            term: term.kind().stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::ImplPolarity {
-    type T = crate::ty::ImplPolarity;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_middle::ty::ImplPolarity::*;
-        match self {
-            Positive => crate::ty::ImplPolarity::Positive,
-            Negative => crate::ty::ImplPolarity::Negative,
-            Reservation => crate::ty::ImplPolarity::Reservation,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::PredicatePolarity {
-    type T = crate::ty::PredicatePolarity;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_middle::ty::PredicatePolarity::*;
-        match self {
-            Positive => crate::ty::PredicatePolarity::Positive,
-            Negative => crate::ty::PredicatePolarity::Negative,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::Region<'tcx> {
-    type T = crate::ty::Region;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        Region { kind: self.kind().stable(tables, cx) }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::RegionKind<'tcx> {
-    type T = crate::ty::RegionKind;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::{BoundRegion, EarlyParamRegion, RegionKind};
-        match self {
-            ty::ReEarlyParam(early_reg) => RegionKind::ReEarlyParam(EarlyParamRegion {
-                index: early_reg.index,
-                name: early_reg.name.to_string(),
-            }),
-            ty::ReBound(db_index, bound_reg) => RegionKind::ReBound(
-                db_index.as_u32(),
-                BoundRegion {
-                    var: bound_reg.var.as_u32(),
-                    kind: bound_reg.kind.stable(tables, cx),
-                },
-            ),
-            ty::ReStatic => RegionKind::ReStatic,
-            ty::RePlaceholder(place_holder) => RegionKind::RePlaceholder(crate::ty::Placeholder {
-                universe: place_holder.universe.as_u32(),
-                bound: BoundRegion {
-                    var: place_holder.bound.var.as_u32(),
-                    kind: place_holder.bound.kind.stable(tables, cx),
-                },
-            }),
-            ty::ReErased => RegionKind::ReErased,
-            _ => unreachable!("{self:?}"),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::Instance<'tcx> {
-    type T = crate::mir::mono::Instance;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        let def = tables.instance_def(cx.lift(*self).unwrap());
-        let kind = match self.def {
-            ty::InstanceKind::Item(..) => crate::mir::mono::InstanceKind::Item,
-            ty::InstanceKind::Intrinsic(..) => crate::mir::mono::InstanceKind::Intrinsic,
-            ty::InstanceKind::Virtual(_def_id, idx) => {
-                crate::mir::mono::InstanceKind::Virtual { idx }
-            }
-            ty::InstanceKind::VTableShim(..)
-            | ty::InstanceKind::ReifyShim(..)
-            | ty::InstanceKind::FnPtrAddrShim(..)
-            | ty::InstanceKind::ClosureOnceShim { .. }
-            | ty::InstanceKind::ConstructCoroutineInClosureShim { .. }
-            | ty::InstanceKind::ThreadLocalShim(..)
-            | ty::InstanceKind::DropGlue(..)
-            | ty::InstanceKind::CloneShim(..)
-            | ty::InstanceKind::FnPtrShim(..)
-            | ty::InstanceKind::FutureDropPollShim(..)
-            | ty::InstanceKind::AsyncDropGlue(..)
-            | ty::InstanceKind::AsyncDropGlueCtorShim(..) => crate::mir::mono::InstanceKind::Shim,
-        };
-        crate::mir::mono::Instance { def, kind }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::Variance {
-    type T = crate::mir::Variance;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            ty::Bivariant => crate::mir::Variance::Bivariant,
-            ty::Contravariant => crate::mir::Variance::Contravariant,
-            ty::Covariant => crate::mir::Variance::Covariant,
-            ty::Invariant => crate::mir::Variance::Invariant,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::Movability {
-    type T = crate::ty::Movability;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        match self {
-            ty::Movability::Static => crate::ty::Movability::Static,
-            ty::Movability::Movable => crate::ty::Movability::Movable,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_abi::ExternAbi {
-    type T = crate::ty::Abi;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use rustc_abi::ExternAbi;
-
-        use crate::ty::Abi;
-        match *self {
-            ExternAbi::Rust => Abi::Rust,
-            ExternAbi::C { unwind } => Abi::C { unwind },
-            ExternAbi::Cdecl { unwind } => Abi::Cdecl { unwind },
-            ExternAbi::Stdcall { unwind } => Abi::Stdcall { unwind },
-            ExternAbi::Fastcall { unwind } => Abi::Fastcall { unwind },
-            ExternAbi::Vectorcall { unwind } => Abi::Vectorcall { unwind },
-            ExternAbi::Thiscall { unwind } => Abi::Thiscall { unwind },
-            ExternAbi::Aapcs { unwind } => Abi::Aapcs { unwind },
-            ExternAbi::Win64 { unwind } => Abi::Win64 { unwind },
-            ExternAbi::SysV64 { unwind } => Abi::SysV64 { unwind },
-            ExternAbi::PtxKernel => Abi::PtxKernel,
-            ExternAbi::GpuKernel => Abi::GpuKernel,
-            ExternAbi::Msp430Interrupt => Abi::Msp430Interrupt,
-            ExternAbi::X86Interrupt => Abi::X86Interrupt,
-            ExternAbi::EfiApi => Abi::EfiApi,
-            ExternAbi::AvrInterrupt => Abi::AvrInterrupt,
-            ExternAbi::AvrNonBlockingInterrupt => Abi::AvrNonBlockingInterrupt,
-            ExternAbi::CmseNonSecureCall => Abi::CCmseNonSecureCall,
-            ExternAbi::CmseNonSecureEntry => Abi::CCmseNonSecureEntry,
-            ExternAbi::System { unwind } => Abi::System { unwind },
-            ExternAbi::RustCall => Abi::RustCall,
-            ExternAbi::Unadjusted => Abi::Unadjusted,
-            ExternAbi::RustCold => Abi::RustCold,
-            ExternAbi::RustInvalid => Abi::RustInvalid,
-            ExternAbi::RiscvInterruptM => Abi::RiscvInterruptM,
-            ExternAbi::RiscvInterruptS => Abi::RiscvInterruptS,
-            ExternAbi::Custom => Abi::Custom,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_session::cstore::ForeignModule {
-    type T = crate::ty::ForeignModule;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        crate::ty::ForeignModule {
-            def_id: tables.foreign_module_def(self.def_id),
-            abi: self.abi.stable(tables, cx),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::AssocKind {
-    type T = crate::ty::AssocKind;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::{AssocKind, AssocTypeData};
-        match *self {
-            ty::AssocKind::Const { name } => AssocKind::Const { name: name.to_string() },
-            ty::AssocKind::Fn { name, has_self } => {
-                AssocKind::Fn { name: name.to_string(), has_self }
-            }
-            ty::AssocKind::Type { data } => AssocKind::Type {
-                data: match data {
-                    ty::AssocTypeData::Normal(name) => AssocTypeData::Normal(name.to_string()),
-                    ty::AssocTypeData::Rpitit(rpitit) => {
-                        AssocTypeData::Rpitit(rpitit.stable(tables, cx))
-                    }
-                },
-            },
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::AssocItemContainer {
-    type T = crate::ty::AssocItemContainer;
-
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
-        use crate::ty::AssocItemContainer;
-        match self {
-            ty::AssocItemContainer::Trait => AssocItemContainer::Trait,
-            ty::AssocItemContainer::Impl => AssocItemContainer::Impl,
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::AssocItem {
-    type T = crate::ty::AssocItem;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        crate::ty::AssocItem {
-            def_id: tables.assoc_def(self.def_id),
-            kind: self.kind.stable(tables, cx),
-            container: self.container.stable(tables, cx),
-            trait_item_def_id: self.trait_item_def_id.map(|did| tables.assoc_def(did)),
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for ty::ImplTraitInTraitData {
-    type T = crate::ty::ImplTraitInTraitData;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        _: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        use crate::ty::ImplTraitInTraitData;
-        match self {
-            ty::ImplTraitInTraitData::Trait { fn_def_id, opaque_def_id } => {
-                ImplTraitInTraitData::Trait {
-                    fn_def_id: tables.fn_def(*fn_def_id),
-                    opaque_def_id: tables.opaque_def(*opaque_def_id),
-                }
-            }
-            ty::ImplTraitInTraitData::Impl { fn_def_id } => {
-                ImplTraitInTraitData::Impl { fn_def_id: tables.fn_def(*fn_def_id) }
-            }
-        }
-    }
-}
-
-impl<'tcx> Stable<'tcx> for rustc_middle::ty::util::Discr<'tcx> {
-    type T = crate::ty::Discr;
-
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T {
-        crate::ty::Discr { val: self.val, ty: self.ty.stable(tables, cx) }
-    }
-}
diff --git a/compiler/stable_mir/src/unstable/internal_cx/mod.rs b/compiler/stable_mir/src/unstable/internal_cx/mod.rs
deleted file mode 100644
index 6b0a06e304c..00000000000
--- a/compiler/stable_mir/src/unstable/internal_cx/mod.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-//! Implementation of InternalCx.
-
-use rustc_middle::ty::{List, Ty, TyCtxt};
-use rustc_middle::{mir, ty};
-pub(crate) use traits::*;
-
-use super::InternalCx;
-
-pub(crate) mod traits;
-
-impl<'tcx, T: InternalCx<'tcx>> SmirExistentialProjection<'tcx> for T {
-    fn new_from_args(
-        &self,
-        def_id: rustc_span::def_id::DefId,
-        args: ty::GenericArgsRef<'tcx>,
-        term: ty::Term<'tcx>,
-    ) -> ty::ExistentialProjection<'tcx> {
-        ty::ExistentialProjection::new_from_args(self.tcx(), def_id, args, term)
-    }
-}
-
-impl<'tcx, T: InternalCx<'tcx>> SmirExistentialTraitRef<'tcx> for T {
-    fn new_from_args(
-        &self,
-        trait_def_id: rustc_span::def_id::DefId,
-        args: ty::GenericArgsRef<'tcx>,
-    ) -> ty::ExistentialTraitRef<'tcx> {
-        ty::ExistentialTraitRef::new_from_args(self.tcx(), trait_def_id, args)
-    }
-}
-
-impl<'tcx, T: InternalCx<'tcx>> SmirTraitRef<'tcx> for T {
-    fn new_from_args(
-        &self,
-        trait_def_id: rustc_span::def_id::DefId,
-        args: ty::GenericArgsRef<'tcx>,
-    ) -> ty::TraitRef<'tcx> {
-        ty::TraitRef::new_from_args(self.tcx(), trait_def_id, args)
-    }
-}
-
-impl<'tcx> InternalCx<'tcx> for TyCtxt<'tcx> {
-    fn tcx(self) -> TyCtxt<'tcx> {
-        self
-    }
-
-    fn lift<T: ty::Lift<TyCtxt<'tcx>>>(self, value: T) -> Option<T::Lifted> {
-        TyCtxt::lift(self, value)
-    }
-
-    fn mk_args_from_iter<I, T>(self, iter: I) -> T::Output
-    where
-        I: Iterator<Item = T>,
-        T: ty::CollectAndApply<ty::GenericArg<'tcx>, ty::GenericArgsRef<'tcx>>,
-    {
-        TyCtxt::mk_args_from_iter(self, iter)
-    }
-
-    fn mk_pat(self, v: ty::PatternKind<'tcx>) -> ty::Pattern<'tcx> {
-        TyCtxt::mk_pat(self, v)
-    }
-
-    fn mk_poly_existential_predicates(
-        self,
-        eps: &[ty::PolyExistentialPredicate<'tcx>],
-    ) -> &'tcx List<ty::PolyExistentialPredicate<'tcx>> {
-        TyCtxt::mk_poly_existential_predicates(self, eps)
-    }
-
-    fn mk_type_list(self, v: &[Ty<'tcx>]) -> &'tcx List<Ty<'tcx>> {
-        TyCtxt::mk_type_list(self, v)
-    }
-
-    fn lifetimes_re_erased(self) -> ty::Region<'tcx> {
-        self.lifetimes.re_erased
-    }
-
-    fn mk_bound_variable_kinds_from_iter<I, T>(self, iter: I) -> T::Output
-    where
-        I: Iterator<Item = T>,
-        T: ty::CollectAndApply<ty::BoundVariableKind, &'tcx List<ty::BoundVariableKind>>,
-    {
-        TyCtxt::mk_bound_variable_kinds_from_iter(self, iter)
-    }
-
-    fn mk_place_elems(self, v: &[mir::PlaceElem<'tcx>]) -> &'tcx List<mir::PlaceElem<'tcx>> {
-        TyCtxt::mk_place_elems(self, v)
-    }
-
-    fn adt_def(self, def_id: rustc_hir::def_id::DefId) -> ty::AdtDef<'tcx> {
-        self.adt_def(def_id)
-    }
-}
diff --git a/compiler/stable_mir/src/unstable/internal_cx/traits.rs b/compiler/stable_mir/src/unstable/internal_cx/traits.rs
deleted file mode 100644
index da443cd78f1..00000000000
--- a/compiler/stable_mir/src/unstable/internal_cx/traits.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//! A set of traits that define a stable interface to rustc's internals.
-//!
-//! These traits are primarily used to clarify the behavior of different
-//! functions that share the same name across various contexts.
-
-use rustc_middle::ty;
-
-pub(crate) trait SmirExistentialProjection<'tcx> {
-    fn new_from_args(
-        &self,
-        def_id: rustc_span::def_id::DefId,
-        args: ty::GenericArgsRef<'tcx>,
-        term: ty::Term<'tcx>,
-    ) -> ty::ExistentialProjection<'tcx>;
-}
-
-pub(crate) trait SmirExistentialTraitRef<'tcx> {
-    fn new_from_args(
-        &self,
-        trait_def_id: rustc_span::def_id::DefId,
-        args: ty::GenericArgsRef<'tcx>,
-    ) -> ty::ExistentialTraitRef<'tcx>;
-}
-
-pub(crate) trait SmirTraitRef<'tcx> {
-    fn new_from_args(
-        &self,
-        trait_def_id: rustc_span::def_id::DefId,
-        args: ty::GenericArgsRef<'tcx>,
-    ) -> ty::TraitRef<'tcx>;
-}
diff --git a/compiler/stable_mir/src/unstable/mod.rs b/compiler/stable_mir/src/unstable/mod.rs
deleted file mode 100644
index 51c31e212f5..00000000000
--- a/compiler/stable_mir/src/unstable/mod.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-//! Module that collects the things that have no stability guarantees.
-//!
-//! We want to keep StableMIR definitions and logic separate from
-//! any sort of conversion and usage of internal rustc code. So we
-//! restrict the usage of internal items to be inside this module.
-
-use std::marker::PointeeSized;
-
-use rustc_hir::def::DefKind;
-use rustc_middle::ty::{List, Ty, TyCtxt};
-use rustc_middle::{mir, ty};
-use rustc_smir::Tables;
-use rustc_smir::context::SmirCtxt;
-
-use super::compiler_interface::BridgeTys;
-use crate::{CtorKind, ItemKind};
-
-pub(crate) mod convert;
-mod internal_cx;
-
-/// Trait that defines the methods that are fine to call from [`RustcInternal`].
-///
-/// This trait is only for [`RustcInternal`]. Any other other access to rustc's internals
-/// should go through [`rustc_smir::context::SmirCtxt`].
-pub trait InternalCx<'tcx>: Copy + Clone {
-    fn tcx(self) -> TyCtxt<'tcx>;
-
-    fn lift<T: ty::Lift<TyCtxt<'tcx>>>(self, value: T) -> Option<T::Lifted>;
-
-    fn mk_args_from_iter<I, T>(self, iter: I) -> T::Output
-    where
-        I: Iterator<Item = T>,
-        T: ty::CollectAndApply<ty::GenericArg<'tcx>, ty::GenericArgsRef<'tcx>>;
-
-    fn mk_pat(self, v: ty::PatternKind<'tcx>) -> ty::Pattern<'tcx>;
-
-    fn mk_poly_existential_predicates(
-        self,
-        eps: &[ty::PolyExistentialPredicate<'tcx>],
-    ) -> &'tcx List<ty::PolyExistentialPredicate<'tcx>>;
-
-    fn mk_type_list(self, v: &[Ty<'tcx>]) -> &'tcx List<Ty<'tcx>>;
-
-    fn lifetimes_re_erased(self) -> ty::Region<'tcx>;
-
-    fn mk_bound_variable_kinds_from_iter<I, T>(self, iter: I) -> T::Output
-    where
-        I: Iterator<Item = T>,
-        T: ty::CollectAndApply<ty::BoundVariableKind, &'tcx List<ty::BoundVariableKind>>;
-
-    fn mk_place_elems(self, v: &[mir::PlaceElem<'tcx>]) -> &'tcx List<mir::PlaceElem<'tcx>>;
-
-    fn adt_def(self, def_id: rustc_hir::def_id::DefId) -> ty::AdtDef<'tcx>;
-}
-
-/// Trait used to convert between an internal MIR type to a Stable MIR type.
-///
-/// This trait is currently exposed to users so they can have interoperability between internal MIR
-/// and StableMIR constructs. However, they should be used seldom and they have no influence
-/// in this crate semver.
-#[doc(hidden)]
-pub trait Stable<'tcx>: PointeeSized {
-    /// The stable representation of the type implementing Stable.
-    type T;
-    /// Converts an object to the equivalent Stable MIR representation.
-    fn stable<'cx>(
-        &self,
-        tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
-    ) -> Self::T;
-}
-
-/// Trait used to translate a stable construct to its rustc counterpart.
-///
-/// This is basically a mirror of [Stable].
-///
-/// This trait is currently exposed to users so they can have interoperability between internal MIR
-/// and StableMIR constructs. They should be used seldom as they have no stability guarantees.
-#[doc(hidden)]
-pub trait RustcInternal {
-    type T<'tcx>;
-    fn internal<'tcx>(
-        &self,
-        tables: &mut Tables<'_, BridgeTys>,
-        tcx: impl InternalCx<'tcx>,
-    ) -> Self::T<'tcx>;
-}
-
-pub(crate) fn new_item_kind(kind: DefKind) -> ItemKind {
-    match kind {
-        DefKind::Mod
-        | DefKind::Struct
-        | DefKind::Union
-        | DefKind::Enum
-        | DefKind::Variant
-        | DefKind::Trait
-        | DefKind::TyAlias
-        | DefKind::ForeignTy
-        | DefKind::TraitAlias
-        | DefKind::AssocTy
-        | DefKind::TyParam
-        | DefKind::ConstParam
-        | DefKind::Macro(_)
-        | DefKind::ExternCrate
-        | DefKind::Use
-        | DefKind::ForeignMod
-        | DefKind::OpaqueTy
-        | DefKind::Field
-        | DefKind::LifetimeParam
-        | DefKind::Impl { .. }
-        | DefKind::GlobalAsm => {
-            unreachable!("Not a valid item kind: {kind:?}");
-        }
-        DefKind::Closure | DefKind::AssocFn | DefKind::Fn | DefKind::SyntheticCoroutineBody => {
-            ItemKind::Fn
-        }
-        DefKind::Const | DefKind::InlineConst | DefKind::AssocConst | DefKind::AnonConst => {
-            ItemKind::Const
-        }
-        DefKind::Static { .. } => ItemKind::Static,
-        DefKind::Ctor(_, rustc_hir::def::CtorKind::Const) => ItemKind::Ctor(CtorKind::Const),
-        DefKind::Ctor(_, rustc_hir::def::CtorKind::Fn) => ItemKind::Ctor(CtorKind::Fn),
-    }
-}
diff --git a/compiler/stable_mir/src/visitor.rs b/compiler/stable_mir/src/visitor.rs
deleted file mode 100644
index 45e2a815470..00000000000
--- a/compiler/stable_mir/src/visitor.rs
+++ /dev/null
@@ -1,224 +0,0 @@
-use std::ops::ControlFlow;
-
-use super::ty::{
-    Allocation, Binder, ConstDef, ExistentialPredicate, FnSig, GenericArgKind, GenericArgs,
-    MirConst, Promoted, Region, RigidTy, TermKind, Ty, UnevaluatedConst,
-};
-use crate::Opaque;
-use crate::ty::TyConst;
-
-pub trait Visitor: Sized {
-    type Break;
-    fn visit_ty(&mut self, ty: &Ty) -> ControlFlow<Self::Break> {
-        ty.super_visit(self)
-    }
-    fn visit_const(&mut self, c: &TyConst) -> ControlFlow<Self::Break> {
-        c.super_visit(self)
-    }
-    fn visit_reg(&mut self, reg: &Region) -> ControlFlow<Self::Break> {
-        reg.super_visit(self)
-    }
-}
-
-pub trait Visitable {
-    fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        self.super_visit(visitor)
-    }
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break>;
-}
-
-impl Visitable for Ty {
-    fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        visitor.visit_ty(self)
-    }
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        match self.kind() {
-            super::ty::TyKind::RigidTy(ty) => ty.visit(visitor)?,
-            super::ty::TyKind::Alias(_, alias) => alias.args.visit(visitor)?,
-            super::ty::TyKind::Param(_) | super::ty::TyKind::Bound(_, _) => {}
-        }
-        ControlFlow::Continue(())
-    }
-}
-
-impl Visitable for TyConst {
-    fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        visitor.visit_const(self)
-    }
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        match &self.kind {
-            super::ty::TyConstKind::Param(_) | super::ty::TyConstKind::Bound(_, _) => {}
-            super::ty::TyConstKind::Unevaluated(_, args) => args.visit(visitor)?,
-            super::ty::TyConstKind::Value(ty, alloc) => {
-                alloc.visit(visitor)?;
-                ty.visit(visitor)?;
-            }
-            super::ty::TyConstKind::ZSTValue(ty) => ty.visit(visitor)?,
-        }
-        ControlFlow::Continue(())
-    }
-}
-
-impl Visitable for MirConst {
-    fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        self.super_visit(visitor)
-    }
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        match &self.kind() {
-            super::ty::ConstantKind::Ty(ct) => ct.visit(visitor)?,
-            super::ty::ConstantKind::Allocated(alloc) => alloc.visit(visitor)?,
-            super::ty::ConstantKind::Unevaluated(uv) => uv.visit(visitor)?,
-            super::ty::ConstantKind::Param(_) | super::ty::ConstantKind::ZeroSized => {}
-        }
-        self.ty().visit(visitor)
-    }
-}
-
-impl Visitable for Opaque {
-    fn super_visit<V: Visitor>(&self, _visitor: &mut V) -> ControlFlow<V::Break> {
-        ControlFlow::Continue(())
-    }
-}
-
-impl Visitable for Allocation {
-    fn super_visit<V: Visitor>(&self, _visitor: &mut V) -> ControlFlow<V::Break> {
-        ControlFlow::Continue(())
-    }
-}
-
-impl Visitable for UnevaluatedConst {
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        let UnevaluatedConst { def, args, promoted } = self;
-        def.visit(visitor)?;
-        args.visit(visitor)?;
-        promoted.visit(visitor)
-    }
-}
-
-impl Visitable for ConstDef {
-    fn super_visit<V: Visitor>(&self, _visitor: &mut V) -> ControlFlow<V::Break> {
-        ControlFlow::Continue(())
-    }
-}
-
-impl<T: Visitable> Visitable for Option<T> {
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        match self {
-            Some(val) => val.visit(visitor),
-            None => ControlFlow::Continue(()),
-        }
-    }
-}
-
-impl Visitable for Promoted {
-    fn super_visit<V: Visitor>(&self, _visitor: &mut V) -> ControlFlow<V::Break> {
-        ControlFlow::Continue(())
-    }
-}
-
-impl Visitable for GenericArgs {
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        self.0.visit(visitor)
-    }
-}
-
-impl Visitable for Region {
-    fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        visitor.visit_reg(self)
-    }
-
-    fn super_visit<V: Visitor>(&self, _: &mut V) -> ControlFlow<V::Break> {
-        ControlFlow::Continue(())
-    }
-}
-
-impl Visitable for GenericArgKind {
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        match self {
-            GenericArgKind::Lifetime(lt) => lt.visit(visitor),
-            GenericArgKind::Type(t) => t.visit(visitor),
-            GenericArgKind::Const(c) => c.visit(visitor),
-        }
-    }
-}
-
-impl Visitable for RigidTy {
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        match self {
-            RigidTy::Bool
-            | RigidTy::Char
-            | RigidTy::Int(_)
-            | RigidTy::Uint(_)
-            | RigidTy::Float(_)
-            | RigidTy::Never
-            | RigidTy::Foreign(_)
-            | RigidTy::Str => ControlFlow::Continue(()),
-            RigidTy::Array(t, c) => {
-                t.visit(visitor)?;
-                c.visit(visitor)
-            }
-            RigidTy::Pat(t, _p) => t.visit(visitor),
-            RigidTy::Slice(inner) => inner.visit(visitor),
-            RigidTy::RawPtr(ty, _) => ty.visit(visitor),
-            RigidTy::Ref(reg, ty, _) => {
-                reg.visit(visitor)?;
-                ty.visit(visitor)
-            }
-            RigidTy::Adt(_, args)
-            | RigidTy::Closure(_, args)
-            | RigidTy::Coroutine(_, args, _)
-            | RigidTy::CoroutineWitness(_, args)
-            | RigidTy::CoroutineClosure(_, args)
-            | RigidTy::FnDef(_, args) => args.visit(visitor),
-            RigidTy::FnPtr(sig) => sig.visit(visitor),
-            RigidTy::Dynamic(pred, r, _) => {
-                pred.visit(visitor)?;
-                r.visit(visitor)
-            }
-            RigidTy::Tuple(fields) => fields.visit(visitor),
-        }
-    }
-}
-
-impl<T: Visitable> Visitable for Vec<T> {
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        for arg in self {
-            arg.visit(visitor)?;
-        }
-        ControlFlow::Continue(())
-    }
-}
-
-impl<T: Visitable> Visitable for Binder<T> {
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        self.value.visit(visitor)
-    }
-}
-
-impl Visitable for ExistentialPredicate {
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        match self {
-            ExistentialPredicate::Trait(tr) => tr.generic_args.visit(visitor),
-            ExistentialPredicate::Projection(p) => {
-                p.term.visit(visitor)?;
-                p.generic_args.visit(visitor)
-            }
-            ExistentialPredicate::AutoTrait(_) => ControlFlow::Continue(()),
-        }
-    }
-}
-
-impl Visitable for TermKind {
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        match self {
-            TermKind::Type(t) => t.visit(visitor),
-            TermKind::Const(c) => c.visit(visitor),
-        }
-    }
-}
-
-impl Visitable for FnSig {
-    fn super_visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
-        self.inputs_and_output.visit(visitor)
-    }
-}
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 1282a89a5e4..09bb2e35bda 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -2400,10 +2400,10 @@ pub fn run_cargo(
                 keep = true;
             } else if rlib_only_metadata {
                 if filename.contains("jemalloc_sys")
-                    || filename.contains("rustc_smir")
-                    || filename.contains("stable_mir")
+                    || filename.contains("rustc_public_bridge")
+                    || filename.contains("rustc_public")
                 {
-                    // jemalloc_sys and rustc_smir are not linked into librustc_driver.so,
+                    // jemalloc_sys and rustc_public_bridge are not linked into librustc_driver.so,
                     // so we need to distribute them as rlib to be able to use them.
                     keep |= filename.ends_with(".rlib");
                 } else {
diff --git a/tests/ui-fulldeps/stable-mir/check_abi.rs b/tests/ui-fulldeps/stable-mir/check_abi.rs
index 9d83dd9ce1a..fc2227d147d 100644
--- a/tests/ui-fulldeps/stable-mir/check_abi.rs
+++ b/tests/ui-fulldeps/stable-mir/check_abi.rs
@@ -14,17 +14,17 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::abi::{
+use rustc_public::abi::{
     ArgAbi, CallConvention, FieldsShape, IntegerLength, PassMode, Primitive, Scalar, ValueAbi,
     VariantsShape,
 };
-use stable_mir::mir::MirVisitor;
-use stable_mir::mir::mono::Instance;
-use stable_mir::target::MachineInfo;
-use stable_mir::ty::{AdtDef, RigidTy, Ty, TyKind};
-use stable_mir::{CrateDef, CrateItem, CrateItems, ItemKind};
+use rustc_public::mir::MirVisitor;
+use rustc_public::mir::mono::Instance;
+use rustc_public::target::MachineInfo;
+use rustc_public::ty::{AdtDef, RigidTy, Ty, TyKind};
+use rustc_public::{CrateDef, CrateItem, CrateItems, ItemKind};
 use std::assert_matches::assert_matches;
 use std::collections::HashSet;
 use std::convert::TryFrom;
@@ -36,7 +36,7 @@ const CRATE_NAME: &str = "input";
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_stable_mir() -> ControlFlow<()> {
     // Find items in the local crate.
-    let items = stable_mir::all_local_items();
+    let items = rustc_public::all_local_items();
 
     // Test fn_abi
     let target_fn = *get_item(&items, (ItemKind::Fn, "fn_abi")).unwrap();
@@ -69,7 +69,7 @@ fn test_stable_mir() -> ControlFlow<()> {
     assert!(ptr_variadic_fn_abi.c_variadic);
     assert_eq!(ptr_variadic_fn_abi.args.len(), 1);
 
-    let entry = stable_mir::entry_fn().unwrap();
+    let entry = rustc_public::entry_fn().unwrap();
     let main_fn = Instance::try_from(entry).unwrap();
     let mut visitor = AdtDefVisitor::default();
     visitor.visit_body(&main_fn.body().unwrap());
@@ -147,7 +147,7 @@ fn check_niche(abi: &ArgAbi) {
 fn get_item<'a>(
     items: &'a CrateItems,
     item: (ItemKind, &str),
-) -> Option<&'a stable_mir::CrateItem> {
+) -> Option<&'a rustc_public::CrateItem> {
     items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1)
 }
 
@@ -157,7 +157,7 @@ struct AdtDefVisitor {
 }
 
 impl MirVisitor for AdtDefVisitor {
-    fn visit_ty(&mut self, ty: &Ty, _location: stable_mir::mir::visit::Location) {
+    fn visit_ty(&mut self, ty: &Ty, _location: rustc_public::mir::visit::Location) {
         if let TyKind::RigidTy(RigidTy::Adt(adt, _)) = ty.kind() {
             self.adt_defs.insert(adt);
         }
diff --git a/tests/ui-fulldeps/stable-mir/check_allocation.rs b/tests/ui-fulldeps/stable-mir/check_allocation.rs
index c2d1d5d873b..83845a9aa42 100644
--- a/tests/ui-fulldeps/stable-mir/check_allocation.rs
+++ b/tests/ui-fulldeps/stable-mir/check_allocation.rs
@@ -17,7 +17,7 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
 use std::ascii::Char;
 use std::assert_matches::assert_matches;
@@ -27,19 +27,19 @@ use std::ffi::CStr;
 use std::io::Write;
 use std::ops::ControlFlow;
 
-use stable_mir::crate_def::CrateDef;
-use stable_mir::mir::Body;
-use stable_mir::mir::alloc::GlobalAlloc;
-use stable_mir::mir::mono::{Instance, StaticDef};
-use stable_mir::ty::{Allocation, ConstantKind};
-use stable_mir::{CrateItem, CrateItems, ItemKind};
+use rustc_public::crate_def::CrateDef;
+use rustc_public::mir::Body;
+use rustc_public::mir::alloc::GlobalAlloc;
+use rustc_public::mir::mono::{Instance, StaticDef};
+use rustc_public::ty::{Allocation, ConstantKind};
+use rustc_public::{CrateItem, CrateItems, ItemKind};
 
 const CRATE_NAME: &str = "input";
 
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_stable_mir() -> ControlFlow<()> {
     // Find items in the local crate.
-    let items = stable_mir::all_local_items();
+    let items = rustc_public::all_local_items();
     check_foo(*get_item(&items, (ItemKind::Static, "FOO")).unwrap());
     check_bar(*get_item(&items, (ItemKind::Static, "BAR")).unwrap());
     check_len(*get_item(&items, (ItemKind::Static, "LEN")).unwrap());
@@ -164,7 +164,7 @@ fn check_other_consts(item: CrateItem) {
     }
     let bool_id = bool_id.unwrap();
     let char_id = char_id.unwrap();
-    // FIXME(stable_mir): add `read_ptr` to `Allocation`
+    // FIXME(rustc_public): add `read_ptr` to `Allocation`
     assert_ne!(bool_id, char_id);
 }
 
@@ -196,7 +196,7 @@ fn check_len(item: CrateItem) {
 fn get_item<'a>(
     items: &'a CrateItems,
     item: (ItemKind, &str),
-) -> Option<&'a stable_mir::CrateItem> {
+) -> Option<&'a rustc_public::CrateItem> {
     items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1)
 }
 
diff --git a/tests/ui-fulldeps/stable-mir/check_assoc_items.rs b/tests/ui-fulldeps/stable-mir/check_assoc_items.rs
index 574f7797854..1557991f8ca 100644
--- a/tests/ui-fulldeps/stable-mir/check_assoc_items.rs
+++ b/tests/ui-fulldeps/stable-mir/check_assoc_items.rs
@@ -14,20 +14,20 @@ extern crate rustc_middle;
 
 extern crate rustc_driver;
 extern crate rustc_interface;
-extern crate stable_mir;
+extern crate rustc_public;
 
 use std::collections::HashSet;
 use std::io::Write;
 use std::ops::ControlFlow;
 
-use stable_mir::ty::*;
-use stable_mir::{CrateDef, *};
+use rustc_public::ty::*;
+use rustc_public::{CrateDef, *};
 
 const CRATE_NAME: &str = "crate_assoc_items";
 
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_assoc_items() -> ControlFlow<()> {
-    let local_crate = stable_mir::local_crate();
+    let local_crate = rustc_public::local_crate();
     check_items(
         &local_crate.fn_defs(),
         &[
diff --git a/tests/ui-fulldeps/stable-mir/check_attribute.rs b/tests/ui-fulldeps/stable-mir/check_attribute.rs
index f234c658dfd..d8807872ec4 100644
--- a/tests/ui-fulldeps/stable-mir/check_attribute.rs
+++ b/tests/ui-fulldeps/stable-mir/check_attribute.rs
@@ -13,9 +13,9 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::{CrateDef, CrateItems};
+use rustc_public::{CrateDef, CrateItems};
 use std::io::Write;
 use std::ops::ControlFlow;
 
@@ -24,7 +24,7 @@ const CRATE_NAME: &str = "input";
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_stable_mir() -> ControlFlow<()> {
     // Find items in the local crate.
-    let items = stable_mir::all_local_items();
+    let items = rustc_public::all_local_items();
 
     test_tool(&items);
 
@@ -46,7 +46,7 @@ fn test_tool(items: &CrateItems) {
 fn get_item<'a>(
     items: &'a CrateItems,
     name: &str,
-) -> Option<&'a stable_mir::CrateItem> {
+) -> Option<&'a rustc_public::CrateItem> {
     items.iter().find(|crate_item| crate_item.name() == name)
 }
 
diff --git a/tests/ui-fulldeps/stable-mir/check_binop.rs b/tests/ui-fulldeps/stable-mir/check_binop.rs
index 748c2088a30..aa089a5d125 100644
--- a/tests/ui-fulldeps/stable-mir/check_binop.rs
+++ b/tests/ui-fulldeps/stable-mir/check_binop.rs
@@ -13,12 +13,12 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::mir::mono::Instance;
-use stable_mir::mir::visit::{Location, MirVisitor};
-use stable_mir::mir::{LocalDecl, Rvalue, Statement, StatementKind, Terminator, TerminatorKind};
-use stable_mir::ty::{RigidTy, TyKind};
+use rustc_public::mir::mono::Instance;
+use rustc_public::mir::visit::{Location, MirVisitor};
+use rustc_public::mir::{LocalDecl, Rvalue, Statement, StatementKind, Terminator, TerminatorKind};
+use rustc_public::ty::{RigidTy, TyKind};
 use std::collections::HashSet;
 use std::convert::TryFrom;
 use std::io::Write;
@@ -27,7 +27,7 @@ use std::ops::ControlFlow;
 /// This function tests that we can correctly get type information from binary operations.
 fn test_binops() -> ControlFlow<()> {
     // Find items in the local crate.
-    let items = stable_mir::all_local_items();
+    let items = rustc_public::all_local_items();
     let mut instances =
         items.into_iter().map(|item| Instance::try_from(item).unwrap()).collect::<Vec<_>>();
     while let Some(instance) = instances.pop() {
diff --git a/tests/ui-fulldeps/stable-mir/check_coroutine_body.rs b/tests/ui-fulldeps/stable-mir/check_coroutine_body.rs
index 2af32afc1f7..725b538b0fe 100644
--- a/tests/ui-fulldeps/stable-mir/check_coroutine_body.rs
+++ b/tests/ui-fulldeps/stable-mir/check_coroutine_body.rs
@@ -14,18 +14,18 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
 use std::io::Write;
 use std::ops::ControlFlow;
 
-use stable_mir::mir::Body;
-use stable_mir::ty::{RigidTy, TyKind};
+use rustc_public::mir::Body;
+use rustc_public::ty::{RigidTy, TyKind};
 
 const CRATE_NAME: &str = "crate_coroutine_body";
 
 fn test_coroutine_body() -> ControlFlow<()> {
-    let crate_items = stable_mir::all_local_items();
+    let crate_items = rustc_public::all_local_items();
     if let Some(body) = crate_items.iter().find_map(|item| {
         let item_ty = item.ty();
         if let TyKind::RigidTy(RigidTy::Coroutine(def, ..)) = &item_ty.kind() {
diff --git a/tests/ui-fulldeps/stable-mir/check_crate_defs.rs b/tests/ui-fulldeps/stable-mir/check_crate_defs.rs
index d3929c5e48b..27d5b0bc238 100644
--- a/tests/ui-fulldeps/stable-mir/check_crate_defs.rs
+++ b/tests/ui-fulldeps/stable-mir/check_crate_defs.rs
@@ -14,9 +14,9 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::CrateDef;
+use rustc_public::CrateDef;
 use std::collections::HashSet;
 use std::io::Write;
 use std::ops::ControlFlow;
@@ -26,7 +26,7 @@ const CRATE_NAME: &str = "crate_defs";
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_stable_mir() -> ControlFlow<()> {
     // Find items in the local crate.
-    let local = stable_mir::local_crate();
+    let local = rustc_public::local_crate();
     check_items(&local.statics(), &["PRIVATE_STATIC", "dummy::PUBLIC_STATIC"]);
     check_items(
         &local.fn_defs(),
@@ -44,7 +44,7 @@ fn test_stable_mir() -> ControlFlow<()> {
     // Find items inside core crate.
     // FIXME: We are currently missing primitive type methods and trait implementations for external
     // crates.
-    let core = stable_mir::find_crates("core").pop().expect("Cannot find `core` crate");
+    let core = rustc_public::find_crates("core").pop().expect("Cannot find `core` crate");
     contains(
         &core.fn_defs(),
         &[
diff --git a/tests/ui-fulldeps/stable-mir/check_def_ty.rs b/tests/ui-fulldeps/stable-mir/check_def_ty.rs
index 101e7eb9121..b5954352dc0 100644
--- a/tests/ui-fulldeps/stable-mir/check_def_ty.rs
+++ b/tests/ui-fulldeps/stable-mir/check_def_ty.rs
@@ -14,10 +14,10 @@ extern crate rustc_middle;
 
 extern crate rustc_driver;
 extern crate rustc_interface;
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::ty::{Ty, ForeignItemKind};
-use stable_mir::*;
+use rustc_public::ty::{Ty, ForeignItemKind};
+use rustc_public::*;
 use std::io::Write;
 use std::ops::ControlFlow;
 
@@ -25,7 +25,7 @@ const CRATE_NAME: &str = "crate_def_ty";
 
 /// Test if we can retrieve type information from different definitions.
 fn test_def_tys() -> ControlFlow<()> {
-    let items = stable_mir::all_local_items();
+    let items = rustc_public::all_local_items();
     for item in &items {
         // Type from crate items.
         let ty = item.ty();
@@ -37,7 +37,7 @@ fn test_def_tys() -> ControlFlow<()> {
         }
     }
 
-    let foreign_items = stable_mir::local_crate().foreign_modules();
+    let foreign_items = rustc_public::local_crate().foreign_modules();
     for item in foreign_items[0].module().items() {
         // Type from foreign items.
         let ty = item.ty();
diff --git a/tests/ui-fulldeps/stable-mir/check_defs.rs b/tests/ui-fulldeps/stable-mir/check_defs.rs
index 65db50ee3ff..5e45f19cac8 100644
--- a/tests/ui-fulldeps/stable-mir/check_defs.rs
+++ b/tests/ui-fulldeps/stable-mir/check_defs.rs
@@ -13,13 +13,13 @@ extern crate rustc_middle;
 
 extern crate rustc_driver;
 extern crate rustc_interface;
-extern crate stable_mir;
+extern crate rustc_public;
 
 use std::assert_matches::assert_matches;
 use mir::{mono::Instance, TerminatorKind::*};
-use stable_mir::mir::mono::InstanceKind;
-use stable_mir::ty::{RigidTy, TyKind, Ty, UintTy};
-use stable_mir::*;
+use rustc_public::mir::mono::InstanceKind;
+use rustc_public::ty::{RigidTy, TyKind, Ty, UintTy};
+use rustc_public::*;
 use std::io::Write;
 use std::ops::ControlFlow;
 
@@ -27,7 +27,7 @@ const CRATE_NAME: &str = "input";
 
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_stable_mir() -> ControlFlow<()> {
-    let entry = stable_mir::entry_fn().unwrap();
+    let entry = rustc_public::entry_fn().unwrap();
     let main_fn = Instance::try_from(entry).unwrap();
     assert_eq!(main_fn.name(), "main");
     assert_eq!(main_fn.trimmed_name(), "main");
diff --git a/tests/ui-fulldeps/stable-mir/check_foreign.rs b/tests/ui-fulldeps/stable-mir/check_foreign.rs
index 2947d51b63b..9aee067f41b 100644
--- a/tests/ui-fulldeps/stable-mir/check_foreign.rs
+++ b/tests/ui-fulldeps/stable-mir/check_foreign.rs
@@ -14,9 +14,9 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 extern crate rustc_span;
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::{
+use rustc_public::{
     ty::{Abi, ForeignItemKind},
     *,
 };
diff --git a/tests/ui-fulldeps/stable-mir/check_instance.rs b/tests/ui-fulldeps/stable-mir/check_instance.rs
index 9b1e4176531..18971076043 100644
--- a/tests/ui-fulldeps/stable-mir/check_instance.rs
+++ b/tests/ui-fulldeps/stable-mir/check_instance.rs
@@ -13,21 +13,21 @@ extern crate rustc_middle;
 
 extern crate rustc_driver;
 extern crate rustc_interface;
-extern crate stable_mir;
+extern crate rustc_public;
 
 use std::io::Write;
 use std::ops::ControlFlow;
 
 use mir::mono::Instance;
 use mir::TerminatorKind::*;
-use stable_mir::ty::{RigidTy, TyKind};
-use stable_mir::*;
+use rustc_public::ty::{RigidTy, TyKind};
+use rustc_public::*;
 
 const CRATE_NAME: &str = "input";
 
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_stable_mir() -> ControlFlow<()> {
-    let items = stable_mir::all_local_items();
+    let items = rustc_public::all_local_items();
 
     // Get all items and split generic vs monomorphic items.
     let (generic, mono): (Vec<_>, Vec<_>) =
diff --git a/tests/ui-fulldeps/stable-mir/check_intrinsics.rs b/tests/ui-fulldeps/stable-mir/check_intrinsics.rs
index 2fce367c7a0..854ac77956e 100644
--- a/tests/ui-fulldeps/stable-mir/check_intrinsics.rs
+++ b/tests/ui-fulldeps/stable-mir/check_intrinsics.rs
@@ -18,12 +18,12 @@ extern crate rustc_hir;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::mir::mono::{Instance, InstanceKind};
-use stable_mir::mir::visit::{Location, MirVisitor};
-use stable_mir::mir::{LocalDecl, Terminator, TerminatorKind};
-use stable_mir::ty::{FnDef, GenericArgs, RigidTy, TyKind};
+use rustc_public::mir::mono::{Instance, InstanceKind};
+use rustc_public::mir::visit::{Location, MirVisitor};
+use rustc_public::mir::{LocalDecl, Terminator, TerminatorKind};
+use rustc_public::ty::{FnDef, GenericArgs, RigidTy, TyKind};
 use std::assert_matches::assert_matches;
 use std::convert::TryFrom;
 use std::io::Write;
@@ -32,7 +32,7 @@ use std::ops::ControlFlow;
 /// This function tests that we can correctly get type information from binary operations.
 fn test_intrinsics() -> ControlFlow<()> {
     // Find items in the local crate.
-    let main_def = stable_mir::all_local_items()[0];
+    let main_def = rustc_public::all_local_items()[0];
     let main_instance = Instance::try_from(main_def).unwrap();
     let main_body = main_instance.body().unwrap();
     let mut visitor = CallsVisitor { locals: main_body.locals(), calls: Default::default() };
diff --git a/tests/ui-fulldeps/stable-mir/check_item_kind.rs b/tests/ui-fulldeps/stable-mir/check_item_kind.rs
index 20b9e86ff92..58e740bdaef 100644
--- a/tests/ui-fulldeps/stable-mir/check_item_kind.rs
+++ b/tests/ui-fulldeps/stable-mir/check_item_kind.rs
@@ -13,9 +13,9 @@ extern crate rustc_middle;
 
 extern crate rustc_driver;
 extern crate rustc_interface;
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::*;
+use rustc_public::*;
 use std::io::Write;
 use std::ops::ControlFlow;
 
@@ -23,7 +23,7 @@ const CRATE_NAME: &str = "input";
 
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_item_kind() -> ControlFlow<()> {
-    let items = stable_mir::all_local_items();
+    let items = rustc_public::all_local_items();
     assert_eq!(items.len(), 4);
     // Constructor item.
     for item in items {
diff --git a/tests/ui-fulldeps/stable-mir/check_normalization.rs b/tests/ui-fulldeps/stable-mir/check_normalization.rs
index bb5cd49e1b0..aa6a257dac6 100644
--- a/tests/ui-fulldeps/stable-mir/check_normalization.rs
+++ b/tests/ui-fulldeps/stable-mir/check_normalization.rs
@@ -12,11 +12,11 @@ extern crate rustc_middle;
 
 extern crate rustc_driver;
 extern crate rustc_interface;
-extern crate stable_mir;
+extern crate rustc_public;
 
 use mir::mono::Instance;
 use ty::{Ty, TyKind, RigidTy};
-use stable_mir::*;
+use rustc_public::*;
 use std::io::Write;
 use std::ops::ControlFlow;
 
@@ -24,7 +24,7 @@ const CRATE_NAME: &str = "input";
 
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_stable_mir() -> ControlFlow<()> {
-    let items = stable_mir::all_local_items();
+    let items = rustc_public::all_local_items();
 
     // Get all items and split generic vs monomorphic items.
     let instances: Vec<_> =
diff --git a/tests/ui-fulldeps/stable-mir/check_trait_queries.rs b/tests/ui-fulldeps/stable-mir/check_trait_queries.rs
index 73ba0ea23c9..a6c37883643 100644
--- a/tests/ui-fulldeps/stable-mir/check_trait_queries.rs
+++ b/tests/ui-fulldeps/stable-mir/check_trait_queries.rs
@@ -14,9 +14,9 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::CrateDef;
+use rustc_public::CrateDef;
 use std::collections::HashSet;
 use std::io::Write;
 use std::ops::ControlFlow;
@@ -25,7 +25,7 @@ const CRATE_NAME: &str = "trait_test";
 
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_traits() -> ControlFlow<()> {
-    let local_crate = stable_mir::local_crate();
+    let local_crate = rustc_public::local_crate();
     let local_traits = local_crate.trait_decls();
     assert_eq!(local_traits.len(), 1, "Expected `Max` trait, but found {:?}", local_traits);
     assert_eq!(&local_traits[0].name(), "Max");
@@ -42,14 +42,14 @@ fn test_traits() -> ControlFlow<()> {
     assert_impl(&impl_names, "<u64 as Max>");
     assert_impl(&impl_names, "<impl std::convert::From<Positive> for u64>");
 
-    let all_traits = stable_mir::all_trait_decls();
+    let all_traits = rustc_public::all_trait_decls();
     assert!(all_traits.len() > local_traits.len());
     assert!(
         local_traits.iter().all(|t| all_traits.contains(t)),
         "Local: {local_traits:#?}, All: {all_traits:#?}"
     );
 
-    let all_impls = stable_mir::all_trait_impls();
+    let all_impls = rustc_public::all_trait_impls();
     assert!(all_impls.len() > local_impls.len());
     assert!(
         local_impls.iter().all(|t| all_impls.contains(t)),
diff --git a/tests/ui-fulldeps/stable-mir/check_transform.rs b/tests/ui-fulldeps/stable-mir/check_transform.rs
index 460f1b9e963..3209fcf9ede 100644
--- a/tests/ui-fulldeps/stable-mir/check_transform.rs
+++ b/tests/ui-fulldeps/stable-mir/check_transform.rs
@@ -15,13 +15,13 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::mir::alloc::GlobalAlloc;
-use stable_mir::mir::mono::Instance;
-use stable_mir::mir::{Body, ConstOperand, Operand, Rvalue, StatementKind, TerminatorKind};
-use stable_mir::ty::{ConstantKind, MirConst};
-use stable_mir::{CrateDef, CrateItems, ItemKind};
+use rustc_public::mir::alloc::GlobalAlloc;
+use rustc_public::mir::mono::Instance;
+use rustc_public::mir::{Body, ConstOperand, Operand, Rvalue, StatementKind, TerminatorKind};
+use rustc_public::ty::{ConstantKind, MirConst};
+use rustc_public::{CrateDef, CrateItems, ItemKind};
 use std::convert::TryFrom;
 use std::io::Write;
 use std::ops::ControlFlow;
@@ -31,7 +31,7 @@ const CRATE_NAME: &str = "input";
 /// This function uses the Stable MIR APIs to transform the MIR.
 fn test_transform() -> ControlFlow<()> {
     // Find items in the local crate.
-    let items = stable_mir::all_local_items();
+    let items = rustc_public::all_local_items();
 
     // Test fn_abi
     let target_fn = *get_item(&items, (ItemKind::Fn, "dummy")).unwrap();
@@ -109,7 +109,7 @@ fn change_panic_msg(mut body: Body, new_msg: &str) -> Body {
 fn get_item<'a>(
     items: &'a CrateItems,
     item: (ItemKind, &str),
-) -> Option<&'a stable_mir::CrateItem> {
+) -> Option<&'a rustc_public::CrateItem> {
     items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1)
 }
 
diff --git a/tests/ui-fulldeps/stable-mir/check_ty_fold.rs b/tests/ui-fulldeps/stable-mir/check_ty_fold.rs
index 1a21757d038..07ef0d2bb50 100644
--- a/tests/ui-fulldeps/stable-mir/check_ty_fold.rs
+++ b/tests/ui-fulldeps/stable-mir/check_ty_fold.rs
@@ -15,13 +15,13 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::mir::{
+use rustc_public::mir::{
     Body, FieldIdx, MirVisitor, Place, ProjectionElem,
     visit::{Location, PlaceContext},
 };
-use stable_mir::ty::{RigidTy, Ty, TyKind};
+use rustc_public::ty::{RigidTy, Ty, TyKind};
 use std::io::Write;
 use std::ops::ControlFlow;
 
@@ -29,7 +29,7 @@ const CRATE_NAME: &str = "input";
 
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_stable_mir() -> ControlFlow<()> {
-    let main_fn = stable_mir::entry_fn();
+    let main_fn = rustc_public::entry_fn();
     let body = main_fn.unwrap().expect_body();
     let mut visitor = PlaceVisitor { body: &body, tested: false };
     visitor.visit_body(&body);
diff --git a/tests/ui-fulldeps/stable-mir/check_variant.rs b/tests/ui-fulldeps/stable-mir/check_variant.rs
index 4cff57308f6..ebe76bd89d5 100644
--- a/tests/ui-fulldeps/stable-mir/check_variant.rs
+++ b/tests/ui-fulldeps/stable-mir/check_variant.rs
@@ -15,15 +15,15 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
 use std::io::Write;
 use std::ops::ControlFlow;
 
-use stable_mir::CrateItem;
-use stable_mir::crate_def::CrateDef;
-use stable_mir::mir::{AggregateKind, Rvalue, Statement, StatementKind};
-use stable_mir::ty::{IntTy, RigidTy, Ty};
+use rustc_public::CrateItem;
+use rustc_public::crate_def::CrateDef;
+use rustc_public::mir::{AggregateKind, Rvalue, Statement, StatementKind};
+use rustc_public::ty::{IntTy, RigidTy, Ty};
 
 const CRATE_NAME: &str = "crate_variant_ty";
 
@@ -97,7 +97,7 @@ fn check_adt_poly2() {
 }
 
 fn get_fn(name: &str) -> CrateItem {
-    stable_mir::all_local_items().into_iter().find(|it| it.name().eq(name)).unwrap()
+    rustc_public::all_local_items().into_iter().find(|it| it.name().eq(name)).unwrap()
 }
 
 fn check_statement_is_aggregate_assign(
diff --git a/tests/ui-fulldeps/stable-mir/closure-generic-body.rs b/tests/ui-fulldeps/stable-mir/closure-generic-body.rs
index 6b3447e5839..e5f910fbda1 100644
--- a/tests/ui-fulldeps/stable-mir/closure-generic-body.rs
+++ b/tests/ui-fulldeps/stable-mir/closure-generic-body.rs
@@ -14,18 +14,18 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
 use std::io::Write;
 use std::ops::ControlFlow;
 
-use stable_mir::mir::{Body, ConstOperand, Operand, TerminatorKind};
-use stable_mir::ty::{FnDef, RigidTy, TyKind};
+use rustc_public::mir::{Body, ConstOperand, Operand, TerminatorKind};
+use rustc_public::ty::{FnDef, RigidTy, TyKind};
 
 const CRATE_NAME: &str = "crate_closure_body";
 
 fn test_closure_body() -> ControlFlow<()> {
-    let crate_items = stable_mir::all_local_items();
+    let crate_items = rustc_public::all_local_items();
     for item in crate_items {
         let item_ty = item.ty();
         match &item_ty.kind() {
diff --git a/tests/ui-fulldeps/stable-mir/closure_body.rs b/tests/ui-fulldeps/stable-mir/closure_body.rs
index a1c97e7549b..f5f9f23ad12 100644
--- a/tests/ui-fulldeps/stable-mir/closure_body.rs
+++ b/tests/ui-fulldeps/stable-mir/closure_body.rs
@@ -14,18 +14,18 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
 use std::io::Write;
 use std::ops::ControlFlow;
 
-use stable_mir::mir::{Body, ConstOperand, Operand, TerminatorKind};
-use stable_mir::ty::{FnDef, RigidTy, TyKind};
+use rustc_public::mir::{Body, ConstOperand, Operand, TerminatorKind};
+use rustc_public::ty::{FnDef, RigidTy, TyKind};
 
 const CRATE_NAME: &str = "crate_closure_body";
 
 fn test_closure_body() -> ControlFlow<()> {
-    let crate_items = stable_mir::all_local_items();
+    let crate_items = rustc_public::all_local_items();
     for item in crate_items {
         let item_ty = item.ty();
         match &item_ty.kind() {
diff --git a/tests/ui-fulldeps/stable-mir/compilation-result.rs b/tests/ui-fulldeps/stable-mir/compilation-result.rs
index d577de48c55..ed013375c71 100644
--- a/tests/ui-fulldeps/stable-mir/compilation-result.rs
+++ b/tests/ui-fulldeps/stable-mir/compilation-result.rs
@@ -14,7 +14,7 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
 use std::io::Write;
 
@@ -40,7 +40,7 @@ fn test_continue(args: &[String]) {
 
 fn test_break(args: &[String]) {
     let result = run!(args, || ControlFlow::Break::<bool, i32>(false));
-    assert_eq!(result, Err(stable_mir::CompilerError::Interrupted(false)));
+    assert_eq!(result, Err(rustc_public::CompilerError::Interrupted(false)));
 }
 
 #[allow(unreachable_code)]
@@ -48,7 +48,7 @@ fn test_skipped(args: &[String]) {
     let mut args = args.to_vec();
     args.push("--version".to_string());
     let result = run!(&args, || unreachable!() as ControlFlow<()>);
-    assert_eq!(result, Err(stable_mir::CompilerError::Skipped));
+    assert_eq!(result, Err(rustc_public::CompilerError::Skipped));
 }
 
 #[allow(unreachable_code)]
@@ -56,7 +56,7 @@ fn test_failed(args: &[String]) {
     let mut args = args.to_vec();
     args.push("--cfg=broken".to_string());
     let result = run!(&args, || unreachable!() as ControlFlow<()>);
-    assert_eq!(result, Err(stable_mir::CompilerError::Failed));
+    assert_eq!(result, Err(rustc_public::CompilerError::Failed));
 }
 
 /// Test that we are able to pass a closure and set the return according to the captured value.
diff --git a/tests/ui-fulldeps/stable-mir/crate-info.rs b/tests/ui-fulldeps/stable-mir/crate-info.rs
index fd7c2032b6d..4f46dff9b82 100644
--- a/tests/ui-fulldeps/stable-mir/crate-info.rs
+++ b/tests/ui-fulldeps/stable-mir/crate-info.rs
@@ -15,13 +15,13 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
 use rustc_hir::def::DefKind;
-use stable_mir::ItemKind;
-use stable_mir::crate_def::CrateDef;
-use stable_mir::mir::mono::Instance;
-use stable_mir::ty::{RigidTy, TyKind};
+use rustc_public::ItemKind;
+use rustc_public::crate_def::CrateDef;
+use rustc_public::mir::mono::Instance;
+use rustc_public::ty::{RigidTy, TyKind};
 use std::assert_matches::assert_matches;
 use std::io::Write;
 use std::ops::ControlFlow;
@@ -30,18 +30,18 @@ const CRATE_NAME: &str = "input";
 
 /// This function uses the Stable MIR APIs to get information about the test crate.
 fn test_stable_mir() -> ControlFlow<()> {
-    // Get the local crate using stable_mir API.
-    let local = stable_mir::local_crate();
+    // Get the local crate using rustc_public API.
+    let local = rustc_public::local_crate();
     assert_eq!(&local.name, CRATE_NAME);
 
-    assert_eq!(stable_mir::entry_fn(), None);
+    assert_eq!(rustc_public::entry_fn(), None);
 
     // Find items in the local crate.
-    let items = stable_mir::all_local_items();
+    let items = rustc_public::all_local_items();
     assert!(get_item(&items, (DefKind::Fn, "foo::bar")).is_some());
 
     // Find the `std` crate and assert that there is only one of it.
-    assert!(stable_mir::find_crates("std").len() == 1);
+    assert!(rustc_public::find_crates("std").len() == 1);
 
     let bar = get_item(&items, (DefKind::Fn, "bar")).unwrap();
     let body = bar.expect_body();
@@ -50,11 +50,11 @@ fn test_stable_mir() -> ControlFlow<()> {
     let block = &body.blocks[0];
     assert_eq!(block.statements.len(), 1);
     match &block.statements[0].kind {
-        stable_mir::mir::StatementKind::Assign(..) => {}
+        rustc_public::mir::StatementKind::Assign(..) => {}
         other => panic!("{other:?}"),
     }
     match &block.terminator.kind {
-        stable_mir::mir::TerminatorKind::Return => {}
+        rustc_public::mir::TerminatorKind::Return => {}
         other => panic!("{other:?}"),
     }
 
@@ -64,7 +64,7 @@ fn test_stable_mir() -> ControlFlow<()> {
     assert_eq!(body.blocks.len(), 4);
     let block = &body.blocks[0];
     match &block.terminator.kind {
-        stable_mir::mir::TerminatorKind::Call { .. } => {}
+        rustc_public::mir::TerminatorKind::Call { .. } => {}
         other => panic!("{other:?}"),
     }
 
@@ -73,28 +73,32 @@ fn test_stable_mir() -> ControlFlow<()> {
     assert_eq!(body.locals().len(), 6);
     assert_matches!(
         body.locals()[0].ty.kind(),
-        stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Bool)
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool)
     );
     assert_matches!(
         body.locals()[1].ty.kind(),
-        stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Bool)
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool)
     );
     assert_matches!(
         body.locals()[2].ty.kind(),
-        stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Char)
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Char)
     );
     assert_matches!(
         body.locals()[3].ty.kind(),
-        stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Int(stable_mir::ty::IntTy::I32))
+        rustc_public::ty::TyKind::RigidTy(
+            rustc_public::ty::RigidTy::Int(rustc_public::ty::IntTy::I32)
+        )
     );
     assert_matches!(
         body.locals()[4].ty.kind(),
-        stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Uint(stable_mir::ty::UintTy::U64))
+        rustc_public::ty::TyKind::RigidTy(
+            rustc_public::ty::RigidTy::Uint(rustc_public::ty::UintTy::U64)
+        )
     );
     assert_matches!(
         body.locals()[5].ty.kind(),
-        stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Float(
-            stable_mir::ty::FloatTy::F64
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Float(
+            rustc_public::ty::FloatTy::F64
         ))
     );
 
@@ -103,7 +107,7 @@ fn test_stable_mir() -> ControlFlow<()> {
     assert_eq!(body.blocks.len(), 2);
     let block = &body.blocks[0];
     match &block.terminator.kind {
-        stable_mir::mir::TerminatorKind::Drop { .. } => {}
+        rustc_public::mir::TerminatorKind::Drop { .. } => {}
         other => panic!("{other:?}"),
     }
 
@@ -112,7 +116,7 @@ fn test_stable_mir() -> ControlFlow<()> {
     assert_eq!(body.blocks.len(), 2);
     let block = &body.blocks[0];
     match &block.terminator.kind {
-        stable_mir::mir::TerminatorKind::Assert { .. } => {}
+        rustc_public::mir::TerminatorKind::Assert { .. } => {}
         other => panic!("{other:?}"),
     }
 
@@ -120,7 +124,7 @@ fn test_stable_mir() -> ControlFlow<()> {
     let instance = Instance::try_from(monomorphic.clone()).unwrap();
     for block in instance.body().unwrap().blocks {
         match &block.terminator.kind {
-            stable_mir::mir::TerminatorKind::Call { func, .. } => {
+            rustc_public::mir::TerminatorKind::Call { func, .. } => {
                 let TyKind::RigidTy(ty) = func.ty(&body.locals()).unwrap().kind() else {
                     unreachable!()
                 };
@@ -131,7 +135,7 @@ fn test_stable_mir() -> ControlFlow<()> {
                     other => panic!("{other:?}"),
                 }
             }
-            stable_mir::mir::TerminatorKind::Return => {}
+            rustc_public::mir::TerminatorKind::Return => {}
             other => panic!("{other:?}"),
         }
     }
@@ -145,22 +149,26 @@ fn test_stable_mir() -> ControlFlow<()> {
     assert_eq!(body.locals().len(), 4);
     assert_matches!(
         body.ret_local().ty.kind(),
-        stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Char)
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Char)
     );
     assert_eq!(body.arg_locals().len(), 2);
     assert_matches!(
         body.arg_locals()[0].ty.kind(),
-        stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Int(stable_mir::ty::IntTy::I32))
+        rustc_public::ty::TyKind::RigidTy(
+            rustc_public::ty::RigidTy::Int(rustc_public::ty::IntTy::I32)
+        )
     );
     assert_matches!(
         body.arg_locals()[1].ty.kind(),
-        stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Uint(stable_mir::ty::UintTy::U64))
+        rustc_public::ty::TyKind::RigidTy(
+            rustc_public::ty::RigidTy::Uint(rustc_public::ty::UintTy::U64)
+        )
     );
     assert_eq!(body.inner_locals().len(), 1);
     // If conditions have an extra inner local to hold their results
     assert_matches!(
         body.inner_locals()[0].ty.kind(),
-        stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Bool)
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool)
     );
 
     ControlFlow::Continue(())
@@ -168,9 +176,9 @@ fn test_stable_mir() -> ControlFlow<()> {
 
 // Use internal API to find a function in a crate.
 fn get_item<'a>(
-    items: &'a stable_mir::CrateItems,
+    items: &'a rustc_public::CrateItems,
     item: (DefKind, &str),
-) -> Option<&'a stable_mir::CrateItem> {
+) -> Option<&'a rustc_public::CrateItem> {
     items.iter().find(|crate_item| {
         matches!(
             (item.0, crate_item.kind()),
diff --git a/tests/ui-fulldeps/stable-mir/projections.rs b/tests/ui-fulldeps/stable-mir/projections.rs
index f8104287700..3b360cd2fcf 100644
--- a/tests/ui-fulldeps/stable-mir/projections.rs
+++ b/tests/ui-fulldeps/stable-mir/projections.rs
@@ -15,12 +15,12 @@ extern crate rustc_middle;
 extern crate rustc_driver;
 extern crate rustc_interface;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::ItemKind;
-use stable_mir::crate_def::CrateDef;
-use stable_mir::mir::{ProjectionElem, Rvalue, StatementKind};
-use stable_mir::ty::{RigidTy, TyKind, UintTy};
+use rustc_public::ItemKind;
+use rustc_public::crate_def::CrateDef;
+use rustc_public::mir::{ProjectionElem, Rvalue, StatementKind};
+use rustc_public::ty::{RigidTy, TyKind, UintTy};
 use std::assert_matches::assert_matches;
 use std::io::Write;
 use std::ops::ControlFlow;
@@ -29,15 +29,15 @@ const CRATE_NAME: &str = "input";
 
 /// Tests projections within Place objects
 fn test_place_projections() -> ControlFlow<()> {
-    let items = stable_mir::all_local_items();
+    let items = rustc_public::all_local_items();
     let body = get_item(&items, (ItemKind::Fn, "projections")).unwrap().expect_body();
     assert_eq!(body.blocks.len(), 4);
     // The first statement assigns `&s.c` to a local. The projections include a deref for `s`, since
     // `s` is passed as a reference argument, and a field access for field `c`.
     match &body.blocks[0].statements[0].kind {
         StatementKind::Assign(
-            place @ stable_mir::mir::Place { local: _, projection: local_proj },
-            Rvalue::Ref(_, _, stable_mir::mir::Place { local: _, projection: r_proj }),
+            place @ rustc_public::mir::Place { local: _, projection: local_proj },
+            Rvalue::Ref(_, _, rustc_public::mir::Place { local: _, projection: r_proj }),
         ) => {
             // We can't match on vecs, only on slices. Comparing statements for equality wouldn't be
             // any easier since we'd then have to add in the expected local and region values
@@ -48,7 +48,7 @@ fn test_place_projections() -> ControlFlow<()> {
                 [ProjectionElem::Deref, ProjectionElem::Field(2, ty)] => {
                     assert_matches!(
                         ty.kind(),
-                        TyKind::RigidTy(RigidTy::Uint(stable_mir::ty::UintTy::U8))
+                        TyKind::RigidTy(RigidTy::Uint(rustc_public::ty::UintTy::U8))
                     );
                     let ty = place.ty(body.locals()).unwrap();
                     assert_matches!(ty.kind().rigid(), Some(RigidTy::Ref(..)));
@@ -70,8 +70,8 @@ fn test_place_projections() -> ControlFlow<()> {
     // since `slice` is a reference, and an index.
     match &body.blocks[2].statements[0].kind {
         StatementKind::Assign(
-            place @ stable_mir::mir::Place { local: _, projection: local_proj },
-            Rvalue::Use(stable_mir::mir::Operand::Copy(stable_mir::mir::Place {
+            place @ rustc_public::mir::Place { local: _, projection: local_proj },
+            Rvalue::Use(rustc_public::mir::Operand::Copy(rustc_public::mir::Place {
                 local: _,
                 projection: r_proj,
             })),
@@ -93,18 +93,18 @@ fn test_place_projections() -> ControlFlow<()> {
     // The first terminator gets a slice of an array via the Index operation. Specifically it
     // performs `&vals[1..3]`. There are no projections in this case, the arguments are just locals.
     match &body.blocks[0].terminator.kind {
-        stable_mir::mir::TerminatorKind::Call { args, .. } =>
+        rustc_public::mir::TerminatorKind::Call { args, .. } =>
         // We can't match on vecs, only on slices. Comparing for equality wouldn't be any easier
         // since we'd then have to add in the expected local values instead of matching on
         // wildcards.
         {
             match &args[..] {
                 [
-                    stable_mir::mir::Operand::Move(stable_mir::mir::Place {
+                    rustc_public::mir::Operand::Move(rustc_public::mir::Place {
                         local: _,
                         projection: arg1_proj,
                     }),
-                    stable_mir::mir::Operand::Move(stable_mir::mir::Place {
+                    rustc_public::mir::Operand::Move(rustc_public::mir::Place {
                         local: _,
                         projection: arg2_proj,
                     }),
@@ -133,9 +133,9 @@ fn test_place_projections() -> ControlFlow<()> {
 
 // Use internal API to find a function in a crate.
 fn get_item<'a>(
-    items: &'a stable_mir::CrateItems,
+    items: &'a rustc_public::CrateItems,
     item: (ItemKind, &str),
-) -> Option<&'a stable_mir::CrateItem> {
+) -> Option<&'a rustc_public::CrateItem> {
     items.iter().find(|crate_item| crate_item.kind() == item.0 && crate_item.name() == item.1)
 }
 
diff --git a/tests/ui-fulldeps/stable-mir/smir_internal.rs b/tests/ui-fulldeps/stable-mir/smir_internal.rs
index 287f4353d51..dd70cfe5f5e 100644
--- a/tests/ui-fulldeps/stable-mir/smir_internal.rs
+++ b/tests/ui-fulldeps/stable-mir/smir_internal.rs
@@ -14,17 +14,17 @@ extern crate rustc_driver;
 extern crate rustc_interface;
 extern crate rustc_middle;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
 use rustc_middle::ty::TyCtxt;
-use stable_mir::rustc_internal;
+use rustc_public::rustc_internal;
 use std::io::Write;
 use std::ops::ControlFlow;
 
 const CRATE_NAME: &str = "input";
 
 fn test_translation(tcx: TyCtxt<'_>) -> ControlFlow<()> {
-    let main_fn = stable_mir::entry_fn().unwrap();
+    let main_fn = rustc_public::entry_fn().unwrap();
     let body = main_fn.expect_body();
     let orig_ty = body.locals()[0].ty;
     let rustc_ty = rustc_internal::internal(tcx, &orig_ty);
diff --git a/tests/ui-fulldeps/stable-mir/smir_serde.rs b/tests/ui-fulldeps/stable-mir/smir_serde.rs
index c2f00e56c2c..31642c6cb94 100644
--- a/tests/ui-fulldeps/stable-mir/smir_serde.rs
+++ b/tests/ui-fulldeps/stable-mir/smir_serde.rs
@@ -16,11 +16,11 @@ extern crate rustc_middle;
 extern crate serde;
 extern crate serde_json;
 #[macro_use]
-extern crate stable_mir;
+extern crate rustc_public;
 
 use rustc_middle::ty::TyCtxt;
 use serde_json::to_string;
-use stable_mir::mir::Body;
+use rustc_public::mir::Body;
 use std::io::{BufWriter, Write};
 use std::ops::ControlFlow;
 
@@ -29,9 +29,9 @@ const CRATE_NAME: &str = "input";
 fn serialize_to_json(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
     let path = "output.json";
     let mut writer = BufWriter::new(std::fs::File::create(path).expect("Failed to create path"));
-    let local_crate = stable_mir::local_crate();
+    let local_crate = rustc_public::local_crate();
     let items: Vec<Body> =
-        stable_mir::all_local_items().iter().map(|item| item.expect_body()).collect();
+        rustc_public::all_local_items().iter().map(|item| item.expect_body()).collect();
     let crate_data = (local_crate.name, items);
     writer
         .write_all(to_string(&crate_data).expect("serde_json failed").as_bytes())
diff --git a/tests/ui-fulldeps/stable-mir/smir_visitor.rs b/tests/ui-fulldeps/stable-mir/smir_visitor.rs
index 46f85a992ef..66787e2927b 100644
--- a/tests/ui-fulldeps/stable-mir/smir_visitor.rs
+++ b/tests/ui-fulldeps/stable-mir/smir_visitor.rs
@@ -13,11 +13,11 @@ extern crate rustc_middle;
 
 extern crate rustc_driver;
 extern crate rustc_interface;
-extern crate stable_mir;
+extern crate rustc_public;
 
-use stable_mir::mir::MirVisitor;
-use stable_mir::mir::MutMirVisitor;
-use stable_mir::*;
+use rustc_public::mir::MirVisitor;
+use rustc_public::mir::MutMirVisitor;
+use rustc_public::*;
 use std::collections::HashSet;
 use std::io::Write;
 use std::ops::ControlFlow;
@@ -25,7 +25,7 @@ use std::ops::ControlFlow;
 const CRATE_NAME: &str = "input";
 
 fn test_visitor() -> ControlFlow<()> {
-    let main_fn = stable_mir::entry_fn();
+    let main_fn = rustc_public::entry_fn();
     let main_body = main_fn.unwrap().expect_body();
     let main_visitor = TestVisitor::collect(&main_body);
     assert!(main_visitor.ret_val.is_some());
@@ -99,7 +99,7 @@ impl<'a> mir::MirVisitor for TestVisitor<'a> {
 }
 
 fn test_mut_visitor() -> ControlFlow<()> {
-    let main_fn = stable_mir::entry_fn();
+    let main_fn = rustc_public::entry_fn();
     let mut main_body = main_fn.unwrap().expect_body();
     let locals = main_body.locals().to_vec();
     let mut main_visitor = TestMutVisitor::collect(locals);
diff --git a/triagebot.toml b/triagebot.toml
index 125617fce74..75e794c700d 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1050,8 +1050,8 @@ cc = ["@davidtwco", "@compiler-errors", "@TaKO8Ki"]
 message = "`rustc_macros::diagnostics` was changed"
 cc = ["@davidtwco", "@compiler-errors", "@TaKO8Ki"]
 
-[mentions."compiler/stable_mir"]
-message = "This PR changes Stable MIR"
+[mentions."compiler/rustc_public"]
+message = "This PR changes rustc_public"
 cc = ["@oli-obk", "@celinval", "@ouz-a"]
 
 [mentions."compiler/rustc_target/src/spec"]
@@ -1445,7 +1445,7 @@ dep-bumps = [
 "/compiler/rustc_const_eval/src/interpret" =             ["compiler", "mir"]
 "/compiler/rustc_mir_build/src/builder" =                ["compiler", "mir"]
 "/compiler/rustc_mir_transform" =                        ["compiler", "mir", "mir-opt"]
-"/compiler/rustc_smir" =                                 ["project-stable-mir"]
+"/compiler/rustc_public_bridge" =                        ["project-stable-mir"]
 "/compiler/rustc_parse" =                                ["compiler", "parser"]
 "/compiler/rustc_parse/src/lexer" =                      ["compiler", "lexer"]
 "/compiler/rustc_query_impl" =                           ["compiler", "query-system"]
@@ -1455,7 +1455,7 @@ dep-bumps = [
 "/compiler/rustc_trait_selection" =                      ["compiler", "types"]
 "/compiler/rustc_traits" =                               ["compiler", "types"]
 "/compiler/rustc_type_ir" =                              ["compiler", "types"]
-"/compiler/stable_mir" =                                 ["project-stable-mir"]
+"/compiler/rustc_public" =                               ["project-stable-mir"]
 "/library/alloc" =                                       ["libs"]
 "/library/core" =                                        ["libs", "@scottmcm"]
 "/library/panic_abort" =                                 ["libs"]
-- 
cgit 1.4.1-3-g733a5


From b19a508b90a539cd1ff14d7924f9c18bc9fb5af2 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Sun, 13 Jul 2025 15:12:36 +0800
Subject: Use `TestSuite` enum instead of stringly-typed test suites

---
 src/tools/compiletest/src/common.rs           | 41 +++++++++++++++++++++------
 src/tools/compiletest/src/directives.rs       |  4 ---
 src/tools/compiletest/src/directives/tests.rs |  2 +-
 src/tools/compiletest/src/lib.rs              |  2 +-
 src/tools/compiletest/src/runtest.rs          | 11 ++++---
 src/tools/compiletest/src/runtest/coverage.rs |  4 +--
 6 files changed, 44 insertions(+), 20 deletions(-)

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 849f44031b7..33da1a25db1 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -53,6 +53,32 @@ impl TestMode {
     }
 }
 
+// Note that coverage tests use the same test files for multiple test modes.
+string_enum! {
+    #[derive(Clone, Copy, PartialEq, Debug)]
+    pub enum TestSuite {
+        Assembly => "assembly",
+        Codegen => "codegen",
+        CodegenUnits => "codegen-units",
+        Coverage => "coverage",
+        CoverageRunRustdoc => "coverage-run-rustdoc",
+        Crashes => "crashes",
+        Debuginfo => "debuginfo",
+        Incremental => "incremental",
+        MirOpt => "mir-opt",
+        Pretty => "pretty",
+        RunMake => "run-make",
+        Rustdoc => "rustdoc",
+        RustdocGui => "rustdoc-gui",
+        RustdocJs => "rustdoc-js",
+        RustdocJsStd=> "rustdoc-js-std",
+        RustdocJson => "rustdoc-json",
+        RustdocUi => "rustdoc-ui",
+        Ui => "ui",
+        UiFullDeps => "ui-fulldeps",
+    }
+}
+
 string_enum! {
     #[derive(Clone, Copy, PartialEq, Debug, Hash)]
     pub enum PassMode {
@@ -276,15 +302,13 @@ pub struct Config {
 
     /// The test suite.
     ///
-    /// Example: `tests/ui/` is the "UI" test *suite*, which happens to also be of the
+    /// Example: `tests/ui/` is [`TestSuite::Ui`] test *suite*, which happens to also be of the
     /// [`TestMode::Ui`] test *mode*.
     ///
-    /// Note that the same test directory (e.g. `tests/coverage/`) may correspond to multiple test
+    /// Note that the same test suite (e.g. `tests/coverage/`) may correspond to multiple test
     /// modes, e.g. `tests/coverage/` can be run under both [`TestMode::CoverageRun`] and
     /// [`TestMode::CoverageMap`].
-    ///
-    /// FIXME: stop using stringly-typed test suites!
-    pub suite: String,
+    pub suite: TestSuite,
 
     /// When specified, **only** the specified [`Debugger`] will be used to run against the
     /// `tests/debuginfo` test suite. When unspecified, `compiletest` will attempt to find all three
@@ -537,8 +561,8 @@ pub struct Config {
     // Configuration for various run-make tests frobbing things like C compilers or querying about
     // various LLVM component information.
     //
-    // FIXME: this really should be better packaged together. FIXME: these need better docs, e.g.
-    // for *host*, or for *target*?
+    // FIXME: this really should be better packaged together.
+    // FIXME: these need better docs, e.g. for *host*, or for *target*?
     pub cc: String,
     pub cxx: String,
     pub cflags: String,
@@ -617,6 +641,8 @@ impl Config {
         // For instance, `//@ ignore-stage1` will not work at all.
         Config {
             mode: TestMode::Rustdoc,
+            // E.g. this has no sensible default tbh.
+            suite: TestSuite::Ui,
 
             // Dummy values.
             edition: Default::default(),
@@ -642,7 +668,6 @@ impl Config {
             sysroot_base: Utf8PathBuf::default(),
             stage: Default::default(),
             stage_id: String::default(),
-            suite: Default::default(),
             debugger: Default::default(),
             run_ignored: Default::default(),
             with_rustc_debug_assertions: Default::default(),
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 7fadb4dae2a..282e2654fea 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -56,7 +56,6 @@ impl EarlyProps {
         let mut poisoned = false;
         iter_directives(
             config.mode,
-            &config.suite,
             &mut poisoned,
             testfile,
             rdr,
@@ -349,7 +348,6 @@ impl TestProps {
 
             iter_directives(
                 config.mode,
-                &config.suite,
                 &mut poisoned,
                 testfile,
                 file,
@@ -869,7 +867,6 @@ const COMPILETEST_DIRECTIVE_PREFIX: &str = "//@";
 
 fn iter_directives(
     mode: TestMode,
-    _suite: &str,
     poisoned: &mut bool,
     testfile: &Utf8Path,
     rdr: impl Read,
@@ -1388,7 +1385,6 @@ pub(crate) fn make_test_description<R: Read>(
     // Scan through the test file to handle `ignore-*`, `only-*`, and `needs-*` directives.
     iter_directives(
         config.mode,
-        &config.suite,
         &mut local_poisoned,
         path,
         src,
diff --git a/src/tools/compiletest/src/directives/tests.rs b/src/tools/compiletest/src/directives/tests.rs
index 9c5751b416b..5682cc57b6f 100644
--- a/src/tools/compiletest/src/directives/tests.rs
+++ b/src/tools/compiletest/src/directives/tests.rs
@@ -785,7 +785,7 @@ fn threads_support() {
 
 fn run_path(poisoned: &mut bool, path: &Utf8Path, buf: &[u8]) {
     let rdr = std::io::Cursor::new(&buf);
-    iter_directives(TestMode::Ui, "ui", poisoned, path, rdr, &mut |_| {});
+    iter_directives(TestMode::Ui, poisoned, path, rdr, &mut |_| {});
 }
 
 #[test]
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index be82f8cb480..f3b3605a120 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -360,7 +360,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
         stage_id: matches.opt_str("stage-id").unwrap(),
 
         mode,
-        suite: matches.opt_str("suite").unwrap(),
+        suite: matches.opt_str("suite").unwrap().parse().expect("invalid suite"),
         debugger: matches.opt_str("debugger").map(|debugger| {
             debugger
                 .parse::<Debugger>()
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 12111e9c6ef..cb8f593c9df 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -16,9 +16,9 @@ use regex::{Captures, Regex};
 use tracing::*;
 
 use crate::common::{
-    CompareMode, Config, Debugger, FailMode, PassMode, TestMode, TestPaths, UI_EXTENSIONS,
-    UI_FIXED, UI_RUN_STDERR, UI_RUN_STDOUT, UI_STDERR, UI_STDOUT, UI_SVG, UI_WINDOWS_SVG,
-    expected_output_path, incremental_dir, output_base_dir, output_base_name,
+    CompareMode, Config, Debugger, FailMode, PassMode, TestMode, TestPaths, TestSuite,
+    UI_EXTENSIONS, UI_FIXED, UI_RUN_STDERR, UI_RUN_STDOUT, UI_STDERR, UI_STDOUT, UI_SVG,
+    UI_WINDOWS_SVG, expected_output_path, incremental_dir, output_base_dir, output_base_name,
     output_testname_unique,
 };
 use crate::compute_diff::{DiffLine, make_diff, write_diff, write_filtered_diff};
@@ -1494,7 +1494,10 @@ impl<'test> TestCx<'test> {
     }
 
     fn is_rustdoc(&self) -> bool {
-        matches!(self.config.suite.as_str(), "rustdoc-ui" | "rustdoc-js" | "rustdoc-json")
+        matches!(
+            self.config.suite,
+            TestSuite::RustdocUi | TestSuite::RustdocJs | TestSuite::RustdocJson
+        )
     }
 
     fn make_compile_args(
diff --git a/src/tools/compiletest/src/runtest/coverage.rs b/src/tools/compiletest/src/runtest/coverage.rs
index 38f0e956474..d0a0c960b45 100644
--- a/src/tools/compiletest/src/runtest/coverage.rs
+++ b/src/tools/compiletest/src/runtest/coverage.rs
@@ -6,7 +6,7 @@ use std::process::Command;
 use camino::{Utf8Path, Utf8PathBuf};
 use glob::glob;
 
-use crate::common::{UI_COVERAGE, UI_COVERAGE_MAP};
+use crate::common::{TestSuite, UI_COVERAGE, UI_COVERAGE_MAP};
 use crate::runtest::{Emit, ProcRes, TestCx, WillExecute};
 use crate::util::static_regex;
 
@@ -91,7 +91,7 @@ impl<'test> TestCx<'test> {
         let mut profraw_paths = vec![profraw_path];
         let mut bin_paths = vec![self.make_exe_name()];
 
-        if self.config.suite == "coverage-run-rustdoc" {
+        if self.config.suite == TestSuite::CoverageRunRustdoc {
             self.run_doctests_for_coverage(&mut profraw_paths, &mut bin_paths);
         }
 
-- 
cgit 1.4.1-3-g733a5


From 9fd3886838afd28ee3834d0e7162fd6ab5adc944 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Sun, 13 Jul 2025 22:53:57 +0000
Subject: Add experimental backtrace-trace-only std feature

---
 library/std/Cargo.toml           |   3 ++
 library/std/src/sys/backtrace.rs | 100 +++++++++++++++++++++------------------
 library/sysroot/Cargo.toml       |   1 +
 3 files changed, 57 insertions(+), 47 deletions(-)

diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 62ece4b6961..86d23df5238 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -92,6 +92,9 @@ backtrace = [
     'object/rustc-dep-of-std',
     'miniz_oxide/rustc-dep-of-std',
 ]
+# Disable symbolization in backtraces. For use with -Zbuild-std.
+# FIXME: Ideally this should be an additive backtrace-symbolization feature
+backtrace-trace-only = []
 
 panic-unwind = ["dep:panic_unwind"]
 compiler-builtins-c = ["alloc/compiler-builtins-c"]
diff --git a/library/std/src/sys/backtrace.rs b/library/std/src/sys/backtrace.rs
index efa6a896dad..272d0fa4d1a 100644
--- a/library/std/src/sys/backtrace.rs
+++ b/library/std/src/sys/backtrace.rs
@@ -68,61 +68,67 @@ unsafe fn _print_fmt(fmt: &mut fmt::Formatter<'_>, print_fmt: PrintFmt) -> fmt::
                 return false;
             }
 
-            let mut hit = false;
-            backtrace_rs::resolve_frame_unsynchronized(frame, |symbol| {
-                hit = true;
-
-                // `__rust_end_short_backtrace` means we are done hiding symbols
-                // for now. Print until we see `__rust_begin_short_backtrace`.
-                if print_fmt == PrintFmt::Short {
-                    if let Some(sym) = symbol.name().and_then(|s| s.as_str()) {
-                        if sym.contains("__rust_end_short_backtrace") {
-                            print = true;
-                            return;
-                        }
-                        if print && sym.contains("__rust_begin_short_backtrace") {
-                            print = false;
-                            return;
-                        }
-                        if !print {
-                            omitted_count += 1;
+            if cfg!(feature = "backtrace-trace-only") {
+                const HEX_WIDTH: usize = 2 + 2 * size_of::<usize>();
+                let frame_ip = frame.ip();
+                res = writeln!(bt_fmt.formatter(), "{idx:4}: {frame_ip:HEX_WIDTH$?}");
+            } else {
+                let mut hit = false;
+                backtrace_rs::resolve_frame_unsynchronized(frame, |symbol| {
+                    hit = true;
+
+                    // `__rust_end_short_backtrace` means we are done hiding symbols
+                    // for now. Print until we see `__rust_begin_short_backtrace`.
+                    if print_fmt == PrintFmt::Short {
+                        if let Some(sym) = symbol.name().and_then(|s| s.as_str()) {
+                            if sym.contains("__rust_end_short_backtrace") {
+                                print = true;
+                                return;
+                            }
+                            if print && sym.contains("__rust_begin_short_backtrace") {
+                                print = false;
+                                return;
+                            }
+                            if !print {
+                                omitted_count += 1;
+                            }
                         }
                     }
-                }
 
-                if print {
-                    if omitted_count > 0 {
-                        debug_assert!(print_fmt == PrintFmt::Short);
-                        // only print the message between the middle of frames
-                        if !first_omit {
-                            let _ = writeln!(
-                                bt_fmt.formatter(),
-                                "      [... omitted {} frame{} ...]",
-                                omitted_count,
-                                if omitted_count > 1 { "s" } else { "" }
-                            );
+                    if print {
+                        if omitted_count > 0 {
+                            debug_assert!(print_fmt == PrintFmt::Short);
+                            // only print the message between the middle of frames
+                            if !first_omit {
+                                let _ = writeln!(
+                                    bt_fmt.formatter(),
+                                    "      [... omitted {} frame{} ...]",
+                                    omitted_count,
+                                    if omitted_count > 1 { "s" } else { "" }
+                                );
+                            }
+                            first_omit = false;
+                            omitted_count = 0;
                         }
-                        first_omit = false;
-                        omitted_count = 0;
+                        res = bt_fmt.frame().symbol(frame, symbol);
                     }
-                    res = bt_fmt.frame().symbol(frame, symbol);
+                });
+                #[cfg(target_os = "nto")]
+                if libc::__my_thread_exit as *mut libc::c_void == frame.ip() {
+                    if !hit && print {
+                        use crate::backtrace_rs::SymbolName;
+                        res = bt_fmt.frame().print_raw(
+                            frame.ip(),
+                            Some(SymbolName::new("__my_thread_exit".as_bytes())),
+                            None,
+                            None,
+                        );
+                    }
+                    return false;
                 }
-            });
-            #[cfg(target_os = "nto")]
-            if libc::__my_thread_exit as *mut libc::c_void == frame.ip() {
                 if !hit && print {
-                    use crate::backtrace_rs::SymbolName;
-                    res = bt_fmt.frame().print_raw(
-                        frame.ip(),
-                        Some(SymbolName::new("__my_thread_exit".as_bytes())),
-                        None,
-                        None,
-                    );
+                    res = bt_fmt.frame().print_raw(frame.ip(), None, None, None);
                 }
-                return false;
-            }
-            if !hit && print {
-                res = bt_fmt.frame().print_raw(frame.ip(), None, None, None);
             }
 
             idx += 1;
diff --git a/library/sysroot/Cargo.toml b/library/sysroot/Cargo.toml
index 290c2eeed44..032f5272a9c 100644
--- a/library/sysroot/Cargo.toml
+++ b/library/sysroot/Cargo.toml
@@ -20,6 +20,7 @@ test = { path = "../test", public = true }
 [features]
 default = ["std_detect_file_io", "std_detect_dlsym_getauxval", "panic-unwind"]
 backtrace = ["std/backtrace"]
+backtrace-trace-only = ["std/backtrace-trace-only"]
 compiler-builtins-c = ["std/compiler-builtins-c"]
 compiler-builtins-mem = ["std/compiler-builtins-mem"]
 compiler-builtins-no-asm = ["std/compiler-builtins-no-asm"]
-- 
cgit 1.4.1-3-g733a5


From 000e67aafb7ae8c755387a073f34662c4f6fc335 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 9 Jul 2025 07:25:12 +0000
Subject: Preserve constness in trait objects up to hir ty lowering

---
 .../src/hir_ty_lowering/dyn_compatibility.rs       |  2 +-
 .../const-trait-bounds-trait-objects.rs            |  2 ++
 .../const-trait-bounds-trait-objects.stderr        | 26 ++++++++++++++++++++--
 3 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
index cb106962be1..364ad38556b 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
@@ -49,7 +49,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             } = self.lower_poly_trait_ref(
                 &trait_bound.trait_ref,
                 trait_bound.span,
-                hir::BoundConstness::Never,
+                trait_bound.modifiers.constness,
                 hir::BoundPolarity::Positive,
                 dummy_self,
                 &mut user_written_bounds,
diff --git a/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.rs b/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.rs
index ece87529c3e..1d1da9b0e3d 100644
--- a/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.rs
+++ b/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.rs
@@ -14,5 +14,7 @@ fn main() {
 trait NonConst {}
 const fn handle(_: &dyn const NonConst) {}
 //~^ ERROR const trait bounds are not allowed in trait object types
+//~| ERROR `const` can only be applied to `#[const_trait]` traits
 const fn take(_: &dyn [const] NonConst) {}
 //~^ ERROR `[const]` is not allowed here
+//~| ERROR `[const]` can only be applied to `#[const_trait]` traits
diff --git a/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr b/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr
index 090555c6377..06e0493024c 100644
--- a/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr
+++ b/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr
@@ -19,12 +19,34 @@ LL | const fn handle(_: &dyn const NonConst) {}
    |                         ^^^^^^^^^^^^^^
 
 error: `[const]` is not allowed here
-  --> $DIR/const-trait-bounds-trait-objects.rs:17:23
+  --> $DIR/const-trait-bounds-trait-objects.rs:18:23
    |
 LL | const fn take(_: &dyn [const] NonConst) {}
    |                       ^^^^^^^
    |
    = note: trait objects cannot have `[const]` trait bounds
 
-error: aborting due to 4 previous errors
+error: `const` can only be applied to `#[const_trait]` traits
+  --> $DIR/const-trait-bounds-trait-objects.rs:15:25
+   |
+LL | const fn handle(_: &dyn const NonConst) {}
+   |                         ^^^^^ can't be applied to `NonConst`
+   |
+help: mark `NonConst` as `#[const_trait]` to allow it to have `const` implementations
+   |
+LL | #[const_trait] trait NonConst {}
+   | ++++++++++++++
+
+error: `[const]` can only be applied to `#[const_trait]` traits
+  --> $DIR/const-trait-bounds-trait-objects.rs:18:23
+   |
+LL | const fn take(_: &dyn [const] NonConst) {}
+   |                       ^^^^^^^ can't be applied to `NonConst`
+   |
+help: mark `NonConst` as `#[const_trait]` to allow it to have `const` implementations
+   |
+LL | #[const_trait] trait NonConst {}
+   | ++++++++++++++
+
+error: aborting due to 6 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 553074431875701f66107049339dc1e67f0cdeba Mon Sep 17 00:00:00 2001
From: Jake Goulding <jake.goulding@gmail.com>
Date: Thu, 10 Jul 2025 18:36:22 -0400
Subject: Reword mismatched-lifetime-syntaxes text based on feedback

Key changes include:

- Removal of the word "syntax" from the lint message. More accurately,
  it could have been something like "syntax group" or "syntax
  category", but avoiding it completely is easier.
- The primary lint message now reflects exactly which mismatch is
  occurring, instead of trying to be general. A new `help` line is
  general across the mismatch kinds.
- Suggestions have been reduced to be more minimal, no longer also
  changing non-idiomatic but unrelated aspects.
- Suggestion text no longer mentions changes when those changes don't
  occur in that specific suggestion.
---
 compiler/rustc_lint/messages.ftl                   |  53 ++-
 compiler/rustc_lint/src/lib.rs                     |   2 +-
 compiler/rustc_lint/src/lifetime_syntax.rs         | 149 ++++--
 compiler/rustc_lint/src/lints.rs                   |  72 ++-
 src/tools/clippy/tests/ui/ptr_arg.rs               |   2 +-
 src/tools/clippy/tests/ui/ptr_arg.stderr           |  11 +-
 .../type-dependent/issue-71348.full.stderr         |  11 +-
 .../const-generics/type-dependent/issue-71348.rs   |   2 +-
 .../ui/impl-trait/rpit-assoc-pair-with-lifetime.rs |   2 +-
 .../rpit-assoc-pair-with-lifetime.stderr           |   7 +-
 .../example-from-issue48686.rs                     |   2 +-
 .../example-from-issue48686.stderr                 |   9 +-
 .../missing-lifetime-kind.rs                       |   8 +-
 .../missing-lifetime-kind.stderr                   |  36 +-
 .../not-tied-to-crate.rs                           |   4 +-
 .../not-tied-to-crate.stderr                       |  18 +-
 .../mismatched-lifetime-syntaxes-details/static.rs |   8 +-
 .../static.stderr                                  |  36 +-
 tests/ui/lifetimes/mismatched-lifetime-syntaxes.rs | 104 +++--
 .../lifetimes/mismatched-lifetime-syntaxes.stderr  | 497 ++++++++++++---------
 .../self/elision/ignore-non-reference-lifetimes.rs |   4 +-
 .../elision/ignore-non-reference-lifetimes.stderr  |  18 +-
 tests/ui/self/self_lifetime-async.rs               |   4 +-
 tests/ui/self/self_lifetime-async.stderr           |  18 +-
 tests/ui/self/self_lifetime.rs                     |   4 +-
 tests/ui/self/self_lifetime.stderr                 |  18 +-
 26 files changed, 680 insertions(+), 419 deletions(-)

diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 8d9f2385b71..5fece464270 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -508,27 +508,50 @@ lint_metavariable_still_repeating = variable `{$name}` is still repeating at thi
 
 lint_metavariable_wrong_operator = meta-variable repeats with different Kleene operator
 
-lint_mismatched_lifetime_syntaxes =
-    lifetime flowing from input to output with different syntax can be confusing
-    .label_mismatched_lifetime_syntaxes_inputs =
-        {$n_inputs ->
-            [one] this lifetime flows
-            *[other] these lifetimes flow
-        } to the output
-    .label_mismatched_lifetime_syntaxes_outputs =
-        the {$n_outputs ->
-            [one] lifetime gets
-            *[other] lifetimes get
-        } resolved as `{$lifetime_name}`
+lint_mismatched_lifetime_syntaxes_eliding_while_named =
+    eliding a lifetime that's named elsewhere is confusing
+
+lint_mismatched_lifetime_syntaxes_help =
+    the same lifetime is referred to in inconsistent ways, making the signature confusing
+
+lint_mismatched_lifetime_syntaxes_hiding_and_eliding_while_named =
+    hiding or eliding a lifetime that's named elsewhere is confusing
+
+lint_mismatched_lifetime_syntaxes_hiding_while_elided =
+    hiding a lifetime that's elided elsewhere is confusing
+
+lint_mismatched_lifetime_syntaxes_hiding_while_named =
+    hiding a lifetime that's named elsewhere is confusing
+
+lint_mismatched_lifetime_syntaxes_input_elided =
+    the lifetime is elided here
+
+lint_mismatched_lifetime_syntaxes_input_hidden =
+    the lifetime is hidden here
+
+lint_mismatched_lifetime_syntaxes_input_named =
+    the lifetime is named here
+
+lint_mismatched_lifetime_syntaxes_output_elided =
+    the same lifetime is elided here
+
+lint_mismatched_lifetime_syntaxes_output_hidden =
+    the same lifetime is hidden here
+
+lint_mismatched_lifetime_syntaxes_output_named =
+    the same lifetime is named here
 
 lint_mismatched_lifetime_syntaxes_suggestion_explicit =
-    one option is to consistently use `{$lifetime_name}`
+    consistently use `{$lifetime_name}`
 
 lint_mismatched_lifetime_syntaxes_suggestion_implicit =
-    one option is to consistently remove the lifetime
+    remove the lifetime name from references
 
 lint_mismatched_lifetime_syntaxes_suggestion_mixed =
-    one option is to remove the lifetime for references and use the anonymous lifetime for paths
+    remove the lifetime name from references and use `'_` for type paths
+
+lint_mismatched_lifetime_syntaxes_suggestion_mixed_only_paths =
+    use `'_` for type paths
 
 lint_missing_unsafe_on_extern = extern blocks should be unsafe
     .suggestion = needs `unsafe` before the extern keyword
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index 419124d5144..f06757b3c23 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -55,7 +55,7 @@ mod invalid_from_utf8;
 mod late;
 mod let_underscore;
 mod levels;
-mod lifetime_syntax;
+pub mod lifetime_syntax;
 mod lints;
 mod macro_expr_fragment_specifier_2024_migration;
 mod map_unit_fn;
diff --git a/compiler/rustc_lint/src/lifetime_syntax.rs b/compiler/rustc_lint/src/lifetime_syntax.rs
index 5465968e984..2a5a34cdc6e 100644
--- a/compiler/rustc_lint/src/lifetime_syntax.rs
+++ b/compiler/rustc_lint/src/lifetime_syntax.rs
@@ -140,43 +140,115 @@ fn report_mismatches<'tcx>(
     }
 }
 
-fn lifetimes_use_matched_syntax(input_info: &[Info<'_>], output_info: &[Info<'_>]) -> bool {
-    // Categorize lifetimes into source/syntax buckets.
-    let mut n_hidden = 0;
-    let mut n_elided = 0;
-    let mut n_named = 0;
+#[derive(Debug, Copy, Clone, PartialEq)]
+enum LifetimeSyntaxCategory {
+    Hidden,
+    Elided,
+    Named,
+}
 
-    for info in input_info.iter().chain(output_info) {
+impl LifetimeSyntaxCategory {
+    fn new(syntax_source: (hir::LifetimeSyntax, LifetimeSource)) -> Option<Self> {
         use LifetimeSource::*;
         use hir::LifetimeSyntax::*;
 
-        let syntax_source = (info.lifetime.syntax, info.lifetime.source);
-
         match syntax_source {
-            // Ignore any other kind of lifetime.
-            (_, Other) => continue,
-
             // E.g. `&T`.
-            (Implicit, Reference | OutlivesBound | PreciseCapturing) |
+            (Implicit, Reference) |
             // E.g. `&'_ T`.
-            (ExplicitAnonymous, Reference | OutlivesBound | PreciseCapturing) |
+            (ExplicitAnonymous, Reference) |
             // E.g. `ContainsLifetime<'_>`.
-            (ExplicitAnonymous, Path { .. }) => n_elided += 1,
+            (ExplicitAnonymous, Path { .. }) |
+            // E.g. `+ '_`, `+ use<'_>`.
+            (ExplicitAnonymous, OutlivesBound | PreciseCapturing) => {
+                Some(Self::Elided)
+            }
 
             // E.g. `ContainsLifetime`.
-            (Implicit, Path { .. }) => n_hidden += 1,
+            (Implicit, Path { .. }) => {
+                Some(Self::Hidden)
+            }
 
             // E.g. `&'a T`.
-            (ExplicitBound, Reference | OutlivesBound | PreciseCapturing) |
+            (ExplicitBound, Reference) |
             // E.g. `ContainsLifetime<'a>`.
-            (ExplicitBound, Path { .. }) => n_named += 1,
-        };
+            (ExplicitBound, Path { .. }) |
+            // E.g. `+ 'a`, `+ use<'a>`.
+            (ExplicitBound, OutlivesBound | PreciseCapturing) => {
+                Some(Self::Named)
+            }
+
+            (Implicit, OutlivesBound | PreciseCapturing) |
+            (_, Other) => {
+                None
+            }
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct LifetimeSyntaxCategories<T> {
+    pub hidden: T,
+    pub elided: T,
+    pub named: T,
+}
+
+impl<T> LifetimeSyntaxCategories<T> {
+    fn select(&mut self, category: LifetimeSyntaxCategory) -> &mut T {
+        use LifetimeSyntaxCategory::*;
+
+        match category {
+            Elided => &mut self.elided,
+            Hidden => &mut self.hidden,
+            Named => &mut self.named,
+        }
+    }
+}
+
+impl<T> LifetimeSyntaxCategories<Vec<T>> {
+    pub fn len(&self) -> LifetimeSyntaxCategories<usize> {
+        LifetimeSyntaxCategories {
+            hidden: self.hidden.len(),
+            elided: self.elided.len(),
+            named: self.named.len(),
+        }
+    }
+
+    pub fn flatten(&self) -> impl Iterator<Item = &T> {
+        let Self { hidden, elided, named } = self;
+        [hidden.iter(), elided.iter(), named.iter()].into_iter().flatten()
+    }
+}
+
+impl std::ops::Add for LifetimeSyntaxCategories<usize> {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self {
+            hidden: self.hidden + rhs.hidden,
+            elided: self.elided + rhs.elided,
+            named: self.named + rhs.named,
+        }
+    }
+}
+
+fn lifetimes_use_matched_syntax(input_info: &[Info<'_>], output_info: &[Info<'_>]) -> bool {
+    let mut syntax_counts = LifetimeSyntaxCategories::<usize>::default();
+
+    for info in input_info.iter().chain(output_info) {
+        if let Some(category) = info.lifetime_syntax_category() {
+            *syntax_counts.select(category) += 1;
+        }
     }
 
-    let syntax_counts = (n_hidden, n_elided, n_named);
     tracing::debug!(?syntax_counts);
 
-    matches!(syntax_counts, (_, 0, 0) | (0, _, 0) | (0, 0, _))
+    matches!(
+        syntax_counts,
+        LifetimeSyntaxCategories { hidden: _, elided: 0, named: 0 }
+            | LifetimeSyntaxCategories { hidden: 0, elided: _, named: 0 }
+            | LifetimeSyntaxCategories { hidden: 0, elided: 0, named: _ }
+    )
 }
 
 fn emit_mismatch_diagnostic<'tcx>(
@@ -238,7 +310,7 @@ fn emit_mismatch_diagnostic<'tcx>(
         use LifetimeSource::*;
         use hir::LifetimeSyntax::*;
 
-        let syntax_source = (info.lifetime.syntax, info.lifetime.source);
+        let syntax_source = info.syntax_source();
 
         if let (_, Other) = syntax_source {
             // Ignore any other kind of lifetime.
@@ -259,7 +331,6 @@ fn emit_mismatch_diagnostic<'tcx>(
             // E.g. `&'_ T`.
             (ExplicitAnonymous, Reference) => {
                 suggest_change_to_implicit.push(info);
-                suggest_change_to_mixed_implicit.push(info);
                 suggest_change_to_explicit_bound.push(info);
             }
 
@@ -319,12 +390,22 @@ fn emit_mismatch_diagnostic<'tcx>(
         }
     }
 
+    let categorize = |infos: &[Info<'_>]| {
+        let mut categories = LifetimeSyntaxCategories::<Vec<_>>::default();
+        for info in infos {
+            if let Some(category) = info.lifetime_syntax_category() {
+                categories.select(category).push(info.reporting_span());
+            }
+        }
+        categories
+    };
+
+    let inputs = categorize(input_info);
+    let outputs = categorize(output_info);
+
     let make_implicit_suggestions =
         |infos: &[&Info<'_>]| infos.iter().map(|i| i.removing_span()).collect::<Vec<_>>();
 
-    let inputs = input_info.iter().map(|info| info.reporting_span()).collect();
-    let outputs = output_info.iter().map(|info| info.reporting_span()).collect();
-
     let explicit_bound_suggestion = bound_lifetime.map(|info| {
         build_mismatch_suggestion(info.lifetime_name(), &suggest_change_to_explicit_bound)
     });
@@ -399,8 +480,6 @@ fn emit_mismatch_diagnostic<'tcx>(
         ?explicit_anonymous_suggestion,
     );
 
-    let lifetime_name = bound_lifetime.map(|info| info.lifetime_name()).unwrap_or("'_").to_owned();
-
     // We can produce a number of suggestions which may overwhelm
     // the user. Instead, we order the suggestions based on Rust
     // idioms. The "best" choice is shown to the user and the
@@ -413,8 +492,8 @@ fn emit_mismatch_diagnostic<'tcx>(
 
     cx.emit_span_lint(
         MISMATCHED_LIFETIME_SYNTAXES,
-        Vec::clone(&inputs),
-        lints::MismatchedLifetimeSyntaxes { lifetime_name, inputs, outputs, suggestions },
+        inputs.flatten().copied().collect::<Vec<_>>(),
+        lints::MismatchedLifetimeSyntaxes { inputs, outputs, suggestions },
     );
 }
 
@@ -422,12 +501,12 @@ fn build_mismatch_suggestion(
     lifetime_name: &str,
     infos: &[&Info<'_>],
 ) -> lints::MismatchedLifetimeSyntaxesSuggestion {
-    let lifetime_name_sugg = lifetime_name.to_owned();
+    let lifetime_name = lifetime_name.to_owned();
 
     let suggestions = infos.iter().map(|info| info.suggestion(&lifetime_name)).collect();
 
     lints::MismatchedLifetimeSyntaxesSuggestion::Explicit {
-        lifetime_name_sugg,
+        lifetime_name,
         suggestions,
         tool_only: false,
     }
@@ -441,6 +520,14 @@ struct Info<'tcx> {
 }
 
 impl<'tcx> Info<'tcx> {
+    fn syntax_source(&self) -> (hir::LifetimeSyntax, LifetimeSource) {
+        (self.lifetime.syntax, self.lifetime.source)
+    }
+
+    fn lifetime_syntax_category(&self) -> Option<LifetimeSyntaxCategory> {
+        LifetimeSyntaxCategory::new(self.syntax_source())
+    }
+
     fn lifetime_name(&self) -> &str {
         self.lifetime.ident.as_str()
     }
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 21148833eaf..ef18b0ac20b 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -21,6 +21,7 @@ use rustc_span::{Ident, MacroRulesNormalizedIdent, Span, Symbol, sym};
 
 use crate::builtin::{InitError, ShorthandAssocTyCollector, TypeAliasBounds};
 use crate::errors::{OverruledAttributeSub, RequestedLevel};
+use crate::lifetime_syntax::LifetimeSyntaxCategories;
 use crate::{LateContext, fluent_generated as fluent};
 
 // array_into_iter.rs
@@ -3194,30 +3195,59 @@ pub(crate) struct ReservedMultihash {
 
 #[derive(Debug)]
 pub(crate) struct MismatchedLifetimeSyntaxes {
-    pub lifetime_name: String,
-    pub inputs: Vec<Span>,
-    pub outputs: Vec<Span>,
+    pub inputs: LifetimeSyntaxCategories<Vec<Span>>,
+    pub outputs: LifetimeSyntaxCategories<Vec<Span>>,
 
     pub suggestions: Vec<MismatchedLifetimeSyntaxesSuggestion>,
 }
 
 impl<'a, G: EmissionGuarantee> LintDiagnostic<'a, G> for MismatchedLifetimeSyntaxes {
     fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, G>) {
-        diag.primary_message(fluent::lint_mismatched_lifetime_syntaxes);
+        let counts = self.inputs.len() + self.outputs.len();
+        let message = match counts {
+            LifetimeSyntaxCategories { hidden: 0, elided: 0, named: 0 } => {
+                panic!("No lifetime mismatch detected")
+            }
+
+            LifetimeSyntaxCategories { hidden: _, elided: _, named: 0 } => {
+                fluent::lint_mismatched_lifetime_syntaxes_hiding_while_elided
+            }
+
+            LifetimeSyntaxCategories { hidden: _, elided: 0, named: _ } => {
+                fluent::lint_mismatched_lifetime_syntaxes_hiding_while_named
+            }
+
+            LifetimeSyntaxCategories { hidden: 0, elided: _, named: _ } => {
+                fluent::lint_mismatched_lifetime_syntaxes_eliding_while_named
+            }
 
-        diag.arg("lifetime_name", self.lifetime_name);
+            LifetimeSyntaxCategories { hidden: _, elided: _, named: _ } => {
+                fluent::lint_mismatched_lifetime_syntaxes_hiding_and_eliding_while_named
+            }
+        };
+        diag.primary_message(message);
 
-        diag.arg("n_inputs", self.inputs.len());
-        for input in self.inputs {
-            let a = diag.eagerly_translate(fluent::lint_label_mismatched_lifetime_syntaxes_inputs);
-            diag.span_label(input, a);
+        for s in self.inputs.hidden {
+            diag.span_label(s, fluent::lint_mismatched_lifetime_syntaxes_input_hidden);
+        }
+        for s in self.inputs.elided {
+            diag.span_label(s, fluent::lint_mismatched_lifetime_syntaxes_input_elided);
+        }
+        for s in self.inputs.named {
+            diag.span_label(s, fluent::lint_mismatched_lifetime_syntaxes_input_named);
         }
 
-        diag.arg("n_outputs", self.outputs.len());
-        for output in self.outputs {
-            let a = diag.eagerly_translate(fluent::lint_label_mismatched_lifetime_syntaxes_outputs);
-            diag.span_label(output, a);
+        for s in self.outputs.hidden {
+            diag.span_label(s, fluent::lint_mismatched_lifetime_syntaxes_output_hidden);
+        }
+        for s in self.outputs.elided {
+            diag.span_label(s, fluent::lint_mismatched_lifetime_syntaxes_output_elided);
         }
+        for s in self.outputs.named {
+            diag.span_label(s, fluent::lint_mismatched_lifetime_syntaxes_output_named);
+        }
+
+        diag.help(fluent::lint_mismatched_lifetime_syntaxes_help);
 
         let mut suggestions = self.suggestions.into_iter();
         if let Some(s) = suggestions.next() {
@@ -3245,7 +3275,7 @@ pub(crate) enum MismatchedLifetimeSyntaxesSuggestion {
     },
 
     Explicit {
-        lifetime_name_sugg: String,
+        lifetime_name: String,
         suggestions: Vec<(Span, String)>,
         tool_only: bool,
     },
@@ -3285,6 +3315,12 @@ impl Subdiagnostic for MismatchedLifetimeSyntaxesSuggestion {
             }
 
             Mixed { implicit_suggestions, explicit_anonymous_suggestions, tool_only } => {
+                let message = if implicit_suggestions.is_empty() {
+                    fluent::lint_mismatched_lifetime_syntaxes_suggestion_mixed_only_paths
+                } else {
+                    fluent::lint_mismatched_lifetime_syntaxes_suggestion_mixed
+                };
+
                 let implicit_suggestions =
                     implicit_suggestions.into_iter().map(|s| (s, String::new()));
 
@@ -3292,19 +3328,19 @@ impl Subdiagnostic for MismatchedLifetimeSyntaxesSuggestion {
                     implicit_suggestions.chain(explicit_anonymous_suggestions).collect();
 
                 diag.multipart_suggestion_with_style(
-                    fluent::lint_mismatched_lifetime_syntaxes_suggestion_mixed,
+                    message,
                     suggestions,
                     Applicability::MaybeIncorrect,
                     style(tool_only),
                 );
             }
 
-            Explicit { lifetime_name_sugg, suggestions, tool_only } => {
-                diag.arg("lifetime_name_sugg", lifetime_name_sugg);
+            Explicit { lifetime_name, suggestions, tool_only } => {
+                diag.arg("lifetime_name", lifetime_name);
                 let msg = diag.eagerly_translate(
                     fluent::lint_mismatched_lifetime_syntaxes_suggestion_explicit,
                 );
-                diag.remove_arg("lifetime_name_sugg");
+                diag.remove_arg("lifetime_name");
                 diag.multipart_suggestion_with_style(
                     msg,
                     suggestions,
diff --git a/src/tools/clippy/tests/ui/ptr_arg.rs b/src/tools/clippy/tests/ui/ptr_arg.rs
index 65f3f05d6cb..578641e910d 100644
--- a/src/tools/clippy/tests/ui/ptr_arg.rs
+++ b/src/tools/clippy/tests/ui/ptr_arg.rs
@@ -312,7 +312,7 @@ mod issue_9218 {
 
     // Inferred to be `&'a str`, afaik.
     fn cow_good_ret_ty<'a>(input: &'a Cow<'a, str>) -> &str {
-        //~^ ERROR: lifetime flowing from input to output with different syntax
+        //~^ ERROR: eliding a lifetime that's named elsewhere is confusing
         todo!()
     }
 }
diff --git a/src/tools/clippy/tests/ui/ptr_arg.stderr b/src/tools/clippy/tests/ui/ptr_arg.stderr
index 600343754e1..fd9ceddfe11 100644
--- a/src/tools/clippy/tests/ui/ptr_arg.stderr
+++ b/src/tools/clippy/tests/ui/ptr_arg.stderr
@@ -231,18 +231,19 @@ error: writing `&String` instead of `&str` involves a new object where a slice w
 LL |     fn good(v1: &String, v2: &String) {
    |                              ^^^^^^^ help: change this to: `&str`
 
-error: lifetime flowing from input to output with different syntax can be confusing
+error: eliding a lifetime that's named elsewhere is confusing
   --> tests/ui/ptr_arg.rs:314:36
    |
 LL |     fn cow_good_ret_ty<'a>(input: &'a Cow<'a, str>) -> &str {
-   |                                    ^^     ^^           ---- the lifetime gets resolved as `'a`
+   |                                    ^^     ^^           ---- the same lifetime is elided here
    |                                    |      |
-   |                                    |      these lifetimes flow to the output
-   |                                    these lifetimes flow to the output
+   |                                    |      the lifetime is named here
+   |                                    the lifetime is named here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
    = note: `-D mismatched-lifetime-syntaxes` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(mismatched_lifetime_syntaxes)]`
-help: one option is to consistently use `'a`
+help: consistently use `'a`
    |
 LL |     fn cow_good_ret_ty<'a>(input: &'a Cow<'a, str>) -> &'a str {
    |                                                         ++
diff --git a/tests/ui/const-generics/type-dependent/issue-71348.full.stderr b/tests/ui/const-generics/type-dependent/issue-71348.full.stderr
index f68fdb3b651..32fa46b92b3 100644
--- a/tests/ui/const-generics/type-dependent/issue-71348.full.stderr
+++ b/tests/ui/const-generics/type-dependent/issue-71348.full.stderr
@@ -1,14 +1,15 @@
-warning: lifetime flowing from input to output with different syntax can be confusing
+warning: hiding a lifetime that's named elsewhere is confusing
   --> $DIR/issue-71348.rs:18:40
    |
 LL |     fn ask<'a, const N: &'static str>(&'a self) -> &'a <Self as Get<N>>::Target
-   |                                        ^^           -- ------------------------ the lifetimes get resolved as `'a`
+   |                                        ^^           -- ------------------------ the same lifetime is hidden here
    |                                        |            |
-   |                                        |            the lifetimes get resolved as `'a`
-   |                                        this lifetime flows to the output
+   |                                        |            the same lifetime is named here
+   |                                        the lifetime is named here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
    = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
-help: one option is to consistently use `'a`
+help: consistently use `'a`
    |
 LL |     fn ask<'a, const N: &'static str>(&'a self) -> &'a <Self as Get<'a, N>>::Target
    |                                                                     +++
diff --git a/tests/ui/const-generics/type-dependent/issue-71348.rs b/tests/ui/const-generics/type-dependent/issue-71348.rs
index c6563c80305..9053f362ce4 100644
--- a/tests/ui/const-generics/type-dependent/issue-71348.rs
+++ b/tests/ui/const-generics/type-dependent/issue-71348.rs
@@ -17,7 +17,7 @@ trait Get<'a, const N: &'static str> {
 impl Foo {
     fn ask<'a, const N: &'static str>(&'a self) -> &'a <Self as Get<N>>::Target
     //[min]~^ ERROR `&'static str` is forbidden as the type of a const generic parameter
-    //[full]~^^ WARNING lifetime flowing from input to output with different syntax
+    //[full]~^^ WARNING hiding a lifetime that's named elsewhere is confusing
     where
         Self: Get<'a, N>,
     {
diff --git a/tests/ui/impl-trait/rpit-assoc-pair-with-lifetime.rs b/tests/ui/impl-trait/rpit-assoc-pair-with-lifetime.rs
index 1ac3c593dbe..1b8a5d4ca99 100644
--- a/tests/ui/impl-trait/rpit-assoc-pair-with-lifetime.rs
+++ b/tests/ui/impl-trait/rpit-assoc-pair-with-lifetime.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 
 pub fn iter<'a>(v: Vec<(u32, &'a u32)>) -> impl DoubleEndedIterator<Item = (u32, &u32)> {
-    //~^ WARNING lifetime flowing from input to output with different syntax
+    //~^ WARNING eliding a lifetime that's named elsewhere is confusing
     v.into_iter()
 }
 
diff --git a/tests/ui/impl-trait/rpit-assoc-pair-with-lifetime.stderr b/tests/ui/impl-trait/rpit-assoc-pair-with-lifetime.stderr
index b9d8674992c..3651226e0c3 100644
--- a/tests/ui/impl-trait/rpit-assoc-pair-with-lifetime.stderr
+++ b/tests/ui/impl-trait/rpit-assoc-pair-with-lifetime.stderr
@@ -1,11 +1,12 @@
-warning: lifetime flowing from input to output with different syntax can be confusing
+warning: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/rpit-assoc-pair-with-lifetime.rs:3:31
    |
 LL | pub fn iter<'a>(v: Vec<(u32, &'a u32)>) -> impl DoubleEndedIterator<Item = (u32, &u32)> {
-   |                               ^^ this lifetime flows to the output               ---- the lifetime gets resolved as `'a`
+   |                               ^^ the lifetime is named here                      ---- the same lifetime is elided here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
    = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
-help: one option is to consistently use `'a`
+help: consistently use `'a`
    |
 LL | pub fn iter<'a>(v: Vec<(u32, &'a u32)>) -> impl DoubleEndedIterator<Item = (u32, &'a u32)> {
    |                                                                                   ++
diff --git a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/example-from-issue48686.rs b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/example-from-issue48686.rs
index 1804003d367..9162a38f510 100644
--- a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/example-from-issue48686.rs
+++ b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/example-from-issue48686.rs
@@ -4,7 +4,7 @@ struct Foo;
 
 impl Foo {
     pub fn get_mut(&'static self, x: &mut u8) -> &mut u8 {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         unsafe { &mut *(x as *mut _) }
     }
 }
diff --git a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/example-from-issue48686.stderr b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/example-from-issue48686.stderr
index 7c7411651d0..5a7a5a6ebf9 100644
--- a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/example-from-issue48686.stderr
+++ b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/example-from-issue48686.stderr
@@ -1,17 +1,18 @@
-error: lifetime flowing from input to output with different syntax can be confusing
+error: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/example-from-issue48686.rs:6:21
    |
 LL |     pub fn get_mut(&'static self, x: &mut u8) -> &mut u8 {
-   |                     ^^^^^^^                      ------- the lifetime gets resolved as `'static`
+   |                     ^^^^^^^                      ------- the same lifetime is elided here
    |                     |
-   |                     this lifetime flows to the output
+   |                     the lifetime is named here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
 note: the lint level is defined here
   --> $DIR/example-from-issue48686.rs:1:9
    |
 LL | #![deny(mismatched_lifetime_syntaxes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: one option is to consistently use `'static`
+help: consistently use `'static`
    |
 LL |     pub fn get_mut(&'static self, x: &mut u8) -> &'static mut u8 {
    |                                                   +++++++
diff --git a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/missing-lifetime-kind.rs b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/missing-lifetime-kind.rs
index 3d5aab5c829..ecc790be5a0 100644
--- a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/missing-lifetime-kind.rs
+++ b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/missing-lifetime-kind.rs
@@ -1,26 +1,26 @@
 #![deny(mismatched_lifetime_syntaxes)]
 
 fn ampersand<'a>(x: &'a u8) -> &u8 {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR eliding a lifetime that's named elsewhere is confusing
     x
 }
 
 struct Brackets<'a>(&'a u8);
 
 fn brackets<'a>(x: &'a u8) -> Brackets {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's named elsewhere is confusing
     Brackets(x)
 }
 
 struct Comma<'a, T>(&'a T);
 
 fn comma<'a>(x: &'a u8) -> Comma<u8> {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's named elsewhere is confusing
     Comma(x)
 }
 
 fn underscore<'a>(x: &'a u8) -> &'_ u8 {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR eliding a lifetime that's named elsewhere is confusing
     x
 }
 
diff --git a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/missing-lifetime-kind.stderr b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/missing-lifetime-kind.stderr
index 681b3c97052..af56a0a0ea5 100644
--- a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/missing-lifetime-kind.stderr
+++ b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/missing-lifetime-kind.stderr
@@ -1,56 +1,60 @@
-error: lifetime flowing from input to output with different syntax can be confusing
+error: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/missing-lifetime-kind.rs:3:22
    |
 LL | fn ampersand<'a>(x: &'a u8) -> &u8 {
-   |                      ^^        --- the lifetime gets resolved as `'a`
+   |                      ^^        --- the same lifetime is elided here
    |                      |
-   |                      this lifetime flows to the output
+   |                      the lifetime is named here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
 note: the lint level is defined here
   --> $DIR/missing-lifetime-kind.rs:1:9
    |
 LL | #![deny(mismatched_lifetime_syntaxes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: one option is to consistently use `'a`
+help: consistently use `'a`
    |
 LL | fn ampersand<'a>(x: &'a u8) -> &'a u8 {
    |                                 ++
 
-error: lifetime flowing from input to output with different syntax can be confusing
+error: hiding a lifetime that's named elsewhere is confusing
   --> $DIR/missing-lifetime-kind.rs:10:21
    |
 LL | fn brackets<'a>(x: &'a u8) -> Brackets {
-   |                     ^^        -------- the lifetime gets resolved as `'a`
+   |                     ^^        -------- the same lifetime is hidden here
    |                     |
-   |                     this lifetime flows to the output
+   |                     the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL | fn brackets<'a>(x: &'a u8) -> Brackets<'a> {
    |                                       ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
+error: hiding a lifetime that's named elsewhere is confusing
   --> $DIR/missing-lifetime-kind.rs:17:18
    |
 LL | fn comma<'a>(x: &'a u8) -> Comma<u8> {
-   |                  ^^        --------- the lifetime gets resolved as `'a`
+   |                  ^^        --------- the same lifetime is hidden here
    |                  |
-   |                  this lifetime flows to the output
+   |                  the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL | fn comma<'a>(x: &'a u8) -> Comma<'a, u8> {
    |                                  +++
 
-error: lifetime flowing from input to output with different syntax can be confusing
+error: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/missing-lifetime-kind.rs:22:23
    |
 LL | fn underscore<'a>(x: &'a u8) -> &'_ u8 {
-   |                       ^^         -- the lifetime gets resolved as `'a`
+   |                       ^^         -- the same lifetime is elided here
    |                       |
-   |                       this lifetime flows to the output
+   |                       the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL - fn underscore<'a>(x: &'a u8) -> &'_ u8 {
 LL + fn underscore<'a>(x: &'a u8) -> &'a u8 {
diff --git a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/not-tied-to-crate.rs b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/not-tied-to-crate.rs
index cc398ab7888..449b2a3c0a8 100644
--- a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/not-tied-to-crate.rs
+++ b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/not-tied-to-crate.rs
@@ -6,13 +6,13 @@
 #[warn(mismatched_lifetime_syntaxes)]
 mod foo {
     fn bar(x: &'static u8) -> &u8 {
-        //~^ WARNING lifetime flowing from input to output with different syntax
+        //~^ WARNING eliding a lifetime that's named elsewhere is confusing
         x
     }
 
     #[deny(mismatched_lifetime_syntaxes)]
     fn baz(x: &'static u8) -> &u8 {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         x
     }
 }
diff --git a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/not-tied-to-crate.stderr b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/not-tied-to-crate.stderr
index da691225c17..cf0a29678fa 100644
--- a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/not-tied-to-crate.stderr
+++ b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/not-tied-to-crate.stderr
@@ -1,35 +1,37 @@
-warning: lifetime flowing from input to output with different syntax can be confusing
+warning: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/not-tied-to-crate.rs:8:16
    |
 LL |     fn bar(x: &'static u8) -> &u8 {
-   |                ^^^^^^^        --- the lifetime gets resolved as `'static`
+   |                ^^^^^^^        --- the same lifetime is elided here
    |                |
-   |                this lifetime flows to the output
+   |                the lifetime is named here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
 note: the lint level is defined here
   --> $DIR/not-tied-to-crate.rs:6:8
    |
 LL | #[warn(mismatched_lifetime_syntaxes)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: one option is to consistently use `'static`
+help: consistently use `'static`
    |
 LL |     fn bar(x: &'static u8) -> &'static u8 {
    |                                +++++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
+error: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/not-tied-to-crate.rs:14:16
    |
 LL |     fn baz(x: &'static u8) -> &u8 {
-   |                ^^^^^^^        --- the lifetime gets resolved as `'static`
+   |                ^^^^^^^        --- the same lifetime is elided here
    |                |
-   |                this lifetime flows to the output
+   |                the lifetime is named here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
 note: the lint level is defined here
   --> $DIR/not-tied-to-crate.rs:13:12
    |
 LL |     #[deny(mismatched_lifetime_syntaxes)]
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: one option is to consistently use `'static`
+help: consistently use `'static`
    |
 LL |     fn baz(x: &'static u8) -> &'static u8 {
    |                                +++++++
diff --git a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/static.rs b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/static.rs
index 47ae258f138..c41cf44e1c5 100644
--- a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/static.rs
+++ b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/static.rs
@@ -14,26 +14,26 @@ impl Trait for () {
 }
 
 fn ampersand(x: &'static u8) -> &u8 {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR eliding a lifetime that's named elsewhere is confusing
     x
 }
 
 struct Brackets<'a>(&'a u8);
 
 fn brackets(x: &'static u8) -> Brackets {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's named elsewhere is confusing
     Brackets(x)
 }
 
 struct Comma<'a, T>(&'a T);
 
 fn comma(x: &'static u8) -> Comma<u8> {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's named elsewhere is confusing
     Comma(x)
 }
 
 fn underscore(x: &'static u8) -> &'_ u8 {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR eliding a lifetime that's named elsewhere is confusing
     x
 }
 
diff --git a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/static.stderr b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/static.stderr
index 5b9a986bcbe..d60bec6f7e4 100644
--- a/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/static.stderr
+++ b/tests/ui/lifetimes/mismatched-lifetime-syntaxes-details/static.stderr
@@ -1,56 +1,60 @@
-error: lifetime flowing from input to output with different syntax can be confusing
+error: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/static.rs:16:18
    |
 LL | fn ampersand(x: &'static u8) -> &u8 {
-   |                  ^^^^^^^        --- the lifetime gets resolved as `'static`
+   |                  ^^^^^^^        --- the same lifetime is elided here
    |                  |
-   |                  this lifetime flows to the output
+   |                  the lifetime is named here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
 note: the lint level is defined here
   --> $DIR/static.rs:1:9
    |
 LL | #![deny(mismatched_lifetime_syntaxes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: one option is to consistently use `'static`
+help: consistently use `'static`
    |
 LL | fn ampersand(x: &'static u8) -> &'static u8 {
    |                                  +++++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
+error: hiding a lifetime that's named elsewhere is confusing
   --> $DIR/static.rs:23:17
    |
 LL | fn brackets(x: &'static u8) -> Brackets {
-   |                 ^^^^^^^        -------- the lifetime gets resolved as `'static`
+   |                 ^^^^^^^        -------- the same lifetime is hidden here
    |                 |
-   |                 this lifetime flows to the output
+   |                 the lifetime is named here
    |
-help: one option is to consistently use `'static`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'static`
    |
 LL | fn brackets(x: &'static u8) -> Brackets<'static> {
    |                                        +++++++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
+error: hiding a lifetime that's named elsewhere is confusing
   --> $DIR/static.rs:30:14
    |
 LL | fn comma(x: &'static u8) -> Comma<u8> {
-   |              ^^^^^^^        --------- the lifetime gets resolved as `'static`
+   |              ^^^^^^^        --------- the same lifetime is hidden here
    |              |
-   |              this lifetime flows to the output
+   |              the lifetime is named here
    |
-help: one option is to consistently use `'static`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'static`
    |
 LL | fn comma(x: &'static u8) -> Comma<'static, u8> {
    |                                   ++++++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
+error: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/static.rs:35:19
    |
 LL | fn underscore(x: &'static u8) -> &'_ u8 {
-   |                   ^^^^^^^         -- the lifetime gets resolved as `'static`
+   |                   ^^^^^^^         -- the same lifetime is elided here
    |                   |
-   |                   this lifetime flows to the output
+   |                   the lifetime is named here
    |
-help: one option is to consistently use `'static`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'static`
    |
 LL - fn underscore(x: &'static u8) -> &'_ u8 {
 LL + fn underscore(x: &'static u8) -> &'static u8 {
diff --git a/tests/ui/lifetimes/mismatched-lifetime-syntaxes.rs b/tests/ui/lifetimes/mismatched-lifetime-syntaxes.rs
index b98423afb17..f6260c47202 100644
--- a/tests/ui/lifetimes/mismatched-lifetime-syntaxes.rs
+++ b/tests/ui/lifetimes/mismatched-lifetime-syntaxes.rs
@@ -5,109 +5,111 @@ struct ContainsLifetime<'a>(&'a u8);
 
 struct S(u8);
 
+// ref to ref
+
 fn explicit_bound_ref_to_implicit_ref<'a>(v: &'a u8) -> &u8 {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR eliding a lifetime that's named elsewhere is confusing
     v
 }
 
 fn explicit_bound_ref_to_explicit_anonymous_ref<'a>(v: &'a u8) -> &'_ u8 {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR eliding a lifetime that's named elsewhere is confusing
     v
 }
 
-// ---
+// path to path
 
 fn implicit_path_to_explicit_anonymous_path(v: ContainsLifetime) -> ContainsLifetime<'_> {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
     v
 }
 
 fn explicit_anonymous_path_to_implicit_path(v: ContainsLifetime<'_>) -> ContainsLifetime {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
     v
 }
 
 fn explicit_bound_path_to_implicit_path<'a>(v: ContainsLifetime<'a>) -> ContainsLifetime {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's named elsewhere is confusing
     v
 }
 
 fn explicit_bound_path_to_explicit_anonymous_path<'a>(
     v: ContainsLifetime<'a>,
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR eliding a lifetime that's named elsewhere is confusing
 ) -> ContainsLifetime<'_> {
     v
 }
 
-// ---
+// ref to path
 
 fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
     ContainsLifetime(v)
 }
 
 fn explicit_anonymous_ref_to_implicit_path(v: &'_ u8) -> ContainsLifetime {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
     ContainsLifetime(v)
 }
 
 fn explicit_bound_ref_to_implicit_path<'a>(v: &'a u8) -> ContainsLifetime {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's named elsewhere is confusing
     ContainsLifetime(v)
 }
 
 fn explicit_bound_ref_to_explicit_anonymous_path<'a>(v: &'a u8) -> ContainsLifetime<'_> {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR eliding a lifetime that's named elsewhere is confusing
     ContainsLifetime(v)
 }
 
-// ---
+// path to ref
 
 fn implicit_path_to_implicit_ref(v: ContainsLifetime) -> &u8 {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
     v.0
 }
 
 fn implicit_path_to_explicit_anonymous_ref(v: ContainsLifetime) -> &'_ u8 {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
     v.0
 }
 
 fn explicit_bound_path_to_implicit_ref<'a>(v: ContainsLifetime<'a>) -> &u8 {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR eliding a lifetime that's named elsewhere is confusing
     v.0
 }
 
 fn explicit_bound_path_to_explicit_anonymous_ref<'a>(v: ContainsLifetime<'a>) -> &'_ u8 {
-    //~^ ERROR lifetime flowing from input to output with different syntax
+    //~^ ERROR eliding a lifetime that's named elsewhere is confusing
     v.0
 }
 
 impl S {
     fn method_explicit_bound_ref_to_implicit_ref<'a>(&'a self) -> &u8 {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         &self.0
     }
 
     fn method_explicit_bound_ref_to_explicit_anonymous_ref<'a>(&'a self) -> &'_ u8 {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         &self.0
     }
 
     // ---
 
     fn method_explicit_anonymous_ref_to_implicit_path(&'_ self) -> ContainsLifetime {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
         ContainsLifetime(&self.0)
     }
 
     fn method_explicit_bound_ref_to_implicit_path<'a>(&'a self) -> ContainsLifetime {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR hiding a lifetime that's named elsewhere is confusing
         ContainsLifetime(&self.0)
     }
 
     fn method_explicit_bound_ref_to_explicit_anonymous_path<'a>(&'a self) -> ContainsLifetime<'_> {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         ContainsLifetime(&self.0)
     }
 }
@@ -122,43 +124,43 @@ mod static_suggestions {
     struct S(u8);
 
     fn static_ref_to_implicit_ref(v: &'static u8) -> &u8 {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         v
     }
 
     fn static_ref_to_explicit_anonymous_ref(v: &'static u8) -> &'_ u8 {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         v
     }
 
     fn static_ref_to_implicit_path(v: &'static u8) -> ContainsLifetime {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR hiding a lifetime that's named elsewhere is confusing
         ContainsLifetime(v)
     }
 
     fn static_ref_to_explicit_anonymous_path(v: &'static u8) -> ContainsLifetime<'_> {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         ContainsLifetime(v)
     }
 
     impl S {
         fn static_ref_to_implicit_ref(&'static self) -> &u8 {
-            //~^ ERROR lifetime flowing from input to output with different syntax
+            //~^ ERROR eliding a lifetime that's named elsewhere is confusing
             &self.0
         }
 
         fn static_ref_to_explicit_anonymous_ref(&'static self) -> &'_ u8 {
-            //~^ ERROR lifetime flowing from input to output with different syntax
+            //~^ ERROR eliding a lifetime that's named elsewhere is confusing
             &self.0
         }
 
         fn static_ref_to_implicit_path(&'static self) -> ContainsLifetime {
-            //~^ ERROR lifetime flowing from input to output with different syntax
+            //~^ ERROR hiding a lifetime that's named elsewhere is confusing
             ContainsLifetime(&self.0)
         }
 
         fn static_ref_to_explicit_anonymous_path(&'static self) -> ContainsLifetime<'_> {
-            //~^ ERROR lifetime flowing from input to output with different syntax
+            //~^ ERROR eliding a lifetime that's named elsewhere is confusing
             ContainsLifetime(&self.0)
         }
     }
@@ -170,23 +172,23 @@ mod impl_trait {
     struct ContainsLifetime<'a>(&'a u8);
 
     fn explicit_bound_ref_to_impl_trait_bound<'a>(v: &'a u8) -> impl FnOnce() + '_ {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         move || _ = v
     }
 
     fn explicit_bound_ref_to_impl_trait_precise_capture<'a>(v: &'a u8) -> impl FnOnce() + use<'_> {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         move || _ = v
     }
 
     fn explicit_bound_path_to_impl_trait_bound<'a>(v: ContainsLifetime<'a>) -> impl FnOnce() + '_ {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         move || _ = v
     }
 
     fn explicit_bound_path_to_impl_trait_precise_capture<'a>(
         v: ContainsLifetime<'a>,
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
     ) -> impl FnOnce() + use<'_> {
         move || _ = v
     }
@@ -200,13 +202,13 @@ mod dyn_trait {
     struct ContainsLifetime<'a>(&'a u8);
 
     fn explicit_bound_ref_to_dyn_trait_bound<'a>(v: &'a u8) -> Box<dyn Iterator<Item = &u8> + '_> {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         Box::new(iter::once(v))
     }
 
     fn explicit_bound_path_to_dyn_trait_bound<'a>(
         v: ContainsLifetime<'a>,
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR hiding a lifetime that's named elsewhere is confusing
     ) -> Box<dyn Iterator<Item = ContainsLifetime> + '_> {
         Box::new(iter::once(v))
     }
@@ -214,10 +216,28 @@ mod dyn_trait {
 
 /// These tests serve to exercise edge cases of the lint formatting
 mod diagnostic_output {
+    #[derive(Copy, Clone)]
+    struct ContainsLifetime<'a>(&'a u8);
+
+    fn multiple_inputs<'a>(v: (&'a u8, &'a u8)) -> &u8 {
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
+        v.0
+    }
+
     fn multiple_outputs<'a>(v: &'a u8) -> (&u8, &u8) {
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
         (v, v)
     }
+
+    fn all_three_categories<'a>(v: ContainsLifetime<'a>) -> (&u8, ContainsLifetime) {
+        //~^ ERROR hiding or eliding a lifetime that's named elsewhere is confusing
+        (v.0, v)
+    }
+
+    fn explicit_bound_output<'a>(v: &'a u8) -> (&u8, &'a u8, ContainsLifetime<'a>) {
+        //~^ ERROR eliding a lifetime that's named elsewhere is confusing
+        (v, v, ContainsLifetime(v))
+    }
 }
 
 /// Trait functions are represented differently in the HIR. Make sure
@@ -228,20 +248,20 @@ mod trait_functions {
 
     trait TheTrait {
         fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime;
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
 
         fn method_implicit_ref_to_implicit_path(&self) -> ContainsLifetime;
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
     }
 
     impl TheTrait for &u8 {
         fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime {
-            //~^ ERROR lifetime flowing from input to output with different syntax
+            //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
             ContainsLifetime(v)
         }
 
         fn method_implicit_ref_to_implicit_path(&self) -> ContainsLifetime {
-            //~^ ERROR lifetime flowing from input to output with different syntax
+            //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
             ContainsLifetime(self)
         }
     }
@@ -255,7 +275,7 @@ mod foreign_functions {
 
     extern "Rust" {
         fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime;
-        //~^ ERROR lifetime flowing from input to output with different syntax
+        //~^ ERROR hiding a lifetime that's elided elsewhere is confusing
     }
 }
 
diff --git a/tests/ui/lifetimes/mismatched-lifetime-syntaxes.stderr b/tests/ui/lifetimes/mismatched-lifetime-syntaxes.stderr
index 108b3f14169..20b7561c594 100644
--- a/tests/ui/lifetimes/mismatched-lifetime-syntaxes.stderr
+++ b/tests/ui/lifetimes/mismatched-lifetime-syntaxes.stderr
@@ -1,538 +1,613 @@
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:8:47
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:10:47
    |
 LL | fn explicit_bound_ref_to_implicit_ref<'a>(v: &'a u8) -> &u8 {
-   |                                               ^^        --- the lifetime gets resolved as `'a`
+   |                                               ^^        --- the same lifetime is elided here
    |                                               |
-   |                                               this lifetime flows to the output
+   |                                               the lifetime is named here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
 note: the lint level is defined here
   --> $DIR/mismatched-lifetime-syntaxes.rs:1:9
    |
 LL | #![deny(mismatched_lifetime_syntaxes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: one option is to consistently use `'a`
+help: consistently use `'a`
    |
 LL | fn explicit_bound_ref_to_implicit_ref<'a>(v: &'a u8) -> &'a u8 {
    |                                                          ++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:13:57
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:15:57
    |
 LL | fn explicit_bound_ref_to_explicit_anonymous_ref<'a>(v: &'a u8) -> &'_ u8 {
-   |                                                         ^^         -- the lifetime gets resolved as `'a`
+   |                                                         ^^         -- the same lifetime is elided here
    |                                                         |
-   |                                                         this lifetime flows to the output
+   |                                                         the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL - fn explicit_bound_ref_to_explicit_anonymous_ref<'a>(v: &'a u8) -> &'_ u8 {
 LL + fn explicit_bound_ref_to_explicit_anonymous_ref<'a>(v: &'a u8) -> &'a u8 {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:20:48
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:22:48
    |
 LL | fn implicit_path_to_explicit_anonymous_path(v: ContainsLifetime) -> ContainsLifetime<'_> {
-   |                                                ^^^^^^^^^^^^^^^^                      -- the lifetime gets resolved as `'_`
+   |                                                ^^^^^^^^^^^^^^^^                      -- the same lifetime is elided here
    |                                                |
-   |                                                this lifetime flows to the output
+   |                                                the lifetime is hidden here
    |
-help: one option is to consistently use `'_`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'_`
    |
 LL | fn implicit_path_to_explicit_anonymous_path(v: ContainsLifetime<'_>) -> ContainsLifetime<'_> {
    |                                                                ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:25:65
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:27:65
    |
 LL | fn explicit_anonymous_path_to_implicit_path(v: ContainsLifetime<'_>) -> ContainsLifetime {
-   |                                                                 ^^      ---------------- the lifetime gets resolved as `'_`
+   |                                                                 ^^      ---------------- the same lifetime is hidden here
    |                                                                 |
-   |                                                                 this lifetime flows to the output
+   |                                                                 the lifetime is elided here
    |
-help: one option is to consistently use `'_`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'_`
    |
 LL | fn explicit_anonymous_path_to_implicit_path(v: ContainsLifetime<'_>) -> ContainsLifetime<'_> {
    |                                                                                         ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:30:65
+error: hiding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:32:65
    |
 LL | fn explicit_bound_path_to_implicit_path<'a>(v: ContainsLifetime<'a>) -> ContainsLifetime {
-   |                                                                 ^^      ---------------- the lifetime gets resolved as `'a`
+   |                                                                 ^^      ---------------- the same lifetime is hidden here
    |                                                                 |
-   |                                                                 this lifetime flows to the output
+   |                                                                 the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL | fn explicit_bound_path_to_implicit_path<'a>(v: ContainsLifetime<'a>) -> ContainsLifetime<'a> {
    |                                                                                         ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:36:25
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:38:25
    |
 LL |     v: ContainsLifetime<'a>,
-   |                         ^^ this lifetime flows to the output
+   |                         ^^ the lifetime is named here
 LL |
 LL | ) -> ContainsLifetime<'_> {
-   |                       -- the lifetime gets resolved as `'a`
+   |                       -- the same lifetime is elided here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL - ) -> ContainsLifetime<'_> {
 LL + ) -> ContainsLifetime<'a> {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:44:37
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:46:37
    |
 LL | fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime {
-   |                                     ^^^     ---------------- the lifetime gets resolved as `'_`
+   |                                     ^^^     ---------------- the same lifetime is hidden here
    |                                     |
-   |                                     this lifetime flows to the output
+   |                                     the lifetime is elided here
    |
-help: one option is to remove the lifetime for references and use the anonymous lifetime for paths
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: use `'_` for type paths
    |
 LL | fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime<'_> {
    |                                                             ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:49:48
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:51:48
    |
 LL | fn explicit_anonymous_ref_to_implicit_path(v: &'_ u8) -> ContainsLifetime {
-   |                                                ^^        ---------------- the lifetime gets resolved as `'_`
+   |                                                ^^        ---------------- the same lifetime is hidden here
    |                                                |
-   |                                                this lifetime flows to the output
+   |                                                the lifetime is elided here
    |
-help: one option is to remove the lifetime for references and use the anonymous lifetime for paths
-   |
-LL - fn explicit_anonymous_ref_to_implicit_path(v: &'_ u8) -> ContainsLifetime {
-LL + fn explicit_anonymous_ref_to_implicit_path(v: &u8) -> ContainsLifetime<'_> {
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: use `'_` for type paths
    |
+LL | fn explicit_anonymous_ref_to_implicit_path(v: &'_ u8) -> ContainsLifetime<'_> {
+   |                                                                          ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:54:48
+error: hiding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:56:48
    |
 LL | fn explicit_bound_ref_to_implicit_path<'a>(v: &'a u8) -> ContainsLifetime {
-   |                                                ^^        ---------------- the lifetime gets resolved as `'a`
+   |                                                ^^        ---------------- the same lifetime is hidden here
    |                                                |
-   |                                                this lifetime flows to the output
+   |                                                the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL | fn explicit_bound_ref_to_implicit_path<'a>(v: &'a u8) -> ContainsLifetime<'a> {
    |                                                                          ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:59:58
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:61:58
    |
 LL | fn explicit_bound_ref_to_explicit_anonymous_path<'a>(v: &'a u8) -> ContainsLifetime<'_> {
-   |                                                          ^^                         -- the lifetime gets resolved as `'a`
+   |                                                          ^^                         -- the same lifetime is elided here
    |                                                          |
-   |                                                          this lifetime flows to the output
+   |                                                          the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL - fn explicit_bound_ref_to_explicit_anonymous_path<'a>(v: &'a u8) -> ContainsLifetime<'_> {
 LL + fn explicit_bound_ref_to_explicit_anonymous_path<'a>(v: &'a u8) -> ContainsLifetime<'a> {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:66:37
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:68:37
    |
 LL | fn implicit_path_to_implicit_ref(v: ContainsLifetime) -> &u8 {
-   |                                     ^^^^^^^^^^^^^^^^     --- the lifetime gets resolved as `'_`
+   |                                     ^^^^^^^^^^^^^^^^     --- the same lifetime is elided here
    |                                     |
-   |                                     this lifetime flows to the output
+   |                                     the lifetime is hidden here
    |
-help: one option is to remove the lifetime for references and use the anonymous lifetime for paths
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: use `'_` for type paths
    |
 LL | fn implicit_path_to_implicit_ref(v: ContainsLifetime<'_>) -> &u8 {
    |                                                     ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:71:47
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:73:47
    |
 LL | fn implicit_path_to_explicit_anonymous_ref(v: ContainsLifetime) -> &'_ u8 {
-   |                                               ^^^^^^^^^^^^^^^^      -- the lifetime gets resolved as `'_`
+   |                                               ^^^^^^^^^^^^^^^^      -- the same lifetime is elided here
    |                                               |
-   |                                               this lifetime flows to the output
-   |
-help: one option is to remove the lifetime for references and use the anonymous lifetime for paths
+   |                                               the lifetime is hidden here
    |
-LL - fn implicit_path_to_explicit_anonymous_ref(v: ContainsLifetime) -> &'_ u8 {
-LL + fn implicit_path_to_explicit_anonymous_ref(v: ContainsLifetime<'_>) -> &u8 {
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: use `'_` for type paths
    |
+LL | fn implicit_path_to_explicit_anonymous_ref(v: ContainsLifetime<'_>) -> &'_ u8 {
+   |                                                               ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:76:64
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:78:64
    |
 LL | fn explicit_bound_path_to_implicit_ref<'a>(v: ContainsLifetime<'a>) -> &u8 {
-   |                                                                ^^      --- the lifetime gets resolved as `'a`
+   |                                                                ^^      --- the same lifetime is elided here
    |                                                                |
-   |                                                                this lifetime flows to the output
+   |                                                                the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL | fn explicit_bound_path_to_implicit_ref<'a>(v: ContainsLifetime<'a>) -> &'a u8 {
    |                                                                         ++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:81:74
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:83:74
    |
 LL | fn explicit_bound_path_to_explicit_anonymous_ref<'a>(v: ContainsLifetime<'a>) -> &'_ u8 {
-   |                                                                          ^^       -- the lifetime gets resolved as `'a`
+   |                                                                          ^^       -- the same lifetime is elided here
    |                                                                          |
-   |                                                                          this lifetime flows to the output
+   |                                                                          the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL - fn explicit_bound_path_to_explicit_anonymous_ref<'a>(v: ContainsLifetime<'a>) -> &'_ u8 {
 LL + fn explicit_bound_path_to_explicit_anonymous_ref<'a>(v: ContainsLifetime<'a>) -> &'a u8 {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:87:55
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:89:55
    |
 LL |     fn method_explicit_bound_ref_to_implicit_ref<'a>(&'a self) -> &u8 {
-   |                                                       ^^          --- the lifetime gets resolved as `'a`
+   |                                                       ^^          --- the same lifetime is elided here
    |                                                       |
-   |                                                       this lifetime flows to the output
+   |                                                       the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL |     fn method_explicit_bound_ref_to_implicit_ref<'a>(&'a self) -> &'a u8 {
    |                                                                    ++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:92:65
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:94:65
    |
 LL |     fn method_explicit_bound_ref_to_explicit_anonymous_ref<'a>(&'a self) -> &'_ u8 {
-   |                                                                 ^^           -- the lifetime gets resolved as `'a`
+   |                                                                 ^^           -- the same lifetime is elided here
    |                                                                 |
-   |                                                                 this lifetime flows to the output
+   |                                                                 the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL -     fn method_explicit_bound_ref_to_explicit_anonymous_ref<'a>(&'a self) -> &'_ u8 {
 LL +     fn method_explicit_bound_ref_to_explicit_anonymous_ref<'a>(&'a self) -> &'a u8 {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:99:56
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:101:56
    |
 LL |     fn method_explicit_anonymous_ref_to_implicit_path(&'_ self) -> ContainsLifetime {
-   |                                                        ^^          ---------------- the lifetime gets resolved as `'_`
+   |                                                        ^^          ---------------- the same lifetime is hidden here
    |                                                        |
-   |                                                        this lifetime flows to the output
+   |                                                        the lifetime is elided here
    |
-help: one option is to remove the lifetime for references and use the anonymous lifetime for paths
-   |
-LL -     fn method_explicit_anonymous_ref_to_implicit_path(&'_ self) -> ContainsLifetime {
-LL +     fn method_explicit_anonymous_ref_to_implicit_path(&self) -> ContainsLifetime<'_> {
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: use `'_` for type paths
    |
+LL |     fn method_explicit_anonymous_ref_to_implicit_path(&'_ self) -> ContainsLifetime<'_> {
+   |                                                                                    ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:104:56
+error: hiding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:106:56
    |
 LL |     fn method_explicit_bound_ref_to_implicit_path<'a>(&'a self) -> ContainsLifetime {
-   |                                                        ^^          ---------------- the lifetime gets resolved as `'a`
+   |                                                        ^^          ---------------- the same lifetime is hidden here
    |                                                        |
-   |                                                        this lifetime flows to the output
+   |                                                        the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL |     fn method_explicit_bound_ref_to_implicit_path<'a>(&'a self) -> ContainsLifetime<'a> {
    |                                                                                    ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:109:66
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:111:66
    |
 LL |     fn method_explicit_bound_ref_to_explicit_anonymous_path<'a>(&'a self) -> ContainsLifetime<'_> {
-   |                                                                  ^^                           -- the lifetime gets resolved as `'a`
+   |                                                                  ^^                           -- the same lifetime is elided here
    |                                                                  |
-   |                                                                  this lifetime flows to the output
+   |                                                                  the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL -     fn method_explicit_bound_ref_to_explicit_anonymous_path<'a>(&'a self) -> ContainsLifetime<'_> {
 LL +     fn method_explicit_bound_ref_to_explicit_anonymous_path<'a>(&'a self) -> ContainsLifetime<'a> {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:124:39
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:126:39
    |
 LL |     fn static_ref_to_implicit_ref(v: &'static u8) -> &u8 {
-   |                                       ^^^^^^^        --- the lifetime gets resolved as `'static`
+   |                                       ^^^^^^^        --- the same lifetime is elided here
    |                                       |
-   |                                       this lifetime flows to the output
+   |                                       the lifetime is named here
    |
-help: one option is to consistently use `'static`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'static`
    |
 LL |     fn static_ref_to_implicit_ref(v: &'static u8) -> &'static u8 {
    |                                                       +++++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:129:49
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:131:49
    |
 LL |     fn static_ref_to_explicit_anonymous_ref(v: &'static u8) -> &'_ u8 {
-   |                                                 ^^^^^^^         -- the lifetime gets resolved as `'static`
+   |                                                 ^^^^^^^         -- the same lifetime is elided here
    |                                                 |
-   |                                                 this lifetime flows to the output
+   |                                                 the lifetime is named here
    |
-help: one option is to consistently use `'static`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'static`
    |
 LL -     fn static_ref_to_explicit_anonymous_ref(v: &'static u8) -> &'_ u8 {
 LL +     fn static_ref_to_explicit_anonymous_ref(v: &'static u8) -> &'static u8 {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:134:40
+error: hiding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:136:40
    |
 LL |     fn static_ref_to_implicit_path(v: &'static u8) -> ContainsLifetime {
-   |                                        ^^^^^^^        ---------------- the lifetime gets resolved as `'static`
+   |                                        ^^^^^^^        ---------------- the same lifetime is hidden here
    |                                        |
-   |                                        this lifetime flows to the output
+   |                                        the lifetime is named here
    |
-help: one option is to consistently use `'static`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'static`
    |
 LL |     fn static_ref_to_implicit_path(v: &'static u8) -> ContainsLifetime<'static> {
    |                                                                       +++++++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:139:50
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:141:50
    |
 LL |     fn static_ref_to_explicit_anonymous_path(v: &'static u8) -> ContainsLifetime<'_> {
-   |                                                  ^^^^^^^                         -- the lifetime gets resolved as `'static`
+   |                                                  ^^^^^^^                         -- the same lifetime is elided here
    |                                                  |
-   |                                                  this lifetime flows to the output
+   |                                                  the lifetime is named here
    |
-help: one option is to consistently use `'static`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'static`
    |
 LL -     fn static_ref_to_explicit_anonymous_path(v: &'static u8) -> ContainsLifetime<'_> {
 LL +     fn static_ref_to_explicit_anonymous_path(v: &'static u8) -> ContainsLifetime<'static> {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:145:40
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:147:40
    |
 LL |         fn static_ref_to_implicit_ref(&'static self) -> &u8 {
-   |                                        ^^^^^^^          --- the lifetime gets resolved as `'static`
+   |                                        ^^^^^^^          --- the same lifetime is elided here
    |                                        |
-   |                                        this lifetime flows to the output
+   |                                        the lifetime is named here
    |
-help: one option is to consistently use `'static`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'static`
    |
 LL |         fn static_ref_to_implicit_ref(&'static self) -> &'static u8 {
    |                                                          +++++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:150:50
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:152:50
    |
 LL |         fn static_ref_to_explicit_anonymous_ref(&'static self) -> &'_ u8 {
-   |                                                  ^^^^^^^           -- the lifetime gets resolved as `'static`
+   |                                                  ^^^^^^^           -- the same lifetime is elided here
    |                                                  |
-   |                                                  this lifetime flows to the output
+   |                                                  the lifetime is named here
    |
-help: one option is to consistently use `'static`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'static`
    |
 LL -         fn static_ref_to_explicit_anonymous_ref(&'static self) -> &'_ u8 {
 LL +         fn static_ref_to_explicit_anonymous_ref(&'static self) -> &'static u8 {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:155:41
+error: hiding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:157:41
    |
 LL |         fn static_ref_to_implicit_path(&'static self) -> ContainsLifetime {
-   |                                         ^^^^^^^          ---------------- the lifetime gets resolved as `'static`
+   |                                         ^^^^^^^          ---------------- the same lifetime is hidden here
    |                                         |
-   |                                         this lifetime flows to the output
+   |                                         the lifetime is named here
    |
-help: one option is to consistently use `'static`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'static`
    |
 LL |         fn static_ref_to_implicit_path(&'static self) -> ContainsLifetime<'static> {
    |                                                                          +++++++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:160:51
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:162:51
    |
 LL |         fn static_ref_to_explicit_anonymous_path(&'static self) -> ContainsLifetime<'_> {
-   |                                                   ^^^^^^^                           -- the lifetime gets resolved as `'static`
+   |                                                   ^^^^^^^                           -- the same lifetime is elided here
    |                                                   |
-   |                                                   this lifetime flows to the output
+   |                                                   the lifetime is named here
    |
-help: one option is to consistently use `'static`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'static`
    |
 LL -         fn static_ref_to_explicit_anonymous_path(&'static self) -> ContainsLifetime<'_> {
 LL +         fn static_ref_to_explicit_anonymous_path(&'static self) -> ContainsLifetime<'static> {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:172:55
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:174:55
    |
 LL |     fn explicit_bound_ref_to_impl_trait_bound<'a>(v: &'a u8) -> impl FnOnce() + '_ {
-   |                                                       ^^                        -- the lifetime gets resolved as `'a`
+   |                                                       ^^                        -- the same lifetime is elided here
    |                                                       |
-   |                                                       this lifetime flows to the output
+   |                                                       the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL -     fn explicit_bound_ref_to_impl_trait_bound<'a>(v: &'a u8) -> impl FnOnce() + '_ {
 LL +     fn explicit_bound_ref_to_impl_trait_bound<'a>(v: &'a u8) -> impl FnOnce() + 'a {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:177:65
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:179:65
    |
 LL |     fn explicit_bound_ref_to_impl_trait_precise_capture<'a>(v: &'a u8) -> impl FnOnce() + use<'_> {
-   |                                                                 ^^                            -- the lifetime gets resolved as `'a`
-   |                                                                 |
-   |                                                                 this lifetime flows to the output
+   |                                                                 ^^ the lifetime is named here -- the same lifetime is elided here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL -     fn explicit_bound_ref_to_impl_trait_precise_capture<'a>(v: &'a u8) -> impl FnOnce() + use<'_> {
 LL +     fn explicit_bound_ref_to_impl_trait_precise_capture<'a>(v: &'a u8) -> impl FnOnce() + use<'a> {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:182:72
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:184:72
    |
 LL |     fn explicit_bound_path_to_impl_trait_bound<'a>(v: ContainsLifetime<'a>) -> impl FnOnce() + '_ {
-   |                                                                        ^^                      -- the lifetime gets resolved as `'a`
+   |                                                                        ^^                      -- the same lifetime is elided here
    |                                                                        |
-   |                                                                        this lifetime flows to the output
+   |                                                                        the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL -     fn explicit_bound_path_to_impl_trait_bound<'a>(v: ContainsLifetime<'a>) -> impl FnOnce() + '_ {
 LL +     fn explicit_bound_path_to_impl_trait_bound<'a>(v: ContainsLifetime<'a>) -> impl FnOnce() + 'a {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:188:29
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:190:29
    |
 LL |         v: ContainsLifetime<'a>,
-   |                             ^^ this lifetime flows to the output
+   |                             ^^ the lifetime is named here
 LL |
 LL |     ) -> impl FnOnce() + use<'_> {
-   |                              -- the lifetime gets resolved as `'a`
+   |                              -- the same lifetime is elided here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL -     ) -> impl FnOnce() + use<'_> {
 LL +     ) -> impl FnOnce() + use<'a> {
    |
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:202:54
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:204:54
    |
 LL |     fn explicit_bound_ref_to_dyn_trait_bound<'a>(v: &'a u8) -> Box<dyn Iterator<Item = &u8> + '_> {
-   |                                                      ^^                                ---    -- the lifetimes get resolved as `'a`
-   |                                                      |                                 |
-   |                                                      |                                 the lifetimes get resolved as `'a`
-   |                                                      this lifetime flows to the output
+   |                                                      ^^ the lifetime is named here     --- the same lifetime is elided here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL |     fn explicit_bound_ref_to_dyn_trait_bound<'a>(v: &'a u8) -> Box<dyn Iterator<Item = &'a u8> + '_> {
    |                                                                                         ++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:208:29
+error: hiding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:210:29
    |
 LL |         v: ContainsLifetime<'a>,
-   |                             ^^ this lifetime flows to the output
+   |                             ^^ the lifetime is named here
 LL |
 LL |     ) -> Box<dyn Iterator<Item = ContainsLifetime> + '_> {
-   |                                  ----------------    -- the lifetimes get resolved as `'a`
-   |                                  |
-   |                                  the lifetimes get resolved as `'a`
+   |                                  ---------------- the same lifetime is hidden here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL |     ) -> Box<dyn Iterator<Item = ContainsLifetime<'a>> + '_> {
    |                                                  ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:217:33
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:222:33
+   |
+LL |     fn multiple_inputs<'a>(v: (&'a u8, &'a u8)) -> &u8 {
+   |                                 ^^      ^^         --- the same lifetime is elided here
+   |                                 |       |
+   |                                 |       the lifetime is named here
+   |                                 the lifetime is named here
+   |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
+   |
+LL |     fn multiple_inputs<'a>(v: (&'a u8, &'a u8)) -> &'a u8 {
+   |                                                     ++
+
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:227:33
    |
 LL |     fn multiple_outputs<'a>(v: &'a u8) -> (&u8, &u8) {
-   |                                 ^^         ---  --- the lifetimes get resolved as `'a`
+   |                                 ^^         ---  --- the same lifetime is elided here
    |                                 |          |
-   |                                 |          the lifetimes get resolved as `'a`
-   |                                 this lifetime flows to the output
+   |                                 |          the same lifetime is elided here
+   |                                 the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL |     fn multiple_outputs<'a>(v: &'a u8) -> (&'a u8, &'a u8) {
    |                                             ++      ++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:230:45
+error: hiding or eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:232:53
+   |
+LL |     fn all_three_categories<'a>(v: ContainsLifetime<'a>) -> (&u8, ContainsLifetime) {
+   |                                                     ^^       ---  ---------------- the same lifetime is hidden here
+   |                                                     |        |
+   |                                                     |        the same lifetime is elided here
+   |                                                     the lifetime is named here
+   |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
+   |
+LL |     fn all_three_categories<'a>(v: ContainsLifetime<'a>) -> (&'a u8, ContainsLifetime<'a>) {
+   |                                                               ++                     ++++
+
+error: eliding a lifetime that's named elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:237:38
+   |
+LL |     fn explicit_bound_output<'a>(v: &'a u8) -> (&u8, &'a u8, ContainsLifetime<'a>) {
+   |                                      ^^         ---   --                      -- the same lifetime is named here
+   |                                      |          |     |
+   |                                      |          |     the same lifetime is named here
+   |                                      |          the same lifetime is elided here
+   |                                      the lifetime is named here
+   |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
+   |
+LL |     fn explicit_bound_output<'a>(v: &'a u8) -> (&'a u8, &'a u8, ContainsLifetime<'a>) {
+   |                                                  ++
+
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:250:45
    |
 LL |         fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime;
-   |                                             ^^^     ---------------- the lifetime gets resolved as `'_`
+   |                                             ^^^     ---------------- the same lifetime is hidden here
    |                                             |
-   |                                             this lifetime flows to the output
+   |                                             the lifetime is elided here
    |
-help: one option is to remove the lifetime for references and use the anonymous lifetime for paths
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: use `'_` for type paths
    |
 LL |         fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime<'_>;
    |                                                                     ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:233:49
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:253:49
    |
 LL |         fn method_implicit_ref_to_implicit_path(&self) -> ContainsLifetime;
-   |                                                 ^^^^^     ---------------- the lifetime gets resolved as `'_`
+   |                                                 ^^^^^     ---------------- the same lifetime is hidden here
    |                                                 |
-   |                                                 this lifetime flows to the output
+   |                                                 the lifetime is elided here
    |
-help: one option is to remove the lifetime for references and use the anonymous lifetime for paths
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: use `'_` for type paths
    |
 LL |         fn method_implicit_ref_to_implicit_path(&self) -> ContainsLifetime<'_>;
    |                                                                           ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:238:45
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:258:45
    |
 LL |         fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime {
-   |                                             ^^^     ---------------- the lifetime gets resolved as `'_`
+   |                                             ^^^     ---------------- the same lifetime is hidden here
    |                                             |
-   |                                             this lifetime flows to the output
+   |                                             the lifetime is elided here
    |
-help: one option is to remove the lifetime for references and use the anonymous lifetime for paths
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: use `'_` for type paths
    |
 LL |         fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime<'_> {
    |                                                                     ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:243:49
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:263:49
    |
 LL |         fn method_implicit_ref_to_implicit_path(&self) -> ContainsLifetime {
-   |                                                 ^^^^^     ---------------- the lifetime gets resolved as `'_`
+   |                                                 ^^^^^     ---------------- the same lifetime is hidden here
    |                                                 |
-   |                                                 this lifetime flows to the output
+   |                                                 the lifetime is elided here
    |
-help: one option is to remove the lifetime for references and use the anonymous lifetime for paths
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: use `'_` for type paths
    |
 LL |         fn method_implicit_ref_to_implicit_path(&self) -> ContainsLifetime<'_> {
    |                                                                           ++++
 
-error: lifetime flowing from input to output with different syntax can be confusing
-  --> $DIR/mismatched-lifetime-syntaxes.rs:257:45
+error: hiding a lifetime that's elided elsewhere is confusing
+  --> $DIR/mismatched-lifetime-syntaxes.rs:277:45
    |
 LL |         fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime;
-   |                                             ^^^     ---------------- the lifetime gets resolved as `'_`
+   |                                             ^^^     ---------------- the same lifetime is hidden here
    |                                             |
-   |                                             this lifetime flows to the output
+   |                                             the lifetime is elided here
    |
-help: one option is to remove the lifetime for references and use the anonymous lifetime for paths
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: use `'_` for type paths
    |
 LL |         fn implicit_ref_to_implicit_path(v: &u8) -> ContainsLifetime<'_>;
    |                                                                     ++++
 
-error: aborting due to 39 previous errors
+error: aborting due to 42 previous errors
 
diff --git a/tests/ui/self/elision/ignore-non-reference-lifetimes.rs b/tests/ui/self/elision/ignore-non-reference-lifetimes.rs
index ecd669059ed..ce2fb8235cc 100644
--- a/tests/ui/self/elision/ignore-non-reference-lifetimes.rs
+++ b/tests/ui/self/elision/ignore-non-reference-lifetimes.rs
@@ -4,11 +4,11 @@ struct Foo<'a>(&'a str);
 
 impl<'b> Foo<'b> {
     fn a<'a>(self: Self, a: &'a str) -> &str {
-        //~^ WARNING lifetime flowing from input to output with different syntax
+        //~^ WARNING eliding a lifetime that's named elsewhere is confusing
         a
     }
     fn b<'a>(self: Foo<'b>, a: &'a str) -> &str {
-        //~^ WARNING lifetime flowing from input to output with different syntax
+        //~^ WARNING eliding a lifetime that's named elsewhere is confusing
         a
     }
 }
diff --git a/tests/ui/self/elision/ignore-non-reference-lifetimes.stderr b/tests/ui/self/elision/ignore-non-reference-lifetimes.stderr
index 5351bf3c94c..7108fa1a290 100644
--- a/tests/ui/self/elision/ignore-non-reference-lifetimes.stderr
+++ b/tests/ui/self/elision/ignore-non-reference-lifetimes.stderr
@@ -1,26 +1,28 @@
-warning: lifetime flowing from input to output with different syntax can be confusing
+warning: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/ignore-non-reference-lifetimes.rs:6:30
    |
 LL |     fn a<'a>(self: Self, a: &'a str) -> &str {
-   |                              ^^         ---- the lifetime gets resolved as `'a`
+   |                              ^^         ---- the same lifetime is elided here
    |                              |
-   |                              this lifetime flows to the output
+   |                              the lifetime is named here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
    = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
-help: one option is to consistently use `'a`
+help: consistently use `'a`
    |
 LL |     fn a<'a>(self: Self, a: &'a str) -> &'a str {
    |                                          ++
 
-warning: lifetime flowing from input to output with different syntax can be confusing
+warning: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/ignore-non-reference-lifetimes.rs:10:33
    |
 LL |     fn b<'a>(self: Foo<'b>, a: &'a str) -> &str {
-   |                                 ^^         ---- the lifetime gets resolved as `'a`
+   |                                 ^^         ---- the same lifetime is elided here
    |                                 |
-   |                                 this lifetime flows to the output
+   |                                 the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL |     fn b<'a>(self: Foo<'b>, a: &'a str) -> &'a str {
    |                                             ++
diff --git a/tests/ui/self/self_lifetime-async.rs b/tests/ui/self/self_lifetime-async.rs
index f839ab03a60..0093971fee4 100644
--- a/tests/ui/self/self_lifetime-async.rs
+++ b/tests/ui/self/self_lifetime-async.rs
@@ -4,13 +4,13 @@
 struct Foo<'a>(&'a ());
 impl<'a> Foo<'a> {
     async fn foo<'b>(self: &'b Foo<'a>) -> &() { self.0 }
-    //~^ WARNING lifetime flowing from input to output with different syntax
+    //~^ WARNING eliding a lifetime that's named elsewhere is confusing
 }
 
 type Alias = Foo<'static>;
 impl Alias {
     async fn bar<'a>(self: &Alias, arg: &'a ()) -> &() { arg }
-    //~^ WARNING lifetime flowing from input to output with different syntax
+    //~^ WARNING eliding a lifetime that's named elsewhere is confusing
 }
 
 fn main() {}
diff --git a/tests/ui/self/self_lifetime-async.stderr b/tests/ui/self/self_lifetime-async.stderr
index a9c1be2e808..43dc96abdc2 100644
--- a/tests/ui/self/self_lifetime-async.stderr
+++ b/tests/ui/self/self_lifetime-async.stderr
@@ -1,26 +1,28 @@
-warning: lifetime flowing from input to output with different syntax can be confusing
+warning: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/self_lifetime-async.rs:6:29
    |
 LL |     async fn foo<'b>(self: &'b Foo<'a>) -> &() { self.0 }
-   |                             ^^             --- the lifetime gets resolved as `'b`
+   |                             ^^             --- the same lifetime is elided here
    |                             |
-   |                             this lifetime flows to the output
+   |                             the lifetime is named here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
    = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
-help: one option is to consistently use `'b`
+help: consistently use `'b`
    |
 LL |     async fn foo<'b>(self: &'b Foo<'a>) -> &'b () { self.0 }
    |                                             ++
 
-warning: lifetime flowing from input to output with different syntax can be confusing
+warning: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/self_lifetime-async.rs:12:42
    |
 LL |     async fn bar<'a>(self: &Alias, arg: &'a ()) -> &() { arg }
-   |                                          ^^        --- the lifetime gets resolved as `'a`
+   |                                          ^^        --- the same lifetime is elided here
    |                                          |
-   |                                          this lifetime flows to the output
+   |                                          the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL |     async fn bar<'a>(self: &Alias, arg: &'a ()) -> &'a () { arg }
    |                                                     ++
diff --git a/tests/ui/self/self_lifetime.rs b/tests/ui/self/self_lifetime.rs
index aaa31f85ad5..190809af22f 100644
--- a/tests/ui/self/self_lifetime.rs
+++ b/tests/ui/self/self_lifetime.rs
@@ -5,13 +5,13 @@
 struct Foo<'a>(&'a ());
 impl<'a> Foo<'a> {
     fn foo<'b>(self: &'b Foo<'a>) -> &() { self.0 }
-    //~^ WARNING lifetime flowing from input to output with different syntax
+    //~^ WARNING eliding a lifetime that's named elsewhere is confusing
 }
 
 type Alias = Foo<'static>;
 impl Alias {
     fn bar<'a>(self: &Alias, arg: &'a ()) -> &() { arg }
-    //~^ WARNING lifetime flowing from input to output with different syntax
+    //~^ WARNING eliding a lifetime that's named elsewhere is confusing
 }
 
 fn main() {}
diff --git a/tests/ui/self/self_lifetime.stderr b/tests/ui/self/self_lifetime.stderr
index ec676e69cf6..4f9b2fcd2ad 100644
--- a/tests/ui/self/self_lifetime.stderr
+++ b/tests/ui/self/self_lifetime.stderr
@@ -1,26 +1,28 @@
-warning: lifetime flowing from input to output with different syntax can be confusing
+warning: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/self_lifetime.rs:7:23
    |
 LL |     fn foo<'b>(self: &'b Foo<'a>) -> &() { self.0 }
-   |                       ^^             --- the lifetime gets resolved as `'b`
+   |                       ^^             --- the same lifetime is elided here
    |                       |
-   |                       this lifetime flows to the output
+   |                       the lifetime is named here
    |
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
    = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
-help: one option is to consistently use `'b`
+help: consistently use `'b`
    |
 LL |     fn foo<'b>(self: &'b Foo<'a>) -> &'b () { self.0 }
    |                                       ++
 
-warning: lifetime flowing from input to output with different syntax can be confusing
+warning: eliding a lifetime that's named elsewhere is confusing
   --> $DIR/self_lifetime.rs:13:36
    |
 LL |     fn bar<'a>(self: &Alias, arg: &'a ()) -> &() { arg }
-   |                                    ^^        --- the lifetime gets resolved as `'a`
+   |                                    ^^        --- the same lifetime is elided here
    |                                    |
-   |                                    this lifetime flows to the output
+   |                                    the lifetime is named here
    |
-help: one option is to consistently use `'a`
+   = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
+help: consistently use `'a`
    |
 LL |     fn bar<'a>(self: &Alias, arg: &'a ()) -> &'a () { arg }
    |                                               ++
-- 
cgit 1.4.1-3-g733a5


From c8fb37a521b1f8cf13ddf1ffb81b0a30b05e0706 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Sat, 31 May 2025 10:39:09 +0000
Subject: Don't call WSACleanup on process exit

---
 .../std/src/sys/net/connection/socket/windows.rs   | 36 +++++++++++++---------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/library/std/src/sys/net/connection/socket/windows.rs b/library/std/src/sys/net/connection/socket/windows.rs
index ce975bb2289..b71d8b1357b 100644
--- a/library/std/src/sys/net/connection/socket/windows.rs
+++ b/library/std/src/sys/net/connection/socket/windows.rs
@@ -8,7 +8,8 @@ use crate::net::{Shutdown, SocketAddr};
 use crate::os::windows::io::{
     AsRawSocket, AsSocket, BorrowedSocket, FromRawSocket, IntoRawSocket, OwnedSocket, RawSocket,
 };
-use crate::sync::OnceLock;
+use crate::sync::atomic::Atomic;
+use crate::sync::atomic::Ordering::{AcqRel, Relaxed};
 use crate::sys::c;
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::time::Duration;
@@ -114,33 +115,38 @@ pub(super) mod netc {
 #[expect(missing_debug_implementations)]
 pub struct Socket(OwnedSocket);
 
-static WSA_CLEANUP: OnceLock<unsafe extern "system" fn() -> i32> = OnceLock::new();
+static WSA_INITIALIZED: Atomic<bool> = Atomic::<bool>::new(false);
 
 /// Checks whether the Windows socket interface has been started already, and
 /// if not, starts it.
+#[inline]
 pub fn init() {
-    let _ = WSA_CLEANUP.get_or_init(|| unsafe {
+    if !WSA_INITIALIZED.load(Relaxed) {
+        wsa_startup();
+    }
+}
+
+#[cold]
+fn wsa_startup() {
+    unsafe {
         let mut data: c::WSADATA = mem::zeroed();
         let ret = c::WSAStartup(
             0x202, // version 2.2
             &mut data,
         );
         assert_eq!(ret, 0);
-
-        // Only register `WSACleanup` if `WSAStartup` is actually ever called.
-        // Workaround to prevent linking to `WS2_32.dll` when no network functionality is used.
-        // See issue #85441.
-        c::WSACleanup
-    });
+        if WSA_INITIALIZED.swap(true, AcqRel) {
+            // If another thread raced with us and called WSAStartup first then call
+            // WSACleanup so it's as though WSAStartup was only called once.
+            c::WSACleanup();
+        }
+    }
 }
 
 pub fn cleanup() {
-    // only perform cleanup if network functionality was actually initialized
-    if let Some(cleanup) = WSA_CLEANUP.get() {
-        unsafe {
-            cleanup();
-        }
-    }
+    // We don't need to call WSACleanup here because exiting the process will cause
+    // the OS to clean everything for us, which is faster than doing it manually.
+    // See #141799.
 }
 
 /// Returns the last error from the Windows socket interface.
-- 
cgit 1.4.1-3-g733a5


From 1b8d65ed29e17e24d0acecf1986ab320c5747a85 Mon Sep 17 00:00:00 2001
From: Ada Alakbarova <ada.alakbarova@proton.me>
Date: Mon, 14 Jul 2025 18:10:41 +0200
Subject: rustc_type_ir/walk: move docstring to `TypeWalker` itself

having it on the impl block is a bit weird imo
---
 compiler/rustc_type_ir/src/walk.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_type_ir/src/walk.rs b/compiler/rustc_type_ir/src/walk.rs
index 737550eb73e..9912fad1756 100644
--- a/compiler/rustc_type_ir/src/walk.rs
+++ b/compiler/rustc_type_ir/src/walk.rs
@@ -12,12 +12,6 @@ use crate::{self as ty, Interner};
 // avoid heap allocations.
 type TypeWalkerStack<I> = SmallVec<[<I as Interner>::GenericArg; 8]>;
 
-pub struct TypeWalker<I: Interner> {
-    stack: TypeWalkerStack<I>,
-    last_subtree: usize,
-    pub visited: SsoHashSet<I::GenericArg>,
-}
-
 /// An iterator for walking the type tree.
 ///
 /// It's very easy to produce a deeply
@@ -26,6 +20,12 @@ pub struct TypeWalker<I: Interner> {
 /// in this situation walker only visits each type once.
 /// It maintains a set of visited types and
 /// skips any types that are already there.
+pub struct TypeWalker<I: Interner> {
+    stack: TypeWalkerStack<I>,
+    last_subtree: usize,
+    pub visited: SsoHashSet<I::GenericArg>,
+}
+
 impl<I: Interner> TypeWalker<I> {
     pub fn new(root: I::GenericArg) -> Self {
         Self { stack: smallvec![root], last_subtree: 1, visited: SsoHashSet::new() }
-- 
cgit 1.4.1-3-g733a5


From ae1b1b4f8a9a1cd012cd7db944bbfa2adae703cb Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Tue, 10 Jun 2025 18:36:22 +0200
Subject: tests: Fix duplicated-path-in-error fail with musl

musl's dlopen returns a different error than glibc, which contains the
name of the file. This would cause the test to fail, since the filename
would appear twice in the output (once in the error from rustc, once in
the error message from musl). Split the expected test outputs for the
different libc implementations.

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 src/tools/compiletest/src/directives.rs               | 1 +
 tests/ui/codegen/duplicated-path-in-error.gnu.stderr  | 2 ++
 tests/ui/codegen/duplicated-path-in-error.musl.stderr | 2 ++
 tests/ui/codegen/duplicated-path-in-error.rs          | 7 +++++++
 tests/ui/codegen/duplicated-path-in-error.stderr      | 2 --
 5 files changed, 12 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/codegen/duplicated-path-in-error.gnu.stderr
 create mode 100644 tests/ui/codegen/duplicated-path-in-error.musl.stderr
 delete mode 100644 tests/ui/codegen/duplicated-path-in-error.stderr

diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 215793fe947..e31f8f43e1b 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -973,6 +973,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "only-mips64",
     "only-msp430",
     "only-msvc",
+    "only-musl",
     "only-nightly",
     "only-nvptx64",
     "only-powerpc",
diff --git a/tests/ui/codegen/duplicated-path-in-error.gnu.stderr b/tests/ui/codegen/duplicated-path-in-error.gnu.stderr
new file mode 100644
index 00000000000..d0d34e2f934
--- /dev/null
+++ b/tests/ui/codegen/duplicated-path-in-error.gnu.stderr
@@ -0,0 +1,2 @@
+error: couldn't load codegen backend /non-existing-one.so: cannot open shared object file: No such file or directory
+
diff --git a/tests/ui/codegen/duplicated-path-in-error.musl.stderr b/tests/ui/codegen/duplicated-path-in-error.musl.stderr
new file mode 100644
index 00000000000..2892ebffdde
--- /dev/null
+++ b/tests/ui/codegen/duplicated-path-in-error.musl.stderr
@@ -0,0 +1,2 @@
+error: couldn't load codegen backend /non-existing-one.so: Error loading shared library /non-existing-one.so: No such file or directory
+
diff --git a/tests/ui/codegen/duplicated-path-in-error.rs b/tests/ui/codegen/duplicated-path-in-error.rs
index a446395de20..fed93828ee2 100644
--- a/tests/ui/codegen/duplicated-path-in-error.rs
+++ b/tests/ui/codegen/duplicated-path-in-error.rs
@@ -1,8 +1,15 @@
+//@ revisions: musl gnu
 //@ only-linux
+//@ ignore-cross-compile because this relies on host libc behaviour
 //@ compile-flags: -Zcodegen-backend=/non-existing-one.so
+//@[gnu] only-gnu
+//@[musl] only-musl
 
 // This test ensures that the error of the "not found dylib" doesn't duplicate
 // the path of the dylib.
+//
+// glibc and musl have different dlopen error messages, so the expected error
+// message differs between the two.
 
 fn main() {}
 
diff --git a/tests/ui/codegen/duplicated-path-in-error.stderr b/tests/ui/codegen/duplicated-path-in-error.stderr
deleted file mode 100644
index d0d34e2f934..00000000000
--- a/tests/ui/codegen/duplicated-path-in-error.stderr
+++ /dev/null
@@ -1,2 +0,0 @@
-error: couldn't load codegen backend /non-existing-one.so: cannot open shared object file: No such file or directory
-
-- 
cgit 1.4.1-3-g733a5


From 904273c58e474877786679f89a6a7e15b75acfb1 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Tue, 8 Jul 2025 17:31:37 +0800
Subject: Register change tracker warning for removal of `./x suggest`

---
 src/bootstrap/src/utils/change_tracker.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 1f6ed8129da..d888a7863bc 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -476,4 +476,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Info,
         summary: "Option `tool.TOOL_NAME.features` now works on any subcommand, not just `build`.",
     },
+    ChangeInfo {
+        change_id: 143630,
+        severity: ChangeSeverity::Warning,
+        summary: "The current `./x suggest` implementation has been removed due to it being quite broken and a lack of maintenance bandwidth, with no prejudice against re-implementing it in a more maintainable form.",
+    },
 ];
-- 
cgit 1.4.1-3-g733a5


From 91d064b44286d87723fc8ef2ae9d8e3d047d12f2 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Tue, 8 Jul 2025 17:52:00 +0800
Subject: Remove current implementation of `./x suggest`

This is quite a bit of implementation complexity, yet it is quite
broken, and we don't have the maintenance bandwidth to address.

Remove the current implementation if only to reduce bootstrap's
implementation complexity; the `suggest` flow comes with its own set of
hacks.
---
 Cargo.lock                                         |  8 --
 Cargo.toml                                         |  1 -
 src/bootstrap/src/core/build_steps/mod.rs          |  1 -
 src/bootstrap/src/core/build_steps/suggest.rs      | 68 ---------------
 src/bootstrap/src/core/build_steps/test.rs         |  9 +-
 src/bootstrap/src/core/build_steps/tool.rs         |  1 -
 src/bootstrap/src/core/builder/cargo.rs            |  2 +-
 src/bootstrap/src/core/builder/mod.rs              |  6 +-
 src/bootstrap/src/core/config/config.rs            |  2 -
 src/bootstrap/src/core/config/flags.rs             |  8 --
 src/bootstrap/src/core/sanity.rs                   |  1 -
 src/bootstrap/src/lib.rs                           | 11 +--
 src/bootstrap/src/utils/cc_detect.rs               |  1 -
 src/bootstrap/src/utils/metrics.rs                 |  2 +-
 src/tools/suggest-tests/Cargo.toml                 |  8 --
 src/tools/suggest-tests/src/dynamic_suggestions.rs | 32 --------
 src/tools/suggest-tests/src/lib.rs                 | 96 ----------------------
 src/tools/suggest-tests/src/main.rs                | 40 ---------
 src/tools/suggest-tests/src/static_suggestions.rs  | 40 ---------
 src/tools/suggest-tests/src/tests.rs               | 21 -----
 20 files changed, 10 insertions(+), 348 deletions(-)
 delete mode 100644 src/bootstrap/src/core/build_steps/suggest.rs
 delete mode 100644 src/tools/suggest-tests/Cargo.toml
 delete mode 100644 src/tools/suggest-tests/src/dynamic_suggestions.rs
 delete mode 100644 src/tools/suggest-tests/src/lib.rs
 delete mode 100644 src/tools/suggest-tests/src/main.rs
 delete mode 100644 src/tools/suggest-tests/src/static_suggestions.rs
 delete mode 100644 src/tools/suggest-tests/src/tests.rs

diff --git a/Cargo.lock b/Cargo.lock
index a6c36b4bdfa..ff2b21c64b0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5188,14 +5188,6 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "suggest-tests"
-version = "0.1.0"
-dependencies = [
- "build_helper",
- "glob",
-]
-
 [[package]]
 name = "syn"
 version = "1.0.109"
diff --git a/Cargo.toml b/Cargo.toml
index 6d3425f4115..67c7a9d67ed 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,7 +39,6 @@ members = [
   "src/tools/rustdoc-gui-test",
   "src/tools/rustdoc-themes",
   "src/tools/rustfmt",
-  "src/tools/suggest-tests",
   "src/tools/test-float-parse",
   "src/tools/tidy",
   "src/tools/tier-check",
diff --git a/src/bootstrap/src/core/build_steps/mod.rs b/src/bootstrap/src/core/build_steps/mod.rs
index fcb6abea434..c2ad9a4df59 100644
--- a/src/bootstrap/src/core/build_steps/mod.rs
+++ b/src/bootstrap/src/core/build_steps/mod.rs
@@ -11,7 +11,6 @@ pub(crate) mod llvm;
 pub(crate) mod perf;
 pub(crate) mod run;
 pub(crate) mod setup;
-pub(crate) mod suggest;
 pub(crate) mod synthetic_targets;
 pub(crate) mod test;
 pub(crate) mod tool;
diff --git a/src/bootstrap/src/core/build_steps/suggest.rs b/src/bootstrap/src/core/build_steps/suggest.rs
deleted file mode 100644
index fd4918961ad..00000000000
--- a/src/bootstrap/src/core/build_steps/suggest.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//! Attempt to magically identify good tests to run
-
-use std::path::PathBuf;
-use std::str::FromStr;
-
-use clap::Parser;
-
-use crate::core::build_steps::tool::Tool;
-use crate::core::builder::Builder;
-
-/// Suggests a list of possible `x.py` commands to run based on modified files in branch.
-pub fn suggest(builder: &Builder<'_>, run: bool) {
-    let git_config = builder.config.git_config();
-    let suggestions = builder
-        .tool_cmd(Tool::SuggestTests)
-        .env("SUGGEST_TESTS_NIGHTLY_BRANCH", git_config.nightly_branch)
-        .env("SUGGEST_TESTS_MERGE_COMMIT_EMAIL", git_config.git_merge_commit_email)
-        .run_capture_stdout(builder)
-        .stdout();
-
-    let suggestions = suggestions
-        .lines()
-        .map(|line| {
-            let mut sections = line.split_ascii_whitespace();
-
-            // this code expects one suggestion per line in the following format:
-            // <x_subcommand> {some number of flags} [optional stage number]
-            let cmd = sections.next().unwrap();
-            let stage = sections.next_back().and_then(|s| str::parse(s).ok());
-            let paths: Vec<PathBuf> = sections.map(|p| PathBuf::from_str(p).unwrap()).collect();
-
-            (cmd, stage, paths)
-        })
-        .collect::<Vec<_>>();
-
-    if !suggestions.is_empty() {
-        println!("==== SUGGESTIONS ====");
-        for sug in &suggestions {
-            print!("x {} ", sug.0);
-            if let Some(stage) = sug.1 {
-                print!("--stage {stage} ");
-            }
-
-            for path in &sug.2 {
-                print!("{} ", path.display());
-            }
-            println!();
-        }
-        println!("=====================");
-    } else {
-        println!("No suggestions found!");
-        return;
-    }
-
-    if run {
-        for sug in suggestions {
-            let mut build: crate::Build = builder.build.clone();
-            build.config.paths = sug.2;
-            build.config.cmd = crate::core::config::flags::Flags::parse_from(["x.py", sug.0]).cmd;
-            if let Some(stage) = sug.1 {
-                build.config.stage = stage;
-            }
-            build.build();
-        }
-    } else {
-        println!("HELP: consider using the `--run` flag to automatically run suggested tests");
-    }
-}
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 757eac1475c..9e7ea5c115f 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -47,12 +47,11 @@ impl Step for CrateBootstrap {
     const DEFAULT: bool = true;
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        // This step is responsible for several different tool paths. By default
-        // it will test all of them, but requesting specific tools on the
-        // command-line (e.g. `./x test suggest-tests`) will test only the
-        // specified tools.
+        // This step is responsible for several different tool paths.
+        //
+        // By default, it will test all of them, but requesting specific tools on the command-line
+        // (e.g. `./x test src/tools/coverage-dump`) will test only the specified tools.
         run.path("src/tools/jsondoclint")
-            .path("src/tools/suggest-tests")
             .path("src/tools/replace-version-placeholder")
             .path("src/tools/coverage-dump")
             // We want `./x test tidy` to _run_ the tidy tool, not its tests.
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 814a44b9a13..1c994b0ccfc 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -517,7 +517,6 @@ bootstrap_tool!(
     ReplaceVersionPlaceholder, "src/tools/replace-version-placeholder", "replace-version-placeholder";
     CollectLicenseMetadata, "src/tools/collect-license-metadata", "collect-license-metadata";
     GenerateCopyright, "src/tools/generate-copyright", "generate-copyright";
-    SuggestTests, "src/tools/suggest-tests", "suggest-tests";
     GenerateWindowsSys, "src/tools/generate-windows-sys", "generate-windows-sys";
     // rustdoc-gui-test has a crate dependency on compiletest, so it needs the same unstable features.
     RustdocGUITest, "src/tools/rustdoc-gui-test", "rustdoc-gui-test", is_unstable_tool = true, allow_features = COMPILETEST_ALLOW_FEATURES;
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index d5a290d804c..a3b471ca56e 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -113,7 +113,7 @@ impl Cargo {
 
         match cmd_kind {
             // No need to configure the target linker for these command types.
-            Kind::Clean | Kind::Check | Kind::Suggest | Kind::Format | Kind::Setup => {}
+            Kind::Clean | Kind::Check | Kind::Format | Kind::Setup => {}
             _ => {
                 cargo.configure_linker(builder, mode);
             }
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 7115c5a1cbe..1b75d00b30e 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -845,7 +845,6 @@ pub enum Kind {
     #[value(alias = "r")]
     Run,
     Setup,
-    Suggest,
     Vendor,
     Perf,
 }
@@ -869,7 +868,6 @@ impl Kind {
             Kind::Install => "install",
             Kind::Run => "run",
             Kind::Setup => "setup",
-            Kind::Suggest => "suggest",
             Kind::Vendor => "vendor",
             Kind::Perf => "perf",
         }
@@ -881,7 +879,6 @@ impl Kind {
             Kind::Bench => "Benchmarking",
             Kind::Doc => "Documenting",
             Kind::Run => "Running",
-            Kind::Suggest => "Suggesting",
             Kind::Clippy => "Linting",
             Kind::Perf => "Profiling & benchmarking",
             _ => {
@@ -1201,7 +1198,7 @@ impl<'a> Builder<'a> {
             Kind::Clean => describe!(clean::CleanAll, clean::Rustc, clean::Std),
             Kind::Vendor => describe!(vendor::Vendor),
             // special-cased in Build::build()
-            Kind::Format | Kind::Suggest | Kind::Perf => vec![],
+            Kind::Format | Kind::Perf => vec![],
             Kind::MiriTest | Kind::MiriSetup => unreachable!(),
         }
     }
@@ -1269,7 +1266,6 @@ impl<'a> Builder<'a> {
             Subcommand::Run { .. } => (Kind::Run, &paths[..]),
             Subcommand::Clean { .. } => (Kind::Clean, &paths[..]),
             Subcommand::Format { .. } => (Kind::Format, &[][..]),
-            Subcommand::Suggest { .. } => (Kind::Suggest, &[][..]),
             Subcommand::Setup { profile: ref path } => (
                 Kind::Setup,
                 path.as_ref().map_or([].as_slice(), |path| std::slice::from_ref(path)),
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 0039d44785c..28958b60fc3 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -1050,7 +1050,6 @@ impl Config {
             | Subcommand::Run { .. }
             | Subcommand::Setup { .. }
             | Subcommand::Format { .. }
-            | Subcommand::Suggest { .. }
             | Subcommand::Vendor { .. } => flags_stage.unwrap_or(0),
         };
 
@@ -1098,7 +1097,6 @@ impl Config {
                 | Subcommand::Run { .. }
                 | Subcommand::Setup { .. }
                 | Subcommand::Format { .. }
-                | Subcommand::Suggest { .. }
                 | Subcommand::Vendor { .. }
                 | Subcommand::Perf { .. } => {}
             }
diff --git a/src/bootstrap/src/core/config/flags.rs b/src/bootstrap/src/core/config/flags.rs
index 155b6f58758..1547ca44494 100644
--- a/src/bootstrap/src/core/config/flags.rs
+++ b/src/bootstrap/src/core/config/flags.rs
@@ -481,13 +481,6 @@ Arguments:
         #[arg(value_name = "<PROFILE>|hook|editor|link")]
         profile: Option<PathBuf>,
     },
-    /// Suggest a subset of tests to run, based on modified files
-    #[command(long_about = "\n")]
-    Suggest {
-        /// run suggested tests
-        #[arg(long)]
-        run: bool,
-    },
     /// Vendor dependencies
     Vendor {
         /// Additional `Cargo.toml` to sync and vendor
@@ -518,7 +511,6 @@ impl Subcommand {
             Subcommand::Install => Kind::Install,
             Subcommand::Run { .. } => Kind::Run,
             Subcommand::Setup { .. } => Kind::Setup,
-            Subcommand::Suggest { .. } => Kind::Suggest,
             Subcommand::Vendor { .. } => Kind::Vendor,
             Subcommand::Perf { .. } => Kind::Perf,
         }
diff --git a/src/bootstrap/src/core/sanity.rs b/src/bootstrap/src/core/sanity.rs
index f2119e84cce..b39d464493e 100644
--- a/src/bootstrap/src/core/sanity.rs
+++ b/src/bootstrap/src/core/sanity.rs
@@ -216,7 +216,6 @@ than building it.
             build.config.cmd,
             Subcommand::Clean { .. }
                 | Subcommand::Check { .. }
-                | Subcommand::Suggest { .. }
                 | Subcommand::Format { .. }
                 | Subcommand::Setup { .. }
         );
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 66a164703b7..44be51815c7 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -651,11 +651,9 @@ impl Build {
         // Handle hard-coded subcommands.
         {
             #[cfg(feature = "tracing")]
-            let _hardcoded_span = span!(
-                tracing::Level::DEBUG,
-                "handling hardcoded subcommands (Format, Suggest, Perf)"
-            )
-            .entered();
+            let _hardcoded_span =
+                span!(tracing::Level::DEBUG, "handling hardcoded subcommands (Format, Perf)")
+                    .entered();
 
             match &self.config.cmd {
                 Subcommand::Format { check, all } => {
@@ -666,9 +664,6 @@ impl Build {
                         &self.config.paths,
                     );
                 }
-                Subcommand::Suggest { run } => {
-                    return core::build_steps::suggest::suggest(&builder::Builder::new(self), *run);
-                }
                 Subcommand::Perf(args) => {
                     return core::build_steps::perf::perf(&builder::Builder::new(self), args);
                 }
diff --git a/src/bootstrap/src/utils/cc_detect.rs b/src/bootstrap/src/utils/cc_detect.rs
index dcafeb80f90..778591189a3 100644
--- a/src/bootstrap/src/utils/cc_detect.rs
+++ b/src/bootstrap/src/utils/cc_detect.rs
@@ -67,7 +67,6 @@ pub fn fill_compilers(build: &mut Build) {
         // We don't need to check cross targets for these commands.
         crate::Subcommand::Clean { .. }
         | crate::Subcommand::Check { .. }
-        | crate::Subcommand::Suggest { .. }
         | crate::Subcommand::Format { .. }
         | crate::Subcommand::Setup { .. } => {
             build.hosts.iter().cloned().chain(iter::once(build.host_target)).collect()
diff --git a/src/bootstrap/src/utils/metrics.rs b/src/bootstrap/src/utils/metrics.rs
index 862c4449624..9b1ccc32cb6 100644
--- a/src/bootstrap/src/utils/metrics.rs
+++ b/src/bootstrap/src/utils/metrics.rs
@@ -43,7 +43,7 @@ pub(crate) struct BuildMetrics {
     state: RefCell<MetricsState>,
 }
 
-/// NOTE: this isn't really cloning anything, but `x suggest` doesn't need metrics so this is probably ok.
+// NOTE: this isn't really cloning anything, but necessary for `Build: Clone`.
 impl Clone for BuildMetrics {
     fn clone(&self) -> Self {
         Self::init()
diff --git a/src/tools/suggest-tests/Cargo.toml b/src/tools/suggest-tests/Cargo.toml
deleted file mode 100644
index d6f86078d7e..00000000000
--- a/src/tools/suggest-tests/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[package]
-name = "suggest-tests"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-glob = "0.3.0"
-build_helper = { version = "0.1.0", path = "../../build_helper" }
diff --git a/src/tools/suggest-tests/src/dynamic_suggestions.rs b/src/tools/suggest-tests/src/dynamic_suggestions.rs
deleted file mode 100644
index f09720f1c91..00000000000
--- a/src/tools/suggest-tests/src/dynamic_suggestions.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-use std::path::Path;
-
-use crate::Suggestion;
-
-type DynamicSuggestion = fn(&Path) -> Vec<Suggestion>;
-
-pub(crate) const DYNAMIC_SUGGESTIONS: &[DynamicSuggestion] = &[
-    |path: &Path| -> Vec<Suggestion> {
-        if path.starts_with("compiler/") || path.starts_with("library/") {
-            let path = path.components().take(2).collect::<Vec<_>>();
-
-            vec![Suggestion::with_single_path(
-                "test",
-                None,
-                &format!(
-                    "{}/{}",
-                    path[0].as_os_str().to_str().unwrap(),
-                    path[1].as_os_str().to_str().unwrap()
-                ),
-            )]
-        } else {
-            Vec::new()
-        }
-    },
-    |path: &Path| -> Vec<Suggestion> {
-        if path.starts_with("compiler/rustc_pattern_analysis") {
-            vec![Suggestion::new("test", None, &["tests/ui", "--test-args", "pattern"])]
-        } else {
-            Vec::new()
-        }
-    },
-];
diff --git a/src/tools/suggest-tests/src/lib.rs b/src/tools/suggest-tests/src/lib.rs
deleted file mode 100644
index cc1288c6b72..00000000000
--- a/src/tools/suggest-tests/src/lib.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-use std::fmt::{self, Display};
-use std::path::Path;
-
-use dynamic_suggestions::DYNAMIC_SUGGESTIONS;
-use glob::Pattern;
-use static_suggestions::static_suggestions;
-
-mod dynamic_suggestions;
-mod static_suggestions;
-
-#[cfg(test)]
-mod tests;
-
-macro_rules! sug {
-    ($cmd:expr) => {
-        Suggestion::new($cmd, None, &[])
-    };
-
-    ($cmd:expr, $paths:expr) => {
-        Suggestion::new($cmd, None, $paths.as_slice())
-    };
-
-    ($cmd:expr, $stage:expr, $paths:expr) => {
-        Suggestion::new($cmd, Some($stage), $paths.as_slice())
-    };
-}
-
-pub(crate) use sug;
-
-pub fn get_suggestions<T: AsRef<str>>(modified_files: &[T]) -> Vec<Suggestion> {
-    let mut suggestions = Vec::new();
-
-    // static suggestions
-    for (globs, sugs) in static_suggestions().iter() {
-        let globs = globs
-            .iter()
-            .map(|glob| Pattern::new(glob).expect("Found invalid glob pattern!"))
-            .collect::<Vec<_>>();
-        let matches_some_glob = |file: &str| globs.iter().any(|glob| glob.matches(file));
-
-        if modified_files.iter().map(AsRef::as_ref).any(matches_some_glob) {
-            suggestions.extend_from_slice(sugs);
-        }
-    }
-
-    // dynamic suggestions
-    for sug in DYNAMIC_SUGGESTIONS {
-        for file in modified_files {
-            let sugs = sug(Path::new(file.as_ref()));
-
-            suggestions.extend_from_slice(&sugs);
-        }
-    }
-
-    suggestions.sort();
-    suggestions.dedup();
-
-    suggestions
-}
-
-#[derive(Clone, PartialOrd, Ord, PartialEq, Eq, Debug)]
-pub struct Suggestion {
-    pub cmd: String,
-    pub stage: Option<u32>,
-    pub paths: Vec<String>,
-}
-
-impl Suggestion {
-    pub fn new(cmd: &str, stage: Option<u32>, paths: &[&str]) -> Self {
-        Self { cmd: cmd.to_owned(), stage, paths: paths.iter().map(|p| p.to_string()).collect() }
-    }
-
-    pub fn with_single_path(cmd: &str, stage: Option<u32>, path: &str) -> Self {
-        Self::new(cmd, stage, &[path])
-    }
-}
-
-impl Display for Suggestion {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        write!(f, "{} ", self.cmd)?;
-
-        for path in &self.paths {
-            write!(f, "{} ", path)?;
-        }
-
-        if let Some(stage) = self.stage {
-            write!(f, "{}", stage)?;
-        } else {
-            // write a sentinel value here (in place of a stage) to be consumed
-            // by the shim in bootstrap, it will be read and ignored.
-            write!(f, "N/A")?;
-        }
-
-        Ok(())
-    }
-}
diff --git a/src/tools/suggest-tests/src/main.rs b/src/tools/suggest-tests/src/main.rs
deleted file mode 100644
index d84f8e9fa1b..00000000000
--- a/src/tools/suggest-tests/src/main.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use std::process::ExitCode;
-
-use build_helper::git::{GitConfig, get_git_modified_files};
-use suggest_tests::get_suggestions;
-
-fn main() -> ExitCode {
-    let modified_files = get_git_modified_files(
-        &GitConfig {
-            nightly_branch: &env("SUGGEST_TESTS_NIGHTLY_BRANCH"),
-            git_merge_commit_email: &env("SUGGEST_TESTS_MERGE_COMMIT_EMAIL"),
-        },
-        None,
-        &Vec::new(),
-    );
-    let modified_files = match modified_files {
-        Ok(files) => files,
-        Err(err) => {
-            eprintln!("Could not get modified files from git: \"{err}\"");
-            return ExitCode::FAILURE;
-        }
-    };
-
-    let suggestions = get_suggestions(&modified_files);
-
-    for sug in &suggestions {
-        println!("{sug}");
-    }
-
-    ExitCode::SUCCESS
-}
-
-fn env(key: &str) -> String {
-    match std::env::var(key) {
-        Ok(var) => var,
-        Err(err) => {
-            eprintln!("suggest-tests: failed to read environment variable {key}: {err}");
-            std::process::exit(1);
-        }
-    }
-}
diff --git a/src/tools/suggest-tests/src/static_suggestions.rs b/src/tools/suggest-tests/src/static_suggestions.rs
deleted file mode 100644
index d363d583b54..00000000000
--- a/src/tools/suggest-tests/src/static_suggestions.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use std::sync::OnceLock;
-
-use crate::{Suggestion, sug};
-
-// FIXME: perhaps this could use `std::lazy` when it is stabilized
-macro_rules! static_suggestions {
-    ($( [ $( $glob:expr ),* $(,)? ] => [ $( $suggestion:expr ),* $(,)? ] ),* $(,)? ) => {
-        pub(crate) fn static_suggestions() -> &'static [(Vec<&'static str>, Vec<Suggestion>)]
-        {
-            static S: OnceLock<Vec<(Vec<&'static str>, Vec<Suggestion>)>> = OnceLock::new();
-            S.get_or_init(|| vec![ $( (vec![ $($glob),* ], vec![ $($suggestion),* ]) ),*])
-        }
-    }
-}
-
-static_suggestions! {
-    ["*.md"] => [
-        sug!("test", 0, ["linkchecker"]),
-    ],
-
-    ["compiler/*"] => [
-        sug!("check"),
-        sug!("test", 1, ["tests/ui", "tests/run-make"]),
-    ],
-
-    ["compiler/rustc_mir_transform/*"] => [
-        sug!("test", 1, ["mir-opt"]),
-    ],
-
-    [
-        "compiler/rustc_mir_transform/src/coverage/*",
-        "compiler/rustc_codegen_llvm/src/coverageinfo/*",
-    ] => [
-        sug!("test", 1, ["coverage"]),
-    ],
-
-    ["src/librustdoc/*"] => [
-        sug!("test", 1, ["rustdoc"]),
-    ],
-}
diff --git a/src/tools/suggest-tests/src/tests.rs b/src/tools/suggest-tests/src/tests.rs
deleted file mode 100644
index b4149136fa3..00000000000
--- a/src/tools/suggest-tests/src/tests.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-macro_rules! sugg_test {
-    ( $( $name:ident: $paths:expr => $suggestions:expr ),* ) => {
-        $(
-            #[test]
-            fn $name() {
-                let suggestions = crate::get_suggestions(&$paths).into_iter().map(|s| s.to_string()).collect::<Vec<_>>();
-                assert_eq!(suggestions, $suggestions);
-            }
-        )*
-    };
-}
-
-sugg_test! {
-    test_error_code_docs: ["compiler/rustc_error_codes/src/error_codes/E0000.md"] =>
-        ["check N/A", "test compiler/rustc_error_codes N/A", "test linkchecker 0", "test tests/ui tests/run-make 1"],
-
-    test_rustdoc: ["src/librustdoc/src/lib.rs"] => ["test rustdoc 1"],
-
-    test_rustdoc_and_libstd: ["src/librustdoc/src/lib.rs", "library/std/src/lib.rs"] =>
-        ["test library/std N/A", "test rustdoc 1"]
-}
-- 
cgit 1.4.1-3-g733a5


From 647c051feca0a8b2e7e63bd1009917ea963b8bc7 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Tue, 8 Jul 2025 17:53:58 +0800
Subject: Regenerate completions after removing `./x suggest`

---
 src/etc/completions/x.fish    |  37 --------
 src/etc/completions/x.ps1     |  44 ----------
 src/etc/completions/x.py.fish |  37 --------
 src/etc/completions/x.py.ps1  |  44 ----------
 src/etc/completions/x.py.sh   | 191 +-----------------------------------------
 src/etc/completions/x.py.zsh  |  51 -----------
 src/etc/completions/x.sh      | 191 +-----------------------------------------
 src/etc/completions/x.zsh     |  51 -----------
 8 files changed, 2 insertions(+), 644 deletions(-)

diff --git a/src/etc/completions/x.fish b/src/etc/completions/x.fish
index d3da1f353e2..28a228d5464 100644
--- a/src/etc/completions/x.fish
+++ b/src/etc/completions/x.fish
@@ -73,7 +73,6 @@ complete -c x -n "__fish_x_needs_command" -a "dist" -d 'Build distribution artif
 complete -c x -n "__fish_x_needs_command" -a "install" -d 'Install distribution artifacts'
 complete -c x -n "__fish_x_needs_command" -a "run" -d 'Run tools contained in this repository'
 complete -c x -n "__fish_x_needs_command" -a "setup" -d 'Set up the environment for development'
-complete -c x -n "__fish_x_needs_command" -a "suggest" -d 'Suggest a subset of tests to run, based on modified files'
 complete -c x -n "__fish_x_needs_command" -a "vendor" -d 'Vendor dependencies'
 complete -c x -n "__fish_x_needs_command" -a "perf" -d 'Perform profiling and benchmarking of the compiler using `rustc-perf`'
 complete -c x -n "__fish_x_using_subcommand build" -l config -d 'TOML configuration file for build' -r -F
@@ -599,42 +598,6 @@ complete -c x -n "__fish_x_using_subcommand setup" -l enable-bolt-settings -d 'E
 complete -c x -n "__fish_x_using_subcommand setup" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
 complete -c x -n "__fish_x_using_subcommand setup" -l skip-std-check-if-no-download-rustc -d 'Skip checking the standard library if `rust.download-rustc` isn\'t available. This is mostly for RA as building the stage1 compiler to check the library tree on each code change might be too much for some computers'
 complete -c x -n "__fish_x_using_subcommand setup" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x -n "__fish_x_using_subcommand suggest" -l config -d 'TOML configuration file for build' -r -F
-complete -c x -n "__fish_x_using_subcommand suggest" -l build-dir -d 'Build directory, overrides `build.build-dir` in `bootstrap.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x -n "__fish_x_using_subcommand suggest" -l build -d 'host target of the stage0 compiler' -r -f
-complete -c x -n "__fish_x_using_subcommand suggest" -l host -d 'host targets to build' -r -f
-complete -c x -n "__fish_x_using_subcommand suggest" -l target -d 'target targets to build' -r -f
-complete -c x -n "__fish_x_using_subcommand suggest" -l exclude -d 'build paths to exclude' -r -F
-complete -c x -n "__fish_x_using_subcommand suggest" -l skip -d 'build paths to skip' -r -F
-complete -c x -n "__fish_x_using_subcommand suggest" -l rustc-error-format -d 'rustc error format' -r -f
-complete -c x -n "__fish_x_using_subcommand suggest" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x -n "__fish_x_using_subcommand suggest" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x -n "__fish_x_using_subcommand suggest" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x -n "__fish_x_using_subcommand suggest" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x -n "__fish_x_using_subcommand suggest" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x -n "__fish_x_using_subcommand suggest" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x -n "__fish_x_using_subcommand suggest" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
-complete -c x -n "__fish_x_using_subcommand suggest" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
-complete -c x -n "__fish_x_using_subcommand suggest" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x -n "__fish_x_using_subcommand suggest" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x -n "__fish_x_using_subcommand suggest" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x -n "__fish_x_using_subcommand suggest" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x -n "__fish_x_using_subcommand suggest" -l set -d 'override options in bootstrap.toml' -r -f
-complete -c x -n "__fish_x_using_subcommand suggest" -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 suggest" -l run -d 'run suggested tests'
-complete -c x -n "__fish_x_using_subcommand suggest" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x -n "__fish_x_using_subcommand suggest" -s i -l incremental -d 'use incremental compilation'
-complete -c x -n "__fish_x_using_subcommand suggest" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x -n "__fish_x_using_subcommand suggest" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x -n "__fish_x_using_subcommand suggest" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x -n "__fish_x_using_subcommand suggest" -l json-output -d 'use message-format=json'
-complete -c x -n "__fish_x_using_subcommand suggest" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
-complete -c x -n "__fish_x_using_subcommand suggest" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x -n "__fish_x_using_subcommand suggest" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x -n "__fish_x_using_subcommand suggest" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x -n "__fish_x_using_subcommand suggest" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x -n "__fish_x_using_subcommand suggest" -l skip-std-check-if-no-download-rustc -d 'Skip checking the standard library if `rust.download-rustc` isn\'t available. This is mostly for RA as building the stage1 compiler to check the library tree on each code change might be too much for some computers'
-complete -c x -n "__fish_x_using_subcommand suggest" -s h -l help -d 'Print help (see more with \'--help\')'
 complete -c x -n "__fish_x_using_subcommand vendor" -l sync -d 'Additional `Cargo.toml` to sync and vendor' -r -F
 complete -c x -n "__fish_x_using_subcommand vendor" -l config -d 'TOML configuration file for build' -r -F
 complete -c x -n "__fish_x_using_subcommand vendor" -l build-dir -d 'Build directory, overrides `build.build-dir` in `bootstrap.toml`' -r -f -a "(__fish_complete_directories)"
diff --git a/src/etc/completions/x.ps1 b/src/etc/completions/x.ps1
index b5b59c58bba..0c9b3828273 100644
--- a/src/etc/completions/x.ps1
+++ b/src/etc/completions/x.ps1
@@ -74,7 +74,6 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('install', 'install', [CompletionResultType]::ParameterValue, 'Install distribution artifacts')
             [CompletionResult]::new('run', 'run', [CompletionResultType]::ParameterValue, 'Run tools contained in this repository')
             [CompletionResult]::new('setup', 'setup', [CompletionResultType]::ParameterValue, 'Set up the environment for development')
-            [CompletionResult]::new('suggest', 'suggest', [CompletionResultType]::ParameterValue, 'Suggest a subset of tests to run, based on modified files')
             [CompletionResult]::new('vendor', 'vendor', [CompletionResultType]::ParameterValue, 'Vendor dependencies')
             [CompletionResult]::new('perf', 'perf', [CompletionResultType]::ParameterValue, 'Perform profiling and benchmarking of the compiler using `rustc-perf`')
             break
@@ -700,49 +699,6 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
             [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
-        'x;suggest' {
-            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `bootstrap.toml`')
-            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'host target of the stage0 compiler')
-            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [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('--run', '--run', [CompletionResultType]::ParameterName, 'run suggested 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')
-            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
-            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('--skip-std-check-if-no-download-rustc', '--skip-std-check-if-no-download-rustc', [CompletionResultType]::ParameterName, 'Skip checking the standard library if `rust.download-rustc` isn''t available. This is mostly for RA as building the stage1 compiler to check the library tree on each code change might be too much for some computers')
-            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            break
-        }
         'x;vendor' {
             [CompletionResult]::new('--sync', '--sync', [CompletionResultType]::ParameterName, 'Additional `Cargo.toml` to sync and vendor')
             [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
diff --git a/src/etc/completions/x.py.fish b/src/etc/completions/x.py.fish
index da7680a879d..43ae7424e27 100644
--- a/src/etc/completions/x.py.fish
+++ b/src/etc/completions/x.py.fish
@@ -73,7 +73,6 @@ complete -c x.py -n "__fish_x.py_needs_command" -a "dist" -d 'Build distribution
 complete -c x.py -n "__fish_x.py_needs_command" -a "install" -d 'Install distribution artifacts'
 complete -c x.py -n "__fish_x.py_needs_command" -a "run" -d 'Run tools contained in this repository'
 complete -c x.py -n "__fish_x.py_needs_command" -a "setup" -d 'Set up the environment for development'
-complete -c x.py -n "__fish_x.py_needs_command" -a "suggest" -d 'Suggest a subset of tests to run, based on modified files'
 complete -c x.py -n "__fish_x.py_needs_command" -a "vendor" -d 'Vendor dependencies'
 complete -c x.py -n "__fish_x.py_needs_command" -a "perf" -d 'Perform profiling and benchmarking of the compiler using `rustc-perf`'
 complete -c x.py -n "__fish_x.py_using_subcommand build" -l config -d 'TOML configuration file for build' -r -F
@@ -599,42 +598,6 @@ complete -c x.py -n "__fish_x.py_using_subcommand setup" -l enable-bolt-settings
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -l skip-std-check-if-no-download-rustc -d 'Skip checking the standard library if `rust.download-rustc` isn\'t available. This is mostly for RA as building the stage1 compiler to check the library tree on each code change might be too much for some computers'
 complete -c x.py -n "__fish_x.py_using_subcommand setup" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l build-dir -d 'Build directory, overrides `build.build-dir` in `bootstrap.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l build -d 'host target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l rustc-error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l set -d 'override options in bootstrap.toml' -r -f
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -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 suggest" -l run -d 'run suggested tests'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l compile-time-deps -d 'only build proc-macros and build scripts (for rust-analyzer)'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l skip-std-check-if-no-download-rustc -d 'Skip checking the standard library if `rust.download-rustc` isn\'t available. This is mostly for RA as building the stage1 compiler to check the library tree on each code change might be too much for some computers'
-complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s h -l help -d 'Print help (see more with \'--help\')'
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l sync -d 'Additional `Cargo.toml` to sync and vendor' -r -F
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l config -d 'TOML configuration file for build' -r -F
 complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l build-dir -d 'Build directory, overrides `build.build-dir` in `bootstrap.toml`' -r -f -a "(__fish_complete_directories)"
diff --git a/src/etc/completions/x.py.ps1 b/src/etc/completions/x.py.ps1
index 3fc8e7d5bbd..4311e383d64 100644
--- a/src/etc/completions/x.py.ps1
+++ b/src/etc/completions/x.py.ps1
@@ -74,7 +74,6 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('install', 'install', [CompletionResultType]::ParameterValue, 'Install distribution artifacts')
             [CompletionResult]::new('run', 'run', [CompletionResultType]::ParameterValue, 'Run tools contained in this repository')
             [CompletionResult]::new('setup', 'setup', [CompletionResultType]::ParameterValue, 'Set up the environment for development')
-            [CompletionResult]::new('suggest', 'suggest', [CompletionResultType]::ParameterValue, 'Suggest a subset of tests to run, based on modified files')
             [CompletionResult]::new('vendor', 'vendor', [CompletionResultType]::ParameterValue, 'Vendor dependencies')
             [CompletionResult]::new('perf', 'perf', [CompletionResultType]::ParameterValue, 'Perform profiling and benchmarking of the compiler using `rustc-perf`')
             break
@@ -700,49 +699,6 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
-        'x.py;suggest' {
-            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `bootstrap.toml`')
-            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'host target of the stage0 compiler')
-            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [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('--run', '--run', [CompletionResultType]::ParameterName, 'run suggested 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')
-            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--compile-time-deps', '--compile-time-deps', [CompletionResultType]::ParameterName, 'only build proc-macros and build scripts (for rust-analyzer)')
-            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('--skip-std-check-if-no-download-rustc', '--skip-std-check-if-no-download-rustc', [CompletionResultType]::ParameterName, 'Skip checking the standard library if `rust.download-rustc` isn''t available. This is mostly for RA as building the stage1 compiler to check the library tree on each code change might be too much for some computers')
-            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            break
-        }
         'x.py;vendor' {
             [CompletionResult]::new('--sync', '--sync', [CompletionResultType]::ParameterName, 'Additional `Cargo.toml` to sync and vendor')
             [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
diff --git a/src/etc/completions/x.py.sh b/src/etc/completions/x.py.sh
index 8f13de282fb..f31bdb58dc4 100644
--- a/src/etc/completions/x.py.sh
+++ b/src/etc/completions/x.py.sh
@@ -54,9 +54,6 @@ _x.py() {
             x.py,setup)
                 cmd="x.py__setup"
                 ;;
-            x.py,suggest)
-                cmd="x.py__suggest"
-                ;;
             x.py,test)
                 cmd="x.py__test"
                 ;;
@@ -85,7 +82,7 @@ _x.py() {
 
     case "${cmd}" in
         x.py)
-            opts="-v -i -j -h --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]... build check clippy fix fmt doc test miri bench clean dist install run setup suggest vendor perf"
+            opts="-v -i -j -h --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]... build check clippy fix fmt doc test miri bench clean dist install run setup vendor perf"
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3877,192 +3874,6 @@ _x.py() {
             COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
             return 0
             ;;
-        x.py__suggest)
-            opts="-v -i -j -h --run --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
-            fi
-            case "${prev}" in
-                --config)
-                    local oldifs
-                    if [ -n "${IFS+x}" ]; then
-                        oldifs="$IFS"
-                    fi
-                    IFS=$'\n'
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    if [ -n "${oldifs+x}" ]; then
-                        IFS="$oldifs"
-                    fi
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o filenames
-                    fi
-                    return 0
-                    ;;
-                --build-dir)
-                    COMPREPLY=()
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o plusdirs
-                    fi
-                    return 0
-                    ;;
-                --build)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --host)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --target)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --exclude)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --skip)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --rustc-error-format)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --on-fail)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --stage)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --keep-stage)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --keep-stage-std)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --src)
-                    COMPREPLY=()
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o plusdirs
-                    fi
-                    return 0
-                    ;;
-                --jobs)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                -j)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --warnings)
-                    COMPREPLY=($(compgen -W "deny warn default" -- "${cur}"))
-                    return 0
-                    ;;
-                --color)
-                    COMPREPLY=($(compgen -W "always never auto" -- "${cur}"))
-                    return 0
-                    ;;
-                --rust-profile-generate)
-                    local oldifs
-                    if [ -n "${IFS+x}" ]; then
-                        oldifs="$IFS"
-                    fi
-                    IFS=$'\n'
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    if [ -n "${oldifs+x}" ]; then
-                        IFS="$oldifs"
-                    fi
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o filenames
-                    fi
-                    return 0
-                    ;;
-                --rust-profile-use)
-                    local oldifs
-                    if [ -n "${IFS+x}" ]; then
-                        oldifs="$IFS"
-                    fi
-                    IFS=$'\n'
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    if [ -n "${oldifs+x}" ]; then
-                        IFS="$oldifs"
-                    fi
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o filenames
-                    fi
-                    return 0
-                    ;;
-                --llvm-profile-use)
-                    local oldifs
-                    if [ -n "${IFS+x}" ]; then
-                        oldifs="$IFS"
-                    fi
-                    IFS=$'\n'
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    if [ -n "${oldifs+x}" ]; then
-                        IFS="$oldifs"
-                    fi
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o filenames
-                    fi
-                    return 0
-                    ;;
-                --reproducible-artifact)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --set)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --ci)
-                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
-                    return 0
-                    ;;
-                *)
-                    COMPREPLY=()
-                    ;;
-            esac
-            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
-            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 --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
diff --git a/src/etc/completions/x.py.zsh b/src/etc/completions/x.py.zsh
index 60ce9002116..aff35b31e21 100644
--- a/src/etc/completions/x.py.zsh
+++ b/src/etc/completions/x.py.zsh
@@ -715,51 +715,6 @@ _arguments "${_arguments_options[@]}" : \
 '*::paths -- paths for the subcommand:_files' \
 && ret=0
 ;;
-(suggest)
-_arguments "${_arguments_options[@]}" : \
-'--config=[TOML configuration file for build]:FILE:_files' \
-'--build-dir=[Build directory, overrides \`build.build-dir\` in \`bootstrap.toml\`]:DIR:_files -/' \
-'--build=[host target of the stage0 compiler]:BUILD:' \
-'--host=[host targets to build]:HOST:' \
-'--target=[target targets to build]:TARGET:' \
-'*--exclude=[build paths to exclude]:PATH:_files' \
-'*--skip=[build paths to skip]:PATH:_files' \
-'--rustc-error-format=[rustc error format]:RUSTC_ERROR_FORMAT:' \
-'--on-fail=[command to run on failure]:CMD:_cmdstring' \
-'--stage=[stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)]:N:' \
-'*--keep-stage=[stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)]:N:' \
-'*--keep-stage-std=[stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)]:N:' \
-'--src=[path to the root of the rust checkout]:DIR:_files -/' \
-'-j+[number of jobs to run in parallel]:JOBS:' \
-'--jobs=[number of jobs to run in parallel]:JOBS:' \
-'--warnings=[if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour]:deny|warn:(deny warn default)' \
-'--color=[whether to use color in cargo and rustc output]:STYLE:(always never auto)' \
-'--rust-profile-generate=[generate PGO profile with rustc build]:PROFILE:_files' \
-'--rust-profile-use=[use PGO profile for rustc build]:PROFILE:_files' \
-'--llvm-profile-use=[use PGO profile for LLVM build]:PROFILE:_files' \
-'*--reproducible-artifact=[Additional reproducible artifacts that should be added to the reproducible artifacts archive]:REPRODUCIBLE_ARTIFACT:_default' \
-'*--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)' \
-'--run[run suggested tests]' \
-'*-v[use verbose output (-vv for very verbose)]' \
-'*--verbose[use verbose output (-vv for very verbose)]' \
-'-i[use incremental compilation]' \
-'--incremental[use incremental compilation]' \
-'--include-default-paths[include default paths in addition to the provided ones]' \
-'--dry-run[dry run; don'\''t build anything]' \
-'--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
-'--json-output[use message-format=json]' \
-'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
-'--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
-'--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
-'--enable-bolt-settings[Enable BOLT link flags]' \
-'--skip-stage0-validation[Skip stage0 compiler validation]' \
-'--skip-std-check-if-no-download-rustc[Skip checking the standard library if \`rust.download-rustc\` isn'\''t available. This is mostly for RA as building the stage1 compiler to check the library tree on each code change might be too much for some computers]' \
-'-h[Print help (see more with '\''--help'\'')]' \
-'--help[Print help (see more with '\''--help'\'')]' \
-'*::paths -- paths for the subcommand:_files' \
-&& ret=0
-;;
 (vendor)
 _arguments "${_arguments_options[@]}" : \
 '*--sync=[Additional \`Cargo.toml\` to sync and vendor]:SYNC:_files' \
@@ -1120,7 +1075,6 @@ _x.py_commands() {
 'install:Install distribution artifacts' \
 'run:Run tools contained in this repository' \
 'setup:Set up the environment for development' \
-'suggest:Suggest a subset of tests to run, based on modified files' \
 'vendor:Vendor dependencies' \
 'perf:Perform profiling and benchmarking of the compiler using \`rustc-perf\`' \
     )
@@ -1227,11 +1181,6 @@ _x.py__setup_commands() {
     local commands; commands=()
     _describe -t commands 'x.py setup commands' commands "$@"
 }
-(( $+functions[_x.py__suggest_commands] )) ||
-_x.py__suggest_commands() {
-    local commands; commands=()
-    _describe -t commands 'x.py suggest commands' commands "$@"
-}
 (( $+functions[_x.py__test_commands] )) ||
 _x.py__test_commands() {
     local commands; commands=()
diff --git a/src/etc/completions/x.sh b/src/etc/completions/x.sh
index f6ecf4cebf4..927d8f7661c 100644
--- a/src/etc/completions/x.sh
+++ b/src/etc/completions/x.sh
@@ -54,9 +54,6 @@ _x() {
             x,setup)
                 cmd="x__setup"
                 ;;
-            x,suggest)
-                cmd="x__suggest"
-                ;;
             x,test)
                 cmd="x__test"
                 ;;
@@ -85,7 +82,7 @@ _x() {
 
     case "${cmd}" in
         x)
-            opts="-v -i -j -h --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]... build check clippy fix fmt doc test miri bench clean dist install run setup suggest vendor perf"
+            opts="-v -i -j -h --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]... build check clippy fix fmt doc test miri bench clean dist install run setup vendor perf"
             if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                 COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                 return 0
@@ -3877,192 +3874,6 @@ _x() {
             COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
             return 0
             ;;
-        x__suggest)
-            opts="-v -i -j -h --run --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
-            fi
-            case "${prev}" in
-                --config)
-                    local oldifs
-                    if [ -n "${IFS+x}" ]; then
-                        oldifs="$IFS"
-                    fi
-                    IFS=$'\n'
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    if [ -n "${oldifs+x}" ]; then
-                        IFS="$oldifs"
-                    fi
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o filenames
-                    fi
-                    return 0
-                    ;;
-                --build-dir)
-                    COMPREPLY=()
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o plusdirs
-                    fi
-                    return 0
-                    ;;
-                --build)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --host)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --target)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --exclude)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --skip)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --rustc-error-format)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --on-fail)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --stage)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --keep-stage)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --keep-stage-std)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --src)
-                    COMPREPLY=()
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o plusdirs
-                    fi
-                    return 0
-                    ;;
-                --jobs)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                -j)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --warnings)
-                    COMPREPLY=($(compgen -W "deny warn default" -- "${cur}"))
-                    return 0
-                    ;;
-                --color)
-                    COMPREPLY=($(compgen -W "always never auto" -- "${cur}"))
-                    return 0
-                    ;;
-                --rust-profile-generate)
-                    local oldifs
-                    if [ -n "${IFS+x}" ]; then
-                        oldifs="$IFS"
-                    fi
-                    IFS=$'\n'
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    if [ -n "${oldifs+x}" ]; then
-                        IFS="$oldifs"
-                    fi
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o filenames
-                    fi
-                    return 0
-                    ;;
-                --rust-profile-use)
-                    local oldifs
-                    if [ -n "${IFS+x}" ]; then
-                        oldifs="$IFS"
-                    fi
-                    IFS=$'\n'
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    if [ -n "${oldifs+x}" ]; then
-                        IFS="$oldifs"
-                    fi
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o filenames
-                    fi
-                    return 0
-                    ;;
-                --llvm-profile-use)
-                    local oldifs
-                    if [ -n "${IFS+x}" ]; then
-                        oldifs="$IFS"
-                    fi
-                    IFS=$'\n'
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    if [ -n "${oldifs+x}" ]; then
-                        IFS="$oldifs"
-                    fi
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o filenames
-                    fi
-                    return 0
-                    ;;
-                --reproducible-artifact)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --set)
-                    COMPREPLY=("${cur}")
-                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
-                        compopt -o nospace
-                    fi
-                    return 0
-                    ;;
-                --ci)
-                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
-                    return 0
-                    ;;
-                *)
-                    COMPREPLY=()
-                    ;;
-            esac
-            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
-            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 --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
diff --git a/src/etc/completions/x.zsh b/src/etc/completions/x.zsh
index 452a26fef07..28ad00f3a0d 100644
--- a/src/etc/completions/x.zsh
+++ b/src/etc/completions/x.zsh
@@ -715,51 +715,6 @@ _arguments "${_arguments_options[@]}" : \
 '*::paths -- paths for the subcommand:_files' \
 && ret=0
 ;;
-(suggest)
-_arguments "${_arguments_options[@]}" : \
-'--config=[TOML configuration file for build]:FILE:_files' \
-'--build-dir=[Build directory, overrides \`build.build-dir\` in \`bootstrap.toml\`]:DIR:_files -/' \
-'--build=[host target of the stage0 compiler]:BUILD:' \
-'--host=[host targets to build]:HOST:' \
-'--target=[target targets to build]:TARGET:' \
-'*--exclude=[build paths to exclude]:PATH:_files' \
-'*--skip=[build paths to skip]:PATH:_files' \
-'--rustc-error-format=[rustc error format]:RUSTC_ERROR_FORMAT:' \
-'--on-fail=[command to run on failure]:CMD:_cmdstring' \
-'--stage=[stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)]:N:' \
-'*--keep-stage=[stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)]:N:' \
-'*--keep-stage-std=[stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)]:N:' \
-'--src=[path to the root of the rust checkout]:DIR:_files -/' \
-'-j+[number of jobs to run in parallel]:JOBS:' \
-'--jobs=[number of jobs to run in parallel]:JOBS:' \
-'--warnings=[if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour]:deny|warn:(deny warn default)' \
-'--color=[whether to use color in cargo and rustc output]:STYLE:(always never auto)' \
-'--rust-profile-generate=[generate PGO profile with rustc build]:PROFILE:_files' \
-'--rust-profile-use=[use PGO profile for rustc build]:PROFILE:_files' \
-'--llvm-profile-use=[use PGO profile for LLVM build]:PROFILE:_files' \
-'*--reproducible-artifact=[Additional reproducible artifacts that should be added to the reproducible artifacts archive]:REPRODUCIBLE_ARTIFACT:_default' \
-'*--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)' \
-'--run[run suggested tests]' \
-'*-v[use verbose output (-vv for very verbose)]' \
-'*--verbose[use verbose output (-vv for very verbose)]' \
-'-i[use incremental compilation]' \
-'--incremental[use incremental compilation]' \
-'--include-default-paths[include default paths in addition to the provided ones]' \
-'--dry-run[dry run; don'\''t build anything]' \
-'--dump-bootstrap-shims[Indicates whether to dump the work done from bootstrap shims]' \
-'--json-output[use message-format=json]' \
-'--compile-time-deps[only build proc-macros and build scripts (for rust-analyzer)]' \
-'--bypass-bootstrap-lock[Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)]' \
-'--llvm-profile-generate[generate PGO profile with llvm built for rustc]' \
-'--enable-bolt-settings[Enable BOLT link flags]' \
-'--skip-stage0-validation[Skip stage0 compiler validation]' \
-'--skip-std-check-if-no-download-rustc[Skip checking the standard library if \`rust.download-rustc\` isn'\''t available. This is mostly for RA as building the stage1 compiler to check the library tree on each code change might be too much for some computers]' \
-'-h[Print help (see more with '\''--help'\'')]' \
-'--help[Print help (see more with '\''--help'\'')]' \
-'*::paths -- paths for the subcommand:_files' \
-&& ret=0
-;;
 (vendor)
 _arguments "${_arguments_options[@]}" : \
 '*--sync=[Additional \`Cargo.toml\` to sync and vendor]:SYNC:_files' \
@@ -1120,7 +1075,6 @@ _x_commands() {
 'install:Install distribution artifacts' \
 'run:Run tools contained in this repository' \
 'setup:Set up the environment for development' \
-'suggest:Suggest a subset of tests to run, based on modified files' \
 'vendor:Vendor dependencies' \
 'perf:Perform profiling and benchmarking of the compiler using \`rustc-perf\`' \
     )
@@ -1227,11 +1181,6 @@ _x__setup_commands() {
     local commands; commands=()
     _describe -t commands 'x setup commands' commands "$@"
 }
-(( $+functions[_x__suggest_commands] )) ||
-_x__suggest_commands() {
-    local commands; commands=()
-    _describe -t commands 'x suggest commands' commands "$@"
-}
 (( $+functions[_x__test_commands] )) ||
 _x__test_commands() {
     local commands; commands=()
-- 
cgit 1.4.1-3-g733a5


From 186afbb911b561d7f10efa9c5a729715f2db4131 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Tue, 8 Jul 2025 17:58:49 +0800
Subject: Remove mentions of `./x suggest` and `suggest-tests` in
 rustc-dev-guide

---
 src/doc/rustc-dev-guide/src/SUMMARY.md             |  1 -
 src/doc/rustc-dev-guide/src/building/quickstart.md |  3 --
 src/doc/rustc-dev-guide/src/building/suggested.md  | 17 -------
 src/doc/rustc-dev-guide/src/tests/suggest-tests.md | 59 ----------------------
 4 files changed, 80 deletions(-)
 delete mode 100644 src/doc/rustc-dev-guide/src/tests/suggest-tests.md

diff --git a/src/doc/rustc-dev-guide/src/SUMMARY.md b/src/doc/rustc-dev-guide/src/SUMMARY.md
index 7f2f32c62ff..651e2925ad5 100644
--- a/src/doc/rustc-dev-guide/src/SUMMARY.md
+++ b/src/doc/rustc-dev-guide/src/SUMMARY.md
@@ -35,7 +35,6 @@
         - [Cranelift codegen backend](./tests/codegen-backend-tests/cg_clif.md)
         - [GCC codegen backend](./tests/codegen-backend-tests/cg_gcc.md)
     - [Performance testing](./tests/perf.md)
-    - [Suggest tests tool](./tests/suggest-tests.md)
     - [Misc info](./tests/misc.md)
 - [Debugging the compiler](./compiler-debugging.md)
     - [Using the tracing/logging instrumentation](./tracing.md)
diff --git a/src/doc/rustc-dev-guide/src/building/quickstart.md b/src/doc/rustc-dev-guide/src/building/quickstart.md
index 9a8ab353e02..97314d80369 100644
--- a/src/doc/rustc-dev-guide/src/building/quickstart.md
+++ b/src/doc/rustc-dev-guide/src/building/quickstart.md
@@ -61,9 +61,6 @@ and check the output.
 Use `--bless` if you've made a change and want to update the `.stderr` files
 with the new output.
 
-> `./x suggest` can also be helpful for suggesting which tests to run after a
-> change.
-
 Congrats, you are now ready to make a change to the compiler! If you have more
 questions, [the full chapter](./how-to-build-and-run.md) might contain the
 answers, and if it doesn't, feel free to ask for help on
diff --git a/src/doc/rustc-dev-guide/src/building/suggested.md b/src/doc/rustc-dev-guide/src/building/suggested.md
index bfb2f4d1084..7f626314f71 100644
--- a/src/doc/rustc-dev-guide/src/building/suggested.md
+++ b/src/doc/rustc-dev-guide/src/building/suggested.md
@@ -270,23 +270,6 @@ run the tests at some later time. You can then use `git bisect` to track down
 is that you are left with a fairly fine-grained set of commits at the end, all
 of which build and pass tests. This often helps reviewing.
 
-## `x suggest`
-
-The `x suggest` subcommand suggests (and runs) a subset of the extensive
-`rust-lang/rust` tests based on files you have changed. This is especially
-useful for new contributors who have not mastered the arcane `x` flags yet and
-more experienced contributors as a shorthand for reducing mental effort. In all
-cases it is useful not to run the full tests (which can take on the order of
-tens of minutes) and just run a subset which are relevant to your changes. For
-example, running `tidy` and `linkchecker` is useful when editing Markdown files,
-whereas UI tests are much less likely to be helpful. While `x suggest` is a
-useful tool, it does not guarantee perfect coverage (just as PR CI isn't a
-substitute for bors). See the [dedicated chapter](../tests/suggest-tests.md) for
-more information and contribution instructions.
-
-Please note that `x suggest` is in a beta state currently and the tests that it
-will suggest are limited.
-
 ## Configuring `rustup` to use nightly
 
 Some parts of the bootstrap process uses pinned, nightly versions of tools like
diff --git a/src/doc/rustc-dev-guide/src/tests/suggest-tests.md b/src/doc/rustc-dev-guide/src/tests/suggest-tests.md
deleted file mode 100644
index 663e8a5af3b..00000000000
--- a/src/doc/rustc-dev-guide/src/tests/suggest-tests.md
+++ /dev/null
@@ -1,59 +0,0 @@
-# Suggest tests tool
-
-This chapter is about the internals of and contribution instructions for the
-`suggest-tests` tool. For a high-level overview of the tool, see [this
-section](../building/suggested.md#x-suggest). This tool is currently in a beta
-state and is tracked by [this](https://github.com/rust-lang/rust/issues/109933)
-issue on Github. Currently the number of tests it will suggest are very limited
-in scope, we are looking to expand this (contributions welcome!).
-
-## Internals
-
-The tool is defined in a separate crate
-([`src/tools/suggest-tests`](https://github.com/rust-lang/rust/blob/master/src/tools/suggest-tests))
-which outputs suggestions which are parsed by a shim in bootstrap
-([`src/bootstrap/src/core/build_steps/suggest.rs`](https://github.com/rust-lang/rust/blob/master/src/bootstrap/src/core/build_steps/suggest.rs)).
-The only notable thing the bootstrap shim does is (when invoked with the `--run`
-flag) use bootstrap's internal mechanisms to create a new `Builder` and uses it
-to invoke the suggested commands. The `suggest-tests` crate is where the fun
-happens, two kinds of suggestions are defined: "static" and "dynamic"
-suggestions.
-
-### Static suggestions
-
-Defined
-[here](https://github.com/rust-lang/rust/blob/master/src/tools/suggest-tests/src/static_suggestions.rs).
-Static suggestions are simple: they are just
-[globs](https://crates.io/crates/glob) which map to a `x` command. In
-`suggest-tests`, this is implemented with a simple `macro_rules` macro.
-
-### Dynamic suggestions
-
-Defined
-[here](https://github.com/rust-lang/rust/blob/master/src/tools/suggest-tests/src/dynamic_suggestions.rs).
-These are more complicated than static suggestions and are implemented as
-functions with the following signature: `fn(&Path) -> Vec<Suggestion>`. In other
-words, each suggestion takes a path to a modified file and (after running
-arbitrary Rust code) can return any number of suggestions, or none. Dynamic
-suggestions are useful for situations where fine-grained control over
-suggestions is needed. For example, modifications to the `compiler/xyz/` path
-should trigger the `x test compiler/xyz` suggestion. In the future, dynamic
-suggestions might even read file contents to determine if (what) tests should
-run.
-
-## Adding a suggestion
-
-The following steps should serve as a rough guide to add suggestions to
-`suggest-tests` (very welcome!):
-
-1. Determine the rules for your suggestion. Is it simple and operates only on a
-   single path or does it match globs? Does it need fine-grained control over
-   the resulting command or does "one size fit all"?
-2. Based on the previous step, decide if your suggestion should be implemented
-   as either static or dynamic.
-3. Implement the suggestion. If it is dynamic then a test is highly recommended,
-   to verify that your logic is correct and to give an example of the
-   suggestion. See the
-   [tests.rs](https://github.com/rust-lang/rust/blob/master/src/tools/suggest-tests/src/tests.rs)
-   file.
-4. Open a PR implementing your suggestion. **(TODO: add example PR)**
-- 
cgit 1.4.1-3-g733a5


From 0a899e0e8ad99d2e7afd1dd8e8466d6a14a04787 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Tue, 8 Jul 2025 17:59:54 +0800
Subject: Update triagebot autolabel

---
 triagebot.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/triagebot.toml b/triagebot.toml
index 125617fce74..714bb8d4b97 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -506,7 +506,6 @@ trigger_files = [
     "src/tools/remote-test-server",
     "src/tools/remote-test-client",
     "src/tools/rustdoc-gui-test",
-    "src/tools/suggest-tests",
 ]
 
 [autolabel."A-tidy"]
-- 
cgit 1.4.1-3-g733a5


From 1669ba055c1e02c459df42926f8762bc27b8ada8 Mon Sep 17 00:00:00 2001
From: rustbot <47979223+rustbot@users.noreply.github.com>
Date: Mon, 14 Jul 2025 19:01:40 +0200
Subject: Update books

---
 src/doc/book            | 2 +-
 src/doc/embedded-book   | 2 +-
 src/doc/nomicon         | 2 +-
 src/doc/reference       | 2 +-
 src/doc/rust-by-example | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/doc/book b/src/doc/book
index ef1ce8f87a8..b2d1a0821e1 160000
--- a/src/doc/book
+++ b/src/doc/book
@@ -1 +1 @@
-Subproject commit ef1ce8f87a8b18feb1b6a9cf9a4939a79bde6795
+Subproject commit b2d1a0821e12a676b496d61891b8e3d374a8e832
diff --git a/src/doc/embedded-book b/src/doc/embedded-book
index 41f688a598a..fe88fbb6839 160000
--- a/src/doc/embedded-book
+++ b/src/doc/embedded-book
@@ -1 +1 @@
-Subproject commit 41f688a598a5022b749e23d37f3c524f6a0b28e1
+Subproject commit fe88fbb68391a465680dd91109f0a151a1676f3e
diff --git a/src/doc/nomicon b/src/doc/nomicon
index 8b61acfaea8..3ff38432059 160000
--- a/src/doc/nomicon
+++ b/src/doc/nomicon
@@ -1 +1 @@
-Subproject commit 8b61acfaea822e9ac926190bc8f15791c33336e8
+Subproject commit 3ff384320598bbe8d8cfe5cb8f18f78a3a3e6b15
diff --git a/src/doc/reference b/src/doc/reference
index e9fc99f1078..1f45bd41fa6 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit e9fc99f107840813916f62e16b3f6d9556e1f2d8
+Subproject commit 1f45bd41fa6c17b7c048ed6bfe5f168c4311206a
diff --git a/src/doc/rust-by-example b/src/doc/rust-by-example
index 288b4e4948a..e386be5f44a 160000
--- a/src/doc/rust-by-example
+++ b/src/doc/rust-by-example
@@ -1 +1 @@
-Subproject commit 288b4e4948add43f387cad35adc7b1c54ca6fe12
+Subproject commit e386be5f44af711854207c11fdd61bb576270b04
-- 
cgit 1.4.1-3-g733a5


From 9bdd3b0ee6a6fd5914fea0f56f3b754410733e53 Mon Sep 17 00:00:00 2001
From: Paul Murphy <paumurph@redhat.com>
Date: Thu, 10 Jul 2025 10:58:58 -0500
Subject: Don't always panic if WASI_SDK_PATH is not set when detecting
 compilers

They are not always needed when building std, as is the case when
packaging on Fedora. Panic if building from CI, but warn otherwise.
---
 src/bootstrap/src/utils/cc_detect.rs | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/bootstrap/src/utils/cc_detect.rs b/src/bootstrap/src/utils/cc_detect.rs
index dcafeb80f90..2569f95e3ef 100644
--- a/src/bootstrap/src/utils/cc_detect.rs
+++ b/src/bootstrap/src/utils/cc_detect.rs
@@ -221,10 +221,15 @@ fn default_compiler(
         }
 
         t if t.contains("-wasi") => {
-            let root = build
-                .wasi_sdk_path
-                .as_ref()
-                .expect("WASI_SDK_PATH mut be configured for a -wasi target");
+            let root = if let Some(path) = build.wasi_sdk_path.as_ref() {
+                path
+            } else {
+                if build.config.is_running_on_ci {
+                    panic!("ERROR: WASI_SDK_PATH must be configured for a -wasi target on CI");
+                }
+                println!("WARNING: WASI_SDK_PATH not set, using default cc/cxx compiler");
+                return None;
+            };
             let compiler = match compiler {
                 Language::C => format!("{t}-clang"),
                 Language::CPlusPlus => format!("{t}-clang++"),
-- 
cgit 1.4.1-3-g733a5


From d0153f5872c484dff2a4b0ef6cad45c1f14fa1b7 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Mon, 14 Jul 2025 11:03:16 +0200
Subject: update `cfg_select!` documentation

and make internal terminology consistent

Co-authored-by: Travis Cross <tc@traviscross.com>
---
 compiler/rustc_builtin_macros/messages.ftl      |  6 +++---
 compiler/rustc_builtin_macros/src/cfg_select.rs | 16 ++++++++--------
 compiler/rustc_parse/src/parser/cfg_select.rs   | 10 ++++++----
 library/core/src/macros/mod.rs                  | 16 +++++++---------
 tests/ui/macros/cfg_select.rs                   |  7 +++++--
 tests/ui/macros/cfg_select.stderr               | 14 ++++++++++----
 6 files changed, 39 insertions(+), 30 deletions(-)

diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
index 183927edb02..ae186d744c4 100644
--- a/compiler/rustc_builtin_macros/messages.ftl
+++ b/compiler/rustc_builtin_macros/messages.ftl
@@ -81,11 +81,11 @@ builtin_macros_cfg_accessible_literal_path = `cfg_accessible` path cannot be a l
 builtin_macros_cfg_accessible_multiple_paths = multiple `cfg_accessible` paths are specified
 builtin_macros_cfg_accessible_unspecified_path = `cfg_accessible` path is not specified
 
-builtin_macros_cfg_select_no_matches = none of the rules in this `cfg_select` evaluated to true
+builtin_macros_cfg_select_no_matches = none of the predicates in this `cfg_select` evaluated to true
 
-builtin_macros_cfg_select_unreachable = unreachable rule
+builtin_macros_cfg_select_unreachable = unreachable predicate
     .label = always matches
-    .label2 = this rules is never reached
+    .label2 = this predicate is never reached
 
 builtin_macros_coerce_pointee_requires_maybe_sized = `derive(CoercePointee)` requires `{$name}` to be marked `?Sized`
 
diff --git a/compiler/rustc_builtin_macros/src/cfg_select.rs b/compiler/rustc_builtin_macros/src/cfg_select.rs
index 2dc387d5866..f22d5f255c2 100644
--- a/compiler/rustc_builtin_macros/src/cfg_select.rs
+++ b/compiler/rustc_builtin_macros/src/cfg_select.rs
@@ -1,12 +1,12 @@
 use rustc_ast::tokenstream::TokenStream;
 use rustc_attr_parsing as attr;
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
-use rustc_parse::parser::cfg_select::{CfgSelectBranches, CfgSelectRule, parse_cfg_select};
+use rustc_parse::parser::cfg_select::{CfgSelectBranches, CfgSelectPredicate, parse_cfg_select};
 use rustc_span::{Ident, Span, sym};
 
 use crate::errors::{CfgSelectNoMatches, CfgSelectUnreachable};
 
-/// Selects the first arm whose rule evaluates to true.
+/// Selects the first arm whose predicate evaluates to true.
 fn select_arm(ecx: &ExtCtxt<'_>, branches: CfgSelectBranches) -> Option<(TokenStream, Span)> {
     for (cfg, tt, arm_span) in branches.reachable {
         if attr::cfg_matches(
@@ -30,11 +30,11 @@ pub(super) fn expand_cfg_select<'cx>(
     ExpandResult::Ready(match parse_cfg_select(&mut ecx.new_parser_from_tts(tts)) {
         Ok(branches) => {
             if let Some((underscore, _, _)) = branches.wildcard {
-                // Warn for every unreachable rule. We store the fully parsed branch for rustfmt.
-                for (rule, _, _) in &branches.unreachable {
-                    let span = match rule {
-                        CfgSelectRule::Wildcard(underscore) => underscore.span,
-                        CfgSelectRule::Cfg(cfg) => cfg.span(),
+                // Warn for every unreachable predicate. We store the fully parsed branch for rustfmt.
+                for (predicate, _, _) in &branches.unreachable {
+                    let span = match predicate {
+                        CfgSelectPredicate::Wildcard(underscore) => underscore.span,
+                        CfgSelectPredicate::Cfg(cfg) => cfg.span(),
                     };
                     let err = CfgSelectUnreachable { span, wildcard_span: underscore.span };
                     ecx.dcx().emit_warn(err);
@@ -50,7 +50,7 @@ pub(super) fn expand_cfg_select<'cx>(
                     Ident::with_dummy_span(sym::cfg_select),
                 );
             } else {
-                // Emit a compiler error when none of the rules matched.
+                // Emit a compiler error when none of the predicates matched.
                 let guar = ecx.dcx().emit_err(CfgSelectNoMatches { span: sp });
                 DummyResult::any(sp, guar)
             }
diff --git a/compiler/rustc_parse/src/parser/cfg_select.rs b/compiler/rustc_parse/src/parser/cfg_select.rs
index 24a05afff4a..2c6fb224d70 100644
--- a/compiler/rustc_parse/src/parser/cfg_select.rs
+++ b/compiler/rustc_parse/src/parser/cfg_select.rs
@@ -7,7 +7,7 @@ use rustc_span::Span;
 use crate::exp;
 use crate::parser::Parser;
 
-pub enum CfgSelectRule {
+pub enum CfgSelectPredicate {
     Cfg(MetaItemInner),
     Wildcard(Token),
 }
@@ -20,7 +20,7 @@ pub struct CfgSelectBranches {
     pub wildcard: Option<(Token, TokenStream, Span)>,
     /// All branches after the first wildcard, including further wildcards.
     /// These branches are kept for formatting.
-    pub unreachable: Vec<(CfgSelectRule, TokenStream, Span)>,
+    pub unreachable: Vec<(CfgSelectPredicate, TokenStream, Span)>,
 }
 
 /// Parses a `TokenTree` that must be of the form `{ /* ... */ }`, and returns a `TokenStream` where
@@ -52,7 +52,7 @@ pub fn parse_cfg_select<'a>(p: &mut Parser<'a>) -> PResult<'a, CfgSelectBranches
             match branches.wildcard {
                 None => branches.wildcard = Some((underscore, tts, span)),
                 Some(_) => {
-                    branches.unreachable.push((CfgSelectRule::Wildcard(underscore), tts, span))
+                    branches.unreachable.push((CfgSelectPredicate::Wildcard(underscore), tts, span))
                 }
             }
         } else {
@@ -64,7 +64,9 @@ pub fn parse_cfg_select<'a>(p: &mut Parser<'a>) -> PResult<'a, CfgSelectBranches
 
             match branches.wildcard {
                 None => branches.reachable.push((meta_item, tts, span)),
-                Some(_) => branches.unreachable.push((CfgSelectRule::Cfg(meta_item), tts, span)),
+                Some(_) => {
+                    branches.unreachable.push((CfgSelectPredicate::Cfg(meta_item), tts, span))
+                }
             }
         }
     }
diff --git a/library/core/src/macros/mod.rs b/library/core/src/macros/mod.rs
index 6b9cbb06435..1b6dbc2f428 100644
--- a/library/core/src/macros/mod.rs
+++ b/library/core/src/macros/mod.rs
@@ -196,16 +196,14 @@ pub macro assert_matches {
     },
 }
 
-/// A macro for defining `#[cfg]` match-like statements.
+/// Selects code at compile-time based on `cfg` predicates.
 ///
-/// It is similar to the `if/elif` C preprocessor macro by allowing definition of a cascade of
-/// `#[cfg]` cases, emitting the implementation which matches first.
+/// This macro evaluates, at compile-time, a series of `cfg` predicates,
+/// selects the first that is true, and emits the code guarded by that
+/// predicate. The code guarded by other predicates is not emitted.
 ///
-/// This allows you to conveniently provide a long list `#[cfg]`'d blocks of code
-/// without having to rewrite each clause multiple times.
-///
-/// Trailing `_` wildcard match arms are **optional** and they indicate a fallback branch when
-/// all previous declarations do not evaluate to true.
+/// An optional trailing `_` wildcard can be used to specify a fallback. If
+/// none of the predicates are true, a [`compile_error`] is emitted.
 ///
 /// # Example
 ///
@@ -225,7 +223,7 @@ pub macro assert_matches {
 /// }
 /// ```
 ///
-/// If desired, it is possible to return expressions through the use of surrounding braces:
+/// The `cfg_select!` macro can also be used in expression position:
 ///
 /// ```
 /// #![feature(cfg_select)]
diff --git a/tests/ui/macros/cfg_select.rs b/tests/ui/macros/cfg_select.rs
index a4d94836a09..461d2e0e8c1 100644
--- a/tests/ui/macros/cfg_select.rs
+++ b/tests/ui/macros/cfg_select.rs
@@ -18,10 +18,13 @@ fn arm_rhs_must_be_in_braces() -> i32 {
 cfg_select! {
     _ => {}
     true => {}
-    //~^ WARN unreachable rule
+    //~^ WARN unreachable predicate
 }
 
 cfg_select! {
-    //~^ ERROR none of the rules in this `cfg_select` evaluated to true
+    //~^ ERROR none of the predicates in this `cfg_select` evaluated to true
     false => {}
 }
+
+cfg_select! {}
+//~^ ERROR none of the predicates in this `cfg_select` evaluated to true
diff --git a/tests/ui/macros/cfg_select.stderr b/tests/ui/macros/cfg_select.stderr
index fef5e95a6bc..6c18a7c189d 100644
--- a/tests/ui/macros/cfg_select.stderr
+++ b/tests/ui/macros/cfg_select.stderr
@@ -4,15 +4,15 @@ error: expected `{`, found `1`
 LL |         true => 1
    |                 ^ expected `{`
 
-warning: unreachable rule
+warning: unreachable predicate
   --> $DIR/cfg_select.rs:20:5
    |
 LL |     _ => {}
    |     - always matches
 LL |     true => {}
-   |     ^^^^ this rules is never reached
+   |     ^^^^ this predicate is never reached
 
-error: none of the rules in this `cfg_select` evaluated to true
+error: none of the predicates in this `cfg_select` evaluated to true
   --> $DIR/cfg_select.rs:24:1
    |
 LL | / cfg_select! {
@@ -21,5 +21,11 @@ LL | |     false => {}
 LL | | }
    | |_^
 
-error: aborting due to 2 previous errors; 1 warning emitted
+error: none of the predicates in this `cfg_select` evaluated to true
+  --> $DIR/cfg_select.rs:29:1
+   |
+LL | cfg_select! {}
+   | ^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors; 1 warning emitted
 
-- 
cgit 1.4.1-3-g733a5


From f0d0afab8e3c37286d261467df053a9a1635b91a Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Sun, 13 Jul 2025 11:56:13 +0200
Subject: Port `#[pointee]` to the new attribute parsing infrastructure

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>
---
 compiler/rustc_attr_data_structures/src/attributes.rs         | 3 +++
 compiler/rustc_attr_data_structures/src/encode_cross_crate.rs | 1 +
 compiler/rustc_attr_parsing/src/attributes/traits.rs          | 7 +++++++
 compiler/rustc_attr_parsing/src/context.rs                    | 5 +++--
 compiler/rustc_parse/src/validate_attr.rs                     | 1 +
 compiler/rustc_passes/src/check_attr.rs                       | 2 +-
 6 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 9b14ed88978..a5c04970e81 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -349,6 +349,9 @@ pub enum AttributeKind {
     /// Represents `#[path]`
     Path(Symbol, Span),
 
+    /// Represents `#[pointee]`
+    Pointee(Span),
+
     /// Represents `#[rustc_pub_transparent]` (used by the `repr_transparent_external_private_fields` lint).
     PubTransparent(Span),
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 494b570c86c..3e2dc0a15b2 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -57,6 +57,7 @@ impl AttributeKind {
             ParenSugar(..) => No,
             PassByValue(..) => Yes,
             Path(..) => No,
+            Pointee(..) => No,
             PubTransparent(..) => Yes,
             Repr { .. } => No,
             RustcLayoutScalarValidRangeEnd(..) => Yes,
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index ee8a33ae9c4..d5e088effd5 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -145,3 +145,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for FundamentalParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::Fundamental;
 }
+
+pub(crate) struct PointeeParser;
+impl<S: Stage> NoArgsAttributeParser<S> for PointeeParser {
+    const PATH: &[Symbol] = &[sym::pointee];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::Pointee;
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 6c70f2ee4ee..61638001a2b 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -48,8 +48,8 @@ use crate::attributes::test_attrs::IgnoreParser;
 use crate::attributes::traits::{
     AllowIncoherentImplParser, CoherenceIsCoreParser, CoinductiveParser, ConstTraitParser,
     DenyExplicitImplParser, DoNotImplementViaObjectParser, FundamentalParser, MarkerParser,
-    ParenSugarParser, SkipDuringMethodDispatchParser, SpecializationTraitParser, TypeConstParser,
-    UnsafeSpecializationMarkerParser,
+    ParenSugarParser, PointeeParser, SkipDuringMethodDispatchParser, SpecializationTraitParser,
+    TypeConstParser, UnsafeSpecializationMarkerParser,
 };
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
@@ -178,6 +178,7 @@ attribute_parsers!(
         Single<WithoutArgs<OmitGdbPrettyPrinterSectionParser>>,
         Single<WithoutArgs<ParenSugarParser>>,
         Single<WithoutArgs<PassByValueParser>>,
+        Single<WithoutArgs<PointeeParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
         Single<WithoutArgs<SpecializationTraitParser>>,
         Single<WithoutArgs<StdInternalSymbolParser>>,
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 5c748e956a0..b9d387e072c 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -299,6 +299,7 @@ pub fn check_builtin_meta_item(
                 | sym::align
                 | sym::deprecated
                 | sym::optimize
+                | sym::pointee
                 | sym::cold
                 | sym::target_feature
                 | sym::rustc_allow_const_fn_unstable
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 820255afe27..2009ddc1e2d 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -251,6 +251,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     AttributeKind::BodyStability { .. }
                     | AttributeKind::ConstStabilityIndirect
                     | AttributeKind::MacroTransparency(_)
+                    | AttributeKind::Pointee(..)
                     | AttributeKind::Dummy
                     | AttributeKind::OmitGdbPrettyPrinterSection,
                 ) => { /* do nothing  */ }
@@ -381,7 +382,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             | sym::cfg_attr_trace
                             // need to be fixed
                             | sym::cfi_encoding // FIXME(cfi_encoding)
-                            | sym::pointee // FIXME(derive_coerce_pointee)
                             | sym::instruction_set // broken on stable!!!
                             | sym::windows_subsystem // broken on stable!!!
                             | sym::patchable_function_entry // FIXME(patchable_function_entry)
-- 
cgit 1.4.1-3-g733a5


From 1d3ea1fd6e8c665145c559cdc94bb3e5736715a9 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Tue, 15 Jul 2025 01:15:33 +0300
Subject: Infer lifetimes for GATs in expression/pattern position

We should not only in type position.
---
 .../rust-analyzer/crates/hir-ty/src/lower/path.rs  |  8 ++++++--
 .../src/handlers/incorrect_generics_len.rs         | 24 ++++++++++++++++++++++
 2 files changed, 30 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 06686b6a164..5c06234fa07 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
@@ -1018,8 +1018,12 @@ fn check_generic_args_len(
     }
 
     let lifetime_args_len = def_generics.len_lifetimes_self();
-    if provided_lifetimes_count == 0 && lifetime_args_len > 0 && !lowering_assoc_type_generics {
-        // In generic associated types, we never allow inferring the lifetimes.
+    if provided_lifetimes_count == 0
+        && lifetime_args_len > 0
+        && (!lowering_assoc_type_generics || infer_args)
+    {
+        // In generic associated types, we never allow inferring the lifetimes, but only in type context, that is
+        // when `infer_args == false`. In expression/pattern context we always allow inferring them, even for GATs.
         match lifetime_elision {
             &LifetimeElisionKind::AnonymousCreateParameter { report_in_path } => {
                 ctx.report_elided_lifetimes_in_path(def, lifetime_args_len as u32, report_in_path);
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 06f35759420..7402133f747 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
@@ -183,4 +183,28 @@ fn main() {
 "#,
         );
     }
+
+    #[test]
+    fn generic_assoc_type_infer_lifetime_in_expr_position() {
+        check_diagnostics(
+            r#"
+//- minicore: sized
+struct Player;
+
+struct Foo<'c, C> {
+    _v: &'c C,
+}
+trait WithSignals: Sized {
+    type SignalCollection<'c, C>;
+    fn __signals_from_external(&self) -> Self::SignalCollection<'_, Self>;
+}
+impl WithSignals for Player {
+    type SignalCollection<'c, C> = Foo<'c, C>;
+    fn __signals_from_external(&self) -> Self::SignalCollection<'_, Self> {
+        Self::SignalCollection { _v: self }
+    }
+}
+        "#,
+        );
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 02dc14b25c729b8167620d2c2381ebbab20a0a04 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Mon, 14 Jul 2025 16:28:32 -0700
Subject: Update mdbook to 0.4.52

Changelog: https://github.com/rust-lang/mdBook/blob/master/CHANGELOG.md#mdbook-0452

This primarily picks up a few fixes.
---
 src/tools/rustbook/Cargo.lock | 4 ++--
 src/tools/rustbook/Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/tools/rustbook/Cargo.lock b/src/tools/rustbook/Cargo.lock
index 050ddf47bae..27798d6aeb0 100644
--- a/src/tools/rustbook/Cargo.lock
+++ b/src/tools/rustbook/Cargo.lock
@@ -885,9 +885,9 @@ dependencies = [
 
 [[package]]
 name = "mdbook"
-version = "0.4.51"
+version = "0.4.52"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a87e65420ab45ca9c1b8cdf698f95b710cc826d373fa550f0f7fad82beac9328"
+checksum = "93c284d2855916af7c5919cf9ad897cfc77d3c2db6f55429c7cfb769182030ec"
 dependencies = [
  "ammonia",
  "anyhow",
diff --git a/src/tools/rustbook/Cargo.toml b/src/tools/rustbook/Cargo.toml
index 69c0cfaf5c9..c7c6e39f157 100644
--- a/src/tools/rustbook/Cargo.toml
+++ b/src/tools/rustbook/Cargo.toml
@@ -15,6 +15,6 @@ mdbook-i18n-helpers = "0.3.3"
 mdbook-spec = { path = "../../doc/reference/mdbook-spec" }
 
 [dependencies.mdbook]
-version = "0.4.51"
+version = "0.4.52"
 default-features = false
 features = ["search"]
-- 
cgit 1.4.1-3-g733a5


From ed88af21637ff3677100fd26f8db354cd6134ad4 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Mon, 14 Jul 2025 04:28:20 +0800
Subject: Recover and suggest use `;` to construct array type

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 compiler/rustc_parse/src/parser/ty.rs              | 59 +++++++++++++++-
 src/tools/tidy/src/issues.txt                      |  1 -
 src/tools/tidy/src/ui_tests.rs                     |  2 +-
 tests/ui/issues/issue-50571.fixed                  | 10 ---
 tests/ui/issues/issue-50571.rs                     | 10 ---
 tests/ui/issues/issue-50571.stderr                 | 15 ----
 tests/ui/parser/better-expected.rs                 |  2 +-
 tests/ui/parser/better-expected.stderr             | 12 ++--
 .../ui/parser/issues/error-pattern-issue-50571.rs  | 11 +++
 .../parser/issues/error-pattern-issue-50571.stderr | 28 ++++++++
 tests/ui/parser/recover/array-type-no-semi.rs      | 11 ++-
 tests/ui/parser/recover/array-type-no-semi.stderr  | 79 +++++++++++++---------
 .../removed-syntax/removed-syntax-fixed-vec.rs     |  7 +-
 .../removed-syntax/removed-syntax-fixed-vec.stderr | 21 +++++-
 14 files changed, 182 insertions(+), 86 deletions(-)
 delete mode 100644 tests/ui/issues/issue-50571.fixed
 delete mode 100644 tests/ui/issues/issue-50571.rs
 delete mode 100644 tests/ui/issues/issue-50571.stderr
 create mode 100644 tests/ui/parser/issues/error-pattern-issue-50571.rs
 create mode 100644 tests/ui/parser/issues/error-pattern-issue-50571.stderr

diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index a997be3405d..740dd10ea8b 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -575,14 +575,69 @@ impl<'a> Parser<'a> {
                 self.expect(exp!(CloseBracket))?;
             }
             TyKind::Array(elt_ty, length)
-        } else {
-            self.expect(exp!(CloseBracket))?;
+        } else if self.eat(exp!(CloseBracket)) {
             TyKind::Slice(elt_ty)
+        } else {
+            self.maybe_recover_array_ty_without_semi(elt_ty)?
         };
 
         Ok(ty)
     }
 
+    /// Recover from malformed array type syntax.
+    ///
+    /// This method attempts to recover from cases like:
+    /// - `[u8, 5]` → suggests using `;`, return a Array type
+    /// - `[u8 5]` → suggests using `;`, return a Array type
+    /// Consider to add more cases in the future.
+    fn maybe_recover_array_ty_without_semi(&mut self, elt_ty: P<Ty>) -> PResult<'a, TyKind> {
+        let span = self.token.span;
+        let token_descr = super::token_descr(&self.token);
+        let mut err =
+            self.dcx().struct_span_err(span, format!("expected `;` or `]`, found {}", token_descr));
+        err.span_label(span, "expected `;` or `]`");
+        err.note("you might have meant to write a slice or array type");
+
+        // If we cannot recover, return the error immediately.
+        if !self.may_recover() {
+            return Err(err);
+        }
+
+        let snapshot = self.create_snapshot_for_diagnostic();
+
+        let suggestion_span = if self.eat(exp!(Comma)) || self.eat(exp!(Star)) {
+            // Consume common erroneous separators.
+            self.prev_token.span
+        } else {
+            self.token.span.shrink_to_lo()
+        };
+
+        // we first try to parse pattern like `[u8 5]`
+        let length = match self.parse_expr_anon_const() {
+            Ok(length) => length,
+            Err(e) => {
+                e.cancel();
+                self.restore_snapshot(snapshot);
+                return Err(err);
+            }
+        };
+
+        if let Err(e) = self.expect(exp!(CloseBracket)) {
+            e.cancel();
+            self.restore_snapshot(snapshot);
+            return Err(err);
+        }
+
+        err.span_suggestion_verbose(
+            suggestion_span,
+            "you might have meant to use `;` as the separator",
+            ";",
+            Applicability::MaybeIncorrect,
+        );
+        err.emit();
+        Ok(TyKind::Array(elt_ty, length))
+    }
+
     fn parse_borrowed_pointee(&mut self) -> PResult<'a, TyKind> {
         let and_span = self.prev_token.span;
         let mut opt_lifetime = self.check_lifetime().then(|| self.expect_lifetime());
diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index cac4dba2b49..8b57db23d01 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -2338,7 +2338,6 @@ ui/issues/issue-50415.rs
 ui/issues/issue-50442.rs
 ui/issues/issue-50471.rs
 ui/issues/issue-50518.rs
-ui/issues/issue-50571.rs
 ui/issues/issue-50581.rs
 ui/issues/issue-50582.rs
 ui/issues/issue-50585.rs
diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs
index 53226fcb80e..74f8104c7e9 100644
--- a/src/tools/tidy/src/ui_tests.rs
+++ b/src/tools/tidy/src/ui_tests.rs
@@ -17,7 +17,7 @@ use ignore::Walk;
 const ENTRY_LIMIT: u32 = 901;
 // FIXME: The following limits should be reduced eventually.
 
-const ISSUES_ENTRY_LIMIT: u32 = 1619;
+const ISSUES_ENTRY_LIMIT: u32 = 1616;
 
 const EXPECTED_TEST_FILE_EXTENSIONS: &[&str] = &[
     "rs",     // test source files
diff --git a/tests/ui/issues/issue-50571.fixed b/tests/ui/issues/issue-50571.fixed
deleted file mode 100644
index 6d73f17cca4..00000000000
--- a/tests/ui/issues/issue-50571.fixed
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ edition: 2015
-//@ run-rustfix
-
-#![allow(dead_code)]
-trait Foo {
-    fn foo(_: [i32; 2]) {}
-    //~^ ERROR: patterns aren't allowed in methods without bodies
-}
-
-fn main() {}
diff --git a/tests/ui/issues/issue-50571.rs b/tests/ui/issues/issue-50571.rs
deleted file mode 100644
index dd840ffe4d1..00000000000
--- a/tests/ui/issues/issue-50571.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ edition: 2015
-//@ run-rustfix
-
-#![allow(dead_code)]
-trait Foo {
-    fn foo([a, b]: [i32; 2]) {}
-    //~^ ERROR: patterns aren't allowed in methods without bodies
-}
-
-fn main() {}
diff --git a/tests/ui/issues/issue-50571.stderr b/tests/ui/issues/issue-50571.stderr
deleted file mode 100644
index 9b00fe0f5db..00000000000
--- a/tests/ui/issues/issue-50571.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0642]: patterns aren't allowed in methods without bodies
-  --> $DIR/issue-50571.rs:6:12
-   |
-LL |     fn foo([a, b]: [i32; 2]) {}
-   |            ^^^^^^
-   |
-help: give this argument a name or use an underscore to ignore it
-   |
-LL -     fn foo([a, b]: [i32; 2]) {}
-LL +     fn foo(_: [i32; 2]) {}
-   |
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0642`.
diff --git a/tests/ui/parser/better-expected.rs b/tests/ui/parser/better-expected.rs
index 16b61caa4df..91128c39691 100644
--- a/tests/ui/parser/better-expected.rs
+++ b/tests/ui/parser/better-expected.rs
@@ -1,3 +1,3 @@
 fn main() {
-    let x: [isize 3]; //~ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `3`
+    let x: [isize 3]; //~ ERROR expected `;` or `]`, found `3`
 }
diff --git a/tests/ui/parser/better-expected.stderr b/tests/ui/parser/better-expected.stderr
index f4ec933be16..4646ce7eff0 100644
--- a/tests/ui/parser/better-expected.stderr
+++ b/tests/ui/parser/better-expected.stderr
@@ -1,10 +1,14 @@
-error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `3`
+error: expected `;` or `]`, found `3`
   --> $DIR/better-expected.rs:2:19
    |
 LL |     let x: [isize 3];
-   |          -        ^ expected one of 7 possible tokens
-   |          |
-   |          while parsing the type for `x`
+   |                   ^ expected `;` or `]`
+   |
+   = note: you might have meant to write a slice or array type
+help: you might have meant to use `;` as the separator
+   |
+LL |     let x: [isize ;3];
+   |                   +
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/error-pattern-issue-50571.rs b/tests/ui/parser/issues/error-pattern-issue-50571.rs
new file mode 100644
index 00000000000..0c2ce6052cb
--- /dev/null
+++ b/tests/ui/parser/issues/error-pattern-issue-50571.rs
@@ -0,0 +1,11 @@
+// There is a regression introduced for issue #143828
+//@ edition: 2015
+
+#![allow(dead_code)]
+trait Foo {
+    fn foo([a, b]: [i32; 2]) {}
+    //~^ ERROR: expected `;` or `]`, found `,`
+    //~| ERROR: patterns aren't allowed in methods without bodies
+}
+
+fn main() {}
diff --git a/tests/ui/parser/issues/error-pattern-issue-50571.stderr b/tests/ui/parser/issues/error-pattern-issue-50571.stderr
new file mode 100644
index 00000000000..47457cff461
--- /dev/null
+++ b/tests/ui/parser/issues/error-pattern-issue-50571.stderr
@@ -0,0 +1,28 @@
+error: expected `;` or `]`, found `,`
+  --> $DIR/error-pattern-issue-50571.rs:6:14
+   |
+LL |     fn foo([a, b]: [i32; 2]) {}
+   |              ^ expected `;` or `]`
+   |
+   = note: you might have meant to write a slice or array type
+help: you might have meant to use `;` as the separator
+   |
+LL -     fn foo([a, b]: [i32; 2]) {}
+LL +     fn foo([a; b]: [i32; 2]) {}
+   |
+
+error[E0642]: patterns aren't allowed in methods without bodies
+  --> $DIR/error-pattern-issue-50571.rs:6:12
+   |
+LL |     fn foo([a, b]: [i32; 2]) {}
+   |            ^^^^^^
+   |
+help: give this argument a name or use an underscore to ignore it
+   |
+LL -     fn foo([a, b]: [i32; 2]) {}
+LL +     fn foo(_: [i32; 2]) {}
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0642`.
diff --git a/tests/ui/parser/recover/array-type-no-semi.rs b/tests/ui/parser/recover/array-type-no-semi.rs
index ae5efbaf36c..2cc5d979604 100644
--- a/tests/ui/parser/recover/array-type-no-semi.rs
+++ b/tests/ui/parser/recover/array-type-no-semi.rs
@@ -5,14 +5,13 @@
 fn main() {
     let x = 5;
     let b: [i32, 5];
-    //~^ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
-    //~| ERROR expected value, found builtin type `i32` [E0423]
+    //~^ ERROR expected `;` or `]`, found `,`
     let a: [i32, ];
-    //~^ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
+    //~^ ERROR expected `;` or `]`, found `,`
     //~| ERROR expected value, found builtin type `i32` [E0423]
     let c: [i32, x];
-    //~^ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
-    //~| ERROR expected value, found builtin type `i32` [E0423]
+    //~^ ERROR expected `;` or `]`, found `,`
+    //~| ERROR attempt to use a non-constant value in a constant [E0435]
     let e: [i32 5];
-    //~^ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `5`
+    //~^ ERROR expected `;` or `]`, found `5`
 }
diff --git a/tests/ui/parser/recover/array-type-no-semi.stderr b/tests/ui/parser/recover/array-type-no-semi.stderr
index 84b7282b4fe..82330465144 100644
--- a/tests/ui/parser/recover/array-type-no-semi.stderr
+++ b/tests/ui/parser/recover/array-type-no-semi.stderr
@@ -1,56 +1,71 @@
-error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
+error: expected `;` or `]`, found `,`
   --> $DIR/array-type-no-semi.rs:7:16
    |
 LL |     let b: [i32, 5];
-   |          -     ^ expected one of 7 possible tokens
-   |          |
-   |          while parsing the type for `b`
-   |          help: use `=` if you meant to assign
+   |                ^ expected `;` or `]`
+   |
+   = note: you might have meant to write a slice or array type
+help: you might have meant to use `;` as the separator
+   |
+LL -     let b: [i32, 5];
+LL +     let b: [i32; 5];
+   |
 
-error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
-  --> $DIR/array-type-no-semi.rs:10:16
+error: expected `;` or `]`, found `,`
+  --> $DIR/array-type-no-semi.rs:9:16
    |
 LL |     let a: [i32, ];
-   |          -     ^ expected one of 7 possible tokens
+   |          -     ^ expected `;` or `]`
    |          |
    |          while parsing the type for `a`
    |          help: use `=` if you meant to assign
+   |
+   = note: you might have meant to write a slice or array type
 
-error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `,`
-  --> $DIR/array-type-no-semi.rs:13:16
+error: expected `;` or `]`, found `,`
+  --> $DIR/array-type-no-semi.rs:12:16
    |
 LL |     let c: [i32, x];
-   |          -     ^ expected one of 7 possible tokens
-   |          |
-   |          while parsing the type for `c`
-   |          help: use `=` if you meant to assign
+   |                ^ expected `;` or `]`
+   |
+   = note: you might have meant to write a slice or array type
+help: you might have meant to use `;` as the separator
+   |
+LL -     let c: [i32, x];
+LL +     let c: [i32; x];
+   |
 
-error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `5`
-  --> $DIR/array-type-no-semi.rs:16:17
+error: expected `;` or `]`, found `5`
+  --> $DIR/array-type-no-semi.rs:15:17
    |
 LL |     let e: [i32 5];
-   |          -      ^ expected one of 7 possible tokens
-   |          |
-   |          while parsing the type for `e`
-
-error[E0423]: expected value, found builtin type `i32`
-  --> $DIR/array-type-no-semi.rs:7:13
+   |                 ^ expected `;` or `]`
    |
-LL |     let b: [i32, 5];
-   |             ^^^ not a value
+   = note: you might have meant to write a slice or array type
+help: you might have meant to use `;` as the separator
+   |
+LL |     let e: [i32 ;5];
+   |                 +
 
-error[E0423]: expected value, found builtin type `i32`
-  --> $DIR/array-type-no-semi.rs:10:13
+error[E0435]: attempt to use a non-constant value in a constant
+  --> $DIR/array-type-no-semi.rs:12:18
+   |
+LL |     let c: [i32, x];
+   |                  ^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL -     let x = 5;
+LL +     const x: /* Type */ = 5;
    |
-LL |     let a: [i32, ];
-   |             ^^^ not a value
 
 error[E0423]: expected value, found builtin type `i32`
-  --> $DIR/array-type-no-semi.rs:13:13
+  --> $DIR/array-type-no-semi.rs:9:13
    |
-LL |     let c: [i32, x];
+LL |     let a: [i32, ];
    |             ^^^ not a value
 
-error: aborting due to 7 previous errors
+error: aborting due to 6 previous errors
 
-For more information about this error, try `rustc --explain E0423`.
+Some errors have detailed explanations: E0423, E0435.
+For more information about an error, try `rustc --explain E0423`.
diff --git a/tests/ui/parser/removed-syntax/removed-syntax-fixed-vec.rs b/tests/ui/parser/removed-syntax/removed-syntax-fixed-vec.rs
index 560efecb91c..fb9a1c643fc 100644
--- a/tests/ui/parser/removed-syntax/removed-syntax-fixed-vec.rs
+++ b/tests/ui/parser/removed-syntax/removed-syntax-fixed-vec.rs
@@ -1 +1,6 @@
-type v = [isize * 3]; //~ ERROR expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `*`
+type v = [isize * 3];
+//~^ ERROR expected `;` or `]`, found `*`
+//~| WARN type `v` should have an upper camel case name [non_camel_case_types]
+
+
+fn main() {}
diff --git a/tests/ui/parser/removed-syntax/removed-syntax-fixed-vec.stderr b/tests/ui/parser/removed-syntax/removed-syntax-fixed-vec.stderr
index 5bc9c2ccf00..8d7938a1a46 100644
--- a/tests/ui/parser/removed-syntax/removed-syntax-fixed-vec.stderr
+++ b/tests/ui/parser/removed-syntax/removed-syntax-fixed-vec.stderr
@@ -1,8 +1,23 @@
-error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `]`, found `*`
+error: expected `;` or `]`, found `*`
   --> $DIR/removed-syntax-fixed-vec.rs:1:17
    |
 LL | type v = [isize * 3];
-   |                 ^ expected one of 7 possible tokens
+   |                 ^ expected `;` or `]`
+   |
+   = note: you might have meant to write a slice or array type
+help: you might have meant to use `;` as the separator
+   |
+LL - type v = [isize * 3];
+LL + type v = [isize ; 3];
+   |
+
+warning: type `v` should have an upper camel case name
+  --> $DIR/removed-syntax-fixed-vec.rs:1:6
+   |
+LL | type v = [isize * 3];
+   |      ^ help: convert the identifier to upper camel case (notice the capitalization): `V`
+   |
+   = note: `#[warn(non_camel_case_types)]` on by default
 
-error: aborting due to 1 previous error
+error: aborting due to 1 previous error; 1 warning emitted
 
-- 
cgit 1.4.1-3-g733a5


From 80224c3e888bf14ddca14700e79363b25eda93ce Mon Sep 17 00:00:00 2001
From: Karan Janthe <karanjanthe@gmail.com>
Date: Fri, 13 Jun 2025 05:09:09 +0000
Subject: test: Add UI tests for testing type analysis autodiff

Signed-off-by: Karan Janthe <karanjanthe@gmail.com>
---
 src/tools/enzyme                                   |  2 +-
 .../autodiff/type-trees/type-analysis/README.md    | 13 ++++++
 .../type-trees/type-analysis/array/array.check     | 26 +++++++++++
 .../type-trees/type-analysis/array/array.rs        | 20 ++++++++
 .../type-trees/type-analysis/array/rmake.rs        | 28 +++++++++++
 .../type-trees/type-analysis/array3d/array3d.check | 54 ++++++++++++++++++++++
 .../type-trees/type-analysis/array3d/array3d.rs    | 32 +++++++++++++
 .../type-trees/type-analysis/array3d/rmake.rs      | 28 +++++++++++
 .../type-trees/type-analysis/box/box.check         | 12 +++++
 .../autodiff/type-trees/type-analysis/box/box.rs   | 18 ++++++++
 .../autodiff/type-trees/type-analysis/box/rmake.rs | 28 +++++++++++
 .../const_pointer/const_pointer.check              | 10 ++++
 .../type-analysis/const_pointer/const_pointer.rs   | 18 ++++++++
 .../type-analysis/const_pointer/rmake.rs           | 31 +++++++++++++
 .../type-trees/type-analysis/f32/f32.check         | 12 +++++
 .../autodiff/type-trees/type-analysis/f32/f32.rs   | 19 ++++++++
 .../autodiff/type-trees/type-analysis/f32/rmake.rs | 28 +++++++++++
 .../type-trees/type-analysis/f64/f64.check         | 10 ++++
 .../autodiff/type-trees/type-analysis/f64/f64.rs   | 20 ++++++++
 .../autodiff/type-trees/type-analysis/f64/rmake.rs | 28 +++++++++++
 .../type-trees/type-analysis/i128/i128.check       | 10 ++++
 .../autodiff/type-trees/type-analysis/i128/i128.rs | 14 ++++++
 .../type-trees/type-analysis/i128/rmake.rs         | 28 +++++++++++
 .../type-trees/type-analysis/i16/i16.check         | 10 ++++
 .../autodiff/type-trees/type-analysis/i16/i16.rs   | 14 ++++++
 .../autodiff/type-trees/type-analysis/i16/rmake.rs | 28 +++++++++++
 .../type-trees/type-analysis/i32/i32.check         | 10 ++++
 .../autodiff/type-trees/type-analysis/i32/i32.rs   | 14 ++++++
 .../autodiff/type-trees/type-analysis/i32/rmake.rs | 28 +++++++++++
 .../autodiff/type-trees/type-analysis/i8/i8.check  | 10 ++++
 .../autodiff/type-trees/type-analysis/i8/i8.rs     | 14 ++++++
 .../autodiff/type-trees/type-analysis/i8/rmake.rs  | 28 +++++++++++
 .../type-trees/type-analysis/isize/isize.check     | 10 ++++
 .../type-trees/type-analysis/isize/isize.rs        | 14 ++++++
 .../type-trees/type-analysis/isize/rmake.rs        | 28 +++++++++++
 .../type-analysis/mut_pointer/mut_pointer.check    | 10 ++++
 .../type-analysis/mut_pointer/mut_pointer.rs       | 18 ++++++++
 .../type-trees/type-analysis/mut_pointer/rmake.rs  | 28 +++++++++++
 .../type-trees/type-analysis/mut_ref/mut_ref.check | 10 ++++
 .../type-trees/type-analysis/mut_ref/mut_ref.rs    | 18 ++++++++
 .../type-trees/type-analysis/mut_ref/rmake.rs      | 28 +++++++++++
 .../type-trees/type-analysis/ref/ref.check         | 10 ++++
 .../autodiff/type-trees/type-analysis/ref/ref.rs   | 18 ++++++++
 .../autodiff/type-trees/type-analysis/ref/rmake.rs | 28 +++++++++++
 .../type-trees/type-analysis/struct/rmake.rs       | 28 +++++++++++
 .../type-trees/type-analysis/struct/struct.check   | 10 ++++
 .../type-trees/type-analysis/struct/struct.rs      | 23 +++++++++
 .../type-trees/type-analysis/u128/rmake.rs         | 28 +++++++++++
 .../type-trees/type-analysis/u128/u128.check       | 10 ++++
 .../autodiff/type-trees/type-analysis/u128/u128.rs | 14 ++++++
 .../autodiff/type-trees/type-analysis/u16/rmake.rs | 28 +++++++++++
 .../type-trees/type-analysis/u16/u16.check         | 10 ++++
 .../autodiff/type-trees/type-analysis/u16/u16.rs   | 14 ++++++
 .../autodiff/type-trees/type-analysis/u32/rmake.rs | 28 +++++++++++
 .../type-trees/type-analysis/u32/u32.check         | 10 ++++
 .../autodiff/type-trees/type-analysis/u32/u32.rs   | 14 ++++++
 .../autodiff/type-trees/type-analysis/u8/rmake.rs  | 28 +++++++++++
 .../autodiff/type-trees/type-analysis/u8/u8.check  | 10 ++++
 .../autodiff/type-trees/type-analysis/u8/u8.rs     | 14 ++++++
 .../type-trees/type-analysis/union/rmake.rs        | 28 +++++++++++
 .../type-trees/type-analysis/union/union.check     | 10 ++++
 .../type-trees/type-analysis/union/union.rs        | 20 ++++++++
 .../type-trees/type-analysis/usize/rmake.rs        | 28 +++++++++++
 .../type-trees/type-analysis/usize/usize.check     | 10 ++++
 .../type-trees/type-analysis/usize/usize.rs        | 14 ++++++
 .../autodiff/type-trees/type-analysis/vec/rmake.rs | 28 +++++++++++
 .../type-trees/type-analysis/vec/vec.check         | 18 ++++++++
 .../autodiff/type-trees/type-analysis/vec/vec.rs   | 14 ++++++
 68 files changed, 1303 insertions(+), 1 deletion(-)
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/README.md
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/array/array.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/array/array.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/array/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/array3d/array3d.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/array3d/array3d.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/array3d/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/box/box.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/box/box.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/box/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/const_pointer/const_pointer.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/const_pointer/const_pointer.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/const_pointer/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/f32/f32.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/f32/f32.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/f32/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/f64/f64.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/f64/f64.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/f64/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i128/i128.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i128/i128.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i128/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i16/i16.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i16/i16.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i16/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i32/i32.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i32/i32.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i32/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i8/i8.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i8/i8.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/i8/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/isize/isize.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/isize/isize.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/isize/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/mut_pointer.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/mut_pointer.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/mut_ref/mut_ref.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/mut_ref/mut_ref.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/mut_ref/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/ref/ref.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/ref/ref.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/ref/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/struct/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/struct/struct.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/struct/struct.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u128/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u128/u128.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u128/u128.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u16/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u16/u16.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u16/u16.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u32/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u32/u32.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u32/u32.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u8/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u8/u8.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/u8/u8.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/union/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/union/union.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/union/union.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/usize/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/usize/usize.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/usize/usize.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/vec/rmake.rs
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/vec/vec.check
 create mode 100644 tests/run-make/autodiff/type-trees/type-analysis/vec/vec.rs

diff --git a/src/tools/enzyme b/src/tools/enzyme
index 0f65f31837a..b5098d515d5 160000
--- a/src/tools/enzyme
+++ b/src/tools/enzyme
@@ -1 +1 @@
-Subproject commit 0f65f31837a608db469ebde94adbc921be70bd8a
+Subproject commit b5098d515d5e1bd0f5470553bc0d18da9794ca8b
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/README.md b/tests/run-make/autodiff/type-trees/type-analysis/README.md
new file mode 100644
index 00000000000..c712edfaf50
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/README.md
@@ -0,0 +1,13 @@
+# Autodiff Type-Trees Type Analysis Tests
+
+This directory contains run-make tests for the autodiff type-trees type analysis functionality. These tests verify that the autodiff compiler correctly analyzes and tracks type information for different Rust types during automatic differentiation.
+
+## What These Tests Do
+
+Each test compiles a simple Rust function with the `#[autodiff_reverse]` attribute and verifies that the compiler:
+
+1. **Correctly identifies type information** in the generated LLVM IR
+2. **Tracks type annotations** for variables and operations
+3. **Preserves type context** through the autodiff transformation process
+
+The tests capture the stdout from the autodiff compiler (which contains type analysis information) and verify it matches expected patterns using FileCheck.
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/array/array.check b/tests/run-make/autodiff/type-trees/type-analysis/array/array.check
new file mode 100644
index 00000000000..6e4197692a7
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/array/array.check
@@ -0,0 +1,26 @@
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float, [-1,4]:Float@float, [-1,8]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw i8, ptr %{{[0-9]+}}, i64 4, !dbg !{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float, [-1,4]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fadd float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw i8, ptr %{{[0-9]+}}, i64 8, !dbg !{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fadd float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer, [-1,0]:Float@float, [-1,4]:Float@float, [-1,8]:Float@float}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float, [-1,4]:Float@float, [-1,8]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw i8, ptr %{{[0-9]+}}, i64 4, !dbg !{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float, [-1,4]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fadd float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw i8, ptr %{{[0-9]+}}, i64 8, !dbg !{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fadd float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/array/array.rs b/tests/run-make/autodiff/type-trees/type-analysis/array/array.rs
new file mode 100644
index 00000000000..9a859418b10
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/array/array.rs
@@ -0,0 +1,20 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &[f32; 3]) -> f32 {
+    x[0] * x[0] + x[1] * x[1] + x[2] * x[2]
+}
+
+fn main() {
+    let x = [1.0f32, 2.0, 3.0];
+    let mut df_dx = [0.0f32; 3];
+    let out = callee(&x);
+    let out_ = d_square(&x, &mut df_dx, 1.0);
+    assert_eq!(out, out_);
+    assert_eq!(2.0, df_dx[0]);
+    assert_eq!(4.0, df_dx[1]);
+    assert_eq!(6.0, df_dx[2]);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/array/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/array/rmake.rs
new file mode 100644
index 00000000000..d68ab46bb94
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/array/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("array.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("array.stdout", stdout);
+    rfs::write("array.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("array.check").stdin_buf(rfs::read("array.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/array3d/array3d.check b/tests/run-make/autodiff/type-trees/type-analysis/array3d/array3d.check
new file mode 100644
index 00000000000..ed81ad4869a
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/array3d/array3d.check
@@ -0,0 +1,54 @@
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: br label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ %{{[0-9]+}}, %{{[0-9]+}} ], !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ %{{[0-9]+}}, %{{[0-9]+}} ], !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ 0.000000e+00, %{{[0-9]+}} ], [ %{{[0-9]+}}, %{{[0-9]+}} ]: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = phi i1 [ true, %{{[0-9]+}} ], [ false, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = phi i64 [ 0, %{{[0-9]+}} ], [ 1, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw [2 x [2 x float]], ptr %{{[0-9]+}}, i64 %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: br label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ %{{[0-9]+}}, %{{[0-9]+}} ], !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ %{{[0-9]+}}, %{{[0-9]+}} ], [ %{{[0-9]+}}, %{{[0-9]+}} ]: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = phi i1 [ true, %{{[0-9]+}} ], [ false, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = phi i64 [ 0, %{{[0-9]+}} ], [ 1, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw [2 x float], ptr %{{[0-9]+}}, i64 %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: br label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ %{{[0-9]+}}, %{{[0-9]+}} ], [ %{{[0-9]+}}, %{{[0-9]+}} ]: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = phi i1 [ true, %{{[0-9]+}} ], [ false, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = phi i64 [ 0, %{{[0-9]+}} ], [ 1, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw float, ptr %{{[0-9]+}}, i64 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fadd float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer, [-1,0]:Float@float}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: br label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ %{{[0-9]+}}, %{{[0-9]+}} ], !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ %{{[0-9]+}}, %{{[0-9]+}} ], !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ 0.000000e+00, %{{[0-9]+}} ], [ %{{[0-9]+}}, %{{[0-9]+}} ]: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = phi i1 [ true, %{{[0-9]+}} ], [ false, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = phi i64 [ 0, %{{[0-9]+}} ], [ 1, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw [2 x [2 x float]], ptr %{{[0-9]+}}, i64 %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: br label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ %{{[0-9]+}}, %{{[0-9]+}} ], !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ %{{[0-9]+}}, %{{[0-9]+}} ], [ %{{[0-9]+}}, %{{[0-9]+}} ]: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = phi i1 [ true, %{{[0-9]+}} ], [ false, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = phi i64 [ 0, %{{[0-9]+}} ], [ 1, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw [2 x float], ptr %{{[0-9]+}}, i64 %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: br label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ %{{[0-9]+}}, %{{[0-9]+}} ], [ %{{[0-9]+}}, %{{[0-9]+}} ]: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = phi i1 [ true, %{{[0-9]+}} ], [ false, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = phi i64 [ 0, %{{[0-9]+}} ], [ 1, %{{[0-9]+}} ]: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw float, ptr %{{[0-9]+}}, i64 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fadd float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/array3d/array3d.rs b/tests/run-make/autodiff/type-trees/type-analysis/array3d/array3d.rs
new file mode 100644
index 00000000000..a95111a0dae
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/array3d/array3d.rs
@@ -0,0 +1,32 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &[[[f32; 2]; 2]; 2]) -> f32 {
+    let mut sum = 0.0;
+    for i in 0..2 {
+        for j in 0..2 {
+            for k in 0..2 {
+                sum += x[i][j][k] * x[i][j][k];
+            }
+        }
+    }
+    sum
+}
+
+fn main() {
+    let x = [[[1.0f32, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]];
+    let mut df_dx = [[[0.0f32; 2]; 2]; 2];
+    let out = callee(&x);
+    let out_ = d_square(&x, &mut df_dx, 1.0);
+    assert_eq!(out, out_);
+    for i in 0..2 {
+        for j in 0..2 {
+            for k in 0..2 {
+                assert_eq!(df_dx[i][j][k], 2.0 * x[i][j][k]);
+            }
+        }
+    }
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/array3d/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/array3d/rmake.rs
new file mode 100644
index 00000000000..8e75c21c9d6
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/array3d/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("array3d.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("array3d.stdout", stdout);
+    rfs::write("array3d.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("array3d.check").stdin_buf(rfs::read("array3d.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/box/box.check b/tests/run-make/autodiff/type-trees/type-analysis/box/box.check
new file mode 100644
index 00000000000..1911e18a137
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/box/box.check
@@ -0,0 +1,12 @@
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Pointer, [-1,0,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load ptr, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !nonnull !{{[0-9]+}}, !align !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer, [-1,0]:Pointer, [-1,0,0]:Float@float}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Pointer, [-1,0,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load ptr, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !nonnull !{{[0-9]+}}, !align !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/box/box.rs b/tests/run-make/autodiff/type-trees/type-analysis/box/box.rs
new file mode 100644
index 00000000000..658ccffc74e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/box/box.rs
@@ -0,0 +1,18 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &Box<f32>) -> f32 {
+    **x * **x
+}
+
+fn main() {
+    let x = Box::new(7.0f32);
+    let mut df_dx = Box::new(0.0f32);
+    let out = callee(&x);
+    let out_ = d_square(&x, &mut df_dx, 1.0);
+    assert_eq!(out, out_);
+    assert_eq!(14.0, *df_dx);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/box/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/box/rmake.rs
new file mode 100644
index 00000000000..1e8c8f9ccbd
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/box/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("box.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("box.stdout", stdout);
+    rfs::write("box.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("box.check").stdin_buf(rfs::read("box.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/const_pointer/const_pointer.check b/tests/run-make/autodiff/type-trees/type-analysis/const_pointer/const_pointer.check
new file mode 100644
index 00000000000..e7503453f8e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/const_pointer/const_pointer.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer, [-1,0]:Float@float}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/const_pointer/const_pointer.rs b/tests/run-make/autodiff/type-trees/type-analysis/const_pointer/const_pointer.rs
new file mode 100644
index 00000000000..8c877bfec05
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/const_pointer/const_pointer.rs
@@ -0,0 +1,18 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: *const f32) -> f32 {
+    unsafe { *x * *x }
+}
+
+fn main() {
+    let x: f32 = 7.0;
+    let out = callee(&x as *const f32);
+    let mut df_dx: f32 = 0.0;
+    let out_ = d_square(&x as *const f32, &mut df_dx, 1.0);
+    assert_eq!(out, out_);
+    assert_eq!(14.0, df_dx);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/const_pointer/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/const_pointer/rmake.rs
new file mode 100644
index 00000000000..ce38c6bd2ae
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/const_pointer/rmake.rs
@@ -0,0 +1,31 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("const_pointer.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("const_pointer.stdout", stdout);
+    rfs::write("const_pointer.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck()
+        .patterns("const_pointer.check")
+        .stdin_buf(rfs::read("const_pointer.stdout"))
+        .run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/f32/f32.check b/tests/run-make/autodiff/type-trees/type-analysis/f32/f32.check
new file mode 100644
index 00000000000..0cc0ffda43d
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/f32/f32.check
@@ -0,0 +1,12 @@
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer, [-1,0]:Float@float}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {} 
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/f32/f32.rs b/tests/run-make/autodiff/type-trees/type-analysis/f32/f32.rs
new file mode 100644
index 00000000000..b945821934a
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/f32/f32.rs
@@ -0,0 +1,19 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &f32) -> f32 {
+    *x * *x
+}
+
+fn main() {
+    let x: f32 = 7.0;
+    let mut df_dx: f32 = 0.0;
+    let out = callee(&x);
+    let out_ = d_square(&x, &mut df_dx, 1.0);
+
+    assert_eq!(out, out_);
+    assert_eq!(14.0, df_dx);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/f32/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/f32/rmake.rs
new file mode 100644
index 00000000000..d7e49219da6
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/f32/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("f32.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("f32.stdout", stdout);
+    rfs::write("f32.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("f32.check").stdin_buf(rfs::read("f32.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/f64/f64.check b/tests/run-make/autodiff/type-trees/type-analysis/f64/f64.check
new file mode 100644
index 00000000000..efc49da5ffc
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/f64/f64.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Float@double} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@double}
+// CHECK-DAG: %{{[0-9]+}} = load double, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@double}
+// CHECK-DAG: %{{[0-9]+}} = fmul double %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@double}
+// CHECK-DAG: ret double %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Float@double} |{[-1]:Pointer, [-1,0]:Float@double}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@double}
+// CHECK-DAG: %{{[0-9]+}} = load double, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@double}
+// CHECK-DAG: %{{[0-9]+}} = fmul double %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@double}
+// CHECK-DAG: ret double %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/f64/f64.rs b/tests/run-make/autodiff/type-trees/type-analysis/f64/f64.rs
new file mode 100644
index 00000000000..9b47569652e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/f64/f64.rs
@@ -0,0 +1,20 @@
+#![feature(autodiff)]
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_callee, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &f64) -> f64 {
+    x * x
+}
+
+fn main() {
+    let x = std::hint::black_box(3.0);
+
+    let output = callee(&x);
+    assert_eq!(9.0, output);
+
+    let mut df_dx = 0.0;
+    let output_ = d_callee(&x, &mut df_dx, 1.0);
+    assert_eq!(output, output_);
+    assert_eq!(6.0, df_dx);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/f64/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/f64/rmake.rs
new file mode 100644
index 00000000000..8bf92b8c1bd
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/f64/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("f64.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("f64.stdout", stdout);
+    rfs::write("f64.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("f64.check").stdin_buf(rfs::read("f64.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i128/i128.check b/tests/run-make/autodiff/type-trees/type-analysis/i128/i128.check
new file mode 100644
index 00000000000..31a07219e74
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i128/i128.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer, [-1,8]:Integer, [-1,9]:Integer, [-1,10]:Integer, [-1,11]:Integer, [-1,12]:Integer, [-1,13]:Integer, [-1,14]:Integer, [-1,15]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i128, ptr %{{[0-9]+}}, align 16, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i128 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i128 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer, [-1,8]:Integer, [-1,9]:Integer, [-1,10]:Integer, [-1,11]:Integer, [-1,12]:Integer, [-1,13]:Integer, [-1,14]:Integer, [-1,15]:Integer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer, [-1,8]:Integer, [-1,9]:Integer, [-1,10]:Integer, [-1,11]:Integer, [-1,12]:Integer, [-1,13]:Integer, [-1,14]:Integer, [-1,15]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i128, ptr %{{[0-9]+}}, align 16, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i128 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i128 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i128/i128.rs b/tests/run-make/autodiff/type-trees/type-analysis/i128/i128.rs
new file mode 100644
index 00000000000..19dfbbb22db
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i128/i128.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &i128) -> i128 {
+    *x * *x
+}
+
+fn main() {
+    let x: i128 = 7;
+    let _ = callee(&x);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i128/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/i128/rmake.rs
new file mode 100644
index 00000000000..21e8698634f
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i128/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("i128.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("i128.stdout", stdout);
+    rfs::write("i128.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("i128.check").stdin_buf(rfs::read("i128.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i16/i16.check b/tests/run-make/autodiff/type-trees/type-analysis/i16/i16.check
new file mode 100644
index 00000000000..8cc299532c5
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i16/i16.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i16, ptr %{{[0-9]+}}, align 2, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i16 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i16 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i16, ptr %{{[0-9]+}}, align 2, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i16 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i16 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i16/i16.rs b/tests/run-make/autodiff/type-trees/type-analysis/i16/i16.rs
new file mode 100644
index 00000000000..82099198a2e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i16/i16.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &i16) -> i16 {
+    *x * *x
+}
+
+fn main() {
+    let x: i16 = 7;
+    let _ = callee(&x);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i16/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/i16/rmake.rs
new file mode 100644
index 00000000000..a2875a8c573
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i16/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("i16.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("i16.stdout", stdout);
+    rfs::write("i16.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("i16.check").stdin_buf(rfs::read("i16.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i32/i32.check b/tests/run-make/autodiff/type-trees/type-analysis/i32/i32.check
new file mode 100644
index 00000000000..4df982887d7
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i32/i32.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i32, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i32 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i32 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i32, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i32 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i32 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i32/i32.rs b/tests/run-make/autodiff/type-trees/type-analysis/i32/i32.rs
new file mode 100644
index 00000000000..e95068d5c49
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i32/i32.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &i32) -> i32 {
+    *x * *x
+}
+
+fn main() {
+    let x: i32 = 7;
+    let _ = callee(&x);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i32/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/i32/rmake.rs
new file mode 100644
index 00000000000..857017feeab
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i32/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("i32.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("i32.stdout", stdout);
+    rfs::write("i32.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("i32.check").stdin_buf(rfs::read("i32.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i8/i8.check b/tests/run-make/autodiff/type-trees/type-analysis/i8/i8.check
new file mode 100644
index 00000000000..651a2085bc6
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i8/i8.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i8, ptr %{{[0-9]+}}, align 1, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i8 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i8 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer, [-1,0]:Integer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i8, ptr %{{[0-9]+}}, align 1, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i8 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i8 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i8/i8.rs b/tests/run-make/autodiff/type-trees/type-analysis/i8/i8.rs
new file mode 100644
index 00000000000..afc0cad703c
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i8/i8.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &i8) -> i8 {
+    *x * *x
+}
+
+fn main() {
+    let x: i8 = 7;
+    let _ = callee(&x);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/i8/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/i8/rmake.rs
new file mode 100644
index 00000000000..6551e2d6c4e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/i8/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("i8.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("i8.stdout", stdout);
+    rfs::write("i8.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("i8.check").stdin_buf(rfs::read("i8.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/isize/isize.check b/tests/run-make/autodiff/type-trees/type-analysis/isize/isize.check
new file mode 100644
index 00000000000..40ee6edc02c
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/isize/isize.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i64, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i64 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i64, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i64 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/isize/isize.rs b/tests/run-make/autodiff/type-trees/type-analysis/isize/isize.rs
new file mode 100644
index 00000000000..dd160984a4e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/isize/isize.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &isize) -> isize {
+    *x * *x
+}
+
+fn main() {
+    let x: isize = 7;
+    let _ = callee(&x);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/isize/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/isize/rmake.rs
new file mode 100644
index 00000000000..09277f63ed4
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/isize/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("isize.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("isize.stdout", stdout);
+    rfs::write("isize.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("isize.check").stdin_buf(rfs::read("isize.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/mut_pointer.check b/tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/mut_pointer.check
new file mode 100644
index 00000000000..e7503453f8e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/mut_pointer.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer, [-1,0]:Float@float}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/mut_pointer.rs b/tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/mut_pointer.rs
new file mode 100644
index 00000000000..2b672f6d3f8
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/mut_pointer.rs
@@ -0,0 +1,18 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: *mut f32) -> f32 {
+    unsafe { *x * *x }
+}
+
+fn main() {
+    let mut x: f32 = 7.0;
+    let out = callee(&mut x as *mut f32);
+    let mut df_dx: f32 = 0.0;
+    let out_ = d_square(&mut x as *mut f32, &mut df_dx, 1.0);
+    assert_eq!(out, out_);
+    assert_eq!(14.0, df_dx);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/rmake.rs
new file mode 100644
index 00000000000..4d5a5042141
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/mut_pointer/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("mut_pointer.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("mut_pointer.stdout", stdout);
+    rfs::write("mut_pointer.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("mut_pointer.check").stdin_buf(rfs::read("mut_pointer.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/mut_ref/mut_ref.check b/tests/run-make/autodiff/type-trees/type-analysis/mut_ref/mut_ref.check
new file mode 100644
index 00000000000..e7503453f8e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/mut_ref/mut_ref.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer, [-1,0]:Float@float}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/mut_ref/mut_ref.rs b/tests/run-make/autodiff/type-trees/type-analysis/mut_ref/mut_ref.rs
new file mode 100644
index 00000000000..7019e3f71ed
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/mut_ref/mut_ref.rs
@@ -0,0 +1,18 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &mut f32) -> f32 {
+    *x * *x
+}
+
+fn main() {
+    let mut x: f32 = 7.0;
+    let mut df_dx: f32 = 0.0;
+    let out = callee(&mut x);
+    let out_ = d_square(&mut x, &mut df_dx, 1.0);
+    assert_eq!(out, out_);
+    assert_eq!(14.0, df_dx);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/mut_ref/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/mut_ref/rmake.rs
new file mode 100644
index 00000000000..13668c54e78
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/mut_ref/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("mut_ref.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("mut_ref.stdout", stdout);
+    rfs::write("mut_ref.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("mut_ref.check").stdin_buf(rfs::read("mut_ref.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/ref/ref.check b/tests/run-make/autodiff/type-trees/type-analysis/ref/ref.check
new file mode 100644
index 00000000000..e7503453f8e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/ref/ref.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer, [-1,0]:Float@float}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/ref/ref.rs b/tests/run-make/autodiff/type-trees/type-analysis/ref/ref.rs
new file mode 100644
index 00000000000..3ced164b86f
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/ref/ref.rs
@@ -0,0 +1,18 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &f32) -> f32 {
+    *x * *x
+}
+
+fn main() {
+    let x: f32 = 7.0;
+    let mut df_dx: f32 = 0.0;
+    let out = callee(&x);
+    let out_ = d_square(&x, &mut df_dx, 1.0);
+    assert_eq!(out, out_);
+    assert_eq!(14.0, df_dx);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/ref/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/ref/rmake.rs
new file mode 100644
index 00000000000..b68e4e5b8ac
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/ref/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("ref.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("ref.stdout", stdout);
+    rfs::write("ref.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("ref.check").stdin_buf(rfs::read("ref.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/struct/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/struct/rmake.rs
new file mode 100644
index 00000000000..4073f7554cc
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/struct/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("struct.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("struct.stdout", stdout);
+    rfs::write("struct.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("struct.check").stdin_buf(rfs::read("struct.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/struct/struct.check b/tests/run-make/autodiff/type-trees/type-analysis/struct/struct.check
new file mode 100644
index 00000000000..e7503453f8e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/struct/struct.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer, [-1,0]:Float@float}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/struct/struct.rs b/tests/run-make/autodiff/type-trees/type-analysis/struct/struct.rs
new file mode 100644
index 00000000000..52cb6a9a6b9
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/struct/struct.rs
@@ -0,0 +1,23 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[derive(Copy, Clone)]
+struct MyStruct {
+    f: f32,
+}
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &MyStruct) -> f32 {
+    x.f * x.f
+}
+
+fn main() {
+    let x = MyStruct { f: 7.0 };
+    let mut df_dx = MyStruct { f: 0.0 };
+    let out = callee(&x);
+    let out_ = d_square(&x, &mut df_dx, 1.0);
+    assert_eq!(out, out_);
+    assert_eq!(14.0, df_dx.f);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u128/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/u128/rmake.rs
new file mode 100644
index 00000000000..3f605d47c68
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u128/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("u128.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("u128.stdout", stdout);
+    rfs::write("u128.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("u128.check").stdin_buf(rfs::read("u128.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u128/u128.check b/tests/run-make/autodiff/type-trees/type-analysis/u128/u128.check
new file mode 100644
index 00000000000..31a07219e74
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u128/u128.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer, [-1,8]:Integer, [-1,9]:Integer, [-1,10]:Integer, [-1,11]:Integer, [-1,12]:Integer, [-1,13]:Integer, [-1,14]:Integer, [-1,15]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i128, ptr %{{[0-9]+}}, align 16, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i128 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i128 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer, [-1,8]:Integer, [-1,9]:Integer, [-1,10]:Integer, [-1,11]:Integer, [-1,12]:Integer, [-1,13]:Integer, [-1,14]:Integer, [-1,15]:Integer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer, [-1,8]:Integer, [-1,9]:Integer, [-1,10]:Integer, [-1,11]:Integer, [-1,12]:Integer, [-1,13]:Integer, [-1,14]:Integer, [-1,15]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i128, ptr %{{[0-9]+}}, align 16, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i128 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i128 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u128/u128.rs b/tests/run-make/autodiff/type-trees/type-analysis/u128/u128.rs
new file mode 100644
index 00000000000..d19d2faa51b
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u128/u128.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &u128) -> u128 {
+    *x * *x
+}
+
+fn main() {
+    let x: u128 = 7;
+    let _ = callee(&x);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u16/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/u16/rmake.rs
new file mode 100644
index 00000000000..0051f6f9795
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u16/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("u16.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("u16.stdout", stdout);
+    rfs::write("u16.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("u16.check").stdin_buf(rfs::read("u16.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u16/u16.check b/tests/run-make/autodiff/type-trees/type-analysis/u16/u16.check
new file mode 100644
index 00000000000..8cc299532c5
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u16/u16.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i16, ptr %{{[0-9]+}}, align 2, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i16 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i16 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i16, ptr %{{[0-9]+}}, align 2, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i16 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i16 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u16/u16.rs b/tests/run-make/autodiff/type-trees/type-analysis/u16/u16.rs
new file mode 100644
index 00000000000..f5f5b50622b
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u16/u16.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &u16) -> u16 {
+    *x * *x
+}
+
+fn main() {
+    let x: u16 = 7;
+    let _ = callee(&x);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u32/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/u32/rmake.rs
new file mode 100644
index 00000000000..0882230b1c6
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u32/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("u32.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("u32.stdout", stdout);
+    rfs::write("u32.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("u32.check").stdin_buf(rfs::read("u32.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u32/u32.check b/tests/run-make/autodiff/type-trees/type-analysis/u32/u32.check
new file mode 100644
index 00000000000..4df982887d7
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u32/u32.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i32, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i32 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i32 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i32, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i32 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i32 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u32/u32.rs b/tests/run-make/autodiff/type-trees/type-analysis/u32/u32.rs
new file mode 100644
index 00000000000..66b4c222c51
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u32/u32.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &u32) -> u32 {
+    *x * *x
+}
+
+fn main() {
+    let x: u32 = 7;
+    let _ = callee(&x);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u8/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/u8/rmake.rs
new file mode 100644
index 00000000000..100b4f498f2
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u8/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("u8.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("u8.stdout", stdout);
+    rfs::write("u8.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("u8.check").stdin_buf(rfs::read("u8.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u8/u8.check b/tests/run-make/autodiff/type-trees/type-analysis/u8/u8.check
new file mode 100644
index 00000000000..651a2085bc6
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u8/u8.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i8, ptr %{{[0-9]+}}, align 1, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i8 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i8 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer, [-1,0]:Integer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i8, ptr %{{[0-9]+}}, align 1, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i8 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i8 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/u8/u8.rs b/tests/run-make/autodiff/type-trees/type-analysis/u8/u8.rs
new file mode 100644
index 00000000000..de9cdeb631e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/u8/u8.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &u8) -> u8 {
+    *x * *x
+}
+
+fn main() {
+    let x: u8 = 7;
+    let _ = callee(&x);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/union/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/union/rmake.rs
new file mode 100644
index 00000000000..67f0fe18481
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/union/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("union.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("union.stdout", stdout);
+    rfs::write("union.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("union.check").stdin_buf(rfs::read("union.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/union/union.check b/tests/run-make/autodiff/type-trees/type-analysis/union/union.check
new file mode 100644
index 00000000000..e7503453f8e
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/union/union.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer, [-1,0]:Float@float}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fmul float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/union/union.rs b/tests/run-make/autodiff/type-trees/type-analysis/union/union.rs
new file mode 100644
index 00000000000..8d997f8c839
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/union/union.rs
@@ -0,0 +1,20 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[allow(dead_code)]
+union MyUnion {
+    f: f32,
+    i: i32,
+}
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &MyUnion) -> f32 {
+    unsafe { x.f * x.f }
+}
+
+fn main() {
+    let x = MyUnion { f: 7.0 };
+    let _ = callee(&x);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/usize/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/usize/rmake.rs
new file mode 100644
index 00000000000..d5cfd708c3a
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/usize/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("usize.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("usize.stdout", stdout);
+    rfs::write("usize.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("usize.check").stdin_buf(rfs::read("usize.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/usize/usize.check b/tests/run-make/autodiff/type-trees/type-analysis/usize/usize.check
new file mode 100644
index 00000000000..40ee6edc02c
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/usize/usize.check
@@ -0,0 +1,10 @@
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i64, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i64 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK: callee - {[-1]:Integer} |{[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Integer, [-1,1]:Integer, [-1,2]:Integer, [-1,3]:Integer, [-1,4]:Integer, [-1,5]:Integer, [-1,6]:Integer, [-1,7]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = load i64, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: ret i64 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/usize/usize.rs b/tests/run-make/autodiff/type-trees/type-analysis/usize/usize.rs
new file mode 100644
index 00000000000..8e758be57d4
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/usize/usize.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(x: &usize) -> usize {
+    *x * *x
+}
+
+fn main() {
+    let x: usize = 7;
+    let _ = callee(&x);
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/vec/rmake.rs b/tests/run-make/autodiff/type-trees/type-analysis/vec/rmake.rs
new file mode 100644
index 00000000000..94491fab8d6
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/vec/rmake.rs
@@ -0,0 +1,28 @@
+//@ needs-enzyme
+//@ ignore-cross-compile
+
+use std::fs;
+
+use run_make_support::{llvm_filecheck, rfs, rustc};
+
+fn main() {
+    // Compile the Rust file with the required flags, capturing both stdout and stderr
+    let output = rustc()
+        .input("vec.rs")
+        .arg("-Zautodiff=Enable,PrintTAFn=callee")
+        .arg("-Zautodiff=NoPostopt")
+        .opt_level("3")
+        .arg("-Clto=fat")
+        .arg("-g")
+        .run();
+
+    let stdout = output.stdout_utf8();
+    let stderr = output.stderr_utf8();
+
+    // Write the outputs to files
+    rfs::write("vec.stdout", stdout);
+    rfs::write("vec.stderr", stderr);
+
+    // Run FileCheck on the stdout using the check file
+    llvm_filecheck().patterns("vec.check").stdin_buf(rfs::read("vec.stdout")).run();
+}
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/vec/vec.check b/tests/run-make/autodiff/type-trees/type-analysis/vec/vec.check
new file mode 100644
index 00000000000..dcf9508b69d
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/vec/vec.check
@@ -0,0 +1,18 @@
+// CHECK: callee - {[-1]:Float@float} |{[-1]:Pointer}:{}
+// CHECK: ptr %{{[0-9]+}}: {[-1]:Pointer}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw i8, ptr %{{[0-9]+}}, i64 8, !dbg !{{[0-9]+}}: {[-1]:Pointer}
+// CHECK-DAG: %{{[0-9]+}} = load ptr, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !nonnull !102, !noundef !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw i8, ptr %{{[0-9]+}}, i64 16, !dbg !{{[0-9]+}}: {[-1]:Pointer}
+// CHECK-DAG: %{{[0-9]+}} = load i64, ptr %{{[0-9]+}}, align 8, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = icmp eq i64 %{{[0-9]+}}, 0, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ], !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ %{{[0-9]+}}, %{{[0-9]+}} ], [ -0.000000e+00, %{{[0-9]+}} ], !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = getelementptr inbounds nuw float, ptr %{{[0-9]+}}, i64 %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Pointer, [-1,0]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = load float, ptr %{{[0-9]+}}, align 4, !dbg !{{[0-9]+}}, !noundef !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = fadd float %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: %{{[0-9]+}} = add nuw i64 %{{[0-9]+}}, 1, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: %{{[0-9]+}} = icmp eq i64 %{{[0-9]+}}, %{{[0-9]+}}, !dbg !{{[0-9]+}}: {[-1]:Integer}
+// CHECK-DAG: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
+// CHECK-DAG: %{{[0-9]+}} = phi float [ -0.000000e+00, %{{[0-9]+}} ], [ %{{[0-9]+}}, %{{[0-9]+}} ], !dbg !{{[0-9]+}}: {[-1]:Float@float}
+// CHECK-DAG: ret float %{{[0-9]+}}, !dbg !{{[0-9]+}}: {}
\ No newline at end of file
diff --git a/tests/run-make/autodiff/type-trees/type-analysis/vec/vec.rs b/tests/run-make/autodiff/type-trees/type-analysis/vec/vec.rs
new file mode 100644
index 00000000000..b60c2a88064
--- /dev/null
+++ b/tests/run-make/autodiff/type-trees/type-analysis/vec/vec.rs
@@ -0,0 +1,14 @@
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn callee(arg: &std::vec::Vec<f32>) -> f32 {
+    arg.iter().sum()
+}
+
+fn main() {
+    let v = vec![1.0f32, 2.0, 3.0];
+    let _ = callee(&v);
+}
-- 
cgit 1.4.1-3-g733a5


From a9a5b33c2d7d5d1ada0efd23f97cc1f3b774dbda Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Tue, 15 Jul 2025 04:59:27 +0000
Subject: Preparing for merge from rustc

---
 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 adf3f7389c6..67f27e7aa2c 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-9c3064e131f4939cc95a29bb11413c49bbda1491
+7f2065a4bae1faed5bab928c670964eafbf43b55
-- 
cgit 1.4.1-3-g733a5


From a14baf1e56cf9049992c25e0abb9ee4a7242e057 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Mon, 7 Jul 2025 09:04:21 +0200
Subject: Define datastructures for `#[cfg]` attribute, move StrippedCfgItem

---
 compiler/rustc_ast/src/expand/mod.rs               | 17 --------------
 .../rustc_attr_data_structures/src/attributes.rs   | 27 +++++++++++++++++++++-
 compiler/rustc_expand/src/base.rs                  | 10 ++++++--
 compiler/rustc_metadata/src/rmeta/mod.rs           |  2 +-
 compiler/rustc_middle/src/arena.rs                 |  2 +-
 compiler/rustc_middle/src/query/mod.rs             |  2 +-
 compiler/rustc_middle/src/ty/mod.rs                |  3 +--
 compiler/rustc_middle/src/ty/parameterized.rs      |  2 +-
 compiler/rustc_resolve/src/lib.rs                  |  2 +-
 compiler/rustc_resolve/src/macros.rs               | 17 ++++++++++----
 10 files changed, 53 insertions(+), 31 deletions(-)

diff --git a/compiler/rustc_ast/src/expand/mod.rs b/compiler/rustc_ast/src/expand/mod.rs
index 323a8fab6d5..069bff67b97 100644
--- a/compiler/rustc_ast/src/expand/mod.rs
+++ b/compiler/rustc_ast/src/expand/mod.rs
@@ -1,24 +1,7 @@
 //! Definitions shared by macros / syntax extensions and e.g. `rustc_middle`.
 
 use rustc_macros::{Decodable, Encodable, HashStable_Generic};
-use rustc_span::Ident;
-use rustc_span::def_id::DefId;
-
-use crate::MetaItem;
 
 pub mod allocator;
 pub mod autodiff_attrs;
 pub mod typetree;
-
-#[derive(Debug, Clone, Encodable, Decodable, HashStable_Generic)]
-pub struct StrippedCfgItem<ModId = DefId> {
-    pub parent_module: ModId,
-    pub ident: Ident,
-    pub cfg: MetaItem,
-}
-
-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 }
-    }
-}
diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 9b14ed88978..995ac514d8d 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -3,7 +3,7 @@ use rustc_ast::token::CommentKind;
 use rustc_ast::{self as ast, AttrStyle};
 use rustc_macros::{Decodable, Encodable, HashStable_Generic, PrintAttribute};
 use rustc_span::hygiene::Transparency;
-use rustc_span::{Span, Symbol};
+use rustc_span::{Ident, Span, Symbol};
 use thin_vec::ThinVec;
 
 use crate::{DefaultBodyStability, PartialConstStability, PrintAttribute, RustcVersion, Stability};
@@ -69,6 +69,7 @@ pub enum ReprAttr {
     ReprAlign(Align),
 }
 pub use ReprAttr::*;
+use rustc_span::def_id::DefId;
 
 pub enum TransparencyError {
     UnknownTransparency(Symbol, Span),
@@ -140,6 +141,30 @@ pub enum UsedBy {
     Linker,
 }
 
+#[derive(Debug, Clone, Encodable, Decodable, HashStable_Generic)]
+pub struct StrippedCfgItem<ModId = DefId> {
+    pub parent_module: ModId,
+    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 }
+    }
+}
+
+#[derive(Encodable, Decodable, Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(HashStable_Generic, PrintAttribute)]
+pub enum CfgEntry {
+    All(ThinVec<CfgEntry>, Span),
+    Any(ThinVec<CfgEntry>, Span),
+    Not(Box<CfgEntry>, Span),
+    Bool(bool, Span),
+    NameValue { name: Symbol, name_span: Span, value: Option<(Symbol, Span)>, span: Span },
+    Version(Option<RustcVersion>, Span),
+}
+
 /// Represents parsed *built-in* inert attributes.
 ///
 /// ## Overview
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 757a7e1c8e7..ce3006c2604 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -11,7 +11,7 @@ use rustc_ast::token::MetaVarKind;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::visit::{AssocCtxt, Visitor};
 use rustc_ast::{self as ast, AttrVec, Attribute, HasAttrs, Item, NodeId, PatKind};
-use rustc_attr_data_structures::{AttributeKind, Deprecation, Stability, find_attr};
+use rustc_attr_data_structures::{AttributeKind, CfgEntry, Deprecation, Stability, find_attr};
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_data_structures::sync;
 use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed, PResult};
@@ -1128,7 +1128,13 @@ pub trait ResolverExpand {
     /// HIR proc macros items back to their harness items.
     fn declare_proc_macro(&mut self, id: NodeId);
 
-    fn append_stripped_cfg_item(&mut self, parent_node: NodeId, ident: Ident, cfg: ast::MetaItem);
+    fn append_stripped_cfg_item(
+        &mut self,
+        parent_node: NodeId,
+        ident: Ident,
+        cfg: CfgEntry,
+        cfg_span: Span,
+    );
 
     /// Tools registered with `#![register_tool]` and used by tool attributes and lints.
     fn registered_tools(&self) -> &RegisteredTools;
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
index 8347626080e..915c9731688 100644
--- a/compiler/rustc_metadata/src/rmeta/mod.rs
+++ b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -7,7 +7,7 @@ use def_path_hash_map::DefPathHashMapRef;
 use encoder::EncodeContext;
 pub use encoder::{EncodedMetadata, encode_metadata, rendered_const};
 use rustc_abi::{FieldIdx, ReprOptions, VariantIdx};
-use rustc_ast::expand::StrippedCfgItem;
+use rustc_attr_data_structures::StrippedCfgItem;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::svh::Svh;
 use rustc_hir::PreciseCapturingArgKind;
diff --git a/compiler/rustc_middle/src/arena.rs b/compiler/rustc_middle/src/arena.rs
index f140ab4755b..43a7af9ce38 100644
--- a/compiler/rustc_middle/src/arena.rs
+++ b/compiler/rustc_middle/src/arena.rs
@@ -110,7 +110,7 @@ macro_rules! arena_types {
             [] external_constraints: rustc_middle::traits::solve::ExternalConstraintsData<rustc_middle::ty::TyCtxt<'tcx>>,
             [] predefined_opaques_in_body: rustc_middle::traits::solve::PredefinedOpaquesData<rustc_middle::ty::TyCtxt<'tcx>>,
             [decode] doc_link_resolutions: rustc_hir::def::DocLinkResMap,
-            [] stripped_cfg_items: rustc_ast::expand::StrippedCfgItem,
+            [] stripped_cfg_items: rustc_attr_data_structures::StrippedCfgItem,
             [] mod_child: rustc_middle::metadata::ModChild,
             [] features: rustc_feature::Features,
             [decode] specialization_graph: rustc_middle::traits::specialization_graph::Graph,
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 842d118449a..935cc889574 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -69,8 +69,8 @@ use std::sync::Arc;
 
 use rustc_abi::Align;
 use rustc_arena::TypedArena;
-use rustc_ast::expand::StrippedCfgItem;
 use rustc_ast::expand::allocator::AllocatorKind;
+use rustc_attr_data_structures::StrippedCfgItem;
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_data_structures::sorted_map::SortedMap;
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index a352ab3fd08..6e8f1e8fdd5 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -25,10 +25,9 @@ pub use generic_args::{GenericArgKind, TermKind, *};
 pub use generics::*;
 pub use intrinsic::IntrinsicDef;
 use rustc_abi::{Align, FieldIdx, Integer, IntegerType, ReprFlags, ReprOptions, VariantIdx};
-use rustc_ast::expand::StrippedCfgItem;
 use rustc_ast::node_id::NodeMap;
 pub use rustc_ast_ir::{Movability, Mutability, try_visit};
-use rustc_attr_data_structures::{AttributeKind, find_attr};
+use rustc_attr_data_structures::{AttributeKind, StrippedCfgItem, find_attr};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_data_structures::intern::Interned;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
diff --git a/compiler/rustc_middle/src/ty/parameterized.rs b/compiler/rustc_middle/src/ty/parameterized.rs
index 3d601fc0533..dbacbe21edb 100644
--- a/compiler/rustc_middle/src/ty/parameterized.rs
+++ b/compiler/rustc_middle/src/ty/parameterized.rs
@@ -87,7 +87,7 @@ trivially_parameterized_over_tcx! {
     ty::IntrinsicDef,
     rustc_ast::Attribute,
     rustc_ast::DelimArgs,
-    rustc_ast::expand::StrippedCfgItem<rustc_hir::def_id::DefIndex>,
+    rustc_attr_data_structures::StrippedCfgItem<rustc_hir::def_id::DefIndex>,
     rustc_attr_data_structures::ConstStability,
     rustc_attr_data_structures::DefaultBodyStability,
     rustc_attr_data_structures::Deprecation,
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index f8d1b6783e3..c2b3451d4a1 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -36,12 +36,12 @@ use late::{
 };
 use macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
 use rustc_arena::{DroplessArena, TypedArena};
-use rustc_ast::expand::StrippedCfgItem;
 use rustc_ast::node_id::NodeMap;
 use rustc_ast::{
     self as ast, AngleBracketedArg, CRATE_NODE_ID, Crate, Expr, ExprKind, GenericArg, GenericArgs,
     LitKind, NodeId, Path, attr,
 };
+use rustc_attr_data_structures::StrippedCfgItem;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_data_structures::intern::Interned;
 use rustc_data_structures::steal::Steal;
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 5864b035f73..cbb24289f51 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -5,10 +5,9 @@ use std::cell::Cell;
 use std::mem;
 use std::sync::Arc;
 
-use rustc_ast::expand::StrippedCfgItem;
 use rustc_ast::{self as ast, Crate, NodeId, attr};
 use rustc_ast_pretty::pprust;
-use rustc_attr_data_structures::StabilityLevel;
+use rustc_attr_data_structures::{CfgEntry, StabilityLevel, StrippedCfgItem};
 use rustc_errors::{Applicability, DiagCtxtHandle, StashKey};
 use rustc_expand::base::{
     Annotatable, DeriveResolution, Indeterminate, ResolverExpand, SyntaxExtension,
@@ -485,8 +484,18 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
         self.proc_macros.push(self.local_def_id(id))
     }
 
-    fn append_stripped_cfg_item(&mut self, parent_node: NodeId, ident: Ident, cfg: ast::MetaItem) {
-        self.stripped_cfg_items.push(StrippedCfgItem { parent_module: parent_node, ident, cfg });
+    fn append_stripped_cfg_item(
+        &mut self,
+        parent_node: NodeId,
+        ident: Ident,
+        cfg: CfgEntry,
+        cfg_span: Span,
+    ) {
+        self.stripped_cfg_items.push(StrippedCfgItem {
+            parent_module: parent_node,
+            ident,
+            cfg: (cfg, cfg_span),
+        });
     }
 
     fn registered_tools(&self) -> &RegisteredTools {
-- 
cgit 1.4.1-3-g733a5


From 38dd6f5206dea1388755c48afe55ad5af5a12577 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Mon, 7 Jul 2025 09:06:44 +0200
Subject: Allow `Early` stage to emit errors

---
 compiler/rustc_ast_lowering/src/lib.rs             |  9 +-
 compiler/rustc_attr_parsing/src/context.rs         | 97 ++++++++++++++++++----
 .../src/deriving/generic/mod.rs                    |  2 +-
 compiler/rustc_lint/src/nonstandard_style.rs       |  2 +-
 compiler/rustc_resolve/src/def_collector.rs        |  1 +
 5 files changed, 93 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 348fe2ee40a..1c96a375035 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -42,7 +42,7 @@ use std::sync::Arc;
 
 use rustc_ast::node_id::NodeMap;
 use rustc_ast::{self as ast, *};
-use rustc_attr_parsing::{AttributeParser, OmitDoc};
+use rustc_attr_parsing::{AttributeParser, Late, OmitDoc};
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::sorted_map::SortedMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
@@ -192,7 +192,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             // interact with `gen`/`async gen` blocks
             allow_async_iterator: [sym::gen_future, sym::async_iterator].into(),
 
-            attribute_parser: AttributeParser::new(tcx.sess, tcx.features(), registered_tools),
+            attribute_parser: AttributeParser::new(
+                tcx.sess,
+                tcx.features(),
+                registered_tools,
+                Late,
+            ),
             delayed_lints: Vec::new(),
         }
     }
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 6c70f2ee4ee..1f6675b4c5a 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -1,6 +1,5 @@
 use std::cell::RefCell;
 use std::collections::BTreeMap;
-use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 use std::sync::LazyLock;
 
@@ -202,7 +201,11 @@ pub trait Stage: Sized + 'static + Sealed {
 
     fn parsers() -> &'static group_type!(Self);
 
-    fn emit_err<'sess>(sess: &'sess Session, diag: impl for<'x> Diagnostic<'x>) -> ErrorGuaranteed;
+    fn emit_err<'sess>(
+        &self,
+        sess: &'sess Session,
+        diag: impl for<'x> Diagnostic<'x>,
+    ) -> ErrorGuaranteed;
 }
 
 // allow because it's a sealed trait
@@ -214,8 +217,16 @@ impl Stage for Early {
     fn parsers() -> &'static group_type!(Self) {
         &early::ATTRIBUTE_PARSERS
     }
-    fn emit_err<'sess>(sess: &'sess Session, diag: impl for<'x> Diagnostic<'x>) -> ErrorGuaranteed {
-        sess.dcx().create_err(diag).delay_as_bug()
+    fn emit_err<'sess>(
+        &self,
+        sess: &'sess Session,
+        diag: impl for<'x> Diagnostic<'x>,
+    ) -> ErrorGuaranteed {
+        if self.emit_errors {
+            sess.dcx().emit_err(diag)
+        } else {
+            sess.dcx().create_err(diag).delay_as_bug()
+        }
     }
 }
 
@@ -228,20 +239,29 @@ impl Stage for Late {
     fn parsers() -> &'static group_type!(Self) {
         &late::ATTRIBUTE_PARSERS
     }
-    fn emit_err<'sess>(tcx: &'sess Session, diag: impl for<'x> Diagnostic<'x>) -> ErrorGuaranteed {
+    fn emit_err<'sess>(
+        &self,
+        tcx: &'sess Session,
+        diag: impl for<'x> Diagnostic<'x>,
+    ) -> ErrorGuaranteed {
         tcx.dcx().emit_err(diag)
     }
 }
 
 /// used when parsing attributes for miscellaneous things *before* ast lowering
-pub struct Early;
+pub struct Early {
+    /// Whether to emit errors or delay them as a bug
+    /// For most attributes, the attribute will be parsed again in the `Late` stage and in this case the errors should be delayed
+    /// But for some, such as `cfg`, the attribute will be removed before the `Late` stage so errors must be emitted
+    pub emit_errors: bool,
+}
 /// used when parsing attributes during ast lowering
 pub struct Late;
 
 /// Context given to every attribute parser when accepting
 ///
 /// Gives [`AttributeParser`]s enough information to create errors, for example.
-pub(crate) struct AcceptContext<'f, 'sess, S: Stage> {
+pub struct AcceptContext<'f, 'sess, S: Stage> {
     pub(crate) shared: SharedContext<'f, 'sess, S>,
     /// The span of the attribute currently being parsed
     pub(crate) attr_span: Span,
@@ -257,7 +277,7 @@ pub(crate) struct AcceptContext<'f, 'sess, S: Stage> {
 
 impl<'f, 'sess: 'f, S: Stage> SharedContext<'f, 'sess, S> {
     pub(crate) fn emit_err(&self, diag: impl for<'x> Diagnostic<'x>) -> ErrorGuaranteed {
-        S::emit_err(&self.sess, diag)
+        self.stage.emit_err(&self.sess, diag)
     }
 
     /// Emit a lint. This method is somewhat special, since lints emitted during attribute parsing
@@ -472,7 +492,7 @@ impl<'f, 'sess, S: Stage> DerefMut for AcceptContext<'f, 'sess, S> {
 ///
 /// Gives [`AttributeParser`](crate::attributes::AttributeParser)s enough information to create
 /// errors, for example.
-pub(crate) struct SharedContext<'p, 'sess, S: Stage> {
+pub struct SharedContext<'p, 'sess, S: Stage> {
     /// The parse context, gives access to the session and the
     /// diagnostics context.
     pub(crate) cx: &'p mut AttributeParser<'sess, S>,
@@ -540,7 +560,7 @@ pub struct AttributeParser<'sess, S: Stage = Late> {
     pub(crate) tools: Vec<Symbol>,
     features: Option<&'sess Features>,
     sess: &'sess Session,
-    stage: PhantomData<S>,
+    stage: S,
 
     /// *Only* parse attributes with this symbol.
     ///
@@ -569,13 +589,14 @@ impl<'sess> AttributeParser<'sess, Early> {
         sym: Symbol,
         target_span: Span,
         target_node_id: NodeId,
+        features: Option<&'sess Features>,
     ) -> Option<Attribute> {
         let mut p = Self {
-            features: None,
+            features,
             tools: Vec::new(),
             parse_only: Some(sym),
             sess,
-            stage: PhantomData,
+            stage: Early { emit_errors: false },
         };
         let mut parsed = p.parse_attribute_list(
             attrs,
@@ -591,11 +612,55 @@ impl<'sess> AttributeParser<'sess, Early> {
 
         parsed.pop()
     }
+
+    pub fn parse_single<T>(
+        sess: &'sess Session,
+        attr: &ast::Attribute,
+        target_span: Span,
+        target_node_id: NodeId,
+        features: Option<&'sess Features>,
+        emit_errors: bool,
+        parse_fn: fn(cx: &mut AcceptContext<'_, '_, Early>, item: &ArgParser<'_>) -> T,
+        template: &AttributeTemplate,
+    ) -> T {
+        let mut parser = Self {
+            features,
+            tools: Vec::new(),
+            parse_only: None,
+            sess,
+            stage: Early { emit_errors },
+        };
+        let ast::AttrKind::Normal(normal_attr) = &attr.kind else {
+            panic!("parse_single called on a doc attr")
+        };
+        let meta_parser = MetaItemParser::from_attr(normal_attr, parser.dcx());
+        let path = meta_parser.path();
+        let args = meta_parser.args();
+        let mut cx: AcceptContext<'_, 'sess, Early> = AcceptContext {
+            shared: SharedContext {
+                cx: &mut parser,
+                target_span,
+                target_id: target_node_id,
+                emit_lint: &mut |_lint| {
+                    panic!("can't emit lints here for now (nothing uses this atm)");
+                },
+            },
+            attr_span: attr.span,
+            template,
+            attr_path: path.get_attribute_path(),
+        };
+        parse_fn(&mut cx, args)
+    }
 }
 
 impl<'sess, S: Stage> AttributeParser<'sess, S> {
-    pub fn new(sess: &'sess Session, features: &'sess Features, tools: Vec<Symbol>) -> Self {
-        Self { features: Some(features), tools, parse_only: None, sess, stage: PhantomData }
+    pub fn new(
+        sess: &'sess Session,
+        features: &'sess Features,
+        tools: Vec<Symbol>,
+        stage: S,
+    ) -> Self {
+        Self { features: Some(features), tools, parse_only: None, sess, stage }
     }
 
     pub(crate) fn sess(&self) -> &'sess Session {
@@ -606,6 +671,10 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         self.features.expect("features not available at this point in the compiler")
     }
 
+    pub(crate) fn features_option(&self) -> Option<&'sess Features> {
+        self.features
+    }
+
     pub(crate) fn dcx(&self) -> DiagCtxtHandle<'sess> {
         self.sess().dcx()
     }
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
index 8c3093acea4..c55a9e73e38 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -484,7 +484,7 @@ impl<'a> TraitDef<'a> {
         match item {
             Annotatable::Item(item) => {
                 let is_packed = matches!(
-                    AttributeParser::parse_limited(cx.sess, &item.attrs, sym::repr, item.span, item.id),
+                    AttributeParser::parse_limited(cx.sess, &item.attrs, sym::repr, item.span, item.id, None),
                     Some(Attribute::Parsed(AttributeKind::Repr { reprs, .. })) if reprs.iter().any(|(x, _)| matches!(x, ReprPacked(..)))
                 );
 
diff --git a/compiler/rustc_lint/src/nonstandard_style.rs b/compiler/rustc_lint/src/nonstandard_style.rs
index bc9badbb232..db89396d1dc 100644
--- a/compiler/rustc_lint/src/nonstandard_style.rs
+++ b/compiler/rustc_lint/src/nonstandard_style.rs
@@ -167,7 +167,7 @@ impl NonCamelCaseTypes {
 impl EarlyLintPass for NonCamelCaseTypes {
     fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) {
         let has_repr_c = matches!(
-            AttributeParser::parse_limited(cx.sess(), &it.attrs, sym::repr, it.span, it.id),
+            AttributeParser::parse_limited(cx.sess(), &it.attrs, sym::repr, it.span, it.id, None),
             Some(Attribute::Parsed(AttributeKind::Repr { reprs, ..})) if reprs.iter().any(|(r, _)| r == &ReprAttr::ReprC)
         );
 
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index e2caf632dd2..781e2ce9704 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -132,6 +132,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                     &self.resolver.tcx.sess,
                     self.resolver.tcx.features(),
                     Vec::new(),
+                    Early { emit_errors: false },
                 );
                 let attrs = parser.parse_attribute_list(
                     &i.attrs,
-- 
cgit 1.4.1-3-g733a5


From 30f4a9cd539a9bffda21e056c8ab291d02e85541 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Mon, 7 Jul 2025 09:08:02 +0200
Subject: Move `cfg` -> `cfg_old`

---
 .../rustc_attr_parsing/src/attributes/cfg_old.rs   | 247 +++++++++++++++++++++
 compiler/rustc_attr_parsing/src/attributes/mod.rs  |   1 +
 compiler/rustc_attr_parsing/src/lib.rs             |   3 +-
 3 files changed, 250 insertions(+), 1 deletion(-)
 create mode 100644 compiler/rustc_attr_parsing/src/attributes/cfg_old.rs

diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg_old.rs b/compiler/rustc_attr_parsing/src/attributes/cfg_old.rs
new file mode 100644
index 00000000000..c5025a8b6ea
--- /dev/null
+++ b/compiler/rustc_attr_parsing/src/attributes/cfg_old.rs
@@ -0,0 +1,247 @@
+use rustc_ast::{LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit, NodeId};
+use rustc_ast_pretty::pprust;
+use rustc_attr_data_structures::RustcVersion;
+use rustc_feature::{Features, GatedCfg, find_gated_cfg};
+use rustc_session::Session;
+use rustc_session::config::ExpectedValues;
+use rustc_session::lint::builtin::UNEXPECTED_CFGS;
+use rustc_session::lint::{BuiltinLintDiag, Lint};
+use rustc_session::parse::feature_err;
+use rustc_span::{Span, Symbol, sym};
+
+use crate::session_diagnostics::{self, UnsupportedLiteralReason};
+use crate::{fluent_generated, parse_version};
+
+/// Emitter of a builtin lint from `cfg_matches`.
+///
+/// Used to support emitting a lint (currently on check-cfg), either:
+///  - as an early buffered lint (in `rustc`)
+///  - or has a "normal" lint from HIR (in `rustdoc`)
+pub trait CfgMatchesLintEmitter {
+    fn emit_span_lint(&self, sess: &Session, lint: &'static Lint, sp: Span, diag: BuiltinLintDiag);
+}
+
+impl CfgMatchesLintEmitter for NodeId {
+    fn emit_span_lint(&self, sess: &Session, lint: &'static Lint, sp: Span, diag: BuiltinLintDiag) {
+        sess.psess.buffer_lint(lint, sp, *self, diag);
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Condition {
+    pub name: Symbol,
+    pub name_span: Span,
+    pub value: Option<Symbol>,
+    pub value_span: Option<Span>,
+    pub span: Span,
+}
+
+/// Tests if a cfg-pattern matches the cfg set
+pub fn cfg_matches(
+    cfg: &MetaItemInner,
+    sess: &Session,
+    lint_emitter: impl CfgMatchesLintEmitter,
+    features: Option<&Features>,
+) -> bool {
+    eval_condition(cfg, sess, features, &mut |cfg| {
+        try_gate_cfg(cfg.name, cfg.span, sess, features);
+        match sess.psess.check_config.expecteds.get(&cfg.name) {
+            Some(ExpectedValues::Some(values)) if !values.contains(&cfg.value) => {
+                lint_emitter.emit_span_lint(
+                    sess,
+                    UNEXPECTED_CFGS,
+                    cfg.span,
+                    BuiltinLintDiag::UnexpectedCfgValue(
+                        (cfg.name, cfg.name_span),
+                        cfg.value.map(|v| (v, cfg.value_span.unwrap())),
+                    ),
+                );
+            }
+            None if sess.psess.check_config.exhaustive_names => {
+                lint_emitter.emit_span_lint(
+                    sess,
+                    UNEXPECTED_CFGS,
+                    cfg.span,
+                    BuiltinLintDiag::UnexpectedCfgName(
+                        (cfg.name, cfg.name_span),
+                        cfg.value.map(|v| (v, cfg.value_span.unwrap())),
+                    ),
+                );
+            }
+            _ => { /* not unexpected */ }
+        }
+        sess.psess.config.contains(&(cfg.name, cfg.value))
+    })
+}
+
+pub fn try_gate_cfg(name: Symbol, span: Span, sess: &Session, features: Option<&Features>) {
+    let gate = find_gated_cfg(|sym| sym == name);
+    if let (Some(feats), Some(gated_cfg)) = (features, gate) {
+        gate_cfg(gated_cfg, span, sess, feats);
+    }
+}
+
+#[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
+fn gate_cfg(gated_cfg: &GatedCfg, cfg_span: Span, sess: &Session, features: &Features) {
+    let (cfg, feature, has_feature) = gated_cfg;
+    if !has_feature(features) && !cfg_span.allows_unstable(*feature) {
+        let explain = format!("`cfg({cfg})` is experimental and subject to change");
+        feature_err(sess, *feature, cfg_span, explain).emit();
+    }
+}
+
+/// Evaluate a cfg-like condition (with `any` and `all`), using `eval` to
+/// evaluate individual items.
+pub fn eval_condition(
+    cfg: &MetaItemInner,
+    sess: &Session,
+    features: Option<&Features>,
+    eval: &mut impl FnMut(Condition) -> bool,
+) -> bool {
+    let dcx = sess.dcx();
+
+    let cfg = match cfg {
+        MetaItemInner::MetaItem(meta_item) => meta_item,
+        MetaItemInner::Lit(MetaItemLit { kind: LitKind::Bool(b), .. }) => {
+            return *b;
+        }
+        _ => {
+            dcx.emit_err(session_diagnostics::UnsupportedLiteral {
+                span: cfg.span(),
+                reason: UnsupportedLiteralReason::CfgBoolean,
+                is_bytestr: false,
+                start_point_span: sess.source_map().start_point(cfg.span()),
+            });
+            return false;
+        }
+    };
+
+    match &cfg.kind {
+        MetaItemKind::List(mis) if cfg.has_name(sym::version) => {
+            try_gate_cfg(sym::version, cfg.span, sess, features);
+            let (min_version, span) = match &mis[..] {
+                [MetaItemInner::Lit(MetaItemLit { kind: LitKind::Str(sym, ..), span, .. })] => {
+                    (sym, span)
+                }
+                [
+                    MetaItemInner::Lit(MetaItemLit { span, .. })
+                    | MetaItemInner::MetaItem(MetaItem { span, .. }),
+                ] => {
+                    dcx.emit_err(session_diagnostics::ExpectedVersionLiteral { span: *span });
+                    return false;
+                }
+                [..] => {
+                    dcx.emit_err(session_diagnostics::ExpectedSingleVersionLiteral {
+                        span: cfg.span,
+                    });
+                    return false;
+                }
+            };
+            let Some(min_version) = parse_version(*min_version) else {
+                dcx.emit_warn(session_diagnostics::UnknownVersionLiteral { span: *span });
+                return false;
+            };
+
+            // See https://github.com/rust-lang/rust/issues/64796#issuecomment-640851454 for details
+            if sess.psess.assume_incomplete_release {
+                RustcVersion::current_overridable() > min_version
+            } else {
+                RustcVersion::current_overridable() >= min_version
+            }
+        }
+        MetaItemKind::List(mis) => {
+            for mi in mis.iter() {
+                if mi.meta_item_or_bool().is_none() {
+                    dcx.emit_err(session_diagnostics::UnsupportedLiteral {
+                        span: mi.span(),
+                        reason: UnsupportedLiteralReason::Generic,
+                        is_bytestr: false,
+                        start_point_span: sess.source_map().start_point(mi.span()),
+                    });
+                    return false;
+                }
+            }
+
+            // The unwraps below may look dangerous, but we've already asserted
+            // that they won't fail with the loop above.
+            match cfg.name() {
+                Some(sym::any) => mis
+                    .iter()
+                    // We don't use any() here, because we want to evaluate all cfg condition
+                    // as eval_condition can (and does) extra checks
+                    .fold(false, |res, mi| res | eval_condition(mi, sess, features, eval)),
+                Some(sym::all) => mis
+                    .iter()
+                    // We don't use all() here, because we want to evaluate all cfg condition
+                    // as eval_condition can (and does) extra checks
+                    .fold(true, |res, mi| res & eval_condition(mi, sess, features, eval)),
+                Some(sym::not) => {
+                    let [mi] = mis.as_slice() else {
+                        dcx.emit_err(session_diagnostics::ExpectedOneCfgPattern { span: cfg.span });
+                        return false;
+                    };
+
+                    !eval_condition(mi, sess, features, eval)
+                }
+                Some(sym::target) => {
+                    if let Some(features) = features
+                        && !features.cfg_target_compact()
+                    {
+                        feature_err(
+                            sess,
+                            sym::cfg_target_compact,
+                            cfg.span,
+                            fluent_generated::attr_parsing_unstable_cfg_target_compact,
+                        )
+                        .emit();
+                    }
+
+                    mis.iter().fold(true, |res, mi| {
+                        let Some(mut mi) = mi.meta_item().cloned() else {
+                            dcx.emit_err(session_diagnostics::CfgPredicateIdentifier {
+                                span: mi.span(),
+                            });
+                            return false;
+                        };
+
+                        if let [seg, ..] = &mut mi.path.segments[..] {
+                            seg.ident.name = Symbol::intern(&format!("target_{}", seg.ident.name));
+                        }
+
+                        res & eval_condition(&MetaItemInner::MetaItem(mi), sess, features, eval)
+                    })
+                }
+                _ => {
+                    dcx.emit_err(session_diagnostics::InvalidPredicate {
+                        span: cfg.span,
+                        predicate: pprust::path_to_string(&cfg.path),
+                    });
+                    false
+                }
+            }
+        }
+        MetaItemKind::Word | MetaItemKind::NameValue(..) if cfg.path.segments.len() != 1 => {
+            dcx.emit_err(session_diagnostics::CfgPredicateIdentifier { span: cfg.path.span });
+            true
+        }
+        MetaItemKind::NameValue(lit) if !lit.kind.is_str() => {
+            dcx.emit_err(session_diagnostics::UnsupportedLiteral {
+                span: lit.span,
+                reason: UnsupportedLiteralReason::CfgString,
+                is_bytestr: lit.kind.is_bytestr(),
+                start_point_span: sess.source_map().start_point(lit.span),
+            });
+            true
+        }
+        MetaItemKind::Word | MetaItemKind::NameValue(..) => {
+            let ident = cfg.ident().expect("multi-segment cfg predicate");
+            eval(Condition {
+                name: ident.name,
+                name_span: ident.span,
+                value: cfg.value_str(),
+                value_span: cfg.name_value_literal_span(),
+                span: cfg.span,
+            })
+        }
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
index 68c716d1a99..200f1381960 100644
--- a/compiler/rustc_attr_parsing/src/attributes/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -27,6 +27,7 @@ use crate::session_diagnostics::UnusedMultiple;
 
 pub(crate) mod allow_unstable;
 pub(crate) mod cfg;
+pub(crate) mod cfg_old;
 pub(crate) mod codegen_attrs;
 pub(crate) mod confusables;
 pub(crate) mod deprecation;
diff --git a/compiler/rustc_attr_parsing/src/lib.rs b/compiler/rustc_attr_parsing/src/lib.rs
index 47eeb63bad3..2102a26108b 100644
--- a/compiler/rustc_attr_parsing/src/lib.rs
+++ b/compiler/rustc_attr_parsing/src/lib.rs
@@ -90,7 +90,8 @@ mod lints;
 pub mod parser;
 mod session_diagnostics;
 
-pub use attributes::cfg::*;
+pub use attributes::cfg::{CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg_attr};
+pub use attributes::cfg_old::*;
 pub use attributes::util::{
     find_crate_name, is_builtin_attr, is_doc_alias_attrs_contain_symbol, parse_version,
 };
-- 
cgit 1.4.1-3-g733a5


From a74a28493a00900616d5e52cd85b8b6bae761935 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Tue, 15 Jul 2025 15:10:24 +0800
Subject: Add tests for UB check in `set_len`, `from_raw_parts_in`,
 `from_parts_in`

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 tests/ui/precondition-checks/vec-from-parts.rs     | 15 +++++++++++
 tests/ui/precondition-checks/vec-from-raw-parts.rs | 29 ++++++++++++++++++++++
 tests/ui/precondition-checks/vec-set-len.rs        | 11 ++++++++
 3 files changed, 55 insertions(+)
 create mode 100644 tests/ui/precondition-checks/vec-from-parts.rs
 create mode 100644 tests/ui/precondition-checks/vec-from-raw-parts.rs
 create mode 100644 tests/ui/precondition-checks/vec-set-len.rs

diff --git a/tests/ui/precondition-checks/vec-from-parts.rs b/tests/ui/precondition-checks/vec-from-parts.rs
new file mode 100644
index 00000000000..0bafb5aa715
--- /dev/null
+++ b/tests/ui/precondition-checks/vec-from-parts.rs
@@ -0,0 +1,15 @@
+//@ run-fail
+//@ compile-flags: -Cdebug-assertions=yes
+//@ error-pattern: unsafe precondition(s) violated: Vec::from_parts_in requires that length <= capacity
+#![feature(allocator_api)]
+
+use std::ptr::NonNull;
+
+fn main() {
+    let ptr: NonNull<i32> = std::ptr::NonNull::dangling();
+    // Test Vec::from_parts_in with length > capacity
+    unsafe {
+        let alloc = std::alloc::Global;
+        let _vec = Vec::from_parts_in(ptr, 10, 5, alloc);
+    }
+}
diff --git a/tests/ui/precondition-checks/vec-from-raw-parts.rs b/tests/ui/precondition-checks/vec-from-raw-parts.rs
new file mode 100644
index 00000000000..884d34c0a56
--- /dev/null
+++ b/tests/ui/precondition-checks/vec-from-raw-parts.rs
@@ -0,0 +1,29 @@
+//@ run-fail
+//@ compile-flags: -Cdebug-assertions=yes
+//@ error-pattern: unsafe precondition(s) violated: Vec::from_raw_parts_in requires that length <= capacity
+//@ revisions: vec_from_raw_parts vec_from_raw_parts_in string_from_raw_parts
+
+#![feature(allocator_api)]
+
+fn main() {
+    let ptr = std::ptr::null_mut::<u8>();
+    // Test Vec::from_raw_parts with length > capacity
+    unsafe {
+        #[cfg(vec_from_raw_parts)]
+        let _vec = Vec::from_raw_parts(ptr, 10, 5);
+    }
+
+    // Test Vec::from_raw_parts_in with length > capacity
+    unsafe {
+        let alloc = std::alloc::Global;
+        #[cfg(vec_from_raw_parts_in)]
+        let _vec = Vec::from_raw_parts_in(ptr, 10, 5, alloc);
+    }
+
+    // Test String::from_raw_parts with length > capacity
+    // Because it calls Vec::from_raw_parts, it should also fail
+    unsafe {
+        #[cfg(string_from_raw_parts)]
+        let _vec = String::from_raw_parts(ptr, 10, 5);
+    }
+}
diff --git a/tests/ui/precondition-checks/vec-set-len.rs b/tests/ui/precondition-checks/vec-set-len.rs
new file mode 100644
index 00000000000..0987e7fe028
--- /dev/null
+++ b/tests/ui/precondition-checks/vec-set-len.rs
@@ -0,0 +1,11 @@
+//@ run-fail
+//@ compile-flags: -Cdebug-assertions=yes
+//@ error-pattern: unsafe precondition(s) violated: Vec::set_len requires that new_len <= capacity()
+
+fn main() {
+    let mut vec: Vec<i32> = Vec::with_capacity(5);
+    // Test set_len with length > capacity
+    unsafe {
+        vec.set_len(10);
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From 6133c676d7b5e025121c858c4e7942cce70adf27 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Mon, 7 Jul 2025 09:09:54 +0200
Subject: Define attribute parser & config evaluator

---
 compiler/rustc_attr_parsing/src/attributes/cfg.rs | 464 ++++++++++++----------
 compiler/rustc_expand/src/config.rs               |  52 ++-
 compiler/rustc_expand/src/expand.rs               |  38 +-
 compiler/rustc_parse/src/validate_attr.rs         |  14 +-
 compiler/rustc_resolve/src/diagnostics.rs         |  21 +-
 5 files changed, 325 insertions(+), 264 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg.rs b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
index a8d9229cbc3..a56855b3bd3 100644
--- a/compiler/rustc_attr_parsing/src/attributes/cfg.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
@@ -1,247 +1,291 @@
-use rustc_ast::{LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit, NodeId};
-use rustc_ast_pretty::pprust;
-use rustc_attr_data_structures::RustcVersion;
-use rustc_feature::{Features, GatedCfg, find_gated_cfg};
+use rustc_ast::{LitKind, NodeId};
+use rustc_attr_data_structures::{CfgEntry, RustcVersion};
+use rustc_feature::{AttributeTemplate, Features, template};
 use rustc_session::Session;
 use rustc_session::config::ExpectedValues;
+use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::UNEXPECTED_CFGS;
-use rustc_session::lint::{BuiltinLintDiag, Lint};
 use rustc_session::parse::feature_err;
 use rustc_span::{Span, Symbol, sym};
+use thin_vec::ThinVec;
 
-use crate::session_diagnostics::{self, UnsupportedLiteralReason};
-use crate::{fluent_generated, parse_version};
+use crate::context::{AcceptContext, Stage};
+use crate::parser::{ArgParser, MetaItemListParser, MetaItemOrLitParser, NameValueParser};
+use crate::{
+    CfgMatchesLintEmitter, fluent_generated, parse_version, session_diagnostics, try_gate_cfg,
+};
 
-/// Emitter of a builtin lint from `cfg_matches`.
-///
-/// Used to support emitting a lint (currently on check-cfg), either:
-///  - as an early buffered lint (in `rustc`)
-///  - or has a "normal" lint from HIR (in `rustdoc`)
-pub trait CfgMatchesLintEmitter {
-    fn emit_span_lint(&self, sess: &Session, lint: &'static Lint, sp: Span, diag: BuiltinLintDiag);
-}
+pub const CFG_TEMPLATE: AttributeTemplate = template!(List: "predicate");
 
-impl CfgMatchesLintEmitter for NodeId {
-    fn emit_span_lint(&self, sess: &Session, lint: &'static Lint, sp: Span, diag: BuiltinLintDiag) {
-        sess.psess.buffer_lint(lint, sp, *self, diag);
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Condition {
-    pub name: Symbol,
-    pub name_span: Span,
-    pub value: Option<Symbol>,
-    pub value_span: Option<Span>,
-    pub span: Span,
+pub fn parse_cfg_attr<'c, S: Stage>(
+    cx: &'c mut AcceptContext<'_, '_, S>,
+    args: &'c ArgParser<'_>,
+) -> Option<CfgEntry> {
+    let ArgParser::List(list) = args else {
+        cx.expected_list(cx.attr_span);
+        return None;
+    };
+    let Some(single) = list.single() else {
+        cx.expected_single_argument(list.span);
+        return None;
+    };
+    parse_cfg_entry(cx, single)
 }
 
-/// Tests if a cfg-pattern matches the cfg set
-pub fn cfg_matches(
-    cfg: &MetaItemInner,
-    sess: &Session,
-    lint_emitter: impl CfgMatchesLintEmitter,
-    features: Option<&Features>,
-) -> bool {
-    eval_condition(cfg, sess, features, &mut |cfg| {
-        try_gate_cfg(cfg.name, cfg.span, sess, features);
-        match sess.psess.check_config.expecteds.get(&cfg.name) {
-            Some(ExpectedValues::Some(values)) if !values.contains(&cfg.value) => {
-                lint_emitter.emit_span_lint(
-                    sess,
-                    UNEXPECTED_CFGS,
-                    cfg.span,
-                    BuiltinLintDiag::UnexpectedCfgValue(
-                        (cfg.name, cfg.name_span),
-                        cfg.value.map(|v| (v, cfg.value_span.unwrap())),
-                    ),
-                );
+fn parse_cfg_entry<S: Stage>(
+    cx: &mut AcceptContext<'_, '_, S>,
+    item: &MetaItemOrLitParser<'_>,
+) -> Option<CfgEntry> {
+    Some(match item {
+        MetaItemOrLitParser::MetaItemParser(meta) => match meta.args() {
+            ArgParser::List(list) => match meta.path().word_sym() {
+                Some(sym::not) => {
+                    let Some(single) = list.single() else {
+                        cx.expected_single_argument(list.span);
+                        return None;
+                    };
+                    CfgEntry::Not(Box::new(parse_cfg_entry(cx, single)?), list.span)
+                }
+                Some(sym::any) => CfgEntry::Any(
+                    list.mixed().flat_map(|sub_item| parse_cfg_entry(cx, sub_item)).collect(),
+                    list.span,
+                ),
+                Some(sym::all) => CfgEntry::All(
+                    list.mixed().flat_map(|sub_item| parse_cfg_entry(cx, sub_item)).collect(),
+                    list.span,
+                ),
+                Some(sym::target) => parse_cfg_entry_target(cx, list, meta.span())?,
+                Some(sym::version) => parse_cfg_entry_version(cx, list, meta.span())?,
+                _ => {
+                    cx.emit_err(session_diagnostics::InvalidPredicate {
+                        span: meta.span(),
+                        predicate: meta.path().to_string(),
+                    });
+                    return None;
+                }
+            },
+            a @ (ArgParser::NoArgs | ArgParser::NameValue(_)) => {
+                let Some(name) = meta.path().word_sym() else {
+                    cx.emit_err(session_diagnostics::CfgPredicateIdentifier {
+                        span: meta.path().span(),
+                    });
+                    return None;
+                };
+                parse_name_value(name, meta.path().span(), a.name_value(), meta.span(), cx)?
             }
-            None if sess.psess.check_config.exhaustive_names => {
-                lint_emitter.emit_span_lint(
-                    sess,
-                    UNEXPECTED_CFGS,
-                    cfg.span,
-                    BuiltinLintDiag::UnexpectedCfgName(
-                        (cfg.name, cfg.name_span),
-                        cfg.value.map(|v| (v, cfg.value_span.unwrap())),
-                    ),
-                );
+        },
+        MetaItemOrLitParser::Lit(lit) => match lit.kind {
+            LitKind::Bool(b) => CfgEntry::Bool(b, lit.span),
+            _ => {
+                cx.emit_err(session_diagnostics::CfgPredicateIdentifier { span: lit.span });
+                return None;
             }
-            _ => { /* not unexpected */ }
-        }
-        sess.psess.config.contains(&(cfg.name, cfg.value))
+        },
+        MetaItemOrLitParser::Err(_, _) => return None,
     })
 }
 
-fn try_gate_cfg(name: Symbol, span: Span, sess: &Session, features: Option<&Features>) {
-    let gate = find_gated_cfg(|sym| sym == name);
-    if let (Some(feats), Some(gated_cfg)) = (features, gate) {
-        gate_cfg(gated_cfg, span, sess, feats);
-    }
+fn parse_cfg_entry_version<S: Stage>(
+    cx: &mut AcceptContext<'_, '_, S>,
+    list: &MetaItemListParser<'_>,
+    meta_span: Span,
+) -> Option<CfgEntry> {
+    try_gate_cfg(sym::version, meta_span, cx.sess(), Some(cx.features()));
+    let Some(version) = list.single() else {
+        cx.emit_err(session_diagnostics::ExpectedSingleVersionLiteral { span: list.span });
+        return None;
+    };
+    let Some(version_lit) = version.lit() else {
+        cx.emit_err(session_diagnostics::ExpectedVersionLiteral { span: version.span() });
+        return None;
+    };
+    let Some(version_str) = version_lit.value_str() else {
+        cx.emit_err(session_diagnostics::ExpectedVersionLiteral { span: version_lit.span });
+        return None;
+    };
+
+    let min_version = parse_version(version_str).or_else(|| {
+        cx.sess()
+            .dcx()
+            .emit_warn(session_diagnostics::UnknownVersionLiteral { span: version_lit.span });
+        None
+    });
+
+    Some(CfgEntry::Version(min_version, list.span))
 }
 
-#[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
-fn gate_cfg(gated_cfg: &GatedCfg, cfg_span: Span, sess: &Session, features: &Features) {
-    let (cfg, feature, has_feature) = gated_cfg;
-    if !has_feature(features) && !cfg_span.allows_unstable(*feature) {
-        let explain = format!("`cfg({cfg})` is experimental and subject to change");
-        feature_err(sess, *feature, cfg_span, explain).emit();
+fn parse_cfg_entry_target<S: Stage>(
+    cx: &mut AcceptContext<'_, '_, S>,
+    list: &MetaItemListParser<'_>,
+    meta_span: Span,
+) -> Option<CfgEntry> {
+    if !cx.features().cfg_target_compact() {
+        feature_err(
+            cx.sess(),
+            sym::cfg_target_compact,
+            meta_span,
+            fluent_generated::attr_parsing_unstable_cfg_target_compact,
+        )
+        .emit();
     }
-}
 
-/// Evaluate a cfg-like condition (with `any` and `all`), using `eval` to
-/// evaluate individual items.
-pub fn eval_condition(
-    cfg: &MetaItemInner,
-    sess: &Session,
-    features: Option<&Features>,
-    eval: &mut impl FnMut(Condition) -> bool,
-) -> bool {
-    let dcx = sess.dcx();
-
-    let cfg = match cfg {
-        MetaItemInner::MetaItem(meta_item) => meta_item,
-        MetaItemInner::Lit(MetaItemLit { kind: LitKind::Bool(b), .. }) => {
-            return *b;
-        }
-        _ => {
-            dcx.emit_err(session_diagnostics::UnsupportedLiteral {
-                span: cfg.span(),
-                reason: UnsupportedLiteralReason::CfgBoolean,
-                is_bytestr: false,
-                start_point_span: sess.source_map().start_point(cfg.span()),
+    let mut result = ThinVec::new();
+    for sub_item in list.mixed() {
+        // First, validate that this is a NameValue item
+        let Some(sub_item) = sub_item.meta_item() else {
+            cx.expected_name_value(sub_item.span(), None);
+            continue;
+        };
+        let Some(nv) = sub_item.args().name_value() else {
+            cx.expected_name_value(sub_item.span(), None);
+            continue;
+        };
+
+        // Then, parse it as a name-value item
+        let Some(name) = sub_item.path().word_sym() else {
+            cx.emit_err(session_diagnostics::CfgPredicateIdentifier {
+                span: sub_item.path().span(),
             });
-            return false;
+            return None;
+        };
+        let name = Symbol::intern(&format!("target_{name}"));
+        if let Some(cfg) =
+            parse_name_value(name, sub_item.path().span(), Some(nv), sub_item.span(), cx)
+        {
+            result.push(cfg);
+        }
+    }
+    Some(CfgEntry::All(result, list.span))
+}
+
+fn parse_name_value<S: Stage>(
+    name: Symbol,
+    name_span: Span,
+    value: Option<&NameValueParser>,
+    span: Span,
+    cx: &mut AcceptContext<'_, '_, S>,
+) -> Option<CfgEntry> {
+    try_gate_cfg(name, span, cx.sess(), cx.features_option());
+
+    let value = match value {
+        None => None,
+        Some(value) => {
+            let Some(value_str) = value.value_as_str() else {
+                cx.expected_string_literal(value.value_span, Some(value.value_as_lit()));
+                return None;
+            };
+            Some((value_str, value.value_span))
         }
     };
 
-    match &cfg.kind {
-        MetaItemKind::List(mis) if cfg.has_name(sym::version) => {
-            try_gate_cfg(sym::version, cfg.span, sess, features);
-            let (min_version, span) = match &mis[..] {
-                [MetaItemInner::Lit(MetaItemLit { kind: LitKind::Str(sym, ..), span, .. })] => {
-                    (sym, span)
-                }
-                [
-                    MetaItemInner::Lit(MetaItemLit { span, .. })
-                    | MetaItemInner::MetaItem(MetaItem { span, .. }),
-                ] => {
-                    dcx.emit_err(session_diagnostics::ExpectedVersionLiteral { span: *span });
-                    return false;
+    Some(CfgEntry::NameValue { name, name_span, value, span })
+}
+
+pub fn eval_config_entry(
+    sess: &Session,
+    cfg_entry: &CfgEntry,
+    id: NodeId,
+    features: Option<&Features>,
+) -> EvalConfigResult {
+    match cfg_entry {
+        CfgEntry::All(subs, ..) => {
+            let mut all = None;
+            for sub in subs {
+                let res = eval_config_entry(sess, sub, id, features);
+                // We cannot short-circuit because `eval_config_entry` emits some lints
+                if !res.as_bool() {
+                    all.get_or_insert(res);
                 }
-                [..] => {
-                    dcx.emit_err(session_diagnostics::ExpectedSingleVersionLiteral {
-                        span: cfg.span,
-                    });
-                    return false;
+            }
+            all.unwrap_or_else(|| EvalConfigResult::True)
+        }
+        CfgEntry::Any(subs, span) => {
+            let mut any = None;
+            for sub in subs {
+                let res = eval_config_entry(sess, sub, id, features);
+                // We cannot short-circuit because `eval_config_entry` emits some lints
+                if res.as_bool() {
+                    any.get_or_insert(res);
                 }
-            };
-            let Some(min_version) = parse_version(*min_version) else {
-                dcx.emit_warn(session_diagnostics::UnknownVersionLiteral { span: *span });
-                return false;
-            };
-
-            // See https://github.com/rust-lang/rust/issues/64796#issuecomment-640851454 for details
-            if sess.psess.assume_incomplete_release {
-                RustcVersion::current_overridable() > min_version
+            }
+            any.unwrap_or_else(|| EvalConfigResult::False {
+                reason: cfg_entry.clone(),
+                reason_span: *span,
+            })
+        }
+        CfgEntry::Not(sub, span) => {
+            if eval_config_entry(sess, sub, id, features).as_bool() {
+                EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
             } else {
-                RustcVersion::current_overridable() >= min_version
+                EvalConfigResult::True
             }
         }
-        MetaItemKind::List(mis) => {
-            for mi in mis.iter() {
-                if mi.meta_item_or_bool().is_none() {
-                    dcx.emit_err(session_diagnostics::UnsupportedLiteral {
-                        span: mi.span(),
-                        reason: UnsupportedLiteralReason::Generic,
-                        is_bytestr: false,
-                        start_point_span: sess.source_map().start_point(mi.span()),
-                    });
-                    return false;
-                }
+        CfgEntry::Bool(b, span) => {
+            if *b {
+                EvalConfigResult::True
+            } else {
+                EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
             }
-
-            // The unwraps below may look dangerous, but we've already asserted
-            // that they won't fail with the loop above.
-            match cfg.name() {
-                Some(sym::any) => mis
-                    .iter()
-                    // We don't use any() here, because we want to evaluate all cfg condition
-                    // as eval_condition can (and does) extra checks
-                    .fold(false, |res, mi| res | eval_condition(mi, sess, features, eval)),
-                Some(sym::all) => mis
-                    .iter()
-                    // We don't use all() here, because we want to evaluate all cfg condition
-                    // as eval_condition can (and does) extra checks
-                    .fold(true, |res, mi| res & eval_condition(mi, sess, features, eval)),
-                Some(sym::not) => {
-                    let [mi] = mis.as_slice() else {
-                        dcx.emit_err(session_diagnostics::ExpectedOneCfgPattern { span: cfg.span });
-                        return false;
-                    };
-
-                    !eval_condition(mi, sess, features, eval)
-                }
-                Some(sym::target) => {
-                    if let Some(features) = features
-                        && !features.cfg_target_compact()
-                    {
-                        feature_err(
-                            sess,
-                            sym::cfg_target_compact,
-                            cfg.span,
-                            fluent_generated::attr_parsing_unstable_cfg_target_compact,
-                        )
-                        .emit();
-                    }
-
-                    mis.iter().fold(true, |res, mi| {
-                        let Some(mut mi) = mi.meta_item().cloned() else {
-                            dcx.emit_err(session_diagnostics::CfgPredicateIdentifier {
-                                span: mi.span(),
-                            });
-                            return false;
-                        };
-
-                        if let [seg, ..] = &mut mi.path.segments[..] {
-                            seg.ident.name = Symbol::intern(&format!("target_{}", seg.ident.name));
-                        }
-
-                        res & eval_condition(&MetaItemInner::MetaItem(mi), sess, features, eval)
-                    })
+        }
+        CfgEntry::NameValue { name, name_span, value, span } => {
+            match sess.psess.check_config.expecteds.get(name) {
+                Some(ExpectedValues::Some(values)) if !values.contains(&value.map(|(v, _)| v)) => {
+                    id.emit_span_lint(
+                        sess,
+                        UNEXPECTED_CFGS,
+                        *span,
+                        BuiltinLintDiag::UnexpectedCfgValue((*name, *name_span), *value),
+                    );
                 }
-                _ => {
-                    dcx.emit_err(session_diagnostics::InvalidPredicate {
-                        span: cfg.span,
-                        predicate: pprust::path_to_string(&cfg.path),
-                    });
-                    false
+                None if sess.psess.check_config.exhaustive_names => {
+                    id.emit_span_lint(
+                        sess,
+                        UNEXPECTED_CFGS,
+                        *span,
+                        BuiltinLintDiag::UnexpectedCfgName((*name, *name_span), *value),
+                    );
                 }
+                _ => { /* not unexpected */ }
+            }
+
+            if sess.psess.config.contains(&(*name, value.map(|(v, _)| v))) {
+                EvalConfigResult::True
+            } else {
+                EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
             }
         }
-        MetaItemKind::Word | MetaItemKind::NameValue(..) if cfg.path.segments.len() != 1 => {
-            dcx.emit_err(session_diagnostics::CfgPredicateIdentifier { span: cfg.path.span });
-            true
-        }
-        MetaItemKind::NameValue(lit) if !lit.kind.is_str() => {
-            dcx.emit_err(session_diagnostics::UnsupportedLiteral {
-                span: lit.span,
-                reason: UnsupportedLiteralReason::CfgString,
-                is_bytestr: lit.kind.is_bytestr(),
-                start_point_span: sess.source_map().start_point(lit.span),
-            });
-            true
+        CfgEntry::Version(min_version, version_span) => {
+            let Some(min_version) = min_version else {
+                return EvalConfigResult::False {
+                    reason: cfg_entry.clone(),
+                    reason_span: *version_span,
+                };
+            };
+            // See https://github.com/rust-lang/rust/issues/64796#issuecomment-640851454 for details
+            let min_version_ok = if sess.psess.assume_incomplete_release {
+                RustcVersion::current_overridable() > *min_version
+            } else {
+                RustcVersion::current_overridable() >= *min_version
+            };
+            if min_version_ok {
+                EvalConfigResult::True
+            } else {
+                EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *version_span }
+            }
         }
-        MetaItemKind::Word | MetaItemKind::NameValue(..) => {
-            let ident = cfg.ident().expect("multi-segment cfg predicate");
-            eval(Condition {
-                name: ident.name,
-                name_span: ident.span,
-                value: cfg.value_str(),
-                value_span: cfg.name_value_literal_span(),
-                span: cfg.span,
-            })
+    }
+}
+
+pub enum EvalConfigResult {
+    True,
+    False { reason: CfgEntry, reason_span: Span },
+}
+
+impl EvalConfigResult {
+    pub fn as_bool(&self) -> bool {
+        match self {
+            EvalConfigResult::True => true,
+            EvalConfigResult::False { .. } => false,
         }
     }
 }
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
index 170ac39d1ec..6922ddfd6bd 100644
--- a/compiler/rustc_expand/src/config.rs
+++ b/compiler/rustc_expand/src/config.rs
@@ -11,6 +11,9 @@ use rustc_ast::{
     NodeId, NormalAttr,
 };
 use rustc_attr_parsing as attr;
+use rustc_attr_parsing::{
+    AttributeParser, CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg_attr,
+};
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_feature::{
     ACCEPTED_LANG_FEATURES, AttributeSafety, EnabledLangFeature, EnabledLibFeature, Features,
@@ -18,6 +21,7 @@ use rustc_feature::{
 };
 use rustc_lint_defs::BuiltinLintDiag;
 use rustc_parse::validate_attr;
+use rustc_parse::validate_attr::deny_builtin_meta_unsafety;
 use rustc_session::Session;
 use rustc_session::parse::feature_err;
 use rustc_span::{STDLIB_STABLE_CRATES, Span, Symbol, sym};
@@ -161,7 +165,10 @@ pub fn pre_configure_attrs(sess: &Session, attrs: &[Attribute]) -> ast::AttrVec
     attrs
         .iter()
         .flat_map(|attr| strip_unconfigured.process_cfg_attr(attr))
-        .take_while(|attr| !is_cfg(attr) || strip_unconfigured.cfg_true(attr).0)
+        .take_while(|attr| {
+            !is_cfg(attr)
+                || strip_unconfigured.cfg_true(attr, strip_unconfigured.lint_node_id).as_bool()
+        })
         .collect()
 }
 
@@ -394,26 +401,42 @@ impl<'a> StripUnconfigured<'a> {
 
     /// Determines if a node with the given attributes should be included in this configuration.
     fn in_cfg(&self, attrs: &[Attribute]) -> bool {
-        attrs.iter().all(|attr| !is_cfg(attr) || self.cfg_true(attr).0)
+        attrs.iter().all(|attr| !is_cfg(attr) || self.cfg_true(attr, self.lint_node_id).as_bool())
     }
 
-    pub(crate) fn cfg_true(&self, attr: &Attribute) -> (bool, Option<MetaItem>) {
-        let meta_item = match validate_attr::parse_meta(&self.sess.psess, attr) {
-            Ok(meta_item) => meta_item,
+    pub(crate) fn cfg_true(&self, attr: &Attribute, node: NodeId) -> EvalConfigResult {
+        // We need to run this to do basic validation of the attribute, such as that lits are valid, etc
+        // FIXME(jdonszelmann) this should not be necessary in the future
+        match validate_attr::parse_meta(&self.sess.psess, attr) {
+            Ok(_) => {}
             Err(err) => {
                 err.emit();
-                return (true, None);
+                return EvalConfigResult::True;
             }
-        };
+        }
 
-        validate_attr::deny_builtin_meta_unsafety(&self.sess.psess, &meta_item);
+        // Unsafety check needs to be done explicitly here because this attribute will be removed before the normal check
+        deny_builtin_meta_unsafety(
+            self.sess.dcx(),
+            attr.get_normal_item().unsafety,
+            &rustc_ast::Path::from_ident(attr.ident().unwrap()),
+        );
+
+        let Some(cfg) = AttributeParser::parse_single(
+            self.sess,
+            attr,
+            attr.span,
+            node,
+            self.features,
+            true,
+            parse_cfg_attr,
+            &CFG_TEMPLATE,
+        ) else {
+            // Cfg attribute was not parsable, give up
+            return EvalConfigResult::True;
+        };
 
-        (
-            parse_cfg(&meta_item, self.sess).is_none_or(|meta_item| {
-                attr::cfg_matches(meta_item, &self.sess, self.lint_node_id, self.features)
-            }),
-            Some(meta_item),
-        )
+        eval_config_entry(self.sess, &cfg, self.lint_node_id, self.features)
     }
 
     /// If attributes are not allowed on expressions, emit an error for `attr`
@@ -465,6 +488,7 @@ impl<'a> StripUnconfigured<'a> {
     }
 }
 
+/// FIXME: Still used by Rustdoc, should be removed after
 pub fn parse_cfg<'a>(meta_item: &'a MetaItem, sess: &Session) -> Option<&'a MetaItemInner> {
     let span = meta_item.span;
     match meta_item.meta_item_list() {
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index 2de09aa1a28..f99060e9a21 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -13,6 +13,7 @@ use rustc_ast::{
     MetaItemKind, ModKind, NodeId, PatKind, StmtKind, TyKind, token,
 };
 use rustc_ast_pretty::pprust;
+use rustc_attr_parsing::EvalConfigResult;
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_errors::PResult;
 use rustc_feature::Features;
@@ -2166,19 +2167,19 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
 
     fn expand_cfg_true(
         &mut self,
-        node: &mut impl HasAttrs,
+        node: &mut (impl HasAttrs + HasNodeId),
         attr: ast::Attribute,
         pos: usize,
-    ) -> (bool, Option<ast::MetaItem>) {
-        let (res, meta_item) = self.cfg().cfg_true(&attr);
-        if res {
+    ) -> EvalConfigResult {
+        let res = self.cfg().cfg_true(&attr, node.node_id());
+        if res.as_bool() {
             // A trace attribute left in AST in place of the original `cfg` attribute.
             // It can later be used by lints or other diagnostics.
             let trace_attr = attr_into_trace(attr, sym::cfg_trace);
             node.visit_attrs(|attrs| attrs.insert(pos, trace_attr));
         }
 
-        (res, meta_item)
+        res
     }
 
     fn expand_cfg_attr(&self, node: &mut impl HasAttrs, attr: &ast::Attribute, pos: usize) {
@@ -2199,20 +2200,21 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
             return match self.take_first_attr(&mut node) {
                 Some((attr, pos, derives)) => match attr.name() {
                     Some(sym::cfg) => {
-                        let (res, meta_item) = self.expand_cfg_true(&mut node, attr, pos);
-                        if res {
-                            continue;
-                        }
-
-                        if let Some(meta_item) = meta_item {
-                            for ident in node.declared_idents() {
-                                self.cx.resolver.append_stripped_cfg_item(
-                                    self.cx.current_expansion.lint_node_id,
-                                    ident,
-                                    meta_item.clone(),
-                                )
+                        let res = self.expand_cfg_true(&mut node, attr, pos);
+                        match res {
+                            EvalConfigResult::True => continue,
+                            EvalConfigResult::False { reason, reason_span } => {
+                                for ident in node.declared_idents() {
+                                    self.cx.resolver.append_stripped_cfg_item(
+                                        self.cx.current_expansion.lint_node_id,
+                                        ident,
+                                        reason.clone(),
+                                        reason_span,
+                                    )
+                                }
                             }
                         }
+
                         Default::default()
                     }
                     Some(sym::cfg_attr) => {
@@ -2291,7 +2293,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                 Some((attr, pos, derives)) => match attr.name() {
                     Some(sym::cfg) => {
                         let span = attr.span;
-                        if self.expand_cfg_true(node, attr, pos).0 {
+                        if self.expand_cfg_true(node, attr, pos).as_bool() {
                             continue;
                         }
 
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 5c748e956a0..e000d61083d 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -4,9 +4,9 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_ast::{
     self as ast, AttrArgs, Attribute, DelimArgs, MetaItem, MetaItemInner, MetaItemKind, NodeId,
-    Safety,
+    Path, Safety,
 };
-use rustc_errors::{Applicability, FatalError, PResult};
+use rustc_errors::{Applicability, DiagCtxtHandle, FatalError, PResult};
 use rustc_feature::{AttributeSafety, AttributeTemplate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute};
 use rustc_session::errors::report_lit_error;
 use rustc_session::lint::BuiltinLintDiag;
@@ -247,14 +247,12 @@ pub fn check_attribute_safety(
 
 // Called by `check_builtin_meta_item` and code that manually denies
 // `unsafe(...)` in `cfg`
-pub fn deny_builtin_meta_unsafety(psess: &ParseSess, meta: &MetaItem) {
+pub fn deny_builtin_meta_unsafety(diag: DiagCtxtHandle<'_>, unsafety: Safety, name: &Path) {
     // This only supports denying unsafety right now - making builtin attributes
     // support unsafety will requite us to thread the actual `Attribute` through
     // for the nice diagnostics.
-    if let Safety::Unsafe(unsafe_span) = meta.unsafety {
-        psess
-            .dcx()
-            .emit_err(errors::InvalidAttrUnsafe { span: unsafe_span, name: meta.path.clone() });
+    if let Safety::Unsafe(unsafe_span) = unsafety {
+        diag.emit_err(errors::InvalidAttrUnsafe { span: unsafe_span, name: name.clone() });
     }
 }
 
@@ -326,7 +324,7 @@ pub fn check_builtin_meta_item(
     }
 
     if deny_unsafety {
-        deny_builtin_meta_unsafety(psess, meta);
+        deny_builtin_meta_unsafety(psess.dcx(), meta.unsafety, &meta.path);
     }
 }
 
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index b2f16fb1dfb..93d848787ef 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1,11 +1,10 @@
-use rustc_ast::expand::StrippedCfgItem;
 use rustc_ast::ptr::P;
 use rustc_ast::visit::{self, Visitor};
-use rustc_ast::{
-    self as ast, CRATE_NODE_ID, Crate, ItemKind, MetaItemInner, MetaItemKind, ModKind, NodeId, Path,
-};
+use rustc_ast::{self as ast, CRATE_NODE_ID, Crate, ItemKind, ModKind, NodeId, Path};
 use rustc_ast_pretty::pprust;
-use rustc_attr_data_structures::{self as attr, AttributeKind, Stability, find_attr};
+use rustc_attr_data_structures::{
+    self as attr, AttributeKind, CfgEntry, Stability, StrippedCfgItem, find_attr,
+};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_errors::codes::*;
@@ -2860,17 +2859,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let note = errors::FoundItemConfigureOut { span: ident.span };
             err.subdiagnostic(note);
 
-            if let MetaItemKind::List(nested) = &cfg.kind
-                && let MetaItemInner::MetaItem(meta_item) = &nested[0]
-                && let MetaItemKind::NameValue(feature_name) = &meta_item.kind
-            {
-                let note = errors::ItemWasBehindFeature {
-                    feature: feature_name.symbol,
-                    span: meta_item.span,
-                };
+            if let CfgEntry::NameValue { value: Some((feature, _)), .. } = cfg.0 {
+                let note = errors::ItemWasBehindFeature { feature, span: cfg.1 };
                 err.subdiagnostic(note);
             } else {
-                let note = errors::ItemWasCfgOut { span: cfg.span };
+                let note = errors::ItemWasCfgOut { span: cfg.1 };
                 err.subdiagnostic(note);
             }
         }
-- 
cgit 1.4.1-3-g733a5


From c7f5ddc09871dc74c9f451435b042707eef5dc6c Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Mon, 7 Jul 2025 09:10:38 +0200
Subject: Changes to diagnostics

---
 .../rustc_attr_parsing/src/session_diagnostics.rs  |  8 ++-
 tests/ui/attributes/malformed-attrs.rs             |  2 +-
 tests/ui/attributes/malformed-attrs.stderr         |  7 ++-
 tests/ui/cfg/cfg-target-compact-errors.rs          | 12 +++--
 tests/ui/cfg/cfg-target-compact-errors.stderr      | 47 ++++++++++------
 tests/ui/cfg/cfg-version/syntax.stderr             |  4 +-
 tests/ui/cfg/diagnostics-cross-crate.stderr        | 12 ++---
 tests/ui/cfg/diagnostics-reexport-2.stderr         | 20 +++----
 tests/ui/cfg/diagnostics-reexport.stderr           | 16 +++---
 tests/ui/cfg/diagnostics-same-crate.stderr         | 16 +++---
 tests/ui/check-cfg/compact-names.rs                |  4 ++
 tests/ui/check-cfg/compact-names.stderr            | 11 +++-
 .../cfg-attr-syntax-validation.rs                  | 25 ++++++---
 .../cfg-attr-syntax-validation.stderr              | 63 ++++++++++++++--------
 tests/ui/macros/macro-outer-attributes.stderr      | 14 ++---
 15 files changed, 163 insertions(+), 98 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index 8a240639d75..97bf3d1c549 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -593,7 +593,13 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError {
                 diag.code(E0565);
             }
             AttributeParseErrorReason::ExpectedNameValue(None) => {
-                // The suggestion we add below this match already contains enough information
+                // If the span is the entire attribute, the suggestion we add below this match already contains enough information
+                if self.span != self.attr_span {
+                    diag.span_label(
+                        self.span,
+                        format!("expected this to be of the form `... = \"...\"`"),
+                    );
+                }
             }
             AttributeParseErrorReason::ExpectedNameValue(Some(name)) => {
                 diag.span_label(
diff --git a/tests/ui/attributes/malformed-attrs.rs b/tests/ui/attributes/malformed-attrs.rs
index aa52de63a60..5026687b97b 100644
--- a/tests/ui/attributes/malformed-attrs.rs
+++ b/tests/ui/attributes/malformed-attrs.rs
@@ -100,7 +100,7 @@
 //~^ ERROR malformed
 //~| ERROR the `#[proc_macro]` attribute is only usable with crates of the `proc-macro` crate type
 #[cfg]
-//~^ ERROR is not followed by parentheses
+//~^ ERROR malformed
 #[cfg_attr]
 //~^ ERROR malformed
 #[instruction_set]
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index 3dc3c32c936..56f2be353e7 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -1,8 +1,11 @@
-error: `cfg` is not followed by parentheses
+error[E0539]: malformed `cfg` attribute input
   --> $DIR/malformed-attrs.rs:102:1
    |
 LL | #[cfg]
-   | ^^^^^^ help: expected syntax is: `cfg(/* predicate */)`
+   | ^^^^^^
+   | |
+   | expected this to be a list
+   | help: must be of the form: `#[cfg(predicate)]`
 
 error: malformed `cfg_attr` attribute input
   --> $DIR/malformed-attrs.rs:104:1
diff --git a/tests/ui/cfg/cfg-target-compact-errors.rs b/tests/ui/cfg/cfg-target-compact-errors.rs
index e00d42fe4d9..cfb19c58a19 100644
--- a/tests/ui/cfg/cfg-target-compact-errors.rs
+++ b/tests/ui/cfg/cfg-target-compact-errors.rs
@@ -3,19 +3,23 @@
 #![feature(cfg_target_compact)]
 
 #[cfg(target(o::o))]
-//~^ ERROR `cfg` predicate key must be an identifier
+//~^ ERROR malformed `cfg` attribute input
 fn one() {}
 
 #[cfg(target(os = 8))]
-//~^ ERROR literal in `cfg` predicate value must be a string
+//~^ ERROR malformed `cfg` attribute input
 fn two() {}
 
 #[cfg(target(os = "linux", pointer(width = "64")))]
-//~^ ERROR invalid predicate `target_pointer`
+//~^ ERROR malformed `cfg` attribute input
 fn three() {}
 
 #[cfg(target(true))]
-//~^ ERROR `cfg` predicate key must be an identifier
+//~^ ERROR malformed `cfg` attribute input
 fn four() {}
 
+#[cfg(target(clippy::os = "linux"))]
+//~^ ERROR `cfg` predicate key must be an identifier
+fn five() {}
+
 fn main() {}
diff --git a/tests/ui/cfg/cfg-target-compact-errors.stderr b/tests/ui/cfg/cfg-target-compact-errors.stderr
index 219d9732c32..7df6729e881 100644
--- a/tests/ui/cfg/cfg-target-compact-errors.stderr
+++ b/tests/ui/cfg/cfg-target-compact-errors.stderr
@@ -1,28 +1,45 @@
-error: `cfg` predicate key must be an identifier
-  --> $DIR/cfg-target-compact-errors.rs:5:14
+error[E0539]: malformed `cfg` attribute input
+  --> $DIR/cfg-target-compact-errors.rs:5:1
    |
 LL | #[cfg(target(o::o))]
-   |              ^^^^
+   | ^^^^^^^^^^^^^----^^^
+   | |            |
+   | |            expected this to be of the form `... = "..."`
+   | help: must be of the form: `#[cfg(predicate)]`
 
-error[E0565]: literal in `cfg` predicate value must be a string
-  --> $DIR/cfg-target-compact-errors.rs:9:19
+error[E0539]: malformed `cfg` attribute input
+  --> $DIR/cfg-target-compact-errors.rs:9:1
    |
 LL | #[cfg(target(os = 8))]
-   |                   ^
+   | ^^^^^^^^^^^^^^^^^^-^^^
+   | |                 |
+   | |                 expected a string literal here
+   | help: must be of the form: `#[cfg(predicate)]`
 
-error[E0537]: invalid predicate `target_pointer`
-  --> $DIR/cfg-target-compact-errors.rs:13:28
+error[E0539]: malformed `cfg` attribute input
+  --> $DIR/cfg-target-compact-errors.rs:13:1
    |
 LL | #[cfg(target(os = "linux", pointer(width = "64")))]
-   |                            ^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------------^^^
+   | |                          |
+   | |                          expected this to be of the form `... = "..."`
+   | help: must be of the form: `#[cfg(predicate)]`
 
-error: `cfg` predicate key must be an identifier
-  --> $DIR/cfg-target-compact-errors.rs:17:14
+error[E0539]: malformed `cfg` attribute input
+  --> $DIR/cfg-target-compact-errors.rs:17:1
    |
 LL | #[cfg(target(true))]
-   |              ^^^^
+   | ^^^^^^^^^^^^^----^^^
+   | |            |
+   | |            expected this to be of the form `... = "..."`
+   | help: must be of the form: `#[cfg(predicate)]`
+
+error: `cfg` predicate key must be an identifier
+  --> $DIR/cfg-target-compact-errors.rs:21:14
+   |
+LL | #[cfg(target(clippy::os = "linux"))]
+   |              ^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-Some errors have detailed explanations: E0537, E0565.
-For more information about an error, try `rustc --explain E0537`.
+For more information about this error, try `rustc --explain E0539`.
diff --git a/tests/ui/cfg/cfg-version/syntax.stderr b/tests/ui/cfg/cfg-version/syntax.stderr
index 2facd960763..188f6d7aa5d 100644
--- a/tests/ui/cfg/cfg-version/syntax.stderr
+++ b/tests/ui/cfg/cfg-version/syntax.stderr
@@ -17,10 +17,10 @@ LL | #[cfg(version(false))]
    |               ^^^^^
 
 error: expected single version literal
-  --> $DIR/syntax.rs:23:7
+  --> $DIR/syntax.rs:23:14
    |
 LL | #[cfg(version("1.43", "1.44", "1.45"))]
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: unknown version literal format, assuming it refers to a future version
   --> $DIR/syntax.rs:51:15
diff --git a/tests/ui/cfg/diagnostics-cross-crate.stderr b/tests/ui/cfg/diagnostics-cross-crate.stderr
index 3e32a856e95..155b3db2f42 100644
--- a/tests/ui/cfg/diagnostics-cross-crate.stderr
+++ b/tests/ui/cfg/diagnostics-cross-crate.stderr
@@ -10,10 +10,10 @@ note: found an item that was configured out
 LL |     pub mod doesnt_exist {
    |             ^^^^^^^^^^^^
 note: the item is gated here
-  --> $DIR/auxiliary/cfged_out.rs:5:5
+  --> $DIR/auxiliary/cfged_out.rs:5:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0425]: cannot find function `uwu` in crate `cfged_out`
   --> $DIR/diagnostics-cross-crate.rs:7:16
@@ -33,10 +33,10 @@ note: found an item that was configured out
 LL |     pub fn uwu() {}
    |            ^^^
 note: the item is gated here
-  --> $DIR/auxiliary/cfged_out.rs:2:5
+  --> $DIR/auxiliary/cfged_out.rs:2:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0425]: cannot find function `meow` in module `cfged_out::inner::right`
   --> $DIR/diagnostics-cross-crate.rs:24:30
@@ -67,10 +67,10 @@ note: found an item that was configured out
 LL | pub fn vanished() {}
    |        ^^^^^^^^
 note: the item is gated here
-  --> $DIR/auxiliary/cfged_out.rs:21:1
+  --> $DIR/auxiliary/cfged_out.rs:21:7
    |
 LL | #[cfg(i_dont_exist_and_you_can_do_nothing_about_it)]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/cfg/diagnostics-reexport-2.stderr b/tests/ui/cfg/diagnostics-reexport-2.stderr
index 95ac5a19b0b..e1f91fcc5d1 100644
--- a/tests/ui/cfg/diagnostics-reexport-2.stderr
+++ b/tests/ui/cfg/diagnostics-reexport-2.stderr
@@ -10,10 +10,10 @@ note: found an item that was configured out
 LL |     pub mod gated {
    |             ^^^^^
 note: the item is gated here
-  --> $DIR/diagnostics-reexport-2.rs:4:5
+  --> $DIR/diagnostics-reexport-2.rs:4:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0433]: failed to resolve: could not find `gated` in `reexport2`
   --> $DIR/diagnostics-reexport-2.rs:46:16
@@ -27,10 +27,10 @@ note: found an item that was configured out
 LL |     pub mod gated {
    |             ^^^^^
 note: the item is gated here
-  --> $DIR/diagnostics-reexport-2.rs:4:5
+  --> $DIR/diagnostics-reexport-2.rs:4:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0433]: failed to resolve: could not find `gated` in `reexport30`
   --> $DIR/diagnostics-reexport-2.rs:50:17
@@ -44,10 +44,10 @@ note: found an item that was configured out
 LL |     pub mod gated {
    |             ^^^^^
 note: the item is gated here
-  --> $DIR/diagnostics-reexport-2.rs:4:5
+  --> $DIR/diagnostics-reexport-2.rs:4:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0433]: failed to resolve: could not find `gated` in `reexport31`
   --> $DIR/diagnostics-reexport-2.rs:54:17
@@ -61,10 +61,10 @@ note: found an item that was configured out
 LL |     pub mod gated {
    |             ^^^^^
 note: the item is gated here
-  --> $DIR/diagnostics-reexport-2.rs:4:5
+  --> $DIR/diagnostics-reexport-2.rs:4:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0433]: failed to resolve: could not find `gated` in `reexport32`
   --> $DIR/diagnostics-reexport-2.rs:58:17
@@ -78,10 +78,10 @@ note: found an item that was configured out
 LL |     pub mod gated {
    |             ^^^^^
 note: the item is gated here
-  --> $DIR/diagnostics-reexport-2.rs:4:5
+  --> $DIR/diagnostics-reexport-2.rs:4:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/cfg/diagnostics-reexport.stderr b/tests/ui/cfg/diagnostics-reexport.stderr
index 95dc4fac945..bf1bbcba7e4 100644
--- a/tests/ui/cfg/diagnostics-reexport.stderr
+++ b/tests/ui/cfg/diagnostics-reexport.stderr
@@ -10,10 +10,10 @@ note: found an item that was configured out
 LL |     pub fn x() {}
    |            ^
 note: the item is gated here
-  --> $DIR/diagnostics-reexport.rs:17:5
+  --> $DIR/diagnostics-reexport.rs:17:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0432]: unresolved imports `b::x`, `b::y`
   --> $DIR/diagnostics-reexport.rs:22:13
@@ -29,20 +29,20 @@ note: found an item that was configured out
 LL |     pub fn x() {}
    |            ^
 note: the item is gated here
-  --> $DIR/diagnostics-reexport.rs:28:5
+  --> $DIR/diagnostics-reexport.rs:28:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 note: found an item that was configured out
   --> $DIR/diagnostics-reexport.rs:32:12
    |
 LL |     pub fn y() {}
    |            ^
 note: the item is gated here
-  --> $DIR/diagnostics-reexport.rs:31:5
+  --> $DIR/diagnostics-reexport.rs:31:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0425]: cannot find function `uwu` in module `inner`
   --> $DIR/diagnostics-reexport.rs:38:12
@@ -56,10 +56,10 @@ note: found an item that was configured out
 LL |     pub use super::uwu;
    |                    ^^^
 note: the item is gated here
-  --> $DIR/diagnostics-reexport.rs:7:5
+  --> $DIR/diagnostics-reexport.rs:7:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/cfg/diagnostics-same-crate.stderr b/tests/ui/cfg/diagnostics-same-crate.stderr
index 75a1bc39a01..121f25ca090 100644
--- a/tests/ui/cfg/diagnostics-same-crate.stderr
+++ b/tests/ui/cfg/diagnostics-same-crate.stderr
@@ -10,10 +10,10 @@ note: found an item that was configured out
 LL |     pub mod doesnt_exist {
    |             ^^^^^^^^^^^^
 note: the item is gated here
-  --> $DIR/diagnostics-same-crate.rs:8:5
+  --> $DIR/diagnostics-same-crate.rs:8:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0432]: unresolved import `super::inner::doesnt_exist`
   --> $DIR/diagnostics-same-crate.rs:35:23
@@ -27,10 +27,10 @@ note: found an item that was configured out
 LL |     pub mod doesnt_exist {
    |             ^^^^^^^^^^^^
 note: the item is gated here
-  --> $DIR/diagnostics-same-crate.rs:8:5
+  --> $DIR/diagnostics-same-crate.rs:8:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0433]: failed to resolve: could not find `doesnt_exist` in `inner`
   --> $DIR/diagnostics-same-crate.rs:54:12
@@ -44,10 +44,10 @@ note: found an item that was configured out
 LL |     pub mod doesnt_exist {
    |             ^^^^^^^^^^^^
 note: the item is gated here
-  --> $DIR/diagnostics-same-crate.rs:8:5
+  --> $DIR/diagnostics-same-crate.rs:8:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0425]: cannot find function `uwu` in module `inner`
   --> $DIR/diagnostics-same-crate.rs:49:12
@@ -61,10 +61,10 @@ note: found an item that was configured out
 LL |     pub fn uwu() {}
    |            ^^^
 note: the item is gated here
-  --> $DIR/diagnostics-same-crate.rs:4:5
+  --> $DIR/diagnostics-same-crate.rs:4:11
    |
 LL |     #[cfg(false)]
-   |     ^^^^^^^^^^^^^
+   |           ^^^^^
 
 error[E0425]: cannot find function `meow` in module `inner::right`
   --> $DIR/diagnostics-same-crate.rs:58:19
diff --git a/tests/ui/check-cfg/compact-names.rs b/tests/ui/check-cfg/compact-names.rs
index 931afdf986f..fbf8f9d2002 100644
--- a/tests/ui/check-cfg/compact-names.rs
+++ b/tests/ui/check-cfg/compact-names.rs
@@ -13,4 +13,8 @@ pub fn expected() {}
 //~^ WARNING unexpected `cfg` condition name
 pub fn unexpected() {}
 
+#[cfg(target(os = "windows", architecture = "arm"))]
+//~^ WARNING unexpected `cfg` condition name
+pub fn unexpected2() {}
+
 fn main() {}
diff --git a/tests/ui/check-cfg/compact-names.stderr b/tests/ui/check-cfg/compact-names.stderr
index 74ed0337e3b..3221b4e07ec 100644
--- a/tests/ui/check-cfg/compact-names.stderr
+++ b/tests/ui/check-cfg/compact-names.stderr
@@ -8,5 +8,14 @@ LL | #[cfg(target(os = "linux", architecture = "arm"))]
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
    = note: `#[warn(unexpected_cfgs)]` on by default
 
-warning: 1 warning emitted
+warning: unexpected `cfg` condition name: `target_architecture`
+  --> $DIR/compact-names.rs:16:30
+   |
+LL | #[cfg(target(os = "windows", architecture = "arm"))]
+   |                              ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: to expect this configuration use `--check-cfg=cfg(target_architecture, values("arm"))`
+   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
+
+warning: 2 warnings emitted
 
diff --git a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs
index 47418b4e091..df87a3d846e 100644
--- a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs
+++ b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs
@@ -1,16 +1,24 @@
-#[cfg] //~ ERROR `cfg` is not followed by parentheses
+#[cfg]
+//~^ ERROR malformed `cfg` attribute
+//~| NOTE expected this to be a list
 struct S1;
 
-#[cfg = 10] //~ ERROR `cfg` is not followed by parentheses
+#[cfg = 10]
+//~^ ERROR malformed `cfg` attribute
+//~| NOTE expected this to be a list
 struct S2;
 
-#[cfg()] //~ ERROR `cfg` predicate is not specified
+#[cfg()]
+//~^ ERROR malformed `cfg` attribute
+//~| NOTE expected a single argument here
 struct S3;
 
-#[cfg(a, b)] //~ ERROR multiple `cfg` predicates are specified
+#[cfg(a, b)]
+//~^ ERROR malformed `cfg` attribute
+//~| NOTE expected a single argument here
 struct S4;
 
-#[cfg("str")] //~ ERROR `cfg` predicate key cannot be a literal
+#[cfg("str")] //~ ERROR `cfg` predicate key must be an identifier
 struct S5;
 
 #[cfg(a::b)] //~ ERROR `cfg` predicate key must be an identifier
@@ -19,10 +27,12 @@ struct S6;
 #[cfg(a())] //~ ERROR invalid predicate `a`
 struct S7;
 
-#[cfg(a = 10)] //~ ERROR literal in `cfg` predicate value must be a string
+#[cfg(a = 10)] //~ ERROR malformed `cfg` attribute input
+//~^ NOTE expected a string literal here
 struct S8;
 
-#[cfg(a = b"hi")]  //~ ERROR literal in `cfg` predicate value must be a string
+#[cfg(a = b"hi")]  //~ ERROR malformed `cfg` attribute input
+//~^ NOTE expected a normal string literal, not a byte string literal
 struct S9;
 
 macro_rules! generate_s10 {
@@ -34,5 +44,6 @@ macro_rules! generate_s10 {
 }
 
 generate_s10!(concat!("nonexistent"));
+//~^ NOTE in this expansion of generate_s10!
 
 fn main() {}
diff --git a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr
index 66ce2ee9858..75e9b9209c0 100644
--- a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr
+++ b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr
@@ -1,61 +1,78 @@
-error: `cfg` is not followed by parentheses
+error[E0539]: malformed `cfg` attribute input
   --> $DIR/cfg-attr-syntax-validation.rs:1:1
    |
 LL | #[cfg]
-   | ^^^^^^ help: expected syntax is: `cfg(/* predicate */)`
+   | ^^^^^^
+   | |
+   | expected this to be a list
+   | help: must be of the form: `#[cfg(predicate)]`
 
-error: `cfg` is not followed by parentheses
-  --> $DIR/cfg-attr-syntax-validation.rs:4:1
+error[E0539]: malformed `cfg` attribute input
+  --> $DIR/cfg-attr-syntax-validation.rs:6:1
    |
 LL | #[cfg = 10]
-   | ^^^^^^^^^^^ help: expected syntax is: `cfg(/* predicate */)`
+   | ^^^^^^^^^^^
+   | |
+   | expected this to be a list
+   | help: must be of the form: `#[cfg(predicate)]`
 
-error: `cfg` predicate is not specified
-  --> $DIR/cfg-attr-syntax-validation.rs:7:1
+error[E0805]: malformed `cfg` attribute input
+  --> $DIR/cfg-attr-syntax-validation.rs:11:1
    |
 LL | #[cfg()]
-   | ^^^^^^^^ help: expected syntax is: `cfg(/* predicate */)`
+   | ^^^^^--^
+   | |    |
+   | |    expected a single argument here
+   | help: must be of the form: `#[cfg(predicate)]`
 
-error: multiple `cfg` predicates are specified
-  --> $DIR/cfg-attr-syntax-validation.rs:10:10
+error[E0805]: malformed `cfg` attribute input
+  --> $DIR/cfg-attr-syntax-validation.rs:16:1
    |
 LL | #[cfg(a, b)]
-   |          ^
+   | ^^^^^------^
+   | |    |
+   | |    expected a single argument here
+   | help: must be of the form: `#[cfg(predicate)]`
 
-error: `cfg` predicate key cannot be a literal
-  --> $DIR/cfg-attr-syntax-validation.rs:13:7
+error: `cfg` predicate key must be an identifier
+  --> $DIR/cfg-attr-syntax-validation.rs:21:7
    |
 LL | #[cfg("str")]
    |       ^^^^^
 
 error: `cfg` predicate key must be an identifier
-  --> $DIR/cfg-attr-syntax-validation.rs:16:7
+  --> $DIR/cfg-attr-syntax-validation.rs:24:7
    |
 LL | #[cfg(a::b)]
    |       ^^^^
 
 error[E0537]: invalid predicate `a`
-  --> $DIR/cfg-attr-syntax-validation.rs:19:7
+  --> $DIR/cfg-attr-syntax-validation.rs:27:7
    |
 LL | #[cfg(a())]
    |       ^^^
 
-error[E0565]: literal in `cfg` predicate value must be a string
-  --> $DIR/cfg-attr-syntax-validation.rs:22:11
+error[E0539]: malformed `cfg` attribute input
+  --> $DIR/cfg-attr-syntax-validation.rs:30:1
    |
 LL | #[cfg(a = 10)]
-   |           ^^
+   | ^^^^^^^^^^--^^
+   | |         |
+   | |         expected a string literal here
+   | help: must be of the form: `#[cfg(predicate)]`
 
-error[E0565]: literal in `cfg` predicate value must be a string
-  --> $DIR/cfg-attr-syntax-validation.rs:25:11
+error[E0539]: malformed `cfg` attribute input
+  --> $DIR/cfg-attr-syntax-validation.rs:34:1
    |
 LL | #[cfg(a = b"hi")]
-   |           -^^^^
+   | ^^^^^^^^^^-^^^^^^
    |           |
    |           help: consider removing the prefix
+   |
+   = note: expected a normal string literal, not a byte string literal
 
 error: expected unsuffixed literal, found `expr` metavariable
-  --> $DIR/cfg-attr-syntax-validation.rs:30:25
+  --> $DIR/cfg-attr-syntax-validation.rs:40:25
    |
 LL |         #[cfg(feature = $expr)]
    |                         ^^^^^
@@ -67,5 +84,5 @@ LL | generate_s10!(concat!("nonexistent"));
 
 error: aborting due to 10 previous errors
 
-Some errors have detailed explanations: E0537, E0565.
+Some errors have detailed explanations: E0537, E0539, E0805.
 For more information about an error, try `rustc --explain E0537`.
diff --git a/tests/ui/macros/macro-outer-attributes.stderr b/tests/ui/macros/macro-outer-attributes.stderr
index a894c90f4c3..9215754d4bb 100644
--- a/tests/ui/macros/macro-outer-attributes.stderr
+++ b/tests/ui/macros/macro-outer-attributes.stderr
@@ -10,16 +10,10 @@ note: found an item that was configured out
 LL |       pub fn bar() { });
    |              ^^^
 note: the item is gated here
-  --> $DIR/macro-outer-attributes.rs:5:45
-   |
-LL |                        $i:item) => (mod $nm { #[$a] $i }); }
-   |                                               ^^^^^
-LL |
-LL | / test!(a,
-LL | |       #[cfg(false)],
-LL | |       pub fn bar() { });
-   | |_______________________- in this macro invocation
-   = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
+  --> $DIR/macro-outer-attributes.rs:8:13
+   |
+LL |       #[cfg(false)],
+   |             ^^^^^
 help: consider importing this function
    |
 LL + use b::bar;
-- 
cgit 1.4.1-3-g733a5


From 7a7c74ad89df9f87824fa17fbbe0448d9ab6f7cc Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Mon, 7 Jul 2025 09:10:54 +0200
Subject: New example for E0536

---
 compiler/rustc_error_codes/src/error_codes/E0536.md | 16 +++++++---------
 tests/ui/span/E0536.rs                              |  7 +++----
 tests/ui/span/E0536.stderr                          |  6 +++---
 3 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_error_codes/src/error_codes/E0536.md b/compiler/rustc_error_codes/src/error_codes/E0536.md
index c081a3d9cfa..f00d1773944 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0536.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0536.md
@@ -3,22 +3,20 @@ The `not` cfg-predicate was malformed.
 Erroneous code example:
 
 ```compile_fail,E0536
-#[cfg(not())] // error: expected 1 cfg-pattern
-pub fn something() {}
-
-pub fn main() {}
+pub fn main() {
+    if cfg!(not()) { }
+}
 ```
 
 The `not` predicate expects one cfg-pattern. Example:
 
 ```
-#[cfg(not(target_os = "linux"))] // ok!
-pub fn something() {}
-
-pub fn main() {}
+pub fn main() {
+    if cfg!(not(target_os = "linux")) { } // ok!
+}
 ```
 
-For more information about the `cfg` attribute, read the section on
+For more information about the `cfg` macro, read the section on
 [Conditional Compilation][conditional-compilation] in the Reference.
 
 [conditional-compilation]: https://doc.rust-lang.org/reference/conditional-compilation.html
diff --git a/tests/ui/span/E0536.rs b/tests/ui/span/E0536.rs
index 72de7b6f453..ae073363354 100644
--- a/tests/ui/span/E0536.rs
+++ b/tests/ui/span/E0536.rs
@@ -1,4 +1,3 @@
-#[cfg(not())] //~ ERROR E0536
-pub fn something() {}
-
-pub fn main() {}
+pub fn main() {
+    if cfg!(not()) { } //~ ERROR E0536
+}
diff --git a/tests/ui/span/E0536.stderr b/tests/ui/span/E0536.stderr
index b0f652208c4..6c25f9140a1 100644
--- a/tests/ui/span/E0536.stderr
+++ b/tests/ui/span/E0536.stderr
@@ -1,8 +1,8 @@
 error[E0536]: expected 1 cfg-pattern
-  --> $DIR/E0536.rs:1:7
+  --> $DIR/E0536.rs:2:13
    |
-LL | #[cfg(not())]
-   |       ^^^^^
+LL |     if cfg!(not()) { }
+   |             ^^^^^
 
 error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From b5230e53604f1227a087397e561e1cd2329f59b6 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Fri, 11 Jul 2025 08:06:42 +0000
Subject: constify `SliceIndex` trait

---
 library/core/src/range.rs       | 16 +++++++++++-----
 library/core/src/slice/index.rs | 35 ++++++++++++++++++++++++-----------
 library/core/src/str/traits.rs  | 27 ++++++++++++++++++---------
 3 files changed, 53 insertions(+), 25 deletions(-)

diff --git a/library/core/src/range.rs b/library/core/src/range.rs
index 2276112a27b..5cd7956291c 100644
--- a/library/core/src/range.rs
+++ b/library/core/src/range.rs
@@ -186,14 +186,17 @@ impl<T> IntoBounds<T> for Range<T> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> From<Range<T>> for legacy::Range<T> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<T> const From<Range<T>> for legacy::Range<T> {
     #[inline]
     fn from(value: Range<T>) -> Self {
         Self { start: value.start, end: value.end }
     }
 }
+
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> From<legacy::Range<T>> for Range<T> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<T> const From<legacy::Range<T>> for Range<T> {
     #[inline]
     fn from(value: legacy::Range<T>) -> Self {
         Self { start: value.start, end: value.end }
@@ -362,7 +365,8 @@ impl<T> IntoBounds<T> for RangeInclusive<T> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> From<RangeInclusive<T>> for legacy::RangeInclusive<T> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<T> const From<RangeInclusive<T>> for legacy::RangeInclusive<T> {
     #[inline]
     fn from(value: RangeInclusive<T>) -> Self {
         Self::new(value.start, value.end)
@@ -506,14 +510,16 @@ impl<T> IntoBounds<T> for RangeFrom<T> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> From<RangeFrom<T>> for legacy::RangeFrom<T> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<T> const From<RangeFrom<T>> for legacy::RangeFrom<T> {
     #[inline]
     fn from(value: RangeFrom<T>) -> Self {
         Self { start: value.start }
     }
 }
 #[unstable(feature = "new_range_api", issue = "125687")]
-impl<T> From<legacy::RangeFrom<T>> for RangeFrom<T> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<T> const From<legacy::RangeFrom<T>> for RangeFrom<T> {
     #[inline]
     fn from(value: legacy::RangeFrom<T>) -> Self {
         Self { start: value.start }
diff --git a/library/core/src/slice/index.rs b/library/core/src/slice/index.rs
index f725c3fdd94..c9b8e9c71b4 100644
--- a/library/core/src/slice/index.rs
+++ b/library/core/src/slice/index.rs
@@ -158,6 +158,8 @@ mod private_slice_index {
     message = "the type `{T}` cannot be indexed by `{Self}`",
     label = "slice indices are of type `usize` or ranges of `usize`"
 )]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
 pub unsafe trait SliceIndex<T: ?Sized>: private_slice_index::Sealed {
     /// The output type returned by methods.
     #[stable(feature = "slice_get_slice", since = "1.28.0")]
@@ -208,7 +210,8 @@ pub unsafe trait SliceIndex<T: ?Sized>: private_slice_index::Sealed {
 
 /// The methods `index` and `index_mut` panic if the index is out of bounds.
 #[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
-unsafe impl<T> SliceIndex<[T]> for usize {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for usize {
     type Output = T;
 
     #[inline]
@@ -278,7 +281,8 @@ unsafe impl<T> SliceIndex<[T]> for usize {
 
 /// Because `IndexRange` guarantees `start <= end`, fewer checks are needed here
 /// than there are for a general `Range<usize>` (which might be `100..3`).
-unsafe impl<T> SliceIndex<[T]> for ops::IndexRange {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for ops::IndexRange {
     type Output = [T];
 
     #[inline]
@@ -354,7 +358,8 @@ unsafe impl<T> SliceIndex<[T]> for ops::IndexRange {
 /// - the start of the range is greater than the end of the range or
 /// - the end of the range is out of bounds.
 #[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
-unsafe impl<T> SliceIndex<[T]> for ops::Range<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for ops::Range<usize> {
     type Output = [T];
 
     #[inline]
@@ -453,7 +458,8 @@ unsafe impl<T> SliceIndex<[T]> for ops::Range<usize> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-unsafe impl<T> SliceIndex<[T]> for range::Range<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for range::Range<usize> {
     type Output = [T];
 
     #[inline]
@@ -491,7 +497,8 @@ unsafe impl<T> SliceIndex<[T]> for range::Range<usize> {
 
 /// The methods `index` and `index_mut` panic if the end of the range is out of bounds.
 #[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
-unsafe impl<T> SliceIndex<[T]> for ops::RangeTo<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for ops::RangeTo<usize> {
     type Output = [T];
 
     #[inline]
@@ -529,7 +536,8 @@ unsafe impl<T> SliceIndex<[T]> for ops::RangeTo<usize> {
 
 /// The methods `index` and `index_mut` panic if the start of the range is out of bounds.
 #[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
-unsafe impl<T> SliceIndex<[T]> for ops::RangeFrom<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for ops::RangeFrom<usize> {
     type Output = [T];
 
     #[inline]
@@ -574,7 +582,8 @@ unsafe impl<T> SliceIndex<[T]> for ops::RangeFrom<usize> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-unsafe impl<T> SliceIndex<[T]> for range::RangeFrom<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for range::RangeFrom<usize> {
     type Output = [T];
 
     #[inline]
@@ -611,7 +620,8 @@ unsafe impl<T> SliceIndex<[T]> for range::RangeFrom<usize> {
 }
 
 #[stable(feature = "slice_get_slice_impls", since = "1.15.0")]
-unsafe impl<T> SliceIndex<[T]> for ops::RangeFull {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for ops::RangeFull {
     type Output = [T];
 
     #[inline]
@@ -650,7 +660,8 @@ unsafe impl<T> SliceIndex<[T]> for ops::RangeFull {
 /// - the start of the range is greater than the end of the range or
 /// - the end of the range is out of bounds.
 #[stable(feature = "inclusive_range", since = "1.26.0")]
-unsafe impl<T> SliceIndex<[T]> for ops::RangeInclusive<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for ops::RangeInclusive<usize> {
     type Output = [T];
 
     #[inline]
@@ -693,7 +704,8 @@ unsafe impl<T> SliceIndex<[T]> for ops::RangeInclusive<usize> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-unsafe impl<T> SliceIndex<[T]> for range::RangeInclusive<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for range::RangeInclusive<usize> {
     type Output = [T];
 
     #[inline]
@@ -731,7 +743,8 @@ unsafe impl<T> SliceIndex<[T]> for range::RangeInclusive<usize> {
 
 /// The methods `index` and `index_mut` panic if the end of the range is out of bounds.
 #[stable(feature = "inclusive_range", since = "1.26.0")]
-unsafe impl<T> SliceIndex<[T]> for ops::RangeToInclusive<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl<T> const SliceIndex<[T]> for ops::RangeToInclusive<usize> {
     type Output = [T];
 
     #[inline]
diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs
index b9559c83171..2ed5e686399 100644
--- a/library/core/src/str/traits.rs
+++ b/library/core/src/str/traits.rs
@@ -92,7 +92,8 @@ const fn str_index_overflow_fail() -> ! {
 ///
 /// Equivalent to `&self[0 .. len]` or `&mut self[0 .. len]`.
 #[stable(feature = "str_checked_slicing", since = "1.20.0")]
-unsafe impl SliceIndex<str> for ops::RangeFull {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl const SliceIndex<str> for ops::RangeFull {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
@@ -156,7 +157,8 @@ unsafe impl SliceIndex<str> for ops::RangeFull {
 /// // &s[3 .. 100];
 /// ```
 #[stable(feature = "str_checked_slicing", since = "1.20.0")]
-unsafe impl SliceIndex<str> for ops::Range<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl const SliceIndex<str> for ops::Range<usize> {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
@@ -260,7 +262,8 @@ unsafe impl SliceIndex<str> for ops::Range<usize> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-unsafe impl SliceIndex<str> for range::Range<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl const SliceIndex<str> for range::Range<usize> {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
@@ -431,7 +434,8 @@ unsafe impl SliceIndex<str> for (ops::Bound<usize>, ops::Bound<usize>) {
 /// Panics if `end` does not point to the starting byte offset of a
 /// character (as defined by `is_char_boundary`), or if `end > len`.
 #[stable(feature = "str_checked_slicing", since = "1.20.0")]
-unsafe impl SliceIndex<str> for ops::RangeTo<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl const SliceIndex<str> for ops::RangeTo<usize> {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
@@ -499,7 +503,8 @@ unsafe impl SliceIndex<str> for ops::RangeTo<usize> {
 /// Panics if `begin` does not point to the starting byte offset of
 /// a character (as defined by `is_char_boundary`), or if `begin > len`.
 #[stable(feature = "str_checked_slicing", since = "1.20.0")]
-unsafe impl SliceIndex<str> for ops::RangeFrom<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl const SliceIndex<str> for ops::RangeFrom<usize> {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
@@ -554,7 +559,8 @@ unsafe impl SliceIndex<str> for ops::RangeFrom<usize> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-unsafe impl SliceIndex<str> for range::RangeFrom<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl const SliceIndex<str> for range::RangeFrom<usize> {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
@@ -625,7 +631,8 @@ unsafe impl SliceIndex<str> for range::RangeFrom<usize> {
 /// to the ending byte offset of a character (`end + 1` is either a starting
 /// byte offset or equal to `len`), if `begin > end`, or if `end >= len`.
 #[stable(feature = "inclusive_range", since = "1.26.0")]
-unsafe impl SliceIndex<str> for ops::RangeInclusive<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl const SliceIndex<str> for ops::RangeInclusive<usize> {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
@@ -662,7 +669,8 @@ unsafe impl SliceIndex<str> for ops::RangeInclusive<usize> {
 }
 
 #[unstable(feature = "new_range_api", issue = "125687")]
-unsafe impl SliceIndex<str> for range::RangeInclusive<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl const SliceIndex<str> for range::RangeInclusive<usize> {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
@@ -713,7 +721,8 @@ unsafe impl SliceIndex<str> for range::RangeInclusive<usize> {
 /// (`end + 1` is either a starting byte offset as defined by
 /// `is_char_boundary`, or equal to `len`), or if `end >= len`.
 #[stable(feature = "inclusive_range", since = "1.26.0")]
-unsafe impl SliceIndex<str> for ops::RangeToInclusive<usize> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+unsafe impl const SliceIndex<str> for ops::RangeToInclusive<usize> {
     type Output = str;
     #[inline]
     fn get(self, slice: &str) -> Option<&Self::Output> {
-- 
cgit 1.4.1-3-g733a5


From cb7d52f6430922b5ffd29073f6605b19b80e7f36 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Fri, 11 Jul 2025 08:37:09 +0000
Subject: constify some methods using `SliceIndex`

---
 library/core/src/ptr/const_ptr.rs                    |  5 +++--
 library/core/src/ptr/mut_ptr.rs                      |  5 +++--
 library/core/src/ptr/non_null.rs                     |  5 +++--
 library/core/src/slice/mod.rs                        | 20 ++++++++++++--------
 library/core/src/str/mod.rs                          |  6 ++++--
 tests/ui/consts/const-eval/ub-slice-get-unchecked.rs |  3 ++-
 .../consts/const-eval/ub-slice-get-unchecked.stderr  | 12 ++++++------
 7 files changed, 33 insertions(+), 23 deletions(-)

diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs
index 27b0c6830db..2ad520b7ead 100644
--- a/library/core/src/ptr/const_ptr.rs
+++ b/library/core/src/ptr/const_ptr.rs
@@ -1524,10 +1524,11 @@ impl<T> *const [T] {
     /// }
     /// ```
     #[unstable(feature = "slice_ptr_get", issue = "74265")]
+    #[rustc_const_unstable(feature = "const_index", issue = "143775")]
     #[inline]
-    pub unsafe fn get_unchecked<I>(self, index: I) -> *const I::Output
+    pub const unsafe fn get_unchecked<I>(self, index: I) -> *const I::Output
     where
-        I: SliceIndex<[T]>,
+        I: ~const SliceIndex<[T]>,
     {
         // SAFETY: the caller ensures that `self` is dereferenceable and `index` in-bounds.
         unsafe { index.get_unchecked(self) }
diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs
index 73efdf04454..579e2461103 100644
--- a/library/core/src/ptr/mut_ptr.rs
+++ b/library/core/src/ptr/mut_ptr.rs
@@ -1881,10 +1881,11 @@ impl<T> *mut [T] {
     /// }
     /// ```
     #[unstable(feature = "slice_ptr_get", issue = "74265")]
+    #[rustc_const_unstable(feature = "const_index", issue = "143775")]
     #[inline(always)]
-    pub unsafe fn get_unchecked_mut<I>(self, index: I) -> *mut I::Output
+    pub const unsafe fn get_unchecked_mut<I>(self, index: I) -> *mut I::Output
     where
-        I: SliceIndex<[T]>,
+        I: ~const SliceIndex<[T]>,
     {
         // SAFETY: the caller ensures that `self` is dereferenceable and `index` in-bounds.
         unsafe { index.get_unchecked_mut(self) }
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index c4ca29a3679..62da6567cca 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -1597,10 +1597,11 @@ impl<T> NonNull<[T]> {
     /// }
     /// ```
     #[unstable(feature = "slice_ptr_get", issue = "74265")]
+    #[rustc_const_unstable(feature = "const_index", issue = "143775")]
     #[inline]
-    pub unsafe fn get_unchecked_mut<I>(self, index: I) -> NonNull<I::Output>
+    pub const unsafe fn get_unchecked_mut<I>(self, index: I) -> NonNull<I::Output>
     where
-        I: SliceIndex<[T]>,
+        I: ~const SliceIndex<[T]>,
     {
         // SAFETY: the caller ensures that `self` is dereferenceable and `index` in-bounds.
         // As a consequence, the resulting pointer cannot be null.
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index abcba5a621e..32419024db9 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -568,9 +568,10 @@ impl<T> [T] {
     #[rustc_no_implicit_autorefs]
     #[inline]
     #[must_use]
-    pub fn get<I>(&self, index: I) -> Option<&I::Output>
+    #[rustc_const_unstable(feature = "const_index", issue = "143775")]
+    pub const fn get<I>(&self, index: I) -> Option<&I::Output>
     where
-        I: SliceIndex<Self>,
+        I: ~const SliceIndex<Self>,
     {
         index.get(self)
     }
@@ -594,9 +595,10 @@ impl<T> [T] {
     #[rustc_no_implicit_autorefs]
     #[inline]
     #[must_use]
-    pub fn get_mut<I>(&mut self, index: I) -> Option<&mut I::Output>
+    #[rustc_const_unstable(feature = "const_index", issue = "143775")]
+    pub const fn get_mut<I>(&mut self, index: I) -> Option<&mut I::Output>
     where
-        I: SliceIndex<Self>,
+        I: ~const SliceIndex<Self>,
     {
         index.get_mut(self)
     }
@@ -633,9 +635,10 @@ impl<T> [T] {
     #[inline]
     #[must_use]
     #[track_caller]
-    pub unsafe fn get_unchecked<I>(&self, index: I) -> &I::Output
+    #[rustc_const_unstable(feature = "const_index", issue = "143775")]
+    pub const unsafe fn get_unchecked<I>(&self, index: I) -> &I::Output
     where
-        I: SliceIndex<Self>,
+        I: ~const SliceIndex<Self>,
     {
         // SAFETY: the caller must uphold most of the safety requirements for `get_unchecked`;
         // the slice is dereferenceable because `self` is a safe reference.
@@ -677,9 +680,10 @@ impl<T> [T] {
     #[inline]
     #[must_use]
     #[track_caller]
-    pub unsafe fn get_unchecked_mut<I>(&mut self, index: I) -> &mut I::Output
+    #[rustc_const_unstable(feature = "const_index", issue = "143775")]
+    pub const unsafe fn get_unchecked_mut<I>(&mut self, index: I) -> &mut I::Output
     where
-        I: SliceIndex<Self>,
+        I: ~const SliceIndex<Self>,
     {
         // SAFETY: the caller must uphold the safety requirements for `get_unchecked_mut`;
         // the slice is dereferenceable because `self` is a safe reference.
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index fba3436496e..bb0106b9fd9 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -589,8 +589,9 @@ impl str {
     /// assert!(v.get(..42).is_none());
     /// ```
     #[stable(feature = "str_checked_slicing", since = "1.20.0")]
+    #[rustc_const_unstable(feature = "const_index", issue = "143775")]
     #[inline]
-    pub fn get<I: SliceIndex<str>>(&self, i: I) -> Option<&I::Output> {
+    pub const fn get<I: ~const SliceIndex<str>>(&self, i: I) -> Option<&I::Output> {
         i.get(self)
     }
 
@@ -621,8 +622,9 @@ impl str {
     /// assert_eq!("HEllo", v);
     /// ```
     #[stable(feature = "str_checked_slicing", since = "1.20.0")]
+    #[rustc_const_unstable(feature = "const_index", issue = "143775")]
     #[inline]
-    pub fn get_mut<I: SliceIndex<str>>(&mut self, i: I) -> Option<&mut I::Output> {
+    pub const fn get_mut<I: ~const SliceIndex<str>>(&mut self, i: I) -> Option<&mut I::Output> {
         i.get_mut(self)
     }
 
diff --git a/tests/ui/consts/const-eval/ub-slice-get-unchecked.rs b/tests/ui/consts/const-eval/ub-slice-get-unchecked.rs
index e805ac01c9d..ad2b49e6049 100644
--- a/tests/ui/consts/const-eval/ub-slice-get-unchecked.rs
+++ b/tests/ui/consts/const-eval/ub-slice-get-unchecked.rs
@@ -1,9 +1,10 @@
-//@ known-bug: #110395
+#![feature(const_index, const_trait_impl)]
 
 const A: [(); 5] = [(), (), (), (), ()];
 
 // Since the indexing is on a ZST, the addresses are all fine,
 // but we should still catch the bad range.
 const B: &[()] = unsafe { A.get_unchecked(3..1) };
+//~^ ERROR: slice::get_unchecked requires that the range is within the slice
 
 fn main() {}
diff --git a/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr b/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr
index 6e428079afe..88ea310f19c 100644
--- a/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr
+++ b/tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr
@@ -1,11 +1,11 @@
-error[E0015]: cannot call non-const method `core::slice::<impl [()]>::get_unchecked::<std::ops::Range<usize>>` in constants
-  --> $DIR/ub-slice-get-unchecked.rs:7:29
+error[E0080]: evaluation panicked: unsafe precondition(s) violated: slice::get_unchecked requires that the range is within the slice
+              
+              This indicates a bug in the program. This Undefined Behavior check is optional, and cannot be relied on for safety.
+  --> $DIR/ub-slice-get-unchecked.rs:7:27
    |
 LL | const B: &[()] = unsafe { A.get_unchecked(3..1) };
-   |                             ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: calls in constants are limited to constant functions, tuple structs and tuple variants
+   |                           ^^^^^^^^^^^^^^^^^^^^^ evaluation of `B` failed here
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0080`.
-- 
cgit 1.4.1-3-g733a5


From 2b4ede7e3d37de731821b5b04a6f1fce269c1afb Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Fri, 11 Jul 2025 09:24:42 +0000
Subject: constify `Index` trait and its slice impls

---
 library/core/src/array/mod.rs                      | 10 +++---
 library/core/src/ops/index.rs                      |  6 +++-
 library/core/src/slice/index.rs                    | 10 +++---
 library/core/src/str/traits.rs                     | 10 +++---
 tests/ui/consts/issue-94675.rs                     |  4 ++-
 tests/ui/consts/issue-94675.stderr                 | 27 ++++++++++-----
 .../issues/issue-35813-postfix-after-cast.rs       |  3 +-
 .../issues/issue-35813-postfix-after-cast.stderr   | 38 ++++++++--------------
 8 files changed, 60 insertions(+), 48 deletions(-)

diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs
index 16356f749c9..62203e132b7 100644
--- a/library/core/src/array/mod.rs
+++ b/library/core/src/array/mod.rs
@@ -374,9 +374,10 @@ impl<'a, T, const N: usize> IntoIterator for &'a mut [T; N] {
 }
 
 #[stable(feature = "index_trait_on_arrays", since = "1.50.0")]
-impl<T, I, const N: usize> Index<I> for [T; N]
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<T, I, const N: usize> const Index<I> for [T; N]
 where
-    [T]: Index<I>,
+    [T]: ~const Index<I>,
 {
     type Output = <[T] as Index<I>>::Output;
 
@@ -387,9 +388,10 @@ where
 }
 
 #[stable(feature = "index_trait_on_arrays", since = "1.50.0")]
-impl<T, I, const N: usize> IndexMut<I> for [T; N]
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<T, I, const N: usize> const IndexMut<I> for [T; N]
 where
-    [T]: IndexMut<I>,
+    [T]: ~const IndexMut<I>,
 {
     #[inline]
     fn index_mut(&mut self, index: I) -> &mut Self::Output {
diff --git a/library/core/src/ops/index.rs b/library/core/src/ops/index.rs
index 8092fa9eb2f..d8489e9a949 100644
--- a/library/core/src/ops/index.rs
+++ b/library/core/src/ops/index.rs
@@ -55,6 +55,8 @@
 #[doc(alias = "]")]
 #[doc(alias = "[")]
 #[doc(alias = "[]")]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
 pub trait Index<Idx: ?Sized> {
     /// The returned type after indexing.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -165,7 +167,9 @@ see chapter in The Book <https://doc.rust-lang.org/book/ch08-02-strings.html#ind
 #[doc(alias = "[")]
 #[doc(alias = "]")]
 #[doc(alias = "[]")]
-pub trait IndexMut<Idx: ?Sized>: Index<Idx> {
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+#[const_trait]
+pub trait IndexMut<Idx: ?Sized>: ~const Index<Idx> {
     /// Performs the mutable indexing (`container[index]`) operation.
     ///
     /// # Panics
diff --git a/library/core/src/slice/index.rs b/library/core/src/slice/index.rs
index c9b8e9c71b4..322b3580ede 100644
--- a/library/core/src/slice/index.rs
+++ b/library/core/src/slice/index.rs
@@ -6,9 +6,10 @@ use crate::ub_checks::assert_unsafe_precondition;
 use crate::{ops, range};
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, I> ops::Index<I> for [T]
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<T, I> const ops::Index<I> for [T]
 where
-    I: SliceIndex<[T]>,
+    I: ~const SliceIndex<[T]>,
 {
     type Output = I::Output;
 
@@ -19,9 +20,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, I> ops::IndexMut<I> for [T]
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<T, I> const ops::IndexMut<I> for [T]
 where
-    I: SliceIndex<[T]>,
+    I: ~const SliceIndex<[T]>,
 {
     #[inline(always)]
     fn index_mut(&mut self, index: I) -> &mut I::Output {
diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs
index 2ed5e686399..42ffc591b5b 100644
--- a/library/core/src/str/traits.rs
+++ b/library/core/src/str/traits.rs
@@ -49,9 +49,10 @@ impl PartialOrd for str {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<I> ops::Index<I> for str
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<I> const ops::Index<I> for str
 where
-    I: SliceIndex<str>,
+    I: ~const SliceIndex<str>,
 {
     type Output = I::Output;
 
@@ -62,9 +63,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<I> ops::IndexMut<I> for str
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<I> const ops::IndexMut<I> for str
 where
-    I: SliceIndex<str>,
+    I: ~const SliceIndex<str>,
 {
     #[inline]
     fn index_mut(&mut self, index: I) -> &mut I::Output {
diff --git a/tests/ui/consts/issue-94675.rs b/tests/ui/consts/issue-94675.rs
index 87c8b04452b..22791e7d15e 100644
--- a/tests/ui/consts/issue-94675.rs
+++ b/tests/ui/consts/issue-94675.rs
@@ -7,7 +7,9 @@ struct Foo<'a> {
 impl<'a> Foo<'a> {
     const fn spam(&mut self, baz: &mut Vec<u32>) {
         self.bar[0] = baz.len();
-        //~^ ERROR: cannot call
+        //~^ ERROR: `Vec<usize>: [const] Index<_>` is not satisfied
+        //~| ERROR: `Vec<usize>: [const] Index<usize>` is not satisfied
+        //~| ERROR: `Vec<usize>: [const] IndexMut<usize>` is not satisfied
     }
 }
 
diff --git a/tests/ui/consts/issue-94675.stderr b/tests/ui/consts/issue-94675.stderr
index 63a86b45633..608ce0cfef0 100644
--- a/tests/ui/consts/issue-94675.stderr
+++ b/tests/ui/consts/issue-94675.stderr
@@ -1,13 +1,24 @@
-error[E0015]: cannot call non-const operator in constant functions
-  --> $DIR/issue-94675.rs:9:17
+error[E0277]: the trait bound `Vec<usize>: [const] Index<_>` is not satisfied
+  --> $DIR/issue-94675.rs:9:9
    |
 LL |         self.bar[0] = baz.len();
-   |                 ^^^
+   |         ^^^^^^^^^^^
+
+error[E0277]: the trait bound `Vec<usize>: [const] IndexMut<usize>` is not satisfied
+  --> $DIR/issue-94675.rs:9:9
+   |
+LL |         self.bar[0] = baz.len();
+   |         ^^^^^^^^^^^
+
+error[E0277]: the trait bound `Vec<usize>: [const] Index<usize>` is not satisfied
+  --> $DIR/issue-94675.rs:9:9
+   |
+LL |         self.bar[0] = baz.len();
+   |         ^^^^^^^^^^^
    |
-note: impl defined here, but it is not `const`
-  --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+note: required by a bound in `std::ops::IndexMut::index_mut`
+  --> $SRC_DIR/core/src/ops/index.rs:LL:COL
 
-error: aborting due to 1 previous error
+error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/parser/issues/issue-35813-postfix-after-cast.rs b/tests/ui/parser/issues/issue-35813-postfix-after-cast.rs
index 316c612940c..439793ea8f7 100644
--- a/tests/ui/parser/issues/issue-35813-postfix-after-cast.rs
+++ b/tests/ui/parser/issues/issue-35813-postfix-after-cast.rs
@@ -1,6 +1,6 @@
 //@ edition:2018
 #![crate_type = "lib"]
-#![feature(type_ascription)]
+#![feature(type_ascription, const_index, const_trait_impl)]
 use std::future::Future;
 use std::pin::Pin;
 
@@ -129,7 +129,6 @@ pub fn inside_block() {
 
 static bar: &[i32] = &(&[1,2,3] as &[i32][0..1]);
 //~^ ERROR: cast cannot be followed by indexing
-//~| ERROR: cannot call non-const operator in statics
 
 static bar2: &[i32] = &(&[1i32,2,3]: &[i32; 3][0..1]);
 //~^ ERROR: expected one of
diff --git a/tests/ui/parser/issues/issue-35813-postfix-after-cast.stderr b/tests/ui/parser/issues/issue-35813-postfix-after-cast.stderr
index 64cf8baf9a5..ce7129da937 100644
--- a/tests/ui/parser/issues/issue-35813-postfix-after-cast.stderr
+++ b/tests/ui/parser/issues/issue-35813-postfix-after-cast.stderr
@@ -219,13 +219,13 @@ LL | static bar: &[i32] = &((&[1,2,3] as &[i32])[0..1]);
    |                        +                  +
 
 error: expected one of `)`, `,`, `.`, `?`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:134:36
+  --> $DIR/issue-35813-postfix-after-cast.rs:133:36
    |
 LL | static bar2: &[i32] = &(&[1i32,2,3]: &[i32; 3][0..1]);
    |                                    ^ expected one of `)`, `,`, `.`, `?`, or an operator
 
 error: cast cannot be followed by `?`
-  --> $DIR/issue-35813-postfix-after-cast.rs:139:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:138:5
    |
 LL |     Err(0u64) as Result<u64,u64>?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -236,25 +236,25 @@ LL |     (Err(0u64) as Result<u64,u64>)?;
    |     +                            +
 
 error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:141:14
+  --> $DIR/issue-35813-postfix-after-cast.rs:140:14
    |
 LL |     Err(0u64): Result<u64,u64>?;
    |              ^ expected one of `.`, `;`, `?`, `}`, or an operator
 
 error: expected identifier, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:153:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:152:13
    |
 LL |     drop_ptr: F();
    |             ^ expected identifier
 
 error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:160:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:159:13
    |
 LL |     drop_ptr: fn(u8);
    |             ^ expected one of 8 possible tokens
 
 error: cast cannot be followed by a function call
-  --> $DIR/issue-35813-postfix-after-cast.rs:166:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:165:5
    |
 LL |     drop as fn(u8)(0);
    |     ^^^^^^^^^^^^^^
@@ -265,13 +265,13 @@ LL |     (drop as fn(u8))(0);
    |     +              +
 
 error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:168:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:167:13
    |
 LL |     drop_ptr: fn(u8)(0);
    |             ^ expected one of 8 possible tokens
 
 error: cast cannot be followed by `.await`
-  --> $DIR/issue-35813-postfix-after-cast.rs:173:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:172:5
    |
 LL |     Box::pin(noop()) as Pin<Box<dyn Future<Output = ()>>>.await;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -282,13 +282,13 @@ LL |     (Box::pin(noop()) as Pin<Box<dyn Future<Output = ()>>>).await;
    |     +                                                     +
 
 error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:176:21
+  --> $DIR/issue-35813-postfix-after-cast.rs:175:21
    |
 LL |     Box::pin(noop()): Pin<Box<_>>.await;
    |                     ^ expected one of `.`, `;`, `?`, `}`, or an operator
 
 error: cast cannot be followed by a field access
-  --> $DIR/issue-35813-postfix-after-cast.rs:188:5
+  --> $DIR/issue-35813-postfix-after-cast.rs:187:5
    |
 LL |     Foo::default() as Foo.bar;
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -299,7 +299,7 @@ LL |     (Foo::default() as Foo).bar;
    |     +                     +
 
 error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
-  --> $DIR/issue-35813-postfix-after-cast.rs:190:19
+  --> $DIR/issue-35813-postfix-after-cast.rs:189:19
    |
 LL |     Foo::default(): Foo.bar;
    |                   ^ expected one of `.`, `;`, `?`, `}`, or an operator
@@ -322,21 +322,11 @@ LL |         if true { 33 } else { 44 }: i32.max(0)
    |                                   ^ expected one of `,`, `.`, `?`, or an operator
 
 error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
-  --> $DIR/issue-35813-postfix-after-cast.rs:151:13
+  --> $DIR/issue-35813-postfix-after-cast.rs:150:13
    |
 LL |     drop as F();
    |             ^^^ only `Fn` traits may use parentheses
 
-error[E0015]: cannot call non-const operator in statics
-  --> $DIR/issue-35813-postfix-after-cast.rs:130:42
-   |
-LL | static bar: &[i32] = &(&[1,2,3] as &[i32][0..1]);
-   |                                          ^^^^^^
-   |
-   = note: calls in statics are limited to constant functions, tuple structs and tuple variants
-   = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
-
-error: aborting due to 40 previous errors
+error: aborting due to 39 previous errors
 
-Some errors have detailed explanations: E0015, E0214.
-For more information about an error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0214`.
-- 
cgit 1.4.1-3-g733a5


From 0d6dc2f52de5bd7900f36c3e12234ee5d8fa7f91 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Mon, 14 Jul 2025 09:08:29 +0000
Subject: tidy: more clippy fixes

---
 src/tools/tidy/src/features.rs              | 35 +++++++++++-----------
 src/tools/tidy/src/fluent_period.rs         | 29 +++++++++---------
 src/tools/tidy/src/lib.rs                   |  2 +-
 src/tools/tidy/src/mir_opt_tests.rs         | 31 ++++++++++---------
 src/tools/tidy/src/rustdoc_templates.rs     |  2 +-
 src/tools/tidy/src/style.rs                 | 46 ++++++++++++++---------------
 src/tools/tidy/src/target_specific_tests.rs | 22 +++++++-------
 src/tools/tidy/src/ui_tests.rs              | 43 +++++++++++++--------------
 src/tools/tidy/src/x_version.rs             | 12 ++++----
 9 files changed, 110 insertions(+), 112 deletions(-)

diff --git a/src/tools/tidy/src/features.rs b/src/tools/tidy/src/features.rs
index e83b47e1380..fb00b3a943f 100644
--- a/src/tools/tidy/src/features.rs
+++ b/src/tools/tidy/src/features.rs
@@ -331,11 +331,9 @@ fn collect_lang_features_in(features: &mut Features, base: &Path, file: &str, ba
             continue;
         }
 
-        if in_feature_group {
-            if let Some(doc_comment) = line.strip_prefix("///") {
-                doc_comments.push(doc_comment.trim().to_string());
-                continue;
-            }
+        if in_feature_group && let Some(doc_comment) = line.strip_prefix("///") {
+            doc_comments.push(doc_comment.trim().to_string());
+            continue;
         }
 
         let mut parts = line.split(',');
@@ -465,19 +463,20 @@ fn get_and_check_lib_features(
     map_lib_features(base_src_path, &mut |res, file, line| match res {
         Ok((name, f)) => {
             let mut check_features = |f: &Feature, list: &Features, display: &str| {
-                if let Some(s) = list.get(name) {
-                    if f.tracking_issue != s.tracking_issue && f.level != Status::Accepted {
-                        tidy_error!(
-                            bad,
-                            "{}:{}: feature gate {} has inconsistent `issue`: \"{}\" mismatches the {} `issue` of \"{}\"",
-                            file.display(),
-                            line,
-                            name,
-                            f.tracking_issue_display(),
-                            display,
-                            s.tracking_issue_display(),
-                        );
-                    }
+                if let Some(s) = list.get(name)
+                    && f.tracking_issue != s.tracking_issue
+                    && f.level != Status::Accepted
+                {
+                    tidy_error!(
+                        bad,
+                        "{}:{}: feature gate {} has inconsistent `issue`: \"{}\" mismatches the {} `issue` of \"{}\"",
+                        file.display(),
+                        line,
+                        name,
+                        f.tracking_issue_display(),
+                        display,
+                        s.tracking_issue_display(),
+                    );
                 }
             };
             check_features(&f, lang_features, "corresponding lang feature");
diff --git a/src/tools/tidy/src/fluent_period.rs b/src/tools/tidy/src/fluent_period.rs
index 85c1ef6166a..836b5699289 100644
--- a/src/tools/tidy/src/fluent_period.rs
+++ b/src/tools/tidy/src/fluent_period.rs
@@ -33,14 +33,14 @@ fn check_period(filename: &str, contents: &str, bad: &mut bool) {
                 continue;
             }
 
-            if let Some(pat) = &m.value {
-                if let Some(PatternElement::TextElement { value }) = pat.elements.last() {
-                    // We don't care about ellipses.
-                    if value.ends_with(".") && !value.ends_with("...") {
-                        let ll = find_line(contents, value);
-                        let name = m.id.name;
-                        tidy_error!(bad, "{filename}:{ll}: message `{name}` ends in a period");
-                    }
+            if let Some(pat) = &m.value
+                && let Some(PatternElement::TextElement { value }) = pat.elements.last()
+            {
+                // We don't care about ellipses.
+                if value.ends_with(".") && !value.ends_with("...") {
+                    let ll = find_line(contents, value);
+                    let name = m.id.name;
+                    tidy_error!(bad, "{filename}:{ll}: message `{name}` ends in a period");
                 }
             }
 
@@ -50,12 +50,13 @@ fn check_period(filename: &str, contents: &str, bad: &mut bool) {
                     continue;
                 }
 
-                if let Some(PatternElement::TextElement { value }) = attr.value.elements.last() {
-                    if value.ends_with(".") && !value.ends_with("...") {
-                        let ll = find_line(contents, value);
-                        let name = attr.id.name;
-                        tidy_error!(bad, "{filename}:{ll}: attr `{name}` ends in a period");
-                    }
+                if let Some(PatternElement::TextElement { value }) = attr.value.elements.last()
+                    && value.ends_with(".")
+                    && !value.ends_with("...")
+                {
+                    let ll = find_line(contents, value);
+                    let name = attr.id.name;
+                    tidy_error!(bad, "{filename}:{ll}: attr `{name}` ends in a period");
                 }
             }
         }
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 77855392b4d..bd8660797a8 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -134,7 +134,7 @@ pub fn files_modified(ci_info: &CiInfo, pred: impl Fn(&str) -> bool) -> bool {
         eprintln!("No base commit, assuming all files are modified");
         return true;
     };
-    match crate::git_diff(&base_commit, "--name-status") {
+    match crate::git_diff(base_commit, "--name-status") {
         Some(output) => {
             let modified_files = output.lines().filter_map(|ln| {
                 let (status, name) = ln
diff --git a/src/tools/tidy/src/mir_opt_tests.rs b/src/tools/tidy/src/mir_opt_tests.rs
index 1efe71b1687..6119eb58383 100644
--- a/src/tools/tidy/src/mir_opt_tests.rs
+++ b/src/tools/tidy/src/mir_opt_tests.rs
@@ -55,22 +55,21 @@ fn check_dash_files(path: &Path, bless: bool, bad: &mut bool) {
         .filter(|e| e.file_type().is_file())
     {
         let path = file.path();
-        if path.extension() == Some("rs".as_ref()) {
-            if let Some(name) = path.file_name().and_then(|s| s.to_str()) {
-                if name.contains('-') {
-                    if !bless {
-                        tidy_error!(
-                            bad,
-                            "mir-opt test files should not have dashes in them: {}",
-                            path.display()
-                        );
-                    } else {
-                        let new_name = name.replace('-', "_");
-                        let mut new_path = path.to_owned();
-                        new_path.set_file_name(new_name);
-                        let _ = std::fs::rename(path, new_path);
-                    }
-                }
+        if path.extension() == Some("rs".as_ref())
+            && let Some(name) = path.file_name().and_then(|s| s.to_str())
+            && name.contains('-')
+        {
+            if !bless {
+                tidy_error!(
+                    bad,
+                    "mir-opt test files should not have dashes in them: {}",
+                    path.display()
+                );
+            } else {
+                let new_name = name.replace('-', "_");
+                let mut new_path = path.to_owned();
+                new_path.set_file_name(new_name);
+                let _ = std::fs::rename(path, new_path);
             }
         }
     }
diff --git a/src/tools/tidy/src/rustdoc_templates.rs b/src/tools/tidy/src/rustdoc_templates.rs
index dca3e8d9d25..597290a6a9a 100644
--- a/src/tools/tidy/src/rustdoc_templates.rs
+++ b/src/tools/tidy/src/rustdoc_templates.rs
@@ -26,7 +26,7 @@ pub fn check(librustdoc_path: &Path, bad: &mut bool) {
                         None
                     // Then we check if this a comment tag.
                     } else if *tag != "{#" {
-                        return Some(false);
+                        Some(false)
                     // And finally we check if the comment is empty (ie, only there to strip
                     // extra whitespace characters).
                     } else if let Some(start_pos) = line.rfind(tag) {
diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs
index 8dde4618ce5..35ed61eacc7 100644
--- a/src/tools/tidy/src/style.rs
+++ b/src/tools/tidy/src/style.rs
@@ -417,10 +417,10 @@ pub fn check(path: &Path, bad: &mut bool) {
             return;
         }
         // Shell completions are automatically generated
-        if let Some(p) = file.parent() {
-            if p.ends_with(Path::new("src/etc/completions")) {
-                return;
-            }
+        if let Some(p) = file.parent()
+            && p.ends_with(Path::new("src/etc/completions"))
+        {
+            return;
         }
         let [
             mut skip_cr,
@@ -604,25 +604,25 @@ pub fn check(path: &Path, bad: &mut bool) {
                         backtick_count += comment_text.chars().filter(|ch| *ch == '`').count();
                     }
                     comment_block = Some((start_line, backtick_count));
-                } else if let Some((start_line, backtick_count)) = comment_block.take() {
-                    if backtick_count % 2 == 1 {
-                        let mut err = |msg: &str| {
-                            tidy_error!(bad, "{}:{start_line}: {msg}", file.display());
-                        };
-                        let block_len = (i + 1) - start_line;
-                        if block_len == 1 {
-                            suppressible_tidy_err!(
-                                err,
-                                skip_odd_backticks,
-                                "comment with odd number of backticks"
-                            );
-                        } else {
-                            suppressible_tidy_err!(
-                                err,
-                                skip_odd_backticks,
-                                "{block_len}-line comment block with odd number of backticks"
-                            );
-                        }
+                } else if let Some((start_line, backtick_count)) = comment_block.take()
+                    && backtick_count % 2 == 1
+                {
+                    let mut err = |msg: &str| {
+                        tidy_error!(bad, "{}:{start_line}: {msg}", file.display());
+                    };
+                    let block_len = (i + 1) - start_line;
+                    if block_len == 1 {
+                        suppressible_tidy_err!(
+                            err,
+                            skip_odd_backticks,
+                            "comment with odd number of backticks"
+                        );
+                    } else {
+                        suppressible_tidy_err!(
+                            err,
+                            skip_odd_backticks,
+                            "{block_len}-line comment block with odd number of backticks"
+                        );
                     }
                 }
             }
diff --git a/src/tools/tidy/src/target_specific_tests.rs b/src/tools/tidy/src/target_specific_tests.rs
index 1a6fd3eaf2d..f4a6783abb6 100644
--- a/src/tools/tidy/src/target_specific_tests.rs
+++ b/src/tools/tidy/src/target_specific_tests.rs
@@ -30,17 +30,17 @@ pub fn check(tests_path: &Path, bad: &mut bool) {
                         comp_vec.push(component);
                     }
                 }
-            } else if let Some(compile_flags) = directive.strip_prefix(COMPILE_FLAGS_HEADER) {
-                if let Some((_, v)) = compile_flags.split_once("--target") {
-                    let v = v.trim_start_matches([' ', '=']);
-                    let v = if v == "{{target}}" { Some((v, v)) } else { v.split_once("-") };
-                    if let Some((arch, _)) = v {
-                        let info = header_map.entry(revision).or_insert(RevisionInfo::default());
-                        info.target_arch.replace(arch);
-                    } else {
-                        eprintln!("{file}: seems to have a malformed --target value");
-                        *bad = true;
-                    }
+            } else if let Some(compile_flags) = directive.strip_prefix(COMPILE_FLAGS_HEADER)
+                && let Some((_, v)) = compile_flags.split_once("--target")
+            {
+                let v = v.trim_start_matches([' ', '=']);
+                let v = if v == "{{target}}" { Some((v, v)) } else { v.split_once("-") };
+                if let Some((arch, _)) = v {
+                    let info = header_map.entry(revision).or_insert(RevisionInfo::default());
+                    info.target_arch.replace(arch);
+                } else {
+                    eprintln!("{file}: seems to have a malformed --target value");
+                    *bad = true;
                 }
             }
         });
diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs
index b1ace74e5bd..adc00182872 100644
--- a/src/tools/tidy/src/ui_tests.rs
+++ b/src/tools/tidy/src/ui_tests.rs
@@ -161,31 +161,30 @@ pub fn check(root_path: &Path, bless: bool, bad: &mut bool) {
                     tidy_error!(bad, "Stray file with UI testing output: {:?}", file_path);
                 }
 
-                if let Ok(metadata) = fs::metadata(file_path) {
-                    if metadata.len() == 0 {
-                        tidy_error!(bad, "Empty file with UI testing output: {:?}", file_path);
-                    }
+                if let Ok(metadata) = fs::metadata(file_path)
+                    && metadata.len() == 0
+                {
+                    tidy_error!(bad, "Empty file with UI testing output: {:?}", file_path);
                 }
             }
 
-            if ext == "rs" {
-                if let Some(test_name) = static_regex!(r"^issues?[-_]?(\d{3,})").captures(testname)
-                {
-                    // these paths are always relative to the passed `path` and always UTF8
-                    let stripped_path = file_path
-                        .strip_prefix(path)
-                        .unwrap()
-                        .to_str()
-                        .unwrap()
-                        .replace(std::path::MAIN_SEPARATOR_STR, "/");
-
-                    if !remaining_issue_names.remove(stripped_path.as_str()) {
-                        tidy_error!(
-                            bad,
-                            "file `tests/{stripped_path}` must begin with a descriptive name, consider `{{reason}}-issue-{issue_n}.rs`",
-                            issue_n = &test_name[1],
-                        );
-                    }
+            if ext == "rs"
+                && let Some(test_name) = static_regex!(r"^issues?[-_]?(\d{3,})").captures(testname)
+            {
+                // these paths are always relative to the passed `path` and always UTF8
+                let stripped_path = file_path
+                    .strip_prefix(path)
+                    .unwrap()
+                    .to_str()
+                    .unwrap()
+                    .replace(std::path::MAIN_SEPARATOR_STR, "/");
+
+                if !remaining_issue_names.remove(stripped_path.as_str()) {
+                    tidy_error!(
+                        bad,
+                        "file `tests/{stripped_path}` must begin with a descriptive name, consider `{{reason}}-issue-{issue_n}.rs`",
+                        issue_n = &test_name[1],
+                    );
                 }
             }
         }
diff --git a/src/tools/tidy/src/x_version.rs b/src/tools/tidy/src/x_version.rs
index 6a5e9eca813..9f7f43c4000 100644
--- a/src/tools/tidy/src/x_version.rs
+++ b/src/tools/tidy/src/x_version.rs
@@ -25,12 +25,12 @@ pub fn check(root: &Path, cargo: &Path, bad: &mut bool) {
                 if let Some(version) = iter.next() {
                     // Check this is the rust-lang/rust x tool installation since it should be
                     // installed at a path containing `src/tools/x`.
-                    if let Some(path) = iter.next() {
-                        if path.contains("src/tools/x") {
-                            let version = version.strip_prefix("v").unwrap();
-                            installed = Some(Version::parse(version).unwrap());
-                            break;
-                        }
+                    if let Some(path) = iter.next()
+                        && path.contains("src/tools/x")
+                    {
+                        let version = version.strip_prefix("v").unwrap();
+                        installed = Some(Version::parse(version).unwrap());
+                        break;
                     };
                 }
             } else {
-- 
cgit 1.4.1-3-g733a5


From e1d35c551fde82668d7e8be8f759bd02e9b5345b Mon Sep 17 00:00:00 2001
From: Patrick-6 <pamu99@gmx.ch>
Date: Tue, 15 Jul 2025 10:32:19 +0200
Subject: Add std::hint::spin_loop()

---
 src/tools/miri/tests/pass/0weak_memory_consistency.rs    | 12 ++++++++++--
 src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs | 12 ++++++++++--
 src/tools/miri/tests/pass/weak_memory/weak.rs            |  4 ++--
 3 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/src/tools/miri/tests/pass/0weak_memory_consistency.rs b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
index b33aefaf1d5..5fba5493442 100644
--- a/src/tools/miri/tests/pass/0weak_memory_consistency.rs
+++ b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
@@ -48,6 +48,14 @@ fn loads_value(loc: &AtomicI32, ord: Ordering, val: i32) -> i32 {
     val
 }
 
+/// Spins until it acquires a pre-determined boolean.
+fn loads_bool(loc: &AtomicBool, ord: Ordering, val: bool) -> bool {
+    while loc.load(ord) != val {
+        std::hint::spin_loop();
+    }
+    val
+}
+
 fn test_corr() {
     let x = static_atomic(0);
     let y = static_atomic(0);
@@ -216,12 +224,12 @@ fn test_sync_through_rmw_and_fences() {
     let go = static_atomic_bool(false);
 
     let t1 = spawn(move || {
-        while !go.load(Relaxed) {}
+        loads_bool(go, Relaxed, true);
         rdmw(y, x, z)
     });
 
     let t2 = spawn(move || {
-        while !go.load(Relaxed) {}
+        loads_bool(go, Relaxed, true);
         rdmw(z, x, y)
     });
 
diff --git a/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs b/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs
index 45cc5e6e722..2c9d742a8b1 100644
--- a/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs
+++ b/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs
@@ -27,6 +27,14 @@ fn loads_value(loc: &AtomicI32, ord: Ordering, val: i32) -> i32 {
     val
 }
 
+/// Spins until it acquires a pre-determined boolean.
+fn loads_bool(loc: &AtomicBool, ord: Ordering, val: bool) -> bool {
+    while loc.load(ord) != val {
+        std::hint::spin_loop();
+    }
+    val
+}
+
 // Test case SB taken from Repairing Sequential Consistency in C/C++11
 // by Lahav et al.
 // https://plv.mpi-sws.org/scfix/paper.pdf
@@ -60,11 +68,11 @@ fn test_iriw_sc_rlx() {
     let a = spawn(move || x.store(true, Relaxed));
     let b = spawn(move || y.store(true, Relaxed));
     let c = spawn(move || {
-        while !x.load(SeqCst) {}
+        loads_bool(x, SeqCst, true);
         y.load(SeqCst)
     });
     let d = spawn(move || {
-        while !y.load(SeqCst) {}
+        loads_bool(y, SeqCst, true);
         x.load(SeqCst)
     });
 
diff --git a/src/tools/miri/tests/pass/weak_memory/weak.rs b/src/tools/miri/tests/pass/weak_memory/weak.rs
index eeab4ebf129..569a307ab06 100644
--- a/src/tools/miri/tests/pass/weak_memory/weak.rs
+++ b/src/tools/miri/tests/pass/weak_memory/weak.rs
@@ -119,12 +119,12 @@ fn faa_replaced_by_load() -> bool {
     let go = static_atomic(0);
 
     let t1 = spawn(move || {
-        while go.load(Relaxed) == 0 {}
+        reads_value(go, 1);
         rdmw(y, x, z)
     });
 
     let t2 = spawn(move || {
-        while go.load(Relaxed) == 0 {}
+        reads_value(go, 1);
         rdmw(z, x, y)
     });
 
-- 
cgit 1.4.1-3-g733a5


From da6d7ca1be6586ba8e0d2b89f1d60ff256dfc7ea Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Tue, 15 Jul 2025 08:59:41 +0000
Subject: tidy static regex: OnceLock -> LazyLock

---
 src/tools/tidy/src/lib.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index bd8660797a8..a301781fac8 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -13,8 +13,9 @@ use termcolor::WriteColor;
 
 macro_rules! static_regex {
     ($re:literal) => {{
-        static RE: ::std::sync::OnceLock<::regex::Regex> = ::std::sync::OnceLock::new();
-        RE.get_or_init(|| ::regex::Regex::new($re).unwrap())
+        static RE: ::std::sync::LazyLock<::regex::Regex> =
+            ::std::sync::LazyLock::new(|| ::regex::Regex::new($re).unwrap());
+        &*RE
     }};
 }
 
-- 
cgit 1.4.1-3-g733a5


From 32391f71598f637887abcb7614ad287763f8275d Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Tue, 15 Jul 2025 09:07:07 +0000
Subject: tidy: improve comment

---
 src/tools/tidy/src/fluent_used.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/tidy/src/fluent_used.rs b/src/tools/tidy/src/fluent_used.rs
index 12fafd9a7ff..909bf482ddf 100644
--- a/src/tools/tidy/src/fluent_used.rs
+++ b/src/tools/tidy/src/fluent_used.rs
@@ -12,7 +12,7 @@ fn filter_used_messages(
 ) {
     // we don't just check messages never appear in Rust files,
     // because messages can be used as parts of other fluent messages in Fluent files,
-    // so we do checking messages appear only once in all Rust and Fluent files.
+    // so we check messages appear only once in all Rust and Fluent files.
     let matches = static_regex!(r"\w+").find_iter(contents);
     for name in matches {
         if let Some((name, filename)) = msgs_not_appeared_yet.remove_entry(name.as_str()) {
-- 
cgit 1.4.1-3-g733a5


From cbaaf153a58ed0ebbc9c327c3d61462aef7aee15 Mon Sep 17 00:00:00 2001
From: Samuel Tardieu <sam@rfc1149.net>
Date: Tue, 15 Jul 2025 11:04:07 +0200
Subject: tidy: check for invalid file names

---
 src/tools/tidy/src/filenames.rs | 40 ++++++++++++++++++++++++++++++++++++++++
 src/tools/tidy/src/lib.rs       |  1 +
 src/tools/tidy/src/main.rs      |  2 ++
 3 files changed, 43 insertions(+)
 create mode 100644 src/tools/tidy/src/filenames.rs

diff --git a/src/tools/tidy/src/filenames.rs b/src/tools/tidy/src/filenames.rs
new file mode 100644
index 00000000000..53115f4eaa4
--- /dev/null
+++ b/src/tools/tidy/src/filenames.rs
@@ -0,0 +1,40 @@
+//! Tidy check to ensure that there are no filenames containing forbidden characters
+//! checked into the source tree by accident:
+//! - Non-UTF8 filenames
+//! - Control characters such as CR or TAB
+//! - Filenames containing ":" as they are not supported on Windows
+//!
+//! Only files added to git are checked, as it may be acceptable to have temporary
+//! invalid filenames in the local directory during development.
+
+use std::path::Path;
+use std::process::Command;
+
+pub fn check(root_path: &Path, bad: &mut bool) {
+    let stat_output = Command::new("git")
+        .arg("-C")
+        .arg(root_path)
+        .args(["ls-files", "-z"])
+        .output()
+        .unwrap()
+        .stdout;
+    for filename in stat_output.split(|&b| b == 0) {
+        match str::from_utf8(filename) {
+            Err(_) => tidy_error!(
+                bad,
+                r#"non-UTF8 file names are not supported: "{}""#,
+                String::from_utf8_lossy(filename),
+            ),
+            Ok(name) if name.chars().any(|c| c.is_control()) => tidy_error!(
+                bad,
+                r#"control characters are not supported in file names: "{}""#,
+                String::from_utf8_lossy(filename),
+            ),
+            Ok(name) if name.contains(':') => tidy_error!(
+                bad,
+                r#"":" is not supported in file names because of Windows compatibility: "{name}""#,
+            ),
+            _ => (),
+        }
+    }
+}
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 77855392b4d..ade4055b5bd 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -167,6 +167,7 @@ pub mod error_codes;
 pub mod ext_tool_checks;
 pub mod extdeps;
 pub mod features;
+pub mod filenames;
 pub mod fluent_alphabetical;
 pub mod fluent_period;
 mod fluent_used;
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index a67f7a511b5..0f1116a632e 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -155,6 +155,8 @@ fn main() {
 
         check!(triagebot, &root_path);
 
+        check!(filenames, &root_path);
+
         let collected = {
             drain_handles(&mut handles);
 
-- 
cgit 1.4.1-3-g733a5


From 6b51eee9df2622c790cb7ff26176c9be7672ef9c Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Mon, 7 Jul 2025 11:10:51 +0200
Subject: Add enter_trace_span! that checks #[cfg("tracing")]

Includes a custom syntax shortand to enter_trace_span! with NAME::SUBNAME.

MaybeEnteredTraceSpan is `pub use`d in lib.rs to make it available also in bin/, just in case.
---
 src/tools/miri/src/helpers.rs | 41 +++++++++++++++++++++++++++++++++++++++++
 src/tools/miri/src/lib.rs     |  4 +++-
 2 files changed, 44 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index b259243602e..b76d046d1d2 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -1431,3 +1431,44 @@ impl ToU64 for usize {
         self.try_into().unwrap()
     }
 }
+
+/// This struct is needed to enforce `#[must_use]` on values produced by [enter_trace_span] even
+/// when the "tracing" feature is not enabled.
+#[must_use]
+pub struct MaybeEnteredTraceSpan {
+    #[cfg(feature = "tracing")]
+    pub _entered_span: tracing::span::EnteredSpan,
+}
+
+/// Enters a [tracing::info_span] only if the "tracing" feature is enabled, otherwise does nothing.
+/// This is like [rustc_const_eval::enter_trace_span] except that it does not depend on the
+/// [Machine] trait to check if tracing is enabled, because from the Miri codebase we can directly
+/// check whether the "tracing" feature is enabled, unlike from the rustc_const_eval codebase.
+///
+/// In addition to the syntax accepted by [tracing::span!], this macro optionally allows passing
+/// the span name (i.e. the first macro argument) in the form `NAME::SUBNAME` (without quotes) to
+/// indicate that the span has name "NAME" (usually the name of the component) and has an additional
+/// more specific name "SUBNAME" (usually the function name). The latter is passed to the [tracing]
+/// infrastructure as a span field with the name "NAME". This allows not being distracted by
+/// subnames when looking at the trace in <https://ui.perfetto.dev>, but when deeper introspection
+/// is needed within a component, it's still possible to view the subnames directly in the UI by
+/// selecting a span, clicking on the "NAME" argument on the right, and clicking on "Visualize
+/// argument values".
+/// ```rust
+/// // for example, the first will expand to the second
+/// enter_trace_span!(borrow_tracker::on_stack_pop, /* ... */)
+/// enter_trace_span!("borrow_tracker", borrow_tracker = "on_stack_pop", /* ... */)
+/// ```
+#[macro_export]
+macro_rules! enter_trace_span {
+    ($name:ident :: $subname:ident $($tt:tt)*) => {{
+        enter_trace_span!(stringify!($name), $name = %stringify!(subname) $($tt)*)
+    }};
+
+    ($($tt:tt)*) => {
+        $crate::MaybeEnteredTraceSpan {
+            #[cfg(feature = "tracing")]
+            _entered_span: tracing::info_span!($($tt)*).entered()
+        }
+    };
+}
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index ca99d69b32d..f6d01831a97 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -139,7 +139,9 @@ pub use crate::eval::{
     AlignmentCheck, BacktraceStyle, IsolatedOp, MiriConfig, MiriEntryFnType, RejectOpWith,
     ValidationMode, create_ecx, eval_entry,
 };
-pub use crate::helpers::{AccessKind, EvalContextExt as _, ToU64 as _, ToUsize as _};
+pub use crate::helpers::{
+    AccessKind, EvalContextExt as _, MaybeEnteredTraceSpan, ToU64 as _, ToUsize as _,
+};
 pub use crate::intrinsics::EvalContextExt as _;
 pub use crate::machine::{
     AllocExtra, DynMachineCallback, FrameExtra, MachineCallback, MemoryKind, MiriInterpCx,
-- 
cgit 1.4.1-3-g733a5


From 2ee58dc31fe5f3f60b9ad56dd85900d02f70db4a Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Mon, 7 Jul 2025 11:11:15 +0200
Subject: Add tracing calls to borrow tracker under the same name

... but the function name is specified in the arguments, see https://github.com/rust-lang/miri/pull/4452#discussion_r2204958019
---
 src/tools/miri/src/borrow_tracker/mod.rs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/tools/miri/src/borrow_tracker/mod.rs b/src/tools/miri/src/borrow_tracker/mod.rs
index 36c61053a32..ec6c2c60ca9 100644
--- a/src/tools/miri/src/borrow_tracker/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/mod.rs
@@ -260,6 +260,7 @@ impl GlobalStateInner {
         kind: MemoryKind,
         machine: &MiriMachine<'_>,
     ) -> AllocState {
+        let _span = enter_trace_span!(borrow_tracker::new_allocation, ?id, ?alloc_size, ?kind);
         match self.borrow_tracker_method {
             BorrowTrackerMethod::StackedBorrows =>
                 AllocState::StackedBorrows(Box::new(RefCell::new(Stacks::new_allocation(
@@ -280,6 +281,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         kind: RetagKind,
         val: &ImmTy<'tcx>,
     ) -> InterpResult<'tcx, ImmTy<'tcx>> {
+        let _span = enter_trace_span!(borrow_tracker::retag_ptr_value, ?kind, ?val.layout);
         let this = self.eval_context_mut();
         let method = this.machine.borrow_tracker.as_ref().unwrap().borrow().borrow_tracker_method;
         match method {
@@ -293,6 +295,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         kind: RetagKind,
         place: &PlaceTy<'tcx>,
     ) -> InterpResult<'tcx> {
+        let _span = enter_trace_span!(borrow_tracker::retag_place_contents, ?kind, ?place);
         let this = self.eval_context_mut();
         let method = this.machine.borrow_tracker.as_ref().unwrap().borrow().borrow_tracker_method;
         match method {
@@ -302,6 +305,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     }
 
     fn protect_place(&mut self, place: &MPlaceTy<'tcx>) -> InterpResult<'tcx, MPlaceTy<'tcx>> {
+        let _span = enter_trace_span!(borrow_tracker::protect_place, ?place);
         let this = self.eval_context_mut();
         let method = this.machine.borrow_tracker.as_ref().unwrap().borrow().borrow_tracker_method;
         match method {
@@ -311,6 +315,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     }
 
     fn expose_tag(&self, alloc_id: AllocId, tag: BorTag) -> InterpResult<'tcx> {
+        let _span =
+            enter_trace_span!(borrow_tracker::expose_tag, alloc_id = alloc_id.0, tag = tag.0);
         let this = self.eval_context_ref();
         let method = this.machine.borrow_tracker.as_ref().unwrap().borrow().borrow_tracker_method;
         match method {
@@ -354,6 +360,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         &self,
         frame: &Frame<'tcx, Provenance, FrameExtra<'tcx>>,
     ) -> InterpResult<'tcx> {
+        let _span = enter_trace_span!(borrow_tracker::on_stack_pop);
         let this = self.eval_context_ref();
         let borrow_tracker = this.machine.borrow_tracker.as_ref().unwrap();
         // The body of this loop needs `borrow_tracker` immutably
@@ -431,6 +438,7 @@ impl AllocState {
         range: AllocRange,
         machine: &MiriMachine<'tcx>,
     ) -> InterpResult<'tcx> {
+        let _span = enter_trace_span!(borrow_tracker::before_memory_read, alloc_id = alloc_id.0);
         match self {
             AllocState::StackedBorrows(sb) =>
                 sb.borrow_mut().before_memory_read(alloc_id, prov_extra, range, machine),
@@ -452,6 +460,7 @@ impl AllocState {
         range: AllocRange,
         machine: &MiriMachine<'tcx>,
     ) -> InterpResult<'tcx> {
+        let _span = enter_trace_span!(borrow_tracker::before_memory_write, alloc_id = alloc_id.0);
         match self {
             AllocState::StackedBorrows(sb) =>
                 sb.get_mut().before_memory_write(alloc_id, prov_extra, range, machine),
@@ -473,6 +482,8 @@ impl AllocState {
         size: Size,
         machine: &MiriMachine<'tcx>,
     ) -> InterpResult<'tcx> {
+        let _span =
+            enter_trace_span!(borrow_tracker::before_memory_deallocation, alloc_id = alloc_id.0);
         match self {
             AllocState::StackedBorrows(sb) =>
                 sb.get_mut().before_memory_deallocation(alloc_id, prov_extra, size, machine),
@@ -482,6 +493,7 @@ impl AllocState {
     }
 
     pub fn remove_unreachable_tags(&self, tags: &FxHashSet<BorTag>) {
+        let _span = enter_trace_span!(borrow_tracker::remove_unreachable_tags);
         match self {
             AllocState::StackedBorrows(sb) => sb.borrow_mut().remove_unreachable_tags(tags),
             AllocState::TreeBorrows(tb) => tb.borrow_mut().remove_unreachable_tags(tags),
@@ -496,6 +508,11 @@ impl AllocState {
         tag: BorTag,
         alloc_id: AllocId, // diagnostics
     ) -> InterpResult<'tcx> {
+        let _span = enter_trace_span!(
+            borrow_tracker::release_protector,
+            alloc_id = alloc_id.0,
+            tag = tag.0
+        );
         match self {
             AllocState::StackedBorrows(_sb) => interp_ok(()),
             AllocState::TreeBorrows(tb) =>
@@ -506,6 +523,7 @@ impl AllocState {
 
 impl VisitProvenance for AllocState {
     fn visit_provenance(&self, visit: &mut VisitWith<'_>) {
+        let _span = enter_trace_span!(borrow_tracker::visit_provenance);
         match self {
             AllocState::StackedBorrows(sb) => sb.visit_provenance(visit),
             AllocState::TreeBorrows(tb) => tb.visit_provenance(visit),
-- 
cgit 1.4.1-3-g733a5


From 132a47e72316b60e99c3e5fefb9c3a06641138e4 Mon Sep 17 00:00:00 2001
From: Bastian Kersting <bkersting@google.com>
Date: Tue, 15 Jul 2025 12:28:15 +0000
Subject: Correct which exploit mitigations are enabled by default

---
 src/doc/rustc/src/exploit-mitigations.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/doc/rustc/src/exploit-mitigations.md b/src/doc/rustc/src/exploit-mitigations.md
index f8bafe03214..c80d7d8743c 100644
--- a/src/doc/rustc/src/exploit-mitigations.md
+++ b/src/doc/rustc/src/exploit-mitigations.md
@@ -54,17 +54,17 @@ Summary of exploit mitigations supported by the Rust compiler when building
 programs for the Linux operating system on the AMD64 architecture and
 equivalent.
 
-| Exploit mitigation | Supported and enabled by default | Since |
-| - | - | - |
-| Position-independent executable | Yes | 0.12.0 (2014-10-09) |
-| Integer overflow checks | Yes (enabled when debug assertions are enabled, and disabled when debug assertions are disabled) | 1.1.0 (2015-06-25) |
-| Non-executable memory regions | Yes | 1.8.0 (2016-04-14) |
-| Stack clashing protection | Yes | 1.20.0 (2017-08-31) |
-| Read-only relocations and immediate binding | Yes | 1.21.0 (2017-10-12) |
-| Heap corruption protection | Yes | 1.32.0 (2019-01-17) (via operating system default or specified allocator) |
-| Stack smashing protection | Yes | Nightly |
-| Forward-edge control flow protection | Yes | Nightly |
-| Backward-edge control flow protection (e.g., shadow and safe stack) | Yes | Nightly |
+| Exploit mitigation | Supported | Enabled by default | Since |
+| - | - | - | - |
+| Position-independent executable | Yes | Yes | 0.12.0 (2014-10-09) |
+| Integer overflow checks | Yes | (enabled when debug assertions are enabled, and disabled when debug assertions are disabled) | 1.1.0 (2015-06-25) |
+| Non-executable memory regions | Yes | Yes | 1.8.0 (2016-04-14) |
+| Stack clashing protection | Yes | Yes | 1.20.0 (2017-08-31) |
+| Read-only relocations and immediate binding | Yes | Yes | 1.21.0 (2017-10-12) |
+| Heap corruption protection | Yes | Yes | 1.32.0 (2019-01-17) (via operating system default or specified allocator) |
+| Stack smashing protection | Yes | No, `-Z stack-protector` | Nightly |
+| Forward-edge control flow protection | Yes | No, `-Z sanitizer=cfi` | Nightly |
+| Backward-edge control flow protection (e.g., shadow and safe stack) | Yes | No, `-Z sanitizer=shadow-call-stack,safestack` | Nightly |
 
 [^all-targets]: See <https://github.com/rust-lang/rust/tree/master/compiler/rustc_target/src/spec>
     for a list of targets and their default options.
-- 
cgit 1.4.1-3-g733a5


From 14f47009cc5b02cd8c28ca2cc9c1fd58aeeef25b Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Tue, 15 Jul 2025 14:57:51 +0200
Subject: Add InterpCx::fn_abi_of_instance/_fn_ptr with tracing, shadowing
 FnAbiOf

---
 compiler/rustc_const_eval/src/interpret/call.rs    |  2 +-
 .../rustc_const_eval/src/interpret/eval_context.rs | 55 +++++++++++++++-------
 compiler/rustc_const_eval/src/interpret/step.rs    |  1 -
 src/tools/miri/src/helpers.rs                      |  2 +-
 4 files changed, 41 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index ad3e02580f3..1503f3bcd99 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -6,7 +6,7 @@ use std::borrow::Cow;
 use either::{Left, Right};
 use rustc_abi::{self as abi, ExternAbi, FieldIdx, Integer, VariantIdx};
 use rustc_hir::def_id::DefId;
-use rustc_middle::ty::layout::{FnAbiOf, IntegerExt, TyAndLayout};
+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_span::sym;
diff --git a/compiler/rustc_const_eval/src/interpret/eval_context.rs b/compiler/rustc_const_eval/src/interpret/eval_context.rs
index 41fc8d47cd3..11e7706fe60 100644
--- a/compiler/rustc_const_eval/src/interpret/eval_context.rs
+++ b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@@ -7,8 +7,8 @@ use rustc_hir::def_id::DefId;
 use rustc_middle::mir::interpret::{ErrorHandled, InvalidMetaKind, ReportedErrorInfo};
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::layout::{
-    self, FnAbiError, FnAbiOfHelpers, FnAbiRequest, LayoutError, LayoutOf, LayoutOfHelpers,
-    TyAndLayout,
+    self, FnAbiError, FnAbiOf, FnAbiOfHelpers, FnAbiRequest, LayoutError, LayoutOf,
+    LayoutOfHelpers, TyAndLayout,
 };
 use rustc_middle::ty::{self, GenericArgsRef, Ty, TyCtxt, TypeFoldable, TypingEnv, Variance};
 use rustc_middle::{mir, span_bug};
@@ -92,20 +92,6 @@ impl<'tcx, M: Machine<'tcx>> LayoutOfHelpers<'tcx> for InterpCx<'tcx, M> {
     }
 }
 
-impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
-    /// This inherent method takes priority over the trait method with the same name in LayoutOf,
-    /// and allows wrapping the actual [LayoutOf::layout_of] with a tracing span.
-    /// See [LayoutOf::layout_of] for the original documentation.
-    #[inline(always)]
-    pub fn layout_of(
-        &self,
-        ty: Ty<'tcx>,
-    ) -> <InterpCx<'tcx, M> as LayoutOfHelpers<'tcx>>::LayoutOfResult {
-        let _span = enter_trace_span!(M, "InterpCx::layout_of", "ty = {:?}", ty.kind());
-        LayoutOf::layout_of(self, ty)
-    }
-}
-
 impl<'tcx, M: Machine<'tcx>> FnAbiOfHelpers<'tcx> for InterpCx<'tcx, M> {
     type FnAbiOfResult = Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, InterpErrorKind<'tcx>>;
 
@@ -121,6 +107,43 @@ impl<'tcx, M: Machine<'tcx>> FnAbiOfHelpers<'tcx> for InterpCx<'tcx, M> {
     }
 }
 
+impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
+    /// This inherent method takes priority over the trait method with the same name in LayoutOf,
+    /// and allows wrapping the actual [LayoutOf::layout_of] with a tracing span.
+    /// See [LayoutOf::layout_of] for the original documentation.
+    #[inline(always)]
+    pub fn layout_of(&self, ty: Ty<'tcx>) -> <Self as LayoutOfHelpers<'tcx>>::LayoutOfResult {
+        let _span = enter_trace_span!(M, "InterpCx::layout_of", ty = ?ty.kind());
+        LayoutOf::layout_of(self, ty)
+    }
+
+    /// This inherent method takes priority over the trait method with the same name in FnAbiOf,
+    /// and allows wrapping the actual [FnAbiOf::fn_abi_of_fn_ptr] with a tracing span.
+    /// See [FnAbiOf::fn_abi_of_fn_ptr] for the original documentation.
+    #[inline(always)]
+    pub fn fn_abi_of_fn_ptr(
+        &self,
+        sig: ty::PolyFnSig<'tcx>,
+        extra_args: &'tcx ty::List<Ty<'tcx>>,
+    ) -> <Self as FnAbiOfHelpers<'tcx>>::FnAbiOfResult {
+        let _span = enter_trace_span!(M, "InterpCx::fn_abi_of_fn_ptr", ?sig, ?extra_args);
+        FnAbiOf::fn_abi_of_fn_ptr(self, sig, extra_args)
+    }
+
+    /// This inherent method takes priority over the trait method with the same name in FnAbiOf,
+    /// and allows wrapping the actual [FnAbiOf::fn_abi_of_instance] with a tracing span.
+    /// See [FnAbiOf::fn_abi_of_instance] for the original documentation.
+    #[inline(always)]
+    pub fn fn_abi_of_instance(
+        &self,
+        instance: ty::Instance<'tcx>,
+        extra_args: &'tcx ty::List<Ty<'tcx>>,
+    ) -> <Self as FnAbiOfHelpers<'tcx>>::FnAbiOfResult {
+        let _span = enter_trace_span!(M, "InterpCx::fn_abi_of_instance", ?instance, ?extra_args);
+        FnAbiOf::fn_abi_of_instance(self, instance, extra_args)
+    }
+}
+
 /// Test if it is valid for a MIR assignment to assign `src`-typed place to `dest`-typed value.
 /// This test should be symmetric, as it is primarily about layout compatibility.
 pub(super) fn mir_assign_valid_types<'tcx>(
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index 833fcc38817..629dcc3523c 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -5,7 +5,6 @@
 use either::Either;
 use rustc_abi::{FIRST_VARIANT, FieldIdx};
 use rustc_index::IndexSlice;
-use rustc_middle::ty::layout::FnAbiOf;
 use rustc_middle::ty::{self, Instance, Ty};
 use rustc_middle::{bug, mir, span_bug};
 use rustc_span::source_map::Spanned;
diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index c150dc16b07..f2283f0902b 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -13,7 +13,7 @@ use rustc_index::IndexVec;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::middle::dependency_format::Linkage;
 use rustc_middle::middle::exported_symbols::ExportedSymbol;
-use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, MaybeResult, TyAndLayout};
+use rustc_middle::ty::layout::{LayoutOf, MaybeResult, TyAndLayout};
 use rustc_middle::ty::{self, Binder, FloatTy, FnSig, IntTy, Ty, TyCtxt, UintTy};
 use rustc_session::config::CrateType;
 use rustc_span::{Span, Symbol};
-- 
cgit 1.4.1-3-g733a5


From 4a77a62e5611890dd275e17de0fb1694e4ff9a28 Mon Sep 17 00:00:00 2001
From: David Mládek <david.mladek.cz@gmail.com>
Date: Tue, 15 Jul 2025 15:26:18 +0200
Subject: rustc_resolve: rename `check_hidden_glob_reexports` to
 `lint_reexports`

---
 compiler/rustc_resolve/src/imports.rs | 5 +----
 compiler/rustc_resolve/src/lib.rs     | 4 +---
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 40c63a3edf3..b2f6ee6563c 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -634,10 +634,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
-    pub(crate) fn check_hidden_glob_reexports(
-        &mut self,
-        exported_ambiguities: FxHashSet<NameBinding<'ra>>,
-    ) {
+    pub(crate) fn lint_reexports(&mut self, exported_ambiguities: FxHashSet<NameBinding<'ra>>) {
         for module in self.arenas.local_modules().iter() {
             for (key, resolution) in self.resolutions(*module).borrow().iter() {
                 let resolution = resolution.borrow();
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index c2b3451d4a1..87963295c2d 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -1775,9 +1775,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let exported_ambiguities = self.tcx.sess.time("compute_effective_visibilities", || {
                 EffectiveVisibilitiesVisitor::compute_effective_visibilities(self, krate)
             });
-            self.tcx.sess.time("check_hidden_glob_reexports", || {
-                self.check_hidden_glob_reexports(exported_ambiguities)
-            });
+            self.tcx.sess.time("lint_reexports", || self.lint_reexports(exported_ambiguities));
             self.tcx
                 .sess
                 .time("finalize_macro_resolutions", || self.finalize_macro_resolutions(krate));
-- 
cgit 1.4.1-3-g733a5


From 8b868fa534a8b660a5b8051a5c883d4c15c5b70e Mon Sep 17 00:00:00 2001
From: David Mládek <david.mladek.cz@gmail.com>
Date: Sat, 12 Jul 2025 16:44:34 +0200
Subject: Implement resolver warnings about reexporting private dependencies

---
 compiler/rustc_lint/messages.ftl               |  3 ++
 compiler/rustc_lint/src/early/diagnostics.rs   |  3 ++
 compiler/rustc_lint/src/lints.rs               |  8 +++++
 compiler/rustc_lint_defs/src/lib.rs            |  5 +++
 compiler/rustc_resolve/src/imports.rs          | 25 ++++++++++++--
 tests/ui/privacy/pub-priv-dep/pub-priv1.rs     | 14 ++++----
 tests/ui/privacy/pub-priv-dep/pub-priv1.stderr | 46 +++++++++++++++++++++++---
 7 files changed, 90 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 8d9f2385b71..183db43ca76 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -744,6 +744,9 @@ lint_redundant_semicolons_suggestion = remove {$multiple_semicolons ->
         *[false] this semicolon
     }
 
+lint_reexport_private_dependency =
+    {$kind} `{$name}` from private dependency '{$krate}' is re-exported
+
 lint_remove_mut_from_pattern = remove `mut` from the parameter
 
 lint_removed_lint = lint `{$name}` has been removed: {$reason}
diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
index 653559009cc..f0fbf5bc81e 100644
--- a/compiler/rustc_lint/src/early/diagnostics.rs
+++ b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -351,6 +351,9 @@ pub fn decorate_builtin_lint(
             }
             .decorate_lint(diag);
         }
+        BuiltinLintDiag::ReexportPrivateDependency { name, kind, krate } => {
+            lints::ReexportPrivateDependency { name, kind, krate }.decorate_lint(diag);
+        }
         BuiltinLintDiag::UnusedQualifications { removal_span } => {
             lints::UnusedQualifications { removal_span }.decorate_lint(diag);
         }
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 21148833eaf..fc3c1073259 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -3080,6 +3080,14 @@ pub(crate) struct HiddenGlobReexports {
     pub namespace: String,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(lint_reexport_private_dependency)]
+pub(crate) struct ReexportPrivateDependency {
+    pub name: String,
+    pub kind: String,
+    pub krate: Symbol,
+}
+
 #[derive(LintDiagnostic)]
 #[diag(lint_unnecessary_qualification)]
 pub(crate) struct UnusedQualifications {
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index cd402c9234f..fe068d96b74 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -739,6 +739,11 @@ pub enum BuiltinLintDiag {
         /// The local binding that shadows the glob reexport.
         private_item_span: Span,
     },
+    ReexportPrivateDependency {
+        name: String,
+        kind: String,
+        krate: Symbol,
+    },
     UnusedQualifications {
         /// The span of the unnecessarily-qualified path to remove.
         removal_span: Span,
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index b2f6ee6563c..9e8eac75fa1 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -14,8 +14,8 @@ use rustc_middle::metadata::{ModChild, Reexport};
 use rustc_middle::{span_bug, ty};
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{
-    AMBIGUOUS_GLOB_REEXPORTS, HIDDEN_GLOB_REEXPORTS, PUB_USE_OF_PRIVATE_EXTERN_CRATE,
-    REDUNDANT_IMPORTS, UNUSED_IMPORTS,
+    AMBIGUOUS_GLOB_REEXPORTS, EXPORTED_PRIVATE_DEPENDENCIES, HIDDEN_GLOB_REEXPORTS,
+    PUB_USE_OF_PRIVATE_EXTERN_CRATE, REDUNDANT_IMPORTS, UNUSED_IMPORTS,
 };
 use rustc_session::parse::feature_err;
 use rustc_span::edit_distance::find_best_match_for_name;
@@ -696,6 +696,27 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         }
                     }
                 }
+
+                if let NameBindingKind::Import { import, .. } = binding.kind
+                    && let Some(binding_id) = import.id()
+                    && let import_def_id = self.local_def_id(binding_id)
+                    && self.effective_visibilities.is_exported(import_def_id)
+                    && let Res::Def(reexported_kind, reexported_def_id) = binding.res()
+                    && !matches!(reexported_kind, DefKind::Ctor(..))
+                    && !reexported_def_id.is_local()
+                    && self.tcx.is_private_dep(reexported_def_id.krate)
+                {
+                    self.lint_buffer.buffer_lint(
+                        EXPORTED_PRIVATE_DEPENDENCIES,
+                        binding_id,
+                        binding.span,
+                        BuiltinLintDiag::ReexportPrivateDependency {
+                            kind: binding.res().descr().to_string(),
+                            name: key.ident.name.to_string(),
+                            krate: self.tcx.crate_name(reexported_def_id.krate),
+                        },
+                    );
+                }
             }
         }
     }
diff --git a/tests/ui/privacy/pub-priv-dep/pub-priv1.rs b/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
index 877029f3de3..192ca0db8bd 100644
--- a/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
+++ b/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
@@ -9,10 +9,10 @@
 #![deny(exported_private_dependencies)]
 
 // This crate is a private dependency
-// FIXME: This should trigger.
 pub extern crate priv_dep;
+//~^ ERROR crate `priv_dep` from private dependency 'priv_dep' is re-exported
 // This crate is a public dependency
-extern crate pub_dep;
+pub extern crate pub_dep;
 // This crate is a private dependency
 extern crate pm;
 
@@ -91,16 +91,16 @@ pub struct AllowedPrivType {
     pub allowed: OtherType,
 }
 
-// FIXME: This should trigger.
 pub use priv_dep::m;
-// FIXME: This should trigger.
+//~^ ERROR macro `m` from private dependency 'priv_dep' is re-exported
 pub use pm::fn_like;
-// FIXME: This should trigger.
+//~^ ERROR macro `fn_like` from private dependency 'pm' is re-exported
 pub use pm::PmDerive;
-// FIXME: This should trigger.
+//~^ ERROR macro `PmDerive` from private dependency 'pm' is re-exported
 pub use pm::pm_attr;
+//~^ ERROR macro `pm_attr` from private dependency 'pm' is re-exported
 
-// FIXME: This should trigger.
 pub use priv_dep::E::V1;
+//~^ ERROR variant `V1` from private dependency 'priv_dep' is re-exported
 
 fn main() {}
diff --git a/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr b/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
index adfe13424cd..9da47827be4 100644
--- a/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
+++ b/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
@@ -1,8 +1,8 @@
-error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:29:5
+error: crate `priv_dep` from private dependency 'priv_dep' is re-exported
+  --> $DIR/pub-priv1.rs:12:1
    |
-LL |     pub field: OtherType,
-   |     ^^^^^^^^^^^^^^^^^^^^
+LL | pub extern crate priv_dep;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/pub-priv1.rs:9:9
@@ -10,6 +10,42 @@ note: the lint level is defined here
 LL | #![deny(exported_private_dependencies)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: macro `m` from private dependency 'priv_dep' is re-exported
+  --> $DIR/pub-priv1.rs:94:9
+   |
+LL | pub use priv_dep::m;
+   |         ^^^^^^^^^^^
+
+error: macro `fn_like` from private dependency 'pm' is re-exported
+  --> $DIR/pub-priv1.rs:96:9
+   |
+LL | pub use pm::fn_like;
+   |         ^^^^^^^^^^^
+
+error: derive macro `PmDerive` from private dependency 'pm' is re-exported
+  --> $DIR/pub-priv1.rs:98:9
+   |
+LL | pub use pm::PmDerive;
+   |         ^^^^^^^^^^^^
+
+error: attribute macro `pm_attr` from private dependency 'pm' is re-exported
+  --> $DIR/pub-priv1.rs:100:9
+   |
+LL | pub use pm::pm_attr;
+   |         ^^^^^^^^^^^
+
+error: variant `V1` from private dependency 'priv_dep' is re-exported
+  --> $DIR/pub-priv1.rs:103:9
+   |
+LL | pub use priv_dep::E::V1;
+   |         ^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:29:5
+   |
+LL |     pub field: OtherType,
+   |     ^^^^^^^^^^^^^^^^^^^^
+
 error: type `OtherType` from private dependency 'priv_dep' in public interface
   --> $DIR/pub-priv1.rs:36:5
    |
@@ -90,5 +126,5 @@ LL | impl PubTraitOnPrivate for OtherType {}
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 14 previous errors
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From d627e252ae5f1d282f3c2ca6c0a0e24154552e8a Mon Sep 17 00:00:00 2001
From: David Mládek <david.mladek.cz@gmail.com>
Date: Sat, 12 Jul 2025 23:07:41 +0200
Subject: make `std_detect` public dependency of `std`

---
 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 62ece4b6961..ca2fb2f49a3 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -23,7 +23,7 @@ unwind = { path = "../unwind" }
 hashbrown = { version = "0.15", default-features = false, features = [
     'rustc-dep-of-std',
 ] }
-std_detect = { path = "../stdarch/crates/std_detect", default-features = false, features = [
+std_detect = { path = "../stdarch/crates/std_detect", public = true, default-features = false, features = [
     'rustc-dep-of-std',
 ] }
 
-- 
cgit 1.4.1-3-g733a5


From fecd99881d545d6096d5489419f096cffe53b171 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 14 Jul 2025 13:30:36 +0000
Subject: Setup unstable feature bound attribute

---
 .../rustc_attr_data_structures/src/attributes.rs   |  3 ++
 .../src/attributes/allow_unstable.rs               | 20 ++++++++++
 compiler/rustc_passes/messages.ftl                 |  4 ++
 compiler/rustc_passes/src/check_attr.rs            | 44 ++++++++++++++++++++++
 compiler/rustc_passes/src/errors.rs                |  9 +++++
 .../unstable_inherent_method.rs                    | 23 +++++++++++
 .../unstable_inherent_method.stderr                | 20 ++++++++++
 7 files changed, 123 insertions(+)
 create mode 100644 tests/ui/unstable-feature-bound/unstable_inherent_method.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable_inherent_method.stderr

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 995ac514d8d..5f38be346ed 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -417,6 +417,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_unsafe_specialization_marker]`.
     UnsafeSpecializationMarker(Span),
 
+    /// Represents `#[unstable_feature_bound]`.
+    UnstableFeatureBound(ThinVec<(Symbol, Span)>),
+
     /// Represents `#[used]`
     Used { used_by: UsedBy, span: Span },
     // tidy-alphabetical-end
diff --git a/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs b/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
index 1c51c3eee4e..a6bd2306ec5 100644
--- a/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
@@ -27,6 +27,26 @@ impl<S: Stage> CombineAttributeParser<S> for AllowInternalUnstableParser {
     }
 }
 
+pub(crate) struct UnstableFeatureBoundParser;
+impl<S: Stage> CombineAttributeParser<S> for UnstableFeatureBoundParser {
+    const PATH: &'static [rustc_span::Symbol] = &[sym::unstable_feature_bound];
+    type Item = (Symbol, Span);
+    const CONVERT: ConvertFn<Self::Item> = |items, _| AttributeKind::UnstableFeatureBound(items);
+    const TEMPLATE: AttributeTemplate = template!(Word, List: "feat1, feat2, ...");
+
+    fn extend<'c>(
+        cx: &'c mut AcceptContext<'_, '_, S>,
+        args: &'c ArgParser<'_>,
+    ) -> impl IntoIterator<Item = Self::Item> {
+        if !cx.features().staged_api() {
+            cx.emit_err(session_diagnostics::StabilityOutsideStd { span: cx.attr_span });
+        }
+        parse_unstable(cx, args, <Self as CombineAttributeParser<S>>::PATH[0])
+            .into_iter()
+            .zip(iter::repeat(cx.attr_span))
+    }
+}
+
 pub(crate) struct AllowConstFnUnstableParser;
 impl<S: Stage> CombineAttributeParser<S> for AllowConstFnUnstableParser {
     const PATH: &[Symbol] = &[sym::rustc_allow_const_fn_unstable];
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 3418d997b83..500b4279588 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -667,6 +667,10 @@ passes_rustc_std_internal_symbol =
     attribute should be applied to functions or statics
     .label = not a function or static
 
+passes_rustc_unstable_feature_bound =
+    attribute should be applied to `impl` or free function outside of any `impl` or trait
+    .label = not an `impl` or free function
+
 passes_should_be_applied_to_fn =
     attribute should be applied to a function definition
     .label = {$on_crate ->
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 820255afe27..89000ab2619 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -247,6 +247,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 &Attribute::Parsed(AttributeKind::FfiPure(attr_span)) => {
                     self.check_ffi_pure(attr_span, attrs, target)
                 }
+                Attribute::Parsed(AttributeKind::UnstableFeatureBound(syms)) => {
+                    self.check_unstable_feature_bound(syms.first().unwrap().1, span, target)
+                }
                 Attribute::Parsed(
                     AttributeKind::BodyStability { .. }
                     | AttributeKind::ConstStabilityIndirect
@@ -2267,6 +2270,47 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
+    fn check_unstable_feature_bound(&self, attr_span: Span, span: Span, target: Target) {
+        match target {
+            // FIXME(staged_api): There's no reason we can't support more targets here. We're just
+            // being conservative to begin with.
+            Target::Fn | Target::Impl => {}
+            Target::ExternCrate
+            | Target::Use
+            | Target::Static
+            | Target::Const
+            | Target::Closure
+            | Target::Mod
+            | Target::ForeignMod
+            | Target::GlobalAsm
+            | Target::TyAlias
+            | Target::Enum
+            | Target::Variant
+            | Target::Struct
+            | Target::Field
+            | Target::Union
+            | Target::Trait
+            | Target::TraitAlias
+            | Target::Expression
+            | Target::Statement
+            | Target::Arm
+            | Target::AssocConst
+            | Target::Method(_)
+            | Target::AssocTy
+            | Target::ForeignFn
+            | Target::ForeignStatic
+            | Target::ForeignTy
+            | Target::GenericParam(_)
+            | Target::MacroDef
+            | Target::Param
+            | Target::PatField
+            | Target::ExprField
+            | Target::WherePredicate => {
+                self.tcx.dcx().emit_err(errors::RustcUnstableFeatureBound { attr_span, span });
+            }
+        }
+    }
+
     fn check_rustc_std_internal_symbol(&self, attr_span: Span, span: Span, target: Target) {
         match target {
             Target::Fn | Target::Static | Target::ForeignFn | Target::ForeignStatic => {}
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 093a2b38804..37330c0ed6e 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -686,6 +686,15 @@ pub(crate) struct RustcAllowConstFnUnstable {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(passes_rustc_unstable_feature_bound)]
+pub(crate) struct RustcUnstableFeatureBound {
+    #[primary_span]
+    pub attr_span: Span,
+    #[label]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(passes_rustc_std_internal_symbol)]
 pub(crate) struct RustcStdInternalSymbol {
diff --git a/tests/ui/unstable-feature-bound/unstable_inherent_method.rs b/tests/ui/unstable-feature-bound/unstable_inherent_method.rs
new file mode 100644
index 00000000000..5f3095430a8
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_inherent_method.rs
@@ -0,0 +1,23 @@
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![stable(feature = "a", since = "1.1.1" )]
+
+/// FIXME(tiif): we haven't allowed marking trait and impl method as
+/// unstable yet, but it should be possible.
+
+#[stable(feature = "a", since = "1.1.1" )]
+pub trait Trait {
+    #[unstable(feature = "feat", issue = "none" )]
+    #[unstable_feature_bound(foo)]
+    //~^ ERROR: attribute should be applied to `impl` or free function outside of any `impl` or trait
+    fn foo();
+}
+
+#[stable(feature = "a", since = "1.1.1" )]
+impl Trait for u8 {
+    #[unstable_feature_bound(foo)]
+    //~^ ERROR: attribute should be applied to `impl` or free function outside of any `impl` or trait
+    fn foo() {}
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-feature-bound/unstable_inherent_method.stderr b/tests/ui/unstable-feature-bound/unstable_inherent_method.stderr
new file mode 100644
index 00000000000..fa1c39db259
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_inherent_method.stderr
@@ -0,0 +1,20 @@
+error: attribute should be applied to `impl` or free function outside of any `impl` or trait
+  --> $DIR/unstable_inherent_method.rs:11:5
+   |
+LL |     #[unstable_feature_bound(foo)]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |
+LL |     fn foo();
+   |     --------- not an `impl` or free function
+
+error: attribute should be applied to `impl` or free function outside of any `impl` or trait
+  --> $DIR/unstable_inherent_method.rs:18:5
+   |
+LL |     #[unstable_feature_bound(foo)]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |
+LL |     fn foo() {}
+   |     ----------- not an `impl` or free function
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 2586185831d318fda4de40b9fcc7c2737351292a Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 14 Jul 2025 13:31:30 +0000
Subject: Lower the UnstableFeatureBound predicate to UnstableFeature predicate

---
 compiler/rustc_hir_analysis/src/collect/predicates_of.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index a93e58b101f..60ccc484e00 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -1,6 +1,7 @@
 use std::assert_matches::assert_matches;
 
 use hir::Node;
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
@@ -333,6 +334,19 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
         predicates.extend(const_evaluatable_predicates_of(tcx, def_id, &predicates));
     }
 
+    let attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(def_id));
+    // FIXME(staged_api): We might want to look at the normal stability attributes too but
+    // first we would need a way to let std/core use APIs with unstable feature bounds from
+    // within stable APIs.
+    let allow_unstable_feature_attr =
+        find_attr!(attrs, AttributeKind::UnstableFeatureBound(i) => i)
+            .map(|i| i.as_slice())
+            .unwrap_or_default();
+
+    for (feat_name, span) in allow_unstable_feature_attr {
+        predicates.insert((ty::ClauseKind::UnstableFeature(*feat_name).upcast(tcx), *span));
+    }
+
     let mut predicates: Vec<_> = predicates.into_iter().collect();
 
     // Subtle: before we store the predicates into the tcx, we
-- 
cgit 1.4.1-3-g733a5


From 1e5c7b28772bb99b8af4ac350aaabbb28168dc99 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 14 Jul 2025 13:35:06 +0000
Subject: Add the core logic in old and new solvers

---
 compiler/rustc_middle/src/ty/context.rs            |  7 ++++
 .../src/solve/eval_ctxt/mod.rs                     | 12 +++++++
 compiler/rustc_next_trait_solver/src/solve/mod.rs  | 14 ++++++++
 .../rustc_trait_selection/src/traits/fulfill.rs    | 11 +++++-
 .../rustc_trait_selection/src/traits/select/mod.rs | 10 +++++-
 compiler/rustc_type_ir/src/infer_ctxt.rs           | 42 ++++++++++++++++++++++
 compiler/rustc_type_ir/src/inherent.rs             |  2 ++
 7 files changed, 96 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 98b2ce01d89..290213cab5e 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -833,6 +833,13 @@ impl<'tcx> rustc_type_ir::inherent::Features<TyCtxt<'tcx>> for &'tcx rustc_featu
     fn associated_const_equality(self) -> bool {
         self.associated_const_equality()
     }
+
+    fn feature_bound_holds_in_crate(self, symbol: Symbol) -> bool {
+        // We don't consider feature bounds to hold in the crate when `staged_api` feature is
+        // enabled, even if it is enabled through `#[feature]`.
+        // This is to prevent accidentally leaking unstable APIs to stable.
+        !self.staged_api() && self.enabled(symbol)
+    }
 }
 
 impl<'tcx> rustc_type_ir::inherent::Span<TyCtxt<'tcx>> for Span {
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 b42587618b5..ce9b794d40d 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
@@ -22,6 +22,7 @@ use crate::delegate::SolverDelegate;
 use crate::placeholder::BoundVarReplacer;
 use crate::solve::inspect::{self, ProofTreeBuilder};
 use crate::solve::search_graph::SearchGraph;
+use crate::solve::ty::may_use_unstable_feature;
 use crate::solve::{
     CanonicalInput, Certainty, FIXPOINT_STEP_LIMIT, Goal, GoalEvaluation, GoalEvaluationKind,
     GoalSource, GoalStalledOn, HasChanged, NestedNormalizationGoals, NoSolution, QueryInput,
@@ -550,6 +551,9 @@ where
                 ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, ty)) => {
                     self.compute_const_arg_has_type_goal(Goal { param_env, predicate: (ct, ty) })
                 }
+                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(symbol)) => {
+                    self.compute_unstable_feature_goal(param_env, symbol)
+                }
                 ty::PredicateKind::Subtype(predicate) => {
                     self.compute_subtype_goal(Goal { param_env, predicate })
                 }
@@ -1177,6 +1181,14 @@ where
     ) -> T {
         BoundVarReplacer::replace_bound_vars(&**self.delegate, universes, t).0
     }
+
+    pub(super) fn may_use_unstable_feature(
+        &self,
+        param_env: I::ParamEnv,
+        symbol: I::Symbol,
+    ) -> bool {
+        may_use_unstable_feature(&**self.delegate, param_env, symbol)
+    }
 }
 
 /// Eagerly replace aliases with inference variables, emitting `AliasRelate`
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
index e68ea22c7a2..5ea3f0d1061 100644
--- a/compiler/rustc_next_trait_solver/src/solve/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -148,6 +148,20 @@ where
         }
     }
 
+    fn compute_unstable_feature_goal(
+        &mut self,
+        param_env: <I as Interner>::ParamEnv,
+        symbol: <I as Interner>::Symbol,
+    ) -> QueryResult<I> {
+        if self.may_use_unstable_feature(param_env, symbol) {
+            self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+        } else {
+            self.evaluate_added_goals_and_make_canonical_response(Certainty::Maybe(
+                MaybeCause::Ambiguity,
+            ))
+        }
+    }
+
     #[instrument(level = "trace", skip(self))]
     fn compute_const_evaluatable_goal(
         &mut self,
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index 64a51e0550b..3e13e504266 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -11,7 +11,9 @@ use rustc_infer::traits::{
 use rustc_middle::bug;
 use rustc_middle::ty::abstract_const::NotConstEvaluatable;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
-use rustc_middle::ty::{self, Binder, Const, GenericArgsRef, TypeVisitableExt, TypingMode};
+use rustc_middle::ty::{
+    self, Binder, Const, GenericArgsRef, TypeVisitableExt, TypingMode, may_use_unstable_feature,
+};
 use thin_vec::{ThinVec, thin_vec};
 use tracing::{debug, debug_span, instrument};
 
@@ -767,6 +769,13 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                         }
                     }
                 }
+                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(symbol)) => {
+                    if may_use_unstable_feature(self.selcx.infcx, obligation.param_env, symbol) {
+                        ProcessResult::Changed(Default::default())
+                    } else {
+                        ProcessResult::Unchanged
+                    }
+                }
             },
         }
     }
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 2e65750db25..10bcf861d35 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -28,7 +28,7 @@ use rustc_middle::ty::error::TypeErrorToStringExt;
 use rustc_middle::ty::print::{PrintTraitRefExt as _, with_no_trimmed_paths};
 use rustc_middle::ty::{
     self, DeepRejectCtxt, GenericArgsRef, PolyProjectionPredicate, SizedTraitKind, Ty, TyCtxt,
-    TypeFoldable, TypeVisitableExt, TypingMode, Upcast, elaborate,
+    TypeFoldable, TypeVisitableExt, TypingMode, Upcast, elaborate, may_use_unstable_feature,
 };
 use rustc_span::{Symbol, sym};
 use tracing::{debug, instrument, trace};
@@ -832,6 +832,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     }
                 }
 
+                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(symbol)) => {
+                    if may_use_unstable_feature(self.infcx, obligation.param_env, symbol) {
+                        Ok(EvaluatedToOk)
+                    } else {
+                        Ok(EvaluatedToAmbig)
+                    }
+                }
+
                 ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(uv)) => {
                     match const_evaluatable::is_const_evaluatable(
                         self.infcx,
diff --git a/compiler/rustc_type_ir/src/infer_ctxt.rs b/compiler/rustc_type_ir/src/infer_ctxt.rs
index 6c77a90250a..b558d016448 100644
--- a/compiler/rustc_type_ir/src/infer_ctxt.rs
+++ b/compiler/rustc_type_ir/src/infer_ctxt.rs
@@ -285,3 +285,45 @@ pub trait InferCtxtLike: Sized {
 
     fn reset_opaque_types(&self);
 }
+
+pub fn may_use_unstable_feature<'a, I: Interner, Infcx>(
+    infcx: &'a Infcx,
+    param_env: I::ParamEnv,
+    symbol: I::Symbol,
+) -> bool
+where
+    Infcx: InferCtxtLike<Interner = I>,
+{
+    // Iterate through all goals in param_env to find the one that has the same symbol.
+    for pred in param_env.caller_bounds().iter() {
+        if let ty::ClauseKind::UnstableFeature(sym) = pred.kind().skip_binder() {
+            if sym == symbol {
+                return true;
+            }
+        }
+    }
+
+    // During codegen we must assume that all feature bounds hold as we may be
+    // monomorphizing a body from an upstream crate which had an unstable feature
+    // enabled that we do not.
+    //
+    // Coherence should already report overlap errors involving unstable impls
+    // as the affected code would otherwise break when stabilizing this feature.
+    // It is also easily possible to accidentally cause unsoundness this way as
+    // we have to always enable unstable impls during codegen.
+    //
+    // Return ambiguity can also prevent people from writing code which depends on inference guidance
+    // that might no longer work after the impl is stabilised,
+    // tests/ui/unstable-feature-bound/unstable_impl_method_selection.rs is one of the example.
+    //
+    // Note: `feature_bound_holds_in_crate` does not consider a feature to be enabled
+    // if we are in std/core even if there is a corresponding `feature` attribute on the crate.
+
+    if (infcx.typing_mode() == TypingMode::PostAnalysis)
+        || infcx.cx().features().feature_bound_holds_in_crate(symbol)
+    {
+        return true;
+    } else {
+        return false;
+    }
+}
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index 2754d40fd36..0e307e15d5b 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -630,6 +630,8 @@ pub trait Features<I: Interner>: Copy {
     fn coroutine_clone(self) -> bool;
 
     fn associated_const_equality(self) -> bool;
+
+    fn feature_bound_holds_in_crate(self, symbol: I::Symbol) -> bool;
 }
 
 pub trait DefId<I: Interner>: Copy + Debug + Hash + Eq + TypeFoldable<I> {
-- 
cgit 1.4.1-3-g733a5


From ab29256b96660ffd01ab0257588cb6cbd08355a8 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 14 Jul 2025 13:36:19 +0000
Subject: Make stability attribute not to error when unstable feature bound is
 in effect

---
 compiler/rustc_passes/src/stability.rs             | 32 ++++++++++++++++++--
 .../unstable-feature-bound-no-effect.rs            | 35 ++++++++++++++++++++++
 .../unstable-feature-bound-no-effect.stderr        | 11 +++++++
 3 files changed, 76 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/unstable-feature-bound/unstable-feature-bound-no-effect.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable-feature-bound-no-effect.stderr

diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index adda94fda8f..e5530d52686 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -802,12 +802,28 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                     // FIXME(jdonszelmann): make it impossible to miss the or_else in the typesystem
                     let const_stab = attrs::find_attr!(attrs, AttributeKind::ConstStability{stability, ..} => *stability);
 
+                    let unstable_feature_stab =
+                        find_attr!(attrs, AttributeKind::UnstableFeatureBound(i) => i)
+                            .map(|i| i.as_slice())
+                            .unwrap_or_default();
+
                     // If this impl block has an #[unstable] attribute, give an
                     // error if all involved types and traits are stable, because
                     // it will have no effect.
                     // See: https://github.com/rust-lang/rust/issues/55436
+                    //
+                    // The exception is when there are both  #[unstable_feature_bound(..)] and
+                    //  #![unstable(feature = "..", issue = "..")] that have the same symbol because
+                    // that can effectively mark an impl as unstable.
+                    //
+                    // For example:
+                    // ```
+                    // #[unstable_feature_bound(feat_foo)]
+                    // #[unstable(feature = "feat_foo", issue = "none")]
+                    // impl Foo for Bar {}
+                    // ```
                     if let Some((
-                        Stability { level: attrs::StabilityLevel::Unstable { .. }, .. },
+                        Stability { level: attrs::StabilityLevel::Unstable { .. }, feature },
                         span,
                     )) = stab
                     {
@@ -815,9 +831,21 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                         c.visit_ty_unambig(self_ty);
                         c.visit_trait_ref(t);
 
+                        // Skip the lint if the impl is marked as unstable using
+                        // #[unstable_feature_bound(..)]
+                        let mut unstable_feature_bound_in_effect = false;
+                        for (unstable_bound_feat_name, _) in unstable_feature_stab {
+                            if *unstable_bound_feat_name == feature {
+                                unstable_feature_bound_in_effect = true;
+                            }
+                        }
+
                         // do not lint when the trait isn't resolved, since resolution error should
                         // be fixed first
-                        if t.path.res != Res::Err && c.fully_stable {
+                        if t.path.res != Res::Err
+                            && c.fully_stable
+                            && !unstable_feature_bound_in_effect
+                        {
                             self.tcx.emit_node_span_lint(
                                 INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
                                 item.hir_id(),
diff --git a/tests/ui/unstable-feature-bound/unstable-feature-bound-no-effect.rs b/tests/ui/unstable-feature-bound/unstable-feature-bound-no-effect.rs
new file mode 100644
index 00000000000..99501893ae0
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-feature-bound-no-effect.rs
@@ -0,0 +1,35 @@
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![allow(dead_code)]
+#![stable(feature = "a", since = "1.1.1" )]
+
+/// If #[unstable(..)] and #[unstable_feature_name(..)] have the same feature name,
+/// the error should not be thrown as it can effectively mark an impl as unstable.
+///
+/// If the feature name in #[feature] does not exist in #[unstable_feature_bound(..)]
+/// an error should still be thrown because that feature will not be unstable.
+
+#[stable(feature = "a", since = "1.1.1")]
+trait Moo {}
+#[stable(feature = "a", since = "1.1.1")]
+trait Foo {}
+#[stable(feature = "a", since = "1.1.1")]
+trait Boo {}
+#[stable(feature = "a", since = "1.1.1")]
+pub struct Bar;
+
+
+#[unstable(feature = "feat_moo", issue = "none")]
+#[unstable_feature_bound(feat_foo)] //~^ ERROR: an `#[unstable]` annotation here has no effect
+impl Moo for Bar {}
+
+#[unstable(feature = "feat_foo", issue = "none")]
+#[unstable_feature_bound(feat_foo)]
+impl Foo for Bar {}
+
+
+#[unstable(feature = "feat_foo", issue = "none")]
+#[unstable_feature_bound(feat_foo, feat_bar)]
+impl Boo for Bar {}
+
+fn main() {}
diff --git a/tests/ui/unstable-feature-bound/unstable-feature-bound-no-effect.stderr b/tests/ui/unstable-feature-bound/unstable-feature-bound-no-effect.stderr
new file mode 100644
index 00000000000..4c8af2bbe56
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-feature-bound-no-effect.stderr
@@ -0,0 +1,11 @@
+error: an `#[unstable]` annotation here has no effect
+  --> $DIR/unstable-feature-bound-no-effect.rs:22:1
+   |
+LL | #[unstable(feature = "feat_moo", issue = "none")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #55436 <https://github.com/rust-lang/rust/issues/55436> for more information
+   = note: `#[deny(ineffective_unstable_trait_impl)]` on by default
+
+error: aborting due to 1 previous error
+
-- 
cgit 1.4.1-3-g733a5


From dd067a689a05e50b80206536de22a2400277a7f8 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 14 Jul 2025 13:37:51 +0000
Subject: Lint against having both #[unstable_feature_bound] and #[stable] on
 the same item

---
 compiler/rustc_attr_parsing/messages.ftl                   |  3 +++
 compiler/rustc_attr_parsing/src/attributes/stability.rs    | 10 ++++++++++
 compiler/rustc_attr_parsing/src/session_diagnostics.rs     |  8 ++++++++
 .../unstable_feature_bound_incompatible_stability.rs       | 14 ++++++++++++++
 .../unstable_feature_bound_incompatible_stability.stderr   | 10 ++++++++++
 5 files changed, 45 insertions(+)
 create mode 100644 tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.stderr

diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
index 8d0ead63a8d..35ff48cb5f2 100644
--- a/compiler/rustc_attr_parsing/messages.ftl
+++ b/compiler/rustc_attr_parsing/messages.ftl
@@ -136,6 +136,9 @@ attr_parsing_unrecognized_repr_hint =
 attr_parsing_unstable_cfg_target_compact =
     compact `cfg(target(..))` is experimental and subject to change
 
+attr_parsing_unstable_feature_bound_incompatible_stability = Item annotated with `#[unstable_feature_bound]` should not be stable
+    .help = If this item is meant to be stable, do not use any functions annotated with `#[unstable_feature_bound]`. Otherwise, mark this item as unstable with `#[unstable]`
+
 attr_parsing_unsupported_literal_cfg_boolean =
     literal in `cfg` predicate value must be a boolean
 attr_parsing_unsupported_literal_cfg_string =
diff --git a/compiler/rustc_attr_parsing/src/attributes/stability.rs b/compiler/rustc_attr_parsing/src/attributes/stability.rs
index 6bccd0042a8..8f405e5aad9 100644
--- a/compiler/rustc_attr_parsing/src/attributes/stability.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/stability.rs
@@ -98,6 +98,16 @@ impl<S: Stage> AttributeParser<S> for StabilityParser {
             }
         }
 
+        if let Some((Stability { level: StabilityLevel::Stable { .. }, .. }, _)) = self.stability {
+            for other_attr in cx.all_attrs {
+                if other_attr.word_is(sym::unstable_feature_bound) {
+                    cx.emit_err(session_diagnostics::UnstableFeatureBoundIncompatibleStability {
+                        span: cx.target_span,
+                    });
+                }
+            }
+        }
+
         let (stability, span) = self.stability?;
 
         Some(AttributeKind::Stability { stability, span })
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index 97bf3d1c549..5b0bf0e6662 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -503,6 +503,14 @@ pub(crate) struct UnrecognizedReprHint {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(attr_parsing_unstable_feature_bound_incompatible_stability)]
+#[help]
+pub(crate) struct UnstableFeatureBoundIncompatibleStability {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(attr_parsing_naked_functions_incompatible_attribute, code = E0736)]
 pub(crate) struct NakedFunctionIncompatibleAttribute {
diff --git a/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.rs b/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.rs
new file mode 100644
index 00000000000..1a9652c1023
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.rs
@@ -0,0 +1,14 @@
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![allow(dead_code)]
+#![stable(feature = "a", since = "1.1.1" )]
+
+// Lint against the usage of both #[unstable_feature_bound] and #[stable] on the
+// same item.
+
+#[stable(feature = "a", since = "1.1.1")]
+#[unstable_feature_bound(feat_bar)]
+fn bar() {}
+//~^ ERROR Item annotated with `#[unstable_feature_bound]` should not be stable
+
+fn main() {}
diff --git a/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.stderr b/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.stderr
new file mode 100644
index 00000000000..9cb6a181bef
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_feature_bound_incompatible_stability.stderr
@@ -0,0 +1,10 @@
+error: Item annotated with `#[unstable_feature_bound]` should not be stable
+  --> $DIR/unstable_feature_bound_incompatible_stability.rs:11:1
+   |
+LL | fn bar() {}
+   | ^^^^^^^^^^^
+   |
+   = help: If this item is meant to be stable, do not use any functions annotated with `#[unstable_feature_bound]`. Otherwise, mark this item as unstable with `#[unstable]`
+
+error: aborting due to 1 previous error
+
-- 
cgit 1.4.1-3-g733a5


From 7356ff7517f4d95583f8fd6d631441893c87dd3f Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 14 Jul 2025 13:38:19 +0000
Subject: Implement other logics

---
 .../src/encode_cross_crate.rs                      |  1 +
 compiler/rustc_attr_parsing/src/context.rs         |  5 ++-
 compiler/rustc_feature/src/builtin_attrs.rs        |  4 +++
 compiler/rustc_hir_analysis/src/check/wfcheck.rs   | 14 +++++---
 .../src/collect/predicates_of.rs                   |  2 ++
 .../src/impl_wf_check/min_specialization.rs        |  1 +
 .../rustc_hir_analysis/src/outlives/explicit.rs    |  1 +
 .../src/fn_ctxt/inspect_obligations.rs             |  1 +
 compiler/rustc_hir_typeck/src/method/probe.rs      |  1 +
 compiler/rustc_lint/src/builtin.rs                 |  3 +-
 compiler/rustc_middle/src/ty/context.rs            |  1 +
 compiler/rustc_middle/src/ty/predicate.rs          |  3 ++
 compiler/rustc_middle/src/ty/print/pretty.rs       |  1 +
 compiler/rustc_privacy/src/lib.rs                  |  1 +
 .../rustc_public/src/unstable/convert/stable/ty.rs |  3 ++
 compiler/rustc_session/src/parse.rs                | 40 ++++++++++++++++++++++
 compiler/rustc_span/src/symbol.rs                  |  1 +
 .../src/error_reporting/traits/ambiguity.rs        | 25 ++++++++++++++
 .../error_reporting/traits/fulfillment_errors.rs   |  2 ++
 .../rustc_trait_selection/src/traits/auto_trait.rs |  1 +
 .../src/traits/dyn_compatibility.rs                |  2 ++
 .../rustc_trait_selection/src/traits/fulfill.rs    |  3 ++
 .../query/type_op/implied_outlives_bounds.rs       |  1 +
 compiler/rustc_trait_selection/src/traits/util.rs  |  1 +
 compiler/rustc_trait_selection/src/traits/wf.rs    |  2 ++
 .../rustc_traits/src/normalize_erasing_regions.rs  |  1 +
 compiler/rustc_type_ir/src/elaborate.rs            |  3 ++
 compiler/rustc_type_ir/src/flags.rs                |  3 +-
 compiler/rustc_type_ir/src/interner.rs             |  1 +
 compiler/rustc_type_ir/src/predicate_kind.rs       | 10 ++++++
 src/librustdoc/clean/mod.rs                        |  3 +-
 31 files changed, 132 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 494b570c86c..84c3bd1eb61 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -70,6 +70,7 @@ impl AttributeKind {
             TrackCaller(..) => Yes,
             TypeConst(..) => Yes,
             UnsafeSpecializationMarker(..) => No,
+            UnstableFeatureBound(..) => No,
             Used { .. } => No,
             // tidy-alphabetical-end
         }
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 1f6675b4c5a..390246239ed 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -13,7 +13,9 @@ use rustc_hir::{AttrArgs, AttrItem, AttrPath, Attribute, HashIgnoredAttrId, HirI
 use rustc_session::Session;
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
 
-use crate::attributes::allow_unstable::{AllowConstFnUnstableParser, AllowInternalUnstableParser};
+use crate::attributes::allow_unstable::{
+    AllowConstFnUnstableParser, AllowInternalUnstableParser, UnstableFeatureBoundParser,
+};
 use crate::attributes::codegen_attrs::{
     ColdParser, ExportNameParser, NakedParser, NoMangleParser, OmitGdbPrettyPrinterSectionParser,
     OptimizeParser, TargetFeatureParser, TrackCallerParser, UsedParser,
@@ -133,6 +135,7 @@ attribute_parsers!(
         Combine<AllowInternalUnstableParser>,
         Combine<ReprParser>,
         Combine<TargetFeatureParser>,
+        Combine<UnstableFeatureBoundParser>,
         // tidy-alphabetical-end
 
         // tidy-alphabetical-start
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 7d9915d7f68..e2827f227ab 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -683,6 +683,10 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         template!(List: r#"feature = "name", reason = "...", issue = "N""#), DuplicatesOk,
         EncodeCrossCrate::Yes
     ),
+    ungated!(
+        unstable_feature_bound, Normal, template!(Word, List: "feat1, feat2, ..."),
+        DuplicatesOk, EncodeCrossCrate::No,
+    ),
     ungated!(
         rustc_const_unstable, Normal, template!(List: r#"feature = "name""#),
         DuplicatesOk, EncodeCrossCrate::Yes
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 607028f4d9a..14ec82ede1c 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -2212,12 +2212,16 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
         let implied_obligations = traits::elaborate(tcx, predicates_with_span);
 
         for (pred, obligation_span) in implied_obligations {
-            // We lower empty bounds like `Vec<dyn Copy>:` as
-            // `WellFormed(Vec<dyn Copy>)`, which will later get checked by
-            // regular WF checking
-            if let ty::ClauseKind::WellFormed(..) = pred.kind().skip_binder() {
-                continue;
+            match pred.kind().skip_binder() {
+                // We lower empty bounds like `Vec<dyn Copy>:` as
+                // `WellFormed(Vec<dyn Copy>)`, which will later get checked by
+                // regular WF checking
+                ty::ClauseKind::WellFormed(..)
+                // Unstable feature goals cannot be proven in an empty environment so skip them
+                | ty::ClauseKind::UnstableFeature(..) => continue,
+                _ => {}
             }
+
             // Match the existing behavior.
             if pred.is_global() && !pred.has_type_flags(TypeFlags::HAS_BINDER_VARS) {
                 let pred = self.normalize(span, None, pred);
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index 60ccc484e00..af78130899e 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -778,6 +778,7 @@ pub(super) fn assert_only_contains_predicates_from<'tcx>(
                     ty::ClauseKind::RegionOutlives(_)
                     | ty::ClauseKind::ConstArgHasType(_, _)
                     | ty::ClauseKind::WellFormed(_)
+                    | ty::ClauseKind::UnstableFeature(_)
                     | ty::ClauseKind::ConstEvaluatable(_) => {
                         bug!(
                             "unexpected non-`Self` predicate when computing \
@@ -805,6 +806,7 @@ pub(super) fn assert_only_contains_predicates_from<'tcx>(
                     | ty::ClauseKind::ConstArgHasType(_, _)
                     | ty::ClauseKind::WellFormed(_)
                     | ty::ClauseKind::ConstEvaluatable(_)
+                    | ty::ClauseKind::UnstableFeature(_)
                     | ty::ClauseKind::HostEffect(..) => {
                         bug!(
                             "unexpected non-`Self` predicate when computing \
diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
index 574d19a5aa5..0043f0c7117 100644
--- a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
+++ b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
@@ -499,6 +499,7 @@ fn trait_specialization_kind<'tcx>(
         | ty::ClauseKind::ConstArgHasType(..)
         | ty::ClauseKind::WellFormed(_)
         | ty::ClauseKind::ConstEvaluatable(..)
+        | ty::ClauseKind::UnstableFeature(_)
         | ty::ClauseKind::HostEffect(..) => None,
     }
 }
diff --git a/compiler/rustc_hir_analysis/src/outlives/explicit.rs b/compiler/rustc_hir_analysis/src/outlives/explicit.rs
index 2c1d443f951..d3a57a4d8e5 100644
--- a/compiler/rustc_hir_analysis/src/outlives/explicit.rs
+++ b/compiler/rustc_hir_analysis/src/outlives/explicit.rs
@@ -54,6 +54,7 @@ impl<'tcx> ExplicitPredicatesMap<'tcx> {
                     | ty::ClauseKind::ConstArgHasType(_, _)
                     | ty::ClauseKind::WellFormed(_)
                     | ty::ClauseKind::ConstEvaluatable(_)
+                    | ty::ClauseKind::UnstableFeature(_)
                     | ty::ClauseKind::HostEffect(..) => {}
                 }
             }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/inspect_obligations.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/inspect_obligations.rs
index e4c62bf027b..367e2b6b372 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/inspect_obligations.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/inspect_obligations.rs
@@ -54,6 +54,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             | ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..))
             | ty::PredicateKind::ConstEquate(..)
             | ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(..))
+            | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_))
             | ty::PredicateKind::Ambiguous => false,
         }
     }
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index 94c93e73627..3261327a9fd 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -921,6 +921,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 | ty::ClauseKind::ConstArgHasType(_, _)
                 | ty::ClauseKind::WellFormed(_)
                 | ty::ClauseKind::ConstEvaluatable(_)
+                | ty::ClauseKind::UnstableFeature(_)
                 | ty::ClauseKind::HostEffect(..) => None,
             }
         });
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 255ff56f62b..8244f0bed4c 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -1519,8 +1519,9 @@ impl<'tcx> LateLintPass<'tcx> for TrivialConstraints {
                     ClauseKind::TypeOutlives(..) |
                     ClauseKind::RegionOutlives(..) => "lifetime",
 
+                    ClauseKind::UnstableFeature(_)
                     // `ConstArgHasType` is never global as `ct` is always a param
-                    ClauseKind::ConstArgHasType(..)
+                    | ClauseKind::ConstArgHasType(..)
                     // Ignore projections, as they can only be global
                     // if the trait bound is global
                     | ClauseKind::Projection(..)
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 290213cab5e..915b062417f 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -137,6 +137,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     type FnInputTys = &'tcx [Ty<'tcx>];
     type ParamTy = ParamTy;
     type BoundTy = ty::BoundTy;
+    type Symbol = Symbol;
 
     type PlaceholderTy = ty::PlaceholderType;
     type ErrorGuaranteed = ErrorGuaranteed;
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
index bc2ac42b6b1..ec2224877a8 100644
--- a/compiler/rustc_middle/src/ty/predicate.rs
+++ b/compiler/rustc_middle/src/ty/predicate.rs
@@ -131,6 +131,7 @@ impl<'tcx> Predicate<'tcx> {
             | PredicateKind::Clause(ClauseKind::TypeOutlives(_))
             | PredicateKind::Clause(ClauseKind::Projection(_))
             | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
+            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
             | PredicateKind::DynCompatible(_)
             | PredicateKind::Subtype(_)
             | PredicateKind::Coerce(_)
@@ -649,6 +650,7 @@ impl<'tcx> Predicate<'tcx> {
             PredicateKind::Clause(ClauseKind::Projection(..))
             | PredicateKind::Clause(ClauseKind::HostEffect(..))
             | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
+            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
             | PredicateKind::NormalizesTo(..)
             | PredicateKind::AliasRelate(..)
             | PredicateKind::Subtype(..)
@@ -670,6 +672,7 @@ impl<'tcx> Predicate<'tcx> {
             PredicateKind::Clause(ClauseKind::Trait(..))
             | PredicateKind::Clause(ClauseKind::HostEffect(..))
             | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
+            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
             | PredicateKind::NormalizesTo(..)
             | PredicateKind::AliasRelate(..)
             | PredicateKind::Subtype(..)
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 7c48a4b0885..b857788b8b7 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -3237,6 +3237,7 @@ define_print! {
             ty::ClauseKind::ConstEvaluatable(ct) => {
                 p!("the constant `", print(ct), "` can be evaluated")
             }
+            ty::ClauseKind::UnstableFeature(symbol) => p!("unstable feature: ", write("`{}`", symbol)),
         }
     }
 
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index ab2433234aa..80c13e44d7d 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -156,6 +156,7 @@ where
             }
             ty::ClauseKind::ConstEvaluatable(ct) => ct.visit_with(self),
             ty::ClauseKind::WellFormed(term) => term.visit_with(self),
+            ty::ClauseKind::UnstableFeature(_) => V::Result::output(),
         }
     }
 
diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
index 75c29788787..6b226b8a24d 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
@@ -764,6 +764,9 @@ impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> {
             ClauseKind::HostEffect(..) => {
                 todo!()
             }
+            ClauseKind::UnstableFeature(_) => {
+                todo!()
+            }
         }
     }
 }
diff --git a/compiler/rustc_session/src/parse.rs b/compiler/rustc_session/src/parse.rs
index 0118cdb1fc2..ea7a524efe6 100644
--- a/compiler/rustc_session/src/parse.rs
+++ b/compiler/rustc_session/src/parse.rs
@@ -205,6 +205,46 @@ pub fn add_feature_diagnostics_for_issue<G: EmissionGuarantee>(
     }
 }
 
+/// This is only used by unstable_feature_bound as it does not have issue number information for now.
+/// This is basically the same as `feature_err_issue`
+/// but without the feature issue note. If we can do a lookup for issue number from feature name,
+/// then we should directly use `feature_err_issue` for ambiguity error of
+/// #[unstable_feature_bound].
+#[track_caller]
+pub fn feature_err_unstable_feature_bound(
+    sess: &Session,
+    feature: Symbol,
+    span: impl Into<MultiSpan>,
+    explain: impl Into<DiagMessage>,
+) -> Diag<'_> {
+    let span = span.into();
+
+    // Cancel an earlier warning for this same error, if it exists.
+    if let Some(span) = span.primary_span() {
+        if let Some(err) = sess.dcx().steal_non_err(span, StashKey::EarlySyntaxWarning) {
+            err.cancel()
+        }
+    }
+
+    let mut err = sess.dcx().create_err(FeatureGateError { span, explain: explain.into() });
+
+    // #23973: do not suggest `#![feature(...)]` if we are in beta/stable
+    if sess.psess.unstable_features.is_nightly_build() {
+        err.subdiagnostic(FeatureDiagnosticHelp { feature });
+
+        if feature == sym::rustc_attrs {
+            // We're unlikely to stabilize something out of `rustc_attrs`
+            // without at least renaming it, so pointing out how old
+            // the compiler is will do little good.
+        } else if sess.opts.unstable_opts.ui_testing {
+            err.subdiagnostic(SuggestUpgradeCompiler::ui_testing());
+        } else if let Some(suggestion) = SuggestUpgradeCompiler::new() {
+            err.subdiagnostic(suggestion);
+        }
+    }
+    err
+}
+
 /// Info about a parsing session.
 pub struct ParseSess {
     dcx: DiagCtxt,
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 8b12edf426c..bd34055f851 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -2284,6 +2284,7 @@ symbols! {
         unsized_locals,
         unsized_tuple_coercion,
         unstable,
+        unstable_feature_bound,
         unstable_location_reason_default: "this crate is being loaded from the sysroot, an \
                           unstable location; did you mean to load this crate \
                           from crates.io via `Cargo.toml` instead?",
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 712e88300ff..98f67257fd1 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs
@@ -12,6 +12,7 @@ use rustc_infer::traits::{
     Obligation, ObligationCause, ObligationCauseCode, PolyTraitObligation, PredicateObligation,
 };
 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};
 use tracing::{debug, instrument};
 
@@ -611,6 +612,30 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 )
                 .with_span_label(span, format!("cannot normalize `{alias}`"))
             }
+            ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(sym)) => {
+                if let Some(e) = self.tainted_by_errors() {
+                    return e;
+                }
+
+                let mut err;
+
+                if self.tcx.features().staged_api() {
+                    err = self.dcx().struct_span_err(
+                        span,
+                        format!("unstable feature `{sym}` is used without being enabled."),
+                    );
+
+                    err.help(format!("The feature can be enabled by marking the current item with `#[unstable_feature_bound({sym})]`"));
+                } else {
+                    err = feature_err_unstable_feature_bound(
+                        &self.tcx.sess,
+                        sym,
+                        span,
+                        format!("use of unstable library feature `{sym}`"),
+                    );
+                }
+                err
+            }
 
             _ => {
                 if let Some(e) = self.tainted_by_errors() {
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 cd3e6c4bc54..1ac309da101 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
@@ -647,6 +647,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     | ty::PredicateKind::ConstEquate { .. }
                     // Ambiguous predicates should never error
                     | ty::PredicateKind::Ambiguous
+                    // We never return Err when proving UnstableFeature goal.
+                    | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature{ .. })
                     | ty::PredicateKind::NormalizesTo { .. }
                     | ty::PredicateKind::AliasRelate { .. }
                     | ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType { .. }) => {
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
index 3ae908ec16b..759db1d18c0 100644
--- a/compiler/rustc_trait_selection/src/traits/auto_trait.rs
+++ b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -800,6 +800,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                 // FIXME(generic_const_exprs): you can absolutely add this as a where clauses
                 | ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..))
                 | ty::PredicateKind::Coerce(..)
+                | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_))
                 | ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(..)) => {}
                 ty::PredicateKind::Ambiguous => return false,
             };
diff --git a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
index 9a4f3887bbb..ea1eed95723 100644
--- a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
+++ b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
@@ -238,6 +238,7 @@ fn predicate_references_self<'tcx>(
         // FIXME(generic_const_exprs): this can mention `Self`
         | ty::ClauseKind::ConstEvaluatable(..)
         | ty::ClauseKind::HostEffect(..)
+        | ty::ClauseKind::UnstableFeature(_)
          => None,
     }
 }
@@ -278,6 +279,7 @@ fn generics_require_sized_self(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
         | ty::ClauseKind::ConstArgHasType(_, _)
         | ty::ClauseKind::WellFormed(_)
         | ty::ClauseKind::ConstEvaluatable(_)
+        | ty::ClauseKind::UnstableFeature(_)
         | ty::ClauseKind::HostEffect(..) => false,
     })
 }
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index 3e13e504266..2b5a41ef5a7 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -406,6 +406,9 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                 ty::PredicateKind::AliasRelate(..) => {
                     bug!("AliasRelate is only used by the new solver")
                 }
+                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_)) => {
+                   unreachable!("unexpected higher ranked `UnstableFeature` goal")
+                }
             },
             Some(pred) => match pred {
                 ty::PredicateKind::Clause(ty::ClauseKind::Trait(data)) => {
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
index e294f7839aa..7540cbe3fd1 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
@@ -110,6 +110,7 @@ pub fn compute_implied_outlives_bounds_inner<'tcx>(
                 | ty::PredicateKind::ConstEquate(..)
                 | ty::PredicateKind::Ambiguous
                 | ty::PredicateKind::NormalizesTo(..)
+                | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_))
                 | ty::PredicateKind::AliasRelate(..) => {}
 
                 // We need to search through *all* WellFormed predicates
diff --git a/compiler/rustc_trait_selection/src/traits/util.rs b/compiler/rustc_trait_selection/src/traits/util.rs
index 141454bfe37..25cd7787a34 100644
--- a/compiler/rustc_trait_selection/src/traits/util.rs
+++ b/compiler/rustc_trait_selection/src/traits/util.rs
@@ -80,6 +80,7 @@ pub fn expand_trait_aliases<'tcx>(
             | ty::ClauseKind::ConstArgHasType(_, _)
             | ty::ClauseKind::WellFormed(_)
             | ty::ClauseKind::ConstEvaluatable(_)
+            | ty::ClauseKind::UnstableFeature(_)
             | ty::ClauseKind::HostEffect(..) => {}
         }
     }
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index fed9f254cdf..adce9850b59 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -197,6 +197,7 @@ pub fn clause_obligations<'tcx>(
         ty::ClauseKind::ConstEvaluatable(ct) => {
             wf.add_wf_preds_for_term(ct.into());
         }
+        ty::ClauseKind::UnstableFeature(_) => {}
     }
 
     wf.normalize(infcx)
@@ -1095,6 +1096,7 @@ pub fn object_region_bounds<'tcx>(
                 | ty::ClauseKind::Projection(_)
                 | ty::ClauseKind::ConstArgHasType(_, _)
                 | ty::ClauseKind::WellFormed(_)
+                | ty::ClauseKind::UnstableFeature(_)
                 | ty::ClauseKind::ConstEvaluatable(_) => None,
             }
         })
diff --git a/compiler/rustc_traits/src/normalize_erasing_regions.rs b/compiler/rustc_traits/src/normalize_erasing_regions.rs
index 68ff66bbce7..c1b848a2e79 100644
--- a/compiler/rustc_traits/src/normalize_erasing_regions.rs
+++ b/compiler/rustc_traits/src/normalize_erasing_regions.rs
@@ -57,6 +57,7 @@ fn not_outlives_predicate(p: ty::Predicate<'_>) -> bool {
         | ty::PredicateKind::Clause(ty::ClauseKind::Projection(..))
         | ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(..))
         | ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(..))
+        | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_))
         | ty::PredicateKind::NormalizesTo(..)
         | ty::PredicateKind::AliasRelate(..)
         | ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(..))
diff --git a/compiler/rustc_type_ir/src/elaborate.rs b/compiler/rustc_type_ir/src/elaborate.rs
index 7ffcf7b5d96..38008248757 100644
--- a/compiler/rustc_type_ir/src/elaborate.rs
+++ b/compiler/rustc_type_ir/src/elaborate.rs
@@ -234,6 +234,9 @@ impl<I: Interner, O: Elaboratable<I>> Elaborator<I, O> {
             ty::ClauseKind::ConstArgHasType(..) => {
                 // Nothing to elaborate
             }
+            ty::ClauseKind::UnstableFeature(_) => {
+                // Nothing to elaborate
+            }
         }
     }
 }
diff --git a/compiler/rustc_type_ir/src/flags.rs b/compiler/rustc_type_ir/src/flags.rs
index 37cc2baa402..a231908f874 100644
--- a/compiler/rustc_type_ir/src/flags.rs
+++ b/compiler/rustc_type_ir/src/flags.rs
@@ -401,7 +401,6 @@ impl<I: Interner> FlagComputation<I> {
                 self.add_const(expected);
                 self.add_const(found);
             }
-            ty::PredicateKind::Ambiguous => {}
             ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term }) => {
                 self.add_alias_term(alias);
                 self.add_term(term);
@@ -410,6 +409,8 @@ impl<I: Interner> FlagComputation<I> {
                 self.add_term(t1);
                 self.add_term(t2);
             }
+            ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_sym)) => {}
+            ty::PredicateKind::Ambiguous => {}
         }
     }
 
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index dd3cf1fc181..0ec326d2116 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -106,6 +106,7 @@ pub trait Interner:
     type ParamTy: ParamLike;
     type BoundTy: BoundVarLike<Self>;
     type PlaceholderTy: PlaceholderLike<Self, Bound = Self::BoundTy>;
+    type Symbol: Copy + Hash + PartialEq + Eq + Debug;
 
     // Things stored inside of tys
     type ErrorGuaranteed: Copy + Debug + Hash + Eq;
diff --git a/compiler/rustc_type_ir/src/predicate_kind.rs b/compiler/rustc_type_ir/src/predicate_kind.rs
index 4e41fd16ffd..8bc15ec4ff5 100644
--- a/compiler/rustc_type_ir/src/predicate_kind.rs
+++ b/compiler/rustc_type_ir/src/predicate_kind.rs
@@ -46,6 +46,13 @@ pub enum ClauseKind<I: Interner> {
     /// corresponding trait clause; this just enforces the *constness* of that
     /// implementation.
     HostEffect(ty::HostEffectPredicate<I>),
+
+    /// Support marking impl as unstable.
+    UnstableFeature(
+        #[type_foldable(identity)]
+        #[type_visitable(ignore)]
+        I::Symbol,
+    ),
 }
 
 #[derive_where(Clone, Copy, Hash, PartialEq, Eq; I: Interner)]
@@ -134,6 +141,9 @@ impl<I: Interner> fmt::Debug for ClauseKind<I> {
             ClauseKind::ConstEvaluatable(ct) => {
                 write!(f, "ConstEvaluatable({ct:?})")
             }
+            ClauseKind::UnstableFeature(feature_name) => {
+                write!(f, "UnstableFeature({feature_name:?})")
+            }
         }
     }
 }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index e7a1f4d8397..3df04091f16 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -390,7 +390,8 @@ pub(crate) fn clean_predicate<'tcx>(
         ty::ClauseKind::ConstEvaluatable(..)
         | ty::ClauseKind::WellFormed(..)
         | ty::ClauseKind::ConstArgHasType(..)
-        // FIXME(const_trait_impl): We can probably use this `HostEffect` pred to render `[const]`.
+        | ty::ClauseKind::UnstableFeature(..)
+        // FIXME(const_trait_impl): We can probably use this `HostEffect` pred to render `~const`.
         | ty::ClauseKind::HostEffect(_) => None,
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 7dd28181e2243c3715efc7e0ce49848bfd256c86 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 14 Jul 2025 13:38:36 +0000
Subject: Add tests

---
 .../auxiliary/unstable_feature.rs                  | 25 +++++++++++++
 .../auxiliary/unstable_impl_codegen_aux1.rs        | 19 ++++++++++
 .../auxiliary/unstable_impl_codegen_aux2.rs        | 13 +++++++
 .../auxiliary/unstable_impl_coherence_aux.rs       | 11 ++++++
 .../unstable_impl_method_selection_aux.rs          | 20 +++++++++++
 .../unstable-feature-bound-two-error.rs            | 12 +++++++
 .../unstable-feature-bound-two-error.stderr        | 13 +++++++
 ...le-feature-cross-crate-exact-symbol.fail.stderr | 13 +++++++
 .../unstable-feature-cross-crate-exact-symbol.rs   | 18 ++++++++++
 ...unstable-feature-cross-crate-multiple-symbol.rs | 11 ++++++
 ...e-feature-cross-crate-require-bound.fail.stderr | 13 +++++++
 .../unstable-feature-cross-crate-require-bound.rs  | 14 ++++++++
 .../unstable-feature-exact-symbol.fail.stderr      | 17 +++++++++
 .../unstable-feature-exact-symbol.rs               | 42 ++++++++++++++++++++++
 .../unstable-impl-assoc-type.fail.stderr           | 22 ++++++++++++
 .../unstable-impl-assoc-type.rs                    | 28 +++++++++++++++
 .../unstable-impl-cannot-use-feature.fail.stderr   | 17 +++++++++
 .../unstable-impl-cannot-use-feature.rs            | 30 ++++++++++++++++
 .../unstable-impl-multiple-symbol.rs               | 27 ++++++++++++++
 .../unstable_feature_bound_free_fn.fail.stderr     | 17 +++++++++
 .../unstable_feature_bound_free_fn.rs              | 40 +++++++++++++++++++++
 .../unstable_feature_bound_multi_attr.rs           | 36 +++++++++++++++++++
 .../unstable_feature_bound_multi_attr.stderr       | 18 ++++++++++
 .../unstable_feature_bound_staged_api.rs           | 13 +++++++
 .../unstable_feature_bound_staged_api.stderr       |  9 +++++
 .../unstable_impl_codegen.rs                       | 13 +++++++
 .../unstable_impl_coherence.disabled.stderr        | 13 +++++++
 .../unstable_impl_coherence.enabled.stderr         | 13 +++++++
 .../unstable_impl_coherence.rs                     | 17 +++++++++
 .../unstable_impl_method_selection.rs              | 15 ++++++++
 .../unstable_impl_method_selection.stderr          | 14 ++++++++
 31 files changed, 583 insertions(+)
 create mode 100644 tests/ui/unstable-feature-bound/auxiliary/unstable_feature.rs
 create mode 100644 tests/ui/unstable-feature-bound/auxiliary/unstable_impl_codegen_aux1.rs
 create mode 100644 tests/ui/unstable-feature-bound/auxiliary/unstable_impl_codegen_aux2.rs
 create mode 100644 tests/ui/unstable-feature-bound/auxiliary/unstable_impl_coherence_aux.rs
 create mode 100644 tests/ui/unstable-feature-bound/auxiliary/unstable_impl_method_selection_aux.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable-feature-bound-two-error.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable-feature-bound-two-error.stderr
 create mode 100644 tests/ui/unstable-feature-bound/unstable-feature-cross-crate-exact-symbol.fail.stderr
 create mode 100644 tests/ui/unstable-feature-bound/unstable-feature-cross-crate-exact-symbol.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable-feature-cross-crate-multiple-symbol.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable-feature-cross-crate-require-bound.fail.stderr
 create mode 100644 tests/ui/unstable-feature-bound/unstable-feature-cross-crate-require-bound.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable-feature-exact-symbol.fail.stderr
 create mode 100644 tests/ui/unstable-feature-bound/unstable-feature-exact-symbol.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable-impl-assoc-type.fail.stderr
 create mode 100644 tests/ui/unstable-feature-bound/unstable-impl-assoc-type.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable-impl-cannot-use-feature.fail.stderr
 create mode 100644 tests/ui/unstable-feature-bound/unstable-impl-cannot-use-feature.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable-impl-multiple-symbol.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable_feature_bound_free_fn.fail.stderr
 create mode 100644 tests/ui/unstable-feature-bound/unstable_feature_bound_free_fn.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable_feature_bound_multi_attr.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable_feature_bound_multi_attr.stderr
 create mode 100644 tests/ui/unstable-feature-bound/unstable_feature_bound_staged_api.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable_feature_bound_staged_api.stderr
 create mode 100644 tests/ui/unstable-feature-bound/unstable_impl_codegen.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable_impl_coherence.disabled.stderr
 create mode 100644 tests/ui/unstable-feature-bound/unstable_impl_coherence.enabled.stderr
 create mode 100644 tests/ui/unstable-feature-bound/unstable_impl_coherence.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable_impl_method_selection.rs
 create mode 100644 tests/ui/unstable-feature-bound/unstable_impl_method_selection.stderr

diff --git a/tests/ui/unstable-feature-bound/auxiliary/unstable_feature.rs b/tests/ui/unstable-feature-bound/auxiliary/unstable_feature.rs
new file mode 100644
index 00000000000..3749deb7627
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/auxiliary/unstable_feature.rs
@@ -0,0 +1,25 @@
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![stable(feature = "a", since = "1.1.1" )]
+
+#[stable(feature = "a", since = "1.1.1" )]
+pub trait Foo {
+    #[stable(feature = "a", since = "1.1.1" )]
+    fn foo();
+}
+#[stable(feature = "a", since = "1.1.1" )]
+pub struct Bar;
+#[stable(feature = "a", since = "1.1.1" )]
+pub struct Moo;
+
+#[unstable_feature_bound(feat_bar)]
+#[unstable(feature = "feat_bar", issue = "none" )]
+impl Foo for Bar {
+    fn foo() {}
+}
+
+#[unstable_feature_bound(feat_moo)]
+#[unstable(feature = "feat_moo", issue = "none" )]
+impl Foo for Moo {
+    fn foo() {}
+}
diff --git a/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_codegen_aux1.rs b/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_codegen_aux1.rs
new file mode 100644
index 00000000000..8c0d14a1bab
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_codegen_aux1.rs
@@ -0,0 +1,19 @@
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![stable(feature = "a", since = "1.1.1" )]
+
+/// Aux crate for unstable impl codegen test.
+
+#[stable(feature = "a", since = "1.1.1" )]
+pub trait Trait {
+    #[stable(feature = "a", since = "1.1.1" )]
+    fn method(&self);
+}
+
+#[unstable_feature_bound(foo)]
+#[unstable(feature = "foo", issue = "none" )]
+impl<T> Trait for T {
+    fn method(&self) {
+        println!("hi");
+    }
+}
diff --git a/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_codegen_aux2.rs b/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_codegen_aux2.rs
new file mode 100644
index 00000000000..1b0e2b2eec3
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_codegen_aux2.rs
@@ -0,0 +1,13 @@
+//@ aux-build:unstable_impl_codegen_aux1.rs
+#![feature(foo)]
+
+extern crate unstable_impl_codegen_aux1 as aux;
+use aux::Trait;
+
+/// Upstream crate for unstable impl codegen test
+/// that depends on aux crate in
+/// unstable_impl_codegen_aux1.rs
+
+pub fn foo<T>(a: T) {
+    a.method();
+}
diff --git a/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_coherence_aux.rs b/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_coherence_aux.rs
new file mode 100644
index 00000000000..2e055101216
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_coherence_aux.rs
@@ -0,0 +1,11 @@
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![allow(dead_code)]
+#![stable(feature = "a", since = "1.1.1" )]
+
+#[stable(feature = "a", since = "1.1.1" )]
+pub trait Trait {}
+
+#[unstable_feature_bound(foo)]
+#[unstable(feature = "foo", issue = "none" )]
+impl <T> Trait for T {}
diff --git a/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_method_selection_aux.rs b/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_method_selection_aux.rs
new file mode 100644
index 00000000000..3a433007b5d
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/auxiliary/unstable_impl_method_selection_aux.rs
@@ -0,0 +1,20 @@
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![stable(feature = "a", since = "1.1.1" )]
+
+#[stable(feature = "a", since = "1.1.1" )]
+pub trait Trait {
+    #[stable(feature = "a", since = "1.1.1" )]
+    fn foo(&self) {}
+}
+
+#[stable(feature = "a", since = "1.1.1" )]
+impl Trait for Vec<u32> {
+    fn foo(&self) {}
+}
+
+#[unstable_feature_bound(bar)]
+#[unstable(feature = "bar", issue = "none" )]
+impl Trait for Vec<u64> {
+    fn foo(&self) {}
+}
diff --git a/tests/ui/unstable-feature-bound/unstable-feature-bound-two-error.rs b/tests/ui/unstable-feature-bound/unstable-feature-bound-two-error.rs
new file mode 100644
index 00000000000..798c2d8562c
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-feature-bound-two-error.rs
@@ -0,0 +1,12 @@
+//@ aux-build:unstable_feature.rs
+extern crate unstable_feature;
+use unstable_feature::{Foo, Bar, Moo};
+
+// FIXME: both `feat_bar` and `feat_moo` are needed to pass this test,
+// but the diagnostic only will point out `feat_bar`.
+
+fn main() {
+    Bar::foo();
+    //~^ ERROR: use of unstable library feature `feat_bar` [E0658]
+    Moo::foo();
+}
diff --git a/tests/ui/unstable-feature-bound/unstable-feature-bound-two-error.stderr b/tests/ui/unstable-feature-bound/unstable-feature-bound-two-error.stderr
new file mode 100644
index 00000000000..673d10ce2ad
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-feature-bound-two-error.stderr
@@ -0,0 +1,13 @@
+error[E0658]: use of unstable library feature `feat_bar`
+  --> $DIR/unstable-feature-bound-two-error.rs:9:5
+   |
+LL |     Bar::foo();
+   |     ^^^
+   |
+   = help: add `#![feature(feat_bar)]` 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 `Bar` to implement `Foo`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-exact-symbol.fail.stderr b/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-exact-symbol.fail.stderr
new file mode 100644
index 00000000000..ce8d7358cfc
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-exact-symbol.fail.stderr
@@ -0,0 +1,13 @@
+error[E0658]: use of unstable library feature `feat_moo`
+  --> $DIR/unstable-feature-cross-crate-exact-symbol.rs:16:5
+   |
+LL |     Moo::foo();
+   |     ^^^
+   |
+   = help: add `#![feature(feat_moo)]` 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 `Moo` to implement `Foo`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-exact-symbol.rs b/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-exact-symbol.rs
new file mode 100644
index 00000000000..a427bb8eb7e
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-exact-symbol.rs
@@ -0,0 +1,18 @@
+//@ aux-build:unstable_feature.rs
+//@ revisions: pass fail
+//@[pass] check-pass
+
+#![cfg_attr(pass, feature(feat_bar, feat_moo))]
+#![cfg_attr(fail, feature(feat_bar))]
+
+extern crate unstable_feature;
+use unstable_feature::{Foo, Bar, Moo};
+
+/// To use impls gated by both `feat_foo` and `feat_moo`,
+/// both features must be enabled.
+
+fn main() {
+    Bar::foo();
+    Moo::foo();
+    //[fail]~^ ERROR:use of unstable library feature `feat_moo` [E0658]
+}
diff --git a/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-multiple-symbol.rs b/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-multiple-symbol.rs
new file mode 100644
index 00000000000..5b09c898a08
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-multiple-symbol.rs
@@ -0,0 +1,11 @@
+//@ aux-build:unstable_feature.rs
+//@ check-pass
+#![feature(feat_bar, feat_moo)]
+extern crate unstable_feature;
+use unstable_feature::{Foo, Bar};
+
+/// Bar::foo() should still be usable even if we enable multiple feature.
+
+fn main() {
+    Bar::foo();
+}
diff --git a/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-require-bound.fail.stderr b/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-require-bound.fail.stderr
new file mode 100644
index 00000000000..87a2ad41fc1
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-require-bound.fail.stderr
@@ -0,0 +1,13 @@
+error[E0658]: use of unstable library feature `feat_bar`
+  --> $DIR/unstable-feature-cross-crate-require-bound.rs:12:5
+   |
+LL |     Bar::foo();
+   |     ^^^
+   |
+   = help: add `#![feature(feat_bar)]` 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 `Bar` to implement `Foo`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-require-bound.rs b/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-require-bound.rs
new file mode 100644
index 00000000000..8be214b5324
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-feature-cross-crate-require-bound.rs
@@ -0,0 +1,14 @@
+//@ aux-build:unstable_feature.rs
+//@ revisions: pass fail
+//@[pass] check-pass
+
+#![cfg_attr(pass, feature(feat_bar))]
+extern crate unstable_feature;
+use unstable_feature::{Foo, Bar};
+
+/// #[feature(..)] is required to use unstable impl.
+
+fn main() {
+    Bar::foo();
+    //[fail]~^ ERROR: use of unstable library feature `feat_bar` [E0658]
+}
diff --git a/tests/ui/unstable-feature-bound/unstable-feature-exact-symbol.fail.stderr b/tests/ui/unstable-feature-bound/unstable-feature-exact-symbol.fail.stderr
new file mode 100644
index 00000000000..b8cb63ec65f
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-feature-exact-symbol.fail.stderr
@@ -0,0 +1,17 @@
+error: unstable feature `feat_moo` is used without being enabled.
+  --> $DIR/unstable-feature-exact-symbol.rs:37:5
+   |
+LL |     Bar::moo();
+   |     ^^^
+   |
+   = help: The feature can be enabled by marking the current item with `#[unstable_feature_bound(feat_moo)]`
+note: required for `Bar` to implement `Moo`
+  --> $DIR/unstable-feature-exact-symbol.rs:29:6
+   |
+LL | #[unstable_feature_bound(feat_moo)]
+   | ----------------------------------- unsatisfied trait bound introduced here
+LL | impl Moo for Bar {
+   |      ^^^     ^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/unstable-feature-bound/unstable-feature-exact-symbol.rs b/tests/ui/unstable-feature-bound/unstable-feature-exact-symbol.rs
new file mode 100644
index 00000000000..2de9e6a857e
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-feature-exact-symbol.rs
@@ -0,0 +1,42 @@
+//@ revisions: pass fail
+//@[pass] check-pass
+
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![allow(dead_code)]
+#![unstable(feature = "feat_foo", issue = "none" )]
+
+/// In staged-api crate, impl that is marked as unstable with
+/// feature name `feat_moo` should not be accessible
+/// if only `feat_foo` is enabled.
+
+pub trait Foo {
+    fn foo();
+}
+
+pub trait Moo {
+    fn moo();
+}
+
+pub struct Bar;
+
+#[unstable_feature_bound(feat_foo)]
+impl Foo for Bar {
+    fn foo() {}
+}
+
+#[unstable_feature_bound(feat_moo)]
+impl Moo for Bar {
+    fn moo() {}
+}
+
+#[cfg_attr(fail, unstable_feature_bound(feat_foo))]
+#[cfg_attr(pass, unstable_feature_bound(feat_foo, feat_moo))]
+fn bar() {
+    Bar::foo();
+    Bar::moo();
+    //[fail]~^ ERROR  unstable feature `feat_moo` is used without being enabled.
+
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-feature-bound/unstable-impl-assoc-type.fail.stderr b/tests/ui/unstable-feature-bound/unstable-impl-assoc-type.fail.stderr
new file mode 100644
index 00000000000..db9759b4cc3
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-impl-assoc-type.fail.stderr
@@ -0,0 +1,22 @@
+error: unstable feature `feat_foo` is used without being enabled.
+  --> $DIR/unstable-impl-assoc-type.rs:23:16
+   |
+LL |   type Assoc = Self;
+   |                ^^^^
+   |
+   = help: The feature can be enabled by marking the current item with `#[unstable_feature_bound(feat_foo)]`
+note: required for `Foo` to implement `Bar`
+  --> $DIR/unstable-impl-assoc-type.rs:19:6
+   |
+LL | #[unstable_feature_bound(feat_foo)]
+   | ----------------------------------- unsatisfied trait bound introduced here
+LL | impl Bar for Foo {}
+   |      ^^^     ^^^
+note: required by a bound in `Trait::Assoc`
+  --> $DIR/unstable-impl-assoc-type.rs:13:17
+   |
+LL |     type Assoc: Bar;
+   |                 ^^^ required by this bound in `Trait::Assoc`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/unstable-feature-bound/unstable-impl-assoc-type.rs b/tests/ui/unstable-feature-bound/unstable-impl-assoc-type.rs
new file mode 100644
index 00000000000..e31dc688dfa
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-impl-assoc-type.rs
@@ -0,0 +1,28 @@
+//@ revisions: pass fail
+//@[pass] check-pass
+
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![unstable(feature = "feat_foo", issue = "none" )]
+
+/// Test that you can't leak unstable impls through item bounds on associated types.
+
+trait Bar {}
+
+trait Trait {
+    type Assoc: Bar;
+}
+
+struct Foo;
+
+#[unstable_feature_bound(feat_foo)]
+impl Bar for Foo {}
+
+#[cfg_attr(pass, unstable_feature_bound(feat_foo))]
+impl Trait for Foo {
+  type Assoc = Self;
+  //[fail]~^ ERROR: unstable feature `feat_foo` is used without being enabled.
+
+}
+
+fn main(){}
diff --git a/tests/ui/unstable-feature-bound/unstable-impl-cannot-use-feature.fail.stderr b/tests/ui/unstable-feature-bound/unstable-impl-cannot-use-feature.fail.stderr
new file mode 100644
index 00000000000..d56072362fe
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-impl-cannot-use-feature.fail.stderr
@@ -0,0 +1,17 @@
+error: unstable feature `feat_foo` is used without being enabled.
+  --> $DIR/unstable-impl-cannot-use-feature.rs:26:5
+   |
+LL |     Bar::foo();
+   |     ^^^
+   |
+   = help: The feature can be enabled by marking the current item with `#[unstable_feature_bound(feat_foo)]`
+note: required for `Bar` to implement `Foo`
+  --> $DIR/unstable-impl-cannot-use-feature.rs:20:6
+   |
+LL | #[unstable_feature_bound(feat_foo)]
+   | ----------------------------------- unsatisfied trait bound introduced here
+LL | impl Foo for Bar {
+   |      ^^^     ^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/unstable-feature-bound/unstable-impl-cannot-use-feature.rs b/tests/ui/unstable-feature-bound/unstable-impl-cannot-use-feature.rs
new file mode 100644
index 00000000000..0da618445fd
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-impl-cannot-use-feature.rs
@@ -0,0 +1,30 @@
+//@ revisions: pass fail
+//@[pass] check-pass
+
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![allow(dead_code)]
+#![unstable(feature = "feat_foo", issue = "none" )]
+
+#![cfg_attr(fail, feature(feat_foo))]
+
+/// In staged-api crate, using an unstable impl requires
+/// #[unstable_feature_bound(..)], not  #[feature(..)].
+
+pub trait Foo {
+    fn foo();
+}
+pub struct Bar;
+
+#[unstable_feature_bound(feat_foo)]
+impl Foo for Bar {
+    fn foo() {}
+}
+
+#[cfg_attr(pass, unstable_feature_bound(feat_foo))]
+fn bar() {
+    Bar::foo();
+    //[fail]~^ ERROR: unstable feature `feat_foo` is used without being enabled.
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-feature-bound/unstable-impl-multiple-symbol.rs b/tests/ui/unstable-feature-bound/unstable-impl-multiple-symbol.rs
new file mode 100644
index 00000000000..c9a9029b0a0
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable-impl-multiple-symbol.rs
@@ -0,0 +1,27 @@
+//@ check-pass
+
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![allow(dead_code)]
+#![unstable(feature = "feat_foo", issue = "none" )]
+
+/// In staged-api crate, if feat_foo is only needed to use an impl,
+/// having both `feat_foo` and `feat_bar` will still make it pass.
+
+pub trait Foo {
+    fn foo();
+}
+pub struct Bar;
+
+// Annotate the impl as unstable.
+#[unstable_feature_bound(feat_foo)]
+impl Foo for Bar {
+    fn foo() {}
+}
+
+#[unstable_feature_bound(feat_foo, feat_bar)]
+fn bar() {
+    Bar::foo();
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-feature-bound/unstable_feature_bound_free_fn.fail.stderr b/tests/ui/unstable-feature-bound/unstable_feature_bound_free_fn.fail.stderr
new file mode 100644
index 00000000000..f8354256828
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_feature_bound_free_fn.fail.stderr
@@ -0,0 +1,17 @@
+error: unstable feature `feat_bar` is used without being enabled.
+  --> $DIR/unstable_feature_bound_free_fn.rs:36:5
+   |
+LL |     bar();
+   |     ^^^^^
+   |
+   = help: The feature can be enabled by marking the current item with `#[unstable_feature_bound(feat_bar)]`
+note: required by a bound in `bar`
+  --> $DIR/unstable_feature_bound_free_fn.rs:29:1
+   |
+LL | #[unstable_feature_bound(feat_bar)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `bar`
+LL | fn bar() {
+   |    --- required by a bound in this function
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/unstable-feature-bound/unstable_feature_bound_free_fn.rs b/tests/ui/unstable-feature-bound/unstable_feature_bound_free_fn.rs
new file mode 100644
index 00000000000..30e2ab3d65e
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_feature_bound_free_fn.rs
@@ -0,0 +1,40 @@
+//@ revisions: pass fail
+//@[pass] check-pass
+
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![allow(dead_code)]
+#![stable(feature = "a", since = "1.1.1" )]
+
+/// When a free function with #[unstable_feature_bound(feat_bar)] is called by another
+/// free function, that function should be annotated with
+/// #[unstable_feature_bound(feat_bar)] too.
+
+#[stable(feature = "a", since = "1.1.1")]
+trait Foo {
+    #[stable(feature = "a", since = "1.1.1")]
+    fn foo() {
+    }
+}
+#[stable(feature = "a", since = "1.1.1")]
+pub struct Bar;
+
+#[unstable_feature_bound(feat_bar)]
+#[unstable(feature = "feat_bar", issue = "none" )]
+impl Foo for Bar {
+    fn foo() {}
+}
+
+
+#[unstable_feature_bound(feat_bar)]
+fn bar() {
+    Bar::foo();
+}
+
+#[cfg_attr(pass, unstable_feature_bound(feat_bar))]
+fn bar2() {
+    bar();
+    //[fail]~^ERROR unstable feature `feat_bar` is used without being enabled.
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-feature-bound/unstable_feature_bound_multi_attr.rs b/tests/ui/unstable-feature-bound/unstable_feature_bound_multi_attr.rs
new file mode 100644
index 00000000000..3d6b52ba517
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_feature_bound_multi_attr.rs
@@ -0,0 +1,36 @@
+#![allow(internal_features)]
+#![feature(staged_api)]
+#![allow(dead_code)]
+#![unstable(feature = "feat_bar", issue = "none" )]
+
+/// Test the behaviour of multiple unstable_feature_bound attribute.
+
+trait Foo {
+    fn foo();
+}
+struct Bar;
+
+#[unstable_feature_bound(feat_bar, feat_koo)]
+#[unstable_feature_bound(feat_foo, feat_moo)]
+impl Foo for Bar {
+    fn foo(){}
+}
+
+#[unstable_feature_bound(feat_bar, feat_koo)]
+#[unstable_feature_bound(feat_foo, feat_moo)]
+fn moo() {
+    Bar::foo();
+}
+
+#[unstable_feature_bound(feat_bar, feat_koo, feat_foo, feat_moo)]
+fn koo() {
+    Bar::foo();
+}
+
+#[unstable_feature_bound(feat_koo, feat_foo, feat_moo)]
+fn boo() {
+    Bar::foo();
+    //~^ ERROR: unstable feature `feat_bar` is used without being enabled.
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-feature-bound/unstable_feature_bound_multi_attr.stderr b/tests/ui/unstable-feature-bound/unstable_feature_bound_multi_attr.stderr
new file mode 100644
index 00000000000..936c70c1979
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_feature_bound_multi_attr.stderr
@@ -0,0 +1,18 @@
+error: unstable feature `feat_bar` is used without being enabled.
+  --> $DIR/unstable_feature_bound_multi_attr.rs:32:5
+   |
+LL |     Bar::foo();
+   |     ^^^
+   |
+   = help: The feature can be enabled by marking the current item with `#[unstable_feature_bound(feat_bar)]`
+note: required for `Bar` to implement `Foo`
+  --> $DIR/unstable_feature_bound_multi_attr.rs:15:6
+   |
+LL | #[unstable_feature_bound(feat_bar, feat_koo)]
+   | --------------------------------------------- unsatisfied trait bound introduced here
+LL | #[unstable_feature_bound(feat_foo, feat_moo)]
+LL | impl Foo for Bar {
+   |      ^^^     ^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/unstable-feature-bound/unstable_feature_bound_staged_api.rs b/tests/ui/unstable-feature-bound/unstable_feature_bound_staged_api.rs
new file mode 100644
index 00000000000..51e388f7dd3
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_feature_bound_staged_api.rs
@@ -0,0 +1,13 @@
+/// Unstable feature bound can only be used only when
+/// #[feature(staged_api)] is enabled.
+
+pub trait Foo {
+}
+pub struct Bar;
+
+#[unstable_feature_bound(feat_bar)]
+//~^ ERROR: stability attributes may not be used outside of the standard library
+impl Foo for Bar {
+}
+
+fn main(){}
diff --git a/tests/ui/unstable-feature-bound/unstable_feature_bound_staged_api.stderr b/tests/ui/unstable-feature-bound/unstable_feature_bound_staged_api.stderr
new file mode 100644
index 00000000000..35ab89e6ad9
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_feature_bound_staged_api.stderr
@@ -0,0 +1,9 @@
+error[E0734]: stability attributes may not be used outside of the standard library
+  --> $DIR/unstable_feature_bound_staged_api.rs:8:1
+   |
+LL | #[unstable_feature_bound(feat_bar)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0734`.
diff --git a/tests/ui/unstable-feature-bound/unstable_impl_codegen.rs b/tests/ui/unstable-feature-bound/unstable_impl_codegen.rs
new file mode 100644
index 00000000000..285a64d2250
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_impl_codegen.rs
@@ -0,0 +1,13 @@
+//@ aux-build:unstable_impl_codegen_aux2.rs
+//@ run-pass
+
+/// Downstream crate for unstable impl codegen test
+/// that depends on upstream crate in
+/// unstable_impl_codegen_aux2.rs
+
+extern crate unstable_impl_codegen_aux2 as aux;
+use aux::foo;
+
+fn main() {
+    foo(1_u8);
+}
diff --git a/tests/ui/unstable-feature-bound/unstable_impl_coherence.disabled.stderr b/tests/ui/unstable-feature-bound/unstable_impl_coherence.disabled.stderr
new file mode 100644
index 00000000000..c3147558b03
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_impl_coherence.disabled.stderr
@@ -0,0 +1,13 @@
+error[E0119]: conflicting implementations of trait `Trait` for type `LocalTy`
+  --> $DIR/unstable_impl_coherence.rs:14:1
+   |
+LL | impl aux::Trait for LocalTy {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: conflicting implementation in crate `unstable_impl_coherence_aux`:
+           - impl<T> Trait for T
+             where unstable feature: `foo`;
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/unstable-feature-bound/unstable_impl_coherence.enabled.stderr b/tests/ui/unstable-feature-bound/unstable_impl_coherence.enabled.stderr
new file mode 100644
index 00000000000..c3147558b03
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_impl_coherence.enabled.stderr
@@ -0,0 +1,13 @@
+error[E0119]: conflicting implementations of trait `Trait` for type `LocalTy`
+  --> $DIR/unstable_impl_coherence.rs:14:1
+   |
+LL | impl aux::Trait for LocalTy {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: conflicting implementation in crate `unstable_impl_coherence_aux`:
+           - impl<T> Trait for T
+             where unstable feature: `foo`;
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/unstable-feature-bound/unstable_impl_coherence.rs b/tests/ui/unstable-feature-bound/unstable_impl_coherence.rs
new file mode 100644
index 00000000000..22100f85f71
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_impl_coherence.rs
@@ -0,0 +1,17 @@
+//@ aux-build:unstable_impl_coherence_aux.rs
+//@ revisions: enabled disabled
+
+#![cfg_attr(enabled, feature(foo))]
+extern crate unstable_impl_coherence_aux as aux;
+use aux::Trait;
+
+/// Coherence test for unstable impl.
+/// No matter feature `foo` is enabled or not, the impl
+/// for aux::Trait will be rejected by coherence checking.
+
+struct LocalTy;
+
+impl aux::Trait for LocalTy {}
+//~^ ERROR: conflicting implementations of trait `Trait` for type `LocalTy`
+
+fn main(){}
diff --git a/tests/ui/unstable-feature-bound/unstable_impl_method_selection.rs b/tests/ui/unstable-feature-bound/unstable_impl_method_selection.rs
new file mode 100644
index 00000000000..acf521d3130
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_impl_method_selection.rs
@@ -0,0 +1,15 @@
+//@ aux-build:unstable_impl_method_selection_aux.rs
+
+extern crate unstable_impl_method_selection_aux as aux;
+use aux::Trait;
+
+// The test below should not infer the type based on the fact
+// that `impl Trait for Vec<u64>` is unstable. This would cause breakage
+// in downstream crate once `impl Trait for Vec<u64>` is stabilised.
+
+fn bar() {
+    vec![].foo();
+    //~^ ERROR type annotations needed
+}
+
+fn main() {}
diff --git a/tests/ui/unstable-feature-bound/unstable_impl_method_selection.stderr b/tests/ui/unstable-feature-bound/unstable_impl_method_selection.stderr
new file mode 100644
index 00000000000..c2bb10f043b
--- /dev/null
+++ b/tests/ui/unstable-feature-bound/unstable_impl_method_selection.stderr
@@ -0,0 +1,14 @@
+error[E0283]: type annotations needed
+  --> $DIR/unstable_impl_method_selection.rs:11:12
+   |
+LL |     vec![].foo();
+   |            ^^^ cannot infer type for struct `Vec<_>`
+   |
+   = note: multiple `impl`s satisfying `Vec<_>: Trait` found in the `unstable_impl_method_selection_aux` crate:
+           - impl Trait for Vec<u32>;
+           - impl Trait for Vec<u64>
+             where unstable feature: `bar`;
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0283`.
-- 
cgit 1.4.1-3-g733a5


From e331de149f4fe5ddafe7f4bad13acb1499a6108e Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Mon, 14 Jul 2025 14:33:54 +0000
Subject: Fix CI

---
 compiler/rustc_session/src/parse.rs      | 2 +-
 compiler/rustc_type_ir/src/infer_ctxt.rs | 7 +------
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_session/src/parse.rs b/compiler/rustc_session/src/parse.rs
index ea7a524efe6..9097b27b86c 100644
--- a/compiler/rustc_session/src/parse.rs
+++ b/compiler/rustc_session/src/parse.rs
@@ -209,7 +209,7 @@ pub fn add_feature_diagnostics_for_issue<G: EmissionGuarantee>(
 /// This is basically the same as `feature_err_issue`
 /// but without the feature issue note. If we can do a lookup for issue number from feature name,
 /// then we should directly use `feature_err_issue` for ambiguity error of
-/// #[unstable_feature_bound].
+/// `#[unstable_feature_bound]`.
 #[track_caller]
 pub fn feature_err_unstable_feature_bound(
     sess: &Session,
diff --git a/compiler/rustc_type_ir/src/infer_ctxt.rs b/compiler/rustc_type_ir/src/infer_ctxt.rs
index b558d016448..e86a2305e23 100644
--- a/compiler/rustc_type_ir/src/infer_ctxt.rs
+++ b/compiler/rustc_type_ir/src/infer_ctxt.rs
@@ -319,11 +319,6 @@ where
     // Note: `feature_bound_holds_in_crate` does not consider a feature to be enabled
     // if we are in std/core even if there is a corresponding `feature` attribute on the crate.
 
-    if (infcx.typing_mode() == TypingMode::PostAnalysis)
+    (infcx.typing_mode() == TypingMode::PostAnalysis)
         || infcx.cx().features().feature_bound_holds_in_crate(symbol)
-    {
-        return true;
-    } else {
-        return false;
-    }
 }
-- 
cgit 1.4.1-3-g733a5


From 0a037425caed0dd80d58494caf4f22b75d5b70ae Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Sun, 6 Jul 2025 00:24:42 +0900
Subject: chore: Cleanup cargo config queries

---
 .../crates/project-model/src/cargo_config_file.rs  |  34 +++++
 .../rust-analyzer/crates/project-model/src/env.rs  | 137 ++++++++-------------
 .../rust-analyzer/crates/project-model/src/lib.rs  |   5 +-
 .../project-model/src/toolchain_info/rustc_cfg.rs  |   4 +-
 .../src/toolchain_info/target_data_layout.rs       |   4 +-
 .../src/toolchain_info/target_tuple.rs             |  50 ++++----
 .../project-model/src/toolchain_info/version.rs    |   4 +-
 .../crates/project-model/src/workspace.rs          |  46 ++++---
 8 files changed, 151 insertions(+), 133 deletions(-)
 create mode 100644 src/tools/rust-analyzer/crates/project-model/src/cargo_config_file.rs

diff --git a/src/tools/rust-analyzer/crates/project-model/src/cargo_config_file.rs b/src/tools/rust-analyzer/crates/project-model/src/cargo_config_file.rs
new file mode 100644
index 00000000000..7966f74df30
--- /dev/null
+++ b/src/tools/rust-analyzer/crates/project-model/src/cargo_config_file.rs
@@ -0,0 +1,34 @@
+//! Read `.cargo/config.toml` as a JSON object
+use rustc_hash::FxHashMap;
+use toolchain::Tool;
+
+use crate::{ManifestPath, Sysroot, utf8_stdout};
+
+pub(crate) type CargoConfigFile = serde_json::Map<String, serde_json::Value>;
+
+pub(crate) fn read(
+    manifest: &ManifestPath,
+    extra_env: &FxHashMap<String, Option<String>>,
+    sysroot: &Sysroot,
+) -> Option<CargoConfigFile> {
+    let mut cargo_config = sysroot.tool(Tool::Cargo, manifest.parent(), extra_env);
+    cargo_config
+        .args(["-Z", "unstable-options", "config", "get", "--format", "json"])
+        .env("RUSTC_BOOTSTRAP", "1");
+    if manifest.is_rust_manifest() {
+        cargo_config.arg("-Zscript");
+    }
+
+    tracing::debug!("Discovering cargo config by {:?}", cargo_config);
+    let json: serde_json::Map<String, serde_json::Value> = utf8_stdout(&mut cargo_config)
+        .inspect(|json| {
+            tracing::debug!("Discovered cargo config: {:?}", json);
+        })
+        .inspect_err(|err| {
+            tracing::debug!("Failed to discover cargo config: {:?}", err);
+        })
+        .ok()
+        .and_then(|stdout| serde_json::from_str(&stdout).ok())?;
+
+    Some(json)
+}
diff --git a/src/tools/rust-analyzer/crates/project-model/src/env.rs b/src/tools/rust-analyzer/crates/project-model/src/env.rs
index 9e0415c3b39..d281492fc98 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/env.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/env.rs
@@ -1,10 +1,9 @@
 //! Cargo-like environment variables injection.
 use base_db::Env;
-use paths::{Utf8Path, Utf8PathBuf};
-use rustc_hash::FxHashMap;
+use paths::Utf8Path;
 use toolchain::Tool;
 
-use crate::{ManifestPath, PackageData, Sysroot, TargetKind, utf8_stdout};
+use crate::{ManifestPath, PackageData, TargetKind, cargo_config_file::CargoConfigFile};
 
 /// Recreates the compile-time environment variables that Cargo sets.
 ///
@@ -61,104 +60,68 @@ pub(crate) fn inject_rustc_tool_env(env: &mut Env, cargo_name: &str, kind: Targe
     env.set("CARGO_CRATE_NAME", cargo_name.replace('-', "_"));
 }
 
-pub(crate) fn cargo_config_env(
-    manifest: &ManifestPath,
-    extra_env: &FxHashMap<String, Option<String>>,
-    sysroot: &Sysroot,
-) -> Env {
-    let mut cargo_config = sysroot.tool(Tool::Cargo, manifest.parent(), extra_env);
-    cargo_config
-        .args(["-Z", "unstable-options", "config", "get", "env"])
-        .env("RUSTC_BOOTSTRAP", "1");
-    if manifest.is_rust_manifest() {
-        cargo_config.arg("-Zscript");
-    }
-    // if successful we receive `env.key.value = "value" per entry
-    tracing::debug!("Discovering cargo config env by {:?}", cargo_config);
-    utf8_stdout(&mut cargo_config)
-        .map(|stdout| parse_output_cargo_config_env(manifest, &stdout))
-        .inspect(|env| {
-            tracing::debug!("Discovered cargo config env: {:?}", env);
-        })
-        .inspect_err(|err| {
-            tracing::debug!("Failed to discover cargo config env: {:?}", err);
-        })
-        .unwrap_or_default()
-}
-
-fn parse_output_cargo_config_env(manifest: &ManifestPath, stdout: &str) -> Env {
+pub(crate) fn cargo_config_env(manifest: &ManifestPath, config: &Option<CargoConfigFile>) -> Env {
     let mut env = Env::default();
-    let mut relatives = vec![];
-    for (key, val) in
-        stdout.lines().filter_map(|l| l.strip_prefix("env.")).filter_map(|l| l.split_once(" = "))
-    {
-        let val = val.trim_matches('"').to_owned();
-        if let Some((key, modifier)) = key.split_once('.') {
-            match modifier {
-                "relative" => relatives.push((key, val)),
-                "value" => _ = env.insert(key, val),
-                _ => {
-                    tracing::warn!(
-                        "Unknown modifier in cargo config env: {}, expected `relative` or `value`",
-                        modifier
-                    );
-                    continue;
-                }
-            }
-        } else {
-            env.insert(key, val);
-        }
-    }
+    let Some(serde_json::Value::Object(env_json)) = config.as_ref().and_then(|c| c.get("env"))
+    else {
+        return env;
+    };
+
     // FIXME: The base here should be the parent of the `.cargo/config` file, not the manifest.
     // But cargo does not provide this information.
     let base = <_ as AsRef<Utf8Path>>::as_ref(manifest.parent());
-    for (key, relative) in relatives {
-        if relative != "true" {
+
+    for (key, entry) in env_json {
+        let serde_json::Value::Object(entry) = entry else {
             continue;
-        }
-        if let Some(suffix) = env.get(key) {
-            env.insert(key, base.join(suffix).to_string());
-        }
-    }
-    env
-}
+        };
+        let Some(value) = entry.get("value").and_then(|v| v.as_str()) else {
+            continue;
+        };
 
-pub(crate) fn cargo_config_build_target_dir(
-    manifest: &ManifestPath,
-    extra_env: &FxHashMap<String, Option<String>>,
-    sysroot: &Sysroot,
-) -> Option<Utf8PathBuf> {
-    let mut cargo_config = sysroot.tool(Tool::Cargo, manifest.parent(), extra_env);
-    cargo_config
-        .args(["-Z", "unstable-options", "config", "get", "build.target-dir"])
-        .env("RUSTC_BOOTSTRAP", "1");
-    if manifest.is_rust_manifest() {
-        cargo_config.arg("-Zscript");
+        let value = if entry
+            .get("relative")
+            .and_then(|v| v.as_bool())
+            .is_some_and(std::convert::identity)
+        {
+            base.join(value).to_string()
+        } else {
+            value.to_owned()
+        };
+        env.insert(key, value);
     }
-    utf8_stdout(&mut cargo_config)
-        .map(|stdout| {
-            Utf8Path::new(stdout.trim_start_matches("build.target-dir = ").trim_matches('"'))
-                .to_owned()
-        })
-        .ok()
+
+    env
 }
 
 #[test]
 fn parse_output_cargo_config_env_works() {
-    let stdout = r#"
-env.CARGO_WORKSPACE_DIR.relative = true
-env.CARGO_WORKSPACE_DIR.value = ""
-env.RELATIVE.relative = true
-env.RELATIVE.value = "../relative"
-env.INVALID.relative = invalidbool
-env.INVALID.value = "../relative"
-env.TEST.value = "test"
-"#
-    .trim();
+    let raw = r#"
+{
+  "env": {
+    "CARGO_WORKSPACE_DIR": {
+      "relative": true,
+      "value": ""
+    },
+    "INVALID": {
+      "relative": "invalidbool",
+      "value": "../relative"
+    },
+    "RELATIVE": {
+      "relative": true,
+      "value": "../relative"
+    },
+    "TEST": {
+      "value": "test"
+    }
+  }
+}
+"#;
+    let config: CargoConfigFile = serde_json::from_str(raw).unwrap();
     let cwd = paths::Utf8PathBuf::try_from(std::env::current_dir().unwrap()).unwrap();
     let manifest = paths::AbsPathBuf::assert(cwd.join("Cargo.toml"));
     let manifest = ManifestPath::try_from(manifest).unwrap();
-    let env = parse_output_cargo_config_env(&manifest, stdout);
+    let env = cargo_config_env(&manifest, &Some(config));
     assert_eq!(env.get("CARGO_WORKSPACE_DIR").as_deref(), Some(cwd.join("").as_str()));
     assert_eq!(env.get("RELATIVE").as_deref(), Some(cwd.join("../relative").as_str()));
     assert_eq!(env.get("INVALID").as_deref(), Some("../relative"));
diff --git a/src/tools/rust-analyzer/crates/project-model/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/src/lib.rs
index 436af64cf13..3bf3d06e6b1 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/lib.rs
@@ -24,7 +24,7 @@ pub mod toolchain_info {
 
     use std::path::Path;
 
-    use crate::{ManifestPath, Sysroot};
+    use crate::{ManifestPath, Sysroot, cargo_config_file::CargoConfigFile};
 
     #[derive(Copy, Clone)]
     pub enum QueryConfig<'a> {
@@ -32,11 +32,12 @@ pub mod toolchain_info {
         Rustc(&'a Sysroot, &'a Path),
         /// Attempt to use cargo to query the desired information, honoring cargo configurations.
         /// If this fails, falls back to invoking `rustc` directly.
-        Cargo(&'a Sysroot, &'a ManifestPath),
+        Cargo(&'a Sysroot, &'a ManifestPath, &'a Option<CargoConfigFile>),
     }
 }
 
 mod build_dependencies;
+mod cargo_config_file;
 mod cargo_workspace;
 mod env;
 mod manifest_path;
diff --git a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/rustc_cfg.rs b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/rustc_cfg.rs
index a77f76797fc..6e06e88bf7a 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/rustc_cfg.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/rustc_cfg.rs
@@ -63,7 +63,7 @@ fn rustc_print_cfg(
 ) -> anyhow::Result<String> {
     const RUSTC_ARGS: [&str; 2] = ["--print", "cfg"];
     let (sysroot, current_dir) = match config {
-        QueryConfig::Cargo(sysroot, cargo_toml) => {
+        QueryConfig::Cargo(sysroot, cargo_toml, _) => {
             let mut cmd = sysroot.tool(Tool::Cargo, cargo_toml.parent(), extra_env);
             cmd.args(["rustc", "-Z", "unstable-options"]).args(RUSTC_ARGS);
             if let Some(target) = target {
@@ -109,7 +109,7 @@ mod tests {
         let sysroot = Sysroot::empty();
         let manifest_path =
             ManifestPath::try_from(AbsPathBuf::assert(Utf8PathBuf::from(manifest_path))).unwrap();
-        let cfg = QueryConfig::Cargo(&sysroot, &manifest_path);
+        let cfg = QueryConfig::Cargo(&sysroot, &manifest_path, &None);
         assert_ne!(get(cfg, None, &FxHashMap::default()), vec![]);
     }
 
diff --git a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data_layout.rs b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data_layout.rs
index a4d0ec69537..a28f468e692 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data_layout.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_data_layout.rs
@@ -20,7 +20,7 @@ pub fn get(
             })
     };
     let (sysroot, current_dir) = match config {
-        QueryConfig::Cargo(sysroot, cargo_toml) => {
+        QueryConfig::Cargo(sysroot, cargo_toml, _) => {
             let mut cmd = sysroot.tool(Tool::Cargo, cargo_toml.parent(), extra_env);
             cmd.env("RUSTC_BOOTSTRAP", "1");
             cmd.args(["rustc", "-Z", "unstable-options"]).args(RUSTC_ARGS).args([
@@ -66,7 +66,7 @@ mod tests {
         let sysroot = Sysroot::empty();
         let manifest_path =
             ManifestPath::try_from(AbsPathBuf::assert(Utf8PathBuf::from(manifest_path))).unwrap();
-        let cfg = QueryConfig::Cargo(&sysroot, &manifest_path);
+        let cfg = QueryConfig::Cargo(&sysroot, &manifest_path, &None);
         assert!(get(cfg, None, &FxHashMap::default()).is_ok());
     }
 
diff --git a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_tuple.rs b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_tuple.rs
index f6ab8532197..9f12ededb61 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_tuple.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/target_tuple.rs
@@ -5,7 +5,9 @@ use anyhow::Context;
 use rustc_hash::FxHashMap;
 use toolchain::Tool;
 
-use crate::{ManifestPath, Sysroot, toolchain_info::QueryConfig, utf8_stdout};
+use crate::{
+    Sysroot, cargo_config_file::CargoConfigFile, toolchain_info::QueryConfig, utf8_stdout,
+};
 
 /// For cargo, runs `cargo -Zunstable-options config get build.target` to get the configured project target(s).
 /// For rustc, runs `rustc --print -vV` to get the host target.
@@ -20,8 +22,8 @@ pub fn get(
     }
 
     let (sysroot, current_dir) = match config {
-        QueryConfig::Cargo(sysroot, cargo_toml) => {
-            match cargo_config_build_target(cargo_toml, extra_env, sysroot) {
+        QueryConfig::Cargo(sysroot, cargo_toml, config_file) => {
+            match config_file.as_ref().and_then(cargo_config_build_target) {
                 Some(it) => return Ok(it),
                 None => (sysroot, cargo_toml.parent().as_ref()),
             }
@@ -50,30 +52,30 @@ fn rustc_discover_host_tuple(
     }
 }
 
-fn cargo_config_build_target(
-    cargo_toml: &ManifestPath,
-    extra_env: &FxHashMap<String, Option<String>>,
-    sysroot: &Sysroot,
-) -> Option<Vec<String>> {
-    let mut cmd = sysroot.tool(Tool::Cargo, cargo_toml.parent(), extra_env);
-    cmd.current_dir(cargo_toml.parent()).env("RUSTC_BOOTSTRAP", "1");
-    cmd.args(["-Z", "unstable-options", "config", "get", "build.target"]);
-    // if successful we receive `build.target = "target-tuple"`
-    // or `build.target = ["<target 1>", ..]`
-    // this might be `error: config value `build.target` is not set` in which case we
-    // don't wanna log the error
-    utf8_stdout(&mut cmd).and_then(parse_output_cargo_config_build_target).ok()
+fn cargo_config_build_target(config: &CargoConfigFile) -> Option<Vec<String>> {
+    match parse_json_cargo_config_build_target(config) {
+        Ok(v) => v,
+        Err(e) => {
+            tracing::debug!("Failed to discover cargo config build target {e:?}");
+            None
+        }
+    }
 }
 
 // Parses `"build.target = [target-tuple, target-tuple, ...]"` or `"build.target = "target-tuple"`
-fn parse_output_cargo_config_build_target(stdout: String) -> anyhow::Result<Vec<String>> {
-    let trimmed = stdout.trim_start_matches("build.target = ").trim_matches('"');
-
-    if !trimmed.starts_with('[') {
-        return Ok([trimmed.to_owned()].to_vec());
+fn parse_json_cargo_config_build_target(
+    config: &CargoConfigFile,
+) -> anyhow::Result<Option<Vec<String>>> {
+    let target = config.get("build").and_then(|v| v.as_object()).and_then(|m| m.get("target"));
+    match target {
+        Some(serde_json::Value::String(s)) => Ok(Some(vec![s.to_owned()])),
+        Some(v) => serde_json::from_value(v.clone())
+            .map(Option::Some)
+            .context("Failed to parse `build.target` as an array of target"),
+        // t`error: config value `build.target` is not set`, in which case we
+        // don't wanna log the error
+        None => Ok(None),
     }
-
-    serde_json::from_str(trimmed).context("Failed to parse `build.target` as an array of target")
 }
 
 #[cfg(test)]
@@ -90,7 +92,7 @@ mod tests {
         let sysroot = Sysroot::empty();
         let manifest_path =
             ManifestPath::try_from(AbsPathBuf::assert(Utf8PathBuf::from(manifest_path))).unwrap();
-        let cfg = QueryConfig::Cargo(&sysroot, &manifest_path);
+        let cfg = QueryConfig::Cargo(&sysroot, &manifest_path, &None);
         assert!(get(cfg, None, &FxHashMap::default()).is_ok());
     }
 
diff --git a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/version.rs b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/version.rs
index 91ba8598591..357053d8e82 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/version.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/toolchain_info/version.rs
@@ -12,7 +12,7 @@ pub(crate) fn get(
     extra_env: &FxHashMap<String, Option<String>>,
 ) -> Result<Option<Version>, anyhow::Error> {
     let (mut cmd, prefix) = match config {
-        QueryConfig::Cargo(sysroot, cargo_toml) => {
+        QueryConfig::Cargo(sysroot, cargo_toml, _) => {
             (sysroot.tool(Tool::Cargo, cargo_toml.parent(), extra_env), "cargo ")
         }
         QueryConfig::Rustc(sysroot, current_dir) => {
@@ -44,7 +44,7 @@ mod tests {
         let sysroot = Sysroot::empty();
         let manifest_path =
             ManifestPath::try_from(AbsPathBuf::assert(Utf8PathBuf::from(manifest_path))).unwrap();
-        let cfg = QueryConfig::Cargo(&sysroot, &manifest_path);
+        let cfg = QueryConfig::Cargo(&sysroot, &manifest_path, &None);
         assert!(get(cfg, &FxHashMap::default()).is_ok());
     }
 
diff --git a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
index 43db84b4fa3..801c2abdfcc 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
@@ -25,11 +25,9 @@ use crate::{
     ProjectJson, ProjectManifest, RustSourceWorkspaceConfig, Sysroot, TargetData, TargetKind,
     WorkspaceBuildScripts,
     build_dependencies::BuildScriptOutput,
+    cargo_config_file,
     cargo_workspace::{CargoMetadataConfig, DepKind, PackageData, RustLibSource},
-    env::{
-        cargo_config_build_target_dir, cargo_config_env, inject_cargo_env,
-        inject_cargo_package_env, inject_rustc_tool_env,
-    },
+    env::{cargo_config_env, inject_cargo_env, inject_cargo_package_env, inject_rustc_tool_env},
     project_json::{Crate, CrateArrayIdx},
     sysroot::RustLibSrcWorkspace,
     toolchain_info::{QueryConfig, rustc_cfg, target_data_layout, target_tuple, version},
@@ -270,7 +268,9 @@ impl ProjectWorkspace {
 
         tracing::info!(workspace = %cargo_toml, src_root = ?sysroot.rust_lib_src_root(), root = ?sysroot.root(), "Using sysroot");
         progress("querying project metadata".to_owned());
-        let toolchain_config = QueryConfig::Cargo(&sysroot, cargo_toml);
+        let config_file = cargo_config_file::read(cargo_toml, extra_env, &sysroot);
+        let config_file_ = config_file.clone();
+        let toolchain_config = QueryConfig::Cargo(&sysroot, cargo_toml, &config_file_);
         let targets =
             target_tuple::get(toolchain_config, target.as_deref(), extra_env).unwrap_or_default();
         let toolchain = version::get(toolchain_config, extra_env)
@@ -285,7 +285,7 @@ impl ProjectWorkspace {
         let target_dir = config
             .target_dir
             .clone()
-            .or_else(|| cargo_config_build_target_dir(cargo_toml, extra_env, &sysroot))
+            .or_else(|| cargo_target_dir(cargo_toml, extra_env, &sysroot))
             .unwrap_or_else(|| workspace_dir.join("target").into());
 
         // We spawn a bunch of processes to query various information about the workspace's
@@ -397,7 +397,7 @@ impl ProjectWorkspace {
                 )
             });
             let cargo_config_extra_env =
-                s.spawn(|| cargo_config_env(cargo_toml, extra_env, &sysroot));
+                s.spawn(move || cargo_config_env(cargo_toml, &config_file));
             thread::Result::Ok((
                 rustc_cfg.join()?,
                 data_layout.join()?,
@@ -476,9 +476,7 @@ impl ProjectWorkspace {
         let target_dir = config
             .target_dir
             .clone()
-            .or_else(|| {
-                cargo_config_build_target_dir(project_json.manifest()?, &config.extra_env, &sysroot)
-            })
+            .or_else(|| cargo_target_dir(project_json.manifest()?, &config.extra_env, &sysroot))
             .unwrap_or_else(|| project_root.join("target").into());
 
         // We spawn a bunch of processes to query various information about the workspace's
@@ -554,7 +552,8 @@ impl ProjectWorkspace {
             None => Sysroot::empty(),
         };
 
-        let query_config = QueryConfig::Cargo(&sysroot, detached_file);
+        let config_file = cargo_config_file::read(detached_file, &config.extra_env, &sysroot);
+        let query_config = QueryConfig::Cargo(&sysroot, detached_file, &config_file);
         let toolchain = version::get(query_config, &config.extra_env).ok().flatten();
         let targets = target_tuple::get(query_config, config.target.as_deref(), &config.extra_env)
             .unwrap_or_default();
@@ -563,7 +562,7 @@ impl ProjectWorkspace {
         let target_dir = config
             .target_dir
             .clone()
-            .or_else(|| cargo_config_build_target_dir(detached_file, &config.extra_env, &sysroot))
+            .or_else(|| cargo_target_dir(detached_file, &config.extra_env, &sysroot))
             .unwrap_or_else(|| dir.join("target").into());
 
         let loaded_sysroot = sysroot.load_workspace(
@@ -600,8 +599,7 @@ impl ProjectWorkspace {
         )
         .ok()
         .map(|(ws, error)| {
-            let cargo_config_extra_env =
-                cargo_config_env(detached_file, &config.extra_env, &sysroot);
+            let cargo_config_extra_env = cargo_config_env(detached_file, &config_file);
             (
                 CargoWorkspace::new(ws, detached_file.clone(), cargo_config_extra_env, false),
                 WorkspaceBuildScripts::default(),
@@ -1901,3 +1899,23 @@ fn sysroot_metadata_config(
         kind: "sysroot",
     }
 }
+
+fn cargo_target_dir(
+    manifest: &ManifestPath,
+    extra_env: &FxHashMap<String, Option<String>>,
+    sysroot: &Sysroot,
+) -> Option<Utf8PathBuf> {
+    let cargo = sysroot.tool(Tool::Cargo, manifest.parent(), extra_env);
+    let mut meta = cargo_metadata::MetadataCommand::new();
+    meta.cargo_path(cargo.get_program());
+    meta.manifest_path(manifest);
+    // `--no-deps` doesn't (over)write lockfiles as it doesn't do any package resolve.
+    // So we can use it to get `target_directory` before copying lockfiles
+    let mut other_options = vec!["--no-deps".to_owned()];
+    if manifest.is_rust_manifest() {
+        meta.env("RUSTC_BOOTSTRAP", "1");
+        other_options.push("-Zscript".to_owned());
+    }
+    meta.other_options(other_options);
+    meta.exec().map(|m| m.target_directory).ok()
+}
-- 
cgit 1.4.1-3-g733a5


From a65e2f0e90f34d91130fa3d51bdfa792162f05a7 Mon Sep 17 00:00:00 2001
From: Shoyu Vanilla <modulo641@gmail.com>
Date: Mon, 7 Jul 2025 01:24:26 +0900
Subject: Further decrease number of `cargo metadata` invokes

---
 .../crates/project-model/src/cargo_workspace.rs    | 395 +++++++++++----------
 .../crates/project-model/src/sysroot.rs            |  23 +-
 .../crates/project-model/src/tests.rs              |   9 +-
 .../crates/project-model/src/workspace.rs          |  84 ++---
 .../crates/rust-analyzer/src/cli/rustc_tests.rs    |   2 +
 5 files changed, 270 insertions(+), 243 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
index 4bacc904174..daadcd9d79a 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs
@@ -300,8 +300,6 @@ pub struct CargoMetadataConfig {
     pub extra_args: Vec<String>,
     /// Extra env vars to set when invoking the cargo command
     pub extra_env: FxHashMap<String, Option<String>>,
-    /// The target dir for this workspace load.
-    pub target_dir: Utf8PathBuf,
     /// What kind of metadata are we fetching: workspace, rustc, or sysroot.
     pub kind: &'static str,
     /// The toolchain version, if known.
@@ -317,188 +315,6 @@ struct PackageMetadata {
 }
 
 impl CargoWorkspace {
-    /// Fetches the metadata for the given `cargo_toml` manifest.
-    /// A successful result may contain another metadata error if the initial fetching failed but
-    /// the `--no-deps` retry succeeded.
-    ///
-    /// The sysroot is used to set the `RUSTUP_TOOLCHAIN` env var when invoking cargo
-    /// to ensure that the rustup proxy uses the correct toolchain.
-    pub fn fetch_metadata(
-        cargo_toml: &ManifestPath,
-        current_dir: &AbsPath,
-        config: &CargoMetadataConfig,
-        sysroot: &Sysroot,
-        no_deps: bool,
-        locked: bool,
-        progress: &dyn Fn(String),
-    ) -> anyhow::Result<(cargo_metadata::Metadata, Option<anyhow::Error>)> {
-        let res = Self::fetch_metadata_(
-            cargo_toml,
-            current_dir,
-            config,
-            sysroot,
-            no_deps,
-            locked,
-            progress,
-        );
-        if let Ok((_, Some(ref e))) = res {
-            tracing::warn!(
-                %cargo_toml,
-                ?e,
-                "`cargo metadata` failed, but retry with `--no-deps` succeeded"
-            );
-        }
-        res
-    }
-
-    fn fetch_metadata_(
-        cargo_toml: &ManifestPath,
-        current_dir: &AbsPath,
-        config: &CargoMetadataConfig,
-        sysroot: &Sysroot,
-        no_deps: bool,
-        locked: bool,
-        progress: &dyn Fn(String),
-    ) -> anyhow::Result<(cargo_metadata::Metadata, Option<anyhow::Error>)> {
-        let cargo = sysroot.tool(Tool::Cargo, current_dir, &config.extra_env);
-        let mut meta = MetadataCommand::new();
-        meta.cargo_path(cargo.get_program());
-        cargo.get_envs().for_each(|(var, val)| _ = meta.env(var, val.unwrap_or_default()));
-        meta.manifest_path(cargo_toml.to_path_buf());
-        match &config.features {
-            CargoFeatures::All => {
-                meta.features(CargoOpt::AllFeatures);
-            }
-            CargoFeatures::Selected { features, no_default_features } => {
-                if *no_default_features {
-                    meta.features(CargoOpt::NoDefaultFeatures);
-                }
-                if !features.is_empty() {
-                    meta.features(CargoOpt::SomeFeatures(features.clone()));
-                }
-            }
-        }
-        meta.current_dir(current_dir);
-
-        let mut other_options = vec![];
-        // cargo metadata only supports a subset of flags of what cargo usually accepts, and usually
-        // the only relevant flags for metadata here are unstable ones, so we pass those along
-        // but nothing else
-        let mut extra_args = config.extra_args.iter();
-        while let Some(arg) = extra_args.next() {
-            if arg == "-Z" {
-                if let Some(arg) = extra_args.next() {
-                    other_options.push("-Z".to_owned());
-                    other_options.push(arg.to_owned());
-                }
-            }
-        }
-
-        if !config.targets.is_empty() {
-            other_options.extend(
-                config.targets.iter().flat_map(|it| ["--filter-platform".to_owned(), it.clone()]),
-            );
-        }
-        if no_deps {
-            other_options.push("--no-deps".to_owned());
-        }
-
-        let mut using_lockfile_copy = false;
-        // The manifest is a rust file, so this means its a script manifest
-        if cargo_toml.is_rust_manifest() {
-            other_options.push("-Zscript".to_owned());
-        } else if config
-            .toolchain_version
-            .as_ref()
-            .is_some_and(|v| *v >= MINIMUM_TOOLCHAIN_VERSION_SUPPORTING_LOCKFILE_PATH)
-        {
-            let lockfile = <_ as AsRef<Utf8Path>>::as_ref(cargo_toml).with_extension("lock");
-            let target_lockfile = config
-                .target_dir
-                .join("rust-analyzer")
-                .join("metadata")
-                .join(config.kind)
-                .join("Cargo.lock");
-            match std::fs::copy(&lockfile, &target_lockfile) {
-                Ok(_) => {
-                    using_lockfile_copy = true;
-                    other_options.push("--lockfile-path".to_owned());
-                    other_options.push(target_lockfile.to_string());
-                }
-                Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
-                    // There exists no lockfile yet
-                    using_lockfile_copy = true;
-                    other_options.push("--lockfile-path".to_owned());
-                    other_options.push(target_lockfile.to_string());
-                }
-                Err(e) => {
-                    tracing::warn!(
-                        "Failed to copy lock file from `{lockfile}` to `{target_lockfile}`: {e}",
-                    );
-                }
-            }
-        }
-        if using_lockfile_copy {
-            other_options.push("-Zunstable-options".to_owned());
-            meta.env("RUSTC_BOOTSTRAP", "1");
-        }
-        // No need to lock it if we copied the lockfile, we won't modify the original after all/
-        // This way cargo cannot error out on us if the lockfile requires updating.
-        if !using_lockfile_copy && locked {
-            other_options.push("--locked".to_owned());
-        }
-        meta.other_options(other_options);
-
-        // FIXME: Fetching metadata is a slow process, as it might require
-        // calling crates.io. We should be reporting progress here, but it's
-        // unclear whether cargo itself supports it.
-        progress("cargo metadata: started".to_owned());
-
-        let res = (|| -> anyhow::Result<(_, _)> {
-            let mut errored = false;
-            let output =
-                spawn_with_streaming_output(meta.cargo_command(), &mut |_| (), &mut |line| {
-                    errored = errored || line.starts_with("error") || line.starts_with("warning");
-                    if errored {
-                        progress("cargo metadata: ?".to_owned());
-                        return;
-                    }
-                    progress(format!("cargo metadata: {line}"));
-                })?;
-            if !output.status.success() {
-                progress(format!("cargo metadata: failed {}", output.status));
-                let error = cargo_metadata::Error::CargoMetadata {
-                    stderr: String::from_utf8(output.stderr)?,
-                }
-                .into();
-                if !no_deps {
-                    // If we failed to fetch metadata with deps, try again without them.
-                    // This makes r-a still work partially when offline.
-                    if let Ok((metadata, _)) = Self::fetch_metadata_(
-                        cargo_toml,
-                        current_dir,
-                        config,
-                        sysroot,
-                        true,
-                        locked,
-                        progress,
-                    ) {
-                        return Ok((metadata, Some(error)));
-                    }
-                }
-                return Err(error);
-            }
-            let stdout = from_utf8(&output.stdout)?
-                .lines()
-                .find(|line| line.starts_with('{'))
-                .ok_or(cargo_metadata::Error::NoJson)?;
-            Ok((cargo_metadata::MetadataCommand::parse(stdout)?, None))
-        })()
-        .with_context(|| format!("Failed to run `{:?}`", meta.cargo_command()));
-        progress("cargo metadata: finished".to_owned());
-        res
-    }
-
     pub fn new(
         mut meta: cargo_metadata::Metadata,
         ws_manifest_path: ManifestPath,
@@ -733,3 +549,214 @@ impl CargoWorkspace {
         self.requires_rustc_private
     }
 }
+
+pub(crate) struct FetchMetadata {
+    command: cargo_metadata::MetadataCommand,
+    lockfile_path: Option<Utf8PathBuf>,
+    kind: &'static str,
+    no_deps: bool,
+    no_deps_result: anyhow::Result<cargo_metadata::Metadata>,
+    other_options: Vec<String>,
+}
+
+impl FetchMetadata {
+    /// Builds a command to fetch metadata for the given `cargo_toml` manifest.
+    ///
+    /// Performs a lightweight pre-fetch using the `--no-deps` option,
+    /// available via [`FetchMetadata::no_deps_metadata`], to gather basic
+    /// information such as the `target-dir`.
+    ///
+    /// The provided sysroot is used to set the `RUSTUP_TOOLCHAIN`
+    /// environment variable when invoking Cargo, ensuring that the
+    /// rustup proxy selects the correct toolchain.
+    pub(crate) fn new(
+        cargo_toml: &ManifestPath,
+        current_dir: &AbsPath,
+        config: &CargoMetadataConfig,
+        sysroot: &Sysroot,
+        no_deps: bool,
+    ) -> Self {
+        let cargo = sysroot.tool(Tool::Cargo, current_dir, &config.extra_env);
+        let mut command = MetadataCommand::new();
+        command.cargo_path(cargo.get_program());
+        cargo.get_envs().for_each(|(var, val)| _ = command.env(var, val.unwrap_or_default()));
+        command.manifest_path(cargo_toml.to_path_buf());
+        match &config.features {
+            CargoFeatures::All => {
+                command.features(CargoOpt::AllFeatures);
+            }
+            CargoFeatures::Selected { features, no_default_features } => {
+                if *no_default_features {
+                    command.features(CargoOpt::NoDefaultFeatures);
+                }
+                if !features.is_empty() {
+                    command.features(CargoOpt::SomeFeatures(features.clone()));
+                }
+            }
+        }
+        command.current_dir(current_dir);
+
+        let mut needs_nightly = false;
+        let mut other_options = vec![];
+        // cargo metadata only supports a subset of flags of what cargo usually accepts, and usually
+        // the only relevant flags for metadata here are unstable ones, so we pass those along
+        // but nothing else
+        let mut extra_args = config.extra_args.iter();
+        while let Some(arg) = extra_args.next() {
+            if arg == "-Z" {
+                if let Some(arg) = extra_args.next() {
+                    needs_nightly = true;
+                    other_options.push("-Z".to_owned());
+                    other_options.push(arg.to_owned());
+                }
+            }
+        }
+
+        let mut lockfile_path = None;
+        if cargo_toml.is_rust_manifest() {
+            needs_nightly = true;
+            other_options.push("-Zscript".to_owned());
+        } else if config
+            .toolchain_version
+            .as_ref()
+            .is_some_and(|v| *v >= MINIMUM_TOOLCHAIN_VERSION_SUPPORTING_LOCKFILE_PATH)
+        {
+            lockfile_path = Some(<_ as AsRef<Utf8Path>>::as_ref(cargo_toml).with_extension("lock"));
+        }
+
+        if !config.targets.is_empty() {
+            other_options.extend(
+                config.targets.iter().flat_map(|it| ["--filter-platform".to_owned(), it.clone()]),
+            );
+        }
+
+        command.other_options(other_options.clone());
+
+        if needs_nightly {
+            command.env("RUSTC_BOOTSTRAP", "1");
+        }
+
+        // Pre-fetch basic metadata using `--no-deps`, which:
+        // - avoids fetching registries like crates.io,
+        // - skips dependency resolution and does not modify lockfiles,
+        // - and thus doesn't require progress reporting or copying lockfiles.
+        //
+        // Useful as a fast fallback to extract info like `target-dir`.
+        let cargo_command;
+        let no_deps_result = if no_deps {
+            command.no_deps();
+            cargo_command = command.cargo_command();
+            command.exec()
+        } else {
+            let mut no_deps_command = command.clone();
+            no_deps_command.no_deps();
+            cargo_command = no_deps_command.cargo_command();
+            no_deps_command.exec()
+        }
+        .with_context(|| format!("Failed to run `{cargo_command:?}`"));
+
+        Self { command, lockfile_path, kind: config.kind, no_deps, no_deps_result, other_options }
+    }
+
+    pub(crate) fn no_deps_metadata(&self) -> Option<&cargo_metadata::Metadata> {
+        self.no_deps_result.as_ref().ok()
+    }
+
+    /// Executes the metadata-fetching command.
+    ///
+    /// A successful result may still contain a metadata error if the full fetch failed,
+    /// but the fallback `--no-deps` pre-fetch succeeded during command construction.
+    pub(crate) fn exec(
+        self,
+        target_dir: &Utf8Path,
+        locked: bool,
+        progress: &dyn Fn(String),
+    ) -> anyhow::Result<(cargo_metadata::Metadata, Option<anyhow::Error>)> {
+        let Self { mut command, lockfile_path, kind, no_deps, no_deps_result, mut other_options } =
+            self;
+
+        if no_deps {
+            return no_deps_result.map(|m| (m, None));
+        }
+
+        let mut using_lockfile_copy = false;
+        // The manifest is a rust file, so this means its a script manifest
+        if let Some(lockfile) = lockfile_path {
+            let target_lockfile =
+                target_dir.join("rust-analyzer").join("metadata").join(kind).join("Cargo.lock");
+            match std::fs::copy(&lockfile, &target_lockfile) {
+                Ok(_) => {
+                    using_lockfile_copy = true;
+                    other_options.push("--lockfile-path".to_owned());
+                    other_options.push(target_lockfile.to_string());
+                }
+                Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+                    // There exists no lockfile yet
+                    using_lockfile_copy = true;
+                    other_options.push("--lockfile-path".to_owned());
+                    other_options.push(target_lockfile.to_string());
+                }
+                Err(e) => {
+                    tracing::warn!(
+                        "Failed to copy lock file from `{lockfile}` to `{target_lockfile}`: {e}",
+                    );
+                }
+            }
+        }
+        if using_lockfile_copy {
+            other_options.push("-Zunstable-options".to_owned());
+            command.env("RUSTC_BOOTSTRAP", "1");
+        }
+        // No need to lock it if we copied the lockfile, we won't modify the original after all/
+        // This way cargo cannot error out on us if the lockfile requires updating.
+        if !using_lockfile_copy && locked {
+            other_options.push("--locked".to_owned());
+        }
+        command.other_options(other_options);
+
+        // FIXME: Fetching metadata is a slow process, as it might require
+        // calling crates.io. We should be reporting progress here, but it's
+        // unclear whether cargo itself supports it.
+        progress("cargo metadata: started".to_owned());
+
+        let res = (|| -> anyhow::Result<(_, _)> {
+            let mut errored = false;
+            let output =
+                spawn_with_streaming_output(command.cargo_command(), &mut |_| (), &mut |line| {
+                    errored = errored || line.starts_with("error") || line.starts_with("warning");
+                    if errored {
+                        progress("cargo metadata: ?".to_owned());
+                        return;
+                    }
+                    progress(format!("cargo metadata: {line}"));
+                })?;
+            if !output.status.success() {
+                progress(format!("cargo metadata: failed {}", output.status));
+                let error = cargo_metadata::Error::CargoMetadata {
+                    stderr: String::from_utf8(output.stderr)?,
+                }
+                .into();
+                if !no_deps {
+                    // If we failed to fetch metadata with deps, return pre-fetched result without them.
+                    // This makes r-a still work partially when offline.
+                    if let Ok(metadata) = no_deps_result {
+                        tracing::warn!(
+                            ?error,
+                            "`cargo metadata` failed and returning succeeded result with `--no-deps`"
+                        );
+                        return Ok((metadata, Some(error)));
+                    }
+                }
+                return Err(error);
+            }
+            let stdout = from_utf8(&output.stdout)?
+                .lines()
+                .find(|line| line.starts_with('{'))
+                .ok_or(cargo_metadata::Error::NoJson)?;
+            Ok((cargo_metadata::MetadataCommand::parse(stdout)?, None))
+        })()
+        .with_context(|| format!("Failed to run `{:?}`", command.cargo_command()));
+        progress("cargo metadata: finished".to_owned());
+        res
+    }
+}
diff --git a/src/tools/rust-analyzer/crates/project-model/src/sysroot.rs b/src/tools/rust-analyzer/crates/project-model/src/sysroot.rs
index 9f19260d309..9781c46737d 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/sysroot.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/sysroot.rs
@@ -9,14 +9,15 @@ use std::{env, fs, ops::Not, path::Path, process::Command};
 
 use anyhow::{Result, format_err};
 use itertools::Itertools;
-use paths::{AbsPath, AbsPathBuf, Utf8PathBuf};
+use paths::{AbsPath, AbsPathBuf, Utf8Path, Utf8PathBuf};
 use rustc_hash::FxHashMap;
 use stdx::format_to;
 use toolchain::{Tool, probe_for_binary};
 
 use crate::{
     CargoWorkspace, ManifestPath, ProjectJson, RustSourceWorkspaceConfig,
-    cargo_workspace::CargoMetadataConfig, utf8_stdout,
+    cargo_workspace::{CargoMetadataConfig, FetchMetadata},
+    utf8_stdout,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -211,6 +212,7 @@ impl Sysroot {
         sysroot_source_config: &RustSourceWorkspaceConfig,
         no_deps: bool,
         current_dir: &AbsPath,
+        target_dir: &Utf8Path,
         progress: &dyn Fn(String),
     ) -> Option<RustLibSrcWorkspace> {
         assert!(matches!(self.workspace, RustLibSrcWorkspace::Empty), "workspace already loaded");
@@ -224,6 +226,7 @@ impl Sysroot {
                 match self.load_library_via_cargo(
                     &library_manifest,
                     current_dir,
+                    target_dir,
                     cargo_config,
                     no_deps,
                     progress,
@@ -319,6 +322,7 @@ impl Sysroot {
         &self,
         library_manifest: &ManifestPath,
         current_dir: &AbsPath,
+        target_dir: &Utf8Path,
         cargo_config: &CargoMetadataConfig,
         no_deps: bool,
         progress: &dyn Fn(String),
@@ -331,16 +335,11 @@ impl Sysroot {
             Some("nightly".to_owned()),
         );
 
-        let (mut res, _) = CargoWorkspace::fetch_metadata(
-            library_manifest,
-            current_dir,
-            &cargo_config,
-            self,
-            no_deps,
-            // Make sure we never attempt to write to the sysroot
-            true,
-            progress,
-        )?;
+        // Make sure we never attempt to write to the sysroot
+        let locked = true;
+        let (mut res, _) =
+            FetchMetadata::new(library_manifest, current_dir, &cargo_config, self, no_deps)
+                .exec(target_dir, locked, progress)?;
 
         // Patch out `rustc-std-workspace-*` crates to point to the real crates.
         // This is done prior to `CrateGraph` construction to prevent de-duplication logic from failing.
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 f229e9a650d..ed72520f40d 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/tests.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/tests.rs
@@ -239,8 +239,13 @@ fn smoke_test_real_sysroot_cargo() {
     );
     let cwd = AbsPathBuf::assert_utf8(temp_dir().join("smoke_test_real_sysroot_cargo"));
     std::fs::create_dir_all(&cwd).unwrap();
-    let loaded_sysroot =
-        sysroot.load_workspace(&RustSourceWorkspaceConfig::default_cargo(), false, &cwd, &|_| ());
+    let loaded_sysroot = sysroot.load_workspace(
+        &RustSourceWorkspaceConfig::default_cargo(),
+        false,
+        &cwd,
+        &Utf8PathBuf::default(),
+        &|_| (),
+    );
     if let Some(loaded_sysroot) = loaded_sysroot {
         sysroot.set_workspace(loaded_sysroot);
     }
diff --git a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
index 801c2abdfcc..677f29e3c60 100644
--- a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
+++ b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs
@@ -26,7 +26,7 @@ use crate::{
     WorkspaceBuildScripts,
     build_dependencies::BuildScriptOutput,
     cargo_config_file,
-    cargo_workspace::{CargoMetadataConfig, DepKind, PackageData, RustLibSource},
+    cargo_workspace::{CargoMetadataConfig, DepKind, FetchMetadata, PackageData, RustLibSource},
     env::{cargo_config_env, inject_cargo_env, inject_cargo_package_env, inject_rustc_tool_env},
     project_json::{Crate, CrateArrayIdx},
     sysroot::RustLibSrcWorkspace,
@@ -282,10 +282,24 @@ impl ProjectWorkspace {
             .ok()
             .flatten();
 
+        let fetch_metadata = FetchMetadata::new(
+            cargo_toml,
+            workspace_dir,
+            &CargoMetadataConfig {
+                features: features.clone(),
+                targets: targets.clone(),
+                extra_args: extra_args.clone(),
+                extra_env: extra_env.clone(),
+                toolchain_version: toolchain.clone(),
+                kind: "workspace",
+            },
+            &sysroot,
+            *no_deps,
+        );
         let target_dir = config
             .target_dir
             .clone()
-            .or_else(|| cargo_target_dir(cargo_toml, extra_env, &sysroot))
+            .or_else(|| fetch_metadata.no_deps_metadata().map(|m| m.target_directory.clone()))
             .unwrap_or_else(|| workspace_dir.join("target").into());
 
         // We spawn a bunch of processes to query various information about the workspace's
@@ -319,7 +333,7 @@ impl ProjectWorkspace {
                 };
                 rustc_dir.and_then(|rustc_dir| {
                     info!(workspace = %cargo_toml, rustc_dir = %rustc_dir, "Using rustc source");
-                    match CargoWorkspace::fetch_metadata(
+                    match FetchMetadata::new(
                         &rustc_dir,
                         workspace_dir,
                         &CargoMetadataConfig {
@@ -327,15 +341,12 @@ impl ProjectWorkspace {
                             targets: targets.clone(),
                             extra_args: extra_args.clone(),
                             extra_env: extra_env.clone(),
-                            target_dir: target_dir.clone(),
                             toolchain_version: toolchain.clone(),
                             kind: "rustc-dev"
                         },
                         &sysroot,
                         *no_deps,
-                        true,
-                        progress,
-                    ) {
+                    ).exec(&target_dir, true, progress) {
                         Ok((meta, _error)) => {
                             let workspace = CargoWorkspace::new(
                                 meta,
@@ -364,35 +375,17 @@ impl ProjectWorkspace {
                 })
             });
 
-            let cargo_metadata = s.spawn(|| {
-                CargoWorkspace::fetch_metadata(
-                    cargo_toml,
-                    workspace_dir,
-                    &CargoMetadataConfig {
-                        features: features.clone(),
-                        targets: targets.clone(),
-                        extra_args: extra_args.clone(),
-                        extra_env: extra_env.clone(),
-                        target_dir: target_dir.clone(),
-                        toolchain_version: toolchain.clone(),
-                        kind: "workspace",
-                    },
-                    &sysroot,
-                    *no_deps,
-                    false,
-                    progress,
-                )
-            });
+            let cargo_metadata = s.spawn(|| fetch_metadata.exec(&target_dir, false, progress));
             let loaded_sysroot = s.spawn(|| {
                 sysroot.load_workspace(
                     &RustSourceWorkspaceConfig::CargoMetadata(sysroot_metadata_config(
                         config,
                         &targets,
                         toolchain.clone(),
-                        target_dir.clone(),
                     )),
                     config.no_deps,
                     workspace_dir,
+                    &target_dir,
                     progress,
                 )
             });
@@ -500,6 +493,7 @@ impl ProjectWorkspace {
                         &RustSourceWorkspaceConfig::Json(*sysroot_project),
                         config.no_deps,
                         project_root,
+                        &target_dir,
                         progress,
                     )
                 } else {
@@ -508,10 +502,10 @@ impl ProjectWorkspace {
                             config,
                             &targets,
                             toolchain.clone(),
-                            target_dir,
                         )),
                         config.no_deps,
                         project_root,
+                        &target_dir,
                         progress,
                     )
                 }
@@ -570,17 +564,17 @@ impl ProjectWorkspace {
                 config,
                 &targets,
                 toolchain.clone(),
-                target_dir.clone(),
             )),
             config.no_deps,
             dir,
+            &target_dir,
             &|_| (),
         );
         if let Some(loaded_sysroot) = loaded_sysroot {
             sysroot.set_workspace(loaded_sysroot);
         }
 
-        let cargo_script = CargoWorkspace::fetch_metadata(
+        let fetch_metadata = FetchMetadata::new(
             detached_file,
             dir,
             &CargoMetadataConfig {
@@ -588,24 +582,26 @@ impl ProjectWorkspace {
                 targets,
                 extra_args: config.extra_args.clone(),
                 extra_env: config.extra_env.clone(),
-                target_dir,
                 toolchain_version: toolchain.clone(),
                 kind: "detached-file",
             },
             &sysroot,
             config.no_deps,
-            false,
-            &|_| (),
-        )
-        .ok()
-        .map(|(ws, error)| {
-            let cargo_config_extra_env = cargo_config_env(detached_file, &config_file);
-            (
-                CargoWorkspace::new(ws, detached_file.clone(), cargo_config_extra_env, false),
-                WorkspaceBuildScripts::default(),
-                error.map(Arc::new),
-            )
-        });
+        );
+        let target_dir = config
+            .target_dir
+            .clone()
+            .or_else(|| fetch_metadata.no_deps_metadata().map(|m| m.target_directory.clone()))
+            .unwrap_or_else(|| dir.join("target").into());
+        let cargo_script =
+            fetch_metadata.exec(&target_dir, false, &|_| ()).ok().map(|(ws, error)| {
+                let cargo_config_extra_env = cargo_config_env(detached_file, &config_file);
+                (
+                    CargoWorkspace::new(ws, detached_file.clone(), cargo_config_extra_env, false),
+                    WorkspaceBuildScripts::default(),
+                    error.map(Arc::new),
+                )
+            });
 
         Ok(ProjectWorkspace {
             kind: ProjectWorkspaceKind::DetachedFile {
@@ -1887,14 +1883,12 @@ fn sysroot_metadata_config(
     config: &CargoConfig,
     targets: &[String],
     toolchain_version: Option<Version>,
-    target_dir: Utf8PathBuf,
 ) -> CargoMetadataConfig {
     CargoMetadataConfig {
         features: Default::default(),
         targets: targets.to_vec(),
         extra_args: Default::default(),
         extra_env: config.extra_env.clone(),
-        target_dir,
         toolchain_version,
         kind: "sysroot",
     }
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 f97bf832442..30ac93fb6f8 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
@@ -9,6 +9,7 @@ use hir::{ChangeWithProcMacros, Crate};
 use ide::{AnalysisHost, DiagnosticCode, DiagnosticsConfig};
 use ide_db::base_db;
 use itertools::Either;
+use paths::Utf8PathBuf;
 use profile::StopWatch;
 use project_model::toolchain_info::{QueryConfig, target_data_layout};
 use project_model::{
@@ -79,6 +80,7 @@ impl Tester {
             &RustSourceWorkspaceConfig::default_cargo(),
             false,
             &path,
+            &Utf8PathBuf::default(),
             &|_| (),
         );
         if let Some(loaded_sysroot) = loaded_sysroot {
-- 
cgit 1.4.1-3-g733a5


From 9a76dde4d23371d2deef39c56ff9f22051c884f7 Mon Sep 17 00:00:00 2001
From: Patrick-6 <pamu99@gmx.ch>
Date: Tue, 15 Jul 2025 15:50:02 +0200
Subject: Make spin function naming more consistent

---
 src/tools/miri/tests/pass/0weak_memory_consistency.rs    | 16 ++++++++--------
 src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs | 10 +++++-----
 src/tools/miri/tests/pass/weak_memory/weak.rs            |  8 ++++----
 3 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/tools/miri/tests/pass/0weak_memory_consistency.rs b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
index 5fba5493442..e4ed9675de8 100644
--- a/src/tools/miri/tests/pass/0weak_memory_consistency.rs
+++ b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
@@ -41,7 +41,7 @@ fn static_atomic_bool(val: bool) -> &'static AtomicBool {
 }
 
 /// Spins until it acquires a pre-determined value.
-fn loads_value(loc: &AtomicI32, ord: Ordering, val: i32) -> i32 {
+fn spin_until_i32(loc: &AtomicI32, ord: Ordering, val: i32) -> i32 {
     while loc.load(ord) != val {
         std::hint::spin_loop();
     }
@@ -49,7 +49,7 @@ fn loads_value(loc: &AtomicI32, ord: Ordering, val: i32) -> i32 {
 }
 
 /// Spins until it acquires a pre-determined boolean.
-fn loads_bool(loc: &AtomicBool, ord: Ordering, val: bool) -> bool {
+fn spin_until_bool(loc: &AtomicBool, ord: Ordering, val: bool) -> bool {
     while loc.load(ord) != val {
         std::hint::spin_loop();
     }
@@ -73,7 +73,7 @@ fn test_corr() {
     }); //                                           |                    |
     #[rustfmt::skip] //                              |synchronizes-with   |happens-before
     let j3 = spawn(move || { //                      |                    |
-        loads_value(&y, Acquire, 1); // <------------+                    |
+        spin_until_i32(&y, Acquire, 1); // <---------+                    |
         x.load(Relaxed) // <----------------------------------------------+
         // The two reads on x are ordered by hb, so they cannot observe values
         // differently from the modification order. If the first read observed
@@ -98,12 +98,12 @@ fn test_wrc() {
     }); //                                           |                     |
     #[rustfmt::skip] //                              |synchronizes-with    |
     let j2 = spawn(move || { //                      |                     |
-        loads_value(&x, Acquire, 1); // <------------+                     |
+        spin_until_i32(&x, Acquire, 1); // <---------+                     |
         y.store(1, Release); // ---------------------+                     |happens-before
     }); //                                           |                     |
     #[rustfmt::skip] //                              |synchronizes-with    |
     let j3 = spawn(move || { //                      |                     |
-        loads_value(&y, Acquire, 1); // <------------+                     |
+        spin_until_i32(&y, Acquire, 1); // <---------+                     |
         x.load(Relaxed) // <-----------------------------------------------+
     });
 
@@ -129,7 +129,7 @@ fn test_message_passing() {
     #[rustfmt::skip] //                              |synchronizes-with  | happens-before
     let j2 = spawn(move || { //                      |                   |
         let x = x; // avoid field capturing          |                   |
-        loads_value(&y, Acquire, 1); // <------------+                   |
+        spin_until_i32(&y, Acquire, 1); // <---------+                   |
         unsafe { *x.0 } // <---------------------------------------------+
     });
 
@@ -224,12 +224,12 @@ fn test_sync_through_rmw_and_fences() {
     let go = static_atomic_bool(false);
 
     let t1 = spawn(move || {
-        loads_bool(go, Relaxed, true);
+        spin_until_bool(go, Relaxed, true);
         rdmw(y, x, z)
     });
 
     let t2 = spawn(move || {
-        loads_bool(go, Relaxed, true);
+        spin_until_bool(go, Relaxed, true);
         rdmw(z, x, y)
     });
 
diff --git a/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs b/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs
index 2c9d742a8b1..937c2a8cf28 100644
--- a/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs
+++ b/src/tools/miri/tests/pass/0weak_memory_consistency_sc.rs
@@ -20,7 +20,7 @@ fn static_atomic_bool(val: bool) -> &'static AtomicBool {
 }
 
 /// Spins until it acquires a pre-determined value.
-fn loads_value(loc: &AtomicI32, ord: Ordering, val: i32) -> i32 {
+fn spin_until_i32(loc: &AtomicI32, ord: Ordering, val: i32) -> i32 {
     while loc.load(ord) != val {
         std::hint::spin_loop();
     }
@@ -28,7 +28,7 @@ fn loads_value(loc: &AtomicI32, ord: Ordering, val: i32) -> i32 {
 }
 
 /// Spins until it acquires a pre-determined boolean.
-fn loads_bool(loc: &AtomicBool, ord: Ordering, val: bool) -> bool {
+fn spin_until_bool(loc: &AtomicBool, ord: Ordering, val: bool) -> bool {
     while loc.load(ord) != val {
         std::hint::spin_loop();
     }
@@ -68,11 +68,11 @@ fn test_iriw_sc_rlx() {
     let a = spawn(move || x.store(true, Relaxed));
     let b = spawn(move || y.store(true, Relaxed));
     let c = spawn(move || {
-        loads_bool(x, SeqCst, true);
+        spin_until_bool(x, SeqCst, true);
         y.load(SeqCst)
     });
     let d = spawn(move || {
-        loads_bool(y, SeqCst, true);
+        spin_until_bool(y, SeqCst, true);
         x.load(SeqCst)
     });
 
@@ -144,7 +144,7 @@ fn test_cpp20_rwc_syncs() {
     });
 
     let j2 = spawn(move || {
-        loads_value(&x, Relaxed, 1);
+        spin_until_i32(&x, Relaxed, 1);
         fence(SeqCst);
         y.load(Relaxed)
     });
diff --git a/src/tools/miri/tests/pass/weak_memory/weak.rs b/src/tools/miri/tests/pass/weak_memory/weak.rs
index 569a307ab06..199f83f0528 100644
--- a/src/tools/miri/tests/pass/weak_memory/weak.rs
+++ b/src/tools/miri/tests/pass/weak_memory/weak.rs
@@ -24,7 +24,7 @@ fn static_atomic(val: usize) -> &'static AtomicUsize {
 }
 
 // Spins until it reads the given value
-fn reads_value(loc: &AtomicUsize, val: usize) -> usize {
+fn spin_until(loc: &AtomicUsize, val: usize) -> usize {
     while loc.load(Relaxed) != val {
         std::hint::spin_loop();
     }
@@ -85,7 +85,7 @@ fn initialization_write(add_fence: bool) -> bool {
     });
 
     let j2 = spawn(move || {
-        reads_value(wait, 1);
+        spin_until(wait, 1);
         if add_fence {
             fence(AcqRel);
         }
@@ -119,12 +119,12 @@ fn faa_replaced_by_load() -> bool {
     let go = static_atomic(0);
 
     let t1 = spawn(move || {
-        reads_value(go, 1);
+        spin_until(go, 1);
         rdmw(y, x, z)
     });
 
     let t2 = spawn(move || {
-        reads_value(go, 1);
+        spin_until(go, 1);
         rdmw(z, x, y)
     });
 
-- 
cgit 1.4.1-3-g733a5


From 4b421d44e20351426cf4ded11248bd1d0af40b5f Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Tue, 15 Jul 2025 13:33:32 +0000
Subject: Fix handling of SCRIPT_ARG in docker images

Instead of making this a build parameter, pass the SCRIPT as an
environment variable.

To this purpose, normalize on always referring to a script in
`/scripts`.

For i686-gnu-nopt-2 I had to create a separate script, because
Docker seems to be really terrible at command line argument
parsing, so it's not possible to pass an environment variable that
contains whitespace.
---
 src/ci/docker/host-aarch64/aarch64-gnu-llvm-19/Dockerfile |  8 +++-----
 src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile    |  4 +---
 src/ci/docker/host-x86_64/i686-gnu-nopt/Dockerfile        |  4 ++--
 src/ci/docker/host-x86_64/i686-gnu/Dockerfile             |  3 +--
 src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile   | 14 ++++++--------
 src/ci/docker/host-x86_64/x86_64-gnu-llvm-20/Dockerfile   | 14 ++++++--------
 src/ci/docker/run.sh                                      | 12 ++++--------
 src/ci/docker/scripts/i686-gnu-nopt-2.sh                  |  6 ++++++
 src/ci/docker/scripts/x86_64-gnu-llvm2.sh                 |  2 +-
 src/ci/github-actions/jobs.yml                            |  6 ++----
 10 files changed, 32 insertions(+), 41 deletions(-)
 create mode 100755 src/ci/docker/scripts/i686-gnu-nopt-2.sh

diff --git a/src/ci/docker/host-aarch64/aarch64-gnu-llvm-19/Dockerfile b/src/ci/docker/host-aarch64/aarch64-gnu-llvm-19/Dockerfile
index 2f9d0010573..e73fbe506f7 100644
--- a/src/ci/docker/host-aarch64/aarch64-gnu-llvm-19/Dockerfile
+++ b/src/ci/docker/host-aarch64/aarch64-gnu-llvm-19/Dockerfile
@@ -50,9 +50,7 @@ ENV RUST_CONFIGURE_ARGS \
 
 COPY scripts/shared.sh /scripts/
 
-ARG SCRIPT_ARG
+COPY scripts/stage_2_test_set1.sh /scripts/
+COPY scripts/stage_2_test_set2.sh /scripts/
 
-COPY scripts/stage_2_test_set1.sh /tmp/
-COPY scripts/stage_2_test_set2.sh /tmp/
-
-ENV SCRIPT "/tmp/${SCRIPT_ARG}"
+ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
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 44f6a8d2a15..01f19eac1d2 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
@@ -96,12 +96,10 @@ ENV RUST_CONFIGURE_ARGS \
       --set rust.lto=thin \
       --set rust.codegen-units=1
 
-ARG SCRIPT_ARG
-
 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 /scripts/${SCRIPT_ARG}
+ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
 
 ENV CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER=clang
 
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 58e66fd637a..be3df9d4036 100644
--- a/src/ci/docker/host-x86_64/i686-gnu-nopt/Dockerfile
+++ b/src/ci/docker/host-x86_64/i686-gnu-nopt/Dockerfile
@@ -23,7 +23,7 @@ COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
 ENV RUST_CONFIGURE_ARGS --build=i686-unknown-linux-gnu --disable-optimize-tests
-ARG SCRIPT_ARG
 COPY scripts/stage_2_test_set1.sh /scripts/
 COPY scripts/stage_2_test_set2.sh /scripts/
-ENV SCRIPT ${SCRIPT_ARG}
+COPY scripts/i686-gnu-nopt-2.sh /scripts/
+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 a715f7182d2..00cd24b89db 100644
--- a/src/ci/docker/host-x86_64/i686-gnu/Dockerfile
+++ b/src/ci/docker/host-x86_64/i686-gnu/Dockerfile
@@ -24,7 +24,6 @@ COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
 ENV RUST_CONFIGURE_ARGS --build=i686-unknown-linux-gnu
-ARG SCRIPT_ARG
 COPY scripts/stage_2_test_set1.sh /scripts/
 COPY scripts/stage_2_test_set2.sh /scripts/
-ENV SCRIPT /scripts/${SCRIPT_ARG}
+ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile
index c09be047c6a..5cba7c564f1 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile
@@ -57,12 +57,10 @@ ENV RUST_CONFIGURE_ARGS \
 
 COPY scripts/shared.sh /scripts/
 
-ARG SCRIPT_ARG
+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/
 
-COPY scripts/x86_64-gnu-llvm.sh /tmp/
-COPY scripts/x86_64-gnu-llvm2.sh /tmp/
-COPY scripts/x86_64-gnu-llvm3.sh /tmp/
-COPY scripts/stage_2_test_set1.sh /tmp/
-COPY scripts/stage_2_test_set2.sh /tmp/
-
-ENV SCRIPT "/tmp/${SCRIPT_ARG}"
+ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
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
index 83a3bfb37a5..92c2631000f 100644
--- 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
@@ -57,12 +57,10 @@ ENV RUST_CONFIGURE_ARGS \
 
 COPY scripts/shared.sh /scripts/
 
-ARG SCRIPT_ARG
+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/
 
-COPY scripts/x86_64-gnu-llvm.sh /tmp/
-COPY scripts/x86_64-gnu-llvm2.sh /tmp/
-COPY scripts/x86_64-gnu-llvm3.sh /tmp/
-COPY scripts/stage_2_test_set1.sh /tmp/
-COPY scripts/stage_2_test_set2.sh /tmp/
-
-ENV SCRIPT "/tmp/${SCRIPT_ARG}"
+ENV SCRIPT "Must specify DOCKER_SCRIPT for this image"
diff --git a/src/ci/docker/run.sh b/src/ci/docker/run.sh
index da7d084d48d..044f5a8fff3 100755
--- a/src/ci/docker/run.sh
+++ b/src/ci/docker/run.sh
@@ -114,14 +114,6 @@ if [ -f "$docker_dir/$image/Dockerfile" ]; then
         "$context"
     )
 
-    # If the environment variable DOCKER_SCRIPT is defined,
-    # set the build argument SCRIPT_ARG to DOCKER_SCRIPT.
-    # In this way, we run the script defined in CI,
-    # instead of the one defined in the Dockerfile.
-    if [ -n "${DOCKER_SCRIPT+x}" ]; then
-      build_args+=("--build-arg" "SCRIPT_ARG=${DOCKER_SCRIPT}")
-    fi
-
     GHCR_BUILDKIT_IMAGE="ghcr.io/rust-lang/buildkit:buildx-stable-1"
     # On non-CI jobs, we try to download a pre-built image from the rust-lang-ci
     # ghcr.io registry. If it is not possible, we fall back to building the image
@@ -341,6 +333,10 @@ if [ "$ENABLE_GCC_CODEGEN" = "1" ]; then
   echo "Setting extra environment values for docker: $extra_env"
 fi
 
+if [ -n "${DOCKER_SCRIPT}" ]; then
+  extra_env="$extra_env --env SCRIPT=\"/scripts/${DOCKER_SCRIPT}\""
+fi
+
 docker \
   run \
   --workdir /checkout/obj \
diff --git a/src/ci/docker/scripts/i686-gnu-nopt-2.sh b/src/ci/docker/scripts/i686-gnu-nopt-2.sh
new file mode 100755
index 00000000000..4c171739daf
--- /dev/null
+++ b/src/ci/docker/scripts/i686-gnu-nopt-2.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+set -ex
+
+python3 ../x.py test --stage 1 --set rust.optimize=false library/std &&
+/scripts/stage_2_test_set2.sh
diff --git a/src/ci/docker/scripts/x86_64-gnu-llvm2.sh b/src/ci/docker/scripts/x86_64-gnu-llvm2.sh
index fe5382aaa48..0060b9bfd23 100755
--- a/src/ci/docker/scripts/x86_64-gnu-llvm2.sh
+++ b/src/ci/docker/scripts/x86_64-gnu-llvm2.sh
@@ -4,7 +4,7 @@ set -ex
 
 ##### Test stage 2 #####
 
-/tmp/stage_2_test_set1.sh
+/scripts/stage_2_test_set1.sh
 
 # Run the `mir-opt` tests again but this time for a 32-bit target.
 # This enforces that tests using `// EMIT_MIR_FOR_EACH_BIT_WIDTH` have
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 445fc0dd018..6c5e37b51ef 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -315,16 +315,14 @@ auto:
   - name: i686-gnu-nopt-1
     env:
       IMAGE: i686-gnu-nopt
-      DOCKER_SCRIPT: /scripts/stage_2_test_set1.sh
+      DOCKER_SCRIPT: stage_2_test_set1.sh
     <<: *job-linux-4c
 
   # Skip tests that run in i686-gnu-nopt-1
   - name: i686-gnu-nopt-2
     env:
       IMAGE: i686-gnu-nopt
-      DOCKER_SCRIPT: >-
-        python3 ../x.py test --stage 1 --set rust.optimize=false library/std &&
-        /scripts/stage_2_test_set2.sh
+      DOCKER_SCRIPT: i686-gnu-nopt-2.sh
     <<: *job-linux-4c
 
   - name: pr-check-1
-- 
cgit 1.4.1-3-g733a5


From ec3443f573817bb6c7a1ba38dc13fa5bb7f85717 Mon Sep 17 00:00:00 2001
From: Laurențiu Nicola <lnicola@dend.ro>
Date: Tue, 15 Jul 2025 17:27:21 +0300
Subject: Preparing for merge from rust-lang/rust

---
 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 902793225ea..57ff326ce5a 100644
--- a/src/tools/rust-analyzer/rust-version
+++ b/src/tools/rust-analyzer/rust-version
@@ -1 +1 @@
-ad3b7257615c28aaf8212a189ec032b8af75de51
+a9fb6103b05c6ad6eee6bed4c0bb5a2e8e1024c6
-- 
cgit 1.4.1-3-g733a5


From 28f822f100c3714b37be9566b6dac376c72d2758 Mon Sep 17 00:00:00 2001
From: Laurențiu Nicola <lnicola@dend.ro>
Date: Tue, 15 Jul 2025 17:41:08 +0300
Subject: Format and bump rustc crates

---
 src/tools/rust-analyzer/Cargo.lock                 | 40 +++++++++-------------
 src/tools/rust-analyzer/Cargo.toml                 | 16 +++++----
 .../crates/hir-ty/src/layout/target.rs             |  2 +-
 .../rust-analyzer/crates/parser/src/lexed_str.rs   |  4 +--
 4 files changed, 30 insertions(+), 32 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 53682c4b8bb..1bd82c5d342 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1502,7 +1502,7 @@ dependencies = [
  "edition",
  "expect-test",
  "ra-ap-rustc_lexer",
- "rustc-literal-escaper 0.0.4",
+ "rustc-literal-escaper",
  "stdx",
  "tracing",
 ]
@@ -1753,9 +1753,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_abi"
-version = "0.116.0"
+version = "0.121.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a967e3a9cd3e38b543f503978e0eccee461e3aea3f7b10e944959bff41dbe612"
+checksum = "3ee51482d1c9d3e538acda8cce723db8eea1a81540544bf362bf4c3d841b2329"
 dependencies = [
  "bitflags 2.9.1",
  "ra-ap-rustc_hashes",
@@ -1765,18 +1765,18 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_hashes"
-version = "0.116.0"
+version = "0.121.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ea4c755ecbbffa5743c251344f484ebe571ec7bc5b36d80b2a8ae775d1a7a40"
+checksum = "19c8f1e0c28e24e1b4c55dc08058c6c9829df2204497d4034259f491d348c204"
 dependencies = [
  "rustc-stable-hash",
 ]
 
 [[package]]
 name = "ra-ap-rustc_index"
-version = "0.116.0"
+version = "0.121.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aca7ad7cf911538c619caa2162339fe98637e9e46f11bb0484ef96735df4d64a"
+checksum = "5f33f429cec6b92fa2c7243883279fb29dd233fdc3e94099aff32aa91aa87f50"
 dependencies = [
  "ra-ap-rustc_index_macros",
  "smallvec",
@@ -1784,9 +1784,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_index_macros"
-version = "0.116.0"
+version = "0.121.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8767ba551c9355bc3031be072cc4bb0381106e5e7cd275e72b7a8c76051c4070"
+checksum = "b9b55910dbe1fe7ef34bdc1d1bcb41e99b377eb680ea58a1218d95d6b4152257"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1795,9 +1795,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_lexer"
-version = "0.116.0"
+version = "0.121.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6101374afb267e6c27e4e2eb0b1352e9f3504c1a8f716f619cd39244e2ed92ab"
+checksum = "22944e31fb91e9b3e75bcbc91e37d958b8c0825a6160927f2856831d2ce83b36"
 dependencies = [
  "memchr",
  "unicode-properties",
@@ -1806,19 +1806,19 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_parse_format"
-version = "0.116.0"
+version = "0.121.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecd88a19f00da4f43e6727d5013444cbc399804b5046dfa2bbcd28ebed3970ce"
+checksum = "81057891bc2063ad9e353f29462fbc47a0f5072560af34428ae9313aaa5e9d97"
 dependencies = [
  "ra-ap-rustc_lexer",
- "rustc-literal-escaper 0.0.2",
+ "rustc-literal-escaper",
 ]
 
 [[package]]
 name = "ra-ap-rustc_pattern_analysis"
-version = "0.116.0"
+version = "0.121.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb332dd32d7850a799862533b1c021e6062558861a4ad57817bf522499fbb892"
+checksum = "fe21a3542980d56d2435e96c2720773cac1c63fd4db666417e414729da192eb3"
 dependencies = [
  "ra-ap-rustc_index",
  "rustc-hash 2.1.1",
@@ -1963,12 +1963,6 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
-[[package]]
-name = "rustc-literal-escaper"
-version = "0.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0041b6238913c41fe704213a4a9329e2f685a156d1781998128b4149c230ad04"
-
 [[package]]
 name = "rustc-literal-escaper"
 version = "0.0.4"
@@ -2262,7 +2256,7 @@ dependencies = [
  "rayon",
  "rowan",
  "rustc-hash 2.1.1",
- "rustc-literal-escaper 0.0.4",
+ "rustc-literal-escaper",
  "rustc_apfloat",
  "smol_str",
  "stdx",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index e6d1efb58b7..41fa06a76a7 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -89,11 +89,11 @@ vfs-notify = { path = "./crates/vfs-notify", version = "0.0.0" }
 vfs = { path = "./crates/vfs", version = "0.0.0" }
 edition = { path = "./crates/edition", version = "0.0.0" }
 
-ra-ap-rustc_lexer = { version = "0.116", default-features = false }
-ra-ap-rustc_parse_format = { version = "0.116", default-features = false }
-ra-ap-rustc_index = { version = "0.116", default-features = false }
-ra-ap-rustc_abi = { version = "0.116", default-features = false }
-ra-ap-rustc_pattern_analysis = { version = "0.116", default-features = false }
+ra-ap-rustc_lexer = { version = "0.121", default-features = false }
+ra-ap-rustc_parse_format = { version = "0.121", default-features = false }
+ra-ap-rustc_index = { version = "0.121", default-features = false }
+ra-ap-rustc_abi = { version = "0.121", default-features = false }
+ra-ap-rustc_pattern_analysis = { version = "0.121", default-features = false }
 
 # local crates that aren't published to crates.io. These should not have versions.
 
@@ -138,7 +138,11 @@ rayon = "1.10.0"
 rowan = "=0.15.15"
 # Ideally we'd not enable the macros feature but unfortunately the `tracked` attribute does not work
 # on impls without it
-salsa = { version = "0.23.0", default-features = true, features = ["rayon","salsa_unstable", "macros"] }
+salsa = { version = "0.23.0", default-features = true, features = [
+  "rayon",
+  "salsa_unstable",
+  "macros",
+] }
 salsa-macros = "0.23.0"
 semver = "1.0.26"
 serde = { version = "1.0.219" }
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout/target.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout/target.rs
index 88c33ecccad..82d0ed4f194 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout/target.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout/target.rs
@@ -2,7 +2,7 @@
 
 use base_db::Crate;
 use hir_def::layout::TargetDataLayout;
-use rustc_abi::{AlignFromBytesError, TargetDataLayoutErrors, AddressSpace};
+use rustc_abi::{AddressSpace, AlignFromBytesError, TargetDataLayoutErrors};
 use triomphe::Arc;
 
 use crate::db::HirDatabase;
diff --git a/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs b/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
index bff9acd78fa..8fff1c3db74 100644
--- a/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
+++ b/src/tools/rust-analyzer/crates/parser/src/lexed_str.rs
@@ -11,8 +11,8 @@
 use std::ops;
 
 use rustc_literal_escaper::{
-    unescape_byte, unescape_byte_str, unescape_c_str, unescape_char, unescape_str, EscapeError,
-    Mode,
+    EscapeError, Mode, unescape_byte, unescape_byte_str, unescape_c_str, unescape_char,
+    unescape_str,
 };
 
 use crate::{
-- 
cgit 1.4.1-3-g733a5


From 8770e5734ed5e7c1b8bc8b59b73b7f79134e4190 Mon Sep 17 00:00:00 2001
From: Havard Eidnes <he@NetBSD.org>
Date: Mon, 14 Jul 2025 17:03:42 +0000
Subject: Add `0323pin` as target maintainer, and fix link to pkgsrc-wip and
 explain.

---
 src/doc/rustc/src/platform-support/netbsd.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/doc/rustc/src/platform-support/netbsd.md b/src/doc/rustc/src/platform-support/netbsd.md
index e80ff85edad..b173bf82b44 100644
--- a/src/doc/rustc/src/platform-support/netbsd.md
+++ b/src/doc/rustc/src/platform-support/netbsd.md
@@ -32,10 +32,11 @@ are built for NetBSD 8.x but also work on newer OS versions).
 ## Target Maintainers
 
 [@he32](https://github.com/he32)
+[@0323pin](https://github.com/0323pin)
 
 Further contacts:
 
-- [NetBSD/pkgsrc-wip's rust](https://github.com/NetBSD/pkgsrc-wip/blob/master/rust185/Makefile) maintainer (see MAINTAINER variable). This package is part of "pkgsrc work-in-progress" and is used for deployment and testing of new versions of rust
+- [NetBSD/pkgsrc-wip's rust](https://github.com/NetBSD/pkgsrc-wip/blob/master/rust188/Makefile) maintainer (see MAINTAINER variable). This package is part of "pkgsrc work-in-progress" and is used for deployment and testing of new versions of rust.  Note that we have the convention of having multiple rust versions active in pkgsrc-wip at any one time, so the version number is part of the directory name, and from time to time old versions are culled so this is not a fully "stable" link.
 - [NetBSD's pkgsrc lang/rust](https://github.com/NetBSD/pkgsrc/tree/trunk/lang/rust) for the "proper" package in pkgsrc.
 - [NetBSD's pkgsrc lang/rust-bin](https://github.com/NetBSD/pkgsrc/tree/trunk/lang/rust-bin) which re-uses the bootstrap kit as a binary distribution and therefore avoids the rather protracted native build time of rust itself
 
-- 
cgit 1.4.1-3-g733a5


From 7976ca2442db9b69a7949b5fd6afcf8894441afa Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 19 May 2025 10:14:48 +0000
Subject: Add outlives to CoroutineWitnessTypes

---
 compiler/rustc_middle/src/ty/context.rs          | 5 +++++
 compiler/rustc_middle/src/ty/structural_impls.rs | 1 +
 compiler/rustc_traits/src/coroutine_witnesses.rs | 3 +--
 compiler/rustc_type_ir/src/interner.rs           | 7 +++++++
 compiler/rustc_type_ir/src/ty_kind.rs            | 1 +
 5 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 98b2ce01d89..45e311e95e4 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -162,6 +162,8 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     type BoundRegion = ty::BoundRegion;
     type PlaceholderRegion = ty::PlaceholderRegion;
 
+    type RegionAssumptions = &'tcx ty::List<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>;
+
     type ParamEnv = ty::ParamEnv<'tcx>;
     type Predicate = Predicate<'tcx>;
 
@@ -874,6 +876,7 @@ pub struct CtxtInterners<'tcx> {
     offset_of: InternedSet<'tcx, List<(VariantIdx, FieldIdx)>>,
     valtree: InternedSet<'tcx, ty::ValTreeKind<'tcx>>,
     patterns: InternedSet<'tcx, List<ty::Pattern<'tcx>>>,
+    outlives: InternedSet<'tcx, List<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>>,
 }
 
 impl<'tcx> CtxtInterners<'tcx> {
@@ -911,6 +914,7 @@ impl<'tcx> CtxtInterners<'tcx> {
             offset_of: InternedSet::with_capacity(N),
             valtree: InternedSet::with_capacity(N),
             patterns: InternedSet::with_capacity(N),
+            outlives: InternedSet::with_capacity(N),
         }
     }
 
@@ -2692,6 +2696,7 @@ slice_interners!(
     captures: intern_captures(&'tcx ty::CapturedPlace<'tcx>),
     offset_of: pub mk_offset_of((VariantIdx, FieldIdx)),
     patterns: pub mk_patterns(Pattern<'tcx>),
+    outlives: pub mk_outlives(ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>),
 );
 
 impl<'tcx> TyCtxt<'tcx> {
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index af9c98bd87d..55aec0efd0f 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -802,4 +802,5 @@ list_fold! {
     &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> : mk_poly_existential_predicates,
     &'tcx ty::List<PlaceElem<'tcx>> : mk_place_elems,
     &'tcx ty::List<ty::Pattern<'tcx>> : mk_patterns,
+    &'tcx ty::List<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>> : mk_outlives,
 }
diff --git a/compiler/rustc_traits/src/coroutine_witnesses.rs b/compiler/rustc_traits/src/coroutine_witnesses.rs
index 447e13126cc..c1573ba7641 100644
--- a/compiler/rustc_traits/src/coroutine_witnesses.rs
+++ b/compiler/rustc_traits/src/coroutine_witnesses.rs
@@ -29,9 +29,8 @@ pub(crate) fn coroutine_hidden_types<'tcx>(
                 ty
             }),
     );
-
     ty::EarlyBinder::bind(ty::Binder::bind_with_vars(
-        ty::CoroutineWitnessTypes { types: bound_tys },
+        ty::CoroutineWitnessTypes { types: bound_tys, assumptions: ty::List::empty() },
         tcx.mk_bound_variable_kinds(&vars),
     ))
 }
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index dd3cf1fc181..dfd683ac243 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -145,6 +145,13 @@ pub trait Interner:
     type BoundRegion: BoundVarLike<Self>;
     type PlaceholderRegion: PlaceholderLike<Self, Bound = Self::BoundRegion>;
 
+    type RegionAssumptions: Copy
+        + Debug
+        + Hash
+        + Eq
+        + SliceLike<Item = ty::OutlivesPredicate<Self, Self::GenericArg>>
+        + TypeFoldable<Self>;
+
     // Predicates
     type ParamEnv: ParamEnv<Self>;
     type Predicate: Predicate<Self>;
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index db6fbefcf05..7c665424750 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -1150,4 +1150,5 @@ pub struct FnHeader<I: Interner> {
 #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
 pub struct CoroutineWitnessTypes<I: Interner> {
     pub types: I::Tys,
+    pub assumptions: I::RegionAssumptions,
 }
-- 
cgit 1.4.1-3-g733a5


From 3e7dfaa51027d33f3613ed0203df495784b21f19 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 9 Jul 2025 23:57:41 +0000
Subject: Deduce outlives obligations from WF of coroutine interior types

---
 compiler/rustc_middle/src/query/mod.rs           |  2 +-
 compiler/rustc_middle/src/ty/context.rs          | 11 +++++
 compiler/rustc_traits/src/coroutine_witnesses.rs | 57 +++++++++++++++++++++++-
 3 files changed, 67 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 935cc889574..f605da24bc4 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -988,7 +988,7 @@ rustc_queries! {
     }
 
     query coroutine_hidden_types(
-        def_id: DefId
+        def_id: DefId,
     ) -> ty::EarlyBinder<'tcx, ty::Binder<'tcx, ty::CoroutineWitnessTypes<TyCtxt<'tcx>>>> {
         desc { "looking up the hidden types stored across await points in a coroutine" }
     }
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 45e311e95e4..5a1d8d215d2 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -3112,6 +3112,17 @@ impl<'tcx> TyCtxt<'tcx> {
         T::collect_and_apply(iter, |xs| self.mk_bound_variable_kinds(xs))
     }
 
+    pub fn mk_outlives_from_iter<I, T>(self, iter: I) -> T::Output
+    where
+        I: Iterator<Item = T>,
+        T: CollectAndApply<
+                ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>,
+                &'tcx ty::List<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+            >,
+    {
+        T::collect_and_apply(iter, |xs| self.mk_outlives(xs))
+    }
+
     /// Emit a lint at `span` from a lint struct (some type that implements `LintDiagnostic`,
     /// typically generated by `#[derive(LintDiagnostic)]`).
     #[track_caller]
diff --git a/compiler/rustc_traits/src/coroutine_witnesses.rs b/compiler/rustc_traits/src/coroutine_witnesses.rs
index c1573ba7641..d79777437e6 100644
--- a/compiler/rustc_traits/src/coroutine_witnesses.rs
+++ b/compiler/rustc_traits/src/coroutine_witnesses.rs
@@ -1,5 +1,10 @@
 use rustc_hir::def_id::DefId;
-use rustc_middle::ty::{self, TyCtxt, fold_regions};
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_infer::infer::canonical::query_response::make_query_region_constraints;
+use rustc_infer::infer::resolve::OpportunisticRegionResolver;
+use rustc_infer::traits::{Obligation, ObligationCause};
+use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, TypeVisitableExt, fold_regions};
+use rustc_trait_selection::traits::{ObligationCtxt, with_replaced_escaping_bound_vars};
 
 /// Return the set of types that should be taken into account when checking
 /// trait bounds on a coroutine's internal state. This properly replaces
@@ -29,8 +34,56 @@ pub(crate) fn coroutine_hidden_types<'tcx>(
                 ty
             }),
     );
+
+    let assumptions = compute_assumptions(tcx, def_id, bound_tys);
+
     ty::EarlyBinder::bind(ty::Binder::bind_with_vars(
-        ty::CoroutineWitnessTypes { types: bound_tys, assumptions: ty::List::empty() },
+        ty::CoroutineWitnessTypes { types: bound_tys, assumptions },
         tcx.mk_bound_variable_kinds(&vars),
     ))
 }
+
+fn compute_assumptions<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    def_id: DefId,
+    bound_tys: &'tcx ty::List<Ty<'tcx>>,
+) -> &'tcx ty::List<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>> {
+    let infcx = tcx.infer_ctxt().build(ty::TypingMode::Analysis {
+        defining_opaque_types_and_generators: ty::List::empty(),
+    });
+    with_replaced_escaping_bound_vars(&infcx, &mut vec![None], bound_tys, |bound_tys| {
+        let param_env = tcx.param_env(def_id);
+        let ocx = ObligationCtxt::new(&infcx);
+
+        ocx.register_obligations(bound_tys.iter().map(|ty| {
+            Obligation::new(
+                tcx,
+                ObligationCause::dummy(),
+                param_env,
+                ty::ClauseKind::WellFormed(ty.into()),
+            )
+        }));
+        let _errors = ocx.select_all_or_error();
+
+        let region_obligations = infcx.take_registered_region_obligations();
+        let region_constraints = infcx.take_and_reset_region_constraints();
+
+        let outlives = make_query_region_constraints(
+            tcx,
+            region_obligations,
+            &region_constraints,
+        )
+        .outlives
+        .fold_with(&mut OpportunisticRegionResolver::new(&infcx));
+
+        tcx.mk_outlives_from_iter(
+            outlives
+                .into_iter()
+                .map(|(o, _)| o)
+                // FIXME(higher_ranked_auto): We probably should deeply resolve these before
+                // filtering out infers which only correspond to unconstrained infer regions
+                // which we can sometimes get.
+                .filter(|o| !o.has_infer()),
+        )
+    })
+}
-- 
cgit 1.4.1-3-g733a5


From e3f643c70670a3e1567b0816502ab247565305f8 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 13 Jul 2025 20:43:29 +0000
Subject: Consider outlives assumptions when proving auto traits for coroutine
 interiors

---
 .../src/type_check/constraint_conversion.rs        | 27 ++++++--
 compiler/rustc_borrowck/src/type_check/mod.rs      |  5 ++
 .../src/infer/canonical/query_response.rs          | 28 ++++++++-
 compiler/rustc_infer/src/infer/mod.rs              | 15 ++++-
 compiler/rustc_infer/src/infer/outlives/env.rs     | 13 +++-
 compiler/rustc_infer/src/infer/outlives/mod.rs     | 19 +++++-
 .../rustc_infer/src/infer/outlives/obligations.rs  | 22 +++++++
 .../rustc_infer/src/infer/snapshot/undo_log.rs     |  4 ++
 compiler/rustc_middle/src/infer/canonical.rs       | 11 +++-
 compiler/rustc_trait_selection/src/regions.rs      |  8 ++-
 .../rustc_trait_selection/src/solve/delegate.rs    |  8 ++-
 .../rustc_trait_selection/src/traits/coherence.rs  |  1 +
 .../src/traits/outlives_bounds.rs                  |  5 +-
 .../src/traits/query/type_op/custom.rs             |  7 +++
 .../src/traits/query/type_op/mod.rs                |  3 +-
 .../src/traits/select/confirmation.rs              | 25 ++++++--
 .../rustc_trait_selection/src/traits/select/mod.rs | 73 ++++++++++++++++------
 compiler/rustc_traits/src/coroutine_witnesses.rs   |  2 +
 compiler/rustc_type_ir/src/elaborate.rs            | 51 +++++++++++++++
 src/tools/tidy/src/issues.txt                      |  2 -
 .../drop-tracking-unresolved-typeck-results.rs     |  3 +-
 .../drop-tracking-unresolved-typeck-results.stderr | 29 ---------
 .../return-type-notation/issue-110963-early.rs     |  2 +-
 .../return-type-notation/issue-110963-early.stderr | 31 ---------
 .../generic-associated-types/bugs/issue-100013.rs  | 35 -----------
 .../bugs/issue-100013.stderr                       | 48 --------------
 .../higher-ranked-coroutine-param-outlives-2.rs    | 24 +++++++
 .../higher-ranked-coroutine-param-outlives.rs      | 21 +++++++
 tests/ui/generic-associated-types/issue-92096.rs   | 28 ---------
 .../ui/generic-associated-types/issue-92096.stderr |  8 ---
 30 files changed, 332 insertions(+), 226 deletions(-)
 delete mode 100644 tests/ui/async-await/drop-tracking-unresolved-typeck-results.stderr
 delete mode 100644 tests/ui/async-await/return-type-notation/issue-110963-early.stderr
 delete mode 100644 tests/ui/generic-associated-types/bugs/issue-100013.rs
 delete mode 100644 tests/ui/generic-associated-types/bugs/issue-100013.stderr
 create mode 100644 tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.rs
 create mode 100644 tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.rs
 delete mode 100644 tests/ui/generic-associated-types/issue-92096.rs
 delete mode 100644 tests/ui/generic-associated-types/issue-92096.stderr

diff --git a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
index ca636a8c999..fec3e415f75 100644
--- a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
+++ b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
@@ -1,3 +1,4 @@
+use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def_id::LocalDefId;
 use rustc_infer::infer::canonical::QueryRegionConstraints;
 use rustc_infer::infer::outlives::env::RegionBoundPairs;
@@ -7,7 +8,7 @@ use rustc_infer::infer::{InferCtxt, SubregionOrigin};
 use rustc_infer::traits::query::type_op::DeeplyNormalize;
 use rustc_middle::bug;
 use rustc_middle::ty::{
-    self, GenericArgKind, Ty, TyCtxt, TypeFoldable, TypeVisitableExt, fold_regions,
+    self, GenericArgKind, Ty, TyCtxt, TypeFoldable, TypeVisitableExt, elaborate, fold_regions,
 };
 use rustc_span::Span;
 use rustc_trait_selection::traits::query::type_op::{TypeOp, TypeOpOutput};
@@ -70,10 +71,12 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
 
     #[instrument(skip(self), level = "debug")]
     pub(super) fn convert_all(&mut self, query_constraints: &QueryRegionConstraints<'tcx>) {
-        let QueryRegionConstraints { outlives } = query_constraints;
+        let QueryRegionConstraints { outlives, assumptions } = query_constraints;
+        let assumptions =
+            elaborate::elaborate_outlives_assumptions(self.infcx.tcx, assumptions.iter().copied());
 
         for &(predicate, constraint_category) in outlives {
-            self.convert(predicate, constraint_category);
+            self.convert(predicate, constraint_category, &assumptions);
         }
     }
 
@@ -112,7 +115,11 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
 
             self.category = outlives_requirement.category;
             self.span = outlives_requirement.blame_span;
-            self.convert(ty::OutlivesPredicate(subject, outlived_region), self.category);
+            self.convert(
+                ty::OutlivesPredicate(subject, outlived_region),
+                self.category,
+                &Default::default(),
+            );
         }
         (self.category, self.span, self.from_closure) = backup;
     }
@@ -121,6 +128,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
         &mut self,
         predicate: ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>,
         constraint_category: ConstraintCategory<'tcx>,
+        higher_ranked_assumptions: &FxHashSet<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
     ) {
         let tcx = self.infcx.tcx;
         debug!("generate: constraints at: {:#?}", self.locations);
@@ -150,7 +158,13 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
             }
 
             let mut next_outlives_predicates = vec![];
-            for (ty::OutlivesPredicate(k1, r2), constraint_category) in outlives_predicates {
+            for (pred, constraint_category) in outlives_predicates {
+                // Constraint is implied by a coroutine's well-formedness.
+                if higher_ranked_assumptions.contains(&pred) {
+                    continue;
+                }
+
+                let ty::OutlivesPredicate(k1, r2) = pred;
                 match k1.kind() {
                     GenericArgKind::Lifetime(r1) => {
                         let r1_vid = self.to_region_vid(r1);
@@ -273,7 +287,8 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
         match self.param_env.and(DeeplyNormalize { value: ty }).fully_perform(self.infcx, self.span)
         {
             Ok(TypeOpOutput { output: ty, constraints, .. }) => {
-                if let Some(QueryRegionConstraints { outlives }) = constraints {
+                // FIXME(higher_ranked_auto): What should we do with the assumptions here?
+                if let Some(QueryRegionConstraints { outlives, assumptions: _ }) = constraints {
                     next_outlives_predicates.extend(outlives.iter().copied());
                 }
                 ty
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index f877e5eaadb..d500088c259 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -131,6 +131,11 @@ pub(crate) fn type_check<'tcx>(
         pre_obligations.is_empty(),
         "there should be no incoming region obligations = {pre_obligations:#?}",
     );
+    let pre_assumptions = infcx.take_registered_region_assumptions();
+    assert!(
+        pre_assumptions.is_empty(),
+        "there should be no incoming region assumptions = {pre_assumptions:#?}",
+    );
 
     debug!(?normalized_inputs_and_output);
 
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index d5d49e3188a..fed56976128 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -116,9 +116,15 @@ impl<'tcx> InferCtxt<'tcx> {
         }
 
         let region_obligations = self.take_registered_region_obligations();
+        let region_assumptions = self.take_registered_region_assumptions();
         debug!(?region_obligations);
         let region_constraints = self.with_region_constraints(|region_constraints| {
-            make_query_region_constraints(tcx, region_obligations, region_constraints)
+            make_query_region_constraints(
+                tcx,
+                region_obligations,
+                region_constraints,
+                region_assumptions,
+            )
         });
         debug!(?region_constraints);
 
@@ -169,6 +175,11 @@ impl<'tcx> InferCtxt<'tcx> {
             self.register_outlives_constraint(predicate, cause);
         }
 
+        for assumption in &query_response.value.region_constraints.assumptions {
+            let assumption = instantiate_value(self.tcx, &result_args, *assumption);
+            self.register_region_assumption(assumption);
+        }
+
         let user_result: R =
             query_response.instantiate_projected(self.tcx, &result_args, |q_r| q_r.value.clone());
 
@@ -292,6 +303,18 @@ impl<'tcx> InferCtxt<'tcx> {
             }),
         );
 
+        // FIXME(higher_ranked_auto): Optimize this to instantiate all assumptions
+        // at once, rather than calling `instantiate_value` repeatedly which may
+        // create more universes.
+        output_query_region_constraints.assumptions.extend(
+            query_response
+                .value
+                .region_constraints
+                .assumptions
+                .iter()
+                .map(|&r_c| instantiate_value(self.tcx, &result_args, r_c)),
+        );
+
         let user_result: R =
             query_response.instantiate_projected(self.tcx, &result_args, |q_r| q_r.value.clone());
 
@@ -567,6 +590,7 @@ pub fn make_query_region_constraints<'tcx>(
     tcx: TyCtxt<'tcx>,
     outlives_obligations: Vec<TypeOutlivesConstraint<'tcx>>,
     region_constraints: &RegionConstraintData<'tcx>,
+    assumptions: Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
 ) -> QueryRegionConstraints<'tcx> {
     let RegionConstraintData { constraints, verifys } = region_constraints;
 
@@ -602,5 +626,5 @@ pub fn make_query_region_constraints<'tcx>(
         }))
         .collect();
 
-    QueryRegionConstraints { outlives }
+    QueryRegionConstraints { outlives, assumptions }
 }
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index cc3ad921489..458b21da6ce 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -149,6 +149,13 @@ pub struct InferCtxtInner<'tcx> {
     /// that all type inference variables have been bound and so forth.
     region_obligations: Vec<TypeOutlivesConstraint<'tcx>>,
 
+    /// The outlives bounds that we assume must hold about placeholders that
+    /// come from instantiating the binder of coroutine-witnesses. These bounds
+    /// are deduced from the well-formedness of the witness's types, and are
+    /// necessary because of the way we anonymize the regions in a coroutine,
+    /// which may cause types to no longer be considered well-formed.
+    region_assumptions: Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+
     /// Caches for opaque type inference.
     opaque_type_storage: OpaqueTypeStorage<'tcx>,
 }
@@ -164,7 +171,8 @@ impl<'tcx> InferCtxtInner<'tcx> {
             int_unification_storage: Default::default(),
             float_unification_storage: Default::default(),
             region_constraint_storage: Some(Default::default()),
-            region_obligations: vec![],
+            region_obligations: Default::default(),
+            region_assumptions: Default::default(),
             opaque_type_storage: Default::default(),
         }
     }
@@ -174,6 +182,11 @@ impl<'tcx> InferCtxtInner<'tcx> {
         &self.region_obligations
     }
 
+    #[inline]
+    pub fn region_assumptions(&self) -> &[ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>] {
+        &self.region_assumptions
+    }
+
     #[inline]
     pub fn projection_cache(&mut self) -> traits::ProjectionCache<'_, 'tcx> {
         self.projection_cache.with_log(&mut self.undo_log)
diff --git a/compiler/rustc_infer/src/infer/outlives/env.rs b/compiler/rustc_infer/src/infer/outlives/env.rs
index cb5a33c5c97..2175ff1b4ae 100644
--- a/compiler/rustc_infer/src/infer/outlives/env.rs
+++ b/compiler/rustc_infer/src/infer/outlives/env.rs
@@ -1,4 +1,4 @@
-use rustc_data_structures::fx::FxIndexSet;
+use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_data_structures::transitive_relation::TransitiveRelationBuilder;
 use rustc_middle::{bug, ty};
 use tracing::debug;
@@ -39,6 +39,9 @@ pub struct OutlivesEnvironment<'tcx> {
     /// optimized in the future, though.
     region_bound_pairs: RegionBoundPairs<'tcx>,
     known_type_outlives: Vec<ty::PolyTypeOutlivesPredicate<'tcx>>,
+    /// Assumptions that come from the well-formedness of coroutines that we prove
+    /// auto trait bounds for during the type checking of this body.
+    higher_ranked_assumptions: FxHashSet<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
 }
 
 /// "Region-bound pairs" tracks outlives relations that are known to
@@ -52,6 +55,7 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
         param_env: ty::ParamEnv<'tcx>,
         known_type_outlives: Vec<ty::PolyTypeOutlivesPredicate<'tcx>>,
         extra_bounds: impl IntoIterator<Item = OutlivesBound<'tcx>>,
+        higher_ranked_assumptions: FxHashSet<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
     ) -> Self {
         let mut region_relation = TransitiveRelationBuilder::default();
         let mut region_bound_pairs = RegionBoundPairs::default();
@@ -88,6 +92,7 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
             known_type_outlives,
             free_region_map: FreeRegionMap { relation: region_relation.freeze() },
             region_bound_pairs,
+            higher_ranked_assumptions,
         }
     }
 
@@ -102,4 +107,10 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
     pub fn known_type_outlives(&self) -> &[ty::PolyTypeOutlivesPredicate<'tcx>] {
         &self.known_type_outlives
     }
+
+    pub fn higher_ranked_assumptions(
+        &self,
+    ) -> &FxHashSet<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>> {
+        &self.higher_ranked_assumptions
+    }
 }
diff --git a/compiler/rustc_infer/src/infer/outlives/mod.rs b/compiler/rustc_infer/src/infer/outlives/mod.rs
index 2a4544c1140..db668032f1f 100644
--- a/compiler/rustc_infer/src/infer/outlives/mod.rs
+++ b/compiler/rustc_infer/src/infer/outlives/mod.rs
@@ -10,6 +10,7 @@ use super::region_constraints::{RegionConstraintData, UndoLog};
 use super::{InferCtxt, RegionResolutionError, SubregionOrigin};
 use crate::infer::free_regions::RegionRelations;
 use crate::infer::lexical_region_resolve;
+use crate::infer::region_constraints::Constraint;
 
 pub mod env;
 pub mod for_liveness;
@@ -54,18 +55,27 @@ impl<'tcx> InferCtxt<'tcx> {
             }
         };
 
-        let storage = {
+        let mut storage = {
             let mut inner = self.inner.borrow_mut();
             let inner = &mut *inner;
             assert!(
                 self.tainted_by_errors().is_some() || inner.region_obligations.is_empty(),
                 "region_obligations not empty: {:#?}",
-                inner.region_obligations
+                inner.region_obligations,
             );
             assert!(!UndoLogs::<UndoLog<'_>>::in_snapshot(&inner.undo_log));
             inner.region_constraint_storage.take().expect("regions already resolved")
         };
 
+        // Filter out any region-region outlives assumptions that are implied by
+        // coroutine well-formedness.
+        storage.data.constraints.retain(|(constraint, _)| match *constraint {
+            Constraint::RegSubReg(r1, r2) => !outlives_env
+                .higher_ranked_assumptions()
+                .contains(&ty::OutlivesPredicate(r2.into(), r1)),
+            _ => true,
+        });
+
         let region_rels = &RegionRelations::new(self.tcx, outlives_env.free_region_map());
 
         let (lexical_region_resolutions, errors) =
@@ -93,6 +103,11 @@ impl<'tcx> InferCtxt<'tcx> {
             "region_obligations not empty: {:#?}",
             self.inner.borrow().region_obligations
         );
+        assert!(
+            self.inner.borrow().region_assumptions.is_empty(),
+            "region_assumptions not empty: {:#?}",
+            self.inner.borrow().region_assumptions
+        );
 
         self.inner.borrow_mut().unwrap_region_constraints().take_and_reset_data()
     }
diff --git a/compiler/rustc_infer/src/infer/outlives/obligations.rs b/compiler/rustc_infer/src/infer/outlives/obligations.rs
index 43504bd77c1..2066cdd717e 100644
--- a/compiler/rustc_infer/src/infer/outlives/obligations.rs
+++ b/compiler/rustc_infer/src/infer/outlives/obligations.rs
@@ -170,6 +170,21 @@ impl<'tcx> InferCtxt<'tcx> {
         std::mem::take(&mut self.inner.borrow_mut().region_obligations)
     }
 
+    pub fn register_region_assumption(
+        &self,
+        assumption: ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>,
+    ) {
+        let mut inner = self.inner.borrow_mut();
+        inner.undo_log.push(UndoLog::PushRegionAssumption);
+        inner.region_assumptions.push(assumption);
+    }
+
+    pub fn take_registered_region_assumptions(
+        &self,
+    ) -> Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>> {
+        std::mem::take(&mut self.inner.borrow_mut().region_assumptions)
+    }
+
     /// Process the region obligations that must be proven (during
     /// `regionck`) for the given `body_id`, given information about
     /// the region bounds in scope and so forth.
@@ -220,6 +235,13 @@ impl<'tcx> InferCtxt<'tcx> {
                 let (sup_type, sub_region) =
                     (sup_type, sub_region).fold_with(&mut OpportunisticRegionResolver::new(self));
 
+                if outlives_env
+                    .higher_ranked_assumptions()
+                    .contains(&ty::OutlivesPredicate(sup_type.into(), sub_region))
+                {
+                    continue;
+                }
+
                 debug!(?sup_type, ?sub_region, ?origin);
 
                 let outlives = &mut TypeOutlives::new(
diff --git a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
index 34e649afedc..40e4c329446 100644
--- a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
+++ b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
@@ -28,6 +28,7 @@ pub(crate) enum UndoLog<'tcx> {
     RegionUnificationTable(sv::UndoLog<ut::Delegate<RegionVidKey<'tcx>>>),
     ProjectionCache(traits::UndoLog<'tcx>),
     PushTypeOutlivesConstraint,
+    PushRegionAssumption,
 }
 
 macro_rules! impl_from {
@@ -77,6 +78,9 @@ impl<'tcx> Rollback<UndoLog<'tcx>> for InferCtxtInner<'tcx> {
                 let popped = self.region_obligations.pop();
                 assert_matches!(popped, Some(_), "pushed region constraint but could not pop it");
             }
+            UndoLog::PushRegionAssumption => {
+                self.region_assumptions.pop();
+            }
         }
     }
 }
diff --git a/compiler/rustc_middle/src/infer/canonical.rs b/compiler/rustc_middle/src/infer/canonical.rs
index 2bbc48b633c..8ce2789cb8e 100644
--- a/compiler/rustc_middle/src/infer/canonical.rs
+++ b/compiler/rustc_middle/src/infer/canonical.rs
@@ -81,13 +81,18 @@ pub struct QueryResponse<'tcx, R> {
 #[derive(HashStable, TypeFoldable, TypeVisitable)]
 pub struct QueryRegionConstraints<'tcx> {
     pub outlives: Vec<QueryOutlivesConstraint<'tcx>>,
+    pub assumptions: Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
 }
 
 impl QueryRegionConstraints<'_> {
-    /// Represents an empty (trivially true) set of region
-    /// constraints.
+    /// Represents an empty (trivially true) set of region constraints.
+    ///
+    /// FIXME(higher_ranked_auto): This could still just be true if there are only assumptions?
+    /// Because I don't expect for us to get cases where an assumption from one query would
+    /// discharge a requirement from another query, which is a potential problem if we did throw
+    /// away these assumptions because there were no constraints.
     pub fn is_empty(&self) -> bool {
-        self.outlives.is_empty()
+        self.outlives.is_empty() && self.assumptions.is_empty()
     }
 }
 
diff --git a/compiler/rustc_trait_selection/src/regions.rs b/compiler/rustc_trait_selection/src/regions.rs
index 068e90b00b8..2b33b8ac9f8 100644
--- a/compiler/rustc_trait_selection/src/regions.rs
+++ b/compiler/rustc_trait_selection/src/regions.rs
@@ -4,7 +4,7 @@ use rustc_infer::infer::{InferCtxt, RegionResolutionError};
 use rustc_macros::extension;
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::traits::query::NoSolution;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, Ty, elaborate};
 
 use crate::traits::ScrubbedTraitError;
 use crate::traits::outlives_bounds::InferCtxtExt;
@@ -46,6 +46,11 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
             }
         }
 
+        // FIXME(-Znext-trait-solver): Normalize these.
+        let higher_ranked_assumptions = infcx.take_registered_region_assumptions();
+        let higher_ranked_assumptions =
+            elaborate::elaborate_outlives_assumptions(infcx.tcx, higher_ranked_assumptions);
+
         // FIXME: This needs to be modified so that we normalize the known type
         // outlives obligations then elaborate them into their region/type components.
         // Otherwise, `<W<'a> as Mirror>::Assoc: 'b` will not imply `'a: 'b` even
@@ -59,6 +64,7 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
                 assumed_wf_tys,
                 disable_implied_bounds_hack,
             ),
+            higher_ranked_assumptions,
         )
     }
 }
diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
index 1a24254d57f..670589faf9c 100644
--- a/compiler/rustc_trait_selection/src/solve/delegate.rs
+++ b/compiler/rustc_trait_selection/src/solve/delegate.rs
@@ -212,8 +212,14 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
         // Cannot use `take_registered_region_obligations` as we may compute the response
         // inside of a `probe` whenever we have multiple choices inside of the solver.
         let region_obligations = self.0.inner.borrow().region_obligations().to_owned();
+        let region_assumptions = self.0.inner.borrow().region_assumptions().to_owned();
         let region_constraints = self.0.with_region_constraints(|region_constraints| {
-            make_query_region_constraints(self.tcx, region_obligations, region_constraints)
+            make_query_region_constraints(
+                self.tcx,
+                region_obligations,
+                region_constraints,
+                region_assumptions,
+            )
         });
 
         let mut seen = FxHashSet::default();
diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs
index ce5a4edeaaa..f50f01a285b 100644
--- a/compiler/rustc_trait_selection/src/traits/coherence.rs
+++ b/compiler/rustc_trait_selection/src/traits/coherence.rs
@@ -461,6 +461,7 @@ fn impl_intersection_has_negative_obligation(
     // requirements, when proving the negated where clauses below.
     drop(equate_obligations);
     drop(infcx.take_registered_region_obligations());
+    drop(infcx.take_registered_region_assumptions());
     drop(infcx.take_and_reset_region_constraints());
 
     plug_infer_with_placeholders(
diff --git a/compiler/rustc_trait_selection/src/traits/outlives_bounds.rs b/compiler/rustc_trait_selection/src/traits/outlives_bounds.rs
index 59d3ac21387..53518038f8d 100644
--- a/compiler/rustc_trait_selection/src/traits/outlives_bounds.rs
+++ b/compiler/rustc_trait_selection/src/traits/outlives_bounds.rs
@@ -78,7 +78,10 @@ fn implied_outlives_bounds<'a, 'tcx>(
     bounds.retain(|bound| !bound.has_placeholders());
 
     if !constraints.is_empty() {
-        let QueryRegionConstraints { outlives } = constraints;
+        // FIXME(higher_ranked_auto): Should we register assumptions here?
+        // We otherwise would get spurious errors if normalizing an implied
+        // outlives bound required proving some higher-ranked coroutine obl.
+        let QueryRegionConstraints { outlives, assumptions: _ } = constraints;
         let cause = ObligationCause::misc(span, body_id);
         for &(predicate, _) in &outlives {
             infcx.register_outlives_constraint(predicate, &cause);
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
index 3b549244431..f027ba1c5cb 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs
@@ -80,6 +80,11 @@ where
         pre_obligations.is_empty(),
         "scrape_region_constraints: incoming region obligations = {pre_obligations:#?}",
     );
+    let pre_assumptions = infcx.take_registered_region_assumptions();
+    assert!(
+        pre_assumptions.is_empty(),
+        "scrape_region_constraints: incoming region assumptions = {pre_assumptions:#?}",
+    );
 
     let value = infcx.commit_if_ok(|_| {
         let ocx = ObligationCtxt::new(infcx);
@@ -100,11 +105,13 @@ where
     let value = infcx.resolve_vars_if_possible(value);
 
     let region_obligations = infcx.take_registered_region_obligations();
+    let region_assumptions = infcx.take_registered_region_assumptions();
     let region_constraint_data = infcx.take_and_reset_region_constraints();
     let region_constraints = query_response::make_query_region_constraints(
         infcx.tcx,
         region_obligations,
         &region_constraint_data,
+        region_assumptions,
     );
 
     if region_constraints.is_empty() {
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs
index 4bdf04311a0..018e9748cf0 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs
@@ -180,8 +180,9 @@ where
             span,
         )?;
         output.error_info = error_info;
-        if let Some(QueryRegionConstraints { outlives }) = output.constraints {
+        if let Some(QueryRegionConstraints { outlives, assumptions }) = output.constraints {
             region_constraints.outlives.extend(outlives.iter().cloned());
+            region_constraints.assumptions.extend(assumptions.iter().cloned());
         }
         output.constraints = if region_constraints.is_empty() {
             None
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index ee8cef20279..488094b15ac 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -411,18 +411,33 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 obligation.predicate.self_ty().map_bound(|ty| self.infcx.shallow_resolve(ty));
             let self_ty = self.infcx.enter_forall_and_leak_universe(self_ty);
 
-            let types = self.constituent_types_for_ty(self_ty)?;
-            let types = self.infcx.enter_forall_and_leak_universe(types);
+            let constituents = self.constituent_types_for_auto_trait(self_ty)?;
+            let constituents = self.infcx.enter_forall_and_leak_universe(constituents);
 
             let cause = obligation.derived_cause(ObligationCauseCode::BuiltinDerived);
-            let obligations = self.collect_predicates_for_types(
+            let mut obligations = self.collect_predicates_for_types(
                 obligation.param_env,
-                cause,
+                cause.clone(),
                 obligation.recursion_depth + 1,
                 obligation.predicate.def_id(),
-                types,
+                constituents.types,
             );
 
+            // FIXME(coroutine_clone): We could uplift this into `collect_predicates_for_types`
+            // and do this for `Copy`/`Clone` too, but that's feature-gated so it doesn't really
+            // matter yet.
+            for assumption in constituents.assumptions {
+                let assumption = normalize_with_depth_to(
+                    self,
+                    obligation.param_env,
+                    cause.clone(),
+                    obligation.recursion_depth + 1,
+                    assumption,
+                    &mut obligations,
+                );
+                self.infcx.register_region_assumption(assumption);
+            }
+
             Ok(obligations)
         })
     }
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 2e65750db25..b46fa9a44d3 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -20,6 +20,7 @@ use rustc_infer::infer::DefineOpaqueTypes;
 use rustc_infer::infer::at::ToTrace;
 use rustc_infer::infer::relate::TypeRelation;
 use rustc_infer::traits::{PredicateObligations, TraitObligation};
+use rustc_macros::{TypeFoldable, TypeVisitable};
 use rustc_middle::bug;
 use rustc_middle::dep_graph::{DepNodeIndex, dep_kinds};
 pub use rustc_middle::traits::select::*;
@@ -2247,10 +2248,10 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
     /// Zed<i32> where enum Zed { A(T), B(u32) } -> [i32, u32]
     /// ```
     #[instrument(level = "debug", skip(self), ret)]
-    fn constituent_types_for_ty(
+    fn constituent_types_for_auto_trait(
         &self,
         t: Ty<'tcx>,
-    ) -> Result<ty::Binder<'tcx, Vec<Ty<'tcx>>>, SelectionError<'tcx>> {
+    ) -> Result<ty::Binder<'tcx, AutoImplConstituents<'tcx>>, SelectionError<'tcx>> {
         Ok(match *t.kind() {
             ty::Uint(_)
             | ty::Int(_)
@@ -2261,17 +2262,26 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             | ty::Error(_)
             | ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
             | ty::Never
-            | ty::Char => ty::Binder::dummy(Vec::new()),
+            | ty::Char => {
+                ty::Binder::dummy(AutoImplConstituents { types: vec![], assumptions: vec![] })
+            }
 
             // This branch is only for `experimental_default_bounds`.
             // Other foreign types were rejected earlier in
             // `assemble_candidates_from_auto_impls`.
-            ty::Foreign(..) => ty::Binder::dummy(Vec::new()),
+            ty::Foreign(..) => {
+                ty::Binder::dummy(AutoImplConstituents { types: vec![], assumptions: vec![] })
+            }
 
-            ty::UnsafeBinder(ty) => ty.map_bound(|ty| vec![ty]),
+            ty::UnsafeBinder(ty) => {
+                ty.map_bound(|ty| AutoImplConstituents { types: vec![ty], assumptions: vec![] })
+            }
 
             // Treat this like `struct str([u8]);`
-            ty::Str => ty::Binder::dummy(vec![Ty::new_slice(self.tcx(), self.tcx().types.u8)]),
+            ty::Str => ty::Binder::dummy(AutoImplConstituents {
+                types: vec![Ty::new_slice(self.tcx(), self.tcx().types.u8)],
+                assumptions: vec![],
+            }),
 
             ty::Placeholder(..)
             | ty::Dynamic(..)
@@ -2283,30 +2293,41 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             }
 
             ty::RawPtr(element_ty, _) | ty::Ref(_, element_ty, _) => {
-                ty::Binder::dummy(vec![element_ty])
+                ty::Binder::dummy(AutoImplConstituents {
+                    types: vec![element_ty],
+                    assumptions: vec![],
+                })
             }
 
-            ty::Pat(ty, _) | ty::Array(ty, _) | ty::Slice(ty) => ty::Binder::dummy(vec![ty]),
+            ty::Pat(ty, _) | ty::Array(ty, _) | ty::Slice(ty) => {
+                ty::Binder::dummy(AutoImplConstituents { types: vec![ty], assumptions: vec![] })
+            }
 
             ty::Tuple(tys) => {
                 // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet
-                ty::Binder::dummy(tys.iter().collect())
+                ty::Binder::dummy(AutoImplConstituents {
+                    types: tys.iter().collect(),
+                    assumptions: vec![],
+                })
             }
 
             ty::Closure(_, args) => {
                 let ty = self.infcx.shallow_resolve(args.as_closure().tupled_upvars_ty());
-                ty::Binder::dummy(vec![ty])
+                ty::Binder::dummy(AutoImplConstituents { types: vec![ty], assumptions: vec![] })
             }
 
             ty::CoroutineClosure(_, args) => {
                 let ty = self.infcx.shallow_resolve(args.as_coroutine_closure().tupled_upvars_ty());
-                ty::Binder::dummy(vec![ty])
+                ty::Binder::dummy(AutoImplConstituents { types: vec![ty], assumptions: vec![] })
             }
 
             ty::Coroutine(_, args) => {
                 let ty = self.infcx.shallow_resolve(args.as_coroutine().tupled_upvars_ty());
                 let witness = args.as_coroutine().witness();
-                ty::Binder::dummy([ty].into_iter().chain(iter::once(witness)).collect())
+                ty::Binder::dummy(AutoImplConstituents {
+                    types: [ty].into_iter().chain(iter::once(witness)).collect(),
+                    assumptions: vec![],
+                })
             }
 
             ty::CoroutineWitness(def_id, args) => self
@@ -2314,16 +2335,23 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                 .tcx
                 .coroutine_hidden_types(def_id)
                 .instantiate(self.infcx.tcx, args)
-                .map_bound(|witness| witness.types.to_vec()),
+                .map_bound(|witness| AutoImplConstituents {
+                    types: witness.types.to_vec(),
+                    assumptions: witness.assumptions.to_vec(),
+                }),
 
             // For `PhantomData<T>`, we pass `T`.
             ty::Adt(def, args) if def.is_phantom_data() => {
-                ty::Binder::dummy(args.types().collect())
+                ty::Binder::dummy(AutoImplConstituents {
+                    types: args.types().collect(),
+                    assumptions: vec![],
+                })
             }
 
-            ty::Adt(def, args) => {
-                ty::Binder::dummy(def.all_fields().map(|f| f.ty(self.tcx(), args)).collect())
-            }
+            ty::Adt(def, args) => ty::Binder::dummy(AutoImplConstituents {
+                types: def.all_fields().map(|f| f.ty(self.tcx(), args)).collect(),
+                assumptions: vec![],
+            }),
 
             ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => {
                 if self.infcx.can_define_opaque_ty(def_id) {
@@ -2333,7 +2361,10 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                     // 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(vec![ty.instantiate(self.tcx(), args)]),
+                        Ok(ty) => ty::Binder::dummy(AutoImplConstituents {
+                            types: vec![ty.instantiate(self.tcx(), args)],
+                            assumptions: vec![],
+                        }),
                         Err(_) => {
                             return Err(SelectionError::OpaqueTypeAutoTraitLeakageUnknown(def_id));
                         }
@@ -3113,3 +3144,9 @@ pub(crate) enum ProjectionMatchesProjection {
     Ambiguous,
     No,
 }
+
+#[derive(Clone, Debug, TypeFoldable, TypeVisitable)]
+pub(crate) struct AutoImplConstituents<'tcx> {
+    pub types: Vec<Ty<'tcx>>,
+    pub assumptions: Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+}
diff --git a/compiler/rustc_traits/src/coroutine_witnesses.rs b/compiler/rustc_traits/src/coroutine_witnesses.rs
index d79777437e6..9e487e380a9 100644
--- a/compiler/rustc_traits/src/coroutine_witnesses.rs
+++ b/compiler/rustc_traits/src/coroutine_witnesses.rs
@@ -66,12 +66,14 @@ fn compute_assumptions<'tcx>(
         let _errors = ocx.select_all_or_error();
 
         let region_obligations = infcx.take_registered_region_obligations();
+        let region_assumptions = infcx.take_registered_region_assumptions();
         let region_constraints = infcx.take_and_reset_region_constraints();
 
         let outlives = make_query_region_constraints(
             tcx,
             region_obligations,
             &region_constraints,
+            region_assumptions,
         )
         .outlives
         .fold_with(&mut OpportunisticRegionResolver::new(&infcx));
diff --git a/compiler/rustc_type_ir/src/elaborate.rs b/compiler/rustc_type_ir/src/elaborate.rs
index 7ffcf7b5d96..d3c95147649 100644
--- a/compiler/rustc_type_ir/src/elaborate.rs
+++ b/compiler/rustc_type_ir/src/elaborate.rs
@@ -368,3 +368,54 @@ impl<I: Interner, It: Iterator<Item = I::Clause>> Iterator for FilterToTraits<I,
         (0, upper)
     }
 }
+
+pub fn elaborate_outlives_assumptions<I: Interner>(
+    cx: I,
+    assumptions: impl IntoIterator<Item = ty::OutlivesPredicate<I, I::GenericArg>>,
+) -> HashSet<ty::OutlivesPredicate<I, I::GenericArg>> {
+    let mut collected = HashSet::default();
+
+    for ty::OutlivesPredicate(arg1, r2) in assumptions {
+        collected.insert(ty::OutlivesPredicate(arg1, r2));
+        match arg1.kind() {
+            // Elaborate the components of an type, since we may have substituted a
+            // generic coroutine with a more specific type.
+            ty::GenericArgKind::Type(ty1) => {
+                let mut components = smallvec![];
+                push_outlives_components(cx, ty1, &mut components);
+                for c in components {
+                    match c {
+                        Component::Region(r1) => {
+                            if !r1.is_bound() {
+                                collected.insert(ty::OutlivesPredicate(r1.into(), r2));
+                            }
+                        }
+
+                        Component::Param(p) => {
+                            let ty = Ty::new_param(cx, p);
+                            collected.insert(ty::OutlivesPredicate(ty.into(), r2));
+                        }
+
+                        Component::Placeholder(p) => {
+                            let ty = Ty::new_placeholder(cx, p);
+                            collected.insert(ty::OutlivesPredicate(ty.into(), r2));
+                        }
+
+                        Component::Alias(alias_ty) => {
+                            collected.insert(ty::OutlivesPredicate(alias_ty.to_ty(cx).into(), r2));
+                        }
+
+                        Component::UnresolvedInferenceVariable(_) | Component::EscapingAlias(_) => {
+                        }
+                    }
+                }
+            }
+            // Nothing to elaborate for a region.
+            ty::GenericArgKind::Lifetime(_) => {}
+            // Consts don't really participate in outlives.
+            ty::GenericArgKind::Const(_) => {}
+        }
+    }
+
+    collected
+}
diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 8b57db23d01..77414bec82d 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -1021,7 +1021,6 @@ ui/foreign/issue-91370-foreign-fn-block-impl.rs
 ui/foreign/issue-99276-same-type-lifetimes.rs
 ui/function-pointer/issue-102289.rs
 ui/functions-closures/closure-expected-type/issue-38714.rs
-ui/generic-associated-types/bugs/issue-100013.rs
 ui/generic-associated-types/bugs/issue-80626.rs
 ui/generic-associated-types/bugs/issue-87735.rs
 ui/generic-associated-types/bugs/issue-87755.rs
@@ -1099,7 +1098,6 @@ ui/generic-associated-types/issue-90729.rs
 ui/generic-associated-types/issue-91139.rs
 ui/generic-associated-types/issue-91883.rs
 ui/generic-associated-types/issue-92033.rs
-ui/generic-associated-types/issue-92096.rs
 ui/generic-associated-types/issue-92280.rs
 ui/generic-associated-types/issue-92954.rs
 ui/generic-associated-types/issue-93141.rs
diff --git a/tests/ui/async-await/drop-tracking-unresolved-typeck-results.rs b/tests/ui/async-await/drop-tracking-unresolved-typeck-results.rs
index e6c295405e2..51945e02352 100644
--- a/tests/ui/async-await/drop-tracking-unresolved-typeck-results.rs
+++ b/tests/ui/async-await/drop-tracking-unresolved-typeck-results.rs
@@ -1,5 +1,6 @@
 //@ incremental
 //@ edition: 2021
+//@ check-pass
 
 use std::future::*;
 use std::marker::PhantomData;
@@ -96,8 +97,6 @@ impl<St: ?Sized + Stream + Unpin> Future for Next<'_, St> {
 
 fn main() {
     send(async {
-        //~^ ERROR implementation of `FnOnce` is not general enough
-        //~| ERROR implementation of `FnOnce` is not general enough
         Next(&Buffered(Map(Empty(PhantomData), ready::<&()>), FuturesOrdered(PhantomData), 0)).await
     });
 }
diff --git a/tests/ui/async-await/drop-tracking-unresolved-typeck-results.stderr b/tests/ui/async-await/drop-tracking-unresolved-typeck-results.stderr
deleted file mode 100644
index 0d3ee8a9377..00000000000
--- a/tests/ui/async-await/drop-tracking-unresolved-typeck-results.stderr
+++ /dev/null
@@ -1,29 +0,0 @@
-error: implementation of `FnOnce` is not general enough
-  --> $DIR/drop-tracking-unresolved-typeck-results.rs:98:5
-   |
-LL | /     send(async {
-LL | |
-LL | |
-LL | |         Next(&Buffered(Map(Empty(PhantomData), ready::<&()>), FuturesOrdered(PhantomData), 0)).await
-LL | |     });
-   | |______^ implementation of `FnOnce` is not general enough
-   |
-   = note: `fn(&'0 ()) -> std::future::Ready<&'0 ()> {std::future::ready::<&'0 ()>}` must implement `FnOnce<(&'1 (),)>`, for any two lifetimes `'0` and `'1`...
-   = note: ...but it actually implements `FnOnce<(&(),)>`
-
-error: implementation of `FnOnce` is not general enough
-  --> $DIR/drop-tracking-unresolved-typeck-results.rs:98:5
-   |
-LL | /     send(async {
-LL | |
-LL | |
-LL | |         Next(&Buffered(Map(Empty(PhantomData), ready::<&()>), FuturesOrdered(PhantomData), 0)).await
-LL | |     });
-   | |______^ implementation of `FnOnce` is not general enough
-   |
-   = note: `fn(&'0 ()) -> std::future::Ready<&'0 ()> {std::future::ready::<&'0 ()>}` must implement `FnOnce<(&'1 (),)>`, for any two lifetimes `'0` and `'1`...
-   = note: ...but it actually implements `FnOnce<(&(),)>`
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/async-await/return-type-notation/issue-110963-early.rs b/tests/ui/async-await/return-type-notation/issue-110963-early.rs
index 46b8fbf6f86..7985f2e2de1 100644
--- a/tests/ui/async-await/return-type-notation/issue-110963-early.rs
+++ b/tests/ui/async-await/return-type-notation/issue-110963-early.rs
@@ -1,5 +1,5 @@
 //@ edition: 2021
-//@ known-bug: #110963
+//@ check-pass
 
 #![feature(return_type_notation)]
 
diff --git a/tests/ui/async-await/return-type-notation/issue-110963-early.stderr b/tests/ui/async-await/return-type-notation/issue-110963-early.stderr
deleted file mode 100644
index d6c3bd12aee..00000000000
--- a/tests/ui/async-await/return-type-notation/issue-110963-early.stderr
+++ /dev/null
@@ -1,31 +0,0 @@
-error: implementation of `Send` is not general enough
-  --> $DIR/issue-110963-early.rs:14:5
-   |
-LL | /     spawn(async move {
-LL | |         let mut hc = hc;
-LL | |         if !hc.check().await {
-LL | |             log_health_check_failure().await;
-LL | |         }
-LL | |     });
-   | |______^ implementation of `Send` is not general enough
-   |
-   = note: `Send` would have to be implemented for the type `impl Future<Output = bool> { <HC as HealthCheck>::check<'0>(..) }`, for any two lifetimes `'0` and `'1`...
-   = note: ...but `Send` is actually implemented for the type `impl Future<Output = bool> { <HC as HealthCheck>::check<'2>(..) }`, for some specific lifetime `'2`
-
-error: implementation of `Send` is not general enough
-  --> $DIR/issue-110963-early.rs:14:5
-   |
-LL | /     spawn(async move {
-LL | |         let mut hc = hc;
-LL | |         if !hc.check().await {
-LL | |             log_health_check_failure().await;
-LL | |         }
-LL | |     });
-   | |______^ implementation of `Send` is not general enough
-   |
-   = note: `Send` would have to be implemented for the type `impl Future<Output = bool> { <HC as HealthCheck>::check<'0>(..) }`, for any two lifetimes `'0` and `'1`...
-   = note: ...but `Send` is actually implemented for the type `impl Future<Output = bool> { <HC as HealthCheck>::check<'2>(..) }`, for some specific lifetime `'2`
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/generic-associated-types/bugs/issue-100013.rs b/tests/ui/generic-associated-types/bugs/issue-100013.rs
deleted file mode 100644
index ac72c29c03b..00000000000
--- a/tests/ui/generic-associated-types/bugs/issue-100013.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ check-fail
-//@ known-bug: #100013
-//@ edition: 2021
-
-// We really should accept this, but we need implied bounds between the regions
-// in a coroutine interior.
-
-pub trait FutureIterator {
-    type Future<'s, 'cx>: Send
-    where
-        's: 'cx;
-}
-
-fn call<I: FutureIterator>() -> impl Send {
-    async { // a coroutine checked for autotrait impl `Send`
-        let x = None::<I::Future<'_, '_>>; // a type referencing GAT
-        async {}.await; // a yield point
-    }
-}
-
-fn call2<'a, 'b, I: FutureIterator>() -> impl Send {
-    async { // a coroutine checked for autotrait impl `Send`
-        let x = None::<I::Future<'a, 'b>>; // a type referencing GAT
-        async {}.await; // a yield point
-    }
-}
-
-fn call3<'a: 'b, 'b, I: FutureIterator>() -> impl Send {
-    async { // a coroutine checked for autotrait impl `Send`
-        let x = None::<I::Future<'a, 'b>>; // a type referencing GAT
-        async {}.await; // a yield point
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/generic-associated-types/bugs/issue-100013.stderr b/tests/ui/generic-associated-types/bugs/issue-100013.stderr
deleted file mode 100644
index ff82aebfef9..00000000000
--- a/tests/ui/generic-associated-types/bugs/issue-100013.stderr
+++ /dev/null
@@ -1,48 +0,0 @@
-error: lifetime bound not satisfied
-  --> $DIR/issue-100013.rs:15:5
-   |
-LL | /     async { // a coroutine checked for autotrait impl `Send`
-LL | |         let x = None::<I::Future<'_, '_>>; // a type referencing GAT
-LL | |         async {}.await; // a yield point
-LL | |     }
-   | |_____^
-   |
-   = note: this is a known limitation that will be removed in the future (see issue #100013 <https://github.com/rust-lang/rust/issues/100013> for more information)
-
-error: lifetime bound not satisfied
-  --> $DIR/issue-100013.rs:22:5
-   |
-LL | /     async { // a coroutine checked for autotrait impl `Send`
-LL | |         let x = None::<I::Future<'a, 'b>>; // a type referencing GAT
-LL | |         async {}.await; // a yield point
-LL | |     }
-   | |_____^
-   |
-   = note: this is a known limitation that will be removed in the future (see issue #100013 <https://github.com/rust-lang/rust/issues/100013> for more information)
-
-error: lifetime may not live long enough
-  --> $DIR/issue-100013.rs:23:17
-   |
-LL | fn call2<'a, 'b, I: FutureIterator>() -> impl Send {
-   |          --  -- lifetime `'b` defined here
-   |          |
-   |          lifetime `'a` defined here
-LL |     async { // a coroutine checked for autotrait impl `Send`
-LL |         let x = None::<I::Future<'a, 'b>>; // a type referencing GAT
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'b`
-   |
-   = help: consider adding the following bound: `'a: 'b`
-
-error: lifetime bound not satisfied
-  --> $DIR/issue-100013.rs:29:5
-   |
-LL | /     async { // a coroutine checked for autotrait impl `Send`
-LL | |         let x = None::<I::Future<'a, 'b>>; // a type referencing GAT
-LL | |         async {}.await; // a yield point
-LL | |     }
-   | |_____^
-   |
-   = note: this is a known limitation that will be removed in the future (see issue #100013 <https://github.com/rust-lang/rust/issues/100013> for more information)
-
-error: aborting due to 4 previous errors
-
diff --git a/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.rs b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.rs
new file mode 100644
index 00000000000..f7762600165
--- /dev/null
+++ b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.rs
@@ -0,0 +1,24 @@
+//@ check-pass
+//@ edition: 2021
+
+pub trait FutureIterator {
+    type Future<'s, 'cx>: Send
+    where
+        's: 'cx;
+}
+
+fn call<I: FutureIterator>() -> impl Send {
+    async { // a coroutine checked for autotrait impl `Send`
+        let x = None::<I::Future<'_, '_>>; // a type referencing GAT
+        async {}.await; // a yield point
+    }
+}
+
+fn call2<'a: 'b, 'b, I: FutureIterator>() -> impl Send {
+    async { // a coroutine checked for autotrait impl `Send`
+        let x = None::<I::Future<'a, 'b>>; // a type referencing GAT
+        async {}.await; // a yield point
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.rs b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.rs
new file mode 100644
index 00000000000..33a085ad26b
--- /dev/null
+++ b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.rs
@@ -0,0 +1,21 @@
+//@ edition:2018
+//@ check-pass
+
+use std::future::Future;
+
+trait Client {
+    type Connecting<'a>: Future + Send
+    where
+        Self: 'a;
+
+    fn connect(&'_ self) -> Self::Connecting<'_>;
+}
+
+fn call_connect<C>(c: &'_ C) -> impl '_ + Future + Send
+where
+    C: Client + Send + Sync,
+{
+    async move { c.connect().await }
+}
+
+fn main() {}
diff --git a/tests/ui/generic-associated-types/issue-92096.rs b/tests/ui/generic-associated-types/issue-92096.rs
deleted file mode 100644
index a34c4179584..00000000000
--- a/tests/ui/generic-associated-types/issue-92096.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ edition:2018
-
-use std::future::Future;
-
-trait Client {
-    type Connecting<'a>: Future + Send
-    where
-        Self: 'a;
-
-    fn connect(&'_ self) -> Self::Connecting<'_>;
-}
-
-fn call_connect<C>(c: &'_ C) -> impl '_ + Future + Send
-where
-    C: Client + Send + Sync,
-{
-    async move { c.connect().await }
-    //~^ ERROR `C` does not live long enough
-    //
-    // FIXME(#71723). This is because we infer at some point a value of
-    //
-    // impl Future<Output = <C as Client>::Connection<'_>>
-    //
-    // and then we somehow fail the WF check because `where C: 'a` is not known,
-    // but I'm not entirely sure how that comes about.
-}
-
-fn main() {}
diff --git a/tests/ui/generic-associated-types/issue-92096.stderr b/tests/ui/generic-associated-types/issue-92096.stderr
deleted file mode 100644
index b9a16cf184e..00000000000
--- a/tests/ui/generic-associated-types/issue-92096.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: `C` does not live long enough
-  --> $DIR/issue-92096.rs:17:5
-   |
-LL |     async move { c.connect().await }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
-- 
cgit 1.4.1-3-g733a5


From 512cf3ae88b26f50a92ebfcb69c24ca39acd72e6 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 13 Jul 2025 21:01:25 +0000
Subject: Gate things properly

---
 .../src/type_check/constraint_conversion.rs        |  4 ++-
 compiler/rustc_infer/src/infer/outlives/mod.rs     | 14 +++++-----
 .../rustc_infer/src/infer/outlives/obligations.rs  |  7 ++---
 compiler/rustc_session/src/options.rs              |  2 ++
 ...unresolved-typeck-results.no_assumptions.stderr | 25 +++++++++++++++++
 .../drop-tracking-unresolved-typeck-results.rs     |  5 +++-
 .../issue-110963-early.no_assumptions.stderr       | 31 ++++++++++++++++++++++
 .../return-type-notation/issue-110963-early.rs     |  5 +++-
 ...oroutine-param-outlives-2.no_assumptions.stderr | 24 +++++++++++++++++
 .../higher-ranked-coroutine-param-outlives-2.rs    |  5 +++-
 ...-coroutine-param-outlives.no_assumptions.stderr |  8 ++++++
 .../higher-ranked-coroutine-param-outlives.rs      |  5 +++-
 12 files changed, 121 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/async-await/drop-tracking-unresolved-typeck-results.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/return-type-notation/issue-110963-early.no_assumptions.stderr
 create mode 100644 tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.no_assumptions.stderr
 create mode 100644 tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.no_assumptions.stderr

diff --git a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
index fec3e415f75..989d2cc70dd 100644
--- a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
+++ b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
@@ -160,7 +160,9 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
             let mut next_outlives_predicates = vec![];
             for (pred, constraint_category) in outlives_predicates {
                 // Constraint is implied by a coroutine's well-formedness.
-                if higher_ranked_assumptions.contains(&pred) {
+                if self.infcx.tcx.sess.opts.unstable_opts.higher_ranked_assumptions
+                    && higher_ranked_assumptions.contains(&pred)
+                {
                     continue;
                 }
 
diff --git a/compiler/rustc_infer/src/infer/outlives/mod.rs b/compiler/rustc_infer/src/infer/outlives/mod.rs
index db668032f1f..19911bfbd48 100644
--- a/compiler/rustc_infer/src/infer/outlives/mod.rs
+++ b/compiler/rustc_infer/src/infer/outlives/mod.rs
@@ -69,12 +69,14 @@ impl<'tcx> InferCtxt<'tcx> {
 
         // Filter out any region-region outlives assumptions that are implied by
         // coroutine well-formedness.
-        storage.data.constraints.retain(|(constraint, _)| match *constraint {
-            Constraint::RegSubReg(r1, r2) => !outlives_env
-                .higher_ranked_assumptions()
-                .contains(&ty::OutlivesPredicate(r2.into(), r1)),
-            _ => true,
-        });
+        if self.tcx.sess.opts.unstable_opts.higher_ranked_assumptions {
+            storage.data.constraints.retain(|(constraint, _)| match *constraint {
+                Constraint::RegSubReg(r1, r2) => !outlives_env
+                    .higher_ranked_assumptions()
+                    .contains(&ty::OutlivesPredicate(r2.into(), r1)),
+                _ => true,
+            });
+        }
 
         let region_rels = &RegionRelations::new(self.tcx, outlives_env.free_region_map());
 
diff --git a/compiler/rustc_infer/src/infer/outlives/obligations.rs b/compiler/rustc_infer/src/infer/outlives/obligations.rs
index 2066cdd717e..1ca59c8d130 100644
--- a/compiler/rustc_infer/src/infer/outlives/obligations.rs
+++ b/compiler/rustc_infer/src/infer/outlives/obligations.rs
@@ -235,9 +235,10 @@ impl<'tcx> InferCtxt<'tcx> {
                 let (sup_type, sub_region) =
                     (sup_type, sub_region).fold_with(&mut OpportunisticRegionResolver::new(self));
 
-                if outlives_env
-                    .higher_ranked_assumptions()
-                    .contains(&ty::OutlivesPredicate(sup_type.into(), sub_region))
+                if self.tcx.sess.opts.unstable_opts.higher_ranked_assumptions
+                    && outlives_env
+                        .higher_ranked_assumptions()
+                        .contains(&ty::OutlivesPredicate(sup_type.into(), sub_region))
                 {
                     continue;
                 }
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 626262c8442..2bdde2f887a 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -2256,6 +2256,8 @@ options! {
         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"),
+    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],
diff --git a/tests/ui/async-await/drop-tracking-unresolved-typeck-results.no_assumptions.stderr b/tests/ui/async-await/drop-tracking-unresolved-typeck-results.no_assumptions.stderr
new file mode 100644
index 00000000000..d5560bf8920
--- /dev/null
+++ b/tests/ui/async-await/drop-tracking-unresolved-typeck-results.no_assumptions.stderr
@@ -0,0 +1,25 @@
+error: implementation of `FnOnce` is not general enough
+  --> $DIR/drop-tracking-unresolved-typeck-results.rs:102:5
+   |
+LL | /     send(async {
+LL | |         Next(&Buffered(Map(Empty(PhantomData), ready::<&()>), FuturesOrdered(PhantomData), 0)).await
+LL | |     });
+   | |______^ implementation of `FnOnce` is not general enough
+   |
+   = note: `fn(&'0 ()) -> std::future::Ready<&'0 ()> {std::future::ready::<&'0 ()>}` must implement `FnOnce<(&'1 (),)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `FnOnce<(&(),)>`
+
+error: implementation of `FnOnce` is not general enough
+  --> $DIR/drop-tracking-unresolved-typeck-results.rs:102:5
+   |
+LL | /     send(async {
+LL | |         Next(&Buffered(Map(Empty(PhantomData), ready::<&()>), FuturesOrdered(PhantomData), 0)).await
+LL | |     });
+   | |______^ implementation of `FnOnce` is not general enough
+   |
+   = note: `fn(&'0 ()) -> std::future::Ready<&'0 ()> {std::future::ready::<&'0 ()>}` must implement `FnOnce<(&'1 (),)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `FnOnce<(&(),)>`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/drop-tracking-unresolved-typeck-results.rs b/tests/ui/async-await/drop-tracking-unresolved-typeck-results.rs
index 51945e02352..16f929331cb 100644
--- a/tests/ui/async-await/drop-tracking-unresolved-typeck-results.rs
+++ b/tests/ui/async-await/drop-tracking-unresolved-typeck-results.rs
@@ -1,6 +1,9 @@
 //@ incremental
 //@ edition: 2021
-//@ check-pass
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
 
 use std::future::*;
 use std::marker::PhantomData;
diff --git a/tests/ui/async-await/return-type-notation/issue-110963-early.no_assumptions.stderr b/tests/ui/async-await/return-type-notation/issue-110963-early.no_assumptions.stderr
new file mode 100644
index 00000000000..bb436364924
--- /dev/null
+++ b/tests/ui/async-await/return-type-notation/issue-110963-early.no_assumptions.stderr
@@ -0,0 +1,31 @@
+error: implementation of `Send` is not general enough
+  --> $DIR/issue-110963-early.rs:17:5
+   |
+LL | /     spawn(async move {
+LL | |         let mut hc = hc;
+LL | |         if !hc.check().await {
+LL | |             log_health_check_failure().await;
+LL | |         }
+LL | |     });
+   | |______^ implementation of `Send` is not general enough
+   |
+   = note: `Send` would have to be implemented for the type `impl Future<Output = bool> { <HC as HealthCheck>::check<'0>(..) }`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Send` is actually implemented for the type `impl Future<Output = bool> { <HC as HealthCheck>::check<'2>(..) }`, for some specific lifetime `'2`
+
+error: implementation of `Send` is not general enough
+  --> $DIR/issue-110963-early.rs:17:5
+   |
+LL | /     spawn(async move {
+LL | |         let mut hc = hc;
+LL | |         if !hc.check().await {
+LL | |             log_health_check_failure().await;
+LL | |         }
+LL | |     });
+   | |______^ implementation of `Send` is not general enough
+   |
+   = note: `Send` would have to be implemented for the type `impl Future<Output = bool> { <HC as HealthCheck>::check<'0>(..) }`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Send` is actually implemented for the type `impl Future<Output = bool> { <HC as HealthCheck>::check<'2>(..) }`, for some specific lifetime `'2`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/return-type-notation/issue-110963-early.rs b/tests/ui/async-await/return-type-notation/issue-110963-early.rs
index 7985f2e2de1..8c3180c0119 100644
--- a/tests/ui/async-await/return-type-notation/issue-110963-early.rs
+++ b/tests/ui/async-await/return-type-notation/issue-110963-early.rs
@@ -1,5 +1,8 @@
 //@ edition: 2021
-//@ check-pass
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
 
 #![feature(return_type_notation)]
 
diff --git a/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.no_assumptions.stderr b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.no_assumptions.stderr
new file mode 100644
index 00000000000..8b62fb6a254
--- /dev/null
+++ b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.no_assumptions.stderr
@@ -0,0 +1,24 @@
+error: lifetime bound not satisfied
+  --> $DIR/higher-ranked-coroutine-param-outlives-2.rs:14:5
+   |
+LL | /     async { // a coroutine checked for autotrait impl `Send`
+LL | |         let x = None::<I::Future<'_, '_>>; // a type referencing GAT
+LL | |         async {}.await; // a yield point
+LL | |     }
+   | |_____^
+   |
+   = note: this is a known limitation that will be removed in the future (see issue #100013 <https://github.com/rust-lang/rust/issues/100013> for more information)
+
+error: lifetime bound not satisfied
+  --> $DIR/higher-ranked-coroutine-param-outlives-2.rs:21:5
+   |
+LL | /     async { // a coroutine checked for autotrait impl `Send`
+LL | |         let x = None::<I::Future<'a, 'b>>; // a type referencing GAT
+LL | |         async {}.await; // a yield point
+LL | |     }
+   | |_____^
+   |
+   = note: this is a known limitation that will be removed in the future (see issue #100013 <https://github.com/rust-lang/rust/issues/100013> for more information)
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.rs b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.rs
index f7762600165..a5ed162d62c 100644
--- a/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.rs
+++ b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives-2.rs
@@ -1,5 +1,8 @@
-//@ check-pass
 //@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
 
 pub trait FutureIterator {
     type Future<'s, 'cx>: Send
diff --git a/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.no_assumptions.stderr b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.no_assumptions.stderr
new file mode 100644
index 00000000000..f747ba9a733
--- /dev/null
+++ b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.no_assumptions.stderr
@@ -0,0 +1,8 @@
+error: `C` does not live long enough
+  --> $DIR/higher-ranked-coroutine-param-outlives.rs:21:5
+   |
+LL |     async move { c.connect().await }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.rs b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.rs
index 33a085ad26b..5f683bd82fa 100644
--- a/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.rs
+++ b/tests/ui/generic-associated-types/higher-ranked-coroutine-param-outlives.rs
@@ -1,5 +1,8 @@
 //@ edition:2018
-//@ check-pass
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
 
 use std::future::Future;
 
-- 
cgit 1.4.1-3-g733a5


From 78fa79e7a642c8817b67d1c10d782c4c7b661a00 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 13 Jul 2025 23:17:21 +0000
Subject: Add tests, some of them fail...

---
 ...igher-ranked-auto-trait-1.no_assumptions.stderr | 38 ++++++++++++
 tests/ui/async-await/higher-ranked-auto-trait-1.rs | 48 +++++++++++++++
 .../higher-ranked-auto-trait-10.assumptions.stderr | 21 +++++++
 ...gher-ranked-auto-trait-10.no_assumptions.stderr | 21 +++++++
 .../ui/async-await/higher-ranked-auto-trait-10.rs  | 35 +++++++++++
 .../higher-ranked-auto-trait-11.assumptions.stderr | 20 ++++++
 ...gher-ranked-auto-trait-11.no_assumptions.stderr | 20 ++++++
 .../ui/async-await/higher-ranked-auto-trait-11.rs  | 31 ++++++++++
 ...gher-ranked-auto-trait-12.no_assumptions.stderr | 18 ++++++
 .../ui/async-await/higher-ranked-auto-trait-12.rs  | 40 ++++++++++++
 .../higher-ranked-auto-trait-13.assumptions.stderr | 41 ++++++++++++
 ...gher-ranked-auto-trait-13.no_assumptions.stderr | 60 ++++++++++++++++++
 .../ui/async-await/higher-ranked-auto-trait-13.rs  | 68 ++++++++++++++++++++
 ...gher-ranked-auto-trait-14.no_assumptions.stderr | 33 ++++++++++
 .../ui/async-await/higher-ranked-auto-trait-14.rs  | 29 +++++++++
 ...gher-ranked-auto-trait-15.no_assumptions.stderr | 21 +++++++
 .../ui/async-await/higher-ranked-auto-trait-15.rs  | 21 +++++++
 .../higher-ranked-auto-trait-16.assumptions.stderr | 25 ++++++++
 ...gher-ranked-auto-trait-16.no_assumptions.stderr | 25 ++++++++
 .../ui/async-await/higher-ranked-auto-trait-16.rs  | 23 +++++++
 ...gher-ranked-auto-trait-17.no_assumptions.stderr | 29 +++++++++
 .../ui/async-await/higher-ranked-auto-trait-17.rs  | 30 +++++++++
 ...igher-ranked-auto-trait-2.no_assumptions.stderr | 49 +++++++++++++++
 tests/ui/async-await/higher-ranked-auto-trait-2.rs | 23 +++++++
 ...igher-ranked-auto-trait-3.no_assumptions.stderr | 12 ++++
 tests/ui/async-await/higher-ranked-auto-trait-3.rs | 72 ++++++++++++++++++++++
 ...igher-ranked-auto-trait-4.no_assumptions.stderr | 10 +++
 tests/ui/async-await/higher-ranked-auto-trait-4.rs | 34 ++++++++++
 ...igher-ranked-auto-trait-5.no_assumptions.stderr | 13 ++++
 tests/ui/async-await/higher-ranked-auto-trait-5.rs | 54 ++++++++++++++++
 ...igher-ranked-auto-trait-6.no_assumptions.stderr | 50 +++++++++++++++
 tests/ui/async-await/higher-ranked-auto-trait-6.rs | 59 ++++++++++++++++++
 ...igher-ranked-auto-trait-7.no_assumptions.stderr |  8 +++
 tests/ui/async-await/higher-ranked-auto-trait-7.rs | 33 ++++++++++
 ...igher-ranked-auto-trait-8.no_assumptions.stderr | 10 +++
 tests/ui/async-await/higher-ranked-auto-trait-8.rs | 27 ++++++++
 ...igher-ranked-auto-trait-9.no_assumptions.stderr | 11 ++++
 tests/ui/async-await/higher-ranked-auto-trait-9.rs | 44 +++++++++++++
 38 files changed, 1206 insertions(+)
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-1.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-1.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-10.assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-10.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-10.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-11.assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-11.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-11.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-12.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-12.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-13.assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-13.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-13.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-14.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-14.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-15.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-15.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-16.assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-16.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-16.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-17.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-17.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-2.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-2.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-3.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-3.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-4.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-4.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-5.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-5.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-6.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-6.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-7.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-7.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-8.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-8.rs
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-9.no_assumptions.stderr
 create mode 100644 tests/ui/async-await/higher-ranked-auto-trait-9.rs

diff --git a/tests/ui/async-await/higher-ranked-auto-trait-1.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-1.no_assumptions.stderr
new file mode 100644
index 00000000000..b298a3bf215
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-1.no_assumptions.stderr
@@ -0,0 +1,38 @@
+error[E0308]: mismatched types
+  --> $DIR/higher-ranked-auto-trait-1.rs:37:5
+   |
+LL | /     async {
+LL | |         let _y = &();
+LL | |         let _x = filter(FilterMap {
+LL | |             f: || async move { *_y },
+...  |
+LL | |         drop(_x);
+LL | |     }
+   | |_____^ one type is more general than the other
+   |
+   = note: expected `async` block `{async block@$DIR/higher-ranked-auto-trait-1.rs:40:19: 40:29}`
+              found `async` block `{async block@$DIR/higher-ranked-auto-trait-1.rs:40:19: 40:29}`
+   = note: no two async blocks, even if identical, have the same type
+   = help: consider pinning your async block and casting it to a trait object
+
+error[E0308]: mismatched types
+  --> $DIR/higher-ranked-auto-trait-1.rs:37:5
+   |
+LL | /     async {
+LL | |         let _y = &();
+LL | |         let _x = filter(FilterMap {
+LL | |             f: || async move { *_y },
+...  |
+LL | |         drop(_x);
+LL | |     }
+   | |_____^ one type is more general than the other
+   |
+   = note: expected `async` block `{async block@$DIR/higher-ranked-auto-trait-1.rs:40:19: 40:29}`
+              found `async` block `{async block@$DIR/higher-ranked-auto-trait-1.rs:40:19: 40:29}`
+   = note: no two async blocks, even if identical, have the same type
+   = help: consider pinning your async block and casting it to a trait object
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-1.rs b/tests/ui/async-await/higher-ranked-auto-trait-1.rs
new file mode 100644
index 00000000000..740f7e29245
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-1.rs
@@ -0,0 +1,48 @@
+// Repro for <https://github.com/rust-lang/rust/issues/79648#issuecomment-749127947>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+use std::future::Future;
+use std::marker::PhantomData;
+
+trait Stream {
+    type Item;
+}
+
+struct Filter<St: Stream> {
+    pending_item: St::Item,
+}
+
+fn filter<St: Stream>(_: St) -> Filter<St> {
+    unimplemented!();
+}
+
+struct FilterMap<Fut, F> {
+    f: F,
+    pending: PhantomData<Fut>,
+}
+
+impl<Fut, F> Stream for FilterMap<Fut, F>
+where
+    F: FnMut() -> Fut,
+    Fut: Future,
+{
+    type Item = ();
+}
+
+pub fn get_foo() -> impl Future + Send {
+    async {
+        let _y = &();
+        let _x = filter(FilterMap {
+            f: || async move { *_y },
+            pending: PhantomData,
+        });
+        async {}.await;
+        drop(_x);
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-10.assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-10.assumptions.stderr
new file mode 100644
index 00000000000..6fcf1b1eac1
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-10.assumptions.stderr
@@ -0,0 +1,21 @@
+error: implementation of `Foo` is not general enough
+  --> $DIR/higher-ranked-auto-trait-10.rs:32:5
+   |
+LL |     Box::new(async move { get_foo(x).await })
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Foo` is not general enough
+   |
+   = note: `Foo<'1>` would have to be implemented for the type `&'0 str`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Foo<'2>` is actually implemented for the type `&'2 str`, for some specific lifetime `'2`
+
+error: implementation of `Foo` is not general enough
+  --> $DIR/higher-ranked-auto-trait-10.rs:32:5
+   |
+LL |     Box::new(async move { get_foo(x).await })
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Foo` is not general enough
+   |
+   = note: `Foo<'1>` would have to be implemented for the type `&'0 str`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Foo<'2>` is actually implemented for the type `&'2 str`, for some specific lifetime `'2`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-10.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-10.no_assumptions.stderr
new file mode 100644
index 00000000000..6fcf1b1eac1
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-10.no_assumptions.stderr
@@ -0,0 +1,21 @@
+error: implementation of `Foo` is not general enough
+  --> $DIR/higher-ranked-auto-trait-10.rs:32:5
+   |
+LL |     Box::new(async move { get_foo(x).await })
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Foo` is not general enough
+   |
+   = note: `Foo<'1>` would have to be implemented for the type `&'0 str`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Foo<'2>` is actually implemented for the type `&'2 str`, for some specific lifetime `'2`
+
+error: implementation of `Foo` is not general enough
+  --> $DIR/higher-ranked-auto-trait-10.rs:32:5
+   |
+LL |     Box::new(async move { get_foo(x).await })
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Foo` is not general enough
+   |
+   = note: `Foo<'1>` would have to be implemented for the type `&'0 str`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Foo<'2>` is actually implemented for the type `&'2 str`, for some specific lifetime `'2`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-10.rs b/tests/ui/async-await/higher-ranked-auto-trait-10.rs
new file mode 100644
index 00000000000..4bfa27961ab
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-10.rs
@@ -0,0 +1,35 @@
+// Repro for <https://github.com/rust-lang/rust/issues/92415#issue-1090723521>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] known-bug: unknown
+//@[no_assumptions] known-bug: #110338
+
+use std::any::Any;
+use std::future::Future;
+
+trait Foo<'a>: Sized {
+    type Error;
+    fn foo(x: &'a str) -> Result<Self, Self::Error>;
+}
+
+impl<'a> Foo<'a> for &'a str {
+    type Error = ();
+
+    fn foo(x: &'a str) -> Result<Self, Self::Error> {
+        Ok(x)
+    }
+}
+
+async fn get_foo<'a, T>(x: &'a str) -> Result<T, <T as Foo<'a>>::Error>
+where
+    T: Foo<'a>,
+{
+    Foo::foo(x)
+}
+
+fn bar<'a>(x: &'a str) -> Box<dyn Future<Output = Result<&'a str, ()>> + Send + 'a> {
+    Box::new(async move { get_foo(x).await })
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-11.assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-11.assumptions.stderr
new file mode 100644
index 00000000000..d39843f628c
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-11.assumptions.stderr
@@ -0,0 +1,20 @@
+error: lifetime may not live long enough
+  --> $DIR/higher-ranked-auto-trait-11.rs:27:9
+   |
+LL | impl<'a, T> Foo<'a> for MyType<T>
+   |      -- lifetime `'a` defined here
+...
+LL |         Box::pin(async move { <T as Foo<'a>>::foo().await })
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ coercion requires that `'a` must outlive `'static`
+
+error: implementation of `Send` is not general enough
+  --> $DIR/higher-ranked-auto-trait-11.rs:27:9
+   |
+LL |         Box::pin(async move { <T as Foo<'a>>::foo().await })
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Send` is not general enough
+   |
+   = note: `Send` would have to be implemented for the type `<T as Foo<'0>>::Future`, for any lifetime `'0`...
+   = note: ...but `Send` is actually implemented for the type `<T as Foo<'1>>::Future`, for some specific lifetime `'1`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-11.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-11.no_assumptions.stderr
new file mode 100644
index 00000000000..d39843f628c
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-11.no_assumptions.stderr
@@ -0,0 +1,20 @@
+error: lifetime may not live long enough
+  --> $DIR/higher-ranked-auto-trait-11.rs:27:9
+   |
+LL | impl<'a, T> Foo<'a> for MyType<T>
+   |      -- lifetime `'a` defined here
+...
+LL |         Box::pin(async move { <T as Foo<'a>>::foo().await })
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ coercion requires that `'a` must outlive `'static`
+
+error: implementation of `Send` is not general enough
+  --> $DIR/higher-ranked-auto-trait-11.rs:27:9
+   |
+LL |         Box::pin(async move { <T as Foo<'a>>::foo().await })
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Send` is not general enough
+   |
+   = note: `Send` would have to be implemented for the type `<T as Foo<'0>>::Future`, for any lifetime `'0`...
+   = note: ...but `Send` is actually implemented for the type `<T as Foo<'1>>::Future`, for some specific lifetime `'1`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-11.rs b/tests/ui/async-await/higher-ranked-auto-trait-11.rs
new file mode 100644
index 00000000000..3aebdd8224d
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-11.rs
@@ -0,0 +1,31 @@
+// Repro for <https://github.com/rust-lang/rust/issues/60658#issuecomment-1509321859>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] known-bug: unknown
+//@[no_assumptions] known-bug: #110338
+
+use core::pin::Pin;
+use std::future::Future;
+
+pub trait Foo<'a> {
+    type Future: Future<Output = ()>;
+
+    fn foo() -> Self::Future;
+}
+
+struct MyType<T>(T);
+
+impl<'a, T> Foo<'a> for MyType<T>
+where
+    T: Foo<'a>,
+    T::Future: Send,
+{
+    type Future = Pin<Box<dyn Future<Output = ()> + Send + 'a>>;
+
+    fn foo() -> Self::Future {
+        Box::pin(async move { <T as Foo<'a>>::foo().await })
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-12.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-12.no_assumptions.stderr
new file mode 100644
index 00000000000..63e71cbc40c
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-12.no_assumptions.stderr
@@ -0,0 +1,18 @@
+error: implementation of `Robot` is not general enough
+  --> $DIR/higher-ranked-auto-trait-12.rs:31:20
+   |
+LL |       let _my_task = this_is_send(async move {
+   |  ____________________^
+LL | |         let _my_iter = IRobot {
+LL | |             id: 32,
+LL | |             robot: source,
+LL | |         };
+LL | |         yield_now().await;
+LL | |     });
+   | |______^ implementation of `Robot` is not general enough
+   |
+   = note: `Box<(dyn Robot<Id = u32> + Send + '0)>` must implement `Robot`, for any lifetime `'0`...
+   = note: ...but `Robot` is actually implemented for the type `Box<(dyn Robot<Id = u32> + Send + 'static)>`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-12.rs b/tests/ui/async-await/higher-ranked-auto-trait-12.rs
new file mode 100644
index 00000000000..b1cca5cbb00
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-12.rs
@@ -0,0 +1,40 @@
+// Repro for <https://github.com/rust-lang/rust/issues/71671#issuecomment-848994782>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+pub trait Robot {
+    type Id;
+}
+
+pub type DynRobot = Box<dyn Robot<Id = u32> + Send>;
+
+impl Robot for DynRobot {
+    type Id = u32;
+}
+
+struct IRobot<R: Robot> {
+    id: R::Id,
+    robot: R,
+}
+
+// stand-in for tokio::spawn
+fn this_is_send<T: Send>(value: T) -> T {
+    value
+}
+
+async fn yield_now() {}
+
+fn test(source: DynRobot) {
+    let _my_task = this_is_send(async move {
+        let _my_iter = IRobot {
+            id: 32,
+            robot: source,
+        };
+        yield_now().await;
+    });
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-13.assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-13.assumptions.stderr
new file mode 100644
index 00000000000..f69218740dc
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-13.assumptions.stderr
@@ -0,0 +1,41 @@
+error: implementation of `Getter` is not general enough
+  --> $DIR/higher-ranked-auto-trait-13.rs:65:5
+   |
+LL |     assert_send(my_send_async_method(struct_with_lifetime, data));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Getter` is not general enough
+   |
+   = note: `Getter<'1>` would have to be implemented for the type `GetterImpl<'0, ConstructableImpl<'_>>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Getter<'2>` is actually implemented for the type `GetterImpl<'2, ConstructableImpl<'_>>`, for some specific lifetime `'2`
+
+error: implementation of `Getter` is not general enough
+  --> $DIR/higher-ranked-auto-trait-13.rs:65:5
+   |
+LL |     assert_send(my_send_async_method(struct_with_lifetime, data));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Getter` is not general enough
+   |
+   = note: `Getter<'1>` would have to be implemented for the type `GetterImpl<'0, ConstructableImpl<'_>>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Getter<'2>` is actually implemented for the type `GetterImpl<'2, ConstructableImpl<'_>>`, for some specific lifetime `'2`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: implementation of `Getter` is not general enough
+  --> $DIR/higher-ranked-auto-trait-13.rs:65:5
+   |
+LL |     assert_send(my_send_async_method(struct_with_lifetime, data));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Getter` is not general enough
+   |
+   = note: `Getter<'1>` would have to be implemented for the type `GetterImpl<'0, ConstructableImpl<'_>>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Getter<'2>` is actually implemented for the type `GetterImpl<'2, ConstructableImpl<'_>>`, for some specific lifetime `'2`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: implementation of `Getter` is not general enough
+  --> $DIR/higher-ranked-auto-trait-13.rs:65:5
+   |
+LL |     assert_send(my_send_async_method(struct_with_lifetime, data));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Getter` is not general enough
+   |
+   = note: `Getter<'1>` would have to be implemented for the type `GetterImpl<'0, ConstructableImpl<'_>>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Getter<'2>` is actually implemented for the type `GetterImpl<'2, ConstructableImpl<'_>>`, for some specific lifetime `'2`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-13.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-13.no_assumptions.stderr
new file mode 100644
index 00000000000..cfbdaa8ad4b
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-13.no_assumptions.stderr
@@ -0,0 +1,60 @@
+error: implementation of `Getter` is not general enough
+  --> $DIR/higher-ranked-auto-trait-13.rs:65:5
+   |
+LL |     assert_send(my_send_async_method(struct_with_lifetime, data));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Getter` is not general enough
+   |
+   = note: `Getter<'1>` would have to be implemented for the type `GetterImpl<'0, ConstructableImpl<'_>>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Getter<'2>` is actually implemented for the type `GetterImpl<'2, ConstructableImpl<'_>>`, for some specific lifetime `'2`
+
+error: implementation of `Getter` is not general enough
+  --> $DIR/higher-ranked-auto-trait-13.rs:65:5
+   |
+LL |     assert_send(my_send_async_method(struct_with_lifetime, data));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Getter` is not general enough
+   |
+   = note: `Getter<'1>` would have to be implemented for the type `GetterImpl<'0, ConstructableImpl<'_>>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Getter<'2>` is actually implemented for the type `GetterImpl<'2, ConstructableImpl<'_>>`, for some specific lifetime `'2`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: implementation of `Callable` is not general enough
+  --> $DIR/higher-ranked-auto-trait-13.rs:65:5
+   |
+LL |     assert_send(my_send_async_method(struct_with_lifetime, data));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Callable` is not general enough
+   |
+   = note: `Callable<'_>` would have to be implemented for the type `ConstructableImpl<'0>`, for any lifetime `'0`...
+   = note: ...but `Callable<'1>` is actually implemented for the type `ConstructableImpl<'1>`, for some specific lifetime `'1`
+
+error: implementation of `Getter` is not general enough
+  --> $DIR/higher-ranked-auto-trait-13.rs:65:5
+   |
+LL |     assert_send(my_send_async_method(struct_with_lifetime, data));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Getter` is not general enough
+   |
+   = note: `Getter<'1>` would have to be implemented for the type `GetterImpl<'0, ConstructableImpl<'_>>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Getter<'2>` is actually implemented for the type `GetterImpl<'2, ConstructableImpl<'_>>`, for some specific lifetime `'2`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: implementation of `Getter` is not general enough
+  --> $DIR/higher-ranked-auto-trait-13.rs:65:5
+   |
+LL |     assert_send(my_send_async_method(struct_with_lifetime, data));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Getter` is not general enough
+   |
+   = note: `Getter<'1>` would have to be implemented for the type `GetterImpl<'0, ConstructableImpl<'_>>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but `Getter<'2>` is actually implemented for the type `GetterImpl<'2, ConstructableImpl<'_>>`, for some specific lifetime `'2`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: implementation of `Callable` is not general enough
+  --> $DIR/higher-ranked-auto-trait-13.rs:65:5
+   |
+LL |     assert_send(my_send_async_method(struct_with_lifetime, data));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Callable` is not general enough
+   |
+   = note: `Callable<'_>` would have to be implemented for the type `ConstructableImpl<'0>`, for any lifetime `'0`...
+   = note: ...but `Callable<'1>` is actually implemented for the type `ConstructableImpl<'1>`, for some specific lifetime `'1`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-13.rs b/tests/ui/async-await/higher-ranked-auto-trait-13.rs
new file mode 100644
index 00000000000..4bce0f5197f
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-13.rs
@@ -0,0 +1,68 @@
+// Repro for <https://github.com/rust-lang/rust/issues/114046#issue-1819720359>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] known-bug: unknown
+//@[no_assumptions] known-bug: #110338
+
+use std::marker::PhantomData;
+
+trait Callable<'a>: Send + Sync {
+    fn callable(data: &'a [u8]);
+}
+
+trait Getter<'a>: Send + Sync {
+    type ItemSize: Send + Sync;
+
+    fn get(data: &'a [u8]);
+}
+
+struct List<'a, A: Getter<'a>> {
+    data: &'a [u8],
+    item_size: A::ItemSize, // Removing this member causes the code to compile
+    phantom: PhantomData<A>,
+}
+
+struct GetterImpl<'a, T: Callable<'a> + 'a> {
+    p: PhantomData<&'a T>,
+}
+
+impl<'a, T: Callable<'a> + 'a> Getter<'a> for GetterImpl<'a, T> {
+    type ItemSize = ();
+
+    fn get(data: &'a [u8]) {
+        <T>::callable(data);
+    }
+}
+
+struct ConstructableImpl<'a> {
+    _data: &'a [u8],
+}
+
+impl<'a> Callable<'a> for ConstructableImpl<'a> {
+    fn callable(_: &'a [u8]) {}
+}
+
+struct StructWithLifetime<'a> {
+    marker: &'a PhantomData<u8>,
+}
+
+async fn async_method() {}
+
+fn assert_send(_: impl Send + Sync) {}
+
+// This async method ought to be send, but is not
+async fn my_send_async_method(_struct_with_lifetime: &mut StructWithLifetime<'_>, data: &Vec<u8>) {
+    let _named =
+        List::<'_, GetterImpl<ConstructableImpl<'_>>> { data, item_size: (), phantom: PhantomData };
+    // Moving the await point above the constructed of _named, causes
+    // the method to become send, even though _named is Send + Sync
+    async_method().await;
+    assert_send(_named);
+}
+
+fn dummy(struct_with_lifetime: &mut StructWithLifetime<'_>, data: &Vec<u8>) {
+    assert_send(my_send_async_method(struct_with_lifetime, data));
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-14.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-14.no_assumptions.stderr
new file mode 100644
index 00000000000..b47db2b19ff
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-14.no_assumptions.stderr
@@ -0,0 +1,33 @@
+error: implementation of `FnOnce` is not general enough
+  --> $DIR/higher-ranked-auto-trait-14.rs:20:5
+   |
+LL | /     async move {
+LL | |         let xs = unique_x.union(&cached)
+LL | |             // .copied() // works
+LL | |             .map(|x| *x) // error
+LL | |             ;
+LL | |         let blah = val.blah(xs.into_iter()).await;
+LL | |     }
+   | |_____^ implementation of `FnOnce` is not general enough
+   |
+   = note: closure with signature `fn(&'0 u32) -> u32` must implement `FnOnce<(&'1 u32,)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `FnOnce<(&u32,)>`
+
+error: implementation of `FnOnce` is not general enough
+  --> $DIR/higher-ranked-auto-trait-14.rs:20:5
+   |
+LL | /     async move {
+LL | |         let xs = unique_x.union(&cached)
+LL | |             // .copied() // works
+LL | |             .map(|x| *x) // error
+LL | |             ;
+LL | |         let blah = val.blah(xs.into_iter()).await;
+LL | |     }
+   | |_____^ implementation of `FnOnce` is not general enough
+   |
+   = note: closure with signature `fn(&'0 u32) -> u32` must implement `FnOnce<(&'1 u32,)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `FnOnce<(&u32,)>`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-14.rs b/tests/ui/async-await/higher-ranked-auto-trait-14.rs
new file mode 100644
index 00000000000..5ed12cd6e38
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-14.rs
@@ -0,0 +1,29 @@
+// Repro for <https://github.com/rust-lang/rust/issues/124757#issue-2279603232>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+use std::collections::HashSet;
+use std::future::Future;
+
+trait MyTrait {
+    fn blah(&self, x: impl Iterator<Item = u32>) -> impl Future<Output = ()> + Send;
+}
+
+fn foo<T: MyTrait + Send + Sync>(
+    val: T,
+    unique_x: HashSet<u32>,
+) -> impl Future<Output = ()> + Send {
+    let cached = HashSet::new();
+    async move {
+        let xs = unique_x.union(&cached)
+            // .copied() // works
+            .map(|x| *x) // error
+            ;
+        let blah = val.blah(xs.into_iter()).await;
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-15.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-15.no_assumptions.stderr
new file mode 100644
index 00000000000..b4f3570d9f2
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-15.no_assumptions.stderr
@@ -0,0 +1,21 @@
+error: implementation of `FnOnce` is not general enough
+  --> $DIR/higher-ranked-auto-trait-15.rs:20:5
+   |
+LL |     require_send(future);
+   |     ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough
+   |
+   = note: closure with signature `fn(&'0 Vec<i32>) -> std::slice::Iter<'_, i32>` must implement `FnOnce<(&'1 Vec<i32>,)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `FnOnce<(&Vec<i32>,)>`
+
+error: implementation of `FnOnce` is not general enough
+  --> $DIR/higher-ranked-auto-trait-15.rs:20:5
+   |
+LL |     require_send(future);
+   |     ^^^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough
+   |
+   = note: closure with signature `fn(&'0 Vec<i32>) -> std::slice::Iter<'_, i32>` must implement `FnOnce<(&'1 Vec<i32>,)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `FnOnce<(&Vec<i32>,)>`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-15.rs b/tests/ui/async-await/higher-ranked-auto-trait-15.rs
new file mode 100644
index 00000000000..153fcac4c3a
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-15.rs
@@ -0,0 +1,21 @@
+// Repro for <https://github.com/rust-lang/rust/issues/126044#issuecomment-2154313449>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+async fn listen() {
+    let things: Vec<Vec<i32>> = vec![];
+    for _ in things.iter().map(|n| n.iter()).flatten() {
+        // comment this line and everything compiles
+        async {}.await;
+    }
+}
+
+fn require_send<T: Send>(_x: T) {}
+
+fn main() {
+    let future = listen();
+    require_send(future);
+}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-16.assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-16.assumptions.stderr
new file mode 100644
index 00000000000..412c31b1bd8
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-16.assumptions.stderr
@@ -0,0 +1,25 @@
+error: implementation of `AsyncFnOnce` is not general enough
+  --> $DIR/higher-ranked-auto-trait-16.rs:18:5
+   |
+LL | /     assert_send(async {
+LL | |         commit_if_ok(&mut ctxt, async |_| todo!()).await;
+LL | |     });
+   | |______^ implementation of `AsyncFnOnce` is not general enough
+   |
+   = note: `{async closure@$DIR/higher-ranked-auto-trait-16.rs:19:33: 19:42}` must implement `AsyncFnOnce<(&mut Ctxt<'1>,)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `AsyncFnOnce<(&mut Ctxt<'_>,)>`
+
+error: implementation of `AsyncFnOnce` is not general enough
+  --> $DIR/higher-ranked-auto-trait-16.rs:18:5
+   |
+LL | /     assert_send(async {
+LL | |         commit_if_ok(&mut ctxt, async |_| todo!()).await;
+LL | |     });
+   | |______^ implementation of `AsyncFnOnce` is not general enough
+   |
+   = note: `{async closure@$DIR/higher-ranked-auto-trait-16.rs:19:33: 19:42}` must implement `AsyncFnOnce<(&mut Ctxt<'1>,)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `AsyncFnOnce<(&mut Ctxt<'_>,)>`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-16.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-16.no_assumptions.stderr
new file mode 100644
index 00000000000..412c31b1bd8
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-16.no_assumptions.stderr
@@ -0,0 +1,25 @@
+error: implementation of `AsyncFnOnce` is not general enough
+  --> $DIR/higher-ranked-auto-trait-16.rs:18:5
+   |
+LL | /     assert_send(async {
+LL | |         commit_if_ok(&mut ctxt, async |_| todo!()).await;
+LL | |     });
+   | |______^ implementation of `AsyncFnOnce` is not general enough
+   |
+   = note: `{async closure@$DIR/higher-ranked-auto-trait-16.rs:19:33: 19:42}` must implement `AsyncFnOnce<(&mut Ctxt<'1>,)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `AsyncFnOnce<(&mut Ctxt<'_>,)>`
+
+error: implementation of `AsyncFnOnce` is not general enough
+  --> $DIR/higher-ranked-auto-trait-16.rs:18:5
+   |
+LL | /     assert_send(async {
+LL | |         commit_if_ok(&mut ctxt, async |_| todo!()).await;
+LL | |     });
+   | |______^ implementation of `AsyncFnOnce` is not general enough
+   |
+   = note: `{async closure@$DIR/higher-ranked-auto-trait-16.rs:19:33: 19:42}` must implement `AsyncFnOnce<(&mut Ctxt<'1>,)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `AsyncFnOnce<(&mut Ctxt<'_>,)>`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-16.rs b/tests/ui/async-await/higher-ranked-auto-trait-16.rs
new file mode 100644
index 00000000000..2b206f0a4c5
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-16.rs
@@ -0,0 +1,23 @@
+// Repro for <https://github.com/rust-lang/rust/issues/126350#issue-2349492101>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] known-bug: unknown
+//@[no_assumptions] known-bug: #110338
+
+fn assert_send<T: Send>(_: T) {}
+
+#[derive(Clone)]
+struct Ctxt<'a>(&'a ());
+
+async fn commit_if_ok<'a>(ctxt: &mut Ctxt<'a>, f: impl AsyncFnOnce(&mut Ctxt<'a>)) {
+    f(&mut ctxt.clone()).await;
+}
+
+fn operation(mut ctxt: Ctxt<'_>) {
+    assert_send(async {
+        commit_if_ok(&mut ctxt, async |_| todo!()).await;
+    });
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-17.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-17.no_assumptions.stderr
new file mode 100644
index 00000000000..152900ca1ae
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-17.no_assumptions.stderr
@@ -0,0 +1,29 @@
+error: implementation of `FnOnce` is not general enough
+  --> $DIR/higher-ranked-auto-trait-17.rs:12:5
+   |
+LL | /     async move {
+LL | |         let iter = Adaptor::new(a.iter().map(|_: &()| {}));
+LL | |         std::future::pending::<()>().await;
+LL | |         drop(iter);
+LL | |     }
+   | |_____^ implementation of `FnOnce` is not general enough
+   |
+   = note: closure with signature `fn(&'0 ())` must implement `FnOnce<(&'1 (),)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `FnOnce<(&(),)>`
+
+error: implementation of `FnOnce` is not general enough
+  --> $DIR/higher-ranked-auto-trait-17.rs:12:5
+   |
+LL | /     async move {
+LL | |         let iter = Adaptor::new(a.iter().map(|_: &()| {}));
+LL | |         std::future::pending::<()>().await;
+LL | |         drop(iter);
+LL | |     }
+   | |_____^ implementation of `FnOnce` is not general enough
+   |
+   = note: closure with signature `fn(&'0 ())` must implement `FnOnce<(&'1 (),)>`, for any two lifetimes `'0` and `'1`...
+   = note: ...but it actually implements `FnOnce<(&(),)>`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-17.rs b/tests/ui/async-await/higher-ranked-auto-trait-17.rs
new file mode 100644
index 00000000000..152432466c0
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-17.rs
@@ -0,0 +1,30 @@
+// Repro for <https://github.com/rust-lang/rust/issues/114177#issue-1826550174>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+// Using `impl Future` instead of `async to ensure that the Future is Send.
+//
+// In the original code `a` would be `&[T]`. For more minimization I've removed the reference.
+fn foo(a: [(); 0]) -> impl std::future::Future<Output = ()> + Send {
+    async move {
+        let iter = Adaptor::new(a.iter().map(|_: &()| {}));
+        std::future::pending::<()>().await;
+        drop(iter);
+    }
+}
+
+struct Adaptor<T: Iterator> {
+    iter: T,
+    v: T::Item,
+}
+
+impl<T: Iterator> Adaptor<T> {
+    pub fn new(_: T) -> Self {
+        Self { iter: todo!(), v: todo!() }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-2.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-2.no_assumptions.stderr
new file mode 100644
index 00000000000..2fc44412b9d
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-2.no_assumptions.stderr
@@ -0,0 +1,49 @@
+error: lifetime bound not satisfied
+  --> $DIR/higher-ranked-auto-trait-2.rs:16:9
+   |
+LL | /         async move {
+LL | |             // asks for an unspecified lifetime to outlive itself? weird diagnostics
+LL | |             self.run(t).await;
+LL | |         }
+   | |_________^
+   |
+   = note: this is a known limitation that will be removed in the future (see issue #100013 <https://github.com/rust-lang/rust/issues/100013> for more information)
+
+error: lifetime bound not satisfied
+  --> $DIR/higher-ranked-auto-trait-2.rs:16:9
+   |
+LL | /         async move {
+LL | |             // asks for an unspecified lifetime to outlive itself? weird diagnostics
+LL | |             self.run(t).await;
+LL | |         }
+   | |_________^
+   |
+   = note: this is a known limitation that will be removed in the future (see issue #100013 <https://github.com/rust-lang/rust/issues/100013> for more information)
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: lifetime bound not satisfied
+  --> $DIR/higher-ranked-auto-trait-2.rs:16:9
+   |
+LL | /         async move {
+LL | |             // asks for an unspecified lifetime to outlive itself? weird diagnostics
+LL | |             self.run(t).await;
+LL | |         }
+   | |_________^
+   |
+   = note: this is a known limitation that will be removed in the future (see issue #100013 <https://github.com/rust-lang/rust/issues/100013> for more information)
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: lifetime bound not satisfied
+  --> $DIR/higher-ranked-auto-trait-2.rs:16:9
+   |
+LL | /         async move {
+LL | |             // asks for an unspecified lifetime to outlive itself? weird diagnostics
+LL | |             self.run(t).await;
+LL | |         }
+   | |_________^
+   |
+   = note: this is a known limitation that will be removed in the future (see issue #100013 <https://github.com/rust-lang/rust/issues/100013> for more information)
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-2.rs b/tests/ui/async-await/higher-ranked-auto-trait-2.rs
new file mode 100644
index 00000000000..6c75597265b
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-2.rs
@@ -0,0 +1,23 @@
+// Repro for <https://github.com/rust-lang/rust/issues/111105#issue-1692860759>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+use std::future::Future;
+
+pub trait Foo: Sync {
+    fn run<'a, 'b: 'a, T: Sync>(&'a self, _: &'b T) -> impl Future<Output = ()> + 'a + Send;
+}
+
+pub trait FooExt: Foo {
+    fn run_via<'a, 'b: 'a, T: Sync>(&'a self, t: &'b T) -> impl Future<Output = ()> + 'a + Send {
+        async move {
+            // asks for an unspecified lifetime to outlive itself? weird diagnostics
+            self.run(t).await;
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-3.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-3.no_assumptions.stderr
new file mode 100644
index 00000000000..c5c98ac807e
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-3.no_assumptions.stderr
@@ -0,0 +1,12 @@
+error: lifetime bound not satisfied
+  --> $DIR/higher-ranked-auto-trait-3.rs:66:9
+   |
+LL | /         async {
+LL | |             self.fi_2.get_iter(cx).await;
+LL | |         }
+   | |_________^
+   |
+   = note: this is a known limitation that will be removed in the future (see issue #100013 <https://github.com/rust-lang/rust/issues/100013> for more information)
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-3.rs b/tests/ui/async-await/higher-ranked-auto-trait-3.rs
new file mode 100644
index 00000000000..d42d4236680
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-3.rs
@@ -0,0 +1,72 @@
+// Repro for <https://github.com/rust-lang/rust/issues/100013#issue-1323807923>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+#![feature(impl_trait_in_assoc_type)]
+
+use std::future::Future;
+
+pub trait FutureIterator: 'static {
+    type Iterator;
+
+    type Future<'s, 'cx>: Future<Output = Self::Iterator> + Send + 'cx
+    where
+        's: 'cx;
+
+    fn get_iter<'s, 'cx>(&'s self, info: &'cx ()) -> Self::Future<'s, 'cx>;
+}
+
+trait IterCaller: 'static {
+    type Future1<'cx>: Future<Output = ()> + Send + 'cx;
+    type Future2<'cx>: Future<Output = ()> + Send + 'cx;
+
+    fn call_1<'s, 'cx>(&'s self, cx: &'cx ()) -> Self::Future1<'cx>
+    where
+        's: 'cx;
+    fn call_2<'s, 'cx>(&'s self, cx: &'cx ()) -> Self::Future2<'cx>
+    where
+        's: 'cx;
+}
+
+struct UseIter<FI1, FI2> {
+    fi_1: FI1,
+    fi_2: FI2,
+}
+
+impl<FI1, FI2> IterCaller for UseIter<FI1, FI2>
+where
+    FI1: FutureIterator + 'static + Send + Sync,
+    for<'s, 'cx> FI1::Future<'s, 'cx>: Send,
+    FI2: FutureIterator + 'static + Send + Sync,
+{
+    type Future1<'cx> = impl Future<Output = ()> + Send + 'cx
+    where
+        Self: 'cx;
+
+    type Future2<'cx> = impl Future<Output = ()> + Send + 'cx
+    where
+        Self: 'cx;
+
+    fn call_1<'s, 'cx>(&'s self, cx: &'cx ()) -> Self::Future1<'cx>
+    where
+        's: 'cx,
+    {
+        async {
+            self.fi_1.get_iter(cx).await;
+        }
+    }
+
+    fn call_2<'s, 'cx>(&'s self, cx: &'cx ()) -> Self::Future2<'cx>
+    where
+        's: 'cx,
+    {
+        async {
+            self.fi_2.get_iter(cx).await;
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-4.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-4.no_assumptions.stderr
new file mode 100644
index 00000000000..5aa5b83655a
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-4.no_assumptions.stderr
@@ -0,0 +1,10 @@
+error: higher-ranked lifetime error
+  --> $DIR/higher-ranked-auto-trait-4.rs:29:5
+   |
+LL | /     async {
+LL | |         let _ = evil_function::<dyn BoringTrait, _>().await;
+LL | |     }
+   | |_____^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-4.rs b/tests/ui/async-await/higher-ranked-auto-trait-4.rs
new file mode 100644
index 00000000000..0586af41e9e
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-4.rs
@@ -0,0 +1,34 @@
+// Repro for <https://github.com/rust-lang/rust/issues/102211#issuecomment-2891975128>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+use std::future::Future;
+
+trait BoringTrait {}
+
+trait TraitWithAssocType<I> {
+    type Assoc;
+}
+
+impl<T> TraitWithAssocType<()> for T
+where
+    T: ?Sized + 'static,
+{
+    type Assoc = ();
+}
+
+fn evil_function<T: TraitWithAssocType<I> + ?Sized, I>()
+-> impl Future<Output = Result<(), T::Assoc>> {
+    async { Ok(()) }
+}
+
+fn fails_to_compile() -> impl std::future::Future<Output = ()> + Send {
+    async {
+        let _ = evil_function::<dyn BoringTrait, _>().await;
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-5.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-5.no_assumptions.stderr
new file mode 100644
index 00000000000..8fa3c7483c8
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-5.no_assumptions.stderr
@@ -0,0 +1,13 @@
+error: implementation of `Send` is not general enough
+  --> $DIR/higher-ranked-auto-trait-5.rs:13:5
+   |
+LL | /     assert_send(async {
+LL | |         call_me.call().await;
+LL | |     });
+   | |______^ implementation of `Send` is not general enough
+   |
+   = note: `Send` would have to be implemented for the type `&'0 str`, for any lifetime `'0`...
+   = note: ...but `Send` is actually implemented for the type `&'1 str`, for some specific lifetime `'1`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-5.rs b/tests/ui/async-await/higher-ranked-auto-trait-5.rs
new file mode 100644
index 00000000000..9a8b3f4357c
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-5.rs
@@ -0,0 +1,54 @@
+// Repro for <https://github.com/rust-lang/rust/issues/130113#issue-2512517191>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+use std::future::Future;
+
+fn main() {
+    let call_me = Wrap(CallMeImpl { value: "test" });
+
+    assert_send(async {
+        call_me.call().await;
+    });
+}
+
+pub fn assert_send<F>(_future: F)
+where
+    F: Future + Send,
+{
+}
+
+pub trait CallMe {
+    fn call(&self) -> impl Future<Output = ()> + Send;
+}
+
+struct Wrap<T>(T);
+
+impl<S> CallMe for Wrap<S>
+where
+    S: CallMe + Send,
+{
+    // adding `+ Send` to this RPIT fixes the issue
+    fn call(&self) -> impl Future<Output = ()> {
+        self.0.call()
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct CallMeImpl<T> {
+    value: T,
+}
+
+impl<T> CallMe for CallMeImpl<T>
+where
+    // Can replace `Send` by `ToString`, `Clone`, whatever. When removing the
+    // `Send` bound, the compiler produces a higher-ranked lifetime error.
+    T: Send + 'static,
+{
+    fn call(&self) -> impl Future<Output = ()> {
+        async {}
+    }
+}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-6.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-6.no_assumptions.stderr
new file mode 100644
index 00000000000..d1f2d9a0753
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-6.no_assumptions.stderr
@@ -0,0 +1,50 @@
+error[E0308]: mismatched types
+  --> $DIR/higher-ranked-auto-trait-6.rs:16:5
+   |
+LL |     Box::new(async { new(|| async { f().await }).await })
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
+   |
+   = note: expected `async` block `{async block@$DIR/higher-ranked-auto-trait-6.rs:16:29: 16:34}`
+              found `async` block `{async block@$DIR/higher-ranked-auto-trait-6.rs:16:29: 16:34}`
+   = note: no two async blocks, even if identical, have the same type
+   = help: consider pinning your async block and casting it to a trait object
+
+error[E0308]: mismatched types
+  --> $DIR/higher-ranked-auto-trait-6.rs:16:5
+   |
+LL |     Box::new(async { new(|| async { f().await }).await })
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
+   |
+   = note: expected `async` block `{async block@$DIR/higher-ranked-auto-trait-6.rs:16:29: 16:34}`
+              found `async` block `{async block@$DIR/higher-ranked-auto-trait-6.rs:16:29: 16:34}`
+   = note: no two async blocks, even if identical, have the same type
+   = help: consider pinning your async block and casting it to a trait object
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0308]: mismatched types
+  --> $DIR/higher-ranked-auto-trait-6.rs:16:5
+   |
+LL |     Box::new(async { new(|| async { f().await }).await })
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
+   |
+   = note: expected `async` block `{async block@$DIR/higher-ranked-auto-trait-6.rs:16:29: 16:34}`
+              found `async` block `{async block@$DIR/higher-ranked-auto-trait-6.rs:16:29: 16:34}`
+   = note: no two async blocks, even if identical, have the same type
+   = help: consider pinning your async block and casting it to a trait object
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0308]: mismatched types
+  --> $DIR/higher-ranked-auto-trait-6.rs:16:5
+   |
+LL |     Box::new(async { new(|| async { f().await }).await })
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
+   |
+   = note: expected `async` block `{async block@$DIR/higher-ranked-auto-trait-6.rs:16:29: 16:34}`
+              found `async` block `{async block@$DIR/higher-ranked-auto-trait-6.rs:16:29: 16:34}`
+   = note: no two async blocks, even if identical, have the same type
+   = help: consider pinning your async block and casting it to a trait object
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-6.rs b/tests/ui/async-await/higher-ranked-auto-trait-6.rs
new file mode 100644
index 00000000000..2c6adf8938d
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-6.rs
@@ -0,0 +1,59 @@
+// Repro for <https://github.com/rust-lang/rust/issues/82921#issue-825114180>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+use core::future::Future;
+use core::marker::PhantomData;
+use core::pin::Pin;
+use core::task::{Context, Poll};
+
+async fn f() {}
+
+pub fn fail<'a>() -> Box<dyn Future<Output = ()> + Send + 'a> {
+    Box::new(async { new(|| async { f().await }).await })
+}
+
+fn new<A, B>(_a: A) -> F<A, B>
+where
+    A: Fn() -> B,
+{
+    F { _i: PhantomData }
+}
+
+trait Stream {
+    type Item;
+}
+
+struct T<A, B> {
+    _a: PhantomData<A>,
+    _b: PhantomData<B>,
+}
+
+impl<A, B> Stream for T<A, B>
+where
+    A: Fn() -> B,
+{
+    type Item = B;
+}
+
+struct F<A, B>
+where
+    A: Fn() -> B,
+{
+    _i: PhantomData<<T<A, B> as Stream>::Item>,
+}
+
+impl<A, B> Future for F<A, B>
+where
+    A: Fn() -> B,
+{
+    type Output = ();
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
+        unimplemented!()
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-7.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-7.no_assumptions.stderr
new file mode 100644
index 00000000000..dcb8075566e
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-7.no_assumptions.stderr
@@ -0,0 +1,8 @@
+error: `S` does not live long enough
+  --> $DIR/higher-ranked-auto-trait-7.rs:26:5
+   |
+LL |     future::<'a, S, _>(async move {
+   |     ^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-7.rs b/tests/ui/async-await/higher-ranked-auto-trait-7.rs
new file mode 100644
index 00000000000..abded5a88d3
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-7.rs
@@ -0,0 +1,33 @@
+// Repro for <https://github.com/rust-lang/rust/issues/90696#issuecomment-963375847>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+#![allow(dropping_copy_types)]
+
+use std::{future::Future, marker::PhantomData};
+
+trait Trait {
+    type Associated<'a>: Send
+    where
+        Self: 'a;
+}
+
+fn future<'a, S: Trait + 'a, F>(f: F) -> F
+where
+    F: Future<Output = ()> + Send,
+{
+    f
+}
+
+fn foo<'a, S: Trait + 'a>() {
+    future::<'a, S, _>(async move {
+        let result: PhantomData<S::Associated<'a>> = PhantomData;
+        async {}.await;
+        drop(result);
+    });
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-8.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-8.no_assumptions.stderr
new file mode 100644
index 00000000000..6208675117b
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-8.no_assumptions.stderr
@@ -0,0 +1,10 @@
+error: higher-ranked lifetime error
+  --> $DIR/higher-ranked-auto-trait-8.rs:26:5
+   |
+LL |     needs_send(use_my_struct(second_struct)); // ERROR
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: could not prove `impl Future<Output = ()>: Send`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-8.rs b/tests/ui/async-await/higher-ranked-auto-trait-8.rs
new file mode 100644
index 00000000000..91cef204e44
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-8.rs
@@ -0,0 +1,27 @@
+// Repro for <https://github.com/rust-lang/rust/issues/64552#issuecomment-532801232>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+fn needs_send<T: Send>(_val: T) {}
+async fn use_async<T>(_val: T) {}
+
+struct MyStruct<'a, T: 'a> {
+    val: &'a T,
+}
+
+unsafe impl<'a, T: 'a> Send for MyStruct<'a, T> {}
+
+async fn use_my_struct(val: MyStruct<'static, &'static u8>) {
+    use_async(val).await;
+}
+
+fn main() {
+    let first_struct: MyStruct<'static, &'static u8> = MyStruct { val: &&26 };
+    let second_struct: MyStruct<'static, &'static u8> = MyStruct { val: &&27 };
+
+    needs_send(first_struct);
+    needs_send(use_my_struct(second_struct)); // ERROR
+}
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-9.no_assumptions.stderr b/tests/ui/async-await/higher-ranked-auto-trait-9.no_assumptions.stderr
new file mode 100644
index 00000000000..809cbcf0cad
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-9.no_assumptions.stderr
@@ -0,0 +1,11 @@
+error: implementation of `Debug` is not general enough
+  --> $DIR/higher-ranked-auto-trait-9.rs:43:50
+   |
+LL |     let fut: &(dyn Future<Output = ()> + Send) = &fut as _;
+   |                                                  ^^^^^^^^^ implementation of `Debug` is not general enough
+   |
+   = note: `(dyn Any + '0)` must implement `Debug`, for any lifetime `'0`...
+   = note: ...but `Debug` is actually implemented for the type `(dyn Any + 'static)`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/async-await/higher-ranked-auto-trait-9.rs b/tests/ui/async-await/higher-ranked-auto-trait-9.rs
new file mode 100644
index 00000000000..66edbf23f2b
--- /dev/null
+++ b/tests/ui/async-await/higher-ranked-auto-trait-9.rs
@@ -0,0 +1,44 @@
+// Repro for <https://github.com/rust-lang/rust/issues/87425#issue-952059416>.
+//@ edition: 2021
+//@ revisions: assumptions no_assumptions
+//@[assumptions] compile-flags: -Zhigher-ranked-assumptions
+//@[assumptions] check-pass
+//@[no_assumptions] known-bug: #110338
+
+use std::any::Any;
+use std::fmt;
+use std::future::Future;
+
+pub trait Foo {
+    type Item;
+}
+
+impl<F, I> Foo for F
+where
+    Self: FnOnce() -> I,
+    I: fmt::Debug,
+{
+    type Item = I;
+}
+
+async fn foo_item<F: Foo>(_: F) -> F::Item {
+    unimplemented!()
+}
+
+fn main() {
+    let fut = async {
+        let callback = || -> Box<dyn Any> { unimplemented!() };
+
+        // Using plain fn instead of a closure fixes the error,
+        // though you obviously can't capture any state...
+        // fn callback() -> Box<dyn Any> {
+        //     todo!()
+        // }
+
+        foo_item(callback).await;
+    };
+
+    // Removing `+ Send` bound also fixes the error,
+    // though at the cost of loosing `Send`ability...
+    let fut: &(dyn Future<Output = ()> + Send) = &fut as _;
+}
-- 
cgit 1.4.1-3-g733a5


From 3634f46fdb50887dd0f6877cab1d7f9cf45458af Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 15 Jul 2025 16:01:43 +0000
Subject: Add alias for ArgOutlivesPredicate

---
 .../rustc_borrowck/src/type_check/constraint_conversion.rs    |  6 +++---
 compiler/rustc_hir_analysis/src/outlives/utils.rs             |  3 +--
 compiler/rustc_infer/src/infer/canonical/query_response.rs    |  2 +-
 compiler/rustc_infer/src/infer/mod.rs                         |  4 ++--
 compiler/rustc_infer/src/infer/outlives/env.rs                |  8 +++-----
 compiler/rustc_infer/src/infer/outlives/obligations.rs        | 11 +++--------
 compiler/rustc_middle/src/infer/canonical.rs                  |  5 ++---
 compiler/rustc_middle/src/ty/context.rs                       | 10 +++++-----
 compiler/rustc_middle/src/ty/mod.rs                           |  2 +-
 compiler/rustc_middle/src/ty/predicate.rs                     |  1 +
 compiler/rustc_middle/src/ty/structural_impls.rs              |  2 +-
 compiler/rustc_trait_selection/src/solve/delegate.rs          |  4 +---
 compiler/rustc_trait_selection/src/traits/select/mod.rs       |  2 +-
 compiler/rustc_traits/src/coroutine_witnesses.rs              |  2 +-
 14 files changed, 26 insertions(+), 36 deletions(-)

diff --git a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
index 989d2cc70dd..9bb96b94506 100644
--- a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
+++ b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
@@ -126,9 +126,9 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
 
     fn convert(
         &mut self,
-        predicate: ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>,
+        predicate: ty::ArgOutlivesPredicate<'tcx>,
         constraint_category: ConstraintCategory<'tcx>,
-        higher_ranked_assumptions: &FxHashSet<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+        higher_ranked_assumptions: &FxHashSet<ty::ArgOutlivesPredicate<'tcx>>,
     ) {
         let tcx = self.infcx.tcx;
         debug!("generate: constraints at: {:#?}", self.locations);
@@ -282,7 +282,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
         &self,
         ty: Ty<'tcx>,
         next_outlives_predicates: &mut Vec<(
-            ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>,
+            ty::ArgOutlivesPredicate<'tcx>,
             ConstraintCategory<'tcx>,
         )>,
     ) -> Ty<'tcx> {
diff --git a/compiler/rustc_hir_analysis/src/outlives/utils.rs b/compiler/rustc_hir_analysis/src/outlives/utils.rs
index 301f5de9424..99a633e2b7d 100644
--- a/compiler/rustc_hir_analysis/src/outlives/utils.rs
+++ b/compiler/rustc_hir_analysis/src/outlives/utils.rs
@@ -7,8 +7,7 @@ use smallvec::smallvec;
 
 /// Tracks the `T: 'a` or `'a: 'a` predicates that we have inferred
 /// must be added to the struct header.
-pub(crate) type RequiredPredicates<'tcx> =
-    FxIndexMap<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>, Span>;
+pub(crate) type RequiredPredicates<'tcx> = FxIndexMap<ty::ArgOutlivesPredicate<'tcx>, Span>;
 
 /// Given a requirement `T: 'a` or `'b: 'a`, deduce the
 /// outlives_component and add it to `required_predicates`
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index fed56976128..6be53c948c8 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -590,7 +590,7 @@ pub fn make_query_region_constraints<'tcx>(
     tcx: TyCtxt<'tcx>,
     outlives_obligations: Vec<TypeOutlivesConstraint<'tcx>>,
     region_constraints: &RegionConstraintData<'tcx>,
-    assumptions: Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+    assumptions: Vec<ty::ArgOutlivesPredicate<'tcx>>,
 ) -> QueryRegionConstraints<'tcx> {
     let RegionConstraintData { constraints, verifys } = region_constraints;
 
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index 458b21da6ce..2d269e320b6 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -154,7 +154,7 @@ pub struct InferCtxtInner<'tcx> {
     /// are deduced from the well-formedness of the witness's types, and are
     /// necessary because of the way we anonymize the regions in a coroutine,
     /// which may cause types to no longer be considered well-formed.
-    region_assumptions: Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+    region_assumptions: Vec<ty::ArgOutlivesPredicate<'tcx>>,
 
     /// Caches for opaque type inference.
     opaque_type_storage: OpaqueTypeStorage<'tcx>,
@@ -183,7 +183,7 @@ impl<'tcx> InferCtxtInner<'tcx> {
     }
 
     #[inline]
-    pub fn region_assumptions(&self) -> &[ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>] {
+    pub fn region_assumptions(&self) -> &[ty::ArgOutlivesPredicate<'tcx>] {
         &self.region_assumptions
     }
 
diff --git a/compiler/rustc_infer/src/infer/outlives/env.rs b/compiler/rustc_infer/src/infer/outlives/env.rs
index 2175ff1b4ae..47b738a4079 100644
--- a/compiler/rustc_infer/src/infer/outlives/env.rs
+++ b/compiler/rustc_infer/src/infer/outlives/env.rs
@@ -41,7 +41,7 @@ pub struct OutlivesEnvironment<'tcx> {
     known_type_outlives: Vec<ty::PolyTypeOutlivesPredicate<'tcx>>,
     /// Assumptions that come from the well-formedness of coroutines that we prove
     /// auto trait bounds for during the type checking of this body.
-    higher_ranked_assumptions: FxHashSet<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+    higher_ranked_assumptions: FxHashSet<ty::ArgOutlivesPredicate<'tcx>>,
 }
 
 /// "Region-bound pairs" tracks outlives relations that are known to
@@ -55,7 +55,7 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
         param_env: ty::ParamEnv<'tcx>,
         known_type_outlives: Vec<ty::PolyTypeOutlivesPredicate<'tcx>>,
         extra_bounds: impl IntoIterator<Item = OutlivesBound<'tcx>>,
-        higher_ranked_assumptions: FxHashSet<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+        higher_ranked_assumptions: FxHashSet<ty::ArgOutlivesPredicate<'tcx>>,
     ) -> Self {
         let mut region_relation = TransitiveRelationBuilder::default();
         let mut region_bound_pairs = RegionBoundPairs::default();
@@ -108,9 +108,7 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
         &self.known_type_outlives
     }
 
-    pub fn higher_ranked_assumptions(
-        &self,
-    ) -> &FxHashSet<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>> {
+    pub fn higher_ranked_assumptions(&self) -> &FxHashSet<ty::ArgOutlivesPredicate<'tcx>> {
         &self.higher_ranked_assumptions
     }
 }
diff --git a/compiler/rustc_infer/src/infer/outlives/obligations.rs b/compiler/rustc_infer/src/infer/outlives/obligations.rs
index 1ca59c8d130..a8520c0e71d 100644
--- a/compiler/rustc_infer/src/infer/outlives/obligations.rs
+++ b/compiler/rustc_infer/src/infer/outlives/obligations.rs
@@ -84,7 +84,7 @@ use crate::traits::{ObligationCause, ObligationCauseCode};
 impl<'tcx> InferCtxt<'tcx> {
     pub fn register_outlives_constraint(
         &self,
-        ty::OutlivesPredicate(arg, r2): ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>,
+        ty::OutlivesPredicate(arg, r2): ty::ArgOutlivesPredicate<'tcx>,
         cause: &ObligationCause<'tcx>,
     ) {
         match arg.kind() {
@@ -170,18 +170,13 @@ impl<'tcx> InferCtxt<'tcx> {
         std::mem::take(&mut self.inner.borrow_mut().region_obligations)
     }
 
-    pub fn register_region_assumption(
-        &self,
-        assumption: ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>,
-    ) {
+    pub fn register_region_assumption(&self, assumption: ty::ArgOutlivesPredicate<'tcx>) {
         let mut inner = self.inner.borrow_mut();
         inner.undo_log.push(UndoLog::PushRegionAssumption);
         inner.region_assumptions.push(assumption);
     }
 
-    pub fn take_registered_region_assumptions(
-        &self,
-    ) -> Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>> {
+    pub fn take_registered_region_assumptions(&self) -> Vec<ty::ArgOutlivesPredicate<'tcx>> {
         std::mem::take(&mut self.inner.borrow_mut().region_assumptions)
     }
 
diff --git a/compiler/rustc_middle/src/infer/canonical.rs b/compiler/rustc_middle/src/infer/canonical.rs
index 8ce2789cb8e..4fe4c2dadee 100644
--- a/compiler/rustc_middle/src/infer/canonical.rs
+++ b/compiler/rustc_middle/src/infer/canonical.rs
@@ -81,7 +81,7 @@ pub struct QueryResponse<'tcx, R> {
 #[derive(HashStable, TypeFoldable, TypeVisitable)]
 pub struct QueryRegionConstraints<'tcx> {
     pub outlives: Vec<QueryOutlivesConstraint<'tcx>>,
-    pub assumptions: Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+    pub assumptions: Vec<ty::ArgOutlivesPredicate<'tcx>>,
 }
 
 impl QueryRegionConstraints<'_> {
@@ -135,8 +135,7 @@ impl<'tcx, R> QueryResponse<'tcx, R> {
     }
 }
 
-pub type QueryOutlivesConstraint<'tcx> =
-    (ty::OutlivesPredicate<'tcx, GenericArg<'tcx>>, ConstraintCategory<'tcx>);
+pub type QueryOutlivesConstraint<'tcx> = (ty::ArgOutlivesPredicate<'tcx>, ConstraintCategory<'tcx>);
 
 #[derive(Default)]
 pub struct CanonicalParamEnvCache<'tcx> {
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 5a1d8d215d2..5570ba1d912 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -162,7 +162,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     type BoundRegion = ty::BoundRegion;
     type PlaceholderRegion = ty::PlaceholderRegion;
 
-    type RegionAssumptions = &'tcx ty::List<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>;
+    type RegionAssumptions = &'tcx ty::List<ty::ArgOutlivesPredicate<'tcx>>;
 
     type ParamEnv = ty::ParamEnv<'tcx>;
     type Predicate = Predicate<'tcx>;
@@ -876,7 +876,7 @@ pub struct CtxtInterners<'tcx> {
     offset_of: InternedSet<'tcx, List<(VariantIdx, FieldIdx)>>,
     valtree: InternedSet<'tcx, ty::ValTreeKind<'tcx>>,
     patterns: InternedSet<'tcx, List<ty::Pattern<'tcx>>>,
-    outlives: InternedSet<'tcx, List<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>>,
+    outlives: InternedSet<'tcx, List<ty::ArgOutlivesPredicate<'tcx>>>,
 }
 
 impl<'tcx> CtxtInterners<'tcx> {
@@ -2696,7 +2696,7 @@ slice_interners!(
     captures: intern_captures(&'tcx ty::CapturedPlace<'tcx>),
     offset_of: pub mk_offset_of((VariantIdx, FieldIdx)),
     patterns: pub mk_patterns(Pattern<'tcx>),
-    outlives: pub mk_outlives(ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>),
+    outlives: pub mk_outlives(ty::ArgOutlivesPredicate<'tcx>),
 );
 
 impl<'tcx> TyCtxt<'tcx> {
@@ -3116,8 +3116,8 @@ impl<'tcx> TyCtxt<'tcx> {
     where
         I: Iterator<Item = T>,
         T: CollectAndApply<
-                ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>,
-                &'tcx ty::List<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+                ty::ArgOutlivesPredicate<'tcx>,
+                &'tcx ty::List<ty::ArgOutlivesPredicate<'tcx>>,
             >,
     {
         T::collect_and_apply(iter, |xs| self.mk_outlives(xs))
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 6e8f1e8fdd5..a7cde2ad485 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -88,7 +88,7 @@ pub use self::opaque_types::OpaqueTypeKey;
 pub use self::parameterized::ParameterizedOverTcx;
 pub use self::pattern::{Pattern, PatternKind};
 pub use self::predicate::{
-    AliasTerm, Clause, ClauseKind, CoercePredicate, ExistentialPredicate,
+    AliasTerm, ArgOutlivesPredicate, Clause, ClauseKind, CoercePredicate, ExistentialPredicate,
     ExistentialPredicateStableCmpExt, ExistentialProjection, ExistentialTraitRef,
     HostEffectPredicate, NormalizesTo, OutlivesPredicate, PolyCoercePredicate,
     PolyExistentialPredicate, PolyExistentialProjection, PolyExistentialTraitRef,
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
index bc2ac42b6b1..26f4282249e 100644
--- a/compiler/rustc_middle/src/ty/predicate.rs
+++ b/compiler/rustc_middle/src/ty/predicate.rs
@@ -26,6 +26,7 @@ pub type SubtypePredicate<'tcx> = ir::SubtypePredicate<TyCtxt<'tcx>>;
 pub type OutlivesPredicate<'tcx, T> = ir::OutlivesPredicate<TyCtxt<'tcx>, T>;
 pub type RegionOutlivesPredicate<'tcx> = OutlivesPredicate<'tcx, ty::Region<'tcx>>;
 pub type TypeOutlivesPredicate<'tcx> = OutlivesPredicate<'tcx, Ty<'tcx>>;
+pub type ArgOutlivesPredicate<'tcx> = OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>;
 pub type PolyTraitPredicate<'tcx> = ty::Binder<'tcx, TraitPredicate<'tcx>>;
 pub type PolyRegionOutlivesPredicate<'tcx> = ty::Binder<'tcx, RegionOutlivesPredicate<'tcx>>;
 pub type PolyTypeOutlivesPredicate<'tcx> = ty::Binder<'tcx, TypeOutlivesPredicate<'tcx>>;
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 55aec0efd0f..ab31d943408 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -802,5 +802,5 @@ list_fold! {
     &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> : mk_poly_existential_predicates,
     &'tcx ty::List<PlaceElem<'tcx>> : mk_place_elems,
     &'tcx ty::List<ty::Pattern<'tcx>> : mk_patterns,
-    &'tcx ty::List<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>> : mk_outlives,
+    &'tcx ty::List<ty::ArgOutlivesPredicate<'tcx>> : mk_outlives,
 }
diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
index 670589faf9c..17429e15cce 100644
--- a/compiler/rustc_trait_selection/src/solve/delegate.rs
+++ b/compiler/rustc_trait_selection/src/solve/delegate.rs
@@ -206,9 +206,7 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
         .map(|obligations| obligations.into_iter().map(|obligation| obligation.as_goal()).collect())
     }
 
-    fn make_deduplicated_outlives_constraints(
-        &self,
-    ) -> Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>> {
+    fn make_deduplicated_outlives_constraints(&self) -> Vec<ty::ArgOutlivesPredicate<'tcx>> {
         // Cannot use `take_registered_region_obligations` as we may compute the response
         // inside of a `probe` whenever we have multiple choices inside of the solver.
         let region_obligations = self.0.inner.borrow().region_obligations().to_owned();
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index b46fa9a44d3..e05782e41fb 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -3148,5 +3148,5 @@ pub(crate) enum ProjectionMatchesProjection {
 #[derive(Clone, Debug, TypeFoldable, TypeVisitable)]
 pub(crate) struct AutoImplConstituents<'tcx> {
     pub types: Vec<Ty<'tcx>>,
-    pub assumptions: Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+    pub assumptions: Vec<ty::ArgOutlivesPredicate<'tcx>>,
 }
diff --git a/compiler/rustc_traits/src/coroutine_witnesses.rs b/compiler/rustc_traits/src/coroutine_witnesses.rs
index 9e487e380a9..87d17f3e131 100644
--- a/compiler/rustc_traits/src/coroutine_witnesses.rs
+++ b/compiler/rustc_traits/src/coroutine_witnesses.rs
@@ -47,7 +47,7 @@ fn compute_assumptions<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: DefId,
     bound_tys: &'tcx ty::List<Ty<'tcx>>,
-) -> &'tcx ty::List<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>> {
+) -> &'tcx ty::List<ty::ArgOutlivesPredicate<'tcx>> {
     let infcx = tcx.infer_ctxt().build(ty::TypingMode::Analysis {
         defining_opaque_types_and_generators: ty::List::empty(),
     });
-- 
cgit 1.4.1-3-g733a5


From e7f5bbe7438019ac6af84ce4f8cc04ab2df8c744 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 14 Jul 2025 17:16:47 +0530
Subject: remove description from rust toml struct

---
 src/bootstrap/src/core/config/config.rs    |  4 ++--
 src/bootstrap/src/core/config/toml/rust.rs | 20 +-------------------
 2 files changed, 3 insertions(+), 21 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 28958b60fc3..f0bba8a191e 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -697,7 +697,7 @@ impl Config {
         config.change_id = toml.change_id.inner;
 
         let Build {
-            mut description,
+            description,
             build,
             host,
             target,
@@ -942,7 +942,7 @@ impl Config {
         config.rust_profile_use = flags_rust_profile_use;
         config.rust_profile_generate = flags_rust_profile_generate;
 
-        config.apply_rust_config(toml.rust, flags_warnings, &mut description);
+        config.apply_rust_config(toml.rust, flags_warnings);
 
         config.reproducible_artifacts = flags_reproducible_artifact;
         config.description = description;
diff --git a/src/bootstrap/src/core/config/toml/rust.rs b/src/bootstrap/src/core/config/toml/rust.rs
index 0fae235bb93..307aa52294b 100644
--- a/src/bootstrap/src/core/config/toml/rust.rs
+++ b/src/bootstrap/src/core/config/toml/rust.rs
@@ -36,8 +36,6 @@ define_config! {
         incremental: Option<bool> = "incremental",
         default_linker: Option<String> = "default-linker",
         channel: Option<String> = "channel",
-        // FIXME: Remove this field at Q2 2025, it has been replaced by build.description
-        description: Option<String> = "description",
         musl_root: Option<String> = "musl-root",
         rpath: Option<bool> = "rpath",
         strip: Option<bool> = "strip",
@@ -320,7 +318,6 @@ pub fn check_incompatible_options_for_ci_rustc(
         jemalloc,
         rpath,
         channel,
-        description,
         default_linker,
         std_features,
 
@@ -388,7 +385,6 @@ pub fn check_incompatible_options_for_ci_rustc(
     err!(current_rust_config.std_features, std_features, "rust");
 
     warn!(current_rust_config.channel, channel, "rust");
-    warn!(current_rust_config.description, description, "rust");
 
     Ok(())
 }
@@ -415,12 +411,7 @@ pub(crate) fn validate_codegen_backends(backends: Vec<String>, section: &str) ->
 }
 
 impl Config {
-    pub fn apply_rust_config(
-        &mut self,
-        toml_rust: Option<Rust>,
-        warnings: Warnings,
-        description: &mut Option<String>,
-    ) {
+    pub fn apply_rust_config(&mut self, toml_rust: Option<Rust>, warnings: Warnings) {
         let mut debug = None;
         let mut rustc_debug_assertions = None;
         let mut std_debug_assertions = None;
@@ -459,7 +450,6 @@ impl Config {
                 randomize_layout,
                 default_linker,
                 channel: _, // already handled above
-                description: rust_description,
                 musl_root,
                 rpath,
                 verbose_tests,
@@ -552,14 +542,6 @@ impl Config {
             set(&mut self.jemalloc, jemalloc);
             set(&mut self.test_compare_mode, test_compare_mode);
             set(&mut self.backtrace, backtrace);
-            if rust_description.is_some() {
-                eprintln!(
-                    "Warning: rust.description is deprecated. Use build.description instead."
-                );
-            }
-            if description.is_none() {
-                *description = rust_description;
-            }
             set(&mut self.rust_dist_src, dist_src);
             set(&mut self.verbose_tests, verbose_tests);
             // in the case "false" is set explicitly, do not overwrite the command line args
-- 
cgit 1.4.1-3-g733a5


From 76967afd3bd491be8ac99f972bd79a7028852344 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 14 Jul 2025 17:20:10 +0530
Subject: remove ccache from llvm

---
 src/bootstrap/src/core/config/config.rs    |  4 ++--
 src/bootstrap/src/core/config/toml/llvm.rs | 16 +---------------
 2 files changed, 3 insertions(+), 17 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index f0bba8a191e..22a75183404 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -749,7 +749,7 @@ impl Config {
             compiletest_diff_tool,
             compiletest_use_stage0_libtest,
             tidy_extra_checks,
-            mut ccache,
+            ccache,
             exclude,
         } = toml.build.unwrap_or_default();
 
@@ -963,7 +963,7 @@ impl Config {
             config.channel = channel;
         }
 
-        config.apply_llvm_config(toml.llvm, &mut ccache);
+        config.apply_llvm_config(toml.llvm);
 
         config.apply_gcc_config(toml.gcc);
 
diff --git a/src/bootstrap/src/core/config/toml/llvm.rs b/src/bootstrap/src/core/config/toml/llvm.rs
index 4774e202bd8..1f0cecd145c 100644
--- a/src/bootstrap/src/core/config/toml/llvm.rs
+++ b/src/bootstrap/src/core/config/toml/llvm.rs
@@ -17,8 +17,6 @@ define_config! {
         tests: Option<bool> = "tests",
         enzyme: Option<bool> = "enzyme",
         plugins: Option<bool> = "plugins",
-        // FIXME: Remove this field at Q2 2025, it has been replaced by build.ccache
-        ccache: Option<StringOrBool> = "ccache",
         static_libstdcpp: Option<bool> = "static-libstdcpp",
         libzstd: Option<bool> = "libzstd",
         ninja: Option<bool> = "ninja",
@@ -97,7 +95,6 @@ pub fn check_incompatible_options_for_ci_llvm(
         assertions: _,
         tests: _,
         plugins,
-        ccache: _,
         static_libstdcpp: _,
         libzstd,
         ninja: _,
@@ -149,11 +146,7 @@ pub fn check_incompatible_options_for_ci_llvm(
 }
 
 impl Config {
-    pub fn apply_llvm_config(
-        &mut self,
-        toml_llvm: Option<Llvm>,
-        ccache: &mut Option<StringOrBool>,
-    ) {
+    pub fn apply_llvm_config(&mut self, toml_llvm: Option<Llvm>) {
         let mut llvm_tests = None;
         let mut llvm_enzyme = None;
         let mut llvm_offload = None;
@@ -168,7 +161,6 @@ impl Config {
                 tests,
                 enzyme,
                 plugins,
-                ccache: llvm_ccache,
                 static_libstdcpp,
                 libzstd,
                 ninja,
@@ -191,13 +183,7 @@ impl Config {
                 download_ci_llvm,
                 build_config,
             } = llvm;
-            if llvm_ccache.is_some() {
-                eprintln!("Warning: llvm.ccache is deprecated. Use build.ccache instead.");
-            }
 
-            if ccache.is_none() {
-                *ccache = llvm_ccache;
-            }
             set(&mut self.ninja_in_file, ninja);
             llvm_tests = tests;
             llvm_enzyme = enzyme;
-- 
cgit 1.4.1-3-g733a5


From 3f2dc2bd1a2e0120b868911497ddbd8e43f3a9fa Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Tue, 8 Jul 2025 00:20:57 +0800
Subject: add `const_make_global`; err for `const_allocate` ptrs if didn't call

Co-Authored-By: Ralf Jung <post@ralfj.de>
Co-Authored-By: Oli Scherer <github333195615777966@oli-obk.de>
---
 compiler/rustc_const_eval/messages.ftl             | 11 ++++
 compiler/rustc_const_eval/src/const_eval/error.rs  | 32 +++++++++++-
 .../src/const_eval/eval_queries.rs                 |  2 +-
 .../rustc_const_eval/src/const_eval/machine.rs     | 19 +++++--
 compiler/rustc_const_eval/src/errors.rs            |  8 +++
 compiler/rustc_const_eval/src/interpret/intern.rs  | 58 +++++++++++++++++++---
 compiler/rustc_const_eval/src/interpret/memory.rs  | 44 ++++++++++++++++
 .../src/util/check_validity_requirement.rs         | 10 ++--
 compiler/rustc_hir_analysis/src/check/intrinsic.rs |  3 ++
 compiler/rustc_middle/src/mir/interpret/error.rs   |  2 +-
 compiler/rustc_span/src/symbol.rs                  |  1 +
 library/alloc/src/boxed/thin.rs                    |  7 +--
 library/core/src/intrinsics/mod.rs                 |  9 ++++
 .../heap/alloc_intrinsic_nontransient.rs           |  4 +-
 .../heap/alloc_intrinsic_uninit.32bit.stderr       |  2 +-
 .../heap/alloc_intrinsic_uninit.64bit.stderr       |  2 +-
 .../const-eval/heap/alloc_intrinsic_uninit.rs      |  5 +-
 .../const-eval/heap/alloc_intrinsic_untyped.rs     |  1 +
 .../const-eval/heap/alloc_intrinsic_untyped.stderr | 10 +++-
 .../ui/consts/const-eval/heap/dealloc_intrinsic.rs |  2 +-
 .../consts/const-eval/heap/make-global-dangling.rs | 16 ++++++
 .../const-eval/heap/make-global-dangling.stderr    | 15 ++++++
 .../ui/consts/const-eval/heap/make-global-other.rs | 13 +++++
 .../const-eval/heap/make-global-other.stderr       |  9 ++++
 .../ui/consts/const-eval/heap/make-global-twice.rs | 16 ++++++
 .../const-eval/heap/make-global-twice.stderr       |  9 ++++
 tests/ui/consts/const-eval/heap/make-global.rs     | 21 ++++++++
 .../const-eval/heap/ptr_made_global_mutated.rs     | 14 ++++++
 .../const-eval/heap/ptr_made_global_mutated.stderr |  9 ++++
 .../consts/const-eval/heap/ptr_not_made_global.rs  | 19 +++++++
 .../const-eval/heap/ptr_not_made_global.stderr     | 18 +++++++
 31 files changed, 361 insertions(+), 30 deletions(-)
 create mode 100644 tests/ui/consts/const-eval/heap/make-global-dangling.rs
 create mode 100644 tests/ui/consts/const-eval/heap/make-global-dangling.stderr
 create mode 100644 tests/ui/consts/const-eval/heap/make-global-other.rs
 create mode 100644 tests/ui/consts/const-eval/heap/make-global-other.stderr
 create mode 100644 tests/ui/consts/const-eval/heap/make-global-twice.rs
 create mode 100644 tests/ui/consts/const-eval/heap/make-global-twice.stderr
 create mode 100644 tests/ui/consts/const-eval/heap/make-global.rs
 create mode 100644 tests/ui/consts/const-eval/heap/ptr_made_global_mutated.rs
 create mode 100644 tests/ui/consts/const-eval/heap/ptr_made_global_mutated.stderr
 create mode 100644 tests/ui/consts/const-eval/heap/ptr_not_made_global.rs
 create mode 100644 tests/ui/consts/const-eval/heap/ptr_not_made_global.stderr

diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index b767ca9a3c2..04637884011 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -56,6 +56,17 @@ const_eval_const_context = {$kind ->
     *[other] {""}
 }
 
+const_eval_const_heap_ptr_in_final = encountered `const_allocate` pointer in final value that was not made global
+    .note = use `const_make_global` to make allocated pointers immutable before returning
+
+const_eval_const_make_global_ptr_already_made_global = attempting to call `const_make_global` twice on the same allocation {$alloc}
+
+const_eval_const_make_global_ptr_is_non_heap = pointer passed to `const_make_global` does not point to a heap allocation: {$ptr}
+
+const_eval_const_make_global_with_dangling_ptr = pointer passed to `const_make_global` is dangling: {$ptr}
+
+const_eval_const_make_global_with_offset = making {$ptr} global which does not point to the beginning of an object
+
 const_eval_copy_nonoverlapping_overlapping =
     `copy_nonoverlapping` called on overlapping ranges
 
diff --git a/compiler/rustc_const_eval/src/const_eval/error.rs b/compiler/rustc_const_eval/src/const_eval/error.rs
index 08fc03d9c46..5b07b7c13c1 100644
--- a/compiler/rustc_const_eval/src/const_eval/error.rs
+++ b/compiler/rustc_const_eval/src/const_eval/error.rs
@@ -2,7 +2,7 @@ use std::mem;
 
 use rustc_errors::{Diag, DiagArgName, DiagArgValue, DiagMessage, IntoDiagArg};
 use rustc_middle::mir::AssertKind;
-use rustc_middle::mir::interpret::{Provenance, ReportedErrorInfo};
+use rustc_middle::mir::interpret::{AllocId, Provenance, ReportedErrorInfo};
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::layout::LayoutError;
 use rustc_middle::ty::{ConstInt, TyCtxt};
@@ -22,8 +22,22 @@ pub enum ConstEvalErrKind {
     ModifiedGlobal,
     RecursiveStatic,
     AssertFailure(AssertKind<ConstInt>),
-    Panic { msg: Symbol, line: u32, col: u32, file: Symbol },
+    Panic {
+        msg: Symbol,
+        line: u32,
+        col: u32,
+        file: Symbol,
+    },
     WriteThroughImmutablePointer,
+    /// Called `const_make_global` twice.
+    ConstMakeGlobalPtrAlreadyMadeGlobal(AllocId),
+    /// Called `const_make_global` on a non-heap pointer.
+    ConstMakeGlobalPtrIsNonHeap(String),
+    /// Called `const_make_global` on a dangling pointer.
+    ConstMakeGlobalWithDanglingPtr(String),
+    /// Called `const_make_global` on a pointer that does not start at the
+    /// beginning of an object.
+    ConstMakeGlobalWithOffset(String),
 }
 
 impl MachineStopType for ConstEvalErrKind {
@@ -38,6 +52,12 @@ impl MachineStopType for ConstEvalErrKind {
             RecursiveStatic => const_eval_recursive_static,
             AssertFailure(x) => x.diagnostic_message(),
             WriteThroughImmutablePointer => const_eval_write_through_immutable_pointer,
+            ConstMakeGlobalPtrAlreadyMadeGlobal { .. } => {
+                const_eval_const_make_global_ptr_already_made_global
+            }
+            ConstMakeGlobalPtrIsNonHeap(_) => const_eval_const_make_global_ptr_is_non_heap,
+            ConstMakeGlobalWithDanglingPtr(_) => const_eval_const_make_global_with_dangling_ptr,
+            ConstMakeGlobalWithOffset(_) => const_eval_const_make_global_with_offset,
         }
     }
     fn add_args(self: Box<Self>, adder: &mut dyn FnMut(DiagArgName, DiagArgValue)) {
@@ -51,6 +71,14 @@ impl MachineStopType for ConstEvalErrKind {
             Panic { msg, .. } => {
                 adder("msg".into(), msg.into_diag_arg(&mut None));
             }
+            ConstMakeGlobalPtrIsNonHeap(ptr)
+            | ConstMakeGlobalWithOffset(ptr)
+            | ConstMakeGlobalWithDanglingPtr(ptr) => {
+                adder("ptr".into(), ptr.into_diag_arg(&mut None));
+            }
+            ConstMakeGlobalPtrAlreadyMadeGlobal(alloc) => {
+                adder("alloc".into(), alloc.into_diag_arg(&mut None));
+            }
         }
     }
 }
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 4bd4b493009..32209ff4367 100644
--- a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -93,7 +93,7 @@ fn eval_body_using_ecx<'tcx, R: InterpretationResult<'tcx>>(
     // Since evaluation had no errors, validate the resulting constant.
     const_validate_mplace(ecx, &ret, cid)?;
 
-    // Only report this after validation, as validaiton produces much better diagnostics.
+    // Only report this after validation, as validation produces much better diagnostics.
     // FIXME: ensure validation always reports this and stop making interning care about it.
 
     match intern_result {
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index 52fc898192a..4e952b043fb 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -169,13 +169,15 @@ pub type CompileTimeInterpCx<'tcx> = InterpCx<'tcx, CompileTimeMachine<'tcx>>;
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum MemoryKind {
-    Heap,
+    Heap { was_made_global: bool },
 }
 
 impl fmt::Display for MemoryKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            MemoryKind::Heap => write!(f, "heap allocation"),
+            MemoryKind::Heap { was_made_global } => {
+                write!(f, "heap allocation{}", if *was_made_global { " (made global)" } else { "" })
+            }
         }
     }
 }
@@ -184,7 +186,7 @@ impl interpret::MayLeak for MemoryKind {
     #[inline(always)]
     fn may_leak(self) -> bool {
         match self {
-            MemoryKind::Heap => false,
+            MemoryKind::Heap { was_made_global } => was_made_global,
         }
     }
 }
@@ -420,7 +422,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 let ptr = ecx.allocate_ptr(
                     Size::from_bytes(size),
                     align,
-                    interpret::MemoryKind::Machine(MemoryKind::Heap),
+                    interpret::MemoryKind::Machine(MemoryKind::Heap { was_made_global: false }),
                     AllocInit::Uninit,
                 )?;
                 ecx.write_pointer(ptr, dest)?;
@@ -453,10 +455,17 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                     ecx.deallocate_ptr(
                         ptr,
                         Some((size, align)),
-                        interpret::MemoryKind::Machine(MemoryKind::Heap),
+                        interpret::MemoryKind::Machine(MemoryKind::Heap { was_made_global: false }),
                     )?;
                 }
             }
+
+            sym::const_make_global => {
+                let ptr = ecx.read_pointer(&args[0])?;
+                ecx.make_const_heap_ptr_global(ptr)?;
+                ecx.write_pointer(ptr, dest)?;
+            }
+
             // The intrinsic represents whether the value is known to the optimizer (LLVM).
             // We're not doing any optimizations here, so there is no optimizer that could know the value.
             // (We know the value here in the machine of course, but this is the runtime of that code,
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index 49cd7138748..b6a64035261 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -43,6 +43,14 @@ pub(crate) struct MutablePtrInFinal {
     pub kind: InternKind,
 }
 
+#[derive(Diagnostic)]
+#[diag(const_eval_const_heap_ptr_in_final)]
+#[note]
+pub(crate) struct ConstHeapPtrInFinal {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(const_eval_unstable_in_stable_exposed)]
 pub(crate) struct UnstableInStableExposed {
diff --git a/compiler/rustc_const_eval/src/interpret/intern.rs b/compiler/rustc_const_eval/src/interpret/intern.rs
index f0f958d069e..85524949053 100644
--- a/compiler/rustc_const_eval/src/interpret/intern.rs
+++ b/compiler/rustc_const_eval/src/interpret/intern.rs
@@ -31,7 +31,7 @@ use super::{
 };
 use crate::const_eval;
 use crate::const_eval::DummyMachine;
-use crate::errors::NestedStaticInThreadLocal;
+use crate::errors::{ConstHeapPtrInFinal, NestedStaticInThreadLocal};
 
 pub trait CompileTimeMachine<'tcx, T> = Machine<
         'tcx,
@@ -55,6 +55,35 @@ impl HasStaticRootDefId for const_eval::CompileTimeMachine<'_> {
     }
 }
 
+pub enum DisallowInternReason {
+    ConstHeap,
+}
+
+/// A trait for controlling whether memory allocated in the interpreter can be interned.
+///
+/// This prevents us from interning `const_allocate` pointers that have not been made
+/// global through `const_make_global`.
+pub trait CanIntern {
+    fn disallows_intern(&self) -> Option<DisallowInternReason>;
+}
+
+impl CanIntern for const_eval::MemoryKind {
+    fn disallows_intern(&self) -> Option<DisallowInternReason> {
+        match self {
+            const_eval::MemoryKind::Heap { was_made_global: false } => {
+                Some(DisallowInternReason::ConstHeap)
+            }
+            const_eval::MemoryKind::Heap { was_made_global: true } => None,
+        }
+    }
+}
+
+impl CanIntern for ! {
+    fn disallows_intern(&self) -> Option<DisallowInternReason> {
+        *self
+    }
+}
+
 /// Intern an allocation. Returns `Err` if the allocation does not exist in the local memory.
 ///
 /// `mutability` can be used to force immutable interning: if it is `Mutability::Not`, the
@@ -62,7 +91,7 @@ impl HasStaticRootDefId for const_eval::CompileTimeMachine<'_> {
 /// already mutable (as a sanity check).
 ///
 /// Returns an iterator over all relocations referred to by this allocation.
-fn intern_shallow<'tcx, T, M: CompileTimeMachine<'tcx, T>>(
+fn intern_shallow<'tcx, T: CanIntern, M: CompileTimeMachine<'tcx, T>>(
     ecx: &mut InterpCx<'tcx, M>,
     alloc_id: AllocId,
     mutability: Mutability,
@@ -71,9 +100,26 @@ fn intern_shallow<'tcx, T, M: CompileTimeMachine<'tcx, T>>(
     trace!("intern_shallow {:?}", alloc_id);
     // remove allocation
     // FIXME(#120456) - is `swap_remove` correct?
-    let Some((_kind, mut alloc)) = ecx.memory.alloc_map.swap_remove(&alloc_id) else {
+    let Some((kind, mut alloc)) = ecx.memory.alloc_map.swap_remove(&alloc_id) else {
         return Err(());
     };
+
+    match kind {
+        MemoryKind::Machine(x) if let Some(reason) = x.disallows_intern() => match reason {
+            // attempting to intern a `const_allocate`d pointer that was not made global via
+            // `const_make_global`. We emit an error here but don't return an `Err`. The `Err`
+            // is for pointers that we can't intern at all (i.e. dangling pointers). We still
+            // (recursively) intern this pointer because we don't have to worry about the
+            // additional paperwork involved with _not_ interning it, such as storing it in
+            // the dead memory map and having to deal with additional "dangling pointer"
+            // messages if someone tries to store the non-made-global ptr in the final value.
+            DisallowInternReason::ConstHeap => {
+                ecx.tcx.dcx().emit_err(ConstHeapPtrInFinal { span: ecx.tcx.span });
+            }
+        },
+        MemoryKind::Machine(_) | MemoryKind::Stack | MemoryKind::CallerLocation => {}
+    }
+
     // Set allocation mutability as appropriate. This is used by LLVM to put things into
     // read-only memory, and also by Miri when evaluating other globals that
     // access this one.
@@ -99,7 +145,7 @@ fn intern_shallow<'tcx, T, M: CompileTimeMachine<'tcx, T>>(
     } else {
         ecx.tcx.set_alloc_id_memory(alloc_id, alloc);
     }
-    Ok(alloc.0.0.provenance().ptrs().iter().map(|&(_, prov)| prov))
+    Ok(alloc.inner().provenance().ptrs().iter().map(|&(_, prov)| prov))
 }
 
 /// Creates a new `DefId` and feeds all the right queries to make this `DefId`
@@ -181,7 +227,7 @@ pub fn intern_const_alloc_recursive<'tcx, M: CompileTimeMachine<'tcx, const_eval
         }
         InternKind::Static(Mutability::Not) => {
             (
-                // Outermost allocation is mutable if `!Freeze`.
+                // Outermost allocation is mutable if `!Freeze` i.e. contains interior mutable types.
                 if ret.layout.ty.is_freeze(*ecx.tcx, ecx.typing_env) {
                     Mutability::Not
                 } else {
@@ -321,7 +367,7 @@ pub fn intern_const_alloc_recursive<'tcx, M: CompileTimeMachine<'tcx, const_eval
 
 /// Intern `ret`. This function assumes that `ret` references no other allocation.
 #[instrument(level = "debug", skip(ecx))]
-pub fn intern_const_alloc_for_constprop<'tcx, T, M: CompileTimeMachine<'tcx, T>>(
+pub fn intern_const_alloc_for_constprop<'tcx, T: CanIntern, M: CompileTimeMachine<'tcx, T>>(
     ecx: &mut InterpCx<'tcx, M>,
     alloc_id: AllocId,
 ) -> InterpResult<'tcx, ()> {
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 6414821e21d..50578e13a7a 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -26,6 +26,7 @@ use super::{
     Misalignment, Pointer, PointerArithmetic, Provenance, Scalar, alloc_range, err_ub,
     err_ub_custom, interp_ok, throw_ub, throw_ub_custom, throw_unsup, throw_unsup_format,
 };
+use crate::const_eval::ConstEvalErrKind;
 use crate::fluent_generated as fluent;
 
 #[derive(Debug, PartialEq, Copy, Clone)]
@@ -311,6 +312,49 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         interp_ok(new_ptr)
     }
 
+    /// mark the `const_allocate`d pointer immutable so we can intern it.
+    pub fn make_const_heap_ptr_global(
+        &mut self,
+        ptr: Pointer<Option<M::Provenance>>,
+    ) -> InterpResult<'tcx>
+    where
+        M: Machine<'tcx, MemoryKind = crate::const_eval::MemoryKind>,
+    {
+        let (alloc_id, offset, _) = self.ptr_get_alloc_id(ptr, 0)?;
+        if offset.bytes() != 0 {
+            return Err(ConstEvalErrKind::ConstMakeGlobalWithOffset(format!("{ptr:?}"))).into();
+        }
+
+        let not_local_heap =
+            matches!(self.tcx.try_get_global_alloc(alloc_id), Some(GlobalAlloc::Memory(_)));
+
+        if not_local_heap {
+            return Err(ConstEvalErrKind::ConstMakeGlobalPtrIsNonHeap(format!("{ptr:?}"))).into();
+        }
+
+        let (kind, alloc) = self.memory.alloc_map.get_mut_or(alloc_id, || {
+            Err(ConstEvalErrKind::ConstMakeGlobalWithDanglingPtr(format!("{ptr:?}")))
+        })?;
+
+        alloc.mutability = Mutability::Not;
+
+        match kind {
+            MemoryKind::Stack | MemoryKind::CallerLocation => {
+                return Err(ConstEvalErrKind::ConstMakeGlobalPtrIsNonHeap(format!("{ptr:?}")))
+                    .into();
+            }
+            MemoryKind::Machine(crate::const_eval::MemoryKind::Heap { was_made_global }) => {
+                if *was_made_global {
+                    return Err(ConstEvalErrKind::ConstMakeGlobalPtrAlreadyMadeGlobal(alloc_id))
+                        .into();
+                }
+                *was_made_global = true;
+            }
+        }
+
+        interp_ok(())
+    }
+
     #[instrument(skip(self), level = "debug")]
     pub fn deallocate_ptr(
         &mut self,
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 4ca39bbc68e..1c2167a50fd 100644
--- a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
+++ b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
@@ -52,9 +52,8 @@ fn check_validity_requirement_strict<'tcx>(
 
     let mut cx = InterpCx::new(cx.tcx(), DUMMY_SP, cx.typing_env, machine);
 
-    let allocated = cx
-        .allocate(ty, MemoryKind::Machine(crate::const_eval::MemoryKind::Heap))
-        .expect("OOM: failed to allocate for uninit check");
+    let allocated =
+        cx.allocate(ty, MemoryKind::Stack).expect("OOM: failed to allocate for uninit check");
 
     if kind == ValidityRequirement::Zero {
         cx.write_bytes_ptr(
@@ -185,7 +184,10 @@ pub(crate) fn validate_scalar_in_layout<'tcx>(
         bug!("could not compute layout of {scalar:?}:{ty:?}")
     };
     let allocated = cx
-        .allocate(layout, MemoryKind::Machine(crate::const_eval::MemoryKind::Heap))
+        .allocate(
+            layout,
+            MemoryKind::Machine(crate::const_eval::MemoryKind::Heap { was_made_global: false }),
+        )
         .expect("OOM: failed to allocate for uninit check");
 
     cx.write_scalar(scalar, &allocated).unwrap();
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index dcab6ef1c5a..6e5fe3823ab 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -422,6 +422,9 @@ pub(crate) fn check_intrinsic_type(
             vec![Ty::new_mut_ptr(tcx, tcx.types.u8), tcx.types.usize, tcx.types.usize],
             tcx.types.unit,
         ),
+        sym::const_make_global => {
+            (0, 0, vec![Ty::new_mut_ptr(tcx, tcx.types.u8)], Ty::new_imm_ptr(tcx, tcx.types.u8))
+        }
 
         sym::ptr_offset_from => (
             1,
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
index 71e0c943fbb..3e68afbfabd 100644
--- a/compiler/rustc_middle/src/mir/interpret/error.rs
+++ b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -257,7 +257,7 @@ pub enum InvalidProgramInfo<'tcx> {
 /// Details of why a pointer had to be in-bounds.
 #[derive(Debug, Copy, Clone)]
 pub enum CheckInAllocMsg {
-    /// We are access memory.
+    /// We are accessing memory.
     MemoryAccess,
     /// We are doing pointer arithmetic.
     InboundsPointerArithmetic,
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 8b12edf426c..599ef9aba2a 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -715,6 +715,7 @@ symbols! {
         const_indexing,
         const_let,
         const_loop,
+        const_make_global,
         const_mut_refs,
         const_panic,
         const_panic_fmt,
diff --git a/library/alloc/src/boxed/thin.rs b/library/alloc/src/boxed/thin.rs
index 21425b9846e..1cce36606d2 100644
--- a/library/alloc/src/boxed/thin.rs
+++ b/library/alloc/src/boxed/thin.rs
@@ -5,7 +5,7 @@
 use core::error::Error;
 use core::fmt::{self, Debug, Display, Formatter};
 #[cfg(not(no_global_oom_handling))]
-use core::intrinsics::const_allocate;
+use core::intrinsics::{const_allocate, const_make_global};
 use core::marker::PhantomData;
 #[cfg(not(no_global_oom_handling))]
 use core::marker::Unsize;
@@ -340,9 +340,10 @@ impl<H> WithHeader<H> {
                     alloc.add(metadata_offset).cast();
                 // SAFETY: `*metadata_ptr` is within the allocation.
                 metadata_ptr.write(ptr::metadata::<Dyn>(ptr::dangling::<T>() as *const Dyn));
-
+                // SAFETY: valid heap allocation
+                const_make_global(alloc);
                 // SAFETY: we have just written the metadata.
-                &*(metadata_ptr)
+                &*metadata_ptr
             }
         };
 
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index c2e4b751c65..038c705d5b5 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2533,6 +2533,15 @@ pub const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize)
     // Runtime NOP
 }
 
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+#[rustc_nounwind]
+#[rustc_intrinsic]
+#[miri::intrinsic_fallback_is_spec]
+pub const unsafe fn const_make_global(ptr: *mut u8) -> *const u8 {
+    // const eval overrides this function; at runtime, it is a NOP.
+    ptr
+}
+
 /// Returns whether we should perform contract-checking at runtime.
 ///
 /// This is meant to be similar to the ub_checks intrinsic, in terms
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient.rs b/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient.rs
index 83ed496ac2c..fa49990abfd 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient.rs
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient.rs
@@ -8,11 +8,11 @@ const FOO_RAW: *const i32 = foo();
 
 const fn foo() -> &'static i32 {
     let t = unsafe {
-        let i = intrinsics::const_allocate(4, 4) as * mut i32;
+        let i = intrinsics::const_allocate(4, 4) as *mut i32;
         *i = 20;
         i
     };
-    unsafe { &*t }
+    unsafe { &*(intrinsics::const_make_global(t as *mut u8) as *mut i32) }
 }
 fn main() {
     assert_eq!(*FOO, 20);
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 11ed0841a00..a8c7ee93971 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,7 +1,7 @@
 error[E0080]: constructing invalid value at .<deref>: encountered uninitialized memory, but expected an integer
   --> $DIR/alloc_intrinsic_uninit.rs:7:1
    |
-LL | const BAR: &i32 = unsafe { &*(intrinsics::const_allocate(4, 4) as *mut i32) };
+LL | const BAR: &i32 = unsafe {
    | ^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
    = 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.
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 691bde87d2f..47e1c22cc2c 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,7 +1,7 @@
 error[E0080]: constructing invalid value at .<deref>: encountered uninitialized memory, but expected an integer
   --> $DIR/alloc_intrinsic_uninit.rs:7:1
    |
-LL | const BAR: &i32 = unsafe { &*(intrinsics::const_allocate(4, 4) as *mut i32) };
+LL | const BAR: &i32 = unsafe {
    | ^^^^^^^^^^^^^^^ it is undefined behavior to use this value
    |
    = 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.
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 ffc35ca1ddc..2736cdeed8c 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.rs
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.rs
@@ -4,6 +4,7 @@
 #![feature(const_heap)]
 use std::intrinsics;
 
-const BAR: &i32 = unsafe { &*(intrinsics::const_allocate(4, 4) as *mut i32) };
-//~^ ERROR: uninitialized memory
+const BAR: &i32 = unsafe { //~ ERROR: uninitialized memory
+    &*(intrinsics::const_make_global(intrinsics::const_allocate(4, 4)) as *mut i32)
+};
 fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.rs b/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.rs
index 26cb69e458b..201fa715022 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.rs
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.rs
@@ -7,5 +7,6 @@ use std::intrinsics;
 
 const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
 //~^ error: mutable pointer in final value of constant
+//~| error: encountered `const_allocate` pointer in final value that was not made global
 
 fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr
index 0dc49dc3cd8..e69d27e48c8 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr
@@ -1,8 +1,16 @@
+error: encountered `const_allocate` pointer in final value that was not made global
+  --> $DIR/alloc_intrinsic_untyped.rs:8:1
+   |
+LL | const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: use `const_make_global` to make allocated pointers immutable before returning
+
 error: encountered mutable pointer in final value of constant
   --> $DIR/alloc_intrinsic_untyped.rs:8:1
    |
 LL | const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
    | ^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui/consts/const-eval/heap/dealloc_intrinsic.rs b/tests/ui/consts/const-eval/heap/dealloc_intrinsic.rs
index 3cc035c66d3..515e12d2b77 100644
--- a/tests/ui/consts/const-eval/heap/dealloc_intrinsic.rs
+++ b/tests/ui/consts/const-eval/heap/dealloc_intrinsic.rs
@@ -12,7 +12,7 @@ const _X: () = unsafe {
 const Y: &u32 = unsafe {
     let ptr = intrinsics::const_allocate(4, 4) as *mut u32;
     *ptr = 42;
-    &*ptr
+    &*(intrinsics::const_make_global(ptr as *mut u8) as *const u32)
 };
 
 const Z: &u32 = &42;
diff --git a/tests/ui/consts/const-eval/heap/make-global-dangling.rs b/tests/ui/consts/const-eval/heap/make-global-dangling.rs
new file mode 100644
index 00000000000..4099e6e13ed
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/make-global-dangling.rs
@@ -0,0 +1,16 @@
+#![feature(core_intrinsics)]
+#![feature(const_heap)]
+
+use std::intrinsics;
+
+const Y: &u32 = unsafe {
+    &*(intrinsics::const_make_global(std::ptr::null_mut()) as *const u32)
+    //~^ error: pointer not dereferenceable
+};
+
+const Z: &u32 = unsafe {
+    &*(intrinsics::const_make_global(std::ptr::dangling_mut()) as *const u32)
+    //~^ error: pointer not dereferenceable
+};
+
+fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/make-global-dangling.stderr b/tests/ui/consts/const-eval/heap/make-global-dangling.stderr
new file mode 100644
index 00000000000..4a5f59b9855
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/make-global-dangling.stderr
@@ -0,0 +1,15 @@
+error[E0080]: pointer not dereferenceable: pointer must point to some allocation, but got null pointer
+  --> $DIR/make-global-dangling.rs:7:8
+   |
+LL |     &*(intrinsics::const_make_global(std::ptr::null_mut()) as *const u32)
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `Y` failed here
+
+error[E0080]: pointer not dereferenceable: pointer must point to some allocation, but got 0x1[noalloc] which is a dangling pointer (it has no provenance)
+  --> $DIR/make-global-dangling.rs:12:8
+   |
+LL |     &*(intrinsics::const_make_global(std::ptr::dangling_mut()) as *const u32)
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `Z` failed here
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/heap/make-global-other.rs b/tests/ui/consts/const-eval/heap/make-global-other.rs
new file mode 100644
index 00000000000..dd5d27cc968
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/make-global-other.rs
@@ -0,0 +1,13 @@
+#![feature(core_intrinsics)]
+#![feature(const_heap)]
+
+use std::intrinsics;
+
+const X: &i32 = &0;
+
+const Y: &i32 = unsafe {
+    &*(intrinsics::const_make_global(X as *const i32 as *mut u8) as *const i32)
+    //~^ error: pointer passed to `const_make_global` does not point to a heap allocation: ALLOC0<imm>
+};
+
+fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/make-global-other.stderr b/tests/ui/consts/const-eval/heap/make-global-other.stderr
new file mode 100644
index 00000000000..572230afe3b
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/make-global-other.stderr
@@ -0,0 +1,9 @@
+error[E0080]: pointer passed to `const_make_global` does not point to a heap allocation: ALLOC0<imm>
+  --> $DIR/make-global-other.rs:9:8
+   |
+LL |     &*(intrinsics::const_make_global(X as *const i32 as *mut u8) as *const i32)
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `Y` failed here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/heap/make-global-twice.rs b/tests/ui/consts/const-eval/heap/make-global-twice.rs
new file mode 100644
index 00000000000..36d779ad034
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/make-global-twice.rs
@@ -0,0 +1,16 @@
+#![feature(core_intrinsics)]
+#![feature(const_heap)]
+
+use std::intrinsics;
+
+const Y: &i32 = unsafe {
+    let ptr = intrinsics::const_allocate(4, 4);
+    let i = ptr as *mut i32;
+    *i = 20;
+    intrinsics::const_make_global(ptr);
+    intrinsics::const_make_global(ptr);
+    //~^ error: attempting to call `const_make_global` twice on the same allocation ALLOC0
+    &*i
+};
+
+fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/make-global-twice.stderr b/tests/ui/consts/const-eval/heap/make-global-twice.stderr
new file mode 100644
index 00000000000..35d2385d9e0
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/make-global-twice.stderr
@@ -0,0 +1,9 @@
+error[E0080]: attempting to call `const_make_global` twice on the same allocation ALLOC0
+  --> $DIR/make-global-twice.rs:11:5
+   |
+LL |     intrinsics::const_make_global(ptr);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `Y` failed here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/heap/make-global.rs b/tests/ui/consts/const-eval/heap/make-global.rs
new file mode 100644
index 00000000000..b26fe2434ab
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/make-global.rs
@@ -0,0 +1,21 @@
+//@ run-pass
+#![feature(core_intrinsics)]
+#![feature(const_heap)]
+use std::intrinsics;
+
+const FOO: &i32 = foo();
+const FOO_RAW: *const i32 = foo();
+
+const fn foo() -> &'static i32 {
+    unsafe {
+        let ptr = intrinsics::const_allocate(4, 4);
+        let t = ptr as *mut i32;
+        *t = 20;
+        intrinsics::const_make_global(ptr);
+        &*t
+    }
+}
+fn main() {
+    assert_eq!(*FOO, 20);
+    assert_eq!(unsafe { *FOO_RAW }, 20);
+}
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
new file mode 100644
index 00000000000..75f2d87d4d0
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.rs
@@ -0,0 +1,14 @@
+#![feature(core_intrinsics)]
+#![feature(const_heap)]
+use std::intrinsics;
+
+const A: &u8 = unsafe {
+    let ptr = intrinsics::const_allocate(1, 1);
+    *ptr = 1;
+    let ptr: *const u8 = intrinsics::const_make_global(ptr);
+    *(ptr as *mut u8) = 2;
+    //~^ error: writing to ALLOC0 which is read-only
+    &*ptr
+};
+
+fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.stderr b/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.stderr
new file mode 100644
index 00000000000..15af44b74d5
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.stderr
@@ -0,0 +1,9 @@
+error[E0080]: writing to ALLOC0 which is read-only
+  --> $DIR/ptr_made_global_mutated.rs:9:5
+   |
+LL |     *(ptr as *mut u8) = 2;
+   |     ^^^^^^^^^^^^^^^^^^^^^ evaluation of `A` failed here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/heap/ptr_not_made_global.rs b/tests/ui/consts/const-eval/heap/ptr_not_made_global.rs
new file mode 100644
index 00000000000..4b0499d4106
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/ptr_not_made_global.rs
@@ -0,0 +1,19 @@
+#![feature(core_intrinsics)]
+#![feature(const_heap)]
+use std::intrinsics;
+
+const FOO: &i32 = foo();
+//~^ error: encountered `const_allocate` pointer in final value that was not made global
+const FOO_RAW: *const i32 = foo();
+//~^ error: encountered `const_allocate` pointer in final value that was not made global
+
+const fn foo() -> &'static i32 {
+    let t = unsafe {
+        let i = intrinsics::const_allocate(4, 4) as *mut i32;
+        *i = 20;
+        i
+    };
+    unsafe { &*t }
+}
+
+fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/ptr_not_made_global.stderr b/tests/ui/consts/const-eval/heap/ptr_not_made_global.stderr
new file mode 100644
index 00000000000..569a8be3e8c
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/ptr_not_made_global.stderr
@@ -0,0 +1,18 @@
+error: encountered `const_allocate` pointer in final value that was not made global
+  --> $DIR/ptr_not_made_global.rs:5:1
+   |
+LL | const FOO: &i32 = foo();
+   | ^^^^^^^^^^^^^^^
+   |
+   = note: use `const_make_global` to make allocated pointers immutable before returning
+
+error: encountered `const_allocate` pointer in final value that was not made global
+  --> $DIR/ptr_not_made_global.rs:7:1
+   |
+LL | const FOO_RAW: *const i32 = foo();
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: use `const_make_global` to make allocated pointers immutable before returning
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 44b38ca45edc4bd826f4ef5e3fb2221cbd1649cd Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Thu, 10 Jul 2025 17:54:55 +0800
Subject: format pointer later instead of eagerly converting to string

---
 compiler/rustc_const_eval/src/const_eval/error.rs | 12 ++++++------
 compiler/rustc_const_eval/src/interpret/memory.rs | 18 +++++++++---------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_const_eval/src/const_eval/error.rs b/compiler/rustc_const_eval/src/const_eval/error.rs
index 5b07b7c13c1..3e880d02001 100644
--- a/compiler/rustc_const_eval/src/const_eval/error.rs
+++ b/compiler/rustc_const_eval/src/const_eval/error.rs
@@ -11,8 +11,8 @@ use rustc_span::{Span, Symbol};
 use super::CompileTimeMachine;
 use crate::errors::{self, FrameNote, ReportErrorExt};
 use crate::interpret::{
-    ErrorHandled, Frame, InterpErrorInfo, InterpErrorKind, MachineStopType, err_inval,
-    err_machine_stop,
+    CtfeProvenance, ErrorHandled, Frame, InterpErrorInfo, InterpErrorKind, MachineStopType,
+    Pointer, err_inval, err_machine_stop,
 };
 
 /// The CTFE machine has some custom error kinds.
@@ -32,12 +32,12 @@ pub enum ConstEvalErrKind {
     /// Called `const_make_global` twice.
     ConstMakeGlobalPtrAlreadyMadeGlobal(AllocId),
     /// Called `const_make_global` on a non-heap pointer.
-    ConstMakeGlobalPtrIsNonHeap(String),
+    ConstMakeGlobalPtrIsNonHeap(Pointer<Option<CtfeProvenance>>),
     /// Called `const_make_global` on a dangling pointer.
-    ConstMakeGlobalWithDanglingPtr(String),
+    ConstMakeGlobalWithDanglingPtr(Pointer<Option<CtfeProvenance>>),
     /// Called `const_make_global` on a pointer that does not start at the
     /// beginning of an object.
-    ConstMakeGlobalWithOffset(String),
+    ConstMakeGlobalWithOffset(Pointer<Option<CtfeProvenance>>),
 }
 
 impl MachineStopType for ConstEvalErrKind {
@@ -74,7 +74,7 @@ impl MachineStopType for ConstEvalErrKind {
             ConstMakeGlobalPtrIsNonHeap(ptr)
             | ConstMakeGlobalWithOffset(ptr)
             | ConstMakeGlobalWithDanglingPtr(ptr) => {
-                adder("ptr".into(), ptr.into_diag_arg(&mut None));
+                adder("ptr".into(), format!("{ptr:?}").into_diag_arg(&mut None));
             }
             ConstMakeGlobalPtrAlreadyMadeGlobal(alloc) => {
                 adder("alloc".into(), alloc.into_diag_arg(&mut None));
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 50578e13a7a..08682dd193d 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -315,33 +315,33 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// mark the `const_allocate`d pointer immutable so we can intern it.
     pub fn make_const_heap_ptr_global(
         &mut self,
-        ptr: Pointer<Option<M::Provenance>>,
+        ptr: Pointer<Option<CtfeProvenance>>,
     ) -> InterpResult<'tcx>
     where
-        M: Machine<'tcx, MemoryKind = crate::const_eval::MemoryKind>,
+        M: Machine<'tcx, MemoryKind = crate::const_eval::MemoryKind, Provenance = CtfeProvenance>,
     {
         let (alloc_id, offset, _) = self.ptr_get_alloc_id(ptr, 0)?;
         if offset.bytes() != 0 {
-            return Err(ConstEvalErrKind::ConstMakeGlobalWithOffset(format!("{ptr:?}"))).into();
+            return Err(ConstEvalErrKind::ConstMakeGlobalWithOffset(ptr)).into();
         }
 
         let not_local_heap =
             matches!(self.tcx.try_get_global_alloc(alloc_id), Some(GlobalAlloc::Memory(_)));
 
         if not_local_heap {
-            return Err(ConstEvalErrKind::ConstMakeGlobalPtrIsNonHeap(format!("{ptr:?}"))).into();
+            return Err(ConstEvalErrKind::ConstMakeGlobalPtrIsNonHeap(ptr)).into();
         }
 
-        let (kind, alloc) = self.memory.alloc_map.get_mut_or(alloc_id, || {
-            Err(ConstEvalErrKind::ConstMakeGlobalWithDanglingPtr(format!("{ptr:?}")))
-        })?;
+        let (kind, alloc) = self
+            .memory
+            .alloc_map
+            .get_mut_or(alloc_id, || Err(ConstEvalErrKind::ConstMakeGlobalWithDanglingPtr(ptr)))?;
 
         alloc.mutability = Mutability::Not;
 
         match kind {
             MemoryKind::Stack | MemoryKind::CallerLocation => {
-                return Err(ConstEvalErrKind::ConstMakeGlobalPtrIsNonHeap(format!("{ptr:?}")))
-                    .into();
+                return Err(ConstEvalErrKind::ConstMakeGlobalPtrIsNonHeap(ptr)).into();
             }
             MemoryKind::Machine(crate::const_eval::MemoryKind::Heap { was_made_global }) => {
                 if *was_made_global {
-- 
cgit 1.4.1-3-g733a5


From 306928fc11a7c7805cce78660aa41347476393ca Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 14 Jul 2025 21:08:03 +0530
Subject: update change tracking with warning on removal of fields.

---
 src/bootstrap/src/utils/change_tracker.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index d888a7863bc..f802640a42d 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -481,4 +481,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Warning,
         summary: "The current `./x suggest` implementation has been removed due to it being quite broken and a lack of maintenance bandwidth, with no prejudice against re-implementing it in a more maintainable form.",
     },
+    ChangeInfo {
+        change_id: 143926,
+        severity: ChangeSeverity::Warning,
+        summary: "Removed `rust.description` and `llvm.ccache` as it was deprecated in #137723 and #136941 long time ago.",
+    },
 ];
-- 
cgit 1.4.1-3-g733a5


From fd48b7b8dd911229b635f7969e6213b5af337b7d Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Sun, 13 Jul 2025 15:11:31 +0800
Subject: Comment more code and make tests clearer

Co-Authored-By: Ralf Jung <post@ralfj.de>
---
 compiler/rustc_const_eval/src/const_eval/machine.rs      |  6 +++++-
 compiler/rustc_const_eval/src/interpret/intern.rs        | 13 ++++++-------
 compiler/rustc_const_eval/src/interpret/memory.rs        | 16 +++++++++-------
 .../src/util/check_validity_requirement.rs               | 11 +++++------
 .../const-eval/heap/alloc_intrinsic_nontransient.rs      |  2 +-
 .../ui/consts/const-eval/heap/alloc_intrinsic_uninit.rs  |  3 ++-
 .../ui/consts/const-eval/heap/alloc_intrinsic_untyped.rs | 12 ------------
 .../const-eval/heap/alloc_intrinsic_untyped.stderr       | 16 ----------------
 tests/ui/consts/const-eval/heap/make-global-dangling.rs  |  2 ++
 .../consts/const-eval/heap/make-global-dangling.stderr   |  4 ++--
 tests/ui/consts/const-eval/heap/make-global-other.rs     |  2 ++
 tests/ui/consts/const-eval/heap/make-global-other.stderr |  2 +-
 tests/ui/consts/const-eval/heap/make-global-twice.rs     |  2 ++
 tests/ui/consts/const-eval/heap/make-global-twice.stderr |  2 +-
 .../ui/consts/const-eval/heap/ptr_made_global_mutated.rs |  1 +
 .../const-eval/heap/ptr_made_global_mutated.stderr       |  2 +-
 tests/ui/consts/const-eval/heap/ptr_not_made_global.rs   |  5 +++++
 .../ui/consts/const-eval/heap/ptr_not_made_global.stderr |  4 ++--
 .../ui/consts/const-eval/heap/ptr_not_made_global_mut.rs | 12 ++++++++++++
 .../const-eval/heap/ptr_not_made_global_mut.stderr       | 16 ++++++++++++++++
 20 files changed, 75 insertions(+), 58 deletions(-)
 delete mode 100644 tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.rs
 delete mode 100644 tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr
 create mode 100644 tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.rs
 create mode 100644 tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.stderr

diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index 4e952b043fb..0a6bdef2225 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -169,7 +169,11 @@ pub type CompileTimeInterpCx<'tcx> = InterpCx<'tcx, CompileTimeMachine<'tcx>>;
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum MemoryKind {
-    Heap { was_made_global: bool },
+    Heap {
+        /// Indicates whether `make_global` was called on this allocation.
+        /// If this is `true`, the allocation must be immutable.
+        was_made_global: bool,
+    },
 }
 
 impl fmt::Display for MemoryKind {
diff --git a/compiler/rustc_const_eval/src/interpret/intern.rs b/compiler/rustc_const_eval/src/interpret/intern.rs
index 85524949053..b8fcdc9b7ef 100644
--- a/compiler/rustc_const_eval/src/interpret/intern.rs
+++ b/compiler/rustc_const_eval/src/interpret/intern.rs
@@ -106,13 +106,12 @@ fn intern_shallow<'tcx, T: CanIntern, M: CompileTimeMachine<'tcx, T>>(
 
     match kind {
         MemoryKind::Machine(x) if let Some(reason) = x.disallows_intern() => match reason {
-            // attempting to intern a `const_allocate`d pointer that was not made global via
-            // `const_make_global`. We emit an error here but don't return an `Err`. The `Err`
-            // is for pointers that we can't intern at all (i.e. dangling pointers). We still
-            // (recursively) intern this pointer because we don't have to worry about the
-            // additional paperwork involved with _not_ interning it, such as storing it in
-            // the dead memory map and having to deal with additional "dangling pointer"
-            // messages if someone tries to store the non-made-global ptr in the final value.
+            // Attempting to intern a `const_allocate`d pointer that was not made global via
+            // `const_make_global`. This is an error, but if we return `Err` now, things
+            // become inconsistent because we already removed the allocation from `alloc_map`.
+            // So instead we just emit an error and then continue interning as usual.
+            // We *could* do this check before removing the allocation from `alloc_map`, but then
+            // it would be much harder to ensure that we only error once for each allocation.
             DisallowInternReason::ConstHeap => {
                 ecx.tcx.dcx().emit_err(ConstHeapPtrInFinal { span: ecx.tcx.span });
             }
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 08682dd193d..5f9f43a320b 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -312,7 +312,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         interp_ok(new_ptr)
     }
 
-    /// mark the `const_allocate`d pointer immutable so we can intern it.
+    /// Mark the `const_allocate`d allocation `ptr` points to as immutable so we can intern it.
     pub fn make_const_heap_ptr_global(
         &mut self,
         ptr: Pointer<Option<CtfeProvenance>>,
@@ -325,20 +325,19 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             return Err(ConstEvalErrKind::ConstMakeGlobalWithOffset(ptr)).into();
         }
 
-        let not_local_heap =
-            matches!(self.tcx.try_get_global_alloc(alloc_id), Some(GlobalAlloc::Memory(_)));
-
-        if not_local_heap {
+        if matches!(self.tcx.try_get_global_alloc(alloc_id), Some(_)) {
+            // This points to something outside the current interpreter.
             return Err(ConstEvalErrKind::ConstMakeGlobalPtrIsNonHeap(ptr)).into();
         }
 
+        // If we can't find it in `alloc_map` it must be dangling (because we don't use
+        // `extra_fn_ptr_map` in const-eval).
         let (kind, alloc) = self
             .memory
             .alloc_map
             .get_mut_or(alloc_id, || Err(ConstEvalErrKind::ConstMakeGlobalWithDanglingPtr(ptr)))?;
 
-        alloc.mutability = Mutability::Not;
-
+        // Ensure this is actually a *heap* allocation, and record it as made-global.
         match kind {
             MemoryKind::Stack | MemoryKind::CallerLocation => {
                 return Err(ConstEvalErrKind::ConstMakeGlobalPtrIsNonHeap(ptr)).into();
@@ -352,6 +351,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             }
         }
 
+        // Prevent further mutation, this is now an immutable global.
+        alloc.mutability = Mutability::Not;
+
         interp_ok(())
     }
 
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 1c2167a50fd..b1f29598750 100644
--- a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
+++ b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
@@ -52,6 +52,7 @@ fn check_validity_requirement_strict<'tcx>(
 
     let mut cx = InterpCx::new(cx.tcx(), DUMMY_SP, cx.typing_env, machine);
 
+    // It doesn't really matter which `MemoryKind` we use here, `Stack` is the least wrong.
     let allocated =
         cx.allocate(ty, MemoryKind::Stack).expect("OOM: failed to allocate for uninit check");
 
@@ -183,12 +184,10 @@ pub(crate) fn validate_scalar_in_layout<'tcx>(
     let Ok(layout) = cx.layout_of(ty) else {
         bug!("could not compute layout of {scalar:?}:{ty:?}")
     };
-    let allocated = cx
-        .allocate(
-            layout,
-            MemoryKind::Machine(crate::const_eval::MemoryKind::Heap { was_made_global: false }),
-        )
-        .expect("OOM: failed to allocate for uninit check");
+
+    // It doesn't really matter which `MemoryKind` we use here, `Stack` is the least wrong.
+    let allocated =
+        cx.allocate(layout, MemoryKind::Stack).expect("OOM: failed to allocate for uninit check");
 
     cx.write_scalar(scalar, &allocated).unwrap();
 
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient.rs b/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient.rs
index fa49990abfd..af24e463b50 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient.rs
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_nontransient.rs
@@ -12,7 +12,7 @@ const fn foo() -> &'static i32 {
         *i = 20;
         i
     };
-    unsafe { &*(intrinsics::const_make_global(t as *mut u8) as *mut i32) }
+    unsafe { &*(intrinsics::const_make_global(t as *mut u8) as *const i32) }
 }
 fn main() {
     assert_eq!(*FOO, 20);
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 2736cdeed8c..c54115de204 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.rs
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_uninit.rs
@@ -5,6 +5,7 @@
 use std::intrinsics;
 
 const BAR: &i32 = unsafe { //~ ERROR: uninitialized memory
-    &*(intrinsics::const_make_global(intrinsics::const_allocate(4, 4)) as *mut i32)
+    // 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)
 };
 fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.rs b/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.rs
deleted file mode 100644
index 201fa715022..00000000000
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-// We unleash Miri here since this test demonstrates code that bypasses the checks against interning
-// mutable pointers, which currently ICEs. Unleashing Miri silences the ICE.
-//@ compile-flags: -Zunleash-the-miri-inside-of-you
-#![feature(core_intrinsics)]
-#![feature(const_heap)]
-use std::intrinsics;
-
-const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
-//~^ error: mutable pointer in final value of constant
-//~| error: encountered `const_allocate` pointer in final value that was not made global
-
-fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr
deleted file mode 100644
index e69d27e48c8..00000000000
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error: encountered `const_allocate` pointer in final value that was not made global
-  --> $DIR/alloc_intrinsic_untyped.rs:8:1
-   |
-LL | const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
-   | ^^^^^^^^^^^^^^^^^^^
-   |
-   = note: use `const_make_global` to make allocated pointers immutable before returning
-
-error: encountered mutable pointer in final value of constant
-  --> $DIR/alloc_intrinsic_untyped.rs:8:1
-   |
-LL | const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
-   | ^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 2 previous errors
-
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 4099e6e13ed..f4c5929bc41 100644
--- a/tests/ui/consts/const-eval/heap/make-global-dangling.rs
+++ b/tests/ui/consts/const-eval/heap/make-global-dangling.rs
@@ -1,3 +1,5 @@
+// Ensure that we can't call `const_make_global` on dangling pointers.
+
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 
diff --git a/tests/ui/consts/const-eval/heap/make-global-dangling.stderr b/tests/ui/consts/const-eval/heap/make-global-dangling.stderr
index 4a5f59b9855..48c2796d0bf 100644
--- a/tests/ui/consts/const-eval/heap/make-global-dangling.stderr
+++ b/tests/ui/consts/const-eval/heap/make-global-dangling.stderr
@@ -1,11 +1,11 @@
 error[E0080]: pointer not dereferenceable: pointer must point to some allocation, but got null pointer
-  --> $DIR/make-global-dangling.rs:7:8
+  --> $DIR/make-global-dangling.rs:9:8
    |
 LL |     &*(intrinsics::const_make_global(std::ptr::null_mut()) as *const u32)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `Y` failed here
 
 error[E0080]: pointer not dereferenceable: pointer must point to some allocation, but got 0x1[noalloc] which is a dangling pointer (it has no provenance)
-  --> $DIR/make-global-dangling.rs:12:8
+  --> $DIR/make-global-dangling.rs:14:8
    |
 LL |     &*(intrinsics::const_make_global(std::ptr::dangling_mut()) as *const u32)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `Z` failed here
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 dd5d27cc968..4e2a59de13e 100644
--- a/tests/ui/consts/const-eval/heap/make-global-other.rs
+++ b/tests/ui/consts/const-eval/heap/make-global-other.rs
@@ -1,3 +1,5 @@
+// Ensure that we can't call `const_make_global` on pointers not in the current interpreter.
+
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 
diff --git a/tests/ui/consts/const-eval/heap/make-global-other.stderr b/tests/ui/consts/const-eval/heap/make-global-other.stderr
index 572230afe3b..ed0d768cf37 100644
--- a/tests/ui/consts/const-eval/heap/make-global-other.stderr
+++ b/tests/ui/consts/const-eval/heap/make-global-other.stderr
@@ -1,5 +1,5 @@
 error[E0080]: pointer passed to `const_make_global` does not point to a heap allocation: ALLOC0<imm>
-  --> $DIR/make-global-other.rs:9:8
+  --> $DIR/make-global-other.rs:11:8
    |
 LL |     &*(intrinsics::const_make_global(X as *const i32 as *mut u8) as *const i32)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `Y` failed here
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 36d779ad034..0cd617cea3e 100644
--- a/tests/ui/consts/const-eval/heap/make-global-twice.rs
+++ b/tests/ui/consts/const-eval/heap/make-global-twice.rs
@@ -1,3 +1,5 @@
+// Ensure that we can't call `const_make_global` twice.
+
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 
diff --git a/tests/ui/consts/const-eval/heap/make-global-twice.stderr b/tests/ui/consts/const-eval/heap/make-global-twice.stderr
index 35d2385d9e0..95cdb9694d8 100644
--- a/tests/ui/consts/const-eval/heap/make-global-twice.stderr
+++ b/tests/ui/consts/const-eval/heap/make-global-twice.stderr
@@ -1,5 +1,5 @@
 error[E0080]: attempting to call `const_make_global` twice on the same allocation ALLOC0
-  --> $DIR/make-global-twice.rs:11:5
+  --> $DIR/make-global-twice.rs:13:5
    |
 LL |     intrinsics::const_make_global(ptr);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `Y` failed here
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 75f2d87d4d0..bea2a5949c2 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
@@ -1,3 +1,4 @@
+// Ensure that once an allocation is "made global", we can no longer mutate it.
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 use std::intrinsics;
diff --git a/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.stderr b/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.stderr
index 15af44b74d5..0e88ea77d1c 100644
--- a/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.stderr
+++ b/tests/ui/consts/const-eval/heap/ptr_made_global_mutated.stderr
@@ -1,5 +1,5 @@
 error[E0080]: writing to ALLOC0 which is read-only
-  --> $DIR/ptr_made_global_mutated.rs:9:5
+  --> $DIR/ptr_made_global_mutated.rs:10:5
    |
 LL |     *(ptr as *mut u8) = 2;
    |     ^^^^^^^^^^^^^^^^^^^^^ evaluation of `A` failed here
diff --git a/tests/ui/consts/const-eval/heap/ptr_not_made_global.rs b/tests/ui/consts/const-eval/heap/ptr_not_made_global.rs
index 4b0499d4106..6980e92c218 100644
--- a/tests/ui/consts/const-eval/heap/ptr_not_made_global.rs
+++ b/tests/ui/consts/const-eval/heap/ptr_not_made_global.rs
@@ -1,3 +1,8 @@
+// Ensure that we reject interning `const_allocate`d allocations in the final value of constants
+// if they have not been made global through `const_make_global`. The pointers are made *immutable*
+// to focus the test on the missing `make_global`; `ptr_not_made_global_mut.rs` covers the case
+// where the pointer remains mutable.
+
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 use std::intrinsics;
diff --git a/tests/ui/consts/const-eval/heap/ptr_not_made_global.stderr b/tests/ui/consts/const-eval/heap/ptr_not_made_global.stderr
index 569a8be3e8c..cb2bb1e8cd8 100644
--- a/tests/ui/consts/const-eval/heap/ptr_not_made_global.stderr
+++ b/tests/ui/consts/const-eval/heap/ptr_not_made_global.stderr
@@ -1,5 +1,5 @@
 error: encountered `const_allocate` pointer in final value that was not made global
-  --> $DIR/ptr_not_made_global.rs:5:1
+  --> $DIR/ptr_not_made_global.rs:10:1
    |
 LL | const FOO: &i32 = foo();
    | ^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL | const FOO: &i32 = foo();
    = note: use `const_make_global` to make allocated pointers immutable before returning
 
 error: encountered `const_allocate` pointer in final value that was not made global
-  --> $DIR/ptr_not_made_global.rs:7:1
+  --> $DIR/ptr_not_made_global.rs:12:1
    |
 LL | const FOO_RAW: *const i32 = foo();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.rs b/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.rs
new file mode 100644
index 00000000000..201fa715022
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.rs
@@ -0,0 +1,12 @@
+// We unleash Miri here since this test demonstrates code that bypasses the checks against interning
+// mutable pointers, which currently ICEs. Unleashing Miri silences the ICE.
+//@ compile-flags: -Zunleash-the-miri-inside-of-you
+#![feature(core_intrinsics)]
+#![feature(const_heap)]
+use std::intrinsics;
+
+const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
+//~^ error: mutable pointer in final value of constant
+//~| error: encountered `const_allocate` pointer in final value that was not made global
+
+fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.stderr b/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.stderr
new file mode 100644
index 00000000000..eae79d24797
--- /dev/null
+++ b/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.stderr
@@ -0,0 +1,16 @@
+error: encountered `const_allocate` pointer in final value that was not made global
+  --> $DIR/ptr_not_made_global_mut.rs:8:1
+   |
+LL | const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: use `const_make_global` to make allocated pointers immutable before returning
+
+error: encountered mutable pointer in final value of constant
+  --> $DIR/ptr_not_made_global_mut.rs:8:1
+   |
+LL | const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
+   | ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 078332fdc8e11f7ff8253c019085098538ec3c2a Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <code@alona.page>
Date: Fri, 20 Jun 2025 02:48:15 +0000
Subject: rustdoc-json: Structured attributes

Implements https://www.github.com/rust-lang/rust/issues/141358.

This has 2 primary benefits:

1. For rustdoc-json consumers, they no longer need to parse strings of
   attributes, but it's there in a structured and normalized way.
2. For rustc contributors, the output of HIR pretty printing is no
   longer a versioned thing in the output. People can work on
   https://github.com/rust-lang/rust/issues/131229 without needing to
   bump `FORMAT_VERSION`.

(Over time, as the attribute refractor continues, I expect we'll add new
things to `rustdoc_json_types::Attribute`. But this can be done
separately to the rustc changes).
---
 src/librustdoc/clean/types.rs                      | 80 ++++++-----------
 src/librustdoc/html/render/mod.rs                  |  6 +-
 src/librustdoc/html/render/print_item.rs           |  3 +-
 src/librustdoc/json/conversions.rs                 | 99 +++++++++++++++++++++-
 src/rustdoc-json-types/lib.rs                      | 89 ++++++++++++++++++-
 tests/rustdoc-json/attrs/automatically_derived.rs  |  2 +-
 tests/rustdoc-json/attrs/cold.rs                   |  2 +-
 tests/rustdoc-json/attrs/export_name_2021.rs       |  2 +-
 tests/rustdoc-json/attrs/export_name_2024.rs       |  4 +-
 tests/rustdoc-json/attrs/inline.rs                 |  6 +-
 tests/rustdoc-json/attrs/link_section_2021.rs      |  3 +-
 tests/rustdoc-json/attrs/link_section_2024.rs      |  3 +-
 tests/rustdoc-json/attrs/must_use.rs               |  4 +-
 tests/rustdoc-json/attrs/no_mangle_2021.rs         |  2 +-
 tests/rustdoc-json/attrs/no_mangle_2024.rs         |  2 +-
 tests/rustdoc-json/attrs/non_exhaustive.rs         |  6 +-
 tests/rustdoc-json/attrs/optimize.rs               |  6 +-
 tests/rustdoc-json/attrs/repr_align.rs             |  3 +-
 tests/rustdoc-json/attrs/repr_c.rs                 | 18 +++-
 tests/rustdoc-json/attrs/repr_c_int_enum.rs        | 11 +++
 tests/rustdoc-json/attrs/repr_combination.rs       | 25 +++---
 tests/rustdoc-json/attrs/repr_int_enum.rs          | 15 +++-
 tests/rustdoc-json/attrs/repr_packed.rs            |  8 +-
 tests/rustdoc-json/attrs/target_feature.rs         | 25 ++++--
 tests/rustdoc-json/enums/discriminant/struct.rs    |  2 +-
 tests/rustdoc-json/enums/discriminant/tuple.rs     |  2 +-
 tests/rustdoc-json/keyword_private.rs              |  4 +-
 .../visibility/doc_hidden_documented.rs            |  6 +-
 28 files changed, 316 insertions(+), 122 deletions(-)
 create mode 100644 tests/rustdoc-json/attrs/repr_c_int_enum.rs

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 3ecd41db2dd..20babc6168b 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -759,79 +759,48 @@ impl Item {
         Some(tcx.visibility(def_id))
     }
 
-    fn attributes_without_repr(&self, tcx: TyCtxt<'_>, is_json: bool) -> Vec<String> {
-        const ALLOWED_ATTRIBUTES: &[Symbol] =
-            &[sym::export_name, sym::link_section, sym::no_mangle, sym::non_exhaustive];
+    /// Get a list of attributes excluding `#[repr]` to display.
+    ///
+    /// Only used by the HTML output-format.
+    fn attributes_without_repr(&self) -> Vec<String> {
         self.attrs
             .other_attrs
             .iter()
-            .filter_map(|attr| {
-                if let hir::Attribute::Parsed(AttributeKind::LinkSection { name, .. }) = attr {
+            .filter_map(|attr| match attr {
+                hir::Attribute::Parsed(AttributeKind::LinkSection { name, .. }) => {
                     Some(format!("#[link_section = \"{name}\"]"))
                 }
-                // NoMangle is special cased, as it appears in HTML output, and we want to show it in source form, not HIR printing.
-                // It is also used by cargo-semver-checks.
-                else if let hir::Attribute::Parsed(AttributeKind::NoMangle(..)) = attr {
+                hir::Attribute::Parsed(AttributeKind::NoMangle(..)) => {
                     Some("#[no_mangle]".to_string())
-                } else if let hir::Attribute::Parsed(AttributeKind::ExportName { name, .. }) = attr
-                {
+                }
+                hir::Attribute::Parsed(AttributeKind::ExportName { name, .. }) => {
                     Some(format!("#[export_name = \"{name}\"]"))
-                } else if let hir::Attribute::Parsed(AttributeKind::NonExhaustive(..)) = attr {
+                }
+                hir::Attribute::Parsed(AttributeKind::NonExhaustive(..)) => {
                     Some("#[non_exhaustive]".to_string())
-                } else if is_json {
-                    match attr {
-                        // rustdoc-json stores this in `Item::deprecation`, so we
-                        // don't want it it `Item::attrs`.
-                        hir::Attribute::Parsed(AttributeKind::Deprecation { .. }) => None,
-                        // We have separate pretty-printing logic for `#[repr(..)]` attributes.
-                        hir::Attribute::Parsed(AttributeKind::Repr { .. }) => None,
-                        // target_feature is special-cased because cargo-semver-checks uses it
-                        hir::Attribute::Parsed(AttributeKind::TargetFeature(features, _)) => {
-                            let mut output = String::new();
-                            for (i, (feature, _)) in features.iter().enumerate() {
-                                if i != 0 {
-                                    output.push_str(", ");
-                                }
-                                output.push_str(&format!("enable=\"{}\"", feature.as_str()));
-                            }
-                            Some(format!("#[target_feature({output})]"))
-                        }
-                        hir::Attribute::Parsed(AttributeKind::AutomaticallyDerived(..)) => {
-                            Some("#[automatically_derived]".to_string())
-                        }
-                        _ => Some({
-                            let mut s = rustc_hir_pretty::attribute_to_string(&tcx, attr);
-                            assert_eq!(s.pop(), Some('\n'));
-                            s
-                        }),
-                    }
-                } else {
-                    if !attr.has_any_name(ALLOWED_ATTRIBUTES) {
-                        return None;
-                    }
-                    Some(
-                        rustc_hir_pretty::attribute_to_string(&tcx, attr)
-                            .replace("\\\n", "")
-                            .replace('\n', "")
-                            .replace("  ", " "),
-                    )
                 }
+                _ => None,
             })
             .collect()
     }
 
-    pub(crate) fn attributes(&self, tcx: TyCtxt<'_>, cache: &Cache, is_json: bool) -> Vec<String> {
-        let mut attrs = self.attributes_without_repr(tcx, is_json);
+    /// Get a list of attributes to display on this item.
+    ///
+    /// Only used by the HTML output-format.
+    pub(crate) fn attributes(&self, tcx: TyCtxt<'_>, cache: &Cache) -> Vec<String> {
+        let mut attrs = self.attributes_without_repr();
 
-        if let Some(repr_attr) = self.repr(tcx, cache, is_json) {
+        if let Some(repr_attr) = self.repr(tcx, cache) {
             attrs.push(repr_attr);
         }
         attrs
     }
 
     /// Returns a stringified `#[repr(...)]` attribute.
-    pub(crate) fn repr(&self, tcx: TyCtxt<'_>, cache: &Cache, is_json: bool) -> Option<String> {
-        repr_attributes(tcx, cache, self.def_id()?, self.type_(), is_json)
+    ///
+    /// Only used by the HTML output-format.
+    pub(crate) fn repr(&self, tcx: TyCtxt<'_>, cache: &Cache) -> Option<String> {
+        repr_attributes(tcx, cache, self.def_id()?, self.type_())
     }
 
     pub fn is_doc_hidden(&self) -> bool {
@@ -843,12 +812,14 @@ impl Item {
     }
 }
 
+/// Return a string representing the `#[repr]` attribute if present.
+///
+/// Only used by the HTML output-format.
 pub(crate) fn repr_attributes(
     tcx: TyCtxt<'_>,
     cache: &Cache,
     def_id: DefId,
     item_type: ItemType,
-    is_json: bool,
 ) -> Option<String> {
     use rustc_abi::IntegerType;
 
@@ -865,7 +836,6 @@ pub(crate) fn repr_attributes(
         // Render `repr(transparent)` iff the non-1-ZST field is public or at least one
         // field is public in case all fields are 1-ZST fields.
         let render_transparent = cache.document_private
-            || is_json
             || adt
                 .all_fields()
                 .find(|field| {
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 70f3f54e4c0..06de4944d97 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -1191,7 +1191,7 @@ fn render_assoc_item(
 // a whitespace prefix and newline.
 fn render_attributes_in_pre(it: &clean::Item, prefix: &str, cx: &Context<'_>) -> impl fmt::Display {
     fmt::from_fn(move |f| {
-        for a in it.attributes(cx.tcx(), cx.cache(), false) {
+        for a in it.attributes(cx.tcx(), cx.cache()) {
             writeln!(f, "{prefix}{a}")?;
         }
         Ok(())
@@ -1207,7 +1207,7 @@ fn render_code_attribute(code_attr: CodeAttribute, w: &mut impl fmt::Write) {
 // When an attribute is rendered inside a <code> tag, it is formatted using
 // a div to produce a newline after it.
 fn render_attributes_in_code(w: &mut impl fmt::Write, it: &clean::Item, cx: &Context<'_>) {
-    for attr in it.attributes(cx.tcx(), cx.cache(), false) {
+    for attr in it.attributes(cx.tcx(), cx.cache()) {
         render_code_attribute(CodeAttribute(attr), w);
     }
 }
@@ -1219,7 +1219,7 @@ fn render_repr_attributes_in_code(
     def_id: DefId,
     item_type: ItemType,
 ) {
-    if let Some(repr) = clean::repr_attributes(cx.tcx(), cx.cache(), def_id, item_type, false) {
+    if let Some(repr) = clean::repr_attributes(cx.tcx(), cx.cache(), def_id, item_type) {
         render_code_attribute(CodeAttribute(repr), w);
     }
 }
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index e33bdc0db32..667d39e9bc2 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -1487,12 +1487,11 @@ impl<'a, 'cx: 'a> ItemUnion<'a, 'cx> {
                     self.cx.cache(),
                     self.def_id,
                     ItemType::Union,
-                    false,
                 ) {
                     writeln!(f, "{repr}")?;
                 };
             } else {
-                for a in self.it.attributes(self.cx.tcx(), self.cx.cache(), false) {
+                for a in self.it.attributes(self.cx.tcx(), self.cx.cache()) {
                     writeln!(f, "{a}")?;
                 }
             }
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index e7163bead92..0a84d8caa30 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -5,10 +5,12 @@
 use rustc_abi::ExternAbi;
 use rustc_ast::ast;
 use rustc_attr_data_structures::{self as attrs, DeprecatedSince};
+use rustc_hir as hir;
 use rustc_hir::def::CtorKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{HeaderSafety, Safety};
 use rustc_metadata::rendered_const;
+use rustc_middle::ty::TyCtxt;
 use rustc_middle::{bug, ty};
 use rustc_span::{Pos, kw, sym};
 use rustdoc_json_types::*;
@@ -39,7 +41,12 @@ impl JsonRenderer<'_> {
             })
             .collect();
         let docs = item.opt_doc_value();
-        let attrs = item.attributes(self.tcx, &self.cache, true);
+        let attrs = item
+            .attrs
+            .other_attrs
+            .iter()
+            .filter_map(|a| maybe_from_hir_attr(a, item.item_id, self.tcx))
+            .collect();
         let span = item.span(self.tcx);
         let visibility = item.visibility(self.tcx);
         let clean::ItemInner { name, item_id, .. } = *item.inner;
@@ -886,3 +893,93 @@ impl FromClean<ItemType> for ItemKind {
         }
     }
 }
+
+/// Maybe convert a attribute from hir to json.
+///
+/// Returns `None` if the attribute shouldn't be in the output.
+fn maybe_from_hir_attr(
+    attr: &hir::Attribute,
+    item_id: ItemId,
+    tcx: TyCtxt<'_>,
+) -> Option<Attribute> {
+    use attrs::AttributeKind as AK;
+
+    let kind = match attr {
+        hir::Attribute::Parsed(kind) => kind,
+
+        hir::Attribute::Unparsed(_) => {
+            // FIXME: We should handle `#[doc(hidden)]`.
+            return Some(other_attr(tcx, attr));
+        }
+    };
+
+    Some(match kind {
+        AK::Deprecation { .. } => return None, // Handled separately into Item::deprecation.
+        AK::DocComment { .. } => unreachable!("doc comments stripped out earlier"),
+
+        AK::MustUse { reason, span: _ } => {
+            Attribute::MustUse { reason: reason.map(|s| s.to_string()) }
+        }
+        AK::Repr { .. } => repr_attr(
+            tcx,
+            item_id.as_def_id().expect("all items that could have #[repr] have a DefId"),
+        ),
+        AK::ExportName { name, span: _ } => Attribute::ExportName(name.to_string()),
+        AK::LinkSection { name, span: _ } => Attribute::LinkSection(name.to_string()),
+        AK::TargetFeature(features, _span) => Attribute::TargetFeature {
+            enable: features.iter().map(|(feat, _span)| feat.to_string()).collect(),
+        },
+
+        AK::NoMangle(_) => Attribute::NoMangle,
+        AK::NonExhaustive(_) => Attribute::NonExhaustive,
+        AK::AutomaticallyDerived(_) => Attribute::AutomaticallyDerived,
+
+        _ => other_attr(tcx, attr),
+    })
+}
+
+fn other_attr(tcx: TyCtxt<'_>, attr: &hir::Attribute) -> Attribute {
+    let mut s = rustc_hir_pretty::attribute_to_string(&tcx, attr);
+    assert_eq!(s.pop(), Some('\n'));
+    Attribute::Other(s)
+}
+
+fn repr_attr(tcx: TyCtxt<'_>, def_id: DefId) -> Attribute {
+    let repr = tcx.adt_def(def_id).repr();
+
+    let kind = if repr.c() {
+        ReprKind::C
+    } else if repr.transparent() {
+        ReprKind::Transparent
+    } else if repr.simd() {
+        ReprKind::Simd
+    } else {
+        ReprKind::Rust
+    };
+
+    let align = repr.align.map(|a| a.bytes());
+    let packed = repr.pack.map(|p| p.bytes());
+    let int = repr.int.map(format_integer_type);
+
+    Attribute::Repr(AttributeRepr { kind, align, packed, int })
+}
+
+fn format_integer_type(it: rustc_abi::IntegerType) -> String {
+    use rustc_abi::Integer::*;
+    use rustc_abi::IntegerType::*;
+    match it {
+        Pointer(true) => "isize",
+        Pointer(false) => "usize",
+        Fixed(I8, true) => "i8",
+        Fixed(I8, false) => "u8",
+        Fixed(I16, true) => "i16",
+        Fixed(I16, false) => "u16",
+        Fixed(I32, true) => "i32",
+        Fixed(I32, false) => "u32",
+        Fixed(I64, true) => "i64",
+        Fixed(I64, false) => "u64",
+        Fixed(I128, true) => "i128",
+        Fixed(I128, false) => "u128",
+    }
+    .to_owned()
+}
diff --git a/src/rustdoc-json-types/lib.rs b/src/rustdoc-json-types/lib.rs
index 0e72ddd9db1..6235b0e8576 100644
--- a/src/rustdoc-json-types/lib.rs
+++ b/src/rustdoc-json-types/lib.rs
@@ -37,8 +37,8 @@ pub type FxHashMap<K, V> = HashMap<K, V>; // re-export for use in src/librustdoc
 // will instead cause conflicts. See #94591 for more. (This paragraph and the "Latest feature" line
 // are deliberately not in a doc comment, because they need not be in public docs.)
 //
-// Latest feature: Pretty printing of no_mangle attributes changed
-pub const FORMAT_VERSION: u32 = 53;
+// Latest feature: Structured Attributes
+pub const FORMAT_VERSION: u32 = 54;
 
 /// The root of the emitted JSON blob.
 ///
@@ -195,13 +195,94 @@ pub struct Item {
     /// - `#[repr(C)]` and other reprs also appear as themselves,
     ///   though potentially with a different order: e.g. `repr(i8, C)` may become `repr(C, i8)`.
     ///   Multiple repr attributes on the same item may be combined into an equivalent single attr.
-    pub attrs: Vec<String>,
+    pub attrs: Vec<Attribute>,
     /// Information about the item’s deprecation, if present.
     pub deprecation: Option<Deprecation>,
     /// The type-specific fields describing this item.
     pub inner: ItemEnum,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+/// An attribute, e.g. `#[repr(C)]`
+///
+/// This doesn't include:
+/// - `#[doc = "Doc Comment"]` or `/// Doc comment`. These are in [`Item::docs`] instead.
+/// - `#[deprecated]`. These are in [`Item::deprecation`] instead.
+pub enum Attribute {
+    /// `#[non_exhaustive]`
+    NonExhaustive,
+
+    /// `#[must_use]`
+    MustUse { reason: Option<String> },
+
+    /// `#[export_name = "name"]`
+    ExportName(String),
+
+    /// `#[link_section = "name"]`
+    LinkSection(String),
+
+    /// `#[automatically_derived]`
+    AutomaticallyDerived,
+
+    /// `#[repr]`
+    Repr(AttributeRepr),
+
+    /// `#[no_mangle]`
+    NoMangle,
+
+    /// #[target_feature(enable = "feature1", enable = "feature2")]
+    TargetFeature { enable: Vec<String> },
+
+    /// Something else.
+    ///
+    /// Things here are explicitly *not* covered by the [`FORMAT_VERSION`]
+    /// constant, and may change without bumping the format version.
+    ///
+    /// As an implementation detail, this is currently either:
+    /// 1. A HIR debug printing, like `"#[attr = Optimize(Speed)]"`
+    /// 2. The attribute as it appears in source form, like
+    ///    `"#[optimize(speed)]"`.
+    Other(String),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+/// The contents of a `#[repr(...)]` attribute.
+///
+/// Used in [`Attribute::Repr`].
+pub struct AttributeRepr {
+    /// The representation, e.g. `#[repr(C)]`, `#[repr(transparent)]`
+    pub kind: ReprKind,
+
+    /// Alignment in bytes, if explicitly specified by `#[repr(align(...)]`.
+    pub align: Option<u64>,
+    /// Alignment in bytes, if explicitly specified by `#[repr(packed(...)]]`.
+    pub packed: Option<u64>,
+
+    /// The integer type for an enum descriminant, if explicitly specified.
+    ///
+    /// e.g. `"i32"`, for `#[repr(C, i32)]`
+    pub int: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+/// The kind of `#[repr]`.
+///
+/// See [AttributeRepr::kind]`.
+pub enum ReprKind {
+    /// `#[repr(Rust)]`
+    ///
+    /// Also the default.
+    Rust,
+    /// `#[repr(C)]`
+    C,
+    /// `#[repr(transparent)]
+    Transparent,
+    /// `#[repr(simd)]`
+    Simd,
+}
+
 /// A range of source code.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct Span {
@@ -1343,7 +1424,7 @@ pub struct Static {
 
     /// Is the static `unsafe`?
     ///
-    /// This is only true if it's in an `extern` block, and not explicity marked
+    /// This is only true if it's in an `extern` block, and not explicitly marked
     /// as `safe`.
     ///
     /// ```rust
diff --git a/tests/rustdoc-json/attrs/automatically_derived.rs b/tests/rustdoc-json/attrs/automatically_derived.rs
index 4e1ab3d145e..9ba310d3655 100644
--- a/tests/rustdoc-json/attrs/automatically_derived.rs
+++ b/tests/rustdoc-json/attrs/automatically_derived.rs
@@ -9,5 +9,5 @@ impl Default for Manual {
     }
 }
 
-//@ is '$.index[?(@.inner.impl.for.resolved_path.path == "Derive" && @.inner.impl.trait.path == "Default")].attrs' '["#[automatically_derived]"]'
+//@ is '$.index[?(@.inner.impl.for.resolved_path.path == "Derive" && @.inner.impl.trait.path == "Default")].attrs' '["automatically_derived"]'
 //@ is '$.index[?(@.inner.impl.for.resolved_path.path == "Manual" && @.inner.impl.trait.path == "Default")].attrs' '[]'
diff --git a/tests/rustdoc-json/attrs/cold.rs b/tests/rustdoc-json/attrs/cold.rs
index e219345d669..ec1926e894e 100644
--- a/tests/rustdoc-json/attrs/cold.rs
+++ b/tests/rustdoc-json/attrs/cold.rs
@@ -1,3 +1,3 @@
-//@ is "$.index[?(@.name=='cold_fn')].attrs" '["#[attr = Cold]"]'
+//@ is "$.index[?(@.name=='cold_fn')].attrs" '[{"other": "#[attr = Cold]"}]'
 #[cold]
 pub fn cold_fn() {}
diff --git a/tests/rustdoc-json/attrs/export_name_2021.rs b/tests/rustdoc-json/attrs/export_name_2021.rs
index 254e9f6ef5b..451d9b9eb37 100644
--- a/tests/rustdoc-json/attrs/export_name_2021.rs
+++ b/tests/rustdoc-json/attrs/export_name_2021.rs
@@ -1,6 +1,6 @@
 //@ edition: 2021
 #![no_std]
 
-//@ is "$.index[?(@.name=='example')].attrs" '["#[export_name = \"altered\"]"]'
+//@ is "$.index[?(@.name=='example')].attrs" '[{"export_name": "altered"}]'
 #[export_name = "altered"]
 pub extern "C" fn example() {}
diff --git a/tests/rustdoc-json/attrs/export_name_2024.rs b/tests/rustdoc-json/attrs/export_name_2024.rs
index 8129c109306..7e398db92ab 100644
--- a/tests/rustdoc-json/attrs/export_name_2024.rs
+++ b/tests/rustdoc-json/attrs/export_name_2024.rs
@@ -2,8 +2,8 @@
 #![no_std]
 
 // The representation of `#[unsafe(export_name = ..)]` in rustdoc in edition 2024
-// is still `#[export_name = ..]` without the `unsafe` attribute wrapper.
+// doesn't mention the `unsafe`.
 
-//@ is "$.index[?(@.name=='example')].attrs" '["#[export_name = \"altered\"]"]'
+//@ is "$.index[?(@.name=='example')].attrs" '[{"export_name": "altered"}]'
 #[unsafe(export_name = "altered")]
 pub extern "C" fn example() {}
diff --git a/tests/rustdoc-json/attrs/inline.rs b/tests/rustdoc-json/attrs/inline.rs
index b9ea6ab1d10..2aed49a48a5 100644
--- a/tests/rustdoc-json/attrs/inline.rs
+++ b/tests/rustdoc-json/attrs/inline.rs
@@ -1,11 +1,11 @@
-//@ is "$.index[?(@.name=='just_inline')].attrs" '["#[attr = Inline(Hint)]"]'
+//@ is "$.index[?(@.name=='just_inline')].attrs" '[{"other": "#[attr = Inline(Hint)]"}]'
 #[inline]
 pub fn just_inline() {}
 
-//@ is "$.index[?(@.name=='inline_always')].attrs" '["#[attr = Inline(Always)]"]'
+//@ is "$.index[?(@.name=='inline_always')].attrs" '[{"other": "#[attr = Inline(Always)]"}]'
 #[inline(always)]
 pub fn inline_always() {}
 
-//@ is "$.index[?(@.name=='inline_never')].attrs" '["#[attr = Inline(Never)]"]'
+//@ is "$.index[?(@.name=='inline_never')].attrs" '[{"other": "#[attr = Inline(Never)]"}]'
 #[inline(never)]
 pub fn inline_never() {}
diff --git a/tests/rustdoc-json/attrs/link_section_2021.rs b/tests/rustdoc-json/attrs/link_section_2021.rs
index a1312f4210b..acd8ecd0e30 100644
--- a/tests/rustdoc-json/attrs/link_section_2021.rs
+++ b/tests/rustdoc-json/attrs/link_section_2021.rs
@@ -1,6 +1,7 @@
 //@ edition: 2021
 #![no_std]
 
-//@ is "$.index[?(@.name=='example')].attrs" '["#[link_section = \".text\"]"]'
+//@ count "$.index[?(@.name=='example')].attrs[*]" 1
+//@ is "$.index[?(@.name=='example')].attrs[*].link_section" '".text"'
 #[link_section = ".text"]
 pub extern "C" fn example() {}
diff --git a/tests/rustdoc-json/attrs/link_section_2024.rs b/tests/rustdoc-json/attrs/link_section_2024.rs
index edb028451a8..8107493229b 100644
--- a/tests/rustdoc-json/attrs/link_section_2024.rs
+++ b/tests/rustdoc-json/attrs/link_section_2024.rs
@@ -4,6 +4,7 @@
 // Since the 2024 edition the link_section attribute must use the unsafe qualification.
 // However, the unsafe qualification is not shown by rustdoc.
 
-//@ is "$.index[?(@.name=='example')].attrs" '["#[link_section = \".text\"]"]'
+//@ count "$.index[?(@.name=='example')].attrs[*]" 1
+//@ is "$.index[?(@.name=='example')].attrs[*].link_section" '".text"'
 #[unsafe(link_section = ".text")]
 pub extern "C" fn example() {}
diff --git a/tests/rustdoc-json/attrs/must_use.rs b/tests/rustdoc-json/attrs/must_use.rs
index 3ca6f5a75a5..3f924c5169c 100644
--- a/tests/rustdoc-json/attrs/must_use.rs
+++ b/tests/rustdoc-json/attrs/must_use.rs
@@ -1,9 +1,9 @@
 #![no_std]
 
-//@ is "$.index[?(@.name=='example')].attrs" '["#[attr = MustUse]"]'
+//@ is "$.index[?(@.name=='example')].attrs[*].must_use.reason" null
 #[must_use]
 pub fn example() -> impl Iterator<Item = i64> {}
 
-//@ is "$.index[?(@.name=='explicit_message')].attrs" '["#[attr = MustUse {reason: \"does nothing if you do not use it\"}]"]'
+//@ is "$.index[?(@.name=='explicit_message')].attrs[*].must_use.reason" '"does nothing if you do not use it"'
 #[must_use = "does nothing if you do not use it"]
 pub fn explicit_message() -> impl Iterator<Item = i64> {}
diff --git a/tests/rustdoc-json/attrs/no_mangle_2021.rs b/tests/rustdoc-json/attrs/no_mangle_2021.rs
index 588be7256db..703dcb56491 100644
--- a/tests/rustdoc-json/attrs/no_mangle_2021.rs
+++ b/tests/rustdoc-json/attrs/no_mangle_2021.rs
@@ -1,6 +1,6 @@
 //@ edition: 2021
 #![no_std]
 
-//@ is "$.index[?(@.name=='example')].attrs" '["#[no_mangle]"]'
+//@ is "$.index[?(@.name=='example')].attrs" '["no_mangle"]'
 #[no_mangle]
 pub extern "C" fn example() {}
diff --git a/tests/rustdoc-json/attrs/no_mangle_2024.rs b/tests/rustdoc-json/attrs/no_mangle_2024.rs
index 0d500e20e6c..8af00eeda6b 100644
--- a/tests/rustdoc-json/attrs/no_mangle_2024.rs
+++ b/tests/rustdoc-json/attrs/no_mangle_2024.rs
@@ -4,6 +4,6 @@
 // The representation of `#[unsafe(no_mangle)]` in rustdoc in edition 2024
 // is still `#[no_mangle]` without the `unsafe` attribute wrapper.
 
-//@ is "$.index[?(@.name=='example')].attrs" '["#[no_mangle]"]'
+//@ is "$.index[?(@.name=='example')].attrs" '["no_mangle"]'
 #[unsafe(no_mangle)]
 pub extern "C" fn example() {}
diff --git a/tests/rustdoc-json/attrs/non_exhaustive.rs b/tests/rustdoc-json/attrs/non_exhaustive.rs
index b95f1a8171f..e4e6c8fd53b 100644
--- a/tests/rustdoc-json/attrs/non_exhaustive.rs
+++ b/tests/rustdoc-json/attrs/non_exhaustive.rs
@@ -1,18 +1,18 @@
 #![no_std]
 
-//@ is "$.index[?(@.name=='MyEnum')].attrs" '["#[non_exhaustive]"]'
+//@ is "$.index[?(@.name=='MyEnum')].attrs" '["non_exhaustive"]'
 #[non_exhaustive]
 pub enum MyEnum {
     First,
 }
 
 pub enum NonExhaustiveVariant {
-    //@ is "$.index[?(@.name=='Variant')].attrs" '["#[non_exhaustive]"]'
+    //@ is "$.index[?(@.name=='Variant')].attrs" '["non_exhaustive"]'
     #[non_exhaustive]
     Variant(i64),
 }
 
-//@ is "$.index[?(@.name=='MyStruct')].attrs" '["#[non_exhaustive]"]'
+//@ is "$.index[?(@.name=='MyStruct')].attrs" '["non_exhaustive"]'
 #[non_exhaustive]
 pub struct MyStruct {
     pub x: i64,
diff --git a/tests/rustdoc-json/attrs/optimize.rs b/tests/rustdoc-json/attrs/optimize.rs
index 0bed0ad18c3..5988120ab2f 100644
--- a/tests/rustdoc-json/attrs/optimize.rs
+++ b/tests/rustdoc-json/attrs/optimize.rs
@@ -1,13 +1,13 @@
 #![feature(optimize_attribute)]
 
-//@ is "$.index[?(@.name=='speed')].attrs" '["#[attr = Optimize(Speed)]"]'
+//@ is "$.index[?(@.name=='speed')].attrs" '[{"other": "#[attr = Optimize(Speed)]"}]'
 #[optimize(speed)]
 pub fn speed() {}
 
-//@ is "$.index[?(@.name=='size')].attrs" '["#[attr = Optimize(Size)]"]'
+//@ is "$.index[?(@.name=='size')].attrs" '[{"other": "#[attr = Optimize(Size)]"}]'
 #[optimize(size)]
 pub fn size() {}
 
-//@ is "$.index[?(@.name=='none')].attrs" '["#[attr = Optimize(DoNotOptimize)]"]'
+//@ is "$.index[?(@.name=='none')].attrs" '[{"other": "#[attr = Optimize(DoNotOptimize)]"}]'
 #[optimize(none)]
 pub fn none() {}
diff --git a/tests/rustdoc-json/attrs/repr_align.rs b/tests/rustdoc-json/attrs/repr_align.rs
index c6debda7f1c..f9d3417c485 100644
--- a/tests/rustdoc-json/attrs/repr_align.rs
+++ b/tests/rustdoc-json/attrs/repr_align.rs
@@ -1,6 +1,7 @@
 #![no_std]
 
-//@ is "$.index[?(@.name=='Aligned')].attrs" '["#[repr(align(4))]"]'
+//@ count "$.index[?(@.name=='Aligned')].attrs[*]" 1
+//@ is "$.index[?(@.name=='Aligned')].attrs[*].repr.align" 4
 #[repr(align(4))]
 pub struct Aligned {
     a: i8,
diff --git a/tests/rustdoc-json/attrs/repr_c.rs b/tests/rustdoc-json/attrs/repr_c.rs
index e6219413f30..89dbc16cb2a 100644
--- a/tests/rustdoc-json/attrs/repr_c.rs
+++ b/tests/rustdoc-json/attrs/repr_c.rs
@@ -1,16 +1,28 @@
 #![no_std]
 
-//@ is "$.index[?(@.name=='ReprCStruct')].attrs" '["#[repr(C)]"]'
+//@ count "$.index[?(@.name=='ReprCStruct')].attrs" 1
+//@ is "$.index[?(@.name=='ReprCStruct')].attrs[*].repr.kind" '"c"'
+//@ is "$.index[?(@.name=='ReprCStruct')].attrs[*].repr.int" null
+//@ is "$.index[?(@.name=='ReprCStruct')].attrs[*].repr.packed" null
+//@ is "$.index[?(@.name=='ReprCStruct')].attrs[*].repr.align" null
 #[repr(C)]
 pub struct ReprCStruct(pub i64);
 
-//@ is "$.index[?(@.name=='ReprCEnum')].attrs" '["#[repr(C)]"]'
+//@ count "$.index[?(@.name=='ReprCEnum')].attrs" 1
+//@ is "$.index[?(@.name=='ReprCEnum')].attrs[*].repr.kind" '"c"'
+//@ is "$.index[?(@.name=='ReprCEnum')].attrs[*].repr.int" null
+//@ is "$.index[?(@.name=='ReprCEnum')].attrs[*].repr.packed" null
+//@ is "$.index[?(@.name=='ReprCEnum')].attrs[*].repr.align" null
 #[repr(C)]
 pub enum ReprCEnum {
     First,
 }
 
-//@ is "$.index[?(@.name=='ReprCUnion')].attrs" '["#[repr(C)]"]'
+//@ count "$.index[?(@.name=='ReprCUnion')].attrs" 1
+//@ is "$.index[?(@.name=='ReprCUnion')].attrs[*].repr.kind" '"c"'
+//@ is "$.index[?(@.name=='ReprCUnion')].attrs[*].repr.int" null
+//@ is "$.index[?(@.name=='ReprCUnion')].attrs[*].repr.packed" null
+//@ is "$.index[?(@.name=='ReprCUnion')].attrs[*].repr.align" null
 #[repr(C)]
 pub union ReprCUnion {
     pub left: i64,
diff --git a/tests/rustdoc-json/attrs/repr_c_int_enum.rs b/tests/rustdoc-json/attrs/repr_c_int_enum.rs
new file mode 100644
index 00000000000..e90bcf2b5c6
--- /dev/null
+++ b/tests/rustdoc-json/attrs/repr_c_int_enum.rs
@@ -0,0 +1,11 @@
+//@ count "$.index[?(@.name=='Foo')].attrs" 1
+//@ is "$.index[?(@.name=='Foo')].attrs[*].repr.kind" '"c"'
+//@ is "$.index[?(@.name=='Foo')].attrs[*].repr.int" '"u8"'
+//@ is "$.index[?(@.name=='Foo')].attrs[*].repr.packed" null
+//@ is "$.index[?(@.name=='Foo')].attrs[*].repr.align" 16
+#[repr(C, u8)]
+#[repr(align(16))]
+pub enum Foo {
+    A(bool) = b'A',
+    B(char) = b'C',
+}
diff --git a/tests/rustdoc-json/attrs/repr_combination.rs b/tests/rustdoc-json/attrs/repr_combination.rs
index 6fe29c5eac0..bd4a8563b6f 100644
--- a/tests/rustdoc-json/attrs/repr_combination.rs
+++ b/tests/rustdoc-json/attrs/repr_combination.rs
@@ -1,35 +1,34 @@
 #![no_std]
 
 // Combinations of `#[repr(..)]` attributes.
-// Rustdoc JSON emits normalized output, regardless of the original source.
 
-//@ is "$.index[?(@.name=='ReprCI8')].attrs" '["#[repr(C, i8)]"]'
+//@ is "$.index[?(@.name=='ReprCI8')].attrs" '[{"repr":{"align":null,"int":"i8","kind":"c","packed":null}}]'
 #[repr(C, i8)]
 pub enum ReprCI8 {
     First,
 }
 
-//@ is "$.index[?(@.name=='SeparateReprCI16')].attrs" '["#[repr(C, i16)]"]'
+//@ is "$.index[?(@.name=='SeparateReprCI16')].attrs" '[{"repr":{"align":null,"int":"i16","kind":"c","packed":null}}]'
 #[repr(C)]
 #[repr(i16)]
 pub enum SeparateReprCI16 {
     First,
 }
 
-//@ is "$.index[?(@.name=='ReversedReprCUsize')].attrs" '["#[repr(C, usize)]"]'
+//@ is "$.index[?(@.name=='ReversedReprCUsize')].attrs" '[{"repr":{"align":null,"int":"usize","kind":"c","packed":null}}]'
 #[repr(usize, C)]
 pub enum ReversedReprCUsize {
     First,
 }
 
-//@ is "$.index[?(@.name=='ReprCPacked')].attrs" '["#[repr(C, packed(1))]"]'
+//@ is "$.index[?(@.name=='ReprCPacked')].attrs" '[{"repr":{"align":null,"int":null,"kind":"c","packed":1}}]'
 #[repr(C, packed)]
 pub struct ReprCPacked {
     a: i8,
     b: i64,
 }
 
-//@ is "$.index[?(@.name=='SeparateReprCPacked')].attrs" '["#[repr(C, packed(2))]"]'
+//@ is "$.index[?(@.name=='SeparateReprCPacked')].attrs" '[{"repr":{"align":null,"int":null,"kind":"c","packed":2}}]'
 #[repr(C)]
 #[repr(packed(2))]
 pub struct SeparateReprCPacked {
@@ -37,21 +36,21 @@ pub struct SeparateReprCPacked {
     b: i64,
 }
 
-//@ is "$.index[?(@.name=='ReversedReprCPacked')].attrs" '["#[repr(C, packed(2))]"]'
+//@ is "$.index[?(@.name=='ReversedReprCPacked')].attrs" '[{"repr":{"align":null,"int":null,"kind":"c","packed":2}}]'
 #[repr(packed(2), C)]
 pub struct ReversedReprCPacked {
     a: i8,
     b: i64,
 }
 
-//@ is "$.index[?(@.name=='ReprCAlign')].attrs" '["#[repr(C, align(16))]"]'
+//@ is "$.index[?(@.name=='ReprCAlign')].attrs" '[{"repr":{"align":16,"int":null,"kind":"c","packed":null}}]'
 #[repr(C, align(16))]
 pub struct ReprCAlign {
     a: i8,
     b: i64,
 }
 
-//@ is "$.index[?(@.name=='SeparateReprCAlign')].attrs" '["#[repr(C, align(2))]"]'
+//@ is "$.index[?(@.name=='SeparateReprCAlign')].attrs" '[{"repr":{"align":2,"int":null,"kind":"c","packed":null}}]'
 #[repr(C)]
 #[repr(align(2))]
 pub struct SeparateReprCAlign {
@@ -59,25 +58,25 @@ pub struct SeparateReprCAlign {
     b: i64,
 }
 
-//@ is "$.index[?(@.name=='ReversedReprCAlign')].attrs" '["#[repr(C, align(2))]"]'
+//@ is "$.index[?(@.name=='ReversedReprCAlign')].attrs" '[{"repr":{"align":2,"int":null,"kind":"c","packed":null}}]'
 #[repr(align(2), C)]
 pub struct ReversedReprCAlign {
     a: i8,
     b: i64,
 }
 
-//@ is "$.index[?(@.name=='AlignedExplicitRepr')].attrs" '["#[repr(C, align(16), isize)]"]'
+//@ is "$.index[?(@.name=='AlignedExplicitRepr')].attrs" '[{"repr":{"align":16,"int":"isize","kind":"c","packed":null}}]'
 #[repr(C, align(16), isize)]
 pub enum AlignedExplicitRepr {
     First,
 }
 
-//@ is "$.index[?(@.name=='ReorderedAlignedExplicitRepr')].attrs" '["#[repr(C, align(16), isize)]"]'
+//@ is "$.index[?(@.name=='ReorderedAlignedExplicitRepr')].attrs" '[{"repr":{"align":16,"int":"isize","kind":"c","packed":null}}]'
 #[repr(isize, C, align(16))]
 pub enum ReorderedAlignedExplicitRepr {
     First,
 }
 
-//@ is "$.index[?(@.name=='Transparent')].attrs" '["#[repr(transparent)]"]'
+//@ is "$.index[?(@.name=='Transparent')].attrs" '[{"repr":{"align":null,"int":null,"kind":"transparent","packed":null}}]'
 #[repr(transparent)]
 pub struct Transparent(i64);
diff --git a/tests/rustdoc-json/attrs/repr_int_enum.rs b/tests/rustdoc-json/attrs/repr_int_enum.rs
index 9b09f341d4f..79e17f53ad9 100644
--- a/tests/rustdoc-json/attrs/repr_int_enum.rs
+++ b/tests/rustdoc-json/attrs/repr_int_enum.rs
@@ -1,18 +1,27 @@
 #![no_std]
 
-//@ is "$.index[?(@.name=='I8')].attrs" '["#[repr(i8)]"]'
+//@ is "$.index[?(@.name=='I8')].attrs[*].repr.int" '"i8"'
+//@ is "$.index[?(@.name=='I8')].attrs[*].repr.kind" '"rust"'
+//@ is "$.index[?(@.name=='I8')].attrs[*].repr.align" null
+//@ is "$.index[?(@.name=='I8')].attrs[*].repr.packed" null
 #[repr(i8)]
 pub enum I8 {
     First,
 }
 
-//@ is "$.index[?(@.name=='I32')].attrs" '["#[repr(i32)]"]'
+//@ is "$.index[?(@.name=='I32')].attrs[*].repr.int" '"i32"'
+//@ is "$.index[?(@.name=='I32')].attrs[*].repr.kind" '"rust"'
+//@ is "$.index[?(@.name=='I32')].attrs[*].repr.align" null
+//@ is "$.index[?(@.name=='I32')].attrs[*].repr.packed" null
 #[repr(i32)]
 pub enum I32 {
     First,
 }
 
-//@ is "$.index[?(@.name=='Usize')].attrs" '["#[repr(usize)]"]'
+//@ is "$.index[?(@.name=='Usize')].attrs[*].repr.int" '"usize"'
+//@ is "$.index[?(@.name=='Usize')].attrs[*].repr.kind" '"rust"'
+//@ is "$.index[?(@.name=='Usize')].attrs[*].repr.align" null
+//@ is "$.index[?(@.name=='Usize')].attrs[*].repr.packed" null
 #[repr(usize)]
 pub enum Usize {
     First,
diff --git a/tests/rustdoc-json/attrs/repr_packed.rs b/tests/rustdoc-json/attrs/repr_packed.rs
index 9f3fd86c4b0..ab573835b45 100644
--- a/tests/rustdoc-json/attrs/repr_packed.rs
+++ b/tests/rustdoc-json/attrs/repr_packed.rs
@@ -1,16 +1,18 @@
 #![no_std]
 
 // Note the normalization:
-// `#[repr(packed)]` in source becomes `#[repr(packed(1))]` in rustdoc JSON.
+// `#[repr(packed)]` in source becomes `{"repr": {"packed": 1, ...}}` in rustdoc JSON.
 //
-//@ is "$.index[?(@.name=='Packed')].attrs" '["#[repr(packed(1))]"]'
+//@ is "$.index[?(@.name=='Packed')].attrs[*].repr.packed" 1
+//@ is "$.index[?(@.name=='Packed')].attrs[*].repr.kind" '"rust"'
 #[repr(packed)]
 pub struct Packed {
     a: i8,
     b: i64,
 }
 
-//@ is "$.index[?(@.name=='PackedAligned')].attrs" '["#[repr(packed(4))]"]'
+//@ is "$.index[?(@.name=='PackedAligned')].attrs[*].repr.packed" 4
+//@ is "$.index[?(@.name=='PackedAligned')].attrs[*].repr.kind" '"rust"'
 #[repr(packed(4))]
 pub struct PackedAligned {
     a: i8,
diff --git a/tests/rustdoc-json/attrs/target_feature.rs b/tests/rustdoc-json/attrs/target_feature.rs
index 01bc4f54d32..efe3752c166 100644
--- a/tests/rustdoc-json/attrs/target_feature.rs
+++ b/tests/rustdoc-json/attrs/target_feature.rs
@@ -1,38 +1,49 @@
-//@ is "$.index[?(@.name=='test1')].attrs" '["#[target_feature(enable=\"avx\")]"]'
 //@ is "$.index[?(@.name=='test1')].inner.function.header.is_unsafe" false
+//@ count "$.index[?(@.name=='test1')].attrs[*]" 1
+//@ is    "$.index[?(@.name=='test1')].attrs[*].target_feature.enable" '["avx"]'
 #[target_feature(enable = "avx")]
 pub fn test1() {}
 
-//@ is "$.index[?(@.name=='test2')].attrs" '["#[target_feature(enable=\"avx\", enable=\"avx2\")]"]'
 //@ is "$.index[?(@.name=='test2')].inner.function.header.is_unsafe" false
+//@ count "$.index[?(@.name=='test2')].attrs[*]" 1
+//@ is    "$.index[?(@.name=='test2')].attrs[*].target_feature.enable" '["avx", "avx2"]'
 #[target_feature(enable = "avx,avx2")]
 pub fn test2() {}
 
-//@ is "$.index[?(@.name=='test3')].attrs" '["#[target_feature(enable=\"avx\", enable=\"avx2\")]"]'
 //@ is "$.index[?(@.name=='test3')].inner.function.header.is_unsafe" false
+//@ count "$.index[?(@.name=='test3')].attrs[*]" 1
+//@ is    "$.index[?(@.name=='test3')].attrs[*].target_feature.enable" '["avx", "avx2"]'
 #[target_feature(enable = "avx", enable = "avx2")]
 pub fn test3() {}
 
-//@ is "$.index[?(@.name=='test4')].attrs" '["#[target_feature(enable=\"avx\", enable=\"avx2\", enable=\"avx512f\")]"]'
 //@ is "$.index[?(@.name=='test4')].inner.function.header.is_unsafe" false
+//@ count "$.index[?(@.name=='test4')].attrs[*]" 1
+//@ is    "$.index[?(@.name=='test4')].attrs[*].target_feature.enable" '["avx", "avx2", "avx512f"]'
 #[target_feature(enable = "avx", enable = "avx2,avx512f")]
 pub fn test4() {}
 
-//@ is "$.index[?(@.name=='test_unsafe_fn')].attrs" '["#[target_feature(enable=\"avx\")]"]'
+//@ count "$.index[?(@.name=='test5')].attrs[*]" 1
+//@ is    "$.index[?(@.name=='test5')].attrs[*].target_feature.enable" '["avx", "avx2"]'
+#[target_feature(enable = "avx")]
+#[target_feature(enable = "avx2")]
+pub fn test5() {}
+
 //@ is "$.index[?(@.name=='test_unsafe_fn')].inner.function.header.is_unsafe" true
+//@ count "$.index[?(@.name=='test_unsafe_fn')].attrs[*]" 1
+//@ is    "$.index[?(@.name=='test_unsafe_fn')].attrs[*].target_feature.enable" '["avx"]'
 #[target_feature(enable = "avx")]
 pub unsafe fn test_unsafe_fn() {}
 
 pub struct Example;
 
 impl Example {
-    //@ is "$.index[?(@.name=='safe_assoc_fn')].attrs" '["#[target_feature(enable=\"avx\")]"]'
     //@ is "$.index[?(@.name=='safe_assoc_fn')].inner.function.header.is_unsafe" false
+    //@ is "$.index[?(@.name=='safe_assoc_fn')].attrs[*].target_feature.enable" '["avx"]'
     #[target_feature(enable = "avx")]
     pub fn safe_assoc_fn() {}
 
-    //@ is "$.index[?(@.name=='unsafe_assoc_fn')].attrs" '["#[target_feature(enable=\"avx\")]"]'
     //@ is "$.index[?(@.name=='unsafe_assoc_fn')].inner.function.header.is_unsafe" true
+    //@ is "$.index[?(@.name=='unsafe_assoc_fn')].attrs[*].target_feature.enable" '["avx"]'
     #[target_feature(enable = "avx")]
     pub unsafe fn unsafe_assoc_fn() {}
 }
diff --git a/tests/rustdoc-json/enums/discriminant/struct.rs b/tests/rustdoc-json/enums/discriminant/struct.rs
index ea669e6a0b3..fed0e545798 100644
--- a/tests/rustdoc-json/enums/discriminant/struct.rs
+++ b/tests/rustdoc-json/enums/discriminant/struct.rs
@@ -1,5 +1,5 @@
 #[repr(i32)]
-//@ is "$.index[?(@.name=='Foo')].attrs" '["#[repr(i32)]"]'
+//@ is "$.index[?(@.name=='Foo')].attrs[*].repr.int" '"i32"'
 pub enum Foo {
     //@ is    "$.index[?(@.name=='Struct')].inner.variant.discriminant" null
     //@ count "$.index[?(@.name=='Struct')].inner.variant.kind.struct.fields[*]" 0
diff --git a/tests/rustdoc-json/enums/discriminant/tuple.rs b/tests/rustdoc-json/enums/discriminant/tuple.rs
index 1b8e791eb23..54bba76a063 100644
--- a/tests/rustdoc-json/enums/discriminant/tuple.rs
+++ b/tests/rustdoc-json/enums/discriminant/tuple.rs
@@ -1,5 +1,5 @@
 #[repr(u32)]
-//@ is "$.index[?(@.name=='Foo')].attrs" '["#[repr(u32)]"]'
+//@ is "$.index[?(@.name=='Foo')].attrs[*].repr.int" '"u32"'
 pub enum Foo {
     //@ is    "$.index[?(@.name=='Tuple')].inner.variant.discriminant" null
     //@ count "$.index[?(@.name=='Tuple')].inner.variant.kind.tuple[*]" 0
diff --git a/tests/rustdoc-json/keyword_private.rs b/tests/rustdoc-json/keyword_private.rs
index fea546c9fb6..3198fc2529e 100644
--- a/tests/rustdoc-json/keyword_private.rs
+++ b/tests/rustdoc-json/keyword_private.rs
@@ -5,7 +5,7 @@
 
 //@ !has "$.index[?(@.name=='match')]"
 //@ has  "$.index[?(@.name=='foo')]"
-//@ is   "$.index[?(@.name=='foo')].attrs" '["#[doc(keyword = \"match\")]"]'
+//@ is   "$.index[?(@.name=='foo')].attrs[*].other" '"#[doc(keyword = \"match\")]"'
 //@ is   "$.index[?(@.name=='foo')].docs" '"this is a test!"'
 #[doc(keyword = "match")]
 /// this is a test!
@@ -13,7 +13,7 @@ pub mod foo {}
 
 //@ !has "$.index[?(@.name=='break')]"
 //@ has "$.index[?(@.name=='bar')]"
-//@ is   "$.index[?(@.name=='bar')].attrs" '["#[doc(keyword = \"break\")]"]'
+//@ is   "$.index[?(@.name=='bar')].attrs[*].other" '"#[doc(keyword = \"break\")]"'
 //@ is   "$.index[?(@.name=='bar')].docs" '"hello"'
 #[doc(keyword = "break")]
 /// hello
diff --git a/tests/rustdoc-json/visibility/doc_hidden_documented.rs b/tests/rustdoc-json/visibility/doc_hidden_documented.rs
index 6e9ef48680b..f05e4f9d92d 100644
--- a/tests/rustdoc-json/visibility/doc_hidden_documented.rs
+++ b/tests/rustdoc-json/visibility/doc_hidden_documented.rs
@@ -1,15 +1,15 @@
 //@ compile-flags: --document-hidden-items
 #![no_std]
 
-//@ is "$.index[?(@.name=='func')].attrs" '["#[doc(hidden)]"]'
+//@ is "$.index[?(@.name=='func')].attrs" '[{"other": "#[doc(hidden)]"}]'
 #[doc(hidden)]
 pub fn func() {}
 
-//@ is "$.index[?(@.name=='Unit')].attrs" '["#[doc(hidden)]"]'
+//@ is "$.index[?(@.name=='Unit')].attrs" '[{"other": "#[doc(hidden)]"}]'
 #[doc(hidden)]
 pub struct Unit;
 
-//@ is "$.index[?(@.name=='hidden')].attrs" '["#[doc(hidden)]"]'
+//@ is "$.index[?(@.name=='hidden')].attrs" '[{"other": "#[doc(hidden)]"}]'
 #[doc(hidden)]
 pub mod hidden {
     //@ is "$.index[?(@.name=='Inner')].attrs" '[]'
-- 
cgit 1.4.1-3-g733a5


From 4f1b3e3afc47f94f00de6294d180e90aa260b67d Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Tue, 15 Jul 2025 19:44:31 +0200
Subject: Clarify comments

---
 src/bootstrap/src/core/build_steps/tool.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index df89eb1da20..4d2fa177765 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -196,6 +196,7 @@ impl Step for ToolBuild {
             Kind::Build,
             self.mode,
             self.tool,
+            // A stage N tool is built with the stage N-1 compiler.
             self.build_compiler.stage + 1,
             &self.build_compiler.host,
             &self.target,
@@ -366,7 +367,7 @@ pub(crate) fn get_tool_rustc_compiler(
 }
 
 /// Determines how to build a `ToolTarget`, i.e. which compiler should be used to compile it.
-/// The compiler stage is automatically auto-bumped if we need to cross-compile a stage 1 tool.
+/// The compiler stage is automatically bumped if we need to cross-compile a stage 1 tool.
 pub enum ToolTargetBuildMode {
     /// Build the tool using rustc that corresponds to the selected CLI stage.
     Build(TargetSelection),
@@ -399,7 +400,7 @@ pub(crate) fn get_tool_target_compiler(
         builder.compiler(build_compiler_stage, builder.host_target)
     } else {
         // If we are cross-compiling a stage 1 tool, we cannot do that with a stage 0 compiler,
-        // so we auto-bump the tool's stage to 2.
+        // so we auto-bump the tool's stage to 2, which means we need a stage 1 compiler.
         builder.compiler(build_compiler_stage.max(1), builder.host_target)
     };
     builder.std(compiler, target);
-- 
cgit 1.4.1-3-g733a5


From bbb114ef6198b1d2de4898f838b4ae3183c2db90 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sat, 12 Jul 2025 13:16:34 -0500
Subject: ci cleanup: rustdoc-gui-test now installs browser-ui-test

this removes the need for --unsafe-perm in the Dockerfile.
---
 src/build_helper/src/lib.rs                        |  1 +
 src/build_helper/src/npm.rs                        | 30 +++++++
 .../docker/host-x86_64/x86_64-gnu-miri/Dockerfile  |  8 --
 .../docker/host-x86_64/x86_64-gnu-tools/Dockerfile | 11 ---
 .../x86_64-gnu-tools/browser-ui-test.version       |  1 -
 src/tools/rustdoc-gui-test/src/main.rs             | 93 +++-------------------
 6 files changed, 44 insertions(+), 100 deletions(-)
 create mode 100644 src/build_helper/src/npm.rs
 delete mode 100644 src/ci/docker/host-x86_64/x86_64-gnu-tools/browser-ui-test.version

diff --git a/src/build_helper/src/lib.rs b/src/build_helper/src/lib.rs
index 05de8fd2d42..266eedc6245 100644
--- a/src/build_helper/src/lib.rs
+++ b/src/build_helper/src/lib.rs
@@ -5,6 +5,7 @@ pub mod drop_bomb;
 pub mod fs;
 pub mod git;
 pub mod metrics;
+pub mod npm;
 pub mod stage0_parser;
 pub mod targets;
 pub mod util;
diff --git a/src/build_helper/src/npm.rs b/src/build_helper/src/npm.rs
new file mode 100644
index 00000000000..dedef40978d
--- /dev/null
+++ b/src/build_helper/src/npm.rs
@@ -0,0 +1,30 @@
+use std::error::Error;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::{fs, io};
+
+/// Install an exact package version, and return the path of `node_modules`.
+pub fn install_one(
+    out_dir: &Path,
+    npm_bin: &Path,
+    pkg_name: &str,
+    pkg_version: &str,
+) -> Result<PathBuf, io::Error> {
+    let nm_path = out_dir.join("node_modules");
+    let _ = fs::create_dir(&nm_path);
+    let mut child = Command::new(npm_bin)
+        .arg("install")
+        .arg("--audit=false")
+        .arg("--fund=false")
+        .arg(format!("{pkg_name}@{pkg_version}"))
+        .current_dir(out_dir)
+        .spawn()?;
+    let exit_status = child.wait()?;
+    if !exit_status.success() {
+        eprintln!("npm install did not exit successfully");
+        return Err(io::Error::other(Box::<dyn Error + Send + Sync>::from(format!(
+            "npm install returned exit code {exit_status}"
+        ))));
+    }
+    Ok(nm_path)
+}
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 b937bc3e678..ad2ee85c7bb 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
@@ -46,12 +46,4 @@ ENV HOST_TARGET x86_64-unknown-linux-gnu
 
 COPY scripts/shared.sh /scripts/
 
-# For now, we need to use `--unsafe-perm=true` to go around an issue when npm tries
-# to create a new folder. For reference:
-# https://github.com/puppeteer/puppeteer/issues/375
-#
-# We also specify the version in case we need to update it to go around cache limitations.
-#
-# The `browser-ui-test.version` file is also used by bootstrap to emit warnings in case
-# the local version of the package is different than the one used by the CI.
 ENV SCRIPT /tmp/check-miri.sh ../x.py
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 e770c58bd9c..95357d22937 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,8 +76,6 @@ COPY scripts/nodejs.sh /scripts/
 RUN sh /scripts/nodejs.sh /node
 ENV PATH="/node/bin:${PATH}"
 
-COPY host-x86_64/x86_64-gnu-tools/browser-ui-test.version /tmp/
-
 ENV RUST_CONFIGURE_ARGS \
   --build=x86_64-unknown-linux-gnu \
   --save-toolstates=/tmp/toolstate/toolstates.json \
@@ -91,15 +89,6 @@ ENV HOST_TARGET x86_64-unknown-linux-gnu
 
 COPY scripts/shared.sh /scripts/
 
-# For now, we need to use `--unsafe-perm=true` to go around an issue when npm tries
-# to create a new folder. For reference:
-# https://github.com/puppeteer/puppeteer/issues/375
-#
-# We also specify the version in case we need to update it to go around cache limitations.
-#
-# The `browser-ui-test.version` file is also used by bootstrap to emit warnings in case
-# the local version of the package is different than the one used by the CI.
 ENV SCRIPT /tmp/checktools.sh ../x.py && \
-  npm install browser-ui-test@$(head -n 1 /tmp/browser-ui-test.version) --unsafe-perm=true && \
   python3 ../x.py check compiletest --set build.compiletest-use-stage0-libtest=true && \
   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-tools/browser-ui-test.version b/src/ci/docker/host-x86_64/x86_64-gnu-tools/browser-ui-test.version
deleted file mode 100644
index b9f8e558df4..00000000000
--- a/src/ci/docker/host-x86_64/x86_64-gnu-tools/browser-ui-test.version
+++ /dev/null
@@ -1 +0,0 @@
-0.21.1
\ No newline at end of file
diff --git a/src/tools/rustdoc-gui-test/src/main.rs b/src/tools/rustdoc-gui-test/src/main.rs
index 6461f38f527..bcec950a404 100644
--- a/src/tools/rustdoc-gui-test/src/main.rs
+++ b/src/tools/rustdoc-gui-test/src/main.rs
@@ -1,63 +1,15 @@
+use std::env;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::sync::Arc;
-use std::{env, fs};
 
+use build_helper::npm;
 use build_helper::util::try_run;
 use compiletest::directives::TestProps;
 use config::Config;
 
 mod config;
 
-fn get_browser_ui_test_version_inner(npm: &Path, global: bool) -> Option<String> {
-    let mut command = Command::new(&npm);
-    command.arg("list").arg("--parseable").arg("--long").arg("--depth=0");
-    if global {
-        command.arg("--global");
-    }
-    let lines = match command.output() {
-        Ok(output) => String::from_utf8_lossy(&output.stdout).into_owned(),
-        Err(e) => {
-            eprintln!(
-                "path to npm can be wrong, provided path: {npm:?}. Try to set npm path \
-            in bootstrap.toml in [build.npm]",
-            );
-            panic!("{:?}", e)
-        }
-    };
-    lines
-        .lines()
-        .find_map(|l| l.rsplit(':').next()?.strip_prefix("browser-ui-test@"))
-        .map(|v| v.to_owned())
-}
-
-fn get_browser_ui_test_version(npm: &Path) -> Option<String> {
-    get_browser_ui_test_version_inner(npm, false)
-        .or_else(|| get_browser_ui_test_version_inner(npm, true))
-}
-
-fn compare_browser_ui_test_version(installed_version: &str, src: &Path) {
-    match fs::read_to_string(
-        src.join("src/ci/docker/host-x86_64/x86_64-gnu-tools/browser-ui-test.version"),
-    ) {
-        Ok(v) => {
-            if v.trim() != installed_version {
-                eprintln!(
-                    "⚠️ Installed version of browser-ui-test (`{}`) is different than the \
-                     one used in the CI (`{}`)",
-                    installed_version, v
-                );
-                eprintln!(
-                    "You can install this version using `npm update browser-ui-test` or by using \
-                     `npm install browser-ui-test@{}`",
-                    v,
-                );
-            }
-        }
-        Err(e) => eprintln!("Couldn't find the CI browser-ui-test version: {:?}", e),
-    }
-}
-
 fn find_librs<P: AsRef<Path>>(path: P) -> Option<PathBuf> {
     for entry in walkdir::WalkDir::new(path) {
         let entry = entry.ok()?;
@@ -71,27 +23,6 @@ fn find_librs<P: AsRef<Path>>(path: P) -> Option<PathBuf> {
 fn main() -> Result<(), ()> {
     let config = Arc::new(Config::from_args(env::args().collect()));
 
-    // The goal here is to check if the necessary packages are installed, and if not, we
-    // panic.
-    match get_browser_ui_test_version(&config.npm) {
-        Some(version) => {
-            // We also check the version currently used in CI and emit a warning if it's not the
-            // same one.
-            compare_browser_ui_test_version(&version, &config.rust_src);
-        }
-        None => {
-            eprintln!(
-                r#"
-error: rustdoc-gui test suite cannot be run because npm `browser-ui-test` dependency is missing.
-
-If you want to install the `browser-ui-test` dependency, run `npm install browser-ui-test`
-"#,
-            );
-
-            panic!("Cannot run rustdoc-gui tests");
-        }
-    }
-
     let src_path = config.rust_src.join("tests/rustdoc-gui/src");
     for entry in src_path.read_dir().expect("read_dir call failed") {
         if let Ok(entry) = entry {
@@ -138,16 +69,12 @@ If you want to install the `browser-ui-test` dependency, run `npm install browse
         }
     }
 
-    let mut command = Command::new(&config.nodejs);
+    // FIXME(binarycat): once we get package.json in version control, this should be updated to install via that instead
+    let local_node_modules =
+        npm::install_one(&config.out_dir, &config.npm, "browser-ui-test", "0.21.1")
+            .expect("unable to install browser-ui-test");
 
-    if let Ok(current_dir) = env::current_dir() {
-        let local_node_modules = current_dir.join("node_modules");
-        if local_node_modules.exists() {
-            // Link the local node_modules if exists.
-            // This is useful when we run rustdoc-gui-test from outside of the source root.
-            env::set_var("NODE_PATH", local_node_modules);
-        }
-    }
+    let mut command = Command::new(&config.nodejs);
 
     command
         .arg(config.rust_src.join("src/tools/rustdoc-gui/tester.js"))
@@ -158,6 +85,12 @@ If you want to install the `browser-ui-test` dependency, run `npm install browse
         .arg("--tests-folder")
         .arg(config.rust_src.join("tests/rustdoc-gui"));
 
+    if local_node_modules.exists() {
+        // Link the local node_modules if exists.
+        // This is useful when we run rustdoc-gui-test from outside of the source root.
+        command.env("NODE_PATH", local_node_modules);
+    }
+
     for file in &config.goml_files {
         command.arg("--file").arg(file);
     }
-- 
cgit 1.4.1-3-g733a5


From 1120cb2fe54fae7a1a8ccd5beb941f5b207084c0 Mon Sep 17 00:00:00 2001
From: Cameron Steffen <cam.steffen94@gmail.com>
Date: Tue, 15 Jul 2025 14:14:22 -0500
Subject: Add LocalKey<Cell>::update

---
 library/std/src/thread/local.rs | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/library/std/src/thread/local.rs b/library/std/src/thread/local.rs
index 7cd44873313..0ad014ccd3e 100644
--- a/library/std/src/thread/local.rs
+++ b/library/std/src/thread/local.rs
@@ -469,6 +469,29 @@ impl<T: 'static> LocalKey<Cell<T>> {
     pub fn replace(&'static self, value: T) -> T {
         self.with(|cell| cell.replace(value))
     }
+
+    /// Updates the contained value using a function.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(local_key_cell_update)]
+    /// use std::cell::Cell;
+    ///
+    /// thread_local! {
+    ///     static X: Cell<i32> = const { Cell::new(5) };
+    /// }
+    ///
+    /// X.update(|x| x + 1);
+    /// assert_eq!(X.get(), 6);
+    /// ```
+    #[unstable(feature = "local_key_cell_update", issue = "143989")]
+    pub fn update(&'static self, f: impl FnOnce(T) -> T)
+    where
+        T: Copy,
+    {
+        self.with(|cell| cell.update(f))
+    }
 }
 
 impl<T: 'static> LocalKey<RefCell<T>> {
-- 
cgit 1.4.1-3-g733a5


From 85c89494d9efdc90f2ac08446c00b0b78287b7a2 Mon Sep 17 00:00:00 2001
From: Ibraheem Ahmed <ibraheem@ibraheem.ca>
Date: Thu, 10 Jul 2025 15:10:33 -0400
Subject: add support for global constructors (i.e. life before main)

---
 src/tools/miri/src/eval.rs       | 91 ++++++++++++++++++++++++++------------
 src/tools/miri/src/helpers.rs    |  9 ++--
 src/tools/miri/src/shims/ctor.rs | 94 ++++++++++++++++++++++++++++++++++++++++
 src/tools/miri/src/shims/mod.rs  |  1 +
 src/tools/miri/src/shims/tls.rs  |  2 +-
 5 files changed, 165 insertions(+), 32 deletions(-)
 create mode 100644 src/tools/miri/src/shims/ctor.rs

diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index 425a136dfa5..d986f2830aa 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -11,14 +11,14 @@ use rustc_abi::ExternAbi;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def::Namespace;
 use rustc_hir::def_id::DefId;
-use rustc_middle::ty::layout::LayoutCx;
+use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutCx};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_session::config::EntryFnType;
 
 use crate::concurrency::GenmcCtx;
 use crate::concurrency::thread::TlsAllocAction;
 use crate::diagnostics::report_leaks;
-use crate::shims::tls;
+use crate::shims::{ctor, tls};
 use crate::*;
 
 #[derive(Copy, Clone, Debug)]
@@ -216,9 +216,15 @@ impl Default for MiriConfig {
 }
 
 /// The state of the main thread. Implementation detail of `on_main_stack_empty`.
-#[derive(Default, Debug)]
+#[derive(Debug)]
 enum MainThreadState<'tcx> {
-    #[default]
+    GlobalCtors {
+        ctor_state: ctor::GlobalCtorState<'tcx>,
+        entry_id: DefId,
+        entry_type: MiriEntryFnType,
+        argc: ImmTy<'tcx>,
+        argv: ImmTy<'tcx>,
+    },
     Running,
     TlsDtors(tls::TlsDtorsState<'tcx>),
     Yield {
@@ -234,6 +240,15 @@ impl<'tcx> MainThreadState<'tcx> {
     ) -> InterpResult<'tcx, Poll<()>> {
         use MainThreadState::*;
         match self {
+            GlobalCtors { ctor_state, entry_id, entry_type, argc, argv } => {
+                match ctor_state.on_stack_empty(this)? {
+                    Poll::Pending => {} // just keep going
+                    Poll::Ready(()) => {
+                        call_main(this, *entry_id, *entry_type, argc.clone(), argv.clone())?;
+                        *self = Running;
+                    }
+                }
+            }
             Running => {
                 *self = TlsDtors(Default::default());
             }
@@ -309,26 +324,6 @@ pub fn create_ecx<'tcx>(
         MiriMachine::new(config, layout_cx, genmc_ctx),
     );
 
-    // Some parts of initialization require a full `InterpCx`.
-    MiriMachine::late_init(&mut ecx, config, {
-        let mut state = MainThreadState::default();
-        // Cannot capture anything GC-relevant here.
-        Box::new(move |m| state.on_main_stack_empty(m))
-    })?;
-
-    // Make sure we have MIR. We check MIR for some stable monomorphic function in libcore.
-    let sentinel =
-        helpers::try_resolve_path(tcx, &["core", "ascii", "escape_default"], Namespace::ValueNS);
-    if !matches!(sentinel, Some(s) if tcx.is_mir_available(s.def.def_id())) {
-        tcx.dcx().fatal(
-            "the current sysroot was built without `-Zalways-encode-mir`, or libcore seems missing. \
-            Use `cargo miri setup` to prepare a sysroot that is suitable for Miri."
-        );
-    }
-
-    // Setup first stack frame.
-    let entry_instance = ty::Instance::mono(tcx, entry_id);
-
     // First argument is constructed later, because it's skipped for `miri_start.`
 
     // Second argument (argc): length of `config.args`.
@@ -395,11 +390,51 @@ pub fn create_ecx<'tcx>(
         ImmTy::from_immediate(imm, layout)
     };
 
+    // Some parts of initialization require a full `InterpCx`.
+    MiriMachine::late_init(&mut ecx, config, {
+        let mut state = MainThreadState::GlobalCtors {
+            entry_id,
+            entry_type,
+            argc,
+            argv,
+            ctor_state: ctor::GlobalCtorState::default(),
+        };
+
+        // Cannot capture anything GC-relevant here.
+        Box::new(move |m| state.on_main_stack_empty(m))
+    })?;
+
+    // Make sure we have MIR. We check MIR for some stable monomorphic function in libcore.
+    let sentinel =
+        helpers::try_resolve_path(tcx, &["core", "ascii", "escape_default"], Namespace::ValueNS);
+    if !matches!(sentinel, Some(s) if tcx.is_mir_available(s.def.def_id())) {
+        tcx.dcx().fatal(
+            "the current sysroot was built without `-Zalways-encode-mir`, or libcore seems missing. \
+            Use `cargo miri setup` to prepare a sysroot that is suitable for Miri."
+        );
+    }
+
+    interp_ok(ecx)
+}
+
+// Call the entry function.
+fn call_main<'tcx>(
+    ecx: &mut MiriInterpCx<'tcx>,
+    entry_id: DefId,
+    entry_type: MiriEntryFnType,
+    argc: ImmTy<'tcx>,
+    argv: ImmTy<'tcx>,
+) -> InterpResult<'tcx, ()> {
+    let tcx = ecx.tcx();
+
+    // Setup first stack frame.
+    let entry_instance = ty::Instance::mono(tcx, entry_id);
+
     // Return place (in static memory so that it does not count as leak).
     let ret_place = ecx.allocate(ecx.machine.layouts.isize, MiriMemoryKind::Machine.into())?;
     ecx.machine.main_fn_ret_place = Some(ret_place.clone());
-    // Call start function.
 
+    // Call start function.
     match entry_type {
         MiriEntryFnType::Rustc(EntryFnType::Main { .. }) => {
             let start_id = tcx.lang_items().start_fn().unwrap_or_else(|| {
@@ -409,7 +444,7 @@ pub fn create_ecx<'tcx>(
             let main_ret_ty = main_ret_ty.no_bound_vars().unwrap();
             let start_instance = ty::Instance::try_resolve(
                 tcx,
-                typing_env,
+                ecx.typing_env(),
                 start_id,
                 tcx.mk_args(&[ty::GenericArg::from(main_ret_ty)]),
             )
@@ -427,7 +462,7 @@ pub fn create_ecx<'tcx>(
                 ExternAbi::Rust,
                 &[
                     ImmTy::from_scalar(
-                        Scalar::from_pointer(main_ptr, &ecx),
+                        Scalar::from_pointer(main_ptr, ecx),
                         // FIXME use a proper fn ptr type
                         ecx.machine.layouts.const_raw_ptr,
                     ),
@@ -450,7 +485,7 @@ pub fn create_ecx<'tcx>(
         }
     }
 
-    interp_ok(ecx)
+    interp_ok(())
 }
 
 /// Evaluates the entry function specified by `entry_id`.
diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index 216b7b1e4bb..35d3e7e647c 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -1235,8 +1235,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         interp_ok(())
     }
 
-    /// Lookup an array of immediates stored as a linker section of name `name`.
-    fn lookup_link_section(&mut self, name: &str) -> InterpResult<'tcx, Vec<ImmTy<'tcx>>> {
+    /// Lookup an array of immediates from any linker sections matching the provided predicate.
+    fn lookup_link_section(
+        &mut self,
+        include_name: impl Fn(&str) -> bool,
+    ) -> InterpResult<'tcx, Vec<ImmTy<'tcx>>> {
         let this = self.eval_context_mut();
         let tcx = this.tcx.tcx;
 
@@ -1247,7 +1250,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             let Some(link_section) = attrs.link_section else {
                 return interp_ok(());
             };
-            if link_section.as_str() == name {
+            if include_name(link_section.as_str()) {
                 let instance = ty::Instance::mono(tcx, def_id);
                 let const_val = this.eval_global(instance).unwrap_or_else(|err| {
                     panic!(
diff --git a/src/tools/miri/src/shims/ctor.rs b/src/tools/miri/src/shims/ctor.rs
new file mode 100644
index 00000000000..75f564989bc
--- /dev/null
+++ b/src/tools/miri/src/shims/ctor.rs
@@ -0,0 +1,94 @@
+//! Implement global constructors.
+
+use std::task::Poll;
+
+use rustc_abi::ExternAbi;
+use rustc_target::spec::BinaryFormat;
+
+use crate::*;
+
+#[derive(Debug, Default)]
+pub struct GlobalCtorState<'tcx>(GlobalCtorStatePriv<'tcx>);
+
+#[derive(Debug, Default)]
+enum GlobalCtorStatePriv<'tcx> {
+    #[default]
+    Init,
+    /// The list of constructor functions that we still have to call.
+    Ctors(Vec<ImmTy<'tcx>>),
+    Done,
+}
+
+impl<'tcx> GlobalCtorState<'tcx> {
+    pub fn on_stack_empty(
+        &mut self,
+        this: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx, Poll<()>> {
+        use GlobalCtorStatePriv::*;
+        let new_state = 'new_state: {
+            match &mut self.0 {
+                Init => {
+                    let this = this.eval_context_mut();
+
+                    // Lookup constructors from the relevant magic link section.
+                    let ctors = match this.tcx.sess.target.binary_format {
+                        // Read the CRT library section on Windows.
+                        BinaryFormat::Coff =>
+                            this.lookup_link_section(|section| section == ".CRT$XCU")?,
+
+                        // Read the `__mod_init_func` section on macOS.
+                        BinaryFormat::MachO =>
+                            this.lookup_link_section(|section| {
+                                let mut parts = section.splitn(3, ',');
+                                let (segment_name, section_name, section_type) =
+                                    (parts.next(), parts.next(), parts.next());
+
+                                segment_name == Some("__DATA")
+                                    && section_name == Some("__mod_init_func")
+                                    // The `mod_init_funcs` directive ensures that the `S_MOD_INIT_FUNC_POINTERS` flag
+                                    // is set on the section, but it is not strictly required.
+                                    && matches!(section_type, None | Some("mod_init_funcs"))
+                            })?,
+
+                        // Read the standard `.init_array` section on platforms that use ELF, or WASM,
+                        // which supports the same linker directive.
+                        // FIXME: Add support for `.init_array.N`.
+                        BinaryFormat::Elf | BinaryFormat::Wasm =>
+                            this.lookup_link_section(|section| section == ".init_array")?,
+
+                        // Other platforms have no global ctor support.
+                        _ => break 'new_state Done,
+                    };
+
+                    break 'new_state Ctors(ctors);
+                }
+                Ctors(ctors) => {
+                    if let Some(ctor) = ctors.pop() {
+                        let this = this.eval_context_mut();
+
+                        let ctor = ctor.to_scalar().to_pointer(this)?;
+                        let thread_callback = this.get_ptr_fn(ctor)?.as_instance()?;
+
+                        // The signature of this function is `unsafe extern "C" fn()`.
+                        this.call_function(
+                            thread_callback,
+                            ExternAbi::C { unwind: false },
+                            &[],
+                            None,
+                            ReturnContinuation::Stop { cleanup: true },
+                        )?;
+
+                        return interp_ok(Poll::Pending); // we stay in this state (but `ctors` got shorter)
+                    }
+
+                    // No more constructors to run.
+                    break 'new_state Done;
+                }
+                Done => return interp_ok(Poll::Ready(())),
+            }
+        };
+
+        self.0 = new_state;
+        interp_ok(Poll::Pending)
+    }
+}
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index b08ab101e94..0faf298bfaa 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -11,6 +11,7 @@ mod wasi;
 mod windows;
 mod x86;
 
+pub mod ctor;
 pub mod env;
 pub mod extern_static;
 pub mod foreign_items;
diff --git a/src/tools/miri/src/shims/tls.rs b/src/tools/miri/src/shims/tls.rs
index 7182637437a..1200029692d 100644
--- a/src/tools/miri/src/shims/tls.rs
+++ b/src/tools/miri/src/shims/tls.rs
@@ -302,7 +302,7 @@ trait EvalContextPrivExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // Windows has a special magic linker section that is run on certain events.
         // We don't support most of that, but just enough to make thread-local dtors in `std` work.
-        interp_ok(this.lookup_link_section(".CRT$XLB")?)
+        interp_ok(this.lookup_link_section(|section| section == ".CRT$XLB")?)
     }
 
     fn schedule_windows_tls_dtor(&mut self, dtor: ImmTy<'tcx>) -> InterpResult<'tcx> {
-- 
cgit 1.4.1-3-g733a5


From d060859376994b32dad84e5bb7f507fbb1dcb89a Mon Sep 17 00:00:00 2001
From: Ibraheem Ahmed <ibraheem@ibraheem.ca>
Date: Thu, 10 Jul 2025 16:37:54 -0400
Subject: add test for global constructors

---
 src/tools/miri/tests/pass/shims/ctor.rs | 43 +++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 src/tools/miri/tests/pass/shims/ctor.rs

diff --git a/src/tools/miri/tests/pass/shims/ctor.rs b/src/tools/miri/tests/pass/shims/ctor.rs
new file mode 100644
index 00000000000..c832e3f82a3
--- /dev/null
+++ b/src/tools/miri/tests/pass/shims/ctor.rs
@@ -0,0 +1,43 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+static COUNT: AtomicUsize = AtomicUsize::new(0);
+
+unsafe extern "C" fn ctor() {
+    COUNT.fetch_add(1, Ordering::Relaxed);
+}
+
+macro_rules! ctor {
+    ($ident:ident = $ctor:ident) => {
+        #[cfg_attr(
+            all(any(
+                target_os = "linux",
+                target_os = "android",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "haiku",
+                target_os = "illumos",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                target_os = "solaris",
+                target_os = "none",
+                target_family = "wasm",
+            )),
+            link_section = ".init_array"
+        )]
+        #[cfg_attr(windows, link_section = ".CRT$XCU")]
+        #[cfg_attr(
+            any(target_os = "macos", target_os = "ios"),
+            link_section = "__DATA,__mod_init_func"
+        )]
+        #[used]
+        static $ident: unsafe extern "C" fn() = $ctor;
+    };
+}
+
+ctor! { CTOR1 = ctor }
+ctor! { CTOR2 = ctor }
+ctor! { CTOR3 = ctor }
+
+fn main() {
+    assert_eq!(COUNT.load(Ordering::Relaxed), 3, "ctors did not run");
+}
-- 
cgit 1.4.1-3-g733a5


From 8e400f97e59211732ba67518199432ae22685cb5 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Tue, 15 Jul 2025 19:07:37 +0200
Subject: Fix ice for feature-gated cfg attributes applied to the crate

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>
---
 compiler/rustc_attr_parsing/src/attributes/cfg.rs | 53 +++++++++++++----------
 compiler/rustc_attr_parsing/src/context.rs        | 27 ++++++++++--
 compiler/rustc_attr_parsing/src/lib.rs            |  2 +-
 compiler/rustc_expand/src/config.rs               | 22 +++++++---
 compiler/rustc_expand/src/expand.rs               |  4 +-
 compiler/rustc_resolve/src/def_collector.rs       |  4 +-
 6 files changed, 74 insertions(+), 38 deletions(-)

diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg.rs b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
index a56855b3bd3..6373cf6e08a 100644
--- a/compiler/rustc_attr_parsing/src/attributes/cfg.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
@@ -9,7 +9,7 @@ use rustc_session::parse::feature_err;
 use rustc_span::{Span, Symbol, sym};
 use thin_vec::ThinVec;
 
-use crate::context::{AcceptContext, Stage};
+use crate::context::{AcceptContext, ShouldEmit, Stage};
 use crate::parser::{ArgParser, MetaItemListParser, MetaItemOrLitParser, NameValueParser};
 use crate::{
     CfgMatchesLintEmitter, fluent_generated, parse_version, session_diagnostics, try_gate_cfg,
@@ -90,7 +90,7 @@ fn parse_cfg_entry_version<S: Stage>(
     list: &MetaItemListParser<'_>,
     meta_span: Span,
 ) -> Option<CfgEntry> {
-    try_gate_cfg(sym::version, meta_span, cx.sess(), Some(cx.features()));
+    try_gate_cfg(sym::version, meta_span, cx.sess(), cx.features_option());
     let Some(version) = list.single() else {
         cx.emit_err(session_diagnostics::ExpectedSingleVersionLiteral { span: list.span });
         return None;
@@ -119,7 +119,9 @@ fn parse_cfg_entry_target<S: Stage>(
     list: &MetaItemListParser<'_>,
     meta_span: Span,
 ) -> Option<CfgEntry> {
-    if !cx.features().cfg_target_compact() {
+    if let Some(features) = cx.features_option()
+        && !features.cfg_target_compact()
+    {
         feature_err(
             cx.sess(),
             sym::cfg_target_compact,
@@ -186,12 +188,13 @@ pub fn eval_config_entry(
     cfg_entry: &CfgEntry,
     id: NodeId,
     features: Option<&Features>,
+    emit_lints: ShouldEmit,
 ) -> EvalConfigResult {
     match cfg_entry {
         CfgEntry::All(subs, ..) => {
             let mut all = None;
             for sub in subs {
-                let res = eval_config_entry(sess, sub, id, features);
+                let res = eval_config_entry(sess, sub, id, features, emit_lints);
                 // We cannot short-circuit because `eval_config_entry` emits some lints
                 if !res.as_bool() {
                     all.get_or_insert(res);
@@ -202,7 +205,7 @@ pub fn eval_config_entry(
         CfgEntry::Any(subs, span) => {
             let mut any = None;
             for sub in subs {
-                let res = eval_config_entry(sess, sub, id, features);
+                let res = eval_config_entry(sess, sub, id, features, emit_lints);
                 // We cannot short-circuit because `eval_config_entry` emits some lints
                 if res.as_bool() {
                     any.get_or_insert(res);
@@ -214,7 +217,7 @@ pub fn eval_config_entry(
             })
         }
         CfgEntry::Not(sub, span) => {
-            if eval_config_entry(sess, sub, id, features).as_bool() {
+            if eval_config_entry(sess, sub, id, features, emit_lints).as_bool() {
                 EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
             } else {
                 EvalConfigResult::True
@@ -228,24 +231,28 @@ pub fn eval_config_entry(
             }
         }
         CfgEntry::NameValue { name, name_span, value, span } => {
-            match sess.psess.check_config.expecteds.get(name) {
-                Some(ExpectedValues::Some(values)) if !values.contains(&value.map(|(v, _)| v)) => {
-                    id.emit_span_lint(
-                        sess,
-                        UNEXPECTED_CFGS,
-                        *span,
-                        BuiltinLintDiag::UnexpectedCfgValue((*name, *name_span), *value),
-                    );
+            if let ShouldEmit::ErrorsAndLints = emit_lints {
+                match sess.psess.check_config.expecteds.get(name) {
+                    Some(ExpectedValues::Some(values))
+                        if !values.contains(&value.map(|(v, _)| v)) =>
+                    {
+                        id.emit_span_lint(
+                            sess,
+                            UNEXPECTED_CFGS,
+                            *span,
+                            BuiltinLintDiag::UnexpectedCfgValue((*name, *name_span), *value),
+                        );
+                    }
+                    None if sess.psess.check_config.exhaustive_names => {
+                        id.emit_span_lint(
+                            sess,
+                            UNEXPECTED_CFGS,
+                            *span,
+                            BuiltinLintDiag::UnexpectedCfgName((*name, *name_span), *value),
+                        );
+                    }
+                    _ => { /* not unexpected */ }
                 }
-                None if sess.psess.check_config.exhaustive_names => {
-                    id.emit_span_lint(
-                        sess,
-                        UNEXPECTED_CFGS,
-                        *span,
-                        BuiltinLintDiag::UnexpectedCfgName((*name, *name_span), *value),
-                    );
-                }
-                _ => { /* not unexpected */ }
             }
 
             if sess.psess.config.contains(&(*name, value.map(|(v, _)| v))) {
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 567341d1517..dc80d408b27 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -223,7 +223,7 @@ impl Stage for Early {
         sess: &'sess Session,
         diag: impl for<'x> Diagnostic<'x>,
     ) -> ErrorGuaranteed {
-        if self.emit_errors {
+        if self.emit_errors.should_emit() {
             sess.dcx().emit_err(diag)
         } else {
             sess.dcx().create_err(diag).delay_as_bug()
@@ -254,7 +254,7 @@ pub struct Early {
     /// Whether to emit errors or delay them as a bug
     /// For most attributes, the attribute will be parsed again in the `Late` stage and in this case the errors should be delayed
     /// But for some, such as `cfg`, the attribute will be removed before the `Late` stage so errors must be emitted
-    pub emit_errors: bool,
+    pub emit_errors: ShouldEmit,
 }
 /// used when parsing attributes during ast lowering
 pub struct Late;
@@ -555,6 +555,25 @@ pub enum OmitDoc {
     Skip,
 }
 
+#[derive(Copy, Clone)]
+pub enum ShouldEmit {
+    /// The operation will emit errors and lints.
+    /// This is usually what you need.
+    ErrorsAndLints,
+    /// The operation will emit *not* errors and lints.
+    /// Use this if you are *sure* that this operation will be called at a different time with `ShouldEmit::Emit`.
+    Nothing,
+}
+
+impl ShouldEmit {
+    pub fn should_emit(&self) -> bool {
+        match self {
+            ShouldEmit::ErrorsAndLints => true,
+            ShouldEmit::Nothing => false,
+        }
+    }
+}
+
 /// Context created once, for example as part of the ast lowering
 /// context, through which all attributes can be lowered.
 pub struct AttributeParser<'sess, S: Stage = Late> {
@@ -597,7 +616,7 @@ impl<'sess> AttributeParser<'sess, Early> {
             tools: Vec::new(),
             parse_only: Some(sym),
             sess,
-            stage: Early { emit_errors: false },
+            stage: Early { emit_errors: ShouldEmit::Nothing },
         };
         let mut parsed = p.parse_attribute_list(
             attrs,
@@ -620,7 +639,7 @@ impl<'sess> AttributeParser<'sess, Early> {
         target_span: Span,
         target_node_id: NodeId,
         features: Option<&'sess Features>,
-        emit_errors: bool,
+        emit_errors: ShouldEmit,
         parse_fn: fn(cx: &mut AcceptContext<'_, '_, Early>, item: &ArgParser<'_>) -> T,
         template: &AttributeTemplate,
     ) -> T {
diff --git a/compiler/rustc_attr_parsing/src/lib.rs b/compiler/rustc_attr_parsing/src/lib.rs
index 2102a26108b..dc54cb6b840 100644
--- a/compiler/rustc_attr_parsing/src/lib.rs
+++ b/compiler/rustc_attr_parsing/src/lib.rs
@@ -95,7 +95,7 @@ pub use attributes::cfg_old::*;
 pub use attributes::util::{
     find_crate_name, is_builtin_attr, is_doc_alias_attrs_contain_symbol, parse_version,
 };
-pub use context::{AttributeParser, Early, Late, OmitDoc};
+pub use context::{AttributeParser, Early, Late, OmitDoc, ShouldEmit};
 pub use lints::emit_attribute_lint;
 
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
index 6922ddfd6bd..83a8d601afe 100644
--- a/compiler/rustc_expand/src/config.rs
+++ b/compiler/rustc_expand/src/config.rs
@@ -12,7 +12,7 @@ use rustc_ast::{
 };
 use rustc_attr_parsing as attr;
 use rustc_attr_parsing::{
-    AttributeParser, CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg_attr,
+    AttributeParser, CFG_TEMPLATE, EvalConfigResult, ShouldEmit, eval_config_entry, parse_cfg_attr,
 };
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_feature::{
@@ -167,7 +167,9 @@ pub fn pre_configure_attrs(sess: &Session, attrs: &[Attribute]) -> ast::AttrVec
         .flat_map(|attr| strip_unconfigured.process_cfg_attr(attr))
         .take_while(|attr| {
             !is_cfg(attr)
-                || strip_unconfigured.cfg_true(attr, strip_unconfigured.lint_node_id).as_bool()
+                || strip_unconfigured
+                    .cfg_true(attr, strip_unconfigured.lint_node_id, ShouldEmit::Nothing)
+                    .as_bool()
         })
         .collect()
 }
@@ -401,10 +403,18 @@ impl<'a> StripUnconfigured<'a> {
 
     /// Determines if a node with the given attributes should be included in this configuration.
     fn in_cfg(&self, attrs: &[Attribute]) -> bool {
-        attrs.iter().all(|attr| !is_cfg(attr) || self.cfg_true(attr, self.lint_node_id).as_bool())
+        attrs.iter().all(|attr| {
+            !is_cfg(attr)
+                || self.cfg_true(attr, self.lint_node_id, ShouldEmit::ErrorsAndLints).as_bool()
+        })
     }
 
-    pub(crate) fn cfg_true(&self, attr: &Attribute, node: NodeId) -> EvalConfigResult {
+    pub(crate) fn cfg_true(
+        &self,
+        attr: &Attribute,
+        node: NodeId,
+        emit_errors: ShouldEmit,
+    ) -> EvalConfigResult {
         // We need to run this to do basic validation of the attribute, such as that lits are valid, etc
         // FIXME(jdonszelmann) this should not be necessary in the future
         match validate_attr::parse_meta(&self.sess.psess, attr) {
@@ -428,7 +438,7 @@ impl<'a> StripUnconfigured<'a> {
             attr.span,
             node,
             self.features,
-            true,
+            emit_errors,
             parse_cfg_attr,
             &CFG_TEMPLATE,
         ) else {
@@ -436,7 +446,7 @@ impl<'a> StripUnconfigured<'a> {
             return EvalConfigResult::True;
         };
 
-        eval_config_entry(self.sess, &cfg, self.lint_node_id, self.features)
+        eval_config_entry(self.sess, &cfg, self.lint_node_id, self.features, emit_errors)
     }
 
     /// If attributes are not allowed on expressions, emit an error for `attr`
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index f99060e9a21..79ec79a2fdf 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -13,7 +13,7 @@ use rustc_ast::{
     MetaItemKind, ModKind, NodeId, PatKind, StmtKind, TyKind, token,
 };
 use rustc_ast_pretty::pprust;
-use rustc_attr_parsing::EvalConfigResult;
+use rustc_attr_parsing::{EvalConfigResult, ShouldEmit};
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_errors::PResult;
 use rustc_feature::Features;
@@ -2171,7 +2171,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
         attr: ast::Attribute,
         pos: usize,
     ) -> EvalConfigResult {
-        let res = self.cfg().cfg_true(&attr, node.node_id());
+        let res = self.cfg().cfg_true(&attr, node.node_id(), ShouldEmit::ErrorsAndLints);
         if res.as_bool() {
             // A trace attribute left in AST in place of the original `cfg` attribute.
             // It can later be used by lints or other diagnostics.
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index 781e2ce9704..7d51fef28d3 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -2,7 +2,7 @@ use std::mem;
 
 use rustc_ast::visit::FnKind;
 use rustc_ast::*;
-use rustc_attr_parsing::{AttributeParser, Early, OmitDoc};
+use rustc_attr_parsing::{AttributeParser, Early, OmitDoc, ShouldEmit};
 use rustc_expand::expand::AstFragment;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind};
@@ -132,7 +132,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                     &self.resolver.tcx.sess,
                     self.resolver.tcx.features(),
                     Vec::new(),
-                    Early { emit_errors: false },
+                    Early { emit_errors: ShouldEmit::Nothing },
                 );
                 let attrs = parser.parse_attribute_list(
                     &i.attrs,
-- 
cgit 1.4.1-3-g733a5


From bfa45ac78b4cb018ece7daa56116e50820d2fd92 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Tue, 15 Jul 2025 19:07:49 +0200
Subject: Add regression test

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>
---
 tests/ui/check-cfg/cfg-crate-features.rs     | 13 +++++++++++
 tests/ui/check-cfg/cfg-crate-features.stderr | 33 ++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)
 create mode 100644 tests/ui/check-cfg/cfg-crate-features.rs
 create mode 100644 tests/ui/check-cfg/cfg-crate-features.stderr

diff --git a/tests/ui/check-cfg/cfg-crate-features.rs b/tests/ui/check-cfg/cfg-crate-features.rs
new file mode 100644
index 00000000000..16be8aaeeaa
--- /dev/null
+++ b/tests/ui/check-cfg/cfg-crate-features.rs
@@ -0,0 +1,13 @@
+// https://github.com/rust-lang/rust/issues/143977
+// Check that features are available when an attribute is applied to a crate
+
+#![cfg(version("1.0"))]
+//~^ ERROR `cfg(version)` is experimental and subject to change
+
+// Using invalid value `does_not_exist`,
+// so we don't accidentally configure out the crate for any certain OS
+#![cfg(not(target(os = "does_not_exist")))]
+//~^ ERROR compact `cfg(target(..))` is experimental and subject to change
+//~| WARN unexpected `cfg` condition value: `does_not_exist`
+
+fn main() {}
diff --git a/tests/ui/check-cfg/cfg-crate-features.stderr b/tests/ui/check-cfg/cfg-crate-features.stderr
new file mode 100644
index 00000000000..60a5404c073
--- /dev/null
+++ b/tests/ui/check-cfg/cfg-crate-features.stderr
@@ -0,0 +1,33 @@
+error[E0658]: `cfg(version)` is experimental and subject to change
+  --> $DIR/cfg-crate-features.rs:4:8
+   |
+LL | #![cfg(version("1.0"))]
+   |        ^^^^^^^^^^^^^^
+   |
+   = note: see issue #64796 <https://github.com/rust-lang/rust/issues/64796> for more information
+   = help: add `#![feature(cfg_version)]` 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]: compact `cfg(target(..))` is experimental and subject to change
+  --> $DIR/cfg-crate-features.rs:9:12
+   |
+LL | #![cfg(not(target(os = "does_not_exist")))]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #96901 <https://github.com/rust-lang/rust/issues/96901> for more information
+   = help: add `#![feature(cfg_target_compact)]` 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: unexpected `cfg` condition value: `does_not_exist`
+  --> $DIR/cfg-crate-features.rs:9:19
+   |
+LL | #![cfg(not(target(os = "does_not_exist")))]
+   |                   ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: expected values for `target_os` are: `aix`, `amdhsa`, `android`, `cuda`, `cygwin`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `lynxos178`, `macos`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `psx`, `redox`, `rtems`, `solaris`, `solid_asp3`, `teeos`, `trusty`, `tvos`, and `uefi` and 9 more
+   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
+   = note: `#[warn(unexpected_cfgs)]` on by default
+
+error: aborting due to 2 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0658`.
-- 
cgit 1.4.1-3-g733a5


From c6e1b2177701df2ce9f61f28cbf28e8ced4ff64a Mon Sep 17 00:00:00 2001
From: Jacob Greenfield <jacob@jacobgreenfield.me>
Date: Tue, 15 Jul 2025 20:47:09 -0400
Subject: Use hygenic macros for stable-mir

---
 compiler/rustc_public/src/rustc_internal/mod.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_public/src/rustc_internal/mod.rs b/compiler/rustc_public/src/rustc_internal/mod.rs
index 5d7c8256d5b..01354fc7bd4 100644
--- a/compiler/rustc_public/src/rustc_internal/mod.rs
+++ b/compiler/rustc_public/src/rustc_internal/mod.rs
@@ -144,10 +144,10 @@ where
 #[macro_export]
 macro_rules! run {
     ($args:expr, $callback_fn:ident) => {
-        run_driver!($args, || $callback_fn())
+        $crate::run_driver!($args, || $callback_fn())
     };
     ($args:expr, $callback:expr) => {
-        run_driver!($args, $callback)
+        $crate::run_driver!($args, $callback)
     };
 }
 
@@ -158,10 +158,10 @@ macro_rules! run {
 #[macro_export]
 macro_rules! run_with_tcx {
     ($args:expr, $callback_fn:ident) => {
-        run_driver!($args, |tcx| $callback_fn(tcx), with_tcx)
+        $crate::run_driver!($args, |tcx| $callback_fn(tcx), with_tcx)
     };
     ($args:expr, $callback:expr) => {
-        run_driver!($args, $callback, with_tcx)
+        $crate::run_driver!($args, $callback, with_tcx)
     };
 }
 
@@ -191,11 +191,11 @@ macro_rules! run_driver {
         use rustc_public::CompilerError;
         use std::ops::ControlFlow;
 
-        pub struct StableMir<B = (), C = (), F = fn($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C>>
+        pub struct StableMir<B = (), C = (), F = fn($($crate::optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C>>
         where
             B: Send,
             C: Send,
-            F: FnOnce($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
+            F: FnOnce($($crate::optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
         {
             callback: Option<F>,
             result: Option<ControlFlow<B, C>>,
@@ -205,7 +205,7 @@ macro_rules! run_driver {
         where
             B: Send,
             C: Send,
-            F: FnOnce($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
+            F: FnOnce($($crate::optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
         {
             /// Creates a new `StableMir` instance, with given test_function and arguments.
             pub fn new(callback: F) -> Self {
@@ -240,7 +240,7 @@ macro_rules! run_driver {
         where
             B: Send,
             C: Send,
-            F: FnOnce($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
+            F: FnOnce($($crate::optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
         {
             /// Called after analysis. Return value instructs the compiler whether to
             /// continue the compilation afterwards (defaults to `Compilation::Continue`)
@@ -251,7 +251,7 @@ macro_rules! run_driver {
             ) -> Compilation {
                 if let Some(callback) = self.callback.take() {
                     rustc_internal::run(tcx, || {
-                        self.result = Some(callback($(optional!($with_tcx tcx))?));
+                        self.result = Some(callback($($crate::optional!($with_tcx tcx))?));
                     })
                     .unwrap();
                     if self.result.as_ref().is_some_and(|val| val.is_continue()) {
-- 
cgit 1.4.1-3-g733a5


From 10bc064d892be46c68b43a1ff8eb6b30abde5fdb Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Tue, 15 Jul 2025 18:32:00 -0700
Subject: Update cargo

---
 src/tools/cargo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/cargo b/src/tools/cargo
index eabb4cd923d..6833aa715d7 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit eabb4cd923deb73e714f7ad3f5234d68ca284dbe
+Subproject commit 6833aa715d724437dc1247d0166afe314ab6854e
-- 
cgit 1.4.1-3-g733a5


From f1d84468c87a4e8ea96e603d21c460004bdeb24f Mon Sep 17 00:00:00 2001
From: "Martin Ombura Jr." <8682597+martinomburajr@users.noreply.github.com>
Date: Tue, 15 Jul 2025 20:07:03 -0700
Subject: Update poison.rs

Typo in word "below"
---
 library/std/src/sync/poison.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/std/src/sync/poison.rs b/library/std/src/sync/poison.rs
index 571f0d14248..0c05f152ef8 100644
--- a/library/std/src/sync/poison.rs
+++ b/library/std/src/sync/poison.rs
@@ -10,7 +10,7 @@
 //! (some invariant is not being upheld).
 //!
 //! The specifics of how this "poisoned" state affects other threads
-//! depend on the primitive. See [#Overview] bellow.
+//! depend on the primitive. See [#Overview] below.
 //!
 //! For the alternative implementations that do not employ poisoning,
 //! see `std::sync::nonpoisoning`.
-- 
cgit 1.4.1-3-g733a5


From 262d02e6fd1fd1b595f19ac33b4693e431c24832 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Wed, 16 Jul 2025 01:57:22 +0000
Subject: Ensure home directory exists

This works around a missing mingw home directory in CI
---
 .github/workflows/ci.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e92afc14c20..dc8ac539a3a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -182,6 +182,11 @@ jobs:
       - name: install MinGW
         run: src/ci/scripts/install-mingw.sh
 
+      # Workaround for spurious ci failures after mingw install
+      # see https://rust-lang.zulipchat.com/#narrow/channel/242791-t-infra/topic/Spurious.20bors.20CI.20failures/near/528915775
+      - name: ensure home dir exists
+        run: mkdir -p ~
+
       - name: install ninja
         run: src/ci/scripts/install-ninja.sh
 
-- 
cgit 1.4.1-3-g733a5


From babe2c0d0f091f5ea9935176b478ea45b152e49e Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Fri, 4 Jul 2025 22:21:31 +0300
Subject: resolve: Merge `NameBindingKind::Module` into `NameBindingKind::Res`

---
 compiler/rustc_hir/src/def.rs                      | 15 +++++++
 .../src/rmeta/decoder/cstore_impl.rs               |  7 +--
 compiler/rustc_middle/src/ty/print/pretty.rs       |  4 +-
 compiler/rustc_resolve/src/build_reduced_graph.rs  | 50 +++++++---------------
 compiler/rustc_resolve/src/diagnostics.rs          | 40 ++++++-----------
 compiler/rustc_resolve/src/ident.rs                |  6 +--
 compiler/rustc_resolve/src/imports.rs              |  3 --
 compiler/rustc_resolve/src/late/diagnostics.rs     |  6 +--
 compiler/rustc_resolve/src/lib.rs                  | 29 ++++---------
 tests/ui/proc-macro/meta-macro-hygiene.stdout      |  6 ---
 .../ui/proc-macro/nonterminal-token-hygiene.stdout |  6 ---
 11 files changed, 61 insertions(+), 111 deletions(-)

diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
index df010f87098..ca57c4f3164 100644
--- a/compiler/rustc_hir/src/def.rs
+++ b/compiler/rustc_hir/src/def.rs
@@ -295,6 +295,12 @@ impl DefKind {
         }
     }
 
+    /// This is a "module" in name resolution sense.
+    #[inline]
+    pub fn is_module_like(self) -> bool {
+        matches!(self, DefKind::Mod | DefKind::Enum | DefKind::Trait)
+    }
+
     #[inline]
     pub fn is_fn_like(self) -> bool {
         matches!(
@@ -720,6 +726,15 @@ impl<Id> Res<Id> {
         }
     }
 
+    /// If this is a "module" in name resolution sense, return its `DefId`.
+    #[inline]
+    pub fn module_like_def_id(&self) -> Option<DefId> {
+        match self {
+            Res::Def(def_kind, def_id) if def_kind.is_module_like() => Some(*def_id),
+            _ => None,
+        }
+    }
+
     /// A human readable name for the res kind ("function", "module", etc.).
     pub fn descr(&self) -> &'static str {
         match *self {
diff --git a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
index 19954459cb5..57a672c45f7 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
@@ -3,7 +3,7 @@ use std::mem;
 use std::sync::Arc;
 
 use rustc_attr_data_structures::Deprecation;
-use rustc_hir::def::{CtorKind, DefKind, Res};
+use rustc_hir::def::{CtorKind, DefKind};
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LOCAL_CRATE};
 use rustc_hir::definitions::{DefKey, DefPath, DefPathHash};
 use rustc_middle::arena::ArenaAllocatable;
@@ -510,10 +510,7 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
                         }
                         Entry::Vacant(entry) => {
                             entry.insert(parent);
-                            if matches!(
-                                child.res,
-                                Res::Def(DefKind::Mod | DefKind::Enum | DefKind::Trait, _)
-                            ) {
+                            if child.res.module_like_def_id().is_some() {
                                 bfs_queue.push_back(def_id);
                             }
                         }
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 7c48a4b0885..8f0f9b21dc1 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -3454,9 +3454,7 @@ fn for_each_def(tcx: TyCtxt<'_>, mut collect_fn: impl for<'b> FnMut(&'b Ident, N
                         collect_fn(&child.ident, ns, def_id);
                     }
 
-                    if matches!(defkind, DefKind::Mod | DefKind::Enum | DefKind::Trait)
-                        && seen_defs.insert(def_id)
-                    {
+                    if defkind.is_module_like() && seen_defs.insert(def_id) {
                         queue.push(def_id);
                     }
                 }
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index 6979d89a8e7..a51cdbe76ee 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -39,21 +39,6 @@ use crate::{
 
 type Res = def::Res<NodeId>;
 
-impl<'ra, Id: Into<DefId>> ToNameBinding<'ra>
-    for (Module<'ra>, ty::Visibility<Id>, Span, LocalExpnId)
-{
-    fn to_name_binding(self, arenas: &'ra ResolverArenas<'ra>) -> NameBinding<'ra> {
-        arenas.alloc_name_binding(NameBindingData {
-            kind: NameBindingKind::Module(self.0),
-            ambiguity: None,
-            warn_ambiguity: false,
-            vis: self.1.to_def_id(),
-            span: self.2,
-            expansion: self.3,
-        })
-    }
-}
-
 impl<'ra, Id: Into<DefId>> ToNameBinding<'ra> for (Res, ty::Visibility<Id>, Span, LocalExpnId) {
     fn to_name_binding(self, arenas: &'ra ResolverArenas<'ra>) -> NameBinding<'ra> {
         arenas.alloc_name_binding(NameBindingData {
@@ -121,7 +106,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         if !def_id.is_local() {
             // Query `def_kind` is not used because query system overhead is too expensive here.
             let def_kind = self.cstore().def_kind_untracked(def_id);
-            if let DefKind::Mod | DefKind::Enum | DefKind::Trait = def_kind {
+            if def_kind.is_module_like() {
                 let parent = self
                     .tcx
                     .opt_parent(def_id)
@@ -223,12 +208,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let expansion = parent_scope.expansion;
         // Record primary definitions.
         match res {
-            Res::Def(DefKind::Mod | DefKind::Enum | DefKind::Trait, def_id) => {
-                let module = self.expect_module(def_id);
-                self.define(parent, ident, TypeNS, (module, vis, span, expansion));
-            }
             Res::Def(
-                DefKind::Struct
+                DefKind::Mod
+                | DefKind::Enum
+                | DefKind::Trait
+                | DefKind::Struct
                 | DefKind::Union
                 | DefKind::Variant
                 | DefKind::TyAlias
@@ -766,7 +750,12 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             }
 
             ItemKind::Mod(_, ident, ref mod_kind) => {
-                let module = self.r.new_module(
+                self.r.define(parent, ident, TypeNS, (res, vis, sp, expansion));
+
+                if let ast::ModKind::Loaded(_, _, _, Err(_)) = mod_kind {
+                    self.r.mods_with_parse_errors.insert(def_id);
+                }
+                self.parent_scope.module = self.r.new_module(
                     Some(parent),
                     ModuleKind::Def(def_kind, def_id, Some(ident.name)),
                     expansion.to_expn_id(),
@@ -774,14 +763,6 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                     parent.no_implicit_prelude
                         || ast::attr::contains_name(&item.attrs, sym::no_implicit_prelude),
                 );
-                self.r.define(parent, ident, TypeNS, (module, vis, sp, expansion));
-
-                if let ast::ModKind::Loaded(_, _, _, Err(_)) = mod_kind {
-                    self.r.mods_with_parse_errors.insert(def_id);
-                }
-
-                // Descend into the module.
-                self.parent_scope.module = module;
             }
 
             // These items live in the value namespace.
@@ -804,15 +785,15 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             }
 
             ItemKind::Enum(ident, _, _) | ItemKind::Trait(box ast::Trait { ident, .. }) => {
-                let module = self.r.new_module(
+                self.r.define(parent, ident, TypeNS, (res, vis, sp, expansion));
+
+                self.parent_scope.module = self.r.new_module(
                     Some(parent),
                     ModuleKind::Def(def_kind, def_id, Some(ident.name)),
                     expansion.to_expn_id(),
                     item.span,
                     parent.no_implicit_prelude,
                 );
-                self.r.define(parent, ident, TypeNS, (module, vis, sp, expansion));
-                self.parent_scope.module = module;
             }
 
             // These items live in both the type and value namespaces.
@@ -920,8 +901,9 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         }
         .map(|module| {
             let used = self.process_macro_use_imports(item, module);
+            let res = module.res().unwrap();
             let vis = ty::Visibility::<LocalDefId>::Public;
-            let binding = (module, vis, sp, expansion).to_name_binding(self.r.arenas);
+            let binding = (res, vis, sp, expansion).to_name_binding(self.r.arenas);
             (used, Some(ModuleOrUniformRoot::Module(module)), binding)
         })
         .unwrap_or((true, None, self.r.dummy_binding));
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 93d848787ef..11e4a729ae2 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -232,12 +232,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             return;
         }
 
-        let old_kind = match (ns, old_binding.module()) {
+        let old_kind = match (ns, old_binding.res()) {
             (ValueNS, _) => "value",
             (MacroNS, _) => "macro",
             (TypeNS, _) if old_binding.is_extern_crate() => "extern crate",
-            (TypeNS, Some(module)) if module.is_normal() => "module",
-            (TypeNS, Some(module)) if module.is_trait() => "trait",
+            (TypeNS, Res::Def(DefKind::Mod, _)) => "module",
+            (TypeNS, Res::Def(DefKind::Trait, _)) => "trait",
             (TypeNS, _) => "type",
         };
 
@@ -1319,7 +1319,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 }
 
                 // collect submodules to explore
-                if let Some(module) = name_binding.module() {
+                if let Some(def_id) = name_binding.res().module_like_def_id() {
                     // form the path
                     let mut path_segments = path_segments.clone();
                     path_segments.push(ast::PathSegment::from_ident(ident));
@@ -1339,14 +1339,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
                     if !is_extern_crate_that_also_appears_in_prelude || alias_import {
                         // add the module to the lookup
-                        if seen_modules.insert(module.def_id()) {
+                        if seen_modules.insert(def_id) {
                             if via_import { &mut worklist_via_import } else { &mut worklist }.push(
                                 (
-                                    module,
+                                    this.expect_module(def_id),
                                     path_segments,
                                     child_accessible,
                                     child_doc_visible,
-                                    is_stable && this.is_stable(module.def_id(), name_binding.span),
+                                    is_stable && this.is_stable(def_id, name_binding.span),
                                 ),
                             );
                         }
@@ -2094,7 +2094,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         true, // re-export
                     ));
                 }
-                NameBindingKind::Res(_) | NameBindingKind::Module(_) => {}
+                NameBindingKind::Res(_) => {}
             }
             let first = binding == first_binding;
             let def_span = self.tcx.sess.source_map().guess_head_span(binding.span);
@@ -2306,25 +2306,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     .ok()
                 };
                 if let Some(binding) = binding {
-                    let mut found = |what| {
-                        msg = format!(
-                            "expected {}, found {} `{}` in {}",
-                            ns.descr(),
-                            what,
-                            ident,
-                            parent
-                        )
-                    };
-                    if binding.module().is_some() {
-                        found("module")
-                    } else {
-                        match binding.res() {
-                            // Avoid using TyCtxt::def_kind_descr in the resolver, because it
-                            // indirectly *calls* the resolver, and would cause a query cycle.
-                            Res::Def(kind, id) => found(kind.descr(id)),
-                            _ => found(ns_to_try.descr()),
-                        }
-                    }
+                    msg = format!(
+                        "expected {}, found {} `{ident}` in {parent}",
+                        ns.descr(),
+                        binding.res().descr(),
+                    );
                 };
             }
             (msg, None)
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 99297de40d5..04f9e35b6b4 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -1637,11 +1637,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     }
 
                     let maybe_assoc = opt_ns != Some(MacroNS) && PathSource::Type.is_expected(res);
-                    if let Some(next_module) = binding.module() {
-                        if self.mods_with_parse_errors.contains(&next_module.def_id()) {
+                    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;
                         }
-                        module = Some(ModuleOrUniformRoot::Module(next_module));
+                        module = Some(ModuleOrUniformRoot::Module(self.expect_module(def_id)));
                         record_segment_res(self, res);
                     } else if res == Res::ToolMod && !is_last && opt_ns.is_some() {
                         if binding.is_import() {
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 40c63a3edf3..2fa20b25469 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -679,9 +679,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             NameBindingKind::Res(res) => {
                                 Some(self.def_id_to_node_id(res.def_id().expect_local()))
                             }
-                            NameBindingKind::Module(module) => {
-                                Some(self.def_id_to_node_id(module.def_id().expect_local()))
-                            }
                             NameBindingKind::Import { import, .. } => import.id(),
                         };
                         if let Some(binding_id) = binding_id {
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index b669796bb02..a4601cb44eb 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -2656,18 +2656,17 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                 if result.is_some() || !name_binding.vis.is_visible_locally() {
                     return;
                 }
-                if let Some(module) = name_binding.module() {
+                if let Some(module_def_id) = name_binding.res().module_like_def_id() {
                     // form the path
                     let mut path_segments = path_segments.clone();
                     path_segments.push(ast::PathSegment::from_ident(ident));
-                    let module_def_id = module.def_id();
                     let doc_visible = doc_visible
                         && (module_def_id.is_local() || !r.tcx.is_doc_hidden(module_def_id));
                     if module_def_id == def_id {
                         let path =
                             Path { span: name_binding.span, segments: path_segments, tokens: None };
                         result = Some((
-                            module,
+                            r.expect_module(module_def_id),
                             ImportSuggestion {
                                 did: Some(def_id),
                                 descr: "module",
@@ -2682,6 +2681,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                     } else {
                         // add the module to the lookup
                         if seen_modules.insert(module_def_id) {
+                            let module = r.expect_module(module_def_id);
                             worklist.push((module, path_segments, doc_visible));
                         }
                     }
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index c2b3451d4a1..eb2b9260483 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -674,7 +674,6 @@ impl<'ra> Module<'ra> {
         }
     }
 
-    // Public for rustdoc.
     fn def_id(self) -> DefId {
         self.opt_def_id().expect("`ModuleData::def_id` is called on a block module")
     }
@@ -782,7 +781,6 @@ impl<'ra> ToNameBinding<'ra> for NameBinding<'ra> {
 #[derive(Clone, Copy, Debug)]
 enum NameBindingKind<'ra> {
     Res(Res),
-    Module(Module<'ra>),
     Import { binding: NameBinding<'ra>, import: Import<'ra> },
 }
 
@@ -875,18 +873,9 @@ struct AmbiguityError<'ra> {
 }
 
 impl<'ra> NameBindingData<'ra> {
-    fn module(&self) -> Option<Module<'ra>> {
-        match self.kind {
-            NameBindingKind::Module(module) => Some(module),
-            NameBindingKind::Import { binding, .. } => binding.module(),
-            _ => None,
-        }
-    }
-
     fn res(&self) -> Res {
         match self.kind {
             NameBindingKind::Res(res) => res,
-            NameBindingKind::Module(module) => module.res().unwrap(),
             NameBindingKind::Import { binding, .. } => binding.res(),
         }
     }
@@ -921,7 +910,7 @@ impl<'ra> NameBindingData<'ra> {
                 DefKind::Variant | DefKind::Ctor(CtorOf::Variant, ..),
                 _,
             )) => true,
-            NameBindingKind::Res(..) | NameBindingKind::Module(..) => false,
+            NameBindingKind::Res(..) => false,
         }
     }
 
@@ -930,11 +919,7 @@ impl<'ra> NameBindingData<'ra> {
             NameBindingKind::Import { import, .. } => {
                 matches!(import.kind, ImportKind::ExternCrate { .. })
             }
-            NameBindingKind::Module(module)
-                if let ModuleKind::Def(DefKind::Mod, def_id, _) = module.kind =>
-            {
-                def_id.is_crate_root()
-            }
+            NameBindingKind::Res(Res::Def(_, def_id)) => def_id.is_crate_root(),
             _ => false,
         }
     }
@@ -1279,7 +1264,8 @@ impl<'ra> ResolverArenas<'ra> {
         if let Some(def_id) = def_id {
             module_map.insert(def_id, module);
             let vis = ty::Visibility::<DefId>::Public;
-            let binding = (module, vis, module.span, LocalExpnId::ROOT).to_name_binding(self);
+            let res = module.res().unwrap();
+            let binding = (res, vis, module.span, LocalExpnId::ROOT).to_name_binding(self);
             module_self_bindings.insert(module, binding);
         }
         module
@@ -1838,7 +1824,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         module.ensure_traits(self);
         let traits = module.traits.borrow();
         for (trait_name, trait_binding) in traits.as_ref().unwrap().iter() {
-            if self.trait_may_have_item(trait_binding.module(), assoc_item) {
+            let trait_module = self.get_module(trait_binding.res().def_id());
+            if self.trait_may_have_item(trait_module, assoc_item) {
                 let def_id = trait_binding.res().def_id();
                 let import_ids = self.find_transitive_imports(&trait_binding.kind, *trait_name);
                 found_traits.push(TraitCandidate { def_id, import_ids });
@@ -2174,9 +2161,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 } else {
                     self.crate_loader(|c| c.maybe_process_path_extern(ident.name))?
                 };
-                let crate_root = self.expect_module(crate_id.as_def_id());
+                let res = Res::Def(DefKind::Mod, crate_id.as_def_id());
                 let vis = ty::Visibility::<DefId>::Public;
-                (crate_root, vis, DUMMY_SP, LocalExpnId::ROOT).to_name_binding(self.arenas)
+                (res, vis, DUMMY_SP, LocalExpnId::ROOT).to_name_binding(self.arenas)
             })
         });
 
diff --git a/tests/ui/proc-macro/meta-macro-hygiene.stdout b/tests/ui/proc-macro/meta-macro-hygiene.stdout
index 1734b9afe92..91d16eca1b0 100644
--- a/tests/ui/proc-macro/meta-macro-hygiene.stdout
+++ b/tests/ui/proc-macro/meta-macro-hygiene.stdout
@@ -49,12 +49,6 @@ crate0::{{expn1}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt:
 crate0::{{expn2}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Bang, "produce_it")
 crate0::{{expn3}}: parent: crate0::{{expn2}}, call_site_ctxt: #3, def_site_ctxt: #0, kind: Macro(Bang, "meta_macro::print_def_site")
 crate0::{{expn4}}: parent: crate0::{{expn3}}, call_site_ctxt: #4, def_site_ctxt: #0, kind: Macro(Bang, "$crate::dummy")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "diagnostic::on_unimplemented")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "diagnostic::on_unimplemented")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "diagnostic::on_unimplemented")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "derive")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "derive")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Bang, "include")
 
 SyntaxContexts:
 #0: parent: #0, outer_mark: (crate0::{{expn0}}, Opaque)
diff --git a/tests/ui/proc-macro/nonterminal-token-hygiene.stdout b/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
index 42257312a87..63741326e34 100644
--- a/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
+++ b/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
@@ -72,12 +72,6 @@ crate0::{{expn1}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt:
 crate0::{{expn2}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Bang, "outer")
 crate0::{{expn3}}: parent: crate0::{{expn2}}, call_site_ctxt: #3, def_site_ctxt: #3, kind: Macro(Bang, "inner")
 crate0::{{expn4}}: parent: crate0::{{expn3}}, call_site_ctxt: #4, def_site_ctxt: #0, kind: Macro(Bang, "print_bang")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "diagnostic::on_unimplemented")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "diagnostic::on_unimplemented")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "diagnostic::on_unimplemented")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "derive")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "derive")
-crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Bang, "include")
 
 SyntaxContexts:
 #0: parent: #0, outer_mark: (crate0::{{expn0}}, Opaque)
-- 
cgit 1.4.1-3-g733a5


From 01b546a19b36bebddc8fbb175837a1d90010d8bd Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Fri, 4 Jul 2025 23:53:34 +0300
Subject: resolve: Remove trait `ToNameBinding`

---
 compiler/rustc_resolve/src/build_reduced_graph.rs | 83 ++++++++++++-----------
 compiler/rustc_resolve/src/ident.rs               | 13 ++--
 compiler/rustc_resolve/src/imports.rs             |  2 +-
 compiler/rustc_resolve/src/lib.rs                 | 57 +++++++++-------
 compiler/rustc_resolve/src/macros.rs              |  7 +-
 5 files changed, 84 insertions(+), 78 deletions(-)

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index a51cdbe76ee..4065dbca675 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -33,39 +33,42 @@ use crate::imports::{ImportData, ImportKind};
 use crate::macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
 use crate::{
     BindingKey, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind, ModuleOrUniformRoot,
-    NameBinding, NameBindingData, NameBindingKind, ParentScope, PathResult, ResolutionError,
-    Resolver, ResolverArenas, Segment, ToNameBinding, Used, VisResolutionError, errors,
+    NameBinding, ParentScope, PathResult, ResolutionError, Resolver, Segment, Used,
+    VisResolutionError, errors,
 };
 
 type Res = def::Res<NodeId>;
 
-impl<'ra, Id: Into<DefId>> ToNameBinding<'ra> for (Res, ty::Visibility<Id>, Span, LocalExpnId) {
-    fn to_name_binding(self, arenas: &'ra ResolverArenas<'ra>) -> NameBinding<'ra> {
-        arenas.alloc_name_binding(NameBindingData {
-            kind: NameBindingKind::Res(self.0),
-            ambiguity: None,
-            warn_ambiguity: false,
-            vis: self.1.to_def_id(),
-            span: self.2,
-            expansion: self.3,
-        })
-    }
-}
-
 impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     /// Defines `name` in namespace `ns` of module `parent` to be `def` if it is not yet defined;
     /// otherwise, reports an error.
-    pub(crate) fn define<T>(&mut self, parent: Module<'ra>, ident: Ident, ns: Namespace, def: T)
-    where
-        T: ToNameBinding<'ra>,
-    {
-        let binding = def.to_name_binding(self.arenas);
+    pub(crate) fn define_binding(
+        &mut self,
+        parent: Module<'ra>,
+        ident: Ident,
+        ns: Namespace,
+        binding: NameBinding<'ra>,
+    ) {
         let key = self.new_disambiguated_key(ident, ns);
         if let Err(old_binding) = self.try_define(parent, key, binding, false) {
             self.report_conflict(parent, ident, ns, old_binding, binding);
         }
     }
 
+    fn define(
+        &mut self,
+        parent: Module<'ra>,
+        ident: Ident,
+        ns: Namespace,
+        res: Res,
+        vis: ty::Visibility<impl Into<DefId>>,
+        span: Span,
+        expn_id: LocalExpnId,
+    ) {
+        let binding = self.arenas.new_res_binding(res, vis.to_def_id(), span, expn_id);
+        self.define_binding(parent, ident, ns, binding)
+    }
+
     /// Walks up the tree of definitions starting at `def_id`,
     /// stopping at the first encountered module.
     /// Parent block modules for arbitrary def-ids are not recorded for the local crate,
@@ -223,7 +226,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 _,
             )
             | Res::PrimTy(..)
-            | Res::ToolMod => self.define(parent, ident, TypeNS, (res, vis, span, expansion)),
+            | Res::ToolMod => self.define(parent, ident, TypeNS, res, vis, span, expansion),
             Res::Def(
                 DefKind::Fn
                 | DefKind::AssocFn
@@ -232,9 +235,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 | DefKind::AssocConst
                 | DefKind::Ctor(..),
                 _,
-            ) => self.define(parent, ident, ValueNS, (res, vis, span, expansion)),
+            ) => self.define(parent, ident, ValueNS, res, vis, span, expansion),
             Res::Def(DefKind::Macro(..), _) | Res::NonMacroAttr(..) => {
-                self.define(parent, ident, MacroNS, (res, vis, span, expansion))
+                self.define(parent, ident, MacroNS, res, vis, span, expansion)
             }
             Res::Def(
                 DefKind::TyParam
@@ -698,7 +701,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         let expansion = parent_scope.expansion;
 
         // Define a name in the type namespace if it is not anonymous.
-        self.r.define(parent, ident, TypeNS, (adt_res, adt_vis, adt_span, expansion));
+        self.r.define(parent, ident, TypeNS, adt_res, adt_vis, adt_span, expansion);
         self.r.feed_visibility(feed, adt_vis);
         let def_id = feed.key();
 
@@ -750,7 +753,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             }
 
             ItemKind::Mod(_, ident, ref mod_kind) => {
-                self.r.define(parent, ident, TypeNS, (res, vis, sp, expansion));
+                self.r.define(parent, ident, TypeNS, res, vis, sp, expansion);
 
                 if let ast::ModKind::Loaded(_, _, _, Err(_)) = mod_kind {
                     self.r.mods_with_parse_errors.insert(def_id);
@@ -769,10 +772,10 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             ItemKind::Const(box ConstItem { ident, .. })
             | ItemKind::Delegation(box Delegation { ident, .. })
             | ItemKind::Static(box StaticItem { ident, .. }) => {
-                self.r.define(parent, ident, ValueNS, (res, vis, sp, expansion));
+                self.r.define(parent, ident, ValueNS, res, vis, sp, expansion);
             }
             ItemKind::Fn(box Fn { ident, .. }) => {
-                self.r.define(parent, ident, ValueNS, (res, vis, sp, expansion));
+                self.r.define(parent, ident, ValueNS, res, vis, sp, expansion);
 
                 // Functions introducing procedural macros reserve a slot
                 // in the macro namespace as well (see #52225).
@@ -781,11 +784,11 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
 
             // These items live in the type namespace.
             ItemKind::TyAlias(box TyAlias { ident, .. }) | ItemKind::TraitAlias(ident, ..) => {
-                self.r.define(parent, ident, TypeNS, (res, vis, sp, expansion));
+                self.r.define(parent, ident, TypeNS, res, vis, sp, expansion);
             }
 
             ItemKind::Enum(ident, _, _) | ItemKind::Trait(box ast::Trait { ident, .. }) => {
-                self.r.define(parent, ident, TypeNS, (res, vis, sp, expansion));
+                self.r.define(parent, ident, TypeNS, res, vis, sp, expansion);
 
                 self.parent_scope.module = self.r.new_module(
                     Some(parent),
@@ -837,7 +840,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                     let feed = self.r.feed(ctor_node_id);
                     let ctor_def_id = feed.key();
                     let ctor_res = self.res(ctor_def_id);
-                    self.r.define(parent, ident, ValueNS, (ctor_res, ctor_vis, sp, expansion));
+                    self.r.define(parent, ident, ValueNS, ctor_res, ctor_vis, sp, expansion);
                     self.r.feed_visibility(feed, ctor_vis);
                     // We need the field visibility spans also for the constructor for E0603.
                     self.insert_field_visibilities_local(ctor_def_id.to_def_id(), vdata.fields());
@@ -901,9 +904,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         }
         .map(|module| {
             let used = self.process_macro_use_imports(item, module);
-            let res = module.res().unwrap();
-            let vis = ty::Visibility::<LocalDefId>::Public;
-            let binding = (res, vis, sp, expansion).to_name_binding(self.r.arenas);
+            let binding = self.r.arenas.new_pub_res_binding(module.res().unwrap(), sp, expansion);
             (used, Some(ModuleOrUniformRoot::Module(module)), binding)
         })
         .unwrap_or((true, None, self.r.dummy_binding));
@@ -960,7 +961,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 );
             }
         }
-        self.r.define(parent, ident, TypeNS, imported_binding);
+        self.r.define_binding(parent, ident, TypeNS, imported_binding);
     }
 
     /// Constructs the reduced graph for one foreign item.
@@ -977,7 +978,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         let parent = self.parent_scope.module;
         let expansion = self.parent_scope.expansion;
         let vis = self.resolve_visibility(&item.vis);
-        self.r.define(parent, ident, ns, (self.res(def_id), vis, item.span, expansion));
+        self.r.define(parent, ident, ns, self.res(def_id), vis, item.span, expansion);
         self.r.feed_visibility(feed, vis);
     }
 
@@ -1217,7 +1218,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             } else {
                 ty::Visibility::Restricted(CRATE_DEF_ID)
             };
-            let binding = (res, vis, span, expansion).to_name_binding(self.r.arenas);
+            let binding = self.r.arenas.new_res_binding(res, vis.to_def_id(), span, expansion);
             self.r.set_binding_parent_module(binding, parent_scope.module);
             self.r.all_macro_rules.insert(ident.name);
             if is_macro_export {
@@ -1236,7 +1237,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 });
                 self.r.import_use_map.insert(import, Used::Other);
                 let import_binding = self.r.import(binding, import);
-                self.r.define(self.r.graph_root, ident, MacroNS, import_binding);
+                self.r.define_binding(self.r.graph_root, ident, MacroNS, import_binding);
             } else {
                 self.r.check_reserved_macro_name(ident, res);
                 self.insert_unused_macro(ident, def_id, item.id);
@@ -1264,7 +1265,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             if !vis.is_public() {
                 self.insert_unused_macro(ident, def_id, item.id);
             }
-            self.r.define(module, ident, MacroNS, (res, vis, span, expansion));
+            self.r.define(module, ident, MacroNS, res, vis, span, expansion);
             self.r.feed_visibility(feed, vis);
             self.parent_scope.macro_rules
         }
@@ -1400,7 +1401,7 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         if ctxt == AssocCtxt::Trait {
             let parent = self.parent_scope.module;
             let expansion = self.parent_scope.expansion;
-            self.r.define(parent, ident, ns, (self.res(def_id), vis, item.span, expansion));
+            self.r.define(parent, ident, ns, self.res(def_id), vis, item.span, expansion);
         } else if !matches!(&item.kind, AssocItemKind::Delegation(deleg) if deleg.from_glob) {
             let impl_def_id = self.r.tcx.local_parent(local_def_id);
             let key = BindingKey::new(ident.normalize_to_macros_2_0(), ns);
@@ -1485,7 +1486,7 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         let feed = self.r.feed(variant.id);
         let def_id = feed.key();
         let vis = self.resolve_visibility(&variant.vis);
-        self.r.define(parent, ident, TypeNS, (self.res(def_id), vis, variant.span, expn_id));
+        self.r.define(parent, ident, TypeNS, self.res(def_id), vis, variant.span, expn_id);
         self.r.feed_visibility(feed, vis);
 
         // If the variant is marked as non_exhaustive then lower the visibility to within the crate.
@@ -1501,7 +1502,7 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             let feed = self.r.feed(ctor_node_id);
             let ctor_def_id = feed.key();
             let ctor_res = self.res(ctor_def_id);
-            self.r.define(parent, ident, ValueNS, (ctor_res, ctor_vis, variant.span, expn_id));
+            self.r.define(parent, ident, ValueNS, ctor_res, ctor_vis, variant.span, expn_id);
             self.r.feed_visibility(feed, ctor_vis);
         }
 
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 04f9e35b6b4..84d66c15f00 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -3,11 +3,10 @@ use Namespace::*;
 use rustc_ast::{self as ast, NodeId};
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{DefKind, Namespace, NonMacroAttrKind, PartialRes, PerNS};
-use rustc_middle::{bug, ty};
+use rustc_middle::bug;
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::PROC_MACRO_DERIVE_RESOLUTION_FALLBACK;
 use rustc_session::parse::feature_err;
-use rustc_span::def_id::LocalDefId;
 use rustc_span::hygiene::{ExpnId, ExpnKind, LocalExpnId, MacroKind, SyntaxContext};
 use rustc_span::{Ident, Span, kw, sym};
 use tracing::{debug, instrument};
@@ -20,11 +19,9 @@ use crate::{
     AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, BindingKey, Determinacy, Finalize,
     ImportKind, LexicalScopeBinding, Module, ModuleKind, ModuleOrUniformRoot, NameBinding,
     NameBindingKind, ParentScope, PathResult, PrivacyError, Res, ResolutionError, Resolver, Scope,
-    ScopeSet, Segment, ToNameBinding, Used, Weak, errors,
+    ScopeSet, Segment, Used, Weak, errors,
 };
 
-type Visibility = ty::Visibility<LocalDefId>;
-
 #[derive(Copy, Clone)]
 pub enum UsePrelude {
     No,
@@ -464,13 +461,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             ) {
                                 Ok((Some(ext), _)) => {
                                     if ext.helper_attrs.contains(&ident.name) {
-                                        let binding = (
+                                        let binding = this.arenas.new_pub_res_binding(
                                             Res::NonMacroAttr(NonMacroAttrKind::DeriveHelperCompat),
-                                            Visibility::Public,
                                             derive.span,
                                             LocalExpnId::ROOT,
-                                        )
-                                            .to_name_binding(this.arenas);
+                                        );
                                         result = Ok((binding, Flags::empty()));
                                         break;
                                     }
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 2fa20b25469..59896ee88f4 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -872,7 +872,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         }
                         // We need the `target`, `source` can be extracted.
                         let imported_binding = this.import(binding, import);
-                        this.define(parent, target, ns, imported_binding);
+                        this.define_binding(parent, target, ns, imported_binding);
                         PendingBinding::Ready(Some(imported_binding))
                     }
                     Err(Determinacy::Determined) => {
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index eb2b9260483..cf106a4892c 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -768,16 +768,6 @@ impl std::hash::Hash for NameBindingData<'_> {
     }
 }
 
-trait ToNameBinding<'ra> {
-    fn to_name_binding(self, arenas: &'ra ResolverArenas<'ra>) -> NameBinding<'ra>;
-}
-
-impl<'ra> ToNameBinding<'ra> for NameBinding<'ra> {
-    fn to_name_binding(self, _: &'ra ResolverArenas<'ra>) -> NameBinding<'ra> {
-        self
-    }
-}
-
 #[derive(Clone, Copy, Debug)]
 enum NameBindingKind<'ra> {
     Res(Res),
@@ -1240,6 +1230,32 @@ pub struct ResolverArenas<'ra> {
 }
 
 impl<'ra> ResolverArenas<'ra> {
+    fn new_res_binding(
+        &'ra self,
+        res: Res,
+        vis: ty::Visibility<DefId>,
+        span: Span,
+        expansion: LocalExpnId,
+    ) -> NameBinding<'ra> {
+        self.alloc_name_binding(NameBindingData {
+            kind: NameBindingKind::Res(res),
+            ambiguity: None,
+            warn_ambiguity: false,
+            vis,
+            span,
+            expansion,
+        })
+    }
+
+    fn new_pub_res_binding(
+        &'ra self,
+        res: Res,
+        span: Span,
+        expn_id: LocalExpnId,
+    ) -> NameBinding<'ra> {
+        self.new_res_binding(res, Visibility::Public, span, expn_id)
+    }
+
     fn new_module(
         &'ra self,
         parent: Option<Module<'ra>>,
@@ -1263,9 +1279,8 @@ impl<'ra> ResolverArenas<'ra> {
         }
         if let Some(def_id) = def_id {
             module_map.insert(def_id, module);
-            let vis = ty::Visibility::<DefId>::Public;
             let res = module.res().unwrap();
-            let binding = (res, vis, module.span, LocalExpnId::ROOT).to_name_binding(self);
+            let binding = self.new_pub_res_binding(res, module.span, LocalExpnId::ROOT);
             module_self_bindings.insert(module, binding);
         }
         module
@@ -1456,8 +1471,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
 
         let registered_tools = tcx.registered_tools(());
-
-        let pub_vis = ty::Visibility::<DefId>::Public;
         let edition = tcx.sess.edition();
 
         let mut resolver = Resolver {
@@ -1506,12 +1519,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             macro_expanded_macro_export_errors: BTreeSet::new(),
 
             arenas,
-            dummy_binding: (Res::Err, pub_vis, DUMMY_SP, LocalExpnId::ROOT).to_name_binding(arenas),
+            dummy_binding: arenas.new_pub_res_binding(Res::Err, DUMMY_SP, LocalExpnId::ROOT),
             builtin_types_bindings: PrimTy::ALL
                 .iter()
                 .map(|prim_ty| {
-                    let binding = (Res::PrimTy(*prim_ty), pub_vis, DUMMY_SP, LocalExpnId::ROOT)
-                        .to_name_binding(arenas);
+                    let res = Res::PrimTy(*prim_ty);
+                    let binding = arenas.new_pub_res_binding(res, DUMMY_SP, LocalExpnId::ROOT);
                     (prim_ty.name(), binding)
                 })
                 .collect(),
@@ -1519,16 +1532,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 .iter()
                 .map(|builtin_attr| {
                     let res = Res::NonMacroAttr(NonMacroAttrKind::Builtin(builtin_attr.name));
-                    let binding =
-                        (res, pub_vis, DUMMY_SP, LocalExpnId::ROOT).to_name_binding(arenas);
+                    let binding = arenas.new_pub_res_binding(res, DUMMY_SP, LocalExpnId::ROOT);
                     (builtin_attr.name, binding)
                 })
                 .collect(),
             registered_tool_bindings: registered_tools
                 .iter()
                 .map(|ident| {
-                    let binding = (Res::ToolMod, pub_vis, ident.span, LocalExpnId::ROOT)
-                        .to_name_binding(arenas);
+                    let res = Res::ToolMod;
+                    let binding = arenas.new_pub_res_binding(res, ident.span, LocalExpnId::ROOT);
                     (*ident, binding)
                 })
                 .collect(),
@@ -2162,8 +2174,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     self.crate_loader(|c| c.maybe_process_path_extern(ident.name))?
                 };
                 let res = Res::Def(DefKind::Mod, crate_id.as_def_id());
-                let vis = ty::Visibility::<DefId>::Public;
-                (res, vis, DUMMY_SP, LocalExpnId::ROOT).to_name_binding(self.arenas)
+                self.arenas.new_pub_res_binding(res, DUMMY_SP, LocalExpnId::ROOT)
             })
         });
 
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index cbb24289f51..c17d74659db 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -20,7 +20,7 @@ use rustc_expand::expand::{
 use rustc_hir::def::{self, DefKind, Namespace, NonMacroAttrKind};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
 use rustc_middle::middle::stability;
-use rustc_middle::ty::{RegisteredTools, TyCtxt, Visibility};
+use rustc_middle::ty::{RegisteredTools, TyCtxt};
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{
     LEGACY_DERIVE_HELPERS, OUT_OF_SCOPE_MACRO_CALLS, UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
@@ -41,7 +41,7 @@ use crate::imports::Import;
 use crate::{
     BindingKey, DeriveData, Determinacy, Finalize, InvocationParent, MacroData, ModuleKind,
     ModuleOrUniformRoot, NameBinding, NameBindingKind, ParentScope, PathResult, ResolutionError,
-    Resolver, ScopeSet, Segment, ToNameBinding, Used,
+    Resolver, ScopeSet, Segment, Used,
 };
 
 type Res = def::Res<NodeId>;
@@ -436,8 +436,7 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
             .iter()
             .map(|(_, ident)| {
                 let res = Res::NonMacroAttr(NonMacroAttrKind::DeriveHelper);
-                let binding = (res, Visibility::<DefId>::Public, ident.span, expn_id)
-                    .to_name_binding(self.arenas);
+                let binding = self.arenas.new_pub_res_binding(res, ident.span, expn_id);
                 (*ident, binding)
             })
             .collect();
-- 
cgit 1.4.1-3-g733a5


From 4fa23d96bc9334716b8f50511f5a920b46d349dd Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Tue, 15 Jul 2025 22:28:05 -0700
Subject: Improve comments inside `codegen_get_discr`

---
 compiler/rustc_codegen_ssa/src/mir/operand.rs | 48 +++++++++++++++++++++++++--
 1 file changed, 46 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index 9910cb5469f..6a3fdb6ede1 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -517,8 +517,52 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
                         bx.cx().const_uint(cast_to, niche_variants.start().as_u32() as u64);
                     (is_niche, tagged_discr, 0)
                 } else {
-                    // The special cases don't apply, so we'll have to go with
-                    // the general algorithm.
+                    // With multiple niched variants we'll have to actually compute
+                    // the variant index from the stored tag.
+                    //
+                    // However, there's still one small optimization we can often do for
+                    // determining *whether* a tag value is a natural value or a niched
+                    // variant. The general algorithm involves a subtraction that often
+                    // wraps in practice, making it tricky to analyse. However, in cases
+                    // where there are few enough possible values of the tag that it doesn't
+                    // need to wrap around, we can instead just look for the contiguous
+                    // tag values on the end of the range with a single comparison.
+                    //
+                    // For example, take the type `enum Demo { A, B, Untagged(bool) }`.
+                    // The `bool` is {0, 1}, and the two other variants are given the
+                    // tags {2, 3} respectively. That means the `tag_range` is
+                    // `[0, 3]`, which doesn't wrap as unsigned (nor as signed), so
+                    // we can test for the niched variants with just `>= 2`.
+                    //
+                    // That means we're looking either for the niche values *above*
+                    // the natural values of the untagged variant:
+                    //
+                    //             niche_start                  niche_end
+                    //                  |                           |
+                    //                  v                           v
+                    // MIN -------------+---------------------------+---------- MAX
+                    //         ^        |         is niche          |
+                    //         |        +---------------------------+
+                    //         |                                    |
+                    //   tag_range.start                      tag_range.end
+                    //
+                    // Or *below* the natural values:
+                    //
+                    //    niche_start              niche_end
+                    //         |                       |
+                    //         v                       v
+                    // MIN ----+-----------------------+---------------------- MAX
+                    //         |       is niche        |           ^
+                    //         +-----------------------+           |
+                    //         |                                   |
+                    //   tag_range.start                      tag_range.end
+                    //
+                    // With those two options and having the flexibility to choose
+                    // between a signed or unsigned comparison on the tag, that
+                    // covers most realistic scenarios. The tests have a (contrived)
+                    // example of a 1-byte enum with over 128 niched variants which
+                    // wraps both as signed as unsigned, though, and for something
+                    // like that we're stuck with the general algorithm.
 
                     let tag_range = tag_scalar.valid_range(&dl);
                     let tag_size = tag_scalar.size(&dl);
-- 
cgit 1.4.1-3-g733a5


From 1a9a226058a31fab77229afc4b0e04c259c64112 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Sat, 5 Jul 2025 00:43:52 +0300
Subject: resolve: Import `ty::Visibility` everywhere

---
 compiler/rustc_resolve/src/build_reduced_graph.rs | 44 +++++++++++------------
 compiler/rustc_resolve/src/imports.rs             |  9 ++---
 compiler/rustc_resolve/src/late.rs                |  8 ++---
 compiler/rustc_resolve/src/lib.rs                 | 20 +++++------
 4 files changed, 39 insertions(+), 42 deletions(-)

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index 4065dbca675..5a1be618cee 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -20,9 +20,9 @@ use rustc_hir::def::{self, *};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
 use rustc_index::bit_set::DenseBitSet;
 use rustc_metadata::creader::LoadedMacro;
+use rustc_middle::bug;
 use rustc_middle::metadata::ModChild;
-use rustc_middle::ty::Feed;
-use rustc_middle::{bug, ty};
+use rustc_middle::ty::{Feed, Visibility};
 use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind};
 use rustc_span::{Ident, Span, Symbol, kw, sym};
 use tracing::debug;
@@ -61,7 +61,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         ident: Ident,
         ns: Namespace,
         res: Res,
-        vis: ty::Visibility<impl Into<DefId>>,
+        vis: Visibility<impl Into<DefId>>,
         span: Span,
         expn_id: LocalExpnId,
     ) {
@@ -281,10 +281,10 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         Res::Def(self.r.tcx.def_kind(def_id), def_id)
     }
 
-    fn resolve_visibility(&mut self, vis: &ast::Visibility) -> ty::Visibility {
+    fn resolve_visibility(&mut self, vis: &ast::Visibility) -> Visibility {
         self.try_resolve_visibility(vis, true).unwrap_or_else(|err| {
             self.r.report_vis_error(err);
-            ty::Visibility::Public
+            Visibility::Public
         })
     }
 
@@ -292,10 +292,10 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         &mut self,
         vis: &'ast ast::Visibility,
         finalize: bool,
-    ) -> Result<ty::Visibility, VisResolutionError<'ast>> {
+    ) -> Result<Visibility, VisResolutionError<'ast>> {
         let parent_scope = &self.parent_scope;
         match vis.kind {
-            ast::VisibilityKind::Public => Ok(ty::Visibility::Public),
+            ast::VisibilityKind::Public => Ok(Visibility::Public),
             ast::VisibilityKind::Inherited => {
                 Ok(match self.parent_scope.module.kind {
                     // Any inherited visibility resolved directly inside an enum or trait
@@ -305,7 +305,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                         self.r.tcx.visibility(def_id).expect_local()
                     }
                     // Otherwise, the visibility is restricted to the nearest parent `mod` item.
-                    _ => ty::Visibility::Restricted(
+                    _ => Visibility::Restricted(
                         self.parent_scope.module.nearest_parent_mod().expect_local(),
                     ),
                 })
@@ -353,9 +353,9 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                         }
                         if module.is_normal() {
                             match res {
-                                Res::Err => Ok(ty::Visibility::Public),
+                                Res::Err => Ok(Visibility::Public),
                                 _ => {
-                                    let vis = ty::Visibility::Restricted(res.def_id());
+                                    let vis = Visibility::Restricted(res.def_id());
                                     if self.r.is_accessible_from(vis, parent_scope.module) {
                                         Ok(vis.expect_local())
                                     } else {
@@ -420,7 +420,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         item: &ast::Item,
         root_span: Span,
         root_id: NodeId,
-        vis: ty::Visibility,
+        vis: Visibility,
     ) {
         let current_module = self.parent_scope.module;
         let import = self.r.arenas.alloc_import(ImportData {
@@ -468,7 +468,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         list_stem: bool,
         // The whole `use` item
         item: &Item,
-        vis: ty::Visibility,
+        vis: Visibility,
         root_span: Span,
     ) {
         debug!(
@@ -677,7 +677,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                         true,
                         // The whole `use` item
                         item,
-                        ty::Visibility::Restricted(
+                        Visibility::Restricted(
                             self.parent_scope.module.nearest_parent_mod().expect_local(),
                         ),
                         root_span,
@@ -693,7 +693,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         ident: Ident,
         feed: Feed<'tcx, LocalDefId>,
         adt_res: Res,
-        adt_vis: ty::Visibility,
+        adt_vis: Visibility,
         adt_span: Span,
     ) {
         let parent_scope = &self.parent_scope;
@@ -818,7 +818,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                     let mut ctor_vis = if vis.is_public()
                         && ast::attr::contains_name(&item.attrs, sym::non_exhaustive)
                     {
-                        ty::Visibility::Restricted(CRATE_DEF_ID)
+                        Visibility::Restricted(CRATE_DEF_ID)
                     } else {
                         vis
                     };
@@ -831,7 +831,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                         // constructor visibility should still be determined correctly.
                         let field_vis = self
                             .try_resolve_visibility(&field.vis, false)
-                            .unwrap_or(ty::Visibility::Public);
+                            .unwrap_or(Visibility::Public);
                         if ctor_vis.is_at_least(field_vis, self.r.tcx) {
                             ctor_vis = field_vis;
                         }
@@ -880,7 +880,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         item: &Item,
         ident: Ident,
         local_def_id: LocalDefId,
-        vis: ty::Visibility,
+        vis: Visibility,
         parent: Module<'ra>,
     ) {
         let sp = item.span;
@@ -1064,7 +1064,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 root_span: span,
                 span,
                 module_path: Vec::new(),
-                vis: ty::Visibility::Restricted(CRATE_DEF_ID),
+                vis: Visibility::Restricted(CRATE_DEF_ID),
             })
         };
 
@@ -1214,9 +1214,9 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             self.r.macro_names.insert(ident);
             let is_macro_export = ast::attr::contains_name(&item.attrs, sym::macro_export);
             let vis = if is_macro_export {
-                ty::Visibility::Public
+                Visibility::Public
             } else {
-                ty::Visibility::Restricted(CRATE_DEF_ID)
+                Visibility::Restricted(CRATE_DEF_ID)
             };
             let binding = self.r.arenas.new_res_binding(res, vis.to_def_id(), span, expansion);
             self.r.set_binding_parent_module(binding, parent_scope.module);
@@ -1258,7 +1258,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 // Visibilities must not be resolved non-speculatively twice
                 // and we already resolved this one as a `fn` item visibility.
                 ItemKind::Fn(..) => {
-                    self.try_resolve_visibility(&item.vis, false).unwrap_or(ty::Visibility::Public)
+                    self.try_resolve_visibility(&item.vis, false).unwrap_or(Visibility::Public)
                 }
                 _ => self.resolve_visibility(&item.vis),
             };
@@ -1492,7 +1492,7 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         // If the variant is marked as non_exhaustive then lower the visibility to within the crate.
         let ctor_vis =
             if vis.is_public() && ast::attr::contains_name(&variant.attrs, sym::non_exhaustive) {
-                ty::Visibility::Restricted(CRATE_DEF_ID)
+                Visibility::Restricted(CRATE_DEF_ID)
             } else {
                 vis
             };
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 59896ee88f4..9a031ee03e0 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -11,7 +11,8 @@ use rustc_errors::{Applicability, MultiSpan, pluralize, struct_span_code_err};
 use rustc_hir::def::{self, DefKind, PartialRes};
 use rustc_hir::def_id::DefId;
 use rustc_middle::metadata::{ModChild, Reexport};
-use rustc_middle::{span_bug, ty};
+use rustc_middle::span_bug;
+use rustc_middle::ty::Visibility;
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{
     AMBIGUOUS_GLOB_REEXPORTS, HIDDEN_GLOB_REEXPORTS, PUB_USE_OF_PRIVATE_EXTERN_CRATE,
@@ -88,7 +89,7 @@ pub(crate) enum ImportKind<'ra> {
         is_prelude: bool,
         // The visibility of the greatest re-export.
         // n.b. `max_vis` is only used in `finalize_import` to check for re-export errors.
-        max_vis: Cell<Option<ty::Visibility>>,
+        max_vis: Cell<Option<Visibility>>,
         id: NodeId,
     },
     ExternCrate {
@@ -185,7 +186,7 @@ pub(crate) struct ImportData<'ra> {
     /// |`use ::foo`      | `ModuleOrUniformRoot::CrateRootAndExternPrelude`    | a special case in 2015 edition |
     /// |`use foo`        | `ModuleOrUniformRoot::CurrentScope`                 | - |
     pub imported_module: Cell<Option<ModuleOrUniformRoot<'ra>>>,
-    pub vis: ty::Visibility,
+    pub vis: Visibility,
 }
 
 /// All imports are unique and allocated on a same arena,
@@ -1280,7 +1281,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             if !binding.vis.is_at_least(import.vis, this.tcx) {
                 reexport_error = Some((ns, binding));
-                if let ty::Visibility::Restricted(binding_def_id) = binding.vis
+                if let Visibility::Restricted(binding_def_id) = binding.vis
                     && binding_def_id.is_top_level_module()
                 {
                     crate_private_reexport = true;
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 44a567f7810..3ef98100d09 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -28,7 +28,7 @@ use rustc_hir::def::{self, CtorKind, DefKind, LifetimeRes, NonMacroAttrKind, Par
 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::DelegationFnSig;
+use rustc_middle::ty::{DelegationFnSig, Visibility};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::{CrateType, ResolveDocLinks};
 use rustc_session::lint::{self, BuiltinLintDiag};
@@ -638,8 +638,8 @@ impl PathSource<'_, '_, '_> {
 enum MaybeExported<'a> {
     Ok(NodeId),
     Impl(Option<DefId>),
-    ImplItem(Result<DefId, &'a Visibility>),
-    NestedUse(&'a Visibility),
+    ImplItem(Result<DefId, &'a ast::Visibility>),
+    NestedUse(&'a ast::Visibility),
 }
 
 impl MaybeExported<'_> {
@@ -3463,7 +3463,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     span,
                     "error should be emitted when an unexpected trait item is used",
                 );
-                rustc_middle::ty::Visibility::Public
+                Visibility::Public
             };
             this.r.feed_visibility(this.r.feed(id), vis);
         };
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index cf106a4892c..5c72a6bcf70 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -65,7 +65,7 @@ use rustc_middle::query::Providers;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{
     self, DelegationFnSig, Feed, MainDefinition, RegisteredTools, ResolverGlobalCtxt,
-    ResolverOutputs, TyCtxt, TyCtxtFeed,
+    ResolverOutputs, TyCtxt, TyCtxtFeed, Visibility,
 };
 use rustc_query_system::ich::StableHashingContext;
 use rustc_session::lint::builtin::PRIVATE_MACRO_USE;
@@ -748,7 +748,7 @@ struct NameBindingData<'ra> {
     warn_ambiguity: bool,
     expansion: LocalExpnId,
     span: Span,
-    vis: ty::Visibility<DefId>,
+    vis: Visibility<DefId>,
 }
 
 /// All name bindings are unique and allocated on a same arena,
@@ -1083,7 +1083,7 @@ pub struct Resolver<'ra, 'tcx> {
     /// Maps glob imports to the names of items actually imported.
     glob_map: FxIndexMap<LocalDefId, FxIndexSet<Symbol>>,
     glob_error: Option<ErrorGuaranteed>,
-    visibilities_for_hashing: Vec<(LocalDefId, ty::Visibility)>,
+    visibilities_for_hashing: Vec<(LocalDefId, Visibility)>,
     used_imports: FxHashSet<NodeId>,
     maybe_unused_trait_imports: FxIndexSet<LocalDefId>,
 
@@ -1156,7 +1156,7 @@ pub struct Resolver<'ra, 'tcx> {
     /// Table for mapping struct IDs into struct constructor IDs,
     /// it's not used during normal resolution, only for better error reporting.
     /// Also includes of list of each fields visibility
-    struct_constructors: LocalDefIdMap<(Res, ty::Visibility<DefId>, Vec<ty::Visibility<DefId>>)>,
+    struct_constructors: LocalDefIdMap<(Res, Visibility<DefId>, Vec<Visibility<DefId>>)>,
 
     lint_buffer: LintBuffer,
 
@@ -1233,7 +1233,7 @@ impl<'ra> ResolverArenas<'ra> {
     fn new_res_binding(
         &'ra self,
         res: Res,
-        vis: ty::Visibility<DefId>,
+        vis: Visibility<DefId>,
         span: Span,
         expansion: LocalExpnId,
     ) -> NameBinding<'ra> {
@@ -1603,7 +1603,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         let root_parent_scope = ParentScope::module(graph_root, &resolver);
         resolver.invocation_parent_scopes.insert(LocalExpnId::ROOT, root_parent_scope);
-        resolver.feed_visibility(crate_feed, ty::Visibility::Public);
+        resolver.feed_visibility(crate_feed, Visibility::Public);
 
         resolver
     }
@@ -1657,7 +1657,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         Default::default()
     }
 
-    fn feed_visibility(&mut self, feed: Feed<'tcx, LocalDefId>, vis: ty::Visibility) {
+    fn feed_visibility(&mut self, feed: Feed<'tcx, LocalDefId>, vis: Visibility) {
         let feed = feed.upgrade(self.tcx);
         feed.visibility(vis.to_def_id());
         self.visibilities_for_hashing.push((feed.def_id(), vis));
@@ -2109,11 +2109,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         self.pat_span_map.insert(node, span);
     }
 
-    fn is_accessible_from(
-        &self,
-        vis: ty::Visibility<impl Into<DefId>>,
-        module: Module<'ra>,
-    ) -> bool {
+    fn is_accessible_from(&self, vis: Visibility<impl Into<DefId>>, module: Module<'ra>) -> bool {
         vis.is_accessible_from(module.nearest_parent_mod(), self.tcx)
     }
 
-- 
cgit 1.4.1-3-g733a5


From 7f398fd5f6444bb57196519c2dbe9554c51d8318 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Sat, 5 Jul 2025 22:47:02 +0300
Subject: resolve: Optimize `fn traits_in_module`

---
 compiler/rustc_resolve/src/lib.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 5c72a6bcf70..b0b29bc2eae 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -579,7 +579,7 @@ struct ModuleData<'ra> {
     globs: RefCell<Vec<Import<'ra>>>,
 
     /// Used to memoize the traits in this module for faster searches through all traits in scope.
-    traits: RefCell<Option<Box<[(Ident, NameBinding<'ra>)]>>>,
+    traits: RefCell<Option<Box<[(Ident, NameBinding<'ra>, Option<Module<'ra>>)]>>>,
 
     /// Span of the module itself. Used for error reporting.
     span: Span,
@@ -655,12 +655,12 @@ impl<'ra> Module<'ra> {
         let mut traits = self.traits.borrow_mut();
         if traits.is_none() {
             let mut collected_traits = Vec::new();
-            self.for_each_child(resolver, |_, name, ns, binding| {
+            self.for_each_child(resolver, |r, name, ns, binding| {
                 if ns != TypeNS {
                     return;
                 }
-                if let Res::Def(DefKind::Trait | DefKind::TraitAlias, _) = binding.res() {
-                    collected_traits.push((name, binding))
+                if let Res::Def(DefKind::Trait | DefKind::TraitAlias, def_id) = binding.res() {
+                    collected_traits.push((name, binding, r.as_mut().get_module(def_id)))
                 }
             });
             *traits = Some(collected_traits.into_boxed_slice());
@@ -1835,11 +1835,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     ) {
         module.ensure_traits(self);
         let traits = module.traits.borrow();
-        for (trait_name, trait_binding) in traits.as_ref().unwrap().iter() {
-            let trait_module = self.get_module(trait_binding.res().def_id());
+        for &(trait_name, trait_binding, trait_module) in traits.as_ref().unwrap().iter() {
             if self.trait_may_have_item(trait_module, assoc_item) {
                 let def_id = trait_binding.res().def_id();
-                let import_ids = self.find_transitive_imports(&trait_binding.kind, *trait_name);
+                let import_ids = self.find_transitive_imports(&trait_binding.kind, trait_name);
                 found_traits.push(TraitCandidate { def_id, import_ids });
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 42ec0280274acfa754ae88061ee6e77e7461fad1 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 15 Jul 2025 17:16:53 +0200
Subject: type_id_eq: check that the hash fully matches the type

---
 .../rustc_const_eval/src/interpret/intrinsics.rs   | 99 ++++++++++++----------
 compiler/rustc_const_eval/src/interpret/memory.rs  |  6 +-
 tests/ui/consts/const_transmute_type_id4.rs        |  2 +-
 tests/ui/consts/const_transmute_type_id4.stderr    |  2 +-
 tests/ui/consts/const_transmute_type_id5.rs        |  9 +-
 tests/ui/consts/const_transmute_type_id5.stderr    |  6 +-
 6 files changed, 66 insertions(+), 58 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 22d29eda913..e24a355891d 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -4,8 +4,9 @@
 
 use std::assert_matches::assert_matches;
 
-use rustc_abi::{FieldIdx, Size};
+use rustc_abi::{FieldIdx, HasDataLayout, Size};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
+use rustc_middle::mir::interpret::{read_target_uint, write_target_uint};
 use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{Ty, TyCtxt};
@@ -30,7 +31,7 @@ pub(crate) fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ConstAll
 }
 impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// Generates a value of `TypeId` for `ty` in-place.
-    pub(crate) fn write_type_id(
+    fn write_type_id(
         &mut self,
         ty: Ty<'tcx>,
         dest: &PlaceTy<'tcx, M::Provenance>,
@@ -48,8 +49,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         // Here we rely on `TypeId` being a newtype around an array of pointers, so we
         // first project to its only field and then the array elements.
         let alloc_id = tcx.reserve_and_set_type_id_alloc(ty);
-        let first = self.project_field(dest, FieldIdx::ZERO)?;
-        let mut elem_iter = self.project_array_fields(&first)?;
+        let arr = self.project_field(dest, FieldIdx::ZERO)?;
+        let mut elem_iter = self.project_array_fields(&arr)?;
         while let Some((_, elem)) = elem_iter.next(self)? {
             // Decorate this part of the hash with provenance; leave the integer part unchanged.
             let hash_fragment = self.read_scalar(&elem)?.to_target_usize(&tcx)?;
@@ -61,6 +62,52 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         interp_ok(())
     }
 
+    /// Read a value of type `TypeId`, returning the type it represents.
+    pub(crate) fn read_type_id(
+        &self,
+        op: &OpTy<'tcx, M::Provenance>,
+    ) -> InterpResult<'tcx, Ty<'tcx>> {
+        // `TypeId` is a newtype around an array of pointers. All pointers must have the same
+        // provenance, and that provenance represents the type.
+        let ptr_size = self.pointer_size().bytes_usize();
+        let arr = self.project_field(op, FieldIdx::ZERO)?;
+
+        let mut ty_and_hash = None;
+        let mut elem_iter = self.project_array_fields(&arr)?;
+        while let Some((idx, elem)) = elem_iter.next(self)? {
+            let elem = self.read_pointer(&elem)?;
+            let (elem_ty, elem_hash) = self.get_ptr_type_id(elem)?;
+            // If this is the first element, remember the type and its hash.
+            // If this is not the first element, ensure it is consistent with the previous ones.
+            let full_hash = match ty_and_hash {
+                None => {
+                    let hash = self.tcx.type_id_hash(elem_ty).as_u128();
+                    let mut hash_bytes = [0u8; 16];
+                    write_target_uint(self.data_layout().endian, &mut hash_bytes, hash).unwrap();
+                    ty_and_hash = Some((elem_ty, hash_bytes));
+                    hash_bytes
+                }
+                Some((ty, hash_bytes)) => {
+                    if ty != elem_ty {
+                        throw_ub_format!(
+                            "invalid `TypeId` value: not all bytes carry the same type id metadata"
+                        );
+                    }
+                    hash_bytes
+                }
+            };
+            // Ensure the elem_hash matches the corresponding part of the full hash.
+            let hash_frag = &full_hash[(idx as usize) * ptr_size..][..ptr_size];
+            if read_target_uint(self.data_layout().endian, hash_frag).unwrap() != elem_hash.into() {
+                throw_ub_format!(
+                    "invalid `TypeId` value: the hash does not match the type id metadata"
+                );
+            }
+        }
+
+        interp_ok(ty_and_hash.unwrap().0)
+    }
+
     /// Returns `true` if emulation happened.
     /// Here we implement the intrinsics that are common to all Miri instances; individual machines can add their own
     /// intrinsic handling.
@@ -97,47 +144,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 self.write_type_id(tp_ty, dest)?;
             }
             sym::type_id_eq => {
-                // Both operands are `TypeId`, which is a newtype around an array of pointers.
-                // Project until we have the array elements.
-                let a_fields = self.project_field(&args[0], FieldIdx::ZERO)?;
-                let b_fields = self.project_field(&args[1], FieldIdx::ZERO)?;
-
-                let mut a_fields = self.project_array_fields(&a_fields)?;
-                let mut b_fields = self.project_array_fields(&b_fields)?;
-
-                let mut provenance_a = None;
-                let mut provenance_b = None;
-                let mut provenance_matches = true;
-
-                while let Some((i, a)) = a_fields.next(self)? {
-                    let (_, b) = b_fields.next(self)?.unwrap();
-
-                    let a = self.deref_pointer(&a)?;
-                    let (a, offset_a) = self.get_ptr_type_id(a.ptr())?;
-
-                    let b = self.deref_pointer(&b)?;
-                    let (b, offset_b) = self.get_ptr_type_id(b.ptr())?;
-
-                    if *provenance_a.get_or_insert(a) != a {
-                        throw_ub_format!(
-                            "type_id_eq: the first TypeId argument is invalid, the provenance of chunk {i} does not match the first chunk's"
-                        )
-                    }
-                    if *provenance_b.get_or_insert(b) != b {
-                        throw_ub_format!(
-                            "type_id_eq: the second TypeId argument is invalid, the provenance of chunk {i} does not match the first chunk's"
-                        )
-                    }
-                    provenance_matches &= a == b;
-
-                    if offset_a != offset_b && provenance_matches {
-                        throw_ub_format!(
-                            "type_id_eq: one of the TypeId arguments is invalid, chunk {i} of the hash does not match the type it represents"
-                        )
-                    }
-                }
-
-                self.write_scalar(Scalar::from_bool(provenance_matches), dest)?;
+                let a_ty = self.read_type_id(&args[0])?;
+                let b_ty = self.read_type_id(&args[1])?;
+                self.write_scalar(Scalar::from_bool(a_ty == b_ty), dest)?;
             }
             sym::variant_count => {
                 let tp_ty = instance.args.type_at(0);
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 6414821e21d..e77467ab412 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -951,12 +951,12 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     pub fn get_ptr_type_id(
         &self,
         ptr: Pointer<Option<M::Provenance>>,
-    ) -> InterpResult<'tcx, (Ty<'tcx>, Size)> {
+    ) -> InterpResult<'tcx, (Ty<'tcx>, u64)> {
         let (alloc_id, offset, _meta) = self.ptr_get_alloc_id(ptr, 0)?;
         let GlobalAlloc::TypeId { ty } = self.tcx.global_alloc(alloc_id) else {
-            throw_ub_format!("type_id_eq: `TypeId` provenance is not a type id")
+            throw_ub_format!("invalid `TypeId` value: not all bytes carry type id metadata")
         };
-        interp_ok((ty, offset))
+        interp_ok((ty, offset.bytes()))
     }
 
     pub fn get_ptr_fn(
diff --git a/tests/ui/consts/const_transmute_type_id4.rs b/tests/ui/consts/const_transmute_type_id4.rs
index 22a607e9e0e..0ea75f2a2f4 100644
--- a/tests/ui/consts/const_transmute_type_id4.rs
+++ b/tests/ui/consts/const_transmute_type_id4.rs
@@ -10,7 +10,7 @@ const _: () = {
         std::ptr::write(ptr.offset(0), main as fn() as *const ());
     }
     assert!(a == b);
-    //~^ ERROR: type_id_eq: `TypeId` provenance is not a type id
+    //~^ ERROR: invalid `TypeId` value
 };
 
 fn main() {}
diff --git a/tests/ui/consts/const_transmute_type_id4.stderr b/tests/ui/consts/const_transmute_type_id4.stderr
index b418a79d7f0..b224227cf35 100644
--- a/tests/ui/consts/const_transmute_type_id4.stderr
+++ b/tests/ui/consts/const_transmute_type_id4.stderr
@@ -1,4 +1,4 @@
-error[E0080]: type_id_eq: `TypeId` provenance is not a type id
+error[E0080]: invalid `TypeId` value: not all bytes carry type id metadata
   --> $DIR/const_transmute_type_id4.rs:12:13
    |
 LL |     assert!(a == b);
diff --git a/tests/ui/consts/const_transmute_type_id5.rs b/tests/ui/consts/const_transmute_type_id5.rs
index 0a9ba01e0dd..ae0429f8dbb 100644
--- a/tests/ui/consts/const_transmute_type_id5.rs
+++ b/tests/ui/consts/const_transmute_type_id5.rs
@@ -1,12 +1,11 @@
-//! Test that we require an equal TypeId to have the same integer
-//! part, even if the provenance matches.
+//! Test that we require an equal TypeId to have an integer part that properly
+//! reflects the type id hash.
 
 #![feature(const_type_id, const_trait_impl, const_cmp)]
 
 use std::any::TypeId;
 
 const _: () = {
-    let a = TypeId::of::<()>();
     let mut b = TypeId::of::<()>();
     unsafe {
         let ptr = &mut b as *mut TypeId as *mut *const ();
@@ -14,8 +13,8 @@ const _: () = {
         let val = std::ptr::read(ptr);
         std::ptr::write(ptr.offset(1), val);
     }
-    assert!(a == b);
-    //~^ ERROR: type_id_eq: one of the TypeId arguments is invalid, chunk 1 of the hash does not match the type it represents
+    assert!(b == b);
+    //~^ ERROR: invalid `TypeId` value
 };
 
 fn main() {}
diff --git a/tests/ui/consts/const_transmute_type_id5.stderr b/tests/ui/consts/const_transmute_type_id5.stderr
index 59823fcc1c9..6205679ebb6 100644
--- a/tests/ui/consts/const_transmute_type_id5.stderr
+++ b/tests/ui/consts/const_transmute_type_id5.stderr
@@ -1,7 +1,7 @@
-error[E0080]: type_id_eq: one of the TypeId arguments is invalid, chunk 1 of the hash does not match the type it represents
-  --> $DIR/const_transmute_type_id5.rs:17:13
+error[E0080]: invalid `TypeId` value: the hash does not match the type id metadata
+  --> $DIR/const_transmute_type_id5.rs:16:13
    |
-LL |     assert!(a == b);
+LL |     assert!(b == b);
    |             ^^^^^^ evaluation of `_` failed inside this call
    |
 note: inside `<TypeId as PartialEq>::eq`
-- 
cgit 1.4.1-3-g733a5


From 0e423f441ade436bd732ececd3dd6c79885dd07c Mon Sep 17 00:00:00 2001
From: Edoardo Marangoni <ecmm@anche.no>
Date: Wed, 16 Jul 2025 09:24:30 +0200
Subject: Boostrap: add warning on `optimize = false`

---
 src/bootstrap/src/core/config/toml/rust.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/bootstrap/src/core/config/toml/rust.rs b/src/bootstrap/src/core/config/toml/rust.rs
index 0fae235bb93..01fbd83317e 100644
--- a/src/bootstrap/src/core/config/toml/rust.rs
+++ b/src/bootstrap/src/core/config/toml/rust.rs
@@ -541,6 +541,14 @@ impl Config {
             lld_enabled = lld_enabled_toml;
             std_features = std_features_toml;
 
+            if optimize_toml.as_ref().is_some_and(|v| matches!(v, RustOptimize::Bool(false))) {
+                eprintln!(
+                    "WARNING: setting `optimize` to `false` is known to cause errors and \
+                    should be considered unsupported. Refer to `bootstrap.example.toml` \
+                    for more details."
+                );
+            }
+
             optimize = optimize_toml;
             self.rust_new_symbol_mangling = new_symbol_mangling;
             set(&mut self.rust_optimize_tests, optimize_tests);
-- 
cgit 1.4.1-3-g733a5


From 07a34c374b75730d7ba022135ac7929a2be6000e Mon Sep 17 00:00:00 2001
From: Stypox <stypox@pm.me>
Date: Tue, 15 Jul 2025 11:28:36 +0200
Subject: Make frame spans appear on a separate trace line

This was done by making the tracing_chrome tracing layer check if "tracing_separate_line" was in the arguments of a span, and act accordingly.
---
 compiler/rustc_const_eval/src/interpret/stack.rs |  7 ++-
 src/tools/miri/src/bin/log/tracing_chrome.rs     | 72 +++++++++++++++++-------
 2 files changed, 57 insertions(+), 22 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/stack.rs b/compiler/rustc_const_eval/src/interpret/stack.rs
index b6ba069526c..2e99bb4209f 100644
--- a/compiler/rustc_const_eval/src/interpret/stack.rs
+++ b/compiler/rustc_const_eval/src/interpret/stack.rs
@@ -12,6 +12,7 @@ use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, mir};
 use rustc_mir_dataflow::impls::always_storage_live_locals;
 use rustc_span::Span;
+use tracing::field::Empty;
 use tracing::{info_span, instrument, trace};
 
 use super::{
@@ -396,7 +397,11 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         // Finish things up.
         M::after_stack_push(self)?;
         self.frame_mut().loc = Left(mir::Location::START);
-        let span = info_span!("frame", "{}", instance);
+        // `tracing_separate_thread` is used to instruct the chrome_tracing [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
+        // [tracing::field::Empty] so that other tracing layers (e.g. the logger) will ignore it.
+        let span = info_span!("frame", tracing_separate_thread = Empty, "{}", instance);
         self.frame_mut().tracing_span.enter(span);
 
         interp_ok(())
diff --git a/src/tools/miri/src/bin/log/tracing_chrome.rs b/src/tools/miri/src/bin/log/tracing_chrome.rs
index 459acea6f0b..5a96633c99e 100644
--- a/src/tools/miri/src/bin/log/tracing_chrome.rs
+++ b/src/tools/miri/src/bin/log/tracing_chrome.rs
@@ -1,8 +1,18 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: Copyright (c) 2020 Thoren Paulson
-//! This file is taken unmodified from the following link, except for file attributes and
-//! `extern crate` at the top.
-//! https://github.com/thoren-d/tracing-chrome/blob/7e2625ab4aeeef2f0ef9bde9d6258dd181c04472/src/lib.rs
+//! This file was initially taken from the following link:
+//! <https://github.com/thoren-d/tracing-chrome/blob/7e2625ab4aeeef2f0ef9bde9d6258dd181c04472/src/lib.rs>
+//!
+//! The precise changes that were made to the original file can be found in git history
+//! (`git log -- path/to/tracing_chrome.rs`), but in summary:
+//! - the file attributes were changed and `extern crate` was added at the top
+//! - if a tracing span has a field called "tracing_separate_thread", it will be given a separate
+//! span ID even in [TraceStyle::Threaded] mode, to make it appear on a separate line when viewing
+//! the trace in <https://ui.perfetto.dev>. This is the syntax to trigger this behavior:
+//!   ```rust
+//!   tracing::info_span!("my_span", tracing_separate_thread = tracing::field::Empty, /* ... */)
+//!   ```
+//!
 //! Depending on the tracing-chrome crate from crates.io is unfortunately not possible, since it
 //! depends on `tracing_core` which conflicts with rustc_private's `tracing_core` (meaning it would
 //! not be possible to use the [ChromeLayer] in a context that expects a [Layer] from
@@ -79,14 +89,26 @@ where
 }
 
 /// Decides how traces will be recorded.
+/// Also see <https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview#heading=h.jh64i9l3vwa1>
 #[derive(Default)]
 pub enum TraceStyle {
-    /// Traces will be recorded as a group of threads.
+    /// Traces will be recorded as a group of threads, and all spans on the same thread will appear
+    /// on a single trace line in <https://ui.perfetto.dev>.
     /// In this style, spans should be entered and exited on the same thread.
+    ///
+    /// If a tracing span has a field called "tracing_separate_thread", it will be given a separate
+    /// span ID even in this mode, to make it appear on a separate line when viewing the trace in
+    /// <https://ui.perfetto.dev>. This is the syntax to trigger this behavior:
+    /// ```rust
+    /// tracing::info_span!("my_span", tracing_separate_thread = tracing::field::Empty, /* ... */)
+    /// ```
+    /// [tracing::field::Empty] is used so that other tracing layers (e.g. the logger) will ignore
+    /// the "tracing_separate_thread" argument and not print out anything for it.
     #[default]
     Threaded,
 
-    /// Traces will recorded as a group of asynchronous operations.
+    /// Traces will recorded as a group of asynchronous operations. All spans will be given separate
+    /// span IDs and will appear on separate trace lines in <https://ui.perfetto.dev>.
     Async,
 }
 
@@ -497,31 +519,39 @@ where
         }
     }
 
-    fn get_root_id(span: SpanRef<S>) -> u64 {
-        span.scope()
-            .from_root()
-            .take(1)
-            .next()
-            .unwrap_or(span)
-            .id()
-            .into_u64()
+    fn get_root_id(&self, span: SpanRef<S>) -> Option<u64> {
+        match self.trace_style {
+            TraceStyle::Threaded => {
+                if span.fields().field("tracing_separate_thread").is_some() {
+                    // assign an independent "id" to spans with argument "tracing_separate_thread",
+                    // so they appear a separate trace line in trace visualization tools, see
+                    // https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview#heading=h.jh64i9l3vwa1
+                    Some(span.id().into_u64())
+                } else {
+                    None
+                }
+            },
+            TraceStyle::Async => Some(
+                span.scope()
+                    .from_root()
+                    .take(1)
+                    .next()
+                    .unwrap_or(span)
+                    .id()
+                    .into_u64()
+            ),
+        }
     }
 
     fn enter_span(&self, span: SpanRef<S>, ts: f64) {
         let callsite = self.get_callsite(EventOrSpan::Span(&span));
-        let root_id = match self.trace_style {
-            TraceStyle::Async => Some(ChromeLayer::get_root_id(span)),
-            _ => None,
-        };
+        let root_id = self.get_root_id(span);
         self.send_message(Message::Enter(ts, callsite, root_id));
     }
 
     fn exit_span(&self, span: SpanRef<S>, ts: f64) {
         let callsite = self.get_callsite(EventOrSpan::Span(&span));
-        let root_id = match self.trace_style {
-            TraceStyle::Async => Some(ChromeLayer::get_root_id(span)),
-            _ => None,
-        };
+        let root_id = self.get_root_id(span);
         self.send_message(Message::Exit(ts, callsite, root_id));
     }
 
-- 
cgit 1.4.1-3-g733a5


From 06f0dca10600390f1e4d19fdefa3453d14238048 Mon Sep 17 00:00:00 2001
From: Nia Espera <a5b6@riseup.net>
Date: Mon, 7 Jul 2025 18:37:47 +0200
Subject: hook up native-lib bits

---
 src/tools/miri/src/lib.rs                          |   1 +
 src/tools/miri/src/shims/native_lib/mod.rs         | 123 ++++++++++++++++++---
 .../miri/src/shims/native_lib/trace/parent.rs      |  23 ++--
 .../tests/native-lib/fail/tracing/partial_init.rs  |  25 +++++
 .../native-lib/fail/tracing/partial_init.stderr    |  39 +++++++
 .../fail/tracing/unexposed_reachable_alloc.rs      |  29 +++++
 .../fail/tracing/unexposed_reachable_alloc.stderr  |  39 +++++++
 .../native-lib/pass/ptr_read_access.notrace.stderr |  18 +++
 .../native-lib/pass/ptr_read_access.notrace.stdout |   1 +
 .../miri/tests/native-lib/pass/ptr_read_access.rs  |   4 +
 .../tests/native-lib/pass/ptr_read_access.stderr   |  18 ---
 .../tests/native-lib/pass/ptr_read_access.stdout   |   1 -
 .../native-lib/pass/ptr_read_access.trace.stderr   |  19 ++++
 .../native-lib/pass/ptr_read_access.trace.stdout   |   1 +
 .../pass/ptr_write_access.notrace.stderr           |  18 +++
 .../miri/tests/native-lib/pass/ptr_write_access.rs |   3 +
 .../tests/native-lib/pass/ptr_write_access.stderr  |  18 ---
 .../native-lib/pass/ptr_write_access.trace.stderr  |  19 ++++
 src/tools/miri/tests/native-lib/ptr_read_access.c  |   6 +
 src/tools/miri/tests/native-lib/ptr_write_access.c |   8 ++
 20 files changed, 351 insertions(+), 62 deletions(-)
 create mode 100644 src/tools/miri/tests/native-lib/fail/tracing/partial_init.rs
 create mode 100644 src/tools/miri/tests/native-lib/fail/tracing/partial_init.stderr
 create mode 100644 src/tools/miri/tests/native-lib/fail/tracing/unexposed_reachable_alloc.rs
 create mode 100644 src/tools/miri/tests/native-lib/fail/tracing/unexposed_reachable_alloc.stderr
 create mode 100644 src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stderr
 create mode 100644 src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stdout
 delete mode 100644 src/tools/miri/tests/native-lib/pass/ptr_read_access.stderr
 delete mode 100644 src/tools/miri/tests/native-lib/pass/ptr_read_access.stdout
 create mode 100644 src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stderr
 create mode 100644 src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stdout
 create mode 100644 src/tools/miri/tests/native-lib/pass/ptr_write_access.notrace.stderr
 delete mode 100644 src/tools/miri/tests/native-lib/pass/ptr_write_access.stderr
 create mode 100644 src/tools/miri/tests/native-lib/pass/ptr_write_access.trace.stderr

diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 374f63a1660..2010b4dae18 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -15,6 +15,7 @@
 #![feature(unqualified_local_imports)]
 #![feature(derive_coerce_pointee)]
 #![feature(arbitrary_self_types)]
+#![feature(iter_advance_by)]
 // Configure clippy and other lints
 #![allow(
     clippy::collapsible_else_if,
diff --git a/src/tools/miri/src/shims/native_lib/mod.rs b/src/tools/miri/src/shims/native_lib/mod.rs
index a2a23c4813f..fb7b1df41a4 100644
--- a/src/tools/miri/src/shims/native_lib/mod.rs
+++ b/src/tools/miri/src/shims/native_lib/mod.rs
@@ -34,18 +34,25 @@ pub struct MemEvents {
 /// A single memory access.
 #[allow(dead_code)]
 #[cfg_attr(target_os = "linux", derive(serde::Serialize, serde::Deserialize))]
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub enum AccessEvent {
-    /// A read may have occurred on this memory range.
-    /// Some instructions *may* read memory without *always* doing that,
-    /// so this can be an over-approximation.
-    /// The range info, however, is reliable if the access did happen.
+    /// A read occurred on this memory range.
     Read(AccessRange),
-    /// A read may have occurred on this memory range.
+    /// A write may have occurred on this memory range.
     /// Some instructions *may* write memory without *always* doing that,
     /// so this can be an over-approximation.
     /// The range info, however, is reliable if the access did happen.
-    Write(AccessRange),
+    /// If the second field is true, the access definitely happened.
+    Write(AccessRange, bool),
+}
+
+impl AccessEvent {
+    fn get_range(&self) -> AccessRange {
+        match self {
+            AccessEvent::Read(access_range) => access_range.clone(),
+            AccessEvent::Write(access_range, _) => access_range.clone(),
+        }
+    }
 }
 
 /// The memory touched by a given access.
@@ -59,6 +66,12 @@ pub struct AccessRange {
     pub size: usize,
 }
 
+impl AccessRange {
+    fn end(&self) -> usize {
+        self.addr.strict_add(self.size)
+    }
+}
+
 impl<'tcx> EvalContextExtPriv<'tcx> for crate::MiriInterpCx<'tcx> {}
 trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// Call native host function and return the output as an immediate.
@@ -196,6 +209,73 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
         None
     }
+
+    /// Applies the `events` to Miri's internal state. The event vector must be
+    /// ordered sequentially by when the accesses happened, and the sizes are
+    /// assumed to be exact.
+    fn tracing_apply_accesses(&mut self, events: MemEvents) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+
+        for evt in events.acc_events {
+            let evt_rg = evt.get_range();
+            // LLVM at least permits vectorising accesses to adjacent allocations,
+            // so we cannot assume 1 access = 1 allocation. :(
+            let mut rg = evt_rg.addr..evt_rg.end();
+            while let Some(curr) = rg.next() {
+                let Some(alloc_id) = this.alloc_id_from_addr(
+                    curr.to_u64(),
+                    rg.len().try_into().unwrap(),
+                    /* only_exposed_allocations */ true,
+                ) else {
+                    throw_ub_format!("Foreign code did an out-of-bounds access!")
+                };
+                let alloc = this.get_alloc_raw(alloc_id)?;
+                // The logical and physical address of the allocation coincide, so we can use
+                // this instead of `addr_from_alloc_id`.
+                let alloc_addr = alloc.get_bytes_unchecked_raw().addr();
+
+                // Determine the range inside the allocation that this access covers. This range is
+                // in terms of offsets from the start of `alloc`. The start of the overlap range
+                // will be `curr`; the end will be the minimum of the end of the allocation and the
+                // end of the access' range.
+                let overlap = curr.strict_sub(alloc_addr)
+                    ..std::cmp::min(alloc.len(), rg.end.strict_sub(alloc_addr));
+                // Skip forward however many bytes of the access are contained in the current
+                // allocation, subtracting 1 since the overlap range includes the current addr
+                // that was already popped off of the range.
+                rg.advance_by(overlap.len().strict_sub(1)).unwrap();
+
+                match evt {
+                    AccessEvent::Read(_) => {
+                        // FIXME: ProvenanceMap should have something like get_range().
+                        let p_map = alloc.provenance();
+                        for idx in overlap {
+                            // If a provenance was read by the foreign code, expose it.
+                            if let Some(prov) = p_map.get(Size::from_bytes(idx), this) {
+                                this.expose_provenance(prov)?;
+                            }
+                        }
+                    }
+                    AccessEvent::Write(_, certain) => {
+                        // Sometimes we aren't certain if a write happened, in which case we
+                        // only initialise that data if the allocation is mutable.
+                        if certain || alloc.mutability.is_mut() {
+                            let (alloc, cx) = this.get_alloc_raw_mut(alloc_id)?;
+                            alloc.process_native_write(
+                                &cx.tcx,
+                                Some(AllocRange {
+                                    start: Size::from_bytes(overlap.start),
+                                    size: Size::from_bytes(overlap.len()),
+                                }),
+                            )
+                        }
+                    }
+                }
+            }
+        }
+
+        interp_ok(())
+    }
 }
 
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
@@ -221,6 +301,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
         };
 
+        // Do we have ptrace?
+        let tracing = trace::Supervisor::is_enabled();
+
         // Get the function arguments, and convert them to `libffi`-compatible form.
         let mut libffi_args = Vec::<CArg>::with_capacity(args.len());
         for arg in args.iter() {
@@ -240,9 +323,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // The first time this happens, print a warning.
                 if !this.machine.native_call_mem_warned.replace(true) {
                     // Newly set, so first time we get here.
-                    this.emit_diagnostic(NonHaltingDiagnostic::NativeCallSharedMem {
-                        tracing: self::trace::Supervisor::is_enabled(),
-                    });
+                    this.emit_diagnostic(NonHaltingDiagnostic::NativeCallSharedMem { tracing });
                 }
 
                 this.expose_provenance(prov)?;
@@ -269,15 +350,23 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             // be read by FFI. The `black_box` is defensive programming as LLVM likes
             // to (incorrectly) optimize away ptr2int casts whose result is unused.
             std::hint::black_box(alloc.get_bytes_unchecked_raw().expose_provenance());
-            // Expose all provenances in this allocation, since the native code can do $whatever.
-            for prov in alloc.provenance().provenances() {
-                this.expose_provenance(prov)?;
+
+            if !tracing {
+                // Expose all provenances in this allocation, since the native code can do $whatever.
+                // Can be skipped when tracing; in that case we'll expose just the actually-read parts later.
+                for prov in alloc.provenance().provenances() {
+                    this.expose_provenance(prov)?;
+                }
             }
 
             // Prepare for possible write from native code if mutable.
             if info.mutbl.is_mut() {
                 let (alloc, cx) = this.get_alloc_raw_mut(alloc_id)?;
-                alloc.process_native_write(&cx.tcx, None);
+                // These writes could initialize everything and wreck havoc with the pointers.
+                // We can skip that when tracing; in that case we'll later do that only for the memory that got actually written.
+                if !tracing {
+                    alloc.process_native_write(&cx.tcx, None);
+                }
                 // Also expose *mutable* provenance for the interpreter-level allocation.
                 std::hint::black_box(alloc.get_bytes_unchecked_raw_mut().expose_provenance());
             }
@@ -289,10 +378,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let (ret, maybe_memevents) =
             this.call_native_with_args(link_name, dest, code_ptr, libffi_args)?;
 
-        if cfg!(target_os = "linux")
-            && let Some(events) = maybe_memevents
-        {
-            trace!("Registered FFI events:\n{events:#0x?}");
+        if tracing {
+            this.tracing_apply_accesses(maybe_memevents.unwrap())?;
         }
 
         this.write_immediate(*ret, dest)?;
diff --git a/src/tools/miri/src/shims/native_lib/trace/parent.rs b/src/tools/miri/src/shims/native_lib/trace/parent.rs
index fc4047eec51..83f6c7a13fc 100644
--- a/src/tools/miri/src/shims/native_lib/trace/parent.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/parent.rs
@@ -58,11 +58,11 @@ impl ArchIndependentRegs for libc::user_regs_struct {
 #[rustfmt::skip]
 impl ArchIndependentRegs for libc::user_regs_struct {
     #[inline]
-    fn ip(&self) -> usize { self.eip.try_into().unwrap() }
+    fn ip(&self) -> usize { self.eip.cast_unsigned().try_into().unwrap() }
     #[inline]
-    fn set_ip(&mut self, ip: usize) { self.eip = ip.try_into().unwrap() }
+    fn set_ip(&mut self, ip: usize) { self.eip = ip.cast_signed().try_into().unwrap() }
     #[inline]
-    fn set_sp(&mut self, sp: usize) { self.esp = sp.try_into().unwrap() }
+    fn set_sp(&mut self, sp: usize) { self.esp = sp.cast_signed().try_into().unwrap() }
 }
 
 /// A unified event representing something happening on the child process. Wraps
@@ -386,7 +386,17 @@ fn capstone_find_events(
                         acc_events.push(AccessEvent::Read(push.clone()));
                     }
                     if acc_ty.is_writable() {
-                        acc_events.push(AccessEvent::Write(push));
+                        // FIXME: This could be made certain; either determine all cases where
+                        // only reads happen, or have an intermediate mempr_* function to first
+                        // map the page(s) as readonly and check if a segfault occurred.
+
+                        // Per https://docs.rs/iced-x86/latest/iced_x86/enum.OpAccess.html,
+                        // we know that the possible access types are Read, CondRead, Write,
+                        // CondWrite, ReadWrite, and ReadCondWrite. Since we got a segfault
+                        // we know some kind of access happened so Cond{Read, Write}s are
+                        // certain reads and writes; the only uncertainty is with an RW op
+                        // as it might be a ReadCondWrite with the write condition unmet.
+                        acc_events.push(AccessEvent::Write(push, !acc_ty.is_readable()));
                     }
 
                     return true;
@@ -442,8 +452,7 @@ fn handle_segfault(
     // Get information on what caused the segfault. This contains the address
     // that triggered it.
     let siginfo = ptrace::getsiginfo(pid).unwrap();
-    // All x86, ARM, etc. instructions only have at most one memory operand
-    // (thankfully!)
+    // All x86 instructions only have at most one memory operand (thankfully!)
     // SAFETY: si_addr is safe to call.
     let addr = unsafe { siginfo.si_addr().addr() };
     let page_addr = addr.strict_sub(addr.strict_rem(page_size));
@@ -490,7 +499,7 @@ fn handle_segfault(
     ptrace::write(
         pid,
         (&raw const PAGE_ADDR).cast_mut().cast(),
-        libc::c_long::try_from(page_addr).unwrap(),
+        libc::c_long::try_from(page_addr.cast_signed()).unwrap(),
     )
     .unwrap();
 
diff --git a/src/tools/miri/tests/native-lib/fail/tracing/partial_init.rs b/src/tools/miri/tests/native-lib/fail/tracing/partial_init.rs
new file mode 100644
index 00000000000..e267f82e215
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/tracing/partial_init.rs
@@ -0,0 +1,25 @@
+//@only-target: x86_64-unknown-linux-gnu i686-unknown-linux-gnu
+//@compile-flags: -Zmiri-native-lib-enable-tracing
+
+extern "C" {
+    fn init_n(n: i32, ptr: *mut u8);
+}
+
+fn main() {
+    partial_init();
+}
+
+// Initialise the first 2 elements of the slice from native code, and check
+// that the 3rd is correctly deemed uninit.
+fn partial_init() {
+    let mut slice = std::mem::MaybeUninit::<[u8; 3]>::uninit();
+    let slice_ptr = slice.as_mut_ptr().cast::<u8>();
+    unsafe {
+        // Initialize the first two elements.
+        init_n(2, slice_ptr);
+        assert!(*slice_ptr == 0);
+        assert!(*slice_ptr.offset(1) == 0);
+        // Reading the third is UB!
+        let _val = *slice_ptr.offset(2); //~ ERROR: Undefined Behavior: using uninitialized data
+    }
+}
diff --git a/src/tools/miri/tests/native-lib/fail/tracing/partial_init.stderr b/src/tools/miri/tests/native-lib/fail/tracing/partial_init.stderr
new file mode 100644
index 00000000000..84fd913b5e5
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/tracing/partial_init.stderr
@@ -0,0 +1,39 @@
+warning: sharing memory with a native function called via FFI
+  --> tests/native-lib/fail/tracing/partial_init.rs:LL:CC
+   |
+LL |         init_n(2, slice_ptr);
+   |         ^^^^^^^^^^^^^^^^^^^^ 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: BACKTRACE:
+   = note: inside `partial_init` at tests/native-lib/fail/tracing/partial_init.rs:LL:CC
+note: inside `main`
+  --> tests/native-lib/fail/tracing/partial_init.rs:LL:CC
+   |
+LL |     partial_init();
+   |     ^^^^^^^^^^^^^^
+
+error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+  --> tests/native-lib/fail/tracing/partial_init.rs:LL:CC
+   |
+LL |         let _val = *slice_ptr.offset(2);
+   |                    ^^^^^^^^^^^^^^^^^^^^ 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: BACKTRACE:
+   = note: inside `partial_init` at tests/native-lib/fail/tracing/partial_init.rs:LL:CC
+note: inside `main`
+  --> tests/native-lib/fail/tracing/partial_init.rs:LL:CC
+   |
+LL |     partial_init();
+   |     ^^^^^^^^^^^^^^
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error; 1 warning emitted
+
diff --git a/src/tools/miri/tests/native-lib/fail/tracing/unexposed_reachable_alloc.rs b/src/tools/miri/tests/native-lib/fail/tracing/unexposed_reachable_alloc.rs
new file mode 100644
index 00000000000..b78c29d98db
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/tracing/unexposed_reachable_alloc.rs
@@ -0,0 +1,29 @@
+//@only-target: x86_64-unknown-linux-gnu i686-unknown-linux-gnu
+//@compile-flags: -Zmiri-permissive-provenance -Zmiri-native-lib-enable-tracing
+
+extern "C" {
+    fn do_one_deref(ptr: *const *const *const i32) -> usize;
+}
+
+fn main() {
+    unexposed_reachable_alloc();
+}
+
+// Expose 2 pointers by virtue of doing a native read and assert that the 3rd in
+// the chain remains properly unexposed.
+fn unexposed_reachable_alloc() {
+    let inner = 42;
+    let intermediate_a = &raw const inner;
+    let intermediate_b = &raw const intermediate_a;
+    let exposed = &raw const intermediate_b;
+    // Discard the return value; it's just there so the access in C doesn't get optimised away.
+    unsafe { do_one_deref(exposed) };
+    // Native read should have exposed the address of intermediate_b...
+    let valid: *const i32 = std::ptr::with_exposed_provenance(intermediate_b.addr());
+    // but not of intermediate_a.
+    let invalid: *const i32 = std::ptr::with_exposed_provenance(intermediate_a.addr());
+    unsafe {
+        let _ok = *valid;
+        let _not_ok = *invalid; //~ ERROR: Undefined Behavior: memory access failed: attempting to access
+    }
+}
diff --git a/src/tools/miri/tests/native-lib/fail/tracing/unexposed_reachable_alloc.stderr b/src/tools/miri/tests/native-lib/fail/tracing/unexposed_reachable_alloc.stderr
new file mode 100644
index 00000000000..2d34dac1b3f
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/fail/tracing/unexposed_reachable_alloc.stderr
@@ -0,0 +1,39 @@
+warning: sharing memory with a native function called via FFI
+  --> tests/native-lib/fail/tracing/unexposed_reachable_alloc.rs:LL:CC
+   |
+LL |     unsafe { do_one_deref(exposed) };
+   |              ^^^^^^^^^^^^^^^^^^^^^ 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: BACKTRACE:
+   = note: inside `unexposed_reachable_alloc` at tests/native-lib/fail/tracing/unexposed_reachable_alloc.rs:LL:CC
+note: inside `main`
+  --> tests/native-lib/fail/tracing/unexposed_reachable_alloc.rs:LL:CC
+   |
+LL |     unexposed_reachable_alloc();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: Undefined Behavior: memory access failed: attempting to access 4 bytes, but got $HEX[noalloc] which is a dangling pointer (it has no provenance)
+  --> tests/native-lib/fail/tracing/unexposed_reachable_alloc.rs:LL:CC
+   |
+LL |         let _not_ok = *invalid;
+   |                       ^^^^^^^^ 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: BACKTRACE:
+   = note: inside `unexposed_reachable_alloc` at tests/native-lib/fail/tracing/unexposed_reachable_alloc.rs:LL:CC
+note: inside `main`
+  --> tests/native-lib/fail/tracing/unexposed_reachable_alloc.rs:LL:CC
+   |
+LL |     unexposed_reachable_alloc();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error; 1 warning emitted
+
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stderr b/src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stderr
new file mode 100644
index 00000000000..04a3025baef
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stderr
@@ -0,0 +1,18 @@
+warning: sharing memory with a native function called via FFI
+  --> tests/native-lib/pass/ptr_read_access.rs:LL:CC
+   |
+LL |     unsafe { print_pointer(&x) };
+   |              ^^^^^^^^^^^^^^^^^ 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: BACKTRACE:
+   = note: inside `test_access_pointer` at tests/native-lib/pass/ptr_read_access.rs:LL:CC
+note: inside `main`
+  --> tests/native-lib/pass/ptr_read_access.rs:LL:CC
+   |
+LL |     test_access_pointer();
+   |     ^^^^^^^^^^^^^^^^^^^^^
+
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stdout b/src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stdout
new file mode 100644
index 00000000000..1a8799abfc9
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/pass/ptr_read_access.notrace.stdout
@@ -0,0 +1 @@
+printing pointer dereference from C: 42
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs b/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs
index 4c852135367..4f3c37f00c1 100644
--- a/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs
+++ b/src/tools/miri/tests/native-lib/pass/ptr_read_access.rs
@@ -1,3 +1,7 @@
+//@revisions: trace notrace
+//@[trace] only-target: x86_64-unknown-linux-gnu i686-unknown-linux-gnu
+//@[trace] compile-flags: -Zmiri-native-lib-enable-tracing
+
 fn main() {
     test_access_pointer();
     test_access_simple();
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_read_access.stderr b/src/tools/miri/tests/native-lib/pass/ptr_read_access.stderr
deleted file mode 100644
index 04a3025baef..00000000000
--- a/src/tools/miri/tests/native-lib/pass/ptr_read_access.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-warning: sharing memory with a native function called via FFI
-  --> tests/native-lib/pass/ptr_read_access.rs:LL:CC
-   |
-LL |     unsafe { print_pointer(&x) };
-   |              ^^^^^^^^^^^^^^^^^ 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: BACKTRACE:
-   = note: inside `test_access_pointer` at tests/native-lib/pass/ptr_read_access.rs:LL:CC
-note: inside `main`
-  --> tests/native-lib/pass/ptr_read_access.rs:LL:CC
-   |
-LL |     test_access_pointer();
-   |     ^^^^^^^^^^^^^^^^^^^^^
-
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_read_access.stdout b/src/tools/miri/tests/native-lib/pass/ptr_read_access.stdout
deleted file mode 100644
index 1a8799abfc9..00000000000
--- a/src/tools/miri/tests/native-lib/pass/ptr_read_access.stdout
+++ /dev/null
@@ -1 +0,0 @@
-printing pointer dereference from C: 42
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stderr b/src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stderr
new file mode 100644
index 00000000000..c2a4508b7fc
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stderr
@@ -0,0 +1,19 @@
+warning: sharing memory with a native function called via FFI
+  --> tests/native-lib/pass/ptr_read_access.rs:LL:CC
+   |
+LL |     unsafe { print_pointer(&x) };
+   |              ^^^^^^^^^^^^^^^^^ 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: BACKTRACE:
+   = note: inside `test_access_pointer` at tests/native-lib/pass/ptr_read_access.rs:LL:CC
+note: inside `main`
+  --> tests/native-lib/pass/ptr_read_access.rs:LL:CC
+   |
+LL |     test_access_pointer();
+   |     ^^^^^^^^^^^^^^^^^^^^^
+
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stdout b/src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stdout
new file mode 100644
index 00000000000..1a8799abfc9
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/pass/ptr_read_access.trace.stdout
@@ -0,0 +1 @@
+printing pointer dereference from C: 42
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_write_access.notrace.stderr b/src/tools/miri/tests/native-lib/pass/ptr_write_access.notrace.stderr
new file mode 100644
index 00000000000..c893b0d9f65
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/pass/ptr_write_access.notrace.stderr
@@ -0,0 +1,18 @@
+warning: sharing memory with a native function called via FFI
+  --> tests/native-lib/pass/ptr_write_access.rs:LL:CC
+   |
+LL |     unsafe { increment_int(&mut x) };
+   |              ^^^^^^^^^^^^^^^^^^^^^ 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: BACKTRACE:
+   = note: inside `test_increment_int` at tests/native-lib/pass/ptr_write_access.rs:LL:CC
+note: inside `main`
+  --> tests/native-lib/pass/ptr_write_access.rs:LL:CC
+   |
+LL |     test_increment_int();
+   |     ^^^^^^^^^^^^^^^^^^^^
+
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 86a9c97f4ce..57def78b0ab 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
@@ -1,3 +1,6 @@
+//@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
 
 #![feature(box_as_ptr)]
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_write_access.stderr b/src/tools/miri/tests/native-lib/pass/ptr_write_access.stderr
deleted file mode 100644
index c893b0d9f65..00000000000
--- a/src/tools/miri/tests/native-lib/pass/ptr_write_access.stderr
+++ /dev/null
@@ -1,18 +0,0 @@
-warning: sharing memory with a native function called via FFI
-  --> tests/native-lib/pass/ptr_write_access.rs:LL:CC
-   |
-LL |     unsafe { increment_int(&mut x) };
-   |              ^^^^^^^^^^^^^^^^^^^^^ 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: BACKTRACE:
-   = note: inside `test_increment_int` at tests/native-lib/pass/ptr_write_access.rs:LL:CC
-note: inside `main`
-  --> tests/native-lib/pass/ptr_write_access.rs:LL:CC
-   |
-LL |     test_increment_int();
-   |     ^^^^^^^^^^^^^^^^^^^^
-
diff --git a/src/tools/miri/tests/native-lib/pass/ptr_write_access.trace.stderr b/src/tools/miri/tests/native-lib/pass/ptr_write_access.trace.stderr
new file mode 100644
index 00000000000..dbf021b15be
--- /dev/null
+++ b/src/tools/miri/tests/native-lib/pass/ptr_write_access.trace.stderr
@@ -0,0 +1,19 @@
+warning: sharing memory with a native function called via FFI
+  --> tests/native-lib/pass/ptr_write_access.rs:LL:CC
+   |
+LL |     unsafe { increment_int(&mut x) };
+   |              ^^^^^^^^^^^^^^^^^^^^^ 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: BACKTRACE:
+   = note: inside `test_increment_int` at tests/native-lib/pass/ptr_write_access.rs:LL:CC
+note: inside `main`
+  --> tests/native-lib/pass/ptr_write_access.rs:LL:CC
+   |
+LL |     test_increment_int();
+   |     ^^^^^^^^^^^^^^^^^^^^
+
diff --git a/src/tools/miri/tests/native-lib/ptr_read_access.c b/src/tools/miri/tests/native-lib/ptr_read_access.c
index b89126d3d7c..021eb6adca4 100644
--- a/src/tools/miri/tests/native-lib/ptr_read_access.c
+++ b/src/tools/miri/tests/native-lib/ptr_read_access.c
@@ -49,3 +49,9 @@ typedef struct Static {
 EXPORT int32_t access_static(const Static *s_ptr) {
   return s_ptr->recurse->recurse->value;
 }
+
+/* Test: unexposed_reachable_alloc */
+
+EXPORT uintptr_t do_one_deref(const int32_t ***ptr) {
+  return (uintptr_t)*ptr;
+}
diff --git a/src/tools/miri/tests/native-lib/ptr_write_access.c b/src/tools/miri/tests/native-lib/ptr_write_access.c
index fd8b005499c..5260d0b3651 100644
--- a/src/tools/miri/tests/native-lib/ptr_write_access.c
+++ b/src/tools/miri/tests/native-lib/ptr_write_access.c
@@ -107,3 +107,11 @@ EXPORT void set_shared_mem(int32_t** ptr) {
 EXPORT void init_ptr_stored_in_shared_mem(int32_t val) {
   **shared_place = val;
 }
+
+/* Test: partial_init */
+
+EXPORT void init_n(int32_t n, char* ptr) {
+  for (int i=0; i<n; i++) {
+    *(ptr+i) = 0;
+  }
+}
-- 
cgit 1.4.1-3-g733a5


From 7daf0e68e091e47aa55f3e9321902c8e97f935af Mon Sep 17 00:00:00 2001
From: Ibraheem Ahmed <ibraheem@ibraheem.ca>
Date: Wed, 16 Jul 2025 03:53:20 -0400
Subject: update comment to reference legacy `.ctors` section

Co-authored-by: Ralf Jung <post@ralfj.de>
---
 src/tools/miri/src/shims/ctor.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/src/shims/ctor.rs b/src/tools/miri/src/shims/ctor.rs
index 75f564989bc..367c2b1608b 100644
--- a/src/tools/miri/src/shims/ctor.rs
+++ b/src/tools/miri/src/shims/ctor.rs
@@ -52,7 +52,7 @@ impl<'tcx> GlobalCtorState<'tcx> {
 
                         // Read the standard `.init_array` section on platforms that use ELF, or WASM,
                         // which supports the same linker directive.
-                        // FIXME: Add support for `.init_array.N`.
+                        // FIXME: Add support for `.init_array.N` and `.ctors`?
                         BinaryFormat::Elf | BinaryFormat::Wasm =>
                             this.lookup_link_section(|section| section == ".init_array")?,
 
-- 
cgit 1.4.1-3-g733a5


From e0bb7299d02b44ba53113cc35b904aa788645a58 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 4 Jun 2025 10:08:41 +0800
Subject: Add AsRef and Borrow for generate_mut_trait_impl

- AsRef -> AsMut
- Borrow -> BorrowMut

Example
====================

```rust
//- minicore: as_ref
struct Foo(i32);

impl<T> core::convert::AsRef$0<i32> for Foo {
    fn as_ref(&self) -> &i32 {
        &self.0
    }
}
```
->
```rust
struct Foo(i32);

$0impl<T> core::convert::AsMut<i32> for Foo {
    fn as_mut(&mut self) -> &mut i32 {
        &self.0
    }
}

impl<T> core::convert::AsRef<i32> for Foo {
    fn as_ref(&self) -> &i32 {
        &self.0
    }
}
```
---
 .../src/handlers/generate_mut_trait_impl.rs        | 114 +++++++++++++++++----
 1 file changed, 96 insertions(+), 18 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
index bab2ccf3f33..789fb8288c2 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
@@ -48,36 +48,42 @@ pub(crate) fn generate_mut_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>
     let impl_def = ctx.find_node_at_offset::<ast::Impl>()?.clone_for_update();
     let indent = impl_def.indent_level();
 
+    let (apply_trait, new_apply_trait) = impl_def
+        .syntax()
+        .descendants()
+        .filter_map(ast::NameRef::cast)
+        .find_map(process_trait_name)?;
+
     let trait_ = impl_def.trait_()?;
     if let ast::Type::PathType(trait_path) = trait_ {
         let trait_type = ctx.sema.resolve_trait(&trait_path.path()?)?;
         let scope = ctx.sema.scope(trait_path.syntax())?;
-        if trait_type != FamousDefs(&ctx.sema, scope.krate()).core_convert_Index()? {
+        let famous_defs = FamousDefs(&ctx.sema, scope.krate());
+        if trait_type != get_famous(&apply_trait.text(), famous_defs)? {
             return None;
         }
     }
 
     // Index -> IndexMut
-    let index_trait = impl_def
-        .syntax()
-        .descendants()
-        .filter_map(ast::NameRef::cast)
-        .find(|it| it.text() == "Index")?;
     ted::replace(
-        index_trait.syntax(),
-        make::path_segment(make::name_ref("IndexMut")).clone_for_update().syntax(),
+        apply_trait.syntax(),
+        make::path_segment(make::name_ref(new_apply_trait)).clone_for_update().syntax(),
     );
 
     // index -> index_mut
-    let trait_method_name = impl_def
+    let (trait_method_name, new_trait_method_name) = impl_def
         .syntax()
         .descendants()
         .filter_map(ast::Name::cast)
-        .find(|it| it.text() == "index")?;
-    ted::replace(trait_method_name.syntax(), make::name("index_mut").clone_for_update().syntax());
+        .find_map(process_method_name)?;
+    ted::replace(
+        trait_method_name.syntax(),
+        make::name(new_trait_method_name).clone_for_update().syntax(),
+    );
 
-    let type_alias = impl_def.syntax().descendants().find_map(ast::TypeAlias::cast)?;
-    ted::remove(type_alias.syntax());
+    if let Some(type_alias) = impl_def.syntax().descendants().find_map(ast::TypeAlias::cast) {
+        ted::remove(type_alias.syntax());
+    }
 
     // &self -> &mut self
     let mut_self_param = make::mut_self_param();
@@ -87,10 +93,8 @@ pub(crate) fn generate_mut_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>
 
     // &Self::Output -> &mut Self::Output
     let ret_type = impl_def.syntax().descendants().find_map(ast::RetType::cast)?;
-    ted::replace(
-        ret_type.syntax(),
-        make::ret_type(make::ty("&mut Self::Output")).clone_for_update().syntax(),
-    );
+    let new_ret_type = process_ret_type(&ret_type)?;
+    ted::replace(ret_type.syntax(), make::ret_type(new_ret_type).clone_for_update().syntax());
 
     let fn_ = impl_def.assoc_item_list()?.assoc_items().find_map(|it| match it {
         ast::AssocItem::Fn(f) => Some(f),
@@ -104,7 +108,7 @@ pub(crate) fn generate_mut_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>
     let target = impl_def.syntax().text_range();
     acc.add(
         AssistId::generate("generate_mut_trait_impl"),
-        "Generate `IndexMut` impl from this `Index` trait",
+        format!("Generate `{new_apply_trait}` impl from this `{apply_trait}` trait"),
         target,
         |edit| {
             edit.insert(target.start(), format!("$0{impl_def}\n\n{indent}"));
@@ -112,6 +116,43 @@ pub(crate) fn generate_mut_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>
     )
 }
 
+fn get_famous(apply_trait: &str, famous: FamousDefs<'_, '_>) -> Option<hir::Trait> {
+    match apply_trait {
+        "Index" => famous.core_convert_Index(),
+        "AsRef" => famous.core_convert_AsRef(),
+        "Borrow" => famous.core_borrow_Borrow(),
+        _ => None,
+    }
+}
+
+fn process_trait_name(name: ast::NameRef) -> Option<(ast::NameRef, &'static str)> {
+    let new_name = match &*name.text() {
+        "Index" => "IndexMut",
+        "AsRef" => "AsMut",
+        "Borrow" => "BorrowMut",
+        _ => return None,
+    };
+    Some((name, new_name))
+}
+
+fn process_method_name(name: ast::Name) -> Option<(ast::Name, &'static str)> {
+    let new_name = match &*name.text() {
+        "index" => "index_mut",
+        "as_ref" => "as_mut",
+        "borrow" => "borrow_mut",
+        _ => return None,
+    };
+    Some((name, new_name))
+}
+
+fn process_ret_type(ref_ty: &ast::RetType) -> Option<ast::Type> {
+    let ty = ref_ty.ty()?;
+    let ast::Type::RefType(ref_type) = ty else {
+        return None;
+    };
+    Some(make::ty_ref(ref_type.ty()?, true))
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
@@ -186,6 +227,35 @@ impl<T> core::ops::Index<Axis> for [T; 3] where T: Copy {
         var_name
     }
 }
+"#,
+        );
+
+        check_assist(
+            generate_mut_trait_impl,
+            r#"
+//- minicore: as_ref
+struct Foo(i32);
+
+impl<T> core::convert::AsRef$0<i32> for Foo {
+    fn as_ref(&self) -> &i32 {
+        &self.0
+    }
+}
+"#,
+            r#"
+struct Foo(i32);
+
+$0impl<T> core::convert::AsMut<i32> for Foo {
+    fn as_mut(&mut self) -> &mut i32 {
+        &self.0
+    }
+}
+
+impl<T> core::convert::AsRef<i32> for Foo {
+    fn as_ref(&self) -> &i32 {
+        &self.0
+    }
+}
 "#,
         );
     }
@@ -285,6 +355,14 @@ mod foo {
 pub trait Index<Idx: ?Sized> {}
 
 impl<T> Index$0<i32> for [T; 3] {}
+"#,
+        );
+        check_assist_not_applicable(
+            generate_mut_trait_impl,
+            r#"
+pub trait AsRef<T: ?Sized> {}
+
+impl<T> AsRef$0<i32> for [T; 3] {}
 "#,
         );
     }
-- 
cgit 1.4.1-3-g733a5


From 9ba661ebdbf5020b5b90c89d8ae889a72da33d6b Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 16 Jul 2025 16:25:46 +0800
Subject: Remove redundant type parameters

---
 .../crates/ide-assists/src/handlers/generate_mut_trait_impl.rs    | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
index 789fb8288c2..415a7fce062 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
@@ -236,7 +236,7 @@ impl<T> core::ops::Index<Axis> for [T; 3] where T: Copy {
 //- minicore: as_ref
 struct Foo(i32);
 
-impl<T> core::convert::AsRef$0<i32> for Foo {
+impl core::convert::AsRef$0<i32> for Foo {
     fn as_ref(&self) -> &i32 {
         &self.0
     }
@@ -245,13 +245,13 @@ impl<T> core::convert::AsRef$0<i32> for Foo {
             r#"
 struct Foo(i32);
 
-$0impl<T> core::convert::AsMut<i32> for Foo {
+$0impl core::convert::AsMut<i32> for Foo {
     fn as_mut(&mut self) -> &mut i32 {
         &self.0
     }
 }
 
-impl<T> core::convert::AsRef<i32> for Foo {
+impl core::convert::AsRef<i32> for Foo {
     fn as_ref(&self) -> &i32 {
         &self.0
     }
@@ -362,7 +362,7 @@ impl<T> Index$0<i32> for [T; 3] {}
             r#"
 pub trait AsRef<T: ?Sized> {}
 
-impl<T> AsRef$0<i32> for [T; 3] {}
+impl AsRef$0<i32> for [T; 3] {}
 "#,
         );
     }
-- 
cgit 1.4.1-3-g733a5


From a7818abc141a072ff069ed6c43ebbe56eade9c23 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 16 Jul 2025 11:01:44 +0200
Subject: minor tweaks and comments

---
 src/tools/miri/src/concurrency/thread.rs           |  2 +
 src/tools/miri/src/eval.rs                         | 41 ++++-----
 src/tools/miri/src/shims/ctor.rs                   | 94 ---------------------
 src/tools/miri/src/shims/global_ctor.rs            | 98 ++++++++++++++++++++++
 src/tools/miri/src/shims/mod.rs                    |  2 +-
 src/tools/miri/tests/pass/alloc-access-tracking.rs |  4 +-
 src/tools/miri/tests/pass/shims/ctor.rs            |  3 +
 7 files changed, 127 insertions(+), 117 deletions(-)
 delete mode 100644 src/tools/miri/src/shims/ctor.rs
 create mode 100644 src/tools/miri/src/shims/global_ctor.rs

diff --git a/src/tools/miri/src/concurrency/thread.rs b/src/tools/miri/src/concurrency/thread.rs
index abfee0ee874..878afdf2517 100644
--- a/src/tools/miri/src/concurrency/thread.rs
+++ b/src/tools/miri/src/concurrency/thread.rs
@@ -677,6 +677,8 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
     fn run_on_stack_empty(&mut self) -> InterpResult<'tcx, Poll<()>> {
         let this = self.eval_context_mut();
         // Inform GenMC that a thread has finished all user code. GenMC needs to know this for scheduling.
+        // FIXME(GenMC): Thread-local destructors *are* user code, so this is odd. Also now that we
+        // support pre-main constructors, it can get called there as well.
         if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
             let thread_id = this.active_thread();
             genmc_ctx.handle_thread_stack_empty(thread_id);
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index d986f2830aa..be6404f64e8 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -18,7 +18,7 @@ use rustc_session::config::EntryFnType;
 use crate::concurrency::GenmcCtx;
 use crate::concurrency::thread::TlsAllocAction;
 use crate::diagnostics::report_leaks;
-use crate::shims::{ctor, tls};
+use crate::shims::{global_ctor, tls};
 use crate::*;
 
 #[derive(Copy, Clone, Debug)]
@@ -219,9 +219,11 @@ impl Default for MiriConfig {
 #[derive(Debug)]
 enum MainThreadState<'tcx> {
     GlobalCtors {
-        ctor_state: ctor::GlobalCtorState<'tcx>,
+        ctor_state: global_ctor::GlobalCtorState<'tcx>,
+        /// The main function to call.
         entry_id: DefId,
         entry_type: MiriEntryFnType,
+        /// Arguments passed to `main`.
         argc: ImmTy<'tcx>,
         argv: ImmTy<'tcx>,
     },
@@ -324,12 +326,19 @@ pub fn create_ecx<'tcx>(
         MiriMachine::new(config, layout_cx, genmc_ctx),
     );
 
-    // First argument is constructed later, because it's skipped for `miri_start.`
+    // Make sure we have MIR. We check MIR for some stable monomorphic function in libcore.
+    let sentinel =
+        helpers::try_resolve_path(tcx, &["core", "ascii", "escape_default"], Namespace::ValueNS);
+    if !matches!(sentinel, Some(s) if tcx.is_mir_available(s.def.def_id())) {
+        tcx.dcx().fatal(
+            "the current sysroot was built without `-Zalways-encode-mir`, or libcore seems missing. \
+            Use `cargo miri setup` to prepare a sysroot that is suitable for Miri."
+        );
+    }
 
-    // Second argument (argc): length of `config.args`.
+    // Compute argc and argv from `config.args`.
     let argc =
         ImmTy::from_int(i64::try_from(config.args.len()).unwrap(), ecx.machine.layouts.isize);
-    // Third argument (`argv`): created from `config.args`.
     let argv = {
         // Put each argument in memory, collect pointers.
         let mut argvs = Vec::<Immediate<Provenance>>::with_capacity(config.args.len());
@@ -354,7 +363,7 @@ pub fn create_ecx<'tcx>(
             ecx.write_immediate(arg, &place)?;
         }
         ecx.mark_immutable(&argvs_place);
-        // Store `argc` and `argv` for macOS `_NSGetArg{c,v}`.
+        // Store `argc` and `argv` for macOS `_NSGetArg{c,v}`, and for the GC to see them.
         {
             let argc_place =
                 ecx.allocate(ecx.machine.layouts.isize, MiriMemoryKind::Machine.into())?;
@@ -369,7 +378,7 @@ pub fn create_ecx<'tcx>(
             ecx.machine.argv = Some(argv_place.ptr());
         }
         // Store command line as UTF-16 for Windows `GetCommandLineW`.
-        {
+        if tcx.sess.target.os == "windows" {
             // Construct a command string with all the arguments.
             let cmd_utf16: Vec<u16> = args_to_utf16_command_string(config.args.iter());
 
@@ -392,28 +401,20 @@ pub fn create_ecx<'tcx>(
 
     // Some parts of initialization require a full `InterpCx`.
     MiriMachine::late_init(&mut ecx, config, {
-        let mut state = MainThreadState::GlobalCtors {
+        let mut main_thread_state = MainThreadState::GlobalCtors {
             entry_id,
             entry_type,
             argc,
             argv,
-            ctor_state: ctor::GlobalCtorState::default(),
+            ctor_state: global_ctor::GlobalCtorState::default(),
         };
 
         // Cannot capture anything GC-relevant here.
-        Box::new(move |m| state.on_main_stack_empty(m))
+        // `argc` and `argv` *are* GC_relevant, but they also get stored in `machine.argc` and
+        // `machine.argv` so we are good.
+        Box::new(move |m| main_thread_state.on_main_stack_empty(m))
     })?;
 
-    // Make sure we have MIR. We check MIR for some stable monomorphic function in libcore.
-    let sentinel =
-        helpers::try_resolve_path(tcx, &["core", "ascii", "escape_default"], Namespace::ValueNS);
-    if !matches!(sentinel, Some(s) if tcx.is_mir_available(s.def.def_id())) {
-        tcx.dcx().fatal(
-            "the current sysroot was built without `-Zalways-encode-mir`, or libcore seems missing. \
-            Use `cargo miri setup` to prepare a sysroot that is suitable for Miri."
-        );
-    }
-
     interp_ok(ecx)
 }
 
diff --git a/src/tools/miri/src/shims/ctor.rs b/src/tools/miri/src/shims/ctor.rs
deleted file mode 100644
index 367c2b1608b..00000000000
--- a/src/tools/miri/src/shims/ctor.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-//! Implement global constructors.
-
-use std::task::Poll;
-
-use rustc_abi::ExternAbi;
-use rustc_target::spec::BinaryFormat;
-
-use crate::*;
-
-#[derive(Debug, Default)]
-pub struct GlobalCtorState<'tcx>(GlobalCtorStatePriv<'tcx>);
-
-#[derive(Debug, Default)]
-enum GlobalCtorStatePriv<'tcx> {
-    #[default]
-    Init,
-    /// The list of constructor functions that we still have to call.
-    Ctors(Vec<ImmTy<'tcx>>),
-    Done,
-}
-
-impl<'tcx> GlobalCtorState<'tcx> {
-    pub fn on_stack_empty(
-        &mut self,
-        this: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, Poll<()>> {
-        use GlobalCtorStatePriv::*;
-        let new_state = 'new_state: {
-            match &mut self.0 {
-                Init => {
-                    let this = this.eval_context_mut();
-
-                    // Lookup constructors from the relevant magic link section.
-                    let ctors = match this.tcx.sess.target.binary_format {
-                        // Read the CRT library section on Windows.
-                        BinaryFormat::Coff =>
-                            this.lookup_link_section(|section| section == ".CRT$XCU")?,
-
-                        // Read the `__mod_init_func` section on macOS.
-                        BinaryFormat::MachO =>
-                            this.lookup_link_section(|section| {
-                                let mut parts = section.splitn(3, ',');
-                                let (segment_name, section_name, section_type) =
-                                    (parts.next(), parts.next(), parts.next());
-
-                                segment_name == Some("__DATA")
-                                    && section_name == Some("__mod_init_func")
-                                    // The `mod_init_funcs` directive ensures that the `S_MOD_INIT_FUNC_POINTERS` flag
-                                    // is set on the section, but it is not strictly required.
-                                    && matches!(section_type, None | Some("mod_init_funcs"))
-                            })?,
-
-                        // Read the standard `.init_array` section on platforms that use ELF, or WASM,
-                        // which supports the same linker directive.
-                        // FIXME: Add support for `.init_array.N` and `.ctors`?
-                        BinaryFormat::Elf | BinaryFormat::Wasm =>
-                            this.lookup_link_section(|section| section == ".init_array")?,
-
-                        // Other platforms have no global ctor support.
-                        _ => break 'new_state Done,
-                    };
-
-                    break 'new_state Ctors(ctors);
-                }
-                Ctors(ctors) => {
-                    if let Some(ctor) = ctors.pop() {
-                        let this = this.eval_context_mut();
-
-                        let ctor = ctor.to_scalar().to_pointer(this)?;
-                        let thread_callback = this.get_ptr_fn(ctor)?.as_instance()?;
-
-                        // The signature of this function is `unsafe extern "C" fn()`.
-                        this.call_function(
-                            thread_callback,
-                            ExternAbi::C { unwind: false },
-                            &[],
-                            None,
-                            ReturnContinuation::Stop { cleanup: true },
-                        )?;
-
-                        return interp_ok(Poll::Pending); // we stay in this state (but `ctors` got shorter)
-                    }
-
-                    // No more constructors to run.
-                    break 'new_state Done;
-                }
-                Done => return interp_ok(Poll::Ready(())),
-            }
-        };
-
-        self.0 = new_state;
-        interp_ok(Poll::Pending)
-    }
-}
diff --git a/src/tools/miri/src/shims/global_ctor.rs b/src/tools/miri/src/shims/global_ctor.rs
new file mode 100644
index 00000000000..c56251bbe63
--- /dev/null
+++ b/src/tools/miri/src/shims/global_ctor.rs
@@ -0,0 +1,98 @@
+//! Implement global constructors.
+
+use std::task::Poll;
+
+use rustc_abi::ExternAbi;
+use rustc_target::spec::BinaryFormat;
+
+use crate::*;
+
+#[derive(Debug, Default)]
+pub struct GlobalCtorState<'tcx>(GlobalCtorStatePriv<'tcx>);
+
+#[derive(Debug, Default)]
+enum GlobalCtorStatePriv<'tcx> {
+    #[default]
+    Init,
+    /// The list of constructor functions that we still have to call.
+    Ctors(Vec<ImmTy<'tcx>>),
+    Done,
+}
+
+impl<'tcx> GlobalCtorState<'tcx> {
+    pub fn on_stack_empty(
+        &mut self,
+        this: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx, Poll<()>> {
+        use GlobalCtorStatePriv::*;
+        let new_state = 'new_state: {
+            match &mut self.0 {
+                Init => {
+                    let this = this.eval_context_mut();
+
+                    // Lookup constructors from the relevant magic link section.
+                    let ctors = match this.tcx.sess.target.binary_format {
+                        // Read the CRT library section on Windows.
+                        BinaryFormat::Coff =>
+                            this.lookup_link_section(|section| section == ".CRT$XCU")?,
+
+                        // Read the `__mod_init_func` section on macOS.
+                        BinaryFormat::MachO =>
+                            this.lookup_link_section(|section| {
+                                let mut parts = section.splitn(3, ',');
+                                let (segment_name, section_name, section_type) =
+                                    (parts.next(), parts.next(), parts.next());
+
+                                segment_name == Some("__DATA")
+                                    && section_name == Some("__mod_init_func")
+                                    // The `mod_init_funcs` directive ensures that the
+                                    // `S_MOD_INIT_FUNC_POINTERS` flag is set on the section. LLVM
+                                    // adds this automatically so we currently do not require it.
+                                    // FIXME: is this guaranteed LLVM behavior? If not, we shouldn't
+                                    // implicitly add it here. Also see
+                                    // <https://github.com/rust-lang/miri/pull/4459#discussion_r2200115629>.
+                                    && matches!(section_type, None | Some("mod_init_funcs"))
+                            })?,
+
+                        // Read the standard `.init_array` section on platforms that use ELF, or WASM,
+                        // which supports the same linker directive.
+                        // FIXME: Add support for `.init_array.N` and `.ctors`?
+                        BinaryFormat::Elf | BinaryFormat::Wasm =>
+                            this.lookup_link_section(|section| section == ".init_array")?,
+
+                        // Other platforms have no global ctor support.
+                        _ => break 'new_state Done,
+                    };
+
+                    break 'new_state Ctors(ctors);
+                }
+                Ctors(ctors) => {
+                    if let Some(ctor) = ctors.pop() {
+                        let this = this.eval_context_mut();
+
+                        let ctor = ctor.to_scalar().to_pointer(this)?;
+                        let thread_callback = this.get_ptr_fn(ctor)?.as_instance()?;
+
+                        // The signature of this function is `unsafe extern "C" fn()`.
+                        this.call_function(
+                            thread_callback,
+                            ExternAbi::C { unwind: false },
+                            &[],
+                            None,
+                            ReturnContinuation::Stop { cleanup: true },
+                        )?;
+
+                        return interp_ok(Poll::Pending); // we stay in this state (but `ctors` got shorter)
+                    }
+
+                    // No more constructors to run.
+                    break 'new_state Done;
+                }
+                Done => return interp_ok(Poll::Ready(())),
+            }
+        };
+
+        self.0 = new_state;
+        interp_ok(Poll::Pending)
+    }
+}
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index 0faf298bfaa..75540f6f150 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -11,10 +11,10 @@ mod wasi;
 mod windows;
 mod x86;
 
-pub mod ctor;
 pub mod env;
 pub mod extern_static;
 pub mod foreign_items;
+pub mod global_ctor;
 pub mod io_error;
 pub mod os_str;
 pub mod panic;
diff --git a/src/tools/miri/tests/pass/alloc-access-tracking.rs b/src/tools/miri/tests/pass/alloc-access-tracking.rs
index 0e88951dc43..9eba0ca171b 100644
--- a/src/tools/miri/tests/pass/alloc-access-tracking.rs
+++ b/src/tools/miri/tests/pass/alloc-access-tracking.rs
@@ -1,7 +1,7 @@
 #![no_std]
 #![no_main]
-//@compile-flags: -Zmiri-track-alloc-id=20 -Zmiri-track-alloc-accesses -Cpanic=abort
-//@normalize-stderr-test: "id 20" -> "id $$ALLOC"
+//@compile-flags: -Zmiri-track-alloc-id=19 -Zmiri-track-alloc-accesses -Cpanic=abort
+//@normalize-stderr-test: "id 19" -> "id $$ALLOC"
 //@only-target: linux # alloc IDs differ between OSes (due to extern static allocations)
 
 extern "Rust" {
diff --git a/src/tools/miri/tests/pass/shims/ctor.rs b/src/tools/miri/tests/pass/shims/ctor.rs
index c832e3f82a3..b997d2386b8 100644
--- a/src/tools/miri/tests/pass/shims/ctor.rs
+++ b/src/tools/miri/tests/pass/shims/ctor.rs
@@ -6,6 +6,7 @@ unsafe extern "C" fn ctor() {
     COUNT.fetch_add(1, Ordering::Relaxed);
 }
 
+#[rustfmt::skip]
 macro_rules! ctor {
     ($ident:ident = $ctor:ident) => {
         #[cfg_attr(
@@ -27,6 +28,8 @@ macro_rules! ctor {
         #[cfg_attr(windows, link_section = ".CRT$XCU")]
         #[cfg_attr(
             any(target_os = "macos", target_os = "ios"),
+            // We do not set the `mod_init_funcs` flag here since ctor/inventory also do not do
+            // that. See <https://github.com/rust-lang/miri/pull/4459#discussion_r2200115629>.
             link_section = "__DATA,__mod_init_func"
         )]
         #[used]
-- 
cgit 1.4.1-3-g733a5


From 9909a37fdcf86aa1302cd5a0656124fda65a2ac0 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 16 Jul 2025 17:15:19 +0800
Subject: Use hir::Trait in parameter

---
 .../src/handlers/generate_mut_trait_impl.rs        | 61 +++++++++-------------
 1 file changed, 24 insertions(+), 37 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
index 415a7fce062..ac07d35e9ec 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
@@ -1,4 +1,4 @@
-use ide_db::famous_defs::FamousDefs;
+use ide_db::{famous_defs::FamousDefs, traits::resolve_target_trait};
 use syntax::{
     AstNode,
     ast::{self, edit_in_place::Indent, make},
@@ -48,27 +48,19 @@ pub(crate) fn generate_mut_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>
     let impl_def = ctx.find_node_at_offset::<ast::Impl>()?.clone_for_update();
     let indent = impl_def.indent_level();
 
-    let (apply_trait, new_apply_trait) = impl_def
-        .syntax()
-        .descendants()
-        .filter_map(ast::NameRef::cast)
-        .find_map(process_trait_name)?;
-
-    let trait_ = impl_def.trait_()?;
-    if let ast::Type::PathType(trait_path) = trait_ {
-        let trait_type = ctx.sema.resolve_trait(&trait_path.path()?)?;
-        let scope = ctx.sema.scope(trait_path.syntax())?;
-        let famous_defs = FamousDefs(&ctx.sema, scope.krate());
-        if trait_type != get_famous(&apply_trait.text(), famous_defs)? {
-            return None;
-        }
-    }
+    let ast::Type::PathType(path) = impl_def.trait_()? else {
+        return None;
+    };
+    let trait_name = path.path()?.segment()?.name_ref()?;
+
+    let scope = ctx.sema.scope(impl_def.trait_()?.syntax())?;
+    let famous = FamousDefs(&ctx.sema, scope.krate());
+
+    let trait_ = resolve_target_trait(&ctx.sema, &impl_def)?;
+    let trait_new = get_trait_mut(&trait_, famous)?;
 
     // Index -> IndexMut
-    ted::replace(
-        apply_trait.syntax(),
-        make::path_segment(make::name_ref(new_apply_trait)).clone_for_update().syntax(),
-    );
+    ted::replace(trait_name.syntax(), make::name_ref(trait_new).clone_for_update().syntax());
 
     // index -> index_mut
     let (trait_method_name, new_trait_method_name) = impl_def
@@ -108,7 +100,7 @@ pub(crate) fn generate_mut_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>
     let target = impl_def.syntax().text_range();
     acc.add(
         AssistId::generate("generate_mut_trait_impl"),
-        format!("Generate `{new_apply_trait}` impl from this `{apply_trait}` trait"),
+        format!("Generate `{trait_new}` impl from this `{trait_name}` trait"),
         target,
         |edit| {
             edit.insert(target.start(), format!("$0{impl_def}\n\n{indent}"));
@@ -116,23 +108,18 @@ pub(crate) fn generate_mut_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>
     )
 }
 
-fn get_famous(apply_trait: &str, famous: FamousDefs<'_, '_>) -> Option<hir::Trait> {
-    match apply_trait {
-        "Index" => famous.core_convert_Index(),
-        "AsRef" => famous.core_convert_AsRef(),
-        "Borrow" => famous.core_borrow_Borrow(),
-        _ => None,
+fn get_trait_mut(apply_trait: &hir::Trait, famous: FamousDefs<'_, '_>) -> Option<&'static str> {
+    let trait_ = Some(apply_trait);
+    if trait_ == famous.core_convert_Index().as_ref() {
+        return Some("IndexMut");
     }
-}
-
-fn process_trait_name(name: ast::NameRef) -> Option<(ast::NameRef, &'static str)> {
-    let new_name = match &*name.text() {
-        "Index" => "IndexMut",
-        "AsRef" => "AsMut",
-        "Borrow" => "BorrowMut",
-        _ => return None,
-    };
-    Some((name, new_name))
+    if trait_ == famous.core_convert_AsRef().as_ref() {
+        return Some("AsMut");
+    }
+    if trait_ == famous.core_borrow_Borrow().as_ref() {
+        return Some("BorrowMut");
+    }
+    None
 }
 
 fn process_method_name(name: ast::Name) -> Option<(ast::Name, &'static str)> {
-- 
cgit 1.4.1-3-g733a5


From 6e3b9ddc3a3884e110ad6b2b57e861d8c0c98771 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 16 Jul 2025 13:40:56 +0200
Subject: triagebot welcome message for new users

---
 src/tools/miri/CONTRIBUTING.md |  2 +-
 src/tools/miri/triagebot.toml  | 11 +++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/CONTRIBUTING.md b/src/tools/miri/CONTRIBUTING.md
index fef7f807e93..e4302b734aa 100644
--- a/src/tools/miri/CONTRIBUTING.md
+++ b/src/tools/miri/CONTRIBUTING.md
@@ -13,7 +13,7 @@ for a list of Miri maintainers.
 
 [Rust Zulip]: https://rust-lang.zulipchat.com
 
-### Pull review process
+### PR review process
 
 When you get a review, please take care of the requested changes in new commits. Do not amend
 existing commits. Generally avoid force-pushing. The only time you should force push is when there
diff --git a/src/tools/miri/triagebot.toml b/src/tools/miri/triagebot.toml
index 60e80c3f673..c109b620846 100644
--- a/src/tools/miri/triagebot.toml
+++ b/src/tools/miri/triagebot.toml
@@ -17,6 +17,17 @@ allow-unauthenticated = [
 [assign]
 warn_non_default_branch = true
 contributing_url = "https://github.com/rust-lang/miri/blob/master/CONTRIBUTING.md"
+[assign.custom_welcome_messages]
+welcome-message = """
+Welcome, and thank you for contributing to Miri!
+To ensure a smooth reviewing experience, please read https://github.com/rust-lang/miri/blob/master/CONTRIBUTING.md#pr-review-process.
+In particular, please do not force-push to the PR branch except when you need to rebase due to a conflict or when the reviewer asks you for it.
+"""
+welcome-message-no-reviewer = """
+Welcome, and thank you for contributing to Miri!
+To ensure a smooth reviewing experience, please read https://github.com/rust-lang/miri/blob/master/CONTRIBUTING.md#pr-review-process.
+In particular, please do not force-push to the PR branch except when you need to rebase due to a conflict or when the reviewer asks you for it.
+"""
 
 [no-merges]
 exclude_titles = ["Rustup"]
-- 
cgit 1.4.1-3-g733a5


From 47b138b2b89f91278b7825569b1bdad24f1eee6a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 15 Jul 2025 18:11:07 +0200
Subject: Make aliases search support partial matching

---
 src/librustdoc/html/render/search_index.rs |   2 +-
 src/librustdoc/html/static/js/rustdoc.d.ts |   5 +
 src/librustdoc/html/static/js/search.js    | 150 +++++++++++++++--------------
 3 files changed, 83 insertions(+), 74 deletions(-)

diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index aff8684ee3a..ef0a8361fd9 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -116,7 +116,7 @@ pub(crate) fn build_index(
     // Set up alias indexes.
     for (i, item) in cache.search_index.iter().enumerate() {
         for alias in &item.aliases[..] {
-            aliases.entry(alias.as_str().to_lowercase()).or_default().push(i);
+            aliases.entry(alias.to_string()).or_default().push(i);
         }
     }
 
diff --git a/src/librustdoc/html/static/js/rustdoc.d.ts b/src/librustdoc/html/static/js/rustdoc.d.ts
index ca2512e5ab6..9ce24d1c06f 100644
--- a/src/librustdoc/html/static/js/rustdoc.d.ts
+++ b/src/librustdoc/html/static/js/rustdoc.d.ts
@@ -227,6 +227,11 @@ declare namespace rustdoc {
         path: string,
         ty: number,
         type: FunctionSearchType | null,
+        descIndex: number,
+        bitIndex: number,
+        implDisambiguator: String | null,
+        is_alias?: boolean,
+        original?: Row,
     }
 
     /**
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index 15cad31f555..2caf214ff73 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -830,7 +830,7 @@ function createQueryElement(query, parserState, name, generics, isInGenerics) {
  */
 function makePrimitiveElement(name, extra) {
     return Object.assign({
-        name: name,
+        name,
         id: null,
         fullPath: [name],
         pathWithoutLast: [],
@@ -1483,6 +1483,7 @@ class DocSearch {
          */
         this.assocTypeIdNameMap = new Map();
         this.ALIASES = new Map();
+        this.FOUND_ALIASES = new Set();
         this.rootPath = rootPath;
         this.searchState = searchState;
 
@@ -2030,6 +2031,8 @@ class DocSearch {
         // normalized names, type signature objects and fingerprints, and aliases.
         id = 0;
 
+        /** @type {Array<[string, { [key: string]: Array<number> },  number]>} */
+        const allAliases = [];
         for (const [crate, crateCorpus] of rawSearchIndex) {
             // a string representing the lengths of each description shard
             // a string representing the list of function types
@@ -2178,10 +2181,10 @@ class DocSearch {
                 paths[i] = { ty, name, path, exactPath, unboxFlag };
             }
 
-            // convert `item*` into an object form, and construct word indices.
+            // Convert `item*` into an object form, and construct word indices.
             //
-            // before any analysis is performed lets gather the search terms to
-            // search against apart from the rest of the data.  This is a quick
+            // Before any analysis is performed, let's gather the search terms to
+            // search against apart from the rest of the data. This is a quick
             // operation that is cached for the life of the page state so that
             // all other search operations have access to this cached data for
             // faster analysis operations
@@ -2269,29 +2272,58 @@ class DocSearch {
             }
 
             if (aliases) {
-                const currentCrateAliases = new Map();
-                this.ALIASES.set(crate, currentCrateAliases);
-                for (const alias_name in aliases) {
-                    if (!Object.prototype.hasOwnProperty.call(aliases, alias_name)) {
-                        continue;
-                    }
-
-                    /** @type{number[]} */
-                    let currentNameAliases;
-                    if (currentCrateAliases.has(alias_name)) {
-                        currentNameAliases = currentCrateAliases.get(alias_name);
-                    } else {
-                        currentNameAliases = [];
-                        currentCrateAliases.set(alias_name, currentNameAliases);
-                    }
-                    for (const local_alias of aliases[alias_name]) {
-                        currentNameAliases.push(local_alias + currentIndex);
-                    }
-                }
+                // We need to add the aliases in `searchIndex` after we finished filling it
+                // to not mess up indexes.
+                allAliases.push([crate, aliases, currentIndex]);
             }
             currentIndex += itemTypes.length;
             this.searchState.descShards.set(crate, descShardList);
         }
+
+        for (const [crate, aliases, index] of allAliases) {
+            for (const [alias_name, alias_refs] of Object.entries(aliases)) {
+                if (!this.ALIASES.has(crate)) {
+                    this.ALIASES.set(crate, new Map());
+                }
+                const word = alias_name.toLowerCase();
+                const crate_alias_map = this.ALIASES.get(crate);
+                if (!crate_alias_map.has(word)) {
+                    crate_alias_map.set(word, []);
+                }
+                const aliases_map = crate_alias_map.get(word);
+
+                const normalizedName = word.indexOf("_") === -1 ? word : word.replace(/_/g, "");
+                for (const alias of alias_refs) {
+                    const originalIndex = alias + index;
+                    const original = searchIndex[originalIndex];
+                    /** @type {rustdoc.Row} */
+                    const row = {
+                        crate,
+                        name: alias_name,
+                        normalizedName,
+                        is_alias: true,
+                        ty: original.ty,
+                        type: original.type,
+                        paramNames: [],
+                        word,
+                        id,
+                        parent: undefined,
+                        original,
+                        path: "",
+                        implDisambiguator: original.implDisambiguator,
+                        // Needed to load the description of the original item.
+                        // @ts-ignore
+                        descShard: original.descShard,
+                        descIndex: original.descIndex,
+                        bitIndex: original.bitIndex,
+                    };
+                    aliases_map.push(row);
+                    this.nameTrie.insert(normalizedName, id, this.tailTable);
+                    id += 1;
+                    searchIndex.push(row);
+                }
+            }
+        }
         // Drop the (rather large) hash table used for reusing function items
         this.TYPES_POOL = new Map();
         return searchIndex;
@@ -2536,6 +2568,8 @@ class DocSearch {
             parsedQuery.elems.reduce((acc, next) => acc + next.pathLast.length, 0) +
             parsedQuery.returned.reduce((acc, next) => acc + next.pathLast.length, 0);
         const maxEditDistance = Math.floor(queryLen / 3);
+        // We reinitialize the `FOUND_ALIASES` map.
+        this.FOUND_ALIASES.clear();
 
         /**
          * @type {Map<string, number>}
@@ -2695,6 +2729,10 @@ class DocSearch {
         const buildHrefAndPath = item => {
             let displayPath;
             let href;
+            if (item.is_alias) {
+                this.FOUND_ALIASES.add(item.word);
+                item = item.original;
+            }
             const type = itemTypes[item.ty];
             const name = item.name;
             let path = item.path;
@@ -3198,8 +3236,7 @@ class DocSearch {
                 result.item = this.searchIndex[result.id];
                 result.word = this.searchIndex[result.id].word;
                 if (isReturnTypeQuery) {
-                    // we are doing a return-type based search,
-                    // deprioritize "clone-like" results,
+                    // We are doing a return-type based search, deprioritize "clone-like" results,
                     // ie. functions that also take the queried type as an argument.
                     const resultItemType = result.item && result.item.type;
                     if (!resultItemType) {
@@ -4259,28 +4296,13 @@ class DocSearch {
             return false;
         }
 
-        // this does not yet have a type in `rustdoc.d.ts`.
-        // @ts-expect-error
-        function createAliasFromItem(item) {
-            return {
-                crate: item.crate,
-                name: item.name,
-                path: item.path,
-                descShard: item.descShard,
-                descIndex: item.descIndex,
-                exactPath: item.exactPath,
-                ty: item.ty,
-                parent: item.parent,
-                type: item.type,
-                is_alias: true,
-                bitIndex: item.bitIndex,
-                implDisambiguator: item.implDisambiguator,
-            };
-        }
-
         // @ts-expect-error
         const handleAliases = async(ret, query, filterCrates, currentCrate) => {
             const lowerQuery = query.toLowerCase();
+            if (this.FOUND_ALIASES.has(lowerQuery)) {
+                return;
+            }
+            this.FOUND_ALIASES.add(lowerQuery);
             // We separate aliases and crate aliases because we want to have current crate
             // aliases to be before the others in the displayed results.
             // @ts-expect-error
@@ -4292,7 +4314,7 @@ class DocSearch {
                     && this.ALIASES.get(filterCrates).has(lowerQuery)) {
                     const query_aliases = this.ALIASES.get(filterCrates).get(lowerQuery);
                     for (const alias of query_aliases) {
-                        aliases.push(createAliasFromItem(this.searchIndex[alias]));
+                        aliases.push(alias);
                     }
                 }
             } else {
@@ -4302,7 +4324,7 @@ class DocSearch {
                         const pushTo = crate === currentCrate ? crateAliases : aliases;
                         const query_aliases = crateAliasesIndex.get(lowerQuery);
                         for (const alias of query_aliases) {
-                            pushTo.push(createAliasFromItem(this.searchIndex[alias]));
+                            pushTo.push(alias);
                         }
                     }
                 }
@@ -4310,9 +4332,9 @@ class DocSearch {
 
             // @ts-expect-error
             const sortFunc = (aaa, bbb) => {
-                if (aaa.path < bbb.path) {
+                if (aaa.original.path < bbb.original.path) {
                     return 1;
-                } else if (aaa.path === bbb.path) {
+                } else if (aaa.original.path === bbb.original.path) {
                     return 0;
                 }
                 return -1;
@@ -4321,21 +4343,10 @@ class DocSearch {
             crateAliases.sort(sortFunc);
             aliases.sort(sortFunc);
 
-            // @ts-expect-error
-            const fetchDesc = alias => {
-                // @ts-expect-error
-                return this.searchIndexEmptyDesc.get(alias.crate).contains(alias.bitIndex) ?
-                    "" : this.searchState.loadDesc(alias);
-            };
-            const [crateDescs, descs] = await Promise.all([
-                // @ts-expect-error
-                Promise.all(crateAliases.map(fetchDesc)),
-                Promise.all(aliases.map(fetchDesc)),
-            ]);
-
             // @ts-expect-error
             const pushFunc = alias => {
-                alias.alias = query;
+                // Cloning `alias` to prevent its fields to be updated.
+                alias = {...alias};
                 const res = buildHrefAndPath(alias);
                 alias.displayPath = pathSplitter(res[0]);
                 alias.fullPath = alias.displayPath + alias.name;
@@ -4347,16 +4358,8 @@ class DocSearch {
                 }
             };
 
-            aliases.forEach((alias, i) => {
-                // @ts-expect-error
-                alias.desc = descs[i];
-            });
             aliases.forEach(pushFunc);
             // @ts-expect-error
-            crateAliases.forEach((alias, i) => {
-                alias.desc = crateDescs[i];
-            });
-            // @ts-expect-error
             crateAliases.forEach(pushFunc);
         };
 
@@ -4802,7 +4805,7 @@ async function addTab(array, query, display) {
         output.className = "search-results " + extraClass;
 
         const lis = Promise.all(array.map(async item => {
-            const name = item.name;
+            const name = item.is_alias ? item.original.name : item.name;
             const type = itemTypes[item.ty];
             const longType = longItemTypes[item.ty];
             const typeName = longType.length !== 0 ? `${longType}` : "?";
@@ -4822,7 +4825,7 @@ async function addTab(array, query, display) {
             let alias = " ";
             if (item.is_alias) {
                 alias = ` <div class="alias">\
-<b>${item.alias}</b><i class="grey">&nbsp;- see&nbsp;</i>\
+<b>${item.name}</b><i class="grey">&nbsp;- see&nbsp;</i>\
 </div>`;
             }
             resultName.insertAdjacentHTML(
@@ -5201,6 +5204,7 @@ function registerSearchEvents() {
         if (searchState.input.value.length === 0) {
             searchState.hideResults();
         } else {
+            // @ts-ignore
             searchState.timeout = setTimeout(search, 500);
         }
     };
@@ -5842,8 +5846,8 @@ Lev1TParametricDescription.prototype.offsetIncrs3 = /*2 bits per value */ new In
 // be called ONLY when the whole file has been parsed and loaded.
 
 // @ts-expect-error
-function initSearch(searchIndx) {
-    rawSearchIndex = searchIndx;
+function initSearch(searchIndex) {
+    rawSearchIndex = searchIndex;
     if (typeof window !== "undefined") {
         // @ts-expect-error
         docSearch = new DocSearch(rawSearchIndex, ROOT_PATH, searchState);
-- 
cgit 1.4.1-3-g733a5


From b0bf51f9a9323ca5abf595c6d0653d60fe68ee24 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 15 Jul 2025 21:07:55 +0200
Subject: Update rustdoc search tester to new alias output

---
 src/tools/rustdoc-js/tester.js | 71 +++++++++++++++++++++++++++---------------
 1 file changed, 46 insertions(+), 25 deletions(-)

diff --git a/src/tools/rustdoc-js/tester.js b/src/tools/rustdoc-js/tester.js
index f70fc917770..0baa179e16b 100644
--- a/src/tools/rustdoc-js/tester.js
+++ b/src/tools/rustdoc-js/tester.js
@@ -28,7 +28,14 @@ function readFile(filePath) {
 }
 
 function contentToDiffLine(key, value) {
-    return `"${key}": "${value}",`;
+    if (typeof value === "object" && !Array.isArray(value) && value !== null) {
+        const out = Object.entries(value)
+            .filter(([subKey, _]) => ["path", "name"].includes(subKey))
+            .map(([subKey, subValue]) => `"${subKey}": ${JSON.stringify(subValue)}`)
+            .join(", ");
+        return `"${key}": ${out},`;
+    }
+    return `"${key}": ${JSON.stringify(value)},`;
 }
 
 function shouldIgnoreField(fieldName) {
@@ -37,47 +44,61 @@ function shouldIgnoreField(fieldName) {
         fieldName === "proposeCorrectionTo";
 }
 
+function valueMapper(key, testOutput) {
+    const isAlias = testOutput["is_alias"];
+    let value = testOutput[key];
+    // To make our life easier, if there is a "parent" type, we add it to the path.
+    if (key === "path") {
+        if (testOutput["parent"] !== undefined) {
+            if (value.length > 0) {
+                value += "::" + testOutput["parent"]["name"];
+            } else {
+                value = testOutput["parent"]["name"];
+            }
+        } else if (testOutput["is_alias"]) {
+            value = valueMapper(key, testOutput["original"]);
+        }
+    } else if (isAlias && key === "alias") {
+        value = testOutput["name"];
+    } else if (isAlias && ["name"].includes(key)) {
+        value = testOutput["original"][key];
+    }
+    return value;
+}
+
 // This function is only called when no matching result was found and therefore will only display
 // the diff between the two items.
-function betterLookingDiff(entry, data) {
+function betterLookingDiff(expected, testOutput) {
     let output = " {\n";
-    const spaces = "     ";
-    for (const key in entry) {
-        if (!Object.prototype.hasOwnProperty.call(entry, key)) {
+    const spaces = "    ";
+    for (const key in expected) {
+        if (!Object.prototype.hasOwnProperty.call(expected, key)) {
             continue;
         }
-        if (!data || !Object.prototype.hasOwnProperty.call(data, key)) {
-            output += "-" + spaces + contentToDiffLine(key, entry[key]) + "\n";
+        if (!testOutput || !Object.prototype.hasOwnProperty.call(testOutput, key)) {
+            output += "-" + spaces + contentToDiffLine(key, expected[key]) + "\n";
             continue;
         }
-        const value = data[key];
-        if (value !== entry[key]) {
-            output += "-" + spaces + contentToDiffLine(key, entry[key]) + "\n";
+        const value = valueMapper(key, testOutput);
+        if (value !== expected[key]) {
+            output += "-" + spaces + contentToDiffLine(key, expected[key]) + "\n";
             output += "+" + spaces + contentToDiffLine(key, value) + "\n";
         } else {
-            output += spaces + contentToDiffLine(key, value) + "\n";
+            output += spaces + " " + contentToDiffLine(key, value) + "\n";
         }
     }
     return output + " }";
 }
 
-function lookForEntry(entry, data) {
-    return data.findIndex(data_entry => {
+function lookForEntry(expected, testOutput) {
+    return testOutput.findIndex(testOutputEntry => {
         let allGood = true;
-        for (const key in entry) {
-            if (!Object.prototype.hasOwnProperty.call(entry, key)) {
+        for (const key in expected) {
+            if (!Object.prototype.hasOwnProperty.call(expected, key)) {
                 continue;
             }
-            let value = data_entry[key];
-            // To make our life easier, if there is a "parent" type, we add it to the path.
-            if (key === "path" && data_entry["parent"] !== undefined) {
-                if (value.length > 0) {
-                    value += "::" + data_entry["parent"]["name"];
-                } else {
-                    value = data_entry["parent"]["name"];
-                }
-            }
-            if (value !== entry[key]) {
+            const value = valueMapper(key, testOutputEntry);
+            if (value !== expected[key]) {
                 allGood = false;
                 break;
             }
-- 
cgit 1.4.1-3-g733a5


From c079c96877fdd3977c8d5be830931ecb4f79018d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 15 Jul 2025 21:08:18 +0200
Subject: Add test for aliases partial match

---
 tests/rustdoc-js-std/alias-lev.js          | 11 +++++++++++
 tests/rustdoc-js/non-english-identifier.js | 17 +++++++++--------
 2 files changed, 20 insertions(+), 8 deletions(-)
 create mode 100644 tests/rustdoc-js-std/alias-lev.js

diff --git a/tests/rustdoc-js-std/alias-lev.js b/tests/rustdoc-js-std/alias-lev.js
new file mode 100644
index 00000000000..17f3dc25d76
--- /dev/null
+++ b/tests/rustdoc-js-std/alias-lev.js
@@ -0,0 +1,11 @@
+// This test ensures that aliases are also allowed to be partially matched.
+
+// ignore-order
+
+const EXPECTED = {
+    // The full alias name is `getcwd`.
+    'query': 'getcw',
+    'others': [
+        { 'path': 'std::env', 'name': 'current_dir', 'alias': 'getcwd' },
+    ],
+};
diff --git a/tests/rustdoc-js/non-english-identifier.js b/tests/rustdoc-js/non-english-identifier.js
index f2180b4c755..3d50bd3ee90 100644
--- a/tests/rustdoc-js/non-english-identifier.js
+++ b/tests/rustdoc-js/non-english-identifier.js
@@ -115,11 +115,10 @@ const EXPECTED = [
         query: '加法',
         others: [
             {
-                name: "add",
+                name: "加法",
                 path: "non_english_identifier",
-                is_alias: true,
-                alias: "加法",
-                href: "../non_english_identifier/macro.add.html"
+                href: "../non_english_identifier/trait.加法.html",
+                desc: "Add"
             },
             {
                 name: "add",
@@ -129,11 +128,13 @@ const EXPECTED = [
                 href: "../non_english_identifier/fn.add.html"
             },
             {
-                name: "加法",
+                name: "add",
                 path: "non_english_identifier",
-                href: "../non_english_identifier/trait.加法.html",
-                desc: "Add"
-            }],
+                is_alias: true,
+                alias: "加法",
+                href: "../non_english_identifier/macro.add.html"
+            },
+        ],
         in_args: [{
             name: "加上",
             path: "non_english_identifier::加法",
-- 
cgit 1.4.1-3-g733a5


From 8d64937dc25eb2b01596a3581ec2660d8e81b9b2 Mon Sep 17 00:00:00 2001
From: David Wood <david.wood2@arm.com>
Date: Wed, 16 Jul 2025 10:56:32 +0000
Subject: trait_sel: `MetaSized` always holds temporarily

As a temporary measure while a proper fix for
`tests/ui/sized-hierarchy/incomplete-inference-issue-143992.rs`
is implemented, make `MetaSized` obligations always hold. In effect,
temporarily reverting the `sized_hierarchy` feature. This is a small
change that can be backported.
---
 compiler/rustc_trait_selection/src/traits/util.rs  |  7 +++
 .../const-size_of_val-align_of_val-extern-type.rs  |  4 +-
 ...nst-size_of_val-align_of_val-extern-type.stderr | 38 +++-------------
 tests/ui/extern/extern-types-size_of_val.rs        |  4 +-
 tests/ui/extern/extern-types-size_of_val.stderr    | 39 ----------------
 tests/ui/extern/extern-types-unsized.rs            |  2 -
 tests/ui/extern/extern-types-unsized.stderr        | 30 +------------
 tests/ui/extern/unsized-extern-derefmove.rs        |  4 --
 tests/ui/extern/unsized-extern-derefmove.stderr    | 52 +---------------------
 tests/ui/layout/unconstrained-param-ice-137308.rs  |  1 -
 .../layout/unconstrained-param-ice-137308.stderr   | 11 +----
 tests/ui/nll/issue-50716.rs                        |  2 +-
 tests/ui/nll/issue-50716.stderr                    | 18 +-------
 .../incomplete-inference-issue-143992.next.stderr  | 17 +++++++
 .../incomplete-inference-issue-143992.rs           | 29 ++++++++++++
 tests/ui/sized-hierarchy/overflow.current.stderr   | 45 -------------------
 tests/ui/sized-hierarchy/overflow.rs               |  6 ++-
 .../traits/resolve-impl-before-constrain-check.rs  |  1 -
 .../resolve-impl-before-constrain-check.stderr     | 11 +----
 19 files changed, 77 insertions(+), 244 deletions(-)
 delete mode 100644 tests/ui/extern/extern-types-size_of_val.stderr
 create mode 100644 tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next.stderr
 create mode 100644 tests/ui/sized-hierarchy/incomplete-inference-issue-143992.rs
 delete mode 100644 tests/ui/sized-hierarchy/overflow.current.stderr

diff --git a/compiler/rustc_trait_selection/src/traits/util.rs b/compiler/rustc_trait_selection/src/traits/util.rs
index 141454bfe37..00e31021eec 100644
--- a/compiler/rustc_trait_selection/src/traits/util.rs
+++ b/compiler/rustc_trait_selection/src/traits/util.rs
@@ -378,6 +378,13 @@ pub fn sizedness_fast_path<'tcx>(tcx: TyCtxt<'tcx>, predicate: ty::Predicate<'tc
             _ => return false,
         };
 
+        // FIXME(sized_hierarchy): this temporarily reverts the `sized_hierarchy` feature
+        // while a proper fix for `tests/ui/sized-hierarchy/incomplete-inference-issue-143992.rs`
+        // is pending a proper fix
+        if !tcx.features().sized_hierarchy() && matches!(sizedness, SizedTraitKind::MetaSized) {
+            return true;
+        }
+
         if trait_pred.self_ty().has_trivial_sizedness(tcx, sizedness) {
             debug!("fast path -- trivial sizedness");
             return true;
diff --git a/tests/ui/consts/const-size_of_val-align_of_val-extern-type.rs b/tests/ui/consts/const-size_of_val-align_of_val-extern-type.rs
index 2372d1c3e3d..fd3ed8f1826 100644
--- a/tests/ui/consts/const-size_of_val-align_of_val-extern-type.rs
+++ b/tests/ui/consts/const-size_of_val-align_of_val-extern-type.rs
@@ -8,8 +8,8 @@ extern "C" {
 }
 
 const _SIZE: usize = unsafe { size_of_val(&4 as *const i32 as *const Opaque) };
-//~^ ERROR the size for values of type `Opaque` cannot be known
+//~^ ERROR `extern type` does not have known layout
 const _ALIGN: usize = unsafe { align_of_val(&4 as *const i32 as *const Opaque) };
-//~^ ERROR the size for values of type `Opaque` cannot be known
+//~^ ERROR `extern type` does not have known layout
 
 fn main() {}
diff --git a/tests/ui/consts/const-size_of_val-align_of_val-extern-type.stderr b/tests/ui/consts/const-size_of_val-align_of_val-extern-type.stderr
index 825b9e94158..23f7aaf538e 100644
--- a/tests/ui/consts/const-size_of_val-align_of_val-extern-type.stderr
+++ b/tests/ui/consts/const-size_of_val-align_of_val-extern-type.stderr
@@ -1,39 +1,15 @@
-error[E0277]: the size for values of type `Opaque` cannot be known
-  --> $DIR/const-size_of_val-align_of_val-extern-type.rs:10:43
+error[E0080]: `extern type` does not have known layout
+  --> $DIR/const-size_of_val-align_of_val-extern-type.rs:10:31
    |
 LL | const _SIZE: usize = unsafe { size_of_val(&4 as *const i32 as *const Opaque) };
-   |                               ----------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `MetaSized` is not implemented for `Opaque`
-   |                               |
-   |                               required by a bound introduced by this call
-   |
-   = note: the trait bound `Opaque: MetaSized` is not satisfied
-note: required by a bound in `std::intrinsics::size_of_val`
-  --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
-help: consider borrowing here
-   |
-LL | const _SIZE: usize = unsafe { size_of_val(&(&4 as *const i32 as *const Opaque)) };
-   |                                           ++                                 +
-LL | const _SIZE: usize = unsafe { size_of_val(&mut (&4 as *const i32 as *const Opaque)) };
-   |                                           ++++++                                 +
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `_SIZE` failed here
 
-error[E0277]: the size for values of type `Opaque` cannot be known
-  --> $DIR/const-size_of_val-align_of_val-extern-type.rs:12:45
+error[E0080]: `extern type` does not have known layout
+  --> $DIR/const-size_of_val-align_of_val-extern-type.rs:12:32
    |
 LL | const _ALIGN: usize = unsafe { align_of_val(&4 as *const i32 as *const Opaque) };
-   |                                ------------ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `MetaSized` is not implemented for `Opaque`
-   |                                |
-   |                                required by a bound introduced by this call
-   |
-   = note: the trait bound `Opaque: MetaSized` is not satisfied
-note: required by a bound in `std::intrinsics::align_of_val`
-  --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
-help: consider borrowing here
-   |
-LL | const _ALIGN: usize = unsafe { align_of_val(&(&4 as *const i32 as *const Opaque)) };
-   |                                             ++                                 +
-LL | const _ALIGN: usize = unsafe { align_of_val(&mut (&4 as *const i32 as *const Opaque)) };
-   |                                             ++++++                                 +
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `_ALIGN` failed here
 
 error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/extern/extern-types-size_of_val.rs b/tests/ui/extern/extern-types-size_of_val.rs
index 3ff51b9b6b0..875ae9a535a 100644
--- a/tests/ui/extern/extern-types-size_of_val.rs
+++ b/tests/ui/extern/extern-types-size_of_val.rs
@@ -1,4 +1,4 @@
-//@ check-fail
+//@ check-pass
 #![feature(extern_types)]
 
 use std::mem::{align_of_val, size_of_val};
@@ -11,7 +11,5 @@ fn main() {
     let x: &A = unsafe { &*(1usize as *const A) };
 
     size_of_val(x);
-    //~^ ERROR the size for values of type `A` cannot be known
     align_of_val(x);
-    //~^ ERROR the size for values of type `A` cannot be known
 }
diff --git a/tests/ui/extern/extern-types-size_of_val.stderr b/tests/ui/extern/extern-types-size_of_val.stderr
deleted file mode 100644
index 8678c6c3d60..00000000000
--- a/tests/ui/extern/extern-types-size_of_val.stderr
+++ /dev/null
@@ -1,39 +0,0 @@
-error[E0277]: the size for values of type `A` cannot be known
-  --> $DIR/extern-types-size_of_val.rs:13:17
-   |
-LL |     size_of_val(x);
-   |     ----------- ^ the trait `MetaSized` is not implemented for `A`
-   |     |
-   |     required by a bound introduced by this call
-   |
-   = note: the trait bound `A: MetaSized` is not satisfied
-note: required by a bound in `std::mem::size_of_val`
-  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-help: consider borrowing here
-   |
-LL |     size_of_val(&x);
-   |                 +
-LL |     size_of_val(&mut x);
-   |                 ++++
-
-error[E0277]: the size for values of type `A` cannot be known
-  --> $DIR/extern-types-size_of_val.rs:15:18
-   |
-LL |     align_of_val(x);
-   |     ------------ ^ the trait `MetaSized` is not implemented for `A`
-   |     |
-   |     required by a bound introduced by this call
-   |
-   = note: the trait bound `A: MetaSized` is not satisfied
-note: required by a bound in `std::mem::align_of_val`
-  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-help: consider borrowing here
-   |
-LL |     align_of_val(&x);
-   |                  +
-LL |     align_of_val(&mut x);
-   |                  ++++
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/extern/extern-types-unsized.rs b/tests/ui/extern/extern-types-unsized.rs
index 46cdc24e083..94a222a7e7e 100644
--- a/tests/ui/extern/extern-types-unsized.rs
+++ b/tests/ui/extern/extern-types-unsized.rs
@@ -27,9 +27,7 @@ fn main() {
 
     assert_sized::<Bar<A>>();
     //~^ ERROR the size for values of type
-    //~| ERROR the size for values of type
 
     assert_sized::<Bar<Bar<A>>>();
     //~^ ERROR the size for values of type
-    //~| ERROR the size for values of type
 }
diff --git a/tests/ui/extern/extern-types-unsized.stderr b/tests/ui/extern/extern-types-unsized.stderr
index 43dd9800d6d..a587d4dda55 100644
--- a/tests/ui/extern/extern-types-unsized.stderr
+++ b/tests/ui/extern/extern-types-unsized.stderr
@@ -59,21 +59,8 @@ help: consider relaxing the implicit `Sized` restriction
 LL | fn assert_sized<T: ?Sized>() {}
    |                  ++++++++
 
-error[E0277]: the size for values of type `A` cannot be known
-  --> $DIR/extern-types-unsized.rs:28:20
-   |
-LL |     assert_sized::<Bar<A>>();
-   |                    ^^^^^^ doesn't have a known size
-   |
-   = help: the trait `MetaSized` is not implemented for `A`
-note: required by a bound in `Bar`
-  --> $DIR/extern-types-unsized.rs:14:12
-   |
-LL | struct Bar<T: ?Sized> {
-   |            ^ required by this bound in `Bar`
-
 error[E0277]: the size for values of type `A` cannot be known at compilation time
-  --> $DIR/extern-types-unsized.rs:32:20
+  --> $DIR/extern-types-unsized.rs:31:20
    |
 LL |     assert_sized::<Bar<Bar<A>>>();
    |                    ^^^^^^^^^^^ doesn't have a size known at compile-time
@@ -94,19 +81,6 @@ help: consider relaxing the implicit `Sized` restriction
 LL | fn assert_sized<T: ?Sized>() {}
    |                  ++++++++
 
-error[E0277]: the size for values of type `A` cannot be known
-  --> $DIR/extern-types-unsized.rs:32:20
-   |
-LL |     assert_sized::<Bar<Bar<A>>>();
-   |                    ^^^^^^^^^^^ doesn't have a known size
-   |
-   = help: the trait `MetaSized` is not implemented for `A`
-note: required by a bound in `Bar`
-  --> $DIR/extern-types-unsized.rs:14:12
-   |
-LL | struct Bar<T: ?Sized> {
-   |            ^ required by this bound in `Bar`
-
-error: aborting due to 6 previous errors
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/extern/unsized-extern-derefmove.rs b/tests/ui/extern/unsized-extern-derefmove.rs
index c02375266ab..39597a12fe1 100644
--- a/tests/ui/extern/unsized-extern-derefmove.rs
+++ b/tests/ui/extern/unsized-extern-derefmove.rs
@@ -7,14 +7,10 @@ extern "C" {
 }
 
 unsafe fn make_device() -> Box<Device> {
-//~^ ERROR the size for values of type `Device` cannot be known
     Box::from_raw(0 as *mut _)
-//~^ ERROR the size for values of type `Device` cannot be known
-//~| ERROR the size for values of type `Device` cannot be known
 }
 
 fn main() {
     let d: Device = unsafe { *make_device() };
 //~^ ERROR the size for values of type `Device` cannot be known
-//~| ERROR the size for values of type `Device` cannot be known
 }
diff --git a/tests/ui/extern/unsized-extern-derefmove.stderr b/tests/ui/extern/unsized-extern-derefmove.stderr
index a9efc2e66e3..c43184d94e1 100644
--- a/tests/ui/extern/unsized-extern-derefmove.stderr
+++ b/tests/ui/extern/unsized-extern-derefmove.stderr
@@ -1,43 +1,5 @@
-error[E0277]: the size for values of type `Device` cannot be known
-  --> $DIR/unsized-extern-derefmove.rs:9:28
-   |
-LL | unsafe fn make_device() -> Box<Device> {
-   |                            ^^^^^^^^^^^ doesn't have a known size
-   |
-   = help: the trait `MetaSized` is not implemented for `Device`
-note: required by a bound in `Box`
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
-
-error[E0277]: the size for values of type `Device` cannot be known
-  --> $DIR/unsized-extern-derefmove.rs:11:19
-   |
-LL |     Box::from_raw(0 as *mut _)
-   |     ------------- ^^^^^^^^^^^ the trait `MetaSized` is not implemented for `Device`
-   |     |
-   |     required by a bound introduced by this call
-   |
-   = note: the trait bound `Device: MetaSized` is not satisfied
-note: required by a bound in `Box::<T>::from_raw`
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
-help: consider borrowing here
-   |
-LL |     Box::from_raw(&(0 as *mut _))
-   |                   ++           +
-LL |     Box::from_raw(&mut (0 as *mut _))
-   |                   ++++++           +
-
-error[E0277]: the size for values of type `Device` cannot be known
-  --> $DIR/unsized-extern-derefmove.rs:11:5
-   |
-LL |     Box::from_raw(0 as *mut _)
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a known size
-   |
-   = help: the trait `MetaSized` is not implemented for `Device`
-note: required by a bound in `Box`
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
-
 error[E0277]: the size for values of type `Device` cannot be known at compilation time
-  --> $DIR/unsized-extern-derefmove.rs:17:9
+  --> $DIR/unsized-extern-derefmove.rs:14:9
    |
 LL |     let d: Device = unsafe { *make_device() };
    |         ^ doesn't have a size known at compile-time
@@ -49,16 +11,6 @@ help: consider borrowing here
 LL |     let d: &Device = unsafe { *make_device() };
    |            +
 
-error[E0277]: the size for values of type `Device` cannot be known
-  --> $DIR/unsized-extern-derefmove.rs:17:31
-   |
-LL |     let d: Device = unsafe { *make_device() };
-   |                               ^^^^^^^^^^^^^ doesn't have a known size
-   |
-   = help: the trait `MetaSized` is not implemented for `Device`
-note: required by a bound in `Box`
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
-
-error: aborting due to 5 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/layout/unconstrained-param-ice-137308.rs b/tests/ui/layout/unconstrained-param-ice-137308.rs
index 03b7e759960..d05e6e1fd3f 100644
--- a/tests/ui/layout/unconstrained-param-ice-137308.rs
+++ b/tests/ui/layout/unconstrained-param-ice-137308.rs
@@ -17,4 +17,3 @@ impl<C: ?Sized> A for u8 { //~ ERROR: the type parameter `C` is not constrained
 #[rustc_layout(debug)]
 struct S([u8; <u8 as A>::B]);
 //~^ ERROR: the type has an unknown layout
-//~| ERROR: type annotations needed
diff --git a/tests/ui/layout/unconstrained-param-ice-137308.stderr b/tests/ui/layout/unconstrained-param-ice-137308.stderr
index 82cd1217c49..615c131eb90 100644
--- a/tests/ui/layout/unconstrained-param-ice-137308.stderr
+++ b/tests/ui/layout/unconstrained-param-ice-137308.stderr
@@ -4,19 +4,12 @@ error[E0207]: the type parameter `C` is not constrained by the impl trait, self
 LL | impl<C: ?Sized> A for u8 {
    |      ^ unconstrained type parameter
 
-error[E0282]: type annotations needed
-  --> $DIR/unconstrained-param-ice-137308.rs:18:16
-   |
-LL | struct S([u8; <u8 as A>::B]);
-   |                ^^ cannot infer type for type parameter `C`
-
 error: the type has an unknown layout
   --> $DIR/unconstrained-param-ice-137308.rs:18:1
    |
 LL | struct S([u8; <u8 as A>::B]);
    | ^^^^^^^^
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0207, E0282.
-For more information about an error, try `rustc --explain E0207`.
+For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/nll/issue-50716.rs b/tests/ui/nll/issue-50716.rs
index 76c6fc5e7b9..96168ebeaa1 100644
--- a/tests/ui/nll/issue-50716.rs
+++ b/tests/ui/nll/issue-50716.rs
@@ -5,7 +5,7 @@ trait A {
     type X: ?Sized;
 }
 
-fn foo<'a, T: 'static>(s: Box<<&'a T as A>::X>) //~ ERROR
+fn foo<'a, T: 'static>(s: Box<<&'a T as A>::X>)
 where
     for<'b> &'b T: A,
     <&'static T as A>::X: Sized
diff --git a/tests/ui/nll/issue-50716.stderr b/tests/ui/nll/issue-50716.stderr
index edd7fd765da..536f88085de 100644
--- a/tests/ui/nll/issue-50716.stderr
+++ b/tests/ui/nll/issue-50716.stderr
@@ -1,18 +1,3 @@
-error[E0308]: mismatched types
-  --> $DIR/issue-50716.rs:8:27
-   |
-LL | fn foo<'a, T: 'static>(s: Box<<&'a T as A>::X>)
-   |                           ^^^^^^^^^^^^^^^^^^^^ lifetime mismatch
-   |
-   = note: expected trait `<<&'a T as A>::X as MetaSized>`
-              found trait `<<&'static T as A>::X as MetaSized>`
-note: the lifetime `'a` as defined here...
-  --> $DIR/issue-50716.rs:8:8
-   |
-LL | fn foo<'a, T: 'static>(s: Box<<&'a T as A>::X>)
-   |        ^^
-   = note: ...does not necessarily outlive the static lifetime
-
 error: lifetime may not live long enough
   --> $DIR/issue-50716.rs:13:14
    |
@@ -22,6 +7,5 @@ LL | fn foo<'a, T: 'static>(s: Box<<&'a T as A>::X>)
 LL |     let _x = *s;
    |              ^^ proving this value is `Sized` requires that `'a` must outlive `'static`
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next.stderr b/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next.stderr
new file mode 100644
index 00000000000..cf56f42afc8
--- /dev/null
+++ b/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next.stderr
@@ -0,0 +1,17 @@
+error[E0308]: mismatched types
+  --> $DIR/incomplete-inference-issue-143992.rs:27:28
+   |
+LL |     let _x = T::Assoc::new(());
+   |              ------------- ^^ expected `[u32; 1]`, found `()`
+   |              |
+   |              arguments to this function are incorrect
+   |
+note: associated function defined here
+  --> $DIR/incomplete-inference-issue-143992.rs:18:8
+   |
+LL |     fn new(r: R) -> R {
+   |        ^^^ ----
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.rs b/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.rs
new file mode 100644
index 00000000000..3e3e1dc50e5
--- /dev/null
+++ b/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.rs
@@ -0,0 +1,29 @@
+//@ compile-flags: --crate-type=lib
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[current] check-pass
+//@[next] compile-flags: -Znext-solver
+//@[next] check-fail
+
+// Test that we avoid incomplete inference when normalizing. Without this,
+// `Trait`'s implicit `MetaSized` supertrait requires proving `T::Assoc<_>: MetaSized`
+// before checking the `new` arguments, resulting in eagerly constraining the inference
+// var to `u32`. This is undesirable and would breaking code.
+
+pub trait Trait {
+    type Assoc<G>: OtherTrait<G>;
+}
+
+pub trait OtherTrait<R> {
+    fn new(r: R) -> R {
+        r
+    }
+}
+
+pub fn function<T: Trait>()
+where
+    T::Assoc<[u32; 1]>: Clone,
+{
+    let _x = T::Assoc::new(());
+//[next]~^ ERROR mismatched types
+}
diff --git a/tests/ui/sized-hierarchy/overflow.current.stderr b/tests/ui/sized-hierarchy/overflow.current.stderr
deleted file mode 100644
index e90548aa78c..00000000000
--- a/tests/ui/sized-hierarchy/overflow.current.stderr
+++ /dev/null
@@ -1,45 +0,0 @@
-error[E0275]: overflow evaluating the requirement `Element: MetaSized`
-  --> $DIR/overflow.rs:16:16
-   |
-LL | struct Element(<Box<Box<Element>> as ParseTokens>::Output);
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: required for `Box<Element>` to implement `ParseTokens`
-  --> $DIR/overflow.rs:12:31
-   |
-LL | impl<T: ParseTokens + ?Sized> ParseTokens for Box<T> {
-   |      -                        ^^^^^^^^^^^     ^^^^^^
-   |      |
-   |      unsatisfied trait bound introduced here
-   = note: 1 redundant requirement hidden
-   = note: required for `Box<Box<Element>>` to implement `ParseTokens`
-
-error[E0275]: overflow evaluating the requirement `Box<Element>: ParseTokens`
-  --> $DIR/overflow.rs:18:22
-   |
-LL | impl ParseTokens for Element {
-   |                      ^^^^^^^
-   |
-note: required for `Box<Box<Element>>` to implement `ParseTokens`
-  --> $DIR/overflow.rs:12:31
-   |
-LL | impl<T: ParseTokens + ?Sized> ParseTokens for Box<T> {
-   |         -----------           ^^^^^^^^^^^     ^^^^^^
-   |         |
-   |         unsatisfied trait bound introduced here
-note: required because it appears within the type `Element`
-  --> $DIR/overflow.rs:16:8
-   |
-LL | struct Element(<Box<Box<Element>> as ParseTokens>::Output);
-   |        ^^^^^^^
-note: required by a bound in `ParseTokens`
-  --> $DIR/overflow.rs:9:1
-   |
-LL | / trait ParseTokens {
-LL | |     type Output;
-LL | | }
-   | |_^ required by this bound in `ParseTokens`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/sized-hierarchy/overflow.rs b/tests/ui/sized-hierarchy/overflow.rs
index e1af4885e53..f8e5dd5d402 100644
--- a/tests/ui/sized-hierarchy/overflow.rs
+++ b/tests/ui/sized-hierarchy/overflow.rs
@@ -1,9 +1,13 @@
 //@ compile-flags: --crate-type=lib
 //@ revisions: current next
 //@ ignore-compare-mode-next-solver (explicit revisions)
+//@[current] check-pass
 //@[next] check-pass
 //@[next] compile-flags: -Znext-solver
 
+// FIXME(sized_hierarchy): this is expected to fail in the old solver when there
+// isn't a temporary revert of the `sized_hierarchy` feature
+
 use std::marker::PhantomData;
 
 trait ParseTokens {
@@ -14,8 +18,6 @@ impl<T: ParseTokens + ?Sized> ParseTokens for Box<T> {
 }
 
 struct Element(<Box<Box<Element>> as ParseTokens>::Output);
-//[current]~^ ERROR overflow evaluating
 impl ParseTokens for Element {
-//[current]~^ ERROR overflow evaluating
     type Output = ();
 }
diff --git a/tests/ui/traits/resolve-impl-before-constrain-check.rs b/tests/ui/traits/resolve-impl-before-constrain-check.rs
index 50d1a874551..87f9c241e40 100644
--- a/tests/ui/traits/resolve-impl-before-constrain-check.rs
+++ b/tests/ui/traits/resolve-impl-before-constrain-check.rs
@@ -15,7 +15,6 @@ use foo::*;
 
 fn test() -> impl Sized {
     <() as Callable>::call()
-//~^ ERROR: type annotations needed
 }
 
 fn main() {}
diff --git a/tests/ui/traits/resolve-impl-before-constrain-check.stderr b/tests/ui/traits/resolve-impl-before-constrain-check.stderr
index 13fbfdb855c..e8e569ba625 100644
--- a/tests/ui/traits/resolve-impl-before-constrain-check.stderr
+++ b/tests/ui/traits/resolve-impl-before-constrain-check.stderr
@@ -4,13 +4,6 @@ error[E0207]: the type parameter `V` is not constrained by the impl trait, self
 LL |     impl<V: ?Sized> Callable for () {
    |          ^ unconstrained type parameter
 
-error[E0282]: type annotations needed
-  --> $DIR/resolve-impl-before-constrain-check.rs:17:6
-   |
-LL |     <() as Callable>::call()
-   |      ^^ cannot infer type for type parameter `V`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0207, E0282.
-For more information about an error, try `rustc --explain E0207`.
+For more information about this error, try `rustc --explain E0207`.
-- 
cgit 1.4.1-3-g733a5


From 83fbcabd92dd62198a1275d0d5cf7925150d1d6a Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Wed, 16 Jul 2025 08:44:15 -0400
Subject: Fix warnings in tests

---
 tests/run/asm.rs       |  1 +
 tests/run/float.rs     | 16 +++++++---------
 tests/run/int.rs       |  2 --
 tests/run/volatile.rs  |  3 ++-
 tests/run/volatile2.rs |  6 ++----
 5 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/tests/run/asm.rs b/tests/run/asm.rs
index 2dbf43be664..9b15a28d829 100644
--- a/tests/run/asm.rs
+++ b/tests/run/asm.rs
@@ -16,6 +16,7 @@ add_asm:
      ret"
 );
 
+#[cfg(target_arch = "x86_64")]
 extern "C" {
     fn add_asm(a: i64, b: i64) -> i64;
 }
diff --git a/tests/run/float.rs b/tests/run/float.rs
index 424fa1cf4ad..df555f383fe 100644
--- a/tests/run/float.rs
+++ b/tests/run/float.rs
@@ -3,8 +3,6 @@
 // Run-time:
 //   status: 0
 
-#![feature(const_black_box)]
-
 fn main() {
     use std::hint::black_box;
 
@@ -15,14 +13,14 @@ fn main() {
         }};
     }
 
-    check!(i32, (black_box(0.0f32) as i32));
+    check!(i32, black_box(0.0f32) as i32);
 
-    check!(u64, (black_box(f32::NAN) as u64));
-    check!(u128, (black_box(f32::NAN) as u128));
+    check!(u64, black_box(f32::NAN) as u64);
+    check!(u128, black_box(f32::NAN) as u128);
 
-    check!(i64, (black_box(f64::NAN) as i64));
-    check!(u64, (black_box(f64::NAN) as u64));
+    check!(i64, black_box(f64::NAN) as i64);
+    check!(u64, black_box(f64::NAN) as u64);
 
-    check!(i16, (black_box(f32::MIN) as i16));
-    check!(i16, (black_box(f32::MAX) as i16));
+    check!(i16, black_box(f32::MIN) as i16);
+    check!(i16, black_box(f32::MAX) as i16);
 }
diff --git a/tests/run/int.rs b/tests/run/int.rs
index 47b5dea46f8..e20ecc23679 100644
--- a/tests/run/int.rs
+++ b/tests/run/int.rs
@@ -3,8 +3,6 @@
 // Run-time:
 //   status: 0
 
-#![feature(const_black_box)]
-
 fn main() {
     use std::hint::black_box;
 
diff --git a/tests/run/volatile.rs b/tests/run/volatile.rs
index 8b043312593..94a7bdc5c06 100644
--- a/tests/run/volatile.rs
+++ b/tests/run/volatile.rs
@@ -5,13 +5,14 @@
 
 use std::mem::MaybeUninit;
 
+#[allow(dead_code)]
 #[derive(Debug)]
 struct Struct {
     pointer: *const (),
     func: unsafe fn(*const ()),
 }
 
-fn func(ptr: *const ()) {
+fn func(_ptr: *const ()) {
 }
 
 fn main() {
diff --git a/tests/run/volatile2.rs b/tests/run/volatile2.rs
index a177b817ab3..bdcb8259878 100644
--- a/tests/run/volatile2.rs
+++ b/tests/run/volatile2.rs
@@ -6,8 +6,6 @@
 mod libc {
     #[link(name = "c")]
     extern "C" {
-        pub fn puts(s: *const u8) -> i32;
-
         pub fn sigaction(signum: i32, act: *const sigaction, oldact: *mut sigaction) -> i32;
         pub fn mmap(addr: *mut (), len: usize, prot: i32, flags: i32, fd: i32, offset: i64) -> *mut ();
         pub fn mprotect(addr: *mut (), len: usize, prot: i32) -> i32;
@@ -61,7 +59,7 @@ fn main() {
             panic!("error: mmap failed");
         }
 
-        let p_count = (&mut COUNT) as *mut u32;
+        let p_count = (&raw mut COUNT) as *mut u32;
         p_count.write_volatile(0);
 
         // Trigger segfaults
@@ -94,7 +92,7 @@ fn main() {
 }
 
 unsafe extern "C" fn segv_handler(_: i32, _: *mut (), _: *mut ()) {
-    let p_count = (&mut COUNT) as *mut u32;
+    let p_count = (&raw mut COUNT) as *mut u32;
     p_count.write_volatile(p_count.read_volatile() + 1);
     let count = p_count.read_volatile();
 
-- 
cgit 1.4.1-3-g733a5


From f2b8fda3a696615671d7a4cc534c080fffd3a790 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Wed, 16 Jul 2025 21:27:39 +0800
Subject: Add AsMut to minicore prelude::v1

---
 src/tools/rust-analyzer/crates/test-utils/src/minicore.rs | 1 +
 1 file changed, 1 insertion(+)

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 dc1eba1a1ab..2b522598e2d 100644
--- a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
+++ b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
@@ -1941,6 +1941,7 @@ pub mod prelude {
             clone::Clone,                            // :clone
             cmp::{Eq, PartialEq},                    // :eq
             cmp::{Ord, PartialOrd},                  // :ord
+            convert::AsMut,                          // :as_mut
             convert::AsRef,                          // :as_ref
             convert::{From, Into, TryFrom, TryInto}, // :from
             default::Default,                        // :default
-- 
cgit 1.4.1-3-g733a5


From 8f854d9cb2d108a2d4f980ccb4d5909e214e6ef0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 16 Jul 2025 15:11:11 +0200
Subject: const heap: fix ICE on forgotten make_global

---
 .../src/const_eval/eval_queries.rs                 | 11 +++-
 compiler/rustc_const_eval/src/interpret/intern.rs  | 74 ++++++++++------------
 compiler/rustc_const_eval/src/interpret/mod.rs     |  2 +-
 .../rustc_const_eval/src/interpret/validity.rs     | 10 ++-
 tests/crashes/const_mut_ref_check_bypass.rs        | 11 ----
 .../const-eval/heap/ptr_not_made_global_mut.rs     |  9 ++-
 .../const-eval/heap/ptr_not_made_global_mut.stderr |  8 +--
 7 files changed, 58 insertions(+), 67 deletions(-)
 delete mode 100644 tests/crashes/const_mut_ref_check_bypass.rs

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 32209ff4367..ce72d59b8b0 100644
--- a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -18,7 +18,7 @@ use tracing::{debug, instrument, trace};
 use super::{CanAccessMutGlobal, CompileTimeInterpCx, CompileTimeMachine};
 use crate::const_eval::CheckAlignment;
 use crate::interpret::{
-    CtfeValidationMode, GlobalId, Immediate, InternKind, InternResult, InterpCx, InterpErrorKind,
+    CtfeValidationMode, GlobalId, Immediate, InternError, InternKind, InterpCx, InterpErrorKind,
     InterpResult, MPlaceTy, MemoryKind, OpTy, RefTracking, ReturnContinuation, create_static_alloc,
     intern_const_alloc_recursive, interp_ok, throw_exhaust,
 };
@@ -98,20 +98,25 @@ fn eval_body_using_ecx<'tcx, R: InterpretationResult<'tcx>>(
 
     match intern_result {
         Ok(()) => {}
-        Err(InternResult::FoundDanglingPointer) => {
+        Err(InternError::DanglingPointer) => {
             throw_inval!(AlreadyReported(ReportedErrorInfo::non_const_eval_error(
                 ecx.tcx
                     .dcx()
                     .emit_err(errors::DanglingPtrInFinal { span: ecx.tcx.span, kind: intern_kind }),
             )));
         }
-        Err(InternResult::FoundBadMutablePointer) => {
+        Err(InternError::BadMutablePointer) => {
             throw_inval!(AlreadyReported(ReportedErrorInfo::non_const_eval_error(
                 ecx.tcx
                     .dcx()
                     .emit_err(errors::MutablePtrInFinal { span: ecx.tcx.span, kind: intern_kind }),
             )));
         }
+        Err(InternError::ConstAllocNotGlobal) => {
+            throw_inval!(AlreadyReported(ReportedErrorInfo::non_const_eval_error(
+                ecx.tcx.dcx().emit_err(errors::ConstHeapPtrInFinal { span: ecx.tcx.span }),
+            )));
+        }
     }
 
     interp_ok(R::make_result(ret, ecx))
diff --git a/compiler/rustc_const_eval/src/interpret/intern.rs b/compiler/rustc_const_eval/src/interpret/intern.rs
index b8fcdc9b7ef..f25bb222bcf 100644
--- a/compiler/rustc_const_eval/src/interpret/intern.rs
+++ b/compiler/rustc_const_eval/src/interpret/intern.rs
@@ -26,12 +26,9 @@ use rustc_middle::ty::layout::TyAndLayout;
 use rustc_span::def_id::LocalDefId;
 use tracing::{instrument, trace};
 
-use super::{
-    AllocId, Allocation, InterpCx, MPlaceTy, Machine, MemoryKind, PlaceTy, err_ub, interp_ok,
-};
-use crate::const_eval;
+use super::{AllocId, Allocation, InterpCx, MPlaceTy, Machine, MemoryKind, PlaceTy, interp_ok};
 use crate::const_eval::DummyMachine;
-use crate::errors::{ConstHeapPtrInFinal, NestedStaticInThreadLocal};
+use crate::{const_eval, errors};
 
 pub trait CompileTimeMachine<'tcx, T> = Machine<
         'tcx,
@@ -63,7 +60,7 @@ pub enum DisallowInternReason {
 ///
 /// This prevents us from interning `const_allocate` pointers that have not been made
 /// global through `const_make_global`.
-pub trait CanIntern {
+pub trait CanIntern: Copy {
     fn disallows_intern(&self) -> Option<DisallowInternReason>;
 }
 
@@ -96,24 +93,22 @@ fn intern_shallow<'tcx, T: CanIntern, M: CompileTimeMachine<'tcx, T>>(
     alloc_id: AllocId,
     mutability: Mutability,
     disambiguator: Option<&mut DisambiguatorState>,
-) -> Result<impl Iterator<Item = CtfeProvenance> + 'tcx, ()> {
+) -> Result<impl Iterator<Item = CtfeProvenance> + 'tcx, InternError> {
     trace!("intern_shallow {:?}", alloc_id);
     // remove allocation
     // FIXME(#120456) - is `swap_remove` correct?
     let Some((kind, mut alloc)) = ecx.memory.alloc_map.swap_remove(&alloc_id) else {
-        return Err(());
+        return Err(InternError::DanglingPointer);
     };
 
     match kind {
         MemoryKind::Machine(x) if let Some(reason) = x.disallows_intern() => match reason {
-            // Attempting to intern a `const_allocate`d pointer that was not made global via
-            // `const_make_global`. This is an error, but if we return `Err` now, things
-            // become inconsistent because we already removed the allocation from `alloc_map`.
-            // So instead we just emit an error and then continue interning as usual.
-            // We *could* do this check before removing the allocation from `alloc_map`, but then
-            // it would be much harder to ensure that we only error once for each allocation.
             DisallowInternReason::ConstHeap => {
-                ecx.tcx.dcx().emit_err(ConstHeapPtrInFinal { span: ecx.tcx.span });
+                // Attempting to intern a `const_allocate`d pointer that was not made global via
+                // `const_make_global`. We want to error here, but we have to first put the
+                // allocation back into the `alloc_map` to keep things in a consistent state.
+                ecx.memory.alloc_map.insert(alloc_id, (kind, alloc));
+                return Err(InternError::ConstAllocNotGlobal);
             }
         },
         MemoryKind::Machine(_) | MemoryKind::Stack | MemoryKind::CallerLocation => {}
@@ -170,7 +165,7 @@ fn intern_as_new_static<'tcx>(
     tcx.set_nested_alloc_id_static(alloc_id, feed.def_id());
 
     if tcx.is_thread_local_static(static_id.into()) {
-        tcx.dcx().emit_err(NestedStaticInThreadLocal { span: tcx.def_span(static_id) });
+        tcx.dcx().emit_err(errors::NestedStaticInThreadLocal { span: tcx.def_span(static_id) });
     }
 
     // These do not inherit the codegen attrs of the parent static allocation, since
@@ -196,9 +191,10 @@ pub enum InternKind {
 }
 
 #[derive(Debug)]
-pub enum InternResult {
-    FoundBadMutablePointer,
-    FoundDanglingPointer,
+pub enum InternError {
+    BadMutablePointer,
+    DanglingPointer,
+    ConstAllocNotGlobal,
 }
 
 /// Intern `ret` and everything it references.
@@ -212,7 +208,7 @@ pub fn intern_const_alloc_recursive<'tcx, M: CompileTimeMachine<'tcx, const_eval
     ecx: &mut InterpCx<'tcx, M>,
     intern_kind: InternKind,
     ret: &MPlaceTy<'tcx>,
-) -> Result<(), InternResult> {
+) -> Result<(), InternError> {
     let mut disambiguator = DisambiguatorState::new();
 
     // We are interning recursively, and for mutability we are distinguishing the "root" allocation
@@ -269,6 +265,7 @@ pub fn intern_const_alloc_recursive<'tcx, M: CompileTimeMachine<'tcx, const_eval
     // We want to first report "dangling" and then "mutable", so we need to delay reporting these
     // errors.
     let mut result = Ok(());
+    let mut found_bad_mutable_ptr = false;
 
     // Keep interning as long as there are things to intern.
     // We show errors if there are dangling pointers, or mutable pointers in immutable contexts
@@ -323,18 +320,7 @@ pub fn intern_const_alloc_recursive<'tcx, M: CompileTimeMachine<'tcx, const_eval
             // when there is memory there that someone might expect to be mutable, but we make it immutable.
             let dangling = !is_already_global && !ecx.memory.alloc_map.contains_key(&alloc_id);
             if !dangling {
-                // Found a mutable pointer inside a const where inner allocations should be
-                // immutable.
-                if !ecx.tcx.sess.opts.unstable_opts.unleash_the_miri_inside_of_you {
-                    span_bug!(
-                        ecx.tcx.span,
-                        "the static const safety checks accepted a mutable pointer they should not have accepted"
-                    );
-                }
-                // Prefer dangling pointer errors over mutable pointer errors
-                if result.is_ok() {
-                    result = Err(InternResult::FoundBadMutablePointer);
-                }
+                found_bad_mutable_ptr = true;
             }
         }
         if ecx.tcx.try_get_global_alloc(alloc_id).is_some() {
@@ -355,12 +341,25 @@ pub fn intern_const_alloc_recursive<'tcx, M: CompileTimeMachine<'tcx, const_eval
         just_interned.insert(alloc_id);
         match intern_shallow(ecx, alloc_id, inner_mutability, Some(&mut disambiguator)) {
             Ok(nested) => todo.extend(nested),
-            Err(()) => {
-                ecx.tcx.dcx().delayed_bug("found dangling pointer during const interning");
-                result = Err(InternResult::FoundDanglingPointer);
+            Err(err) => {
+                ecx.tcx.dcx().delayed_bug("error during const interning");
+                result = Err(err);
             }
         }
     }
+    if found_bad_mutable_ptr && result.is_ok() {
+        // We found a mutable pointer inside a const where inner allocations should be immutable,
+        // and there was no other error. This should usually never happen! However, this can happen
+        // in unleash-miri mode, so report it as a normal error then.
+        if ecx.tcx.sess.opts.unstable_opts.unleash_the_miri_inside_of_you {
+            result = Err(InternError::BadMutablePointer);
+        } else {
+            span_bug!(
+                ecx.tcx.span,
+                "the static const safety checks accepted a mutable pointer they should not have accepted"
+            );
+        }
+    }
     result
 }
 
@@ -375,10 +374,7 @@ pub fn intern_const_alloc_for_constprop<'tcx, T: CanIntern, M: CompileTimeMachin
         return interp_ok(());
     }
     // Move allocation to `tcx`.
-    if let Some(_) = intern_shallow(ecx, alloc_id, Mutability::Not, None)
-        .map_err(|()| err_ub!(DeadLocal))?
-        .next()
-    {
+    if let Some(_) = intern_shallow(ecx, alloc_id, Mutability::Not, None).unwrap().next() {
         // We are not doing recursive interning, so we don't currently support provenance.
         // (If this assertion ever triggers, we should just implement a
         // proper recursive interning loop -- or just call `intern_const_alloc_recursive`.
diff --git a/compiler/rustc_const_eval/src/interpret/mod.rs b/compiler/rustc_const_eval/src/interpret/mod.rs
index 2fc372dd019..2f365ec77b3 100644
--- a/compiler/rustc_const_eval/src/interpret/mod.rs
+++ b/compiler/rustc_const_eval/src/interpret/mod.rs
@@ -26,7 +26,7 @@ pub use self::call::FnArg;
 pub use self::eval_context::{InterpCx, format_interp_error};
 use self::eval_context::{from_known_layout, mir_assign_valid_types};
 pub use self::intern::{
-    HasStaticRootDefId, InternKind, InternResult, intern_const_alloc_for_constprop,
+    HasStaticRootDefId, InternError, InternKind, intern_const_alloc_for_constprop,
     intern_const_alloc_recursive,
 };
 pub use self::machine::{AllocMap, Machine, MayLeak, ReturnAction, compile_time_machine};
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index fc44490c96d..62f591ceaa9 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -558,7 +558,15 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
                 {
                     // Everything should be already interned.
                     let Some(global_alloc) = self.ecx.tcx.try_get_global_alloc(alloc_id) else {
-                        assert!(self.ecx.memory.alloc_map.get(alloc_id).is_none());
+                        if self.ecx.memory.alloc_map.contains_key(&alloc_id) {
+                            // This can happen when interning didn't complete due to, e.g.
+                            // missing `make_global`. This must mean other errors are already
+                            // being reported.
+                            self.ecx.tcx.dcx().delayed_bug(
+                                "interning did not complete, there should be an error",
+                            );
+                            return interp_ok(());
+                        }
                         // We can't have *any* references to non-existing allocations in const-eval
                         // as the rest of rustc isn't happy with them... so we throw an error, even
                         // though for zero-sized references this isn't really UB.
diff --git a/tests/crashes/const_mut_ref_check_bypass.rs b/tests/crashes/const_mut_ref_check_bypass.rs
deleted file mode 100644
index 6234536c72b..00000000000
--- a/tests/crashes/const_mut_ref_check_bypass.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Version of `tests/ui/consts/const-eval/heap/alloc_intrinsic_untyped.rs` without the flag that
-// suppresses the ICE.
-//@ known-bug: #129233
-#![feature(core_intrinsics)]
-#![feature(const_heap)]
-#![feature(const_mut_refs)]
-use std::intrinsics;
-
-const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
-
-fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.rs b/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.rs
index 201fa715022..e44a3f7a23c 100644
--- a/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.rs
+++ b/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.rs
@@ -1,12 +1,11 @@
-// We unleash Miri here since this test demonstrates code that bypasses the checks against interning
-// mutable pointers, which currently ICEs. Unleashing Miri silences the ICE.
-//@ compile-flags: -Zunleash-the-miri-inside-of-you
+// Ensure that we reject interning `const_allocate`d allocations in the final value of constants
+// if they have not been made global through `const_make_global`. This covers the case where the
+// pointer is even still mutable, which used to ICE.
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 use std::intrinsics;
 
 const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
-//~^ error: mutable pointer in final value of constant
-//~| error: encountered `const_allocate` pointer in final value that was not made global
+//~^ error: encountered `const_allocate` pointer in final value that was not made global
 
 fn main() {}
diff --git a/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.stderr b/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.stderr
index eae79d24797..2445ce633d6 100644
--- a/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.stderr
+++ b/tests/ui/consts/const-eval/heap/ptr_not_made_global_mut.stderr
@@ -6,11 +6,5 @@ LL | const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32
    |
    = note: use `const_make_global` to make allocated pointers immutable before returning
 
-error: encountered mutable pointer in final value of constant
-  --> $DIR/ptr_not_made_global_mut.rs:8:1
-   |
-LL | const BAR: *mut i32 = unsafe { intrinsics::const_allocate(4, 4) as *mut i32 };
-   | ^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From 0bf0860a0ef285fe3e4eb3b176006c14d8ca9d8d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 16 Jul 2025 15:19:17 +0200
Subject: simplfy memory kind handling during interning

---
 .../src/const_eval/dummy_machine.rs                |  1 -
 .../rustc_const_eval/src/const_eval/machine.rs     |  2 -
 compiler/rustc_const_eval/src/interpret/intern.rs  | 49 +++++-----------------
 compiler/rustc_const_eval/src/interpret/machine.rs |  1 +
 4 files changed, 11 insertions(+), 42 deletions(-)

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 b6e2682af36..438aed41b8b 100644
--- a/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs
@@ -49,7 +49,6 @@ impl HasStaticRootDefId for DummyMachine {
 
 impl<'tcx> interpret::Machine<'tcx> for DummyMachine {
     interpret::compile_time_machine!(<'tcx>);
-    type MemoryKind = !;
     const PANIC_ON_ALLOC_FAIL: bool = true;
 
     // We want to just eval random consts in the program, so `eval_mir_const` can fail.
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index 0a6bdef2225..70ad57b2b11 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -320,8 +320,6 @@ impl<'tcx> CompileTimeMachine<'tcx> {
 impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
     compile_time_machine!(<'tcx>);
 
-    type MemoryKind = MemoryKind;
-
     const PANIC_ON_ALLOC_FAIL: bool = false; // will be raised as a proper error
 
     #[inline(always)]
diff --git a/compiler/rustc_const_eval/src/interpret/intern.rs b/compiler/rustc_const_eval/src/interpret/intern.rs
index f25bb222bcf..bb59b9f5418 100644
--- a/compiler/rustc_const_eval/src/interpret/intern.rs
+++ b/compiler/rustc_const_eval/src/interpret/intern.rs
@@ -30,14 +30,14 @@ use super::{AllocId, Allocation, InterpCx, MPlaceTy, Machine, MemoryKind, PlaceT
 use crate::const_eval::DummyMachine;
 use crate::{const_eval, errors};
 
-pub trait CompileTimeMachine<'tcx, T> = Machine<
+pub trait CompileTimeMachine<'tcx> = Machine<
         'tcx,
-        MemoryKind = T,
+        MemoryKind = const_eval::MemoryKind,
         Provenance = CtfeProvenance,
         ExtraFnVal = !,
         FrameExtra = (),
         AllocExtra = (),
-        MemoryMap = FxIndexMap<AllocId, (MemoryKind<T>, Allocation)>,
+        MemoryMap = FxIndexMap<AllocId, (MemoryKind<const_eval::MemoryKind>, Allocation)>,
     > + HasStaticRootDefId;
 
 pub trait HasStaticRootDefId {
@@ -52,35 +52,6 @@ impl HasStaticRootDefId for const_eval::CompileTimeMachine<'_> {
     }
 }
 
-pub enum DisallowInternReason {
-    ConstHeap,
-}
-
-/// A trait for controlling whether memory allocated in the interpreter can be interned.
-///
-/// This prevents us from interning `const_allocate` pointers that have not been made
-/// global through `const_make_global`.
-pub trait CanIntern: Copy {
-    fn disallows_intern(&self) -> Option<DisallowInternReason>;
-}
-
-impl CanIntern for const_eval::MemoryKind {
-    fn disallows_intern(&self) -> Option<DisallowInternReason> {
-        match self {
-            const_eval::MemoryKind::Heap { was_made_global: false } => {
-                Some(DisallowInternReason::ConstHeap)
-            }
-            const_eval::MemoryKind::Heap { was_made_global: true } => None,
-        }
-    }
-}
-
-impl CanIntern for ! {
-    fn disallows_intern(&self) -> Option<DisallowInternReason> {
-        *self
-    }
-}
-
 /// Intern an allocation. Returns `Err` if the allocation does not exist in the local memory.
 ///
 /// `mutability` can be used to force immutable interning: if it is `Mutability::Not`, the
@@ -88,7 +59,7 @@ impl CanIntern for ! {
 /// already mutable (as a sanity check).
 ///
 /// Returns an iterator over all relocations referred to by this allocation.
-fn intern_shallow<'tcx, T: CanIntern, M: CompileTimeMachine<'tcx, T>>(
+fn intern_shallow<'tcx, M: CompileTimeMachine<'tcx>>(
     ecx: &mut InterpCx<'tcx, M>,
     alloc_id: AllocId,
     mutability: Mutability,
@@ -102,16 +73,16 @@ fn intern_shallow<'tcx, T: CanIntern, M: CompileTimeMachine<'tcx, T>>(
     };
 
     match kind {
-        MemoryKind::Machine(x) if let Some(reason) = x.disallows_intern() => match reason {
-            DisallowInternReason::ConstHeap => {
+        MemoryKind::Machine(const_eval::MemoryKind::Heap { was_made_global }) => {
+            if !was_made_global {
                 // Attempting to intern a `const_allocate`d pointer that was not made global via
                 // `const_make_global`. We want to error here, but we have to first put the
                 // allocation back into the `alloc_map` to keep things in a consistent state.
                 ecx.memory.alloc_map.insert(alloc_id, (kind, alloc));
                 return Err(InternError::ConstAllocNotGlobal);
             }
-        },
-        MemoryKind::Machine(_) | MemoryKind::Stack | MemoryKind::CallerLocation => {}
+        }
+        MemoryKind::Stack | MemoryKind::CallerLocation => {}
     }
 
     // Set allocation mutability as appropriate. This is used by LLVM to put things into
@@ -204,7 +175,7 @@ pub enum InternError {
 ///
 /// For `InternKind::Static` the root allocation will not be interned, but must be handled by the caller.
 #[instrument(level = "debug", skip(ecx))]
-pub fn intern_const_alloc_recursive<'tcx, M: CompileTimeMachine<'tcx, const_eval::MemoryKind>>(
+pub fn intern_const_alloc_recursive<'tcx, M: CompileTimeMachine<'tcx>>(
     ecx: &mut InterpCx<'tcx, M>,
     intern_kind: InternKind,
     ret: &MPlaceTy<'tcx>,
@@ -365,7 +336,7 @@ pub fn intern_const_alloc_recursive<'tcx, M: CompileTimeMachine<'tcx, const_eval
 
 /// Intern `ret`. This function assumes that `ret` references no other allocation.
 #[instrument(level = "debug", skip(ecx))]
-pub fn intern_const_alloc_for_constprop<'tcx, T: CanIntern, M: CompileTimeMachine<'tcx, T>>(
+pub fn intern_const_alloc_for_constprop<'tcx, M: CompileTimeMachine<'tcx>>(
     ecx: &mut InterpCx<'tcx, M>,
     alloc_id: AllocId,
 ) -> InterpResult<'tcx, ()> {
diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
index d150ed69250..e981f3973ae 100644
--- a/compiler/rustc_const_eval/src/interpret/machine.rs
+++ b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -649,6 +649,7 @@ pub macro compile_time_machine(<$tcx: lifetime>) {
 
     type ExtraFnVal = !;
 
+    type MemoryKind = $crate::const_eval::MemoryKind;
     type MemoryMap =
         rustc_data_structures::fx::FxIndexMap<AllocId, (MemoryKind<Self::MemoryKind>, Allocation)>;
     const GLOBAL_KIND: Option<Self::MemoryKind> = None; // no copying of globals from `tcx` to machine memory
-- 
cgit 1.4.1-3-g733a5


From ecd958f4802bfead8a35a1fcdbb1c17467ad727c Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Wed, 16 Jul 2025 09:33:08 -0400
Subject: Fix LTO errors

---
 .github/workflows/release.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index b0c552751e3..b7e2583aad3 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -78,7 +78,8 @@ jobs:
     - name: Run tests
       run: |
         # FIXME(antoyo): we cannot enable LTO for stdarch tests currently because of some failing LTO tests using proc-macros.
-        printf '[profile.release]\nlto = "fat"\n' >> build/build_sysroot/sysroot_src/library/sysroot/Cargo.toml
+        # FIXME(antoyo): this should probably not be needed since we embed the LTO bitcode.
+        printf '[profile.release]\nlto = "fat"\n' >> build/build_sysroot/sysroot_src/library/Cargo.toml
         EMBED_LTO_BITCODE=1 ./y.sh test --release --clean --release-sysroot --build-sysroot --keep-lto-tests ${{ matrix.commands }}
 
     - name: Run y.sh cargo build
-- 
cgit 1.4.1-3-g733a5


From 4e054fc4c4809a3c1df60ea99077f4d662b79750 Mon Sep 17 00:00:00 2001
From: Sasha Pourcelot <sasha.pourcelot@protonmail.com>
Date: Sun, 13 Jul 2025 11:51:22 +0200
Subject: Port `#[coverage]` to the new attribute system

---
 .../rustc_attr_data_structures/src/attributes.rs   |  19 +++
 .../src/encode_cross_crate.rs                      |   1 +
 .../src/attributes/codegen_attrs.rs                |  41 ++++-
 compiler/rustc_attr_parsing/src/context.rs         |  26 ++-
 .../rustc_attr_parsing/src/session_diagnostics.rs  |  49 +++++-
 compiler/rustc_mir_transform/src/coverage/query.rs |  32 ++--
 compiler/rustc_parse/src/validate_attr.rs          |   1 +
 compiler/rustc_passes/src/check_attr.rs            |   8 +-
 tests/ui/attributes/malformed-attrs.stderr         |  26 +--
 tests/ui/coverage-attr/bad-attr-ice.feat.stderr    |   7 +-
 tests/ui/coverage-attr/bad-attr-ice.nofeat.stderr  |  27 +--
 tests/ui/coverage-attr/bad-syntax.stderr           | 134 ++++++++-------
 tests/ui/coverage-attr/name-value.rs               |   7 -
 tests/ui/coverage-attr/name-value.stderr           | 179 ++++++--------------
 tests/ui/coverage-attr/subword.stderr              |  33 ++--
 tests/ui/coverage-attr/word-only.rs                |   7 -
 tests/ui/coverage-attr/word-only.stderr            | 185 ++++++---------------
 17 files changed, 377 insertions(+), 405 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 3dedeb1b372..24f52d6f500 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -110,6 +110,22 @@ pub enum DeprecatedSince {
     Err,
 }
 
+#[derive(
+    Copy,
+    Debug,
+    Eq,
+    PartialEq,
+    Encodable,
+    Decodable,
+    Clone,
+    HashStable_Generic,
+    PrintAttribute
+)]
+pub enum CoverageStatus {
+    On,
+    Off,
+}
+
 impl Deprecation {
     /// Whether an item marked with #[deprecated(since = "X")] is currently
     /// deprecated (i.e., whether X is not greater than the current rustc
@@ -274,6 +290,9 @@ pub enum AttributeKind {
     /// Represents `#[const_trait]`.
     ConstTrait(Span),
 
+    /// Represents `#[coverage]`.
+    Coverage(Span, CoverageStatus),
+
     ///Represents `#[rustc_deny_explicit_impl]`.
     DenyExplicitImpl(Span),
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 3e2dc0a15b2..8105e4fb125 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -28,6 +28,7 @@ impl AttributeKind {
             ConstStability { .. } => Yes,
             ConstStabilityIndirect => No,
             ConstTrait(..) => No,
+            Coverage(..) => No,
             DenyExplicitImpl(..) => No,
             Deprecation { .. } => Yes,
             DoNotImplementViaObject(..) => No,
diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index 34d9b048348..3e542771d58 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -1,4 +1,4 @@
-use rustc_attr_data_structures::{AttributeKind, OptimizeAttr, UsedBy};
+use rustc_attr_data_structures::{AttributeKind, CoverageStatus, OptimizeAttr, UsedBy};
 use rustc_feature::{AttributeTemplate, template};
 use rustc_session::parse::feature_err;
 use rustc_span::{Span, Symbol, sym};
@@ -52,6 +52,45 @@ impl<S: Stage> NoArgsAttributeParser<S> for ColdParser {
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::Cold;
 }
 
+pub(crate) struct CoverageParser;
+
+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 TEMPLATE: AttributeTemplate = template!(OneOf: &[sym::off, sym::on]);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let Some(args) = args.list() else {
+            cx.expected_specific_argument_and_list(cx.attr_span, vec!["on", "off"]);
+            return None;
+        };
+
+        let Some(arg) = args.single() else {
+            cx.expected_single_argument(args.span);
+            return None;
+        };
+
+        let fail_incorrect_argument = |span| cx.expected_specific_argument(span, vec!["on", "off"]);
+
+        let Some(arg) = arg.meta_item() else {
+            fail_incorrect_argument(args.span);
+            return None;
+        };
+
+        let status = match arg.path().word_sym() {
+            Some(sym::off) => CoverageStatus::Off,
+            Some(sym::on) => CoverageStatus::On,
+            None | Some(_) => {
+                fail_incorrect_argument(arg.span());
+                return None;
+            }
+        };
+
+        Some(AttributeKind::Coverage(cx.attr_span, status))
+    }
+}
+
 pub(crate) struct ExportNameParser;
 
 impl<S: Stage> SingleAttributeParser<S> for ExportNameParser {
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 567341d1517..043a0524269 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -15,8 +15,9 @@ use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
 
 use crate::attributes::allow_unstable::{AllowConstFnUnstableParser, AllowInternalUnstableParser};
 use crate::attributes::codegen_attrs::{
-    ColdParser, ExportNameParser, NakedParser, NoMangleParser, OmitGdbPrettyPrinterSectionParser,
-    OptimizeParser, TargetFeatureParser, TrackCallerParser, UsedParser,
+    ColdParser, CoverageParser, ExportNameParser, NakedParser, NoMangleParser,
+    OmitGdbPrettyPrinterSectionParser, OptimizeParser, TargetFeatureParser, TrackCallerParser,
+    UsedParser,
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::deprecation::DeprecationParser;
@@ -136,6 +137,7 @@ attribute_parsers!(
         // tidy-alphabetical-end
 
         // tidy-alphabetical-start
+        Single<CoverageParser>,
         Single<DeprecationParser>,
         Single<DummyParser>,
         Single<ExportNameParser>,
@@ -449,6 +451,25 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             reason: AttributeParseErrorReason::ExpectedSpecificArgument {
                 possibilities,
                 strings: false,
+                list: false,
+            },
+        })
+    }
+
+    pub(crate) fn expected_specific_argument_and_list(
+        &self,
+        span: Span,
+        possibilities: Vec<&'static str>,
+    ) -> ErrorGuaranteed {
+        self.emit_err(AttributeParseError {
+            span,
+            attr_span: self.attr_span,
+            template: self.template.clone(),
+            attribute: self.attr_path.clone(),
+            reason: AttributeParseErrorReason::ExpectedSpecificArgument {
+                possibilities,
+                strings: false,
+                list: true,
             },
         })
     }
@@ -466,6 +487,7 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             reason: AttributeParseErrorReason::ExpectedSpecificArgument {
                 possibilities,
                 strings: true,
+                list: false,
             },
         })
     }
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index 97bf3d1c549..67dac8da384 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -525,7 +525,9 @@ pub(crate) struct LinkOrdinalOutOfRange {
 
 pub(crate) enum AttributeParseErrorReason {
     ExpectedNoArgs,
-    ExpectedStringLiteral { byte_string: Option<Span> },
+    ExpectedStringLiteral {
+        byte_string: Option<Span>,
+    },
     ExpectedIntegerLiteral,
     ExpectedAtLeastOneArgument,
     ExpectedSingleArgument,
@@ -533,7 +535,12 @@ pub(crate) enum AttributeParseErrorReason {
     UnexpectedLiteral,
     ExpectedNameValue(Option<Symbol>),
     DuplicateKey(Symbol),
-    ExpectedSpecificArgument { possibilities: Vec<&'static str>, strings: bool },
+    ExpectedSpecificArgument {
+        possibilities: Vec<&'static str>,
+        strings: bool,
+        /// Should we tell the user to write a list when they didn't?
+        list: bool,
+    },
 }
 
 pub(crate) struct AttributeParseError {
@@ -607,7 +614,11 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError {
                     format!("expected this to be of the form `{name} = \"...\"`"),
                 );
             }
-            AttributeParseErrorReason::ExpectedSpecificArgument { possibilities, strings } => {
+            AttributeParseErrorReason::ExpectedSpecificArgument {
+                possibilities,
+                strings,
+                list: false,
+            } => {
                 let quote = if strings { '"' } else { '`' };
                 match possibilities.as_slice() {
                     &[] => {}
@@ -633,6 +644,38 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError {
                     }
                 }
             }
+            AttributeParseErrorReason::ExpectedSpecificArgument {
+                possibilities,
+                strings,
+                list: true,
+            } => {
+                let quote = if strings { '"' } else { '`' };
+                match possibilities.as_slice() {
+                    &[] => {}
+                    &[x] => {
+                        diag.span_label(
+                            self.span,
+                            format!(
+                                "this attribute is only valid with {quote}{x}{quote} as an argument"
+                            ),
+                        );
+                    }
+                    [first, second] => {
+                        diag.span_label(self.span, format!("this attribute is only valid with either {quote}{first}{quote} or {quote}{second}{quote} as an argument"));
+                    }
+                    [first @ .., second_to_last, last] => {
+                        let mut res = String::new();
+                        for i in first {
+                            res.push_str(&format!("{quote}{i}{quote}, "));
+                        }
+                        res.push_str(&format!(
+                            "{quote}{second_to_last}{quote} or {quote}{last}{quote}"
+                        ));
+
+                        diag.span_label(self.span, format!("this attribute is only valid with one of the following arguments: {res}"));
+                    }
+                }
+            }
         }
 
         let suggestions = self.template.suggestions(false, &name);
diff --git a/compiler/rustc_mir_transform/src/coverage/query.rs b/compiler/rustc_mir_transform/src/coverage/query.rs
index ccf76dc7108..986c001de5e 100644
--- a/compiler/rustc_mir_transform/src/coverage/query.rs
+++ b/compiler/rustc_mir_transform/src/coverage/query.rs
@@ -1,3 +1,4 @@
+use rustc_attr_data_structures::{AttributeKind, CoverageStatus, find_attr};
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mir::coverage::{BasicCoverageBlock, CoverageIdsInfo, CoverageKind, MappingKind};
@@ -5,7 +6,6 @@ use rustc_middle::mir::{Body, Statement, StatementKind};
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_middle::util::Providers;
 use rustc_span::def_id::LocalDefId;
-use rustc_span::sym;
 use tracing::trace;
 
 use crate::coverage::counters::node_flow::make_node_counters;
@@ -58,26 +58,20 @@ fn is_eligible_for_coverage(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
 /// Query implementation for `coverage_attr_on`.
 fn coverage_attr_on(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
     // Check for annotations directly on this def.
-    if let Some(attr) = tcx.get_attr(def_id, sym::coverage) {
-        match attr.meta_item_list().as_deref() {
-            Some([item]) if item.has_name(sym::off) => return false,
-            Some([item]) if item.has_name(sym::on) => return true,
-            Some(_) | None => {
-                // Other possibilities should have been rejected by `rustc_parse::validate_attr`.
-                // Use `span_delayed_bug` to avoid an ICE in failing builds (#127880).
-                tcx.dcx().span_delayed_bug(attr.span(), "unexpected value of coverage attribute");
-            }
+    if let Some(coverage_status) =
+        find_attr!(tcx.get_all_attrs(def_id), AttributeKind::Coverage(_, status) => status)
+    {
+        *coverage_status == CoverageStatus::On
+    } else {
+        match tcx.opt_local_parent(def_id) {
+            // Check the parent def (and so on recursively) until we find an
+            // enclosing attribute or reach the crate root.
+            Some(parent) => tcx.coverage_attr_on(parent),
+            // We reached the crate root without seeing a coverage attribute, so
+            // allow coverage instrumentation by default.
+            None => true,
         }
     }
-
-    match tcx.opt_local_parent(def_id) {
-        // Check the parent def (and so on recursively) until we find an
-        // enclosing attribute or reach the crate root.
-        Some(parent) => tcx.coverage_attr_on(parent),
-        // We reached the crate root without seeing a coverage attribute, so
-        // allow coverage instrumentation by default.
-        None => true,
-    }
 }
 
 /// Query implementation for `coverage_ids_info`.
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 783d79d978a..a476f0db37e 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -318,6 +318,7 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_layout_scalar_valid_range_end
                 | sym::no_implicit_prelude
                 | sym::automatically_derived
+                | sym::coverage
         ) {
             return;
         }
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2009ddc1e2d..810472eb2de 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -285,6 +285,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 &Attribute::Parsed(AttributeKind::StdInternalSymbol(attr_span)) => {
                     self.check_rustc_std_internal_symbol(attr_span, span, target)
                 }
+                &Attribute::Parsed(AttributeKind::Coverage(attr_span, _)) => {
+                    self.check_coverage(attr_span, span, target)
+                }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);
                     match attr.path().as_slice() {
@@ -294,7 +297,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         [sym::diagnostic, sym::on_unimplemented, ..] => {
                             self.check_diagnostic_on_unimplemented(attr.span(), hir_id, target)
                         }
-                        [sym::coverage, ..] => self.check_coverage(attr, span, target),
                         [sym::no_sanitize, ..] => {
                             self.check_no_sanitize(attr, span, target)
                         }
@@ -585,7 +587,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
 
     /// Checks that `#[coverage(..)]` is applied to a function/closure/method,
     /// or to an impl block or module.
-    fn check_coverage(&self, attr: &Attribute, target_span: Span, target: Target) {
+    fn check_coverage(&self, attr_span: Span, target_span: Span, target: Target) {
         let mut not_fn_impl_mod = None;
         let mut no_body = None;
 
@@ -608,7 +610,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
 
         self.dcx().emit_err(errors::CoverageAttributeNotAllowed {
-            attr_span: attr.span(),
+            attr_span,
             not_fn_impl_mod,
             no_body,
             help: (),
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index 56f2be353e7..0d0c338d302 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -37,19 +37,6 @@ error: malformed `crate_name` attribute input
 LL | #[crate_name]
    | ^^^^^^^^^^^^^ help: must be of the form: `#[crate_name = "name"]`
 
-error: malformed `coverage` attribute input
-  --> $DIR/malformed-attrs.rs:90:1
-   |
-LL | #[coverage]
-   | ^^^^^^^^^^^
-   |
-help: the following are the possible correct uses
-   |
-LL | #[coverage(off)]
-   |           +++++
-LL | #[coverage(on)]
-   |           ++++
-
 error: malformed `no_sanitize` attribute input
   --> $DIR/malformed-attrs.rs:92:1
    |
@@ -460,6 +447,19 @@ error[E0539]: malformed `link_section` attribute input
 LL | #[link_section]
    | ^^^^^^^^^^^^^^^ help: must be of the form: `#[link_section = "name"]`
 
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/malformed-attrs.rs:90:1
+   |
+LL | #[coverage]
+   | ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
+   |
+help: try changing it to one of the following valid forms of the attribute
+   |
+LL | #[coverage(off)]
+   |           +++++
+LL | #[coverage(on)]
+   |           ++++
+
 error[E0565]: malformed `no_implicit_prelude` attribute input
   --> $DIR/malformed-attrs.rs:97:1
    |
diff --git a/tests/ui/coverage-attr/bad-attr-ice.feat.stderr b/tests/ui/coverage-attr/bad-attr-ice.feat.stderr
index dc84394fe3c..5a003af42da 100644
--- a/tests/ui/coverage-attr/bad-attr-ice.feat.stderr
+++ b/tests/ui/coverage-attr/bad-attr-ice.feat.stderr
@@ -1,10 +1,10 @@
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/bad-attr-ice.rs:11:1
    |
 LL | #[coverage]
-   | ^^^^^^^^^^^
+   | ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL | #[coverage(off)]
    |           +++++
@@ -13,3 +13,4 @@ LL | #[coverage(on)]
 
 error: aborting due to 1 previous error
 
+For more information about this error, try `rustc --explain E0539`.
diff --git a/tests/ui/coverage-attr/bad-attr-ice.nofeat.stderr b/tests/ui/coverage-attr/bad-attr-ice.nofeat.stderr
index 49b8974bfdf..4501e5e9dc8 100644
--- a/tests/ui/coverage-attr/bad-attr-ice.nofeat.stderr
+++ b/tests/ui/coverage-attr/bad-attr-ice.nofeat.stderr
@@ -1,26 +1,27 @@
-error: malformed `coverage` attribute input
+error[E0658]: the `#[coverage]` attribute is an experimental feature
   --> $DIR/bad-attr-ice.rs:11:1
    |
 LL | #[coverage]
    | ^^^^^^^^^^^
    |
-help: the following are the possible correct uses
-   |
-LL | #[coverage(off)]
-   |           +++++
-LL | #[coverage(on)]
-   |           ++++
+   = note: see issue #84605 <https://github.com/rust-lang/rust/issues/84605> for more information
+   = help: add `#![feature(coverage_attribute)]` 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 `#[coverage]` attribute is an experimental feature
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/bad-attr-ice.rs:11:1
    |
 LL | #[coverage]
-   | ^^^^^^^^^^^
+   | ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-   = note: see issue #84605 <https://github.com/rust-lang/rust/issues/84605> for more information
-   = help: add `#![feature(coverage_attribute)]` 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: try changing it to one of the following valid forms of the attribute
+   |
+LL | #[coverage(off)]
+   |           +++++
+LL | #[coverage(on)]
+   |           ++++
 
 error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0658`.
+Some errors have detailed explanations: E0539, E0658.
+For more information about an error, try `rustc --explain E0539`.
diff --git a/tests/ui/coverage-attr/bad-syntax.stderr b/tests/ui/coverage-attr/bad-syntax.stderr
index fa500b54209..927f61da08d 100644
--- a/tests/ui/coverage-attr/bad-syntax.stderr
+++ b/tests/ui/coverage-attr/bad-syntax.stderr
@@ -1,23 +1,59 @@
-error: malformed `coverage` attribute input
+error: expected identifier, found `,`
+  --> $DIR/bad-syntax.rs:44:12
+   |
+LL | #[coverage(,off)]
+   |            ^ expected identifier
+   |
+help: remove this comma
+   |
+LL - #[coverage(,off)]
+LL + #[coverage(off)]
+   |
+
+error: multiple `coverage` attributes
+  --> $DIR/bad-syntax.rs:9:1
+   |
+LL | #[coverage(off)]
+   | ^^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/bad-syntax.rs:10: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)]
+   | ^^^^^^^^^^^^^^^
+
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/bad-syntax.rs:17:1
    |
 LL | #[coverage]
-   | ^^^^^^^^^^^
+   | ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL | #[coverage(off)]
    |           +++++
 LL | #[coverage(on)]
    |           ++++
 
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/bad-syntax.rs:20:1
    |
 LL | #[coverage = true]
-   | ^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage = true]
 LL + #[coverage(off)]
@@ -26,26 +62,30 @@ LL - #[coverage = true]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
+error[E0805]: malformed `coverage` attribute input
   --> $DIR/bad-syntax.rs:23:1
    |
 LL | #[coverage()]
-   | ^^^^^^^^^^^^^
+   | ^^^^^^^^^^--^
+   |           |
+   |           expected a single argument here
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL | #[coverage(off)]
    |            +++
 LL | #[coverage(on)]
    |            ++
 
-error: malformed `coverage` attribute input
+error[E0805]: malformed `coverage` attribute input
   --> $DIR/bad-syntax.rs:26:1
    |
 LL | #[coverage(off, off)]
-   | ^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^----------^
+   |           |
+   |           expected a single argument here
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage(off, off)]
 LL + #[coverage(off)]
@@ -54,13 +94,15 @@ LL - #[coverage(off, off)]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
+error[E0805]: malformed `coverage` attribute input
   --> $DIR/bad-syntax.rs:29:1
    |
 LL | #[coverage(off, on)]
-   | ^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^---------^
+   |           |
+   |           expected a single argument here
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage(off, on)]
 LL + #[coverage(off)]
@@ -69,13 +111,15 @@ LL - #[coverage(off, on)]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/bad-syntax.rs:32:1
    |
 LL | #[coverage(bogus)]
-   | ^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^-----^^
+   |            |
+   |            valid arguments are `on` or `off`
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage(bogus)]
 LL + #[coverage(off)]
@@ -84,13 +128,15 @@ LL - #[coverage(bogus)]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
+error[E0805]: malformed `coverage` attribute input
   --> $DIR/bad-syntax.rs:35:1
    |
 LL | #[coverage(bogus, off)]
-   | ^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^------------^
+   |           |
+   |           expected a single argument here
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage(bogus, off)]
 LL + #[coverage(off)]
@@ -99,13 +145,15 @@ LL - #[coverage(bogus, off)]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
+error[E0805]: malformed `coverage` attribute input
   --> $DIR/bad-syntax.rs:38:1
    |
 LL | #[coverage(off, bogus)]
-   | ^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^------------^
+   |           |
+   |           expected a single argument here
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage(off, bogus)]
 LL + #[coverage(off)]
@@ -114,41 +162,7 @@ LL - #[coverage(off, bogus)]
 LL + #[coverage(on)]
    |
 
-error: expected identifier, found `,`
-  --> $DIR/bad-syntax.rs:44:12
-   |
-LL | #[coverage(,off)]
-   |            ^ expected identifier
-   |
-help: remove this comma
-   |
-LL - #[coverage(,off)]
-LL + #[coverage(off)]
-   |
-
-error: multiple `coverage` attributes
-  --> $DIR/bad-syntax.rs:9:1
-   |
-LL | #[coverage(off)]
-   | ^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
-  --> $DIR/bad-syntax.rs:10: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)]
-   | ^^^^^^^^^^^^^^^
-
 error: aborting due to 11 previous errors
 
+Some errors have detailed explanations: E0539, E0805.
+For more information about an error, try `rustc --explain E0539`.
diff --git a/tests/ui/coverage-attr/name-value.rs b/tests/ui/coverage-attr/name-value.rs
index ffd9afe2ce1..8171dbbf692 100644
--- a/tests/ui/coverage-attr/name-value.rs
+++ b/tests/ui/coverage-attr/name-value.rs
@@ -20,7 +20,6 @@ mod my_mod_inner {
 
 #[coverage = "off"]
 //~^ ERROR malformed `coverage` attribute input
-//~| ERROR [E0788]
 struct MyStruct;
 
 #[coverage = "off"]
@@ -28,22 +27,18 @@ struct MyStruct;
 impl MyStruct {
     #[coverage = "off"]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR [E0788]
     const X: u32 = 7;
 }
 
 #[coverage = "off"]
 //~^ ERROR malformed `coverage` attribute input
-//~| ERROR [E0788]
 trait MyTrait {
     #[coverage = "off"]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR [E0788]
     const X: u32;
 
     #[coverage = "off"]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR [E0788]
     type T;
 }
 
@@ -52,12 +47,10 @@ trait MyTrait {
 impl MyTrait for MyStruct {
     #[coverage = "off"]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR [E0788]
     const X: u32 = 8;
 
     #[coverage = "off"]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR [E0788]
     type T = ();
 }
 
diff --git a/tests/ui/coverage-attr/name-value.stderr b/tests/ui/coverage-attr/name-value.stderr
index f24db78415e..a838ec5df8e 100644
--- a/tests/ui/coverage-attr/name-value.stderr
+++ b/tests/ui/coverage-attr/name-value.stderr
@@ -1,10 +1,10 @@
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/name-value.rs:12:1
    |
 LL | #[coverage = "off"]
-   | ^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage = "off"]
 LL + #[coverage(off)]
@@ -13,28 +13,28 @@ LL - #[coverage = "off"]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/name-value.rs:17:5
    |
 LL |     #![coverage = "off"]
-   |     ^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL -     #![coverage = "off"]
-LL +     #![coverage(off)]
+LL +     #[coverage(off)]
    |
 LL -     #![coverage = "off"]
-LL +     #![coverage(on)]
+LL +     #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/name-value.rs:21:1
    |
 LL | #[coverage = "off"]
-   | ^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage = "off"]
 LL + #[coverage(off)]
@@ -43,13 +43,13 @@ LL - #[coverage = "off"]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:26:1
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/name-value.rs:25:1
    |
 LL | #[coverage = "off"]
-   | ^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage = "off"]
 LL + #[coverage(off)]
@@ -58,13 +58,13 @@ LL - #[coverage = "off"]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:29:5
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/name-value.rs:28:5
    |
 LL |     #[coverage = "off"]
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL -     #[coverage = "off"]
 LL +     #[coverage(off)]
@@ -73,13 +73,13 @@ LL -     #[coverage = "off"]
 LL +     #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:35:1
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/name-value.rs:33:1
    |
 LL | #[coverage = "off"]
-   | ^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage = "off"]
 LL + #[coverage(off)]
@@ -88,13 +88,13 @@ LL - #[coverage = "off"]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:39:5
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/name-value.rs:36:5
    |
 LL |     #[coverage = "off"]
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL -     #[coverage = "off"]
 LL +     #[coverage(off)]
@@ -103,13 +103,13 @@ LL -     #[coverage = "off"]
 LL +     #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:44:5
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/name-value.rs:40:5
    |
 LL |     #[coverage = "off"]
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL -     #[coverage = "off"]
 LL +     #[coverage(off)]
@@ -118,13 +118,13 @@ LL -     #[coverage = "off"]
 LL +     #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:50:1
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/name-value.rs:45:1
    |
 LL | #[coverage = "off"]
-   | ^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage = "off"]
 LL + #[coverage(off)]
@@ -133,13 +133,13 @@ LL - #[coverage = "off"]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:53:5
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/name-value.rs:48:5
    |
 LL |     #[coverage = "off"]
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL -     #[coverage = "off"]
 LL +     #[coverage(off)]
@@ -148,13 +148,13 @@ LL -     #[coverage = "off"]
 LL +     #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:58:5
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/name-value.rs:52:5
    |
 LL |     #[coverage = "off"]
-   |     ^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL -     #[coverage = "off"]
 LL +     #[coverage(off)]
@@ -163,13 +163,13 @@ LL -     #[coverage = "off"]
 LL +     #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
-  --> $DIR/name-value.rs:64:1
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/name-value.rs:57:1
    |
 LL | #[coverage = "off"]
-   | ^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage = "off"]
 LL + #[coverage(off)]
@@ -178,87 +178,6 @@ LL - #[coverage = "off"]
 LL + #[coverage(on)]
    |
 
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/name-value.rs:21:1
-   |
-LL | #[coverage = "off"]
-   | ^^^^^^^^^^^^^^^^^^^
-...
-LL | struct MyStruct;
-   | ---------------- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/name-value.rs:35:1
-   |
-LL |   #[coverage = "off"]
-   |   ^^^^^^^^^^^^^^^^^^^
-...
-LL | / trait MyTrait {
-LL | |     #[coverage = "off"]
-...  |
-LL | |     type T;
-LL | | }
-   | |_- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/name-value.rs:39:5
-   |
-LL |     #[coverage = "off"]
-   |     ^^^^^^^^^^^^^^^^^^^
-...
-LL |     const X: u32;
-   |     ------------- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/name-value.rs:44:5
-   |
-LL |     #[coverage = "off"]
-   |     ^^^^^^^^^^^^^^^^^^^
-...
-LL |     type T;
-   |     ------- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/name-value.rs:29:5
-   |
-LL |     #[coverage = "off"]
-   |     ^^^^^^^^^^^^^^^^^^^
-...
-LL |     const X: u32 = 7;
-   |     ----------------- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/name-value.rs:53:5
-   |
-LL |     #[coverage = "off"]
-   |     ^^^^^^^^^^^^^^^^^^^
-...
-LL |     const X: u32 = 8;
-   |     ----------------- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/name-value.rs:58:5
-   |
-LL |     #[coverage = "off"]
-   |     ^^^^^^^^^^^^^^^^^^^
-...
-LL |     type T = ();
-   |     ------------ not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error: aborting due to 19 previous errors
+error: aborting due to 12 previous errors
 
-For more information about this error, try `rustc --explain E0788`.
+For more information about this error, try `rustc --explain E0539`.
diff --git a/tests/ui/coverage-attr/subword.stderr b/tests/ui/coverage-attr/subword.stderr
index a5d1a492181..32a09a10c84 100644
--- a/tests/ui/coverage-attr/subword.stderr
+++ b/tests/ui/coverage-attr/subword.stderr
@@ -1,10 +1,12 @@
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/subword.rs:8:1
    |
 LL | #[coverage(yes(milord))]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^-----------^^
+   |            |
+   |            valid arguments are `on` or `off`
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage(yes(milord))]
 LL + #[coverage(off)]
@@ -13,13 +15,15 @@ LL - #[coverage(yes(milord))]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/subword.rs:11:1
    |
 LL | #[coverage(no(milord))]
-   | ^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^----------^^
+   |            |
+   |            valid arguments are `on` or `off`
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage(no(milord))]
 LL + #[coverage(off)]
@@ -28,13 +32,15 @@ LL - #[coverage(no(milord))]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/subword.rs:14:1
    |
 LL | #[coverage(yes = "milord")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^--------------^^
+   |            |
+   |            valid arguments are `on` or `off`
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage(yes = "milord")]
 LL + #[coverage(off)]
@@ -43,13 +49,15 @@ LL - #[coverage(yes = "milord")]
 LL + #[coverage(on)]
    |
 
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/subword.rs:17:1
    |
 LL | #[coverage(no = "milord")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^-------------^^
+   |            |
+   |            valid arguments are `on` or `off`
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL - #[coverage(no = "milord")]
 LL + #[coverage(off)]
@@ -60,3 +68,4 @@ LL + #[coverage(on)]
 
 error: aborting due to 4 previous errors
 
+For more information about this error, try `rustc --explain E0539`.
diff --git a/tests/ui/coverage-attr/word-only.rs b/tests/ui/coverage-attr/word-only.rs
index d0f743938f3..81bd558b8b0 100644
--- a/tests/ui/coverage-attr/word-only.rs
+++ b/tests/ui/coverage-attr/word-only.rs
@@ -20,7 +20,6 @@ mod my_mod_inner {
 
 #[coverage]
 //~^ ERROR malformed `coverage` attribute input
-//~| ERROR [E0788]
 struct MyStruct;
 
 #[coverage]
@@ -28,22 +27,18 @@ struct MyStruct;
 impl MyStruct {
     #[coverage]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR [E0788]
     const X: u32 = 7;
 }
 
 #[coverage]
 //~^ ERROR malformed `coverage` attribute input
-//~| ERROR [E0788]
 trait MyTrait {
     #[coverage]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR [E0788]
     const X: u32;
 
     #[coverage]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR [E0788]
     type T;
 }
 
@@ -52,12 +47,10 @@ trait MyTrait {
 impl MyTrait for MyStruct {
     #[coverage]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR [E0788]
     const X: u32 = 8;
 
     #[coverage]
     //~^ ERROR malformed `coverage` attribute input
-    //~| ERROR [E0788]
     type T = ();
 }
 
diff --git a/tests/ui/coverage-attr/word-only.stderr b/tests/ui/coverage-attr/word-only.stderr
index 2773db9c857..dd161360a5c 100644
--- a/tests/ui/coverage-attr/word-only.stderr
+++ b/tests/ui/coverage-attr/word-only.stderr
@@ -1,240 +1,161 @@
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/word-only.rs:12:1
    |
 LL | #[coverage]
-   | ^^^^^^^^^^^
+   | ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL | #[coverage(off)]
    |           +++++
 LL | #[coverage(on)]
    |           ++++
 
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/word-only.rs:17:5
    |
 LL |     #![coverage]
-   |     ^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
+   |
+LL -     #![coverage]
+LL +     #[coverage(off)]
+   |
+LL -     #![coverage]
+LL +     #[coverage(on)]
    |
-LL |     #![coverage(off)]
-   |                +++++
-LL |     #![coverage(on)]
-   |                ++++
 
-error: malformed `coverage` attribute input
+error[E0539]: malformed `coverage` attribute input
   --> $DIR/word-only.rs:21:1
    |
 LL | #[coverage]
-   | ^^^^^^^^^^^
+   | ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL | #[coverage(off)]
    |           +++++
 LL | #[coverage(on)]
    |           ++++
 
-error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:26:1
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/word-only.rs:25:1
    |
 LL | #[coverage]
-   | ^^^^^^^^^^^
+   | ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL | #[coverage(off)]
    |           +++++
 LL | #[coverage(on)]
    |           ++++
 
-error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:29:5
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/word-only.rs:28:5
    |
 LL |     #[coverage]
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL |     #[coverage(off)]
    |               +++++
 LL |     #[coverage(on)]
    |               ++++
 
-error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:35:1
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/word-only.rs:33:1
    |
 LL | #[coverage]
-   | ^^^^^^^^^^^
+   | ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL | #[coverage(off)]
    |           +++++
 LL | #[coverage(on)]
    |           ++++
 
-error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:39:5
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/word-only.rs:36:5
    |
 LL |     #[coverage]
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL |     #[coverage(off)]
    |               +++++
 LL |     #[coverage(on)]
    |               ++++
 
-error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:44:5
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/word-only.rs:40:5
    |
 LL |     #[coverage]
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL |     #[coverage(off)]
    |               +++++
 LL |     #[coverage(on)]
    |               ++++
 
-error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:50:1
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/word-only.rs:45:1
    |
 LL | #[coverage]
-   | ^^^^^^^^^^^
+   | ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL | #[coverage(off)]
    |           +++++
 LL | #[coverage(on)]
    |           ++++
 
-error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:53:5
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/word-only.rs:48:5
    |
 LL |     #[coverage]
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL |     #[coverage(off)]
    |               +++++
 LL |     #[coverage(on)]
    |               ++++
 
-error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:58:5
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/word-only.rs:52:5
    |
 LL |     #[coverage]
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL |     #[coverage(off)]
    |               +++++
 LL |     #[coverage(on)]
    |               ++++
 
-error: malformed `coverage` attribute input
-  --> $DIR/word-only.rs:64:1
+error[E0539]: malformed `coverage` attribute input
+  --> $DIR/word-only.rs:57:1
    |
 LL | #[coverage]
-   | ^^^^^^^^^^^
+   | ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
    |
-help: the following are the possible correct uses
+help: try changing it to one of the following valid forms of the attribute
    |
 LL | #[coverage(off)]
    |           +++++
 LL | #[coverage(on)]
    |           ++++
 
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/word-only.rs:21:1
-   |
-LL | #[coverage]
-   | ^^^^^^^^^^^
-...
-LL | struct MyStruct;
-   | ---------------- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/word-only.rs:35:1
-   |
-LL |   #[coverage]
-   |   ^^^^^^^^^^^
-...
-LL | / trait MyTrait {
-LL | |     #[coverage]
-...  |
-LL | |     type T;
-LL | | }
-   | |_- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/word-only.rs:39:5
-   |
-LL |     #[coverage]
-   |     ^^^^^^^^^^^
-...
-LL |     const X: u32;
-   |     ------------- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/word-only.rs:44:5
-   |
-LL |     #[coverage]
-   |     ^^^^^^^^^^^
-...
-LL |     type T;
-   |     ------- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/word-only.rs:29:5
-   |
-LL |     #[coverage]
-   |     ^^^^^^^^^^^
-...
-LL |     const X: u32 = 7;
-   |     ----------------- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/word-only.rs:53:5
-   |
-LL |     #[coverage]
-   |     ^^^^^^^^^^^
-...
-LL |     const X: u32 = 8;
-   |     ----------------- not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error[E0788]: coverage attribute not allowed here
-  --> $DIR/word-only.rs:58:5
-   |
-LL |     #[coverage]
-   |     ^^^^^^^^^^^
-...
-LL |     type T = ();
-   |     ------------ not a function, impl block, or module
-   |
-   = help: coverage attribute can be applied to a function (with body), impl block, or module
-
-error: aborting due to 19 previous errors
+error: aborting due to 12 previous errors
 
-For more information about this error, try `rustc --explain E0788`.
+For more information about this error, try `rustc --explain E0539`.
-- 
cgit 1.4.1-3-g733a5


From af39c0c57cb23678daaeb75ea729edd71aba14b8 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Thu, 10 Jul 2025 14:17:10 +0800
Subject: Emit warning when there is no space between `-o` and confusing arg

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 compiler/rustc_driver_impl/src/lib.rs          | 46 +++++++++++++
 compiler/rustc_session/src/config.rs           |  5 ++
 tests/run-make/option-output-no-space/main.rs  |  1 +
 tests/run-make/option-output-no-space/rmake.rs | 95 ++++++++++++++++++++++++++
 4 files changed, 147 insertions(+)
 create mode 100644 tests/run-make/option-output-no-space/main.rs
 create mode 100644 tests/run-make/option-output-no-space/rmake.rs

diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 18490385455..f3ed6042105 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -1237,9 +1237,55 @@ pub fn handle_options(early_dcx: &EarlyDiagCtxt, args: &[String]) -> Option<geto
         return None;
     }
 
+    warn_on_confusing_output_filename_flag(early_dcx, &matches, args);
+
     Some(matches)
 }
 
+/// Warn if `-o` is used without a space between the flag name and the value
+/// and the value is a high-value confusables,
+/// e.g. `-optimize` instead of `-o optimize`, see issue #142812.
+fn warn_on_confusing_output_filename_flag(
+    early_dcx: &EarlyDiagCtxt,
+    matches: &getopts::Matches,
+    args: &[String],
+) {
+    fn eq_ignore_separators(s1: &str, s2: &str) -> bool {
+        let s1 = s1.replace('-', "_");
+        let s2 = s2.replace('-', "_");
+        s1 == s2
+    }
+
+    if let Some(name) = matches.opt_str("o")
+        && let Some(suspect) = args.iter().find(|arg| arg.starts_with("-o") && *arg != "-o")
+    {
+        let filename = suspect.strip_prefix("-").unwrap_or(suspect);
+        let optgroups = config::rustc_optgroups();
+        let fake_args = ["optimize", "o0", "o1", "o2", "o3", "ofast", "og", "os", "oz"];
+
+        // Check if provided filename might be confusing in conjunction with `-o` flag,
+        // i.e. consider `-o{filename}` such as `-optimize` with `filename` being `ptimize`.
+        // There are high-value confusables, for example:
+        // - Long name of flags, e.g. `--out-dir` vs `-out-dir`
+        // - C compiler flag, e.g. `optimize`, `o0`, `o1`, `o2`, `o3`, `ofast`.
+        // - Codegen flags, e.g. `pt-level` of `-opt-level`.
+        if optgroups.iter().any(|option| eq_ignore_separators(option.long_name(), filename))
+            || config::CG_OPTIONS.iter().any(|option| eq_ignore_separators(option.name(), filename))
+            || fake_args.iter().any(|arg| eq_ignore_separators(arg, filename))
+        {
+            early_dcx.early_warn(
+                "option `-o` has no space between flag name and value, which can be confusing",
+            );
+            early_dcx.early_note(format!(
+                "output filename `-o {name}` is applied instead of a flag named `o{name}`"
+            ));
+            early_dcx.early_help(format!(
+                "insert a space between `-o` and `{name}` if this is intentional: `-o {name}`"
+            ));
+        }
+    }
+}
+
 fn parse_crate_attrs<'a>(sess: &'a Session) -> PResult<'a, ast::AttrVec> {
     let mut parser = unwrap_or_emit_fatal(match &sess.io.input {
         Input::File(file) => new_parser_from_file(&sess.psess, file, None),
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 4627c2978fc..7f2f5f1c5a4 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -1653,6 +1653,11 @@ impl RustcOptGroup {
             OptionKind::FlagMulti => options.optflagmulti(short_name, long_name, desc),
         };
     }
+
+    /// This is for diagnostics-only.
+    pub fn long_name(&self) -> &str {
+        self.long_name
+    }
 }
 
 pub fn make_opt(
diff --git a/tests/run-make/option-output-no-space/main.rs b/tests/run-make/option-output-no-space/main.rs
new file mode 100644
index 00000000000..f328e4d9d04
--- /dev/null
+++ b/tests/run-make/option-output-no-space/main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/tests/run-make/option-output-no-space/rmake.rs b/tests/run-make/option-output-no-space/rmake.rs
new file mode 100644
index 00000000000..2c42f15aa89
--- /dev/null
+++ b/tests/run-make/option-output-no-space/rmake.rs
@@ -0,0 +1,95 @@
+// This test is to check if the warning is emitted when no space
+// between `-o` and arg is applied, see issue #142812
+
+//@ ignore-cross-compile
+use run_make_support::rustc;
+
+fn main() {
+    // test fake args
+    rustc()
+        .input("main.rs")
+        .arg("-optimize")
+        .run()
+        .assert_stderr_contains(
+            "warning: option `-o` has no space between flag name and value, which can be confusing",
+        )
+        .assert_stderr_contains(
+            "note: output filename `-o ptimize` is applied instead of a flag named `optimize`",
+        );
+    rustc()
+        .input("main.rs")
+        .arg("-o0")
+        .run()
+        .assert_stderr_contains(
+            "warning: option `-o` has no space between flag name and value, which can be confusing",
+        )
+        .assert_stderr_contains(
+            "note: output filename `-o 0` is applied instead of a flag named `o0`",
+        );
+    rustc().input("main.rs").arg("-o1").run();
+    // test real args by iter optgroups
+    rustc()
+        .input("main.rs")
+        .arg("-out-dir")
+        .run()
+        .assert_stderr_contains(
+            "warning: option `-o` has no space between flag name and value, which can be confusing",
+        )
+        .assert_stderr_contains(
+            "note: output filename `-o ut-dir` is applied instead of a flag named `out-dir`",
+        )
+        .assert_stderr_contains(
+            "help: insert a space between `-o` and `ut-dir` if this is intentional: `-o ut-dir`",
+        );
+    // test real args by iter CG_OPTIONS
+    rustc()
+        .input("main.rs")
+        .arg("-opt_level")
+        .run()
+        .assert_stderr_contains(
+            "warning: option `-o` has no space between flag name and value, which can be confusing",
+        )
+        .assert_stderr_contains(
+            "note: output filename `-o pt_level` is applied instead of a flag named `opt_level`",
+        )
+        .assert_stderr_contains(
+            "help: insert a space between `-o` and `pt_level` if this is intentional: `-o pt_level`"
+        );
+    // separater in-sensitive
+    rustc()
+        .input("main.rs")
+        .arg("-opt-level")
+        .run()
+        .assert_stderr_contains(
+            "warning: option `-o` has no space between flag name and value, which can be confusing",
+        )
+        .assert_stderr_contains(
+            "note: output filename `-o pt-level` is applied instead of a flag named `opt-level`",
+        )
+        .assert_stderr_contains(
+            "help: insert a space between `-o` and `pt-level` if this is intentional: `-o pt-level`"
+        );
+    rustc()
+        .input("main.rs")
+        .arg("-overflow-checks")
+        .run()
+        .assert_stderr_contains(
+            "warning: option `-o` has no space between flag name and value, which can be confusing",
+        )
+        .assert_stderr_contains(
+            "note: output filename `-o verflow-checks` \
+            is applied instead of a flag named `overflow-checks`",
+        )
+        .assert_stderr_contains(
+            "help: insert a space between `-o` and `verflow-checks` \
+            if this is intentional: `-o verflow-checks`",
+        );
+
+    // No warning for Z_OPTIONS
+    rustc().input("main.rs").arg("-oom").run().assert_stderr_equals("");
+
+    // test no warning when there is space between `-o` and arg
+    rustc().input("main.rs").arg("-o").arg("ptimize").run().assert_stderr_equals("");
+    rustc().input("main.rs").arg("--out-dir").arg("xxx").run().assert_stderr_equals("");
+    rustc().input("main.rs").arg("-o").arg("out-dir").run().assert_stderr_equals("");
+}
-- 
cgit 1.4.1-3-g733a5


From 61fafa9244483e2e1cf2e64bd741b812ea4b1145 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Thu, 17 Jul 2025 00:49:56 +0800
Subject: Add tailexpr & -> &mut for generate_mut_trait_impl

---
 .../src/handlers/generate_mut_trait_impl.rs        | 23 ++++++++++++++++++----
 .../crates/ide-assists/src/tests/generated.rs      |  2 +-
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
index ac07d35e9ec..4ddab2cfad0 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
@@ -1,6 +1,6 @@
 use ide_db::{famous_defs::FamousDefs, traits::resolve_target_trait};
 use syntax::{
-    AstNode,
+    AstNode, T,
     ast::{self, edit_in_place::Indent, make},
     ted,
 };
@@ -32,7 +32,7 @@ use crate::{AssistContext, AssistId, Assists};
 //
 // $0impl<T> core::ops::IndexMut<Axis> for [T; 3] {
 //     fn index_mut(&mut self, index: Axis) -> &mut Self::Output {
-//         &self[index as usize]
+//         &mut self[index as usize]
 //     }
 // }
 //
@@ -92,6 +92,7 @@ pub(crate) fn generate_mut_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>
         ast::AssocItem::Fn(f) => Some(f),
         _ => None,
     })?;
+    let _ = process_ref_mut(&fn_);
 
     let assoc_list = make::assoc_item_list().clone_for_update();
     ted::replace(impl_def.assoc_item_list()?.syntax(), assoc_list.syntax());
@@ -108,6 +109,20 @@ pub(crate) fn generate_mut_trait_impl(acc: &mut Assists, ctx: &AssistContext<'_>
     )
 }
 
+fn process_ref_mut(fn_: &ast::Fn) -> Option<()> {
+    let expr = fn_.body()?.tail_expr()?;
+    match &expr {
+        ast::Expr::RefExpr(ref_expr) if ref_expr.mut_token().is_none() => {
+            ted::insert_all_raw(
+                ted::Position::after(ref_expr.amp_token()?),
+                vec![make::token(T![mut]).into(), make::tokens::whitespace(" ").into()],
+            );
+        }
+        _ => {}
+    }
+    None
+}
+
 fn get_trait_mut(apply_trait: &hir::Trait, famous: FamousDefs<'_, '_>) -> Option<&'static str> {
     let trait_ = Some(apply_trait);
     if trait_ == famous.core_convert_Index().as_ref() {
@@ -167,7 +182,7 @@ pub enum Axis { X = 0, Y = 1, Z = 2 }
 
 $0impl<T> core::ops::IndexMut<Axis> for [T; 3] {
     fn index_mut(&mut self, index: Axis) -> &mut Self::Output {
-        &self[index as usize]
+        &mut self[index as usize]
     }
 }
 
@@ -234,7 +249,7 @@ struct Foo(i32);
 
 $0impl core::convert::AsMut<i32> for Foo {
     fn as_mut(&mut self) -> &mut i32 {
-        &self.0
+        &mut self.0
     }
 }
 
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 72f7195cbd7..fe74694d8a4 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
@@ -1933,7 +1933,7 @@ pub enum Axis { X = 0, Y = 1, Z = 2 }
 
 $0impl<T> core::ops::IndexMut<Axis> for [T; 3] {
     fn index_mut(&mut self, index: Axis) -> &mut Self::Output {
-        &self[index as usize]
+        &mut self[index as usize]
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 9ef3be2f8662a6f65c02f7551bae0f7476da8211 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 16 Jul 2025 21:29:16 +0200
Subject: go over invariants again :3

Co-authored-by: Boxy <rust@boxyuwu.dev>
---
 src/doc/rustc-dev-guide/src/solve/invariants.md | 81 +++++++++++++++----------
 1 file changed, 48 insertions(+), 33 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/solve/invariants.md b/src/doc/rustc-dev-guide/src/solve/invariants.md
index fd12b195757..2f5a134f4df 100644
--- a/src/doc/rustc-dev-guide/src/solve/invariants.md
+++ b/src/doc/rustc-dev-guide/src/solve/invariants.md
@@ -11,10 +11,8 @@ It is important to know about the things you can assume while working on - and w
 type system, so here's an incomplete and unofficial list of invariants of
 the core type system:
 
-- ✅: this invariant mostly holds, with some weird exceptions, you can rely on it outside
-of these cases
-- ❌: this invariant does not hold, either due to bugs or by design, you must not rely on
-it for soundness or have to be incredibly careful when doing so
+- ✅: this invariant mostly holds, with some weird exceptions or current bugs
+- ❌: this invariant does not hold, and is unlikely to do so in the future; do not rely on it for soundness or have to be incredibly careful when doing so
 
 ### `wf(X)` implies `wf(normalize(X))` ✅
 
@@ -23,6 +21,8 @@ well-formed after normalizing said aliases. We rely on this as
 otherwise we would have to re-check for well-formedness for these
 types.
 
+This currently does not hold due to a type system unsoundness: [#84533](https://github.com/rust-lang/rust/issues/84533).
+
 ### Structural equality modulo regions implies semantic equality ✅
 
 If you have a some type and equate it to itself after replacing any regions with unique
@@ -36,7 +36,7 @@ If this invariant is broken MIR typeck ends up failing with an ICE.
 
 TODO: this invariant is formulated in a weird way and needs to be elaborated.
 Pretty much: I would like this check to only fail if there's a solver bug:
-https://github.com/rust-lang/rust/blob/2ffeb4636b4ae376f716dc4378a7efb37632dc2d/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs#L391-L407
+https://github.com/rust-lang/rust/blob/2ffeb4636b4ae376f716dc4378a7efb37632dc2d/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs#L391-L407 We should readd this check and see where it breaks :3
 
 If we prove some goal/equate types/whatever, apply the resulting inference constraints,
 and then redo the original action, the result should be the same.
@@ -73,40 +73,47 @@ Many of the currently known unsound issues end up relying on this invariant bein
 It is however very difficult to imagine a sound type system without this invariant, so
 the issue is that the invariant is broken, not that we incorrectly rely on it.
 
-### Generic goals and their instantiations have the same result ✅
+### The type system is complete ❌
+
+The type system is not complete, it often adds unnecessary inference constraints, and errors
+even though the goal could hold.
+
+- method selection
+- opaque type inference
+- handling type outlives constraints
+- preferring `ParamEnv` candidates over `Impl` candidates during candidate selection
+in the trait solver
+
+### Goals keep their result from HIR typeck afterwards ✅
 
-Pretty much: If we successfully typecheck a generic function concrete instantiations
-of that function should also typeck. We should not get errors post-monomorphization.
-We can however get overflow errors at that point.
+Having a goal which succeeds during HIR typeck but fails when being reevaluated during MIR borrowck causes ICE, e.g. [#140211](https://github.com/rust-lang/rust/issues/140211).
 
-TODO: example for overflow error post-monomorphization
+Having a goal which succeeds during HIR typeck but fails after being instantiated is unsound, e.g. [#140212](https://github.com/rust-lang/rust/issues/140212).
+
+It is interesting that we allow some incompleteness in the trait solver while still maintaining this limitation. It would be nice if there was a clear way to separate the "allowed incompleteness" from behavior which would break this invariant.
+
+#### Normalization must not change results
 
 This invariant is relied on to allow the normalization of generic aliases. Breaking
 it can easily result in unsoundness, e.g. [#57893](https://github.com/rust-lang/rust/issues/57893)
 
+#### Goals may still overflow after instantiation
+
+As they start to hit the recursion limit. We also have diverging aliases which are scuffed. It's unclear how these should be handled :3
+
 ### Trait goals in empty environments are proven by a unique impl ✅
 
 If a trait goal holds with an empty environment, there should be a unique `impl`,
 either user-defined or builtin, which is used to prove that goal. This is
-necessary to select a unique method.
+necessary to select unique methods and associated items.
 
 We do however break this invariant in few cases, some of which are due to bugs,
 some by design:
 - *marker traits* are allowed to overlap as they do not have associated items
 - *specialization* allows specializing impls to overlap with their parent
 - the builtin trait object trait implementation can overlap with a user-defined impl:
-[#57893]
+[#57893](https://github.com/rust-lang/rust/issues/57893)
 
-### The type system is complete ❌
-
-The type system is not complete, it often adds unnecessary inference constraints, and errors
-even though the goal could hold.
-
-- method selection
-- opaque type inference
-- handling type outlives constraints
-- preferring `ParamEnv` candidates over `Impl` candidates during candidate selection
-in the trait solver
 
 #### The type system is complete during the implicit negative overlap check in coherence ✅
 
@@ -121,18 +128,19 @@ We have to be careful as it is quite easy to break:
 - generalization of aliases
 - generalization during subtyping binders (luckily not exploitable in coherence)
 
-### Trait solving must be (free) lifetime agnostic ✅
+### Trait solving must not depend on lifetimes being different ✅
+
+If a goal holds with lifetimes being different, it must also hold with these lifetimes being the same. We otherwise get post-monomorphization errors during codegen or unsoundness due to invalid vtables.
+
+We could also just get inconsistent behavior when first proving a goal with different lifetimes which are later constrained to be equal.
 
-Trait solving during codegen should have the same result as during typeck. As we erase
-all free regions during codegen we must not rely on them during typeck. A noteworthy example
-is special behavior for `'static`.
+### Trait solving in bodies must not depend on lifetimes being equal ✅
 
 We also have to be careful with relying on equality of regions in the trait solver.
 This is fine for codegen, as we treat all erased regions as equal. We can however
 lose equality information from HIR to MIR typeck.
 
-The new solver "uniquifies regions" during canonicalization, canonicalizing `u32: Trait<'x, 'x>`
-as `exists<'0, '1> u32: Trait<'0, '1>`, to make it harder to rely on this property.
+This currently does not hold with the new solver: [trait-system-refactor-initiative#27](https://github.com/rust-lang/trait-system-refactor-initiative/issues/27).
 
 ### Removing ambiguity makes strictly more things compile ❌
 
@@ -146,9 +154,16 @@ changes, breaking existing projects.
 
 Two types being equal in the type system must mean that they have the
 same `TypeId` after instantiating their generic parameters with concrete
-arguments. This currently does not hold: [#97156].
+arguments. We can otherwise use their different `TypeId`s to impact trait selection.
+
+We lookup types using structural equality during codegen, but this shouldn't necessarily be unsound
+- may result in redundant method codegen or backend type check errors?
+- we also rely on it in CTFE assertions
+
+### Semantically different types have different `TypeId`s ✅
+
+Semantically different `'static` types need different `TypeId`s to avoid transmutes,
+for example `for<'a> fn(&'a str)` vs `fn(&'static str)` must have a different `TypeId`.
+
 
-[#57893]: https://github.com/rust-lang/rust/issues/57893
-[#97156]: https://github.com/rust-lang/rust/issues/97156
-[#114936]: https://github.com/rust-lang/rust/issues/114936
-[coherence]:  ../coherence.md
+[coherence]: ../coherence.md
-- 
cgit 1.4.1-3-g733a5


From f100767dce1fcc0287047053cc29659ac5321a6b Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Tue, 1 Jul 2025 20:02:31 +0200
Subject: fix `-Zsanitizer=kcfi` on `#[naked]` functions

And more broadly only codegen `InstanceKind::Item` using the naked
function codegen code. Other instance kinds should follow the normal
path.
---
 compiler/rustc_codegen_cranelift/src/driver/aot.rs |  8 +++-
 compiler/rustc_codegen_ssa/src/mono_item.rs        | 13 +++---
 tests/codegen/sanitizer/kcfi/naked-function.rs     | 47 ++++++++++++++++++++++
 tests/ui/asm/naked-function-shim.rs                | 31 ++++++++++++++
 4 files changed, 91 insertions(+), 8 deletions(-)
 create mode 100644 tests/codegen/sanitizer/kcfi/naked-function.rs
 create mode 100644 tests/ui/asm/naked-function-shim.rs

diff --git a/compiler/rustc_codegen_cranelift/src/driver/aot.rs b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
index 442151fe32d..727f2760c0f 100644
--- a/compiler/rustc_codegen_cranelift/src/driver/aot.rs
+++ b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
@@ -530,8 +530,12 @@ fn codegen_cgu_content(
     for (mono_item, item_data) in mono_items {
         match mono_item {
             MonoItem::Fn(instance) => {
-                if tcx.codegen_fn_attrs(instance.def_id()).flags.contains(CodegenFnAttrFlags::NAKED)
-                {
+                // Other `InstanceKind`s (e.g. `ReifyShim` generated by indirect calls) should be
+                // codegened like a normal function.
+                let is_item_instance = matches!(instance.def, InstanceKind::Item(_));
+
+                let flags = tcx.codegen_fn_attrs(instance.def_id()).flags;
+                if is_item_instance && flags.contains(CodegenFnAttrFlags::NAKED) {
                     rustc_codegen_ssa::mir::naked_asm::codegen_naked_asm(
                         &mut GlobalAsmContext { tcx, global_asm: &mut cx.global_asm },
                         instance,
diff --git a/compiler/rustc_codegen_ssa/src/mono_item.rs b/compiler/rustc_codegen_ssa/src/mono_item.rs
index 7b4268abe4b..fa0ef04b2e6 100644
--- a/compiler/rustc_codegen_ssa/src/mono_item.rs
+++ b/compiler/rustc_codegen_ssa/src/mono_item.rs
@@ -1,5 +1,6 @@
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mir::mono::{Linkage, MonoItem, MonoItemData, Visibility};
+use rustc_middle::ty::InstanceKind;
 use rustc_middle::ty::layout::HasTyCtxt;
 use tracing::debug;
 
@@ -41,12 +42,12 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
                 base::codegen_global_asm(cx, item_id);
             }
             MonoItem::Fn(instance) => {
-                if cx
-                    .tcx()
-                    .codegen_fn_attrs(instance.def_id())
-                    .flags
-                    .contains(CodegenFnAttrFlags::NAKED)
-                {
+                // Other `InstanceKind`s (e.g. `ReifyShim` generated by indirect calls) should be
+                // codegened like a normal function.
+                let is_item_instance = matches!(instance.def, InstanceKind::Item(_));
+
+                let flags = cx.tcx().codegen_fn_attrs(instance.def_id()).flags;
+                if is_item_instance && flags.contains(CodegenFnAttrFlags::NAKED) {
                     naked_asm::codegen_naked_asm::<Bx::CodegenCx>(cx, instance, item_data);
                 } else {
                     base::codegen_instance::<Bx>(cx, instance);
diff --git a/tests/codegen/sanitizer/kcfi/naked-function.rs b/tests/codegen/sanitizer/kcfi/naked-function.rs
new file mode 100644
index 00000000000..92431fc7d63
--- /dev/null
+++ b/tests/codegen/sanitizer/kcfi/naked-function.rs
@@ -0,0 +1,47 @@
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components: x86
+//@ compile-flags: -Ctarget-feature=-crt-static -Zsanitizer=kcfi -Cno-prepopulate-passes -Copt-level=0
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+struct Thing;
+trait MyTrait {
+    #[unsafe(naked)]
+    extern "C" fn my_naked_function() {
+        // the real function is defined
+        // CHECK: .globl
+        // CHECK-SAME: my_naked_function
+        naked_asm!("ret")
+    }
+}
+impl MyTrait for Thing {}
+
+// CHECK-LABEL: main
+#[unsafe(no_mangle)]
+pub fn main() {
+    // Trick the compiler into generating an indirect call.
+    const F: extern "C" fn() = Thing::my_naked_function;
+
+    // main calls the shim function
+    // CHECK: call
+    // CHECK-SAME: my_naked_function
+    // CHECK-SAME: reify.shim.fnptr
+    (F)();
+}
+
+// the shim calls the real function
+// CHECK: define
+// CHECK-SAME: my_naked_function
+// CHECK-SAME: reify.shim.fnptr
+
+// CHECK: declare !kcfi_type
+// CHECK-SAME: my_naked_function
diff --git a/tests/ui/asm/naked-function-shim.rs b/tests/ui/asm/naked-function-shim.rs
new file mode 100644
index 00000000000..4694d0cd963
--- /dev/null
+++ b/tests/ui/asm/naked-function-shim.rs
@@ -0,0 +1,31 @@
+// The indirect call will generate a shim that then calls the actual function. Test that
+// this is handled correctly. See also https://github.com/rust-lang/rust/issues/143266.
+
+//@ build-pass
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components: x86
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+trait MyTrait {
+    #[unsafe(naked)]
+    extern "C" fn foo(&self) {
+        naked_asm!("ret")
+    }
+}
+
+impl MyTrait for i32 {}
+
+fn main() {
+    let x: extern "C" fn(&_) = <dyn MyTrait as MyTrait>::foo;
+    x(&1);
+}
-- 
cgit 1.4.1-3-g733a5


From ec0ff720d1a89cb51edd90116c6e70051affa95f Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 2 Jul 2025 10:46:15 +0200
Subject: add `codegen_instance_attrs` query

and use it for naked functions
---
 compiler/rustc_codegen_cranelift/src/driver/aot.rs   |  8 ++------
 compiler/rustc_codegen_ssa/src/codegen_attrs.rs      |  1 +
 compiler/rustc_codegen_ssa/src/mir/debuginfo.rs      |  2 +-
 compiler/rustc_codegen_ssa/src/mir/mod.rs            |  5 ++---
 compiler/rustc_codegen_ssa/src/mono_item.rs          |  9 ++-------
 compiler/rustc_middle/src/middle/codegen_fn_attrs.rs | 20 ++++++++++++++++++++
 tests/codegen/sanitizer/kcfi/naked-function.rs       | 12 ++++++------
 7 files changed, 34 insertions(+), 23 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/src/driver/aot.rs b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
index 727f2760c0f..8ec3599b63d 100644
--- a/compiler/rustc_codegen_cranelift/src/driver/aot.rs
+++ b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
@@ -530,12 +530,8 @@ fn codegen_cgu_content(
     for (mono_item, item_data) in mono_items {
         match mono_item {
             MonoItem::Fn(instance) => {
-                // Other `InstanceKind`s (e.g. `ReifyShim` generated by indirect calls) should be
-                // codegened like a normal function.
-                let is_item_instance = matches!(instance.def, InstanceKind::Item(_));
-
-                let flags = tcx.codegen_fn_attrs(instance.def_id()).flags;
-                if is_item_instance && flags.contains(CodegenFnAttrFlags::NAKED) {
+                let flags = tcx.codegen_instance_attrs(instance.def).flags;
+                if flags.contains(CodegenFnAttrFlags::NAKED) {
                     rustc_codegen_ssa::mir::naked_asm::codegen_naked_asm(
                         &mut GlobalAsmContext { tcx, global_asm: &mut cx.global_asm },
                         instance,
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 85d01d4f938..a1dd64736fc 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -114,6 +114,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                     codegen_fn_attrs.export_name = Some(*name);
                 }
                 AttributeKind::Naked(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED,
+
                 AttributeKind::Align { align, .. } => codegen_fn_attrs.alignment = Some(*align),
                 AttributeKind::LinkName { name, .. } => codegen_fn_attrs.link_name = Some(*name),
                 AttributeKind::LinkSection { name, .. } => {
diff --git a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
index 025f5fb54f4..b8f635ab781 100644
--- a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
@@ -356,7 +356,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             LocalRef::Operand(operand) => {
                 // Don't spill operands onto the stack in naked functions.
                 // See: https://github.com/rust-lang/rust/issues/42779
-                let attrs = bx.tcx().codegen_fn_attrs(self.instance.def_id());
+                let attrs = bx.tcx().codegen_instance_attrs(self.instance.def);
                 if attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
                     return;
                 }
diff --git a/compiler/rustc_codegen_ssa/src/mir/mod.rs b/compiler/rustc_codegen_ssa/src/mir/mod.rs
index fa69820d5d2..50d0f910744 100644
--- a/compiler/rustc_codegen_ssa/src/mir/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -390,9 +390,8 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
     let mut num_untupled = None;
 
-    let codegen_fn_attrs = bx.tcx().codegen_fn_attrs(fx.instance.def_id());
-    let naked = codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NAKED);
-    if naked {
+    let codegen_fn_attrs = bx.tcx().codegen_instance_attrs(fx.instance.def);
+    if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
         return vec![];
     }
 
diff --git a/compiler/rustc_codegen_ssa/src/mono_item.rs b/compiler/rustc_codegen_ssa/src/mono_item.rs
index fa0ef04b2e6..2c3a6de750e 100644
--- a/compiler/rustc_codegen_ssa/src/mono_item.rs
+++ b/compiler/rustc_codegen_ssa/src/mono_item.rs
@@ -1,6 +1,5 @@
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mir::mono::{Linkage, MonoItem, MonoItemData, Visibility};
-use rustc_middle::ty::InstanceKind;
 use rustc_middle::ty::layout::HasTyCtxt;
 use tracing::debug;
 
@@ -42,12 +41,8 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
                 base::codegen_global_asm(cx, item_id);
             }
             MonoItem::Fn(instance) => {
-                // Other `InstanceKind`s (e.g. `ReifyShim` generated by indirect calls) should be
-                // codegened like a normal function.
-                let is_item_instance = matches!(instance.def, InstanceKind::Item(_));
-
-                let flags = cx.tcx().codegen_fn_attrs(instance.def_id()).flags;
-                if is_item_instance && flags.contains(CodegenFnAttrFlags::NAKED) {
+                let flags = cx.tcx().codegen_instance_attrs(instance.def).flags;
+                if flags.contains(CodegenFnAttrFlags::NAKED) {
                     naked_asm::codegen_naked_asm::<Bx::CodegenCx>(cx, instance, item_data);
                 } else {
                     base::codegen_instance::<Bx>(cx, instance);
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
index 2f16d385efb..92670e7e018 100644
--- a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
+++ b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use rustc_abi::Align;
 use rustc_ast::expand::autodiff_attrs::AutoDiffAttrs;
 use rustc_attr_data_structures::{InlineAttr, InstructionSetAttr, OptimizeAttr};
@@ -6,6 +8,24 @@ use rustc_span::Symbol;
 use rustc_target::spec::SanitizerSet;
 
 use crate::mir::mono::Linkage;
+use crate::ty::{InstanceKind, TyCtxt};
+
+impl<'tcx> TyCtxt<'tcx> {
+    pub fn codegen_instance_attrs(
+        self,
+        instance_kind: InstanceKind<'_>,
+    ) -> Cow<'tcx, CodegenFnAttrs> {
+        let mut attrs = Cow::Borrowed(self.codegen_fn_attrs(instance_kind.def_id()));
+
+        // Drop the `#[naked]` attribute on non-item `InstanceKind`s, like the shims that
+        // are generated for indirect function calls.
+        if !matches!(instance_kind, InstanceKind::Item(_)) {
+            attrs.to_mut().flags.remove(CodegenFnAttrFlags::NAKED);
+        }
+
+        attrs
+    }
+}
 
 #[derive(Clone, TyEncodable, TyDecodable, HashStable, Debug)]
 pub struct CodegenFnAttrs {
diff --git a/tests/codegen/sanitizer/kcfi/naked-function.rs b/tests/codegen/sanitizer/kcfi/naked-function.rs
index 92431fc7d63..2c8cdc919b8 100644
--- a/tests/codegen/sanitizer/kcfi/naked-function.rs
+++ b/tests/codegen/sanitizer/kcfi/naked-function.rs
@@ -25,6 +25,11 @@ trait MyTrait {
 }
 impl MyTrait for Thing {}
 
+// the shim calls the real function
+// CHECK-LABEL: define
+// CHECK-SAME: my_naked_function
+// CHECK-SAME: reify.shim.fnptr
+
 // CHECK-LABEL: main
 #[unsafe(no_mangle)]
 pub fn main() {
@@ -32,16 +37,11 @@ pub fn main() {
     const F: extern "C" fn() = Thing::my_naked_function;
 
     // main calls the shim function
-    // CHECK: call
+    // CHECK: call void
     // CHECK-SAME: my_naked_function
     // CHECK-SAME: reify.shim.fnptr
     (F)();
 }
 
-// the shim calls the real function
-// CHECK: define
-// CHECK-SAME: my_naked_function
-// CHECK-SAME: reify.shim.fnptr
-
 // CHECK: declare !kcfi_type
 // CHECK-SAME: my_naked_function
-- 
cgit 1.4.1-3-g733a5


From b390c413882205de0716de3464f409d87f309d25 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 16 Jul 2025 19:42:52 +0200
Subject: triagebot: tweak welcome message

---
 src/tools/miri/triagebot.toml | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/tools/miri/triagebot.toml b/src/tools/miri/triagebot.toml
index c109b620846..9352ac73424 100644
--- a/src/tools/miri/triagebot.toml
+++ b/src/tools/miri/triagebot.toml
@@ -16,17 +16,12 @@ allow-unauthenticated = [
 # Enables assigning users to issues and PRs.
 [assign]
 warn_non_default_branch = true
-contributing_url = "https://github.com/rust-lang/miri/blob/master/CONTRIBUTING.md"
+contributing_url = "https://github.com/rust-lang/miri/blob/master/CONTRIBUTING.md#pr-review-process"
 [assign.custom_welcome_messages]
-welcome-message = """
-Welcome, and thank you for contributing to Miri!
-To ensure a smooth reviewing experience, please read https://github.com/rust-lang/miri/blob/master/CONTRIBUTING.md#pr-review-process.
-In particular, please do not force-push to the PR branch except when you need to rebase due to a conflict or when the reviewer asks you for it.
-"""
+welcome-message = "(unused)"
 welcome-message-no-reviewer = """
-Welcome, and thank you for contributing to Miri!
-To ensure a smooth reviewing experience, please read https://github.com/rust-lang/miri/blob/master/CONTRIBUTING.md#pr-review-process.
-In particular, please do not force-push to the PR branch except when you need to rebase due to a conflict or when the reviewer asks you for it.
+Thank you for contributing to Miri!
+Please remember to not force-push to the PR branch except when you need to rebase due to a conflict or when the reviewer asks you for it.
 """
 
 [no-merges]
-- 
cgit 1.4.1-3-g733a5


From 6728da5396b3ac80e2b6b53027c4f7cea4dbba02 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 16 Jul 2025 22:17:16 +0200
Subject: set S-waiting-on labels on new PRs

---
 src/tools/miri/triagebot.toml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/tools/miri/triagebot.toml b/src/tools/miri/triagebot.toml
index 9352ac73424..a0ce9f80024 100644
--- a/src/tools/miri/triagebot.toml
+++ b/src/tools/miri/triagebot.toml
@@ -44,6 +44,12 @@ remove = []
 add = ["S-waiting-on-author"]
 unless = ["S-blocked", "S-waiting-on-team", "S-waiting-on-review"]
 
+[autolabel."S-waiting-on-review"]
+new_pr = true
+
+[autolabel."S-waiting-on-author"]
+new_draft = true
+
 # Automatically close and reopen PRs made by bots to run CI on them
 [bot-pull-requests]
 
-- 
cgit 1.4.1-3-g733a5


From 9c8ab891876b37aac458a7461d904fe593856745 Mon Sep 17 00:00:00 2001
From: Folkert de Vries <folkert@folkertdev.nl>
Date: Wed, 2 Jul 2025 11:12:54 +0200
Subject: use `codegen_instance_attrs` where an instance is (easily) available

---
 compiler/rustc_codegen_cranelift/src/driver/jit.rs   |  2 +-
 compiler/rustc_codegen_cranelift/src/driver/mod.rs   |  2 +-
 compiler/rustc_codegen_gcc/src/attributes.rs         |  2 +-
 compiler/rustc_codegen_gcc/src/callee.rs             |  2 +-
 compiler/rustc_codegen_gcc/src/mono_item.rs          |  2 +-
 compiler/rustc_codegen_llvm/src/attributes.rs        |  2 +-
 compiler/rustc_codegen_llvm/src/callee.rs            |  2 +-
 compiler/rustc_codegen_llvm/src/mono_item.rs         |  4 ++--
 compiler/rustc_codegen_ssa/src/codegen_attrs.rs      |  1 -
 compiler/rustc_codegen_ssa/src/mir/naked_asm.rs      |  2 +-
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs         | 12 ++++++++++--
 compiler/rustc_codegen_ssa/src/mono_item.rs          |  2 +-
 compiler/rustc_const_eval/src/interpret/memory.rs    |  2 +-
 compiler/rustc_middle/src/middle/codegen_fn_attrs.rs |  4 +++-
 compiler/rustc_middle/src/mir/mono.rs                | 13 ++++++-------
 compiler/rustc_middle/src/query/mod.rs               |  9 +++++++++
 compiler/rustc_symbol_mangling/src/lib.rs            |  2 +-
 src/tools/miri/src/machine.rs                        |  4 ++--
 18 files changed, 43 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/src/driver/jit.rs b/compiler/rustc_codegen_cranelift/src/driver/jit.rs
index b1f185b551c..b3497503bf0 100644
--- a/compiler/rustc_codegen_cranelift/src/driver/jit.rs
+++ b/compiler/rustc_codegen_cranelift/src/driver/jit.rs
@@ -127,7 +127,7 @@ fn codegen_and_compile_fn<'tcx>(
     module: &mut dyn Module,
     instance: Instance<'tcx>,
 ) {
-    if tcx.codegen_fn_attrs(instance.def_id()).flags.contains(CodegenFnAttrFlags::NAKED) {
+    if tcx.codegen_instance_attrs(instance.def).flags.contains(CodegenFnAttrFlags::NAKED) {
         tcx.dcx()
             .span_fatal(tcx.def_span(instance.def_id()), "Naked asm is not supported in JIT mode");
     }
diff --git a/compiler/rustc_codegen_cranelift/src/driver/mod.rs b/compiler/rustc_codegen_cranelift/src/driver/mod.rs
index ffd47cace38..8f83c30b598 100644
--- a/compiler/rustc_codegen_cranelift/src/driver/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/driver/mod.rs
@@ -35,7 +35,7 @@ fn predefine_mono_items<'tcx>(
                         is_compiler_builtins,
                     );
                     let is_naked = tcx
-                        .codegen_fn_attrs(instance.def_id())
+                        .codegen_instance_attrs(instance.def)
                         .flags
                         .contains(CodegenFnAttrFlags::NAKED);
                     module
diff --git a/compiler/rustc_codegen_gcc/src/attributes.rs b/compiler/rustc_codegen_gcc/src/attributes.rs
index bf0927dc590..7a1ae6ca9c8 100644
--- a/compiler/rustc_codegen_gcc/src/attributes.rs
+++ b/compiler/rustc_codegen_gcc/src/attributes.rs
@@ -87,7 +87,7 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
     #[cfg_attr(not(feature = "master"), allow(unused_variables))] func: Function<'gcc>,
     instance: ty::Instance<'tcx>,
 ) {
-    let codegen_fn_attrs = cx.tcx.codegen_fn_attrs(instance.def_id());
+    let codegen_fn_attrs = cx.tcx.codegen_instance_attrs(instance.def);
 
     #[cfg(feature = "master")]
     {
diff --git a/compiler/rustc_codegen_gcc/src/callee.rs b/compiler/rustc_codegen_gcc/src/callee.rs
index 189ac7cd779..e7ca95af594 100644
--- a/compiler/rustc_codegen_gcc/src/callee.rs
+++ b/compiler/rustc_codegen_gcc/src/callee.rs
@@ -105,7 +105,7 @@ pub fn get_fn<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, instance: Instance<'tcx>)
             let is_hidden = if is_generic {
                 // This is a monomorphization of a generic function.
                 if !(cx.tcx.sess.opts.share_generics()
-                    || tcx.codegen_fn_attrs(instance_def_id).inline
+                    || tcx.codegen_instance_attrs(instance.def).inline
                         == rustc_attr_data_structures::InlineAttr::Never)
                 {
                     // When not sharing generics, all instances are in the same
diff --git a/compiler/rustc_codegen_gcc/src/mono_item.rs b/compiler/rustc_codegen_gcc/src/mono_item.rs
index 539e3ac8507..51f35cbdee4 100644
--- a/compiler/rustc_codegen_gcc/src/mono_item.rs
+++ b/compiler/rustc_codegen_gcc/src/mono_item.rs
@@ -53,7 +53,7 @@ impl<'gcc, 'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         let fn_abi = self.fn_abi_of_instance(instance, ty::List::empty());
         self.linkage.set(base::linkage_to_gcc(linkage));
         let decl = self.declare_fn(symbol_name, fn_abi);
-        //let attrs = self.tcx.codegen_fn_attrs(instance.def_id());
+        //let attrs = self.tcx.codegen_instance_attrs(instance.def);
 
         attributes::from_fn_attrs(self, decl, instance);
 
diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index 1ea5a062254..c32f11b27f3 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -344,7 +344,7 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
     llfn: &'ll Value,
     instance: ty::Instance<'tcx>,
 ) {
-    let codegen_fn_attrs = cx.tcx.codegen_fn_attrs(instance.def_id());
+    let codegen_fn_attrs = cx.tcx.codegen_instance_attrs(instance.def);
 
     let mut to_add = SmallVec::<[_; 16]>::new();
 
diff --git a/compiler/rustc_codegen_llvm/src/callee.rs b/compiler/rustc_codegen_llvm/src/callee.rs
index 6d68eca60af..5a3dd90ab24 100644
--- a/compiler/rustc_codegen_llvm/src/callee.rs
+++ b/compiler/rustc_codegen_llvm/src/callee.rs
@@ -102,7 +102,7 @@ pub(crate) fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'t
         let is_hidden = if is_generic {
             // This is a monomorphization of a generic function.
             if !(cx.tcx.sess.opts.share_generics()
-                || tcx.codegen_fn_attrs(instance_def_id).inline
+                || tcx.codegen_instance_attrs(instance.def).inline
                     == rustc_attr_data_structures::InlineAttr::Never)
             {
                 // When not sharing generics, all instances are in the same
diff --git a/compiler/rustc_codegen_llvm/src/mono_item.rs b/compiler/rustc_codegen_llvm/src/mono_item.rs
index 3f38e1e191b..c471a02baa2 100644
--- a/compiler/rustc_codegen_llvm/src/mono_item.rs
+++ b/compiler/rustc_codegen_llvm/src/mono_item.rs
@@ -55,8 +55,8 @@ impl<'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
         let fn_abi = self.fn_abi_of_instance(instance, ty::List::empty());
         let lldecl = self.declare_fn(symbol_name, fn_abi, Some(instance));
         llvm::set_linkage(lldecl, base::linkage_to_llvm(linkage));
-        let attrs = self.tcx.codegen_fn_attrs(instance.def_id());
-        base::set_link_section(lldecl, attrs);
+        let attrs = self.tcx.codegen_instance_attrs(instance.def);
+        base::set_link_section(lldecl, &attrs);
         if (linkage == Linkage::LinkOnceODR || linkage == Linkage::WeakODR)
             && self.tcx.sess.target.supports_comdat()
         {
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index a1dd64736fc..85d01d4f938 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -114,7 +114,6 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                     codegen_fn_attrs.export_name = Some(*name);
                 }
                 AttributeKind::Naked(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED,
-
                 AttributeKind::Align { align, .. } => codegen_fn_attrs.alignment = Some(*align),
                 AttributeKind::LinkName { name, .. } => codegen_fn_attrs.link_name = Some(*name),
                 AttributeKind::LinkSection { name, .. } => {
diff --git a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
index beaf8950978..42e435cf0a3 100644
--- a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
@@ -128,7 +128,7 @@ fn prefix_and_suffix<'tcx>(
     let is_arm = tcx.sess.target.arch == "arm";
     let is_thumb = tcx.sess.unstable_target_features.contains(&sym::thumb_mode);
 
-    let attrs = tcx.codegen_fn_attrs(instance.def_id());
+    let attrs = tcx.codegen_instance_attrs(instance.def);
     let link_section = attrs.link_section.map(|symbol| symbol.as_str().to_string());
 
     // If no alignment is specified, an alignment of 4 bytes is used.
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index e90463aacc8..2587e89417a 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -611,11 +611,19 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     let fn_abi = bx.fn_abi_of_instance(instance, ty::List::empty());
                     let fn_ty = bx.fn_decl_backend_type(fn_abi);
                     let fn_attrs = if bx.tcx().def_kind(instance.def_id()).has_codegen_attrs() {
-                        Some(bx.tcx().codegen_fn_attrs(instance.def_id()))
+                        Some(bx.tcx().codegen_instance_attrs(instance.def))
                     } else {
                         None
                     };
-                    bx.call(fn_ty, fn_attrs, Some(fn_abi), fn_ptr, &[], None, Some(instance))
+                    bx.call(
+                        fn_ty,
+                        fn_attrs.as_deref(),
+                        Some(fn_abi),
+                        fn_ptr,
+                        &[],
+                        None,
+                        Some(instance),
+                    )
                 } else {
                     bx.get_static(def_id)
                 };
diff --git a/compiler/rustc_codegen_ssa/src/mono_item.rs b/compiler/rustc_codegen_ssa/src/mono_item.rs
index 2c3a6de750e..b9040c330fb 100644
--- a/compiler/rustc_codegen_ssa/src/mono_item.rs
+++ b/compiler/rustc_codegen_ssa/src/mono_item.rs
@@ -71,7 +71,7 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
                 cx.predefine_static(def_id, linkage, visibility, symbol_name);
             }
             MonoItem::Fn(instance) => {
-                let attrs = cx.tcx().codegen_fn_attrs(instance.def_id());
+                let attrs = cx.tcx().codegen_instance_attrs(instance.def);
 
                 if attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
                     // do not define this function; it will become a global assembly block
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 6414821e21d..0dd274b1b00 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -890,7 +890,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         if let Some(fn_val) = self.get_fn_alloc(id) {
             let align = match fn_val {
                 FnVal::Instance(instance) => {
-                    self.tcx.codegen_fn_attrs(instance.def_id()).alignment.unwrap_or(Align::ONE)
+                    self.tcx.codegen_instance_attrs(instance.def).alignment.unwrap_or(Align::ONE)
                 }
                 // Machine-specific extra functions currently do not support alignment restrictions.
                 FnVal::Other(_) => Align::ONE,
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
index 92670e7e018..6eae3b51e29 100644
--- a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
+++ b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -20,7 +20,9 @@ impl<'tcx> TyCtxt<'tcx> {
         // Drop the `#[naked]` attribute on non-item `InstanceKind`s, like the shims that
         // are generated for indirect function calls.
         if !matches!(instance_kind, InstanceKind::Item(_)) {
-            attrs.to_mut().flags.remove(CodegenFnAttrFlags::NAKED);
+            if attrs.flags.contains(CodegenFnAttrFlags::NAKED) {
+                attrs.to_mut().flags.remove(CodegenFnAttrFlags::NAKED);
+            }
         }
 
         attrs
diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs
index 47ba850d50d..2d7ddd105bd 100644
--- a/compiler/rustc_middle/src/mir/mono.rs
+++ b/compiler/rustc_middle/src/mir/mono.rs
@@ -152,7 +152,7 @@ impl<'tcx> MonoItem<'tcx> {
         // If the function is #[naked] or contains any other attribute that requires exactly-once
         // instantiation:
         // We emit an unused_attributes lint for this case, which should be kept in sync if possible.
-        let codegen_fn_attrs = tcx.codegen_fn_attrs(instance.def_id());
+        let codegen_fn_attrs = tcx.codegen_instance_attrs(instance.def);
         if codegen_fn_attrs.contains_extern_indicator()
             || codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NAKED)
         {
@@ -219,7 +219,7 @@ impl<'tcx> MonoItem<'tcx> {
         // functions the same as those that unconditionally get LocalCopy codegen. It's only when
         // we get here that we can at least not codegen a #[inline(never)] generic function in all
         // of our CGUs.
-        if let InlineAttr::Never = tcx.codegen_fn_attrs(instance.def_id()).inline
+        if let InlineAttr::Never = codegen_fn_attrs.inline
             && self.is_generic_fn()
         {
             return InstantiationMode::GloballyShared { may_conflict: true };
@@ -234,14 +234,13 @@ impl<'tcx> MonoItem<'tcx> {
     }
 
     pub fn explicit_linkage(&self, tcx: TyCtxt<'tcx>) -> Option<Linkage> {
-        let def_id = match *self {
-            MonoItem::Fn(ref instance) => instance.def_id(),
-            MonoItem::Static(def_id) => def_id,
+        let instance_kind = match *self {
+            MonoItem::Fn(ref instance) => instance.def,
+            MonoItem::Static(def_id) => InstanceKind::Item(def_id),
             MonoItem::GlobalAsm(..) => return None,
         };
 
-        let codegen_fn_attrs = tcx.codegen_fn_attrs(def_id);
-        codegen_fn_attrs.linkage
+        tcx.codegen_instance_attrs(instance_kind).linkage
     }
 
     /// Returns `true` if this instance is instantiable - whether it has no unsatisfied
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 842d118449a..ec9f6d918e2 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1505,6 +1505,15 @@ rustc_queries! {
         separate_provide_extern
     }
 
+    /// Returns the `CodegenFnAttrs` for the item at `def_id`.
+    ///
+    /// If possible, use `tcx.codegen_instance_attrs` instead. That function takes the
+    /// instance kind into account.
+    ///
+    /// For example, the `#[naked]` attribute should be applied for `InstanceKind::Item`,
+    /// but should not be applied if the instance kind is `InstanceKind::ReifyShim`.
+    /// Using this query would include the attribute regardless of the actual instance
+    /// kind at the call site.
     query codegen_fn_attrs(def_id: DefId) -> &'tcx CodegenFnAttrs {
         desc { |tcx| "computing codegen attributes of `{}`", tcx.def_path_str(def_id) }
         arena_cache
diff --git a/compiler/rustc_symbol_mangling/src/lib.rs b/compiler/rustc_symbol_mangling/src/lib.rs
index a9bf5eae445..6bcb7f6e093 100644
--- a/compiler/rustc_symbol_mangling/src/lib.rs
+++ b/compiler/rustc_symbol_mangling/src/lib.rs
@@ -180,7 +180,7 @@ fn compute_symbol_name<'tcx>(
 
     // FIXME(eddyb) Precompute a custom symbol name based on attributes.
     let attrs = if tcx.def_kind(def_id).has_codegen_attrs() {
-        tcx.codegen_fn_attrs(def_id)
+        &tcx.codegen_instance_attrs(instance.def)
     } else {
         CodegenFnAttrs::EMPTY
     };
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 35399dbf4cb..e8ae3350e56 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1086,7 +1086,7 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         ecx: &MiriInterpCx<'tcx>,
         instance: ty::Instance<'tcx>,
     ) -> InterpResult<'tcx> {
-        let attrs = ecx.tcx.codegen_fn_attrs(instance.def_id());
+        let attrs = ecx.tcx.codegen_instance_attrs(instance.def);
         if attrs
             .target_features
             .iter()
@@ -1790,7 +1790,7 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
                 ecx.tcx.sess.opts.unstable_opts.cross_crate_inline_threshold,
                 InliningThreshold::Always
             ) || !matches!(
-                ecx.tcx.codegen_fn_attrs(instance.def_id()).inline,
+                ecx.tcx.codegen_instance_attrs(instance.def).inline,
                 InlineAttr::Never
             );
             !is_generic && !can_be_inlined
-- 
cgit 1.4.1-3-g733a5


From fb7aa9e4fdb88a4833274303899b9801ef924100 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 May 2025 15:51:47 +1000
Subject: Improve path segment joining.

There are many places that join path segments with `::` to produce a
string. A lot of these use `join("::")`. Many in rustdoc use
`join_with_double_colon`, and a few use `.joined("..")`. One in Clippy
uses `itertools::join`. A couple of them look for `kw::PathRoot` in the
first segment, which can be important.

This commit introduces `rustc_ast::join_path_{syms,ident}` to do the
joining for everyone. `rustc_ast` is as good a location for these as
any, being the earliest-running of the several crates with a `Path`
type. Two functions are needed because `Ident` printing is more complex
than simple `Symbol` printing.

The commit also removes `join_with_double_colon`, and
`estimate_item_path_byte_length` with it.

There are still a handful of places that join strings with "::" that are
unchanged. They are not that important: some of them are in tests, and
some of them first split a path around "::" and then rejoin with "::".

This fixes one test case where `{{root}}` shows up in an error message.
---
 compiler/rustc_ast/src/ast.rs                      | 55 +++++++++++++++++++++-
 compiler/rustc_builtin_macros/src/source_util.rs   |  4 +-
 compiler/rustc_builtin_macros/src/test.rs          |  9 +---
 compiler/rustc_hir/src/hir.rs                      |  4 +-
 .../src/method/prelude_edition_lints.rs            | 11 ++---
 compiler/rustc_passes/src/check_attr.rs            |  6 +--
 compiler/rustc_resolve/src/diagnostics.rs          | 29 ++++++------
 compiler/rustc_resolve/src/rustdoc.rs              | 10 ++--
 src/librustdoc/clean/utils.rs                      | 11 ++---
 src/librustdoc/formats/cache.rs                    |  4 +-
 src/librustdoc/html/format.rs                      | 23 +++------
 src/librustdoc/html/render/context.rs              |  4 +-
 src/librustdoc/html/render/mod.rs                  |  9 ++--
 src/librustdoc/html/render/print_item.rs           |  9 ++--
 src/librustdoc/html/render/search_index.rs         | 14 +++---
 src/librustdoc/html/render/write_shared.rs         |  4 +-
 src/librustdoc/html/url_parts_builder.rs           | 12 +----
 .../src/methods/from_iter_instead_of_collect.rs    |  3 +-
 src/tools/clippy/clippy_utils/src/lib.rs           | 17 +++----
 tests/ui/asm/naked-invalid-attr.stderr             |  2 +-
 20 files changed, 130 insertions(+), 110 deletions(-)

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 3c576316f62..fa542a810dc 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -18,7 +18,7 @@
 //! - [`Attribute`]: Metadata associated with item.
 //! - [`UnOp`], [`BinOp`], and [`BinOpKind`]: Unary and binary operators.
 
-use std::borrow::Cow;
+use std::borrow::{Borrow, Cow};
 use std::{cmp, fmt};
 
 pub use GenericArgs::*;
@@ -155,6 +155,59 @@ impl Path {
     }
 }
 
+/// Joins multiple symbols with "::" into a path, e.g. "a::b::c". If the first
+/// segment is `kw::PathRoot` it will be printed as empty, e.g. "::b::c".
+///
+/// The generics on the `path` argument mean it can accept many forms, such as:
+/// - `&[Symbol]`
+/// - `Vec<Symbol>`
+/// - `Vec<&Symbol>`
+/// - `impl Iterator<Item = Symbol>`
+/// - `impl Iterator<Item = &Symbol>`
+///
+/// Panics if `path` is empty or a segment after the first is `kw::PathRoot`.
+pub fn join_path_syms(path: impl IntoIterator<Item = impl Borrow<Symbol>>) -> String {
+    // This is a guess at the needed capacity that works well in practice. It is slightly faster
+    // than (a) starting with an empty string, or (b) computing the exact capacity required.
+    // `8` works well because it's about the right size and jemalloc's size classes are all
+    // multiples of 8.
+    let mut iter = path.into_iter();
+    let len_hint = iter.size_hint().1.unwrap_or(1);
+    let mut s = String::with_capacity(len_hint * 8);
+
+    let first_sym = *iter.next().unwrap().borrow();
+    if first_sym != kw::PathRoot {
+        s.push_str(first_sym.as_str());
+    }
+    for sym in iter {
+        let sym = *sym.borrow();
+        debug_assert_ne!(sym, kw::PathRoot);
+        s.push_str("::");
+        s.push_str(sym.as_str());
+    }
+    s
+}
+
+/// Like `join_path_syms`, but for `Ident`s. This function is necessary because
+/// `Ident::to_string` does more than just print the symbol in the `name` field.
+pub fn join_path_idents(path: impl IntoIterator<Item = impl Borrow<Ident>>) -> String {
+    let mut iter = path.into_iter();
+    let len_hint = iter.size_hint().1.unwrap_or(1);
+    let mut s = String::with_capacity(len_hint * 8);
+
+    let first_ident = *iter.next().unwrap().borrow();
+    if first_ident.name != kw::PathRoot {
+        s.push_str(&first_ident.to_string());
+    }
+    for ident in iter {
+        let ident = *ident.borrow();
+        debug_assert_ne!(ident.name, kw::PathRoot);
+        s.push_str("::");
+        s.push_str(&ident.to_string());
+    }
+    s
+}
+
 /// A segment of a path: an identifier, an optional lifetime, and a set of types.
 ///
 /// E.g., `std`, `String` or `Box<T>`.
diff --git a/compiler/rustc_builtin_macros/src/source_util.rs b/compiler/rustc_builtin_macros/src/source_util.rs
index cebfffa1e16..ecfd46a84ec 100644
--- a/compiler/rustc_builtin_macros/src/source_util.rs
+++ b/compiler/rustc_builtin_macros/src/source_util.rs
@@ -4,8 +4,8 @@ use std::sync::Arc;
 
 use rustc_ast as ast;
 use rustc_ast::ptr::P;
-use rustc_ast::token;
 use rustc_ast::tokenstream::TokenStream;
+use rustc_ast::{join_path_idents, token};
 use rustc_ast_pretty::pprust;
 use rustc_expand::base::{
     DummyResult, ExpandResult, ExtCtxt, MacEager, MacResult, MacroExpanderResult, resolve_path,
@@ -100,7 +100,7 @@ pub(crate) fn expand_mod(
     let sp = cx.with_def_site_ctxt(sp);
     check_zero_tts(cx, sp, tts, "module_path!");
     let mod_path = &cx.current_expansion.module.mod_path;
-    let string = mod_path.iter().map(|x| x.to_string()).collect::<Vec<String>>().join("::");
+    let string = join_path_idents(mod_path);
 
     ExpandResult::Ready(MacEager::expr(cx.expr_str(sp, Symbol::intern(&string))))
 }
diff --git a/compiler/rustc_builtin_macros/src/test.rs b/compiler/rustc_builtin_macros/src/test.rs
index b067578794b..ba3d8368b2a 100644
--- a/compiler/rustc_builtin_macros/src/test.rs
+++ b/compiler/rustc_builtin_macros/src/test.rs
@@ -5,7 +5,7 @@ use std::assert_matches::assert_matches;
 use std::iter;
 
 use rustc_ast::ptr::P;
-use rustc_ast::{self as ast, GenericParamKind, attr};
+use rustc_ast::{self as ast, GenericParamKind, attr, join_path_idents};
 use rustc_ast_pretty::pprust;
 use rustc_errors::{Applicability, Diag, Level};
 use rustc_expand::base::*;
@@ -446,12 +446,7 @@ fn get_location_info(cx: &ExtCtxt<'_>, fn_: &ast::Fn) -> (Symbol, usize, usize,
 }
 
 fn item_path(mod_path: &[Ident], item_ident: &Ident) -> String {
-    mod_path
-        .iter()
-        .chain(iter::once(item_ident))
-        .map(|x| x.to_string())
-        .collect::<Vec<String>>()
-        .join("::")
+    join_path_idents(mod_path.iter().chain(iter::once(item_ident)))
 }
 
 enum ShouldPanic {
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 159518a8d87..ace2259aec3 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -7,7 +7,7 @@ use rustc_ast::token::CommentKind;
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_ast::{
     self as ast, FloatTy, InlineAsmOptions, InlineAsmTemplatePiece, IntTy, Label, LitIntType,
-    LitKind, TraitObjectSyntax, UintTy, UnsafeBinderCastKind,
+    LitKind, TraitObjectSyntax, UintTy, UnsafeBinderCastKind, join_path_idents,
 };
 pub use rustc_ast::{
     AssignOp, AssignOpKind, AttrId, AttrStyle, BinOp, BinOpKind, BindingMode, BorrowKind,
@@ -1168,7 +1168,7 @@ impl AttrPath {
 
 impl fmt::Display for AttrPath {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.segments.iter().map(|i| i.to_string()).collect::<Vec<_>>().join("::"))
+        write!(f, "{}", join_path_idents(&self.segments))
     }
 }
 
diff --git a/compiler/rustc_hir_typeck/src/method/prelude_edition_lints.rs b/compiler/rustc_hir_typeck/src/method/prelude_edition_lints.rs
index 0037d5ac042..38413cca633 100644
--- a/compiler/rustc_hir_typeck/src/method/prelude_edition_lints.rs
+++ b/compiler/rustc_hir_typeck/src/method/prelude_edition_lints.rs
@@ -2,6 +2,7 @@ use std::fmt::Write;
 
 use hir::def_id::DefId;
 use hir::{HirId, ItemKind};
+use rustc_ast::join_path_idents;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{ARRAY_INTO_ITER, BOXED_SLICE_INTO_ITER};
@@ -383,13 +384,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // All that is left is `_`! We need to use the full path. It doesn't matter which one we
         // pick, so just take the first one.
         match import_items[0].kind {
-            ItemKind::Use(path, _) => Some(
-                path.segments
-                    .iter()
-                    .map(|segment| segment.ident.to_string())
-                    .collect::<Vec<_>>()
-                    .join("::"),
-            ),
+            ItemKind::Use(path, _) => {
+                Some(join_path_idents(path.segments.iter().map(|seg| seg.ident)))
+            }
             _ => {
                 span_bug!(span, "unexpected item kind, expected a use: {:?}", import_items[0].kind);
             }
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2009ddc1e2d..5b2b9c152aa 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -10,7 +10,7 @@ use std::collections::hash_map::Entry;
 use std::slice;
 
 use rustc_abi::{Align, ExternAbi, Size};
-use rustc_ast::{AttrStyle, LitKind, MetaItemInner, MetaItemKind, ast};
+use rustc_ast::{AttrStyle, LitKind, MetaItemInner, MetaItemKind, ast, join_path_syms};
 use rustc_attr_data_structures::{AttributeKind, InlineAttr, ReprAttr, find_attr};
 use rustc_attr_parsing::{AttributeParser, Late};
 use rustc_data_structures::fx::FxHashMap;
@@ -678,9 +678,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         allowed_target: Target,
     ) {
         if target != allowed_target {
-            let path = attr.path();
-            let path: Vec<_> = path.iter().map(|s| s.as_str()).collect();
-            let attr_name = path.join("::");
+            let attr_name = join_path_syms(attr.path());
             self.tcx.emit_node_span_lint(
                 UNUSED_ATTRIBUTES,
                 hir_id,
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 11e4a729ae2..5a162b5d2b9 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1,6 +1,8 @@
 use rustc_ast::ptr::P;
 use rustc_ast::visit::{self, Visitor};
-use rustc_ast::{self as ast, CRATE_NODE_ID, Crate, ItemKind, ModKind, NodeId, Path};
+use rustc_ast::{
+    self as ast, CRATE_NODE_ID, Crate, ItemKind, ModKind, NodeId, Path, join_path_idents,
+};
 use rustc_ast_pretty::pprust;
 use rustc_attr_data_structures::{
     self as attr, AttributeKind, CfgEntry, Stability, StrippedCfgItem, find_attr,
@@ -2018,7 +2020,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
         }
 
-        let mut sugg_paths = vec![];
+        let mut sugg_paths: Vec<(Vec<Ident>, bool)> = vec![];
         if let Some(mut def_id) = res.opt_def_id() {
             // We can't use `def_path_str` in resolve.
             let mut path = vec![def_id];
@@ -2031,16 +2033,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 }
             }
             // We will only suggest importing directly if it is accessible through that path.
-            let path_names: Option<Vec<String>> = path
+            let path_names: Option<Vec<Ident>> = path
                 .iter()
                 .rev()
                 .map(|def_id| {
-                    self.tcx.opt_item_name(*def_id).map(|n| {
-                        if def_id.is_top_level_module() {
-                            "crate".to_string()
+                    self.tcx.opt_item_name(*def_id).map(|name| {
+                        Ident::with_dummy_span(if def_id.is_top_level_module() {
+                            kw::Crate
                         } else {
-                            n.to_string()
-                        }
+                            name
+                        })
                     })
                 })
                 .collect();
@@ -2084,13 +2086,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             match binding.kind {
                 NameBindingKind::Import { import, .. } => {
                     for segment in import.module_path.iter().skip(1) {
-                        path.push(segment.ident.to_string());
+                        path.push(segment.ident);
                     }
                     sugg_paths.push((
-                        path.iter()
-                            .cloned()
-                            .chain(vec![ident.to_string()].into_iter())
-                            .collect::<Vec<_>>(),
+                        path.iter().cloned().chain(std::iter::once(ident)).collect::<Vec<_>>(),
                         true, // re-export
                     ));
                 }
@@ -2126,7 +2125,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             err.subdiagnostic(note);
         }
         // We prioritize shorter paths, non-core imports and direct imports over the alternatives.
-        sugg_paths.sort_by_key(|(p, reexport)| (p.len(), p[0] == "core", *reexport));
+        sugg_paths.sort_by_key(|(p, reexport)| (p.len(), p[0].name == sym::core, *reexport));
         for (sugg, reexport) in sugg_paths {
             if not_publicly_reexported {
                 break;
@@ -2136,7 +2135,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 // `tests/ui/imports/issue-55884-2.rs`
                 continue;
             }
-            let path = sugg.join("::");
+            let path = join_path_idents(sugg);
             let sugg = if reexport {
                 errors::ImportIdent::ThroughReExport { span: dedup_span, ident, path }
             } else {
diff --git a/compiler/rustc_resolve/src/rustdoc.rs b/compiler/rustc_resolve/src/rustdoc.rs
index f61cd1f0adf..24e15ded94f 100644
--- a/compiler/rustc_resolve/src/rustdoc.rs
+++ b/compiler/rustc_resolve/src/rustdoc.rs
@@ -7,6 +7,7 @@ use pulldown_cmark::{
 };
 use rustc_ast as ast;
 use rustc_ast::attr::AttributeExt;
+use rustc_ast::join_path_syms;
 use rustc_ast::util::comments::beautify_doc_string;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::unord::UnordSet;
@@ -259,7 +260,7 @@ pub fn main_body_opts() -> Options {
         | Options::ENABLE_SMART_PUNCTUATION
 }
 
-fn strip_generics_from_path_segment(segment: Vec<char>) -> Result<String, MalformedGenerics> {
+fn strip_generics_from_path_segment(segment: Vec<char>) -> Result<Symbol, MalformedGenerics> {
     let mut stripped_segment = String::new();
     let mut param_depth = 0;
 
@@ -284,7 +285,7 @@ fn strip_generics_from_path_segment(segment: Vec<char>) -> Result<String, Malfor
     }
 
     if param_depth == 0 {
-        Ok(stripped_segment)
+        Ok(Symbol::intern(&stripped_segment))
     } else {
         // The segment has unbalanced angle brackets, e.g. `Vec<T` or `Vec<T>>`
         Err(MalformedGenerics::UnbalancedAngleBrackets)
@@ -346,9 +347,8 @@ pub fn strip_generics_from_path(path_str: &str) -> Result<Box<str>, MalformedGen
 
     debug!("path_str: {path_str:?}\nstripped segments: {stripped_segments:?}");
 
-    let stripped_path = stripped_segments.join("::");
-
-    if !stripped_path.is_empty() {
+    if !stripped_segments.is_empty() {
+        let stripped_path = join_path_syms(stripped_segments);
         Ok(stripped_path.into())
     } else {
         Err(MalformedGenerics::MissingType)
diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs
index bf3f7607274..fd1b17b6476 100644
--- a/src/librustdoc/clean/utils.rs
+++ b/src/librustdoc/clean/utils.rs
@@ -3,6 +3,7 @@ use std::fmt::{self, Display, Write as _};
 use std::sync::LazyLock as Lazy;
 use std::{ascii, mem};
 
+use rustc_ast::join_path_idents;
 use rustc_ast::tokenstream::TokenTree;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
@@ -24,7 +25,7 @@ use crate::clean::{
     clean_middle_ty, inline,
 };
 use crate::core::DocContext;
-use crate::display::{Joined as _, MaybeDisplay as _};
+use crate::display::Joined as _;
 
 #[cfg(test)]
 mod tests;
@@ -251,13 +252,7 @@ pub(crate) fn qpath_to_string(p: &hir::QPath<'_>) -> String {
         hir::QPath::LangItem(lang_item, ..) => return lang_item.name().to_string(),
     };
 
-    fmt::from_fn(|f| {
-        segments
-            .iter()
-            .map(|seg| (seg.ident.name != kw::PathRoot).then_some(seg.ident).maybe_display())
-            .joined("::", f)
-    })
-    .to_string()
+    join_path_idents(segments.iter().map(|seg| seg.ident))
 }
 
 pub(crate) fn build_deref_target_impls(
diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs
index 4989bd718c9..5191120ebdb 100644
--- a/src/librustdoc/formats/cache.rs
+++ b/src/librustdoc/formats/cache.rs
@@ -1,5 +1,6 @@
 use std::mem;
 
+use rustc_ast::join_path_syms;
 use rustc_attr_data_structures::StabilityLevel;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet};
@@ -13,7 +14,6 @@ use crate::core::DocContext;
 use crate::fold::DocFolder;
 use crate::formats::Impl;
 use crate::formats::item_type::ItemType;
-use crate::html::format::join_with_double_colon;
 use crate::html::markdown::short_markdown_summary;
 use crate::html::render::IndexItem;
 use crate::html::render::search_index::get_function_type_for_search;
@@ -558,7 +558,7 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It
         clean::ItemKind::ImportItem(import) => import.source.did.unwrap_or(item_def_id),
         _ => item_def_id,
     };
-    let path = join_with_double_colon(parent_path);
+    let path = join_path_syms(parent_path);
     let impl_id = if let Some(ParentStackItem::Impl { item_id, .. }) = cache.parent_stack.last() {
         item_id.as_def_id()
     } else {
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index bcb3e57c844..b16485107a0 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -14,6 +14,7 @@ use std::slice;
 
 use itertools::{Either, Itertools};
 use rustc_abi::ExternAbi;
+use rustc_ast::join_path_syms;
 use rustc_attr_data_structures::{ConstStability, StabilityLevel, StableSince};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
@@ -25,7 +26,7 @@ use rustc_span::symbol::kw;
 use rustc_span::{Symbol, sym};
 use tracing::{debug, trace};
 
-use super::url_parts_builder::{UrlPartsBuilder, estimate_item_path_byte_length};
+use super::url_parts_builder::UrlPartsBuilder;
 use crate::clean::types::ExternalLocation;
 use crate::clean::utils::find_nearest_parent_module;
 use crate::clean::{self, ExternalCrate, PrimitiveType};
@@ -369,18 +370,6 @@ pub(crate) enum HrefError {
     NotInExternalCache,
 }
 
-// Panics if `syms` is empty.
-pub(crate) fn join_with_double_colon(syms: &[Symbol]) -> String {
-    let mut s = String::with_capacity(estimate_item_path_byte_length(syms.len()));
-    // NOTE: using `Joined::joined` here causes a noticeable perf regression
-    s.push_str(syms[0].as_str());
-    for sym in &syms[1..] {
-        s.push_str("::");
-        s.push_str(sym.as_str());
-    }
-    s
-}
-
 /// This function is to get the external macro path because they are not in the cache used in
 /// `href_with_root_path`.
 fn generate_macro_def_id_path(
@@ -672,7 +661,7 @@ pub(crate) fn link_tooltip(
             write!(f, "{}", cx.tcx().item_name(id))?;
         } else if !fqp.is_empty() {
             write!(f, "{shortty} ")?;
-            fqp.iter().joined("::", f)?;
+            write!(f, "{}", join_path_syms(fqp))?;
         }
         Ok(())
     })
@@ -703,7 +692,7 @@ fn resolved_path(
                     write!(
                         f,
                         "{path}::{anchor}",
-                        path = join_with_double_colon(&fqp[..fqp.len() - 1]),
+                        path = join_path_syms(&fqp[..fqp.len() - 1]),
                         anchor = print_anchor(did, *fqp.last().unwrap(), cx)
                     )
                 } else {
@@ -835,7 +824,7 @@ pub(crate) fn print_anchor(did: DefId, text: Symbol, cx: &Context<'_>) -> impl D
             write!(
                 f,
                 r#"<a class="{short_ty}" href="{url}" title="{short_ty} {path}">{text}</a>"#,
-                path = join_with_double_colon(&fqp),
+                path = join_path_syms(fqp),
                 text = EscapeBodyText(text.as_str()),
             )
         } else {
@@ -1095,7 +1084,7 @@ impl clean::QPathData {
                                     title=\"type {path}::{name}\">{name}</a>",
                         shortty = ItemType::AssocType,
                         name = assoc.name,
-                        path = join_with_double_colon(&path),
+                        path = join_path_syms(path),
                     )
                 } else {
                     write!(f, "{}", assoc.name)
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
index 3b4dae841ee..7b814701a73 100644
--- a/src/librustdoc/html/render/context.rs
+++ b/src/librustdoc/html/render/context.rs
@@ -6,6 +6,7 @@ use std::path::{Path, PathBuf};
 use std::sync::mpsc::{Receiver, channel};
 
 use askama::Template;
+use rustc_ast::join_path_syms;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_hir::def_id::{DefIdMap, LOCAL_CRATE};
 use rustc_middle::ty::TyCtxt;
@@ -27,7 +28,6 @@ use crate::formats::FormatRenderer;
 use crate::formats::cache::Cache;
 use crate::formats::item_type::ItemType;
 use crate::html::escape::Escape;
-use crate::html::format::join_with_double_colon;
 use crate::html::markdown::{self, ErrorCodes, IdMap, plain_text_summary};
 use crate::html::render::write_shared::write_shared;
 use crate::html::url_parts_builder::UrlPartsBuilder;
@@ -211,7 +211,7 @@ impl<'tcx> Context<'tcx> {
                 title.push_str(" in ");
             }
             // No need to include the namespace for primitive types and keywords
-            title.push_str(&join_with_double_colon(&self.current));
+            title.push_str(&join_path_syms(&self.current));
         };
         title.push_str(" - Rust");
         let tyname = it.type_();
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 06de4944d97..d8c37137bbc 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -49,6 +49,7 @@ use std::{fs, str};
 
 use askama::Template;
 use itertools::Either;
+use rustc_ast::join_path_syms;
 use rustc_attr_data_structures::{
     ConstStability, DeprecatedSince, Deprecation, RustcVersion, StabilityLevel, StableSince,
 };
@@ -74,9 +75,9 @@ use crate::formats::cache::Cache;
 use crate::formats::item_type::ItemType;
 use crate::html::escape::Escape;
 use crate::html::format::{
-    Ending, HrefError, PrintWithSpace, href, join_with_double_colon, print_abi_with_space,
-    print_constness_with_space, print_default_space, print_generic_bounds, print_where_clause,
-    visibility_print_with_space, write_str,
+    Ending, HrefError, PrintWithSpace, href, print_abi_with_space, print_constness_with_space,
+    print_default_space, print_generic_bounds, print_where_clause, visibility_print_with_space,
+    write_str,
 };
 use crate::html::markdown::{
     HeadingOffset, IdMap, Markdown, MarkdownItemInfo, MarkdownSummaryLine,
@@ -2555,7 +2556,7 @@ fn collect_paths_for_type(first_ty: &clean::Type, cache: &Cache) -> Vec<String>
         let fqp = cache.exact_paths.get(&did).or_else(get_extern);
 
         if let Some(path) = fqp {
-            out.push(join_with_double_colon(path));
+            out.push(join_path_syms(path));
         }
     };
 
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index 667d39e9bc2..5fbda4797cc 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -4,6 +4,7 @@ use std::iter;
 
 use askama::Template;
 use rustc_abi::VariantIdx;
+use rustc_ast::join_path_syms;
 use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
 use rustc_hir as hir;
 use rustc_hir::def::CtorKind;
@@ -30,8 +31,8 @@ use crate::formats::Impl;
 use crate::formats::item_type::ItemType;
 use crate::html::escape::{Escape, EscapeBodyTextWithWbr};
 use crate::html::format::{
-    Ending, PrintWithSpace, join_with_double_colon, print_abi_with_space,
-    print_constness_with_space, print_where_clause, visibility_print_with_space,
+    Ending, PrintWithSpace, print_abi_with_space, print_constness_with_space, print_where_clause,
+    visibility_print_with_space,
 };
 use crate::html::markdown::{HeadingOffset, MarkdownSummaryLine};
 use crate::html::render::{document_full, document_item_info};
@@ -1424,7 +1425,7 @@ fn item_type_alias(cx: &Context<'_>, it: &clean::Item, t: &clean::TypeAlias) ->
                 iter::repeat_n("..", cx.current.len()).chain(iter::once("type.impl")).collect();
             js_src_path.extend(target_fqp[..target_fqp.len() - 1].iter().copied());
             js_src_path.push_fmt(format_args!("{target_type}.{}.js", target_fqp.last().unwrap()));
-            let self_path = fmt::from_fn(|f| self_fqp.iter().joined("::", f));
+            let self_path = join_path_syms(self_fqp);
             write!(
                 w,
                 "<script src=\"{src}\" data-self-path=\"{self_path}\" async></script>",
@@ -2256,7 +2257,7 @@ pub(crate) fn compare_names(left: &str, right: &str) -> Ordering {
 }
 
 pub(super) fn full_path(cx: &Context<'_>, item: &clean::Item) -> String {
-    let mut s = join_with_double_colon(&cx.current);
+    let mut s = join_path_syms(&cx.current);
     s.push_str("::");
     s.push_str(item.name.unwrap().as_str());
     s
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index aff8684ee3a..80a59fa218c 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -4,6 +4,7 @@ use std::collections::hash_map::Entry;
 use std::collections::{BTreeMap, VecDeque};
 
 use encode::{bitmap_to_string, write_vlqhex_to_string};
+use rustc_ast::join_path_syms;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_middle::ty::TyCtxt;
 use rustc_span::def_id::DefId;
@@ -17,7 +18,6 @@ use crate::clean::types::{Function, Generics, ItemId, Type, WherePredicate};
 use crate::clean::{self, utils};
 use crate::formats::cache::{Cache, OrphanImplItem};
 use crate::formats::item_type::ItemType;
-use crate::html::format::join_with_double_colon;
 use crate::html::markdown::short_markdown_summary;
 use crate::html::render::ordered_json::OrderedJson;
 use crate::html::render::{self, IndexItem, IndexItemFunctionType, RenderType, RenderTypeId};
@@ -78,7 +78,7 @@ pub(crate) fn build_index(
                 ty: item.type_(),
                 defid: item.item_id.as_def_id(),
                 name: item.name.unwrap(),
-                path: join_with_double_colon(&fqp[..fqp.len() - 1]),
+                path: join_path_syms(&fqp[..fqp.len() - 1]),
                 desc,
                 parent: Some(parent),
                 parent_idx: None,
@@ -416,7 +416,7 @@ pub(crate) fn build_index(
                             if fqp.len() < 2 {
                                 return None;
                             }
-                            join_with_double_colon(&fqp[..fqp.len() - 1])
+                            join_path_syms(&fqp[..fqp.len() - 1])
                         };
                     if path == item.path {
                         return None;
@@ -427,10 +427,10 @@ pub(crate) fn build_index(
                 let i = <isize as TryInto<usize>>::try_into(parent_idx).unwrap();
                 item.path = {
                     let p = &crate_paths[i].1;
-                    join_with_double_colon(&p[..p.len() - 1])
+                    join_path_syms(&p[..p.len() - 1])
                 };
                 item.exact_path =
-                    crate_paths[i].2.as_ref().map(|xp| join_with_double_colon(&xp[..xp.len() - 1]));
+                    crate_paths[i].2.as_ref().map(|xp| join_path_syms(&xp[..xp.len() - 1]));
             }
 
             // Omit the parent path if it is same to that of the prior item.
@@ -549,11 +549,11 @@ pub(crate) fn build_index(
                     });
                     continue;
                 }
-                let full_path = join_with_double_colon(&path[..path.len() - 1]);
+                let full_path = join_path_syms(&path[..path.len() - 1]);
                 let full_exact_path = exact
                     .as_ref()
                     .filter(|exact| exact.last() == path.last() && exact.len() >= 2)
-                    .map(|exact| join_with_double_colon(&exact[..exact.len() - 1]));
+                    .map(|exact| join_path_syms(&exact[..exact.len() - 1]));
                 let exact_path = extra_paths.len() + self.items.len();
                 let exact_path = full_exact_path.as_ref().map(|full_exact_path| match extra_paths
                     .entry(full_exact_path.clone())
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index 0078671fcc5..1f691392b17 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -26,6 +26,7 @@ use std::{fmt, fs};
 
 use indexmap::IndexMap;
 use regex::Regex;
+use rustc_ast::join_path_syms;
 use rustc_data_structures::flock;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_middle::ty::TyCtxt;
@@ -43,7 +44,6 @@ use crate::docfs::PathError;
 use crate::error::Error;
 use crate::formats::Impl;
 use crate::formats::item_type::ItemType;
-use crate::html::format::join_with_double_colon;
 use crate::html::layout;
 use crate::html::render::ordered_json::{EscapedJson, OrderedJson};
 use crate::html::render::search_index::{SerializedSearchIndex, build_index};
@@ -608,7 +608,7 @@ impl TypeAliasPart {
                     for &(type_alias_fqp, type_alias_item) in type_aliases {
                         cx.id_map.borrow_mut().clear();
                         cx.deref_id_map.borrow_mut().clear();
-                        let type_alias_fqp = join_with_double_colon(&type_alias_fqp);
+                        let type_alias_fqp = join_path_syms(type_alias_fqp);
                         if let Some(ret) = &mut ret {
                             ret.aliases.push(type_alias_fqp);
                         } else {
diff --git a/src/librustdoc/html/url_parts_builder.rs b/src/librustdoc/html/url_parts_builder.rs
index 9a533827441..705fa498e8d 100644
--- a/src/librustdoc/html/url_parts_builder.rs
+++ b/src/librustdoc/html/url_parts_builder.rs
@@ -117,7 +117,7 @@ impl UrlPartsBuilder {
 
 /// This is just a guess at the average length of a URL part,
 /// used for [`String::with_capacity`] calls in the [`FromIterator`]
-/// and [`Extend`] impls, and for [estimating item path lengths].
+/// and [`Extend`] impls.
 ///
 /// The value `8` was chosen for two main reasons:
 ///
@@ -125,18 +125,8 @@ impl UrlPartsBuilder {
 /// * jemalloc's size classes are all multiples of eight,
 ///   which means that the amount of memory it allocates will often match
 ///   the amount requested, avoiding wasted bytes.
-///
-/// [estimating item path lengths]: estimate_item_path_byte_length
 const AVG_PART_LENGTH: usize = 8;
 
-/// Estimate the number of bytes in an item's path, based on how many segments it has.
-///
-/// **Note:** This is only to be used with, e.g., [`String::with_capacity()`];
-/// the return value is just a rough estimate.
-pub(crate) const fn estimate_item_path_byte_length(segment_count: usize) -> usize {
-    AVG_PART_LENGTH * segment_count
-}
-
 impl<'a> FromIterator<&'a str> for UrlPartsBuilder {
     fn from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> Self {
         let iter = iter.into_iter();
diff --git a/src/tools/clippy/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/src/tools/clippy/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 045363058d1..d664eaaac70 100644
--- a/src/tools/clippy/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -4,6 +4,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{is_path_diagnostic_item, sugg};
+use rustc_ast::join_path_idents;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{self as hir, Expr, ExprKind, GenericArg, QPath, TyKind};
@@ -47,7 +48,7 @@ fn build_full_type(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, app: &mut Applica
         && let QPath::Resolved(None, ty_path) = &ty_qpath
         && let Res::Def(_, ty_did) = ty_path.res
     {
-        let mut ty_str = itertools::join(ty_path.segments.iter().map(|s| s.ident), "::");
+        let mut ty_str = join_path_idents(ty_path.segments.iter().map(|seg| seg.ident));
         let mut first = true;
         let mut append = |arg: &str| {
             write!(&mut ty_str, "{}{arg}", [", ", "<"][usize::from(first)]).unwrap();
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index ad8c816e204..ff1ee663f9b 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -89,6 +89,7 @@ use std::sync::{Mutex, MutexGuard, OnceLock};
 
 use itertools::Itertools;
 use rustc_abi::Integer;
+use rustc_ast::join_path_syms;
 use rustc_ast::ast::{self, LitKind, RangeLimits};
 use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::fx::FxHashMap;
@@ -3245,8 +3246,8 @@ fn maybe_get_relative_path(from: &DefPath, to: &DefPath, max_super: usize) -> St
                 // a::b::c  ::d::sym refers to
                 // e::f::sym:: ::
                 // result should be super::super::super::super::e::f
-                if let DefPathData::TypeNs(s) = l {
-                    path.push(s.to_string());
+                if let DefPathData::TypeNs(sym) = l {
+                    path.push(sym);
                 }
                 if let DefPathData::TypeNs(_) = r {
                     go_up_by += 1;
@@ -3256,7 +3257,7 @@ fn maybe_get_relative_path(from: &DefPath, to: &DefPath, max_super: usize) -> St
             // a::b::sym:: ::    refers to
             // c::d::e  ::f::sym
             // when looking at `f`
-            Left(DefPathData::TypeNs(sym)) => path.push(sym.to_string()),
+            Left(DefPathData::TypeNs(sym)) => path.push(sym),
             // consider:
             // a::b::c  ::d::sym refers to
             // e::f::sym:: ::
@@ -3268,17 +3269,17 @@ fn maybe_get_relative_path(from: &DefPath, to: &DefPath, max_super: usize) -> St
 
     if go_up_by > max_super {
         // `super` chain would be too long, just use the absolute path instead
-        once(String::from("crate"))
-            .chain(to.data.iter().filter_map(|el| {
+        join_path_syms(
+            once(kw::Crate).chain(to.data.iter().filter_map(|el| {
                 if let DefPathData::TypeNs(sym) = el.data {
-                    Some(sym.to_string())
+                    Some(sym)
                 } else {
                     None
                 }
             }))
-            .join("::")
+        )
     } else {
-        repeat_n(String::from("super"), go_up_by).chain(path).join("::")
+        join_path_syms(repeat_n(kw::Super, go_up_by).chain(path))
     }
 }
 
diff --git a/tests/ui/asm/naked-invalid-attr.stderr b/tests/ui/asm/naked-invalid-attr.stderr
index 915b54b3fc2..2571c8fa989 100644
--- a/tests/ui/asm/naked-invalid-attr.stderr
+++ b/tests/ui/asm/naked-invalid-attr.stderr
@@ -8,7 +8,7 @@ error[E0736]: attribute incompatible with `#[unsafe(naked)]`
   --> $DIR/naked-invalid-attr.rs:56:3
    |
 LL | #[::a]
-   |   ^^^ the `{{root}}::a` attribute is incompatible with `#[unsafe(naked)]`
+   |   ^^^ the `::a` attribute is incompatible with `#[unsafe(naked)]`
 ...
 LL | #[unsafe(naked)]
    | ---------------- function marked with `#[unsafe(naked)]` here
-- 
cgit 1.4.1-3-g733a5


From 6414352bff4f92db7efb177c4b3263060379ca60 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 20 Jun 2025 16:59:02 +1000
Subject: Use `join_path_syms` in one more place.

This one is a bit marginal, because the segments are a mix of symbols
and strings.
---
 compiler/rustc_hir/src/definitions.rs                | 20 +++++++-------------
 compiler/rustc_middle/src/ty/print/pretty.rs         |  2 +-
 .../src/error_reporting/infer/mod.rs                 | 11 ++++++-----
 3 files changed, 14 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_hir/src/definitions.rs b/compiler/rustc_hir/src/definitions.rs
index f93b9e5af53..8aec11a2e81 100644
--- a/compiler/rustc_hir/src/definitions.rs
+++ b/compiler/rustc_hir/src/definitions.rs
@@ -181,32 +181,26 @@ pub struct DisambiguatedDefPathData {
 }
 
 impl DisambiguatedDefPathData {
-    pub fn fmt_maybe_verbose(&self, writer: &mut impl Write, verbose: bool) -> fmt::Result {
+    pub fn as_sym(&self, verbose: bool) -> Symbol {
         match self.data.name() {
             DefPathDataName::Named(name) => {
                 if verbose && self.disambiguator != 0 {
-                    write!(writer, "{}#{}", name, self.disambiguator)
+                    Symbol::intern(&format!("{}#{}", name, self.disambiguator))
                 } else {
-                    writer.write_str(name.as_str())
+                    name
                 }
             }
             DefPathDataName::Anon { namespace } => {
                 if let DefPathData::AnonAssocTy(method) = self.data {
-                    write!(writer, "{}::{{{}#{}}}", method, namespace, self.disambiguator)
+                    Symbol::intern(&format!("{}::{{{}#{}}}", method, namespace, self.disambiguator))
                 } else {
-                    write!(writer, "{{{}#{}}}", namespace, self.disambiguator)
+                    Symbol::intern(&format!("{{{}#{}}}", namespace, self.disambiguator))
                 }
             }
         }
     }
 }
 
-impl fmt::Display for DisambiguatedDefPathData {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.fmt_maybe_verbose(f, true)
-    }
-}
-
 #[derive(Clone, Debug, Encodable, Decodable)]
 pub struct DefPath {
     /// The path leading from the crate root to the item.
@@ -250,7 +244,7 @@ impl DefPath {
         let mut s = String::with_capacity(self.data.len() * 16);
 
         for component in &self.data {
-            write!(s, "::{component}").unwrap();
+            write!(s, "::{}", component.as_sym(true)).unwrap();
         }
 
         s
@@ -266,7 +260,7 @@ impl DefPath {
         for component in &self.data {
             s.extend(opt_delimiter);
             opt_delimiter = Some('-');
-            write!(s, "{component}").unwrap();
+            write!(s, "{}", component.as_sym(true)).unwrap();
         }
 
         s
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 8f0f9b21dc1..b7088bd003a 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -2430,7 +2430,7 @@ impl<'tcx> Printer<'tcx> for FmtPrinter<'_, 'tcx> {
         }
 
         let verbose = self.should_print_verbose();
-        disambiguated_data.fmt_maybe_verbose(self, verbose)?;
+        write!(self, "{}", disambiguated_data.as_sym(verbose))?;
 
         self.empty_path = false;
 
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 bc464b099e2..b9acadc406e 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -51,6 +51,7 @@ use std::path::PathBuf;
 use std::{cmp, fmt, iter};
 
 use rustc_abi::ExternAbi;
+use rustc_ast::join_path_syms;
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_errors::{
     Applicability, Diag, DiagStyledString, IntoDiagArg, MultiSpan, StringPart, pluralize,
@@ -73,7 +74,7 @@ use rustc_middle::ty::{
     TypeVisitableExt,
 };
 use rustc_span::def_id::LOCAL_CRATE;
-use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, Pos, Span, sym};
+use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, Pos, Span, Symbol, sym};
 use tracing::{debug, instrument};
 
 use crate::error_reporting::TypeErrCtxt;
@@ -225,7 +226,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 
         struct AbsolutePathPrinter<'tcx> {
             tcx: TyCtxt<'tcx>,
-            segments: Vec<String>,
+            segments: Vec<Symbol>,
         }
 
         impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
@@ -253,7 +254,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             }
 
             fn path_crate(&mut self, cnum: CrateNum) -> Result<(), PrintError> {
-                self.segments = vec![self.tcx.crate_name(cnum).to_string()];
+                self.segments = vec![self.tcx.crate_name(cnum)];
                 Ok(())
             }
             fn path_qualified(
@@ -279,7 +280,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 disambiguated_data: &DisambiguatedDefPathData,
             ) -> Result<(), PrintError> {
                 print_prefix(self)?;
-                self.segments.push(disambiguated_data.to_string());
+                self.segments.push(disambiguated_data.as_sym(true));
                 Ok(())
             }
             fn path_generic_args(
@@ -314,7 +315,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 // known" by the same name, we use the "absolute path" which uses the original
                 // crate name instead.
                 let (expected, found) = if expected_str == found_str {
-                    (expected_abs.join("::"), found_abs.join("::"))
+                    (join_path_syms(&expected_abs), join_path_syms(&found_abs))
                 } else {
                     (expected_str.clone(), found_str.clone())
                 };
-- 
cgit 1.4.1-3-g733a5


From 5d611e55489b70482295419888844c29af11b2ee Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Sun, 6 Jul 2025 23:17:01 +0300
Subject: resolve: Move `self_binding` to `ModuleData`

---
 compiler/rustc_resolve/src/ident.rs |  2 +-
 compiler/rustc_resolve/src/lib.rs   | 39 ++++++++++++++-----------------------
 2 files changed, 16 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 84d66c15f00..6ac3034d1d9 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -841,7 +841,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 if ns == TypeNS {
                     if ident.name == kw::Crate || ident.name == kw::DollarCrate {
                         let module = self.resolve_crate_root(ident);
-                        return Ok(self.module_self_bindings[&module]);
+                        return Ok(module.self_binding.unwrap());
                     } else if ident.name == kw::Super || ident.name == kw::SelfLower {
                         // FIXME: Implement these with renaming requirements so that e.g.
                         // `use super;` doesn't work, but `use super as name;` does.
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index b0b29bc2eae..73a6d4c0c3e 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -585,6 +585,10 @@ struct ModuleData<'ra> {
     span: Span,
 
     expansion: ExpnId,
+
+    /// Binding for implicitly declared names that come with a module,
+    /// like `self` (not yet used), or `crate`/`$crate` (for root modules).
+    self_binding: Option<NameBinding<'ra>>,
 }
 
 /// All modules are unique and allocated on a same arena,
@@ -613,6 +617,7 @@ impl<'ra> ModuleData<'ra> {
         expansion: ExpnId,
         span: Span,
         no_implicit_prelude: bool,
+        self_binding: Option<NameBinding<'ra>>,
     ) -> Self {
         let is_foreign = match kind {
             ModuleKind::Def(_, def_id, _) => !def_id.is_local(),
@@ -630,6 +635,7 @@ impl<'ra> ModuleData<'ra> {
             traits: RefCell::new(None),
             span,
             expansion,
+            self_binding,
         }
     }
 }
@@ -1101,10 +1107,6 @@ pub struct Resolver<'ra, 'tcx> {
     builtin_types_bindings: FxHashMap<Symbol, NameBinding<'ra>>,
     builtin_attrs_bindings: FxHashMap<Symbol, NameBinding<'ra>>,
     registered_tool_bindings: FxHashMap<Ident, NameBinding<'ra>>,
-    /// Binding for implicitly declared names that come with a module,
-    /// like `self` (not yet used), or `crate`/`$crate` (for root modules).
-    module_self_bindings: FxHashMap<Module<'ra>, NameBinding<'ra>>,
-
     used_extern_options: FxHashSet<Symbol>,
     macro_names: FxHashSet<Ident>,
     builtin_macros: FxHashMap<Symbol, SyntaxExtensionKind>,
@@ -1264,24 +1266,27 @@ impl<'ra> ResolverArenas<'ra> {
         span: Span,
         no_implicit_prelude: bool,
         module_map: &mut FxIndexMap<DefId, Module<'ra>>,
-        module_self_bindings: &mut FxHashMap<Module<'ra>, NameBinding<'ra>>,
     ) -> Module<'ra> {
+        let (def_id, self_binding) = match kind {
+            ModuleKind::Def(def_kind, def_id, _) => (
+                Some(def_id),
+                Some(self.new_pub_res_binding(Res::Def(def_kind, def_id), span, LocalExpnId::ROOT)),
+            ),
+            ModuleKind::Block => (None, None),
+        };
         let module = Module(Interned::new_unchecked(self.modules.alloc(ModuleData::new(
             parent,
             kind,
             expn_id,
             span,
             no_implicit_prelude,
+            self_binding,
         ))));
-        let def_id = module.opt_def_id();
         if def_id.is_none_or(|def_id| def_id.is_local()) {
             self.local_modules.borrow_mut().push(module);
         }
         if let Some(def_id) = def_id {
             module_map.insert(def_id, module);
-            let res = module.res().unwrap();
-            let binding = self.new_pub_res_binding(res, module.span, LocalExpnId::ROOT);
-            module_self_bindings.insert(module, binding);
         }
         module
     }
@@ -1424,7 +1429,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     ) -> Resolver<'ra, 'tcx> {
         let root_def_id = CRATE_DEF_ID.to_def_id();
         let mut module_map = FxIndexMap::default();
-        let mut module_self_bindings = FxHashMap::default();
         let graph_root = arenas.new_module(
             None,
             ModuleKind::Def(DefKind::Mod, root_def_id, None),
@@ -1432,7 +1436,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             crate_span,
             attr::contains_name(attrs, sym::no_implicit_prelude),
             &mut module_map,
-            &mut module_self_bindings,
         );
         let empty_module = arenas.new_module(
             None,
@@ -1441,7 +1444,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             DUMMY_SP,
             true,
             &mut Default::default(),
-            &mut Default::default(),
         );
 
         let mut node_id_to_def_id = NodeMap::default();
@@ -1544,8 +1546,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     (*ident, binding)
                 })
                 .collect(),
-            module_self_bindings,
-
             used_extern_options: Default::default(),
             macro_names: FxHashSet::default(),
             builtin_macros: Default::default(),
@@ -1617,16 +1617,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         no_implicit_prelude: bool,
     ) -> Module<'ra> {
         let module_map = &mut self.module_map;
-        let module_self_bindings = &mut self.module_self_bindings;
-        self.arenas.new_module(
-            parent,
-            kind,
-            expn_id,
-            span,
-            no_implicit_prelude,
-            module_map,
-            module_self_bindings,
-        )
+        self.arenas.new_module(parent, kind, expn_id, span, no_implicit_prelude, module_map)
     }
 
     fn new_local_macro(&mut self, def_id: LocalDefId, macro_data: MacroData) -> &'ra MacroData {
-- 
cgit 1.4.1-3-g733a5


From 8d7193973f5beede7893969197b1661b43f254be Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Sun, 6 Jul 2025 23:47:19 +0300
Subject: resolve: Use `module_map` and `get_module` less

---
 compiler/rustc_resolve/src/diagnostics.rs          | 38 ++++++++++++----------
 .../rustc_resolve/src/effective_visibilities.rs    |  3 +-
 compiler/rustc_resolve/src/late/diagnostics.rs     | 20 +++++-------
 3 files changed, 31 insertions(+), 30 deletions(-)

diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 11e4a729ae2..d263ab25045 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -2771,7 +2771,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     }
 
     /// Finds a cfg-ed out item inside `module` with the matching name.
-    pub(crate) fn find_cfg_stripped(&self, err: &mut Diag<'_>, segment: &Symbol, module: DefId) {
+    pub(crate) fn find_cfg_stripped(
+        &mut self,
+        err: &mut Diag<'_>,
+        segment: &Symbol,
+        module: DefId,
+    ) {
         let local_items;
         let symbols = if module.is_local() {
             local_items = self
@@ -2797,7 +2802,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
 
             fn comes_from_same_module_for_glob(
-                r: &Resolver<'_, '_>,
+                r: &mut Resolver<'_, '_>,
                 parent_module: DefId,
                 module: DefId,
                 visited: &mut FxHashMap<DefId, bool>,
@@ -2809,24 +2814,23 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     return cached;
                 }
                 visited.insert(parent_module, false);
-                let res = r.module_map.get(&parent_module).is_some_and(|m| {
-                    for importer in m.glob_importers.borrow().iter() {
-                        if let Some(next_parent_module) = importer.parent_scope.module.opt_def_id()
+                let m = r.expect_module(parent_module);
+                let mut res = false;
+                for importer in m.glob_importers.borrow().iter() {
+                    if let Some(next_parent_module) = importer.parent_scope.module.opt_def_id() {
+                        if next_parent_module == module
+                            || comes_from_same_module_for_glob(
+                                r,
+                                next_parent_module,
+                                module,
+                                visited,
+                            )
                         {
-                            if next_parent_module == module
-                                || comes_from_same_module_for_glob(
-                                    r,
-                                    next_parent_module,
-                                    module,
-                                    visited,
-                                )
-                            {
-                                return true;
-                            }
+                            res = true;
+                            break;
                         }
                     }
-                    false
-                });
+                }
                 visited.insert(parent_module, res);
                 res
             }
diff --git a/compiler/rustc_resolve/src/effective_visibilities.rs b/compiler/rustc_resolve/src/effective_visibilities.rs
index 5de80de3f8d..741671b6d2f 100644
--- a/compiler/rustc_resolve/src/effective_visibilities.rs
+++ b/compiler/rustc_resolve/src/effective_visibilities.rs
@@ -113,8 +113,7 @@ impl<'a, 'ra, 'tcx> EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
     /// Update effective visibilities of bindings in the given module,
     /// including their whole reexport chains.
     fn set_bindings_effective_visibilities(&mut self, module_id: LocalDefId) {
-        assert!(self.r.module_map.contains_key(&module_id.to_def_id()));
-        let module = self.r.get_module(module_id.to_def_id()).unwrap();
+        let module = self.r.expect_module(module_id.to_def_id());
         let resolutions = self.r.resolutions(module);
 
         for (_, name_resolution) in resolutions.borrow().iter() {
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index a4601cb44eb..70a7dbf1b04 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -926,7 +926,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                     continue;
                 };
                 if let Res::Def(DefKind::Mod, module) = res.expect_full_res()
-                    && let Some(module) = self.r.get_module(module)
+                    && let module = self.r.expect_module(module)
                     && let item = path[idx + 1].ident
                     && let Some(did) = find_doc_alias_name(self.r, module, item.name)
                 {
@@ -2531,16 +2531,14 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                     // FIXME: this is not totally accurate, but mostly works
                     suggestion.candidate != following_seg.ident.name
                 }
-                Res::Def(DefKind::Mod, def_id) => self.r.get_module(def_id).map_or_else(
-                    || false,
-                    |module| {
-                        self.r
-                            .resolutions(module)
-                            .borrow()
-                            .iter()
-                            .any(|(key, _)| key.ident.name == following_seg.ident.name)
-                    },
-                ),
+                Res::Def(DefKind::Mod, def_id) => {
+                    let module = self.r.expect_module(def_id);
+                    self.r
+                        .resolutions(module)
+                        .borrow()
+                        .iter()
+                        .any(|(key, _)| key.ident.name == following_seg.ident.name)
+                }
                 _ => true,
             });
         }
-- 
cgit 1.4.1-3-g733a5


From 8b8889df2550fac573cbaddb1db1419080118d63 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Mon, 7 Jul 2025 00:15:13 +0300
Subject: resolve: Split `module_map` into two maps for local and extern
 modules

---
 compiler/rustc_resolve/src/build_reduced_graph.rs | 57 ++++++++++++-----------
 compiler/rustc_resolve/src/diagnostics.rs         | 11 ++++-
 compiler/rustc_resolve/src/lib.rs                 | 42 +++++++++++------
 3 files changed, 69 insertions(+), 41 deletions(-)

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index 5a1be618cee..676acd78ea7 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -102,33 +102,36 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     /// or trait), then this function returns that module's resolver representation, otherwise it
     /// returns `None`.
     pub(crate) fn get_module(&mut self, def_id: DefId) -> Option<Module<'ra>> {
-        if let module @ Some(..) = self.module_map.get(&def_id) {
-            return module.copied();
-        }
+        match def_id.as_local() {
+            Some(local_def_id) => self.local_module_map.get(&local_def_id).copied(),
+            None => {
+                if let module @ Some(..) = self.extern_module_map.borrow().get(&def_id) {
+                    return module.copied();
+                }
 
-        if !def_id.is_local() {
-            // Query `def_kind` is not used because query system overhead is too expensive here.
-            let def_kind = self.cstore().def_kind_untracked(def_id);
-            if def_kind.is_module_like() {
-                let parent = self
-                    .tcx
-                    .opt_parent(def_id)
-                    .map(|parent_id| self.get_nearest_non_block_module(parent_id));
-                // Query `expn_that_defined` is not used because
-                // hashing spans in its result is expensive.
-                let expn_id = self.cstore().expn_that_defined_untracked(def_id, self.tcx.sess);
-                return Some(self.new_module(
-                    parent,
-                    ModuleKind::Def(def_kind, def_id, Some(self.tcx.item_name(def_id))),
-                    expn_id,
-                    self.def_span(def_id),
-                    // FIXME: Account for `#[no_implicit_prelude]` attributes.
-                    parent.is_some_and(|module| module.no_implicit_prelude),
-                ));
+                // Query `def_kind` is not used because query system overhead is too expensive here.
+                let def_kind = self.cstore().def_kind_untracked(def_id);
+                if def_kind.is_module_like() {
+                    let parent = self
+                        .tcx
+                        .opt_parent(def_id)
+                        .map(|parent_id| self.get_nearest_non_block_module(parent_id));
+                    // Query `expn_that_defined` is not used because
+                    // hashing spans in its result is expensive.
+                    let expn_id = self.cstore().expn_that_defined_untracked(def_id, self.tcx.sess);
+                    return Some(self.new_extern_module(
+                        parent,
+                        ModuleKind::Def(def_kind, def_id, Some(self.tcx.item_name(def_id))),
+                        expn_id,
+                        self.def_span(def_id),
+                        // FIXME: Account for `#[no_implicit_prelude]` attributes.
+                        parent.is_some_and(|module| module.no_implicit_prelude),
+                    ));
+                }
+
+                None
             }
         }
-
-        None
     }
 
     pub(crate) fn expn_def_scope(&mut self, expn_id: ExpnId) -> Module<'ra> {
@@ -758,7 +761,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 if let ast::ModKind::Loaded(_, _, _, Err(_)) = mod_kind {
                     self.r.mods_with_parse_errors.insert(def_id);
                 }
-                self.parent_scope.module = self.r.new_module(
+                self.parent_scope.module = self.r.new_local_module(
                     Some(parent),
                     ModuleKind::Def(def_kind, def_id, Some(ident.name)),
                     expansion.to_expn_id(),
@@ -790,7 +793,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             ItemKind::Enum(ident, _, _) | ItemKind::Trait(box ast::Trait { ident, .. }) => {
                 self.r.define(parent, ident, TypeNS, res, vis, sp, expansion);
 
-                self.parent_scope.module = self.r.new_module(
+                self.parent_scope.module = self.r.new_local_module(
                     Some(parent),
                     ModuleKind::Def(def_kind, def_id, Some(ident.name)),
                     expansion.to_expn_id(),
@@ -986,7 +989,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         let parent = self.parent_scope.module;
         let expansion = self.parent_scope.expansion;
         if self.block_needs_anonymous_module(block) {
-            let module = self.r.new_module(
+            let module = self.r.new_local_module(
                 Some(parent),
                 ModuleKind::Block,
                 expansion.to_expn_id(),
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index d263ab25045..9e9ab7356b8 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -2159,7 +2159,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             .keys()
             .map(|ident| ident.name)
             .chain(
-                self.module_map
+                self.local_module_map
+                    .iter()
+                    .filter(|(_, module)| {
+                        current_module.is_ancestor_of(**module) && current_module != **module
+                    })
+                    .flat_map(|(_, module)| module.kind.name()),
+            )
+            .chain(
+                self.extern_module_map
+                    .borrow()
                     .iter()
                     .filter(|(_, module)| {
                         current_module.is_ancestor_of(**module) && current_module != **module
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 73a6d4c0c3e..98786c1e6f9 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -1081,7 +1081,10 @@ pub struct Resolver<'ra, 'tcx> {
     /// some AST passes can generate identifiers that only resolve to local or
     /// lang items.
     empty_module: Module<'ra>,
-    module_map: FxIndexMap<DefId, Module<'ra>>,
+    /// Eagerly populated map of all local non-block modules.
+    local_module_map: FxIndexMap<LocalDefId, Module<'ra>>,
+    /// Lazily populated cache of modules loaded from external crates.
+    extern_module_map: RefCell<FxIndexMap<DefId, Module<'ra>>>,
     binding_parent_modules: FxHashMap<NameBinding<'ra>, Module<'ra>>,
 
     underscore_disambiguator: u32,
@@ -1112,8 +1115,9 @@ pub struct Resolver<'ra, 'tcx> {
     builtin_macros: FxHashMap<Symbol, SyntaxExtensionKind>,
     registered_tools: &'tcx RegisteredTools,
     macro_use_prelude: FxIndexMap<Symbol, NameBinding<'ra>>,
+    /// Eagerly populated map of all local macro definitions.
     local_macro_map: FxHashMap<LocalDefId, &'ra MacroData>,
-    /// Lazily populated cache of macros loaded from external crates.
+    /// Lazily populated cache of macro definitions loaded from external crates.
     extern_macro_map: RefCell<FxHashMap<DefId, &'ra MacroData>>,
     dummy_ext_bang: Arc<SyntaxExtension>,
     dummy_ext_derive: Arc<SyntaxExtension>,
@@ -1265,7 +1269,6 @@ impl<'ra> ResolverArenas<'ra> {
         expn_id: ExpnId,
         span: Span,
         no_implicit_prelude: bool,
-        module_map: &mut FxIndexMap<DefId, Module<'ra>>,
     ) -> Module<'ra> {
         let (def_id, self_binding) = match kind {
             ModuleKind::Def(def_kind, def_id, _) => (
@@ -1285,9 +1288,6 @@ impl<'ra> ResolverArenas<'ra> {
         if def_id.is_none_or(|def_id| def_id.is_local()) {
             self.local_modules.borrow_mut().push(module);
         }
-        if let Some(def_id) = def_id {
-            module_map.insert(def_id, module);
-        }
         module
     }
     fn local_modules(&'ra self) -> std::cell::Ref<'ra, Vec<Module<'ra>>> {
@@ -1428,22 +1428,21 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         arenas: &'ra ResolverArenas<'ra>,
     ) -> Resolver<'ra, 'tcx> {
         let root_def_id = CRATE_DEF_ID.to_def_id();
-        let mut module_map = FxIndexMap::default();
+        let mut local_module_map = FxIndexMap::default();
         let graph_root = arenas.new_module(
             None,
             ModuleKind::Def(DefKind::Mod, root_def_id, None),
             ExpnId::root(),
             crate_span,
             attr::contains_name(attrs, sym::no_implicit_prelude),
-            &mut module_map,
         );
+        local_module_map.insert(CRATE_DEF_ID, graph_root);
         let empty_module = arenas.new_module(
             None,
             ModuleKind::Def(DefKind::Mod, root_def_id, None),
             ExpnId::root(),
             DUMMY_SP,
             true,
-            &mut Default::default(),
         );
 
         let mut node_id_to_def_id = NodeMap::default();
@@ -1504,7 +1503,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             trait_map: NodeMap::default(),
             underscore_disambiguator: 0,
             empty_module,
-            module_map,
+            local_module_map,
+            extern_module_map: Default::default(),
             block_map: Default::default(),
             binding_parent_modules: FxHashMap::default(),
             ast_transform_scopes: FxHashMap::default(),
@@ -1608,7 +1608,22 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         resolver
     }
 
-    fn new_module(
+    fn new_local_module(
+        &mut self,
+        parent: Option<Module<'ra>>,
+        kind: ModuleKind,
+        expn_id: ExpnId,
+        span: Span,
+        no_implicit_prelude: bool,
+    ) -> Module<'ra> {
+        let module = self.arenas.new_module(parent, kind, expn_id, span, no_implicit_prelude);
+        if let Some(def_id) = module.opt_def_id() {
+            self.local_module_map.insert(def_id.expect_local(), module);
+        }
+        module
+    }
+
+    fn new_extern_module(
         &mut self,
         parent: Option<Module<'ra>>,
         kind: ModuleKind,
@@ -1616,8 +1631,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         span: Span,
         no_implicit_prelude: bool,
     ) -> Module<'ra> {
-        let module_map = &mut self.module_map;
-        self.arenas.new_module(parent, kind, expn_id, span, no_implicit_prelude, module_map)
+        let module = self.arenas.new_module(parent, kind, expn_id, span, no_implicit_prelude);
+        self.extern_module_map.borrow_mut().insert(module.def_id(), module);
+        module
     }
 
     fn new_local_macro(&mut self, def_id: LocalDefId, macro_data: MacroData) -> &'ra MacroData {
-- 
cgit 1.4.1-3-g733a5


From 6849f816b1c908b446698a08b5cd27d258bad073 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Mon, 7 Jul 2025 00:39:07 +0300
Subject: resolve: Change `&mut Resolver` to `&Resolver` when possible

---
 compiler/rustc_expand/src/base.rs                  |  2 +-
 compiler/rustc_resolve/src/build_reduced_graph.rs  | 14 ++++++-------
 compiler/rustc_resolve/src/diagnostics.rs          | 15 +++++---------
 .../rustc_resolve/src/effective_visibilities.rs    |  6 +++---
 compiler/rustc_resolve/src/ident.rs                |  4 ++--
 compiler/rustc_resolve/src/imports.rs              |  2 +-
 compiler/rustc_resolve/src/late.rs                 |  2 +-
 compiler/rustc_resolve/src/late/diagnostics.rs     | 24 +++++++++-------------
 compiler/rustc_resolve/src/lib.rs                  |  6 +++---
 compiler/rustc_resolve/src/macros.rs               |  4 ++--
 10 files changed, 35 insertions(+), 44 deletions(-)

diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index ce3006c2604..1928cfd9048 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -1062,7 +1062,7 @@ pub trait ResolverExpand {
     fn next_node_id(&mut self) -> NodeId;
     fn invocation_parent(&self, id: LocalExpnId) -> LocalDefId;
 
-    fn resolve_dollar_crates(&mut self);
+    fn resolve_dollar_crates(&self);
     fn visit_ast_fragment_with_placeholders(
         &mut self,
         expn_id: LocalExpnId,
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index 676acd78ea7..e56aabfd414 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -85,7 +85,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     /// Reachable macros with block module parents exist due to `#[macro_export] macro_rules!`,
     /// but they cannot use def-site hygiene, so the assumption holds
     /// (<https://github.com/rust-lang/rust/pull/77984#issuecomment-712445508>).
-    pub(crate) fn get_nearest_non_block_module(&mut self, mut def_id: DefId) -> Module<'ra> {
+    pub(crate) fn get_nearest_non_block_module(&self, mut def_id: DefId) -> Module<'ra> {
         loop {
             match self.get_module(def_id) {
                 Some(module) => return module,
@@ -94,14 +94,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
-    pub(crate) fn expect_module(&mut self, def_id: DefId) -> Module<'ra> {
+    pub(crate) fn expect_module(&self, def_id: DefId) -> Module<'ra> {
         self.get_module(def_id).expect("argument `DefId` is not a module")
     }
 
     /// If `def_id` refers to a module (in resolver's sense, i.e. a module item, crate root, enum,
     /// or trait), then this function returns that module's resolver representation, otherwise it
     /// returns `None`.
-    pub(crate) fn get_module(&mut self, def_id: DefId) -> Option<Module<'ra>> {
+    pub(crate) fn get_module(&self, def_id: DefId) -> Option<Module<'ra>> {
         match def_id.as_local() {
             Some(local_def_id) => self.local_module_map.get(&local_def_id).copied(),
             None => {
@@ -134,7 +134,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
-    pub(crate) fn expn_def_scope(&mut self, expn_id: ExpnId) -> Module<'ra> {
+    pub(crate) fn expn_def_scope(&self, expn_id: ExpnId) -> Module<'ra> {
         match expn_id.expn_data().macro_def_id {
             Some(def_id) => self.macro_def_scope(def_id),
             None => expn_id
@@ -144,7 +144,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
-    pub(crate) fn macro_def_scope(&mut self, def_id: DefId) -> Module<'ra> {
+    pub(crate) fn macro_def_scope(&self, def_id: DefId) -> Module<'ra> {
         if let Some(id) = def_id.as_local() {
             self.local_macro_def_scopes[&id]
         } else {
@@ -406,7 +406,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         self.r.field_visibility_spans.insert(def_id, field_vis);
     }
 
-    fn block_needs_anonymous_module(&mut self, block: &Block) -> bool {
+    fn block_needs_anonymous_module(&self, block: &Block) -> bool {
         // If any statements are items, we need to create an anonymous module
         block
             .stmts
@@ -1121,7 +1121,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
     }
 
     /// Returns `true` if this attribute list contains `macro_use`.
-    fn contains_macro_use(&mut self, attrs: &[ast::Attribute]) -> bool {
+    fn contains_macro_use(&self, attrs: &[ast::Attribute]) -> bool {
         for attr in attrs {
             if attr.has_name(sym::macro_escape) {
                 let inner_attribute = matches!(attr.style, ast::AttrStyle::Inner);
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 9e9ab7356b8..aa12a842e6e 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -2150,7 +2150,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     }
 
     pub(crate) fn find_similarly_named_module_or_crate(
-        &mut self,
+        &self,
         ident: Symbol,
         current_module: Module<'ra>,
     ) -> Option<Symbol> {
@@ -2444,7 +2444,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     }
 
     fn undeclared_module_suggest_declare(
-        &mut self,
+        &self,
         ident: Ident,
         path: std::path::PathBuf,
     ) -> Option<(Vec<(Span, String)>, String, Applicability)> {
@@ -2459,7 +2459,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         ))
     }
 
-    fn undeclared_module_exists(&mut self, ident: Ident) -> Option<std::path::PathBuf> {
+    fn undeclared_module_exists(&self, ident: Ident) -> Option<std::path::PathBuf> {
         let map = self.tcx.sess.source_map();
 
         let src = map.span_to_filename(ident.span).into_local_path()?;
@@ -2780,12 +2780,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     }
 
     /// Finds a cfg-ed out item inside `module` with the matching name.
-    pub(crate) fn find_cfg_stripped(
-        &mut self,
-        err: &mut Diag<'_>,
-        segment: &Symbol,
-        module: DefId,
-    ) {
+    pub(crate) fn find_cfg_stripped(&self, err: &mut Diag<'_>, segment: &Symbol, module: DefId) {
         let local_items;
         let symbols = if module.is_local() {
             local_items = self
@@ -2811,7 +2806,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
 
             fn comes_from_same_module_for_glob(
-                r: &mut Resolver<'_, '_>,
+                r: &Resolver<'_, '_>,
                 parent_module: DefId,
                 module: DefId,
                 visited: &mut FxHashMap<DefId, bool>,
diff --git a/compiler/rustc_resolve/src/effective_visibilities.rs b/compiler/rustc_resolve/src/effective_visibilities.rs
index 741671b6d2f..34d1e9552fd 100644
--- a/compiler/rustc_resolve/src/effective_visibilities.rs
+++ b/compiler/rustc_resolve/src/effective_visibilities.rs
@@ -38,11 +38,11 @@ pub(crate) struct EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
 }
 
 impl Resolver<'_, '_> {
-    fn nearest_normal_mod(&mut self, def_id: LocalDefId) -> LocalDefId {
+    fn nearest_normal_mod(&self, def_id: LocalDefId) -> LocalDefId {
         self.get_nearest_non_block_module(def_id.to_def_id()).nearest_parent_mod().expect_local()
     }
 
-    fn private_vis_import(&mut self, binding: NameBinding<'_>) -> Visibility {
+    fn private_vis_import(&self, binding: NameBinding<'_>) -> Visibility {
         let NameBindingKind::Import { import, .. } = binding.kind else { unreachable!() };
         Visibility::Restricted(
             import
@@ -52,7 +52,7 @@ impl Resolver<'_, '_> {
         )
     }
 
-    fn private_vis_def(&mut self, def_id: LocalDefId) -> Visibility {
+    fn private_vis_def(&self, def_id: LocalDefId) -> Visibility {
         // For mod items `nearest_normal_mod` returns its argument, but we actually need its parent.
         let normal_mod_id = self.nearest_normal_mod(def_id);
         if normal_mod_id == def_id {
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 6ac3034d1d9..34941398a2b 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -219,7 +219,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     }
 
     fn hygienic_lexical_parent(
-        &mut self,
+        &self,
         module: Module<'ra>,
         ctxt: &mut SyntaxContext,
         derive_fallback_lint_id: Option<NodeId>,
@@ -885,7 +885,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             );
         }
 
-        let check_usable = |this: &mut Self, binding: NameBinding<'ra>| {
+        let check_usable = |this: &Self, binding: NameBinding<'ra>| {
             let usable = this.is_accessible_from(binding.vis, parent_scope.module);
             if usable { Ok(binding) } else { Err((Determined, Weak::No)) }
         };
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 9a031ee03e0..4b20d50c427 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -456,7 +456,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         f: F,
     ) -> T
     where
-        F: FnOnce(&mut Resolver<'ra, 'tcx>, &mut NameResolution<'ra>) -> T,
+        F: FnOnce(&Resolver<'ra, 'tcx>, &mut NameResolution<'ra>) -> T,
     {
         // Ensure that `resolution` isn't borrowed when defining in the module's glob importers,
         // during which the resolution might end up getting re-defined via a glob cycle.
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 3ef98100d09..753b9365cd8 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -2491,7 +2491,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
 
     /// Searches the current set of local scopes for labels. Returns the `NodeId` of the resolved
     /// label and reports an error if the label is not found or is unreachable.
-    fn resolve_label(&mut self, mut label: Ident) -> Result<(NodeId, Span), ResolutionError<'ra>> {
+    fn resolve_label(&self, mut label: Ident) -> Result<(NodeId, Span), ResolutionError<'ra>> {
         let mut suggestion = None;
 
         for i in (0..self.label_ribs.len()).rev() {
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index 70a7dbf1b04..ee462d90764 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -939,7 +939,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
     }
 
     fn suggest_trait_and_bounds(
-        &mut self,
+        &self,
         err: &mut Diag<'_>,
         source: PathSource<'_, '_, '_>,
         res: Option<Res>,
@@ -1140,7 +1140,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
 
     /// Emit special messages for unresolved `Self` and `self`.
     fn suggest_self_ty(
-        &mut self,
+        &self,
         err: &mut Diag<'_>,
         source: PathSource<'_, '_, '_>,
         path: &[Segment],
@@ -1256,7 +1256,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
     }
 
     fn detect_missing_binding_available_from_pattern(
-        &mut self,
+        &self,
         err: &mut Diag<'_>,
         path: &[Segment],
         following_seg: Option<&Segment>,
@@ -1302,11 +1302,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
         }
     }
 
-    fn suggest_at_operator_in_slice_pat_with_range(
-        &mut self,
-        err: &mut Diag<'_>,
-        path: &[Segment],
-    ) {
+    fn suggest_at_operator_in_slice_pat_with_range(&self, err: &mut Diag<'_>, path: &[Segment]) {
         let Some(pat) = self.diag_metadata.current_pat else { return };
         let (bound, side, range) = match &pat.kind {
             ast::PatKind::Range(Some(bound), None, range) => (bound, Side::Start, range),
@@ -1367,7 +1363,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
     }
 
     fn explain_functions_in_pattern(
-        &mut self,
+        &self,
         err: &mut Diag<'_>,
         res: Option<Res>,
         source: PathSource<'_, '_, '_>,
@@ -1379,7 +1375,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
     }
 
     fn suggest_changing_type_to_const_param(
-        &mut self,
+        &self,
         err: &mut Diag<'_>,
         res: Option<Res>,
         source: PathSource<'_, '_, '_>,
@@ -1429,7 +1425,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
     }
 
     fn suggest_pattern_match_with_let(
-        &mut self,
+        &self,
         err: &mut Diag<'_>,
         source: PathSource<'_, '_, '_>,
         span: Span,
@@ -1485,7 +1481,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
     }
 
     /// Given `where <T as Bar>::Baz: String`, suggest `where T: Bar<Baz = String>`.
-    fn restrict_assoc_type_in_where_clause(&mut self, span: Span, err: &mut Diag<'_>) -> bool {
+    fn restrict_assoc_type_in_where_clause(&self, span: Span, err: &mut Diag<'_>) -> bool {
         // Detect that we are actually in a `where` predicate.
         let (bounded_ty, bounds, where_span) = if let Some(ast::WherePredicate {
             kind:
@@ -1633,7 +1629,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
         let ns = source.namespace();
         let is_expected = &|res| source.is_expected(res);
 
-        let path_sep = |this: &mut Self, err: &mut Diag<'_>, expr: &Expr, kind: DefKind| {
+        let path_sep = |this: &Self, err: &mut Diag<'_>, expr: &Expr, kind: DefKind| {
             const MESSAGE: &str = "use the path separator to refer to an item";
 
             let (lhs_span, rhs_span) = match &expr.kind {
@@ -2587,7 +2583,7 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
 
     // try to give a suggestion for this pattern: `name = blah`, which is common in other languages
     // suggest `let name = blah` to introduce a new binding
-    fn let_binding_suggestion(&mut self, err: &mut Diag<'_>, ident_span: Span) -> bool {
+    fn let_binding_suggestion(&self, err: &mut Diag<'_>, ident_span: Span) -> bool {
         if ident_span.from_expansion() {
             return false;
         }
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 98786c1e6f9..3202d31fdbc 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -1624,7 +1624,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     }
 
     fn new_extern_module(
-        &mut self,
+        &self,
         parent: Option<Module<'ra>>,
         kind: ModuleKind,
         expn_id: ExpnId,
@@ -2021,7 +2021,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
-    fn resolve_crate_root(&mut self, ident: Ident) -> Module<'ra> {
+    fn resolve_crate_root(&self, ident: Ident) -> Module<'ra> {
         debug!("resolve_crate_root({:?})", ident);
         let mut ctxt = ident.span.ctxt();
         let mark = if ident.name == kw::DollarCrate {
@@ -2094,7 +2094,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         module
     }
 
-    fn resolve_self(&mut self, ctxt: &mut SyntaxContext, module: Module<'ra>) -> Module<'ra> {
+    fn resolve_self(&self, ctxt: &mut SyntaxContext, module: Module<'ra>) -> Module<'ra> {
         let mut module = self.expect_module(module.nearest_parent_mod());
         while module.span.ctxt().normalize_to_macros_2_0() != *ctxt {
             let parent = module.parent.unwrap_or_else(|| self.expn_def_scope(ctxt.remove_mark()));
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index c17d74659db..77ef7f56c09 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -170,7 +170,7 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
         self.invocation_parents[&id].parent_def
     }
 
-    fn resolve_dollar_crates(&mut self) {
+    fn resolve_dollar_crates(&self) {
         hygiene::update_dollar_crate_names(|ctxt| {
             let ident = Ident::new(kw::DollarCrate, DUMMY_SP.with_ctxt(ctxt));
             match self.resolve_crate_root(ident).kind {
@@ -835,7 +835,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     }
 
     pub(crate) fn finalize_macro_resolutions(&mut self, krate: &Crate) {
-        let check_consistency = |this: &mut Self,
+        let check_consistency = |this: &Self,
                                  path: &[Segment],
                                  span,
                                  kind: MacroKind,
-- 
cgit 1.4.1-3-g733a5


From fad8dec970f51a2d4c23593b059b1684bd85472a Mon Sep 17 00:00:00 2001
From: anatawa12 <anatawa12@icloud.com>
Date: Wed, 16 Jul 2025 15:39:31 +0900
Subject: fix: false positive double_negations when it jumps macro boundary

---
 compiler/rustc_lint/src/builtin.rs               |  2 ++
 tests/ui/lint/lint-double-negations-macro.rs     | 16 ++++++++++++++++
 tests/ui/lint/lint-double-negations-macro.stderr | 20 ++++++++++++++++++++
 3 files changed, 38 insertions(+)
 create mode 100644 tests/ui/lint/lint-double-negations-macro.rs
 create mode 100644 tests/ui/lint/lint-double-negations-macro.stderr

diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 255ff56f62b..93df056c43b 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -1584,6 +1584,8 @@ impl EarlyLintPass for DoubleNegations {
         if let ExprKind::Unary(UnOp::Neg, ref inner) = expr.kind
             && let ExprKind::Unary(UnOp::Neg, ref inner2) = inner.kind
             && !matches!(inner2.kind, ExprKind::Unary(UnOp::Neg, _))
+            // Don't lint if this jumps macro expansion boundary (Issue #143980)
+            && expr.span.eq_ctxt(inner.span)
         {
             cx.emit_span_lint(
                 DOUBLE_NEGATIONS,
diff --git a/tests/ui/lint/lint-double-negations-macro.rs b/tests/ui/lint/lint-double-negations-macro.rs
new file mode 100644
index 00000000000..a6583271d5a
--- /dev/null
+++ b/tests/ui/lint/lint-double-negations-macro.rs
@@ -0,0 +1,16 @@
+//@ check-pass
+macro_rules! neg {
+    ($e: expr) => {
+        -$e
+    };
+}
+macro_rules! bad_macro {
+    ($e: expr) => {
+        --$e //~ WARN use of a double negation
+    };
+}
+
+fn main() {
+    neg!(-1);
+    bad_macro!(1);
+}
diff --git a/tests/ui/lint/lint-double-negations-macro.stderr b/tests/ui/lint/lint-double-negations-macro.stderr
new file mode 100644
index 00000000000..d6ac9be48f3
--- /dev/null
+++ b/tests/ui/lint/lint-double-negations-macro.stderr
@@ -0,0 +1,20 @@
+warning: use of a double negation
+  --> $DIR/lint-double-negations-macro.rs:9:9
+   |
+LL |         --$e
+   |         ^^^^
+...
+LL |     bad_macro!(1);
+   |     ------------- in this macro invocation
+   |
+   = note: the prefix `--` could be misinterpreted as a decrement operator which exists in other languages
+   = note: use `-= 1` if you meant to decrement the value
+   = note: `#[warn(double_negations)]` on by default
+   = note: this warning originates in the macro `bad_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: add parentheses for clarity
+   |
+LL |         -(-$e)
+   |          +   +
+
+warning: 1 warning emitted
+
-- 
cgit 1.4.1-3-g733a5


From 8df6a1d26636bb60fd9f8d45e3da9c0c2529ee29 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Thu, 17 Jul 2025 05:42:53 +0200
Subject: some improvements to "Invariants of the type system"

---
 src/doc/rustc-dev-guide/src/solve/invariants.md | 41 +++++++++++++------------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/solve/invariants.md b/src/doc/rustc-dev-guide/src/solve/invariants.md
index 2f5a134f4df..8ec15f339e5 100644
--- a/src/doc/rustc-dev-guide/src/solve/invariants.md
+++ b/src/doc/rustc-dev-guide/src/solve/invariants.md
@@ -4,10 +4,10 @@ FIXME: This file talks about invariants of the type system as a whole, not only
 
 There are a lot of invariants - things the type system guarantees to be true at all times -
 which are desirable or expected from other languages and type systems. Unfortunately, quite
-a few of them do not hold in Rust right now. This is either a fundamental to its design or
-caused by bugs and something that may change in the future.
+a few of them do not hold in Rust right now. This is either fundamental to its design or
+caused by bugs, and something that may change in the future.
 
-It is important to know about the things you can assume while working on - and with - the
+It is important to know about the things you can assume while working on, and with, the
 type system, so here's an incomplete and unofficial list of invariants of
 the core type system:
 
@@ -29,14 +29,15 @@ If you have a some type and equate it to itself after replacing any regions with
 inference variables in both the lhs and rhs, the now potentially structurally different
 types should still be equal to each other.
 
-Needed to prevent goals from succeeding in HIR typeck and then failing in MIR borrowck.
-If this invariant is broken MIR typeck ends up failing with an ICE.
+This is needed to prevent goals from succeeding in HIR typeck and then failing in MIR borrowck.
+If this invariant is broken, MIR typeck ends up failing with an ICE.
 
 ### Applying inference results from a goal does not change its result ❌
 
 TODO: this invariant is formulated in a weird way and needs to be elaborated.
 Pretty much: I would like this check to only fail if there's a solver bug:
-https://github.com/rust-lang/rust/blob/2ffeb4636b4ae376f716dc4378a7efb37632dc2d/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs#L391-L407 We should readd this check and see where it breaks :3
+<https://github.com/rust-lang/rust/blob/2ffeb4636b4ae376f716dc4378a7efb37632dc2d/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs#L391-L407>.
+We should readd this check and see where it breaks :3
 
 If we prove some goal/equate types/whatever, apply the resulting inference constraints,
 and then redo the original action, the result should be the same.
@@ -75,8 +76,8 @@ the issue is that the invariant is broken, not that we incorrectly rely on it.
 
 ### The type system is complete ❌
 
-The type system is not complete, it often adds unnecessary inference constraints, and errors
-even though the goal could hold.
+The type system is not complete.
+It often adds unnecessary inference constraints, and errors even though the goal could hold.
 
 - method selection
 - opaque type inference
@@ -95,11 +96,13 @@ It is interesting that we allow some incompleteness in the trait solver while st
 #### Normalization must not change results
 
 This invariant is relied on to allow the normalization of generic aliases. Breaking
-it can easily result in unsoundness, e.g. [#57893](https://github.com/rust-lang/rust/issues/57893)
+it can easily result in unsoundness, e.g. [#57893](https://github.com/rust-lang/rust/issues/57893).
 
 #### Goals may still overflow after instantiation
 
-As they start to hit the recursion limit. We also have diverging aliases which are scuffed. It's unclear how these should be handled :3
+This happens they start to hit the recursion limit.
+We also have diverging aliases which are scuffed.
+It's unclear how these should be handled :3
 
 ### Trait goals in empty environments are proven by a unique impl ✅
 
@@ -107,8 +110,7 @@ If a trait goal holds with an empty environment, there should be a unique `impl`
 either user-defined or builtin, which is used to prove that goal. This is
 necessary to select unique methods and associated items.
 
-We do however break this invariant in few cases, some of which are due to bugs,
-some by design:
+We do however break this invariant in a few cases, some of which are due to bugs, some by design:
 - *marker traits* are allowed to overlap as they do not have associated items
 - *specialization* allows specializing impls to overlap with their parent
 - the builtin trait object trait implementation can overlap with a user-defined impl:
@@ -117,11 +119,12 @@ some by design:
 
 #### The type system is complete during the implicit negative overlap check in coherence ✅
 
-For more on overlap checking: [coherence]
+For more on overlap checking, see [Coherence chapter].
 
-During the implicit negative overlap check in coherence we must never return *error* for
-goals which can be proven. This would allow for overlapping impls with potentially different
-associated items, breaking a bunch of other invariants.
+During the implicit negative overlap check in coherence,
+we must never return *error* for goals which can be proven.
+This would allow for overlapping impls with potentially different associated items,
+breaking a bunch of other invariants.
 
 This invariant is currently broken in many different ways while actually something we rely on.
 We have to be careful as it is quite easy to break:
@@ -147,8 +150,8 @@ This currently does not hold with the new solver: [trait-system-refactor-initiat
 Ideally we *should* not rely on ambiguity for things to compile.
 Not doing that will cause future improvements to be breaking changes.
 
-Due to *incompleteness* this is not the case and improving inference can result in inference
-changes, breaking existing projects.
+Due to *incompleteness* this is not the case,
+and improving inference can result in inference changes, breaking existing projects.
 
 ### Semantic equality implies structural equality ✅
 
@@ -166,4 +169,4 @@ Semantically different `'static` types need different `TypeId`s to avoid transmu
 for example `for<'a> fn(&'a str)` vs `fn(&'static str)` must have a different `TypeId`.
 
 
-[coherence]: ../coherence.md
+[coherence chapter]: ../coherence.md
-- 
cgit 1.4.1-3-g733a5


From 2faf5ed0cd20debd5eb6efe1795badccf6390c60 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Thu, 17 Jul 2025 04:14:28 +0000
Subject: Prepare for merging from rust-lang/rust

This updates the rust-version file to fd2eb391d032181459773f3498c17b198513e0d0.
---
 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 e444613e631..3f10132b684 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-c96a69059ecc618b519da385a6ccd03155aa0237
+fd2eb391d032181459773f3498c17b198513e0d0
-- 
cgit 1.4.1-3-g733a5


From dd364bd2261b37b6cd0d7f823b158a0c2903746b Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Thu, 17 Jul 2025 06:32:23 +0200
Subject: copy-paste convenience

---
 src/doc/rustc-dev-guide/src/external-repos.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/doc/rustc-dev-guide/src/external-repos.md b/src/doc/rustc-dev-guide/src/external-repos.md
index 68986a0bc68..ecc65b26ab7 100644
--- a/src/doc/rustc-dev-guide/src/external-repos.md
+++ b/src/doc/rustc-dev-guide/src/external-repos.md
@@ -60,7 +60,10 @@ Currently, we are migrating Josh repositories to it. So far, it is used in:
 - rustc-dev-guide
 - stdarch
 
-To use the tool, first install it with `cargo install --locked --git https://github.com/rust-lang/josh-sync`.
+To install the tool:
+```
+cargo install --locked --git https://github.com/rust-lang/josh-sync
+```
 
 Both pulls (synchronize changes from rust-lang/rust into the subtree) and pushes (synchronize
 changes from the subtree to rust-lang/rust) are performed from the subtree repository (so first
-- 
cgit 1.4.1-3-g733a5


From 5946616c064330cb7418930dd20f317e5a4d5339 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Thu, 17 Jul 2025 04:59:14 +0000
Subject: Preparing for merge from rustc

---
 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 67f27e7aa2c..3f10132b684 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-7f2065a4bae1faed5bab928c670964eafbf43b55
+fd2eb391d032181459773f3498c17b198513e0d0
-- 
cgit 1.4.1-3-g733a5


From 49ae52e3ffeb3d98f19845eba5eb9fa1408fa432 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Thu, 17 Jul 2025 08:02:26 +0200
Subject: Fix encoding of `link_section` and `no_mangle` cross crate

---
 compiler/rustc_attr_data_structures/src/encode_cross_crate.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 3e2dc0a15b2..c24b45e83f9 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -40,9 +40,9 @@ impl AttributeKind {
             Fundamental { .. } => Yes,
             Ignore { .. } => No,
             Inline(..) => No,
-            LinkName { .. } => Yes,
+            LinkName { .. } => Yes, // Needed for rustdoc
             LinkOrdinal { .. } => No,
-            LinkSection { .. } => No,
+            LinkSection { .. } => Yes, // Needed for rustdoc
             LoopMatch(..) => No,
             MacroTransparency(..) => Yes,
             Marker(..) => No,
@@ -50,8 +50,8 @@ impl AttributeKind {
             MustUse { .. } => Yes,
             Naked(..) => No,
             NoImplicitPrelude(..) => No,
-            NoMangle(..) => No,
-            NonExhaustive(..) => Yes,
+            NoMangle(..) => Yes,      // Needed for rustdoc
+            NonExhaustive(..) => Yes, // Needed for rustdoc
             OmitGdbPrettyPrinterSection => No,
             Optimize(..) => No,
             ParenSugar(..) => No,
-- 
cgit 1.4.1-3-g733a5


From 9f16db6611b0fb35f4a16dcbf326fb9aee3d87f3 Mon Sep 17 00:00:00 2001
From: Jonathan Brouwer <jonathantbrouwer@gmail.com>
Date: Thu, 17 Jul 2025 08:03:17 +0200
Subject: Regression test

---
 tests/rustdoc/reexport/auxiliary/reexports-attrs.rs | 14 ++++++++++++++
 tests/rustdoc/reexport/reexport-attrs.rs            | 20 ++++++++++++++++++++
 2 files changed, 34 insertions(+)
 create mode 100644 tests/rustdoc/reexport/auxiliary/reexports-attrs.rs
 create mode 100644 tests/rustdoc/reexport/reexport-attrs.rs

diff --git a/tests/rustdoc/reexport/auxiliary/reexports-attrs.rs b/tests/rustdoc/reexport/auxiliary/reexports-attrs.rs
new file mode 100644
index 00000000000..96fa8209cde
--- /dev/null
+++ b/tests/rustdoc/reexport/auxiliary/reexports-attrs.rs
@@ -0,0 +1,14 @@
+#[unsafe(no_mangle)]
+pub fn f0() {}
+
+#[unsafe(link_section = ".here")]
+pub fn f1() {}
+
+#[unsafe(export_name = "f2export")]
+pub fn f2() {}
+
+#[repr(u8)]
+pub enum T0 { V1 }
+
+#[non_exhaustive]
+pub enum T1 {}
diff --git a/tests/rustdoc/reexport/reexport-attrs.rs b/tests/rustdoc/reexport/reexport-attrs.rs
new file mode 100644
index 00000000000..0ec645841f0
--- /dev/null
+++ b/tests/rustdoc/reexport/reexport-attrs.rs
@@ -0,0 +1,20 @@
+//@ aux-build: reexports-attrs.rs
+
+#![crate_name = "foo"]
+
+extern crate reexports_attrs;
+
+//@ has 'foo/fn.f0.html' '//pre[@class="rust item-decl"]' '#[no_mangle]'
+pub use reexports_attrs::f0;
+
+//@ has 'foo/fn.f1.html' '//pre[@class="rust item-decl"]' '#[link_section = ".here"]'
+pub use reexports_attrs::f1;
+
+//@ has 'foo/fn.f2.html' '//pre[@class="rust item-decl"]' '#[export_name = "f2export"]'
+pub use reexports_attrs::f2;
+
+//@ has 'foo/enum.T0.html' '//pre[@class="rust item-decl"]' '#[repr(u8)]'
+pub use reexports_attrs::T0;
+
+//@ has 'foo/enum.T1.html' '//pre[@class="rust item-decl"]' '#[non_exhaustive]'
+pub use reexports_attrs::T1;
-- 
cgit 1.4.1-3-g733a5


From 5bb6b9db300870f436e8a45ffbe11efa41e44cad Mon Sep 17 00:00:00 2001
From: usamoi <usamoi@outlook.com>
Date: Mon, 14 Jul 2025 16:41:42 +0800
Subject: remove no_gc_sections

---
 compiler/rustc_codegen_ssa/src/back/link.rs       |  2 --
 compiler/rustc_codegen_ssa/src/back/linker.rs     | 33 -----------------------
 tests/run-make/export-executable-symbols/rmake.rs |  1 +
 tests/ui/linking/export-executable-symbols.rs     |  1 +
 4 files changed, 2 insertions(+), 35 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index ae148287a60..5ce301c0eb9 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -2543,8 +2543,6 @@ fn add_order_independent_options(
         let keep_metadata =
             crate_type == CrateType::Dylib || sess.opts.cg.profile_generate.enabled();
         cmd.gc_sections(keep_metadata);
-    } else {
-        cmd.no_gc_sections();
     }
 
     cmd.set_output_kind(link_output_kind, crate_type, out_filename);
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index e0a3ad55be0..050797354b4 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -326,7 +326,6 @@ pub(crate) trait Linker {
         link_or_cc_args(self, &[path]);
     }
     fn gc_sections(&mut self, keep_metadata: bool);
-    fn no_gc_sections(&mut self);
     fn full_relro(&mut self);
     fn partial_relro(&mut self);
     fn no_relro(&mut self);
@@ -688,12 +687,6 @@ impl<'a> Linker for GccLinker<'a> {
         }
     }
 
-    fn no_gc_sections(&mut self) {
-        if self.is_gnu || self.sess.target.is_like_wasm {
-            self.link_arg("--no-gc-sections");
-        }
-    }
-
     fn optimize(&mut self) {
         if !self.is_gnu && !self.sess.target.is_like_wasm {
             return;
@@ -1010,10 +1003,6 @@ impl<'a> Linker for MsvcLinker<'a> {
         }
     }
 
-    fn no_gc_sections(&mut self) {
-        self.link_arg("/OPT:NOREF,NOICF");
-    }
-
     fn full_relro(&mut self) {
         // noop
     }
@@ -1243,10 +1232,6 @@ impl<'a> Linker for EmLinker<'a> {
         // noop
     }
 
-    fn no_gc_sections(&mut self) {
-        // noop
-    }
-
     fn optimize(&mut self) {
         // Emscripten performs own optimizations
         self.cc_arg(match self.sess.opts.optimize {
@@ -1418,10 +1403,6 @@ impl<'a> Linker for WasmLd<'a> {
         self.link_arg("--gc-sections");
     }
 
-    fn no_gc_sections(&mut self) {
-        self.link_arg("--no-gc-sections");
-    }
-
     fn optimize(&mut self) {
         // The -O flag is, as of late 2023, only used for merging of strings and debuginfo, and
         // only differentiates -O0 and -O1. It does not apply to LTO.
@@ -1567,10 +1548,6 @@ impl<'a> Linker for L4Bender<'a> {
         }
     }
 
-    fn no_gc_sections(&mut self) {
-        self.link_arg("--no-gc-sections");
-    }
-
     fn optimize(&mut self) {
         // GNU-style linkers support optimization with -O. GNU ld doesn't
         // need a numeric argument, but other linkers do.
@@ -1734,10 +1711,6 @@ impl<'a> Linker for AixLinker<'a> {
         self.link_arg("-bgc");
     }
 
-    fn no_gc_sections(&mut self) {
-        self.link_arg("-bnogc");
-    }
-
     fn optimize(&mut self) {}
 
     fn pgo_gen(&mut self) {
@@ -1982,8 +1955,6 @@ impl<'a> Linker for PtxLinker<'a> {
 
     fn gc_sections(&mut self, _keep_metadata: bool) {}
 
-    fn no_gc_sections(&mut self) {}
-
     fn pgo_gen(&mut self) {}
 
     fn no_crt_objects(&mut self) {}
@@ -2057,8 +2028,6 @@ impl<'a> Linker for LlbcLinker<'a> {
 
     fn gc_sections(&mut self, _keep_metadata: bool) {}
 
-    fn no_gc_sections(&mut self) {}
-
     fn pgo_gen(&mut self) {}
 
     fn no_crt_objects(&mut self) {}
@@ -2139,8 +2108,6 @@ impl<'a> Linker for BpfLinker<'a> {
 
     fn gc_sections(&mut self, _keep_metadata: bool) {}
 
-    fn no_gc_sections(&mut self) {}
-
     fn pgo_gen(&mut self) {}
 
     fn no_crt_objects(&mut self) {}
diff --git a/tests/run-make/export-executable-symbols/rmake.rs b/tests/run-make/export-executable-symbols/rmake.rs
index c602a43f957..aa130b0855b 100644
--- a/tests/run-make/export-executable-symbols/rmake.rs
+++ b/tests/run-make/export-executable-symbols/rmake.rs
@@ -5,6 +5,7 @@
 // See https://github.com/rust-lang/rust/pull/85673
 
 //@ ignore-wasm
+//@ ignore-cross-compile
 
 use run_make_support::object::Object;
 use run_make_support::{bin_name, is_darwin, object, rustc};
diff --git a/tests/ui/linking/export-executable-symbols.rs b/tests/ui/linking/export-executable-symbols.rs
index edaf312f192..2bff58ca38a 100644
--- a/tests/ui/linking/export-executable-symbols.rs
+++ b/tests/ui/linking/export-executable-symbols.rs
@@ -1,6 +1,7 @@
 //@ run-pass
 //@ compile-flags: -Ctarget-feature=-crt-static -Zexport-executable-symbols
 //@ ignore-wasm
+//@ ignore-cross-compile
 //@ edition: 2024
 
 // Regression test for <https://github.com/rust-lang/rust/issues/101610>.
-- 
cgit 1.4.1-3-g733a5


From 6645bf54c159e5b06f829dbf04b6f6360a832993 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Thu, 17 Jul 2025 10:12:55 +0200
Subject: Copy GCC sources into the build directory even outside CI

---
 src/bootstrap/src/core/build_steps/gcc.rs | 25 +++++++++++--------------
 1 file changed, 11 insertions(+), 14 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/gcc.rs b/src/bootstrap/src/core/build_steps/gcc.rs
index 899e3fd9a45..d4cbbe60921 100644
--- a/src/bootstrap/src/core/build_steps/gcc.rs
+++ b/src/bootstrap/src/core/build_steps/gcc.rs
@@ -220,21 +220,18 @@ fn build_gcc(metadata: &Meta, builder: &Builder<'_>, target: TargetSelection) {
     t!(fs::create_dir_all(install_dir));
 
     // GCC creates files (e.g. symlinks to the downloaded dependencies)
-    // in the source directory, which does not work with our CI setup, where we mount
+    // in the source directory, which does not work with our CI/Docker setup, where we mount
     // source directories as read-only on Linux.
-    // Therefore, as a part of the build in CI, we first copy the whole source directory
-    // to the build directory, and perform the build from there.
-    let src_dir = if builder.config.is_running_on_ci {
-        let src_dir = builder.gcc_out(target).join("src");
-        if src_dir.exists() {
-            builder.remove_dir(&src_dir);
-        }
-        builder.create_dir(&src_dir);
-        builder.cp_link_r(root, &src_dir);
-        src_dir
-    } else {
-        root.clone()
-    };
+    // And in general, we shouldn't be modifying the source directories if possible, even for local
+    // builds.
+    // Therefore, we first copy the whole source directory to the build directory, and perform the
+    // build from there.
+    let src_dir = builder.gcc_out(target).join("src");
+    if src_dir.exists() {
+        builder.remove_dir(&src_dir);
+    }
+    builder.create_dir(&src_dir);
+    builder.cp_link_r(root, &src_dir);
 
     command(src_dir.join("contrib/download_prerequisites")).current_dir(&src_dir).run(builder);
     let mut configure_cmd = command(src_dir.join("configure"));
-- 
cgit 1.4.1-3-g733a5


From 5157aa1a0f4d9a7a5f90bff59a7f9f7ca39ca1e9 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Thu, 17 Jul 2025 03:58:43 -0500
Subject: Allow a new lint failure in nightly

```text
warning: function `f32_to_bits` is never used
   --> libm/src/math/support/float_traits.rs:367:14
    |
367 | pub const fn f32_to_bits(x: f32) -> u32 {
    |              ^^^^^^^^^^^
    |
    = note: `#[warn(dead_code)]` on by default

warning: function `f64_to_bits` is never used
   --> libm/src/math/support/float_traits.rs:381:14
    |
381 | pub const fn f64_to_bits(x: f64) -> u64 {
    |              ^^^^^^^^^^^

warning: `libm` (lib) generated 2 warnings
```

This is a false positive, see RUST-144060.
---
 library/compiler-builtins/libm/src/math/support/float_traits.rs | 2 ++
 1 file changed, 2 insertions(+)

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 c3e7eeec245..fb790e69615 100644
--- a/library/compiler-builtins/libm/src/math/support/float_traits.rs
+++ b/library/compiler-builtins/libm/src/math/support/float_traits.rs
@@ -363,6 +363,7 @@ pub const fn f32_from_bits(bits: u32) -> f32 {
 }
 
 /// `f32::to_bits`
+#[allow(dead_code)] // workaround for false positive RUST-144060
 #[allow(unnecessary_transmutes)] // lint appears in newer versions of Rust
 pub const fn f32_to_bits(x: f32) -> u32 {
     // SAFETY: POD cast with no preconditions
@@ -377,6 +378,7 @@ pub const fn f64_from_bits(bits: u64) -> f64 {
 }
 
 /// `f64::to_bits`
+#[allow(dead_code)] // workaround for false positive RUST-144060
 #[allow(unnecessary_transmutes)] // lint appears in newer versions of Rust
 pub const fn f64_to_bits(x: f64) -> u64 {
     // SAFETY: POD cast with no preconditions
-- 
cgit 1.4.1-3-g733a5


From b8f4e3f755fe919cf2c22cf21d3d4caa3ef5858f Mon Sep 17 00:00:00 2001
From: Shashi Shankar <shashishankar1687@gmail.com>
Date: Sat, 12 Jul 2025 18:10:48 +0200
Subject: examples: add `minimal_lsp.rs` and FIFO test script.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* `examples/minimal_lsp.rs` – compact LSP server showing definition,
  completion, hover, rustfmt-based formatting, and dummy diagnostics.
  Advertises UTF-8 offset encoding.

* `examples/manual_test.sh` – FIFO script that streams the canonical
  nine LSP packets so anyone can validate the server from two terminals.

No new runtime deps; `anyhow` stays under [dev-dependencies].
---
 src/tools/rust-analyzer/lib/lsp-server/Cargo.toml  |   3 +
 .../lib/lsp-server/examples/goto_def.rs            | 132 --------
 .../lib/lsp-server/examples/manual_test.sh         |  53 ++++
 .../lib/lsp-server/examples/minimal_lsp.rs         | 335 +++++++++++++++++++++
 4 files changed, 391 insertions(+), 132 deletions(-)
 delete mode 100644 src/tools/rust-analyzer/lib/lsp-server/examples/goto_def.rs
 create mode 100755 src/tools/rust-analyzer/lib/lsp-server/examples/manual_test.sh
 create mode 100644 src/tools/rust-analyzer/lib/lsp-server/examples/minimal_lsp.rs

diff --git a/src/tools/rust-analyzer/lib/lsp-server/Cargo.toml b/src/tools/rust-analyzer/lib/lsp-server/Cargo.toml
index 35a5a4d82b2..1fc1da50a0a 100644
--- a/src/tools/rust-analyzer/lib/lsp-server/Cargo.toml
+++ b/src/tools/rust-analyzer/lib/lsp-server/Cargo.toml
@@ -16,6 +16,9 @@ crossbeam-channel.workspace = true
 [dev-dependencies]
 lsp-types = "=0.95"
 ctrlc = "3.4.7"
+anyhow.workspace     = true
+rustc-hash.workspace = true
+toolchain.workspace  = true
 
 [lints]
 workspace = true
diff --git a/src/tools/rust-analyzer/lib/lsp-server/examples/goto_def.rs b/src/tools/rust-analyzer/lib/lsp-server/examples/goto_def.rs
deleted file mode 100644
index 6b3acda7bcd..00000000000
--- a/src/tools/rust-analyzer/lib/lsp-server/examples/goto_def.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-//! A minimal example LSP server that can only respond to the `gotoDefinition` request. To use
-//! this example, execute it and then send an `initialize` request.
-//!
-//! ```no_run
-//! Content-Length: 85
-//!
-//! {"jsonrpc": "2.0", "method": "initialize", "id": 1, "params": {"capabilities": {}}}
-//! ```
-//!
-//! This will respond with a server response. Then send it a `initialized` notification which will
-//! have no response.
-//!
-//! ```no_run
-//! Content-Length: 59
-//!
-//! {"jsonrpc": "2.0", "method": "initialized", "params": {}}
-//! ```
-//!
-//! Once these two are sent, then we enter the main loop of the server. The only request this
-//! example can handle is `gotoDefinition`:
-//!
-//! ```no_run
-//! Content-Length: 159
-//!
-//! {"jsonrpc": "2.0", "method": "textDocument/definition", "id": 2, "params": {"textDocument": {"uri": "file://temp"}, "position": {"line": 1, "character": 1}}}
-//! ```
-//!
-//! To finish up without errors, send a shutdown request:
-//!
-//! ```no_run
-//! Content-Length: 67
-//!
-//! {"jsonrpc": "2.0", "method": "shutdown", "id": 3, "params": null}
-//! ```
-//!
-//! The server will exit the main loop and finally we send a `shutdown` notification to stop
-//! the server.
-//!
-//! ```
-//! Content-Length: 54
-//!
-//! {"jsonrpc": "2.0", "method": "exit", "params": null}
-//! ```
-
-#![allow(clippy::print_stderr)]
-
-use std::error::Error;
-
-use lsp_types::OneOf;
-use lsp_types::{
-    GotoDefinitionResponse, InitializeParams, ServerCapabilities, request::GotoDefinition,
-};
-
-use lsp_server::{Connection, ExtractError, Message, Request, RequestId, Response};
-
-fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
-    // Note that  we must have our logging only write out to stderr.
-    eprintln!("starting generic LSP server");
-
-    // Create the transport. Includes the stdio (stdin and stdout) versions but this could
-    // also be implemented to use sockets or HTTP.
-    let (connection, io_threads) = Connection::stdio();
-
-    // Run the server and wait for the two threads to end (typically by trigger LSP Exit event).
-    let server_capabilities = serde_json::to_value(&ServerCapabilities {
-        definition_provider: Some(OneOf::Left(true)),
-        ..Default::default()
-    })
-    .unwrap();
-    let initialization_params = match connection.initialize(server_capabilities) {
-        Ok(it) => it,
-        Err(e) => {
-            if e.channel_is_disconnected() {
-                io_threads.join()?;
-            }
-            return Err(e.into());
-        }
-    };
-    main_loop(connection, initialization_params)?;
-    io_threads.join()?;
-
-    // Shut down gracefully.
-    eprintln!("shutting down server");
-    Ok(())
-}
-
-fn main_loop(
-    connection: Connection,
-    params: serde_json::Value,
-) -> Result<(), Box<dyn Error + Sync + Send>> {
-    let _params: InitializeParams = serde_json::from_value(params).unwrap();
-    eprintln!("starting example main loop");
-    for msg in &connection.receiver {
-        eprintln!("got msg: {msg:?}");
-        match msg {
-            Message::Request(req) => {
-                if connection.handle_shutdown(&req)? {
-                    return Ok(());
-                }
-                eprintln!("got request: {req:?}");
-                match cast::<GotoDefinition>(req) {
-                    Ok((id, params)) => {
-                        eprintln!("got gotoDefinition request #{id}: {params:?}");
-                        let result = Some(GotoDefinitionResponse::Array(Vec::new()));
-                        let result = serde_json::to_value(&result).unwrap();
-                        let resp = Response { id, result: Some(result), error: None };
-                        connection.sender.send(Message::Response(resp))?;
-                        continue;
-                    }
-                    Err(err @ ExtractError::JsonError { .. }) => panic!("{err:?}"),
-                    Err(ExtractError::MethodMismatch(req)) => req,
-                };
-                // ...
-            }
-            Message::Response(resp) => {
-                eprintln!("got response: {resp:?}");
-            }
-            Message::Notification(not) => {
-                eprintln!("got notification: {not:?}");
-            }
-        }
-    }
-    Ok(())
-}
-
-fn cast<R>(req: Request) -> Result<(RequestId, R::Params), ExtractError<Request>>
-where
-    R: lsp_types::request::Request,
-    R::Params: serde::de::DeserializeOwned,
-{
-    req.extract(R::METHOD)
-}
diff --git a/src/tools/rust-analyzer/lib/lsp-server/examples/manual_test.sh b/src/tools/rust-analyzer/lib/lsp-server/examples/manual_test.sh
new file mode 100755
index 00000000000..d028ac43301
--- /dev/null
+++ b/src/tools/rust-analyzer/lib/lsp-server/examples/manual_test.sh
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# Simple nine-packet LSP test for examples/minimal_lsp.rs
+# Usage (two tabs):
+#
+#   mkfifo /tmp/lsp_pipe          # one-time setup
+#   # tab 1 – run the server
+#   cat /tmp/lsp_pipe | cargo run --example minimal_lsp
+#
+#   # tab 2 – fire the packets (this script)
+#   bash examples/manual_test.sh          # blocks until server exits
+#
+# If you don’t use a second tab, run the script in the background:
+#
+#   bash examples/manual_test.sh &        # writer in background
+#   cat /tmp/lsp_pipe | cargo run --example minimal_lsp
+#
+# The script opens /tmp/lsp_pipe for writing (exec 3>) and sends each JSON
+# packet with a correct Content-Length header.
+#
+# One-liner alternative (single terminal, no FIFO):
+#
+#   cargo run --example minimal_lsp <<'EOF'
+#     … nine packets …
+#   EOF
+#
+# Both approaches feed identical bytes to minimal_lsp via stdin.
+
+set -eu
+PIPE=${1:-/tmp/lsp_pipe}
+
+mkfifo -m 600 "$PIPE" 2>/dev/null || true       # create once, ignore if exists
+
+# open write end so the fifo stays open
+exec 3> "$PIPE"
+
+send() {
+  local body=$1
+  local len=$(printf '%s' "$body" | wc -c)
+  printf 'Content-Length: %d\r\n\r\n%s' "$len" "$body" >&3
+}
+
+send '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"capabilities":{}}}'
+send '{"jsonrpc":"2.0","method":"initialized","params":{}}'
+send '{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///tmp/foo.rs","languageId":"rust","version":1,"text":"fn  main( ){println!(\"hi\") }"}}}'
+send '{"jsonrpc":"2.0","id":2,"method":"textDocument/completion","params":{"textDocument":{"uri":"file:///tmp/foo.rs"},"position":{"line":0,"character":0}}}'
+send '{"jsonrpc":"2.0","id":3,"method":"textDocument/hover","params":{"textDocument":{"uri":"file:///tmp/foo.rs"},"position":{"line":0,"character":0}}}'
+send '{"jsonrpc":"2.0","id":4,"method":"textDocument/definition","params":{"textDocument":{"uri":"file:///tmp/foo.rs"},"position":{"line":0,"character":0}}}'
+send '{"jsonrpc":"2.0","id":5,"method":"textDocument/formatting","params":{"textDocument":{"uri":"file:///tmp/foo.rs"},"options":{"tabSize":4,"insertSpaces":true}}}'
+send '{"jsonrpc":"2.0","id":6,"method":"shutdown","params":null}'
+send '{"jsonrpc":"2.0","method":"exit","params":null}'
+
+exec 3>&-
+echo "Packets sent – watch the other terminal for responses."
diff --git a/src/tools/rust-analyzer/lib/lsp-server/examples/minimal_lsp.rs b/src/tools/rust-analyzer/lib/lsp-server/examples/minimal_lsp.rs
new file mode 100644
index 00000000000..5eef999e062
--- /dev/null
+++ b/src/tools/rust-analyzer/lib/lsp-server/examples/minimal_lsp.rs
@@ -0,0 +1,335 @@
+//! Minimal Language‑Server‑Protocol example: **`minimal_lsp.rs`**
+//! =============================================================
+//!
+//! | ↔ / ← | LSP method | What the implementation does |
+//! |-------|------------|------------------------------|
+//! | ↔ | `initialize` / `initialized` | capability handshake |
+//! | ← | `textDocument/publishDiagnostics` | pushes a dummy info diagnostic whenever the buffer changes |
+//! | ← | `textDocument/definition` | echoes an empty location array so the jump works |
+//! | ← | `textDocument/completion` | offers one hard‑coded item `HelloFromLSP` |
+//! | ← | `textDocument/hover` | shows *Hello from minimal_lsp* markdown |
+//! | ← | `textDocument/formatting` | pipes the doc through **rustfmt** and returns a full‑file edit |
+//!
+//! ### Quick start
+//! ```bash
+//! cd rust-analyzer/lib/lsp-server
+//! cargo run --example minimal_lsp
+//! ```
+//!
+//! ### Minimal manual session (all nine packets)
+//! ```no_run
+//! # 1. initialize - server replies with capabilities
+//! Content-Length: 85
+
+//! {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"capabilities":{}}}
+//!
+//! # 2. initialized - no response expected
+//! Content-Length: 59
+
+//! {"jsonrpc":"2.0","method":"initialized","params":{}}
+//!
+//! # 3. didOpen - provide initial buffer text
+//! Content-Length: 173
+
+//! {"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"file:///tmp/foo.rs","languageId":"rust","version":1,"text":"fn  main( ){println!(\"hi\") }"}}}
+//!
+//! # 4. completion - expect HelloFromLSP
+//! Content-Length: 139
+
+//! {"jsonrpc":"2.0","id":2,"method":"textDocument/completion","params":{"textDocument":{"uri":"file:///tmp/foo.rs"},"position":{"line":0,"character":0}}}
+//!
+//! # 5. hover - expect markdown greeting
+//! Content-Length: 135
+
+//! {"jsonrpc":"2.0","id":3,"method":"textDocument/hover","params":{"textDocument":{"uri":"file:///tmp/foo.rs"},"position":{"line":0,"character":0}}}
+//!
+//! # 6. goto-definition - dummy empty array
+//! Content-Length: 139
+
+//! {"jsonrpc":"2.0","id":4,"method":"textDocument/definition","params":{"textDocument":{"uri":"file:///tmp/foo.rs"},"position":{"line":0,"character":0}}}
+//!
+//! # 7. formatting - rustfmt full document
+//! Content-Length: 157
+
+//! {"jsonrpc":"2.0","id":5,"method":"textDocument/formatting","params":{"textDocument":{"uri":"file:///tmp/foo.rs"},"options":{"tabSize":4,"insertSpaces":true}}}
+//!
+//! # 8. shutdown request - server acks and prepares to exit
+//! Content-Length: 67
+
+//! {"jsonrpc":"2.0","id":6,"method":"shutdown","params":null}
+//!
+//! # 9. exit notification - terminates the server
+//! Content-Length: 54
+
+//! {"jsonrpc":"2.0","method":"exit","params":null}
+//! ```
+//!
+
+use std::{error::Error, io::Write};
+
+use rustc_hash::FxHashMap; // fast hash map
+use std::process::Stdio;
+use toolchain::command; // clippy-approved wrapper
+
+#[allow(clippy::print_stderr, clippy::disallowed_types, clippy::disallowed_methods)]
+use anyhow::{Context, Result, anyhow, bail};
+use lsp_server::{Connection, Message, Request as ServerRequest, RequestId, Response};
+use lsp_types::notification::Notification as _; // for METHOD consts
+use lsp_types::request::Request as _;
+use lsp_types::{
+    CompletionItem,
+    CompletionItemKind,
+    // capability helpers
+    CompletionOptions,
+    CompletionResponse,
+    Diagnostic,
+    DiagnosticSeverity,
+    DidChangeTextDocumentParams,
+    DidOpenTextDocumentParams,
+    DocumentFormattingParams,
+    Hover,
+    HoverContents,
+    HoverProviderCapability,
+    // core
+    InitializeParams,
+    MarkedString,
+    OneOf,
+    Position,
+    PublishDiagnosticsParams,
+    Range,
+    ServerCapabilities,
+    TextDocumentSyncCapability,
+    TextDocumentSyncKind,
+    TextEdit,
+    Url,
+    // notifications
+    notification::{DidChangeTextDocument, DidOpenTextDocument, PublishDiagnostics},
+    // requests
+    request::{Completion, Formatting, GotoDefinition, HoverRequest},
+}; // for METHOD consts
+
+// =====================================================================
+// main
+// =====================================================================
+
+#[allow(clippy::print_stderr)]
+fn main() -> std::result::Result<(), Box<dyn Error + Sync + Send>> {
+    log::error!("starting minimal_lsp");
+
+    // transport
+    let (connection, io_thread) = Connection::stdio();
+
+    // advertised capabilities
+    let caps = ServerCapabilities {
+        text_document_sync: Some(TextDocumentSyncCapability::Kind(TextDocumentSyncKind::FULL)),
+        completion_provider: Some(CompletionOptions::default()),
+        definition_provider: Some(OneOf::Left(true)),
+        hover_provider: Some(HoverProviderCapability::Simple(true)),
+        document_formatting_provider: Some(OneOf::Left(true)),
+        ..Default::default()
+    };
+    let init_value = serde_json::json!({
+        "capabilities": caps,
+        "offsetEncoding": ["utf-8"],
+    });
+
+    let init_params = connection.initialize(init_value)?;
+    main_loop(connection, init_params)?;
+    io_thread.join()?;
+    log::error!("shutting down server");
+    Ok(())
+}
+
+// =====================================================================
+// event loop
+// =====================================================================
+
+fn main_loop(
+    connection: Connection,
+    params: serde_json::Value,
+) -> std::result::Result<(), Box<dyn Error + Sync + Send>> {
+    let _init: InitializeParams = serde_json::from_value(params)?;
+    let mut docs: FxHashMap<Url, String> = FxHashMap::default();
+
+    for msg in &connection.receiver {
+        match msg {
+            Message::Request(req) => {
+                if connection.handle_shutdown(&req)? {
+                    break;
+                }
+                if let Err(err) = handle_request(&connection, &req, &mut docs) {
+                    log::error!("[lsp] request {} failed: {err}", &req.method);
+                }
+            }
+            Message::Notification(note) => {
+                if let Err(err) = handle_notification(&connection, &note, &mut docs) {
+                    log::error!("[lsp] notification {} failed: {err}", note.method);
+                }
+            }
+            Message::Response(resp) => log::error!("[lsp] response: {resp:?}"),
+        }
+    }
+    Ok(())
+}
+
+// =====================================================================
+// notifications
+// =====================================================================
+
+fn handle_notification(
+    conn: &Connection,
+    note: &lsp_server::Notification,
+    docs: &mut FxHashMap<Url, String>,
+) -> Result<()> {
+    match note.method.as_str() {
+        DidOpenTextDocument::METHOD => {
+            let p: DidOpenTextDocumentParams = serde_json::from_value(note.params.clone())?;
+            let uri = p.text_document.uri;
+            docs.insert(uri.clone(), p.text_document.text);
+            publish_dummy_diag(conn, &uri)?;
+        }
+        DidChangeTextDocument::METHOD => {
+            let p: DidChangeTextDocumentParams = serde_json::from_value(note.params.clone())?;
+            if let Some(change) = p.content_changes.into_iter().next() {
+                let uri = p.text_document.uri;
+                docs.insert(uri.clone(), change.text);
+                publish_dummy_diag(conn, &uri)?;
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}
+
+// =====================================================================
+// requests
+// =====================================================================
+
+fn handle_request(
+    conn: &Connection,
+    req: &ServerRequest,
+    docs: &mut FxHashMap<Url, String>,
+) -> Result<()> {
+    match req.method.as_str() {
+        GotoDefinition::METHOD => {
+            send_ok(conn, req.id.clone(), &lsp_types::GotoDefinitionResponse::Array(Vec::new()))?;
+        }
+        Completion::METHOD => {
+            let item = CompletionItem {
+                label: "HelloFromLSP".into(),
+                kind: Some(CompletionItemKind::FUNCTION),
+                detail: Some("dummy completion".into()),
+                ..Default::default()
+            };
+            send_ok(conn, req.id.clone(), &CompletionResponse::Array(vec![item]))?;
+        }
+        HoverRequest::METHOD => {
+            let hover = Hover {
+                contents: HoverContents::Scalar(MarkedString::String(
+                    "Hello from *minimal_lsp*".into(),
+                )),
+                range: None,
+            };
+            send_ok(conn, req.id.clone(), &hover)?;
+        }
+        Formatting::METHOD => {
+            let p: DocumentFormattingParams = serde_json::from_value(req.params.clone())?;
+            let uri = p.text_document.uri;
+            let text = docs
+                .get(&uri)
+                .ok_or_else(|| anyhow!("document not in cache – did you send DidOpen?"))?;
+            let formatted = run_rustfmt(text)?;
+            let edit = TextEdit { range: full_range(text), new_text: formatted };
+            send_ok(conn, req.id.clone(), &vec![edit])?;
+        }
+        _ => send_err(
+            conn,
+            req.id.clone(),
+            lsp_server::ErrorCode::MethodNotFound,
+            "unhandled method",
+        )?,
+    }
+    Ok(())
+}
+
+// =====================================================================
+// diagnostics
+// =====================================================================
+fn publish_dummy_diag(conn: &Connection, uri: &Url) -> Result<()> {
+    let diag = Diagnostic {
+        range: Range::new(Position::new(0, 0), Position::new(0, 1)),
+        severity: Some(DiagnosticSeverity::INFORMATION),
+        code: None,
+        code_description: None,
+        source: Some("minimal_lsp".into()),
+        message: "dummy diagnostic".into(),
+        related_information: None,
+        tags: None,
+        data: None,
+    };
+    let params =
+        PublishDiagnosticsParams { uri: uri.clone(), diagnostics: vec![diag], version: None };
+    conn.sender.send(Message::Notification(lsp_server::Notification::new(
+        PublishDiagnostics::METHOD.to_owned(),
+        params,
+    )))?;
+    Ok(())
+}
+
+// =====================================================================
+// helpers
+// =====================================================================
+
+fn run_rustfmt(input: &str) -> Result<String> {
+    let cwd = std::env::current_dir().expect("can't determine CWD");
+    let mut child = command("rustfmt", &cwd, &FxHashMap::default())
+        .arg("--emit")
+        .arg("stdout")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .context("failed to spawn rustfmt – is it installed?")?;
+
+    let Some(stdin) = child.stdin.as_mut() else {
+        bail!("stdin unavailable");
+    };
+    stdin.write_all(input.as_bytes())?;
+    let output = child.wait_with_output()?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        bail!("rustfmt failed: {stderr}");
+    }
+    Ok(String::from_utf8(output.stdout)?)
+}
+
+fn full_range(text: &str) -> Range {
+    let last_line_idx = text.lines().count().saturating_sub(1) as u32;
+    let last_col = text.lines().last().map_or(0, |l| l.chars().count()) as u32;
+    Range::new(Position::new(0, 0), Position::new(last_line_idx, last_col))
+}
+
+fn send_ok<T: serde::Serialize>(conn: &Connection, id: RequestId, result: &T) -> Result<()> {
+    let resp = Response { id, result: Some(serde_json::to_value(result)?), error: None };
+    conn.sender.send(Message::Response(resp))?;
+    Ok(())
+}
+
+fn send_err(
+    conn: &Connection,
+    id: RequestId,
+    code: lsp_server::ErrorCode,
+    msg: &str,
+) -> Result<()> {
+    let resp = Response {
+        id,
+        result: None,
+        error: Some(lsp_server::ResponseError {
+            code: code as i32,
+            message: msg.into(),
+            data: None,
+        }),
+    };
+    conn.sender.send(Message::Response(resp))?;
+    Ok(())
+}
-- 
cgit 1.4.1-3-g733a5


From 853333d4bdc7570b74e4bf02d506c2951a9d3e4b Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Tue, 15 Jul 2025 09:57:44 +0000
Subject: constify `Option` methods

---
 library/core/src/option.rs | 137 ++++++++++++++++++++++++++++++++-------------
 1 file changed, 97 insertions(+), 40 deletions(-)

diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 9f432758a66..7633429fc5c 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -577,6 +577,7 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use crate::iter::{self, FusedIterator, TrustedLen};
+use crate::marker::Destruct;
 use crate::ops::{self, ControlFlow, Deref, DerefMut};
 use crate::panicking::{panic, panic_display};
 use crate::pin::Pin;
@@ -649,7 +650,8 @@ impl<T> Option<T> {
     #[must_use]
     #[inline]
     #[stable(feature = "is_some_and", since = "1.70.0")]
-    pub fn is_some_and(self, f: impl FnOnce(T) -> bool) -> bool {
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn is_some_and(self, f: impl ~const FnOnce(T) -> bool + ~const Destruct) -> bool {
         match self {
             None => false,
             Some(x) => f(x),
@@ -697,7 +699,8 @@ impl<T> Option<T> {
     #[must_use]
     #[inline]
     #[stable(feature = "is_none_or", since = "1.82.0")]
-    pub fn is_none_or(self, f: impl FnOnce(T) -> bool) -> bool {
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn is_none_or(self, f: impl ~const FnOnce(T) -> bool + ~const Destruct) -> bool {
         match self {
             None => true,
             Some(x) => f(x),
@@ -1023,7 +1026,12 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn unwrap_or(self, default: T) -> T {
+    #[rustc_allow_const_fn_unstable(const_precise_live_drops)]
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn unwrap_or(self, default: T) -> T
+    where
+        T: ~const Destruct,
+    {
         match self {
             Some(x) => x,
             None => default,
@@ -1042,9 +1050,10 @@ impl<T> Option<T> {
     #[inline]
     #[track_caller]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn unwrap_or_else<F>(self, f: F) -> T
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn unwrap_or_else<F>(self, f: F) -> T
     where
-        F: FnOnce() -> T,
+        F: ~const FnOnce() -> T + ~const Destruct,
     {
         match self {
             Some(x) => x,
@@ -1073,9 +1082,10 @@ impl<T> Option<T> {
     /// [`FromStr`]: crate::str::FromStr
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn unwrap_or_default(self) -> T
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn unwrap_or_default(self) -> T
     where
-        T: Default,
+        T: ~const Default,
     {
         match self {
             Some(x) => x,
@@ -1139,9 +1149,10 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn map<U, F>(self, f: F) -> Option<U>
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn map<U, F>(self, f: F) -> Option<U>
     where
-        F: FnOnce(T) -> U,
+        F: ~const FnOnce(T) -> U + ~const Destruct,
     {
         match self {
             Some(x) => Some(f(x)),
@@ -1169,7 +1180,11 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "result_option_inspect", since = "1.76.0")]
-    pub fn inspect<F: FnOnce(&T)>(self, f: F) -> Self {
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn inspect<F>(self, f: F) -> Self
+    where
+        F: ~const FnOnce(&T) + ~const Destruct,
+    {
         if let Some(ref x) = self {
             f(x);
         }
@@ -1198,9 +1213,11 @@ impl<T> Option<T> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[must_use = "if you don't need the returned value, use `if let` instead"]
-    pub fn map_or<U, F>(self, default: U, f: F) -> U
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn map_or<U, F>(self, default: U, f: F) -> U
     where
-        F: FnOnce(T) -> U,
+        F: ~const FnOnce(T) -> U + ~const Destruct,
+        U: ~const Destruct,
     {
         match self {
             Some(t) => f(t),
@@ -1243,10 +1260,11 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn map_or_else<U, D, F>(self, default: D, f: F) -> U
     where
-        D: FnOnce() -> U,
-        F: FnOnce(T) -> U,
+        D: ~const FnOnce() -> U + ~const Destruct,
+        F: ~const FnOnce(T) -> U + ~const Destruct,
     {
         match self {
             Some(t) => f(t),
@@ -1273,10 +1291,11 @@ impl<T> Option<T> {
     /// [default value]: Default::default
     #[inline]
     #[unstable(feature = "result_option_map_or_default", issue = "138099")]
-    pub fn map_or_default<U, F>(self, f: F) -> U
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn map_or_default<U, F>(self, f: F) -> U
     where
-        U: Default,
-        F: FnOnce(T) -> U,
+        U: ~const Default,
+        F: ~const FnOnce(T) -> U + ~const Destruct,
     {
         match self {
             Some(t) => f(t),
@@ -1307,7 +1326,8 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn ok_or<E>(self, err: E) -> Result<T, E> {
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn ok_or<E: ~const Destruct>(self, err: E) -> Result<T, E> {
         match self {
             Some(v) => Ok(v),
             None => Err(err),
@@ -1332,9 +1352,10 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn ok_or_else<E, F>(self, err: F) -> Result<T, E>
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn ok_or_else<E, F>(self, err: F) -> Result<T, E>
     where
-        F: FnOnce() -> E,
+        F: ~const FnOnce() -> E + ~const Destruct,
     {
         match self {
             Some(v) => Ok(v),
@@ -1463,7 +1484,12 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn and<U>(self, optb: Option<U>) -> Option<U> {
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn and<U>(self, optb: Option<U>) -> Option<U>
+    where
+        T: ~const Destruct,
+        U: ~const Destruct,
+    {
         match self {
             Some(_) => optb,
             None => None,
@@ -1502,9 +1528,10 @@ impl<T> Option<T> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_confusables("flat_map", "flatmap")]
-    pub fn and_then<U, F>(self, f: F) -> Option<U>
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn and_then<U, F>(self, f: F) -> Option<U>
     where
-        F: FnOnce(T) -> Option<U>,
+        F: ~const FnOnce(T) -> Option<U> + ~const Destruct,
     {
         match self {
             Some(x) => f(x),
@@ -1538,9 +1565,11 @@ impl<T> Option<T> {
     /// [`Some(t)`]: Some
     #[inline]
     #[stable(feature = "option_filter", since = "1.27.0")]
-    pub fn filter<P>(self, predicate: P) -> Self
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn filter<P>(self, predicate: P) -> Self
     where
-        P: FnOnce(&T) -> bool,
+        P: ~const FnOnce(&T) -> bool + ~const Destruct,
+        T: ~const Destruct,
     {
         if let Some(x) = self {
             if predicate(&x) {
@@ -1579,7 +1608,11 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn or(self, optb: Option<T>) -> Option<T> {
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn or(self, optb: Option<T>) -> Option<T>
+    where
+        T: ~const Destruct,
+    {
         match self {
             x @ Some(_) => x,
             None => optb,
@@ -1601,9 +1634,13 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn or_else<F>(self, f: F) -> Option<T>
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn or_else<F>(self, f: F) -> Option<T>
     where
-        F: FnOnce() -> Option<T>,
+        F: ~const FnOnce() -> Option<T> + ~const Destruct,
+        //FIXME(const_hack): this `T: ~const Destruct` is unnecessary, but even precise live drops can't tell
+        // no value of type `T` gets dropped here
+        T: ~const Destruct,
     {
         match self {
             x @ Some(_) => x,
@@ -1634,7 +1671,11 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "option_xor", since = "1.37.0")]
-    pub fn xor(self, optb: Option<T>) -> Option<T> {
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn xor(self, optb: Option<T>) -> Option<T>
+    where
+        T: ~const Destruct,
+    {
         match (self, optb) {
             (a @ Some(_), None) => a,
             (None, b @ Some(_)) => b,
@@ -1668,7 +1709,11 @@ impl<T> Option<T> {
     #[must_use = "if you intended to set a value, consider assignment instead"]
     #[inline]
     #[stable(feature = "option_insert", since = "1.53.0")]
-    pub fn insert(&mut self, value: T) -> &mut T {
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn insert(&mut self, value: T) -> &mut T
+    where
+        T: ~const Destruct,
+    {
         *self = Some(value);
 
         // SAFETY: the code above just filled the option
@@ -1720,9 +1765,10 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "option_get_or_insert_default", since = "1.83.0")]
-    pub fn get_or_insert_default(&mut self) -> &mut T
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn get_or_insert_default(&mut self) -> &mut T
     where
-        T: Default,
+        T: ~const Default + ~const Destruct,
     {
         self.get_or_insert_with(T::default)
     }
@@ -1746,9 +1792,11 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "option_entry", since = "1.20.0")]
-    pub fn get_or_insert_with<F>(&mut self, f: F) -> &mut T
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn get_or_insert_with<F>(&mut self, f: F) -> &mut T
     where
-        F: FnOnce() -> T,
+        F: ~const FnOnce() -> T + ~const Destruct,
+        T: ~const Destruct,
     {
         if let None = self {
             *self = Some(f());
@@ -1812,9 +1860,10 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "option_take_if", since = "1.80.0")]
-    pub fn take_if<P>(&mut self, predicate: P) -> Option<T>
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn take_if<P>(&mut self, predicate: P) -> Option<T>
     where
-        P: FnOnce(&mut T) -> bool,
+        P: ~const FnOnce(&mut T) -> bool + ~const Destruct,
     {
         if self.as_mut().map_or(false, predicate) { self.take() } else { None }
     }
@@ -1859,7 +1908,12 @@ impl<T> Option<T> {
     /// assert_eq!(x.zip(z), None);
     /// ```
     #[stable(feature = "option_zip_option", since = "1.46.0")]
-    pub fn zip<U>(self, other: Option<U>) -> Option<(T, U)> {
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn zip<U>(self, other: Option<U>) -> Option<(T, U)>
+    where
+        T: ~const Destruct,
+        U: ~const Destruct,
+    {
         match (self, other) {
             (Some(a), Some(b)) => Some((a, b)),
             _ => None,
@@ -1895,9 +1949,12 @@ impl<T> Option<T> {
     /// assert_eq!(x.zip_with(None, Point::new), None);
     /// ```
     #[unstable(feature = "option_zip", issue = "70086")]
-    pub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R>
+    #[rustc_const_unstable(feature = "const_option_ops", issue = "143956")]
+    pub const fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R>
     where
-        F: FnOnce(T, U) -> R,
+        F: ~const FnOnce(T, U) -> R + ~const Destruct,
+        T: ~const Destruct,
+        U: ~const Destruct,
     {
         match (self, other) {
             (Some(a), Some(b)) => Some(f(a, b)),
-- 
cgit 1.4.1-3-g733a5


From 387b6037c5522d2ceee41358e0d91cd9222e19d8 Mon Sep 17 00:00:00 2001
From: Nia Espera <nia-e@haecceity.cc>
Date: Wed, 16 Jul 2025 04:38:26 +0200
Subject: allow using different cargo binary

---
 src/tools/miri/CONTRIBUTING.md         |  1 +
 src/tools/miri/miri                    |  3 ++-
 src/tools/miri/miri-script/src/util.rs | 15 ++++++++++-----
 3 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/tools/miri/CONTRIBUTING.md b/src/tools/miri/CONTRIBUTING.md
index e4302b734aa..aff5fbcae94 100644
--- a/src/tools/miri/CONTRIBUTING.md
+++ b/src/tools/miri/CONTRIBUTING.md
@@ -348,6 +348,7 @@ https. Add the following to your `.gitconfig`:
 
 The following environment variables are relevant to `./miri`:
 
+* `CARGO` sets the binary used to execute Cargo; if none is specified, defaults to `cargo`.
 * `MIRI_AUTO_OPS` indicates whether the automatic execution of rustfmt, clippy and toolchain setup
   (as controlled by the `./auto-*` files) should be skipped. If it is set to `no`, they are skipped.
   This is used to allow automated IDE actions to avoid the auto ops.
diff --git a/src/tools/miri/miri b/src/tools/miri/miri
index 549998ae44a..a5f2bb1550a 100755
--- a/src/tools/miri/miri
+++ b/src/tools/miri/miri
@@ -15,8 +15,9 @@ if [ -n "$MIRI_IN_RA" ]; then
   CARGO_FLAGS+=("--message-format=json" "-Zroot-dir=$ROOT_DIR")
   TARGET_DIR="$ROOT_DIR"/target
 fi
+
 # Run cargo.
-cargo $TOOLCHAIN build --manifest-path "$ROOT_DIR"/miri-script/Cargo.toml \
+${CARGO:-cargo} $TOOLCHAIN build --manifest-path "$ROOT_DIR"/miri-script/Cargo.toml \
   --target-dir "$TARGET_DIR" "${CARGO_FLAGS[@]}" || \
   ( echo "Failed to build miri-script. Is the 'stable' toolchain installed?"; exit 1 )
 # Instead of doing just `cargo run --manifest-path .. $@`, we invoke miri-script binary directly.
diff --git a/src/tools/miri/miri-script/src/util.rs b/src/tools/miri/miri-script/src/util.rs
index c100cf195ba..6121096f823 100644
--- a/src/tools/miri/miri-script/src/util.rs
+++ b/src/tools/miri/miri-script/src/util.rs
@@ -38,6 +38,8 @@ pub struct MiriEnv {
     pub miri_dir: PathBuf,
     /// active_toolchain is passed as `+toolchain` argument to cargo/rustc invocations.
     toolchain: String,
+    /// The cargo binary to use.
+    cargo_bin: String,
     /// Extra flags to pass to cargo.
     cargo_extra_flags: Vec<String>,
     /// The rustc sysroot
@@ -106,6 +108,9 @@ impl MiriEnv {
             sh.set_var("PATH", new_path);
         }
 
+        // Get the cargo binary to use, if one is set.
+        let cargo_bin = std::env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
+
         // Get extra flags for cargo.
         let cargo_extra_flags = std::env::var("CARGO_EXTRA_FLAGS").unwrap_or_default();
         let mut cargo_extra_flags = flagsplit(&cargo_extra_flags);
@@ -119,7 +124,7 @@ impl MiriEnv {
         // Also set `-Zroot-dir` for cargo, to print diagnostics relative to the miri dir.
         cargo_extra_flags.push(format!("-Zroot-dir={}", miri_dir.display()));
 
-        Ok(MiriEnv { miri_dir, toolchain, sh, sysroot, cargo_extra_flags, libdir })
+        Ok(MiriEnv { miri_dir, toolchain, sh, sysroot, cargo_bin, cargo_extra_flags, libdir })
     }
 
     /// Make sure the `features` you pass here exist for the specified `crate_dir`. For example, the
@@ -130,12 +135,12 @@ impl MiriEnv {
         cmd: &str,
         features: &[String],
     ) -> Cmd<'_> {
-        let MiriEnv { toolchain, cargo_extra_flags, .. } = self;
+        let MiriEnv { toolchain, cargo_extra_flags, cargo_bin, .. } = self;
         let manifest_path = path!(self.miri_dir / crate_dir.as_ref() / "Cargo.toml");
         let features = features_to_args(features);
         cmd!(
             self.sh,
-            "cargo +{toolchain} {cmd} {cargo_extra_flags...} --manifest-path {manifest_path} {features...}"
+            "{cargo_bin} +{toolchain} {cmd} {cargo_extra_flags...} --manifest-path {manifest_path} {features...}"
         )
     }
 
@@ -147,12 +152,12 @@ impl MiriEnv {
         features: &[String],
         args: impl IntoIterator<Item = impl AsRef<OsStr>>,
     ) -> Result<()> {
-        let MiriEnv { sysroot, toolchain, cargo_extra_flags, .. } = self;
+        let MiriEnv { sysroot, toolchain, cargo_extra_flags, cargo_bin, .. } = self;
         let path = path!(self.miri_dir / crate_dir.as_ref());
         let features = features_to_args(features);
         // Install binaries to the miri toolchain's `sysroot` so they do not interact with other toolchains.
         // (Not using `cargo_cmd` as `install` is special and doesn't use `--manifest-path`.)
-        cmd!(self.sh, "cargo +{toolchain} install {cargo_extra_flags...} --path {path} --force --root {sysroot} {features...} {args...}").run()?;
+        cmd!(self.sh, "{cargo_bin} +{toolchain} install {cargo_extra_flags...} --path {path} --force --root {sysroot} {features...} {args...}").run()?;
         Ok(())
     }
 
-- 
cgit 1.4.1-3-g733a5


From 2ca2d93035ecb4b7afab079329979262aae379a4 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Thu, 17 Jul 2025 17:32:26 +0800
Subject: Auto-label `src/ci` and `.github/workflows` with `A-CI`

And include `.github/workflows` for `T-infra` trigger files.
---
 triagebot.toml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/triagebot.toml b/triagebot.toml
index 2f8114aeb3b..cddb867c471 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -471,6 +471,7 @@ trigger_files = [
 
 [autolabel."T-infra"]
 trigger_files = [
+    ".github/workflows",
     "src/ci",
     "src/tools/bump-stage0",
     "src/tools/cargotest",
@@ -598,6 +599,12 @@ trigger_files = [
     "src/tools/clippy",
 ]
 
+[autolabel."A-CI"]
+trigger_files = [
+    ".github/workflows",
+    "src/ci",
+]
+
 # ------------------------------------------------------------------------------
 # Prioritization and team nominations
 # ------------------------------------------------------------------------------
-- 
cgit 1.4.1-3-g733a5


From 1205c539463c939cfb684b8acbf85ee700dd24b0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 17 Jul 2025 11:32:43 +0200
Subject: tweak PR process description

---
 src/tools/miri/CONTRIBUTING.md | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/tools/miri/CONTRIBUTING.md b/src/tools/miri/CONTRIBUTING.md
index e4302b734aa..bef3ffe7e95 100644
--- a/src/tools/miri/CONTRIBUTING.md
+++ b/src/tools/miri/CONTRIBUTING.md
@@ -19,10 +19,14 @@ When you get a review, please take care of the requested changes in new commits.
 existing commits. Generally avoid force-pushing. The only time you should force push is when there
 is a conflict with the master branch (in that case you should rebase across master, not merge), and
 all the way at the end of the review process when the reviewer tells you that the PR is done and you
-should squash the commits. If you are unsure how to use `git rebase` to squash commits, use `./miri
-squash` which automates the process but leaves little room for customization. (All this is to work
-around the fact that Github is quite bad at dealing with force pushes and does not support `git
-range-diff`. Maybe one day Github will be good at git and then life can become easier.)
+should squash the commits. (All this is to work around the fact that Github is quite bad at
+dealing with force pushes and does not support `git range-diff`.)
+
+The recommended way to squash commits is to use `./miri squash`, which will make everything into a
+single commit. You will be asked for the commit message; please ensure it describes the entire PR.
+You can also use `git rebase` manually if you need more control (e.g. if there should be more than
+one commit at the end), but then please use `--keep-base` to ensure the PR remains based on the same
+upstream commit.
 
 Most PRs bounce back and forth between the reviewer and the author several times, so it is good to
 keep track of who is expected to take the next step. We are using the `S-waiting-for-review` and
-- 
cgit 1.4.1-3-g733a5


From 491b873d83052acb89d6b6ad5a5ab31d0a88a8c5 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Thu, 17 Jul 2025 17:33:44 +0800
Subject: Add myself to `infra-ci` reviewer group

---
 triagebot.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/triagebot.toml b/triagebot.toml
index cddb867c471..61d8a814c89 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1323,6 +1323,7 @@ infra-ci = [
     "@Kobzol",
     "@marcoieni",
     "@jdno",
+    "@jieyouxu",
 ]
 rustdoc = [
     "@GuillaumeGomez",
-- 
cgit 1.4.1-3-g733a5


From 69326878eeabb713e2d4a85215b87f18e498313c Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Sun, 13 Jul 2025 16:49:19 +0800
Subject: parse `const trait Trait`

---
 compiler/rustc_ast/src/ast.rs                      |  1 +
 compiler/rustc_ast/src/visit.rs                    |  3 +-
 compiler/rustc_ast_lowering/src/item.rs            | 13 ++++++--
 compiler/rustc_ast_passes/messages.ftl             |  4 +--
 compiler/rustc_ast_passes/src/ast_validation.rs    | 38 +++++++++++++---------
 compiler/rustc_ast_passes/src/errors.rs            |  2 +-
 compiler/rustc_ast_pretty/src/pprust/state/item.rs |  2 ++
 .../rustc_attr_parsing/src/attributes/traits.rs    |  1 +
 compiler/rustc_const_eval/src/check_consts/mod.rs  |  2 +-
 .../rustc_const_eval/src/const_eval/machine.rs     |  4 +--
 compiler/rustc_feature/src/builtin_attrs.rs        |  1 +
 compiler/rustc_hir/src/hir.rs                      | 19 ++++++++---
 compiler/rustc_hir/src/intravisit.rs               | 10 +++++-
 compiler/rustc_hir_analysis/messages.ftl           | 12 +++----
 compiler/rustc_hir_analysis/src/collect.rs         | 13 +++++---
 .../src/collect/predicates_of.rs                   |  4 +--
 .../src/collect/resolve_bound_vars.rs              |  2 +-
 compiler/rustc_hir_analysis/src/errors.rs          |  2 ++
 .../src/errors/wrong_number_of_generic_args.rs     |  2 +-
 .../src/hir_ty_lowering/bounds.rs                  |  2 +-
 compiler/rustc_hir_pretty/src/lib.rs               | 11 ++++++-
 compiler/rustc_hir_typeck/src/method/suggest.rs    |  6 ++--
 .../src/multiple_supertrait_upcastable.rs          |  2 +-
 compiler/rustc_metadata/src/rmeta/encoder.rs       |  2 +-
 compiler/rustc_middle/src/hir/map.rs               |  2 +-
 compiler/rustc_middle/src/ty/trait_def.rs          |  2 +-
 compiler/rustc_parse/messages.ftl                  |  1 +
 compiler/rustc_parse/src/errors.rs                 |  8 +++++
 compiler/rustc_parse/src/parser/item.rs            | 28 ++++++++++++----
 compiler/rustc_passes/messages.ftl                 |  2 +-
 compiler/rustc_passes/src/check_attr.rs            |  2 +-
 .../src/error_reporting/traits/mod.rs              |  2 +-
 .../src/error_reporting/traits/suggestions.rs      | 10 +++---
 compiler/rustc_trait_selection/src/errors.rs       |  2 +-
 src/doc/rustc-dev-guide/src/effects.md             |  9 ++---
 src/librustdoc/clean/mod.rs                        |  2 +-
 src/librustdoc/clean/types.rs                      |  2 +-
 .../src/arbitrary_source_item_ordering.rs          |  2 +-
 src/tools/clippy/clippy_lints/src/doc/mod.rs       |  2 +-
 src/tools/clippy/clippy_lints/src/len_zero.rs      |  2 +-
 .../clippy/clippy_lints/src/missing_inline.rs      |  2 +-
 src/tools/clippy/clippy_lints/src/trait_bounds.rs  |  4 +--
 .../clippy/clippy_lints/src/upper_case_acronyms.rs |  2 +-
 src/tools/clippy/clippy_utils/src/ast_utils/mod.rs |  5 ++-
 .../clippy/clippy_utils/src/check_proc_macro.rs    |  4 +--
 src/tools/clippy/tests/ui/assign_ops.fixed         |  3 +-
 src/tools/clippy/tests/ui/assign_ops.rs            |  3 +-
 .../ui/missing_const_for_fn/const_trait.fixed      |  3 +-
 .../tests/ui/missing_const_for_fn/const_trait.rs   |  3 +-
 .../ui/missing_const_for_fn/const_trait.stderr     |  2 +-
 .../tests/ui/trait_duplication_in_bounds.fixed     |  3 +-
 .../clippy/tests/ui/trait_duplication_in_bounds.rs |  3 +-
 .../tests/ui/trait_duplication_in_bounds.stderr    |  6 ++--
 .../crates/test-utils/src/minicore.rs              |  3 +-
 src/tools/rustfmt/src/items.rs                     |  4 ++-
 tests/crashes/117629.rs                            |  3 +-
 .../const-super-trait-nightly-disabled.stderr      | 10 +++---
 .../const-super-trait-nightly-enabled.stderr       | 10 +++---
 .../const-super-trait-stable-disabled.stderr       | 10 +++---
 .../const-super-trait-stable-enabled.stderr        | 10 +++---
 .../run-make/const-trait-stable-toolchain/rmake.rs | 10 ++----
 tests/ui/consts/const-try.rs                       |  4 +--
 tests/ui/consts/const-try.stderr                   |  8 ++---
 tests/ui/consts/rustc-impl-const-stability.stderr  |  4 +--
 tests/ui/specialization/const_trait_impl.stderr    | 24 +++++++-------
 .../stability-attribute/missing-const-stability.rs |  3 +-
 .../missing-const-stability.stderr                 |  6 ++--
 .../conditionally-const-invalid-places.stderr      |  8 ++---
 .../const-traits/const-bounds-non-const-trait.rs   |  6 ++--
 .../const-bounds-non-const-trait.stderr            | 12 +++----
 .../const-impl-requires-const-trait.rs             |  2 +-
 .../const-impl-requires-const-trait.stderr         |  6 ++--
 .../const-trait-bounds-trait-objects.rs            |  8 ++---
 .../const-trait-bounds-trait-objects.stderr        | 20 ++++++------
 .../const_derives/derive-const-gate.rs             |  2 +-
 .../const_derives/derive-const-gate.stderr         |  4 +--
 .../derive-const-non-const-type.stderr             |  4 +--
 .../const-traits/ice-119717-constant-lifetime.rs   |  2 +-
 .../ice-119717-constant-lifetime.stderr            |  4 +--
 .../const-traits/ice-126148-failed-to-normalize.rs |  4 +--
 .../ice-126148-failed-to-normalize.stderr          |  8 ++---
 tests/ui/traits/const-traits/spec-effectvar-ice.rs |  6 ++--
 .../traits/const-traits/spec-effectvar-ice.stderr  | 16 ++++-----
 .../const-traits/super-traits-fail-2.nn.stderr     | 14 ++++----
 .../const-traits/super-traits-fail-2.ny.stderr     | 20 ++++++------
 .../ui/traits/const-traits/super-traits-fail-2.rs  | 10 +++---
 .../const-traits/super-traits-fail-2.yn.stderr     |  2 +-
 .../const-traits/super-traits-fail-3.nnn.stderr    | 22 ++++++-------
 .../const-traits/super-traits-fail-3.nny.stderr    | 22 ++++++-------
 .../ui/traits/const-traits/super-traits-fail-3.rs  | 14 ++++----
 .../const-traits/super-traits-fail-3.ynn.stderr    | 22 ++++++-------
 .../const-traits/super-traits-fail-3.yny.stderr    | 20 ++++++------
 .../const-traits/super-traits-fail-3.yyn.stderr    | 10 +++---
 .../trait-default-body-stability.stderr            |  8 ++---
 94 files changed, 365 insertions(+), 299 deletions(-)

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index fa542a810dc..8c2b521c560 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -3690,6 +3690,7 @@ impl Default for FnHeader {
 
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct Trait {
+    pub constness: Const,
     pub safety: Safety,
     pub is_auto: IsAuto,
     pub ident: Ident,
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index 37fcc0d2167..a344f23c345 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -738,7 +738,8 @@ macro_rules! common_visitor_and_walkers {
                         try_visit!(vis.visit_ty(self_ty));
                         visit_assoc_items(vis, items, AssocCtxt::Impl { of_trait: of_trait.is_some() })
                     }
-                    ItemKind::Trait(box Trait { safety, is_auto: _, ident, generics, bounds, items }) => {
+                    ItemKind::Trait(box Trait { constness, safety, is_auto: _, ident, generics, bounds, items }) => {
+                        try_visit!(visit_constness(vis, constness));
                         try_visit!(visit_safety(vis, safety));
                         try_visit!(vis.visit_ident(ident));
                         try_visit!(vis.visit_generics(generics));
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 9d40a7386f6..abd70c7517c 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -417,7 +417,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     items: new_impl_items,
                 }))
             }
-            ItemKind::Trait(box Trait { is_auto, safety, ident, generics, bounds, items }) => {
+            ItemKind::Trait(box Trait {
+                constness,
+                is_auto,
+                safety,
+                ident,
+                generics,
+                bounds,
+                items,
+            }) => {
+                let constness = self.lower_constness(*constness);
                 let ident = self.lower_ident(*ident);
                 let (generics, (safety, items, bounds)) = self.lower_generics(
                     generics,
@@ -435,7 +444,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         (safety, items, bounds)
                     },
                 );
-                hir::ItemKind::Trait(*is_auto, safety, ident, generics, bounds, items)
+                hir::ItemKind::Trait(constness, *is_auto, safety, ident, generics, bounds, items)
             }
             ItemKind::TraitAlias(ident, generics, bounds) => {
                 let ident = self.lower_ident(*ident);
diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index c5780c957c9..e419154d65d 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -240,10 +240,10 @@ ast_passes_static_without_body =
 ast_passes_tilde_const_disallowed = `[const]` is not allowed here
     .closure = closures cannot have `[const]` trait bounds
     .function = this function is not `const`, so it cannot have `[const]` trait bounds
-    .trait = this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+    .trait = this trait is not `const`, so it cannot have `[const]` trait bounds
     .trait_impl = this impl is not `const`, so it cannot have `[const]` trait bounds
     .impl = inherent impls cannot have `[const]` trait bounds
-    .trait_assoc_ty = associated types in non-`#[const_trait]` traits cannot have `[const]` trait bounds
+    .trait_assoc_ty = associated types in non-`const` traits cannot have `[const]` trait bounds
     .trait_impl_assoc_ty = associated types in non-const impls cannot have `[const]` trait bounds
     .inherent_assoc_ty = inherent associated types cannot have `[const]` trait bounds
     .object = trait objects cannot have `[const]` trait bounds
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 38889d28151..c69250c0305 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -49,14 +49,14 @@ enum SelfSemantic {
 }
 
 enum TraitOrTraitImpl {
-    Trait { span: Span, constness_span: Option<Span> },
+    Trait { span: Span, constness: Const },
     TraitImpl { constness: Const, polarity: ImplPolarity, trait_ref_span: Span },
 }
 
 impl TraitOrTraitImpl {
     fn constness(&self) -> Option<Span> {
         match self {
-            Self::Trait { constness_span: Some(span), .. }
+            Self::Trait { constness: Const::Yes(span), .. }
             | Self::TraitImpl { constness: Const::Yes(span), .. } => Some(*span),
             _ => None,
         }
@@ -110,15 +110,10 @@ impl<'a> AstValidator<'a> {
         self.outer_trait_or_trait_impl = old;
     }
 
-    fn with_in_trait(
-        &mut self,
-        span: Span,
-        constness_span: Option<Span>,
-        f: impl FnOnce(&mut Self),
-    ) {
+    fn with_in_trait(&mut self, span: Span, constness: Const, f: impl FnOnce(&mut Self)) {
         let old = mem::replace(
             &mut self.outer_trait_or_trait_impl,
-            Some(TraitOrTraitImpl::Trait { span, constness_span }),
+            Some(TraitOrTraitImpl::Trait { span, constness }),
         );
         f(self);
         self.outer_trait_or_trait_impl = old;
@@ -273,7 +268,7 @@ impl<'a> AstValidator<'a> {
         };
 
         let make_trait_const_sugg = if const_trait_impl
-            && let TraitOrTraitImpl::Trait { span, constness_span: None } = parent
+            && let TraitOrTraitImpl::Trait { span, constness: ast::Const::No } = parent
         {
             Some(span.shrink_to_lo())
         } else {
@@ -1131,10 +1126,23 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 }
                 visit::walk_item(self, item)
             }
-            ItemKind::Trait(box Trait { is_auto, generics, ident, bounds, items, .. }) => {
+            ItemKind::Trait(box Trait {
+                constness,
+                is_auto,
+                generics,
+                ident,
+                bounds,
+                items,
+                ..
+            }) => {
                 self.visit_attrs_vis_ident(&item.attrs, &item.vis, ident);
-                let is_const_trait =
+                // FIXME(const_trait_impl) remove this
+                let alt_const_trait_span =
                     attr::find_by_name(&item.attrs, sym::const_trait).map(|attr| attr.span);
+                let constness = match (*constness, alt_const_trait_span) {
+                    (Const::Yes(span), _) | (Const::No, Some(span)) => Const::Yes(span),
+                    (Const::No, None) => Const::No,
+                };
                 if *is_auto == IsAuto::Yes {
                     // Auto traits cannot have generics, super traits nor contain items.
                     self.deny_generic_params(generics, ident.span);
@@ -1145,13 +1153,13 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
 
                 // Equivalent of `visit::walk_item` for `ItemKind::Trait` that inserts a bound
                 // context for the supertraits.
-                let disallowed =
-                    is_const_trait.is_none().then(|| TildeConstReason::Trait { span: item.span });
+                let disallowed = matches!(constness, ast::Const::No)
+                    .then(|| TildeConstReason::Trait { span: item.span });
                 self.with_tilde_const(disallowed, |this| {
                     this.visit_generics(generics);
                     walk_list!(this, visit_param_bound, bounds, BoundKind::SuperTraits)
                 });
-                self.with_in_trait(item.span, is_const_trait, |this| {
+                self.with_in_trait(item.span, constness, |this| {
                     walk_list!(this, visit_assoc_item, items, AssocCtxt::Trait);
                 });
             }
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 3b2730d4ff9..c1ebd025c7a 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -590,7 +590,7 @@ pub(crate) struct ConstBoundTraitObject {
 }
 
 // FIXME(const_trait_impl): Consider making the note/reason the message of the diagnostic.
-// FIXME(const_trait_impl): Provide structured suggestions (e.g., add `const` / `#[const_trait]` here).
+// FIXME(const_trait_impl): Provide structured suggestions (e.g., add `const` here).
 #[derive(Diagnostic)]
 #[diag(ast_passes_tilde_const_disallowed)]
 pub(crate) struct TildeConstDisallowed {
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/item.rs b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
index 6c442553976..11c97a552c6 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/item.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
@@ -357,6 +357,7 @@ impl<'a> State<'a> {
                 self.bclose(item.span, empty, cb);
             }
             ast::ItemKind::Trait(box ast::Trait {
+                constness,
                 safety,
                 is_auto,
                 ident,
@@ -366,6 +367,7 @@ impl<'a> State<'a> {
             }) => {
                 let (cb, ib) = self.head("");
                 self.print_visibility(&item.vis);
+                self.print_constness(*constness);
                 self.print_safety(*safety);
                 self.print_is_auto(*is_auto);
                 self.word_nbsp("trait");
diff --git a/compiler/rustc_attr_parsing/src/attributes/traits.rs b/compiler/rustc_attr_parsing/src/attributes/traits.rs
index d5e088effd5..e69a533699b 100644
--- a/compiler/rustc_attr_parsing/src/attributes/traits.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/traits.rs
@@ -91,6 +91,7 @@ impl<S: Stage> NoArgsAttributeParser<S> for DoNotImplementViaObjectParser {
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::DoNotImplementViaObject;
 }
 
+// FIXME(const_trait_impl): remove this
 // Const traits
 
 pub(crate) struct ConstTraitParser;
diff --git a/compiler/rustc_const_eval/src/check_consts/mod.rs b/compiler/rustc_const_eval/src/check_consts/mod.rs
index 9ab8e0692e1..ebf18c6f2ac 100644
--- a/compiler/rustc_const_eval/src/check_consts/mod.rs
+++ b/compiler/rustc_const_eval/src/check_consts/mod.rs
@@ -93,7 +93,7 @@ pub fn rustc_allow_const_fn_unstable(
 /// world into two functions: those that are safe to expose on stable (and hence may not use
 /// unstable features, not even recursively), and those that are not.
 pub fn is_fn_or_trait_safe_to_expose_on_stable(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
-    // A default body in a `#[const_trait]` is const-stable when the trait is const-stable.
+    // A default body in a `const trait` is const-stable when the trait is const-stable.
     if tcx.is_const_default_method(def_id) {
         return is_fn_or_trait_safe_to_expose_on_stable(tcx, tcx.parent(def_id));
     }
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index 70ad57b2b11..f24fb18f83b 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -363,8 +363,8 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
         if let ty::InstanceKind::Item(def) = instance.def {
             // Execution might have wandered off into other crates, so we cannot do a stability-
             // sensitive check here. But we can at least rule out functions that are not const at
-            // all. That said, we have to allow calling functions inside a trait marked with
-            // #[const_trait]. These *are* const-checked!
+            // all. That said, we have to allow calling functions inside a `const trait`. These
+            // *are* const-checked!
             if !ecx.tcx.is_const_fn(def) || ecx.tcx.has_attr(def, sym::rustc_do_not_const_check) {
                 // We certainly do *not* want to actually call the fn
                 // though, so be sure we return here.
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index e2827f227ab..74872504b79 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -614,6 +614,7 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     ),
 
     // RFC 2632
+    // FIXME(const_trait_impl) remove this
     gated!(
         const_trait, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No, const_trait_impl,
         "`const_trait` is a temporary placeholder for marking a trait that is suitable for `const` \
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index ace2259aec3..e7898648c2b 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -4163,6 +4163,7 @@ impl<'hir> Item<'hir> {
 
         expect_trait,
             (
+                Constness,
                 IsAuto,
                 Safety,
                 Ident,
@@ -4170,8 +4171,8 @@ impl<'hir> Item<'hir> {
                 GenericBounds<'hir>,
                 &'hir [TraitItemId]
             ),
-            ItemKind::Trait(is_auto, safety, ident, generics, bounds, items),
-            (*is_auto, *safety, *ident, generics, bounds, items);
+            ItemKind::Trait(constness, is_auto, safety, ident, generics, bounds, items),
+            (*constness, *is_auto, *safety, *ident, generics, bounds, items);
 
         expect_trait_alias, (Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
             ItemKind::TraitAlias(ident, generics, bounds), (*ident, generics, bounds);
@@ -4341,7 +4342,15 @@ pub enum ItemKind<'hir> {
     /// A union definition, e.g., `union Foo<A, B> {x: A, y: B}`.
     Union(Ident, &'hir Generics<'hir>, VariantData<'hir>),
     /// A trait definition.
-    Trait(IsAuto, Safety, Ident, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemId]),
+    Trait(
+        Constness,
+        IsAuto,
+        Safety,
+        Ident,
+        &'hir Generics<'hir>,
+        GenericBounds<'hir>,
+        &'hir [TraitItemId],
+    ),
     /// A trait alias.
     TraitAlias(Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
 
@@ -4385,7 +4394,7 @@ impl ItemKind<'_> {
             | ItemKind::Enum(ident, ..)
             | ItemKind::Struct(ident, ..)
             | ItemKind::Union(ident, ..)
-            | ItemKind::Trait(_, _, ident, ..)
+            | ItemKind::Trait(_, _, _, ident, ..)
             | ItemKind::TraitAlias(ident, ..) => Some(ident),
 
             ItemKind::Use(_, UseKind::Glob | UseKind::ListStem)
@@ -4403,7 +4412,7 @@ impl ItemKind<'_> {
             | ItemKind::Enum(_, generics, _)
             | ItemKind::Struct(_, generics, _)
             | ItemKind::Union(_, generics, _)
-            | ItemKind::Trait(_, _, _, generics, _, _)
+            | ItemKind::Trait(_, _, _, _, generics, _, _)
             | ItemKind::TraitAlias(_, generics, _)
             | ItemKind::Impl(Impl { generics, .. }) => generics,
             _ => return None,
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index 3edb94c28da..f33915d5b07 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -618,7 +618,15 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
             try_visit!(visitor.visit_generics(generics));
             try_visit!(visitor.visit_variant_data(struct_definition));
         }
-        ItemKind::Trait(_is_auto, _safety, ident, ref generics, bounds, trait_item_refs) => {
+        ItemKind::Trait(
+            _constness,
+            _is_auto,
+            _safety,
+            ident,
+            ref generics,
+            bounds,
+            trait_item_refs,
+        ) => {
             try_visit!(visitor.visit_ident(ident));
             try_visit!(visitor.visit_generics(generics));
             walk_list!(visitor, visit_param_bound, bounds);
diff --git a/compiler/rustc_hir_analysis/messages.ftl b/compiler/rustc_hir_analysis/messages.ftl
index 529d3578985..a20becbe7e8 100644
--- a/compiler/rustc_hir_analysis/messages.ftl
+++ b/compiler/rustc_hir_analysis/messages.ftl
@@ -117,15 +117,15 @@ hir_analysis_coercion_between_struct_same_note = expected coercion between the s
 
 hir_analysis_coercion_between_struct_single_note = expected a single field to be coerced, none found
 
-hir_analysis_const_bound_for_non_const_trait = `{$modifier}` can only be applied to `#[const_trait]` traits
+hir_analysis_const_bound_for_non_const_trait = `{$modifier}` can only be applied to `const` traits
     .label = can't be applied to `{$trait_name}`
-    .note = `{$trait_name}` can't be used with `{$modifier}` because it isn't annotated with `#[const_trait]`
-    .suggestion = {$suggestion_pre}mark `{$trait_name}` as `#[const_trait]` to allow it to have `const` implementations
+    .note = `{$trait_name}` can't be used with `{$modifier}` because it isn't `const`
+    .suggestion = {$suggestion_pre}mark `{$trait_name}` as `const` to allow it to have `const` implementations
 
-hir_analysis_const_impl_for_non_const_trait = const `impl` for trait `{$trait_name}` which is not marked with `#[const_trait]`
+hir_analysis_const_impl_for_non_const_trait = const `impl` for trait `{$trait_name}` which is not `const`
     .label = this trait is not `const`
-    .suggestion = {$suggestion_pre}mark `{$trait_name}` as `#[const_trait]` to allow it to have `const` implementations
-    .note = marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+    .suggestion = {$suggestion_pre}mark `{$trait_name}` as `const` to allow it to have `const` implementations
+    .note = marking a trait with `const` ensures all default method bodies are `const`
     .adding = adding a non-const method body in the future would be a breaking change
 
 hir_analysis_const_param_ty_impl_on_non_adt =
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 28a8758178f..0728b24eb14 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -844,15 +844,20 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::AdtDef<'_> {
 fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     let item = tcx.hir_expect_item(def_id);
 
-    let (is_alias, is_auto, safety) = match item.kind {
-        hir::ItemKind::Trait(is_auto, safety, ..) => (false, is_auto == hir::IsAuto::Yes, safety),
-        hir::ItemKind::TraitAlias(..) => (true, false, hir::Safety::Safe),
+    let (constness, is_alias, is_auto, safety) = match item.kind {
+        hir::ItemKind::Trait(constness, is_auto, safety, ..) => {
+            (constness, false, is_auto == hir::IsAuto::Yes, safety)
+        }
+        hir::ItemKind::TraitAlias(..) => (hir::Constness::NotConst, true, false, hir::Safety::Safe),
         _ => span_bug!(item.span, "trait_def_of_item invoked on non-trait"),
     };
 
     let attrs = tcx.get_all_attrs(def_id);
     // Only regular traits can be const.
-    let constness = if !is_alias && find_attr!(attrs, AttributeKind::ConstTrait(_)) {
+    // FIXME(const_trait_impl): remove this
+    let constness = if constness == hir::Constness::Const
+        || !is_alias && find_attr!(attrs, AttributeKind::ConstTrait(_))
+    {
         hir::Constness::Const
     } else {
         hir::Constness::NotConst
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index af78130899e..f2f1560d8b2 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -163,7 +163,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
                         .map(|t| ty::Binder::dummy(t.instantiate_identity()));
                 }
             }
-            ItemKind::Trait(_, _, _, _, self_bounds, ..)
+            ItemKind::Trait(_, _, _, _, _, self_bounds, ..)
             | ItemKind::TraitAlias(_, _, self_bounds) => {
                 is_trait = Some((self_bounds, item.span));
             }
@@ -1022,7 +1022,7 @@ pub(super) fn const_conditions<'tcx>(
         Node::Item(item) => match item.kind {
             hir::ItemKind::Impl(impl_) => (impl_.generics, None, false),
             hir::ItemKind::Fn { generics, .. } => (generics, None, false),
-            hir::ItemKind::Trait(_, _, _, generics, supertraits, _) => {
+            hir::ItemKind::Trait(_, _, _, _, generics, supertraits, _) => {
                 (generics, Some((item.owner_id.def_id, supertraits)), false)
             }
             _ => bug!("const_conditions called on wrong item: {def_id:?}"),
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 8d7ac7db67b..77e63e38c8c 100644
--- a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
+++ b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -634,7 +634,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
             | hir::ItemKind::Enum(_, generics, _)
             | hir::ItemKind::Struct(_, generics, _)
             | hir::ItemKind::Union(_, generics, _)
-            | hir::ItemKind::Trait(_, _, _, generics, ..)
+            | hir::ItemKind::Trait(_, _, _, _, generics, ..)
             | hir::ItemKind::TraitAlias(_, generics, ..)
             | hir::ItemKind::Impl(&hir::Impl { generics, .. }) => {
                 // These kinds of items have only early-bound lifetime parameters.
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index c1c82839212..eb65050c17c 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -525,6 +525,7 @@ pub(crate) struct ConstImplForNonConstTrait {
     pub trait_name: String,
     #[suggestion(
         applicability = "machine-applicable",
+        // FIXME(const_trait_impl) fix this suggestion
         code = "#[const_trait] ",
         style = "verbose"
     )]
@@ -548,6 +549,7 @@ pub(crate) struct ConstBoundForNonConstTrait {
     pub suggestion_pre: &'static str,
     #[suggestion(
         applicability = "machine-applicable",
+        // FIXME(const_trait_impl) fix this suggestion
         code = "#[const_trait] ",
         style = "verbose"
     )]
diff --git a/compiler/rustc_hir_analysis/src/errors/wrong_number_of_generic_args.rs b/compiler/rustc_hir_analysis/src/errors/wrong_number_of_generic_args.rs
index 3f928fd056e..2d60c9561a9 100644
--- a/compiler/rustc_hir_analysis/src/errors/wrong_number_of_generic_args.rs
+++ b/compiler/rustc_hir_analysis/src/errors/wrong_number_of_generic_args.rs
@@ -635,7 +635,7 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
                 self.suggest_adding_type_and_const_args(err);
             }
             ExcessTypesOrConsts { .. } => {
-                // this can happen with `[const] T` where T isn't a const_trait.
+                // this can happen with `[const] T` where T isn't a `const trait`.
             }
             _ => unreachable!(),
         }
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
index 4784cfb5235..9a752aeccdd 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -334,7 +334,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         };
 
         let (trait_generics, trait_bounds) = match parent_trait.kind {
-            hir::ItemKind::Trait(_, _, _, generics, supertraits, _) => (generics, supertraits),
+            hir::ItemKind::Trait(_, _, _, _, generics, supertraits, _) => (generics, supertraits),
             hir::ItemKind::TraitAlias(_, generics, supertraits) => (generics, supertraits),
             _ => unreachable!(),
         };
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index 2c13c9ef438..bda02042aa6 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -735,8 +735,17 @@ impl<'a> State<'a> {
                 }
                 self.bclose(item.span, cb);
             }
-            hir::ItemKind::Trait(is_auto, safety, ident, generics, bounds, trait_items) => {
+            hir::ItemKind::Trait(
+                constness,
+                is_auto,
+                safety,
+                ident,
+                generics,
+                bounds,
+                trait_items,
+            ) => {
                 let (cb, ib) = self.head("");
+                self.print_constness(constness);
                 self.print_is_auto(is_auto);
                 self.print_safety(safety);
                 self.word_nbsp("trait");
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 2815621ffde..dbfa7e6273c 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -1189,7 +1189,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         entry.1.insert((self_ty.span, ""));
                     }
                     Some(Node::Item(hir::Item {
-                        kind: hir::ItemKind::Trait(rustc_ast::ast::IsAuto::Yes, ..),
+                        kind: hir::ItemKind::Trait(_, rustc_ast::ast::IsAuto::Yes, ..),
                         span: item_span,
                         ..
                     })) => {
@@ -1201,7 +1201,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     Some(
                         Node::Item(hir::Item {
                             kind:
-                                hir::ItemKind::Trait(_, _, ident, ..)
+                                hir::ItemKind::Trait(_, _, _, ident, ..)
                                 | hir::ItemKind::TraitAlias(ident, ..),
                             ..
                         })
@@ -4084,7 +4084,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             return;
                         }
                         Node::Item(hir::Item {
-                            kind: hir::ItemKind::Trait(_, _, ident, _, bounds, _),
+                            kind: hir::ItemKind::Trait(_, _, _, ident, _, bounds, _),
                             ..
                         }) => {
                             let (sp, sep, article) = if bounds.is_empty() {
diff --git a/compiler/rustc_lint/src/multiple_supertrait_upcastable.rs b/compiler/rustc_lint/src/multiple_supertrait_upcastable.rs
index 3cc55eaa0f2..5513c703f1d 100644
--- a/compiler/rustc_lint/src/multiple_supertrait_upcastable.rs
+++ b/compiler/rustc_lint/src/multiple_supertrait_upcastable.rs
@@ -39,7 +39,7 @@ impl<'tcx> LateLintPass<'tcx> for MultipleSupertraitUpcastable {
         let def_id = item.owner_id.to_def_id();
         // NOTE(nbdd0121): use `dyn_compatibility_violations` instead of `is_dyn_compatible` because
         // the latter will report `where_clause_object_safety` lint.
-        if let hir::ItemKind::Trait(_, _, ident, ..) = item.kind
+        if let hir::ItemKind::Trait(_, _, _, ident, ..) = item.kind
             && cx.tcx.is_dyn_compatible(def_id)
         {
             let direct_super_traits_iter = cx
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index b50453cb0df..5cd98038fc6 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1131,7 +1131,7 @@ fn should_encode_mir(
                     && reachable_set.contains(&def_id)
                     && (generics.requires_monomorphization(tcx)
                         || tcx.cross_crate_inlinable(def_id)));
-            // The function has a `const` modifier or is in a `#[const_trait]`.
+            // The function has a `const` modifier or is in a `const trait`.
             let is_const_fn = tcx.is_const_fn(def_id.to_def_id())
                 || tcx.is_const_default_method(def_id.to_def_id());
             (is_const_fn, opt)
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index 84710e5e636..42a1e7377f4 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -940,7 +940,7 @@ impl<'tcx> TyCtxt<'tcx> {
             }) => until_within(*outer_span, ty.span),
             // With generics and bounds.
             Node::Item(Item {
-                kind: ItemKind::Trait(_, _, _, generics, bounds, _),
+                kind: ItemKind::Trait(_, _, _, _, generics, bounds, _),
                 span: outer_span,
                 ..
             })
diff --git a/compiler/rustc_middle/src/ty/trait_def.rs b/compiler/rustc_middle/src/ty/trait_def.rs
index ea25ce65f77..59e2b2a034d 100644
--- a/compiler/rustc_middle/src/ty/trait_def.rs
+++ b/compiler/rustc_middle/src/ty/trait_def.rs
@@ -20,7 +20,7 @@ pub struct TraitDef {
 
     pub safety: hir::Safety,
 
-    /// Whether this trait has been annotated with `#[const_trait]`.
+    /// Whether this trait is `const`.
     pub constness: hir::Constness,
 
     /// If `true`, then this trait had the `#[rustc_paren_sugar]`
diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index af9f8735549..859118a4ade 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -855,6 +855,7 @@ parse_trailing_vert_not_allowed = a trailing `|` is not allowed in an or-pattern
     .suggestion = remove the `{$token}`
 
 parse_trait_alias_cannot_be_auto = trait aliases cannot be `auto`
+parse_trait_alias_cannot_be_const = trait aliases cannot be `const`
 parse_trait_alias_cannot_be_unsafe = trait aliases cannot be `unsafe`
 
 parse_transpose_dyn_or_impl = `for<...>` expected after `{$kw}`, not before
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index 7f1b0991f0c..4aaaba01fae 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -1961,6 +1961,14 @@ pub(crate) struct TraitAliasCannotBeAuto {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(parse_trait_alias_cannot_be_const)]
+pub(crate) struct TraitAliasCannotBeConst {
+    #[primary_span]
+    #[label(parse_trait_alias_cannot_be_const)]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_trait_alias_cannot_be_unsafe)]
 pub(crate) struct TraitAliasCannotBeUnsafe {
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index d6cc98d505c..b767b0fcf99 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -244,6 +244,9 @@ impl<'a> Parser<'a> {
             self.bump(); // `static`
             let mutability = self.parse_mutability();
             self.parse_static_item(safety, mutability)?
+        } else if self.check_keyword(exp!(Trait)) || self.check_trait_front_matter() {
+            // TRAIT ITEM
+            self.parse_item_trait(attrs, lo)?
         } else if let Const::Yes(const_span) = self.parse_constness(Case::Sensitive) {
             // CONST ITEM
             if self.token.is_keyword(kw::Impl) {
@@ -262,9 +265,6 @@ impl<'a> Parser<'a> {
                     define_opaque: None,
                 }))
             }
-        } else if self.check_keyword(exp!(Trait)) || self.check_auto_or_unsafe_trait_item() {
-            // TRAIT ITEM
-            self.parse_item_trait(attrs, lo)?
         } else if self.check_keyword(exp!(Impl))
             || self.check_keyword(exp!(Unsafe)) && self.is_keyword_ahead(1, &[kw::Impl])
         {
@@ -373,7 +373,7 @@ impl<'a> Parser<'a> {
     pub(super) fn is_path_start_item(&mut self) -> bool {
         self.is_kw_followed_by_ident(kw::Union) // no: `union::b`, yes: `union U { .. }`
         || self.is_reuse_path_item()
-        || self.check_auto_or_unsafe_trait_item() // no: `auto::b`, yes: `auto trait X { .. }`
+        || self.check_trait_front_matter() // no: `auto::b`, yes: `auto trait X { .. }`
         || self.is_async_fn() // no(2015): `async::b`, yes: `async fn`
         || matches!(self.is_macro_rules_item(), IsMacroRulesItem::Yes{..}) // no: `macro_rules::b`, yes: `macro_rules! mac`
     }
@@ -872,16 +872,19 @@ impl<'a> Parser<'a> {
         }
     }
 
-    /// Is this an `(unsafe auto? | auto) trait` item?
-    fn check_auto_or_unsafe_trait_item(&mut self) -> bool {
+    /// Is this an `(const unsafe? auto?| unsafe auto? | auto) trait` item?
+    fn check_trait_front_matter(&mut self) -> bool {
         // auto trait
         self.check_keyword(exp!(Auto)) && self.is_keyword_ahead(1, &[kw::Trait])
             // unsafe auto trait
             || self.check_keyword(exp!(Unsafe)) && self.is_keyword_ahead(1, &[kw::Trait, kw::Auto])
+            || self.check_keyword(exp!(Const)) && ((self.is_keyword_ahead(1, &[kw::Trait]) || self.is_keyword_ahead(1, &[kw::Auto]) && self.is_keyword_ahead(2, &[kw::Trait]))
+                || self.is_keyword_ahead(1, &[kw::Unsafe]) && self.is_keyword_ahead(2, &[kw::Trait, kw::Auto]))
     }
 
     /// Parses `unsafe? auto? trait Foo { ... }` or `trait Foo = Bar;`.
     fn parse_item_trait(&mut self, attrs: &mut AttrVec, lo: Span) -> PResult<'a, ItemKind> {
+        let constness = self.parse_constness(Case::Sensitive);
         let safety = self.parse_safety(Case::Sensitive);
         // Parse optional `auto` prefix.
         let is_auto = if self.eat_keyword(exp!(Auto)) {
@@ -913,6 +916,9 @@ impl<'a> Parser<'a> {
             self.expect_semi()?;
 
             let whole_span = lo.to(self.prev_token.span);
+            if let Const::Yes(_) = constness {
+                self.dcx().emit_err(errors::TraitAliasCannotBeConst { span: whole_span });
+            }
             if is_auto == IsAuto::Yes {
                 self.dcx().emit_err(errors::TraitAliasCannotBeAuto { span: whole_span });
             }
@@ -927,7 +933,15 @@ impl<'a> Parser<'a> {
             // It's a normal trait.
             generics.where_clause = self.parse_where_clause()?;
             let items = self.parse_item_list(attrs, |p| p.parse_trait_item(ForceCollect::No))?;
-            Ok(ItemKind::Trait(Box::new(Trait { is_auto, safety, ident, generics, bounds, items })))
+            Ok(ItemKind::Trait(Box::new(Trait {
+                constness,
+                is_auto,
+                safety,
+                ident,
+                generics,
+                bounds,
+                items,
+            })))
         }
     }
 
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 500b4279588..d1b856ca415 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -784,7 +784,7 @@ passes_unused_capture_maybe_capture_ref = value captured by `{$name}` is never r
     .help = did you mean to capture by reference instead?
 
 passes_unused_default_method_body_const_note =
-    `default_method_body_is_const` has been replaced with `#[const_trait]` on traits
+    `default_method_body_is_const` has been replaced with `const` on traits
 
 passes_unused_duplicate =
     unused attribute
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 1285e0ddf8e..d8ffcedeb88 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1160,7 +1160,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         match item.kind {
             ItemKind::Enum(_, generics, _) | ItemKind::Struct(_, generics, _)
                 if generics.params.len() != 0 => {}
-            ItemKind::Trait(_, _, _, generics, _, items)
+            ItemKind::Trait(_, _, _, _, generics, _, items)
                 if generics.params.len() != 0
                     || items.iter().any(|item| {
                         matches!(self.tcx.def_kind(item.owner_id), DefKind::AssocTy)
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
index d4cc1ceb280..1d8b934cef3 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
@@ -453,7 +453,7 @@ pub fn report_dyn_incompatibility<'tcx>(
     let trait_str = tcx.def_path_str(trait_def_id);
     let trait_span = tcx.hir_get_if_local(trait_def_id).and_then(|node| match node {
         hir::Node::Item(item) => match item.kind {
-            hir::ItemKind::Trait(_, _, ident, ..) | hir::ItemKind::TraitAlias(ident, _, _) => {
+            hir::ItemKind::Trait(_, _, _, ident, ..) | hir::ItemKind::TraitAlias(ident, _, _) => {
                 Some(ident.span)
             }
             _ => unreachable!(),
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 bd1d29826e6..cbbfad663db 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -267,7 +267,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             let node = self.tcx.hir_node_by_def_id(body_id);
             match node {
                 hir::Node::Item(hir::Item {
-                    kind: hir::ItemKind::Trait(_, _, ident, generics, bounds, _),
+                    kind: hir::ItemKind::Trait(_, _, _, ident, generics, bounds, _),
                     ..
                 }) if self_ty == self.tcx.types.self_param => {
                     assert!(param_ty);
@@ -330,7 +330,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 }
                 hir::Node::Item(hir::Item {
                     kind:
-                        hir::ItemKind::Trait(_, _, _, generics, ..)
+                        hir::ItemKind::Trait(_, _, _, _, generics, ..)
                         | hir::ItemKind::Impl(hir::Impl { generics, .. }),
                     ..
                 }) if projection.is_some() => {
@@ -354,7 +354,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         hir::ItemKind::Struct(_, generics, _)
                         | hir::ItemKind::Enum(_, generics, _)
                         | hir::ItemKind::Union(_, generics, _)
-                        | hir::ItemKind::Trait(_, _, _, generics, ..)
+                        | hir::ItemKind::Trait(_, _, _, _, generics, ..)
                         | hir::ItemKind::Impl(hir::Impl { generics, .. })
                         | hir::ItemKind::Fn { generics, .. }
                         | hir::ItemKind::TyAlias(_, generics, _)
@@ -414,7 +414,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         hir::ItemKind::Struct(_, generics, _)
                         | hir::ItemKind::Enum(_, generics, _)
                         | hir::ItemKind::Union(_, generics, _)
-                        | hir::ItemKind::Trait(_, _, _, generics, ..)
+                        | hir::ItemKind::Trait(_, _, _, _, generics, ..)
                         | hir::ItemKind::Impl(hir::Impl { generics, .. })
                         | hir::ItemKind::Fn { generics, .. }
                         | hir::ItemKind::TyAlias(_, generics, _)
@@ -3436,7 +3436,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 let mut is_auto_trait = false;
                 match tcx.hir_get_if_local(data.impl_or_alias_def_id) {
                     Some(Node::Item(hir::Item {
-                        kind: hir::ItemKind::Trait(is_auto, _, ident, ..),
+                        kind: hir::ItemKind::Trait(_, is_auto, _, ident, ..),
                         ..
                     })) => {
                         // FIXME: we should do something else so that it works even on crate foreign
diff --git a/compiler/rustc_trait_selection/src/errors.rs b/compiler/rustc_trait_selection/src/errors.rs
index 90cdf75265d..7901d52dffb 100644
--- a/compiler/rustc_trait_selection/src/errors.rs
+++ b/compiler/rustc_trait_selection/src/errors.rs
@@ -534,7 +534,7 @@ impl Subdiagnostic for AddLifetimeParamsSuggestion<'_> {
                     match self.tcx.parent_hir_node(self.tcx.local_def_id_to_hir_id(anon_reg.scope))
                     {
                         hir::Node::Item(hir::Item {
-                            kind: hir::ItemKind::Trait(_, _, _, generics, ..),
+                            kind: hir::ItemKind::Trait(_, _, _, _, generics, ..),
                             ..
                         })
                         | hir::Node::Item(hir::Item {
diff --git a/src/doc/rustc-dev-guide/src/effects.md b/src/doc/rustc-dev-guide/src/effects.md
index c7aa2714668..87b0103a7bc 100644
--- a/src/doc/rustc-dev-guide/src/effects.md
+++ b/src/doc/rustc-dev-guide/src/effects.md
@@ -67,10 +67,8 @@ in [`wfcheck::check_impl`].
 Here's an example:
 
 ```rust
-#[const_trait]
-trait Bar {}
-#[const_trait]
-trait Foo: ~const Bar {}
+const trait Bar {}
+const trait Foo: ~const Bar {}
 // `const_conditions` contains `HostEffect(Self: Bar, maybe)`
 
 impl const Bar for () {}
@@ -85,8 +83,7 @@ predicates of the trait method, and we attempt to prove the predicates of the
 impl method. We do the same for `const_conditions`:
 
 ```rust
-#[const_trait]
-trait Foo {
+const trait Foo {
     fn hi<T: ~const Default>();
 }
 
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 3df04091f16..1265a39d27b 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2865,7 +2865,7 @@ fn clean_maybe_renamed_item<'tcx>(
             ItemKind::Fn { ref sig, generics, body: body_id, .. } => {
                 clean_fn_or_proc_macro(item, sig, generics, body_id, &mut name, cx)
             }
-            ItemKind::Trait(_, _, _, generics, bounds, item_ids) => {
+            ItemKind::Trait(_, _, _, _, generics, bounds, item_ids) => {
                 let items = item_ids
                     .iter()
                     .map(|&ti| clean_trait_item(cx.tcx.hir_trait_item(ti), cx))
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 20babc6168b..09647492d93 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -648,7 +648,7 @@ impl Item {
             let sig = tcx.fn_sig(def_id).skip_binder();
             let constness = if tcx.is_const_fn(def_id) {
                 // rustc's `is_const_fn` returns `true` for associated functions that have an `impl const` parent
-                // or that have a `#[const_trait]` parent. Do not display those as `const` in rustdoc because we
+                // or that have a `const trait` parent. Do not display those as `const` in rustdoc because we
                 // won't be printing correct syntax plus the syntax is unstable.
                 match tcx.opt_associated_item(def_id) {
                     Some(ty::AssocItem {
diff --git a/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs b/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs
index 07df893ae3c..a9d3015ce5c 100644
--- a/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs
+++ b/src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs
@@ -306,7 +306,7 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
                     cur_f = Some(field);
                 }
             },
-            ItemKind::Trait(is_auto, _safety, _ident, _generics, _generic_bounds, item_ref)
+            ItemKind::Trait(_constness, is_auto, _safety, _ident, _generics, _generic_bounds, item_ref)
                 if self.enable_ordering_for_trait && *is_auto == IsAuto::No =>
             {
                 let mut cur_t: Option<(TraitItemId, Ident)> = None;
diff --git a/src/tools/clippy/clippy_lints/src/doc/mod.rs b/src/tools/clippy/clippy_lints/src/doc/mod.rs
index 2bf52216b83..22b781b8929 100644
--- a/src/tools/clippy/clippy_lints/src/doc/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/mod.rs
@@ -740,7 +740,7 @@ impl<'tcx> LateLintPass<'tcx> for Documentation {
                             );
                         }
                     },
-                    ItemKind::Trait(_, unsafety, ..) => match (headers.safety, unsafety) {
+                    ItemKind::Trait(_, _, unsafety, ..) => match (headers.safety, unsafety) {
                         (false, Safety::Unsafe) => span_lint(
                             cx,
                             MISSING_SAFETY_DOC,
diff --git a/src/tools/clippy/clippy_lints/src/len_zero.rs b/src/tools/clippy/clippy_lints/src/len_zero.rs
index d32017a8b41..1bf03480c82 100644
--- a/src/tools/clippy/clippy_lints/src/len_zero.rs
+++ b/src/tools/clippy/clippy_lints/src/len_zero.rs
@@ -125,7 +125,7 @@ declare_lint_pass!(LenZero => [LEN_ZERO, LEN_WITHOUT_IS_EMPTY, COMPARISON_TO_EMP
 
 impl<'tcx> LateLintPass<'tcx> for LenZero {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if let ItemKind::Trait(_, _, ident, _, _, trait_items) = item.kind
+        if let ItemKind::Trait(_, _, _, ident, _, _, trait_items) = item.kind
             && !item.span.from_expansion()
         {
             check_trait_items(cx, item, ident, trait_items);
diff --git a/src/tools/clippy/clippy_lints/src/missing_inline.rs b/src/tools/clippy/clippy_lints/src/missing_inline.rs
index 329f7193437..c4a3d10299b 100644
--- a/src/tools/clippy/clippy_lints/src/missing_inline.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_inline.rs
@@ -101,7 +101,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
                 let attrs = cx.tcx.hir_attrs(it.hir_id());
                 check_missing_inline_attrs(cx, attrs, it.span, desc);
             },
-            hir::ItemKind::Trait(ref _is_auto, ref _unsafe, _ident, _generics, _bounds, trait_items) => {
+            hir::ItemKind::Trait(ref _constness, ref _is_auto, ref _unsafe, _ident, _generics, _bounds, trait_items) => {
                 // note: we need to check if the trait is exported so we can't use
                 // `LateLintPass::check_trait_item` here.
                 for &tit in trait_items {
diff --git a/src/tools/clippy/clippy_lints/src/trait_bounds.rs b/src/tools/clippy/clippy_lints/src/trait_bounds.rs
index 45e54302e32..9182a55081f 100644
--- a/src/tools/clippy/clippy_lints/src/trait_bounds.rs
+++ b/src/tools/clippy/clippy_lints/src/trait_bounds.rs
@@ -112,7 +112,7 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
         // special handling for self trait bounds as these are not considered generics
         // ie. trait Foo: Display {}
         if let Item {
-            kind: ItemKind::Trait(_, _, _, _, bounds, ..),
+            kind: ItemKind::Trait(_, _, _, _, _, bounds, ..),
             ..
         } = item
         {
@@ -133,7 +133,7 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
                     ..
                 }) = segments.first()
                 && let Some(Node::Item(Item {
-                    kind: ItemKind::Trait(_, _, _, _, self_bounds, _),
+                    kind: ItemKind::Trait(_, _, _, _, _, self_bounds, _),
                     ..
                 })) = cx.tcx.hir_get_if_local(*def_id)
             {
diff --git a/src/tools/clippy/clippy_lints/src/upper_case_acronyms.rs b/src/tools/clippy/clippy_lints/src/upper_case_acronyms.rs
index 02281b9e922..944cd91a7fd 100644
--- a/src/tools/clippy/clippy_lints/src/upper_case_acronyms.rs
+++ b/src/tools/clippy/clippy_lints/src/upper_case_acronyms.rs
@@ -131,7 +131,7 @@ impl LateLintPass<'_> for UpperCaseAcronyms {
             return;
         }
         match it.kind {
-            ItemKind::TyAlias(ident, ..) | ItemKind::Struct(ident, ..) | ItemKind::Trait(_, _, ident, ..) => {
+            ItemKind::TyAlias(ident, ..) | ItemKind::Struct(ident, ..) | ItemKind::Trait(_, _, _, ident, ..) => {
                 check_ident(cx, &ident, it.hir_id(), self.upper_case_acronyms_aggressive);
             },
             ItemKind::Enum(ident, _, ref enumdef) => {
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 42254ec8e92..96f0273c439 100644
--- a/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
+++ b/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
@@ -444,6 +444,7 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
         },
         (
             Trait(box ast::Trait {
+                constness: lc,
                 is_auto: la,
                 safety: lu,
                 ident: li,
@@ -452,6 +453,7 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
                 items: lis,
             }),
             Trait(box ast::Trait {
+                constness: rc,
                 is_auto: ra,
                 safety: ru,
                 ident: ri,
@@ -460,7 +462,8 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
                 items: ris,
             }),
         ) => {
-            la == ra
+            matches!(lc, ast::Const::No) == matches!(rc, ast::Const::No)
+                && la == ra
                 && matches!(lu, Safety::Default) == matches!(ru, Safety::Default)
                 && eq_id(*li, *ri)
                 && eq_generics(lg, rg)
diff --git a/src/tools/clippy/clippy_utils/src/check_proc_macro.rs b/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
index ce61fffe0de..dc31ed08fb7 100644
--- a/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
+++ b/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
@@ -252,11 +252,11 @@ fn item_search_pat(item: &Item<'_>) -> (Pat, Pat) {
         ItemKind::Struct(_, _, VariantData::Struct { .. }) => (Pat::Str("struct"), Pat::Str("}")),
         ItemKind::Struct(..) => (Pat::Str("struct"), Pat::Str(";")),
         ItemKind::Union(..) => (Pat::Str("union"), Pat::Str("}")),
-        ItemKind::Trait(_, Safety::Unsafe, ..)
+        ItemKind::Trait(_, _, Safety::Unsafe, ..)
         | ItemKind::Impl(Impl {
             safety: Safety::Unsafe, ..
         }) => (Pat::Str("unsafe"), Pat::Str("}")),
-        ItemKind::Trait(IsAuto::Yes, ..) => (Pat::Str("auto"), Pat::Str("}")),
+        ItemKind::Trait(_, IsAuto::Yes, ..) => (Pat::Str("auto"), Pat::Str("}")),
         ItemKind::Trait(..) => (Pat::Str("trait"), Pat::Str("}")),
         ItemKind::Impl(_) => (Pat::Str("impl"), Pat::Str("}")),
         _ => return (Pat::Str(""), Pat::Str("")),
diff --git a/src/tools/clippy/tests/ui/assign_ops.fixed b/src/tools/clippy/tests/ui/assign_ops.fixed
index 99beea850a2..eee61f949e7 100644
--- a/src/tools/clippy/tests/ui/assign_ops.fixed
+++ b/src/tools/clippy/tests/ui/assign_ops.fixed
@@ -84,8 +84,7 @@ mod issue14871 {
         const ONE: Self;
     }
 
-    #[const_trait]
-    pub trait NumberConstants {
+    pub const trait NumberConstants {
         fn constant(value: usize) -> Self;
     }
 
diff --git a/src/tools/clippy/tests/ui/assign_ops.rs b/src/tools/clippy/tests/ui/assign_ops.rs
index 900d5ad38e0..13ffcee0a3c 100644
--- a/src/tools/clippy/tests/ui/assign_ops.rs
+++ b/src/tools/clippy/tests/ui/assign_ops.rs
@@ -84,8 +84,7 @@ mod issue14871 {
         const ONE: Self;
     }
 
-    #[const_trait]
-    pub trait NumberConstants {
+    pub const trait NumberConstants {
         fn constant(value: usize) -> Self;
     }
 
diff --git a/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.fixed b/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.fixed
index f1d5579a723..c113c1caaa6 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.fixed
+++ b/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.fixed
@@ -3,8 +3,7 @@
 
 // Reduced test case from https://github.com/rust-lang/rust-clippy/issues/14658
 
-#[const_trait]
-trait ConstTrait {
+const trait ConstTrait {
     fn method(self);
 }
 
diff --git a/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.rs b/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.rs
index d495759526d..69248bc52d5 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.rs
+++ b/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.rs
@@ -3,8 +3,7 @@
 
 // Reduced test case from https://github.com/rust-lang/rust-clippy/issues/14658
 
-#[const_trait]
-trait ConstTrait {
+const trait ConstTrait {
     fn method(self);
 }
 
diff --git a/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.stderr b/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.stderr
index b994b88fac6..7ea009cfc9b 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.stderr
+++ b/src/tools/clippy/tests/ui/missing_const_for_fn/const_trait.stderr
@@ -1,5 +1,5 @@
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/const_trait.rs:24:1
+  --> tests/ui/missing_const_for_fn/const_trait.rs:23:1
    |
 LL | / fn can_be_const() {
 LL | |     0u64.method();
diff --git a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.fixed b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.fixed
index cf52ecf2f03..88ba5f810b4 100644
--- a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.fixed
+++ b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.fixed
@@ -167,8 +167,7 @@ where
 }
 
 // #13476
-#[const_trait]
-trait ConstTrait {}
+const trait ConstTrait {}
 const fn const_trait_bounds_good<T: ConstTrait + [const] ConstTrait>() {}
 
 const fn const_trait_bounds_bad<T: [const] ConstTrait>() {}
diff --git a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.rs b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.rs
index 955562f08dc..19a4e70e294 100644
--- a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.rs
+++ b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.rs
@@ -167,8 +167,7 @@ where
 }
 
 // #13476
-#[const_trait]
-trait ConstTrait {}
+const trait ConstTrait {}
 const fn const_trait_bounds_good<T: ConstTrait + [const] ConstTrait>() {}
 
 const fn const_trait_bounds_bad<T: [const] ConstTrait + [const] ConstTrait>() {}
diff --git a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.stderr b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.stderr
index ab31721ef51..a56a683de97 100644
--- a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.stderr
+++ b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.stderr
@@ -59,19 +59,19 @@ LL | fn bad_trait_object(arg0: &(dyn Any + Send + Send)) {
    |                                 ^^^^^^^^^^^^^^^^^ help: try: `Any + Send`
 
 error: these bounds contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:174:36
+  --> tests/ui/trait_duplication_in_bounds.rs:173:36
    |
 LL | const fn const_trait_bounds_bad<T: [const] ConstTrait + [const] ConstTrait>() {}
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[const] ConstTrait`
 
 error: these where clauses contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:181:8
+  --> tests/ui/trait_duplication_in_bounds.rs:180:8
    |
 LL |     T: IntoIterator<Item = U::Owned> + IntoIterator<Item = U::Owned>,
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `IntoIterator<Item = U::Owned>`
 
 error: these where clauses contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:203:8
+  --> tests/ui/trait_duplication_in_bounds.rs:202:8
    |
 LL |     T: AssocConstTrait<ASSOC = 0> + AssocConstTrait<ASSOC = 0>,
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `AssocConstTrait<ASSOC = 0>`
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 dc1eba1a1ab..e5d8f78d948 100644
--- a/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
+++ b/src/tools/rust-analyzer/crates/test-utils/src/minicore.rs
@@ -1011,8 +1011,7 @@ pub mod ops {
     }
 
     #[lang = "add_assign"]
-    #[const_trait]
-    pub trait AddAssign<Rhs = Self> {
+    pub const trait AddAssign<Rhs = Self> {
         fn add_assign(&mut self, rhs: Rhs);
     }
 
diff --git a/src/tools/rustfmt/src/items.rs b/src/tools/rustfmt/src/items.rs
index 1a3897b51cb..7084639aca9 100644
--- a/src/tools/rustfmt/src/items.rs
+++ b/src/tools/rustfmt/src/items.rs
@@ -1172,6 +1172,7 @@ pub(crate) fn format_trait(
         unreachable!();
     };
     let ast::Trait {
+        constness,
         is_auto,
         safety,
         ident,
@@ -1182,7 +1183,8 @@ pub(crate) fn format_trait(
 
     let mut result = String::with_capacity(128);
     let header = format!(
-        "{}{}{}trait ",
+        "{}{}{}{}trait ",
+        format_constness(constness),
         format_visibility(context, &item.vis),
         format_safety(safety),
         format_auto(is_auto),
diff --git a/tests/crashes/117629.rs b/tests/crashes/117629.rs
index d8b5f328545..f63365395c6 100644
--- a/tests/crashes/117629.rs
+++ b/tests/crashes/117629.rs
@@ -3,8 +3,7 @@
 
 #![feature(const_trait_impl)]
 
-#[const_trait]
-trait Tr {
+const trait Tr {
     async fn ft1() {}
 }
 
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
index 5ce815b9aed..464208f989e 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr
@@ -4,7 +4,7 @@ error: `[const]` is not allowed here
 LL | trait Bar: ~const Foo {}
    |            ^^^^^^
    |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
   --> const-super-trait.rs:7:1
    |
 LL | trait Bar: ~const Foo {}
@@ -30,24 +30,24 @@ LL | const fn foo<T: ~const Bar>(x: &T) {
    = 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: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> const-super-trait.rs:7:12
    |
 LL | trait Bar: ~const Foo {}
    |            ^^^^^^ can't be applied to `Foo`
    |
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> const-super-trait.rs:9:17
    |
 LL | const fn foo<T: ~const Bar>(x: &T) {
    |                 ^^^^^^ can't be applied to `Bar`
    |
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Bar: ~const Foo {}
    | ++++++++++++++
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr
index ef764a62b06..569e559186f 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr
@@ -4,30 +4,30 @@ error: `[const]` is not allowed here
 LL | trait Bar: ~const Foo {}
    |            ^^^^^^
    |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
   --> const-super-trait.rs:7:1
    |
 LL | trait Bar: ~const Foo {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> const-super-trait.rs:7:12
    |
 LL | trait Bar: ~const Foo {}
    |            ^^^^^^ can't be applied to `Foo`
    |
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> const-super-trait.rs:9:17
    |
 LL | const fn foo<T: ~const Bar>(x: &T) {
    |                 ^^^^^^ can't be applied to `Bar`
    |
-help: mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Bar` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Bar: ~const Foo {}
    | ++++++++++++++
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
index 3dc147e076f..694e06fb6ea 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr
@@ -4,7 +4,7 @@ error: `[const]` is not allowed here
 7 | trait Bar: ~const Foo {}
   |            ^^^^^^
   |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
  --> const-super-trait.rs:7:1
   |
 7 | trait Bar: ~const Foo {}
@@ -26,25 +26,25 @@ error[E0658]: const trait impls are experimental
   |
   = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> for more information
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
  --> const-super-trait.rs:7:12
   |
 7 | trait Bar: ~const Foo {}
   |            ^^^^^^ can't be applied to `Foo`
   |
-note: `Foo` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+note: `Foo` can't be used with `[const]` because it isn't `const`
  --> const-super-trait.rs:3:1
   |
 3 | trait Foo {
   | ^^^^^^^^^
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
  --> const-super-trait.rs:9:17
   |
 9 | const fn foo<T: ~const Bar>(x: &T) {
   |                 ^^^^^^ can't be applied to `Bar`
   |
-note: `Bar` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+note: `Bar` can't be used with `[const]` because it isn't `const`
  --> const-super-trait.rs:7:1
   |
 7 | trait Bar: ~const Foo {}
diff --git a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr
index 2cdeb277ca4..2109f0deb72 100644
--- a/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr
+++ b/tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr
@@ -4,7 +4,7 @@ error: `[const]` is not allowed here
 7 | trait Bar: ~const Foo {}
   |            ^^^^^^
   |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
  --> const-super-trait.rs:7:1
   |
 7 | trait Bar: ~const Foo {}
@@ -16,25 +16,25 @@ error[E0554]: `#![feature]` may not be used on the NIGHTLY release channel
 1 | #![cfg_attr(feature_enabled, feature(const_trait_impl))]
   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
  --> const-super-trait.rs:7:12
   |
 7 | trait Bar: ~const Foo {}
   |            ^^^^^^ can't be applied to `Foo`
   |
-note: `Foo` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+note: `Foo` can't be used with `[const]` because it isn't `const`
  --> const-super-trait.rs:3:1
   |
 3 | trait Foo {
   | ^^^^^^^^^
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
  --> const-super-trait.rs:9:17
   |
 9 | const fn foo<T: ~const Bar>(x: &T) {
   |                 ^^^^^^ can't be applied to `Bar`
   |
-note: `Bar` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+note: `Bar` can't be used with `[const]` because it isn't `const`
  --> const-super-trait.rs:7:1
   |
 7 | trait Bar: ~const Foo {}
diff --git a/tests/run-make/const-trait-stable-toolchain/rmake.rs b/tests/run-make/const-trait-stable-toolchain/rmake.rs
index 09a7c27a106..729b71457e9 100644
--- a/tests/run-make/const-trait-stable-toolchain/rmake.rs
+++ b/tests/run-make/const-trait-stable-toolchain/rmake.rs
@@ -11,9 +11,7 @@ fn main() {
         .env("RUSTC_BOOTSTRAP", "-1")
         .cfg("feature_enabled")
         .run_fail()
-        .assert_stderr_not_contains(
-            "as `#[const_trait]` to allow it to have `const` implementations",
-        )
+        .assert_stderr_not_contains("as `const` to allow it to have `const` implementations")
         .stderr_utf8();
     diff()
         .expected_file("const-super-trait-stable-enabled.stderr")
@@ -29,7 +27,7 @@ fn main() {
         .ui_testing()
         .run_fail()
         .assert_stderr_not_contains("enable `#![feature(const_trait_impl)]` in your crate and mark")
-        .assert_stderr_contains("as `#[const_trait]` to allow it to have `const` implementations")
+        .assert_stderr_contains("as `const` to allow it to have `const` implementations")
         .stderr_utf8();
     diff()
         .expected_file("const-super-trait-nightly-enabled.stderr")
@@ -40,9 +38,7 @@ fn main() {
         .env("RUSTC_BOOTSTRAP", "-1")
         .run_fail()
         .assert_stderr_not_contains("enable `#![feature(const_trait_impl)]` in your crate and mark")
-        .assert_stderr_not_contains(
-            "as `#[const_trait]` to allow it to have `const` implementations",
-        )
+        .assert_stderr_not_contains("as `const` to allow it to have `const` implementations")
         .stderr_utf8();
     diff()
         .expected_file("const-super-trait-stable-disabled.stderr")
diff --git a/tests/ui/consts/const-try.rs b/tests/ui/consts/const-try.rs
index 26aa9230a39..e13fad78441 100644
--- a/tests/ui/consts/const-try.rs
+++ b/tests/ui/consts/const-try.rs
@@ -13,14 +13,14 @@ struct TryMe;
 struct Error;
 
 impl const FromResidual<Error> for TryMe {
-    //~^ ERROR const `impl` for trait `FromResidual` which is not marked with `#[const_trait]`
+    //~^ ERROR const `impl` for trait `FromResidual` which is not `const`
     fn from_residual(residual: Error) -> Self {
         TryMe
     }
 }
 
 impl const Try for TryMe {
-    //~^ ERROR const `impl` for trait `Try` which is not marked with `#[const_trait]`
+    //~^ ERROR const `impl` for trait `Try` which is not `const`
     type Output = ();
     type Residual = Error;
     fn from_output(output: Self::Output) -> Self {
diff --git a/tests/ui/consts/const-try.stderr b/tests/ui/consts/const-try.stderr
index 4209ca1d526..7004ea3e6db 100644
--- a/tests/ui/consts/const-try.stderr
+++ b/tests/ui/consts/const-try.stderr
@@ -1,19 +1,19 @@
-error: const `impl` for trait `FromResidual` which is not marked with `#[const_trait]`
+error: const `impl` for trait `FromResidual` which is not `const`
   --> $DIR/const-try.rs:15:12
    |
 LL | impl const FromResidual<Error> for TryMe {
    |            ^^^^^^^^^^^^^^^^^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
-error: const `impl` for trait `Try` which is not marked with `#[const_trait]`
+error: const `impl` for trait `Try` which is not `const`
   --> $DIR/const-try.rs:22:12
    |
 LL | impl const Try for TryMe {
    |            ^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
 error[E0015]: `?` is not allowed on `TryMe` in constant functions
diff --git a/tests/ui/consts/rustc-impl-const-stability.stderr b/tests/ui/consts/rustc-impl-const-stability.stderr
index a3ef4031a13..55c08539688 100644
--- a/tests/ui/consts/rustc-impl-const-stability.stderr
+++ b/tests/ui/consts/rustc-impl-const-stability.stderr
@@ -1,10 +1,10 @@
-error: const `impl` for trait `Debug` which is not marked with `#[const_trait]`
+error: const `impl` for trait `Debug` which is not `const`
   --> $DIR/rustc-impl-const-stability.rs:15:12
    |
 LL | impl const std::fmt::Debug for Data {
    |            ^^^^^^^^^^^^^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/specialization/const_trait_impl.stderr b/tests/ui/specialization/const_trait_impl.stderr
index b9c768812c8..a21a48997ee 100644
--- a/tests/ui/specialization/const_trait_impl.stderr
+++ b/tests/ui/specialization/const_trait_impl.stderr
@@ -1,57 +1,57 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/const_trait_impl.rs:36:9
    |
 LL | impl<T: [const] Debug> const A for T {
    |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+note: `Debug` can't be used with `[const]` because it isn't `const`
   --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/const_trait_impl.rs:42:9
    |
 LL | impl<T: [const] Debug + [const] Sup> const A for T {
    |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+note: `Debug` can't be used with `[const]` because it isn't `const`
   --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/const_trait_impl.rs:48:9
    |
 LL | impl<T: [const] Debug + [const] Sub> const A for T {
    |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+note: `Debug` can't be used with `[const]` because it isn't `const`
   --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/const_trait_impl.rs:42:9
    |
 LL | impl<T: [const] Debug + [const] Sup> const A for T {
    |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+note: `Debug` can't be used with `[const]` because it isn't `const`
   --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/const_trait_impl.rs:36:9
    |
 LL | impl<T: [const] Debug> const A for T {
    |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+note: `Debug` can't be used with `[const]` because it isn't `const`
   --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/const_trait_impl.rs:48:9
    |
 LL | impl<T: [const] Debug + [const] Sub> const A for T {
    |         ^^^^^^^ can't be applied to `Debug`
    |
-note: `Debug` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
+note: `Debug` can't be used with `[const]` because it isn't `const`
   --> $SRC_DIR/core/src/fmt/mod.rs:LL:COL
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
diff --git a/tests/ui/stability-attribute/missing-const-stability.rs b/tests/ui/stability-attribute/missing-const-stability.rs
index c3e72e83948..8a37f19ffb0 100644
--- a/tests/ui/stability-attribute/missing-const-stability.rs
+++ b/tests/ui/stability-attribute/missing-const-stability.rs
@@ -20,8 +20,7 @@ impl Foo {
 }
 
 #[stable(feature = "stable", since = "1.0.0")]
-#[const_trait]
-pub trait Bar {
+pub const trait Bar {
 //~^ ERROR trait has missing const stability attribute
     #[stable(feature = "stable", since = "1.0.0")]
     fn fun();
diff --git a/tests/ui/stability-attribute/missing-const-stability.stderr b/tests/ui/stability-attribute/missing-const-stability.stderr
index 09461e6fb54..70a2450c53a 100644
--- a/tests/ui/stability-attribute/missing-const-stability.stderr
+++ b/tests/ui/stability-attribute/missing-const-stability.stderr
@@ -5,9 +5,9 @@ LL | pub const fn foo() {}
    | ^^^^^^^^^^^^^^^^^^^^^
 
 error: trait has missing const stability attribute
-  --> $DIR/missing-const-stability.rs:24:1
+  --> $DIR/missing-const-stability.rs:23:1
    |
-LL | / pub trait Bar {
+LL | / pub const trait Bar {
 LL | |
 LL | |     #[stable(feature = "stable", since = "1.0.0")]
 LL | |     fn fun();
@@ -15,7 +15,7 @@ LL | | }
    | |_^
 
 error: function has missing const stability attribute
-  --> $DIR/missing-const-stability.rs:37:1
+  --> $DIR/missing-const-stability.rs:36:1
    |
 LL | pub const unsafe fn size_of_val<T>(x: *const T) -> usize { 42 }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/traits/const-traits/conditionally-const-invalid-places.stderr b/tests/ui/traits/const-traits/conditionally-const-invalid-places.stderr
index d0dd9502915..010b1584643 100644
--- a/tests/ui/traits/const-traits/conditionally-const-invalid-places.stderr
+++ b/tests/ui/traits/const-traits/conditionally-const-invalid-places.stderr
@@ -72,7 +72,7 @@ error: `[const]` is not allowed here
 LL |     type Type<T: [const] Trait>: [const] Trait;
    |                  ^^^^^^^
    |
-note: associated types in non-`#[const_trait]` traits cannot have `[const]` trait bounds
+note: associated types in non-`const` traits cannot have `[const]` trait bounds
   --> $DIR/conditionally-const-invalid-places.rs:25:5
    |
 LL |     type Type<T: [const] Trait>: [const] Trait;
@@ -84,7 +84,7 @@ error: `[const]` is not allowed here
 LL |     type Type<T: [const] Trait>: [const] Trait;
    |                                  ^^^^^^^
    |
-note: associated types in non-`#[const_trait]` traits cannot have `[const]` trait bounds
+note: associated types in non-`const` traits cannot have `[const]` trait bounds
   --> $DIR/conditionally-const-invalid-places.rs:25:5
    |
 LL |     type Type<T: [const] Trait>: [const] Trait;
@@ -180,7 +180,7 @@ error: `[const]` is not allowed here
 LL | trait Child0: [const] Trait {}
    |               ^^^^^^^
    |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
   --> $DIR/conditionally-const-invalid-places.rs:52:1
    |
 LL | trait Child0: [const] Trait {}
@@ -192,7 +192,7 @@ error: `[const]` is not allowed here
 LL | trait Child1 where Self: [const] Trait {}
    |                          ^^^^^^^
    |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
   --> $DIR/conditionally-const-invalid-places.rs:53:1
    |
 LL | trait Child1 where Self: [const] Trait {}
diff --git a/tests/ui/traits/const-traits/const-bounds-non-const-trait.rs b/tests/ui/traits/const-traits/const-bounds-non-const-trait.rs
index ae31d9ae0ac..baded179201 100644
--- a/tests/ui/traits/const-traits/const-bounds-non-const-trait.rs
+++ b/tests/ui/traits/const-traits/const-bounds-non-const-trait.rs
@@ -4,10 +4,10 @@
 trait NonConst {}
 
 const fn perform<T: [const] NonConst>() {}
-//~^ ERROR `[const]` can only be applied to `#[const_trait]` traits
-//~| ERROR `[const]` can only be applied to `#[const_trait]` traits
+//~^ ERROR `[const]` can only be applied to `const` traits
+//~| ERROR `[const]` can only be applied to `const` traits
 
 fn operate<T: const NonConst>() {}
-//~^ ERROR `const` can only be applied to `#[const_trait]` traits
+//~^ ERROR `const` can only be applied to `const` traits
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/const-bounds-non-const-trait.stderr b/tests/ui/traits/const-traits/const-bounds-non-const-trait.stderr
index 6c68e4ec3ac..304d81bb917 100644
--- a/tests/ui/traits/const-traits/const-bounds-non-const-trait.stderr
+++ b/tests/ui/traits/const-traits/const-bounds-non-const-trait.stderr
@@ -1,33 +1,33 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/const-bounds-non-const-trait.rs:6:21
    |
 LL | const fn perform<T: [const] NonConst>() {}
    |                     ^^^^^^^ can't be applied to `NonConst`
    |
-help: mark `NonConst` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `NonConst` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait NonConst {}
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/const-bounds-non-const-trait.rs:6:21
    |
 LL | const fn perform<T: [const] NonConst>() {}
    |                     ^^^^^^^ can't be applied to `NonConst`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `NonConst` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `NonConst` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait NonConst {}
    | ++++++++++++++
 
-error: `const` can only be applied to `#[const_trait]` traits
+error: `const` can only be applied to `const` traits
   --> $DIR/const-bounds-non-const-trait.rs:10:15
    |
 LL | fn operate<T: const NonConst>() {}
    |               ^^^^^ can't be applied to `NonConst`
    |
-help: mark `NonConst` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `NonConst` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait NonConst {}
    | ++++++++++++++
diff --git a/tests/ui/traits/const-traits/const-impl-requires-const-trait.rs b/tests/ui/traits/const-traits/const-impl-requires-const-trait.rs
index 6bea664b65f..176ae091a41 100644
--- a/tests/ui/traits/const-traits/const-impl-requires-const-trait.rs
+++ b/tests/ui/traits/const-traits/const-impl-requires-const-trait.rs
@@ -4,6 +4,6 @@
 pub trait A {}
 
 impl const A for () {}
-//~^ ERROR: const `impl` for trait `A` which is not marked with `#[const_trait]`
+//~^ ERROR: const `impl` for trait `A` which is not `const`
 
 fn main() {}
diff --git a/tests/ui/traits/const-traits/const-impl-requires-const-trait.stderr b/tests/ui/traits/const-traits/const-impl-requires-const-trait.stderr
index c728eda069e..bf73436b78d 100644
--- a/tests/ui/traits/const-traits/const-impl-requires-const-trait.stderr
+++ b/tests/ui/traits/const-traits/const-impl-requires-const-trait.stderr
@@ -1,12 +1,12 @@
-error: const `impl` for trait `A` which is not marked with `#[const_trait]`
+error: const `impl` for trait `A` which is not `const`
   --> $DIR/const-impl-requires-const-trait.rs:6:12
    |
 LL | impl const A for () {}
    |            ^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
-help: mark `A` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `A` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] pub trait A {}
    | ++++++++++++++
diff --git a/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.rs b/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.rs
index 1d1da9b0e3d..658132441c2 100644
--- a/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.rs
+++ b/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.rs
@@ -1,9 +1,7 @@
 #![feature(const_trait_impl)]
-// FIXME(const_trait_impl) add effects
 //@ edition: 2021
 
-#[const_trait]
-trait Trait {}
+const trait Trait {}
 
 fn main() {
     let _: &dyn const Trait; //~ ERROR const trait bounds are not allowed in trait object types
@@ -14,7 +12,7 @@ fn main() {
 trait NonConst {}
 const fn handle(_: &dyn const NonConst) {}
 //~^ ERROR const trait bounds are not allowed in trait object types
-//~| ERROR `const` can only be applied to `#[const_trait]` traits
+//~| ERROR `const` can only be applied to `const` traits
 const fn take(_: &dyn [const] NonConst) {}
 //~^ ERROR `[const]` is not allowed here
-//~| ERROR `[const]` can only be applied to `#[const_trait]` traits
+//~| ERROR `[const]` can only be applied to `const` traits
diff --git a/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr b/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr
index 06e0493024c..3ba5da39106 100644
--- a/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr
+++ b/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr
@@ -1,11 +1,11 @@
 error: const trait bounds are not allowed in trait object types
-  --> $DIR/const-trait-bounds-trait-objects.rs:9:17
+  --> $DIR/const-trait-bounds-trait-objects.rs:7:17
    |
 LL |     let _: &dyn const Trait;
    |                 ^^^^^^^^^^^
 
 error: `[const]` is not allowed here
-  --> $DIR/const-trait-bounds-trait-objects.rs:10:17
+  --> $DIR/const-trait-bounds-trait-objects.rs:8:17
    |
 LL |     let _: &dyn [const] Trait;
    |                 ^^^^^^^
@@ -13,37 +13,37 @@ LL |     let _: &dyn [const] Trait;
    = note: trait objects cannot have `[const]` trait bounds
 
 error: const trait bounds are not allowed in trait object types
-  --> $DIR/const-trait-bounds-trait-objects.rs:15:25
+  --> $DIR/const-trait-bounds-trait-objects.rs:13:25
    |
 LL | const fn handle(_: &dyn const NonConst) {}
    |                         ^^^^^^^^^^^^^^
 
 error: `[const]` is not allowed here
-  --> $DIR/const-trait-bounds-trait-objects.rs:18:23
+  --> $DIR/const-trait-bounds-trait-objects.rs:16:23
    |
 LL | const fn take(_: &dyn [const] NonConst) {}
    |                       ^^^^^^^
    |
    = note: trait objects cannot have `[const]` trait bounds
 
-error: `const` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-trait-bounds-trait-objects.rs:15:25
+error: `const` can only be applied to `const` traits
+  --> $DIR/const-trait-bounds-trait-objects.rs:13:25
    |
 LL | const fn handle(_: &dyn const NonConst) {}
    |                         ^^^^^ can't be applied to `NonConst`
    |
-help: mark `NonConst` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `NonConst` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait NonConst {}
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
-  --> $DIR/const-trait-bounds-trait-objects.rs:18:23
+error: `[const]` can only be applied to `const` traits
+  --> $DIR/const-trait-bounds-trait-objects.rs:16:23
    |
 LL | const fn take(_: &dyn [const] NonConst) {}
    |                       ^^^^^^^ can't be applied to `NonConst`
    |
-help: mark `NonConst` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `NonConst` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait NonConst {}
    | ++++++++++++++
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-gate.rs b/tests/ui/traits/const-traits/const_derives/derive-const-gate.rs
index 04fea1189ae..c0796907855 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-gate.rs
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-gate.rs
@@ -1,5 +1,5 @@
 #[derive_const(Debug)] //~ ERROR use of unstable library feature
-//~^ ERROR const `impl` for trait `Debug` which is not marked with `#[const_trait]`
+//~^ ERROR const `impl` for trait `Debug` which is not `const`
 //~| ERROR cannot call non-const method
 pub struct S;
 
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr b/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr
index 5bde358001c..5ed12b37052 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr
@@ -7,13 +7,13 @@ LL | #[derive_const(Debug)]
    = help: add `#![feature(derive_const)]` 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: const `impl` for trait `Debug` which is not marked with `#[const_trait]`
+error: const `impl` for trait `Debug` which is not `const`
   --> $DIR/derive-const-gate.rs:1:16
    |
 LL | #[derive_const(Debug)]
    |                ^^^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
 error[E0015]: cannot call non-const method `Formatter::<'_>::write_str` in constant functions
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
index c0bd360ebe5..93638801895 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-non-const-type.stderr
@@ -1,10 +1,10 @@
-error: const `impl` for trait `Debug` which is not marked with `#[const_trait]`
+error: const `impl` for trait `Debug` which is not `const`
   --> $DIR/derive-const-non-const-type.rs:12:16
    |
 LL | #[derive_const(Debug)]
    |                ^^^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
 error[E0015]: cannot call non-const method `Formatter::<'_>::debug_tuple_field1_finish` in constant functions
diff --git a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs
index e53b87274d3..47c85980aca 100644
--- a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs
+++ b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs
@@ -4,7 +4,7 @@
 use std::ops::FromResidual;
 
 impl<T> const FromResidual for T {
-    //~^ ERROR const `impl` for trait `FromResidual` which is not marked with `#[const_trait]`
+    //~^ ERROR const `impl` for trait `FromResidual` which is not `const`
     //~| ERROR type parameter `T` must be used as the type parameter for some local type
     fn from_residual(t: T) -> _ {
         //~^ ERROR the placeholder `_` is not allowed
diff --git a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr
index a165ef12060..5c5fba95f02 100644
--- a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr
+++ b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr
@@ -1,10 +1,10 @@
-error: const `impl` for trait `FromResidual` which is not marked with `#[const_trait]`
+error: const `impl` for trait `FromResidual` which is not `const`
   --> $DIR/ice-119717-constant-lifetime.rs:6:15
    |
 LL | impl<T> const FromResidual for T {
    |               ^^^^^^^^^^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
 error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
diff --git a/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.rs b/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.rs
index 3473be565c1..5e368b9e6a9 100644
--- a/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.rs
+++ b/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.rs
@@ -6,11 +6,11 @@ struct TryMe;
 struct Error;
 
 impl const FromResidual<Error> for TryMe {}
-//~^ ERROR const `impl` for trait `FromResidual` which is not marked with `#[const_trait]`
+//~^ ERROR const `impl` for trait `FromResidual` which is not `const`
 //~| ERROR not all trait items implemented
 
 impl const Try for TryMe {
-    //~^ ERROR const `impl` for trait `Try` which is not marked with `#[const_trait]`
+    //~^ ERROR const `impl` for trait `Try` which is not `const`
     //~| ERROR not all trait items implemented
     type Output = ();
     type Residual = Error;
diff --git a/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.stderr b/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.stderr
index 41f99c2d375..849d6522cd6 100644
--- a/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.stderr
+++ b/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.stderr
@@ -1,10 +1,10 @@
-error: const `impl` for trait `FromResidual` which is not marked with `#[const_trait]`
+error: const `impl` for trait `FromResidual` which is not `const`
   --> $DIR/ice-126148-failed-to-normalize.rs:8:12
    |
 LL | impl const FromResidual<Error> for TryMe {}
    |            ^^^^^^^^^^^^^^^^^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
 error[E0046]: not all trait items implemented, missing: `from_residual`
@@ -15,13 +15,13 @@ LL | impl const FromResidual<Error> for TryMe {}
    |
    = help: implement the missing item: `fn from_residual(_: Error) -> Self { todo!() }`
 
-error: const `impl` for trait `Try` which is not marked with `#[const_trait]`
+error: const `impl` for trait `Try` which is not `const`
   --> $DIR/ice-126148-failed-to-normalize.rs:12:12
    |
 LL | impl const Try for TryMe {
    |            ^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
 error[E0046]: not all trait items implemented, missing: `from_output`, `branch`
diff --git a/tests/ui/traits/const-traits/spec-effectvar-ice.rs b/tests/ui/traits/const-traits/spec-effectvar-ice.rs
index c85b1746967..46f71b114a3 100644
--- a/tests/ui/traits/const-traits/spec-effectvar-ice.rs
+++ b/tests/ui/traits/const-traits/spec-effectvar-ice.rs
@@ -8,11 +8,11 @@ trait Specialize {}
 trait Foo {}
 
 impl<T> const Foo for T {}
-//~^ error: const `impl` for trait `Foo` which is not marked with `#[const_trait]`
+//~^ error: const `impl` for trait `Foo` which is not `const`
 
 impl<T> const Foo for T where T: const Specialize {}
-//~^ error: const `impl` for trait `Foo` which is not marked with `#[const_trait]`
-//~| error: `const` can only be applied to `#[const_trait]` traits
+//~^ error: const `impl` for trait `Foo` which is not `const`
+//~| error: `const` can only be applied to `const` traits
 //~| error: specialization impl does not specialize any associated items
 //~| error: cannot specialize on trait `Specialize`
 
diff --git a/tests/ui/traits/const-traits/spec-effectvar-ice.stderr b/tests/ui/traits/const-traits/spec-effectvar-ice.stderr
index 474d96698d5..ef5e58e1c3d 100644
--- a/tests/ui/traits/const-traits/spec-effectvar-ice.stderr
+++ b/tests/ui/traits/const-traits/spec-effectvar-ice.stderr
@@ -1,36 +1,36 @@
-error: const `impl` for trait `Foo` which is not marked with `#[const_trait]`
+error: const `impl` for trait `Foo` which is not `const`
   --> $DIR/spec-effectvar-ice.rs:10:15
    |
 LL | impl<T> const Foo for T {}
    |               ^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {}
    | ++++++++++++++
 
-error: const `impl` for trait `Foo` which is not marked with `#[const_trait]`
+error: const `impl` for trait `Foo` which is not `const`
   --> $DIR/spec-effectvar-ice.rs:13:15
    |
 LL | impl<T> const Foo for T where T: const Specialize {}
    |               ^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {}
    | ++++++++++++++
 
-error: `const` can only be applied to `#[const_trait]` traits
+error: `const` can only be applied to `const` traits
   --> $DIR/spec-effectvar-ice.rs:13:34
    |
 LL | impl<T> const Foo for T where T: const Specialize {}
    |                                  ^^^^^ can't be applied to `Specialize`
    |
-help: mark `Specialize` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Specialize` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Specialize {}
    | ++++++++++++++
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr b/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
index 19f072b289e..0ecbad64bc8 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
@@ -4,43 +4,43 @@ error: `[const]` is not allowed here
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^
    |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
   --> $DIR/super-traits-fail-2.rs:11:1
    |
 LL | trait Bar: [const] Foo {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-2.rs:11:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-2.rs:11:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-2.rs:11:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr b/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
index 4921f78d3ac..0e5b697d1dd 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
@@ -1,58 +1,58 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-2.rs:11:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-2.rs:11:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-2.rs:11:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-2.rs:11:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-2.rs:11:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.rs b/tests/ui/traits/const-traits/super-traits-fail-2.rs
index 781dacb81a1..36e7c1c4e4a 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.rs
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.rs
@@ -9,11 +9,11 @@ trait Foo {
 
 #[cfg_attr(any(yy, ny), const_trait)]
 trait Bar: [const] Foo {}
-//[ny,nn]~^ ERROR: `[const]` can only be applied to `#[const_trait]`
-//[ny,nn]~| ERROR: `[const]` can only be applied to `#[const_trait]`
-//[ny,nn]~| ERROR: `[const]` can only be applied to `#[const_trait]`
-//[ny]~| ERROR: `[const]` can only be applied to `#[const_trait]`
-//[ny]~| ERROR: `[const]` can only be applied to `#[const_trait]`
+//[ny,nn]~^ ERROR: `[const]` can only be applied to `const` traits
+//[ny,nn]~| ERROR: `[const]` can only be applied to `const` traits
+//[ny,nn]~| ERROR: `[const]` can only be applied to `const` traits
+//[ny]~| ERROR: `[const]` can only be applied to `const` traits
+//[ny]~| ERROR: `[const]` can only be applied to `const` traits
 //[yn,nn]~^^^^^^ ERROR: `[const]` is not allowed here
 
 const fn foo<T: Bar>(x: &T) {
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.yn.stderr b/tests/ui/traits/const-traits/super-traits-fail-2.yn.stderr
index a151349822e..657e8ee82e3 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.yn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.yn.stderr
@@ -4,7 +4,7 @@ error: `[const]` is not allowed here
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^
    |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
   --> $DIR/super-traits-fail-2.rs:11:1
    |
 LL | trait Bar: [const] Foo {}
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
index 3f48375dd04..a0ae60526ef 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
@@ -4,7 +4,7 @@ error: `[const]` is not allowed here
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^
    |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
   --> $DIR/super-traits-fail-3.rs:23:1
    |
 LL | trait Bar: [const] Foo {}
@@ -30,60 +30,60 @@ LL | const fn foo<T: [const] Bar>(x: &T) {
    = 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: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:32:17
    |
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^ can't be applied to `Bar`
    |
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Bar: [const] Foo {}
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:32:17
    |
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^ can't be applied to `Bar`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Bar: [const] Foo {}
    | ++++++++++++++
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
index 3f48375dd04..a0ae60526ef 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
@@ -4,7 +4,7 @@ error: `[const]` is not allowed here
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^
    |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
   --> $DIR/super-traits-fail-3.rs:23:1
    |
 LL | trait Bar: [const] Foo {}
@@ -30,60 +30,60 @@ LL | const fn foo<T: [const] Bar>(x: &T) {
    = 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: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:32:17
    |
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^ can't be applied to `Bar`
    |
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Bar: [const] Foo {}
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:32:17
    |
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^ can't be applied to `Bar`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
+help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Bar: [const] Foo {}
    | ++++++++++++++
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.rs b/tests/ui/traits/const-traits/super-traits-fail-3.rs
index 5370f607dec..d74bd346784 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.rs
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.rs
@@ -21,17 +21,17 @@ trait Foo {
 #[cfg_attr(any(yyy, yny, nyy, nyn), const_trait)]
 //[nyy,nyn]~^ ERROR: `const_trait` is a temporary placeholder for marking a trait that is suitable for `const` `impls` and all default bodies as `const`, which may be removed or renamed in the future
 trait Bar: [const] Foo {}
-//[yny,ynn,nny,nnn]~^ ERROR: `[const]` can only be applied to `#[const_trait]`
-//[yny,ynn,nny,nnn]~| ERROR: `[const]` can only be applied to `#[const_trait]`
-//[yny,ynn,nny,nnn]~| ERROR: `[const]` can only be applied to `#[const_trait]`
-//[yny]~^^^^ ERROR: `[const]` can only be applied to `#[const_trait]`
-//[yny]~| ERROR: `[const]` can only be applied to `#[const_trait]`
+//[yny,ynn,nny,nnn]~^ ERROR: `[const]` can only be applied to `const` traits
+//[yny,ynn,nny,nnn]~| ERROR: `[const]` can only be applied to `const` traits
+//[yny,ynn,nny,nnn]~| ERROR: `[const]` can only be applied to `const` traits
+//[yny]~^^^^ ERROR: `[const]` can only be applied to `const` traits
+//[yny]~| ERROR: `[const]` can only be applied to `const` traits
 //[yyn,ynn,nny,nnn]~^^^^^^ ERROR: `[const]` is not allowed here
 //[nyy,nyn,nny,nnn]~^^^^^^^ ERROR: const trait impls are experimental
 
 const fn foo<T: [const] Bar>(x: &T) {
-    //[yyn,ynn,nny,nnn]~^ ERROR: `[const]` can only be applied to `#[const_trait]`
-    //[yyn,ynn,nny,nnn]~| ERROR: `[const]` can only be applied to `#[const_trait]`
+    //[yyn,ynn,nny,nnn]~^ ERROR: `[const]` can only be applied to `const` traits
+    //[yyn,ynn,nny,nnn]~| ERROR: `[const]` can only be applied to `const` traits
     //[nyy,nyn,nny,nnn]~^^^ ERROR: const trait impls are experimental
     x.a();
     //[yyn]~^ ERROR: the trait bound `T: [const] Foo` is not satisfied
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
index 89e090b7d1c..c8ec77c2f09 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
@@ -4,66 +4,66 @@ error: `[const]` is not allowed here
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^
    |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
   --> $DIR/super-traits-fail-3.rs:23:1
    |
 LL | trait Bar: [const] Foo {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:32:17
    |
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^ can't be applied to `Bar`
    |
-help: mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Bar` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Bar: [const] Foo {}
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:32:17
    |
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^ can't be applied to `Bar`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Bar` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Bar: [const] Foo {}
    | ++++++++++++++
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
index 683eeb73850..a820239cde0 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
@@ -1,58 +1,58 @@
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:23:12
    |
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^ can't be applied to `Foo`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Foo` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Foo {
    | ++++++++++++++
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.yyn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.yyn.stderr
index 39cfdfe2030..de3664dae84 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.yyn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.yyn.stderr
@@ -4,31 +4,31 @@ error: `[const]` is not allowed here
 LL | trait Bar: [const] Foo {}
    |            ^^^^^^^
    |
-note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
+note: this trait is not `const`, so it cannot have `[const]` trait bounds
   --> $DIR/super-traits-fail-3.rs:23:1
    |
 LL | trait Bar: [const] Foo {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:32:17
    |
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^ can't be applied to `Bar`
    |
-help: mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Bar` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Bar: [const] Foo {}
    | ++++++++++++++
 
-error: `[const]` can only be applied to `#[const_trait]` traits
+error: `[const]` can only be applied to `const` traits
   --> $DIR/super-traits-fail-3.rs:32:17
    |
 LL | const fn foo<T: [const] Bar>(x: &T) {
    |                 ^^^^^^^ can't be applied to `Bar`
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
+help: mark `Bar` as `const` to allow it to have `const` implementations
    |
 LL | #[const_trait] trait Bar: [const] Foo {}
    | ++++++++++++++
diff --git a/tests/ui/traits/const-traits/trait-default-body-stability.stderr b/tests/ui/traits/const-traits/trait-default-body-stability.stderr
index a13d9a1e075..b995d6f4f3d 100644
--- a/tests/ui/traits/const-traits/trait-default-body-stability.stderr
+++ b/tests/ui/traits/const-traits/trait-default-body-stability.stderr
@@ -1,19 +1,19 @@
-error: const `impl` for trait `Try` which is not marked with `#[const_trait]`
+error: const `impl` for trait `Try` which is not `const`
   --> $DIR/trait-default-body-stability.rs:19:12
    |
 LL | impl const Try for T {
    |            ^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
-error: const `impl` for trait `FromResidual` which is not marked with `#[const_trait]`
+error: const `impl` for trait `FromResidual` which is not `const`
   --> $DIR/trait-default-body-stability.rs:34:12
    |
 LL | impl const FromResidual for T {
    |            ^^^^^^^^^^^^ this trait is not `const`
    |
-   = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
+   = note: marking a trait with `const` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
 error[E0015]: `?` is not allowed on `T` in constant functions
-- 
cgit 1.4.1-3-g733a5


From d963c78140a9636810e7ffd0c50022b23be902cb Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Thu, 17 Jul 2025 12:30:52 +0200
Subject: Update the `no-merges` PR title

Match the new CI-created PRs:
https://github.com/rust-lang/compiler-builtins/pull/974.
---
 library/compiler-builtins/triagebot.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/compiler-builtins/triagebot.toml b/library/compiler-builtins/triagebot.toml
index 715be27fc65..8a2356c2b1c 100644
--- a/library/compiler-builtins/triagebot.toml
+++ b/library/compiler-builtins/triagebot.toml
@@ -4,7 +4,7 @@
 # Warns when a PR contains merge commits
 # Documentation at: https://forge.rust-lang.org/triagebot/no-merge.html
 [no-merges]
-exclude_titles = ["Update from"]
+exclude_titles = ["Rustc pull update"]
 
 # Canonicalize issue numbers to avoid closing the wrong issue
 # when commits are included in subtrees, as well as warning links in commits.
-- 
cgit 1.4.1-3-g733a5


From c0597fbd80acdc23434ed8f59c41f0728a2d9ba6 Mon Sep 17 00:00:00 2001
From: Kivooeo <Kivooeo123@gmail.com>
Date: Mon, 14 Jul 2025 02:19:24 +0500
Subject: cleaned up some tests

Reverting file name weird-exprs.rs due to its historical use, recognition in community and references
---
 .../deduplicate-diagnostics.deduplicate.stderr     |   4 +-
 .../deduplicate-diagnostics.duplicate.stderr       |  10 +-
 .../ui/diagnostic-flags/deduplicate-diagnostics.rs |   2 +
 tests/ui/expr/syntax-edge-cases-lint-clean.rs      | 303 ---------------------
 tests/ui/expr/weird-exprs.rs                       | 303 +++++++++++++++++++++
 tests/ui/fmt/println-debug-different-types.rs      |   4 +-
 tests/ui/linking/ld64-cross-compilation.rs         |   8 +-
 tests/ui/shadowed/shadowing-generic-item.rs        |   2 +
 tests/ui/shadowed/shadowing-generic-item.stderr    |   4 +-
 .../ui/symbol-names/struct-constructor-mangling.rs |   4 +-
 10 files changed, 325 insertions(+), 319 deletions(-)
 delete mode 100644 tests/ui/expr/syntax-edge-cases-lint-clean.rs
 create mode 100644 tests/ui/expr/weird-exprs.rs

diff --git a/tests/ui/diagnostic-flags/deduplicate-diagnostics.deduplicate.stderr b/tests/ui/diagnostic-flags/deduplicate-diagnostics.deduplicate.stderr
index 5df2c687bdd..c0d568eb538 100644
--- a/tests/ui/diagnostic-flags/deduplicate-diagnostics.deduplicate.stderr
+++ b/tests/ui/diagnostic-flags/deduplicate-diagnostics.deduplicate.stderr
@@ -1,11 +1,11 @@
 error[E0452]: malformed lint attribute input
-  --> $DIR/deduplicate-diagnostics.rs:8:8
+  --> $DIR/deduplicate-diagnostics.rs:10:8
    |
 LL | #[deny("literal")]
    |        ^^^^^^^^^ bad attribute argument
 
 error: cannot find derive macro `Unresolved` in this scope
-  --> $DIR/deduplicate-diagnostics.rs:4:10
+  --> $DIR/deduplicate-diagnostics.rs:6:10
    |
 LL | #[derive(Unresolved)]
    |          ^^^^^^^^^^
diff --git a/tests/ui/diagnostic-flags/deduplicate-diagnostics.duplicate.stderr b/tests/ui/diagnostic-flags/deduplicate-diagnostics.duplicate.stderr
index 48e2ba7b86a..74d7066293f 100644
--- a/tests/ui/diagnostic-flags/deduplicate-diagnostics.duplicate.stderr
+++ b/tests/ui/diagnostic-flags/deduplicate-diagnostics.duplicate.stderr
@@ -1,17 +1,17 @@
 error[E0452]: malformed lint attribute input
-  --> $DIR/deduplicate-diagnostics.rs:8:8
+  --> $DIR/deduplicate-diagnostics.rs:10:8
    |
 LL | #[deny("literal")]
    |        ^^^^^^^^^ bad attribute argument
 
 error: cannot find derive macro `Unresolved` in this scope
-  --> $DIR/deduplicate-diagnostics.rs:4:10
+  --> $DIR/deduplicate-diagnostics.rs:6:10
    |
 LL | #[derive(Unresolved)]
    |          ^^^^^^^^^^
 
 error: cannot find derive macro `Unresolved` in this scope
-  --> $DIR/deduplicate-diagnostics.rs:4:10
+  --> $DIR/deduplicate-diagnostics.rs:6:10
    |
 LL | #[derive(Unresolved)]
    |          ^^^^^^^^^^
@@ -19,7 +19,7 @@ LL | #[derive(Unresolved)]
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0452]: malformed lint attribute input
-  --> $DIR/deduplicate-diagnostics.rs:8:8
+  --> $DIR/deduplicate-diagnostics.rs:10:8
    |
 LL | #[deny("literal")]
    |        ^^^^^^^^^ bad attribute argument
@@ -27,7 +27,7 @@ LL | #[deny("literal")]
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0452]: malformed lint attribute input
-  --> $DIR/deduplicate-diagnostics.rs:8:8
+  --> $DIR/deduplicate-diagnostics.rs:10:8
    |
 LL | #[deny("literal")]
    |        ^^^^^^^^^ bad attribute argument
diff --git a/tests/ui/diagnostic-flags/deduplicate-diagnostics.rs b/tests/ui/diagnostic-flags/deduplicate-diagnostics.rs
index 299c1f5f461..48705266e35 100644
--- a/tests/ui/diagnostic-flags/deduplicate-diagnostics.rs
+++ b/tests/ui/diagnostic-flags/deduplicate-diagnostics.rs
@@ -1,3 +1,5 @@
+//! Test that `-Z deduplicate-diagnostics` flag properly deduplicates diagnostic messages.
+
 //@ revisions: duplicate deduplicate
 //@[deduplicate] compile-flags: -Z deduplicate-diagnostics=yes
 
diff --git a/tests/ui/expr/syntax-edge-cases-lint-clean.rs b/tests/ui/expr/syntax-edge-cases-lint-clean.rs
deleted file mode 100644
index 7db92d46067..00000000000
--- a/tests/ui/expr/syntax-edge-cases-lint-clean.rs
+++ /dev/null
@@ -1,303 +0,0 @@
-//@ run-pass
-
-#![feature(coroutines)]
-
-#![allow(non_camel_case_types)]
-#![allow(dead_code)]
-#![allow(redundant_semicolons)]
-#![allow(unreachable_code)]
-#![allow(unused_braces, unused_must_use, unused_parens)]
-#![allow(uncommon_codepoints, confusable_idents)]
-#![allow(unused_imports)]
-#![allow(unreachable_patterns)]
-
-#![recursion_limit = "256"]
-
-extern crate core;
-use std::cell::Cell;
-use std::mem::swap;
-use std::ops::Deref;
-
-// Just a grab bag of stuff that you wouldn't want to actually write.
-
-fn strange() -> bool { let _x: bool = return true; }
-
-fn funny() {
-    fn f(_x: ()) { }
-    f(return);
-}
-
-fn what() {
-    fn the(x: &Cell<bool>) {
-        return while !x.get() { x.set(true); };
-    }
-    let i = &Cell::new(false);
-    let dont = {||the(i)};
-    dont();
-    assert!(i.get());
-}
-
-fn zombiejesus() {
-    loop {
-        while (return) {
-            if (return) {
-                match (return) {
-                    1 => {
-                        if (return) {
-                            return
-                        } else {
-                            return
-                        }
-                    }
-                    _ => { return }
-                };
-            } else if (return) {
-                return;
-            }
-        }
-        if (return) { break; }
-    }
-}
-
-fn notsure() {
-    let mut _x: isize;
-    let mut _y = (_x = 0) == (_x = 0);
-    let mut _z = (_x = 0) < (_x = 0);
-    let _a = (_x += 0) == (_x = 0);
-    let _b = swap(&mut _y, &mut _z) == swap(&mut _y, &mut _z);
-}
-
-fn canttouchthis() -> usize {
-    fn p() -> bool { true }
-    let _a = (assert!(true) == (assert!(p())));
-    let _c = (assert!(p()) == ());
-    let _b: bool = (println!("{}", 0) == (return 0));
-}
-
-fn angrydome() {
-    loop { if break { } }
-    let mut i = 0;
-    loop { i += 1; if i == 1 { match (continue) { 1 => { }, _ => panic!("wat") } }
-      break; }
-}
-
-fn evil_lincoln() { let _evil: () = println!("lincoln"); }
-
-fn dots() {
-    assert_eq!(String::from(".................................................."),
-               format!("{:?}", .. .. .. .. .. .. .. .. .. .. .. .. ..
-                               .. .. .. .. .. .. .. .. .. .. .. ..));
-}
-
-fn u8(u8: u8) {
-    if u8 != 0u8 {
-        assert_eq!(8u8, {
-            macro_rules! u8 {
-                (u8) => {
-                    mod u8 {
-                        pub fn u8<'u8: 'u8 + 'u8>(u8: &'u8 u8) -> &'u8 u8 {
-                            "u8";
-                            u8
-                        }
-                    }
-                };
-            }
-
-            u8!(u8);
-            let &u8: &u8 = u8::u8(&8u8);
-            crate::u8(0u8);
-            u8
-        });
-    }
-}
-
-fn fishy() {
-    assert_eq!(String::from("><>"),
-               String::<>::from::<>("><>").chars::<>().rev::<>().collect::<String>());
-}
-
-fn union() {
-    union union<'union> { union: &'union union<'union>, }
-}
-
-fn special_characters() {
-    let val = !((|(..):(_,_),(|__@_|__)|__)((&*"\\",'🤔')/**/,{})=={&[..=..][..];})//
-    ;
-    assert!(!val);
-}
-
-fn punch_card() -> impl std::fmt::Debug {
-    ..=..=.. ..    .. .. .. ..    .. .. .. ..    .. .. .. ..
-    ..=.. ..=..    .. .. .. ..    .. .. .. ..    .. ..=.. ..
-    ..=.. ..=..    ..=.. ..=..    .. ..=..=..    ..=..=..=..
-    ..=..=.. ..    ..=.. ..=..    ..=.. .. ..    .. ..=.. ..
-    ..=.. ..=..    ..=.. ..=..    .. ..=.. ..    .. ..=.. ..
-    ..=.. ..=..    ..=.. ..=..    .. .. ..=..    .. ..=.. ..
-    ..=.. ..=..    .. ..=..=..    ..=..=.. ..    .. ..=..=..
-}
-
-fn r#match() {
-    let val: () = match match match match match () {
-        () => ()
-    } {
-        () => ()
-    } {
-        () => ()
-    } {
-        () => ()
-    } {
-        () => ()
-    };
-    assert_eq!(val, ());
-}
-
-fn i_yield() {
-    #[coroutine]
-    static || {
-        yield yield yield yield yield yield yield yield yield;
-    };
-}
-
-fn match_nested_if() {
-    let val = match () {
-        () if if if if true {true} else {false} {true} else {false} {true} else {false} => true,
-        _ => false,
-    };
-    assert!(val);
-}
-
-fn monkey_barrel() {
-    let val: () = ()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=();
-    assert_eq!(val, ());
-}
-
-fn 𝚌𝚘𝚗𝚝𝚒𝚗𝚞𝚎() {
-    type 𝚕𝚘𝚘𝚙 = i32;
-    fn 𝚋𝚛𝚎𝚊𝚔() -> 𝚕𝚘𝚘𝚙 {
-        let 𝚛𝚎𝚝𝚞𝚛𝚗 = 42;
-        return 𝚛𝚎𝚝𝚞𝚛𝚗;
-    }
-    assert_eq!(loop {
-        break 𝚋𝚛𝚎𝚊𝚔 ();
-    }, 42);
-}
-
-fn function() {
-    struct foo;
-    impl Deref for foo {
-        type Target = fn() -> Self;
-        fn deref(&self) -> &Self::Target {
-            &((|| foo) as _)
-        }
-    }
-    let foo = foo () ()() ()()() ()()()() ()()()()();
-}
-
-fn bathroom_stall() {
-    let mut i = 1;
-    matches!(2, _|_|_|_|_|_ if (i+=1) != (i+=1));
-    assert_eq!(i, 13);
-}
-
-fn closure_matching() {
-    let x = |_| Some(1);
-    let (|x| x) = match x(..) {
-        |_| Some(2) => |_| Some(3),
-        |_| _ => unreachable!(),
-    };
-    assert!(matches!(x(..), |_| Some(4)));
-}
-
-fn semisemisemisemisemi() {
-    ;;;;;;; ;;;;;;; ;;;    ;;; ;;
-    ;;      ;;      ;;;;  ;;;; ;;
-    ;;;;;;; ;;;;;   ;; ;;;; ;; ;;
-         ;; ;;      ;;  ;;  ;; ;;
-    ;;;;;;; ;;;;;;; ;;      ;; ;;
-}
-
-fn useful_syntax() {
-    use {{std::{{collections::{{HashMap}}}}}};
-    use ::{{{{core}, {std}}}};
-    use {{::{{core as core2}}}};
-}
-
-fn infcx() {
-    pub mod cx {
-        pub mod cx {
-            pub use super::cx;
-            pub struct Cx;
-        }
-    }
-    let _cx: cx::cx::Cx = cx::cx::cx::cx::cx::Cx;
-}
-
-fn return_already() -> impl std::fmt::Debug {
-    loop {
-        return !!!!!!!
-        break !!!!!!1111
-    }
-}
-
-fn fake_macros() -> impl std::fmt::Debug {
-    loop {
-        if! {
-            match! (
-                break! {
-                    return! {
-                        1337
-                    }
-                }
-            )
-
-            {}
-        }
-
-        {}
-    }
-}
-
-fn fish_fight() {
-    trait Rope {
-        fn _____________<U>(_: Self, _: U) where Self: Sized {}
-    }
-
-    struct T;
-
-    impl Rope for T {}
-
-    fn tug_o_war(_: impl Fn(T, T)) {}
-
-    tug_o_war(<T>::_____________::<T>);
-}
-
-pub fn main() {
-    strange();
-    funny();
-    what();
-    zombiejesus();
-    notsure();
-    canttouchthis();
-    angrydome();
-    evil_lincoln();
-    dots();
-    u8(8u8);
-    fishy();
-    union();
-    special_characters();
-    punch_card();
-    r#match();
-    i_yield();
-    match_nested_if();
-    monkey_barrel();
-    𝚌𝚘𝚗𝚝𝚒𝚗𝚞𝚎();
-    function();
-    bathroom_stall();
-    closure_matching();
-    semisemisemisemisemi();
-    useful_syntax();
-    infcx();
-    return_already();
-    fake_macros();
-    fish_fight();
-}
diff --git a/tests/ui/expr/weird-exprs.rs b/tests/ui/expr/weird-exprs.rs
new file mode 100644
index 00000000000..7db92d46067
--- /dev/null
+++ b/tests/ui/expr/weird-exprs.rs
@@ -0,0 +1,303 @@
+//@ run-pass
+
+#![feature(coroutines)]
+
+#![allow(non_camel_case_types)]
+#![allow(dead_code)]
+#![allow(redundant_semicolons)]
+#![allow(unreachable_code)]
+#![allow(unused_braces, unused_must_use, unused_parens)]
+#![allow(uncommon_codepoints, confusable_idents)]
+#![allow(unused_imports)]
+#![allow(unreachable_patterns)]
+
+#![recursion_limit = "256"]
+
+extern crate core;
+use std::cell::Cell;
+use std::mem::swap;
+use std::ops::Deref;
+
+// Just a grab bag of stuff that you wouldn't want to actually write.
+
+fn strange() -> bool { let _x: bool = return true; }
+
+fn funny() {
+    fn f(_x: ()) { }
+    f(return);
+}
+
+fn what() {
+    fn the(x: &Cell<bool>) {
+        return while !x.get() { x.set(true); };
+    }
+    let i = &Cell::new(false);
+    let dont = {||the(i)};
+    dont();
+    assert!(i.get());
+}
+
+fn zombiejesus() {
+    loop {
+        while (return) {
+            if (return) {
+                match (return) {
+                    1 => {
+                        if (return) {
+                            return
+                        } else {
+                            return
+                        }
+                    }
+                    _ => { return }
+                };
+            } else if (return) {
+                return;
+            }
+        }
+        if (return) { break; }
+    }
+}
+
+fn notsure() {
+    let mut _x: isize;
+    let mut _y = (_x = 0) == (_x = 0);
+    let mut _z = (_x = 0) < (_x = 0);
+    let _a = (_x += 0) == (_x = 0);
+    let _b = swap(&mut _y, &mut _z) == swap(&mut _y, &mut _z);
+}
+
+fn canttouchthis() -> usize {
+    fn p() -> bool { true }
+    let _a = (assert!(true) == (assert!(p())));
+    let _c = (assert!(p()) == ());
+    let _b: bool = (println!("{}", 0) == (return 0));
+}
+
+fn angrydome() {
+    loop { if break { } }
+    let mut i = 0;
+    loop { i += 1; if i == 1 { match (continue) { 1 => { }, _ => panic!("wat") } }
+      break; }
+}
+
+fn evil_lincoln() { let _evil: () = println!("lincoln"); }
+
+fn dots() {
+    assert_eq!(String::from(".................................................."),
+               format!("{:?}", .. .. .. .. .. .. .. .. .. .. .. .. ..
+                               .. .. .. .. .. .. .. .. .. .. .. ..));
+}
+
+fn u8(u8: u8) {
+    if u8 != 0u8 {
+        assert_eq!(8u8, {
+            macro_rules! u8 {
+                (u8) => {
+                    mod u8 {
+                        pub fn u8<'u8: 'u8 + 'u8>(u8: &'u8 u8) -> &'u8 u8 {
+                            "u8";
+                            u8
+                        }
+                    }
+                };
+            }
+
+            u8!(u8);
+            let &u8: &u8 = u8::u8(&8u8);
+            crate::u8(0u8);
+            u8
+        });
+    }
+}
+
+fn fishy() {
+    assert_eq!(String::from("><>"),
+               String::<>::from::<>("><>").chars::<>().rev::<>().collect::<String>());
+}
+
+fn union() {
+    union union<'union> { union: &'union union<'union>, }
+}
+
+fn special_characters() {
+    let val = !((|(..):(_,_),(|__@_|__)|__)((&*"\\",'🤔')/**/,{})=={&[..=..][..];})//
+    ;
+    assert!(!val);
+}
+
+fn punch_card() -> impl std::fmt::Debug {
+    ..=..=.. ..    .. .. .. ..    .. .. .. ..    .. .. .. ..
+    ..=.. ..=..    .. .. .. ..    .. .. .. ..    .. ..=.. ..
+    ..=.. ..=..    ..=.. ..=..    .. ..=..=..    ..=..=..=..
+    ..=..=.. ..    ..=.. ..=..    ..=.. .. ..    .. ..=.. ..
+    ..=.. ..=..    ..=.. ..=..    .. ..=.. ..    .. ..=.. ..
+    ..=.. ..=..    ..=.. ..=..    .. .. ..=..    .. ..=.. ..
+    ..=.. ..=..    .. ..=..=..    ..=..=.. ..    .. ..=..=..
+}
+
+fn r#match() {
+    let val: () = match match match match match () {
+        () => ()
+    } {
+        () => ()
+    } {
+        () => ()
+    } {
+        () => ()
+    } {
+        () => ()
+    };
+    assert_eq!(val, ());
+}
+
+fn i_yield() {
+    #[coroutine]
+    static || {
+        yield yield yield yield yield yield yield yield yield;
+    };
+}
+
+fn match_nested_if() {
+    let val = match () {
+        () if if if if true {true} else {false} {true} else {false} {true} else {false} => true,
+        _ => false,
+    };
+    assert!(val);
+}
+
+fn monkey_barrel() {
+    let val: () = ()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=();
+    assert_eq!(val, ());
+}
+
+fn 𝚌𝚘𝚗𝚝𝚒𝚗𝚞𝚎() {
+    type 𝚕𝚘𝚘𝚙 = i32;
+    fn 𝚋𝚛𝚎𝚊𝚔() -> 𝚕𝚘𝚘𝚙 {
+        let 𝚛𝚎𝚝𝚞𝚛𝚗 = 42;
+        return 𝚛𝚎𝚝𝚞𝚛𝚗;
+    }
+    assert_eq!(loop {
+        break 𝚋𝚛𝚎𝚊𝚔 ();
+    }, 42);
+}
+
+fn function() {
+    struct foo;
+    impl Deref for foo {
+        type Target = fn() -> Self;
+        fn deref(&self) -> &Self::Target {
+            &((|| foo) as _)
+        }
+    }
+    let foo = foo () ()() ()()() ()()()() ()()()()();
+}
+
+fn bathroom_stall() {
+    let mut i = 1;
+    matches!(2, _|_|_|_|_|_ if (i+=1) != (i+=1));
+    assert_eq!(i, 13);
+}
+
+fn closure_matching() {
+    let x = |_| Some(1);
+    let (|x| x) = match x(..) {
+        |_| Some(2) => |_| Some(3),
+        |_| _ => unreachable!(),
+    };
+    assert!(matches!(x(..), |_| Some(4)));
+}
+
+fn semisemisemisemisemi() {
+    ;;;;;;; ;;;;;;; ;;;    ;;; ;;
+    ;;      ;;      ;;;;  ;;;; ;;
+    ;;;;;;; ;;;;;   ;; ;;;; ;; ;;
+         ;; ;;      ;;  ;;  ;; ;;
+    ;;;;;;; ;;;;;;; ;;      ;; ;;
+}
+
+fn useful_syntax() {
+    use {{std::{{collections::{{HashMap}}}}}};
+    use ::{{{{core}, {std}}}};
+    use {{::{{core as core2}}}};
+}
+
+fn infcx() {
+    pub mod cx {
+        pub mod cx {
+            pub use super::cx;
+            pub struct Cx;
+        }
+    }
+    let _cx: cx::cx::Cx = cx::cx::cx::cx::cx::Cx;
+}
+
+fn return_already() -> impl std::fmt::Debug {
+    loop {
+        return !!!!!!!
+        break !!!!!!1111
+    }
+}
+
+fn fake_macros() -> impl std::fmt::Debug {
+    loop {
+        if! {
+            match! (
+                break! {
+                    return! {
+                        1337
+                    }
+                }
+            )
+
+            {}
+        }
+
+        {}
+    }
+}
+
+fn fish_fight() {
+    trait Rope {
+        fn _____________<U>(_: Self, _: U) where Self: Sized {}
+    }
+
+    struct T;
+
+    impl Rope for T {}
+
+    fn tug_o_war(_: impl Fn(T, T)) {}
+
+    tug_o_war(<T>::_____________::<T>);
+}
+
+pub fn main() {
+    strange();
+    funny();
+    what();
+    zombiejesus();
+    notsure();
+    canttouchthis();
+    angrydome();
+    evil_lincoln();
+    dots();
+    u8(8u8);
+    fishy();
+    union();
+    special_characters();
+    punch_card();
+    r#match();
+    i_yield();
+    match_nested_if();
+    monkey_barrel();
+    𝚌𝚘𝚗𝚝𝚒𝚗𝚞𝚎();
+    function();
+    bathroom_stall();
+    closure_matching();
+    semisemisemisemisemi();
+    useful_syntax();
+    infcx();
+    return_already();
+    fake_macros();
+    fish_fight();
+}
diff --git a/tests/ui/fmt/println-debug-different-types.rs b/tests/ui/fmt/println-debug-different-types.rs
index 64994a55817..9e21be1f03f 100644
--- a/tests/ui/fmt/println-debug-different-types.rs
+++ b/tests/ui/fmt/println-debug-different-types.rs
@@ -1,8 +1,10 @@
+//! Smoke test for println!() with debug format specifiers.
+
 //@ run-pass
 
 #[derive(Debug)]
 enum Numbers {
-    Three
+    Three,
 }
 
 pub fn main() {
diff --git a/tests/ui/linking/ld64-cross-compilation.rs b/tests/ui/linking/ld64-cross-compilation.rs
index 75acc07a002..d6c6d1ff91d 100644
--- a/tests/ui/linking/ld64-cross-compilation.rs
+++ b/tests/ui/linking/ld64-cross-compilation.rs
@@ -1,11 +1,11 @@
+//! This is a regression test for https://github.com/rust-lang/rust/issues/140686.
+//! Although this is a ld64(ld-classic) bug, we still need to support it
+//! due to cross-compilation and support for older Xcode.
+
 //@ compile-flags: -Copt-level=3 -Ccodegen-units=256 -Clink-arg=-ld_classic
 //@ run-pass
 //@ only-x86_64-apple-darwin
 
-// This is a regression test for https://github.com/rust-lang/rust/issues/140686.
-// Although this is a ld64(ld-classic) bug, we still need to support it
-// due to cross-compilation and support for older Xcode.
-
 fn main() {
     let dst: Vec<u8> = Vec::new();
     let len = broken_func(std::hint::black_box(2), dst);
diff --git a/tests/ui/shadowed/shadowing-generic-item.rs b/tests/ui/shadowed/shadowing-generic-item.rs
index 46cfdf1efa8..c3a0ced04e7 100644
--- a/tests/ui/shadowed/shadowing-generic-item.rs
+++ b/tests/ui/shadowed/shadowing-generic-item.rs
@@ -1,3 +1,5 @@
+//! Test that generic parameters shadow structs and modules with the same name.
+
 struct T { i: i32 }
 fn f<T>() {
     let t = T { i: 0 }; //~ ERROR expected struct, variant or union type, found type parameter `T`
diff --git a/tests/ui/shadowed/shadowing-generic-item.stderr b/tests/ui/shadowed/shadowing-generic-item.stderr
index f0eaa1a5c64..55a0bb36ea8 100644
--- a/tests/ui/shadowed/shadowing-generic-item.stderr
+++ b/tests/ui/shadowed/shadowing-generic-item.stderr
@@ -1,5 +1,5 @@
 error[E0574]: expected struct, variant or union type, found type parameter `T`
-  --> $DIR/lexical-scopes.rs:3:13
+  --> $DIR/shadowing-generic-item.rs:5:13
    |
 LL | struct T { i: i32 }
    |        - you might have meant to refer to this struct
@@ -9,7 +9,7 @@ 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
-  --> $DIR/lexical-scopes.rs:10:10
+  --> $DIR/shadowing-generic-item.rs:12:10
    |
 LL | fn g<Foo>() {
    |      --- function or associated item `f` not found for this type parameter
diff --git a/tests/ui/symbol-names/struct-constructor-mangling.rs b/tests/ui/symbol-names/struct-constructor-mangling.rs
index f32cbb7aaae..ec8791e2154 100644
--- a/tests/ui/symbol-names/struct-constructor-mangling.rs
+++ b/tests/ui/symbol-names/struct-constructor-mangling.rs
@@ -1,3 +1,5 @@
+//! Test that the symbol mangling of Foo-the-constructor-function versus Foo-the-type do not collide
+
 //@ run-pass
 
 fn size_of_val<T>(_: &T) -> usize {
@@ -6,8 +8,6 @@ fn size_of_val<T>(_: &T) -> usize {
 
 struct Foo(#[allow(dead_code)] i64);
 
-// Test that the (symbol) mangling of `Foo` (the `struct` type) and that of
-// `typeof Foo` (the function type of the `struct` constructor) don't collide.
 fn main() {
     size_of_val(&Foo(0));
     size_of_val(&Foo);
-- 
cgit 1.4.1-3-g733a5


From f2048019718409885ac57c480f010bdfbfe5bfd0 Mon Sep 17 00:00:00 2001
From: codedump <lichuang1982@gmail.com>
Date: Wed, 16 Jul 2025 23:21:47 +0800
Subject: fix: fix issue 143740, Wrong messages from compiler confusing methods
 with the same name from different traits

---
 compiler/rustc_hir_typeck/src/method/probe.rs      |  3 +-
 .../call_method_without_import.no_import.stderr    |  7 +----
 .../impl-trait/no-method-suggested-traits.stderr   |  8 -----
 ...o-same-trait-object-with-separate-params.stderr | 16 ++--------
 tests/ui/methods/wrong-ambig-message.rs            | 34 ++++++++++++++++++++++
 tests/ui/methods/wrong-ambig-message.stderr        | 30 +++++++++++++++++++
 6 files changed, 70 insertions(+), 28 deletions(-)
 create mode 100644 tests/ui/methods/wrong-ambig-message.rs
 create mode 100644 tests/ui/methods/wrong-ambig-message.stderr

diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index 94c93e73627..d5ac17bd785 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -1649,7 +1649,8 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 }
             }
 
-            let sources = candidates.iter().map(|p| self.candidate_source(p, self_ty)).collect();
+            let sources =
+                applicable_candidates.iter().map(|p| self.candidate_source(p.0, self_ty)).collect();
             return Some(Err(MethodError::Ambiguity(sources)));
         }
 
diff --git a/tests/ui/impl-trait/call_method_without_import.no_import.stderr b/tests/ui/impl-trait/call_method_without_import.no_import.stderr
index e59409ea27e..dbac74b2247 100644
--- a/tests/ui/impl-trait/call_method_without_import.no_import.stderr
+++ b/tests/ui/impl-trait/call_method_without_import.no_import.stderr
@@ -22,15 +22,10 @@ LL |         x.fmt(f);
    = help: items from traits can only be used if the trait is in scope
 help: the following traits which provide `fmt` are implemented but not in scope; perhaps you want to import one of them
    |
-LL + use std::fmt::Binary;
-   |
 LL + use std::fmt::Debug;
    |
-LL + use std::fmt::Display;
-   |
-LL + use std::fmt::LowerExp;
+LL + use std::fmt::Pointer;
    |
-   = and 5 other candidates
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/impl-trait/no-method-suggested-traits.stderr b/tests/ui/impl-trait/no-method-suggested-traits.stderr
index 061c9bd8f35..b376f205411 100644
--- a/tests/ui/impl-trait/no-method-suggested-traits.stderr
+++ b/tests/ui/impl-trait/no-method-suggested-traits.stderr
@@ -9,12 +9,8 @@ help: the following traits which provide `method` are implemented but not in sco
    |
 LL + use foo::Bar;
    |
-LL + use no_method_suggested_traits::Reexported;
-   |
 LL + use no_method_suggested_traits::foo::PubPub;
    |
-LL + use no_method_suggested_traits::qux::PrivPub;
-   |
 help: there is a method `method2` with a similar name
    |
 LL |     1u32.method2();
@@ -31,12 +27,8 @@ help: the following traits which provide `method` are implemented but not in sco
    |
 LL + use foo::Bar;
    |
-LL + use no_method_suggested_traits::Reexported;
-   |
 LL + use no_method_suggested_traits::foo::PubPub;
    |
-LL + use no_method_suggested_traits::qux::PrivPub;
-   |
 help: there is a method `method2` with a similar name
    |
 LL |     std::rc::Rc::new(&mut Box::new(&1u32)).method2();
diff --git a/tests/ui/methods/method-deref-to-same-trait-object-with-separate-params.stderr b/tests/ui/methods/method-deref-to-same-trait-object-with-separate-params.stderr
index 32cff62284e..aeecb82e9d9 100644
--- a/tests/ui/methods/method-deref-to-same-trait-object-with-separate-params.stderr
+++ b/tests/ui/methods/method-deref-to-same-trait-object-with-separate-params.stderr
@@ -20,17 +20,12 @@ error[E0034]: multiple applicable items in scope
 LL |     let z = x.foo();
    |               ^^^ multiple `foo` found
    |
-note: candidate #1 is defined in the trait `FinalFoo`
-  --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:60:5
-   |
-LL |     fn foo(&self) -> u8;
-   |     ^^^^^^^^^^^^^^^^^^^^
-note: candidate #2 is defined in an impl of the trait `NuisanceFoo` for the type `T`
+note: candidate #1 is defined in an impl of the trait `NuisanceFoo` for the type `T`
   --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:73:9
    |
 LL |         fn foo(self) {}
    |         ^^^^^^^^^^^^
-note: candidate #3 is defined in an impl of the trait `X` for the type `T`
+note: candidate #2 is defined in an impl of the trait `X` for the type `T`
   --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:46:9
    |
 LL |         fn foo(self: Smaht<Self, u64>) -> u64 {
@@ -38,14 +33,9 @@ LL |         fn foo(self: Smaht<Self, u64>) -> u64 {
 help: disambiguate the method for candidate #1
    |
 LL -     let z = x.foo();
-LL +     let z = FinalFoo::foo(&x);
-   |
-help: disambiguate the method for candidate #2
-   |
-LL -     let z = x.foo();
 LL +     let z = NuisanceFoo::foo(x);
    |
-help: disambiguate the method for candidate #3
+help: disambiguate the method for candidate #2
    |
 LL -     let z = x.foo();
 LL +     let z = X::foo(x);
diff --git a/tests/ui/methods/wrong-ambig-message.rs b/tests/ui/methods/wrong-ambig-message.rs
new file mode 100644
index 00000000000..f88d77e259d
--- /dev/null
+++ b/tests/ui/methods/wrong-ambig-message.rs
@@ -0,0 +1,34 @@
+fn main() {
+    trait Hello {
+        fn name(&self) -> String;
+    }
+
+    #[derive(Debug)]
+    struct Container2 {
+        val: String,
+    }
+
+    trait AName2 {
+        fn name(&self) -> String;
+    }
+
+    trait BName2 {
+        fn name(&self, v: bool) -> String;
+    }
+
+    impl AName2 for Container2 {
+        fn name(&self) -> String {
+            "aname2".into()
+        }
+    }
+
+    impl BName2 for Container2 {
+        fn name(&self, _v: bool) -> String {
+            "bname2".into()
+        }
+    }
+
+    let c2 = Container2 { val: "abc".into() };
+    println!("c2 = {:?}", c2.name());
+    //~^ ERROR: multiple applicable items in scope
+}
diff --git a/tests/ui/methods/wrong-ambig-message.stderr b/tests/ui/methods/wrong-ambig-message.stderr
new file mode 100644
index 00000000000..9a254595e40
--- /dev/null
+++ b/tests/ui/methods/wrong-ambig-message.stderr
@@ -0,0 +1,30 @@
+error[E0034]: multiple applicable items in scope
+  --> $DIR/wrong-ambig-message.rs:32:30
+   |
+LL |     println!("c2 = {:?}", c2.name());
+   |                              ^^^^ multiple `name` found
+   |
+note: candidate #1 is defined in an impl of the trait `AName2` for the type `Container2`
+  --> $DIR/wrong-ambig-message.rs:20:9
+   |
+LL |         fn name(&self) -> String {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl of the trait `BName2` for the type `Container2`
+  --> $DIR/wrong-ambig-message.rs:26:9
+   |
+LL |         fn name(&self, _v: bool) -> String {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: disambiguate the method for candidate #1
+   |
+LL -     println!("c2 = {:?}", c2.name());
+LL +     println!("c2 = {:?}", AName2::name(&c2));
+   |
+help: disambiguate the method for candidate #2
+   |
+LL -     println!("c2 = {:?}", c2.name());
+LL +     println!("c2 = {:?}", BName2::name(&c2));
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0034`.
-- 
cgit 1.4.1-3-g733a5


From 16d8f3c895c8278a6519b6015b6e9d9a5a1fd311 Mon Sep 17 00:00:00 2001
From: dianqk <dianqk@dianqk.net>
Date: Thu, 17 Jul 2025 19:53:13 +0800
Subject: Update LLVM submodule

---
 src/llvm-project | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm-project b/src/llvm-project
index d3c793b0256..e8a2ffcf322 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit d3c793b025645a4565ac59aceb30d2d116ff1a41
+Subproject commit e8a2ffcf322f45b8dce82c65ab27a3e2430a6b51
-- 
cgit 1.4.1-3-g733a5


From a886852e23fad1be91648871b0240805fd52c13c Mon Sep 17 00:00:00 2001
From: MarcoIeni <11428655+MarcoIeni@users.noreply.github.com>
Date: Thu, 17 Jul 2025 14:54:14 +0200
Subject: ci: use windows 22 for all free runners

---
 src/ci/github-actions/jobs.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 6c5e37b51ef..f0c52fe3d1c 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -34,6 +34,8 @@ runners:
     os: windows-2022
     <<: *base-job
 
+  # NOTE: windows-2025 has less disk space available than windows-2022,
+  # because the D drive is missing.
   - &job-windows-25
     os: windows-2025
     <<: *base-job
@@ -542,13 +544,13 @@ auto:
     env:
       RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-sanitizers --enable-profiler
       SCRIPT: make ci-msvc-py
-    <<: *job-windows-25
+    <<: *job-windows
 
   - name: x86_64-msvc-2
     env:
       RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-sanitizers --enable-profiler
       SCRIPT: make ci-msvc-ps1
-    <<: *job-windows-25
+    <<: *job-windows
 
   # i686-msvc is split into two jobs to run tests in parallel.
   - name: i686-msvc-1
-- 
cgit 1.4.1-3-g733a5


From 998df3a3e851908afd05c3318f16d99849af5c55 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Tue, 15 Jul 2025 23:42:35 +0300
Subject: resolve: Make disambiguators for underscore bindings module-local

---
 compiler/rustc_resolve/src/build_reduced_graph.rs | 30 ++++++++++--------
 compiler/rustc_resolve/src/imports.rs             | 38 +++++++++++++++--------
 compiler/rustc_resolve/src/lib.rs                 | 33 +++++++++-----------
 compiler/rustc_resolve/src/macros.rs              |  2 +-
 4 files changed, 58 insertions(+), 45 deletions(-)

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index 5a1be618cee..9a5c18247e7 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -49,8 +49,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         ns: Namespace,
         binding: NameBinding<'ra>,
     ) {
-        let key = self.new_disambiguated_key(ident, ns);
-        if let Err(old_binding) = self.try_define(parent, key, binding, false) {
+        if let Err(old_binding) = self.try_define(parent, ident, ns, binding, false) {
             self.report_conflict(parent, ident, ns, old_binding, binding);
         }
     }
@@ -439,16 +438,18 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
 
         self.r.indeterminate_imports.push(import);
         match import.kind {
-            // Don't add unresolved underscore imports to modules
-            ImportKind::Single { target: Ident { name: kw::Underscore, .. }, .. } => {}
             ImportKind::Single { target, type_ns_only, .. } => {
-                self.r.per_ns(|this, ns| {
-                    if !type_ns_only || ns == TypeNS {
-                        let key = BindingKey::new(target, ns);
-                        let mut resolution = this.resolution(current_module, key).borrow_mut();
-                        resolution.single_imports.insert(import);
-                    }
-                });
+                // Don't add underscore imports to `single_imports`
+                // because they cannot define any usable names.
+                if target.name != kw::Underscore {
+                    self.r.per_ns(|this, ns| {
+                        if !type_ns_only || ns == TypeNS {
+                            let key = BindingKey::new(target, ns);
+                            let mut resolution = this.resolution(current_module, key).borrow_mut();
+                            resolution.single_imports.insert(import);
+                        }
+                    });
+                }
             }
             // We don't add prelude imports to the globs since they only affect lexical scopes,
             // which are not relevant to import resolution.
@@ -1402,9 +1403,12 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             let parent = self.parent_scope.module;
             let expansion = self.parent_scope.expansion;
             self.r.define(parent, ident, ns, self.res(def_id), vis, item.span, expansion);
-        } else if !matches!(&item.kind, AssocItemKind::Delegation(deleg) if deleg.from_glob) {
+        } else if !matches!(&item.kind, AssocItemKind::Delegation(deleg) if deleg.from_glob)
+            && ident.name != kw::Underscore
+        {
+            // Don't add underscore names, they cannot be looked up anyway.
             let impl_def_id = self.r.tcx.local_parent(local_def_id);
-            let key = BindingKey::new(ident.normalize_to_macros_2_0(), ns);
+            let key = BindingKey::new(ident, ns);
             self.r.impl_binding_keys.entry(impl_def_id).or_default().insert(key);
         }
 
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index c3e39d2071b..888322c0fd6 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -25,7 +25,7 @@ use rustc_span::{Ident, Span, Symbol, kw, sym};
 use smallvec::SmallVec;
 use tracing::debug;
 
-use crate::Namespace::*;
+use crate::Namespace::{self, *};
 use crate::diagnostics::{DiagMode, Suggestion, import_candidates};
 use crate::errors::{
     CannotBeReexportedCratePublic, CannotBeReexportedCratePublicNS, CannotBeReexportedPrivate,
@@ -338,13 +338,20 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     pub(crate) fn try_define(
         &mut self,
         module: Module<'ra>,
-        key: BindingKey,
+        ident: Ident,
+        ns: Namespace,
         binding: NameBinding<'ra>,
         warn_ambiguity: bool,
     ) -> Result<(), NameBinding<'ra>> {
         let res = binding.res();
-        self.check_reserved_macro_name(key.ident, res);
+        self.check_reserved_macro_name(ident, res);
         self.set_binding_parent_module(binding, module);
+        // Even if underscore names cannot be looked up, we still need to add them to modules,
+        // because they can be fetched by glob imports from those modules, and bring traits
+        // into scope both directly and through glob imports.
+        let key = BindingKey::new_disambiguated(ident, ns, || {
+            (module.0.0.lazy_resolutions.borrow().len() + 1).try_into().unwrap()
+        });
         self.update_resolution(module, key, warn_ambiguity, |this, resolution| {
             if let Some(old_binding) = resolution.best_binding() {
                 if res == Res::Err && old_binding.res() != Res::Err {
@@ -383,7 +390,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     (old_glob @ true, false) | (old_glob @ false, true) => {
                         let (glob_binding, non_glob_binding) =
                             if old_glob { (old_binding, binding) } else { (binding, old_binding) };
-                        if key.ns == MacroNS
+                        if ns == MacroNS
                             && non_glob_binding.expansion != LocalExpnId::ROOT
                             && glob_binding.res() != non_glob_binding.res()
                         {
@@ -489,10 +496,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             };
             if self.is_accessible_from(binding.vis, scope) {
                 let imported_binding = self.import(binding, *import);
-                let key = BindingKey { ident, ..key };
                 let _ = self.try_define(
                     import.parent_scope.module,
-                    key,
+                    ident,
+                    key.ns,
                     imported_binding,
                     warn_ambiguity,
                 );
@@ -514,11 +521,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let dummy_binding = self.dummy_binding;
             let dummy_binding = self.import(dummy_binding, import);
             self.per_ns(|this, ns| {
-                let key = BindingKey::new(target, ns);
-                let _ = this.try_define(import.parent_scope.module, key, dummy_binding, false);
-                this.update_resolution(import.parent_scope.module, key, false, |_, resolution| {
-                    resolution.single_imports.swap_remove(&import);
-                })
+                let module = import.parent_scope.module;
+                let _ = this.try_define(module, target, ns, dummy_binding, false);
+                // Don't remove underscores from `single_imports`, they were never added.
+                if target.name != kw::Underscore {
+                    let key = BindingKey::new(target, ns);
+                    this.update_resolution(module, key, false, |_, resolution| {
+                        resolution.single_imports.swap_remove(&import);
+                    })
+                }
             });
             self.record_use(target, dummy_binding, Used::Other);
         } else if import.imported_module.get().is_none() {
@@ -895,7 +906,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         PendingBinding::Ready(Some(imported_binding))
                     }
                     Err(Determinacy::Determined) => {
-                        // Don't update the resolution for underscores, because it was never added.
+                        // Don't remove underscores from `single_imports`, they were never added.
                         if target.name != kw::Underscore {
                             let key = BindingKey::new(target, ns);
                             this.update_resolution(parent, key, false, |_, resolution| {
@@ -1510,7 +1521,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     .is_some_and(|binding| binding.warn_ambiguity_recursive());
                 let _ = self.try_define(
                     import.parent_scope.module,
-                    key,
+                    key.ident,
+                    key.ns,
                     imported_binding,
                     warn_ambiguity,
                 );
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index f904f326296..81907881f44 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -532,15 +532,26 @@ struct BindingKey {
     /// identifier.
     ident: Ident,
     ns: Namespace,
-    /// 0 if ident is not `_`, otherwise a value that's unique to the specific
-    /// `_` in the expanded AST that introduced this binding.
+    /// When we add an underscore binding (with ident `_`) to some module, this field has
+    /// a non-zero value that uniquely identifies this binding in that module.
+    /// For non-underscore bindings this field is zero.
+    /// When a key is constructed for name lookup (as opposed to name definition), this field is
+    /// also zero, even for underscore names, so for underscores the lookup will never succeed.
     disambiguator: u32,
 }
 
 impl BindingKey {
     fn new(ident: Ident, ns: Namespace) -> Self {
-        let ident = ident.normalize_to_macros_2_0();
-        BindingKey { ident, ns, disambiguator: 0 }
+        BindingKey { ident: ident.normalize_to_macros_2_0(), ns, disambiguator: 0 }
+    }
+
+    fn new_disambiguated(
+        ident: Ident,
+        ns: Namespace,
+        disambiguator: impl FnOnce() -> u32,
+    ) -> BindingKey {
+        let disambiguator = if ident.name == kw::Underscore { disambiguator() } else { 0 };
+        BindingKey { ident: ident.normalize_to_macros_2_0(), ns, disambiguator }
     }
 }
 
@@ -1078,8 +1089,6 @@ pub struct Resolver<'ra, 'tcx> {
     module_map: FxIndexMap<DefId, Module<'ra>>,
     binding_parent_modules: FxHashMap<NameBinding<'ra>, Module<'ra>>,
 
-    underscore_disambiguator: u32,
-
     /// Maps glob imports to the names of items actually imported.
     glob_map: FxIndexMap<LocalDefId, FxIndexSet<Symbol>>,
     glob_error: Option<ErrorGuaranteed>,
@@ -1500,7 +1509,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             extern_crate_map: Default::default(),
             module_children: Default::default(),
             trait_map: NodeMap::default(),
-            underscore_disambiguator: 0,
             empty_module,
             module_map,
             block_map: Default::default(),
@@ -1880,17 +1888,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         import_ids
     }
 
-    fn new_disambiguated_key(&mut self, ident: Ident, ns: Namespace) -> BindingKey {
-        let ident = ident.normalize_to_macros_2_0();
-        let disambiguator = if ident.name == kw::Underscore {
-            self.underscore_disambiguator += 1;
-            self.underscore_disambiguator
-        } else {
-            0
-        };
-        BindingKey { ident, ns, disambiguator }
-    }
-
     fn resolutions(&mut self, module: Module<'ra>) -> &'ra Resolutions<'ra> {
         if module.populate_on_access.get() {
             module.populate_on_access.set(false);
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index c17d74659db..2b5632805b6 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -530,7 +530,7 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
         target_trait.for_each_child(self, |this, ident, ns, _binding| {
             // FIXME: Adjust hygiene for idents from globs, like for glob imports.
             if let Some(overriding_keys) = this.impl_binding_keys.get(&impl_def_id)
-                && overriding_keys.contains(&BindingKey::new(ident.normalize_to_macros_2_0(), ns))
+                && overriding_keys.contains(&BindingKey::new(ident, ns))
             {
                 // The name is overridden, do not produce it from the glob delegation.
             } else {
-- 
cgit 1.4.1-3-g733a5


From 0a71873c34d38978121853f0d97358427bd54038 Mon Sep 17 00:00:00 2001
From: Erick Tryzelaar <etryzelaar@google.com>
Date: Thu, 17 Jul 2025 14:12:03 +0000
Subject: panic_main.rs panic=unwind tests needs unwinding

Only run the panic=unwind tests on platforms that support unwinding.
---
 tests/ui/panics/panic-main.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/ui/panics/panic-main.rs b/tests/ui/panics/panic-main.rs
index bf79de78a57..2395f68241f 100644
--- a/tests/ui/panics/panic-main.rs
+++ b/tests/ui/panics/panic-main.rs
@@ -14,12 +14,15 @@
 
 //@[unwind-zero] compile-flags: -Cpanic=unwind
 //@[unwind-zero] exec-env:RUST_BACKTRACE=0
+//@[unwind-zero] needs-unwind
 
 //@[unwind-one] compile-flags: -Cpanic=unwind
 //@[unwind-one] exec-env:RUST_BACKTRACE=1
+//@[unwind-one] needs-unwind
 
 //@[unwind-full] compile-flags: -Cpanic=unwind
 //@[unwind-full] exec-env:RUST_BACKTRACE=full
+//@[unwind-full] needs-unwind
 
 //@ run-fail
 //@ error-pattern:moop
-- 
cgit 1.4.1-3-g733a5


From 2f5722cf1bdd4ffcdf46e85ffbd97455aaeec7de Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Fri, 11 Jul 2025 10:21:29 +0000
Subject: Make `Option` `const PartialEq`

---
 library/core/src/option.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 9f432758a66..da6e311ff5e 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -2243,7 +2243,8 @@ impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> crate::marker::StructuralPartialEq for Option<T> {}
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialEq> PartialEq for Option<T> {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T: ~const PartialEq> const PartialEq for Option<T> {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
         // Spelling out the cases explicitly optimizes better than
-- 
cgit 1.4.1-3-g733a5


From 9d29583355018f00d65b9d5e08758e3f9bcba97c Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Fri, 11 Jul 2025 10:34:29 +0000
Subject: Make `NonZero` `const PartialEq`

---
 library/core/src/num/nonzero.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/library/core/src/num/nonzero.rs b/library/core/src/num/nonzero.rs
index 11d50e0f89f..b8900c4113a 100644
--- a/library/core/src/num/nonzero.rs
+++ b/library/core/src/num/nonzero.rs
@@ -200,9 +200,10 @@ impl<T> UseCloned for NonZero<T> where T: ZeroablePrimitive {}
 impl<T> Copy for NonZero<T> where T: ZeroablePrimitive {}
 
 #[stable(feature = "nonzero", since = "1.28.0")]
-impl<T> PartialEq for NonZero<T>
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T> const PartialEq for NonZero<T>
 where
-    T: ZeroablePrimitive + PartialEq,
+    T: ZeroablePrimitive + ~const PartialEq,
 {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
-- 
cgit 1.4.1-3-g733a5


From 250648e871c1e685f09427bd31fd399090f15640 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Fri, 11 Jul 2025 10:20:25 +0000
Subject: Make `derive_const` usable within libcore again

Also make it *only* usable on nightly
---
 .../rustc_builtin_macros/src/deriving/bounds.rs    |  4 ++
 .../rustc_builtin_macros/src/deriving/clone.rs     |  1 +
 .../rustc_builtin_macros/src/deriving/cmp/eq.rs    |  1 +
 .../rustc_builtin_macros/src/deriving/cmp/ord.rs   |  1 +
 .../src/deriving/cmp/partial_eq.rs                 |  2 +
 .../src/deriving/cmp/partial_ord.rs                |  1 +
 .../rustc_builtin_macros/src/deriving/debug.rs     |  1 +
 .../rustc_builtin_macros/src/deriving/default.rs   |  1 +
 .../src/deriving/generic/mod.rs                    | 47 ++++++++++++++++++++--
 compiler/rustc_builtin_macros/src/deriving/hash.rs |  1 +
 compiler/rustc_expand/src/build.rs                 | 10 ++++-
 compiler/rustc_span/src/symbol.rs                  |  1 +
 library/core/src/macros/mod.rs                     |  2 +-
 library/core/src/prelude/v1.rs                     |  2 +-
 library/std/src/prelude/v1.rs                      |  2 +-
 tests/ui/consts/const-eval/auxiliary/stability.rs  |  9 +++--
 .../const_derives/derive-const-gate.stderr         |  1 +
 17 files changed, 75 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/deriving/bounds.rs b/compiler/rustc_builtin_macros/src/deriving/bounds.rs
index a98e9c6d1c7..dd8f0e46a0e 100644
--- a/compiler/rustc_builtin_macros/src/deriving/bounds.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/bounds.rs
@@ -23,6 +23,7 @@ pub(crate) fn expand_deriving_copy(
         methods: Vec::new(),
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
 
     trait_def.expand(cx, mitem, item, push);
@@ -46,6 +47,7 @@ pub(crate) fn expand_deriving_const_param_ty(
         methods: Vec::new(),
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
 
     trait_def.expand(cx, mitem, item, push);
@@ -60,6 +62,7 @@ pub(crate) fn expand_deriving_const_param_ty(
         methods: Vec::new(),
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
 
     trait_def.expand(cx, mitem, item, push);
@@ -83,6 +86,7 @@ pub(crate) fn expand_deriving_unsized_const_param_ty(
         methods: Vec::new(),
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
 
     trait_def.expand(cx, mitem, item, push);
diff --git a/compiler/rustc_builtin_macros/src/deriving/clone.rs b/compiler/rustc_builtin_macros/src/deriving/clone.rs
index 69f8c273797..3c78f53c5cb 100644
--- a/compiler/rustc_builtin_macros/src/deriving/clone.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/clone.rs
@@ -87,6 +87,7 @@ pub(crate) fn expand_deriving_clone(
         }],
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
 
     trait_def.expand_ext(cx, mitem, item, push, is_simple)
diff --git a/compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs b/compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs
index eca79e4dc48..29d531219a6 100644
--- a/compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs
@@ -43,6 +43,7 @@ pub(crate) fn expand_deriving_eq(
         }],
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
     trait_def.expand_ext(cx, mitem, item, push, true)
 }
diff --git a/compiler/rustc_builtin_macros/src/deriving/cmp/ord.rs b/compiler/rustc_builtin_macros/src/deriving/cmp/ord.rs
index 1ed44c20bc6..0e1ecf3118a 100644
--- a/compiler/rustc_builtin_macros/src/deriving/cmp/ord.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/cmp/ord.rs
@@ -34,6 +34,7 @@ pub(crate) fn expand_deriving_ord(
         }],
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
 
     trait_def.expand(cx, mitem, item, push)
diff --git a/compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs b/compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs
index b1d950b8d89..990835fa277 100644
--- a/compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs
@@ -30,6 +30,7 @@ pub(crate) fn expand_deriving_partial_eq(
         methods: Vec::new(),
         associated_types: Vec::new(),
         is_const: false,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
     structural_trait_def.expand(cx, mitem, item, push);
 
@@ -58,6 +59,7 @@ pub(crate) fn expand_deriving_partial_eq(
         methods,
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
     trait_def.expand(cx, mitem, item, push)
 }
diff --git a/compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs b/compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs
index 0a076dd670b..f5d262ece36 100644
--- a/compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs
@@ -64,6 +64,7 @@ pub(crate) fn expand_deriving_partial_ord(
         methods: vec![partial_cmp_def],
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
     trait_def.expand(cx, mitem, item, push)
 }
diff --git a/compiler/rustc_builtin_macros/src/deriving/debug.rs b/compiler/rustc_builtin_macros/src/deriving/debug.rs
index 8ab21986e68..1d63ce7d5fd 100644
--- a/compiler/rustc_builtin_macros/src/deriving/debug.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/debug.rs
@@ -41,6 +41,7 @@ pub(crate) fn expand_deriving_debug(
         }],
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
     trait_def.expand(cx, mitem, item, push)
 }
diff --git a/compiler/rustc_builtin_macros/src/deriving/default.rs b/compiler/rustc_builtin_macros/src/deriving/default.rs
index 1fe567e23f4..b4e2d27fed3 100644
--- a/compiler/rustc_builtin_macros/src/deriving/default.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/default.rs
@@ -51,6 +51,7 @@ pub(crate) fn expand_deriving_default(
         }],
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
     trait_def.expand(cx, mitem, item, push)
 }
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
index c55a9e73e38..b24e5563761 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -181,9 +181,11 @@ use std::{iter, vec};
 pub(crate) use StaticFields::*;
 pub(crate) use SubstructureFields::*;
 use rustc_ast::ptr::P;
+use rustc_ast::token::{IdentIsRaw, LitKind, Token, TokenKind};
+use rustc_ast::tokenstream::{DelimSpan, Spacing, TokenTree};
 use rustc_ast::{
-    self as ast, AnonConst, BindingMode, ByRef, EnumDef, Expr, GenericArg, GenericParamKind,
-    Generics, Mutability, PatKind, VariantData,
+    self as ast, AnonConst, AttrArgs, BindingMode, ByRef, DelimArgs, EnumDef, Expr, GenericArg,
+    GenericParamKind, Generics, Mutability, PatKind, Safety, VariantData,
 };
 use rustc_attr_data_structures::{AttributeKind, ReprPacked};
 use rustc_attr_parsing::AttributeParser;
@@ -222,6 +224,8 @@ pub(crate) struct TraitDef<'a> {
     pub associated_types: Vec<(Ident, Ty)>,
 
     pub is_const: bool,
+
+    pub is_staged_api_crate: bool,
 }
 
 pub(crate) struct MethodDef<'a> {
@@ -784,8 +788,45 @@ impl<'a> TraitDef<'a> {
         // Create the type of `self`.
         let path = cx.path_all(self.span, false, vec![type_ident], self_params);
         let self_type = cx.ty_path(path);
+        let rustc_const_unstable =
+            cx.path_ident(self.span, Ident::new(sym::rustc_const_unstable, self.span));
+
+        let mut attrs = thin_vec![cx.attr_word(sym::automatically_derived, self.span),];
+
+        // Only add `rustc_const_unstable` attributes if `derive_const` is used within libcore/libstd,
+        // Other crates don't need stability attributes, so adding them is not useful, but libcore needs them
+        // on all const trait impls.
+        if self.is_const && self.is_staged_api_crate {
+            attrs.push(
+                cx.attr_nested(
+                    rustc_ast::AttrItem {
+                        unsafety: Safety::Default,
+                        path: rustc_const_unstable,
+                        args: AttrArgs::Delimited(DelimArgs {
+                            dspan: DelimSpan::from_single(self.span),
+                            delim: rustc_ast::token::Delimiter::Parenthesis,
+                            tokens: [
+                                TokenKind::Ident(sym::feature, IdentIsRaw::No),
+                                TokenKind::Eq,
+                                TokenKind::lit(LitKind::Str, sym::derive_const, None),
+                                TokenKind::Comma,
+                                TokenKind::Ident(sym::issue, IdentIsRaw::No),
+                                TokenKind::Eq,
+                                TokenKind::lit(LitKind::Str, sym::derive_const_issue, None),
+                            ]
+                            .into_iter()
+                            .map(|kind| {
+                                TokenTree::Token(Token { kind, span: self.span }, Spacing::Alone)
+                            })
+                            .collect(),
+                        }),
+                        tokens: None,
+                    },
+                    self.span,
+                ),
+            )
+        }
 
-        let attrs = thin_vec![cx.attr_word(sym::automatically_derived, self.span),];
         let opt_trait_ref = Some(trait_ref);
 
         cx.item(
diff --git a/compiler/rustc_builtin_macros/src/deriving/hash.rs b/compiler/rustc_builtin_macros/src/deriving/hash.rs
index 6e6dbe19e4d..78534449895 100644
--- a/compiler/rustc_builtin_macros/src/deriving/hash.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/hash.rs
@@ -41,6 +41,7 @@ pub(crate) fn expand_deriving_hash(
         }],
         associated_types: Vec::new(),
         is_const,
+        is_staged_api_crate: cx.ecfg.features.staged_api(),
     };
 
     hash_trait_def.expand(cx, mitem, item, push);
diff --git a/compiler/rustc_expand/src/build.rs b/compiler/rustc_expand/src/build.rs
index 85683c1a03f..51d6e43ab67 100644
--- a/compiler/rustc_expand/src/build.rs
+++ b/compiler/rustc_expand/src/build.rs
@@ -3,8 +3,8 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::util::literal;
 use rustc_ast::{
-    self as ast, AnonConst, AttrVec, BlockCheckMode, Expr, LocalKind, MatchKind, PatKind, UnOp,
-    attr, token, tokenstream,
+    self as ast, AnonConst, AttrItem, AttrVec, BlockCheckMode, Expr, LocalKind, MatchKind, PatKind,
+    UnOp, attr, token, tokenstream,
 };
 use rustc_span::source_map::Spanned;
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
@@ -766,4 +766,10 @@ impl<'a> ExtCtxt<'a> {
             span,
         )
     }
+
+    // Builds an attribute fully manually.
+    pub fn attr_nested(&self, inner: AttrItem, span: Span) -> ast::Attribute {
+        let g = &self.sess.psess.attr_id_generator;
+        attr::mk_attr_from_item(g, inner, None, ast::AttrStyle::Outer, span)
+    }
 }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index bd34055f851..769ac4f7f22 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -839,6 +839,7 @@ symbols! {
         derive,
         derive_coerce_pointee,
         derive_const,
+        derive_const_issue: "118304",
         derive_default_enum,
         derive_smart_pointer,
         destruct,
diff --git a/library/core/src/macros/mod.rs b/library/core/src/macros/mod.rs
index 1b6dbc2f428..8ac6ce2242d 100644
--- a/library/core/src/macros/mod.rs
+++ b/library/core/src/macros/mod.rs
@@ -1615,7 +1615,7 @@ pub(crate) mod builtin {
     /// See [the reference] for more info.
     ///
     /// [the reference]: ../../../reference/attributes/derive.html
-    #[unstable(feature = "derive_const", issue = "none")]
+    #[unstable(feature = "derive_const", issue = "118304")]
     #[rustc_builtin_macro]
     pub macro derive_const($item:item) {
         /* compiler built-in */
diff --git a/library/core/src/prelude/v1.rs b/library/core/src/prelude/v1.rs
index 7b9e04920d5..a4be66b90ca 100644
--- a/library/core/src/prelude/v1.rs
+++ b/library/core/src/prelude/v1.rs
@@ -80,7 +80,7 @@ pub use crate::macros::builtin::{
     alloc_error_handler, bench, derive, global_allocator, test, test_case,
 };
 
-#[unstable(feature = "derive_const", issue = "none")]
+#[unstable(feature = "derive_const", issue = "118304")]
 pub use crate::macros::builtin::derive_const;
 
 #[unstable(
diff --git a/library/std/src/prelude/v1.rs b/library/std/src/prelude/v1.rs
index 69f03353153..70c11131556 100644
--- a/library/std/src/prelude/v1.rs
+++ b/library/std/src/prelude/v1.rs
@@ -67,7 +67,7 @@ pub use core::prelude::v1::{
     alloc_error_handler, bench, derive, global_allocator, test, test_case,
 };
 
-#[unstable(feature = "derive_const", issue = "none")]
+#[unstable(feature = "derive_const", issue = "118304")]
 pub use core::prelude::v1::derive_const;
 
 // Do not `doc(no_inline)` either.
diff --git a/tests/ui/consts/const-eval/auxiliary/stability.rs b/tests/ui/consts/const-eval/auxiliary/stability.rs
index e6159551860..48ced3bc51e 100644
--- a/tests/ui/consts/const-eval/auxiliary/stability.rs
+++ b/tests/ui/consts/const-eval/auxiliary/stability.rs
@@ -1,10 +1,11 @@
 // Crate that exports a const fn. Used for testing cross-crate.
 
-#![crate_type="rlib"]
+#![crate_type = "rlib"]
 #![stable(feature = "rust1", since = "1.0.0")]
-
 #![feature(staged_api)]
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature="foo", issue = "none")]
-pub const fn foo() -> u32 { 42 }
+#[rustc_const_unstable(feature = "foo", issue = "none")]
+pub const fn foo() -> u32 {
+    42
+}
diff --git a/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr b/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr
index 5bde358001c..f5d90544411 100644
--- a/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr
+++ b/tests/ui/traits/const-traits/const_derives/derive-const-gate.stderr
@@ -4,6 +4,7 @@ error[E0658]: use of unstable library feature `derive_const`
 LL | #[derive_const(Debug)]
    |   ^^^^^^^^^^^^
    |
+   = note: see issue #118304 <https://github.com/rust-lang/rust/issues/118304> for more information
    = help: add `#![feature(derive_const)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-- 
cgit 1.4.1-3-g733a5


From 10762d5001f6abe686b14bffb83e618ec8fa2bb6 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Thu, 17 Jul 2025 16:17:40 +0000
Subject: Fix debuginfo-lto-alloc.rs test

This should have used build-pass rather than check-pass.
---
 tests/ui/lto/debuginfo-lto-alloc.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/ui/lto/debuginfo-lto-alloc.rs b/tests/ui/lto/debuginfo-lto-alloc.rs
index 89043275329..d6855f8760d 100644
--- a/tests/ui/lto/debuginfo-lto-alloc.rs
+++ b/tests/ui/lto/debuginfo-lto-alloc.rs
@@ -8,8 +8,9 @@
 // This test reproduces the circumstances that caused the error to appear, and checks
 // that compilation is successful.
 
-//@ check-pass
+//@ build-pass
 //@ compile-flags: --test -C debuginfo=2 -C lto=fat
+//@ no-prefer-dynamic
 //@ incremental
 
 extern crate alloc;
-- 
cgit 1.4.1-3-g733a5


From cecf9ead40352f77e2e83765f0f6a796277299ec Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Tue, 1 Jul 2025 20:34:45 +0800
Subject: Add test raw-underscore-lifetime.rs

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 tests/ui/underscore-lifetime/raw-underscore-lifetime.rs   | 10 ++++++++++
 .../ui/underscore-lifetime/raw-underscore-lifetime.stderr | 15 +++++++++++++++
 2 files changed, 25 insertions(+)
 create mode 100644 tests/ui/underscore-lifetime/raw-underscore-lifetime.rs
 create mode 100644 tests/ui/underscore-lifetime/raw-underscore-lifetime.stderr

diff --git a/tests/ui/underscore-lifetime/raw-underscore-lifetime.rs b/tests/ui/underscore-lifetime/raw-underscore-lifetime.rs
new file mode 100644
index 00000000000..9ab040f2eab
--- /dev/null
+++ b/tests/ui/underscore-lifetime/raw-underscore-lifetime.rs
@@ -0,0 +1,10 @@
+// This test is to ensure that the raw underscore lifetime won't emit two duplicate errors.
+// See issue #143152
+
+//@ edition: 2021
+
+fn f<'r#_>(){}
+//~^ ERROR `_` cannot be a raw lifetime
+//~| ERROR `'_` cannot be used here [E0637]
+
+fn main() {}
diff --git a/tests/ui/underscore-lifetime/raw-underscore-lifetime.stderr b/tests/ui/underscore-lifetime/raw-underscore-lifetime.stderr
new file mode 100644
index 00000000000..39627d8a476
--- /dev/null
+++ b/tests/ui/underscore-lifetime/raw-underscore-lifetime.stderr
@@ -0,0 +1,15 @@
+error: `_` cannot be a raw lifetime
+  --> $DIR/raw-underscore-lifetime.rs:6:6
+   |
+LL | fn f<'r#_>(){}
+   |      ^^^^
+
+error[E0637]: `'_` cannot be used here
+  --> $DIR/raw-underscore-lifetime.rs:6:6
+   |
+LL | fn f<'r#_>(){}
+   |      ^^^^ `'_` is a reserved lifetime name
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0637`.
-- 
cgit 1.4.1-3-g733a5


From 848d4a5a381ddda172a5629d8050a58388ecb2b9 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Tue, 1 Jul 2025 20:49:07 +0800
Subject: Remove similar errors about raw underscore lifetime

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 compiler/rustc_resolve/src/late.rs                         | 14 +++++++++++++-
 tests/ui/underscore-lifetime/raw-underscore-lifetime.rs    |  1 -
 .../ui/underscore-lifetime/raw-underscore-lifetime.stderr  |  9 +--------
 3 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 753b9365cd8..93cec8daa5a 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -2899,9 +2899,21 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 }
 
                 if param.ident.name == kw::UnderscoreLifetime {
+                    // To avoid emitting two similar errors,
+                    // we need to check if the span is a raw underscore lifetime, see issue #143152
+                    let is_raw_underscore_lifetime = self
+                        .r
+                        .tcx
+                        .sess
+                        .psess
+                        .raw_identifier_spans
+                        .iter()
+                        .any(|span| span == param.span());
+
                     self.r
                         .dcx()
-                        .emit_err(errors::UnderscoreLifetimeIsReserved { span: param.ident.span });
+                        .create_err(errors::UnderscoreLifetimeIsReserved { span: param.ident.span })
+                        .emit_unless(is_raw_underscore_lifetime);
                     // Record lifetime res, so lowering knows there is something fishy.
                     self.record_lifetime_param(param.id, LifetimeRes::Error);
                     continue;
diff --git a/tests/ui/underscore-lifetime/raw-underscore-lifetime.rs b/tests/ui/underscore-lifetime/raw-underscore-lifetime.rs
index 9ab040f2eab..874b3d2c48d 100644
--- a/tests/ui/underscore-lifetime/raw-underscore-lifetime.rs
+++ b/tests/ui/underscore-lifetime/raw-underscore-lifetime.rs
@@ -5,6 +5,5 @@
 
 fn f<'r#_>(){}
 //~^ ERROR `_` cannot be a raw lifetime
-//~| ERROR `'_` cannot be used here [E0637]
 
 fn main() {}
diff --git a/tests/ui/underscore-lifetime/raw-underscore-lifetime.stderr b/tests/ui/underscore-lifetime/raw-underscore-lifetime.stderr
index 39627d8a476..bdb357a47f4 100644
--- a/tests/ui/underscore-lifetime/raw-underscore-lifetime.stderr
+++ b/tests/ui/underscore-lifetime/raw-underscore-lifetime.stderr
@@ -4,12 +4,5 @@ error: `_` cannot be a raw lifetime
 LL | fn f<'r#_>(){}
    |      ^^^^
 
-error[E0637]: `'_` cannot be used here
-  --> $DIR/raw-underscore-lifetime.rs:6:6
-   |
-LL | fn f<'r#_>(){}
-   |      ^^^^ `'_` is a reserved lifetime name
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0637`.
-- 
cgit 1.4.1-3-g733a5


From 96171dc78f23430a28ed8eb6a3879758d3d0d3d5 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 25 Jun 2025 16:03:52 +0000
Subject: Check if type has coroutines before visiting

---
 compiler/rustc_trait_selection/src/solve/fulfill.rs | 11 +++++++----
 compiler/rustc_type_ir/src/flags.rs                 | 16 ++++++++++++----
 compiler/rustc_type_ir/src/visit.rs                 |  4 ++++
 3 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index d56042a5ca2..72770535b3e 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -10,7 +10,8 @@ use rustc_infer::traits::{
     FromSolverError, PredicateObligation, PredicateObligations, TraitEngine,
 };
 use rustc_middle::ty::{
-    self, DelayedSet, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor, TypingMode,
+    self, DelayedSet, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
+    TypingMode,
 };
 use rustc_next_trait_solver::delegate::SolverDelegate as _;
 use rustc_next_trait_solver::solve::{
@@ -332,10 +333,12 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for StalledOnCoroutines<'tcx> {
         if let ty::CoroutineWitness(def_id, _) = *ty.kind()
             && def_id.as_local().is_some_and(|def_id| self.stalled_generators.contains(&def_id))
         {
-            return ControlFlow::Break(());
+            ControlFlow::Break(())
+        } else if ty.has_coroutines() {
+            ty.super_visit_with(self)
+        } else {
+            ControlFlow::Continue(())
         }
-
-        ty.super_visit_with(self)
     }
 }
 
diff --git a/compiler/rustc_type_ir/src/flags.rs b/compiler/rustc_type_ir/src/flags.rs
index a231908f874..d7b9e0ca340 100644
--- a/compiler/rustc_type_ir/src/flags.rs
+++ b/compiler/rustc_type_ir/src/flags.rs
@@ -130,6 +130,12 @@ bitflags::bitflags! {
 
         /// Does this have any binders with bound vars (e.g. that need to be anonymized)?
         const HAS_BINDER_VARS             = 1 << 23;
+
+        /// Does this type have any coroutine witnesses in it?
+        // FIXME: This should probably be changed to track whether the type has any
+        // *coroutines* in it, though this will happen if we remove coroutine witnesses
+        // altogether.
+        const HAS_TY_CORO                 = 1 << 24;
     }
 }
 
@@ -240,10 +246,12 @@ impl<I: Interner> FlagComputation<I> {
                 self.add_flags(TypeFlags::HAS_TY_PARAM);
             }
 
-            ty::Closure(_, args)
-            | ty::Coroutine(_, args)
-            | ty::CoroutineClosure(_, args)
-            | ty::CoroutineWitness(_, args) => {
+            ty::Closure(_, args) | ty::Coroutine(_, args) | ty::CoroutineClosure(_, args) => {
+                self.add_args(args.as_slice());
+            }
+
+            ty::CoroutineWitness(_, args) => {
+                self.add_flags(TypeFlags::HAS_TY_CORO);
                 self.add_args(args.as_slice());
             }
 
diff --git a/compiler/rustc_type_ir/src/visit.rs b/compiler/rustc_type_ir/src/visit.rs
index a96ac97f785..5104484e9c4 100644
--- a/compiler/rustc_type_ir/src/visit.rs
+++ b/compiler/rustc_type_ir/src/visit.rs
@@ -269,6 +269,10 @@ pub trait TypeVisitableExt<I: Interner>: TypeVisitable<I> {
         self.has_type_flags(TypeFlags::HAS_TY_OPAQUE)
     }
 
+    fn has_coroutines(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_TY_CORO)
+    }
+
     fn references_error(&self) -> bool {
         self.has_type_flags(TypeFlags::HAS_ERROR)
     }
-- 
cgit 1.4.1-3-g733a5


From 72bc11d14688599fbcaedf2be9175aa374e1c0d9 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 29 May 2025 12:34:24 +0000
Subject: Unstall obligations by looking for coroutines in old solver

---
 compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs     | 51 +++++-----------------
 .../rustc_trait_selection/src/solve/fulfill.rs     | 16 +++----
 .../rustc_trait_selection/src/traits/fulfill.rs    | 39 ++++++++++++++---
 3 files changed, 52 insertions(+), 54 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index af1fc045ac8..0b3d50ff219 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -625,50 +625,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // trigger query cycle ICEs, as doing so requires MIR.
         self.select_obligations_where_possible(|_| {});
 
-        let coroutines = std::mem::take(&mut *self.deferred_coroutine_interiors.borrow_mut());
-        debug!(?coroutines);
-
-        let mut obligations = vec![];
-
-        if !self.next_trait_solver() {
-            for &(coroutine_def_id, interior) in coroutines.iter() {
-                debug!(?coroutine_def_id);
-
-                // Create the `CoroutineWitness` type that we will unify with `interior`.
-                let args = ty::GenericArgs::identity_for_item(
-                    self.tcx,
-                    self.tcx.typeck_root_def_id(coroutine_def_id.to_def_id()),
-                );
-                let witness =
-                    Ty::new_coroutine_witness(self.tcx, coroutine_def_id.to_def_id(), args);
-
-                // Unify `interior` with `witness` and collect all the resulting obligations.
-                let span = self.tcx.hir_body_owned_by(coroutine_def_id).value.span;
-                let ty::Infer(ty::InferTy::TyVar(_)) = interior.kind() else {
-                    span_bug!(span, "coroutine interior witness not infer: {:?}", interior.kind())
-                };
-                let ok = self
-                    .at(&self.misc(span), self.param_env)
-                    // Will never define opaque types, as all we do is instantiate a type variable.
-                    .eq(DefineOpaqueTypes::Yes, interior, witness)
-                    .expect("Failed to unify coroutine interior type");
-
-                obligations.extend(ok.obligations);
-            }
-        }
+        let ty::TypingMode::Analysis { defining_opaque_types_and_generators } = self.typing_mode()
+        else {
+            bug!();
+        };
 
-        if !coroutines.is_empty() {
-            obligations.extend(
+        if defining_opaque_types_and_generators
+            .iter()
+            .any(|def_id| self.tcx.is_coroutine(def_id.to_def_id()))
+        {
+            self.typeck_results.borrow_mut().coroutine_stalled_predicates.extend(
                 self.fulfillment_cx
                     .borrow_mut()
-                    .drain_stalled_obligations_for_coroutines(&self.infcx),
+                    .drain_stalled_obligations_for_coroutines(&self.infcx)
+                    .into_iter()
+                    .map(|o| (o.predicate, o.cause)),
             );
         }
-
-        self.typeck_results
-            .borrow_mut()
-            .coroutine_stalled_predicates
-            .extend(obligations.into_iter().map(|o| (o.predicate, o.cause)));
     }
 
     #[instrument(skip(self), level = "debug")]
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index 72770535b3e..3ce0f025512 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -255,7 +255,7 @@ where
         &mut self,
         infcx: &InferCtxt<'tcx>,
     ) -> PredicateObligations<'tcx> {
-        let stalled_generators = match infcx.typing_mode() {
+        let stalled_coroutines = match infcx.typing_mode() {
             TypingMode::Analysis { defining_opaque_types_and_generators } => {
                 defining_opaque_types_and_generators
             }
@@ -265,7 +265,7 @@ where
             | TypingMode::PostAnalysis => return Default::default(),
         };
 
-        if stalled_generators.is_empty() {
+        if stalled_coroutines.is_empty() {
             return Default::default();
         }
 
@@ -276,7 +276,7 @@ where
                         .visit_proof_tree(
                             obl.as_goal(),
                             &mut StalledOnCoroutines {
-                                stalled_generators,
+                                stalled_coroutines,
                                 span: obl.cause.span,
                                 cache: Default::default(),
                             },
@@ -298,10 +298,10 @@ where
 ///
 /// This function can be also return false positives, which will lead to poor diagnostics
 /// so we want to keep this visitor *precise* too.
-struct StalledOnCoroutines<'tcx> {
-    stalled_generators: &'tcx ty::List<LocalDefId>,
-    span: Span,
-    cache: DelayedSet<Ty<'tcx>>,
+pub struct StalledOnCoroutines<'tcx> {
+    pub stalled_coroutines: &'tcx ty::List<LocalDefId>,
+    pub span: Span,
+    pub cache: DelayedSet<Ty<'tcx>>,
 }
 
 impl<'tcx> inspect::ProofTreeVisitor<'tcx> for StalledOnCoroutines<'tcx> {
@@ -331,7 +331,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for StalledOnCoroutines<'tcx> {
         }
 
         if let ty::CoroutineWitness(def_id, _) = *ty.kind()
-            && def_id.as_local().is_some_and(|def_id| self.stalled_generators.contains(&def_id))
+            && def_id.as_local().is_some_and(|def_id| self.stalled_coroutines.contains(&def_id))
         {
             ControlFlow::Break(())
         } else if ty.has_coroutines() {
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index 2b5a41ef5a7..c6c68b1c401 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -3,6 +3,7 @@ use std::marker::PhantomData;
 use rustc_data_structures::obligation_forest::{
     Error, ForestObligation, ObligationForest, ObligationProcessor, Outcome, ProcessResult,
 };
+use rustc_hir::def_id::LocalDefId;
 use rustc_infer::infer::DefineOpaqueTypes;
 use rustc_infer::traits::{
     FromSolverError, PolyTraitObligation, PredicateObligations, ProjectionCacheKey, SelectionError,
@@ -12,8 +13,9 @@ use rustc_middle::bug;
 use rustc_middle::ty::abstract_const::NotConstEvaluatable;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::{
-    self, Binder, Const, GenericArgsRef, TypeVisitableExt, TypingMode, may_use_unstable_feature,
+    self, Binder, Const, GenericArgsRef, TypeVisitable, TypeVisitableExt, TypingMode,
 };
+use rustc_span::DUMMY_SP;
 use thin_vec::{ThinVec, thin_vec};
 use tracing::{debug, debug_span, instrument};
 
@@ -26,6 +28,7 @@ use super::{
 };
 use crate::error_reporting::InferCtxtErrorExt;
 use crate::infer::{InferCtxt, TyOrConstInferVar};
+use crate::solve::StalledOnCoroutines;
 use crate::traits::normalize::normalize_with_depth_to;
 use crate::traits::project::{PolyProjectionObligation, ProjectionCacheKeyExt as _};
 use crate::traits::query::evaluate_obligation::InferCtxtExt;
@@ -168,8 +171,25 @@ where
         &mut self,
         infcx: &InferCtxt<'tcx>,
     ) -> PredicateObligations<'tcx> {
-        let mut processor =
-            DrainProcessor { removed_predicates: PredicateObligations::new(), infcx };
+        let stalled_coroutines = match infcx.typing_mode() {
+            TypingMode::Analysis { defining_opaque_types_and_generators } => {
+                defining_opaque_types_and_generators
+            }
+            TypingMode::Coherence
+            | TypingMode::Borrowck { defining_opaque_types: _ }
+            | TypingMode::PostBorrowckAnalysis { defined_opaque_types: _ }
+            | TypingMode::PostAnalysis => return Default::default(),
+        };
+
+        if stalled_coroutines.is_empty() {
+            return Default::default();
+        }
+
+        let mut processor = DrainProcessor {
+            infcx,
+            removed_predicates: PredicateObligations::new(),
+            stalled_coroutines,
+        };
         let outcome: Outcome<_, _> = self.predicates.process_obligations(&mut processor);
         assert!(outcome.errors.is_empty());
         return processor.removed_predicates;
@@ -177,6 +197,7 @@ where
         struct DrainProcessor<'a, 'tcx> {
             infcx: &'a InferCtxt<'tcx>,
             removed_predicates: PredicateObligations<'tcx>,
+            stalled_coroutines: &'tcx ty::List<LocalDefId>,
         }
 
         impl<'tcx> ObligationProcessor for DrainProcessor<'_, 'tcx> {
@@ -185,10 +206,14 @@ where
             type OUT = Outcome<Self::Obligation, Self::Error>;
 
             fn needs_process_obligation(&self, pending_obligation: &Self::Obligation) -> bool {
-                pending_obligation
-                    .stalled_on
-                    .iter()
-                    .any(|&var| self.infcx.ty_or_const_infer_var_changed(var))
+                self.infcx
+                    .resolve_vars_if_possible(pending_obligation.obligation.predicate)
+                    .visit_with(&mut StalledOnCoroutines {
+                        stalled_coroutines: self.stalled_coroutines,
+                        span: DUMMY_SP,
+                        cache: Default::default(),
+                    })
+                    .is_break()
             }
 
             fn process_obligation(
-- 
cgit 1.4.1-3-g733a5


From 216cdb7b22b637cef75b7225c642cb7587192643 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 29 May 2025 12:34:50 +0000
Subject: Eagerly unify coroutine witness in old solver

---
 compiler/rustc_hir_typeck/src/closure.rs           |  11 +-
 compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs  |   3 -
 compiler/rustc_middle/src/ty/context.rs            |  18 ++--
 compiler/rustc_trait_selection/src/infer.rs        |   4 +-
 compiler/rustc_trait_selection/src/solve.rs        |   2 +-
 .../rustc_trait_selection/src/traits/fulfill.rs    |   1 +
 .../src/traits/select/candidate_assembly.rs        |  33 ++++--
 .../rustc_trait_selection/src/traits/select/mod.rs |  15 ++-
 .../ui/async-await/async-closures/def-path.stderr  |   4 +-
 tests/ui/coroutine/clone-impl.rs                   |  25 ++---
 tests/ui/coroutine/clone-impl.stderr               | 113 ++++++++-------------
 .../print/coroutine-print-verbose-3.stderr         |   2 +-
 tests/ui/impl-trait/issues/issue-55872-3.rs        |   1 +
 tests/ui/impl-trait/issues/issue-55872-3.stderr    |  16 ++-
 14 files changed, 125 insertions(+), 123 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/closure.rs b/compiler/rustc_hir_typeck/src/closure.rs
index 459c0498d50..a413f805873 100644
--- a/compiler/rustc_hir_typeck/src/closure.rs
+++ b/compiler/rustc_hir_typeck/src/closure.rs
@@ -161,16 +161,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // Resume type defaults to `()` if the coroutine has no argument.
                 let resume_ty = liberated_sig.inputs().get(0).copied().unwrap_or(tcx.types.unit);
 
-                // In the new solver, we can just instantiate this eagerly
-                // with the witness. This will ensure that goals that don't need
-                // to stall on interior types will get processed eagerly.
-                let interior = if self.next_trait_solver() {
-                    Ty::new_coroutine_witness(tcx, expr_def_id.to_def_id(), parent_args)
-                } else {
-                    self.next_ty_var(expr_span)
-                };
-
-                self.deferred_coroutine_interiors.borrow_mut().push((expr_def_id, interior));
+                let interior = Ty::new_coroutine_witness(tcx, expr_def_id.to_def_id(), parent_args);
 
                 // Coroutines that come from coroutine closures have not yet determined
                 // their kind ty, so make a fresh infer var which will be constrained
diff --git a/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs b/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
index 26be5fc6d19..9f4ab8ca5d4 100644
--- a/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
+++ b/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
@@ -63,8 +63,6 @@ pub(crate) struct TypeckRootCtxt<'tcx> {
 
     pub(super) deferred_asm_checks: RefCell<Vec<(&'tcx hir::InlineAsm<'tcx>, HirId)>>,
 
-    pub(super) deferred_coroutine_interiors: RefCell<Vec<(LocalDefId, Ty<'tcx>)>>,
-
     pub(super) deferred_repeat_expr_checks:
         RefCell<Vec<(&'tcx hir::Expr<'tcx>, Ty<'tcx>, ty::Const<'tcx>)>>,
 
@@ -103,7 +101,6 @@ impl<'tcx> TypeckRootCtxt<'tcx> {
             deferred_cast_checks: RefCell::new(Vec::new()),
             deferred_transmute_checks: RefCell::new(Vec::new()),
             deferred_asm_checks: RefCell::new(Vec::new()),
-            deferred_coroutine_interiors: RefCell::new(Vec::new()),
             deferred_repeat_expr_checks: RefCell::new(Vec::new()),
             diverging_type_vars: RefCell::new(Default::default()),
             infer_var_info: RefCell::new(Default::default()),
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 915b062417f..684d13e147e 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -714,17 +714,13 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self,
         defining_anchor: Self::LocalDefId,
     ) -> Self::LocalDefIds {
-        if self.next_trait_solver_globally() {
-            let coroutines_defined_by = self
-                .nested_bodies_within(defining_anchor)
-                .iter()
-                .filter(|def_id| self.is_coroutine(def_id.to_def_id()));
-            self.mk_local_def_ids_from_iter(
-                self.opaque_types_defined_by(defining_anchor).iter().chain(coroutines_defined_by),
-            )
-        } else {
-            self.opaque_types_defined_by(defining_anchor)
-        }
+        let coroutines_defined_by = self
+            .nested_bodies_within(defining_anchor)
+            .iter()
+            .filter(|def_id| self.is_coroutine(def_id.to_def_id()));
+        self.mk_local_def_ids_from_iter(
+            self.opaque_types_defined_by(defining_anchor).iter().chain(coroutines_defined_by),
+        )
     }
 }
 
diff --git a/compiler/rustc_trait_selection/src/infer.rs b/compiler/rustc_trait_selection/src/infer.rs
index 0118321befb..7c6b7b14ecb 100644
--- a/compiler/rustc_trait_selection/src/infer.rs
+++ b/compiler/rustc_trait_selection/src/infer.rs
@@ -33,8 +33,8 @@ impl<'tcx> InferCtxt<'tcx> {
         let ty = self.resolve_vars_if_possible(ty);
 
         // FIXME(#132279): This should be removed as it causes us to incorrectly
-        // handle opaques in their defining scope.
-        if !self.next_trait_solver() && !(param_env, ty).has_infer() {
+        // handle opaques in their defining scope, and stalled coroutines.
+        if !self.next_trait_solver() && !(param_env, ty).has_infer() && !ty.has_coroutines() {
             return self.tcx.type_is_copy_modulo_regions(self.typing_env(param_env), ty);
         }
 
diff --git a/compiler/rustc_trait_selection/src/solve.rs b/compiler/rustc_trait_selection/src/solve.rs
index 5a5d16167d2..f58961683a9 100644
--- a/compiler/rustc_trait_selection/src/solve.rs
+++ b/compiler/rustc_trait_selection/src/solve.rs
@@ -7,7 +7,7 @@ mod normalize;
 mod select;
 
 pub(crate) use delegate::SolverDelegate;
-pub use fulfill::{FulfillmentCtxt, NextSolverError};
+pub use fulfill::{FulfillmentCtxt, NextSolverError, StalledOnCoroutines};
 pub(crate) use normalize::deeply_normalize_for_diagnostics;
 pub use normalize::{
     deeply_normalize, deeply_normalize_with_skipped_universes,
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index c6c68b1c401..e35f89358e9 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -14,6 +14,7 @@ use rustc_middle::ty::abstract_const::NotConstEvaluatable;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::{
     self, Binder, Const, GenericArgsRef, TypeVisitable, TypeVisitableExt, TypingMode,
+    may_use_unstable_feature,
 };
 use rustc_span::DUMMY_SP;
 use thin_vec::{ThinVec, thin_vec};
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index cc188a280aa..2c7089507a8 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -842,6 +842,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     }
                 }
 
+                ty::CoroutineWitness(def_id, _) => {
+                    if self.should_stall_coroutine_witness(def_id) {
+                        candidates.ambiguous = true;
+                    } else {
+                        candidates.vec.push(AutoImplCandidate);
+                    }
+                }
+
                 ty::Bool
                 | ty::Char
                 | ty::Int(_)
@@ -861,7 +869,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | ty::Coroutine(..)
                 | ty::Never
                 | ty::Tuple(_)
-                | ty::CoroutineWitness(..)
                 | ty::UnsafeBinder(_) => {
                     // Only consider auto impls of unsafe traits when there are
                     // no unsafe fields.
@@ -1119,12 +1126,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         match *self_ty.kind() {
             // These impls are built-in because we cannot express sufficiently
             // generic impls in libcore.
-            ty::FnDef(..)
-            | ty::FnPtr(..)
-            | ty::Error(_)
-            | ty::Tuple(..)
-            | ty::CoroutineWitness(..)
-            | ty::Pat(..) => {
+            ty::FnDef(..) | ty::FnPtr(..) | ty::Error(_) | ty::Tuple(..) | ty::Pat(..) => {
                 candidates.vec.push(BuiltinCandidate);
             }
 
@@ -1192,6 +1194,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 }
             }
 
+            ty::CoroutineWitness(coroutine_def_id, _) => {
+                if self.should_stall_coroutine_witness(coroutine_def_id) {
+                    candidates.ambiguous = true;
+                } else {
+                    candidates.vec.push(SizedCandidate);
+                }
+            }
+
             // Fallback to whatever user-defined impls or param-env clauses exist in this case.
             ty::Adt(..) | ty::Alias(..) | ty::Param(..) | ty::Placeholder(..) => {}
 
@@ -1229,7 +1239,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::Char
             | ty::Ref(..)
             | ty::Coroutine(..)
-            | ty::CoroutineWitness(..)
             | ty::Array(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
@@ -1238,6 +1247,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 candidates.vec.push(SizedCandidate);
             }
 
+            ty::CoroutineWitness(coroutine_def_id, _) => {
+                if self.should_stall_coroutine_witness(coroutine_def_id) {
+                    candidates.ambiguous = true;
+                } else {
+                    candidates.vec.push(SizedCandidate);
+                }
+            }
+
             // Conditionally `Sized`.
             ty::Tuple(..) | ty::Pat(..) | ty::Adt(..) | ty::UnsafeBinder(_) => {
                 candidates.vec.push(SizedCandidate);
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 10bcf861d35..d0b88d2fb18 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -1512,7 +1512,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 defining_opaque_types_and_generators: defining_opaque_types,
             }
             | TypingMode::Borrowck { defining_opaque_types } => {
-                defining_opaque_types.is_empty() || !pred.has_opaque_types()
+                defining_opaque_types.is_empty()
+                    || (!pred.has_opaque_types() && !pred.has_coroutines())
             }
             // The hidden types of `defined_opaque_types` is not local to the current
             // inference context, so we can freely move this to the global cache.
@@ -2811,6 +2812,18 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
 
         obligations
     }
+
+    fn should_stall_coroutine_witness(&self, def_id: DefId) -> bool {
+        match self.infcx.typing_mode() {
+            TypingMode::Analysis { defining_opaque_types_and_generators: stalled_generators } => {
+                def_id.as_local().is_some_and(|def_id| stalled_generators.contains(&def_id))
+            }
+            TypingMode::Coherence
+            | TypingMode::PostAnalysis
+            | TypingMode::Borrowck { defining_opaque_types: _ }
+            | TypingMode::PostBorrowckAnalysis { defined_opaque_types: _ } => false,
+        }
+    }
 }
 
 impl<'o, 'tcx> TraitObligationStack<'o, 'tcx> {
diff --git a/tests/ui/async-await/async-closures/def-path.stderr b/tests/ui/async-await/async-closures/def-path.stderr
index b50e353b698..58a5b0b79c4 100644
--- a/tests/ui/async-await/async-closures/def-path.stderr
+++ b/tests/ui/async-await/async-closures/def-path.stderr
@@ -5,11 +5,11 @@ LL |     let x = async || {};
    |                      -- the expected `async` closure body
 LL |
 LL |     let () = x();
-   |         ^^   --- this expression has type `{static main::{closure#0}::{closure#0}<?17t> upvar_tys=?16t resume_ty=ResumeTy yield_ty=() return_ty=() witness=?5t}`
+   |         ^^   --- this expression has type `{static main::{closure#0}::{closure#0}<?16t> upvar_tys=?15t resume_ty=ResumeTy yield_ty=() return_ty=() witness={main::{closure#0}::{closure#0}}}`
    |         |
    |         expected `async` closure body, found `()`
    |
-   = note: expected `async` closure body `{static main::{closure#0}::{closure#0}<?17t> upvar_tys=?16t resume_ty=ResumeTy yield_ty=() return_ty=() witness=?5t}`
+   = note: expected `async` closure body `{static main::{closure#0}::{closure#0}<?16t> upvar_tys=?15t resume_ty=ResumeTy yield_ty=() return_ty=() witness={main::{closure#0}::{closure#0}}}`
                          found unit type `()`
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/coroutine/clone-impl.rs b/tests/ui/coroutine/clone-impl.rs
index b07fad18aee..e528f031d52 100644
--- a/tests/ui/coroutine/clone-impl.rs
+++ b/tests/ui/coroutine/clone-impl.rs
@@ -38,39 +38,40 @@ fn test2() {
     check_clone(&gen_copy_1);
 }
 
-fn test3() {
+fn test3_upvars() {
     let clonable_0: Vec<u32> = Vec::new();
     let gen_clone_0 = #[coroutine]
     move || {
-        let v = vec!['a'];
-        yield;
-        drop(v);
         drop(clonable_0);
     };
     check_copy(&gen_clone_0);
     //~^ ERROR the trait bound `Vec<u32>: Copy` is not satisfied
-    //~| ERROR the trait bound `Vec<char>: Copy` is not satisfied
     check_clone(&gen_clone_0);
 }
 
+fn test3_witness() {
+    let gen_clone_1 = #[coroutine]
+    move || {
+        let v = vec!['a'];
+        yield;
+        drop(v);
+    };
+    check_copy(&gen_clone_1);
+    //~^ ERROR the trait bound `Vec<char>: Copy` is not satisfied
+    check_clone(&gen_clone_1);
+}
+
 fn test4() {
     let clonable_1: Vec<u32> = Vec::new();
     let gen_clone_1 = #[coroutine]
     move || {
-        let v = vec!['a'];
-        /*
-        let n = NonClone;
-        drop(n);
-        */
         yield;
         let n = NonClone;
         drop(n);
-        drop(v);
         drop(clonable_1);
     };
     check_copy(&gen_clone_1);
     //~^ ERROR the trait bound `Vec<u32>: Copy` is not satisfied
-    //~| ERROR the trait bound `Vec<char>: Copy` is not satisfied
     check_clone(&gen_clone_1);
 }
 
diff --git a/tests/ui/coroutine/clone-impl.stderr b/tests/ui/coroutine/clone-impl.stderr
index ed933fe784e..714e5aa3d9e 100644
--- a/tests/ui/coroutine/clone-impl.stderr
+++ b/tests/ui/coroutine/clone-impl.stderr
@@ -1,104 +1,59 @@
 error[E0277]: the trait bound `Vec<u32>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:44:5: 44:12}`
-  --> $DIR/clone-impl.rs:50:5
+  --> $DIR/clone-impl.rs:47:16
    |
 LL |     move || {
    |     ------- within this `{coroutine@$DIR/clone-impl.rs:44:5: 44:12}`
 ...
 LL |     check_copy(&gen_clone_0);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:44:5: 44:12}`, the trait `Copy` is not implemented for `Vec<u32>`
+   |                ^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:44:5: 44:12}`, the trait `Copy` is not implemented for `Vec<u32>`
    |
 note: captured value does not implement `Copy`
-  --> $DIR/clone-impl.rs:48:14
+  --> $DIR/clone-impl.rs:45:14
    |
 LL |         drop(clonable_0);
    |              ^^^^^^^^^^ has type `Vec<u32>` which does not implement `Copy`
 note: required by a bound in `check_copy`
-  --> $DIR/clone-impl.rs:90:18
+  --> $DIR/clone-impl.rs:91:18
    |
 LL | fn check_copy<T: Copy>(_x: &T) {}
    |                  ^^^^ required by this bound in `check_copy`
 
-error[E0277]: the trait bound `Vec<char>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:44:5: 44:12}`
-  --> $DIR/clone-impl.rs:50:5
+error[E0277]: the trait bound `Vec<u32>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:67:5: 67:12}`
+  --> $DIR/clone-impl.rs:73:16
    |
 LL |     move || {
-   |     ------- within this `{coroutine@$DIR/clone-impl.rs:44:5: 44:12}`
-...
-LL |     check_copy(&gen_clone_0);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:44:5: 44:12}`, the trait `Copy` is not implemented for `Vec<char>`
-   |
-note: coroutine does not implement `Copy` as this value is used across a yield
-  --> $DIR/clone-impl.rs:46:9
-   |
-LL |         let v = vec!['a'];
-   |             - has type `Vec<char>` which does not implement `Copy`
-LL |         yield;
-   |         ^^^^^ yield occurs here, with `v` maybe used later
-note: required by a bound in `check_copy`
-  --> $DIR/clone-impl.rs:90:18
-   |
-LL | fn check_copy<T: Copy>(_x: &T) {}
-   |                  ^^^^ required by this bound in `check_copy`
-
-error[E0277]: the trait bound `Vec<u32>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:59:5: 59:12}`
-  --> $DIR/clone-impl.rs:71:5
-   |
-LL |     move || {
-   |     ------- within this `{coroutine@$DIR/clone-impl.rs:59:5: 59:12}`
+   |     ------- within this `{coroutine@$DIR/clone-impl.rs:67:5: 67:12}`
 ...
 LL |     check_copy(&gen_clone_1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:59:5: 59:12}`, the trait `Copy` is not implemented for `Vec<u32>`
+   |                ^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:67:5: 67:12}`, the trait `Copy` is not implemented for `Vec<u32>`
    |
 note: captured value does not implement `Copy`
-  --> $DIR/clone-impl.rs:69:14
+  --> $DIR/clone-impl.rs:71:14
    |
 LL |         drop(clonable_1);
    |              ^^^^^^^^^^ has type `Vec<u32>` which does not implement `Copy`
 note: required by a bound in `check_copy`
-  --> $DIR/clone-impl.rs:90:18
-   |
-LL | fn check_copy<T: Copy>(_x: &T) {}
-   |                  ^^^^ required by this bound in `check_copy`
-
-error[E0277]: the trait bound `Vec<char>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:59:5: 59:12}`
-  --> $DIR/clone-impl.rs:71:5
-   |
-LL |     move || {
-   |     ------- within this `{coroutine@$DIR/clone-impl.rs:59:5: 59:12}`
-...
-LL |     check_copy(&gen_clone_1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:59:5: 59:12}`, the trait `Copy` is not implemented for `Vec<char>`
-   |
-note: coroutine does not implement `Copy` as this value is used across a yield
-  --> $DIR/clone-impl.rs:65:9
-   |
-LL |         let v = vec!['a'];
-   |             - has type `Vec<char>` which does not implement `Copy`
-...
-LL |         yield;
-   |         ^^^^^ yield occurs here, with `v` maybe used later
-note: required by a bound in `check_copy`
-  --> $DIR/clone-impl.rs:90:18
+  --> $DIR/clone-impl.rs:91:18
    |
 LL | fn check_copy<T: Copy>(_x: &T) {}
    |                  ^^^^ required by this bound in `check_copy`
 
-error[E0277]: the trait bound `NonClone: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:80:5: 80:12}`
-  --> $DIR/clone-impl.rs:84:5
+error[E0277]: the trait bound `NonClone: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:81:5: 81:12}`
+  --> $DIR/clone-impl.rs:85:16
    |
 LL |     move || {
-   |     ------- within this `{coroutine@$DIR/clone-impl.rs:80:5: 80:12}`
+   |     ------- within this `{coroutine@$DIR/clone-impl.rs:81:5: 81:12}`
 ...
 LL |     check_copy(&gen_non_clone);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:80:5: 80:12}`, the trait `Copy` is not implemented for `NonClone`
+   |                ^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:81:5: 81:12}`, the trait `Copy` is not implemented for `NonClone`
    |
 note: captured value does not implement `Copy`
-  --> $DIR/clone-impl.rs:82:14
+  --> $DIR/clone-impl.rs:83:14
    |
 LL |         drop(non_clonable);
    |              ^^^^^^^^^^^^ has type `NonClone` which does not implement `Copy`
 note: required by a bound in `check_copy`
-  --> $DIR/clone-impl.rs:90:18
+  --> $DIR/clone-impl.rs:91:18
    |
 LL | fn check_copy<T: Copy>(_x: &T) {}
    |                  ^^^^ required by this bound in `check_copy`
@@ -108,22 +63,22 @@ LL + #[derive(Copy)]
 LL | struct NonClone;
    |
 
-error[E0277]: the trait bound `NonClone: Clone` is not satisfied in `{coroutine@$DIR/clone-impl.rs:80:5: 80:12}`
-  --> $DIR/clone-impl.rs:86:5
+error[E0277]: the trait bound `NonClone: Clone` is not satisfied in `{coroutine@$DIR/clone-impl.rs:81:5: 81:12}`
+  --> $DIR/clone-impl.rs:87:17
    |
 LL |     move || {
-   |     ------- within this `{coroutine@$DIR/clone-impl.rs:80:5: 80:12}`
+   |     ------- within this `{coroutine@$DIR/clone-impl.rs:81:5: 81:12}`
 ...
 LL |     check_clone(&gen_non_clone);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:80:5: 80:12}`, the trait `Clone` is not implemented for `NonClone`
+   |                 ^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:81:5: 81:12}`, the trait `Clone` is not implemented for `NonClone`
    |
 note: captured value does not implement `Clone`
-  --> $DIR/clone-impl.rs:82:14
+  --> $DIR/clone-impl.rs:83:14
    |
 LL |         drop(non_clonable);
    |              ^^^^^^^^^^^^ has type `NonClone` which does not implement `Clone`
 note: required by a bound in `check_clone`
-  --> $DIR/clone-impl.rs:91:19
+  --> $DIR/clone-impl.rs:92:19
    |
 LL | fn check_clone<T: Clone>(_x: &T) {}
    |                   ^^^^^ required by this bound in `check_clone`
@@ -133,6 +88,28 @@ LL + #[derive(Clone)]
 LL | struct NonClone;
    |
 
-error: aborting due to 6 previous errors
+error[E0277]: the trait bound `Vec<char>: Copy` is not satisfied in `{coroutine@$DIR/clone-impl.rs:54:5: 54:12}`
+  --> $DIR/clone-impl.rs:59:5
+   |
+LL |     move || {
+   |     ------- within this `{coroutine@$DIR/clone-impl.rs:54:5: 54:12}`
+...
+LL |     check_copy(&gen_clone_1);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ within `{coroutine@$DIR/clone-impl.rs:54:5: 54:12}`, the trait `Copy` is not implemented for `Vec<char>`
+   |
+note: coroutine does not implement `Copy` as this value is used across a yield
+  --> $DIR/clone-impl.rs:56:9
+   |
+LL |         let v = vec!['a'];
+   |             - has type `Vec<char>` which does not implement `Copy`
+LL |         yield;
+   |         ^^^^^ yield occurs here, with `v` maybe used later
+note: required by a bound in `check_copy`
+  --> $DIR/clone-impl.rs:91:18
+   |
+LL | fn check_copy<T: Copy>(_x: &T) {}
+   |                  ^^^^ required by this bound in `check_copy`
+
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr b/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
index 2f9f20cf1ff..4a1e5b078a8 100644
--- a/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
+++ b/tests/ui/coroutine/print/coroutine-print-verbose-3.stderr
@@ -11,7 +11,7 @@ LL | |     };
    | |_____^ expected `()`, found coroutine
    |
    = note: expected unit type `()`
-              found coroutine `{main::{closure#0} upvar_tys=?4t resume_ty=() yield_ty=i32 return_ty=&'?1 str witness=?6t}`
+              found coroutine `{main::{closure#0} upvar_tys=?4t resume_ty=() yield_ty=i32 return_ty=&'?1 str witness={main::{closure#0}}}`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/issues/issue-55872-3.rs b/tests/ui/impl-trait/issues/issue-55872-3.rs
index 698e7f36234..763b4b9fd32 100644
--- a/tests/ui/impl-trait/issues/issue-55872-3.rs
+++ b/tests/ui/impl-trait/issues/issue-55872-3.rs
@@ -14,6 +14,7 @@ impl<S> Bar for S {
     fn foo<T>() -> Self::E {
         //~^ ERROR : Copy` is not satisfied [E0277]
         //~| ERROR type parameter `T` is part of concrete type
+        //~| ERROR type parameter `T` is part of concrete type
         async {}
     }
 }
diff --git a/tests/ui/impl-trait/issues/issue-55872-3.stderr b/tests/ui/impl-trait/issues/issue-55872-3.stderr
index 3281dcc3501..ce2dd7f02b4 100644
--- a/tests/ui/impl-trait/issues/issue-55872-3.stderr
+++ b/tests/ui/impl-trait/issues/issue-55872-3.stderr
@@ -1,11 +1,11 @@
-error[E0277]: the trait bound `{async block@$DIR/issue-55872-3.rs:17:9: 17:14}: Copy` is not satisfied
+error[E0277]: the trait bound `{async block@$DIR/issue-55872-3.rs:18:9: 18:14}: Copy` is not satisfied
   --> $DIR/issue-55872-3.rs:14:20
    |
 LL |     fn foo<T>() -> Self::E {
-   |                    ^^^^^^^ the trait `Copy` is not implemented for `{async block@$DIR/issue-55872-3.rs:17:9: 17:14}`
+   |                    ^^^^^^^ the trait `Copy` is not implemented for `{async block@$DIR/issue-55872-3.rs:18:9: 18:14}`
 ...
 LL |         async {}
-   |         -------- return type was inferred to be `{async block@$DIR/issue-55872-3.rs:17:9: 17:14}` here
+   |         -------- return type was inferred to be `{async block@$DIR/issue-55872-3.rs:18:9: 18:14}` here
 
 error: type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias
   --> $DIR/issue-55872-3.rs:14:20
@@ -13,6 +13,14 @@ error: type parameter `T` is part of concrete type but not used in parameter lis
 LL |     fn foo<T>() -> Self::E {
    |                    ^^^^^^^
 
-error: aborting due to 2 previous errors
+error: type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias
+  --> $DIR/issue-55872-3.rs:14:20
+   |
+LL |     fn foo<T>() -> Self::E {
+   |                    ^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 68b415a0c4cfa054f275424db770d08227c09099 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Fri, 11 Jul 2025 10:20:25 +0000
Subject: Make slices `[const] PartialEq`

---
 library/core/src/cmp.rs                            |  3 ++-
 library/core/src/cmp/bytewise.rs                   |  8 ++++++--
 library/core/src/intrinsics/mod.rs                 |  1 +
 library/core/src/lib.rs                            |  2 ++
 library/core/src/slice/cmp.rs                      | 22 +++++++++++++++-------
 library/core/src/str/traits.rs                     |  3 ++-
 tests/ui/consts/const-compare-bytes-ub.rs          |  2 +-
 tests/ui/consts/const-compare-bytes.rs             |  2 +-
 tests/ui/traits/const-traits/const-impl-trait.rs   |  2 +-
 .../const-traits/match-non-const-eq.gated.stderr   | 12 ------------
 tests/ui/traits/const-traits/match-non-const-eq.rs |  9 +++++----
 .../const-traits/match-non-const-eq.stock.stderr   | 22 ++++++++++++++++++----
 12 files changed, 54 insertions(+), 34 deletions(-)
 delete mode 100644 tests/ui/traits/const-traits/match-non-const-eq.gated.stderr

diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index 03b120fbf0c..6419ae99113 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -381,7 +381,8 @@ pub struct AssertParamIsEq<T: Eq + PointeeSized> {
 ///
 /// assert_eq!(2.cmp(&1), Ordering::Greater);
 /// ```
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+#[derive(Clone, Copy, Eq, PartialOrd, Ord, Debug, Hash)]
+#[derive_const(PartialEq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 // This is a lang item only so that `BinOp::Cmp` in MIR can return it.
 // It has no special behavior, but does require that the three variants
diff --git a/library/core/src/cmp/bytewise.rs b/library/core/src/cmp/bytewise.rs
index a06a5227fe2..7d61c9345ec 100644
--- a/library/core/src/cmp/bytewise.rs
+++ b/library/core/src/cmp/bytewise.rs
@@ -17,11 +17,15 @@ use crate::num::NonZero;
 /// - Neither `Self` nor `Rhs` have provenance, so integer comparisons are correct.
 /// - `<Self as PartialEq<Rhs>>::{eq,ne}` are equivalent to comparing the bytes.
 #[rustc_specialization_trait]
-pub(crate) unsafe trait BytewiseEq<Rhs = Self>: PartialEq<Rhs> + Sized {}
+#[const_trait]
+pub(crate) unsafe trait BytewiseEq<Rhs = Self>:
+    ~const PartialEq<Rhs> + Sized
+{
+}
 
 macro_rules! is_bytewise_comparable {
     ($($t:ty),+ $(,)?) => {$(
-        unsafe impl BytewiseEq for $t {}
+        unsafe impl const BytewiseEq for $t {}
     )+};
 }
 
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 1ece3d9bd5e..b11972600fa 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -2208,6 +2208,7 @@ pub const unsafe fn raw_eq<T>(a: &T, b: &T) -> bool;
 /// [valid]: crate::ptr#safety
 #[rustc_nounwind]
 #[rustc_intrinsic]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 pub const unsafe fn compare_bytes(left: *const u8, right: *const u8, bytes: usize) -> i32;
 
 /// See documentation of [`std::hint::black_box`] for details.
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 2f701171505..fedc4dada20 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -103,6 +103,7 @@
 #![feature(cfg_select)]
 #![feature(cfg_target_has_reliable_f16_f128)]
 #![feature(const_carrying_mul_add)]
+#![feature(const_cmp)]
 #![feature(const_destruct)]
 #![feature(const_eval_select)]
 #![feature(core_intrinsics)]
@@ -146,6 +147,7 @@
 #![feature(const_trait_impl)]
 #![feature(decl_macro)]
 #![feature(deprecated_suggestion)]
+#![feature(derive_const)]
 #![feature(doc_cfg)]
 #![feature(doc_cfg_hide)]
 #![feature(doc_notable_trait)]
diff --git a/library/core/src/slice/cmp.rs b/library/core/src/slice/cmp.rs
index 5ce72b46eee..1eda8bc1bec 100644
--- a/library/core/src/slice/cmp.rs
+++ b/library/core/src/slice/cmp.rs
@@ -8,9 +8,10 @@ use crate::num::NonZero;
 use crate::ops::ControlFlow;
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, U> PartialEq<[U]> for [T]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<T, U> const PartialEq<[U]> for [T]
 where
-    T: PartialEq<U>,
+    T: ~const PartialEq<U>,
 {
     fn eq(&self, other: &[U]) -> bool {
         SlicePartialEq::equal(self, other)
@@ -94,6 +95,8 @@ impl<T: PartialOrd> PartialOrd for [T] {
 
 #[doc(hidden)]
 // intermediate trait for specialization of slice's PartialEq
+#[const_trait]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
 trait SlicePartialEq<B> {
     fn equal(&self, other: &[B]) -> bool;
 
@@ -103,9 +106,10 @@ trait SlicePartialEq<B> {
 }
 
 // Generic slice equality
-impl<A, B> SlicePartialEq<B> for [A]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A, B> const SlicePartialEq<B> for [A]
 where
-    A: PartialEq<B>,
+    A: ~const PartialEq<B>,
 {
     default fn equal(&self, other: &[B]) -> bool {
         if self.len() != other.len() {
@@ -115,11 +119,14 @@ where
         // Implemented as explicit indexing rather
         // than zipped iterators for performance reasons.
         // See PR https://github.com/rust-lang/rust/pull/116846
-        for idx in 0..self.len() {
+        // FIXME(const_hack): make this a `for idx in 0..self.len()` loop.
+        let mut idx = 0;
+        while idx < self.len() {
             // bound checks are optimized away
             if self[idx] != other[idx] {
                 return false;
             }
+            idx += 1;
         }
 
         true
@@ -128,9 +135,10 @@ where
 
 // When each element can be compared byte-wise, we can compare all the bytes
 // from the whole size in one call to the intrinsics.
-impl<A, B> SlicePartialEq<B> for [A]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl<A, B> const SlicePartialEq<B> for [A]
 where
-    A: BytewiseEq<B>,
+    A: ~const BytewiseEq<B>,
 {
     fn equal(&self, other: &[B]) -> bool {
         if self.len() != other.len() {
diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs
index 42ffc591b5b..d0f2b9226bf 100644
--- a/library/core/src/str/traits.rs
+++ b/library/core/src/str/traits.rs
@@ -23,7 +23,8 @@ impl Ord for str {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq for str {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const PartialEq for str {
     #[inline]
     fn eq(&self, other: &str) -> bool {
         self.as_bytes() == other.as_bytes()
diff --git a/tests/ui/consts/const-compare-bytes-ub.rs b/tests/ui/consts/const-compare-bytes-ub.rs
index 0bc8585a4ee..7e3df92a2bf 100644
--- a/tests/ui/consts/const-compare-bytes-ub.rs
+++ b/tests/ui/consts/const-compare-bytes-ub.rs
@@ -1,6 +1,6 @@
 //@ check-fail
 
-#![feature(core_intrinsics)]
+#![feature(core_intrinsics, const_cmp)]
 use std::intrinsics::compare_bytes;
 use std::mem::MaybeUninit;
 
diff --git a/tests/ui/consts/const-compare-bytes.rs b/tests/ui/consts/const-compare-bytes.rs
index cd5cdfd0400..9563375555c 100644
--- a/tests/ui/consts/const-compare-bytes.rs
+++ b/tests/ui/consts/const-compare-bytes.rs
@@ -1,6 +1,6 @@
 //@ run-pass
 
-#![feature(core_intrinsics)]
+#![feature(core_intrinsics, const_cmp)]
 use std::intrinsics::compare_bytes;
 
 fn main() {
diff --git a/tests/ui/traits/const-traits/const-impl-trait.rs b/tests/ui/traits/const-traits/const-impl-trait.rs
index dc960422a4a..da28d9a47c3 100644
--- a/tests/ui/traits/const-traits/const-impl-trait.rs
+++ b/tests/ui/traits/const-traits/const-impl-trait.rs
@@ -1,7 +1,7 @@
 //@ compile-flags: -Znext-solver
 //@ known-bug: #110395
 
-// Broken until we have `const PartialEq` impl in stdlib
+// Broken until `(): const PartialEq`
 
 #![allow(incomplete_features)]
 #![feature(const_trait_impl, const_cmp, const_destruct)]
diff --git a/tests/ui/traits/const-traits/match-non-const-eq.gated.stderr b/tests/ui/traits/const-traits/match-non-const-eq.gated.stderr
deleted file mode 100644
index 89e59e5db6e..00000000000
--- a/tests/ui/traits/const-traits/match-non-const-eq.gated.stderr
+++ /dev/null
@@ -1,12 +0,0 @@
-error[E0015]: cannot match on `str` in constant functions
-  --> $DIR/match-non-const-eq.rs:7:9
-   |
-LL |         "a" => (), //FIXME [gated]~ ERROR can't compare `str` with `str` in const contexts
-   |         ^^^
-   |
-   = note: `str` cannot be compared in compile-time, and therefore cannot be used in `match`es
-   = 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 E0015`.
diff --git a/tests/ui/traits/const-traits/match-non-const-eq.rs b/tests/ui/traits/const-traits/match-non-const-eq.rs
index 73f8af86bd0..03adb8dc5a4 100644
--- a/tests/ui/traits/const-traits/match-non-const-eq.rs
+++ b/tests/ui/traits/const-traits/match-non-const-eq.rs
@@ -1,11 +1,12 @@
-//@ known-bug: #110395
 //@ revisions: stock gated
-#![cfg_attr(gated, feature(const_trait_impl))]
+#![cfg_attr(gated, feature(const_trait_impl, const_cmp))]
+//@[gated] check-pass
 
 const fn foo(input: &'static str) {
     match input {
-        "a" => (), //FIXME [gated]~ ERROR can't compare `str` with `str` in const contexts
-        //FIXME ~^ ERROR cannot match on `str` in constant functions
+        "a" => (),
+        //[stock]~^ ERROR cannot match on `str` in constant functions
+        //[stock]~| ERROR `PartialEq` is not yet stable as a const trait
         _ => (),
     }
 }
diff --git a/tests/ui/traits/const-traits/match-non-const-eq.stock.stderr b/tests/ui/traits/const-traits/match-non-const-eq.stock.stderr
index 89e59e5db6e..5b662447bde 100644
--- a/tests/ui/traits/const-traits/match-non-const-eq.stock.stderr
+++ b/tests/ui/traits/const-traits/match-non-const-eq.stock.stderr
@@ -1,12 +1,26 @@
-error[E0015]: cannot match on `str` in constant functions
+error[E0658]: cannot match on `str` in constant functions
   --> $DIR/match-non-const-eq.rs:7:9
    |
-LL |         "a" => (), //FIXME [gated]~ ERROR can't compare `str` with `str` in const contexts
+LL |         "a" => (),
    |         ^^^
    |
    = note: `str` cannot be compared in compile-time, and therefore cannot be used in `match`es
    = note: calls in constant functions 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 1 previous error
+error: `PartialEq` is not yet stable as a const trait
+  --> $DIR/match-non-const-eq.rs:7:9
+   |
+LL |         "a" => (),
+   |         ^^^
+   |
+help: add `#![feature(const_cmp)]` to the crate attributes to enable
+   |
+LL + #![feature(const_cmp)]
+   |
+
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0658`.
-- 
cgit 1.4.1-3-g733a5


From c37524403827525ed3d7a359b62d7231a80a5992 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Tue, 8 Jul 2025 18:45:11 +0000
Subject: Add test for `default_field_values` and `const_default`

Add a test showing `#![feature(default_field_values)]` using `#[const_trait] trait Default` (`#![feature(const_default)]` + `#![feature(const_trait_impl)]`).
---
 .../const-trait-default-field-value.rs             | 37 ++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 tests/ui/structs/default-field-values/const-trait-default-field-value.rs

diff --git a/tests/ui/structs/default-field-values/const-trait-default-field-value.rs b/tests/ui/structs/default-field-values/const-trait-default-field-value.rs
new file mode 100644
index 00000000000..60c22efabc4
--- /dev/null
+++ b/tests/ui/structs/default-field-values/const-trait-default-field-value.rs
@@ -0,0 +1,37 @@
+//@ check-pass
+
+// Ensure that `default_field_values` and `const_default` interact properly.
+
+#![feature(const_default)]
+#![feature(const_trait_impl)]
+#![feature(default_field_values)]
+#![feature(derive_const)]
+
+#[derive(PartialEq, Eq, Debug)]
+#[derive_const(Default)]
+struct S {
+    r: Option<String> = <Option<_> as Default>::default(),
+    s: String = String::default(),
+    o: Option<String> = Option::<String>::default(),
+    p: std::marker::PhantomData<()> = std::marker::PhantomData::default(),
+    q: Option<String> = <Option<String> as Default>::default(),
+    t: Option<String> = Option::default(),
+    v: Option<String> = const { Option::default() },
+}
+
+const _: S = S { .. };
+const _: S = const { S { .. } };
+const _: S = S::default();
+const _: S = const { S::default() };
+
+fn main() {
+    let s = S { .. };
+    assert_eq!(s.r, None);
+    assert_eq!(&s.s, "");
+    assert_eq!(s.o, None);
+    assert_eq!(s.p, std::marker::PhantomData);
+    assert_eq!(s.q, None);
+    assert_eq!(s.t, None);
+    assert_eq!(s.v, None);
+    assert_eq!(s, S::default());
+}
-- 
cgit 1.4.1-3-g733a5


From 12eedafc38b1d3af02c9c15333d0ba2f1aee1253 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 18 Jun 2025 12:51:47 +0000
Subject: Report the range of uninit bytes in CTFE errors

---
 compiler/rustc_const_eval/src/interpret/validity.rs       |  2 +-
 compiler/rustc_middle/src/mir/interpret/allocation.rs     |  7 +++++--
 .../concurrency/libc_pthread_cond_double_destroy.rs       |  2 +-
 .../concurrency/libc_pthread_cond_double_destroy.stderr   |  9 ++++++++-
 .../concurrency/libc_pthread_condattr_double_destroy.rs   |  2 +-
 .../libc_pthread_condattr_double_destroy.stderr           |  7 ++++++-
 .../concurrency/libc_pthread_mutex_double_destroy.rs      |  2 +-
 .../concurrency/libc_pthread_mutex_double_destroy.stderr  |  9 ++++++++-
 .../concurrency/libc_pthread_mutexattr_double_destroy.rs  |  2 +-
 .../libc_pthread_mutexattr_double_destroy.stderr          |  7 ++++++-
 .../concurrency/libc_pthread_rwlock_double_destroy.rs     |  2 +-
 .../concurrency/libc_pthread_rwlock_double_destroy.stderr | 10 +++++++++-
 .../fail/function_calls/arg_inplace_observe_after.stderr  |  7 ++++++-
 .../function_calls/arg_inplace_observe_during.none.stderr |  7 ++++++-
 .../return_pointer_aliasing_read.none.stderr              |  7 ++++++-
 .../fail/function_calls/return_pointer_on_unwind.stderr   | 15 ++++++++++++++-
 .../fail/intrinsics/ptr_metadata_uninit_slice_data.rs     |  2 +-
 .../fail/intrinsics/ptr_metadata_uninit_slice_data.stderr |  7 ++++++-
 .../fail/intrinsics/ptr_metadata_uninit_slice_len.rs      |  2 +-
 .../fail/intrinsics/ptr_metadata_uninit_slice_len.stderr  |  7 ++++++-
 .../tests/fail/intrinsics/ptr_metadata_uninit_thin.rs     |  2 +-
 .../tests/fail/intrinsics/ptr_metadata_uninit_thin.stderr |  7 ++++++-
 src/tools/miri/tests/fail/read_from_trivial_switch.rs     |  2 +-
 src/tools/miri/tests/fail/read_from_trivial_switch.stderr |  7 ++++++-
 src/tools/miri/tests/fail/uninit/padding-enum.stderr      |  8 +++++++-
 src/tools/miri/tests/fail/uninit/padding-pair.stderr      |  7 ++++++-
 src/tools/miri/tests/fail/uninit/padding-struct.stderr    |  7 ++++++-
 src/tools/miri/tests/fail/uninit/padding-wide-ptr.stderr  |  7 ++++++-
 .../miri/tests/fail/uninit/transmute-pair-uninit.stderr   |  7 ++++++-
 src/tools/miri/tests/fail/uninit/uninit_byte_read.stderr  |  7 ++++++-
 src/tools/miri/tests/fail/validity/invalid_int_op.stderr  |  7 ++++++-
 .../min_const_generics/invalid-patterns.32bit.stderr      |  4 ++--
 .../min_const_generics/invalid-patterns.64bit.stderr      |  4 ++--
 tests/ui/consts/const-err-enum-discriminant.stderr        |  2 +-
 .../const-pointer-values-in-various-types.64bit.stderr    |  4 ++--
 tests/ui/consts/const-eval/ub-enum-overwrite.stderr       |  2 +-
 tests/ui/consts/const-eval/ub-enum.stderr                 |  2 +-
 tests/ui/consts/const-eval/ub-nonnull.stderr              |  2 +-
 tests/ui/consts/const-eval/ub-ref-ptr.stderr              |  4 ++--
 tests/ui/consts/const-eval/ub-wide-ptr.stderr             |  4 ++--
 tests/ui/consts/const-eval/union-const-eval-field.stderr  |  2 +-
 tests/ui/consts/const-eval/union-ice.stderr               |  6 +++---
 tests/ui/consts/const-eval/union-ub.32bit.stderr          |  2 +-
 tests/ui/consts/const-eval/union-ub.64bit.stderr          |  2 +-
 tests/ui/type/pattern_types/validity.rs                   |  4 ++--
 tests/ui/type/pattern_types/validity.stderr               |  4 ++--
 46 files changed, 175 insertions(+), 56 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 62f591ceaa9..693b3782960 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -394,7 +394,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
         interp_ok(try_validation!(
             self.ecx.read_immediate(val),
             self.path,
-            Ub(InvalidUninitBytes(None)) =>
+            Ub(InvalidUninitBytes(_)) =>
                 Uninit { expected },
             // The `Unsup` cases can only occur during CTFE
             Unsup(ReadPointerAsInt(_)) =>
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation.rs b/compiler/rustc_middle/src/mir/interpret/allocation.rs
index 133111ff15d..27ead514531 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation.rs
@@ -702,8 +702,11 @@ impl<Prov: Provenance, Extra, Bytes: AllocBytes> Allocation<Prov, Extra, Bytes>
         read_provenance: bool,
     ) -> AllocResult<Scalar<Prov>> {
         // First and foremost, if anything is uninit, bail.
-        if self.init_mask.is_range_initialized(range).is_err() {
-            return Err(AllocError::InvalidUninitBytes(None));
+        if let Err(bad) = self.init_mask.is_range_initialized(range) {
+            return Err(AllocError::InvalidUninitBytes(Some(BadBytesAccess {
+                access: range,
+                bad,
+            })));
         }
 
         // Get the integer part of the result. We HAVE TO check provenance before returning this!
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs
index 047fe07df14..8624e4d28fb 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs
@@ -15,6 +15,6 @@ fn main() {
         libc::pthread_cond_destroy(cond.as_mut_ptr());
 
         libc::pthread_cond_destroy(cond.as_mut_ptr());
-        //~^ ERROR: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+        //~^ ERROR: /Undefined Behavior: reading memory .*, but memory is uninitialized/
     }
 }
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.stderr
index 7abdfa87f75..3318ac7fca5 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs:LL:CC
    |
 LL |         libc::pthread_cond_destroy(cond.as_mut_ptr());
@@ -9,6 +9,13 @@ LL |         libc::pthread_cond_destroy(cond.as_mut_ptr());
    = note: BACKTRACE:
    = note: inside `main` at tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
+ALLOC (stack variable, size: 48, align: 8) {
+    0x00 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x10 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x20 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+}
+
 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-dep/concurrency/libc_pthread_condattr_double_destroy.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.rs
index 90e33d58673..a510ee77cfb 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.rs
@@ -13,6 +13,6 @@ fn main() {
         libc::pthread_condattr_destroy(attr.as_mut_ptr());
 
         libc::pthread_condattr_destroy(attr.as_mut_ptr());
-        //~^ ERROR: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+        //~^ ERROR: /Undefined Behavior: reading memory .*, but memory is uninitialized/
     }
 }
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.stderr
index 28a66253ae8..1971bbc7210 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.rs:LL:CC
    |
 LL |         libc::pthread_condattr_destroy(attr.as_mut_ptr());
@@ -9,6 +9,11 @@ LL |         libc::pthread_condattr_destroy(attr.as_mut_ptr());
    = note: BACKTRACE:
    = note: inside `main` at tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
+ALLOC (stack variable, size: 4, align: 4) {
+    __ __ __ __                                     │ ░░░░
+}
+
 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-dep/concurrency/libc_pthread_mutex_double_destroy.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.rs
index 1792c227e13..71a80292032 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.rs
@@ -16,6 +16,6 @@ fn main() {
         libc::pthread_mutex_destroy(mutex.as_mut_ptr());
 
         libc::pthread_mutex_destroy(mutex.as_mut_ptr());
-        //~^ ERROR: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+        //~^ ERROR: /Undefined Behavior: reading memory .*, but memory is uninitialized/
     }
 }
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.stderr
index e7a6dee0203..251f8036e38 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.rs:LL:CC
    |
 LL |         libc::pthread_mutex_destroy(mutex.as_mut_ptr());
@@ -9,6 +9,13 @@ LL |         libc::pthread_mutex_destroy(mutex.as_mut_ptr());
    = note: BACKTRACE:
    = note: inside `main` at tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
+ALLOC (stack variable, size: 40, align: 8) {
+    0x00 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x10 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x20 │ __ __ __ __ __ __ __ __                         │ ░░░░░░░░
+}
+
 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-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs
index 3711c1f8dc1..28dacc9931a 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs
@@ -12,6 +12,6 @@ fn main() {
         libc::pthread_mutexattr_destroy(attr.as_mut_ptr());
 
         libc::pthread_mutexattr_destroy(attr.as_mut_ptr());
-        //~^ ERROR: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+        //~^ ERROR: /Undefined Behavior: reading memory .*, but memory is uninitialized/
     }
 }
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.stderr
index 0c9ee71de45..b341efb7770 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs:LL:CC
    |
 LL |         libc::pthread_mutexattr_destroy(attr.as_mut_ptr());
@@ -9,6 +9,11 @@ LL |         libc::pthread_mutexattr_destroy(attr.as_mut_ptr());
    = note: BACKTRACE:
    = note: inside `main` at tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
+ALLOC (stack variable, size: 4, align: 4) {
+    __ __ __ __                                     │ ░░░░
+}
+
 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-dep/concurrency/libc_pthread_rwlock_double_destroy.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.rs
index 6a31e972e68..a46a124bf2e 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.rs
@@ -9,6 +9,6 @@ fn main() {
         libc::pthread_rwlock_destroy(&mut lock);
 
         libc::pthread_rwlock_destroy(&mut lock);
-        //~^ ERROR: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+        //~^ ERROR: /Undefined Behavior: reading memory .*, but memory is uninitialized/
     }
 }
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.stderr
index 836f0d060bd..8f388577a27 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.rs:LL:CC
    |
 LL |         libc::pthread_rwlock_destroy(&mut lock);
@@ -9,6 +9,14 @@ LL |         libc::pthread_rwlock_destroy(&mut lock);
    = note: BACKTRACE:
    = note: inside `main` at tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
+ALLOC (stack variable, size: 56, align: 8) {
+    0x00 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x10 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x20 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x30 │ __ __ __ __ __ __ __ __                         │ ░░░░░░░░
+}
+
 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/function_calls/arg_inplace_observe_after.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_after.stderr
index 6a7d9a495f9..3252368ea6d 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_after.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_after.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> tests/fail/function_calls/arg_inplace_observe_after.rs:LL:CC
    |
 LL |             _observe = non_copy.0;
@@ -9,6 +9,11 @@ LL |             _observe = non_copy.0;
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/function_calls/arg_inplace_observe_after.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
+ALLOC (stack variable, size: 4, align: 4) {
+    __ __ __ __                                     │ ░░░░
+}
+
 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/function_calls/arg_inplace_observe_during.none.stderr b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.none.stderr
index 0fc634bb7fc..09a5b9a6496 100644
--- a/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.none.stderr
+++ b/src/tools/miri/tests/fail/function_calls/arg_inplace_observe_during.none.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> tests/fail/function_calls/arg_inplace_observe_during.rs:LL:CC
    |
 LL |     unsafe { ptr.read() };
@@ -14,6 +14,11 @@ note: inside `main`
 LL |             Call(_unit = change_arg(Move(*ptr), ptr), ReturnTo(after_call), UnwindContinue())
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
+ALLOC (stack variable, size: 4, align: 4) {
+    __ __ __ __                                     │ ░░░░
+}
+
 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/function_calls/return_pointer_aliasing_read.none.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.none.stderr
index 746ab2e59ca..24091547258 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.none.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.none.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> tests/fail/function_calls/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |     unsafe { ptr.read() };
@@ -14,6 +14,11 @@ note: inside `main`
 LL |             Call(*ptr = myfun(ptr), ReturnTo(after_call), UnwindContinue())
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
+ALLOC (stack variable, size: 4, align: 4) {
+    __ __ __ __                                     │ ░░░░
+}
+
 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/function_calls/return_pointer_on_unwind.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
index 7747a75d1cf..93720ca7d27 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
@@ -3,7 +3,7 @@ thread 'main' panicked at tests/fail/function_calls/return_pointer_on_unwind.rs:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> tests/fail/function_calls/return_pointer_on_unwind.rs:LL:CC
    |
 LL |     dbg!(x.0);
@@ -15,6 +15,19 @@ LL |     dbg!(x.0);
    = note: inside `main` at RUSTLIB/std/src/macros.rs:LL:CC
    = note: this error originates in the macro `dbg` (in Nightly builds, run with -Z macro-backtrace for more info)
 
+Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
+ALLOC (stack variable, size: 132, align: 4) {
+    0x00 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x10 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x20 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x30 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x40 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x50 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x60 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x70 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
+    0x80 │ __ __ __ __                                     │ ░░░░
+}
+
 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/intrinsics/ptr_metadata_uninit_slice_data.rs b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.rs
index 0c305eed6e1..16f07c7ee99 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.rs
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.rs
@@ -9,7 +9,7 @@ use std::intrinsics::mir::*;
 pub unsafe fn deref_meta(p: *const *const [i32]) -> usize {
     mir! {
         {
-            RET = PtrMetadata(*p); //~ ERROR: Undefined Behavior: using uninitialized data
+            RET = PtrMetadata(*p); //~ ERROR: /Undefined Behavior: .*, but memory is uninitialized/
             Return()
         }
     }
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.stderr
index 1c22876ba43..9bacd80f7d5 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
   --> tests/fail/intrinsics/ptr_metadata_uninit_slice_data.rs:LL:CC
    |
 LL |             RET = PtrMetadata(*p);
@@ -14,6 +14,11 @@ note: inside `main`
 LL |         let _meta = deref_meta(p.as_ptr().cast());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+Uninitialized memory occurred at ALLOC[0x0..0x8], in this allocation:
+ALLOC (stack variable, size: 16, align: 8) {
+    __ __ __ __ __ __ __ __ 04 00 00 00 00 00 00 00 │ ░░░░░░░░........
+}
+
 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/intrinsics/ptr_metadata_uninit_slice_len.rs b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.rs
index a2ffdc92c4e..38db894537b 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.rs
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.rs
@@ -9,7 +9,7 @@ use std::intrinsics::mir::*;
 pub unsafe fn deref_meta(p: *const *const [i32]) -> usize {
     mir! {
         {
-            RET = PtrMetadata(*p); //~ ERROR: Undefined Behavior: using uninitialized data
+            RET = PtrMetadata(*p); //~ ERROR: /Undefined Behavior: .*, but memory is uninitialized/
             Return()
         }
     }
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.stderr
index 00e63b1275f..621325d72ff 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.stderr
@@ -12,7 +12,7 @@ LL |         (*p.as_mut_ptr().cast::<[*const i32; 2]>())[0] = 4 as *const i32;
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/intrinsics/ptr_metadata_uninit_slice_len.rs:LL:CC
 
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x8..0x10], but memory is uninitialized at [0x8..0x10], and this operation requires initialized memory
   --> tests/fail/intrinsics/ptr_metadata_uninit_slice_len.rs:LL:CC
    |
 LL |             RET = PtrMetadata(*p);
@@ -28,6 +28,11 @@ note: inside `main`
 LL |         let _meta = deref_meta(p.as_ptr().cast());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+Uninitialized memory occurred at ALLOC[0x8..0x10], in this allocation:
+ALLOC (stack variable, size: 16, align: 8) {
+    ╾────0x4[wildcard]────╼ __ __ __ __ __ __ __ __ │ ╾──────╼░░░░░░░░
+}
+
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
 error: aborting due to 1 previous error; 1 warning emitted
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.rs b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.rs
index e5a51289a8a..179fd33ed7c 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.rs
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.rs
@@ -9,7 +9,7 @@ use std::intrinsics::mir::*;
 pub unsafe fn deref_meta(p: *const *const i32) -> () {
     mir! {
         {
-            RET = PtrMetadata(*p); //~ ERROR: Undefined Behavior: using uninitialized data
+            RET = PtrMetadata(*p); //~ ERROR: /Undefined Behavior: .*, but memory is uninitialized/
             Return()
         }
     }
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.stderr
index 24066953d79..b0e45242057 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
   --> tests/fail/intrinsics/ptr_metadata_uninit_thin.rs:LL:CC
    |
 LL |             RET = PtrMetadata(*p);
@@ -14,6 +14,11 @@ note: inside `main`
 LL |         let _meta = deref_meta(p.as_ptr());
    |                     ^^^^^^^^^^^^^^^^^^^^^^
 
+Uninitialized memory occurred at ALLOC[0x0..0x8], in this allocation:
+ALLOC (stack variable, size: 8, align: 8) {
+    __ __ __ __ __ __ __ __                         │ ░░░░░░░░
+}
+
 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/read_from_trivial_switch.rs b/src/tools/miri/tests/fail/read_from_trivial_switch.rs
index d34b1cd5820..35117c80b73 100644
--- a/src/tools/miri/tests/fail/read_from_trivial_switch.rs
+++ b/src/tools/miri/tests/fail/read_from_trivial_switch.rs
@@ -10,5 +10,5 @@ fn main() {
     let uninit: MaybeUninit<i32> = MaybeUninit::uninit();
     let bad_ref: &i32 = unsafe { uninit.assume_init_ref() };
     let &(0 | _) = bad_ref;
-    //~^ ERROR: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+    //~^ ERROR: /Undefined Behavior: .*, but memory is uninitialized .* requires initialized memory/
 }
diff --git a/src/tools/miri/tests/fail/read_from_trivial_switch.stderr b/src/tools/miri/tests/fail/read_from_trivial_switch.stderr
index 923d836ee0c..1d0c76c3c08 100644
--- a/src/tools/miri/tests/fail/read_from_trivial_switch.stderr
+++ b/src/tools/miri/tests/fail/read_from_trivial_switch.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> tests/fail/read_from_trivial_switch.rs:LL:CC
    |
 LL |     let &(0 | _) = bad_ref;
@@ -9,6 +9,11 @@ LL |     let &(0 | _) = bad_ref;
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/read_from_trivial_switch.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
+ALLOC (stack variable, size: 4, align: 4) {
+    __ __ __ __                                     │ ░░░░
+}
+
 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/uninit/padding-enum.stderr b/src/tools/miri/tests/fail/uninit/padding-enum.stderr
index a9a5568f4e8..ee3867fc60b 100644
--- a/src/tools/miri/tests/fail/uninit/padding-enum.stderr
+++ b/src/tools/miri/tests/fail/uninit/padding-enum.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x8..0x9], but memory is uninitialized at [0x8..0x9], and this operation requires initialized memory
   --> tests/fail/uninit/padding-enum.rs:LL:CC
    |
 LL |         let _val = *c.add(padding_offset);
@@ -9,6 +9,12 @@ LL |         let _val = *c.add(padding_offset);
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/uninit/padding-enum.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x8..0x9], in this allocation:
+ALLOC (stack variable, size: 24, align: 8) {
+    0x00 │ 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ __ │ ........░░░░░░░░
+    0x10 │ __ __ __ __ __ __ __ __                         │ ░░░░░░░░
+}
+
 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/uninit/padding-pair.stderr b/src/tools/miri/tests/fail/uninit/padding-pair.stderr
index d281a351d41..a9841815de3 100644
--- a/src/tools/miri/tests/fail/uninit/padding-pair.stderr
+++ b/src/tools/miri/tests/fail/uninit/padding-pair.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x9..0xa], but memory is uninitialized at [0x9..0xa], and this operation requires initialized memory
   --> tests/fail/uninit/padding-pair.rs:LL:CC
    |
 LL |     let v = unsafe { *z.offset(first_undef) };
@@ -9,6 +9,11 @@ LL |     let v = unsafe { *z.offset(first_undef) };
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/uninit/padding-pair.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x9..0xa], in this allocation:
+ALLOC (stack variable, size: 16, align: 8) {
+    00 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ │ .........░░░░░░░
+}
+
 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/uninit/padding-struct.stderr b/src/tools/miri/tests/fail/uninit/padding-struct.stderr
index 3298f6a4510..05d754625d3 100644
--- a/src/tools/miri/tests/fail/uninit/padding-struct.stderr
+++ b/src/tools/miri/tests/fail/uninit/padding-struct.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x1..0x2], but memory is uninitialized at [0x1..0x2], and this operation requires initialized memory
   --> tests/fail/uninit/padding-struct.rs:LL:CC
    |
 LL |         let _val = *c.add(1);
@@ -9,6 +9,11 @@ LL |         let _val = *c.add(1);
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/uninit/padding-struct.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x1..0x2], in this allocation:
+ALLOC (stack variable, size: 4, align: 2) {
+    00 __ 00 00                                     │ .░..
+}
+
 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/uninit/padding-wide-ptr.stderr b/src/tools/miri/tests/fail/uninit/padding-wide-ptr.stderr
index d92d05ae631..f6446a5a95b 100644
--- a/src/tools/miri/tests/fail/uninit/padding-wide-ptr.stderr
+++ b/src/tools/miri/tests/fail/uninit/padding-wide-ptr.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x8..0x9], but memory is uninitialized at [0x8..0x9], and this operation requires initialized memory
   --> tests/fail/uninit/padding-wide-ptr.rs:LL:CC
    |
 LL |         let _val = *c.add(mem::size_of::<*const u8>());
@@ -9,6 +9,11 @@ LL |         let _val = *c.add(mem::size_of::<*const u8>());
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/uninit/padding-wide-ptr.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x8..0x9], in this allocation:
+ALLOC (stack variable, size: 16, align: 8) {
+    00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ __ │ ........░░░░░░░░
+}
+
 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/uninit/transmute-pair-uninit.stderr b/src/tools/miri/tests/fail/uninit/transmute-pair-uninit.stderr
index 0ae0ce5de9c..385d877e2ee 100644
--- a/src/tools/miri/tests/fail/uninit/transmute-pair-uninit.stderr
+++ b/src/tools/miri/tests/fail/uninit/transmute-pair-uninit.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x9..0xa], but memory is uninitialized at [0x9..0xa], and this operation requires initialized memory
   --> tests/fail/uninit/transmute-pair-uninit.rs:LL:CC
    |
 LL |     let v = unsafe { *z.offset(first_undef) };
@@ -9,6 +9,11 @@ LL |     let v = unsafe { *z.offset(first_undef) };
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/uninit/transmute-pair-uninit.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x9..0xa], in this allocation:
+ALLOC (stack variable, size: 16, align: 8) {
+    00 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ │ .........░░░░░░░
+}
+
 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/uninit/uninit_byte_read.stderr b/src/tools/miri/tests/fail/uninit/uninit_byte_read.stderr
index d2a5a2d3831..5a5aa12987c 100644
--- a/src/tools/miri/tests/fail/uninit/uninit_byte_read.stderr
+++ b/src/tools/miri/tests/fail/uninit/uninit_byte_read.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x5..0x6], but memory is uninitialized at [0x5..0x6], and this operation requires initialized memory
   --> tests/fail/uninit/uninit_byte_read.rs:LL:CC
    |
 LL |     let undef = unsafe { *v.as_ptr().add(5) };
@@ -9,6 +9,11 @@ LL |     let undef = unsafe { *v.as_ptr().add(5) };
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/uninit/uninit_byte_read.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x5..0x6], in this allocation:
+ALLOC (Rust heap, size: 10, align: 1) {
+    __ __ __ __ __ __ __ __ __ __                   │ ░░░░░░░░░░
+}
+
 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_int_op.stderr b/src/tools/miri/tests/fail/validity/invalid_int_op.stderr
index 6e24cadfc20..0b1915621b2 100644
--- a/src/tools/miri/tests/fail/validity/invalid_int_op.stderr
+++ b/src/tools/miri/tests/fail/validity/invalid_int_op.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> tests/fail/validity/invalid_int_op.rs:LL:CC
    |
 LL |     let i = unsafe { std::mem::MaybeUninit::<i32>::uninit().assume_init() };
@@ -9,6 +9,11 @@ LL |     let i = unsafe { std::mem::MaybeUninit::<i32>::uninit().assume_init() }
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/validity/invalid_int_op.rs:LL:CC
 
+Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
+ALLOC (stack variable, size: 4, align: 4) {
+    __ __ __ __                                     │ ░░░░
+}
+
 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/const-generics/min_const_generics/invalid-patterns.32bit.stderr b/tests/ui/const-generics/min_const_generics/invalid-patterns.32bit.stderr
index 92b226fe0f7..107179516bc 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
@@ -1,4 +1,4 @@
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+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
    |
 LL |   get_flag::<false, { unsafe { char_raw.character } }>();
@@ -26,7 +26,7 @@ LL |   get_flag::<{ unsafe { bool_raw.boolean } }, { unsafe { char_raw.character
                42                                              │ B
            }
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC1[0x0..0x4], but memory is uninitialized at [0x1..0x4], and this operation requires initialized memory
   --> $DIR/invalid-patterns.rs:44:58
    |
 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 92b226fe0f7..107179516bc 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
@@ -1,4 +1,4 @@
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+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
    |
 LL |   get_flag::<false, { unsafe { char_raw.character } }>();
@@ -26,7 +26,7 @@ LL |   get_flag::<{ unsafe { bool_raw.boolean } }, { unsafe { char_raw.character
                42                                              │ B
            }
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC1[0x0..0x4], but memory is uninitialized at [0x1..0x4], and this operation requires initialized memory
   --> $DIR/invalid-patterns.rs:44:58
    |
 LL |   get_flag::<{ unsafe { bool_raw.boolean } }, { unsafe { char_raw.character } }>();
diff --git a/tests/ui/consts/const-err-enum-discriminant.stderr b/tests/ui/consts/const-err-enum-discriminant.stderr
index 8724333ad7a..f935d1054de 100644
--- a/tests/ui/consts/const-err-enum-discriminant.stderr
+++ b/tests/ui/consts/const-err-enum-discriminant.stderr
@@ -1,4 +1,4 @@
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC0[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
   --> $DIR/const-err-enum-discriminant.rs:8:21
    |
 LL |     Boo = [unsafe { Foo { b: () }.a }; 4][3],
diff --git a/tests/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr b/tests/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr
index d28d6841ca9..65e846b5741 100644
--- a/tests/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr
+++ b/tests/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr
@@ -43,7 +43,7 @@ LL |     const I32_REF_U64_UNION: u64 = unsafe { Nonsense { int_32_ref: &3 }.uin
    = 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]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC0[0x0..0x10], but memory is uninitialized at [0x8..0x10], and this operation requires initialized memory
   --> $DIR/const-pointer-values-in-various-types.rs:42:47
    |
 LL |     const I32_REF_U128_UNION: u128 = unsafe { Nonsense { int_32_ref: &3 }.uint_128 };
@@ -85,7 +85,7 @@ LL |     const I32_REF_I64_UNION: i64 = unsafe { Nonsense { int_32_ref: &3 }.int
    = 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]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC1[0x0..0x10], but memory is uninitialized at [0x8..0x10], and this operation requires initialized memory
   --> $DIR/const-pointer-values-in-various-types.rs:57:47
    |
 LL |     const I32_REF_I128_UNION: i128 = unsafe { Nonsense { int_32_ref: &3 }.int_128 };
diff --git a/tests/ui/consts/const-eval/ub-enum-overwrite.stderr b/tests/ui/consts/const-eval/ub-enum-overwrite.stderr
index 52af52d3236..14f369eace4 100644
--- a/tests/ui/consts/const-eval/ub-enum-overwrite.stderr
+++ b/tests/ui/consts/const-eval/ub-enum-overwrite.stderr
@@ -1,4 +1,4 @@
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC0[0x1..0x2], but memory is uninitialized at [0x1..0x2], and this operation requires initialized memory
   --> $DIR/ub-enum-overwrite.rs:11:14
    |
 LL |     unsafe { *p }
diff --git a/tests/ui/consts/const-eval/ub-enum.stderr b/tests/ui/consts/const-eval/ub-enum.stderr
index 29f7a1f051a..6665830e250 100644
--- a/tests/ui/consts/const-eval/ub-enum.stderr
+++ b/tests/ui/consts/const-eval/ub-enum.stderr
@@ -56,7 +56,7 @@ LL | const BAD_ENUM2_WRAPPED: Wrap<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]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC0[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
   --> $DIR/ub-enum.rs:61:41
    |
 LL | const BAD_ENUM2_UNDEF: Enum2 = unsafe { MaybeUninit { uninit: () }.init };
diff --git a/tests/ui/consts/const-eval/ub-nonnull.stderr b/tests/ui/consts/const-eval/ub-nonnull.stderr
index 314141e4837..c92797f330a 100644
--- a/tests/ui/consts/const-eval/ub-nonnull.stderr
+++ b/tests/ui/consts/const-eval/ub-nonnull.stderr
@@ -37,7 +37,7 @@ LL | const NULL_USIZE: NonZero<usize> = unsafe { mem::transmute(0usize) };
                HEX_DUMP
            }
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC2[0x0..0x1], but memory is uninitialized at [0x0..0x1], and this operation requires initialized memory
   --> $DIR/ub-nonnull.rs:36:38
    |
 LL | const UNINIT: NonZero<u8> = unsafe { MaybeUninit { uninit: () }.init };
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.stderr b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
index d5ccc396b90..beb54e43534 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.stderr
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
@@ -103,7 +103,7 @@ LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
                HEX_DUMP
            }
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC3[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
   --> $DIR/ub-ref-ptr.rs:48:41
    |
 LL | const UNINIT_PTR: *const i32 = unsafe { MaybeUninit { uninit: () }.init };
@@ -120,7 +120,7 @@ LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
                HEX_DUMP
            }
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC4[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
   --> $DIR/ub-ref-ptr.rs:53:38
    |
 LL | const UNINIT_FN_PTR: fn() = unsafe { MaybeUninit { uninit: () }.init };
diff --git a/tests/ui/consts/const-eval/ub-wide-ptr.stderr b/tests/ui/consts/const-eval/ub-wide-ptr.stderr
index 8724dd9a3c0..a3eb5c72031 100644
--- a/tests/ui/consts/const-eval/ub-wide-ptr.stderr
+++ b/tests/ui/consts/const-eval/ub-wide-ptr.stderr
@@ -71,7 +71,7 @@ LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUni
                HEX_DUMP
            }
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC32[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
   --> $DIR/ub-wide-ptr.rs:63:1
    |
 LL | const SLICE_LENGTH_UNINIT: &[u8] = unsafe {
@@ -179,7 +179,7 @@ note: erroneous constant encountered
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC33[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
   --> $DIR/ub-wide-ptr.rs:101:1
    |
 LL | const RAW_SLICE_LENGTH_UNINIT: *const [u8] = unsafe {
diff --git a/tests/ui/consts/const-eval/union-const-eval-field.stderr b/tests/ui/consts/const-eval/union-const-eval-field.stderr
index 07ff4c3ca36..deddf9e0b6d 100644
--- a/tests/ui/consts/const-eval/union-const-eval-field.stderr
+++ b/tests/ui/consts/const-eval/union-const-eval-field.stderr
@@ -1,4 +1,4 @@
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC0[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
   --> $DIR/union-const-eval-field.rs:28:37
    |
 LL |     const FIELD3: Field3 = unsafe { UNION.field3 };
diff --git a/tests/ui/consts/const-eval/union-ice.stderr b/tests/ui/consts/const-eval/union-ice.stderr
index b00fcc91d68..826d7440a80 100644
--- a/tests/ui/consts/const-eval/union-ice.stderr
+++ b/tests/ui/consts/const-eval/union-ice.stderr
@@ -1,16 +1,16 @@
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC0[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
   --> $DIR/union-ice.rs:14:33
    |
 LL | const FIELD3: Field3 = unsafe { UNION.field3 };
    |                                 ^^^^^^^^^^^^ evaluation of `FIELD3` failed here
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC1[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
   --> $DIR/union-ice.rs:19:17
    |
 LL |     b: unsafe { UNION.field3 },
    |                 ^^^^^^^^^^^^ evaluation of `FIELD_PATH` failed here
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC2[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
   --> $DIR/union-ice.rs:31:18
    |
 LL |         unsafe { UNION.field3 },
diff --git a/tests/ui/consts/const-eval/union-ub.32bit.stderr b/tests/ui/consts/const-eval/union-ub.32bit.stderr
index 9f0697984e4..70bf2cf5390 100644
--- a/tests/ui/consts/const-eval/union-ub.32bit.stderr
+++ b/tests/ui/consts/const-eval/union-ub.32bit.stderr
@@ -9,7 +9,7 @@ LL | const BAD_BOOL: bool = unsafe { DummyUnion { u8: 42 }.bool };
                2a                                              │ *
            }
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC0[0x0..0x1], but memory is uninitialized at [0x0..0x1], and this operation requires initialized memory
   --> $DIR/union-ub.rs:35:36
    |
 LL | const UNINIT_BOOL: bool = unsafe { DummyUnion { unit: () }.bool };
diff --git a/tests/ui/consts/const-eval/union-ub.64bit.stderr b/tests/ui/consts/const-eval/union-ub.64bit.stderr
index 9f0697984e4..70bf2cf5390 100644
--- a/tests/ui/consts/const-eval/union-ub.64bit.stderr
+++ b/tests/ui/consts/const-eval/union-ub.64bit.stderr
@@ -9,7 +9,7 @@ LL | const BAD_BOOL: bool = unsafe { DummyUnion { u8: 42 }.bool };
                2a                                              │ *
            }
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC0[0x0..0x1], but memory is uninitialized at [0x0..0x1], and this operation requires initialized memory
   --> $DIR/union-ub.rs:35:36
    |
 LL | const UNINIT_BOOL: bool = unsafe { DummyUnion { unit: () }.bool };
diff --git a/tests/ui/type/pattern_types/validity.rs b/tests/ui/type/pattern_types/validity.rs
index a4e49692c98..432aacb9be3 100644
--- a/tests/ui/type/pattern_types/validity.rs
+++ b/tests/ui/type/pattern_types/validity.rs
@@ -11,7 +11,7 @@ const BAD: pattern_type!(u32 is 1..) = unsafe { std::mem::transmute(0) };
 //~^ ERROR: constructing invalid value: encountered 0
 
 const BAD_UNINIT: pattern_type!(u32 is 1..) =
-    //~^ ERROR: using uninitialized data, but this operation requires initialized memory
+    //~^ ERROR: this operation requires initialized memory
     unsafe { std::mem::transmute(std::mem::MaybeUninit::<u32>::uninit()) };
 
 const BAD_PTR: pattern_type!(usize is 1..) = unsafe { std::mem::transmute(&42) };
@@ -27,7 +27,7 @@ const BAD_FOO: Foo = Foo(Bar(unsafe { std::mem::transmute(0) }));
 //~^ ERROR: constructing invalid value at .0.0: encountered 0
 
 const CHAR_UNINIT: pattern_type!(char is 'A'..'Z') =
-    //~^ ERROR: using uninitialized data, but this operation requires initialized memory
+    //~^ 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') };
diff --git a/tests/ui/type/pattern_types/validity.stderr b/tests/ui/type/pattern_types/validity.stderr
index 4f4c16028f6..76824055d8a 100644
--- a/tests/ui/type/pattern_types/validity.stderr
+++ b/tests/ui/type/pattern_types/validity.stderr
@@ -9,7 +9,7 @@ LL | const BAD: pattern_type!(u32 is 1..) = unsafe { std::mem::transmute(0) };
                HEX_DUMP
            }
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC0[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> $DIR/validity.rs:13:1
    |
 LL | const BAD_UNINIT: pattern_type!(u32 is 1..) =
@@ -46,7 +46,7 @@ LL | const BAD_FOO: Foo = Foo(Bar(unsafe { std::mem::transmute(0) }));
                HEX_DUMP
            }
 
-error[E0080]: using uninitialized data, but this operation requires initialized memory
+error[E0080]: reading memory at ALLOC1[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
   --> $DIR/validity.rs:29:1
    |
 LL | const CHAR_UNINIT: pattern_type!(char is 'A'..'Z') =
-- 
cgit 1.4.1-3-g733a5


From bf24c0dfa581bffed5e3627c2881e46cc76d4d93 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 17 Jul 2025 22:12:26 +0200
Subject: miri sleep tests: increase slack

---
 src/tools/miri/tests/pass-dep/libc/libc-time.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

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 e8957846ad5..9e9fadfca9e 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-time.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-time.rs
@@ -336,7 +336,7 @@ fn test_nanosleep() {
     let remainder = ptr::null_mut::<libc::timespec>();
     let is_error = unsafe { libc::nanosleep(&duration_zero, remainder) };
     assert_eq!(is_error, 0);
-    assert!(start_test_sleep.elapsed() < Duration::from_millis(10));
+    assert!(start_test_sleep.elapsed() < Duration::from_millis(100));
 
     let start_test_sleep = Instant::now();
     let duration_100_millis = libc::timespec { tv_sec: 0, tv_nsec: 1_000_000_000 / 10 };
@@ -390,7 +390,7 @@ mod test_clock_nanosleep {
             )
         };
         assert_eq!(error, 0);
-        assert!(start_test_sleep.elapsed() < Duration::from_millis(10));
+        assert!(start_test_sleep.elapsed() < Duration::from_millis(100));
 
         let start_test_sleep = Instant::now();
         let hunderd_millis_after_start = add_100_millis(timespec_now(libc::CLOCK_MONOTONIC));
@@ -417,7 +417,7 @@ mod test_clock_nanosleep {
             libc::clock_nanosleep(libc::CLOCK_MONOTONIC, NO_FLAGS, &duration_zero, remainder)
         };
         assert_eq!(error, 0);
-        assert!(start_test_sleep.elapsed() < Duration::from_millis(10));
+        assert!(start_test_sleep.elapsed() < Duration::from_millis(100));
 
         let start_test_sleep = Instant::now();
         let duration_100_millis = libc::timespec { tv_sec: 0, tv_nsec: 1_000_000_000 / 10 };
-- 
cgit 1.4.1-3-g733a5


From 87a27f94b095793a1833a9dacec1493cc6cdcd6b Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sat, 12 Jul 2025 14:53:14 +0000
Subject: Specify of_trait in Target::Impl.

---
 compiler/rustc_hir/src/target.rs                   |  11 +-
 compiler/rustc_passes/messages.ftl                 |   3 +-
 compiler/rustc_passes/src/check_attr.rs            |  18 +-
 compiler/rustc_passes/src/lang_items.rs            |   2 +-
 .../check-doc-alias-attr-location.stderr           |   4 +-
 tests/ui/attributes/positions/used.stderr          |   2 +-
 .../issue-43106-gating-of-builtin-attrs.rs         |   6 +
 .../issue-43106-gating-of-builtin-attrs.stderr     | 258 +++++++++++----------
 tests/ui/lint/unused/unused-attr-duplicate.rs      |   4 +-
 tests/ui/lint/unused/unused-attr-duplicate.stderr  |  36 +--
 .../lint/unused/unused_attributes-must_use.stderr  |   4 +-
 .../rustdoc/check-doc-alias-attr-location.stderr   |   4 +-
 12 files changed, 187 insertions(+), 165 deletions(-)

diff --git a/compiler/rustc_hir/src/target.rs b/compiler/rustc_hir/src/target.rs
index 601898023fc..5e13c8ec11f 100644
--- a/compiler/rustc_hir/src/target.rs
+++ b/compiler/rustc_hir/src/target.rs
@@ -41,7 +41,7 @@ pub enum Target {
     Union,
     Trait,
     TraitAlias,
-    Impl,
+    Impl { of_trait: bool },
     Expression,
     Statement,
     Arm,
@@ -86,7 +86,7 @@ impl Target {
             | Target::Union
             | Target::Trait
             | Target::TraitAlias
-            | Target::Impl
+            | Target::Impl { .. }
             | Target::Expression
             | Target::Statement
             | Target::Arm
@@ -119,7 +119,7 @@ impl Target {
             ItemKind::Union(..) => Target::Union,
             ItemKind::Trait(..) => Target::Trait,
             ItemKind::TraitAlias(..) => Target::TraitAlias,
-            ItemKind::Impl { .. } => Target::Impl,
+            ItemKind::Impl(imp_) => Target::Impl { of_trait: imp_.of_trait.is_some() },
         }
     }
 
@@ -141,7 +141,7 @@ impl Target {
             DefKind::Union => Target::Union,
             DefKind::Trait => Target::Trait,
             DefKind::TraitAlias => Target::TraitAlias,
-            DefKind::Impl { .. } => Target::Impl,
+            DefKind::Impl { of_trait } => Target::Impl { of_trait },
             _ => panic!("impossible case reached"),
         }
     }
@@ -196,7 +196,8 @@ impl Target {
             Target::Union => "union",
             Target::Trait => "trait",
             Target::TraitAlias => "trait alias",
-            Target::Impl => "implementation block",
+            Target::Impl { of_trait: false } => "inherent implementation block",
+            Target::Impl { of_trait: true } => "trait implementation block",
             Target::Expression => "expression",
             Target::Statement => "statement",
             Target::Arm => "match arm",
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index d1b856ca415..51e23edb9bb 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -560,7 +560,8 @@ passes_only_has_effect_on =
     `#[{$attr_name}]` only has an effect on {$target_name ->
         [function] functions
         [module] modules
-        [implementation_block] implementation blocks
+        [trait_implementation_block] trait implementation blocks
+        [inherent_implementation_block] inherent implementation blocks
         *[unspecified] (unspecified--this is a compiler bug)
     }
 
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index d8ffcedeb88..ffa6081d712 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -161,7 +161,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         sym::automatically_derived,
                         *attr_span,
                         target,
-                        Target::Impl,
+                        Target::Impl { of_trait: true },
                     ),
                 Attribute::Parsed(
                     AttributeKind::Stability { span, .. }
@@ -492,7 +492,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         attr: &Attribute,
         item: Option<ItemLike<'_>>,
     ) {
-        if !matches!(target, Target::Impl)
+        if !matches!(target, Target::Impl { .. })
             || matches!(
                 item,
                 Some(ItemLike::Item(hir::Item {  kind: hir::ItemKind::Impl(_impl),.. }))
@@ -596,7 +596,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             Target::Fn
             | Target::Closure
             | Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent)
-            | Target::Impl
+            | Target::Impl { .. }
             | Target::Mod => return,
 
             // These are "functions", but they aren't allowed because they don't
@@ -985,9 +985,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         let span = meta.span();
         if let Some(location) = match target {
             Target::AssocTy => {
-                let parent_def_id = self.tcx.hir_get_parent_item(hir_id).def_id;
-                let containing_item = self.tcx.hir_expect_item(parent_def_id);
-                if Target::from_item(containing_item) == Target::Impl {
+                if let DefKind::Impl { .. } =
+                    self.tcx.def_kind(self.tcx.local_parent(hir_id.owner.def_id))
+                {
                     Some("type alias in implementation block")
                 } else {
                     None
@@ -1010,7 +1010,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             | Target::Arm
             | Target::ForeignMod
             | Target::Closure
-            | Target::Impl
+            | Target::Impl { .. }
             | Target::WherePredicate => Some(target.name()),
             Target::ExternCrate
             | Target::Use
@@ -1588,7 +1588,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         let article = match target {
             Target::ExternCrate
             | Target::Enum
-            | Target::Impl
+            | Target::Impl { .. }
             | Target::Expression
             | Target::Arm
             | Target::AssocConst
@@ -2272,7 +2272,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         match target {
             // FIXME(staged_api): There's no reason we can't support more targets here. We're just
             // being conservative to begin with.
-            Target::Fn | Target::Impl => {}
+            Target::Fn | Target::Impl { .. } => {}
             Target::ExternCrate
             | Target::Use
             | Target::Static
diff --git a/compiler/rustc_passes/src/lang_items.rs b/compiler/rustc_passes/src/lang_items.rs
index 3afed9784de..6fac01827a4 100644
--- a/compiler/rustc_passes/src/lang_items.rs
+++ b/compiler/rustc_passes/src/lang_items.rs
@@ -287,7 +287,7 @@ impl<'ast, 'tcx> visit::Visitor<'ast> for LanguageItemCollector<'ast, 'tcx> {
             ast::ItemKind::Union(..) => Target::Union,
             ast::ItemKind::Trait(_) => Target::Trait,
             ast::ItemKind::TraitAlias(..) => Target::TraitAlias,
-            ast::ItemKind::Impl(_) => Target::Impl,
+            ast::ItemKind::Impl(imp_) => Target::Impl { of_trait: imp_.of_trait.is_some() },
             ast::ItemKind::MacroDef(..) => Target::MacroDef,
             ast::ItemKind::MacCall(_) | ast::ItemKind::DelegationMac(_) => {
                 unreachable!("macros should have been expanded")
diff --git a/tests/rustdoc-ui/check-doc-alias-attr-location.stderr b/tests/rustdoc-ui/check-doc-alias-attr-location.stderr
index 85c9516236c..9d3ce5e63ef 100644
--- a/tests/rustdoc-ui/check-doc-alias-attr-location.stderr
+++ b/tests/rustdoc-ui/check-doc-alias-attr-location.stderr
@@ -4,13 +4,13 @@ error: `#[doc(alias = "...")]` isn't allowed on foreign module
 LL | #[doc(alias = "foo")]
    |       ^^^^^^^^^^^^^
 
-error: `#[doc(alias = "...")]` isn't allowed on implementation block
+error: `#[doc(alias = "...")]` isn't allowed on inherent implementation block
   --> $DIR/check-doc-alias-attr-location.rs:10:7
    |
 LL | #[doc(alias = "bar")]
    |       ^^^^^^^^^^^^^
 
-error: `#[doc(alias = "...")]` isn't allowed on implementation block
+error: `#[doc(alias = "...")]` isn't allowed on trait implementation block
   --> $DIR/check-doc-alias-attr-location.rs:16:7
    |
 LL | #[doc(alias = "foobar")]
diff --git a/tests/ui/attributes/positions/used.stderr b/tests/ui/attributes/positions/used.stderr
index 96dd43a3a93..64460c178cb 100644
--- a/tests/ui/attributes/positions/used.stderr
+++ b/tests/ui/attributes/positions/used.stderr
@@ -28,7 +28,7 @@ error: attribute must be applied to a `static` variable
 LL | #[used]
    | ^^^^^^^
 LL | impl Bar for Foo {}
-   | ------------------- but this is a implementation block
+   | ------------------- but this is a trait implementation block
 
 error: attribute must be applied to a `static` variable
   --> $DIR/used.rs:21:5
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
index d07201ebbd1..9740eaaf1e9 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
@@ -269,7 +269,13 @@ mod automatically_derived {
     #[automatically_derived] type T = S;
     //~^ WARN `#[automatically_derived]
 
+    #[automatically_derived] trait W { }
+    //~^ WARN `#[automatically_derived]
+
     #[automatically_derived] impl S { }
+    //~^ WARN `#[automatically_derived]
+
+    #[automatically_derived] impl W for S { }
 }
 
 #[no_mangle]
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
index 5d7d1caeeab..3271aa0620b 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
@@ -1,5 +1,5 @@
 warning: `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:391:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:397:17
    |
 LL |     mod inner { #![macro_escape] }
    |                 ^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     mod inner { #![macro_escape] }
    = help: try an outer attribute: `#[macro_use]`
 
 warning: `#[macro_escape]` is a deprecated synonym for `#[macro_use]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:388:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:394:1
    |
 LL | #[macro_escape]
    | ^^^^^^^^^^^^^^^
@@ -198,14 +198,14 @@ note: the lint level is defined here
 LL | #![warn(unused_attributes, unknown_lints)]
    |         ^^^^^^^^^^^^^^^^^
 
-warning: `#[automatically_derived]` only has an effect on implementation blocks
+warning: `#[automatically_derived]` only has an effect on trait implementation blocks
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:257:1
    |
 LL | #[automatically_derived]
    | ^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: attribute should be applied to a free function, impl method or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:275:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:281:1
    |
 LL |   #[no_mangle]
    |   ^^^^^^^^^^^^
@@ -220,31 +220,31 @@ LL | | }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: `#[should_panic]` only has an effect on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:315:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:321:1
    |
 LL | #[should_panic]
    | ^^^^^^^^^^^^^^^
 
 warning: `#[ignore]` only has an effect on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:333:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:339:1
    |
 LL | #[ignore]
    | ^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:368:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:374:1
    |
 LL | #[reexport_test_harness_main = "2900"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:408:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:414:1
    |
 LL | #[no_std]
    | ^^^^^^^^^
 
 warning: attribute should be applied to a function definition
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:444:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:450:1
    |
 LL |   #[cold]
    |   ^^^^^^^
@@ -260,7 +260,7 @@ LL | | }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a foreign function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:473:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:479:1
    |
 LL |   #[link_name = "1900"]
    |   ^^^^^^^^^^^^^^^^^^^^^
@@ -276,7 +276,7 @@ LL | | }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:512:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:518:1
    |
 LL |   #[link_section = "1800"]
    |   ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -292,7 +292,7 @@ LL | | }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:544:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:550:1
    |
 LL |   #[link()]
    |   ^^^^^^^^^
@@ -308,55 +308,55 @@ LL | | }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: `#[must_use]` has no effect when applied to a module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:595:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:601:1
    |
 LL | #[must_use]
    | ^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:608:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:614:1
    |
 LL | #[windows_subsystem = "windows"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:629:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:635:1
    |
 LL | #[crate_name = "0900"]
    | ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:648:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:654:1
    |
 LL | #[crate_type = "0800"]
    | ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:667:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:673:1
    |
 LL | #[feature(x0600)]
    | ^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:687:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:693:1
    |
 LL | #[no_main]
    | ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:706:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:712:1
    |
 LL | #[no_builtins]
    | ^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:725:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:731:1
    |
 LL | #[recursion_limit="0200"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:744:1
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:750:1
    |
 LL | #[type_length_limit="0100"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -495,32 +495,44 @@ warning: `#[path]` only has an effect on modules
 LL |     #[path = "3800"] impl S { }
    |     ^^^^^^^^^^^^^^^^
 
-warning: `#[automatically_derived]` only has an effect on implementation blocks
+warning: `#[automatically_derived]` only has an effect on trait implementation blocks
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:260:17
    |
 LL |     mod inner { #![automatically_derived] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: `#[automatically_derived]` only has an effect on implementation blocks
+warning: `#[automatically_derived]` only has an effect on trait implementation blocks
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:263:5
    |
 LL |     #[automatically_derived] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: `#[automatically_derived]` only has an effect on implementation blocks
+warning: `#[automatically_derived]` only has an effect on trait implementation blocks
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:266:5
    |
 LL |     #[automatically_derived] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: `#[automatically_derived]` only has an effect on implementation blocks
+warning: `#[automatically_derived]` only has an effect on trait implementation blocks
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:269:5
    |
 LL |     #[automatically_derived] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
+warning: `#[automatically_derived]` only has an effect on trait implementation blocks
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:272:5
+   |
+LL |     #[automatically_derived] trait W { }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: `#[automatically_derived]` only has an effect on trait implementation blocks
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:275:5
+   |
+LL |     #[automatically_derived] impl S { }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
 warning: attribute should be applied to a free function, impl method or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:280:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:286:17
    |
 LL |     mod inner { #![no_mangle] }
    |     ------------^^^^^^^^^^^^^-- not a free function, impl method or static
@@ -528,7 +540,7 @@ LL |     mod inner { #![no_mangle] }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a free function, impl method or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:287:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:293:5
    |
 LL |     #[no_mangle] struct S;
    |     ^^^^^^^^^^^^ --------- not a free function, impl method or static
@@ -536,7 +548,7 @@ LL |     #[no_mangle] struct S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a free function, impl method or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:292:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:298:5
    |
 LL |     #[no_mangle] type T = S;
    |     ^^^^^^^^^^^^ ----------- not a free function, impl method or static
@@ -544,7 +556,7 @@ LL |     #[no_mangle] type T = S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a free function, impl method or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:297:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:303:5
    |
 LL |     #[no_mangle] impl S { }
    |     ^^^^^^^^^^^^ ---------- not a free function, impl method or static
@@ -552,7 +564,7 @@ LL |     #[no_mangle] impl S { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a free function, impl method or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:303:9
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:309:9
    |
 LL |         #[no_mangle] fn foo();
    |         ^^^^^^^^^^^^ --------- not a free function, impl method or static
@@ -560,7 +572,7 @@ LL |         #[no_mangle] fn foo();
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a free function, impl method or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:308:9
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:314:9
    |
 LL |         #[no_mangle] fn bar() {}
    |         ^^^^^^^^^^^^ ----------- not a free function, impl method or static
@@ -568,163 +580,163 @@ LL |         #[no_mangle] fn bar() {}
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: `#[should_panic]` only has an effect on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:318:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:324:17
    |
 LL |     mod inner { #![should_panic] }
    |                 ^^^^^^^^^^^^^^^^
 
 warning: `#[should_panic]` only has an effect on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:323:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:329:5
    |
 LL |     #[should_panic] struct S;
    |     ^^^^^^^^^^^^^^^
 
 warning: `#[should_panic]` only has an effect on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:326:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:332:5
    |
 LL |     #[should_panic] type T = S;
    |     ^^^^^^^^^^^^^^^
 
 warning: `#[should_panic]` only has an effect on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:329:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:335:5
    |
 LL |     #[should_panic] impl S { }
    |     ^^^^^^^^^^^^^^^
 
 warning: `#[ignore]` only has an effect on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:336:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:342:17
    |
 LL |     mod inner { #![ignore] }
    |                 ^^^^^^^^^^
 
 warning: `#[ignore]` only has an effect on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:341:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:347:5
    |
 LL |     #[ignore] struct S;
    |     ^^^^^^^^^
 
 warning: `#[ignore]` only has an effect on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:344:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:350:5
    |
 LL |     #[ignore] type T = S;
    |     ^^^^^^^^^
 
 warning: `#[ignore]` only has an effect on functions
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:347:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:353:5
    |
 LL |     #[ignore] impl S { }
    |     ^^^^^^^^^
 
 warning: `#[no_implicit_prelude]` only has an effect on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:355:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:361:5
    |
 LL |     #[no_implicit_prelude] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: `#[no_implicit_prelude]` only has an effect on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:358:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:364:5
    |
 LL |     #[no_implicit_prelude] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: `#[no_implicit_prelude]` only has an effect on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:361:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:367:5
    |
 LL |     #[no_implicit_prelude] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: `#[no_implicit_prelude]` only has an effect on modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:364:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:370:5
    |
 LL |     #[no_implicit_prelude] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:371:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:377:17
    |
 LL |     mod inner { #![reexport_test_harness_main="2900"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:374:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:380:5
    |
 LL |     #[reexport_test_harness_main = "2900"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:377:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:383:5
    |
 LL |     #[reexport_test_harness_main = "2900"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:380:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:386:5
    |
 LL |     #[reexport_test_harness_main = "2900"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:383:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:389:5
    |
 LL |     #[reexport_test_harness_main = "2900"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: `#[macro_escape]` only has an effect on `extern crate` and modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:395:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:401:5
    |
 LL |     #[macro_escape] fn f() { }
    |     ^^^^^^^^^^^^^^^
 
 warning: `#[macro_escape]` only has an effect on `extern crate` and modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:398:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:404:5
    |
 LL |     #[macro_escape] struct S;
    |     ^^^^^^^^^^^^^^^
 
 warning: `#[macro_escape]` only has an effect on `extern crate` and modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:401:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:407:5
    |
 LL |     #[macro_escape] type T = S;
    |     ^^^^^^^^^^^^^^^
 
 warning: `#[macro_escape]` only has an effect on `extern crate` and modules
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:404:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:410:5
    |
 LL |     #[macro_escape] impl S { }
    |     ^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:411:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:417:17
    |
 LL |     mod inner { #![no_std] }
    |                 ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:414:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:420:5
    |
 LL |     #[no_std] fn f() { }
    |     ^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:417:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:423:5
    |
 LL |     #[no_std] struct S;
    |     ^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:420:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:426:5
    |
 LL |     #[no_std] type T = S;
    |     ^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:423:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:429:5
    |
 LL |     #[no_std] impl S { }
    |     ^^^^^^^^^
 
 warning: attribute should be applied to a function definition
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:450:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:456:17
    |
 LL |     mod inner { #![cold] }
    |     ------------^^^^^^^^-- not a function definition
@@ -732,7 +744,7 @@ LL |     mod inner { #![cold] }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a function definition
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:457:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:463:5
    |
 LL |     #[cold] struct S;
    |     ^^^^^^^ --------- not a function definition
@@ -740,7 +752,7 @@ LL |     #[cold] struct S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a function definition
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:462:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:468:5
    |
 LL |     #[cold] type T = S;
    |     ^^^^^^^ ----------- not a function definition
@@ -748,7 +760,7 @@ LL |     #[cold] type T = S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a function definition
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:467:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:473:5
    |
 LL |     #[cold] impl S { }
    |     ^^^^^^^ ---------- not a function definition
@@ -756,7 +768,7 @@ LL |     #[cold] impl S { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a foreign function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:479:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:485:5
    |
 LL |     #[link_name = "1900"]
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -766,13 +778,13 @@ LL |     extern "C" { }
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 help: try `#[link(name = "1900")]` instead
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:479:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:485:5
    |
 LL |     #[link_name = "1900"]
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 warning: attribute should be applied to a foreign function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:486:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:492:17
    |
 LL |     mod inner { #![link_name="1900"] }
    |     ------------^^^^^^^^^^^^^^^^^^^^-- not a foreign function or static
@@ -780,7 +792,7 @@ LL |     mod inner { #![link_name="1900"] }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a foreign function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:491:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:497:5
    |
 LL |     #[link_name = "1900"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^ ---------- not a foreign function or static
@@ -788,7 +800,7 @@ LL |     #[link_name = "1900"] fn f() { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a foreign function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:496:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:502:5
    |
 LL |     #[link_name = "1900"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^ --------- not a foreign function or static
@@ -796,7 +808,7 @@ LL |     #[link_name = "1900"] struct S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a foreign function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:501:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:507:5
    |
 LL |     #[link_name = "1900"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^ ----------- not a foreign function or static
@@ -804,7 +816,7 @@ LL |     #[link_name = "1900"] type T = S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a foreign function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:506:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:512:5
    |
 LL |     #[link_name = "1900"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^ ---------- not a foreign function or static
@@ -812,7 +824,7 @@ LL |     #[link_name = "1900"] impl S { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:518:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:524:17
    |
 LL |     mod inner { #![link_section="1800"] }
    |     ------------^^^^^^^^^^^^^^^^^^^^^^^-- not a function or static
@@ -820,7 +832,7 @@ LL |     mod inner { #![link_section="1800"] }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:525:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:531:5
    |
 LL |     #[link_section = "1800"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ --------- not a function or static
@@ -828,7 +840,7 @@ LL |     #[link_section = "1800"] struct S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:530:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:536:5
    |
 LL |     #[link_section = "1800"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ ----------- not a function or static
@@ -836,7 +848,7 @@ LL |     #[link_section = "1800"] type T = S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to a function or static
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:535:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:541:5
    |
 LL |     #[link_section = "1800"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ ---------- not a function or static
@@ -844,7 +856,7 @@ LL |     #[link_section = "1800"] impl S { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:550:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:556:17
    |
 LL |     mod inner { #![link()] }
    |     ------------^^^^^^^^^^-- not an `extern` block
@@ -852,7 +864,7 @@ LL |     mod inner { #![link()] }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:555:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:561:5
    |
 LL |     #[link()] fn f() { }
    |     ^^^^^^^^^ ---------- not an `extern` block
@@ -860,7 +872,7 @@ LL |     #[link()] fn f() { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:560:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:566:5
    |
 LL |     #[link()] struct S;
    |     ^^^^^^^^^ --------- not an `extern` block
@@ -868,7 +880,7 @@ LL |     #[link()] struct S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:565:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:571:5
    |
 LL |     #[link()] type T = S;
    |     ^^^^^^^^^ ----------- not an `extern` block
@@ -876,7 +888,7 @@ LL |     #[link()] type T = S;
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:570:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:576:5
    |
 LL |     #[link()] impl S { }
    |     ^^^^^^^^^ ---------- not an `extern` block
@@ -884,7 +896,7 @@ LL |     #[link()] impl S { }
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: attribute should be applied to an `extern` block with non-Rust ABI
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:575:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:581:5
    |
 LL |     #[link()] extern "Rust" {}
    |     ^^^^^^^^^
@@ -892,259 +904,259 @@ LL |     #[link()] extern "Rust" {}
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
 warning: `#[must_use]` has no effect when applied to a module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:597:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:603:17
    |
 LL |     mod inner { #![must_use] }
    |                 ^^^^^^^^^^^^
 
 warning: `#[must_use]` has no effect when applied to a type alias
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:603:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:609:5
    |
 LL |     #[must_use] type T = S;
    |     ^^^^^^^^^^^
 
-warning: `#[must_use]` has no effect when applied to an implementation block
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:605:5
+warning: `#[must_use]` has no effect when applied to an inherent implementation block
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:611:5
    |
 LL |     #[must_use] impl S { }
    |     ^^^^^^^^^^^
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:611:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:617:17
    |
 LL |     mod inner { #![windows_subsystem="windows"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:614:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:620:5
    |
 LL |     #[windows_subsystem = "windows"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:617:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:623:5
    |
 LL |     #[windows_subsystem = "windows"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:620:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:626:5
    |
 LL |     #[windows_subsystem = "windows"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:623:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:629:5
    |
 LL |     #[windows_subsystem = "windows"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:632:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:638:17
    |
 LL |     mod inner { #![crate_name="0900"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:635:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:641:5
    |
 LL |     #[crate_name = "0900"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:638:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:644:5
    |
 LL |     #[crate_name = "0900"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:641:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:647:5
    |
 LL |     #[crate_name = "0900"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:644:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:650:5
    |
 LL |     #[crate_name = "0900"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:651:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:657:17
    |
 LL |     mod inner { #![crate_type="0800"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:654:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:660:5
    |
 LL |     #[crate_type = "0800"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:657:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:663:5
    |
 LL |     #[crate_type = "0800"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:660:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:666:5
    |
 LL |     #[crate_type = "0800"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:663:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:669:5
    |
 LL |     #[crate_type = "0800"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:670:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:676:17
    |
 LL |     mod inner { #![feature(x0600)] }
    |                 ^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:673:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:679:5
    |
 LL |     #[feature(x0600)] fn f() { }
    |     ^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:676:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:682:5
    |
 LL |     #[feature(x0600)] struct S;
    |     ^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:679:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:685:5
    |
 LL |     #[feature(x0600)] type T = S;
    |     ^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:682:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:688:5
    |
 LL |     #[feature(x0600)] impl S { }
    |     ^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:690:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:696:17
    |
 LL |     mod inner { #![no_main] }
    |                 ^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:693:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:699:5
    |
 LL |     #[no_main] fn f() { }
    |     ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:696:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:702:5
    |
 LL |     #[no_main] struct S;
    |     ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:699:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:705:5
    |
 LL |     #[no_main] type T = S;
    |     ^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:702:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:708:5
    |
 LL |     #[no_main] impl S { }
    |     ^^^^^^^^^^
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:709:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:715:17
    |
 LL |     mod inner { #![no_builtins] }
    |                 ^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:712:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:718:5
    |
 LL |     #[no_builtins] fn f() { }
    |     ^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:715:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:721:5
    |
 LL |     #[no_builtins] struct S;
    |     ^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:718:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:724:5
    |
 LL |     #[no_builtins] type T = S;
    |     ^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:721:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:727:5
    |
 LL |     #[no_builtins] impl S { }
    |     ^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:728:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:734:17
    |
 LL |     mod inner { #![recursion_limit="0200"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:731:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:737:5
    |
 LL |     #[recursion_limit="0200"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:734:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:740:5
    |
 LL |     #[recursion_limit="0200"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:737:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:743:5
    |
 LL |     #[recursion_limit="0200"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:740:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:746:5
    |
 LL |     #[recursion_limit="0200"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be in the root module
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:747:17
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:753:17
    |
 LL |     mod inner { #![type_length_limit="0100"] }
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:750:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:756:5
    |
 LL |     #[type_length_limit="0100"] fn f() { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:753:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:759:5
    |
 LL |     #[type_length_limit="0100"] struct S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:756:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:762:5
    |
 LL |     #[type_length_limit="0100"] type T = S;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:759:5
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:765:5
    |
 LL |     #[type_length_limit="0100"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -1157,5 +1169,5 @@ LL | #![feature(rust1)]
    |
    = note: `#[warn(stable_features)]` on by default
 
-warning: 171 warnings emitted
+warning: 173 warnings emitted
 
diff --git a/tests/ui/lint/unused/unused-attr-duplicate.rs b/tests/ui/lint/unused/unused-attr-duplicate.rs
index bf94a42f6e0..cfa6c2b4228 100644
--- a/tests/ui/lint/unused/unused-attr-duplicate.rs
+++ b/tests/ui/lint/unused/unused-attr-duplicate.rs
@@ -66,9 +66,11 @@ fn t1() {}
 #[non_exhaustive] //~ ERROR unused attribute
 pub struct X;
 
+trait Trait {}
+
 #[automatically_derived]
 #[automatically_derived] //~ ERROR unused attribute
-impl X {}
+impl Trait for X {}
 
 #[inline(always)]
 #[inline(never)] //~ ERROR unused attribute
diff --git a/tests/ui/lint/unused/unused-attr-duplicate.stderr b/tests/ui/lint/unused/unused-attr-duplicate.stderr
index 6db6af823f4..ecc1b7ff5a4 100644
--- a/tests/ui/lint/unused/unused-attr-duplicate.stderr
+++ b/tests/ui/lint/unused/unused-attr-duplicate.stderr
@@ -179,112 +179,112 @@ LL | #[non_exhaustive]
    | ^^^^^^^^^^^^^^^^^
 
 error: unused attribute
-  --> $DIR/unused-attr-duplicate.rs:70:1
+  --> $DIR/unused-attr-duplicate.rs:72:1
    |
 LL | #[automatically_derived]
    | ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:69:1
+  --> $DIR/unused-attr-duplicate.rs:71:1
    |
 LL | #[automatically_derived]
    | ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unused attribute
-  --> $DIR/unused-attr-duplicate.rs:74:1
+  --> $DIR/unused-attr-duplicate.rs:76:1
    |
 LL | #[inline(never)]
    | ^^^^^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:73:1
+  --> $DIR/unused-attr-duplicate.rs:75:1
    |
 LL | #[inline(always)]
    | ^^^^^^^^^^^^^^^^^
    = 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:77:1
+  --> $DIR/unused-attr-duplicate.rs:79:1
    |
 LL | #[cold]
    | ^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:76:1
+  --> $DIR/unused-attr-duplicate.rs:78:1
    |
 LL | #[cold]
    | ^^^^^^^
 
 error: unused attribute
-  --> $DIR/unused-attr-duplicate.rs:79:1
+  --> $DIR/unused-attr-duplicate.rs:81:1
    |
 LL | #[track_caller]
    | ^^^^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:78:1
+  --> $DIR/unused-attr-duplicate.rs:80:1
    |
 LL | #[track_caller]
    | ^^^^^^^^^^^^^^^
 
 error: unused attribute
-  --> $DIR/unused-attr-duplicate.rs:86:5
+  --> $DIR/unused-attr-duplicate.rs:88:5
    |
 LL |     #[link_name = "this_does_not_exist"]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:88:5
+  --> $DIR/unused-attr-duplicate.rs:90: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:92:1
+  --> $DIR/unused-attr-duplicate.rs:94:1
    |
 LL | #[export_name = "exported_symbol_name"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:94:1
+  --> $DIR/unused-attr-duplicate.rs:96: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
-  --> $DIR/unused-attr-duplicate.rs:98:1
+  --> $DIR/unused-attr-duplicate.rs:100:1
    |
 LL | #[no_mangle]
    | ^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:97:1
+  --> $DIR/unused-attr-duplicate.rs:99:1
    |
 LL | #[no_mangle]
    | ^^^^^^^^^^^^
 
 error: unused attribute
-  --> $DIR/unused-attr-duplicate.rs:102:1
+  --> $DIR/unused-attr-duplicate.rs:104:1
    |
 LL | #[used]
    | ^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:101:1
+  --> $DIR/unused-attr-duplicate.rs:103:1
    |
 LL | #[used]
    | ^^^^^^^
 
 error: unused attribute
-  --> $DIR/unused-attr-duplicate.rs:105:1
+  --> $DIR/unused-attr-duplicate.rs:107:1
    |
 LL | #[link_section = ".text"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
    |
 note: attribute also specified here
-  --> $DIR/unused-attr-duplicate.rs:108:1
+  --> $DIR/unused-attr-duplicate.rs:110:1
    |
 LL | #[link_section = ".bss"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/lint/unused/unused_attributes-must_use.stderr b/tests/ui/lint/unused/unused_attributes-must_use.stderr
index 28fd8eeb8cb..862ffa42d80 100644
--- a/tests/ui/lint/unused/unused_attributes-must_use.stderr
+++ b/tests/ui/lint/unused/unused_attributes-must_use.stderr
@@ -45,7 +45,7 @@ error: `#[must_use]` has no effect when applied to a static item
 LL | #[must_use]
    | ^^^^^^^^^^^
 
-error: `#[must_use]` has no effect when applied to an implementation block
+error: `#[must_use]` has no effect when applied to an inherent implementation block
   --> $DIR/unused_attributes-must_use.rs:33:1
    |
 LL | #[must_use]
@@ -69,7 +69,7 @@ error: `#[must_use]` has no effect when applied to a type parameter
 LL | fn qux<#[must_use] T>(_: T) {}
    |        ^^^^^^^^^^^
 
-error: `#[must_use]` has no effect when applied to an implementation block
+error: `#[must_use]` has no effect when applied to an trait implementation block
   --> $DIR/unused_attributes-must_use.rs:79:1
    |
 LL | #[must_use]
diff --git a/tests/ui/rustdoc/check-doc-alias-attr-location.stderr b/tests/ui/rustdoc/check-doc-alias-attr-location.stderr
index 23c93a4ed8b..4244c11eb3e 100644
--- a/tests/ui/rustdoc/check-doc-alias-attr-location.stderr
+++ b/tests/ui/rustdoc/check-doc-alias-attr-location.stderr
@@ -10,13 +10,13 @@ error: `#[doc(alias = "...")]` isn't allowed on foreign module
 LL | #[doc(alias = "foo")]
    |       ^^^^^^^^^^^^^
 
-error: `#[doc(alias = "...")]` isn't allowed on implementation block
+error: `#[doc(alias = "...")]` isn't allowed on inherent implementation block
   --> $DIR/check-doc-alias-attr-location.rs:12:7
    |
 LL | #[doc(alias = "bar")]
    |       ^^^^^^^^^^^^^
 
-error: `#[doc(alias = "...")]` isn't allowed on implementation block
+error: `#[doc(alias = "...")]` isn't allowed on trait implementation block
   --> $DIR/check-doc-alias-attr-location.rs:18:7
    |
 LL | #[doc(alias = "foobar")]
-- 
cgit 1.4.1-3-g733a5


From 0d1aefafa81c98392c4d79d12c246d94552ae7d8 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sat, 12 Jul 2025 14:24:30 +0000
Subject: Warn useless deprecation in check_attr.

---
 compiler/rustc_hir/src/target.rs        | 18 ++++++++++++------
 compiler/rustc_passes/src/check_attr.rs | 27 +++++++++++++++++++++++++--
 compiler/rustc_passes/src/stability.rs  | 16 ++--------------
 3 files changed, 39 insertions(+), 22 deletions(-)

diff --git a/compiler/rustc_hir/src/target.rs b/compiler/rustc_hir/src/target.rs
index 5e13c8ec11f..d617f44f8d8 100644
--- a/compiler/rustc_hir/src/target.rs
+++ b/compiler/rustc_hir/src/target.rs
@@ -51,7 +51,7 @@ pub enum Target {
     ForeignFn,
     ForeignStatic,
     ForeignTy,
-    GenericParam(GenericParamKind),
+    GenericParam { kind: GenericParamKind, has_default: bool },
     MacroDef,
     Param,
     PatField,
@@ -93,7 +93,7 @@ impl Target {
             | Target::ForeignFn
             | Target::ForeignStatic
             | Target::ForeignTy
-            | Target::GenericParam(_)
+            | Target::GenericParam { .. }
             | Target::MacroDef
             | Target::Param
             | Target::PatField
@@ -169,11 +169,17 @@ impl Target {
 
     pub fn from_generic_param(generic_param: &hir::GenericParam<'_>) -> Target {
         match generic_param.kind {
-            hir::GenericParamKind::Type { .. } => Target::GenericParam(GenericParamKind::Type),
+            hir::GenericParamKind::Type { default, .. } => Target::GenericParam {
+                kind: GenericParamKind::Type,
+                has_default: default.is_some(),
+            },
             hir::GenericParamKind::Lifetime { .. } => {
-                Target::GenericParam(GenericParamKind::Lifetime)
+                Target::GenericParam { kind: GenericParamKind::Lifetime, has_default: false }
             }
-            hir::GenericParamKind::Const { .. } => Target::GenericParam(GenericParamKind::Const),
+            hir::GenericParamKind::Const { default, .. } => Target::GenericParam {
+                kind: GenericParamKind::Const,
+                has_default: default.is_some(),
+            },
         }
     }
 
@@ -211,7 +217,7 @@ impl Target {
             Target::ForeignFn => "foreign function",
             Target::ForeignStatic => "foreign static item",
             Target::ForeignTy => "foreign type",
-            Target::GenericParam(kind) => match kind {
+            Target::GenericParam { kind, has_default: _ } => match kind {
                 GenericParamKind::Type => "type parameter",
                 GenericParamKind::Lifetime => "lifetime parameter",
                 GenericParamKind::Const => "const parameter",
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index ffa6081d712..44b7afc88ec 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -36,6 +36,7 @@ use rustc_session::lint;
 use rustc_session::lint::builtin::{
     CONFLICTING_REPR_HINTS, INVALID_DOC_ATTRIBUTES, INVALID_MACRO_EXPORT_ARGUMENTS,
     MALFORMED_DIAGNOSTIC_ATTRIBUTES, MISPLACED_DIAGNOSTIC_ATTRIBUTES, UNUSED_ATTRIBUTES,
+    USELESS_DEPRECATED,
 };
 use rustc_session::parse::feature_err;
 use rustc_span::edition::Edition;
@@ -1031,7 +1032,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             | Target::ForeignFn
             | Target::ForeignStatic
             | Target::ForeignTy
-            | Target::GenericParam(..)
+            | Target::GenericParam { .. }
             | Target::MacroDef
             | Target::PatField
             | Target::ExprField => None,
@@ -2298,7 +2299,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             | Target::ForeignFn
             | Target::ForeignStatic
             | Target::ForeignTy
-            | Target::GenericParam(_)
+            | Target::GenericParam { .. }
             | Target::MacroDef
             | Target::Param
             | Target::PatField
@@ -2352,6 +2353,28 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     errors::Deprecated,
                 );
             }
+            Target::Impl { of_trait: true }
+            | Target::GenericParam { has_default: false, kind: _ } => {
+                self.tcx.emit_node_span_lint(
+                    USELESS_DEPRECATED,
+                    hir_id,
+                    attr.span(),
+                    errors::DeprecatedAnnotationHasNoEffect { span: attr.span() },
+                );
+            }
+            Target::AssocConst | Target::Method(..) | Target::AssocTy
+                if matches!(
+                    self.tcx.def_kind(self.tcx.local_parent(hir_id.owner.def_id)),
+                    DefKind::Impl { of_trait: true }
+                ) =>
+            {
+                self.tcx.emit_node_span_lint(
+                    USELESS_DEPRECATED,
+                    hir_id,
+                    attr.span(),
+                    errors::DeprecatedAnnotationHasNoEffect { span: attr.span() },
+                );
+            }
             _ => {}
         }
     }
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index e5530d52686..0308acc9847 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -27,9 +27,7 @@ use rustc_middle::query::Providers;
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::lint;
-use rustc_session::lint::builtin::{
-    DEPRECATED, INEFFECTIVE_UNSTABLE_TRAIT_IMPL, USELESS_DEPRECATED,
-};
+use rustc_session::lint::builtin::{DEPRECATED, INEFFECTIVE_UNSTABLE_TRAIT_IMPL};
 use rustc_span::{Span, Symbol, sym};
 use tracing::{debug, info};
 
@@ -125,19 +123,9 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         let const_stability_indirect = find_attr!(attrs, AttributeKind::ConstStabilityIndirect);
 
         let mut is_deprecated = false;
-        if let Some((depr, span)) = &depr {
+        if let Some((depr, _)) = &depr {
             is_deprecated = true;
 
-            if matches!(kind, AnnotationKind::Prohibited | AnnotationKind::DeprecationProhibited) {
-                let hir_id = self.tcx.local_def_id_to_hir_id(def_id);
-                self.tcx.emit_node_span_lint(
-                    USELESS_DEPRECATED,
-                    hir_id,
-                    *span,
-                    errors::DeprecatedAnnotationHasNoEffect { span: *span },
-                );
-            }
-
             // `Deprecation` is just two pointers, no need to intern it
             let depr_entry = DeprecationEntry::local(*depr, def_id);
             self.index.depr_map.insert(def_id, depr_entry);
-- 
cgit 1.4.1-3-g733a5


From ce664c57adfed89ab7ebde65cf7c5dd327533725 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Tue, 18 Jan 2022 21:01:07 +0100
Subject: Querify lookup_deprecation_entry.

---
 compiler/rustc_middle/src/middle/stability.rs |  5 --
 compiler/rustc_passes/src/stability.rs        | 79 +++++++++++++--------------
 2 files changed, 39 insertions(+), 45 deletions(-)

diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
index 99faba7b2c0..9c2528ca410 100644
--- a/compiler/rustc_middle/src/middle/stability.rs
+++ b/compiler/rustc_middle/src/middle/stability.rs
@@ -73,7 +73,6 @@ pub struct Index {
     pub stab_map: LocalDefIdMap<Stability>,
     pub const_stab_map: LocalDefIdMap<ConstStability>,
     pub default_body_stab_map: LocalDefIdMap<DefaultBodyStability>,
-    pub depr_map: LocalDefIdMap<DeprecationEntry>,
     /// Mapping from feature name to feature name based on the `implied_by` field of `#[unstable]`
     /// attributes. If a `#[unstable(feature = "implier", implied_by = "impliee")]` attribute
     /// exists, then this map will have a `impliee -> implier` entry.
@@ -101,10 +100,6 @@ impl Index {
     pub fn local_default_body_stability(&self, def_id: LocalDefId) -> Option<DefaultBodyStability> {
         self.default_body_stab_map.get(&def_id).copied()
     }
-
-    pub fn local_deprecation_entry(&self, def_id: LocalDefId) -> Option<DeprecationEntry> {
-        self.depr_map.get(&def_id).cloned()
-    }
 }
 
 pub fn report_unstable(
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 0308acc9847..35332e6e724 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -89,13 +89,40 @@ impl InheritStability {
     }
 }
 
+fn inherit_deprecation(def_kind: DefKind) -> InheritDeprecation {
+    match def_kind {
+        DefKind::LifetimeParam | DefKind::TyParam | DefKind::ConstParam => InheritDeprecation::No,
+        _ => InheritDeprecation::Yes,
+    }
+}
+
+fn lookup_deprecation_entry(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<DeprecationEntry> {
+    let attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(def_id));
+    let depr = attrs::find_attr!(attrs,
+        AttributeKind::Deprecation { deprecation, span: _ } => *deprecation
+    );
+
+    let Some(depr) = depr else {
+        if inherit_deprecation(tcx.def_kind(def_id)).yes() {
+            let parent_id = tcx.opt_local_parent(def_id)?;
+            let parent_depr = tcx.lookup_deprecation_entry(parent_id)?;
+            info!("tagging child {:?} as deprecated from parent", def_id);
+            return Some(parent_depr);
+        }
+
+        return None;
+    };
+
+    // `Deprecation` is just two pointers, no need to intern it
+    Some(DeprecationEntry::local(depr, def_id))
+}
+
 /// A private tree-walker for producing an `Index`.
 struct Annotator<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     index: &'a mut Index,
     parent_stab: Option<Stability>,
     parent_const_stab: Option<ConstStability>,
-    parent_depr: Option<DeprecationEntry>,
     in_trait_impl: bool,
 }
 
@@ -119,24 +146,9 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         let attrs = self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(def_id));
         debug!("annotate(id = {:?}, attrs = {:?})", def_id, attrs);
 
-        let depr = attrs::find_attr!(attrs, AttributeKind::Deprecation{deprecation, span} => (*deprecation, *span));
+        let depr = self.tcx.lookup_deprecation_entry(def_id);
         let const_stability_indirect = find_attr!(attrs, AttributeKind::ConstStabilityIndirect);
 
-        let mut is_deprecated = false;
-        if let Some((depr, _)) = &depr {
-            is_deprecated = true;
-
-            // `Deprecation` is just two pointers, no need to intern it
-            let depr_entry = DeprecationEntry::local(*depr, def_id);
-            self.index.depr_map.insert(def_id, depr_entry);
-        } else if let Some(parent_depr) = self.parent_depr {
-            if inherit_deprecation.yes() {
-                is_deprecated = true;
-                info!("tagging child {:?} as deprecated from parent", def_id);
-                self.index.depr_map.insert(def_id, parent_depr);
-            }
-        }
-
         if !self.tcx.features().staged_api() {
             // Propagate unstability. This can happen even for non-staged-api crates in case
             // -Zforce-unstable-if-unmarked is set.
@@ -152,12 +164,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
                 }
             }
 
-            self.recurse_with_stability_attrs(
-                depr.map(|(d, _)| DeprecationEntry::local(d, def_id)),
-                None,
-                None,
-                visit_children,
-            );
+            self.recurse_with_stability_attrs(None, None, visit_children);
             return;
         }
 
@@ -166,11 +173,14 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         let body_stab =
             attrs::find_attr!(attrs, AttributeKind::BodyStability { stability, .. } => *stability);
 
-        if let Some((depr, span)) = &depr
-            && depr.is_since_rustc_version()
+        if let Some(depr) = &depr
+            && depr.attr.is_since_rustc_version()
             && stab.is_none()
+            && let Some(depr_span) = attrs::find_attr!(attrs,
+                AttributeKind::Deprecation { span, .. } => *span
+            )
         {
-            self.tcx.dcx().emit_err(errors::DeprecatedAttribute { span: *span });
+            self.tcx.dcx().emit_err(errors::DeprecatedAttribute { span: depr_span });
         }
 
         if let Some(body_stab) = body_stab {
@@ -183,7 +193,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         let stab = stab.map(|(stab, span)| {
             // Error if prohibited, or can't inherit anything from a container.
             if kind == AnnotationKind::Prohibited
-                || (kind == AnnotationKind::Container && stab.level.is_stable() && is_deprecated)
+                || (kind == AnnotationKind::Container && stab.level.is_stable() && depr.is_some())
             {
                 self.tcx.dcx().emit_err(errors::UselessStability { span, item_sp });
             }
@@ -195,7 +205,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             if let (
                 &Some(DeprecatedSince::RustcVersion(dep_since)),
                 &attrs::StabilityLevel::Stable { since: stab_since, .. },
-            ) = (&depr.as_ref().map(|(d, _)| d.since), &stab.level)
+            ) = (&depr.as_ref().map(|d| d.attr.since), &stab.level)
             {
                 match stab_since {
                     StableSince::Current => {
@@ -343,7 +353,6 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         }
 
         self.recurse_with_stability_attrs(
-            depr.map(|(d, _)| DeprecationEntry::local(d, def_id)),
             stab,
             inherit_const_stability.yes().then_some(const_stab).flatten(),
             visit_children,
@@ -352,19 +361,14 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
 
     fn recurse_with_stability_attrs(
         &mut self,
-        depr: Option<DeprecationEntry>,
         stab: Option<Stability>,
         const_stab: Option<ConstStability>,
         f: impl FnOnce(&mut Self),
     ) {
         // These will be `Some` if this item changes the corresponding stability attribute.
-        let mut replaced_parent_depr = None;
         let mut replaced_parent_stab = None;
         let mut replaced_parent_const_stab = None;
 
-        if let Some(depr) = depr {
-            replaced_parent_depr = Some(replace(&mut self.parent_depr, Some(depr)));
-        }
         if let Some(stab) = stab {
             replaced_parent_stab = Some(replace(&mut self.parent_stab, Some(stab)));
         }
@@ -375,9 +379,6 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
 
         f(self);
 
-        if let Some(orig_parent_depr) = replaced_parent_depr {
-            self.parent_depr = orig_parent_depr;
-        }
         if let Some(orig_parent_stab) = replaced_parent_stab {
             self.parent_stab = orig_parent_stab;
         }
@@ -679,7 +680,6 @@ fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
         stab_map: Default::default(),
         const_stab_map: Default::default(),
         default_body_stab_map: Default::default(),
-        depr_map: Default::default(),
         implications: Default::default(),
     };
 
@@ -689,7 +689,6 @@ fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
             index: &mut index,
             parent_stab: None,
             parent_const_stab: None,
-            parent_depr: None,
             in_trait_impl: false,
         };
 
@@ -741,7 +740,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         lookup_stability: |tcx, id| tcx.stability().local_stability(id),
         lookup_const_stability: |tcx, id| tcx.stability().local_const_stability(id),
         lookup_default_body_stability: |tcx, id| tcx.stability().local_default_body_stability(id),
-        lookup_deprecation_entry: |tcx, id| tcx.stability().local_deprecation_entry(id),
+        lookup_deprecation_entry,
         ..*providers
     };
 }
-- 
cgit 1.4.1-3-g733a5


From 408d8162a1ed66d4ea2d48ed83fed73349cc295b Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sat, 12 Jul 2025 14:33:04 +0000
Subject: Check stability attributes are compatible in
 `check_unused_or_stable_features`.

---
 compiler/rustc_passes/src/stability.rs             | 342 +++++++++++----------
 .../rustc-const-stability-require-const.stderr     |  48 +--
 2 files changed, 203 insertions(+), 187 deletions(-)

diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 35332e6e724..cd29800cce5 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -6,8 +6,8 @@ use std::num::NonZero;
 
 use rustc_ast_lowering::stability::extern_abi_stability;
 use rustc_attr_data_structures::{
-    self as attrs, AttributeKind, ConstStability, DeprecatedSince, PartialConstStability,
-    Stability, StabilityLevel, StableSince, UnstableReason, VERSION_PLACEHOLDER, find_attr,
+    self as attrs, AttributeKind, ConstStability, DeprecatedSince, Stability, StabilityLevel,
+    StableSince, UnstableReason, VERSION_PLACEHOLDER, find_attr,
 };
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::unord::{ExtendUnord, UnordMap, UnordSet};
@@ -29,7 +29,7 @@ use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::lint;
 use rustc_session::lint::builtin::{DEPRECATED, INEFFECTIVE_UNSTABLE_TRAIT_IMPL};
 use rustc_span::{Span, Symbol, sym};
-use tracing::{debug, info};
+use tracing::{debug, info, instrument};
 
 use crate::errors;
 
@@ -96,6 +96,39 @@ fn inherit_deprecation(def_kind: DefKind) -> InheritDeprecation {
     }
 }
 
+fn annotation_kind(tcx: TyCtxt<'_>, def_id: LocalDefId) -> AnnotationKind {
+    let def_kind = tcx.def_kind(def_id);
+    match def_kind {
+        // Inherent impls and foreign modules serve only as containers for other items,
+        // they don't have their own stability. They still can be annotated as unstable
+        // and propagate this unstability to children, but this annotation is completely
+        // optional. They inherit stability from their parents when unannotated.
+        DefKind::Impl { of_trait: false } | DefKind::ForeignMod => AnnotationKind::Container,
+        DefKind::Impl { of_trait: true } => AnnotationKind::DeprecationProhibited,
+
+        // Allow stability attributes on default generic arguments.
+        DefKind::TyParam | DefKind::ConstParam => {
+            match &tcx.hir_node_by_def_id(def_id).expect_generic_param().kind {
+                hir::GenericParamKind::Type { default: Some(_), .. }
+                | hir::GenericParamKind::Const { default: Some(_), .. } => {
+                    AnnotationKind::Container
+                }
+                _ => AnnotationKind::Prohibited,
+            }
+        }
+
+        // Impl items in trait impls cannot have stability.
+        DefKind::AssocTy | DefKind::AssocFn | DefKind::AssocConst => {
+            match tcx.def_kind(tcx.local_parent(def_id)) {
+                DefKind::Impl { of_trait: true } => AnnotationKind::Prohibited,
+                _ => AnnotationKind::Required,
+            }
+        }
+
+        _ => AnnotationKind::Required,
+    }
+}
+
 fn lookup_deprecation_entry(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<DeprecationEntry> {
     let attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(def_id));
     let depr = attrs::find_attr!(attrs,
@@ -123,7 +156,6 @@ struct Annotator<'a, 'tcx> {
     index: &'a mut Index,
     parent_stab: Option<Stability>,
     parent_const_stab: Option<ConstStability>,
-    in_trait_impl: bool,
 }
 
 impl<'a, 'tcx> Annotator<'a, 'tcx> {
@@ -133,9 +165,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
     fn annotate<F>(
         &mut self,
         def_id: LocalDefId,
-        item_sp: Span,
         fn_sig: Option<&'tcx hir::FnSig<'tcx>>,
-        kind: AnnotationKind,
         inherit_deprecation: InheritDeprecation,
         inherit_const_stability: InheritConstStability,
         inherit_from_parent: InheritStability,
@@ -146,7 +176,6 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         let attrs = self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(def_id));
         debug!("annotate(id = {:?}, attrs = {:?})", def_id, attrs);
 
-        let depr = self.tcx.lookup_deprecation_entry(def_id);
         let const_stability_indirect = find_attr!(attrs, AttributeKind::ConstStabilityIndirect);
 
         if !self.tcx.features().staged_api() {
@@ -169,20 +198,11 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         }
 
         // # Regular and body stability
-        let stab = attrs::find_attr!(attrs, AttributeKind::Stability { stability, span } => (*stability, *span));
+        let stab =
+            attrs::find_attr!(attrs, AttributeKind::Stability { stability, span: _ } => *stability);
         let body_stab =
             attrs::find_attr!(attrs, AttributeKind::BodyStability { stability, .. } => *stability);
 
-        if let Some(depr) = &depr
-            && depr.attr.is_since_rustc_version()
-            && stab.is_none()
-            && let Some(depr_span) = attrs::find_attr!(attrs,
-                AttributeKind::Deprecation { span, .. } => *span
-            )
-        {
-            self.tcx.dcx().emit_err(errors::DeprecatedAttribute { span: depr_span });
-        }
-
         if let Some(body_stab) = body_stab {
             // FIXME: check that this item can have body stability
 
@@ -190,52 +210,9 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             debug!(?self.index.default_body_stab_map);
         }
 
-        let stab = stab.map(|(stab, span)| {
-            // Error if prohibited, or can't inherit anything from a container.
-            if kind == AnnotationKind::Prohibited
-                || (kind == AnnotationKind::Container && stab.level.is_stable() && depr.is_some())
-            {
-                self.tcx.dcx().emit_err(errors::UselessStability { span, item_sp });
-            }
-
+        if let Some(stab) = stab {
             debug!("annotate: found {:?}", stab);
 
-            // Check if deprecated_since < stable_since. If it is,
-            // this is *almost surely* an accident.
-            if let (
-                &Some(DeprecatedSince::RustcVersion(dep_since)),
-                &attrs::StabilityLevel::Stable { since: stab_since, .. },
-            ) = (&depr.as_ref().map(|d| d.attr.since), &stab.level)
-            {
-                match stab_since {
-                    StableSince::Current => {
-                        self.tcx
-                            .dcx()
-                            .emit_err(errors::CannotStabilizeDeprecated { span, item_sp });
-                    }
-                    StableSince::Version(stab_since) => {
-                        if dep_since < stab_since {
-                            self.tcx
-                                .dcx()
-                                .emit_err(errors::CannotStabilizeDeprecated { span, item_sp });
-                        }
-                    }
-                    StableSince::Err => {
-                        // An error already reported. Assume the unparseable stabilization
-                        // version is older than the deprecation version.
-                    }
-                }
-            }
-
-            // Stable *language* features shouldn't be used as unstable library features.
-            // (Not doing this for stable library features is checked by tidy.)
-            if let Stability { level: StabilityLevel::Unstable { .. }, feature } = stab {
-                if ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == feature).is_some() {
-                    self.tcx
-                        .dcx()
-                        .emit_err(errors::UnstableAttrForAlreadyStableFeature { span, item_sp });
-                }
-            }
             if let Stability {
                 level: StabilityLevel::Unstable { implied_by: Some(implied_by), .. },
                 feature,
@@ -245,8 +222,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             }
 
             self.index.stab_map.insert(def_id, stab);
-            stab
-        });
+        }
 
         if stab.is_none() {
             debug!("annotate: stab not found, parent = {:?}", self.parent_stab);
@@ -261,54 +237,12 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
 
         // # Const stability
 
-        let const_stab = attrs::find_attr!(attrs, AttributeKind::ConstStability { stability, span } => (*stability, *span));
-
-        // If the current node is a function with const stability attributes (directly given or
-        // implied), check if the function/method is const or the parent impl block is const.
-        if let Some(fn_sig) = fn_sig
-            && !fn_sig.header.is_const()
-            && const_stab.is_some()
-        {
-            self.tcx.dcx().emit_err(errors::MissingConstErr { fn_sig_span: fn_sig.span });
-        }
-
-        // If this is marked const *stable*, it must also be regular-stable.
-        if let Some((const_stab, const_span)) = const_stab
-            && let Some(fn_sig) = fn_sig
-            && const_stab.is_const_stable()
-            && !stab.is_some_and(|s| s.is_stable())
-        {
-            self.tcx
-                .dcx()
-                .emit_err(errors::ConstStableNotStable { fn_sig_span: fn_sig.span, const_span });
-        }
-
-        // Stable *language* features shouldn't be used as unstable library features.
-        // (Not doing this for stable library features is checked by tidy.)
-        if let Some((
-            PartialConstStability { level: StabilityLevel::Unstable { .. }, feature, .. },
-            const_span,
-        )) = const_stab
-        {
-            if ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == feature).is_some() {
-                self.tcx.dcx().emit_err(errors::UnstableAttrForAlreadyStableFeature {
-                    span: const_span,
-                    item_sp,
-                });
-            }
-        }
-
-        if let Some((stab, span)) = &const_stab
-            && stab.is_const_stable()
-            && const_stability_indirect
-        {
-            self.tcx.dcx().emit_err(errors::RustcConstStableIndirectPairing { span: *span });
-        }
+        let const_stab = attrs::find_attr!(attrs, AttributeKind::ConstStability { stability, span: _ } => *stability);
 
         // After checking the immediate attributes, get rid of the span and compute implied
         // const stability: inherit feature gate from regular stability.
-        let mut const_stab = const_stab
-            .map(|(stab, _span)| ConstStability::from_partial(stab, const_stability_indirect));
+        let mut const_stab =
+            const_stab.map(|stab| ConstStability::from_partial(stab, const_stability_indirect));
 
         // If this is a const fn but not annotated with stability markers, see if we can inherit regular stability.
         if fn_sig.is_some_and(|s| s.header.is_const()) && const_stab.is_none() &&
@@ -399,33 +333,18 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
     }
 
     fn visit_item(&mut self, i: &'tcx Item<'tcx>) {
-        let orig_in_trait_impl = self.in_trait_impl;
-        let mut kind = AnnotationKind::Required;
         let mut const_stab_inherit = InheritConstStability::No;
         let mut fn_sig = None;
 
         match i.kind {
-            // Inherent impls and foreign modules serve only as containers for other items,
-            // they don't have their own stability. They still can be annotated as unstable
-            // and propagate this instability to children, but this annotation is completely
-            // optional. They inherit stability from their parents when unannotated.
-            hir::ItemKind::Impl(hir::Impl { of_trait: None, .. })
-            | hir::ItemKind::ForeignMod { .. } => {
-                self.in_trait_impl = false;
-                kind = AnnotationKind::Container;
-            }
             hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) => {
-                self.in_trait_impl = true;
-                kind = AnnotationKind::DeprecationProhibited;
                 const_stab_inherit = InheritConstStability::Yes;
             }
             hir::ItemKind::Struct(_, _, ref sd) => {
                 if let Some(ctor_def_id) = sd.ctor_def_id() {
                     self.annotate(
                         ctor_def_id,
-                        i.span,
                         None,
-                        AnnotationKind::Required,
                         InheritDeprecation::Yes,
                         InheritConstStability::No,
                         InheritStability::Yes,
@@ -441,15 +360,12 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
 
         self.annotate(
             i.owner_id.def_id,
-            i.span,
             fn_sig,
-            kind,
             InheritDeprecation::Yes,
             const_stab_inherit,
             InheritStability::No,
             |v| intravisit::walk_item(v, i),
         );
-        self.in_trait_impl = orig_in_trait_impl;
     }
 
     fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem<'tcx>) {
@@ -460,9 +376,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
 
         self.annotate(
             ti.owner_id.def_id,
-            ti.span,
             fn_sig,
-            AnnotationKind::Required,
             InheritDeprecation::Yes,
             InheritConstStability::No,
             InheritStability::No,
@@ -473,9 +387,6 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
     }
 
     fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem<'tcx>) {
-        let kind =
-            if self.in_trait_impl { AnnotationKind::Prohibited } else { AnnotationKind::Required };
-
         let fn_sig = match ii.kind {
             hir::ImplItemKind::Fn(ref fn_sig, _) => Some(fn_sig),
             _ => None,
@@ -483,9 +394,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
 
         self.annotate(
             ii.owner_id.def_id,
-            ii.span,
             fn_sig,
-            kind,
             InheritDeprecation::Yes,
             InheritConstStability::No,
             InheritStability::No,
@@ -498,9 +407,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
     fn visit_variant(&mut self, var: &'tcx Variant<'tcx>) {
         self.annotate(
             var.def_id,
-            var.span,
             None,
-            AnnotationKind::Required,
             InheritDeprecation::Yes,
             InheritConstStability::No,
             InheritStability::Yes,
@@ -508,9 +415,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
                 if let Some(ctor_def_id) = var.data.ctor_def_id() {
                     v.annotate(
                         ctor_def_id,
-                        var.span,
                         None,
-                        AnnotationKind::Required,
                         InheritDeprecation::Yes,
                         InheritConstStability::No,
                         InheritStability::Yes,
@@ -526,9 +431,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
     fn visit_field_def(&mut self, s: &'tcx FieldDef<'tcx>) {
         self.annotate(
             s.def_id,
-            s.span,
             None,
-            AnnotationKind::Required,
             InheritDeprecation::Yes,
             InheritConstStability::No,
             InheritStability::Yes,
@@ -545,9 +448,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
         };
         self.annotate(
             i.owner_id.def_id,
-            i.span,
             fn_sig,
-            AnnotationKind::Required,
             InheritDeprecation::Yes,
             InheritConstStability::No,
             InheritStability::No,
@@ -558,18 +459,9 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
     }
 
     fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam<'tcx>) {
-        let kind = match &p.kind {
-            // Allow stability attributes on default generic arguments.
-            hir::GenericParamKind::Type { default: Some(_), .. }
-            | hir::GenericParamKind::Const { default: Some(_), .. } => AnnotationKind::Container,
-            _ => AnnotationKind::Prohibited,
-        };
-
         self.annotate(
             p.def_id,
-            p.span,
             None,
-            kind,
             InheritDeprecation::No,
             InheritConstStability::No,
             InheritStability::No,
@@ -586,6 +478,125 @@ struct MissingStabilityAnnotations<'tcx> {
 }
 
 impl<'tcx> MissingStabilityAnnotations<'tcx> {
+    #[instrument(level = "trace", skip(self))]
+    fn check_compatible_stability(&self, def_id: LocalDefId, item_sp: Span) {
+        if !self.tcx.features().staged_api() {
+            return;
+        }
+
+        let depr = self.tcx.lookup_deprecation_entry(def_id);
+        let stab = self.tcx.lookup_stability(def_id);
+        let const_stab = self.tcx.lookup_const_stability(def_id);
+
+        macro_rules! find_attr_span {
+            ($name:ident) => {{
+                let attrs = self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(def_id));
+                attrs::find_attr!(attrs, AttributeKind::$name { span, .. } => *span)
+            }}
+        }
+
+        if stab.is_none()
+            && depr.map_or(false, |d| d.attr.is_since_rustc_version())
+            && let Some(span) = find_attr_span!(Deprecation)
+        {
+            self.tcx.dcx().emit_err(errors::DeprecatedAttribute { span });
+        }
+
+        if let Some(stab) = stab {
+            // Error if prohibited, or can't inherit anything from a container.
+            let kind = annotation_kind(self.tcx, def_id);
+            if kind == AnnotationKind::Prohibited
+                || (kind == AnnotationKind::Container && stab.level.is_stable() && depr.is_some())
+            {
+                if let Some(span) = find_attr_span!(Stability) {
+                    self.tcx.dcx().emit_err(errors::UselessStability { span, item_sp });
+                }
+            }
+
+            // Check if deprecated_since < stable_since. If it is,
+            // this is *almost surely* an accident.
+            if let Some(depr) = depr
+                && let DeprecatedSince::RustcVersion(dep_since) = depr.attr.since
+                && let attrs::StabilityLevel::Stable { since: stab_since, .. } = stab.level
+                && let Some(span) = find_attr_span!(Stability)
+            {
+                match stab_since {
+                    StableSince::Current => {
+                        self.tcx
+                            .dcx()
+                            .emit_err(errors::CannotStabilizeDeprecated { span, item_sp });
+                    }
+                    StableSince::Version(stab_since) => {
+                        if dep_since < stab_since {
+                            self.tcx
+                                .dcx()
+                                .emit_err(errors::CannotStabilizeDeprecated { span, item_sp });
+                        }
+                    }
+                    StableSince::Err => {
+                        // An error already reported. Assume the unparseable stabilization
+                        // version is older than the deprecation version.
+                    }
+                }
+            }
+
+            // Stable *language* features shouldn't be used as unstable library features.
+            // (Not doing this for stable library features is checked by tidy.)
+            if let Stability { level: StabilityLevel::Unstable { .. }, feature } = stab
+                && ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == feature).is_some()
+                && let Some(span) = find_attr_span!(Stability)
+            {
+                self.tcx
+                    .dcx()
+                    .emit_err(errors::UnstableAttrForAlreadyStableFeature { span, item_sp });
+            }
+        }
+
+        // If the current node is a function with const stability attributes (directly given or
+        // implied), check if the function/method is const or the parent impl block is const.
+        let fn_sig = self.tcx.hir_node_by_def_id(def_id).fn_sig();
+        if let Some(fn_sig) = fn_sig
+            && !fn_sig.header.is_const()
+            && const_stab.is_some()
+            && find_attr_span!(ConstStability).is_some()
+        {
+            self.tcx.dcx().emit_err(errors::MissingConstErr { fn_sig_span: fn_sig.span });
+        }
+
+        // If this is marked const *stable*, it must also be regular-stable.
+        if let Some(const_stab) = const_stab
+            && let Some(fn_sig) = fn_sig
+            && const_stab.is_const_stable()
+            && !stab.is_some_and(|s| s.is_stable())
+            && let Some(const_span) = find_attr_span!(ConstStability)
+        {
+            self.tcx
+                .dcx()
+                .emit_err(errors::ConstStableNotStable { fn_sig_span: fn_sig.span, const_span });
+        }
+
+        // Stable *language* features shouldn't be used as unstable library features.
+        // (Not doing this for stable library features is checked by tidy.)
+        if let Some(ConstStability { level: StabilityLevel::Unstable { .. }, feature, .. }) =
+            const_stab
+            && let Some(const_span) = find_attr_span!(ConstStability)
+            && ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == feature).is_some()
+        {
+            self.tcx.dcx().emit_err(errors::UnstableAttrForAlreadyStableFeature {
+                span: const_span,
+                item_sp,
+            });
+        }
+
+        if let Some(stab) = &const_stab
+            && stab.is_const_stable()
+            && stab.const_stable_indirect
+            && let Some(span) = find_attr_span!(ConstStability)
+        {
+            self.tcx.dcx().emit_err(errors::RustcConstStableIndirectPairing { span });
+        }
+    }
+
     fn check_missing_stability(&self, def_id: LocalDefId, span: Span) {
         let stab = self.tcx.stability().local_stability(def_id);
         if !self.tcx.sess.is_test_crate()
@@ -621,6 +632,8 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
     }
 
     fn visit_item(&mut self, i: &'tcx Item<'tcx>) {
+        self.check_compatible_stability(i.owner_id.def_id, i.span);
+
         // Inherent impls and foreign modules serve only as containers for other items,
         // they don't have their own stability. They still can be annotated as unstable
         // and propagate this instability to children, but this annotation is completely
@@ -640,11 +653,13 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
     }
 
     fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem<'tcx>) {
+        self.check_compatible_stability(ti.owner_id.def_id, ti.span);
         self.check_missing_stability(ti.owner_id.def_id, ti.span);
         intravisit::walk_trait_item(self, ti);
     }
 
     fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem<'tcx>) {
+        self.check_compatible_stability(ii.owner_id.def_id, ii.span);
         let impl_def_id = self.tcx.hir_get_parent_item(ii.hir_id());
         if self.tcx.impl_trait_ref(impl_def_id).is_none() {
             self.check_missing_stability(ii.owner_id.def_id, ii.span);
@@ -654,6 +669,7 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
     }
 
     fn visit_variant(&mut self, var: &'tcx Variant<'tcx>) {
+        self.check_compatible_stability(var.def_id, var.span);
         self.check_missing_stability(var.def_id, var.span);
         if let Some(ctor_def_id) = var.data.ctor_def_id() {
             self.check_missing_stability(ctor_def_id, var.span);
@@ -662,17 +678,24 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
     }
 
     fn visit_field_def(&mut self, s: &'tcx FieldDef<'tcx>) {
+        self.check_compatible_stability(s.def_id, s.span);
         self.check_missing_stability(s.def_id, s.span);
         intravisit::walk_field_def(self, s);
     }
 
     fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem<'tcx>) {
+        self.check_compatible_stability(i.owner_id.def_id, i.span);
         self.check_missing_stability(i.owner_id.def_id, i.span);
         intravisit::walk_foreign_item(self, i);
     }
-    // Note that we don't need to `check_missing_stability` for default generic parameters,
-    // as we assume that any default generic parameters without attributes are automatically
-    // stable (assuming they have not inherited instability from their parent).
+
+    fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam<'tcx>) {
+        self.check_compatible_stability(p.def_id, p.span);
+        // Note that we don't need to `check_missing_stability` for default generic parameters,
+        // as we assume that any default generic parameters without attributes are automatically
+        // stable (assuming they have not inherited instability from their parent).
+        intravisit::walk_generic_param(self, p);
+    }
 }
 
 fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
@@ -684,13 +707,8 @@ fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
     };
 
     {
-        let mut annotator = Annotator {
-            tcx,
-            index: &mut index,
-            parent_stab: None,
-            parent_const_stab: None,
-            in_trait_impl: false,
-        };
+        let mut annotator =
+            Annotator { tcx, index: &mut index, parent_stab: None, parent_const_stab: None };
 
         // If the `-Z force-unstable-if-unmarked` flag is passed then we provide
         // a parent stability annotation which indicates that this is private
@@ -714,9 +732,7 @@ fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
 
         annotator.annotate(
             CRATE_DEF_ID,
-            tcx.hir_span(CRATE_HIR_ID),
             None,
-            AnnotationKind::Required,
             InheritDeprecation::Yes,
             InheritConstStability::No,
             InheritStability::No,
diff --git a/tests/ui/consts/rustc-const-stability-require-const.stderr b/tests/ui/consts/rustc-const-stability-require-const.stderr
index 4b13826584d..8d10bddaa45 100644
--- a/tests/ui/consts/rustc-const-stability-require-const.stderr
+++ b/tests/ui/consts/rustc-const-stability-require-const.stderr
@@ -22,30 +22,6 @@ help: make the function or method const
 LL | pub fn bar() {}
    | ^^^^^^^^^^^^
 
-error: attributes `#[rustc_const_unstable]`, `#[rustc_const_stable]` and `#[rustc_const_stable_indirect]` require the function or method to be `const`
-  --> $DIR/rustc-const-stability-require-const.rs:21:5
-   |
-LL |     pub fn salad(&self) -> &'static str { "mmmmmm" }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: make the function or method const
-  --> $DIR/rustc-const-stability-require-const.rs:21:5
-   |
-LL |     pub fn salad(&self) -> &'static str { "mmmmmm" }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: attributes `#[rustc_const_unstable]`, `#[rustc_const_stable]` and `#[rustc_const_stable_indirect]` require the function or method to be `const`
-  --> $DIR/rustc-const-stability-require-const.rs:26:5
-   |
-LL |     pub fn roasted(&self) -> &'static str { "mmmmmmmmmm" }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: make the function or method const
-  --> $DIR/rustc-const-stability-require-const.rs:26:5
-   |
-LL |     pub fn roasted(&self) -> &'static str { "mmmmmmmmmm" }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: attributes `#[rustc_const_unstable]`, `#[rustc_const_stable]` and `#[rustc_const_stable_indirect]` require the function or method to be `const`
   --> $DIR/rustc-const-stability-require-const.rs:32:1
    |
@@ -86,5 +62,29 @@ LL | #[rustc_const_stable(feature = "barfoo_const", since = "1.0.0")]
 LL | pub const fn barfoo_unstable() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: attributes `#[rustc_const_unstable]`, `#[rustc_const_stable]` and `#[rustc_const_stable_indirect]` require the function or method to be `const`
+  --> $DIR/rustc-const-stability-require-const.rs:21:5
+   |
+LL |     pub fn salad(&self) -> &'static str { "mmmmmm" }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function or method const
+  --> $DIR/rustc-const-stability-require-const.rs:21:5
+   |
+LL |     pub fn salad(&self) -> &'static str { "mmmmmm" }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: attributes `#[rustc_const_unstable]`, `#[rustc_const_stable]` and `#[rustc_const_stable_indirect]` require the function or method to be `const`
+  --> $DIR/rustc-const-stability-require-const.rs:26:5
+   |
+LL |     pub fn roasted(&self) -> &'static str { "mmmmmmmmmm" }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: make the function or method const
+  --> $DIR/rustc-const-stability-require-const.rs:26:5
+   |
+LL |     pub fn roasted(&self) -> &'static str { "mmmmmmmmmm" }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: aborting due to 8 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 4f38864661720311cb0371f2254fa30e300b47c8 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sun, 13 Jul 2025 11:30:30 +0000
Subject: Check for already stable features in check_attr.

---
 compiler/rustc_passes/src/check_attr.rs            | 43 ++++++++++++++++++----
 compiler/rustc_passes/src/errors.rs                |  4 +-
 compiler/rustc_passes/src/stability.rs             | 27 +-------------
 ...ttribute-rejects-already-stable-features.stderr | 22 +++++------
 4 files changed, 51 insertions(+), 45 deletions(-)

diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 44b7afc88ec..7df008133de 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -11,11 +11,17 @@ use std::slice;
 
 use rustc_abi::{Align, ExternAbi, Size};
 use rustc_ast::{AttrStyle, LitKind, MetaItemInner, MetaItemKind, ast, join_path_syms};
-use rustc_attr_data_structures::{AttributeKind, InlineAttr, ReprAttr, find_attr};
+use rustc_attr_data_structures::{
+    AttributeKind, InlineAttr, PartialConstStability, ReprAttr, Stability, StabilityLevel,
+    find_attr,
+};
 use rustc_attr_parsing::{AttributeParser, Late};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Applicability, DiagCtxtHandle, IntoDiagArg, MultiSpan, StashKey};
-use rustc_feature::{AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute};
+use rustc_feature::{
+    ACCEPTED_LANG_FEATURES, AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP,
+    BuiltinAttribute,
+};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalModDefId;
 use rustc_hir::intravisit::{self, Visitor};
@@ -165,9 +171,15 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         Target::Impl { of_trait: true },
                     ),
                 Attribute::Parsed(
-                    AttributeKind::Stability { span, .. }
-                    | AttributeKind::ConstStability { span, .. },
-                ) => self.check_stability_promotable(*span, target),
+                    AttributeKind::Stability {
+                        span: attr_span,
+                        stability: Stability { level, feature },
+                    }
+                    | AttributeKind::ConstStability {
+                        span: attr_span,
+                        stability: PartialConstStability { level, feature, .. },
+                    },
+                ) => self.check_stability(*attr_span, span, level, *feature, target),
                 Attribute::Parsed(AttributeKind::Inline(InlineAttr::Force { .. }, ..)) => {} // handled separately below
                 Attribute::Parsed(AttributeKind::Inline(kind, attr_span)) => {
                     self.check_inline(hir_id, *attr_span, span, kind, target)
@@ -2319,13 +2331,30 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    fn check_stability_promotable(&self, span: Span, target: Target) {
+    fn check_stability(
+        &self,
+        attr_span: Span,
+        item_span: Span,
+        level: &StabilityLevel,
+        feature: Symbol,
+        target: Target,
+    ) {
         match target {
             Target::Expression => {
-                self.dcx().emit_err(errors::StabilityPromotable { attr_span: span });
+                self.dcx().emit_err(errors::StabilityPromotable { attr_span });
             }
             _ => {}
         }
+
+        // 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_link_ordinal(&self, attr_span: Span, _span: Span, target: Target) {
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 37330c0ed6e..c6ab6b0d601 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -1373,9 +1373,9 @@ pub(crate) struct UnstableAttrForAlreadyStableFeature {
     #[primary_span]
     #[label]
     #[help]
-    pub span: Span,
+    pub attr_span: Span,
     #[label(passes_item)]
-    pub item_sp: Span,
+    pub item_span: Span,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index cd29800cce5..6fa1c81e569 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -11,7 +11,7 @@ use rustc_attr_data_structures::{
 };
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::unord::{ExtendUnord, UnordMap, UnordSet};
-use rustc_feature::{ACCEPTED_LANG_FEATURES, EnabledLangFeature, EnabledLibFeature};
+use rustc_feature::{EnabledLangFeature, EnabledLibFeature};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE, LocalDefId, LocalModDefId};
 use rustc_hir::hir_id::CRATE_HIR_ID;
@@ -478,6 +478,7 @@ struct MissingStabilityAnnotations<'tcx> {
 }
 
 impl<'tcx> MissingStabilityAnnotations<'tcx> {
+    /// Verify that deprecation and stability attributes make sense with one another.
     #[instrument(level = "trace", skip(self))]
     fn check_compatible_stability(&self, def_id: LocalDefId, item_sp: Span) {
         if !self.tcx.features().staged_api() {
@@ -539,17 +540,6 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
                     }
                 }
             }
-
-            // Stable *language* features shouldn't be used as unstable library features.
-            // (Not doing this for stable library features is checked by tidy.)
-            if let Stability { level: StabilityLevel::Unstable { .. }, feature } = stab
-                && ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == feature).is_some()
-                && let Some(span) = find_attr_span!(Stability)
-            {
-                self.tcx
-                    .dcx()
-                    .emit_err(errors::UnstableAttrForAlreadyStableFeature { span, item_sp });
-            }
         }
 
         // If the current node is a function with const stability attributes (directly given or
@@ -575,19 +565,6 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
                 .emit_err(errors::ConstStableNotStable { fn_sig_span: fn_sig.span, const_span });
         }
 
-        // Stable *language* features shouldn't be used as unstable library features.
-        // (Not doing this for stable library features is checked by tidy.)
-        if let Some(ConstStability { level: StabilityLevel::Unstable { .. }, feature, .. }) =
-            const_stab
-            && let Some(const_span) = find_attr_span!(ConstStability)
-            && ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == feature).is_some()
-        {
-            self.tcx.dcx().emit_err(errors::UnstableAttrForAlreadyStableFeature {
-                span: const_span,
-                item_sp,
-            });
-        }
-
         if let Some(stab) = &const_stab
             && stab.is_const_stable()
             && stab.const_stable_indirect
diff --git a/tests/ui/feature-gates/unstable-attribute-rejects-already-stable-features.stderr b/tests/ui/feature-gates/unstable-attribute-rejects-already-stable-features.stderr
index 319056a9c88..d599523c727 100644
--- a/tests/ui/feature-gates/unstable-attribute-rejects-already-stable-features.stderr
+++ b/tests/ui/feature-gates/unstable-attribute-rejects-already-stable-features.stderr
@@ -1,31 +1,31 @@
 error: can't mark as unstable using an already stable feature
-  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:6:1
+  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:7:1
    |
-LL | #[unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this feature is already stable
 LL | #[rustc_const_unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this feature is already stable
 LL | const fn my_fun() {}
    | -------------------- the stability attribute annotates this item
    |
 help: consider removing the attribute
-  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:6:1
+  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:7:1
    |
-LL | #[unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #[rustc_const_unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: can't mark as unstable using an already stable feature
-  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:7:1
+  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:6:1
    |
+LL | #[unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this feature is already stable
 LL | #[rustc_const_unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this feature is already stable
 LL | const fn my_fun() {}
    | -------------------- the stability attribute annotates this item
    |
 help: consider removing the attribute
-  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:7:1
+  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:6:1
    |
-LL | #[rustc_const_unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #[unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From f6ef440816235b5737b5d5d6692328395611767c Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Mon, 30 Jan 2023 20:47:11 +0000
Subject: Querify lookup_default_body_stability.

---
 compiler/rustc_middle/src/middle/stability.rs |  5 -----
 compiler/rustc_passes/src/stability.rs        | 32 +++++++++++++++------------
 2 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
index 9c2528ca410..1c90fa66423 100644
--- a/compiler/rustc_middle/src/middle/stability.rs
+++ b/compiler/rustc_middle/src/middle/stability.rs
@@ -72,7 +72,6 @@ pub struct Index {
     /// are filled by the annotator.
     pub stab_map: LocalDefIdMap<Stability>,
     pub const_stab_map: LocalDefIdMap<ConstStability>,
-    pub default_body_stab_map: LocalDefIdMap<DefaultBodyStability>,
     /// Mapping from feature name to feature name based on the `implied_by` field of `#[unstable]`
     /// attributes. If a `#[unstable(feature = "implier", implied_by = "impliee")]` attribute
     /// exists, then this map will have a `impliee -> implier` entry.
@@ -96,10 +95,6 @@ impl Index {
     pub fn local_const_stability(&self, def_id: LocalDefId) -> Option<ConstStability> {
         self.const_stab_map.get(&def_id).copied()
     }
-
-    pub fn local_default_body_stability(&self, def_id: LocalDefId) -> Option<DefaultBodyStability> {
-        self.default_body_stab_map.get(&def_id).copied()
-    }
 }
 
 pub fn report_unstable(
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 6fa1c81e569..5445b930540 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -6,8 +6,8 @@ use std::num::NonZero;
 
 use rustc_ast_lowering::stability::extern_abi_stability;
 use rustc_attr_data_structures::{
-    self as attrs, AttributeKind, ConstStability, DeprecatedSince, Stability, StabilityLevel,
-    StableSince, UnstableReason, VERSION_PLACEHOLDER, find_attr,
+    self as attrs, AttributeKind, ConstStability, DefaultBodyStability, DeprecatedSince, Stability,
+    StabilityLevel, StableSince, UnstableReason, VERSION_PLACEHOLDER, find_attr,
 };
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::unord::{ExtendUnord, UnordMap, UnordSet};
@@ -150,6 +150,20 @@ fn lookup_deprecation_entry(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<Depre
     Some(DeprecationEntry::local(depr, def_id))
 }
 
+#[instrument(level = "debug", skip(tcx))]
+fn lookup_default_body_stability(
+    tcx: TyCtxt<'_>,
+    def_id: LocalDefId,
+) -> Option<DefaultBodyStability> {
+    if !tcx.features().staged_api() {
+        return None;
+    }
+
+    let attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(def_id));
+    // FIXME: check that this item can have body stability
+    attrs::find_attr!(attrs, AttributeKind::BodyStability { stability, .. } => *stability)
+}
+
 /// A private tree-walker for producing an `Index`.
 struct Annotator<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
@@ -197,18 +211,9 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             return;
         }
 
-        // # Regular and body stability
+        // # Regular stability
         let stab =
             attrs::find_attr!(attrs, AttributeKind::Stability { stability, span: _ } => *stability);
-        let body_stab =
-            attrs::find_attr!(attrs, AttributeKind::BodyStability { stability, .. } => *stability);
-
-        if let Some(body_stab) = body_stab {
-            // FIXME: check that this item can have body stability
-
-            self.index.default_body_stab_map.insert(def_id, body_stab);
-            debug!(?self.index.default_body_stab_map);
-        }
 
         if let Some(stab) = stab {
             debug!("annotate: found {:?}", stab);
@@ -679,7 +684,6 @@ fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
     let mut index = Index {
         stab_map: Default::default(),
         const_stab_map: Default::default(),
-        default_body_stab_map: Default::default(),
         implications: Default::default(),
     };
 
@@ -732,7 +736,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         stability_implications: |tcx, _| tcx.stability().implications.clone(),
         lookup_stability: |tcx, id| tcx.stability().local_stability(id),
         lookup_const_stability: |tcx, id| tcx.stability().local_const_stability(id),
-        lookup_default_body_stability: |tcx, id| tcx.stability().local_default_body_stability(id),
+        lookup_default_body_stability,
         lookup_deprecation_entry,
         ..*providers
     };
-- 
cgit 1.4.1-3-g733a5


From 1eeb990e190298fb0b2197d52b7337def6f9215e Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sat, 12 Jul 2025 10:15:25 +0000
Subject: Querify lookup_stability.

---
 compiler/rustc_middle/src/middle/stability.rs |   5 -
 compiler/rustc_passes/src/stability.rs        | 225 ++++++++++++--------------
 2 files changed, 107 insertions(+), 123 deletions(-)

diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
index 1c90fa66423..9ac7ab64474 100644
--- a/compiler/rustc_middle/src/middle/stability.rs
+++ b/compiler/rustc_middle/src/middle/stability.rs
@@ -70,7 +70,6 @@ impl DeprecationEntry {
 pub struct Index {
     /// This is mostly a cache, except the stabilities of local items
     /// are filled by the annotator.
-    pub stab_map: LocalDefIdMap<Stability>,
     pub const_stab_map: LocalDefIdMap<ConstStability>,
     /// Mapping from feature name to feature name based on the `implied_by` field of `#[unstable]`
     /// attributes. If a `#[unstable(feature = "implier", implied_by = "impliee")]` attribute
@@ -88,10 +87,6 @@ pub struct Index {
 }
 
 impl Index {
-    pub fn local_stability(&self, def_id: LocalDefId) -> Option<Stability> {
-        self.stab_map.get(&def_id).copied()
-    }
-
     pub fn local_const_stability(&self, def_id: LocalDefId) -> Option<ConstStability> {
         self.const_stab_map.get(&def_id).copied()
     }
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 5445b930540..3f6414fe962 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -150,6 +150,78 @@ fn lookup_deprecation_entry(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<Depre
     Some(DeprecationEntry::local(depr, def_id))
 }
 
+fn inherit_stability(def_kind: DefKind) -> InheritStability {
+    match def_kind {
+        DefKind::Field | DefKind::Variant | DefKind::Ctor(..) => InheritStability::Yes,
+        _ => InheritStability::No,
+    }
+}
+
+/// If the `-Z force-unstable-if-unmarked` flag is passed then we provide
+/// a parent stability annotation which indicates that this is private
+/// with the `rustc_private` feature. This is intended for use when
+/// compiling `librustc_*` crates themselves so we can leverage crates.io
+/// while maintaining the invariant that all sysroot crates are unstable
+/// by default and are unable to be used.
+const FORCE_UNSTABLE: Stability = Stability {
+    level: attrs::StabilityLevel::Unstable {
+        reason: UnstableReason::Default,
+        issue: NonZero::new(27812),
+        is_soft: false,
+        implied_by: None,
+        old_name: None,
+    },
+    feature: sym::rustc_private,
+};
+
+#[instrument(level = "debug", skip(tcx))]
+fn lookup_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<Stability> {
+    // Propagate unstability. This can happen even for non-staged-api crates in case
+    // -Zforce-unstable-if-unmarked is set.
+    if !tcx.features().staged_api() {
+        if !tcx.sess.opts.unstable_opts.force_unstable_if_unmarked {
+            return None;
+        }
+
+        let Some(parent) = tcx.opt_local_parent(def_id) else { return Some(FORCE_UNSTABLE) };
+
+        if inherit_deprecation(tcx.def_kind(def_id)).yes() {
+            let parent = tcx.lookup_stability(parent)?;
+            if parent.is_unstable() {
+                return Some(parent);
+            }
+        }
+
+        return None;
+    }
+
+    // # Regular stability
+    let attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(def_id));
+    let stab =
+        attrs::find_attr!(attrs, AttributeKind::Stability { stability, span: _ } => *stability);
+
+    if let Some(stab) = stab {
+        return Some(stab);
+    }
+
+    if inherit_deprecation(tcx.def_kind(def_id)).yes() {
+        let Some(parent) = tcx.opt_local_parent(def_id) else {
+            return tcx
+                .sess
+                .opts
+                .unstable_opts
+                .force_unstable_if_unmarked
+                .then_some(FORCE_UNSTABLE);
+        };
+        let parent = tcx.lookup_stability(parent)?;
+        if parent.is_unstable() || inherit_stability(tcx.def_kind(def_id)).yes() {
+            return Some(parent);
+        }
+    }
+
+    None
+}
+
 #[instrument(level = "debug", skip(tcx))]
 fn lookup_default_body_stability(
     tcx: TyCtxt<'_>,
@@ -168,7 +240,6 @@ fn lookup_default_body_stability(
 struct Annotator<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     index: &'a mut Index,
-    parent_stab: Option<Stability>,
     parent_const_stab: Option<ConstStability>,
 }
 
@@ -182,7 +253,6 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         fn_sig: Option<&'tcx hir::FnSig<'tcx>>,
         inherit_deprecation: InheritDeprecation,
         inherit_const_stability: InheritConstStability,
-        inherit_from_parent: InheritStability,
         visit_children: F,
     ) where
         F: FnOnce(&mut Self),
@@ -190,14 +260,16 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         let attrs = self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(def_id));
         debug!("annotate(id = {:?}, attrs = {:?})", def_id, attrs);
 
+        let stab = self.tcx.lookup_stability(def_id);
         let const_stability_indirect = find_attr!(attrs, AttributeKind::ConstStabilityIndirect);
 
         if !self.tcx.features().staged_api() {
             // Propagate unstability. This can happen even for non-staged-api crates in case
             // -Zforce-unstable-if-unmarked is set.
-            if let Some(stab) = self.parent_stab {
+            if let Some(parent_def_id) = self.tcx.opt_local_parent(def_id)
+                && let Some(stab) = self.tcx.lookup_stability(parent_def_id)
+            {
                 if inherit_deprecation.yes() && stab.is_unstable() {
-                    self.index.stab_map.insert(def_id, stab);
                     if fn_sig.is_some_and(|s| s.header.is_const()) {
                         self.index.const_stab_map.insert(
                             def_id,
@@ -207,39 +279,18 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
                 }
             }
 
-            self.recurse_with_stability_attrs(None, None, visit_children);
+            self.recurse_with_stability_attrs(None, visit_children);
             return;
         }
 
-        // # Regular stability
-        let stab =
-            attrs::find_attr!(attrs, AttributeKind::Stability { stability, span: _ } => *stability);
-
-        if let Some(stab) = stab {
-            debug!("annotate: found {:?}", stab);
-
-            if let Stability {
-                level: StabilityLevel::Unstable { implied_by: Some(implied_by), .. },
-                feature,
-            } = stab
-            {
-                self.index.implications.insert(implied_by, feature);
-            }
-
-            self.index.stab_map.insert(def_id, stab);
-        }
-
-        if stab.is_none() {
-            debug!("annotate: stab not found, parent = {:?}", self.parent_stab);
-            if let Some(stab) = self.parent_stab {
-                if inherit_deprecation.yes() && stab.is_unstable() || inherit_from_parent.yes() {
-                    self.index.stab_map.insert(def_id, stab);
-                }
-            }
+        if let Some(Stability {
+            level: StabilityLevel::Unstable { implied_by: Some(implied_by), .. },
+            feature,
+        }) = stab
+        {
+            self.index.implications.insert(implied_by, feature);
         }
 
-        let final_stab = self.index.stab_map.get(&def_id);
-
         // # Const stability
 
         let const_stab = attrs::find_attr!(attrs, AttributeKind::ConstStability { stability, span: _ } => *stability);
@@ -253,7 +304,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         if fn_sig.is_some_and(|s| s.header.is_const()) && const_stab.is_none() &&
             // We only ever inherit unstable features.
             let Some(inherit_regular_stab) =
-                final_stab.filter(|s| s.is_unstable())
+                stab.filter(|s| s.is_unstable())
         {
             const_stab = Some(ConstStability {
                 // We subject these implicitly-const functions to recursive const stability.
@@ -292,7 +343,6 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         }
 
         self.recurse_with_stability_attrs(
-            stab,
             inherit_const_stability.yes().then_some(const_stab).flatten(),
             visit_children,
         );
@@ -300,17 +350,12 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
 
     fn recurse_with_stability_attrs(
         &mut self,
-        stab: Option<Stability>,
         const_stab: Option<ConstStability>,
         f: impl FnOnce(&mut Self),
     ) {
         // These will be `Some` if this item changes the corresponding stability attribute.
-        let mut replaced_parent_stab = None;
         let mut replaced_parent_const_stab = None;
 
-        if let Some(stab) = stab {
-            replaced_parent_stab = Some(replace(&mut self.parent_stab, Some(stab)));
-        }
         if let Some(const_stab) = const_stab {
             replaced_parent_const_stab =
                 Some(replace(&mut self.parent_const_stab, Some(const_stab)));
@@ -318,9 +363,6 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
 
         f(self);
 
-        if let Some(orig_parent_stab) = replaced_parent_stab {
-            self.parent_stab = orig_parent_stab;
-        }
         if let Some(orig_parent_const_stab) = replaced_parent_const_stab {
             self.parent_const_stab = orig_parent_const_stab;
         }
@@ -352,7 +394,6 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
                         None,
                         InheritDeprecation::Yes,
                         InheritConstStability::No,
-                        InheritStability::Yes,
                         |_| {},
                     )
                 }
@@ -368,7 +409,6 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
             fn_sig,
             InheritDeprecation::Yes,
             const_stab_inherit,
-            InheritStability::No,
             |v| intravisit::walk_item(v, i),
         );
     }
@@ -384,7 +424,6 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
             fn_sig,
             InheritDeprecation::Yes,
             InheritConstStability::No,
-            InheritStability::No,
             |v| {
                 intravisit::walk_trait_item(v, ti);
             },
@@ -402,7 +441,6 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
             fn_sig,
             InheritDeprecation::Yes,
             InheritConstStability::No,
-            InheritStability::No,
             |v| {
                 intravisit::walk_impl_item(v, ii);
             },
@@ -410,40 +448,25 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
     }
 
     fn visit_variant(&mut self, var: &'tcx Variant<'tcx>) {
-        self.annotate(
-            var.def_id,
-            None,
-            InheritDeprecation::Yes,
-            InheritConstStability::No,
-            InheritStability::Yes,
-            |v| {
-                if let Some(ctor_def_id) = var.data.ctor_def_id() {
-                    v.annotate(
-                        ctor_def_id,
-                        None,
-                        InheritDeprecation::Yes,
-                        InheritConstStability::No,
-                        InheritStability::Yes,
-                        |_| {},
-                    );
-                }
+        self.annotate(var.def_id, None, InheritDeprecation::Yes, InheritConstStability::No, |v| {
+            if let Some(ctor_def_id) = var.data.ctor_def_id() {
+                v.annotate(
+                    ctor_def_id,
+                    None,
+                    InheritDeprecation::Yes,
+                    InheritConstStability::No,
+                    |_| {},
+                );
+            }
 
-                intravisit::walk_variant(v, var)
-            },
-        )
+            intravisit::walk_variant(v, var)
+        })
     }
 
     fn visit_field_def(&mut self, s: &'tcx FieldDef<'tcx>) {
-        self.annotate(
-            s.def_id,
-            None,
-            InheritDeprecation::Yes,
-            InheritConstStability::No,
-            InheritStability::Yes,
-            |v| {
-                intravisit::walk_field_def(v, s);
-            },
-        );
+        self.annotate(s.def_id, None, InheritDeprecation::Yes, InheritConstStability::No, |v| {
+            intravisit::walk_field_def(v, s);
+        });
     }
 
     fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem<'tcx>) {
@@ -456,7 +479,6 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
             fn_sig,
             InheritDeprecation::Yes,
             InheritConstStability::No,
-            InheritStability::No,
             |v| {
                 intravisit::walk_foreign_item(v, i);
             },
@@ -464,16 +486,9 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
     }
 
     fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam<'tcx>) {
-        self.annotate(
-            p.def_id,
-            None,
-            InheritDeprecation::No,
-            InheritConstStability::No,
-            InheritStability::No,
-            |v| {
-                intravisit::walk_generic_param(v, p);
-            },
-        );
+        self.annotate(p.def_id, None, InheritDeprecation::No, InheritConstStability::No, |v| {
+            intravisit::walk_generic_param(v, p);
+        });
     }
 }
 
@@ -580,7 +595,7 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
     }
 
     fn check_missing_stability(&self, def_id: LocalDefId, span: Span) {
-        let stab = self.tcx.stability().local_stability(def_id);
+        let stab = self.tcx.lookup_stability(def_id);
         if !self.tcx.sess.is_test_crate()
             && stab.is_none()
             && self.effective_visibilities.is_reachable(def_id)
@@ -681,42 +696,16 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
 }
 
 fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
-    let mut index = Index {
-        stab_map: Default::default(),
-        const_stab_map: Default::default(),
-        implications: Default::default(),
-    };
+    let mut index = Index { const_stab_map: Default::default(), implications: Default::default() };
 
     {
-        let mut annotator =
-            Annotator { tcx, index: &mut index, parent_stab: None, parent_const_stab: None };
-
-        // If the `-Z force-unstable-if-unmarked` flag is passed then we provide
-        // a parent stability annotation which indicates that this is private
-        // with the `rustc_private` feature. This is intended for use when
-        // compiling `librustc_*` crates themselves so we can leverage crates.io
-        // while maintaining the invariant that all sysroot crates are unstable
-        // by default and are unable to be used.
-        if tcx.sess.opts.unstable_opts.force_unstable_if_unmarked {
-            let stability = Stability {
-                level: attrs::StabilityLevel::Unstable {
-                    reason: UnstableReason::Default,
-                    issue: NonZero::new(27812),
-                    is_soft: false,
-                    implied_by: None,
-                    old_name: None,
-                },
-                feature: sym::rustc_private,
-            };
-            annotator.parent_stab = Some(stability);
-        }
+        let mut annotator = Annotator { tcx, index: &mut index, parent_const_stab: None };
 
         annotator.annotate(
             CRATE_DEF_ID,
             None,
             InheritDeprecation::Yes,
             InheritConstStability::No,
-            InheritStability::No,
             |v| tcx.hir_walk_toplevel_module(v),
         );
     }
@@ -734,7 +723,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         check_mod_unstable_api_usage,
         stability_index,
         stability_implications: |tcx, _| tcx.stability().implications.clone(),
-        lookup_stability: |tcx, id| tcx.stability().local_stability(id),
+        lookup_stability,
         lookup_const_stability: |tcx, id| tcx.stability().local_const_stability(id),
         lookup_default_body_stability,
         lookup_deprecation_entry,
@@ -1042,7 +1031,7 @@ fn is_unstable_reexport(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
     };
     let def_id = owner.def_id;
 
-    let Some(stab) = tcx.stability().local_stability(def_id) else {
+    let Some(stab) = tcx.lookup_stability(def_id) else {
         return false;
     };
 
-- 
cgit 1.4.1-3-g733a5


From 62bd3c465fcde0b8cd6f0160785ba558548d3951 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sat, 12 Jul 2025 10:41:16 +0000
Subject: Querify lookup_const_stability.

---
 compiler/rustc_middle/src/middle/stability.rs |  11 +-
 compiler/rustc_passes/src/stability.rs        | 284 ++++++++++----------------
 2 files changed, 110 insertions(+), 185 deletions(-)

diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
index 9ac7ab64474..2dcf10deb54 100644
--- a/compiler/rustc_middle/src/middle/stability.rs
+++ b/compiler/rustc_middle/src/middle/stability.rs
@@ -10,7 +10,7 @@ use rustc_attr_data_structures::{
 use rustc_data_structures::unord::UnordMap;
 use rustc_errors::{Applicability, Diag, EmissionGuarantee};
 use rustc_feature::GateIssue;
-use rustc_hir::def_id::{DefId, LocalDefId, LocalDefIdMap};
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{self as hir, HirId};
 use rustc_macros::{Decodable, Encodable, HashStable, Subdiagnostic};
 use rustc_session::Session;
@@ -68,9 +68,6 @@ impl DeprecationEntry {
 /// A stability index, giving the stability level for items and methods.
 #[derive(HashStable, Debug)]
 pub struct Index {
-    /// This is mostly a cache, except the stabilities of local items
-    /// are filled by the annotator.
-    pub const_stab_map: LocalDefIdMap<ConstStability>,
     /// Mapping from feature name to feature name based on the `implied_by` field of `#[unstable]`
     /// attributes. If a `#[unstable(feature = "implier", implied_by = "impliee")]` attribute
     /// exists, then this map will have a `impliee -> implier` entry.
@@ -86,12 +83,6 @@ pub struct Index {
     pub implications: UnordMap<Symbol, Symbol>,
 }
 
-impl Index {
-    pub fn local_const_stability(&self, def_id: LocalDefId) -> Option<ConstStability> {
-        self.const_stab_map.get(&def_id).copied()
-    }
-}
-
 pub fn report_unstable(
     sess: &Session,
     feature: Symbol,
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 3f6414fe962..b47742df12b 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -1,7 +1,6 @@
 //! A pass that annotates every item and method with its stability level,
 //! propagating default levels lexically from parent to children ast nodes.
 
-use std::mem::replace;
 use std::num::NonZero;
 
 use rustc_ast_lowering::stability::extern_abi_stability;
@@ -96,6 +95,19 @@ fn inherit_deprecation(def_kind: DefKind) -> InheritDeprecation {
     }
 }
 
+fn inherit_const_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> InheritConstStability {
+    let def_kind = tcx.def_kind(def_id);
+    match def_kind {
+        DefKind::AssocFn | DefKind::AssocTy | DefKind::AssocConst => {
+            match tcx.def_kind(tcx.local_parent(def_id)) {
+                DefKind::Impl { of_trait: true } => InheritConstStability::Yes,
+                _ => InheritConstStability::No,
+            }
+        }
+        _ => InheritConstStability::No,
+    }
+}
+
 fn annotation_kind(tcx: TyCtxt<'_>, def_id: LocalDefId) -> AnnotationKind {
     let def_kind = tcx.def_kind(def_id);
     match def_kind {
@@ -236,50 +248,96 @@ fn lookup_default_body_stability(
     attrs::find_attr!(attrs, AttributeKind::BodyStability { stability, .. } => *stability)
 }
 
+#[instrument(level = "debug", skip(tcx))]
+fn lookup_const_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ConstStability> {
+    if !tcx.features().staged_api() {
+        // Propagate unstability. This can happen even for non-staged-api crates in case
+        // -Zforce-unstable-if-unmarked is set.
+        if inherit_deprecation(tcx.def_kind(def_id)).yes() {
+            let parent = tcx.opt_local_parent(def_id)?;
+            let parent_stab = tcx.lookup_stability(parent)?;
+            if parent_stab.is_unstable()
+                && let Some(fn_sig) = tcx.hir_node_by_def_id(def_id).fn_sig()
+                && fn_sig.header.is_const()
+            {
+                let attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(def_id));
+                let const_stability_indirect =
+                    find_attr!(attrs, AttributeKind::ConstStabilityIndirect);
+                return Some(ConstStability::unmarked(const_stability_indirect, parent_stab));
+            }
+        }
+
+        return None;
+    }
+
+    let attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(def_id));
+    let const_stability_indirect = find_attr!(attrs, AttributeKind::ConstStabilityIndirect);
+    let const_stab = attrs::find_attr!(attrs, AttributeKind::ConstStability { stability, span: _ } => *stability);
+
+    // After checking the immediate attributes, get rid of the span and compute implied
+    // const stability: inherit feature gate from regular stability.
+    let mut const_stab = const_stab
+        .map(|const_stab| ConstStability::from_partial(const_stab, const_stability_indirect));
+
+    // If this is a const fn but not annotated with stability markers, see if we can inherit regular stability.
+    if let Some(fn_sig) = tcx.hir_node_by_def_id(def_id).fn_sig()
+            && fn_sig.header.is_const()
+            && const_stab.is_none()
+            // We only ever inherit unstable features.
+            && let Some(inherit_regular_stab) = tcx.lookup_stability(def_id)
+            && inherit_regular_stab.is_unstable()
+    {
+        const_stab = Some(ConstStability {
+            // We subject these implicitly-const functions to recursive const stability.
+            const_stable_indirect: true,
+            promotable: false,
+            level: inherit_regular_stab.level,
+            feature: inherit_regular_stab.feature,
+        });
+    }
+
+    // Now that everything is computed, insert it into the table.
+    if let Some(const_stab) = const_stab {
+        return Some(const_stab);
+    }
+
+    // `impl const Trait for Type` items forward their const stability to their
+    // immediate children.
+    // FIXME(const_trait_impl): how is this supposed to interact with `#[rustc_const_stable_indirect]`?
+    // Currently, once that is set, we do not inherit anything from the parent any more.
+    if inherit_const_stability(tcx, def_id).yes() {
+        let parent = tcx.opt_local_parent(def_id)?;
+        let parent = tcx.lookup_const_stability(parent)?;
+        if parent.is_const_unstable() {
+            return Some(parent);
+        }
+    }
+
+    None
+}
+
 /// A private tree-walker for producing an `Index`.
 struct Annotator<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     index: &'a mut Index,
-    parent_const_stab: Option<ConstStability>,
 }
 
 impl<'a, 'tcx> Annotator<'a, 'tcx> {
     /// Determine the stability for a node based on its attributes and inherited stability. The
     /// stability is recorded in the index and used as the parent. If the node is a function,
     /// `fn_sig` is its signature.
-    fn annotate<F>(
-        &mut self,
-        def_id: LocalDefId,
-        fn_sig: Option<&'tcx hir::FnSig<'tcx>>,
-        inherit_deprecation: InheritDeprecation,
-        inherit_const_stability: InheritConstStability,
-        visit_children: F,
-    ) where
+    #[instrument(level = "trace", skip(self, visit_children))]
+    fn annotate<F>(&mut self, def_id: LocalDefId, visit_children: F)
+    where
         F: FnOnce(&mut Self),
     {
         let attrs = self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(def_id));
         debug!("annotate(id = {:?}, attrs = {:?})", def_id, attrs);
 
         let stab = self.tcx.lookup_stability(def_id);
-        let const_stability_indirect = find_attr!(attrs, AttributeKind::ConstStabilityIndirect);
 
         if !self.tcx.features().staged_api() {
-            // Propagate unstability. This can happen even for non-staged-api crates in case
-            // -Zforce-unstable-if-unmarked is set.
-            if let Some(parent_def_id) = self.tcx.opt_local_parent(def_id)
-                && let Some(stab) = self.tcx.lookup_stability(parent_def_id)
-            {
-                if inherit_deprecation.yes() && stab.is_unstable() {
-                    if fn_sig.is_some_and(|s| s.header.is_const()) {
-                        self.index.const_stab_map.insert(
-                            def_id,
-                            ConstStability::unmarked(const_stability_indirect, stab),
-                        );
-                    }
-                }
-            }
-
-            self.recurse_with_stability_attrs(None, visit_children);
+            visit_children(self);
             return;
         }
 
@@ -293,32 +351,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
 
         // # Const stability
 
-        let const_stab = attrs::find_attr!(attrs, AttributeKind::ConstStability { stability, span: _ } => *stability);
-
-        // After checking the immediate attributes, get rid of the span and compute implied
-        // const stability: inherit feature gate from regular stability.
-        let mut const_stab =
-            const_stab.map(|stab| ConstStability::from_partial(stab, const_stability_indirect));
-
-        // If this is a const fn but not annotated with stability markers, see if we can inherit regular stability.
-        if fn_sig.is_some_and(|s| s.header.is_const()) && const_stab.is_none() &&
-            // We only ever inherit unstable features.
-            let Some(inherit_regular_stab) =
-                stab.filter(|s| s.is_unstable())
-        {
-            const_stab = Some(ConstStability {
-                // We subject these implicitly-const functions to recursive const stability.
-                const_stable_indirect: true,
-                promotable: false,
-                level: inherit_regular_stab.level,
-                feature: inherit_regular_stab.feature,
-            });
-        }
-
-        // Now that everything is computed, insert it into the table.
-        const_stab.inspect(|const_stab| {
-            self.index.const_stab_map.insert(def_id, *const_stab);
-        });
+        let const_stab = self.tcx.lookup_const_stability(def_id);
 
         if let Some(ConstStability {
             level: StabilityLevel::Unstable { implied_by: Some(implied_by), .. },
@@ -329,43 +362,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             self.index.implications.insert(implied_by, feature);
         }
 
-        // `impl const Trait for Type` items forward their const stability to their
-        // immediate children.
-        // FIXME(const_trait_impl): how is this supposed to interact with `#[rustc_const_stable_indirect]`?
-        // Currently, once that is set, we do not inherit anything from the parent any more.
-        if const_stab.is_none() {
-            debug!("annotate: const_stab not found, parent = {:?}", self.parent_const_stab);
-            if let Some(parent) = self.parent_const_stab {
-                if parent.is_const_unstable() {
-                    self.index.const_stab_map.insert(def_id, parent);
-                }
-            }
-        }
-
-        self.recurse_with_stability_attrs(
-            inherit_const_stability.yes().then_some(const_stab).flatten(),
-            visit_children,
-        );
-    }
-
-    fn recurse_with_stability_attrs(
-        &mut self,
-        const_stab: Option<ConstStability>,
-        f: impl FnOnce(&mut Self),
-    ) {
-        // These will be `Some` if this item changes the corresponding stability attribute.
-        let mut replaced_parent_const_stab = None;
-
-        if let Some(const_stab) = const_stab {
-            replaced_parent_const_stab =
-                Some(replace(&mut self.parent_const_stab, Some(const_stab)));
-        }
-
-        f(self);
-
-        if let Some(orig_parent_const_stab) = replaced_parent_const_stab {
-            self.parent_const_stab = orig_parent_const_stab;
-        }
+        visit_children(self)
     }
 }
 
@@ -380,83 +377,34 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
     }
 
     fn visit_item(&mut self, i: &'tcx Item<'tcx>) {
-        let mut const_stab_inherit = InheritConstStability::No;
-        let mut fn_sig = None;
-
         match i.kind {
-            hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) => {
-                const_stab_inherit = InheritConstStability::Yes;
-            }
             hir::ItemKind::Struct(_, _, ref sd) => {
                 if let Some(ctor_def_id) = sd.ctor_def_id() {
-                    self.annotate(
-                        ctor_def_id,
-                        None,
-                        InheritDeprecation::Yes,
-                        InheritConstStability::No,
-                        |_| {},
-                    )
+                    self.annotate(ctor_def_id, |_| {})
                 }
             }
-            hir::ItemKind::Fn { sig: ref item_fn_sig, .. } => {
-                fn_sig = Some(item_fn_sig);
-            }
             _ => {}
         }
 
-        self.annotate(
-            i.owner_id.def_id,
-            fn_sig,
-            InheritDeprecation::Yes,
-            const_stab_inherit,
-            |v| intravisit::walk_item(v, i),
-        );
+        self.annotate(i.owner_id.def_id, |v| intravisit::walk_item(v, i));
     }
 
     fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem<'tcx>) {
-        let fn_sig = match ti.kind {
-            hir::TraitItemKind::Fn(ref fn_sig, _) => Some(fn_sig),
-            _ => None,
-        };
-
-        self.annotate(
-            ti.owner_id.def_id,
-            fn_sig,
-            InheritDeprecation::Yes,
-            InheritConstStability::No,
-            |v| {
-                intravisit::walk_trait_item(v, ti);
-            },
-        );
+        self.annotate(ti.owner_id.def_id, |v| {
+            intravisit::walk_trait_item(v, ti);
+        });
     }
 
     fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem<'tcx>) {
-        let fn_sig = match ii.kind {
-            hir::ImplItemKind::Fn(ref fn_sig, _) => Some(fn_sig),
-            _ => None,
-        };
-
-        self.annotate(
-            ii.owner_id.def_id,
-            fn_sig,
-            InheritDeprecation::Yes,
-            InheritConstStability::No,
-            |v| {
-                intravisit::walk_impl_item(v, ii);
-            },
-        );
+        self.annotate(ii.owner_id.def_id, |v| {
+            intravisit::walk_impl_item(v, ii);
+        });
     }
 
     fn visit_variant(&mut self, var: &'tcx Variant<'tcx>) {
-        self.annotate(var.def_id, None, InheritDeprecation::Yes, InheritConstStability::No, |v| {
+        self.annotate(var.def_id, |v| {
             if let Some(ctor_def_id) = var.data.ctor_def_id() {
-                v.annotate(
-                    ctor_def_id,
-                    None,
-                    InheritDeprecation::Yes,
-                    InheritConstStability::No,
-                    |_| {},
-                );
+                v.annotate(ctor_def_id, |_| {});
             }
 
             intravisit::walk_variant(v, var)
@@ -464,29 +412,19 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
     }
 
     fn visit_field_def(&mut self, s: &'tcx FieldDef<'tcx>) {
-        self.annotate(s.def_id, None, InheritDeprecation::Yes, InheritConstStability::No, |v| {
+        self.annotate(s.def_id, |v| {
             intravisit::walk_field_def(v, s);
         });
     }
 
     fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem<'tcx>) {
-        let fn_sig = match &i.kind {
-            rustc_hir::ForeignItemKind::Fn(fn_sig, ..) => Some(fn_sig),
-            _ => None,
-        };
-        self.annotate(
-            i.owner_id.def_id,
-            fn_sig,
-            InheritDeprecation::Yes,
-            InheritConstStability::No,
-            |v| {
-                intravisit::walk_foreign_item(v, i);
-            },
-        );
+        self.annotate(i.owner_id.def_id, |v| {
+            intravisit::walk_foreign_item(v, i);
+        });
     }
 
     fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam<'tcx>) {
-        self.annotate(p.def_id, None, InheritDeprecation::No, InheritConstStability::No, |v| {
+        self.annotate(p.def_id, |v| {
             intravisit::walk_generic_param(v, p);
         });
     }
@@ -594,8 +532,10 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
         }
     }
 
+    #[instrument(level = "debug", skip(self))]
     fn check_missing_stability(&self, def_id: LocalDefId, span: Span) {
         let stab = self.tcx.lookup_stability(def_id);
+        self.tcx.ensure_ok().lookup_const_stability(def_id);
         if !self.tcx.sess.is_test_crate()
             && stab.is_none()
             && self.effective_visibilities.is_reachable(def_id)
@@ -696,18 +636,12 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
 }
 
 fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
-    let mut index = Index { const_stab_map: Default::default(), implications: Default::default() };
+    let mut index = Index { implications: Default::default() };
 
     {
-        let mut annotator = Annotator { tcx, index: &mut index, parent_const_stab: None };
-
-        annotator.annotate(
-            CRATE_DEF_ID,
-            None,
-            InheritDeprecation::Yes,
-            InheritConstStability::No,
-            |v| tcx.hir_walk_toplevel_module(v),
-        );
+        let mut annotator = Annotator { tcx, index: &mut index };
+
+        annotator.annotate(CRATE_DEF_ID, |v| tcx.hir_walk_toplevel_module(v));
     }
     index
 }
@@ -724,7 +658,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         stability_index,
         stability_implications: |tcx, _| tcx.stability().implications.clone(),
         lookup_stability,
-        lookup_const_stability: |tcx, id| tcx.stability().local_const_stability(id),
+        lookup_const_stability,
         lookup_default_body_stability,
         lookup_deprecation_entry,
         ..*providers
-- 
cgit 1.4.1-3-g733a5


From 06f104fd7760eb28b6722f9509adaf6a63226567 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sat, 12 Jul 2025 10:57:57 +0000
Subject: Simplify annotator.

---
 compiler/rustc_passes/src/stability.rs | 88 ++++++++++++----------------------
 1 file changed, 30 insertions(+), 58 deletions(-)

diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index b47742df12b..c11c3d10451 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -28,7 +28,7 @@ use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::lint;
 use rustc_session::lint::builtin::{DEPRECATED, INEFFECTIVE_UNSTABLE_TRAIT_IMPL};
 use rustc_span::{Span, Symbol, sym};
-use tracing::{debug, info, instrument};
+use tracing::{info, instrument};
 
 use crate::errors;
 
@@ -326,43 +326,23 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
     /// Determine the stability for a node based on its attributes and inherited stability. The
     /// stability is recorded in the index and used as the parent. If the node is a function,
     /// `fn_sig` is its signature.
-    #[instrument(level = "trace", skip(self, visit_children))]
-    fn annotate<F>(&mut self, def_id: LocalDefId, visit_children: F)
-    where
-        F: FnOnce(&mut Self),
-    {
-        let attrs = self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(def_id));
-        debug!("annotate(id = {:?}, attrs = {:?})", def_id, attrs);
-
-        let stab = self.tcx.lookup_stability(def_id);
-
+    #[instrument(level = "trace", skip(self))]
+    fn annotate(&mut self, def_id: LocalDefId) {
         if !self.tcx.features().staged_api() {
-            visit_children(self);
             return;
         }
 
-        if let Some(Stability {
-            level: StabilityLevel::Unstable { implied_by: Some(implied_by), .. },
-            feature,
-        }) = stab
+        if let Some(stability) = self.tcx.lookup_stability(def_id)
+            && let StabilityLevel::Unstable { implied_by: Some(implied_by), .. } = stability.level
         {
-            self.index.implications.insert(implied_by, feature);
+            self.index.implications.insert(implied_by, stability.feature);
         }
 
-        // # Const stability
-
-        let const_stab = self.tcx.lookup_const_stability(def_id);
-
-        if let Some(ConstStability {
-            level: StabilityLevel::Unstable { implied_by: Some(implied_by), .. },
-            feature,
-            ..
-        }) = const_stab
+        if let Some(stability) = self.tcx.lookup_const_stability(def_id)
+            && let StabilityLevel::Unstable { implied_by: Some(implied_by), .. } = stability.level
         {
-            self.index.implications.insert(implied_by, feature);
+            self.index.implications.insert(implied_by, stability.feature);
         }
-
-        visit_children(self)
     }
 }
 
@@ -380,53 +360,48 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
         match i.kind {
             hir::ItemKind::Struct(_, _, ref sd) => {
                 if let Some(ctor_def_id) = sd.ctor_def_id() {
-                    self.annotate(ctor_def_id, |_| {})
+                    self.annotate(ctor_def_id);
                 }
             }
             _ => {}
         }
 
-        self.annotate(i.owner_id.def_id, |v| intravisit::walk_item(v, i));
+        self.annotate(i.owner_id.def_id);
+        intravisit::walk_item(self, i)
     }
 
     fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem<'tcx>) {
-        self.annotate(ti.owner_id.def_id, |v| {
-            intravisit::walk_trait_item(v, ti);
-        });
+        self.annotate(ti.owner_id.def_id);
+        intravisit::walk_trait_item(self, ti);
     }
 
     fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem<'tcx>) {
-        self.annotate(ii.owner_id.def_id, |v| {
-            intravisit::walk_impl_item(v, ii);
-        });
+        self.annotate(ii.owner_id.def_id);
+        intravisit::walk_impl_item(self, ii);
     }
 
     fn visit_variant(&mut self, var: &'tcx Variant<'tcx>) {
-        self.annotate(var.def_id, |v| {
-            if let Some(ctor_def_id) = var.data.ctor_def_id() {
-                v.annotate(ctor_def_id, |_| {});
-            }
+        self.annotate(var.def_id);
+        if let Some(ctor_def_id) = var.data.ctor_def_id() {
+            self.annotate(ctor_def_id);
+        }
 
-            intravisit::walk_variant(v, var)
-        })
+        intravisit::walk_variant(self, var)
     }
 
     fn visit_field_def(&mut self, s: &'tcx FieldDef<'tcx>) {
-        self.annotate(s.def_id, |v| {
-            intravisit::walk_field_def(v, s);
-        });
+        self.annotate(s.def_id);
+        intravisit::walk_field_def(self, s);
     }
 
     fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem<'tcx>) {
-        self.annotate(i.owner_id.def_id, |v| {
-            intravisit::walk_foreign_item(v, i);
-        });
+        self.annotate(i.owner_id.def_id);
+        intravisit::walk_foreign_item(self, i);
     }
 
     fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam<'tcx>) {
-        self.annotate(p.def_id, |v| {
-            intravisit::walk_generic_param(v, p);
-        });
+        self.annotate(p.def_id);
+        intravisit::walk_generic_param(self, p);
     }
 }
 
@@ -637,12 +612,9 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
 
 fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
     let mut index = Index { implications: Default::default() };
-
-    {
-        let mut annotator = Annotator { tcx, index: &mut index };
-
-        annotator.annotate(CRATE_DEF_ID, |v| tcx.hir_walk_toplevel_module(v));
-    }
+    let mut annotator = Annotator { tcx, index: &mut index };
+    annotator.annotate(CRATE_DEF_ID);
+    tcx.hir_walk_toplevel_module(&mut annotator);
     index
 }
 
-- 
cgit 1.4.1-3-g733a5


From f7e0891423cff18731e9c4616d0e99d404e914de Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sat, 12 Jul 2025 10:58:33 +0000
Subject: Retire stability_index query.

---
 compiler/rustc_interface/src/passes.rs        |  1 -
 compiler/rustc_middle/src/middle/stability.rs | 19 ------------------
 compiler/rustc_middle/src/query/mod.rs        | 19 ++++++++++++------
 compiler/rustc_middle/src/ty/context.rs       |  6 +-----
 compiler/rustc_passes/src/stability.rs        | 28 ++++++++++++---------------
 5 files changed, 26 insertions(+), 47 deletions(-)

diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index a438cde018c..998661d635a 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -1065,7 +1065,6 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
                 // This marks the corresponding crate-level attributes
                 // as used, and ensures that their values are valid.
                 tcx.ensure_ok().limits(());
-                tcx.ensure_ok().stability_index(());
             }
         );
     });
diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
index 2dcf10deb54..dc9311188e8 100644
--- a/compiler/rustc_middle/src/middle/stability.rs
+++ b/compiler/rustc_middle/src/middle/stability.rs
@@ -7,7 +7,6 @@ use rustc_ast::NodeId;
 use rustc_attr_data_structures::{
     self as attrs, ConstStability, DefaultBodyStability, DeprecatedSince, Deprecation, Stability,
 };
-use rustc_data_structures::unord::UnordMap;
 use rustc_errors::{Applicability, Diag, EmissionGuarantee};
 use rustc_feature::GateIssue;
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -65,24 +64,6 @@ impl DeprecationEntry {
     }
 }
 
-/// A stability index, giving the stability level for items and methods.
-#[derive(HashStable, Debug)]
-pub struct Index {
-    /// Mapping from feature name to feature name based on the `implied_by` field of `#[unstable]`
-    /// attributes. If a `#[unstable(feature = "implier", implied_by = "impliee")]` attribute
-    /// exists, then this map will have a `impliee -> implier` entry.
-    ///
-    /// This mapping is necessary unless both the `#[stable]` and `#[unstable]` attributes should
-    /// specify their implications (both `implies` and `implied_by`). If only one of the two
-    /// attributes do (as in the current implementation, `implied_by` in `#[unstable]`), then this
-    /// mapping is necessary for diagnostics. When a "unnecessary feature attribute" error is
-    /// reported, only the `#[stable]` attribute information is available, so the map is necessary
-    /// to know that the feature implies another feature. If it were reversed, and the `#[stable]`
-    /// attribute had an `implies` meta item, then a map would be necessary when avoiding a "use of
-    /// unstable feature" error for a feature that was implied.
-    pub implications: UnordMap<Symbol, Symbol>,
-}
-
 pub fn report_unstable(
     sess: &Session,
     feature: Symbol,
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 935cc889574..855b2e0cfec 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -112,7 +112,7 @@ use crate::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
 use crate::middle::lib_features::LibFeatures;
 use crate::middle::privacy::EffectiveVisibilities;
 use crate::middle::resolve_bound_vars::{ObjectLifetimeDefault, ResolveBoundVars, ResolvedArg};
-use crate::middle::stability::{self, DeprecationEntry};
+use crate::middle::stability::DeprecationEntry;
 use crate::mir::interpret::{
     EvalStaticInitializerRawResult, EvalToAllocationRawResult, EvalToConstValueResult,
     EvalToValTreeResult, GlobalId, LitToConstInput,
@@ -2162,6 +2162,18 @@ rustc_queries! {
         separate_provide_extern
         arena_cache
     }
+    /// Mapping from feature name to feature name based on the `implied_by` field of `#[unstable]`
+    /// attributes. If a `#[unstable(feature = "implier", implied_by = "impliee")]` attribute
+    /// exists, then this map will have a `impliee -> implier` entry.
+    ///
+    /// This mapping is necessary unless both the `#[stable]` and `#[unstable]` attributes should
+    /// specify their implications (both `implies` and `implied_by`). If only one of the two
+    /// attributes do (as in the current implementation, `implied_by` in `#[unstable]`), then this
+    /// mapping is necessary for diagnostics. When a "unnecessary feature attribute" error is
+    /// reported, only the `#[stable]` attribute information is available, so the map is necessary
+    /// to know that the feature implies another feature. If it were reversed, and the `#[stable]`
+    /// attribute had an `implies` meta item, then a map would be necessary when avoiding a "use of
+    /// unstable feature" error for a feature that was implied.
     query stability_implications(_: CrateNum) -> &'tcx UnordMap<Symbol, Symbol> {
         arena_cache
         desc { "calculating the implications between `#[unstable]` features defined in a crate" }
@@ -2268,11 +2280,6 @@ rustc_queries! {
         desc { "fetching potentially unused trait imports" }
     }
 
-    query stability_index(_: ()) -> &'tcx stability::Index {
-        arena_cache
-        eval_always
-        desc { "calculating the stability index for the local crate" }
-    }
     /// All available crates in the graph, including those that should not be user-facing
     /// (such as private crates).
     query crates(_: ()) -> &'tcx [CrateNum] {
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 915b062417f..0979d04e4bf 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -65,7 +65,7 @@ use crate::infer::canonical::{CanonicalParamEnvCache, CanonicalVarKind, Canonica
 use crate::lint::lint_level;
 use crate::metadata::ModChild;
 use crate::middle::codegen_fn_attrs::{CodegenFnAttrs, TargetFeature};
-use crate::middle::{resolve_bound_vars, stability};
+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;
@@ -1807,10 +1807,6 @@ impl<'tcx> TyCtxt<'tcx> {
         )
     }
 
-    pub fn stability(self) -> &'tcx stability::Index {
-        self.stability_index(())
-    }
-
     pub fn features(self) -> &'tcx rustc_feature::Features {
         self.features_query(())
     }
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index c11c3d10451..489fa09faec 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -19,10 +19,8 @@ use rustc_hir::{self as hir, AmbigArg, FieldDef, Item, ItemKind, TraitRef, Ty, T
 use rustc_middle::hir::nested_filter;
 use rustc_middle::middle::lib_features::{FeatureStability, LibFeatures};
 use rustc_middle::middle::privacy::EffectiveVisibilities;
-use rustc_middle::middle::stability::{
-    AllowUnstable, Deprecated, DeprecationEntry, EvalResult, Index,
-};
-use rustc_middle::query::Providers;
+use rustc_middle::middle::stability::{AllowUnstable, Deprecated, DeprecationEntry, EvalResult};
+use rustc_middle::query::{LocalCrate, Providers};
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::lint;
@@ -317,12 +315,12 @@ fn lookup_const_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ConstSt
 }
 
 /// A private tree-walker for producing an `Index`.
-struct Annotator<'a, 'tcx> {
+struct Annotator<'tcx> {
     tcx: TyCtxt<'tcx>,
-    index: &'a mut Index,
+    implications: UnordMap<Symbol, Symbol>,
 }
 
-impl<'a, 'tcx> Annotator<'a, 'tcx> {
+impl<'tcx> Annotator<'tcx> {
     /// Determine the stability for a node based on its attributes and inherited stability. The
     /// stability is recorded in the index and used as the parent. If the node is a function,
     /// `fn_sig` is its signature.
@@ -335,18 +333,18 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         if let Some(stability) = self.tcx.lookup_stability(def_id)
             && let StabilityLevel::Unstable { implied_by: Some(implied_by), .. } = stability.level
         {
-            self.index.implications.insert(implied_by, stability.feature);
+            self.implications.insert(implied_by, stability.feature);
         }
 
         if let Some(stability) = self.tcx.lookup_const_stability(def_id)
             && let StabilityLevel::Unstable { implied_by: Some(implied_by), .. } = stability.level
         {
-            self.index.implications.insert(implied_by, stability.feature);
+            self.implications.insert(implied_by, stability.feature);
         }
     }
 }
 
-impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
+impl<'tcx> Visitor<'tcx> for Annotator<'tcx> {
     /// Because stability levels are scoped lexically, we want to walk
     /// nested items in the context of the outer item, so enable
     /// deep-walking.
@@ -610,12 +608,11 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
     }
 }
 
-fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
-    let mut index = Index { implications: Default::default() };
-    let mut annotator = Annotator { tcx, index: &mut index };
+fn stability_implications(tcx: TyCtxt<'_>, LocalCrate: LocalCrate) -> UnordMap<Symbol, Symbol> {
+    let mut annotator = Annotator { tcx, implications: Default::default() };
     annotator.annotate(CRATE_DEF_ID);
     tcx.hir_walk_toplevel_module(&mut annotator);
-    index
+    annotator.implications
 }
 
 /// Cross-references the feature names of unstable APIs with enabled
@@ -627,8 +624,7 @@ fn check_mod_unstable_api_usage(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
 pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers {
         check_mod_unstable_api_usage,
-        stability_index,
-        stability_implications: |tcx, _| tcx.stability().implications.clone(),
+        stability_implications,
         lookup_stability,
         lookup_const_stability,
         lookup_default_body_stability,
-- 
cgit 1.4.1-3-g733a5


From 3301ac5f7ba902d445e9484e1e73d80763de4a7e Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Sun, 30 Jan 2022 15:41:35 +0100
Subject: Integrate stable feature checking into a query.

---
 compiler/rustc_interface/src/passes.rs             |  5 --
 compiler/rustc_passes/src/stability.rs             | 69 +++++++++++++---------
 .../issue-43106-gating-of-builtin-attrs.stderr     | 16 ++---
 tests/ui/lint/lint-stability-deprecated.stderr     | 20 +++----
 tests/ui/lint/lint-stability.stderr                | 18 +++---
 tests/ui/missing/missing-stability.stderr          |  9 +--
 .../effective_visibilities_invariants.stderr       |  2 +-
 tests/ui/privacy/issue-113860-1.stderr             | 18 ++----
 tests/ui/privacy/issue-113860-2.stderr             | 18 ++----
 tests/ui/privacy/issue-113860.stderr               | 18 ++----
 .../missing-const-stability.stderr                 | 14 ++---
 .../stability-attribute-sanity-3.stderr            |  6 +-
 12 files changed, 93 insertions(+), 120 deletions(-)

diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index 998661d635a..fb6897c7d89 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -1054,11 +1054,6 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
                     tcx.ensure_ok().check_mod_unstable_api_usage(module);
                 });
             },
-            {
-                sess.time("unused_lib_feature_checking", || {
-                    rustc_passes::stability::check_unused_or_stable_features(tcx)
-                });
-            },
             {
                 // We force these queries to run,
                 // since they might not otherwise get called.
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 489fa09faec..61827dde64f 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -13,7 +13,6 @@ use rustc_data_structures::unord::{ExtendUnord, UnordMap, UnordSet};
 use rustc_feature::{EnabledLangFeature, EnabledLibFeature};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE, LocalDefId, LocalModDefId};
-use rustc_hir::hir_id::CRATE_HIR_ID;
 use rustc_hir::intravisit::{self, Visitor, VisitorExt};
 use rustc_hir::{self as hir, AmbigArg, FieldDef, Item, ItemKind, TraitRef, Ty, TyKind, Variant};
 use rustc_middle::hir::nested_filter;
@@ -411,7 +410,7 @@ struct MissingStabilityAnnotations<'tcx> {
 impl<'tcx> MissingStabilityAnnotations<'tcx> {
     /// Verify that deprecation and stability attributes make sense with one another.
     #[instrument(level = "trace", skip(self))]
-    fn check_compatible_stability(&self, def_id: LocalDefId, item_sp: Span) {
+    fn check_compatible_stability(&self, def_id: LocalDefId) {
         if !self.tcx.features().staged_api() {
             return;
         }
@@ -441,6 +440,7 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
                 || (kind == AnnotationKind::Container && stab.level.is_stable() && depr.is_some())
             {
                 if let Some(span) = find_attr_span!(Stability) {
+                    let item_sp = self.tcx.def_span(def_id);
                     self.tcx.dcx().emit_err(errors::UselessStability { span, item_sp });
                 }
             }
@@ -452,6 +452,7 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
                 && let attrs::StabilityLevel::Stable { since: stab_since, .. } = stab.level
                 && let Some(span) = find_attr_span!(Stability)
             {
+                let item_sp = self.tcx.def_span(def_id);
                 match stab_since {
                     StableSince::Current => {
                         self.tcx
@@ -506,7 +507,7 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn check_missing_stability(&self, def_id: LocalDefId, span: Span) {
+    fn check_missing_stability(&self, def_id: LocalDefId) {
         let stab = self.tcx.lookup_stability(def_id);
         self.tcx.ensure_ok().lookup_const_stability(def_id);
         if !self.tcx.sess.is_test_crate()
@@ -514,11 +515,12 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
             && self.effective_visibilities.is_reachable(def_id)
         {
             let descr = self.tcx.def_descr(def_id.to_def_id());
+            let span = self.tcx.def_span(def_id);
             self.tcx.dcx().emit_err(errors::MissingStabilityAttr { span, descr });
         }
     }
 
-    fn check_missing_const_stability(&self, def_id: LocalDefId, span: Span) {
+    fn check_missing_const_stability(&self, def_id: LocalDefId) {
         let is_const = self.tcx.is_const_fn(def_id.to_def_id())
             || (self.tcx.def_kind(def_id.to_def_id()) == DefKind::Trait
                 && self.tcx.is_const_trait(def_id.to_def_id()));
@@ -528,6 +530,7 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
             && self.effective_visibilities.is_reachable(def_id)
             && self.tcx.lookup_const_stability(def_id).is_none()
         {
+            let span = self.tcx.def_span(def_id);
             let descr = self.tcx.def_descr(def_id.to_def_id());
             self.tcx.dcx().emit_err(errors::MissingConstStabAttr { span, descr });
         }
@@ -542,7 +545,7 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
     }
 
     fn visit_item(&mut self, i: &'tcx Item<'tcx>) {
-        self.check_compatible_stability(i.owner_id.def_id, i.span);
+        self.check_compatible_stability(i.owner_id.def_id);
 
         // Inherent impls and foreign modules serve only as containers for other items,
         // they don't have their own stability. They still can be annotated as unstable
@@ -553,54 +556,54 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
             hir::ItemKind::Impl(hir::Impl { of_trait: None, .. })
                 | hir::ItemKind::ForeignMod { .. }
         ) {
-            self.check_missing_stability(i.owner_id.def_id, i.span);
+            self.check_missing_stability(i.owner_id.def_id);
         }
 
         // Ensure stable `const fn` have a const stability attribute.
-        self.check_missing_const_stability(i.owner_id.def_id, i.span);
+        self.check_missing_const_stability(i.owner_id.def_id);
 
         intravisit::walk_item(self, i)
     }
 
     fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem<'tcx>) {
-        self.check_compatible_stability(ti.owner_id.def_id, ti.span);
-        self.check_missing_stability(ti.owner_id.def_id, ti.span);
+        self.check_compatible_stability(ti.owner_id.def_id);
+        self.check_missing_stability(ti.owner_id.def_id);
         intravisit::walk_trait_item(self, ti);
     }
 
     fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem<'tcx>) {
-        self.check_compatible_stability(ii.owner_id.def_id, ii.span);
+        self.check_compatible_stability(ii.owner_id.def_id);
         let impl_def_id = self.tcx.hir_get_parent_item(ii.hir_id());
         if self.tcx.impl_trait_ref(impl_def_id).is_none() {
-            self.check_missing_stability(ii.owner_id.def_id, ii.span);
-            self.check_missing_const_stability(ii.owner_id.def_id, ii.span);
+            self.check_missing_stability(ii.owner_id.def_id);
+            self.check_missing_const_stability(ii.owner_id.def_id);
         }
         intravisit::walk_impl_item(self, ii);
     }
 
     fn visit_variant(&mut self, var: &'tcx Variant<'tcx>) {
-        self.check_compatible_stability(var.def_id, var.span);
-        self.check_missing_stability(var.def_id, var.span);
+        self.check_compatible_stability(var.def_id);
+        self.check_missing_stability(var.def_id);
         if let Some(ctor_def_id) = var.data.ctor_def_id() {
-            self.check_missing_stability(ctor_def_id, var.span);
+            self.check_missing_stability(ctor_def_id);
         }
         intravisit::walk_variant(self, var);
     }
 
     fn visit_field_def(&mut self, s: &'tcx FieldDef<'tcx>) {
-        self.check_compatible_stability(s.def_id, s.span);
-        self.check_missing_stability(s.def_id, s.span);
+        self.check_compatible_stability(s.def_id);
+        self.check_missing_stability(s.def_id);
         intravisit::walk_field_def(self, s);
     }
 
     fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem<'tcx>) {
-        self.check_compatible_stability(i.owner_id.def_id, i.span);
-        self.check_missing_stability(i.owner_id.def_id, i.span);
+        self.check_compatible_stability(i.owner_id.def_id);
+        self.check_missing_stability(i.owner_id.def_id);
         intravisit::walk_foreign_item(self, i);
     }
 
     fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam<'tcx>) {
-        self.check_compatible_stability(p.def_id, p.span);
+        self.check_compatible_stability(p.def_id);
         // Note that we don't need to `check_missing_stability` for default generic parameters,
         // as we assume that any default generic parameters without attributes are automatically
         // stable (assuming they have not inherited instability from their parent).
@@ -619,6 +622,21 @@ fn stability_implications(tcx: TyCtxt<'_>, LocalCrate: LocalCrate) -> UnordMap<S
 /// features and possibly prints errors.
 fn check_mod_unstable_api_usage(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
     tcx.hir_visit_item_likes_in_module(module_def_id, &mut Checker { tcx });
+
+    let is_staged_api =
+        tcx.sess.opts.unstable_opts.force_unstable_if_unmarked || tcx.features().staged_api();
+    if is_staged_api {
+        let effective_visibilities = &tcx.effective_visibilities(());
+        let mut missing = MissingStabilityAnnotations { tcx, effective_visibilities };
+        if module_def_id.is_top_level_module() {
+            missing.check_missing_stability(CRATE_DEF_ID);
+        }
+        tcx.hir_visit_item_likes_in_module(module_def_id, &mut missing);
+    }
+
+    if module_def_id.is_top_level_module() {
+        check_unused_or_stable_features(tcx)
+    }
 }
 
 pub(crate) fn provide(providers: &mut Providers) {
@@ -1002,16 +1020,9 @@ impl<'tcx> Visitor<'tcx> for CheckTraitImplStable<'tcx> {
 /// Given the list of enabled features that were not language features (i.e., that
 /// were expected to be library features), and the list of features used from
 /// libraries, identify activated features that don't exist and error about them.
+// This is `pub` for rustdoc. rustc should call it through `check_mod_unstable_api_usage`.
 pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) {
-    let is_staged_api =
-        tcx.sess.opts.unstable_opts.force_unstable_if_unmarked || tcx.features().staged_api();
-    if is_staged_api {
-        let effective_visibilities = &tcx.effective_visibilities(());
-        let mut missing = MissingStabilityAnnotations { tcx, effective_visibilities };
-        missing.check_missing_stability(CRATE_DEF_ID, tcx.hir_span(CRATE_HIR_ID));
-        tcx.hir_walk_toplevel_module(&mut missing);
-        tcx.hir_visit_all_item_likes_in_crate(&mut missing);
-    }
+    let _prof_timer = tcx.sess.timer("unused_lib_feature_checking");
 
     let enabled_lang_features = tcx.features().enabled_lang_features();
     let mut lang_features = UnordSet::default();
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
index 3271aa0620b..9016ca1efa7 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
@@ -417,6 +417,14 @@ LL | #![cold]
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 
+warning: the feature `rust1` has been stable since 1.0.0 and no longer requires an attribute to enable
+  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:85:12
+   |
+LL | #![feature(rust1)]
+   |            ^^^^^
+   |
+   = note: `#[warn(stable_features)]` on by default
+
 warning: `#[macro_use]` only has an effect on `extern crate` and modules
   --> $DIR/issue-43106-gating-of-builtin-attrs.rs:176:5
    |
@@ -1161,13 +1169,5 @@ warning: crate-level attribute should be an inner attribute: add an exclamation
 LL |     #[type_length_limit="0100"] impl S { }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: the feature `rust1` has been stable since 1.0.0 and no longer requires an attribute to enable
-  --> $DIR/issue-43106-gating-of-builtin-attrs.rs:85:12
-   |
-LL | #![feature(rust1)]
-   |            ^^^^^
-   |
-   = note: `#[warn(stable_features)]` on by default
-
 warning: 173 warnings emitted
 
diff --git a/tests/ui/lint/lint-stability-deprecated.stderr b/tests/ui/lint/lint-stability-deprecated.stderr
index 51205ff4340..0399fab746e 100644
--- a/tests/ui/lint/lint-stability-deprecated.stderr
+++ b/tests/ui/lint/lint-stability-deprecated.stderr
@@ -1,8 +1,8 @@
-warning: use of deprecated function `lint_stability::deprecated`: text
-  --> $DIR/lint-stability-deprecated.rs:24:9
+warning: use of deprecated associated type `lint_stability::TraitWithAssociatedTypes::TypeDeprecated`: text
+  --> $DIR/lint-stability-deprecated.rs:97:48
    |
-LL |         deprecated();
-   |         ^^^^^^^^^^
+LL |         struct S2<T: TraitWithAssociatedTypes>(T::TypeDeprecated);
+   |                                                ^^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/lint-stability-deprecated.rs:6:9
@@ -10,6 +10,12 @@ note: the lint level is defined here
 LL | #![warn(deprecated)]
    |         ^^^^^^^^^^
 
+warning: use of deprecated function `lint_stability::deprecated`: text
+  --> $DIR/lint-stability-deprecated.rs:24:9
+   |
+LL |         deprecated();
+   |         ^^^^^^^^^^
+
 warning: use of deprecated method `lint_stability::Trait::trait_deprecated`: text
   --> $DIR/lint-stability-deprecated.rs:29:16
    |
@@ -316,12 +322,6 @@ warning: use of deprecated function `this_crate::MethodTester::test_method_body:
 LL |             fn_in_body();
    |             ^^^^^^^^^^
 
-warning: use of deprecated associated type `lint_stability::TraitWithAssociatedTypes::TypeDeprecated`: text
-  --> $DIR/lint-stability-deprecated.rs:97:48
-   |
-LL |         struct S2<T: TraitWithAssociatedTypes>(T::TypeDeprecated);
-   |                                                ^^^^^^^^^^^^^^^^^
-
 warning: use of deprecated associated type `lint_stability::TraitWithAssociatedTypes::TypeDeprecated`: text
   --> $DIR/lint-stability-deprecated.rs:101:13
    |
diff --git a/tests/ui/lint/lint-stability.stderr b/tests/ui/lint/lint-stability.stderr
index fd57908a77b..249f3ccaa54 100644
--- a/tests/ui/lint/lint-stability.stderr
+++ b/tests/ui/lint/lint-stability.stderr
@@ -1,3 +1,12 @@
+error[E0658]: use of unstable library feature `unstable_test_feature`
+  --> $DIR/lint-stability.rs:88:48
+   |
+LL |         struct S1<T: TraitWithAssociatedTypes>(T::TypeUnstable);
+   |                                                ^^^^^^^^^^^^^^^
+   |
+   = help: add `#![feature(unstable_test_feature)]` 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 `unstable_test_feature`
   --> $DIR/lint-stability.rs:17:5
    |
@@ -367,15 +376,6 @@ LL |         let _ = Unstable::StableVariant;
    = help: add `#![feature(unstable_test_feature)]` 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 `unstable_test_feature`
-  --> $DIR/lint-stability.rs:88:48
-   |
-LL |         struct S1<T: TraitWithAssociatedTypes>(T::TypeUnstable);
-   |                                                ^^^^^^^^^^^^^^^
-   |
-   = help: add `#![feature(unstable_test_feature)]` 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 `unstable_test_feature`
   --> $DIR/lint-stability.rs:92:13
    |
diff --git a/tests/ui/missing/missing-stability.stderr b/tests/ui/missing/missing-stability.stderr
index 659f8c78cae..bf8046c4e12 100644
--- a/tests/ui/missing/missing-stability.stderr
+++ b/tests/ui/missing/missing-stability.stderr
@@ -1,17 +1,14 @@
 error: function has missing stability attribute
   --> $DIR/missing-stability.rs:8:1
    |
-LL | / pub fn unmarked() {
-LL | |
-LL | |     ()
-LL | | }
-   | |_^
+LL | pub fn unmarked() {
+   | ^^^^^^^^^^^^^^^^^
 
 error: function has missing stability attribute
   --> $DIR/missing-stability.rs:22:5
    |
 LL |     pub fn unmarked() {}
-   |     ^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/privacy/effective_visibilities_invariants.stderr b/tests/ui/privacy/effective_visibilities_invariants.stderr
index 64d0402f84e..97bee1e2d8d 100644
--- a/tests/ui/privacy/effective_visibilities_invariants.stderr
+++ b/tests/ui/privacy/effective_visibilities_invariants.stderr
@@ -23,7 +23,7 @@ error: module has missing stability attribute
   --> $DIR/effective_visibilities_invariants.rs:5:1
    |
 LL | pub mod m {}
-   | ^^^^^^^^^^^^
+   | ^^^^^^^^^
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/privacy/issue-113860-1.stderr b/tests/ui/privacy/issue-113860-1.stderr
index dad9ebadf04..764c9f4925b 100644
--- a/tests/ui/privacy/issue-113860-1.stderr
+++ b/tests/ui/privacy/issue-113860-1.stderr
@@ -20,28 +20,20 @@ LL | | fn main() {}
 error: trait has missing stability attribute
   --> $DIR/issue-113860-1.rs:4:1
    |
-LL | / pub trait Trait {
-LL | |
-LL | |     fn fun() {}
-LL | |
-LL | | }
-   | |_^
+LL | pub trait Trait {
+   | ^^^^^^^^^^^^^^^
 
 error: implementation has missing stability attribute
   --> $DIR/issue-113860-1.rs:10:1
    |
-LL | / impl Trait for u8 {
-LL | |
-LL | |     pub(self) fn fun() {}
-LL | |
-LL | | }
-   | |_^
+LL | impl Trait for u8 {
+   | ^^^^^^^^^^^^^^^^^
 
 error: associated function has missing stability attribute
   --> $DIR/issue-113860-1.rs:6:5
    |
 LL |     fn fun() {}
-   |     ^^^^^^^^^^^
+   |     ^^^^^^^^
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/privacy/issue-113860-2.stderr b/tests/ui/privacy/issue-113860-2.stderr
index 9805c22dbdf..d0847aa2b49 100644
--- a/tests/ui/privacy/issue-113860-2.stderr
+++ b/tests/ui/privacy/issue-113860-2.stderr
@@ -20,28 +20,20 @@ LL | | fn main() {}
 error: trait has missing stability attribute
   --> $DIR/issue-113860-2.rs:4:1
    |
-LL | / pub trait Trait {
-LL | |
-LL | |     type X;
-LL | |
-LL | | }
-   | |_^
+LL | pub trait Trait {
+   | ^^^^^^^^^^^^^^^
 
 error: implementation has missing stability attribute
   --> $DIR/issue-113860-2.rs:10:1
    |
-LL | / impl Trait for u8 {
-LL | |
-LL | |     pub(self) type X = Self;
-LL | |
-LL | | }
-   | |_^
+LL | impl Trait for u8 {
+   | ^^^^^^^^^^^^^^^^^
 
 error: associated type has missing stability attribute
   --> $DIR/issue-113860-2.rs:6:5
    |
 LL |     type X;
-   |     ^^^^^^^
+   |     ^^^^^^
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/privacy/issue-113860.stderr b/tests/ui/privacy/issue-113860.stderr
index 88efcae4a85..d7a15255b15 100644
--- a/tests/ui/privacy/issue-113860.stderr
+++ b/tests/ui/privacy/issue-113860.stderr
@@ -20,28 +20,20 @@ LL | | fn main() {}
 error: trait has missing stability attribute
   --> $DIR/issue-113860.rs:4:1
    |
-LL | / pub trait Trait {
-LL | |
-LL | |     const X: u32;
-LL | |
-LL | | }
-   | |_^
+LL | pub trait Trait {
+   | ^^^^^^^^^^^^^^^
 
 error: implementation has missing stability attribute
   --> $DIR/issue-113860.rs:10:1
    |
-LL | / impl Trait for u8 {
-LL | |
-LL | |     pub(self) const X: u32 = 3;
-LL | |
-LL | | }
-   | |_^
+LL | impl Trait for u8 {
+   | ^^^^^^^^^^^^^^^^^
 
 error: associated constant has missing stability attribute
   --> $DIR/issue-113860.rs:6:5
    |
 LL |     const X: u32;
-   |     ^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/stability-attribute/missing-const-stability.stderr b/tests/ui/stability-attribute/missing-const-stability.stderr
index 70a2450c53a..5748e20cd2b 100644
--- a/tests/ui/stability-attribute/missing-const-stability.stderr
+++ b/tests/ui/stability-attribute/missing-const-stability.stderr
@@ -2,29 +2,25 @@ error: function has missing const stability attribute
   --> $DIR/missing-const-stability.rs:7:1
    |
 LL | pub const fn foo() {}
-   | ^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^
 
 error: trait has missing const stability attribute
   --> $DIR/missing-const-stability.rs:23:1
    |
-LL | / pub const trait Bar {
-LL | |
-LL | |     #[stable(feature = "stable", since = "1.0.0")]
-LL | |     fn fun();
-LL | | }
-   | |_^
+LL | pub const trait Bar {
+   | ^^^^^^^^^^^^^^^^^^^
 
 error: function has missing const stability attribute
   --> $DIR/missing-const-stability.rs:36:1
    |
 LL | pub const unsafe fn size_of_val<T>(x: *const T) -> usize { 42 }
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: associated function has missing const stability attribute
   --> $DIR/missing-const-stability.rs:16:5
    |
 LL |     pub const fn foo() {}
-   |     ^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/stability-attribute/stability-attribute-sanity-3.stderr b/tests/ui/stability-attribute/stability-attribute-sanity-3.stderr
index a6d1ebf2945..d33bb53360b 100644
--- a/tests/ui/stability-attribute/stability-attribute-sanity-3.stderr
+++ b/tests/ui/stability-attribute/stability-attribute-sanity-3.stderr
@@ -1,10 +1,8 @@
 error: macro has missing stability attribute
   --> $DIR/stability-attribute-sanity-3.rs:8:1
    |
-LL | / macro_rules! mac {
-LL | |     () => ()
-LL | | }
-   | |_^
+LL | macro_rules! mac {
+   | ^^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
-- 
cgit 1.4.1-3-g733a5


From d716dc9a7a1525402adfdeaa497a063d69a97aac Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Wed, 16 Jul 2025 22:32:05 +0000
Subject: Remove useless debugging.

---
 compiler/rustc_passes/src/stability.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 61827dde64f..b23dc5c1fa2 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -25,7 +25,7 @@ use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::lint;
 use rustc_session::lint::builtin::{DEPRECATED, INEFFECTIVE_UNSTABLE_TRAIT_IMPL};
 use rustc_span::{Span, Symbol, sym};
-use tracing::{info, instrument};
+use tracing::instrument;
 
 use crate::errors;
 
@@ -148,7 +148,6 @@ fn lookup_deprecation_entry(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<Depre
         if inherit_deprecation(tcx.def_kind(def_id)).yes() {
             let parent_id = tcx.opt_local_parent(def_id)?;
             let parent_depr = tcx.lookup_deprecation_entry(parent_id)?;
-            info!("tagging child {:?} as deprecated from parent", def_id);
             return Some(parent_depr);
         }
 
-- 
cgit 1.4.1-3-g733a5


From 439803deada83319f685cfd1156ef847ed127742 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Wed, 16 Jul 2025 22:34:00 +0000
Subject: Remove unuseful enums.

---
 compiler/rustc_passes/src/stability.rs | 76 +++++++---------------------------
 1 file changed, 16 insertions(+), 60 deletions(-)

diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index b23dc5c1fa2..fd0ca127491 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -41,67 +41,23 @@ enum AnnotationKind {
     Container,
 }
 
-/// Whether to inherit deprecation flags for nested items. In most cases, we do want to inherit
-/// deprecation, because nested items rarely have individual deprecation attributes, and so
-/// should be treated as deprecated if their parent is. However, default generic parameters
-/// have separate deprecation attributes from their parents, so we do not wish to inherit
-/// deprecation in this case. For example, inheriting deprecation for `T` in `Foo<T>`
-/// would cause a duplicate warning arising from both `Foo` and `T` being deprecated.
-#[derive(Clone)]
-enum InheritDeprecation {
-    Yes,
-    No,
-}
-
-impl InheritDeprecation {
-    fn yes(&self) -> bool {
-        matches!(self, InheritDeprecation::Yes)
-    }
-}
-
-/// Whether to inherit const stability flags for nested items. In most cases, we do not want to
-/// inherit const stability: just because an enclosing `fn` is const-stable does not mean
-/// all `extern` imports declared in it should be const-stable! However, trait methods
-/// inherit const stability attributes from their parent and do not have their own.
-enum InheritConstStability {
-    Yes,
-    No,
-}
-
-impl InheritConstStability {
-    fn yes(&self) -> bool {
-        matches!(self, InheritConstStability::Yes)
-    }
-}
-
-enum InheritStability {
-    Yes,
-    No,
-}
-
-impl InheritStability {
-    fn yes(&self) -> bool {
-        matches!(self, InheritStability::Yes)
-    }
-}
-
-fn inherit_deprecation(def_kind: DefKind) -> InheritDeprecation {
+fn inherit_deprecation(def_kind: DefKind) -> bool {
     match def_kind {
-        DefKind::LifetimeParam | DefKind::TyParam | DefKind::ConstParam => InheritDeprecation::No,
-        _ => InheritDeprecation::Yes,
+        DefKind::LifetimeParam | DefKind::TyParam | DefKind::ConstParam => false,
+        _ => true,
     }
 }
 
-fn inherit_const_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> InheritConstStability {
+fn inherit_const_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
     let def_kind = tcx.def_kind(def_id);
     match def_kind {
         DefKind::AssocFn | DefKind::AssocTy | DefKind::AssocConst => {
             match tcx.def_kind(tcx.local_parent(def_id)) {
-                DefKind::Impl { of_trait: true } => InheritConstStability::Yes,
-                _ => InheritConstStability::No,
+                DefKind::Impl { of_trait: true } => true,
+                _ => false,
             }
         }
-        _ => InheritConstStability::No,
+        _ => false,
     }
 }
 
@@ -145,7 +101,7 @@ fn lookup_deprecation_entry(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<Depre
     );
 
     let Some(depr) = depr else {
-        if inherit_deprecation(tcx.def_kind(def_id)).yes() {
+        if inherit_deprecation(tcx.def_kind(def_id)) {
             let parent_id = tcx.opt_local_parent(def_id)?;
             let parent_depr = tcx.lookup_deprecation_entry(parent_id)?;
             return Some(parent_depr);
@@ -158,10 +114,10 @@ fn lookup_deprecation_entry(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<Depre
     Some(DeprecationEntry::local(depr, def_id))
 }
 
-fn inherit_stability(def_kind: DefKind) -> InheritStability {
+fn inherit_stability(def_kind: DefKind) -> bool {
     match def_kind {
-        DefKind::Field | DefKind::Variant | DefKind::Ctor(..) => InheritStability::Yes,
-        _ => InheritStability::No,
+        DefKind::Field | DefKind::Variant | DefKind::Ctor(..) => true,
+        _ => false,
     }
 }
 
@@ -193,7 +149,7 @@ fn lookup_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<Stability> {
 
         let Some(parent) = tcx.opt_local_parent(def_id) else { return Some(FORCE_UNSTABLE) };
 
-        if inherit_deprecation(tcx.def_kind(def_id)).yes() {
+        if inherit_deprecation(tcx.def_kind(def_id)) {
             let parent = tcx.lookup_stability(parent)?;
             if parent.is_unstable() {
                 return Some(parent);
@@ -212,7 +168,7 @@ fn lookup_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<Stability> {
         return Some(stab);
     }
 
-    if inherit_deprecation(tcx.def_kind(def_id)).yes() {
+    if inherit_deprecation(tcx.def_kind(def_id)) {
         let Some(parent) = tcx.opt_local_parent(def_id) else {
             return tcx
                 .sess
@@ -222,7 +178,7 @@ fn lookup_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<Stability> {
                 .then_some(FORCE_UNSTABLE);
         };
         let parent = tcx.lookup_stability(parent)?;
-        if parent.is_unstable() || inherit_stability(tcx.def_kind(def_id)).yes() {
+        if parent.is_unstable() || inherit_stability(tcx.def_kind(def_id)) {
             return Some(parent);
         }
     }
@@ -249,7 +205,7 @@ fn lookup_const_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ConstSt
     if !tcx.features().staged_api() {
         // Propagate unstability. This can happen even for non-staged-api crates in case
         // -Zforce-unstable-if-unmarked is set.
-        if inherit_deprecation(tcx.def_kind(def_id)).yes() {
+        if inherit_deprecation(tcx.def_kind(def_id)) {
             let parent = tcx.opt_local_parent(def_id)?;
             let parent_stab = tcx.lookup_stability(parent)?;
             if parent_stab.is_unstable()
@@ -301,7 +257,7 @@ fn lookup_const_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ConstSt
     // immediate children.
     // FIXME(const_trait_impl): how is this supposed to interact with `#[rustc_const_stable_indirect]`?
     // Currently, once that is set, we do not inherit anything from the parent any more.
-    if inherit_const_stability(tcx, def_id).yes() {
+    if inherit_const_stability(tcx, def_id) {
         let parent = tcx.opt_local_parent(def_id)?;
         let parent = tcx.lookup_const_stability(parent)?;
         if parent.is_const_unstable() {
-- 
cgit 1.4.1-3-g733a5


From 83255f57e09694f68b5df6713de46de7894d469b Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Wed, 16 Jul 2025 22:39:04 +0000
Subject: Include ErrorGuaranteed in StableSince::Err.

---
 compiler/rustc_attr_data_structures/src/lib.rs            | 4 ++--
 compiler/rustc_attr_data_structures/src/stability.rs      | 4 ++--
 compiler/rustc_attr_parsing/src/attributes/stability.rs   | 8 ++++----
 compiler/rustc_passes/src/lib_features.rs                 | 2 +-
 compiler/rustc_passes/src/stability.rs                    | 2 +-
 src/librustdoc/html/render/mod.rs                         | 2 +-
 src/tools/clippy/clippy_lints/src/std_instead_of_core.rs  | 2 +-
 src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs | 2 +-
 8 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_attr_data_structures/src/lib.rs b/compiler/rustc_attr_data_structures/src/lib.rs
index 8f8ce575a18..ecca0e39063 100644
--- a/compiler/rustc_attr_data_structures/src/lib.rs
+++ b/compiler/rustc_attr_data_structures/src/lib.rs
@@ -24,7 +24,7 @@ use rustc_ast::token::CommentKind;
 use rustc_ast::{AttrStyle, IntTy, UintTy};
 use rustc_ast_pretty::pp::Printer;
 use rustc_span::hygiene::Transparency;
-use rustc_span::{Span, Symbol};
+use rustc_span::{ErrorGuaranteed, Span, Symbol};
 pub use stability::*;
 use thin_vec::ThinVec;
 pub use version::*;
@@ -170,7 +170,7 @@ macro_rules! print_tup {
 }
 
 print_tup!(A B C D E F G H);
-print_skip!(Span, ());
+print_skip!(Span, (), ErrorGuaranteed);
 print_disp!(u16, bool, NonZero<u32>);
 print_debug!(Symbol, UintTy, IntTy, Align, AttrStyle, CommentKind, Transparency);
 
diff --git a/compiler/rustc_attr_data_structures/src/stability.rs b/compiler/rustc_attr_data_structures/src/stability.rs
index 218e771c745..bd31c062117 100644
--- a/compiler/rustc_attr_data_structures/src/stability.rs
+++ b/compiler/rustc_attr_data_structures/src/stability.rs
@@ -1,7 +1,7 @@
 use std::num::NonZero;
 
 use rustc_macros::{Decodable, Encodable, HashStable_Generic, PrintAttribute};
-use rustc_span::{Symbol, sym};
+use rustc_span::{ErrorGuaranteed, Symbol, sym};
 
 use crate::{PrintAttribute, RustcVersion};
 
@@ -153,7 +153,7 @@ pub enum StableSince {
     /// Stabilized in the upcoming version, whatever number that is.
     Current,
     /// Failed to parse a stabilization version.
-    Err,
+    Err(ErrorGuaranteed),
 }
 
 impl StabilityLevel {
diff --git a/compiler/rustc_attr_parsing/src/attributes/stability.rs b/compiler/rustc_attr_parsing/src/attributes/stability.rs
index 8f405e5aad9..59337749c87 100644
--- a/compiler/rustc_attr_parsing/src/attributes/stability.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/stability.rs
@@ -292,12 +292,12 @@ pub(crate) fn parse_stability<S: Stage>(
         } else if let Some(version) = parse_version(since) {
             StableSince::Version(version)
         } else {
-            cx.emit_err(session_diagnostics::InvalidSince { span: cx.attr_span });
-            StableSince::Err
+            let err = cx.emit_err(session_diagnostics::InvalidSince { span: cx.attr_span });
+            StableSince::Err(err)
         }
     } else {
-        cx.emit_err(session_diagnostics::MissingSince { span: cx.attr_span });
-        StableSince::Err
+        let err = cx.emit_err(session_diagnostics::MissingSince { span: cx.attr_span });
+        StableSince::Err(err)
     };
 
     match feature {
diff --git a/compiler/rustc_passes/src/lib_features.rs b/compiler/rustc_passes/src/lib_features.rs
index 127e0df1332..35d2a655991 100644
--- a/compiler/rustc_passes/src/lib_features.rs
+++ b/compiler/rustc_passes/src/lib_features.rs
@@ -44,7 +44,7 @@ impl<'tcx> LibFeatureCollector<'tcx> {
             StabilityLevel::Stable { since, .. } => FeatureStability::AcceptedSince(match since {
                 StableSince::Version(v) => Symbol::intern(&v.to_string()),
                 StableSince::Current => sym::env_CFG_RELEASE,
-                StableSince::Err => return None,
+                StableSince::Err(_) => return None,
             }),
         };
 
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index fd0ca127491..988025db58b 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -421,7 +421,7 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
                                 .emit_err(errors::CannotStabilizeDeprecated { span, item_sp });
                         }
                     }
-                    StableSince::Err => {
+                    StableSince::Err(_) => {
                         // An error already reported. Assume the unparseable stabilization
                         // version is older than the deprecation version.
                     }
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index d8c37137bbc..2cfc9af39e4 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -1110,7 +1110,7 @@ fn since_to_string(since: &StableSince) -> Option<String> {
     match since {
         StableSince::Version(since) => Some(since.to_string()),
         StableSince::Current => Some(RustcVersion::CURRENT.to_string()),
-        StableSince::Err => None,
+        StableSince::Err(_) => None,
     }
 }
 
diff --git a/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs b/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs
index cf70e883bd0..216f168471e 100644
--- a/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs
+++ b/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs
@@ -249,7 +249,7 @@ fn is_stable(cx: &LateContext<'_>, mut def_id: DefId, msrv: Msrv) -> bool {
             let stable = match since {
                 StableSince::Version(v) => msrv.meets(cx, v),
                 StableSince::Current => msrv.current(cx).is_none(),
-                StableSince::Err => false,
+                StableSince::Err(_) => false,
             };
 
             if !stable {
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
index 942c71ac33b..b3356450d38 100644
--- a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
+++ b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
@@ -432,7 +432,7 @@ pub fn is_stable_const_fn(cx: &LateContext<'_>, def_id: DefId, msrv: Msrv) -> bo
                     let const_stab_rust_version = match since {
                         StableSince::Version(version) => version,
                         StableSince::Current => RustcVersion::CURRENT,
-                        StableSince::Err => return false,
+                        StableSince::Err(_) => return false,
                     };
 
                     msrv.meets(cx, const_stab_rust_version)
-- 
cgit 1.4.1-3-g733a5


From ee430346fe2265fc320c098efe8e1bbcbe0dd54c Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Wed, 16 Jul 2025 22:42:55 +0000
Subject: Correct comments.

---
 compiler/rustc_passes/src/stability.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 988025db58b..a1a900d54b9 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -124,7 +124,7 @@ fn inherit_stability(def_kind: DefKind) -> bool {
 /// If the `-Z force-unstable-if-unmarked` flag is passed then we provide
 /// a parent stability annotation which indicates that this is private
 /// with the `rustc_private` feature. This is intended for use when
-/// compiling `librustc_*` crates themselves so we can leverage crates.io
+/// compiling library and `rustc_*` crates themselves so we can leverage crates.io
 /// while maintaining the invariant that all sysroot crates are unstable
 /// by default and are unable to be used.
 const FORCE_UNSTABLE: Stability = Stability {
@@ -248,13 +248,11 @@ fn lookup_const_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ConstSt
         });
     }
 
-    // Now that everything is computed, insert it into the table.
     if let Some(const_stab) = const_stab {
         return Some(const_stab);
     }
 
-    // `impl const Trait for Type` items forward their const stability to their
-    // immediate children.
+    // `impl const Trait for Type` items forward their const stability to their immediate children.
     // FIXME(const_trait_impl): how is this supposed to interact with `#[rustc_const_stable_indirect]`?
     // Currently, once that is set, we do not inherit anything from the parent any more.
     if inherit_const_stability(tcx, def_id) {
-- 
cgit 1.4.1-3-g733a5


From 7662731d75ceb19f6242c61a6812c22809e6adc2 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Wed, 16 Jul 2025 22:43:26 +0000
Subject: Fix formatting.

---
 compiler/rustc_passes/src/stability.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index a1a900d54b9..40999d622dc 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -231,13 +231,14 @@ fn lookup_const_stability(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ConstSt
     let mut const_stab = const_stab
         .map(|const_stab| ConstStability::from_partial(const_stab, const_stability_indirect));
 
-    // If this is a const fn but not annotated with stability markers, see if we can inherit regular stability.
+    // If this is a const fn but not annotated with stability markers, see if we can inherit
+    // regular stability.
     if let Some(fn_sig) = tcx.hir_node_by_def_id(def_id).fn_sig()
-            && fn_sig.header.is_const()
-            && const_stab.is_none()
-            // We only ever inherit unstable features.
-            && let Some(inherit_regular_stab) = tcx.lookup_stability(def_id)
-            && inherit_regular_stab.is_unstable()
+        && fn_sig.header.is_const()
+        && const_stab.is_none()
+        // We only ever inherit unstable features.
+        && let Some(inherit_regular_stab) = tcx.lookup_stability(def_id)
+        && inherit_regular_stab.is_unstable()
     {
         const_stab = Some(ConstStability {
             // We subject these implicitly-const functions to recursive const stability.
-- 
cgit 1.4.1-3-g733a5


From 247d4f405227d32b5e62f012d35815e4ad6ce0a2 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 17 Jul 2025 23:43:25 +0000
Subject: Add test.

---
 tests/ui/privacy/private-in-public-warn.rs         |  21 ++-
 tests/ui/privacy/private-in-public-warn.stderr     | 175 ++++++++++++++++-----
 .../ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs  |   1 +
 tests/ui/privacy/pub-priv-dep/pub-priv1.rs         |   9 +-
 tests/ui/privacy/pub-priv-dep/pub-priv1.stderr     |  52 ++++--
 5 files changed, 202 insertions(+), 56 deletions(-)

diff --git a/tests/ui/privacy/private-in-public-warn.rs b/tests/ui/privacy/private-in-public-warn.rs
index 746b98fbd07..1794fa95669 100644
--- a/tests/ui/privacy/private-in-public-warn.rs
+++ b/tests/ui/privacy/private-in-public-warn.rs
@@ -35,6 +35,7 @@ mod types {
 
 mod traits {
     trait PrivTr {}
+    impl PrivTr for () {}
     pub struct Pub<T>(T);
     pub trait PubTr {}
 
@@ -45,7 +46,13 @@ mod traits {
     pub trait Tr3 {
         type Alias: PrivTr;
         //~^ ERROR trait `traits::PrivTr` is more private than the item `traits::Tr3::Alias`
-        fn f<T: PrivTr>(arg: T) {} //~ ERROR trait `traits::PrivTr` is more private than the item `traits::Tr3::f`
+        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}`
+        fn h() -> impl PrivTr {}
+        //~^ 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>`
     impl<T: PrivTr> PubTr for Pub<T> {} // OK, trait impl predicates
@@ -75,12 +82,24 @@ mod generics {
     pub struct Pub<T = u8>(T);
     trait PrivTr<T> {}
     pub trait PubTr<T> {}
+    impl PrivTr<Priv<()>> for () {}
 
     pub trait Tr1: PrivTr<Pub> {}
         //~^ ERROR trait `generics::PrivTr<generics::Pub>` is more private than the item `generics::Tr1`
     pub trait Tr2: PubTr<Priv> {} //~ ERROR type `generics::Priv` is more private than the item `generics::Tr2`
     pub trait Tr3: PubTr<[Priv; 1]> {} //~ ERROR type `generics::Priv` is more private than the item `generics::Tr3`
     pub trait Tr4: PubTr<Pub<Priv>> {} //~ ERROR type `generics::Priv` is more private than the item `Tr4`
+
+    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}`
+        fn provided() -> impl PrivTr<Priv<()>> {}
+        //~^ 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}`
+    }
 }
 
 mod impls {
diff --git a/tests/ui/privacy/private-in-public-warn.stderr b/tests/ui/privacy/private-in-public-warn.stderr
index 3743879ffa6..09dbe4d67e3 100644
--- a/tests/ui/privacy/private-in-public-warn.stderr
+++ b/tests/ui/privacy/private-in-public-warn.stderr
@@ -130,7 +130,7 @@ LL |         type Alias = Priv;
    |         ^^^^^^^^^^ can't leak private type
 
 error: trait `traits::PrivTr` is more private than the item `traits::Alias`
-  --> $DIR/private-in-public-warn.rs:41:5
+  --> $DIR/private-in-public-warn.rs:42:5
    |
 LL |     pub type Alias<T: PrivTr> = T;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ type alias `traits::Alias` is reachable at visibility `pub(crate)`
@@ -147,7 +147,7 @@ LL | #![deny(private_interfaces, private_bounds)]
    |                             ^^^^^^^^^^^^^^
 
 error: trait `traits::PrivTr` is more private than the item `traits::Tr1`
-  --> $DIR/private-in-public-warn.rs:43:5
+  --> $DIR/private-in-public-warn.rs:44:5
    |
 LL |     pub trait Tr1: PrivTr {}
    |     ^^^^^^^^^^^^^^^^^^^^^ trait `traits::Tr1` is reachable at visibility `pub(crate)`
@@ -159,7 +159,7 @@ LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `traits::PrivTr` is more private than the item `traits::Tr2`
-  --> $DIR/private-in-public-warn.rs:44:5
+  --> $DIR/private-in-public-warn.rs:45:5
    |
 LL |     pub trait Tr2<T: PrivTr> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ trait `traits::Tr2` is reachable at visibility `pub(crate)`
@@ -171,7 +171,7 @@ LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `traits::PrivTr` is more private than the item `traits::Tr3::Alias`
-  --> $DIR/private-in-public-warn.rs:46:9
+  --> $DIR/private-in-public-warn.rs:47:9
    |
 LL |         type Alias: PrivTr;
    |         ^^^^^^^^^^^^^^^^^^ associated type `traits::Tr3::Alias` is reachable at visibility `pub(crate)`
@@ -183,7 +183,7 @@ LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `traits::PrivTr` is more private than the item `traits::Tr3::f`
-  --> $DIR/private-in-public-warn.rs:48:9
+  --> $DIR/private-in-public-warn.rs:49:9
    |
 LL |         fn f<T: PrivTr>(arg: T) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^ associated function `traits::Tr3::f` is reachable at visibility `pub(crate)`
@@ -194,8 +194,41 @@ 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}`
+  --> $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 {}
+   |     ^^^^^^^^^^^^
+
+error[E0446]: private trait `traits::PrivTr` in public interface
+  --> $DIR/private-in-public-warn.rs:53:19
+   |
+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:53: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 {}
+   |     ^^^^^^^^^^^^
+
 error: trait `traits::PrivTr` is more private than the item `traits::Pub<T>`
-  --> $DIR/private-in-public-warn.rs:50:5
+  --> $DIR/private-in-public-warn.rs:57:5
    |
 LL |     impl<T: PrivTr> Pub<T> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^ implementation `traits::Pub<T>` is reachable at visibility `pub(crate)`
@@ -207,103 +240,169 @@ LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `traits_where::PrivTr` is more private than the item `traits_where::Alias`
-  --> $DIR/private-in-public-warn.rs:59:5
+  --> $DIR/private-in-public-warn.rs:66:5
    |
 LL |     pub type Alias<T> where T: PrivTr = T;
    |     ^^^^^^^^^^^^^^^^^ type alias `traits_where::Alias` is reachable at visibility `pub(crate)`
    |
 note: but trait `traits_where::PrivTr` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:55:5
+  --> $DIR/private-in-public-warn.rs:62:5
    |
 LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `traits_where::PrivTr` is more private than the item `traits_where::Tr2`
-  --> $DIR/private-in-public-warn.rs:62:5
+  --> $DIR/private-in-public-warn.rs:69:5
    |
 LL |     pub trait Tr2<T> where T: PrivTr {}
    |     ^^^^^^^^^^^^^^^^ trait `traits_where::Tr2` is reachable at visibility `pub(crate)`
    |
 note: but trait `traits_where::PrivTr` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:55:5
+  --> $DIR/private-in-public-warn.rs:62:5
    |
 LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `traits_where::PrivTr` is more private than the item `traits_where::Tr3::f`
-  --> $DIR/private-in-public-warn.rs:65:9
+  --> $DIR/private-in-public-warn.rs:72:9
    |
 LL |         fn f<T>(arg: T) where T: PrivTr {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ associated function `traits_where::Tr3::f` is reachable at visibility `pub(crate)`
    |
 note: but trait `traits_where::PrivTr` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:55:5
+  --> $DIR/private-in-public-warn.rs:62:5
    |
 LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `traits_where::PrivTr` is more private than the item `traits_where::Pub<T>`
-  --> $DIR/private-in-public-warn.rs:68:5
+  --> $DIR/private-in-public-warn.rs:75:5
    |
 LL |     impl<T> Pub<T> where T: PrivTr {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation `traits_where::Pub<T>` is reachable at visibility `pub(crate)`
    |
 note: but trait `traits_where::PrivTr` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:55:5
+  --> $DIR/private-in-public-warn.rs:62:5
    |
 LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `generics::PrivTr<generics::Pub>` is more private than the item `generics::Tr1`
-  --> $DIR/private-in-public-warn.rs:79:5
+  --> $DIR/private-in-public-warn.rs:87:5
    |
 LL |     pub trait Tr1: PrivTr<Pub> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `generics::Tr1` is reachable at visibility `pub(crate)`
    |
 note: but trait `generics::PrivTr<generics::Pub>` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:76:5
+  --> $DIR/private-in-public-warn.rs:83:5
    |
 LL |     trait PrivTr<T> {}
    |     ^^^^^^^^^^^^^^^
 
 error: type `generics::Priv` is more private than the item `generics::Tr2`
-  --> $DIR/private-in-public-warn.rs:81:5
+  --> $DIR/private-in-public-warn.rs:89:5
    |
 LL |     pub trait Tr2: PubTr<Priv> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `generics::Tr2` is reachable at visibility `pub(crate)`
    |
 note: but type `generics::Priv` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:74:5
+  --> $DIR/private-in-public-warn.rs:81:5
    |
 LL |     struct Priv<T = u8>(T);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: type `generics::Priv` is more private than the item `generics::Tr3`
-  --> $DIR/private-in-public-warn.rs:82:5
+  --> $DIR/private-in-public-warn.rs:90:5
    |
 LL |     pub trait Tr3: PubTr<[Priv; 1]> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `generics::Tr3` is reachable at visibility `pub(crate)`
    |
 note: but type `generics::Priv` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:74:5
+  --> $DIR/private-in-public-warn.rs:81:5
    |
 LL |     struct Priv<T = u8>(T);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: type `generics::Priv` is more private than the item `Tr4`
-  --> $DIR/private-in-public-warn.rs:83:5
+  --> $DIR/private-in-public-warn.rs:91:5
    |
 LL |     pub trait Tr4: PubTr<Pub<Priv>> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `Tr4` is reachable at visibility `pub(crate)`
    |
 note: but type `generics::Priv` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:74:5
+  --> $DIR/private-in-public-warn.rs:81:5
+   |
+LL |     struct Priv<T = u8>(T);
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error: trait `generics::PrivTr<generics::Priv<()>>` is more private than the item `Tr5::required::{anon_assoc#0}`
+  --> $DIR/private-in-public-warn.rs:94: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:83:5
+   |
+LL |     trait PrivTr<T> {}
+   |     ^^^^^^^^^^^^^^^
+
+error: type `generics::Priv<()>` is more private than the item `Tr5::required::{anon_assoc#0}`
+  --> $DIR/private-in-public-warn.rs:94: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:81:5
+   |
+LL |     struct Priv<T = u8>(T);
+   |     ^^^^^^^^^^^^^^^^^^^
+
+error[E0446]: private trait `generics::PrivTr<generics::Priv<()>>` in public interface
+  --> $DIR/private-in-public-warn.rs:97:26
+   |
+LL |     trait PrivTr<T> {}
+   |     --------------- `generics::PrivTr<generics::Priv<()>>` declared as private
+...
+LL |         fn provided() -> impl PrivTr<Priv<()>> {}
+   |                          ^^^^^^^^^^^^^^^^^^^^^ can't leak private trait
+
+error[E0446]: private type `generics::Priv<()>` in public interface
+  --> $DIR/private-in-public-warn.rs:97:26
+   |
+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:97: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:83:5
+   |
+LL |     trait PrivTr<T> {}
+   |     ^^^^^^^^^^^^^^^
+
+error: type `generics::Priv<()>` is more private than the item `Tr5::provided::{anon_assoc#0}`
+  --> $DIR/private-in-public-warn.rs:97: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:81:5
    |
 LL |     struct Priv<T = u8>(T);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error[E0446]: private type `impls::Priv` in public interface
-  --> $DIR/private-in-public-warn.rs:109:9
+  --> $DIR/private-in-public-warn.rs:128:9
    |
 LL |     struct Priv;
    |     ----------- `impls::Priv` declared as private
@@ -312,19 +411,19 @@ LL |         type Alias = Priv;
    |         ^^^^^^^^^^ can't leak private type
 
 error: type `aliases_pub::Priv` is more private than the item `aliases_pub::<impl Pub2>::f`
-  --> $DIR/private-in-public-warn.rs:180:9
+  --> $DIR/private-in-public-warn.rs:199:9
    |
 LL |         pub fn f(arg: Priv) {}
    |         ^^^^^^^^^^^^^^^^^^^ associated function `aliases_pub::<impl Pub2>::f` is reachable at visibility `pub(crate)`
    |
 note: but type `aliases_pub::Priv` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:153:5
+  --> $DIR/private-in-public-warn.rs:172:5
    |
 LL |     struct Priv;
    |     ^^^^^^^^^^^
 
 error[E0446]: private type `aliases_pub::Priv` in public interface
-  --> $DIR/private-in-public-warn.rs:183:9
+  --> $DIR/private-in-public-warn.rs:202:9
    |
 LL |     struct Priv;
    |     ----------- `aliases_pub::Priv` declared as private
@@ -333,7 +432,7 @@ LL |         type Check = Priv;
    |         ^^^^^^^^^^ can't leak private type
 
 error[E0446]: private type `aliases_pub::Priv` in public interface
-  --> $DIR/private-in-public-warn.rs:186:9
+  --> $DIR/private-in-public-warn.rs:205:9
    |
 LL |     struct Priv;
    |     ----------- `aliases_pub::Priv` declared as private
@@ -342,7 +441,7 @@ LL |         type Check = Priv;
    |         ^^^^^^^^^^ can't leak private type
 
 error[E0446]: private type `aliases_pub::Priv` in public interface
-  --> $DIR/private-in-public-warn.rs:189:9
+  --> $DIR/private-in-public-warn.rs:208:9
    |
 LL |     struct Priv;
    |     ----------- `aliases_pub::Priv` declared as private
@@ -351,7 +450,7 @@ LL |         type Check = Priv;
    |         ^^^^^^^^^^ can't leak private type
 
 error[E0446]: private type `aliases_pub::Priv` in public interface
-  --> $DIR/private-in-public-warn.rs:192:9
+  --> $DIR/private-in-public-warn.rs:211:9
    |
 LL |     struct Priv;
    |     ----------- `aliases_pub::Priv` declared as private
@@ -360,43 +459,43 @@ LL |         type Check = Priv;
    |         ^^^^^^^^^^ can't leak private type
 
 error: trait `PrivTr1` is more private than the item `aliases_priv::Tr1`
-  --> $DIR/private-in-public-warn.rs:222:5
+  --> $DIR/private-in-public-warn.rs:241:5
    |
 LL |     pub trait Tr1: PrivUseAliasTr {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `aliases_priv::Tr1` is reachable at visibility `pub(crate)`
    |
 note: but trait `PrivTr1` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:208:5
+  --> $DIR/private-in-public-warn.rs:227:5
    |
 LL |     trait PrivTr1<T = u8> {
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: trait `PrivTr1<Priv2>` is more private than the item `aliases_priv::Tr2`
-  --> $DIR/private-in-public-warn.rs:224:5
+  --> $DIR/private-in-public-warn.rs:243:5
    |
 LL |     pub trait Tr2: PrivUseAliasTr<PrivAlias> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `aliases_priv::Tr2` is reachable at visibility `pub(crate)`
    |
 note: but trait `PrivTr1<Priv2>` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:208:5
+  --> $DIR/private-in-public-warn.rs:227:5
    |
 LL |     trait PrivTr1<T = u8> {
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: type `Priv2` is more private than the item `aliases_priv::Tr2`
-  --> $DIR/private-in-public-warn.rs:224:5
+  --> $DIR/private-in-public-warn.rs:243:5
    |
 LL |     pub trait Tr2: PrivUseAliasTr<PrivAlias> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `aliases_priv::Tr2` is reachable at visibility `pub(crate)`
    |
 note: but type `Priv2` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:206:5
+  --> $DIR/private-in-public-warn.rs:225:5
    |
 LL |     struct Priv2;
    |     ^^^^^^^^^^^^
 
 warning: bounds on generic parameters in type aliases are not enforced
-  --> $DIR/private-in-public-warn.rs:41:23
+  --> $DIR/private-in-public-warn.rs:42:23
    |
 LL |     pub type Alias<T: PrivTr> = T;
    |                     --^^^^^^
@@ -410,7 +509,7 @@ LL |     pub type Alias<T: PrivTr> = T;
    = note: `#[warn(type_alias_bounds)]` on by default
 
 warning: where clauses on type aliases are not enforced
-  --> $DIR/private-in-public-warn.rs:59:29
+  --> $DIR/private-in-public-warn.rs:66:29
    |
 LL |     pub type Alias<T> where T: PrivTr = T;
    |                       ------^^^^^^^^^
@@ -422,6 +521,6 @@ LL |     pub type Alias<T> where T: PrivTr = T;
            see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
    = help: add `#![feature(lazy_type_alias)]` to the crate attributes to enable the desired semantics
 
-error: aborting due to 34 previous errors; 2 warnings emitted
+error: aborting due to 43 previous errors; 2 warnings emitted
 
 For more information about this error, try `rustc --explain E0446`.
diff --git a/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs b/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs
index 4eeecdc0569..75640147026 100644
--- a/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs
+++ b/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs
@@ -1,5 +1,6 @@
 pub struct OtherType;
 pub trait OtherTrait {}
+impl OtherTrait for OtherType {}
 
 #[macro_export]
 macro_rules! m {
diff --git a/tests/ui/privacy/pub-priv-dep/pub-priv1.rs b/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
index 192ca0db8bd..0bad116934b 100644
--- a/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
+++ b/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
@@ -44,8 +44,15 @@ impl PublicType {
 
 pub trait MyPubTrait {
     type Foo: OtherTrait;
+    //~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
+
+    fn required() -> impl OtherTrait;
+    //~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
+
+    fn provided() -> impl OtherTrait { OtherType }
+    //~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
+    //~| ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
 }
-//~^^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
 
 pub trait WithSuperTrait: OtherTrait {}
 //~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
diff --git a/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr b/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
index 9da47827be4..275bcfcb7da 100644
--- a/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
+++ b/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
@@ -11,31 +11,31 @@ LL | #![deny(exported_private_dependencies)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: macro `m` from private dependency 'priv_dep' is re-exported
-  --> $DIR/pub-priv1.rs:94:9
+  --> $DIR/pub-priv1.rs:101:9
    |
 LL | pub use priv_dep::m;
    |         ^^^^^^^^^^^
 
 error: macro `fn_like` from private dependency 'pm' is re-exported
-  --> $DIR/pub-priv1.rs:96:9
+  --> $DIR/pub-priv1.rs:103:9
    |
 LL | pub use pm::fn_like;
    |         ^^^^^^^^^^^
 
 error: derive macro `PmDerive` from private dependency 'pm' is re-exported
-  --> $DIR/pub-priv1.rs:98:9
+  --> $DIR/pub-priv1.rs:105:9
    |
 LL | pub use pm::PmDerive;
    |         ^^^^^^^^^^^^
 
 error: attribute macro `pm_attr` from private dependency 'pm' is re-exported
-  --> $DIR/pub-priv1.rs:100:9
+  --> $DIR/pub-priv1.rs:107:9
    |
 LL | pub use pm::pm_attr;
    |         ^^^^^^^^^^^
 
 error: variant `V1` from private dependency 'priv_dep' is re-exported
-  --> $DIR/pub-priv1.rs:103:9
+  --> $DIR/pub-priv1.rs:110:9
    |
 LL | pub use priv_dep::E::V1;
    |         ^^^^^^^^^^^^^^^
@@ -65,66 +65,86 @@ LL |     type Foo: OtherTrait;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:50:1
+  --> $DIR/pub-priv1.rs:49:22
+   |
+LL |     fn required() -> impl OtherTrait;
+   |                      ^^^^^^^^^^^^^^^
+
+error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:52:22
+   |
+LL |     fn provided() -> impl OtherTrait { OtherType }
+   |                      ^^^^^^^^^^^^^^^
+
+error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:52:22
+   |
+LL |     fn provided() -> impl OtherTrait { OtherType }
+   |                      ^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:57:1
    |
 LL | pub trait WithSuperTrait: OtherTrait {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:59:5
+  --> $DIR/pub-priv1.rs:66:5
    |
 LL |     type X = OtherType;
    |     ^^^^^^
 
 error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:63:1
+  --> $DIR/pub-priv1.rs:70:1
    |
 LL | pub fn in_bounds<T: OtherTrait>(x: T) { unimplemented!() }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:66:1
+  --> $DIR/pub-priv1.rs:73:1
    |
 LL | pub fn private_in_generic() -> std::num::Saturating<OtherType> { unimplemented!() }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:69:1
+  --> $DIR/pub-priv1.rs:76:1
    |
 LL | pub static STATIC: OtherType = OtherType;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:72:1
+  --> $DIR/pub-priv1.rs:79:1
    |
 LL | pub const CONST: OtherType = OtherType;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:75:1
+  --> $DIR/pub-priv1.rs:82:1
    |
 LL | pub type Alias = OtherType;
    | ^^^^^^^^^^^^^^
 
 error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:80:1
+  --> $DIR/pub-priv1.rs:87:1
    |
 LL | impl OtherTrait for PublicWithPrivateImpl {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:85:1
+  --> $DIR/pub-priv1.rs:92:1
    |
 LL | impl PubTraitOnPrivate for OtherType {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:85:1
+  --> $DIR/pub-priv1.rs:92:1
    |
 LL | impl PubTraitOnPrivate for OtherType {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 20 previous errors
+error: aborting due to 23 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From c004a96603bf8cfdd9ac462526a8e06ad6df5b66 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 17 Jul 2025 23:51:47 +0000
Subject: Do not check privacy for RPITIT.

---
 compiler/rustc_privacy/src/lib.rs              |   8 ++
 tests/ui/privacy/private-in-public-warn.rs     |   9 --
 tests/ui/privacy/private-in-public-warn.stderr | 163 +++++--------------------
 tests/ui/privacy/pub-priv-dep/pub-priv1.rs     |   3 -
 tests/ui/privacy/pub-priv-dep/pub-priv1.stderr |  52 +++-----
 5 files changed, 56 insertions(+), 179 deletions(-)

diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index 80c13e44d7d..9dd80bc9964 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -1624,6 +1624,10 @@ impl<'tcx> PrivateItemsInPublicInterfacesChecker<'_, 'tcx> {
                 self.check(def_id, item_visibility, effective_vis).generics().predicates();
 
                 for assoc_item in tcx.associated_items(id.owner_id).in_definition_order() {
+                    if assoc_item.is_impl_trait_in_trait() {
+                        continue;
+                    }
+
                     self.check_assoc_item(assoc_item, item_visibility, effective_vis);
 
                     if assoc_item.is_type() {
@@ -1736,6 +1740,10 @@ impl<'tcx> PrivateItemsInPublicInterfacesChecker<'_, 'tcx> {
                 check.ty().trait_ref();
 
                 for assoc_item in tcx.associated_items(id.owner_id).in_definition_order() {
+                    if assoc_item.is_impl_trait_in_trait() {
+                        continue;
+                    }
+
                     let impl_item_vis = if !of_trait {
                         min(tcx.local_visibility(assoc_item.def_id.expect_local()), impl_vis, tcx)
                     } else {
diff --git a/tests/ui/privacy/private-in-public-warn.rs b/tests/ui/privacy/private-in-public-warn.rs
index 1794fa95669..f79e4641312 100644
--- a/tests/ui/privacy/private-in-public-warn.rs
+++ b/tests/ui/privacy/private-in-public-warn.rs
@@ -49,10 +49,7 @@ mod traits {
         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}`
         fn h() -> impl PrivTr {}
-        //~^ 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>`
     impl<T: PrivTr> PubTr for Pub<T> {} // OK, trait impl predicates
@@ -92,13 +89,7 @@ mod generics {
 
     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}`
         fn provided() -> impl PrivTr<Priv<()>> {}
-        //~^ 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 09dbe4d67e3..c2a57e3b82c 100644
--- a/tests/ui/privacy/private-in-public-warn.stderr
+++ b/tests/ui/privacy/private-in-public-warn.stderr
@@ -194,41 +194,8 @@ 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}`
-  --> $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 {}
-   |     ^^^^^^^^^^^^
-
-error[E0446]: private trait `traits::PrivTr` in public interface
-  --> $DIR/private-in-public-warn.rs:53:19
-   |
-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:53: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 {}
-   |     ^^^^^^^^^^^^
-
 error: trait `traits::PrivTr` is more private than the item `traits::Pub<T>`
-  --> $DIR/private-in-public-warn.rs:57:5
+  --> $DIR/private-in-public-warn.rs:54:5
    |
 LL |     impl<T: PrivTr> Pub<T> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^ implementation `traits::Pub<T>` is reachable at visibility `pub(crate)`
@@ -240,169 +207,103 @@ LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `traits_where::PrivTr` is more private than the item `traits_where::Alias`
-  --> $DIR/private-in-public-warn.rs:66:5
+  --> $DIR/private-in-public-warn.rs:63:5
    |
 LL |     pub type Alias<T> where T: PrivTr = T;
    |     ^^^^^^^^^^^^^^^^^ type alias `traits_where::Alias` is reachable at visibility `pub(crate)`
    |
 note: but trait `traits_where::PrivTr` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:62:5
+  --> $DIR/private-in-public-warn.rs:59:5
    |
 LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `traits_where::PrivTr` is more private than the item `traits_where::Tr2`
-  --> $DIR/private-in-public-warn.rs:69:5
+  --> $DIR/private-in-public-warn.rs:66:5
    |
 LL |     pub trait Tr2<T> where T: PrivTr {}
    |     ^^^^^^^^^^^^^^^^ trait `traits_where::Tr2` is reachable at visibility `pub(crate)`
    |
 note: but trait `traits_where::PrivTr` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:62:5
+  --> $DIR/private-in-public-warn.rs:59:5
    |
 LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `traits_where::PrivTr` is more private than the item `traits_where::Tr3::f`
-  --> $DIR/private-in-public-warn.rs:72:9
+  --> $DIR/private-in-public-warn.rs:69:9
    |
 LL |         fn f<T>(arg: T) where T: PrivTr {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ associated function `traits_where::Tr3::f` is reachable at visibility `pub(crate)`
    |
 note: but trait `traits_where::PrivTr` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:62:5
+  --> $DIR/private-in-public-warn.rs:59:5
    |
 LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `traits_where::PrivTr` is more private than the item `traits_where::Pub<T>`
-  --> $DIR/private-in-public-warn.rs:75:5
+  --> $DIR/private-in-public-warn.rs:72:5
    |
 LL |     impl<T> Pub<T> where T: PrivTr {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation `traits_where::Pub<T>` is reachable at visibility `pub(crate)`
    |
 note: but trait `traits_where::PrivTr` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:62:5
+  --> $DIR/private-in-public-warn.rs:59:5
    |
 LL |     trait PrivTr {}
    |     ^^^^^^^^^^^^
 
 error: trait `generics::PrivTr<generics::Pub>` is more private than the item `generics::Tr1`
-  --> $DIR/private-in-public-warn.rs:87:5
+  --> $DIR/private-in-public-warn.rs:84:5
    |
 LL |     pub trait Tr1: PrivTr<Pub> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `generics::Tr1` is reachable at visibility `pub(crate)`
    |
 note: but trait `generics::PrivTr<generics::Pub>` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:83:5
+  --> $DIR/private-in-public-warn.rs:80:5
    |
 LL |     trait PrivTr<T> {}
    |     ^^^^^^^^^^^^^^^
 
 error: type `generics::Priv` is more private than the item `generics::Tr2`
-  --> $DIR/private-in-public-warn.rs:89:5
+  --> $DIR/private-in-public-warn.rs:86:5
    |
 LL |     pub trait Tr2: PubTr<Priv> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `generics::Tr2` is reachable at visibility `pub(crate)`
    |
 note: but type `generics::Priv` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:81:5
+  --> $DIR/private-in-public-warn.rs:78:5
    |
 LL |     struct Priv<T = u8>(T);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: type `generics::Priv` is more private than the item `generics::Tr3`
-  --> $DIR/private-in-public-warn.rs:90:5
+  --> $DIR/private-in-public-warn.rs:87:5
    |
 LL |     pub trait Tr3: PubTr<[Priv; 1]> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `generics::Tr3` is reachable at visibility `pub(crate)`
    |
 note: but type `generics::Priv` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:81:5
+  --> $DIR/private-in-public-warn.rs:78:5
    |
 LL |     struct Priv<T = u8>(T);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: type `generics::Priv` is more private than the item `Tr4`
-  --> $DIR/private-in-public-warn.rs:91:5
+  --> $DIR/private-in-public-warn.rs:88:5
    |
 LL |     pub trait Tr4: PubTr<Pub<Priv>> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `Tr4` is reachable at visibility `pub(crate)`
    |
 note: but type `generics::Priv` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:81:5
-   |
-LL |     struct Priv<T = u8>(T);
-   |     ^^^^^^^^^^^^^^^^^^^
-
-error: trait `generics::PrivTr<generics::Priv<()>>` is more private than the item `Tr5::required::{anon_assoc#0}`
-  --> $DIR/private-in-public-warn.rs:94: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:83:5
-   |
-LL |     trait PrivTr<T> {}
-   |     ^^^^^^^^^^^^^^^
-
-error: type `generics::Priv<()>` is more private than the item `Tr5::required::{anon_assoc#0}`
-  --> $DIR/private-in-public-warn.rs:94: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:81:5
-   |
-LL |     struct Priv<T = u8>(T);
-   |     ^^^^^^^^^^^^^^^^^^^
-
-error[E0446]: private trait `generics::PrivTr<generics::Priv<()>>` in public interface
-  --> $DIR/private-in-public-warn.rs:97:26
-   |
-LL |     trait PrivTr<T> {}
-   |     --------------- `generics::PrivTr<generics::Priv<()>>` declared as private
-...
-LL |         fn provided() -> impl PrivTr<Priv<()>> {}
-   |                          ^^^^^^^^^^^^^^^^^^^^^ can't leak private trait
-
-error[E0446]: private type `generics::Priv<()>` in public interface
-  --> $DIR/private-in-public-warn.rs:97:26
-   |
-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:97: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:83:5
-   |
-LL |     trait PrivTr<T> {}
-   |     ^^^^^^^^^^^^^^^
-
-error: type `generics::Priv<()>` is more private than the item `Tr5::provided::{anon_assoc#0}`
-  --> $DIR/private-in-public-warn.rs:97: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:81:5
+  --> $DIR/private-in-public-warn.rs:78:5
    |
 LL |     struct Priv<T = u8>(T);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error[E0446]: private type `impls::Priv` in public interface
-  --> $DIR/private-in-public-warn.rs:128:9
+  --> $DIR/private-in-public-warn.rs:119:9
    |
 LL |     struct Priv;
    |     ----------- `impls::Priv` declared as private
@@ -411,19 +312,19 @@ LL |         type Alias = Priv;
    |         ^^^^^^^^^^ can't leak private type
 
 error: type `aliases_pub::Priv` is more private than the item `aliases_pub::<impl Pub2>::f`
-  --> $DIR/private-in-public-warn.rs:199:9
+  --> $DIR/private-in-public-warn.rs:190:9
    |
 LL |         pub fn f(arg: Priv) {}
    |         ^^^^^^^^^^^^^^^^^^^ associated function `aliases_pub::<impl Pub2>::f` is reachable at visibility `pub(crate)`
    |
 note: but type `aliases_pub::Priv` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:172:5
+  --> $DIR/private-in-public-warn.rs:163:5
    |
 LL |     struct Priv;
    |     ^^^^^^^^^^^
 
 error[E0446]: private type `aliases_pub::Priv` in public interface
-  --> $DIR/private-in-public-warn.rs:202:9
+  --> $DIR/private-in-public-warn.rs:193:9
    |
 LL |     struct Priv;
    |     ----------- `aliases_pub::Priv` declared as private
@@ -432,7 +333,7 @@ LL |         type Check = Priv;
    |         ^^^^^^^^^^ can't leak private type
 
 error[E0446]: private type `aliases_pub::Priv` in public interface
-  --> $DIR/private-in-public-warn.rs:205:9
+  --> $DIR/private-in-public-warn.rs:196:9
    |
 LL |     struct Priv;
    |     ----------- `aliases_pub::Priv` declared as private
@@ -441,7 +342,7 @@ LL |         type Check = Priv;
    |         ^^^^^^^^^^ can't leak private type
 
 error[E0446]: private type `aliases_pub::Priv` in public interface
-  --> $DIR/private-in-public-warn.rs:208:9
+  --> $DIR/private-in-public-warn.rs:199:9
    |
 LL |     struct Priv;
    |     ----------- `aliases_pub::Priv` declared as private
@@ -450,7 +351,7 @@ LL |         type Check = Priv;
    |         ^^^^^^^^^^ can't leak private type
 
 error[E0446]: private type `aliases_pub::Priv` in public interface
-  --> $DIR/private-in-public-warn.rs:211:9
+  --> $DIR/private-in-public-warn.rs:202:9
    |
 LL |     struct Priv;
    |     ----------- `aliases_pub::Priv` declared as private
@@ -459,37 +360,37 @@ LL |         type Check = Priv;
    |         ^^^^^^^^^^ can't leak private type
 
 error: trait `PrivTr1` is more private than the item `aliases_priv::Tr1`
-  --> $DIR/private-in-public-warn.rs:241:5
+  --> $DIR/private-in-public-warn.rs:232:5
    |
 LL |     pub trait Tr1: PrivUseAliasTr {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `aliases_priv::Tr1` is reachable at visibility `pub(crate)`
    |
 note: but trait `PrivTr1` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:227:5
+  --> $DIR/private-in-public-warn.rs:218:5
    |
 LL |     trait PrivTr1<T = u8> {
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: trait `PrivTr1<Priv2>` is more private than the item `aliases_priv::Tr2`
-  --> $DIR/private-in-public-warn.rs:243:5
+  --> $DIR/private-in-public-warn.rs:234:5
    |
 LL |     pub trait Tr2: PrivUseAliasTr<PrivAlias> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `aliases_priv::Tr2` is reachable at visibility `pub(crate)`
    |
 note: but trait `PrivTr1<Priv2>` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:227:5
+  --> $DIR/private-in-public-warn.rs:218:5
    |
 LL |     trait PrivTr1<T = u8> {
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: type `Priv2` is more private than the item `aliases_priv::Tr2`
-  --> $DIR/private-in-public-warn.rs:243:5
+  --> $DIR/private-in-public-warn.rs:234:5
    |
 LL |     pub trait Tr2: PrivUseAliasTr<PrivAlias> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait `aliases_priv::Tr2` is reachable at visibility `pub(crate)`
    |
 note: but type `Priv2` is only usable at visibility `pub(self)`
-  --> $DIR/private-in-public-warn.rs:225:5
+  --> $DIR/private-in-public-warn.rs:216:5
    |
 LL |     struct Priv2;
    |     ^^^^^^^^^^^^
@@ -509,7 +410,7 @@ LL |     pub type Alias<T: PrivTr> = T;
    = note: `#[warn(type_alias_bounds)]` on by default
 
 warning: where clauses on type aliases are not enforced
-  --> $DIR/private-in-public-warn.rs:66:29
+  --> $DIR/private-in-public-warn.rs:63:29
    |
 LL |     pub type Alias<T> where T: PrivTr = T;
    |                       ------^^^^^^^^^
@@ -521,6 +422,6 @@ LL |     pub type Alias<T> where T: PrivTr = T;
            see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
    = help: add `#![feature(lazy_type_alias)]` to the crate attributes to enable the desired semantics
 
-error: aborting due to 43 previous errors; 2 warnings emitted
+error: aborting due to 34 previous errors; 2 warnings emitted
 
 For more information about this error, try `rustc --explain E0446`.
diff --git a/tests/ui/privacy/pub-priv-dep/pub-priv1.rs b/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
index 0bad116934b..b85f2754fb1 100644
--- a/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
+++ b/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
@@ -47,11 +47,8 @@ pub trait MyPubTrait {
     //~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
 
     fn required() -> impl OtherTrait;
-    //~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
 
     fn provided() -> impl OtherTrait { OtherType }
-    //~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
-    //~| ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
 }
 
 pub trait WithSuperTrait: OtherTrait {}
diff --git a/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr b/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
index 275bcfcb7da..24bd071567f 100644
--- a/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
+++ b/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
@@ -11,31 +11,31 @@ LL | #![deny(exported_private_dependencies)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: macro `m` from private dependency 'priv_dep' is re-exported
-  --> $DIR/pub-priv1.rs:101:9
+  --> $DIR/pub-priv1.rs:98:9
    |
 LL | pub use priv_dep::m;
    |         ^^^^^^^^^^^
 
 error: macro `fn_like` from private dependency 'pm' is re-exported
-  --> $DIR/pub-priv1.rs:103:9
+  --> $DIR/pub-priv1.rs:100:9
    |
 LL | pub use pm::fn_like;
    |         ^^^^^^^^^^^
 
 error: derive macro `PmDerive` from private dependency 'pm' is re-exported
-  --> $DIR/pub-priv1.rs:105:9
+  --> $DIR/pub-priv1.rs:102:9
    |
 LL | pub use pm::PmDerive;
    |         ^^^^^^^^^^^^
 
 error: attribute macro `pm_attr` from private dependency 'pm' is re-exported
-  --> $DIR/pub-priv1.rs:107:9
+  --> $DIR/pub-priv1.rs:104:9
    |
 LL | pub use pm::pm_attr;
    |         ^^^^^^^^^^^
 
 error: variant `V1` from private dependency 'priv_dep' is re-exported
-  --> $DIR/pub-priv1.rs:110:9
+  --> $DIR/pub-priv1.rs:107:9
    |
 LL | pub use priv_dep::E::V1;
    |         ^^^^^^^^^^^^^^^
@@ -65,86 +65,66 @@ LL |     type Foo: OtherTrait;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:49:22
-   |
-LL |     fn required() -> impl OtherTrait;
-   |                      ^^^^^^^^^^^^^^^
-
-error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:52:22
-   |
-LL |     fn provided() -> impl OtherTrait { OtherType }
-   |                      ^^^^^^^^^^^^^^^
-
-error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:52:22
-   |
-LL |     fn provided() -> impl OtherTrait { OtherType }
-   |                      ^^^^^^^^^^^^^^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:57:1
+  --> $DIR/pub-priv1.rs:54:1
    |
 LL | pub trait WithSuperTrait: OtherTrait {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:66:5
+  --> $DIR/pub-priv1.rs:63:5
    |
 LL |     type X = OtherType;
    |     ^^^^^^
 
 error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:70:1
+  --> $DIR/pub-priv1.rs:67:1
    |
 LL | pub fn in_bounds<T: OtherTrait>(x: T) { unimplemented!() }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:73:1
+  --> $DIR/pub-priv1.rs:70:1
    |
 LL | pub fn private_in_generic() -> std::num::Saturating<OtherType> { unimplemented!() }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:76:1
+  --> $DIR/pub-priv1.rs:73:1
    |
 LL | pub static STATIC: OtherType = OtherType;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:79:1
+  --> $DIR/pub-priv1.rs:76:1
    |
 LL | pub const CONST: OtherType = OtherType;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:82:1
+  --> $DIR/pub-priv1.rs:79:1
    |
 LL | pub type Alias = OtherType;
    | ^^^^^^^^^^^^^^
 
 error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:87:1
+  --> $DIR/pub-priv1.rs:84:1
    |
 LL | impl OtherTrait for PublicWithPrivateImpl {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:92:1
+  --> $DIR/pub-priv1.rs:89:1
    |
 LL | impl PubTraitOnPrivate for OtherType {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:92:1
+  --> $DIR/pub-priv1.rs:89:1
    |
 LL | impl PubTraitOnPrivate for OtherType {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 23 previous errors
+error: aborting due to 20 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2ce0b665d37bceddb29e6dbd45172299380e13f7 Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Wed, 18 Jun 2025 15:35:22 +0200
Subject: HIR ty lowering: Simplify signature of `lower_poly_trait_ref`

---
 .../src/hir_ty_lowering/bounds.rs                  |  6 +---
 .../src/hir_ty_lowering/dyn_compatibility.rs       | 24 +++++--------
 .../rustc_hir_analysis/src/hir_ty_lowering/mod.rs  | 13 ++++---
 .../mutually-exclusive-trait-bound-modifiers.rs    |  3 ++
 ...mutually-exclusive-trait-bound-modifiers.stderr | 40 ++++++++++++++++++----
 5 files changed, 54 insertions(+), 32 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
index 9a752aeccdd..b59ff863383 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -482,12 +482,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
             match hir_bound {
                 hir::GenericBound::Trait(poly_trait_ref) => {
-                    let hir::TraitBoundModifiers { constness, polarity } = poly_trait_ref.modifiers;
                     let _ = self.lower_poly_trait_ref(
-                        &poly_trait_ref.trait_ref,
-                        poly_trait_ref.span,
-                        constness,
-                        polarity,
+                        poly_trait_ref,
                         param_ty,
                         bounds,
                         predicate_filter,
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
index 364ad38556b..474025e07af 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
@@ -18,9 +18,7 @@ use tracing::{debug, instrument};
 
 use super::HirTyLowerer;
 use crate::errors::SelfInTypeAlias;
-use crate::hir_ty_lowering::{
-    GenericArgCountMismatch, GenericArgCountResult, PredicateFilter, RegionInferReason,
-};
+use crate::hir_ty_lowering::{GenericArgCountMismatch, PredicateFilter, RegionInferReason};
 
 impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     /// Lower a trait object type from the HIR to our internal notion of a type.
@@ -38,24 +36,18 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         let mut user_written_bounds = Vec::new();
         let mut potential_assoc_types = Vec::new();
-        for trait_bound in hir_bounds.iter() {
-            if let hir::BoundPolarity::Maybe(_) = trait_bound.modifiers.polarity {
+        for poly_trait_ref in hir_bounds.iter() {
+            if let hir::BoundPolarity::Maybe(_) = poly_trait_ref.modifiers.polarity {
                 continue;
             }
-            if let GenericArgCountResult {
-                correct:
-                    Err(GenericArgCountMismatch { invalid_args: cur_potential_assoc_types, .. }),
-                ..
-            } = self.lower_poly_trait_ref(
-                &trait_bound.trait_ref,
-                trait_bound.span,
-                trait_bound.modifiers.constness,
-                hir::BoundPolarity::Positive,
+            let result = self.lower_poly_trait_ref(
+                poly_trait_ref,
                 dummy_self,
                 &mut user_written_bounds,
                 PredicateFilter::SelfOnly,
-            ) {
-                potential_assoc_types.extend(cur_potential_assoc_types);
+            );
+            if let Err(GenericArgCountMismatch { invalid_args, .. }) = result.correct {
+                potential_assoc_types.extend(invalid_args);
             }
         }
 
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 a5bd7c1a34a..5521f97059b 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -747,17 +747,20 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     /// If for example you had `for<'a> Foo<'a>: Bar<'a>`, then the `self_ty` would be `Foo<'a>`
     /// where `'a` is a bound region at depth 0. Similarly, the `trait_ref` would be `Bar<'a>`.
     /// The lowered poly-trait-ref will track this binder explicitly, however.
-    #[instrument(level = "debug", skip(self, span, constness, bounds))]
+    #[instrument(level = "debug", skip(self, bounds))]
     pub(crate) fn lower_poly_trait_ref(
         &self,
-        trait_ref: &hir::TraitRef<'tcx>,
-        span: Span,
-        constness: hir::BoundConstness,
-        polarity: hir::BoundPolarity,
+        poly_trait_ref: &hir::PolyTraitRef<'tcx>,
         self_ty: Ty<'tcx>,
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         predicate_filter: PredicateFilter,
     ) -> GenericArgCountResult {
+        // We use the *resolved* bound vars later instead of the HIR ones since the former
+        // also include the bound vars of the overarching predicate if applicable.
+        let hir::PolyTraitRef { bound_generic_params: _, modifiers, ref trait_ref, span } =
+            *poly_trait_ref;
+        let hir::TraitBoundModifiers { constness, polarity } = modifiers;
+
         let trait_def_id = trait_ref.trait_def_id().unwrap_or_else(|| FatalError.raise());
         let trait_segment = trait_ref.path.segments.last().unwrap();
 
diff --git a/tests/ui/traits/const-traits/mutually-exclusive-trait-bound-modifiers.rs b/tests/ui/traits/const-traits/mutually-exclusive-trait-bound-modifiers.rs
index 5f47778a140..8d1d3a4c790 100644
--- a/tests/ui/traits/const-traits/mutually-exclusive-trait-bound-modifiers.rs
+++ b/tests/ui/traits/const-traits/mutually-exclusive-trait-bound-modifiers.rs
@@ -2,9 +2,12 @@
 
 const fn maybe_const_maybe<T: [const] ?Sized>() {}
 //~^ ERROR `[const]` trait not allowed with `?` trait polarity modifier
+//~| ERROR `[const]` can only be applied to `const` traits
+//~| ERROR `[const]` can only be applied to `const` traits
 
 fn const_maybe<T: const ?Sized>() {}
 //~^ ERROR `const` trait not allowed with `?` trait polarity modifier
+//~| ERROR `const` can only be applied to `const` traits
 
 const fn maybe_const_negative<T: [const] !Trait>() {}
 //~^ ERROR `[const]` trait not allowed with `!` trait polarity modifier
diff --git a/tests/ui/traits/const-traits/mutually-exclusive-trait-bound-modifiers.stderr b/tests/ui/traits/const-traits/mutually-exclusive-trait-bound-modifiers.stderr
index 429131f905f..0ac40c51270 100644
--- a/tests/ui/traits/const-traits/mutually-exclusive-trait-bound-modifiers.stderr
+++ b/tests/ui/traits/const-traits/mutually-exclusive-trait-bound-modifiers.stderr
@@ -7,7 +7,7 @@ LL | const fn maybe_const_maybe<T: [const] ?Sized>() {}
    |                               there is not a well-defined meaning for a `[const] ?` trait
 
 error: `const` trait not allowed with `?` trait polarity modifier
-  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:6:25
+  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:8:25
    |
 LL | fn const_maybe<T: const ?Sized>() {}
    |                   ----- ^
@@ -15,7 +15,7 @@ LL | fn const_maybe<T: const ?Sized>() {}
    |                   there is not a well-defined meaning for a `const ?` trait
 
 error: `[const]` trait not allowed with `!` trait polarity modifier
-  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:9:42
+  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:12:42
    |
 LL | const fn maybe_const_negative<T: [const] !Trait>() {}
    |                                  ------- ^
@@ -23,7 +23,7 @@ LL | const fn maybe_const_negative<T: [const] !Trait>() {}
    |                                  there is not a well-defined meaning for a `[const] !` trait
 
 error: `const` trait not allowed with `!` trait polarity modifier
-  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:13:28
+  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:16:28
    |
 LL | fn const_negative<T: const !Trait>() {}
    |                      ----- ^
@@ -31,16 +31,44 @@ LL | fn const_negative<T: const !Trait>() {}
    |                      there is not a well-defined meaning for a `const !` trait
 
 error: negative bounds are not supported
-  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:9:42
+  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:12:42
    |
 LL | const fn maybe_const_negative<T: [const] !Trait>() {}
    |                                          ^
 
 error: negative bounds are not supported
-  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:13:28
+  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:16:28
    |
 LL | fn const_negative<T: const !Trait>() {}
    |                            ^
 
-error: aborting due to 6 previous errors
+error: `[const]` can only be applied to `const` traits
+  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:3:31
+   |
+LL | const fn maybe_const_maybe<T: [const] ?Sized>() {}
+   |                               ^^^^^^^ can't be applied to `Sized`
+   |
+note: `Sized` can't be used with `[const]` because it isn't `const`
+  --> $SRC_DIR/core/src/marker.rs:LL:COL
+
+error: `[const]` can only be applied to `const` traits
+  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:3:31
+   |
+LL | const fn maybe_const_maybe<T: [const] ?Sized>() {}
+   |                               ^^^^^^^ can't be applied to `Sized`
+   |
+note: `Sized` can't be used with `[const]` because it isn't `const`
+  --> $SRC_DIR/core/src/marker.rs:LL:COL
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: `const` can only be applied to `const` traits
+  --> $DIR/mutually-exclusive-trait-bound-modifiers.rs:8:19
+   |
+LL | fn const_maybe<T: const ?Sized>() {}
+   |                   ^^^^^ can't be applied to `Sized`
+   |
+note: `Sized` can't be used with `const` because it isn't `const`
+  --> $SRC_DIR/core/src/marker.rs:LL:COL
+
+error: aborting due to 9 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 10d7e5faf20d019568de77503cb13f0203296d02 Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Wed, 18 Jun 2025 16:43:38 +0200
Subject: HIR ty lowering: Validate relaxed bounds in trait object types

Only relevant to the internal feature `more_maybe_bounds`.
---
 .../src/hir_ty_lowering/dyn_compatibility.rs       |  3 ---
 .../maybe-bounds-in-dyn-traits.rs                  |  4 ++++
 .../maybe-bounds-in-dyn-traits.stderr              | 25 ++++++++++++++++++++--
 3 files changed, 27 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
index 474025e07af..813353c12aa 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
@@ -37,9 +37,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let mut user_written_bounds = Vec::new();
         let mut potential_assoc_types = Vec::new();
         for poly_trait_ref in hir_bounds.iter() {
-            if let hir::BoundPolarity::Maybe(_) = poly_trait_ref.modifiers.polarity {
-                continue;
-            }
             let result = self.lower_poly_trait_ref(
                 poly_trait_ref,
                 dummy_self,
diff --git a/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.rs b/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.rs
index 5069cd256b2..e7cca41a47e 100644
--- a/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.rs
+++ b/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.rs
@@ -64,4 +64,8 @@ fn main() {
     x.leak_foo();
     //~^ ERROR the trait bound `dyn Trait: Leak` is not satisfied
     x.maybe_leak_foo();
+    // Ensure that we validate the generic args of relaxed bounds in trait object types.
+    let _: dyn Trait + ?Leak<(), Undefined = ()>;
+    //~^ ERROR trait takes 0 generic arguments but 1 generic argument was supplied
+    //~| ERROR associated type `Undefined` not found for `Leak`
 }
diff --git a/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.stderr b/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.stderr
index 48745e40268..350233b7cbe 100644
--- a/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.stderr
+++ b/tests/ui/traits/default_auto_traits/maybe-bounds-in-dyn-traits.stderr
@@ -18,6 +18,27 @@ note: required by a bound in `Trait::leak_foo`
 LL |     fn leak_foo(&self) {}
    |     ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Trait::leak_foo`
 
-error: aborting due to 2 previous errors
+error[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/maybe-bounds-in-dyn-traits.rs:68:25
+   |
+LL |     let _: dyn Trait + ?Leak<(), Undefined = ()>;
+   |                         ^^^^-------------------- help: remove the unnecessary generics
+   |                         |
+   |                         expected 0 generic arguments
+   |
+note: trait defined here, with 0 generic parameters
+  --> $DIR/maybe-bounds-in-dyn-traits.rs:44:12
+   |
+LL | auto trait Leak {}
+   |            ^^^^
+
+error[E0220]: associated type `Undefined` not found for `Leak`
+  --> $DIR/maybe-bounds-in-dyn-traits.rs:68:34
+   |
+LL |     let _: dyn Trait + ?Leak<(), Undefined = ()>;
+   |                                  ^^^^^^^^^ associated type `Undefined` not found
+
+error: aborting due to 4 previous errors
 
-For more information about this error, try `rustc --explain E0277`.
+Some errors have detailed explanations: E0107, E0220, E0277.
+For more information about an error, try `rustc --explain E0107`.
-- 
cgit 1.4.1-3-g733a5


From 9788f59bbf893965db98dc633e64e4405414b698 Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Wed, 18 Jun 2025 17:02:51 +0200
Subject: Update comment about `where Ty:`

We no longer move trait predicates where the self ty is a ty param to
"the bounds of a ty param".
---
 compiler/rustc_hir_analysis/src/collect/predicates_of.rs | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index f2f1560d8b2..cc53919626e 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -267,20 +267,16 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
         match predicate.kind {
             hir::WherePredicateKind::BoundPredicate(bound_pred) => {
                 let ty = icx.lowerer().lower_ty_maybe_return_type_notation(bound_pred.bounded_ty);
-
                 let bound_vars = tcx.late_bound_vars(predicate.hir_id);
-                // Keep the type around in a dummy predicate, in case of no bounds.
-                // That way, `where Ty:` is not a complete noop (see #53696) and `Ty`
-                // is still checked for WF.
+
+                // This is a `where Ty:` (sic!).
                 if bound_pred.bounds.is_empty() {
                     if let ty::Param(_) = ty.kind() {
-                        // This is a `where T:`, which can be in the HIR from the
-                        // transformation that moves `?Sized` to `T`'s declaration.
-                        // We can skip the predicate because type parameters are
-                        // trivially WF, but also we *should*, to avoid exposing
-                        // users who never wrote `where Type:,` themselves, to
-                        // compiler/tooling bugs from not handling WF predicates.
+                        // We can skip the predicate because type parameters are trivially WF.
                     } else {
+                        // Keep the type around in a dummy predicate. That way, it's not a complete
+                        // noop (see #53696) and `Ty` is still checked for WF.
+
                         let span = bound_pred.bounded_ty.span;
                         let predicate = ty::Binder::bind_with_vars(
                             ty::ClauseKind::WellFormed(ty.into()),
-- 
cgit 1.4.1-3-g733a5


From 1df99f22d3a1776b36fc00fc35626fd841f7242f Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Wed, 18 Jun 2025 22:10:53 +0200
Subject: AST lowering: More robustly deal with relaxed bounds

---
 compiler/rustc_ast_lowering/messages.ftl           |   3 -
 compiler/rustc_ast_lowering/src/errors.rs          |   7 --
 compiler/rustc_ast_lowering/src/item.rs            | 112 ++++++------------
 compiler/rustc_ast_lowering/src/lib.rs             | 128 +++++++++++++++++----
 compiler/rustc_ast_passes/messages.ftl             |   5 -
 compiler/rustc_ast_passes/src/ast_validation.rs    |  23 ----
 compiler/rustc_ast_passes/src/errors.rs            |  16 ---
 .../missing-associated_item_or_field_def_ids.rs    |   5 +-
 ...missing-associated_item_or_field_def_ids.stderr |  24 ++--
 ...-getting-associated-items-of-undefined-trait.rs |   5 +-
 ...ting-associated-items-of-undefined-trait.stderr |  27 ++---
 .../feature-gate-more-maybe-bounds.stderr          |  17 ++-
 tests/ui/sized-hierarchy/default-supertrait.stderr |   4 +-
 .../maybe-trait-bounds-forbidden-locations.stderr  |   2 +-
 tests/ui/unsized/maybe-bounds-where.rs             |  28 -----
 tests/ui/unsized/maybe-bounds-where.stderr         |  70 -----------
 tests/ui/unsized/relaxed-bounds-invalid-places.rs  |  31 +++++
 .../unsized/relaxed-bounds-invalid-places.stderr   |  70 +++++++++++
 18 files changed, 278 insertions(+), 299 deletions(-)
 delete mode 100644 tests/ui/unsized/maybe-bounds-where.rs
 delete mode 100644 tests/ui/unsized/maybe-bounds-where.stderr
 create mode 100644 tests/ui/unsized/relaxed-bounds-invalid-places.rs
 create mode 100644 tests/ui/unsized/relaxed-bounds-invalid-places.stderr

diff --git a/compiler/rustc_ast_lowering/messages.ftl b/compiler/rustc_ast_lowering/messages.ftl
index c6472fd45fa..370b15d2871 100644
--- a/compiler/rustc_ast_lowering/messages.ftl
+++ b/compiler/rustc_ast_lowering/messages.ftl
@@ -127,9 +127,6 @@ ast_lowering_misplaced_impl_trait =
     `impl Trait` is not allowed in {$position}
     .note = `impl Trait` is only allowed in arguments and return types of functions and methods
 
-ast_lowering_misplaced_relax_trait_bound =
-    `?Trait` bounds are only permitted at the point where a type parameter is declared
-
 ast_lowering_never_pattern_with_body =
     a never pattern is always unreachable
     .label = this will never be executed
diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs
index b444324ef91..83f3a976e83 100644
--- a/compiler/rustc_ast_lowering/src/errors.rs
+++ b/compiler/rustc_ast_lowering/src/errors.rs
@@ -324,13 +324,6 @@ pub(crate) struct MisplacedDoubleDot {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(ast_lowering_misplaced_relax_trait_bound)]
-pub(crate) struct MisplacedRelaxTraitBound {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(ast_lowering_match_arm_with_no_body)]
 pub(crate) struct MatchArmWithNoBody {
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index abd70c7517c..ddf01b69e7f 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -16,14 +16,11 @@ use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 use tracing::instrument;
 
-use super::errors::{
-    InvalidAbi, InvalidAbiSuggestion, MisplacedRelaxTraitBound, TupleStructWithDefault,
-    UnionWithDefault,
-};
+use super::errors::{InvalidAbi, InvalidAbiSuggestion, TupleStructWithDefault, UnionWithDefault};
 use super::stability::{enabled_names, gate_unstable_abi};
 use super::{
     AstOwner, FnDeclKind, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
-    ResolverAstLoweringExt,
+    RelaxedBoundForbiddenReason, RelaxedBoundPolicy, ResolverAstLoweringExt,
 };
 
 pub(super) struct ItemLowerer<'a, 'hir> {
@@ -435,6 +432,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     |this| {
                         let bounds = this.lower_param_bounds(
                             bounds,
+                            RelaxedBoundPolicy::Forbidden(RelaxedBoundForbiddenReason::SuperTrait),
                             ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                         );
                         let items = this.arena.alloc_from_iter(
@@ -455,6 +453,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     |this| {
                         this.lower_param_bounds(
                             bounds,
+                            RelaxedBoundPolicy::Allowed,
                             ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                         )
                     },
@@ -940,6 +939,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         hir::TraitItemKind::Type(
                             this.lower_param_bounds(
                                 bounds,
+                                RelaxedBoundPolicy::Allowed,
                                 ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                             ),
                             ty,
@@ -1677,61 +1677,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
         assert!(self.impl_trait_defs.is_empty());
         assert!(self.impl_trait_bounds.is_empty());
 
-        // Error if `?Trait` bounds in where clauses don't refer directly to type parameters.
-        // Note: we used to clone these bounds directly onto the type parameter (and avoid lowering
-        // these into hir when we lower thee where clauses), but this makes it quite difficult to
-        // keep track of the Span info. Now, `<dyn HirTyLowerer>::add_implicit_sized_bound`
-        // checks both param bounds and where clauses for `?Sized`.
-        for pred in &generics.where_clause.predicates {
-            let WherePredicateKind::BoundPredicate(bound_pred) = &pred.kind else {
-                continue;
-            };
-            let compute_is_param = || {
-                // Check if the where clause type is a plain type parameter.
-                match self
-                    .resolver
-                    .get_partial_res(bound_pred.bounded_ty.id)
-                    .and_then(|r| r.full_res())
-                {
-                    Some(Res::Def(DefKind::TyParam, def_id))
-                        if bound_pred.bound_generic_params.is_empty() =>
-                    {
-                        generics
-                            .params
-                            .iter()
-                            .any(|p| def_id == self.local_def_id(p.id).to_def_id())
-                    }
-                    // Either the `bounded_ty` is not a plain type parameter, or
-                    // it's not found in the generic type parameters list.
-                    _ => false,
-                }
-            };
-            // We only need to compute this once per `WherePredicate`, but don't
-            // need to compute this at all unless there is a Maybe bound.
-            let mut is_param: Option<bool> = None;
-            for bound in &bound_pred.bounds {
-                if !matches!(
-                    *bound,
-                    GenericBound::Trait(PolyTraitRef {
-                        modifiers: TraitBoundModifiers { polarity: BoundPolarity::Maybe(_), .. },
-                        ..
-                    })
-                ) {
-                    continue;
-                }
-                let is_param = *is_param.get_or_insert_with(compute_is_param);
-                if !is_param && !self.tcx.features().more_maybe_bounds() {
-                    self.tcx
-                        .sess
-                        .create_feature_err(
-                            MisplacedRelaxTraitBound { span: bound.span() },
-                            sym::more_maybe_bounds,
-                        )
-                        .emit();
-                }
-            }
-        }
-
         let mut predicates: SmallVec<[hir::WherePredicate<'hir>; 4]> = SmallVec::new();
         predicates.extend(generics.params.iter().filter_map(|param| {
             self.lower_generic_bound_predicate(
@@ -1741,6 +1686,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 &param.bounds,
                 param.colon_span,
                 generics.span,
+                RelaxedBoundPolicy::Allowed,
                 itctx,
                 PredicateOrigin::GenericParam,
             )
@@ -1750,7 +1696,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 .where_clause
                 .predicates
                 .iter()
-                .map(|predicate| self.lower_where_predicate(predicate)),
+                .map(|predicate| self.lower_where_predicate(predicate, &generics.params)),
         );
 
         let mut params: SmallVec<[hir::GenericParam<'hir>; 4]> = self
@@ -1827,6 +1773,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         bounds: &[GenericBound],
         colon_span: Option<Span>,
         parent_span: Span,
+        rbp: RelaxedBoundPolicy<'_>,
         itctx: ImplTraitContext,
         origin: PredicateOrigin,
     ) -> Option<hir::WherePredicate<'hir>> {
@@ -1835,7 +1782,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             return None;
         }
 
-        let bounds = self.lower_param_bounds(bounds, itctx);
+        let bounds = self.lower_param_bounds(bounds, rbp, itctx);
 
         let param_span = ident.span;
 
@@ -1887,7 +1834,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         Some(hir::WherePredicate { hir_id, span, kind })
     }
 
-    fn lower_where_predicate(&mut self, pred: &WherePredicate) -> hir::WherePredicate<'hir> {
+    fn lower_where_predicate(
+        &mut self,
+        pred: &WherePredicate,
+        params: &[ast::GenericParam],
+    ) -> hir::WherePredicate<'hir> {
         let hir_id = self.lower_node_id(pred.id);
         let span = self.lower_span(pred.span);
         self.lower_attrs(hir_id, &pred.attrs, span);
@@ -1896,17 +1847,29 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 bound_generic_params,
                 bounded_ty,
                 bounds,
-            }) => hir::WherePredicateKind::BoundPredicate(hir::WhereBoundPredicate {
-                bound_generic_params: self
-                    .lower_generic_params(bound_generic_params, hir::GenericParamSource::Binder),
-                bounded_ty: self
-                    .lower_ty(bounded_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
-                bounds: self.lower_param_bounds(
-                    bounds,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
-                ),
-                origin: PredicateOrigin::WhereClause,
-            }),
+            }) => {
+                let rbp = if bound_generic_params.is_empty() {
+                    RelaxedBoundPolicy::AllowedIfOnTyParam(bounded_ty.id, params)
+                } else {
+                    RelaxedBoundPolicy::Forbidden(RelaxedBoundForbiddenReason::LateBoundVarsInScope)
+                };
+                hir::WherePredicateKind::BoundPredicate(hir::WhereBoundPredicate {
+                    bound_generic_params: self.lower_generic_params(
+                        bound_generic_params,
+                        hir::GenericParamSource::Binder,
+                    ),
+                    bounded_ty: self.lower_ty(
+                        bounded_ty,
+                        ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                    ),
+                    bounds: self.lower_param_bounds(
+                        bounds,
+                        rbp,
+                        ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                    ),
+                    origin: PredicateOrigin::WhereClause,
+                })
+            }
             WherePredicateKind::RegionPredicate(WhereRegionPredicate { lifetime, bounds }) => {
                 hir::WherePredicateKind::RegionPredicate(hir::WhereRegionPredicate {
                     lifetime: self.lower_lifetime(
@@ -1916,6 +1879,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     ),
                     bounds: self.lower_param_bounds(
                         bounds,
+                        RelaxedBoundPolicy::Allowed,
                         ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                     ),
                     in_where_clause: true,
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 1c96a375035..d3d521e83b0 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -53,14 +53,14 @@ use rustc_hir::def::{DefKind, LifetimeRes, Namespace, PartialRes, PerNS, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE, LocalDefId};
 use rustc_hir::lints::DelayedLint;
 use rustc_hir::{
-    self as hir, AngleBrackets, ConstArg, GenericArg, HirId, ItemLocalMap, LangItem,
-    LifetimeSource, LifetimeSyntax, ParamName, TraitCandidate,
+    self as hir, AngleBrackets, ConstArg, GenericArg, HirId, ItemLocalMap, LifetimeSource,
+    LifetimeSyntax, ParamName, TraitCandidate,
 };
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::extension;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
-use rustc_session::parse::add_feature_diagnostics;
+use rustc_session::parse::{add_feature_diagnostics, feature_err};
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
 use rustc_span::{DUMMY_SP, DesugaringKind, Span};
 use smallvec::SmallVec;
@@ -281,6 +281,24 @@ impl ResolverAstLowering {
     }
 }
 
+/// How relaxed bounds `?Trait` should be treated.
+///
+/// Relaxed bounds should only be allowed in places where we later
+/// (namely during HIR ty lowering) perform *sized elaboration*.
+#[derive(Clone, Copy, Debug)]
+enum RelaxedBoundPolicy<'a> {
+    Allowed,
+    AllowedIfOnTyParam(NodeId, &'a [ast::GenericParam]),
+    Forbidden(RelaxedBoundForbiddenReason),
+}
+
+#[derive(Clone, Copy, Debug)]
+enum RelaxedBoundForbiddenReason {
+    TraitObjectTy,
+    SuperTrait,
+    LateBoundVarsInScope,
+}
+
 /// Context of `impl Trait` in code, which determines whether it is allowed in an HIR subtree,
 /// and if so, what meaning it has.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -1084,10 +1102,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         &*self.arena.alloc(self.ty(constraint.span, hir::TyKind::Err(guar)));
                     hir::AssocItemConstraintKind::Equality { term: err_ty.into() }
                 } else {
-                    // Desugar `AssocTy: Bounds` into an assoc type binding where the
-                    // later desugars into a trait predicate.
-                    let bounds = self.lower_param_bounds(bounds, itctx);
-
+                    // FIXME(#135229): These should be forbidden!
+                    let bounds =
+                        self.lower_param_bounds(bounds, RelaxedBoundPolicy::Allowed, itctx);
                     hir::AssocItemConstraintKind::Bound { bounds }
                 }
             }
@@ -1216,6 +1233,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         span: t.span,
                         parens: ast::Parens::No,
                     },
+                    RelaxedBoundPolicy::Forbidden(RelaxedBoundForbiddenReason::TraitObjectTy),
                     itctx,
                 );
                 let bounds = this.arena.alloc_from_iter([bound]);
@@ -1271,7 +1289,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     parenthesized: hir::GenericArgsParentheses::No,
                     span_ext: span,
                 });
-                let path = self.make_lang_item_qpath(LangItem::Pin, span, Some(args));
+                let path = self.make_lang_item_qpath(hir::LangItem::Pin, span, Some(args));
                 hir::TyKind::Path(path)
             }
             TyKind::FnPtr(f) => {
@@ -1332,7 +1350,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             // takes care of rejecting invalid modifier combinations and
                             // const trait bounds in trait object types.
                             GenericBound::Trait(ty) => {
-                                let trait_ref = this.lower_poly_trait_ref(ty, itctx);
+                                let trait_ref = this.lower_poly_trait_ref(
+                                    ty,
+                                    RelaxedBoundPolicy::Forbidden(
+                                        RelaxedBoundForbiddenReason::TraitObjectTy,
+                                    ),
+                                    itctx,
+                                );
                                 Some(trait_ref)
                             }
                             GenericBound::Outlives(lifetime) => {
@@ -1387,9 +1411,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         }
                         path
                     }
-                    ImplTraitContext::InBinding => {
-                        hir::TyKind::TraitAscription(self.lower_param_bounds(bounds, itctx))
-                    }
+                    ImplTraitContext::InBinding => hir::TyKind::TraitAscription(
+                        self.lower_param_bounds(bounds, RelaxedBoundPolicy::Allowed, itctx),
+                    ),
                     ImplTraitContext::FeatureGated(position, feature) => {
                         let guar = self
                             .tcx
@@ -1505,7 +1529,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let opaque_ty_span = self.mark_span_with_reason(DesugaringKind::OpaqueTy, span, None);
 
         self.lower_opaque_inner(opaque_ty_node_id, origin, opaque_ty_span, |this| {
-            this.lower_param_bounds(bounds, itctx)
+            this.lower_param_bounds(bounds, RelaxedBoundPolicy::Allowed, itctx)
         })
     }
 
@@ -1799,10 +1823,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn lower_param_bound(
         &mut self,
         tpb: &GenericBound,
+        rbp: RelaxedBoundPolicy<'_>,
         itctx: ImplTraitContext,
     ) -> hir::GenericBound<'hir> {
         match tpb {
-            GenericBound::Trait(p) => hir::GenericBound::Trait(self.lower_poly_trait_ref(p, itctx)),
+            GenericBound::Trait(p) => {
+                hir::GenericBound::Trait(self.lower_poly_trait_ref(p, rbp, itctx))
+            }
             GenericBound::Outlives(lifetime) => hir::GenericBound::Outlives(self.lower_lifetime(
                 lifetime,
                 LifetimeSource::OutlivesBound,
@@ -2017,19 +2044,75 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     #[instrument(level = "debug", skip(self))]
     fn lower_poly_trait_ref(
         &mut self,
-        p: &PolyTraitRef,
+        PolyTraitRef { bound_generic_params, modifiers, trait_ref, span, parens: _ }: &PolyTraitRef,
+        rbp: RelaxedBoundPolicy<'_>,
         itctx: ImplTraitContext,
     ) -> hir::PolyTraitRef<'hir> {
         let bound_generic_params =
-            self.lower_lifetime_binder(p.trait_ref.ref_id, &p.bound_generic_params);
-        let trait_ref = self.lower_trait_ref(p.modifiers, &p.trait_ref, itctx);
-        let modifiers = self.lower_trait_bound_modifiers(p.modifiers);
+            self.lower_lifetime_binder(trait_ref.ref_id, bound_generic_params);
+        let trait_ref = self.lower_trait_ref(*modifiers, trait_ref, itctx);
+        let modifiers = self.lower_trait_bound_modifiers(*modifiers);
+
+        if let ast::BoundPolarity::Maybe(_) = modifiers.polarity {
+            self.validate_relaxed_bound(trait_ref, *span, rbp);
+        }
+
         hir::PolyTraitRef {
             bound_generic_params,
             modifiers,
             trait_ref,
-            span: self.lower_span(p.span),
+            span: self.lower_span(*span),
+        }
+    }
+
+    fn validate_relaxed_bound(
+        &self,
+        trait_ref: hir::TraitRef<'_>,
+        span: Span,
+        rbp: RelaxedBoundPolicy<'_>,
+    ) {
+        let err = |message| feature_err(&self.tcx.sess, sym::more_maybe_bounds, span, message);
+
+        match rbp {
+            RelaxedBoundPolicy::Allowed => return,
+            RelaxedBoundPolicy::AllowedIfOnTyParam(id, params) => {
+                if let Some(res) = self.resolver.get_partial_res(id).and_then(|r| r.full_res())
+                    && let Res::Def(DefKind::TyParam, def_id) = res
+                    && params.iter().any(|p| def_id == self.local_def_id(p.id).to_def_id())
+                {
+                    return;
+                }
+                if self.tcx.features().more_maybe_bounds() {
+                    return;
+                }
+            }
+            RelaxedBoundPolicy::Forbidden(reason) => {
+                if self.tcx.features().more_maybe_bounds() {
+                    return;
+                }
+
+                match reason {
+                    RelaxedBoundForbiddenReason::TraitObjectTy => {
+                        err("`?Trait` is not permitted in trait object types").emit();
+                        return;
+                    }
+                    RelaxedBoundForbiddenReason::SuperTrait => {
+                        let mut diag = err("`?Trait` is not permitted in supertraits");
+                        if let Some(def_id) = trait_ref.trait_def_id()
+                            && self.tcx.is_lang_item(def_id, hir::LangItem::Sized)
+                        {
+                            diag.note("traits are `?Sized` by default");
+                        }
+                        diag.emit();
+                        return;
+                    }
+                    RelaxedBoundForbiddenReason::LateBoundVarsInScope => {}
+                };
+            }
         }
+
+        err("`?Trait` bounds are only permitted at the point where a type parameter is declared")
+            .emit();
     }
 
     fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext) -> hir::MutTy<'hir> {
@@ -2040,17 +2123,19 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn lower_param_bounds(
         &mut self,
         bounds: &[GenericBound],
+        rbp: RelaxedBoundPolicy<'_>,
         itctx: ImplTraitContext,
     ) -> hir::GenericBounds<'hir> {
-        self.arena.alloc_from_iter(self.lower_param_bounds_mut(bounds, itctx))
+        self.arena.alloc_from_iter(self.lower_param_bounds_mut(bounds, rbp, itctx))
     }
 
     fn lower_param_bounds_mut(
         &mut self,
         bounds: &[GenericBound],
+        rbp: RelaxedBoundPolicy<'_>,
         itctx: ImplTraitContext,
     ) -> impl Iterator<Item = hir::GenericBound<'hir>> {
-        bounds.iter().map(move |bound| self.lower_param_bound(bound, itctx))
+        bounds.iter().map(move |bound| self.lower_param_bound(bound, rbp, itctx))
     }
 
     #[instrument(level = "debug", skip(self), ret)]
@@ -2084,6 +2169,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             bounds,
             /* colon_span */ None,
             span,
+            RelaxedBoundPolicy::Allowed,
             ImplTraitContext::Universal,
             hir::PredicateOrigin::ImplTrait,
         );
diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index e419154d65d..af93d55c898 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -212,11 +212,6 @@ ast_passes_nomangle_ascii = `#[no_mangle]` requires ASCII identifier
 ast_passes_obsolete_auto = `impl Trait for .. {"{}"}` is an obsolete syntax
     .help = use `auto trait Trait {"{}"}` instead
 
-ast_passes_optional_trait_object = `?Trait` is not permitted in trait object types
-
-ast_passes_optional_trait_supertrait = `?Trait` is not permitted in supertraits
-    .note = traits are `?{$path_str}` by default
-
 ast_passes_out_of_order_params = {$param_ord} parameters must be declared prior to {$max_param} parameters
     .suggestion = reorder the parameters: lifetimes, then consts and types
 
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index c69250c0305..a08dae11153 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -1381,29 +1381,6 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
         match bound {
             GenericBound::Trait(trait_ref) => {
                 match (ctxt, trait_ref.modifiers.constness, trait_ref.modifiers.polarity) {
-                    (BoundKind::SuperTraits, BoundConstness::Never, BoundPolarity::Maybe(_))
-                        if !self.features.more_maybe_bounds() =>
-                    {
-                        self.sess
-                            .create_feature_err(
-                                errors::OptionalTraitSupertrait {
-                                    span: trait_ref.span,
-                                    path_str: pprust::path_to_string(&trait_ref.trait_ref.path),
-                                },
-                                sym::more_maybe_bounds,
-                            )
-                            .emit();
-                    }
-                    (BoundKind::TraitObject, BoundConstness::Never, BoundPolarity::Maybe(_))
-                        if !self.features.more_maybe_bounds() =>
-                    {
-                        self.sess
-                            .create_feature_err(
-                                errors::OptionalTraitObject { span: trait_ref.span },
-                                sym::more_maybe_bounds,
-                            )
-                            .emit();
-                    }
                     (
                         BoundKind::TraitObject,
                         BoundConstness::Always(_),
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index c1ebd025c7a..fd4b2528541 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -566,22 +566,6 @@ pub(crate) struct NestedLifetimes {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(ast_passes_optional_trait_supertrait)]
-#[note]
-pub(crate) struct OptionalTraitSupertrait {
-    #[primary_span]
-    pub span: Span,
-    pub path_str: String,
-}
-
-#[derive(Diagnostic)]
-#[diag(ast_passes_optional_trait_object)]
-pub(crate) struct OptionalTraitObject {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(ast_passes_const_bound_trait_object)]
 pub(crate) struct ConstBoundTraitObject {
diff --git a/tests/ui/associated-item/missing-associated_item_or_field_def_ids.rs b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.rs
index b90bb9ea4dd..18c71e5c744 100644
--- a/tests/ui/associated-item/missing-associated_item_or_field_def_ids.rs
+++ b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.rs
@@ -1,8 +1,7 @@
 // Regression test for <https://github.com/rust-lang/rust/issues/137554>.
 
 fn main() -> dyn Iterator + ?Iterator::advance_by(usize) {
-    //~^ ERROR `?Trait` is not permitted in trait object types
-    //~| ERROR expected trait, found associated function `Iterator::advance_by`
-    //~| ERROR the value of the associated type `Item` in `Iterator` must be specified
+    //~^ ERROR expected trait, found associated function `Iterator::advance_by`
+    //~| ERROR `?Trait` is not permitted in trait object types
     todo!()
 }
diff --git a/tests/ui/associated-item/missing-associated_item_or_field_def_ids.stderr b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.stderr
index 7f0fbc800ed..6ec8e01c78d 100644
--- a/tests/ui/associated-item/missing-associated_item_or_field_def_ids.stderr
+++ b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.stderr
@@ -1,25 +1,19 @@
-error[E0658]: `?Trait` is not permitted in trait object types
-  --> $DIR/missing-associated_item_or_field_def_ids.rs:3:29
-   |
-LL | fn main() -> dyn Iterator + ?Iterator::advance_by(usize) {
-   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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[E0404]: expected trait, found associated function `Iterator::advance_by`
   --> $DIR/missing-associated_item_or_field_def_ids.rs:3:30
    |
 LL | fn main() -> dyn Iterator + ?Iterator::advance_by(usize) {
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a trait
 
-error[E0191]: the value of the associated type `Item` in `Iterator` must be specified
-  --> $DIR/missing-associated_item_or_field_def_ids.rs:3:18
+error[E0658]: `?Trait` is not permitted in trait object types
+  --> $DIR/missing-associated_item_or_field_def_ids.rs:3:29
    |
 LL | fn main() -> dyn Iterator + ?Iterator::advance_by(usize) {
-   |                  ^^^^^^^^ help: specify the associated type: `Iterator<Item = Type>`
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: add `#![feature(more_maybe_bounds)]` 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: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0191, E0404, E0658.
-For more information about an error, try `rustc --explain E0191`.
+Some errors have detailed explanations: E0404, E0658.
+For more information about an error, try `rustc --explain E0404`.
diff --git a/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.rs b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.rs
index f6b749a5100..9e0a86abb2e 100644
--- a/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.rs
+++ b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.rs
@@ -6,7 +6,6 @@ trait Tr {
 
 fn main() {
     let _: dyn Tr + ?Foo<Assoc = ()>;
-    //~^ ERROR: `?Trait` is not permitted in trait object types
-    //~| ERROR: cannot find trait `Foo` in this scope
-    //~| ERROR: the value of the associated type `Item` in `Tr` must be specified
+    //~^ ERROR: cannot find trait `Foo` in this scope
+    //~| ERROR: `?Trait` is not permitted in trait object types
 }
diff --git a/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.stderr b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.stderr
index f31a1de76a7..bd83c1a9ea8 100644
--- a/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.stderr
+++ b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.stderr
@@ -1,28 +1,19 @@
-error[E0658]: `?Trait` is not permitted in trait object types
-  --> $DIR/avoid-getting-associated-items-of-undefined-trait.rs:8:21
-   |
-LL |     let _: dyn Tr + ?Foo<Assoc = ()>;
-   |                     ^^^^^^^^^^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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[E0405]: cannot find trait `Foo` in this scope
   --> $DIR/avoid-getting-associated-items-of-undefined-trait.rs:8:22
    |
 LL |     let _: dyn Tr + ?Foo<Assoc = ()>;
    |                      ^^^ not found in this scope
 
-error[E0191]: the value of the associated type `Item` in `Tr` must be specified
-  --> $DIR/avoid-getting-associated-items-of-undefined-trait.rs:8:16
+error[E0658]: `?Trait` is not permitted in trait object types
+  --> $DIR/avoid-getting-associated-items-of-undefined-trait.rs:8:21
    |
-LL |     type Item;
-   |     --------- `Item` defined here
-...
 LL |     let _: dyn Tr + ?Foo<Assoc = ()>;
-   |                ^^ help: specify the associated type: `Tr<Item = Type>`
+   |                     ^^^^^^^^^^^^^^^^
+   |
+   = help: add `#![feature(more_maybe_bounds)]` 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: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0191, E0405, E0658.
-For more information about an error, try `rustc --explain E0191`.
+Some errors have detailed explanations: E0405, E0658.
+For more information about an error, try `rustc --explain E0405`.
diff --git a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
index 729df4eb37c..f52532a035b 100644
--- a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
+++ b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
@@ -4,24 +4,23 @@ error[E0658]: `?Trait` is not permitted in supertraits
 LL | trait Trait3: ?Trait1 {}
    |               ^^^^^^^
    |
-   = note: traits are `?Trait1` by default
    = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` is not permitted in trait object types
-  --> $DIR/feature-gate-more-maybe-bounds.rs:10:28
+error[E0658]: `?Trait` bounds are only permitted at the point where a type parameter is declared
+  --> $DIR/feature-gate-more-maybe-bounds.rs:7:26
    |
-LL | fn foo(_: Box<dyn Trait1 + ?Trait2>) {}
-   |                            ^^^^^^^
+LL | trait Trait4 where Self: ?Trait1 {}
+   |                          ^^^^^^^
    |
    = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` bounds are only permitted at the point where a type parameter is declared
-  --> $DIR/feature-gate-more-maybe-bounds.rs:7:26
+error[E0658]: `?Trait` is not permitted in trait object types
+  --> $DIR/feature-gate-more-maybe-bounds.rs:10:28
    |
-LL | trait Trait4 where Self: ?Trait1 {}
-   |                          ^^^^^^^
+LL | fn foo(_: Box<dyn Trait1 + ?Trait2>) {}
+   |                            ^^^^^^^
    |
    = help: add `#![feature(more_maybe_bounds)]` 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/sized-hierarchy/default-supertrait.stderr b/tests/ui/sized-hierarchy/default-supertrait.stderr
index de23936b900..0cb4f346a63 100644
--- a/tests/ui/sized-hierarchy/default-supertrait.stderr
+++ b/tests/ui/sized-hierarchy/default-supertrait.stderr
@@ -4,9 +4,9 @@ error[E0658]: `?Trait` is not permitted in supertraits
 LL | trait NegSized: ?Sized { }
    |                 ^^^^^^
    |
-   = note: traits are `?Sized` by default
    = help: add `#![feature(more_maybe_bounds)]` 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: traits are `?Sized` by default
 
 error[E0658]: `?Trait` is not permitted in supertraits
   --> $DIR/default-supertrait.rs:13:21
@@ -14,7 +14,6 @@ error[E0658]: `?Trait` is not permitted in supertraits
 LL | trait NegMetaSized: ?MetaSized { }
    |                     ^^^^^^^^^^
    |
-   = note: traits are `?MetaSized` by default
    = help: add `#![feature(more_maybe_bounds)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
@@ -24,7 +23,6 @@ error[E0658]: `?Trait` is not permitted in supertraits
 LL | trait NegPointeeSized: ?PointeeSized { }
    |                        ^^^^^^^^^^^^^
    |
-   = note: traits are `?PointeeSized` by default
    = help: add `#![feature(more_maybe_bounds)]` 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/traits/maybe-trait-bounds-forbidden-locations.stderr b/tests/ui/traits/maybe-trait-bounds-forbidden-locations.stderr
index bd0baa580bd..5c4100d0e26 100644
--- a/tests/ui/traits/maybe-trait-bounds-forbidden-locations.stderr
+++ b/tests/ui/traits/maybe-trait-bounds-forbidden-locations.stderr
@@ -4,9 +4,9 @@ error[E0658]: `?Trait` is not permitted in supertraits
 LL | trait Tr: ?Sized {}
    |           ^^^^^^
    |
-   = note: traits are `?Sized` by default
    = help: add `#![feature(more_maybe_bounds)]` 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: traits are `?Sized` by default
 
 error[E0658]: `?Trait` is not permitted in trait object types
   --> $DIR/maybe-trait-bounds-forbidden-locations.rs:13:20
diff --git a/tests/ui/unsized/maybe-bounds-where.rs b/tests/ui/unsized/maybe-bounds-where.rs
deleted file mode 100644
index 4c4141631a7..00000000000
--- a/tests/ui/unsized/maybe-bounds-where.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-struct S1<T>(T) where (T): ?Sized;
-//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
-
-struct S2<T>(T) where u8: ?Sized;
-//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
-
-struct S3<T>(T) where &'static T: ?Sized;
-//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
-
-trait Trait<'a> {}
-
-struct S4<T>(T) where for<'a> T: ?Trait<'a>;
-//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
-//~| ERROR relaxing a default bound only does something for `?Sized`
-
-struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
-//~^ ERROR type parameter has more than one relaxed default bound
-//~| ERROR relaxing a default bound only does something for `?Sized`
-
-impl<T> S1<T> {
-    fn f() where T: ?Sized {}
-    //~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
-}
-
-fn main() {
-    let u = vec![1, 2, 3];
-    let _s: S5<[u8]> = S5(&u[..]); // OK
-}
diff --git a/tests/ui/unsized/maybe-bounds-where.stderr b/tests/ui/unsized/maybe-bounds-where.stderr
deleted file mode 100644
index fb6d37c2966..00000000000
--- a/tests/ui/unsized/maybe-bounds-where.stderr
+++ /dev/null
@@ -1,70 +0,0 @@
-error[E0658]: `?Trait` bounds are only permitted at the point where a type parameter is declared
-  --> $DIR/maybe-bounds-where.rs:1:28
-   |
-LL | struct S1<T>(T) where (T): ?Sized;
-   |                            ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` bounds are only permitted at the point where a type parameter is declared
-  --> $DIR/maybe-bounds-where.rs:4:27
-   |
-LL | struct S2<T>(T) where u8: ?Sized;
-   |                           ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` bounds are only permitted at the point where a type parameter is declared
-  --> $DIR/maybe-bounds-where.rs:7:35
-   |
-LL | struct S3<T>(T) where &'static T: ?Sized;
-   |                                   ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` bounds are only permitted at the point where a type parameter is declared
-  --> $DIR/maybe-bounds-where.rs:12:34
-   |
-LL | struct S4<T>(T) where for<'a> T: ?Trait<'a>;
-   |                                  ^^^^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` bounds are only permitted at the point where a type parameter is declared
-  --> $DIR/maybe-bounds-where.rs:21:21
-   |
-LL |     fn f() where T: ?Sized {}
-   |                     ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/maybe-bounds-where.rs:12:34
-   |
-LL | struct S4<T>(T) where for<'a> T: ?Trait<'a>;
-   |                                  ^^^^^^^^^^
-
-error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/maybe-bounds-where.rs:16:33
-   |
-LL | struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
-   |                                 ^^^^^^^^^^^^^^^   ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/maybe-bounds-where.rs:16:33
-   |
-LL | struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
-   |                                 ^^^^^^^^^^^^^^^
-
-error: aborting due to 8 previous errors
-
-Some errors have detailed explanations: E0203, E0658.
-For more information about an error, try `rustc --explain E0203`.
diff --git a/tests/ui/unsized/relaxed-bounds-invalid-places.rs b/tests/ui/unsized/relaxed-bounds-invalid-places.rs
new file mode 100644
index 00000000000..ce3f35608be
--- /dev/null
+++ b/tests/ui/unsized/relaxed-bounds-invalid-places.rs
@@ -0,0 +1,31 @@
+// Test that relaxed bounds can only be placed on type parameters defined by the closest item
+// (ignoring relaxed bounds inside `impl Trait` and in associated type defs here).
+
+struct S1<T>(T) where (T): ?Sized;
+//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
+
+struct S2<T>(T) where u8: ?Sized;
+//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
+
+struct S3<T>(T) where &'static T: ?Sized;
+//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
+
+trait Trait<'a> {}
+
+struct S4<T>(T) where for<'a> T: ?Trait<'a>;
+//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
+//~| ERROR relaxing a default bound only does something for `?Sized`
+
+struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
+//~^ ERROR type parameter has more than one relaxed default bound
+//~| ERROR relaxing a default bound only does something for `?Sized`
+
+impl<T> S1<T> {
+    fn f() where T: ?Sized {}
+    //~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
+}
+
+fn main() {
+    let u = vec![1, 2, 3];
+    let _s: S5<[u8]> = S5(&u[..]); // OK
+}
diff --git a/tests/ui/unsized/relaxed-bounds-invalid-places.stderr b/tests/ui/unsized/relaxed-bounds-invalid-places.stderr
new file mode 100644
index 00000000000..3287eb8d1e9
--- /dev/null
+++ b/tests/ui/unsized/relaxed-bounds-invalid-places.stderr
@@ -0,0 +1,70 @@
+error[E0658]: `?Trait` bounds are only permitted at the point where a type parameter is declared
+  --> $DIR/relaxed-bounds-invalid-places.rs:4:28
+   |
+LL | struct S1<T>(T) where (T): ?Sized;
+   |                            ^^^^^^
+   |
+   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` bounds are only permitted at the point where a type parameter is declared
+  --> $DIR/relaxed-bounds-invalid-places.rs:7:27
+   |
+LL | struct S2<T>(T) where u8: ?Sized;
+   |                           ^^^^^^
+   |
+   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` bounds are only permitted at the point where a type parameter is declared
+  --> $DIR/relaxed-bounds-invalid-places.rs:10:35
+   |
+LL | struct S3<T>(T) where &'static T: ?Sized;
+   |                                   ^^^^^^
+   |
+   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` bounds are only permitted at the point where a type parameter is declared
+  --> $DIR/relaxed-bounds-invalid-places.rs:15:34
+   |
+LL | struct S4<T>(T) where for<'a> T: ?Trait<'a>;
+   |                                  ^^^^^^^^^^
+   |
+   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` bounds are only permitted at the point where a type parameter is declared
+  --> $DIR/relaxed-bounds-invalid-places.rs:24:21
+   |
+LL |     fn f() where T: ?Sized {}
+   |                     ^^^^^^
+   |
+   = help: add `#![feature(more_maybe_bounds)]` 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: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+  --> $DIR/relaxed-bounds-invalid-places.rs:15:34
+   |
+LL | struct S4<T>(T) where for<'a> T: ?Trait<'a>;
+   |                                  ^^^^^^^^^^
+
+error[E0203]: type parameter has more than one relaxed default bound, only one is supported
+  --> $DIR/relaxed-bounds-invalid-places.rs:19:33
+   |
+LL | struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
+   |                                 ^^^^^^^^^^^^^^^   ^^^^^^
+   |
+   = help: add `#![feature(more_maybe_bounds)]` 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: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+  --> $DIR/relaxed-bounds-invalid-places.rs:19:33
+   |
+LL | struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
+   |                                 ^^^^^^^^^^^^^^^
+
+error: aborting due to 8 previous errors
+
+Some errors have detailed explanations: E0203, E0658.
+For more information about an error, try `rustc --explain E0203`.
-- 
cgit 1.4.1-3-g733a5


From 8388b31c5bb1478defee2963c6caae69348a7e1a Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Fri, 18 Jul 2025 14:02:00 +1000
Subject: Split some multi-snapshot tests to make blessing easier

When a snapshot test fails, it only emits a `.pending-snap` file for the first
snapshot assertion that actually failed, because subsequent assertions aren't
executed. That makes it cumbersome to re-bless tests that contain multiple
snapshot assertions.
---
 src/bootstrap/src/core/builder/tests.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 51a90649692..e71edbb8bc5 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -712,7 +712,11 @@ mod snapshot {
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
         ");
+    }
 
+    #[test]
+    fn build_rustc_no_explicit_stage() {
+        let ctx = TestCtx::new();
         insta::assert_snapshot!(
             ctx.config("build")
                 .path("rustc")
@@ -1299,7 +1303,11 @@ mod snapshot {
         [check] rustc 0 <host> -> cranelift 1 <host>
         [check] rustc 0 <host> -> gcc 1 <host>
         ");
+    }
 
+    #[test]
+    fn check_rustc_no_explicit_stage() {
+        let ctx = TestCtx::new();
         insta::assert_snapshot!(
             ctx.config("check")
                 .path("rustc")
-- 
cgit 1.4.1-3-g733a5


From 7a217e1ba51b486cd7d56eb684ae44dc3a44e1b3 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 16 Jul 2025 17:16:15 +1000
Subject: Don't trigger an LLVM build from check builds using the stage 0
 compiler

---
 src/bootstrap/src/core/build_steps/compile.rs | 29 ++++++++++++++++++---------
 src/bootstrap/src/core/builder/tests.rs       |  8 --------
 2 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 09bb2e35bda..9d29b1320b1 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -1323,7 +1323,7 @@ pub fn rustc_cargo_env(
     builder: &Builder<'_>,
     cargo: &mut Cargo,
     target: TargetSelection,
-    build_stage: u32,
+    _build_stage: u32,
 ) {
     // Set some configuration variables picked up by build scripts and
     // the compiler alike
@@ -1379,18 +1379,24 @@ pub fn rustc_cargo_env(
         cargo.rustflag("--cfg=llvm_enzyme");
     }
 
-    // Note that this is disabled if LLVM itself is disabled or we're in a check
-    // build. If we are in a check build we still go ahead here presuming we've
-    // detected that LLVM is already built and good to go which helps prevent
-    // busting caches (e.g. like #71152).
+    // These conditionals represent a tension between three forces:
+    // - For non-check builds, we need to define some LLVM-related environment
+    //   variables, requiring LLVM to have been built.
+    // - For check builds, we want to avoid building LLVM if possible.
+    // - Check builds and non-check builds should have the same environment if
+    //   possible, to avoid unnecessary rebuilds due to cache-busting.
+    //
+    // Therefore we try to avoid building LLVM for check builds, but only if
+    // building LLVM would be expensive. If "building" LLVM is cheap
+    // (i.e. it's already built or is downloadable), we prefer to maintain a
+    // consistent environment between check and non-check builds.
     if builder.config.llvm_enabled(target) {
-        let building_is_expensive =
+        let building_llvm_is_expensive =
             crate::core::build_steps::llvm::prebuilt_llvm_config(builder, target, false)
                 .should_build();
-        // `top_stage == stage` might be false for `check --stage 1`, if we are building the stage 1 compiler
-        let can_skip_build = builder.kind == Kind::Check && builder.top_stage == build_stage;
-        let should_skip_build = building_is_expensive && can_skip_build;
-        if !should_skip_build {
+
+        let skip_llvm = (builder.kind == Kind::Check) && building_llvm_is_expensive;
+        if !skip_llvm {
             rustc_llvm_env(builder, cargo, target)
         }
     }
@@ -1407,6 +1413,9 @@ pub fn rustc_cargo_env(
 
 /// Pass down configuration from the LLVM build into the build of
 /// rustc_llvm and rustc_codegen_llvm.
+///
+/// Note that this has the side-effect of _building LLVM_, which is sometimes
+/// unwanted (e.g. for check builds).
 fn rustc_llvm_env(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetSelection) {
     if builder.config.is_rust_llvm(target) {
         cargo.env("LLVM_RUSTLLVM", "1");
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index e71edbb8bc5..97e7e512ce1 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1298,7 +1298,6 @@ mod snapshot {
             ctx.config("check")
                 .path("compiler")
                 .render_steps(), @r"
-        [build] llvm <host>
         [check] rustc 0 <host> -> rustc 1 <host>
         [check] rustc 0 <host> -> cranelift 1 <host>
         [check] rustc 0 <host> -> gcc 1 <host>
@@ -1312,7 +1311,6 @@ mod snapshot {
             ctx.config("check")
                 .path("rustc")
                 .render_steps(), @r"
-        [build] llvm <host>
         [check] rustc 0 <host> -> rustc 1 <host>
         ");
     }
@@ -1332,7 +1330,6 @@ mod snapshot {
                 .path("compiler")
                 .stage(1)
                 .render_steps(), @r"
-        [build] llvm <host>
         [check] rustc 0 <host> -> rustc 1 <host>
         [check] rustc 0 <host> -> cranelift 1 <host>
         [check] rustc 0 <host> -> gcc 1 <host>
@@ -1464,7 +1461,6 @@ mod snapshot {
                 .paths(&["library", "compiler"])
                 .args(&args)
                 .render_steps(), @r"
-        [build] llvm <host>
         [check] rustc 0 <host> -> rustc 1 <host>
         [check] rustc 0 <host> -> cranelift 1 <host>
         [check] rustc 0 <host> -> gcc 1 <host>
@@ -1478,7 +1474,6 @@ mod snapshot {
             ctx.config("check")
                 .path("miri")
                 .render_steps(), @r"
-        [build] llvm <host>
         [check] rustc 0 <host> -> rustc 1 <host>
         [check] rustc 0 <host> -> Miri 1 <host>
         ");
@@ -1499,7 +1494,6 @@ mod snapshot {
                 .path("miri")
                 .stage(1)
                 .render_steps(), @r"
-        [build] llvm <host>
         [check] rustc 0 <host> -> rustc 1 <host>
         [check] rustc 0 <host> -> Miri 1 <host>
         ");
@@ -1552,7 +1546,6 @@ mod snapshot {
             ctx.config("check")
                 .path("rustc_codegen_cranelift")
                 .render_steps(), @r"
-        [build] llvm <host>
         [check] rustc 0 <host> -> rustc 1 <host>
         [check] rustc 0 <host> -> cranelift 1 <host>
         [check] rustc 0 <host> -> gcc 1 <host>
@@ -1566,7 +1559,6 @@ mod snapshot {
             ctx.config("check")
                 .path("rust-analyzer")
                 .render_steps(), @r"
-        [build] llvm <host>
         [check] rustc 0 <host> -> rustc 1 <host>
         [check] rustc 0 <host> -> rust-analyzer 1 <host>
         ");
-- 
cgit 1.4.1-3-g733a5


From a028ca5f9bd771e825e5c8c3c55f938aea89985e Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 16 Jul 2025 20:53:29 +1000
Subject: Clean up an unused compiler-stage parameter

---
 src/bootstrap/src/core/build_steps/check.rs   |  2 +-
 src/bootstrap/src/core/build_steps/compile.rs | 11 +++--------
 src/bootstrap/src/core/build_steps/test.rs    |  4 ++--
 3 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 3278b55305c..0aec3cf7ca4 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -350,7 +350,7 @@ impl Step for CodegenBackend {
         cargo
             .arg("--manifest-path")
             .arg(builder.src.join(format!("compiler/rustc_codegen_{backend}/Cargo.toml")));
-        rustc_cargo_env(builder, &mut cargo, target, build_compiler.stage);
+        rustc_cargo_env(builder, &mut cargo, target);
 
         let _guard = builder.msg_check(format!("rustc_codegen_{backend}"), target, None);
 
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 9d29b1320b1..fc5bf6dc354 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -1316,15 +1316,10 @@ pub fn rustc_cargo(
         cargo.env("RUSTC_WRAPPER", ccache);
     }
 
-    rustc_cargo_env(builder, cargo, target, build_compiler.stage);
+    rustc_cargo_env(builder, cargo, target);
 }
 
-pub fn rustc_cargo_env(
-    builder: &Builder<'_>,
-    cargo: &mut Cargo,
-    target: TargetSelection,
-    _build_stage: u32,
-) {
+pub fn rustc_cargo_env(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetSelection) {
     // Set some configuration variables picked up by build scripts and
     // the compiler alike
     cargo
@@ -1674,7 +1669,7 @@ impl Step for CodegenBackend {
         cargo
             .arg("--manifest-path")
             .arg(builder.src.join(format!("compiler/rustc_codegen_{backend}/Cargo.toml")));
-        rustc_cargo_env(builder, &mut cargo, target, compiler.stage);
+        rustc_cargo_env(builder, &mut cargo, target);
 
         // Ideally, we'd have a separate step for the individual codegen backends,
         // like we have in tests (test::CodegenGCC) but that would require a lot of restructuring.
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 9e7ea5c115f..b7dd2b778bb 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -3386,7 +3386,7 @@ impl Step for CodegenCranelift {
             cargo
                 .arg("--manifest-path")
                 .arg(builder.src.join("compiler/rustc_codegen_cranelift/build_system/Cargo.toml"));
-            compile::rustc_cargo_env(builder, &mut cargo, target, compiler.stage);
+            compile::rustc_cargo_env(builder, &mut cargo, target);
 
             // Avoid incremental cache issues when changing rustc
             cargo.env("CARGO_BUILD_INCREMENTAL", "false");
@@ -3518,7 +3518,7 @@ impl Step for CodegenGCC {
             cargo
                 .arg("--manifest-path")
                 .arg(builder.src.join("compiler/rustc_codegen_gcc/build_system/Cargo.toml"));
-            compile::rustc_cargo_env(builder, &mut cargo, target, compiler.stage);
+            compile::rustc_cargo_env(builder, &mut cargo, target);
             add_cg_gcc_cargo_flags(&mut cargo, &gcc);
 
             // Avoid incremental cache issues when changing rustc
-- 
cgit 1.4.1-3-g733a5


From 60f6ad81a12600ec7a584bd004a81611928875f3 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Fri, 18 Jul 2025 05:00:24 +0000
Subject: Preparing for merge from rustc

---
 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 3f10132b684..f9457b3e447 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-fd2eb391d032181459773f3498c17b198513e0d0
+e4662966273ed58b51f9ff8d682accc202aa1210
-- 
cgit 1.4.1-3-g733a5


From cadcc1ce7137e63c70740e6cc3897557094382af Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Thu, 17 Jul 2025 20:14:16 +0200
Subject: bootstrap: Ignore `rust.debuginfo-level-tests` for codegen tests

codegen tests typically depend on the raw LLVM IR output and are
sensitive to debuginfo level. So do not apply
`rust.debuginfo-level-tests` for codegen tests.

Before this commit:

    $ ./x test --set rust.debuginfo-level-tests=2 tests/codegen --force-rerun
    test result: FAILED. 654 passed; 136 failed; 75 ignored; 0 measured; 0 filtered out; finished in 3.22s

After this commit:

    $ ./x test --set rust.debuginfo-level-tests=2 tests/codegen --force-rerun
    NOTE: ignoring `rust.debuginfo-level-tests=2` for codegen tests
    test result: ok. 790 passed; 0 failed; 75 ignored; 0 measured; 0 filtered out; finished in 3.21s
---
 src/bootstrap/src/core/build_steps/test.rs | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 9e7ea5c115f..38f36de8f05 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1810,7 +1810,24 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         }
 
         let mut flags = if is_rustdoc { Vec::new() } else { vec!["-Crpath".to_string()] };
-        flags.push(format!("-Cdebuginfo={}", builder.config.rust_debuginfo_level_tests));
+        flags.push(format!(
+            "-Cdebuginfo={}",
+            if suite == "codegen" {
+                // codegen tests typically check LLVM IR and are sensitive to additional debuginfo.
+                // So do not apply `rust.debuginfo-level-tests` for codegen tests.
+                if builder.config.rust_debuginfo_level_tests
+                    != crate::core::config::DebuginfoLevel::None
+                {
+                    println!(
+                        "NOTE: ignoring `rust.debuginfo-level-tests={}` for codegen tests",
+                        builder.config.rust_debuginfo_level_tests
+                    );
+                }
+                crate::core::config::DebuginfoLevel::None
+            } else {
+                builder.config.rust_debuginfo_level_tests
+            }
+        ));
         flags.extend(builder.config.cmd.compiletest_rustc_args().iter().map(|s| s.to_string()));
 
         if suite != "mir-opt" {
-- 
cgit 1.4.1-3-g733a5


From 482b34952d1cd41a00e298b00de37875342261ea Mon Sep 17 00:00:00 2001
From: Laurențiu Nicola <lnicola@dend.ro>
Date: Fri, 18 Jul 2025 08:39:13 +0300
Subject: Update lockfile

---
 src/tools/rust-analyzer/Cargo.lock | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 1bd82c5d342..e55cd80943d 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1221,13 +1221,16 @@ checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 name = "lsp-server"
 version = "0.7.8"
 dependencies = [
+ "anyhow",
  "crossbeam-channel",
  "ctrlc",
  "log",
  "lsp-types",
+ "rustc-hash 2.1.1",
  "serde",
  "serde_derive",
  "serde_json",
+ "toolchain",
 ]
 
 [[package]]
-- 
cgit 1.4.1-3-g733a5


From 63e1074c97b60d248f86321f021871f93ba10c31 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Wed, 9 Jul 2025 14:18:37 +0200
Subject: Update AMDGPU data layout

---
 compiler/rustc_codegen_llvm/src/context.rs                  | 5 +++++
 compiler/rustc_target/src/spec/targets/amdgcn_amd_amdhsa.rs | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 6a23becaa96..34bed2a1d2a 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -207,6 +207,11 @@ pub(crate) unsafe fn create_module<'ll>(
             // 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 == "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")
+        }
     }
 
     // Ensure the data-layout values hardcoded remain the defaults.
diff --git a/compiler/rustc_target/src/spec/targets/amdgcn_amd_amdhsa.rs b/compiler/rustc_target/src/spec/targets/amdgcn_amd_amdhsa.rs
index f20782cabb8..0d6c6194e26 100644
--- a/compiler/rustc_target/src/spec/targets/amdgcn_amd_amdhsa.rs
+++ b/compiler/rustc_target/src/spec/targets/amdgcn_amd_amdhsa.rs
@@ -3,7 +3,7 @@ use crate::spec::{Cc, LinkerFlavor, Lld, PanicStrategy, Target, TargetMetadata,
 pub(crate) fn target() -> Target {
     Target {
         arch: "amdgpu".into(),
-        data_layout: "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9".into(),
+        data_layout: "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9".into(),
         llvm_target: "amdgcn-amd-amdhsa".into(),
         metadata: TargetMetadata {
             description: Some("AMD GPU".into()),
-- 
cgit 1.4.1-3-g733a5


From 12b19be741ea07934d7478bd8e450dca8f85afe5 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Fri, 11 Jul 2025 10:11:03 +0200
Subject: Pass wasm exception model to TargetOptions

This is no longer implied by -wasm-enable-eh.
---
 compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs | 2 ++
 compiler/rustc_codegen_llvm/src/back/write.rs                | 4 ++++
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs                  | 1 +
 compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp             | 5 ++++-
 tests/assembly/wasm_exceptions.rs                            | 1 -
 5 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs b/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
index dfde4595590..8e82013e94a 100644
--- a/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
+++ b/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
@@ -39,6 +39,7 @@ impl OwnedTargetMachine {
         debug_info_compression: &CStr,
         use_emulated_tls: bool,
         args_cstr_buff: &[u8],
+        use_wasm_eh: bool,
     ) -> Result<Self, LlvmError<'static>> {
         assert!(args_cstr_buff.len() > 0);
         assert!(
@@ -72,6 +73,7 @@ impl OwnedTargetMachine {
                 use_emulated_tls,
                 args_cstr_buff.as_ptr() as *const c_char,
                 args_cstr_buff.len(),
+                use_wasm_eh,
             )
         };
 
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index 68279008c03..6f8fba2a30d 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -15,6 +15,7 @@ use rustc_codegen_ssa::back::write::{
     BitcodeSection, CodegenContext, EmitObj, ModuleConfig, TargetMachineFactoryConfig,
     TargetMachineFactoryFn,
 };
+use rustc_codegen_ssa::base::wants_wasm_eh;
 use rustc_codegen_ssa::traits::*;
 use rustc_codegen_ssa::{CompiledModule, ModuleCodegen, ModuleKind};
 use rustc_data_structures::profiling::SelfProfilerRef;
@@ -285,6 +286,8 @@ pub(crate) fn target_machine_factory(
     let file_name_display_preference =
         sess.filename_display_preference(RemapPathScopeComponents::DEBUGINFO);
 
+    let use_wasm_eh = wants_wasm_eh(sess);
+
     Arc::new(move |config: TargetMachineFactoryConfig| {
         let path_to_cstring_helper = |path: Option<PathBuf>| -> CString {
             let path = path.unwrap_or_default();
@@ -321,6 +324,7 @@ pub(crate) fn target_machine_factory(
             &debuginfo_compression,
             use_emulated_tls,
             &args_cstr_buff,
+            use_wasm_eh,
         )
     })
 }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 0b1e632cbc4..80a0e5c5acc 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2425,6 +2425,7 @@ unsafe extern "C" {
         UseEmulatedTls: bool,
         ArgsCstrBuff: *const c_char,
         ArgsCstrBuffLen: usize,
+        UseWasmEH: bool,
     ) -> *mut TargetMachine;
 
     pub(crate) fn LLVMRustDisposeTargetMachine(T: *mut TargetMachine);
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index cc33764e485..e649978780e 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -396,7 +396,7 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
     bool EmitStackSizeSection, bool RelaxELFRelocations, bool UseInitArray,
     const char *SplitDwarfFile, const char *OutputObjFile,
     const char *DebugInfoCompression, bool UseEmulatedTls,
-    const char *ArgsCstrBuff, size_t ArgsCstrBuffLen) {
+    const char *ArgsCstrBuff, size_t ArgsCstrBuffLen, bool UseWasmEH) {
 
   auto OptLevel = fromRust(RustOptLevel);
   auto RM = fromRust(RustReloc);
@@ -462,6 +462,9 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
     Options.ThreadModel = ThreadModel::Single;
   }
 
+  if (UseWasmEH)
+    Options.ExceptionModel = ExceptionHandling::Wasm;
+
   Options.EmitStackSizeSection = EmitStackSizeSection;
 
   if (ArgsCstrBuff != nullptr) {
diff --git a/tests/assembly/wasm_exceptions.rs b/tests/assembly/wasm_exceptions.rs
index f05ccfadc58..704e8026f3f 100644
--- a/tests/assembly/wasm_exceptions.rs
+++ b/tests/assembly/wasm_exceptions.rs
@@ -2,7 +2,6 @@
 //@ assembly-output: emit-asm
 //@ compile-flags: -C target-feature=+exception-handling
 //@ compile-flags: -C panic=unwind
-//@ compile-flags: -C llvm-args=-wasm-enable-eh
 
 #![crate_type = "lib"]
 #![feature(core_intrinsics)]
-- 
cgit 1.4.1-3-g733a5


From a65563e9cd817e2cfd75291bb97529dfb14eb451 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Mon, 14 Jul 2025 10:29:05 +0200
Subject: Make emit-arity-indicator.rs a no_core test

The presence of `@add-core-stubs` indicates that this was already
intended.
---
 tests/assembly/sanitizer/kcfi/emit-arity-indicator.rs | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/tests/assembly/sanitizer/kcfi/emit-arity-indicator.rs b/tests/assembly/sanitizer/kcfi/emit-arity-indicator.rs
index b3b623b509b..f9966a23446 100644
--- a/tests/assembly/sanitizer/kcfi/emit-arity-indicator.rs
+++ b/tests/assembly/sanitizer/kcfi/emit-arity-indicator.rs
@@ -8,6 +8,14 @@
 //@ min-llvm-version: 21.0.0
 
 #![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+
+unsafe extern "C" {
+    safe fn add(x: i32, y: i32) -> i32;
+}
 
 pub fn add_one(x: i32) -> i32 {
     // CHECK-LABEL: __cfi__{{.*}}7add_one{{.*}}:
@@ -23,7 +31,7 @@ pub fn add_one(x: i32) -> i32 {
     // CHECK-NEXT:  nop
     // CHECK-NEXT:  nop
     // CHECK-NEXT:  mov ecx, 2628068948
-    x + 1
+    add(x, 1)
 }
 
 pub fn add_two(x: i32, _y: i32) -> i32 {
@@ -40,7 +48,7 @@ pub fn add_two(x: i32, _y: i32) -> i32 {
     // CHECK-NEXT:  nop
     // CHECK-NEXT:  nop
     // CHECK-NEXT:  mov edx, 2505940310
-    x + 2
+    add(x, 2)
 }
 
 pub fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
@@ -57,5 +65,5 @@ pub fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
     // CHECK-NEXT:  nop
     // CHECK-NEXT:  nop
     // CHECK-NEXT:  mov edx, 653723426
-    f(arg) + f(arg)
+    add(f(arg), f(arg))
 }
-- 
cgit 1.4.1-3-g733a5


From 99507a3ce8c5fb5d29833ae6caac9d72febee670 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Fri, 18 Jul 2025 09:36:38 +0200
Subject: update comment

---
 compiler/rustc_next_trait_solver/src/solve/trait_goals.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
index 098dc9dbaf0..650b85d99d2 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -1219,10 +1219,8 @@ where
             // the type (even if after unification and processing nested goals
             // it does not hold) will disqualify the built-in auto impl.
             //
-            // This differs from the current stable behavior and fixes #84857.
-            // Due to breakage found via crater, we currently instead lint
-            // patterns which can be used to exploit this unsoundness on stable,
-            // see #93367 for more details.
+            // We've originally had a more permissive check here which resulted
+            // in unsoundness, see #84857.
             ty::Bool
             | ty::Char
             | ty::Int(_)
-- 
cgit 1.4.1-3-g733a5


From 9e4f777602cdac0458c57615f3019c92e4152d72 Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Fri, 18 Jul 2025 00:46:56 +0200
Subject: bootstrap: Detect musl hosts

Currently, all non-Android Linux hosts are assumed to be using glibc.
This obviously isn't very portable and will currently result in
downloading a stage0 toolchain for glibc even on musl hosts.

There are multiple ways to detect musl somewhat reliably, but the
easiest option is to check for the python SOABI config variable, which
has values like "cpython-313-x86_64-linux-gnu" or
"cpython-313-powerpc64-linux-musl".

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 src/bootstrap/bootstrap.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py
index d8c6be78247..40e08361a0f 100644
--- a/src/bootstrap/bootstrap.py
+++ b/src/bootstrap/bootstrap.py
@@ -8,6 +8,7 @@ import re
 import shutil
 import subprocess
 import sys
+import sysconfig
 import tarfile
 import tempfile
 
@@ -333,7 +334,11 @@ def default_build_triple(verbose):
         if ostype == "Android":
             kernel = "linux-android"
         else:
-            kernel = "unknown-linux-gnu"
+            python_soabi = sysconfig.get_config_var("SOABI")
+            if python_soabi is not None and "musl" in python_soabi:
+                kernel = "unknown-linux-musl"
+            else:
+                kernel = "unknown-linux-gnu"
     elif kernel == "SunOS":
         kernel = "pc-solaris"
         # On Solaris, uname -m will return a machine classification instead
-- 
cgit 1.4.1-3-g733a5


From 652ba279ecc693d8b4310c40e645a62009f5b0ed Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Wed, 18 Jun 2025 12:51:47 +0000
Subject: Show the memory of uninit reads

---
 compiler/rustc_const_eval/src/const_eval/error.rs  | 25 +++++--
 .../src/const_eval/eval_queries.rs                 |  4 +-
 .../libc_pthread_cond_double_destroy.rs            |  2 +
 .../libc_pthread_cond_double_destroy.stderr        | 10 +--
 .../libc_pthread_condattr_double_destroy.rs        |  2 +
 .../libc_pthread_condattr_double_destroy.stderr    |  8 +--
 .../libc_pthread_mutex_double_destroy.rs           |  2 +
 .../libc_pthread_mutex_double_destroy.stderr       | 10 +--
 .../libc_pthread_mutexattr_double_destroy.rs       |  2 +
 .../libc_pthread_mutexattr_double_destroy.stderr   |  8 +--
 .../libc_pthread_rwlock_double_destroy.rs          |  2 +
 .../libc_pthread_rwlock_double_destroy.stderr      | 11 +---
 .../intrinsics/ptr_metadata_uninit_slice_data.rs   |  5 +-
 .../ptr_metadata_uninit_slice_data.stderr          |  8 +--
 .../intrinsics/ptr_metadata_uninit_slice_len.rs    |  5 +-
 .../ptr_metadata_uninit_slice_len.stderr           |  8 +--
 .../fail/intrinsics/ptr_metadata_uninit_thin.rs    |  3 +
 .../intrinsics/ptr_metadata_uninit_thin.stderr     |  8 +--
 .../miri/tests/fail/read_from_trivial_switch.rs    |  3 +
 .../tests/fail/read_from_trivial_switch.stderr     |  8 +--
 src/tools/miri/tests/fail/uninit/padding-enum.rs   |  3 +
 .../miri/tests/fail/uninit/padding-enum.stderr     |  9 +--
 src/tools/miri/tests/fail/uninit/padding-pair.rs   |  3 +
 .../miri/tests/fail/uninit/padding-pair.stderr     |  8 +--
 .../miri/tests/fail/uninit/padding-wide-ptr.rs     |  3 +
 .../miri/tests/fail/uninit/padding-wide-ptr.stderr |  8 +--
 .../tests/fail/uninit/transmute-pair-uninit.rs     |  3 +
 .../tests/fail/uninit/transmute-pair-uninit.stderr |  8 +--
 .../tests/native-lib/fail/tracing/partial_init.rs  |  2 +-
 .../native-lib/fail/tracing/partial_init.stderr    |  7 +-
 .../invalid-patterns.32bit.stderr                  |  8 +++
 .../invalid-patterns.64bit.stderr                  |  8 +++
 tests/ui/consts/const-compare-bytes-ub.stderr      |  8 +++
 .../const-err-enum-discriminant.32bit.stderr       | 13 ++++
 .../const-err-enum-discriminant.64bit.stderr       | 13 ++++
 tests/ui/consts/const-err-enum-discriminant.rs     |  2 +
 tests/ui/consts/const-err-enum-discriminant.stderr |  9 ---
 ...st-pointer-values-in-various-types.64bit.stderr | 12 +++-
 .../ui/consts/const-eval/ub-enum-overwrite.stderr  |  4 ++
 tests/ui/consts/const-eval/ub-enum.rs              |  3 +-
 tests/ui/consts/const-eval/ub-enum.stderr          | 34 +++++-----
 tests/ui/consts/const-eval/ub-nonnull.stderr       |  4 ++
 tests/ui/consts/const-eval/ub-ref-ptr.rs           |  3 +-
 tests/ui/consts/const-eval/ub-ref-ptr.stderr       | 46 +++++++------
 tests/ui/consts/const-eval/ub-wide-ptr.rs          |  7 +-
 tests/ui/consts/const-eval/ub-wide-ptr.stderr      | 76 ++++++++++++----------
 .../ui/consts/const-eval/union-const-eval-field.rs |  1 +
 .../const-eval/union-const-eval-field.stderr       | 10 ++-
 tests/ui/consts/const-eval/union-ice.stderr        | 12 ++++
 tests/ui/consts/const-eval/union-ub.32bit.stderr   |  4 ++
 tests/ui/consts/const-eval/union-ub.64bit.stderr   |  4 ++
 .../intrinsics/intrinsic-raw_eq-const-bad.stderr   |  4 ++
 tests/ui/type/pattern_types/validity.stderr        |  8 +++
 53 files changed, 310 insertions(+), 171 deletions(-)
 create mode 100644 tests/ui/consts/const-err-enum-discriminant.32bit.stderr
 create mode 100644 tests/ui/consts/const-err-enum-discriminant.64bit.stderr
 delete mode 100644 tests/ui/consts/const-err-enum-discriminant.stderr

diff --git a/compiler/rustc_const_eval/src/const_eval/error.rs b/compiler/rustc_const_eval/src/const_eval/error.rs
index 3e880d02001..e00fb2c1eaf 100644
--- a/compiler/rustc_const_eval/src/const_eval/error.rs
+++ b/compiler/rustc_const_eval/src/const_eval/error.rs
@@ -2,17 +2,17 @@ use std::mem;
 
 use rustc_errors::{Diag, DiagArgName, DiagArgValue, DiagMessage, IntoDiagArg};
 use rustc_middle::mir::AssertKind;
-use rustc_middle::mir::interpret::{AllocId, Provenance, ReportedErrorInfo};
+use rustc_middle::mir::interpret::{AllocId, Provenance, ReportedErrorInfo, UndefinedBehaviorInfo};
 use rustc_middle::query::TyCtxtAt;
+use rustc_middle::ty::ConstInt;
 use rustc_middle::ty::layout::LayoutError;
-use rustc_middle::ty::{ConstInt, TyCtxt};
 use rustc_span::{Span, Symbol};
 
 use super::CompileTimeMachine;
 use crate::errors::{self, FrameNote, ReportErrorExt};
 use crate::interpret::{
-    CtfeProvenance, ErrorHandled, Frame, InterpErrorInfo, InterpErrorKind, MachineStopType,
-    Pointer, err_inval, err_machine_stop,
+    CtfeProvenance, ErrorHandled, Frame, InterpCx, InterpErrorInfo, InterpErrorKind,
+    MachineStopType, Pointer, err_inval, err_machine_stop,
 };
 
 /// The CTFE machine has some custom error kinds.
@@ -163,7 +163,7 @@ pub fn get_span_and_frames<'tcx>(
 /// 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>(
-    tcx: TyCtxt<'tcx>,
+    ecx: &InterpCx<'tcx, CompileTimeMachine<'tcx>>,
     error: InterpErrorKind<'tcx>,
     span: Span,
     get_span_and_frames: C,
@@ -173,6 +173,7 @@ where
     C: FnOnce() -> (Span, Vec<FrameNote>),
     F: FnOnce(&mut Diag<'_>, Span, Vec<FrameNote>),
 {
+    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
@@ -198,6 +199,20 @@ where
                 InterpErrorKind::ResourceExhaustion(_) | InterpErrorKind::InvalidProgram(_)
             );
 
+            if let InterpErrorKind::UndefinedBehavior(UndefinedBehaviorInfo::InvalidUninitBytes(
+                Some((alloc_id, _access)),
+            )) = error
+            {
+                let bytes = ecx.print_alloc_bytes_for_diagnostics(alloc_id);
+                let info = ecx.get_alloc_info(alloc_id);
+                let raw_bytes = errors::RawBytesNote {
+                    size: info.size.bytes(),
+                    align: info.align.bytes(),
+                    bytes,
+                };
+                err.subdiagnostic(raw_bytes);
+            }
+
             error.add_args(&mut err);
 
             mk(&mut err, span, frames);
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 ce72d59b8b0..f584f6c948e 100644
--- a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -411,7 +411,7 @@ fn report_eval_error<'tcx>(
     let instance = with_no_trimmed_paths!(cid.instance.to_string());
 
     super::report(
-        *ecx.tcx,
+        ecx,
         error,
         DUMMY_SP,
         || super::get_span_and_frames(ecx.tcx, ecx.stack()),
@@ -451,7 +451,7 @@ fn report_validation_error<'tcx>(
         errors::RawBytesNote { size: info.size.bytes(), align: info.align.bytes(), bytes };
 
     crate::const_eval::report(
-        *ecx.tcx,
+        ecx,
         error,
         DUMMY_SP,
         || crate::const_eval::get_span_and_frames(ecx.tcx, ecx.stack()),
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs
index 8624e4d28fb..5778765589d 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs
@@ -1,4 +1,6 @@
 //@ignore-target: windows # No pthreads on Windows
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
 
 /// Test that destroying a pthread_cond twice fails, even without a check for number validity
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.stderr
index 3318ac7fca5..6156070cf95 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs:LL:CC
    |
 LL |         libc::pthread_cond_destroy(cond.as_mut_ptr());
@@ -9,12 +9,8 @@ LL |         libc::pthread_cond_destroy(cond.as_mut_ptr());
    = note: BACKTRACE:
    = note: inside `main` at tests/fail-dep/concurrency/libc_pthread_cond_double_destroy.rs:LL:CC
 
-Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
-ALLOC (stack variable, size: 48, align: 8) {
-    0x00 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
-    0x10 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
-    0x20 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.rs
index a510ee77cfb..91169660491 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.rs
@@ -1,5 +1,7 @@
 //@ignore-target: windows # No pthreads on Windows
 //@ignore-target: apple # Our macOS condattr don't have any fields so we do not notice this.
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
 
 /// Test that destroying a pthread_condattr twice fails, even without a check for number validity
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.stderr
index 1971bbc7210..da64970ff2e 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.rs:LL:CC
    |
 LL |         libc::pthread_condattr_destroy(attr.as_mut_ptr());
@@ -9,10 +9,8 @@ LL |         libc::pthread_condattr_destroy(attr.as_mut_ptr());
    = note: BACKTRACE:
    = note: inside `main` at tests/fail-dep/concurrency/libc_pthread_condattr_double_destroy.rs:LL:CC
 
-Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
-ALLOC (stack variable, size: 4, align: 4) {
-    __ __ __ __                                     │ ░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.rs
index 71a80292032..f04fe8be6b3 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.rs
@@ -1,4 +1,6 @@
 //@ignore-target: windows # No pthreads on Windows
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
 
 /// Test that destroying a pthread_mutex twice fails, even without a check for number validity
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.stderr
index 251f8036e38..05db823b252 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.rs:LL:CC
    |
 LL |         libc::pthread_mutex_destroy(mutex.as_mut_ptr());
@@ -9,12 +9,8 @@ LL |         libc::pthread_mutex_destroy(mutex.as_mut_ptr());
    = note: BACKTRACE:
    = note: inside `main` at tests/fail-dep/concurrency/libc_pthread_mutex_double_destroy.rs:LL:CC
 
-Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
-ALLOC (stack variable, size: 40, align: 8) {
-    0x00 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
-    0x10 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
-    0x20 │ __ __ __ __ __ __ __ __                         │ ░░░░░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs
index 28dacc9931a..d9daf5259bb 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs
@@ -1,4 +1,6 @@
 //@ignore-target: windows # No pthreads on Windows
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
 
 /// Test that destroying a pthread_mutexattr twice fails, even without a check for number validity
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.stderr
index b341efb7770..ee3883de36b 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs:LL:CC
    |
 LL |         libc::pthread_mutexattr_destroy(attr.as_mut_ptr());
@@ -9,10 +9,8 @@ LL |         libc::pthread_mutexattr_destroy(attr.as_mut_ptr());
    = note: BACKTRACE:
    = note: inside `main` at tests/fail-dep/concurrency/libc_pthread_mutexattr_double_destroy.rs:LL:CC
 
-Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
-ALLOC (stack variable, size: 4, align: 4) {
-    __ __ __ __                                     │ ░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.rs b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.rs
index a46a124bf2e..720ba71d238 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.rs
@@ -1,4 +1,6 @@
 //@ignore-target: windows # No pthreads on Windows
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
 
 /// Test that destroying a pthread_rwlock twice fails, even without a check for number validity
 
diff --git a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.stderr b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.stderr
index 8f388577a27..430398dc8fd 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.stderr
+++ b/src/tools/miri/tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.rs:LL:CC
    |
 LL |         libc::pthread_rwlock_destroy(&mut lock);
@@ -9,13 +9,8 @@ LL |         libc::pthread_rwlock_destroy(&mut lock);
    = note: BACKTRACE:
    = note: inside `main` at tests/fail-dep/concurrency/libc_pthread_rwlock_double_destroy.rs:LL:CC
 
-Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
-ALLOC (stack variable, size: 56, align: 8) {
-    0x00 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
-    0x10 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
-    0x20 │ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ │ ░░░░░░░░░░░░░░░░
-    0x30 │ __ __ __ __ __ __ __ __                         │ ░░░░░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.rs b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.rs
index 16f07c7ee99..c03e468cfba 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.rs
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.rs
@@ -1,4 +1,7 @@
 //@compile-flags: -Zmiri-disable-validation
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
+
 #![feature(core_intrinsics, custom_mir)]
 use std::intrinsics::mir::*;
 
@@ -9,7 +12,7 @@ use std::intrinsics::mir::*;
 pub unsafe fn deref_meta(p: *const *const [i32]) -> usize {
     mir! {
         {
-            RET = PtrMetadata(*p); //~ ERROR: /Undefined Behavior: .*, but memory is uninitialized/
+            RET = PtrMetadata(*p); //~ ERROR: /Undefined Behavior: .* but memory is uninitialized/
             Return()
         }
     }
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.stderr
index 9bacd80f7d5..1e7f500edb2 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_data.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail/intrinsics/ptr_metadata_uninit_slice_data.rs:LL:CC
    |
 LL |             RET = PtrMetadata(*p);
@@ -14,10 +14,8 @@ note: inside `main`
 LL |         let _meta = deref_meta(p.as_ptr().cast());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Uninitialized memory occurred at ALLOC[0x0..0x8], in this allocation:
-ALLOC (stack variable, size: 16, align: 8) {
-    __ __ __ __ __ __ __ __ 04 00 00 00 00 00 00 00 │ ░░░░░░░░........
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.rs b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.rs
index 38db894537b..7053c0f6e18 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.rs
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.rs
@@ -1,4 +1,7 @@
 //@compile-flags: -Zmiri-disable-validation
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]+..0x[0-9a-z]+\]" -> "[0xX..0xY]"
+
 #![feature(core_intrinsics, custom_mir)]
 use std::intrinsics::mir::*;
 
@@ -9,7 +12,7 @@ use std::intrinsics::mir::*;
 pub unsafe fn deref_meta(p: *const *const [i32]) -> usize {
     mir! {
         {
-            RET = PtrMetadata(*p); //~ ERROR: /Undefined Behavior: .*, but memory is uninitialized/
+            RET = PtrMetadata(*p); //~ ERROR: /Undefined Behavior: .* but memory is uninitialized/
             Return()
         }
     }
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.stderr
index 621325d72ff..80b4c8bec0d 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_slice_len.stderr
@@ -12,7 +12,7 @@ LL |         (*p.as_mut_ptr().cast::<[*const i32; 2]>())[0] = 4 as *const i32;
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/intrinsics/ptr_metadata_uninit_slice_len.rs:LL:CC
 
-error: Undefined Behavior: reading memory at ALLOC[0x8..0x10], but memory is uninitialized at [0x8..0x10], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail/intrinsics/ptr_metadata_uninit_slice_len.rs:LL:CC
    |
 LL |             RET = PtrMetadata(*p);
@@ -28,10 +28,8 @@ note: inside `main`
 LL |         let _meta = deref_meta(p.as_ptr().cast());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Uninitialized memory occurred at ALLOC[0x8..0x10], in this allocation:
-ALLOC (stack variable, size: 16, align: 8) {
-    ╾────0x4[wildcard]────╼ __ __ __ __ __ __ __ __ │ ╾──────╼░░░░░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.rs b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.rs
index 179fd33ed7c..3ba29847337 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.rs
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.rs
@@ -1,4 +1,7 @@
 //@compile-flags: -Zmiri-disable-validation
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
+
 #![feature(core_intrinsics, custom_mir)]
 use std::intrinsics::mir::*;
 
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.stderr
index b0e45242057..7a1f3d6ea84 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_metadata_uninit_thin.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail/intrinsics/ptr_metadata_uninit_thin.rs:LL:CC
    |
 LL |             RET = PtrMetadata(*p);
@@ -14,10 +14,8 @@ note: inside `main`
 LL |         let _meta = deref_meta(p.as_ptr());
    |                     ^^^^^^^^^^^^^^^^^^^^^^
 
-Uninitialized memory occurred at ALLOC[0x0..0x8], in this allocation:
-ALLOC (stack variable, size: 8, align: 8) {
-    __ __ __ __ __ __ __ __                         │ ░░░░░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/read_from_trivial_switch.rs b/src/tools/miri/tests/fail/read_from_trivial_switch.rs
index 35117c80b73..2696c42aeae 100644
--- a/src/tools/miri/tests/fail/read_from_trivial_switch.rs
+++ b/src/tools/miri/tests/fail/read_from_trivial_switch.rs
@@ -4,6 +4,9 @@
 //
 // See <https://github.com/rust-lang/miri/issues/4237>.
 
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
+
 use std::mem::MaybeUninit;
 
 fn main() {
diff --git a/src/tools/miri/tests/fail/read_from_trivial_switch.stderr b/src/tools/miri/tests/fail/read_from_trivial_switch.stderr
index 1d0c76c3c08..1dcc341b7e6 100644
--- a/src/tools/miri/tests/fail/read_from_trivial_switch.stderr
+++ b/src/tools/miri/tests/fail/read_from_trivial_switch.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail/read_from_trivial_switch.rs:LL:CC
    |
 LL |     let &(0 | _) = bad_ref;
@@ -9,10 +9,8 @@ LL |     let &(0 | _) = bad_ref;
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/read_from_trivial_switch.rs:LL:CC
 
-Uninitialized memory occurred at ALLOC[0x0..0x4], in this allocation:
-ALLOC (stack variable, size: 4, align: 4) {
-    __ __ __ __                                     │ ░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/uninit/padding-enum.rs b/src/tools/miri/tests/fail/uninit/padding-enum.rs
index e1a16bea23c..606fa21016f 100644
--- a/src/tools/miri/tests/fail/uninit/padding-enum.rs
+++ b/src/tools/miri/tests/fail/uninit/padding-enum.rs
@@ -1,3 +1,6 @@
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
+
 use std::mem;
 
 // We have three fields to avoid the ScalarPair optimization.
diff --git a/src/tools/miri/tests/fail/uninit/padding-enum.stderr b/src/tools/miri/tests/fail/uninit/padding-enum.stderr
index ee3867fc60b..64229ac8817 100644
--- a/src/tools/miri/tests/fail/uninit/padding-enum.stderr
+++ b/src/tools/miri/tests/fail/uninit/padding-enum.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x8..0x9], but memory is uninitialized at [0x8..0x9], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail/uninit/padding-enum.rs:LL:CC
    |
 LL |         let _val = *c.add(padding_offset);
@@ -9,11 +9,8 @@ LL |         let _val = *c.add(padding_offset);
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/uninit/padding-enum.rs:LL:CC
 
-Uninitialized memory occurred at ALLOC[0x8..0x9], in this allocation:
-ALLOC (stack variable, size: 24, align: 8) {
-    0x00 │ 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ __ │ ........░░░░░░░░
-    0x10 │ __ __ __ __ __ __ __ __                         │ ░░░░░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/uninit/padding-pair.rs b/src/tools/miri/tests/fail/uninit/padding-pair.rs
index c8c00b3c65a..70ae48ff77d 100644
--- a/src/tools/miri/tests/fail/uninit/padding-pair.rs
+++ b/src/tools/miri/tests/fail/uninit/padding-pair.rs
@@ -1,3 +1,6 @@
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
+
 #![feature(core_intrinsics)]
 
 use std::mem::{self, MaybeUninit};
diff --git a/src/tools/miri/tests/fail/uninit/padding-pair.stderr b/src/tools/miri/tests/fail/uninit/padding-pair.stderr
index a9841815de3..2e7a577f204 100644
--- a/src/tools/miri/tests/fail/uninit/padding-pair.stderr
+++ b/src/tools/miri/tests/fail/uninit/padding-pair.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x9..0xa], but memory is uninitialized at [0x9..0xa], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail/uninit/padding-pair.rs:LL:CC
    |
 LL |     let v = unsafe { *z.offset(first_undef) };
@@ -9,10 +9,8 @@ LL |     let v = unsafe { *z.offset(first_undef) };
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/uninit/padding-pair.rs:LL:CC
 
-Uninitialized memory occurred at ALLOC[0x9..0xa], in this allocation:
-ALLOC (stack variable, size: 16, align: 8) {
-    00 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ │ .........░░░░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/uninit/padding-wide-ptr.rs b/src/tools/miri/tests/fail/uninit/padding-wide-ptr.rs
index 4e363dbf81e..549785e0223 100644
--- a/src/tools/miri/tests/fail/uninit/padding-wide-ptr.rs
+++ b/src/tools/miri/tests/fail/uninit/padding-wide-ptr.rs
@@ -1,3 +1,6 @@
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
+
 use std::mem;
 
 // If this is `None`, the metadata becomes padding.
diff --git a/src/tools/miri/tests/fail/uninit/padding-wide-ptr.stderr b/src/tools/miri/tests/fail/uninit/padding-wide-ptr.stderr
index f6446a5a95b..ce11320ca1b 100644
--- a/src/tools/miri/tests/fail/uninit/padding-wide-ptr.stderr
+++ b/src/tools/miri/tests/fail/uninit/padding-wide-ptr.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x8..0x9], but memory is uninitialized at [0x8..0x9], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail/uninit/padding-wide-ptr.rs:LL:CC
    |
 LL |         let _val = *c.add(mem::size_of::<*const u8>());
@@ -9,10 +9,8 @@ LL |         let _val = *c.add(mem::size_of::<*const u8>());
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/uninit/padding-wide-ptr.rs:LL:CC
 
-Uninitialized memory occurred at ALLOC[0x8..0x9], in this allocation:
-ALLOC (stack variable, size: 16, align: 8) {
-    00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ __ │ ........░░░░░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
diff --git a/src/tools/miri/tests/fail/uninit/transmute-pair-uninit.rs b/src/tools/miri/tests/fail/uninit/transmute-pair-uninit.rs
index 0ba5520a544..c1d284c7057 100644
--- a/src/tools/miri/tests/fail/uninit/transmute-pair-uninit.rs
+++ b/src/tools/miri/tests/fail/uninit/transmute-pair-uninit.rs
@@ -1,3 +1,6 @@
+//@ normalize-stderr-test: "(\n)ALLOC \(.*\) \{\n(.*\n)*\}(\n)" -> "${1}ALLOC DUMP${3}"
+//@ normalize-stderr-test: "\[0x[0-9a-z]..0x[0-9a-z]\]" -> "[0xX..0xY]"
+
 #![feature(core_intrinsics)]
 
 use std::mem::{self, MaybeUninit};
diff --git a/src/tools/miri/tests/fail/uninit/transmute-pair-uninit.stderr b/src/tools/miri/tests/fail/uninit/transmute-pair-uninit.stderr
index 385d877e2ee..eb049dd41ec 100644
--- a/src/tools/miri/tests/fail/uninit/transmute-pair-uninit.stderr
+++ b/src/tools/miri/tests/fail/uninit/transmute-pair-uninit.stderr
@@ -1,4 +1,4 @@
-error: Undefined Behavior: reading memory at ALLOC[0x9..0xa], but memory is uninitialized at [0x9..0xa], and this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0xX..0xY], but memory is uninitialized at [0xX..0xY], and this operation requires initialized memory
   --> tests/fail/uninit/transmute-pair-uninit.rs:LL:CC
    |
 LL |     let v = unsafe { *z.offset(first_undef) };
@@ -9,10 +9,8 @@ LL |     let v = unsafe { *z.offset(first_undef) };
    = note: BACKTRACE:
    = note: inside `main` at tests/fail/uninit/transmute-pair-uninit.rs:LL:CC
 
-Uninitialized memory occurred at ALLOC[0x9..0xa], in this allocation:
-ALLOC (stack variable, size: 16, align: 8) {
-    00 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ │ .........░░░░░░░
-}
+Uninitialized memory occurred at ALLOC[0xX..0xY], in this allocation:
+ALLOC DUMP
 
 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/tracing/partial_init.rs b/src/tools/miri/tests/native-lib/fail/tracing/partial_init.rs
index e267f82e215..7ab160773ff 100644
--- a/src/tools/miri/tests/native-lib/fail/tracing/partial_init.rs
+++ b/src/tools/miri/tests/native-lib/fail/tracing/partial_init.rs
@@ -20,6 +20,6 @@ fn partial_init() {
         assert!(*slice_ptr == 0);
         assert!(*slice_ptr.offset(1) == 0);
         // Reading the third is UB!
-        let _val = *slice_ptr.offset(2); //~ ERROR: Undefined Behavior: using uninitialized data
+        let _val = *slice_ptr.offset(2); //~ ERROR: /Undefined Behavior: reading memory.*, but memory is uninitialized/
     }
 }
diff --git a/src/tools/miri/tests/native-lib/fail/tracing/partial_init.stderr b/src/tools/miri/tests/native-lib/fail/tracing/partial_init.stderr
index 84fd913b5e5..74a599ede5c 100644
--- a/src/tools/miri/tests/native-lib/fail/tracing/partial_init.stderr
+++ b/src/tools/miri/tests/native-lib/fail/tracing/partial_init.stderr
@@ -17,7 +17,7 @@ note: inside `main`
 LL |     partial_init();
    |     ^^^^^^^^^^^^^^
 
-error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+error: Undefined Behavior: reading memory at ALLOC[0x2..0x3], but memory is uninitialized at [0x2..0x3], and this operation requires initialized memory
   --> tests/native-lib/fail/tracing/partial_init.rs:LL:CC
    |
 LL |         let _val = *slice_ptr.offset(2);
@@ -33,6 +33,11 @@ note: inside `main`
 LL |     partial_init();
    |     ^^^^^^^^^^^^^^
 
+Uninitialized memory occurred at ALLOC[0x2..0x3], in this allocation:
+ALLOC (stack variable, size: 3, align: 1) {
+    ╾00[wildcard] (1 ptr byte)╼ ╾00[wildcard] (1 ptr byte)╼ __                                        │ ━━░
+}
+
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
 
 error: aborting due to 1 previous error; 1 warning emitted
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 107179516bc..0c57eddbe93 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,6 +3,10 @@ error[E0080]: reading memory at ALLOC0[0x0..0x4], but memory is uninitialized at
    |
 LL |   get_flag::<false, { unsafe { char_raw.character } }>();
    |                                ^^^^^^^^^^^^^^^^^^ evaluation of `main::{constant#7}` failed here
+   |
+   = note: the raw bytes of the constant (size: 4, align: 4) {
+               ff __ __ __                                     │ .░░░
+           }
 
 error[E0080]: constructing invalid value: encountered 0x42, but expected a boolean
   --> $DIR/invalid-patterns.rs:42:14
@@ -31,6 +35,10 @@ error[E0080]: reading memory at ALLOC1[0x0..0x4], but memory is uninitialized at
    |
 LL |   get_flag::<{ unsafe { bool_raw.boolean } }, { unsafe { char_raw.character } }>();
    |                                                          ^^^^^^^^^^^^^^^^^^ evaluation of `main::{constant#11}` failed here
+   |
+   = note: the raw bytes of the constant (size: 4, align: 4) {
+               ff __ __ __                                     │ .░░░
+           }
 
 error[E0308]: mismatched types
   --> $DIR/invalid-patterns.rs:31:21
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 107179516bc..0c57eddbe93 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,6 +3,10 @@ error[E0080]: reading memory at ALLOC0[0x0..0x4], but memory is uninitialized at
    |
 LL |   get_flag::<false, { unsafe { char_raw.character } }>();
    |                                ^^^^^^^^^^^^^^^^^^ evaluation of `main::{constant#7}` failed here
+   |
+   = note: the raw bytes of the constant (size: 4, align: 4) {
+               ff __ __ __                                     │ .░░░
+           }
 
 error[E0080]: constructing invalid value: encountered 0x42, but expected a boolean
   --> $DIR/invalid-patterns.rs:42:14
@@ -31,6 +35,10 @@ error[E0080]: reading memory at ALLOC1[0x0..0x4], but memory is uninitialized at
    |
 LL |   get_flag::<{ unsafe { bool_raw.boolean } }, { unsafe { char_raw.character } }>();
    |                                                          ^^^^^^^^^^^^^^^^^^ evaluation of `main::{constant#11}` failed here
+   |
+   = note: the raw bytes of the constant (size: 4, align: 4) {
+               ff __ __ __                                     │ .░░░
+           }
 
 error[E0308]: mismatched types
   --> $DIR/invalid-patterns.rs:31:21
diff --git a/tests/ui/consts/const-compare-bytes-ub.stderr b/tests/ui/consts/const-compare-bytes-ub.stderr
index c1706a8c4b0..770a55cc726 100644
--- a/tests/ui/consts/const-compare-bytes-ub.stderr
+++ b/tests/ui/consts/const-compare-bytes-ub.stderr
@@ -33,12 +33,20 @@ error[E0080]: reading memory at ALLOC2[0x0..0x1], but memory is uninitialized at
    |
 LL |         compare_bytes(MaybeUninit::uninit().as_ptr(), [1].as_ptr(), 1)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `main::LHS_UNINIT` failed here
+   |
+   = note: the raw bytes of the constant (size: 1, align: 1) {
+               __                                              │ ░
+           }
 
 error[E0080]: reading memory at ALLOC3[0x0..0x1], but memory is uninitialized at [0x0..0x1], and this operation requires initialized memory
   --> $DIR/const-compare-bytes-ub.rs:33:9
    |
 LL |         compare_bytes([1].as_ptr(), MaybeUninit::uninit().as_ptr(), 1)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `main::RHS_UNINIT` failed here
+   |
+   = note: the raw bytes of the constant (size: 1, align: 1) {
+               __                                              │ ░
+           }
 
 error[E0080]: unable to turn pointer into integer
   --> $DIR/const-compare-bytes-ub.rs:37:9
diff --git a/tests/ui/consts/const-err-enum-discriminant.32bit.stderr b/tests/ui/consts/const-err-enum-discriminant.32bit.stderr
new file mode 100644
index 00000000000..cc786108f64
--- /dev/null
+++ b/tests/ui/consts/const-err-enum-discriminant.32bit.stderr
@@ -0,0 +1,13 @@
+error[E0080]: reading memory at ALLOC0[0x0..0x4], but memory is uninitialized at [0x0..0x4], and this operation requires initialized memory
+  --> $DIR/const-err-enum-discriminant.rs:10:21
+   |
+LL |     Boo = [unsafe { Foo { b: () }.a }; 4][3],
+   |                     ^^^^^^^^^^^^^^^ evaluation of `Bar::Boo::{constant#0}` failed here
+   |
+   = note: the raw bytes of the constant (size: 4, align: 4) {
+               __ __ __ __                                     │ ░░░░
+           }
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-err-enum-discriminant.64bit.stderr b/tests/ui/consts/const-err-enum-discriminant.64bit.stderr
new file mode 100644
index 00000000000..1d32851aac1
--- /dev/null
+++ b/tests/ui/consts/const-err-enum-discriminant.64bit.stderr
@@ -0,0 +1,13 @@
+error[E0080]: reading memory at ALLOC0[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
+  --> $DIR/const-err-enum-discriminant.rs:10:21
+   |
+LL |     Boo = [unsafe { Foo { b: () }.a }; 4][3],
+   |                     ^^^^^^^^^^^^^^^ evaluation of `Bar::Boo::{constant#0}` failed here
+   |
+   = note: the raw bytes of the constant (size: 8, align: 8) {
+               __ __ __ __ __ __ __ __                         │ ░░░░░░░░
+           }
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-err-enum-discriminant.rs b/tests/ui/consts/const-err-enum-discriminant.rs
index 190ef47f436..55674600584 100644
--- a/tests/ui/consts/const-err-enum-discriminant.rs
+++ b/tests/ui/consts/const-err-enum-discriminant.rs
@@ -1,3 +1,5 @@
+//@ stderr-per-bitwidth
+
 #[derive(Copy, Clone)]
 union Foo {
     a: isize,
diff --git a/tests/ui/consts/const-err-enum-discriminant.stderr b/tests/ui/consts/const-err-enum-discriminant.stderr
deleted file mode 100644
index f935d1054de..00000000000
--- a/tests/ui/consts/const-err-enum-discriminant.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0080]: reading memory at ALLOC0[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
-  --> $DIR/const-err-enum-discriminant.rs:8:21
-   |
-LL |     Boo = [unsafe { Foo { b: () }.a }; 4][3],
-   |                     ^^^^^^^^^^^^^^^ evaluation of `Bar::Boo::{constant#0}` failed here
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr b/tests/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr
index 65e846b5741..60f6ef0f64b 100644
--- a/tests/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr
+++ b/tests/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr
@@ -43,11 +43,15 @@ LL |     const I32_REF_U64_UNION: u64 = unsafe { Nonsense { int_32_ref: &3 }.uin
    = 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]: reading memory at ALLOC0[0x0..0x10], but memory is uninitialized at [0x8..0x10], and this operation requires initialized memory
+error[E0080]: reading memory at ALLOC2[0x0..0x10], but memory is uninitialized at [0x8..0x10], and this operation requires initialized memory
   --> $DIR/const-pointer-values-in-various-types.rs:42:47
    |
 LL |     const I32_REF_U128_UNION: u128 = unsafe { Nonsense { int_32_ref: &3 }.uint_128 };
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `main::I32_REF_U128_UNION` failed here
+   |
+   = note: the raw bytes of the constant (size: 16, align: 16) {
+               ╾ALLOC0<imm>╼ __ __ __ __ __ __ __ __ │ ╾──────╼░░░░░░░░
+           }
 
 error[E0080]: unable to turn pointer into integer
   --> $DIR/const-pointer-values-in-various-types.rs:45:43
@@ -85,11 +89,15 @@ LL |     const I32_REF_I64_UNION: i64 = unsafe { Nonsense { int_32_ref: &3 }.int
    = 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]: reading memory at ALLOC1[0x0..0x10], but memory is uninitialized at [0x8..0x10], and this operation requires initialized memory
+error[E0080]: reading memory at ALLOC3[0x0..0x10], but memory is uninitialized at [0x8..0x10], and this operation requires initialized memory
   --> $DIR/const-pointer-values-in-various-types.rs:57:47
    |
 LL |     const I32_REF_I128_UNION: i128 = unsafe { Nonsense { int_32_ref: &3 }.int_128 };
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `main::I32_REF_I128_UNION` failed here
+   |
+   = note: the raw bytes of the constant (size: 16, align: 16) {
+               ╾ALLOC1<imm>╼ __ __ __ __ __ __ __ __ │ ╾──────╼░░░░░░░░
+           }
 
 error[E0080]: unable to turn pointer into integer
   --> $DIR/const-pointer-values-in-various-types.rs:60:45
diff --git a/tests/ui/consts/const-eval/ub-enum-overwrite.stderr b/tests/ui/consts/const-eval/ub-enum-overwrite.stderr
index 14f369eace4..2fd01b67c49 100644
--- a/tests/ui/consts/const-eval/ub-enum-overwrite.stderr
+++ b/tests/ui/consts/const-eval/ub-enum-overwrite.stderr
@@ -3,6 +3,10 @@ error[E0080]: reading memory at ALLOC0[0x1..0x2], but memory is uninitialized at
    |
 LL |     unsafe { *p }
    |              ^^ evaluation of `_` failed here
+   |
+   = note: the raw bytes of the constant (size: 2, align: 1) {
+               01 __                                           │ .░
+           }
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/ub-enum.rs b/tests/ui/consts/const-eval/ub-enum.rs
index 52fc9945068..9c78bb6efed 100644
--- a/tests/ui/consts/const-eval/ub-enum.rs
+++ b/tests/ui/consts/const-eval/ub-enum.rs
@@ -1,7 +1,8 @@
 // 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"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 //@ normalize-stderr: "0x0+" -> "0x0"
+//@ normalize-stderr: "0x[0-9](\.\.|\])" -> "0x%$1"
 //@ dont-require-annotations: NOTE
 
 #![feature(never_type)]
diff --git a/tests/ui/consts/const-eval/ub-enum.stderr b/tests/ui/consts/const-eval/ub-enum.stderr
index 6665830e250..5cbd6176c92 100644
--- a/tests/ui/consts/const-eval/ub-enum.stderr
+++ b/tests/ui/consts/const-eval/ub-enum.stderr
@@ -1,5 +1,5 @@
 error[E0080]: constructing invalid value at .<enum-tag>: encountered 0x01, but expected a valid enum tag
-  --> $DIR/ub-enum.rs:29:1
+  --> $DIR/ub-enum.rs:30:1
    |
 LL | const BAD_ENUM: Enum = unsafe { mem::transmute(1usize) };
    | ^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -10,7 +10,7 @@ LL | const BAD_ENUM: Enum = unsafe { mem::transmute(1usize) };
            }
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-enum.rs:32:1
+  --> $DIR/ub-enum.rs:33:1
    |
 LL | const BAD_ENUM_PTR: Enum = unsafe { mem::transmute(&1) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_ENUM_PTR` failed here
@@ -19,7 +19,7 @@ LL | const BAD_ENUM_PTR: Enum = unsafe { mem::transmute(&1) };
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-enum.rs:35:1
+  --> $DIR/ub-enum.rs:36:1
    |
 LL | const BAD_ENUM_WRAPPED: Wrap<Enum> = unsafe { mem::transmute(&1) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_ENUM_WRAPPED` failed here
@@ -28,7 +28,7 @@ LL | const BAD_ENUM_WRAPPED: Wrap<Enum> = unsafe { mem::transmute(&1) };
    = 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
-  --> $DIR/ub-enum.rs:47:1
+  --> $DIR/ub-enum.rs:48:1
    |
 LL | const BAD_ENUM2: Enum2 = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -39,7 +39,7 @@ LL | const BAD_ENUM2: Enum2 = unsafe { mem::transmute(0usize) };
            }
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-enum.rs:49:1
+  --> $DIR/ub-enum.rs:50:1
    |
 LL | const BAD_ENUM2_PTR: Enum2 = unsafe { mem::transmute(&0) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_ENUM2_PTR` failed here
@@ -48,7 +48,7 @@ LL | const BAD_ENUM2_PTR: Enum2 = unsafe { mem::transmute(&0) };
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-enum.rs:52:1
+  --> $DIR/ub-enum.rs:53:1
    |
 LL | const BAD_ENUM2_WRAPPED: Wrap<Enum2> = unsafe { mem::transmute(&0) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_ENUM2_WRAPPED` failed here
@@ -56,14 +56,18 @@ LL | const BAD_ENUM2_WRAPPED: Wrap<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]: reading memory at ALLOC0[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
-  --> $DIR/ub-enum.rs:61:41
+error[E0080]: reading memory at ALLOC0[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
+  --> $DIR/ub-enum.rs:62:41
    |
 LL | const BAD_ENUM2_UNDEF: Enum2 = unsafe { MaybeUninit { uninit: () }.init };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_ENUM2_UNDEF` failed here
+   |
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               HEX_DUMP
+           }
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-enum.rs:65:1
+  --> $DIR/ub-enum.rs:66:1
    |
 LL | const BAD_ENUM2_OPTION_PTR: Option<Enum2> = unsafe { mem::transmute(&0) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_ENUM2_OPTION_PTR` failed here
@@ -72,7 +76,7 @@ LL | const BAD_ENUM2_OPTION_PTR: Option<Enum2> = unsafe { mem::transmute(&0) };
    = 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
-  --> $DIR/ub-enum.rs:82:1
+  --> $DIR/ub-enum.rs:83:1
    |
 LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute(1u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -83,7 +87,7 @@ LL | const BAD_UNINHABITED_VARIANT1: UninhDiscriminant = unsafe { mem::transmute
            }
 
 error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
-  --> $DIR/ub-enum.rs:84:1
+  --> $DIR/ub-enum.rs:85:1
    |
 LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute(3u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -94,7 +98,7 @@ LL | const BAD_UNINHABITED_VARIANT2: UninhDiscriminant = unsafe { mem::transmute
            }
 
 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`)
-  --> $DIR/ub-enum.rs:92:1
+  --> $DIR/ub-enum.rs:93:1
    |
 LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::transmute(!0u32) }));
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -105,19 +109,19 @@ LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::tran
            }
 
 error[E0080]: constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
-  --> $DIR/ub-enum.rs:97:77
+  --> $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
-  --> $DIR/ub-enum.rs:99:77
+  --> $DIR/ub-enum.rs:100:77
    |
 LL | const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe { mem::transmute(0u64) };
    |                                                                             ^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_UNINHABITED_WITH_DATA2` failed here
 
 error[E0080]: read discriminant of an uninhabited enum variant
-  --> $DIR/ub-enum.rs:105:9
+  --> $DIR/ub-enum.rs:106:9
    |
 LL |         std::mem::discriminant(&*(&() as *const () as *const Never));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `TEST_ICE_89765` failed inside this call
diff --git a/tests/ui/consts/const-eval/ub-nonnull.stderr b/tests/ui/consts/const-eval/ub-nonnull.stderr
index c92797f330a..19ae66cf3c6 100644
--- a/tests/ui/consts/const-eval/ub-nonnull.stderr
+++ b/tests/ui/consts/const-eval/ub-nonnull.stderr
@@ -42,6 +42,10 @@ error[E0080]: reading memory at ALLOC2[0x0..0x1], but memory is uninitialized at
    |
 LL | const UNINIT: NonZero<u8> = unsafe { MaybeUninit { uninit: () }.init };
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `UNINIT` failed here
+   |
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               __                                              │ ░
+           }
 
 error[E0080]: constructing invalid value: encountered 42, but expected something in the range 10..=30
   --> $DIR/ub-nonnull.rs:44:1
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.rs b/tests/ui/consts/const-eval/ub-ref-ptr.rs
index 64b48939be6..d8e5102fcbe 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.rs
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.rs
@@ -1,8 +1,9 @@
 // ignore-tidy-linelength
 // 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"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 //@ dont-require-annotations: NOTE
+//@ normalize-stderr: "0x[0-9](\.\.|\])" -> "0x%$1"
 
 #![allow(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 beb54e43534..451ebb6eba1 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.stderr
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
@@ -1,5 +1,5 @@
 error[E0080]: constructing invalid value: encountered an unaligned reference (required 2 byte alignment but found 1)
-  --> $DIR/ub-ref-ptr.rs:17:1
+  --> $DIR/ub-ref-ptr.rs:18:1
    |
 LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
    | ^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -10,7 +10,7 @@ LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
            }
 
 error[E0080]: constructing invalid value: encountered an unaligned box (required 2 byte alignment but found 1)
-  --> $DIR/ub-ref-ptr.rs:20:1
+  --> $DIR/ub-ref-ptr.rs:21:1
    |
 LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -21,7 +21,7 @@ LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
            }
 
 error[E0080]: constructing invalid value: encountered a null reference
-  --> $DIR/ub-ref-ptr.rs:23:1
+  --> $DIR/ub-ref-ptr.rs:24:1
    |
 LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -32,7 +32,7 @@ LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
            }
 
 error[E0080]: constructing invalid value: encountered a null box
-  --> $DIR/ub-ref-ptr.rs:26:1
+  --> $DIR/ub-ref-ptr.rs:27:1
    |
 LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -43,7 +43,7 @@ LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
            }
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-ref-ptr.rs:33:1
+  --> $DIR/ub-ref-ptr.rs:34:1
    |
 LL | const REF_AS_USIZE: usize = unsafe { mem::transmute(&0) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `REF_AS_USIZE` failed here
@@ -52,7 +52,7 @@ LL | const REF_AS_USIZE: usize = unsafe { mem::transmute(&0) };
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-ref-ptr.rs:36:39
+  --> $DIR/ub-ref-ptr.rs:37:39
    |
 LL | const REF_AS_USIZE_SLICE: &[usize] = &[unsafe { mem::transmute(&0) }];
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `REF_AS_USIZE_SLICE` failed here
@@ -61,13 +61,13 @@ LL | const REF_AS_USIZE_SLICE: &[usize] = &[unsafe { mem::transmute(&0) }];
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 note: erroneous constant encountered
-  --> $DIR/ub-ref-ptr.rs:36:38
+  --> $DIR/ub-ref-ptr.rs:37:38
    |
 LL | const REF_AS_USIZE_SLICE: &[usize] = &[unsafe { mem::transmute(&0) }];
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-ref-ptr.rs:39:86
+  --> $DIR/ub-ref-ptr.rs:40:86
    |
 LL | const REF_AS_USIZE_BOX_SLICE: Box<[usize]> = unsafe { mem::transmute::<&[usize], _>(&[mem::transmute(&0)]) };
    |                                                                                      ^^^^^^^^^^^^^^^^^^^^ evaluation of `REF_AS_USIZE_BOX_SLICE` failed here
@@ -76,13 +76,13 @@ LL | const REF_AS_USIZE_BOX_SLICE: Box<[usize]> = unsafe { mem::transmute::<&[us
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 note: erroneous constant encountered
-  --> $DIR/ub-ref-ptr.rs:39:85
+  --> $DIR/ub-ref-ptr.rs:40:85
    |
 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)
-  --> $DIR/ub-ref-ptr.rs:42:1
+  --> $DIR/ub-ref-ptr.rs:43:1
    |
 LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -93,7 +93,7 @@ LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
            }
 
 error[E0080]: constructing invalid value: encountered a dangling box (0x539[noalloc] has no provenance)
-  --> $DIR/ub-ref-ptr.rs:45:1
+  --> $DIR/ub-ref-ptr.rs:46:1
    |
 LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -103,14 +103,18 @@ LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
                HEX_DUMP
            }
 
-error[E0080]: reading memory at ALLOC3[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
-  --> $DIR/ub-ref-ptr.rs:48:41
+error[E0080]: reading memory at ALLOC3[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
+  --> $DIR/ub-ref-ptr.rs:49:41
    |
 LL | const UNINIT_PTR: *const i32 = unsafe { MaybeUninit { uninit: () }.init };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `UNINIT_PTR` failed here
+   |
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               HEX_DUMP
+           }
 
 error[E0080]: constructing invalid value: encountered null pointer, but expected a function pointer
-  --> $DIR/ub-ref-ptr.rs:51:1
+  --> $DIR/ub-ref-ptr.rs:52:1
    |
 LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -120,14 +124,18 @@ LL | const NULL_FN_PTR: fn() = unsafe { mem::transmute(0usize) };
                HEX_DUMP
            }
 
-error[E0080]: reading memory at ALLOC4[0x0..0x8], but memory is uninitialized at [0x0..0x8], and this operation requires initialized memory
-  --> $DIR/ub-ref-ptr.rs:53:38
+error[E0080]: reading memory at ALLOC4[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
+  --> $DIR/ub-ref-ptr.rs:54:38
    |
 LL | const UNINIT_FN_PTR: fn() = unsafe { MaybeUninit { uninit: () }.init };
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `UNINIT_FN_PTR` failed here
+   |
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               HEX_DUMP
+           }
 
 error[E0080]: constructing invalid value: encountered 0xd[noalloc], but expected a function pointer
-  --> $DIR/ub-ref-ptr.rs:55:1
+  --> $DIR/ub-ref-ptr.rs:56:1
    |
 LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -138,7 +146,7 @@ LL | const DANGLING_FN_PTR: fn() = unsafe { mem::transmute(13usize) };
            }
 
 error[E0080]: constructing invalid value: encountered ALLOC2<imm>, but expected a function pointer
-  --> $DIR/ub-ref-ptr.rs:57:1
+  --> $DIR/ub-ref-ptr.rs:58:1
    |
 LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -149,7 +157,7 @@ LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
            }
 
 error[E0080]: accessing memory based on pointer with alignment 1, but alignment 4 is required
-  --> $DIR/ub-ref-ptr.rs:64:5
+  --> $DIR/ub-ref-ptr.rs:65:5
    |
 LL |     ptr.read();
    |     ^^^^^^^^^^ evaluation of `UNALIGNED_READ` failed here
diff --git a/tests/ui/consts/const-eval/ub-wide-ptr.rs b/tests/ui/consts/const-eval/ub-wide-ptr.rs
index 86235897e7e..0bbb104c032 100644
--- a/tests/ui/consts/const-eval/ub-wide-ptr.rs
+++ b/tests/ui/consts/const-eval/ub-wide-ptr.rs
@@ -6,9 +6,10 @@ use std::{ptr, mem};
 
 // 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"
+//@ normalize-stderr: "([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 //@ normalize-stderr: "offset \d+" -> "offset N"
 //@ normalize-stderr: "size \d+" -> "size N"
+//@ normalize-stderr: "0x[0-9](\.\.|\])" -> "0x%$1"
 //@ dont-require-annotations: NOTE
 
 /// A newtype wrapper to prevent MIR generation from inserting reborrows that would affect the error
@@ -61,7 +62,7 @@ const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::
 const SLICE_VALID: &[u8] = unsafe { mem::transmute((&42u8, 1usize)) };
 // bad slice: length uninit
 const SLICE_LENGTH_UNINIT: &[u8] = unsafe {
-//~^ ERROR uninitialized
+    //~^ ERROR uninitialized
     let uninit_len = MaybeUninit::<usize> { uninit: () };
     mem::transmute((42, uninit_len))
 };
@@ -99,7 +100,7 @@ const RAW_SLICE_VALID: *const [u8] = unsafe { mem::transmute((&42u8, 1usize)) };
 const RAW_SLICE_TOO_LONG: *const [u8] = unsafe { mem::transmute((&42u8, 999usize)) }; // ok because raw
 const RAW_SLICE_MUCH_TOO_LONG: *const [u8] = unsafe { mem::transmute((&42u8, usize::MAX)) }; // ok because raw
 const RAW_SLICE_LENGTH_UNINIT: *const [u8] = unsafe {
-//~^ ERROR uninitialized
+    //~^ ERROR uninitialized
     let uninit_len = MaybeUninit::<usize> { uninit: () };
     mem::transmute((42, uninit_len))
 };
diff --git a/tests/ui/consts/const-eval/ub-wide-ptr.stderr b/tests/ui/consts/const-eval/ub-wide-ptr.stderr
index a3eb5c72031..ab15ba826a5 100644
--- a/tests/ui/consts/const-eval/ub-wide-ptr.stderr
+++ b/tests/ui/consts/const-eval/ub-wide-ptr.stderr
@@ -1,5 +1,5 @@
 error[E0080]: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
-  --> $DIR/ub-wide-ptr.rs:39:1
+  --> $DIR/ub-wide-ptr.rs:40:1
    |
 LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -10,7 +10,7 @@ LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
            }
 
 error[E0080]: constructing invalid value at .0: encountered invalid reference metadata: slice is bigger than largest supported object
-  --> $DIR/ub-wide-ptr.rs:41:1
+  --> $DIR/ub-wide-ptr.rs:42:1
    |
 LL | const NESTED_STR_MUCH_TOO_LONG: (&str,) = (unsafe { mem::transmute((&42, usize::MAX)) },);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -21,7 +21,7 @@ LL | const NESTED_STR_MUCH_TOO_LONG: (&str,) = (unsafe { mem::transmute((&42, us
            }
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-wide-ptr.rs:44:1
+  --> $DIR/ub-wide-ptr.rs:45:1
    |
 LL | const STR_LENGTH_PTR: &str = unsafe { mem::transmute((&42u8, &3)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `STR_LENGTH_PTR` failed here
@@ -30,7 +30,7 @@ LL | const STR_LENGTH_PTR: &str = unsafe { mem::transmute((&42u8, &3)) };
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-wide-ptr.rs:47:1
+  --> $DIR/ub-wide-ptr.rs:48:1
    |
 LL | const MY_STR_LENGTH_PTR: &MyStr = unsafe { mem::transmute((&42u8, &3)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `MY_STR_LENGTH_PTR` failed here
@@ -39,7 +39,7 @@ LL | const MY_STR_LENGTH_PTR: &MyStr = unsafe { mem::transmute((&42u8, &3)) };
    = 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
-  --> $DIR/ub-wide-ptr.rs:49:1
+  --> $DIR/ub-wide-ptr.rs:50:1
    |
 LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize::MAX)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -50,7 +50,7 @@ LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize:
            }
 
 error[E0080]: constructing invalid value at .<deref>: encountered uninitialized memory, but expected a string
-  --> $DIR/ub-wide-ptr.rs:53:1
+  --> $DIR/ub-wide-ptr.rs:54:1
    |
 LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -61,7 +61,7 @@ LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit:
            }
 
 error[E0080]: constructing invalid value at .<deref>.0: encountered uninitialized memory, but expected a string
-  --> $DIR/ub-wide-ptr.rs:56:1
+  --> $DIR/ub-wide-ptr.rs:57:1
    |
 LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -71,14 +71,18 @@ LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUni
                HEX_DUMP
            }
 
-error[E0080]: reading memory at ALLOC32[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
-  --> $DIR/ub-wide-ptr.rs:63:1
+error[E0080]: reading memory at ALLOC32[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
+  --> $DIR/ub-wide-ptr.rs:64:1
    |
 LL | const SLICE_LENGTH_UNINIT: &[u8] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `SLICE_LENGTH_UNINIT` failed here
+   |
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               HEX_DUMP
+           }
 
 error[E0080]: constructing invalid value: encountered a dangling reference (going beyond the bounds of its allocation)
-  --> $DIR/ub-wide-ptr.rs:69:1
+  --> $DIR/ub-wide-ptr.rs:70:1
    |
 LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -89,7 +93,7 @@ LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
            }
 
 error[E0080]: constructing invalid value: encountered invalid reference metadata: slice is bigger than largest supported object
-  --> $DIR/ub-wide-ptr.rs:72:1
+  --> $DIR/ub-wide-ptr.rs:73:1
    |
 LL | const SLICE_TOO_LONG_OVERFLOW: &[u32] = unsafe { mem::transmute((&42u32, isize::MAX)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -100,7 +104,7 @@ LL | const SLICE_TOO_LONG_OVERFLOW: &[u32] = unsafe { mem::transmute((&42u32, is
            }
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-wide-ptr.rs:75:1
+  --> $DIR/ub-wide-ptr.rs:76:1
    |
 LL | const SLICE_LENGTH_PTR: &[u8] = unsafe { mem::transmute((&42u8, &3)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `SLICE_LENGTH_PTR` failed here
@@ -109,7 +113,7 @@ LL | const SLICE_LENGTH_PTR: &[u8] = unsafe { mem::transmute((&42u8, &3)) };
    = 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)
-  --> $DIR/ub-wide-ptr.rs:78:1
+  --> $DIR/ub-wide-ptr.rs:79:1
    |
 LL | const SLICE_TOO_LONG_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, 999usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -120,7 +124,7 @@ LL | const SLICE_TOO_LONG_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, 999us
            }
 
 error[E0080]: unable to turn pointer into integer
-  --> $DIR/ub-wide-ptr.rs:81:1
+  --> $DIR/ub-wide-ptr.rs:82:1
    |
 LL | const SLICE_LENGTH_PTR_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, &3)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `SLICE_LENGTH_PTR_BOX` failed here
@@ -129,7 +133,7 @@ LL | const SLICE_LENGTH_PTR_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, &3)
    = 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
-  --> $DIR/ub-wide-ptr.rs:85:1
+  --> $DIR/ub-wide-ptr.rs:86:1
    |
 LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -140,13 +144,13 @@ LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
            }
 
 note: erroneous constant encountered
-  --> $DIR/ub-wide-ptr.rs:85:40
+  --> $DIR/ub-wide-ptr.rs:86:40
    |
 LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
    |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0080]: constructing invalid value at .<deref>.0: encountered 0x03, but expected a boolean
-  --> $DIR/ub-wide-ptr.rs:91:1
+  --> $DIR/ub-wide-ptr.rs:92:1
    |
 LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3u8) }, [false]);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -157,13 +161,13 @@ LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3
            }
 
 note: erroneous constant encountered
-  --> $DIR/ub-wide-ptr.rs:91:42
+  --> $DIR/ub-wide-ptr.rs:92:42
    |
 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
-  --> $DIR/ub-wide-ptr.rs:94:1
+  --> $DIR/ub-wide-ptr.rs:95:1
    |
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -174,19 +178,23 @@ LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::tran
            }
 
 note: erroneous constant encountered
-  --> $DIR/ub-wide-ptr.rs:94:42
+  --> $DIR/ub-wide-ptr.rs:95:42
    |
 LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0080]: reading memory at ALLOC33[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
-  --> $DIR/ub-wide-ptr.rs:101:1
+error[E0080]: reading memory at ALLOC33[0x%..0x%], but memory is uninitialized at [0x%..0x%], and this operation requires initialized memory
+  --> $DIR/ub-wide-ptr.rs:102:1
    |
 LL | const RAW_SLICE_LENGTH_UNINIT: *const [u8] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `RAW_SLICE_LENGTH_UNINIT` failed here
+   |
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               HEX_DUMP
+           }
 
 error[E0080]: constructing invalid value at .0: encountered ALLOC12<imm>, but expected a vtable pointer
-  --> $DIR/ub-wide-ptr.rs:109:1
+  --> $DIR/ub-wide-ptr.rs:110:1
    |
 LL | const TRAIT_OBJ_SHORT_VTABLE_1: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u8))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -197,7 +205,7 @@ LL | const TRAIT_OBJ_SHORT_VTABLE_1: W<&dyn Trait> = unsafe { mem::transmute(W((
            }
 
 error[E0080]: constructing invalid value at .0: encountered ALLOC14<imm>, but expected a vtable pointer
-  --> $DIR/ub-wide-ptr.rs:112:1
+  --> $DIR/ub-wide-ptr.rs:113:1
    |
 LL | const TRAIT_OBJ_SHORT_VTABLE_2: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, &3u64))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -208,7 +216,7 @@ LL | const TRAIT_OBJ_SHORT_VTABLE_2: W<&dyn Trait> = unsafe { mem::transmute(W((
            }
 
 error[E0080]: constructing invalid value at .0: encountered 0x4[noalloc], but expected a vtable pointer
-  --> $DIR/ub-wide-ptr.rs:115:1
+  --> $DIR/ub-wide-ptr.rs:116:1
    |
 LL | const TRAIT_OBJ_INT_VTABLE: W<&dyn Trait> = unsafe { mem::transmute(W((&92u8, 4usize))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -219,7 +227,7 @@ LL | const TRAIT_OBJ_INT_VTABLE: W<&dyn Trait> = unsafe { mem::transmute(W((&92u
            }
 
 error[E0080]: constructing invalid value: encountered ALLOC17<imm>, but expected a vtable pointer
-  --> $DIR/ub-wide-ptr.rs:117:1
+  --> $DIR/ub-wide-ptr.rs:118:1
    |
 LL | const TRAIT_OBJ_UNALIGNED_VTABLE: &dyn Trait = unsafe { mem::transmute((&92u8, &[0u8; 128])) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -230,7 +238,7 @@ LL | const TRAIT_OBJ_UNALIGNED_VTABLE: &dyn Trait = unsafe { mem::transmute((&92
            }
 
 error[E0080]: constructing invalid value: encountered ALLOC19<imm>, but expected a vtable pointer
-  --> $DIR/ub-wide-ptr.rs:119:1
+  --> $DIR/ub-wide-ptr.rs:120:1
    |
 LL | const TRAIT_OBJ_BAD_DROP_FN_NULL: &dyn Trait = unsafe { mem::transmute((&92u8, &[0usize; 8])) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -241,7 +249,7 @@ LL | const TRAIT_OBJ_BAD_DROP_FN_NULL: &dyn Trait = unsafe { mem::transmute((&92
            }
 
 error[E0080]: constructing invalid value: encountered ALLOC21<imm>, but expected a vtable pointer
-  --> $DIR/ub-wide-ptr.rs:121:1
+  --> $DIR/ub-wide-ptr.rs:122:1
    |
 LL | const TRAIT_OBJ_BAD_DROP_FN_INT: &dyn Trait = unsafe { mem::transmute((&92u8, &[1usize; 8])) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -252,7 +260,7 @@ LL | const TRAIT_OBJ_BAD_DROP_FN_INT: &dyn Trait = unsafe { mem::transmute((&92u
            }
 
 error[E0080]: constructing invalid value at .0: encountered ALLOC23<imm>, but expected a vtable pointer
-  --> $DIR/ub-wide-ptr.rs:123:1
+  --> $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]))) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -263,7 +271,7 @@ LL | const TRAIT_OBJ_BAD_DROP_FN_NOT_FN_PTR: W<&dyn Trait> = unsafe { mem::trans
            }
 
 error[E0080]: constructing invalid value at .<deref>.<dyn-downcast>: encountered 0x03, but expected a boolean
-  --> $DIR/ub-wide-ptr.rs:127:1
+  --> $DIR/ub-wide-ptr.rs:128:1
    |
 LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_, &bool>(&3u8) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -274,7 +282,7 @@ LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_,
            }
 
 error[E0080]: constructing invalid value: encountered null pointer, but expected a vtable pointer
-  --> $DIR/ub-wide-ptr.rs:131:1
+  --> $DIR/ub-wide-ptr.rs:132:1
    |
 LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute((&92u8, 0usize)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -285,7 +293,7 @@ LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute
            }
 
 error[E0080]: constructing invalid value: encountered ALLOC28<imm>, but expected a vtable pointer
-  --> $DIR/ub-wide-ptr.rs:133:1
+  --> $DIR/ub-wide-ptr.rs:134:1
    |
 LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transmute((&92u8, &3u64)) };
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -296,7 +304,7 @@ LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transm
            }
 
 error[E0080]: constructing invalid value: encountered null pointer, but expected a vtable pointer
-  --> $DIR/ub-wide-ptr.rs:140:1
+  --> $DIR/ub-wide-ptr.rs:141:1
    |
 LL | static mut RAW_TRAIT_OBJ_VTABLE_NULL_THROUGH_REF: *const dyn Trait = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
@@ -307,7 +315,7 @@ LL | static mut RAW_TRAIT_OBJ_VTABLE_NULL_THROUGH_REF: *const dyn Trait = unsafe
            }
 
 error[E0080]: constructing invalid value: encountered ALLOC31<imm>, but expected a vtable pointer
-  --> $DIR/ub-wide-ptr.rs:144:1
+  --> $DIR/ub-wide-ptr.rs:145:1
    |
 LL | static mut RAW_TRAIT_OBJ_VTABLE_INVALID_THROUGH_REF: *const dyn Trait = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ it is undefined behavior to use this value
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 0ad94eee7f4..719e59b007c 100644
--- a/tests/ui/consts/const-eval/union-const-eval-field.rs
+++ b/tests/ui/consts/const-eval/union-const-eval-field.rs
@@ -1,4 +1,5 @@
 //@ dont-require-annotations: NOTE
+//@ normalize-stderr: "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)"
 
 type Field1 = i32;
 type Field2 = f32;
diff --git a/tests/ui/consts/const-eval/union-const-eval-field.stderr b/tests/ui/consts/const-eval/union-const-eval-field.stderr
index deddf9e0b6d..1843ce273ac 100644
--- a/tests/ui/consts/const-eval/union-const-eval-field.stderr
+++ b/tests/ui/consts/const-eval/union-const-eval-field.stderr
@@ -1,17 +1,21 @@
 error[E0080]: reading memory at ALLOC0[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
-  --> $DIR/union-const-eval-field.rs:28:37
+  --> $DIR/union-const-eval-field.rs:29:37
    |
 LL |     const FIELD3: Field3 = unsafe { UNION.field3 };
    |                                     ^^^^^^^^^^^^ evaluation of `read_field3::FIELD3` failed here
+   |
+   = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+               00 00 80 3f __ __ __ __                         │ ...?░░░░
+           }
 
 note: erroneous constant encountered
-  --> $DIR/union-const-eval-field.rs:30:5
+  --> $DIR/union-const-eval-field.rs:31:5
    |
 LL |     FIELD3
    |     ^^^^^^
 
 note: erroneous constant encountered
-  --> $DIR/union-const-eval-field.rs:30:5
+  --> $DIR/union-const-eval-field.rs:31:5
    |
 LL |     FIELD3
    |     ^^^^^^
diff --git a/tests/ui/consts/const-eval/union-ice.stderr b/tests/ui/consts/const-eval/union-ice.stderr
index 826d7440a80..0506be63ea6 100644
--- a/tests/ui/consts/const-eval/union-ice.stderr
+++ b/tests/ui/consts/const-eval/union-ice.stderr
@@ -3,18 +3,30 @@ error[E0080]: reading memory at ALLOC0[0x0..0x8], but memory is uninitialized at
    |
 LL | const FIELD3: Field3 = unsafe { UNION.field3 };
    |                                 ^^^^^^^^^^^^ evaluation of `FIELD3` failed here
+   |
+   = note: the raw bytes of the constant (size: 8, align: 8) {
+               00 00 80 3f __ __ __ __                         │ ...?░░░░
+           }
 
 error[E0080]: reading memory at ALLOC1[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
   --> $DIR/union-ice.rs:19:17
    |
 LL |     b: unsafe { UNION.field3 },
    |                 ^^^^^^^^^^^^ evaluation of `FIELD_PATH` failed here
+   |
+   = note: the raw bytes of the constant (size: 8, align: 8) {
+               00 00 80 3f __ __ __ __                         │ ...?░░░░
+           }
 
 error[E0080]: reading memory at ALLOC2[0x0..0x8], but memory is uninitialized at [0x4..0x8], and this operation requires initialized memory
   --> $DIR/union-ice.rs:31:18
    |
 LL |         unsafe { UNION.field3 },
    |                  ^^^^^^^^^^^^ evaluation of `FIELD_PATH2` failed here
+   |
+   = note: the raw bytes of the constant (size: 8, align: 8) {
+               00 00 80 3f __ __ __ __                         │ ...?░░░░
+           }
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/consts/const-eval/union-ub.32bit.stderr b/tests/ui/consts/const-eval/union-ub.32bit.stderr
index 70bf2cf5390..757bcea91c3 100644
--- a/tests/ui/consts/const-eval/union-ub.32bit.stderr
+++ b/tests/ui/consts/const-eval/union-ub.32bit.stderr
@@ -14,6 +14,10 @@ error[E0080]: reading memory at ALLOC0[0x0..0x1], but memory is uninitialized at
    |
 LL | const UNINIT_BOOL: bool = unsafe { DummyUnion { unit: () }.bool };
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `UNINIT_BOOL` failed here
+   |
+   = note: the raw bytes of the constant (size: 1, align: 1) {
+               __                                              │ ░
+           }
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/consts/const-eval/union-ub.64bit.stderr b/tests/ui/consts/const-eval/union-ub.64bit.stderr
index 70bf2cf5390..757bcea91c3 100644
--- a/tests/ui/consts/const-eval/union-ub.64bit.stderr
+++ b/tests/ui/consts/const-eval/union-ub.64bit.stderr
@@ -14,6 +14,10 @@ error[E0080]: reading memory at ALLOC0[0x0..0x1], but memory is uninitialized at
    |
 LL | const UNINIT_BOOL: bool = unsafe { DummyUnion { unit: () }.bool };
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `UNINIT_BOOL` failed here
+   |
+   = note: the raw bytes of the constant (size: 1, align: 1) {
+               __                                              │ ░
+           }
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr
index 10f4d8d1a71..5f4ef14d586 100644
--- a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr
+++ b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr
@@ -3,6 +3,10 @@ error[E0080]: reading memory at ALLOC0[0x0..0x4], but memory is uninitialized at
    |
 LL |     std::intrinsics::raw_eq(&(1_u8, 2_u16), &(1_u8, 2_u16))
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `RAW_EQ_PADDING` failed here
+   |
+   = note: the raw bytes of the constant (size: 4, align: 2) {
+               01 __ 02 00                                     │ .░..
+           }
 
 error[E0080]: unable to turn pointer into integer
   --> $DIR/intrinsic-raw_eq-const-bad.rs:9:5
diff --git a/tests/ui/type/pattern_types/validity.stderr b/tests/ui/type/pattern_types/validity.stderr
index 76824055d8a..b545cd75ddb 100644
--- a/tests/ui/type/pattern_types/validity.stderr
+++ b/tests/ui/type/pattern_types/validity.stderr
@@ -14,6 +14,10 @@ error[E0080]: reading memory at ALLOC0[0x0..0x4], but memory is uninitialized at
    |
 LL | const BAD_UNINIT: pattern_type!(u32 is 1..) =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `BAD_UNINIT` failed here
+   |
+   = note: the raw bytes of the constant (size: 4, align: 4) {
+               __ __ __ __                                     │ ░░░░
+           }
 
 error[E0080]: unable to turn pointer into integer
   --> $DIR/validity.rs:17:1
@@ -51,6 +55,10 @@ error[E0080]: reading memory at ALLOC1[0x0..0x4], but memory is uninitialized at
    |
 LL | const CHAR_UNINIT: pattern_type!(char is 'A'..'Z') =
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation of `CHAR_UNINIT` failed here
+   |
+   = note: the raw bytes of the constant (size: 4, align: 4) {
+               __ __ __ __                                     │ ░░░░
+           }
 
 error[E0080]: constructing invalid value: encountered 97, but expected something in the range 65..=89
   --> $DIR/validity.rs:33:1
-- 
cgit 1.4.1-3-g733a5


From 8e840f726d013f824cc2e98aa54307f27295b34b Mon Sep 17 00:00:00 2001
From: Maksim Bondarenkov <maksapple2306@gmail.com>
Date: Fri, 18 Jul 2025 11:20:03 +0300
Subject: opt-dist: make llvm builds optional

adds command line option for disabling llvm builds. it's useful in case of user having their own
optimized LLVM, so they won't waste time for (at least) 3 LLVM builds. in this case PGO optimized
will be already built in Stage 1, so my previous PR should be addressed for this change
---
 src/tools/opt-dist/src/environment.rs |   5 ++
 src/tools/opt-dist/src/exec.rs        |  12 ++--
 src/tools/opt-dist/src/main.rs        | 122 ++++++++++++++++++++--------------
 src/tools/opt-dist/src/training.rs    |   4 +-
 4 files changed, 87 insertions(+), 56 deletions(-)

diff --git a/src/tools/opt-dist/src/environment.rs b/src/tools/opt-dist/src/environment.rs
index 946e926a3c0..d41dc80e6b2 100644
--- a/src/tools/opt-dist/src/environment.rs
+++ b/src/tools/opt-dist/src/environment.rs
@@ -27,6 +27,7 @@ pub struct Environment {
     shared_llvm: bool,
     run_tests: bool,
     fast_try_build: bool,
+    build_llvm: bool,
 }
 
 impl Environment {
@@ -111,6 +112,10 @@ impl Environment {
     pub fn is_fast_try_build(&self) -> bool {
         self.fast_try_build
     }
+
+    pub fn build_llvm(&self) -> bool {
+        self.build_llvm
+    }
 }
 
 /// What is the extension of binary executables on this platform?
diff --git a/src/tools/opt-dist/src/exec.rs b/src/tools/opt-dist/src/exec.rs
index 0dc6e56b9d5..56eff2ca2a7 100644
--- a/src/tools/opt-dist/src/exec.rs
+++ b/src/tools/opt-dist/src/exec.rs
@@ -139,8 +139,10 @@ impl Bootstrap {
         self
     }
 
-    pub fn llvm_pgo_optimize(mut self, profile: &LlvmPGOProfile) -> Self {
-        self.cmd = self.cmd.arg("--llvm-profile-use").arg(profile.0.as_str());
+    pub fn llvm_pgo_optimize(mut self, profile: Option<&LlvmPGOProfile>) -> Self {
+        if let Some(prof) = profile {
+            self.cmd = self.cmd.arg("--llvm-profile-use").arg(prof.0.as_str());
+        }
         self
     }
 
@@ -174,8 +176,10 @@ impl Bootstrap {
         self
     }
 
-    pub fn with_bolt_profile(mut self, profile: BoltProfile) -> Self {
-        self.cmd = self.cmd.arg("--reproducible-artifact").arg(profile.0.as_str());
+    pub fn with_bolt_profile(mut self, profile: Option<BoltProfile>) -> Self {
+        if let Some(prof) = profile {
+            self.cmd = self.cmd.arg("--reproducible-artifact").arg(prof.0.as_str());
+        }
         self
     }
 
diff --git a/src/tools/opt-dist/src/main.rs b/src/tools/opt-dist/src/main.rs
index 9c8a6637a3b..7857f196626 100644
--- a/src/tools/opt-dist/src/main.rs
+++ b/src/tools/opt-dist/src/main.rs
@@ -98,6 +98,10 @@ enum EnvironmentCmd {
         /// Perform tests after final build if it's not a fast try build
         #[arg(long)]
         run_tests: bool,
+
+        /// Will be LLVM built during the run?
+        #[arg(long, default_value_t = true, action(clap::ArgAction::Set))]
+        build_llvm: bool,
     },
     /// Perform an optimized build on Linux CI, from inside Docker.
     LinuxCi {
@@ -133,6 +137,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
             benchmark_cargo_config,
             shared,
             run_tests,
+            build_llvm,
         } => {
             let env = EnvironmentBuilder::default()
                 .host_tuple(target_triple)
@@ -148,6 +153,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
                 .benchmark_cargo_config(benchmark_cargo_config)
                 .run_tests(run_tests)
                 .fast_try_build(is_fast_try_build)
+                .build_llvm(build_llvm)
                 .build()?;
 
             (env, shared.build_args)
@@ -172,6 +178,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
                 .skipped_tests(vec![])
                 .run_tests(true)
                 .fast_try_build(is_fast_try_build)
+                .build_llvm(true)
                 .build()?;
 
             (env, shared.build_args)
@@ -193,6 +200,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
                 .skipped_tests(vec![])
                 .run_tests(true)
                 .fast_try_build(is_fast_try_build)
+                .build_llvm(true)
                 .build()?;
 
             (env, shared.build_args)
@@ -255,30 +263,35 @@ fn execute_pipeline(
     // Stage 2: Gather LLVM PGO profiles
     // Here we build a PGO instrumented LLVM, reusing the previously PGO optimized rustc.
     // Then we use the instrumented LLVM to gather LLVM PGO profiles.
-    let llvm_pgo_profile = timer.section("Stage 2 (LLVM PGO)", |stage| {
-        // Remove the previous, uninstrumented build of LLVM.
-        clear_llvm_files(env)?;
+    let llvm_pgo_profile = if env.build_llvm() {
+        timer.section("Stage 2 (LLVM PGO)", |stage| {
+            // Remove the previous, uninstrumented build of LLVM.
+            clear_llvm_files(env)?;
 
-        let llvm_profile_dir_root = env.artifact_dir().join("llvm-pgo");
+            let llvm_profile_dir_root = env.artifact_dir().join("llvm-pgo");
 
-        stage.section("Build PGO instrumented LLVM", |section| {
-            Bootstrap::build(env)
-                .llvm_pgo_instrument(&llvm_profile_dir_root)
-                .avoid_rustc_rebuild()
-                .run(section)
-        })?;
+            stage.section("Build PGO instrumented LLVM", |section| {
+                Bootstrap::build(env)
+                    .llvm_pgo_instrument(&llvm_profile_dir_root)
+                    .avoid_rustc_rebuild()
+                    .run(section)
+            })?;
 
-        let profile = stage
-            .section("Gather profiles", |_| gather_llvm_profiles(env, &llvm_profile_dir_root))?;
+            let profile = stage.section("Gather profiles", |_| {
+                gather_llvm_profiles(env, &llvm_profile_dir_root)
+            })?;
 
-        print_free_disk_space()?;
+            print_free_disk_space()?;
 
-        // Proactively delete the instrumented artifacts, to avoid using them by accident in
-        // follow-up stages.
-        clear_llvm_files(env)?;
+            // Proactively delete the instrumented artifacts, to avoid using them by accident in
+            // follow-up stages.
+            clear_llvm_files(env)?;
 
-        Ok(profile)
-    })?;
+            Ok(Some(profile))
+        })?
+    } else {
+        None
+    };
 
     let bolt_profiles = if env.use_bolt() {
         // Stage 3: Build BOLT instrumented LLVM
@@ -286,37 +299,43 @@ fn execute_pipeline(
         // Note that we don't remove LLVM artifacts after this step, so that they are reused in the final dist build.
         // BOLT instrumentation is performed "on-the-fly" when the LLVM library is copied to the sysroot of rustc,
         // therefore the LLVM artifacts on disk are not "tainted" with BOLT instrumentation and they can be reused.
+        let libdir = env.build_artifacts().join("stage2").join("lib");
         timer.section("Stage 3 (BOLT)", |stage| {
-            stage.section("Build PGO optimized LLVM", |stage| {
-                Bootstrap::build(env)
-                    .with_llvm_bolt_ldflags()
-                    .llvm_pgo_optimize(&llvm_pgo_profile)
-                    .avoid_rustc_rebuild()
-                    .run(stage)
-            })?;
-
-            let libdir = env.build_artifacts().join("stage2").join("lib");
-            // The actual name will be something like libLLVM.so.18.1-rust-dev.
-            let llvm_lib = io::find_file_in_dir(&libdir, "libLLVM.so", "")?;
-
-            log::info!("Optimizing {llvm_lib} with BOLT");
-
-            // FIXME(kobzol): try gather profiles together, at once for LLVM and rustc
-            // Instrument the libraries and gather profiles
-            let llvm_profile = with_bolt_instrumented(&llvm_lib, |llvm_profile_dir| {
-                stage.section("Gather profiles", |_| {
-                    gather_bolt_profiles(env, "LLVM", llvm_benchmarks(env), llvm_profile_dir)
-                })
-            })?;
-            print_free_disk_space()?;
-
-            // Now optimize the library with BOLT. The `libLLVM-XXX.so` library is actually hard-linked
-            // from several places, and this specific path (`llvm_lib`) will *not* be packaged into
-            // the final dist build. However, when BOLT optimizes an artifact, it does so *in-place*,
-            // therefore it will actually optimize all the hard links, which means that the final
-            // packaged `libLLVM.so` file *will* be BOLT optimized.
-            bolt_optimize(&llvm_lib, &llvm_profile, env)
-                .context("Could not optimize LLVM with BOLT")?;
+            let llvm_profile = if env.build_llvm() {
+                stage.section("Build PGO optimized LLVM", |stage| {
+                    Bootstrap::build(env)
+                        .with_llvm_bolt_ldflags()
+                        .llvm_pgo_optimize(llvm_pgo_profile.as_ref())
+                        .avoid_rustc_rebuild()
+                        .run(stage)
+                })?;
+
+                // The actual name will be something like libLLVM.so.18.1-rust-dev.
+                let llvm_lib = io::find_file_in_dir(&libdir, "libLLVM.so", "")?;
+
+                log::info!("Optimizing {llvm_lib} with BOLT");
+
+                // FIXME(kobzol): try gather profiles together, at once for LLVM and rustc
+                // Instrument the libraries and gather profiles
+                let llvm_profile = with_bolt_instrumented(&llvm_lib, |llvm_profile_dir| {
+                    stage.section("Gather profiles", |_| {
+                        gather_bolt_profiles(env, "LLVM", llvm_benchmarks(env), llvm_profile_dir)
+                    })
+                })?;
+                print_free_disk_space()?;
+
+                // Now optimize the library with BOLT. The `libLLVM-XXX.so` library is actually hard-linked
+                // from several places, and this specific path (`llvm_lib`) will *not* be packaged into
+                // the final dist build. However, when BOLT optimizes an artifact, it does so *in-place*,
+                // therefore it will actually optimize all the hard links, which means that the final
+                // packaged `libLLVM.so` file *will* be BOLT optimized.
+                bolt_optimize(&llvm_lib, &llvm_profile, env)
+                    .context("Could not optimize LLVM with BOLT")?;
+
+                Some(llvm_profile)
+            } else {
+                None
+            };
 
             let rustc_lib = io::find_file_in_dir(&libdir, "librustc_driver", ".so")?;
 
@@ -334,15 +353,16 @@ fn execute_pipeline(
             bolt_optimize(&rustc_lib, &rustc_profile, env)
                 .context("Could not optimize rustc with BOLT")?;
 
-            // LLVM is not being cleared here, we want to use the BOLT-optimized LLVM
-            Ok(vec![llvm_profile, rustc_profile])
+            // LLVM is not being cleared here. Either we built it and we want to use the BOLT-optimized LLVM, or we
+            // didn't build it, so we don't want to remove it.
+            Ok(vec![llvm_profile, Some(rustc_profile)])
         })?
     } else {
         vec![]
     };
 
     let mut dist = Bootstrap::dist(env, &dist_args)
-        .llvm_pgo_optimize(&llvm_pgo_profile)
+        .llvm_pgo_optimize(llvm_pgo_profile.as_ref())
         .rustc_pgo_optimize(&rustc_pgo_profile)
         .avoid_rustc_rebuild();
 
diff --git a/src/tools/opt-dist/src/training.rs b/src/tools/opt-dist/src/training.rs
index 36a7d6a7cba..ae062d5c60c 100644
--- a/src/tools/opt-dist/src/training.rs
+++ b/src/tools/opt-dist/src/training.rs
@@ -163,7 +163,9 @@ pub fn gather_rustc_profiles(
     let merged_profile = env.artifact_dir().join("rustc-pgo.profdata");
     log::info!("Merging Rustc PGO profiles to {merged_profile}");
 
-    merge_llvm_profiles(env, &merged_profile, profile_root, LlvmProfdata::Target)?;
+    let llvm_profdata = if env.build_llvm() { LlvmProfdata::Target } else { LlvmProfdata::Host };
+
+    merge_llvm_profiles(env, &merged_profile, profile_root, llvm_profdata)?;
     log_profile_stats("Rustc", &merged_profile, profile_root)?;
 
     // We don't need the individual .profraw files now that they have been merged
-- 
cgit 1.4.1-3-g733a5


From 24ea3e22d3e2e02ccf055a45cac3550457a7ae3d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 18 Jul 2025 09:40:58 +0200
Subject: make native-lib support compile-time-optional, and centralize cfg
 usage

---
 src/tools/miri/Cargo.toml                 | 15 ++++++++-------
 src/tools/miri/src/alloc/alloc_bytes.rs   |  9 ++-------
 src/tools/miri/src/alloc/mod.rs           | 28 +++++++++++++++++++++++++++-
 src/tools/miri/src/bin/miri.rs            |  7 ++++---
 src/tools/miri/src/lib.rs                 |  2 +-
 src/tools/miri/src/machine.rs             | 20 ++++++--------------
 src/tools/miri/src/shims/foreign_items.rs |  2 +-
 src/tools/miri/src/shims/mod.rs           |  4 ++--
 src/tools/miri/tests/ui.rs                |  2 +-
 9 files changed, 52 insertions(+), 37 deletions(-)

diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index 75476d7923c..0aff34e9fbe 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -38,14 +38,14 @@ features = ['unprefixed_malloc_on_supported_platforms']
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
-libffi = "4.0.0"
-libloading = "0.8"
+libffi = { version = "4.0.0", optional = true }
+libloading = { version = "0.8", optional = true }
+nix = { version = "0.30.1", features = ["mman", "ptrace", "signal"], optional = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]
-nix = { version = "0.30.1", features = ["mman", "ptrace", "signal"] }
-ipc-channel = "0.19.0"
-serde = { version = "1.0.219", features = ["derive"] }
-capstone = "0.13"
+ipc-channel = { version = "0.19.0", optional = true }
+serde = { version = "1.0.219", features = ["derive"], optional = true }
+capstone = { version = "0.13", optional = true }
 
 [dev-dependencies]
 ui_test = "0.29.1"
@@ -64,11 +64,12 @@ name = "ui"
 harness = false
 
 [features]
-default = ["stack-cache"]
+default = ["stack-cache", "native-lib"]
 genmc = []
 stack-cache = []
 stack-cache-consistency-check = ["stack-cache"]
 tracing = ["serde_json"]
+native-lib = ["dep:libffi", "dep:libloading", "dep:capstone", "dep:ipc-channel", "dep:nix", "dep:serde"]
 
 [lints.rust.unexpected_cfgs]
 level = "warn"
diff --git a/src/tools/miri/src/alloc/alloc_bytes.rs b/src/tools/miri/src/alloc/alloc_bytes.rs
index 2a253952b27..5d00d3eafcb 100644
--- a/src/tools/miri/src/alloc/alloc_bytes.rs
+++ b/src/tools/miri/src/alloc/alloc_bytes.rs
@@ -1,20 +1,18 @@
 use std::alloc::Layout;
 use std::borrow::Cow;
+use std::cell::RefCell;
+use std::rc::Rc;
 use std::{alloc, slice};
-#[cfg(target_os = "linux")]
-use std::{cell::RefCell, rc::Rc};
 
 use rustc_abi::{Align, Size};
 use rustc_middle::mir::interpret::AllocBytes;
 
-#[cfg(target_os = "linux")]
 use crate::alloc::isolated_alloc::IsolatedAlloc;
 use crate::helpers::ToU64 as _;
 
 #[derive(Clone, Debug)]
 pub enum MiriAllocParams {
     Global,
-    #[cfg(target_os = "linux")]
     Isolated(Rc<RefCell<IsolatedAlloc>>),
 }
 
@@ -56,7 +54,6 @@ impl Drop for MiriAllocBytes {
         unsafe {
             match self.params.clone() {
                 MiriAllocParams::Global => alloc::dealloc(self.ptr, alloc_layout),
-                #[cfg(target_os = "linux")]
                 MiriAllocParams::Isolated(alloc) =>
                     alloc.borrow_mut().dealloc(self.ptr, alloc_layout),
             }
@@ -123,7 +120,6 @@ impl AllocBytes for MiriAllocBytes {
         let alloc_fn = |layout, params: &MiriAllocParams| unsafe {
             match params {
                 MiriAllocParams::Global => alloc::alloc(layout),
-                #[cfg(target_os = "linux")]
                 MiriAllocParams::Isolated(alloc) => alloc.borrow_mut().alloc(layout),
             }
         };
@@ -144,7 +140,6 @@ impl AllocBytes for MiriAllocBytes {
         let alloc_fn = |layout, params: &MiriAllocParams| unsafe {
             match params {
                 MiriAllocParams::Global => alloc::alloc_zeroed(layout),
-                #[cfg(target_os = "linux")]
                 MiriAllocParams::Isolated(alloc) => alloc.borrow_mut().alloc_zeroed(layout),
             }
         };
diff --git a/src/tools/miri/src/alloc/mod.rs b/src/tools/miri/src/alloc/mod.rs
index 3be885920d2..35158f50a8f 100644
--- a/src/tools/miri/src/alloc/mod.rs
+++ b/src/tools/miri/src/alloc/mod.rs
@@ -1,5 +1,31 @@
 mod alloc_bytes;
-#[cfg(target_os = "linux")]
+#[cfg(all(unix, feature = "native-lib"))]
 pub mod isolated_alloc;
+#[cfg(not(all(unix, feature = "native-lib")))]
+pub mod isolated_alloc {
+    use std::alloc::Layout;
+
+    /// Stub allocator to avoid `cfg`s in the rest of Miri.
+    #[derive(Debug)]
+    pub struct IsolatedAlloc(!);
+
+    impl IsolatedAlloc {
+        pub fn new() -> Self {
+            unreachable!()
+        }
+
+        pub unsafe fn alloc(&mut self, _layout: Layout) -> *mut u8 {
+            match self.0 {}
+        }
+
+        pub unsafe fn alloc_zeroed(&mut self, _layout: Layout) -> *mut u8 {
+            match self.0 {}
+        }
+
+        pub unsafe fn dealloc(&mut self, _ptr: *mut u8, _layout: Layout) {
+            match self.0 {}
+        }
+    }
+}
 
 pub use self::alloc_bytes::{MiriAllocBytes, MiriAllocParams};
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index 61cebedf081..5d9c05807b8 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -335,9 +335,10 @@ impl rustc_driver::Callbacks for MiriBeRustCompilerCalls {
 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 code code.
-    #[cfg(target_os = "linux")]
+    // Make sure the supervisor knows about the exit code.
+    #[cfg(all(unix, feature = "native-lib"))]
     miri::native_lib::register_retcode_sv(exit_code);
+    // Actually exit.
     std::process::exit(exit_code);
 }
 
@@ -754,7 +755,7 @@ fn main() {
     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(target_os = "linux")]
+        #[cfg(all(unix, feature = "native-lib"))]
         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 a591d21071d..0f293c0d8f7 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -97,7 +97,7 @@ pub use rustc_const_eval::interpret::{self, AllocMap, Provenance as _};
 use rustc_middle::{bug, span_bug};
 use tracing::{info, trace};
 
-#[cfg(target_os = "linux")]
+#[cfg(all(unix, feature = "native-lib"))]
 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 9c077e5b7b6..bce0063c9ce 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -530,7 +530,6 @@ pub struct MiriMachine<'tcx> {
     pub(crate) rng: RefCell<StdRng>,
 
     /// The allocator used for the machine's `AllocBytes` in native-libs mode.
-    #[cfg(target_os = "linux")]
     pub(crate) allocator: Option<Rc<RefCell<crate::alloc::isolated_alloc::IsolatedAlloc>>>,
 
     /// The allocation IDs to report when they are being allocated
@@ -554,9 +553,9 @@ pub struct MiriMachine<'tcx> {
     pub(crate) basic_block_count: u64,
 
     /// Handle of the optional shared object file for native functions.
-    #[cfg(unix)]
+    #[cfg(all(unix, feature = "native-lib"))]
     pub native_lib: Vec<(libloading::Library, std::path::PathBuf)>,
-    #[cfg(not(unix))]
+    #[cfg(not(all(unix, feature = "native-lib")))]
     pub native_lib: Vec<!>,
 
     /// Run a garbage collector for BorTags every N basic blocks.
@@ -603,7 +602,7 @@ pub struct MiriMachine<'tcx> {
     /// Remembers whether we already warned about an extern type with Stacked Borrows.
     pub(crate) sb_extern_type_warned: Cell<bool>,
     /// Remember whether we already warned about sharing memory with a native call.
-    #[cfg(unix)]
+    #[allow(unused)]
     pub(crate) native_call_mem_warned: Cell<bool>,
     /// Remembers which shims have already shown the warning about erroring in isolation.
     pub(crate) reject_in_isolation_warned: RefCell<FxHashSet<String>>,
@@ -718,7 +717,6 @@ impl<'tcx> MiriMachine<'tcx> {
             local_crates,
             extern_statics: FxHashMap::default(),
             rng: RefCell::new(rng),
-            #[cfg(target_os = "linux")]
             allocator: if !config.native_lib.is_empty() {
                 Some(Rc::new(RefCell::new(crate::alloc::isolated_alloc::IsolatedAlloc::new())))
             } else { None },
@@ -730,7 +728,7 @@ impl<'tcx> MiriMachine<'tcx> {
             report_progress: config.report_progress,
             basic_block_count: 0,
             monotonic_clock: MonotonicClock::new(config.isolated_op == IsolatedOp::Allow),
-            #[cfg(unix)]
+            #[cfg(all(unix, feature = "native-lib"))]
             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();
@@ -752,9 +750,9 @@ impl<'tcx> MiriMachine<'tcx> {
                     lib_file_path.clone(),
                 )
             }).collect(),
-            #[cfg(not(unix))]
+            #[cfg(not(all(unix, feature = "native-lib")))]
             native_lib: config.native_lib.iter().map(|_| {
-                panic!("calling functions from native libraries via FFI is only supported on Unix")
+                panic!("calling functions from native libraries via FFI is not supported in this build of Miri")
             }).collect(),
             gc_interval: config.gc_interval,
             since_gc: 0,
@@ -771,7 +769,6 @@ impl<'tcx> MiriMachine<'tcx> {
             pthread_rwlock_sanity: Cell::new(false),
             pthread_condvar_sanity: Cell::new(false),
             sb_extern_type_warned: Cell::new(false),
-            #[cfg(unix)]
             native_call_mem_warned: Cell::new(false),
             reject_in_isolation_warned: Default::default(),
             int2ptr_warned: Default::default(),
@@ -924,7 +921,6 @@ impl VisitProvenance for MiriMachine<'_> {
             backtrace_style: _,
             local_crates: _,
             rng: _,
-            #[cfg(target_os = "linux")]
             allocator: _,
             tracked_alloc_ids: _,
             track_alloc_accesses: _,
@@ -949,7 +945,6 @@ impl VisitProvenance for MiriMachine<'_> {
             pthread_rwlock_sanity: _,
             pthread_condvar_sanity: _,
             sb_extern_type_warned: _,
-            #[cfg(unix)]
             native_call_mem_warned: _,
             reject_in_isolation_warned: _,
             int2ptr_warned: _,
@@ -1817,13 +1812,10 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
     fn get_default_alloc_params(&self) -> <Self::Bytes as AllocBytes>::AllocParams {
         use crate::alloc::MiriAllocParams;
 
-        #[cfg(target_os = "linux")]
         match &self.allocator {
             Some(alloc) => MiriAllocParams::Isolated(alloc.clone()),
             None => MiriAllocParams::Global,
         }
-        #[cfg(not(target_os = "linux"))]
-        MiriAllocParams::Global
     }
 
     fn enter_trace_span(span: impl FnOnce() -> tracing::Span) -> impl EnteredTraceSpan {
diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index 9ddba8c2b48..94cda57658a 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -237,7 +237,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let this = self.eval_context_mut();
 
         // First deal with any external C functions in linked .so file.
-        #[cfg(unix)]
+        #[cfg(all(unix, feature = "native-lib"))]
         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 75540f6f150..2a7709829ee 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -4,7 +4,7 @@ mod aarch64;
 mod alloc;
 mod backtrace;
 mod files;
-#[cfg(unix)]
+#[cfg(all(unix, feature = "native-lib"))]
 mod native_lib;
 mod unix;
 mod wasi;
@@ -23,7 +23,7 @@ pub mod tls;
 pub mod unwind;
 
 pub use self::files::FdTable;
-#[cfg(target_os = "linux")]
+#[cfg(all(unix, feature = "native-lib"))]
 pub use self::native_lib::trace::{init_sv, register_retcode_sv};
 pub use self::unix::{DirTable, EpollInterestTable};
 
diff --git a/src/tools/miri/tests/ui.rs b/src/tools/miri/tests/ui.rs
index 43f855d57dd..e521269586d 100644
--- a/src/tools/miri/tests/ui.rs
+++ b/src/tools/miri/tests/ui.rs
@@ -335,7 +335,7 @@ fn main() -> Result<()> {
     ui(Mode::Panic, "tests/panic", &target, WithDependencies, tmpdir.path())?;
     ui(Mode::Fail, "tests/fail", &target, WithoutDependencies, tmpdir.path())?;
     ui(Mode::Fail, "tests/fail-dep", &target, WithDependencies, tmpdir.path())?;
-    if cfg!(unix) && target == host {
+    if cfg!(all(unix, feature = "native-lib")) && target == host {
         ui(Mode::Pass, "tests/native-lib/pass", &target, WithoutDependencies, tmpdir.path())?;
         ui(Mode::Fail, "tests/native-lib/fail", &target, WithoutDependencies, tmpdir.path())?;
     }
-- 
cgit 1.4.1-3-g733a5


From cc6bc7af2336923e1f1f0e9620e1ce426e5efe4f Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 18 Jul 2025 10:09:49 +0200
Subject: RA config: disable default features for faster build script build

---
 src/tools/miri/etc/rust_analyzer_helix.toml  | 1 +
 src/tools/miri/etc/rust_analyzer_vscode.json | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/tools/miri/etc/rust_analyzer_helix.toml b/src/tools/miri/etc/rust_analyzer_helix.toml
index 9bfb09120d8..91e4070478c 100644
--- a/src/tools/miri/etc/rust_analyzer_helix.toml
+++ b/src/tools/miri/etc/rust_analyzer_helix.toml
@@ -26,5 +26,6 @@ invocationStrategy = "once"
 overrideCommand = [
     "./miri",
     "check",
+    "--no-default-features",
     "--message-format=json",
 ]
diff --git a/src/tools/miri/etc/rust_analyzer_vscode.json b/src/tools/miri/etc/rust_analyzer_vscode.json
index c646953e92b..6917c6a1fd8 100644
--- a/src/tools/miri/etc/rust_analyzer_vscode.json
+++ b/src/tools/miri/etc/rust_analyzer_vscode.json
@@ -20,6 +20,7 @@
     "rust-analyzer.cargo.buildScripts.overrideCommand": [
         "./miri",
         "check",
+        "--no-default-features",
         "--message-format=json",
     ],
 }
-- 
cgit 1.4.1-3-g733a5


From 84ed70b69daa6865d3713d36fabad90a2fb96afd Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Fri, 20 Jun 2025 21:39:19 +0200
Subject: Reword diagnostics about relaxed bounds in invalid contexts

---
 compiler/rustc_ast_lowering/src/lib.rs             | 26 ++++++--
 .../missing-associated_item_or_field_def_ids.rs    |  2 +-
 ...missing-associated_item_or_field_def_ids.stderr |  8 +--
 ...-getting-associated-items-of-undefined-trait.rs |  2 +-
 ...ting-associated-items-of-undefined-trait.stderr |  8 +--
 .../feature-gate-more-maybe-bounds.rs              |  8 +--
 .../feature-gate-more-maybe-bounds.stderr          | 34 ++++-------
 tests/ui/parser/trait-object-trait-parens.rs       |  6 +-
 tests/ui/parser/trait-object-trait-parens.stderr   | 18 ++----
 tests/ui/sized-hierarchy/default-supertrait.rs     |  6 +-
 tests/ui/sized-hierarchy/default-supertrait.stderr | 17 ++----
 .../maybe-trait-bounds-forbidden-locations.rs      | 18 ------
 .../maybe-trait-bounds-forbidden-locations.stderr  | 31 ----------
 tests/ui/traits/wf-object/maybe-bound.rs           | 18 ------
 tests/ui/traits/wf-object/maybe-bound.stderr       | 48 ---------------
 tests/ui/traits/wf-object/only-maybe-bound.rs      |  2 +-
 tests/ui/traits/wf-object/only-maybe-bound.stderr  |  8 +--
 tests/ui/unsized/relaxed-bounds-invalid-places.rs  | 35 ++++++-----
 .../unsized/relaxed-bounds-invalid-places.stderr   | 70 ++++++++++++++--------
 19 files changed, 125 insertions(+), 240 deletions(-)
 delete mode 100644 tests/ui/traits/maybe-trait-bounds-forbidden-locations.rs
 delete mode 100644 tests/ui/traits/maybe-trait-bounds-forbidden-locations.stderr
 delete mode 100644 tests/ui/traits/wf-object/maybe-bound.rs
 delete mode 100644 tests/ui/traits/wf-object/maybe-bound.stderr

diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index d3d521e83b0..533ee9bff54 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -60,7 +60,7 @@ use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::extension;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
-use rustc_session::parse::{add_feature_diagnostics, feature_err};
+use rustc_session::parse::add_feature_diagnostics;
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
 use rustc_span::{DUMMY_SP, DesugaringKind, Span};
 use smallvec::SmallVec;
@@ -2071,7 +2071,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         span: Span,
         rbp: RelaxedBoundPolicy<'_>,
     ) {
-        let err = |message| feature_err(&self.tcx.sess, sym::more_maybe_bounds, span, message);
+        // Even though feature `more_maybe_bounds` bypasses the given policy and (currently) enables
+        // relaxed bounds in every conceivable position[^1], we don't want to advertise it to the user
+        // (via a feature gate) since it's super internal. Besides this, it'd be quite distracting.
+        //
+        // [^1]: Strictly speaking, this is incorrect (at the very least for `Sized`) because it's
+        //       no longer fully consistent with default trait elaboration in HIR ty lowering.
 
         match rbp {
             RelaxedBoundPolicy::Allowed => return,
@@ -2093,11 +2098,17 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                 match reason {
                     RelaxedBoundForbiddenReason::TraitObjectTy => {
-                        err("`?Trait` is not permitted in trait object types").emit();
+                        self.dcx().span_err(
+                            span,
+                            "relaxed bounds are not permitted in trait object types",
+                        );
                         return;
                     }
                     RelaxedBoundForbiddenReason::SuperTrait => {
-                        let mut diag = err("`?Trait` is not permitted in supertraits");
+                        let mut diag = self.dcx().struct_span_err(
+                            span,
+                            "relaxed bounds are not permitted in supertrait bounds",
+                        );
                         if let Some(def_id) = trait_ref.trait_def_id()
                             && self.tcx.is_lang_item(def_id, hir::LangItem::Sized)
                         {
@@ -2111,7 +2122,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             }
         }
 
-        err("`?Trait` bounds are only permitted at the point where a type parameter is declared")
+        self.dcx()
+            .struct_span_err(span, "this relaxed bound is not permitted here")
+            .with_note(
+                "in this context, relaxed bounds are only allowed on \
+                 type parameters defined by the closest item",
+            )
             .emit();
     }
 
diff --git a/tests/ui/associated-item/missing-associated_item_or_field_def_ids.rs b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.rs
index 18c71e5c744..029ce7d0e7e 100644
--- a/tests/ui/associated-item/missing-associated_item_or_field_def_ids.rs
+++ b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.rs
@@ -2,6 +2,6 @@
 
 fn main() -> dyn Iterator + ?Iterator::advance_by(usize) {
     //~^ ERROR expected trait, found associated function `Iterator::advance_by`
-    //~| ERROR `?Trait` is not permitted in trait object types
+    //~| ERROR relaxed bounds are not permitted in trait object types
     todo!()
 }
diff --git a/tests/ui/associated-item/missing-associated_item_or_field_def_ids.stderr b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.stderr
index 6ec8e01c78d..ffe0b14a030 100644
--- a/tests/ui/associated-item/missing-associated_item_or_field_def_ids.stderr
+++ b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.stderr
@@ -4,16 +4,12 @@ error[E0404]: expected trait, found associated function `Iterator::advance_by`
 LL | fn main() -> dyn Iterator + ?Iterator::advance_by(usize) {
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a trait
 
-error[E0658]: `?Trait` is not permitted in trait object types
+error: relaxed bounds are not permitted in trait object types
   --> $DIR/missing-associated_item_or_field_def_ids.rs:3:29
    |
 LL | fn main() -> dyn Iterator + ?Iterator::advance_by(usize) {
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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
 
-Some errors have detailed explanations: E0404, E0658.
-For more information about an error, try `rustc --explain E0404`.
+For more information about this error, try `rustc --explain E0404`.
diff --git a/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.rs b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.rs
index 9e0a86abb2e..bac4e608867 100644
--- a/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.rs
+++ b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.rs
@@ -7,5 +7,5 @@ trait Tr {
 fn main() {
     let _: dyn Tr + ?Foo<Assoc = ()>;
     //~^ ERROR: cannot find trait `Foo` in this scope
-    //~| ERROR: `?Trait` is not permitted in trait object types
+    //~| ERROR: relaxed bounds are not permitted in trait object types
 }
diff --git a/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.stderr b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.stderr
index bd83c1a9ea8..3660fcece62 100644
--- a/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.stderr
+++ b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.stderr
@@ -4,16 +4,12 @@ error[E0405]: cannot find trait `Foo` in this scope
 LL |     let _: dyn Tr + ?Foo<Assoc = ()>;
    |                      ^^^ not found in this scope
 
-error[E0658]: `?Trait` is not permitted in trait object types
+error: relaxed bounds are not permitted in trait object types
   --> $DIR/avoid-getting-associated-items-of-undefined-trait.rs:8:21
    |
 LL |     let _: dyn Tr + ?Foo<Assoc = ()>;
    |                     ^^^^^^^^^^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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
 
-Some errors have detailed explanations: E0405, E0658.
-For more information about an error, try `rustc --explain E0405`.
+For more information about this error, try `rustc --explain E0405`.
diff --git a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs
index 6a832744e3e..3066967f87e 100644
--- a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs
+++ b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs
@@ -2,13 +2,11 @@
 
 trait Trait1 {}
 auto trait Trait2 {}
-trait Trait3: ?Trait1 {}
-//~^  ERROR `?Trait` is not permitted in supertraits
-trait Trait4 where Self: ?Trait1 {}
-//~^ ERROR ?Trait` bounds are only permitted at the point where a type parameter is declared
+trait Trait3: ?Trait1 {} //~ ERROR relaxed bounds are not permitted in supertrait bounds
+trait Trait4 where Self: ?Trait1 {} //~ ERROR this relaxed bound is not permitted here
 
 fn foo(_: Box<dyn Trait1 + ?Trait2>) {}
-//~^  ERROR `?Trait` is not permitted in trait object types
+//~^  ERROR relaxed bounds are not permitted in trait object types
 fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
 //~^ ERROR type parameter has more than one relaxed default bound, only one is supported
 //~| ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
diff --git a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
index f52532a035b..35b5b80d69e 100644
--- a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
+++ b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
@@ -1,32 +1,25 @@
-error[E0658]: `?Trait` is not permitted in supertraits
+error: relaxed bounds are not permitted in supertrait bounds
   --> $DIR/feature-gate-more-maybe-bounds.rs:5:15
    |
 LL | trait Trait3: ?Trait1 {}
    |               ^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` bounds are only permitted at the point where a type parameter is declared
-  --> $DIR/feature-gate-more-maybe-bounds.rs:7:26
+error: this relaxed bound is not permitted here
+  --> $DIR/feature-gate-more-maybe-bounds.rs:6:26
    |
 LL | trait Trait4 where Self: ?Trait1 {}
    |                          ^^^^^^^
    |
-   = help: add `#![feature(more_maybe_bounds)]` 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: in this context, relaxed bounds are only allowed on type parameters defined by the closest item
 
-error[E0658]: `?Trait` is not permitted in trait object types
-  --> $DIR/feature-gate-more-maybe-bounds.rs:10:28
+error: relaxed bounds are not permitted in trait object types
+  --> $DIR/feature-gate-more-maybe-bounds.rs:8:28
    |
 LL | fn foo(_: Box<dyn Trait1 + ?Trait2>) {}
    |                            ^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/feature-gate-more-maybe-bounds.rs:12:11
+  --> $DIR/feature-gate-more-maybe-bounds.rs:10:11
    |
 LL | fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
    |           ^^^^^^^   ^^^^^^^
@@ -35,36 +28,35 @@ LL | fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/feature-gate-more-maybe-bounds.rs:12:11
+  --> $DIR/feature-gate-more-maybe-bounds.rs:10:11
    |
 LL | fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
    |           ^^^^^^^
 
 error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/feature-gate-more-maybe-bounds.rs:12:21
+  --> $DIR/feature-gate-more-maybe-bounds.rs:10:21
    |
 LL | fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
    |                     ^^^^^^^
 
 error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/feature-gate-more-maybe-bounds.rs:19:11
+  --> $DIR/feature-gate-more-maybe-bounds.rs:17:11
    |
 LL | fn baz<T: ?Trait + ?Trait>(_ : T) {}
    |           ^^^^^^   ^^^^^^
 
 error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/feature-gate-more-maybe-bounds.rs:19:11
+  --> $DIR/feature-gate-more-maybe-bounds.rs:17:11
    |
 LL | fn baz<T: ?Trait + ?Trait>(_ : T) {}
    |           ^^^^^^
 
 error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/feature-gate-more-maybe-bounds.rs:19:20
+  --> $DIR/feature-gate-more-maybe-bounds.rs:17:20
    |
 LL | fn baz<T: ?Trait + ?Trait>(_ : T) {}
    |                    ^^^^^^
 
 error: aborting due to 9 previous errors
 
-Some errors have detailed explanations: E0203, E0658.
-For more information about an error, try `rustc --explain E0203`.
+For more information about this error, try `rustc --explain E0203`.
diff --git a/tests/ui/parser/trait-object-trait-parens.rs b/tests/ui/parser/trait-object-trait-parens.rs
index 438034bc38a..51f0e2de611 100644
--- a/tests/ui/parser/trait-object-trait-parens.rs
+++ b/tests/ui/parser/trait-object-trait-parens.rs
@@ -6,17 +6,17 @@ fn f<T: (Copy) + (?Sized) + (for<'a> Trait<'a>)>() {}
 
 fn main() {
     let _: Box<(Obj) + (?Sized) + (for<'a> Trait<'a>)>;
-    //~^ ERROR `?Trait` is not permitted in trait object types
+    //~^ ERROR relaxed bounds are not permitted in trait object types
     //~| ERROR only auto traits can be used as additional traits
     //~| WARN trait objects without an explicit `dyn` are deprecated
     //~| WARN this is accepted in the current edition
     let _: Box<?Sized + (for<'a> Trait<'a>) + (Obj)>;
-    //~^ ERROR `?Trait` is not permitted in trait object types
+    //~^ ERROR relaxed bounds are not permitted in trait object types
     //~| ERROR only auto traits can be used as additional traits
     //~| WARN trait objects without an explicit `dyn` are deprecated
     //~| WARN this is accepted in the current edition
     let _: Box<for<'a> Trait<'a> + (Obj) + (?Sized)>;
-    //~^ ERROR `?Trait` is not permitted in trait object types
+    //~^ ERROR relaxed bounds are not permitted in trait object types
     //~| ERROR only auto traits can be used as additional traits
     //~| WARN trait objects without an explicit `dyn` are deprecated
     //~| WARN this is accepted in the current edition
diff --git a/tests/ui/parser/trait-object-trait-parens.stderr b/tests/ui/parser/trait-object-trait-parens.stderr
index d75352b6811..26d388f8779 100644
--- a/tests/ui/parser/trait-object-trait-parens.stderr
+++ b/tests/ui/parser/trait-object-trait-parens.stderr
@@ -1,29 +1,20 @@
-error[E0658]: `?Trait` is not permitted in trait object types
+error: relaxed bounds are not permitted in trait object types
   --> $DIR/trait-object-trait-parens.rs:8:24
    |
 LL |     let _: Box<(Obj) + (?Sized) + (for<'a> Trait<'a>)>;
    |                        ^^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` is not permitted in trait object types
+error: relaxed bounds are not permitted in trait object types
   --> $DIR/trait-object-trait-parens.rs:13:16
    |
 LL |     let _: Box<?Sized + (for<'a> Trait<'a>) + (Obj)>;
    |                ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` is not permitted in trait object types
+error: relaxed bounds are not permitted in trait object types
   --> $DIR/trait-object-trait-parens.rs:18:44
    |
 LL |     let _: Box<for<'a> Trait<'a> + (Obj) + (?Sized)>;
    |                                            ^^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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: trait objects without an explicit `dyn` are deprecated
   --> $DIR/trait-object-trait-parens.rs:8:16
@@ -100,5 +91,4 @@ LL |     let _: Box<for<'a> Trait<'a> + (Obj) + (?Sized)>;
 
 error: aborting due to 6 previous errors; 3 warnings emitted
 
-Some errors have detailed explanations: E0225, E0658.
-For more information about an error, try `rustc --explain E0225`.
+For more information about this error, try `rustc --explain E0225`.
diff --git a/tests/ui/sized-hierarchy/default-supertrait.rs b/tests/ui/sized-hierarchy/default-supertrait.rs
index b25acf9e6ea..ab3b28e84db 100644
--- a/tests/ui/sized-hierarchy/default-supertrait.rs
+++ b/tests/ui/sized-hierarchy/default-supertrait.rs
@@ -6,18 +6,18 @@ use std::marker::{MetaSized, PointeeSized};
 trait Sized_: Sized { }
 
 trait NegSized: ?Sized { }
-//~^ ERROR `?Trait` is not permitted in supertraits
+//~^ ERROR relaxed bounds are not permitted in supertrait bounds
 
 trait MetaSized_: MetaSized { }
 
 trait NegMetaSized: ?MetaSized { }
-//~^ ERROR `?Trait` is not permitted in supertraits
+//~^ ERROR relaxed bounds are not permitted in supertrait bounds
 
 
 trait PointeeSized_: PointeeSized { }
 
 trait NegPointeeSized: ?PointeeSized { }
-//~^ ERROR `?Trait` is not permitted in supertraits
+//~^ ERROR relaxed bounds are not permitted in supertrait bounds
 
 trait Bare {}
 
diff --git a/tests/ui/sized-hierarchy/default-supertrait.stderr b/tests/ui/sized-hierarchy/default-supertrait.stderr
index 0cb4f346a63..f5589d6e279 100644
--- a/tests/ui/sized-hierarchy/default-supertrait.stderr
+++ b/tests/ui/sized-hierarchy/default-supertrait.stderr
@@ -1,30 +1,22 @@
-error[E0658]: `?Trait` is not permitted in supertraits
+error: relaxed bounds are not permitted in supertrait bounds
   --> $DIR/default-supertrait.rs:8:17
    |
 LL | trait NegSized: ?Sized { }
    |                 ^^^^^^
    |
-   = help: add `#![feature(more_maybe_bounds)]` 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: traits are `?Sized` by default
 
-error[E0658]: `?Trait` is not permitted in supertraits
+error: relaxed bounds are not permitted in supertrait bounds
   --> $DIR/default-supertrait.rs:13:21
    |
 LL | trait NegMetaSized: ?MetaSized { }
    |                     ^^^^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` is not permitted in supertraits
+error: relaxed bounds are not permitted in supertrait bounds
   --> $DIR/default-supertrait.rs:19:24
    |
 LL | trait NegPointeeSized: ?PointeeSized { }
    |                        ^^^^^^^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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 size for values of type `T` cannot be known
   --> $DIR/default-supertrait.rs:52:38
@@ -119,5 +111,4 @@ LL | fn with_bare_trait<T: PointeeSized + Bare + std::marker::MetaSized>() {
 
 error: aborting due to 9 previous errors
 
-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`.
diff --git a/tests/ui/traits/maybe-trait-bounds-forbidden-locations.rs b/tests/ui/traits/maybe-trait-bounds-forbidden-locations.rs
deleted file mode 100644
index 04963c98765..00000000000
--- a/tests/ui/traits/maybe-trait-bounds-forbidden-locations.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//! Test that ?Trait bounds are forbidden in supertraits and trait object types.
-//!
-//! While `?Sized` and other maybe bounds are allowed in type parameter bounds and where clauses,
-//! they are explicitly forbidden in certain syntactic positions:
-//! - As supertraits in trait definitions
-//! - In trait object type expressions
-//!
-//! See https://github.com/rust-lang/rust/issues/20503
-
-trait Tr: ?Sized {}
-//~^ ERROR `?Trait` is not permitted in supertraits
-
-type A1 = dyn Tr + (?Sized);
-//~^ ERROR `?Trait` is not permitted in trait object types
-type A2 = dyn for<'a> Tr + (?Sized);
-//~^ ERROR `?Trait` is not permitted in trait object types
-
-fn main() {}
diff --git a/tests/ui/traits/maybe-trait-bounds-forbidden-locations.stderr b/tests/ui/traits/maybe-trait-bounds-forbidden-locations.stderr
deleted file mode 100644
index 5c4100d0e26..00000000000
--- a/tests/ui/traits/maybe-trait-bounds-forbidden-locations.stderr
+++ /dev/null
@@ -1,31 +0,0 @@
-error[E0658]: `?Trait` is not permitted in supertraits
-  --> $DIR/maybe-trait-bounds-forbidden-locations.rs:10:11
-   |
-LL | trait Tr: ?Sized {}
-   |           ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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: traits are `?Sized` by default
-
-error[E0658]: `?Trait` is not permitted in trait object types
-  --> $DIR/maybe-trait-bounds-forbidden-locations.rs:13:20
-   |
-LL | type A1 = dyn Tr + (?Sized);
-   |                    ^^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` is not permitted in trait object types
-  --> $DIR/maybe-trait-bounds-forbidden-locations.rs:15:28
-   |
-LL | type A2 = dyn for<'a> Tr + (?Sized);
-   |                            ^^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/traits/wf-object/maybe-bound.rs b/tests/ui/traits/wf-object/maybe-bound.rs
deleted file mode 100644
index 17771e976ef..00000000000
--- a/tests/ui/traits/wf-object/maybe-bound.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Test that `dyn ... + ?Sized + ...` is okay (though `?Sized` has no effect in trait objects).
-
-trait Foo {}
-
-type _0 = dyn ?Sized + Foo;
-//~^ ERROR `?Trait` is not permitted in trait object types
-
-type _1 = dyn Foo + ?Sized;
-//~^ ERROR `?Trait` is not permitted in trait object types
-
-type _2 = dyn Foo + ?Sized + ?Sized;
-//~^ ERROR `?Trait` is not permitted in trait object types
-//~| ERROR `?Trait` is not permitted in trait object types
-
-type _3 = dyn ?Sized + Foo;
-//~^ ERROR `?Trait` is not permitted in trait object types
-
-fn main() {}
diff --git a/tests/ui/traits/wf-object/maybe-bound.stderr b/tests/ui/traits/wf-object/maybe-bound.stderr
deleted file mode 100644
index be7afabd0d0..00000000000
--- a/tests/ui/traits/wf-object/maybe-bound.stderr
+++ /dev/null
@@ -1,48 +0,0 @@
-error[E0658]: `?Trait` is not permitted in trait object types
-  --> $DIR/maybe-bound.rs:5:15
-   |
-LL | type _0 = dyn ?Sized + Foo;
-   |               ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` is not permitted in trait object types
-  --> $DIR/maybe-bound.rs:8:21
-   |
-LL | type _1 = dyn Foo + ?Sized;
-   |                     ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` is not permitted in trait object types
-  --> $DIR/maybe-bound.rs:11:21
-   |
-LL | type _2 = dyn Foo + ?Sized + ?Sized;
-   |                     ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` is not permitted in trait object types
-  --> $DIR/maybe-bound.rs:11:30
-   |
-LL | type _2 = dyn Foo + ?Sized + ?Sized;
-   |                              ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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]: `?Trait` is not permitted in trait object types
-  --> $DIR/maybe-bound.rs:15:15
-   |
-LL | type _3 = dyn ?Sized + Foo;
-   |               ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/traits/wf-object/only-maybe-bound.rs b/tests/ui/traits/wf-object/only-maybe-bound.rs
index 3e6db3e997c..96360e0331c 100644
--- a/tests/ui/traits/wf-object/only-maybe-bound.rs
+++ b/tests/ui/traits/wf-object/only-maybe-bound.rs
@@ -2,6 +2,6 @@
 
 type _0 = dyn ?Sized;
 //~^ ERROR at least one trait is required for an object type [E0224]
-//~| ERROR ?Trait` is not permitted in trait object types
+//~| ERROR relaxed bounds are not permitted in trait object types
 
 fn main() {}
diff --git a/tests/ui/traits/wf-object/only-maybe-bound.stderr b/tests/ui/traits/wf-object/only-maybe-bound.stderr
index 26269476eaa..6ae4568c699 100644
--- a/tests/ui/traits/wf-object/only-maybe-bound.stderr
+++ b/tests/ui/traits/wf-object/only-maybe-bound.stderr
@@ -1,11 +1,8 @@
-error[E0658]: `?Trait` is not permitted in trait object types
+error: relaxed bounds are not permitted in trait object types
   --> $DIR/only-maybe-bound.rs:3:15
    |
 LL | type _0 = dyn ?Sized;
    |               ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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[E0224]: at least one trait is required for an object type
   --> $DIR/only-maybe-bound.rs:3:11
@@ -15,5 +12,4 @@ LL | type _0 = dyn ?Sized;
 
 error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0224, E0658.
-For more information about an error, try `rustc --explain E0224`.
+For more information about this error, try `rustc --explain E0224`.
diff --git a/tests/ui/unsized/relaxed-bounds-invalid-places.rs b/tests/ui/unsized/relaxed-bounds-invalid-places.rs
index ce3f35608be..e9f39d5f211 100644
--- a/tests/ui/unsized/relaxed-bounds-invalid-places.rs
+++ b/tests/ui/unsized/relaxed-bounds-invalid-places.rs
@@ -1,19 +1,18 @@
-// Test that relaxed bounds can only be placed on type parameters defined by the closest item
-// (ignoring relaxed bounds inside `impl Trait` and in associated type defs here).
+// Test various places where relaxed bounds are not permitted.
+//
+// Relaxed bounds are only permitted inside impl-Trait, assoc ty item bounds and
+// on type params defined by the closest item.
 
-struct S1<T>(T) where (T): ?Sized;
-//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
+struct S1<T>(T) where (T): ?Sized; //~ ERROR this relaxed bound is not permitted here
 
-struct S2<T>(T) where u8: ?Sized;
-//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
+struct S2<T>(T) where u8: ?Sized; //~ ERROR this relaxed bound is not permitted here
 
-struct S3<T>(T) where &'static T: ?Sized;
-//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
+struct S3<T>(T) where &'static T: ?Sized; //~ ERROR this relaxed bound is not permitted here
 
 trait Trait<'a> {}
 
 struct S4<T>(T) where for<'a> T: ?Trait<'a>;
-//~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
+//~^ ERROR this relaxed bound is not permitted here
 //~| ERROR relaxing a default bound only does something for `?Sized`
 
 struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
@@ -21,11 +20,17 @@ struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
 //~| ERROR relaxing a default bound only does something for `?Sized`
 
 impl<T> S1<T> {
-    fn f() where T: ?Sized {}
-    //~^ ERROR `?Trait` bounds are only permitted at the point where a type parameter is declared
+    fn f() where T: ?Sized {} //~ ERROR this relaxed bound is not permitted here
 }
 
-fn main() {
-    let u = vec![1, 2, 3];
-    let _s: S5<[u8]> = S5(&u[..]); // OK
-}
+trait Tr: ?Sized {} //~ ERROR relaxed bounds are not permitted in supertrait bounds
+
+// Test that relaxed `Sized` bounds are rejected in trait object types:
+
+type O1 = dyn Tr + ?Sized; //~ ERROR relaxed bounds are not permitted in trait object types
+type O2 = dyn ?Sized + ?Sized + Tr;
+//~^ ERROR relaxed bounds are not permitted in trait object types
+//~| ERROR relaxed bounds are not permitted in trait object types
+
+fn main() {}
+
diff --git a/tests/ui/unsized/relaxed-bounds-invalid-places.stderr b/tests/ui/unsized/relaxed-bounds-invalid-places.stderr
index 3287eb8d1e9..a08dc15058a 100644
--- a/tests/ui/unsized/relaxed-bounds-invalid-places.stderr
+++ b/tests/ui/unsized/relaxed-bounds-invalid-places.stderr
@@ -1,56 +1,77 @@
-error[E0658]: `?Trait` bounds are only permitted at the point where a type parameter is declared
-  --> $DIR/relaxed-bounds-invalid-places.rs:4:28
+error: this relaxed bound is not permitted here
+  --> $DIR/relaxed-bounds-invalid-places.rs:6:28
    |
 LL | struct S1<T>(T) where (T): ?Sized;
    |                            ^^^^^^
    |
-   = help: add `#![feature(more_maybe_bounds)]` 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: in this context, relaxed bounds are only allowed on type parameters defined by the closest item
 
-error[E0658]: `?Trait` bounds are only permitted at the point where a type parameter is declared
-  --> $DIR/relaxed-bounds-invalid-places.rs:7:27
+error: this relaxed bound is not permitted here
+  --> $DIR/relaxed-bounds-invalid-places.rs:8:27
    |
 LL | struct S2<T>(T) where u8: ?Sized;
    |                           ^^^^^^
    |
-   = help: add `#![feature(more_maybe_bounds)]` 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: in this context, relaxed bounds are only allowed on type parameters defined by the closest item
 
-error[E0658]: `?Trait` bounds are only permitted at the point where a type parameter is declared
+error: this relaxed bound is not permitted here
   --> $DIR/relaxed-bounds-invalid-places.rs:10:35
    |
 LL | struct S3<T>(T) where &'static T: ?Sized;
    |                                   ^^^^^^
    |
-   = help: add `#![feature(more_maybe_bounds)]` 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: in this context, relaxed bounds are only allowed on type parameters defined by the closest item
 
-error[E0658]: `?Trait` bounds are only permitted at the point where a type parameter is declared
-  --> $DIR/relaxed-bounds-invalid-places.rs:15:34
+error: this relaxed bound is not permitted here
+  --> $DIR/relaxed-bounds-invalid-places.rs:14:34
    |
 LL | struct S4<T>(T) where for<'a> T: ?Trait<'a>;
    |                                  ^^^^^^^^^^
    |
-   = help: add `#![feature(more_maybe_bounds)]` 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: in this context, relaxed bounds are only allowed on type parameters defined by the closest item
 
-error[E0658]: `?Trait` bounds are only permitted at the point where a type parameter is declared
-  --> $DIR/relaxed-bounds-invalid-places.rs:24:21
+error: this relaxed bound is not permitted here
+  --> $DIR/relaxed-bounds-invalid-places.rs:23:21
    |
 LL |     fn f() where T: ?Sized {}
    |                     ^^^^^^
    |
-   = help: add `#![feature(more_maybe_bounds)]` 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: in this context, relaxed bounds are only allowed on type parameters defined by the closest item
+
+error: relaxed bounds are not permitted in supertrait bounds
+  --> $DIR/relaxed-bounds-invalid-places.rs:26:11
+   |
+LL | trait Tr: ?Sized {}
+   |           ^^^^^^
+   |
+   = note: traits are `?Sized` by default
+
+error: relaxed bounds are not permitted in trait object types
+  --> $DIR/relaxed-bounds-invalid-places.rs:30:20
+   |
+LL | type O1 = dyn Tr + ?Sized;
+   |                    ^^^^^^
+
+error: relaxed bounds are not permitted in trait object types
+  --> $DIR/relaxed-bounds-invalid-places.rs:31:15
+   |
+LL | type O2 = dyn ?Sized + ?Sized + Tr;
+   |               ^^^^^^
+
+error: relaxed bounds are not permitted in trait object types
+  --> $DIR/relaxed-bounds-invalid-places.rs:31:24
+   |
+LL | type O2 = dyn ?Sized + ?Sized + Tr;
+   |                        ^^^^^^
 
 error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/relaxed-bounds-invalid-places.rs:15:34
+  --> $DIR/relaxed-bounds-invalid-places.rs:14:34
    |
 LL | struct S4<T>(T) where for<'a> T: ?Trait<'a>;
    |                                  ^^^^^^^^^^
 
 error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/relaxed-bounds-invalid-places.rs:19:33
+  --> $DIR/relaxed-bounds-invalid-places.rs:18:33
    |
 LL | struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
    |                                 ^^^^^^^^^^^^^^^   ^^^^^^
@@ -59,12 +80,11 @@ LL | struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/relaxed-bounds-invalid-places.rs:19:33
+  --> $DIR/relaxed-bounds-invalid-places.rs:18:33
    |
 LL | struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
    |                                 ^^^^^^^^^^^^^^^
 
-error: aborting due to 8 previous errors
+error: aborting due to 12 previous errors
 
-Some errors have detailed explanations: E0203, E0658.
-For more information about an error, try `rustc --explain E0203`.
+For more information about this error, try `rustc --explain E0203`.
-- 
cgit 1.4.1-3-g733a5


From 879f62bb3c23b7a90ac71bb217056fd49ff8dafb Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Thu, 19 Jun 2025 18:41:57 +0200
Subject: Reword diagnostic about relaxing non-`Sized` bound

* The phrasing "only does something for" made sense back when this
  diagnostic was a (hard) warning. Now however, it's simply a hard
  error and thus completely rules out "doing something".
* The primary message was way too long
* The new wording more closely mirrors the wording we use for applying
  other bound modifiers (like `const` and `async`) to incompatible
  traits.
* "all other traits are not bound by default" is no longer accurate
  under Sized Hierarchy. E.g., traits and assoc tys are (currently)
  bounded by `MetaSized` by default but can't be relaxed using
  `?MetaSized` (instead, you relax it by adding `PointeeSized`).
* I've decided against adding any diagnositic notes or suggestions
  for now like "trait `Trait` can't be relaxed as it's not bound by
  default" which would be incorrect for `MetaSized` and assoc tys
  as mentioned above) or "consider changing `?MetaSized` to
  `PointeeSized`" as the Sized Hierarchy impl is still WIP)
---
 .../src/hir_ty_lowering/bounds.rs                  | 27 +++++++++----
 .../src/hir_ty_lowering/errors.rs                  | 47 ++++++++++------------
 .../feature-gate-more-maybe-bounds.rs              |  8 ++--
 .../feature-gate-more-maybe-bounds.stderr          |  8 ++--
 tests/ui/impl-trait/opt-out-bound-not-satisfied.rs |  4 +-
 .../impl-trait/opt-out-bound-not-satisfied.stderr  |  4 +-
 tests/ui/issues/issue-37534.rs                     |  2 +-
 tests/ui/issues/issue-37534.stderr                 |  2 +-
 tests/ui/issues/issue-87199.rs                     |  8 ++--
 tests/ui/issues/issue-87199.stderr                 |  8 ++--
 tests/ui/sized-hierarchy/default-bound.rs          |  4 +-
 tests/ui/sized-hierarchy/default-bound.stderr      |  4 +-
 tests/ui/trait-bounds/maybe-bound-has-path-args.rs |  2 +-
 .../trait-bounds/maybe-bound-has-path-args.stderr  |  2 +-
 tests/ui/trait-bounds/maybe-bound-with-assoc.rs    |  4 +-
 .../ui/trait-bounds/maybe-bound-with-assoc.stderr  |  4 +-
 tests/ui/trait-bounds/more_maybe_bounds.rs         | 29 +++++++++++++
 tests/ui/trait-bounds/more_maybe_bounds.stderr     | 20 +++++++++
 tests/ui/traits/maybe-polarity-pass.rs             | 25 ------------
 tests/ui/traits/maybe-polarity-pass.stderr         | 20 ---------
 tests/ui/traits/maybe-polarity-repeated.rs         |  4 +-
 tests/ui/traits/maybe-polarity-repeated.stderr     |  4 +-
 tests/ui/unsized/relaxed-bounds-invalid-places.rs  |  4 +-
 .../unsized/relaxed-bounds-invalid-places.stderr   |  4 +-
 24 files changed, 131 insertions(+), 117 deletions(-)
 create mode 100644 tests/ui/trait-bounds/more_maybe_bounds.rs
 create mode 100644 tests/ui/trait-bounds/more_maybe_bounds.stderr
 delete mode 100644 tests/ui/traits/maybe-polarity-pass.rs
 delete mode 100644 tests/ui/traits/maybe-polarity-pass.stderr

diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
index b59ff863383..dbd22fabab8 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -85,17 +85,17 @@ fn search_bounds_for<'tcx>(
     }
 }
 
-fn collect_unbounds<'tcx>(
+fn collect_relaxed_bounds<'tcx>(
     hir_bounds: &'tcx [hir::GenericBound<'tcx>],
     self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
 ) -> SmallVec<[&'tcx PolyTraitRef<'tcx>; 1]> {
-    let mut unbounds: SmallVec<[_; 1]> = SmallVec::new();
+    let mut relaxed_bounds: SmallVec<[_; 1]> = SmallVec::new();
     search_bounds_for(hir_bounds, self_ty_where_predicates, |ptr| {
         if matches!(ptr.modifiers.polarity, hir::BoundPolarity::Maybe(_)) {
-            unbounds.push(ptr);
+            relaxed_bounds.push(ptr);
         }
     });
-    unbounds
+    relaxed_bounds
 }
 
 fn collect_bounds<'a, 'tcx>(
@@ -209,9 +209,22 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 return;
             }
         } else {
-            // Report invalid unbounds on sizedness-bounded generic parameters.
-            let unbounds = collect_unbounds(hir_bounds, self_ty_where_predicates);
-            self.check_and_report_invalid_unbounds_on_param(unbounds);
+            // Report invalid relaxed bounds.
+            // FIXME: Since we only call this validation function here in this function, we only
+            //        fully validate relaxed bounds in contexts where we perform
+            //        "sized elaboration". In most cases that doesn't matter because we *usually*
+            //        reject such relaxed bounds outright during AST lowering.
+            //        However, this can easily get out of sync! Ideally, we would perform this step
+            //        where we are guaranteed to catch *all* bounds like in
+            //        `Self::lower_poly_trait_ref`. List of concrete issues:
+            //        FIXME(more_maybe_bounds): We don't call this for e.g., trait object tys or
+            //                                  supertrait bounds!
+            //        FIXME(trait_alias, #143122): We don't call it for the RHS. Arguably however,
+            //                                       AST lowering should reject them outright.
+            //        FIXME(associated_type_bounds): We don't call this for them. However, AST
+            //                                       lowering should reject them outright (#135229).
+            let bounds = collect_relaxed_bounds(hir_bounds, self_ty_where_predicates);
+            self.check_and_report_invalid_relaxed_bounds(bounds);
         }
 
         let collected = collect_sizedness_bounds(tcx, hir_bounds, self_ty_where_predicates, span);
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
index 5d85a3f8455..8c99a41f626 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -8,7 +8,7 @@ use rustc_errors::{
 };
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{self as hir, HirId, LangItem, PolyTraitRef};
+use rustc_hir::{self as hir, HirId, PolyTraitRef};
 use rustc_middle::bug;
 use rustc_middle::ty::fast_reject::{TreatParams, simplify_type};
 use rustc_middle::ty::print::{PrintPolyTraitRefExt as _, PrintTraitRefExt as _};
@@ -35,26 +35,24 @@ use crate::fluent_generated as fluent;
 use crate::hir_ty_lowering::{AssocItemQSelf, HirTyLowerer};
 
 impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
-    /// Check for multiple relaxed default bounds and relaxed bounds of non-sizedness traits.
-    pub(crate) fn check_and_report_invalid_unbounds_on_param(
+    /// Check for multiple relaxed bounds and relaxed bounds of non-default traits.
+    pub(crate) fn check_and_report_invalid_relaxed_bounds(
         &self,
-        unbounds: SmallVec<[&PolyTraitRef<'_>; 1]>,
+        relaxed_bounds: SmallVec<[&PolyTraitRef<'_>; 1]>,
     ) {
         let tcx = self.tcx();
 
-        let sized_did = tcx.require_lang_item(LangItem::Sized, DUMMY_SP);
-
         let mut unique_bounds = FxIndexSet::default();
         let mut seen_repeat = false;
-        for unbound in &unbounds {
-            if let Res::Def(DefKind::Trait, unbound_def_id) = unbound.trait_ref.path.res {
-                seen_repeat |= !unique_bounds.insert(unbound_def_id);
+        for bound in &relaxed_bounds {
+            if let Res::Def(DefKind::Trait, trait_def_id) = bound.trait_ref.path.res {
+                seen_repeat |= !unique_bounds.insert(trait_def_id);
             }
         }
 
-        if unbounds.len() > 1 {
+        if relaxed_bounds.len() > 1 {
             let err = errors::MultipleRelaxedDefaultBounds {
-                spans: unbounds.iter().map(|ptr| ptr.span).collect(),
+                spans: relaxed_bounds.iter().map(|ptr| ptr.span).collect(),
             };
 
             if seen_repeat {
@@ -64,24 +62,23 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             };
         }
 
-        for unbound in unbounds {
-            if let Res::Def(DefKind::Trait, did) = unbound.trait_ref.path.res
-                && ((did == sized_did) || tcx.is_default_trait(did))
+        let sized_def_id = tcx.require_lang_item(hir::LangItem::Sized, DUMMY_SP);
+
+        for bound in relaxed_bounds {
+            if let Res::Def(DefKind::Trait, def_id) = bound.trait_ref.path.res
+                && (def_id == sized_def_id || tcx.is_default_trait(def_id))
             {
                 continue;
             }
-
-            let unbound_traits = match tcx.sess.opts.unstable_opts.experimental_default_bounds {
-                true => "`?Sized` and `experimental_default_bounds`",
-                false => "`?Sized`",
-            };
             self.dcx().span_err(
-                unbound.span,
-                format!(
-                    "relaxing a default bound only does something for {}; all other traits are \
-                     not bound by default",
-                    unbound_traits
-                ),
+                bound.span,
+                if tcx.sess.opts.unstable_opts.experimental_default_bounds
+                    || tcx.features().more_maybe_bounds()
+                {
+                    "bound modifier `?` can only be applied to default traits like `Sized`"
+                } else {
+                    "bound modifier `?` can only be applied to `Sized`"
+                },
             );
         }
     }
diff --git a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs
index 3066967f87e..7c9d88462f6 100644
--- a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs
+++ b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs
@@ -9,14 +9,14 @@ fn foo(_: Box<dyn Trait1 + ?Trait2>) {}
 //~^  ERROR relaxed bounds are not permitted in trait object types
 fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
 //~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-//~| ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+//~| ERROR bound modifier `?` can only be applied to `Sized`
+//~| ERROR bound modifier `?` can only be applied to `Sized`
 
 trait Trait {}
 // Do not suggest `#![feature(more_maybe_bounds)]` for repetitions
 fn baz<T: ?Trait + ?Trait>(_ : T) {}
 //~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-//~| ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+//~| ERROR bound modifier `?` can only be applied to `Sized`
+//~| ERROR bound modifier `?` can only be applied to `Sized`
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
index 35b5b80d69e..c6d940db57b 100644
--- a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
+++ b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
@@ -27,13 +27,13 @@ LL | fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
    = help: add `#![feature(more_maybe_bounds)]` 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: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/feature-gate-more-maybe-bounds.rs:10:11
    |
 LL | fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
    |           ^^^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/feature-gate-more-maybe-bounds.rs:10:21
    |
 LL | fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
@@ -45,13 +45,13 @@ error[E0203]: type parameter has more than one relaxed default bound, only one i
 LL | fn baz<T: ?Trait + ?Trait>(_ : T) {}
    |           ^^^^^^   ^^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/feature-gate-more-maybe-bounds.rs:17:11
    |
 LL | fn baz<T: ?Trait + ?Trait>(_ : T) {}
    |           ^^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/feature-gate-more-maybe-bounds.rs:17:20
    |
 LL | fn baz<T: ?Trait + ?Trait>(_ : T) {}
diff --git a/tests/ui/impl-trait/opt-out-bound-not-satisfied.rs b/tests/ui/impl-trait/opt-out-bound-not-satisfied.rs
index 27c493a13bf..7e0e1eadf9c 100644
--- a/tests/ui/impl-trait/opt-out-bound-not-satisfied.rs
+++ b/tests/ui/impl-trait/opt-out-bound-not-satisfied.rs
@@ -3,8 +3,8 @@
 
 use std::future::Future;
 fn foo() -> impl ?Future<Output = impl Send> {
-    //~^ ERROR: relaxing a default bound only does something for `?Sized`
-    //~| ERROR: relaxing a default bound only does something for `?Sized`
+    //~^ ERROR: bound modifier `?` can only be applied to `Sized`
+    //~| ERROR: bound modifier `?` can only be applied to `Sized`
     ()
 }
 
diff --git a/tests/ui/impl-trait/opt-out-bound-not-satisfied.stderr b/tests/ui/impl-trait/opt-out-bound-not-satisfied.stderr
index dc4314c58ad..f99d6a7e5f6 100644
--- a/tests/ui/impl-trait/opt-out-bound-not-satisfied.stderr
+++ b/tests/ui/impl-trait/opt-out-bound-not-satisfied.stderr
@@ -1,10 +1,10 @@
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/opt-out-bound-not-satisfied.rs:5:18
    |
 LL | fn foo() -> impl ?Future<Output = impl Send> {
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/opt-out-bound-not-satisfied.rs:5:18
    |
 LL | fn foo() -> impl ?Future<Output = impl Send> {
diff --git a/tests/ui/issues/issue-37534.rs b/tests/ui/issues/issue-37534.rs
index 09d60b7786b..63f6479ae2e 100644
--- a/tests/ui/issues/issue-37534.rs
+++ b/tests/ui/issues/issue-37534.rs
@@ -1,5 +1,5 @@
 struct Foo<T: ?Hash> {}
 //~^ ERROR expected trait, found derive macro `Hash`
-//~| ERROR relaxing a default bound only does something for `?Sized`
+//~| ERROR bound modifier `?` can only be applied to `Sized`
 
 fn main() {}
diff --git a/tests/ui/issues/issue-37534.stderr b/tests/ui/issues/issue-37534.stderr
index 3219854bc70..08607354203 100644
--- a/tests/ui/issues/issue-37534.stderr
+++ b/tests/ui/issues/issue-37534.stderr
@@ -9,7 +9,7 @@ help: consider importing this trait instead
 LL + use std::hash::Hash;
    |
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/issue-37534.rs:1:15
    |
 LL | struct Foo<T: ?Hash> {}
diff --git a/tests/ui/issues/issue-87199.rs b/tests/ui/issues/issue-87199.rs
index 4e4e35c6a71..dd9dfc74ca3 100644
--- a/tests/ui/issues/issue-87199.rs
+++ b/tests/ui/issues/issue-87199.rs
@@ -6,12 +6,12 @@
 
 // Check that these function definitions only emit warnings, not errors
 fn arg<T: ?Send>(_: T) {}
-//~^ ERROR: relaxing a default bound only does something for `?Sized`
+//~^ ERROR: bound modifier `?` can only be applied to `Sized`
 fn ref_arg<T: ?Send>(_: &T) {}
-//~^ ERROR: relaxing a default bound only does something for `?Sized`
+//~^ ERROR: bound modifier `?` can only be applied to `Sized`
 fn ret() -> impl Iterator<Item = ()> + ?Send { std::iter::empty() }
-//~^ ERROR: relaxing a default bound only does something for `?Sized`
-//~| ERROR: relaxing a default bound only does something for `?Sized`
+//~^ ERROR: bound modifier `?` can only be applied to `Sized`
+//~| ERROR: bound modifier `?` can only be applied to `Sized`
 
 // Check that there's no `?Sized` relaxation!
 fn main() {
diff --git a/tests/ui/issues/issue-87199.stderr b/tests/ui/issues/issue-87199.stderr
index acc4e84779c..8a930a3d704 100644
--- a/tests/ui/issues/issue-87199.stderr
+++ b/tests/ui/issues/issue-87199.stderr
@@ -1,22 +1,22 @@
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/issue-87199.rs:8:11
    |
 LL | fn arg<T: ?Send>(_: T) {}
    |           ^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/issue-87199.rs:10:15
    |
 LL | fn ref_arg<T: ?Send>(_: &T) {}
    |               ^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/issue-87199.rs:12:40
    |
 LL | fn ret() -> impl Iterator<Item = ()> + ?Send { std::iter::empty() }
    |                                        ^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/issue-87199.rs:12:40
    |
 LL | fn ret() -> impl Iterator<Item = ()> + ?Send { std::iter::empty() }
diff --git a/tests/ui/sized-hierarchy/default-bound.rs b/tests/ui/sized-hierarchy/default-bound.rs
index 12b2eb2b5c1..bbb2c6d96ba 100644
--- a/tests/ui/sized-hierarchy/default-bound.rs
+++ b/tests/ui/sized-hierarchy/default-bound.rs
@@ -14,13 +14,13 @@ fn neg_sized<T: ?Sized>() {}
 fn metasized<T: MetaSized>() {}
 
 fn neg_metasized<T: ?MetaSized>() {}
-//~^ ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+//~^ ERROR bound modifier `?` can only be applied to `Sized`
 
 
 fn pointeesized<T: PointeeSized>() { }
 
 fn neg_pointeesized<T: ?PointeeSized>() { }
-//~^ ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+//~^ ERROR bound modifier `?` can only be applied to `Sized`
 
 
 fn main() {
diff --git a/tests/ui/sized-hierarchy/default-bound.stderr b/tests/ui/sized-hierarchy/default-bound.stderr
index 22f0fa29d3e..0a4ea6f44d8 100644
--- a/tests/ui/sized-hierarchy/default-bound.stderr
+++ b/tests/ui/sized-hierarchy/default-bound.stderr
@@ -1,10 +1,10 @@
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/default-bound.rs:16:21
    |
 LL | fn neg_metasized<T: ?MetaSized>() {}
    |                     ^^^^^^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/default-bound.rs:22:24
    |
 LL | fn neg_pointeesized<T: ?PointeeSized>() { }
diff --git a/tests/ui/trait-bounds/maybe-bound-has-path-args.rs b/tests/ui/trait-bounds/maybe-bound-has-path-args.rs
index e5abcae5d21..14a26670497 100644
--- a/tests/ui/trait-bounds/maybe-bound-has-path-args.rs
+++ b/tests/ui/trait-bounds/maybe-bound-has-path-args.rs
@@ -2,6 +2,6 @@ trait Trait {}
 
 fn test<T: ?self::<i32>::Trait>() {}
 //~^ ERROR type arguments are not allowed on module `maybe_bound_has_path_args`
-//~| ERROR relaxing a default bound only does something for `?Sized`
+//~| ERROR bound modifier `?` can only be applied to `Sized`
 
 fn main() {}
diff --git a/tests/ui/trait-bounds/maybe-bound-has-path-args.stderr b/tests/ui/trait-bounds/maybe-bound-has-path-args.stderr
index dc55b26c918..bf968b05af0 100644
--- a/tests/ui/trait-bounds/maybe-bound-has-path-args.stderr
+++ b/tests/ui/trait-bounds/maybe-bound-has-path-args.stderr
@@ -1,4 +1,4 @@
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/maybe-bound-has-path-args.rs:3:12
    |
 LL | fn test<T: ?self::<i32>::Trait>() {}
diff --git a/tests/ui/trait-bounds/maybe-bound-with-assoc.rs b/tests/ui/trait-bounds/maybe-bound-with-assoc.rs
index 9127c2de16d..e123f18474d 100644
--- a/tests/ui/trait-bounds/maybe-bound-with-assoc.rs
+++ b/tests/ui/trait-bounds/maybe-bound-with-assoc.rs
@@ -2,11 +2,11 @@ trait HasAssoc {
     type Assoc;
 }
 fn hasassoc<T: ?HasAssoc<Assoc = ()>>() {}
-//~^ ERROR relaxing a default bound
+//~^ ERROR bound modifier `?` can only be applied to `Sized`
 
 trait NoAssoc {}
 fn noassoc<T: ?NoAssoc<Missing = ()>>() {}
-//~^ ERROR relaxing a default bound
+//~^ ERROR bound modifier `?` can only be applied to `Sized`
 //~| ERROR associated type `Missing` not found for `NoAssoc`
 
 fn main() {}
diff --git a/tests/ui/trait-bounds/maybe-bound-with-assoc.stderr b/tests/ui/trait-bounds/maybe-bound-with-assoc.stderr
index 36a1e0ade20..b2ae0584aff 100644
--- a/tests/ui/trait-bounds/maybe-bound-with-assoc.stderr
+++ b/tests/ui/trait-bounds/maybe-bound-with-assoc.stderr
@@ -1,10 +1,10 @@
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/maybe-bound-with-assoc.rs:4:16
    |
 LL | fn hasassoc<T: ?HasAssoc<Assoc = ()>>() {}
    |                ^^^^^^^^^^^^^^^^^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/maybe-bound-with-assoc.rs:8:15
    |
 LL | fn noassoc<T: ?NoAssoc<Missing = ()>>() {}
diff --git a/tests/ui/trait-bounds/more_maybe_bounds.rs b/tests/ui/trait-bounds/more_maybe_bounds.rs
new file mode 100644
index 00000000000..61b630479ac
--- /dev/null
+++ b/tests/ui/trait-bounds/more_maybe_bounds.rs
@@ -0,0 +1,29 @@
+// FIXME(more_maybe_bounds): Even under `more_maybe_bounds` / `-Zexperimental-default-bounds`,
+// trying to relax non-default bounds should still be an error in all contexts! As you can see
+// there are placed like supertrait bounds and trait object types where we currently don't perform
+// this check.
+#![feature(auto_traits, more_maybe_bounds, negative_impls)]
+
+trait Trait1 {}
+auto trait Trait2 {}
+
+// FIXME: `?Trait1` should be rejected, `Trait1` isn't marked `#[lang = "default_traitN"]`.
+trait Trait3: ?Trait1 {}
+trait Trait4 where Self: Trait1 {}
+
+// FIXME: `?Trait2` should be rejected, `Trait2` isn't marked `#[lang = "default_traitN"]`.
+fn foo(_: Box<(dyn Trait3 + ?Trait2)>) {}
+fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
+//~^ ERROR bound modifier `?` can only be applied to default traits like `Sized`
+//~| ERROR bound modifier `?` can only be applied to default traits like `Sized`
+//~| ERROR bound modifier `?` can only be applied to default traits like `Sized`
+
+struct S;
+impl !Trait2 for S {}
+impl Trait1 for S {}
+impl Trait3 for S {}
+
+fn main() {
+    foo(Box::new(S));
+    bar(&S);
+}
diff --git a/tests/ui/trait-bounds/more_maybe_bounds.stderr b/tests/ui/trait-bounds/more_maybe_bounds.stderr
new file mode 100644
index 00000000000..09c9fc31165
--- /dev/null
+++ b/tests/ui/trait-bounds/more_maybe_bounds.stderr
@@ -0,0 +1,20 @@
+error: bound modifier `?` can only be applied to default traits like `Sized`
+  --> $DIR/more_maybe_bounds.rs:16:20
+   |
+LL | fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
+   |                    ^^^^^^^
+
+error: bound modifier `?` can only be applied to default traits like `Sized`
+  --> $DIR/more_maybe_bounds.rs:16:30
+   |
+LL | fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
+   |                              ^^^^^^^
+
+error: bound modifier `?` can only be applied to default traits like `Sized`
+  --> $DIR/more_maybe_bounds.rs:16:40
+   |
+LL | fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
+   |                                        ^^^^^^^
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/traits/maybe-polarity-pass.rs b/tests/ui/traits/maybe-polarity-pass.rs
deleted file mode 100644
index 1ccd52bc169..00000000000
--- a/tests/ui/traits/maybe-polarity-pass.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#![feature(auto_traits)]
-#![feature(more_maybe_bounds)]
-#![feature(negative_impls)]
-
-trait Trait1 {}
-auto trait Trait2 {}
-
-trait Trait3 : ?Trait1 {}
-trait Trait4 where Self: Trait1 {}
-
-fn foo(_: Box<(dyn Trait3 + ?Trait2)>) {}
-fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
-//~^ ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-//~| ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-//~| ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-
-struct S;
-impl !Trait2 for S {}
-impl Trait1 for S {}
-impl Trait3 for S {}
-
-fn main() {
-    foo(Box::new(S));
-    bar(&S);
-}
diff --git a/tests/ui/traits/maybe-polarity-pass.stderr b/tests/ui/traits/maybe-polarity-pass.stderr
deleted file mode 100644
index 1f378dd665a..00000000000
--- a/tests/ui/traits/maybe-polarity-pass.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/maybe-polarity-pass.rs:12:20
-   |
-LL | fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
-   |                    ^^^^^^^
-
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/maybe-polarity-pass.rs:12:30
-   |
-LL | fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
-   |                              ^^^^^^^
-
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/maybe-polarity-pass.rs:12:40
-   |
-LL | fn bar<T: ?Sized + ?Trait2 + ?Trait1 + ?Trait4>(_: &T) {}
-   |                                        ^^^^^^^
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui/traits/maybe-polarity-repeated.rs b/tests/ui/traits/maybe-polarity-repeated.rs
index fd1ef567b3e..962e3d5dbc5 100644
--- a/tests/ui/traits/maybe-polarity-repeated.rs
+++ b/tests/ui/traits/maybe-polarity-repeated.rs
@@ -3,7 +3,7 @@
 trait Trait {}
 fn foo<T: ?Trait + ?Trait>(_: T) {}
 //~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-//~| ERROR relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+//~| ERROR bound modifier `?` can only be applied to default traits like `Sized`
+//~| ERROR bound modifier `?` can only be applied to default traits like `Sized`
 
 fn main() {}
diff --git a/tests/ui/traits/maybe-polarity-repeated.stderr b/tests/ui/traits/maybe-polarity-repeated.stderr
index 4fa1dc45bda..de16c147180 100644
--- a/tests/ui/traits/maybe-polarity-repeated.stderr
+++ b/tests/ui/traits/maybe-polarity-repeated.stderr
@@ -4,13 +4,13 @@ error[E0203]: type parameter has more than one relaxed default bound, only one i
 LL | fn foo<T: ?Trait + ?Trait>(_: T) {}
    |           ^^^^^^   ^^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to default traits like `Sized`
   --> $DIR/maybe-polarity-repeated.rs:4:11
    |
 LL | fn foo<T: ?Trait + ?Trait>(_: T) {}
    |           ^^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to default traits like `Sized`
   --> $DIR/maybe-polarity-repeated.rs:4:20
    |
 LL | fn foo<T: ?Trait + ?Trait>(_: T) {}
diff --git a/tests/ui/unsized/relaxed-bounds-invalid-places.rs b/tests/ui/unsized/relaxed-bounds-invalid-places.rs
index e9f39d5f211..64d4523ac49 100644
--- a/tests/ui/unsized/relaxed-bounds-invalid-places.rs
+++ b/tests/ui/unsized/relaxed-bounds-invalid-places.rs
@@ -13,11 +13,11 @@ trait Trait<'a> {}
 
 struct S4<T>(T) where for<'a> T: ?Trait<'a>;
 //~^ ERROR this relaxed bound is not permitted here
-//~| ERROR relaxing a default bound only does something for `?Sized`
+//~| ERROR bound modifier `?` can only be applied to `Sized`
 
 struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
 //~^ ERROR type parameter has more than one relaxed default bound
-//~| ERROR relaxing a default bound only does something for `?Sized`
+//~| ERROR bound modifier `?` can only be applied to `Sized`
 
 impl<T> S1<T> {
     fn f() where T: ?Sized {} //~ ERROR this relaxed bound is not permitted here
diff --git a/tests/ui/unsized/relaxed-bounds-invalid-places.stderr b/tests/ui/unsized/relaxed-bounds-invalid-places.stderr
index a08dc15058a..cfa0d274b26 100644
--- a/tests/ui/unsized/relaxed-bounds-invalid-places.stderr
+++ b/tests/ui/unsized/relaxed-bounds-invalid-places.stderr
@@ -64,7 +64,7 @@ error: relaxed bounds are not permitted in trait object types
 LL | type O2 = dyn ?Sized + ?Sized + Tr;
    |                        ^^^^^^
 
-error: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/relaxed-bounds-invalid-places.rs:14:34
    |
 LL | struct S4<T>(T) where for<'a> T: ?Trait<'a>;
@@ -79,7 +79,7 @@ LL | struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
    = help: add `#![feature(more_maybe_bounds)]` 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: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
+error: bound modifier `?` can only be applied to `Sized`
   --> $DIR/relaxed-bounds-invalid-places.rs:18:33
    |
 LL | struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
-- 
cgit 1.4.1-3-g733a5


From 4e53043395b747b267bee975080896fb781fe19f Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Fri, 18 Jul 2025 15:46:00 +0530
Subject: populate the target_config now before its usage and update the test
 accordingly

---
 src/bootstrap/src/core/builder/tests.rs | 2 ++
 src/bootstrap/src/core/config/config.rs | 3 +--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 51a90649692..7f0c6fbd854 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1638,6 +1638,7 @@ mod snapshot {
                 .render_steps(), @r"
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 0 <host> -> LldWrapper 1 <host>
         [build] rustdoc 0 <host>
         [doc] std 1 <host> crates=[core]
         ");
@@ -1653,6 +1654,7 @@ mod snapshot {
                 .render_steps(), @r"
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
+        [build] rustc 0 <host> -> LldWrapper 1 <host>
         [build] rustdoc 0 <host>
         [doc] std 1 <host> crates=[alloc,core]
         ");
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 22a75183404..6e04f115424 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -942,6 +942,7 @@ impl Config {
         config.rust_profile_use = flags_rust_profile_use;
         config.rust_profile_generate = flags_rust_profile_generate;
 
+        config.apply_target_config(toml.target);
         config.apply_rust_config(toml.rust, flags_warnings);
 
         config.reproducible_artifacts = flags_reproducible_artifact;
@@ -967,8 +968,6 @@ impl Config {
 
         config.apply_gcc_config(toml.gcc);
 
-        config.apply_target_config(toml.target);
-
         match ccache {
             Some(StringOrBool::String(ref s)) => config.ccache = Some(s.to_string()),
             Some(StringOrBool::Bool(true)) => {
-- 
cgit 1.4.1-3-g733a5


From cdc3d701cb4ff37e9d0c96c1c68b2e8789c19441 Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Fri, 18 Jul 2025 12:24:56 +0200
Subject: Don't reject *multiple* relaxed bounds, reject *duplicate* ones.

Having multiple relaxed bounds like `?Sized + ?Iterator` is actually *fine*.
We actually want to reject *duplicate* relaxed bounds like `?Sized + ?Sized`
because these most certainly represent a user error.

Note that this doesn't mean that we accept more code because a bound like
`?Iterator` is still invalid as it's not relaxing a *default* trait and
the only way to define / use more default bounds is under the experimental
and internal feature `more_maybe_bounds` plus `lang_items` plus unstable
flag `-Zexperimental-default-bounds` (historical context: for the longest
time, bounds like `?Iterator` were actually allowed and lead to a hard
warning).

Ultimately, this simply *reframes* the diagnostic. The scope of
`more_maybe_bounds` / `-Zexperimental-default-bounds` remains unchanged
as well.
---
 .../rustc_error_codes/src/error_codes/E0203.md     |  10 +-
 compiler/rustc_hir_analysis/messages.ftl           |   3 -
 compiler/rustc_hir_analysis/src/errors.rs          |   7 -
 .../src/hir_ty_lowering/errors.rs                  |  26 ++-
 .../feature-gate-more-maybe-bounds.rs              |  10 +-
 .../feature-gate-more-maybe-bounds.stderr          |  30 +---
 ...uggestionf-for-repeated-unsized-bound-127441.rs |  39 ----
 ...stionf-for-repeated-unsized-bound-127441.stderr | 196 ---------------------
 tests/ui/trait-bounds/duplicate-relaxed-bounds.rs  |  22 +++
 .../trait-bounds/duplicate-relaxed-bounds.stderr   |  47 +++++
 .../ui/trait-bounds/fix-dyn-sized-fn-param-sugg.rs |  38 ++++
 .../fix-dyn-sized-fn-param-sugg.stderr             | 196 +++++++++++++++++++++
 tests/ui/trait-bounds/more_maybe_bounds.rs         |   2 +-
 tests/ui/traits/maybe-polarity-repeated.rs         |   9 -
 tests/ui/traits/maybe-polarity-repeated.stderr     |  21 ---
 tests/ui/unsized/relaxed-bounds-invalid-places.rs  |   4 +-
 .../unsized/relaxed-bounds-invalid-places.stderr   |  22 +--
 17 files changed, 330 insertions(+), 352 deletions(-)
 delete mode 100644 tests/ui/trait-bounds/bad-suggestionf-for-repeated-unsized-bound-127441.rs
 delete mode 100644 tests/ui/trait-bounds/bad-suggestionf-for-repeated-unsized-bound-127441.stderr
 create mode 100644 tests/ui/trait-bounds/duplicate-relaxed-bounds.rs
 create mode 100644 tests/ui/trait-bounds/duplicate-relaxed-bounds.stderr
 create mode 100644 tests/ui/trait-bounds/fix-dyn-sized-fn-param-sugg.rs
 create mode 100644 tests/ui/trait-bounds/fix-dyn-sized-fn-param-sugg.stderr
 delete mode 100644 tests/ui/traits/maybe-polarity-repeated.rs
 delete mode 100644 tests/ui/traits/maybe-polarity-repeated.stderr

diff --git a/compiler/rustc_error_codes/src/error_codes/E0203.md b/compiler/rustc_error_codes/src/error_codes/E0203.md
index 1edb519275f..a4dceedbf1f 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0203.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0203.md
@@ -1,15 +1,15 @@
-Having multiple relaxed default bounds is unsupported.
+Having duplicate relaxed default bounds is unsupported.
 
 Erroneous code example:
 
 ```compile_fail,E0203
-struct Bad<T: ?Sized + ?Send>{
-    inner: T
+struct Bad<T: ?Sized + ?Sized>{
+    inner: T,
 }
 ```
 
-Here the type `T` cannot have a relaxed bound for multiple default traits
-(`Sized` and `Send`). This can be fixed by only using one relaxed bound.
+Here the type parameter `T` cannot have duplicate relaxed bounds for default
+trait `Sized`. This can be fixed by only using one relaxed bound:
 
 ```
 struct Good<T: ?Sized>{
diff --git a/compiler/rustc_hir_analysis/messages.ftl b/compiler/rustc_hir_analysis/messages.ftl
index a20becbe7e8..90cb1727034 100644
--- a/compiler/rustc_hir_analysis/messages.ftl
+++ b/compiler/rustc_hir_analysis/messages.ftl
@@ -371,9 +371,6 @@ hir_analysis_missing_type_params =
         *[other] parameters
     } must be specified on the object type
 
-hir_analysis_multiple_relaxed_default_bounds =
-    type parameter has more than one relaxed default bound, only one is supported
-
 hir_analysis_must_be_name_of_associated_function = must be a name of an associated function
 
 hir_analysis_must_implement_not_function = not a function
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index eb65050c17c..3283ce95ee0 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -278,13 +278,6 @@ pub(crate) struct CopyImplOnTypeWithDtor {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(hir_analysis_multiple_relaxed_default_bounds, code = E0203)]
-pub(crate) struct MultipleRelaxedDefaultBounds {
-    #[primary_span]
-    pub spans: Vec<Span>,
-}
-
 #[derive(Diagnostic)]
 #[diag(hir_analysis_copy_impl_on_non_adt, code = E0206)]
 pub(crate) struct CopyImplOnNonAdt {
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
index 8c99a41f626..3db78db931a 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -35,31 +35,29 @@ use crate::fluent_generated as fluent;
 use crate::hir_ty_lowering::{AssocItemQSelf, HirTyLowerer};
 
 impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
-    /// Check for multiple relaxed bounds and relaxed bounds of non-default traits.
+    /// Check for duplicate relaxed bounds and relaxed bounds of non-default traits.
     pub(crate) fn check_and_report_invalid_relaxed_bounds(
         &self,
         relaxed_bounds: SmallVec<[&PolyTraitRef<'_>; 1]>,
     ) {
         let tcx = self.tcx();
 
-        let mut unique_bounds = FxIndexSet::default();
-        let mut seen_repeat = false;
+        let mut grouped_bounds = FxIndexMap::<_, Vec<_>>::default();
+
         for bound in &relaxed_bounds {
             if let Res::Def(DefKind::Trait, trait_def_id) = bound.trait_ref.path.res {
-                seen_repeat |= !unique_bounds.insert(trait_def_id);
+                grouped_bounds.entry(trait_def_id).or_default().push(bound.span);
             }
         }
 
-        if relaxed_bounds.len() > 1 {
-            let err = errors::MultipleRelaxedDefaultBounds {
-                spans: relaxed_bounds.iter().map(|ptr| ptr.span).collect(),
-            };
-
-            if seen_repeat {
-                tcx.dcx().emit_err(err);
-            } else if !tcx.features().more_maybe_bounds() {
-                tcx.sess.create_feature_err(err, sym::more_maybe_bounds).emit();
-            };
+        for (trait_def_id, spans) in grouped_bounds {
+            if spans.len() > 1 {
+                let name = tcx.item_name(trait_def_id);
+                self.dcx()
+                    .struct_span_err(spans, format!("duplicate relaxed `{name}` bounds"))
+                    .with_code(E0203)
+                    .emit();
+            }
         }
 
         let sized_def_id = tcx.require_lang_item(hir::LangItem::Sized, DUMMY_SP);
diff --git a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs
index 7c9d88462f6..9c727ae3aad 100644
--- a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs
+++ b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.rs
@@ -8,15 +8,7 @@ trait Trait4 where Self: ?Trait1 {} //~ ERROR this relaxed bound is not permitte
 fn foo(_: Box<dyn Trait1 + ?Trait2>) {}
 //~^  ERROR relaxed bounds are not permitted in trait object types
 fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
-//~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR bound modifier `?` can only be applied to `Sized`
-//~| ERROR bound modifier `?` can only be applied to `Sized`
-
-trait Trait {}
-// Do not suggest `#![feature(more_maybe_bounds)]` for repetitions
-fn baz<T: ?Trait + ?Trait>(_ : T) {}
-//~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR bound modifier `?` can only be applied to `Sized`
+//~^ ERROR bound modifier `?` can only be applied to `Sized`
 //~| ERROR bound modifier `?` can only be applied to `Sized`
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
index c6d940db57b..da6ad5f16e2 100644
--- a/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
+++ b/tests/ui/feature-gates/feature-gate-more-maybe-bounds.stderr
@@ -18,15 +18,6 @@ error: relaxed bounds are not permitted in trait object types
 LL | fn foo(_: Box<dyn Trait1 + ?Trait2>) {}
    |                            ^^^^^^^
 
-error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/feature-gate-more-maybe-bounds.rs:10:11
-   |
-LL | fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
-   |           ^^^^^^^   ^^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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: bound modifier `?` can only be applied to `Sized`
   --> $DIR/feature-gate-more-maybe-bounds.rs:10:11
    |
@@ -39,24 +30,5 @@ error: bound modifier `?` can only be applied to `Sized`
 LL | fn bar<T: ?Trait1 + ?Trait2>(_: T) {}
    |                     ^^^^^^^
 
-error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/feature-gate-more-maybe-bounds.rs:17:11
-   |
-LL | fn baz<T: ?Trait + ?Trait>(_ : T) {}
-   |           ^^^^^^   ^^^^^^
-
-error: bound modifier `?` can only be applied to `Sized`
-  --> $DIR/feature-gate-more-maybe-bounds.rs:17:11
-   |
-LL | fn baz<T: ?Trait + ?Trait>(_ : T) {}
-   |           ^^^^^^
-
-error: bound modifier `?` can only be applied to `Sized`
-  --> $DIR/feature-gate-more-maybe-bounds.rs:17:20
-   |
-LL | fn baz<T: ?Trait + ?Trait>(_ : T) {}
-   |                    ^^^^^^
-
-error: aborting due to 9 previous errors
+error: aborting due to 5 previous errors
 
-For more information about this error, try `rustc --explain E0203`.
diff --git a/tests/ui/trait-bounds/bad-suggestionf-for-repeated-unsized-bound-127441.rs b/tests/ui/trait-bounds/bad-suggestionf-for-repeated-unsized-bound-127441.rs
deleted file mode 100644
index e6d7f74880f..00000000000
--- a/tests/ui/trait-bounds/bad-suggestionf-for-repeated-unsized-bound-127441.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Regression test for #127441
-
-// Tests that we make the correct suggestion
-// in case there are more than one `?Sized`
-// bounds on a function parameter
-
-use std::fmt::Debug;
-
-fn foo1<T: ?Sized>(a: T) {}
-//~^ ERROR he size for values of type `T` cannot be known at compilation time
-
-fn foo2<T: ?Sized + ?Sized>(a: T) {}
-//~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR the size for values of type `T` cannot be known at compilation time
-
-fn foo3<T: ?Sized + ?Sized + Debug>(a: T) {}
-//~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR he size for values of type `T` cannot be known at compilation time
-
-fn foo4<T: ?Sized + Debug + ?Sized >(a: T) {}
-//~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR the size for values of type `T` cannot be known at compilation time
-
-fn foo5(_: impl ?Sized) {}
-//~^ ERROR the size for values of type `impl ?Sized` cannot be known at compilation time
-
-fn foo6(_: impl ?Sized + ?Sized) {}
-//~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR the size for values of type `impl ?Sized + ?Sized` cannot be known at compilation tim
-
-fn foo7(_: impl ?Sized + ?Sized + Debug) {}
-//~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR the size for values of type `impl ?Sized + ?Sized + Debug` cannot be known at compilation time
-
-fn foo8(_: impl ?Sized + Debug + ?Sized ) {}
-//~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR the size for values of type `impl ?Sized + Debug + ?Sized` cannot be known at compilation time
-
-fn main() {}
diff --git a/tests/ui/trait-bounds/bad-suggestionf-for-repeated-unsized-bound-127441.stderr b/tests/ui/trait-bounds/bad-suggestionf-for-repeated-unsized-bound-127441.stderr
deleted file mode 100644
index 363f52d6df8..00000000000
--- a/tests/ui/trait-bounds/bad-suggestionf-for-repeated-unsized-bound-127441.stderr
+++ /dev/null
@@ -1,196 +0,0 @@
-error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:12:12
-   |
-LL | fn foo2<T: ?Sized + ?Sized>(a: T) {}
-   |            ^^^^^^   ^^^^^^
-
-error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:16:12
-   |
-LL | fn foo3<T: ?Sized + ?Sized + Debug>(a: T) {}
-   |            ^^^^^^   ^^^^^^
-
-error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:20:12
-   |
-LL | fn foo4<T: ?Sized + Debug + ?Sized >(a: T) {}
-   |            ^^^^^^           ^^^^^^
-
-error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:27:17
-   |
-LL | fn foo6(_: impl ?Sized + ?Sized) {}
-   |                 ^^^^^^   ^^^^^^
-
-error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:31:17
-   |
-LL | fn foo7(_: impl ?Sized + ?Sized + Debug) {}
-   |                 ^^^^^^   ^^^^^^
-
-error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:35:17
-   |
-LL | fn foo8(_: impl ?Sized + Debug + ?Sized ) {}
-   |                 ^^^^^^           ^^^^^^
-
-error[E0277]: the size for values of type `T` cannot be known at compilation time
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:9:23
-   |
-LL | fn foo1<T: ?Sized>(a: T) {}
-   |         -             ^ doesn't have a size known at compile-time
-   |         |
-   |         this type parameter needs to be `Sized`
-   |
-   = help: unsized fn params are gated as an unstable feature
-help: consider removing the `?Sized` bound to make the type parameter `Sized`
-   |
-LL - fn foo1<T: ?Sized>(a: T) {}
-LL + fn foo1<T>(a: T) {}
-   |
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL | fn foo1<T: ?Sized>(a: &T) {}
-   |                       +
-
-error[E0277]: the size for values of type `T` cannot be known at compilation time
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:12:32
-   |
-LL | fn foo2<T: ?Sized + ?Sized>(a: T) {}
-   |         -                      ^ doesn't have a size known at compile-time
-   |         |
-   |         this type parameter needs to be `Sized`
-   |
-   = help: unsized fn params are gated as an unstable feature
-help: consider removing the `?Sized` bound to make the type parameter `Sized`
-   |
-LL - fn foo2<T: ?Sized + ?Sized>(a: T) {}
-LL + fn foo2<T>(a: T) {}
-   |
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL | fn foo2<T: ?Sized + ?Sized>(a: &T) {}
-   |                                +
-
-error[E0277]: the size for values of type `T` cannot be known at compilation time
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:16:40
-   |
-LL | fn foo3<T: ?Sized + ?Sized + Debug>(a: T) {}
-   |         -                              ^ doesn't have a size known at compile-time
-   |         |
-   |         this type parameter needs to be `Sized`
-   |
-   = help: unsized fn params are gated as an unstable feature
-help: consider restricting type parameters
-   |
-LL - fn foo3<T: ?Sized + ?Sized + Debug>(a: T) {}
-LL + fn foo3<T: Debug>(a: T) {}
-   |
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL | fn foo3<T: ?Sized + ?Sized + Debug>(a: &T) {}
-   |                                        +
-
-error[E0277]: the size for values of type `T` cannot be known at compilation time
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:20:41
-   |
-LL | fn foo4<T: ?Sized + Debug + ?Sized >(a: T) {}
-   |         -                               ^ doesn't have a size known at compile-time
-   |         |
-   |         this type parameter needs to be `Sized`
-   |
-   = help: unsized fn params are gated as an unstable feature
-help: consider restricting type parameters
-   |
-LL - fn foo4<T: ?Sized + Debug + ?Sized >(a: T) {}
-LL + fn foo4<T: Debug >(a: T) {}
-   |
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL | fn foo4<T: ?Sized + Debug + ?Sized >(a: &T) {}
-   |                                         +
-
-error[E0277]: the size for values of type `impl ?Sized` cannot be known at compilation time
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:24:12
-   |
-LL | fn foo5(_: impl ?Sized) {}
-   |            ^^^^^^^^^^^
-   |            |
-   |            doesn't have a size known at compile-time
-   |            this type parameter needs to be `Sized`
-   |
-   = help: unsized fn params are gated as an unstable feature
-help: consider replacing `?Sized` with `Sized`
-   |
-LL - fn foo5(_: impl ?Sized) {}
-LL + fn foo5(_: impl Sized) {}
-   |
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL | fn foo5(_: &impl ?Sized) {}
-   |            +
-
-error[E0277]: the size for values of type `impl ?Sized + ?Sized` cannot be known at compilation time
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:27:12
-   |
-LL | fn foo6(_: impl ?Sized + ?Sized) {}
-   |            ^^^^^^^^^^^^^^^^^^^^
-   |            |
-   |            doesn't have a size known at compile-time
-   |            this type parameter needs to be `Sized`
-   |
-   = help: unsized fn params are gated as an unstable feature
-help: consider restricting type parameters
-   |
-LL - fn foo6(_: impl ?Sized + ?Sized) {}
-LL + fn foo6(_: impl Sized) {}
-   |
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL | fn foo6(_: &impl ?Sized + ?Sized) {}
-   |            +
-
-error[E0277]: the size for values of type `impl ?Sized + ?Sized + Debug` cannot be known at compilation time
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:31:12
-   |
-LL | fn foo7(_: impl ?Sized + ?Sized + Debug) {}
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |            |
-   |            doesn't have a size known at compile-time
-   |            this type parameter needs to be `Sized`
-   |
-   = help: unsized fn params are gated as an unstable feature
-help: consider restricting type parameters
-   |
-LL - fn foo7(_: impl ?Sized + ?Sized + Debug) {}
-LL + fn foo7(_: impl Debug) {}
-   |
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL | fn foo7(_: &impl ?Sized + ?Sized + Debug) {}
-   |            +
-
-error[E0277]: the size for values of type `impl ?Sized + Debug + ?Sized` cannot be known at compilation time
-  --> $DIR/bad-suggestionf-for-repeated-unsized-bound-127441.rs:35:12
-   |
-LL | fn foo8(_: impl ?Sized + Debug + ?Sized ) {}
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |            |
-   |            doesn't have a size known at compile-time
-   |            this type parameter needs to be `Sized`
-   |
-   = help: unsized fn params are gated as an unstable feature
-help: consider restricting type parameters
-   |
-LL - fn foo8(_: impl ?Sized + Debug + ?Sized ) {}
-LL + fn foo8(_: impl Debug ) {}
-   |
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL | fn foo8(_: &impl ?Sized + Debug + ?Sized ) {}
-   |            +
-
-error: aborting due to 14 previous errors
-
-Some errors have detailed explanations: E0203, E0277.
-For more information about an error, try `rustc --explain E0203`.
diff --git a/tests/ui/trait-bounds/duplicate-relaxed-bounds.rs b/tests/ui/trait-bounds/duplicate-relaxed-bounds.rs
new file mode 100644
index 00000000000..a1681ddec77
--- /dev/null
+++ b/tests/ui/trait-bounds/duplicate-relaxed-bounds.rs
@@ -0,0 +1,22 @@
+fn dupes<T: ?Sized + ?Sized + ?Iterator + ?Iterator>() {}
+//~^ ERROR duplicate relaxed `Sized` bounds
+//~| ERROR duplicate relaxed `Iterator` bounds
+//~| ERROR bound modifier `?` can only be applied to `Sized`
+//~| ERROR bound modifier `?` can only be applied to `Sized`
+
+trait Trait {
+    // We used to say "type parameter has more than one relaxed default bound"
+    // even on *associated types* like here. Test that we no longer do that.
+    type Type: ?Sized + ?Sized;
+    //~^ ERROR duplicate relaxed `Sized` bounds
+    //~| ERROR duplicate relaxed `Sized` bounds
+}
+
+// We used to emit an additional error about "multiple relaxed default bounds".
+// However, multiple relaxed bounds are actually *fine* if they're distinct.
+// Ultimately, we still reject this because `Sized` is
+// the only (stable) default trait, so we're fine.
+fn not_dupes<T: ?Sized + ?Iterator>() {}
+//~^ ERROR bound modifier `?` can only be applied to `Sized`
+
+fn main() {}
diff --git a/tests/ui/trait-bounds/duplicate-relaxed-bounds.stderr b/tests/ui/trait-bounds/duplicate-relaxed-bounds.stderr
new file mode 100644
index 00000000000..ccc723fc7a6
--- /dev/null
+++ b/tests/ui/trait-bounds/duplicate-relaxed-bounds.stderr
@@ -0,0 +1,47 @@
+error[E0203]: duplicate relaxed `Sized` bounds
+  --> $DIR/duplicate-relaxed-bounds.rs:1:13
+   |
+LL | fn dupes<T: ?Sized + ?Sized + ?Iterator + ?Iterator>() {}
+   |             ^^^^^^   ^^^^^^
+
+error[E0203]: duplicate relaxed `Iterator` bounds
+  --> $DIR/duplicate-relaxed-bounds.rs:1:31
+   |
+LL | fn dupes<T: ?Sized + ?Sized + ?Iterator + ?Iterator>() {}
+   |                               ^^^^^^^^^   ^^^^^^^^^
+
+error: bound modifier `?` can only be applied to `Sized`
+  --> $DIR/duplicate-relaxed-bounds.rs:1:31
+   |
+LL | fn dupes<T: ?Sized + ?Sized + ?Iterator + ?Iterator>() {}
+   |                               ^^^^^^^^^
+
+error: bound modifier `?` can only be applied to `Sized`
+  --> $DIR/duplicate-relaxed-bounds.rs:1:43
+   |
+LL | fn dupes<T: ?Sized + ?Sized + ?Iterator + ?Iterator>() {}
+   |                                           ^^^^^^^^^
+
+error: bound modifier `?` can only be applied to `Sized`
+  --> $DIR/duplicate-relaxed-bounds.rs:19:26
+   |
+LL | fn not_dupes<T: ?Sized + ?Iterator>() {}
+   |                          ^^^^^^^^^
+
+error[E0203]: duplicate relaxed `Sized` bounds
+  --> $DIR/duplicate-relaxed-bounds.rs:10:16
+   |
+LL |     type Type: ?Sized + ?Sized;
+   |                ^^^^^^   ^^^^^^
+
+error[E0203]: duplicate relaxed `Sized` bounds
+  --> $DIR/duplicate-relaxed-bounds.rs:10:16
+   |
+LL |     type Type: ?Sized + ?Sized;
+   |                ^^^^^^   ^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 7 previous errors
+
+For more information about this error, try `rustc --explain E0203`.
diff --git a/tests/ui/trait-bounds/fix-dyn-sized-fn-param-sugg.rs b/tests/ui/trait-bounds/fix-dyn-sized-fn-param-sugg.rs
new file mode 100644
index 00000000000..1aa36207bc3
--- /dev/null
+++ b/tests/ui/trait-bounds/fix-dyn-sized-fn-param-sugg.rs
@@ -0,0 +1,38 @@
+// Test that we emit a correct structured suggestions for dynamically sized ("maybe unsized")
+// function parameters.
+// We used to emit a butchered suggestion if duplicate relaxed `Sized` bounds were present.
+// issue: <https://github.com/rust-lang/rust/issues/127441>.
+
+use std::fmt::Debug;
+
+fn foo1<T: ?Sized>(a: T) {}
+//~^ ERROR the size for values of type `T` cannot be known at compilation time
+
+fn foo2<T: ?Sized + ?Sized>(a: T) {}
+//~^ ERROR duplicate relaxed `Sized` bounds
+//~| ERROR the size for values of type `T` cannot be known at compilation time
+
+fn foo3<T: ?Sized + ?Sized + Debug>(a: T) {}
+//~^ ERROR duplicate relaxed `Sized` bounds
+//~| ERROR the size for values of type `T` cannot be known at compilation time
+
+fn foo4<T: ?Sized + Debug + ?Sized >(a: T) {}
+//~^ ERROR duplicate relaxed `Sized` bounds
+//~| ERROR the size for values of type `T` cannot be known at compilation time
+
+fn foo5(_: impl ?Sized) {}
+//~^ ERROR the size for values of type `impl ?Sized` cannot be known at compilation time
+
+fn foo6(_: impl ?Sized + ?Sized) {}
+//~^ ERROR duplicate relaxed `Sized` bounds
+//~| ERROR the size for values of type `impl ?Sized + ?Sized` cannot be known at compilation tim
+
+fn foo7(_: impl ?Sized + ?Sized + Debug) {}
+//~^ ERROR duplicate relaxed `Sized` bounds
+//~| ERROR the size for values of type `impl ?Sized + ?Sized + Debug` cannot be known at compilation time
+
+fn foo8(_: impl ?Sized + Debug + ?Sized ) {}
+//~^ ERROR duplicate relaxed `Sized` bounds
+//~| ERROR the size for values of type `impl ?Sized + Debug + ?Sized` cannot be known at compilation time
+
+fn main() {}
diff --git a/tests/ui/trait-bounds/fix-dyn-sized-fn-param-sugg.stderr b/tests/ui/trait-bounds/fix-dyn-sized-fn-param-sugg.stderr
new file mode 100644
index 00000000000..7a9c2f043ac
--- /dev/null
+++ b/tests/ui/trait-bounds/fix-dyn-sized-fn-param-sugg.stderr
@@ -0,0 +1,196 @@
+error[E0203]: duplicate relaxed `Sized` bounds
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:11:12
+   |
+LL | fn foo2<T: ?Sized + ?Sized>(a: T) {}
+   |            ^^^^^^   ^^^^^^
+
+error[E0203]: duplicate relaxed `Sized` bounds
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:15:12
+   |
+LL | fn foo3<T: ?Sized + ?Sized + Debug>(a: T) {}
+   |            ^^^^^^   ^^^^^^
+
+error[E0203]: duplicate relaxed `Sized` bounds
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:19:12
+   |
+LL | fn foo4<T: ?Sized + Debug + ?Sized >(a: T) {}
+   |            ^^^^^^           ^^^^^^
+
+error[E0203]: duplicate relaxed `Sized` bounds
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:26:17
+   |
+LL | fn foo6(_: impl ?Sized + ?Sized) {}
+   |                 ^^^^^^   ^^^^^^
+
+error[E0203]: duplicate relaxed `Sized` bounds
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:30:17
+   |
+LL | fn foo7(_: impl ?Sized + ?Sized + Debug) {}
+   |                 ^^^^^^   ^^^^^^
+
+error[E0203]: duplicate relaxed `Sized` bounds
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:34:17
+   |
+LL | fn foo8(_: impl ?Sized + Debug + ?Sized ) {}
+   |                 ^^^^^^           ^^^^^^
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:8:23
+   |
+LL | fn foo1<T: ?Sized>(a: T) {}
+   |         -             ^ doesn't have a size known at compile-time
+   |         |
+   |         this type parameter needs to be `Sized`
+   |
+   = help: unsized fn params are gated as an unstable feature
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+   |
+LL - fn foo1<T: ?Sized>(a: T) {}
+LL + fn foo1<T>(a: T) {}
+   |
+help: function arguments must have a statically known size, borrowed types always have a known size
+   |
+LL | fn foo1<T: ?Sized>(a: &T) {}
+   |                       +
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:11:32
+   |
+LL | fn foo2<T: ?Sized + ?Sized>(a: T) {}
+   |         -                      ^ doesn't have a size known at compile-time
+   |         |
+   |         this type parameter needs to be `Sized`
+   |
+   = help: unsized fn params are gated as an unstable feature
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+   |
+LL - fn foo2<T: ?Sized + ?Sized>(a: T) {}
+LL + fn foo2<T>(a: T) {}
+   |
+help: function arguments must have a statically known size, borrowed types always have a known size
+   |
+LL | fn foo2<T: ?Sized + ?Sized>(a: &T) {}
+   |                                +
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:15:40
+   |
+LL | fn foo3<T: ?Sized + ?Sized + Debug>(a: T) {}
+   |         -                              ^ doesn't have a size known at compile-time
+   |         |
+   |         this type parameter needs to be `Sized`
+   |
+   = help: unsized fn params are gated as an unstable feature
+help: consider restricting type parameters
+   |
+LL - fn foo3<T: ?Sized + ?Sized + Debug>(a: T) {}
+LL + fn foo3<T: Debug>(a: T) {}
+   |
+help: function arguments must have a statically known size, borrowed types always have a known size
+   |
+LL | fn foo3<T: ?Sized + ?Sized + Debug>(a: &T) {}
+   |                                        +
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:19:41
+   |
+LL | fn foo4<T: ?Sized + Debug + ?Sized >(a: T) {}
+   |         -                               ^ doesn't have a size known at compile-time
+   |         |
+   |         this type parameter needs to be `Sized`
+   |
+   = help: unsized fn params are gated as an unstable feature
+help: consider restricting type parameters
+   |
+LL - fn foo4<T: ?Sized + Debug + ?Sized >(a: T) {}
+LL + fn foo4<T: Debug >(a: T) {}
+   |
+help: function arguments must have a statically known size, borrowed types always have a known size
+   |
+LL | fn foo4<T: ?Sized + Debug + ?Sized >(a: &T) {}
+   |                                         +
+
+error[E0277]: the size for values of type `impl ?Sized` cannot be known at compilation time
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:23:12
+   |
+LL | fn foo5(_: impl ?Sized) {}
+   |            ^^^^^^^^^^^
+   |            |
+   |            doesn't have a size known at compile-time
+   |            this type parameter needs to be `Sized`
+   |
+   = help: unsized fn params are gated as an unstable feature
+help: consider replacing `?Sized` with `Sized`
+   |
+LL - fn foo5(_: impl ?Sized) {}
+LL + fn foo5(_: impl Sized) {}
+   |
+help: function arguments must have a statically known size, borrowed types always have a known size
+   |
+LL | fn foo5(_: &impl ?Sized) {}
+   |            +
+
+error[E0277]: the size for values of type `impl ?Sized + ?Sized` cannot be known at compilation time
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:26:12
+   |
+LL | fn foo6(_: impl ?Sized + ?Sized) {}
+   |            ^^^^^^^^^^^^^^^^^^^^
+   |            |
+   |            doesn't have a size known at compile-time
+   |            this type parameter needs to be `Sized`
+   |
+   = help: unsized fn params are gated as an unstable feature
+help: consider restricting type parameters
+   |
+LL - fn foo6(_: impl ?Sized + ?Sized) {}
+LL + fn foo6(_: impl Sized) {}
+   |
+help: function arguments must have a statically known size, borrowed types always have a known size
+   |
+LL | fn foo6(_: &impl ?Sized + ?Sized) {}
+   |            +
+
+error[E0277]: the size for values of type `impl ?Sized + ?Sized + Debug` cannot be known at compilation time
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:30:12
+   |
+LL | fn foo7(_: impl ?Sized + ?Sized + Debug) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |            |
+   |            doesn't have a size known at compile-time
+   |            this type parameter needs to be `Sized`
+   |
+   = help: unsized fn params are gated as an unstable feature
+help: consider restricting type parameters
+   |
+LL - fn foo7(_: impl ?Sized + ?Sized + Debug) {}
+LL + fn foo7(_: impl Debug) {}
+   |
+help: function arguments must have a statically known size, borrowed types always have a known size
+   |
+LL | fn foo7(_: &impl ?Sized + ?Sized + Debug) {}
+   |            +
+
+error[E0277]: the size for values of type `impl ?Sized + Debug + ?Sized` cannot be known at compilation time
+  --> $DIR/fix-dyn-sized-fn-param-sugg.rs:34:12
+   |
+LL | fn foo8(_: impl ?Sized + Debug + ?Sized ) {}
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |            |
+   |            doesn't have a size known at compile-time
+   |            this type parameter needs to be `Sized`
+   |
+   = help: unsized fn params are gated as an unstable feature
+help: consider restricting type parameters
+   |
+LL - fn foo8(_: impl ?Sized + Debug + ?Sized ) {}
+LL + fn foo8(_: impl Debug ) {}
+   |
+help: function arguments must have a statically known size, borrowed types always have a known size
+   |
+LL | fn foo8(_: &impl ?Sized + Debug + ?Sized ) {}
+   |            +
+
+error: aborting due to 14 previous errors
+
+Some errors have detailed explanations: E0203, E0277.
+For more information about an error, try `rustc --explain E0203`.
diff --git a/tests/ui/trait-bounds/more_maybe_bounds.rs b/tests/ui/trait-bounds/more_maybe_bounds.rs
index 61b630479ac..47348b0a0dd 100644
--- a/tests/ui/trait-bounds/more_maybe_bounds.rs
+++ b/tests/ui/trait-bounds/more_maybe_bounds.rs
@@ -1,6 +1,6 @@
 // FIXME(more_maybe_bounds): Even under `more_maybe_bounds` / `-Zexperimental-default-bounds`,
 // trying to relax non-default bounds should still be an error in all contexts! As you can see
-// there are placed like supertrait bounds and trait object types where we currently don't perform
+// there are places like supertrait bounds and trait object types where we currently don't perform
 // this check.
 #![feature(auto_traits, more_maybe_bounds, negative_impls)]
 
diff --git a/tests/ui/traits/maybe-polarity-repeated.rs b/tests/ui/traits/maybe-polarity-repeated.rs
deleted file mode 100644
index 962e3d5dbc5..00000000000
--- a/tests/ui/traits/maybe-polarity-repeated.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![feature(more_maybe_bounds)]
-
-trait Trait {}
-fn foo<T: ?Trait + ?Trait>(_: T) {}
-//~^ ERROR type parameter has more than one relaxed default bound, only one is supported
-//~| ERROR bound modifier `?` can only be applied to default traits like `Sized`
-//~| ERROR bound modifier `?` can only be applied to default traits like `Sized`
-
-fn main() {}
diff --git a/tests/ui/traits/maybe-polarity-repeated.stderr b/tests/ui/traits/maybe-polarity-repeated.stderr
deleted file mode 100644
index de16c147180..00000000000
--- a/tests/ui/traits/maybe-polarity-repeated.stderr
+++ /dev/null
@@ -1,21 +0,0 @@
-error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/maybe-polarity-repeated.rs:4:11
-   |
-LL | fn foo<T: ?Trait + ?Trait>(_: T) {}
-   |           ^^^^^^   ^^^^^^
-
-error: bound modifier `?` can only be applied to default traits like `Sized`
-  --> $DIR/maybe-polarity-repeated.rs:4:11
-   |
-LL | fn foo<T: ?Trait + ?Trait>(_: T) {}
-   |           ^^^^^^
-
-error: bound modifier `?` can only be applied to default traits like `Sized`
-  --> $DIR/maybe-polarity-repeated.rs:4:20
-   |
-LL | fn foo<T: ?Trait + ?Trait>(_: T) {}
-   |                    ^^^^^^
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0203`.
diff --git a/tests/ui/unsized/relaxed-bounds-invalid-places.rs b/tests/ui/unsized/relaxed-bounds-invalid-places.rs
index 64d4523ac49..b8eda1e7786 100644
--- a/tests/ui/unsized/relaxed-bounds-invalid-places.rs
+++ b/tests/ui/unsized/relaxed-bounds-invalid-places.rs
@@ -16,8 +16,7 @@ struct S4<T>(T) where for<'a> T: ?Trait<'a>;
 //~| ERROR bound modifier `?` can only be applied to `Sized`
 
 struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
-//~^ ERROR type parameter has more than one relaxed default bound
-//~| ERROR bound modifier `?` can only be applied to `Sized`
+//~^ ERROR bound modifier `?` can only be applied to `Sized`
 
 impl<T> S1<T> {
     fn f() where T: ?Sized {} //~ ERROR this relaxed bound is not permitted here
@@ -33,4 +32,3 @@ type O2 = dyn ?Sized + ?Sized + Tr;
 //~| ERROR relaxed bounds are not permitted in trait object types
 
 fn main() {}
-
diff --git a/tests/ui/unsized/relaxed-bounds-invalid-places.stderr b/tests/ui/unsized/relaxed-bounds-invalid-places.stderr
index cfa0d274b26..30285d62693 100644
--- a/tests/ui/unsized/relaxed-bounds-invalid-places.stderr
+++ b/tests/ui/unsized/relaxed-bounds-invalid-places.stderr
@@ -31,7 +31,7 @@ LL | struct S4<T>(T) where for<'a> T: ?Trait<'a>;
    = note: in this context, relaxed bounds are only allowed on type parameters defined by the closest item
 
 error: this relaxed bound is not permitted here
-  --> $DIR/relaxed-bounds-invalid-places.rs:23:21
+  --> $DIR/relaxed-bounds-invalid-places.rs:22:21
    |
 LL |     fn f() where T: ?Sized {}
    |                     ^^^^^^
@@ -39,7 +39,7 @@ LL |     fn f() where T: ?Sized {}
    = note: in this context, relaxed bounds are only allowed on type parameters defined by the closest item
 
 error: relaxed bounds are not permitted in supertrait bounds
-  --> $DIR/relaxed-bounds-invalid-places.rs:26:11
+  --> $DIR/relaxed-bounds-invalid-places.rs:25:11
    |
 LL | trait Tr: ?Sized {}
    |           ^^^^^^
@@ -47,19 +47,19 @@ LL | trait Tr: ?Sized {}
    = note: traits are `?Sized` by default
 
 error: relaxed bounds are not permitted in trait object types
-  --> $DIR/relaxed-bounds-invalid-places.rs:30:20
+  --> $DIR/relaxed-bounds-invalid-places.rs:29:20
    |
 LL | type O1 = dyn Tr + ?Sized;
    |                    ^^^^^^
 
 error: relaxed bounds are not permitted in trait object types
-  --> $DIR/relaxed-bounds-invalid-places.rs:31:15
+  --> $DIR/relaxed-bounds-invalid-places.rs:30:15
    |
 LL | type O2 = dyn ?Sized + ?Sized + Tr;
    |               ^^^^^^
 
 error: relaxed bounds are not permitted in trait object types
-  --> $DIR/relaxed-bounds-invalid-places.rs:31:24
+  --> $DIR/relaxed-bounds-invalid-places.rs:30:24
    |
 LL | type O2 = dyn ?Sized + ?Sized + Tr;
    |                        ^^^^^^
@@ -70,21 +70,11 @@ error: bound modifier `?` can only be applied to `Sized`
 LL | struct S4<T>(T) where for<'a> T: ?Trait<'a>;
    |                                  ^^^^^^^^^^
 
-error[E0203]: type parameter has more than one relaxed default bound, only one is supported
-  --> $DIR/relaxed-bounds-invalid-places.rs:18:33
-   |
-LL | struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
-   |                                 ^^^^^^^^^^^^^^^   ^^^^^^
-   |
-   = help: add `#![feature(more_maybe_bounds)]` 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: bound modifier `?` can only be applied to `Sized`
   --> $DIR/relaxed-bounds-invalid-places.rs:18:33
    |
 LL | struct S5<T>(*const T) where T: ?Trait<'static> + ?Sized;
    |                                 ^^^^^^^^^^^^^^^
 
-error: aborting due to 12 previous errors
+error: aborting due to 11 previous errors
 
-For more information about this error, try `rustc --explain E0203`.
-- 
cgit 1.4.1-3-g733a5


From 82a02aefe07092c737c852daccebf49ca25507e3 Mon Sep 17 00:00:00 2001
From: León Orell Valerian Liehr <me@fmease.dev>
Date: Fri, 20 Jun 2025 23:13:11 +0200
Subject: HIR ty lowering: Validate `PointeeSized` bounds

---
 compiler/rustc_hir_analysis/messages.ftl           |  2 -
 compiler/rustc_hir_analysis/src/errors.rs          |  7 --
 .../src/hir_ty_lowering/bounds.rs                  | 36 ++--------
 .../src/hir_ty_lowering/dyn_compatibility.rs       |  8 ---
 .../src/hir_ty_lowering/errors.rs                  |  6 +-
 .../rustc_hir_analysis/src/hir_ty_lowering/mod.rs  | 49 +++++++-------
 tests/ui/sized-hierarchy/pointee-validation.rs     | 20 ++++++
 tests/ui/sized-hierarchy/pointee-validation.stderr | 76 ++++++++++++++++++++++
 .../ui/sized-hierarchy/reject-dyn-pointeesized.rs  |  4 +-
 .../sized-hierarchy/reject-dyn-pointeesized.stderr |  5 +-
 10 files changed, 135 insertions(+), 78 deletions(-)
 create mode 100644 tests/ui/sized-hierarchy/pointee-validation.rs
 create mode 100644 tests/ui/sized-hierarchy/pointee-validation.stderr

diff --git a/compiler/rustc_hir_analysis/messages.ftl b/compiler/rustc_hir_analysis/messages.ftl
index 90cb1727034..7f55f9b2303 100644
--- a/compiler/rustc_hir_analysis/messages.ftl
+++ b/compiler/rustc_hir_analysis/messages.ftl
@@ -445,8 +445,6 @@ hir_analysis_parenthesized_fn_trait_expansion =
 hir_analysis_placeholder_not_allowed_item_signatures = the placeholder `_` is not allowed within types on item signatures for {$kind}
     .label = not allowed in type signatures
 
-hir_analysis_pointee_sized_trait_object = `PointeeSized` cannot be used with trait objects
-
 hir_analysis_precise_capture_self_alias = `Self` can't be captured in `use<...>` precise captures list, since it is an alias
     .label = `Self` is not a generic argument, but an alias to the type of the {$what}
 
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index 3283ce95ee0..5e75a42e824 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -311,13 +311,6 @@ pub(crate) struct TraitObjectDeclaredWithNoTraits {
     pub trait_alias_span: Option<Span>,
 }
 
-#[derive(Diagnostic)]
-#[diag(hir_analysis_pointee_sized_trait_object)]
-pub(crate) struct PointeeSizedTraitObject {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(hir_analysis_ambiguous_lifetime_bound, code = E0227)]
 pub(crate) struct AmbiguousLifetimeBound {
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
index dbd22fabab8..d7a827c649d 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -6,7 +6,7 @@ use rustc_errors::struct_span_code_err;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
-use rustc_hir::{AmbigArg, LangItem, PolyTraitRef};
+use rustc_hir::{AmbigArg, PolyTraitRef};
 use rustc_middle::bug;
 use rustc_middle::ty::{
     self as ty, IsSuggestable, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
@@ -124,13 +124,13 @@ fn collect_sizedness_bounds<'tcx>(
     self_ty_where_predicates: Option<(LocalDefId, &'tcx [hir::WherePredicate<'tcx>])>,
     span: Span,
 ) -> CollectedSizednessBounds {
-    let sized_did = tcx.require_lang_item(LangItem::Sized, span);
+    let sized_did = tcx.require_lang_item(hir::LangItem::Sized, span);
     let sized = collect_bounds(hir_bounds, self_ty_where_predicates, sized_did);
 
-    let meta_sized_did = tcx.require_lang_item(LangItem::MetaSized, span);
+    let meta_sized_did = tcx.require_lang_item(hir::LangItem::MetaSized, span);
     let meta_sized = collect_bounds(hir_bounds, self_ty_where_predicates, meta_sized_did);
 
-    let pointee_sized_did = tcx.require_lang_item(LangItem::PointeeSized, span);
+    let pointee_sized_did = tcx.require_lang_item(hir::LangItem::PointeeSized, span);
     let pointee_sized = collect_bounds(hir_bounds, self_ty_where_predicates, pointee_sized_did);
 
     CollectedSizednessBounds { sized, meta_sized, pointee_sized }
@@ -151,24 +151,6 @@ fn add_trait_bound<'tcx>(
 }
 
 impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
-    /// Skip `PointeeSized` bounds.
-    ///
-    /// `PointeeSized` is a "fake bound" insofar as anywhere a `PointeeSized` bound exists, there
-    /// is actually the absence of any bounds. This avoids limitations around non-global where
-    /// clauses being preferred over item bounds (where `PointeeSized` bounds would be
-    /// proven) - which can result in errors when a `PointeeSized` supertrait/bound/predicate is
-    /// added to some items.
-    pub(crate) fn should_skip_sizedness_bound<'hir>(
-        &self,
-        bound: &'hir hir::GenericBound<'tcx>,
-    ) -> bool {
-        bound
-            .trait_ref()
-            .and_then(|tr| tr.trait_def_id())
-            .map(|did| self.tcx().is_lang_item(did, LangItem::PointeeSized))
-            .unwrap_or(false)
-    }
-
     /// Adds sizedness bounds to a trait, trait alias, parameter, opaque type or associated type.
     ///
     /// - On parameters, opaque type and associated types, add default `Sized` bound if no explicit
@@ -193,8 +175,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             return;
         }
 
-        let meta_sized_did = tcx.require_lang_item(LangItem::MetaSized, span);
-        let pointee_sized_did = tcx.require_lang_item(LangItem::PointeeSized, span);
+        let meta_sized_did = tcx.require_lang_item(hir::LangItem::MetaSized, span);
+        let pointee_sized_did = tcx.require_lang_item(hir::LangItem::PointeeSized, span);
 
         // If adding sizedness bounds to a trait, then there are some relevant early exits
         if let Some(trait_did) = trait_did {
@@ -244,7 +226,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             } else {
                 // If there are no explicit sizedness bounds on a parameter then add a default
                 // `Sized` bound.
-                let sized_did = tcx.require_lang_item(LangItem::Sized, span);
+                let sized_did = tcx.require_lang_item(hir::LangItem::Sized, span);
                 add_trait_bound(tcx, bounds, self_ty, sized_did, span);
             }
         }
@@ -476,10 +458,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         'tcx: 'hir,
     {
         for hir_bound in hir_bounds {
-            if self.should_skip_sizedness_bound(hir_bound) {
-                continue;
-            }
-
             // In order to avoid cycles, when we're lowering `SelfTraitThatDefines`,
             // we skip over any traits that don't define the given associated type.
             if let PredicateFilter::SelfTraitThatDefines(assoc_ident) = predicate_filter {
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
index 813353c12aa..76bb59e3f09 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
@@ -2,7 +2,6 @@ use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::struct_span_code_err;
 use rustc_hir as hir;
-use rustc_hir::LangItem;
 use rustc_hir::def::{DefKind, Res};
 use rustc_lint_defs::builtin::UNUSED_ASSOCIATED_TYPE_BOUNDS;
 use rustc_middle::ty::elaborate::ClauseWithSupertraitSpan;
@@ -70,13 +69,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             let guar = self.report_trait_object_addition_traits(&regular_traits);
             return Ty::new_error(tcx, guar);
         }
-        // We don't support `PointeeSized` principals
-        let pointee_sized_did = tcx.require_lang_item(LangItem::PointeeSized, span);
-        if regular_traits.iter().any(|(pred, _)| pred.def_id() == pointee_sized_did) {
-            let guar = self.report_pointee_sized_trait_object(span);
-            return Ty::new_error(tcx, guar);
-        }
-
         // Don't create a dyn trait if we have errors in the principal.
         if let Err(guar) = regular_traits.error_reported() {
             return Ty::new_error(tcx, guar);
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
index 3db78db931a..287a5532f01 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -29,7 +29,7 @@ use tracing::debug;
 use super::InherentAssocCandidate;
 use crate::errors::{
     self, AssocItemConstraintsNotAllowedHere, ManualImplementation, MissingTypeParams,
-    ParenthesizedFnTraitExpansion, PointeeSizedTraitObject, TraitObjectDeclaredWithNoTraits,
+    ParenthesizedFnTraitExpansion, TraitObjectDeclaredWithNoTraits,
 };
 use crate::fluent_generated as fluent;
 use crate::hir_ty_lowering::{AssocItemQSelf, HirTyLowerer};
@@ -1405,10 +1405,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         self.dcx().emit_err(TraitObjectDeclaredWithNoTraits { span, trait_alias_span })
     }
-
-    pub(super) fn report_pointee_sized_trait_object(&self, span: Span) -> ErrorGuaranteed {
-        self.dcx().emit_err(PointeeSizedTraitObject { span })
-    }
 }
 
 /// Emit an error for the given associated item constraint.
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 5521f97059b..78794cd8eb6 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -755,6 +755,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         bounds: &mut Vec<(ty::Clause<'tcx>, Span)>,
         predicate_filter: PredicateFilter,
     ) -> GenericArgCountResult {
+        let tcx = self.tcx();
+
         // We use the *resolved* bound vars later instead of the HIR ones since the former
         // also include the bound vars of the overarching predicate if applicable.
         let hir::PolyTraitRef { bound_generic_params: _, modifiers, ref trait_ref, span } =
@@ -762,6 +764,29 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let hir::TraitBoundModifiers { constness, polarity } = modifiers;
 
         let trait_def_id = trait_ref.trait_def_id().unwrap_or_else(|| FatalError.raise());
+
+        // Relaxed bounds `?Trait` and `PointeeSized` bounds aren't represented in the `middle::ty` IR
+        // as they denote the *absence* of a default bound. However, we can't bail out early here since
+        // we still need to perform several validation steps (see below). Instead, simply "pour" all
+        // resulting bounds "down the drain", i.e., into a new `Vec` that just gets dropped at the end.
+        let (polarity, bounds) = match polarity {
+            rustc_ast::BoundPolarity::Positive
+                if tcx.is_lang_item(trait_def_id, hir::LangItem::PointeeSized) =>
+            {
+                // To elaborate on the comment directly above, regarding `PointeeSized` specifically,
+                // we don't "reify" such bounds to avoid trait system limitations -- namely,
+                // non-global where-clauses being preferred over item bounds (where `PointeeSized`
+                // bounds would be proven) -- which can result in errors when a `PointeeSized`
+                // supertrait / bound / predicate is added to some items.
+                (ty::PredicatePolarity::Positive, &mut Vec::new())
+            }
+            rustc_ast::BoundPolarity::Positive => (ty::PredicatePolarity::Positive, bounds),
+            rustc_ast::BoundPolarity::Negative(_) => (ty::PredicatePolarity::Negative, bounds),
+            rustc_ast::BoundPolarity::Maybe(_) => {
+                (ty::PredicatePolarity::Positive, &mut Vec::new())
+            }
+        };
+
         let trait_segment = trait_ref.path.segments.last().unwrap();
 
         let _ = self.prohibit_generic_args(
@@ -778,7 +803,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             Some(self_ty),
         );
 
-        let tcx = self.tcx();
         let bound_vars = tcx.late_bound_vars(trait_ref.hir_ref_id);
         debug!(?bound_vars);
 
@@ -789,27 +813,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         debug!(?poly_trait_ref);
 
-        let polarity = match polarity {
-            rustc_ast::BoundPolarity::Positive => ty::PredicatePolarity::Positive,
-            rustc_ast::BoundPolarity::Negative(_) => ty::PredicatePolarity::Negative,
-            rustc_ast::BoundPolarity::Maybe(_) => {
-                // Validate associated type at least. We may want to reject these
-                // outright in the future...
-                for constraint in trait_segment.args().constraints {
-                    let _ = self.lower_assoc_item_constraint(
-                        trait_ref.hir_ref_id,
-                        poly_trait_ref,
-                        constraint,
-                        &mut Default::default(),
-                        &mut Default::default(),
-                        constraint.span,
-                        predicate_filter,
-                    );
-                }
-                return arg_count;
-            }
-        };
-
         // We deal with const conditions later.
         match predicate_filter {
             PredicateFilter::All
@@ -912,7 +915,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             // Don't register any associated item constraints for negative bounds,
             // since we should have emitted an error for them earlier, and they
             // would not be well-formed!
-            if polarity != ty::PredicatePolarity::Positive {
+            if polarity == ty::PredicatePolarity::Negative {
                 self.dcx().span_delayed_bug(
                     constraint.span,
                     "negative trait bounds should not have assoc item constraints",
diff --git a/tests/ui/sized-hierarchy/pointee-validation.rs b/tests/ui/sized-hierarchy/pointee-validation.rs
new file mode 100644
index 00000000000..dfc28829e08
--- /dev/null
+++ b/tests/ui/sized-hierarchy/pointee-validation.rs
@@ -0,0 +1,20 @@
+// Test that despite us dropping `PointeeSized` bounds during HIR ty lowering
+// we still validate it first.
+// issue: <https://github.com/rust-lang/rust/issues/142718>
+#![feature(sized_hierarchy)]
+
+use std::marker::PointeeSized;
+
+struct T where (): PointeeSized<(), Undefined = ()>;
+//~^ ERROR trait takes 0 generic arguments but 1 generic argument was supplied
+//~| ERROR associated type `Undefined` not found for `PointeeSized`
+
+const fn test<T, U>() where T: const PointeeSized, U: [const] PointeeSized {}
+//~^ ERROR `const` can only be applied to `const` traits
+//~| ERROR `const` can only be applied to `const` traits
+//~| ERROR const trait impls are experimental
+//~| ERROR `[const]` can only be applied to `const` traits
+//~| ERROR `[const]` can only be applied to `const` traits
+//~| ERROR const trait impls are experimental
+
+fn main() {}
diff --git a/tests/ui/sized-hierarchy/pointee-validation.stderr b/tests/ui/sized-hierarchy/pointee-validation.stderr
new file mode 100644
index 00000000000..a056d548356
--- /dev/null
+++ b/tests/ui/sized-hierarchy/pointee-validation.stderr
@@ -0,0 +1,76 @@
+error[E0658]: const trait impls are experimental
+  --> $DIR/pointee-validation.rs:12:32
+   |
+LL | const fn test<T, U>() where T: const PointeeSized, U: [const] PointeeSized {}
+   |                                ^^^^^
+   |
+   = 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[E0658]: const trait impls are experimental
+  --> $DIR/pointee-validation.rs:12:55
+   |
+LL | const fn test<T, U>() where T: const PointeeSized, U: [const] PointeeSized {}
+   |                                                       ^^^^^^^
+   |
+   = 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[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied
+  --> $DIR/pointee-validation.rs:8:20
+   |
+LL | struct T where (): PointeeSized<(), Undefined = ()>;
+   |                    ^^^^^^^^^^^^-------------------- help: remove the unnecessary generics
+   |                    |
+   |                    expected 0 generic arguments
+
+error[E0220]: associated type `Undefined` not found for `PointeeSized`
+  --> $DIR/pointee-validation.rs:8:37
+   |
+LL | struct T where (): PointeeSized<(), Undefined = ()>;
+   |                                     ^^^^^^^^^ associated type `Undefined` not found
+
+error: `const` can only be applied to `const` traits
+  --> $DIR/pointee-validation.rs:12:32
+   |
+LL | const fn test<T, U>() where T: const PointeeSized, U: [const] PointeeSized {}
+   |                                ^^^^^ can't be applied to `PointeeSized`
+   |
+note: `PointeeSized` can't be used with `const` because it isn't `const`
+  --> $SRC_DIR/core/src/marker.rs:LL:COL
+
+error: `[const]` can only be applied to `const` traits
+  --> $DIR/pointee-validation.rs:12:55
+   |
+LL | const fn test<T, U>() where T: const PointeeSized, U: [const] PointeeSized {}
+   |                                                       ^^^^^^^ can't be applied to `PointeeSized`
+   |
+note: `PointeeSized` can't be used with `[const]` because it isn't `const`
+  --> $SRC_DIR/core/src/marker.rs:LL:COL
+
+error: `const` can only be applied to `const` traits
+  --> $DIR/pointee-validation.rs:12:32
+   |
+LL | const fn test<T, U>() where T: const PointeeSized, U: [const] PointeeSized {}
+   |                                ^^^^^ can't be applied to `PointeeSized`
+   |
+note: `PointeeSized` can't be used with `const` because it isn't `const`
+  --> $SRC_DIR/core/src/marker.rs:LL:COL
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: `[const]` can only be applied to `const` traits
+  --> $DIR/pointee-validation.rs:12:55
+   |
+LL | const fn test<T, U>() where T: const PointeeSized, U: [const] PointeeSized {}
+   |                                                       ^^^^^^^ can't be applied to `PointeeSized`
+   |
+note: `PointeeSized` can't be used with `[const]` because it isn't `const`
+  --> $SRC_DIR/core/src/marker.rs:LL:COL
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 8 previous errors
+
+Some errors have detailed explanations: E0107, E0220, E0658.
+For more information about an error, try `rustc --explain E0107`.
diff --git a/tests/ui/sized-hierarchy/reject-dyn-pointeesized.rs b/tests/ui/sized-hierarchy/reject-dyn-pointeesized.rs
index ece1702679d..89e4c15371d 100644
--- a/tests/ui/sized-hierarchy/reject-dyn-pointeesized.rs
+++ b/tests/ui/sized-hierarchy/reject-dyn-pointeesized.rs
@@ -3,7 +3,7 @@
 use std::marker::PointeeSized;
 
 type Foo = dyn PointeeSized;
-//~^ ERROR `PointeeSized` cannot be used with trait objects
+//~^ ERROR at least one trait is required for an object type
 
 fn foo(f: &Foo) {}
 
@@ -12,5 +12,5 @@ fn main() {
 
     let x = main;
     let y: Box<dyn PointeeSized> = x;
-//~^ ERROR `PointeeSized` cannot be used with trait objects
+//~^ ERROR at least one trait is required for an object type
 }
diff --git a/tests/ui/sized-hierarchy/reject-dyn-pointeesized.stderr b/tests/ui/sized-hierarchy/reject-dyn-pointeesized.stderr
index a833c6952fd..616b2400f86 100644
--- a/tests/ui/sized-hierarchy/reject-dyn-pointeesized.stderr
+++ b/tests/ui/sized-hierarchy/reject-dyn-pointeesized.stderr
@@ -1,10 +1,10 @@
-error: `PointeeSized` cannot be used with trait objects
+error[E0224]: at least one trait is required for an object type
   --> $DIR/reject-dyn-pointeesized.rs:5:12
    |
 LL | type Foo = dyn PointeeSized;
    |            ^^^^^^^^^^^^^^^^
 
-error: `PointeeSized` cannot be used with trait objects
+error[E0224]: at least one trait is required for an object type
   --> $DIR/reject-dyn-pointeesized.rs:14:16
    |
 LL |     let y: Box<dyn PointeeSized> = x;
@@ -12,3 +12,4 @@ LL |     let y: Box<dyn PointeeSized> = x;
 
 error: aborting due to 2 previous errors
 
+For more information about this error, try `rustc --explain E0224`.
-- 
cgit 1.4.1-3-g733a5


From eda2d0d2365d913022e9626acf9767fbf17f62e6 Mon Sep 17 00:00:00 2001
From: Yiqun Liu <ffengyu964@gmail.com>
Date: Fri, 18 Jul 2025 19:06:50 +0800
Subject: fix typos

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

diff --git a/src/doc/rustc-dev-guide/src/serialization.md b/src/doc/rustc-dev-guide/src/serialization.md
index 47667061eda..8eb37bbe20b 100644
--- a/src/doc/rustc-dev-guide/src/serialization.md
+++ b/src/doc/rustc-dev-guide/src/serialization.md
@@ -75,7 +75,7 @@ impl<D: Decoder> Decodable<D> for MyStruct {
 
 rustc has a lot of [arena allocated types].
 Deserializing these types isn't possible without access to the arena that they need to be allocated on.
-The [`TyDecoder`] and [`TyEncoder`] traits are supertraits of [`Decoder`] and [`Encoder`] that allow access to a [`TyCtxt`].
+The [`TyDecoder`] and [`TyEncoder`] traits are subtraits of [`Decoder`] and [`Encoder`] that allow access to a [`TyCtxt`].
 
 Types which contain `arena` allocated types can then bound the type parameter of their
 [`Encodable`] and [`Decodable`] implementations with these traits.
-- 
cgit 1.4.1-3-g733a5


From 466d33cb5cc79b74691db619d448f80a97baff61 Mon Sep 17 00:00:00 2001
From: LorrensP-2158466 <lorrens.pantelis@student.uhasselt.be>
Date: Tue, 15 Jul 2025 16:34:57 +0200
Subject: inline CrateLoader inside of CStore

---
 compiler/rustc_metadata/src/creader.rs            | 286 +++++++++++-----------
 compiler/rustc_resolve/src/build_reduced_graph.rs |   9 +-
 compiler/rustc_resolve/src/diagnostics.rs         |   3 +-
 compiler/rustc_resolve/src/late/diagnostics.rs    |   3 +-
 compiler/rustc_resolve/src/lib.rs                 |  26 +-
 5 files changed, 169 insertions(+), 158 deletions(-)

diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
index e65c7a68426..438eff33054 100644
--- a/compiler/rustc_metadata/src/creader.rs
+++ b/compiler/rustc_metadata/src/creader.rs
@@ -12,7 +12,6 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::owned_slice::OwnedSlice;
 use rustc_data_structures::svh::Svh;
 use rustc_data_structures::sync::{self, FreezeReadGuard, FreezeWriteGuard};
-use rustc_errors::DiagCtxtHandle;
 use rustc_expand::base::SyntaxExtension;
 use rustc_fs_util::try_canonicalize;
 use rustc_hir as hir;
@@ -23,8 +22,10 @@ use rustc_middle::bug;
 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, OptionsTargetModifiers, TargetModifier,
+    CrateType, ExtendedTargetModifierInfo, ExternLocation, Externs, OptionsTargetModifiers,
+    TargetModifier,
 };
 use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate, ExternCrateSource};
 use rustc_session::lint::{self, BuiltinLintDiag};
@@ -70,6 +71,8 @@ pub struct CStore {
 
     /// Unused externs of the crate
     unused_externs: Vec<Symbol>,
+
+    used_extern_options: FxHashSet<Symbol>,
 }
 
 impl std::fmt::Debug for CStore {
@@ -78,28 +81,6 @@ impl std::fmt::Debug for CStore {
     }
 }
 
-pub struct CrateLoader<'a, 'tcx: 'a> {
-    // Immutable configuration.
-    tcx: TyCtxt<'tcx>,
-    // Mutable output.
-    cstore: &'a mut CStore,
-    used_extern_options: &'a mut FxHashSet<Symbol>,
-}
-
-impl<'a, 'tcx> std::ops::Deref for CrateLoader<'a, 'tcx> {
-    type Target = TyCtxt<'tcx>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.tcx
-    }
-}
-
-impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
-    fn dcx(&self) -> DiagCtxtHandle<'tcx> {
-        self.tcx.dcx()
-    }
-}
-
 pub enum LoadedMacro {
     MacroDef {
         def: MacroDef,
@@ -227,8 +208,8 @@ impl CStore {
 
     fn intern_stable_crate_id<'tcx>(
         &mut self,
-        root: &CrateRoot,
         tcx: TyCtxt<'tcx>,
+        root: &CrateRoot,
     ) -> Result<TyCtxtFeed<'tcx, CrateNum>, CrateError> {
         assert_eq!(self.metas.len(), tcx.untracked().stable_crate_ids.read().len());
         let num = tcx.create_crate_num(root.stable_crate_id()).map_err(|existing| {
@@ -495,21 +476,18 @@ impl CStore {
             has_global_allocator: false,
             has_alloc_error_handler: false,
             unused_externs: Vec::new(),
+            used_extern_options: Default::default(),
         }
     }
-}
 
-impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
-    pub fn new(
-        tcx: TyCtxt<'tcx>,
-        cstore: &'a mut CStore,
-        used_extern_options: &'a mut FxHashSet<Symbol>,
-    ) -> Self {
-        CrateLoader { tcx, cstore, used_extern_options }
-    }
-
-    fn existing_match(&self, name: Symbol, hash: Option<Svh>, kind: PathKind) -> Option<CrateNum> {
-        for (cnum, data) in self.cstore.iter_crate_data() {
+    fn existing_match(
+        &self,
+        externs: &Externs,
+        name: Symbol,
+        hash: Option<Svh>,
+        kind: PathKind,
+    ) -> Option<CrateNum> {
+        for (cnum, data) in self.iter_crate_data() {
             if data.name() != name {
                 trace!("{} did not match {}", data.name(), name);
                 continue;
@@ -533,8 +511,8 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             // We're also sure to compare *paths*, not actual byte slices. The
             // `source` stores paths which are normalized which may be different
             // from the strings on the command line.
-            let source = self.cstore.get_crate_data(cnum).cdata.source();
-            if let Some(entry) = self.sess.opts.externs.get(name.as_str()) {
+            let source = self.get_crate_data(cnum).cdata.source();
+            if let Some(entry) = externs.get(name.as_str()) {
                 // Only use `--extern crate_name=path` here, not `--extern crate_name`.
                 if let Some(mut files) = entry.files() {
                     if files.any(|l| {
@@ -587,6 +565,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
     /// command parameter is set to `public-dependency`
     fn is_private_dep(
         &self,
+        externs: &Externs,
         name: Symbol,
         private_dep: Option<bool>,
         origin: CrateOrigin<'_>,
@@ -595,7 +574,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             return true;
         }
 
-        let extern_private = self.sess.opts.externs.get(name.as_str()).map(|e| e.is_private_dep);
+        let extern_private = externs.get(name.as_str()).map(|e| e.is_private_dep);
         match (extern_private, private_dep) {
             // Explicit non-private via `--extern`, explicit non-private from metadata, or
             // unspecified with default to public.
@@ -605,8 +584,9 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         }
     }
 
-    fn register_crate(
+    fn register_crate<'tcx>(
         &mut self,
+        tcx: TyCtxt<'tcx>,
         host_lib: Option<Library>,
         origin: CrateOrigin<'_>,
         lib: Library,
@@ -615,15 +595,15 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         private_dep: Option<bool>,
     ) -> Result<CrateNum, CrateError> {
         let _prof_timer =
-            self.sess.prof.generic_activity_with_arg("metadata_register_crate", name.as_str());
+            tcx.sess.prof.generic_activity_with_arg("metadata_register_crate", name.as_str());
 
         let Library { source, metadata } = lib;
         let crate_root = metadata.get_root();
         let host_hash = host_lib.as_ref().map(|lib| lib.metadata.get_root().hash());
-        let private_dep = self.is_private_dep(name, private_dep, origin);
+        let private_dep = self.is_private_dep(&tcx.sess.opts.externs, name, private_dep, origin);
 
         // Claim this crate number and cache it
-        let feed = self.cstore.intern_stable_crate_id(&crate_root, self.tcx)?;
+        let feed = self.intern_stable_crate_id(tcx, &crate_root)?;
         let cnum = feed.key();
 
         info!(
@@ -643,8 +623,15 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             &crate_paths
         };
 
-        let cnum_map =
-            self.resolve_crate_deps(dep_root, &crate_root, &metadata, cnum, dep_kind, private_dep)?;
+        let cnum_map = self.resolve_crate_deps(
+            tcx,
+            dep_root,
+            &crate_root,
+            &metadata,
+            cnum,
+            dep_kind,
+            private_dep,
+        )?;
 
         let raw_proc_macros = if crate_root.is_proc_macro_crate() {
             let temp_root;
@@ -656,14 +643,14 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                 None => (&source, &crate_root),
             };
             let dlsym_dylib = dlsym_source.dylib.as_ref().expect("no dylib for a proc-macro crate");
-            Some(self.dlsym_proc_macros(&dlsym_dylib.0, dlsym_root.stable_crate_id())?)
+            Some(self.dlsym_proc_macros(tcx.sess, &dlsym_dylib.0, dlsym_root.stable_crate_id())?)
         } else {
             None
         };
 
         let crate_metadata = CrateMetadata::new(
-            self.sess,
-            self.cstore,
+            tcx.sess,
+            self,
             metadata,
             crate_root,
             raw_proc_macros,
@@ -675,13 +662,14 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             host_hash,
         );
 
-        self.cstore.set_crate_data(cnum, crate_metadata);
+        self.set_crate_data(cnum, crate_metadata);
 
         Ok(cnum)
     }
 
-    fn load_proc_macro<'b>(
+    fn load_proc_macro<'a, 'b>(
         &self,
+        sess: &'a Session,
         locator: &mut CrateLocator<'b>,
         crate_rejections: &mut CrateRejections,
         path_kind: PathKind,
@@ -690,13 +678,13 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
     where
         'a: 'b,
     {
-        if self.sess.opts.unstable_opts.dual_proc_macros {
+        if sess.opts.unstable_opts.dual_proc_macros {
             // Use a new crate locator and crate rejections so trying to load a proc macro doesn't
             // affect the error message we emit
             let mut proc_macro_locator = locator.clone();
 
             // Try to load a proc macro
-            proc_macro_locator.for_target_proc_macro(self.sess, path_kind);
+            proc_macro_locator.for_target_proc_macro(sess, path_kind);
 
             // Load the proc macro crate for the target
             let target_result =
@@ -713,7 +701,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             *crate_rejections = CrateRejections::default();
 
             // Load the proc macro crate for the host
-            locator.for_proc_macro(self.sess, path_kind);
+            locator.for_proc_macro(sess, path_kind);
 
             locator.hash = host_hash;
 
@@ -734,7 +722,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             let mut proc_macro_locator = locator.clone();
 
             // Load the proc macro crate for the host
-            proc_macro_locator.for_proc_macro(self.sess, path_kind);
+            proc_macro_locator.for_proc_macro(sess, path_kind);
 
             let Some(host_result) =
                 self.load(&mut proc_macro_locator, &mut CrateRejections::default())?
@@ -746,32 +734,39 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         }
     }
 
-    fn resolve_crate(
+    fn resolve_crate<'tcx>(
         &mut self,
+        tcx: TyCtxt<'tcx>,
         name: Symbol,
         span: Span,
         dep_kind: CrateDepKind,
         origin: CrateOrigin<'_>,
     ) -> Option<CrateNum> {
         self.used_extern_options.insert(name);
-        match self.maybe_resolve_crate(name, dep_kind, origin) {
+        match self.maybe_resolve_crate(tcx, name, dep_kind, origin) {
             Ok(cnum) => {
-                self.cstore.set_used_recursively(cnum);
+                self.set_used_recursively(cnum);
                 Some(cnum)
             }
             Err(err) => {
                 debug!("failed to resolve crate {} {:?}", name, dep_kind);
                 let missing_core = self
-                    .maybe_resolve_crate(sym::core, CrateDepKind::Explicit, CrateOrigin::Extern)
+                    .maybe_resolve_crate(
+                        tcx,
+                        sym::core,
+                        CrateDepKind::Explicit,
+                        CrateOrigin::Extern,
+                    )
                     .is_err();
-                err.report(self.sess, span, missing_core);
+                err.report(tcx.sess, span, missing_core);
                 None
             }
         }
     }
 
-    fn maybe_resolve_crate<'b>(
+    fn maybe_resolve_crate<'b, 'tcx>(
         &'b mut self,
+        tcx: TyCtxt<'tcx>,
         name: Symbol,
         mut dep_kind: CrateDepKind,
         origin: CrateOrigin<'b>,
@@ -789,17 +784,19 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         let path_kind = if dep.is_some() { PathKind::Dependency } else { PathKind::Crate };
         let private_dep = origin.private_dep();
 
-        let result = if let Some(cnum) = self.existing_match(name, hash, path_kind) {
+        let result = if let Some(cnum) =
+            self.existing_match(&tcx.sess.opts.externs, name, hash, path_kind)
+        {
             (LoadResult::Previous(cnum), None)
         } else {
             info!("falling back to a load");
             let mut locator = CrateLocator::new(
-                self.sess,
-                &*self.cstore.metadata_loader,
+                tcx.sess,
+                &*self.metadata_loader,
                 name,
                 // The all loop is because `--crate-type=rlib --crate-type=rlib` is
                 // legal and produces both inside this type.
-                self.tcx.crate_types().iter().all(|c| *c == CrateType::Rlib),
+                tcx.crate_types().iter().all(|c| *c == CrateType::Rlib),
                 hash,
                 extra_filename,
                 path_kind,
@@ -812,6 +809,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                     info!("falling back to loading proc_macro");
                     dep_kind = CrateDepKind::MacrosOnly;
                     match self.load_proc_macro(
+                        tcx.sess,
                         &mut locator,
                         &mut crate_rejections,
                         path_kind,
@@ -831,8 +829,9 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                 // not specified by `--extern` on command line parameters, it may be
                 // `private-dependency` when `register_crate` is called for the first time. Then it must be updated to
                 // `public-dependency` here.
-                let private_dep = self.is_private_dep(name, private_dep, origin);
-                let data = self.cstore.get_crate_data_mut(cnum);
+                let private_dep =
+                    self.is_private_dep(&tcx.sess.opts.externs, name, private_dep, origin);
+                let data = self.get_crate_data_mut(cnum);
                 if data.is_proc_macro_crate() {
                     dep_kind = CrateDepKind::MacrosOnly;
                 }
@@ -842,7 +841,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             }
             (LoadResult::Loaded(library), host_library) => {
                 info!("register newly loaded library for `{}`", name);
-                self.register_crate(host_library, origin, library, dep_kind, name, private_dep)
+                self.register_crate(tcx, host_library, origin, library, dep_kind, name, private_dep)
             }
             _ => panic!(),
         }
@@ -863,7 +862,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         // duplicates by just using the first crate.
         let root = library.metadata.get_root();
         let mut result = LoadResult::Loaded(library);
-        for (cnum, data) in self.cstore.iter_crate_data() {
+        for (cnum, data) in self.iter_crate_data() {
             if data.name() == root.name() && root.hash() == data.hash() {
                 assert!(locator.hash.is_none());
                 info!("load success, going to previous cnum: {}", cnum);
@@ -877,6 +876,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
     /// Go through the crate metadata and load any crates that it references.
     fn resolve_crate_deps(
         &mut self,
+        tcx: TyCtxt<'_>,
         dep_root: &CratePaths,
         crate_root: &CrateRoot,
         metadata: &MetadataBlob,
@@ -913,6 +913,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                 _ => dep.kind,
             };
             let cnum = self.maybe_resolve_crate(
+                tcx,
                 dep.name,
                 dep_kind,
                 CrateOrigin::IndirectDependency {
@@ -930,10 +931,11 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
 
     fn dlsym_proc_macros(
         &self,
+        sess: &Session,
         path: &Path,
         stable_crate_id: StableCrateId,
     ) -> Result<&'static [ProcMacro], CrateError> {
-        let sym_name = self.sess.generate_proc_macro_decls_symbol(stable_crate_id);
+        let sym_name = sess.generate_proc_macro_decls_symbol(stable_crate_id);
         debug!("trying to dlsym proc_macros {} for symbol `{}`", path.display(), sym_name);
 
         unsafe {
@@ -955,10 +957,10 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         }
     }
 
-    fn inject_panic_runtime(&mut self, krate: &ast::Crate) {
+    fn inject_panic_runtime(&mut self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
         // If we're only compiling an rlib, then there's no need to select a
         // panic runtime, so we just skip this section entirely.
-        let only_rlib = self.tcx.crate_types().iter().all(|ct| *ct == CrateType::Rlib);
+        let only_rlib = tcx.crate_types().iter().all(|ct| *ct == CrateType::Rlib);
         if only_rlib {
             info!("panic runtime injection skipped, only generating rlib");
             return;
@@ -968,7 +970,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         // the same time we perform some general validation of the DAG we've got
         // going such as ensuring everything has a compatible panic strategy.
         let mut needs_panic_runtime = attr::contains_name(&krate.attrs, sym::needs_panic_runtime);
-        for (_cnum, data) in self.cstore.iter_crate_data() {
+        for (_cnum, data) in self.iter_crate_data() {
             needs_panic_runtime |= data.needs_panic_runtime();
         }
 
@@ -987,7 +989,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         // Also note that we have yet to perform validation of the crate graph
         // in terms of everyone has a compatible panic runtime format, that's
         // performed later as part of the `dependency_format` module.
-        let desired_strategy = self.sess.panic_strategy();
+        let desired_strategy = tcx.sess.panic_strategy();
         let name = match desired_strategy {
             PanicStrategy::Unwind => sym::panic_unwind,
             PanicStrategy::Abort => sym::panic_abort,
@@ -995,64 +997,64 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         info!("panic runtime not found -- loading {}", name);
 
         let Some(cnum) =
-            self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected)
+            self.resolve_crate(tcx, name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected)
         else {
             return;
         };
-        let data = self.cstore.get_crate_data(cnum);
+        let data = self.get_crate_data(cnum);
 
         // Sanity check the loaded crate to ensure it is indeed a panic runtime
         // and the panic strategy is indeed what we thought it was.
         if !data.is_panic_runtime() {
-            self.dcx().emit_err(errors::CrateNotPanicRuntime { crate_name: name });
+            tcx.dcx().emit_err(errors::CrateNotPanicRuntime { crate_name: name });
         }
         if data.required_panic_strategy() != Some(desired_strategy) {
-            self.dcx()
+            tcx.dcx()
                 .emit_err(errors::NoPanicStrategy { crate_name: name, strategy: desired_strategy });
         }
 
-        self.cstore.injected_panic_runtime = Some(cnum);
+        self.injected_panic_runtime = Some(cnum);
     }
 
-    fn inject_profiler_runtime(&mut self) {
+    fn inject_profiler_runtime(&mut self, tcx: TyCtxt<'_>) {
         let needs_profiler_runtime =
-            self.sess.instrument_coverage() || self.sess.opts.cg.profile_generate.enabled();
-        if !needs_profiler_runtime || self.sess.opts.unstable_opts.no_profiler_runtime {
+            tcx.sess.instrument_coverage() || tcx.sess.opts.cg.profile_generate.enabled();
+        if !needs_profiler_runtime || tcx.sess.opts.unstable_opts.no_profiler_runtime {
             return;
         }
 
         info!("loading profiler");
 
-        let name = Symbol::intern(&self.sess.opts.unstable_opts.profiler_runtime);
+        let name = Symbol::intern(&tcx.sess.opts.unstable_opts.profiler_runtime);
         let Some(cnum) =
-            self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected)
+            self.resolve_crate(tcx, name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected)
         else {
             return;
         };
-        let data = self.cstore.get_crate_data(cnum);
+        let data = self.get_crate_data(cnum);
 
         // Sanity check the loaded crate to ensure it is indeed a profiler runtime
         if !data.is_profiler_runtime() {
-            self.dcx().emit_err(errors::NotProfilerRuntime { crate_name: name });
+            tcx.dcx().emit_err(errors::NotProfilerRuntime { crate_name: name });
         }
     }
 
-    fn inject_allocator_crate(&mut self, krate: &ast::Crate) {
-        self.cstore.has_global_allocator =
+    fn inject_allocator_crate(&mut self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
+        self.has_global_allocator =
             match &*fn_spans(krate, Symbol::intern(&global_fn_name(sym::alloc))) {
                 [span1, span2, ..] => {
-                    self.dcx()
+                    tcx.dcx()
                         .emit_err(errors::NoMultipleGlobalAlloc { span2: *span2, span1: *span1 });
                     true
                 }
                 spans => !spans.is_empty(),
             };
-        self.cstore.has_alloc_error_handler = match &*fn_spans(
+        self.has_alloc_error_handler = match &*fn_spans(
             krate,
             Symbol::intern(alloc_error_handler_name(AllocatorKind::Global)),
         ) {
             [span1, span2, ..] => {
-                self.dcx()
+                tcx.dcx()
                     .emit_err(errors::NoMultipleAllocErrorHandler { span2: *span2, span1: *span1 });
                 true
             }
@@ -1063,7 +1065,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         // about through the `#![needs_allocator]` attribute and is typically
         // written down in liballoc.
         if !attr::contains_name(&krate.attrs, sym::needs_allocator)
-            && !self.cstore.iter_crate_data().any(|(_, data)| data.needs_allocator())
+            && !self.iter_crate_data().any(|(_, data)| data.needs_allocator())
         {
             return;
         }
@@ -1071,7 +1073,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         // At this point we've determined that we need an allocator. Let's see
         // if our compilation session actually needs an allocator based on what
         // we're emitting.
-        let all_rlib = self.tcx.crate_types().iter().all(|ct| matches!(*ct, CrateType::Rlib));
+        let all_rlib = tcx.crate_types().iter().all(|ct| matches!(*ct, CrateType::Rlib));
         if all_rlib {
             return;
         }
@@ -1086,12 +1088,12 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         #[allow(rustc::symbol_intern_string_literal)]
         let this_crate = Symbol::intern("this crate");
 
-        let mut global_allocator = self.cstore.has_global_allocator.then_some(this_crate);
-        for (_, data) in self.cstore.iter_crate_data() {
+        let mut global_allocator = self.has_global_allocator.then_some(this_crate);
+        for (_, data) in self.iter_crate_data() {
             if data.has_global_allocator() {
                 match global_allocator {
                     Some(other_crate) => {
-                        self.dcx().emit_err(errors::ConflictingGlobalAlloc {
+                        tcx.dcx().emit_err(errors::ConflictingGlobalAlloc {
                             crate_name: data.name(),
                             other_crate_name: other_crate,
                         });
@@ -1100,12 +1102,12 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                 }
             }
         }
-        let mut alloc_error_handler = self.cstore.has_alloc_error_handler.then_some(this_crate);
-        for (_, data) in self.cstore.iter_crate_data() {
+        let mut alloc_error_handler = self.has_alloc_error_handler.then_some(this_crate);
+        for (_, data) in self.iter_crate_data() {
             if data.has_alloc_error_handler() {
                 match alloc_error_handler {
                     Some(other_crate) => {
-                        self.dcx().emit_err(errors::ConflictingAllocErrorHandler {
+                        tcx.dcx().emit_err(errors::ConflictingAllocErrorHandler {
                             crate_name: data.name(),
                             other_crate_name: other_crate,
                         });
@@ -1116,35 +1118,36 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         }
 
         if global_allocator.is_some() {
-            self.cstore.allocator_kind = Some(AllocatorKind::Global);
+            self.allocator_kind = Some(AllocatorKind::Global);
         } else {
             // Ok we haven't found a global allocator but we still need an
             // allocator. At this point our allocator request is typically fulfilled
             // by the standard library, denoted by the `#![default_lib_allocator]`
             // attribute.
             if !attr::contains_name(&krate.attrs, sym::default_lib_allocator)
-                && !self.cstore.iter_crate_data().any(|(_, data)| data.has_default_lib_allocator())
+                && !self.iter_crate_data().any(|(_, data)| data.has_default_lib_allocator())
             {
-                self.dcx().emit_err(errors::GlobalAllocRequired);
+                tcx.dcx().emit_err(errors::GlobalAllocRequired);
             }
-            self.cstore.allocator_kind = Some(AllocatorKind::Default);
+            self.allocator_kind = Some(AllocatorKind::Default);
         }
 
         if alloc_error_handler.is_some() {
-            self.cstore.alloc_error_handler_kind = Some(AllocatorKind::Global);
+            self.alloc_error_handler_kind = Some(AllocatorKind::Global);
         } else {
             // The alloc crate provides a default allocation error handler if
             // one isn't specified.
-            self.cstore.alloc_error_handler_kind = Some(AllocatorKind::Default);
+            self.alloc_error_handler_kind = Some(AllocatorKind::Default);
         }
     }
 
-    fn inject_forced_externs(&mut self) {
-        for (name, entry) in self.sess.opts.externs.iter() {
+    fn inject_forced_externs(&mut self, tcx: TyCtxt<'_>) {
+        for (name, entry) in tcx.sess.opts.externs.iter() {
             if entry.force {
                 let name_interned = Symbol::intern(name);
                 if !self.used_extern_options.contains(&name_interned) {
                     self.resolve_crate(
+                        tcx,
                         name_interned,
                         DUMMY_SP,
                         CrateDepKind::Explicit,
@@ -1156,7 +1159,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
     }
 
     /// Inject the `compiler_builtins` crate if it is not already in the graph.
-    fn inject_compiler_builtins(&mut self, krate: &ast::Crate) {
+    fn inject_compiler_builtins(&mut self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
         // `compiler_builtins` does not get extern builtins, nor do `#![no_core]` crates
         if attr::contains_name(&krate.attrs, sym::compiler_builtins)
             || attr::contains_name(&krate.attrs, sym::no_core)
@@ -1167,7 +1170,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
 
         // If a `#![compiler_builtins]` crate already exists, avoid injecting it twice. This is
         // the common case since usually it appears as a dependency of `std` or `alloc`.
-        for (cnum, cmeta) in self.cstore.iter_crate_data() {
+        for (cnum, cmeta) in self.iter_crate_data() {
             if cmeta.is_compiler_builtins() {
                 info!("`compiler_builtins` already exists (cnum = {cnum}); skipping injection");
                 return;
@@ -1176,6 +1179,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
 
         // `compiler_builtins` is not yet in the graph; inject it. Error on resolution failure.
         let Some(cnum) = self.resolve_crate(
+            tcx,
             sym::compiler_builtins,
             krate.spans.inner_span.shrink_to_lo(),
             CrateDepKind::Explicit,
@@ -1186,17 +1190,17 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         };
 
         // Sanity check that the loaded crate is `#![compiler_builtins]`
-        let cmeta = self.cstore.get_crate_data(cnum);
+        let cmeta = self.get_crate_data(cnum);
         if !cmeta.is_compiler_builtins() {
-            self.dcx().emit_err(errors::CrateNotCompilerBuiltins { crate_name: cmeta.name() });
+            tcx.dcx().emit_err(errors::CrateNotCompilerBuiltins { crate_name: cmeta.name() });
         }
     }
 
-    fn report_unused_deps(&mut self, krate: &ast::Crate) {
+    fn report_unused_deps_in_crate(&mut self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
         // Make a point span rather than covering the whole file
         let span = krate.spans.inner_span.shrink_to_lo();
         // Complain about anything left over
-        for (name, entry) in self.sess.opts.externs.iter() {
+        for (name, entry) in tcx.sess.opts.externs.iter() {
             if let ExternLocation::FoundInLibrarySearchDirectories = entry.location {
                 // Don't worry about pathless `--extern foo` sysroot references
                 continue;
@@ -1211,25 +1215,25 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             }
 
             // Got a real unused --extern
-            if self.sess.opts.json_unused_externs.is_enabled() {
-                self.cstore.unused_externs.push(name_interned);
+            if tcx.sess.opts.json_unused_externs.is_enabled() {
+                self.unused_externs.push(name_interned);
                 continue;
             }
 
-            self.sess.psess.buffer_lint(
+            tcx.sess.psess.buffer_lint(
                 lint::builtin::UNUSED_CRATE_DEPENDENCIES,
                 span,
                 ast::CRATE_NODE_ID,
                 BuiltinLintDiag::UnusedCrateDependency {
                     extern_crate: name_interned,
-                    local_crate: self.tcx.crate_name(LOCAL_CRATE),
+                    local_crate: tcx.crate_name(LOCAL_CRATE),
                 },
             );
         }
     }
 
-    fn report_future_incompatible_deps(&self, krate: &ast::Crate) {
-        let name = self.tcx.crate_name(LOCAL_CRATE);
+    fn report_future_incompatible_deps(&self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
+        let name = tcx.crate_name(LOCAL_CRATE);
 
         if name.as_str() == "wasm_bindgen" {
             let major = env::var("CARGO_PKG_VERSION_MAJOR")
@@ -1257,26 +1261,27 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             // Make a point span rather than covering the whole file
             let span = krate.spans.inner_span.shrink_to_lo();
 
-            self.sess.dcx().emit_err(errors::WasmCAbi { span });
+            tcx.sess.dcx().emit_err(errors::WasmCAbi { span });
         }
     }
 
-    pub fn postprocess(&mut self, krate: &ast::Crate) {
-        self.inject_compiler_builtins(krate);
-        self.inject_forced_externs();
-        self.inject_profiler_runtime();
-        self.inject_allocator_crate(krate);
-        self.inject_panic_runtime(krate);
+    pub fn postprocess(&mut self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
+        self.inject_compiler_builtins(tcx, krate);
+        self.inject_forced_externs(tcx);
+        self.inject_profiler_runtime(tcx);
+        self.inject_allocator_crate(tcx, krate);
+        self.inject_panic_runtime(tcx, krate);
 
-        self.report_unused_deps(krate);
-        self.report_future_incompatible_deps(krate);
+        self.report_unused_deps_in_crate(tcx, krate);
+        self.report_future_incompatible_deps(tcx, krate);
 
-        info!("{:?}", CrateDump(self.cstore));
+        info!("{:?}", CrateDump(self));
     }
 
     /// Process an `extern crate foo` AST node.
     pub fn process_extern_crate(
         &mut self,
+        tcx: TyCtxt<'_>,
         item: &ast::Item,
         def_id: LocalDefId,
         definitions: &Definitions,
@@ -1286,7 +1291,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                 debug!("resolving extern crate stmt. ident: {} orig_name: {:?}", ident, orig_name);
                 let name = match orig_name {
                     Some(orig_name) => {
-                        validate_crate_name(self.sess, orig_name, Some(item.span));
+                        validate_crate_name(tcx.sess, orig_name, Some(item.span));
                         orig_name
                     }
                     None => ident.name,
@@ -1297,10 +1302,11 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                     CrateDepKind::Explicit
                 };
 
-                let cnum = self.resolve_crate(name, item.span, dep_kind, CrateOrigin::Extern)?;
+                let cnum =
+                    self.resolve_crate(tcx, name, item.span, dep_kind, CrateOrigin::Extern)?;
 
                 let path_len = definitions.def_path(def_id).data.len();
-                self.cstore.update_extern_crate(
+                self.update_extern_crate(
                     cnum,
                     ExternCrate {
                         src: ExternCrateSource::Extern(def_id.to_def_id()),
@@ -1315,10 +1321,16 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         }
     }
 
-    pub fn process_path_extern(&mut self, name: Symbol, span: Span) -> Option<CrateNum> {
-        let cnum = self.resolve_crate(name, span, CrateDepKind::Explicit, CrateOrigin::Extern)?;
+    pub fn process_path_extern(
+        &mut self,
+        tcx: TyCtxt<'_>,
+        name: Symbol,
+        span: Span,
+    ) -> Option<CrateNum> {
+        let cnum =
+            self.resolve_crate(tcx, name, span, CrateDepKind::Explicit, CrateOrigin::Extern)?;
 
-        self.cstore.update_extern_crate(
+        self.update_extern_crate(
             cnum,
             ExternCrate {
                 src: ExternCrateSource::Path,
@@ -1332,8 +1344,8 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         Some(cnum)
     }
 
-    pub fn maybe_process_path_extern(&mut self, name: Symbol) -> Option<CrateNum> {
-        self.maybe_resolve_crate(name, CrateDepKind::Explicit, CrateOrigin::Extern).ok()
+    pub fn maybe_process_path_extern(&mut self, tcx: TyCtxt<'_>, name: Symbol) -> Option<CrateNum> {
+        self.maybe_resolve_crate(tcx, name, CrateDepKind::Explicit, CrateOrigin::Extern).ok()
     }
 }
 
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index e56aabfd414..737577baa7a 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -897,9 +897,12 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             Some(self.r.graph_root)
         } else {
             let tcx = self.r.tcx;
-            let crate_id = self.r.crate_loader(|c| {
-                c.process_extern_crate(item, local_def_id, &tcx.definitions_untracked())
-            });
+            let crate_id = self.r.cstore_mut().process_extern_crate(
+                self.r.tcx,
+                item,
+                local_def_id,
+                &tcx.definitions_untracked(),
+            );
             crate_id.map(|crate_id| {
                 self.r.extern_crate_map.insert(local_def_id, crate_id);
                 self.r.expect_module(crate_id.as_def_id())
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index f6f45adabe9..d72fbc189e7 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1425,7 +1425,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     // otherwise cause duplicate suggestions.
                     continue;
                 }
-                let Some(crate_id) = self.crate_loader(|c| c.maybe_process_path_extern(ident.name))
+                let Some(crate_id) =
+                    self.cstore_mut().maybe_process_path_extern(self.tcx, ident.name)
                 else {
                     continue;
                 };
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index ee462d90764..69095942f52 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -2485,7 +2485,8 @@ impl<'ast, 'ra, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                             let extern_prelude = self.r.extern_prelude.clone();
                             names.extend(extern_prelude.iter().flat_map(|(ident, _)| {
                                 self.r
-                                    .crate_loader(|c| c.maybe_process_path_extern(ident.name))
+                                    .cstore_mut()
+                                    .maybe_process_path_extern(self.r.tcx, ident.name)
                                     .and_then(|crate_id| {
                                         let crate_mod =
                                             Res::Def(DefKind::Mod, crate_id.as_def_id());
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index dae30b77ec1..0d41a822e8a 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -45,7 +45,7 @@ use rustc_attr_data_structures::StrippedCfgItem;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_data_structures::intern::Interned;
 use rustc_data_structures::steal::Steal;
-use rustc_data_structures::sync::FreezeReadGuard;
+use rustc_data_structures::sync::{FreezeReadGuard, FreezeWriteGuard};
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_errors::{Applicability, Diag, ErrCode, ErrorGuaranteed};
 use rustc_expand::base::{DeriveResolution, SyntaxExtension, SyntaxExtensionKind};
@@ -58,7 +58,7 @@ use rustc_hir::def_id::{CRATE_DEF_ID, CrateNum, DefId, LOCAL_CRATE, LocalDefId,
 use rustc_hir::definitions::DisambiguatorState;
 use rustc_hir::{PrimTy, TraitCandidate};
 use rustc_index::bit_set::DenseBitSet;
-use rustc_metadata::creader::{CStore, CrateLoader};
+use rustc_metadata::creader::CStore;
 use rustc_middle::metadata::ModChild;
 use rustc_middle::middle::privacy::EffectiveVisibilities;
 use rustc_middle::query::Providers;
@@ -1110,7 +1110,6 @@ pub struct Resolver<'ra, 'tcx> {
     builtin_types_bindings: FxHashMap<Symbol, NameBinding<'ra>>,
     builtin_attrs_bindings: FxHashMap<Symbol, NameBinding<'ra>>,
     registered_tool_bindings: FxHashMap<Ident, NameBinding<'ra>>,
-    used_extern_options: FxHashSet<Symbol>,
     macro_names: FxHashSet<Ident>,
     builtin_macros: FxHashMap<Symbol, SyntaxExtensionKind>,
     registered_tools: &'tcx RegisteredTools,
@@ -1546,7 +1545,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     (*ident, binding)
                 })
                 .collect(),
-            used_extern_options: Default::default(),
             macro_names: FxHashSet::default(),
             builtin_macros: Default::default(),
             registered_tools,
@@ -1733,18 +1731,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         StableHashingContext::new(self.tcx.sess, self.tcx.untracked())
     }
 
-    fn crate_loader<T>(&mut self, f: impl FnOnce(&mut CrateLoader<'_, '_>) -> T) -> T {
-        f(&mut CrateLoader::new(
-            self.tcx,
-            &mut CStore::from_tcx_mut(self.tcx),
-            &mut self.used_extern_options,
-        ))
-    }
-
     fn cstore(&self) -> FreezeReadGuard<'_, CStore> {
         CStore::from_tcx(self.tcx)
     }
 
+    fn cstore_mut(&self) -> FreezeWriteGuard<'_, CStore> {
+        CStore::from_tcx_mut(self.tcx)
+    }
+
     fn dummy_ext(&self, macro_kind: MacroKind) -> Arc<SyntaxExtension> {
         match macro_kind {
             MacroKind::Bang => Arc::clone(&self.dummy_ext_bang),
@@ -1790,7 +1784,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             self.tcx.sess.time("resolve_report_errors", || self.report_errors(krate));
             self.tcx
                 .sess
-                .time("resolve_postprocess", || self.crate_loader(|c| c.postprocess(krate)));
+                .time("resolve_postprocess", || self.cstore_mut().postprocess(self.tcx, krate));
         });
 
         // Make sure we don't mutate the cstore from here on.
@@ -2156,7 +2150,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             Some(if let Some(binding) = entry.binding {
                 if finalize {
                     if !entry.is_import() {
-                        self.crate_loader(|c| c.process_path_extern(ident.name, ident.span));
+                        self.cstore_mut().process_path_extern(self.tcx, ident.name, ident.span);
                     } else if entry.introduced_by_item {
                         self.record_use(ident, binding, Used::Other);
                     }
@@ -2165,13 +2159,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             } else {
                 let crate_id = if finalize {
                     let Some(crate_id) =
-                        self.crate_loader(|c| c.process_path_extern(ident.name, ident.span))
+                        self.cstore_mut().process_path_extern(self.tcx, ident.name, ident.span)
                     else {
                         return Some(self.dummy_binding);
                     };
                     crate_id
                 } else {
-                    self.crate_loader(|c| c.maybe_process_path_extern(ident.name))?
+                    self.cstore_mut().maybe_process_path_extern(self.tcx, ident.name)?
                 };
                 let res = Res::Def(DefKind::Mod, crate_id.as_def_id());
                 self.arenas.new_pub_res_binding(res, DUMMY_SP, LocalExpnId::ROOT)
-- 
cgit 1.4.1-3-g733a5


From a438401d05beb6d4307e4741b38c3a133de00c0d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 18 Jul 2025 13:40:11 +0200
Subject: move page protection logic inside native_lib

and ensure we don't unwind out of the "weird state" during tracing
---
 src/tools/miri/Cargo.toml                          |   5 +-
 src/tools/miri/src/alloc/isolated_alloc.rs         |  54 ++---------
 src/tools/miri/src/lib.rs                          |   1 +
 src/tools/miri/src/shims/native_lib/mod.rs         |  13 +--
 src/tools/miri/src/shims/native_lib/trace/child.rs | 101 ++++++++++++++-------
 .../miri/src/shims/native_lib/trace/messages.rs    |   3 +-
 6 files changed, 84 insertions(+), 93 deletions(-)

diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index 0aff34e9fbe..b3503acf0c0 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -38,13 +38,14 @@ features = ['unprefixed_malloc_on_supported_platforms']
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
+# native-lib dependencies
 libffi = { version = "4.0.0", optional = true }
 libloading = { version = "0.8", optional = true }
-nix = { version = "0.30.1", features = ["mman", "ptrace", "signal"], optional = true }
+serde = { version = "1.0.219", features = ["derive"], optional = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]
+nix = { version = "0.30.1", features = ["mman", "ptrace", "signal"], optional = true }
 ipc-channel = { version = "0.19.0", optional = true }
-serde = { version = "1.0.219", features = ["derive"], optional = true }
 capstone = { version = "0.13", optional = true }
 
 [dev-dependencies]
diff --git a/src/tools/miri/src/alloc/isolated_alloc.rs b/src/tools/miri/src/alloc/isolated_alloc.rs
index 7b2f1a3eebf..1745727b16b 100644
--- a/src/tools/miri/src/alloc/isolated_alloc.rs
+++ b/src/tools/miri/src/alloc/isolated_alloc.rs
@@ -1,7 +1,6 @@
 use std::alloc::Layout;
 use std::ptr::NonNull;
 
-use nix::sys::mman;
 use rustc_index::bit_set::DenseBitSet;
 
 /// How many bytes of memory each bit in the bitset represents.
@@ -44,6 +43,10 @@ impl IsolatedAlloc {
         }
     }
 
+    pub fn page_size(&self) -> usize {
+        self.page_size
+    }
+
     /// For simplicity, we serve small allocations in multiples of COMPRESSION_FACTOR
     /// bytes with at least that alignment.
     #[inline]
@@ -302,50 +305,11 @@ impl IsolatedAlloc {
         }
     }
 
-    /// Returns a list of page addresses managed by the allocator.
-    pub fn pages(&self) -> impl Iterator<Item = usize> {
-        let pages = self.page_ptrs.iter().map(|p| p.expose_provenance().get());
-        pages.chain(self.huge_ptrs.iter().flat_map(|(ptr, size)| {
-            (0..size / self.page_size)
-                .map(|i| ptr.expose_provenance().get().strict_add(i * self.page_size))
-        }))
-    }
-
-    /// Protects all owned memory as `PROT_NONE`, preventing accesses.
-    ///
-    /// SAFETY: Accessing memory after this point will result in a segfault
-    /// unless it is first unprotected.
-    pub unsafe fn start_ffi(&mut self) -> Result<(), nix::errno::Errno> {
-        let prot = mman::ProtFlags::PROT_NONE;
-        unsafe { self.mprotect(prot) }
-    }
-
-    /// Deprotects all owned memory by setting it to RW. Erroring here is very
-    /// likely unrecoverable, so it may panic if applying those permissions
-    /// fails.
-    pub fn end_ffi(&mut self) {
-        let prot = mman::ProtFlags::PROT_READ | mman::ProtFlags::PROT_WRITE;
-        unsafe {
-            self.mprotect(prot).unwrap();
-        }
-    }
-
-    /// Applies `prot` to every page managed by the allocator.
-    ///
-    /// SAFETY: Accessing memory in violation of the protection flags will
-    /// trigger a segfault.
-    unsafe fn mprotect(&mut self, prot: mman::ProtFlags) -> Result<(), nix::errno::Errno> {
-        for &pg in &self.page_ptrs {
-            unsafe {
-                mman::mprotect(pg.cast(), self.page_size, prot)?;
-            }
-        }
-        for &(hpg, size) in &self.huge_ptrs {
-            unsafe {
-                mman::mprotect(hpg.cast(), size.next_multiple_of(self.page_size), prot)?;
-            }
-        }
-        Ok(())
+    /// Returns a list of page ranges managed by the allocator, given in terms of pointers
+    /// and size (in bytes).
+    pub fn pages(&self) -> impl Iterator<Item = (NonNull<u8>, usize)> {
+        let pages = self.page_ptrs.iter().map(|&p| (p, self.page_size));
+        pages.chain(self.huge_ptrs.iter().copied())
     }
 }
 
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 0f293c0d8f7..ae70257653c 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -1,3 +1,4 @@
+#![feature(abort_unwind)]
 #![feature(cfg_select)]
 #![feature(rustc_private)]
 #![feature(float_gamma)]
diff --git a/src/tools/miri/src/shims/native_lib/mod.rs b/src/tools/miri/src/shims/native_lib/mod.rs
index fb7b1df41a4..2827ed997a7 100644
--- a/src/tools/miri/src/shims/native_lib/mod.rs
+++ b/src/tools/miri/src/shims/native_lib/mod.rs
@@ -8,6 +8,7 @@ use rustc_abi::{BackendRepr, HasDataLayout, Size};
 use rustc_middle::mir::interpret::Pointer;
 use rustc_middle::ty::{self as ty, IntTy, UintTy};
 use rustc_span::Symbol;
+use serde::{Deserialize, Serialize};
 
 #[cfg_attr(
     not(all(
@@ -23,18 +24,14 @@ use crate::*;
 
 /// The final results of an FFI trace, containing every relevant event detected
 /// by the tracer.
-#[allow(dead_code)]
-#[cfg_attr(target_os = "linux", derive(serde::Serialize, serde::Deserialize))]
-#[derive(Debug)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct MemEvents {
     /// An list of memory accesses that occurred, in the order they occurred in.
     pub acc_events: Vec<AccessEvent>,
 }
 
 /// A single memory access.
-#[allow(dead_code)]
-#[cfg_attr(target_os = "linux", derive(serde::Serialize, serde::Deserialize))]
-#[derive(Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub enum AccessEvent {
     /// A read occurred on this memory range.
     Read(AccessRange),
@@ -56,9 +53,7 @@ impl AccessEvent {
 }
 
 /// The memory touched by a given access.
-#[allow(dead_code)]
-#[cfg_attr(target_os = "linux", derive(serde::Serialize, serde::Deserialize))]
-#[derive(Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct AccessRange {
     /// The base address in memory where an access occurred.
     pub addr: usize,
diff --git a/src/tools/miri/src/shims/native_lib/trace/child.rs b/src/tools/miri/src/shims/native_lib/trace/child.rs
index de26cb0fe55..b998ba822dd 100644
--- a/src/tools/miri/src/shims/native_lib/trace/child.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/child.rs
@@ -1,8 +1,9 @@
 use std::cell::RefCell;
+use std::ptr::NonNull;
 use std::rc::Rc;
 
 use ipc_channel::ipc;
-use nix::sys::{ptrace, signal};
+use nix::sys::{mman, ptrace, signal};
 use nix::unistd;
 use rustc_const_eval::interpret::InterpResult;
 
@@ -44,6 +45,16 @@ impl Supervisor {
         SUPERVISOR.lock().unwrap().is_some()
     }
 
+    unsafe fn protect_pages(
+        pages: impl Iterator<Item = (NonNull<u8>, usize)>,
+        prot: mman::ProtFlags,
+    ) -> Result<(), nix::errno::Errno> {
+        for (pg, sz) in pages {
+            unsafe { mman::mprotect(pg.cast(), sz, prot)? };
+        }
+        Ok(())
+    }
+
     /// Performs an arbitrary FFI call, enabling tracing from the supervisor.
     /// As this locks the supervisor via a mutex, no other threads may enter FFI
     /// until this function returns.
@@ -60,47 +71,67 @@ impl Supervisor {
 
         // Get pointers to all the pages the supervisor must allow accesses in
         // and prepare the callback stack.
-        let page_ptrs = alloc.borrow().pages().collect();
+        let alloc = alloc.borrow();
+        let page_size = alloc.page_size();
+        let page_ptrs = alloc
+            .pages()
+            .flat_map(|(pg, sz)| {
+                // Convert (page, size) pair into list of pages.
+                let start = pg.expose_provenance().get();
+                (0..sz.strict_div(alloc.page_size()))
+                    .map(move |i| start.strict_add(i.strict_mul(page_size)))
+            })
+            .collect();
         let raw_stack_ptr: *mut [u8; CALLBACK_STACK_SIZE] =
             Box::leak(Box::new([0u8; CALLBACK_STACK_SIZE])).as_mut_ptr().cast();
         let stack_ptr = raw_stack_ptr.expose_provenance();
         let start_info = StartFfiInfo { page_ptrs, stack_ptr };
 
-        // SAFETY: We do not access machine memory past this point until the
-        // supervisor is ready to allow it.
-        unsafe {
-            if alloc.borrow_mut().start_ffi().is_err() {
-                // Don't mess up unwinding by maybe leaving the memory partly protected
-                alloc.borrow_mut().end_ffi();
-                panic!("Cannot protect memory for FFI call!");
+        // Unwinding might be messed up due to partly protected memory, so let's abort if something
+        // breaks inside here.
+        let res = std::panic::abort_unwind(|| {
+            // SAFETY: We do not access machine memory past this point until the
+            // supervisor is ready to allow it.
+            // FIXME: this is sketchy, as technically the memory is still in the Rust Abstract Machine,
+            // and the compiler would be allowed to reorder accesses below this block...
+            unsafe {
+                Self::protect_pages(alloc.pages(), mman::ProtFlags::PROT_NONE).unwrap();
             }
-        }
 
-        // Send over the info.
-        // NB: if we do not wait to receive a blank confirmation response, it is
-        // possible that the supervisor is alerted of the SIGSTOP *before* it has
-        // actually received the start_info, thus deadlocking! This way, we can
-        // enforce an ordering for these events.
-        sv.message_tx.send(TraceRequest::StartFfi(start_info)).unwrap();
-        sv.confirm_rx.recv().unwrap();
-        // We need to be stopped for the supervisor to be able to make certain
-        // modifications to our memory - simply waiting on the recv() doesn't
-        // count.
-        signal::raise(signal::SIGSTOP).unwrap();
-
-        let res = f();
-
-        // We can't use IPC channels here to signal that FFI mode has ended,
-        // since they might allocate memory which could get us stuck in a SIGTRAP
-        // with no easy way out! While this could be worked around, it is much
-        // simpler and more robust to simply use the signals which are left for
-        // arbitrary usage. Since this will block until we are continued by the
-        // supervisor, we can assume past this point that everything is back to
-        // normal.
-        signal::raise(signal::SIGUSR1).unwrap();
-
-        // This is safe! It just sets memory to normal expected permissions.
-        alloc.borrow_mut().end_ffi();
+            // Send over the info.
+            // NB: if we do not wait to receive a blank confirmation response, it is
+            // possible that the supervisor is alerted of the SIGSTOP *before* it has
+            // actually received the start_info, thus deadlocking! This way, we can
+            // enforce an ordering for these events.
+            sv.message_tx.send(TraceRequest::StartFfi(start_info)).unwrap();
+            sv.confirm_rx.recv().unwrap();
+            // We need to be stopped for the supervisor to be able to make certain
+            // modifications to our memory - simply waiting on the recv() doesn't
+            // count.
+            signal::raise(signal::SIGSTOP).unwrap();
+
+            let res = f();
+
+            // We can't use IPC channels here to signal that FFI mode has ended,
+            // since they might allocate memory which could get us stuck in a SIGTRAP
+            // with no easy way out! While this could be worked around, it is much
+            // simpler and more robust to simply use the signals which are left for
+            // arbitrary usage. Since this will block until we are continued by the
+            // supervisor, we can assume past this point that everything is back to
+            // normal.
+            signal::raise(signal::SIGUSR1).unwrap();
+
+            // SAFETY: We set memory back to normal, so this is safe.
+            unsafe {
+                Self::protect_pages(
+                    alloc.pages(),
+                    mman::ProtFlags::PROT_READ | mman::ProtFlags::PROT_WRITE,
+                )
+                .unwrap();
+            }
+
+            res
+        });
 
         // SAFETY: Caller upholds that this pointer was allocated as a box with
         // this type.
diff --git a/src/tools/miri/src/shims/native_lib/trace/messages.rs b/src/tools/miri/src/shims/native_lib/trace/messages.rs
index 1f9df556b57..bef6cc1b2f3 100644
--- a/src/tools/miri/src/shims/native_lib/trace/messages.rs
+++ b/src/tools/miri/src/shims/native_lib/trace/messages.rs
@@ -45,8 +45,7 @@ pub enum TraceRequest {
 /// Information needed to begin tracing.
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
 pub struct StartFfiInfo {
-    /// A vector of page addresses. These should have been automatically obtained
-    /// with `IsolatedAlloc::pages` and prepared with `IsolatedAlloc::start_ffi`.
+    /// A vector of page addresses that store the miri heap which is accessible from C.
     pub page_ptrs: Vec<usize>,
     /// The address of an allocation that can serve as a temporary stack.
     /// This should be a leaked `Box<[u8; CALLBACK_STACK_SIZE]>` cast to an int.
-- 
cgit 1.4.1-3-g733a5


From d5411f7664161a9845edc8b80f370327397e85fd Mon Sep 17 00:00:00 2001
From: Caiweiran <cai.weiran.zte.com.cn>
Date: Fri, 18 Jul 2025 12:02:43 +0000
Subject: Ignore tests/run-make/link-eh-frame-terminator/rmake.rs when
 cross-compiling

---
 tests/run-make/link-eh-frame-terminator/rmake.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/run-make/link-eh-frame-terminator/rmake.rs b/tests/run-make/link-eh-frame-terminator/rmake.rs
index 6bfae386ea1..06b77f011ec 100644
--- a/tests/run-make/link-eh-frame-terminator/rmake.rs
+++ b/tests/run-make/link-eh-frame-terminator/rmake.rs
@@ -9,6 +9,7 @@
 //@ ignore-32bit
 // Reason: the usage of a large array in the test causes an out-of-memory
 // error on 32 bit systems.
+//@ ignore-cross-compile
 
 use run_make_support::{bin_name, llvm_objdump, run, rustc};
 
-- 
cgit 1.4.1-3-g733a5


From 181c1bda0ef33c36e59628de6dd5c6ddf95f599f Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Thu, 10 Jul 2025 16:27:40 +0800
Subject: Deduplicate `unmatched_delims` in `rustc_parse` to reduce confusion

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 compiler/rustc_parse/src/lexer/diagnostics.rs        | 20 +++++++++++++-------
 compiler/rustc_parse/src/lexer/tokentrees.rs         | 15 +++++++++++++--
 tests/ui/parser/deli-ident-issue-2.rs                |  2 +-
 tests/ui/parser/deli-ident-issue-2.stderr            | 12 +++---------
 tests/ui/parser/issues/issue-104367.stderr           |  1 -
 tests/ui/parser/issues/issue-105209.rs               |  2 +-
 tests/ui/parser/issues/issue-105209.stderr           |  9 ++++-----
 tests/ui/parser/issues/issue-62973.stderr            |  6 ++----
 tests/ui/parser/issues/issue-63116.stderr            |  5 ++---
 ...-67377-invalid-syntax-in-enum-discriminant.stderr | 12 ++++--------
 .../ui/parser/issues/issue-68987-unmatch-issue-2.rs  |  2 +-
 .../parser/issues/issue-68987-unmatch-issue-2.stderr | 12 +++---------
 .../ui/parser/issues/issue-68987-unmatch-issue-3.rs  |  2 +-
 .../parser/issues/issue-68987-unmatch-issue-3.stderr | 12 +++---------
 tests/ui/parser/issues/issue-81827.stderr            |  5 ++---
 .../ui/parser/issues/unnessary-error-issue-138401.rs |  3 +--
 .../issues/unnessary-error-issue-138401.stderr       | 17 +++++------------
 tests/ui/suggestions/issue-94171.stderr              |  4 +---
 tests/ui/typeck/issue-91334.stderr                   |  5 ++---
 19 files changed, 62 insertions(+), 84 deletions(-)

diff --git a/compiler/rustc_parse/src/lexer/diagnostics.rs b/compiler/rustc_parse/src/lexer/diagnostics.rs
index 0b97d4e6993..6de001fc998 100644
--- a/compiler/rustc_parse/src/lexer/diagnostics.rs
+++ b/compiler/rustc_parse/src/lexer/diagnostics.rs
@@ -34,9 +34,12 @@ pub(super) fn same_indentation_level(sm: &SourceMap, open_sp: Span, close_sp: Sp
 
 // When we get a `)` or `]` for `{`, we should emit help message here
 // it's more friendly compared to report `unmatched error` in later phase
-fn report_missing_open_delim(err: &mut Diag<'_>, unmatched_delims: &[UnmatchedDelim]) -> bool {
+pub(super) fn report_missing_open_delim(
+    err: &mut Diag<'_>,
+    unmatched_delims: &mut Vec<UnmatchedDelim>,
+) -> bool {
     let mut reported_missing_open = false;
-    for unmatch_brace in unmatched_delims.iter() {
+    unmatched_delims.retain(|unmatch_brace| {
         if let Some(delim) = unmatch_brace.found_delim
             && matches!(delim, Delimiter::Parenthesis | Delimiter::Bracket)
         {
@@ -45,13 +48,20 @@ fn report_missing_open_delim(err: &mut Diag<'_>, unmatched_delims: &[UnmatchedDe
                 Delimiter::Bracket => "[",
                 _ => unreachable!(),
             };
+
+            if let Some(unclosed_span) = unmatch_brace.unclosed_span {
+                err.span_label(unclosed_span, "the nearest open delimiter");
+            }
             err.span_label(
                 unmatch_brace.found_span.shrink_to_lo(),
                 format!("missing open `{missed_open}` for this delimiter"),
             );
             reported_missing_open = true;
+            false
+        } else {
+            true
         }
-    }
+    });
     reported_missing_open
 }
 
@@ -61,10 +71,6 @@ pub(super) fn report_suspicious_mismatch_block(
     sm: &SourceMap,
     delim: Delimiter,
 ) {
-    if report_missing_open_delim(err, &diag_info.unmatched_delims) {
-        return;
-    }
-
     let mut matched_spans: Vec<(Span, bool)> = diag_info
         .matching_block_spans
         .iter()
diff --git a/compiler/rustc_parse/src/lexer/tokentrees.rs b/compiler/rustc_parse/src/lexer/tokentrees.rs
index fbea958dcc5..64748199f28 100644
--- a/compiler/rustc_parse/src/lexer/tokentrees.rs
+++ b/compiler/rustc_parse/src/lexer/tokentrees.rs
@@ -3,7 +3,9 @@ use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, Toke
 use rustc_ast_pretty::pprust::token_to_string;
 use rustc_errors::Diag;
 
-use super::diagnostics::{report_suspicious_mismatch_block, same_indentation_level};
+use super::diagnostics::{
+    report_missing_open_delim, report_suspicious_mismatch_block, same_indentation_level,
+};
 use super::{Lexer, UnmatchedDelim};
 
 impl<'psess, 'src> Lexer<'psess, 'src> {
@@ -244,7 +246,16 @@ impl<'psess, 'src> Lexer<'psess, 'src> {
         let msg = format!("unexpected closing delimiter: `{token_str}`");
         let mut err = self.dcx().struct_span_err(self.token.span, msg);
 
-        report_suspicious_mismatch_block(&mut err, &self.diag_info, self.psess.source_map(), delim);
+        // if there is no missing open delim, report suspicious mismatch block
+        if !report_missing_open_delim(&mut err, &mut self.diag_info.unmatched_delims) {
+            report_suspicious_mismatch_block(
+                &mut err,
+                &self.diag_info,
+                self.psess.source_map(),
+                delim,
+            );
+        }
+
         err.span_label(self.token.span, "unexpected closing delimiter");
         err
     }
diff --git a/tests/ui/parser/deli-ident-issue-2.rs b/tests/ui/parser/deli-ident-issue-2.rs
index 5394760df70..419933c68ad 100644
--- a/tests/ui/parser/deli-ident-issue-2.rs
+++ b/tests/ui/parser/deli-ident-issue-2.rs
@@ -1,6 +1,6 @@
 fn main() {
     if 1 < 2 {
-        let _a = vec!]; //~ ERROR mismatched closing delimiter
+        let _a = vec!];
     }
 } //~ ERROR unexpected closing delimiter
 
diff --git a/tests/ui/parser/deli-ident-issue-2.stderr b/tests/ui/parser/deli-ident-issue-2.stderr
index e0188cdfb4a..703cbf19626 100644
--- a/tests/ui/parser/deli-ident-issue-2.stderr
+++ b/tests/ui/parser/deli-ident-issue-2.stderr
@@ -1,19 +1,13 @@
-error: mismatched closing delimiter: `]`
-  --> $DIR/deli-ident-issue-2.rs:2:14
-   |
-LL |     if 1 < 2 {
-   |              ^ unclosed delimiter
-LL |         let _a = vec!];
-   |                      ^ mismatched closing delimiter
-
 error: unexpected closing delimiter: `}`
   --> $DIR/deli-ident-issue-2.rs:5:1
    |
+LL |     if 1 < 2 {
+   |              - the nearest open delimiter
 LL |         let _a = vec!];
    |                      - missing open `[` for this delimiter
 LL |     }
 LL | }
    | ^ unexpected closing delimiter
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-104367.stderr b/tests/ui/parser/issues/issue-104367.stderr
index c067d12e2d9..f01fa4a1265 100644
--- a/tests/ui/parser/issues/issue-104367.stderr
+++ b/tests/ui/parser/issues/issue-104367.stderr
@@ -18,7 +18,6 @@ LL |     d: [u32; {
 LL |         #![cfg] {
    |                 - unclosed delimiter
 LL |             #![w,)
-   |                  - missing open `(` for this delimiter
 LL |
    |                                                                      ^
 
diff --git a/tests/ui/parser/issues/issue-105209.rs b/tests/ui/parser/issues/issue-105209.rs
index f4e331523bf..12c902e1d80 100644
--- a/tests/ui/parser/issues/issue-105209.rs
+++ b/tests/ui/parser/issues/issue-105209.rs
@@ -1,3 +1,3 @@
 //@ compile-flags: -Zunpretty=ast-tree
 #![c={#![c[)x   //~ ERROR mismatched closing delimiter
-                //~ ERROR this file contains an unclosed delimiter
+    //~ ERROR this file contains an unclosed delimiter
diff --git a/tests/ui/parser/issues/issue-105209.stderr b/tests/ui/parser/issues/issue-105209.stderr
index 72017e4327d..75643d18029 100644
--- a/tests/ui/parser/issues/issue-105209.stderr
+++ b/tests/ui/parser/issues/issue-105209.stderr
@@ -7,16 +7,15 @@ LL | #![c={#![c[)x
    |           unclosed delimiter
 
 error: this file contains an unclosed delimiter
-  --> $DIR/issue-105209.rs:3:68
+  --> $DIR/issue-105209.rs:3:56
    |
 LL | #![c={#![c[)x
-   |   -  -  -  - missing open `(` for this delimiter
-   |   |  |  |
-   |   |  |  unclosed delimiter
+   |   -  -  - unclosed delimiter
+   |   |  |
    |   |  unclosed delimiter
    |   unclosed delimiter
 LL |
-   |                                                                   ^
+   |                                                       ^
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/parser/issues/issue-62973.stderr b/tests/ui/parser/issues/issue-62973.stderr
index ea3e2bebee4..c7fc5bc29ed 100644
--- a/tests/ui/parser/issues/issue-62973.stderr
+++ b/tests/ui/parser/issues/issue-62973.stderr
@@ -18,10 +18,8 @@ error: this file contains an unclosed delimiter
   --> $DIR/issue-62973.rs:10:2
    |
 LL | fn p() { match s { v, E { [) {) }
-   |        -         -         -  - missing open `(` for this delimiter
-   |        |         |         |
-   |        |         |         missing open `(` for this delimiter
-   |        |         unclosed delimiter
+   |        -         - unclosed delimiter
+   |        |
    |        unclosed delimiter
 LL |
 LL |
diff --git a/tests/ui/parser/issues/issue-63116.stderr b/tests/ui/parser/issues/issue-63116.stderr
index e5bad84d112..736a0ac2cf6 100644
--- a/tests/ui/parser/issues/issue-63116.stderr
+++ b/tests/ui/parser/issues/issue-63116.stderr
@@ -10,9 +10,8 @@ error: this file contains an unclosed delimiter
   --> $DIR/issue-63116.rs:4:18
    |
 LL | impl W <s(f;Y(;]
-   |          -     -^
-   |          |     |
-   |          |     missing open `[` for this delimiter
+   |          -      ^
+   |          |
    |          unclosed delimiter
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/parser/issues/issue-67377-invalid-syntax-in-enum-discriminant.stderr b/tests/ui/parser/issues/issue-67377-invalid-syntax-in-enum-discriminant.stderr
index b82b0f3255b..5301d43e2ae 100644
--- a/tests/ui/parser/issues/issue-67377-invalid-syntax-in-enum-discriminant.stderr
+++ b/tests/ui/parser/issues/issue-67377-invalid-syntax-in-enum-discriminant.stderr
@@ -28,18 +28,14 @@ LL |         V = [Vec::new; { [0].len() ].len() as isize,
 error: this file contains an unclosed delimiter
   --> $DIR/issue-67377-invalid-syntax-in-enum-discriminant.rs:23:65
    |
-LL |         V = [PhantomData; { [ () ].len() ].len() as isize,
-   |                                          - missing open `[` for this delimiter
-...
-LL |         V = [Vec::new; { [].len()  ].len() as isize,
-   |                                    - missing open `[` for this delimiter
-...
 LL | mod c {
    |       - unclosed delimiter
 LL |     enum Bug {
-LL |         V = [Vec::new; { [0].len() ].len() as isize,
-   |                                    - missing open `[` for this delimiter
+   |              - this delimiter might not be properly closed...
 ...
+LL | }
+   | - ...as it matches this but it has different indentation
+LL |
 LL | fn main() {}
    |                                                                ^
 
diff --git a/tests/ui/parser/issues/issue-68987-unmatch-issue-2.rs b/tests/ui/parser/issues/issue-68987-unmatch-issue-2.rs
index 89aaa68ba40..9b4452ed2a1 100644
--- a/tests/ui/parser/issues/issue-68987-unmatch-issue-2.rs
+++ b/tests/ui/parser/issues/issue-68987-unmatch-issue-2.rs
@@ -1,7 +1,7 @@
 // FIXME: this case need more work to fix
 // currently the TokenTree matching ')' with '{', which is not user friendly for diagnostics
 async fn obstest() -> Result<> {
-    let obs_connect = || -> Result<(), MyError) { //~ ERROR mismatched closing delimiter
+    let obs_connect = || -> Result<(), MyError) {
         async {
         }
     }
diff --git a/tests/ui/parser/issues/issue-68987-unmatch-issue-2.stderr b/tests/ui/parser/issues/issue-68987-unmatch-issue-2.stderr
index 0ecb748a0a4..c29a4ff8dbe 100644
--- a/tests/ui/parser/issues/issue-68987-unmatch-issue-2.stderr
+++ b/tests/ui/parser/issues/issue-68987-unmatch-issue-2.stderr
@@ -1,19 +1,13 @@
-error: mismatched closing delimiter: `)`
-  --> $DIR/issue-68987-unmatch-issue-2.rs:3:32
-   |
-LL | async fn obstest() -> Result<> {
-   |                                ^ unclosed delimiter
-LL |     let obs_connect = || -> Result<(), MyError) {
-   |                                               ^ mismatched closing delimiter
-
 error: unexpected closing delimiter: `}`
   --> $DIR/issue-68987-unmatch-issue-2.rs:14:1
    |
+LL | async fn obstest() -> Result<> {
+   |                                - the nearest open delimiter
 LL |     let obs_connect = || -> Result<(), MyError) {
    |                                               - missing open `(` for this delimiter
 ...
 LL | }
    | ^ unexpected closing delimiter
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-68987-unmatch-issue-3.rs b/tests/ui/parser/issues/issue-68987-unmatch-issue-3.rs
index e98df8d7c3c..e71e2730980 100644
--- a/tests/ui/parser/issues/issue-68987-unmatch-issue-3.rs
+++ b/tests/ui/parser/issues/issue-68987-unmatch-issue-3.rs
@@ -3,6 +3,6 @@ fn f(i: u32, j: u32) {
     let res = String::new();
     let mut cnt = i;
     while cnt < j {
-        write!&mut res, " "); //~ ERROR mismatched closing delimiter
+        write!&mut res, " ");
     }
 } //~ ERROR unexpected closing delimiter
diff --git a/tests/ui/parser/issues/issue-68987-unmatch-issue-3.stderr b/tests/ui/parser/issues/issue-68987-unmatch-issue-3.stderr
index dfc4407ed65..6b012af1af3 100644
--- a/tests/ui/parser/issues/issue-68987-unmatch-issue-3.stderr
+++ b/tests/ui/parser/issues/issue-68987-unmatch-issue-3.stderr
@@ -1,19 +1,13 @@
-error: mismatched closing delimiter: `)`
-  --> $DIR/issue-68987-unmatch-issue-3.rs:5:19
-   |
-LL |     while cnt < j {
-   |                   ^ unclosed delimiter
-LL |         write!&mut res, " ");
-   |                            ^ mismatched closing delimiter
-
 error: unexpected closing delimiter: `}`
   --> $DIR/issue-68987-unmatch-issue-3.rs:8:1
    |
+LL |     while cnt < j {
+   |                   - the nearest open delimiter
 LL |         write!&mut res, " ");
    |                            - missing open `(` for this delimiter
 LL |     }
 LL | }
    | ^ unexpected closing delimiter
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/issue-81827.stderr b/tests/ui/parser/issues/issue-81827.stderr
index 986ed6b7e70..9737c8c90ae 100644
--- a/tests/ui/parser/issues/issue-81827.stderr
+++ b/tests/ui/parser/issues/issue-81827.stderr
@@ -11,9 +11,8 @@ error: this file contains an unclosed delimiter
   --> $DIR/issue-81827.rs:7:27
    |
 LL | fn r()->i{0|{#[cfg(r(0{]0
-   |          -  -          - ^
-   |          |  |          |
-   |          |  |          missing open `[` for this delimiter
+   |          -  -            ^
+   |          |  |
    |          |  unclosed delimiter
    |          unclosed delimiter
 
diff --git a/tests/ui/parser/issues/unnessary-error-issue-138401.rs b/tests/ui/parser/issues/unnessary-error-issue-138401.rs
index e5e5f1ee4e9..208c516365a 100644
--- a/tests/ui/parser/issues/unnessary-error-issue-138401.rs
+++ b/tests/ui/parser/issues/unnessary-error-issue-138401.rs
@@ -1,6 +1,5 @@
 pub fn foo(x: i64) -> i64 {
-    x.abs) 
-    //~^ ERROR mismatched closing delimiter
+    x.abs)
 }
 //~^ ERROR unexpected closing delimiter: `}`
 
diff --git a/tests/ui/parser/issues/unnessary-error-issue-138401.stderr b/tests/ui/parser/issues/unnessary-error-issue-138401.stderr
index b50f77f1247..54c73b50a42 100644
--- a/tests/ui/parser/issues/unnessary-error-issue-138401.stderr
+++ b/tests/ui/parser/issues/unnessary-error-issue-138401.stderr
@@ -1,19 +1,12 @@
-error: mismatched closing delimiter: `)`
-  --> $DIR/unnessary-error-issue-138401.rs:1:27
-   |
-LL | pub fn foo(x: i64) -> i64 {
-   |                           ^ unclosed delimiter
-LL |     x.abs) 
-   |          ^ mismatched closing delimiter
-
 error: unexpected closing delimiter: `}`
-  --> $DIR/unnessary-error-issue-138401.rs:4:1
+  --> $DIR/unnessary-error-issue-138401.rs:3:1
    |
-LL |     x.abs) 
+LL | pub fn foo(x: i64) -> i64 {
+   |                           - the nearest open delimiter
+LL |     x.abs)
    |          - missing open `(` for this delimiter
-LL |
 LL | }
    | ^ unexpected closing delimiter
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/issue-94171.stderr b/tests/ui/suggestions/issue-94171.stderr
index bcbd46cd8ec..52306a2465f 100644
--- a/tests/ui/suggestions/issue-94171.stderr
+++ b/tests/ui/suggestions/issue-94171.stderr
@@ -22,9 +22,7 @@ error: this file contains an unclosed delimiter
   --> $DIR/issue-94171.rs:5:52
    |
 LL | fn L(]{match
-   |      -- unclosed delimiter
-   |      |
-   |      missing open `[` for this delimiter
+   |       - unclosed delimiter
 LL | (; {`
    | -  - unclosed delimiter
    | |
diff --git a/tests/ui/typeck/issue-91334.stderr b/tests/ui/typeck/issue-91334.stderr
index 01e34919ce6..a348e1ebf7e 100644
--- a/tests/ui/typeck/issue-91334.stderr
+++ b/tests/ui/typeck/issue-91334.stderr
@@ -11,9 +11,8 @@ error: this file contains an unclosed delimiter
   --> $DIR/issue-91334.rs:7:23
    |
 LL | fn f(){||yield(((){),
-   |       -       -    - ^
-   |       |       |    |
-   |       |       |    missing open `(` for this delimiter
+   |       -       -      ^
+   |       |       |
    |       |       unclosed delimiter
    |       unclosed delimiter
 
-- 
cgit 1.4.1-3-g733a5


From c65d3ce365ecb6d6f36b413edb591d4746f52305 Mon Sep 17 00:00:00 2001
From: Oli Scherer <github333195615777966@oli-obk.de>
Date: Thu, 3 Jul 2025 08:00:47 +0000
Subject: Generalize `unsize` and `unsize_into` destinations

---
 compiler/rustc_const_eval/src/interpret/cast.rs | 7 ++++---
 compiler/rustc_mir_transform/src/gvn.rs         | 2 +-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
index 7a73d70fc85..de4fbc7b475 100644
--- a/compiler/rustc_const_eval/src/interpret/cast.rs
+++ b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -17,6 +17,7 @@ use super::{
     throw_ub_custom,
 };
 use crate::fluent_generated as fluent;
+use crate::interpret::Writeable;
 
 impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     pub fn cast(
@@ -358,7 +359,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     fn unsize_into_ptr(
         &mut self,
         src: &OpTy<'tcx, M::Provenance>,
-        dest: &PlaceTy<'tcx, M::Provenance>,
+        dest: &impl Writeable<'tcx, M::Provenance>,
         // The pointee types
         source_ty: Ty<'tcx>,
         cast_ty: Ty<'tcx>,
@@ -455,7 +456,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         &mut self,
         src: &OpTy<'tcx, M::Provenance>,
         cast_ty: TyAndLayout<'tcx>,
-        dest: &PlaceTy<'tcx, M::Provenance>,
+        dest: &impl Writeable<'tcx, M::Provenance>,
     ) -> InterpResult<'tcx> {
         trace!("Unsizing {:?} of type {} into {}", *src, src.layout.ty, cast_ty.ty);
         match (src.layout.ty.kind(), cast_ty.ty.kind()) {
@@ -496,7 +497,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                     self.cur_span(),
                     "unsize_into: invalid conversion: {:?} -> {:?}",
                     src.layout,
-                    dest.layout
+                    dest.layout()
                 )
             }
         }
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 07717b7c069..6657f89ceb5 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -579,7 +579,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 CastKind::PointerCoercion(ty::adjustment::PointerCoercion::Unsize, _) => {
                     let src = self.evaluated[value].as_ref()?;
                     let dest = self.ecx.allocate(ty, MemoryKind::Stack).discard_err()?;
-                    self.ecx.unsize_into(src, ty, &dest.clone().into()).discard_err()?;
+                    self.ecx.unsize_into(src, ty, &dest).discard_err()?;
                     self.ecx
                         .alloc_mark_immutable(dest.ptr().provenance.unwrap().alloc_id())
                         .discard_err()?;
-- 
cgit 1.4.1-3-g733a5


From 15acb0e0ec849453d9db928821cecc552bb51bfd Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 18 Jul 2025 13:43:24 +0000
Subject: unicode-table-gen: clippy fixes

---
 .../unicode-table-generator/src/cascading_map.rs   | 14 ++++++-------
 .../unicode-table-generator/src/case_mapping.rs    |  2 +-
 src/tools/unicode-table-generator/src/main.rs      | 24 +++++++++++-----------
 .../unicode-table-generator/src/raw_emitter.rs     | 23 ++++++++-------------
 4 files changed, 28 insertions(+), 35 deletions(-)

diff --git a/src/tools/unicode-table-generator/src/cascading_map.rs b/src/tools/unicode-table-generator/src/cascading_map.rs
index 1eb35e819c0..78a7bba3208 100644
--- a/src/tools/unicode-table-generator/src/cascading_map.rs
+++ b/src/tools/unicode-table-generator/src/cascading_map.rs
@@ -21,7 +21,7 @@ impl RawEmitter {
 
         let points = ranges
             .iter()
-            .flat_map(|r| (r.start..r.end).into_iter().collect::<Vec<u32>>())
+            .flat_map(|r| (r.start..r.end).collect::<Vec<u32>>())
             .collect::<Vec<u32>>();
 
         println!("there are {} points", points.len());
@@ -32,21 +32,20 @@ impl RawEmitter {
             // assert that there is no whitespace over the 0x3000 range.
             assert!(point <= 0x3000, "the highest unicode whitespace value has changed");
             let high_bytes = point as usize >> 8;
-            let codepoints = codepoints_by_high_bytes.entry(high_bytes).or_insert_with(Vec::new);
+            let codepoints = codepoints_by_high_bytes.entry(high_bytes).or_default();
             codepoints.push(point);
         }
 
         let mut bit_for_high_byte = 1u8;
         let mut arms = Vec::<String>::new();
 
-        let mut high_bytes: Vec<usize> =
-            codepoints_by_high_bytes.keys().map(|k| k.clone()).collect();
+        let mut high_bytes: Vec<usize> = codepoints_by_high_bytes.keys().copied().collect();
         high_bytes.sort();
         for high_byte in high_bytes {
             let codepoints = codepoints_by_high_bytes.get_mut(&high_byte).unwrap();
             if codepoints.len() == 1 {
                 let ch = codepoints.pop().unwrap();
-                arms.push(format!("{} => c as u32 == {:#04x}", high_byte, ch));
+                arms.push(format!("{high_byte} => c as u32 == {ch:#04x}"));
                 continue;
             }
             // more than 1 codepoint in this arm
@@ -54,8 +53,7 @@ impl RawEmitter {
                 map[(*codepoint & 0xff) as usize] |= bit_for_high_byte;
             }
             arms.push(format!(
-                "{} => WHITESPACE_MAP[c as usize & 0xff] & {} != 0",
-                high_byte, bit_for_high_byte
+                "{high_byte} => WHITESPACE_MAP[c as usize & 0xff] & {bit_for_high_byte} != 0"
             ));
             bit_for_high_byte <<= 1;
         }
@@ -68,7 +66,7 @@ impl RawEmitter {
         writeln!(&mut self.file, "pub const fn lookup(c: char) -> bool {{").unwrap();
         writeln!(&mut self.file, "    match c as u32 >> 8 {{").unwrap();
         for arm in arms {
-            writeln!(&mut self.file, "        {},", arm).unwrap();
+            writeln!(&mut self.file, "        {arm},").unwrap();
         }
         writeln!(&mut self.file, "        _ => false,").unwrap();
         writeln!(&mut self.file, "    }}").unwrap();
diff --git a/src/tools/unicode-table-generator/src/case_mapping.rs b/src/tools/unicode-table-generator/src/case_mapping.rs
index 00241b7ee0e..9c6454492e7 100644
--- a/src/tools/unicode-table-generator/src/case_mapping.rs
+++ b/src/tools/unicode-table-generator/src/case_mapping.rs
@@ -9,7 +9,7 @@ const INDEX_MASK: u32 = 1 << 22;
 pub(crate) fn generate_case_mapping(data: &UnicodeData) -> String {
     let mut file = String::new();
 
-    write!(file, "const INDEX_MASK: u32 = 0x{:x};", INDEX_MASK).unwrap();
+    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');
diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index 415db2c4dbc..00f8c1f6ec3 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -196,12 +196,12 @@ fn load_data() -> UnicodeData {
                     .flat_map(|codepoints| match codepoints {
                         Codepoints::Single(c) => c
                             .scalar()
-                            .map(|ch| (ch as u32..ch as u32 + 1))
+                            .map(|ch| ch as u32..ch as u32 + 1)
                             .into_iter()
                             .collect::<Vec<_>>(),
                         Codepoints::Range(c) => c
                             .into_iter()
-                            .flat_map(|c| c.scalar().map(|ch| (ch as u32..ch as u32 + 1)))
+                            .flat_map(|c| c.scalar().map(|ch| ch as u32..ch as u32 + 1))
                             .collect::<Vec<_>>(),
                     })
                     .collect::<Vec<Range<u32>>>(),
@@ -236,7 +236,7 @@ fn main() {
     let ranges_by_property = &unicode_data.ranges;
 
     if let Some(path) = test_path {
-        std::fs::write(&path, generate_tests(&write_location, &ranges_by_property)).unwrap();
+        std::fs::write(&path, generate_tests(&write_location, ranges_by_property)).unwrap();
     }
 
     let mut total_bytes = 0;
@@ -246,9 +246,9 @@ fn main() {
 
         let mut emitter = RawEmitter::new();
         if property == &"White_Space" {
-            emit_whitespace(&mut emitter, &ranges);
+            emit_whitespace(&mut emitter, ranges);
         } else {
-            emit_codepoints(&mut emitter, &ranges);
+            emit_codepoints(&mut emitter, ranges);
         }
 
         modules.push((property.to_lowercase().to_string(), emitter.file));
@@ -288,7 +288,7 @@ fn main() {
         for line in contents.lines() {
             if !line.trim().is_empty() {
                 table_file.push_str("    ");
-                table_file.push_str(&line);
+                table_file.push_str(line);
             }
             table_file.push('\n');
         }
@@ -312,7 +312,7 @@ fn version() -> String {
     let start = readme.find(prefix).unwrap() + prefix.len();
     let end = readme.find(" of the Unicode Standard.").unwrap();
     let version =
-        readme[start..end].split('.').map(|v| v.parse::<u32>().expect(&v)).collect::<Vec<_>>();
+        readme[start..end].split('.').map(|v| v.parse::<u32>().expect(v)).collect::<Vec<_>>();
     let [major, minor, micro] = [version[0], version[1], version[2]];
 
     out.push_str(&format!("({major}, {minor}, {micro});\n"));
@@ -320,7 +320,7 @@ fn version() -> String {
 }
 
 fn fmt_list<V: std::fmt::Debug>(values: impl IntoIterator<Item = V>) -> String {
-    let pieces = values.into_iter().map(|b| format!("{:?}, ", b)).collect::<Vec<_>>();
+    let pieces = values.into_iter().map(|b| format!("{b:?}, ")).collect::<Vec<_>>();
     let mut out = String::new();
     let mut line = String::from("\n    ");
     for piece in pieces {
@@ -348,7 +348,7 @@ fn generate_tests(data_path: &str, ranges: &[(&str, Vec<Range<u32>>)]) -> String
     s.push_str("\nfn main() {\n");
 
     for (property, ranges) in ranges {
-        s.push_str(&format!(r#"    println!("Testing {}");"#, property));
+        s.push_str(&format!(r#"    println!("Testing {property}");"#));
         s.push('\n');
         s.push_str(&format!("    {}_true();\n", property.to_lowercase()));
         s.push_str(&format!("    {}_false();\n", property.to_lowercase()));
@@ -373,7 +373,7 @@ fn generate_tests(data_path: &str, ranges: &[(&str, Vec<Range<u32>>)]) -> String
         s.push_str("    }\n\n");
     }
 
-    s.push_str("}");
+    s.push('}');
     s
 }
 
@@ -388,7 +388,7 @@ fn generate_asserts(s: &mut String, property: &str, points: &[u32], truthy: bool
                 range.start,
             ));
         } else {
-            s.push_str(&format!("        for chn in {:?}u32 {{\n", range));
+            s.push_str(&format!("        for chn in {range:?}u32 {{\n"));
             s.push_str(&format!(
                 "            assert!({}unicode_data::{}::lookup(std::char::from_u32(chn).unwrap()), \"{{:?}}\", chn);\n",
                 if truthy { "" } else { "!" },
@@ -439,7 +439,7 @@ fn merge_ranges(ranges: &mut Vec<Range<u32>>) {
     let mut last_end = None;
     for range in ranges {
         if let Some(last) = last_end {
-            assert!(range.start > last, "{:?}", range);
+            assert!(range.start > last, "{range:?}");
         }
         last_end = Some(range.end);
     }
diff --git a/src/tools/unicode-table-generator/src/raw_emitter.rs b/src/tools/unicode-table-generator/src/raw_emitter.rs
index ee94d3c93a6..e1e77af9283 100644
--- a/src/tools/unicode-table-generator/src/raw_emitter.rs
+++ b/src/tools/unicode-table-generator/src/raw_emitter.rs
@@ -156,10 +156,10 @@ pub fn emit_codepoints(emitter: &mut RawEmitter, ranges: &[Range<u32>]) {
     emitter.blank_line();
 
     let mut bitset = emitter.clone();
-    let bitset_ok = bitset.emit_bitset(&ranges).is_ok();
+    let bitset_ok = bitset.emit_bitset(ranges).is_ok();
 
     let mut skiplist = emitter.clone();
-    skiplist.emit_skiplist(&ranges);
+    skiplist.emit_skiplist(ranges);
 
     if bitset_ok && bitset.bytes_used <= skiplist.bytes_used {
         *emitter = bitset;
@@ -174,7 +174,7 @@ pub fn emit_whitespace(emitter: &mut RawEmitter, ranges: &[Range<u32>]) {
     emitter.blank_line();
 
     let mut cascading = emitter.clone();
-    cascading.emit_cascading_map(&ranges);
+    cascading.emit_cascading_map(ranges);
     *emitter = cascading;
     emitter.desc = String::from("cascading");
 }
@@ -311,10 +311,9 @@ impl Canonicalized {
                     }
                 }
             }
-            assert!(
-                unique_mapping
-                    .insert(to, UniqueMapping::Canonical(canonical_words.len()))
-                    .is_none()
+            assert_eq!(
+                unique_mapping.insert(to, UniqueMapping::Canonical(canonical_words.len())),
+                None
             );
             canonical_words.push(to);
 
@@ -340,14 +339,10 @@ impl Canonicalized {
         // We'll probably always have some slack though so this loop will still
         // be needed.
         for &w in unique_words {
-            if !unique_mapping.contains_key(&w) {
-                assert!(
-                    unique_mapping
-                        .insert(w, UniqueMapping::Canonical(canonical_words.len()))
-                        .is_none()
-                );
+            unique_mapping.entry(w).or_insert_with(|| {
                 canonical_words.push(w);
-            }
+                UniqueMapping::Canonical(canonical_words.len())
+            });
         }
         assert_eq!(canonicalized_words.len() + canonical_words.len(), unique_words.len());
         assert_eq!(unique_mapping.len(), unique_words.len());
-- 
cgit 1.4.1-3-g733a5


From 09593059867b066d23776e00a2ce31c370ec9277 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 18 Jul 2025 13:45:33 +0000
Subject: unicode-table-gen: edition 2024

---
 src/tools/unicode-table-generator/Cargo.toml         | 2 +-
 src/tools/unicode-table-generator/src/raw_emitter.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/unicode-table-generator/Cargo.toml b/src/tools/unicode-table-generator/Cargo.toml
index f8a500922d0..3ca6e9e316f 100644
--- a/src/tools/unicode-table-generator/Cargo.toml
+++ b/src/tools/unicode-table-generator/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "unicode-table-generator"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/src/tools/unicode-table-generator/src/raw_emitter.rs b/src/tools/unicode-table-generator/src/raw_emitter.rs
index e1e77af9283..e9e0efc4594 100644
--- a/src/tools/unicode-table-generator/src/raw_emitter.rs
+++ b/src/tools/unicode-table-generator/src/raw_emitter.rs
@@ -272,7 +272,7 @@ impl Canonicalized {
         // for canonical when possible.
         while let Some((&to, _)) = mappings
             .iter()
-            .find(|(&to, _)| to == 0)
+            .find(|&(&to, _)| to == 0)
             .or_else(|| mappings.iter().max_by_key(|m| m.1.len()))
         {
             // Get the mapping with the most entries. Currently, no mapping can
-- 
cgit 1.4.1-3-g733a5


From b0073d92fbb5402ff7bed69f28aab4b34b05a9df Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Fri, 18 Jul 2025 13:51:18 +0000
Subject: unicode-table-gen: more clippy fixes

---
 src/tools/unicode-table-generator/src/main.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/tools/unicode-table-generator/src/main.rs b/src/tools/unicode-table-generator/src/main.rs
index 00f8c1f6ec3..6cdb82a87bd 100644
--- a/src/tools/unicode-table-generator/src/main.rs
+++ b/src/tools/unicode-table-generator/src/main.rs
@@ -160,15 +160,15 @@ fn load_data() -> UnicodeData {
                 .push(Codepoints::Single(row.codepoint));
         }
 
-        if let Some(mapped) = row.simple_lowercase_mapping {
-            if mapped != row.codepoint {
-                to_lower.insert(row.codepoint.value(), (mapped.value(), 0, 0));
-            }
+        if let Some(mapped) = row.simple_lowercase_mapping
+            && mapped != row.codepoint
+        {
+            to_lower.insert(row.codepoint.value(), (mapped.value(), 0, 0));
         }
-        if let Some(mapped) = row.simple_uppercase_mapping {
-            if mapped != row.codepoint {
-                to_upper.insert(row.codepoint.value(), (mapped.value(), 0, 0));
-            }
+        if let Some(mapped) = row.simple_uppercase_mapping
+            && mapped != row.codepoint
+        {
+            to_upper.insert(row.codepoint.value(), (mapped.value(), 0, 0));
         }
     }
 
-- 
cgit 1.4.1-3-g733a5


From 4d1695103f15ec885ced2eef25cdc9fd08332b66 Mon Sep 17 00:00:00 2001
From: Antoni Boucher <bouanto@zoho.com>
Date: Fri, 18 Jul 2025 11:26:44 -0400
Subject: Comment some tests in the m68k CI because we cannot run programs on
 architectures not supported by the object crate anymore

---
 .github/workflows/m68k.yml | 38 ++++++++++++++++++++++----------------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/m68k.yml b/.github/workflows/m68k.yml
index 176ee8628b0..759d0d59e26 100644
--- a/.github/workflows/m68k.yml
+++ b/.github/workflows/m68k.yml
@@ -91,7 +91,11 @@ jobs:
         ./y.sh prepare --only-libcore --cross
         ./y.sh build --sysroot --features compiler-builtins-no-f16-f128 --target-triple m68k-unknown-linux-gnu
         ./y.sh test --mini-tests --target-triple m68k-unknown-linux-gnu
-        CG_GCC_TEST_TARGET=m68k-unknown-linux-gnu ./y.sh test --cargo-tests --target-triple m68k-unknown-linux-gnu
+        # FIXME: since https://github.com/rust-lang/rust/pull/140809, we cannot run programs for architectures not
+        # supported by the object crate, since this adds a dependency on symbols.o for the panic runtime.
+        # And as such, a wrong order of the object files in the linker command now fails with an undefined reference
+        # to some symbols like __rustc::rust_panic.
+        #CG_GCC_TEST_TARGET=m68k-unknown-linux-gnu ./y.sh test --cargo-tests --target-triple m68k-unknown-linux-gnu
         ./y.sh clean all
 
     - name: Prepare dependencies
@@ -100,21 +104,23 @@ jobs:
         git config --global user.name "User"
         ./y.sh prepare --cross
 
-    - name: Run tests
-      run: |
-        ./y.sh test --target-triple m68k-unknown-linux-gnu --release --clean --build-sysroot --sysroot-features compiler-builtins-no-f16-f128 ${{ matrix.commands }}
-
-    - name: Run Hello World!
-      run: |
-        ./y.sh build --target-triple m68k-unknown-linux-gnu
-
-        vm_dir=$(pwd)/vm
-        cd tests/hello-world
-        CG_RUSTFLAGS="-Clinker=m68k-unknown-linux-gnu-gcc" ../../y.sh cargo build --target m68k-unknown-linux-gnu
-        sudo cp target/m68k-unknown-linux-gnu/debug/hello_world $vm_dir/home/
-        sudo chroot $vm_dir qemu-m68k-static /home/hello_world > hello_world_stdout
-        expected_output="40"
-        test $(cat hello_world_stdout) == $expected_output || (echo "Output differs. Actual output: $(cat hello_world_stdout)"; exit 1)
+    # FIXME: We cannot run programs for architectures not supported by the object crate. See comment above.
+    #- name: Run tests
+      #run: |
+        #./y.sh test --target-triple m68k-unknown-linux-gnu --release --clean --build-sysroot --sysroot-features compiler-builtins-no-f16-f128 ${{ matrix.commands }}
+
+    # FIXME: We cannot run programs for architectures not supported by the object crate. See comment above.
+    #- name: Run Hello World!
+      #run: |
+        #./y.sh build --target-triple m68k-unknown-linux-gnu
+
+        #vm_dir=$(pwd)/vm
+        #cd tests/hello-world
+        #CG_RUSTFLAGS="-Clinker=m68k-unknown-linux-gnu-gcc" ../../y.sh cargo build --target m68k-unknown-linux-gnu
+        #sudo cp target/m68k-unknown-linux-gnu/debug/hello_world $vm_dir/home/
+        #sudo chroot $vm_dir qemu-m68k-static /home/hello_world > hello_world_stdout
+        #expected_output="40"
+        #test $(cat hello_world_stdout) == $expected_output || (echo "Output differs. Actual output: $(cat hello_world_stdout)"; exit 1)
 
   # Summary job for the merge queue.
   # ALL THE PREVIOUS JOBS NEED TO BE ADDED TO THE `needs` SECTION OF THIS JOB!
-- 
cgit 1.4.1-3-g733a5


From 3b9c16bc0e90e57ed4ff548a50a577ea4dd7a50c Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 9 Jul 2025 20:00:59 +0000
Subject: Be a bit more careful around exotic cycles in in the inliner

---
 compiler/rustc_mir_transform/src/inline/cycle.rs   | 44 ++++++++++++--------
 .../inline_double_cycle.a.Inline.panic-abort.diff  | 48 ++++++++++++++++++++++
 .../inline_double_cycle.a.Inline.panic-unwind.diff | 48 ++++++++++++++++++++++
 .../inline_double_cycle.b.Inline.panic-abort.diff  | 48 ++++++++++++++++++++++
 .../inline_double_cycle.b.Inline.panic-unwind.diff | 48 ++++++++++++++++++++++
 tests/mir-opt/inline_double_cycle.rs               | 22 ++++++++++
 6 files changed, 242 insertions(+), 16 deletions(-)
 create mode 100644 tests/mir-opt/inline_double_cycle.a.Inline.panic-abort.diff
 create mode 100644 tests/mir-opt/inline_double_cycle.a.Inline.panic-unwind.diff
 create mode 100644 tests/mir-opt/inline_double_cycle.b.Inline.panic-abort.diff
 create mode 100644 tests/mir-opt/inline_double_cycle.b.Inline.panic-unwind.diff
 create mode 100644 tests/mir-opt/inline_double_cycle.rs

diff --git a/compiler/rustc_mir_transform/src/inline/cycle.rs b/compiler/rustc_mir_transform/src/inline/cycle.rs
index 93a81f0dca5..7f9234d1dc8 100644
--- a/compiler/rustc_mir_transform/src/inline/cycle.rs
+++ b/compiler/rustc_mir_transform/src/inline/cycle.rs
@@ -64,15 +64,15 @@ fn process<'tcx>(
     typing_env: ty::TypingEnv<'tcx>,
     caller: ty::Instance<'tcx>,
     target: LocalDefId,
-    seen: &mut FxHashSet<ty::Instance<'tcx>>,
+    seen: &mut FxHashMap<ty::Instance<'tcx>, bool>,
     involved: &mut FxHashSet<LocalDefId>,
     recursion_limiter: &mut FxHashMap<DefId, usize>,
     recursion_limit: Limit,
 ) -> bool {
     trace!(%caller);
-    let mut cycle_found = false;
+    let mut reaches_root = false;
 
-    for &(callee, args) in tcx.mir_inliner_callees(caller.def) {
+    for &(callee_def_id, args) in tcx.mir_inliner_callees(caller.def) {
         let Ok(args) = caller.try_instantiate_mir_and_normalize_erasing_regions(
             tcx,
             typing_env,
@@ -81,14 +81,17 @@ fn process<'tcx>(
             trace!(?caller, ?typing_env, ?args, "cannot normalize, skipping");
             continue;
         };
-        let Ok(Some(callee)) = ty::Instance::try_resolve(tcx, typing_env, callee, args) else {
-            trace!(?callee, "cannot resolve, skipping");
+        let Ok(Some(callee)) = ty::Instance::try_resolve(tcx, typing_env, callee_def_id, args)
+        else {
+            trace!(?callee_def_id, "cannot resolve, skipping");
             continue;
         };
 
         // Found a path.
         if callee.def_id() == target.to_def_id() {
-            cycle_found = true;
+            reaches_root = true;
+            seen.insert(callee, true);
+            continue;
         }
 
         if tcx.is_constructor(callee.def_id()) {
@@ -101,10 +104,17 @@ fn process<'tcx>(
             continue;
         }
 
-        if seen.insert(callee) {
+        let callee_reaches_root = if let Some(&c) = seen.get(&callee) {
+            // Even if we have seen this callee before, and thus don't need
+            // to recurse into it, we still need to propagate whether it reaches
+            // the root so that we can mark all the involved callers, in case we
+            // end up reaching that same recursive callee through some *other* cycle.
+            c
+        } else {
+            seen.insert(callee, false);
             let recursion = recursion_limiter.entry(callee.def_id()).or_default();
             trace!(?callee, recursion = *recursion);
-            let found_recursion = if recursion_limit.value_within_limit(*recursion) {
+            let callee_reaches_root = if recursion_limit.value_within_limit(*recursion) {
                 *recursion += 1;
                 ensure_sufficient_stack(|| {
                     process(
@@ -122,17 +132,19 @@ fn process<'tcx>(
                 // Pessimistically assume that there could be recursion.
                 true
             };
-            if found_recursion {
-                if let Some(callee) = callee.def_id().as_local() {
-                    // Calling `optimized_mir` of a non-local definition cannot cycle.
-                    involved.insert(callee);
-                }
-                cycle_found = true;
+            seen.insert(callee, callee_reaches_root);
+            callee_reaches_root
+        };
+        if callee_reaches_root {
+            if let Some(callee_def_id) = callee.def_id().as_local() {
+                // Calling `optimized_mir` of a non-local definition cannot cycle.
+                involved.insert(callee_def_id);
             }
+            reaches_root = true;
         }
     }
 
-    cycle_found
+    reaches_root
 }
 
 #[instrument(level = "debug", skip(tcx), ret)]
@@ -166,7 +178,7 @@ pub(crate) fn mir_callgraph_cyclic<'tcx>(
         typing_env,
         root_instance,
         root,
-        &mut FxHashSet::default(),
+        &mut FxHashMap::default(),
         &mut involved,
         &mut FxHashMap::default(),
         recursion_limit,
diff --git a/tests/mir-opt/inline_double_cycle.a.Inline.panic-abort.diff b/tests/mir-opt/inline_double_cycle.a.Inline.panic-abort.diff
new file mode 100644
index 00000000000..90a4a509ac1
--- /dev/null
+++ b/tests/mir-opt/inline_double_cycle.a.Inline.panic-abort.diff
@@ -0,0 +1,48 @@
+- // MIR for `a` before Inline
++ // MIR for `a` after Inline
+  
+  fn a() -> () {
+      let mut _0: ();
+      let _1: ();
+      let mut _2: ();
+      let _3: ();
+      let mut _4: ();
++     let mut _5: fn() {a};
++     let mut _6: fn() {b};
++     scope 1 (inlined <fn() {a} as FnOnce<()>>::call_once - shim(fn() {a})) {
++     }
++     scope 2 (inlined <fn() {b} as FnOnce<()>>::call_once - shim(fn() {b})) {
++     }
+  
+      bb0: {
+          StorageLive(_1);
+          StorageLive(_2);
+          _2 = ();
+-         _1 = <fn() {a} as FnOnce<()>>::call_once(a, move _2) -> [return: bb1, unwind unreachable];
++         StorageLive(_5);
++         _5 = a;
++         _1 = move _5() -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
++         StorageDead(_5);
+          StorageDead(_2);
+          StorageDead(_1);
+          StorageLive(_3);
+          StorageLive(_4);
+          _4 = ();
+-         _3 = <fn() {b} as FnOnce<()>>::call_once(b, move _4) -> [return: bb2, unwind unreachable];
++         StorageLive(_6);
++         _6 = b;
++         _3 = move _6() -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
++         StorageDead(_6);
+          StorageDead(_4);
+          StorageDead(_3);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline_double_cycle.a.Inline.panic-unwind.diff b/tests/mir-opt/inline_double_cycle.a.Inline.panic-unwind.diff
new file mode 100644
index 00000000000..55da685a3d4
--- /dev/null
+++ b/tests/mir-opt/inline_double_cycle.a.Inline.panic-unwind.diff
@@ -0,0 +1,48 @@
+- // MIR for `a` before Inline
++ // MIR for `a` after Inline
+  
+  fn a() -> () {
+      let mut _0: ();
+      let _1: ();
+      let mut _2: ();
+      let _3: ();
+      let mut _4: ();
++     let mut _5: fn() {a};
++     let mut _6: fn() {b};
++     scope 1 (inlined <fn() {a} as FnOnce<()>>::call_once - shim(fn() {a})) {
++     }
++     scope 2 (inlined <fn() {b} as FnOnce<()>>::call_once - shim(fn() {b})) {
++     }
+  
+      bb0: {
+          StorageLive(_1);
+          StorageLive(_2);
+          _2 = ();
+-         _1 = <fn() {a} as FnOnce<()>>::call_once(a, move _2) -> [return: bb1, unwind continue];
++         StorageLive(_5);
++         _5 = a;
++         _1 = move _5() -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
++         StorageDead(_5);
+          StorageDead(_2);
+          StorageDead(_1);
+          StorageLive(_3);
+          StorageLive(_4);
+          _4 = ();
+-         _3 = <fn() {b} as FnOnce<()>>::call_once(b, move _4) -> [return: bb2, unwind continue];
++         StorageLive(_6);
++         _6 = b;
++         _3 = move _6() -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
++         StorageDead(_6);
+          StorageDead(_4);
+          StorageDead(_3);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline_double_cycle.b.Inline.panic-abort.diff b/tests/mir-opt/inline_double_cycle.b.Inline.panic-abort.diff
new file mode 100644
index 00000000000..2090411276c
--- /dev/null
+++ b/tests/mir-opt/inline_double_cycle.b.Inline.panic-abort.diff
@@ -0,0 +1,48 @@
+- // MIR for `b` before Inline
++ // MIR for `b` after Inline
+  
+  fn b() -> () {
+      let mut _0: ();
+      let _1: ();
+      let mut _2: ();
+      let _3: ();
+      let mut _4: ();
++     let mut _5: fn() {b};
++     let mut _6: fn() {a};
++     scope 1 (inlined <fn() {b} as FnOnce<()>>::call_once - shim(fn() {b})) {
++     }
++     scope 2 (inlined <fn() {a} as FnOnce<()>>::call_once - shim(fn() {a})) {
++     }
+  
+      bb0: {
+          StorageLive(_1);
+          StorageLive(_2);
+          _2 = ();
+-         _1 = <fn() {b} as FnOnce<()>>::call_once(b, move _2) -> [return: bb1, unwind unreachable];
++         StorageLive(_5);
++         _5 = b;
++         _1 = move _5() -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
++         StorageDead(_5);
+          StorageDead(_2);
+          StorageDead(_1);
+          StorageLive(_3);
+          StorageLive(_4);
+          _4 = ();
+-         _3 = <fn() {a} as FnOnce<()>>::call_once(a, move _4) -> [return: bb2, unwind unreachable];
++         StorageLive(_6);
++         _6 = a;
++         _3 = move _6() -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
++         StorageDead(_6);
+          StorageDead(_4);
+          StorageDead(_3);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline_double_cycle.b.Inline.panic-unwind.diff b/tests/mir-opt/inline_double_cycle.b.Inline.panic-unwind.diff
new file mode 100644
index 00000000000..9e6eef1fa30
--- /dev/null
+++ b/tests/mir-opt/inline_double_cycle.b.Inline.panic-unwind.diff
@@ -0,0 +1,48 @@
+- // MIR for `b` before Inline
++ // MIR for `b` after Inline
+  
+  fn b() -> () {
+      let mut _0: ();
+      let _1: ();
+      let mut _2: ();
+      let _3: ();
+      let mut _4: ();
++     let mut _5: fn() {b};
++     let mut _6: fn() {a};
++     scope 1 (inlined <fn() {b} as FnOnce<()>>::call_once - shim(fn() {b})) {
++     }
++     scope 2 (inlined <fn() {a} as FnOnce<()>>::call_once - shim(fn() {a})) {
++     }
+  
+      bb0: {
+          StorageLive(_1);
+          StorageLive(_2);
+          _2 = ();
+-         _1 = <fn() {b} as FnOnce<()>>::call_once(b, move _2) -> [return: bb1, unwind continue];
++         StorageLive(_5);
++         _5 = b;
++         _1 = move _5() -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
++         StorageDead(_5);
+          StorageDead(_2);
+          StorageDead(_1);
+          StorageLive(_3);
+          StorageLive(_4);
+          _4 = ();
+-         _3 = <fn() {a} as FnOnce<()>>::call_once(a, move _4) -> [return: bb2, unwind continue];
++         StorageLive(_6);
++         _6 = a;
++         _3 = move _6() -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
++         StorageDead(_6);
+          StorageDead(_4);
+          StorageDead(_3);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline_double_cycle.rs b/tests/mir-opt/inline_double_cycle.rs
new file mode 100644
index 00000000000..cf3b87cf0ad
--- /dev/null
+++ b/tests/mir-opt/inline_double_cycle.rs
@@ -0,0 +1,22 @@
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+// skip-filecheck
+//@ test-mir-pass: Inline
+//@ edition: 2021
+//@ compile-flags: -Zinline-mir --crate-type=lib
+
+// EMIT_MIR inline_double_cycle.a.Inline.diff
+// EMIT_MIR inline_double_cycle.b.Inline.diff
+
+#![feature(fn_traits)]
+
+#[inline]
+pub fn a() {
+    FnOnce::call_once(a, ());
+    FnOnce::call_once(b, ());
+}
+
+#[inline]
+pub fn b() {
+    FnOnce::call_once(b, ());
+    FnOnce::call_once(a, ());
+}
-- 
cgit 1.4.1-3-g733a5


From 8a8717e971dbdc6155506a4332e9ce8ef9151caa Mon Sep 17 00:00:00 2001
From: Luigi Sartor Piucco <luigipiucco@gmail.com>
Date: Sun, 20 Apr 2025 18:43:54 -0300
Subject: fix: don't panic on volatile access to null

According to
https://discourse.llvm.org/t/rfc-volatile-access-to-non-dereferenceable-memory-may-be-well-defined/86303/4,
LLVM allows volatile operations on null and handles it correctly. This
should be allowed in Rust as well, because I/O memory may be hard-coded
to address 0 in some cases, like the AVR chip ATtiny1626.

A test case that ensured a failure when passing null to volatile was
removed, since it's now valid.

Due to the addition of `maybe_is_aligned` to `ub_checks`,
`maybe_is_aligned_and_not_null` was refactored to use it.

docs: revise restrictions on volatile operations

A distinction between usage on Rust memory vs. non-Rust memory was
introduced. Documentation was reworded to explain what that means, and
make explicit that:

- No trapping can occur from volatile operations;
- On Rust memory, all safety rules must be respected;
- On Rust memory, the primary difference from regular access is that
  volatile always involves a memory dereference;
- On Rust memory, the only data affected by an operation is the one
  pointed to in the argument(s) of the function;
- On Rust memory, provenance follows the same rules as non-volatile
  access;
- On non-Rust memory, any address known to not contain Rust memory is
  valid (including 0 and usize::MAX);
- On non-Rust memory, no Rust memory may be affected (it is implicit
  that any other non-Rust memory may be affected, though, even if not
  referenced by the pointer). This should be relevant when, for example,
  reading register A causes a flag to change in register B, or writing
  to A causes B to change in some way. Everything affected mustn't be
  inside an allocation.
- On non-Rust memory, provenance is irrelevant and a pointer with none
  can be used in a valid way.

fix: don't lint null as UB for volatile

Also remove a now-unneeded `allow` line.

fix: additional wording nits
---
 compiler/rustc_lint/src/ptr_nulls.rs           |   4 +-
 library/core/src/ptr/mod.rs                    | 168 ++++++++++++++-----------
 library/core/src/ub_checks.rs                  |  18 ++-
 tests/ui/lint/invalid_null_args.rs             |   5 +-
 tests/ui/lint/invalid_null_args.stderr         |  58 +++------
 tests/ui/precondition-checks/read_volatile.rs  |   6 +-
 tests/ui/precondition-checks/write_volatile.rs |   6 +-
 7 files changed, 127 insertions(+), 138 deletions(-)

diff --git a/compiler/rustc_lint/src/ptr_nulls.rs b/compiler/rustc_lint/src/ptr_nulls.rs
index 826bce2c315..b2fa0fba76d 100644
--- a/compiler/rustc_lint/src/ptr_nulls.rs
+++ b/compiler/rustc_lint/src/ptr_nulls.rs
@@ -160,12 +160,10 @@ impl<'tcx> LateLintPass<'tcx> for PtrNullChecks {
                 let (arg_indices, are_zsts_allowed): (&[_], _) = match diag_name {
                     sym::ptr_read
                     | sym::ptr_read_unaligned
-                    | sym::ptr_read_volatile
                     | sym::ptr_replace
                     | sym::ptr_write
                     | sym::ptr_write_bytes
-                    | sym::ptr_write_unaligned
-                    | sym::ptr_write_volatile => (&[0], true),
+                    | sym::ptr_write_unaligned => (&[0], true),
                     sym::slice_from_raw_parts | sym::slice_from_raw_parts_mut => (&[0], false),
                     sym::ptr_copy
                     | sym::ptr_copy_nonoverlapping
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index fe8c6f83034..dbe3999b4a4 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -28,7 +28,8 @@
 //!   undefined behavior to perform two concurrent accesses to the same location from different
 //!   threads unless both accesses only read from memory. Notice that this explicitly
 //!   includes [`read_volatile`] and [`write_volatile`]: Volatile accesses cannot
-//!   be used for inter-thread synchronization.
+//!   be used for inter-thread synchronization, regardless of whether they are acting on
+//!   Rust memory or not.
 //! * The result of casting a reference to a pointer is valid for as long as the
 //!   underlying allocation is live and no reference (just raw pointers) is used to
 //!   access the same memory. That is, reference and pointer accesses cannot be
@@ -114,6 +115,10 @@
 //! fully contiguous (i.e., has no "holes"), there is no guarantee that this
 //! will not change in the future.
 //!
+//! Allocations must behave like "normal" memory: in particular, reads must not have
+//! side-effects, and writes must become visible to other threads using the usual synchronization
+//! primitives.
+//!
 //! For any allocation with `base` address, `size`, and a set of
 //! `addresses`, the following are guaranteed:
 //! - For all addresses `a` in `addresses`, `a` is in the range `base .. (base +
@@ -2021,54 +2026,61 @@ pub const unsafe fn write_unaligned<T>(dst: *mut T, src: T) {
     }
 }
 
-/// Performs a volatile read of the value from `src` without moving it. This
-/// leaves the memory in `src` unchanged.
-///
-/// Volatile operations are intended to act on I/O memory, and are guaranteed
-/// to not be elided or reordered by the compiler across other volatile
-/// operations.
-///
-/// # Notes
-///
-/// Rust does not currently have a rigorously and formally defined memory model,
-/// so the precise semantics of what "volatile" means here is subject to change
-/// over time. That being said, the semantics will almost always end up pretty
-/// similar to [C11's definition of volatile][c11].
-///
-/// The compiler shouldn't change the relative order or number of volatile
-/// memory operations. However, volatile memory operations on zero-sized types
-/// (e.g., if a zero-sized type is passed to `read_volatile`) are noops
-/// and may be ignored.
-///
-/// [c11]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
+/// Performs a volatile read of the value from `src` without moving it.
+///
+/// Volatile operations are intended to act on I/O memory. As such, they are considered externally
+/// observable events (just like syscalls, but less opaque), and are guaranteed to not be elided or
+/// reordered by the compiler across other externally observable events. With this in mind, there
+/// are two cases of usage that need to be distinguished:
+///
+/// - When a volatile operation is used for memory inside an [allocation], it behaves exactly like
+///   [`read`], except for the additional guarantee that it won't be elided or reordered (see
+///   above). This implies that the operation will actually access memory and not e.g. be lowered to
+///   reusing data from a previous read. Other than that, all the usual rules for memory accesses
+///   apply (including provenance).  In particular, just like in C, whether an operation is volatile
+///   has no bearing whatsoever on questions involving concurrent accesses from multiple threads.
+///   Volatile accesses behave exactly like non-atomic accesses in that regard.
+///
+/// - Volatile operations, however, may also be used to access memory that is _outside_ of any Rust
+///   allocation. In this use-case, the pointer does *not* have to be [valid] for reads. This is
+///   typically used for CPU and peripheral registers that must be accessed via an I/O memory
+///   mapping, most commonly at fixed addresses reserved by the hardware. These often have special
+///   semantics associated to their manipulation, and cannot be used as general purpose memory.
+///   Here, any address value is possible, including 0 and [`usize::MAX`], so long as the semantics
+///   of such a read are well-defined by the target hardware. The provenance of the pointer is
+///   irrelevant, and it can be created with [`without_provenance`]. The access must not trap. It
+///   can cause side-effects, but those must not affect Rust-allocated memory in any way. This
+///   access is still not considered [atomic], and as such it cannot be used for inter-thread
+///   synchronization.
+///
+/// Note that volatile memory operations where T is a zero-sized type are noops and may be ignored.
+///
+/// [allocation]: crate::ptr#allocated-object
+/// [atomic]: crate::sync::atomic#memory-model-for-atomic-accesses
 ///
 /// # Safety
 ///
+/// Like [`read`], `read_volatile` creates a bitwise copy of `T`, regardless of whether `T` is
+/// [`Copy`]. If `T` is not [`Copy`], using both the returned value and the value at `*src` can
+/// [violate memory safety][read-ownership]. However, storing non-[`Copy`] types in volatile memory
+/// is almost certainly incorrect.
+///
 /// Behavior is undefined if any of the following conditions are violated:
 ///
-/// * `src` must be [valid] for reads.
+/// * `src` must be either [valid] for reads, or it must point to memory outside of all Rust
+///   allocations and reading from that memory must:
+///   - not trap, and
+///   - not cause any memory inside a Rust allocation to be modified.
 ///
 /// * `src` must be properly aligned.
 ///
-/// * `src` must point to a properly initialized value of type `T`.
-///
-/// Like [`read`], `read_volatile` creates a bitwise copy of `T`, regardless of
-/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned
-/// value and the value at `*src` can [violate memory safety][read-ownership].
-/// However, storing non-[`Copy`] types in volatile memory is almost certainly
-/// incorrect.
+/// * Reading from `src` must produce a properly initialized value of type `T`.
 ///
 /// Note that even if `T` has size `0`, the pointer must be properly aligned.
 ///
 /// [valid]: self#safety
 /// [read-ownership]: read#ownership-of-the-returned-value
 ///
-/// Just like in C, whether an operation is volatile has no bearing whatsoever
-/// on questions involving concurrent access from multiple threads. Volatile
-/// accesses behave exactly like non-atomic accesses in that regard. In particular,
-/// a race between a `read_volatile` and any write operation to the same location
-/// is undefined behavior.
-///
 /// # Examples
 ///
 /// Basic usage:
@@ -2090,50 +2102,63 @@ pub unsafe fn read_volatile<T>(src: *const T) -> T {
     unsafe {
         ub_checks::assert_unsafe_precondition!(
             check_language_ub,
-            "ptr::read_volatile requires that the pointer argument is aligned and non-null",
+            "ptr::read_volatile requires that the pointer argument is aligned",
             (
                 addr: *const () = src as *const (),
                 align: usize = align_of::<T>(),
-                is_zst: bool = T::IS_ZST,
-            ) => ub_checks::maybe_is_aligned_and_not_null(addr, align, is_zst)
+            ) => ub_checks::maybe_is_aligned(addr, align)
         );
         intrinsics::volatile_load(src)
     }
 }
 
-/// Performs a volatile write of a memory location with the given value without
-/// reading or dropping the old value.
-///
-/// Volatile operations are intended to act on I/O memory, and are guaranteed
-/// to not be elided or reordered by the compiler across other volatile
-/// operations.
-///
-/// `write_volatile` does not drop the contents of `dst`. This is safe, but it
-/// could leak allocations or resources, so care should be taken not to overwrite
-/// an object that should be dropped.
-///
-/// Additionally, it does not drop `src`. Semantically, `src` is moved into the
-/// location pointed to by `dst`.
-///
-/// # Notes
-///
-/// Rust does not currently have a rigorously and formally defined memory model,
-/// so the precise semantics of what "volatile" means here is subject to change
-/// over time. That being said, the semantics will almost always end up pretty
-/// similar to [C11's definition of volatile][c11].
-///
-/// The compiler shouldn't change the relative order or number of volatile
-/// memory operations. However, volatile memory operations on zero-sized types
-/// (e.g., if a zero-sized type is passed to `write_volatile`) are noops
-/// and may be ignored.
-///
-/// [c11]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
+/// Performs a volatile write of a memory location with the given value without reading or dropping
+/// the old value.
+///
+/// Volatile operations are intended to act on I/O memory. As such, they are considered externally
+/// observable events (just like syscalls), and are guaranteed to not be elided or reordered by the
+/// compiler across other externally observable events. With this in mind, there are two cases of
+/// usage that need to be distinguished:
+///
+/// - When a volatile operation is used for memory inside an [allocation], it behaves exactly like
+///   [`write`][write()], except for the additional guarantee that it won't be elided or reordered
+///   (see above). This implies that the operation will actually access memory and not e.g. be
+///   lowered to a register access. Other than that, all the usual rules for memory accesses apply
+///   (including provenance). In particular, just like in C, whether an operation is volatile has no
+///   bearing whatsoever on questions involving concurrent access from multiple threads. Volatile
+///   accesses behave exactly like non-atomic accesses in that regard.
+///
+/// - Volatile operations, however, may also be used to access memory that is _outside_ of any Rust
+///   allocation. In this use-case, the pointer does *not* have to be [valid] for writes. This is
+///   typically used for CPU and peripheral registers that must be accessed via an I/O memory
+///   mapping, most commonly at fixed addresses reserved by the hardware. These often have special
+///   semantics associated to their manipulation, and cannot be used as general purpose memory.
+///   Here, any address value is possible, including 0 and [`usize::MAX`], so long as the semantics
+///   of such a write are well-defined by the target hardware. The provenance of the pointer is
+///   irrelevant, and it can be created with [`without_provenance`]. The access must not trap. It
+///   can cause side-effects, but those must not affect Rust-allocated memory in any way. This
+///   access is still not considered [atomic], and as such it cannot be used for inter-thread
+///   synchronization.
+///
+/// Note that volatile memory operations on zero-sized types (e.g., if a zero-sized type is passed
+/// to `write_volatile`) are noops and may be ignored.
+///
+/// `write_volatile` does not drop the contents of `dst`. This is safe, but it could leak
+/// allocations or resources, so care should be taken not to overwrite an object that should be
+/// dropped when operating on Rust memory. Additionally, it does not drop `src`. Semantically, `src`
+/// is moved into the location pointed to by `dst`.
+///
+/// [allocation]: crate::ptr#allocated-object
+/// [atomic]: crate::sync::atomic#memory-model-for-atomic-accesses
 ///
 /// # Safety
 ///
 /// Behavior is undefined if any of the following conditions are violated:
 ///
-/// * `dst` must be [valid] for writes.
+/// * `dst` must be either [valid] for writes, or it must point to memory outside of all Rust
+///   allocations and writing to that memory must:
+///   - not trap, and
+///   - not cause any memory inside a Rust allocation to be modified.
 ///
 /// * `dst` must be properly aligned.
 ///
@@ -2141,12 +2166,6 @@ pub unsafe fn read_volatile<T>(src: *const T) -> T {
 ///
 /// [valid]: self#safety
 ///
-/// Just like in C, whether an operation is volatile has no bearing whatsoever
-/// on questions involving concurrent access from multiple threads. Volatile
-/// accesses behave exactly like non-atomic accesses in that regard. In particular,
-/// a race between a `write_volatile` and any other operation (reading or writing)
-/// on the same location is undefined behavior.
-///
 /// # Examples
 ///
 /// Basic usage:
@@ -2170,12 +2189,11 @@ pub unsafe fn write_volatile<T>(dst: *mut T, src: T) {
     unsafe {
         ub_checks::assert_unsafe_precondition!(
             check_language_ub,
-            "ptr::write_volatile requires that the pointer argument is aligned and non-null",
+            "ptr::write_volatile requires that the pointer argument is aligned",
             (
                 addr: *mut () = dst as *mut (),
                 align: usize = align_of::<T>(),
-                is_zst: bool = T::IS_ZST,
-            ) => ub_checks::maybe_is_aligned_and_not_null(addr, align, is_zst)
+            ) => ub_checks::maybe_is_aligned(addr, align)
         );
         intrinsics::volatile_store(dst, src);
     }
diff --git a/library/core/src/ub_checks.rs b/library/core/src/ub_checks.rs
index a7caaeb95cd..b809294cfce 100644
--- a/library/core/src/ub_checks.rs
+++ b/library/core/src/ub_checks.rs
@@ -120,13 +120,25 @@ pub(crate) const fn maybe_is_aligned_and_not_null(
     align: usize,
     is_zst: bool,
 ) -> bool {
+    // This is just for safety checks so we can const_eval_select.
+    maybe_is_aligned(ptr, align) && (is_zst || !ptr.is_null())
+}
+
+/// Checks whether `ptr` is properly aligned with respect to the given alignment.
+///
+/// In `const` this is approximate and can fail spuriously. It is primarily intended
+/// for `assert_unsafe_precondition!` with `check_language_ub`, in which case the
+/// check is anyway not executed in `const`.
+#[inline]
+#[rustc_allow_const_fn_unstable(const_eval_select)]
+pub(crate) const fn maybe_is_aligned(ptr: *const (), align: usize) -> bool {
     // This is just for safety checks so we can const_eval_select.
     const_eval_select!(
-        @capture { ptr: *const (), align: usize, is_zst: bool } -> bool:
+        @capture { ptr: *const (), align: usize } -> bool:
         if const {
-            is_zst || !ptr.is_null()
+            true
         } else {
-            ptr.is_aligned_to(align) && (is_zst || !ptr.is_null())
+            ptr.is_aligned_to(align)
         }
     )
 }
diff --git a/tests/ui/lint/invalid_null_args.rs b/tests/ui/lint/invalid_null_args.rs
index f40f06a0d36..ee29d622ad7 100644
--- a/tests/ui/lint/invalid_null_args.rs
+++ b/tests/ui/lint/invalid_null_args.rs
@@ -58,10 +58,9 @@ unsafe fn null_ptr() {
     let _a: A = ptr::read_unaligned(ptr::null_mut());
     //~^ ERROR calling this function with a null pointer is undefined behavior
 
+    // These two should *not* fire the lint.
     let _a: A = ptr::read_volatile(ptr::null());
-    //~^ ERROR calling this function with a null pointer is undefined behavior
     let _a: A = ptr::read_volatile(ptr::null_mut());
-    //~^ ERROR calling this function with a null pointer is undefined behavior
 
     let _a: A = ptr::replace(ptr::null_mut(), v);
     //~^ ERROR calling this function with a null pointer is undefined behavior
@@ -82,8 +81,8 @@ unsafe fn null_ptr() {
     ptr::write_unaligned(ptr::null_mut(), v);
     //~^ ERROR calling this function with a null pointer is undefined behavior
 
+    // This one should *not* fire the lint.
     ptr::write_volatile(ptr::null_mut(), v);
-    //~^ ERROR calling this function with a null pointer is undefined behavior
 
     ptr::write_bytes::<usize>(ptr::null_mut(), 42, 0);
     //~^ ERROR calling this function with a null pointer is undefined behavior
diff --git a/tests/ui/lint/invalid_null_args.stderr b/tests/ui/lint/invalid_null_args.stderr
index 11c6270cfb7..028bd7051dc 100644
--- a/tests/ui/lint/invalid_null_args.stderr
+++ b/tests/ui/lint/invalid_null_args.stderr
@@ -164,27 +164,7 @@ LL |     let _a: A = ptr::read_unaligned(ptr::null_mut());
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:61:17
-   |
-LL |     let _a: A = ptr::read_volatile(ptr::null());
-   |                 ^^^^^^^^^^^^^^^^^^^-----------^
-   |                                    |
-   |                                    null pointer originates from here
-   |
-   = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
-
-error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:63:17
-   |
-LL |     let _a: A = ptr::read_volatile(ptr::null_mut());
-   |                 ^^^^^^^^^^^^^^^^^^^---------------^
-   |                                    |
-   |                                    null pointer originates from here
-   |
-   = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
-
-error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:66:17
+  --> $DIR/invalid_null_args.rs:65:17
    |
 LL |     let _a: A = ptr::replace(ptr::null_mut(), v);
    |                 ^^^^^^^^^^^^^---------------^^^^
@@ -194,7 +174,7 @@ LL |     let _a: A = ptr::replace(ptr::null_mut(), v);
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:69:5
+  --> $DIR/invalid_null_args.rs:68:5
    |
 LL |     ptr::swap::<A>(ptr::null_mut(), &mut v);
    |     ^^^^^^^^^^^^^^^---------------^^^^^^^^^
@@ -204,7 +184,7 @@ LL |     ptr::swap::<A>(ptr::null_mut(), &mut v);
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:71:5
+  --> $DIR/invalid_null_args.rs:70:5
    |
 LL |     ptr::swap::<A>(&mut v, ptr::null_mut());
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
@@ -214,7 +194,7 @@ LL |     ptr::swap::<A>(&mut v, ptr::null_mut());
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:74:5
+  --> $DIR/invalid_null_args.rs:73:5
    |
 LL |     ptr::swap_nonoverlapping::<A>(ptr::null_mut(), &mut v, 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------^^^^^^^^^^^^
@@ -224,7 +204,7 @@ LL |     ptr::swap_nonoverlapping::<A>(ptr::null_mut(), &mut v, 0);
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:76:5
+  --> $DIR/invalid_null_args.rs:75:5
    |
 LL |     ptr::swap_nonoverlapping::<A>(&mut v, ptr::null_mut(), 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------^^^^
@@ -234,7 +214,7 @@ LL |     ptr::swap_nonoverlapping::<A>(&mut v, ptr::null_mut(), 0);
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:79:5
+  --> $DIR/invalid_null_args.rs:78:5
    |
 LL |     ptr::write(ptr::null_mut(), v);
    |     ^^^^^^^^^^^---------------^^^^
@@ -244,7 +224,7 @@ LL |     ptr::write(ptr::null_mut(), v);
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:82:5
+  --> $DIR/invalid_null_args.rs:81:5
    |
 LL |     ptr::write_unaligned(ptr::null_mut(), v);
    |     ^^^^^^^^^^^^^^^^^^^^^---------------^^^^
@@ -254,17 +234,7 @@ LL |     ptr::write_unaligned(ptr::null_mut(), v);
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:85:5
-   |
-LL |     ptr::write_volatile(ptr::null_mut(), v);
-   |     ^^^^^^^^^^^^^^^^^^^^---------------^^^^
-   |                         |
-   |                         null pointer originates from here
-   |
-   = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
-
-error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:88:5
+  --> $DIR/invalid_null_args.rs:87:5
    |
 LL |     ptr::write_bytes::<usize>(ptr::null_mut(), 42, 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^---------------^^^^^^^^
@@ -274,7 +244,7 @@ LL |     ptr::write_bytes::<usize>(ptr::null_mut(), 42, 0);
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:93:18
+  --> $DIR/invalid_null_args.rs:92:18
    |
 LL |     let _a: u8 = ptr::read(const_ptr);
    |                  ^^^^^^^^^^^^^^^^^^^^
@@ -287,7 +257,7 @@ LL |     let null_ptr = ptr::null_mut();
    |                    ^^^^^^^^^^^^^^^
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:100:5
+  --> $DIR/invalid_null_args.rs:99:5
    |
 LL |     std::slice::from_raw_parts::<()>(ptr::null(), 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -297,7 +267,7 @@ LL |     std::slice::from_raw_parts::<()>(ptr::null(), 0);
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:102:5
+  --> $DIR/invalid_null_args.rs:101:5
    |
 LL |     std::slice::from_raw_parts::<Zst>(ptr::null(), 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -307,7 +277,7 @@ LL |     std::slice::from_raw_parts::<Zst>(ptr::null(), 0);
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:104:5
+  --> $DIR/invalid_null_args.rs:103:5
    |
 LL |     std::slice::from_raw_parts_mut::<()>(ptr::null_mut(), 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------^^^^
@@ -317,7 +287,7 @@ LL |     std::slice::from_raw_parts_mut::<()>(ptr::null_mut(), 0);
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
 error: calling this function with a null pointer is undefined behavior, even if the result of the function is unused
-  --> $DIR/invalid_null_args.rs:106:5
+  --> $DIR/invalid_null_args.rs:105:5
    |
 LL |     std::slice::from_raw_parts_mut::<Zst>(ptr::null_mut(), 0);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------^^^^
@@ -326,5 +296,5 @@ LL |     std::slice::from_raw_parts_mut::<Zst>(ptr::null_mut(), 0);
    |
    = help: for more information, visit <https://doc.rust-lang.org/std/ptr/index.html> and <https://doc.rust-lang.org/reference/behavior-considered-undefined.html>
 
-error: aborting due to 31 previous errors
+error: aborting due to 28 previous errors
 
diff --git a/tests/ui/precondition-checks/read_volatile.rs b/tests/ui/precondition-checks/read_volatile.rs
index ada8932c398..d858e6b939a 100644
--- a/tests/ui/precondition-checks/read_volatile.rs
+++ b/tests/ui/precondition-checks/read_volatile.rs
@@ -1,9 +1,7 @@
 //@ run-fail
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: ptr::read_volatile requires
-//@ revisions: null misaligned
-
-#![allow(invalid_null_arguments)]
+//@ revisions: misaligned
 
 use std::ptr;
 
@@ -11,8 +9,6 @@ fn main() {
     let src = [0u16; 2];
     let src = src.as_ptr();
     unsafe {
-        #[cfg(null)]
-        ptr::read_volatile(ptr::null::<u8>());
         #[cfg(misaligned)]
         ptr::read_volatile(src.byte_add(1));
     }
diff --git a/tests/ui/precondition-checks/write_volatile.rs b/tests/ui/precondition-checks/write_volatile.rs
index 0d5ecb014b3..ddc882be432 100644
--- a/tests/ui/precondition-checks/write_volatile.rs
+++ b/tests/ui/precondition-checks/write_volatile.rs
@@ -1,9 +1,7 @@
 //@ run-fail
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: ptr::write_volatile requires
-//@ revisions: null misaligned
-
-#![allow(invalid_null_arguments)]
+//@ revisions: misaligned
 
 use std::ptr;
 
@@ -11,8 +9,6 @@ fn main() {
     let mut dst = [0u16; 2];
     let mut dst = dst.as_mut_ptr();
     unsafe {
-        #[cfg(null)]
-        ptr::write_volatile(ptr::null_mut::<u8>(), 1u8);
         #[cfg(misaligned)]
         ptr::write_volatile(dst.byte_add(1), 1u16);
     }
-- 
cgit 1.4.1-3-g733a5


From 4cebbabd5ce3fdb1444cc7efdb8e07eff52b6652 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Fri, 18 Jul 2025 16:47:39 +0000
Subject: Add implicit sized bound to trait ascription types

---
 .../rustc_hir_analysis/src/hir_ty_lowering/mod.rs     |  8 ++++++++
 tests/ui/impl-trait/in-bindings/implicit-sized.rs     | 19 +++++++++++++++++++
 tests/ui/impl-trait/in-bindings/implicit-sized.stderr | 11 +++++++++++
 3 files changed, 38 insertions(+)
 create mode 100644 tests/ui/impl-trait/in-bindings/implicit-sized.rs
 create mode 100644 tests/ui/impl-trait/in-bindings/implicit-sized.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 a5bd7c1a34a..2a6ba31d5ab 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2489,6 +2489,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     ty::List::empty(),
                     PredicateFilter::All,
                 );
+                self.add_sizedness_bounds(
+                    &mut bounds,
+                    self_ty,
+                    hir_bounds,
+                    None,
+                    None,
+                    hir_ty.span,
+                );
                 self.register_trait_ascription_bounds(bounds, hir_ty.hir_id, hir_ty.span);
                 self_ty
             }
diff --git a/tests/ui/impl-trait/in-bindings/implicit-sized.rs b/tests/ui/impl-trait/in-bindings/implicit-sized.rs
new file mode 100644
index 00000000000..2f16db94189
--- /dev/null
+++ b/tests/ui/impl-trait/in-bindings/implicit-sized.rs
@@ -0,0 +1,19 @@
+#![feature(impl_trait_in_bindings)]
+
+trait Trait {}
+impl<T: ?Sized> Trait for T {}
+
+fn doesnt_work() {
+    let x: &impl Trait = "hi";
+    //~^ ERROR the size for values of type `str` cannot be known at compilation time
+}
+
+fn works() {
+    let x: &(impl Trait + ?Sized) = "hi";
+    // No implicit sized.
+
+    let x: &impl Trait = &();
+    // Is actually sized.
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/in-bindings/implicit-sized.stderr b/tests/ui/impl-trait/in-bindings/implicit-sized.stderr
new file mode 100644
index 00000000000..465a928cf86
--- /dev/null
+++ b/tests/ui/impl-trait/in-bindings/implicit-sized.stderr
@@ -0,0 +1,11 @@
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+  --> $DIR/implicit-sized.rs:7:13
+   |
+LL |     let x: &impl Trait = "hi";
+   |             ^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `str`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
-- 
cgit 1.4.1-3-g733a5


From 664d742933e020f70032e0fd8cd9c8869848fd4f Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Fri, 18 Jul 2025 18:29:29 +0200
Subject: rustc_codegen_ssa: Don't skip target-features after crt-static

The current behaviour introduced by commit
a50a3b8e318594c41783294e440d864763e412ef would discard any
target features specified after crt-static (the only member of
RUSTC_SPECIFIC_FEATURES). This is because it returned instead of
continuing processing the next flag.

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 compiler/rustc_codegen_ssa/src/target_features.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/target_features.rs b/compiler/rustc_codegen_ssa/src/target_features.rs
index 53df99993f0..def4ec13e87 100644
--- a/compiler/rustc_codegen_ssa/src/target_features.rs
+++ b/compiler/rustc_codegen_ssa/src/target_features.rs
@@ -149,14 +149,14 @@ fn parse_rust_feature_flag<'a>(
         if let Some(base_feature) = feature.strip_prefix('+') {
             // Skip features that are not target features, but rustc features.
             if RUSTC_SPECIFIC_FEATURES.contains(&base_feature) {
-                return;
+                continue;
             }
 
             callback(base_feature, sess.target.implied_target_features(base_feature), true)
         } else if let Some(base_feature) = feature.strip_prefix('-') {
             // Skip features that are not target features, but rustc features.
             if RUSTC_SPECIFIC_FEATURES.contains(&base_feature) {
-                return;
+                continue;
             }
 
             // If `f1` implies `f2`, then `!f2` implies `!f1` -- this is standard logical
-- 
cgit 1.4.1-3-g733a5


From 1b35d5f89c4e3c605cd455a28f00aad24de0a662 Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Fri, 18 Jul 2025 18:55:33 +0200
Subject: tests: Add a regression test for crt-static with target features

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 .../cfg/crt-static-with-target-features-works.rs   | 24 ++++++++++++++++++++++
 .../crt-static-with-target-features-works.stderr   |  8 ++++++++
 2 files changed, 32 insertions(+)
 create mode 100644 tests/ui/cfg/crt-static-with-target-features-works.rs
 create mode 100644 tests/ui/cfg/crt-static-with-target-features-works.stderr

diff --git a/tests/ui/cfg/crt-static-with-target-features-works.rs b/tests/ui/cfg/crt-static-with-target-features-works.rs
new file mode 100644
index 00000000000..bce02229624
--- /dev/null
+++ b/tests/ui/cfg/crt-static-with-target-features-works.rs
@@ -0,0 +1,24 @@
+// Test to ensure that specifying a value for crt-static in target features
+// does not result in skipping the features following it.
+// This is a regression test for #144143
+
+//@ add-core-stubs
+//@ needs-llvm-components: x86
+//@ compile-flags: --target=x86_64-unknown-linux-gnu
+//@ compile-flags: -Ctarget-feature=+crt-static,+avx2
+
+#![crate_type = "rlib"]
+#![feature(no_core, rustc_attrs, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[rustc_builtin_macro]
+macro_rules! compile_error {
+    () => {};
+}
+
+#[cfg(target_feature = "avx2")]
+compile_error!("+avx2");
+//~^ ERROR: +avx2
diff --git a/tests/ui/cfg/crt-static-with-target-features-works.stderr b/tests/ui/cfg/crt-static-with-target-features-works.stderr
new file mode 100644
index 00000000000..6f265c685bb
--- /dev/null
+++ b/tests/ui/cfg/crt-static-with-target-features-works.stderr
@@ -0,0 +1,8 @@
+error: +avx2
+  --> $DIR/crt-static-with-target-features-works.rs:23:1
+   |
+LL | compile_error!("+avx2");
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
-- 
cgit 1.4.1-3-g733a5


From d1a146bbbbe2de47b77aacf3cb47eb79eb39338b Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Fri, 18 Jul 2025 18:33:26 +0200
Subject: tests: Skip supported-crate-types test on musl hosts

This test depends on the target-specific behavior of crt-static for musl
targets. However, running the testsuite on a musl host requires
setting `crt-static` to `false`, as it wouldn't otherwise be possible to
build rustc. This in turn will enable `-Ctarget-feature=-crt-static` for
all tests, mismatching the expected `+crt-static` for the musl target
tested in this testcase.

Since this test specifically tests the default value of `crt-static` for
the musl target, ignoring it entirely makes more sense than manually
setting `-Ctarget-feature=+crt-static` here, but both would be valid
approaches.

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 tests/ui/print-request/supported-crate-types.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/ui/print-request/supported-crate-types.rs b/tests/ui/print-request/supported-crate-types.rs
index c8b4c0c1a41..50185a231ee 100644
--- a/tests/ui/print-request/supported-crate-types.rs
+++ b/tests/ui/print-request/supported-crate-types.rs
@@ -8,6 +8,11 @@
 
 //@ check-pass
 
+// FIXME: musl targets are currently statically linked, but running on a musl host
+// requires dynamic linkage, which in turn changes the supported crate types for
+// x86_64-unknown-linux-musl.
+//@ ignore-musl
+
 //@ revisions: wasm musl linux
 
 //@[wasm] compile-flags: --target=wasm32-unknown-unknown --print=supported-crate-types -Zunstable-options
-- 
cgit 1.4.1-3-g733a5


From b2e94bf020a99473cf80f05f410af8a5cfc486a6 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 18 Jul 2025 00:20:17 +0800
Subject: Add test demonstrating current beta `#[align]` name resolution
 regression

See RUST-143834.
---
 .../fn-align-nameres-ambiguity-143834.rs           | 21 +++++++++++++++++++++
 .../fn-align-nameres-ambiguity-143834.stderr       | 22 ++++++++++++++++++++++
 2 files changed, 43 insertions(+)
 create mode 100644 tests/ui/attributes/fn-align-nameres-ambiguity-143834.rs
 create mode 100644 tests/ui/attributes/fn-align-nameres-ambiguity-143834.stderr

diff --git a/tests/ui/attributes/fn-align-nameres-ambiguity-143834.rs b/tests/ui/attributes/fn-align-nameres-ambiguity-143834.rs
new file mode 100644
index 00000000000..5629f92c468
--- /dev/null
+++ b/tests/ui/attributes/fn-align-nameres-ambiguity-143834.rs
@@ -0,0 +1,21 @@
+//~ NOTE `align` could refer to a built-in attribute
+
+// Anti-regression test to demonstrate that at least we mitigated breakage from adding a new
+// `#[align]` built-in attribute.
+
+// Needs edition >= 2018 macro use behavior.
+//@ edition: 2018
+
+macro_rules! align {
+    //~^ NOTE `align` could also refer to the macro defined here
+    () => {
+        /* .. */
+    };
+}
+
+pub(crate) use align;
+//~^ ERROR `align` is ambiguous
+//~| NOTE ambiguous name
+//~| NOTE ambiguous because of a name conflict with a builtin attribute
+
+fn main() {}
diff --git a/tests/ui/attributes/fn-align-nameres-ambiguity-143834.stderr b/tests/ui/attributes/fn-align-nameres-ambiguity-143834.stderr
new file mode 100644
index 00000000000..304537173a8
--- /dev/null
+++ b/tests/ui/attributes/fn-align-nameres-ambiguity-143834.stderr
@@ -0,0 +1,22 @@
+error[E0659]: `align` is ambiguous
+  --> $DIR/fn-align-nameres-ambiguity-143834.rs:16:16
+   |
+LL | pub(crate) use align;
+   |                ^^^^^ ambiguous name
+   |
+   = note: ambiguous because of a name conflict with a builtin attribute
+   = note: `align` could refer to a built-in attribute
+note: `align` could also refer to the macro defined here
+  --> $DIR/fn-align-nameres-ambiguity-143834.rs:9:1
+   |
+LL | / macro_rules! align {
+LL | |
+LL | |     () => {
+LL | |         /* .. */
+LL | |     };
+LL | | }
+   | |_^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0659`.
-- 
cgit 1.4.1-3-g733a5


From e6f283080c794609dadd2ded323d5af76c99b5e9 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Fri, 18 Jul 2025 17:30:00 +0000
Subject: Remove pretty print hack for async blocks

---
 compiler/rustc_middle/src/ty/print/pretty.rs | 26 +-------------------------
 1 file changed, 1 insertion(+), 25 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 2eb530f328d..9ee64df0ad0 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1210,30 +1210,6 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                     }
 
                     for (assoc_item_def_id, term) in assoc_items {
-                        // Skip printing `<{coroutine@} as Coroutine<_>>::Return` from async blocks,
-                        // unless we can find out what coroutine return type it comes from.
-                        let term = if let Some(ty) = term.skip_binder().as_type()
-                            && let ty::Alias(ty::Projection, proj) = ty.kind()
-                            && let Some(assoc) = tcx.opt_associated_item(proj.def_id)
-                            && assoc
-                                .trait_container(tcx)
-                                .is_some_and(|def_id| tcx.is_lang_item(def_id, LangItem::Coroutine))
-                            && assoc.opt_name() == Some(rustc_span::sym::Return)
-                        {
-                            if let ty::Coroutine(_, args) = args.type_at(0).kind() {
-                                let return_ty = args.as_coroutine().return_ty();
-                                if !return_ty.is_ty_var() {
-                                    return_ty.into()
-                                } else {
-                                    continue;
-                                }
-                            } else {
-                                continue;
-                            }
-                        } else {
-                            term.skip_binder()
-                        };
-
                         if first {
                             p!("<");
                             first = false;
@@ -1243,7 +1219,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
 
                         p!(write("{} = ", tcx.associated_item(assoc_item_def_id).name()));
 
-                        match term.kind() {
+                        match term.skip_binder().kind() {
                             TermKind::Ty(ty) => p!(print(ty)),
                             TermKind::Const(c) => p!(print(c)),
                         };
-- 
cgit 1.4.1-3-g733a5


From fb1a205a559e5d8302de4c428cfab14942e520c9 Mon Sep 17 00:00:00 2001
From: Micke <155267459+reallesee@users.noreply.github.com>
Date: Fri, 18 Jul 2025 19:31:37 +0200
Subject: docs: update link to RISC-V and Xtensa installation guide

---
 src/doc/rustc/src/platform-support/xtensa.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/rustc/src/platform-support/xtensa.md b/src/doc/rustc/src/platform-support/xtensa.md
index 994b3adb92e..8592ce7eda9 100644
--- a/src/doc/rustc/src/platform-support/xtensa.md
+++ b/src/doc/rustc/src/platform-support/xtensa.md
@@ -24,4 +24,4 @@ Xtensa targets that support `std` are documented in the [ESP-IDF platform suppor
 
 ## Building the targets
 
-The targets can be built by installing the [Xtensa enabled Rust channel](https://github.com/esp-rs/rust/). See instructions in the [RISC-V and Xtensa Targets section of The Rust on ESP Book](https://docs.esp-rs.org/book/installation/riscv-and-xtensa.html).
+The targets can be built by installing the [Xtensa enabled Rust channel](https://github.com/esp-rs/rust/). See instructions in the [RISC-V and Xtensa Targets section of The Rust on ESP Book](https://docs.espressif.com/projects/rust/book/installation/index.html).
-- 
cgit 1.4.1-3-g733a5


From 7dacaef5d3c252ea47287ce34234a89e3c5ff57e Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Fri, 18 Jul 2025 17:35:57 +0000
Subject: mem: Use `core::ffi::c_int`

This alias was added in 9897bfb8a ("Fix memset arguments for MSP430
target"), which predates `core::ffi`. Now that it exists we can just use
`core::ffi::c_int`.
---
 library/compiler-builtins/compiler-builtins/src/mem/mod.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/library/compiler-builtins/compiler-builtins/src/mem/mod.rs b/library/compiler-builtins/compiler-builtins/src/mem/mod.rs
index 6828f3804e0..a6f533cb725 100644
--- a/library/compiler-builtins/compiler-builtins/src/mem/mod.rs
+++ b/library/compiler-builtins/compiler-builtins/src/mem/mod.rs
@@ -3,13 +3,6 @@
 // FIXME(e2024): this eventually needs to be removed.
 #![allow(unsafe_op_in_unsafe_fn)]
 
-#[allow(warnings)]
-#[cfg(target_pointer_width = "16")]
-type c_int = i16;
-#[allow(warnings)]
-#[cfg(not(target_pointer_width = "16"))]
-type c_int = i32;
-
 // memcpy/memmove/memset have optimized implementations on some architectures
 #[cfg_attr(
     all(not(feature = "no-asm"), target_arch = "x86_64"),
@@ -38,7 +31,7 @@ intrinsics! {
     }
 
     #[mem_builtin]
-    pub unsafe extern "C" fn memset(s: *mut u8, c: crate::mem::c_int, n: usize) -> *mut u8 {
+    pub unsafe extern "C" fn memset(s: *mut u8, c: core::ffi::c_int, n: usize) -> *mut u8 {
         impls::set_bytes(s, c as u8, n);
         s
     }
-- 
cgit 1.4.1-3-g733a5


From 69b71e44107b4905ec7ad84ccb3edf4f14b3df69 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Fri, 18 Jul 2025 00:10:46 +0800
Subject: Mitigate `#[align]` name resolution ambiguity regression with a
 rename

From `#[align]` -> `#[rustc_align]`. Attributes starting with `rustc`
are always perma-unstable and feature-gated by `feature(rustc_attrs)`.

See regression RUST-143834.

For the underlying problem where even introducing new feature-gated
unstable built-in attributes can break user code such as

```rs
macro_rules! align {
    () => {
        /* .. */
    };
}

pub(crate) use align; // `use` here becomes ambiguous
```

refer to RUST-134963.

Since the `#[align]` attribute is still feature-gated by
`feature(fn_align)`, we can rename it as a mitigation. Note that
`#[rustc_align]` will obviously mean that current unstable user code
using `feature(fn_aling)` will need additionally `feature(rustc_attrs)`,
but this is a short-term mitigation to buy time, and is expected to be
changed to a better name with less collision potential.

See
<https://rust-lang.zulipchat.com/#narrow/channel/238009-t-compiler.2Fmeetings/topic/.5Bweekly.5D.202025-07-17/near/529290371>
where mitigation options were considered.
---
 .../rustc_attr_data_structures/src/attributes.rs   |   1 +
 .../src/attributes/codegen_attrs.rs                |   3 +-
 compiler/rustc_attr_parsing/src/attributes/repr.rs |   2 +-
 compiler/rustc_feature/src/builtin_attrs.rs        |   3 +-
 .../rustc_middle/src/middle/codegen_fn_attrs.rs    |   1 +
 compiler/rustc_parse/src/validate_attr.rs          |   4 +-
 compiler/rustc_passes/messages.ftl                 |   6 +-
 compiler/rustc_passes/src/check_attr.rs            |   1 +
 compiler/rustc_span/src/symbol.rs                  |   2 +
 src/tools/miri/tests/pass/fn_align.rs              |  10 +-
 tests/codegen/align-fn.rs                          |  54 +++----
 tests/codegen/min-function-alignment.rs            |   6 +-
 tests/codegen/naked-fn/aligned.rs                  |   5 +-
 tests/codegen/naked-fn/min-function-alignment.rs   |   6 +-
 tests/ui/asm/naked-with-invalid-repr-attr.rs       |   6 +-
 tests/ui/asm/naked-with-invalid-repr-attr.stderr   |  12 +-
 tests/ui/attributes/fn-align-dyn.rs                |   7 +-
 .../fn-align-nameres-ambiguity-143834.rs           |  10 +-
 .../fn-align-nameres-ambiguity-143834.stderr       |  22 ---
 tests/ui/attributes/malformed-attrs.rs             |   3 +-
 tests/ui/attributes/malformed-attrs.stderr         | 170 ++++++++++-----------
 tests/ui/attributes/malformed-fn-align.rs          |  35 +++--
 tests/ui/attributes/malformed-fn-align.stderr      | 116 +++++++-------
 tests/ui/feature-gates/feature-gate-fn_align.rs    |  14 +-
 .../ui/feature-gates/feature-gate-fn_align.stderr  |  26 ++--
 25 files changed, 270 insertions(+), 255 deletions(-)
 delete mode 100644 tests/ui/attributes/fn-align-nameres-ambiguity-143834.stderr

diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 3157b18b635..9f99b33adcc 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -234,6 +234,7 @@ pub enum CfgEntry {
 pub enum AttributeKind {
     // tidy-alphabetical-start
     /// Represents `#[align(N)]`.
+    // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
     Align { align: Align, span: Span },
 
     /// Represents `#[rustc_allow_const_fn_unstable]`.
diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
index 3e542771d58..bb28121c2c5 100644
--- a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -177,7 +177,8 @@ impl<S: Stage> AttributeParser<S> for NakedParser {
             sym::instruction_set,
             sym::repr,
             sym::rustc_std_internal_symbol,
-            sym::align,
+            // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+            sym::rustc_align,
             // obviously compatible with self
             sym::naked,
             // documentation
diff --git a/compiler/rustc_attr_parsing/src/attributes/repr.rs b/compiler/rustc_attr_parsing/src/attributes/repr.rs
index 6a45832ed7f..521acbb607c 100644
--- a/compiler/rustc_attr_parsing/src/attributes/repr.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/repr.rs
@@ -274,7 +274,7 @@ fn parse_alignment(node: &LitKind) -> Result<Align, &'static str> {
 pub(crate) struct AlignParser(Option<(Align, Span)>);
 
 impl AlignParser {
-    const PATH: &'static [Symbol] = &[sym::align];
+    const PATH: &'static [Symbol] = &[sym::rustc_align];
     const TEMPLATE: AttributeTemplate = template!(List: "<alignment in bytes>");
 
     fn parse<'c, S: Stage>(
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 74872504b79..96df6aa19bc 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -490,7 +490,8 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     ),
     ungated!(no_link, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No),
     ungated!(repr, Normal, template!(List: "C"), DuplicatesOk, EncodeCrossCrate::No),
-    gated!(align, Normal, template!(List: "alignment"), DuplicatesOk, EncodeCrossCrate::No, fn_align, experimental!(align)),
+    // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+    gated!(rustc_align, Normal, template!(List: "alignment"), DuplicatesOk, EncodeCrossCrate::No, fn_align, experimental!(rustc_align)),
     ungated!(unsafe(Edition2024) export_name, Normal, template!(NameValueStr: "name"), FutureWarnPreceding, EncodeCrossCrate::No),
     ungated!(unsafe(Edition2024) link_section, Normal, template!(NameValueStr: "name"), FutureWarnPreceding, EncodeCrossCrate::No),
     ungated!(unsafe(Edition2024) no_mangle, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No),
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
index 6eae3b51e29..34a29acdc85 100644
--- a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
+++ b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -70,6 +70,7 @@ pub struct CodegenFnAttrs {
     /// switching between multiple instruction sets.
     pub instruction_set: Option<InstructionSetAttr>,
     /// The `#[align(...)]` attribute. Determines the alignment of the function body.
+    // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
     pub alignment: Option<Align>,
     /// The `#[patchable_function_entry(...)]` attribute. Indicates how many nops should be around
     /// the function entry.
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index a476f0db37e..cca621103b5 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -294,7 +294,9 @@ pub fn check_builtin_meta_item(
                 | sym::rustc_paren_sugar
                 | sym::type_const
                 | sym::repr
-                | sym::align
+                // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres
+                // ambiguity
+                | sym::rustc_align
                 | sym::deprecated
                 | sym::optimize
                 | sym::pointee
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index d1b856ca415..f5375f23541 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -14,7 +14,7 @@ passes_abi_of =
     fn_abi_of({$fn_name}) = {$fn_abi}
 
 passes_align_attr_application =
-    `#[align(...)]` should be applied to a function item
+    `#[rustc_align(...)]` should be applied to a function item
     .label = not a function item
 
 passes_align_on_fields =
@@ -22,7 +22,7 @@ passes_align_on_fields =
     .warn = {-passes_previously_accepted}
 
 passes_align_should_be_repr_align =
-    `#[align(...)]` is not supported on {$item} items
+    `#[rustc_align(...)]` is not supported on {$item} items
     .suggestion = use `#[repr(align(...))]` instead
 
 passes_allow_incoherent_impl =
@@ -604,7 +604,7 @@ passes_repr_align_greater_than_target_max =
 
 passes_repr_align_should_be_align =
     `#[repr(align(...))]` is not supported on {$item} items
-    .help = use `#[align(...)]` instead
+    .help = use `#[rustc_align(...)]` instead
 
 passes_repr_conflicting =
     conflicting representation hints
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2766b14bb8d..4f35bcc6be1 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1957,6 +1957,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     }
 
     /// Checks if the `#[align]` attributes on `item` are valid.
+    // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
     fn check_align(
         &self,
         span: Span,
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index d28a73bc139..762126a4aaa 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1809,6 +1809,8 @@ symbols! {
         rust_out,
         rustc,
         rustc_abi,
+        // FIXME(#82232, #143834): temporary name to mitigate `#[align]` nameres ambiguity
+        rustc_align,
         rustc_allocator,
         rustc_allocator_zeroed,
         rustc_allow_const_fn_unstable,
diff --git a/src/tools/miri/tests/pass/fn_align.rs b/src/tools/miri/tests/pass/fn_align.rs
index 28f92995880..9752d033458 100644
--- a/src/tools/miri/tests/pass/fn_align.rs
+++ b/src/tools/miri/tests/pass/fn_align.rs
@@ -1,15 +1,19 @@
 //@compile-flags: -Zmin-function-alignment=8
+
+// FIXME(rust-lang/rust#82232, rust-lang/rust#143834): temporarily renamed to mitigate `#[align]`
+// nameres ambiguity
+#![feature(rustc_attrs)]
 #![feature(fn_align)]
 
 // When a function uses `align(N)`, the function address should be a multiple of `N`.
 
-#[align(256)]
+#[rustc_align(256)]
 fn foo() {}
 
-#[align(16)]
+#[rustc_align(16)]
 fn bar() {}
 
-#[align(4)]
+#[rustc_align(4)]
 fn baz() {}
 
 fn main() {
diff --git a/tests/codegen/align-fn.rs b/tests/codegen/align-fn.rs
index fd572910c28..cbc24e2ae2e 100644
--- a/tests/codegen/align-fn.rs
+++ b/tests/codegen/align-fn.rs
@@ -3,11 +3,13 @@
 //@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
 
 #![crate_type = "lib"]
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+#![feature(rustc_attrs)]
 #![feature(fn_align)]
 
 // CHECK: align 16
 #[unsafe(no_mangle)]
-#[align(16)]
+#[rustc_align(16)]
 pub fn fn_align() {}
 
 pub struct A;
@@ -15,12 +17,12 @@ pub struct A;
 impl A {
     // CHECK: align 16
     #[unsafe(no_mangle)]
-    #[align(16)]
+    #[rustc_align(16)]
     pub fn method_align(self) {}
 
     // CHECK: align 16
     #[unsafe(no_mangle)]
-    #[align(16)]
+    #[rustc_align(16)]
     pub fn associated_fn() {}
 }
 
@@ -29,18 +31,18 @@ trait T: Sized {
 
     fn trait_method(self) {}
 
-    #[align(8)]
+    #[rustc_align(8)]
     fn trait_method_inherit_low(self);
 
-    #[align(32)]
+    #[rustc_align(32)]
     fn trait_method_inherit_high(self);
 
-    #[align(32)]
+    #[rustc_align(32)]
     fn trait_method_inherit_default(self) {}
 
-    #[align(4)]
-    #[align(128)]
-    #[align(8)]
+    #[rustc_align(4)]
+    #[rustc_align(128)]
+    #[rustc_align(8)]
     fn inherit_highest(self) {}
 }
 
@@ -48,27 +50,27 @@ impl T for A {
     // CHECK-LABEL: trait_fn
     // CHECK-SAME: align 16
     #[unsafe(no_mangle)]
-    #[align(16)]
+    #[rustc_align(16)]
     fn trait_fn() {}
 
     // CHECK-LABEL: trait_method
     // CHECK-SAME: align 16
     #[unsafe(no_mangle)]
-    #[align(16)]
+    #[rustc_align(16)]
     fn trait_method(self) {}
 
     // The prototype's align is ignored because the align here is higher.
     // CHECK-LABEL: trait_method_inherit_low
     // CHECK-SAME: align 16
     #[unsafe(no_mangle)]
-    #[align(16)]
+    #[rustc_align(16)]
     fn trait_method_inherit_low(self) {}
 
     // The prototype's align is used because it is higher.
     // CHECK-LABEL: trait_method_inherit_high
     // CHECK-SAME: align 32
     #[unsafe(no_mangle)]
-    #[align(16)]
+    #[rustc_align(16)]
     fn trait_method_inherit_high(self) {}
 
     // The prototype's align inherited.
@@ -81,8 +83,8 @@ impl T for A {
     // CHECK-LABEL: inherit_highest
     // CHECK-SAME: align 128
     #[unsafe(no_mangle)]
-    #[align(32)]
-    #[align(64)]
+    #[rustc_align(32)]
+    #[rustc_align(64)]
     fn inherit_highest(self) {}
 }
 
@@ -90,7 +92,7 @@ trait HasDefaultImpl: Sized {
     // CHECK-LABEL: inherit_from_default_method
     // CHECK-LABEL: inherit_from_default_method
     // CHECK-SAME: align 32
-    #[align(32)]
+    #[rustc_align(32)]
     fn inherit_from_default_method(self) {}
 }
 
@@ -101,35 +103,35 @@ impl HasDefaultImpl for InstantiateDefaultMethods {}
 // CHECK-LABEL: align_specified_twice_1
 // CHECK-SAME: align 64
 #[unsafe(no_mangle)]
-#[align(32)]
-#[align(64)]
+#[rustc_align(32)]
+#[rustc_align(64)]
 pub fn align_specified_twice_1() {}
 
 // CHECK-LABEL: align_specified_twice_2
 // CHECK-SAME: align 128
 #[unsafe(no_mangle)]
-#[align(128)]
-#[align(32)]
+#[rustc_align(128)]
+#[rustc_align(32)]
 pub fn align_specified_twice_2() {}
 
 // CHECK-LABEL: align_specified_twice_3
 // CHECK-SAME: align 256
 #[unsafe(no_mangle)]
-#[align(32)]
-#[align(256)]
+#[rustc_align(32)]
+#[rustc_align(256)]
 pub fn align_specified_twice_3() {}
 
 const _: () = {
     // CHECK-LABEL: align_unmangled
     // CHECK-SAME: align 256
     #[unsafe(no_mangle)]
-    #[align(32)]
-    #[align(256)]
+    #[rustc_align(32)]
+    #[rustc_align(256)]
     extern "C" fn align_unmangled() {}
 };
 
 unsafe extern "C" {
-    #[align(256)]
+    #[rustc_align(256)]
     fn align_unmangled();
 }
 
@@ -137,5 +139,5 @@ unsafe extern "C" {
 // CHECK-LABEL: async_align
 // CHECK-SAME: align 64
 #[unsafe(no_mangle)]
-#[align(64)]
+#[rustc_align(64)]
 pub async fn async_align() {}
diff --git a/tests/codegen/min-function-alignment.rs b/tests/codegen/min-function-alignment.rs
index 6a3843b0f4f..ea5f957e81f 100644
--- a/tests/codegen/min-function-alignment.rs
+++ b/tests/codegen/min-function-alignment.rs
@@ -5,6 +5,8 @@
 //@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
 
 #![crate_type = "lib"]
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+#![feature(rustc_attrs)]
 #![feature(fn_align)]
 
 // Functions without explicit alignment use the global minimum.
@@ -21,7 +23,7 @@ pub fn no_explicit_align() {}
 // align16: align 16
 // align1024: align 1024
 #[no_mangle]
-#[align(8)]
+#[rustc_align(8)]
 pub fn lower_align() {}
 
 // the higher value of min-function-alignment and the align attribute wins out
@@ -30,7 +32,7 @@ pub fn lower_align() {}
 // align16: align 32
 // align1024: align 1024
 #[no_mangle]
-#[align(32)]
+#[rustc_align(32)]
 pub fn higher_align() {}
 
 // cold functions follow the same rules as other functions
diff --git a/tests/codegen/naked-fn/aligned.rs b/tests/codegen/naked-fn/aligned.rs
index 2648b0213ca..d7281c4219a 100644
--- a/tests/codegen/naked-fn/aligned.rs
+++ b/tests/codegen/naked-fn/aligned.rs
@@ -4,12 +4,15 @@
 //@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
 
 #![crate_type = "lib"]
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+#![feature(rustc_attrs)]
 #![feature(fn_align)]
+
 use std::arch::naked_asm;
 
 // CHECK: .balign 16
 // CHECK-LABEL: naked_empty:
-#[align(16)]
+#[rustc_align(16)]
 #[no_mangle]
 #[unsafe(naked)]
 pub extern "C" fn naked_empty() {
diff --git a/tests/codegen/naked-fn/min-function-alignment.rs b/tests/codegen/naked-fn/min-function-alignment.rs
index 4ebaacd3eff..406e9334fa5 100644
--- a/tests/codegen/naked-fn/min-function-alignment.rs
+++ b/tests/codegen/naked-fn/min-function-alignment.rs
@@ -3,6 +3,8 @@
 //@ ignore-arm no "ret" mnemonic
 //@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
 
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+#![feature(rustc_attrs)]
 #![feature(fn_align)]
 #![crate_type = "lib"]
 
@@ -17,7 +19,7 @@ pub extern "C" fn naked_no_explicit_align() {
 
 // CHECK: .balign 16
 #[no_mangle]
-#[align(8)]
+#[rustc_align(8)]
 #[unsafe(naked)]
 pub extern "C" fn naked_lower_align() {
     core::arch::naked_asm!("ret")
@@ -25,7 +27,7 @@ pub extern "C" fn naked_lower_align() {
 
 // CHECK: .balign 32
 #[no_mangle]
-#[align(32)]
+#[rustc_align(32)]
 #[unsafe(naked)]
 pub extern "C" fn naked_higher_align() {
     core::arch::naked_asm!("ret")
diff --git a/tests/ui/asm/naked-with-invalid-repr-attr.rs b/tests/ui/asm/naked-with-invalid-repr-attr.rs
index bfbbf29a69e..4620d007e4e 100644
--- a/tests/ui/asm/naked-with-invalid-repr-attr.rs
+++ b/tests/ui/asm/naked-with-invalid-repr-attr.rs
@@ -1,5 +1,9 @@
 //@ needs-asm-support
+
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+#![feature(rustc_attrs)]
 #![feature(fn_align)]
+
 #![crate_type = "lib"]
 use std::arch::naked_asm;
 
@@ -21,7 +25,7 @@ extern "C" fn example2() {
 
 #[repr(C)]
 //~^ ERROR attribute should be applied to a struct, enum, or union [E0517]
-#[align(16)]
+#[rustc_align(16)]
 #[unsafe(naked)]
 extern "C" fn example3() {
     //~^ NOTE not a struct, enum, or union
diff --git a/tests/ui/asm/naked-with-invalid-repr-attr.stderr b/tests/ui/asm/naked-with-invalid-repr-attr.stderr
index 4eb4a4e5a04..8530495be66 100644
--- a/tests/ui/asm/naked-with-invalid-repr-attr.stderr
+++ b/tests/ui/asm/naked-with-invalid-repr-attr.stderr
@@ -1,5 +1,5 @@
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/naked-with-invalid-repr-attr.rs:6:8
+  --> $DIR/naked-with-invalid-repr-attr.rs:10:8
    |
 LL |   #[repr(C)]
    |          ^
@@ -11,7 +11,7 @@ LL | | }
    | |_- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/naked-with-invalid-repr-attr.rs:14:8
+  --> $DIR/naked-with-invalid-repr-attr.rs:18:8
    |
 LL |   #[repr(transparent)]
    |          ^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL | | }
    | |_- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/naked-with-invalid-repr-attr.rs:22:8
+  --> $DIR/naked-with-invalid-repr-attr.rs:26:8
    |
 LL |   #[repr(C)]
    |          ^
@@ -35,7 +35,7 @@ LL | | }
    | |_- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct, enum, or union
-  --> $DIR/naked-with-invalid-repr-attr.rs:32:8
+  --> $DIR/naked-with-invalid-repr-attr.rs:36:8
    |
 LL |   #[repr(C, packed)]
    |          ^
@@ -48,7 +48,7 @@ LL | | }
    | |_- not a struct, enum, or union
 
 error[E0517]: attribute should be applied to a struct or union
-  --> $DIR/naked-with-invalid-repr-attr.rs:32:11
+  --> $DIR/naked-with-invalid-repr-attr.rs:36:11
    |
 LL |   #[repr(C, packed)]
    |             ^^^^^^
@@ -61,7 +61,7 @@ LL | | }
    | |_- not a struct or union
 
 error[E0517]: attribute should be applied to an enum
-  --> $DIR/naked-with-invalid-repr-attr.rs:42:8
+  --> $DIR/naked-with-invalid-repr-attr.rs:46:8
    |
 LL |   #[repr(u8)]
    |          ^^
diff --git a/tests/ui/attributes/fn-align-dyn.rs b/tests/ui/attributes/fn-align-dyn.rs
index 8ba4d5e2897..3778c75a2ca 100644
--- a/tests/ui/attributes/fn-align-dyn.rs
+++ b/tests/ui/attributes/fn-align-dyn.rs
@@ -1,12 +1,15 @@
 //@ run-pass
 //@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
+
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+#![feature(rustc_attrs)]
 #![feature(fn_align)]
 
 trait Test {
-    #[align(4096)]
+    #[rustc_align(4096)]
     fn foo(&self);
 
-    #[align(4096)]
+    #[rustc_align(4096)]
     fn foo1(&self);
 }
 
diff --git a/tests/ui/attributes/fn-align-nameres-ambiguity-143834.rs b/tests/ui/attributes/fn-align-nameres-ambiguity-143834.rs
index 5629f92c468..536d6ff43fb 100644
--- a/tests/ui/attributes/fn-align-nameres-ambiguity-143834.rs
+++ b/tests/ui/attributes/fn-align-nameres-ambiguity-143834.rs
@@ -1,21 +1,19 @@
-//~ NOTE `align` could refer to a built-in attribute
-
 // Anti-regression test to demonstrate that at least we mitigated breakage from adding a new
 // `#[align]` built-in attribute.
+//
+// See https://github.com/rust-lang/rust/issues/143834.
+
+//@ check-pass
 
 // Needs edition >= 2018 macro use behavior.
 //@ edition: 2018
 
 macro_rules! align {
-    //~^ NOTE `align` could also refer to the macro defined here
     () => {
         /* .. */
     };
 }
 
 pub(crate) use align;
-//~^ ERROR `align` is ambiguous
-//~| NOTE ambiguous name
-//~| NOTE ambiguous because of a name conflict with a builtin attribute
 
 fn main() {}
diff --git a/tests/ui/attributes/fn-align-nameres-ambiguity-143834.stderr b/tests/ui/attributes/fn-align-nameres-ambiguity-143834.stderr
deleted file mode 100644
index 304537173a8..00000000000
--- a/tests/ui/attributes/fn-align-nameres-ambiguity-143834.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error[E0659]: `align` is ambiguous
-  --> $DIR/fn-align-nameres-ambiguity-143834.rs:16:16
-   |
-LL | pub(crate) use align;
-   |                ^^^^^ ambiguous name
-   |
-   = note: ambiguous because of a name conflict with a builtin attribute
-   = note: `align` could refer to a built-in attribute
-note: `align` could also refer to the macro defined here
-  --> $DIR/fn-align-nameres-ambiguity-143834.rs:9:1
-   |
-LL | / macro_rules! align {
-LL | |
-LL | |     () => {
-LL | |         /* .. */
-LL | |     };
-LL | | }
-   | |_^
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0659`.
diff --git a/tests/ui/attributes/malformed-attrs.rs b/tests/ui/attributes/malformed-attrs.rs
index 5026687b97b..d4c6ecaa189 100644
--- a/tests/ui/attributes/malformed-attrs.rs
+++ b/tests/ui/attributes/malformed-attrs.rs
@@ -3,6 +3,7 @@
 #![feature(rustc_attrs)]
 #![feature(rustc_allow_const_fn_unstable)]
 #![feature(allow_internal_unstable)]
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
 #![feature(fn_align)]
 #![feature(optimize_attribute)]
 #![feature(dropck_eyepatch)]
@@ -53,7 +54,7 @@
 #[inline = 5]
 //~^ ERROR valid forms for the attribute are
 //~| WARN this was previously accepted by the compiler
-#[align]
+#[rustc_align]
 //~^ ERROR malformed
 #[optimize]
 //~^ ERROR malformed
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index 0d0c338d302..de53af851a3 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -1,5 +1,5 @@
 error[E0539]: malformed `cfg` attribute input
-  --> $DIR/malformed-attrs.rs:102:1
+  --> $DIR/malformed-attrs.rs:103:1
    |
 LL | #[cfg]
    | ^^^^^^
@@ -8,7 +8,7 @@ LL | #[cfg]
    | help: must be of the form: `#[cfg(predicate)]`
 
 error: malformed `cfg_attr` attribute input
-  --> $DIR/malformed-attrs.rs:104:1
+  --> $DIR/malformed-attrs.rs:105:1
    |
 LL | #[cfg_attr]
    | ^^^^^^^^^^^
@@ -20,67 +20,67 @@ LL | #[cfg_attr(condition, attribute, other_attribute, ...)]
    |           ++++++++++++++++++++++++++++++++++++++++++++
 
 error[E0463]: can't find crate for `wloop`
-  --> $DIR/malformed-attrs.rs:211:1
+  --> $DIR/malformed-attrs.rs:212:1
    |
 LL | extern crate wloop;
    | ^^^^^^^^^^^^^^^^^^^ can't find crate
 
 error: malformed `windows_subsystem` attribute input
-  --> $DIR/malformed-attrs.rs:29:1
+  --> $DIR/malformed-attrs.rs:30:1
    |
 LL | #![windows_subsystem]
    | ^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#![windows_subsystem = "windows|console"]`
 
 error: malformed `crate_name` attribute input
-  --> $DIR/malformed-attrs.rs:74:1
+  --> $DIR/malformed-attrs.rs:75:1
    |
 LL | #[crate_name]
    | ^^^^^^^^^^^^^ help: must be of the form: `#[crate_name = "name"]`
 
 error: malformed `no_sanitize` attribute input
-  --> $DIR/malformed-attrs.rs:92:1
+  --> $DIR/malformed-attrs.rs:93:1
    |
 LL | #[no_sanitize]
    | ^^^^^^^^^^^^^^ help: must be of the form: `#[no_sanitize(address, kcfi, memory, thread)]`
 
 error: malformed `proc_macro` attribute input
-  --> $DIR/malformed-attrs.rs:99:1
+  --> $DIR/malformed-attrs.rs:100:1
    |
 LL | #[proc_macro = 18]
    | ^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro]`
 
 error: malformed `instruction_set` attribute input
-  --> $DIR/malformed-attrs.rs:106:1
+  --> $DIR/malformed-attrs.rs:107:1
    |
 LL | #[instruction_set]
    | ^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[instruction_set(set)]`
 
 error: malformed `patchable_function_entry` attribute input
-  --> $DIR/malformed-attrs.rs:108:1
+  --> $DIR/malformed-attrs.rs:109:1
    |
 LL | #[patchable_function_entry]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[patchable_function_entry(prefix_nops = m, entry_nops = n)]`
 
 error: malformed `coroutine` attribute input
-  --> $DIR/malformed-attrs.rs:111:5
+  --> $DIR/malformed-attrs.rs:112:5
    |
 LL |     #[coroutine = 63] || {}
    |     ^^^^^^^^^^^^^^^^^ help: must be of the form: `#[coroutine]`
 
 error: malformed `proc_macro_attribute` attribute input
-  --> $DIR/malformed-attrs.rs:116:1
+  --> $DIR/malformed-attrs.rs:117:1
    |
 LL | #[proc_macro_attribute = 19]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro_attribute]`
 
 error: malformed `proc_macro_derive` attribute input
-  --> $DIR/malformed-attrs.rs:123:1
+  --> $DIR/malformed-attrs.rs:124:1
    |
 LL | #[proc_macro_derive]
    | ^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
 
 error: malformed `must_not_suspend` attribute input
-  --> $DIR/malformed-attrs.rs:132:1
+  --> $DIR/malformed-attrs.rs:133:1
    |
 LL | #[must_not_suspend()]
    | ^^^^^^^^^^^^^^^^^^^^^
@@ -95,67 +95,67 @@ LL + #[must_not_suspend]
    |
 
 error: malformed `cfi_encoding` attribute input
-  --> $DIR/malformed-attrs.rs:134:1
+  --> $DIR/malformed-attrs.rs:135:1
    |
 LL | #[cfi_encoding]
    | ^^^^^^^^^^^^^^^ help: must be of the form: `#[cfi_encoding = "encoding"]`
 
 error: malformed `linkage` attribute input
-  --> $DIR/malformed-attrs.rs:173:5
+  --> $DIR/malformed-attrs.rs:174:5
    |
 LL |     #[linkage]
    |     ^^^^^^^^^^ help: must be of the form: `#[linkage = "external|internal|..."]`
 
 error: malformed `allow` attribute input
-  --> $DIR/malformed-attrs.rs:178:1
+  --> $DIR/malformed-attrs.rs:179:1
    |
 LL | #[allow]
    | ^^^^^^^^ help: must be of the form: `#[allow(lint1, lint2, ..., /*opt*/ reason = "...")]`
 
 error: malformed `expect` attribute input
-  --> $DIR/malformed-attrs.rs:180:1
+  --> $DIR/malformed-attrs.rs:181:1
    |
 LL | #[expect]
    | ^^^^^^^^^ help: must be of the form: `#[expect(lint1, lint2, ..., /*opt*/ reason = "...")]`
 
 error: malformed `warn` attribute input
-  --> $DIR/malformed-attrs.rs:182:1
+  --> $DIR/malformed-attrs.rs:183:1
    |
 LL | #[warn]
    | ^^^^^^^ help: must be of the form: `#[warn(lint1, lint2, ..., /*opt*/ reason = "...")]`
 
 error: malformed `deny` attribute input
-  --> $DIR/malformed-attrs.rs:184:1
+  --> $DIR/malformed-attrs.rs:185:1
    |
 LL | #[deny]
    | ^^^^^^^ help: must be of the form: `#[deny(lint1, lint2, ..., /*opt*/ reason = "...")]`
 
 error: malformed `forbid` attribute input
-  --> $DIR/malformed-attrs.rs:186:1
+  --> $DIR/malformed-attrs.rs:187:1
    |
 LL | #[forbid]
    | ^^^^^^^^^ help: must be of the form: `#[forbid(lint1, lint2, ..., /*opt*/ reason = "...")]`
 
 error: malformed `debugger_visualizer` attribute input
-  --> $DIR/malformed-attrs.rs:188:1
+  --> $DIR/malformed-attrs.rs:189:1
    |
 LL | #[debugger_visualizer]
    | ^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[debugger_visualizer(natvis_file = "...", gdb_script_file = "...")]`
 
 error: malformed `thread_local` attribute input
-  --> $DIR/malformed-attrs.rs:203:1
+  --> $DIR/malformed-attrs.rs:204:1
    |
 LL | #[thread_local()]
    | ^^^^^^^^^^^^^^^^^ help: must be of the form: `#[thread_local]`
 
 error: malformed `no_link` attribute input
-  --> $DIR/malformed-attrs.rs:207:1
+  --> $DIR/malformed-attrs.rs:208:1
    |
 LL | #[no_link()]
    | ^^^^^^^^^^^^ help: must be of the form: `#[no_link]`
 
 error: malformed `macro_use` attribute input
-  --> $DIR/malformed-attrs.rs:209:1
+  --> $DIR/malformed-attrs.rs:210:1
    |
 LL | #[macro_use = 1]
    | ^^^^^^^^^^^^^^^^
@@ -170,7 +170,7 @@ LL + #[macro_use]
    |
 
 error: malformed `macro_export` attribute input
-  --> $DIR/malformed-attrs.rs:214:1
+  --> $DIR/malformed-attrs.rs:215:1
    |
 LL | #[macro_export = 18]
    | ^^^^^^^^^^^^^^^^^^^^
@@ -185,31 +185,31 @@ LL + #[macro_export]
    |
 
 error: malformed `allow_internal_unsafe` attribute input
-  --> $DIR/malformed-attrs.rs:216:1
+  --> $DIR/malformed-attrs.rs:217:1
    |
 LL | #[allow_internal_unsafe = 1]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[allow_internal_unsafe]`
 
 error: the `#[proc_macro]` attribute is only usable with crates of the `proc-macro` crate type
-  --> $DIR/malformed-attrs.rs:99:1
+  --> $DIR/malformed-attrs.rs:100:1
    |
 LL | #[proc_macro = 18]
    | ^^^^^^^^^^^^^^^^^^
 
 error: the `#[proc_macro_attribute]` attribute is only usable with crates of the `proc-macro` crate type
-  --> $DIR/malformed-attrs.rs:116:1
+  --> $DIR/malformed-attrs.rs:117:1
    |
 LL | #[proc_macro_attribute = 19]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the `#[proc_macro_derive]` attribute is only usable with crates of the `proc-macro` crate type
-  --> $DIR/malformed-attrs.rs:123:1
+  --> $DIR/malformed-attrs.rs:124:1
    |
 LL | #[proc_macro_derive]
    | ^^^^^^^^^^^^^^^^^^^^
 
 error[E0658]: allow_internal_unsafe side-steps the unsafe_code lint
-  --> $DIR/malformed-attrs.rs:216:1
+  --> $DIR/malformed-attrs.rs:217:1
    |
 LL | #[allow_internal_unsafe = 1]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -218,7 +218,7 @@ LL | #[allow_internal_unsafe = 1]
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: valid forms for the attribute are `#[doc(hidden|inline|...)]` and `#[doc = "string"]`
-  --> $DIR/malformed-attrs.rs:43:1
+  --> $DIR/malformed-attrs.rs:44:1
    |
 LL | #[doc]
    | ^^^^^^
@@ -228,7 +228,7 @@ LL | #[doc]
    = note: `#[deny(ill_formed_attribute_input)]` on by default
 
 error: valid forms for the attribute are `#[doc(hidden|inline|...)]` and `#[doc = "string"]`
-  --> $DIR/malformed-attrs.rs:76:1
+  --> $DIR/malformed-attrs.rs:77:1
    |
 LL | #[doc]
    | ^^^^^^
@@ -237,7 +237,7 @@ LL | #[doc]
    = note: for more information, see issue #57571 <https://github.com/rust-lang/rust/issues/57571>
 
 error: attribute must be of the form `#[link(name = "...", /*opt*/ kind = "dylib|static|...", /*opt*/ wasm_import_module = "...", /*opt*/ import_name_type = "decorated|noprefix|undecorated")]`
-  --> $DIR/malformed-attrs.rs:83:1
+  --> $DIR/malformed-attrs.rs:84:1
    |
 LL | #[link]
    | ^^^^^^^
@@ -246,7 +246,7 @@ LL | #[link]
    = note: for more information, see issue #57571 <https://github.com/rust-lang/rust/issues/57571>
 
 error: invalid argument
-  --> $DIR/malformed-attrs.rs:188:1
+  --> $DIR/malformed-attrs.rs:189:1
    |
 LL | #[debugger_visualizer]
    | ^^^^^^^^^^^^^^^^^^^^^^
@@ -256,7 +256,7 @@ LL | #[debugger_visualizer]
    = note: expected: `gdb_script_file = "..."`
 
 error[E0565]: malformed `omit_gdb_pretty_printer_section` attribute input
-  --> $DIR/malformed-attrs.rs:26:1
+  --> $DIR/malformed-attrs.rs:27:1
    |
 LL | #![omit_gdb_pretty_printer_section = 1]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---^
@@ -265,25 +265,25 @@ LL | #![omit_gdb_pretty_printer_section = 1]
    | help: must be of the form: `#[omit_gdb_pretty_printer_section]`
 
 error[E0539]: malformed `export_name` attribute input
-  --> $DIR/malformed-attrs.rs:32:1
+  --> $DIR/malformed-attrs.rs:33:1
    |
 LL | #[unsafe(export_name)]
    | ^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[export_name = "name"]`
 
 error: `rustc_allow_const_fn_unstable` expects a list of feature names
-  --> $DIR/malformed-attrs.rs:34:1
+  --> $DIR/malformed-attrs.rs:35:1
    |
 LL | #[rustc_allow_const_fn_unstable]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `allow_internal_unstable` expects a list of feature names
-  --> $DIR/malformed-attrs.rs:37:1
+  --> $DIR/malformed-attrs.rs:38:1
    |
 LL | #[allow_internal_unstable]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0539]: malformed `rustc_confusables` attribute input
-  --> $DIR/malformed-attrs.rs:39:1
+  --> $DIR/malformed-attrs.rs:40:1
    |
 LL | #[rustc_confusables]
    | ^^^^^^^^^^^^^^^^^^^^
@@ -292,7 +292,7 @@ LL | #[rustc_confusables]
    | help: must be of the form: `#[rustc_confusables("name1", "name2", ...)]`
 
 error[E0539]: malformed `deprecated` attribute input
-  --> $DIR/malformed-attrs.rs:41:1
+  --> $DIR/malformed-attrs.rs:42:1
    |
 LL | #[deprecated = 5]
    | ^^^^^^^^^^^^^^^-^
@@ -312,13 +312,13 @@ LL + #[deprecated]
    |
 
 error[E0539]: malformed `rustc_macro_transparency` attribute input
-  --> $DIR/malformed-attrs.rs:46:1
+  --> $DIR/malformed-attrs.rs:47:1
    |
 LL | #[rustc_macro_transparency]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[rustc_macro_transparency = "transparent|semitransparent|opaque"]`
 
 error[E0539]: malformed `repr` attribute input
-  --> $DIR/malformed-attrs.rs:48:1
+  --> $DIR/malformed-attrs.rs:49:1
    |
 LL | #[repr]
    | ^^^^^^^
@@ -327,7 +327,7 @@ LL | #[repr]
    | help: must be of the form: `#[repr(C | Rust | align(...) | packed(...) | <integer type> | transparent)]`
 
 error[E0565]: malformed `rustc_as_ptr` attribute input
-  --> $DIR/malformed-attrs.rs:51:1
+  --> $DIR/malformed-attrs.rs:52:1
    |
 LL | #[rustc_as_ptr = 5]
    | ^^^^^^^^^^^^^^^---^
@@ -335,17 +335,17 @@ LL | #[rustc_as_ptr = 5]
    | |              didn't expect any arguments here
    | help: must be of the form: `#[rustc_as_ptr]`
 
-error[E0539]: malformed `align` attribute input
-  --> $DIR/malformed-attrs.rs:56:1
+error[E0539]: malformed `rustc_align` attribute input
+  --> $DIR/malformed-attrs.rs:57:1
    |
-LL | #[align]
-   | ^^^^^^^^
+LL | #[rustc_align]
+   | ^^^^^^^^^^^^^^
    | |
    | expected this to be a list
-   | help: must be of the form: `#[align(<alignment in bytes>)]`
+   | help: must be of the form: `#[rustc_align(<alignment in bytes>)]`
 
 error[E0539]: malformed `optimize` attribute input
-  --> $DIR/malformed-attrs.rs:58:1
+  --> $DIR/malformed-attrs.rs:59:1
    |
 LL | #[optimize]
    | ^^^^^^^^^^^
@@ -354,7 +354,7 @@ LL | #[optimize]
    | help: must be of the form: `#[optimize(size|speed|none)]`
 
 error[E0565]: malformed `cold` attribute input
-  --> $DIR/malformed-attrs.rs:60:1
+  --> $DIR/malformed-attrs.rs:61:1
    |
 LL | #[cold = 1]
    | ^^^^^^^---^
@@ -363,13 +363,13 @@ LL | #[cold = 1]
    | help: must be of the form: `#[cold]`
 
 error: valid forms for the attribute are `#[must_use = "reason"]` and `#[must_use]`
-  --> $DIR/malformed-attrs.rs:62:1
+  --> $DIR/malformed-attrs.rs:63:1
    |
 LL | #[must_use()]
    | ^^^^^^^^^^^^^
 
 error[E0565]: malformed `no_mangle` attribute input
-  --> $DIR/malformed-attrs.rs:64:1
+  --> $DIR/malformed-attrs.rs:65:1
    |
 LL | #[no_mangle = 1]
    | ^^^^^^^^^^^^---^
@@ -378,7 +378,7 @@ LL | #[no_mangle = 1]
    | help: must be of the form: `#[no_mangle]`
 
 error[E0565]: malformed `naked` attribute input
-  --> $DIR/malformed-attrs.rs:66:1
+  --> $DIR/malformed-attrs.rs:67:1
    |
 LL | #[unsafe(naked())]
    | ^^^^^^^^^^^^^^--^^
@@ -387,7 +387,7 @@ LL | #[unsafe(naked())]
    | help: must be of the form: `#[naked]`
 
 error[E0565]: malformed `track_caller` attribute input
-  --> $DIR/malformed-attrs.rs:68:1
+  --> $DIR/malformed-attrs.rs:69:1
    |
 LL | #[track_caller()]
    | ^^^^^^^^^^^^^^--^
@@ -396,13 +396,13 @@ LL | #[track_caller()]
    | help: must be of the form: `#[track_caller]`
 
 error[E0539]: malformed `export_name` attribute input
-  --> $DIR/malformed-attrs.rs:70:1
+  --> $DIR/malformed-attrs.rs:71:1
    |
 LL | #[export_name()]
    | ^^^^^^^^^^^^^^^^ help: must be of the form: `#[export_name = "name"]`
 
 error[E0805]: malformed `used` attribute input
-  --> $DIR/malformed-attrs.rs:72:1
+  --> $DIR/malformed-attrs.rs:73:1
    |
 LL | #[used()]
    | ^^^^^^--^
@@ -418,7 +418,7 @@ LL + #[used]
    |
 
 error[E0539]: malformed `target_feature` attribute input
-  --> $DIR/malformed-attrs.rs:79:1
+  --> $DIR/malformed-attrs.rs:80:1
    |
 LL | #[target_feature]
    | ^^^^^^^^^^^^^^^^^
@@ -427,7 +427,7 @@ LL | #[target_feature]
    | help: must be of the form: `#[target_feature(enable = "feat1, feat2")]`
 
 error[E0565]: malformed `export_stable` attribute input
-  --> $DIR/malformed-attrs.rs:81:1
+  --> $DIR/malformed-attrs.rs:82:1
    |
 LL | #[export_stable = 1]
    | ^^^^^^^^^^^^^^^^---^
@@ -436,19 +436,19 @@ LL | #[export_stable = 1]
    | help: must be of the form: `#[export_stable]`
 
 error[E0539]: malformed `link_name` attribute input
-  --> $DIR/malformed-attrs.rs:86:1
+  --> $DIR/malformed-attrs.rs:87:1
    |
 LL | #[link_name]
    | ^^^^^^^^^^^^ help: must be of the form: `#[link_name = "name"]`
 
 error[E0539]: malformed `link_section` attribute input
-  --> $DIR/malformed-attrs.rs:88:1
+  --> $DIR/malformed-attrs.rs:89:1
    |
 LL | #[link_section]
    | ^^^^^^^^^^^^^^^ help: must be of the form: `#[link_section = "name"]`
 
 error[E0539]: malformed `coverage` attribute input
-  --> $DIR/malformed-attrs.rs:90:1
+  --> $DIR/malformed-attrs.rs:91:1
    |
 LL | #[coverage]
    | ^^^^^^^^^^^ this attribute is only valid with either `on` or `off` as an argument
@@ -461,7 +461,7 @@ LL | #[coverage(on)]
    |           ++++
 
 error[E0565]: malformed `no_implicit_prelude` attribute input
-  --> $DIR/malformed-attrs.rs:97:1
+  --> $DIR/malformed-attrs.rs:98:1
    |
 LL | #[no_implicit_prelude = 23]
    | ^^^^^^^^^^^^^^^^^^^^^^----^
@@ -470,7 +470,7 @@ LL | #[no_implicit_prelude = 23]
    | help: must be of the form: `#[no_implicit_prelude]`
 
 error[E0539]: malformed `must_use` attribute input
-  --> $DIR/malformed-attrs.rs:119:1
+  --> $DIR/malformed-attrs.rs:120:1
    |
 LL | #[must_use = 1]
    | ^^^^^^^^^^^^^-^
@@ -487,7 +487,7 @@ LL + #[must_use]
    |
 
 error[E0539]: malformed `rustc_layout_scalar_valid_range_start` attribute input
-  --> $DIR/malformed-attrs.rs:128:1
+  --> $DIR/malformed-attrs.rs:129:1
    |
 LL | #[rustc_layout_scalar_valid_range_start]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -496,7 +496,7 @@ LL | #[rustc_layout_scalar_valid_range_start]
    | help: must be of the form: `#[rustc_layout_scalar_valid_range_start(start)]`
 
 error[E0539]: malformed `rustc_layout_scalar_valid_range_end` attribute input
-  --> $DIR/malformed-attrs.rs:130:1
+  --> $DIR/malformed-attrs.rs:131:1
    |
 LL | #[rustc_layout_scalar_valid_range_end]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -505,7 +505,7 @@ LL | #[rustc_layout_scalar_valid_range_end]
    | help: must be of the form: `#[rustc_layout_scalar_valid_range_end(end)]`
 
 error[E0565]: malformed `marker` attribute input
-  --> $DIR/malformed-attrs.rs:155:1
+  --> $DIR/malformed-attrs.rs:156:1
    |
 LL | #[marker = 3]
    | ^^^^^^^^^---^
@@ -514,7 +514,7 @@ LL | #[marker = 3]
    | help: must be of the form: `#[marker]`
 
 error[E0565]: malformed `fundamental` attribute input
-  --> $DIR/malformed-attrs.rs:157:1
+  --> $DIR/malformed-attrs.rs:158:1
    |
 LL | #[fundamental()]
    | ^^^^^^^^^^^^^--^
@@ -523,7 +523,7 @@ LL | #[fundamental()]
    | help: must be of the form: `#[fundamental]`
 
 error[E0565]: malformed `ffi_pure` attribute input
-  --> $DIR/malformed-attrs.rs:165:5
+  --> $DIR/malformed-attrs.rs:166:5
    |
 LL |     #[unsafe(ffi_pure = 1)]
    |     ^^^^^^^^^^^^^^^^^^---^^
@@ -532,7 +532,7 @@ LL |     #[unsafe(ffi_pure = 1)]
    |     help: must be of the form: `#[ffi_pure]`
 
 error[E0539]: malformed `link_ordinal` attribute input
-  --> $DIR/malformed-attrs.rs:167:5
+  --> $DIR/malformed-attrs.rs:168:5
    |
 LL |     #[link_ordinal]
    |     ^^^^^^^^^^^^^^^
@@ -541,7 +541,7 @@ LL |     #[link_ordinal]
    |     help: must be of the form: `#[link_ordinal(ordinal)]`
 
 error[E0565]: malformed `ffi_const` attribute input
-  --> $DIR/malformed-attrs.rs:171:5
+  --> $DIR/malformed-attrs.rs:172:5
    |
 LL |     #[unsafe(ffi_const = 1)]
    |     ^^^^^^^^^^^^^^^^^^^---^^
@@ -550,7 +550,7 @@ LL |     #[unsafe(ffi_const = 1)]
    |     help: must be of the form: `#[ffi_const]`
 
 error[E0565]: malformed `automatically_derived` attribute input
-  --> $DIR/malformed-attrs.rs:191:1
+  --> $DIR/malformed-attrs.rs:192:1
    |
 LL | #[automatically_derived = 18]
    | ^^^^^^^^^^^^^^^^^^^^^^^^----^
@@ -559,7 +559,7 @@ LL | #[automatically_derived = 18]
    | help: must be of the form: `#[automatically_derived]`
 
 error[E0565]: malformed `non_exhaustive` attribute input
-  --> $DIR/malformed-attrs.rs:197:1
+  --> $DIR/malformed-attrs.rs:198:1
    |
 LL | #[non_exhaustive = 1]
    | ^^^^^^^^^^^^^^^^^---^
@@ -568,7 +568,7 @@ LL | #[non_exhaustive = 1]
    | help: must be of the form: `#[non_exhaustive]`
 
 error[E0565]: malformed `type_const` attribute input
-  --> $DIR/malformed-attrs.rs:143:5
+  --> $DIR/malformed-attrs.rs:144:5
    |
 LL |     #[type_const = 1]
    |     ^^^^^^^^^^^^^---^
@@ -577,7 +577,7 @@ LL |     #[type_const = 1]
    |     help: must be of the form: `#[type_const]`
 
 error: attribute should be applied to `const fn`
-  --> $DIR/malformed-attrs.rs:34:1
+  --> $DIR/malformed-attrs.rs:35:1
    |
 LL |   #[rustc_allow_const_fn_unstable]
    |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -589,19 +589,19 @@ LL | | }
    | |_- not a `const fn`
 
 error: `#[repr(align(...))]` is not supported on function items
-  --> $DIR/malformed-attrs.rs:48:1
+  --> $DIR/malformed-attrs.rs:49:1
    |
 LL | #[repr]
    | ^^^^^^^
    |
-help: use `#[align(...)]` instead
-  --> $DIR/malformed-attrs.rs:48:1
+help: use `#[rustc_align(...)]` instead
+  --> $DIR/malformed-attrs.rs:49:1
    |
 LL | #[repr]
    | ^^^^^^^
 
 warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
-  --> $DIR/malformed-attrs.rs:149:1
+  --> $DIR/malformed-attrs.rs:150:1
    |
 LL | #[diagnostic::do_not_recommend()]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -609,7 +609,7 @@ LL | #[diagnostic::do_not_recommend()]
    = note: `#[warn(malformed_diagnostic_attributes)]` on by default
 
 warning: missing options for `on_unimplemented` attribute
-  --> $DIR/malformed-attrs.rs:138:1
+  --> $DIR/malformed-attrs.rs:139:1
    |
 LL | #[diagnostic::on_unimplemented]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -617,7 +617,7 @@ LL | #[diagnostic::on_unimplemented]
    = help: at least one of the `message`, `note` and `label` options are expected
 
 warning: malformed `on_unimplemented` attribute
-  --> $DIR/malformed-attrs.rs:140:1
+  --> $DIR/malformed-attrs.rs:141:1
    |
 LL | #[diagnostic::on_unimplemented = 1]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ invalid option found here
@@ -625,7 +625,7 @@ LL | #[diagnostic::on_unimplemented = 1]
    = help: only `message`, `note` and `label` are allowed as options
 
 error: valid forms for the attribute are `#[inline(always|never)]` and `#[inline]`
-  --> $DIR/malformed-attrs.rs:53:1
+  --> $DIR/malformed-attrs.rs:54:1
    |
 LL | #[inline = 5]
    | ^^^^^^^^^^^^^
@@ -634,7 +634,7 @@ LL | #[inline = 5]
    = note: for more information, see issue #57571 <https://github.com/rust-lang/rust/issues/57571>
 
 error: valid forms for the attribute are `#[ignore = "reason"]` and `#[ignore]`
-  --> $DIR/malformed-attrs.rs:94:1
+  --> $DIR/malformed-attrs.rs:95:1
    |
 LL | #[ignore()]
    | ^^^^^^^^^^^
@@ -643,7 +643,7 @@ LL | #[ignore()]
    = note: for more information, see issue #57571 <https://github.com/rust-lang/rust/issues/57571>
 
 error: valid forms for the attribute are `#[ignore = "reason"]` and `#[ignore]`
-  --> $DIR/malformed-attrs.rs:223:1
+  --> $DIR/malformed-attrs.rs:224:1
    |
 LL | #[ignore = 1]
    | ^^^^^^^^^^^^^
@@ -652,7 +652,7 @@ LL | #[ignore = 1]
    = note: for more information, see issue #57571 <https://github.com/rust-lang/rust/issues/57571>
 
 error[E0308]: mismatched types
-  --> $DIR/malformed-attrs.rs:111:23
+  --> $DIR/malformed-attrs.rs:112:23
    |
 LL | fn test() {
    |          - help: a return type might be missing here: `-> _`
@@ -660,7 +660,7 @@ LL |     #[coroutine = 63] || {}
    |                       ^^^^^ expected `()`, found coroutine
    |
    = note: expected unit type `()`
-              found coroutine `{coroutine@$DIR/malformed-attrs.rs:111:23: 111:25}`
+              found coroutine `{coroutine@$DIR/malformed-attrs.rs:112:23: 112:25}`
 
 error: aborting due to 75 previous errors; 3 warnings emitted
 
diff --git a/tests/ui/attributes/malformed-fn-align.rs b/tests/ui/attributes/malformed-fn-align.rs
index e06e6116842..cf143b28e54 100644
--- a/tests/ui/attributes/malformed-fn-align.rs
+++ b/tests/ui/attributes/malformed-fn-align.rs
@@ -1,49 +1,54 @@
+// ignore-tidy-linelength
+
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+#![feature(rustc_attrs)]
 #![feature(fn_align)]
+
 #![crate_type = "lib"]
 
 trait MyTrait {
-    #[align] //~ ERROR malformed `align` attribute input
+    #[rustc_align] //~ ERROR malformed `rustc_align` attribute input
     fn myfun1();
 
-    #[align(1, 2)] //~ ERROR malformed `align` attribute input
+    #[rustc_align(1, 2)] //~ ERROR malformed `rustc_align` attribute input
     fn myfun2();
 }
 
-#[align = 16] //~ ERROR malformed `align` attribute input
+#[rustc_align = 16] //~ ERROR malformed `rustc_align` attribute input
 fn f1() {}
 
-#[align("hello")] //~ ERROR invalid alignment value: not an unsuffixed integer
+#[rustc_align("hello")] //~ ERROR invalid alignment value: not an unsuffixed integer
 fn f2() {}
 
-#[align(0)] //~ ERROR invalid alignment value: not a power of two
+#[rustc_align(0)] //~ ERROR invalid alignment value: not a power of two
 fn f3() {}
 
 #[repr(align(16))] //~ ERROR `#[repr(align(...))]` is not supported on function items
 fn f4() {}
 
-#[align(-1)] //~ ERROR expected unsuffixed literal, found `-`
+#[rustc_align(-1)] //~ ERROR expected unsuffixed literal, found `-`
 fn f5() {}
 
-#[align(3)] //~ ERROR invalid alignment value: not a power of two
+#[rustc_align(3)] //~ ERROR invalid alignment value: not a power of two
 fn f6() {}
 
-#[align(4usize)] //~ ERROR invalid alignment value: not an unsuffixed integer [E0589]
+#[rustc_align(4usize)] //~ ERROR invalid alignment value: not an unsuffixed integer [E0589]
 //~^ ERROR suffixed literals are not allowed in attributes
 fn f7() {}
 
-#[align(16)]
-#[align(3)] //~ ERROR invalid alignment value: not a power of two
-#[align(16)]
+#[rustc_align(16)]
+#[rustc_align(3)] //~ ERROR invalid alignment value: not a power of two
+#[rustc_align(16)]
 fn f8() {}
 
-#[align(16)] //~ ERROR `#[align(...)]` is not supported on struct items
+#[rustc_align(16)] //~ ERROR `#[rustc_align(...)]` is not supported on struct items
 struct S1;
 
-#[align(32)] //~ ERROR `#[align(...)]` should be applied to a function item
+#[rustc_align(32)] //~ ERROR `#[rustc_align(...)]` should be applied to a function item
 const FOO: i32 = 42;
 
-#[align(32)] //~ ERROR `#[align(...)]` should be applied to a function item
+#[rustc_align(32)] //~ ERROR `#[rustc_align(...)]` should be applied to a function item
 mod test {}
 
-#[align(32)] //~ ERROR `#[align(...)]` should be applied to a function item
+#[rustc_align(32)] //~ ERROR `#[rustc_align(...)]` should be applied to a function item
 use ::std::iter;
diff --git a/tests/ui/attributes/malformed-fn-align.stderr b/tests/ui/attributes/malformed-fn-align.stderr
index af3625b1f3b..d995a7bf070 100644
--- a/tests/ui/attributes/malformed-fn-align.stderr
+++ b/tests/ui/attributes/malformed-fn-align.stderr
@@ -1,119 +1,119 @@
 error: expected unsuffixed literal, found `-`
-  --> $DIR/malformed-fn-align.rs:24:9
+  --> $DIR/malformed-fn-align.rs:29:15
    |
-LL | #[align(-1)]
-   |         ^
+LL | #[rustc_align(-1)]
+   |               ^
 
 error: suffixed literals are not allowed in attributes
-  --> $DIR/malformed-fn-align.rs:30:9
+  --> $DIR/malformed-fn-align.rs:35:15
    |
-LL | #[align(4usize)]
-   |         ^^^^^^
+LL | #[rustc_align(4usize)]
+   |               ^^^^^^
    |
    = help: instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
 
-error[E0539]: malformed `align` attribute input
-  --> $DIR/malformed-fn-align.rs:5:5
+error[E0539]: malformed `rustc_align` attribute input
+  --> $DIR/malformed-fn-align.rs:10:5
    |
-LL |     #[align]
-   |     ^^^^^^^^
+LL |     #[rustc_align]
+   |     ^^^^^^^^^^^^^^
    |     |
    |     expected this to be a list
-   |     help: must be of the form: `#[align(<alignment in bytes>)]`
+   |     help: must be of the form: `#[rustc_align(<alignment in bytes>)]`
 
-error[E0805]: malformed `align` attribute input
-  --> $DIR/malformed-fn-align.rs:8:5
+error[E0805]: malformed `rustc_align` attribute input
+  --> $DIR/malformed-fn-align.rs:13:5
    |
-LL |     #[align(1, 2)]
-   |     ^^^^^^^------^
-   |     |      |
-   |     |      expected a single argument here
-   |     help: must be of the form: `#[align(<alignment in bytes>)]`
+LL |     #[rustc_align(1, 2)]
+   |     ^^^^^^^^^^^^^------^
+   |     |            |
+   |     |            expected a single argument here
+   |     help: must be of the form: `#[rustc_align(<alignment in bytes>)]`
 
-error[E0539]: malformed `align` attribute input
-  --> $DIR/malformed-fn-align.rs:12:1
+error[E0539]: malformed `rustc_align` attribute input
+  --> $DIR/malformed-fn-align.rs:17:1
    |
-LL | #[align = 16]
-   | ^^^^^^^^^^^^^
+LL | #[rustc_align = 16]
+   | ^^^^^^^^^^^^^^^^^^^
    | |
    | expected this to be a list
-   | help: must be of the form: `#[align(<alignment in bytes>)]`
+   | help: must be of the form: `#[rustc_align(<alignment in bytes>)]`
 
 error[E0589]: invalid alignment value: not an unsuffixed integer
-  --> $DIR/malformed-fn-align.rs:15:9
+  --> $DIR/malformed-fn-align.rs:20:15
    |
-LL | #[align("hello")]
-   |         ^^^^^^^
+LL | #[rustc_align("hello")]
+   |               ^^^^^^^
 
 error[E0589]: invalid alignment value: not a power of two
-  --> $DIR/malformed-fn-align.rs:18:9
+  --> $DIR/malformed-fn-align.rs:23:15
    |
-LL | #[align(0)]
-   |         ^
+LL | #[rustc_align(0)]
+   |               ^
 
 error[E0589]: invalid alignment value: not a power of two
-  --> $DIR/malformed-fn-align.rs:27:9
+  --> $DIR/malformed-fn-align.rs:32:15
    |
-LL | #[align(3)]
-   |         ^
+LL | #[rustc_align(3)]
+   |               ^
 
 error[E0589]: invalid alignment value: not an unsuffixed integer
-  --> $DIR/malformed-fn-align.rs:30:9
+  --> $DIR/malformed-fn-align.rs:35:15
    |
-LL | #[align(4usize)]
-   |         ^^^^^^
+LL | #[rustc_align(4usize)]
+   |               ^^^^^^
 
 error[E0589]: invalid alignment value: not a power of two
-  --> $DIR/malformed-fn-align.rs:35:9
+  --> $DIR/malformed-fn-align.rs:40:15
    |
-LL | #[align(3)]
-   |         ^
+LL | #[rustc_align(3)]
+   |               ^
 
 error: `#[repr(align(...))]` is not supported on function items
-  --> $DIR/malformed-fn-align.rs:21:8
+  --> $DIR/malformed-fn-align.rs:26:8
    |
 LL | #[repr(align(16))]
    |        ^^^^^^^^^
    |
-help: use `#[align(...)]` instead
-  --> $DIR/malformed-fn-align.rs:21:8
+help: use `#[rustc_align(...)]` instead
+  --> $DIR/malformed-fn-align.rs:26:8
    |
 LL | #[repr(align(16))]
    |        ^^^^^^^^^
 
-error: `#[align(...)]` is not supported on struct items
-  --> $DIR/malformed-fn-align.rs:39:1
+error: `#[rustc_align(...)]` is not supported on struct items
+  --> $DIR/malformed-fn-align.rs:44:1
    |
-LL | #[align(16)]
-   | ^^^^^^^^^^^^
+LL | #[rustc_align(16)]
+   | ^^^^^^^^^^^^^^^^^^
    |
 help: use `#[repr(align(...))]` instead
    |
-LL - #[align(16)]
+LL - #[rustc_align(16)]
 LL + #[repr(align(16))]
    |
 
-error: `#[align(...)]` should be applied to a function item
-  --> $DIR/malformed-fn-align.rs:42:1
+error: `#[rustc_align(...)]` should be applied to a function item
+  --> $DIR/malformed-fn-align.rs:47:1
    |
-LL | #[align(32)]
-   | ^^^^^^^^^^^^
+LL | #[rustc_align(32)]
+   | ^^^^^^^^^^^^^^^^^^
 LL | const FOO: i32 = 42;
    | -------------------- not a function item
 
-error: `#[align(...)]` should be applied to a function item
-  --> $DIR/malformed-fn-align.rs:45:1
+error: `#[rustc_align(...)]` should be applied to a function item
+  --> $DIR/malformed-fn-align.rs:50:1
    |
-LL | #[align(32)]
-   | ^^^^^^^^^^^^
+LL | #[rustc_align(32)]
+   | ^^^^^^^^^^^^^^^^^^
 LL | mod test {}
    | ----------- not a function item
 
-error: `#[align(...)]` should be applied to a function item
-  --> $DIR/malformed-fn-align.rs:48:1
+error: `#[rustc_align(...)]` should be applied to a function item
+  --> $DIR/malformed-fn-align.rs:53:1
    |
-LL | #[align(32)]
-   | ^^^^^^^^^^^^
+LL | #[rustc_align(32)]
+   | ^^^^^^^^^^^^^^^^^^
 LL | use ::std::iter;
    | ---------------- not a function item
 
diff --git a/tests/ui/feature-gates/feature-gate-fn_align.rs b/tests/ui/feature-gates/feature-gate-fn_align.rs
index b6c300e5cbe..36e17c4a8dd 100644
--- a/tests/ui/feature-gates/feature-gate-fn_align.rs
+++ b/tests/ui/feature-gates/feature-gate-fn_align.rs
@@ -1,12 +1,16 @@
 #![crate_type = "lib"]
 
-#[align(16)]
-//~^ ERROR the `#[align]` attribute is an experimental feature
+// ignore-tidy-linelength
+
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+
+#[rustc_align(16)]
+//~^ ERROR the `#[rustc_align]` attribute is an experimental feature
 fn requires_alignment() {}
 
 trait MyTrait {
-    #[align]
-    //~^ ERROR the `#[align]` attribute is an experimental feature
-    //~| ERROR malformed `align` attribute input
+    #[rustc_align]
+    //~^ ERROR the `#[rustc_align]` attribute is an experimental feature
+    //~| ERROR malformed `rustc_align` attribute input
     fn myfun();
 }
diff --git a/tests/ui/feature-gates/feature-gate-fn_align.stderr b/tests/ui/feature-gates/feature-gate-fn_align.stderr
index 921cf08435c..6196f4f298f 100644
--- a/tests/ui/feature-gates/feature-gate-fn_align.stderr
+++ b/tests/ui/feature-gates/feature-gate-fn_align.stderr
@@ -1,31 +1,31 @@
-error[E0658]: the `#[align]` attribute is an experimental feature
-  --> $DIR/feature-gate-fn_align.rs:3:1
+error[E0658]: the `#[rustc_align]` attribute is an experimental feature
+  --> $DIR/feature-gate-fn_align.rs:7:1
    |
-LL | #[align(16)]
-   | ^^^^^^^^^^^^
+LL | #[rustc_align(16)]
+   | ^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #82232 <https://github.com/rust-lang/rust/issues/82232> for more information
    = help: add `#![feature(fn_align)]` 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 `#[align]` attribute is an experimental feature
-  --> $DIR/feature-gate-fn_align.rs:8:5
+error[E0658]: the `#[rustc_align]` attribute is an experimental feature
+  --> $DIR/feature-gate-fn_align.rs:12:5
    |
-LL |     #[align]
-   |     ^^^^^^^^
+LL |     #[rustc_align]
+   |     ^^^^^^^^^^^^^^
    |
    = note: see issue #82232 <https://github.com/rust-lang/rust/issues/82232> for more information
    = help: add `#![feature(fn_align)]` 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[E0539]: malformed `align` attribute input
-  --> $DIR/feature-gate-fn_align.rs:8:5
+error[E0539]: malformed `rustc_align` attribute input
+  --> $DIR/feature-gate-fn_align.rs:12:5
    |
-LL |     #[align]
-   |     ^^^^^^^^
+LL |     #[rustc_align]
+   |     ^^^^^^^^^^^^^^
    |     |
    |     expected this to be a list
-   |     help: must be of the form: `#[align(<alignment in bytes>)]`
+   |     help: must be of the form: `#[rustc_align(<alignment in bytes>)]`
 
 error: aborting due to 3 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 2d51acd2fbcbadb6f30709c5dd305494d413d388 Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Fri, 18 Jul 2025 19:44:20 +0200
Subject: tests: assembly: cstring-merging: Disable GlobalMerge pass

The test relies on LLVM not merging all the globals into one and would
currently otherwise fail on powerpc64le.

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 tests/assembly/cstring-merging.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/assembly/cstring-merging.rs b/tests/assembly/cstring-merging.rs
index f7d0775f7af..03688e0068b 100644
--- a/tests/assembly/cstring-merging.rs
+++ b/tests/assembly/cstring-merging.rs
@@ -2,7 +2,7 @@
 // other architectures (including ARM and x86-64) use the prefix `.Lanon.`
 //@ only-linux
 //@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3
+//@ compile-flags: --crate-type=lib -Copt-level=3 -Cllvm-args=-enable-global-merge=0
 //@ edition: 2024
 
 use std::ffi::CStr;
-- 
cgit 1.4.1-3-g733a5


From c58e0bd09368a96dbde1ec1f30e36764e1431125 Mon Sep 17 00:00:00 2001
From: xizheyin <xizheyin@smail.nju.edu.cn>
Date: Sat, 19 Jul 2025 01:49:19 +0800
Subject: rename `emit_unless` to `emit_unless_delay`

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
---
 compiler/rustc_errors/src/diagnostic.rs                    |  2 +-
 compiler/rustc_hir_analysis/src/check/compare_impl_item.rs | 14 +++++++-------
 .../rustc_hir_analysis/src/collect/resolve_bound_vars.rs   |  2 +-
 .../rustc_hir_analysis/src/hir_ty_lowering/generics.rs     |  2 +-
 compiler/rustc_hir_typeck/src/coercion.rs                  |  2 +-
 compiler/rustc_hir_typeck/src/expr.rs                      |  6 +++---
 compiler/rustc_resolve/src/late.rs                         |  2 +-
 7 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index a128f8d31a1..96c7ba6ed27 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -1421,7 +1421,7 @@ impl<'a, G: EmissionGuarantee> Diag<'a, G> {
     ///
     /// See `emit` and `delay_as_bug` for details.
     #[track_caller]
-    pub fn emit_unless(mut self, delay: bool) -> G::EmitResult {
+    pub fn emit_unless_delay(mut self, delay: bool) -> G::EmitResult {
         if delay {
             self.downgrade_to_delayed_bug();
         }
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index 87db80f2423..e24426f9fed 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -1173,7 +1173,7 @@ fn check_region_bounds_on_impl_item<'tcx>(
             bounds_span,
             where_span,
         })
-        .emit_unless(delay);
+        .emit_unless_delay(delay);
 
     Err(reported)
 }
@@ -1481,7 +1481,7 @@ fn compare_self_type<'tcx>(
             } else {
                 err.note_trait_signature(trait_m.name(), trait_m.signature(tcx));
             }
-            return Err(err.emit_unless(delay));
+            return Err(err.emit_unless_delay(delay));
         }
 
         (true, false) => {
@@ -1502,7 +1502,7 @@ fn compare_self_type<'tcx>(
                 err.note_trait_signature(trait_m.name(), trait_m.signature(tcx));
             }
 
-            return Err(err.emit_unless(delay));
+            return Err(err.emit_unless_delay(delay));
         }
     }
 
@@ -1662,7 +1662,7 @@ fn compare_number_of_generics<'tcx>(
                 err.span_label(*span, "`impl Trait` introduces an implicit type parameter");
             }
 
-            let reported = err.emit_unless(delay);
+            let reported = err.emit_unless_delay(delay);
             err_occurred = Some(reported);
         }
     }
@@ -1745,7 +1745,7 @@ fn compare_number_of_method_arguments<'tcx>(
             ),
         );
 
-        return Err(err.emit_unless(delay));
+        return Err(err.emit_unless_delay(delay));
     }
 
     Ok(())
@@ -1872,7 +1872,7 @@ fn compare_synthetic_generics<'tcx>(
                     );
                 };
             }
-            error_found = Some(err.emit_unless(delay));
+            error_found = Some(err.emit_unless_delay(delay));
         }
     }
     if let Some(reported) = error_found { Err(reported) } else { Ok(()) }
@@ -1974,7 +1974,7 @@ fn compare_generic_param_kinds<'tcx>(
             err.span_label(impl_header_span, "");
             err.span_label(param_impl_span, make_param_message("found", param_impl));
 
-            let reported = err.emit_unless(delay);
+            let reported = err.emit_unless_delay(delay);
             return Err(reported);
         }
     }
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 77e63e38c8c..eb3492f5de6 100644
--- a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
+++ b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -2495,7 +2495,7 @@ fn deny_non_region_late_bound(
             format!("late-bound {what} parameter not allowed on {where_}"),
         );
 
-        let guar = diag.emit_unless(!tcx.features().non_lifetime_binders() || !first);
+        let guar = diag.emit_unless_delay(!tcx.features().non_lifetime_binders() || !first);
 
         first = false;
         *arg = ResolvedArg::Error(guar);
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
index 8c7c3750865..fc519c194bb 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
@@ -570,7 +570,7 @@ pub(crate) fn check_generic_arg_count(
                     gen_args,
                     def_id,
                 ))
-                .emit_unless(all_params_are_binded)
+                .emit_unless_delay(all_params_are_binded)
         });
 
         Err(reported)
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index b2a229ad651..6d67535da5f 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -1775,7 +1775,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
                     );
                 }
 
-                let reported = err.emit_unless(unsized_return);
+                let reported = err.emit_unless_delay(unsized_return);
 
                 self.final_ty = Some(Ty::new_error(fcx.tcx, reported));
             }
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 067ee0f0eb0..08e8164078c 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -1549,7 +1549,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // If the assignment expression itself is ill-formed, don't
         // bother emitting another error
-        err.emit_unless(lhs_ty.references_error() || rhs_ty.references_error())
+        err.emit_unless_delay(lhs_ty.references_error() || rhs_ty.references_error())
     }
 
     pub(super) fn check_expr_let(
@@ -3865,7 +3865,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         self.dcx()
                             .create_err(NoVariantNamed { span: ident.span, ident, ty: container })
                             .with_span_label(field.span, "variant not found")
-                            .emit_unless(container.references_error());
+                            .emit_unless_delay(container.references_error());
                         break;
                     };
                     let Some(&subfield) = fields.next() else {
@@ -3897,7 +3897,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 enum_span: field.span,
                                 field_span: subident.span,
                             })
-                            .emit_unless(container.references_error());
+                            .emit_unless_delay(container.references_error());
                         break;
                     };
 
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 93cec8daa5a..a3a770502de 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -2913,7 +2913,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     self.r
                         .dcx()
                         .create_err(errors::UnderscoreLifetimeIsReserved { span: param.ident.span })
-                        .emit_unless(is_raw_underscore_lifetime);
+                        .emit_unless_delay(is_raw_underscore_lifetime);
                     // Record lifetime res, so lowering knows there is something fishy.
                     self.record_lifetime_param(param.id, LifetimeRes::Error);
                     continue;
-- 
cgit 1.4.1-3-g733a5


From 6b87978169d260ac4512e66c81e9298055b902c2 Mon Sep 17 00:00:00 2001
From: Julien THILLARD <54775010+supersurviveur@users.noreply.github.com>
Date: Fri, 18 Jul 2025 20:19:13 +0200
Subject: Change the `memcmp` and `bcmp` return type to `c_int`

Fix the return type of `memcmp` and `bcmp` builtin functions on targets
with a `c_int` other than `i32`.

Linked issue: https://github.com/rust-lang/rust/issues/144076
---
 library/compiler-builtins/compiler-builtins/src/mem/impls.rs | 5 +++--
 library/compiler-builtins/compiler-builtins/src/mem/mod.rs   | 4 ++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/library/compiler-builtins/compiler-builtins/src/mem/impls.rs b/library/compiler-builtins/compiler-builtins/src/mem/impls.rs
index 14a4787485d..da16dee25ce 100644
--- a/library/compiler-builtins/compiler-builtins/src/mem/impls.rs
+++ b/library/compiler-builtins/compiler-builtins/src/mem/impls.rs
@@ -15,6 +15,7 @@
 // this use. Of course this is not a guarantee that such use will work, it just means that this
 // 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;
 
 const WORD_SIZE: usize = core::mem::size_of::<usize>();
@@ -384,13 +385,13 @@ pub unsafe fn set_bytes(mut s: *mut u8, c: u8, mut n: usize) {
 }
 
 #[inline(always)]
-pub unsafe fn compare_bytes(s1: *const u8, s2: *const u8, n: usize) -> i32 {
+pub unsafe fn compare_bytes(s1: *const u8, s2: *const u8, n: usize) -> c_int {
     let mut i = 0;
     while i < n {
         let a = *s1.wrapping_add(i);
         let b = *s2.wrapping_add(i);
         if a != b {
-            return a as i32 - b as i32;
+            return c_int::from(a) - c_int::from(b);
         }
         i += 1;
     }
diff --git a/library/compiler-builtins/compiler-builtins/src/mem/mod.rs b/library/compiler-builtins/compiler-builtins/src/mem/mod.rs
index a6f533cb725..a227f60a294 100644
--- a/library/compiler-builtins/compiler-builtins/src/mem/mod.rs
+++ b/library/compiler-builtins/compiler-builtins/src/mem/mod.rs
@@ -37,12 +37,12 @@ intrinsics! {
     }
 
     #[mem_builtin]
-    pub unsafe extern "C" fn memcmp(s1: *const u8, s2: *const u8, n: usize) -> i32 {
+    pub unsafe extern "C" fn memcmp(s1: *const u8, s2: *const u8, n: usize) -> core::ffi::c_int {
         impls::compare_bytes(s1, s2, n)
     }
 
     #[mem_builtin]
-    pub unsafe extern "C" fn bcmp(s1: *const u8, s2: *const u8, n: usize) -> i32 {
+    pub unsafe extern "C" fn bcmp(s1: *const u8, s2: *const u8, n: usize) -> core::ffi::c_int {
         memcmp(s1, s2, n)
     }
 
-- 
cgit 1.4.1-3-g733a5


From 58a05caa457738d99fcee06aaa821317ea4015fb Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Fri, 18 Jul 2025 18:33:23 +0000
Subject: Rename optional-mingw-check to optional-pr-check

---
 src/ci/github-actions/jobs.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index f0c52fe3d1c..0a6ebe44b3d 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -172,9 +172,9 @@ try:
 optional:
   # This job is used just to test optional jobs.
   # It will be replaced by tier 2 and tier 3 jobs in the future.
-  - name: optional-mingw-check-1
+  - name: optional-pr-check-1
     env:
-      IMAGE: mingw-check-1
+      IMAGE: pr-check-1
     <<: *job-linux-4c
 
 # Main CI jobs that have to be green to merge a commit into master
-- 
cgit 1.4.1-3-g733a5


From 966fc577894c283a1285c8554c10fc56ba67e58c Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Tue, 15 Jul 2025 13:13:03 +0000
Subject: `SmirCtxt` to `CompilerCtxt`, `SmirInterface` to `CompilerInterface`

aaa
---
 compiler/rustc_public/src/alloc.rs                 |   8 +-
 compiler/rustc_public/src/compiler_interface.rs    |  22 ++--
 compiler/rustc_public/src/lib.rs                   |   4 +-
 compiler/rustc_public/src/rustc_internal/mod.rs    |   8 +-
 compiler/rustc_public/src/unstable/convert/mod.rs  |  14 +--
 .../src/unstable/convert/stable/abi.rs             |  50 ++++-----
 .../src/unstable/convert/stable/mir.rs             |  80 +++++++-------
 .../src/unstable/convert/stable/mod.rs             |  14 +--
 .../rustc_public/src/unstable/convert/stable/ty.rs | 120 ++++++++++-----------
 compiler/rustc_public/src/unstable/mod.rs          |   6 +-
 compiler/rustc_public_bridge/src/alloc.rs          |  12 +--
 compiler/rustc_public_bridge/src/bridge.rs         |   4 +-
 compiler/rustc_public_bridge/src/context/impls.rs  |  10 +-
 compiler/rustc_public_bridge/src/context/mod.rs    |  16 +--
 compiler/rustc_public_bridge/src/lib.rs            |   4 +-
 15 files changed, 186 insertions(+), 186 deletions(-)

diff --git a/compiler/rustc_public/src/alloc.rs b/compiler/rustc_public/src/alloc.rs
index d2db6c08bbc..f2cb8a900a6 100644
--- a/compiler/rustc_public/src/alloc.rs
+++ b/compiler/rustc_public/src/alloc.rs
@@ -8,7 +8,7 @@ use rustc_abi::Align;
 use rustc_middle::mir::ConstValue;
 use rustc_middle::mir::interpret::AllocRange;
 use rustc_public_bridge::bridge::SmirError;
-use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::context::CompilerCtxt;
 use rustc_public_bridge::{Tables, alloc};
 
 use super::Error;
@@ -35,7 +35,7 @@ pub(crate) fn new_allocation<'tcx>(
     ty: rustc_middle::ty::Ty<'tcx>,
     const_value: ConstValue<'tcx>,
     tables: &mut Tables<'tcx, BridgeTys>,
-    cx: &SmirCtxt<'tcx, BridgeTys>,
+    cx: &CompilerCtxt<'tcx, BridgeTys>,
 ) -> Allocation {
     try_new_allocation(ty, const_value, tables, cx)
         .unwrap_or_else(|_| panic!("Failed to convert: {const_value:?} to {ty:?}"))
@@ -46,7 +46,7 @@ pub(crate) fn try_new_allocation<'tcx>(
     ty: rustc_middle::ty::Ty<'tcx>,
     const_value: ConstValue<'tcx>,
     tables: &mut Tables<'tcx, BridgeTys>,
-    cx: &SmirCtxt<'tcx, BridgeTys>,
+    cx: &CompilerCtxt<'tcx, BridgeTys>,
 ) -> Result<Allocation, Error> {
     let layout = alloc::create_ty_and_layout(cx, ty).map_err(|e| Error::from_internal(e))?;
     match const_value {
@@ -70,7 +70,7 @@ pub(super) fn allocation_filter<'tcx>(
     alloc: &rustc_middle::mir::interpret::Allocation,
     alloc_range: AllocRange,
     tables: &mut Tables<'tcx, BridgeTys>,
-    cx: &SmirCtxt<'tcx, BridgeTys>,
+    cx: &CompilerCtxt<'tcx, BridgeTys>,
 ) -> Allocation {
     alloc::allocation_filter(alloc, alloc_range, tables, cx)
 }
diff --git a/compiler/rustc_public/src/compiler_interface.rs b/compiler/rustc_public/src/compiler_interface.rs
index d15438c2b80..84c0ea973b7 100644
--- a/compiler/rustc_public/src/compiler_interface.rs
+++ b/compiler/rustc_public/src/compiler_interface.rs
@@ -6,7 +6,7 @@
 use std::cell::Cell;
 
 use rustc_hir::def::DefKind;
-use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::context::CompilerCtxt;
 use rustc_public_bridge::{Bridge, SmirContainer};
 use tracing::debug;
 
@@ -66,13 +66,13 @@ impl Bridge for BridgeTys {
     type Allocation = crate::ty::Allocation;
 }
 
-/// Stable public API for querying compiler information.
+/// Public API for querying compiler information.
 ///
-/// All queries are delegated to [`rustc_public_bridge::context::SmirCtxt`] that provides
+/// All queries are delegated to [`rustc_public_bridge::context::CompilerCtxt`] that provides
 /// similar APIs but based on internal rustc constructs.
 ///
 /// Do not use this directly. This is currently used in the macro expansion.
-pub(crate) trait SmirInterface {
+pub(crate) trait CompilerInterface {
     fn entry_fn(&self) -> Option<CrateItem>;
     /// Retrieve all items of the local crate that have a MIR associated with them.
     fn all_local_items(&self) -> CrateItems;
@@ -316,7 +316,7 @@ pub(crate) trait SmirInterface {
     fn associated_items(&self, def_id: DefId) -> AssocItems;
 }
 
-impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> {
+impl<'tcx> CompilerInterface for SmirContainer<'tcx, BridgeTys> {
     fn entry_fn(&self) -> Option<CrateItem> {
         let mut tables = self.tables.borrow_mut();
         let cx = &*self.cx.borrow();
@@ -1059,10 +1059,10 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> {
     }
 }
 
-// A thread local variable that stores a pointer to [`SmirInterface`].
+// A thread local variable that stores a pointer to [`CompilerInterface`].
 scoped_tls::scoped_thread_local!(static TLV: Cell<*const ()>);
 
-pub(crate) fn run<F, T>(interface: &dyn SmirInterface, f: F) -> Result<T, Error>
+pub(crate) fn run<F, T>(interface: &dyn CompilerInterface, f: F) -> Result<T, Error>
 where
     F: FnOnce() -> T,
 {
@@ -1074,21 +1074,21 @@ where
     }
 }
 
-/// Execute the given function with access the [`SmirInterface`].
+/// Execute the given function with access the [`CompilerInterface`].
 ///
 /// I.e., This function will load the current interface and calls a function with it.
 /// Do not nest these, as that will ICE.
-pub(crate) fn with<R>(f: impl FnOnce(&dyn SmirInterface) -> R) -> R {
+pub(crate) fn with<R>(f: impl FnOnce(&dyn CompilerInterface) -> R) -> R {
     assert!(TLV.is_set());
     TLV.with(|tlv| {
         let ptr = tlv.get();
         assert!(!ptr.is_null());
-        f(unsafe { *(ptr as *const &dyn SmirInterface) })
+        f(unsafe { *(ptr as *const &dyn CompilerInterface) })
     })
 }
 
 fn smir_crate<'tcx>(
-    cx: &SmirCtxt<'tcx, BridgeTys>,
+    cx: &CompilerCtxt<'tcx, BridgeTys>,
     crate_num: rustc_span::def_id::CrateNum,
 ) -> Crate {
     let name = cx.crate_name(crate_num);
diff --git a/compiler/rustc_public/src/lib.rs b/compiler/rustc_public/src/lib.rs
index e320c4eca71..958b3b26478 100644
--- a/compiler/rustc_public/src/lib.rs
+++ b/compiler/rustc_public/src/lib.rs
@@ -24,7 +24,7 @@ use std::{fmt, io};
 
 pub(crate) use rustc_public_bridge::IndexedVal;
 use rustc_public_bridge::Tables;
-use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::context::CompilerCtxt;
 /// Export the rustc_internal APIs. Note that this module has no stability
 /// guarantees and it is not taken into account for semver.
 #[cfg(feature = "rustc_internal")]
@@ -288,7 +288,7 @@ impl rustc_public_bridge::bridge::Allocation<compiler_interface::BridgeTys>
         align: u64,
         mutability: rustc_middle::mir::Mutability,
         tables: &mut Tables<'tcx, compiler_interface::BridgeTys>,
-        cx: &SmirCtxt<'tcx, compiler_interface::BridgeTys>,
+        cx: &CompilerCtxt<'tcx, compiler_interface::BridgeTys>,
     ) -> Self {
         Self {
             bytes,
diff --git a/compiler/rustc_public/src/rustc_internal/mod.rs b/compiler/rustc_public/src/rustc_internal/mod.rs
index 01354fc7bd4..0e1c857e8b1 100644
--- a/compiler/rustc_public/src/rustc_internal/mod.rs
+++ b/compiler/rustc_public/src/rustc_internal/mod.rs
@@ -6,7 +6,7 @@
 use std::cell::{Cell, RefCell};
 
 use rustc_middle::ty::TyCtxt;
-use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::context::CompilerCtxt;
 use rustc_public_bridge::{Bridge, SmirContainer, Tables};
 use rustc_span::def_id::CrateNum;
 use scoped_tls::scoped_thread_local;
@@ -72,7 +72,7 @@ where
 /// Loads the current context and calls a function with it.
 /// Do not nest these, as that will ICE.
 pub(crate) fn with_container<R, B: Bridge>(
-    f: impl for<'tcx> FnOnce(&mut Tables<'tcx, B>, &SmirCtxt<'tcx, B>) -> R,
+    f: impl for<'tcx> FnOnce(&mut Tables<'tcx, B>, &CompilerCtxt<'tcx, B>) -> R,
 ) -> R {
     assert!(TLV.is_set());
     TLV.with(|tlv| {
@@ -89,8 +89,8 @@ pub fn run<F, T>(tcx: TyCtxt<'_>, f: F) -> Result<T, Error>
 where
     F: FnOnce() -> T,
 {
-    let smir_cx = RefCell::new(SmirCtxt::new(tcx));
-    let container = SmirContainer { tables: RefCell::new(Tables::default()), cx: smir_cx };
+    let compiler_cx = RefCell::new(CompilerCtxt::new(tcx));
+    let container = SmirContainer { tables: RefCell::new(Tables::default()), cx: compiler_cx };
 
     crate::compiler_interface::run(&container, || init(&container, f))
 }
diff --git a/compiler/rustc_public/src/unstable/convert/mod.rs b/compiler/rustc_public/src/unstable/convert/mod.rs
index 85a71e09c3e..a2e83c6e239 100644
--- a/compiler/rustc_public/src/unstable/convert/mod.rs
+++ b/compiler/rustc_public/src/unstable/convert/mod.rs
@@ -9,7 +9,7 @@
 use std::ops::RangeInclusive;
 
 use rustc_public_bridge::Tables;
-use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::context::CompilerCtxt;
 
 use super::Stable;
 use crate::compiler_interface::BridgeTys;
@@ -26,7 +26,7 @@ where
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         (*self).stable(tables, cx)
     }
@@ -41,7 +41,7 @@ where
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         self.as_ref().map(|value| value.stable(tables, cx))
     }
@@ -57,7 +57,7 @@ where
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             Ok(val) => Ok(val.stable(tables, cx)),
@@ -74,7 +74,7 @@ where
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         self.iter().map(|e| e.stable(tables, cx)).collect()
     }
@@ -89,7 +89,7 @@ where
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         (self.0.stable(tables, cx), self.1.stable(tables, cx))
     }
@@ -103,7 +103,7 @@ where
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         RangeInclusive::new(self.start().stable(tables, cx), self.end().stable(tables, cx))
     }
diff --git a/compiler/rustc_public/src/unstable/convert/stable/abi.rs b/compiler/rustc_public/src/unstable/convert/stable/abi.rs
index 40a8bf614e1..782e75a930e 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/abi.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/abi.rs
@@ -5,7 +5,7 @@
 use rustc_abi::{ArmCall, CanonAbi, InterruptKind, X86Call};
 use rustc_middle::ty;
 use rustc_public_bridge::Tables;
-use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::context::CompilerCtxt;
 use rustc_target::callconv;
 
 use crate::abi::{
@@ -21,7 +21,7 @@ use crate::{IndexedVal, opaque};
 
 impl<'tcx> Stable<'tcx> for rustc_abi::VariantIdx {
     type T = VariantIdx;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         VariantIdx::to_val(self.as_usize())
     }
 }
@@ -29,7 +29,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::VariantIdx {
 impl<'tcx> Stable<'tcx> for rustc_abi::Endian {
     type T = crate::target::Endian;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             rustc_abi::Endian::Little => crate::target::Endian::Little,
             rustc_abi::Endian::Big => crate::target::Endian::Big,
@@ -43,7 +43,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::TyAndLayout<'tcx, ty::Ty<'tcx>> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         TyAndLayout { ty: self.ty.stable(tables, cx), layout: self.layout.stable(tables, cx) }
     }
@@ -55,7 +55,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Layout<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         tables.layout_id(cx.lift(*self).unwrap())
     }
@@ -67,7 +67,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::LayoutData<rustc_abi::FieldIdx, rustc_abi
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         LayoutShape {
             fields: self.fields.stable(tables, cx),
@@ -85,7 +85,7 @@ impl<'tcx> Stable<'tcx> for callconv::FnAbi<'tcx, ty::Ty<'tcx>> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         assert!(self.args.len() >= self.fixed_count as usize);
         assert!(!self.c_variadic || matches!(self.conv, CanonAbi::C));
@@ -105,7 +105,7 @@ impl<'tcx> Stable<'tcx> for callconv::ArgAbi<'tcx, ty::Ty<'tcx>> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         ArgAbi {
             ty: self.layout.ty.stable(tables, cx),
@@ -118,7 +118,7 @@ impl<'tcx> Stable<'tcx> for callconv::ArgAbi<'tcx, ty::Ty<'tcx>> {
 impl<'tcx> Stable<'tcx> for CanonAbi {
     type T = CallConvention;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             CanonAbi::C => CallConvention::C,
             CanonAbi::Rust => CallConvention::Rust,
@@ -154,7 +154,7 @@ impl<'tcx> Stable<'tcx> for CanonAbi {
 impl<'tcx> Stable<'tcx> for callconv::PassMode {
     type T = PassMode;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             callconv::PassMode::Ignore => PassMode::Ignore,
             callconv::PassMode::Direct(attr) => PassMode::Direct(opaque(attr)),
@@ -179,7 +179,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape<rustc_abi::FieldIdx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             rustc_abi::FieldsShape::Primitive => FieldsShape::Primitive,
@@ -200,7 +200,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Variants<rustc_abi::FieldIdx, rustc_abi::
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             rustc_abi::Variants::Single { index } => {
@@ -225,7 +225,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::TagEncoding<rustc_abi::VariantIdx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             rustc_abi::TagEncoding::Direct => TagEncoding::Direct,
@@ -246,7 +246,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::BackendRepr {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match *self {
             rustc_abi::BackendRepr::Scalar(scalar) => ValueAbi::Scalar(scalar.stable(tables, cx)),
@@ -264,7 +264,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::BackendRepr {
 impl<'tcx> Stable<'tcx> for rustc_abi::Size {
     type T = Size;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         Size::from_bits(self.bits_usize())
     }
 }
@@ -272,7 +272,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Size {
 impl<'tcx> Stable<'tcx> for rustc_abi::Align {
     type T = Align;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         self.bytes()
     }
 }
@@ -283,7 +283,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Scalar {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             rustc_abi::Scalar::Initialized { value, valid_range } => Scalar::Initialized {
@@ -301,7 +301,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Primitive {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             rustc_abi::Primitive::Int(length, signed) => {
@@ -318,7 +318,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Primitive {
 impl<'tcx> Stable<'tcx> for rustc_abi::AddressSpace {
     type T = AddressSpace;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         AddressSpace(self.0)
     }
 }
@@ -326,7 +326,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::AddressSpace {
 impl<'tcx> Stable<'tcx> for rustc_abi::Integer {
     type T = IntegerLength;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             rustc_abi::Integer::I8 => IntegerLength::I8,
             rustc_abi::Integer::I16 => IntegerLength::I16,
@@ -340,7 +340,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Integer {
 impl<'tcx> Stable<'tcx> for rustc_abi::Float {
     type T = FloatLength;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             rustc_abi::Float::F16 => FloatLength::F16,
             rustc_abi::Float::F32 => FloatLength::F32,
@@ -353,7 +353,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Float {
 impl<'tcx> Stable<'tcx> for rustc_abi::WrappingRange {
     type T = WrappingRange;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         WrappingRange { start: self.start, end: self.end }
     }
 }
@@ -364,7 +364,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::ReprFlags {
     fn stable<'cx>(
         &self,
         _tables: &mut Tables<'cx, BridgeTys>,
-        _cx: &SmirCtxt<'cx, BridgeTys>,
+        _cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         ReprFlags {
             is_simd: self.intersects(Self::IS_SIMD),
@@ -381,7 +381,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::IntegerType {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             rustc_abi::IntegerType::Pointer(signed) => IntegerType::Pointer { is_signed: *signed },
@@ -398,7 +398,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::ReprOptions {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         ReprOptions {
             int: self.int.map(|int| int.stable(tables, cx)),
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
index bd7d4807152..433e7a20f01 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/mir.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
@@ -4,7 +4,7 @@ use rustc_middle::mir::mono::MonoItem;
 use rustc_middle::{bug, mir};
 use rustc_public_bridge::Tables;
 use rustc_public_bridge::bridge::SmirError;
-use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::context::CompilerCtxt;
 
 use crate::compiler_interface::BridgeTys;
 use crate::mir::alloc::GlobalAlloc;
@@ -19,7 +19,7 @@ impl<'tcx> Stable<'tcx> for mir::Body<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         crate::mir::Body::new(
             self.basic_blocks
@@ -54,7 +54,7 @@ impl<'tcx> Stable<'tcx> for mir::VarDebugInfo<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         crate::mir::VarDebugInfo {
             name: self.name.to_string(),
@@ -71,7 +71,7 @@ impl<'tcx> Stable<'tcx> for mir::Statement<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         Statement {
             kind: self.kind.stable(tables, cx),
@@ -85,7 +85,7 @@ impl<'tcx> Stable<'tcx> for mir::SourceInfo {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         crate::mir::SourceInfo { span: self.span.stable(tables, cx), scope: self.scope.into() }
     }
@@ -96,7 +96,7 @@ impl<'tcx> Stable<'tcx> for mir::VarDebugInfoFragment<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         VarDebugInfoFragment {
             ty: self.ty.stable(tables, cx),
@@ -110,7 +110,7 @@ impl<'tcx> Stable<'tcx> for mir::VarDebugInfoContents<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             mir::VarDebugInfoContents::Place(place) => {
@@ -133,7 +133,7 @@ impl<'tcx> Stable<'tcx> for mir::StatementKind<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             mir::StatementKind::Assign(assign) => crate::mir::StatementKind::Assign(
@@ -195,7 +195,7 @@ impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::mir::Rvalue::*;
         match self {
@@ -259,7 +259,7 @@ impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> {
 
 impl<'tcx> Stable<'tcx> for mir::Mutability {
     type T = crate::mir::Mutability;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_hir::Mutability::*;
         match *self {
             Not => crate::mir::Mutability::Not,
@@ -270,7 +270,7 @@ impl<'tcx> Stable<'tcx> for mir::Mutability {
 
 impl<'tcx> Stable<'tcx> for mir::RawPtrKind {
     type T = crate::mir::RawPtrKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use mir::RawPtrKind::*;
         match *self {
             Const => crate::mir::RawPtrKind::Const,
@@ -285,7 +285,7 @@ impl<'tcx> Stable<'tcx> for mir::BorrowKind {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::mir::BorrowKind::*;
         match *self {
@@ -298,7 +298,7 @@ impl<'tcx> Stable<'tcx> for mir::BorrowKind {
 
 impl<'tcx> Stable<'tcx> for mir::MutBorrowKind {
     type T = crate::mir::MutBorrowKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_middle::mir::MutBorrowKind::*;
         match *self {
             Default => crate::mir::MutBorrowKind::Default,
@@ -310,7 +310,7 @@ impl<'tcx> Stable<'tcx> for mir::MutBorrowKind {
 
 impl<'tcx> Stable<'tcx> for mir::FakeBorrowKind {
     type T = crate::mir::FakeBorrowKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_middle::mir::FakeBorrowKind::*;
         match *self {
             Deep => crate::mir::FakeBorrowKind::Deep,
@@ -324,7 +324,7 @@ impl<'tcx> Stable<'tcx> for mir::NullOp<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::mir::NullOp::*;
         match self {
@@ -344,7 +344,7 @@ impl<'tcx> Stable<'tcx> for mir::CastKind {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::mir::CastKind::*;
         match self {
@@ -364,7 +364,7 @@ impl<'tcx> Stable<'tcx> for mir::CastKind {
 
 impl<'tcx> Stable<'tcx> for mir::FakeReadCause {
     type T = crate::mir::FakeReadCause;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_middle::mir::FakeReadCause::*;
         match self {
             ForMatchGuard => crate::mir::FakeReadCause::ForMatchGuard,
@@ -383,7 +383,7 @@ impl<'tcx> Stable<'tcx> for mir::Operand<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::mir::Operand::*;
         match self {
@@ -400,7 +400,7 @@ impl<'tcx> Stable<'tcx> for mir::ConstOperand<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         crate::mir::ConstOperand {
             span: self.span.stable(tables, cx),
@@ -415,7 +415,7 @@ impl<'tcx> Stable<'tcx> for mir::Place<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         crate::mir::Place {
             local: self.local.as_usize(),
@@ -429,7 +429,7 @@ impl<'tcx> Stable<'tcx> for mir::PlaceElem<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::mir::ProjectionElem::*;
         match self {
@@ -464,21 +464,21 @@ impl<'tcx> Stable<'tcx> for mir::PlaceElem<'tcx> {
 impl<'tcx> Stable<'tcx> for mir::UserTypeProjection {
     type T = crate::mir::UserTypeProjection;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         UserTypeProjection { base: self.base.as_usize(), projection: opaque(&self.projs) }
     }
 }
 
 impl<'tcx> Stable<'tcx> for mir::Local {
     type T = crate::mir::Local;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         self.as_usize()
     }
 }
 
 impl<'tcx> Stable<'tcx> for mir::RetagKind {
     type T = crate::mir::RetagKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_middle::mir::RetagKind;
         match self {
             RetagKind::FnEntry => crate::mir::RetagKind::FnEntry,
@@ -491,7 +491,7 @@ impl<'tcx> Stable<'tcx> for mir::RetagKind {
 
 impl<'tcx> Stable<'tcx> for mir::UnwindAction {
     type T = crate::mir::UnwindAction;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_middle::mir::UnwindAction;
         match self {
             UnwindAction::Continue => crate::mir::UnwindAction::Continue,
@@ -508,7 +508,7 @@ impl<'tcx> Stable<'tcx> for mir::NonDivergingIntrinsic<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::mir::NonDivergingIntrinsic;
 
@@ -533,7 +533,7 @@ impl<'tcx> Stable<'tcx> for mir::AssertMessage<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::mir::AssertKind;
         match self {
@@ -580,7 +580,7 @@ impl<'tcx> Stable<'tcx> for mir::AssertMessage<'tcx> {
 
 impl<'tcx> Stable<'tcx> for mir::BinOp {
     type T = crate::mir::BinOp;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_middle::mir::BinOp;
         match self {
             BinOp::Add => crate::mir::BinOp::Add,
@@ -615,7 +615,7 @@ impl<'tcx> Stable<'tcx> for mir::BinOp {
 
 impl<'tcx> Stable<'tcx> for mir::UnOp {
     type T = crate::mir::UnOp;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_middle::mir::UnOp;
         match self {
             UnOp::Not => crate::mir::UnOp::Not,
@@ -630,7 +630,7 @@ impl<'tcx> Stable<'tcx> for mir::AggregateKind<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             mir::AggregateKind::Array(ty) => {
@@ -676,7 +676,7 @@ impl<'tcx> Stable<'tcx> for mir::InlineAsmOperand<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::mir::InlineAsmOperand;
 
@@ -703,7 +703,7 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::mir::Terminator;
         Terminator {
@@ -718,7 +718,7 @@ impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::mir::TerminatorKind;
         match self {
@@ -807,7 +807,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::ConstAllocation<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         self.inner().stable(tables, cx)
     }
@@ -819,7 +819,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::Allocation {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_public_bridge::context::SmirAllocRange;
         alloc::allocation_filter(
@@ -836,7 +836,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::AllocId {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        _: &SmirCtxt<'cx, BridgeTys>,
+        _: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         tables.create_alloc_id(*self)
     }
@@ -848,7 +848,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::GlobalAlloc<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             mir::interpret::GlobalAlloc::Function { instance, .. } => {
@@ -877,7 +877,7 @@ impl<'tcx> Stable<'tcx> for rustc_middle::mir::Const<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let id = tables.intern_mir_const(cx.lift(*self).unwrap());
         match *self {
@@ -913,7 +913,7 @@ impl<'tcx> Stable<'tcx> for rustc_middle::mir::Const<'tcx> {
 impl<'tcx> Stable<'tcx> for mir::interpret::ErrorHandled {
     type T = Error;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         Error::new(format!("{self:?}"))
     }
 }
@@ -924,7 +924,7 @@ impl<'tcx> Stable<'tcx> for MonoItem<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::mir::mono::MonoItem as StableMonoItem;
         match self {
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mod.rs b/compiler/rustc_public/src/unstable/convert/stable/mod.rs
index ea78ca50eb3..add52fc18ca 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/mod.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/mod.rs
@@ -2,7 +2,7 @@
 
 use rustc_abi::FieldIdx;
 use rustc_public_bridge::Tables;
-use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::context::CompilerCtxt;
 
 use super::Stable;
 use crate::compiler_interface::BridgeTys;
@@ -13,7 +13,7 @@ mod ty;
 
 impl<'tcx> Stable<'tcx> for rustc_hir::Safety {
     type T = crate::mir::Safety;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             rustc_hir::Safety::Unsafe => crate::mir::Safety::Unsafe,
             rustc_hir::Safety::Safe => crate::mir::Safety::Safe,
@@ -23,14 +23,14 @@ impl<'tcx> Stable<'tcx> for rustc_hir::Safety {
 
 impl<'tcx> Stable<'tcx> for FieldIdx {
     type T = usize;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         self.as_usize()
     }
 }
 
 impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineSource {
     type T = crate::mir::CoroutineSource;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_hir::CoroutineSource;
         match self {
             CoroutineSource::Block => crate::mir::CoroutineSource::Block,
@@ -45,7 +45,7 @@ impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineKind {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_hir::{CoroutineDesugaring, CoroutineKind};
         match *self {
@@ -77,7 +77,7 @@ impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineKind {
 impl<'tcx> Stable<'tcx> for rustc_span::Symbol {
     type T = crate::Symbol;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         self.to_string()
     }
 }
@@ -88,7 +88,7 @@ impl<'tcx> Stable<'tcx> for rustc_span::Span {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        _: &SmirCtxt<'cx, BridgeTys>,
+        _: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         tables.create_span(*self)
     }
diff --git a/compiler/rustc_public/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
index 6b226b8a24d..d679615b3bd 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/ty.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs
@@ -3,7 +3,7 @@
 use rustc_middle::ty::Ty;
 use rustc_middle::{bug, mir, ty};
 use rustc_public_bridge::Tables;
-use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::context::CompilerCtxt;
 
 use crate::alloc;
 use crate::compiler_interface::BridgeTys;
@@ -14,7 +14,7 @@ use crate::unstable::Stable;
 
 impl<'tcx> Stable<'tcx> for ty::AliasTyKind {
     type T = crate::ty::AliasKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             ty::Projection => crate::ty::AliasKind::Projection,
             ty::Inherent => crate::ty::AliasKind::Inherent,
@@ -29,7 +29,7 @@ impl<'tcx> Stable<'tcx> for ty::AliasTy<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let ty::AliasTy { args, def_id, .. } = self;
         crate::ty::AliasTy { def_id: tables.alias_def(*def_id), args: args.stable(tables, cx) }
@@ -41,7 +41,7 @@ impl<'tcx> Stable<'tcx> for ty::AliasTerm<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let ty::AliasTerm { args, def_id, .. } = self;
         crate::ty::AliasTerm { def_id: tables.alias_def(*def_id), args: args.stable(tables, cx) }
@@ -51,7 +51,7 @@ impl<'tcx> Stable<'tcx> for ty::AliasTerm<'tcx> {
 impl<'tcx> Stable<'tcx> for ty::DynKind {
     type T = crate::ty::DynKind;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             ty::Dyn => crate::ty::DynKind::Dyn,
         }
@@ -64,7 +64,7 @@ impl<'tcx> Stable<'tcx> for ty::ExistentialPredicate<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::ExistentialPredicate::*;
         match self {
@@ -85,7 +85,7 @@ impl<'tcx> Stable<'tcx> for ty::ExistentialTraitRef<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let ty::ExistentialTraitRef { def_id, args, .. } = self;
         crate::ty::ExistentialTraitRef {
@@ -101,7 +101,7 @@ impl<'tcx> Stable<'tcx> for ty::TermKind<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::TermKind;
         match self {
@@ -120,7 +120,7 @@ impl<'tcx> Stable<'tcx> for ty::ExistentialProjection<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let ty::ExistentialProjection { def_id, args, term, .. } = self;
         crate::ty::ExistentialProjection {
@@ -136,7 +136,7 @@ impl<'tcx> Stable<'tcx> for ty::adjustment::PointerCoercion {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::ty::adjustment::PointerCoercion;
         match self {
@@ -154,7 +154,7 @@ impl<'tcx> Stable<'tcx> for ty::adjustment::PointerCoercion {
 
 impl<'tcx> Stable<'tcx> for ty::UserTypeAnnotationIndex {
     type T = usize;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         self.as_usize()
     }
 }
@@ -162,7 +162,7 @@ impl<'tcx> Stable<'tcx> for ty::UserTypeAnnotationIndex {
 impl<'tcx> Stable<'tcx> for ty::AdtKind {
     type T = AdtKind;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             ty::AdtKind::Struct => AdtKind::Struct,
             ty::AdtKind::Union => AdtKind::Union,
@@ -177,7 +177,7 @@ impl<'tcx> Stable<'tcx> for ty::FieldDef {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         crate::ty::FieldDef {
             def: tables.create_def_id(self.did),
@@ -191,7 +191,7 @@ impl<'tcx> Stable<'tcx> for ty::GenericArgs<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         GenericArgs(self.iter().map(|arg| arg.kind().stable(tables, cx)).collect())
     }
@@ -203,7 +203,7 @@ impl<'tcx> Stable<'tcx> for ty::GenericArgKind<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::GenericArgKind;
         match self {
@@ -225,7 +225,7 @@ where
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::Binder;
 
@@ -249,7 +249,7 @@ where
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::EarlyBinder;
 
@@ -262,7 +262,7 @@ impl<'tcx> Stable<'tcx> for ty::FnSig<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::FnSig;
 
@@ -285,7 +285,7 @@ impl<'tcx> Stable<'tcx> for ty::BoundTyKind {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::BoundTyKind;
 
@@ -304,7 +304,7 @@ impl<'tcx> Stable<'tcx> for ty::BoundRegionKind {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::BoundRegionKind;
 
@@ -326,7 +326,7 @@ impl<'tcx> Stable<'tcx> for ty::BoundVariableKind {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::BoundVariableKind;
 
@@ -345,7 +345,7 @@ impl<'tcx> Stable<'tcx> for ty::BoundVariableKind {
 impl<'tcx> Stable<'tcx> for ty::IntTy {
     type T = IntTy;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             ty::IntTy::Isize => IntTy::Isize,
             ty::IntTy::I8 => IntTy::I8,
@@ -360,7 +360,7 @@ impl<'tcx> Stable<'tcx> for ty::IntTy {
 impl<'tcx> Stable<'tcx> for ty::UintTy {
     type T = UintTy;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             ty::UintTy::Usize => UintTy::Usize,
             ty::UintTy::U8 => UintTy::U8,
@@ -375,7 +375,7 @@ impl<'tcx> Stable<'tcx> for ty::UintTy {
 impl<'tcx> Stable<'tcx> for ty::FloatTy {
     type T = FloatTy;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             ty::FloatTy::F16 => FloatTy::F16,
             ty::FloatTy::F32 => FloatTy::F32,
@@ -390,7 +390,7 @@ impl<'tcx> Stable<'tcx> for Ty<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         tables.intern_ty(cx.lift(*self).unwrap())
     }
@@ -401,7 +401,7 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match self {
             ty::Bool => TyKind::RigidTy(RigidTy::Bool),
@@ -487,7 +487,7 @@ impl<'tcx> Stable<'tcx> for ty::Pattern<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         match **self {
             ty::PatternKind::Range { start, end } => crate::ty::Pattern::Range {
@@ -507,7 +507,7 @@ impl<'tcx> Stable<'tcx> for ty::Const<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let ct = cx.lift(*self).unwrap();
         let kind = match ct.kind() {
@@ -540,7 +540,7 @@ impl<'tcx> Stable<'tcx> for ty::Const<'tcx> {
 
 impl<'tcx> Stable<'tcx> for ty::ParamConst {
     type T = crate::ty::ParamConst;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use crate::ty::ParamConst;
         ParamConst { index: self.index, name: self.name.to_string() }
     }
@@ -548,7 +548,7 @@ impl<'tcx> Stable<'tcx> for ty::ParamConst {
 
 impl<'tcx> Stable<'tcx> for ty::ParamTy {
     type T = crate::ty::ParamTy;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use crate::ty::ParamTy;
         ParamTy { index: self.index, name: self.name.to_string() }
     }
@@ -559,7 +559,7 @@ impl<'tcx> Stable<'tcx> for ty::BoundTy {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::BoundTy;
         BoundTy { var: self.var.as_usize(), kind: self.kind.stable(tables, cx) }
@@ -568,7 +568,7 @@ impl<'tcx> Stable<'tcx> for ty::BoundTy {
 
 impl<'tcx> Stable<'tcx> for ty::trait_def::TraitSpecializationKind {
     type T = crate::ty::TraitSpecializationKind;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use crate::ty::TraitSpecializationKind;
 
         match self {
@@ -586,7 +586,7 @@ impl<'tcx> Stable<'tcx> for ty::TraitDef {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::opaque;
         use crate::ty::TraitDecl;
@@ -616,7 +616,7 @@ impl<'tcx> Stable<'tcx> for ty::TraitRef<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::TraitRef;
 
@@ -630,7 +630,7 @@ impl<'tcx> Stable<'tcx> for ty::Generics {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::Generics;
 
@@ -655,7 +655,7 @@ impl<'tcx> Stable<'tcx> for ty::Generics {
 impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDefKind {
     type T = crate::ty::GenericParamDefKind;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use crate::ty::GenericParamDefKind;
         match self {
             ty::GenericParamDefKind::Lifetime => GenericParamDefKind::Lifetime,
@@ -675,7 +675,7 @@ impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDef {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         GenericParamDef {
             name: self.name.to_string(),
@@ -693,7 +693,7 @@ impl<'tcx> Stable<'tcx> for ty::PredicateKind<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::ty::PredicateKind;
         match self {
@@ -731,7 +731,7 @@ impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use rustc_middle::ty::ClauseKind;
         match *self {
@@ -774,7 +774,7 @@ impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> {
 impl<'tcx> Stable<'tcx> for ty::ClosureKind {
     type T = crate::ty::ClosureKind;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_middle::ty::ClosureKind::*;
         match self {
             Fn => crate::ty::ClosureKind::Fn,
@@ -790,7 +790,7 @@ impl<'tcx> Stable<'tcx> for ty::SubtypePredicate<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let ty::SubtypePredicate { a, b, a_is_expected: _ } = self;
         crate::ty::SubtypePredicate { a: a.stable(tables, cx), b: b.stable(tables, cx) }
@@ -803,7 +803,7 @@ impl<'tcx> Stable<'tcx> for ty::CoercePredicate<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let ty::CoercePredicate { a, b } = self;
         crate::ty::CoercePredicate { a: a.stable(tables, cx), b: b.stable(tables, cx) }
@@ -813,7 +813,7 @@ impl<'tcx> Stable<'tcx> for ty::CoercePredicate<'tcx> {
 impl<'tcx> Stable<'tcx> for ty::AliasRelationDirection {
     type T = crate::ty::AliasRelationDirection;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_middle::ty::AliasRelationDirection::*;
         match self {
             Equate => crate::ty::AliasRelationDirection::Equate,
@@ -828,7 +828,7 @@ impl<'tcx> Stable<'tcx> for ty::TraitPredicate<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let ty::TraitPredicate { trait_ref, polarity } = self;
         crate::ty::TraitPredicate {
@@ -847,7 +847,7 @@ where
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let ty::OutlivesPredicate(a, b) = self;
         crate::ty::OutlivesPredicate(a.stable(tables, cx), b.stable(tables, cx))
@@ -860,7 +860,7 @@ impl<'tcx> Stable<'tcx> for ty::ProjectionPredicate<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let ty::ProjectionPredicate { projection_term, term } = self;
         crate::ty::ProjectionPredicate {
@@ -873,7 +873,7 @@ impl<'tcx> Stable<'tcx> for ty::ProjectionPredicate<'tcx> {
 impl<'tcx> Stable<'tcx> for ty::ImplPolarity {
     type T = crate::ty::ImplPolarity;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_middle::ty::ImplPolarity::*;
         match self {
             Positive => crate::ty::ImplPolarity::Positive,
@@ -886,7 +886,7 @@ impl<'tcx> Stable<'tcx> for ty::ImplPolarity {
 impl<'tcx> Stable<'tcx> for ty::PredicatePolarity {
     type T = crate::ty::PredicatePolarity;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_middle::ty::PredicatePolarity::*;
         match self {
             Positive => crate::ty::PredicatePolarity::Positive,
@@ -901,7 +901,7 @@ impl<'tcx> Stable<'tcx> for ty::Region<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         Region { kind: self.kind().stable(tables, cx) }
     }
@@ -913,7 +913,7 @@ impl<'tcx> Stable<'tcx> for ty::RegionKind<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::{BoundRegion, EarlyParamRegion, RegionKind};
         match self {
@@ -948,7 +948,7 @@ impl<'tcx> Stable<'tcx> for ty::Instance<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         let def = tables.instance_def(cx.lift(*self).unwrap());
         let kind = match self.def {
@@ -976,7 +976,7 @@ impl<'tcx> Stable<'tcx> for ty::Instance<'tcx> {
 
 impl<'tcx> Stable<'tcx> for ty::Variance {
     type T = crate::mir::Variance;
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             ty::Bivariant => crate::mir::Variance::Bivariant,
             ty::Contravariant => crate::mir::Variance::Contravariant,
@@ -989,7 +989,7 @@ impl<'tcx> Stable<'tcx> for ty::Variance {
 impl<'tcx> Stable<'tcx> for ty::Movability {
     type T = crate::ty::Movability;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             ty::Movability::Static => crate::ty::Movability::Static,
             ty::Movability::Movable => crate::ty::Movability::Movable,
@@ -1000,7 +1000,7 @@ impl<'tcx> Stable<'tcx> for ty::Movability {
 impl<'tcx> Stable<'tcx> for rustc_abi::ExternAbi {
     type T = crate::ty::Abi;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use rustc_abi::ExternAbi;
 
         use crate::ty::Abi;
@@ -1042,7 +1042,7 @@ impl<'tcx> Stable<'tcx> for rustc_session::cstore::ForeignModule {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         crate::ty::ForeignModule {
             def_id: tables.foreign_module_def(self.def_id),
@@ -1057,7 +1057,7 @@ impl<'tcx> Stable<'tcx> for ty::AssocKind {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::{AssocKind, AssocTypeData};
         match *self {
@@ -1080,7 +1080,7 @@ impl<'tcx> Stable<'tcx> for ty::AssocKind {
 impl<'tcx> Stable<'tcx> for ty::AssocItemContainer {
     type T = crate::ty::AssocItemContainer;
 
-    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T {
+    fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         use crate::ty::AssocItemContainer;
         match self {
             ty::AssocItemContainer::Trait => AssocItemContainer::Trait,
@@ -1095,7 +1095,7 @@ impl<'tcx> Stable<'tcx> for ty::AssocItem {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         crate::ty::AssocItem {
             def_id: tables.assoc_def(self.def_id),
@@ -1112,7 +1112,7 @@ impl<'tcx> Stable<'tcx> for ty::ImplTraitInTraitData {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        _: &SmirCtxt<'cx, BridgeTys>,
+        _: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         use crate::ty::ImplTraitInTraitData;
         match self {
@@ -1135,7 +1135,7 @@ impl<'tcx> Stable<'tcx> for rustc_middle::ty::util::Discr<'tcx> {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
         crate::ty::Discr { val: self.val, ty: self.ty.stable(tables, cx) }
     }
diff --git a/compiler/rustc_public/src/unstable/mod.rs b/compiler/rustc_public/src/unstable/mod.rs
index ce7c41a64fa..ca154a3378a 100644
--- a/compiler/rustc_public/src/unstable/mod.rs
+++ b/compiler/rustc_public/src/unstable/mod.rs
@@ -10,7 +10,7 @@ use rustc_hir::def::DefKind;
 use rustc_middle::ty::{List, Ty, TyCtxt};
 use rustc_middle::{mir, ty};
 use rustc_public_bridge::Tables;
-use rustc_public_bridge::context::SmirCtxt;
+use rustc_public_bridge::context::CompilerCtxt;
 
 use super::compiler_interface::BridgeTys;
 use crate::{CtorKind, ItemKind};
@@ -21,7 +21,7 @@ mod internal_cx;
 /// Trait that defines the methods that are fine to call from [`RustcInternal`].
 ///
 /// This trait is only for [`RustcInternal`]. Any other other access to rustc's internals
-/// should go through [`rustc_public_bridge::context::SmirCtxt`].
+/// should go through [`rustc_public_bridge::context::CompilerCtxt`].
 pub trait InternalCx<'tcx>: Copy + Clone {
     fn tcx(self) -> TyCtxt<'tcx>;
 
@@ -66,7 +66,7 @@ pub trait Stable<'tcx>: PointeeSized {
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
-        cx: &SmirCtxt<'cx, BridgeTys>,
+        cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T;
 }
 
diff --git a/compiler/rustc_public_bridge/src/alloc.rs b/compiler/rustc_public_bridge/src/alloc.rs
index 23bbaddce06..906e4aae9f2 100644
--- a/compiler/rustc_public_bridge/src/alloc.rs
+++ b/compiler/rustc_public_bridge/src/alloc.rs
@@ -10,12 +10,12 @@ use rustc_middle::mir::interpret::{
 };
 use rustc_middle::ty::{Ty, layout};
 
-use super::{SmirCtxt, Tables};
+use super::{CompilerCtxt, Tables};
 use crate::bridge::Allocation as _;
 use crate::{Bridge, SmirError};
 
 pub fn create_ty_and_layout<'tcx, B: Bridge>(
-    cx: &SmirCtxt<'tcx, B>,
+    cx: &CompilerCtxt<'tcx, B>,
     ty: Ty<'tcx>,
 ) -> Result<TyAndLayout<'tcx, Ty<'tcx>>, &'tcx layout::LayoutError<'tcx>> {
     use crate::context::SmirTypingEnv;
@@ -25,7 +25,7 @@ pub fn create_ty_and_layout<'tcx, B: Bridge>(
 pub fn try_new_scalar<'tcx, B: Bridge>(
     layout: TyAndLayout<'tcx, Ty<'tcx>>,
     scalar: Scalar,
-    cx: &SmirCtxt<'tcx, B>,
+    cx: &CompilerCtxt<'tcx, B>,
 ) -> Result<Allocation, B::Error> {
     let size = scalar.size();
     let mut allocation = Allocation::new(size, layout.align.abi, AllocInit::Uninit, ());
@@ -40,7 +40,7 @@ pub fn try_new_slice<'tcx, B: Bridge>(
     layout: TyAndLayout<'tcx, Ty<'tcx>>,
     data: ConstAllocation<'tcx>,
     meta: u64,
-    cx: &SmirCtxt<'tcx, B>,
+    cx: &CompilerCtxt<'tcx, B>,
 ) -> Result<Allocation, B::Error> {
     let alloc_id = cx.tcx.reserve_and_set_memory_alloc(data);
     let ptr = Pointer::new(alloc_id.into(), Size::ZERO);
@@ -60,7 +60,7 @@ pub fn try_new_slice<'tcx, B: Bridge>(
 
 pub fn try_new_indirect<'tcx, B: Bridge>(
     alloc_id: AllocId,
-    cx: &SmirCtxt<'tcx, B>,
+    cx: &CompilerCtxt<'tcx, B>,
 ) -> ConstAllocation<'tcx> {
     let alloc = cx.tcx.global_alloc(alloc_id).unwrap_memory();
 
@@ -72,7 +72,7 @@ pub fn allocation_filter<'tcx, B: Bridge>(
     alloc: &rustc_middle::mir::interpret::Allocation,
     alloc_range: AllocRange,
     tables: &mut Tables<'tcx, B>,
-    cx: &SmirCtxt<'tcx, B>,
+    cx: &CompilerCtxt<'tcx, B>,
 ) -> B::Allocation {
     let mut bytes: Vec<Option<u8>> = alloc
         .inspect_with_uninit_and_ptr_outside_interpreter(
diff --git a/compiler/rustc_public_bridge/src/bridge.rs b/compiler/rustc_public_bridge/src/bridge.rs
index 379a8da5df9..675bb2d8bc3 100644
--- a/compiler/rustc_public_bridge/src/bridge.rs
+++ b/compiler/rustc_public_bridge/src/bridge.rs
@@ -6,7 +6,7 @@
 
 use std::fmt::Debug;
 
-use super::context::SmirCtxt;
+use super::context::CompilerCtxt;
 use super::{Bridge, Tables};
 
 pub trait SmirError {
@@ -25,7 +25,7 @@ pub trait Allocation<B: Bridge> {
         align: u64,
         mutability: rustc_middle::mir::Mutability,
         tables: &mut Tables<'tcx, B>,
-        cx: &SmirCtxt<'tcx, B>,
+        cx: &CompilerCtxt<'tcx, B>,
     ) -> Self;
 }
 
diff --git a/compiler/rustc_public_bridge/src/context/impls.rs b/compiler/rustc_public_bridge/src/context/impls.rs
index fdefad2821b..268aa6927d2 100644
--- a/compiler/rustc_public_bridge/src/context/impls.rs
+++ b/compiler/rustc_public_bridge/src/context/impls.rs
@@ -24,23 +24,23 @@ use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use rustc_span::{FileNameDisplayPreference, Span, Symbol};
 use rustc_target::callconv::FnAbi;
 
-use super::{SmirAllocRange, SmirCtxt, SmirTy, SmirTypingEnv};
+use super::{SmirAllocRange, CompilerCtxt, SmirTy, SmirTypingEnv};
 use crate::builder::BodyBuilder;
 use crate::{Bridge, SmirError, Tables, filter_def_ids};
 
-impl<'tcx, B: Bridge> SmirTy<'tcx> for SmirCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> SmirTy<'tcx> for CompilerCtxt<'tcx, B> {
     fn new_foreign(&self, def_id: DefId) -> ty::Ty<'tcx> {
         ty::Ty::new_foreign(self.tcx, def_id)
     }
 }
 
-impl<'tcx, B: Bridge> SmirTypingEnv<'tcx> for SmirCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> SmirTypingEnv<'tcx> for CompilerCtxt<'tcx, B> {
     fn fully_monomorphized(&self) -> ty::TypingEnv<'tcx> {
         ty::TypingEnv::fully_monomorphized()
     }
 }
 
-impl<'tcx, B: Bridge> SmirAllocRange<'tcx> for SmirCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> SmirAllocRange<'tcx> for CompilerCtxt<'tcx, B> {
     fn alloc_range(
         &self,
         offset: rustc_abi::Size,
@@ -50,7 +50,7 @@ impl<'tcx, B: Bridge> SmirAllocRange<'tcx> for SmirCtxt<'tcx, B> {
     }
 }
 
-impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> CompilerCtxt<'tcx, B> {
     pub fn lift<T: ty::Lift<TyCtxt<'tcx>>>(&self, value: T) -> Option<T::Lifted> {
         self.tcx.lift(value)
     }
diff --git a/compiler/rustc_public_bridge/src/context/mod.rs b/compiler/rustc_public_bridge/src/context/mod.rs
index da20be2a4b3..d2fbf976a24 100644
--- a/compiler/rustc_public_bridge/src/context/mod.rs
+++ b/compiler/rustc_public_bridge/src/context/mod.rs
@@ -18,21 +18,21 @@ pub use traits::*;
 
 /// Provides direct access to rustc's internal queries.
 ///
-/// `SmirInterface` must go through
+/// `CompilerInterface` must go through
 /// this context to obtain rustc-level information.
-pub struct SmirCtxt<'tcx, B: Bridge> {
+pub struct CompilerCtxt<'tcx, B: Bridge> {
     pub tcx: TyCtxt<'tcx>,
     _marker: PhantomData<B>,
 }
 
-impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> CompilerCtxt<'tcx, B> {
     pub fn new(tcx: TyCtxt<'tcx>) -> Self {
         Self { tcx, _marker: Default::default() }
     }
 }
 
 /// Implement error handling for extracting function ABI information.
-impl<'tcx, B: Bridge> FnAbiOfHelpers<'tcx> for SmirCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> FnAbiOfHelpers<'tcx> for CompilerCtxt<'tcx, B> {
     type FnAbiOfResult = Result<&'tcx rustc_target::callconv::FnAbi<'tcx, Ty<'tcx>>, B::Error>;
 
     #[inline]
@@ -46,7 +46,7 @@ impl<'tcx, B: Bridge> FnAbiOfHelpers<'tcx> for SmirCtxt<'tcx, B> {
     }
 }
 
-impl<'tcx, B: Bridge> LayoutOfHelpers<'tcx> for SmirCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> LayoutOfHelpers<'tcx> for CompilerCtxt<'tcx, B> {
     type LayoutOfResult = Result<ty::layout::TyAndLayout<'tcx>, B::Error>;
 
     #[inline]
@@ -60,19 +60,19 @@ impl<'tcx, B: Bridge> LayoutOfHelpers<'tcx> for SmirCtxt<'tcx, B> {
     }
 }
 
-impl<'tcx, B: Bridge> HasTypingEnv<'tcx> for SmirCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> HasTypingEnv<'tcx> for CompilerCtxt<'tcx, B> {
     fn typing_env(&self) -> ty::TypingEnv<'tcx> {
         ty::TypingEnv::fully_monomorphized()
     }
 }
 
-impl<'tcx, B: Bridge> HasTyCtxt<'tcx> for SmirCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> HasTyCtxt<'tcx> for CompilerCtxt<'tcx, B> {
     fn tcx(&self) -> TyCtxt<'tcx> {
         self.tcx
     }
 }
 
-impl<'tcx, B: Bridge> HasDataLayout for SmirCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> HasDataLayout for CompilerCtxt<'tcx, B> {
     fn data_layout(&self) -> &rustc_abi::TargetDataLayout {
         self.tcx.data_layout()
     }
diff --git a/compiler/rustc_public_bridge/src/lib.rs b/compiler/rustc_public_bridge/src/lib.rs
index 652a8093a87..7f58430ea49 100644
--- a/compiler/rustc_public_bridge/src/lib.rs
+++ b/compiler/rustc_public_bridge/src/lib.rs
@@ -29,7 +29,7 @@ use std::hash::Hash;
 use std::ops::Index;
 
 use bridge::*;
-use context::SmirCtxt;
+use context::CompilerCtxt;
 use rustc_data_structures::fx::{self, FxIndexMap};
 use rustc_middle::mir;
 use rustc_middle::mir::interpret::AllocId;
@@ -48,7 +48,7 @@ pub mod rustc_internal {}
 /// A container which is used for TLS.
 pub struct SmirContainer<'tcx, B: Bridge> {
     pub tables: RefCell<Tables<'tcx, B>>,
-    pub cx: RefCell<SmirCtxt<'tcx, B>>,
+    pub cx: RefCell<CompilerCtxt<'tcx, B>>,
 }
 
 pub struct Tables<'tcx, B: Bridge> {
-- 
cgit 1.4.1-3-g733a5


From 7f22e88fab428181401b0c9d3aaf972784a65383 Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Tue, 15 Jul 2025 13:21:41 +0000
Subject: `SmirContainer` to `Container`

---
 compiler/rustc_public/src/compiler_interface.rs | 4 ++--
 compiler/rustc_public/src/rustc_internal/mod.rs | 8 ++++----
 compiler/rustc_public_bridge/src/lib.rs         | 2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_public/src/compiler_interface.rs b/compiler/rustc_public/src/compiler_interface.rs
index 84c0ea973b7..1e7a4223f3f 100644
--- a/compiler/rustc_public/src/compiler_interface.rs
+++ b/compiler/rustc_public/src/compiler_interface.rs
@@ -7,7 +7,7 @@ use std::cell::Cell;
 
 use rustc_hir::def::DefKind;
 use rustc_public_bridge::context::CompilerCtxt;
-use rustc_public_bridge::{Bridge, SmirContainer};
+use rustc_public_bridge::{Bridge, Container};
 use tracing::debug;
 
 use crate::abi::{FnAbi, Layout, LayoutShape, ReprOptions};
@@ -316,7 +316,7 @@ pub(crate) trait CompilerInterface {
     fn associated_items(&self, def_id: DefId) -> AssocItems;
 }
 
-impl<'tcx> CompilerInterface for SmirContainer<'tcx, BridgeTys> {
+impl<'tcx> CompilerInterface for Container<'tcx, BridgeTys> {
     fn entry_fn(&self) -> Option<CrateItem> {
         let mut tables = self.tables.borrow_mut();
         let cx = &*self.cx.borrow();
diff --git a/compiler/rustc_public/src/rustc_internal/mod.rs b/compiler/rustc_public/src/rustc_internal/mod.rs
index 0e1c857e8b1..ca999b62f80 100644
--- a/compiler/rustc_public/src/rustc_internal/mod.rs
+++ b/compiler/rustc_public/src/rustc_internal/mod.rs
@@ -7,7 +7,7 @@ use std::cell::{Cell, RefCell};
 
 use rustc_middle::ty::TyCtxt;
 use rustc_public_bridge::context::CompilerCtxt;
-use rustc_public_bridge::{Bridge, SmirContainer, Tables};
+use rustc_public_bridge::{Bridge, Container, Tables};
 use rustc_span::def_id::CrateNum;
 use scoped_tls::scoped_thread_local;
 
@@ -60,7 +60,7 @@ pub fn crate_num(item: &crate::Crate) -> CrateNum {
 // datastructures and stable MIR datastructures
 scoped_thread_local! (static TLV: Cell<*const ()>);
 
-pub(crate) fn init<'tcx, F, T, B: Bridge>(container: &SmirContainer<'tcx, B>, f: F) -> T
+pub(crate) fn init<'tcx, F, T, B: Bridge>(container: &Container<'tcx, B>, f: F) -> T
 where
     F: FnOnce() -> T,
 {
@@ -78,7 +78,7 @@ pub(crate) fn with_container<R, B: Bridge>(
     TLV.with(|tlv| {
         let ptr = tlv.get();
         assert!(!ptr.is_null());
-        let container = ptr as *const SmirContainer<'_, B>;
+        let container = ptr as *const Container<'_, B>;
         let mut tables = unsafe { (*container).tables.borrow_mut() };
         let cx = unsafe { (*container).cx.borrow() };
         f(&mut *tables, &*cx)
@@ -90,7 +90,7 @@ where
     F: FnOnce() -> T,
 {
     let compiler_cx = RefCell::new(CompilerCtxt::new(tcx));
-    let container = SmirContainer { tables: RefCell::new(Tables::default()), cx: compiler_cx };
+    let container = Container { tables: RefCell::new(Tables::default()), cx: compiler_cx };
 
     crate::compiler_interface::run(&container, || init(&container, f))
 }
diff --git a/compiler/rustc_public_bridge/src/lib.rs b/compiler/rustc_public_bridge/src/lib.rs
index 7f58430ea49..2bb259a857c 100644
--- a/compiler/rustc_public_bridge/src/lib.rs
+++ b/compiler/rustc_public_bridge/src/lib.rs
@@ -46,7 +46,7 @@ pub mod context;
 pub mod rustc_internal {}
 
 /// A container which is used for TLS.
-pub struct SmirContainer<'tcx, B: Bridge> {
+pub struct Container<'tcx, B: Bridge> {
     pub tables: RefCell<Tables<'tcx, B>>,
     pub cx: RefCell<CompilerCtxt<'tcx, B>>,
 }
-- 
cgit 1.4.1-3-g733a5


From ad0de062b50e521bd1ea100921d25021ab90b1e5 Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Tue, 15 Jul 2025 13:51:55 +0000
Subject: use "helper" as a more descriptive name

---
 compiler/rustc_public/src/alloc.rs                 |  2 +-
 compiler/rustc_public/src/compiler_interface.rs    |  2 +-
 .../rustc_public/src/unstable/convert/internal.rs  |  6 ++---
 .../src/unstable/convert/stable/mir.rs             |  2 +-
 .../src/unstable/internal_cx/helpers.rs            | 31 ++++++++++++++++++++++
 .../rustc_public/src/unstable/internal_cx/mod.rs   | 10 +++----
 .../src/unstable/internal_cx/traits.rs             | 31 ----------------------
 compiler/rustc_public_bridge/src/alloc.rs          |  2 +-
 .../rustc_public_bridge/src/context/helpers.rs     | 21 +++++++++++++++
 compiler/rustc_public_bridge/src/context/impls.rs  | 10 +++----
 compiler/rustc_public_bridge/src/context/mod.rs    |  4 +--
 compiler/rustc_public_bridge/src/context/traits.rs | 21 ---------------
 12 files changed, 71 insertions(+), 71 deletions(-)
 create mode 100644 compiler/rustc_public/src/unstable/internal_cx/helpers.rs
 delete mode 100644 compiler/rustc_public/src/unstable/internal_cx/traits.rs
 create mode 100644 compiler/rustc_public_bridge/src/context/helpers.rs
 delete mode 100644 compiler/rustc_public_bridge/src/context/traits.rs

diff --git a/compiler/rustc_public/src/alloc.rs b/compiler/rustc_public/src/alloc.rs
index f2cb8a900a6..cb6cc37e829 100644
--- a/compiler/rustc_public/src/alloc.rs
+++ b/compiler/rustc_public/src/alloc.rs
@@ -59,7 +59,7 @@ pub(crate) fn try_new_allocation<'tcx>(
         }
         ConstValue::Indirect { alloc_id, offset } => {
             let alloc = alloc::try_new_indirect(alloc_id, cx);
-            use rustc_public_bridge::context::SmirAllocRange;
+            use rustc_public_bridge::context::AllocRangeHelpers;
             Ok(allocation_filter(&alloc.0, cx.alloc_range(offset, layout.size), tables, cx))
         }
     }
diff --git a/compiler/rustc_public/src/compiler_interface.rs b/compiler/rustc_public/src/compiler_interface.rs
index 1e7a4223f3f..043064951d5 100644
--- a/compiler/rustc_public/src/compiler_interface.rs
+++ b/compiler/rustc_public/src/compiler_interface.rs
@@ -567,7 +567,7 @@ impl<'tcx> CompilerInterface for Container<'tcx, BridgeTys> {
             DefKind::Fn => ForeignItemKind::Fn(tables.fn_def(def_id)),
             DefKind::Static { .. } => ForeignItemKind::Static(tables.static_def(def_id)),
             DefKind::ForeignTy => {
-                use rustc_public_bridge::context::SmirTy;
+                use rustc_public_bridge::context::TyHelpers;
                 ForeignItemKind::Type(tables.intern_ty(cx.new_foreign(def_id)))
             }
             def_kind => unreachable!("Unexpected kind for a foreign item: {:?}", def_kind),
diff --git a/compiler/rustc_public/src/unstable/convert/internal.rs b/compiler/rustc_public/src/unstable/convert/internal.rs
index 8a6238413b0..0571a03b62b 100644
--- a/compiler/rustc_public/src/unstable/convert/internal.rs
+++ b/compiler/rustc_public/src/unstable/convert/internal.rs
@@ -504,7 +504,7 @@ impl RustcInternal for ExistentialProjection {
         tables: &mut Tables<'_, BridgeTys>,
         tcx: impl InternalCx<'tcx>,
     ) -> Self::T<'tcx> {
-        use crate::unstable::internal_cx::SmirExistentialProjection;
+        use crate::unstable::internal_cx::ExistentialProjectionHelpers;
         tcx.new_from_args(
             self.def_id.0.internal(tables, tcx),
             self.generic_args.internal(tables, tcx),
@@ -536,7 +536,7 @@ impl RustcInternal for ExistentialTraitRef {
         tables: &mut Tables<'_, BridgeTys>,
         tcx: impl InternalCx<'tcx>,
     ) -> Self::T<'tcx> {
-        use crate::unstable::internal_cx::SmirExistentialTraitRef;
+        use crate::unstable::internal_cx::ExistentialTraitRefHelpers;
         tcx.new_from_args(
             self.def_id.0.internal(tables, tcx),
             self.generic_args.internal(tables, tcx),
@@ -552,7 +552,7 @@ impl RustcInternal for TraitRef {
         tables: &mut Tables<'_, BridgeTys>,
         tcx: impl InternalCx<'tcx>,
     ) -> Self::T<'tcx> {
-        use crate::unstable::internal_cx::SmirTraitRef;
+        use crate::unstable::internal_cx::TraitRefHelpers;
         tcx.new_from_args(self.def_id.0.internal(tables, tcx), self.args().internal(tables, tcx))
     }
 }
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
index 433e7a20f01..cb68129c660 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/mir.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
@@ -821,7 +821,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::Allocation {
         tables: &mut Tables<'cx, BridgeTys>,
         cx: &CompilerCtxt<'cx, BridgeTys>,
     ) -> Self::T {
-        use rustc_public_bridge::context::SmirAllocRange;
+        use rustc_public_bridge::context::AllocRangeHelpers;
         alloc::allocation_filter(
             self,
             cx.alloc_range(rustc_abi::Size::ZERO, self.size()),
diff --git a/compiler/rustc_public/src/unstable/internal_cx/helpers.rs b/compiler/rustc_public/src/unstable/internal_cx/helpers.rs
new file mode 100644
index 00000000000..da635c04d74
--- /dev/null
+++ b/compiler/rustc_public/src/unstable/internal_cx/helpers.rs
@@ -0,0 +1,31 @@
+//! A set of traits that define a stable interface to rustc's internals.
+//!
+//! These traits are primarily used to clarify the behavior of different
+//! functions that share the same name across various contexts.
+
+use rustc_middle::ty;
+
+pub(crate) trait ExistentialProjectionHelpers<'tcx> {
+    fn new_from_args(
+        &self,
+        def_id: rustc_span::def_id::DefId,
+        args: ty::GenericArgsRef<'tcx>,
+        term: ty::Term<'tcx>,
+    ) -> ty::ExistentialProjection<'tcx>;
+}
+
+pub(crate) trait ExistentialTraitRefHelpers<'tcx> {
+    fn new_from_args(
+        &self,
+        trait_def_id: rustc_span::def_id::DefId,
+        args: ty::GenericArgsRef<'tcx>,
+    ) -> ty::ExistentialTraitRef<'tcx>;
+}
+
+pub(crate) trait TraitRefHelpers<'tcx> {
+    fn new_from_args(
+        &self,
+        trait_def_id: rustc_span::def_id::DefId,
+        args: ty::GenericArgsRef<'tcx>,
+    ) -> ty::TraitRef<'tcx>;
+}
diff --git a/compiler/rustc_public/src/unstable/internal_cx/mod.rs b/compiler/rustc_public/src/unstable/internal_cx/mod.rs
index 6b0a06e304c..44fbfde8775 100644
--- a/compiler/rustc_public/src/unstable/internal_cx/mod.rs
+++ b/compiler/rustc_public/src/unstable/internal_cx/mod.rs
@@ -2,13 +2,13 @@
 
 use rustc_middle::ty::{List, Ty, TyCtxt};
 use rustc_middle::{mir, ty};
-pub(crate) use traits::*;
+pub(crate) use helpers::*;
 
 use super::InternalCx;
 
-pub(crate) mod traits;
+pub(crate) mod helpers;
 
-impl<'tcx, T: InternalCx<'tcx>> SmirExistentialProjection<'tcx> for T {
+impl<'tcx, T: InternalCx<'tcx>> ExistentialProjectionHelpers<'tcx> for T {
     fn new_from_args(
         &self,
         def_id: rustc_span::def_id::DefId,
@@ -19,7 +19,7 @@ impl<'tcx, T: InternalCx<'tcx>> SmirExistentialProjection<'tcx> for T {
     }
 }
 
-impl<'tcx, T: InternalCx<'tcx>> SmirExistentialTraitRef<'tcx> for T {
+impl<'tcx, T: InternalCx<'tcx>> ExistentialTraitRefHelpers<'tcx> for T {
     fn new_from_args(
         &self,
         trait_def_id: rustc_span::def_id::DefId,
@@ -29,7 +29,7 @@ impl<'tcx, T: InternalCx<'tcx>> SmirExistentialTraitRef<'tcx> for T {
     }
 }
 
-impl<'tcx, T: InternalCx<'tcx>> SmirTraitRef<'tcx> for T {
+impl<'tcx, T: InternalCx<'tcx>> TraitRefHelpers<'tcx> for T {
     fn new_from_args(
         &self,
         trait_def_id: rustc_span::def_id::DefId,
diff --git a/compiler/rustc_public/src/unstable/internal_cx/traits.rs b/compiler/rustc_public/src/unstable/internal_cx/traits.rs
deleted file mode 100644
index da443cd78f1..00000000000
--- a/compiler/rustc_public/src/unstable/internal_cx/traits.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//! A set of traits that define a stable interface to rustc's internals.
-//!
-//! These traits are primarily used to clarify the behavior of different
-//! functions that share the same name across various contexts.
-
-use rustc_middle::ty;
-
-pub(crate) trait SmirExistentialProjection<'tcx> {
-    fn new_from_args(
-        &self,
-        def_id: rustc_span::def_id::DefId,
-        args: ty::GenericArgsRef<'tcx>,
-        term: ty::Term<'tcx>,
-    ) -> ty::ExistentialProjection<'tcx>;
-}
-
-pub(crate) trait SmirExistentialTraitRef<'tcx> {
-    fn new_from_args(
-        &self,
-        trait_def_id: rustc_span::def_id::DefId,
-        args: ty::GenericArgsRef<'tcx>,
-    ) -> ty::ExistentialTraitRef<'tcx>;
-}
-
-pub(crate) trait SmirTraitRef<'tcx> {
-    fn new_from_args(
-        &self,
-        trait_def_id: rustc_span::def_id::DefId,
-        args: ty::GenericArgsRef<'tcx>,
-    ) -> ty::TraitRef<'tcx>;
-}
diff --git a/compiler/rustc_public_bridge/src/alloc.rs b/compiler/rustc_public_bridge/src/alloc.rs
index 906e4aae9f2..c866b05e6cf 100644
--- a/compiler/rustc_public_bridge/src/alloc.rs
+++ b/compiler/rustc_public_bridge/src/alloc.rs
@@ -18,7 +18,7 @@ pub fn create_ty_and_layout<'tcx, B: Bridge>(
     cx: &CompilerCtxt<'tcx, B>,
     ty: Ty<'tcx>,
 ) -> Result<TyAndLayout<'tcx, Ty<'tcx>>, &'tcx layout::LayoutError<'tcx>> {
-    use crate::context::SmirTypingEnv;
+    use crate::context::TypingEnvHelpers;
     cx.tcx.layout_of(cx.fully_monomorphized().as_query_input(ty))
 }
 
diff --git a/compiler/rustc_public_bridge/src/context/helpers.rs b/compiler/rustc_public_bridge/src/context/helpers.rs
new file mode 100644
index 00000000000..21eef29e5f1
--- /dev/null
+++ b/compiler/rustc_public_bridge/src/context/helpers.rs
@@ -0,0 +1,21 @@
+//! A set of traits that define a stable interface to rustc's internals.
+//!
+//! These traits abstract rustc's internal APIs, allowing rustc_public to maintain a stable
+//! interface regardless of internal compiler changes.
+
+use rustc_middle::mir::interpret::AllocRange;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
+use rustc_span::def_id::DefId;
+
+pub trait TyHelpers<'tcx> {
+    fn new_foreign(&self, def_id: DefId) -> Ty<'tcx>;
+}
+
+pub trait TypingEnvHelpers<'tcx> {
+    fn fully_monomorphized(&self) -> ty::TypingEnv<'tcx>;
+}
+
+pub trait AllocRangeHelpers<'tcx> {
+    fn alloc_range(&self, offset: rustc_abi::Size, size: rustc_abi::Size) -> AllocRange;
+}
diff --git a/compiler/rustc_public_bridge/src/context/impls.rs b/compiler/rustc_public_bridge/src/context/impls.rs
index 268aa6927d2..8079fc95f97 100644
--- a/compiler/rustc_public_bridge/src/context/impls.rs
+++ b/compiler/rustc_public_bridge/src/context/impls.rs
@@ -24,23 +24,23 @@ use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use rustc_span::{FileNameDisplayPreference, Span, Symbol};
 use rustc_target::callconv::FnAbi;
 
-use super::{SmirAllocRange, CompilerCtxt, SmirTy, SmirTypingEnv};
+use super::{AllocRangeHelpers, CompilerCtxt, TyHelpers, TypingEnvHelpers};
 use crate::builder::BodyBuilder;
 use crate::{Bridge, SmirError, Tables, filter_def_ids};
 
-impl<'tcx, B: Bridge> SmirTy<'tcx> for CompilerCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> TyHelpers<'tcx> for CompilerCtxt<'tcx, B> {
     fn new_foreign(&self, def_id: DefId) -> ty::Ty<'tcx> {
         ty::Ty::new_foreign(self.tcx, def_id)
     }
 }
 
-impl<'tcx, B: Bridge> SmirTypingEnv<'tcx> for CompilerCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> TypingEnvHelpers<'tcx> for CompilerCtxt<'tcx, B> {
     fn fully_monomorphized(&self) -> ty::TypingEnv<'tcx> {
         ty::TypingEnv::fully_monomorphized()
     }
 }
 
-impl<'tcx, B: Bridge> SmirAllocRange<'tcx> for CompilerCtxt<'tcx, B> {
+impl<'tcx, B: Bridge> AllocRangeHelpers<'tcx> for CompilerCtxt<'tcx, B> {
     fn alloc_range(
         &self,
         offset: rustc_abi::Size,
@@ -426,7 +426,7 @@ impl<'tcx, B: Bridge> CompilerCtxt<'tcx, B> {
 
     /// Evaluate constant as a target usize.
     pub fn eval_target_usize(&self, cnst: MirConst<'tcx>) -> Result<u64, B::Error> {
-        use crate::context::SmirTypingEnv;
+        use crate::context::TypingEnvHelpers;
         cnst.try_eval_target_usize(self.tcx, self.fully_monomorphized())
             .ok_or_else(|| B::Error::new(format!("Const `{cnst:?}` cannot be encoded as u64")))
     }
diff --git a/compiler/rustc_public_bridge/src/context/mod.rs b/compiler/rustc_public_bridge/src/context/mod.rs
index d2fbf976a24..3aa5c33c57d 100644
--- a/compiler/rustc_public_bridge/src/context/mod.rs
+++ b/compiler/rustc_public_bridge/src/context/mod.rs
@@ -12,9 +12,9 @@ use rustc_middle::ty::{Ty, TyCtxt};
 use crate::{Bridge, SmirError};
 
 mod impls;
-mod traits;
+mod helpers;
 
-pub use traits::*;
+pub use helpers::*;
 
 /// Provides direct access to rustc's internal queries.
 ///
diff --git a/compiler/rustc_public_bridge/src/context/traits.rs b/compiler/rustc_public_bridge/src/context/traits.rs
deleted file mode 100644
index 8483bee4aad..00000000000
--- a/compiler/rustc_public_bridge/src/context/traits.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! A set of traits that define a stable interface to rustc's internals.
-//!
-//! These traits abstract rustc's internal APIs, allowing StableMIR to maintain a stable
-//! interface regardless of internal compiler changes.
-
-use rustc_middle::mir::interpret::AllocRange;
-use rustc_middle::ty;
-use rustc_middle::ty::Ty;
-use rustc_span::def_id::DefId;
-
-pub trait SmirTy<'tcx> {
-    fn new_foreign(&self, def_id: DefId) -> Ty<'tcx>;
-}
-
-pub trait SmirTypingEnv<'tcx> {
-    fn fully_monomorphized(&self) -> ty::TypingEnv<'tcx>;
-}
-
-pub trait SmirAllocRange<'tcx> {
-    fn alloc_range(&self, offset: rustc_abi::Size, size: rustc_abi::Size) -> AllocRange;
-}
-- 
cgit 1.4.1-3-g733a5


From 08e3cf511819ecc058230ccf2dd4a8e4f55625e1 Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Tue, 15 Jul 2025 13:53:51 +0000
Subject: rename `ui-fulldeps/stable-mir`

---
 tests/ui-fulldeps/rustc_public/check_abi.rs        | 225 ++++++++++++++++++
 tests/ui-fulldeps/rustc_public/check_allocation.rs | 257 ++++++++++++++++++++
 .../ui-fulldeps/rustc_public/check_assoc_items.rs  | 143 ++++++++++++
 tests/ui-fulldeps/rustc_public/check_attribute.rs  | 113 +++++++++
 tests/ui-fulldeps/rustc_public/check_binop.rs      | 146 ++++++++++++
 .../rustc_public/check_coroutine_body.rs           | 105 +++++++++
 tests/ui-fulldeps/rustc_public/check_crate_defs.rs | 148 ++++++++++++
 tests/ui-fulldeps/rustc_public/check_def_ty.rs     | 111 +++++++++
 tests/ui-fulldeps/rustc_public/check_defs.rs       | 139 +++++++++++
 tests/ui-fulldeps/rustc_public/check_foreign.rs    |  89 +++++++
 tests/ui-fulldeps/rustc_public/check_instance.rs   | 137 +++++++++++
 tests/ui-fulldeps/rustc_public/check_intrinsics.rs | 137 +++++++++++
 tests/ui-fulldeps/rustc_public/check_item_kind.rs  |  79 +++++++
 .../rustc_public/check_normalization.rs            |  93 ++++++++
 .../rustc_public/check_trait_queries.rs            | 121 ++++++++++
 tests/ui-fulldeps/rustc_public/check_transform.rs  | 145 ++++++++++++
 tests/ui-fulldeps/rustc_public/check_ty_fold.rs    | 113 +++++++++
 tests/ui-fulldeps/rustc_public/check_variant.rs    | 183 +++++++++++++++
 .../rustc_public/closure-generic-body.rs           |  90 +++++++
 tests/ui-fulldeps/rustc_public/closure_body.rs     |  90 +++++++
 .../ui-fulldeps/rustc_public/compilation-result.rs |  86 +++++++
 tests/ui-fulldeps/rustc_public/crate-info.rs       | 259 +++++++++++++++++++++
 tests/ui-fulldeps/rustc_public/projections.rs      | 174 ++++++++++++++
 tests/ui-fulldeps/rustc_public/smir_internal.rs    |  61 +++++
 tests/ui-fulldeps/rustc_public/smir_serde.rs       |  68 ++++++
 tests/ui-fulldeps/rustc_public/smir_visitor.rs     | 223 ++++++++++++++++++
 tests/ui-fulldeps/stable-mir/check_abi.rs          | 225 ------------------
 tests/ui-fulldeps/stable-mir/check_allocation.rs   | 257 --------------------
 tests/ui-fulldeps/stable-mir/check_assoc_items.rs  | 143 ------------
 tests/ui-fulldeps/stable-mir/check_attribute.rs    | 113 ---------
 tests/ui-fulldeps/stable-mir/check_binop.rs        | 146 ------------
 .../ui-fulldeps/stable-mir/check_coroutine_body.rs | 105 ---------
 tests/ui-fulldeps/stable-mir/check_crate_defs.rs   | 148 ------------
 tests/ui-fulldeps/stable-mir/check_def_ty.rs       | 111 ---------
 tests/ui-fulldeps/stable-mir/check_defs.rs         | 139 -----------
 tests/ui-fulldeps/stable-mir/check_foreign.rs      |  89 -------
 tests/ui-fulldeps/stable-mir/check_instance.rs     | 137 -----------
 tests/ui-fulldeps/stable-mir/check_intrinsics.rs   | 137 -----------
 tests/ui-fulldeps/stable-mir/check_item_kind.rs    |  79 -------
 .../ui-fulldeps/stable-mir/check_normalization.rs  |  93 --------
 .../ui-fulldeps/stable-mir/check_trait_queries.rs  | 121 ----------
 tests/ui-fulldeps/stable-mir/check_transform.rs    | 145 ------------
 tests/ui-fulldeps/stable-mir/check_ty_fold.rs      | 113 ---------
 tests/ui-fulldeps/stable-mir/check_variant.rs      | 183 ---------------
 .../ui-fulldeps/stable-mir/closure-generic-body.rs |  90 -------
 tests/ui-fulldeps/stable-mir/closure_body.rs       |  90 -------
 tests/ui-fulldeps/stable-mir/compilation-result.rs |  86 -------
 tests/ui-fulldeps/stable-mir/crate-info.rs         | 259 ---------------------
 tests/ui-fulldeps/stable-mir/projections.rs        | 174 --------------
 tests/ui-fulldeps/stable-mir/smir_internal.rs      |  61 -----
 tests/ui-fulldeps/stable-mir/smir_serde.rs         |  68 ------
 tests/ui-fulldeps/stable-mir/smir_visitor.rs       | 223 ------------------
 52 files changed, 3535 insertions(+), 3535 deletions(-)
 create mode 100644 tests/ui-fulldeps/rustc_public/check_abi.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_allocation.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_assoc_items.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_attribute.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_binop.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_coroutine_body.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_crate_defs.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_def_ty.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_defs.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_foreign.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_instance.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_intrinsics.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_item_kind.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_normalization.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_trait_queries.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_transform.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_ty_fold.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/check_variant.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/closure-generic-body.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/closure_body.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/compilation-result.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/crate-info.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/projections.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/smir_internal.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/smir_serde.rs
 create mode 100644 tests/ui-fulldeps/rustc_public/smir_visitor.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_abi.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_allocation.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_assoc_items.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_attribute.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_binop.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_coroutine_body.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_crate_defs.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_def_ty.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_defs.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_foreign.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_instance.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_intrinsics.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_item_kind.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_normalization.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_trait_queries.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_transform.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_ty_fold.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/check_variant.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/closure-generic-body.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/closure_body.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/compilation-result.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/crate-info.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/projections.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/smir_internal.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/smir_serde.rs
 delete mode 100644 tests/ui-fulldeps/stable-mir/smir_visitor.rs

diff --git a/tests/ui-fulldeps/rustc_public/check_abi.rs b/tests/ui-fulldeps/rustc_public/check_abi.rs
new file mode 100644
index 00000000000..fc2227d147d
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_abi.rs
@@ -0,0 +1,225 @@
+//@ run-pass
+//! Test information regarding type layout.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+#![feature(ascii_char, ascii_char_variants)]
+
+extern crate rustc_hir;
+extern crate rustc_middle;
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_public::abi::{
+    ArgAbi, CallConvention, FieldsShape, IntegerLength, PassMode, Primitive, Scalar, ValueAbi,
+    VariantsShape,
+};
+use rustc_public::mir::MirVisitor;
+use rustc_public::mir::mono::Instance;
+use rustc_public::target::MachineInfo;
+use rustc_public::ty::{AdtDef, RigidTy, Ty, TyKind};
+use rustc_public::{CrateDef, CrateItem, CrateItems, ItemKind};
+use std::assert_matches::assert_matches;
+use std::collections::HashSet;
+use std::convert::TryFrom;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_stable_mir() -> ControlFlow<()> {
+    // Find items in the local crate.
+    let items = rustc_public::all_local_items();
+
+    // Test fn_abi
+    let target_fn = *get_item(&items, (ItemKind::Fn, "fn_abi")).unwrap();
+    let instance = Instance::try_from(target_fn).unwrap();
+    let fn_abi = instance.fn_abi().unwrap();
+    assert_eq!(fn_abi.conv, CallConvention::Rust);
+    assert_eq!(fn_abi.args.len(), 3);
+
+    check_ignore(&fn_abi.args[0]);
+    check_primitive(&fn_abi.args[1]);
+    check_niche(&fn_abi.args[2]);
+    check_result(&fn_abi.ret);
+
+    // Test variadic function.
+    let variadic_fn = *get_item(&items, (ItemKind::Fn, "variadic_fn")).unwrap();
+    check_variadic(variadic_fn);
+
+    // Extract function pointers.
+    let fn_ptr_holder = *get_item(&items, (ItemKind::Fn, "fn_ptr_holder")).unwrap();
+    let fn_ptr_holder_instance = Instance::try_from(fn_ptr_holder).unwrap();
+    let body = fn_ptr_holder_instance.body().unwrap();
+    let args = body.arg_locals();
+
+    // Test fn_abi of function pointer version.
+    let ptr_fn_abi = args[0].ty.kind().fn_sig().unwrap().fn_ptr_abi().unwrap();
+    assert_eq!(ptr_fn_abi, fn_abi);
+
+    // Test variadic_fn of function pointer version.
+    let ptr_variadic_fn_abi = args[1].ty.kind().fn_sig().unwrap().fn_ptr_abi().unwrap();
+    assert!(ptr_variadic_fn_abi.c_variadic);
+    assert_eq!(ptr_variadic_fn_abi.args.len(), 1);
+
+    let entry = rustc_public::entry_fn().unwrap();
+    let main_fn = Instance::try_from(entry).unwrap();
+    let mut visitor = AdtDefVisitor::default();
+    visitor.visit_body(&main_fn.body().unwrap());
+    let AdtDefVisitor { adt_defs } = visitor;
+    assert_eq!(adt_defs.len(), 1);
+
+    // Test ADT representation options
+    let repr_c_struct = adt_defs.iter().find(|def| def.trimmed_name() == "ReprCStruct").unwrap();
+    assert!(repr_c_struct.repr().flags.is_c);
+
+    ControlFlow::Continue(())
+}
+
+/// Check the variadic function ABI:
+/// ```no_run
+/// pub unsafe extern "C" fn variadic_fn(n: usize, mut args: ...) -> usize {
+///     0
+/// }
+/// ```
+fn check_variadic(variadic_fn: CrateItem) {
+    let instance = Instance::try_from(variadic_fn).unwrap();
+    let abi = instance.fn_abi().unwrap();
+    assert!(abi.c_variadic);
+    assert_eq!(abi.args.len(), 1);
+}
+
+/// Check the argument to be ignored: `ignore: [u8; 0]`.
+fn check_ignore(abi: &ArgAbi) {
+    assert!(abi.ty.kind().is_array());
+    assert_eq!(abi.mode, PassMode::Ignore);
+    let layout = abi.layout.shape();
+    assert!(layout.is_sized());
+    assert!(layout.is_1zst());
+}
+
+/// Check the primitive argument: `primitive: char`.
+fn check_primitive(abi: &ArgAbi) {
+    assert!(abi.ty.kind().is_char());
+    assert_matches!(abi.mode, PassMode::Direct(_));
+    let layout = abi.layout.shape();
+    assert!(layout.is_sized());
+    assert!(!layout.is_1zst());
+    assert_matches!(layout.fields, FieldsShape::Primitive);
+}
+
+/// Check the return value: `Result<usize, &str>`.
+fn check_result(abi: &ArgAbi) {
+    assert!(abi.ty.kind().is_enum());
+    assert_matches!(abi.mode, PassMode::Indirect { .. });
+    let layout = abi.layout.shape();
+    assert!(layout.is_sized());
+    assert_matches!(layout.fields, FieldsShape::Arbitrary { .. });
+    assert_matches!(layout.variants, VariantsShape::Multiple { .. })
+}
+
+/// Checks the niche information about `NonZero<u8>`.
+fn check_niche(abi: &ArgAbi) {
+    assert!(abi.ty.kind().is_struct());
+    assert_matches!(abi.mode, PassMode::Direct { .. });
+    let layout = abi.layout.shape();
+    assert!(layout.is_sized());
+    assert_eq!(layout.size.bytes(), 1);
+
+    let ValueAbi::Scalar(scalar) = layout.abi else { unreachable!() };
+    assert!(scalar.has_niche(&MachineInfo::target()), "Opps: {:?}", scalar);
+
+    let Scalar::Initialized { value, valid_range } = scalar else { unreachable!() };
+    assert_matches!(value, Primitive::Int { length: IntegerLength::I8, signed: false });
+    assert_eq!(valid_range.start, 1);
+    assert_eq!(valid_range.end, u8::MAX.into());
+    assert!(!valid_range.contains(0));
+    assert!(!valid_range.wraps_around());
+}
+
+fn get_item<'a>(
+    items: &'a CrateItems,
+    item: (ItemKind, &str),
+) -> Option<&'a rustc_public::CrateItem> {
+    items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1)
+}
+
+#[derive(Default)]
+struct AdtDefVisitor {
+    adt_defs: HashSet<AdtDef>,
+}
+
+impl MirVisitor for AdtDefVisitor {
+    fn visit_ty(&mut self, ty: &Ty, _location: rustc_public::mir::visit::Location) {
+        if let TyKind::RigidTy(RigidTy::Adt(adt, _)) = ty.kind() {
+            self.adt_defs.insert(adt);
+        }
+        self.super_ty(ty)
+    }
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "alloc_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_stable_mir).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        #![feature(c_variadic)]
+        #![allow(unused_variables)]
+
+        use std::num::NonZero;
+
+        pub fn fn_abi(
+            ignore: [u8; 0],
+            primitive: char,
+            niche: NonZero<u8>,
+        ) -> Result<usize, &'static str> {{
+                // We only care about the signature.
+                todo!()
+        }}
+
+        pub unsafe extern "C" fn variadic_fn(n: usize, mut args: ...) -> usize {{
+            0
+        }}
+
+        pub type ComplexFn = fn([u8; 0], char, NonZero<u8>) -> Result<usize, &'static str>;
+        pub type VariadicFn = unsafe extern "C" fn(usize, ...) -> usize;
+
+        pub fn fn_ptr_holder(complex_fn: ComplexFn, variadic_fn: VariadicFn) {{
+            // We only care about the signature.
+            todo!()
+        }}
+
+        fn main() {{
+            #[repr(C)]
+            struct ReprCStruct;
+
+            let _s = ReprCStruct;
+        }}
+        "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_allocation.rs b/tests/ui-fulldeps/rustc_public/check_allocation.rs
new file mode 100644
index 00000000000..83845a9aa42
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_allocation.rs
@@ -0,0 +1,257 @@
+//@ run-pass
+//! Test that users are able to use stable mir APIs to retrieve information of global allocations
+//! such as `vtable_allocation`.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+#![feature(ascii_char, ascii_char_variants)]
+
+extern crate rustc_hir;
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use std::ascii::Char;
+use std::assert_matches::assert_matches;
+use std::cmp::{max, min};
+use std::collections::HashMap;
+use std::ffi::CStr;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+use rustc_public::crate_def::CrateDef;
+use rustc_public::mir::Body;
+use rustc_public::mir::alloc::GlobalAlloc;
+use rustc_public::mir::mono::{Instance, StaticDef};
+use rustc_public::ty::{Allocation, ConstantKind};
+use rustc_public::{CrateItem, CrateItems, ItemKind};
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_stable_mir() -> ControlFlow<()> {
+    // Find items in the local crate.
+    let items = rustc_public::all_local_items();
+    check_foo(*get_item(&items, (ItemKind::Static, "FOO")).unwrap());
+    check_bar(*get_item(&items, (ItemKind::Static, "BAR")).unwrap());
+    check_len(*get_item(&items, (ItemKind::Static, "LEN")).unwrap());
+    check_cstr(*get_item(&items, (ItemKind::Static, "C_STR")).unwrap());
+    check_other_consts(*get_item(&items, (ItemKind::Fn, "other_consts")).unwrap());
+    ControlFlow::Continue(())
+}
+
+/// Check the allocation data for static `FOO`.
+///
+/// ```no_run
+/// static FOO: [&str; 2] = ["hi", "there"];
+/// ```
+fn check_foo(item: CrateItem) {
+    let def = StaticDef::try_from(item).unwrap();
+    let alloc = def.eval_initializer().unwrap();
+    assert_eq!(alloc.provenance.ptrs.len(), 2);
+
+    let alloc_id_0 = alloc.provenance.ptrs[0].1.0;
+    assert_matches!(GlobalAlloc::from(alloc_id_0), GlobalAlloc::Memory(..));
+
+    let alloc_id_1 = alloc.provenance.ptrs[1].1.0;
+    assert_matches!(GlobalAlloc::from(alloc_id_1), GlobalAlloc::Memory(..));
+}
+
+/// Check the allocation data for static `BAR`.
+///
+/// ```no_run
+/// static BAR: &str = "Bar";
+/// ```
+fn check_bar(item: CrateItem) {
+    let def = StaticDef::try_from(item).unwrap();
+    let alloc = def.eval_initializer().unwrap();
+    assert_eq!(alloc.provenance.ptrs.len(), 1);
+
+    let alloc_id_0 = alloc.provenance.ptrs[0].1.0;
+    let GlobalAlloc::Memory(allocation) = GlobalAlloc::from(alloc_id_0) else { unreachable!() };
+    assert_eq!(allocation.bytes.len(), 3);
+    assert_eq!(allocation.bytes[0].unwrap(), Char::CapitalB.to_u8());
+    assert_eq!(allocation.bytes[1].unwrap(), Char::SmallA.to_u8());
+    assert_eq!(allocation.bytes[2].unwrap(), Char::SmallR.to_u8());
+    assert_eq!(std::str::from_utf8(&allocation.raw_bytes().unwrap()), Ok("Bar"));
+}
+
+/// Check the allocation data for static `C_STR`.
+///
+/// ```no_run
+/// static C_STR: &core::ffi::cstr = c"cstr";
+/// ```
+fn check_cstr(item: CrateItem) {
+    let def = StaticDef::try_from(item).unwrap();
+    let alloc = def.eval_initializer().unwrap();
+    assert_eq!(alloc.provenance.ptrs.len(), 1);
+    let deref = item.ty().kind().builtin_deref(true).unwrap();
+    assert!(deref.ty.kind().is_cstr(), "Expected CStr, but got: {:?}", item.ty());
+
+    let alloc_id_0 = alloc.provenance.ptrs[0].1.0;
+    let GlobalAlloc::Memory(allocation) = GlobalAlloc::from(alloc_id_0) else { unreachable!() };
+    assert_eq!(allocation.bytes.len(), 5);
+    assert_eq!(CStr::from_bytes_until_nul(&allocation.raw_bytes().unwrap()), Ok(c"cstr"));
+}
+
+/// Check the allocation data for constants used in `other_consts` function.
+fn check_other_consts(item: CrateItem) {
+    // Instance body will force constant evaluation.
+    let body = Instance::try_from(item).unwrap().body().unwrap();
+    let assigns = collect_consts(&body);
+    assert_eq!(assigns.len(), 10);
+    let mut char_id = None;
+    let mut bool_id = None;
+    for (name, alloc) in assigns {
+        match name.as_str() {
+            "_max_u128" => {
+                assert_eq!(alloc.read_uint(), Ok(u128::MAX), "Failed parsing allocation: {alloc:?}")
+            }
+            "_min_i128" => {
+                assert_eq!(alloc.read_int(), Ok(i128::MIN), "Failed parsing allocation: {alloc:?}")
+            }
+            "_max_i8" => {
+                assert_eq!(
+                    alloc.read_int().unwrap() as i8,
+                    i8::MAX,
+                    "Failed parsing allocation: {alloc:?}"
+                )
+            }
+            "_char" => {
+                assert_eq!(
+                    char::from_u32(alloc.read_uint().unwrap() as u32),
+                    Some('x'),
+                    "Failed parsing allocation: {alloc:?}"
+                )
+            }
+            "_false" => {
+                assert_eq!(alloc.read_bool(), Ok(false), "Failed parsing allocation: {alloc:?}")
+            }
+            "_true" => {
+                assert_eq!(alloc.read_bool(), Ok(true), "Failed parsing allocation: {alloc:?}")
+            }
+            "_ptr" => {
+                assert_eq!(alloc.is_null(), Ok(false), "Failed parsing allocation: {alloc:?}")
+            }
+            "_null_ptr" => {
+                assert_eq!(alloc.is_null(), Ok(true), "Failed parsing allocation: {alloc:?}")
+            }
+            "_tuple" => {
+                // The order of fields is not guaranteed.
+                let first = alloc.read_partial_uint(0..4).unwrap();
+                let second = alloc.read_partial_uint(4..8).unwrap();
+                assert_eq!(max(first, second) as u32, u32::MAX);
+                assert_eq!(min(first, second), 10);
+            }
+            "_bool_id" => {
+                bool_id = Some(alloc);
+            }
+            "_char_id" => {
+                char_id = Some(alloc);
+            }
+            _ => {
+                unreachable!("{name} -- {alloc:?}")
+            }
+        }
+    }
+    let bool_id = bool_id.unwrap();
+    let char_id = char_id.unwrap();
+    // FIXME(rustc_public): add `read_ptr` to `Allocation`
+    assert_ne!(bool_id, char_id);
+}
+
+/// Collects all the constant assignments.
+pub fn collect_consts(body: &Body) -> HashMap<String, &Allocation> {
+    body.var_debug_info
+        .iter()
+        .filter_map(|info| {
+            info.constant().map(|const_op| {
+                let ConstantKind::Allocated(alloc) = const_op.const_.kind() else { unreachable!() };
+                (info.name.clone(), alloc)
+            })
+        })
+        .collect::<HashMap<_, _>>()
+}
+
+/// Check the allocation data for `LEN`.
+///
+/// ```no_run
+/// static LEN: usize = 2;
+/// ```
+fn check_len(item: CrateItem) {
+    let def = StaticDef::try_from(item).unwrap();
+    let alloc = def.eval_initializer().unwrap();
+    assert!(alloc.provenance.ptrs.is_empty());
+    assert_eq!(alloc.read_uint(), Ok(2));
+}
+
+fn get_item<'a>(
+    items: &'a CrateItems,
+    item: (ItemKind, &str),
+) -> Option<&'a rustc_public::CrateItem> {
+    items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1)
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "alloc_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "--edition=2021".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_stable_mir).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+    #![feature(core_intrinsics)]
+    #![expect(internal_features)]
+    use std::intrinsics::type_id;
+
+    static LEN: usize = 2;
+    static FOO: [&str; 2] = ["hi", "there"];
+    static BAR: &str = "Bar";
+    static C_STR: &std::ffi::CStr = c"cstr";
+    const NULL: *const u8 = std::ptr::null();
+    const TUPLE: (u32, u32) = (10, u32::MAX);
+
+    fn other_consts() {{
+        let _max_u128 = u128::MAX;
+        let _min_i128 = i128::MIN;
+        let _max_i8 = i8::MAX;
+        let _char = 'x';
+        let _false = false;
+        let _true = true;
+        let _ptr = &BAR;
+        let _null_ptr: *const u8 = NULL;
+        let _tuple = TUPLE;
+        let _char_id = const {{ type_id::<char>() }};
+        let _bool_id = const {{ type_id::<bool>() }};
+    }}
+
+    pub fn main() {{
+        println!("{{FOO:?}}! {{BAR}}");
+        assert_eq!(FOO.len(), LEN);
+        other_consts();
+    }}"#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_assoc_items.rs b/tests/ui-fulldeps/rustc_public/check_assoc_items.rs
new file mode 100644
index 00000000000..1557991f8ca
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_assoc_items.rs
@@ -0,0 +1,143 @@
+//@ run-pass
+//! Test that users are able to retrieve all associated items from a definition.
+//! definition.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate rustc_public;
+
+use std::collections::HashSet;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+use rustc_public::ty::*;
+use rustc_public::{CrateDef, *};
+
+const CRATE_NAME: &str = "crate_assoc_items";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_assoc_items() -> ControlFlow<()> {
+    let local_crate = rustc_public::local_crate();
+    check_items(
+        &local_crate.fn_defs(),
+        &[
+            "AStruct::new",
+            "<AStruct as ATrait>::assoc_fn_no_self",
+            "<AStruct as ATrait>::assoc_fn_has_self",
+            "ATrait::rpitit",
+            "ATrait::assoc_fn_has_self",
+            "ATrait::assoc_fn_no_self",
+            "<AStruct as ATrait>::rpitit",
+        ],
+    );
+
+    let local_impls = local_crate.trait_impls();
+    let local_traits = local_crate.trait_decls();
+
+    let trait_assoc_item_defs: Vec<AssocDef> =
+        local_traits[0].associated_items().iter().map(|assoc_item| assoc_item.def_id).collect();
+    check_items(
+        &trait_assoc_item_defs,
+        &[
+            "ATrait::rpitit::{anon_assoc#0}",
+            "ATrait::rpitit",
+            "ATrait::Assoc",
+            "ATrait::assoc_fn_no_self",
+            "ATrait::assoc_fn_has_self",
+        ],
+    );
+
+    let impl_assoc_item_defs: Vec<AssocDef> =
+        local_impls[0].associated_items().iter().map(|assoc_item| assoc_item.def_id).collect();
+    check_items(
+        &impl_assoc_item_defs,
+        &[
+            "<AStruct as ATrait>::rpitit::{anon_assoc#0}",
+            "<AStruct as ATrait>::rpitit",
+            "<AStruct as ATrait>::Assoc",
+            "<AStruct as ATrait>::assoc_fn_no_self",
+            "<AStruct as ATrait>::assoc_fn_has_self",
+        ],
+    );
+
+    ControlFlow::Continue(())
+}
+
+/// Check if the list of definitions matches the expected list.
+/// Note that order doesn't matter.
+fn check_items<T: CrateDef>(items: &[T], expected: &[&str]) {
+    let expected: HashSet<_> = expected.iter().map(|s| s.to_string()).collect();
+    let item_names: HashSet<_> = items.iter().map(|item| item.name()).collect();
+    assert_eq!(item_names, expected);
+}
+
+fn main() {
+    let path = "assoc_items.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_assoc_items).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        #![allow(dead_code, unused_variables)]
+        struct AStruct;
+
+        impl AStruct {{
+            const ASSOC_CONST: &str = "Nina";
+
+            fn new() -> Self {{
+                AStruct{{}}
+            }}
+        }}
+
+        trait ATrait {{
+            type Assoc;
+
+            fn assoc_fn_no_self() {{
+            }}
+
+            fn assoc_fn_has_self(&self) {{
+            }}
+
+            fn rpitit(&self) -> impl std::fmt::Debug {{
+                "ciallo"
+            }}
+        }}
+
+        impl ATrait for AStruct {{
+            type Assoc = u32;
+
+            fn assoc_fn_no_self() {{
+            }}
+
+            fn assoc_fn_has_self(&self) {{
+            }}
+
+            fn rpitit(&self) -> impl std::fmt::Debug {{
+                "ciallo~"
+            }}
+        }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_attribute.rs b/tests/ui-fulldeps/rustc_public/check_attribute.rs
new file mode 100644
index 00000000000..d8807872ec4
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_attribute.rs
@@ -0,0 +1,113 @@
+//@ run-pass
+//! Test information regarding type layout.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+
+#![feature(rustc_private)]
+
+extern crate rustc_hir;
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_public::{CrateDef, CrateItems};
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_stable_mir() -> ControlFlow<()> {
+    // Find items in the local crate.
+    let items = rustc_public::all_local_items();
+
+    test_tool(&items);
+
+    ControlFlow::Continue(())
+}
+
+// Test tool attributes.
+fn test_tool(items: &CrateItems) {
+    let rustfmt_fn = *get_item(&items, "do_not_format").unwrap();
+    let rustfmt_attrs = rustfmt_fn.tool_attrs(&["rustfmt".to_string(), "skip".to_string()]);
+    assert_eq!(rustfmt_attrs[0].as_str(), "#[rustfmt::skip]\n");
+
+    let clippy_fn = *get_item(&items, "complex_fn").unwrap();
+    let clippy_attrs = clippy_fn.tool_attrs(&["clippy".to_string(),
+                                               "cyclomatic_complexity".to_string()]);
+    assert_eq!(clippy_attrs[0].as_str(), "#[clippy::cyclomatic_complexity = \"100\"]\n");
+}
+
+fn get_item<'a>(
+    items: &'a CrateItems,
+    name: &str,
+) -> Option<&'a rustc_public::CrateItem> {
+    items.iter().find(|crate_item| crate_item.name() == name)
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "attribute_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_stable_mir).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        // General metadata applied to the enclosing module or crate.
+        #![crate_type = "lib"]
+
+        // Mixed inner and outer attributes.
+        #[inline]
+        #[deprecated(since = "5.2.0")]
+        fn builtins_fn() {{
+            #![allow(unused_variables)]
+
+            let x = ();
+            let y = ();
+            let z = ();
+        }}
+
+        // A derive attribute to automatically implement a trait.
+        #[derive(Debug, Clone, Copy)]
+        struct Foo(u32);
+
+        // A rustfmt tool attribute.
+        #[rustfmt::skip]
+        fn do_not_format() {{}}
+
+        // A clippy tool attribute.
+        #[clippy::cyclomatic_complexity = "100"]
+        pub fn complex_fn() {{}}
+
+        // A function with many attributes.
+        #[inline]
+        #[allow(unused_variables)]
+        #[allow(dead_code)]
+        #[allow(unused_imports)]
+        fn many_attrs() {{
+            #![allow(clippy::filter_map)]
+            todo!()
+        }}
+        "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_binop.rs b/tests/ui-fulldeps/rustc_public/check_binop.rs
new file mode 100644
index 00000000000..aa089a5d125
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_binop.rs
@@ -0,0 +1,146 @@
+//@ run-pass
+//! Test information regarding binary operations.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+
+#![feature(rustc_private)]
+
+extern crate rustc_hir;
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_public::mir::mono::Instance;
+use rustc_public::mir::visit::{Location, MirVisitor};
+use rustc_public::mir::{LocalDecl, Rvalue, Statement, StatementKind, Terminator, TerminatorKind};
+use rustc_public::ty::{RigidTy, TyKind};
+use std::collections::HashSet;
+use std::convert::TryFrom;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+/// This function tests that we can correctly get type information from binary operations.
+fn test_binops() -> ControlFlow<()> {
+    // Find items in the local crate.
+    let items = rustc_public::all_local_items();
+    let mut instances =
+        items.into_iter().map(|item| Instance::try_from(item).unwrap()).collect::<Vec<_>>();
+    while let Some(instance) = instances.pop() {
+        // The test below shouldn't have recursion in it.
+        let Some(body) = instance.body() else {
+            continue;
+        };
+        let mut visitor = Visitor { locals: body.locals(), calls: Default::default() };
+        visitor.visit_body(&body);
+        instances.extend(visitor.calls.into_iter());
+    }
+    ControlFlow::Continue(())
+}
+
+struct Visitor<'a> {
+    locals: &'a [LocalDecl],
+    calls: HashSet<Instance>,
+}
+
+impl<'a> MirVisitor for Visitor<'a> {
+    fn visit_statement(&mut self, stmt: &Statement, _loc: Location) {
+        match &stmt.kind {
+            StatementKind::Assign(place, Rvalue::BinaryOp(op, rhs, lhs)) => {
+                let ret_ty = place.ty(self.locals).unwrap();
+                let op_ty = op.ty(rhs.ty(self.locals).unwrap(), lhs.ty(self.locals).unwrap());
+                assert_eq!(ret_ty, op_ty, "Operation type should match the assigned place type");
+            }
+            _ => {}
+        }
+    }
+
+    fn visit_terminator(&mut self, term: &Terminator, _loc: Location) {
+        match &term.kind {
+            TerminatorKind::Call { func, .. } => {
+                let TyKind::RigidTy(RigidTy::FnDef(def, args)) =
+                    func.ty(self.locals).unwrap().kind()
+                    else {
+                        return;
+                    };
+                self.calls.insert(Instance::resolve(def, &args).unwrap());
+            }
+            _ => {}
+        }
+    }
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "binop_input.rs";
+    generate_input(&path).unwrap();
+    let args = &["rustc".to_string(), "--crate-type=lib".to_string(), path.to_string()];
+    run!(args, test_binops).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        macro_rules! binop_int {{
+            ($fn:ident, $typ:ty) => {{
+                pub fn $fn(lhs: $typ, rhs: $typ) {{
+                    let eq = lhs == rhs;
+                    let lt = lhs < rhs;
+                    let le = lhs <= rhs;
+
+                    let sum = lhs + rhs;
+                    let mult = lhs * sum;
+                    let shift = mult << 2;
+                    let bit_or = shift | rhs;
+                    let cmp = lhs.cmp(&bit_or);
+
+                    // Try to avoid the results above being pruned
+                    std::hint::black_box(((eq, lt, le), cmp));
+                }}
+            }}
+        }}
+
+        binop_int!(binop_u8, u8);
+        binop_int!(binop_i64, i64);
+
+        pub fn binop_bool(lhs: bool, rhs: bool) {{
+            let eq = lhs == rhs;
+            let or = lhs | eq;
+            let lt = lhs < or;
+            let cmp = lhs.cmp(&rhs);
+
+            // Try to avoid the results above being pruned
+            std::hint::black_box((lt, cmp));
+        }}
+
+        pub fn binop_char(lhs: char, rhs: char) {{
+            let eq = lhs == rhs;
+            let lt = lhs < rhs;
+            let cmp = lhs.cmp(&rhs);
+
+            // Try to avoid the results above being pruned
+            std::hint::black_box(([eq, lt], cmp));
+        }}
+
+        pub fn binop_ptr(lhs: *const char, rhs: *const char) {{
+            let eq = lhs == rhs;
+            let lt = lhs < rhs;
+            let cmp = lhs.cmp(&rhs);
+            let off = unsafe {{ lhs.offset(2) }};
+
+            // Try to avoid the results above being pruned
+            std::hint::black_box(([eq, lt], cmp, off));
+        }}
+        "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_coroutine_body.rs b/tests/ui-fulldeps/rustc_public/check_coroutine_body.rs
new file mode 100644
index 00000000000..725b538b0fe
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_coroutine_body.rs
@@ -0,0 +1,105 @@
+//@ run-pass
+//! Tests stable mir API for retrieving the body of a coroutine.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2024
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use std::io::Write;
+use std::ops::ControlFlow;
+
+use rustc_public::mir::Body;
+use rustc_public::ty::{RigidTy, TyKind};
+
+const CRATE_NAME: &str = "crate_coroutine_body";
+
+fn test_coroutine_body() -> ControlFlow<()> {
+    let crate_items = rustc_public::all_local_items();
+    if let Some(body) = crate_items.iter().find_map(|item| {
+        let item_ty = item.ty();
+        if let TyKind::RigidTy(RigidTy::Coroutine(def, ..)) = &item_ty.kind() {
+            if def.0.name() == "gbc::{closure#0}".to_string() {
+                def.body()
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }) {
+        check_coroutine_body(body);
+    } else {
+        panic!("Cannot find `gbc::{{closure#0}}`. All local items are: {:#?}", crate_items);
+    }
+
+    ControlFlow::Continue(())
+}
+
+fn check_coroutine_body(body: Body) {
+    let ret_ty = &body.locals()[0].ty;
+    let local_3 = &body.locals()[3].ty;
+    let local_4 = &body.locals()[4].ty;
+
+    let TyKind::RigidTy(RigidTy::Adt(def, ..)) = &ret_ty.kind()
+    else {
+        panic!("Expected RigidTy::Adt, got: {:#?}", ret_ty);
+    };
+
+    assert_eq!("std::task::Poll", def.0.name());
+
+    let TyKind::RigidTy(RigidTy::Coroutine(def, ..)) = &local_3.kind()
+    else {
+        panic!("Expected RigidTy::Coroutine, got: {:#?}", local_3);
+    };
+
+    assert_eq!("gbc::{closure#0}::{closure#0}", def.0.name());
+
+    let TyKind::RigidTy(RigidTy::Coroutine(def, ..)) = &local_4.kind()
+    else {
+        panic!("Expected RigidTy::Coroutine, got: {:#?}", local_4);
+    };
+
+    assert_eq!("gbc::{closure#0}::{closure#0}", def.0.name());
+}
+
+fn main() {
+    let path = "coroutine_body.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--edition".to_string(),
+        "2024".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_coroutine_body).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        async fn gbc() -> i32 {{
+            let a = async {{ 1 }}.await;
+            a
+        }}
+
+        fn main() {{}}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_crate_defs.rs b/tests/ui-fulldeps/rustc_public/check_crate_defs.rs
new file mode 100644
index 00000000000..27d5b0bc238
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_crate_defs.rs
@@ -0,0 +1,148 @@
+//@ run-pass
+//! Test information about crate definitions (local and external).
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_hir;
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_public::CrateDef;
+use std::collections::HashSet;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "crate_defs";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_stable_mir() -> ControlFlow<()> {
+    // Find items in the local crate.
+    let local = rustc_public::local_crate();
+    check_items(&local.statics(), &["PRIVATE_STATIC", "dummy::PUBLIC_STATIC"]);
+    check_items(
+        &local.fn_defs(),
+        &[
+            "top_level",
+            "dummy::public_fn",
+            "dummy::private_fn",
+            "dummy::PrivateStruct::new",
+            "<dummy::PrivateStruct as std::ops::Drop>::drop",
+            "DummyTrait::method",
+            "<T as DummyTrait>::method",
+        ],
+    );
+
+    // Find items inside core crate.
+    // FIXME: We are currently missing primitive type methods and trait implementations for external
+    // crates.
+    let core = rustc_public::find_crates("core").pop().expect("Cannot find `core` crate");
+    contains(
+        &core.fn_defs(),
+        &[
+            "std::fmt::Debug::fmt",
+            "std::option::Option::<T>::is_some",
+            "std::ptr::swap",
+            "<std::slice::Iter<'a, T> as std::iter::Iterator>::next",
+            "core::num::<impl u8>::abs_diff",
+        ],
+    );
+    // Ensure nothing crashes. There is no public static in core that we can test here.
+    let _ = core.statics();
+
+    ControlFlow::Continue(())
+}
+
+/// Check if the list of definitions matches the expected list.
+/// Note that order doesn't matter.
+fn check_items<T: CrateDef>(items: &[T], expected: &[&str]) {
+    let expected: HashSet<_> = expected.iter().map(|s| s.to_string()).collect();
+    let item_names: HashSet<_> = items.iter().map(|item| item.name()).collect();
+    assert_eq!(item_names, expected);
+}
+
+/// Check that the list contains the expected items.
+fn contains<T: CrateDef + std::fmt::Debug>(items: &[T], expected: &[&str]) {
+    let expected: HashSet<_> = expected.iter().map(|s| s.to_string()).collect();
+    let item_names = items.iter().map(|item| item.name()).collect();
+    let not_found: Vec<_> = expected.difference(&item_names).collect();
+    assert!(not_found.is_empty(), "Missing items: {:?}", not_found);
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "crate_definitions.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_stable_mir).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        #![allow(dead_code, unused_variables)]
+        static PRIVATE_STATIC: u8 = 0;
+        fn top_level() -> &'static str {{
+            "hello"
+        }}
+
+        pub trait DummyTrait {{
+            fn method(&self) -> Self;
+        }}
+
+        impl<T: Copy> DummyTrait for T {{
+            fn method(&self) -> T {{
+                *self
+            }}
+        }}
+
+        pub mod dummy {{
+            pub static mut PUBLIC_STATIC: Option<char> = None;
+
+            pub fn public_fn(input: bool) -> bool {{
+                private_fn(!input)
+            }}
+
+            fn private_fn(input: bool) -> bool {{
+                todo!()
+            }}
+
+            struct PrivateStruct {{
+                field: u32,
+            }}
+
+            impl PrivateStruct {{
+                fn new() -> Self {{
+                    Self {{ field: 42 }}
+                }}
+            }}
+
+            impl Drop for PrivateStruct {{
+                fn drop(&mut self) {{
+                    println!("Dropping PrivateStruct");
+                }}
+            }}
+        }}
+        "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_def_ty.rs b/tests/ui-fulldeps/rustc_public/check_def_ty.rs
new file mode 100644
index 00000000000..b5954352dc0
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_def_ty.rs
@@ -0,0 +1,111 @@
+//@ run-pass
+//! Test that users are able to use stable mir APIs to retrieve type information from a crate item
+//! definition.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate rustc_public;
+
+use rustc_public::ty::{Ty, ForeignItemKind};
+use rustc_public::*;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "crate_def_ty";
+
+/// Test if we can retrieve type information from different definitions.
+fn test_def_tys() -> ControlFlow<()> {
+    let items = rustc_public::all_local_items();
+    for item in &items {
+        // Type from crate items.
+        let ty = item.ty();
+        match item.name().as_str() {
+            "STATIC_STR" => assert!(ty.kind().is_ref()),
+            "CONST_U32" => assert!(ty.kind().is_integral()),
+            "main" => { check_fn_def(ty) }
+            _ => unreachable!("Unexpected item: `{item:?}`")
+        }
+    }
+
+    let foreign_items = rustc_public::local_crate().foreign_modules();
+    for item in foreign_items[0].module().items() {
+        // Type from foreign items.
+        let ty = item.ty();
+        let item_kind = item.kind();
+        let name = item.name();
+        match item_kind {
+            ForeignItemKind::Fn(fn_def) => {
+                assert_eq!(&name, "extern_fn");
+                assert_eq!(ty, fn_def.ty());
+                check_fn_def(ty)
+            }
+            ForeignItemKind::Static(def) => {
+                assert_eq!(&name, "EXT_STATIC");
+                assert_eq!(ty, def.ty());
+                assert!(ty.kind().is_integral())
+            }
+            _ => unreachable!("Unexpected kind: {item_kind:?}")
+        };
+    }
+
+    ControlFlow::Continue(())
+}
+
+fn check_fn_def(ty: Ty) {
+    let kind = ty.kind();
+    let (def, args) = kind.fn_def().expect(&format!("Expected function type, but found: {ty}"));
+    assert!(def.ty().kind().is_fn());
+    assert_eq!(def.ty_with_args(args), ty);
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "defs_ty_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_def_tys).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        // We would like to check intrinsic definition.
+        #![feature(core_intrinsics)]
+        static STATIC_STR: &str = "foo";
+        const CONST_U32: u32 = 0u32;
+
+        fn main() {{
+            let _c = core::char::from_u32(99);
+            let _v = Vec::<u8>::new();
+            let _i = std::intrinsics::size_of::<u8>();
+        }}
+
+        extern "C" {{
+            fn extern_fn(x: i32) -> i32;
+            static EXT_STATIC: i32;
+        }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_defs.rs b/tests/ui-fulldeps/rustc_public/check_defs.rs
new file mode 100644
index 00000000000..5e45f19cac8
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_defs.rs
@@ -0,0 +1,139 @@
+//@ run-pass
+//! Test that users are able to use stable mir APIs to retrieve information about crate definitions.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate rustc_public;
+
+use std::assert_matches::assert_matches;
+use mir::{mono::Instance, TerminatorKind::*};
+use rustc_public::mir::mono::InstanceKind;
+use rustc_public::ty::{RigidTy, TyKind, Ty, UintTy};
+use rustc_public::*;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_stable_mir() -> ControlFlow<()> {
+    let entry = rustc_public::entry_fn().unwrap();
+    let main_fn = Instance::try_from(entry).unwrap();
+    assert_eq!(main_fn.name(), "main");
+    assert_eq!(main_fn.trimmed_name(), "main");
+
+    let instances = get_instances(main_fn.body().unwrap());
+    assert_eq!(instances.len(), 3);
+    test_fn(instances[0], "from_u32", "std::char::from_u32", "core");
+    test_fn(instances[1], "Vec::<u8>::new", "std::vec::Vec::<u8>::new", "alloc");
+    test_fn(instances[2], "ctpop::<u8>", "std::intrinsics::ctpop::<u8>", "core");
+    test_vec_new(instances[1]);
+    ControlFlow::Continue(())
+}
+
+fn test_fn(instance: Instance, expected_trimmed: &str, expected_qualified: &str, krate: &str) {
+    let trimmed = instance.trimmed_name();
+    let qualified = instance.name();
+    assert_eq!(&trimmed, expected_trimmed);
+    assert_eq!(&qualified, expected_qualified);
+
+    if instance.kind == InstanceKind::Intrinsic {
+        let intrinsic = instance.intrinsic_name().unwrap();
+        let (trimmed_base, _trimmed_args) = trimmed.split_once("::").unwrap();
+        assert_eq!(intrinsic, trimmed_base);
+        return;
+    }
+    assert!(instance.intrinsic_name().is_none());
+
+    let item = CrateItem::try_from(instance).unwrap();
+    let trimmed = item.trimmed_name();
+    let qualified = item.name();
+    assert_eq!(trimmed, expected_trimmed.replace("u8", "T"));
+    assert_eq!(qualified, expected_qualified.replace("u8", "T"));
+    assert_eq!(&item.krate().name, krate);
+}
+
+fn extract_elem_ty(ty: Ty) -> Ty {
+    match ty.kind() {
+        TyKind::RigidTy(RigidTy::Adt(_, args)) => {
+            *args.0[0].expect_ty()
+        }
+        _ => unreachable!("Expected Vec ADT, but found: {ty:?}")
+    }
+}
+
+/// Check signature and type of `Vec::<u8>::new` and its generic version.
+fn test_vec_new(instance: mir::mono::Instance) {
+    let sig = instance.fn_abi().unwrap();
+    assert_eq!(&sig.args, &[]);
+    let elem_ty = extract_elem_ty(sig.ret.ty);
+    assert_matches!(elem_ty.kind(), TyKind::RigidTy(RigidTy::Uint(UintTy::U8)));
+
+    // Get the signature for Vec::<T>::new.
+    let item = CrateItem::try_from(instance).unwrap();
+    let ty = item.ty();
+    let gen_sig = ty.kind().fn_sig().unwrap().skip_binder();
+    let gen_ty = extract_elem_ty(gen_sig.output());
+    assert_matches!(gen_ty.kind(), TyKind::Param(_));
+}
+
+/// Inspect the instance body
+fn get_instances(body: mir::Body) -> Vec<Instance> {
+    body.blocks.iter().filter_map(|bb| {
+        match &bb.terminator.kind {
+            Call { func, .. } => {
+                let TyKind::RigidTy(ty) = func.ty(body.locals()).unwrap().kind() else { unreachable!
+                () };
+                let RigidTy::FnDef(def, args) = ty else { unreachable!() };
+                Instance::resolve(def, &args).ok()
+            }
+            _ => {
+                None
+            }
+        }
+    }).collect::<Vec<_>>()
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "defs_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_stable_mir).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        #![feature(core_intrinsics)]
+
+        fn main() {{
+            let _c = core::char::from_u32(99);
+            let _v = Vec::<u8>::new();
+            let _i = std::intrinsics::ctpop::<u8>(0);
+        }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_foreign.rs b/tests/ui-fulldeps/rustc_public/check_foreign.rs
new file mode 100644
index 00000000000..9aee067f41b
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_foreign.rs
@@ -0,0 +1,89 @@
+//@ run-pass
+//! Test retrieval and kinds of foreign items.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate rustc_span;
+extern crate rustc_public;
+
+use rustc_public::{
+    ty::{Abi, ForeignItemKind},
+    *,
+};
+use std::assert_matches::assert_matches;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_foreign() -> ControlFlow<()> {
+    let mods =
+        local_crate().foreign_modules().into_iter().map(|def| def.module()).collect::<Vec<_>>();
+    assert_eq!(mods.len(), 2);
+
+    let rust_mod = mods.iter().find(|m| matches!(m.abi, Abi::Rust)).unwrap();
+    assert_eq!(rust_mod.items().len(), 1);
+
+    let c_mod = mods.iter().find(|m| matches!(m.abi, Abi::C { .. })).unwrap();
+    let c_items = c_mod.items();
+    assert_eq!(c_items.len(), 3);
+    for item in c_items {
+        let kind = item.kind();
+        match item.name().as_str() {
+            "foo" => assert_matches!(kind, ForeignItemKind::Fn(..)),
+            "bar" => assert_matches!(kind, ForeignItemKind::Static(..)),
+            "Baz" => assert_matches!(kind, ForeignItemKind::Type(..)),
+            name => unreachable!("Unexpected item {name}"),
+        };
+    }
+    ControlFlow::Continue(())
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "foreign_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-type=lib".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, || test_foreign()).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        #![feature(extern_types)]
+        #![allow(unused)]
+        extern "Rust" {{
+            fn rust_foo(x: i32) -> i32;
+        }}
+        extern "C" {{
+            fn foo(x: i32) -> i32;
+            static bar: i32;
+            type Baz;
+        }}
+        "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_instance.rs b/tests/ui-fulldeps/rustc_public/check_instance.rs
new file mode 100644
index 00000000000..18971076043
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_instance.rs
@@ -0,0 +1,137 @@
+//@ run-pass
+//! Test that users are able to use stable mir APIs to retrieve monomorphized instances
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate rustc_public;
+
+use std::io::Write;
+use std::ops::ControlFlow;
+
+use mir::mono::Instance;
+use mir::TerminatorKind::*;
+use rustc_public::ty::{RigidTy, TyKind};
+use rustc_public::*;
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_stable_mir() -> ControlFlow<()> {
+    let items = rustc_public::all_local_items();
+
+    // Get all items and split generic vs monomorphic items.
+    let (generic, mono): (Vec<_>, Vec<_>) =
+        items.into_iter().partition(|item| item.requires_monomorphization());
+    assert_eq!(mono.len(), 3, "Expected 3 mono functions");
+    assert_eq!(generic.len(), 2, "Expected 2 generic functions");
+
+    // For all monomorphic items, get the correspondent instances.
+    let instances = mono
+        .iter()
+        .filter_map(|item| mir::mono::Instance::try_from(*item).ok())
+        .collect::<Vec<mir::mono::Instance>>();
+    assert_eq!(instances.len(), mono.len());
+
+    // For all generic items, try_from should fail.
+    assert!(generic.iter().all(|item| mir::mono::Instance::try_from(*item).is_err()));
+
+    for instance in instances {
+        test_body(instance.body().unwrap())
+    }
+    ControlFlow::Continue(())
+}
+
+/// Inspect the instance body
+fn test_body(body: mir::Body) {
+    for term in body.blocks.iter().map(|bb| &bb.terminator) {
+        match &term.kind {
+            Call { func, .. } => {
+                let TyKind::RigidTy(ty) = func.ty(body.locals()).unwrap().kind() else {
+                    unreachable!()
+                };
+                let RigidTy::FnDef(def, args) = ty else { unreachable!() };
+                let instance = Instance::resolve(def, &args).unwrap();
+                let mangled_name = instance.mangled_name();
+                assert!(instance.has_body() || (mangled_name == "setpwent"), "Failed: {func:?}");
+                assert!(instance.has_body() ^ instance.is_foreign_item());
+                if instance.has_body() {
+                    let body = instance.body().unwrap();
+                    assert!(!body.locals().is_empty(), "Body must at least have a return local");
+                }
+            }
+            Goto { .. } | Assert { .. } | SwitchInt { .. } | Return | Drop { .. } => {
+                /* Do nothing */
+            }
+            _ => {
+                unreachable!("Unexpected terminator {term:?}")
+            }
+        }
+    }
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "instance_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-type=lib".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_stable_mir).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+
+    struct Foo(());
+
+    pub fn ty_param<T>(t: &T) -> T where T: Clone {{
+        t.clone()
+    }}
+
+    pub fn const_param<const LEN: usize>(a: [bool; LEN]) -> bool {{
+        LEN > 0 && a[0]
+    }}
+
+    extern "C" {{
+        // Body should not be available.
+        fn setpwent();
+    }}
+
+    pub fn monomorphic() {{
+        Foo(());
+        let v = vec![10];
+        let dup = ty_param(&v);
+        assert_eq!(v, dup);
+        unsafe {{ setpwent() }};
+    }}
+
+    pub mod foo {{
+        pub fn bar_mono(i: i32) -> i64 {{
+            i as i64
+        }}
+    }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_intrinsics.rs b/tests/ui-fulldeps/rustc_public/check_intrinsics.rs
new file mode 100644
index 00000000000..854ac77956e
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_intrinsics.rs
@@ -0,0 +1,137 @@
+//@ run-pass
+//! Test information regarding intrinsics and ensure we can retrieve the fallback body if it exists.
+//!
+//! This tests relies on the intrinsics implementation, and requires one intrinsic with and one
+//! without a body. It doesn't matter which intrinsic is called here, and feel free to update that
+//! if needed.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+extern crate rustc_hir;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_public::mir::mono::{Instance, InstanceKind};
+use rustc_public::mir::visit::{Location, MirVisitor};
+use rustc_public::mir::{LocalDecl, Terminator, TerminatorKind};
+use rustc_public::ty::{FnDef, GenericArgs, RigidTy, TyKind};
+use std::assert_matches::assert_matches;
+use std::convert::TryFrom;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+/// This function tests that we can correctly get type information from binary operations.
+fn test_intrinsics() -> ControlFlow<()> {
+    // Find items in the local crate.
+    let main_def = rustc_public::all_local_items()[0];
+    let main_instance = Instance::try_from(main_def).unwrap();
+    let main_body = main_instance.body().unwrap();
+    let mut visitor = CallsVisitor { locals: main_body.locals(), calls: Default::default() };
+    visitor.visit_body(&main_body);
+
+    let calls = visitor.calls;
+    assert_eq!(calls.len(), 3, "Expected 3 calls, but found: {calls:?}");
+    for (fn_def, args) in calls.into_iter() {
+        check_instance(&Instance::resolve(fn_def, &args).unwrap());
+        check_def(fn_def);
+    }
+
+    ControlFlow::Continue(())
+}
+
+/// This check is unfortunately tight to the implementation of intrinsics.
+///
+/// We want to ensure that StableMIR can handle intrinsics with and without fallback body:
+/// for intrinsics without a body, obviously we cannot expose anything.
+///
+/// If by any chance this test breaks because you changed how an intrinsic is implemented, please
+/// update the test to invoke a different intrinsic.
+fn check_instance(instance: &Instance) {
+    assert_eq!(instance.kind, InstanceKind::Intrinsic);
+    let name = instance.intrinsic_name().unwrap();
+    if instance.has_body() {
+        let Some(body) = instance.body() else { unreachable!("Expected a body") };
+        assert!(!body.blocks.is_empty());
+        assert_eq!(&name, "select_unpredictable");
+    } else {
+        assert!(instance.body().is_none());
+        assert_matches!(name.as_str(), "size_of_val" | "vtable_size");
+    }
+}
+
+fn check_def(fn_def: FnDef) {
+    assert!(fn_def.is_intrinsic());
+    let intrinsic = fn_def.as_intrinsic().unwrap();
+    assert_eq!(fn_def, intrinsic.into());
+
+    let name = intrinsic.fn_name();
+    match name.as_str() {
+        "select_unpredictable" => {
+            assert!(!intrinsic.must_be_overridden());
+            assert!(fn_def.has_body());
+        }
+        "vtable_size" | "size_of_val" => {
+            assert!(intrinsic.must_be_overridden());
+            assert!(!fn_def.has_body());
+        }
+        _ => unreachable!("Unexpected intrinsic: {}", name),
+    }
+}
+
+struct CallsVisitor<'a> {
+    locals: &'a [LocalDecl],
+    calls: Vec<(FnDef, GenericArgs)>,
+}
+
+impl<'a> MirVisitor for CallsVisitor<'a> {
+    fn visit_terminator(&mut self, term: &Terminator, _loc: Location) {
+        match &term.kind {
+            TerminatorKind::Call { func, .. } => {
+                let TyKind::RigidTy(RigidTy::FnDef(def, args)) =
+                    func.ty(self.locals).unwrap().kind()
+                    else {
+                        return;
+                    };
+                self.calls.push((def, args.clone()));
+            }
+            _ => {}
+        }
+    }
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "binop_input.rs";
+    generate_input(&path).unwrap();
+    let args = &["rustc".to_string(), "--crate-type=lib".to_string(), path.to_string()];
+    run!(args, test_intrinsics).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        #![feature(core_intrinsics)]
+        use std::intrinsics::*;
+        pub fn use_intrinsics(init: bool) -> bool {{
+            let vtable_sz = unsafe {{ vtable_size(0 as *const ()) }};
+            let sz = unsafe {{ size_of_val("hi") }};
+            select_unpredictable(init && sz == 2, false, true)
+        }}
+        "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_item_kind.rs b/tests/ui-fulldeps/rustc_public/check_item_kind.rs
new file mode 100644
index 00000000000..58e740bdaef
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_item_kind.rs
@@ -0,0 +1,79 @@
+//@ run-pass
+//! Test that item kind works as expected.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate rustc_public;
+
+use rustc_public::*;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_item_kind() -> ControlFlow<()> {
+    let items = rustc_public::all_local_items();
+    assert_eq!(items.len(), 4);
+    // Constructor item.
+    for item in items {
+        let expected_kind = match item.name().as_str() {
+            "Dummy" => ItemKind::Ctor(CtorKind::Fn),
+            "dummy" => ItemKind::Fn,
+            "unit" => ItemKind::Fn,
+            "DUMMY_CONST" => ItemKind::Const,
+            name => unreachable!("Unexpected item {name}"),
+        };
+        assert_eq!(item.kind(), expected_kind, "Mismatched type for {}", item.name());
+    }
+    ControlFlow::Continue(())
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "item_kind_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-type=lib".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_item_kind).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        pub struct Dummy(u32);
+        pub const DUMMY_CONST: Dummy = Dummy(0);
+        pub struct DummyUnit;
+
+        pub fn dummy() -> Dummy {{
+            Dummy(5)
+        }}
+
+        pub fn unit() -> DummyUnit {{
+            DummyUnit
+        }}
+        "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_normalization.rs b/tests/ui-fulldeps/rustc_public/check_normalization.rs
new file mode 100644
index 00000000000..aa6a257dac6
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_normalization.rs
@@ -0,0 +1,93 @@
+//@ run-pass
+//! Test that types are normalized in an instance body.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate rustc_public;
+
+use mir::mono::Instance;
+use ty::{Ty, TyKind, RigidTy};
+use rustc_public::*;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_stable_mir() -> ControlFlow<()> {
+    let items = rustc_public::all_local_items();
+
+    // Get all items and split generic vs monomorphic items.
+    let instances: Vec<_> =
+        items.into_iter().filter_map(|item| (!item.requires_monomorphization()).then(|| {
+            Instance::try_from(item).unwrap()
+        })).collect();
+    assert_eq!(instances.len(), 1, "Expected one constant");
+
+    for instance in instances {
+        check_ty(instance.ty());
+    }
+    ControlFlow::Continue(())
+}
+
+fn check_ty(ty: Ty) {
+    match ty.kind() {
+        TyKind::RigidTy(RigidTy::Adt(def, args)) if def.kind().is_struct() => {
+            // Ensure field type is also normalized
+            def.variants_iter().next().unwrap().fields().into_iter().for_each(|f| {
+                check_ty(f.ty_with_args(&args))
+            });
+        }
+        TyKind::RigidTy(RigidTy::Uint(..)) => {}
+        kind => unreachable!("Unexpected kind: {kind:?}")
+    }
+}
+
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "normalization_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-type=lib".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_stable_mir).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        pub trait Primitive {{
+            type Base;
+        }}
+
+        impl Primitive for char {{
+            type Base = u32;
+        }}
+
+        pub struct Wrapper<T: Primitive>(T::Base);
+        pub type WrapperChar = Wrapper<char>;
+        pub const NULL_CHAR: WrapperChar = Wrapper::<char>(0);
+        "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_trait_queries.rs b/tests/ui-fulldeps/rustc_public/check_trait_queries.rs
new file mode 100644
index 00000000000..a6c37883643
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_trait_queries.rs
@@ -0,0 +1,121 @@
+//@ run-pass
+//! Test that users are able to retrieve information about trait declarations and implementations.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_public::CrateDef;
+use std::collections::HashSet;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "trait_test";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_traits() -> ControlFlow<()> {
+    let local_crate = rustc_public::local_crate();
+    let local_traits = local_crate.trait_decls();
+    assert_eq!(local_traits.len(), 1, "Expected `Max` trait, but found {:?}", local_traits);
+    assert_eq!(&local_traits[0].name(), "Max");
+
+    let local_impls = local_crate.trait_impls();
+    let impl_names = local_impls.iter().map(|trait_impl| trait_impl.name()).collect::<HashSet<_>>();
+    assert_impl(&impl_names, "<Positive as Max>");
+    assert_impl(&impl_names, "<Positive as std::marker::Copy>");
+    assert_impl(&impl_names, "<Positive as std::clone::Clone>");
+    assert_impl(&impl_names, "<Positive as std::fmt::Debug>");
+    assert_impl(&impl_names, "<Positive as std::cmp::PartialEq>");
+    assert_impl(&impl_names, "<Positive as std::cmp::Eq>");
+    assert_impl(&impl_names, "<Positive as std::convert::TryFrom<u64>>");
+    assert_impl(&impl_names, "<u64 as Max>");
+    assert_impl(&impl_names, "<impl std::convert::From<Positive> for u64>");
+
+    let all_traits = rustc_public::all_trait_decls();
+    assert!(all_traits.len() > local_traits.len());
+    assert!(
+        local_traits.iter().all(|t| all_traits.contains(t)),
+        "Local: {local_traits:#?}, All: {all_traits:#?}"
+    );
+
+    let all_impls = rustc_public::all_trait_impls();
+    assert!(all_impls.len() > local_impls.len());
+    assert!(
+        local_impls.iter().all(|t| all_impls.contains(t)),
+        "Local: {local_impls:#?}, All: {all_impls:#?}"
+    );
+    ControlFlow::Continue(())
+}
+
+fn assert_impl(impl_names: &HashSet<String>, target: &str) {
+    assert!(
+        impl_names.contains(target),
+        "Failed to find `{target}`. Implementations available: {impl_names:?}",
+    );
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "trait_queries.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_traits).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        use std::convert::TryFrom;
+
+        #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+        pub struct Positive(u64);
+
+        impl TryFrom<u64> for Positive {{
+            type Error = ();
+            fn try_from(val: u64) -> Result<Positive, Self::Error> {{
+                if val > 0 {{ Ok(Positive(val)) }} else {{ Err(()) }}
+            }}
+        }}
+
+        impl From<Positive> for u64 {{
+            fn from(val: Positive) -> u64 {{ val.0 }}
+        }}
+
+        pub trait Max {{
+            fn is_max(&self) -> bool;
+        }}
+
+        impl Max for u64 {{
+            fn is_max(&self) -> bool {{ *self == u64::MAX }}
+        }}
+
+        impl Max for Positive {{
+            fn is_max(&self) -> bool {{ self.0.is_max() }}
+        }}
+
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_transform.rs b/tests/ui-fulldeps/rustc_public/check_transform.rs
new file mode 100644
index 00000000000..3209fcf9ede
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_transform.rs
@@ -0,0 +1,145 @@
+//@ run-pass
+//! Test a few methods to transform StableMIR.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+#![feature(ascii_char, ascii_char_variants)]
+
+extern crate rustc_hir;
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_public::mir::alloc::GlobalAlloc;
+use rustc_public::mir::mono::Instance;
+use rustc_public::mir::{Body, ConstOperand, Operand, Rvalue, StatementKind, TerminatorKind};
+use rustc_public::ty::{ConstantKind, MirConst};
+use rustc_public::{CrateDef, CrateItems, ItemKind};
+use std::convert::TryFrom;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to transform the MIR.
+fn test_transform() -> ControlFlow<()> {
+    // Find items in the local crate.
+    let items = rustc_public::all_local_items();
+
+    // Test fn_abi
+    let target_fn = *get_item(&items, (ItemKind::Fn, "dummy")).unwrap();
+    let instance = Instance::try_from(target_fn).unwrap();
+    let body = instance.body().unwrap();
+    check_msg(&body, "oops");
+
+    let new_msg = "new panic message";
+    let new_body = change_panic_msg(body, new_msg);
+    check_msg(&new_body, new_msg);
+
+    ControlFlow::Continue(())
+}
+
+/// Check that the body panic message matches the given message.
+fn check_msg(body: &Body, expected: &str) {
+    let msg = body
+        .blocks
+        .iter()
+        .find_map(|bb| match &bb.terminator.kind {
+            TerminatorKind::Call { args, .. } => {
+                assert_eq!(args.len(), 1, "Expected panic message, but found {args:?}");
+                let msg_const = match &args[0] {
+                    Operand::Constant(msg_const) => msg_const,
+                    Operand::Copy(place) | Operand::Move(place) => {
+                        assert!(place.projection.is_empty());
+                        bb.statements
+                            .iter()
+                            .find_map(|stmt| match &stmt.kind {
+                                StatementKind::Assign(
+                                    destination,
+                                    Rvalue::Use(Operand::Constant(msg_const)),
+                                ) if destination == place => Some(msg_const),
+                                _ => None,
+                            })
+                            .unwrap()
+                    }
+                };
+                let ConstantKind::Allocated(alloc) = msg_const.const_.kind() else {
+                    unreachable!()
+                };
+                assert_eq!(alloc.provenance.ptrs.len(), 1);
+
+                let alloc_prov_id = alloc.provenance.ptrs[0].1.0;
+                let GlobalAlloc::Memory(val) = GlobalAlloc::from(alloc_prov_id) else {
+                    unreachable!()
+                };
+                let bytes = val.raw_bytes().unwrap();
+                Some(std::str::from_utf8(&bytes).unwrap().to_string())
+            }
+            _ => None,
+        })
+        .expect("Failed to find panic message");
+    assert_eq!(&msg, expected);
+}
+
+/// Modify body to use a different panic message.
+fn change_panic_msg(mut body: Body, new_msg: &str) -> Body {
+    for bb in &mut body.blocks {
+        match &mut bb.terminator.kind {
+            TerminatorKind::Call { args, .. } => {
+                let new_const = MirConst::from_str(new_msg);
+                args[0] = Operand::Constant(ConstOperand {
+                    const_: new_const,
+                    span: bb.terminator.span,
+                    user_ty: None,
+                });
+            }
+            _ => {}
+        }
+    }
+    body
+}
+
+fn get_item<'a>(
+    items: &'a CrateItems,
+    item: (ItemKind, &str),
+) -> Option<&'a rustc_public::CrateItem> {
+    items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1)
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "transform_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_transform).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        fn panic_str(msg: &str) {{ panic!("{{}}", msg); }}
+        pub fn dummy() {{
+            panic_str("oops");
+        }}
+        "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_ty_fold.rs b/tests/ui-fulldeps/rustc_public/check_ty_fold.rs
new file mode 100644
index 00000000000..07ef0d2bb50
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_ty_fold.rs
@@ -0,0 +1,113 @@
+//@ run-pass
+//! Test that users are able to use stable mir APIs to retrieve monomorphized types, and that
+//! we have an error handling for trying to instantiate types with incorrect arguments.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_public::mir::{
+    Body, FieldIdx, MirVisitor, Place, ProjectionElem,
+    visit::{Location, PlaceContext},
+};
+use rustc_public::ty::{RigidTy, Ty, TyKind};
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_stable_mir() -> ControlFlow<()> {
+    let main_fn = rustc_public::entry_fn();
+    let body = main_fn.unwrap().expect_body();
+    let mut visitor = PlaceVisitor { body: &body, tested: false };
+    visitor.visit_body(&body);
+    assert!(visitor.tested);
+    ControlFlow::Continue(())
+}
+
+struct PlaceVisitor<'a> {
+    body: &'a Body,
+    /// Used to ensure that the test was reachable. Otherwise this test would vacuously succeed.
+    tested: bool,
+}
+
+/// Check that `wrapper.inner` place projection can be correctly interpreted.
+/// Ensure that instantiation is correct.
+fn check_tys(local_ty: Ty, idx: FieldIdx, expected_ty: Ty) {
+    let TyKind::RigidTy(RigidTy::Adt(def, args)) = local_ty.kind() else { unreachable!() };
+    assert_eq!(def.ty_with_args(&args), local_ty);
+
+    let field_def = &def.variants_iter().next().unwrap().fields()[idx];
+    let field_ty = field_def.ty_with_args(&args);
+    assert_eq!(field_ty, expected_ty);
+
+    // Check that the generic version is different than the instantiated one.
+    let field_ty_gen = field_def.ty();
+    assert_ne!(field_ty_gen, field_ty);
+}
+
+impl<'a> MirVisitor for PlaceVisitor<'a> {
+    fn visit_place(&mut self, place: &Place, _ptx: PlaceContext, _loc: Location) {
+        let start_ty = self.body.locals()[place.local].ty;
+        match place.projection.as_slice() {
+            [ProjectionElem::Field(idx, ty)] => {
+                check_tys(start_ty, *idx, *ty);
+                self.tested = true;
+            }
+            _ => {}
+        }
+    }
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "ty_fold_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_stable_mir).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        struct Wrapper<T: Default> {{
+            pub inner: T
+        }}
+
+        impl<T: Default> Wrapper<T> {{
+            pub fn new() -> Wrapper<T> {{
+                Wrapper {{ inner: T::default() }}
+            }}
+        }}
+
+        fn main() {{
+            let wrapper = Wrapper::<u8>::new();
+            let _inner = wrapper.inner;
+        }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/check_variant.rs b/tests/ui-fulldeps/rustc_public/check_variant.rs
new file mode 100644
index 00000000000..ebe76bd89d5
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/check_variant.rs
@@ -0,0 +1,183 @@
+//@ run-pass
+//! Test that users are able to use stable mir APIs to retrieve
+//! discriminant value and type for AdtDef and Coroutine variants
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2024
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use std::io::Write;
+use std::ops::ControlFlow;
+
+use rustc_public::CrateItem;
+use rustc_public::crate_def::CrateDef;
+use rustc_public::mir::{AggregateKind, Rvalue, Statement, StatementKind};
+use rustc_public::ty::{IntTy, RigidTy, Ty};
+
+const CRATE_NAME: &str = "crate_variant_ty";
+
+/// Test if we can retrieve discriminant info for different types.
+fn test_def_tys() -> ControlFlow<()> {
+    check_adt_mono();
+    check_adt_poly();
+    check_adt_poly2();
+
+    ControlFlow::Continue(())
+}
+
+fn check_adt_mono() {
+    let mono = get_fn("mono").expect_body();
+
+    check_statement_is_aggregate_assign(
+        &mono.blocks[0].statements[0],
+        0,
+        RigidTy::Int(IntTy::Isize),
+    );
+    check_statement_is_aggregate_assign(
+        &mono.blocks[1].statements[0],
+        1,
+        RigidTy::Int(IntTy::Isize),
+    );
+    check_statement_is_aggregate_assign(
+        &mono.blocks[2].statements[0],
+        2,
+        RigidTy::Int(IntTy::Isize),
+    );
+}
+
+fn check_adt_poly() {
+    let poly = get_fn("poly").expect_body();
+
+    check_statement_is_aggregate_assign(
+        &poly.blocks[0].statements[0],
+        0,
+        RigidTy::Int(IntTy::Isize),
+    );
+    check_statement_is_aggregate_assign(
+        &poly.blocks[1].statements[0],
+        1,
+        RigidTy::Int(IntTy::Isize),
+    );
+    check_statement_is_aggregate_assign(
+        &poly.blocks[2].statements[0],
+        2,
+        RigidTy::Int(IntTy::Isize),
+    );
+}
+
+fn check_adt_poly2() {
+    let poly = get_fn("poly2").expect_body();
+
+    check_statement_is_aggregate_assign(
+        &poly.blocks[0].statements[0],
+        0,
+        RigidTy::Int(IntTy::Isize),
+    );
+    check_statement_is_aggregate_assign(
+        &poly.blocks[1].statements[0],
+        1,
+        RigidTy::Int(IntTy::Isize),
+    );
+    check_statement_is_aggregate_assign(
+        &poly.blocks[2].statements[0],
+        2,
+        RigidTy::Int(IntTy::Isize),
+    );
+}
+
+fn get_fn(name: &str) -> CrateItem {
+    rustc_public::all_local_items().into_iter().find(|it| it.name().eq(name)).unwrap()
+}
+
+fn check_statement_is_aggregate_assign(
+    statement: &Statement,
+    expected_discr_val: u128,
+    expected_discr_ty: RigidTy,
+) {
+    if let Statement { kind: StatementKind::Assign(_, rvalue), .. } = statement
+        && let Rvalue::Aggregate(aggregate, _) = rvalue
+        && let AggregateKind::Adt(adt_def, variant_idx, ..) = aggregate
+    {
+        let discr = adt_def.discriminant_for_variant(*variant_idx);
+
+        assert_eq!(discr.val, expected_discr_val);
+        assert_eq!(discr.ty, Ty::from_rigid_kind(expected_discr_ty));
+    } else {
+        unreachable!("Unexpected statement");
+    }
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "defs_ty_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_def_tys).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        use std::hint::black_box;
+
+        enum Mono {{
+            A,
+            B(i32),
+            C {{ a: i32, b: u32 }},
+        }}
+
+        enum Poly<T> {{
+            A,
+            B(T),
+            C {{ t: T }},
+        }}
+
+        pub fn main() {{
+            mono();
+            poly();
+            poly2::<i32>(1);
+        }}
+
+        fn mono() {{
+            black_box(Mono::A);
+            black_box(Mono::B(6));
+            black_box(Mono::C {{a: 1, b: 10 }});
+        }}
+
+        fn poly() {{
+            black_box(Poly::<i32>::A);
+            black_box(Poly::B(1i32));
+            black_box(Poly::C {{ t: 1i32 }});
+        }}
+
+        fn poly2<T: Copy>(t: T) {{
+            black_box(Poly::<T>::A);
+            black_box(Poly::B(t));
+            black_box(Poly::C {{ t: t }});
+        }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/closure-generic-body.rs b/tests/ui-fulldeps/rustc_public/closure-generic-body.rs
new file mode 100644
index 00000000000..e5f910fbda1
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/closure-generic-body.rs
@@ -0,0 +1,90 @@
+//@ run-pass
+//! Tests stable mir API for retrieving the body of a closure.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use std::io::Write;
+use std::ops::ControlFlow;
+
+use rustc_public::mir::{Body, ConstOperand, Operand, TerminatorKind};
+use rustc_public::ty::{FnDef, RigidTy, TyKind};
+
+const CRATE_NAME: &str = "crate_closure_body";
+
+fn test_closure_body() -> ControlFlow<()> {
+    let crate_items = rustc_public::all_local_items();
+    for item in crate_items {
+        let item_ty = item.ty();
+        match &item_ty.kind() {
+            TyKind::RigidTy(RigidTy::Closure(closure_def, _)) => {
+                let closure_body = closure_def.body().unwrap();
+                check_incr_closure_body(closure_body);
+            }
+            _ => {}
+        }
+    }
+
+    ControlFlow::Continue(())
+}
+
+fn check_incr_closure_body(body: Body) {
+    let first_block = &body.blocks[0];
+    let TerminatorKind::Call { func: Operand::Constant(ConstOperand { const_, .. }), .. } =
+        &first_block.terminator.kind
+    else {
+        panic!("expected Call Terminator, got: ");
+    };
+
+    let TyKind::RigidTy(RigidTy::FnDef(FnDef(def_id), ..), ..) = const_.ty().kind() else {
+        panic!("expected FnDef");
+    };
+
+    assert_eq!(def_id.name(), "id");
+}
+
+fn main() {
+    let path = "closure_body.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_closure_body).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        fn id<T>(y: T) -> T {{
+            y
+        }}
+
+        fn main() {{
+            let cl_id= |x| {{
+                id(x)
+            }};
+
+            let _= cl_id(5);
+        }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/closure_body.rs b/tests/ui-fulldeps/rustc_public/closure_body.rs
new file mode 100644
index 00000000000..f5f9f23ad12
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/closure_body.rs
@@ -0,0 +1,90 @@
+//@ run-pass
+//! Tests stable mir API for retrieving the body of a closure.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use std::io::Write;
+use std::ops::ControlFlow;
+
+use rustc_public::mir::{Body, ConstOperand, Operand, TerminatorKind};
+use rustc_public::ty::{FnDef, RigidTy, TyKind};
+
+const CRATE_NAME: &str = "crate_closure_body";
+
+fn test_closure_body() -> ControlFlow<()> {
+    let crate_items = rustc_public::all_local_items();
+    for item in crate_items {
+        let item_ty = item.ty();
+        match &item_ty.kind() {
+            TyKind::RigidTy(RigidTy::Closure(closure_def, _)) => {
+                let closure_body = closure_def.body().unwrap();
+                check_incr_closure_body(closure_body);
+            }
+            _ => {}
+        }
+    }
+
+    ControlFlow::Continue(())
+}
+
+fn check_incr_closure_body(body: Body) {
+    let first_block = &body.blocks[0];
+    let TerminatorKind::Call { func: Operand::Constant(ConstOperand { const_, .. }), .. } =
+        &first_block.terminator.kind
+    else {
+        panic!("expected Call Terminator, got: ");
+    };
+
+    let TyKind::RigidTy(RigidTy::FnDef(FnDef(def_id), ..), ..) = const_.ty().kind() else {
+        panic!("expected FnDef");
+    };
+
+    assert_eq!(def_id.name(), "incr");
+}
+
+fn main() {
+    let path = "closure_body.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_closure_body).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+        fn incr(y: i32) -> i32 {{
+            y + 1
+        }}
+
+        fn main() {{
+            let cl_incr = |x: i32| {{
+                incr(x)
+            }};
+
+            let _= cl_incr(5);
+        }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/compilation-result.rs b/tests/ui-fulldeps/rustc_public/compilation-result.rs
new file mode 100644
index 00000000000..ed013375c71
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/compilation-result.rs
@@ -0,0 +1,86 @@
+//@ run-pass
+// Test StableMIR behavior when different results are given
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use std::io::Write;
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "input_compilation_result_test.rs";
+    generate_input(&path).unwrap();
+    let args = &["rustc".to_string(), path.to_string()];
+    test_continue(args);
+    test_break(args);
+    test_failed(args);
+    test_skipped(args);
+    test_captured(args)
+}
+
+fn test_continue(args: &[String]) {
+    let result = run!(args, || ControlFlow::Continue::<(), bool>(true));
+    assert_eq!(result, Ok(true));
+}
+
+fn test_break(args: &[String]) {
+    let result = run!(args, || ControlFlow::Break::<bool, i32>(false));
+    assert_eq!(result, Err(rustc_public::CompilerError::Interrupted(false)));
+}
+
+#[allow(unreachable_code)]
+fn test_skipped(args: &[String]) {
+    let mut args = args.to_vec();
+    args.push("--version".to_string());
+    let result = run!(&args, || unreachable!() as ControlFlow<()>);
+    assert_eq!(result, Err(rustc_public::CompilerError::Skipped));
+}
+
+#[allow(unreachable_code)]
+fn test_failed(args: &[String]) {
+    let mut args = args.to_vec();
+    args.push("--cfg=broken".to_string());
+    let result = run!(&args, || unreachable!() as ControlFlow<()>);
+    assert_eq!(result, Err(rustc_public::CompilerError::Failed));
+}
+
+/// Test that we are able to pass a closure and set the return according to the captured value.
+fn test_captured(args: &[String]) {
+    let captured = "10".to_string();
+    let result = run!(args, || ControlFlow::Continue::<(), usize>(captured.len()));
+    assert_eq!(result, Ok(captured.len()));
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+    // This should trigger a compilation failure when enabled.
+    #[cfg(broken)]
+    mod broken_mod {{
+        fn call_invalid() {{
+            invalid_fn();
+        }}
+    }}
+
+    fn main() {{}}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/crate-info.rs b/tests/ui-fulldeps/rustc_public/crate-info.rs
new file mode 100644
index 00000000000..4f46dff9b82
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/crate-info.rs
@@ -0,0 +1,259 @@
+//@ run-pass
+// Test that users are able to use stable mir APIs to retrieve information of the current crate
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_hir;
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_hir::def::DefKind;
+use rustc_public::ItemKind;
+use rustc_public::crate_def::CrateDef;
+use rustc_public::mir::mono::Instance;
+use rustc_public::ty::{RigidTy, TyKind};
+use std::assert_matches::assert_matches;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+/// This function uses the Stable MIR APIs to get information about the test crate.
+fn test_stable_mir() -> ControlFlow<()> {
+    // Get the local crate using rustc_public API.
+    let local = rustc_public::local_crate();
+    assert_eq!(&local.name, CRATE_NAME);
+
+    assert_eq!(rustc_public::entry_fn(), None);
+
+    // Find items in the local crate.
+    let items = rustc_public::all_local_items();
+    assert!(get_item(&items, (DefKind::Fn, "foo::bar")).is_some());
+
+    // Find the `std` crate and assert that there is only one of it.
+    assert!(rustc_public::find_crates("std").len() == 1);
+
+    let bar = get_item(&items, (DefKind::Fn, "bar")).unwrap();
+    let body = bar.expect_body();
+    assert_eq!(body.locals().len(), 2);
+    assert_eq!(body.blocks.len(), 1);
+    let block = &body.blocks[0];
+    assert_eq!(block.statements.len(), 1);
+    match &block.statements[0].kind {
+        rustc_public::mir::StatementKind::Assign(..) => {}
+        other => panic!("{other:?}"),
+    }
+    match &block.terminator.kind {
+        rustc_public::mir::TerminatorKind::Return => {}
+        other => panic!("{other:?}"),
+    }
+
+    let foo_bar = get_item(&items, (DefKind::Fn, "foo_bar")).unwrap();
+    let body = foo_bar.expect_body();
+    assert_eq!(body.locals().len(), 5);
+    assert_eq!(body.blocks.len(), 4);
+    let block = &body.blocks[0];
+    match &block.terminator.kind {
+        rustc_public::mir::TerminatorKind::Call { .. } => {}
+        other => panic!("{other:?}"),
+    }
+
+    let types = get_item(&items, (DefKind::Fn, "types")).unwrap();
+    let body = types.expect_body();
+    assert_eq!(body.locals().len(), 6);
+    assert_matches!(
+        body.locals()[0].ty.kind(),
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool)
+    );
+    assert_matches!(
+        body.locals()[1].ty.kind(),
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool)
+    );
+    assert_matches!(
+        body.locals()[2].ty.kind(),
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Char)
+    );
+    assert_matches!(
+        body.locals()[3].ty.kind(),
+        rustc_public::ty::TyKind::RigidTy(
+            rustc_public::ty::RigidTy::Int(rustc_public::ty::IntTy::I32)
+        )
+    );
+    assert_matches!(
+        body.locals()[4].ty.kind(),
+        rustc_public::ty::TyKind::RigidTy(
+            rustc_public::ty::RigidTy::Uint(rustc_public::ty::UintTy::U64)
+        )
+    );
+    assert_matches!(
+        body.locals()[5].ty.kind(),
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Float(
+            rustc_public::ty::FloatTy::F64
+        ))
+    );
+
+    let drop = get_item(&items, (DefKind::Fn, "drop")).unwrap();
+    let body = drop.expect_body();
+    assert_eq!(body.blocks.len(), 2);
+    let block = &body.blocks[0];
+    match &block.terminator.kind {
+        rustc_public::mir::TerminatorKind::Drop { .. } => {}
+        other => panic!("{other:?}"),
+    }
+
+    let assert = get_item(&items, (DefKind::Fn, "assert")).unwrap();
+    let body = assert.expect_body();
+    assert_eq!(body.blocks.len(), 2);
+    let block = &body.blocks[0];
+    match &block.terminator.kind {
+        rustc_public::mir::TerminatorKind::Assert { .. } => {}
+        other => panic!("{other:?}"),
+    }
+
+    let monomorphic = get_item(&items, (DefKind::Fn, "monomorphic")).unwrap();
+    let instance = Instance::try_from(monomorphic.clone()).unwrap();
+    for block in instance.body().unwrap().blocks {
+        match &block.terminator.kind {
+            rustc_public::mir::TerminatorKind::Call { func, .. } => {
+                let TyKind::RigidTy(ty) = func.ty(&body.locals()).unwrap().kind() else {
+                    unreachable!()
+                };
+                let RigidTy::FnDef(def, args) = ty else { unreachable!() };
+                let next_func = Instance::resolve(def, &args).unwrap();
+                match next_func.body().unwrap().locals()[1].ty.kind() {
+                    TyKind::RigidTy(RigidTy::Uint(_)) | TyKind::RigidTy(RigidTy::Tuple(_)) => {}
+                    other => panic!("{other:?}"),
+                }
+            }
+            rustc_public::mir::TerminatorKind::Return => {}
+            other => panic!("{other:?}"),
+        }
+    }
+
+    let foo_const = get_item(&items, (DefKind::Const, "FOO")).unwrap();
+    // Ensure we don't panic trying to get the body of a constant.
+    foo_const.expect_body();
+
+    let locals_fn = get_item(&items, (DefKind::Fn, "locals")).unwrap();
+    let body = locals_fn.expect_body();
+    assert_eq!(body.locals().len(), 4);
+    assert_matches!(
+        body.ret_local().ty.kind(),
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Char)
+    );
+    assert_eq!(body.arg_locals().len(), 2);
+    assert_matches!(
+        body.arg_locals()[0].ty.kind(),
+        rustc_public::ty::TyKind::RigidTy(
+            rustc_public::ty::RigidTy::Int(rustc_public::ty::IntTy::I32)
+        )
+    );
+    assert_matches!(
+        body.arg_locals()[1].ty.kind(),
+        rustc_public::ty::TyKind::RigidTy(
+            rustc_public::ty::RigidTy::Uint(rustc_public::ty::UintTy::U64)
+        )
+    );
+    assert_eq!(body.inner_locals().len(), 1);
+    // If conditions have an extra inner local to hold their results
+    assert_matches!(
+        body.inner_locals()[0].ty.kind(),
+        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool)
+    );
+
+    ControlFlow::Continue(())
+}
+
+// Use internal API to find a function in a crate.
+fn get_item<'a>(
+    items: &'a rustc_public::CrateItems,
+    item: (DefKind, &str),
+) -> Option<&'a rustc_public::CrateItem> {
+    items.iter().find(|crate_item| {
+        matches!(
+            (item.0, crate_item.kind()),
+            (DefKind::Fn, ItemKind::Fn) | (DefKind::Const, ItemKind::Const)
+        ) && crate_item.name() == item.1
+    })
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "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_stable_mir).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+    pub const FOO: u32 = 1 + 2;
+
+    fn generic<T, const U: usize>(t: T) -> [(); U] {{
+        _ = t;
+        [(); U]
+    }}
+
+    pub fn monomorphic() {{
+        generic::<(), 5>(());
+        generic::<u32, 0>(45);
+    }}
+
+    mod foo {{
+        pub fn bar(i: i32) -> i64 {{
+            i as i64
+        }}
+    }}
+
+    pub fn bar(x: i32) -> i32 {{
+        x
+    }}
+
+    pub fn foo_bar(x: i32, y: i32) -> i64 {{
+        let x_64 = foo::bar(x);
+        let y_64 = foo::bar(y);
+        x_64.wrapping_add(y_64)
+    }}
+
+    pub fn types(b: bool, _: char, _: i32, _: u64, _: f64) -> bool {{
+        b
+    }}
+
+    pub fn drop(_: String) {{}}
+
+    pub fn assert(x: i32) -> i32 {{
+        x + 1
+    }}
+
+    pub fn locals(a: i32, _: u64) -> char {{
+        if a > 5 {{
+            'a'
+        }} else {{
+            'b'
+        }}
+    }}"#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/projections.rs b/tests/ui-fulldeps/rustc_public/projections.rs
new file mode 100644
index 00000000000..3b360cd2fcf
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/projections.rs
@@ -0,0 +1,174 @@
+//@ run-pass
+// Tests the Stable MIR projections API
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_hir;
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_public::ItemKind;
+use rustc_public::crate_def::CrateDef;
+use rustc_public::mir::{ProjectionElem, Rvalue, StatementKind};
+use rustc_public::ty::{RigidTy, TyKind, UintTy};
+use std::assert_matches::assert_matches;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+/// Tests projections within Place objects
+fn test_place_projections() -> ControlFlow<()> {
+    let items = rustc_public::all_local_items();
+    let body = get_item(&items, (ItemKind::Fn, "projections")).unwrap().expect_body();
+    assert_eq!(body.blocks.len(), 4);
+    // The first statement assigns `&s.c` to a local. The projections include a deref for `s`, since
+    // `s` is passed as a reference argument, and a field access for field `c`.
+    match &body.blocks[0].statements[0].kind {
+        StatementKind::Assign(
+            place @ rustc_public::mir::Place { local: _, projection: local_proj },
+            Rvalue::Ref(_, _, rustc_public::mir::Place { local: _, projection: r_proj }),
+        ) => {
+            // We can't match on vecs, only on slices. Comparing statements for equality wouldn't be
+            // any easier since we'd then have to add in the expected local and region values
+            // instead of matching on wildcards.
+            assert!(local_proj.is_empty());
+            match &r_proj[..] {
+                // Similarly we can't match against a type, only against its kind.
+                [ProjectionElem::Deref, ProjectionElem::Field(2, ty)] => {
+                    assert_matches!(
+                        ty.kind(),
+                        TyKind::RigidTy(RigidTy::Uint(rustc_public::ty::UintTy::U8))
+                    );
+                    let ty = place.ty(body.locals()).unwrap();
+                    assert_matches!(ty.kind().rigid(), Some(RigidTy::Ref(..)));
+                }
+                other => panic!(
+                    "Unable to match against expected rvalue projection. Expected the projection \
+                     for `s.c`, which is a Deref and u8 Field. Got: {:?}",
+                    other
+                ),
+            };
+        }
+        other => panic!(
+            "Unable to match against expected Assign statement with a Ref rvalue. Expected the \
+             statement to assign `&s.c` to a local. Got: {:?}",
+            other
+        ),
+    };
+    // This statement assigns `slice[1]` to a local. The projections include a deref for `slice`,
+    // since `slice` is a reference, and an index.
+    match &body.blocks[2].statements[0].kind {
+        StatementKind::Assign(
+            place @ rustc_public::mir::Place { local: _, projection: local_proj },
+            Rvalue::Use(rustc_public::mir::Operand::Copy(rustc_public::mir::Place {
+                local: _,
+                projection: r_proj,
+            })),
+        ) => {
+            // We can't match on vecs, only on slices. Comparing for equality wouldn't be any easier
+            // since we'd then have to add in the expected local values instead of matching on
+            // wildcards.
+            assert!(local_proj.is_empty());
+            assert_matches!(r_proj[..], [ProjectionElem::Deref, ProjectionElem::Index(_)]);
+            let ty = place.ty(body.locals()).unwrap();
+            assert_matches!(ty.kind().rigid(), Some(RigidTy::Uint(UintTy::U8)));
+        }
+        other => panic!(
+            "Unable to match against expected Assign statement with a Use rvalue. Expected the \
+             statement to assign `slice[1]` to a local. Got: {:?}",
+            other
+        ),
+    };
+    // The first terminator gets a slice of an array via the Index operation. Specifically it
+    // performs `&vals[1..3]`. There are no projections in this case, the arguments are just locals.
+    match &body.blocks[0].terminator.kind {
+        rustc_public::mir::TerminatorKind::Call { args, .. } =>
+        // We can't match on vecs, only on slices. Comparing for equality wouldn't be any easier
+        // since we'd then have to add in the expected local values instead of matching on
+        // wildcards.
+        {
+            match &args[..] {
+                [
+                    rustc_public::mir::Operand::Move(rustc_public::mir::Place {
+                        local: _,
+                        projection: arg1_proj,
+                    }),
+                    rustc_public::mir::Operand::Move(rustc_public::mir::Place {
+                        local: _,
+                        projection: arg2_proj,
+                    }),
+                ] => {
+                    assert!(arg1_proj.is_empty());
+                    assert!(arg2_proj.is_empty());
+                }
+                other => {
+                    panic!(
+                        "Unable to match against expected arguments to Index call. Expected two \
+                         move operands. Got: {:?}",
+                        other
+                    )
+                }
+            }
+        }
+        other => panic!(
+            "Unable to match against expected Call terminator. Expected a terminator that calls \
+             the Index operation. Got: {:?}",
+            other
+        ),
+    };
+
+    ControlFlow::Continue(())
+}
+
+// Use internal API to find a function in a crate.
+fn get_item<'a>(
+    items: &'a rustc_public::CrateItems,
+    item: (ItemKind, &str),
+) -> Option<&'a rustc_public::CrateItem> {
+    items.iter().find(|crate_item| crate_item.kind() == item.0 && crate_item.name() == item.1)
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "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_place_projections).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+    pub struct Struct1 {{ _a: u8, _b: u16, c: u8 }}
+
+    pub fn projections(s: &Struct1) -> u8 {{
+        let v = &s.c;
+        let vals = [1, 2, 3, 4];
+        let slice = &vals[1..3];
+        v + slice[1]
+    }}"#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/smir_internal.rs b/tests/ui-fulldeps/rustc_public/smir_internal.rs
new file mode 100644
index 00000000000..dd70cfe5f5e
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/smir_internal.rs
@@ -0,0 +1,61 @@
+//@ run-pass
+//! Test that users are able to use retrieve internal constructs from stable ones to help with
+//! the migration.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate rustc_middle;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_middle::ty::TyCtxt;
+use rustc_public::rustc_internal;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+fn test_translation(tcx: TyCtxt<'_>) -> ControlFlow<()> {
+    let main_fn = rustc_public::entry_fn().unwrap();
+    let body = main_fn.expect_body();
+    let orig_ty = body.locals()[0].ty;
+    let rustc_ty = rustc_internal::internal(tcx, &orig_ty);
+    assert!(rustc_ty.is_unit());
+    ControlFlow::Continue(())
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "internal_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run_with_tcx!(args, test_translation).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+    pub fn main() {{
+    }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/smir_serde.rs b/tests/ui-fulldeps/rustc_public/smir_serde.rs
new file mode 100644
index 00000000000..31642c6cb94
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/smir_serde.rs
@@ -0,0 +1,68 @@
+//@ run-pass
+//! Test that users are able to use serialize stable MIR constructs.
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate rustc_middle;
+extern crate serde;
+extern crate serde_json;
+#[macro_use]
+extern crate rustc_public;
+
+use rustc_middle::ty::TyCtxt;
+use serde_json::to_string;
+use rustc_public::mir::Body;
+use std::io::{BufWriter, Write};
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+fn serialize_to_json(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
+    let path = "output.json";
+    let mut writer = BufWriter::new(std::fs::File::create(path).expect("Failed to create path"));
+    let local_crate = rustc_public::local_crate();
+    let items: Vec<Body> =
+        rustc_public::all_local_items().iter().map(|item| item.expect_body()).collect();
+    let crate_data = (local_crate.name, items);
+    writer
+        .write_all(to_string(&crate_data).expect("serde_json failed").as_bytes())
+        .expect("JSON serialization failed");
+    ControlFlow::Continue(())
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "internal_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run_with_tcx!(args, serialize_to_json).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+    pub fn main() {{
+    }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/rustc_public/smir_visitor.rs b/tests/ui-fulldeps/rustc_public/smir_visitor.rs
new file mode 100644
index 00000000000..66787e2927b
--- /dev/null
+++ b/tests/ui-fulldeps/rustc_public/smir_visitor.rs
@@ -0,0 +1,223 @@
+//@ run-pass
+//! Sanity check Stable MIR Visitor
+
+//@ ignore-stage1
+//@ ignore-cross-compile
+//@ ignore-remote
+//@ edition: 2021
+
+#![feature(rustc_private)]
+#![feature(assert_matches)]
+
+extern crate rustc_middle;
+
+extern crate rustc_driver;
+extern crate rustc_interface;
+extern crate rustc_public;
+
+use rustc_public::mir::MirVisitor;
+use rustc_public::mir::MutMirVisitor;
+use rustc_public::*;
+use std::collections::HashSet;
+use std::io::Write;
+use std::ops::ControlFlow;
+
+const CRATE_NAME: &str = "input";
+
+fn test_visitor() -> ControlFlow<()> {
+    let main_fn = rustc_public::entry_fn();
+    let main_body = main_fn.unwrap().expect_body();
+    let main_visitor = TestVisitor::collect(&main_body);
+    assert!(main_visitor.ret_val.is_some());
+    assert!(main_visitor.args.is_empty());
+    assert!(main_visitor.tys.contains(&main_visitor.ret_val.unwrap().ty));
+    assert!(!main_visitor.calls.is_empty());
+
+    let exit_fn = main_visitor.calls.last().unwrap();
+    assert!(exit_fn.mangled_name().contains("exit_fn"), "Unexpected last function: {exit_fn:?}");
+
+    let exit_body = exit_fn.body().unwrap();
+    let exit_visitor = TestVisitor::collect(&exit_body);
+    assert!(exit_visitor.ret_val.is_some());
+    assert_eq!(exit_visitor.args.len(), 1);
+    assert!(exit_visitor.tys.contains(&exit_visitor.ret_val.unwrap().ty));
+    assert!(exit_visitor.tys.contains(&exit_visitor.args[0].ty));
+    ControlFlow::Continue(())
+}
+
+struct TestVisitor<'a> {
+    pub body: &'a mir::Body,
+    pub tys: HashSet<ty::Ty>,
+    pub ret_val: Option<mir::LocalDecl>,
+    pub args: Vec<mir::LocalDecl>,
+    pub calls: Vec<mir::mono::Instance>,
+}
+
+impl<'a> TestVisitor<'a> {
+    fn collect(body: &'a mir::Body) -> TestVisitor<'a> {
+        let mut visitor = TestVisitor {
+            body: &body,
+            tys: Default::default(),
+            ret_val: None,
+            args: vec![],
+            calls: vec![],
+        };
+        visitor.visit_body(&body);
+        visitor
+    }
+}
+
+impl<'a> mir::MirVisitor for TestVisitor<'a> {
+    fn visit_ty(&mut self, ty: &ty::Ty, _location: mir::visit::Location) {
+        self.tys.insert(*ty);
+        self.super_ty(ty)
+    }
+
+    fn visit_ret_decl(&mut self, local: mir::Local, decl: &mir::LocalDecl) {
+        assert!(local == mir::RETURN_LOCAL);
+        assert!(self.ret_val.is_none());
+        self.ret_val = Some(decl.clone());
+        self.super_ret_decl(local, decl);
+    }
+
+    fn visit_arg_decl(&mut self, local: mir::Local, decl: &mir::LocalDecl) {
+        self.args.push(decl.clone());
+        assert_eq!(local, self.args.len());
+        self.super_arg_decl(local, decl);
+    }
+
+    fn visit_terminator(&mut self, term: &mir::Terminator, location: mir::visit::Location) {
+        if let mir::TerminatorKind::Call { func, .. } = &term.kind {
+            let ty::TyKind::RigidTy(ty) = func.ty(self.body.locals()).unwrap().kind() else {
+                unreachable!()
+            };
+            let ty::RigidTy::FnDef(def, args) = ty else { unreachable!() };
+            self.calls.push(mir::mono::Instance::resolve(def, &args).unwrap());
+        }
+        self.super_terminator(term, location);
+    }
+}
+
+fn test_mut_visitor() -> ControlFlow<()> {
+    let main_fn = rustc_public::entry_fn();
+    let mut main_body = main_fn.unwrap().expect_body();
+    let locals = main_body.locals().to_vec();
+    let mut main_visitor = TestMutVisitor::collect(locals);
+    main_visitor.visit_body(&mut main_body);
+    assert!(main_visitor.ret_val.is_some());
+    assert!(main_visitor.args.is_empty());
+    assert!(main_visitor.tys.contains(&main_visitor.ret_val.unwrap().ty));
+    assert!(!main_visitor.calls.is_empty());
+
+    let exit_fn = main_visitor.calls.last().unwrap();
+    assert!(exit_fn.mangled_name().contains("exit_fn"), "Unexpected last function: {exit_fn:?}");
+
+    let mut exit_body = exit_fn.body().unwrap();
+    let locals = exit_body.locals().to_vec();
+    let mut exit_visitor = TestMutVisitor::collect(locals);
+    exit_visitor.visit_body(&mut exit_body);
+    assert!(exit_visitor.ret_val.is_some());
+    assert_eq!(exit_visitor.args.len(), 1);
+    assert!(exit_visitor.tys.contains(&exit_visitor.ret_val.unwrap().ty));
+    assert!(exit_visitor.tys.contains(&exit_visitor.args[0].ty));
+    ControlFlow::Continue(())
+}
+
+struct TestMutVisitor {
+    locals: Vec<mir::LocalDecl>,
+    pub tys: HashSet<ty::Ty>,
+    pub ret_val: Option<mir::LocalDecl>,
+    pub args: Vec<mir::LocalDecl>,
+    pub calls: Vec<mir::mono::Instance>,
+}
+
+impl TestMutVisitor {
+    fn collect(locals: Vec<mir::LocalDecl>) -> TestMutVisitor {
+        let visitor = TestMutVisitor {
+            locals: locals,
+            tys: Default::default(),
+            ret_val: None,
+            args: vec![],
+            calls: vec![],
+        };
+        visitor
+    }
+}
+
+impl mir::MutMirVisitor for TestMutVisitor {
+    fn visit_ty(&mut self, ty: &mut ty::Ty, _location: mir::visit::Location) {
+        self.tys.insert(*ty);
+        self.super_ty(ty)
+    }
+
+    fn visit_ret_decl(&mut self, local: mir::Local, decl: &mut mir::LocalDecl) {
+        assert!(local == mir::RETURN_LOCAL);
+        assert!(self.ret_val.is_none());
+        self.ret_val = Some(decl.clone());
+        self.super_ret_decl(local, decl);
+    }
+
+    fn visit_arg_decl(&mut self, local: mir::Local, decl: &mut mir::LocalDecl) {
+        self.args.push(decl.clone());
+        assert_eq!(local, self.args.len());
+        self.super_arg_decl(local, decl);
+    }
+
+    fn visit_terminator(&mut self, term: &mut mir::Terminator, location: mir::visit::Location) {
+        if let mir::TerminatorKind::Call { func, .. } = &mut term.kind {
+            let ty::TyKind::RigidTy(ty) = func.ty(&self.locals).unwrap().kind() else {
+                unreachable!()
+            };
+            let ty::RigidTy::FnDef(def, args) = ty else { unreachable!() };
+            self.calls.push(mir::mono::Instance::resolve(def, &args).unwrap());
+        }
+        self.super_terminator(term, location);
+    }
+}
+
+/// This test will generate and analyze a dummy crate using the stable mir.
+/// For that, it will first write the dummy crate into a file.
+/// Then it will create a `StableMir` using custom arguments and then
+/// it will run the compiler.
+fn main() {
+    let path = "sim_visitor_input.rs";
+    generate_input(&path).unwrap();
+    let args = &[
+        "rustc".to_string(),
+        "-Cpanic=abort".to_string(),
+        "--crate-name".to_string(),
+        CRATE_NAME.to_string(),
+        path.to_string(),
+    ];
+    run!(args, test_visitor).unwrap();
+    run!(args, test_mut_visitor).unwrap();
+}
+
+fn generate_input(path: &str) -> std::io::Result<()> {
+    let mut file = std::fs::File::create(path)?;
+    write!(
+        file,
+        r#"
+    fn main() -> std::process::ExitCode {{
+        let inputs = Inputs::new();
+        let total = inputs.values.iter().sum();
+        exit_fn(total)
+    }}
+
+    fn exit_fn(code: u8) -> std::process::ExitCode {{
+        std::process::ExitCode::from(code)
+    }}
+
+    struct Inputs {{
+        values: [u8; 3],
+    }}
+
+    impl Inputs {{
+        fn new() -> Inputs {{
+            Inputs {{ values: [0, 1, 2] }}
+        }}
+    }}
+    "#
+    )?;
+    Ok(())
+}
diff --git a/tests/ui-fulldeps/stable-mir/check_abi.rs b/tests/ui-fulldeps/stable-mir/check_abi.rs
deleted file mode 100644
index fc2227d147d..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_abi.rs
+++ /dev/null
@@ -1,225 +0,0 @@
-//@ run-pass
-//! Test information regarding type layout.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-#![feature(ascii_char, ascii_char_variants)]
-
-extern crate rustc_hir;
-extern crate rustc_middle;
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_public::abi::{
-    ArgAbi, CallConvention, FieldsShape, IntegerLength, PassMode, Primitive, Scalar, ValueAbi,
-    VariantsShape,
-};
-use rustc_public::mir::MirVisitor;
-use rustc_public::mir::mono::Instance;
-use rustc_public::target::MachineInfo;
-use rustc_public::ty::{AdtDef, RigidTy, Ty, TyKind};
-use rustc_public::{CrateDef, CrateItem, CrateItems, ItemKind};
-use std::assert_matches::assert_matches;
-use std::collections::HashSet;
-use std::convert::TryFrom;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_stable_mir() -> ControlFlow<()> {
-    // Find items in the local crate.
-    let items = rustc_public::all_local_items();
-
-    // Test fn_abi
-    let target_fn = *get_item(&items, (ItemKind::Fn, "fn_abi")).unwrap();
-    let instance = Instance::try_from(target_fn).unwrap();
-    let fn_abi = instance.fn_abi().unwrap();
-    assert_eq!(fn_abi.conv, CallConvention::Rust);
-    assert_eq!(fn_abi.args.len(), 3);
-
-    check_ignore(&fn_abi.args[0]);
-    check_primitive(&fn_abi.args[1]);
-    check_niche(&fn_abi.args[2]);
-    check_result(&fn_abi.ret);
-
-    // Test variadic function.
-    let variadic_fn = *get_item(&items, (ItemKind::Fn, "variadic_fn")).unwrap();
-    check_variadic(variadic_fn);
-
-    // Extract function pointers.
-    let fn_ptr_holder = *get_item(&items, (ItemKind::Fn, "fn_ptr_holder")).unwrap();
-    let fn_ptr_holder_instance = Instance::try_from(fn_ptr_holder).unwrap();
-    let body = fn_ptr_holder_instance.body().unwrap();
-    let args = body.arg_locals();
-
-    // Test fn_abi of function pointer version.
-    let ptr_fn_abi = args[0].ty.kind().fn_sig().unwrap().fn_ptr_abi().unwrap();
-    assert_eq!(ptr_fn_abi, fn_abi);
-
-    // Test variadic_fn of function pointer version.
-    let ptr_variadic_fn_abi = args[1].ty.kind().fn_sig().unwrap().fn_ptr_abi().unwrap();
-    assert!(ptr_variadic_fn_abi.c_variadic);
-    assert_eq!(ptr_variadic_fn_abi.args.len(), 1);
-
-    let entry = rustc_public::entry_fn().unwrap();
-    let main_fn = Instance::try_from(entry).unwrap();
-    let mut visitor = AdtDefVisitor::default();
-    visitor.visit_body(&main_fn.body().unwrap());
-    let AdtDefVisitor { adt_defs } = visitor;
-    assert_eq!(adt_defs.len(), 1);
-
-    // Test ADT representation options
-    let repr_c_struct = adt_defs.iter().find(|def| def.trimmed_name() == "ReprCStruct").unwrap();
-    assert!(repr_c_struct.repr().flags.is_c);
-
-    ControlFlow::Continue(())
-}
-
-/// Check the variadic function ABI:
-/// ```no_run
-/// pub unsafe extern "C" fn variadic_fn(n: usize, mut args: ...) -> usize {
-///     0
-/// }
-/// ```
-fn check_variadic(variadic_fn: CrateItem) {
-    let instance = Instance::try_from(variadic_fn).unwrap();
-    let abi = instance.fn_abi().unwrap();
-    assert!(abi.c_variadic);
-    assert_eq!(abi.args.len(), 1);
-}
-
-/// Check the argument to be ignored: `ignore: [u8; 0]`.
-fn check_ignore(abi: &ArgAbi) {
-    assert!(abi.ty.kind().is_array());
-    assert_eq!(abi.mode, PassMode::Ignore);
-    let layout = abi.layout.shape();
-    assert!(layout.is_sized());
-    assert!(layout.is_1zst());
-}
-
-/// Check the primitive argument: `primitive: char`.
-fn check_primitive(abi: &ArgAbi) {
-    assert!(abi.ty.kind().is_char());
-    assert_matches!(abi.mode, PassMode::Direct(_));
-    let layout = abi.layout.shape();
-    assert!(layout.is_sized());
-    assert!(!layout.is_1zst());
-    assert_matches!(layout.fields, FieldsShape::Primitive);
-}
-
-/// Check the return value: `Result<usize, &str>`.
-fn check_result(abi: &ArgAbi) {
-    assert!(abi.ty.kind().is_enum());
-    assert_matches!(abi.mode, PassMode::Indirect { .. });
-    let layout = abi.layout.shape();
-    assert!(layout.is_sized());
-    assert_matches!(layout.fields, FieldsShape::Arbitrary { .. });
-    assert_matches!(layout.variants, VariantsShape::Multiple { .. })
-}
-
-/// Checks the niche information about `NonZero<u8>`.
-fn check_niche(abi: &ArgAbi) {
-    assert!(abi.ty.kind().is_struct());
-    assert_matches!(abi.mode, PassMode::Direct { .. });
-    let layout = abi.layout.shape();
-    assert!(layout.is_sized());
-    assert_eq!(layout.size.bytes(), 1);
-
-    let ValueAbi::Scalar(scalar) = layout.abi else { unreachable!() };
-    assert!(scalar.has_niche(&MachineInfo::target()), "Opps: {:?}", scalar);
-
-    let Scalar::Initialized { value, valid_range } = scalar else { unreachable!() };
-    assert_matches!(value, Primitive::Int { length: IntegerLength::I8, signed: false });
-    assert_eq!(valid_range.start, 1);
-    assert_eq!(valid_range.end, u8::MAX.into());
-    assert!(!valid_range.contains(0));
-    assert!(!valid_range.wraps_around());
-}
-
-fn get_item<'a>(
-    items: &'a CrateItems,
-    item: (ItemKind, &str),
-) -> Option<&'a rustc_public::CrateItem> {
-    items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1)
-}
-
-#[derive(Default)]
-struct AdtDefVisitor {
-    adt_defs: HashSet<AdtDef>,
-}
-
-impl MirVisitor for AdtDefVisitor {
-    fn visit_ty(&mut self, ty: &Ty, _location: rustc_public::mir::visit::Location) {
-        if let TyKind::RigidTy(RigidTy::Adt(adt, _)) = ty.kind() {
-            self.adt_defs.insert(adt);
-        }
-        self.super_ty(ty)
-    }
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "alloc_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_stable_mir).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        #![feature(c_variadic)]
-        #![allow(unused_variables)]
-
-        use std::num::NonZero;
-
-        pub fn fn_abi(
-            ignore: [u8; 0],
-            primitive: char,
-            niche: NonZero<u8>,
-        ) -> Result<usize, &'static str> {{
-                // We only care about the signature.
-                todo!()
-        }}
-
-        pub unsafe extern "C" fn variadic_fn(n: usize, mut args: ...) -> usize {{
-            0
-        }}
-
-        pub type ComplexFn = fn([u8; 0], char, NonZero<u8>) -> Result<usize, &'static str>;
-        pub type VariadicFn = unsafe extern "C" fn(usize, ...) -> usize;
-
-        pub fn fn_ptr_holder(complex_fn: ComplexFn, variadic_fn: VariadicFn) {{
-            // We only care about the signature.
-            todo!()
-        }}
-
-        fn main() {{
-            #[repr(C)]
-            struct ReprCStruct;
-
-            let _s = ReprCStruct;
-        }}
-        "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_allocation.rs b/tests/ui-fulldeps/stable-mir/check_allocation.rs
deleted file mode 100644
index 83845a9aa42..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_allocation.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-//@ run-pass
-//! Test that users are able to use stable mir APIs to retrieve information of global allocations
-//! such as `vtable_allocation`.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-#![feature(ascii_char, ascii_char_variants)]
-
-extern crate rustc_hir;
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use std::ascii::Char;
-use std::assert_matches::assert_matches;
-use std::cmp::{max, min};
-use std::collections::HashMap;
-use std::ffi::CStr;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-use rustc_public::crate_def::CrateDef;
-use rustc_public::mir::Body;
-use rustc_public::mir::alloc::GlobalAlloc;
-use rustc_public::mir::mono::{Instance, StaticDef};
-use rustc_public::ty::{Allocation, ConstantKind};
-use rustc_public::{CrateItem, CrateItems, ItemKind};
-
-const CRATE_NAME: &str = "input";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_stable_mir() -> ControlFlow<()> {
-    // Find items in the local crate.
-    let items = rustc_public::all_local_items();
-    check_foo(*get_item(&items, (ItemKind::Static, "FOO")).unwrap());
-    check_bar(*get_item(&items, (ItemKind::Static, "BAR")).unwrap());
-    check_len(*get_item(&items, (ItemKind::Static, "LEN")).unwrap());
-    check_cstr(*get_item(&items, (ItemKind::Static, "C_STR")).unwrap());
-    check_other_consts(*get_item(&items, (ItemKind::Fn, "other_consts")).unwrap());
-    ControlFlow::Continue(())
-}
-
-/// Check the allocation data for static `FOO`.
-///
-/// ```no_run
-/// static FOO: [&str; 2] = ["hi", "there"];
-/// ```
-fn check_foo(item: CrateItem) {
-    let def = StaticDef::try_from(item).unwrap();
-    let alloc = def.eval_initializer().unwrap();
-    assert_eq!(alloc.provenance.ptrs.len(), 2);
-
-    let alloc_id_0 = alloc.provenance.ptrs[0].1.0;
-    assert_matches!(GlobalAlloc::from(alloc_id_0), GlobalAlloc::Memory(..));
-
-    let alloc_id_1 = alloc.provenance.ptrs[1].1.0;
-    assert_matches!(GlobalAlloc::from(alloc_id_1), GlobalAlloc::Memory(..));
-}
-
-/// Check the allocation data for static `BAR`.
-///
-/// ```no_run
-/// static BAR: &str = "Bar";
-/// ```
-fn check_bar(item: CrateItem) {
-    let def = StaticDef::try_from(item).unwrap();
-    let alloc = def.eval_initializer().unwrap();
-    assert_eq!(alloc.provenance.ptrs.len(), 1);
-
-    let alloc_id_0 = alloc.provenance.ptrs[0].1.0;
-    let GlobalAlloc::Memory(allocation) = GlobalAlloc::from(alloc_id_0) else { unreachable!() };
-    assert_eq!(allocation.bytes.len(), 3);
-    assert_eq!(allocation.bytes[0].unwrap(), Char::CapitalB.to_u8());
-    assert_eq!(allocation.bytes[1].unwrap(), Char::SmallA.to_u8());
-    assert_eq!(allocation.bytes[2].unwrap(), Char::SmallR.to_u8());
-    assert_eq!(std::str::from_utf8(&allocation.raw_bytes().unwrap()), Ok("Bar"));
-}
-
-/// Check the allocation data for static `C_STR`.
-///
-/// ```no_run
-/// static C_STR: &core::ffi::cstr = c"cstr";
-/// ```
-fn check_cstr(item: CrateItem) {
-    let def = StaticDef::try_from(item).unwrap();
-    let alloc = def.eval_initializer().unwrap();
-    assert_eq!(alloc.provenance.ptrs.len(), 1);
-    let deref = item.ty().kind().builtin_deref(true).unwrap();
-    assert!(deref.ty.kind().is_cstr(), "Expected CStr, but got: {:?}", item.ty());
-
-    let alloc_id_0 = alloc.provenance.ptrs[0].1.0;
-    let GlobalAlloc::Memory(allocation) = GlobalAlloc::from(alloc_id_0) else { unreachable!() };
-    assert_eq!(allocation.bytes.len(), 5);
-    assert_eq!(CStr::from_bytes_until_nul(&allocation.raw_bytes().unwrap()), Ok(c"cstr"));
-}
-
-/// Check the allocation data for constants used in `other_consts` function.
-fn check_other_consts(item: CrateItem) {
-    // Instance body will force constant evaluation.
-    let body = Instance::try_from(item).unwrap().body().unwrap();
-    let assigns = collect_consts(&body);
-    assert_eq!(assigns.len(), 10);
-    let mut char_id = None;
-    let mut bool_id = None;
-    for (name, alloc) in assigns {
-        match name.as_str() {
-            "_max_u128" => {
-                assert_eq!(alloc.read_uint(), Ok(u128::MAX), "Failed parsing allocation: {alloc:?}")
-            }
-            "_min_i128" => {
-                assert_eq!(alloc.read_int(), Ok(i128::MIN), "Failed parsing allocation: {alloc:?}")
-            }
-            "_max_i8" => {
-                assert_eq!(
-                    alloc.read_int().unwrap() as i8,
-                    i8::MAX,
-                    "Failed parsing allocation: {alloc:?}"
-                )
-            }
-            "_char" => {
-                assert_eq!(
-                    char::from_u32(alloc.read_uint().unwrap() as u32),
-                    Some('x'),
-                    "Failed parsing allocation: {alloc:?}"
-                )
-            }
-            "_false" => {
-                assert_eq!(alloc.read_bool(), Ok(false), "Failed parsing allocation: {alloc:?}")
-            }
-            "_true" => {
-                assert_eq!(alloc.read_bool(), Ok(true), "Failed parsing allocation: {alloc:?}")
-            }
-            "_ptr" => {
-                assert_eq!(alloc.is_null(), Ok(false), "Failed parsing allocation: {alloc:?}")
-            }
-            "_null_ptr" => {
-                assert_eq!(alloc.is_null(), Ok(true), "Failed parsing allocation: {alloc:?}")
-            }
-            "_tuple" => {
-                // The order of fields is not guaranteed.
-                let first = alloc.read_partial_uint(0..4).unwrap();
-                let second = alloc.read_partial_uint(4..8).unwrap();
-                assert_eq!(max(first, second) as u32, u32::MAX);
-                assert_eq!(min(first, second), 10);
-            }
-            "_bool_id" => {
-                bool_id = Some(alloc);
-            }
-            "_char_id" => {
-                char_id = Some(alloc);
-            }
-            _ => {
-                unreachable!("{name} -- {alloc:?}")
-            }
-        }
-    }
-    let bool_id = bool_id.unwrap();
-    let char_id = char_id.unwrap();
-    // FIXME(rustc_public): add `read_ptr` to `Allocation`
-    assert_ne!(bool_id, char_id);
-}
-
-/// Collects all the constant assignments.
-pub fn collect_consts(body: &Body) -> HashMap<String, &Allocation> {
-    body.var_debug_info
-        .iter()
-        .filter_map(|info| {
-            info.constant().map(|const_op| {
-                let ConstantKind::Allocated(alloc) = const_op.const_.kind() else { unreachable!() };
-                (info.name.clone(), alloc)
-            })
-        })
-        .collect::<HashMap<_, _>>()
-}
-
-/// Check the allocation data for `LEN`.
-///
-/// ```no_run
-/// static LEN: usize = 2;
-/// ```
-fn check_len(item: CrateItem) {
-    let def = StaticDef::try_from(item).unwrap();
-    let alloc = def.eval_initializer().unwrap();
-    assert!(alloc.provenance.ptrs.is_empty());
-    assert_eq!(alloc.read_uint(), Ok(2));
-}
-
-fn get_item<'a>(
-    items: &'a CrateItems,
-    item: (ItemKind, &str),
-) -> Option<&'a rustc_public::CrateItem> {
-    items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1)
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "alloc_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "--edition=2021".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_stable_mir).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-    #![feature(core_intrinsics)]
-    #![expect(internal_features)]
-    use std::intrinsics::type_id;
-
-    static LEN: usize = 2;
-    static FOO: [&str; 2] = ["hi", "there"];
-    static BAR: &str = "Bar";
-    static C_STR: &std::ffi::CStr = c"cstr";
-    const NULL: *const u8 = std::ptr::null();
-    const TUPLE: (u32, u32) = (10, u32::MAX);
-
-    fn other_consts() {{
-        let _max_u128 = u128::MAX;
-        let _min_i128 = i128::MIN;
-        let _max_i8 = i8::MAX;
-        let _char = 'x';
-        let _false = false;
-        let _true = true;
-        let _ptr = &BAR;
-        let _null_ptr: *const u8 = NULL;
-        let _tuple = TUPLE;
-        let _char_id = const {{ type_id::<char>() }};
-        let _bool_id = const {{ type_id::<bool>() }};
-    }}
-
-    pub fn main() {{
-        println!("{{FOO:?}}! {{BAR}}");
-        assert_eq!(FOO.len(), LEN);
-        other_consts();
-    }}"#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_assoc_items.rs b/tests/ui-fulldeps/stable-mir/check_assoc_items.rs
deleted file mode 100644
index 1557991f8ca..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_assoc_items.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-//@ run-pass
-//! Test that users are able to retrieve all associated items from a definition.
-//! definition.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-extern crate rustc_public;
-
-use std::collections::HashSet;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-use rustc_public::ty::*;
-use rustc_public::{CrateDef, *};
-
-const CRATE_NAME: &str = "crate_assoc_items";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_assoc_items() -> ControlFlow<()> {
-    let local_crate = rustc_public::local_crate();
-    check_items(
-        &local_crate.fn_defs(),
-        &[
-            "AStruct::new",
-            "<AStruct as ATrait>::assoc_fn_no_self",
-            "<AStruct as ATrait>::assoc_fn_has_self",
-            "ATrait::rpitit",
-            "ATrait::assoc_fn_has_self",
-            "ATrait::assoc_fn_no_self",
-            "<AStruct as ATrait>::rpitit",
-        ],
-    );
-
-    let local_impls = local_crate.trait_impls();
-    let local_traits = local_crate.trait_decls();
-
-    let trait_assoc_item_defs: Vec<AssocDef> =
-        local_traits[0].associated_items().iter().map(|assoc_item| assoc_item.def_id).collect();
-    check_items(
-        &trait_assoc_item_defs,
-        &[
-            "ATrait::rpitit::{anon_assoc#0}",
-            "ATrait::rpitit",
-            "ATrait::Assoc",
-            "ATrait::assoc_fn_no_self",
-            "ATrait::assoc_fn_has_self",
-        ],
-    );
-
-    let impl_assoc_item_defs: Vec<AssocDef> =
-        local_impls[0].associated_items().iter().map(|assoc_item| assoc_item.def_id).collect();
-    check_items(
-        &impl_assoc_item_defs,
-        &[
-            "<AStruct as ATrait>::rpitit::{anon_assoc#0}",
-            "<AStruct as ATrait>::rpitit",
-            "<AStruct as ATrait>::Assoc",
-            "<AStruct as ATrait>::assoc_fn_no_self",
-            "<AStruct as ATrait>::assoc_fn_has_self",
-        ],
-    );
-
-    ControlFlow::Continue(())
-}
-
-/// Check if the list of definitions matches the expected list.
-/// Note that order doesn't matter.
-fn check_items<T: CrateDef>(items: &[T], expected: &[&str]) {
-    let expected: HashSet<_> = expected.iter().map(|s| s.to_string()).collect();
-    let item_names: HashSet<_> = items.iter().map(|item| item.name()).collect();
-    assert_eq!(item_names, expected);
-}
-
-fn main() {
-    let path = "assoc_items.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_assoc_items).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        #![allow(dead_code, unused_variables)]
-        struct AStruct;
-
-        impl AStruct {{
-            const ASSOC_CONST: &str = "Nina";
-
-            fn new() -> Self {{
-                AStruct{{}}
-            }}
-        }}
-
-        trait ATrait {{
-            type Assoc;
-
-            fn assoc_fn_no_self() {{
-            }}
-
-            fn assoc_fn_has_self(&self) {{
-            }}
-
-            fn rpitit(&self) -> impl std::fmt::Debug {{
-                "ciallo"
-            }}
-        }}
-
-        impl ATrait for AStruct {{
-            type Assoc = u32;
-
-            fn assoc_fn_no_self() {{
-            }}
-
-            fn assoc_fn_has_self(&self) {{
-            }}
-
-            fn rpitit(&self) -> impl std::fmt::Debug {{
-                "ciallo~"
-            }}
-        }}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_attribute.rs b/tests/ui-fulldeps/stable-mir/check_attribute.rs
deleted file mode 100644
index d8807872ec4..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_attribute.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-//@ run-pass
-//! Test information regarding type layout.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-
-#![feature(rustc_private)]
-
-extern crate rustc_hir;
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_public::{CrateDef, CrateItems};
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_stable_mir() -> ControlFlow<()> {
-    // Find items in the local crate.
-    let items = rustc_public::all_local_items();
-
-    test_tool(&items);
-
-    ControlFlow::Continue(())
-}
-
-// Test tool attributes.
-fn test_tool(items: &CrateItems) {
-    let rustfmt_fn = *get_item(&items, "do_not_format").unwrap();
-    let rustfmt_attrs = rustfmt_fn.tool_attrs(&["rustfmt".to_string(), "skip".to_string()]);
-    assert_eq!(rustfmt_attrs[0].as_str(), "#[rustfmt::skip]\n");
-
-    let clippy_fn = *get_item(&items, "complex_fn").unwrap();
-    let clippy_attrs = clippy_fn.tool_attrs(&["clippy".to_string(),
-                                               "cyclomatic_complexity".to_string()]);
-    assert_eq!(clippy_attrs[0].as_str(), "#[clippy::cyclomatic_complexity = \"100\"]\n");
-}
-
-fn get_item<'a>(
-    items: &'a CrateItems,
-    name: &str,
-) -> Option<&'a rustc_public::CrateItem> {
-    items.iter().find(|crate_item| crate_item.name() == name)
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "attribute_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_stable_mir).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        // General metadata applied to the enclosing module or crate.
-        #![crate_type = "lib"]
-
-        // Mixed inner and outer attributes.
-        #[inline]
-        #[deprecated(since = "5.2.0")]
-        fn builtins_fn() {{
-            #![allow(unused_variables)]
-
-            let x = ();
-            let y = ();
-            let z = ();
-        }}
-
-        // A derive attribute to automatically implement a trait.
-        #[derive(Debug, Clone, Copy)]
-        struct Foo(u32);
-
-        // A rustfmt tool attribute.
-        #[rustfmt::skip]
-        fn do_not_format() {{}}
-
-        // A clippy tool attribute.
-        #[clippy::cyclomatic_complexity = "100"]
-        pub fn complex_fn() {{}}
-
-        // A function with many attributes.
-        #[inline]
-        #[allow(unused_variables)]
-        #[allow(dead_code)]
-        #[allow(unused_imports)]
-        fn many_attrs() {{
-            #![allow(clippy::filter_map)]
-            todo!()
-        }}
-        "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_binop.rs b/tests/ui-fulldeps/stable-mir/check_binop.rs
deleted file mode 100644
index aa089a5d125..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_binop.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-//@ run-pass
-//! Test information regarding binary operations.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-
-#![feature(rustc_private)]
-
-extern crate rustc_hir;
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_public::mir::mono::Instance;
-use rustc_public::mir::visit::{Location, MirVisitor};
-use rustc_public::mir::{LocalDecl, Rvalue, Statement, StatementKind, Terminator, TerminatorKind};
-use rustc_public::ty::{RigidTy, TyKind};
-use std::collections::HashSet;
-use std::convert::TryFrom;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-/// This function tests that we can correctly get type information from binary operations.
-fn test_binops() -> ControlFlow<()> {
-    // Find items in the local crate.
-    let items = rustc_public::all_local_items();
-    let mut instances =
-        items.into_iter().map(|item| Instance::try_from(item).unwrap()).collect::<Vec<_>>();
-    while let Some(instance) = instances.pop() {
-        // The test below shouldn't have recursion in it.
-        let Some(body) = instance.body() else {
-            continue;
-        };
-        let mut visitor = Visitor { locals: body.locals(), calls: Default::default() };
-        visitor.visit_body(&body);
-        instances.extend(visitor.calls.into_iter());
-    }
-    ControlFlow::Continue(())
-}
-
-struct Visitor<'a> {
-    locals: &'a [LocalDecl],
-    calls: HashSet<Instance>,
-}
-
-impl<'a> MirVisitor for Visitor<'a> {
-    fn visit_statement(&mut self, stmt: &Statement, _loc: Location) {
-        match &stmt.kind {
-            StatementKind::Assign(place, Rvalue::BinaryOp(op, rhs, lhs)) => {
-                let ret_ty = place.ty(self.locals).unwrap();
-                let op_ty = op.ty(rhs.ty(self.locals).unwrap(), lhs.ty(self.locals).unwrap());
-                assert_eq!(ret_ty, op_ty, "Operation type should match the assigned place type");
-            }
-            _ => {}
-        }
-    }
-
-    fn visit_terminator(&mut self, term: &Terminator, _loc: Location) {
-        match &term.kind {
-            TerminatorKind::Call { func, .. } => {
-                let TyKind::RigidTy(RigidTy::FnDef(def, args)) =
-                    func.ty(self.locals).unwrap().kind()
-                    else {
-                        return;
-                    };
-                self.calls.insert(Instance::resolve(def, &args).unwrap());
-            }
-            _ => {}
-        }
-    }
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "binop_input.rs";
-    generate_input(&path).unwrap();
-    let args = &["rustc".to_string(), "--crate-type=lib".to_string(), path.to_string()];
-    run!(args, test_binops).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        macro_rules! binop_int {{
-            ($fn:ident, $typ:ty) => {{
-                pub fn $fn(lhs: $typ, rhs: $typ) {{
-                    let eq = lhs == rhs;
-                    let lt = lhs < rhs;
-                    let le = lhs <= rhs;
-
-                    let sum = lhs + rhs;
-                    let mult = lhs * sum;
-                    let shift = mult << 2;
-                    let bit_or = shift | rhs;
-                    let cmp = lhs.cmp(&bit_or);
-
-                    // Try to avoid the results above being pruned
-                    std::hint::black_box(((eq, lt, le), cmp));
-                }}
-            }}
-        }}
-
-        binop_int!(binop_u8, u8);
-        binop_int!(binop_i64, i64);
-
-        pub fn binop_bool(lhs: bool, rhs: bool) {{
-            let eq = lhs == rhs;
-            let or = lhs | eq;
-            let lt = lhs < or;
-            let cmp = lhs.cmp(&rhs);
-
-            // Try to avoid the results above being pruned
-            std::hint::black_box((lt, cmp));
-        }}
-
-        pub fn binop_char(lhs: char, rhs: char) {{
-            let eq = lhs == rhs;
-            let lt = lhs < rhs;
-            let cmp = lhs.cmp(&rhs);
-
-            // Try to avoid the results above being pruned
-            std::hint::black_box(([eq, lt], cmp));
-        }}
-
-        pub fn binop_ptr(lhs: *const char, rhs: *const char) {{
-            let eq = lhs == rhs;
-            let lt = lhs < rhs;
-            let cmp = lhs.cmp(&rhs);
-            let off = unsafe {{ lhs.offset(2) }};
-
-            // Try to avoid the results above being pruned
-            std::hint::black_box(([eq, lt], cmp, off));
-        }}
-        "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_coroutine_body.rs b/tests/ui-fulldeps/stable-mir/check_coroutine_body.rs
deleted file mode 100644
index 725b538b0fe..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_coroutine_body.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-//@ run-pass
-//! Tests stable mir API for retrieving the body of a coroutine.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2024
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use std::io::Write;
-use std::ops::ControlFlow;
-
-use rustc_public::mir::Body;
-use rustc_public::ty::{RigidTy, TyKind};
-
-const CRATE_NAME: &str = "crate_coroutine_body";
-
-fn test_coroutine_body() -> ControlFlow<()> {
-    let crate_items = rustc_public::all_local_items();
-    if let Some(body) = crate_items.iter().find_map(|item| {
-        let item_ty = item.ty();
-        if let TyKind::RigidTy(RigidTy::Coroutine(def, ..)) = &item_ty.kind() {
-            if def.0.name() == "gbc::{closure#0}".to_string() {
-                def.body()
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }) {
-        check_coroutine_body(body);
-    } else {
-        panic!("Cannot find `gbc::{{closure#0}}`. All local items are: {:#?}", crate_items);
-    }
-
-    ControlFlow::Continue(())
-}
-
-fn check_coroutine_body(body: Body) {
-    let ret_ty = &body.locals()[0].ty;
-    let local_3 = &body.locals()[3].ty;
-    let local_4 = &body.locals()[4].ty;
-
-    let TyKind::RigidTy(RigidTy::Adt(def, ..)) = &ret_ty.kind()
-    else {
-        panic!("Expected RigidTy::Adt, got: {:#?}", ret_ty);
-    };
-
-    assert_eq!("std::task::Poll", def.0.name());
-
-    let TyKind::RigidTy(RigidTy::Coroutine(def, ..)) = &local_3.kind()
-    else {
-        panic!("Expected RigidTy::Coroutine, got: {:#?}", local_3);
-    };
-
-    assert_eq!("gbc::{closure#0}::{closure#0}", def.0.name());
-
-    let TyKind::RigidTy(RigidTy::Coroutine(def, ..)) = &local_4.kind()
-    else {
-        panic!("Expected RigidTy::Coroutine, got: {:#?}", local_4);
-    };
-
-    assert_eq!("gbc::{closure#0}::{closure#0}", def.0.name());
-}
-
-fn main() {
-    let path = "coroutine_body.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--edition".to_string(),
-        "2024".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_coroutine_body).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        async fn gbc() -> i32 {{
-            let a = async {{ 1 }}.await;
-            a
-        }}
-
-        fn main() {{}}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_crate_defs.rs b/tests/ui-fulldeps/stable-mir/check_crate_defs.rs
deleted file mode 100644
index 27d5b0bc238..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_crate_defs.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-//@ run-pass
-//! Test information about crate definitions (local and external).
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_hir;
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_public::CrateDef;
-use std::collections::HashSet;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "crate_defs";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_stable_mir() -> ControlFlow<()> {
-    // Find items in the local crate.
-    let local = rustc_public::local_crate();
-    check_items(&local.statics(), &["PRIVATE_STATIC", "dummy::PUBLIC_STATIC"]);
-    check_items(
-        &local.fn_defs(),
-        &[
-            "top_level",
-            "dummy::public_fn",
-            "dummy::private_fn",
-            "dummy::PrivateStruct::new",
-            "<dummy::PrivateStruct as std::ops::Drop>::drop",
-            "DummyTrait::method",
-            "<T as DummyTrait>::method",
-        ],
-    );
-
-    // Find items inside core crate.
-    // FIXME: We are currently missing primitive type methods and trait implementations for external
-    // crates.
-    let core = rustc_public::find_crates("core").pop().expect("Cannot find `core` crate");
-    contains(
-        &core.fn_defs(),
-        &[
-            "std::fmt::Debug::fmt",
-            "std::option::Option::<T>::is_some",
-            "std::ptr::swap",
-            "<std::slice::Iter<'a, T> as std::iter::Iterator>::next",
-            "core::num::<impl u8>::abs_diff",
-        ],
-    );
-    // Ensure nothing crashes. There is no public static in core that we can test here.
-    let _ = core.statics();
-
-    ControlFlow::Continue(())
-}
-
-/// Check if the list of definitions matches the expected list.
-/// Note that order doesn't matter.
-fn check_items<T: CrateDef>(items: &[T], expected: &[&str]) {
-    let expected: HashSet<_> = expected.iter().map(|s| s.to_string()).collect();
-    let item_names: HashSet<_> = items.iter().map(|item| item.name()).collect();
-    assert_eq!(item_names, expected);
-}
-
-/// Check that the list contains the expected items.
-fn contains<T: CrateDef + std::fmt::Debug>(items: &[T], expected: &[&str]) {
-    let expected: HashSet<_> = expected.iter().map(|s| s.to_string()).collect();
-    let item_names = items.iter().map(|item| item.name()).collect();
-    let not_found: Vec<_> = expected.difference(&item_names).collect();
-    assert!(not_found.is_empty(), "Missing items: {:?}", not_found);
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "crate_definitions.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_stable_mir).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        #![allow(dead_code, unused_variables)]
-        static PRIVATE_STATIC: u8 = 0;
-        fn top_level() -> &'static str {{
-            "hello"
-        }}
-
-        pub trait DummyTrait {{
-            fn method(&self) -> Self;
-        }}
-
-        impl<T: Copy> DummyTrait for T {{
-            fn method(&self) -> T {{
-                *self
-            }}
-        }}
-
-        pub mod dummy {{
-            pub static mut PUBLIC_STATIC: Option<char> = None;
-
-            pub fn public_fn(input: bool) -> bool {{
-                private_fn(!input)
-            }}
-
-            fn private_fn(input: bool) -> bool {{
-                todo!()
-            }}
-
-            struct PrivateStruct {{
-                field: u32,
-            }}
-
-            impl PrivateStruct {{
-                fn new() -> Self {{
-                    Self {{ field: 42 }}
-                }}
-            }}
-
-            impl Drop for PrivateStruct {{
-                fn drop(&mut self) {{
-                    println!("Dropping PrivateStruct");
-                }}
-            }}
-        }}
-        "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_def_ty.rs b/tests/ui-fulldeps/stable-mir/check_def_ty.rs
deleted file mode 100644
index b5954352dc0..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_def_ty.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-//@ run-pass
-//! Test that users are able to use stable mir APIs to retrieve type information from a crate item
-//! definition.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-extern crate rustc_public;
-
-use rustc_public::ty::{Ty, ForeignItemKind};
-use rustc_public::*;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "crate_def_ty";
-
-/// Test if we can retrieve type information from different definitions.
-fn test_def_tys() -> ControlFlow<()> {
-    let items = rustc_public::all_local_items();
-    for item in &items {
-        // Type from crate items.
-        let ty = item.ty();
-        match item.name().as_str() {
-            "STATIC_STR" => assert!(ty.kind().is_ref()),
-            "CONST_U32" => assert!(ty.kind().is_integral()),
-            "main" => { check_fn_def(ty) }
-            _ => unreachable!("Unexpected item: `{item:?}`")
-        }
-    }
-
-    let foreign_items = rustc_public::local_crate().foreign_modules();
-    for item in foreign_items[0].module().items() {
-        // Type from foreign items.
-        let ty = item.ty();
-        let item_kind = item.kind();
-        let name = item.name();
-        match item_kind {
-            ForeignItemKind::Fn(fn_def) => {
-                assert_eq!(&name, "extern_fn");
-                assert_eq!(ty, fn_def.ty());
-                check_fn_def(ty)
-            }
-            ForeignItemKind::Static(def) => {
-                assert_eq!(&name, "EXT_STATIC");
-                assert_eq!(ty, def.ty());
-                assert!(ty.kind().is_integral())
-            }
-            _ => unreachable!("Unexpected kind: {item_kind:?}")
-        };
-    }
-
-    ControlFlow::Continue(())
-}
-
-fn check_fn_def(ty: Ty) {
-    let kind = ty.kind();
-    let (def, args) = kind.fn_def().expect(&format!("Expected function type, but found: {ty}"));
-    assert!(def.ty().kind().is_fn());
-    assert_eq!(def.ty_with_args(args), ty);
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "defs_ty_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_def_tys).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        // We would like to check intrinsic definition.
-        #![feature(core_intrinsics)]
-        static STATIC_STR: &str = "foo";
-        const CONST_U32: u32 = 0u32;
-
-        fn main() {{
-            let _c = core::char::from_u32(99);
-            let _v = Vec::<u8>::new();
-            let _i = std::intrinsics::size_of::<u8>();
-        }}
-
-        extern "C" {{
-            fn extern_fn(x: i32) -> i32;
-            static EXT_STATIC: i32;
-        }}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_defs.rs b/tests/ui-fulldeps/stable-mir/check_defs.rs
deleted file mode 100644
index 5e45f19cac8..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_defs.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-//@ run-pass
-//! Test that users are able to use stable mir APIs to retrieve information about crate definitions.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-extern crate rustc_public;
-
-use std::assert_matches::assert_matches;
-use mir::{mono::Instance, TerminatorKind::*};
-use rustc_public::mir::mono::InstanceKind;
-use rustc_public::ty::{RigidTy, TyKind, Ty, UintTy};
-use rustc_public::*;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_stable_mir() -> ControlFlow<()> {
-    let entry = rustc_public::entry_fn().unwrap();
-    let main_fn = Instance::try_from(entry).unwrap();
-    assert_eq!(main_fn.name(), "main");
-    assert_eq!(main_fn.trimmed_name(), "main");
-
-    let instances = get_instances(main_fn.body().unwrap());
-    assert_eq!(instances.len(), 3);
-    test_fn(instances[0], "from_u32", "std::char::from_u32", "core");
-    test_fn(instances[1], "Vec::<u8>::new", "std::vec::Vec::<u8>::new", "alloc");
-    test_fn(instances[2], "ctpop::<u8>", "std::intrinsics::ctpop::<u8>", "core");
-    test_vec_new(instances[1]);
-    ControlFlow::Continue(())
-}
-
-fn test_fn(instance: Instance, expected_trimmed: &str, expected_qualified: &str, krate: &str) {
-    let trimmed = instance.trimmed_name();
-    let qualified = instance.name();
-    assert_eq!(&trimmed, expected_trimmed);
-    assert_eq!(&qualified, expected_qualified);
-
-    if instance.kind == InstanceKind::Intrinsic {
-        let intrinsic = instance.intrinsic_name().unwrap();
-        let (trimmed_base, _trimmed_args) = trimmed.split_once("::").unwrap();
-        assert_eq!(intrinsic, trimmed_base);
-        return;
-    }
-    assert!(instance.intrinsic_name().is_none());
-
-    let item = CrateItem::try_from(instance).unwrap();
-    let trimmed = item.trimmed_name();
-    let qualified = item.name();
-    assert_eq!(trimmed, expected_trimmed.replace("u8", "T"));
-    assert_eq!(qualified, expected_qualified.replace("u8", "T"));
-    assert_eq!(&item.krate().name, krate);
-}
-
-fn extract_elem_ty(ty: Ty) -> Ty {
-    match ty.kind() {
-        TyKind::RigidTy(RigidTy::Adt(_, args)) => {
-            *args.0[0].expect_ty()
-        }
-        _ => unreachable!("Expected Vec ADT, but found: {ty:?}")
-    }
-}
-
-/// Check signature and type of `Vec::<u8>::new` and its generic version.
-fn test_vec_new(instance: mir::mono::Instance) {
-    let sig = instance.fn_abi().unwrap();
-    assert_eq!(&sig.args, &[]);
-    let elem_ty = extract_elem_ty(sig.ret.ty);
-    assert_matches!(elem_ty.kind(), TyKind::RigidTy(RigidTy::Uint(UintTy::U8)));
-
-    // Get the signature for Vec::<T>::new.
-    let item = CrateItem::try_from(instance).unwrap();
-    let ty = item.ty();
-    let gen_sig = ty.kind().fn_sig().unwrap().skip_binder();
-    let gen_ty = extract_elem_ty(gen_sig.output());
-    assert_matches!(gen_ty.kind(), TyKind::Param(_));
-}
-
-/// Inspect the instance body
-fn get_instances(body: mir::Body) -> Vec<Instance> {
-    body.blocks.iter().filter_map(|bb| {
-        match &bb.terminator.kind {
-            Call { func, .. } => {
-                let TyKind::RigidTy(ty) = func.ty(body.locals()).unwrap().kind() else { unreachable!
-                () };
-                let RigidTy::FnDef(def, args) = ty else { unreachable!() };
-                Instance::resolve(def, &args).ok()
-            }
-            _ => {
-                None
-            }
-        }
-    }).collect::<Vec<_>>()
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "defs_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_stable_mir).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        #![feature(core_intrinsics)]
-
-        fn main() {{
-            let _c = core::char::from_u32(99);
-            let _v = Vec::<u8>::new();
-            let _i = std::intrinsics::ctpop::<u8>(0);
-        }}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_foreign.rs b/tests/ui-fulldeps/stable-mir/check_foreign.rs
deleted file mode 100644
index 9aee067f41b..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_foreign.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-//@ run-pass
-//! Test retrieval and kinds of foreign items.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-extern crate rustc_span;
-extern crate rustc_public;
-
-use rustc_public::{
-    ty::{Abi, ForeignItemKind},
-    *,
-};
-use std::assert_matches::assert_matches;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_foreign() -> ControlFlow<()> {
-    let mods =
-        local_crate().foreign_modules().into_iter().map(|def| def.module()).collect::<Vec<_>>();
-    assert_eq!(mods.len(), 2);
-
-    let rust_mod = mods.iter().find(|m| matches!(m.abi, Abi::Rust)).unwrap();
-    assert_eq!(rust_mod.items().len(), 1);
-
-    let c_mod = mods.iter().find(|m| matches!(m.abi, Abi::C { .. })).unwrap();
-    let c_items = c_mod.items();
-    assert_eq!(c_items.len(), 3);
-    for item in c_items {
-        let kind = item.kind();
-        match item.name().as_str() {
-            "foo" => assert_matches!(kind, ForeignItemKind::Fn(..)),
-            "bar" => assert_matches!(kind, ForeignItemKind::Static(..)),
-            "Baz" => assert_matches!(kind, ForeignItemKind::Type(..)),
-            name => unreachable!("Unexpected item {name}"),
-        };
-    }
-    ControlFlow::Continue(())
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "foreign_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-type=lib".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, || test_foreign()).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        #![feature(extern_types)]
-        #![allow(unused)]
-        extern "Rust" {{
-            fn rust_foo(x: i32) -> i32;
-        }}
-        extern "C" {{
-            fn foo(x: i32) -> i32;
-            static bar: i32;
-            type Baz;
-        }}
-        "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_instance.rs b/tests/ui-fulldeps/stable-mir/check_instance.rs
deleted file mode 100644
index 18971076043..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_instance.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-//@ run-pass
-//! Test that users are able to use stable mir APIs to retrieve monomorphized instances
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-extern crate rustc_public;
-
-use std::io::Write;
-use std::ops::ControlFlow;
-
-use mir::mono::Instance;
-use mir::TerminatorKind::*;
-use rustc_public::ty::{RigidTy, TyKind};
-use rustc_public::*;
-
-const CRATE_NAME: &str = "input";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_stable_mir() -> ControlFlow<()> {
-    let items = rustc_public::all_local_items();
-
-    // Get all items and split generic vs monomorphic items.
-    let (generic, mono): (Vec<_>, Vec<_>) =
-        items.into_iter().partition(|item| item.requires_monomorphization());
-    assert_eq!(mono.len(), 3, "Expected 3 mono functions");
-    assert_eq!(generic.len(), 2, "Expected 2 generic functions");
-
-    // For all monomorphic items, get the correspondent instances.
-    let instances = mono
-        .iter()
-        .filter_map(|item| mir::mono::Instance::try_from(*item).ok())
-        .collect::<Vec<mir::mono::Instance>>();
-    assert_eq!(instances.len(), mono.len());
-
-    // For all generic items, try_from should fail.
-    assert!(generic.iter().all(|item| mir::mono::Instance::try_from(*item).is_err()));
-
-    for instance in instances {
-        test_body(instance.body().unwrap())
-    }
-    ControlFlow::Continue(())
-}
-
-/// Inspect the instance body
-fn test_body(body: mir::Body) {
-    for term in body.blocks.iter().map(|bb| &bb.terminator) {
-        match &term.kind {
-            Call { func, .. } => {
-                let TyKind::RigidTy(ty) = func.ty(body.locals()).unwrap().kind() else {
-                    unreachable!()
-                };
-                let RigidTy::FnDef(def, args) = ty else { unreachable!() };
-                let instance = Instance::resolve(def, &args).unwrap();
-                let mangled_name = instance.mangled_name();
-                assert!(instance.has_body() || (mangled_name == "setpwent"), "Failed: {func:?}");
-                assert!(instance.has_body() ^ instance.is_foreign_item());
-                if instance.has_body() {
-                    let body = instance.body().unwrap();
-                    assert!(!body.locals().is_empty(), "Body must at least have a return local");
-                }
-            }
-            Goto { .. } | Assert { .. } | SwitchInt { .. } | Return | Drop { .. } => {
-                /* Do nothing */
-            }
-            _ => {
-                unreachable!("Unexpected terminator {term:?}")
-            }
-        }
-    }
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "instance_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-type=lib".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_stable_mir).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-
-    struct Foo(());
-
-    pub fn ty_param<T>(t: &T) -> T where T: Clone {{
-        t.clone()
-    }}
-
-    pub fn const_param<const LEN: usize>(a: [bool; LEN]) -> bool {{
-        LEN > 0 && a[0]
-    }}
-
-    extern "C" {{
-        // Body should not be available.
-        fn setpwent();
-    }}
-
-    pub fn monomorphic() {{
-        Foo(());
-        let v = vec![10];
-        let dup = ty_param(&v);
-        assert_eq!(v, dup);
-        unsafe {{ setpwent() }};
-    }}
-
-    pub mod foo {{
-        pub fn bar_mono(i: i32) -> i64 {{
-            i as i64
-        }}
-    }}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_intrinsics.rs b/tests/ui-fulldeps/stable-mir/check_intrinsics.rs
deleted file mode 100644
index 854ac77956e..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_intrinsics.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-//@ run-pass
-//! Test information regarding intrinsics and ensure we can retrieve the fallback body if it exists.
-//!
-//! This tests relies on the intrinsics implementation, and requires one intrinsic with and one
-//! without a body. It doesn't matter which intrinsic is called here, and feel free to update that
-//! if needed.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-extern crate rustc_hir;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_public::mir::mono::{Instance, InstanceKind};
-use rustc_public::mir::visit::{Location, MirVisitor};
-use rustc_public::mir::{LocalDecl, Terminator, TerminatorKind};
-use rustc_public::ty::{FnDef, GenericArgs, RigidTy, TyKind};
-use std::assert_matches::assert_matches;
-use std::convert::TryFrom;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-/// This function tests that we can correctly get type information from binary operations.
-fn test_intrinsics() -> ControlFlow<()> {
-    // Find items in the local crate.
-    let main_def = rustc_public::all_local_items()[0];
-    let main_instance = Instance::try_from(main_def).unwrap();
-    let main_body = main_instance.body().unwrap();
-    let mut visitor = CallsVisitor { locals: main_body.locals(), calls: Default::default() };
-    visitor.visit_body(&main_body);
-
-    let calls = visitor.calls;
-    assert_eq!(calls.len(), 3, "Expected 3 calls, but found: {calls:?}");
-    for (fn_def, args) in calls.into_iter() {
-        check_instance(&Instance::resolve(fn_def, &args).unwrap());
-        check_def(fn_def);
-    }
-
-    ControlFlow::Continue(())
-}
-
-/// This check is unfortunately tight to the implementation of intrinsics.
-///
-/// We want to ensure that StableMIR can handle intrinsics with and without fallback body:
-/// for intrinsics without a body, obviously we cannot expose anything.
-///
-/// If by any chance this test breaks because you changed how an intrinsic is implemented, please
-/// update the test to invoke a different intrinsic.
-fn check_instance(instance: &Instance) {
-    assert_eq!(instance.kind, InstanceKind::Intrinsic);
-    let name = instance.intrinsic_name().unwrap();
-    if instance.has_body() {
-        let Some(body) = instance.body() else { unreachable!("Expected a body") };
-        assert!(!body.blocks.is_empty());
-        assert_eq!(&name, "select_unpredictable");
-    } else {
-        assert!(instance.body().is_none());
-        assert_matches!(name.as_str(), "size_of_val" | "vtable_size");
-    }
-}
-
-fn check_def(fn_def: FnDef) {
-    assert!(fn_def.is_intrinsic());
-    let intrinsic = fn_def.as_intrinsic().unwrap();
-    assert_eq!(fn_def, intrinsic.into());
-
-    let name = intrinsic.fn_name();
-    match name.as_str() {
-        "select_unpredictable" => {
-            assert!(!intrinsic.must_be_overridden());
-            assert!(fn_def.has_body());
-        }
-        "vtable_size" | "size_of_val" => {
-            assert!(intrinsic.must_be_overridden());
-            assert!(!fn_def.has_body());
-        }
-        _ => unreachable!("Unexpected intrinsic: {}", name),
-    }
-}
-
-struct CallsVisitor<'a> {
-    locals: &'a [LocalDecl],
-    calls: Vec<(FnDef, GenericArgs)>,
-}
-
-impl<'a> MirVisitor for CallsVisitor<'a> {
-    fn visit_terminator(&mut self, term: &Terminator, _loc: Location) {
-        match &term.kind {
-            TerminatorKind::Call { func, .. } => {
-                let TyKind::RigidTy(RigidTy::FnDef(def, args)) =
-                    func.ty(self.locals).unwrap().kind()
-                    else {
-                        return;
-                    };
-                self.calls.push((def, args.clone()));
-            }
-            _ => {}
-        }
-    }
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "binop_input.rs";
-    generate_input(&path).unwrap();
-    let args = &["rustc".to_string(), "--crate-type=lib".to_string(), path.to_string()];
-    run!(args, test_intrinsics).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        #![feature(core_intrinsics)]
-        use std::intrinsics::*;
-        pub fn use_intrinsics(init: bool) -> bool {{
-            let vtable_sz = unsafe {{ vtable_size(0 as *const ()) }};
-            let sz = unsafe {{ size_of_val("hi") }};
-            select_unpredictable(init && sz == 2, false, true)
-        }}
-        "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_item_kind.rs b/tests/ui-fulldeps/stable-mir/check_item_kind.rs
deleted file mode 100644
index 58e740bdaef..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_item_kind.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-//@ run-pass
-//! Test that item kind works as expected.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-extern crate rustc_public;
-
-use rustc_public::*;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_item_kind() -> ControlFlow<()> {
-    let items = rustc_public::all_local_items();
-    assert_eq!(items.len(), 4);
-    // Constructor item.
-    for item in items {
-        let expected_kind = match item.name().as_str() {
-            "Dummy" => ItemKind::Ctor(CtorKind::Fn),
-            "dummy" => ItemKind::Fn,
-            "unit" => ItemKind::Fn,
-            "DUMMY_CONST" => ItemKind::Const,
-            name => unreachable!("Unexpected item {name}"),
-        };
-        assert_eq!(item.kind(), expected_kind, "Mismatched type for {}", item.name());
-    }
-    ControlFlow::Continue(())
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "item_kind_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-type=lib".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_item_kind).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        pub struct Dummy(u32);
-        pub const DUMMY_CONST: Dummy = Dummy(0);
-        pub struct DummyUnit;
-
-        pub fn dummy() -> Dummy {{
-            Dummy(5)
-        }}
-
-        pub fn unit() -> DummyUnit {{
-            DummyUnit
-        }}
-        "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_normalization.rs b/tests/ui-fulldeps/stable-mir/check_normalization.rs
deleted file mode 100644
index aa6a257dac6..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_normalization.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-//@ run-pass
-//! Test that types are normalized in an instance body.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-extern crate rustc_public;
-
-use mir::mono::Instance;
-use ty::{Ty, TyKind, RigidTy};
-use rustc_public::*;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_stable_mir() -> ControlFlow<()> {
-    let items = rustc_public::all_local_items();
-
-    // Get all items and split generic vs monomorphic items.
-    let instances: Vec<_> =
-        items.into_iter().filter_map(|item| (!item.requires_monomorphization()).then(|| {
-            Instance::try_from(item).unwrap()
-        })).collect();
-    assert_eq!(instances.len(), 1, "Expected one constant");
-
-    for instance in instances {
-        check_ty(instance.ty());
-    }
-    ControlFlow::Continue(())
-}
-
-fn check_ty(ty: Ty) {
-    match ty.kind() {
-        TyKind::RigidTy(RigidTy::Adt(def, args)) if def.kind().is_struct() => {
-            // Ensure field type is also normalized
-            def.variants_iter().next().unwrap().fields().into_iter().for_each(|f| {
-                check_ty(f.ty_with_args(&args))
-            });
-        }
-        TyKind::RigidTy(RigidTy::Uint(..)) => {}
-        kind => unreachable!("Unexpected kind: {kind:?}")
-    }
-}
-
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "normalization_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-type=lib".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_stable_mir).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        pub trait Primitive {{
-            type Base;
-        }}
-
-        impl Primitive for char {{
-            type Base = u32;
-        }}
-
-        pub struct Wrapper<T: Primitive>(T::Base);
-        pub type WrapperChar = Wrapper<char>;
-        pub const NULL_CHAR: WrapperChar = Wrapper::<char>(0);
-        "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_trait_queries.rs b/tests/ui-fulldeps/stable-mir/check_trait_queries.rs
deleted file mode 100644
index a6c37883643..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_trait_queries.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-//@ run-pass
-//! Test that users are able to retrieve information about trait declarations and implementations.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_public::CrateDef;
-use std::collections::HashSet;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "trait_test";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_traits() -> ControlFlow<()> {
-    let local_crate = rustc_public::local_crate();
-    let local_traits = local_crate.trait_decls();
-    assert_eq!(local_traits.len(), 1, "Expected `Max` trait, but found {:?}", local_traits);
-    assert_eq!(&local_traits[0].name(), "Max");
-
-    let local_impls = local_crate.trait_impls();
-    let impl_names = local_impls.iter().map(|trait_impl| trait_impl.name()).collect::<HashSet<_>>();
-    assert_impl(&impl_names, "<Positive as Max>");
-    assert_impl(&impl_names, "<Positive as std::marker::Copy>");
-    assert_impl(&impl_names, "<Positive as std::clone::Clone>");
-    assert_impl(&impl_names, "<Positive as std::fmt::Debug>");
-    assert_impl(&impl_names, "<Positive as std::cmp::PartialEq>");
-    assert_impl(&impl_names, "<Positive as std::cmp::Eq>");
-    assert_impl(&impl_names, "<Positive as std::convert::TryFrom<u64>>");
-    assert_impl(&impl_names, "<u64 as Max>");
-    assert_impl(&impl_names, "<impl std::convert::From<Positive> for u64>");
-
-    let all_traits = rustc_public::all_trait_decls();
-    assert!(all_traits.len() > local_traits.len());
-    assert!(
-        local_traits.iter().all(|t| all_traits.contains(t)),
-        "Local: {local_traits:#?}, All: {all_traits:#?}"
-    );
-
-    let all_impls = rustc_public::all_trait_impls();
-    assert!(all_impls.len() > local_impls.len());
-    assert!(
-        local_impls.iter().all(|t| all_impls.contains(t)),
-        "Local: {local_impls:#?}, All: {all_impls:#?}"
-    );
-    ControlFlow::Continue(())
-}
-
-fn assert_impl(impl_names: &HashSet<String>, target: &str) {
-    assert!(
-        impl_names.contains(target),
-        "Failed to find `{target}`. Implementations available: {impl_names:?}",
-    );
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "trait_queries.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_traits).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        use std::convert::TryFrom;
-
-        #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-        pub struct Positive(u64);
-
-        impl TryFrom<u64> for Positive {{
-            type Error = ();
-            fn try_from(val: u64) -> Result<Positive, Self::Error> {{
-                if val > 0 {{ Ok(Positive(val)) }} else {{ Err(()) }}
-            }}
-        }}
-
-        impl From<Positive> for u64 {{
-            fn from(val: Positive) -> u64 {{ val.0 }}
-        }}
-
-        pub trait Max {{
-            fn is_max(&self) -> bool;
-        }}
-
-        impl Max for u64 {{
-            fn is_max(&self) -> bool {{ *self == u64::MAX }}
-        }}
-
-        impl Max for Positive {{
-            fn is_max(&self) -> bool {{ self.0.is_max() }}
-        }}
-
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_transform.rs b/tests/ui-fulldeps/stable-mir/check_transform.rs
deleted file mode 100644
index 3209fcf9ede..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_transform.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-//@ run-pass
-//! Test a few methods to transform StableMIR.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-#![feature(ascii_char, ascii_char_variants)]
-
-extern crate rustc_hir;
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_public::mir::alloc::GlobalAlloc;
-use rustc_public::mir::mono::Instance;
-use rustc_public::mir::{Body, ConstOperand, Operand, Rvalue, StatementKind, TerminatorKind};
-use rustc_public::ty::{ConstantKind, MirConst};
-use rustc_public::{CrateDef, CrateItems, ItemKind};
-use std::convert::TryFrom;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-/// This function uses the Stable MIR APIs to transform the MIR.
-fn test_transform() -> ControlFlow<()> {
-    // Find items in the local crate.
-    let items = rustc_public::all_local_items();
-
-    // Test fn_abi
-    let target_fn = *get_item(&items, (ItemKind::Fn, "dummy")).unwrap();
-    let instance = Instance::try_from(target_fn).unwrap();
-    let body = instance.body().unwrap();
-    check_msg(&body, "oops");
-
-    let new_msg = "new panic message";
-    let new_body = change_panic_msg(body, new_msg);
-    check_msg(&new_body, new_msg);
-
-    ControlFlow::Continue(())
-}
-
-/// Check that the body panic message matches the given message.
-fn check_msg(body: &Body, expected: &str) {
-    let msg = body
-        .blocks
-        .iter()
-        .find_map(|bb| match &bb.terminator.kind {
-            TerminatorKind::Call { args, .. } => {
-                assert_eq!(args.len(), 1, "Expected panic message, but found {args:?}");
-                let msg_const = match &args[0] {
-                    Operand::Constant(msg_const) => msg_const,
-                    Operand::Copy(place) | Operand::Move(place) => {
-                        assert!(place.projection.is_empty());
-                        bb.statements
-                            .iter()
-                            .find_map(|stmt| match &stmt.kind {
-                                StatementKind::Assign(
-                                    destination,
-                                    Rvalue::Use(Operand::Constant(msg_const)),
-                                ) if destination == place => Some(msg_const),
-                                _ => None,
-                            })
-                            .unwrap()
-                    }
-                };
-                let ConstantKind::Allocated(alloc) = msg_const.const_.kind() else {
-                    unreachable!()
-                };
-                assert_eq!(alloc.provenance.ptrs.len(), 1);
-
-                let alloc_prov_id = alloc.provenance.ptrs[0].1.0;
-                let GlobalAlloc::Memory(val) = GlobalAlloc::from(alloc_prov_id) else {
-                    unreachable!()
-                };
-                let bytes = val.raw_bytes().unwrap();
-                Some(std::str::from_utf8(&bytes).unwrap().to_string())
-            }
-            _ => None,
-        })
-        .expect("Failed to find panic message");
-    assert_eq!(&msg, expected);
-}
-
-/// Modify body to use a different panic message.
-fn change_panic_msg(mut body: Body, new_msg: &str) -> Body {
-    for bb in &mut body.blocks {
-        match &mut bb.terminator.kind {
-            TerminatorKind::Call { args, .. } => {
-                let new_const = MirConst::from_str(new_msg);
-                args[0] = Operand::Constant(ConstOperand {
-                    const_: new_const,
-                    span: bb.terminator.span,
-                    user_ty: None,
-                });
-            }
-            _ => {}
-        }
-    }
-    body
-}
-
-fn get_item<'a>(
-    items: &'a CrateItems,
-    item: (ItemKind, &str),
-) -> Option<&'a rustc_public::CrateItem> {
-    items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1)
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "transform_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_transform).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        fn panic_str(msg: &str) {{ panic!("{{}}", msg); }}
-        pub fn dummy() {{
-            panic_str("oops");
-        }}
-        "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_ty_fold.rs b/tests/ui-fulldeps/stable-mir/check_ty_fold.rs
deleted file mode 100644
index 07ef0d2bb50..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_ty_fold.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-//@ run-pass
-//! Test that users are able to use stable mir APIs to retrieve monomorphized types, and that
-//! we have an error handling for trying to instantiate types with incorrect arguments.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_public::mir::{
-    Body, FieldIdx, MirVisitor, Place, ProjectionElem,
-    visit::{Location, PlaceContext},
-};
-use rustc_public::ty::{RigidTy, Ty, TyKind};
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_stable_mir() -> ControlFlow<()> {
-    let main_fn = rustc_public::entry_fn();
-    let body = main_fn.unwrap().expect_body();
-    let mut visitor = PlaceVisitor { body: &body, tested: false };
-    visitor.visit_body(&body);
-    assert!(visitor.tested);
-    ControlFlow::Continue(())
-}
-
-struct PlaceVisitor<'a> {
-    body: &'a Body,
-    /// Used to ensure that the test was reachable. Otherwise this test would vacuously succeed.
-    tested: bool,
-}
-
-/// Check that `wrapper.inner` place projection can be correctly interpreted.
-/// Ensure that instantiation is correct.
-fn check_tys(local_ty: Ty, idx: FieldIdx, expected_ty: Ty) {
-    let TyKind::RigidTy(RigidTy::Adt(def, args)) = local_ty.kind() else { unreachable!() };
-    assert_eq!(def.ty_with_args(&args), local_ty);
-
-    let field_def = &def.variants_iter().next().unwrap().fields()[idx];
-    let field_ty = field_def.ty_with_args(&args);
-    assert_eq!(field_ty, expected_ty);
-
-    // Check that the generic version is different than the instantiated one.
-    let field_ty_gen = field_def.ty();
-    assert_ne!(field_ty_gen, field_ty);
-}
-
-impl<'a> MirVisitor for PlaceVisitor<'a> {
-    fn visit_place(&mut self, place: &Place, _ptx: PlaceContext, _loc: Location) {
-        let start_ty = self.body.locals()[place.local].ty;
-        match place.projection.as_slice() {
-            [ProjectionElem::Field(idx, ty)] => {
-                check_tys(start_ty, *idx, *ty);
-                self.tested = true;
-            }
-            _ => {}
-        }
-    }
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "ty_fold_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_stable_mir).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        struct Wrapper<T: Default> {{
-            pub inner: T
-        }}
-
-        impl<T: Default> Wrapper<T> {{
-            pub fn new() -> Wrapper<T> {{
-                Wrapper {{ inner: T::default() }}
-            }}
-        }}
-
-        fn main() {{
-            let wrapper = Wrapper::<u8>::new();
-            let _inner = wrapper.inner;
-        }}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_variant.rs b/tests/ui-fulldeps/stable-mir/check_variant.rs
deleted file mode 100644
index ebe76bd89d5..00000000000
--- a/tests/ui-fulldeps/stable-mir/check_variant.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-//@ run-pass
-//! Test that users are able to use stable mir APIs to retrieve
-//! discriminant value and type for AdtDef and Coroutine variants
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2024
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use std::io::Write;
-use std::ops::ControlFlow;
-
-use rustc_public::CrateItem;
-use rustc_public::crate_def::CrateDef;
-use rustc_public::mir::{AggregateKind, Rvalue, Statement, StatementKind};
-use rustc_public::ty::{IntTy, RigidTy, Ty};
-
-const CRATE_NAME: &str = "crate_variant_ty";
-
-/// Test if we can retrieve discriminant info for different types.
-fn test_def_tys() -> ControlFlow<()> {
-    check_adt_mono();
-    check_adt_poly();
-    check_adt_poly2();
-
-    ControlFlow::Continue(())
-}
-
-fn check_adt_mono() {
-    let mono = get_fn("mono").expect_body();
-
-    check_statement_is_aggregate_assign(
-        &mono.blocks[0].statements[0],
-        0,
-        RigidTy::Int(IntTy::Isize),
-    );
-    check_statement_is_aggregate_assign(
-        &mono.blocks[1].statements[0],
-        1,
-        RigidTy::Int(IntTy::Isize),
-    );
-    check_statement_is_aggregate_assign(
-        &mono.blocks[2].statements[0],
-        2,
-        RigidTy::Int(IntTy::Isize),
-    );
-}
-
-fn check_adt_poly() {
-    let poly = get_fn("poly").expect_body();
-
-    check_statement_is_aggregate_assign(
-        &poly.blocks[0].statements[0],
-        0,
-        RigidTy::Int(IntTy::Isize),
-    );
-    check_statement_is_aggregate_assign(
-        &poly.blocks[1].statements[0],
-        1,
-        RigidTy::Int(IntTy::Isize),
-    );
-    check_statement_is_aggregate_assign(
-        &poly.blocks[2].statements[0],
-        2,
-        RigidTy::Int(IntTy::Isize),
-    );
-}
-
-fn check_adt_poly2() {
-    let poly = get_fn("poly2").expect_body();
-
-    check_statement_is_aggregate_assign(
-        &poly.blocks[0].statements[0],
-        0,
-        RigidTy::Int(IntTy::Isize),
-    );
-    check_statement_is_aggregate_assign(
-        &poly.blocks[1].statements[0],
-        1,
-        RigidTy::Int(IntTy::Isize),
-    );
-    check_statement_is_aggregate_assign(
-        &poly.blocks[2].statements[0],
-        2,
-        RigidTy::Int(IntTy::Isize),
-    );
-}
-
-fn get_fn(name: &str) -> CrateItem {
-    rustc_public::all_local_items().into_iter().find(|it| it.name().eq(name)).unwrap()
-}
-
-fn check_statement_is_aggregate_assign(
-    statement: &Statement,
-    expected_discr_val: u128,
-    expected_discr_ty: RigidTy,
-) {
-    if let Statement { kind: StatementKind::Assign(_, rvalue), .. } = statement
-        && let Rvalue::Aggregate(aggregate, _) = rvalue
-        && let AggregateKind::Adt(adt_def, variant_idx, ..) = aggregate
-    {
-        let discr = adt_def.discriminant_for_variant(*variant_idx);
-
-        assert_eq!(discr.val, expected_discr_val);
-        assert_eq!(discr.ty, Ty::from_rigid_kind(expected_discr_ty));
-    } else {
-        unreachable!("Unexpected statement");
-    }
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "defs_ty_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_def_tys).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        use std::hint::black_box;
-
-        enum Mono {{
-            A,
-            B(i32),
-            C {{ a: i32, b: u32 }},
-        }}
-
-        enum Poly<T> {{
-            A,
-            B(T),
-            C {{ t: T }},
-        }}
-
-        pub fn main() {{
-            mono();
-            poly();
-            poly2::<i32>(1);
-        }}
-
-        fn mono() {{
-            black_box(Mono::A);
-            black_box(Mono::B(6));
-            black_box(Mono::C {{a: 1, b: 10 }});
-        }}
-
-        fn poly() {{
-            black_box(Poly::<i32>::A);
-            black_box(Poly::B(1i32));
-            black_box(Poly::C {{ t: 1i32 }});
-        }}
-
-        fn poly2<T: Copy>(t: T) {{
-            black_box(Poly::<T>::A);
-            black_box(Poly::B(t));
-            black_box(Poly::C {{ t: t }});
-        }}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/closure-generic-body.rs b/tests/ui-fulldeps/stable-mir/closure-generic-body.rs
deleted file mode 100644
index e5f910fbda1..00000000000
--- a/tests/ui-fulldeps/stable-mir/closure-generic-body.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-//@ run-pass
-//! Tests stable mir API for retrieving the body of a closure.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use std::io::Write;
-use std::ops::ControlFlow;
-
-use rustc_public::mir::{Body, ConstOperand, Operand, TerminatorKind};
-use rustc_public::ty::{FnDef, RigidTy, TyKind};
-
-const CRATE_NAME: &str = "crate_closure_body";
-
-fn test_closure_body() -> ControlFlow<()> {
-    let crate_items = rustc_public::all_local_items();
-    for item in crate_items {
-        let item_ty = item.ty();
-        match &item_ty.kind() {
-            TyKind::RigidTy(RigidTy::Closure(closure_def, _)) => {
-                let closure_body = closure_def.body().unwrap();
-                check_incr_closure_body(closure_body);
-            }
-            _ => {}
-        }
-    }
-
-    ControlFlow::Continue(())
-}
-
-fn check_incr_closure_body(body: Body) {
-    let first_block = &body.blocks[0];
-    let TerminatorKind::Call { func: Operand::Constant(ConstOperand { const_, .. }), .. } =
-        &first_block.terminator.kind
-    else {
-        panic!("expected Call Terminator, got: ");
-    };
-
-    let TyKind::RigidTy(RigidTy::FnDef(FnDef(def_id), ..), ..) = const_.ty().kind() else {
-        panic!("expected FnDef");
-    };
-
-    assert_eq!(def_id.name(), "id");
-}
-
-fn main() {
-    let path = "closure_body.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_closure_body).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        fn id<T>(y: T) -> T {{
-            y
-        }}
-
-        fn main() {{
-            let cl_id= |x| {{
-                id(x)
-            }};
-
-            let _= cl_id(5);
-        }}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/closure_body.rs b/tests/ui-fulldeps/stable-mir/closure_body.rs
deleted file mode 100644
index f5f9f23ad12..00000000000
--- a/tests/ui-fulldeps/stable-mir/closure_body.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-//@ run-pass
-//! Tests stable mir API for retrieving the body of a closure.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use std::io::Write;
-use std::ops::ControlFlow;
-
-use rustc_public::mir::{Body, ConstOperand, Operand, TerminatorKind};
-use rustc_public::ty::{FnDef, RigidTy, TyKind};
-
-const CRATE_NAME: &str = "crate_closure_body";
-
-fn test_closure_body() -> ControlFlow<()> {
-    let crate_items = rustc_public::all_local_items();
-    for item in crate_items {
-        let item_ty = item.ty();
-        match &item_ty.kind() {
-            TyKind::RigidTy(RigidTy::Closure(closure_def, _)) => {
-                let closure_body = closure_def.body().unwrap();
-                check_incr_closure_body(closure_body);
-            }
-            _ => {}
-        }
-    }
-
-    ControlFlow::Continue(())
-}
-
-fn check_incr_closure_body(body: Body) {
-    let first_block = &body.blocks[0];
-    let TerminatorKind::Call { func: Operand::Constant(ConstOperand { const_, .. }), .. } =
-        &first_block.terminator.kind
-    else {
-        panic!("expected Call Terminator, got: ");
-    };
-
-    let TyKind::RigidTy(RigidTy::FnDef(FnDef(def_id), ..), ..) = const_.ty().kind() else {
-        panic!("expected FnDef");
-    };
-
-    assert_eq!(def_id.name(), "incr");
-}
-
-fn main() {
-    let path = "closure_body.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_closure_body).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-        fn incr(y: i32) -> i32 {{
-            y + 1
-        }}
-
-        fn main() {{
-            let cl_incr = |x: i32| {{
-                incr(x)
-            }};
-
-            let _= cl_incr(5);
-        }}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/compilation-result.rs b/tests/ui-fulldeps/stable-mir/compilation-result.rs
deleted file mode 100644
index ed013375c71..00000000000
--- a/tests/ui-fulldeps/stable-mir/compilation-result.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-//@ run-pass
-// Test StableMIR behavior when different results are given
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use std::io::Write;
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "input_compilation_result_test.rs";
-    generate_input(&path).unwrap();
-    let args = &["rustc".to_string(), path.to_string()];
-    test_continue(args);
-    test_break(args);
-    test_failed(args);
-    test_skipped(args);
-    test_captured(args)
-}
-
-fn test_continue(args: &[String]) {
-    let result = run!(args, || ControlFlow::Continue::<(), bool>(true));
-    assert_eq!(result, Ok(true));
-}
-
-fn test_break(args: &[String]) {
-    let result = run!(args, || ControlFlow::Break::<bool, i32>(false));
-    assert_eq!(result, Err(rustc_public::CompilerError::Interrupted(false)));
-}
-
-#[allow(unreachable_code)]
-fn test_skipped(args: &[String]) {
-    let mut args = args.to_vec();
-    args.push("--version".to_string());
-    let result = run!(&args, || unreachable!() as ControlFlow<()>);
-    assert_eq!(result, Err(rustc_public::CompilerError::Skipped));
-}
-
-#[allow(unreachable_code)]
-fn test_failed(args: &[String]) {
-    let mut args = args.to_vec();
-    args.push("--cfg=broken".to_string());
-    let result = run!(&args, || unreachable!() as ControlFlow<()>);
-    assert_eq!(result, Err(rustc_public::CompilerError::Failed));
-}
-
-/// Test that we are able to pass a closure and set the return according to the captured value.
-fn test_captured(args: &[String]) {
-    let captured = "10".to_string();
-    let result = run!(args, || ControlFlow::Continue::<(), usize>(captured.len()));
-    assert_eq!(result, Ok(captured.len()));
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-    // This should trigger a compilation failure when enabled.
-    #[cfg(broken)]
-    mod broken_mod {{
-        fn call_invalid() {{
-            invalid_fn();
-        }}
-    }}
-
-    fn main() {{}}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/crate-info.rs b/tests/ui-fulldeps/stable-mir/crate-info.rs
deleted file mode 100644
index 4f46dff9b82..00000000000
--- a/tests/ui-fulldeps/stable-mir/crate-info.rs
+++ /dev/null
@@ -1,259 +0,0 @@
-//@ run-pass
-// Test that users are able to use stable mir APIs to retrieve information of the current crate
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_hir;
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_hir::def::DefKind;
-use rustc_public::ItemKind;
-use rustc_public::crate_def::CrateDef;
-use rustc_public::mir::mono::Instance;
-use rustc_public::ty::{RigidTy, TyKind};
-use std::assert_matches::assert_matches;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-/// This function uses the Stable MIR APIs to get information about the test crate.
-fn test_stable_mir() -> ControlFlow<()> {
-    // Get the local crate using rustc_public API.
-    let local = rustc_public::local_crate();
-    assert_eq!(&local.name, CRATE_NAME);
-
-    assert_eq!(rustc_public::entry_fn(), None);
-
-    // Find items in the local crate.
-    let items = rustc_public::all_local_items();
-    assert!(get_item(&items, (DefKind::Fn, "foo::bar")).is_some());
-
-    // Find the `std` crate and assert that there is only one of it.
-    assert!(rustc_public::find_crates("std").len() == 1);
-
-    let bar = get_item(&items, (DefKind::Fn, "bar")).unwrap();
-    let body = bar.expect_body();
-    assert_eq!(body.locals().len(), 2);
-    assert_eq!(body.blocks.len(), 1);
-    let block = &body.blocks[0];
-    assert_eq!(block.statements.len(), 1);
-    match &block.statements[0].kind {
-        rustc_public::mir::StatementKind::Assign(..) => {}
-        other => panic!("{other:?}"),
-    }
-    match &block.terminator.kind {
-        rustc_public::mir::TerminatorKind::Return => {}
-        other => panic!("{other:?}"),
-    }
-
-    let foo_bar = get_item(&items, (DefKind::Fn, "foo_bar")).unwrap();
-    let body = foo_bar.expect_body();
-    assert_eq!(body.locals().len(), 5);
-    assert_eq!(body.blocks.len(), 4);
-    let block = &body.blocks[0];
-    match &block.terminator.kind {
-        rustc_public::mir::TerminatorKind::Call { .. } => {}
-        other => panic!("{other:?}"),
-    }
-
-    let types = get_item(&items, (DefKind::Fn, "types")).unwrap();
-    let body = types.expect_body();
-    assert_eq!(body.locals().len(), 6);
-    assert_matches!(
-        body.locals()[0].ty.kind(),
-        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool)
-    );
-    assert_matches!(
-        body.locals()[1].ty.kind(),
-        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool)
-    );
-    assert_matches!(
-        body.locals()[2].ty.kind(),
-        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Char)
-    );
-    assert_matches!(
-        body.locals()[3].ty.kind(),
-        rustc_public::ty::TyKind::RigidTy(
-            rustc_public::ty::RigidTy::Int(rustc_public::ty::IntTy::I32)
-        )
-    );
-    assert_matches!(
-        body.locals()[4].ty.kind(),
-        rustc_public::ty::TyKind::RigidTy(
-            rustc_public::ty::RigidTy::Uint(rustc_public::ty::UintTy::U64)
-        )
-    );
-    assert_matches!(
-        body.locals()[5].ty.kind(),
-        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Float(
-            rustc_public::ty::FloatTy::F64
-        ))
-    );
-
-    let drop = get_item(&items, (DefKind::Fn, "drop")).unwrap();
-    let body = drop.expect_body();
-    assert_eq!(body.blocks.len(), 2);
-    let block = &body.blocks[0];
-    match &block.terminator.kind {
-        rustc_public::mir::TerminatorKind::Drop { .. } => {}
-        other => panic!("{other:?}"),
-    }
-
-    let assert = get_item(&items, (DefKind::Fn, "assert")).unwrap();
-    let body = assert.expect_body();
-    assert_eq!(body.blocks.len(), 2);
-    let block = &body.blocks[0];
-    match &block.terminator.kind {
-        rustc_public::mir::TerminatorKind::Assert { .. } => {}
-        other => panic!("{other:?}"),
-    }
-
-    let monomorphic = get_item(&items, (DefKind::Fn, "monomorphic")).unwrap();
-    let instance = Instance::try_from(monomorphic.clone()).unwrap();
-    for block in instance.body().unwrap().blocks {
-        match &block.terminator.kind {
-            rustc_public::mir::TerminatorKind::Call { func, .. } => {
-                let TyKind::RigidTy(ty) = func.ty(&body.locals()).unwrap().kind() else {
-                    unreachable!()
-                };
-                let RigidTy::FnDef(def, args) = ty else { unreachable!() };
-                let next_func = Instance::resolve(def, &args).unwrap();
-                match next_func.body().unwrap().locals()[1].ty.kind() {
-                    TyKind::RigidTy(RigidTy::Uint(_)) | TyKind::RigidTy(RigidTy::Tuple(_)) => {}
-                    other => panic!("{other:?}"),
-                }
-            }
-            rustc_public::mir::TerminatorKind::Return => {}
-            other => panic!("{other:?}"),
-        }
-    }
-
-    let foo_const = get_item(&items, (DefKind::Const, "FOO")).unwrap();
-    // Ensure we don't panic trying to get the body of a constant.
-    foo_const.expect_body();
-
-    let locals_fn = get_item(&items, (DefKind::Fn, "locals")).unwrap();
-    let body = locals_fn.expect_body();
-    assert_eq!(body.locals().len(), 4);
-    assert_matches!(
-        body.ret_local().ty.kind(),
-        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Char)
-    );
-    assert_eq!(body.arg_locals().len(), 2);
-    assert_matches!(
-        body.arg_locals()[0].ty.kind(),
-        rustc_public::ty::TyKind::RigidTy(
-            rustc_public::ty::RigidTy::Int(rustc_public::ty::IntTy::I32)
-        )
-    );
-    assert_matches!(
-        body.arg_locals()[1].ty.kind(),
-        rustc_public::ty::TyKind::RigidTy(
-            rustc_public::ty::RigidTy::Uint(rustc_public::ty::UintTy::U64)
-        )
-    );
-    assert_eq!(body.inner_locals().len(), 1);
-    // If conditions have an extra inner local to hold their results
-    assert_matches!(
-        body.inner_locals()[0].ty.kind(),
-        rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool)
-    );
-
-    ControlFlow::Continue(())
-}
-
-// Use internal API to find a function in a crate.
-fn get_item<'a>(
-    items: &'a rustc_public::CrateItems,
-    item: (DefKind, &str),
-) -> Option<&'a rustc_public::CrateItem> {
-    items.iter().find(|crate_item| {
-        matches!(
-            (item.0, crate_item.kind()),
-            (DefKind::Fn, ItemKind::Fn) | (DefKind::Const, ItemKind::Const)
-        ) && crate_item.name() == item.1
-    })
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "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_stable_mir).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-    pub const FOO: u32 = 1 + 2;
-
-    fn generic<T, const U: usize>(t: T) -> [(); U] {{
-        _ = t;
-        [(); U]
-    }}
-
-    pub fn monomorphic() {{
-        generic::<(), 5>(());
-        generic::<u32, 0>(45);
-    }}
-
-    mod foo {{
-        pub fn bar(i: i32) -> i64 {{
-            i as i64
-        }}
-    }}
-
-    pub fn bar(x: i32) -> i32 {{
-        x
-    }}
-
-    pub fn foo_bar(x: i32, y: i32) -> i64 {{
-        let x_64 = foo::bar(x);
-        let y_64 = foo::bar(y);
-        x_64.wrapping_add(y_64)
-    }}
-
-    pub fn types(b: bool, _: char, _: i32, _: u64, _: f64) -> bool {{
-        b
-    }}
-
-    pub fn drop(_: String) {{}}
-
-    pub fn assert(x: i32) -> i32 {{
-        x + 1
-    }}
-
-    pub fn locals(a: i32, _: u64) -> char {{
-        if a > 5 {{
-            'a'
-        }} else {{
-            'b'
-        }}
-    }}"#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/projections.rs b/tests/ui-fulldeps/stable-mir/projections.rs
deleted file mode 100644
index 3b360cd2fcf..00000000000
--- a/tests/ui-fulldeps/stable-mir/projections.rs
+++ /dev/null
@@ -1,174 +0,0 @@
-//@ run-pass
-// Tests the Stable MIR projections API
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_hir;
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_public::ItemKind;
-use rustc_public::crate_def::CrateDef;
-use rustc_public::mir::{ProjectionElem, Rvalue, StatementKind};
-use rustc_public::ty::{RigidTy, TyKind, UintTy};
-use std::assert_matches::assert_matches;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-/// Tests projections within Place objects
-fn test_place_projections() -> ControlFlow<()> {
-    let items = rustc_public::all_local_items();
-    let body = get_item(&items, (ItemKind::Fn, "projections")).unwrap().expect_body();
-    assert_eq!(body.blocks.len(), 4);
-    // The first statement assigns `&s.c` to a local. The projections include a deref for `s`, since
-    // `s` is passed as a reference argument, and a field access for field `c`.
-    match &body.blocks[0].statements[0].kind {
-        StatementKind::Assign(
-            place @ rustc_public::mir::Place { local: _, projection: local_proj },
-            Rvalue::Ref(_, _, rustc_public::mir::Place { local: _, projection: r_proj }),
-        ) => {
-            // We can't match on vecs, only on slices. Comparing statements for equality wouldn't be
-            // any easier since we'd then have to add in the expected local and region values
-            // instead of matching on wildcards.
-            assert!(local_proj.is_empty());
-            match &r_proj[..] {
-                // Similarly we can't match against a type, only against its kind.
-                [ProjectionElem::Deref, ProjectionElem::Field(2, ty)] => {
-                    assert_matches!(
-                        ty.kind(),
-                        TyKind::RigidTy(RigidTy::Uint(rustc_public::ty::UintTy::U8))
-                    );
-                    let ty = place.ty(body.locals()).unwrap();
-                    assert_matches!(ty.kind().rigid(), Some(RigidTy::Ref(..)));
-                }
-                other => panic!(
-                    "Unable to match against expected rvalue projection. Expected the projection \
-                     for `s.c`, which is a Deref and u8 Field. Got: {:?}",
-                    other
-                ),
-            };
-        }
-        other => panic!(
-            "Unable to match against expected Assign statement with a Ref rvalue. Expected the \
-             statement to assign `&s.c` to a local. Got: {:?}",
-            other
-        ),
-    };
-    // This statement assigns `slice[1]` to a local. The projections include a deref for `slice`,
-    // since `slice` is a reference, and an index.
-    match &body.blocks[2].statements[0].kind {
-        StatementKind::Assign(
-            place @ rustc_public::mir::Place { local: _, projection: local_proj },
-            Rvalue::Use(rustc_public::mir::Operand::Copy(rustc_public::mir::Place {
-                local: _,
-                projection: r_proj,
-            })),
-        ) => {
-            // We can't match on vecs, only on slices. Comparing for equality wouldn't be any easier
-            // since we'd then have to add in the expected local values instead of matching on
-            // wildcards.
-            assert!(local_proj.is_empty());
-            assert_matches!(r_proj[..], [ProjectionElem::Deref, ProjectionElem::Index(_)]);
-            let ty = place.ty(body.locals()).unwrap();
-            assert_matches!(ty.kind().rigid(), Some(RigidTy::Uint(UintTy::U8)));
-        }
-        other => panic!(
-            "Unable to match against expected Assign statement with a Use rvalue. Expected the \
-             statement to assign `slice[1]` to a local. Got: {:?}",
-            other
-        ),
-    };
-    // The first terminator gets a slice of an array via the Index operation. Specifically it
-    // performs `&vals[1..3]`. There are no projections in this case, the arguments are just locals.
-    match &body.blocks[0].terminator.kind {
-        rustc_public::mir::TerminatorKind::Call { args, .. } =>
-        // We can't match on vecs, only on slices. Comparing for equality wouldn't be any easier
-        // since we'd then have to add in the expected local values instead of matching on
-        // wildcards.
-        {
-            match &args[..] {
-                [
-                    rustc_public::mir::Operand::Move(rustc_public::mir::Place {
-                        local: _,
-                        projection: arg1_proj,
-                    }),
-                    rustc_public::mir::Operand::Move(rustc_public::mir::Place {
-                        local: _,
-                        projection: arg2_proj,
-                    }),
-                ] => {
-                    assert!(arg1_proj.is_empty());
-                    assert!(arg2_proj.is_empty());
-                }
-                other => {
-                    panic!(
-                        "Unable to match against expected arguments to Index call. Expected two \
-                         move operands. Got: {:?}",
-                        other
-                    )
-                }
-            }
-        }
-        other => panic!(
-            "Unable to match against expected Call terminator. Expected a terminator that calls \
-             the Index operation. Got: {:?}",
-            other
-        ),
-    };
-
-    ControlFlow::Continue(())
-}
-
-// Use internal API to find a function in a crate.
-fn get_item<'a>(
-    items: &'a rustc_public::CrateItems,
-    item: (ItemKind, &str),
-) -> Option<&'a rustc_public::CrateItem> {
-    items.iter().find(|crate_item| crate_item.kind() == item.0 && crate_item.name() == item.1)
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "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_place_projections).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-    pub struct Struct1 {{ _a: u8, _b: u16, c: u8 }}
-
-    pub fn projections(s: &Struct1) -> u8 {{
-        let v = &s.c;
-        let vals = [1, 2, 3, 4];
-        let slice = &vals[1..3];
-        v + slice[1]
-    }}"#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/smir_internal.rs b/tests/ui-fulldeps/stable-mir/smir_internal.rs
deleted file mode 100644
index dd70cfe5f5e..00000000000
--- a/tests/ui-fulldeps/stable-mir/smir_internal.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-//@ run-pass
-//! Test that users are able to use retrieve internal constructs from stable ones to help with
-//! the migration.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-extern crate rustc_middle;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_middle::ty::TyCtxt;
-use rustc_public::rustc_internal;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-fn test_translation(tcx: TyCtxt<'_>) -> ControlFlow<()> {
-    let main_fn = rustc_public::entry_fn().unwrap();
-    let body = main_fn.expect_body();
-    let orig_ty = body.locals()[0].ty;
-    let rustc_ty = rustc_internal::internal(tcx, &orig_ty);
-    assert!(rustc_ty.is_unit());
-    ControlFlow::Continue(())
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "internal_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run_with_tcx!(args, test_translation).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-    pub fn main() {{
-    }}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/smir_serde.rs b/tests/ui-fulldeps/stable-mir/smir_serde.rs
deleted file mode 100644
index 31642c6cb94..00000000000
--- a/tests/ui-fulldeps/stable-mir/smir_serde.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//@ run-pass
-//! Test that users are able to use serialize stable MIR constructs.
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-extern crate rustc_middle;
-extern crate serde;
-extern crate serde_json;
-#[macro_use]
-extern crate rustc_public;
-
-use rustc_middle::ty::TyCtxt;
-use serde_json::to_string;
-use rustc_public::mir::Body;
-use std::io::{BufWriter, Write};
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-fn serialize_to_json(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
-    let path = "output.json";
-    let mut writer = BufWriter::new(std::fs::File::create(path).expect("Failed to create path"));
-    let local_crate = rustc_public::local_crate();
-    let items: Vec<Body> =
-        rustc_public::all_local_items().iter().map(|item| item.expect_body()).collect();
-    let crate_data = (local_crate.name, items);
-    writer
-        .write_all(to_string(&crate_data).expect("serde_json failed").as_bytes())
-        .expect("JSON serialization failed");
-    ControlFlow::Continue(())
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "internal_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run_with_tcx!(args, serialize_to_json).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-    pub fn main() {{
-    }}
-    "#
-    )?;
-    Ok(())
-}
diff --git a/tests/ui-fulldeps/stable-mir/smir_visitor.rs b/tests/ui-fulldeps/stable-mir/smir_visitor.rs
deleted file mode 100644
index 66787e2927b..00000000000
--- a/tests/ui-fulldeps/stable-mir/smir_visitor.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-//@ run-pass
-//! Sanity check Stable MIR Visitor
-
-//@ ignore-stage1
-//@ ignore-cross-compile
-//@ ignore-remote
-//@ edition: 2021
-
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-
-extern crate rustc_middle;
-
-extern crate rustc_driver;
-extern crate rustc_interface;
-extern crate rustc_public;
-
-use rustc_public::mir::MirVisitor;
-use rustc_public::mir::MutMirVisitor;
-use rustc_public::*;
-use std::collections::HashSet;
-use std::io::Write;
-use std::ops::ControlFlow;
-
-const CRATE_NAME: &str = "input";
-
-fn test_visitor() -> ControlFlow<()> {
-    let main_fn = rustc_public::entry_fn();
-    let main_body = main_fn.unwrap().expect_body();
-    let main_visitor = TestVisitor::collect(&main_body);
-    assert!(main_visitor.ret_val.is_some());
-    assert!(main_visitor.args.is_empty());
-    assert!(main_visitor.tys.contains(&main_visitor.ret_val.unwrap().ty));
-    assert!(!main_visitor.calls.is_empty());
-
-    let exit_fn = main_visitor.calls.last().unwrap();
-    assert!(exit_fn.mangled_name().contains("exit_fn"), "Unexpected last function: {exit_fn:?}");
-
-    let exit_body = exit_fn.body().unwrap();
-    let exit_visitor = TestVisitor::collect(&exit_body);
-    assert!(exit_visitor.ret_val.is_some());
-    assert_eq!(exit_visitor.args.len(), 1);
-    assert!(exit_visitor.tys.contains(&exit_visitor.ret_val.unwrap().ty));
-    assert!(exit_visitor.tys.contains(&exit_visitor.args[0].ty));
-    ControlFlow::Continue(())
-}
-
-struct TestVisitor<'a> {
-    pub body: &'a mir::Body,
-    pub tys: HashSet<ty::Ty>,
-    pub ret_val: Option<mir::LocalDecl>,
-    pub args: Vec<mir::LocalDecl>,
-    pub calls: Vec<mir::mono::Instance>,
-}
-
-impl<'a> TestVisitor<'a> {
-    fn collect(body: &'a mir::Body) -> TestVisitor<'a> {
-        let mut visitor = TestVisitor {
-            body: &body,
-            tys: Default::default(),
-            ret_val: None,
-            args: vec![],
-            calls: vec![],
-        };
-        visitor.visit_body(&body);
-        visitor
-    }
-}
-
-impl<'a> mir::MirVisitor for TestVisitor<'a> {
-    fn visit_ty(&mut self, ty: &ty::Ty, _location: mir::visit::Location) {
-        self.tys.insert(*ty);
-        self.super_ty(ty)
-    }
-
-    fn visit_ret_decl(&mut self, local: mir::Local, decl: &mir::LocalDecl) {
-        assert!(local == mir::RETURN_LOCAL);
-        assert!(self.ret_val.is_none());
-        self.ret_val = Some(decl.clone());
-        self.super_ret_decl(local, decl);
-    }
-
-    fn visit_arg_decl(&mut self, local: mir::Local, decl: &mir::LocalDecl) {
-        self.args.push(decl.clone());
-        assert_eq!(local, self.args.len());
-        self.super_arg_decl(local, decl);
-    }
-
-    fn visit_terminator(&mut self, term: &mir::Terminator, location: mir::visit::Location) {
-        if let mir::TerminatorKind::Call { func, .. } = &term.kind {
-            let ty::TyKind::RigidTy(ty) = func.ty(self.body.locals()).unwrap().kind() else {
-                unreachable!()
-            };
-            let ty::RigidTy::FnDef(def, args) = ty else { unreachable!() };
-            self.calls.push(mir::mono::Instance::resolve(def, &args).unwrap());
-        }
-        self.super_terminator(term, location);
-    }
-}
-
-fn test_mut_visitor() -> ControlFlow<()> {
-    let main_fn = rustc_public::entry_fn();
-    let mut main_body = main_fn.unwrap().expect_body();
-    let locals = main_body.locals().to_vec();
-    let mut main_visitor = TestMutVisitor::collect(locals);
-    main_visitor.visit_body(&mut main_body);
-    assert!(main_visitor.ret_val.is_some());
-    assert!(main_visitor.args.is_empty());
-    assert!(main_visitor.tys.contains(&main_visitor.ret_val.unwrap().ty));
-    assert!(!main_visitor.calls.is_empty());
-
-    let exit_fn = main_visitor.calls.last().unwrap();
-    assert!(exit_fn.mangled_name().contains("exit_fn"), "Unexpected last function: {exit_fn:?}");
-
-    let mut exit_body = exit_fn.body().unwrap();
-    let locals = exit_body.locals().to_vec();
-    let mut exit_visitor = TestMutVisitor::collect(locals);
-    exit_visitor.visit_body(&mut exit_body);
-    assert!(exit_visitor.ret_val.is_some());
-    assert_eq!(exit_visitor.args.len(), 1);
-    assert!(exit_visitor.tys.contains(&exit_visitor.ret_val.unwrap().ty));
-    assert!(exit_visitor.tys.contains(&exit_visitor.args[0].ty));
-    ControlFlow::Continue(())
-}
-
-struct TestMutVisitor {
-    locals: Vec<mir::LocalDecl>,
-    pub tys: HashSet<ty::Ty>,
-    pub ret_val: Option<mir::LocalDecl>,
-    pub args: Vec<mir::LocalDecl>,
-    pub calls: Vec<mir::mono::Instance>,
-}
-
-impl TestMutVisitor {
-    fn collect(locals: Vec<mir::LocalDecl>) -> TestMutVisitor {
-        let visitor = TestMutVisitor {
-            locals: locals,
-            tys: Default::default(),
-            ret_val: None,
-            args: vec![],
-            calls: vec![],
-        };
-        visitor
-    }
-}
-
-impl mir::MutMirVisitor for TestMutVisitor {
-    fn visit_ty(&mut self, ty: &mut ty::Ty, _location: mir::visit::Location) {
-        self.tys.insert(*ty);
-        self.super_ty(ty)
-    }
-
-    fn visit_ret_decl(&mut self, local: mir::Local, decl: &mut mir::LocalDecl) {
-        assert!(local == mir::RETURN_LOCAL);
-        assert!(self.ret_val.is_none());
-        self.ret_val = Some(decl.clone());
-        self.super_ret_decl(local, decl);
-    }
-
-    fn visit_arg_decl(&mut self, local: mir::Local, decl: &mut mir::LocalDecl) {
-        self.args.push(decl.clone());
-        assert_eq!(local, self.args.len());
-        self.super_arg_decl(local, decl);
-    }
-
-    fn visit_terminator(&mut self, term: &mut mir::Terminator, location: mir::visit::Location) {
-        if let mir::TerminatorKind::Call { func, .. } = &mut term.kind {
-            let ty::TyKind::RigidTy(ty) = func.ty(&self.locals).unwrap().kind() else {
-                unreachable!()
-            };
-            let ty::RigidTy::FnDef(def, args) = ty else { unreachable!() };
-            self.calls.push(mir::mono::Instance::resolve(def, &args).unwrap());
-        }
-        self.super_terminator(term, location);
-    }
-}
-
-/// This test will generate and analyze a dummy crate using the stable mir.
-/// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
-/// it will run the compiler.
-fn main() {
-    let path = "sim_visitor_input.rs";
-    generate_input(&path).unwrap();
-    let args = &[
-        "rustc".to_string(),
-        "-Cpanic=abort".to_string(),
-        "--crate-name".to_string(),
-        CRATE_NAME.to_string(),
-        path.to_string(),
-    ];
-    run!(args, test_visitor).unwrap();
-    run!(args, test_mut_visitor).unwrap();
-}
-
-fn generate_input(path: &str) -> std::io::Result<()> {
-    let mut file = std::fs::File::create(path)?;
-    write!(
-        file,
-        r#"
-    fn main() -> std::process::ExitCode {{
-        let inputs = Inputs::new();
-        let total = inputs.values.iter().sum();
-        exit_fn(total)
-    }}
-
-    fn exit_fn(code: u8) -> std::process::ExitCode {{
-        std::process::ExitCode::from(code)
-    }}
-
-    struct Inputs {{
-        values: [u8; 3],
-    }}
-
-    impl Inputs {{
-        fn new() -> Inputs {{
-            Inputs {{ values: [0, 1, 2] }}
-        }}
-    }}
-    "#
-    )?;
-    Ok(())
-}
-- 
cgit 1.4.1-3-g733a5


From 9a37aab5589ecfe4101b727b2a91c3846a0068cd Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Tue, 15 Jul 2025 13:54:44 +0000
Subject: rename `ui/stable-mir-print`

---
 tests/ui/rustc_public-ir-print/async-closure.rs    |  12 +
 .../ui/rustc_public-ir-print/async-closure.stdout  | 113 +++++
 tests/ui/rustc_public-ir-print/basic_function.rs   |  25 +
 .../ui/rustc_public-ir-print/basic_function.stdout |  87 ++++
 tests/ui/rustc_public-ir-print/operands.rs         |  48 ++
 tests/ui/rustc_public-ir-print/operands.stdout     | 506 +++++++++++++++++++++
 tests/ui/stable-mir-print/async-closure.rs         |  12 -
 tests/ui/stable-mir-print/async-closure.stdout     | 113 -----
 tests/ui/stable-mir-print/basic_function.rs        |  25 -
 tests/ui/stable-mir-print/basic_function.stdout    |  87 ----
 tests/ui/stable-mir-print/operands.rs              |  48 --
 tests/ui/stable-mir-print/operands.stdout          | 506 ---------------------
 12 files changed, 791 insertions(+), 791 deletions(-)
 create mode 100644 tests/ui/rustc_public-ir-print/async-closure.rs
 create mode 100644 tests/ui/rustc_public-ir-print/async-closure.stdout
 create mode 100644 tests/ui/rustc_public-ir-print/basic_function.rs
 create mode 100644 tests/ui/rustc_public-ir-print/basic_function.stdout
 create mode 100644 tests/ui/rustc_public-ir-print/operands.rs
 create mode 100644 tests/ui/rustc_public-ir-print/operands.stdout
 delete mode 100644 tests/ui/stable-mir-print/async-closure.rs
 delete mode 100644 tests/ui/stable-mir-print/async-closure.stdout
 delete mode 100644 tests/ui/stable-mir-print/basic_function.rs
 delete mode 100644 tests/ui/stable-mir-print/basic_function.stdout
 delete mode 100644 tests/ui/stable-mir-print/operands.rs
 delete mode 100644 tests/ui/stable-mir-print/operands.stdout

diff --git a/tests/ui/rustc_public-ir-print/async-closure.rs b/tests/ui/rustc_public-ir-print/async-closure.rs
new file mode 100644
index 00000000000..80f96e09cfc
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/async-closure.rs
@@ -0,0 +1,12 @@
+//@ compile-flags: -Z unpretty=stable-mir --crate-type lib -C panic=abort -Zmir-opt-level=0
+//@ check-pass
+//@ only-x86_64
+//@ edition: 2024
+//@ needs-unwind unwind edges are different with panic=abort
+
+pub fn foo() {
+    let y = 0;
+    let x = async || {
+        let y = y;
+    };
+}
diff --git a/tests/ui/rustc_public-ir-print/async-closure.stdout b/tests/ui/rustc_public-ir-print/async-closure.stdout
new file mode 100644
index 00000000000..31811299722
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/async-closure.stdout
@@ -0,0 +1,113 @@
+// WARNING: This is highly experimental output it's intended for stable-mir developers only.
+// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
+fn foo() -> () {
+    let mut _0: ();
+    let  _1: i32;
+    let  _2: {async closure@$DIR/async-closure.rs:9:13: 9:21};
+    let mut _3: &i32;
+    debug y => _1;
+    debug x => _2;
+    bb0: {
+        StorageLive(_1);
+        _1 = 0_i32;
+        StorageLive(_2);
+        StorageLive(_3);
+        _3 = &_1;
+        _2 = {coroutine-closure@$DIR/async-closure.rs:9:13: 9:21}(move _3);
+        StorageDead(_3);
+        _0 = ();
+        StorageDead(_2);
+        StorageDead(_1);
+        return;
+    }
+}
+fn foo::{closure#0}(_1: &{async closure@$DIR/async-closure.rs:9:13: 9:21}) -> {async closure body@$DIR/async-closure.rs:9:22: 11:6} {
+    let mut _0: {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    let mut _2: &i32;
+    let mut _3: &i32;
+    debug y => (*((*_1).0: &i32));
+    bb0: {
+        StorageLive(_2);
+        _3 = CopyForDeref(((*_1).0: &i32));
+        _2 = &(*_3);
+        _0 = {coroutine@$DIR/async-closure.rs:9:22: 11:6}(move _2);
+        StorageDead(_2);
+        return;
+    }
+}
+fn foo::{closure#0}::{closure#0}(_1: Pin<&mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}>, _2: &mut Context<'_>) -> Poll<()> {
+    let mut _0: Poll<()>;
+    let  _3: i32;
+    let mut _4: &i32;
+    let mut _5: ();
+    let mut _6: &mut Context<'_>;
+    let mut _7: u32;
+    let mut _8: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    let mut _9: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    let mut _10: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    debug _task_context => _6;
+    debug y => (*((*(_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6})).0: &i32));
+    debug y => _3;
+    bb0: {
+        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _7 = discriminant((*_8));
+        switchInt(move _7) -> [0: bb1, 1: bb2, otherwise: bb3];
+    }
+    bb1: {
+        _6 = move _2;
+        StorageLive(_3);
+        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _4 = CopyForDeref(((*_9).0: &i32));
+        _3 = (*_4);
+        _5 = ();
+        StorageDead(_3);
+        _0 = std::task::Poll::Ready(move _5);
+        _10 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        discriminant((*_10) = 1;
+        return;
+    }
+    bb2: {
+        assert(false, `async fn` resumed after completion) -> [success: bb2, unwind unreachable];
+    }
+    bb3: {
+        unreachable;
+    }
+}
+fn foo::{closure#0}::{synthetic#0}(_1: Pin<&mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}>, _2: &mut Context<'_>) -> Poll<()> {
+    let mut _0: Poll<()>;
+    let  _3: i32;
+    let mut _4: &i32;
+    let mut _5: ();
+    let mut _6: &mut Context<'_>;
+    let mut _7: u32;
+    let mut _8: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    let mut _9: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    let mut _10: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
+    debug _task_context => _6;
+    debug y => (*((*(_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6})).0: &i32));
+    debug y => _3;
+    bb0: {
+        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _7 = discriminant((*_8));
+        switchInt(move _7) -> [0: bb1, 1: bb2, otherwise: bb3];
+    }
+    bb1: {
+        _6 = move _2;
+        StorageLive(_3);
+        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        _4 = CopyForDeref(((*_9).0: &i32));
+        _3 = (*_4);
+        _5 = ();
+        StorageDead(_3);
+        _0 = std::task::Poll::Ready(move _5);
+        _10 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
+        discriminant((*_10) = 1;
+        return;
+    }
+    bb2: {
+        assert(false, `async fn` resumed after completion) -> [success: bb2, unwind unreachable];
+    }
+    bb3: {
+        unreachable;
+    }
+}
diff --git a/tests/ui/rustc_public-ir-print/basic_function.rs b/tests/ui/rustc_public-ir-print/basic_function.rs
new file mode 100644
index 00000000000..21469c61f72
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/basic_function.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Z unpretty=stable-mir -Zmir-opt-level=0
+//@ check-pass
+//@ only-x86_64
+//@ needs-unwind unwind edges are different with panic=abort
+
+fn foo(i: i32) -> i32 {
+    i + 1
+}
+
+fn bar(vec: &mut Vec<i32>) -> Vec<i32> {
+    let mut new_vec = vec.clone();
+    new_vec.push(1);
+    new_vec
+}
+
+pub fn demux(input: u8) -> u8 {
+    match input {
+        0 => 10,
+        1 => 6,
+        2 => 8,
+        _ => 0,
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/rustc_public-ir-print/basic_function.stdout b/tests/ui/rustc_public-ir-print/basic_function.stdout
new file mode 100644
index 00000000000..319d9c1dc69
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/basic_function.stdout
@@ -0,0 +1,87 @@
+// WARNING: This is highly experimental output it's intended for stable-mir developers only.
+// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
+fn foo(_1: i32) -> i32 {
+    let mut _0: i32;
+    let mut _2: i32;
+    let mut _3: (i32, bool);
+    debug i => _1;
+    bb0: {
+        StorageLive(_2);
+        _2 = _1;
+        _3 = CheckedAdd(_2, 1_i32);
+        assert(!move (_3.1: bool), "attempt to compute `{} + {}`, which would overflow", move _2, 1_i32) -> [success: bb1, unwind continue];
+    }
+    bb1: {
+        _0 = move (_3.0: i32);
+        StorageDead(_2);
+        return;
+    }
+}
+fn bar(_1: &mut Vec<i32>) -> Vec<i32> {
+    let mut _0: Vec<i32>;
+    let mut _2: Vec<i32>;
+    let mut _3: &Vec<i32>;
+    let  _4: ();
+    let mut _5: &mut Vec<i32>;
+    debug vec => _1;
+    debug new_vec => _2;
+    bb0: {
+        StorageLive(_2);
+        StorageLive(_3);
+        _3 = &(*_1);
+        _2 = <Vec<i32> as Clone>::clone(move _3) -> [return: bb1, unwind continue];
+    }
+    bb1: {
+        StorageDead(_3);
+        StorageLive(_4);
+        StorageLive(_5);
+        _5 = &mut _2;
+        _4 = Vec::<i32>::push(move _5, 1_i32) -> [return: bb2, unwind: bb3];
+    }
+    bb2: {
+        StorageDead(_5);
+        StorageDead(_4);
+        _0 = move _2;
+        StorageDead(_2);
+        return;
+    }
+    bb3: {
+        drop(_2) -> [return: bb4, unwind terminate];
+    }
+    bb4: {
+        resume;
+    }
+}
+fn demux(_1: u8) -> u8 {
+    let mut _0: u8;
+    debug input => _1;
+    bb0: {
+        switchInt(_1) -> [0: bb4, 1: bb3, 2: bb2, otherwise: bb1];
+    }
+    bb1: {
+        _0 = 0_u8;
+        goto -> bb5;
+    }
+    bb2: {
+        _0 = 8_u8;
+        goto -> bb5;
+    }
+    bb3: {
+        _0 = 6_u8;
+        goto -> bb5;
+    }
+    bb4: {
+        _0 = 10_u8;
+        goto -> bb5;
+    }
+    bb5: {
+        return;
+    }
+}
+fn main() -> () {
+    let mut _0: ();
+    bb0: {
+        _0 = ();
+        return;
+    }
+}
diff --git a/tests/ui/rustc_public-ir-print/operands.rs b/tests/ui/rustc_public-ir-print/operands.rs
new file mode 100644
index 00000000000..484ad07cf04
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/operands.rs
@@ -0,0 +1,48 @@
+//@ compile-flags: -Z unpretty=stable-mir --crate-type lib -C panic=abort -Zmir-opt-level=0
+//@ check-pass
+//@ only-x86_64
+//@ needs-unwind unwind edges are different with panic=abort
+//! Check how stable mir pretty printer prints different operands and abort strategy.
+
+pub fn operands(val: u8) {
+    let array = [val; 10];
+    let first = array[0];
+    let last = array[10 - 1];
+    assert_eq!(first, last);
+
+    let reference = &first;
+    let dereferenced = *reference;
+    assert_eq!(dereferenced, first);
+
+    let tuple = (first, last);
+    let (first_again, _) = tuple;
+    let first_again_again = tuple.0;
+    assert_eq!(first_again, first_again_again);
+
+    let length = array.len();
+    let size_of = std::mem::size_of_val(&length);
+    assert_eq!(length, size_of);
+}
+
+pub struct Dummy {
+    c: char,
+    i: i32,
+}
+
+pub enum Ctors {
+    Unit,
+    StructLike { d: Dummy },
+    TupLike(bool),
+}
+
+pub fn more_operands() -> [Ctors; 3] {
+    let dummy = Dummy { c: 'a', i: i32::MIN };
+    let unit = Ctors::Unit;
+    let struct_like = Ctors::StructLike { d: dummy };
+    let tup_like = Ctors::TupLike(false);
+    [unit, struct_like, tup_like]
+}
+
+pub fn closures(x: bool, z: bool) -> impl FnOnce(bool) -> bool {
+    move |y: bool| (x ^ y) || z
+}
diff --git a/tests/ui/rustc_public-ir-print/operands.stdout b/tests/ui/rustc_public-ir-print/operands.stdout
new file mode 100644
index 00000000000..37c5ec1a95e
--- /dev/null
+++ b/tests/ui/rustc_public-ir-print/operands.stdout
@@ -0,0 +1,506 @@
+// WARNING: This is highly experimental output it's intended for stable-mir developers only.
+// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
+fn operands(_1: u8) -> () {
+    let mut _0: ();
+    let  _2: [u8; 10];
+    let mut _3: u8;
+    let  _4: u8;
+    let  _5: usize;
+    let mut _6: bool;
+    let  _7: u8;
+    let  _8: usize;
+    let mut _9: (usize, bool);
+    let mut _10: bool;
+    let  _11: ();
+    let mut _12: (&u8, &u8);
+    let mut _13: &u8;
+    let mut _14: &u8;
+    let  _15: &u8;
+    let  _16: &u8;
+    let mut _17: bool;
+    let mut _18: u8;
+    let mut _19: u8;
+    let mut _20: !;
+    let  _21: core::panicking::AssertKind;
+    let  _22: !;
+    let mut _23: core::panicking::AssertKind;
+    let mut _24: &u8;
+    let  _25: &u8;
+    let mut _26: &u8;
+    let  _27: &u8;
+    let mut _28: Option<Arguments<'_>>;
+    let  _29: &u8;
+    let  _30: u8;
+    let  _31: ();
+    let mut _32: (&u8, &u8);
+    let mut _33: &u8;
+    let mut _34: &u8;
+    let  _35: &u8;
+    let  _36: &u8;
+    let mut _37: bool;
+    let mut _38: u8;
+    let mut _39: u8;
+    let mut _40: !;
+    let  _41: core::panicking::AssertKind;
+    let  _42: !;
+    let mut _43: core::panicking::AssertKind;
+    let mut _44: &u8;
+    let  _45: &u8;
+    let mut _46: &u8;
+    let  _47: &u8;
+    let mut _48: Option<Arguments<'_>>;
+    let  _49: (u8, u8);
+    let mut _50: u8;
+    let mut _51: u8;
+    let  _52: u8;
+    let  _53: u8;
+    let  _54: ();
+    let mut _55: (&u8, &u8);
+    let mut _56: &u8;
+    let mut _57: &u8;
+    let  _58: &u8;
+    let  _59: &u8;
+    let mut _60: bool;
+    let mut _61: u8;
+    let mut _62: u8;
+    let mut _63: !;
+    let  _64: core::panicking::AssertKind;
+    let  _65: !;
+    let mut _66: core::panicking::AssertKind;
+    let mut _67: &u8;
+    let  _68: &u8;
+    let mut _69: &u8;
+    let  _70: &u8;
+    let mut _71: Option<Arguments<'_>>;
+    let  _72: usize;
+    let mut _73: &[u8];
+    let mut _74: &[u8; 10];
+    let  _75: usize;
+    let mut _76: &usize;
+    let  _77: &usize;
+    let  _78: ();
+    let mut _79: (&usize, &usize);
+    let mut _80: &usize;
+    let mut _81: &usize;
+    let  _82: &usize;
+    let  _83: &usize;
+    let mut _84: bool;
+    let mut _85: usize;
+    let mut _86: usize;
+    let mut _87: !;
+    let  _88: core::panicking::AssertKind;
+    let  _89: !;
+    let mut _90: core::panicking::AssertKind;
+    let mut _91: &usize;
+    let  _92: &usize;
+    let mut _93: &usize;
+    let  _94: &usize;
+    let mut _95: Option<Arguments<'_>>;
+    debug val => _1;
+    debug array => _2;
+    debug first => _4;
+    debug last => _7;
+    debug left_val => _15;
+    debug right_val => _16;
+    debug kind => _21;
+    debug reference => _29;
+    debug dereferenced => _30;
+    debug left_val => _35;
+    debug right_val => _36;
+    debug kind => _41;
+    debug tuple => _49;
+    debug first_again => _52;
+    debug first_again_again => _53;
+    debug left_val => _58;
+    debug right_val => _59;
+    debug kind => _64;
+    debug length => _72;
+    debug size_of => _75;
+    debug left_val => _82;
+    debug right_val => _83;
+    debug kind => _88;
+    bb0: {
+        StorageLive(_2);
+        StorageLive(_3);
+        _3 = _1;
+        _2 = [move _3; 10];
+        StorageDead(_3);
+        StorageLive(_4);
+        StorageLive(_5);
+        _5 = 0_usize;
+        _6 = Lt(_5, 10_usize);
+        assert(move _6, "index out of bounds: the length is {} but the index is {}", 10_usize, _5) -> [success: bb1, unwind unreachable];
+    }
+    bb1: {
+        _4 = _2[_5];
+        StorageDead(_5);
+        StorageLive(_7);
+        StorageLive(_8);
+        _9 = CheckedSub(10_usize, 1_usize);
+        assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", 10_usize, 1_usize) -> [success: bb2, unwind unreachable];
+    }
+    bb2: {
+        _8 = move (_9.0: usize);
+        _10 = Lt(_8, 10_usize);
+        assert(move _10, "index out of bounds: the length is {} but the index is {}", 10_usize, _8) -> [success: bb3, unwind unreachable];
+    }
+    bb3: {
+        _7 = _2[_8];
+        StorageDead(_8);
+        StorageLive(_11);
+        StorageLive(_12);
+        StorageLive(_13);
+        _13 = &_4;
+        StorageLive(_14);
+        _14 = &_7;
+        _12 = (move _13, move _14);
+        StorageDead(_14);
+        StorageDead(_13);
+        StorageLive(_15);
+        _15 = (_12.0: &u8);
+        StorageLive(_16);
+        _16 = (_12.1: &u8);
+        StorageLive(_17);
+        StorageLive(_18);
+        _18 = (*_15);
+        StorageLive(_19);
+        _19 = (*_16);
+        _17 = Eq(move _18, move _19);
+        switchInt(move _17) -> [0: bb5, otherwise: bb4];
+    }
+    bb4: {
+        StorageDead(_19);
+        StorageDead(_18);
+        _11 = ();
+        StorageDead(_17);
+        StorageDead(_16);
+        StorageDead(_15);
+        StorageDead(_12);
+        StorageDead(_11);
+        StorageLive(_29);
+        _29 = &_4;
+        StorageLive(_30);
+        _30 = (*_29);
+        StorageLive(_31);
+        StorageLive(_32);
+        StorageLive(_33);
+        _33 = &_30;
+        StorageLive(_34);
+        _34 = &_4;
+        _32 = (move _33, move _34);
+        StorageDead(_34);
+        StorageDead(_33);
+        StorageLive(_35);
+        _35 = (_32.0: &u8);
+        StorageLive(_36);
+        _36 = (_32.1: &u8);
+        StorageLive(_37);
+        StorageLive(_38);
+        _38 = (*_35);
+        StorageLive(_39);
+        _39 = (*_36);
+        _37 = Eq(move _38, move _39);
+        switchInt(move _37) -> [0: bb7, otherwise: bb6];
+    }
+    bb5: {
+        StorageDead(_19);
+        StorageDead(_18);
+        StorageLive(_21);
+        _21 = core::panicking::AssertKind::Eq;
+        StorageLive(_22);
+        StorageLive(_23);
+        _23 = move _21;
+        StorageLive(_24);
+        StorageLive(_25);
+        _25 = &(*_15);
+        _24 = &(*_25);
+        StorageLive(_26);
+        StorageLive(_27);
+        _27 = &(*_16);
+        _26 = &(*_27);
+        StorageLive(_28);
+        _28 = std::option::Option::None;
+        _22 = core::panicking::assert_failed::<u8, u8>(move _23, move _24, move _26, move _28) -> unwind unreachable;
+    }
+    bb6: {
+        StorageDead(_39);
+        StorageDead(_38);
+        _31 = ();
+        StorageDead(_37);
+        StorageDead(_36);
+        StorageDead(_35);
+        StorageDead(_32);
+        StorageDead(_31);
+        StorageLive(_49);
+        StorageLive(_50);
+        _50 = _4;
+        StorageLive(_51);
+        _51 = _7;
+        _49 = (move _50, move _51);
+        StorageDead(_51);
+        StorageDead(_50);
+        StorageLive(_52);
+        _52 = (_49.0: u8);
+        StorageLive(_53);
+        _53 = (_49.0: u8);
+        StorageLive(_54);
+        StorageLive(_55);
+        StorageLive(_56);
+        _56 = &_52;
+        StorageLive(_57);
+        _57 = &_53;
+        _55 = (move _56, move _57);
+        StorageDead(_57);
+        StorageDead(_56);
+        StorageLive(_58);
+        _58 = (_55.0: &u8);
+        StorageLive(_59);
+        _59 = (_55.1: &u8);
+        StorageLive(_60);
+        StorageLive(_61);
+        _61 = (*_58);
+        StorageLive(_62);
+        _62 = (*_59);
+        _60 = Eq(move _61, move _62);
+        switchInt(move _60) -> [0: bb9, otherwise: bb8];
+    }
+    bb7: {
+        StorageDead(_39);
+        StorageDead(_38);
+        StorageLive(_41);
+        _41 = core::panicking::AssertKind::Eq;
+        StorageLive(_42);
+        StorageLive(_43);
+        _43 = move _41;
+        StorageLive(_44);
+        StorageLive(_45);
+        _45 = &(*_35);
+        _44 = &(*_45);
+        StorageLive(_46);
+        StorageLive(_47);
+        _47 = &(*_36);
+        _46 = &(*_47);
+        StorageLive(_48);
+        _48 = std::option::Option::None;
+        _42 = core::panicking::assert_failed::<u8, u8>(move _43, move _44, move _46, move _48) -> unwind unreachable;
+    }
+    bb8: {
+        StorageDead(_62);
+        StorageDead(_61);
+        _54 = ();
+        StorageDead(_60);
+        StorageDead(_59);
+        StorageDead(_58);
+        StorageDead(_55);
+        StorageDead(_54);
+        StorageLive(_72);
+        StorageLive(_73);
+        StorageLive(_74);
+        _74 = &_2;
+        _73 = move _74 as &[u8];
+        StorageDead(_74);
+        _72 = core::slice::<impl [u8]>::len(move _73) -> [return: bb10, unwind unreachable];
+    }
+    bb9: {
+        StorageDead(_62);
+        StorageDead(_61);
+        StorageLive(_64);
+        _64 = core::panicking::AssertKind::Eq;
+        StorageLive(_65);
+        StorageLive(_66);
+        _66 = move _64;
+        StorageLive(_67);
+        StorageLive(_68);
+        _68 = &(*_58);
+        _67 = &(*_68);
+        StorageLive(_69);
+        StorageLive(_70);
+        _70 = &(*_59);
+        _69 = &(*_70);
+        StorageLive(_71);
+        _71 = std::option::Option::None;
+        _65 = core::panicking::assert_failed::<u8, u8>(move _66, move _67, move _69, move _71) -> unwind unreachable;
+    }
+    bb10: {
+        StorageDead(_73);
+        StorageLive(_75);
+        StorageLive(_76);
+        StorageLive(_77);
+        _77 = &_72;
+        _76 = &(*_77);
+        _75 = std::mem::size_of_val::<usize>(move _76) -> [return: bb11, unwind unreachable];
+    }
+    bb11: {
+        StorageDead(_76);
+        StorageDead(_77);
+        StorageLive(_78);
+        StorageLive(_79);
+        StorageLive(_80);
+        _80 = &_72;
+        StorageLive(_81);
+        _81 = &_75;
+        _79 = (move _80, move _81);
+        StorageDead(_81);
+        StorageDead(_80);
+        StorageLive(_82);
+        _82 = (_79.0: &usize);
+        StorageLive(_83);
+        _83 = (_79.1: &usize);
+        StorageLive(_84);
+        StorageLive(_85);
+        _85 = (*_82);
+        StorageLive(_86);
+        _86 = (*_83);
+        _84 = Eq(move _85, move _86);
+        switchInt(move _84) -> [0: bb13, otherwise: bb12];
+    }
+    bb12: {
+        StorageDead(_86);
+        StorageDead(_85);
+        _78 = ();
+        StorageDead(_84);
+        StorageDead(_83);
+        StorageDead(_82);
+        StorageDead(_79);
+        StorageDead(_78);
+        _0 = ();
+        StorageDead(_75);
+        StorageDead(_72);
+        StorageDead(_53);
+        StorageDead(_52);
+        StorageDead(_49);
+        StorageDead(_30);
+        StorageDead(_29);
+        StorageDead(_7);
+        StorageDead(_4);
+        StorageDead(_2);
+        return;
+    }
+    bb13: {
+        StorageDead(_86);
+        StorageDead(_85);
+        StorageLive(_88);
+        _88 = core::panicking::AssertKind::Eq;
+        StorageLive(_89);
+        StorageLive(_90);
+        _90 = move _88;
+        StorageLive(_91);
+        StorageLive(_92);
+        _92 = &(*_82);
+        _91 = &(*_92);
+        StorageLive(_93);
+        StorageLive(_94);
+        _94 = &(*_83);
+        _93 = &(*_94);
+        StorageLive(_95);
+        _95 = std::option::Option::None;
+        _89 = core::panicking::assert_failed::<usize, usize>(move _90, move _91, move _93, move _95) -> unwind unreachable;
+    }
+}
+fn operands::{constant#0}() -> usize {
+    let mut _0: usize;
+    bb0: {
+        _0 = 10_usize;
+        return;
+    }
+}
+fn more_operands() -> [Ctors; 3] {
+    let mut _0: [Ctors; 3];
+    let  _1: Dummy;
+    let  _2: Ctors;
+    let  _3: Ctors;
+    let mut _4: Dummy;
+    let  _5: Ctors;
+    let mut _6: Ctors;
+    let mut _7: Ctors;
+    let mut _8: Ctors;
+    debug dummy => _1;
+    debug unit => _2;
+    debug struct_like => _3;
+    debug tup_like => _5;
+    bb0: {
+        StorageLive(_1);
+        _1 = Dummy('a', core::num::<impl i32>::MIN);
+        StorageLive(_2);
+        _2 = Ctors::Unit;
+        StorageLive(_3);
+        StorageLive(_4);
+        _4 = move _1;
+        _3 = Ctors::StructLike(move _4);
+        StorageDead(_4);
+        StorageLive(_5);
+        _5 = Ctors::TupLike(false);
+        StorageLive(_6);
+        _6 = move _2;
+        StorageLive(_7);
+        _7 = move _3;
+        StorageLive(_8);
+        _8 = move _5;
+        _0 = [move _6, move _7, move _8];
+        StorageDead(_8);
+        StorageDead(_7);
+        StorageDead(_6);
+        StorageDead(_5);
+        StorageDead(_3);
+        StorageDead(_2);
+        StorageDead(_1);
+        return;
+    }
+}
+fn more_operands::{constant#0}() -> usize {
+    let mut _0: usize;
+    bb0: {
+        _0 = 3_usize;
+        return;
+    }
+}
+fn closures(_1: bool, _2: bool) -> {closure@$DIR/operands.rs:47:5: 47:19} {
+    let mut _0: {closure@$DIR/operands.rs:47:5: 47:19};
+    debug x => _1;
+    debug z => _2;
+    bb0: {
+        _0 = {closure@$DIR/operands.rs:47:5: 47:19}(_1, _2);
+        return;
+    }
+}
+fn closures::{closure#0}(_1: {closure@$DIR/operands.rs:47:5: 47:19}, _2: bool) -> bool {
+    let mut _0: bool;
+    let mut _3: bool;
+    let mut _4: bool;
+    let mut _5: bool;
+    debug y => _2;
+    debug x => (_1.0: bool);
+    debug z => (_1.1: bool);
+    bb0: {
+        StorageLive(_3);
+        StorageLive(_4);
+        _4 = (_1.0: bool);
+        StorageLive(_5);
+        _5 = _2;
+        _3 = BitXor(move _4, move _5);
+        switchInt(move _3) -> [0: bb2, otherwise: bb1];
+    }
+    bb1: {
+        StorageDead(_5);
+        StorageDead(_4);
+        _0 = true;
+        goto -> bb3;
+    }
+    bb2: {
+        StorageDead(_5);
+        StorageDead(_4);
+        _0 = (_1.1: bool);
+        goto -> bb3;
+    }
+    bb3: {
+        StorageDead(_3);
+        return;
+    }
+}
+fn Ctors::TupLike(_1: bool) -> Ctors {
+    let mut _0: Ctors;
+    bb0: {
+        _0 = Ctors::TupLike(move _1);
+        return;
+    }
+}
diff --git a/tests/ui/stable-mir-print/async-closure.rs b/tests/ui/stable-mir-print/async-closure.rs
deleted file mode 100644
index 80f96e09cfc..00000000000
--- a/tests/ui/stable-mir-print/async-closure.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ compile-flags: -Z unpretty=stable-mir --crate-type lib -C panic=abort -Zmir-opt-level=0
-//@ check-pass
-//@ only-x86_64
-//@ edition: 2024
-//@ needs-unwind unwind edges are different with panic=abort
-
-pub fn foo() {
-    let y = 0;
-    let x = async || {
-        let y = y;
-    };
-}
diff --git a/tests/ui/stable-mir-print/async-closure.stdout b/tests/ui/stable-mir-print/async-closure.stdout
deleted file mode 100644
index 31811299722..00000000000
--- a/tests/ui/stable-mir-print/async-closure.stdout
+++ /dev/null
@@ -1,113 +0,0 @@
-// WARNING: This is highly experimental output it's intended for stable-mir developers only.
-// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
-fn foo() -> () {
-    let mut _0: ();
-    let  _1: i32;
-    let  _2: {async closure@$DIR/async-closure.rs:9:13: 9:21};
-    let mut _3: &i32;
-    debug y => _1;
-    debug x => _2;
-    bb0: {
-        StorageLive(_1);
-        _1 = 0_i32;
-        StorageLive(_2);
-        StorageLive(_3);
-        _3 = &_1;
-        _2 = {coroutine-closure@$DIR/async-closure.rs:9:13: 9:21}(move _3);
-        StorageDead(_3);
-        _0 = ();
-        StorageDead(_2);
-        StorageDead(_1);
-        return;
-    }
-}
-fn foo::{closure#0}(_1: &{async closure@$DIR/async-closure.rs:9:13: 9:21}) -> {async closure body@$DIR/async-closure.rs:9:22: 11:6} {
-    let mut _0: {async closure body@$DIR/async-closure.rs:9:22: 11:6};
-    let mut _2: &i32;
-    let mut _3: &i32;
-    debug y => (*((*_1).0: &i32));
-    bb0: {
-        StorageLive(_2);
-        _3 = CopyForDeref(((*_1).0: &i32));
-        _2 = &(*_3);
-        _0 = {coroutine@$DIR/async-closure.rs:9:22: 11:6}(move _2);
-        StorageDead(_2);
-        return;
-    }
-}
-fn foo::{closure#0}::{closure#0}(_1: Pin<&mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}>, _2: &mut Context<'_>) -> Poll<()> {
-    let mut _0: Poll<()>;
-    let  _3: i32;
-    let mut _4: &i32;
-    let mut _5: ();
-    let mut _6: &mut Context<'_>;
-    let mut _7: u32;
-    let mut _8: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
-    let mut _9: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
-    let mut _10: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
-    debug _task_context => _6;
-    debug y => (*((*(_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6})).0: &i32));
-    debug y => _3;
-    bb0: {
-        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        _7 = discriminant((*_8));
-        switchInt(move _7) -> [0: bb1, 1: bb2, otherwise: bb3];
-    }
-    bb1: {
-        _6 = move _2;
-        StorageLive(_3);
-        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        _4 = CopyForDeref(((*_9).0: &i32));
-        _3 = (*_4);
-        _5 = ();
-        StorageDead(_3);
-        _0 = std::task::Poll::Ready(move _5);
-        _10 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        discriminant((*_10) = 1;
-        return;
-    }
-    bb2: {
-        assert(false, `async fn` resumed after completion) -> [success: bb2, unwind unreachable];
-    }
-    bb3: {
-        unreachable;
-    }
-}
-fn foo::{closure#0}::{synthetic#0}(_1: Pin<&mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}>, _2: &mut Context<'_>) -> Poll<()> {
-    let mut _0: Poll<()>;
-    let  _3: i32;
-    let mut _4: &i32;
-    let mut _5: ();
-    let mut _6: &mut Context<'_>;
-    let mut _7: u32;
-    let mut _8: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
-    let mut _9: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
-    let mut _10: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6};
-    debug _task_context => _6;
-    debug y => (*((*(_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6})).0: &i32));
-    debug y => _3;
-    bb0: {
-        _8 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        _7 = discriminant((*_8));
-        switchInt(move _7) -> [0: bb1, 1: bb2, otherwise: bb3];
-    }
-    bb1: {
-        _6 = move _2;
-        StorageLive(_3);
-        _9 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        _4 = CopyForDeref(((*_9).0: &i32));
-        _3 = (*_4);
-        _5 = ();
-        StorageDead(_3);
-        _0 = std::task::Poll::Ready(move _5);
-        _10 = CopyForDeref((_1.0: &mut {async closure body@$DIR/async-closure.rs:9:22: 11:6}));
-        discriminant((*_10) = 1;
-        return;
-    }
-    bb2: {
-        assert(false, `async fn` resumed after completion) -> [success: bb2, unwind unreachable];
-    }
-    bb3: {
-        unreachable;
-    }
-}
diff --git a/tests/ui/stable-mir-print/basic_function.rs b/tests/ui/stable-mir-print/basic_function.rs
deleted file mode 100644
index 21469c61f72..00000000000
--- a/tests/ui/stable-mir-print/basic_function.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ compile-flags: -Z unpretty=stable-mir -Zmir-opt-level=0
-//@ check-pass
-//@ only-x86_64
-//@ needs-unwind unwind edges are different with panic=abort
-
-fn foo(i: i32) -> i32 {
-    i + 1
-}
-
-fn bar(vec: &mut Vec<i32>) -> Vec<i32> {
-    let mut new_vec = vec.clone();
-    new_vec.push(1);
-    new_vec
-}
-
-pub fn demux(input: u8) -> u8 {
-    match input {
-        0 => 10,
-        1 => 6,
-        2 => 8,
-        _ => 0,
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/stable-mir-print/basic_function.stdout b/tests/ui/stable-mir-print/basic_function.stdout
deleted file mode 100644
index 319d9c1dc69..00000000000
--- a/tests/ui/stable-mir-print/basic_function.stdout
+++ /dev/null
@@ -1,87 +0,0 @@
-// WARNING: This is highly experimental output it's intended for stable-mir developers only.
-// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
-fn foo(_1: i32) -> i32 {
-    let mut _0: i32;
-    let mut _2: i32;
-    let mut _3: (i32, bool);
-    debug i => _1;
-    bb0: {
-        StorageLive(_2);
-        _2 = _1;
-        _3 = CheckedAdd(_2, 1_i32);
-        assert(!move (_3.1: bool), "attempt to compute `{} + {}`, which would overflow", move _2, 1_i32) -> [success: bb1, unwind continue];
-    }
-    bb1: {
-        _0 = move (_3.0: i32);
-        StorageDead(_2);
-        return;
-    }
-}
-fn bar(_1: &mut Vec<i32>) -> Vec<i32> {
-    let mut _0: Vec<i32>;
-    let mut _2: Vec<i32>;
-    let mut _3: &Vec<i32>;
-    let  _4: ();
-    let mut _5: &mut Vec<i32>;
-    debug vec => _1;
-    debug new_vec => _2;
-    bb0: {
-        StorageLive(_2);
-        StorageLive(_3);
-        _3 = &(*_1);
-        _2 = <Vec<i32> as Clone>::clone(move _3) -> [return: bb1, unwind continue];
-    }
-    bb1: {
-        StorageDead(_3);
-        StorageLive(_4);
-        StorageLive(_5);
-        _5 = &mut _2;
-        _4 = Vec::<i32>::push(move _5, 1_i32) -> [return: bb2, unwind: bb3];
-    }
-    bb2: {
-        StorageDead(_5);
-        StorageDead(_4);
-        _0 = move _2;
-        StorageDead(_2);
-        return;
-    }
-    bb3: {
-        drop(_2) -> [return: bb4, unwind terminate];
-    }
-    bb4: {
-        resume;
-    }
-}
-fn demux(_1: u8) -> u8 {
-    let mut _0: u8;
-    debug input => _1;
-    bb0: {
-        switchInt(_1) -> [0: bb4, 1: bb3, 2: bb2, otherwise: bb1];
-    }
-    bb1: {
-        _0 = 0_u8;
-        goto -> bb5;
-    }
-    bb2: {
-        _0 = 8_u8;
-        goto -> bb5;
-    }
-    bb3: {
-        _0 = 6_u8;
-        goto -> bb5;
-    }
-    bb4: {
-        _0 = 10_u8;
-        goto -> bb5;
-    }
-    bb5: {
-        return;
-    }
-}
-fn main() -> () {
-    let mut _0: ();
-    bb0: {
-        _0 = ();
-        return;
-    }
-}
diff --git a/tests/ui/stable-mir-print/operands.rs b/tests/ui/stable-mir-print/operands.rs
deleted file mode 100644
index 484ad07cf04..00000000000
--- a/tests/ui/stable-mir-print/operands.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-//@ compile-flags: -Z unpretty=stable-mir --crate-type lib -C panic=abort -Zmir-opt-level=0
-//@ check-pass
-//@ only-x86_64
-//@ needs-unwind unwind edges are different with panic=abort
-//! Check how stable mir pretty printer prints different operands and abort strategy.
-
-pub fn operands(val: u8) {
-    let array = [val; 10];
-    let first = array[0];
-    let last = array[10 - 1];
-    assert_eq!(first, last);
-
-    let reference = &first;
-    let dereferenced = *reference;
-    assert_eq!(dereferenced, first);
-
-    let tuple = (first, last);
-    let (first_again, _) = tuple;
-    let first_again_again = tuple.0;
-    assert_eq!(first_again, first_again_again);
-
-    let length = array.len();
-    let size_of = std::mem::size_of_val(&length);
-    assert_eq!(length, size_of);
-}
-
-pub struct Dummy {
-    c: char,
-    i: i32,
-}
-
-pub enum Ctors {
-    Unit,
-    StructLike { d: Dummy },
-    TupLike(bool),
-}
-
-pub fn more_operands() -> [Ctors; 3] {
-    let dummy = Dummy { c: 'a', i: i32::MIN };
-    let unit = Ctors::Unit;
-    let struct_like = Ctors::StructLike { d: dummy };
-    let tup_like = Ctors::TupLike(false);
-    [unit, struct_like, tup_like]
-}
-
-pub fn closures(x: bool, z: bool) -> impl FnOnce(bool) -> bool {
-    move |y: bool| (x ^ y) || z
-}
diff --git a/tests/ui/stable-mir-print/operands.stdout b/tests/ui/stable-mir-print/operands.stdout
deleted file mode 100644
index 37c5ec1a95e..00000000000
--- a/tests/ui/stable-mir-print/operands.stdout
+++ /dev/null
@@ -1,506 +0,0 @@
-// WARNING: This is highly experimental output it's intended for stable-mir developers only.
-// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
-fn operands(_1: u8) -> () {
-    let mut _0: ();
-    let  _2: [u8; 10];
-    let mut _3: u8;
-    let  _4: u8;
-    let  _5: usize;
-    let mut _6: bool;
-    let  _7: u8;
-    let  _8: usize;
-    let mut _9: (usize, bool);
-    let mut _10: bool;
-    let  _11: ();
-    let mut _12: (&u8, &u8);
-    let mut _13: &u8;
-    let mut _14: &u8;
-    let  _15: &u8;
-    let  _16: &u8;
-    let mut _17: bool;
-    let mut _18: u8;
-    let mut _19: u8;
-    let mut _20: !;
-    let  _21: core::panicking::AssertKind;
-    let  _22: !;
-    let mut _23: core::panicking::AssertKind;
-    let mut _24: &u8;
-    let  _25: &u8;
-    let mut _26: &u8;
-    let  _27: &u8;
-    let mut _28: Option<Arguments<'_>>;
-    let  _29: &u8;
-    let  _30: u8;
-    let  _31: ();
-    let mut _32: (&u8, &u8);
-    let mut _33: &u8;
-    let mut _34: &u8;
-    let  _35: &u8;
-    let  _36: &u8;
-    let mut _37: bool;
-    let mut _38: u8;
-    let mut _39: u8;
-    let mut _40: !;
-    let  _41: core::panicking::AssertKind;
-    let  _42: !;
-    let mut _43: core::panicking::AssertKind;
-    let mut _44: &u8;
-    let  _45: &u8;
-    let mut _46: &u8;
-    let  _47: &u8;
-    let mut _48: Option<Arguments<'_>>;
-    let  _49: (u8, u8);
-    let mut _50: u8;
-    let mut _51: u8;
-    let  _52: u8;
-    let  _53: u8;
-    let  _54: ();
-    let mut _55: (&u8, &u8);
-    let mut _56: &u8;
-    let mut _57: &u8;
-    let  _58: &u8;
-    let  _59: &u8;
-    let mut _60: bool;
-    let mut _61: u8;
-    let mut _62: u8;
-    let mut _63: !;
-    let  _64: core::panicking::AssertKind;
-    let  _65: !;
-    let mut _66: core::panicking::AssertKind;
-    let mut _67: &u8;
-    let  _68: &u8;
-    let mut _69: &u8;
-    let  _70: &u8;
-    let mut _71: Option<Arguments<'_>>;
-    let  _72: usize;
-    let mut _73: &[u8];
-    let mut _74: &[u8; 10];
-    let  _75: usize;
-    let mut _76: &usize;
-    let  _77: &usize;
-    let  _78: ();
-    let mut _79: (&usize, &usize);
-    let mut _80: &usize;
-    let mut _81: &usize;
-    let  _82: &usize;
-    let  _83: &usize;
-    let mut _84: bool;
-    let mut _85: usize;
-    let mut _86: usize;
-    let mut _87: !;
-    let  _88: core::panicking::AssertKind;
-    let  _89: !;
-    let mut _90: core::panicking::AssertKind;
-    let mut _91: &usize;
-    let  _92: &usize;
-    let mut _93: &usize;
-    let  _94: &usize;
-    let mut _95: Option<Arguments<'_>>;
-    debug val => _1;
-    debug array => _2;
-    debug first => _4;
-    debug last => _7;
-    debug left_val => _15;
-    debug right_val => _16;
-    debug kind => _21;
-    debug reference => _29;
-    debug dereferenced => _30;
-    debug left_val => _35;
-    debug right_val => _36;
-    debug kind => _41;
-    debug tuple => _49;
-    debug first_again => _52;
-    debug first_again_again => _53;
-    debug left_val => _58;
-    debug right_val => _59;
-    debug kind => _64;
-    debug length => _72;
-    debug size_of => _75;
-    debug left_val => _82;
-    debug right_val => _83;
-    debug kind => _88;
-    bb0: {
-        StorageLive(_2);
-        StorageLive(_3);
-        _3 = _1;
-        _2 = [move _3; 10];
-        StorageDead(_3);
-        StorageLive(_4);
-        StorageLive(_5);
-        _5 = 0_usize;
-        _6 = Lt(_5, 10_usize);
-        assert(move _6, "index out of bounds: the length is {} but the index is {}", 10_usize, _5) -> [success: bb1, unwind unreachable];
-    }
-    bb1: {
-        _4 = _2[_5];
-        StorageDead(_5);
-        StorageLive(_7);
-        StorageLive(_8);
-        _9 = CheckedSub(10_usize, 1_usize);
-        assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", 10_usize, 1_usize) -> [success: bb2, unwind unreachable];
-    }
-    bb2: {
-        _8 = move (_9.0: usize);
-        _10 = Lt(_8, 10_usize);
-        assert(move _10, "index out of bounds: the length is {} but the index is {}", 10_usize, _8) -> [success: bb3, unwind unreachable];
-    }
-    bb3: {
-        _7 = _2[_8];
-        StorageDead(_8);
-        StorageLive(_11);
-        StorageLive(_12);
-        StorageLive(_13);
-        _13 = &_4;
-        StorageLive(_14);
-        _14 = &_7;
-        _12 = (move _13, move _14);
-        StorageDead(_14);
-        StorageDead(_13);
-        StorageLive(_15);
-        _15 = (_12.0: &u8);
-        StorageLive(_16);
-        _16 = (_12.1: &u8);
-        StorageLive(_17);
-        StorageLive(_18);
-        _18 = (*_15);
-        StorageLive(_19);
-        _19 = (*_16);
-        _17 = Eq(move _18, move _19);
-        switchInt(move _17) -> [0: bb5, otherwise: bb4];
-    }
-    bb4: {
-        StorageDead(_19);
-        StorageDead(_18);
-        _11 = ();
-        StorageDead(_17);
-        StorageDead(_16);
-        StorageDead(_15);
-        StorageDead(_12);
-        StorageDead(_11);
-        StorageLive(_29);
-        _29 = &_4;
-        StorageLive(_30);
-        _30 = (*_29);
-        StorageLive(_31);
-        StorageLive(_32);
-        StorageLive(_33);
-        _33 = &_30;
-        StorageLive(_34);
-        _34 = &_4;
-        _32 = (move _33, move _34);
-        StorageDead(_34);
-        StorageDead(_33);
-        StorageLive(_35);
-        _35 = (_32.0: &u8);
-        StorageLive(_36);
-        _36 = (_32.1: &u8);
-        StorageLive(_37);
-        StorageLive(_38);
-        _38 = (*_35);
-        StorageLive(_39);
-        _39 = (*_36);
-        _37 = Eq(move _38, move _39);
-        switchInt(move _37) -> [0: bb7, otherwise: bb6];
-    }
-    bb5: {
-        StorageDead(_19);
-        StorageDead(_18);
-        StorageLive(_21);
-        _21 = core::panicking::AssertKind::Eq;
-        StorageLive(_22);
-        StorageLive(_23);
-        _23 = move _21;
-        StorageLive(_24);
-        StorageLive(_25);
-        _25 = &(*_15);
-        _24 = &(*_25);
-        StorageLive(_26);
-        StorageLive(_27);
-        _27 = &(*_16);
-        _26 = &(*_27);
-        StorageLive(_28);
-        _28 = std::option::Option::None;
-        _22 = core::panicking::assert_failed::<u8, u8>(move _23, move _24, move _26, move _28) -> unwind unreachable;
-    }
-    bb6: {
-        StorageDead(_39);
-        StorageDead(_38);
-        _31 = ();
-        StorageDead(_37);
-        StorageDead(_36);
-        StorageDead(_35);
-        StorageDead(_32);
-        StorageDead(_31);
-        StorageLive(_49);
-        StorageLive(_50);
-        _50 = _4;
-        StorageLive(_51);
-        _51 = _7;
-        _49 = (move _50, move _51);
-        StorageDead(_51);
-        StorageDead(_50);
-        StorageLive(_52);
-        _52 = (_49.0: u8);
-        StorageLive(_53);
-        _53 = (_49.0: u8);
-        StorageLive(_54);
-        StorageLive(_55);
-        StorageLive(_56);
-        _56 = &_52;
-        StorageLive(_57);
-        _57 = &_53;
-        _55 = (move _56, move _57);
-        StorageDead(_57);
-        StorageDead(_56);
-        StorageLive(_58);
-        _58 = (_55.0: &u8);
-        StorageLive(_59);
-        _59 = (_55.1: &u8);
-        StorageLive(_60);
-        StorageLive(_61);
-        _61 = (*_58);
-        StorageLive(_62);
-        _62 = (*_59);
-        _60 = Eq(move _61, move _62);
-        switchInt(move _60) -> [0: bb9, otherwise: bb8];
-    }
-    bb7: {
-        StorageDead(_39);
-        StorageDead(_38);
-        StorageLive(_41);
-        _41 = core::panicking::AssertKind::Eq;
-        StorageLive(_42);
-        StorageLive(_43);
-        _43 = move _41;
-        StorageLive(_44);
-        StorageLive(_45);
-        _45 = &(*_35);
-        _44 = &(*_45);
-        StorageLive(_46);
-        StorageLive(_47);
-        _47 = &(*_36);
-        _46 = &(*_47);
-        StorageLive(_48);
-        _48 = std::option::Option::None;
-        _42 = core::panicking::assert_failed::<u8, u8>(move _43, move _44, move _46, move _48) -> unwind unreachable;
-    }
-    bb8: {
-        StorageDead(_62);
-        StorageDead(_61);
-        _54 = ();
-        StorageDead(_60);
-        StorageDead(_59);
-        StorageDead(_58);
-        StorageDead(_55);
-        StorageDead(_54);
-        StorageLive(_72);
-        StorageLive(_73);
-        StorageLive(_74);
-        _74 = &_2;
-        _73 = move _74 as &[u8];
-        StorageDead(_74);
-        _72 = core::slice::<impl [u8]>::len(move _73) -> [return: bb10, unwind unreachable];
-    }
-    bb9: {
-        StorageDead(_62);
-        StorageDead(_61);
-        StorageLive(_64);
-        _64 = core::panicking::AssertKind::Eq;
-        StorageLive(_65);
-        StorageLive(_66);
-        _66 = move _64;
-        StorageLive(_67);
-        StorageLive(_68);
-        _68 = &(*_58);
-        _67 = &(*_68);
-        StorageLive(_69);
-        StorageLive(_70);
-        _70 = &(*_59);
-        _69 = &(*_70);
-        StorageLive(_71);
-        _71 = std::option::Option::None;
-        _65 = core::panicking::assert_failed::<u8, u8>(move _66, move _67, move _69, move _71) -> unwind unreachable;
-    }
-    bb10: {
-        StorageDead(_73);
-        StorageLive(_75);
-        StorageLive(_76);
-        StorageLive(_77);
-        _77 = &_72;
-        _76 = &(*_77);
-        _75 = std::mem::size_of_val::<usize>(move _76) -> [return: bb11, unwind unreachable];
-    }
-    bb11: {
-        StorageDead(_76);
-        StorageDead(_77);
-        StorageLive(_78);
-        StorageLive(_79);
-        StorageLive(_80);
-        _80 = &_72;
-        StorageLive(_81);
-        _81 = &_75;
-        _79 = (move _80, move _81);
-        StorageDead(_81);
-        StorageDead(_80);
-        StorageLive(_82);
-        _82 = (_79.0: &usize);
-        StorageLive(_83);
-        _83 = (_79.1: &usize);
-        StorageLive(_84);
-        StorageLive(_85);
-        _85 = (*_82);
-        StorageLive(_86);
-        _86 = (*_83);
-        _84 = Eq(move _85, move _86);
-        switchInt(move _84) -> [0: bb13, otherwise: bb12];
-    }
-    bb12: {
-        StorageDead(_86);
-        StorageDead(_85);
-        _78 = ();
-        StorageDead(_84);
-        StorageDead(_83);
-        StorageDead(_82);
-        StorageDead(_79);
-        StorageDead(_78);
-        _0 = ();
-        StorageDead(_75);
-        StorageDead(_72);
-        StorageDead(_53);
-        StorageDead(_52);
-        StorageDead(_49);
-        StorageDead(_30);
-        StorageDead(_29);
-        StorageDead(_7);
-        StorageDead(_4);
-        StorageDead(_2);
-        return;
-    }
-    bb13: {
-        StorageDead(_86);
-        StorageDead(_85);
-        StorageLive(_88);
-        _88 = core::panicking::AssertKind::Eq;
-        StorageLive(_89);
-        StorageLive(_90);
-        _90 = move _88;
-        StorageLive(_91);
-        StorageLive(_92);
-        _92 = &(*_82);
-        _91 = &(*_92);
-        StorageLive(_93);
-        StorageLive(_94);
-        _94 = &(*_83);
-        _93 = &(*_94);
-        StorageLive(_95);
-        _95 = std::option::Option::None;
-        _89 = core::panicking::assert_failed::<usize, usize>(move _90, move _91, move _93, move _95) -> unwind unreachable;
-    }
-}
-fn operands::{constant#0}() -> usize {
-    let mut _0: usize;
-    bb0: {
-        _0 = 10_usize;
-        return;
-    }
-}
-fn more_operands() -> [Ctors; 3] {
-    let mut _0: [Ctors; 3];
-    let  _1: Dummy;
-    let  _2: Ctors;
-    let  _3: Ctors;
-    let mut _4: Dummy;
-    let  _5: Ctors;
-    let mut _6: Ctors;
-    let mut _7: Ctors;
-    let mut _8: Ctors;
-    debug dummy => _1;
-    debug unit => _2;
-    debug struct_like => _3;
-    debug tup_like => _5;
-    bb0: {
-        StorageLive(_1);
-        _1 = Dummy('a', core::num::<impl i32>::MIN);
-        StorageLive(_2);
-        _2 = Ctors::Unit;
-        StorageLive(_3);
-        StorageLive(_4);
-        _4 = move _1;
-        _3 = Ctors::StructLike(move _4);
-        StorageDead(_4);
-        StorageLive(_5);
-        _5 = Ctors::TupLike(false);
-        StorageLive(_6);
-        _6 = move _2;
-        StorageLive(_7);
-        _7 = move _3;
-        StorageLive(_8);
-        _8 = move _5;
-        _0 = [move _6, move _7, move _8];
-        StorageDead(_8);
-        StorageDead(_7);
-        StorageDead(_6);
-        StorageDead(_5);
-        StorageDead(_3);
-        StorageDead(_2);
-        StorageDead(_1);
-        return;
-    }
-}
-fn more_operands::{constant#0}() -> usize {
-    let mut _0: usize;
-    bb0: {
-        _0 = 3_usize;
-        return;
-    }
-}
-fn closures(_1: bool, _2: bool) -> {closure@$DIR/operands.rs:47:5: 47:19} {
-    let mut _0: {closure@$DIR/operands.rs:47:5: 47:19};
-    debug x => _1;
-    debug z => _2;
-    bb0: {
-        _0 = {closure@$DIR/operands.rs:47:5: 47:19}(_1, _2);
-        return;
-    }
-}
-fn closures::{closure#0}(_1: {closure@$DIR/operands.rs:47:5: 47:19}, _2: bool) -> bool {
-    let mut _0: bool;
-    let mut _3: bool;
-    let mut _4: bool;
-    let mut _5: bool;
-    debug y => _2;
-    debug x => (_1.0: bool);
-    debug z => (_1.1: bool);
-    bb0: {
-        StorageLive(_3);
-        StorageLive(_4);
-        _4 = (_1.0: bool);
-        StorageLive(_5);
-        _5 = _2;
-        _3 = BitXor(move _4, move _5);
-        switchInt(move _3) -> [0: bb2, otherwise: bb1];
-    }
-    bb1: {
-        StorageDead(_5);
-        StorageDead(_4);
-        _0 = true;
-        goto -> bb3;
-    }
-    bb2: {
-        StorageDead(_5);
-        StorageDead(_4);
-        _0 = (_1.1: bool);
-        goto -> bb3;
-    }
-    bb3: {
-        StorageDead(_3);
-        return;
-    }
-}
-fn Ctors::TupLike(_1: bool) -> Ctors {
-    let mut _0: Ctors;
-    bb0: {
-        _0 = Ctors::TupLike(move _1);
-        return;
-    }
-}
-- 
cgit 1.4.1-3-g733a5


From a1deaa7097aa92bfb184824faf30791c03d190f8 Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Tue, 15 Jul 2025 15:58:40 +0000
Subject: `SmirError` to `Error`

---
 compiler/rustc_public/src/alloc.rs                 |  2 +-
 compiler/rustc_public/src/error.rs                 |  4 ++--
 compiler/rustc_public/src/mir/mono.rs              | 26 +++++++++++-----------
 .../src/unstable/convert/stable/mir.rs             |  5 ++---
 .../rustc_public/src/unstable/internal_cx/mod.rs   |  2 +-
 compiler/rustc_public_bridge/src/alloc.rs          |  2 +-
 compiler/rustc_public_bridge/src/bridge.rs         |  2 +-
 compiler/rustc_public_bridge/src/context/impls.rs  |  2 +-
 compiler/rustc_public_bridge/src/context/mod.rs    |  4 ++--
 compiler/rustc_public_bridge/src/lib.rs            |  2 +-
 10 files changed, 25 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_public/src/alloc.rs b/compiler/rustc_public/src/alloc.rs
index cb6cc37e829..dcb3cc0e75f 100644
--- a/compiler/rustc_public/src/alloc.rs
+++ b/compiler/rustc_public/src/alloc.rs
@@ -7,7 +7,7 @@
 use rustc_abi::Align;
 use rustc_middle::mir::ConstValue;
 use rustc_middle::mir::interpret::AllocRange;
-use rustc_public_bridge::bridge::SmirError;
+use rustc_public_bridge::bridge::Error as _;
 use rustc_public_bridge::context::CompilerCtxt;
 use rustc_public_bridge::{Tables, alloc};
 
diff --git a/compiler/rustc_public/src/error.rs b/compiler/rustc_public/src/error.rs
index bc2124d1716..70a74eaa9fb 100644
--- a/compiler/rustc_public/src/error.rs
+++ b/compiler/rustc_public/src/error.rs
@@ -7,7 +7,7 @@
 use std::fmt::{Debug, Display, Formatter};
 use std::{fmt, io};
 
-use rustc_public_bridge::bridge::SmirError;
+use rustc_public_bridge::bridge;
 
 macro_rules! error {
      ($fmt: literal $(,)?) => { Error(format!($fmt)) };
@@ -32,7 +32,7 @@ pub enum CompilerError<T> {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Error(pub(crate) String);
 
-impl SmirError for Error {
+impl bridge::Error for Error {
     fn new(msg: String) -> Self {
         Self(msg)
     }
diff --git a/compiler/rustc_public/src/mir/mono.rs b/compiler/rustc_public/src/mir/mono.rs
index c85f0fa36f7..06f6ac17e7b 100644
--- a/compiler/rustc_public/src/mir/mono.rs
+++ b/compiler/rustc_public/src/mir/mono.rs
@@ -1,7 +1,7 @@
 use std::fmt::{Debug, Formatter};
 use std::io;
 
-use rustc_public_bridge::bridge::SmirError;
+use rustc_public_bridge::bridge;
 use serde::Serialize;
 
 use crate::abi::FnAbi;
@@ -120,9 +120,9 @@ impl Instance {
     /// Resolve an instance starting from a function definition and generic arguments.
     pub fn resolve(def: FnDef, args: &GenericArgs) -> Result<Instance, Error> {
         with(|context| {
-            context
-                .resolve_instance(def, args)
-                .ok_or_else(|| Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`")))
+            context.resolve_instance(def, args).ok_or_else(|| {
+                bridge::Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`"))
+            })
         })
     }
 
@@ -134,9 +134,9 @@ impl Instance {
     /// Resolve an instance for a given function pointer.
     pub fn resolve_for_fn_ptr(def: FnDef, args: &GenericArgs) -> Result<Instance, Error> {
         with(|context| {
-            context
-                .resolve_for_fn_ptr(def, args)
-                .ok_or_else(|| Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`")))
+            context.resolve_for_fn_ptr(def, args).ok_or_else(|| {
+                bridge::Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`"))
+            })
         })
     }
 
@@ -147,9 +147,9 @@ impl Instance {
         kind: ClosureKind,
     ) -> Result<Instance, Error> {
         with(|context| {
-            context
-                .resolve_closure(def, args, kind)
-                .ok_or_else(|| Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`")))
+            context.resolve_closure(def, args, kind).ok_or_else(|| {
+                bridge::Error::new(format!("Failed to resolve `{def:?}` with `{args:?}`"))
+            })
         })
     }
 
@@ -201,7 +201,7 @@ impl TryFrom<CrateItem> for Instance {
             if !context.requires_monomorphization(def_id) {
                 Ok(context.mono_instance(def_id))
             } else {
-                Err(Error::new("Item requires monomorphization".to_string()))
+                Err(bridge::Error::new("Item requires monomorphization".to_string()))
             }
         })
     }
@@ -217,7 +217,7 @@ impl TryFrom<Instance> for CrateItem {
             if value.kind == InstanceKind::Item && context.has_body(value.def.def_id()) {
                 Ok(CrateItem(context.instance_def_id(value.def)))
             } else {
-                Err(Error::new(format!("Item kind `{:?}` cannot be converted", value.kind)))
+                Err(bridge::Error::new(format!("Item kind `{:?}` cannot be converted", value.kind)))
             }
         })
     }
@@ -263,7 +263,7 @@ impl TryFrom<CrateItem> for StaticDef {
         if matches!(value.kind(), ItemKind::Static) {
             Ok(StaticDef(value.0))
         } else {
-            Err(Error::new(format!("Expected a static item, but found: {value:?}")))
+            Err(bridge::Error::new(format!("Expected a static item, but found: {value:?}")))
         }
     }
 }
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
index cb68129c660..8dee579e598 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/mir.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
@@ -2,9 +2,8 @@
 
 use rustc_middle::mir::mono::MonoItem;
 use rustc_middle::{bug, mir};
-use rustc_public_bridge::Tables;
-use rustc_public_bridge::bridge::SmirError;
 use rustc_public_bridge::context::CompilerCtxt;
+use rustc_public_bridge::{Tables, bridge};
 
 use crate::compiler_interface::BridgeTys;
 use crate::mir::alloc::GlobalAlloc;
@@ -914,7 +913,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::ErrorHandled {
     type T = Error;
 
     fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
-        Error::new(format!("{self:?}"))
+        bridge::Error::new(format!("{self:?}"))
     }
 }
 
diff --git a/compiler/rustc_public/src/unstable/internal_cx/mod.rs b/compiler/rustc_public/src/unstable/internal_cx/mod.rs
index 44fbfde8775..601ca4fb5cf 100644
--- a/compiler/rustc_public/src/unstable/internal_cx/mod.rs
+++ b/compiler/rustc_public/src/unstable/internal_cx/mod.rs
@@ -1,8 +1,8 @@
 //! Implementation of InternalCx.
 
+pub(crate) use helpers::*;
 use rustc_middle::ty::{List, Ty, TyCtxt};
 use rustc_middle::{mir, ty};
-pub(crate) use helpers::*;
 
 use super::InternalCx;
 
diff --git a/compiler/rustc_public_bridge/src/alloc.rs b/compiler/rustc_public_bridge/src/alloc.rs
index c866b05e6cf..4a4725390a0 100644
--- a/compiler/rustc_public_bridge/src/alloc.rs
+++ b/compiler/rustc_public_bridge/src/alloc.rs
@@ -12,7 +12,7 @@ use rustc_middle::ty::{Ty, layout};
 
 use super::{CompilerCtxt, Tables};
 use crate::bridge::Allocation as _;
-use crate::{Bridge, SmirError};
+use crate::{Bridge, Error};
 
 pub fn create_ty_and_layout<'tcx, B: Bridge>(
     cx: &CompilerCtxt<'tcx, B>,
diff --git a/compiler/rustc_public_bridge/src/bridge.rs b/compiler/rustc_public_bridge/src/bridge.rs
index 675bb2d8bc3..d4f4847c8d3 100644
--- a/compiler/rustc_public_bridge/src/bridge.rs
+++ b/compiler/rustc_public_bridge/src/bridge.rs
@@ -9,7 +9,7 @@ use std::fmt::Debug;
 use super::context::CompilerCtxt;
 use super::{Bridge, Tables};
 
-pub trait SmirError {
+pub trait Error {
     fn new(msg: String) -> Self;
     fn from_internal<T: Debug>(err: T) -> Self;
 }
diff --git a/compiler/rustc_public_bridge/src/context/impls.rs b/compiler/rustc_public_bridge/src/context/impls.rs
index 8079fc95f97..5637da9e5b1 100644
--- a/compiler/rustc_public_bridge/src/context/impls.rs
+++ b/compiler/rustc_public_bridge/src/context/impls.rs
@@ -26,7 +26,7 @@ use rustc_target::callconv::FnAbi;
 
 use super::{AllocRangeHelpers, CompilerCtxt, TyHelpers, TypingEnvHelpers};
 use crate::builder::BodyBuilder;
-use crate::{Bridge, SmirError, Tables, filter_def_ids};
+use crate::{Bridge, Error, Tables, filter_def_ids};
 
 impl<'tcx, B: Bridge> TyHelpers<'tcx> for CompilerCtxt<'tcx, B> {
     fn new_foreign(&self, def_id: DefId) -> ty::Ty<'tcx> {
diff --git a/compiler/rustc_public_bridge/src/context/mod.rs b/compiler/rustc_public_bridge/src/context/mod.rs
index 3aa5c33c57d..b436319ae8b 100644
--- a/compiler/rustc_public_bridge/src/context/mod.rs
+++ b/compiler/rustc_public_bridge/src/context/mod.rs
@@ -9,10 +9,10 @@ use rustc_middle::ty;
 use rustc_middle::ty::layout::{FnAbiOfHelpers, HasTyCtxt, HasTypingEnv, LayoutOfHelpers};
 use rustc_middle::ty::{Ty, TyCtxt};
 
-use crate::{Bridge, SmirError};
+use crate::{Bridge, Error};
 
-mod impls;
 mod helpers;
+mod impls;
 
 pub use helpers::*;
 
diff --git a/compiler/rustc_public_bridge/src/lib.rs b/compiler/rustc_public_bridge/src/lib.rs
index 2bb259a857c..c0e1b6d4f51 100644
--- a/compiler/rustc_public_bridge/src/lib.rs
+++ b/compiler/rustc_public_bridge/src/lib.rs
@@ -222,7 +222,7 @@ pub trait Bridge: Sized {
     type MirConstId: Copy + Debug + PartialEq + IndexedVal;
     type Layout: Copy + Debug + PartialEq + IndexedVal;
 
-    type Error: SmirError;
+    type Error: Error;
     type CrateItem: CrateItem<Self>;
     type AdtDef: AdtDef<Self>;
     type ForeignModuleDef: ForeignModuleDef<Self>;
-- 
cgit 1.4.1-3-g733a5


From 95338717f10b46dfac7ee8333672ede004ca212b Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Tue, 15 Jul 2025 16:02:24 +0000
Subject: Update docs in `rustc_public_bridge`

---
 compiler/rustc_public_bridge/src/alloc.rs         | 2 +-
 compiler/rustc_public_bridge/src/builder.rs       | 7 +++----
 compiler/rustc_public_bridge/src/context/impls.rs | 4 ++--
 compiler/rustc_public_bridge/src/context/mod.rs   | 4 ++--
 compiler/rustc_public_bridge/src/lib.rs           | 6 +++---
 5 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_public_bridge/src/alloc.rs b/compiler/rustc_public_bridge/src/alloc.rs
index 4a4725390a0..ecf9004562c 100644
--- a/compiler/rustc_public_bridge/src/alloc.rs
+++ b/compiler/rustc_public_bridge/src/alloc.rs
@@ -1,4 +1,4 @@
-//! Internal memory allocator implementation for StableMIR.
+//! Internal memory allocator implementation for rustc_public.
 //!
 //! This module handles all direct interactions with rustc queries and performs
 //! the actual memory allocations. The stable interface in `rustc_public::alloc`
diff --git a/compiler/rustc_public_bridge/src/builder.rs b/compiler/rustc_public_bridge/src/builder.rs
index 2141053d09a..ea7f37d72d0 100644
--- a/compiler/rustc_public_bridge/src/builder.rs
+++ b/compiler/rustc_public_bridge/src/builder.rs
@@ -1,8 +1,7 @@
-//! Logic required to produce a monomorphic stable body.
+//! Logic required to produce a monomorphic body.
 //!
-//! We first retrieve and monomorphize the rustc body representation, i.e., we generate a
+//! We retrieve and monomorphize the rustc body representation, i.e., we generate a
 //! monomorphic body using internal representation.
-//! After that, we convert the internal representation into a stable one.
 
 use rustc_hir::def::DefKind;
 use rustc_middle::mir;
@@ -25,7 +24,7 @@ impl<'tcx> BodyBuilder<'tcx> {
         BodyBuilder { tcx, instance }
     }
 
-    /// Build a stable monomorphic body for a given instance based on the MIR body.
+    /// Build a monomorphic body for a given instance based on the MIR body.
     ///
     /// All constants are also evaluated.
     pub(crate) fn build(mut self) -> mir::Body<'tcx> {
diff --git a/compiler/rustc_public_bridge/src/context/impls.rs b/compiler/rustc_public_bridge/src/context/impls.rs
index 5637da9e5b1..612e44b56b1 100644
--- a/compiler/rustc_public_bridge/src/context/impls.rs
+++ b/compiler/rustc_public_bridge/src/context/impls.rs
@@ -1,4 +1,4 @@
-//! Implementation of StableMIR Context.
+//! Implementation of CompilerCtxt.
 
 #![allow(rustc::usage_of_qualified_ty)]
 
@@ -85,7 +85,7 @@ impl<'tcx, B: Bridge> CompilerCtxt<'tcx, B> {
     /// Return whether the item has a body defined by the user.
     ///
     /// Note that intrinsics may have a placeholder body that shouldn't be used in practice.
-    /// In StableMIR, we handle this case as if the body is not available.
+    /// In rustc_public, we handle this case as if the body is not available.
     pub(crate) fn item_has_body(&self, def_id: DefId) -> bool {
         let must_override = if let Some(intrinsic) = self.tcx.intrinsic(def_id) {
             intrinsic.must_be_overridden
diff --git a/compiler/rustc_public_bridge/src/context/mod.rs b/compiler/rustc_public_bridge/src/context/mod.rs
index b436319ae8b..857a2d4e26b 100644
--- a/compiler/rustc_public_bridge/src/context/mod.rs
+++ b/compiler/rustc_public_bridge/src/context/mod.rs
@@ -1,4 +1,4 @@
-//! Implementation of StableMIR Context.
+//! Implementation of CompilerCtxt.
 
 #![allow(rustc::usage_of_qualified_ty)]
 
@@ -19,7 +19,7 @@ pub use helpers::*;
 /// Provides direct access to rustc's internal queries.
 ///
 /// `CompilerInterface` must go through
-/// this context to obtain rustc-level information.
+/// this context to obtain internal information.
 pub struct CompilerCtxt<'tcx, B: Bridge> {
     pub tcx: TyCtxt<'tcx>,
     _marker: PhantomData<B>,
diff --git a/compiler/rustc_public_bridge/src/lib.rs b/compiler/rustc_public_bridge/src/lib.rs
index c0e1b6d4f51..dec3be70baf 100644
--- a/compiler/rustc_public_bridge/src/lib.rs
+++ b/compiler/rustc_public_bridge/src/lib.rs
@@ -1,6 +1,6 @@
-//! Crate that implements what will become the rustc side of Stable MIR.
+//! Crate that implements what will become the rustc side of rustc_public.
 //!
-//! This crate is responsible for building Stable MIR components from internal components.
+//! This crate serves as a proxy for making calls to rustc queries.
 //!
 //! This crate is not intended to be invoked directly by users.
 //! This crate is the public API of rustc that will be invoked by the `rustc_public` crate.
@@ -210,7 +210,7 @@ impl<'tcx, B: Bridge> Tables<'tcx, B> {
     }
 }
 
-/// A trait defining types that are used to emulate StableMIR components, which is really
+/// A trait defining types that are used to emulate rustc_public components, which is really
 /// useful when programming in rustc_public-agnostic settings.
 pub trait Bridge: Sized {
     type DefId: Copy + Debug + PartialEq + IndexedVal;
-- 
cgit 1.4.1-3-g733a5


From 483877a9b2140065df08e15a27c20c9431028ec5 Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Tue, 15 Jul 2025 16:22:33 +0000
Subject: Update docs in `rustc_public`

---
 compiler/rustc_public/src/alloc.rs                    |  2 +-
 compiler/rustc_public/src/compiler_interface.rs       |  4 ++--
 compiler/rustc_public/src/error.rs                    |  2 +-
 compiler/rustc_public/src/mir/alloc.rs                |  2 +-
 compiler/rustc_public/src/mir/body.rs                 |  6 +++---
 compiler/rustc_public/src/mir/mono.rs                 |  4 ++--
 compiler/rustc_public/src/mir/pretty.rs               |  2 +-
 compiler/rustc_public/src/mir/visit.rs                |  2 +-
 compiler/rustc_public/src/rustc_internal/mod.rs       | 12 ++++++------
 compiler/rustc_public/src/rustc_internal/pretty.rs    |  2 +-
 .../rustc_public/src/unstable/convert/internal.rs     |  2 +-
 compiler/rustc_public/src/unstable/convert/mod.rs     |  2 +-
 compiler/rustc_public/src/unstable/mod.rs             | 19 ++++++++++---------
 13 files changed, 31 insertions(+), 30 deletions(-)

diff --git a/compiler/rustc_public/src/alloc.rs b/compiler/rustc_public/src/alloc.rs
index dcb3cc0e75f..75ad31022ff 100644
--- a/compiler/rustc_public/src/alloc.rs
+++ b/compiler/rustc_public/src/alloc.rs
@@ -1,4 +1,4 @@
-//! Memory allocation implementation for StableMIR.
+//! Memory allocation implementation for rustc_public.
 //!
 //! This module is responsible for constructing stable components.
 //! All operations requiring rustc queries must be delegated
diff --git a/compiler/rustc_public/src/compiler_interface.rs b/compiler/rustc_public/src/compiler_interface.rs
index 043064951d5..5a09c3b24f0 100644
--- a/compiler/rustc_public/src/compiler_interface.rs
+++ b/compiler/rustc_public/src/compiler_interface.rs
@@ -1,6 +1,6 @@
 //! Define the interface with the Rust compiler.
 //!
-//! StableMIR users should not use any of the items in this module directly.
+//! rustc_public users should not use any of the items in this module directly.
 //! These APIs have no stability guarantee.
 
 use std::cell::Cell;
@@ -1067,7 +1067,7 @@ where
     F: FnOnce() -> T,
 {
     if TLV.is_set() {
-        Err(Error::from("StableMIR already running"))
+        Err(Error::from("rustc_public already running"))
     } else {
         let ptr: *const () = (&raw const interface) as _;
         TLV.set(&Cell::new(ptr), || Ok(f()))
diff --git a/compiler/rustc_public/src/error.rs b/compiler/rustc_public/src/error.rs
index 70a74eaa9fb..3d75a4bd315 100644
--- a/compiler/rustc_public/src/error.rs
+++ b/compiler/rustc_public/src/error.rs
@@ -1,5 +1,5 @@
 //! When things go wrong, we need some error handling.
-//! There are a few different types of errors in StableMIR:
+//! There are a few different types of errors in rustc_public:
 //!
 //! - [CompilerError]: This represents errors that can be raised when invoking the compiler.
 //! - [Error]: Generic error that represents the reason why a request that could not be fulfilled.
diff --git a/compiler/rustc_public/src/mir/alloc.rs b/compiler/rustc_public/src/mir/alloc.rs
index 9a94551f3ec..07a979f3811 100644
--- a/compiler/rustc_public/src/mir/alloc.rs
+++ b/compiler/rustc_public/src/mir/alloc.rs
@@ -9,7 +9,7 @@ use crate::target::{Endian, MachineInfo};
 use crate::ty::{Allocation, Binder, ExistentialTraitRef, Ty};
 use crate::{Error, IndexedVal, with};
 
-/// An allocation in the SMIR global memory can be either a function pointer,
+/// An allocation in the rustc_public's IR global memory can be either a function pointer,
 /// a static, or a "real" allocation with some data in it.
 #[derive(Debug, Clone, Eq, PartialEq, Serialize)]
 pub enum GlobalAlloc {
diff --git a/compiler/rustc_public/src/mir/body.rs b/compiler/rustc_public/src/mir/body.rs
index 28a7aa6e758..3320b98cd61 100644
--- a/compiler/rustc_public/src/mir/body.rs
+++ b/compiler/rustc_public/src/mir/body.rs
@@ -10,7 +10,7 @@ use crate::ty::{
 };
 use crate::{Error, Opaque, Span, Symbol};
 
-/// The SMIR representation of a single function.
+/// The rustc_public's IR representation of a single function.
 #[derive(Clone, Debug, Serialize)]
 pub struct Body {
     pub blocks: Vec<BasicBlock>,
@@ -771,8 +771,8 @@ pub enum VarDebugInfoContents {
 // In MIR ProjectionElem is parameterized on the second Field argument and the Index argument. This
 // is so it can be used for both Places (for which the projection elements are of type
 // ProjectionElem<Local, Ty>) and user-provided type annotations (for which the projection elements
-// are of type ProjectionElem<(), ()>). In SMIR we don't need this generality, so we just use
-// ProjectionElem for Places.
+// are of type ProjectionElem<(), ()>).
+// In rustc_public's IR we don't need this generality, so we just use ProjectionElem for Places.
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum ProjectionElem {
     /// Dereference projections (e.g. `*_1`) project to the address referenced by the base place.
diff --git a/compiler/rustc_public/src/mir/mono.rs b/compiler/rustc_public/src/mir/mono.rs
index 06f6ac17e7b..d488f5a25c7 100644
--- a/compiler/rustc_public/src/mir/mono.rs
+++ b/compiler/rustc_public/src/mir/mono.rs
@@ -62,7 +62,7 @@ impl Instance {
     /// For more information on fallback body, see <https://github.com/rust-lang/rust/issues/93145>.
     ///
     /// This call is much cheaper than `instance.body().is_some()`, since it doesn't try to build
-    /// the StableMIR body.
+    /// the rustc_public's IR body.
     pub fn has_body(&self) -> bool {
         with(|cx| cx.has_body(self.def.def_id()))
     }
@@ -157,7 +157,7 @@ impl Instance {
     ///
     /// Allow users to check if this shim can be ignored when called directly.
     ///
-    /// We have decided not to export different types of Shims to StableMIR users, however, this
+    /// We have decided not to export different types of Shims to rustc_public users, however, this
     /// is a query that can be very helpful for users when processing DropGlue.
     ///
     /// When generating code for a Drop terminator, users can ignore an empty drop glue.
diff --git a/compiler/rustc_public/src/mir/pretty.rs b/compiler/rustc_public/src/mir/pretty.rs
index f496d80053e..a433df2dba1 100644
--- a/compiler/rustc_public/src/mir/pretty.rs
+++ b/compiler/rustc_public/src/mir/pretty.rs
@@ -1,4 +1,4 @@
-//! Implement methods to pretty print stable MIR body.
+//! Implement methods to pretty print rustc_public's IR body.
 use std::fmt::Debug;
 use std::io::Write;
 use std::{fmt, io, iter};
diff --git a/compiler/rustc_public/src/mir/visit.rs b/compiler/rustc_public/src/mir/visit.rs
index 7dc99d1d1e1..04c4d4d2a82 100644
--- a/compiler/rustc_public/src/mir/visit.rs
+++ b/compiler/rustc_public/src/mir/visit.rs
@@ -1,4 +1,4 @@
-//! # The Stable MIR Visitor
+//! # The rustc_public's IR Visitor
 //!
 //! ## Overview
 //!
diff --git a/compiler/rustc_public/src/rustc_internal/mod.rs b/compiler/rustc_public/src/rustc_internal/mod.rs
index ca999b62f80..a119958974e 100644
--- a/compiler/rustc_public/src/rustc_internal/mod.rs
+++ b/compiler/rustc_public/src/rustc_internal/mod.rs
@@ -1,7 +1,7 @@
-//! Module that implements the bridge between Stable MIR and internal compiler MIR.
+//! Module that implements the bridge between rustc_public's IR and internal compiler MIR.
 //!
 //! For that, we define APIs that will temporarily be public to 3P that exposes rustc internal APIs
-//! until stable MIR is complete.
+//! until rustc_public's IR is complete.
 
 use std::cell::{Cell, RefCell};
 
@@ -26,7 +26,7 @@ pub mod pretty;
 ///
 /// # Panics
 ///
-/// This function will panic if StableMIR has not been properly initialized.
+/// This function will panic if rustc_public has not been properly initialized.
 pub fn stable<'tcx, S: Stable<'tcx>>(item: S) -> S::T {
     with_container(|tables, cx| item.stable(tables, cx))
 }
@@ -41,7 +41,7 @@ pub fn stable<'tcx, S: Stable<'tcx>>(item: S) -> S::T {
 ///
 /// # Panics
 ///
-/// This function will panic if StableMIR has not been properly initialized.
+/// This function will panic if rustc_public has not been properly initialized.
 pub fn internal<'tcx, S>(tcx: TyCtxt<'tcx>, item: S) -> S::T<'tcx>
 where
     S: RustcInternal,
@@ -57,7 +57,7 @@ pub fn crate_num(item: &crate::Crate) -> CrateNum {
 }
 
 // A thread local variable that stores a pointer to the tables mapping between TyCtxt
-// datastructures and stable MIR datastructures
+// datastructures and rustc_public's IR datastructures
 scoped_thread_local! (static TLV: Cell<*const ()>);
 
 pub(crate) fn init<'tcx, F, T, B: Bridge>(container: &Container<'tcx, B>, f: F) -> T
@@ -176,7 +176,7 @@ macro_rules! optional {
 
 /// Prefer using [run!] and [run_with_tcx] instead.
 ///
-/// This macro implements the instantiation of a StableMIR driver, and it will invoke
+/// This macro implements the instantiation of a rustc_public driver, and it will invoke
 /// the given callback after the compiler analyses.
 ///
 /// The third argument determines whether the callback requires `tcx` as an argument.
diff --git a/compiler/rustc_public/src/rustc_internal/pretty.rs b/compiler/rustc_public/src/rustc_internal/pretty.rs
index 28c5280fe04..83522e51977 100644
--- a/compiler/rustc_public/src/rustc_internal/pretty.rs
+++ b/compiler/rustc_public/src/rustc_internal/pretty.rs
@@ -7,7 +7,7 @@ use super::run;
 pub fn write_smir_pretty<'tcx, W: io::Write>(tcx: TyCtxt<'tcx>, w: &mut W) -> io::Result<()> {
     writeln!(
         w,
-        "// WARNING: This is highly experimental output it's intended for stable-mir developers only."
+        "// WARNING: This is highly experimental output it's intended for rustc_public developers only."
     )?;
     writeln!(
         w,
diff --git a/compiler/rustc_public/src/unstable/convert/internal.rs b/compiler/rustc_public/src/unstable/convert/internal.rs
index 0571a03b62b..b2d38e497bc 100644
--- a/compiler/rustc_public/src/unstable/convert/internal.rs
+++ b/compiler/rustc_public/src/unstable/convert/internal.rs
@@ -1,4 +1,4 @@
-//! Module containing the translation from stable mir constructs to the rustc counterpart.
+//! Module containing the translation from rustc_public constructs to the rustc counterpart.
 //!
 //! This module will only include a few constructs to allow users to invoke internal rustc APIs
 //! due to incomplete stable coverage.
diff --git a/compiler/rustc_public/src/unstable/convert/mod.rs b/compiler/rustc_public/src/unstable/convert/mod.rs
index a2e83c6e239..f20406631e3 100644
--- a/compiler/rustc_public/src/unstable/convert/mod.rs
+++ b/compiler/rustc_public/src/unstable/convert/mod.rs
@@ -1,4 +1,4 @@
-//! This module holds the logic to convert rustc internal ADTs into stable mir ADTs.
+//! This module holds the logic to convert rustc internal ADTs into rustc_public ADTs.
 //!
 //! The conversion from stable to internal is not meant to be complete,
 //! and it should be added as when needed to be passed as input to rustc_public_bridge functions.
diff --git a/compiler/rustc_public/src/unstable/mod.rs b/compiler/rustc_public/src/unstable/mod.rs
index ca154a3378a..72b14cfa072 100644
--- a/compiler/rustc_public/src/unstable/mod.rs
+++ b/compiler/rustc_public/src/unstable/mod.rs
@@ -1,6 +1,6 @@
 //! Module that collects the things that have no stability guarantees.
 //!
-//! We want to keep StableMIR definitions and logic separate from
+//! We want to keep rustc_public's IR definitions and logic separate from
 //! any sort of conversion and usage of internal rustc code. So we
 //! restrict the usage of internal items to be inside this module.
 
@@ -53,16 +53,16 @@ pub trait InternalCx<'tcx>: Copy + Clone {
     fn adt_def(self, def_id: rustc_hir::def_id::DefId) -> ty::AdtDef<'tcx>;
 }
 
-/// Trait used to convert between an internal MIR type to a Stable MIR type.
+/// Trait used to convert between an internal MIR type to a rustc_public's IR type.
 ///
-/// This trait is currently exposed to users so they can have interoperability between internal MIR
-/// and StableMIR constructs. However, they should be used seldom and they have no influence
-/// in this crate semver.
+/// This trait is currently exposed to users so they can have interoperability
+/// between internal MIR and rustc_public's IR constructs.
+/// However, they should be used seldom and they have no influence in this crate semver.
 #[doc(hidden)]
 pub trait Stable<'tcx>: PointeeSized {
     /// The stable representation of the type implementing Stable.
     type T;
-    /// Converts an object to the equivalent Stable MIR representation.
+    /// Converts an object to the equivalent rustc_public's IR representation.
     fn stable<'cx>(
         &self,
         tables: &mut Tables<'cx, BridgeTys>,
@@ -70,12 +70,13 @@ pub trait Stable<'tcx>: PointeeSized {
     ) -> Self::T;
 }
 
-/// Trait used to translate a stable construct to its rustc counterpart.
+/// Trait used to translate a rustc_public's IR construct to its rustc counterpart.
 ///
 /// This is basically a mirror of [Stable].
 ///
-/// This trait is currently exposed to users so they can have interoperability between internal MIR
-/// and StableMIR constructs. They should be used seldom as they have no stability guarantees.
+/// This trait is currently exposed to users so they can have interoperability
+/// between internal MIR and rustc_public's IR constructs.
+/// They should be used seldom as they have no stability guarantees.
 #[doc(hidden)]
 pub trait RustcInternal {
     type T<'tcx>;
-- 
cgit 1.4.1-3-g733a5


From 4d79328091167135e890b77f0fbf5b8b9479c80b Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Tue, 15 Jul 2025 16:37:26 +0000
Subject: use `RustcPublic` instead of `StableMir`

---
 compiler/rustc_public/src/rustc_internal/mod.rs       | 12 ++++++------
 tests/ui-fulldeps/rustc_public/check_abi.rs           |  2 +-
 tests/ui-fulldeps/rustc_public/check_allocation.rs    |  2 +-
 tests/ui-fulldeps/rustc_public/check_attribute.rs     |  2 +-
 tests/ui-fulldeps/rustc_public/check_binop.rs         |  2 +-
 tests/ui-fulldeps/rustc_public/check_crate_defs.rs    |  2 +-
 tests/ui-fulldeps/rustc_public/check_def_ty.rs        |  2 +-
 tests/ui-fulldeps/rustc_public/check_defs.rs          |  2 +-
 tests/ui-fulldeps/rustc_public/check_foreign.rs       |  2 +-
 tests/ui-fulldeps/rustc_public/check_instance.rs      |  2 +-
 tests/ui-fulldeps/rustc_public/check_intrinsics.rs    |  2 +-
 tests/ui-fulldeps/rustc_public/check_item_kind.rs     |  2 +-
 tests/ui-fulldeps/rustc_public/check_normalization.rs |  2 +-
 tests/ui-fulldeps/rustc_public/check_trait_queries.rs |  2 +-
 tests/ui-fulldeps/rustc_public/check_transform.rs     |  2 +-
 tests/ui-fulldeps/rustc_public/check_ty_fold.rs       |  2 +-
 tests/ui-fulldeps/rustc_public/check_variant.rs       |  2 +-
 tests/ui-fulldeps/rustc_public/compilation-result.rs  |  2 +-
 tests/ui-fulldeps/rustc_public/crate-info.rs          |  2 +-
 tests/ui-fulldeps/rustc_public/projections.rs         |  2 +-
 tests/ui-fulldeps/rustc_public/smir_internal.rs       |  2 +-
 tests/ui-fulldeps/rustc_public/smir_serde.rs          |  2 +-
 tests/ui-fulldeps/rustc_public/smir_visitor.rs        |  2 +-
 23 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_public/src/rustc_internal/mod.rs b/compiler/rustc_public/src/rustc_internal/mod.rs
index a119958974e..225c811ab3a 100644
--- a/compiler/rustc_public/src/rustc_internal/mod.rs
+++ b/compiler/rustc_public/src/rustc_internal/mod.rs
@@ -191,7 +191,7 @@ macro_rules! run_driver {
         use rustc_public::CompilerError;
         use std::ops::ControlFlow;
 
-        pub struct StableMir<B = (), C = (), F = fn($($crate::optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C>>
+        pub struct RustcPublic<B = (), C = (), F = fn($($crate::optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C>>
         where
             B: Send,
             C: Send,
@@ -201,15 +201,15 @@ macro_rules! run_driver {
             result: Option<ControlFlow<B, C>>,
         }
 
-        impl<B, C, F> StableMir<B, C, F>
+        impl<B, C, F> RustcPublic<B, C, F>
         where
             B: Send,
             C: Send,
             F: FnOnce($($crate::optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
         {
-            /// Creates a new `StableMir` instance, with given test_function and arguments.
+            /// Creates a new `RustcPublic` instance, with given test_function and arguments.
             pub fn new(callback: F) -> Self {
-                StableMir { callback: Some(callback), result: None }
+                RustcPublic { callback: Some(callback), result: None }
             }
 
             /// Runs the compiler against given target and tests it with `test_function`
@@ -236,7 +236,7 @@ macro_rules! run_driver {
             }
         }
 
-        impl<B, C, F> Callbacks for StableMir<B, C, F>
+        impl<B, C, F> Callbacks for RustcPublic<B, C, F>
         where
             B: Send,
             C: Send,
@@ -265,6 +265,6 @@ macro_rules! run_driver {
             }
         }
 
-        StableMir::new($callback).run($args)
+        RustcPublic::new($callback).run($args)
     }};
 }
diff --git a/tests/ui-fulldeps/rustc_public/check_abi.rs b/tests/ui-fulldeps/rustc_public/check_abi.rs
index fc2227d147d..57c8377ea36 100644
--- a/tests/ui-fulldeps/rustc_public/check_abi.rs
+++ b/tests/ui-fulldeps/rustc_public/check_abi.rs
@@ -167,7 +167,7 @@ impl MirVisitor for AdtDefVisitor {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "alloc_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_allocation.rs b/tests/ui-fulldeps/rustc_public/check_allocation.rs
index 83845a9aa42..70e4ee3fe34 100644
--- a/tests/ui-fulldeps/rustc_public/check_allocation.rs
+++ b/tests/ui-fulldeps/rustc_public/check_allocation.rs
@@ -202,7 +202,7 @@ fn get_item<'a>(
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "alloc_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_attribute.rs b/tests/ui-fulldeps/rustc_public/check_attribute.rs
index d8807872ec4..0c34ac4dfe9 100644
--- a/tests/ui-fulldeps/rustc_public/check_attribute.rs
+++ b/tests/ui-fulldeps/rustc_public/check_attribute.rs
@@ -52,7 +52,7 @@ fn get_item<'a>(
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "attribute_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_binop.rs b/tests/ui-fulldeps/rustc_public/check_binop.rs
index aa089a5d125..35be6f973cc 100644
--- a/tests/ui-fulldeps/rustc_public/check_binop.rs
+++ b/tests/ui-fulldeps/rustc_public/check_binop.rs
@@ -76,7 +76,7 @@ impl<'a> MirVisitor for Visitor<'a> {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "binop_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_crate_defs.rs b/tests/ui-fulldeps/rustc_public/check_crate_defs.rs
index 27d5b0bc238..3ca8b66e58d 100644
--- a/tests/ui-fulldeps/rustc_public/check_crate_defs.rs
+++ b/tests/ui-fulldeps/rustc_public/check_crate_defs.rs
@@ -79,7 +79,7 @@ fn contains<T: CrateDef + std::fmt::Debug>(items: &[T], expected: &[&str]) {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "crate_definitions.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_def_ty.rs b/tests/ui-fulldeps/rustc_public/check_def_ty.rs
index b5954352dc0..176a9d79ef1 100644
--- a/tests/ui-fulldeps/rustc_public/check_def_ty.rs
+++ b/tests/ui-fulldeps/rustc_public/check_def_ty.rs
@@ -70,7 +70,7 @@ fn check_fn_def(ty: Ty) {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "defs_ty_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_defs.rs b/tests/ui-fulldeps/rustc_public/check_defs.rs
index 5e45f19cac8..0c45859a132 100644
--- a/tests/ui-fulldeps/rustc_public/check_defs.rs
+++ b/tests/ui-fulldeps/rustc_public/check_defs.rs
@@ -106,7 +106,7 @@ fn get_instances(body: mir::Body) -> Vec<Instance> {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "defs_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_foreign.rs b/tests/ui-fulldeps/rustc_public/check_foreign.rs
index 9aee067f41b..78b62594c61 100644
--- a/tests/ui-fulldeps/rustc_public/check_foreign.rs
+++ b/tests/ui-fulldeps/rustc_public/check_foreign.rs
@@ -52,7 +52,7 @@ fn test_foreign() -> ControlFlow<()> {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "foreign_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_instance.rs b/tests/ui-fulldeps/rustc_public/check_instance.rs
index 18971076043..fd7523963fa 100644
--- a/tests/ui-fulldeps/rustc_public/check_instance.rs
+++ b/tests/ui-fulldeps/rustc_public/check_instance.rs
@@ -81,7 +81,7 @@ fn test_body(body: mir::Body) {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "instance_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_intrinsics.rs b/tests/ui-fulldeps/rustc_public/check_intrinsics.rs
index 854ac77956e..f722f0bbd71 100644
--- a/tests/ui-fulldeps/rustc_public/check_intrinsics.rs
+++ b/tests/ui-fulldeps/rustc_public/check_intrinsics.rs
@@ -110,7 +110,7 @@ impl<'a> MirVisitor for CallsVisitor<'a> {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "binop_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_item_kind.rs b/tests/ui-fulldeps/rustc_public/check_item_kind.rs
index 58e740bdaef..b759628f1a4 100644
--- a/tests/ui-fulldeps/rustc_public/check_item_kind.rs
+++ b/tests/ui-fulldeps/rustc_public/check_item_kind.rs
@@ -41,7 +41,7 @@ fn test_item_kind() -> ControlFlow<()> {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "item_kind_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_normalization.rs b/tests/ui-fulldeps/rustc_public/check_normalization.rs
index aa6a257dac6..db9d3031600 100644
--- a/tests/ui-fulldeps/rustc_public/check_normalization.rs
+++ b/tests/ui-fulldeps/rustc_public/check_normalization.rs
@@ -55,7 +55,7 @@ fn check_ty(ty: Ty) {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "normalization_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_trait_queries.rs b/tests/ui-fulldeps/rustc_public/check_trait_queries.rs
index a6c37883643..0dd13044fcc 100644
--- a/tests/ui-fulldeps/rustc_public/check_trait_queries.rs
+++ b/tests/ui-fulldeps/rustc_public/check_trait_queries.rs
@@ -67,7 +67,7 @@ fn assert_impl(impl_names: &HashSet<String>, target: &str) {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "trait_queries.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_transform.rs b/tests/ui-fulldeps/rustc_public/check_transform.rs
index 3209fcf9ede..b30d98c3b26 100644
--- a/tests/ui-fulldeps/rustc_public/check_transform.rs
+++ b/tests/ui-fulldeps/rustc_public/check_transform.rs
@@ -115,7 +115,7 @@ fn get_item<'a>(
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "transform_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_ty_fold.rs b/tests/ui-fulldeps/rustc_public/check_ty_fold.rs
index 07ef0d2bb50..93cd3049344 100644
--- a/tests/ui-fulldeps/rustc_public/check_ty_fold.rs
+++ b/tests/ui-fulldeps/rustc_public/check_ty_fold.rs
@@ -73,7 +73,7 @@ impl<'a> MirVisitor for PlaceVisitor<'a> {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "ty_fold_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/check_variant.rs b/tests/ui-fulldeps/rustc_public/check_variant.rs
index ebe76bd89d5..9ed16f2357c 100644
--- a/tests/ui-fulldeps/rustc_public/check_variant.rs
+++ b/tests/ui-fulldeps/rustc_public/check_variant.rs
@@ -120,7 +120,7 @@ fn check_statement_is_aggregate_assign(
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "defs_ty_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/compilation-result.rs b/tests/ui-fulldeps/rustc_public/compilation-result.rs
index ed013375c71..d33e602e819 100644
--- a/tests/ui-fulldeps/rustc_public/compilation-result.rs
+++ b/tests/ui-fulldeps/rustc_public/compilation-result.rs
@@ -20,7 +20,7 @@ use std::io::Write;
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "input_compilation_result_test.rs";
diff --git a/tests/ui-fulldeps/rustc_public/crate-info.rs b/tests/ui-fulldeps/rustc_public/crate-info.rs
index 4f46dff9b82..19082d7394a 100644
--- a/tests/ui-fulldeps/rustc_public/crate-info.rs
+++ b/tests/ui-fulldeps/rustc_public/crate-info.rs
@@ -189,7 +189,7 @@ fn get_item<'a>(
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/projections.rs b/tests/ui-fulldeps/rustc_public/projections.rs
index 3b360cd2fcf..e0213b4253c 100644
--- a/tests/ui-fulldeps/rustc_public/projections.rs
+++ b/tests/ui-fulldeps/rustc_public/projections.rs
@@ -141,7 +141,7 @@ fn get_item<'a>(
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/smir_internal.rs b/tests/ui-fulldeps/rustc_public/smir_internal.rs
index dd70cfe5f5e..b74bdfe4eb1 100644
--- a/tests/ui-fulldeps/rustc_public/smir_internal.rs
+++ b/tests/ui-fulldeps/rustc_public/smir_internal.rs
@@ -34,7 +34,7 @@ fn test_translation(tcx: TyCtxt<'_>) -> ControlFlow<()> {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "internal_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/smir_serde.rs b/tests/ui-fulldeps/rustc_public/smir_serde.rs
index 31642c6cb94..972bc5efe20 100644
--- a/tests/ui-fulldeps/rustc_public/smir_serde.rs
+++ b/tests/ui-fulldeps/rustc_public/smir_serde.rs
@@ -41,7 +41,7 @@ fn serialize_to_json(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "internal_input.rs";
diff --git a/tests/ui-fulldeps/rustc_public/smir_visitor.rs b/tests/ui-fulldeps/rustc_public/smir_visitor.rs
index 66787e2927b..9438f46a59b 100644
--- a/tests/ui-fulldeps/rustc_public/smir_visitor.rs
+++ b/tests/ui-fulldeps/rustc_public/smir_visitor.rs
@@ -177,7 +177,7 @@ impl mir::MutMirVisitor for TestMutVisitor {
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "sim_visitor_input.rs";
-- 
cgit 1.4.1-3-g733a5


From 20a7f722d824ebc4e733ec848d797088363624e9 Mon Sep 17 00:00:00 2001
From: Makai <m4kai410@gmail.com>
Date: Thu, 17 Jul 2025 15:49:51 +0000
Subject: fix `ui/rustc_public-ir-print` outputs

---
 tests/ui/rustc_public-ir-print/async-closure.stdout  | 2 +-
 tests/ui/rustc_public-ir-print/basic_function.stdout | 2 +-
 tests/ui/rustc_public-ir-print/operands.stdout       | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/ui/rustc_public-ir-print/async-closure.stdout b/tests/ui/rustc_public-ir-print/async-closure.stdout
index 31811299722..4afb15af7a9 100644
--- a/tests/ui/rustc_public-ir-print/async-closure.stdout
+++ b/tests/ui/rustc_public-ir-print/async-closure.stdout
@@ -1,4 +1,4 @@
-// WARNING: This is highly experimental output it's intended for stable-mir developers only.
+// WARNING: This is highly experimental output it's intended for rustc_public developers only.
 // If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
 fn foo() -> () {
     let mut _0: ();
diff --git a/tests/ui/rustc_public-ir-print/basic_function.stdout b/tests/ui/rustc_public-ir-print/basic_function.stdout
index 319d9c1dc69..dc885e009e9 100644
--- a/tests/ui/rustc_public-ir-print/basic_function.stdout
+++ b/tests/ui/rustc_public-ir-print/basic_function.stdout
@@ -1,4 +1,4 @@
-// WARNING: This is highly experimental output it's intended for stable-mir developers only.
+// WARNING: This is highly experimental output it's intended for rustc_public developers only.
 // If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
 fn foo(_1: i32) -> i32 {
     let mut _0: i32;
diff --git a/tests/ui/rustc_public-ir-print/operands.stdout b/tests/ui/rustc_public-ir-print/operands.stdout
index 37c5ec1a95e..a4b1c07f3a0 100644
--- a/tests/ui/rustc_public-ir-print/operands.stdout
+++ b/tests/ui/rustc_public-ir-print/operands.stdout
@@ -1,4 +1,4 @@
-// WARNING: This is highly experimental output it's intended for stable-mir developers only.
+// WARNING: This is highly experimental output it's intended for rustc_public developers only.
 // If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir.
 fn operands(_1: u8) -> () {
     let mut _0: ();
-- 
cgit 1.4.1-3-g733a5


From 208687e9d39add66f4a4cd846fcaae1387caabfa Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Fri, 18 Jul 2025 19:04:50 +0000
Subject: Prepare for merging from rust-lang/rust

This updates the rust-version file to 82310651b93a594a3fd69015e1562186a080d94c.
---
 library/compiler-builtins/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/compiler-builtins/rust-version b/library/compiler-builtins/rust-version
index 73183983599..a4db05a8796 100644
--- a/library/compiler-builtins/rust-version
+++ b/library/compiler-builtins/rust-version
@@ -1 +1 @@
-d087f112b7d1323446c7b39a8b616aee7fa56b3d
+82310651b93a594a3fd69015e1562186a080d94c
-- 
cgit 1.4.1-3-g733a5


From c79f62d1ea5d210de9bc98ddc7e0588533a2b311 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Wed, 2 Jul 2025 13:27:29 +0000
Subject: clippy fix: bound in one place

---
 library/core/src/cmp.rs                  | 5 +++--
 library/core/src/iter/traits/iterator.rs | 8 ++++----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index b1ca3701fa5..7abadc9124b 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -1481,13 +1481,14 @@ pub trait PartialOrd<Rhs: PointeeSized = Self>: PartialEq<Rhs> + PointeeSized {
     }
 }
 
-fn default_chaining_impl<T: PointeeSized, U: PointeeSized>(
+fn default_chaining_impl<T, U>(
     lhs: &T,
     rhs: &U,
     p: impl FnOnce(Ordering) -> bool,
 ) -> ControlFlow<bool>
 where
-    T: PartialOrd<U>,
+    T: PartialOrd<U> + PointeeSized,
+    U: PointeeSized,
 {
     // It's important that this only call `partial_cmp` once, not call `eq` then
     // one of the relational operators.  We don't want to `bcmp`-then-`memcp` a
diff --git a/library/core/src/iter/traits/iterator.rs b/library/core/src/iter/traits/iterator.rs
index f296792b1dc..10f9d464f7d 100644
--- a/library/core/src/iter/traits/iterator.rs
+++ b/library/core/src/iter/traits/iterator.rs
@@ -3414,10 +3414,10 @@ pub trait Iterator {
     /// ```
     #[stable(feature = "iter_copied", since = "1.36.0")]
     #[rustc_diagnostic_item = "iter_copied"]
-    fn copied<'a, T: 'a>(self) -> Copied<Self>
+    fn copied<'a, T>(self) -> Copied<Self>
     where
+        T: Copy + 'a,
         Self: Sized + Iterator<Item = &'a T>,
-        T: Copy,
     {
         Copied::new(self)
     }
@@ -3462,10 +3462,10 @@ pub trait Iterator {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "iter_cloned"]
-    fn cloned<'a, T: 'a>(self) -> Cloned<Self>
+    fn cloned<'a, T>(self) -> Cloned<Self>
     where
+        T: Clone + 'a,
         Self: Sized + Iterator<Item = &'a T>,
-        T: Clone,
     {
         Cloned::new(self)
     }
-- 
cgit 1.4.1-3-g733a5


From f16474f7bf0419de39db82fcf2f308cb42c2997d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 18 Jul 2025 22:35:30 +0200
Subject: Remove forgotten git annotations

---
 compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs | 7 -------
 1 file changed, 7 deletions(-)

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 358f265a6b8..85489f850e2 100644
--- a/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs
+++ b/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs
@@ -198,12 +198,6 @@ fn main() {
         assert_eq!(intrinsics::align_of::<u16>() as u8, 2);
         assert_eq!(intrinsics::align_of_val(&a) as u8, intrinsics::align_of::<&str>() as u8);
 
-<<<<<<< HEAD
-        assert!(!const { intrinsics::needs_drop::<u8>() });
-        assert!(!const { intrinsics::needs_drop::<[u8]>() });
-        assert!(const { intrinsics::needs_drop::<NoisyDrop>() });
-        assert!(const { intrinsics::needs_drop::<NoisyDropUnsized>() });
-=======
         /*
          * TODO: re-enable in the next sync.
         let u8_needs_drop = const { intrinsics::needs_drop::<u8>() };
@@ -215,7 +209,6 @@ fn main() {
         let noisy_unsized_drop = const { intrinsics::needs_drop::<NoisyDropUnsized>() };
         assert!(noisy_unsized_drop);
         */
->>>>>>> f682d09eefc6700b9e5851ef193847959acf4fac
 
         Unique {
             pointer: 0 as *const &str,
-- 
cgit 1.4.1-3-g733a5


From 3fb1af39876d1d3fadc48b1f66edb52bcfc3d04a Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Fri, 18 Jul 2025 16:02:38 -0700
Subject: 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 b5098d515d5..2cccfba93c1 160000
--- a/src/tools/enzyme
+++ b/src/tools/enzyme
@@ -1 +1 @@
-Subproject commit b5098d515d5e1bd0f5470553bc0d18da9794ca8b
+Subproject commit 2cccfba93c1650f26f1cf8be8aa875a7c1d23fb3
-- 
cgit 1.4.1-3-g733a5


From 42d6b0d8bcdc5a0dfd77fe2daac6f8a8f67ac6cd Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Wed, 18 Jun 2025 15:25:29 -0700
Subject: make more builder functions generic

---
 compiler/rustc_codegen_llvm/src/declare.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs
index eb75716d768..960a895a203 100644
--- a/compiler/rustc_codegen_llvm/src/declare.rs
+++ b/compiler/rustc_codegen_llvm/src/declare.rs
@@ -215,7 +215,9 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
 
         llfn
     }
+}
 
+impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
     /// Declare a global with an intention to define it.
     ///
     /// Use this function when you intend to define a global. This function will
@@ -234,13 +236,13 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
     ///
     /// Use this function when you intend to define a global without a name.
     pub(crate) fn define_private_global(&self, ty: &'ll Type) -> &'ll Value {
-        unsafe { llvm::LLVMRustInsertPrivateGlobal(self.llmod, ty) }
+        unsafe { llvm::LLVMRustInsertPrivateGlobal(self.llmod(), ty) }
     }
 
     /// Gets declared value by name.
     pub(crate) fn get_declared_value(&self, name: &str) -> Option<&'ll Value> {
         debug!("get_declared_value(name={:?})", name);
-        unsafe { llvm::LLVMRustGetNamedValue(self.llmod, name.as_c_char_ptr(), name.len()) }
+        unsafe { llvm::LLVMRustGetNamedValue(self.llmod(), name.as_c_char_ptr(), name.len()) }
     }
 
     /// Gets defined or externally defined (AvailableExternally linkage) value by
-- 
cgit 1.4.1-3-g733a5


From 634016478ec95c6ff933d32789e663ace78e8f82 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Wed, 18 Jun 2025 15:29:43 -0700
Subject: add -Zoffload=Enable flag behind -Zunstable-options, to enable gpu
 (host) code generation

---
 compiler/rustc_codegen_llvm/src/back/lto.rs  |  6 ++++++
 compiler/rustc_codegen_ssa/src/back/write.rs |  2 ++
 compiler/rustc_interface/src/tests.rs        |  9 +++++----
 compiler/rustc_session/src/config.rs         | 19 ++++++++++++++++++-
 compiler/rustc_session/src/options.rs        | 27 +++++++++++++++++++++++++++
 5 files changed, 58 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index 655e1c95373..b050a69eece 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -668,6 +668,12 @@ pub(crate) fn run_pass_manager(
         write::llvm_optimize(cgcx, dcx, module, None, config, opt_level, opt_stage, stage)?;
     }
 
+    if enable_gpu && !thin {
+        let cx =
+            SimpleCx::new(module.module_llvm.llmod(), &module.module_llvm.llcx, cgcx.pointer_size);
+        crate::builder::gpu_offload::handle_gpu_code(cgcx, &cx);
+    }
+
     if cfg!(llvm_enzyme) && enable_ad && !thin {
         let cx =
             SimpleCx::new(module.module_llvm.llmod(), &module.module_llvm.llcx, cgcx.pointer_size);
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 50a7cba300b..24e0a4eb533 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -120,6 +120,7 @@ pub struct ModuleConfig {
     pub emit_lifetime_markers: bool,
     pub llvm_plugins: Vec<String>,
     pub autodiff: Vec<config::AutoDiff>,
+    pub offload: Vec<config::Offload>,
 }
 
 impl ModuleConfig {
@@ -268,6 +269,7 @@ impl ModuleConfig {
             emit_lifetime_markers: sess.emit_lifetime_markers(),
             llvm_plugins: if_regular!(sess.opts.unstable_opts.llvm_plugins.clone(), vec![]),
             autodiff: if_regular!(sess.opts.unstable_opts.autodiff.clone(), vec![]),
+            offload: if_regular!(sess.opts.unstable_opts.offload.clone(), vec![]),
         }
     }
 
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index 360b5629e9d..8771bb44050 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -13,10 +13,10 @@ use rustc_session::config::{
     CoverageOptions, DebugInfo, DumpMonoStatsFormat, ErrorOutputType, ExternEntry, ExternLocation,
     Externs, FmtDebug, FunctionReturn, InliningThreshold, Input, InstrumentCoverage,
     InstrumentXRay, LinkSelfContained, LinkerPluginLto, LocationDetail, LtoCli, MirIncludeSpans,
-    NextSolverConfig, OomStrategy, Options, OutFileName, OutputType, OutputTypes, PAuthKey, PacRet,
-    Passes, PatchableFunctionEntry, Polonius, ProcMacroExecutionStrategy, Strip, SwitchWithOptPath,
-    SymbolManglingVersion, WasiExecModel, build_configuration, build_session_options,
-    rustc_optgroups,
+    NextSolverConfig, Offload, OomStrategy, 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;
@@ -833,6 +833,7 @@ fn test_unstable_options_tracking_hash() {
     tracked!(no_profiler_runtime, true);
     tracked!(no_trait_vptr, true);
     tracked!(no_unique_section_names, true);
+    tracked!(offload, vec![Offload::Enable]);
     tracked!(on_broken_pipe, OnBrokenPipe::Kill);
     tracked!(oom, OomStrategy::Panic);
     tracked!(osx_rpath_install_name, true);
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index d6215e1de04..7bea8685724 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -226,6 +226,13 @@ pub enum CoverageLevel {
     Mcdc,
 }
 
+// The different settings that the `-Z offload` flag can have.
+#[derive(Clone, Copy, PartialEq, Hash, Debug)]
+pub enum Offload {
+    /// Enable the llvm offload pipeline
+    Enable,
+}
+
 /// The different settings that the `-Z autodiff` flag can have.
 #[derive(Clone, PartialEq, Hash, Debug)]
 pub enum AutoDiff {
@@ -2706,6 +2713,15 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
         )
     }
 
+    if !nightly_options::is_unstable_enabled(matches)
+        && unstable_opts.offload.contains(&Offload::Enable)
+    {
+        early_dcx.early_fatal(
+            "`-Zoffload=Enable` also requires `-Zunstable-options` \
+                and a nightly compiler",
+        )
+    }
+
     let target_triple = parse_target_triple(early_dcx, matches);
 
     // Ensure `-Z unstable-options` is required when using the unstable `-C link-self-contained` and
@@ -3178,7 +3194,7 @@ pub(crate) mod dep_tracking {
         AutoDiff, BranchProtection, CFGuard, CFProtection, CollapseMacroDebuginfo, CoverageOptions,
         CrateType, DebugInfo, DebugInfoCompression, ErrorOutputType, FmtDebug, FunctionReturn,
         InliningThreshold, InstrumentCoverage, InstrumentXRay, LinkerPluginLto, LocationDetail,
-        LtoCli, MirStripDebugInfo, NextSolverConfig, OomStrategy, OptLevel, OutFileName,
+        LtoCli, MirStripDebugInfo, NextSolverConfig, Offload, OomStrategy, OptLevel, OutFileName,
         OutputType, OutputTypes, PatchableFunctionEntry, Polonius, RemapPathScopeComponents,
         ResolveDocLinks, SourceFileHashAlgorithm, SplitDwarfKind, SwitchWithOptPath,
         SymbolManglingVersion, WasiExecModel,
@@ -3225,6 +3241,7 @@ pub(crate) mod dep_tracking {
     impl_dep_tracking_hash_via_hash!(
         (),
         AutoDiff,
+        Offload,
         bool,
         usize,
         NonZero<usize>,
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 2bdde2f887a..b33e3815ea4 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -726,6 +726,7 @@ mod desc {
     pub(crate) const parse_list_with_polarity: &str =
         "a comma-separated list of strings, with elements beginning with + or -";
     pub(crate) const parse_autodiff: &str = "a comma separated list of settings: `Enable`, `PrintSteps`, `PrintTA`, `PrintTAFn`, `PrintAA`, `PrintPerf`, `PrintModBefore`, `PrintModAfter`, `PrintModFinal`, `PrintPasses`, `NoPostopt`, `LooseTypes`, `Inline`";
+    pub(crate) const parse_offload: &str = "a comma separated list of settings: `Enable`";
     pub(crate) const parse_comma_list: &str = "a comma-separated list of strings";
     pub(crate) const parse_opt_comma_list: &str = parse_comma_list;
     pub(crate) const parse_number: &str = "a number";
@@ -1357,6 +1358,27 @@ pub mod parse {
         }
     }
 
+    pub(crate) fn parse_offload(slot: &mut Vec<Offload>, v: Option<&str>) -> bool {
+        let Some(v) = v else {
+            *slot = vec![];
+            return true;
+        };
+        let mut v: Vec<&str> = v.split(",").collect();
+        v.sort_unstable();
+        for &val in v.iter() {
+            let variant = match val {
+                "Enable" => Offload::Enable,
+                _ => {
+                    // FIXME(ZuseZ4): print an error saying which value is not recognized
+                    return false;
+                }
+            };
+            slot.push(variant);
+        }
+
+        true
+    }
+
     pub(crate) fn parse_autodiff(slot: &mut Vec<AutoDiff>, v: Option<&str>) -> bool {
         let Some(v) = v else {
             *slot = vec![];
@@ -2401,6 +2423,11 @@ options! {
         "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)"),
     oom: OomStrategy = (OomStrategy::Abort, parse_oom_strategy, [TRACKED],
-- 
cgit 1.4.1-3-g733a5


From 5958ebe829429e3595e8211e6cb1b0328d515ab7 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Wed, 2 Jul 2025 16:35:57 -0700
Subject: add various wrappers for gpu code generation

---
 compiler/rustc_codegen_llvm/src/builder.rs         | 69 ++++++++++++++++++++++
 compiler/rustc_codegen_llvm/src/context.rs         | 18 +++++-
 compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs | 10 +++-
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs        |  8 +++
 compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp   | 37 ++++++++++++
 5 files changed, 140 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 514923ad6f3..0ade9edb0d2 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -3,6 +3,7 @@ use std::ops::Deref;
 use std::{iter, ptr};
 
 pub(crate) mod autodiff;
+pub(crate) mod gpu_offload;
 
 use libc::{c_char, c_uint, size_t};
 use rustc_abi as abi;
@@ -117,6 +118,74 @@ impl<'a, 'll, CX: Borrow<SCx<'ll>>> GenericBuilder<'a, 'll, CX> {
         }
         bx
     }
+
+    // The generic builder has less functionality and thus (unlike the other alloca) we can not
+    // easily jump to the beginning of the function to place our allocas there. We trust the user
+    // to manually do that. FIXME(offload): improve the genericCx and add more llvm wrappers to
+    // handle this.
+    pub(crate) fn direct_alloca(&mut self, ty: &'ll Type, align: Align, name: &str) -> &'ll Value {
+        let val = unsafe {
+            let alloca = llvm::LLVMBuildAlloca(self.llbuilder, ty, UNNAMED);
+            llvm::LLVMSetAlignment(alloca, align.bytes() as c_uint);
+            // Cast to default addrspace if necessary
+            llvm::LLVMBuildPointerCast(self.llbuilder, alloca, self.cx.type_ptr(), UNNAMED)
+        };
+        if name != "" {
+            let name = std::ffi::CString::new(name).unwrap();
+            llvm::set_value_name(val, &name.as_bytes());
+        }
+        val
+    }
+
+    pub(crate) fn inbounds_gep(
+        &mut self,
+        ty: &'ll Type,
+        ptr: &'ll Value,
+        indices: &[&'ll Value],
+    ) -> &'ll Value {
+        unsafe {
+            llvm::LLVMBuildGEPWithNoWrapFlags(
+                self.llbuilder,
+                ty,
+                ptr,
+                indices.as_ptr(),
+                indices.len() as c_uint,
+                UNNAMED,
+                GEPNoWrapFlags::InBounds,
+            )
+        }
+    }
+
+    pub(crate) fn store(&mut self, val: &'ll Value, ptr: &'ll Value, align: Align) -> &'ll Value {
+        debug!("Store {:?} -> {:?}", val, ptr);
+        assert_eq!(self.cx.type_kind(self.cx.val_ty(ptr)), TypeKind::Pointer);
+        unsafe {
+            let store = llvm::LLVMBuildStore(self.llbuilder, val, ptr);
+            llvm::LLVMSetAlignment(store, align.bytes() as c_uint);
+            store
+        }
+    }
+
+    pub(crate) fn load(&mut self, ty: &'ll Type, ptr: &'ll Value, align: Align) -> &'ll Value {
+        unsafe {
+            let load = llvm::LLVMBuildLoad2(self.llbuilder, ty, ptr, UNNAMED);
+            llvm::LLVMSetAlignment(load, align.bytes() as c_uint);
+            load
+        }
+    }
+
+    fn memset(&mut self, ptr: &'ll Value, fill_byte: &'ll Value, size: &'ll Value, align: Align) {
+        unsafe {
+            llvm::LLVMRustBuildMemSet(
+                self.llbuilder,
+                ptr,
+                align.bytes() as c_uint,
+                fill_byte,
+                size,
+                false,
+            );
+        }
+    }
 }
 
 /// Empty string, to be used where LLVM expects an instruction name, indicating
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 6a23becaa96..afbc2971dd7 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -211,7 +211,7 @@ pub(crate) unsafe fn create_module<'ll>(
 
     // Ensure the data-layout values hardcoded remain the defaults.
     {
-        let tm = crate::back::write::create_informational_target_machine(tcx.sess, false);
+        let tm = crate::back::write::create_informational_target_machine(sess, false);
         unsafe {
             llvm::LLVMRustSetDataLayoutFromTargetMachine(llmod, tm.raw());
         }
@@ -680,6 +680,22 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
         unsafe { llvm::LLVMConstInt(ty, val, llvm::False) }
     }
 
+    pub(crate) fn get_const_i64(&self, n: u64) -> &'ll Value {
+        self.get_const_int(self.type_i64(), n)
+    }
+
+    pub(crate) fn get_const_i32(&self, n: u64) -> &'ll Value {
+        self.get_const_int(self.type_i32(), n)
+    }
+
+    pub(crate) fn get_const_i16(&self, n: u64) -> &'ll Value {
+        self.get_const_int(self.type_i16(), n)
+    }
+
+    pub(crate) fn get_const_i8(&self, n: u64) -> &'ll Value {
+        self.get_const_int(self.type_i8(), n)
+    }
+
     pub(crate) fn get_function(&self, name: &str) -> Option<&'ll Value> {
         let name = SmallCStr::new(name);
         unsafe { llvm::LLVMGetNamedFunction((**self).borrow().llmod, name.as_ptr()) }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index c696b8d8ff2..56d756e52cc 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -4,7 +4,7 @@ use libc::{c_char, c_uint};
 
 use super::MetadataKindId;
 use super::ffi::{AttributeKind, BasicBlock, Metadata, Module, Type, Value};
-use crate::llvm::Bool;
+use crate::llvm::{Bool, Builder};
 
 #[link(name = "llvm-wrapper", kind = "static")]
 unsafe extern "C" {
@@ -31,6 +31,14 @@ unsafe extern "C" {
         index: c_uint,
         kind: AttributeKind,
     );
+    pub(crate) fn LLVMRustPositionBefore<'a>(B: &'a Builder<'_>, I: &'a Value);
+    pub(crate) fn LLVMRustPositionAfter<'a>(B: &'a Builder<'_>, I: &'a Value);
+    pub(crate) fn LLVMRustGetFunctionCall(
+        F: &Value,
+        name: *const c_char,
+        NameLen: libc::size_t,
+    ) -> Option<&Value>;
+
 }
 
 unsafe extern "C" {
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 0b1e632cbc4..c2dd29334cd 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1138,6 +1138,11 @@ unsafe extern "C" {
         Count: c_uint,
         Packed: Bool,
     ) -> &'a Value;
+    pub(crate) fn LLVMConstNamedStruct<'a>(
+        StructTy: &'a Type,
+        ConstantVals: *const &'a Value,
+        Count: c_uint,
+    ) -> &'a Value;
     pub(crate) fn LLVMConstVector(ScalarConstantVals: *const &Value, Size: c_uint) -> &Value;
 
     // Constant expressions
@@ -1217,6 +1222,8 @@ unsafe extern "C" {
     ) -> &'a BasicBlock;
 
     // Operations on instructions
+    pub(crate) fn LLVMGetInstructionParent(Inst: &Value) -> &BasicBlock;
+    pub(crate) fn LLVMGetCalledValue(CallInst: &Value) -> Option<&Value>;
     pub(crate) fn LLVMIsAInstruction(Val: &Value) -> Option<&Value>;
     pub(crate) fn LLVMGetFirstBasicBlock(Fn: &Value) -> &BasicBlock;
     pub(crate) fn LLVMGetOperand(Val: &Value, Index: c_uint) -> Option<&Value>;
@@ -2556,6 +2563,7 @@ unsafe extern "C" {
 
     pub(crate) fn LLVMRustSetDataLayoutFromTargetMachine<'a>(M: &'a Module, TM: &'a TargetMachine);
 
+    pub(crate) fn LLVMRustPositionBuilderPastAllocas<'a>(B: &Builder<'a>, Fn: &'a Value);
     pub(crate) fn LLVMRustPositionBuilderAtStart<'a>(B: &Builder<'a>, BB: &'a BasicBlock);
 
     pub(crate) fn LLVMRustSetModulePICLevel(M: &Module);
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 90aa9188c83..82568ed4ae1 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -1591,12 +1591,49 @@ extern "C" LLVMValueRef LLVMRustBuildMemSet(LLVMBuilderRef B, LLVMValueRef Dst,
                                       MaybeAlign(DstAlign), IsVolatile));
 }
 
+extern "C" void LLVMRustPositionBuilderPastAllocas(LLVMBuilderRef B,
+                                                   LLVMValueRef Fn) {
+  Function *F = unwrap<Function>(Fn);
+  unwrap(B)->SetInsertPointPastAllocas(F);
+}
 extern "C" void LLVMRustPositionBuilderAtStart(LLVMBuilderRef B,
                                                LLVMBasicBlockRef BB) {
   auto Point = unwrap(BB)->getFirstInsertionPt();
   unwrap(B)->SetInsertPoint(unwrap(BB), Point);
 }
 
+extern "C" void LLVMRustPositionBefore(LLVMBuilderRef B, LLVMValueRef Instr) {
+  if (auto I = dyn_cast<Instruction>(unwrap<Value>(Instr))) {
+    unwrap(B)->SetInsertPoint(I);
+  }
+}
+
+extern "C" void LLVMRustPositionAfter(LLVMBuilderRef B, LLVMValueRef Instr) {
+  if (auto I = dyn_cast<Instruction>(unwrap<Value>(Instr))) {
+    auto J = I->getNextNonDebugInstruction();
+    unwrap(B)->SetInsertPoint(J);
+  }
+}
+
+extern "C" LLVMValueRef
+LLVMRustGetFunctionCall(LLVMValueRef Fn, const char *Name, size_t NameLen) {
+  auto targetName = StringRef(Name, NameLen);
+  Function *F = unwrap<Function>(Fn);
+  for (auto &BB : *F) {
+    for (auto &I : BB) {
+      if (auto *callInst = llvm::dyn_cast<llvm::CallBase>(&I)) {
+        const llvm::Function *calledFunc = callInst->getCalledFunction();
+        if (calledFunc && calledFunc->getName() == targetName) {
+          // Found a call to the target function
+          return wrap(callInst);
+        }
+      }
+    }
+  }
+
+  return nullptr;
+}
+
 extern "C" bool LLVMRustConstIntGetZExtValue(LLVMValueRef CV, uint64_t *value) {
   auto C = unwrap<llvm::ConstantInt>(CV);
   if (C->getBitWidth() > 64)
-- 
cgit 1.4.1-3-g733a5


From 4a1a5a42952d05533fd4309ad0f3fe290abbf57c Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Wed, 2 Jul 2025 16:36:30 -0700
Subject: gpu host code generation

---
 compiler/rustc_codegen_llvm/src/back/lto.rs        |   1 +
 .../rustc_codegen_llvm/src/builder/gpu_offload.rs  | 439 +++++++++++++++++++++
 compiler/rustc_codegen_llvm/src/common.rs          |   9 +
 compiler/rustc_codegen_llvm/src/lib.rs             |  22 +-
 4 files changed, 464 insertions(+), 7 deletions(-)
 create mode 100644 compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs

diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index b050a69eece..84302009da9 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -654,6 +654,7 @@ pub(crate) fn run_pass_manager(
     // We then run the llvm_optimize function a second time, to optimize the code which we generated
     // in the enzyme differentiation pass.
     let enable_ad = config.autodiff.contains(&config::AutoDiff::Enable);
+    let enable_gpu = config.offload.contains(&config::Offload::Enable);
     let stage = if thin {
         write::AutodiffStage::PreAD
     } else {
diff --git a/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs b/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs
new file mode 100644
index 00000000000..1280ab1442a
--- /dev/null
+++ b/compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs
@@ -0,0 +1,439 @@
+use std::ffi::CString;
+
+use llvm::Linkage::*;
+use rustc_abi::Align;
+use rustc_codegen_ssa::back::write::CodegenContext;
+use rustc_codegen_ssa::traits::BaseTypeCodegenMethods;
+
+use crate::builder::SBuilder;
+use crate::common::AsCCharPtr;
+use crate::llvm::AttributePlace::Function;
+use crate::llvm::{self, Linkage, Type, Value};
+use crate::{LlvmCodegenBackend, SimpleCx, attributes};
+
+pub(crate) fn handle_gpu_code<'ll>(
+    _cgcx: &CodegenContext<LlvmCodegenBackend>,
+    cx: &'ll SimpleCx<'_>,
+) {
+    // The offload memory transfer type for each kernel
+    let mut o_types = vec![];
+    let mut kernels = vec![];
+    let offload_entry_ty = add_tgt_offload_entry(&cx);
+    for num in 0..9 {
+        let kernel = cx.get_function(&format!("kernel_{num}"));
+        if let Some(kernel) = kernel {
+            o_types.push(gen_define_handling(&cx, kernel, offload_entry_ty, num));
+            kernels.push(kernel);
+        }
+    }
+
+    gen_call_handling(&cx, &kernels, &o_types);
+}
+
+// What is our @1 here? A magic global, used in our data_{begin/update/end}_mapper:
+// @0 = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00", align 1
+// @1 = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 22, ptr @0 }, align 8
+fn generate_at_one<'ll>(cx: &'ll SimpleCx<'_>) -> &'ll llvm::Value {
+    // @0 = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00", align 1
+    let unknown_txt = ";unknown;unknown;0;0;;";
+    let c_entry_name = CString::new(unknown_txt).unwrap();
+    let c_val = c_entry_name.as_bytes_with_nul();
+    let initializer = crate::common::bytes_in_context(cx.llcx, c_val);
+    let at_zero = add_unnamed_global(&cx, &"", initializer, PrivateLinkage);
+    llvm::set_alignment(at_zero, Align::ONE);
+
+    // @1 = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 22, ptr @0 }, align 8
+    let struct_ident_ty = cx.type_named_struct("struct.ident_t");
+    let struct_elems = vec![
+        cx.get_const_i32(0),
+        cx.get_const_i32(2),
+        cx.get_const_i32(0),
+        cx.get_const_i32(22),
+        at_zero,
+    ];
+    let struct_elems_ty: Vec<_> = struct_elems.iter().map(|&x| cx.val_ty(x)).collect();
+    let initializer = crate::common::named_struct(struct_ident_ty, &struct_elems);
+    cx.set_struct_body(struct_ident_ty, &struct_elems_ty, false);
+    let at_one = add_unnamed_global(&cx, &"", initializer, PrivateLinkage);
+    llvm::set_alignment(at_one, Align::EIGHT);
+    at_one
+}
+
+pub(crate) fn add_tgt_offload_entry<'ll>(cx: &'ll SimpleCx<'_>) -> &'ll llvm::Type {
+    let offload_entry_ty = cx.type_named_struct("struct.__tgt_offload_entry");
+    let tptr = cx.type_ptr();
+    let ti64 = cx.type_i64();
+    let ti32 = cx.type_i32();
+    let ti16 = cx.type_i16();
+    // For each kernel to run on the gpu, we will later generate one entry of this type.
+    // copied from LLVM
+    // typedef struct {
+    //   uint64_t Reserved;
+    //   uint16_t Version;
+    //   uint16_t Kind;
+    //   uint32_t Flags; Flags associated with the entry (see Target Region Entry Flags)
+    //   void *Address; Address of global symbol within device image (function or global)
+    //   char *SymbolName;
+    //   uint64_t Size; Size of the entry info (0 if it is a function)
+    //   uint64_t Data;
+    //   void *AuxAddr;
+    // } __tgt_offload_entry;
+    let entry_elements = vec![ti64, ti16, ti16, ti32, tptr, tptr, ti64, ti64, tptr];
+    cx.set_struct_body(offload_entry_ty, &entry_elements, false);
+    offload_entry_ty
+}
+
+fn gen_tgt_kernel_global<'ll>(cx: &'ll SimpleCx<'_>) {
+    let kernel_arguments_ty = cx.type_named_struct("struct.__tgt_kernel_arguments");
+    let tptr = cx.type_ptr();
+    let ti64 = cx.type_i64();
+    let ti32 = cx.type_i32();
+    let tarr = cx.type_array(ti32, 3);
+
+    // Taken from the LLVM APITypes.h declaration:
+    //struct KernelArgsTy {
+    //  uint32_t Version = 0; // Version of this struct for ABI compatibility.
+    //  uint32_t NumArgs = 0; // Number of arguments in each input pointer.
+    //  void **ArgBasePtrs =
+    //      nullptr;                 // Base pointer of each argument (e.g. a struct).
+    //  void **ArgPtrs = nullptr;    // Pointer to the argument data.
+    //  int64_t *ArgSizes = nullptr; // Size of the argument data in bytes.
+    //  int64_t *ArgTypes = nullptr; // Type of the data (e.g. to / from).
+    //  void **ArgNames = nullptr;   // Name of the data for debugging, possibly null.
+    //  void **ArgMappers = nullptr; // User-defined mappers, possibly null.
+    //  uint64_t Tripcount =
+    //      0; // Tripcount for the teams / distribute loop, 0 otherwise.
+    //  struct {
+    //    uint64_t NoWait : 1; // Was this kernel spawned with a `nowait` clause.
+    //    uint64_t IsCUDA : 1; // Was this kernel spawned via CUDA.
+    //    uint64_t Unused : 62;
+    //  } Flags = {0, 0, 0};
+    //  // The number of teams (for x,y,z dimension).
+    //  uint32_t NumTeams[3] = {0, 0, 0};
+    //  // The number of threads (for x,y,z dimension).
+    //  uint32_t ThreadLimit[3] = {0, 0, 0};
+    //  uint32_t DynCGroupMem = 0; // Amount of dynamic cgroup memory requested.
+    //};
+    let kernel_elements =
+        vec![ti32, ti32, tptr, tptr, tptr, tptr, tptr, tptr, ti64, ti64, tarr, tarr, ti32];
+
+    cx.set_struct_body(kernel_arguments_ty, &kernel_elements, false);
+    // For now we don't handle kernels, so for now we just add a global dummy
+    // to make sure that the __tgt_offload_entry is defined and handled correctly.
+    cx.declare_global("my_struct_global2", kernel_arguments_ty);
+}
+
+fn gen_tgt_data_mappers<'ll>(
+    cx: &'ll SimpleCx<'_>,
+) -> (&'ll llvm::Value, &'ll llvm::Value, &'ll llvm::Value, &'ll llvm::Type) {
+    let tptr = cx.type_ptr();
+    let ti64 = cx.type_i64();
+    let ti32 = cx.type_i32();
+
+    let args = vec![tptr, ti64, ti32, tptr, tptr, tptr, tptr, tptr, tptr];
+    let mapper_fn_ty = cx.type_func(&args, cx.type_void());
+    let mapper_begin = "__tgt_target_data_begin_mapper";
+    let mapper_update = "__tgt_target_data_update_mapper";
+    let mapper_end = "__tgt_target_data_end_mapper";
+    let begin_mapper_decl = declare_offload_fn(&cx, mapper_begin, mapper_fn_ty);
+    let update_mapper_decl = declare_offload_fn(&cx, mapper_update, mapper_fn_ty);
+    let end_mapper_decl = declare_offload_fn(&cx, mapper_end, mapper_fn_ty);
+
+    let nounwind = llvm::AttributeKind::NoUnwind.create_attr(cx.llcx);
+    attributes::apply_to_llfn(begin_mapper_decl, Function, &[nounwind]);
+    attributes::apply_to_llfn(update_mapper_decl, Function, &[nounwind]);
+    attributes::apply_to_llfn(end_mapper_decl, Function, &[nounwind]);
+
+    (begin_mapper_decl, update_mapper_decl, end_mapper_decl, mapper_fn_ty)
+}
+
+fn add_priv_unnamed_arr<'ll>(cx: &SimpleCx<'ll>, name: &str, vals: &[u64]) -> &'ll llvm::Value {
+    let ti64 = cx.type_i64();
+    let mut size_val = Vec::with_capacity(vals.len());
+    for &val in vals {
+        size_val.push(cx.get_const_i64(val));
+    }
+    let initializer = cx.const_array(ti64, &size_val);
+    add_unnamed_global(cx, name, initializer, PrivateLinkage)
+}
+
+pub(crate) fn add_unnamed_global<'ll>(
+    cx: &SimpleCx<'ll>,
+    name: &str,
+    initializer: &'ll llvm::Value,
+    l: Linkage,
+) -> &'ll llvm::Value {
+    let llglobal = add_global(cx, name, initializer, l);
+    llvm::LLVMSetUnnamedAddress(llglobal, llvm::UnnamedAddr::Global);
+    llglobal
+}
+
+pub(crate) fn add_global<'ll>(
+    cx: &SimpleCx<'ll>,
+    name: &str,
+    initializer: &'ll llvm::Value,
+    l: Linkage,
+) -> &'ll llvm::Value {
+    let c_name = CString::new(name).unwrap();
+    let llglobal: &'ll llvm::Value = llvm::add_global(cx.llmod, cx.val_ty(initializer), &c_name);
+    llvm::set_global_constant(llglobal, true);
+    llvm::set_linkage(llglobal, l);
+    llvm::set_initializer(llglobal, initializer);
+    llglobal
+}
+
+fn gen_define_handling<'ll>(
+    cx: &'ll SimpleCx<'_>,
+    kernel: &'ll llvm::Value,
+    offload_entry_ty: &'ll llvm::Type,
+    num: i64,
+) -> &'ll llvm::Value {
+    let types = cx.func_params_types(cx.get_type_of_global(kernel));
+    // It seems like non-pointer values are automatically mapped. So here, we focus on pointer (or
+    // reference) types.
+    let num_ptr_types = types
+        .iter()
+        .map(|&x| matches!(cx.type_kind(x), rustc_codegen_ssa::common::TypeKind::Pointer))
+        .count();
+
+    // We do not know their size anymore at this level, so hardcode a placeholder.
+    // A follow-up pr will track these from the frontend, where we still have Rust types.
+    // Then, we will be able to figure out that e.g. `&[f32;256]` will result in 4*256 bytes.
+    // I decided that 1024 bytes is a great placeholder value for now.
+    add_priv_unnamed_arr(&cx, &format!(".offload_sizes.{num}"), &vec![1024; num_ptr_types]);
+    // Here we figure out whether something needs to be copied to the gpu (=1), from the gpu (=2),
+    // or both to and from the gpu (=3). Other values shouldn't affect us for now.
+    // A non-mutable reference or pointer will be 1, an array that's not read, but fully overwritten
+    // will be 2. For now, everything is 3, until we have our frontend set up.
+    let o_types =
+        add_priv_unnamed_arr(&cx, &format!(".offload_maptypes.{num}"), &vec![3; num_ptr_types]);
+    // Next: For each function, generate these three entries. A weak constant,
+    // the llvm.rodata entry name, and  the omp_offloading_entries value
+
+    let name = format!(".kernel_{num}.region_id");
+    let initializer = cx.get_const_i8(0);
+    let region_id = add_unnamed_global(&cx, &name, initializer, WeakAnyLinkage);
+
+    let c_entry_name = CString::new(format!("kernel_{num}")).unwrap();
+    let c_val = c_entry_name.as_bytes_with_nul();
+    let offload_entry_name = format!(".offloading.entry_name.{num}");
+
+    let initializer = crate::common::bytes_in_context(cx.llcx, c_val);
+    let llglobal = add_unnamed_global(&cx, &offload_entry_name, initializer, InternalLinkage);
+    llvm::set_alignment(llglobal, Align::ONE);
+    llvm::set_section(llglobal, c".llvm.rodata.offloading");
+
+    // Not actively used yet, for calling real kernels
+    let name = format!(".offloading.entry.kernel_{num}");
+
+    // See the __tgt_offload_entry documentation above.
+    let reserved = cx.get_const_i64(0);
+    let version = cx.get_const_i16(1);
+    let kind = cx.get_const_i16(1);
+    let flags = cx.get_const_i32(0);
+    let size = cx.get_const_i64(0);
+    let data = cx.get_const_i64(0);
+    let aux_addr = cx.const_null(cx.type_ptr());
+    let elems = vec![reserved, version, kind, flags, region_id, llglobal, size, data, aux_addr];
+
+    let initializer = crate::common::named_struct(offload_entry_ty, &elems);
+    let c_name = CString::new(name).unwrap();
+    let llglobal = llvm::add_global(cx.llmod, offload_entry_ty, &c_name);
+    llvm::set_global_constant(llglobal, true);
+    llvm::set_linkage(llglobal, WeakAnyLinkage);
+    llvm::set_initializer(llglobal, initializer);
+    llvm::set_alignment(llglobal, Align::ONE);
+    let c_section_name = CString::new(".omp_offloading_entries").unwrap();
+    llvm::set_section(llglobal, &c_section_name);
+    o_types
+}
+
+fn declare_offload_fn<'ll>(
+    cx: &'ll SimpleCx<'_>,
+    name: &str,
+    ty: &'ll llvm::Type,
+) -> &'ll llvm::Value {
+    crate::declare::declare_simple_fn(
+        cx,
+        name,
+        llvm::CallConv::CCallConv,
+        llvm::UnnamedAddr::No,
+        llvm::Visibility::Default,
+        ty,
+    )
+}
+
+// For each kernel *call*, we now use some of our previous declared globals to move data to and from
+// the gpu. We don't have a proper frontend yet, so we assume that every call to a kernel function
+// from main is intended to run on the GPU. For now, we only handle the data transfer part of it.
+// If two consecutive kernels use the same memory, we still move it to the host and back to the gpu.
+// Since in our frontend users (by default) don't have to specify data transfer, this is something
+// we should optimize in the future! We also assume that everything should be copied back and forth,
+// but sometimes we can directly zero-allocate on the device and only move back, or if something is
+// immutable, we might only copy it to the device, but not back.
+//
+// Current steps:
+// 0. Alloca some variables for the following steps
+// 1. set insert point before kernel call.
+// 2. generate all the GEPS and stores, to be used in 3)
+// 3. generate __tgt_target_data_begin calls to move data to the GPU
+//
+// unchanged: keep kernel call. Later move the kernel to the GPU
+//
+// 4. set insert point after kernel call.
+// 5. generate all the GEPS and stores, to be used in 6)
+// 6. generate __tgt_target_data_end calls to move data from the GPU
+fn gen_call_handling<'ll>(
+    cx: &'ll SimpleCx<'_>,
+    _kernels: &[&'ll llvm::Value],
+    o_types: &[&'ll llvm::Value],
+) {
+    // %struct.__tgt_bin_desc = type { i32, ptr, ptr, ptr }
+    let tptr = cx.type_ptr();
+    let ti32 = cx.type_i32();
+    let tgt_bin_desc_ty = vec![ti32, tptr, tptr, tptr];
+    let tgt_bin_desc = cx.type_named_struct("struct.__tgt_bin_desc");
+    cx.set_struct_body(tgt_bin_desc, &tgt_bin_desc_ty, false);
+
+    gen_tgt_kernel_global(&cx);
+    let (begin_mapper_decl, _, end_mapper_decl, fn_ty) = gen_tgt_data_mappers(&cx);
+
+    let main_fn = cx.get_function("main");
+    let Some(main_fn) = main_fn else { return };
+    let kernel_name = "kernel_1";
+    let call = unsafe {
+        llvm::LLVMRustGetFunctionCall(main_fn, kernel_name.as_c_char_ptr(), kernel_name.len())
+    };
+    let Some(kernel_call) = call else {
+        return;
+    };
+    let kernel_call_bb = unsafe { llvm::LLVMGetInstructionParent(kernel_call) };
+    let called = unsafe { llvm::LLVMGetCalledValue(kernel_call).unwrap() };
+    let mut builder = SBuilder::build(cx, kernel_call_bb);
+
+    let types = cx.func_params_types(cx.get_type_of_global(called));
+    let num_args = types.len() as u64;
+
+    // Step 0)
+    // %struct.__tgt_bin_desc = type { i32, ptr, ptr, ptr }
+    // %6 = alloca %struct.__tgt_bin_desc, align 8
+    unsafe { llvm::LLVMRustPositionBuilderPastAllocas(builder.llbuilder, main_fn) };
+
+    let tgt_bin_desc_alloca = builder.direct_alloca(tgt_bin_desc, Align::EIGHT, "EmptyDesc");
+
+    let ty = cx.type_array(cx.type_ptr(), num_args);
+    // Baseptr are just the input pointer to the kernel, stored in a local alloca
+    let a1 = builder.direct_alloca(ty, Align::EIGHT, ".offload_baseptrs");
+    // Ptrs are the result of a gep into the baseptr, at least for our trivial types.
+    let a2 = builder.direct_alloca(ty, Align::EIGHT, ".offload_ptrs");
+    // These represent the sizes in bytes, e.g. the entry for `&[f64; 16]` will be 8*16.
+    let ty2 = cx.type_array(cx.type_i64(), num_args);
+    let a4 = builder.direct_alloca(ty2, Align::EIGHT, ".offload_sizes");
+    // Now we allocate once per function param, a copy to be passed to one of our maps.
+    let mut vals = vec![];
+    let mut geps = vec![];
+    let i32_0 = cx.get_const_i32(0);
+    for (index, in_ty) in types.iter().enumerate() {
+        // get function arg, store it into the alloca, and read it.
+        let p = llvm::get_param(called, index as u32);
+        let name = llvm::get_value_name(p);
+        let name = str::from_utf8(&name).unwrap();
+        let arg_name = format!("{name}.addr");
+        let alloca = builder.direct_alloca(in_ty, Align::EIGHT, &arg_name);
+
+        builder.store(p, alloca, Align::EIGHT);
+        let val = builder.load(in_ty, alloca, Align::EIGHT);
+        let gep = builder.inbounds_gep(cx.type_f32(), val, &[i32_0]);
+        vals.push(val);
+        geps.push(gep);
+    }
+
+    // Step 1)
+    unsafe { llvm::LLVMRustPositionBefore(builder.llbuilder, kernel_call) };
+    builder.memset(tgt_bin_desc_alloca, cx.get_const_i8(0), cx.get_const_i64(32), Align::EIGHT);
+
+    let mapper_fn_ty = cx.type_func(&[cx.type_ptr()], cx.type_void());
+    let register_lib_decl = declare_offload_fn(&cx, "__tgt_register_lib", mapper_fn_ty);
+    let unregister_lib_decl = declare_offload_fn(&cx, "__tgt_unregister_lib", mapper_fn_ty);
+    let init_ty = cx.type_func(&[], cx.type_void());
+    let init_rtls_decl = declare_offload_fn(cx, "__tgt_init_all_rtls", init_ty);
+
+    // call void @__tgt_register_lib(ptr noundef %6)
+    builder.call(mapper_fn_ty, register_lib_decl, &[tgt_bin_desc_alloca], None);
+    // call void @__tgt_init_all_rtls()
+    builder.call(init_ty, init_rtls_decl, &[], None);
+
+    for i in 0..num_args {
+        let idx = cx.get_const_i32(i);
+        let gep1 = builder.inbounds_gep(ty, a1, &[i32_0, idx]);
+        builder.store(vals[i as usize], gep1, Align::EIGHT);
+        let gep2 = builder.inbounds_gep(ty, a2, &[i32_0, idx]);
+        builder.store(geps[i as usize], gep2, Align::EIGHT);
+        let gep3 = builder.inbounds_gep(ty2, a4, &[i32_0, idx]);
+        // As mentioned above, we don't use Rust type information yet. So for now we will just
+        // assume that we have 1024 bytes, 256 f32 values.
+        // FIXME(offload): write an offload frontend and handle arbitrary types.
+        builder.store(cx.get_const_i64(1024), gep3, Align::EIGHT);
+    }
+
+    // For now we have a very simplistic indexing scheme into our
+    // offload_{baseptrs,ptrs,sizes}. We will probably improve this along with our gpu frontend pr.
+    fn get_geps<'a, 'll>(
+        builder: &mut SBuilder<'a, 'll>,
+        cx: &'ll SimpleCx<'ll>,
+        ty: &'ll Type,
+        ty2: &'ll Type,
+        a1: &'ll Value,
+        a2: &'ll Value,
+        a4: &'ll Value,
+    ) -> (&'ll Value, &'ll Value, &'ll Value) {
+        let i32_0 = cx.get_const_i32(0);
+
+        let gep1 = builder.inbounds_gep(ty, a1, &[i32_0, i32_0]);
+        let gep2 = builder.inbounds_gep(ty, a2, &[i32_0, i32_0]);
+        let gep3 = builder.inbounds_gep(ty2, a4, &[i32_0, i32_0]);
+        (gep1, gep2, gep3)
+    }
+
+    fn generate_mapper_call<'a, 'll>(
+        builder: &mut SBuilder<'a, 'll>,
+        cx: &'ll SimpleCx<'ll>,
+        geps: (&'ll Value, &'ll Value, &'ll Value),
+        o_type: &'ll Value,
+        fn_to_call: &'ll Value,
+        fn_ty: &'ll Type,
+        num_args: u64,
+        s_ident_t: &'ll Value,
+    ) {
+        let nullptr = cx.const_null(cx.type_ptr());
+        let i64_max = cx.get_const_i64(u64::MAX);
+        let num_args = cx.get_const_i32(num_args);
+        let args =
+            vec![s_ident_t, i64_max, num_args, geps.0, geps.1, geps.2, o_type, nullptr, nullptr];
+        builder.call(fn_ty, fn_to_call, &args, None);
+    }
+
+    // Step 2)
+    let s_ident_t = generate_at_one(&cx);
+    let o = o_types[0];
+    let geps = get_geps(&mut builder, &cx, ty, ty2, a1, a2, a4);
+    generate_mapper_call(&mut builder, &cx, geps, o, begin_mapper_decl, fn_ty, num_args, s_ident_t);
+
+    // Step 3)
+    // Here we will add code for the actual kernel launches in a follow-up PR.
+    // FIXME(offload): launch kernels
+
+    // Step 4)
+    unsafe { llvm::LLVMRustPositionAfter(builder.llbuilder, kernel_call) };
+
+    let geps = get_geps(&mut builder, &cx, ty, ty2, a1, a2, a4);
+    generate_mapper_call(&mut builder, &cx, geps, o, end_mapper_decl, fn_ty, num_args, s_ident_t);
+
+    builder.call(mapper_fn_ty, unregister_lib_decl, &[tgt_bin_desc_alloca], None);
+
+    // With this we generated the following begin and end mappers. We could easily generate the
+    // update mapper in an update.
+    // call void @__tgt_target_data_begin_mapper(ptr @1, i64 -1, i32 3, ptr %27, ptr %28, ptr %29, ptr @.offload_maptypes, ptr null, ptr null)
+    // call void @__tgt_target_data_update_mapper(ptr @1, i64 -1, i32 2, ptr %46, ptr %47, ptr %48, ptr @.offload_maptypes.1, ptr null, ptr null)
+    // call void @__tgt_target_data_end_mapper(ptr @1, i64 -1, i32 3, ptr %49, ptr %50, ptr %51, ptr @.offload_maptypes, ptr null, ptr null)
+}
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
index f9ab96b5789..f29fefb66f0 100644
--- a/compiler/rustc_codegen_llvm/src/common.rs
+++ b/compiler/rustc_codegen_llvm/src/common.rs
@@ -118,6 +118,10 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
             r
         }
     }
+
+    pub(crate) fn const_null(&self, t: &'ll Type) -> &'ll Value {
+        unsafe { llvm::LLVMConstNull(t) }
+    }
 }
 
 impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
@@ -377,6 +381,11 @@ pub(crate) fn bytes_in_context<'ll>(llcx: &'ll llvm::Context, bytes: &[u8]) -> &
     }
 }
 
+pub(crate) fn named_struct<'ll>(ty: &'ll Type, elts: &[&'ll Value]) -> &'ll Value {
+    let len = c_uint::try_from(elts.len()).expect("LLVMConstStructInContext elements len overflow");
+    unsafe { llvm::LLVMConstNamedStruct(ty, elts.as_ptr(), len) }
+}
+
 fn struct_in_context<'ll>(
     llcx: &'ll llvm::Context,
     elts: &[&'ll Value],
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 6db4e122ad6..aaf21f9ada9 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -412,6 +412,20 @@ impl ModuleLlvm {
         }
     }
 
+    fn tm_from_cgcx(
+        cgcx: &CodegenContext<LlvmCodegenBackend>,
+        name: &str,
+        dcx: DiagCtxtHandle<'_>,
+    ) -> Result<OwnedTargetMachine, FatalError> {
+        let tm_factory_config = TargetMachineFactoryConfig::new(cgcx, name);
+        match (cgcx.tm_factory)(tm_factory_config) {
+            Ok(m) => Ok(m),
+            Err(e) => {
+                return Err(dcx.emit_almost_fatal(ParseTargetMachineConfig(e)));
+            }
+        }
+    }
+
     fn parse(
         cgcx: &CodegenContext<LlvmCodegenBackend>,
         name: &CStr,
@@ -421,13 +435,7 @@ impl ModuleLlvm {
         unsafe {
             let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names);
             let llmod_raw = back::lto::parse_module(llcx, name, buffer, dcx)?;
-            let tm_factory_config = TargetMachineFactoryConfig::new(cgcx, name.to_str().unwrap());
-            let tm = match (cgcx.tm_factory)(tm_factory_config) {
-                Ok(m) => m,
-                Err(e) => {
-                    return Err(dcx.emit_almost_fatal(ParseTargetMachineConfig(e)));
-                }
-            };
+            let tm = ModuleLlvm::tm_from_cgcx(cgcx, name.to_str().unwrap(), dcx)?;
 
             Ok(ModuleLlvm { llmod_raw, llcx, tm: ManuallyDrop::new(tm) })
         }
-- 
cgit 1.4.1-3-g733a5


From e2ab312c9408761faf64723c77cd4ba4a58792bc Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Fri, 18 Jul 2025 16:00:04 -0700
Subject: add gpu offload codegen host side test

---
 tests/codegen/gpu_offload/gpu_host.rs | 80 +++++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 tests/codegen/gpu_offload/gpu_host.rs

diff --git a/tests/codegen/gpu_offload/gpu_host.rs b/tests/codegen/gpu_offload/gpu_host.rs
new file mode 100644
index 00000000000..513e27426bc
--- /dev/null
+++ b/tests/codegen/gpu_offload/gpu_host.rs
@@ -0,0 +1,80 @@
+//@ compile-flags: -Zoffload=Enable -Zunstable-options -C opt-level=3  -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+
+// This test is verifying that we generate __tgt_target_data_*_mapper before and after a call to the
+// kernel_1. Better documentation to what each global or variable means is available in the gpu
+// offlaod code, or the LLVM offload documentation. This code does not launch any GPU kernels yet,
+// and will be rewritten once a proper offload frontend has landed.
+//
+// We currently only handle memory transfer for specific calls to functions named `kernel_{num}`,
+// when inside of a function called main. This, too, is a temporary workaround for not having a
+// frontend.
+
+#![no_main]
+
+#[unsafe(no_mangle)]
+fn main() {
+    let mut x = [3.0; 256];
+    kernel_1(&mut x);
+    core::hint::black_box(&x);
+}
+
+// CHECK: %struct.__tgt_offload_entry = type { i64, i16, i16, i32, ptr, ptr, i64, i64, ptr }
+// CHECK: %struct.__tgt_kernel_arguments = type { i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, i64, i64, [3 x i32], [3 x i32], i32 }
+// CHECK: %struct.ident_t = type { i32, i32, i32, i32, ptr }
+// CHECK: %struct.__tgt_bin_desc = type { i32, ptr, ptr, ptr }
+
+// CHECK: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 1024]
+// CHECK: @.offload_maptypes.1 = private unnamed_addr constant [1 x i64] [i64 3]
+// CHECK: @.kernel_1.region_id = weak unnamed_addr constant i8 0
+// CHECK: @.offloading.entry_name.1 = internal unnamed_addr constant [9 x i8] c"kernel_1\00", section ".llvm.rodata.offloading", align 1
+// CHECK: @.offloading.entry.kernel_1 = weak constant %struct.__tgt_offload_entry { i64 0, i16 1, i16 1, i32 0, ptr @.kernel_1.region_id, ptr @.offloading.entry_name.1, i64 0, i64 0, ptr null }, section ".omp_offloading_entries", align 1
+// CHECK: @my_struct_global2 = external global %struct.__tgt_kernel_arguments
+// CHECK: @0 = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00", align 1
+// CHECK: @1 = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 22, ptr @0 }, align 8
+
+// CHECK:  Function Attrs:
+// CHECK-NEXT: define{{( dso_local)?}} void @main()
+// CHECK-NEXT: start:
+// CHECK-NEXT:   %0 = alloca [8 x i8], align 8
+// CHECK-NEXT:   %x = alloca [1024 x i8], align 16
+// CHECK-NEXT:   %EmptyDesc = alloca %struct.__tgt_bin_desc, align 8
+// CHECK-NEXT:   %.offload_baseptrs = alloca [1 x ptr], align 8
+// CHECK-NEXT:   %.offload_ptrs = alloca [1 x ptr], align 8
+// CHECK-NEXT:   %.offload_sizes = alloca [1 x i64], align 8
+// CHECK-NEXT:   %x.addr = alloca ptr, align 8
+// CHECK-NEXT:   store ptr %x, ptr %x.addr, align 8
+// CHECK-NEXT:   %1 = load ptr, ptr %x.addr, align 8
+// CHECK-NEXT:   %2 = getelementptr inbounds float, ptr %1, i32 0
+// CHECK:        call void @llvm.memset.p0.i64(ptr align 8 %EmptyDesc, i8 0, i64 32, i1 false)
+// CHECK-NEXT:   call void @__tgt_register_lib(ptr %EmptyDesc)
+// CHECK-NEXT:   call void @__tgt_init_all_rtls()
+// CHECK-NEXT:   %3 = getelementptr inbounds [1 x ptr], ptr %.offload_baseptrs, i32 0, i32 0
+// CHECK-NEXT:   store ptr %1, ptr %3, align 8
+// CHECK-NEXT:   %4 = getelementptr inbounds [1 x ptr], ptr %.offload_ptrs, i32 0, i32 0
+// CHECK-NEXT:   store ptr %2, ptr %4, align 8
+// CHECK-NEXT:   %5 = getelementptr inbounds [1 x i64], ptr %.offload_sizes, i32 0, i32 0
+// CHECK-NEXT:   store i64 1024, ptr %5, align 8
+// CHECK-NEXT:   %6 = getelementptr inbounds [1 x ptr], ptr %.offload_baseptrs, i32 0, i32 0
+// CHECK-NEXT:   %7 = getelementptr inbounds [1 x ptr], ptr %.offload_ptrs, i32 0, i32 0
+// CHECK-NEXT:   %8 = getelementptr inbounds [1 x i64], ptr %.offload_sizes, i32 0, i32 0
+// CHECK-NEXT:   call void @__tgt_target_data_begin_mapper(ptr @1, i64 -1, i32 1, ptr %6, ptr %7, ptr %8, ptr @.offload_maptypes.1, ptr null, ptr null)
+// CHECK-NEXT:   call void @kernel_1(ptr noalias noundef nonnull align 4 dereferenceable(1024) %x)
+// CHECK-NEXT:   %9 = getelementptr inbounds [1 x ptr], ptr %.offload_baseptrs, i32 0, i32 0
+// CHECK-NEXT:   %10 = getelementptr inbounds [1 x ptr], ptr %.offload_ptrs, i32 0, i32 0
+// CHECK-NEXT:   %11 = getelementptr inbounds [1 x i64], ptr %.offload_sizes, i32 0, i32 0
+// CHECK-NEXT:   call void @__tgt_target_data_end_mapper(ptr @1, i64 -1, i32 1, ptr %9, ptr %10, ptr %11, ptr @.offload_maptypes.1, ptr null, ptr null)
+// CHECK-NEXT:   call void @__tgt_unregister_lib(ptr %EmptyDesc)
+// CHECK:        store ptr %x, ptr %0, align 8
+// CHECK-NEXT:   call void asm sideeffect "", "r,~{memory}"(ptr nonnull %0)
+// CHECK:        ret void
+// CHECK-NEXT: }
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+pub fn kernel_1(x: &mut [f32; 256]) {
+    for i in 0..256 {
+        x[i] = 21.0;
+    }
+}
-- 
cgit 1.4.1-3-g733a5


From c068599173f8670caeeda252f115cc28445f7df0 Mon Sep 17 00:00:00 2001
From: Manuel Drehwald <git@manuel.drehwald.info>
Date: Fri, 18 Jul 2025 16:01:05 -0700
Subject: add unstable-books doc for offload

---
 src/doc/unstable-book/src/compiler-flags/offload.md | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 src/doc/unstable-book/src/compiler-flags/offload.md

diff --git a/src/doc/unstable-book/src/compiler-flags/offload.md b/src/doc/unstable-book/src/compiler-flags/offload.md
new file mode 100644
index 00000000000..4266e8c11a2
--- /dev/null
+++ b/src/doc/unstable-book/src/compiler-flags/offload.md
@@ -0,0 +1,8 @@
+# `offload`
+
+The tracking issue for this feature is: [#131513](https://github.com/rust-lang/rust/issues/131513).
+
+------------------------
+
+This feature will later allow you to run functions on GPUs. It is work in progress.
+Set the `-Zoffload=Enable` compiler flag to experiment with it.
-- 
cgit 1.4.1-3-g733a5


From 2a037503efef730fd8c62e5145345fcf816b2243 Mon Sep 17 00:00:00 2001
From: beepster4096 <19316085+beepster4096@users.noreply.github.com>
Date: Fri, 18 Jul 2025 14:00:00 -0700
Subject: debug impls for drop elaborators

---
 compiler/rustc_mir_transform/src/elaborate_drops.rs | 4 ++--
 compiler/rustc_mir_transform/src/shim.rs            | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/elaborate_drops.rs b/compiler/rustc_mir_transform/src/elaborate_drops.rs
index b4fa2be1d00..58dff4514a0 100644
--- a/compiler/rustc_mir_transform/src/elaborate_drops.rs
+++ b/compiler/rustc_mir_transform/src/elaborate_drops.rs
@@ -253,8 +253,8 @@ struct ElaborateDropsCtxt<'a, 'tcx> {
 }
 
 impl fmt::Debug for ElaborateDropsCtxt<'_, '_> {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Ok(())
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ElaborateDropsCtxt").finish_non_exhaustive()
     }
 }
 
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
index cdbc74cdfa8..6c65b072bec 100644
--- a/compiler/rustc_mir_transform/src/shim.rs
+++ b/compiler/rustc_mir_transform/src/shim.rs
@@ -434,8 +434,8 @@ pub(super) struct DropShimElaborator<'a, 'tcx> {
 }
 
 impl fmt::Debug for DropShimElaborator<'_, '_> {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        Ok(())
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.debug_struct("DropShimElaborator").finish_non_exhaustive()
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From b8bcb4dd64859a1930238bc9e36ba96be92bd2f3 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Sat, 19 Jul 2025 04:57:12 +0000
Subject: Preparing for merge from rustc

---
 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 f9457b3e447..601acc00bd6 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-e4662966273ed58b51f9ff8d682accc202aa1210
+ebd8557637b33cc09b6ee8273f3154d5d3af6a15
-- 
cgit 1.4.1-3-g733a5


From 196833ccf2742f0975cd084aac4f354c025638d4 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 19 Jul 2025 13:38:01 +0800
Subject: Fix ide-assist: Deref transtive

---
 .../ide-assists/src/handlers/generate_deref.rs     | 26 ++++++++++++++++++++--
 .../rust-analyzer/crates/ide-assists/src/utils.rs  |  1 +
 2 files changed, 25 insertions(+), 2 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 c7b97dcd231..55a09c5d775 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
@@ -10,7 +10,7 @@ use syntax::{
 use crate::{
     AssistId,
     assist_context::{AssistContext, Assists, SourceChangeBuilder},
-    utils::generate_trait_impl_text,
+    utils::generate_trait_impl_text_intransitive,
 };
 
 // Assist: generate_deref
@@ -150,7 +150,7 @@ fn generate_edit(
         ),
     };
     let strukt_adt = ast::Adt::Struct(strukt);
-    let deref_impl = generate_trait_impl_text(
+    let deref_impl = generate_trait_impl_text_intransitive(
         &strukt_adt,
         &trait_path.display(db, edition).to_string(),
         &impl_code,
@@ -227,6 +227,28 @@ impl core::ops::Deref for B {
         );
     }
 
+    #[test]
+    fn test_generate_record_deref_with_generic() {
+        check_assist(
+            generate_deref,
+            r#"
+//- minicore: deref
+struct A<T>($0T);
+"#,
+            r#"
+struct A<T>(T);
+
+impl<T> core::ops::Deref for A<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+"#,
+        );
+    }
+
     #[test]
     fn test_generate_record_deref_short_path() {
         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 b1606fb7ba7..a302964e17b 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/utils.rs
@@ -567,6 +567,7 @@ pub(crate) fn generate_impl_text(adt: &ast::Adt, code: &str) -> String {
 ///
 /// 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)
 }
-- 
cgit 1.4.1-3-g733a5


From 54d974324c9770b9368194ca3c916fb5a5b6c9a4 Mon Sep 17 00:00:00 2001
From: A4-Tacks <wdsjxhno1001@163.com>
Date: Sat, 19 Jul 2025 15:00:54 +0800
Subject: Add Deref -> DerefMut for generate_mut_trait_impl

---
 .../src/handlers/generate_mut_trait_impl.rs        | 37 ++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
index 4ddab2cfad0..dc26ec79a74 100644
--- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
+++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_mut_trait_impl.rs
@@ -134,6 +134,9 @@ fn get_trait_mut(apply_trait: &hir::Trait, famous: FamousDefs<'_, '_>) -> Option
     if trait_ == famous.core_borrow_Borrow().as_ref() {
         return Some("BorrowMut");
     }
+    if trait_ == famous.core_ops_Deref().as_ref() {
+        return Some("DerefMut");
+    }
     None
 }
 
@@ -142,6 +145,7 @@ fn process_method_name(name: ast::Name) -> Option<(ast::Name, &'static str)> {
         "index" => "index_mut",
         "as_ref" => "as_mut",
         "borrow" => "borrow_mut",
+        "deref" => "deref_mut",
         _ => return None,
     };
     Some((name, new_name))
@@ -258,6 +262,39 @@ impl core::convert::AsRef<i32> for Foo {
         &self.0
     }
 }
+"#,
+        );
+
+        check_assist(
+            generate_mut_trait_impl,
+            r#"
+//- minicore: deref
+struct Foo(i32);
+
+impl core::ops::Deref$0 for Foo {
+    type Target = i32;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+"#,
+            r#"
+struct Foo(i32);
+
+$0impl core::ops::DerefMut for Foo {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl core::ops::Deref for Foo {
+    type Target = i32;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
 "#,
         );
     }
-- 
cgit 1.4.1-3-g733a5


From 2f46cde9a4d23c60a3e79680f917da664064c4e1 Mon Sep 17 00:00:00 2001
From: Young-Flash <dongyang@apache.org>
Date: Sat, 19 Jul 2025 16:19:20 +0800
Subject: minor: remove unused var

---
 src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs b/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
index c081796d078..698fd147789 100755
--- a/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/folding_ranges.rs
@@ -48,7 +48,6 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
     let mut res = vec![];
     let mut visited_comments = FxHashSet::default();
     let mut visited_nodes = FxHashSet::default();
-    let mut merged_fn_bodies = FxHashSet::default();
 
     // regions can be nested, here is a LIFO buffer
     let mut region_starts: Vec<TextSize> = vec![];
@@ -73,7 +72,7 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
                                 continue;
                             }
 
-                            if let Some(body) = fn_node.body() {
+                            if fn_node.body().is_some() {
                                 res.push(Fold {
                                     range: TextRange::new(
                                         node.text_range().start(),
@@ -81,7 +80,6 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
                                     ),
                                     kind: FoldKind::Function,
                                 });
-                                merged_fn_bodies.insert(body.syntax().text_range());
                                 continue;
                             }
                         }
-- 
cgit 1.4.1-3-g733a5


From f16016ad254e864c55c8bdf88b6a5926c1fb7dfb Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Sat, 19 Jul 2025 10:27:46 +0200
Subject: Fix compiler for dist LLVM bitcode linker

---
 src/bootstrap/src/core/build_steps/compile.rs |  2 +-
 src/bootstrap/src/core/build_steps/dist.rs    | 15 +++++++++++----
 src/bootstrap/src/core/build_steps/install.rs |  2 +-
 src/bootstrap/src/core/build_steps/tool.rs    | 21 ++++++++++++++++-----
 src/bootstrap/src/core/builder/tests.rs       |  1 -
 5 files changed, 29 insertions(+), 12 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index d1285340cd6..a80fdefac43 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -2056,7 +2056,7 @@ impl Step for Assemble {
             if builder.config.llvm_bitcode_linker_enabled {
                 trace!("llvm-bitcode-linker enabled, installing");
                 let llvm_bitcode_linker = builder.ensure(
-                    crate::core::build_steps::tool::LlvmBitcodeLinker::for_use_by_compiler(
+                    crate::core::build_steps::tool::LlvmBitcodeLinker::from_target_compiler(
                         builder,
                         target_compiler,
                     ),
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index af17a69302b..39e4fb2ac01 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -1576,7 +1576,7 @@ impl Step for Extended {
             backend: "cranelift".to_string(),
         });
         add_component!("llvm-bitcode-linker" => LlvmBitcodeLinker {
-            target_compiler: compiler,
+            build_compiler: compiler,
             target
         });
 
@@ -2344,9 +2344,13 @@ impl Step for LlvmTools {
     }
 }
 
+/// Distributes the `llvm-bitcode-linker` tool so that it can be used by a compiler whose host
+/// is `target`.
 #[derive(Debug, PartialOrd, Ord, Clone, Hash, PartialEq, Eq)]
 pub struct LlvmBitcodeLinker {
-    pub target_compiler: Compiler,
+    /// The linker will be compiled by this compiler.
+    pub build_compiler: Compiler,
+    /// The linker will by usable by rustc on this host.
     pub target: TargetSelection,
 }
 
@@ -2362,7 +2366,10 @@ impl Step for LlvmBitcodeLinker {
 
     fn make_run(run: RunConfig<'_>) {
         run.builder.ensure(LlvmBitcodeLinker {
-            target_compiler: run.builder.compiler(run.builder.top_stage, run.target),
+            build_compiler: tool::LlvmBitcodeLinker::get_build_compiler_for_target(
+                run.builder,
+                run.target,
+            ),
             target: run.target,
         });
     }
@@ -2371,7 +2378,7 @@ impl Step for LlvmBitcodeLinker {
         let target = self.target;
 
         let llbc_linker = builder
-            .ensure(tool::LlvmBitcodeLinker::for_use_by_compiler(builder, self.target_compiler));
+            .ensure(tool::LlvmBitcodeLinker::from_build_compiler(self.build_compiler, target));
 
         let self_contained_bin_dir = format!("lib/rustlib/{}/bin/self-contained", target.triple);
 
diff --git a/src/bootstrap/src/core/build_steps/install.rs b/src/bootstrap/src/core/build_steps/install.rs
index 285624916d1..4156b49a8b3 100644
--- a/src/bootstrap/src/core/build_steps/install.rs
+++ b/src/bootstrap/src/core/build_steps/install.rs
@@ -287,7 +287,7 @@ install!((self, builder, _config),
         }
     };
     LlvmBitcodeLinker, alias = "llvm-bitcode-linker", Self::should_build(_config), only_hosts: true, {
-        if let Some(tarball) = builder.ensure(dist::LlvmBitcodeLinker { target_compiler: self.compiler, target: self.target }) {
+        if let Some(tarball) = builder.ensure(dist::LlvmBitcodeLinker { build_compiler: self.compiler, target: self.target }) {
             install_sh(builder, "llvm-bitcode-linker", self.compiler.stage, Some(self.target), &tarball);
         } else {
             builder.info(
diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 4d2fa177765..f1e317ebb66 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -1171,8 +1171,14 @@ pub struct LlvmBitcodeLinker {
 }
 
 impl LlvmBitcodeLinker {
+    /// Returns `LlvmBitcodeLinker` that will be **compiled** by the passed compiler, for the given
+    /// `target`.
+    pub fn from_build_compiler(build_compiler: Compiler, target: TargetSelection) -> Self {
+        Self { build_compiler, target }
+    }
+
     /// Returns `LlvmBitcodeLinker` that should be **used** by the passed compiler.
-    pub fn for_use_by_compiler(builder: &Builder<'_>, target_compiler: Compiler) -> Self {
+    pub fn from_target_compiler(builder: &Builder<'_>, target_compiler: Compiler) -> Self {
         Self {
             build_compiler: get_tool_target_compiler(
                 builder,
@@ -1181,6 +1187,14 @@ impl LlvmBitcodeLinker {
             target: target_compiler.host,
         }
     }
+
+    /// Return a compiler that is able to build this tool for the given `target`.
+    pub fn get_build_compiler_for_target(
+        builder: &Builder<'_>,
+        target: TargetSelection,
+    ) -> Compiler {
+        get_tool_target_compiler(builder, ToolTargetBuildMode::Build(target))
+    }
 }
 
 impl Step for LlvmBitcodeLinker {
@@ -1196,10 +1210,7 @@ impl Step for LlvmBitcodeLinker {
 
     fn make_run(run: RunConfig<'_>) {
         run.builder.ensure(LlvmBitcodeLinker {
-            build_compiler: get_tool_target_compiler(
-                run.builder,
-                ToolTargetBuildMode::Build(run.target),
-            ),
+            build_compiler: Self::get_build_compiler_for_target(run.builder, run.target),
             target: run.target,
         });
     }
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 4ca9ff98dee..aa4995a2549 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1293,7 +1293,6 @@ mod snapshot {
         [build] rustc 0 <host> -> miri 1 <target1>
         [build] rustc 0 <host> -> cargo-miri 1 <target1>
         [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <target1>
-        [build] rustc 0 <host> -> LlvmBitcodeLinker 1 <host>
         ");
     }
 
-- 
cgit 1.4.1-3-g733a5


From 7672e4ed85916d564d38dbd3a64803a45568504d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 10:29:13 +0200
Subject: interpret: fix TypeId pointers being considered data pointers

---
 compiler/rustc_const_eval/src/interpret/memory.rs     | 10 ++++------
 library/core/src/any.rs                               |  2 +-
 src/tools/miri/src/alloc_addresses/mod.rs             |  2 +-
 .../miri/src/borrow_tracker/stacked_borrows/mod.rs    |  4 ++--
 src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs |  2 +-
 src/tools/miri/tests/pass/intrinsics/type-id.rs       | 19 +++++++++++++++++++
 6 files changed, 28 insertions(+), 11 deletions(-)
 create mode 100644 src/tools/miri/tests/pass/intrinsics/type-id.rs

diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 47228de5213..20c8e983cea 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -67,8 +67,8 @@ pub enum AllocKind {
     LiveData,
     /// A function allocation (that fn ptrs point to).
     Function,
-    /// A (symbolic) vtable allocation.
-    VTable,
+    /// A "virtual" allocation, used for vtables and TypeId.
+    Virtual,
     /// A dead allocation.
     Dead,
 }
@@ -950,11 +950,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             let (size, align) = global_alloc.size_and_align(*self.tcx, self.typing_env);
             let mutbl = global_alloc.mutability(*self.tcx, self.typing_env);
             let kind = match global_alloc {
-                GlobalAlloc::TypeId { .. }
-                | GlobalAlloc::Static { .. }
-                | GlobalAlloc::Memory { .. } => AllocKind::LiveData,
+                GlobalAlloc::Static { .. } | GlobalAlloc::Memory { .. } => AllocKind::LiveData,
                 GlobalAlloc::Function { .. } => bug!("We already checked function pointers above"),
-                GlobalAlloc::VTable { .. } => AllocKind::VTable,
+                GlobalAlloc::VTable { .. } | GlobalAlloc::TypeId { .. } => AllocKind::Virtual,
             };
             return AllocInfo::new(size, align, kind, mutbl);
         }
diff --git a/library/core/src/any.rs b/library/core/src/any.rs
index 39cdf6efda0..38393379a78 100644
--- a/library/core/src/any.rs
+++ b/library/core/src/any.rs
@@ -783,7 +783,7 @@ impl TypeId {
 
         // This is a provenance-stripping memcpy.
         for (i, chunk) in self.data.iter().copied().enumerate() {
-            let chunk = chunk.expose_provenance().to_ne_bytes();
+            let chunk = chunk.addr().to_ne_bytes();
             let start = i * chunk.len();
             bytes[start..(start + chunk.len())].copy_from_slice(&chunk);
         }
diff --git a/src/tools/miri/src/alloc_addresses/mod.rs b/src/tools/miri/src/alloc_addresses/mod.rs
index 3cc38fa087c..10339928ac2 100644
--- a/src/tools/miri/src/alloc_addresses/mod.rs
+++ b/src/tools/miri/src/alloc_addresses/mod.rs
@@ -157,7 +157,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                         this.get_alloc_bytes_unchecked_raw(alloc_id)?
                     }
                 }
-                AllocKind::Function | AllocKind::VTable => {
+                AllocKind::Function | AllocKind::Virtual => {
                     // Allocate some dummy memory to get a unique address for this function/vtable.
                     let alloc_bytes = MiriAllocBytes::from_bytes(
                         &[0u8; 1],
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 834a4b41f22..e834fdffdd1 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
@@ -650,7 +650,7 @@ trait EvalContextPrivExt<'tcx, 'ecx>: crate::MiriInterpCxExt<'tcx> {
                         dcx.log_protector();
                     }
                 },
-                AllocKind::Function | AllocKind::VTable | AllocKind::Dead => {
+                AllocKind::Function | AllocKind::Virtual | AllocKind::Dead => {
                     // No stacked borrows on these allocations.
                 }
             }
@@ -1021,7 +1021,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 trace!("Stacked Borrows tag {tag:?} exposed in {alloc_id:?}");
                 alloc_extra.borrow_tracker_sb().borrow_mut().exposed_tags.insert(tag);
             }
-            AllocKind::Function | AllocKind::VTable | AllocKind::Dead => {
+            AllocKind::Function | AllocKind::Virtual | AllocKind::Dead => {
                 // No stacked borrows on these allocations.
             }
         }
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 c157c69d7c8..aa92f8a8c30 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -673,7 +673,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 trace!("Tree Borrows tag {tag:?} exposed in {alloc_id:?}");
                 alloc_extra.borrow_tracker_tb().borrow_mut().expose_tag(tag);
             }
-            AllocKind::Function | AllocKind::VTable | AllocKind::Dead => {
+            AllocKind::Function | AllocKind::Virtual | AllocKind::Dead => {
                 // No tree borrows on these allocations.
             }
         }
diff --git a/src/tools/miri/tests/pass/intrinsics/type-id.rs b/src/tools/miri/tests/pass/intrinsics/type-id.rs
new file mode 100644
index 00000000000..123fdbdc9ce
--- /dev/null
+++ b/src/tools/miri/tests/pass/intrinsics/type-id.rs
@@ -0,0 +1,19 @@
+use std::any::{Any, TypeId};
+
+fn main() {
+    let t1 = TypeId::of::<u64>();
+    let t2 = TypeId::of::<u64>();
+    assert_eq!(t1, t2);
+    let t3 = TypeId::of::<usize>();
+    assert_ne!(t1, t3);
+
+    let _ = format!("{t1:?}"); // test that we can debug-print
+
+    let b = Box::new(0u64) as Box<dyn Any>;
+    assert_eq!(*b.downcast_ref::<u64>().unwrap(), 0);
+    assert!(b.downcast_ref::<usize>().is_none());
+
+    // Get the first pointer chunk and try to make it a ZST ref.
+    // This used to trigger an error because TypeId allocs got misclassified as "LiveData".
+    let _raw_chunk = unsafe { (&raw const t1).cast::<&()>().read() };
+}
-- 
cgit 1.4.1-3-g733a5


From 9613ce02c393104ba7ebd4655d004e5f6da3db18 Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Sat, 19 Jul 2025 09:30:39 +0000
Subject: Revert "resolve: Make disambiguators for underscore bindings
 module-local"

This reverts commit 998df3a3e851908afd05c3318f16d99849af5c55.
---
 compiler/rustc_resolve/src/build_reduced_graph.rs | 30 ++++++++----------
 compiler/rustc_resolve/src/imports.rs             | 38 ++++++++---------------
 compiler/rustc_resolve/src/lib.rs                 | 33 +++++++++++---------
 compiler/rustc_resolve/src/macros.rs              |  2 +-
 4 files changed, 45 insertions(+), 58 deletions(-)

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index c3bfd759f4c..737577baa7a 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -49,7 +49,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         ns: Namespace,
         binding: NameBinding<'ra>,
     ) {
-        if let Err(old_binding) = self.try_define(parent, ident, ns, binding, false) {
+        let key = self.new_disambiguated_key(ident, ns);
+        if let Err(old_binding) = self.try_define(parent, key, binding, false) {
             self.report_conflict(parent, ident, ns, old_binding, binding);
         }
     }
@@ -441,18 +442,16 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
 
         self.r.indeterminate_imports.push(import);
         match import.kind {
+            // Don't add unresolved underscore imports to modules
+            ImportKind::Single { target: Ident { name: kw::Underscore, .. }, .. } => {}
             ImportKind::Single { target, type_ns_only, .. } => {
-                // Don't add underscore imports to `single_imports`
-                // because they cannot define any usable names.
-                if target.name != kw::Underscore {
-                    self.r.per_ns(|this, ns| {
-                        if !type_ns_only || ns == TypeNS {
-                            let key = BindingKey::new(target, ns);
-                            let mut resolution = this.resolution(current_module, key).borrow_mut();
-                            resolution.single_imports.insert(import);
-                        }
-                    });
-                }
+                self.r.per_ns(|this, ns| {
+                    if !type_ns_only || ns == TypeNS {
+                        let key = BindingKey::new(target, ns);
+                        let mut resolution = this.resolution(current_module, key).borrow_mut();
+                        resolution.single_imports.insert(import);
+                    }
+                });
             }
             // We don't add prelude imports to the globs since they only affect lexical scopes,
             // which are not relevant to import resolution.
@@ -1409,12 +1408,9 @@ impl<'a, 'ra, 'tcx> Visitor<'a> for BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             let parent = self.parent_scope.module;
             let expansion = self.parent_scope.expansion;
             self.r.define(parent, ident, ns, self.res(def_id), vis, item.span, expansion);
-        } else if !matches!(&item.kind, AssocItemKind::Delegation(deleg) if deleg.from_glob)
-            && ident.name != kw::Underscore
-        {
-            // Don't add underscore names, they cannot be looked up anyway.
+        } else if !matches!(&item.kind, AssocItemKind::Delegation(deleg) if deleg.from_glob) {
             let impl_def_id = self.r.tcx.local_parent(local_def_id);
-            let key = BindingKey::new(ident, ns);
+            let key = BindingKey::new(ident.normalize_to_macros_2_0(), ns);
             self.r.impl_binding_keys.entry(impl_def_id).or_default().insert(key);
         }
 
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index b4c15ed1ca7..0a4c25b0eb0 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -25,7 +25,7 @@ use rustc_span::{Ident, Span, Symbol, kw, sym};
 use smallvec::SmallVec;
 use tracing::debug;
 
-use crate::Namespace::{self, *};
+use crate::Namespace::*;
 use crate::diagnostics::{DiagMode, Suggestion, import_candidates};
 use crate::errors::{
     CannotBeReexportedCratePublic, CannotBeReexportedCratePublicNS, CannotBeReexportedPrivate,
@@ -338,20 +338,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     pub(crate) fn try_define(
         &mut self,
         module: Module<'ra>,
-        ident: Ident,
-        ns: Namespace,
+        key: BindingKey,
         binding: NameBinding<'ra>,
         warn_ambiguity: bool,
     ) -> Result<(), NameBinding<'ra>> {
         let res = binding.res();
-        self.check_reserved_macro_name(ident, res);
+        self.check_reserved_macro_name(key.ident, res);
         self.set_binding_parent_module(binding, module);
-        // Even if underscore names cannot be looked up, we still need to add them to modules,
-        // because they can be fetched by glob imports from those modules, and bring traits
-        // into scope both directly and through glob imports.
-        let key = BindingKey::new_disambiguated(ident, ns, || {
-            (module.0.0.lazy_resolutions.borrow().len() + 1).try_into().unwrap()
-        });
         self.update_resolution(module, key, warn_ambiguity, |this, resolution| {
             if let Some(old_binding) = resolution.best_binding() {
                 if res == Res::Err && old_binding.res() != Res::Err {
@@ -390,7 +383,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     (old_glob @ true, false) | (old_glob @ false, true) => {
                         let (glob_binding, non_glob_binding) =
                             if old_glob { (old_binding, binding) } else { (binding, old_binding) };
-                        if ns == MacroNS
+                        if key.ns == MacroNS
                             && non_glob_binding.expansion != LocalExpnId::ROOT
                             && glob_binding.res() != non_glob_binding.res()
                         {
@@ -496,10 +489,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             };
             if self.is_accessible_from(binding.vis, scope) {
                 let imported_binding = self.import(binding, *import);
+                let key = BindingKey { ident, ..key };
                 let _ = self.try_define(
                     import.parent_scope.module,
-                    ident,
-                    key.ns,
+                    key,
                     imported_binding,
                     warn_ambiguity,
                 );
@@ -521,15 +514,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let dummy_binding = self.dummy_binding;
             let dummy_binding = self.import(dummy_binding, import);
             self.per_ns(|this, ns| {
-                let module = import.parent_scope.module;
-                let _ = this.try_define(module, target, ns, dummy_binding, false);
-                // Don't remove underscores from `single_imports`, they were never added.
-                if target.name != kw::Underscore {
-                    let key = BindingKey::new(target, ns);
-                    this.update_resolution(module, key, false, |_, resolution| {
-                        resolution.single_imports.swap_remove(&import);
-                    })
-                }
+                let key = BindingKey::new(target, ns);
+                let _ = this.try_define(import.parent_scope.module, key, dummy_binding, false);
+                this.update_resolution(import.parent_scope.module, key, false, |_, resolution| {
+                    resolution.single_imports.swap_remove(&import);
+                })
             });
             self.record_use(target, dummy_binding, Used::Other);
         } else if import.imported_module.get().is_none() {
@@ -906,7 +895,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         PendingBinding::Ready(Some(imported_binding))
                     }
                     Err(Determinacy::Determined) => {
-                        // Don't remove underscores from `single_imports`, they were never added.
+                        // Don't update the resolution for underscores, because it was never added.
                         if target.name != kw::Underscore {
                             let key = BindingKey::new(target, ns);
                             this.update_resolution(parent, key, false, |_, resolution| {
@@ -1521,8 +1510,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     .is_some_and(|binding| binding.warn_ambiguity_recursive());
                 let _ = self.try_define(
                     import.parent_scope.module,
-                    key.ident,
-                    key.ns,
+                    key,
                     imported_binding,
                     warn_ambiguity,
                 );
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 948b67a3798..0d41a822e8a 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -532,26 +532,15 @@ struct BindingKey {
     /// identifier.
     ident: Ident,
     ns: Namespace,
-    /// When we add an underscore binding (with ident `_`) to some module, this field has
-    /// a non-zero value that uniquely identifies this binding in that module.
-    /// For non-underscore bindings this field is zero.
-    /// When a key is constructed for name lookup (as opposed to name definition), this field is
-    /// also zero, even for underscore names, so for underscores the lookup will never succeed.
+    /// 0 if ident is not `_`, otherwise a value that's unique to the specific
+    /// `_` in the expanded AST that introduced this binding.
     disambiguator: u32,
 }
 
 impl BindingKey {
     fn new(ident: Ident, ns: Namespace) -> Self {
-        BindingKey { ident: ident.normalize_to_macros_2_0(), ns, disambiguator: 0 }
-    }
-
-    fn new_disambiguated(
-        ident: Ident,
-        ns: Namespace,
-        disambiguator: impl FnOnce() -> u32,
-    ) -> BindingKey {
-        let disambiguator = if ident.name == kw::Underscore { disambiguator() } else { 0 };
-        BindingKey { ident: ident.normalize_to_macros_2_0(), ns, disambiguator }
+        let ident = ident.normalize_to_macros_2_0();
+        BindingKey { ident, ns, disambiguator: 0 }
     }
 }
 
@@ -1098,6 +1087,8 @@ pub struct Resolver<'ra, 'tcx> {
     extern_module_map: RefCell<FxIndexMap<DefId, Module<'ra>>>,
     binding_parent_modules: FxHashMap<NameBinding<'ra>, Module<'ra>>,
 
+    underscore_disambiguator: u32,
+
     /// Maps glob imports to the names of items actually imported.
     glob_map: FxIndexMap<LocalDefId, FxIndexSet<Symbol>>,
     glob_error: Option<ErrorGuaranteed>,
@@ -1509,6 +1500,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             extern_crate_map: Default::default(),
             module_children: Default::default(),
             trait_map: NodeMap::default(),
+            underscore_disambiguator: 0,
             empty_module,
             local_module_map,
             extern_module_map: Default::default(),
@@ -1889,6 +1881,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         import_ids
     }
 
+    fn new_disambiguated_key(&mut self, ident: Ident, ns: Namespace) -> BindingKey {
+        let ident = ident.normalize_to_macros_2_0();
+        let disambiguator = if ident.name == kw::Underscore {
+            self.underscore_disambiguator += 1;
+            self.underscore_disambiguator
+        } else {
+            0
+        };
+        BindingKey { ident, ns, disambiguator }
+    }
+
     fn resolutions(&mut self, module: Module<'ra>) -> &'ra Resolutions<'ra> {
         if module.populate_on_access.get() {
             module.populate_on_access.set(false);
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 0e8904a7dea..77ef7f56c09 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -530,7 +530,7 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
         target_trait.for_each_child(self, |this, ident, ns, _binding| {
             // FIXME: Adjust hygiene for idents from globs, like for glob imports.
             if let Some(overriding_keys) = this.impl_binding_keys.get(&impl_def_id)
-                && overriding_keys.contains(&BindingKey::new(ident, ns))
+                && overriding_keys.contains(&BindingKey::new(ident.normalize_to_macros_2_0(), ns))
             {
                 // The name is overridden, do not produce it from the glob delegation.
             } else {
-- 
cgit 1.4.1-3-g733a5


From 4aa437600818b515d19ec4967005ad5344062734 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 12:30:42 +0200
Subject: add -Zmiri-no-extra-rounding-error to specifically disable just that
 part of float-nondet

---
 src/tools/miri/README.md       | 13 ++++++++-----
 src/tools/miri/src/bin/miri.rs |  2 ++
 src/tools/miri/src/eval.rs     |  3 +++
 src/tools/miri/src/machine.rs  |  4 ++++
 src/tools/miri/src/math.rs     |  2 +-
 5 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index 7816ce1ac56..7ccd27d7b83 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -286,11 +286,6 @@ environment variable. We first document the most relevant and most commonly used
   specific circumstances, but Miri's behavior will also be more stable across versions and targets.
   This is equivalent to `-Zmiri-fixed-schedule -Zmiri-compare-exchange-weak-failure-rate=0.0
   -Zmiri-address-reuse-cross-thread-rate=0.0 -Zmiri-disable-weak-memory-emulation`.
-* `-Zmiri-deterministic-floats` makes Miri's floating-point behavior fully deterministic. This means
-  that operations will always return the preferred NaN, imprecise operations will not have any
-  random error applied to them, and `min`/`max` as "maybe fused" multiply-add all behave
-  deterministically. Note that Miri still uses host floats for some operations, so behavior can
-  still differ depending on the host target and setup.
 * `-Zmiri-disable-isolation` disables host isolation. As a consequence,
   the program has access to host resources such as environment variables, file
   systems, and randomness.
@@ -324,6 +319,8 @@ environment variable. We first document the most relevant and most commonly used
   Can be used without a value; in that case the range defaults to `0..64`.
 * `-Zmiri-many-seeds-keep-going` tells Miri to really try all the seeds in the given range, even if
   a failing seed has already been found. This is useful to determine which fraction of seeds fails.
+* `-Zmiri-no-extra-rounding-error` stops Miri from adding extra rounding errors to float operations
+  that do not have a guaranteed precision.
 * `-Zmiri-num-cpus` states the number of available CPUs to be reported by miri. By default, the
   number of available CPUs is `1`. Note that this flag does not affect how miri handles threads in
   any way.
@@ -376,6 +373,12 @@ to Miri failing to detect cases of undefined behavior in a program.
   will always fail and `0.0` means it will never fail. Note that setting it to
   `1.0` will likely cause hangs, since it means programs using
   `compare_exchange_weak` cannot make progress.
+* `-Zmiri-deterministic-floats` makes Miri's floating-point behavior fully deterministic. This means
+  that operations will always return the preferred NaN, imprecise operations will not have any
+  random error applied to them, and `min`/`max` and "maybe fused" multiply-add all behave
+  deterministically. Note that Miri still uses host floats for some operations, so behavior can
+  still differ depending on the host target and setup. See `-Zmiri-no-extra-rounding-error` for
+  a flag that specifically only disables the random error.
 * `-Zmiri-disable-alignment-check` disables checking pointer alignment, so you
   can focus on other failures, but it means Miri can miss bugs in your program.
   Using this flag is **unsound**.
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index 5d9c05807b8..89fa980ff64 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -562,6 +562,8 @@ fn main() {
             miri_config.force_intrinsic_fallback = true;
         } else if arg == "-Zmiri-deterministic-floats" {
             miri_config.float_nondet = false;
+        } else if arg == "-Zmiri-no-extra-rounding-error" {
+            miri_config.float_rounding_error = false;
         } else if arg == "-Zmiri-strict-provenance" {
             miri_config.provenance_mode = ProvenanceMode::Strict;
         } else if arg == "-Zmiri-permissive-provenance" {
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index be6404f64e8..3c80e60b772 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -170,6 +170,8 @@ pub struct MiriConfig {
     pub force_intrinsic_fallback: bool,
     /// Whether floating-point operations can behave non-deterministically.
     pub float_nondet: bool,
+    /// Whether floating-point operations can have a non-deterministic rounding error.
+    pub float_rounding_error: bool,
 }
 
 impl Default for MiriConfig {
@@ -211,6 +213,7 @@ impl Default for MiriConfig {
             fixed_scheduling: false,
             force_intrinsic_fallback: false,
             float_nondet: true,
+            float_rounding_error: true,
         }
     }
 }
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index e3e7b0b88a7..ce33c870b4b 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -617,6 +617,8 @@ pub struct MiriMachine<'tcx> {
 
     /// Whether floating-point operations can behave non-deterministically.
     pub float_nondet: bool,
+    /// Whether floating-point operations can have a non-deterministic rounding error.
+    pub float_rounding_error: bool,
 }
 
 impl<'tcx> MiriMachine<'tcx> {
@@ -775,6 +777,7 @@ impl<'tcx> MiriMachine<'tcx> {
             mangle_internal_symbol_cache: Default::default(),
             force_intrinsic_fallback: config.force_intrinsic_fallback,
             float_nondet: config.float_nondet,
+            float_rounding_error: config.float_rounding_error,
         }
     }
 
@@ -951,6 +954,7 @@ impl VisitProvenance for MiriMachine<'_> {
             mangle_internal_symbol_cache: _,
             force_intrinsic_fallback: _,
             float_nondet: _,
+            float_rounding_error: _,
         } = self;
 
         threads.visit_provenance(visit);
diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index cf16a5676d6..e9e5a1070c9 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -15,7 +15,7 @@ pub(crate) fn apply_random_float_error<F: rustc_apfloat::Float>(
     val: F,
     err_scale: i32,
 ) -> F {
-    if !ecx.machine.float_nondet {
+    if !ecx.machine.float_nondet || !ecx.machine.float_rounding_error {
         return val;
     }
 
-- 
cgit 1.4.1-3-g733a5


From c1242b794f5ced9f49c069b1f9dcd8b3429103d8 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 13:49:01 +0200
Subject: cargo update

---
 src/tools/miri/Cargo.lock             | 421 ++++++++++++++++++----------------
 src/tools/miri/cargo-miri/Cargo.lock  | 305 ++++++++++++++++--------
 src/tools/miri/miri-script/Cargo.lock | 256 +++++++++++++--------
 3 files changed, 598 insertions(+), 384 deletions(-)

diff --git a/src/tools/miri/Cargo.lock b/src/tools/miri/Cargo.lock
index aa6f059cec2..93db99f7abc 100644
--- a/src/tools/miri/Cargo.lock
+++ b/src/tools/miri/Cargo.lock
@@ -4,18 +4,18 @@ version = 4
 
 [[package]]
 name = "addr2line"
-version = "0.21.0"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
+checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
 dependencies = [
  "gimli",
 ]
 
 [[package]]
-name = "adler"
-version = "1.0.2"
+name = "adler2"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "aes"
@@ -44,40 +44,40 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "710e8eae58854cdc1790fcb56cca04d712a17be849eeb81da2a724bf4bae2bc4"
 dependencies = [
  "anstyle",
- "unicode-width 0.2.0",
+ "unicode-width 0.2.1",
 ]
 
 [[package]]
 name = "anstyle"
-version = "1.0.10"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
+checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd"
 
 [[package]]
 name = "anyhow"
-version = "1.0.97"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "autocfg"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "backtrace"
-version = "0.3.71"
+version = "0.3.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
+checksum = "6806a6321ec58106fea15becdad98371e28d92ccbc7c8f1b3b6dd724fe8f1002"
 dependencies = [
  "addr2line",
- "cc",
  "cfg-if",
  "libc",
  "miniz_oxide",
  "object",
  "rustc-demangle",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -91,15 +91,15 @@ dependencies = [
 
 [[package]]
 name = "bitflags"
-version = "2.9.0"
+version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
 
 [[package]]
 name = "bstr"
-version = "1.11.3"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "531a9155a481e2ee699d4f98f43c0ca4ff8ee1bfd55c31e9e98fb29d2b176fe0"
+checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
 dependencies = [
  "memchr",
  "regex-automata",
@@ -108,15 +108,15 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.17.0"
+version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
 [[package]]
 name = "camino"
-version = "1.1.9"
+version = "1.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
+checksum = "0da45bc31171d8d6960122e222a67740df867c1dd53b4d51caa297084c185cab"
 dependencies = [
  "serde",
 ]
@@ -166,18 +166,18 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.17"
+version = "1.2.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fcb57c740ae1daf453ae85f16e37396f672b039e00d9d866e07ddb24e328e3a"
+checksum = "deec109607ca693028562ed836a5f1c4b8bd77755c4e132fc5ce11b0b6211ae7"
 dependencies = [
  "shlex",
 ]
 
 [[package]]
 name = "cfg-if"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
 
 [[package]]
 name = "cfg_aliases"
@@ -187,34 +187,23 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
 name = "chrono"
-version = "0.4.40"
+version = "0.4.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a7964611d71df112cb1730f2ee67324fcf4d0fc6606acbbe9bfe06df124637c"
+checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
 dependencies = [
  "num-traits",
 ]
 
 [[package]]
 name = "chrono-tz"
-version = "0.10.3"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efdce149c370f133a071ca8ef6ea340b7b88748ab0810097a9e2976eaa34b4f3"
+checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3"
 dependencies = [
  "chrono",
- "chrono-tz-build",
  "phf",
 ]
 
-[[package]]
-name = "chrono-tz-build"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f10f8c9340e31fc120ff885fcdb54a0b48e474bbd77cab557f0c30a3e569402"
-dependencies = [
- "parse-zoneinfo",
- "phf_codegen",
-]
-
 [[package]]
 name = "cipher"
 version = "0.4.4"
@@ -227,27 +216,27 @@ dependencies = [
 
 [[package]]
 name = "color-eyre"
-version = "0.6.3"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55146f5e46f237f7423d74111267d4597b59b0dad0ffaf7303bce9945d843ad5"
+checksum = "e5920befb47832a6d61ee3a3a846565cfa39b331331e68a3b1d1116630f2f26d"
 dependencies = [
  "backtrace",
  "color-spantrace",
  "eyre",
  "indenter",
  "once_cell",
- "owo-colors",
+ "owo-colors 4.2.2",
  "tracing-error",
 ]
 
 [[package]]
 name = "color-spantrace"
-version = "0.2.1"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd6be1b2a7e382e2b98b43b2adcca6bb0e465af0bdd38123873ae61eb17a72c2"
+checksum = "b8b88ea9df13354b55bc7234ebcce36e6ef896aca2e42a15de9e10edce01b427"
 dependencies = [
  "once_cell",
- "owo-colors",
+ "owo-colors 4.2.2",
  "tracing-core",
  "tracing-error",
 ]
@@ -277,7 +266,7 @@ dependencies = [
  "encode_unicode",
  "libc",
  "once_cell",
- "unicode-width 0.2.0",
+ "unicode-width 0.2.1",
  "windows-sys 0.59.0",
 ]
 
@@ -333,7 +322,7 @@ dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -344,12 +333,12 @@ checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
 
 [[package]]
 name = "errno"
-version = "0.3.11"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
+checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -386,20 +375,20 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasi 0.11.1+wasi-snapshot-preview1",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
 dependencies = [
  "cfg-if",
  "libc",
@@ -409,9 +398,9 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.28.1"
+version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
+checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
 
 [[package]]
 name = "indenter"
@@ -428,7 +417,7 @@ dependencies = [
  "console",
  "number_prefix",
  "portable-atomic",
- "unicode-width 0.2.0",
+ "unicode-width 0.2.1",
  "web-time",
 ]
 
@@ -490,15 +479,15 @@ checksum = "db13adb97ab515a3691f56e4dbab09283d0b86cb45abd991d8634a9d6f501760"
 
 [[package]]
 name = "libc"
-version = "0.2.171"
+version = "0.2.174"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
 
 [[package]]
 name = "libffi"
-version = "4.0.0"
+version = "4.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a9434b6fc77375fb624698d5f8c49d7e80b10d59eb1219afda27d1f824d4074"
+checksum = "e7681c6fab541f799a829e44a445a0666cf8d8a6cfebf89419e6aed52c604e87"
 dependencies = [
  "libc",
  "libffi-sys",
@@ -506,28 +495,28 @@ dependencies = [
 
 [[package]]
 name = "libffi-sys"
-version = "3.2.0"
+version = "3.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ead36a2496acfc8edd6cc32352110e9478ac5b9b5f5b9856ebd3d28019addb84"
+checksum = "7b0d828d367b4450ed08e7d510dc46636cd660055f50d67ac943bfe788767c29"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "libloading"
-version = "0.8.6"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
+checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667"
 dependencies = [
  "cfg-if",
- "windows-targets",
+ "windows-targets 0.53.2",
 ]
 
 [[package]]
 name = "libredox"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+checksum = "1580801010e535496706ba011c15f8532df6b42297d2e471fec38ceadd8c0638"
 dependencies = [
  "bitflags",
  "libc",
@@ -535,15 +524,15 @@ dependencies = [
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
 
 [[package]]
 name = "lock_api"
-version = "0.4.12"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
+checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765"
 dependencies = [
  "autocfg",
  "scopeguard",
@@ -557,9 +546,9 @@ checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
 [[package]]
 name = "measureme"
-version = "12.0.1"
+version = "12.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "570a507d8948a66a97f42cbbaf8a6bb9516a51017d4ee949502ad7a10a864395"
+checksum = "6ebd1ebda747ae161a4a377bf93f87e18d46faad2331cc0c7d25b84b1d445f49"
 dependencies = [
  "log",
  "memmap2",
@@ -571,9 +560,9 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.7.4"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
 
 [[package]]
 name = "memmap2"
@@ -586,23 +575,23 @@ dependencies = [
 
 [[package]]
 name = "miniz_oxide"
-version = "0.7.4"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
 dependencies = [
- "adler",
+ "adler2",
 ]
 
 [[package]]
 name = "mio"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
+checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
 dependencies = [
  "libc",
  "log",
- "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.52.0",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -616,14 +605,14 @@ dependencies = [
  "chrono-tz",
  "colored",
  "directories",
- "getrandom 0.3.2",
+ "getrandom 0.3.3",
  "ipc-channel",
  "libc",
  "libffi",
  "libloading",
  "measureme",
  "nix",
- "rand 0.9.0",
+ "rand 0.9.1",
  "regex",
  "rustc_version",
  "serde",
@@ -663,9 +652,9 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
 
 [[package]]
 name = "object"
-version = "0.32.2"
+version = "0.36.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
 dependencies = [
  "memchr",
 ]
@@ -688,6 +677,12 @@ version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f"
 
+[[package]]
+name = "owo-colors"
+version = "4.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48dd4f4a2c8405440fd0462561f0e5806bd0f77e86f51c761481bdd4018b545e"
+
 [[package]]
 name = "pad"
 version = "0.1.6"
@@ -699,9 +694,9 @@ dependencies = [
 
 [[package]]
 name = "parking_lot"
-version = "0.12.3"
+version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
+checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13"
 dependencies = [
  "lock_api",
  "parking_lot_core",
@@ -709,24 +704,15 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.10"
+version = "0.9.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
+checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5"
 dependencies = [
  "cfg-if",
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-targets",
-]
-
-[[package]]
-name = "parse-zoneinfo"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f2a05b18d44e2957b88f96ba460715e295bc1d7510468a2f3d3b44535d26c24"
-dependencies = [
- "regex",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -740,38 +726,18 @@ dependencies = [
 
 [[package]]
 name = "phf"
-version = "0.11.3"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
+checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7"
 dependencies = [
  "phf_shared",
 ]
 
-[[package]]
-name = "phf_codegen"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
-dependencies = [
- "phf_generator",
- "phf_shared",
-]
-
-[[package]]
-name = "phf_generator"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
-dependencies = [
- "phf_shared",
- "rand 0.8.5",
-]
-
 [[package]]
 name = "phf_shared"
-version = "0.11.3"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
+checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981"
 dependencies = [
  "siphasher",
 ]
@@ -784,9 +750,9 @@ checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
 [[package]]
 name = "portable-atomic"
-version = "1.11.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
 
 [[package]]
 name = "ppv-lite86"
@@ -803,15 +769,15 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "abec3fb083c10660b3854367697da94c674e9e82aa7511014dc958beeb7215e9"
 dependencies = [
- "owo-colors",
+ "owo-colors 3.5.0",
  "pad",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.94"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
@@ -827,9 +793,9 @@ dependencies = [
 
 [[package]]
 name = "r-efi"
-version = "5.2.0"
+version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
 name = "rand"
@@ -844,13 +810,12 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
- "zerocopy",
 ]
 
 [[package]]
@@ -879,7 +844,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
 ]
 
 [[package]]
@@ -888,14 +853,14 @@ version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
 dependencies = [
- "getrandom 0.3.2",
+ "getrandom 0.3.3",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.10"
+version = "0.5.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b8c0c260b63a8219631167be35e6a988e9554dbd323f8bd08439c8ed1302bd1"
+checksum = "0d04b7d0ee6b4a0207a0a7adb104d23ecb0b47d6beae7152d0fa34b692b29fd6"
 dependencies = [
  "bitflags",
 ]
@@ -906,7 +871,7 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "libredox",
  "thiserror 2.0.12",
 ]
@@ -942,9 +907,9 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.24"
+version = "0.1.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
+checksum = "989e6739f80c4ad5b13e0fd7fe89531180375b18520cc8c82080e4dc4035b84f"
 
 [[package]]
 name = "rustc-hash"
@@ -975,17 +940,23 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.0.5"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf"
+checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
 dependencies = [
  "bitflags",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
+[[package]]
+name = "rustversion"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
+
 [[package]]
 name = "ryu"
 version = "1.0.20"
@@ -1029,9 +1000,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
 dependencies = [
  "itoa",
  "memchr",
@@ -1062,9 +1033,9 @@ checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
 name = "smallvec"
-version = "1.14.0"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "spanned"
@@ -1078,9 +1049,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.100"
+version = "2.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1089,12 +1060,12 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.19.1"
+version = "3.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
+checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
 dependencies = [
  "fastrand",
- "getrandom 0.3.2",
+ "getrandom 0.3.3",
  "once_cell",
  "rustix",
  "windows-sys 0.59.0",
@@ -1142,12 +1113,11 @@ dependencies = [
 
 [[package]]
 name = "thread_local"
-version = "1.1.8"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
 dependencies = [
  "cfg-if",
- "once_cell",
 ]
 
 [[package]]
@@ -1172,9 +1142,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-core"
-version = "0.1.33"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
+checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
 dependencies = [
  "once_cell",
  "valuable",
@@ -1247,17 +1217,19 @@ checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
 [[package]]
 name = "unicode-width"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
+checksum = "4a1a07cc7db3810833284e8d372ccdc6da29741639ecc70c9ec107df0fa6154c"
 
 [[package]]
 name = "uuid"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
+checksum = "3cf4199d1e5d15ddd86a694e4d0dffa9c323ce759fea589f00fef9d81cc1931d"
 dependencies = [
- "getrandom 0.3.2",
+ "getrandom 0.3.3",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -1274,9 +1246,9 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
 name = "wasi"
@@ -1295,6 +1267,7 @@ checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
 dependencies = [
  "cfg-if",
  "once_cell",
+ "rustversion",
  "wasm-bindgen-macro",
 ]
 
@@ -1361,7 +1334,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
 dependencies = [
  "windows-core",
- "windows-targets",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -1374,7 +1347,7 @@ dependencies = [
  "windows-interface",
  "windows-result",
  "windows-strings",
- "windows-targets",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -1405,7 +1378,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -1415,25 +1388,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
 dependencies = [
  "windows-result",
- "windows-targets",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "windows-sys"
-version = "0.52.0"
+version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "windows-sys"
-version = "0.59.0"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.53.2",
 ]
 
 [[package]]
@@ -1442,14 +1415,30 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "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",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
+dependencies = [
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
 ]
 
 [[package]]
@@ -1458,48 +1447,96 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
 [[package]]
 name = "wit-bindgen-rt"
 version = "0.39.0"
@@ -1511,18 +1548,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.24"
+version = "0.8.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2586fea28e186957ef732a5f8b3be2da217d65c5969d4b1e17f973ebbe876879"
+checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.24"
+version = "0.8.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a996a8f63c5c4448cd959ac1bab0aaa3306ccfd060472f85943ee0750f0169be"
+checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/src/tools/miri/cargo-miri/Cargo.lock b/src/tools/miri/cargo-miri/Cargo.lock
index d37f8750bde..8310dfec939 100644
--- a/src/tools/miri/cargo-miri/Cargo.lock
+++ b/src/tools/miri/cargo-miri/Cargo.lock
@@ -2,32 +2,23 @@
 # It is not intended for manual editing.
 version = 4
 
-[[package]]
-name = "aho-corasick"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "anyhow"
-version = "1.0.97"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "bitflags"
-version = "2.9.0"
+version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
 
 [[package]]
 name = "camino"
-version = "1.1.9"
+version = "1.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
+checksum = "0da45bc31171d8d6960122e222a67740df867c1dd53b4d51caa297084c185cab"
 dependencies = [
  "serde",
 ]
@@ -70,9 +61,9 @@ dependencies = [
 
 [[package]]
 name = "cfg-if"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
 
 [[package]]
 name = "directories"
@@ -92,17 +83,23 @@ dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys",
+ "windows-sys 0.60.2",
 ]
 
+[[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.11"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
+checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -113,20 +110,20 @@ checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
 name = "getrandom"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasi 0.11.1+wasi-snapshot-preview1",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
 dependencies = [
  "cfg-if",
  "libc",
@@ -134,6 +131,22 @@ dependencies = [
  "wasi 0.14.2+wasi-0.2.4",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.15.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
+
+[[package]]
+name = "indexmap"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.15"
@@ -142,15 +155,15 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "libc"
-version = "0.2.171"
+version = "0.2.174"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
 
 [[package]]
 name = "libredox"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+checksum = "1580801010e535496706ba011c15f8532df6b42297d2e471fec38ceadd8c0638"
 dependencies = [
  "bitflags",
  "libc",
@@ -158,15 +171,15 @@ dependencies = [
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
 
 [[package]]
 name = "memchr"
-version = "2.7.4"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
 
 [[package]]
 name = "once_cell"
@@ -182,9 +195,9 @@ checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.94"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
@@ -200,9 +213,9 @@ dependencies = [
 
 [[package]]
 name = "r-efi"
-version = "5.2.0"
+version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
 name = "redox_users"
@@ -210,50 +223,21 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "libredox",
  "thiserror",
 ]
 
-[[package]]
-name = "regex"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
-
 [[package]]
 name = "rustc-build-sysroot"
-version = "0.5.8"
+version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16d115ad7e26e0d1337f64ae6598f758194696afc2e9f34c8a6f24582529c3dc"
+checksum = "fdb13874a0e55baf4ac3d49d38206aecb31a55b75d6c4d04fd850b53942c8cc8"
 dependencies = [
  "anyhow",
- "regex",
  "rustc_version",
  "tempfile",
+ "toml",
  "walkdir",
 ]
 
@@ -274,15 +258,15 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.0.5"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf"
+checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
 dependencies = [
  "bitflags",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -331,9 +315,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
 dependencies = [
  "itoa",
  "memchr",
@@ -341,11 +325,20 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "syn"
-version = "2.0.100"
+version = "2.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -354,15 +347,15 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.19.1"
+version = "3.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
+checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
 dependencies = [
  "fastrand",
- "getrandom 0.3.2",
+ "getrandom 0.3.3",
  "once_cell",
  "rustix",
- "windows-sys",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -385,6 +378,48 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "toml"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+dependencies = [
+ "indexmap",
+ "serde",
+ "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",
+ "winnow",
+]
+
+[[package]]
+name = "toml_write"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.18"
@@ -403,9 +438,9 @@ dependencies = [
 
 [[package]]
 name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
 name = "wasi"
@@ -422,7 +457,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -431,7 +466,16 @@ version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.2",
 ]
 
 [[package]]
@@ -440,14 +484,30 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "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",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
+dependencies = [
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
 ]
 
 [[package]]
@@ -456,48 +516,105 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
+[[package]]
+name = "winnow"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "wit-bindgen-rt"
 version = "0.39.0"
diff --git a/src/tools/miri/miri-script/Cargo.lock b/src/tools/miri/miri-script/Cargo.lock
index 3494a241ec5..0e11f6efd10 100644
--- a/src/tools/miri/miri-script/Cargo.lock
+++ b/src/tools/miri/miri-script/Cargo.lock
@@ -4,9 +4,9 @@ version = 4
 
 [[package]]
 name = "anstream"
-version = "0.6.18"
+version = "0.6.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
+checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -19,62 +19,62 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.10"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
+checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.6"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
+checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.7"
+version = "3.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
+checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882"
 dependencies = [
  "anstyle",
- "once_cell",
- "windows-sys",
+ "once_cell_polyfill",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.97"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "bitflags"
-version = "2.9.0"
+version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
 
 [[package]]
 name = "cfg-if"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
 
 [[package]]
 name = "clap"
-version = "4.5.35"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8aa86934b44c19c50f87cc2790e19f54f7a67aedb64101c2e1a2e5ecfb73944"
+checksum = "be92d32e80243a54711e5d7ce823c35c41c9d929dc4ab58e1276f625841aadf9"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -82,9 +82,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.35"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2414dbb2dd0695280da6ea9261e327479e9d37b0630f6b53ba2a11c60c679fd9"
+checksum = "707eab41e9622f9139419d573eca0900137718000c517d47da73045f54331c3d"
 dependencies = [
  "anstream",
  "anstyle",
@@ -94,9 +94,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.32"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09176aae279615badda0765c0c0b3f6ed53f4709118af73cf4655d85d1530cd7"
+checksum = "ef4f52386a59ca4c860f7393bcf8abd8dfd91ecccc0f774635ff68e92eeef491"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -106,15 +106,15 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.7.4"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
+checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675"
 
 [[package]]
 name = "colorchoice"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 
 [[package]]
 name = "directories"
@@ -134,7 +134,7 @@ dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -157,12 +157,12 @@ checksum = "c7f84e12ccf0a7ddc17a6c41c93326024c42920d7ee630d04950e6926645c0fe"
 
 [[package]]
 name = "errno"
-version = "0.3.11"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
+checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -173,20 +173,20 @@ checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
 name = "getrandom"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasi 0.11.1+wasi-snapshot-preview1",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
 dependencies = [
  "cfg-if",
  "libc",
@@ -223,15 +223,15 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "libc"
-version = "0.2.171"
+version = "0.2.174"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
 
 [[package]]
 name = "libredox"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+checksum = "1580801010e535496706ba011c15f8532df6b42297d2e471fec38ceadd8c0638"
 dependencies = [
  "bitflags",
  "libc",
@@ -239,21 +239,15 @@ dependencies = [
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.15"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
 
 [[package]]
 name = "memchr"
-version = "2.7.4"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
 
 [[package]]
 name = "miri-script"
@@ -282,6 +276,12 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
+
 [[package]]
 name = "option-ext"
 version = "0.2.0"
@@ -296,9 +296,9 @@ checksum = "a6e819bbd49d5939f682638fa54826bf1650abddcd65d000923de8ad63cc7d15"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.94"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
@@ -314,9 +314,9 @@ dependencies = [
 
 [[package]]
 name = "r-efi"
-version = "5.2.0"
+version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
 name = "redox_users"
@@ -324,7 +324,7 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b"
 dependencies = [
- "getrandom 0.2.15",
+ "getrandom 0.2.16",
  "libredox",
  "thiserror",
 ]
@@ -340,28 +340,15 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.44"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
+checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
 dependencies = [
  "bitflags",
  "errno",
  "libc",
- "linux-raw-sys 0.4.15",
- "windows-sys",
-]
-
-[[package]]
-name = "rustix"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf"
-dependencies = [
- "bitflags",
- "errno",
- "libc",
- "linux-raw-sys 0.9.3",
- "windows-sys",
+ "linux-raw-sys",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -407,9 +394,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
 dependencies = [
  "itoa",
  "memchr",
@@ -431,9 +418,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.100"
+version = "2.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -442,15 +429,15 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.19.1"
+version = "3.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
+checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
 dependencies = [
  "fastrand",
- "getrandom 0.3.2",
+ "getrandom 0.3.3",
  "once_cell",
- "rustix 1.0.5",
- "windows-sys",
+ "rustix",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -497,9 +484,9 @@ dependencies = [
 
 [[package]]
 name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
 name = "wasi"
@@ -512,13 +499,13 @@ dependencies = [
 
 [[package]]
 name = "which"
-version = "7.0.2"
+version = "7.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2774c861e1f072b3aadc02f8ba886c26ad6321567ecc294c935434cad06f1283"
+checksum = "24d643ce3fd3e5b54854602a080f34fb10ab75e0b813ee32d00ca2b44fa74762"
 dependencies = [
  "either",
  "env_home",
- "rustix 0.38.44",
+ "rustix",
  "winsafe",
 ]
 
@@ -528,7 +515,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -537,7 +524,16 @@ version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.2",
 ]
 
 [[package]]
@@ -546,14 +542,30 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "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",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
+dependencies = [
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
 ]
 
 [[package]]
@@ -562,48 +574,96 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
 [[package]]
 name = "winsafe"
 version = "0.0.19"
-- 
cgit 1.4.1-3-g733a5


From bb79e79cd121e4ccc72720e922aab53ae1350a22 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 13:34:58 +0200
Subject: bump colored dep

---
 src/tools/miri/Cargo.lock | 13 +++++++++++--
 src/tools/miri/Cargo.toml |  2 +-
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/tools/miri/Cargo.lock b/src/tools/miri/Cargo.lock
index 93db99f7abc..fb06fac17eb 100644
--- a/src/tools/miri/Cargo.lock
+++ b/src/tools/miri/Cargo.lock
@@ -251,6 +251,15 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "colored"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fde0e0ec90c9dfb3b4b1a0891a7dcd0e2bffde2f7efed5fe7c9bb00e5bfb915e"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "comma"
 version = "1.0.0"
@@ -603,7 +612,7 @@ dependencies = [
  "capstone",
  "chrono",
  "chrono-tz",
- "colored",
+ "colored 3.0.0",
  "directories",
  "getrandom 0.3.3",
  "ipc-channel",
@@ -1189,7 +1198,7 @@ dependencies = [
  "cargo-platform",
  "cargo_metadata",
  "color-eyre",
- "colored",
+ "colored 2.2.0",
  "comma",
  "crossbeam-channel",
  "indicatif",
diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index b3503acf0c0..1e7381461c6 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -50,7 +50,7 @@ capstone = { version = "0.13", optional = true }
 
 [dev-dependencies]
 ui_test = "0.29.1"
-colored = "2"
+colored = "3"
 rustc_version = "0.4"
 regex = "1.5.5"
 tempfile = "3"
-- 
cgit 1.4.1-3-g733a5


From 4bd80887d8025353971c7724b8e526c1e7a66fb9 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 13:51:26 +0200
Subject: bump ipc-channel

---
 src/tools/miri/Cargo.lock | 46 +++++++---------------------------------------
 src/tools/miri/Cargo.toml |  2 +-
 2 files changed, 8 insertions(+), 40 deletions(-)

diff --git a/src/tools/miri/Cargo.lock b/src/tools/miri/Cargo.lock
index fb06fac17eb..6aeb5276f61 100644
--- a/src/tools/miri/Cargo.lock
+++ b/src/tools/miri/Cargo.lock
@@ -441,17 +441,16 @@ dependencies = [
 
 [[package]]
 name = "ipc-channel"
-version = "0.19.0"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8251fb7bcd9ccd3725ed8deae9fe7db8e586495c9eb5b0c52e6233e5e75ea"
+checksum = "5b1c98b70019c830a1fc39cecfe1f60ff99c4122f0a189697c810c90ec545c14"
 dependencies = [
  "bincode",
  "crossbeam-channel",
  "fnv",
- "lazy_static",
  "libc",
  "mio",
- "rand 0.8.5",
+ "rand",
  "serde",
  "tempfile",
  "uuid",
@@ -598,7 +597,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
 dependencies = [
  "libc",
- "log",
  "wasi 0.11.1+wasi-snapshot-preview1",
  "windows-sys 0.59.0",
 ]
@@ -621,7 +619,7 @@ dependencies = [
  "libloading",
  "measureme",
  "nix",
- "rand 0.9.1",
+ "rand",
  "regex",
  "rustc_version",
  "serde",
@@ -806,35 +804,14 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha 0.3.1",
- "rand_core 0.6.4",
-]
-
 [[package]]
 name = "rand"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
 dependencies = [
- "rand_chacha 0.9.0",
- "rand_core 0.9.3",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.6.4",
+ "rand_chacha",
+ "rand_core",
 ]
 
 [[package]]
@@ -844,16 +821,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.9.3",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom 0.2.16",
+ "rand_core",
 ]
 
 [[package]]
diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index 1e7381461c6..6031ea03bbe 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -45,7 +45,7 @@ serde = { version = "1.0.219", features = ["derive"], optional = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 nix = { version = "0.30.1", features = ["mman", "ptrace", "signal"], optional = true }
-ipc-channel = { version = "0.19.0", optional = true }
+ipc-channel = { version = "0.20.0", optional = true }
 capstone = { version = "0.13", optional = true }
 
 [dev-dependencies]
-- 
cgit 1.4.1-3-g733a5


From 0b8f558cc9e79c5a4847cf3326cc9c62cfccc3bb Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 13:53:42 +0200
Subject: bump ui_test

---
 src/tools/miri/Cargo.lock  | 9 +++++----
 src/tools/miri/Cargo.toml  | 2 +-
 src/tools/miri/tests/ui.rs | 8 +++-----
 3 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/tools/miri/Cargo.lock b/src/tools/miri/Cargo.lock
index 6aeb5276f61..0af4181dc15 100644
--- a/src/tools/miri/Cargo.lock
+++ b/src/tools/miri/Cargo.lock
@@ -1016,10 +1016,11 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "spanned"
-version = "0.3.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86af297923fbcfd107c20a189a6e9c872160df71a7190ae4a7a6c5dce4b2feb6"
+checksum = "c92d4b0c055fde758f086eb4a6e73410247df8a3837fd606d2caeeaf72aa566d"
 dependencies = [
+ "anyhow",
  "bstr",
  "color-eyre",
 ]
@@ -1156,9 +1157,9 @@ checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
 
 [[package]]
 name = "ui_test"
-version = "0.29.2"
+version = "0.30.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1211b1111c752c73b33073d2958072be08825fd97c9ab4d83444da361a06634b"
+checksum = "b56a6897cc4bb6f8daf1939b0b39cd9645856997f46f4d0b3e3cb7122dfe9251"
 dependencies = [
  "annotate-snippets",
  "anyhow",
diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index 6031ea03bbe..d293af5cea2 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -49,7 +49,7 @@ ipc-channel = { version = "0.20.0", optional = true }
 capstone = { version = "0.13", optional = true }
 
 [dev-dependencies]
-ui_test = "0.29.1"
+ui_test = "0.30.2"
 colored = "3"
 rustc_version = "0.4"
 regex = "1.5.5"
diff --git a/src/tools/miri/tests/ui.rs b/src/tools/miri/tests/ui.rs
index e521269586d..a4463d69341 100644
--- a/src/tools/miri/tests/ui.rs
+++ b/src/tools/miri/tests/ui.rs
@@ -13,7 +13,8 @@ use ui_test::custom_flags::edition::Edition;
 use ui_test::dependencies::DependencyBuilder;
 use ui_test::per_test_config::TestConfig;
 use ui_test::spanned::Spanned;
-use ui_test::{CommandBuilder, Config, Format, Match, ignore_output_conflict, status_emitter};
+use ui_test::status_emitter::StatusEmitter;
+use ui_test::{CommandBuilder, Config, Match, ignore_output_conflict};
 
 #[derive(Copy, Clone, Debug)]
 enum Mode {
@@ -216,10 +217,7 @@ fn run_tests(
         // This could be used to overwrite the `Config` on a per-test basis.
         |_, _| {},
         // No GHA output as that would also show in the main rustc repo.
-        match args.format {
-            Format::Terse => status_emitter::Text::quiet(),
-            Format::Pretty => status_emitter::Text::verbose(),
-        },
+        Box::<dyn StatusEmitter>::from(args.format),
     )
 }
 
-- 
cgit 1.4.1-3-g733a5


From f32ec588ad3524d5ea3e9145a88e94b0b42df0ed Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 13:54:44 +0200
Subject: bump cargo-metadata

---
 src/tools/miri/cargo-miri/Cargo.lock | 374 ++++++++++++++++++++++++++++++++++-
 src/tools/miri/cargo-miri/Cargo.toml |   2 +-
 2 files changed, 371 insertions(+), 5 deletions(-)

diff --git a/src/tools/miri/cargo-miri/Cargo.lock b/src/tools/miri/cargo-miri/Cargo.lock
index 8310dfec939..b3f5dafab64 100644
--- a/src/tools/miri/cargo-miri/Cargo.lock
+++ b/src/tools/miri/cargo-miri/Cargo.lock
@@ -8,6 +8,12 @@ version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
 [[package]]
 name = "bitflags"
 version = "2.9.1"
@@ -38,21 +44,38 @@ dependencies = [
 
 [[package]]
 name = "cargo-platform"
-version = "0.1.9"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84982c6c0ae343635a3a4ee6dedef965513735c8b183caa7289fa6e27399ebd4"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo-util-schemas"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
+checksum = "7dc1a6f7b5651af85774ae5a34b4e8be397d9cf4bc063b7e6dbd99a841837830"
 dependencies = [
+ "semver",
  "serde",
+ "serde-untagged",
+ "serde-value",
+ "thiserror",
+ "toml",
+ "unicode-xid",
+ "url",
 ]
 
 [[package]]
 name = "cargo_metadata"
-version = "0.19.2"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
+checksum = "5cfca2aaa699835ba88faf58a06342a314a950d2b9686165e038286c30316868"
 dependencies = [
  "camino",
  "cargo-platform",
+ "cargo-util-schemas",
  "semver",
  "serde",
  "serde_json",
@@ -86,12 +109,33 @@ dependencies = [
  "windows-sys 0.60.2",
 ]
 
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
+[[package]]
+name = "erased-serde"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e004d887f51fcb9fef17317a2f3525c887d8aa3f4f50fed920816a688284a5b7"
+dependencies = [
+ "serde",
+ "typeid",
+]
+
 [[package]]
 name = "errno"
 version = "0.3.13"
@@ -108,6 +152,15 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
+[[package]]
+name = "form_urlencoded"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
+dependencies = [
+ "percent-encoding",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.16"
@@ -137,6 +190,113 @@ version = "0.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
 
+[[package]]
+name = "icu_collections"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
+
+[[package]]
+name = "icu_properties"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "potential_utf",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
+
+[[package]]
+name = "icu_provider"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "idna"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.10.0"
@@ -175,12 +335,27 @@ version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
 
+[[package]]
+name = "litemap"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
+
 [[package]]
 name = "memchr"
 version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
 
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.21.3"
@@ -193,6 +368,30 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
+[[package]]
+name = "ordered-float"
+version = "2.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+
+[[package]]
+name = "potential_utf"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585"
+dependencies = [
+ "zerovec",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.95"
@@ -302,6 +501,27 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-untagged"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "299d9c19d7d466db4ab10addd5703e4c615dec2a5a16dbbafe191045e87ee66e"
+dependencies = [
+ "erased-serde",
+ "serde",
+ "typeid",
+]
+
+[[package]]
+name = "serde-value"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3a1a3341211875ef120e117ea7fd5228530ae7e7036a779fdc9117be6b3282c"
+dependencies = [
+ "ordered-float",
+ "serde",
+]
+
 [[package]]
 name = "serde_derive"
 version = "1.0.219"
@@ -334,6 +554,18 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
 [[package]]
 name = "syn"
 version = "2.0.104"
@@ -345,6 +577,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "tempfile"
 version = "3.20.0"
@@ -378,6 +621,16 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "tinystr"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
 [[package]]
 name = "toml"
 version = "0.8.23"
@@ -420,12 +673,41 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "url"
+version = "2.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+]
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -623,3 +905,87 @@ checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
 dependencies = [
  "bitflags",
 ]
+
+[[package]]
+name = "writeable"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
+
+[[package]]
+name = "yoke"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/src/tools/miri/cargo-miri/Cargo.toml b/src/tools/miri/cargo-miri/Cargo.toml
index e08733959cc..77cb1df8e74 100644
--- a/src/tools/miri/cargo-miri/Cargo.toml
+++ b/src/tools/miri/cargo-miri/Cargo.toml
@@ -17,7 +17,7 @@ doctest = false # and no doc tests
 directories = "6"
 rustc_version = "0.4"
 serde_json = "1.0.40"
-cargo_metadata = "0.19"
+cargo_metadata = "0.21"
 rustc-build-sysroot = "0.5.8"
 
 # Enable some feature flags that dev-dependencies need but dependencies
-- 
cgit 1.4.1-3-g733a5


From 6ce164d1df26b5efd4cdd950e418269480870619 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 13:57:51 +0200
Subject: ditch which dependency

---
 src/tools/miri/miri-script/Cargo.lock      | 25 -------------------------
 src/tools/miri/miri-script/Cargo.toml      |  1 -
 src/tools/miri/miri-script/src/commands.rs |  7 +++----
 3 files changed, 3 insertions(+), 30 deletions(-)

diff --git a/src/tools/miri/miri-script/Cargo.lock b/src/tools/miri/miri-script/Cargo.lock
index 0e11f6efd10..a049bfcbccd 100644
--- a/src/tools/miri/miri-script/Cargo.lock
+++ b/src/tools/miri/miri-script/Cargo.lock
@@ -149,12 +149,6 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
-[[package]]
-name = "env_home"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7f84e12ccf0a7ddc17a6c41c93326024c42920d7ee630d04950e6926645c0fe"
-
 [[package]]
 name = "errno"
 version = "0.3.13"
@@ -266,7 +260,6 @@ dependencies = [
  "shell-words",
  "tempfile",
  "walkdir",
- "which",
  "xshell",
 ]
 
@@ -497,18 +490,6 @@ dependencies = [
  "wit-bindgen-rt",
 ]
 
-[[package]]
-name = "which"
-version = "7.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d643ce3fd3e5b54854602a080f34fb10ab75e0b813ee32d00ca2b44fa74762"
-dependencies = [
- "either",
- "env_home",
- "rustix",
- "winsafe",
-]
-
 [[package]]
 name = "winapi-util"
 version = "0.1.9"
@@ -664,12 +645,6 @@ version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
 
-[[package]]
-name = "winsafe"
-version = "0.0.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"
-
 [[package]]
 name = "wit-bindgen-rt"
 version = "0.39.0"
diff --git a/src/tools/miri/miri-script/Cargo.toml b/src/tools/miri/miri-script/Cargo.toml
index 9240788d6bc..b3f82cd1d50 100644
--- a/src/tools/miri/miri-script/Cargo.toml
+++ b/src/tools/miri/miri-script/Cargo.toml
@@ -14,7 +14,6 @@ rust-version = "1.85"
 # This is needed to make this package build on stable when the parent package uses unstable cargo features.
 
 [dependencies]
-which = "7"
 walkdir = "2.3"
 itertools = "0.14"
 path_macro = "1.0"
diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index e6ebdf54e38..9aaad9ca04a 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -198,9 +198,6 @@ impl Command {
     }
 
     fn toolchain(flags: Vec<String>) -> Result<()> {
-        // Make sure rustup-toolchain-install-master is installed.
-        which::which("rustup-toolchain-install-master")
-            .context("Please install rustup-toolchain-install-master by running 'cargo install rustup-toolchain-install-master'")?;
         let sh = Shell::new()?;
         sh.change_dir(miri_dir()?);
         let new_commit = sh.read_file("rust-version")?.trim().to_owned();
@@ -227,7 +224,9 @@ impl Command {
         // Install and setup new toolchain.
         cmd!(sh, "rustup toolchain uninstall miri").run()?;
 
-        cmd!(sh, "rustup-toolchain-install-master -n miri -c cargo -c rust-src -c rustc-dev -c llvm-tools -c rustfmt -c clippy {flags...} -- {new_commit}").run()?;
+        cmd!(sh, "rustup-toolchain-install-master -n miri -c cargo -c rust-src -c rustc-dev -c llvm-tools -c rustfmt -c clippy {flags...} -- {new_commit}")
+            .run()
+            .context("Failed to run rustup-toolchain-install-master. If it is not installed, run 'cargo install rustup-toolchain-install-master'.")?;
         cmd!(sh, "rustup override set miri").run()?;
         // Cleanup.
         cmd!(sh, "cargo clean").run()?;
-- 
cgit 1.4.1-3-g733a5


From 6a67a34b73ea8660d02d9220c1f4c7435f1f2082 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 14:07:43 +0200
Subject: move and update test dependencies

---
 src/tools/miri/cargo-miri/src/util.rs        |   7 +-
 src/tools/miri/miri-script/src/main.rs       |   2 +-
 src/tools/miri/test_dependencies/Cargo.lock  | 543 -----------------------
 src/tools/miri/test_dependencies/Cargo.toml  |  38 --
 src/tools/miri/test_dependencies/src/main.rs |   1 -
 src/tools/miri/tests/deps/Cargo.lock         | 635 +++++++++++++++++++++++++++
 src/tools/miri/tests/deps/Cargo.toml         |  38 ++
 src/tools/miri/tests/deps/src/main.rs        |   1 +
 src/tools/miri/tests/ui.rs                   |   2 +-
 9 files changed, 680 insertions(+), 587 deletions(-)
 delete mode 100644 src/tools/miri/test_dependencies/Cargo.lock
 delete mode 100644 src/tools/miri/test_dependencies/Cargo.toml
 delete mode 100644 src/tools/miri/test_dependencies/src/main.rs
 create mode 100644 src/tools/miri/tests/deps/Cargo.lock
 create mode 100644 src/tools/miri/tests/deps/Cargo.toml
 create mode 100644 src/tools/miri/tests/deps/src/main.rs

diff --git a/src/tools/miri/cargo-miri/src/util.rs b/src/tools/miri/cargo-miri/src/util.rs
index 43b2a1b6173..82c6a929357 100644
--- a/src/tools/miri/cargo-miri/src/util.rs
+++ b/src/tools/miri/cargo-miri/src/util.rs
@@ -129,7 +129,8 @@ pub fn exec(mut cmd: Command) -> ! {
     // On non-Unix imitate POSIX exec as closely as we can
     #[cfg(not(unix))]
     {
-        let exit_status = cmd.status().expect("failed to run command");
+        let exit_status =
+            cmd.status().unwrap_or_else(|err| panic!("failed to run `{cmd:?}`:\n{err}"));
         std::process::exit(exit_status.code().unwrap_or(-1))
     }
     // On Unix targets, actually exec.
@@ -138,8 +139,8 @@ pub fn exec(mut cmd: Command) -> ! {
     #[cfg(unix)]
     {
         use std::os::unix::process::CommandExt;
-        let error = cmd.exec();
-        panic!("failed to run command: {error}")
+        let err = cmd.exec();
+        panic!("failed to run `{cmd:?}`:\n{err}")
     }
 }
 
diff --git a/src/tools/miri/miri-script/src/main.rs b/src/tools/miri/miri-script/src/main.rs
index 673d658cf1d..e41df662ca2 100644
--- a/src/tools/miri/miri-script/src/main.rs
+++ b/src/tools/miri/miri-script/src/main.rs
@@ -75,7 +75,7 @@ pub enum Command {
     ///
     /// Also respects MIRIFLAGS environment variable.
     Run {
-        /// Build the program with the dependencies declared in `test_dependencies/Cargo.toml`.
+        /// Build the program with the dependencies declared in `tests/deps/Cargo.toml`.
         #[arg(long)]
         dep: bool,
         /// Show build progress.
diff --git a/src/tools/miri/test_dependencies/Cargo.lock b/src/tools/miri/test_dependencies/Cargo.lock
deleted file mode 100644
index 276c518e74f..00000000000
--- a/src/tools/miri/test_dependencies/Cargo.lock
+++ /dev/null
@@ -1,543 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "addr2line"
-version = "0.24.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
-dependencies = [
- "gimli",
-]
-
-[[package]]
-name = "adler2"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
-
-[[package]]
-name = "backtrace"
-version = "0.3.74"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a"
-dependencies = [
- "addr2line",
- "cfg-if",
- "libc",
- "miniz_oxide",
- "object",
- "rustc-demangle",
- "windows-targets",
-]
-
-[[package]]
-name = "bitflags"
-version = "2.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
-
-[[package]]
-name = "bumpalo"
-version = "3.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
-
-[[package]]
-name = "bytes"
-version = "1.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "errno"
-version = "0.3.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
-dependencies = [
- "libc",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "fastrand"
-version = "2.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
-
-[[package]]
-name = "getrandom"
-version = "0.1.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi 0.9.0+wasi-snapshot-preview1",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
-dependencies = [
- "cfg-if",
- "js-sys",
- "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
-dependencies = [
- "cfg-if",
- "libc",
- "r-efi",
- "wasi 0.14.2+wasi-0.2.4",
-]
-
-[[package]]
-name = "gimli"
-version = "0.31.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
-
-[[package]]
-name = "hermit-abi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
-
-[[package]]
-name = "js-sys"
-version = "0.3.77"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
-dependencies = [
- "once_cell",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.171"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413"
-
-[[package]]
-name = "log"
-version = "0.4.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
-
-[[package]]
-name = "memchr"
-version = "2.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
-
-[[package]]
-name = "miniz_oxide"
-version = "0.8.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3be647b768db090acb35d5ec5db2b0e1f1de11133ca123b9eacf5137868f892a"
-dependencies = [
- "adler2",
-]
-
-[[package]]
-name = "mio"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
-dependencies = [
- "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "miri-test-deps"
-version = "0.1.0"
-dependencies = [
- "cfg-if",
- "getrandom 0.1.16",
- "getrandom 0.2.15",
- "getrandom 0.3.2",
- "libc",
- "num_cpus",
- "page_size",
- "tempfile",
- "tokio",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "num_cpus"
-version = "1.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
-dependencies = [
- "hermit-abi",
- "libc",
-]
-
-[[package]]
-name = "object"
-version = "0.36.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
-
-[[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 = "pin-project-lite"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.94"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "r-efi"
-version = "5.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
-
-[[package]]
-name = "rustc-demangle"
-version = "0.1.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
-
-[[package]]
-name = "rustix"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d97817398dd4bb2e6da002002db259209759911da105da92bec29ccb12cf58bf"
-dependencies = [
- "bitflags",
- "errno",
- "libc",
- "linux-raw-sys",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "signal-hook-registry"
-version = "1.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "socket2"
-version = "0.5.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f5fd57c80058a56cf5c777ab8a126398ece8e442983605d280a44ce79d0edef"
-dependencies = [
- "libc",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tempfile"
-version = "3.19.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
-dependencies = [
- "fastrand",
- "getrandom 0.3.2",
- "once_cell",
- "rustix",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "tokio"
-version = "1.44.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6b88822cbe49de4185e3a4cbf8321dd487cf5fe0c5c65695fef6346371e9c48"
-dependencies = [
- "backtrace",
- "bytes",
- "libc",
- "mio",
- "pin-project-lite",
- "signal-hook-registry",
- "socket2",
- "tokio-macros",
- "windows-sys 0.52.0",
-]
-
-[[package]]
-name = "tokio-macros"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
-
-[[package]]
-name = "wasi"
-version = "0.9.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "wasi"
-version = "0.14.2+wasi-0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
-dependencies = [
- "wit-bindgen-rt",
-]
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
-dependencies = [
- "cfg-if",
- "once_cell",
- "wasm-bindgen-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
-dependencies = [
- "bumpalo",
- "log",
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
-dependencies = [
- "unicode-ident",
-]
-
-[[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-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "windows-sys"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
-dependencies = [
- "windows-targets",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.59.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
-dependencies = [
- "windows-targets",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
-dependencies = [
- "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.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
-
-[[package]]
-name = "wit-bindgen-rt"
-version = "0.39.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
-dependencies = [
- "bitflags",
-]
diff --git a/src/tools/miri/test_dependencies/Cargo.toml b/src/tools/miri/test_dependencies/Cargo.toml
deleted file mode 100644
index 35555723f5d..00000000000
--- a/src/tools/miri/test_dependencies/Cargo.toml
+++ /dev/null
@@ -1,38 +0,0 @@
-[package]
-authors = ["Miri Team"]
-description = "dependencies that unit tests can have"
-license = "MIT OR Apache-2.0"
-name = "miri-test-deps"
-repository = "https://github.com/rust-lang/miri"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-# all dependencies (and their transitive ones) listed here can be used in `tests/*-dep`.
-libc = "0.2"
-num_cpus = "1.10.1"
-cfg-if = "1"
-
-getrandom_01 = { package = "getrandom", version = "0.1" }
-getrandom_02 = { package = "getrandom", version = "0.2", features = ["js"] }
-getrandom_03 = { package = "getrandom", version = "0.3" }
-
-[target.'cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))'.dependencies]
-tempfile = "3"
-page_size = "0.6"
-# Avoid pulling in all of tokio's dependencies.
-# However, without `net` and `signal`, tokio uses fewer relevant system APIs.
-tokio = { version = "1", features = ["macros", "rt-multi-thread", "time", "net", "fs", "sync", "signal", "io-util"] }
-
-[target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.59", features = [
-    "Win32_Foundation",
-    "Win32_System_Threading",
-    "Win32_Storage_FileSystem",
-    "Win32_Security",
-    "Win32_System_IO",
-    "Wdk_Storage_FileSystem",
-] }
-
-# Make sure we are not part of the rustc workspace.
-[workspace]
diff --git a/src/tools/miri/test_dependencies/src/main.rs b/src/tools/miri/test_dependencies/src/main.rs
deleted file mode 100644
index f328e4d9d04..00000000000
--- a/src/tools/miri/test_dependencies/src/main.rs
+++ /dev/null
@@ -1 +0,0 @@
-fn main() {}
diff --git a/src/tools/miri/tests/deps/Cargo.lock b/src/tools/miri/tests/deps/Cargo.lock
new file mode 100644
index 00000000000..4b783ebdc4e
--- /dev/null
+++ b/src/tools/miri/tests/deps/Cargo.lock
@@ -0,0 +1,635 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "addr2line"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "backtrace"
+version = "0.3.75"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6806a6321ec58106fea15becdad98371e28d92ccbc7c8f1b3b6dd724fe8f1002"
+dependencies = [
+ "addr2line",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
+
+[[package]]
+name = "bumpalo"
+version = "3.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+
+[[package]]
+name = "bytes"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
+
+[[package]]
+name = "errno"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "getrandom"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.9.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasi 0.14.2+wasi-0.2.4",
+]
+
+[[package]]
+name = "gimli"
+version = "0.31.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "io-uring"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b86e202f00093dcba4275d4636b93ef9dd75d025ae560d2521b45ea28ab49013"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.174"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
+
+[[package]]
+name = "log"
+version = "0.4.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+
+[[package]]
+name = "memchr"
+version = "2.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+]
+
+[[package]]
+name = "mio"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
+dependencies = [
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "miri-test-deps"
+version = "0.1.0"
+dependencies = [
+ "cfg-if",
+ "getrandom 0.1.16",
+ "getrandom 0.2.16",
+ "getrandom 0.3.3",
+ "libc",
+ "num_cpus",
+ "page_size",
+ "tempfile",
+ "tokio",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "object"
+version = "0.36.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[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 = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+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 = "rustc-demangle"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "989e6739f80c4ad5b13e0fd7fe89531180375b18520cc8c82080e4dc4035b84f"
+
+[[package]]
+name = "rustix"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9203b8055f63a2a00e2f593bb0510367fe707d7ff1e5c872de2f537b339e5410"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
+
+[[package]]
+name = "socket2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
+dependencies = [
+ "fastrand",
+ "getrandom 0.3.3",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "tokio"
+version = "1.46.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc3a2344dafbe23a245241fe8b09735b521110d30fcefbbd5feb1797ca35d17"
+dependencies = [
+ "backtrace",
+ "bytes",
+ "io-uring",
+ "libc",
+ "mio",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "slab",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "wasi"
+version = "0.9.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasi"
+version = "0.14.2+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+dependencies = [
+ "bumpalo",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
+
+[[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-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
+dependencies = [
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+dependencies = [
+ "bitflags",
+]
diff --git a/src/tools/miri/tests/deps/Cargo.toml b/src/tools/miri/tests/deps/Cargo.toml
new file mode 100644
index 00000000000..d85723f0915
--- /dev/null
+++ b/src/tools/miri/tests/deps/Cargo.toml
@@ -0,0 +1,38 @@
+[package]
+authors = ["Miri Team"]
+description = "dependencies that unit tests can have"
+license = "MIT OR Apache-2.0"
+name = "miri-test-deps"
+repository = "https://github.com/rust-lang/miri"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+# all dependencies (and their transitive ones) listed here can be used in `tests/*-dep`.
+libc = "0.2"
+num_cpus = "1.10.1"
+cfg-if = "1"
+
+getrandom_01 = { package = "getrandom", version = "0.1" }
+getrandom_02 = { package = "getrandom", version = "0.2", features = ["js"] }
+getrandom_03 = { package = "getrandom", version = "0.3" }
+
+[target.'cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))'.dependencies]
+tempfile = "3"
+page_size = "0.6"
+# Avoid pulling in all of tokio's dependencies.
+# However, without `net` and `signal`, tokio uses fewer relevant system APIs.
+tokio = { version = "1", features = ["macros", "rt-multi-thread", "time", "net", "fs", "sync", "signal", "io-util"] }
+
+[target.'cfg(windows)'.dependencies]
+windows-sys = { version = "0.60", features = [
+    "Win32_Foundation",
+    "Win32_System_Threading",
+    "Win32_Storage_FileSystem",
+    "Win32_Security",
+    "Win32_System_IO",
+    "Wdk_Storage_FileSystem",
+] }
+
+# Make sure we are not part of the rustc workspace.
+[workspace]
diff --git a/src/tools/miri/tests/deps/src/main.rs b/src/tools/miri/tests/deps/src/main.rs
new file mode 100644
index 00000000000..f328e4d9d04
--- /dev/null
+++ b/src/tools/miri/tests/deps/src/main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/src/tools/miri/tests/ui.rs b/src/tools/miri/tests/ui.rs
index a4463d69341..cb915b11b67 100644
--- a/src/tools/miri/tests/ui.rs
+++ b/src/tools/miri/tests/ui.rs
@@ -142,7 +142,7 @@ fn miri_config(
                     envs: vec![("RUSTFLAGS".into(), None)],
                     ..CommandBuilder::cargo()
                 },
-                crate_manifest_path: Path::new("test_dependencies").join("Cargo.toml"),
+                crate_manifest_path: Path::new("tests/deps").join("Cargo.toml"),
                 build_std: None,
                 bless_lockfile: bless,
             },
-- 
cgit 1.4.1-3-g733a5


From c75edc982c8cf67f30d9c082cf2670f59392ed2e Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 19 Jul 2025 16:20:37 +0200
Subject: Fix clippy lints in librustdoc

---
 src/librustdoc/clean/types.rs                      |  4 +-
 src/librustdoc/clean/utils.rs                      |  6 +-
 src/librustdoc/doctest.rs                          |  4 +-
 src/librustdoc/doctest/rust.rs                     |  2 +-
 src/librustdoc/formats/renderer.rs                 |  4 +-
 src/librustdoc/html/format.rs                      | 12 ++--
 src/librustdoc/html/highlight.rs                   |  4 +-
 src/librustdoc/html/layout.rs                      |  1 -
 src/librustdoc/html/markdown.rs                    |  4 +-
 src/librustdoc/html/render/context.rs              | 84 ++++++++++------------
 src/librustdoc/html/render/mod.rs                  | 39 +++++-----
 src/librustdoc/html/render/ordered_json.rs         |  2 +-
 src/librustdoc/html/render/print_item.rs           | 80 ++++++++++-----------
 src/librustdoc/html/render/sidebar.rs              |  2 +-
 src/librustdoc/html/render/sorted_template.rs      |  3 +-
 src/librustdoc/json/conversions.rs                 | 20 +++---
 src/librustdoc/json/mod.rs                         |  6 +-
 src/librustdoc/passes/collect_intra_doc_links.rs   | 25 ++++---
 .../passes/lint/redundant_explicit_links.rs        | 16 ++---
 src/librustdoc/passes/strip_aliased_non_local.rs   | 10 ++-
 20 files changed, 154 insertions(+), 174 deletions(-)

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 09647492d93..5ac5da24299 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -1677,7 +1677,7 @@ impl Type {
         }
     }
 
-    pub(crate) fn generics<'a>(&'a self) -> Option<impl Iterator<Item = &'a Type>> {
+    pub(crate) fn generics(&self) -> Option<impl Iterator<Item = &Type>> {
         match self {
             Type::Path { path, .. } => path.generics(),
             _ => None,
@@ -2227,7 +2227,7 @@ impl Path {
         self.segments.last().map(|seg| &seg.args)
     }
 
-    pub(crate) fn generics<'a>(&'a self) -> Option<impl Iterator<Item = &'a Type>> {
+    pub(crate) fn generics(&self) -> Option<impl Iterator<Item = &Type>> {
         self.segments.last().and_then(|seg| {
             if let GenericArgs::AngleBracketed { ref args, .. } = seg.args {
                 Some(args.iter().filter_map(|arg| match arg {
diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs
index fd1b17b6476..813fdee57e1 100644
--- a/src/librustdoc/clean/utils.rs
+++ b/src/librustdoc/clean/utils.rs
@@ -343,13 +343,11 @@ pub(crate) fn name_from_pat(p: &hir::Pat<'_>) -> Symbol {
 pub(crate) fn print_const(cx: &DocContext<'_>, n: ty::Const<'_>) -> String {
     match n.kind() {
         ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, args: _ }) => {
-            let s = if let Some(def) = def.as_local() {
+            if let Some(def) = def.as_local() {
                 rendered_const(cx.tcx, cx.tcx.hir_body_owned_by(def), def)
             } else {
                 inline::print_inlined_const(cx.tcx, def)
-            };
-
-            s
+            }
         }
         // array lengths are obviously usize
         ty::ConstKind::Value(cv) if *cv.ty.kind() == ty::Uint(ty::UintTy::Usize) => {
diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 9b4d2533954..38ba6b4503d 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -632,7 +632,7 @@ fn run_test(
         // the user to exploit nightly-only features on stable
         runner_compiler.env("RUSTC_BOOTSTRAP", "1");
         runner_compiler.args(compiler_args);
-        runner_compiler.args(&["--crate-type=bin", "-o"]).arg(&output_file);
+        runner_compiler.args(["--crate-type=bin", "-o"]).arg(&output_file);
         let mut extern_path = std::ffi::OsString::from(format!(
             "--extern=doctest_bundle_{edition}=",
             edition = doctest.edition
@@ -657,7 +657,7 @@ fn run_test(
         extern_path.push(&output_bundle_file);
         runner_compiler.arg(extern_path);
         runner_compiler.arg(&runner_input_file);
-        if std::fs::write(&runner_input_file, &merged_test_code).is_err() {
+        if std::fs::write(&runner_input_file, merged_test_code).is_err() {
             // If we cannot write this file for any reason, we leave. All combined tests will be
             // tested as standalone tests.
             return Err(TestFailure::CompileError);
diff --git a/src/librustdoc/doctest/rust.rs b/src/librustdoc/doctest/rust.rs
index 96975105ac5..f5ec828187a 100644
--- a/src/librustdoc/doctest/rust.rs
+++ b/src/librustdoc/doctest/rust.rs
@@ -140,7 +140,7 @@ impl HirCollector<'_> {
                 .iter()
                 .filter(|a| a.has_name(sym::attr))
                 .flat_map(|a| a.meta_item_list().unwrap_or_default())
-                .map(|i| pprust::meta_list_item_to_string(i))
+                .map(pprust::meta_list_item_to_string)
             {
                 // Add the additional attributes to the global_crate_attrs vector
                 self.collector.global_crate_attrs.push(attr);
diff --git a/src/librustdoc/formats/renderer.rs b/src/librustdoc/formats/renderer.rs
index 79ff1fa38c3..aa4be4db997 100644
--- a/src/librustdoc/formats/renderer.rs
+++ b/src/librustdoc/formats/renderer.rs
@@ -81,7 +81,7 @@ fn run_format_inner<'tcx, T: FormatRenderer<'tcx>>(
         let _timer =
             prof.generic_activity_with_arg("render_mod_item", item.name.unwrap().to_string());
 
-        cx.mod_item_in(&item)?;
+        cx.mod_item_in(item)?;
         let (clean::StrippedItem(box clean::ModuleItem(ref module))
         | clean::ModuleItem(ref module)) = item.inner.kind
         else {
@@ -99,7 +99,7 @@ fn run_format_inner<'tcx, T: FormatRenderer<'tcx>>(
     } else if let Some(item_name) = item.name
         && !item.is_extern_crate()
     {
-        prof.generic_activity_with_arg("render_item", item_name.as_str()).run(|| cx.item(&item))?;
+        prof.generic_activity_with_arg("render_item", item_name.as_str()).run(|| cx.item(item))?;
     }
     Ok(())
 }
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index b16485107a0..be8a2d511e9 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -114,9 +114,9 @@ impl clean::Generics {
             let real_params =
                 fmt::from_fn(|f| real_params.clone().map(|g| g.print(cx)).joined(", ", f));
             if f.alternate() {
-                write!(f, "<{:#}>", real_params)
+                write!(f, "<{real_params:#}>")
             } else {
-                write!(f, "&lt;{}&gt;", real_params)
+                write!(f, "&lt;{real_params}&gt;")
             }
         })
     }
@@ -594,7 +594,7 @@ pub(crate) fn href_with_root_path(
             }
         }
     };
-    let url_parts = make_href(root_path, shortty, url_parts, &fqp, is_remote);
+    let url_parts = make_href(root_path, shortty, url_parts, fqp, is_remote);
     Ok((url_parts, shortty, fqp.clone()))
 }
 
@@ -1115,7 +1115,7 @@ impl clean::Impl {
                 {
                     let last = ty.last();
                     if f.alternate() {
-                        write!(f, "{}<", last)?;
+                        write!(f, "{last}<")?;
                         self.print_type(inner_type, f, use_absolute, cx)?;
                         write!(f, ">")?;
                     } else {
@@ -1219,7 +1219,7 @@ pub(crate) fn print_params(params: &[clean::Parameter], cx: &Context<'_>) -> imp
             .map(|param| {
                 fmt::from_fn(|f| {
                     if let Some(name) = param.name {
-                        write!(f, "{}: ", name)?;
+                        write!(f, "{name}: ")?;
                     }
                     param.type_.print(cx).fmt(f)
                 })
@@ -1341,7 +1341,7 @@ impl clean::FnDecl {
                     write!(f, "const ")?;
                 }
                 if let Some(name) = param.name {
-                    write!(f, "{}: ", name)?;
+                    write!(f, "{name}: ")?;
                 }
                 param.type_.print(cx).fmt(f)?;
             }
diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index b2feee36c93..272180fb990 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -547,7 +547,7 @@ impl<'a> Iterator for TokenIter<'a> {
 fn get_real_ident_class(text: &str, allow_path_keywords: bool) -> Option<Class> {
     let ignore: &[&str] =
         if allow_path_keywords { &["self", "Self", "super", "crate"] } else { &["self", "Self"] };
-    if ignore.iter().any(|k| *k == text) {
+    if ignore.contains(&text) {
         return None;
     }
     Some(match text {
@@ -1159,7 +1159,7 @@ fn string_without_closing_tag<T: Display>(
         return Some("</a>");
     }
     if !open_tag {
-        write!(out, "{}", text_s).unwrap();
+        out.write_str(&text_s).unwrap();
         return None;
     }
     let klass_s = klass.as_html();
diff --git a/src/librustdoc/html/layout.rs b/src/librustdoc/html/layout.rs
index 50320cb231d..1f92c521d46 100644
--- a/src/librustdoc/html/layout.rs
+++ b/src/librustdoc/html/layout.rs
@@ -132,6 +132,5 @@ pub(crate) fn redirect(url: &str) -> String {
     <script>location.replace("{url}" + location.search + location.hash);</script>
 </body>
 </html>"##,
-        url = url,
     )
 }
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index e41435de29c..4addf2c3c96 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -251,7 +251,7 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
                     if !parse_result.rust {
                         let added_classes = parse_result.added_classes;
                         let lang_string = if let Some(lang) = parse_result.unknown.first() {
-                            format!("language-{}", lang)
+                            format!("language-{lang}")
                         } else {
                             String::new()
                         };
@@ -999,7 +999,7 @@ impl<'a, 'tcx> TagIterator<'a, 'tcx> {
 
         if let Some((_, c)) = self.inner.next() {
             if c != '=' {
-                self.emit_error(format!("expected `=`, found `{}`", c));
+                self.emit_error(format!("expected `=`, found `{c}`"));
                 return None;
             }
         } else {
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
index 7b814701a73..5ceb1fc988d 100644
--- a/src/librustdoc/html/render/context.rs
+++ b/src/librustdoc/html/render/context.rs
@@ -193,14 +193,12 @@ impl<'tcx> Context<'tcx> {
         if it.is_stripped()
             && let Some(def_id) = it.def_id()
             && def_id.is_local()
+            && (self.info.is_inside_inlined_module
+                || self.shared.cache.inlined_items.contains(&def_id))
         {
-            if self.info.is_inside_inlined_module
-                || self.shared.cache.inlined_items.contains(&def_id)
-            {
-                // For now we're forced to generate a redirect page for stripped items until
-                // `record_extern_fqn` correctly points to external items.
-                render_redirect_pages = true;
-            }
+            // For now we're forced to generate a redirect page for stripped items until
+            // `record_extern_fqn` correctly points to external items.
+            render_redirect_pages = true;
         }
         let mut title = String::new();
         if !is_module {
@@ -254,40 +252,36 @@ impl<'tcx> Context<'tcx> {
                 &self.shared.style_files,
             )
         } else {
-            if let Some(&(ref names, ty)) = self.cache().paths.get(&it.item_id.expect_def_id()) {
-                if self.current.len() + 1 != names.len()
-                    || self.current.iter().zip(names.iter()).any(|(a, b)| a != b)
-                {
-                    // We checked that the redirection isn't pointing to the current file,
-                    // preventing an infinite redirection loop in the generated
-                    // documentation.
-
-                    let path = fmt::from_fn(|f| {
-                        for name in &names[..names.len() - 1] {
-                            write!(f, "{name}/")?;
-                        }
-                        write!(f, "{}", print_item_path(ty, names.last().unwrap().as_str()))
-                    });
-                    match self.shared.redirections {
-                        Some(ref redirections) => {
-                            let mut current_path = String::new();
-                            for name in &self.current {
-                                current_path.push_str(name.as_str());
-                                current_path.push('/');
-                            }
-                            let _ = write!(
-                                current_path,
-                                "{}",
-                                print_item_path(ty, names.last().unwrap().as_str())
-                            );
-                            redirections.borrow_mut().insert(current_path, path.to_string());
-                        }
-                        None => {
-                            return layout::redirect(&format!(
-                                "{root}{path}",
-                                root = self.root_path()
-                            ));
+            if let Some(&(ref names, ty)) = self.cache().paths.get(&it.item_id.expect_def_id())
+                && (self.current.len() + 1 != names.len()
+                    || self.current.iter().zip(names.iter()).any(|(a, b)| a != b))
+            {
+                // We checked that the redirection isn't pointing to the current file,
+                // preventing an infinite redirection loop in the generated
+                // documentation.
+
+                let path = fmt::from_fn(|f| {
+                    for name in &names[..names.len() - 1] {
+                        write!(f, "{name}/")?;
+                    }
+                    write!(f, "{}", print_item_path(ty, names.last().unwrap().as_str()))
+                });
+                match self.shared.redirections {
+                    Some(ref redirections) => {
+                        let mut current_path = String::new();
+                        for name in &self.current {
+                            current_path.push_str(name.as_str());
+                            current_path.push('/');
                         }
+                        let _ = write!(
+                            current_path,
+                            "{}",
+                            print_item_path(ty, names.last().unwrap().as_str())
+                        );
+                        redirections.borrow_mut().insert(current_path, path.to_string());
+                    }
+                    None => {
+                        return layout::redirect(&format!("{root}{path}", root = self.root_path()));
                     }
                 }
             }
@@ -762,11 +756,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
         // Flush pending errors.
         self.shared.fs.close();
         let nb_errors = self.shared.errors.iter().map(|err| self.tcx().dcx().err(err)).count();
-        if nb_errors > 0 {
-            Err(Error::new(io::Error::new(io::ErrorKind::Other, "I/O error"), ""))
-        } else {
-            Ok(())
-        }
+        if nb_errors > 0 { Err(Error::new(io::Error::other("I/O error"), "")) } else { Ok(()) }
     }
 
     fn mod_item_in(&mut self, item: &clean::Item) -> Result<(), Error> {
@@ -842,7 +832,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
             self.info.render_redirect_pages = item.is_stripped();
         }
 
-        let buf = self.render_item(&item, false);
+        let buf = self.render_item(item, false);
         // buf will be empty if the item is stripped and there is no redirect for it
         if !buf.is_empty() {
             let name = item.name.as_ref().unwrap();
@@ -853,7 +843,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
             self.shared.fs.write(joint_dst, buf)?;
 
             if !self.info.render_redirect_pages {
-                self.shared.all.borrow_mut().append(full_path(self, &item), &item_type);
+                self.shared.all.borrow_mut().append(full_path(self, item), &item_type);
             }
             // If the item is a macro, redirect from the old macro URL (with !)
             // to the new one (without).
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 2cfc9af39e4..872dbbcd19e 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -1483,10 +1483,10 @@ fn render_deref_methods(
             }
         }
         render_assoc_items_inner(&mut w, cx, container_item, did, what, derefs);
-    } else if let Some(prim) = target.primitive_type() {
-        if let Some(&did) = cache.primitive_locations.get(&prim) {
-            render_assoc_items_inner(&mut w, cx, container_item, did, what, derefs);
-        }
+    } else if let Some(prim) = target.primitive_type()
+        && let Some(&did) = cache.primitive_locations.get(&prim)
+    {
+        render_assoc_items_inner(&mut w, cx, container_item, did, what, derefs);
     }
 }
 
@@ -2058,21 +2058,20 @@ fn render_impl(
         // default items which weren't overridden in the implementation block.
         // We don't emit documentation for default items if they appear in the
         // Implementations on Foreign Types or Implementors sections.
-        if rendering_params.show_default_items {
-            if let Some(t) = trait_
-                && !impl_.is_negative_trait_impl()
-            {
-                render_default_items(
-                    &mut default_impl_items,
-                    &mut impl_items,
-                    cx,
-                    t,
-                    impl_,
-                    &i.impl_item,
-                    render_mode,
-                    rendering_params,
-                )?;
-            }
+        if rendering_params.show_default_items
+            && let Some(t) = trait_
+            && !impl_.is_negative_trait_impl()
+        {
+            render_default_items(
+                &mut default_impl_items,
+                &mut impl_items,
+                cx,
+                t,
+                impl_,
+                &i.impl_item,
+                render_mode,
+                rendering_params,
+            )?;
         }
         if render_mode == RenderMode::Normal {
             let toggled = !(impl_items.is_empty() && default_impl_items.is_empty());
@@ -2570,7 +2569,7 @@ fn collect_paths_for_type(first_ty: &clean::Type, cache: &Cache) -> Vec<String>
         match ty {
             clean::Type::Path { path } => process_path(path.def_id()),
             clean::Type::Tuple(tys) => {
-                work.extend(tys.into_iter());
+                work.extend(tys.iter());
             }
             clean::Type::Slice(ty) => {
                 work.push_back(ty);
diff --git a/src/librustdoc/html/render/ordered_json.rs b/src/librustdoc/html/render/ordered_json.rs
index d1dddfebc83..be51dad1c2b 100644
--- a/src/librustdoc/html/render/ordered_json.rs
+++ b/src/librustdoc/html/render/ordered_json.rs
@@ -25,7 +25,7 @@ impl OrderedJson {
             .into_iter()
             .sorted_unstable_by(|a, b| a.borrow().cmp(b.borrow()))
             .format_with(",", |item, f| f(item.borrow()));
-        Self(format!("[{}]", items))
+        Self(format!("[{items}]"))
     }
 
     pub(crate) fn array_unsorted<T: Borrow<Self>, I: IntoIterator<Item = T>>(items: I) -> Self {
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index 5fbda4797cc..02ee34aaac6 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -1451,7 +1451,7 @@ item_template!(
 
 impl<'a, 'cx: 'a> ItemUnion<'a, 'cx> {
     fn render_union(&self) -> impl Display {
-        render_union(self.it, Some(&self.generics), &self.fields, self.cx)
+        render_union(self.it, Some(self.generics), self.fields, self.cx)
     }
 
     fn document_field(&self, field: &'a clean::Item) -> impl Display {
@@ -1982,16 +1982,14 @@ fn item_constant(
                 w.write_str(";")?;
             }
 
-            if !is_literal {
-                if let Some(value) = &value {
-                    let value_lowercase = value.to_lowercase();
-                    let expr_lowercase = expr.to_lowercase();
+            if !is_literal && let Some(value) = &value {
+                let value_lowercase = value.to_lowercase();
+                let expr_lowercase = expr.to_lowercase();
 
-                    if value_lowercase != expr_lowercase
-                        && value_lowercase.trim_end_matches("i32") != expr_lowercase
-                    {
-                        write!(w, " // {value}", value = Escape(value))?;
-                    }
+                if value_lowercase != expr_lowercase
+                    && value_lowercase.trim_end_matches("i32") != expr_lowercase
+                {
+                    write!(w, " // {value}", value = Escape(value))?;
                 }
             }
             Ok::<(), fmt::Error>(())
@@ -2071,41 +2069,39 @@ fn item_fields(
                 _ => None,
             })
             .peekable();
-        if let None | Some(CtorKind::Fn) = ctor_kind {
-            if fields.peek().is_some() {
-                let title = format!(
-                    "{}{}",
-                    if ctor_kind.is_none() { "Fields" } else { "Tuple Fields" },
-                    document_non_exhaustive_header(it),
-                );
+        if let None | Some(CtorKind::Fn) = ctor_kind
+            && fields.peek().is_some()
+        {
+            let title = format!(
+                "{}{}",
+                if ctor_kind.is_none() { "Fields" } else { "Tuple Fields" },
+                document_non_exhaustive_header(it),
+            );
+            write!(
+                w,
+                "{}",
+                write_section_heading(
+                    &title,
+                    "fields",
+                    Some("fields"),
+                    document_non_exhaustive(it)
+                )
+            )?;
+            for (index, (field, ty)) in fields.enumerate() {
+                let field_name =
+                    field.name.map_or_else(|| index.to_string(), |sym| sym.as_str().to_string());
+                let id = cx.derive_id(format!("{typ}.{field_name}", typ = ItemType::StructField));
                 write!(
                     w,
-                    "{}",
-                    write_section_heading(
-                        &title,
-                        "fields",
-                        Some("fields"),
-                        document_non_exhaustive(it)
-                    )
+                    "<span id=\"{id}\" class=\"{item_type} section-header\">\
+                        <a href=\"#{id}\" class=\"anchor field\">§</a>\
+                        <code>{field_name}: {ty}</code>\
+                    </span>\
+                    {doc}",
+                    item_type = ItemType::StructField,
+                    ty = ty.print(cx),
+                    doc = document(cx, field, Some(it), HeadingOffset::H3),
                 )?;
-                for (index, (field, ty)) in fields.enumerate() {
-                    let field_name = field
-                        .name
-                        .map_or_else(|| index.to_string(), |sym| sym.as_str().to_string());
-                    let id =
-                        cx.derive_id(format!("{typ}.{field_name}", typ = ItemType::StructField));
-                    write!(
-                        w,
-                        "<span id=\"{id}\" class=\"{item_type} section-header\">\
-                            <a href=\"#{id}\" class=\"anchor field\">§</a>\
-                            <code>{field_name}: {ty}</code>\
-                        </span>\
-                        {doc}",
-                        item_type = ItemType::StructField,
-                        ty = ty.print(cx),
-                        doc = document(cx, field, Some(it), HeadingOffset::H3),
-                    )?;
-                }
             }
         }
         Ok(())
diff --git a/src/librustdoc/html/render/sidebar.rs b/src/librustdoc/html/render/sidebar.rs
index 91540e06e33..b9f5ada417c 100644
--- a/src/librustdoc/html/render/sidebar.rs
+++ b/src/librustdoc/html/render/sidebar.rs
@@ -541,7 +541,7 @@ fn sidebar_deref_methods<'a>(
                 .iter()
                 .filter(|i| {
                     i.inner_impl().trait_.is_none()
-                        && real_target.is_doc_subtype_of(&i.inner_impl().for_, &c)
+                        && real_target.is_doc_subtype_of(&i.inner_impl().for_, c)
                 })
                 .flat_map(|i| get_methods(i.inner_impl(), true, used_links, deref_mut, cx.tcx()))
                 .collect::<Vec<_>>();
diff --git a/src/librustdoc/html/render/sorted_template.rs b/src/librustdoc/html/render/sorted_template.rs
index a7b954ab70b..659c5e6093b 100644
--- a/src/librustdoc/html/render/sorted_template.rs
+++ b/src/librustdoc/html/render/sorted_template.rs
@@ -63,7 +63,8 @@ impl<F: FileFormat> fmt::Display for SortedTemplate<F> {
         for (p, fragment) in self.fragments.iter().with_position() {
             let mut f = DeltaWriter { inner: &mut f, delta: 0 };
             let sep = if matches!(p, Position::First | Position::Only) { "" } else { F::SEPARATOR };
-            write!(f, "{}{}", sep, fragment)?;
+            f.write_str(sep)?;
+            f.write_str(fragment)?;
             fragment_lengths.push(f.delta);
         }
         let offset = Offset { start: self.before.len(), fragment_lengths };
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index 0a84d8caa30..08bc0bb1950 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -50,7 +50,7 @@ impl JsonRenderer<'_> {
         let span = item.span(self.tcx);
         let visibility = item.visibility(self.tcx);
         let clean::ItemInner { name, item_id, .. } = *item.inner;
-        let id = self.id_from_item(&item);
+        let id = self.id_from_item(item);
         let inner = match item.kind {
             clean::KeywordItem => return None,
             clean::StrippedItem(ref inner) => {
@@ -86,14 +86,14 @@ impl JsonRenderer<'_> {
         items
             .iter()
             .filter(|i| !i.is_stripped() && !i.is_keyword())
-            .map(|i| self.id_from_item(&i))
+            .map(|i| self.id_from_item(i))
             .collect()
     }
 
     fn ids_keeping_stripped(&self, items: &[clean::Item]) -> Vec<Option<Id>> {
         items
             .iter()
-            .map(|i| (!i.is_stripped() && !i.is_keyword()).then(|| self.id_from_item(&i)))
+            .map(|i| (!i.is_stripped() && !i.is_keyword()).then(|| self.id_from_item(i)))
             .collect()
     }
 }
@@ -358,12 +358,12 @@ impl FromClean<clean::Struct> for Struct {
         let clean::Struct { ctor_kind, generics, fields } = struct_;
 
         let kind = match ctor_kind {
-            Some(CtorKind::Fn) => StructKind::Tuple(renderer.ids_keeping_stripped(&fields)),
+            Some(CtorKind::Fn) => StructKind::Tuple(renderer.ids_keeping_stripped(fields)),
             Some(CtorKind::Const) => {
                 assert!(fields.is_empty());
                 StructKind::Unit
             }
-            None => StructKind::Plain { fields: renderer.ids(&fields), has_stripped_fields },
+            None => StructKind::Plain { fields: renderer.ids(fields), has_stripped_fields },
         };
 
         Struct {
@@ -381,7 +381,7 @@ impl FromClean<clean::Union> for Union {
         Union {
             generics: generics.into_json(renderer),
             has_stripped_fields,
-            fields: renderer.ids(&fields),
+            fields: renderer.ids(fields),
             impls: Vec::new(), // Added in JsonRenderer::item
         }
     }
@@ -659,7 +659,7 @@ impl FromClean<clean::FnDecl> for FunctionSignature {
         let clean::FnDecl { inputs, output, c_variadic } = decl;
         FunctionSignature {
             inputs: inputs
-                .into_iter()
+                .iter()
                 .map(|param| {
                     // `_` is the most sensible name for missing param names.
                     let name = param.name.unwrap_or(kw::Underscore).to_string();
@@ -684,7 +684,7 @@ impl FromClean<clean::Trait> for Trait {
             is_auto,
             is_unsafe,
             is_dyn_compatible,
-            items: renderer.ids(&items),
+            items: renderer.ids(items),
             generics: generics.into_json(renderer),
             bounds: bounds.into_json(renderer),
             implementations: Vec::new(), // Added in JsonRenderer::item
@@ -727,7 +727,7 @@ impl FromClean<clean::Impl> for Impl {
                 .collect(),
             trait_: trait_.into_json(renderer),
             for_: for_.into_json(renderer),
-            items: renderer.ids(&items),
+            items: renderer.ids(items),
             is_negative,
             is_synthetic,
             blanket_impl: blanket_impl.map(|x| x.into_json(renderer)),
@@ -770,7 +770,7 @@ impl FromClean<clean::Variant> for Variant {
 
         let kind = match &variant.kind {
             CLike => VariantKind::Plain,
-            Tuple(fields) => VariantKind::Tuple(renderer.ids_keeping_stripped(&fields)),
+            Tuple(fields) => VariantKind::Tuple(renderer.ids_keeping_stripped(fields)),
             Struct(s) => VariantKind::Struct {
                 has_stripped_fields: s.has_stripped_entries(),
                 fields: renderer.ids(&s.fields),
diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs
index 600a4b429f3..760e48baffa 100644
--- a/src/librustdoc/json/mod.rs
+++ b/src/librustdoc/json/mod.rs
@@ -133,7 +133,7 @@ fn target(sess: &rustc_session::Session) -> types::Target {
     let feature_stability: FxHashMap<&str, Stability> = sess
         .target
         .rust_target_features()
-        .into_iter()
+        .iter()
         .copied()
         .map(|(name, stability, _)| (name, stability))
         .collect();
@@ -143,7 +143,7 @@ fn target(sess: &rustc_session::Session) -> types::Target {
         target_features: sess
             .target
             .rust_target_features()
-            .into_iter()
+            .iter()
             .copied()
             .filter(|(_, stability, _)| {
                 // Describe only target features which the user can toggle
@@ -157,7 +157,7 @@ fn target(sess: &rustc_session::Session) -> types::Target {
                         _ => None,
                     },
                     implies_features: implied_features
-                        .into_iter()
+                        .iter()
                         .copied()
                         .filter(|name| {
                             // Imply only target features which the user can toggle
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index ca6f67eb6df..5a9aa2a94c8 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -274,7 +274,7 @@ impl From<DiagnosticInfo<'_>> for OwnedDiagnosticInfo {
 }
 
 impl OwnedDiagnosticInfo {
-    pub(crate) fn into_info(&self) -> DiagnosticInfo<'_> {
+    pub(crate) fn as_info(&self) -> DiagnosticInfo<'_> {
         DiagnosticInfo {
             item: &self.item,
             ori_link: &self.ori_link,
@@ -1177,7 +1177,7 @@ impl LinkCollector<'_, '_> {
                     // Primitive types are always valid.
                     Res::Primitive(_) => true,
                 });
-                let diag_info = info.diag_info.into_info();
+                let diag_info = info.diag_info.as_info();
                 match info.resolved.len() {
                     1 => {
                         let (res, fragment) = info.resolved.pop().unwrap();
@@ -1243,17 +1243,16 @@ impl LinkCollector<'_, '_> {
             disambiguator,
             None | Some(Disambiguator::Namespace(Namespace::TypeNS) | Disambiguator::Primitive)
         ) && !matches!(res, Res::Primitive(_))
+            && let Some(prim) = resolve_primitive(path_str, TypeNS)
         {
-            if let Some(prim) = resolve_primitive(path_str, TypeNS) {
-                // `prim@char`
-                if matches!(disambiguator, Some(Disambiguator::Primitive)) {
-                    res = prim;
-                } else {
-                    // `[char]` when a `char` module is in scope
-                    let candidates = &[(res, res.def_id(self.cx.tcx)), (prim, None)];
-                    ambiguity_error(self.cx, &diag_info, path_str, candidates, true);
-                    return None;
-                }
+            // `prim@char`
+            if matches!(disambiguator, Some(Disambiguator::Primitive)) {
+                res = prim;
+            } else {
+                // `[char]` when a `char` module is in scope
+                let candidates = &[(res, res.def_id(self.cx.tcx)), (prim, None)];
+                ambiguity_error(self.cx, &diag_info, path_str, candidates, true);
+                return None;
             }
         }
 
@@ -2233,7 +2232,7 @@ fn ambiguity_error(
     // proc macro can exist in multiple namespaces at once, so we need to compare `DefIds`
     //  to remove the candidate in the fn namespace.
     let mut possible_proc_macro_id = None;
-    let is_proc_macro_crate = cx.tcx.crate_types() == &[CrateType::ProcMacro];
+    let is_proc_macro_crate = cx.tcx.crate_types() == [CrateType::ProcMacro];
     let mut kinds = candidates
         .iter()
         .map(|(res, def_id)| {
diff --git a/src/librustdoc/passes/lint/redundant_explicit_links.rs b/src/librustdoc/passes/lint/redundant_explicit_links.rs
index 5757b6a9740..e69cf87f957 100644
--- a/src/librustdoc/passes/lint/redundant_explicit_links.rs
+++ b/src/librustdoc/passes/lint/redundant_explicit_links.rs
@@ -93,14 +93,14 @@ fn check_redundant_explicit_link<'md>(
         if let Event::Start(Tag::Link { link_type, dest_url, .. }) = event {
             let link_data = collect_link_data(&mut offset_iter);
 
-            if let Some(resolvable_link) = link_data.resolvable_link.as_ref() {
-                if &link_data.display_link.replace('`', "") != resolvable_link {
-                    // Skips if display link does not match to actual
-                    // resolvable link, usually happens if display link
-                    // has several segments, e.g.
-                    // [this is just an `Option`](Option)
-                    continue;
-                }
+            if let Some(resolvable_link) = link_data.resolvable_link.as_ref()
+                && &link_data.display_link.replace('`', "") != resolvable_link
+            {
+                // Skips if display link does not match to actual
+                // resolvable link, usually happens if display link
+                // has several segments, e.g.
+                // [this is just an `Option`](Option)
+                continue;
             }
 
             let explicit_link = dest_url.to_string();
diff --git a/src/librustdoc/passes/strip_aliased_non_local.rs b/src/librustdoc/passes/strip_aliased_non_local.rs
index b53e3b4e3d7..bb13308e6c2 100644
--- a/src/librustdoc/passes/strip_aliased_non_local.rs
+++ b/src/librustdoc/passes/strip_aliased_non_local.rs
@@ -47,13 +47,11 @@ impl DocFolder for NonLocalStripper<'_> {
         // FIXME(#125009): Not-local should probably consider same Cargo workspace
         if let Some(def_id) = i.def_id()
             && !def_id.is_local()
-        {
-            if i.is_doc_hidden()
+            && (i.is_doc_hidden()
                 // Default to *not* stripping items with inherited visibility.
-                || i.visibility(self.tcx).is_some_and(|viz| viz != Visibility::Public)
-            {
-                return Some(strip_item(i));
-            }
+                || i.visibility(self.tcx).is_some_and(|viz| viz != Visibility::Public))
+        {
+            return Some(strip_item(i));
         }
 
         Some(self.fold_item_recur(i))
-- 
cgit 1.4.1-3-g733a5


From 4ef92bec5abae8cce07e587bdd6f116cfa065873 Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Sat, 19 Jul 2025 15:17:04 +0000
Subject: fix load-bearing typo

---
 library/coretests/tests/iter/adapters/zip.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/coretests/tests/iter/adapters/zip.rs b/library/coretests/tests/iter/adapters/zip.rs
index 83279380175..063e226a61c 100644
--- a/library/coretests/tests/iter/adapters/zip.rs
+++ b/library/coretests/tests/iter/adapters/zip.rs
@@ -273,7 +273,7 @@ fn test_double_ended_zip() {
 
 #[test]
 #[cfg(panic = "unwind")]
-/// Regresion test for #137255
+/// Regression test for #137255
 /// A previous implementation of Zip TrustedRandomAccess specializations tried to do a lot of work
 /// to preserve side-effects of equalizing the iterator lengths during backwards iteration.
 /// This lead to several cases of unsoundness, twice due to being left in an inconsistent state
-- 
cgit 1.4.1-3-g733a5


From e1d4f2a0c297690ddfc24815de57539f532f2471 Mon Sep 17 00:00:00 2001
From: Martin Nordholts <martin.nordholts@codetale.se>
Date: Wed, 25 Jun 2025 07:56:40 +0200
Subject: tests: Require `run-fail` ui tests to have an exit code (`SIGABRT`
 not ok)

And introduce two new directives for ui tests:
* `run-crash`
* `run-fail-or-crash`

Normally a `run-fail` ui test like tests that panic shall not be
terminated by a signal like `SIGABRT`. So begin having that as a hard
requirement.

Some of our current tests do terminate by a signal/crash however.
Introduce and use `run-crash` for those tests. Note that Windows crashes
are not handled by signals but by certain high bits set on the process
exit code. Example exit code for crash on Windows: `0xc000001d`.
Because of this, we define "crash" on all platforms as "not exit with
success and not exit with a regular failure code in the range 1..=127".

Some tests behave differently on different targets:
* Targets without unwind support will abort (crash) instead of exit with
  failure code 101 after panicking. As a special case, allow crashes for
  `run-fail` tests for such targets.
* Different sanitizer implementations handle detected memory problems
  differently. Some abort (crash) the process while others exit with
  failure code 1. Introduce and use `run-fail-or-crash` for such tests.
---
 src/doc/rustc-dev-guide/src/tests/directives.md    |  6 ++-
 src/doc/rustc-dev-guide/src/tests/ui.md            | 20 ++++++--
 src/tools/compiletest/src/common.rs                | 28 +++++++++++-
 src/tools/compiletest/src/directives.rs            | 12 ++++-
 src/tools/compiletest/src/runtest.rs               |  7 +--
 src/tools/compiletest/src/runtest/ui.rs            | 53 +++++++++++++++++++---
 tests/ui/contracts/contract-attributes-generics.rs |  6 +--
 tests/ui/contracts/contract-attributes-nest.rs     |  4 +-
 tests/ui/contracts/contract-attributes-tail.rs     |  4 +-
 .../contract-captures-via-closure-copy.rs          |  2 +-
 tests/ui/contracts/contract-const-fn.rs            |  4 +-
 .../contracts/contracts-ensures-early-fn-exit.rs   |  6 +--
 .../contract-ast-extensions-nest.rs                |  4 +-
 .../contract-ast-extensions-tail.rs                |  4 +-
 .../internal_machinery/contract-intrinsics.rs      |  4 +-
 .../internal_machinery/contract-lang-items.rs      |  2 +-
 tests/ui/extern/extern-types-field-offset.rs       |  2 +-
 .../borrow_misaligned_field_projection.rs          |  2 +-
 tests/ui/mir/alignment/misaligned_borrow.rs        |  2 +-
 tests/ui/mir/alignment/misaligned_lhs.rs           |  2 +-
 tests/ui/mir/alignment/misaligned_mut_borrow.rs    |  2 +-
 tests/ui/mir/alignment/misaligned_rhs.rs           |  2 +-
 tests/ui/mir/alignment/two_pointers.rs             |  2 +-
 tests/ui/mir/enum/convert_non_integer_break.rs     |  2 +-
 .../ui/mir/enum/convert_non_integer_niche_break.rs |  2 +-
 tests/ui/mir/enum/negative_discr_break.rs          |  2 +-
 tests/ui/mir/enum/niche_option_tuple_break.rs      |  2 +-
 tests/ui/mir/enum/numbered_variants_break.rs       |  2 +-
 .../ui/mir/enum/option_with_bigger_niche_break.rs  |  2 +-
 tests/ui/mir/enum/plain_no_data_break.rs           |  2 +-
 tests/ui/mir/enum/single_with_repr_break.rs        |  2 +-
 tests/ui/mir/enum/with_niche_int_break.rs          |  2 +-
 tests/ui/mir/enum/wrap_break.rs                    |  2 +-
 tests/ui/mir/null/borrowed_mut_null.rs             |  2 +-
 tests/ui/mir/null/borrowed_null.rs                 |  2 +-
 tests/ui/mir/null/borrowed_null_zst.rs             |  2 +-
 tests/ui/mir/null/null_lhs.rs                      |  2 +-
 tests/ui/mir/null/null_rhs.rs                      |  2 +-
 tests/ui/mir/null/two_pointers.rs                  |  2 +-
 tests/ui/panics/panic-in-cleanup.rs                |  2 +-
 tests/ui/panics/panic-in-ffi.rs                    |  2 +-
 tests/ui/panics/panic-in-message-fmt.rs            |  2 +-
 tests/ui/panics/panic-main.rs                      |  9 +++-
 tests/ui/precondition-checks/alignment.rs          |  2 +-
 .../ascii-char-digit_unchecked.rs                  |  2 +-
 tests/ui/precondition-checks/assert_unchecked.rs   |  2 +-
 .../precondition-checks/char-from_u32_unchecked.rs |  2 +-
 .../ui/precondition-checks/copy-nonoverlapping.rs  |  2 +-
 tests/ui/precondition-checks/copy.rs               |  2 +-
 tests/ui/precondition-checks/layout.rs             |  2 +-
 tests/ui/precondition-checks/nonnull.rs            |  2 +-
 .../nonzero-from_mut_unchecked.rs                  |  2 +-
 .../precondition-checks/nonzero-new_unchecked.rs   |  2 +-
 tests/ui/precondition-checks/read_volatile.rs      |  2 +-
 tests/ui/precondition-checks/replace.rs            |  2 +-
 .../slice-from-raw-parts-mut.rs                    |  2 +-
 .../ui/precondition-checks/slice-from-raw-parts.rs |  2 +-
 .../ui/precondition-checks/slice-get_unchecked.rs  |  2 +-
 .../precondition-checks/slice-get_unchecked_mut.rs |  2 +-
 tests/ui/precondition-checks/str-get_unchecked.rs  |  2 +-
 .../precondition-checks/str-get_unchecked_mut.rs   |  2 +-
 .../ui/precondition-checks/swap-nonoverlapping.rs  |  2 +-
 tests/ui/precondition-checks/unchecked_add.rs      |  2 +-
 tests/ui/precondition-checks/unchecked_mul.rs      |  2 +-
 tests/ui/precondition-checks/unchecked_shl.rs      |  2 +-
 tests/ui/precondition-checks/unchecked_shr.rs      |  2 +-
 tests/ui/precondition-checks/unchecked_sub.rs      |  2 +-
 .../precondition-checks/unreachable_unchecked.rs   |  2 +-
 tests/ui/precondition-checks/vec-from-parts.rs     |  2 +-
 tests/ui/precondition-checks/vec-from-raw-parts.rs |  2 +-
 tests/ui/precondition-checks/vec-set-len.rs        |  2 +-
 tests/ui/precondition-checks/write_volatile.rs     |  2 +-
 tests/ui/sanitizer/address.rs                      |  2 +-
 tests/ui/sanitizer/badfree.rs                      |  2 +-
 .../ui/sanitizer/new-llvm-pass-manager-thin-lto.rs |  2 +-
 tests/ui/sanitizer/thread.rs                       |  2 +-
 tests/ui/sanitizer/use-after-scope.rs              |  2 +-
 tests/ui/std/issue-81357-unsound-file-methods.rs   |  2 +-
 78 files changed, 196 insertions(+), 101 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index 63aa08c389c..6685add461e 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -75,8 +75,10 @@ expectations](ui.md#controlling-passfail-expectations).
 | `check-fail`                | Building (no codegen) should fail           | `ui`, `crashes`                           | N/A             |
 | `build-pass`                | Building should pass                        | `ui`, `crashes`, `codegen`, `incremental` | N/A             |
 | `build-fail`                | Building should fail                        | `ui`, `crashes`                           | N/A             |
-| `run-pass`                  | Running the test binary should pass         | `ui`, `crashes`, `incremental`            | N/A             |
-| `run-fail`                  | Running the test binary should fail         | `ui`, `crashes`                           | N/A             |
+| `run-pass`                  | Program must exit with code `0`             | `ui`, `crashes`, `incremental`            | N/A             |
+| `run-fail`                  | Program must exit with code `1..=127`       | `ui`, `crashes`                           | N/A             |
+| `run-crash`                 | Program must crash                          | `ui`                                      | N/A             |
+| `run-fail-or-crash`         | Program must `run-fail` or `run-crash`      | `ui`                                      | N/A             |
 | `ignore-pass`               | Ignore `--pass` flag                        | `ui`, `crashes`, `codegen`, `incremental` | N/A             |
 | `dont-check-failure-status` | Don't check exact failure status (i.e. `1`) | `ui`, `incremental`                       | N/A             |
 | `failure-status`            | Check                                       | `ui`, `crashes`                           | Any `u16`       |
diff --git a/src/doc/rustc-dev-guide/src/tests/ui.md b/src/doc/rustc-dev-guide/src/tests/ui.md
index 4fce5838b6e..9bfc60e08a6 100644
--- a/src/doc/rustc-dev-guide/src/tests/ui.md
+++ b/src/doc/rustc-dev-guide/src/tests/ui.md
@@ -448,7 +448,7 @@ even run the resulting program. Just add one of the following
   - `//@ build-pass` — compilation and linking should succeed but do
     not run the resulting binary.
   - `//@ run-pass` — compilation should succeed and running the resulting
-    binary should also succeed.
+    binary should make it exit with code 0 which indicates success.
 - Fail directives:
   - `//@ check-fail` — compilation should fail (the codegen phase is skipped).
     This is the default for UI tests.
@@ -457,10 +457,20 @@ even run the resulting program. Just add one of the following
     - First time is to ensure that the compile succeeds without the codegen phase
     - Second time is to ensure that the full compile fails
   - `//@ run-fail` — compilation should succeed, but running the resulting
-    binary should fail.
-
-For `run-pass` and `run-fail` tests, by default the output of the program itself
-is not checked.
+    binary should make it exit with a code in the range `1..=127` which
+    indicates regular failure. On targets without unwind support, crashes
+    are also accepted.
+  - `//@ run-crash` — compilation should succeed, but running the resulting
+    binary should fail with a crash. Crashing is defined as "not exiting with
+    a code in the range `0..=127`". Example on Linux: Termination by `SIGABRT`
+    or `SIGSEGV`. Example on Windows: Exiting with the code for
+    `STATUS_ILLEGAL_INSTRUCTION` (`0xC000001D`).
+  - `//@ run-fail-or-crash` — compilation should succeed, but running the
+    resulting binary should either `run-fail` or `run-crash`. Useful if a test
+    crashes on some targets but just fails on others.
+
+For `run-pass`. `run-fail`, `run-crash` and `run-fail-or-crash` tests, by
+default the output of the program itself is not checked.
 
 If you want to check the output of running the program, include the
 `check-run-results` directive. This will check for a `.run.stderr` and
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 33da1a25db1..c83070aaba7 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -88,11 +88,37 @@ string_enum! {
     }
 }
 
+string_enum! {
+    #[derive(Clone, Copy, PartialEq, Debug, Hash)]
+    pub enum RunResult {
+        Pass => "run-pass",
+        Fail => "run-fail",
+        Crash => "run-crash",
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
+pub enum RunFailMode {
+    /// Running the program must make it exit with a regular failure exit code
+    /// in the range `1..=127`. If the program is terminated by e.g. a signal
+    /// the test will fail.
+    Fail,
+    /// Running the program must result in a crash, e.g. by `SIGABRT` or
+    /// `SIGSEGV` on Unix or on Windows by having an appropriate NTSTATUS high
+    /// bit in the exit code.
+    Crash,
+    /// Running the program must either fail or crash. Useful for e.g. sanitizer
+    /// tests since some sanitizer implementations exit the process with code 1
+    /// to in the face of memory errors while others abort (crash) the process
+    /// in the face of memory errors.
+    FailOrCrash,
+}
+
 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
 pub enum FailMode {
     Check,
     Build,
-    Run,
+    Run(RunFailMode),
 }
 
 string_enum! {
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 93133ea0bfd..513716357f4 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -9,7 +9,7 @@ use camino::{Utf8Path, Utf8PathBuf};
 use semver::Version;
 use tracing::*;
 
-use crate::common::{Config, Debugger, FailMode, PassMode, TestMode};
+use crate::common::{Config, Debugger, FailMode, PassMode, RunFailMode, TestMode};
 use crate::debuggers::{extract_cdb_version, extract_gdb_version};
 use crate::directives::auxiliary::{AuxProps, parse_and_update_aux};
 use crate::directives::needs::CachedNeedsConditions;
@@ -654,7 +654,13 @@ impl TestProps {
             Some(FailMode::Build)
         } else if config.parse_name_directive(ln, "run-fail") {
             check_ui("run");
-            Some(FailMode::Run)
+            Some(FailMode::Run(RunFailMode::Fail))
+        } else if config.parse_name_directive(ln, "run-crash") {
+            check_ui("run");
+            Some(FailMode::Run(RunFailMode::Crash))
+        } else if config.parse_name_directive(ln, "run-fail-or-crash") {
+            check_ui("run");
+            Some(FailMode::Run(RunFailMode::FailOrCrash))
         } else {
             None
         };
@@ -1007,7 +1013,9 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "regex-error-pattern",
     "remap-src-base",
     "revisions",
+    "run-crash",
     "run-fail",
+    "run-fail-or-crash",
     "run-flags",
     "run-pass",
     "run-rustfix",
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index cb8f593c9df..f66d4f98f1f 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -16,8 +16,8 @@ use regex::{Captures, Regex};
 use tracing::*;
 
 use crate::common::{
-    CompareMode, Config, Debugger, FailMode, PassMode, TestMode, TestPaths, TestSuite,
-    UI_EXTENSIONS, UI_FIXED, UI_RUN_STDERR, UI_RUN_STDOUT, UI_STDERR, UI_STDOUT, UI_SVG,
+    CompareMode, Config, Debugger, FailMode, PassMode, RunFailMode, RunResult, TestMode, TestPaths,
+    TestSuite, UI_EXTENSIONS, UI_FIXED, UI_RUN_STDERR, UI_RUN_STDOUT, UI_STDERR, UI_STDOUT, UI_SVG,
     UI_WINDOWS_SVG, expected_output_path, incremental_dir, output_base_dir, output_base_name,
     output_testname_unique,
 };
@@ -282,7 +282,8 @@ impl<'test> TestCx<'test> {
     fn should_run(&self, pm: Option<PassMode>) -> WillExecute {
         let test_should_run = match self.config.mode {
             TestMode::Ui
-                if pm == Some(PassMode::Run) || self.props.fail_mode == Some(FailMode::Run) =>
+                if pm == Some(PassMode::Run)
+                    || matches!(self.props.fail_mode, Some(FailMode::Run(_))) =>
             {
                 true
             }
diff --git a/src/tools/compiletest/src/runtest/ui.rs b/src/tools/compiletest/src/runtest/ui.rs
index f6bc85cd051..0507c2600ae 100644
--- a/src/tools/compiletest/src/runtest/ui.rs
+++ b/src/tools/compiletest/src/runtest/ui.rs
@@ -6,8 +6,8 @@ use rustfix::{Filter, apply_suggestions, get_suggestions_from_json};
 use tracing::debug;
 
 use super::{
-    AllowUnused, Emit, FailMode, LinkToAux, PassMode, TargetLocation, TestCx, TestOutput,
-    Truncated, UI_FIXED, WillExecute,
+    AllowUnused, Emit, FailMode, LinkToAux, PassMode, RunFailMode, RunResult, TargetLocation,
+    TestCx, TestOutput, Truncated, UI_FIXED, WillExecute,
 };
 use crate::json;
 
@@ -140,12 +140,53 @@ impl TestCx<'_> {
                     &proc_res,
                 );
             }
+            let code = proc_res.status.code();
+            let run_result = if proc_res.status.success() {
+                RunResult::Pass
+            } else if code.is_some_and(|c| c >= 1 && c <= 127) {
+                RunResult::Fail
+            } else {
+                RunResult::Crash
+            };
+            // Help users understand why the test failed by including the actual
+            // exit code and actual run result in the failure message.
+            let pass_hint = format!("code={code:?} so test would pass with `{run_result}`");
             if self.should_run_successfully(pm) {
-                if !proc_res.status.success() {
-                    self.fatal_proc_rec("test run failed!", &proc_res);
+                if run_result != RunResult::Pass {
+                    self.fatal_proc_rec(
+                        &format!("test did not exit with success! {pass_hint}"),
+                        &proc_res,
+                    );
+                }
+            } else if self.props.fail_mode == Some(FailMode::Run(RunFailMode::Fail)) {
+                // If the test is marked as `run-fail` but do not support
+                // unwinding we allow it to crash, since a panic will trigger an
+                // abort (crash) instead of unwind (exit with code 101).
+                let crash_ok = !self.config.can_unwind();
+                if run_result != RunResult::Fail && !(crash_ok && run_result == RunResult::Crash) {
+                    let err = if crash_ok {
+                        format!(
+                            "test did not exit with failure or crash (`{}` can't unwind)! {pass_hint}",
+                            self.config.target
+                        )
+                    } else {
+                        format!("test did not exit with failure! {pass_hint}")
+                    };
+                    self.fatal_proc_rec(&err, &proc_res);
                 }
-            } else if proc_res.status.success() {
-                self.fatal_proc_rec("test run succeeded!", &proc_res);
+            } else if self.props.fail_mode == Some(FailMode::Run(RunFailMode::Crash)) {
+                if run_result != RunResult::Crash {
+                    self.fatal_proc_rec(&format!("test did not crash! {pass_hint}"), &proc_res);
+                }
+            } else if self.props.fail_mode == Some(FailMode::Run(RunFailMode::FailOrCrash)) {
+                if run_result != RunResult::Fail && run_result != RunResult::Crash {
+                    self.fatal_proc_rec(
+                        &format!("test did not exit with failure or crash! {pass_hint}"),
+                        &proc_res,
+                    );
+                }
+            } else {
+                unreachable!("run_ui_test() must not be called if the test should not run");
             }
 
             self.get_output(&proc_res)
diff --git a/tests/ui/contracts/contract-attributes-generics.rs b/tests/ui/contracts/contract-attributes-generics.rs
index fd79c6abedd..3763ce116f8 100644
--- a/tests/ui/contracts/contract-attributes-generics.rs
+++ b/tests/ui/contracts/contract-attributes-generics.rs
@@ -5,9 +5,9 @@
 //@ [unchk_pass] run-pass
 //@ [chk_pass] run-pass
 //
-//@ [chk_fail_pre] run-fail
-//@ [chk_fail_post] run-fail
-//@ [chk_const_fail] run-fail
+//@ [chk_fail_pre] run-crash
+//@ [chk_fail_post] run-crash
+//@ [chk_const_fail] run-crash
 //
 //@ [unchk_pass] compile-flags: -Zcontract-checks=no
 //
diff --git a/tests/ui/contracts/contract-attributes-nest.rs b/tests/ui/contracts/contract-attributes-nest.rs
index e1e61b88f28..d367687b84e 100644
--- a/tests/ui/contracts/contract-attributes-nest.rs
+++ b/tests/ui/contracts/contract-attributes-nest.rs
@@ -5,8 +5,8 @@
 //@ [unchk_fail_post] run-pass
 //@ [chk_pass] run-pass
 //
-//@ [chk_fail_pre] run-fail
-//@ [chk_fail_post] run-fail
+//@ [chk_fail_pre] run-crash
+//@ [chk_fail_post] run-crash
 //
 //@ [unchk_pass] compile-flags: -Zcontract-checks=no
 //@ [unchk_fail_pre] compile-flags: -Zcontract-checks=no
diff --git a/tests/ui/contracts/contract-attributes-tail.rs b/tests/ui/contracts/contract-attributes-tail.rs
index ce4a6be5b82..43edfe5e803 100644
--- a/tests/ui/contracts/contract-attributes-tail.rs
+++ b/tests/ui/contracts/contract-attributes-tail.rs
@@ -5,8 +5,8 @@
 //@ [unchk_fail_post] run-pass
 //@ [chk_pass] run-pass
 //
-//@ [chk_fail_pre] run-fail
-//@ [chk_fail_post] run-fail
+//@ [chk_fail_pre] run-crash
+//@ [chk_fail_post] run-crash
 //
 //@ [unchk_pass] compile-flags: -Zcontract-checks=no
 //@ [unchk_fail_pre] compile-flags: -Zcontract-checks=no
diff --git a/tests/ui/contracts/contract-captures-via-closure-copy.rs b/tests/ui/contracts/contract-captures-via-closure-copy.rs
index 32c6d2bf4fe..bc7e5b9b6f1 100644
--- a/tests/ui/contracts/contract-captures-via-closure-copy.rs
+++ b/tests/ui/contracts/contract-captures-via-closure-copy.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Zcontract-checks=yes
 
 #![feature(contracts)]
diff --git a/tests/ui/contracts/contract-const-fn.rs b/tests/ui/contracts/contract-const-fn.rs
index 733a06ae570..fe8dd37b1f5 100644
--- a/tests/ui/contracts/contract-const-fn.rs
+++ b/tests/ui/contracts/contract-const-fn.rs
@@ -8,8 +8,8 @@
 //
 //@ [all_pass] run-pass
 //
-//@ [runtime_fail_pre] run-fail
-//@ [runtime_fail_post] run-fail
+//@ [runtime_fail_pre] run-crash
+//@ [runtime_fail_post] run-crash
 //
 //@ [all_pass] compile-flags: -Zcontract-checks=yes
 //@ [runtime_fail_pre] compile-flags: -Zcontract-checks=yes
diff --git a/tests/ui/contracts/contracts-ensures-early-fn-exit.rs b/tests/ui/contracts/contracts-ensures-early-fn-exit.rs
index 034cead3b4e..44ae07d8c95 100644
--- a/tests/ui/contracts/contracts-ensures-early-fn-exit.rs
+++ b/tests/ui/contracts/contracts-ensures-early-fn-exit.rs
@@ -2,9 +2,9 @@
 //
 //@ [unchk_pass] run-pass
 //@ [chk_pass] run-pass
-//@ [chk_fail_try] run-fail
-//@ [chk_fail_ret] run-fail
-//@ [chk_fail_yeet] run-fail
+//@ [chk_fail_try] run-crash
+//@ [chk_fail_ret] run-crash
+//@ [chk_fail_yeet] run-crash
 //
 //@ [unchk_pass] compile-flags: -Zcontract-checks=no
 //@ [chk_pass] compile-flags: -Zcontract-checks=yes
diff --git a/tests/ui/contracts/internal_machinery/contract-ast-extensions-nest.rs b/tests/ui/contracts/internal_machinery/contract-ast-extensions-nest.rs
index 6d8cd3949ee..4da0480f8bc 100644
--- a/tests/ui/contracts/internal_machinery/contract-ast-extensions-nest.rs
+++ b/tests/ui/contracts/internal_machinery/contract-ast-extensions-nest.rs
@@ -5,8 +5,8 @@
 //@ [unchk_fail_post] run-pass
 //@ [chk_pass] run-pass
 //
-//@ [chk_fail_pre] run-fail
-//@ [chk_fail_post] run-fail
+//@ [chk_fail_pre] run-crash
+//@ [chk_fail_post] run-crash
 //
 //@ [unchk_pass] compile-flags: -Zcontract-checks=no
 //@ [unchk_fail_pre] compile-flags: -Zcontract-checks=no
diff --git a/tests/ui/contracts/internal_machinery/contract-ast-extensions-tail.rs b/tests/ui/contracts/internal_machinery/contract-ast-extensions-tail.rs
index 07ec26f921b..f3cf5ce082c 100644
--- a/tests/ui/contracts/internal_machinery/contract-ast-extensions-tail.rs
+++ b/tests/ui/contracts/internal_machinery/contract-ast-extensions-tail.rs
@@ -5,8 +5,8 @@
 //@ [unchk_fail_post] run-pass
 //@ [chk_pass] run-pass
 //
-//@ [chk_fail_pre] run-fail
-//@ [chk_fail_post] run-fail
+//@ [chk_fail_pre] run-crash
+//@ [chk_fail_post] run-crash
 //
 //@ [unchk_pass] compile-flags: -Zcontract-checks=no
 //@ [unchk_fail_pre] compile-flags: -Zcontract-checks=no
diff --git a/tests/ui/contracts/internal_machinery/contract-intrinsics.rs b/tests/ui/contracts/internal_machinery/contract-intrinsics.rs
index c62b8cca75a..6e613b53fc9 100644
--- a/tests/ui/contracts/internal_machinery/contract-intrinsics.rs
+++ b/tests/ui/contracts/internal_machinery/contract-intrinsics.rs
@@ -3,8 +3,8 @@
 //@ [default] run-pass
 //@ [unchk_pass] run-pass
 //@ [chk_pass] run-pass
-//@ [chk_fail_requires] run-fail
-//@ [chk_fail_ensures] run-fail
+//@ [chk_fail_requires] run-crash
+//@ [chk_fail_ensures] run-crash
 //
 //@ [unchk_pass] compile-flags: -Zcontract-checks=no
 //@ [chk_pass] compile-flags: -Zcontract-checks=yes
diff --git a/tests/ui/contracts/internal_machinery/contract-lang-items.rs b/tests/ui/contracts/internal_machinery/contract-lang-items.rs
index 73c59194531..ac72d233bf6 100644
--- a/tests/ui/contracts/internal_machinery/contract-lang-items.rs
+++ b/tests/ui/contracts/internal_machinery/contract-lang-items.rs
@@ -4,7 +4,7 @@
 //@ [unchk_fail_post] run-pass
 //@ [chk_pass] run-pass
 //
-//@ [chk_fail_post] run-fail
+//@ [chk_fail_post] run-crash
 //
 //@ [unchk_pass] compile-flags: -Zcontract-checks=no
 //@ [unchk_fail_post] compile-flags: -Zcontract-checks=no
diff --git a/tests/ui/extern/extern-types-field-offset.rs b/tests/ui/extern/extern-types-field-offset.rs
index 75f3eab3e27..035f063cd50 100644
--- a/tests/ui/extern/extern-types-field-offset.rs
+++ b/tests/ui/extern/extern-types-field-offset.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ check-run-results
 //@ exec-env:RUST_BACKTRACE=0
 //@ normalize-stderr: "(core/src/panicking\.rs):[0-9]+:[0-9]+" -> "$1:$$LINE:$$COL"
diff --git a/tests/ui/mir/alignment/borrow_misaligned_field_projection.rs b/tests/ui/mir/alignment/borrow_misaligned_field_projection.rs
index a22965ce1d8..6ba895f172d 100644
--- a/tests/ui/mir/alignment/borrow_misaligned_field_projection.rs
+++ b/tests/ui/mir/alignment/borrow_misaligned_field_projection.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ ignore-i686-pc-windows-msvc: #112480
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: misaligned pointer dereference: address must be a multiple of 0x4 but is
diff --git a/tests/ui/mir/alignment/misaligned_borrow.rs b/tests/ui/mir/alignment/misaligned_borrow.rs
index de8912c7038..60c21deaba5 100644
--- a/tests/ui/mir/alignment/misaligned_borrow.rs
+++ b/tests/ui/mir/alignment/misaligned_borrow.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ ignore-i686-pc-windows-msvc: #112480
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: misaligned pointer dereference: address must be a multiple of 0x4 but is
diff --git a/tests/ui/mir/alignment/misaligned_lhs.rs b/tests/ui/mir/alignment/misaligned_lhs.rs
index b169823bc08..e8ddb10fd9c 100644
--- a/tests/ui/mir/alignment/misaligned_lhs.rs
+++ b/tests/ui/mir/alignment/misaligned_lhs.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ ignore-i686-pc-windows-msvc: #112480
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: misaligned pointer dereference: address must be a multiple of 0x4 but is
diff --git a/tests/ui/mir/alignment/misaligned_mut_borrow.rs b/tests/ui/mir/alignment/misaligned_mut_borrow.rs
index bba20edecfd..c066cc0efcd 100644
--- a/tests/ui/mir/alignment/misaligned_mut_borrow.rs
+++ b/tests/ui/mir/alignment/misaligned_mut_borrow.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ ignore-i686-pc-windows-msvc: #112480
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: misaligned pointer dereference: address must be a multiple of 0x4 but is
diff --git a/tests/ui/mir/alignment/misaligned_rhs.rs b/tests/ui/mir/alignment/misaligned_rhs.rs
index 55da30a2fd7..6bdc39c9d91 100644
--- a/tests/ui/mir/alignment/misaligned_rhs.rs
+++ b/tests/ui/mir/alignment/misaligned_rhs.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ ignore-i686-pc-windows-msvc: #112480
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: misaligned pointer dereference: address must be a multiple of 0x4 but is
diff --git a/tests/ui/mir/alignment/two_pointers.rs b/tests/ui/mir/alignment/two_pointers.rs
index 198a1c9853d..fd8b2f543aa 100644
--- a/tests/ui/mir/alignment/two_pointers.rs
+++ b/tests/ui/mir/alignment/two_pointers.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ ignore-i686-pc-windows-msvc: #112480
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: misaligned pointer dereference: address must be a multiple of 0x4 but is
diff --git a/tests/ui/mir/enum/convert_non_integer_break.rs b/tests/ui/mir/enum/convert_non_integer_break.rs
index 29795190bf6..b0778e2024f 100644
--- a/tests/ui/mir/enum/convert_non_integer_break.rs
+++ b/tests/ui/mir/enum/convert_non_integer_break.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value
 
diff --git a/tests/ui/mir/enum/convert_non_integer_niche_break.rs b/tests/ui/mir/enum/convert_non_integer_niche_break.rs
index 9ff4849c5b1..d26a3aeb506 100644
--- a/tests/ui/mir/enum/convert_non_integer_niche_break.rs
+++ b/tests/ui/mir/enum/convert_non_integer_niche_break.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value 0x5
 
diff --git a/tests/ui/mir/enum/negative_discr_break.rs b/tests/ui/mir/enum/negative_discr_break.rs
index fa1284f72a0..35ee8aa3fc8 100644
--- a/tests/ui/mir/enum/negative_discr_break.rs
+++ b/tests/ui/mir/enum/negative_discr_break.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value 0xfd
 
diff --git a/tests/ui/mir/enum/niche_option_tuple_break.rs b/tests/ui/mir/enum/niche_option_tuple_break.rs
index affdc4784a3..0a933afa153 100644
--- a/tests/ui/mir/enum/niche_option_tuple_break.rs
+++ b/tests/ui/mir/enum/niche_option_tuple_break.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value
 
diff --git a/tests/ui/mir/enum/numbered_variants_break.rs b/tests/ui/mir/enum/numbered_variants_break.rs
index e3e71dc8aec..fbe7d6627a3 100644
--- a/tests/ui/mir/enum/numbered_variants_break.rs
+++ b/tests/ui/mir/enum/numbered_variants_break.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value 0x3
 
diff --git a/tests/ui/mir/enum/option_with_bigger_niche_break.rs b/tests/ui/mir/enum/option_with_bigger_niche_break.rs
index c66614b845b..675d27f0ec2 100644
--- a/tests/ui/mir/enum/option_with_bigger_niche_break.rs
+++ b/tests/ui/mir/enum/option_with_bigger_niche_break.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value 0x0
 
diff --git a/tests/ui/mir/enum/plain_no_data_break.rs b/tests/ui/mir/enum/plain_no_data_break.rs
index db68e752479..966dd641873 100644
--- a/tests/ui/mir/enum/plain_no_data_break.rs
+++ b/tests/ui/mir/enum/plain_no_data_break.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value 0x1
 
diff --git a/tests/ui/mir/enum/single_with_repr_break.rs b/tests/ui/mir/enum/single_with_repr_break.rs
index 5a4ec85a9b5..53e4932d5fd 100644
--- a/tests/ui/mir/enum/single_with_repr_break.rs
+++ b/tests/ui/mir/enum/single_with_repr_break.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value 0x1
 
diff --git a/tests/ui/mir/enum/with_niche_int_break.rs b/tests/ui/mir/enum/with_niche_int_break.rs
index 6a97eaa8f4f..d363dc7568a 100644
--- a/tests/ui/mir/enum/with_niche_int_break.rs
+++ b/tests/ui/mir/enum/with_niche_int_break.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value
 
diff --git a/tests/ui/mir/enum/wrap_break.rs b/tests/ui/mir/enum/wrap_break.rs
index 4491394ca5a..5c410afa511 100644
--- a/tests/ui/mir/enum/wrap_break.rs
+++ b/tests/ui/mir/enum/wrap_break.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: trying to construct an enum from an invalid value 0x0
 #![feature(never_type)]
diff --git a/tests/ui/mir/null/borrowed_mut_null.rs b/tests/ui/mir/null/borrowed_mut_null.rs
index d26452b9dac..a4660f4bf57 100644
--- a/tests/ui/mir/null/borrowed_mut_null.rs
+++ b/tests/ui/mir/null/borrowed_mut_null.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: null pointer dereference occurred
 
diff --git a/tests/ui/mir/null/borrowed_null.rs b/tests/ui/mir/null/borrowed_null.rs
index fefac3a7212..2a50058a482 100644
--- a/tests/ui/mir/null/borrowed_null.rs
+++ b/tests/ui/mir/null/borrowed_null.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: null pointer dereference occurred
 
diff --git a/tests/ui/mir/null/borrowed_null_zst.rs b/tests/ui/mir/null/borrowed_null_zst.rs
index 835727c068b..106fa00b1db 100644
--- a/tests/ui/mir/null/borrowed_null_zst.rs
+++ b/tests/ui/mir/null/borrowed_null_zst.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: null pointer dereference occurred
 
diff --git a/tests/ui/mir/null/null_lhs.rs b/tests/ui/mir/null/null_lhs.rs
index 238d350d1bd..b59338588a5 100644
--- a/tests/ui/mir/null/null_lhs.rs
+++ b/tests/ui/mir/null/null_lhs.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: null pointer dereference occurred
 
diff --git a/tests/ui/mir/null/null_rhs.rs b/tests/ui/mir/null/null_rhs.rs
index 18eafb61869..18fdad759fd 100644
--- a/tests/ui/mir/null/null_rhs.rs
+++ b/tests/ui/mir/null/null_rhs.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: null pointer dereference occurred
 
diff --git a/tests/ui/mir/null/two_pointers.rs b/tests/ui/mir/null/two_pointers.rs
index 52b9510be12..b2aa7cf0384 100644
--- a/tests/ui/mir/null/two_pointers.rs
+++ b/tests/ui/mir/null/two_pointers.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -C debug-assertions
 //@ error-pattern: null pointer dereference occurred
 
diff --git a/tests/ui/panics/panic-in-cleanup.rs b/tests/ui/panics/panic-in-cleanup.rs
index 8cddeb37348..2e307de4393 100644
--- a/tests/ui/panics/panic-in-cleanup.rs
+++ b/tests/ui/panics/panic-in-cleanup.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ exec-env:RUST_BACKTRACE=0
 //@ check-run-results
 //@ error-pattern: panic in a destructor during cleanup
diff --git a/tests/ui/panics/panic-in-ffi.rs b/tests/ui/panics/panic-in-ffi.rs
index 6068e4fdc59..b926d0fa776 100644
--- a/tests/ui/panics/panic-in-ffi.rs
+++ b/tests/ui/panics/panic-in-ffi.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ exec-env:RUST_BACKTRACE=0
 //@ check-run-results
 //@ error-pattern: panic in a function that cannot unwind
diff --git a/tests/ui/panics/panic-in-message-fmt.rs b/tests/ui/panics/panic-in-message-fmt.rs
index 1e9bbaf45c5..4d539f17a0a 100644
--- a/tests/ui/panics/panic-in-message-fmt.rs
+++ b/tests/ui/panics/panic-in-message-fmt.rs
@@ -1,6 +1,6 @@
 // Checks what happens when formatting the panic message panics.
 
-//@ run-fail
+//@ run-crash
 //@ exec-env:RUST_BACKTRACE=0
 //@ check-run-results
 //@ error-pattern: panicked while processing panic
diff --git a/tests/ui/panics/panic-main.rs b/tests/ui/panics/panic-main.rs
index 2395f68241f..2009f69e19e 100644
--- a/tests/ui/panics/panic-main.rs
+++ b/tests/ui/panics/panic-main.rs
@@ -1,30 +1,37 @@
 //@ revisions: default abort-zero abort-one abort-full unwind-zero unwind-one unwind-full
 
+//@[default] run-fail
+
 //@[abort-zero] compile-flags: -Cpanic=abort
 //@[abort-zero] no-prefer-dynamic
 //@[abort-zero] exec-env:RUST_BACKTRACE=0
+//@[abort-zero] run-crash
 
 //@[abort-one] compile-flags: -Cpanic=abort
 //@[abort-one] no-prefer-dynamic
 //@[abort-one] exec-env:RUST_BACKTRACE=1
+//@[abort-one] run-crash
 
 //@[abort-full] compile-flags: -Cpanic=abort
 //@[abort-full] no-prefer-dynamic
 //@[abort-full] exec-env:RUST_BACKTRACE=full
+//@[abort-full] run-crash
 
 //@[unwind-zero] compile-flags: -Cpanic=unwind
 //@[unwind-zero] exec-env:RUST_BACKTRACE=0
 //@[unwind-zero] needs-unwind
+//@[unwind-zero] run-fail
 
 //@[unwind-one] compile-flags: -Cpanic=unwind
 //@[unwind-one] exec-env:RUST_BACKTRACE=1
 //@[unwind-one] needs-unwind
+//@[unwind-one] run-fail
 
 //@[unwind-full] compile-flags: -Cpanic=unwind
 //@[unwind-full] exec-env:RUST_BACKTRACE=full
 //@[unwind-full] needs-unwind
+//@[unwind-full] run-fail
 
-//@ run-fail
 //@ error-pattern:moop
 //@ needs-subprocess
 
diff --git a/tests/ui/precondition-checks/alignment.rs b/tests/ui/precondition-checks/alignment.rs
index 92400528fa0..038a625bed7 100644
--- a/tests/ui/precondition-checks/alignment.rs
+++ b/tests/ui/precondition-checks/alignment.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: Alignment::new_unchecked requires
 
diff --git a/tests/ui/precondition-checks/ascii-char-digit_unchecked.rs b/tests/ui/precondition-checks/ascii-char-digit_unchecked.rs
index 30c6f79fb08..41ba2c5254a 100644
--- a/tests/ui/precondition-checks/ascii-char-digit_unchecked.rs
+++ b/tests/ui/precondition-checks/ascii-char-digit_unchecked.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: `ascii::Char::digit_unchecked` input cannot exceed 9
 
diff --git a/tests/ui/precondition-checks/assert_unchecked.rs b/tests/ui/precondition-checks/assert_unchecked.rs
index 22b2b414550..da5383cdea0 100644
--- a/tests/ui/precondition-checks/assert_unchecked.rs
+++ b/tests/ui/precondition-checks/assert_unchecked.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: hint::assert_unchecked must never be called when the condition is false
 
diff --git a/tests/ui/precondition-checks/char-from_u32_unchecked.rs b/tests/ui/precondition-checks/char-from_u32_unchecked.rs
index d950f20c772..7c34d926d3e 100644
--- a/tests/ui/precondition-checks/char-from_u32_unchecked.rs
+++ b/tests/ui/precondition-checks/char-from_u32_unchecked.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: invalid value for `char`
 
diff --git a/tests/ui/precondition-checks/copy-nonoverlapping.rs b/tests/ui/precondition-checks/copy-nonoverlapping.rs
index eacaa63e543..1d584ddef4c 100644
--- a/tests/ui/precondition-checks/copy-nonoverlapping.rs
+++ b/tests/ui/precondition-checks/copy-nonoverlapping.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: ptr::copy_nonoverlapping requires
 //@ revisions: null_src null_dst misaligned_src misaligned_dst overlapping
diff --git a/tests/ui/precondition-checks/copy.rs b/tests/ui/precondition-checks/copy.rs
index 1fadd90bf70..8faa56a880e 100644
--- a/tests/ui/precondition-checks/copy.rs
+++ b/tests/ui/precondition-checks/copy.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: ptr::copy requires
 //@ revisions: null_src null_dst misaligned_src misaligned_dst
diff --git a/tests/ui/precondition-checks/layout.rs b/tests/ui/precondition-checks/layout.rs
index 4ee66cc9328..6755ebce854 100644
--- a/tests/ui/precondition-checks/layout.rs
+++ b/tests/ui/precondition-checks/layout.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: Layout::from_size_align_unchecked requires
 //@ revisions: toolarge badalign
diff --git a/tests/ui/precondition-checks/nonnull.rs b/tests/ui/precondition-checks/nonnull.rs
index 6b8edd4e582..75bbd65b486 100644
--- a/tests/ui/precondition-checks/nonnull.rs
+++ b/tests/ui/precondition-checks/nonnull.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: NonNull::new_unchecked requires
 
diff --git a/tests/ui/precondition-checks/nonzero-from_mut_unchecked.rs b/tests/ui/precondition-checks/nonzero-from_mut_unchecked.rs
index 46ce7dc356f..d55707fdd0b 100644
--- a/tests/ui/precondition-checks/nonzero-from_mut_unchecked.rs
+++ b/tests/ui/precondition-checks/nonzero-from_mut_unchecked.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: NonZero::from_mut_unchecked requires
 
diff --git a/tests/ui/precondition-checks/nonzero-new_unchecked.rs b/tests/ui/precondition-checks/nonzero-new_unchecked.rs
index 7827a42844f..978f01f150f 100644
--- a/tests/ui/precondition-checks/nonzero-new_unchecked.rs
+++ b/tests/ui/precondition-checks/nonzero-new_unchecked.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: NonZero::new_unchecked requires
 
diff --git a/tests/ui/precondition-checks/read_volatile.rs b/tests/ui/precondition-checks/read_volatile.rs
index ada8932c398..fa1c2c827d7 100644
--- a/tests/ui/precondition-checks/read_volatile.rs
+++ b/tests/ui/precondition-checks/read_volatile.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: ptr::read_volatile requires
 //@ revisions: null misaligned
diff --git a/tests/ui/precondition-checks/replace.rs b/tests/ui/precondition-checks/replace.rs
index 44afbd8174c..447a00c6572 100644
--- a/tests/ui/precondition-checks/replace.rs
+++ b/tests/ui/precondition-checks/replace.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: ptr::replace requires
 //@ revisions: null misaligned
diff --git a/tests/ui/precondition-checks/slice-from-raw-parts-mut.rs b/tests/ui/precondition-checks/slice-from-raw-parts-mut.rs
index 9b9ded69a83..b6397ab2a12 100644
--- a/tests/ui/precondition-checks/slice-from-raw-parts-mut.rs
+++ b/tests/ui/precondition-checks/slice-from-raw-parts-mut.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: slice::from_raw_parts_mut requires
 //@ revisions: null misaligned toolarge
diff --git a/tests/ui/precondition-checks/slice-from-raw-parts.rs b/tests/ui/precondition-checks/slice-from-raw-parts.rs
index 96578c1eae5..a317e3d41a0 100644
--- a/tests/ui/precondition-checks/slice-from-raw-parts.rs
+++ b/tests/ui/precondition-checks/slice-from-raw-parts.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: slice::from_raw_parts requires
 //@ revisions: null misaligned toolarge
diff --git a/tests/ui/precondition-checks/slice-get_unchecked.rs b/tests/ui/precondition-checks/slice-get_unchecked.rs
index 1d8188fb953..7bcb8442540 100644
--- a/tests/ui/precondition-checks/slice-get_unchecked.rs
+++ b/tests/ui/precondition-checks/slice-get_unchecked.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: slice::get_unchecked requires
 //@ revisions: usize range range_to range_from backwards_range
diff --git a/tests/ui/precondition-checks/slice-get_unchecked_mut.rs b/tests/ui/precondition-checks/slice-get_unchecked_mut.rs
index 34c1454af43..2ba3227f39e 100644
--- a/tests/ui/precondition-checks/slice-get_unchecked_mut.rs
+++ b/tests/ui/precondition-checks/slice-get_unchecked_mut.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: slice::get_unchecked_mut requires
 //@ revisions: usize range range_to range_from backwards_range
diff --git a/tests/ui/precondition-checks/str-get_unchecked.rs b/tests/ui/precondition-checks/str-get_unchecked.rs
index 14d17f997ec..2273190e9f4 100644
--- a/tests/ui/precondition-checks/str-get_unchecked.rs
+++ b/tests/ui/precondition-checks/str-get_unchecked.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: str::get_unchecked requires
 //@ revisions: range range_to range_from backwards_range
diff --git a/tests/ui/precondition-checks/str-get_unchecked_mut.rs b/tests/ui/precondition-checks/str-get_unchecked_mut.rs
index ca1b1690055..53e6ee64d47 100644
--- a/tests/ui/precondition-checks/str-get_unchecked_mut.rs
+++ b/tests/ui/precondition-checks/str-get_unchecked_mut.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: str::get_unchecked_mut requires
 //@ revisions: range range_to range_from backwards_range
diff --git a/tests/ui/precondition-checks/swap-nonoverlapping.rs b/tests/ui/precondition-checks/swap-nonoverlapping.rs
index ea1f6f36ad7..81ba72382c0 100644
--- a/tests/ui/precondition-checks/swap-nonoverlapping.rs
+++ b/tests/ui/precondition-checks/swap-nonoverlapping.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: ptr::swap_nonoverlapping requires
 //@ revisions: null_src null_dst misaligned_src misaligned_dst overlapping
diff --git a/tests/ui/precondition-checks/unchecked_add.rs b/tests/ui/precondition-checks/unchecked_add.rs
index f44a6ea32ad..b7727aeb968 100644
--- a/tests/ui/precondition-checks/unchecked_add.rs
+++ b/tests/ui/precondition-checks/unchecked_add.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: u8::unchecked_add cannot overflow
 
diff --git a/tests/ui/precondition-checks/unchecked_mul.rs b/tests/ui/precondition-checks/unchecked_mul.rs
index 66655dda136..3eea8b66abb 100644
--- a/tests/ui/precondition-checks/unchecked_mul.rs
+++ b/tests/ui/precondition-checks/unchecked_mul.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: u8::unchecked_add cannot overflow
 
diff --git a/tests/ui/precondition-checks/unchecked_shl.rs b/tests/ui/precondition-checks/unchecked_shl.rs
index 1c96db0b1ec..57c617e0845 100644
--- a/tests/ui/precondition-checks/unchecked_shl.rs
+++ b/tests/ui/precondition-checks/unchecked_shl.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: u8::unchecked_shl cannot overflow
 
diff --git a/tests/ui/precondition-checks/unchecked_shr.rs b/tests/ui/precondition-checks/unchecked_shr.rs
index 4a6d9ffb1d3..18502d2b645 100644
--- a/tests/ui/precondition-checks/unchecked_shr.rs
+++ b/tests/ui/precondition-checks/unchecked_shr.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: u8::unchecked_shr cannot overflow
 
diff --git a/tests/ui/precondition-checks/unchecked_sub.rs b/tests/ui/precondition-checks/unchecked_sub.rs
index 545dde0e278..bfe8f5849f5 100644
--- a/tests/ui/precondition-checks/unchecked_sub.rs
+++ b/tests/ui/precondition-checks/unchecked_sub.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: u8::unchecked_sub cannot overflow
 
diff --git a/tests/ui/precondition-checks/unreachable_unchecked.rs b/tests/ui/precondition-checks/unreachable_unchecked.rs
index 2435450c4b5..f2855d03a3e 100644
--- a/tests/ui/precondition-checks/unreachable_unchecked.rs
+++ b/tests/ui/precondition-checks/unreachable_unchecked.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: hint::unreachable_unchecked must never be reached
 
diff --git a/tests/ui/precondition-checks/vec-from-parts.rs b/tests/ui/precondition-checks/vec-from-parts.rs
index 0bafb5aa715..ace90770360 100644
--- a/tests/ui/precondition-checks/vec-from-parts.rs
+++ b/tests/ui/precondition-checks/vec-from-parts.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Cdebug-assertions=yes
 //@ error-pattern: unsafe precondition(s) violated: Vec::from_parts_in requires that length <= capacity
 #![feature(allocator_api)]
diff --git a/tests/ui/precondition-checks/vec-from-raw-parts.rs b/tests/ui/precondition-checks/vec-from-raw-parts.rs
index 884d34c0a56..1bc8e6ada10 100644
--- a/tests/ui/precondition-checks/vec-from-raw-parts.rs
+++ b/tests/ui/precondition-checks/vec-from-raw-parts.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Cdebug-assertions=yes
 //@ error-pattern: unsafe precondition(s) violated: Vec::from_raw_parts_in requires that length <= capacity
 //@ revisions: vec_from_raw_parts vec_from_raw_parts_in string_from_raw_parts
diff --git a/tests/ui/precondition-checks/vec-set-len.rs b/tests/ui/precondition-checks/vec-set-len.rs
index 0987e7fe028..c6bdee7dc67 100644
--- a/tests/ui/precondition-checks/vec-set-len.rs
+++ b/tests/ui/precondition-checks/vec-set-len.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Cdebug-assertions=yes
 //@ error-pattern: unsafe precondition(s) violated: Vec::set_len requires that new_len <= capacity()
 
diff --git a/tests/ui/precondition-checks/write_volatile.rs b/tests/ui/precondition-checks/write_volatile.rs
index 0d5ecb014b3..25107871c39 100644
--- a/tests/ui/precondition-checks/write_volatile.rs
+++ b/tests/ui/precondition-checks/write_volatile.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ compile-flags: -Copt-level=3 -Cdebug-assertions=no -Zub-checks=yes
 //@ error-pattern: unsafe precondition(s) violated: ptr::write_volatile requires
 //@ revisions: null misaligned
diff --git a/tests/ui/sanitizer/address.rs b/tests/ui/sanitizer/address.rs
index 7a5e767687c..704d84764c1 100644
--- a/tests/ui/sanitizer/address.rs
+++ b/tests/ui/sanitizer/address.rs
@@ -4,7 +4,7 @@
 //
 //@ compile-flags: -Z sanitizer=address -O -g
 //
-//@ run-fail
+//@ run-fail-or-crash
 //@ error-pattern: AddressSanitizer: stack-buffer-overflow
 //@ error-pattern: 'xs' (line 14) <== Memory access at offset
 
diff --git a/tests/ui/sanitizer/badfree.rs b/tests/ui/sanitizer/badfree.rs
index ecbb58eba00..6b3aea7239c 100644
--- a/tests/ui/sanitizer/badfree.rs
+++ b/tests/ui/sanitizer/badfree.rs
@@ -4,7 +4,7 @@
 //
 //@ compile-flags: -Z sanitizer=address -O
 //
-//@ run-fail
+//@ run-fail-or-crash
 //@ regex-error-pattern: AddressSanitizer: (SEGV|attempting free on address which was not malloc)
 
 use std::ffi::c_void;
diff --git a/tests/ui/sanitizer/new-llvm-pass-manager-thin-lto.rs b/tests/ui/sanitizer/new-llvm-pass-manager-thin-lto.rs
index b7dd4a43782..c1a2c2f26ac 100644
--- a/tests/ui/sanitizer/new-llvm-pass-manager-thin-lto.rs
+++ b/tests/ui/sanitizer/new-llvm-pass-manager-thin-lto.rs
@@ -11,7 +11,7 @@
 //@ compile-flags: -Zsanitizer=address -Clto=thin
 //@[opt0]compile-flags: -Copt-level=0
 //@[opt1]compile-flags: -Copt-level=1
-//@ run-fail
+//@ run-fail-or-crash
 //@ error-pattern: ERROR: AddressSanitizer: stack-use-after-scope
 
 static mut P: *mut usize = std::ptr::null_mut();
diff --git a/tests/ui/sanitizer/thread.rs b/tests/ui/sanitizer/thread.rs
index 566774d6b1d..9073124d1bd 100644
--- a/tests/ui/sanitizer/thread.rs
+++ b/tests/ui/sanitizer/thread.rs
@@ -15,7 +15,7 @@
 //
 //@ compile-flags: -Z sanitizer=thread -O
 //
-//@ run-fail
+//@ run-fail-or-crash
 //@ error-pattern: WARNING: ThreadSanitizer: data race
 //@ error-pattern: Location is heap block of size 4
 //@ error-pattern: allocated by main thread
diff --git a/tests/ui/sanitizer/use-after-scope.rs b/tests/ui/sanitizer/use-after-scope.rs
index 4d7f6f6c2f2..106dc6466d6 100644
--- a/tests/ui/sanitizer/use-after-scope.rs
+++ b/tests/ui/sanitizer/use-after-scope.rs
@@ -3,7 +3,7 @@
 //@ ignore-cross-compile
 //
 //@ compile-flags: -Zsanitizer=address
-//@ run-fail
+//@ run-fail-or-crash
 //@ error-pattern: ERROR: AddressSanitizer: stack-use-after-scope
 
 static mut P: *mut usize = std::ptr::null_mut();
diff --git a/tests/ui/std/issue-81357-unsound-file-methods.rs b/tests/ui/std/issue-81357-unsound-file-methods.rs
index 838df40c32d..99bd31aa260 100644
--- a/tests/ui/std/issue-81357-unsound-file-methods.rs
+++ b/tests/ui/std/issue-81357-unsound-file-methods.rs
@@ -1,4 +1,4 @@
-//@ run-fail
+//@ run-crash
 //@ only-windows
 
 fn main() {
-- 
cgit 1.4.1-3-g733a5


From bb46b8cf6a1683972d0e564494226ef4b60f9619 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 11 Jul 2025 15:14:58 +0200
Subject: Allow selecting check tool `Mode` based on `Builder`

---
 src/bootstrap/src/core/build_steps/check.rs | 39 ++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 15 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 1d30886a86a..01b0915dfaf 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -494,7 +494,8 @@ macro_rules! tool_check_step {
             // The part of this path after the final '/' is also used as a display name.
             path: $path:literal
             $(, alt_path: $alt_path:literal )*
-            , mode: $mode:path
+            // Closure that returns `Mode` based on the passed `&Builder<'_>`
+            , mode: $mode:expr
             $(, allow_features: $allow_features:expr )?
             $(, default: $default:literal )?
             $( , )?
@@ -518,10 +519,13 @@ macro_rules! tool_check_step {
 
             fn make_run(run: RunConfig<'_>) {
                 let target = run.target;
-                let build_compiler = prepare_compiler_for_check(run.builder, target, $mode);
+                let builder = run.builder;
+                let mode = $mode(builder);
+
+                let build_compiler = prepare_compiler_for_check(run.builder, target, mode);
 
                 // It doesn't make sense to cross-check bootstrap tools
-                if $mode == Mode::ToolBootstrap && target != run.builder.host_target {
+                if mode == Mode::ToolBootstrap && target != run.builder.host_target {
                     println!("WARNING: not checking bootstrap tool {} for target {target} as it is a bootstrap (host-only) tool", stringify!($path));
                     return;
                 };
@@ -536,7 +540,8 @@ macro_rules! tool_check_step {
                     $( _value = $allow_features; )?
                     _value
                 };
-                run_tool_check_step(builder, build_compiler, target, $path, $mode, allow_features);
+                let mode = $mode(builder);
+                run_tool_check_step(builder, build_compiler, target, $path, mode, allow_features);
             }
 
             fn metadata(&self) -> Option<StepMetadata> {
@@ -593,43 +598,47 @@ fn run_tool_check_step(
 tool_check_step!(Rustdoc {
     path: "src/tools/rustdoc",
     alt_path: "src/librustdoc",
-    mode: Mode::ToolRustc
+    mode: |_builder| Mode::ToolRustc
 });
 // Clippy, miri and Rustfmt are hybrids. They are external tools, but use a git subtree instead
 // of a submodule. Since the SourceType only drives the deny-warnings
 // behavior, treat it as in-tree so that any new warnings in clippy will be
 // rejected.
-tool_check_step!(Clippy { path: "src/tools/clippy", mode: Mode::ToolRustc });
-tool_check_step!(Miri { path: "src/tools/miri", mode: Mode::ToolRustc });
-tool_check_step!(CargoMiri { path: "src/tools/miri/cargo-miri", mode: Mode::ToolRustc });
-tool_check_step!(Rustfmt { path: "src/tools/rustfmt", mode: Mode::ToolRustc });
+tool_check_step!(Clippy { path: "src/tools/clippy", mode: |_builder| Mode::ToolRustc });
+tool_check_step!(Miri { path: "src/tools/miri", mode: |_builder| Mode::ToolRustc });
+tool_check_step!(CargoMiri { path: "src/tools/miri/cargo-miri", mode: |_builder| Mode::ToolRustc });
+tool_check_step!(Rustfmt { path: "src/tools/rustfmt", mode: |_builder| Mode::ToolRustc });
 tool_check_step!(MiroptTestTools {
     path: "src/tools/miropt-test-tools",
-    mode: Mode::ToolBootstrap
+    mode: |_builder| Mode::ToolBootstrap
 });
 // We want to test the local std
 tool_check_step!(TestFloatParse {
     path: "src/tools/test-float-parse",
-    mode: Mode::ToolStd,
+    mode: |_builder| Mode::ToolStd,
     allow_features: tool::TestFloatParse::ALLOW_FEATURES
 });
 tool_check_step!(FeaturesStatusDump {
     path: "src/tools/features-status-dump",
-    mode: Mode::ToolBootstrap
+    mode: |_builder| Mode::ToolBootstrap
 });
 
-tool_check_step!(Bootstrap { path: "src/bootstrap", mode: Mode::ToolBootstrap, default: false });
+tool_check_step!(Bootstrap {
+    path: "src/bootstrap",
+    mode: |_builder| Mode::ToolBootstrap,
+    default: false
+});
 
 // `run-make-support` will be built as part of suitable run-make compiletest test steps, but support
 // check to make it easier to work on.
 tool_check_step!(RunMakeSupport {
     path: "src/tools/run-make-support",
-    mode: Mode::ToolBootstrap,
+    mode: |_builder| Mode::ToolBootstrap,
     default: false
 });
 
 tool_check_step!(CoverageDump {
     path: "src/tools/coverage-dump",
-    mode: Mode::ToolBootstrap,
+    mode: |_builder| Mode::ToolBootstrap,
     default: false
 });
-- 
cgit 1.4.1-3-g733a5


From 245d2c95b1791aa8f6abb3fd9b99e39ee7bcd15a Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 11 Jul 2025 20:14:36 +0200
Subject: Implement `check::Compiletest` using the `tool_check_step` macro

---
 src/bootstrap/src/core/build_steps/check.rs | 68 ++++++-----------------------
 src/bootstrap/src/core/builder/tests.rs     |  4 +-
 2 files changed, 15 insertions(+), 57 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 01b0915dfaf..2a19e17019e 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -433,61 +433,6 @@ impl Step for RustAnalyzer {
     }
 }
 
-/// Compiletest is implicitly "checked" when it gets built in order to run tests,
-/// so this is mainly for people working on compiletest to run locally.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Compiletest {
-    pub target: TargetSelection,
-}
-
-impl Step for Compiletest {
-    type Output = ();
-    const ONLY_HOSTS: bool = true;
-    const DEFAULT: bool = false;
-
-    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        run.path("src/tools/compiletest")
-    }
-
-    fn make_run(run: RunConfig<'_>) {
-        run.builder.ensure(Compiletest { target: run.target });
-    }
-
-    fn run(self, builder: &Builder<'_>) {
-        let mode = if builder.config.compiletest_use_stage0_libtest {
-            Mode::ToolBootstrap
-        } else {
-            Mode::ToolStd
-        };
-        let build_compiler = prepare_compiler_for_check(builder, self.target, mode);
-
-        let mut cargo = prepare_tool_cargo(
-            builder,
-            build_compiler,
-            mode,
-            self.target,
-            builder.kind,
-            "src/tools/compiletest",
-            SourceType::InTree,
-            &[],
-        );
-
-        cargo.allow_features(COMPILETEST_ALLOW_FEATURES);
-
-        cargo.arg("--all-targets");
-
-        let stamp = BuildStamp::new(&builder.cargo_out(build_compiler, mode, self.target))
-            .with_prefix("compiletest-check");
-
-        let _guard = builder.msg_check("compiletest artifacts", self.target, None);
-        run_cargo(builder, cargo, builder.config.free_args.clone(), &stamp, vec![], true, false);
-    }
-
-    fn metadata(&self) -> Option<StepMetadata> {
-        Some(StepMetadata::check("compiletest", self.target))
-    }
-}
-
 macro_rules! tool_check_step {
     (
         $name:ident {
@@ -642,3 +587,16 @@ tool_check_step!(CoverageDump {
     mode: |_builder| Mode::ToolBootstrap,
     default: false
 });
+
+// Compiletest is implicitly "checked" when it gets built in order to run tests,
+// so this is mainly for people working on compiletest to run locally.
+tool_check_step!(Compiletest {
+    path: "src/tools/compiletest",
+    mode: |builder: &Builder<'_>| if builder.config.compiletest_use_stage0_libtest {
+        Mode::ToolBootstrap
+    } else {
+        Mode::ToolStd
+    },
+    allow_features: COMPILETEST_ALLOW_FEATURES,
+    default: false,
+});
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 2f8cdd2f8c8..d27a2e65ed1 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1528,7 +1528,7 @@ mod snapshot {
         insta::assert_snapshot!(
             ctx.config("check")
                 .path("compiletest")
-                .render_steps(), @"[check] compiletest <host>");
+                .render_steps(), @"[check] rustc 0 <host> -> Compiletest 1 <host>");
     }
 
     #[test]
@@ -1542,7 +1542,7 @@ mod snapshot {
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustc 1 <host> -> std 1 <host>
-        [check] compiletest <host>
+        [check] rustc 1 <host> -> Compiletest 2 <host>
         ");
     }
 
-- 
cgit 1.4.1-3-g733a5


From fc74c2272bc3cf6ee7be23e75808ddf4af0c29ef Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Sat, 19 Jul 2025 12:58:25 +0200
Subject: Add approval blocking labels for new bors

---
 rust-bors.toml | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/rust-bors.toml b/rust-bors.toml
index fbfaa980f05..56f48512b06 100644
--- a/rust-bors.toml
+++ b/rust-bors.toml
@@ -1,2 +1,19 @@
 # 6 hours timeout for CI builds
 timeout = 21600
+
+# Do not allow approving PRs with certain labels
+labels_blocking_approval = [
+    # Waiting for an FCP to finish
+    "final-comment-period",
+    "proposed-final-comment-period",
+    # PRs that were closed or postponed by an FCP
+    "disposition-close",
+    "disposition-postpone",
+    # Waiting for library ACP
+    "S-waiting-on-ACP",
+    "S-waiting-on-concerns",
+    "S-waiting-on-crater",
+    "S-waiting-on-fcp",
+    "S-waiting-on-MCP",
+    "S-waiting-on-team"
+]
-- 
cgit 1.4.1-3-g733a5


From a2586f0c801aa52150925b4a66a517b1ffe13ddd Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Mon, 23 Jun 2025 12:50:18 -0500
Subject: tidy: running of eslint, tsc, and es-check are now an extra check

---
 src/bootstrap/src/core/config/flags.rs           |   2 +-
 src/etc/completions/x.fish                       |   6 +-
 src/etc/completions/x.ps1                        |   6 +-
 src/etc/completions/x.py.fish                    |   6 +-
 src/etc/completions/x.py.ps1                     |   6 +-
 src/etc/completions/x.py.zsh                     |   6 +-
 src/etc/completions/x.zsh                        |   6 +-
 src/tools/tidy/src/ext_tool_checks.rs            |  37 +++++-
 src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs | 141 +++++++++++++++++++++++
 src/tools/tidy/src/lib.rs                        |   1 -
 src/tools/tidy/src/main.rs                       |   4 +-
 src/tools/tidy/src/rustdoc_js.rs                 | 101 ----------------
 12 files changed, 211 insertions(+), 111 deletions(-)
 create mode 100644 src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs
 delete mode 100644 src/tools/tidy/src/rustdoc_js.rs

diff --git a/src/bootstrap/src/core/config/flags.rs b/src/bootstrap/src/core/config/flags.rs
index 1547ca44494..31a427f9ffa 100644
--- a/src/bootstrap/src/core/config/flags.rs
+++ b/src/bootstrap/src/core/config/flags.rs
@@ -386,7 +386,7 @@ pub enum Subcommand {
         bless: bool,
         #[arg(long)]
         /// comma-separated list of other files types to check (accepts py, py:lint,
-        /// py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck)
+        /// py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck, spellcheck)
         ///
         /// Any argument can be prefixed with "auto:" to only run if
         /// relevant files are modified (eg. "auto:py").
diff --git a/src/etc/completions/x.fish b/src/etc/completions/x.fish
index 28a228d5464..f4e7413ca53 100644
--- a/src/etc/completions/x.fish
+++ b/src/etc/completions/x.fish
@@ -299,7 +299,11 @@ complete -c x -n "__fish_x_using_subcommand doc" -l skip-std-check-if-no-downloa
 complete -c x -n "__fish_x_using_subcommand doc" -s h -l help -d 'Print help (see more with \'--help\')'
 complete -c x -n "__fish_x_using_subcommand test" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r
 complete -c x -n "__fish_x_using_subcommand test" -l compiletest-rustc-args -d 'extra options to pass the compiler when running compiletest tests' -r
-complete -c x -n "__fish_x_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck)' -r
+<<<<<<< HEAD
+complete -c x -n "__fish_x_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck, spellcheck)' -r
+=======
+complete -c x -n "__fish_x_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck)' -r
+>>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
 complete -c x -n "__fish_x_using_subcommand test" -l compare-mode -d 'mode describing what file the actual ui output will be compared to' -r
 complete -c x -n "__fish_x_using_subcommand test" -l pass -d 'force {check,build,run}-pass tests to this mode' -r
 complete -c x -n "__fish_x_using_subcommand test" -l run -d 'whether to execute run-* tests' -r
diff --git a/src/etc/completions/x.ps1 b/src/etc/completions/x.ps1
index 0c9b3828273..fced6587d32 100644
--- a/src/etc/completions/x.ps1
+++ b/src/etc/completions/x.ps1
@@ -345,7 +345,11 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
         'x;test' {
             [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)')
             [CompletionResult]::new('--compiletest-rustc-args', '--compiletest-rustc-args', [CompletionResultType]::ParameterName, 'extra options to pass the compiler when running compiletest tests')
-            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck)')
+<<<<<<< HEAD
+            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck, spellcheck)')
+=======
+            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck)')
+>>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
             [CompletionResult]::new('--compare-mode', '--compare-mode', [CompletionResultType]::ParameterName, 'mode describing what file the actual ui output will be compared to')
             [CompletionResult]::new('--pass', '--pass', [CompletionResultType]::ParameterName, 'force {check,build,run}-pass tests to this mode')
             [CompletionResult]::new('--run', '--run', [CompletionResultType]::ParameterName, 'whether to execute run-* tests')
diff --git a/src/etc/completions/x.py.fish b/src/etc/completions/x.py.fish
index 43ae7424e27..c80750111f7 100644
--- a/src/etc/completions/x.py.fish
+++ b/src/etc/completions/x.py.fish
@@ -299,7 +299,11 @@ complete -c x.py -n "__fish_x.py_using_subcommand doc" -l skip-std-check-if-no-d
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -s h -l help -d 'Print help (see more with \'--help\')'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l compiletest-rustc-args -d 'extra options to pass the compiler when running compiletest tests' -r
-complete -c x.py -n "__fish_x.py_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck)' -r
+<<<<<<< HEAD
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck, spellcheck)' -r
+=======
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck)' -r
+>>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l compare-mode -d 'mode describing what file the actual ui output will be compared to' -r
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l pass -d 'force {check,build,run}-pass tests to this mode' -r
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l run -d 'whether to execute run-* tests' -r
diff --git a/src/etc/completions/x.py.ps1 b/src/etc/completions/x.py.ps1
index 4311e383d64..dfb6482b41c 100644
--- a/src/etc/completions/x.py.ps1
+++ b/src/etc/completions/x.py.ps1
@@ -345,7 +345,11 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
         'x.py;test' {
             [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)')
             [CompletionResult]::new('--compiletest-rustc-args', '--compiletest-rustc-args', [CompletionResultType]::ParameterName, 'extra options to pass the compiler when running compiletest tests')
-            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, shell:lint, cpp, cpp:fmt, spellcheck)')
+<<<<<<< HEAD
+            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck, spellcheck)')
+=======
+            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck)')
+>>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
             [CompletionResult]::new('--compare-mode', '--compare-mode', [CompletionResultType]::ParameterName, 'mode describing what file the actual ui output will be compared to')
             [CompletionResult]::new('--pass', '--pass', [CompletionResultType]::ParameterName, 'force {check,build,run}-pass tests to this mode')
             [CompletionResult]::new('--run', '--run', [CompletionResultType]::ParameterName, 'whether to execute run-* tests')
diff --git a/src/etc/completions/x.py.zsh b/src/etc/completions/x.py.zsh
index aff35b31e21..8ccc7a7091c 100644
--- a/src/etc/completions/x.py.zsh
+++ b/src/etc/completions/x.py.zsh
@@ -345,7 +345,11 @@ _arguments "${_arguments_options[@]}" : \
 _arguments "${_arguments_options[@]}" : \
 '*--test-args=[extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)]:ARGS:_default' \
 '*--compiletest-rustc-args=[extra options to pass the compiler when running compiletest tests]:ARGS:_default' \
-'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, shell\:lint, cpp, cpp\:fmt, spellcheck)]:EXTRA_CHECKS:_default' \
+<<<<<<< HEAD
+'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, cpp, cpp\:fmt, js, js\:lint, js\:typecheck, spellcheck)]:EXTRA_CHECKS:_default' \
+=======
+'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, cpp, cpp\:fmt, js, js\:lint, js\:typecheck)]:EXTRA_CHECKS:_default' \
+>>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
 '--compare-mode=[mode describing what file the actual ui output will be compared to]:COMPARE MODE:_default' \
 '--pass=[force {check,build,run}-pass tests to this mode]:check | build | run:_default' \
 '--run=[whether to execute run-* tests]:auto | always | never:_default' \
diff --git a/src/etc/completions/x.zsh b/src/etc/completions/x.zsh
index 28ad00f3a0d..8c00abb7b21 100644
--- a/src/etc/completions/x.zsh
+++ b/src/etc/completions/x.zsh
@@ -345,7 +345,11 @@ _arguments "${_arguments_options[@]}" : \
 _arguments "${_arguments_options[@]}" : \
 '*--test-args=[extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)]:ARGS:_default' \
 '*--compiletest-rustc-args=[extra options to pass the compiler when running compiletest tests]:ARGS:_default' \
-'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, shell\:lint, cpp, cpp\:fmt, spellcheck)]:EXTRA_CHECKS:_default' \
+<<<<<<< HEAD
+'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, cpp, cpp\:fmt, js, js\:lint, js\:typecheck, spellcheck)]:EXTRA_CHECKS:_default' \
+=======
+'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, cpp, cpp\:fmt, js, js\:lint, js\:typecheck)]:EXTRA_CHECKS:_default' \
+>>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
 '--compare-mode=[mode describing what file the actual ui output will be compared to]:COMPARE MODE:_default' \
 '--pass=[force {check,build,run}-pass tests to this mode]:check | build | run:_default' \
 '--run=[whether to execute run-* tests]:auto | always | never:_default' \
diff --git a/src/tools/tidy/src/ext_tool_checks.rs b/src/tools/tidy/src/ext_tool_checks.rs
index 381ea44fd46..03ed0b00f3e 100644
--- a/src/tools/tidy/src/ext_tool_checks.rs
+++ b/src/tools/tidy/src/ext_tool_checks.rs
@@ -25,6 +25,8 @@ use std::{fmt, fs, io};
 
 use crate::CiInfo;
 
+mod rustdoc_js;
+
 const MIN_PY_REV: (u32, u32) = (3, 9);
 const MIN_PY_REV_STR: &str = "≥3.9";
 
@@ -46,12 +48,25 @@ pub fn check(
     root_path: &Path,
     outdir: &Path,
     ci_info: &CiInfo,
+    librustdoc_path: &Path,
+    tools_path: &Path,
+    src_path: &Path,
     bless: bool,
     extra_checks: Option<&str>,
     pos_args: &[String],
     bad: &mut bool,
 ) {
-    if let Err(e) = check_impl(root_path, outdir, ci_info, bless, extra_checks, pos_args) {
+    if let Err(e) = check_impl(
+        root_path,
+        outdir,
+        ci_info,
+        librustdoc_path,
+        tools_path,
+        src_path,
+        bless,
+        extra_checks,
+        pos_args,
+    ) {
         tidy_error!(bad, "{e}");
     }
 }
@@ -60,6 +75,9 @@ fn check_impl(
     root_path: &Path,
     outdir: &Path,
     ci_info: &CiInfo,
+    librustdoc_path: &Path,
+    tools_path: &Path,
+    src_path: &Path,
     bless: bool,
     extra_checks: Option<&str>,
     pos_args: &[String],
@@ -108,6 +126,8 @@ fn check_impl(
     let shell_lint = extra_check!(Shell, Lint);
     let cpp_fmt = extra_check!(Cpp, Fmt);
     let spellcheck = extra_check!(Spellcheck, None);
+    let js_lint = extra_check!(Js, Lint);
+    let js_typecheck = extra_check!(Js, Typecheck);
 
     let mut py_path = None;
 
@@ -275,6 +295,15 @@ fn check_impl(
         spellcheck_runner(&args)?;
     }
 
+    if js_lint {
+        rustdoc_js::lint(librustdoc_path, tools_path, src_path)?;
+        rustdoc_js::es_check(librustdoc_path)?;
+    }
+
+    if js_typecheck {
+        rustdoc_js::typecheck(librustdoc_path)?;
+    }
+
     Ok(())
 }
 
@@ -697,6 +726,7 @@ impl ExtraCheckArg {
             ExtraCheckLang::Py => ".py",
             ExtraCheckLang::Cpp => ".cpp",
             ExtraCheckLang::Shell => ".sh",
+            ExtraCheckLang::Js => ".js",
             ExtraCheckLang::Spellcheck => {
                 return !crate::files_modified(ci_info, |s| {
                     SPELLCHECK_DIRS.iter().any(|dir| Path::new(s).starts_with(dir))
@@ -717,6 +747,7 @@ impl ExtraCheckArg {
             ExtraCheckLang::Cpp => &[Fmt],
             ExtraCheckLang::Shell => &[Lint],
             ExtraCheckLang::Spellcheck => &[],
+            ExtraCheckLang::Js => &[Lint, Typecheck],
         };
         supported_kinds.contains(&kind)
     }
@@ -757,6 +788,7 @@ enum ExtraCheckLang {
     Shell,
     Cpp,
     Spellcheck,
+    Js,
 }
 
 impl FromStr for ExtraCheckLang {
@@ -768,6 +800,7 @@ impl FromStr for ExtraCheckLang {
             "shell" => Self::Shell,
             "cpp" => Self::Cpp,
             "spellcheck" => Self::Spellcheck,
+            "js" => Self::Js,
             _ => return Err(ExtraCheckParseError::UnknownLang(s.to_string())),
         })
     }
@@ -777,6 +810,7 @@ impl FromStr for ExtraCheckLang {
 enum ExtraCheckKind {
     Lint,
     Fmt,
+    Typecheck,
     /// Never parsed, but used as a placeholder for
     /// langs that never have a specific kind.
     None,
@@ -789,6 +823,7 @@ impl FromStr for ExtraCheckKind {
         Ok(match s {
             "lint" => Self::Lint,
             "fmt" => Self::Fmt,
+            "typecheck" => Self::Typecheck,
             _ => return Err(ExtraCheckParseError::UnknownKind(s.to_string())),
         })
     }
diff --git a/src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs b/src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs
new file mode 100644
index 00000000000..24be26ffbd9
--- /dev/null
+++ b/src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs
@@ -0,0 +1,141 @@
+//! Tidy check to ensure that rustdoc templates didn't forget a `{# #}` to strip extra whitespace
+//! characters.
+
+use std::ffi::OsStr;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use ignore::DirEntry;
+
+use crate::walk::walk_no_read;
+
+fn rustdoc_js_files(librustdoc_path: &Path) -> Vec<PathBuf> {
+    let mut files = Vec::new();
+    walk_no_read(
+        &[&librustdoc_path.join("html/static/js")],
+        |path, is_dir| is_dir || path.extension().is_none_or(|ext| ext != OsStr::new("js")),
+        &mut |path: &DirEntry| {
+            files.push(path.path().into());
+        },
+    );
+    return files;
+}
+
+fn run_eslint(args: &[PathBuf], config_folder: PathBuf) -> Result<(), super::Error> {
+    let mut child = Command::new("npx")
+        .arg("eslint")
+        .arg("-c")
+        .arg(config_folder.join(".eslintrc.js"))
+        .args(args)
+        .spawn()?;
+    match child.wait() {
+        Ok(exit_status) => {
+            if exit_status.success() {
+                return Ok(());
+            }
+            Err(super::Error::FailedCheck("eslint command failed"))
+        }
+        Err(error) => Err(super::Error::Generic(format!("eslint command failed: {error:?}"))),
+    }
+}
+
+fn get_eslint_version_inner(global: bool) -> Option<String> {
+    let mut command = Command::new("npm");
+    command.arg("list").arg("--parseable").arg("--long").arg("--depth=0");
+    if global {
+        command.arg("--global");
+    }
+    let output = command.output().ok()?;
+    let lines = String::from_utf8_lossy(&output.stdout);
+    lines.lines().find_map(|l| l.split(':').nth(1)?.strip_prefix("eslint@")).map(|v| v.to_owned())
+}
+
+fn get_eslint_version() -> Option<String> {
+    get_eslint_version_inner(false).or_else(|| get_eslint_version_inner(true))
+}
+
+pub(super) fn lint(
+    librustdoc_path: &Path,
+    tools_path: &Path,
+    src_path: &Path,
+) -> Result<(), super::Error> {
+    let eslint_version_path = src_path.join("ci/docker/host-x86_64/tidy/eslint.version");
+    let eslint_version = match std::fs::read_to_string(&eslint_version_path) {
+        Ok(version) => version.trim().to_string(),
+        Err(error) => {
+            eprintln!("failed to read `{}`: {error:?}", eslint_version_path.display());
+            return Err(error.into());
+        }
+    };
+    // Having the correct `eslint` version installed via `npm` isn't strictly necessary, since we're invoking it via `npx`,
+    // but this check allows the vast majority that is not working on the rustdoc frontend to avoid the penalty of running
+    // `eslint` in tidy. See also: https://github.com/rust-lang/rust/pull/142851
+    match get_eslint_version() {
+        Some(version) => {
+            if version != eslint_version {
+                // unfortunatly we can't use `Error::Version` here becuse `str::trim` isn't const and
+                // Version::required must be a static str
+                return Err(super::Error::Generic(format!(
+                    "⚠️ Installed version of eslint (`{version}`) is different than the \
+                     one used in the CI (`{eslint_version}`)\n\
+                    You can install this version using `npm update eslint` or by using \
+                    `npm install eslint@{eslint_version}`\n
+"
+                )));
+            }
+        }
+        None => {
+            //eprintln!("`eslint` doesn't seem to be installed. Skipping tidy check for JS files.");
+            //eprintln!("You can install it using `npm install eslint@{eslint_version}`");
+            return Err(super::Error::MissingReq(
+                "eslint",
+                "js lint checks",
+                Some(format!("You can install it using `npm install eslint@{eslint_version}`")),
+            ));
+        }
+    }
+    let files_to_check = rustdoc_js_files(librustdoc_path);
+    println!("Running eslint on rustdoc JS files");
+    run_eslint(&files_to_check, librustdoc_path.join("html/static"))?;
+
+    run_eslint(&[tools_path.join("rustdoc-js/tester.js")], tools_path.join("rustdoc-js"))?;
+    run_eslint(&[tools_path.join("rustdoc-gui/tester.js")], tools_path.join("rustdoc-gui"))?;
+    Ok(())
+}
+
+pub(super) fn typecheck(librustdoc_path: &Path) -> Result<(), super::Error> {
+    // use npx to ensure correct version
+    let mut child = Command::new("npx")
+        .arg("tsc")
+        .arg("-p")
+        .arg(librustdoc_path.join("html/static/js/tsconfig.json"))
+        .spawn()?;
+    match child.wait() {
+        Ok(exit_status) => {
+            if exit_status.success() {
+                return Ok(());
+            }
+            Err(super::Error::FailedCheck("tsc command failed"))
+        }
+        Err(error) => Err(super::Error::Generic(format!("tsc command failed: {error:?}"))),
+    }
+}
+
+pub(super) fn es_check(librustdoc_path: &Path) -> Result<(), super::Error> {
+    let files_to_check = rustdoc_js_files(librustdoc_path);
+    // use npx to ensure correct version
+    let mut cmd = Command::new("npx");
+    cmd.arg("es-check").arg("es2019");
+    for f in files_to_check {
+        cmd.arg(f);
+    }
+    match cmd.spawn()?.wait() {
+        Ok(exit_status) => {
+            if exit_status.success() {
+                return Ok(());
+            }
+            Err(super::Error::FailedCheck("es-check command failed"))
+        }
+        Err(error) => Err(super::Error::Generic(format!("es-check command failed: {error:?}"))),
+    }
+}
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index ade4055b5bd..4db74cbf61c 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -178,7 +178,6 @@ pub mod mir_opt_tests;
 pub mod pal;
 pub mod rustdoc_css_themes;
 pub mod rustdoc_gui_tests;
-pub mod rustdoc_js;
 pub mod rustdoc_json;
 pub mod rustdoc_templates;
 pub mod style;
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index 0f1116a632e..358a03dd18c 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -112,7 +112,6 @@ fn main() {
         check!(rustdoc_gui_tests, &tests_path);
         check!(rustdoc_css_themes, &librustdoc_path);
         check!(rustdoc_templates, &librustdoc_path);
-        check!(rustdoc_js, &librustdoc_path, &tools_path, &src_path);
         check!(rustdoc_json, &src_path, &ci_info);
         check!(known_bug, &crashes_path);
         check!(unknown_revision, &tests_path);
@@ -181,6 +180,9 @@ fn main() {
             &root_path,
             &output_directory,
             &ci_info,
+            &librustdoc_path,
+            &tools_path,
+            &src_path,
             bless,
             extra_checks,
             pos_args
diff --git a/src/tools/tidy/src/rustdoc_js.rs b/src/tools/tidy/src/rustdoc_js.rs
deleted file mode 100644
index 5737fcbafc0..00000000000
--- a/src/tools/tidy/src/rustdoc_js.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-//! Tidy check to ensure that rustdoc templates didn't forget a `{# #}` to strip extra whitespace
-//! characters.
-
-use std::ffi::OsStr;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-
-use ignore::DirEntry;
-
-use crate::walk::walk_no_read;
-
-fn run_eslint(args: &[PathBuf], config_folder: PathBuf, bad: &mut bool) {
-    let mut child = match Command::new("npx")
-        .arg("eslint")
-        .arg("-c")
-        .arg(config_folder.join(".eslintrc.js"))
-        .args(args)
-        .spawn()
-    {
-        Ok(child) => child,
-        Err(error) => {
-            *bad = true;
-            eprintln!("failed to run eslint: {error:?}");
-            return;
-        }
-    };
-    match child.wait() {
-        Ok(exit_status) => {
-            if exit_status.success() {
-                return;
-            }
-            eprintln!("eslint command failed");
-        }
-        Err(error) => eprintln!("eslint command failed: {error:?}"),
-    }
-    *bad = true;
-}
-
-fn get_eslint_version_inner(global: bool) -> Option<String> {
-    let mut command = Command::new("npm");
-    command.arg("list").arg("--parseable").arg("--long").arg("--depth=0");
-    if global {
-        command.arg("--global");
-    }
-    let output = command.output().ok()?;
-    let lines = String::from_utf8_lossy(&output.stdout);
-    lines.lines().find_map(|l| l.split(':').nth(1)?.strip_prefix("eslint@")).map(|v| v.to_owned())
-}
-
-fn get_eslint_version() -> Option<String> {
-    get_eslint_version_inner(false).or_else(|| get_eslint_version_inner(true))
-}
-
-pub fn check(librustdoc_path: &Path, tools_path: &Path, src_path: &Path, bad: &mut bool) {
-    let eslint_version_path = src_path.join("ci/docker/host-x86_64/tidy/eslint.version");
-    let eslint_version = match std::fs::read_to_string(&eslint_version_path) {
-        Ok(version) => version.trim().to_string(),
-        Err(error) => {
-            *bad = true;
-            eprintln!("failed to read `{}`: {error:?}", eslint_version_path.display());
-            return;
-        }
-    };
-    // Having the correct `eslint` version installed via `npm` isn't strictly necessary, since we're invoking it via `npx`,
-    // but this check allows the vast majority that is not working on the rustdoc frontend to avoid the penalty of running
-    // `eslint` in tidy. See also: https://github.com/rust-lang/rust/pull/142851
-    match get_eslint_version() {
-        Some(version) => {
-            if version != eslint_version {
-                *bad = true;
-                eprintln!(
-                    "⚠️ Installed version of eslint (`{version}`) is different than the \
-                     one used in the CI (`{eslint_version}`)",
-                );
-                eprintln!(
-                    "You can install this version using `npm update eslint` or by using \
-                     `npm install eslint@{eslint_version}`",
-                );
-                return;
-            }
-        }
-        None => {
-            eprintln!("`eslint` doesn't seem to be installed. Skipping tidy check for JS files.");
-            eprintln!("You can install it using `npm install eslint@{eslint_version}`");
-            return;
-        }
-    }
-    let mut files_to_check = Vec::new();
-    walk_no_read(
-        &[&librustdoc_path.join("html/static/js")],
-        |path, is_dir| is_dir || path.extension().is_none_or(|ext| ext != OsStr::new("js")),
-        &mut |path: &DirEntry| {
-            files_to_check.push(path.path().into());
-        },
-    );
-    println!("Running eslint on rustdoc JS files");
-    run_eslint(&files_to_check, librustdoc_path.join("html/static"), bad);
-
-    run_eslint(&[tools_path.join("rustdoc-js/tester.js")], tools_path.join("rustdoc-js"), bad);
-    run_eslint(&[tools_path.join("rustdoc-gui/tester.js")], tools_path.join("rustdoc-gui"), bad);
-}
-- 
cgit 1.4.1-3-g733a5


From 4bd3b74aa9ec4a21507d73f712186619baf93ba0 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Mon, 23 Jun 2025 12:57:16 -0500
Subject: update CI to use new tidy extra checks for rustdoc js

---
 src/ci/docker/host-x86_64/pr-check-1/Dockerfile | 5 +----
 src/ci/docker/host-x86_64/tidy/Dockerfile       | 2 +-
 2 files changed, 2 insertions(+), 5 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 8bbcc18e2be..e63a383ec99 100644
--- a/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
+++ b/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
@@ -52,7 +52,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 && \
-  # Runs checks to ensure that there are no issues in our JS code.
-  es-check es2019 ../src/librustdoc/html/static/js/*.js && \
-  tsc --project ../src/librustdoc/html/static/js/tsconfig.json
+  python3 ../x.py test collect-license-metadata
diff --git a/src/ci/docker/host-x86_64/tidy/Dockerfile b/src/ci/docker/host-x86_64/tidy/Dockerfile
index dbb950cbe0c..ee1ae5410ee 100644
--- a/src/ci/docker/host-x86_64/tidy/Dockerfile
+++ b/src/ci/docker/host-x86_64/tidy/Dockerfile
@@ -45,4 +45,4 @@ RUN bash -c 'npm install -g eslint@$(cat /tmp/eslint.version)'
 # 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 --stage 0 \
-  src/tools/tidy tidyselftest --extra-checks=py,cpp
+  src/tools/tidy tidyselftest --extra-checks=py,cpp,js
-- 
cgit 1.4.1-3-g733a5


From c8e2a65ed16b948819cee23d883d8e598665318b Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 27 Jun 2025 14:29:39 -0500
Subject: tidy: use a lockfile for js tools instead of npx

this makes us less vulnerable to MITM and supply chain attacks.

it also means that the CI scripts are no longer responsible for
tracking the versions of these tools.

it should also avoid the situation where local tsc and CI
disagree on the presense of errors due to them being different versions.
---
 .gitignore                                       |    2 -
 package-lock.json                                | 3232 ++++++++++++++++++++++
 package.json                                     |    9 +
 src/ci/docker/host-x86_64/pr-check-1/Dockerfile  |    4 -
 src/tools/tidy/src/ext_tool_checks.rs            |   13 +-
 src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs |  148 +-
 src/tools/tidy/src/main.rs                       |    1 -
 7 files changed, 3323 insertions(+), 86 deletions(-)
 create mode 100644 package-lock.json
 create mode 100644 package.json

diff --git a/.gitignore b/.gitignore
index a549b6e6e56..5988a64916a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -85,8 +85,6 @@ __pycache__/
 
 ## Node
 node_modules
-package-lock.json
-package.json
 /src/doc/rustc-dev-guide/mermaid.min.js
 
 ## Rustdoc GUI tests
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 00000000000..dbdd9c644f1
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,3232 @@
+{
+  "name": "rust",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "browser-ui-test": "^0.21.1",
+        "es-check": "^6.2.1",
+        "eslint": "^8.57.1",
+        "eslint-js": "github:eslint/js",
+        "typescript": "^5.8.3"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@caporal/core": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@caporal/core/-/core-2.0.7.tgz",
+      "integrity": "sha512-OvKBEidoXUGT28RP3USXFdLgiR5kGCHfRXR1uBQznyxBHaWjGcpH+G1chRqyIVT82pQoJiauOZRIGlrpyAbRYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/glob": "^7.1.1",
+        "@types/lodash": "^4.14.149",
+        "@types/node": "13.9.3",
+        "@types/table": "^5.0.0",
+        "@types/tabtab": "^3.0.1",
+        "@types/wrap-ansi": "^3.0.0",
+        "chalk": "^3.0.0",
+        "glob": "^7.1.6",
+        "lodash": "^4.17.21",
+        "table": "^5.4.6",
+        "tabtab": "^3.0.2",
+        "winston": "^3.2.1",
+        "wrap-ansi": "^6.2.0"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@colors/colors": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.6.0.tgz",
+      "integrity": "sha512-Ir+AOibqzrIsL6ajt3Rz3LskB7OiMVHqltZmspbW/TJuTVuyOMirVqAkjfY6JISiLHgyNqicAC8AyHHGzNd/dA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.1.90"
+      }
+    },
+    "node_modules/@dabh/diagnostics": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@dabh/diagnostics/-/diagnostics-2.0.3.tgz",
+      "integrity": "sha512-hrlQOIi7hAfzsMqlGSFyVucrx38O+j6wiGOf//H2ecvIEqYN4ADBSS2iLMh5UFyDunCNniUIPk/q3riFv45xRA==",
+      "license": "MIT",
+      "dependencies": {
+        "colorspace": "1.1.x",
+        "enabled": "2.0.x",
+        "kuler": "^2.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz",
+      "integrity": "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==",
+      "license": "MIT",
+      "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.12.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz",
+      "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz",
+      "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.12.4",
+        "debug": "^4.3.2",
+        "espree": "^9.6.0",
+        "globals": "^13.19.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.0",
+        "minimatch": "^3.1.2",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "8.57.1",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.1.tgz",
+      "integrity": "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@humanwhocodes/config-array": {
+      "version": "0.13.0",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz",
+      "integrity": "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==",
+      "deprecated": "Use @eslint/config-array instead",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanwhocodes/object-schema": "^2.0.3",
+        "debug": "^4.3.1",
+        "minimatch": "^3.0.5"
+      },
+      "engines": {
+        "node": ">=10.10.0"
+      }
+    },
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/object-schema": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz",
+      "integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==",
+      "deprecated": "Use @eslint/object-schema instead",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@puppeteer/browsers": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.3.0.tgz",
+      "integrity": "sha512-ioXoq9gPxkss4MYhD+SFaU9p1IHFUX0ILAWFPyjGaBdjLsYAlZw6j1iLA0N/m12uVHLFDfSYNF7EQccjinIMDA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "debug": "^4.3.5",
+        "extract-zip": "^2.0.1",
+        "progress": "^2.0.3",
+        "proxy-agent": "^6.4.0",
+        "semver": "^7.6.3",
+        "tar-fs": "^3.0.6",
+        "unbzip2-stream": "^1.4.3",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "browsers": "lib/cjs/main-cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@tootallnate/quickjs-emscripten": {
+      "version": "0.23.0",
+      "resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
+      "integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/glob": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.2.0.tgz",
+      "integrity": "sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/minimatch": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/lodash": {
+      "version": "4.17.20",
+      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.17.20.tgz",
+      "integrity": "sha512-H3MHACvFUEiujabxhaI/ImO6gUrd8oOurg7LQtS7mbwIXA/cUqWrvBsaeJ23aZEPk1TAYkurjfMbSELfoCXlGA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/minimatch": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-5.1.2.tgz",
+      "integrity": "sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "13.9.3",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-13.9.3.tgz",
+      "integrity": "sha512-01s+ac4qerwd6RHD+mVbOEsraDHSgUaefQlEdBbUolnQFjKwCr7luvAlEwW1RFojh67u0z4OUTjPn9LEl4zIkA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/table": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@types/table/-/table-5.0.0.tgz",
+      "integrity": "sha512-fQLtGLZXor264zUPWI95WNDsZ3QV43/c0lJpR/h1hhLJumXRmHNsrvBfEzW2YMhb0EWCsn4U6h82IgwsajAuTA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/tabtab": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/tabtab/-/tabtab-3.0.4.tgz",
+      "integrity": "sha512-gmh8JsmIYPGRqk8Xb4dmulV37TpLwg0Quo3GJ0LgEcl4v0O92F14PGebBd7LHv9GBEw2KbmBSrvU0/NzIy5AoA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/triple-beam": {
+      "version": "1.3.5",
+      "resolved": "https://registry.npmjs.org/@types/triple-beam/-/triple-beam-1.3.5.tgz",
+      "integrity": "sha512-6WaYesThRMCl19iryMYP7/x2OVgCtbIVflDGFpWnb9irXI3UjYE4AzmYuiUKY1AJstGijoY+MgUszMgRxIYTYw==",
+      "license": "MIT"
+    },
+    "node_modules/@types/wrap-ansi": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/@types/wrap-ansi/-/wrap-ansi-3.0.0.tgz",
+      "integrity": "sha512-ltIpx+kM7g/MLRZfkbL7EsCEjfzCcScLpkg37eXEtx5kmrAKBkTJwd1GIAjDSL8wTpM6Hzn5YO4pSb91BEwu1g==",
+      "license": "MIT"
+    },
+    "node_modules/@types/yauzl": {
+      "version": "2.10.3",
+      "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
+      "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+      "license": "ISC"
+    },
+    "node_modules/acorn": {
+      "version": "8.15.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-escapes": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.2.0.tgz",
+      "integrity": "sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "license": "Python-2.0"
+    },
+    "node_modules/ast-types": {
+      "version": "0.13.4",
+      "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz",
+      "integrity": "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/astral-regex": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-1.0.0.tgz",
+      "integrity": "sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/async": {
+      "version": "3.2.6",
+      "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+      "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
+      "license": "MIT"
+    },
+    "node_modules/b4a": {
+      "version": "1.6.7",
+      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.7.tgz",
+      "integrity": "sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "license": "MIT"
+    },
+    "node_modules/bare-events": {
+      "version": "2.6.0",
+      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.6.0.tgz",
+      "integrity": "sha512-EKZ5BTXYExaNqi3I3f9RtEsaI/xBSGjE0XZCZilPzFAV/goswFHuPd9jEZlPIZ/iNZJwDSao9qRiScySz7MbQg==",
+      "license": "Apache-2.0",
+      "optional": true
+    },
+    "node_modules/bare-fs": {
+      "version": "4.1.6",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.1.6.tgz",
+      "integrity": "sha512-25RsLF33BqooOEFNdMcEhMpJy8EoR88zSMrnOQOaM3USnOK2VmaJ1uaQEwPA6AQjrv1lXChScosN6CzbwbO9OQ==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-events": "^2.5.4",
+        "bare-path": "^3.0.0",
+        "bare-stream": "^2.6.4"
+      },
+      "engines": {
+        "bare": ">=1.16.0"
+      },
+      "peerDependencies": {
+        "bare-buffer": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-buffer": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-os": {
+      "version": "3.6.1",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.6.1.tgz",
+      "integrity": "sha512-uaIjxokhFidJP+bmmvKSgiMzj2sV5GPHaZVAIktcxcpCyBFFWO+YlikVAdhmUo2vYFvFhOXIAlldqV29L8126g==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "engines": {
+        "bare": ">=1.14.0"
+      }
+    },
+    "node_modules/bare-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz",
+      "integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "bare-os": "^3.0.1"
+      }
+    },
+    "node_modules/bare-stream": {
+      "version": "2.6.5",
+      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.6.5.tgz",
+      "integrity": "sha512-jSmxKJNJmHySi6hC42zlZnq00rga4jjxcgNZjY9N5WlOe/iOoGRtdwGsHzQv2RlH2KOYMwGUXhf2zXd32BA9RA==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "streamx": "^2.21.0"
+      },
+      "peerDependencies": {
+        "bare-buffer": "*",
+        "bare-events": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-buffer": {
+          "optional": true
+        },
+        "bare-events": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/basic-ftp": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.0.5.tgz",
+      "integrity": "sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "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==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/browser-ui-test": {
+      "version": "0.21.1",
+      "resolved": "https://registry.npmjs.org/browser-ui-test/-/browser-ui-test-0.21.1.tgz",
+      "integrity": "sha512-b3a9mhALAmbP+GifoN/c295RPyuyfIUFMz0DtlBHbeDW5PYQTMHZZJtm7R2UyP6JiIQSkR+7227sS3maMGMUTg==",
+      "license": "MIT",
+      "dependencies": {
+        "css-unit-converter": "^1.1.2",
+        "pngjs": "^3.4.0",
+        "puppeteer": "^22.15.0",
+        "readline-sync": "^1.4.10"
+      },
+      "bin": {
+        "browser-ui-test": "src/index.js"
+      }
+    },
+    "node_modules/buffer": {
+      "version": "5.7.1",
+      "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+      "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "base64-js": "^1.3.1",
+        "ieee754": "^1.1.13"
+      }
+    },
+    "node_modules/buffer-crc32": {
+      "version": "0.2.13",
+      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+      "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-3.0.0.tgz",
+      "integrity": "sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/chardet": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz",
+      "integrity": "sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==",
+      "license": "MIT"
+    },
+    "node_modules/chromium-bidi": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-0.6.3.tgz",
+      "integrity": "sha512-qXlsCmpCZJAnoTYI83Iu6EdYQpMYdVkCfq08KDh2pmlVqK5t5IA9mGs4/LwCwp4fqisSOMXZxP3HIh8w8aRn0A==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "mitt": "3.0.1",
+        "urlpattern-polyfill": "10.0.0",
+        "zod": "3.23.8"
+      },
+      "peerDependencies": {
+        "devtools-protocol": "*"
+      }
+    },
+    "node_modules/cli-cursor": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz",
+      "integrity": "sha512-8lgKz8LmCRYZZQDpRyT2m5rKJ08TnU4tR9FFFW2rxpxR1FzWi4PQ/NfyODchAatHaUgnSPVcx/R5w6NuTBzFiw==",
+      "license": "MIT",
+      "dependencies": {
+        "restore-cursor": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/cli-width": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.1.tgz",
+      "integrity": "sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw==",
+      "license": "ISC"
+    },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/cliui/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/cliui/node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cliui/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cliui/node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/color": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/color/-/color-3.2.1.tgz",
+      "integrity": "sha512-aBl7dZI9ENN6fUGC7mWpMTPNHmWUSNan9tuWN6ahh5ZLNk9baLJOnSMlrQkHcrfFgz2/RigjUVAjdx36VcemKA==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^1.9.3",
+        "color-string": "^1.6.0"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/color-string": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/color-string/-/color-string-1.9.1.tgz",
+      "integrity": "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "^1.0.0",
+        "simple-swizzle": "^0.2.2"
+      }
+    },
+    "node_modules/color/node_modules/color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "1.1.3"
+      }
+    },
+    "node_modules/color/node_modules/color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
+      "license": "MIT"
+    },
+    "node_modules/colorspace": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/colorspace/-/colorspace-1.1.4.tgz",
+      "integrity": "sha512-BgvKJiuVu1igBUF2kEjRCZXol6wiiGbY5ipL/oVPwm0BL9sIpMIzM8IK7vwuxIIzOXMV3Ey5w+vxhm0rR/TN8w==",
+      "license": "MIT",
+      "dependencies": {
+        "color": "^3.1.3",
+        "text-hex": "1.0.x"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "license": "MIT"
+    },
+    "node_modules/cosmiconfig": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-9.0.0.tgz",
+      "integrity": "sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==",
+      "license": "MIT",
+      "dependencies": {
+        "env-paths": "^2.2.1",
+        "import-fresh": "^3.3.0",
+        "js-yaml": "^4.1.0",
+        "parse-json": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/d-fischer"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.9.5"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/css-unit-converter": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/css-unit-converter/-/css-unit-converter-1.1.2.tgz",
+      "integrity": "sha512-IiJwMC8rdZE0+xiEZHeru6YoONC4rfPMqGm2W85jMIbkFvv5nFTwJVFHam2eFrN6txmoUYFAFXiv8ICVeTO0MA==",
+      "license": "MIT"
+    },
+    "node_modules/data-uri-to-buffer": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
+      "integrity": "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "license": "MIT"
+    },
+    "node_modules/degenerator": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz",
+      "integrity": "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ast-types": "^0.13.4",
+        "escodegen": "^2.1.0",
+        "esprima": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/devtools-protocol": {
+      "version": "0.0.1312386",
+      "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1312386.tgz",
+      "integrity": "sha512-DPnhUXvmvKT2dFA/j7B+riVLUt9Q6RKJlcppojL5CoRywJJKLDYnRlw0gTFKfgDPHP5E04UoB71SxoJlVZy8FA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/doctrine": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+      "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "esutils": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/emoji-regex": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
+      "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
+      "license": "MIT"
+    },
+    "node_modules/enabled": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/enabled/-/enabled-2.0.0.tgz",
+      "integrity": "sha512-AKrN98kuwOzMIdAizXGI86UFBoo26CL21UM763y1h/GMSJ4/OHU9k2YlsmBpyScFo/wbLzWQJBMCW4+IO3/+OQ==",
+      "license": "MIT"
+    },
+    "node_modules/end-of-stream": {
+      "version": "1.4.5",
+      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+      "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+      "license": "MIT",
+      "dependencies": {
+        "once": "^1.4.0"
+      }
+    },
+    "node_modules/env-paths": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
+      "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/error-ex": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
+      "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
+      "license": "MIT",
+      "dependencies": {
+        "is-arrayish": "^0.2.1"
+      }
+    },
+    "node_modules/es-check": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/es-check/-/es-check-6.2.1.tgz",
+      "integrity": "sha512-IPiRXUlwSTd2yMklIf9yEGe6GK5wCS8Sz1aTNHm1QSiYzI4aiq19giYbLi95tb+e0JJVKmcU0iQXQWW60a8V9A==",
+      "license": "MIT",
+      "dependencies": {
+        "@caporal/core": "^2.0.2",
+        "acorn": "^8.7.0",
+        "fast-glob": "^3.2.11"
+      },
+      "bin": {
+        "es-check": "index.js"
+      },
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/es6-promisify": {
+      "version": "6.1.1",
+      "resolved": "https://registry.npmjs.org/es6-promisify/-/es6-promisify-6.1.1.tgz",
+      "integrity": "sha512-HBL8I3mIki5C1Cc9QjKUenHtnG0A5/xA8Q/AllRcfiwl2CZFXGK7ddBiCoRwAix4i2KxcQfjtIVcrVbB3vbmwg==",
+      "license": "MIT"
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/escodegen": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz",
+      "integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esprima": "^4.0.1",
+        "estraverse": "^5.2.0",
+        "esutils": "^2.0.2"
+      },
+      "bin": {
+        "escodegen": "bin/escodegen.js",
+        "esgenerate": "bin/esgenerate.js"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "optionalDependencies": {
+        "source-map": "~0.6.1"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "8.57.1",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz",
+      "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==",
+      "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.2.0",
+        "@eslint-community/regexpp": "^4.6.1",
+        "@eslint/eslintrc": "^2.1.4",
+        "@eslint/js": "8.57.1",
+        "@humanwhocodes/config-array": "^0.13.0",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@nodelib/fs.walk": "^1.2.8",
+        "@ungap/structured-clone": "^1.2.0",
+        "ajv": "^6.12.4",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.2",
+        "debug": "^4.3.2",
+        "doctrine": "^3.0.0",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^7.2.2",
+        "eslint-visitor-keys": "^3.4.3",
+        "espree": "^9.6.1",
+        "esquery": "^1.4.2",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^6.0.1",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "globals": "^13.19.0",
+        "graphemer": "^1.4.0",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "is-path-inside": "^3.0.3",
+        "js-yaml": "^4.1.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "levn": "^0.4.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.2",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3",
+        "strip-ansi": "^6.0.1",
+        "text-table": "^0.2.0"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-js": {
+      "version": "1.0.0",
+      "resolved": "git+ssh://git@github.com/eslint/js.git#5bd12e3772d361af2c4bfad774ea7bfd9caae6bc",
+      "workspaces": [
+        "packages/*"
+      ]
+    },
+    "node_modules/eslint-scope": {
+      "version": "7.2.2",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz",
+      "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint/node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/espree": {
+      "version": "9.6.1",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz",
+      "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.9.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^3.4.1"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "license": "BSD-2-Clause",
+      "bin": {
+        "esparse": "bin/esparse.js",
+        "esvalidate": "bin/esvalidate.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
+      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/external-editor": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz",
+      "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==",
+      "license": "MIT",
+      "dependencies": {
+        "chardet": "^0.7.0",
+        "iconv-lite": "^0.4.24",
+        "tmp": "^0.0.33"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/extract-zip": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
+      "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "debug": "^4.1.1",
+        "get-stream": "^5.1.0",
+        "yauzl": "^2.10.0"
+      },
+      "bin": {
+        "extract-zip": "cli.js"
+      },
+      "engines": {
+        "node": ">= 10.17.0"
+      },
+      "optionalDependencies": {
+        "@types/yauzl": "^2.9.1"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT"
+    },
+    "node_modules/fast-fifo": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
+      "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==",
+      "license": "MIT"
+    },
+    "node_modules/fast-glob": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.stat": "^2.0.2",
+        "@nodelib/fs.walk": "^1.2.3",
+        "glob-parent": "^5.1.2",
+        "merge2": "^1.3.0",
+        "micromatch": "^4.0.8"
+      },
+      "engines": {
+        "node": ">=8.6.0"
+      }
+    },
+    "node_modules/fast-glob/node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "license": "MIT"
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "license": "MIT"
+    },
+    "node_modules/fastq": {
+      "version": "1.19.1",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
+      "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
+      "license": "ISC",
+      "dependencies": {
+        "reusify": "^1.0.4"
+      }
+    },
+    "node_modules/fd-slicer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
+      "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
+      "license": "MIT",
+      "dependencies": {
+        "pend": "~1.2.0"
+      }
+    },
+    "node_modules/fecha": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/fecha/-/fecha-4.2.3.tgz",
+      "integrity": "sha512-OP2IUU6HeYKJi3i0z4A19kHMQoLVs4Hc+DPqqxI2h/DPZHTm/vjsfC6P0b4jCMy14XizLBqvndQ+UilD7707Jw==",
+      "license": "MIT"
+    },
+    "node_modules/figures": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz",
+      "integrity": "sha512-Oa2M9atig69ZkfwiApY8F2Yy+tzMbazyvqv21R0NsSC8floSOC09BbT1ITWAdoMGQvJ/aZnR1KMwdx9tvHnTNA==",
+      "license": "MIT",
+      "dependencies": {
+        "escape-string-regexp": "^1.0.5"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/figures/node_modules/escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
+      "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==",
+      "license": "MIT",
+      "dependencies": {
+        "flat-cache": "^3.0.4"
+      },
+      "engines": {
+        "node": "^10.12.0 || >=12.0.0"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "license": "MIT",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat-cache": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz",
+      "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==",
+      "license": "MIT",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.3",
+        "rimraf": "^3.0.2"
+      },
+      "engines": {
+        "node": "^10.12.0 || >=12.0.0"
+      }
+    },
+    "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==",
+      "license": "ISC"
+    },
+    "node_modules/fn.name": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/fn.name/-/fn.name-1.1.0.tgz",
+      "integrity": "sha512-GRnmB5gPyJpAhTQdSZTSp9uaPSvl09KoYcMQtsB9rQoOmzs9dH6ffeccH+Z+cv6P68Hu5bC6JjRh4Ah/mHSNRw==",
+      "license": "MIT"
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "license": "ISC"
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/get-stream": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
+      "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
+      "license": "MIT",
+      "dependencies": {
+        "pump": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/get-uri": {
+      "version": "6.0.5",
+      "resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.5.tgz",
+      "integrity": "sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg==",
+      "license": "MIT",
+      "dependencies": {
+        "basic-ftp": "^5.0.2",
+        "data-uri-to-buffer": "^6.0.2",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/globals": {
+      "version": "13.24.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz",
+      "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==",
+      "license": "MIT",
+      "dependencies": {
+        "type-fest": "^0.20.2"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/graphemer": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
+      "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
+      "license": "MIT"
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/http-proxy-agent": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ieee754": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "license": "MIT",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "license": "ISC",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/inquirer": {
+      "version": "6.5.2",
+      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-6.5.2.tgz",
+      "integrity": "sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-escapes": "^3.2.0",
+        "chalk": "^2.4.2",
+        "cli-cursor": "^2.1.0",
+        "cli-width": "^2.0.0",
+        "external-editor": "^3.0.3",
+        "figures": "^2.0.0",
+        "lodash": "^4.17.12",
+        "mute-stream": "0.0.7",
+        "run-async": "^2.2.0",
+        "rxjs": "^6.4.0",
+        "string-width": "^2.1.0",
+        "strip-ansi": "^5.1.0",
+        "through": "^2.3.6"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/inquirer/node_modules/ansi-regex": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
+      "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/inquirer/node_modules/ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^1.9.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/inquirer/node_modules/chalk": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^3.2.1",
+        "escape-string-regexp": "^1.0.5",
+        "supports-color": "^5.3.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/inquirer/node_modules/color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "1.1.3"
+      }
+    },
+    "node_modules/inquirer/node_modules/color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
+      "license": "MIT"
+    },
+    "node_modules/inquirer/node_modules/escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/inquirer/node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/inquirer/node_modules/string-width": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
+      "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==",
+      "license": "MIT",
+      "dependencies": {
+        "is-fullwidth-code-point": "^2.0.0",
+        "strip-ansi": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/inquirer/node_modules/string-width/node_modules/ansi-regex": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.1.tgz",
+      "integrity": "sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/inquirer/node_modules/string-width/node_modules/strip-ansi": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
+      "integrity": "sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/inquirer/node_modules/strip-ansi": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+      "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/inquirer/node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/ip-address": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz",
+      "integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==",
+      "license": "MIT",
+      "dependencies": {
+        "jsbn": "1.1.0",
+        "sprintf-js": "^1.1.3"
+      },
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/is-arrayish": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
+      "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
+      "license": "MIT"
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+      "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/is-path-inside": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
+      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-stream": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
+      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "license": "ISC"
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/jsbn": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz",
+      "integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==",
+      "license": "MIT"
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+      "license": "MIT"
+    },
+    "node_modules/json-parse-even-better-errors": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
+      "license": "MIT"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "license": "MIT"
+    },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+      "license": "MIT"
+    },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+      "license": "MIT",
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
+    },
+    "node_modules/kuler": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/kuler/-/kuler-2.0.0.tgz",
+      "integrity": "sha512-Xq9nH7KlWZmXAtodXDDRE7vs6DU1gTU8zYDHDiWLSip45Egwq3plLHzPn27NgvzL2r1LMPC1vdqh98sQxtqj4A==",
+      "license": "MIT"
+    },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/lines-and-columns": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+      "license": "MIT"
+    },
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+      "license": "MIT"
+    },
+    "node_modules/logform": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/logform/-/logform-2.7.0.tgz",
+      "integrity": "sha512-TFYA4jnP7PVbmlBIfhlSe+WKxs9dklXMTEGcBCIvLhE/Tn3H6Gk1norupVW7m5Cnd4bLcr08AytbyV/xj7f/kQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@colors/colors": "1.6.0",
+        "@types/triple-beam": "^1.3.2",
+        "fecha": "^4.2.0",
+        "ms": "^2.1.1",
+        "safe-stable-stringify": "^2.3.1",
+        "triple-beam": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "7.18.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+      "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/merge2": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/micromatch": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+      "license": "MIT",
+      "dependencies": {
+        "braces": "^3.0.3",
+        "picomatch": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=8.6"
+      }
+    },
+    "node_modules/mimic-fn": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz",
+      "integrity": "sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/mitt": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
+      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
+      "license": "MIT"
+    },
+    "node_modules/mkdirp": {
+      "version": "0.5.6",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz",
+      "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==",
+      "license": "MIT",
+      "dependencies": {
+        "minimist": "^1.2.6"
+      },
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/mute-stream": {
+      "version": "0.0.7",
+      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz",
+      "integrity": "sha512-r65nCZhrbXXb6dXOACihYApHw2Q6pV0M3V0PSxd74N0+D8nzAdEAITq2oAjA1jVnKI+tGvEBUpqiMh0+rW6zDQ==",
+      "license": "ISC"
+    },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+      "license": "MIT"
+    },
+    "node_modules/netmask": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/netmask/-/netmask-2.0.2.tgz",
+      "integrity": "sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "license": "ISC",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/one-time": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/one-time/-/one-time-1.0.0.tgz",
+      "integrity": "sha512-5DXOiRKwuSEcQ/l0kGCF6Q3jcADFv5tSmRaJck/OqkVFcOzutB134KRSfF0xDrL39MNnqxbHBbUUcjZIhTgb2g==",
+      "license": "MIT",
+      "dependencies": {
+        "fn.name": "1.x.x"
+      }
+    },
+    "node_modules/onetime": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz",
+      "integrity": "sha512-oyyPpiMaKARvvcgip+JV+7zci5L8D1W9RZIz2l1o08AM3pfspitVWnPt3mzHcBPp12oYMTy0pqrFs/C+m3EwsQ==",
+      "license": "MIT",
+      "dependencies": {
+        "mimic-fn": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+      "license": "MIT",
+      "dependencies": {
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/os-tmpdir": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
+      "integrity": "sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/pac-proxy-agent": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz",
+      "integrity": "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==",
+      "license": "MIT",
+      "dependencies": {
+        "@tootallnate/quickjs-emscripten": "^0.23.0",
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "get-uri": "^6.0.1",
+        "http-proxy-agent": "^7.0.0",
+        "https-proxy-agent": "^7.0.6",
+        "pac-resolver": "^7.0.1",
+        "socks-proxy-agent": "^8.0.5"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/pac-resolver": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz",
+      "integrity": "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==",
+      "license": "MIT",
+      "dependencies": {
+        "degenerator": "^5.0.0",
+        "netmask": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "license": "MIT",
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/parse-json": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
+      "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.0.0",
+        "error-ex": "^1.3.1",
+        "json-parse-even-better-errors": "^2.3.0",
+        "lines-and-columns": "^1.1.6"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/pend": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+      "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/pngjs": {
+      "version": "3.4.0",
+      "resolved": "https://registry.npmjs.org/pngjs/-/pngjs-3.4.0.tgz",
+      "integrity": "sha512-NCrCHhWmnQklfH4MtJMRjZ2a8c80qXeMlQMv2uVp9ISJMTt562SbGd6n2oq0PaPgKm7Z6pL9E2UlLIhC+SHL3w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/progress": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+      "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/proxy-agent": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz",
+      "integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "http-proxy-agent": "^7.0.1",
+        "https-proxy-agent": "^7.0.6",
+        "lru-cache": "^7.14.1",
+        "pac-proxy-agent": "^7.1.0",
+        "proxy-from-env": "^1.1.0",
+        "socks-proxy-agent": "^8.0.5"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
+    "node_modules/pump": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz",
+      "integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==",
+      "license": "MIT",
+      "dependencies": {
+        "end-of-stream": "^1.1.0",
+        "once": "^1.3.1"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/puppeteer": {
+      "version": "22.15.0",
+      "resolved": "https://registry.npmjs.org/puppeteer/-/puppeteer-22.15.0.tgz",
+      "integrity": "sha512-XjCY1SiSEi1T7iSYuxS82ft85kwDJUS7wj1Z0eGVXKdtr5g4xnVcbjwxhq5xBnpK/E7x1VZZoJDxpjAOasHT4Q==",
+      "hasInstallScript": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@puppeteer/browsers": "2.3.0",
+        "cosmiconfig": "^9.0.0",
+        "devtools-protocol": "0.0.1312386",
+        "puppeteer-core": "22.15.0"
+      },
+      "bin": {
+        "puppeteer": "lib/esm/puppeteer/node/cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/puppeteer-core": {
+      "version": "22.15.0",
+      "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-22.15.0.tgz",
+      "integrity": "sha512-cHArnywCiAAVXa3t4GGL2vttNxh7GqXtIYGym99egkNJ3oG//wL9LkvO4WE8W1TJe95t1F1ocu9X4xWaGsOKOA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@puppeteer/browsers": "2.3.0",
+        "chromium-bidi": "0.6.3",
+        "debug": "^4.3.6",
+        "devtools-protocol": "0.0.1312386",
+        "ws": "^8.18.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/queue-microtask": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "license": "MIT",
+      "dependencies": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/readline-sync": {
+      "version": "1.4.10",
+      "resolved": "https://registry.npmjs.org/readline-sync/-/readline-sync-1.4.10.tgz",
+      "integrity": "sha512-gNva8/6UAe8QYepIQH/jQ2qn91Qj0B9sYjMBBs3QOB8F2CXcKgLxQaJRP76sWVRQt+QU+8fAkCbCvjjMFu7Ycw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/restore-cursor": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz",
+      "integrity": "sha512-6IzJLuGi4+R14vwagDHX+JrXmPVtPpn4mffDJ1UdR7/Edm87fl6yi8mMBIVvFtJaNTUvjughmW4hwLhRG7gC1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "onetime": "^2.0.0",
+        "signal-exit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/reusify": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+      "license": "MIT",
+      "engines": {
+        "iojs": ">=1.0.0",
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/rimraf": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+      "deprecated": "Rimraf versions prior to v4 are no longer supported",
+      "license": "ISC",
+      "dependencies": {
+        "glob": "^7.1.3"
+      },
+      "bin": {
+        "rimraf": "bin.js"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/run-async": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.4.1.tgz",
+      "integrity": "sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/run-parallel": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "queue-microtask": "^1.2.2"
+      }
+    },
+    "node_modules/rxjs": {
+      "version": "6.6.7",
+      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.6.7.tgz",
+      "integrity": "sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^1.9.0"
+      },
+      "engines": {
+        "npm": ">=2.0.0"
+      }
+    },
+    "node_modules/rxjs/node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "license": "0BSD"
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safe-stable-stringify": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-2.5.0.tgz",
+      "integrity": "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+      "license": "ISC"
+    },
+    "node_modules/simple-swizzle": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.2.tgz",
+      "integrity": "sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==",
+      "license": "MIT",
+      "dependencies": {
+        "is-arrayish": "^0.3.1"
+      }
+    },
+    "node_modules/simple-swizzle/node_modules/is-arrayish": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.2.tgz",
+      "integrity": "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==",
+      "license": "MIT"
+    },
+    "node_modules/slice-ansi": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-2.1.0.tgz",
+      "integrity": "sha512-Qu+VC3EwYLldKa1fCxuuvULvSJOKEgk9pi8dZeCVK7TqBfUNTH4sFkk4joj8afVSfAYgJoSOetjx9QWOJ5mYoQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^3.2.0",
+        "astral-regex": "^1.0.0",
+        "is-fullwidth-code-point": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/slice-ansi/node_modules/ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^1.9.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/slice-ansi/node_modules/color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "1.1.3"
+      }
+    },
+    "node_modules/slice-ansi/node_modules/color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
+      "license": "MIT"
+    },
+    "node_modules/smart-buffer": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+      "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/socks": {
+      "version": "2.8.6",
+      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.6.tgz",
+      "integrity": "sha512-pe4Y2yzru68lXCb38aAqRf5gvN8YdjP1lok5o0J7BOHljkyCGKVz7H3vpVIXKD27rj2giOJ7DwVyk/GWrPHDWA==",
+      "license": "MIT",
+      "dependencies": {
+        "ip-address": "^9.0.5",
+        "smart-buffer": "^4.2.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/socks-proxy-agent": {
+      "version": "8.0.5",
+      "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
+      "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "socks": "^2.8.3"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "license": "BSD-3-Clause",
+      "optional": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/sprintf-js": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
+      "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/stack-trace": {
+      "version": "0.0.10",
+      "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz",
+      "integrity": "sha512-KGzahc7puUKkzyMt+IqAep+TVNbKP+k2Lmwhub39m1AsTSkaDutx56aDCo+HLDzf/D26BIHTJWNiTG1KAJiQCg==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/streamx": {
+      "version": "2.22.1",
+      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.22.1.tgz",
+      "integrity": "sha512-znKXEBxfatz2GBNK02kRnCXjV+AA4kjZIUxeWSr3UGirZMJfTE9uiwKHobnbgxWyL/JWro8tTq+vOqAK1/qbSA==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-fifo": "^1.3.2",
+        "text-decoder": "^1.1.0"
+      },
+      "optionalDependencies": {
+        "bare-events": "^2.2.0"
+      }
+    },
+    "node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+      "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^7.0.1",
+        "is-fullwidth-code-point": "^2.0.0",
+        "strip-ansi": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/string-width/node_modules/ansi-regex": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
+      "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/string-width/node_modules/strip-ansi": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+      "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/table": {
+      "version": "5.4.6",
+      "resolved": "https://registry.npmjs.org/table/-/table-5.4.6.tgz",
+      "integrity": "sha512-wmEc8m4fjnob4gt5riFRtTu/6+4rSe12TpAELNSqHMfF3IqnA+CH37USM6/YR3qRZv7e56kAEAtd6nKZaxe0Ug==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "ajv": "^6.10.2",
+        "lodash": "^4.17.14",
+        "slice-ansi": "^2.1.0",
+        "string-width": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/tabtab": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/tabtab/-/tabtab-3.0.2.tgz",
+      "integrity": "sha512-jANKmUe0sIQc/zTALTBy186PoM/k6aPrh3A7p6AaAfF6WPSbTx1JYeGIGH162btpH+mmVEXln+UxwViZHO2Jhg==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.0.1",
+        "es6-promisify": "^6.0.0",
+        "inquirer": "^6.0.0",
+        "minimist": "^1.2.0",
+        "mkdirp": "^0.5.1",
+        "untildify": "^3.0.3"
+      }
+    },
+    "node_modules/tar-fs": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.0.tgz",
+      "integrity": "sha512-5Mty5y/sOF1YWj1J6GiBodjlDc05CUR8PKXrsnFAiSG0xA+GHeWLovaZPYUDXkH/1iKRf2+M5+OrRgzC7O9b7w==",
+      "license": "MIT",
+      "dependencies": {
+        "pump": "^3.0.0",
+        "tar-stream": "^3.1.5"
+      },
+      "optionalDependencies": {
+        "bare-fs": "^4.0.1",
+        "bare-path": "^3.0.0"
+      }
+    },
+    "node_modules/tar-stream": {
+      "version": "3.1.7",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.7.tgz",
+      "integrity": "sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==",
+      "license": "MIT",
+      "dependencies": {
+        "b4a": "^1.6.4",
+        "fast-fifo": "^1.2.0",
+        "streamx": "^2.15.0"
+      }
+    },
+    "node_modules/text-decoder": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz",
+      "integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "b4a": "^1.6.4"
+      }
+    },
+    "node_modules/text-hex": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/text-hex/-/text-hex-1.0.0.tgz",
+      "integrity": "sha512-uuVGNWzgJ4yhRaNSiubPY7OjISw4sw4E5Uv0wbjp+OzcbmVU/rsT8ujgcXJhn9ypzsgr5vlzpPqP+MBBKcGvbg==",
+      "license": "MIT"
+    },
+    "node_modules/text-table": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+      "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
+      "license": "MIT"
+    },
+    "node_modules/through": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
+      "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==",
+      "license": "MIT"
+    },
+    "node_modules/tmp": {
+      "version": "0.0.33",
+      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
+      "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==",
+      "license": "MIT",
+      "dependencies": {
+        "os-tmpdir": "~1.0.2"
+      },
+      "engines": {
+        "node": ">=0.6.0"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "license": "MIT",
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/triple-beam": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/triple-beam/-/triple-beam-1.4.1.tgz",
+      "integrity": "sha512-aZbgViZrg1QNcG+LULa7nhZpJTZSLm/mXnHXnbAbjmN5aSa0y7V+wvv6+4WaBtpISJzThKy+PIPxc1Nq1EJ9mg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/type-fest": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
+      "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.8.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
+      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/unbzip2-stream": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/unbzip2-stream/-/unbzip2-stream-1.4.3.tgz",
+      "integrity": "sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer": "^5.2.1",
+        "through": "^2.3.8"
+      }
+    },
+    "node_modules/untildify": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/untildify/-/untildify-3.0.3.tgz",
+      "integrity": "sha512-iSk/J8efr8uPT/Z4eSUywnqyrQU7DSdMfdqK4iWEaUVVmcP5JcnpRqmVMwcwcnmI1ATFNgC5V90u09tBynNFKA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/urlpattern-polyfill": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/urlpattern-polyfill/-/urlpattern-polyfill-10.0.0.tgz",
+      "integrity": "sha512-H/A06tKD7sS1O1X2SshBVeA5FLycRpjqiBeqGKmBwBDBy28EnRjORxTNe269KSSr5un5qyWi1iL61wLxpd+ZOg==",
+      "license": "MIT"
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "license": "MIT"
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/winston": {
+      "version": "3.17.0",
+      "resolved": "https://registry.npmjs.org/winston/-/winston-3.17.0.tgz",
+      "integrity": "sha512-DLiFIXYC5fMPxaRg832S6F5mJYvePtmO5G9v9IgUFPhXm9/GkXarH/TUrBAVzhTCzAj9anE/+GjrgXp/54nOgw==",
+      "license": "MIT",
+      "dependencies": {
+        "@colors/colors": "^1.6.0",
+        "@dabh/diagnostics": "^2.0.2",
+        "async": "^3.2.3",
+        "is-stream": "^2.0.0",
+        "logform": "^2.7.0",
+        "one-time": "^1.0.0",
+        "readable-stream": "^3.4.0",
+        "safe-stable-stringify": "^2.3.1",
+        "stack-trace": "0.0.x",
+        "triple-beam": "^1.3.0",
+        "winston-transport": "^4.9.0"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      }
+    },
+    "node_modules/winston-transport": {
+      "version": "4.9.0",
+      "resolved": "https://registry.npmjs.org/winston-transport/-/winston-transport-4.9.0.tgz",
+      "integrity": "sha512-8drMJ4rkgaPo1Me4zD/3WLfI/zPdA9o2IipKODunnGDcuqbHwjsbB79ylv04LCGGzU0xQ6vTznOMpQGaLhhm6A==",
+      "license": "MIT",
+      "dependencies": {
+        "logform": "^2.7.0",
+        "readable-stream": "^3.6.2",
+        "triple-beam": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      }
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/wrap-ansi": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
+      "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/wrap-ansi/node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "license": "ISC"
+    },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/yargs/node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/yargs/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/yauzl": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
+      "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-crc32": "~0.2.3",
+        "fd-slicer": "~1.1.0"
+      }
+    },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.23.8",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.23.8.tgz",
+      "integrity": "sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 00000000000..945f9a3ee87
--- /dev/null
+++ b/package.json
@@ -0,0 +1,9 @@
+{
+  "dependencies": {
+    "browser-ui-test": "^0.21.1",
+    "es-check": "^6.2.1",
+    "eslint": "^8.57.1",
+    "eslint-js": "github:eslint/js",
+    "typescript": "^5.8.3"
+  }
+}
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 e63a383ec99..d3c3cd1b63e 100644
--- a/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
+++ b/src/ci/docker/host-x86_64/pr-check-1/Dockerfile
@@ -27,10 +27,6 @@ COPY scripts/nodejs.sh /scripts/
 RUN sh /scripts/nodejs.sh /node
 ENV PATH="/node/bin:${PATH}"
 
-# Install es-check
-# Pin its version to prevent unrelated CI failures due to future es-check versions.
-RUN npm install es-check@6.1.1 eslint@8.6.0 typescript@5.7.3 -g
-
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
diff --git a/src/tools/tidy/src/ext_tool_checks.rs b/src/tools/tidy/src/ext_tool_checks.rs
index 03ed0b00f3e..911d4daae5c 100644
--- a/src/tools/tidy/src/ext_tool_checks.rs
+++ b/src/tools/tidy/src/ext_tool_checks.rs
@@ -50,7 +50,6 @@ pub fn check(
     ci_info: &CiInfo,
     librustdoc_path: &Path,
     tools_path: &Path,
-    src_path: &Path,
     bless: bool,
     extra_checks: Option<&str>,
     pos_args: &[String],
@@ -62,7 +61,6 @@ pub fn check(
         ci_info,
         librustdoc_path,
         tools_path,
-        src_path,
         bless,
         extra_checks,
         pos_args,
@@ -77,7 +75,6 @@ fn check_impl(
     ci_info: &CiInfo,
     librustdoc_path: &Path,
     tools_path: &Path,
-    src_path: &Path,
     bless: bool,
     extra_checks: Option<&str>,
     pos_args: &[String],
@@ -295,13 +292,17 @@ fn check_impl(
         spellcheck_runner(&args)?;
     }
 
+    if js_lint || js_typecheck {
+        rustdoc_js::npm_install(root_path, outdir)?;
+    }
+
     if js_lint {
-        rustdoc_js::lint(librustdoc_path, tools_path, src_path)?;
-        rustdoc_js::es_check(librustdoc_path)?;
+        rustdoc_js::lint(outdir, librustdoc_path, tools_path)?;
+        rustdoc_js::es_check(outdir, librustdoc_path)?;
     }
 
     if js_typecheck {
-        rustdoc_js::typecheck(librustdoc_path)?;
+        rustdoc_js::typecheck(outdir, librustdoc_path)?;
     }
 
     Ok(())
diff --git a/src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs b/src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs
index 24be26ffbd9..f96c9612a8e 100644
--- a/src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs
+++ b/src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs
@@ -3,12 +3,61 @@
 
 use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
-use std::process::Command;
+use std::process::{Child, Command};
+use std::{fs, io};
 
+use build_helper::ci::CiEnv;
 use ignore::DirEntry;
 
 use crate::walk::walk_no_read;
 
+fn node_module_bin(outdir: &Path, name: &str) -> PathBuf {
+    outdir.join("node_modules/.bin").join(name)
+}
+
+fn spawn_cmd(cmd: &mut Command) -> Result<Child, io::Error> {
+    cmd.spawn().map_err(|err| {
+        eprintln!("unable to run {cmd:?} due to {err:?}");
+        err
+    })
+}
+
+/// install all js dependencies from package.json.
+pub(super) fn npm_install(root_path: &Path, outdir: &Path) -> Result<(), super::Error> {
+    let copy_to_build = |p| {
+        fs::copy(root_path.join(p), outdir.join(p)).map_err(|e| {
+            eprintln!("unable to copy {p:?} to build directory: {e:?}");
+            e
+        })
+    };
+    // copy stuff to the output directory to make node_modules get put there.
+    copy_to_build("package.json")?;
+    copy_to_build("package-lock.json")?;
+
+    let mut cmd = Command::new("npm");
+    if CiEnv::is_ci() {
+        // `npm ci` redownloads every time and thus is too slow for local development.
+        cmd.arg("ci");
+    } else {
+        cmd.arg("install");
+    }
+    // disable a bunch of things we don't want.
+    // this makes tidy output less noisy, and also significantly improves runtime
+    // of repeated tidy invokations.
+    cmd.args(&["--audit=false", "--save=false", "--fund=false"]);
+    cmd.current_dir(outdir);
+    let mut child = spawn_cmd(&mut cmd)?;
+    match child.wait() {
+        Ok(exit_status) => {
+            if exit_status.success() {
+                return Ok(());
+            }
+            Err(super::Error::FailedCheck("npm install"))
+        }
+        Err(error) => Err(super::Error::Generic(format!("npm install failed: {error:?}"))),
+    }
+}
+
 fn rustdoc_js_files(librustdoc_path: &Path) -> Vec<PathBuf> {
     let mut files = Vec::new();
     walk_no_read(
@@ -21,13 +70,13 @@ fn rustdoc_js_files(librustdoc_path: &Path) -> Vec<PathBuf> {
     return files;
 }
 
-fn run_eslint(args: &[PathBuf], config_folder: PathBuf) -> Result<(), super::Error> {
-    let mut child = Command::new("npx")
-        .arg("eslint")
-        .arg("-c")
-        .arg(config_folder.join(".eslintrc.js"))
-        .args(args)
-        .spawn()?;
+fn run_eslint(outdir: &Path, args: &[PathBuf], config_folder: PathBuf) -> Result<(), super::Error> {
+    let mut child = spawn_cmd(
+        Command::new(node_module_bin(outdir, "eslint"))
+            .arg("-c")
+            .arg(config_folder.join(".eslintrc.js"))
+            .args(args),
+    )?;
     match child.wait() {
         Ok(exit_status) => {
             if exit_status.success() {
@@ -39,77 +88,31 @@ fn run_eslint(args: &[PathBuf], config_folder: PathBuf) -> Result<(), super::Err
     }
 }
 
-fn get_eslint_version_inner(global: bool) -> Option<String> {
-    let mut command = Command::new("npm");
-    command.arg("list").arg("--parseable").arg("--long").arg("--depth=0");
-    if global {
-        command.arg("--global");
-    }
-    let output = command.output().ok()?;
-    let lines = String::from_utf8_lossy(&output.stdout);
-    lines.lines().find_map(|l| l.split(':').nth(1)?.strip_prefix("eslint@")).map(|v| v.to_owned())
-}
-
-fn get_eslint_version() -> Option<String> {
-    get_eslint_version_inner(false).or_else(|| get_eslint_version_inner(true))
-}
-
 pub(super) fn lint(
+    outdir: &Path,
     librustdoc_path: &Path,
     tools_path: &Path,
-    src_path: &Path,
 ) -> Result<(), super::Error> {
-    let eslint_version_path = src_path.join("ci/docker/host-x86_64/tidy/eslint.version");
-    let eslint_version = match std::fs::read_to_string(&eslint_version_path) {
-        Ok(version) => version.trim().to_string(),
-        Err(error) => {
-            eprintln!("failed to read `{}`: {error:?}", eslint_version_path.display());
-            return Err(error.into());
-        }
-    };
-    // Having the correct `eslint` version installed via `npm` isn't strictly necessary, since we're invoking it via `npx`,
-    // but this check allows the vast majority that is not working on the rustdoc frontend to avoid the penalty of running
-    // `eslint` in tidy. See also: https://github.com/rust-lang/rust/pull/142851
-    match get_eslint_version() {
-        Some(version) => {
-            if version != eslint_version {
-                // unfortunatly we can't use `Error::Version` here becuse `str::trim` isn't const and
-                // Version::required must be a static str
-                return Err(super::Error::Generic(format!(
-                    "⚠️ Installed version of eslint (`{version}`) is different than the \
-                     one used in the CI (`{eslint_version}`)\n\
-                    You can install this version using `npm update eslint` or by using \
-                    `npm install eslint@{eslint_version}`\n
-"
-                )));
-            }
-        }
-        None => {
-            //eprintln!("`eslint` doesn't seem to be installed. Skipping tidy check for JS files.");
-            //eprintln!("You can install it using `npm install eslint@{eslint_version}`");
-            return Err(super::Error::MissingReq(
-                "eslint",
-                "js lint checks",
-                Some(format!("You can install it using `npm install eslint@{eslint_version}`")),
-            ));
-        }
-    }
     let files_to_check = rustdoc_js_files(librustdoc_path);
     println!("Running eslint on rustdoc JS files");
-    run_eslint(&files_to_check, librustdoc_path.join("html/static"))?;
+    run_eslint(outdir, &files_to_check, librustdoc_path.join("html/static"))?;
 
-    run_eslint(&[tools_path.join("rustdoc-js/tester.js")], tools_path.join("rustdoc-js"))?;
-    run_eslint(&[tools_path.join("rustdoc-gui/tester.js")], tools_path.join("rustdoc-gui"))?;
+    run_eslint(outdir, &[tools_path.join("rustdoc-js/tester.js")], tools_path.join("rustdoc-js"))?;
+    run_eslint(
+        outdir,
+        &[tools_path.join("rustdoc-gui/tester.js")],
+        tools_path.join("rustdoc-gui"),
+    )?;
     Ok(())
 }
 
-pub(super) fn typecheck(librustdoc_path: &Path) -> Result<(), super::Error> {
+pub(super) fn typecheck(outdir: &Path, librustdoc_path: &Path) -> Result<(), super::Error> {
     // use npx to ensure correct version
-    let mut child = Command::new("npx")
-        .arg("tsc")
-        .arg("-p")
-        .arg(librustdoc_path.join("html/static/js/tsconfig.json"))
-        .spawn()?;
+    let mut child = spawn_cmd(
+        Command::new(node_module_bin(outdir, "tsc"))
+            .arg("-p")
+            .arg(librustdoc_path.join("html/static/js/tsconfig.json")),
+    )?;
     match child.wait() {
         Ok(exit_status) => {
             if exit_status.success() {
@@ -121,15 +124,14 @@ pub(super) fn typecheck(librustdoc_path: &Path) -> Result<(), super::Error> {
     }
 }
 
-pub(super) fn es_check(librustdoc_path: &Path) -> Result<(), super::Error> {
+pub(super) fn es_check(outdir: &Path, librustdoc_path: &Path) -> Result<(), super::Error> {
     let files_to_check = rustdoc_js_files(librustdoc_path);
-    // use npx to ensure correct version
-    let mut cmd = Command::new("npx");
-    cmd.arg("es-check").arg("es2019");
+    let mut cmd = Command::new(node_module_bin(outdir, "es-check"));
+    cmd.arg("es2019");
     for f in files_to_check {
         cmd.arg(f);
     }
-    match cmd.spawn()?.wait() {
+    match spawn_cmd(&mut cmd)?.wait() {
         Ok(exit_status) => {
             if exit_status.success() {
                 return Ok(());
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index 358a03dd18c..13b20f33bd0 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -182,7 +182,6 @@ fn main() {
             &ci_info,
             &librustdoc_path,
             &tools_path,
-            &src_path,
             bless,
             extra_checks,
             pos_args
-- 
cgit 1.4.1-3-g733a5


From 2ffa711ea5ad140635042b09eb5b739f90248a67 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 10 Jul 2025 19:36:27 -0500
Subject: REUSE.toml: add new package.json and package-lock.json

---
 REUSE.toml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/REUSE.toml b/REUSE.toml
index 027b4ccbe25..13aa3e0a411 100644
--- a/REUSE.toml
+++ b/REUSE.toml
@@ -37,6 +37,8 @@ path = [
     "rust-bors.toml",
     "triagebot.toml",
     "typos.toml",
+    "package.json",
+    "package-lock.json",
     "x",
     "x.ps1",
     "x.py",
-- 
cgit 1.4.1-3-g733a5


From ca39010d3e7d3c512d5d8df8094862ffa146837f Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sat, 19 Jul 2025 14:52:31 -0500
Subject: update completions

---
 src/etc/completions/x.fish    | 4 ----
 src/etc/completions/x.ps1     | 4 ----
 src/etc/completions/x.py.fish | 4 ----
 src/etc/completions/x.py.ps1  | 4 ----
 src/etc/completions/x.py.zsh  | 4 ----
 src/etc/completions/x.zsh     | 4 ----
 6 files changed, 24 deletions(-)

diff --git a/src/etc/completions/x.fish b/src/etc/completions/x.fish
index f4e7413ca53..a5e5bb8f09e 100644
--- a/src/etc/completions/x.fish
+++ b/src/etc/completions/x.fish
@@ -299,11 +299,7 @@ complete -c x -n "__fish_x_using_subcommand doc" -l skip-std-check-if-no-downloa
 complete -c x -n "__fish_x_using_subcommand doc" -s h -l help -d 'Print help (see more with \'--help\')'
 complete -c x -n "__fish_x_using_subcommand test" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r
 complete -c x -n "__fish_x_using_subcommand test" -l compiletest-rustc-args -d 'extra options to pass the compiler when running compiletest tests' -r
-<<<<<<< HEAD
 complete -c x -n "__fish_x_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck, spellcheck)' -r
-=======
-complete -c x -n "__fish_x_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck)' -r
->>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
 complete -c x -n "__fish_x_using_subcommand test" -l compare-mode -d 'mode describing what file the actual ui output will be compared to' -r
 complete -c x -n "__fish_x_using_subcommand test" -l pass -d 'force {check,build,run}-pass tests to this mode' -r
 complete -c x -n "__fish_x_using_subcommand test" -l run -d 'whether to execute run-* tests' -r
diff --git a/src/etc/completions/x.ps1 b/src/etc/completions/x.ps1
index fced6587d32..4fee3bc0a86 100644
--- a/src/etc/completions/x.ps1
+++ b/src/etc/completions/x.ps1
@@ -345,11 +345,7 @@ Register-ArgumentCompleter -Native -CommandName 'x' -ScriptBlock {
         'x;test' {
             [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)')
             [CompletionResult]::new('--compiletest-rustc-args', '--compiletest-rustc-args', [CompletionResultType]::ParameterName, 'extra options to pass the compiler when running compiletest tests')
-<<<<<<< HEAD
             [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck, spellcheck)')
-=======
-            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck)')
->>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
             [CompletionResult]::new('--compare-mode', '--compare-mode', [CompletionResultType]::ParameterName, 'mode describing what file the actual ui output will be compared to')
             [CompletionResult]::new('--pass', '--pass', [CompletionResultType]::ParameterName, 'force {check,build,run}-pass tests to this mode')
             [CompletionResult]::new('--run', '--run', [CompletionResultType]::ParameterName, 'whether to execute run-* tests')
diff --git a/src/etc/completions/x.py.fish b/src/etc/completions/x.py.fish
index c80750111f7..e2e6ae05ee0 100644
--- a/src/etc/completions/x.py.fish
+++ b/src/etc/completions/x.py.fish
@@ -299,11 +299,7 @@ complete -c x.py -n "__fish_x.py_using_subcommand doc" -l skip-std-check-if-no-d
 complete -c x.py -n "__fish_x.py_using_subcommand doc" -s h -l help -d 'Print help (see more with \'--help\')'
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l compiletest-rustc-args -d 'extra options to pass the compiler when running compiletest tests' -r
-<<<<<<< HEAD
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck, spellcheck)' -r
-=======
-complete -c x.py -n "__fish_x.py_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck)' -r
->>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l compare-mode -d 'mode describing what file the actual ui output will be compared to' -r
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l pass -d 'force {check,build,run}-pass tests to this mode' -r
 complete -c x.py -n "__fish_x.py_using_subcommand test" -l run -d 'whether to execute run-* tests' -r
diff --git a/src/etc/completions/x.py.ps1 b/src/etc/completions/x.py.ps1
index dfb6482b41c..ea3aacc21c7 100644
--- a/src/etc/completions/x.py.ps1
+++ b/src/etc/completions/x.py.ps1
@@ -345,11 +345,7 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
         'x.py;test' {
             [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)')
             [CompletionResult]::new('--compiletest-rustc-args', '--compiletest-rustc-args', [CompletionResultType]::ParameterName, 'extra options to pass the compiler when running compiletest tests')
-<<<<<<< HEAD
             [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck, spellcheck)')
-=======
-            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell, cpp, cpp:fmt, js, js:lint, js:typecheck)')
->>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
             [CompletionResult]::new('--compare-mode', '--compare-mode', [CompletionResultType]::ParameterName, 'mode describing what file the actual ui output will be compared to')
             [CompletionResult]::new('--pass', '--pass', [CompletionResultType]::ParameterName, 'force {check,build,run}-pass tests to this mode')
             [CompletionResult]::new('--run', '--run', [CompletionResultType]::ParameterName, 'whether to execute run-* tests')
diff --git a/src/etc/completions/x.py.zsh b/src/etc/completions/x.py.zsh
index 8ccc7a7091c..32e986ad141 100644
--- a/src/etc/completions/x.py.zsh
+++ b/src/etc/completions/x.py.zsh
@@ -345,11 +345,7 @@ _arguments "${_arguments_options[@]}" : \
 _arguments "${_arguments_options[@]}" : \
 '*--test-args=[extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)]:ARGS:_default' \
 '*--compiletest-rustc-args=[extra options to pass the compiler when running compiletest tests]:ARGS:_default' \
-<<<<<<< HEAD
 '--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, cpp, cpp\:fmt, js, js\:lint, js\:typecheck, spellcheck)]:EXTRA_CHECKS:_default' \
-=======
-'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, cpp, cpp\:fmt, js, js\:lint, js\:typecheck)]:EXTRA_CHECKS:_default' \
->>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
 '--compare-mode=[mode describing what file the actual ui output will be compared to]:COMPARE MODE:_default' \
 '--pass=[force {check,build,run}-pass tests to this mode]:check | build | run:_default' \
 '--run=[whether to execute run-* tests]:auto | always | never:_default' \
diff --git a/src/etc/completions/x.zsh b/src/etc/completions/x.zsh
index 8c00abb7b21..65995553276 100644
--- a/src/etc/completions/x.zsh
+++ b/src/etc/completions/x.zsh
@@ -345,11 +345,7 @@ _arguments "${_arguments_options[@]}" : \
 _arguments "${_arguments_options[@]}" : \
 '*--test-args=[extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)]:ARGS:_default' \
 '*--compiletest-rustc-args=[extra options to pass the compiler when running compiletest tests]:ARGS:_default' \
-<<<<<<< HEAD
 '--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, cpp, cpp\:fmt, js, js\:lint, js\:typecheck, spellcheck)]:EXTRA_CHECKS:_default' \
-=======
-'--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell, cpp, cpp\:fmt, js, js\:lint, js\:typecheck)]:EXTRA_CHECKS:_default' \
->>>>>>> 98204a1f527 (bootstrap: js:es-lint was removed, remove it from the docs)
 '--compare-mode=[mode describing what file the actual ui output will be compared to]:COMPARE MODE:_default' \
 '--pass=[force {check,build,run}-pass tests to this mode]:check | build | run:_default' \
 '--run=[whether to execute run-* tests]:auto | always | never:_default' \
-- 
cgit 1.4.1-3-g733a5


From c6d50eaa497ef0c3013d21f23cd85e6e97c32c2c Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sat, 19 Jul 2025 14:56:42 -0500
Subject: integrate build_helper::npm into js checks and package.json usage

---
 src/build_helper/src/npm.rs                      | 43 +++++++++++++++---------
 src/tools/rustdoc-gui-test/src/main.rs           |  6 ++--
 src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs | 39 +++------------------
 3 files changed, 34 insertions(+), 54 deletions(-)

diff --git a/src/build_helper/src/npm.rs b/src/build_helper/src/npm.rs
index dedef40978d..86cf6183bd0 100644
--- a/src/build_helper/src/npm.rs
+++ b/src/build_helper/src/npm.rs
@@ -3,23 +3,34 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::{fs, io};
 
-/// Install an exact package version, and return the path of `node_modules`.
-pub fn install_one(
-    out_dir: &Path,
-    npm_bin: &Path,
-    pkg_name: &str,
-    pkg_version: &str,
-) -> Result<PathBuf, io::Error> {
+use crate::ci::CiEnv;
+
+/// Install all the npm deps, and return the path of `node_modules`.
+pub fn install(src_root_path: &Path, out_dir: &Path, npm: &Path) -> Result<PathBuf, io::Error> {
     let nm_path = out_dir.join("node_modules");
-    let _ = fs::create_dir(&nm_path);
-    let mut child = Command::new(npm_bin)
-        .arg("install")
-        .arg("--audit=false")
-        .arg("--fund=false")
-        .arg(format!("{pkg_name}@{pkg_version}"))
-        .current_dir(out_dir)
-        .spawn()?;
-    let exit_status = child.wait()?;
+    let copy_to_build = |p| {
+        fs::copy(src_root_path.join(p), out_dir.join(p)).map_err(|e| {
+            eprintln!("unable to copy {p:?} to build directory: {e:?}");
+            e
+        })
+    };
+    // copy stuff to the output directory to make node_modules get put there.
+    copy_to_build("package.json")?;
+    copy_to_build("package-lock.json")?;
+
+    let mut cmd = Command::new(npm);
+    if CiEnv::is_ci() {
+        // `npm ci` redownloads every time and thus is too slow for local development.
+        cmd.arg("ci");
+    } else {
+        cmd.arg("install");
+    }
+    // disable a bunch of things we don't want.
+    // this makes tidy output less noisy, and also significantly improves runtime
+    // of repeated tidy invokations.
+    cmd.args(&["--audit=false", "--save=false", "--fund=false"]);
+    cmd.current_dir(out_dir);
+    let exit_status = cmd.spawn()?.wait()?;
     if !exit_status.success() {
         eprintln!("npm install did not exit successfully");
         return Err(io::Error::other(Box::<dyn Error + Send + Sync>::from(format!(
diff --git a/src/tools/rustdoc-gui-test/src/main.rs b/src/tools/rustdoc-gui-test/src/main.rs
index 5b86bea8932..42feae8c208 100644
--- a/src/tools/rustdoc-gui-test/src/main.rs
+++ b/src/tools/rustdoc-gui-test/src/main.rs
@@ -65,10 +65,8 @@ fn main() -> Result<(), ()> {
         }
     }
 
-    // FIXME(binarycat): once we get package.json in version control, this should be updated to install via that instead
-    let local_node_modules =
-        npm::install_one(&config.out_dir, &config.npm, "browser-ui-test", "0.21.1")
-            .expect("unable to install browser-ui-test");
+    let local_node_modules = npm::install(&config.rust_src, &config.out_dir, &config.npm)
+        .expect("unable to install browser-ui-test");
 
     let mut command = Command::new(&config.nodejs);
 
diff --git a/src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs b/src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs
index f96c9612a8e..c1a62cedd33 100644
--- a/src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs
+++ b/src/tools/tidy/src/ext_tool_checks/rustdoc_js.rs
@@ -2,11 +2,11 @@
 //! characters.
 
 use std::ffi::OsStr;
+use std::io;
 use std::path::{Path, PathBuf};
 use std::process::{Child, Command};
-use std::{fs, io};
 
-use build_helper::ci::CiEnv;
+use build_helper::npm;
 use ignore::DirEntry;
 
 use crate::walk::walk_no_read;
@@ -24,38 +24,9 @@ fn spawn_cmd(cmd: &mut Command) -> Result<Child, io::Error> {
 
 /// install all js dependencies from package.json.
 pub(super) fn npm_install(root_path: &Path, outdir: &Path) -> Result<(), super::Error> {
-    let copy_to_build = |p| {
-        fs::copy(root_path.join(p), outdir.join(p)).map_err(|e| {
-            eprintln!("unable to copy {p:?} to build directory: {e:?}");
-            e
-        })
-    };
-    // copy stuff to the output directory to make node_modules get put there.
-    copy_to_build("package.json")?;
-    copy_to_build("package-lock.json")?;
-
-    let mut cmd = Command::new("npm");
-    if CiEnv::is_ci() {
-        // `npm ci` redownloads every time and thus is too slow for local development.
-        cmd.arg("ci");
-    } else {
-        cmd.arg("install");
-    }
-    // disable a bunch of things we don't want.
-    // this makes tidy output less noisy, and also significantly improves runtime
-    // of repeated tidy invokations.
-    cmd.args(&["--audit=false", "--save=false", "--fund=false"]);
-    cmd.current_dir(outdir);
-    let mut child = spawn_cmd(&mut cmd)?;
-    match child.wait() {
-        Ok(exit_status) => {
-            if exit_status.success() {
-                return Ok(());
-            }
-            Err(super::Error::FailedCheck("npm install"))
-        }
-        Err(error) => Err(super::Error::Generic(format!("npm install failed: {error:?}"))),
-    }
+    // FIXME(lolbinarycat): make this obey build.npm bootstrap option
+    npm::install(root_path, outdir, Path::new("npm"))?;
+    Ok(())
 }
 
 fn rustdoc_js_files(librustdoc_path: &Path) -> Vec<PathBuf> {
-- 
cgit 1.4.1-3-g733a5


From ca01e7de6fae15337df4b612869353523b3c947d Mon Sep 17 00:00:00 2001
From: Nurzhan Sakén <nurzhan.sakenov@gmail.com>
Date: Mon, 7 Jul 2025 22:48:18 +0400
Subject: Stabilize `const_float_round_methods`

---
 library/core/src/num/f128.rs   |  6 ------
 library/core/src/num/f16.rs    |  6 ------
 library/core/src/num/f32.rs    |  6 ------
 library/core/src/num/f64.rs    |  6 ------
 library/coretests/tests/lib.rs |  1 -
 library/std/src/lib.rs         |  1 -
 library/std/src/num/f32.rs     | 12 ++++++------
 library/std/src/num/f64.rs     | 12 ++++++------
 8 files changed, 12 insertions(+), 38 deletions(-)

diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 4c09c930c79..69e6c100e76 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -1448,7 +1448,6 @@ impl f128 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f128", issue = "116909")]
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn floor(self) -> f128 {
         // SAFETY: intrinsic with no preconditions
@@ -1478,7 +1477,6 @@ impl f128 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f128", issue = "116909")]
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn ceil(self) -> f128 {
         // SAFETY: intrinsic with no preconditions
@@ -1514,7 +1512,6 @@ impl f128 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f128", issue = "116909")]
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn round(self) -> f128 {
         // SAFETY: intrinsic with no preconditions
@@ -1548,7 +1545,6 @@ impl f128 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f128", issue = "116909")]
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn round_ties_even(self) -> f128 {
         intrinsics::round_ties_even_f128(self)
@@ -1580,7 +1576,6 @@ impl f128 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f128", issue = "116909")]
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn trunc(self) -> f128 {
         // SAFETY: intrinsic with no preconditions
@@ -1611,7 +1606,6 @@ impl f128 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f128", issue = "116909")]
     #[rustc_const_unstable(feature = "f128", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn fract(self) -> f128 {
         self - self.trunc()
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 1d98a485c4f..b66cef03d20 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -1424,7 +1424,6 @@ impl f16 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f16", issue = "116909")]
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn floor(self) -> f16 {
         // SAFETY: intrinsic with no preconditions
@@ -1454,7 +1453,6 @@ impl f16 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f16", issue = "116909")]
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn ceil(self) -> f16 {
         // SAFETY: intrinsic with no preconditions
@@ -1490,7 +1488,6 @@ impl f16 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f16", issue = "116909")]
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn round(self) -> f16 {
         // SAFETY: intrinsic with no preconditions
@@ -1524,7 +1521,6 @@ impl f16 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f16", issue = "116909")]
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn round_ties_even(self) -> f16 {
         intrinsics::round_ties_even_f16(self)
@@ -1556,7 +1552,6 @@ impl f16 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f16", issue = "116909")]
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn trunc(self) -> f16 {
         // SAFETY: intrinsic with no preconditions
@@ -1587,7 +1582,6 @@ impl f16 {
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f16", issue = "116909")]
     #[rustc_const_unstable(feature = "f16", issue = "116909")]
-    // #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn fract(self) -> f16 {
         self - self.trunc()
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index b460c7d0205..f8344da79ad 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -1591,7 +1591,6 @@ pub mod math {
     /// [`f32::floor`]: ../../../std/primitive.f32.html#method.floor
     #[inline]
     #[unstable(feature = "core_float_math", issue = "137578")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn floor(x: f32) -> f32 {
         // SAFETY: intrinsic with no preconditions
@@ -1622,7 +1621,6 @@ pub mod math {
     #[doc(alias = "ceiling")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[unstable(feature = "core_float_math", issue = "137578")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     pub const fn ceil(x: f32) -> f32 {
         // SAFETY: intrinsic with no preconditions
         unsafe { intrinsics::ceilf32(x) }
@@ -1657,7 +1655,6 @@ pub mod math {
     #[inline]
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     pub const fn round(x: f32) -> f32 {
         // SAFETY: intrinsic with no preconditions
         unsafe { intrinsics::roundf32(x) }
@@ -1691,7 +1688,6 @@ pub mod math {
     #[inline]
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     pub const fn round_ties_even(x: f32) -> f32 {
         intrinsics::round_ties_even_f32(x)
     }
@@ -1722,7 +1718,6 @@ pub mod math {
     #[doc(alias = "truncate")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[unstable(feature = "core_float_math", issue = "137578")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     pub const fn trunc(x: f32) -> f32 {
         // SAFETY: intrinsic with no preconditions
         unsafe { intrinsics::truncf32(x) }
@@ -1752,7 +1747,6 @@ pub mod math {
     /// [`f32::fract`]: ../../../std/primitive.f32.html#method.fract
     #[inline]
     #[unstable(feature = "core_float_math", issue = "137578")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn fract(x: f32) -> f32 {
         x - trunc(x)
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index 3cd079b84eb..93da63c896e 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -1589,7 +1589,6 @@ pub mod math {
     /// [`f64::floor`]: ../../../std/primitive.f64.html#method.floor
     #[inline]
     #[unstable(feature = "core_float_math", issue = "137578")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn floor(x: f64) -> f64 {
         // SAFETY: intrinsic with no preconditions
@@ -1619,7 +1618,6 @@ pub mod math {
     #[inline]
     #[doc(alias = "ceiling")]
     #[unstable(feature = "core_float_math", issue = "137578")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn ceil(x: f64) -> f64 {
         // SAFETY: intrinsic with no preconditions
@@ -1654,7 +1652,6 @@ pub mod math {
     /// [`f64::round`]: ../../../std/primitive.f64.html#method.round
     #[inline]
     #[unstable(feature = "core_float_math", issue = "137578")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn round(x: f64) -> f64 {
         // SAFETY: intrinsic with no preconditions
@@ -1688,7 +1685,6 @@ pub mod math {
     /// [`f64::round_ties_even`]: ../../../std/primitive.f64.html#method.round_ties_even
     #[inline]
     #[unstable(feature = "core_float_math", issue = "137578")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn round_ties_even(x: f64) -> f64 {
         intrinsics::round_ties_even_f64(x)
@@ -1719,7 +1715,6 @@ pub mod math {
     #[inline]
     #[doc(alias = "truncate")]
     #[unstable(feature = "core_float_math", issue = "137578")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn trunc(x: f64) -> f64 {
         // SAFETY: intrinsic with no preconditions
@@ -1750,7 +1745,6 @@ pub mod math {
     /// [`f64::fract`]: ../../../std/primitive.f64.html#method.fract
     #[inline]
     #[unstable(feature = "core_float_math", issue = "137578")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub const fn fract(x: f64) -> f64 {
         x - trunc(x)
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index e2249bd7f6a..4cfac9ecc2a 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -19,7 +19,6 @@
 #![feature(const_deref)]
 #![feature(const_destruct)]
 #![feature(const_eval_select)]
-#![feature(const_float_round_methods)]
 #![feature(const_ops)]
 #![feature(const_ref_cell)]
 #![feature(const_trait_impl)]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 311b2cb9323..323742a75b0 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -329,7 +329,6 @@
 #![feature(bstr_internals)]
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
-#![feature(const_float_round_methods)]
 #![feature(core_intrinsics)]
 #![feature(core_io_borrowed_buf)]
 #![feature(duration_constants)]
diff --git a/library/std/src/num/f32.rs b/library/std/src/num/f32.rs
index e79ec2ae966..2bff73add33 100644
--- a/library/std/src/num/f32.rs
+++ b/library/std/src/num/f32.rs
@@ -44,7 +44,7 @@ impl f32 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn floor(self) -> f32 {
         core::f32::math::floor(self)
@@ -67,7 +67,7 @@ impl f32 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn ceil(self) -> f32 {
         core::f32::math::ceil(self)
@@ -96,7 +96,7 @@ impl f32 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn round(self) -> f32 {
         core::f32::math::round(self)
@@ -123,7 +123,7 @@ impl f32 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "round_ties_even", since = "1.77.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn round_ties_even(self) -> f32 {
         core::f32::math::round_ties_even(self)
@@ -149,7 +149,7 @@ impl f32 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn trunc(self) -> f32 {
         core::f32::math::trunc(self)
@@ -173,7 +173,7 @@ impl f32 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn fract(self) -> f32 {
         core::f32::math::fract(self)
diff --git a/library/std/src/num/f64.rs b/library/std/src/num/f64.rs
index 853417825f9..b71e319f407 100644
--- a/library/std/src/num/f64.rs
+++ b/library/std/src/num/f64.rs
@@ -44,7 +44,7 @@ impl f64 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn floor(self) -> f64 {
         core::f64::math::floor(self)
@@ -67,7 +67,7 @@ impl f64 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn ceil(self) -> f64 {
         core::f64::math::ceil(self)
@@ -96,7 +96,7 @@ impl f64 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn round(self) -> f64 {
         core::f64::math::round(self)
@@ -123,7 +123,7 @@ impl f64 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "round_ties_even", since = "1.77.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn round_ties_even(self) -> f64 {
         core::f64::math::round_ties_even(self)
@@ -149,7 +149,7 @@ impl f64 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn trunc(self) -> f64 {
         core::f64::math::trunc(self)
@@ -173,7 +173,7 @@ impl f64 {
     #[rustc_allow_incoherent_impl]
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_float_round_methods", issue = "141555")]
+    #[rustc_const_stable(feature = "const_float_round_methods", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub const fn fract(self) -> f64 {
         core::f64::math::fract(self)
-- 
cgit 1.4.1-3-g733a5


From caf4f111bc371d148eb6b2e01dcadc90b4a8b877 Mon Sep 17 00:00:00 2001
From: Nurzhan Sakén <nurzhan.sakenov@gmail.com>
Date: Mon, 7 Jul 2025 23:23:11 +0400
Subject: Add `#[rustc_intrinsic_const_stable_indirect]` to float rounding
 intrinsics

---
 library/core/src/intrinsics/mod.rs | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index f90e6851d1f..106cc725fee 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -1379,6 +1379,7 @@ pub unsafe fn fmuladdf128(a: f128, b: f128, c: f128) -> f128;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::floor`](../../std/primitive.f16.html#method.floor)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn floorf16(x: f16) -> f16;
@@ -1386,6 +1387,7 @@ pub const unsafe fn floorf16(x: f16) -> f16;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::floor`](../../std/primitive.f32.html#method.floor)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn floorf32(x: f32) -> f32;
@@ -1393,6 +1395,7 @@ pub const unsafe fn floorf32(x: f32) -> f32;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::floor`](../../std/primitive.f64.html#method.floor)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn floorf64(x: f64) -> f64;
@@ -1400,6 +1403,7 @@ pub const unsafe fn floorf64(x: f64) -> f64;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::floor`](../../std/primitive.f128.html#method.floor)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn floorf128(x: f128) -> f128;
@@ -1408,6 +1412,7 @@ pub const unsafe fn floorf128(x: f128) -> f128;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::ceil`](../../std/primitive.f16.html#method.ceil)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn ceilf16(x: f16) -> f16;
@@ -1415,6 +1420,7 @@ pub const unsafe fn ceilf16(x: f16) -> f16;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::ceil`](../../std/primitive.f32.html#method.ceil)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn ceilf32(x: f32) -> f32;
@@ -1422,6 +1428,7 @@ pub const unsafe fn ceilf32(x: f32) -> f32;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::ceil`](../../std/primitive.f64.html#method.ceil)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn ceilf64(x: f64) -> f64;
@@ -1429,6 +1436,7 @@ pub const unsafe fn ceilf64(x: f64) -> f64;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::ceil`](../../std/primitive.f128.html#method.ceil)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn ceilf128(x: f128) -> f128;
@@ -1437,6 +1445,7 @@ pub const unsafe fn ceilf128(x: f128) -> f128;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::trunc`](../../std/primitive.f16.html#method.trunc)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn truncf16(x: f16) -> f16;
@@ -1444,6 +1453,7 @@ pub const unsafe fn truncf16(x: f16) -> f16;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::trunc`](../../std/primitive.f32.html#method.trunc)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn truncf32(x: f32) -> f32;
@@ -1451,6 +1461,7 @@ pub const unsafe fn truncf32(x: f32) -> f32;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::trunc`](../../std/primitive.f64.html#method.trunc)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn truncf64(x: f64) -> f64;
@@ -1458,6 +1469,7 @@ pub const unsafe fn truncf64(x: f64) -> f64;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::trunc`](../../std/primitive.f128.html#method.trunc)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn truncf128(x: f128) -> f128;
@@ -1467,6 +1479,7 @@ pub const unsafe fn truncf128(x: f128) -> f128;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::round_ties_even`](../../std/primitive.f16.html#method.round_ties_even)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const fn round_ties_even_f16(x: f16) -> f16;
@@ -1476,6 +1489,7 @@ pub const fn round_ties_even_f16(x: f16) -> f16;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::round_ties_even`](../../std/primitive.f32.html#method.round_ties_even)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const fn round_ties_even_f32(x: f32) -> f32;
@@ -1485,6 +1499,7 @@ pub const fn round_ties_even_f32(x: f32) -> f32;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::round_ties_even`](../../std/primitive.f64.html#method.round_ties_even)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const fn round_ties_even_f64(x: f64) -> f64;
@@ -1494,6 +1509,7 @@ pub const fn round_ties_even_f64(x: f64) -> f64;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::round_ties_even`](../../std/primitive.f128.html#method.round_ties_even)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const fn round_ties_even_f128(x: f128) -> f128;
@@ -1502,6 +1518,7 @@ pub const fn round_ties_even_f128(x: f128) -> f128;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::round`](../../std/primitive.f16.html#method.round)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn roundf16(x: f16) -> f16;
@@ -1509,6 +1526,7 @@ pub const unsafe fn roundf16(x: f16) -> f16;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::round`](../../std/primitive.f32.html#method.round)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn roundf32(x: f32) -> f32;
@@ -1516,6 +1534,7 @@ pub const unsafe fn roundf32(x: f32) -> f32;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::round`](../../std/primitive.f64.html#method.round)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn roundf64(x: f64) -> f64;
@@ -1523,6 +1542,7 @@ pub const unsafe fn roundf64(x: f64) -> f64;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::round`](../../std/primitive.f128.html#method.round)
+#[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub const unsafe fn roundf128(x: f128) -> f128;
-- 
cgit 1.4.1-3-g733a5


From 2f14d0a65d7ec8ee35e7f25ddd996ae40615a2a3 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 19 Jul 2025 22:29:13 +0200
Subject: Add code comment explaining better what `Row.name` is for doc aliases

---
 src/librustdoc/html/static/js/rustdoc.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/librustdoc/html/static/js/rustdoc.d.ts b/src/librustdoc/html/static/js/rustdoc.d.ts
index 9ce24d1c06f..a9589764547 100644
--- a/src/librustdoc/html/static/js/rustdoc.d.ts
+++ b/src/librustdoc/html/static/js/rustdoc.d.ts
@@ -219,6 +219,8 @@ declare namespace rustdoc {
         crate: string,
         descShard: SearchDescShard,
         id: number,
+        // This is the name of the item. For doc aliases, if you want the name of the aliased
+        // item, take a look at `Row.original.name`.
         name: string,
         normalizedName: string,
         word: string,
-- 
cgit 1.4.1-3-g733a5


From 14d097f6418eacf58e300abfb1531111192e9767 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Fri, 18 Jul 2025 17:19:33 -0700
Subject: Give a message with a span on validation error

---
 compiler/rustc_mir_transform/src/validate.rs     | 18 ++++++++++--------
 src/tools/miri/tests/panic/mir-validation.stderr | 14 ++++++++++----
 tests/ui/mir/validate/critical-edge.rs           |  4 ++--
 3 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index cbb9bbfd12f..659ca4df159 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -119,14 +119,16 @@ impl<'a, 'tcx> CfgChecker<'a, 'tcx> {
     #[track_caller]
     fn fail(&self, location: Location, msg: impl AsRef<str>) {
         // We might see broken MIR when other errors have already occurred.
-        assert!(
-            self.tcx.dcx().has_errors().is_some(),
-            "broken MIR in {:?} ({}) at {:?}:\n{}",
-            self.body.source.instance,
-            self.when,
-            location,
-            msg.as_ref(),
-        );
+        if self.tcx.dcx().has_errors().is_none() {
+            span_bug!(
+                self.body.source_info(location).span,
+                "broken MIR in {:?} ({}) at {:?}:\n{}",
+                self.body.source.instance,
+                self.when,
+                location,
+                msg.as_ref(),
+            );
+        }
     }
 
     fn check_edge(&mut self, location: Location, bb: BasicBlock, edge_kind: EdgeKind) {
diff --git a/src/tools/miri/tests/panic/mir-validation.stderr b/src/tools/miri/tests/panic/mir-validation.stderr
index dc70d129da3..f801ac907e6 100644
--- a/src/tools/miri/tests/panic/mir-validation.stderr
+++ b/src/tools/miri/tests/panic/mir-validation.stderr
@@ -1,11 +1,15 @@
+error: internal compiler error: compiler/rustc_mir_transform/src/validate.rs:LL:CC: broken MIR in Item(DefId) (after phase change to runtime-optimized) at bb0[1]:
+                                place (*(_2.0: *mut i32)) has deref as a later projection (it is only permitted as the first projection)
+  --> tests/panic/mir-validation.rs:LL:CC
+   |
+LL |             *(tuple.0) = 1;
+   |             ^^^^^^^^^^^^^^
+
 
 thread 'rustc' panicked at compiler/rustc_mir_transform/src/validate.rs:LL:CC:
-broken MIR in Item(DefId) (after phase change to runtime-optimized) at bb0[1]:
-place (*(_2.0: *mut i32)) has deref as a later projection (it is only permitted as the first projection)
+Box<dyn Any>
 stack backtrace:
 
-error: the compiler unexpectedly panicked. this is a bug.
-
 
 
 
@@ -20,3 +24,5 @@ LL |     extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/mir/validate/critical-edge.rs b/tests/ui/mir/validate/critical-edge.rs
index 2a3bf6a6181..7fe3891d642 100644
--- a/tests/ui/mir/validate/critical-edge.rs
+++ b/tests/ui/mir/validate/critical-edge.rs
@@ -21,6 +21,8 @@ pub fn f(a: u32) -> u32 {
         }
         bb1 = {
             Call(RET = f(1), ReturnTo(bb2), UnwindTerminate(ReasonAbi))
+//~^ ERROR broken MIR in Item
+//~| ERROR encountered critical edge in `Call` terminator
         }
 
         bb2 = {
@@ -29,5 +31,3 @@ pub fn f(a: u32) -> u32 {
         }
     }
 }
-
-//~? RAW encountered critical edge in `Call` terminator
-- 
cgit 1.4.1-3-g733a5


From 8f77d5463a7e6906b7ac44ee235969a7758ef1ed Mon Sep 17 00:00:00 2001
From: Rémy Rakic <remy.rakic+github@gmail.com>
Date: Sat, 19 Jul 2025 19:39:27 +0000
Subject: add non-regression test for issue 144168

---
 .../resolve/underscore-bindings-disambiguators.rs  | 27 +++++++++
 .../underscore-bindings-disambiguators.stderr      | 70 ++++++++++++++++++++++
 2 files changed, 97 insertions(+)
 create mode 100644 tests/ui/resolve/underscore-bindings-disambiguators.rs
 create mode 100644 tests/ui/resolve/underscore-bindings-disambiguators.stderr

diff --git a/tests/ui/resolve/underscore-bindings-disambiguators.rs b/tests/ui/resolve/underscore-bindings-disambiguators.rs
new file mode 100644
index 00000000000..8c89b39f859
--- /dev/null
+++ b/tests/ui/resolve/underscore-bindings-disambiguators.rs
@@ -0,0 +1,27 @@
+// Regression test for issue #144168 where some `_` bindings were incorrectly only allowed once per
+// module, failing with "error[E0428]: the name `_` is defined multiple times".
+
+// This weird/complex setup is reduced from `zerocopy-0.8.25` where the issue was encountered.
+
+#![crate_type = "lib"]
+
+macro_rules! impl_for_transmute_from {
+    () => {
+        const _: () = {};
+    };
+}
+
+mod impls {
+    use super::*;
+    impl_for_transmute_from!();
+    impl_for_transmute_from!();
+    const _: () = todo!(); //~ ERROR: evaluation panicked
+    const _: () = todo!(); //~ ERROR: evaluation panicked
+    const _: () = todo!(); //~ ERROR: evaluation panicked
+    const _: () = todo!(); //~ ERROR: evaluation panicked
+    const _: () = todo!(); //~ ERROR: evaluation panicked
+}
+use X as Y; //~ ERROR: unresolved import
+use Z as W; //~ ERROR: unresolved import
+
+const _: () = todo!(); //~ ERROR: evaluation panicked
diff --git a/tests/ui/resolve/underscore-bindings-disambiguators.stderr b/tests/ui/resolve/underscore-bindings-disambiguators.stderr
new file mode 100644
index 00000000000..0c8081a0c56
--- /dev/null
+++ b/tests/ui/resolve/underscore-bindings-disambiguators.stderr
@@ -0,0 +1,70 @@
+error[E0432]: unresolved import `X`
+  --> $DIR/underscore-bindings-disambiguators.rs:24:5
+   |
+LL | use X as Y;
+   |     -^^^^^
+   |     |
+   |     no `X` in the root
+   |     help: a similar name exists in the module: `_`
+
+error[E0432]: unresolved import `Z`
+  --> $DIR/underscore-bindings-disambiguators.rs:25:5
+   |
+LL | use Z as W;
+   |     -^^^^^
+   |     |
+   |     no `Z` in the root
+   |     help: a similar name exists in the module: `_`
+
+error[E0080]: evaluation panicked: not yet implemented
+  --> $DIR/underscore-bindings-disambiguators.rs:18:19
+   |
+LL |     const _: () = todo!();
+   |                   ^^^^^^^ evaluation of `impls::_` failed here
+   |
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0080]: evaluation panicked: not yet implemented
+  --> $DIR/underscore-bindings-disambiguators.rs:19:19
+   |
+LL |     const _: () = todo!();
+   |                   ^^^^^^^ evaluation of `impls::_` failed here
+   |
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0080]: evaluation panicked: not yet implemented
+  --> $DIR/underscore-bindings-disambiguators.rs:20:19
+   |
+LL |     const _: () = todo!();
+   |                   ^^^^^^^ evaluation of `impls::_` failed here
+   |
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0080]: evaluation panicked: not yet implemented
+  --> $DIR/underscore-bindings-disambiguators.rs:21:19
+   |
+LL |     const _: () = todo!();
+   |                   ^^^^^^^ evaluation of `impls::_` failed here
+   |
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0080]: evaluation panicked: not yet implemented
+  --> $DIR/underscore-bindings-disambiguators.rs:22:19
+   |
+LL |     const _: () = todo!();
+   |                   ^^^^^^^ evaluation of `impls::_` failed here
+   |
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0080]: evaluation panicked: not yet implemented
+  --> $DIR/underscore-bindings-disambiguators.rs:27:15
+   |
+LL | const _: () = todo!();
+   |               ^^^^^^^ evaluation of `_` failed here
+   |
+   = note: this error originates in the macro `todo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 8 previous errors
+
+Some errors have detailed explanations: E0080, E0432.
+For more information about an error, try `rustc --explain E0080`.
-- 
cgit 1.4.1-3-g733a5


From db1449aed549ea8f7f4b1809cf262e70dbf00eeb Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Sat, 19 Jul 2025 22:05:25 +0000
Subject: Initialize mingw for the runner's user

---
 .github/workflows/ci.yml        | 5 -----
 src/ci/scripts/install-mingw.sh | 5 +++++
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index dc8ac539a3a..e92afc14c20 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -182,11 +182,6 @@ jobs:
       - name: install MinGW
         run: src/ci/scripts/install-mingw.sh
 
-      # Workaround for spurious ci failures after mingw install
-      # see https://rust-lang.zulipchat.com/#narrow/channel/242791-t-infra/topic/Spurious.20bors.20CI.20failures/near/528915775
-      - name: ensure home dir exists
-        run: mkdir -p ~
-
       - name: install ninja
         run: src/ci/scripts/install-ninja.sh
 
diff --git a/src/ci/scripts/install-mingw.sh b/src/ci/scripts/install-mingw.sh
index ad852071f29..ed87628659b 100755
--- a/src/ci/scripts/install-mingw.sh
+++ b/src/ci/scripts/install-mingw.sh
@@ -43,4 +43,9 @@ if isWindows && isKnownToBeMingwBuild; then
     curl -o mingw.7z "${MIRRORS_BASE}/${mingw_archive}"
     7z x -y mingw.7z > /dev/null
     ciCommandAddPath "$(cygpath -m "$(pwd)/${mingw_dir}/bin")"
+
+    # Initialize mingw for the user.
+    # This should be done by github but isn't for some reason.
+    # (see https://github.com/actions/runner-images/issues/12600)
+    /c/msys64/usr/bin/bash -lc ' '
 fi
-- 
cgit 1.4.1-3-g733a5


From a6c7ceaae3a918caf7b2e4443441e781405af926 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Sun, 20 Jul 2025 01:20:09 +0300
Subject: Fix search of raw labels and lifetimes

It used to search for `'foo` which won't find `'r#foo`, now we search for `foo` instead.
---
 .../rust-analyzer/crates/ide-db/src/search.rs      |  9 +++--
 .../rust-analyzer/crates/ide/src/references.rs     | 38 ++++++++++++++++++++++
 2 files changed, 45 insertions(+), 2 deletions(-)

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 4efb83ba323..9cf0bcf9190 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/search.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/search.rs
@@ -531,7 +531,7 @@ impl<'a> FindUsages<'a> {
         node.token_at_offset(offset)
             .find(|it| {
                 // `name` is stripped of raw ident prefix. See the comment on name retrieval below.
-                it.text().trim_start_matches("r#") == name
+                it.text().trim_start_matches('\'').trim_start_matches("r#") == name
             })
             .into_iter()
             .flat_map(move |token| {
@@ -938,7 +938,12 @@ impl<'a> FindUsages<'a> {
                     })
                 };
                 // We need to search without the `r#`, hence `as_str` access.
-                self.def.name(sema.db).or_else(self_kw_refs).map(|it| it.as_str().to_smolstr())
+                // We strip `'` from lifetimes and labels as otherwise they may not match with raw-escaped ones,
+                // e.g. if we search `'foo` we won't find `'r#foo`.
+                self.def
+                    .name(sema.db)
+                    .or_else(self_kw_refs)
+                    .map(|it| it.as_str().trim_start_matches('\'').to_smolstr())
             }
         };
         let name = match &name {
diff --git a/src/tools/rust-analyzer/crates/ide/src/references.rs b/src/tools/rust-analyzer/crates/ide/src/references.rs
index fe874bc99b4..86b88a17c75 100644
--- a/src/tools/rust-analyzer/crates/ide/src/references.rs
+++ b/src/tools/rust-analyzer/crates/ide/src/references.rs
@@ -3088,4 +3088,42 @@ fn main() {
             "#]],
         );
     }
+
+    #[test]
+    fn raw_labels_and_lifetimes() {
+        check(
+            r#"
+fn foo<'r#fn>(s: &'r#fn str) {
+    let _a: &'r#fn str = s;
+    let _b: &'r#fn str;
+    'r#break$0: {
+        break 'r#break;
+    }
+}
+        "#,
+            expect![[r#"
+                'r#break Label FileId(0) 87..96 87..95
+
+                FileId(0) 113..121
+            "#]],
+        );
+        check(
+            r#"
+fn foo<'r#fn$0>(s: &'r#fn str) {
+    let _a: &'r#fn str = s;
+    let _b: &'r#fn str;
+    'r#break: {
+        break 'r#break;
+    }
+}
+        "#,
+            expect![[r#"
+                'r#fn LifetimeParam FileId(0) 7..12
+
+                FileId(0) 18..23
+                FileId(0) 44..49
+                FileId(0) 72..77
+            "#]],
+        );
+    }
 }
-- 
cgit 1.4.1-3-g733a5


From 3e5cf9ab86273df68a50e1069555ac74f5e74661 Mon Sep 17 00:00:00 2001
From: github-actions <github-actions@github.com>
Date: Sun, 20 Jul 2025 00:27:45 +0000
Subject: cargo update

compiler & tools dependencies:
     Locking 15 packages to latest compatible versions
    Updating chrono-tz v0.10.3 -> v0.10.4
    Removing chrono-tz-build v0.4.1
    Updating clap v4.5.40 -> v4.5.41
    Updating clap_builder v4.5.40 -> v4.5.41
    Updating clap_derive v4.5.40 -> v4.5.41
    Updating crc32fast v1.4.2 -> v1.5.0
    Updating derive_setters v0.1.7 -> v0.1.8
    Updating libredox v0.1.4 -> v0.1.6
    Updating measureme v12.0.1 -> v12.0.3
    Removing parse-zoneinfo v0.3.1
      Adding phf v0.12.1
      Adding phf_shared v0.12.1
    Updating rustix v1.0.7 -> v1.0.8
    Updating serde_json v1.0.140 -> v1.0.141
    Updating sysinfo v0.36.0 -> v0.36.1
    Updating wasi-preview1-component-adapter-provider v34.0.1 -> v34.0.2
    Updating winnow v0.7.11 -> v0.7.12
note: pass `--verbose` to see 39 unchanged dependencies behind latest

library dependencies:
     Locking 0 packages to latest compatible versions
note: pass `--verbose` to see 3 unchanged dependencies behind latest

rustbook dependencies:
     Locking 13 packages to latest compatible versions
    Updating ammonia v4.1.0 -> v4.1.1
    Updating cc v1.2.29 -> v1.2.30
    Updating clap v4.5.40 -> v4.5.41
    Updating clap_builder v4.5.40 -> v4.5.41
    Updating clap_complete v4.5.54 -> v4.5.55
    Updating clap_derive v4.5.40 -> v4.5.41
    Updating crc32fast v1.4.2 -> v1.5.0
    Updating html5ever v0.31.0 -> v0.35.0
    Updating markup5ever v0.16.2 -> v0.35.0
    Updating match_token v0.1.0 -> v0.35.0
    Updating rustix v1.0.7 -> v1.0.8
    Updating serde_json v1.0.140 -> v1.0.141
    Updating winnow v0.7.11 -> v0.7.12
---
 Cargo.lock                    | 110 +++++++++++++++++++++---------------------
 src/tools/rustbook/Cargo.lock |  55 +++++++++++----------
 2 files changed, 81 insertions(+), 84 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7d2fca8bb3f..1f7470e96c5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -216,7 +216,7 @@ dependencies = [
  "memchr",
  "serde",
  "serde_derive",
- "winnow 0.7.11",
+ "winnow 0.7.12",
 ]
 
 [[package]]
@@ -470,23 +470,12 @@ dependencies = [
 
 [[package]]
 name = "chrono-tz"
-version = "0.10.3"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efdce149c370f133a071ca8ef6ea340b7b88748ab0810097a9e2976eaa34b4f3"
+checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3"
 dependencies = [
  "chrono",
- "chrono-tz-build",
- "phf",
-]
-
-[[package]]
-name = "chrono-tz-build"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f10f8c9340e31fc120ff885fcdb54a0b48e474bbd77cab557f0c30a3e569402"
-dependencies = [
- "parse-zoneinfo",
- "phf_codegen",
+ "phf 0.12.1",
 ]
 
 [[package]]
@@ -501,9 +490,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.40"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40b6887a1d8685cebccf115538db5c0efe625ccac9696ad45c409d96566e910f"
+checksum = "be92d32e80243a54711e5d7ce823c35c41c9d929dc4ab58e1276f625841aadf9"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -521,9 +510,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.40"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0c66c08ce9f0c698cbce5c0279d0bb6ac936d8674174fe48f736533b964f59e"
+checksum = "707eab41e9622f9139419d573eca0900137718000c517d47da73045f54331c3d"
 dependencies = [
  "anstream",
  "anstyle",
@@ -533,9 +522,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.40"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2c7947ae4cc3d851207c1adb5b5e260ff0cca11446b1d6d1423788e442257ce"
+checksum = "ef4f52386a59ca4c860f7393bcf8abd8dfd91ecccc0f774635ff68e92eeef491"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
@@ -798,9 +787,9 @@ dependencies = [
 
 [[package]]
 name = "crc32fast"
-version = "1.4.2"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
  "cfg-if",
 ]
@@ -989,9 +978,9 @@ dependencies = [
 
 [[package]]
 name = "derive_setters"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9c848e86c87e5cc305313041c5677d4d95d60baa71cf95e5f6ea2554bb629ff"
+checksum = "ae5c625eda104c228c06ecaf988d1c60e542176bd7a490e60eeda3493244c0c9"
 dependencies = [
  "darling",
  "proc-macro2",
@@ -2045,9 +2034,9 @@ checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
 
 [[package]]
 name = "libredox"
-version = "0.1.4"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1580801010e535496706ba011c15f8532df6b42297d2e471fec38ceadd8c0638"
+checksum = "4488594b9328dee448adb906d8b126d9b7deb7cf5c22161ee591610bb1be83c0"
 dependencies = [
  "bitflags",
  "libc",
@@ -2157,7 +2146,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7a7213d12e1864c0f002f52c2923d4556935a43dec5e71355c2760e0f6e7a18"
 dependencies = [
  "log",
- "phf",
+ "phf 0.11.3",
  "phf_codegen",
  "string_cache",
  "string_cache_codegen",
@@ -2196,9 +2185,9 @@ dependencies = [
 
 [[package]]
 name = "measureme"
-version = "12.0.1"
+version = "12.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "570a507d8948a66a97f42cbbaf8a6bb9516a51017d4ee949502ad7a10a864395"
+checksum = "6ebd1ebda747ae161a4a377bf93f87e18d46faad2331cc0c7d25b84b1d445f49"
 dependencies = [
  "log",
  "memmap2",
@@ -2632,15 +2621,6 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "parse-zoneinfo"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f2a05b18d44e2957b88f96ba460715e295bc1d7510468a2f3d3b44535d26c24"
-dependencies = [
- "regex",
-]
-
 [[package]]
 name = "pathdiff"
 version = "0.2.3"
@@ -2712,7 +2692,16 @@ version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
 dependencies = [
- "phf_shared",
+ "phf_shared 0.11.3",
+]
+
+[[package]]
+name = "phf"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7"
+dependencies = [
+ "phf_shared 0.12.1",
 ]
 
 [[package]]
@@ -2722,7 +2711,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
 dependencies = [
  "phf_generator",
- "phf_shared",
+ "phf_shared 0.11.3",
 ]
 
 [[package]]
@@ -2731,7 +2720,7 @@ version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
 dependencies = [
- "phf_shared",
+ "phf_shared 0.11.3",
  "rand 0.8.5",
 ]
 
@@ -2744,6 +2733,15 @@ dependencies = [
  "siphasher",
 ]
 
+[[package]]
+name = "phf_shared"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981"
+dependencies = [
+ "siphasher",
+]
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.16"
@@ -4752,15 +4750,15 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
+checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
 dependencies = [
  "bitflags",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -4860,9 +4858,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
 dependencies = [
  "itoa",
  "memchr",
@@ -5027,7 +5025,7 @@ checksum = "bf776ba3fa74f83bf4b63c3dcbbf82173db2632ed8452cb2d891d33f459de70f"
 dependencies = [
  "new_debug_unreachable",
  "parking_lot",
- "phf_shared",
+ "phf_shared 0.11.3",
  "precomputed-hash",
  "serde",
 ]
@@ -5039,7 +5037,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c711928715f1fe0fe509c53b43e993a9a557babc2d0a3567d0a3006f1ac931a0"
 dependencies = [
  "phf_generator",
- "phf_shared",
+ "phf_shared 0.11.3",
  "proc-macro2",
  "quote",
 ]
@@ -5104,9 +5102,9 @@ dependencies = [
 
 [[package]]
 name = "sysinfo"
-version = "0.36.0"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aab138f5c1bb35231de19049060a87977ad23e04f2303e953bc5c2947ac7dec4"
+checksum = "252800745060e7b9ffb7b2badbd8b31cfa4aa2e61af879d0a3bf2a317c20217d"
 dependencies = [
  "libc",
  "objc2-core-foundation",
@@ -5411,7 +5409,7 @@ dependencies = [
  "serde_spanned",
  "toml_datetime",
  "toml_write",
- "winnow 0.7.11",
+ "winnow 0.7.12",
 ]
 
 [[package]]
@@ -5829,9 +5827,9 @@ dependencies = [
 
 [[package]]
 name = "wasi-preview1-component-adapter-provider"
-version = "34.0.1"
+version = "34.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aafa1e6af9a954a4bcf6ef420c33355d0ce84ddc6afbcba7bb6f05126f9120ae"
+checksum = "33696c5f1ff1e083de9f36c3da471abd736362bc173e093f8b0b1ed5a387e39b"
 
 [[package]]
 name = "wasm-bindgen"
@@ -6475,9 +6473,9 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "0.7.11"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74c7b26e3480b707944fc872477815d29a8e429d2f93a1ce000f5fa84a15cbcd"
+checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95"
 dependencies = [
  "memchr",
 ]
diff --git a/src/tools/rustbook/Cargo.lock b/src/tools/rustbook/Cargo.lock
index 27798d6aeb0..e363668d462 100644
--- a/src/tools/rustbook/Cargo.lock
+++ b/src/tools/rustbook/Cargo.lock
@@ -19,9 +19,9 @@ dependencies = [
 
 [[package]]
 name = "ammonia"
-version = "4.1.0"
+version = "4.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ada2ee439075a3e70b6992fce18ac4e407cd05aea9ca3f75d2c0b0c20bbb364"
+checksum = "d6b346764dd0814805de8abf899fe03065bcee69bb1a4771c785817e39f3978f"
 dependencies = [
  "cssparser",
  "html5ever",
@@ -156,9 +156,9 @@ checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
 [[package]]
 name = "cc"
-version = "1.2.29"
+version = "1.2.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c1599538de2394445747c8cf7935946e3cc27e9625f889d979bfb2aaf569362"
+checksum = "deec109607ca693028562ed836a5f1c4b8bd77755c4e132fc5ce11b0b6211ae7"
 dependencies = [
  "shlex",
 ]
@@ -185,9 +185,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.40"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40b6887a1d8685cebccf115538db5c0efe625ccac9696ad45c409d96566e910f"
+checksum = "be92d32e80243a54711e5d7ce823c35c41c9d929dc4ab58e1276f625841aadf9"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -195,9 +195,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.40"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0c66c08ce9f0c698cbce5c0279d0bb6ac936d8674174fe48f736533b964f59e"
+checksum = "707eab41e9622f9139419d573eca0900137718000c517d47da73045f54331c3d"
 dependencies = [
  "anstream",
  "anstyle",
@@ -208,18 +208,18 @@ dependencies = [
 
 [[package]]
 name = "clap_complete"
-version = "4.5.54"
+version = "4.5.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aad5b1b4de04fead402672b48897030eec1f3bfe1550776322f59f6d6e6a5677"
+checksum = "a5abde44486daf70c5be8b8f8f1b66c49f86236edf6fa2abadb4d961c4c6229a"
 dependencies = [
  "clap",
 ]
 
 [[package]]
 name = "clap_derive"
-version = "4.5.40"
+version = "4.5.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2c7947ae4cc3d851207c1adb5b5e260ff0cca11446b1d6d1423788e442257ce"
+checksum = "ef4f52386a59ca4c860f7393bcf8abd8dfd91ecccc0f774635ff68e92eeef491"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -256,9 +256,9 @@ dependencies = [
 
 [[package]]
 name = "crc32fast"
-version = "1.4.2"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
  "cfg-if",
 ]
@@ -582,12 +582,11 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "html5ever"
-version = "0.31.0"
+version = "0.35.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "953cbbe631aae7fc0a112702ad5d3aaf09da38beaf45ea84610d6e1c358f569c"
+checksum = "55d958c2f74b664487a2035fe1dadb032c48718a03b63f3ab0b8537db8549ed4"
 dependencies = [
  "log",
- "mac",
  "markup5ever",
  "match_token",
 ]
@@ -863,9 +862,9 @@ checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
 
 [[package]]
 name = "markup5ever"
-version = "0.16.2"
+version = "0.35.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e4cd8c02f18a011991a039855480c64d74291c5792fcc160d55d77dc4de4a39"
+checksum = "311fe69c934650f8f19652b3946075f0fc41ad8757dbb68f1ca14e7900ecc1c3"
 dependencies = [
  "log",
  "tendril",
@@ -874,9 +873,9 @@ dependencies = [
 
 [[package]]
 name = "match_token"
-version = "0.1.0"
+version = "0.35.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88a9689d8d44bf9964484516275f5cd4c9b59457a6940c1d5d0ecbb94510a36b"
+checksum = "ac84fd3f360fcc43dc5f5d186f02a94192761a080e8bc58621ad4d12296a58cf"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1394,15 +1393,15 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
+checksum = "11181fbabf243db407ef8df94a6ce0b2f9a733bd8be4ad02b4eda9602296cac8"
 dependencies = [
  "bitflags 2.9.1",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1460,9 +1459,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
 dependencies = [
  "itoa",
  "memchr",
@@ -2103,9 +2102,9 @@ checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
 
 [[package]]
 name = "winnow"
-version = "0.7.11"
+version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74c7b26e3480b707944fc872477815d29a8e429d2f93a1ce000f5fa84a15cbcd"
+checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95"
 dependencies = [
  "memchr",
 ]
-- 
cgit 1.4.1-3-g733a5


From 56288857d880bf8fc28a7bd49ba8ed99cb8bd318 Mon Sep 17 00:00:00 2001
From: ltdk <usr@ltdk.xyz>
Date: Thu, 17 Jul 2025 23:22:12 -0400
Subject: Remove deprecated MaybeUninit slice methods

---
 library/core/src/mem/maybe_uninit.rs | 114 +----------------------------------
 1 file changed, 2 insertions(+), 112 deletions(-)

diff --git a/library/core/src/mem/maybe_uninit.rs b/library/core/src/mem/maybe_uninit.rs
index fc35e54bb0d..34d8370da7e 100644
--- a/library/core/src/mem/maybe_uninit.rs
+++ b/library/core/src/mem/maybe_uninit.rs
@@ -1005,28 +1005,6 @@ impl<T> MaybeUninit<T> {
         }
     }
 
-    /// Deprecated version of [`slice::assume_init_ref`].
-    #[unstable(feature = "maybe_uninit_slice", issue = "63569")]
-    #[deprecated(
-        note = "replaced by inherent assume_init_ref method; will eventually be removed",
-        since = "1.83.0"
-    )]
-    pub const unsafe fn slice_assume_init_ref(slice: &[Self]) -> &[T] {
-        // SAFETY: Same for both methods.
-        unsafe { slice.assume_init_ref() }
-    }
-
-    /// Deprecated version of [`slice::assume_init_mut`].
-    #[unstable(feature = "maybe_uninit_slice", issue = "63569")]
-    #[deprecated(
-        note = "replaced by inherent assume_init_mut method; will eventually be removed",
-        since = "1.83.0"
-    )]
-    pub const unsafe fn slice_assume_init_mut(slice: &mut [Self]) -> &mut [T] {
-        // SAFETY: Same for both methods.
-        unsafe { slice.assume_init_mut() }
-    }
-
     /// Gets a pointer to the first element of the array.
     #[unstable(feature = "maybe_uninit_slice", issue = "63569")]
     #[inline(always)]
@@ -1040,94 +1018,6 @@ impl<T> MaybeUninit<T> {
     pub const fn slice_as_mut_ptr(this: &mut [MaybeUninit<T>]) -> *mut T {
         this.as_mut_ptr() as *mut T
     }
-
-    /// Deprecated version of [`slice::write_copy_of_slice`].
-    #[unstable(feature = "maybe_uninit_write_slice", issue = "79995")]
-    #[deprecated(
-        note = "replaced by inherent write_copy_of_slice method; will eventually be removed",
-        since = "1.83.0"
-    )]
-    pub fn copy_from_slice<'a>(this: &'a mut [MaybeUninit<T>], src: &[T]) -> &'a mut [T]
-    where
-        T: Copy,
-    {
-        this.write_copy_of_slice(src)
-    }
-
-    /// Deprecated version of [`slice::write_clone_of_slice`].
-    #[unstable(feature = "maybe_uninit_write_slice", issue = "79995")]
-    #[deprecated(
-        note = "replaced by inherent write_clone_of_slice method; will eventually be removed",
-        since = "1.83.0"
-    )]
-    pub fn clone_from_slice<'a>(this: &'a mut [MaybeUninit<T>], src: &[T]) -> &'a mut [T]
-    where
-        T: Clone,
-    {
-        this.write_clone_of_slice(src)
-    }
-
-    /// Deprecated version of [`slice::write_filled`].
-    #[unstable(feature = "maybe_uninit_fill", issue = "117428")]
-    #[deprecated(
-        note = "replaced by inherent write_filled method; will eventually be removed",
-        since = "1.83.0"
-    )]
-    pub fn fill<'a>(this: &'a mut [MaybeUninit<T>], value: T) -> &'a mut [T]
-    where
-        T: Clone,
-    {
-        this.write_filled(value)
-    }
-
-    /// Deprecated version of [`slice::write_with`].
-    #[unstable(feature = "maybe_uninit_fill", issue = "117428")]
-    #[deprecated(
-        note = "replaced by inherent write_with method; will eventually be removed",
-        since = "1.83.0"
-    )]
-    pub fn fill_with<'a, F>(this: &'a mut [MaybeUninit<T>], mut f: F) -> &'a mut [T]
-    where
-        F: FnMut() -> T,
-    {
-        this.write_with(|_| f())
-    }
-
-    /// Deprecated version of [`slice::write_iter`].
-    #[unstable(feature = "maybe_uninit_fill", issue = "117428")]
-    #[deprecated(
-        note = "replaced by inherent write_iter method; will eventually be removed",
-        since = "1.83.0"
-    )]
-    pub fn fill_from<'a, I>(
-        this: &'a mut [MaybeUninit<T>],
-        it: I,
-    ) -> (&'a mut [T], &'a mut [MaybeUninit<T>])
-    where
-        I: IntoIterator<Item = T>,
-    {
-        this.write_iter(it)
-    }
-
-    /// Deprecated version of [`slice::as_bytes`].
-    #[unstable(feature = "maybe_uninit_as_bytes", issue = "93092")]
-    #[deprecated(
-        note = "replaced by inherent as_bytes method; will eventually be removed",
-        since = "1.83.0"
-    )]
-    pub fn slice_as_bytes(this: &[MaybeUninit<T>]) -> &[MaybeUninit<u8>] {
-        this.as_bytes()
-    }
-
-    /// Deprecated version of [`slice::as_bytes_mut`].
-    #[unstable(feature = "maybe_uninit_as_bytes", issue = "93092")]
-    #[deprecated(
-        note = "replaced by inherent as_bytes_mut method; will eventually be removed",
-        since = "1.83.0"
-    )]
-    pub fn slice_as_bytes_mut(this: &mut [MaybeUninit<T>]) -> &mut [MaybeUninit<u8>] {
-        this.as_bytes_mut()
-    }
 }
 
 impl<T> [MaybeUninit<T>] {
@@ -1304,7 +1194,7 @@ impl<T> [MaybeUninit<T>] {
     /// Fills a slice with elements returned by calling a closure for each index.
     ///
     /// This method uses a closure to create new values. If you'd rather `Clone` a given value, use
-    /// [`MaybeUninit::fill`]. If you want to use the `Default` trait to generate values, you can
+    /// [slice::write_filled]. If you want to use the `Default` trait to generate values, you can
     /// pass [`|_| Default::default()`][Default::default] as the argument.
     ///
     /// # Panics
@@ -1463,7 +1353,7 @@ impl<T> [MaybeUninit<T>] {
     /// use std::mem::MaybeUninit;
     ///
     /// let mut uninit = [MaybeUninit::<u16>::uninit(), MaybeUninit::<u16>::uninit()];
-    /// let uninit_bytes = MaybeUninit::slice_as_bytes_mut(&mut uninit);
+    /// let uninit_bytes = uninit.as_bytes_mut();
     /// uninit_bytes.write_copy_of_slice(&[0x12, 0x34, 0x56, 0x78]);
     /// let vals = unsafe { uninit.assume_init_ref() };
     /// if cfg!(target_endian = "little") {
-- 
cgit 1.4.1-3-g733a5


From 0586c63e070981af7df53e2f778d3e50293d8103 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Wed, 9 Jul 2025 23:59:00 -0700
Subject: Allow `Rvalue::Repeat` to return true in `rvalue_creates_operand` too

The conversation in 143502 made be realize how easy this is to handle, since the only possibilty is ZSTs -- everything else ends up with the destination being `LocalKind::Memory` and thus doesn't call `codegen_rvalue_operand` at all.

This gets us perilously close to a world where `rvalue_creates_operand` only ever returns true.  I'll try out such a world next :)
---
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs | 16 +++++++++---
 tests/codegen/repeat-operand.rs              | 39 ++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 4 deletions(-)
 create mode 100644 tests/codegen/repeat-operand.rs

diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index 2587e89417a..e872f8434e5 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -630,7 +630,17 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 OperandRef { val: OperandValue::Immediate(static_), layout }
             }
             mir::Rvalue::Use(ref operand) => self.codegen_operand(bx, operand),
-            mir::Rvalue::Repeat(..) => bug!("{rvalue:?} in codegen_rvalue_operand"),
+            mir::Rvalue::Repeat(ref elem, len_const) => {
+                // All arrays have `BackendRepr::Memory`, so only the ZST cases
+                // end up here. Anything else forces the destination local to be
+                // `Memory`, and thus ends up handled in `codegen_rvalue` instead.
+                let operand = self.codegen_operand(bx, elem);
+                let array_ty = Ty::new_array_with_const_len(bx.tcx(), operand.layout.ty, len_const);
+                let array_ty = self.monomorphize(array_ty);
+                let array_layout = bx.layout_of(array_ty);
+                assert!(array_layout.is_zst());
+                OperandRef { val: OperandValue::ZeroSized, layout: array_layout }
+            }
             mir::Rvalue::Aggregate(ref kind, ref fields) => {
                 let (variant_index, active_field_index) = match **kind {
                     mir::AggregateKind::Adt(_, variant_index, _, _, active_field_index) => {
@@ -1000,12 +1010,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             mir::Rvalue::NullaryOp(..) |
             mir::Rvalue::ThreadLocalRef(_) |
             mir::Rvalue::Use(..) |
+            mir::Rvalue::Repeat(..) | // (*)
             mir::Rvalue::Aggregate(..) | // (*)
             mir::Rvalue::WrapUnsafeBinder(..) => // (*)
                 true,
-            // Arrays are always aggregates, so it's not worth checking anything here.
-            // (If it's really `[(); N]` or `[T; 0]` and we use the place path, fine.)
-            mir::Rvalue::Repeat(..) => false,
         }
 
         // (*) this is only true if the type is suitable
diff --git a/tests/codegen/repeat-operand.rs b/tests/codegen/repeat-operand.rs
new file mode 100644
index 00000000000..6464b35ddca
--- /dev/null
+++ b/tests/codegen/repeat-operand.rs
@@ -0,0 +1,39 @@
+//@ compile-flags: -Copt-level=1 -Cno-prepopulate-passes
+
+// This test is here to hit the `Rvalue::Repeat` case in `codegen_rvalue_operand`.
+// It only applies when the resulting array is a ZST, so the test is written in
+// such a way as to keep MIR optimizations from seeing that fact and removing
+// the local and statement altogether. (At the time of writing, no other codegen
+// test hit that code path, nor did a stage 2 build of the compiler.)
+
+#![crate_type = "lib"]
+
+#[repr(transparent)]
+pub struct Wrapper<T, const N: usize>([T; N]);
+
+// CHECK-LABEL: define {{.+}}do_repeat{{.+}}()
+// CHECK-NEXT: start:
+// CHECK-NOT: alloca
+// CHECK-NEXT: ret void
+// CHECK-LABEL: define {{.+}}do_repeat{{.+}}(i32 noundef %x)
+// CHECK-NEXT: start:
+// CHECK-NOT: alloca
+// CHECK-NEXT: ret void
+#[inline(never)]
+pub fn do_repeat<T: Copy, const N: usize>(x: T) -> Wrapper<T, N> {
+    Wrapper([x; N])
+}
+
+// CHECK-LABEL: @trigger_repeat_zero_len
+#[no_mangle]
+pub fn trigger_repeat_zero_len() -> Wrapper<u32, 0> {
+    // CHECK: call void {{.+}}do_repeat{{.+}}(i32 noundef 4)
+    do_repeat(4)
+}
+
+// CHECK-LABEL: @trigger_repeat_zst
+#[no_mangle]
+pub fn trigger_repeat_zst() -> Wrapper<(), 8> {
+    // CHECK: call void {{.+}}do_repeat{{.+}}()
+    do_repeat(())
+}
-- 
cgit 1.4.1-3-g733a5


From 4b8f869c638e6d5090420ff46bd14e7b7d909690 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Sat, 19 Jul 2025 20:49:52 -0700
Subject: Split repeat-operand codegen test

Looks like the output it's looking for can be in different orders, so separate tests will fix that.
---
 tests/codegen/repeat-operand-zero-len.rs | 28 +++++++++++++++++++++++
 tests/codegen/repeat-operand-zst-elem.rs | 28 +++++++++++++++++++++++
 tests/codegen/repeat-operand.rs          | 39 --------------------------------
 3 files changed, 56 insertions(+), 39 deletions(-)
 create mode 100644 tests/codegen/repeat-operand-zero-len.rs
 create mode 100644 tests/codegen/repeat-operand-zst-elem.rs
 delete mode 100644 tests/codegen/repeat-operand.rs

diff --git a/tests/codegen/repeat-operand-zero-len.rs b/tests/codegen/repeat-operand-zero-len.rs
new file mode 100644
index 00000000000..b4cec42a07c
--- /dev/null
+++ b/tests/codegen/repeat-operand-zero-len.rs
@@ -0,0 +1,28 @@
+//@ compile-flags: -Copt-level=1 -Cno-prepopulate-passes
+
+// This test is here to hit the `Rvalue::Repeat` case in `codegen_rvalue_operand`.
+// It only applies when the resulting array is a ZST, so the test is written in
+// such a way as to keep MIR optimizations from seeing that fact and removing
+// the local and statement altogether. (At the time of writing, no other codegen
+// test hit that code path, nor did a stage 2 build of the compiler.)
+
+#![crate_type = "lib"]
+
+#[repr(transparent)]
+pub struct Wrapper<T, const N: usize>([T; N]);
+
+// CHECK-LABEL: define {{.+}}do_repeat{{.+}}(i32 noundef %x)
+// CHECK-NEXT: start:
+// CHECK-NOT: alloca
+// CHECK-NEXT: ret void
+#[inline(never)]
+pub fn do_repeat<T: Copy, const N: usize>(x: T) -> Wrapper<T, N> {
+    Wrapper([x; N])
+}
+
+// CHECK-LABEL: @trigger_repeat_zero_len
+#[no_mangle]
+pub fn trigger_repeat_zero_len() -> Wrapper<u32, 0> {
+    // CHECK: call void {{.+}}do_repeat{{.+}}(i32 noundef 4)
+    do_repeat(4)
+}
diff --git a/tests/codegen/repeat-operand-zst-elem.rs b/tests/codegen/repeat-operand-zst-elem.rs
new file mode 100644
index 00000000000..c3637759afa
--- /dev/null
+++ b/tests/codegen/repeat-operand-zst-elem.rs
@@ -0,0 +1,28 @@
+//@ compile-flags: -Copt-level=1 -Cno-prepopulate-passes
+
+// This test is here to hit the `Rvalue::Repeat` case in `codegen_rvalue_operand`.
+// It only applies when the resulting array is a ZST, so the test is written in
+// such a way as to keep MIR optimizations from seeing that fact and removing
+// the local and statement altogether. (At the time of writing, no other codegen
+// test hit that code path, nor did a stage 2 build of the compiler.)
+
+#![crate_type = "lib"]
+
+#[repr(transparent)]
+pub struct Wrapper<T, const N: usize>([T; N]);
+
+// CHECK-LABEL: define {{.+}}do_repeat{{.+}}()
+// CHECK-NEXT: start:
+// CHECK-NOT: alloca
+// CHECK-NEXT: ret void
+#[inline(never)]
+pub fn do_repeat<T: Copy, const N: usize>(x: T) -> Wrapper<T, N> {
+    Wrapper([x; N])
+}
+
+// CHECK-LABEL: @trigger_repeat_zst_elem
+#[no_mangle]
+pub fn trigger_repeat_zst_elem() -> Wrapper<(), 8> {
+    // CHECK: call void {{.+}}do_repeat{{.+}}()
+    do_repeat(())
+}
diff --git a/tests/codegen/repeat-operand.rs b/tests/codegen/repeat-operand.rs
deleted file mode 100644
index 6464b35ddca..00000000000
--- a/tests/codegen/repeat-operand.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//@ compile-flags: -Copt-level=1 -Cno-prepopulate-passes
-
-// This test is here to hit the `Rvalue::Repeat` case in `codegen_rvalue_operand`.
-// It only applies when the resulting array is a ZST, so the test is written in
-// such a way as to keep MIR optimizations from seeing that fact and removing
-// the local and statement altogether. (At the time of writing, no other codegen
-// test hit that code path, nor did a stage 2 build of the compiler.)
-
-#![crate_type = "lib"]
-
-#[repr(transparent)]
-pub struct Wrapper<T, const N: usize>([T; N]);
-
-// CHECK-LABEL: define {{.+}}do_repeat{{.+}}()
-// CHECK-NEXT: start:
-// CHECK-NOT: alloca
-// CHECK-NEXT: ret void
-// CHECK-LABEL: define {{.+}}do_repeat{{.+}}(i32 noundef %x)
-// CHECK-NEXT: start:
-// CHECK-NOT: alloca
-// CHECK-NEXT: ret void
-#[inline(never)]
-pub fn do_repeat<T: Copy, const N: usize>(x: T) -> Wrapper<T, N> {
-    Wrapper([x; N])
-}
-
-// CHECK-LABEL: @trigger_repeat_zero_len
-#[no_mangle]
-pub fn trigger_repeat_zero_len() -> Wrapper<u32, 0> {
-    // CHECK: call void {{.+}}do_repeat{{.+}}(i32 noundef 4)
-    do_repeat(4)
-}
-
-// CHECK-LABEL: @trigger_repeat_zst
-#[no_mangle]
-pub fn trigger_repeat_zst() -> Wrapper<(), 8> {
-    // CHECK: call void {{.+}}do_repeat{{.+}}()
-    do_repeat(())
-}
-- 
cgit 1.4.1-3-g733a5


From 329fda0bc9be49a2107023ccca58fc67cd3d18b4 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Sun, 20 Jul 2025 05:00:42 +0000
Subject: Preparing for merge from rustc

---
 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 601acc00bd6..d734ec333a5 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-ebd8557637b33cc09b6ee8273f3154d5d3af6a15
+6707bf0f59485cf054ac1095725df43220e4be20
-- 
cgit 1.4.1-3-g733a5


From 8b6559b05b5c9c94888b6db2bc89b3da975578c5 Mon Sep 17 00:00:00 2001
From: Chayim Refael Friedman <chayimfr@gmail.com>
Date: Sun, 20 Jul 2025 11:56:45 +0300
Subject: Support `cfg_select!`

---
 src/tools/rust-analyzer/crates/cfg/src/cfg_expr.rs | 14 ++++-
 .../src/macro_expansion_tests/builtin_fn_macro.rs  | 48 ++++++++++++++++
 .../crates/hir-expand/src/builtin/fn_macro.rs      | 66 ++++++++++++++++++++++
 .../crates/intern/src/symbol/symbols.rs            |  1 +
 src/tools/rust-analyzer/crates/tt/src/iter.rs      | 11 ++++
 5 files changed, 139 insertions(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/cfg/src/cfg_expr.rs b/src/tools/rust-analyzer/crates/cfg/src/cfg_expr.rs
index 0ec082dfa7f..aed00aa9fc4 100644
--- a/src/tools/rust-analyzer/crates/cfg/src/cfg_expr.rs
+++ b/src/tools/rust-analyzer/crates/cfg/src/cfg_expr.rs
@@ -68,6 +68,11 @@ impl CfgExpr {
         next_cfg_expr(&mut tt.iter()).unwrap_or(CfgExpr::Invalid)
     }
 
+    #[cfg(feature = "tt")]
+    pub fn parse_from_iter<S: Copy>(tt: &mut tt::iter::TtIter<'_, S>) -> CfgExpr {
+        next_cfg_expr(tt).unwrap_or(CfgExpr::Invalid)
+    }
+
     /// Fold the cfg by querying all basic `Atom` and `KeyValue` predicates.
     pub fn fold(&self, query: &dyn Fn(&CfgAtom) -> bool) -> Option<bool> {
         match self {
@@ -96,7 +101,14 @@ fn next_cfg_expr<S: Copy>(it: &mut tt::iter::TtIter<'_, S>) -> Option<CfgExpr> {
     };
 
     let ret = match it.peek() {
-        Some(TtElement::Leaf(tt::Leaf::Punct(punct))) if punct.char == '=' => {
+        Some(TtElement::Leaf(tt::Leaf::Punct(punct)))
+            // Don't consume on e.g. `=>`.
+            if punct.char == '='
+                && (punct.spacing == tt::Spacing::Alone
+                    || it.remaining().flat_tokens().get(1).is_none_or(|peek2| {
+                        !matches!(peek2, tt::TokenTree::Leaf(tt::Leaf::Punct(_)))
+                    })) =>
+        {
             match it.remaining().flat_tokens().get(1) {
                 Some(tt::TokenTree::Leaf(tt::Leaf::Literal(literal))) => {
                     it.next();
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 1c3af47d522..eeaf865338b 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
@@ -550,3 +550,51 @@ fn main() { "\"hello\""; }
 "##]],
     );
 }
+
+#[test]
+fn cfg_select() {
+    check(
+        r#"
+#[rustc_builtin_macro]
+pub macro cfg_select($($tt:tt)*) {}
+
+cfg_select! {
+    false => { fn false_1() {} }
+    any(false, true) => { fn true_1() {} }
+}
+
+cfg_select! {
+    false => { fn false_2() {} }
+    _ => { fn true_2() {} }
+}
+
+cfg_select! {
+    false => { fn false_3() {} }
+}
+
+cfg_select! {
+    false
+}
+
+cfg_select! {
+    false =>
+}
+
+    "#,
+        expect![[r#"
+#[rustc_builtin_macro]
+pub macro cfg_select($($tt:tt)*) {}
+
+fn true_1() {}
+
+fn true_2() {}
+
+/* error: none of the predicates in this `cfg_select` evaluated to true */
+
+/* error: expected `=>` after cfg expression */
+
+/* error: expected a token tree after `=>` */
+
+    "#]],
+    );
+}
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 60fbc660652..4a9af01091f 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
@@ -127,6 +127,7 @@ register_builtin! {
     (asm, Asm) => asm_expand,
     (global_asm, GlobalAsm) => global_asm_expand,
     (naked_asm, NakedAsm) => naked_asm_expand,
+    (cfg_select, CfgSelect) => cfg_select_expand,
     (cfg, Cfg) => cfg_expand,
     (core_panic, CorePanic) => panic_expand,
     (std_panic, StdPanic) => panic_expand,
@@ -355,6 +356,71 @@ fn naked_asm_expand(
     ExpandResult::ok(expanded)
 }
 
+fn cfg_select_expand(
+    db: &dyn ExpandDatabase,
+    id: MacroCallId,
+    tt: &tt::TopSubtree,
+    span: Span,
+) -> ExpandResult<tt::TopSubtree> {
+    let loc = db.lookup_intern_macro_call(id);
+    let cfg_options = loc.krate.cfg_options(db);
+
+    let mut iter = tt.iter();
+    let mut expand_to = None;
+    while let Some(next) = iter.peek() {
+        let active = if let tt::TtElement::Leaf(tt::Leaf::Ident(ident)) = next
+            && ident.sym == sym::underscore
+        {
+            iter.next();
+            true
+        } else {
+            cfg_options.check(&CfgExpr::parse_from_iter(&mut iter)) != Some(false)
+        };
+        match iter.expect_glued_punct() {
+            Ok(it) if it.len() == 2 && it[0].char == '=' && it[1].char == '>' => {}
+            _ => {
+                let err_span = iter.peek().map(|it| it.first_span()).unwrap_or(span);
+                return ExpandResult::new(
+                    tt::TopSubtree::empty(tt::DelimSpan::from_single(span)),
+                    ExpandError::other(err_span, "expected `=>` after cfg expression"),
+                );
+            }
+        }
+        let expand_to_if_active = match iter.next() {
+            Some(tt::TtElement::Subtree(_, tt)) => tt.remaining(),
+            _ => {
+                let err_span = iter.peek().map(|it| it.first_span()).unwrap_or(span);
+                return ExpandResult::new(
+                    tt::TopSubtree::empty(tt::DelimSpan::from_single(span)),
+                    ExpandError::other(err_span, "expected a token tree after `=>`"),
+                );
+            }
+        };
+
+        if expand_to.is_none() && active {
+            expand_to = Some(expand_to_if_active);
+        }
+    }
+    match expand_to {
+        Some(expand_to) => {
+            let mut builder = tt::TopSubtreeBuilder::new(tt::Delimiter {
+                kind: tt::DelimiterKind::Invisible,
+                open: span,
+                close: span,
+            });
+            builder.extend_with_tt(expand_to);
+            ExpandResult::ok(builder.build())
+        }
+        None => ExpandResult::new(
+            tt::TopSubtree::empty(tt::DelimSpan::from_single(span)),
+            ExpandError::other(
+                span,
+                "none of the predicates in this `cfg_select` evaluated to true",
+            ),
+        ),
+    }
+}
+
 fn cfg_expand(
     db: &dyn ExpandDatabase,
     id: MacroCallId,
diff --git a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
index 1ccd20c25e9..4780743c4d9 100644
--- a/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
+++ b/src/tools/rust-analyzer/crates/intern/src/symbol/symbols.rs
@@ -156,6 +156,7 @@ define_symbols! {
     cfg_attr,
     cfg_eval,
     cfg,
+    cfg_select,
     char,
     clone,
     Clone,
diff --git a/src/tools/rust-analyzer/crates/tt/src/iter.rs b/src/tools/rust-analyzer/crates/tt/src/iter.rs
index 3246156f1cb..2e89d762a0e 100644
--- a/src/tools/rust-analyzer/crates/tt/src/iter.rs
+++ b/src/tools/rust-analyzer/crates/tt/src/iter.rs
@@ -217,6 +217,17 @@ pub enum TtElement<'a, S> {
     Subtree(&'a Subtree<S>, TtIter<'a, S>),
 }
 
+impl<S: Copy + fmt::Debug> fmt::Debug for TtElement<'_, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Leaf(leaf) => f.debug_tuple("Leaf").field(leaf).finish(),
+            Self::Subtree(subtree, inner) => {
+                f.debug_tuple("Subtree").field(subtree).field(inner).finish()
+            }
+        }
+    }
+}
+
 impl<S: Copy> TtElement<'_, S> {
     #[inline]
     pub fn first_span(&self) -> S {
-- 
cgit 1.4.1-3-g733a5


From fdf8bdb7a2a8c9a06045d9648ce0ab6bcf117a6d Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sun, 20 Jul 2025 09:50:58 +0000
Subject: Remove the ptr_unique lang item

Miri no longer uses it.
---
 compiler/rustc_hir/src/lang_items.rs | 3 ---
 compiler/rustc_span/src/symbol.rs    | 1 -
 library/core/src/ptr/unique.rs       | 2 --
 3 files changed, 6 deletions(-)

diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index 6347f1bfa71..75c04b23ed6 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -345,9 +345,6 @@ language_item_table! {
     OwnedBox,                sym::owned_box,           owned_box,                  Target::Struct,         GenericRequirement::Minimum(1);
     GlobalAlloc,             sym::global_alloc_ty,     global_alloc_ty,            Target::Struct,         GenericRequirement::None;
 
-    // Experimental lang item for Miri
-    PtrUnique,               sym::ptr_unique,          ptr_unique,                 Target::Struct,         GenericRequirement::Exact(1);
-
     PhantomData,             sym::phantom_data,        phantom_data,               Target::Struct,         GenericRequirement::Exact(1);
 
     ManuallyDrop,            sym::manually_drop,       manually_drop,              Target::Struct,         GenericRequirement::None;
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index d28a73bc139..d0d09862ade 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1698,7 +1698,6 @@ symbols! {
         ptr_slice_from_raw_parts_mut,
         ptr_swap,
         ptr_swap_nonoverlapping,
-        ptr_unique,
         ptr_write,
         ptr_write_bytes,
         ptr_write_unaligned,
diff --git a/library/core/src/ptr/unique.rs b/library/core/src/ptr/unique.rs
index c069314ff7d..e9e13f9e97f 100644
--- a/library/core/src/ptr/unique.rs
+++ b/library/core/src/ptr/unique.rs
@@ -32,8 +32,6 @@ use crate::ptr::NonNull;
 )]
 #[doc(hidden)]
 #[repr(transparent)]
-// Lang item used experimentally by Miri to define the semantics of `Unique`.
-#[lang = "ptr_unique"]
 pub struct Unique<T: PointeeSized> {
     pointer: NonNull<T>,
     // NOTE: this marker has no consequences for variance, but is necessary
-- 
cgit 1.4.1-3-g733a5


From 9944139f70f2423f572ce48675458ccb67bb8d46 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 18 Jul 2025 11:52:54 +0200
Subject: Add new `ignore-backends` tests annotations

---
 src/bootstrap/src/core/build_steps/test.rs      |  4 +++
 src/doc/rustc-dev-guide/src/tests/directives.md |  1 +
 src/tools/compiletest/src/common.rs             | 34 +++++++++++++++++++++++++
 src/tools/compiletest/src/directives.rs         | 24 ++++++++++++++++-
 src/tools/compiletest/src/lib.rs                | 19 +++++++++++++-
 5 files changed, 80 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 98f11116279..44bcdeacc1e 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1757,6 +1757,10 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         cmd.arg("--host").arg(&*compiler.host.triple);
         cmd.arg("--llvm-filecheck").arg(builder.llvm_filecheck(builder.config.host_target));
 
+        if let Some(codegen_backend) = builder.config.default_codegen_backend(compiler.host) {
+            cmd.arg("--codegen-backend").arg(&codegen_backend);
+        }
+
         if builder.build.config.llvm_enzyme {
             cmd.arg("--has-enzyme");
         }
diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index 6685add461e..15655d1bb2c 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -205,6 +205,7 @@ settings:
   on `wasm32-unknown-unknown` target because the target does not support the
   `proc-macro` crate type.
 - `needs-target-std` — ignores if target platform does not have std support.
+- `ignore-backends` — ignores the listed backends, separated by whitespace characters.
 
 The following directives will check LLVM support:
 
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index c83070aaba7..12084fa0b15 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -175,6 +175,36 @@ pub enum Sanitizer {
     Hwaddress,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum CodegenBackend {
+    Cranelift,
+    Gcc,
+    Llvm,
+}
+
+impl<'a> TryFrom<&'a str> for CodegenBackend {
+    type Error = &'static str;
+
+    fn try_from(value: &'a str) -> Result<Self, Self::Error> {
+        match value.to_lowercase().as_str() {
+            "cranelift" => Ok(Self::Cranelift),
+            "gcc" => Ok(Self::Gcc),
+            "llvm" => Ok(Self::Llvm),
+            _ => Err("unknown backend"),
+        }
+    }
+}
+
+impl CodegenBackend {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Cranelift => "cranelift",
+            Self::Gcc => "gcc",
+            Self::Llvm => "llvm",
+        }
+    }
+}
+
 /// Configuration for `compiletest` *per invocation*.
 ///
 /// In terms of `bootstrap`, this means that `./x test tests/ui tests/run-make` actually correspond
@@ -651,6 +681,9 @@ pub struct Config {
     /// need `core` stubs in cross-compilation scenarios that do not otherwise want/need to
     /// `-Zbuild-std`. Used in e.g. ABI tests.
     pub minicore_path: Utf8PathBuf,
+
+    /// Current codegen backend used.
+    pub codegen_backend: CodegenBackend,
 }
 
 impl Config {
@@ -753,6 +786,7 @@ impl Config {
             profiler_runtime: Default::default(),
             diff_command: Default::default(),
             minicore_path: Default::default(),
+            codegen_backend: CodegenBackend::Llvm,
         }
     }
 
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index 513716357f4..b773956c69f 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -9,7 +9,7 @@ use camino::{Utf8Path, Utf8PathBuf};
 use semver::Version;
 use tracing::*;
 
-use crate::common::{Config, Debugger, FailMode, PassMode, RunFailMode, TestMode};
+use crate::common::{CodegenBackend, Config, Debugger, FailMode, PassMode, RunFailMode, TestMode};
 use crate::debuggers::{extract_cdb_version, extract_gdb_version};
 use crate::directives::auxiliary::{AuxProps, parse_and_update_aux};
 use crate::directives::needs::CachedNeedsConditions;
@@ -818,6 +818,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "ignore-arm-unknown-linux-musleabihf",
     "ignore-auxiliary",
     "ignore-avr",
+    "ignore-backends",
     "ignore-beta",
     "ignore-cdb",
     "ignore-compare-mode-next-solver",
@@ -1669,6 +1670,7 @@ pub(crate) fn make_test_description<R: Read>(
             decision!(cfg::handle_only(config, ln));
             decision!(needs::handle_needs(&cache.needs, config, ln));
             decision!(ignore_llvm(config, path, ln));
+            decision!(ignore_backends(config, path, ln));
             decision!(ignore_cdb(config, ln));
             decision!(ignore_gdb(config, ln));
             decision!(ignore_lldb(config, ln));
@@ -1795,6 +1797,26 @@ fn ignore_lldb(config: &Config, line: &str) -> IgnoreDecision {
     IgnoreDecision::Continue
 }
 
+fn ignore_backends(config: &Config, path: &Utf8Path, line: &str) -> IgnoreDecision {
+    if let Some(backends_to_ignore) = config.parse_name_value_directive(line, "ignore-backends") {
+        for backend in backends_to_ignore.split_whitespace().map(|backend| {
+            match CodegenBackend::try_from(backend) {
+                Ok(backend) => backend,
+                Err(error) => {
+                    panic!("Invalid ignore-backends value `{backend}` in `{path}`: {error}")
+                }
+            }
+        }) {
+            if config.codegen_backend == backend {
+                return IgnoreDecision::Ignore {
+                    reason: format!("{} backend is marked as ignore", backend.as_str()),
+                };
+            }
+        }
+    }
+    IgnoreDecision::Continue
+}
+
 fn ignore_llvm(config: &Config, path: &Utf8Path, line: &str) -> IgnoreDecision {
     if let Some(needed_components) =
         config.parse_name_value_directive(line, "needs-llvm-components")
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index f3b3605a120..41bed8ed8a0 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -39,7 +39,7 @@ use walkdir::WalkDir;
 
 use self::directives::{EarlyProps, make_test_description};
 use crate::common::{
-    CompareMode, Config, Debugger, PassMode, TestMode, TestPaths, UI_EXTENSIONS,
+    CodegenBackend, CompareMode, Config, Debugger, PassMode, TestMode, TestPaths, UI_EXTENSIONS,
     expected_output_path, output_base_dir, output_relative_path,
 };
 use crate::directives::DirectivesCache;
@@ -203,6 +203,12 @@ pub fn parse_config(args: Vec<String>) -> Config {
             "debugger",
             "only test a specific debugger in debuginfo tests",
             "gdb | lldb | cdb",
+        )
+        .optopt(
+            "",
+            "codegen-backend",
+            "the codegen backend currently used",
+            "CODEGEN BACKEND NAME",
         );
 
     let (argv0, args_) = args.split_first().unwrap();
@@ -264,6 +270,15 @@ pub fn parse_config(args: Vec<String>) -> Config {
             || directives::extract_llvm_version_from_binary(&matches.opt_str("llvm-filecheck")?),
         );
 
+    let codegen_backend = match matches.opt_str("codegen-backend").as_deref() {
+        Some(backend) => match CodegenBackend::try_from(backend) {
+            Ok(backend) => backend,
+            Err(error) => panic!("invalid value `{backend}` for `--codegen-backend`: {error}"),
+        },
+        // By default, it's always llvm.
+        None => CodegenBackend::Llvm,
+    };
+
     let run_ignored = matches.opt_present("ignored");
     let with_rustc_debug_assertions = matches.opt_present("with-rustc-debug-assertions");
     let with_std_debug_assertions = matches.opt_present("with-std-debug-assertions");
@@ -449,6 +464,8 @@ pub fn parse_config(args: Vec<String>) -> Config {
         diff_command: matches.opt_str("compiletest-diff-tool"),
 
         minicore_path: opt_path(matches, "minicore-path"),
+
+        codegen_backend,
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 4a35a9f074f5df8ce0d1f14d8569da3b6badfc01 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 18 Jul 2025 12:05:08 +0200
Subject: Add new `needs-backends` tests annotations

---
 src/doc/rustc-dev-guide/src/tests/directives.md |  1 +
 src/tools/compiletest/src/directives.rs         | 25 +++++++++++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/src/doc/rustc-dev-guide/src/tests/directives.md b/src/doc/rustc-dev-guide/src/tests/directives.md
index 15655d1bb2c..5c3ae359ba0 100644
--- a/src/doc/rustc-dev-guide/src/tests/directives.md
+++ b/src/doc/rustc-dev-guide/src/tests/directives.md
@@ -206,6 +206,7 @@ settings:
   `proc-macro` crate type.
 - `needs-target-std` — ignores if target platform does not have std support.
 - `ignore-backends` — ignores the listed backends, separated by whitespace characters.
+- `needs-backends` — only runs the test if current codegen backend is listed.
 
 The following directives will check LLVM support:
 
diff --git a/src/tools/compiletest/src/directives.rs b/src/tools/compiletest/src/directives.rs
index b773956c69f..1397c87ab07 100644
--- a/src/tools/compiletest/src/directives.rs
+++ b/src/tools/compiletest/src/directives.rs
@@ -908,6 +908,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "min-llvm-version",
     "min-system-llvm-version",
     "needs-asm-support",
+    "needs-backends",
     "needs-crate-type",
     "needs-deterministic-layouts",
     "needs-dlltool",
@@ -1671,6 +1672,7 @@ pub(crate) fn make_test_description<R: Read>(
             decision!(needs::handle_needs(&cache.needs, config, ln));
             decision!(ignore_llvm(config, path, ln));
             decision!(ignore_backends(config, path, ln));
+            decision!(needs_backends(config, path, ln));
             decision!(ignore_cdb(config, ln));
             decision!(ignore_gdb(config, ln));
             decision!(ignore_lldb(config, ln));
@@ -1817,6 +1819,29 @@ fn ignore_backends(config: &Config, path: &Utf8Path, line: &str) -> IgnoreDecisi
     IgnoreDecision::Continue
 }
 
+fn needs_backends(config: &Config, path: &Utf8Path, line: &str) -> IgnoreDecision {
+    if let Some(needed_backends) = config.parse_name_value_directive(line, "needs-backends") {
+        if !needed_backends
+            .split_whitespace()
+            .map(|backend| match CodegenBackend::try_from(backend) {
+                Ok(backend) => backend,
+                Err(error) => {
+                    panic!("Invalid needs-backends value `{backend}` in `{path}`: {error}")
+                }
+            })
+            .any(|backend| config.codegen_backend == backend)
+        {
+            return IgnoreDecision::Ignore {
+                reason: format!(
+                    "{} backend is not part of required backends",
+                    config.codegen_backend.as_str()
+                ),
+            };
+        }
+    }
+    IgnoreDecision::Continue
+}
+
 fn ignore_llvm(config: &Config, path: &Utf8Path, line: &str) -> IgnoreDecision {
     if let Some(needed_components) =
         config.parse_name_value_directive(line, "needs-llvm-components")
-- 
cgit 1.4.1-3-g733a5


From e9fb744207b64ff60e7f3dcec3897d76131b165a Mon Sep 17 00:00:00 2001
From: Nadrieril <nadrieril+git@gmail.com>
Date: Sun, 20 Jul 2025 14:41:27 +0200
Subject: Add test

---
 tests/ui/uninhabited/auxiliary/staged-api.rs       |  6 ++++++
 .../uninhabited-unstable-field.current.stderr      | 25 ++++++++++++++++++++--
 .../uninhabited-unstable-field.exhaustive.stderr   | 25 ++++++++++++++++++++--
 tests/ui/uninhabited/uninhabited-unstable-field.rs | 23 ++++++++++++++++----
 4 files changed, 71 insertions(+), 8 deletions(-)

diff --git a/tests/ui/uninhabited/auxiliary/staged-api.rs b/tests/ui/uninhabited/auxiliary/staged-api.rs
index 342ecf020ea..925bb1e0c65 100644
--- a/tests/ui/uninhabited/auxiliary/staged-api.rs
+++ b/tests/ui/uninhabited/auxiliary/staged-api.rs
@@ -6,3 +6,9 @@ pub struct Foo<T> {
     #[unstable(feature = "unstable", issue = "none")]
     pub field: T,
 }
+
+#[unstable(feature = "my_coro_state", issue = "none")]
+pub enum MyCoroutineState<Y, R> {
+    Yielded(Y),
+    Complete(R),
+}
diff --git a/tests/ui/uninhabited/uninhabited-unstable-field.current.stderr b/tests/ui/uninhabited/uninhabited-unstable-field.current.stderr
index 9e0feb4c473..704475ece48 100644
--- a/tests/ui/uninhabited/uninhabited-unstable-field.current.stderr
+++ b/tests/ui/uninhabited/uninhabited-unstable-field.current.stderr
@@ -1,5 +1,5 @@
 error[E0004]: non-exhaustive patterns: type `Foo<Void>` is non-empty
-  --> $DIR/uninhabited-unstable-field.rs:13:11
+  --> $DIR/uninhabited-unstable-field.rs:15:11
    |
 LL |     match x {}
    |           ^
@@ -17,6 +17,27 @@ LL +         _ => todo!(),
 LL ~     }
    |
 
-error: aborting due to 1 previous error
+error[E0004]: non-exhaustive patterns: `MyCoroutineState::Complete(_)` not covered
+  --> $DIR/uninhabited-unstable-field.rs:34:11
+   |
+LL |     match x {
+   |           ^ pattern `MyCoroutineState::Complete(_)` not covered
+   |
+note: `MyCoroutineState<i32, !>` defined here
+  --> $DIR/auxiliary/staged-api.rs:11:1
+   |
+LL | pub enum MyCoroutineState<Y, R> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     Yielded(Y),
+LL |     Complete(R),
+   |     -------- not covered
+   = note: the matched value is of type `MyCoroutineState<i32, !>`
+help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
+   |
+LL ~         MyCoroutineState::Yielded(_) => {},
+LL +         MyCoroutineState::Complete(_) => todo!()
+   |
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/uninhabited/uninhabited-unstable-field.exhaustive.stderr b/tests/ui/uninhabited/uninhabited-unstable-field.exhaustive.stderr
index 9e0feb4c473..704475ece48 100644
--- a/tests/ui/uninhabited/uninhabited-unstable-field.exhaustive.stderr
+++ b/tests/ui/uninhabited/uninhabited-unstable-field.exhaustive.stderr
@@ -1,5 +1,5 @@
 error[E0004]: non-exhaustive patterns: type `Foo<Void>` is non-empty
-  --> $DIR/uninhabited-unstable-field.rs:13:11
+  --> $DIR/uninhabited-unstable-field.rs:15:11
    |
 LL |     match x {}
    |           ^
@@ -17,6 +17,27 @@ LL +         _ => todo!(),
 LL ~     }
    |
 
-error: aborting due to 1 previous error
+error[E0004]: non-exhaustive patterns: `MyCoroutineState::Complete(_)` not covered
+  --> $DIR/uninhabited-unstable-field.rs:34:11
+   |
+LL |     match x {
+   |           ^ pattern `MyCoroutineState::Complete(_)` not covered
+   |
+note: `MyCoroutineState<i32, !>` defined here
+  --> $DIR/auxiliary/staged-api.rs:11:1
+   |
+LL | pub enum MyCoroutineState<Y, R> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     Yielded(Y),
+LL |     Complete(R),
+   |     -------- not covered
+   = note: the matched value is of type `MyCoroutineState<i32, !>`
+help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
+   |
+LL ~         MyCoroutineState::Yielded(_) => {},
+LL +         MyCoroutineState::Complete(_) => todo!()
+   |
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/uninhabited/uninhabited-unstable-field.rs b/tests/ui/uninhabited/uninhabited-unstable-field.rs
index 9b507c518ab..44527319ffd 100644
--- a/tests/ui/uninhabited/uninhabited-unstable-field.rs
+++ b/tests/ui/uninhabited/uninhabited-unstable-field.rs
@@ -1,11 +1,13 @@
 //@ aux-build: staged-api.rs
 //@ revisions: current exhaustive
-
-#![feature(exhaustive_patterns)]
+#![cfg_attr(exhaustive, feature(exhaustive_patterns))]
+#![feature(never_type)]
+#![feature(my_coro_state)] // Custom feature from `staged-api.rs`
+#![deny(unreachable_patterns)]
 
 extern crate staged_api;
 
-use staged_api::Foo;
+use staged_api::{Foo, MyCoroutineState};
 
 enum Void {}
 
@@ -23,7 +25,20 @@ fn demo2(x: Foo<Void>) {
 
 // Same as above, but for wildcard.
 fn demo3(x: Foo<Void>) {
-    match x { _ => {} }
+    match x {
+        _ => {}
+    }
+}
+
+fn unstable_enum(x: MyCoroutineState<i32, !>) {
+    match x {
+        //~^ ERROR non-exhaustive patterns
+        MyCoroutineState::Yielded(_) => {}
+    }
+    match x {
+        MyCoroutineState::Yielded(_) => {}
+        MyCoroutineState::Complete(_) => {}
+    }
 }
 
 fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 258e410feb78aaa2cc897f80124bc67c949df93b Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 3 Jul 2025 13:37:41 +0000
Subject: Unquerify maybe_unused_trait_imports.

---
 compiler/rustc_hir_analysis/src/check_unused.rs         | 2 +-
 compiler/rustc_middle/src/query/mod.rs                  | 3 ---
 compiler/rustc_middle/src/ty/context.rs                 | 2 --
 src/tools/clippy/clippy_lints/src/unused_trait_names.rs | 2 +-
 4 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check_unused.rs b/compiler/rustc_hir_analysis/src/check_unused.rs
index 0133b1e8fcd..3fb33c741c9 100644
--- a/compiler/rustc_hir_analysis/src/check_unused.rs
+++ b/compiler/rustc_hir_analysis/src/check_unused.rs
@@ -18,7 +18,7 @@ pub(super) fn check_unused_traits(tcx: TyCtxt<'_>, (): ()) {
         used_trait_imports.extend_unord(imports.items().copied());
     }
 
-    for &id in tcx.maybe_unused_trait_imports(()) {
+    for &id in tcx.resolutions(()).maybe_unused_trait_imports.iter() {
         debug_assert_eq!(tcx.def_kind(id), DefKind::Use);
         if tcx.visibility(id).is_public() {
             continue;
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index ae8c8259be4..ad7f4973e23 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -2285,9 +2285,6 @@ rustc_queries! {
     query upvars_mentioned(def_id: DefId) -> Option<&'tcx FxIndexMap<hir::HirId, hir::Upvar>> {
         desc { |tcx| "collecting upvars mentioned in `{}`", tcx.def_path_str(def_id) }
     }
-    query maybe_unused_trait_imports(_: ()) -> &'tcx FxIndexSet<LocalDefId> {
-        desc { "fetching potentially unused trait imports" }
-    }
 
     /// All available crates in the graph, including those that should not be user-facing
     /// (such as private crates).
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 7e6bcfee025..51db92ecd78 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -3428,8 +3428,6 @@ pub struct DeducedParamAttrs {
 }
 
 pub fn provide(providers: &mut Providers) {
-    providers.maybe_unused_trait_imports =
-        |tcx, ()| &tcx.resolutions(()).maybe_unused_trait_imports;
     providers.extern_mod_stmt_cnum =
         |tcx, id| tcx.resolutions(()).extern_crate_map.get(&id).cloned();
     providers.is_panic_runtime =
diff --git a/src/tools/clippy/clippy_lints/src/unused_trait_names.rs b/src/tools/clippy/clippy_lints/src/unused_trait_names.rs
index 610cec7b8c8..b7a1d5b2123 100644
--- a/src/tools/clippy/clippy_lints/src/unused_trait_names.rs
+++ b/src/tools/clippy/clippy_lints/src/unused_trait_names.rs
@@ -65,7 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedTraitNames {
             && ident.name != kw::Underscore
             // Only check traits
             && let Some(Res::Def(DefKind::Trait, _)) = path.res.type_ns
-            && cx.tcx.maybe_unused_trait_imports(()).contains(&item.owner_id.def_id)
+            && cx.tcx.resolutions(()).maybe_unused_trait_imports.contains(&item.owner_id.def_id)
             // Only check this import if it is visible to its module only (no pub, pub(crate), ...)
             && let module = cx.tcx.parent_module_from_def_id(item.owner_id.def_id)
             && cx.tcx.visibility(item.owner_id.def_id) == Visibility::Restricted(module.to_def_id())
-- 
cgit 1.4.1-3-g733a5


From 313dff14b93beab9d526e41563eb99135e96060c Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Fri, 4 Jul 2025 16:08:36 +0000
Subject: Add test.

---
 tests/ui/lifetimes/elided-lifetime-in-const-param-type.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 tests/ui/lifetimes/elided-lifetime-in-const-param-type.rs

diff --git a/tests/ui/lifetimes/elided-lifetime-in-const-param-type.rs b/tests/ui/lifetimes/elided-lifetime-in-const-param-type.rs
new file mode 100644
index 00000000000..cdfd1327eae
--- /dev/null
+++ b/tests/ui/lifetimes/elided-lifetime-in-const-param-type.rs
@@ -0,0 +1,12 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/143413>
+//! The anonymous lifetime in `c(&())` is desugared by the resolver as an extra lifetime parameter
+//! at the end of the `for` binder. Verify that lowering creates the definition for that extra
+//! lifetime parameter before lowering `c(&())`.
+
+trait D {}
+
+type A = dyn for<const B: c(&())> D;
+//~^ ERROR cannot find type `c` in this scope
+//~| ERROR only lifetime parameters can be used in this context
+
+fn main() {}
-- 
cgit 1.4.1-3-g733a5


From 7da6fd1221636354139fb92297788b0b5d6b9ca2 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Fri, 4 Jul 2025 16:43:20 +0000
Subject: Lower extra lifetimes before normal generic params.

---
 compiler/rustc_ast_lowering/src/lib.rs             | 29 ++++++++++++++--------
 .../elided-lifetime-in-const-param-type.stderr     | 20 +++++++++++++++
 2 files changed, 38 insertions(+), 11 deletions(-)
 create mode 100644 tests/ui/lifetimes/elided-lifetime-in-const-param-type.stderr

diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 1c96a375035..1f377b81770 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -856,25 +856,32 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     /// name resolver owing to lifetime elision; this also populates the resolver's node-id->def-id
     /// map, so that later calls to `opt_node_id_to_def_id` that refer to these extra lifetime
     /// parameters will be successful.
-    #[instrument(level = "debug", skip(self))]
+    #[instrument(level = "debug", skip(self), ret)]
     #[inline]
     fn lower_lifetime_binder(
         &mut self,
         binder: NodeId,
         generic_params: &[GenericParam],
     ) -> &'hir [hir::GenericParam<'hir>] {
-        let mut generic_params: Vec<_> = self
-            .lower_generic_params_mut(generic_params, hir::GenericParamSource::Binder)
-            .collect();
+        // Start by creating params for extra lifetimes params, as this creates the definitions
+        // that may be referred to by the AST inside `generic_params`.
         let extra_lifetimes = self.resolver.extra_lifetime_params(binder);
         debug!(?extra_lifetimes);
-        generic_params.extend(extra_lifetimes.into_iter().filter_map(|(ident, node_id, res)| {
-            self.lifetime_res_to_generic_param(ident, node_id, res, hir::GenericParamSource::Binder)
-        }));
-        let generic_params = self.arena.alloc_from_iter(generic_params);
-        debug!(?generic_params);
-
-        generic_params
+        let extra_lifetimes: Vec<_> = extra_lifetimes
+            .into_iter()
+            .filter_map(|(ident, node_id, res)| {
+                self.lifetime_res_to_generic_param(
+                    ident,
+                    node_id,
+                    res,
+                    hir::GenericParamSource::Binder,
+                )
+            })
+            .collect();
+        let arena = self.arena;
+        let explicit_generic_params =
+            self.lower_generic_params_mut(generic_params, hir::GenericParamSource::Binder);
+        arena.alloc_from_iter(explicit_generic_params.chain(extra_lifetimes.into_iter()))
     }
 
     fn with_dyn_type_scope<T>(&mut self, in_scope: bool, f: impl FnOnce(&mut Self) -> T) -> T {
diff --git a/tests/ui/lifetimes/elided-lifetime-in-const-param-type.stderr b/tests/ui/lifetimes/elided-lifetime-in-const-param-type.stderr
new file mode 100644
index 00000000000..c7f3c0cc0cd
--- /dev/null
+++ b/tests/ui/lifetimes/elided-lifetime-in-const-param-type.stderr
@@ -0,0 +1,20 @@
+error[E0412]: cannot find type `c` in this scope
+  --> $DIR/elided-lifetime-in-const-param-type.rs:8:27
+   |
+LL | type A = dyn for<const B: c(&())> D;
+   |                           ^ not found in this scope
+
+error[E0658]: only lifetime parameters can be used in this context
+  --> $DIR/elided-lifetime-in-const-param-type.rs:8:24
+   |
+LL | type A = dyn for<const B: c(&())> D;
+   |                        ^
+   |
+   = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information
+   = help: add `#![feature(non_lifetime_binders)]` 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
+
+Some errors have detailed explanations: E0412, E0658.
+For more information about an error, try `rustc --explain E0412`.
-- 
cgit 1.4.1-3-g733a5


From 3567ab19a0edb4f6c7ca88157d84caa3e1564326 Mon Sep 17 00:00:00 2001
From: Nadrieril <nadrieril+git@gmail.com>
Date: Sun, 20 Jul 2025 14:28:58 +0200
Subject: Don't consider unstable fields always-inhabited

This reverts the hack in https://github.com/rust-lang/rust/pull/133889
now that `Pin`'s field is no longer public.
---
 compiler/rustc_middle/src/ty/inhabitedness/mod.rs  | 16 --------
 compiler/rustc_pattern_analysis/src/rustc.rs       |  7 +---
 .../uninhabited-unstable-field.current.stderr      | 43 ----------------------
 .../uninhabited-unstable-field.exhaustive.stderr   | 43 ----------------------
 tests/ui/uninhabited/uninhabited-unstable-field.rs | 17 +++++----
 .../uninhabited/uninhabited-unstable-field.stderr  | 40 ++++++++++++++++++++
 6 files changed, 51 insertions(+), 115 deletions(-)
 delete mode 100644 tests/ui/uninhabited/uninhabited-unstable-field.current.stderr
 delete mode 100644 tests/ui/uninhabited/uninhabited-unstable-field.exhaustive.stderr
 create mode 100644 tests/ui/uninhabited/uninhabited-unstable-field.stderr

diff --git a/compiler/rustc_middle/src/ty/inhabitedness/mod.rs b/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
index 2a336cc21f4..7eb74b52b44 100644
--- a/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
+++ b/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
@@ -43,7 +43,6 @@
 //! This code should only compile in modules where the uninhabitedness of `Foo`
 //! is visible.
 
-use rustc_span::sym;
 use rustc_type_ir::TyKind::*;
 use tracing::instrument;
 
@@ -85,21 +84,6 @@ impl<'tcx> VariantDef {
         InhabitedPredicate::all(
             tcx,
             self.fields.iter().map(|field| {
-                // Unstable fields are always considered to be inhabited. In the future,
-                // this could be extended to be conditional on the field being unstable
-                // only within the module that's querying the inhabitedness, like:
-                //     `let pred = pred.or(InhabitedPredicate::IsUnstable(field.did));`
-                // but this is unnecessary for now, since it would only affect nightly-only
-                // code or code within the standard library itself.
-                // HACK: We filter out `rustc_private` fields since with the flag
-                // `-Zforce-unstable-if-unmarked` we consider all unmarked fields to be
-                // unstable when building the compiler.
-                if tcx
-                    .lookup_stability(field.did)
-                    .is_some_and(|stab| stab.is_unstable() && stab.feature != sym::rustc_private)
-                {
-                    return InhabitedPredicate::True;
-                }
                 let pred = tcx.type_of(field.did).instantiate_identity().inhabited_predicate(tcx);
                 if adt.is_enum() {
                     return pred;
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index ee72b676b38..0c1b0d622f2 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -16,7 +16,7 @@ use rustc_middle::ty::{
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint;
-use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, sym};
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 
 use crate::constructor::Constructor::*;
 use crate::constructor::{
@@ -238,10 +238,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                         let is_visible =
                             adt.is_enum() || field.vis.is_accessible_from(cx.module, cx.tcx);
                         let is_uninhabited = cx.is_uninhabited(*ty);
-                        let is_unstable = cx.tcx.lookup_stability(field.did).is_some_and(|stab| {
-                            stab.is_unstable() && stab.feature != sym::rustc_private
-                        });
-                        let skip = is_uninhabited && (!is_visible || is_unstable);
+                        let skip = is_uninhabited && !is_visible;
                         (ty, PrivateUninhabitedField(skip))
                     });
                     cx.dropless_arena.alloc_from_iter(tys)
diff --git a/tests/ui/uninhabited/uninhabited-unstable-field.current.stderr b/tests/ui/uninhabited/uninhabited-unstable-field.current.stderr
deleted file mode 100644
index 704475ece48..00000000000
--- a/tests/ui/uninhabited/uninhabited-unstable-field.current.stderr
+++ /dev/null
@@ -1,43 +0,0 @@
-error[E0004]: non-exhaustive patterns: type `Foo<Void>` is non-empty
-  --> $DIR/uninhabited-unstable-field.rs:15:11
-   |
-LL |     match x {}
-   |           ^
-   |
-note: `Foo<Void>` defined here
-  --> $DIR/auxiliary/staged-api.rs:5:1
-   |
-LL | pub struct Foo<T> {
-   | ^^^^^^^^^^^^^^^^^
-   = note: the matched value is of type `Foo<Void>`
-help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown
-   |
-LL ~     match x {
-LL +         _ => todo!(),
-LL ~     }
-   |
-
-error[E0004]: non-exhaustive patterns: `MyCoroutineState::Complete(_)` not covered
-  --> $DIR/uninhabited-unstable-field.rs:34:11
-   |
-LL |     match x {
-   |           ^ pattern `MyCoroutineState::Complete(_)` not covered
-   |
-note: `MyCoroutineState<i32, !>` defined here
-  --> $DIR/auxiliary/staged-api.rs:11:1
-   |
-LL | pub enum MyCoroutineState<Y, R> {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-LL |     Yielded(Y),
-LL |     Complete(R),
-   |     -------- not covered
-   = note: the matched value is of type `MyCoroutineState<i32, !>`
-help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
-   |
-LL ~         MyCoroutineState::Yielded(_) => {},
-LL +         MyCoroutineState::Complete(_) => todo!()
-   |
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/uninhabited/uninhabited-unstable-field.exhaustive.stderr b/tests/ui/uninhabited/uninhabited-unstable-field.exhaustive.stderr
deleted file mode 100644
index 704475ece48..00000000000
--- a/tests/ui/uninhabited/uninhabited-unstable-field.exhaustive.stderr
+++ /dev/null
@@ -1,43 +0,0 @@
-error[E0004]: non-exhaustive patterns: type `Foo<Void>` is non-empty
-  --> $DIR/uninhabited-unstable-field.rs:15:11
-   |
-LL |     match x {}
-   |           ^
-   |
-note: `Foo<Void>` defined here
-  --> $DIR/auxiliary/staged-api.rs:5:1
-   |
-LL | pub struct Foo<T> {
-   | ^^^^^^^^^^^^^^^^^
-   = note: the matched value is of type `Foo<Void>`
-help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown
-   |
-LL ~     match x {
-LL +         _ => todo!(),
-LL ~     }
-   |
-
-error[E0004]: non-exhaustive patterns: `MyCoroutineState::Complete(_)` not covered
-  --> $DIR/uninhabited-unstable-field.rs:34:11
-   |
-LL |     match x {
-   |           ^ pattern `MyCoroutineState::Complete(_)` not covered
-   |
-note: `MyCoroutineState<i32, !>` defined here
-  --> $DIR/auxiliary/staged-api.rs:11:1
-   |
-LL | pub enum MyCoroutineState<Y, R> {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-LL |     Yielded(Y),
-LL |     Complete(R),
-   |     -------- not covered
-   = note: the matched value is of type `MyCoroutineState<i32, !>`
-help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
-   |
-LL ~         MyCoroutineState::Yielded(_) => {},
-LL +         MyCoroutineState::Complete(_) => todo!()
-   |
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0004`.
diff --git a/tests/ui/uninhabited/uninhabited-unstable-field.rs b/tests/ui/uninhabited/uninhabited-unstable-field.rs
index 44527319ffd..321b864aa27 100644
--- a/tests/ui/uninhabited/uninhabited-unstable-field.rs
+++ b/tests/ui/uninhabited/uninhabited-unstable-field.rs
@@ -1,6 +1,9 @@
 //@ aux-build: staged-api.rs
-//@ revisions: current exhaustive
-#![cfg_attr(exhaustive, feature(exhaustive_patterns))]
+//! The field of `Pin` used to be public, which would cause `Pin<Void>` to be uninhabited. To remedy
+//! this, we temporarily made it so unstable fields are always considered inhabited. This has now
+//! been reverted, and this file ensures that we don't special-case unstable fields wrt
+//! inhabitedness anymore.
+#![feature(exhaustive_patterns)]
 #![feature(never_type)]
 #![feature(my_coro_state)] // Custom feature from `staged-api.rs`
 #![deny(unreachable_patterns)]
@@ -13,31 +16,29 @@ enum Void {}
 
 fn demo(x: Foo<Void>) {
     match x {}
-    //~^ ERROR non-exhaustive patterns
 }
 
-// Ensure that the pattern is not considered unreachable.
+// Ensure that the pattern is considered unreachable.
 fn demo2(x: Foo<Void>) {
     match x {
-        Foo { .. } => {}
+        Foo { .. } => {} //~ ERROR unreachable
     }
 }
 
 // Same as above, but for wildcard.
 fn demo3(x: Foo<Void>) {
     match x {
-        _ => {}
+        _ => {} //~ ERROR unreachable
     }
 }
 
 fn unstable_enum(x: MyCoroutineState<i32, !>) {
     match x {
-        //~^ ERROR non-exhaustive patterns
         MyCoroutineState::Yielded(_) => {}
     }
     match x {
         MyCoroutineState::Yielded(_) => {}
-        MyCoroutineState::Complete(_) => {}
+        MyCoroutineState::Complete(_) => {} //~ ERROR unreachable
     }
 }
 
diff --git a/tests/ui/uninhabited/uninhabited-unstable-field.stderr b/tests/ui/uninhabited/uninhabited-unstable-field.stderr
new file mode 100644
index 00000000000..a0c9f9366a6
--- /dev/null
+++ b/tests/ui/uninhabited/uninhabited-unstable-field.stderr
@@ -0,0 +1,40 @@
+error: unreachable pattern
+  --> $DIR/uninhabited-unstable-field.rs:24:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^------
+   |         |
+   |         matches no values because `Foo<Void>` 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
+note: the lint level is defined here
+  --> $DIR/uninhabited-unstable-field.rs:9:9
+   |
+LL | #![deny(unreachable_patterns)]
+   |         ^^^^^^^^^^^^^^^^^^^^
+
+error: unreachable pattern
+  --> $DIR/uninhabited-unstable-field.rs:31:9
+   |
+LL |         _ => {}
+   |         ^------
+   |         |
+   |         matches no values because `Foo<Void>` 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/uninhabited-unstable-field.rs:41:9
+   |
+LL |         MyCoroutineState::Complete(_) => {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------
+   |         |
+   |         matches no values because `!` 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: aborting due to 3 previous errors
+
-- 
cgit 1.4.1-3-g733a5


From 08b816ff18347031b1160f1257cde2008c3c366e Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Sat, 12 Jul 2025 02:33:42 -0700
Subject: So many test updates x_x

---
 tests/auxiliary/minisimd.rs                        | 160 +++++++++++++++
 tests/codegen/const-vector.rs                      |  38 ++--
 .../simd-intrinsic/simd-intrinsic-float-abs.rs     |  32 +--
 .../simd-intrinsic/simd-intrinsic-float-ceil.rs    |  32 +--
 .../simd-intrinsic/simd-intrinsic-float-cos.rs     |  32 +--
 .../simd-intrinsic/simd-intrinsic-float-exp.rs     |  32 +--
 .../simd-intrinsic/simd-intrinsic-float-exp2.rs    |  32 +--
 .../simd-intrinsic/simd-intrinsic-float-floor.rs   |  32 +--
 .../simd-intrinsic/simd-intrinsic-float-fma.rs     |  32 +--
 .../simd-intrinsic/simd-intrinsic-float-fsqrt.rs   |  32 +--
 .../simd-intrinsic/simd-intrinsic-float-log.rs     |  32 +--
 .../simd-intrinsic/simd-intrinsic-float-log10.rs   |  32 +--
 .../simd-intrinsic/simd-intrinsic-float-log2.rs    |  32 +--
 .../simd-intrinsic/simd-intrinsic-float-minmax.rs  |   8 +-
 .../simd-intrinsic/simd-intrinsic-float-sin.rs     |  32 +--
 ...simd-intrinsic-generic-arithmetic-saturating.rs |  63 +-----
 .../simd-intrinsic-generic-bitmask.rs              |  16 +-
 .../simd-intrinsic-generic-gather.rs               |  13 +-
 .../simd-intrinsic-generic-masked-load.rs          |  13 +-
 .../simd-intrinsic-generic-masked-store.rs         |  13 +-
 .../simd-intrinsic-generic-scatter.rs              |  13 +-
 .../simd-intrinsic-generic-select.rs               |  24 +--
 .../simd-intrinsic/simd-intrinsic-mask-reduce.rs   |  13 +-
 .../simd-intrinsic-transmute-array.rs              |  15 +-
 tests/codegen/simd/aggregate-simd.rs               |  10 +-
 tests/codegen/simd/packed-simd.rs                  |  12 +-
 tests/codegen/simd/simd_arith_offset.rs            |  12 +-
 tests/ui/simd/generics.rs                          |  60 ++----
 tests/ui/simd/intrinsic/float-math-pass.rs         |  22 +--
 tests/ui/simd/intrinsic/float-minmax-pass.rs       |  16 +-
 tests/ui/simd/intrinsic/generic-arithmetic-pass.rs | 214 +++++++++++----------
 .../generic-arithmetic-saturating-pass.rs          |  82 ++++----
 tests/ui/simd/intrinsic/generic-as.rs              |  38 ++--
 tests/ui/simd/intrinsic/generic-bswap-byte.rs      |  16 +-
 tests/ui/simd/intrinsic/generic-cast-pass.rs       |  38 ++--
 .../simd/intrinsic/generic-cast-pointer-width.rs   |  16 +-
 tests/ui/simd/intrinsic/generic-comparison-pass.rs |  43 ++---
 tests/ui/simd/intrinsic/generic-elements-pass.rs   | 120 ++++++------
 .../simd/intrinsic/generic-gather-scatter-pass.rs  |  34 ++--
 tests/ui/simd/intrinsic/generic-select-pass.rs     |  94 ++++-----
 tests/ui/simd/intrinsic/inlining-issue67557.rs     |  20 +-
 tests/ui/simd/intrinsic/ptr-cast.rs                |  16 +-
 tests/ui/simd/issue-39720.rs                       |  14 +-
 tests/ui/simd/issue-85915-simd-ptrs.rs             |  32 ++-
 tests/ui/simd/issue-89193.rs                       |  22 ++-
 tests/ui/simd/masked-load-store.rs                 |  10 +-
 tests/ui/simd/monomorphize-shuffle-index.rs        |  12 +-
 tests/ui/simd/repr_packed.rs                       |  28 ++-
 tests/ui/simd/shuffle.rs                           |  10 +-
 tests/ui/simd/simd-bitmask-notpow2.rs              |  21 +-
 tests/ui/simd/simd-bitmask.rs                      |  16 +-
 tests/ui/simd/target-feature-mixup.rs              |  41 ++--
 52 files changed, 805 insertions(+), 1037 deletions(-)
 create mode 100644 tests/auxiliary/minisimd.rs

diff --git a/tests/auxiliary/minisimd.rs b/tests/auxiliary/minisimd.rs
new file mode 100644
index 00000000000..ff0c996de1c
--- /dev/null
+++ b/tests/auxiliary/minisimd.rs
@@ -0,0 +1,160 @@
+//! Auxiliary crate for tests that need SIMD types.
+//!
+//! Historically the tests just made their own, but projections into simd types
+//! was banned by <https://github.com/rust-lang/compiler-team/issues/838>, which
+//! breaks `derive(Clone)`, so this exists to give easily-usable types that can
+//! be used without copy-pasting the definitions of the helpers everywhere.
+//!
+//! This makes no attempt to guard against ICEs.  Using it with proper types
+//! and such is your responsibility in the tests you write.
+
+#![allow(unused)]
+#![allow(non_camel_case_types)]
+
+// The field is currently left `pub` for convenience in porting tests, many of
+// which attempt to just construct it directly. That still works; it's just the
+// `.0` projection that doesn't.
+#[repr(simd)]
+#[derive(Copy, Eq)]
+pub struct Simd<T, const N: usize>(pub [T; N]);
+
+impl<T: Copy, const N: usize> Clone for Simd<T, N> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: PartialEq, const N: usize> PartialEq for Simd<T, N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.as_array() == other.as_array()
+    }
+}
+
+impl<T: core::fmt::Debug, const N: usize> core::fmt::Debug for Simd<T, N> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
+        <[T; N] as core::fmt::Debug>::fmt(self.as_array(), f)
+    }
+}
+
+impl<T, const N: usize> core::ops::Index<usize> for Simd<T, N> {
+    type Output = T;
+    fn index(&self, i: usize) -> &T {
+        &self.as_array()[i]
+    }
+}
+
+impl<T, const N: usize> Simd<T, N> {
+    pub const fn from_array(a: [T; N]) -> Self {
+        Simd(a)
+    }
+    pub fn as_array(&self) -> &[T; N] {
+        let p: *const Self = self;
+        unsafe { &*p.cast::<[T; N]>() }
+    }
+    pub fn into_array(self) -> [T; N]
+    where
+        T: Copy,
+    {
+        *self.as_array()
+    }
+}
+
+pub type u8x2 = Simd<u8, 2>;
+pub type u8x4 = Simd<u8, 4>;
+pub type u8x8 = Simd<u8, 8>;
+pub type u8x16 = Simd<u8, 16>;
+pub type u8x32 = Simd<u8, 32>;
+pub type u8x64 = Simd<u8, 64>;
+
+pub type u16x2 = Simd<u16, 2>;
+pub type u16x4 = Simd<u16, 4>;
+pub type u16x8 = Simd<u16, 8>;
+pub type u16x16 = Simd<u16, 16>;
+pub type u16x32 = Simd<u16, 32>;
+
+pub type u32x2 = Simd<u32, 2>;
+pub type u32x4 = Simd<u32, 4>;
+pub type u32x8 = Simd<u32, 8>;
+pub type u32x16 = Simd<u32, 16>;
+
+pub type u64x2 = Simd<u64, 2>;
+pub type u64x4 = Simd<u64, 4>;
+pub type u64x8 = Simd<u64, 8>;
+
+pub type u128x2 = Simd<u128, 2>;
+pub type u128x4 = Simd<u128, 4>;
+
+pub type i8x2 = Simd<i8, 2>;
+pub type i8x4 = Simd<i8, 4>;
+pub type i8x8 = Simd<i8, 8>;
+pub type i8x16 = Simd<i8, 16>;
+pub type i8x32 = Simd<i8, 32>;
+pub type i8x64 = Simd<i8, 64>;
+
+pub type i16x2 = Simd<i16, 2>;
+pub type i16x4 = Simd<i16, 4>;
+pub type i16x8 = Simd<i16, 8>;
+pub type i16x16 = Simd<i16, 16>;
+pub type i16x32 = Simd<i16, 32>;
+
+pub type i32x2 = Simd<i32, 2>;
+pub type i32x4 = Simd<i32, 4>;
+pub type i32x8 = Simd<i32, 8>;
+pub type i32x16 = Simd<i32, 16>;
+
+pub type i64x2 = Simd<i64, 2>;
+pub type i64x4 = Simd<i64, 4>;
+pub type i64x8 = Simd<i64, 8>;
+
+pub type i128x2 = Simd<i128, 2>;
+pub type i128x4 = Simd<i128, 4>;
+
+pub type f32x2 = Simd<f32, 2>;
+pub type f32x4 = Simd<f32, 4>;
+pub type f32x8 = Simd<f32, 8>;
+pub type f32x16 = Simd<f32, 16>;
+
+pub type f64x2 = Simd<f64, 2>;
+pub type f64x4 = Simd<f64, 4>;
+pub type f64x8 = Simd<f64, 8>;
+
+// The field is currently left `pub` for convenience in porting tests, many of
+// which attempt to just construct it directly. That still works; it's just the
+// `.0` projection that doesn't.
+#[repr(simd, packed)]
+#[derive(Copy)]
+pub struct PackedSimd<T, const N: usize>(pub [T; N]);
+
+impl<T: Copy, const N: usize> Clone for PackedSimd<T, N> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: PartialEq, const N: usize> PartialEq for PackedSimd<T, N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.as_array() == other.as_array()
+    }
+}
+
+impl<T: core::fmt::Debug, const N: usize> core::fmt::Debug for PackedSimd<T, N> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
+        <[T; N] as core::fmt::Debug>::fmt(self.as_array(), f)
+    }
+}
+
+impl<T, const N: usize> PackedSimd<T, N> {
+    pub const fn from_array(a: [T; N]) -> Self {
+        PackedSimd(a)
+    }
+    pub fn as_array(&self) -> &[T; N] {
+        let p: *const Self = self;
+        unsafe { &*p.cast::<[T; N]>() }
+    }
+    pub fn into_array(self) -> [T; N]
+    where
+        T: Copy,
+    {
+        *self.as_array()
+    }
+}
diff --git a/tests/codegen/const-vector.rs b/tests/codegen/const-vector.rs
index 42921442e03..a2249f4fff7 100644
--- a/tests/codegen/const-vector.rs
+++ b/tests/codegen/const-vector.rs
@@ -16,18 +16,9 @@
 #![feature(mips_target_feature)]
 #![allow(non_camel_case_types)]
 
-// Setting up structs that can be used as const vectors
-#[repr(simd)]
-#[derive(Clone)]
-pub struct i8x2([i8; 2]);
-
-#[repr(simd)]
-#[derive(Clone)]
-pub struct f32x2([f32; 2]);
-
-#[repr(simd, packed)]
-#[derive(Copy, Clone)]
-pub struct Simd<T, const N: usize>([T; N]);
+#[path = "../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::{PackedSimd as Simd, f32x2, i8x2};
 
 // The following functions are required for the tests to ensure
 // that they are called with a const vector
@@ -45,7 +36,7 @@ extern "unadjusted" {
 
 // Ensure the packed variant of the simd struct does not become a const vector
 // if the size is not a power of 2
-// CHECK: %"Simd<i32, 3>" = type { [3 x i32] }
+// CHECK: %"minisimd::PackedSimd<i32, 3>" = type { [3 x i32] }
 
 #[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
@@ -54,27 +45,34 @@ extern "unadjusted" {
 pub fn do_call() {
     unsafe {
         // CHECK: call void @test_i8x2(<2 x i8> <i8 32, i8 64>
-        test_i8x2(const { i8x2([32, 64]) });
+        test_i8x2(const { i8x2::from_array([32, 64]) });
 
         // CHECK: call void @test_i8x2_two_args(<2 x i8> <i8 32, i8 64>, <2 x i8> <i8 8, i8 16>
-        test_i8x2_two_args(const { i8x2([32, 64]) }, const { i8x2([8, 16]) });
+        test_i8x2_two_args(
+            const { i8x2::from_array([32, 64]) },
+            const { i8x2::from_array([8, 16]) },
+        );
 
         // CHECK: call void @test_i8x2_mixed_args(<2 x i8> <i8 32, i8 64>, i32 43, <2 x i8> <i8 8, i8 16>
-        test_i8x2_mixed_args(const { i8x2([32, 64]) }, 43, const { i8x2([8, 16]) });
+        test_i8x2_mixed_args(
+            const { i8x2::from_array([32, 64]) },
+            43,
+            const { i8x2::from_array([8, 16]) },
+        );
 
         // CHECK: call void @test_i8x2_arr(<2 x i8> <i8 32, i8 64>
-        test_i8x2_arr(const { i8x2([32, 64]) });
+        test_i8x2_arr(const { i8x2::from_array([32, 64]) });
 
         // CHECK: call void @test_f32x2(<2 x float> <float 0x3FD47AE140000000, float 0x3FE47AE140000000>
-        test_f32x2(const { f32x2([0.32, 0.64]) });
+        test_f32x2(const { f32x2::from_array([0.32, 0.64]) });
 
         // CHECK: void @test_f32x2_arr(<2 x float> <float 0x3FD47AE140000000, float 0x3FE47AE140000000>
-        test_f32x2_arr(const { f32x2([0.32, 0.64]) });
+        test_f32x2_arr(const { f32x2::from_array([0.32, 0.64]) });
 
         // CHECK: call void @test_simd(<4 x i32> <i32 2, i32 4, i32 6, i32 8>
         test_simd(const { Simd::<i32, 4>([2, 4, 6, 8]) });
 
-        // CHECK: call void @test_simd_unaligned(%"Simd<i32, 3>" %1
+        // CHECK: call void @test_simd_unaligned(%"minisimd::PackedSimd<i32, 3>" %1
         test_simd_unaligned(const { Simd::<i32, 3>([2, 4, 6]) });
     }
 }
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
index 485ba92272d..baf445d0a1b 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_fabs;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_fabs;
 
 // CHECK-LABEL: @fabs_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn fabs_32x16(a: f32x16) -> f32x16 {
     simd_fabs(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @fabs_64x4
 #[no_mangle]
 pub unsafe fn fabs_64x4(a: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
index e8bda7c29c4..096de569274 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_ceil;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_ceil;
 
 // CHECK-LABEL: @ceil_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn ceil_32x16(a: f32x16) -> f32x16 {
     simd_ceil(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @ceil_64x4
 #[no_mangle]
 pub unsafe fn ceil_64x4(a: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
index 8dc967bc3ad..5b2197924bc 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_fcos;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_fcos;
 
 // CHECK-LABEL: @fcos_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn fcos_32x16(a: f32x16) -> f32x16 {
     simd_fcos(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @fcos_64x4
 #[no_mangle]
 pub unsafe fn fcos_64x4(a: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
index 00caca2f294..d4eadb36c65 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_fexp;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_fexp;
 
 // CHECK-LABEL: @exp_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn exp_32x16(a: f32x16) -> f32x16 {
     simd_fexp(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @exp_64x4
 #[no_mangle]
 pub unsafe fn exp_64x4(a: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
index eda4053189c..d32015b7990 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_fexp2;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_fexp2;
 
 // CHECK-LABEL: @exp2_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn exp2_32x16(a: f32x16) -> f32x16 {
     simd_fexp2(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @exp2_64x4
 #[no_mangle]
 pub unsafe fn exp2_64x4(a: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
index ad69d4cdd88..1e1c8ce0c35 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_floor;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_floor;
 
 // CHECK-LABEL: @floor_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn floor_32x16(a: f32x16) -> f32x16 {
     simd_floor(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @floor_64x4
 #[no_mangle]
 pub unsafe fn floor_64x4(a: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
index cbeefdc31c0..982077d81f9 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_fma;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_fma;
 
 // CHECK-LABEL: @fma_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn fma_32x16(a: f32x16, b: f32x16, c: f32x16) -> f32x16 {
     simd_fma(a, b, c)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @fma_64x4
 #[no_mangle]
 pub unsafe fn fma_64x4(a: f64x4, b: f64x4, c: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
index 618daa4b44d..e20a591f573 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_fsqrt;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_fsqrt;
 
 // CHECK-LABEL: @fsqrt_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn fsqrt_32x16(a: f32x16) -> f32x16 {
     simd_fsqrt(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @fsqrt_64x4
 #[no_mangle]
 pub unsafe fn fsqrt_64x4(a: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
index 98a481e4004..bf1ffc76330 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_flog;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_flog;
 
 // CHECK-LABEL: @log_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn log_32x16(a: f32x16) -> f32x16 {
     simd_flog(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @log_64x4
 #[no_mangle]
 pub unsafe fn log_64x4(a: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
index 9108cd963f0..ccf484e0e41 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_flog10;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_flog10;
 
 // CHECK-LABEL: @log10_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn log10_32x16(a: f32x16) -> f32x16 {
     simd_flog10(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @log10_64x4
 #[no_mangle]
 pub unsafe fn log10_64x4(a: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
index 2b20850dbd9..677d8b01e84 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_flog2;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_flog2;
 
 // CHECK-LABEL: @log2_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn log2_32x16(a: f32x16) -> f32x16 {
     simd_flog2(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @log2_64x4
 #[no_mangle]
 pub unsafe fn log2_64x4(a: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs
index ce07b212e84..8dd464a1bff 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs
@@ -4,11 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::{simd_fmax, simd_fmin};
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
+use std::intrinsics::simd::{simd_fmax, simd_fmin};
 
 // CHECK-LABEL: @fmin
 #[no_mangle]
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
index 7de26b415bb..48becc72c0b 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_fsin;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_fsin;
 
 // CHECK-LABEL: @fsin_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn fsin_32x16(a: f32x16) -> f32x16 {
     simd_fsin(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @fsin_64x4
 #[no_mangle]
 pub unsafe fn fsin_64x4(a: f64x4) -> f64x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
index ecf5eb24ee5..06d46889715 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
@@ -5,66 +5,11 @@
 #![allow(non_camel_case_types)]
 #![deny(unused)]
 
-use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
-
-#[rustfmt::skip]
-mod types {
-    // signed integer types
-
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x2([i8; 2]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x4([i8; 4]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x8([i8; 8]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x16([i8; 16]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x32([i8; 32]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x64([i8; 64]);
-
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x2([i16; 2]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x4([i16; 4]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x8([i16; 8]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x16([i16; 16]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x32([i16; 32]);
-
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x2([i32; 2]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x4([i32; 4]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x8([i32; 8]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x16([i32; 16]);
-
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i64x2([i64; 2]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i64x4([i64; 4]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i64x8([i64; 8]);
-
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i128x2([i128; 2]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct i128x4([i128; 4]);
-
-    // unsigned integer types
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x2([u8; 2]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x4([u8; 4]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x8([u8; 8]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x16([u8; 16]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x32([u8; 32]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x64([u8; 64]);
-
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x2([u16; 2]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x4([u16; 4]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x8([u16; 8]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x16([u16; 16]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x32([u16; 32]);
-
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x2([u32; 2]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x4([u32; 4]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x8([u32; 8]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x16([u32; 16]);
-
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u64x2([u64; 2]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u64x4([u64; 4]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u64x8([u64; 8]);
-
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u128x2([u128; 2]);
-    #[repr(simd)] #[derive(Copy, Clone)] pub struct u128x4([u128; 4]);
-}
-
-use types::*;
+use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
 // NOTE(eddyb) `%{{x|0}}` is used because on some targets (e.g. WASM)
 // SIMD vectors are passed directly, resulting in `%x` being a vector,
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
index a2c40aa91b5..294262d8152 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
@@ -5,19 +5,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_bitmask;
-
-#[repr(simd)]
-#[derive(Copy, Clone)]
-pub struct u32x2([u32; 2]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-pub struct i32x2([i32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone)]
-pub struct i8x16([i8; 16]);
+use std::intrinsics::simd::simd_bitmask;
 
 // NOTE(eddyb) `%{{x|1}}` is used because on some targets (e.g. WASM)
 // SIMD vectors are passed directly, resulting in `%x` being a vector,
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs
index c06b36d68b9..690bfb432f9 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs
@@ -6,15 +6,14 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_gather;
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct Vec2<T>(pub [T; 2]);
+use std::intrinsics::simd::simd_gather;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct Vec4<T>(pub [T; 4]);
+pub type Vec2<T> = Simd<T, 2>;
+pub type Vec4<T> = Simd<T, 4>;
 
 // CHECK-LABEL: @gather_f32x2
 #[no_mangle]
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
index 21578e67cff..fda315dc66c 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
@@ -4,15 +4,14 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_masked_load;
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct Vec2<T>(pub [T; 2]);
+use std::intrinsics::simd::simd_masked_load;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct Vec4<T>(pub [T; 4]);
+pub type Vec2<T> = Simd<T, 2>;
+pub type Vec4<T> = Simd<T, 4>;
 
 // CHECK-LABEL: @load_f32x2
 #[no_mangle]
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
index 22a8f7e54bd..6ca7388d464 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
@@ -4,15 +4,14 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_masked_store;
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct Vec2<T>(pub [T; 2]);
+use std::intrinsics::simd::simd_masked_store;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct Vec4<T>(pub [T; 4]);
+pub type Vec2<T> = Simd<T, 2>;
+pub type Vec4<T> = Simd<T, 4>;
 
 // CHECK-LABEL: @store_f32x2
 #[no_mangle]
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs
index 0cc9e6ae59a..743652966e1 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs
@@ -6,15 +6,14 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_scatter;
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct Vec2<T>(pub [T; 2]);
+use std::intrinsics::simd::simd_scatter;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct Vec4<T>(pub [T; 4]);
+pub type Vec2<T> = Simd<T, 2>;
+pub type Vec4<T> = Simd<T, 4>;
 
 // CHECK-LABEL: @scatter_f32x2
 #[no_mangle]
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs
index f6531c1b23a..2c0bad21f44 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs
@@ -4,27 +4,13 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::{simd_select, simd_select_bitmask};
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8([f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct b8x4(pub [i8; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct i32x4([i32; 4]);
+use std::intrinsics::simd::{simd_select, simd_select_bitmask};
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct u32x4([u32; 4]);
+pub type b8x4 = i8x4;
 
 // CHECK-LABEL: @select_m8
 #[no_mangle]
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs
index 269fe41225e..79f00a6ed60 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs
@@ -4,15 +4,14 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::{simd_reduce_all, simd_reduce_any};
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-pub struct mask32x2([i32; 2]);
+use std::intrinsics::simd::{simd_reduce_all, simd_reduce_any};
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-pub struct mask8x16([i8; 16]);
+pub type mask32x2 = Simd<i32, 2>;
+pub type mask8x16 = Simd<i8, 16>;
 
 // NOTE(eddyb) `%{{x|1}}` is used because on some targets (e.g. WASM)
 // SIMD vectors are passed directly, resulting in `%x` being a vector,
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
index 301f06c2d74..05c2f7e1bdf 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
@@ -8,13 +8,12 @@
 #![allow(non_camel_case_types)]
 #![feature(repr_simd, core_intrinsics)]
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-pub struct S<const N: usize>([f32; N]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-pub struct T([f32; 4]);
+pub type S<const N: usize> = Simd<f32, N>;
+pub type T = Simd<f32, 4>;
 
 // CHECK-LABEL: @array_align(
 #[no_mangle]
@@ -34,7 +33,7 @@ pub fn vector_align() -> usize {
 #[no_mangle]
 pub fn build_array_s(x: [f32; 4]) -> S<4> {
     // CHECK: call void @llvm.memcpy.{{.+}}({{.*}} align [[VECTOR_ALIGN]] {{.*}} align [[ARRAY_ALIGN]] {{.*}}, [[USIZE]] 16, i1 false)
-    S::<4>(x)
+    Simd(x)
 }
 
 // CHECK-LABEL: @build_array_transmute_s
@@ -48,7 +47,7 @@ pub fn build_array_transmute_s(x: [f32; 4]) -> S<4> {
 #[no_mangle]
 pub fn build_array_t(x: [f32; 4]) -> T {
     // CHECK: call void @llvm.memcpy.{{.+}}({{.*}} align [[VECTOR_ALIGN]] {{.*}} align [[ARRAY_ALIGN]] {{.*}}, [[USIZE]] 16, i1 false)
-    T(x)
+    Simd(x)
 }
 
 // CHECK-LABEL: @build_array_transmute_t
diff --git a/tests/codegen/simd/aggregate-simd.rs b/tests/codegen/simd/aggregate-simd.rs
index 065e429a4c7..57a301d634c 100644
--- a/tests/codegen/simd/aggregate-simd.rs
+++ b/tests/codegen/simd/aggregate-simd.rs
@@ -5,15 +5,11 @@
 #![no_std]
 #![crate_type = "lib"]
 
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
 use core::intrinsics::simd::{simd_add, simd_extract};
 
-#[repr(simd)]
-#[derive(Clone, Copy)]
-pub struct Simd<T, const N: usize>([T; N]);
-
-#[repr(simd, packed)]
-#[derive(Clone, Copy)]
-pub struct PackedSimd<T, const N: usize>([T; N]);
+use minisimd::*;
 
 #[repr(transparent)]
 pub struct Transparent<T>(T);
diff --git a/tests/codegen/simd/packed-simd.rs b/tests/codegen/simd/packed-simd.rs
index 73e0d29d7d6..70c03fcc955 100644
--- a/tests/codegen/simd/packed-simd.rs
+++ b/tests/codegen/simd/packed-simd.rs
@@ -9,18 +9,14 @@
 use core::intrinsics::simd as intrinsics;
 use core::{mem, ptr};
 
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::{PackedSimd, Simd as FullSimd};
+
 // Test codegen for not only "packed" but also "fully aligned" SIMD types, and conversion between
 // them. A repr(packed,simd) type with 3 elements can't exceed its element alignment, whereas the
 // same type as repr(simd) will instead have padding.
 
-#[repr(simd, packed)]
-#[derive(Copy, Clone)]
-pub struct PackedSimd<T, const N: usize>([T; N]);
-
-#[repr(simd)]
-#[derive(Copy, Clone)]
-pub struct FullSimd<T, const N: usize>([T; N]);
-
 // non-powers-of-two have padding and need to be expanded to full vectors
 fn load<T, const N: usize>(v: PackedSimd<T, N>) -> FullSimd<T, N> {
     unsafe {
diff --git a/tests/codegen/simd/simd_arith_offset.rs b/tests/codegen/simd/simd_arith_offset.rs
index b8af6fce332..210b4e9bb50 100644
--- a/tests/codegen/simd/simd_arith_offset.rs
+++ b/tests/codegen/simd/simd_arith_offset.rs
@@ -5,16 +5,14 @@
 #![crate_type = "lib"]
 #![feature(repr_simd, core_intrinsics)]
 
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
 use std::intrinsics::simd::simd_arith_offset;
 
-/// A vector of *const T.
-#[derive(Debug, Copy, Clone)]
-#[repr(simd)]
-pub struct SimdConstPtr<T, const LANES: usize>([*const T; LANES]);
+use minisimd::*;
 
-#[derive(Debug, Copy, Clone)]
-#[repr(simd)]
-pub struct Simd<T, const LANES: usize>([T; LANES]);
+/// A vector of *const T.
+pub type SimdConstPtr<T, const LANES: usize> = Simd<*const T, LANES>;
 
 // CHECK-LABEL: smoke
 #[no_mangle]
diff --git a/tests/ui/simd/generics.rs b/tests/ui/simd/generics.rs
index 1ae08fef7cd..54e76f7bc5d 100644
--- a/tests/ui/simd/generics.rs
+++ b/tests/ui/simd/generics.rs
@@ -2,24 +2,18 @@
 #![allow(non_camel_case_types)]
 #![feature(repr_simd, core_intrinsics)]
 
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
 use std::intrinsics::simd::simd_add;
 use std::ops;
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct f32x4([f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct A<const N: usize>([f32; N]);
+type A<const N: usize> = Simd<f32, N>;
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct B<T>([T; 4]);
+type B<T> = Simd<T, 4>;
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct C<T, const N: usize>([T; N]);
+type C<T, const N: usize> = Simd<T, N>;
 
 fn add<T: ops::Add<Output = T>>(lhs: T, rhs: T) -> T {
     lhs + rhs
@@ -33,48 +27,24 @@ impl ops::Add for f32x4 {
     }
 }
 
-impl ops::Add for A<4> {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self {
-        unsafe { simd_add(self, rhs) }
-    }
-}
-
-impl ops::Add for B<f32> {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self {
-        unsafe { simd_add(self, rhs) }
-    }
-}
-
-impl ops::Add for C<f32, 4> {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self {
-        unsafe { simd_add(self, rhs) }
-    }
-}
-
 pub fn main() {
     let x = [1.0f32, 2.0f32, 3.0f32, 4.0f32];
     let y = [2.0f32, 4.0f32, 6.0f32, 8.0f32];
 
     // lame-o
-    let a = f32x4([1.0f32, 2.0f32, 3.0f32, 4.0f32]);
-    let f32x4([a0, a1, a2, a3]) = add(a, a);
+    let a = f32x4::from_array([1.0f32, 2.0f32, 3.0f32, 4.0f32]);
+    let [a0, a1, a2, a3] = add(a, a).into_array();
     assert_eq!(a0, 2.0f32);
     assert_eq!(a1, 4.0f32);
     assert_eq!(a2, 6.0f32);
     assert_eq!(a3, 8.0f32);
 
-    let a = A(x);
-    assert_eq!(add(a, a).0, y);
+    let a = A::from_array(x);
+    assert_eq!(add(a, a).into_array(), y);
 
-    let b = B(x);
-    assert_eq!(add(b, b).0, y);
+    let b = B::from_array(x);
+    assert_eq!(add(b, b).into_array(), y);
 
-    let c = C(x);
-    assert_eq!(add(c, c).0, y);
+    let c = C::from_array(x);
+    assert_eq!(add(c, c).into_array(), y);
 }
diff --git a/tests/ui/simd/intrinsic/float-math-pass.rs b/tests/ui/simd/intrinsic/float-math-pass.rs
index 01fed8537d0..743aae8d1c3 100644
--- a/tests/ui/simd/intrinsic/float-math-pass.rs
+++ b/tests/ui/simd/intrinsic/float-math-pass.rs
@@ -11,9 +11,9 @@
 #![feature(repr_simd, intrinsics, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct f32x4(pub [f32; 4]);
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
 use std::intrinsics::simd::*;
 
@@ -27,19 +27,19 @@ macro_rules! assert_approx_eq {
     ($a:expr, $b:expr) => {{
         let a = $a;
         let b = $b;
-        assert_approx_eq_f32!(a.0[0], b.0[0]);
-        assert_approx_eq_f32!(a.0[1], b.0[1]);
-        assert_approx_eq_f32!(a.0[2], b.0[2]);
-        assert_approx_eq_f32!(a.0[3], b.0[3]);
+        assert_approx_eq_f32!(a[0], b[0]);
+        assert_approx_eq_f32!(a[1], b[1]);
+        assert_approx_eq_f32!(a[2], b[2]);
+        assert_approx_eq_f32!(a[3], b[3]);
     }};
 }
 
 fn main() {
-    let x = f32x4([1.0, 1.0, 1.0, 1.0]);
-    let y = f32x4([-1.0, -1.0, -1.0, -1.0]);
-    let z = f32x4([0.0, 0.0, 0.0, 0.0]);
+    let x = f32x4::from_array([1.0, 1.0, 1.0, 1.0]);
+    let y = f32x4::from_array([-1.0, -1.0, -1.0, -1.0]);
+    let z = f32x4::from_array([0.0, 0.0, 0.0, 0.0]);
 
-    let h = f32x4([0.5, 0.5, 0.5, 0.5]);
+    let h = f32x4::from_array([0.5, 0.5, 0.5, 0.5]);
 
     unsafe {
         let r = simd_fabs(y);
diff --git a/tests/ui/simd/intrinsic/float-minmax-pass.rs b/tests/ui/simd/intrinsic/float-minmax-pass.rs
index 00c0d8cea3f..12210ba0ad1 100644
--- a/tests/ui/simd/intrinsic/float-minmax-pass.rs
+++ b/tests/ui/simd/intrinsic/float-minmax-pass.rs
@@ -6,15 +6,15 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct f32x4(pub [f32; 4]);
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
 use std::intrinsics::simd::*;
 
 fn main() {
-    let x = f32x4([1.0, 2.0, 3.0, 4.0]);
-    let y = f32x4([2.0, 1.0, 4.0, 3.0]);
+    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;
@@ -23,13 +23,13 @@ fn main() {
     #[cfg(any(target_arch = "mips", target_arch = "mips64"))]
     let nan = f32::from_bits(f32::NAN.to_bits() - 1);
 
-    let n = f32x4([nan, nan, nan, nan]);
+    let n = f32x4::from_array([nan, nan, nan, nan]);
 
     unsafe {
         let min0 = simd_fmin(x, y);
         let min1 = simd_fmin(y, x);
         assert_eq!(min0, min1);
-        let e = f32x4([1.0, 1.0, 3.0, 3.0]);
+        let e = f32x4::from_array([1.0, 1.0, 3.0, 3.0]);
         assert_eq!(min0, e);
         let minn = simd_fmin(x, n);
         assert_eq!(minn, x);
@@ -39,7 +39,7 @@ fn main() {
         let max0 = simd_fmax(x, y);
         let max1 = simd_fmax(y, x);
         assert_eq!(max0, max1);
-        let e = f32x4([2.0, 2.0, 4.0, 4.0]);
+        let e = f32x4::from_array([2.0, 2.0, 4.0, 4.0]);
         assert_eq!(max0, e);
         let maxn = simd_fmax(x, n);
         assert_eq!(maxn, x);
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs b/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
index 4c97fb2141d..bf38a8b1720 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
@@ -2,80 +2,77 @@
 #![allow(non_camel_case_types)]
 #![feature(repr_simd, core_intrinsics)]
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct i32x4(pub [i32; 4]);
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct U32<const N: usize>([u32; N]);
-
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct f32x4(pub [f32; 4]);
+type U32<const N: usize> = Simd<u32, N>;
 
 macro_rules! all_eq {
-    ($a: expr, $b: expr) => {{
+    ($a: expr, $b: expr $(,)?) => {{
         let a = $a;
         let b = $b;
-        assert!(a.0 == b.0);
+        assert!(a == b);
     }};
 }
 
 use std::intrinsics::simd::*;
 
 fn main() {
-    let x1 = i32x4([1, 2, 3, 4]);
-    let y1 = U32::<4>([1, 2, 3, 4]);
-    let z1 = f32x4([1.0, 2.0, 3.0, 4.0]);
-    let x2 = i32x4([2, 3, 4, 5]);
-    let y2 = U32::<4>([2, 3, 4, 5]);
-    let z2 = f32x4([2.0, 3.0, 4.0, 5.0]);
-    let x3 = i32x4([0, i32::MAX, i32::MIN, -1_i32]);
-    let y3 = U32::<4>([0, i32::MAX as _, i32::MIN as _, -1_i32 as _]);
+    let x1 = i32x4::from_array([1, 2, 3, 4]);
+    let y1 = U32::<4>::from_array([1, 2, 3, 4]);
+    let z1 = f32x4::from_array([1.0, 2.0, 3.0, 4.0]);
+    let x2 = i32x4::from_array([2, 3, 4, 5]);
+    let y2 = U32::<4>::from_array([2, 3, 4, 5]);
+    let z2 = f32x4::from_array([2.0, 3.0, 4.0, 5.0]);
+    let x3 = i32x4::from_array([0, i32::MAX, i32::MIN, -1_i32]);
+    let y3 = U32::<4>::from_array([0, i32::MAX as _, i32::MIN as _, -1_i32 as _]);
 
     unsafe {
-        all_eq!(simd_add(x1, x2), i32x4([3, 5, 7, 9]));
-        all_eq!(simd_add(x2, x1), i32x4([3, 5, 7, 9]));
-        all_eq!(simd_add(y1, y2), U32::<4>([3, 5, 7, 9]));
-        all_eq!(simd_add(y2, y1), U32::<4>([3, 5, 7, 9]));
-        all_eq!(simd_add(z1, z2), f32x4([3.0, 5.0, 7.0, 9.0]));
-        all_eq!(simd_add(z2, z1), f32x4([3.0, 5.0, 7.0, 9.0]));
-
-        all_eq!(simd_mul(x1, x2), i32x4([2, 6, 12, 20]));
-        all_eq!(simd_mul(x2, x1), i32x4([2, 6, 12, 20]));
-        all_eq!(simd_mul(y1, y2), U32::<4>([2, 6, 12, 20]));
-        all_eq!(simd_mul(y2, y1), U32::<4>([2, 6, 12, 20]));
-        all_eq!(simd_mul(z1, z2), f32x4([2.0, 6.0, 12.0, 20.0]));
-        all_eq!(simd_mul(z2, z1), f32x4([2.0, 6.0, 12.0, 20.0]));
-
-        all_eq!(simd_sub(x2, x1), i32x4([1, 1, 1, 1]));
-        all_eq!(simd_sub(x1, x2), i32x4([-1, -1, -1, -1]));
-        all_eq!(simd_sub(y2, y1), U32::<4>([1, 1, 1, 1]));
-        all_eq!(simd_sub(y1, y2), U32::<4>([!0, !0, !0, !0]));
-        all_eq!(simd_sub(z2, z1), f32x4([1.0, 1.0, 1.0, 1.0]));
-        all_eq!(simd_sub(z1, z2), f32x4([-1.0, -1.0, -1.0, -1.0]));
-
-        all_eq!(simd_div(x1, x1), i32x4([1, 1, 1, 1]));
-        all_eq!(simd_div(i32x4([2, 4, 6, 8]), i32x4([2, 2, 2, 2])), x1);
-        all_eq!(simd_div(y1, y1), U32::<4>([1, 1, 1, 1]));
-        all_eq!(simd_div(U32::<4>([2, 4, 6, 8]), U32::<4>([2, 2, 2, 2])), y1);
-        all_eq!(simd_div(z1, z1), f32x4([1.0, 1.0, 1.0, 1.0]));
-        all_eq!(simd_div(z1, z2), f32x4([1.0 / 2.0, 2.0 / 3.0, 3.0 / 4.0, 4.0 / 5.0]));
-        all_eq!(simd_div(z2, z1), f32x4([2.0 / 1.0, 3.0 / 2.0, 4.0 / 3.0, 5.0 / 4.0]));
-
-        all_eq!(simd_rem(x1, x1), i32x4([0, 0, 0, 0]));
-        all_eq!(simd_rem(x2, x1), i32x4([0, 1, 1, 1]));
-        all_eq!(simd_rem(y1, y1), U32::<4>([0, 0, 0, 0]));
-        all_eq!(simd_rem(y2, y1), U32::<4>([0, 1, 1, 1]));
-        all_eq!(simd_rem(z1, z1), f32x4([0.0, 0.0, 0.0, 0.0]));
+        all_eq!(simd_add(x1, x2), i32x4::from_array([3, 5, 7, 9]));
+        all_eq!(simd_add(x2, x1), i32x4::from_array([3, 5, 7, 9]));
+        all_eq!(simd_add(y1, y2), U32::<4>::from_array([3, 5, 7, 9]));
+        all_eq!(simd_add(y2, y1), U32::<4>::from_array([3, 5, 7, 9]));
+        all_eq!(simd_add(z1, z2), f32x4::from_array([3.0, 5.0, 7.0, 9.0]));
+        all_eq!(simd_add(z2, z1), f32x4::from_array([3.0, 5.0, 7.0, 9.0]));
+
+        all_eq!(simd_mul(x1, x2), i32x4::from_array([2, 6, 12, 20]));
+        all_eq!(simd_mul(x2, x1), i32x4::from_array([2, 6, 12, 20]));
+        all_eq!(simd_mul(y1, y2), U32::<4>::from_array([2, 6, 12, 20]));
+        all_eq!(simd_mul(y2, y1), U32::<4>::from_array([2, 6, 12, 20]));
+        all_eq!(simd_mul(z1, z2), f32x4::from_array([2.0, 6.0, 12.0, 20.0]));
+        all_eq!(simd_mul(z2, z1), f32x4::from_array([2.0, 6.0, 12.0, 20.0]));
+
+        all_eq!(simd_sub(x2, x1), i32x4::from_array([1, 1, 1, 1]));
+        all_eq!(simd_sub(x1, x2), i32x4::from_array([-1, -1, -1, -1]));
+        all_eq!(simd_sub(y2, y1), U32::<4>::from_array([1, 1, 1, 1]));
+        all_eq!(simd_sub(y1, y2), U32::<4>::from_array([!0, !0, !0, !0]));
+        all_eq!(simd_sub(z2, z1), f32x4::from_array([1.0, 1.0, 1.0, 1.0]));
+        all_eq!(simd_sub(z1, z2), f32x4::from_array([-1.0, -1.0, -1.0, -1.0]));
+
+        all_eq!(simd_div(x1, x1), i32x4::from_array([1, 1, 1, 1]));
+        all_eq!(simd_div(i32x4::from_array([2, 4, 6, 8]), i32x4::from_array([2, 2, 2, 2])), x1);
+        all_eq!(simd_div(y1, y1), U32::<4>::from_array([1, 1, 1, 1]));
+        all_eq!(
+            simd_div(U32::<4>::from_array([2, 4, 6, 8]), U32::<4>::from_array([2, 2, 2, 2])),
+            y1,
+        );
+        all_eq!(simd_div(z1, z1), f32x4::from_array([1.0, 1.0, 1.0, 1.0]));
+        all_eq!(simd_div(z1, z2), f32x4::from_array([1.0 / 2.0, 2.0 / 3.0, 3.0 / 4.0, 4.0 / 5.0]));
+        all_eq!(simd_div(z2, z1), f32x4::from_array([2.0 / 1.0, 3.0 / 2.0, 4.0 / 3.0, 5.0 / 4.0]));
+
+        all_eq!(simd_rem(x1, x1), i32x4::from_array([0, 0, 0, 0]));
+        all_eq!(simd_rem(x2, x1), i32x4::from_array([0, 1, 1, 1]));
+        all_eq!(simd_rem(y1, y1), U32::<4>::from_array([0, 0, 0, 0]));
+        all_eq!(simd_rem(y2, y1), U32::<4>::from_array([0, 1, 1, 1]));
+        all_eq!(simd_rem(z1, z1), f32x4::from_array([0.0, 0.0, 0.0, 0.0]));
         all_eq!(simd_rem(z1, z2), z1);
-        all_eq!(simd_rem(z2, z1), f32x4([0.0, 1.0, 1.0, 1.0]));
+        all_eq!(simd_rem(z2, z1), f32x4::from_array([0.0, 1.0, 1.0, 1.0]));
 
-        all_eq!(simd_shl(x1, x2), i32x4([1 << 2, 2 << 3, 3 << 4, 4 << 5]));
-        all_eq!(simd_shl(x2, x1), i32x4([2 << 1, 3 << 2, 4 << 3, 5 << 4]));
-        all_eq!(simd_shl(y1, y2), U32::<4>([1 << 2, 2 << 3, 3 << 4, 4 << 5]));
-        all_eq!(simd_shl(y2, y1), U32::<4>([2 << 1, 3 << 2, 4 << 3, 5 << 4]));
+        all_eq!(simd_shl(x1, x2), i32x4::from_array([1 << 2, 2 << 3, 3 << 4, 4 << 5]));
+        all_eq!(simd_shl(x2, x1), i32x4::from_array([2 << 1, 3 << 2, 4 << 3, 5 << 4]));
+        all_eq!(simd_shl(y1, y2), U32::<4>::from_array([1 << 2, 2 << 3, 3 << 4, 4 << 5]));
+        all_eq!(simd_shl(y2, y1), U32::<4>::from_array([2 << 1, 3 << 2, 4 << 3, 5 << 4]));
 
         // test right-shift by assuming left-shift is correct
         all_eq!(simd_shr(simd_shl(x1, x2), x2), x1);
@@ -85,7 +82,7 @@ fn main() {
 
         all_eq!(
             simd_funnel_shl(x1, x2, x1),
-            i32x4([
+            i32x4::from_array([
                 (1 << 1) | (2 >> 31),
                 (2 << 2) | (3 >> 30),
                 (3 << 3) | (4 >> 29),
@@ -94,7 +91,7 @@ fn main() {
         );
         all_eq!(
             simd_funnel_shl(x2, x1, x1),
-            i32x4([
+            i32x4::from_array([
                 (2 << 1) | (1 >> 31),
                 (3 << 2) | (2 >> 30),
                 (4 << 3) | (3 >> 29),
@@ -103,7 +100,7 @@ fn main() {
         );
         all_eq!(
             simd_funnel_shl(y1, y2, y1),
-            U32::<4>([
+            U32::<4>::from_array([
                 (1 << 1) | (2 >> 31),
                 (2 << 2) | (3 >> 30),
                 (3 << 3) | (4 >> 29),
@@ -112,7 +109,7 @@ fn main() {
         );
         all_eq!(
             simd_funnel_shl(y2, y1, y1),
-            U32::<4>([
+            U32::<4>::from_array([
                 (2 << 1) | (1 >> 31),
                 (3 << 2) | (2 >> 30),
                 (4 << 3) | (3 >> 29),
@@ -122,7 +119,7 @@ fn main() {
 
         all_eq!(
             simd_funnel_shr(x1, x2, x1),
-            i32x4([
+            i32x4::from_array([
                 (1 << 31) | (2 >> 1),
                 (2 << 30) | (3 >> 2),
                 (3 << 29) | (4 >> 3),
@@ -131,7 +128,7 @@ fn main() {
         );
         all_eq!(
             simd_funnel_shr(x2, x1, x1),
-            i32x4([
+            i32x4::from_array([
                 (2 << 31) | (1 >> 1),
                 (3 << 30) | (2 >> 2),
                 (4 << 29) | (3 >> 3),
@@ -140,7 +137,7 @@ fn main() {
         );
         all_eq!(
             simd_funnel_shr(y1, y2, y1),
-            U32::<4>([
+            U32::<4>::from_array([
                 (1 << 31) | (2 >> 1),
                 (2 << 30) | (3 >> 2),
                 (3 << 29) | (4 >> 3),
@@ -149,7 +146,7 @@ fn main() {
         );
         all_eq!(
             simd_funnel_shr(y2, y1, y1),
-            U32::<4>([
+            U32::<4>::from_array([
                 (2 << 31) | (1 >> 1),
                 (3 << 30) | (2 >> 2),
                 (4 << 29) | (3 >> 3),
@@ -159,52 +156,69 @@ fn main() {
 
         // ensure we get logical vs. arithmetic shifts correct
         let (a, b, c, d) = (-12, -123, -1234, -12345);
-        all_eq!(simd_shr(i32x4([a, b, c, d]), x1), i32x4([a >> 1, b >> 2, c >> 3, d >> 4]));
         all_eq!(
-            simd_shr(U32::<4>([a as u32, b as u32, c as u32, d as u32]), y1),
-            U32::<4>([(a as u32) >> 1, (b as u32) >> 2, (c as u32) >> 3, (d as u32) >> 4])
+            simd_shr(i32x4::from_array([a, b, c, d]), x1),
+            i32x4::from_array([a >> 1, b >> 2, c >> 3, d >> 4]),
+        );
+        all_eq!(
+            simd_shr(U32::<4>::from_array([a as u32, b as u32, c as u32, d as u32]), y1),
+            U32::<4>::from_array([
+                (a as u32) >> 1,
+                (b as u32) >> 2,
+                (c as u32) >> 3,
+                (d as u32) >> 4,
+            ]),
         );
 
-        all_eq!(simd_and(x1, x2), i32x4([0, 2, 0, 4]));
-        all_eq!(simd_and(x2, x1), i32x4([0, 2, 0, 4]));
-        all_eq!(simd_and(y1, y2), U32::<4>([0, 2, 0, 4]));
-        all_eq!(simd_and(y2, y1), U32::<4>([0, 2, 0, 4]));
+        all_eq!(simd_and(x1, x2), i32x4::from_array([0, 2, 0, 4]));
+        all_eq!(simd_and(x2, x1), i32x4::from_array([0, 2, 0, 4]));
+        all_eq!(simd_and(y1, y2), U32::<4>::from_array([0, 2, 0, 4]));
+        all_eq!(simd_and(y2, y1), U32::<4>::from_array([0, 2, 0, 4]));
 
-        all_eq!(simd_or(x1, x2), i32x4([3, 3, 7, 5]));
-        all_eq!(simd_or(x2, x1), i32x4([3, 3, 7, 5]));
-        all_eq!(simd_or(y1, y2), U32::<4>([3, 3, 7, 5]));
-        all_eq!(simd_or(y2, y1), U32::<4>([3, 3, 7, 5]));
+        all_eq!(simd_or(x1, x2), i32x4::from_array([3, 3, 7, 5]));
+        all_eq!(simd_or(x2, x1), i32x4::from_array([3, 3, 7, 5]));
+        all_eq!(simd_or(y1, y2), U32::<4>::from_array([3, 3, 7, 5]));
+        all_eq!(simd_or(y2, y1), U32::<4>::from_array([3, 3, 7, 5]));
 
-        all_eq!(simd_xor(x1, x2), i32x4([3, 1, 7, 1]));
-        all_eq!(simd_xor(x2, x1), i32x4([3, 1, 7, 1]));
-        all_eq!(simd_xor(y1, y2), U32::<4>([3, 1, 7, 1]));
-        all_eq!(simd_xor(y2, y1), U32::<4>([3, 1, 7, 1]));
+        all_eq!(simd_xor(x1, x2), i32x4::from_array([3, 1, 7, 1]));
+        all_eq!(simd_xor(x2, x1), i32x4::from_array([3, 1, 7, 1]));
+        all_eq!(simd_xor(y1, y2), U32::<4>::from_array([3, 1, 7, 1]));
+        all_eq!(simd_xor(y2, y1), U32::<4>::from_array([3, 1, 7, 1]));
 
-        all_eq!(simd_neg(x1), i32x4([-1, -2, -3, -4]));
-        all_eq!(simd_neg(x2), i32x4([-2, -3, -4, -5]));
-        all_eq!(simd_neg(z1), f32x4([-1.0, -2.0, -3.0, -4.0]));
-        all_eq!(simd_neg(z2), f32x4([-2.0, -3.0, -4.0, -5.0]));
+        all_eq!(simd_neg(x1), i32x4::from_array([-1, -2, -3, -4]));
+        all_eq!(simd_neg(x2), i32x4::from_array([-2, -3, -4, -5]));
+        all_eq!(simd_neg(z1), f32x4::from_array([-1.0, -2.0, -3.0, -4.0]));
+        all_eq!(simd_neg(z2), f32x4::from_array([-2.0, -3.0, -4.0, -5.0]));
 
-        all_eq!(simd_bswap(x1), i32x4([0x01000000, 0x02000000, 0x03000000, 0x04000000]));
-        all_eq!(simd_bswap(y1), U32::<4>([0x01000000, 0x02000000, 0x03000000, 0x04000000]));
+        all_eq!(
+            simd_bswap(x1),
+            i32x4::from_array([0x01000000, 0x02000000, 0x03000000, 0x04000000]),
+        );
+        all_eq!(
+            simd_bswap(y1),
+            U32::<4>::from_array([0x01000000, 0x02000000, 0x03000000, 0x04000000]),
+        );
 
         all_eq!(
             simd_bitreverse(x1),
-            i32x4([0x80000000u32 as i32, 0x40000000, 0xc0000000u32 as i32, 0x20000000])
+            i32x4::from_array([0x80000000u32 as i32, 0x40000000, 0xc0000000u32 as i32, 0x20000000])
+        );
+        all_eq!(
+            simd_bitreverse(y1),
+            U32::<4>::from_array([0x80000000, 0x40000000, 0xc0000000, 0x20000000]),
         );
-        all_eq!(simd_bitreverse(y1), U32::<4>([0x80000000, 0x40000000, 0xc0000000, 0x20000000]));
 
-        all_eq!(simd_ctlz(x1), i32x4([31, 30, 30, 29]));
-        all_eq!(simd_ctlz(y1), U32::<4>([31, 30, 30, 29]));
+        all_eq!(simd_ctlz(x1), i32x4::from_array([31, 30, 30, 29]));
+        all_eq!(simd_ctlz(y1), U32::<4>::from_array([31, 30, 30, 29]));
 
-        all_eq!(simd_ctpop(x1), i32x4([1, 1, 2, 1]));
-        all_eq!(simd_ctpop(y1), U32::<4>([1, 1, 2, 1]));
-        all_eq!(simd_ctpop(x2), i32x4([1, 2, 1, 2]));
-        all_eq!(simd_ctpop(y2), U32::<4>([1, 2, 1, 2]));
-        all_eq!(simd_ctpop(x3), i32x4([0, 31, 1, 32]));
-        all_eq!(simd_ctpop(y3), U32::<4>([0, 31, 1, 32]));
+        all_eq!(simd_ctpop(x1), i32x4::from_array([1, 1, 2, 1]));
+        all_eq!(simd_ctpop(y1), U32::<4>::from_array([1, 1, 2, 1]));
+        all_eq!(simd_ctpop(x2), i32x4::from_array([1, 2, 1, 2]));
+        all_eq!(simd_ctpop(y2), U32::<4>::from_array([1, 2, 1, 2]));
+        all_eq!(simd_ctpop(x3), i32x4::from_array([0, 31, 1, 32]));
+        all_eq!(simd_ctpop(y3), U32::<4>::from_array([0, 31, 1, 32]));
 
-        all_eq!(simd_cttz(x1), i32x4([0, 1, 0, 2]));
-        all_eq!(simd_cttz(y1), U32::<4>([0, 1, 0, 2]));
+        all_eq!(simd_cttz(x1), i32x4::from_array([0, 1, 0, 2]));
+        all_eq!(simd_cttz(y1), U32::<4>::from_array([0, 1, 0, 2]));
     }
 }
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs b/tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs
index 4d12a312331..a997f123703 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs
@@ -4,26 +4,24 @@
 #![allow(non_camel_case_types)]
 #![feature(repr_simd, core_intrinsics)]
 
-use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct u32x4(pub [u32; 4]);
+use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct I32<const N: usize>([i32; N]);
+type I32<const N: usize> = Simd<i32, N>;
 
 fn main() {
     // unsigned
     {
         const M: u32 = u32::MAX;
 
-        let a = u32x4([1, 2, 3, 4]);
-        let b = u32x4([2, 4, 6, 8]);
-        let m = u32x4([M, M, M, M]);
-        let m1 = u32x4([M - 1, M - 1, M - 1, M - 1]);
-        let z = u32x4([0, 0, 0, 0]);
+        let a = u32x4::from_array([1, 2, 3, 4]);
+        let b = u32x4::from_array([2, 4, 6, 8]);
+        let m = u32x4::from_array([M, M, M, M]);
+        let m1 = u32x4::from_array([M - 1, M - 1, M - 1, M - 1]);
+        let z = u32x4::from_array([0, 0, 0, 0]);
 
         unsafe {
             assert_eq!(simd_saturating_add(z, z), z);
@@ -48,41 +46,41 @@ fn main() {
         const MIN: i32 = i32::MIN;
         const MAX: i32 = i32::MAX;
 
-        let a = I32::<4>([1, 2, 3, 4]);
-        let b = I32::<4>([2, 4, 6, 8]);
-        let c = I32::<4>([-1, -2, -3, -4]);
-        let d = I32::<4>([-2, -4, -6, -8]);
+        let a = I32::<4>::from_array([1, 2, 3, 4]);
+        let b = I32::<4>::from_array([2, 4, 6, 8]);
+        let c = I32::<4>::from_array([-1, -2, -3, -4]);
+        let d = I32::<4>::from_array([-2, -4, -6, -8]);
 
-        let max = I32::<4>([MAX, MAX, MAX, MAX]);
-        let max1 = I32::<4>([MAX - 1, MAX - 1, MAX - 1, MAX - 1]);
-        let min = I32::<4>([MIN, MIN, MIN, MIN]);
-        let min1 = I32::<4>([MIN + 1, MIN + 1, MIN + 1, MIN + 1]);
+        let max = I32::<4>::from_array([MAX, MAX, MAX, MAX]);
+        let max1 = I32::<4>::from_array([MAX - 1, MAX - 1, MAX - 1, MAX - 1]);
+        let min = I32::<4>::from_array([MIN, MIN, MIN, MIN]);
+        let min1 = I32::<4>::from_array([MIN + 1, MIN + 1, MIN + 1, MIN + 1]);
 
-        let z = I32::<4>([0, 0, 0, 0]);
+        let z = I32::<4>::from_array([0, 0, 0, 0]);
 
         unsafe {
-            assert_eq!(simd_saturating_add(z, z).0, z.0);
-            assert_eq!(simd_saturating_add(z, a).0, a.0);
-            assert_eq!(simd_saturating_add(b, z).0, b.0);
-            assert_eq!(simd_saturating_add(a, a).0, b.0);
-            assert_eq!(simd_saturating_add(a, max).0, max.0);
-            assert_eq!(simd_saturating_add(max, b).0, max.0);
-            assert_eq!(simd_saturating_add(max1, a).0, max.0);
-            assert_eq!(simd_saturating_add(min1, z).0, min1.0);
-            assert_eq!(simd_saturating_add(min, z).0, min.0);
-            assert_eq!(simd_saturating_add(min1, c).0, min.0);
-            assert_eq!(simd_saturating_add(min, c).0, min.0);
-            assert_eq!(simd_saturating_add(min1, d).0, min.0);
-            assert_eq!(simd_saturating_add(min, d).0, min.0);
+            assert_eq!(simd_saturating_add(z, z), z);
+            assert_eq!(simd_saturating_add(z, a), a);
+            assert_eq!(simd_saturating_add(b, z), b);
+            assert_eq!(simd_saturating_add(a, a), b);
+            assert_eq!(simd_saturating_add(a, max), max);
+            assert_eq!(simd_saturating_add(max, b), max);
+            assert_eq!(simd_saturating_add(max1, a), max);
+            assert_eq!(simd_saturating_add(min1, z), min1);
+            assert_eq!(simd_saturating_add(min, z), min);
+            assert_eq!(simd_saturating_add(min1, c), min);
+            assert_eq!(simd_saturating_add(min, c), min);
+            assert_eq!(simd_saturating_add(min1, d), min);
+            assert_eq!(simd_saturating_add(min, d), min);
 
-            assert_eq!(simd_saturating_sub(b, z).0, b.0);
-            assert_eq!(simd_saturating_sub(b, a).0, a.0);
-            assert_eq!(simd_saturating_sub(a, a).0, z.0);
-            assert_eq!(simd_saturating_sub(a, b).0, c.0);
-            assert_eq!(simd_saturating_sub(z, max).0, min1.0);
-            assert_eq!(simd_saturating_sub(min1, z).0, min1.0);
-            assert_eq!(simd_saturating_sub(min1, a).0, min.0);
-            assert_eq!(simd_saturating_sub(min1, b).0, min.0);
+            assert_eq!(simd_saturating_sub(b, z), b);
+            assert_eq!(simd_saturating_sub(b, a), a);
+            assert_eq!(simd_saturating_sub(a, a), z);
+            assert_eq!(simd_saturating_sub(a, b), c);
+            assert_eq!(simd_saturating_sub(z, max), min1);
+            assert_eq!(simd_saturating_sub(min1, z), min1);
+            assert_eq!(simd_saturating_sub(min1, a), min);
+            assert_eq!(simd_saturating_sub(min1, b), min);
         }
     }
 }
diff --git a/tests/ui/simd/intrinsic/generic-as.rs b/tests/ui/simd/intrinsic/generic-as.rs
index da53211cbc7..f9ed416b6ff 100644
--- a/tests/ui/simd/intrinsic/generic-as.rs
+++ b/tests/ui/simd/intrinsic/generic-as.rs
@@ -2,45 +2,47 @@
 
 #![feature(repr_simd, core_intrinsics)]
 
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
 use std::intrinsics::simd::simd_as;
 
-#[derive(Copy, Clone)]
-#[repr(simd)]
-struct V<T>([T; 2]);
+type V<T> = Simd<T, 2>;
 
 fn main() {
     unsafe {
-        let u = V::<u32>([u32::MIN, u32::MAX]);
+        let u: V::<u32> = Simd([u32::MIN, u32::MAX]);
         let i: V<i16> = simd_as(u);
-        assert_eq!(i.0[0], u.0[0] as i16);
-        assert_eq!(i.0[1], u.0[1] as i16);
+        assert_eq!(i[0], u[0] as i16);
+        assert_eq!(i[1], u[1] as i16);
     }
 
     unsafe {
-        let f = V::<f32>([f32::MIN, f32::MAX]);
+        let f: V::<f32> = Simd([f32::MIN, f32::MAX]);
         let i: V<i16> = simd_as(f);
-        assert_eq!(i.0[0], f.0[0] as i16);
-        assert_eq!(i.0[1], f.0[1] as i16);
+        assert_eq!(i[0], f[0] as i16);
+        assert_eq!(i[1], f[1] as i16);
     }
 
     unsafe {
-        let f = V::<f32>([f32::MIN, f32::MAX]);
+        let f: V::<f32> = Simd([f32::MIN, f32::MAX]);
         let u: V<u8> = simd_as(f);
-        assert_eq!(u.0[0], f.0[0] as u8);
-        assert_eq!(u.0[1], f.0[1] as u8);
+        assert_eq!(u[0], f[0] as u8);
+        assert_eq!(u[1], f[1] as u8);
     }
 
     unsafe {
-        let f = V::<f64>([f64::MIN, f64::MAX]);
+        let f: V::<f64> = Simd([f64::MIN, f64::MAX]);
         let i: V<isize> = simd_as(f);
-        assert_eq!(i.0[0], f.0[0] as isize);
-        assert_eq!(i.0[1], f.0[1] as isize);
+        assert_eq!(i[0], f[0] as isize);
+        assert_eq!(i[1], f[1] as isize);
     }
 
     unsafe {
-        let f = V::<f64>([f64::MIN, f64::MAX]);
+        let f: V::<f64> = Simd([f64::MIN, f64::MAX]);
         let u: V<usize> = simd_as(f);
-        assert_eq!(u.0[0], f.0[0] as usize);
-        assert_eq!(u.0[1], f.0[1] as usize);
+        assert_eq!(u[0], f[0] as usize);
+        assert_eq!(u[1], f[1] as usize);
     }
 }
diff --git a/tests/ui/simd/intrinsic/generic-bswap-byte.rs b/tests/ui/simd/intrinsic/generic-bswap-byte.rs
index 903a07656a7..d30a560b1c2 100644
--- a/tests/ui/simd/intrinsic/generic-bswap-byte.rs
+++ b/tests/ui/simd/intrinsic/generic-bswap-byte.rs
@@ -2,19 +2,15 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_bswap;
-
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct i8x4([i8; 4]);
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct u8x4([u8; 4]);
+use std::intrinsics::simd::simd_bswap;
 
 fn main() {
     unsafe {
-        assert_eq!(simd_bswap(i8x4([0, 1, 2, 3])).0, [0, 1, 2, 3]);
-        assert_eq!(simd_bswap(u8x4([0, 1, 2, 3])).0, [0, 1, 2, 3]);
+        assert_eq!(simd_bswap(i8x4::from_array([0, 1, 2, 3])).into_array(), [0, 1, 2, 3]);
+        assert_eq!(simd_bswap(u8x4::from_array([0, 1, 2, 3])).into_array(), [0, 1, 2, 3]);
     }
 }
diff --git a/tests/ui/simd/intrinsic/generic-cast-pass.rs b/tests/ui/simd/intrinsic/generic-cast-pass.rs
index 7a4663bcad2..0c3b00d65bf 100644
--- a/tests/ui/simd/intrinsic/generic-cast-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-cast-pass.rs
@@ -2,55 +2,57 @@
 
 #![feature(repr_simd, core_intrinsics)]
 
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
 use std::intrinsics::simd::simd_cast;
 
 use std::cmp::{max, min};
 
-#[derive(Copy, Clone)]
-#[repr(simd)]
-struct V<T>([T; 2]);
+type V<T> = Simd<T, 2>;
 
 fn main() {
     unsafe {
-        let u = V::<u32>([i16::MIN as u32, i16::MAX as u32]);
+        let u: V::<u32> = Simd([i16::MIN as u32, i16::MAX as u32]);
         let i: V<i16> = simd_cast(u);
-        assert_eq!(i.0[0], u.0[0] as i16);
-        assert_eq!(i.0[1], u.0[1] as i16);
+        assert_eq!(i[0], u[0] as i16);
+        assert_eq!(i[1], u[1] as i16);
     }
 
     unsafe {
-        let f = V::<f32>([i16::MIN as f32, i16::MAX as f32]);
+        let f: V::<f32> = Simd([i16::MIN as f32, i16::MAX as f32]);
         let i: V<i16> = simd_cast(f);
-        assert_eq!(i.0[0], f.0[0] as i16);
-        assert_eq!(i.0[1], f.0[1] as i16);
+        assert_eq!(i[0], f[0] as i16);
+        assert_eq!(i[1], f[1] as i16);
     }
 
     unsafe {
-        let f = V::<f32>([u8::MIN as f32, u8::MAX as f32]);
+        let f: V::<f32> = Simd([u8::MIN as f32, u8::MAX as f32]);
         let u: V<u8> = simd_cast(f);
-        assert_eq!(u.0[0], f.0[0] as u8);
-        assert_eq!(u.0[1], f.0[1] as u8);
+        assert_eq!(u[0], f[0] as u8);
+        assert_eq!(u[1], f[1] as u8);
     }
 
     unsafe {
         // We would like to do isize::MIN..=isize::MAX, but those values are not representable in
         // an f64, so we clamp to the range of an i32 to prevent running into UB.
-        let f = V::<f64>([
+        let f: V::<f64> = Simd([
             max(isize::MIN, i32::MIN as isize) as f64,
             min(isize::MAX, i32::MAX as isize) as f64,
         ]);
         let i: V<isize> = simd_cast(f);
-        assert_eq!(i.0[0], f.0[0] as isize);
-        assert_eq!(i.0[1], f.0[1] as isize);
+        assert_eq!(i[0], f[0] as isize);
+        assert_eq!(i[1], f[1] as isize);
     }
 
     unsafe {
-        let f = V::<f64>([
+        let f: V::<f64> = Simd([
             max(usize::MIN, u32::MIN as usize) as f64,
             min(usize::MAX, u32::MAX as usize) as f64,
         ]);
         let u: V<usize> = simd_cast(f);
-        assert_eq!(u.0[0], f.0[0] as usize);
-        assert_eq!(u.0[1], f.0[1] as usize);
+        assert_eq!(u[0], f[0] as usize);
+        assert_eq!(u[1], f[1] as usize);
     }
 }
diff --git a/tests/ui/simd/intrinsic/generic-cast-pointer-width.rs b/tests/ui/simd/intrinsic/generic-cast-pointer-width.rs
index ea34e9ffeb8..594d1d25d16 100644
--- a/tests/ui/simd/intrinsic/generic-cast-pointer-width.rs
+++ b/tests/ui/simd/intrinsic/generic-cast-pointer-width.rs
@@ -1,18 +1,24 @@
 //@ run-pass
 #![feature(repr_simd, core_intrinsics)]
 
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
 use std::intrinsics::simd::simd_cast;
 
-#[derive(Copy, Clone)]
-#[repr(simd)]
-struct V<T>([T; 4]);
+type V<T> = Simd<T, 4>;
 
 fn main() {
-    let u = V::<usize>([0, 1, 2, 3]);
+    let u: V::<usize> = Simd([0, 1, 2, 3]);
     let uu32: V<u32> = unsafe { simd_cast(u) };
     let ui64: V<i64> = unsafe { simd_cast(u) };
 
-    for (u, (uu32, ui64)) in u.0.iter().zip(uu32.0.iter().zip(ui64.0.iter())) {
+    for (u, (uu32, ui64)) in u
+        .as_array()
+        .iter()
+        .zip(uu32.as_array().iter().zip(ui64.as_array().iter()))
+    {
         assert_eq!(*u as u32, *uu32);
         assert_eq!(*u as i64, *ui64);
     }
diff --git a/tests/ui/simd/intrinsic/generic-comparison-pass.rs b/tests/ui/simd/intrinsic/generic-comparison-pass.rs
index 50a05eecb03..3e803e8f603 100644
--- a/tests/ui/simd/intrinsic/generic-comparison-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-comparison-pass.rs
@@ -3,17 +3,11 @@
 #![feature(repr_simd, core_intrinsics, macro_metavar_expr_concat)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::{simd_eq, simd_ge, simd_gt, simd_le, simd_lt, simd_ne};
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct i32x4([i32; 4]);
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct u32x4(pub [u32; 4]);
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct f32x4(pub [f32; 4]);
+use std::intrinsics::simd::{simd_eq, simd_ge, simd_gt, simd_le, simd_lt, simd_ne};
 
 macro_rules! cmp {
     ($method: ident($lhs: expr, $rhs: expr)) => {{
@@ -21,10 +15,11 @@ macro_rules! cmp {
         let rhs = $rhs;
         let e: u32x4 = ${concat(simd_, $method)}($lhs, $rhs);
         // assume the scalar version is correct/the behaviour we want.
-        assert!((e.0[0] != 0) == lhs.0[0].$method(&rhs.0[0]));
-        assert!((e.0[1] != 0) == lhs.0[1].$method(&rhs.0[1]));
-        assert!((e.0[2] != 0) == lhs.0[2].$method(&rhs.0[2]));
-        assert!((e.0[3] != 0) == lhs.0[3].$method(&rhs.0[3]));
+        let (lhs, rhs, e) = (lhs.as_array(), rhs.as_array(), e.as_array());
+        assert!((e[0] != 0) == lhs[0].$method(&rhs[0]));
+        assert!((e[1] != 0) == lhs[1].$method(&rhs[1]));
+        assert!((e[2] != 0) == lhs[2].$method(&rhs[2]));
+        assert!((e[3] != 0) == lhs[3].$method(&rhs[3]));
     }};
 }
 macro_rules! tests {
@@ -53,17 +48,17 @@ macro_rules! tests {
 fn main() {
     // 13 vs. -100 tests that we get signed vs. unsigned comparisons
     // correct (i32: 13 > -100, u32: 13 < -100).    let i1 = i32x4(10, -11, 12, 13);
-    let i1 = i32x4([10, -11, 12, 13]);
-    let i2 = i32x4([5, -5, 20, -100]);
-    let i3 = i32x4([10, -11, 20, -100]);
+    let i1 = i32x4::from_array([10, -11, 12, 13]);
+    let i2 = i32x4::from_array([5, -5, 20, -100]);
+    let i3 = i32x4::from_array([10, -11, 20, -100]);
 
-    let u1 = u32x4([10, !11 + 1, 12, 13]);
-    let u2 = u32x4([5, !5 + 1, 20, !100 + 1]);
-    let u3 = u32x4([10, !11 + 1, 20, !100 + 1]);
+    let u1 = u32x4::from_array([10, !11 + 1, 12, 13]);
+    let u2 = u32x4::from_array([5, !5 + 1, 20, !100 + 1]);
+    let u3 = u32x4::from_array([10, !11 + 1, 20, !100 + 1]);
 
-    let f1 = f32x4([10.0, -11.0, 12.0, 13.0]);
-    let f2 = f32x4([5.0, -5.0, 20.0, -100.0]);
-    let f3 = f32x4([10.0, -11.0, 20.0, -100.0]);
+    let f1 = f32x4::from_array([10.0, -11.0, 12.0, 13.0]);
+    let f2 = f32x4::from_array([5.0, -5.0, 20.0, -100.0]);
+    let f3 = f32x4::from_array([10.0, -11.0, 20.0, -100.0]);
 
     unsafe {
         tests! {
@@ -84,7 +79,7 @@ fn main() {
     // NAN comparisons are special:
     // -11 (*)    13
     // -5        -100 (*)
-    let f4 = f32x4([f32::NAN, f1.0[1], f32::NAN, f2.0[3]]);
+    let f4 = f32x4::from_array([f32::NAN, f1[1], f32::NAN, f2[3]]);
 
     unsafe {
         tests! {
diff --git a/tests/ui/simd/intrinsic/generic-elements-pass.rs b/tests/ui/simd/intrinsic/generic-elements-pass.rs
index e4d47cdb381..f441d992e11 100644
--- a/tests/ui/simd/intrinsic/generic-elements-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-elements-pass.rs
@@ -2,23 +2,14 @@
 
 #![feature(repr_simd, intrinsics, core_intrinsics)]
 
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
 use std::intrinsics::simd::{
     simd_extract, simd_extract_dyn, simd_insert, simd_insert_dyn, simd_shuffle,
 };
 
-#[repr(simd)]
-#[derive(Copy, Clone, Debug, PartialEq)]
-#[allow(non_camel_case_types)]
-struct i32x2([i32; 2]);
-#[repr(simd)]
-#[derive(Copy, Clone, Debug, PartialEq)]
-#[allow(non_camel_case_types)]
-struct i32x4([i32; 4]);
-#[repr(simd)]
-#[derive(Copy, Clone, Debug, PartialEq)]
-#[allow(non_camel_case_types)]
-struct i32x8([i32; 8]);
-
 #[repr(simd)]
 struct SimdShuffleIdx<const LEN: usize>([u32; LEN]);
 
@@ -34,26 +25,26 @@ macro_rules! all_eq {
 }
 
 fn main() {
-    let x2 = i32x2([20, 21]);
-    let x4 = i32x4([40, 41, 42, 43]);
-    let x8 = i32x8([80, 81, 82, 83, 84, 85, 86, 87]);
+    let x2 = i32x2::from_array([20, 21]);
+    let x4 = i32x4::from_array([40, 41, 42, 43]);
+    let x8 = i32x8::from_array([80, 81, 82, 83, 84, 85, 86, 87]);
     unsafe {
-        all_eq!(simd_insert(x2, 0, 100), i32x2([100, 21]));
-        all_eq!(simd_insert(x2, 1, 100), i32x2([20, 100]));
-
-        all_eq!(simd_insert(x4, 0, 100), i32x4([100, 41, 42, 43]));
-        all_eq!(simd_insert(x4, 1, 100), i32x4([40, 100, 42, 43]));
-        all_eq!(simd_insert(x4, 2, 100), i32x4([40, 41, 100, 43]));
-        all_eq!(simd_insert(x4, 3, 100), i32x4([40, 41, 42, 100]));
-
-        all_eq!(simd_insert(x8, 0, 100), i32x8([100, 81, 82, 83, 84, 85, 86, 87]));
-        all_eq!(simd_insert(x8, 1, 100), i32x8([80, 100, 82, 83, 84, 85, 86, 87]));
-        all_eq!(simd_insert(x8, 2, 100), i32x8([80, 81, 100, 83, 84, 85, 86, 87]));
-        all_eq!(simd_insert(x8, 3, 100), i32x8([80, 81, 82, 100, 84, 85, 86, 87]));
-        all_eq!(simd_insert(x8, 4, 100), i32x8([80, 81, 82, 83, 100, 85, 86, 87]));
-        all_eq!(simd_insert(x8, 5, 100), i32x8([80, 81, 82, 83, 84, 100, 86, 87]));
-        all_eq!(simd_insert(x8, 6, 100), i32x8([80, 81, 82, 83, 84, 85, 100, 87]));
-        all_eq!(simd_insert(x8, 7, 100), i32x8([80, 81, 82, 83, 84, 85, 86, 100]));
+        all_eq!(simd_insert(x2, 0, 100), i32x2::from_array([100, 21]));
+        all_eq!(simd_insert(x2, 1, 100), i32x2::from_array([20, 100]));
+
+        all_eq!(simd_insert(x4, 0, 100), i32x4::from_array([100, 41, 42, 43]));
+        all_eq!(simd_insert(x4, 1, 100), i32x4::from_array([40, 100, 42, 43]));
+        all_eq!(simd_insert(x4, 2, 100), i32x4::from_array([40, 41, 100, 43]));
+        all_eq!(simd_insert(x4, 3, 100), i32x4::from_array([40, 41, 42, 100]));
+
+        all_eq!(simd_insert(x8, 0, 100), i32x8::from_array([100, 81, 82, 83, 84, 85, 86, 87]));
+        all_eq!(simd_insert(x8, 1, 100), i32x8::from_array([80, 100, 82, 83, 84, 85, 86, 87]));
+        all_eq!(simd_insert(x8, 2, 100), i32x8::from_array([80, 81, 100, 83, 84, 85, 86, 87]));
+        all_eq!(simd_insert(x8, 3, 100), i32x8::from_array([80, 81, 82, 100, 84, 85, 86, 87]));
+        all_eq!(simd_insert(x8, 4, 100), i32x8::from_array([80, 81, 82, 83, 100, 85, 86, 87]));
+        all_eq!(simd_insert(x8, 5, 100), i32x8::from_array([80, 81, 82, 83, 84, 100, 86, 87]));
+        all_eq!(simd_insert(x8, 6, 100), i32x8::from_array([80, 81, 82, 83, 84, 85, 100, 87]));
+        all_eq!(simd_insert(x8, 7, 100), i32x8::from_array([80, 81, 82, 83, 84, 85, 86, 100]));
 
         all_eq!(simd_extract(x2, 0), 20);
         all_eq!(simd_extract(x2, 1), 21);
@@ -73,22 +64,22 @@ fn main() {
         all_eq!(simd_extract(x8, 7), 87);
     }
     unsafe {
-        all_eq!(simd_insert_dyn(x2, 0, 100), i32x2([100, 21]));
-        all_eq!(simd_insert_dyn(x2, 1, 100), i32x2([20, 100]));
-
-        all_eq!(simd_insert_dyn(x4, 0, 100), i32x4([100, 41, 42, 43]));
-        all_eq!(simd_insert_dyn(x4, 1, 100), i32x4([40, 100, 42, 43]));
-        all_eq!(simd_insert_dyn(x4, 2, 100), i32x4([40, 41, 100, 43]));
-        all_eq!(simd_insert_dyn(x4, 3, 100), i32x4([40, 41, 42, 100]));
-
-        all_eq!(simd_insert_dyn(x8, 0, 100), i32x8([100, 81, 82, 83, 84, 85, 86, 87]));
-        all_eq!(simd_insert_dyn(x8, 1, 100), i32x8([80, 100, 82, 83, 84, 85, 86, 87]));
-        all_eq!(simd_insert_dyn(x8, 2, 100), i32x8([80, 81, 100, 83, 84, 85, 86, 87]));
-        all_eq!(simd_insert_dyn(x8, 3, 100), i32x8([80, 81, 82, 100, 84, 85, 86, 87]));
-        all_eq!(simd_insert_dyn(x8, 4, 100), i32x8([80, 81, 82, 83, 100, 85, 86, 87]));
-        all_eq!(simd_insert_dyn(x8, 5, 100), i32x8([80, 81, 82, 83, 84, 100, 86, 87]));
-        all_eq!(simd_insert_dyn(x8, 6, 100), i32x8([80, 81, 82, 83, 84, 85, 100, 87]));
-        all_eq!(simd_insert_dyn(x8, 7, 100), i32x8([80, 81, 82, 83, 84, 85, 86, 100]));
+        all_eq!(simd_insert_dyn(x2, 0, 100), i32x2::from_array([100, 21]));
+        all_eq!(simd_insert_dyn(x2, 1, 100), i32x2::from_array([20, 100]));
+
+        all_eq!(simd_insert_dyn(x4, 0, 100), i32x4::from_array([100, 41, 42, 43]));
+        all_eq!(simd_insert_dyn(x4, 1, 100), i32x4::from_array([40, 100, 42, 43]));
+        all_eq!(simd_insert_dyn(x4, 2, 100), i32x4::from_array([40, 41, 100, 43]));
+        all_eq!(simd_insert_dyn(x4, 3, 100), i32x4::from_array([40, 41, 42, 100]));
+
+        all_eq!(simd_insert_dyn(x8, 0, 100), i32x8::from_array([100, 81, 82, 83, 84, 85, 86, 87]));
+        all_eq!(simd_insert_dyn(x8, 1, 100), i32x8::from_array([80, 100, 82, 83, 84, 85, 86, 87]));
+        all_eq!(simd_insert_dyn(x8, 2, 100), i32x8::from_array([80, 81, 100, 83, 84, 85, 86, 87]));
+        all_eq!(simd_insert_dyn(x8, 3, 100), i32x8::from_array([80, 81, 82, 100, 84, 85, 86, 87]));
+        all_eq!(simd_insert_dyn(x8, 4, 100), i32x8::from_array([80, 81, 82, 83, 100, 85, 86, 87]));
+        all_eq!(simd_insert_dyn(x8, 5, 100), i32x8::from_array([80, 81, 82, 83, 84, 100, 86, 87]));
+        all_eq!(simd_insert_dyn(x8, 6, 100), i32x8::from_array([80, 81, 82, 83, 84, 85, 100, 87]));
+        all_eq!(simd_insert_dyn(x8, 7, 100), i32x8::from_array([80, 81, 82, 83, 84, 85, 86, 100]));
 
         all_eq!(simd_extract_dyn(x2, 0), 20);
         all_eq!(simd_extract_dyn(x2, 1), 21);
@@ -108,38 +99,47 @@ fn main() {
         all_eq!(simd_extract_dyn(x8, 7), 87);
     }
 
-    let y2 = i32x2([120, 121]);
-    let y4 = i32x4([140, 141, 142, 143]);
-    let y8 = i32x8([180, 181, 182, 183, 184, 185, 186, 187]);
+    let y2 = i32x2::from_array([120, 121]);
+    let y4 = i32x4::from_array([140, 141, 142, 143]);
+    let y8 = i32x8::from_array([180, 181, 182, 183, 184, 185, 186, 187]);
     unsafe {
-        all_eq!(simd_shuffle(x2, y2, const { SimdShuffleIdx([3u32, 0]) }), i32x2([121, 20]));
+        all_eq!(
+            simd_shuffle(x2, y2, const { SimdShuffleIdx([3u32, 0]) }),
+            i32x2::from_array([121, 20])
+        );
         all_eq!(
             simd_shuffle(x2, y2, const { SimdShuffleIdx([3u32, 0, 1, 2]) }),
-            i32x4([121, 20, 21, 120])
+            i32x4::from_array([121, 20, 21, 120])
         );
         all_eq!(
             simd_shuffle(x2, y2, const { SimdShuffleIdx([3u32, 0, 1, 2, 1, 2, 3, 0]) }),
-            i32x8([121, 20, 21, 120, 21, 120, 121, 20])
+            i32x8::from_array([121, 20, 21, 120, 21, 120, 121, 20])
         );
 
-        all_eq!(simd_shuffle(x4, y4, const { SimdShuffleIdx([7u32, 2]) }), i32x2([143, 42]));
+        all_eq!(
+            simd_shuffle(x4, y4, const { SimdShuffleIdx([7u32, 2]) }),
+            i32x2::from_array([143, 42])
+        );
         all_eq!(
             simd_shuffle(x4, y4, const { SimdShuffleIdx([7u32, 2, 5, 0]) }),
-            i32x4([143, 42, 141, 40])
+            i32x4::from_array([143, 42, 141, 40])
         );
         all_eq!(
             simd_shuffle(x4, y4, const { SimdShuffleIdx([7u32, 2, 5, 0, 3, 6, 4, 1]) }),
-            i32x8([143, 42, 141, 40, 43, 142, 140, 41])
+            i32x8::from_array([143, 42, 141, 40, 43, 142, 140, 41])
         );
 
-        all_eq!(simd_shuffle(x8, y8, const { SimdShuffleIdx([11u32, 5]) }), i32x2([183, 85]));
+        all_eq!(
+            simd_shuffle(x8, y8, const { SimdShuffleIdx([11u32, 5]) }),
+            i32x2::from_array([183, 85])
+        );
         all_eq!(
             simd_shuffle(x8, y8, const { SimdShuffleIdx([11u32, 5, 15, 0]) }),
-            i32x4([183, 85, 187, 80])
+            i32x4::from_array([183, 85, 187, 80])
         );
         all_eq!(
             simd_shuffle(x8, y8, const { SimdShuffleIdx([11u32, 5, 15, 0, 3, 8, 12, 1]) }),
-            i32x8([183, 85, 187, 80, 83, 180, 184, 81])
+            i32x8::from_array([183, 85, 187, 80, 83, 180, 184, 81])
         );
     }
 }
diff --git a/tests/ui/simd/intrinsic/generic-gather-scatter-pass.rs b/tests/ui/simd/intrinsic/generic-gather-scatter-pass.rs
index b98d4d6575b..c2418c019ed 100644
--- a/tests/ui/simd/intrinsic/generic-gather-scatter-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-gather-scatter-pass.rs
@@ -6,24 +6,26 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
 use std::intrinsics::simd::{simd_gather, simd_scatter};
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct x4<T>(pub [T; 4]);
+type x4<T> = Simd<T, 4>;
 
 fn main() {
     let mut x = [0_f32, 1., 2., 3., 4., 5., 6., 7.];
 
-    let default = x4([-3_f32, -3., -3., -3.]);
-    let s_strided = x4([0_f32, 2., -3., 6.]);
-    let mask = x4([-1_i32, -1, 0, -1]);
+    let default = x4::from_array([-3_f32, -3., -3., -3.]);
+    let s_strided = x4::from_array([0_f32, 2., -3., 6.]);
+    let mask = x4::from_array([-1_i32, -1, 0, -1]);
 
     // reading from *const
     unsafe {
         let pointer = x.as_ptr();
         let pointers =
-            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
+            x4::from_array(std::array::from_fn(|i| pointer.add(i * 2)));
 
         let r_strided = simd_gather(default, pointers, mask);
 
@@ -34,7 +36,7 @@ fn main() {
     unsafe {
         let pointer = x.as_mut_ptr();
         let pointers =
-            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
+            x4::from_array(std::array::from_fn(|i| pointer.add(i * 2)));
 
         let r_strided = simd_gather(default, pointers, mask);
 
@@ -45,9 +47,9 @@ fn main() {
     unsafe {
         let pointer = x.as_mut_ptr();
         let pointers =
-            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
+            x4::from_array(std::array::from_fn(|i| pointer.add(i * 2)));
 
-        let values = x4([42_f32, 43_f32, 44_f32, 45_f32]);
+        let values = x4::from_array([42_f32, 43_f32, 44_f32, 45_f32]);
         simd_scatter(values, pointers, mask);
 
         assert_eq!(x, [42., 1., 43., 3., 4., 5., 45., 7.]);
@@ -65,14 +67,14 @@ fn main() {
         &x[7] as *const f32,
     ];
 
-    let default = x4([y[0], y[0], y[0], y[0]]);
-    let s_strided = x4([y[0], y[2], y[0], y[6]]);
+    let default = x4::from_array([y[0], y[0], y[0], y[0]]);
+    let s_strided = x4::from_array([y[0], y[2], y[0], y[6]]);
 
     // reading from *const
     unsafe {
         let pointer = y.as_ptr();
         let pointers =
-            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
+            x4::from_array(std::array::from_fn(|i| pointer.add(i * 2)));
 
         let r_strided = simd_gather(default, pointers, mask);
 
@@ -83,7 +85,7 @@ fn main() {
     unsafe {
         let pointer = y.as_mut_ptr();
         let pointers =
-            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
+            x4::from_array(std::array::from_fn(|i| pointer.add(i * 2)));
 
         let r_strided = simd_gather(default, pointers, mask);
 
@@ -94,9 +96,9 @@ fn main() {
     unsafe {
         let pointer = y.as_mut_ptr();
         let pointers =
-            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
+            x4::from_array(std::array::from_fn(|i| pointer.add(i * 2)));
 
-        let values = x4([y[7], y[6], y[5], y[1]]);
+        let values = x4::from_array([y[7], y[6], y[5], y[1]]);
         simd_scatter(values, pointers, mask);
 
         let s = [
diff --git a/tests/ui/simd/intrinsic/generic-select-pass.rs b/tests/ui/simd/intrinsic/generic-select-pass.rs
index 0e5f7c4902f..ff2d70d6a97 100644
--- a/tests/ui/simd/intrinsic/generic-select-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-select-pass.rs
@@ -6,38 +6,24 @@
 // Test that the simd_select intrinsics produces correct results.
 #![feature(repr_simd, core_intrinsics)]
 
-use std::intrinsics::simd::{simd_select, simd_select_bitmask};
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct i32x4(pub [i32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct u32x4(pub [u32; 4]);
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct u32x8([u32; 8]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct f32x4(pub [f32; 4]);
+use std::intrinsics::simd::{simd_select, simd_select_bitmask};
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct b8x4(pub [i8; 4]);
+type b8x4 = i8x4;
 
 fn main() {
-    let m0 = b8x4([!0, !0, !0, !0]);
-    let m1 = b8x4([0, 0, 0, 0]);
-    let m2 = b8x4([!0, !0, 0, 0]);
-    let m3 = b8x4([0, 0, !0, !0]);
-    let m4 = b8x4([!0, 0, !0, 0]);
+    let m0 = b8x4::from_array([!0, !0, !0, !0]);
+    let m1 = b8x4::from_array([0, 0, 0, 0]);
+    let m2 = b8x4::from_array([!0, !0, 0, 0]);
+    let m3 = b8x4::from_array([0, 0, !0, !0]);
+    let m4 = b8x4::from_array([!0, 0, !0, 0]);
 
     unsafe {
-        let a = i32x4([1, -2, 3, 4]);
-        let b = i32x4([5, 6, -7, 8]);
+        let a = i32x4::from_array([1, -2, 3, 4]);
+        let b = i32x4::from_array([5, 6, -7, 8]);
 
         let r: i32x4 = simd_select(m0, a, b);
         let e = a;
@@ -48,21 +34,21 @@ fn main() {
         assert_eq!(r, e);
 
         let r: i32x4 = simd_select(m2, a, b);
-        let e = i32x4([1, -2, -7, 8]);
+        let e = i32x4::from_array([1, -2, -7, 8]);
         assert_eq!(r, e);
 
         let r: i32x4 = simd_select(m3, a, b);
-        let e = i32x4([5, 6, 3, 4]);
+        let e = i32x4::from_array([5, 6, 3, 4]);
         assert_eq!(r, e);
 
         let r: i32x4 = simd_select(m4, a, b);
-        let e = i32x4([1, 6, 3, 8]);
+        let e = i32x4::from_array([1, 6, 3, 8]);
         assert_eq!(r, e);
     }
 
     unsafe {
-        let a = u32x4([1, 2, 3, 4]);
-        let b = u32x4([5, 6, 7, 8]);
+        let a = u32x4::from_array([1, 2, 3, 4]);
+        let b = u32x4::from_array([5, 6, 7, 8]);
 
         let r: u32x4 = simd_select(m0, a, b);
         let e = a;
@@ -73,21 +59,21 @@ fn main() {
         assert_eq!(r, e);
 
         let r: u32x4 = simd_select(m2, a, b);
-        let e = u32x4([1, 2, 7, 8]);
+        let e = u32x4::from_array([1, 2, 7, 8]);
         assert_eq!(r, e);
 
         let r: u32x4 = simd_select(m3, a, b);
-        let e = u32x4([5, 6, 3, 4]);
+        let e = u32x4::from_array([5, 6, 3, 4]);
         assert_eq!(r, e);
 
         let r: u32x4 = simd_select(m4, a, b);
-        let e = u32x4([1, 6, 3, 8]);
+        let e = u32x4::from_array([1, 6, 3, 8]);
         assert_eq!(r, e);
     }
 
     unsafe {
-        let a = f32x4([1., 2., 3., 4.]);
-        let b = f32x4([5., 6., 7., 8.]);
+        let a = f32x4::from_array([1., 2., 3., 4.]);
+        let b = f32x4::from_array([5., 6., 7., 8.]);
 
         let r: f32x4 = simd_select(m0, a, b);
         let e = a;
@@ -98,23 +84,23 @@ fn main() {
         assert_eq!(r, e);
 
         let r: f32x4 = simd_select(m2, a, b);
-        let e = f32x4([1., 2., 7., 8.]);
+        let e = f32x4::from_array([1., 2., 7., 8.]);
         assert_eq!(r, e);
 
         let r: f32x4 = simd_select(m3, a, b);
-        let e = f32x4([5., 6., 3., 4.]);
+        let e = f32x4::from_array([5., 6., 3., 4.]);
         assert_eq!(r, e);
 
         let r: f32x4 = simd_select(m4, a, b);
-        let e = f32x4([1., 6., 3., 8.]);
+        let e = f32x4::from_array([1., 6., 3., 8.]);
         assert_eq!(r, e);
     }
 
     unsafe {
         let t = !0 as i8;
         let f = 0 as i8;
-        let a = b8x4([t, f, t, f]);
-        let b = b8x4([f, f, f, t]);
+        let a = b8x4::from_array([t, f, t, f]);
+        let b = b8x4::from_array([f, f, f, t]);
 
         let r: b8x4 = simd_select(m0, a, b);
         let e = a;
@@ -125,21 +111,21 @@ fn main() {
         assert_eq!(r, e);
 
         let r: b8x4 = simd_select(m2, a, b);
-        let e = b8x4([t, f, f, t]);
+        let e = b8x4::from_array([t, f, f, t]);
         assert_eq!(r, e);
 
         let r: b8x4 = simd_select(m3, a, b);
-        let e = b8x4([f, f, t, f]);
+        let e = b8x4::from_array([f, f, t, f]);
         assert_eq!(r, e);
 
         let r: b8x4 = simd_select(m4, a, b);
-        let e = b8x4([t, f, t, t]);
+        let e = b8x4::from_array([t, f, t, t]);
         assert_eq!(r, e);
     }
 
     unsafe {
-        let a = u32x8([0, 1, 2, 3, 4, 5, 6, 7]);
-        let b = u32x8([8, 9, 10, 11, 12, 13, 14, 15]);
+        let a = u32x8::from_array([0, 1, 2, 3, 4, 5, 6, 7]);
+        let b = u32x8::from_array([8, 9, 10, 11, 12, 13, 14, 15]);
 
         let r: u32x8 = simd_select_bitmask(0u8, a, b);
         let e = b;
@@ -150,21 +136,21 @@ fn main() {
         assert_eq!(r, e);
 
         let r: u32x8 = simd_select_bitmask(0b01010101u8, a, b);
-        let e = u32x8([0, 9, 2, 11, 4, 13, 6, 15]);
+        let e = u32x8::from_array([0, 9, 2, 11, 4, 13, 6, 15]);
         assert_eq!(r, e);
 
         let r: u32x8 = simd_select_bitmask(0b10101010u8, a, b);
-        let e = u32x8([8, 1, 10, 3, 12, 5, 14, 7]);
+        let e = u32x8::from_array([8, 1, 10, 3, 12, 5, 14, 7]);
         assert_eq!(r, e);
 
         let r: u32x8 = simd_select_bitmask(0b11110000u8, a, b);
-        let e = u32x8([8, 9, 10, 11, 4, 5, 6, 7]);
+        let e = u32x8::from_array([8, 9, 10, 11, 4, 5, 6, 7]);
         assert_eq!(r, e);
     }
 
     unsafe {
-        let a = u32x4([0, 1, 2, 3]);
-        let b = u32x4([4, 5, 6, 7]);
+        let a = u32x4::from_array([0, 1, 2, 3]);
+        let b = u32x4::from_array([4, 5, 6, 7]);
 
         let r: u32x4 = simd_select_bitmask(0u8, a, b);
         let e = b;
@@ -175,15 +161,15 @@ fn main() {
         assert_eq!(r, e);
 
         let r: u32x4 = simd_select_bitmask(0b0101u8, a, b);
-        let e = u32x4([0, 5, 2, 7]);
+        let e = u32x4::from_array([0, 5, 2, 7]);
         assert_eq!(r, e);
 
         let r: u32x4 = simd_select_bitmask(0b1010u8, a, b);
-        let e = u32x4([4, 1, 6, 3]);
+        let e = u32x4::from_array([4, 1, 6, 3]);
         assert_eq!(r, e);
 
         let r: u32x4 = simd_select_bitmask(0b1100u8, a, b);
-        let e = u32x4([4, 5, 2, 3]);
+        let e = u32x4::from_array([4, 5, 2, 3]);
         assert_eq!(r, e);
     }
 }
diff --git a/tests/ui/simd/intrinsic/inlining-issue67557.rs b/tests/ui/simd/intrinsic/inlining-issue67557.rs
index 13e7266b2a5..14f180425d8 100644
--- a/tests/ui/simd/intrinsic/inlining-issue67557.rs
+++ b/tests/ui/simd/intrinsic/inlining-issue67557.rs
@@ -5,11 +5,13 @@
 //@ compile-flags: -Zmir-opt-level=4
 #![feature(core_intrinsics, repr_simd)]
 
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
 use std::intrinsics::simd::simd_shuffle;
 
-#[repr(simd)]
-#[derive(Debug, PartialEq)]
-struct Simd2([u8; 2]);
+type Simd2 = u8x2;
 
 #[repr(simd)]
 struct SimdShuffleIdx<const LEN: usize>([u32; LEN]);
@@ -17,7 +19,11 @@ struct SimdShuffleIdx<const LEN: usize>([u32; LEN]);
 fn main() {
     unsafe {
         const IDX: SimdShuffleIdx<2> = SimdShuffleIdx([0, 1]);
-        let p_res: Simd2 = simd_shuffle(Simd2([10, 11]), Simd2([12, 13]), IDX);
+        let p_res: Simd2 = simd_shuffle(
+            Simd2::from_array([10, 11]),
+            Simd2::from_array([12, 13]),
+            IDX,
+        );
         let a_res: Simd2 = inline_me();
 
         assert_10_11(p_res);
@@ -27,16 +33,16 @@ fn main() {
 
 #[inline(never)]
 fn assert_10_11(x: Simd2) {
-    assert_eq!(x, Simd2([10, 11]));
+    assert_eq!(x.into_array(), [10, 11]);
 }
 
 #[inline(never)]
 fn assert_10_13(x: Simd2) {
-    assert_eq!(x, Simd2([10, 13]));
+    assert_eq!(x.into_array(), [10, 13]);
 }
 
 #[inline(always)]
 unsafe fn inline_me() -> Simd2 {
     const IDX: SimdShuffleIdx<2> = SimdShuffleIdx([0, 3]);
-    simd_shuffle(Simd2([10, 11]), Simd2([12, 13]), IDX)
+    simd_shuffle(Simd2::from_array([10, 11]), Simd2::from_array([12, 13]), IDX)
 }
diff --git a/tests/ui/simd/intrinsic/ptr-cast.rs b/tests/ui/simd/intrinsic/ptr-cast.rs
index 3a73c0273e1..63b65d83f76 100644
--- a/tests/ui/simd/intrinsic/ptr-cast.rs
+++ b/tests/ui/simd/intrinsic/ptr-cast.rs
@@ -2,18 +2,20 @@
 
 #![feature(repr_simd, core_intrinsics)]
 
+#[path = "../../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
 use std::intrinsics::simd::{simd_cast_ptr, simd_expose_provenance, simd_with_exposed_provenance};
 
-#[derive(Copy, Clone)]
-#[repr(simd)]
-struct V<T>([T; 2]);
+type V<T> = Simd<T, 2>;
 
 fn main() {
     unsafe {
         let mut foo = 4i8;
         let ptr = &mut foo as *mut i8;
 
-        let ptrs = V::<*mut i8>([ptr, core::ptr::null_mut()]);
+        let ptrs: V::<*mut i8> = Simd([ptr, core::ptr::null_mut()]);
 
         // change constness and type
         let const_ptrs: V<*const u8> = simd_cast_ptr(ptrs);
@@ -22,8 +24,8 @@ fn main() {
 
         let with_exposed_provenance: V<*mut i8> = simd_with_exposed_provenance(exposed_addr);
 
-        assert!(const_ptrs.0 == [ptr as *const u8, core::ptr::null()]);
-        assert!(exposed_addr.0 == [ptr as usize, 0]);
-        assert!(with_exposed_provenance.0 == ptrs.0);
+        assert!(const_ptrs.into_array() == [ptr as *const u8, core::ptr::null()]);
+        assert!(exposed_addr.into_array() == [ptr as usize, 0]);
+        assert!(with_exposed_provenance.into_array() == ptrs.into_array());
     }
 }
diff --git a/tests/ui/simd/issue-39720.rs b/tests/ui/simd/issue-39720.rs
index db441e55167..09d6142c920 100644
--- a/tests/ui/simd/issue-39720.rs
+++ b/tests/ui/simd/issue-39720.rs
@@ -2,16 +2,16 @@
 
 #![feature(repr_simd, core_intrinsics)]
 
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-pub struct Char3(pub [i8; 3]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-pub struct Short3(pub [i16; 3]);
+pub type Char3 = Simd<i8, 3>;
+
+pub type Short3 = Simd<i16, 3>;
 
 fn main() {
-    let cast: Short3 = unsafe { std::intrinsics::simd::simd_cast(Char3([10, -3, -9])) };
+    let cast: Short3 = unsafe { std::intrinsics::simd::simd_cast(Char3::from_array([10, -3, -9])) };
 
     println!("{:?}", cast);
 }
diff --git a/tests/ui/simd/issue-85915-simd-ptrs.rs b/tests/ui/simd/issue-85915-simd-ptrs.rs
index 4e2379d0525..a74c36fabc1 100644
--- a/tests/ui/simd/issue-85915-simd-ptrs.rs
+++ b/tests/ui/simd/issue-85915-simd-ptrs.rs
@@ -6,35 +6,27 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::{simd_gather, simd_scatter};
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct cptrx4<T>([*const T; 4]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct mptrx4<T>([*mut T; 4]);
+use std::intrinsics::simd::{simd_gather, simd_scatter};
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct f32x4([f32; 4]);
+type cptrx4<T> = Simd<*const T, 4>;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct i32x4([i32; 4]);
+type mptrx4<T> = Simd<*mut T, 4>;
 
 fn main() {
     let mut x = [0_f32, 1., 2., 3., 4., 5., 6., 7.];
 
-    let default = f32x4([-3_f32, -3., -3., -3.]);
-    let s_strided = f32x4([0_f32, 2., -3., 6.]);
-    let mask = i32x4([-1_i32, -1, 0, -1]);
+    let default = f32x4::from_array([-3_f32, -3., -3., -3.]);
+    let s_strided = f32x4::from_array([0_f32, 2., -3., 6.]);
+    let mask = i32x4::from_array([-1_i32, -1, 0, -1]);
 
     // reading from *const
     unsafe {
         let pointer = &x as *const f32;
-        let pointers = cptrx4([
+        let pointers = cptrx4::from_array([
             pointer.offset(0) as *const f32,
             pointer.offset(2),
             pointer.offset(4),
@@ -49,14 +41,14 @@ fn main() {
     // writing to *mut
     unsafe {
         let pointer = &mut x as *mut f32;
-        let pointers = mptrx4([
+        let pointers = mptrx4::from_array([
             pointer.offset(0) as *mut f32,
             pointer.offset(2),
             pointer.offset(4),
             pointer.offset(6),
         ]);
 
-        let values = f32x4([42_f32, 43_f32, 44_f32, 45_f32]);
+        let values = f32x4::from_array([42_f32, 43_f32, 44_f32, 45_f32]);
         simd_scatter(values, pointers, mask);
 
         assert_eq!(x, [42., 1., 43., 3., 4., 5., 45., 7.]);
diff --git a/tests/ui/simd/issue-89193.rs b/tests/ui/simd/issue-89193.rs
index a6c3017572a..da4cd456589 100644
--- a/tests/ui/simd/issue-89193.rs
+++ b/tests/ui/simd/issue-89193.rs
@@ -6,36 +6,38 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
 use std::intrinsics::simd::simd_gather;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-struct x4<T>(pub [T; 4]);
+type x4<T> = Simd<T, 4>;
 
 fn main() {
     let x: [usize; 4] = [10, 11, 12, 13];
-    let default = x4([0_usize, 1, 2, 3]);
+    let default = x4::from_array([0_usize, 1, 2, 3]);
     let all_set = u8::MAX as i8; // aka -1
-    let mask = x4([all_set, all_set, all_set, all_set]);
-    let expected = x4([10_usize, 11, 12, 13]);
+    let mask = x4::from_array([all_set, all_set, all_set, all_set]);
+    let expected = x4::from_array([10_usize, 11, 12, 13]);
 
     unsafe {
         let pointer = x.as_ptr();
         let pointers =
-            x4([pointer.offset(0), pointer.offset(1), pointer.offset(2), pointer.offset(3)]);
+            x4::from_array(std::array::from_fn(|i| pointer.add(i)));
         let result = simd_gather(default, pointers, mask);
         assert_eq!(result, expected);
     }
 
     // and again for isize
     let x: [isize; 4] = [10, 11, 12, 13];
-    let default = x4([0_isize, 1, 2, 3]);
-    let expected = x4([10_isize, 11, 12, 13]);
+    let default = x4::from_array([0_isize, 1, 2, 3]);
+    let expected = x4::from_array([10_isize, 11, 12, 13]);
 
     unsafe {
         let pointer = x.as_ptr();
         let pointers =
-            x4([pointer.offset(0), pointer.offset(1), pointer.offset(2), pointer.offset(3)]);
+            x4::from_array(std::array::from_fn(|i| pointer.add(i)));
         let result = simd_gather(default, pointers, mask);
         assert_eq!(result, expected);
     }
diff --git a/tests/ui/simd/masked-load-store.rs b/tests/ui/simd/masked-load-store.rs
index 69ea76581ee..da32ba611c4 100644
--- a/tests/ui/simd/masked-load-store.rs
+++ b/tests/ui/simd/masked-load-store.rs
@@ -1,11 +1,11 @@
 //@ run-pass
 #![feature(repr_simd, core_intrinsics)]
 
-use std::intrinsics::simd::{simd_masked_load, simd_masked_store};
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[derive(Copy, Clone)]
-#[repr(simd)]
-struct Simd<T, const N: usize>([T; N]);
+use std::intrinsics::simd::{simd_masked_load, simd_masked_store};
 
 fn main() {
     unsafe {
@@ -15,7 +15,7 @@ fn main() {
         let b: Simd<u8, 4> =
             simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), b_src.as_ptr(), b_default);
 
-        assert_eq!(&b.0, &[4, 9, 6, 7]);
+        assert_eq!(b.as_array(), &[4, 9, 6, 7]);
 
         let mut output = [u8::MAX; 5];
 
diff --git a/tests/ui/simd/monomorphize-shuffle-index.rs b/tests/ui/simd/monomorphize-shuffle-index.rs
index a56f2ea1452..1490f8e2319 100644
--- a/tests/ui/simd/monomorphize-shuffle-index.rs
+++ b/tests/ui/simd/monomorphize-shuffle-index.rs
@@ -11,6 +11,10 @@
 )]
 #![allow(incomplete_features)]
 
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
 #[cfg(old)]
 use std::intrinsics::simd::simd_shuffle;
 
@@ -18,10 +22,6 @@ use std::intrinsics::simd::simd_shuffle;
 #[rustc_intrinsic]
 unsafe fn simd_shuffle_const_generic<T, U, const I: &'static [u32]>(a: T, b: T) -> U;
 
-#[derive(Copy, Clone)]
-#[repr(simd)]
-struct Simd<T, const N: usize>([T; N]);
-
 trait Shuffle<const N: usize> {
     const I: Simd<u32, N>;
     const J: &'static [u32] = &Self::I.0;
@@ -57,9 +57,9 @@ fn main() {
     let b = Simd::<u8, 4>([4, 5, 6, 7]);
     unsafe {
         let x: Simd<u8, 4> = I1.shuffle(a, b);
-        assert_eq!(x.0, [0, 2, 4, 6]);
+        assert_eq!(x.into_array(), [0, 2, 4, 6]);
 
         let y: Simd<u8, 2> = I2.shuffle(a, b);
-        assert_eq!(y.0, [1, 5]);
+        assert_eq!(y.into_array(), [1, 5]);
     }
 }
diff --git a/tests/ui/simd/repr_packed.rs b/tests/ui/simd/repr_packed.rs
index cc54477ae71..f0c6de7c402 100644
--- a/tests/ui/simd/repr_packed.rs
+++ b/tests/ui/simd/repr_packed.rs
@@ -3,15 +3,16 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_add;
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd, packed)]
-struct Simd<T, const N: usize>([T; N]);
+use std::intrinsics::simd::simd_add;
 
 fn check_size_align<T, const N: usize>() {
     use std::mem;
-    assert_eq!(mem::size_of::<Simd<T, N>>(), mem::size_of::<[T; N]>());
-    assert_eq!(mem::size_of::<Simd<T, N>>() % mem::align_of::<Simd<T, N>>(), 0);
+    assert_eq!(mem::size_of::<PackedSimd<T, N>>(), mem::size_of::<[T; N]>());
+    assert_eq!(mem::size_of::<PackedSimd<T, N>>() % mem::align_of::<PackedSimd<T, N>>(), 0);
 }
 
 fn check_ty<T>() {
@@ -35,14 +36,21 @@ fn main() {
 
     unsafe {
         // powers-of-two have no padding and have the same layout as #[repr(simd)]
-        let x: Simd<f64, 4> =
-            simd_add(Simd::<f64, 4>([0., 1., 2., 3.]), Simd::<f64, 4>([2., 2., 2., 2.]));
-        assert_eq!(std::mem::transmute::<_, [f64; 4]>(x), [2., 3., 4., 5.]);
+        let x: PackedSimd<f64, 4> =
+            simd_add(
+                PackedSimd::<f64, 4>([0., 1., 2., 3.]),
+                PackedSimd::<f64, 4>([2., 2., 2., 2.]),
+            );
+        assert_eq!(x.into_array(), [2., 3., 4., 5.]);
 
         // non-powers-of-two should have padding (which is removed by #[repr(packed)]),
         // but the intrinsic handles it
-        let x: Simd<f64, 3> = simd_add(Simd::<f64, 3>([0., 1., 2.]), Simd::<f64, 3>([2., 2., 2.]));
-        let arr: [f64; 3] = x.0;
+        let x: PackedSimd<f64, 3> =
+            simd_add(
+                PackedSimd::<f64, 3>([0., 1., 2.]),
+                PackedSimd::<f64, 3>([2., 2., 2.]),
+            );
+        let arr: [f64; 3] = x.into_array();
         assert_eq!(arr, [2., 3., 4.]);
     }
 }
diff --git a/tests/ui/simd/shuffle.rs b/tests/ui/simd/shuffle.rs
index cd270edcf00..061571a4786 100644
--- a/tests/ui/simd/shuffle.rs
+++ b/tests/ui/simd/shuffle.rs
@@ -10,10 +10,16 @@ use std::marker::ConstParamTy;
 
 use std::intrinsics::simd::simd_shuffle;
 
+// not using `minisimd` because of the `ConstParamTy`
 #[derive(Copy, Clone, ConstParamTy, PartialEq, Eq)]
 #[repr(simd)]
 struct Simd<T, const N: usize>([T; N]);
 
+fn into_array<T, const N: usize>(v: Simd<T, N>) -> [T; N] {
+    const { assert!(size_of::<Simd<T, N>>() == size_of::<[T; N]>()) }
+    unsafe { std::intrinsics::transmute_unchecked(v) }
+}
+
 unsafe fn __shuffle_vector16<const IDX: Simd<u32, 16>, T, U>(x: T, y: T) -> U {
     simd_shuffle(x, y, IDX)
 }
@@ -25,10 +31,10 @@ fn main() {
     let b = Simd::<u8, 4>([4, 5, 6, 7]);
     unsafe {
         let x: Simd<u8, 4> = simd_shuffle(a, b, I1);
-        assert_eq!(x.0, [0, 2, 4, 6]);
+        assert_eq!(into_array(x), [0, 2, 4, 6]);
 
         let y: Simd<u8, 2> = simd_shuffle(a, b, I2);
-        assert_eq!(y.0, [1, 5]);
+        assert_eq!(into_array(y), [1, 5]);
     }
 
     // Test that an indirection (via an unnamed constant)
diff --git a/tests/ui/simd/simd-bitmask-notpow2.rs b/tests/ui/simd/simd-bitmask-notpow2.rs
index 4935097065e..b9af591d1b9 100644
--- a/tests/ui/simd/simd-bitmask-notpow2.rs
+++ b/tests/ui/simd/simd-bitmask-notpow2.rs
@@ -4,21 +4,23 @@
 //@ ignore-endian-big
 #![feature(repr_simd, core_intrinsics)]
 
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
 use std::intrinsics::simd::{simd_bitmask, simd_select_bitmask};
 
 fn main() {
     // Non-power-of-2 multi-byte mask.
-    #[repr(simd, packed)]
     #[allow(non_camel_case_types)]
-    #[derive(Copy, Clone, Debug, PartialEq)]
-    struct i32x10([i32; 10]);
+    type i32x10 = PackedSimd<i32, 10>;
     impl i32x10 {
         fn splat(x: i32) -> Self {
             Self([x; 10])
         }
     }
     unsafe {
-        let mask = i32x10([!0, !0, 0, !0, 0, 0, !0, 0, !0, 0]);
+        let mask = i32x10::from_array([!0, !0, 0, !0, 0, 0, !0, 0, !0, 0]);
         let mask_bits = if cfg!(target_endian = "little") { 0b0101001011 } else { 0b1101001010 };
         let mask_bytes =
             if cfg!(target_endian = "little") { [0b01001011, 0b01] } else { [0b11, 0b01001010] };
@@ -43,17 +45,20 @@ fn main() {
     }
 
     // Test for a mask where the next multiple of 8 is not a power of two.
-    #[repr(simd, packed)]
     #[allow(non_camel_case_types)]
-    #[derive(Copy, Clone, Debug, PartialEq)]
-    struct i32x20([i32; 20]);
+    type i32x20 = PackedSimd<i32, 20>;
     impl i32x20 {
         fn splat(x: i32) -> Self {
             Self([x; 20])
         }
     }
     unsafe {
-        let mask = i32x20([!0, !0, 0, !0, 0, 0, !0, 0, !0, 0, 0, 0, 0, !0, !0, !0, !0, !0, !0, !0]);
+        let mask = i32x20::from_array([
+            !0, !0,  0, !0,  0,
+             0, !0,  0, !0,  0,
+             0,  0,  0, !0, !0,
+            !0, !0, !0, !0, !0,
+        ]);
         let mask_bits = if cfg!(target_endian = "little") {
             0b11111110000101001011
         } else {
diff --git a/tests/ui/simd/simd-bitmask.rs b/tests/ui/simd/simd-bitmask.rs
index 6fcceeaa24b..609dae3647b 100644
--- a/tests/ui/simd/simd-bitmask.rs
+++ b/tests/ui/simd/simd-bitmask.rs
@@ -1,11 +1,11 @@
 //@run-pass
 #![feature(repr_simd, core_intrinsics)]
 
-use std::intrinsics::simd::{simd_bitmask, simd_select_bitmask};
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[derive(Copy, Clone)]
-#[repr(simd)]
-struct Simd<T, const N: usize>([T; N]);
+use std::intrinsics::simd::{simd_bitmask, simd_select_bitmask};
 
 fn main() {
     unsafe {
@@ -41,11 +41,11 @@ fn main() {
 
         let mask = if cfg!(target_endian = "little") { 0b0101u8 } else { 0b1010u8 };
         let r = simd_select_bitmask(mask, a, b);
-        assert_eq!(r.0, e);
+        assert_eq!(r.into_array(), e);
 
         let mask = if cfg!(target_endian = "little") { [0b0101u8] } else { [0b1010u8] };
         let r = simd_select_bitmask(mask, a, b);
-        assert_eq!(r.0, e);
+        assert_eq!(r.into_array(), e);
 
         let a = Simd::<i32, 16>([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
         let b = Simd::<i32, 16>([16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]);
@@ -57,7 +57,7 @@ fn main() {
             0b0011000000001010u16
         };
         let r = simd_select_bitmask(mask, a, b);
-        assert_eq!(r.0, e);
+        assert_eq!(r.into_array(), e);
 
         let mask = if cfg!(target_endian = "little") {
             [0b00001100u8, 0b01010000u8]
@@ -65,6 +65,6 @@ fn main() {
             [0b00110000u8, 0b00001010u8]
         };
         let r = simd_select_bitmask(mask, a, b);
-        assert_eq!(r.0, e);
+        assert_eq!(r.into_array(), e);
     }
 }
diff --git a/tests/ui/simd/target-feature-mixup.rs b/tests/ui/simd/target-feature-mixup.rs
index 77f18615248..82902891b97 100644
--- a/tests/ui/simd/target-feature-mixup.rs
+++ b/tests/ui/simd/target-feature-mixup.rs
@@ -8,6 +8,11 @@
 
 #![feature(repr_simd, target_feature, cfg_target_feature)]
 
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+#[allow(unused)]
+use minisimd::*;
+
 use std::process::{Command, ExitStatus};
 use std::env;
 
@@ -50,19 +55,13 @@ fn is_sigill(status: ExitStatus) -> bool {
 #[allow(nonstandard_style)]
 mod test {
     // An SSE type
-    #[repr(simd)]
-    #[derive(PartialEq, Debug, Clone, Copy)]
-    struct __m128i([u64; 2]);
+    type __m128i = super::u64x2;
 
     // An AVX type
-    #[repr(simd)]
-    #[derive(PartialEq, Debug, Clone, Copy)]
-    struct __m256i([u64; 4]);
+    type __m256i = super::u64x4;
 
     // An AVX-512 type
-    #[repr(simd)]
-    #[derive(PartialEq, Debug, Clone, Copy)]
-    struct __m512i([u64; 8]);
+    type __m512i = super::u64x8;
 
     pub fn main(level: &str) {
         unsafe {
@@ -88,9 +87,9 @@ mod test {
         )*) => ($(
             $(#[$attr])*
             unsafe fn $main(level: &str) {
-                let m128 = __m128i([1, 2]);
-                let m256 = __m256i([3, 4, 5, 6]);
-                let m512 = __m512i([7, 8, 9, 10, 11, 12, 13, 14]);
+                let m128 = __m128i::from_array([1, 2]);
+                let m256 = __m256i::from_array([3, 4, 5, 6]);
+                let m512 = __m512i::from_array([7, 8, 9, 10, 11, 12, 13, 14]);
                 assert_eq!(id_sse_128(m128), m128);
                 assert_eq!(id_sse_256(m256), m256);
                 assert_eq!(id_sse_512(m512), m512);
@@ -125,55 +124,55 @@ mod test {
 
     #[target_feature(enable = "sse2")]
     unsafe fn id_sse_128(a: __m128i) -> __m128i {
-        assert_eq!(a, __m128i([1, 2]));
+        assert_eq!(a, __m128i::from_array([1, 2]));
         a.clone()
     }
 
     #[target_feature(enable = "sse2")]
     unsafe fn id_sse_256(a: __m256i) -> __m256i {
-        assert_eq!(a, __m256i([3, 4, 5, 6]));
+        assert_eq!(a, __m256i::from_array([3, 4, 5, 6]));
         a.clone()
     }
 
     #[target_feature(enable = "sse2")]
     unsafe fn id_sse_512(a: __m512i) -> __m512i {
-        assert_eq!(a, __m512i([7, 8, 9, 10, 11, 12, 13, 14]));
+        assert_eq!(a, __m512i::from_array([7, 8, 9, 10, 11, 12, 13, 14]));
         a.clone()
     }
 
     #[target_feature(enable = "avx")]
     unsafe fn id_avx_128(a: __m128i) -> __m128i {
-        assert_eq!(a, __m128i([1, 2]));
+        assert_eq!(a, __m128i::from_array([1, 2]));
         a.clone()
     }
 
     #[target_feature(enable = "avx")]
     unsafe fn id_avx_256(a: __m256i) -> __m256i {
-        assert_eq!(a, __m256i([3, 4, 5, 6]));
+        assert_eq!(a, __m256i::from_array([3, 4, 5, 6]));
         a.clone()
     }
 
     #[target_feature(enable = "avx")]
     unsafe fn id_avx_512(a: __m512i) -> __m512i {
-        assert_eq!(a, __m512i([7, 8, 9, 10, 11, 12, 13, 14]));
+        assert_eq!(a, __m512i::from_array([7, 8, 9, 10, 11, 12, 13, 14]));
         a.clone()
     }
 
     #[target_feature(enable = "avx512bw")]
     unsafe fn id_avx512_128(a: __m128i) -> __m128i {
-        assert_eq!(a, __m128i([1, 2]));
+        assert_eq!(a, __m128i::from_array([1, 2]));
         a.clone()
     }
 
     #[target_feature(enable = "avx512bw")]
     unsafe fn id_avx512_256(a: __m256i) -> __m256i {
-        assert_eq!(a, __m256i([3, 4, 5, 6]));
+        assert_eq!(a, __m256i::from_array([3, 4, 5, 6]));
         a.clone()
     }
 
     #[target_feature(enable = "avx512bw")]
     unsafe fn id_avx512_512(a: __m512i) -> __m512i {
-        assert_eq!(a, __m512i([7, 8, 9, 10, 11, 12, 13, 14]));
+        assert_eq!(a, __m512i::from_array([7, 8, 9, 10, 11, 12, 13, 14]));
         a.clone()
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 25a804ab062582bba55bf5cd9844bd13aae00f21 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Fri, 18 Jul 2025 17:29:33 -0700
Subject: ...and wasm tests too

---
 tests/ui/wasm/simd-to-array-80108.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/ui/wasm/simd-to-array-80108.rs b/tests/ui/wasm/simd-to-array-80108.rs
index c7f8585eaa4..f6b368992be 100644
--- a/tests/ui/wasm/simd-to-array-80108.rs
+++ b/tests/ui/wasm/simd-to-array-80108.rs
@@ -10,6 +10,8 @@ pub struct Vector([i32; 4]);
 
 impl Vector {
     pub const fn to_array(self) -> [i32; 4] {
-        self.0
+        // This used to just be `.0`, but that was banned in
+        // <https://github.com/rust-lang/compiler-team/issues/838>
+        unsafe { std::mem::transmute(self) }
     }
 }
-- 
cgit 1.4.1-3-g733a5


From 493fd9a54110dc9d0d60566140e65f701070e34c Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Sat, 12 Jul 2025 17:11:47 -0700
Subject: Update cranelift tests

---
 .../example/float-minmax-pass.rs                   | 22 ++++++++++++++--------
 .../example/mini_core_hello_world.rs               |  3 ++-
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/example/float-minmax-pass.rs b/compiler/rustc_codegen_cranelift/example/float-minmax-pass.rs
index ad46e18c11c..b7491b7e522 100644
--- a/compiler/rustc_codegen_cranelift/example/float-minmax-pass.rs
+++ b/compiler/rustc_codegen_cranelift/example/float-minmax-pass.rs
@@ -11,6 +11,12 @@
 #[derive(Copy, Clone, PartialEq, Debug)]
 struct f32x4(pub [f32; 4]);
 
+impl f32x4 {
+    fn into_array(self) -> [f32; 4] {
+        unsafe { std::mem::transmute(self) }
+    }
+}
+
 use std::intrinsics::simd::*;
 
 fn main() {
@@ -29,22 +35,22 @@ fn main() {
     unsafe {
         let min0 = simd_fmin(x, y);
         let min1 = simd_fmin(y, x);
-        assert_eq!(min0, min1);
+        assert_eq!(min0.into_array(), min1.into_array());
         let e = f32x4([1.0, 1.0, 3.0, 3.0]);
-        assert_eq!(min0, e);
+        assert_eq!(min0.into_array(), e.into_array());
         let minn = simd_fmin(x, n);
-        assert_eq!(minn, x);
+        assert_eq!(minn.into_array(), x.into_array());
         let minn = simd_fmin(y, n);
-        assert_eq!(minn, y);
+        assert_eq!(minn.into_array(), y.into_array());
 
         let max0 = simd_fmax(x, y);
         let max1 = simd_fmax(y, x);
-        assert_eq!(max0, max1);
+        assert_eq!(max0.into_array(), max1.into_array());
         let e = f32x4([2.0, 2.0, 4.0, 4.0]);
-        assert_eq!(max0, e);
+        assert_eq!(max0.into_array(), e.into_array());
         let maxn = simd_fmax(x, n);
-        assert_eq!(maxn, x);
+        assert_eq!(maxn.into_array(), x.into_array());
         let maxn = simd_fmax(y, n);
-        assert_eq!(maxn, y);
+        assert_eq!(maxn.into_array(), y.into_array());
     }
 }
diff --git a/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs b/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs
index 246bd3104ec..86602c6b2a3 100644
--- a/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs
+++ b/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs
@@ -348,7 +348,8 @@ fn main() {
     struct V([f64; 2]);
 
     let f = V([0.0, 1.0]);
-    let _a = f.0[0];
+    let fp = (&raw const f) as *const [f64; 2];
+    let _a = (unsafe { &*fp })[0];
 
     stack_val_align();
 }
-- 
cgit 1.4.1-3-g733a5


From f790042c6ab3cf05622e63928b13cb802d68fadf Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Sun, 13 Jul 2025 11:26:40 -0700
Subject: Update Miri Tests

---
 .../miri/tests/pass/intrinsics/portable-simd.rs    | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
index 726d4c01cc3..e2cd08733af 100644
--- a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
+++ b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
@@ -349,12 +349,15 @@ fn simd_mask() {
     // Non-power-of-2 multi-byte mask.
     #[repr(simd, packed)]
     #[allow(non_camel_case_types)]
-    #[derive(Copy, Clone, Debug, PartialEq)]
+    #[derive(Copy, Clone)]
     struct i32x10([i32; 10]);
     impl i32x10 {
         fn splat(x: i32) -> Self {
             Self([x; 10])
         }
+        fn into_array(self) -> [i32; 10] {
+            unsafe { std::mem::transmute(self) }
+        }
     }
     unsafe {
         let mask = i32x10([!0, !0, 0, !0, 0, 0, !0, 0, !0, 0]);
@@ -377,19 +380,22 @@ fn simd_mask() {
             i32x10::splat(!0), // yes
             i32x10::splat(0),  // no
         );
-        assert_eq!(selected1, mask);
-        assert_eq!(selected2, mask);
+        assert_eq!(selected1.into_array(), mask.into_array());
+        assert_eq!(selected2.into_array(), mask.into_array());
     }
 
     // Test for a mask where the next multiple of 8 is not a power of two.
     #[repr(simd, packed)]
     #[allow(non_camel_case_types)]
-    #[derive(Copy, Clone, Debug, PartialEq)]
+    #[derive(Copy, Clone)]
     struct i32x20([i32; 20]);
     impl i32x20 {
         fn splat(x: i32) -> Self {
             Self([x; 20])
         }
+        fn into_array(self) -> [i32; 20] {
+            unsafe { std::mem::transmute(self) }
+        }
     }
     unsafe {
         let mask = i32x20([!0, !0, 0, !0, 0, 0, !0, 0, !0, 0, 0, 0, 0, !0, !0, !0, !0, !0, !0, !0]);
@@ -419,8 +425,8 @@ fn simd_mask() {
             i32x20::splat(!0), // yes
             i32x20::splat(0),  // no
         );
-        assert_eq!(selected1, mask);
-        assert_eq!(selected2, mask);
+        assert_eq!(selected1.into_array(), mask.into_array());
+        assert_eq!(selected2.into_array(), mask.into_array());
     }
 }
 
@@ -708,12 +714,12 @@ fn simd_ops_non_pow2() {
     let x = SimdPacked([1u32; 3]);
     let y = SimdPacked([2u32; 3]);
     let z = unsafe { intrinsics::simd_add(x, y) };
-    assert_eq!({ z.0 }, [3u32; 3]);
+    assert_eq!(unsafe { *(&raw const z).cast::<[u32; 3]>() }, [3u32; 3]);
 
     let x = SimdPadded([1u32; 3]);
     let y = SimdPadded([2u32; 3]);
     let z = unsafe { intrinsics::simd_add(x, y) };
-    assert_eq!(z.0, [3u32; 3]);
+    assert_eq!(unsafe { *(&raw const z).cast::<[u32; 3]>() }, [3u32; 3]);
 }
 
 fn main() {
-- 
cgit 1.4.1-3-g733a5


From 6fd83ea5e57ee593f774d24ffe90c87a9cf3b51c Mon Sep 17 00:00:00 2001
From: ognevnydemon <maksapple2306@gmail.com>
Date: Sun, 20 Jul 2025 20:19:11 +0300
Subject: opt-dist: change build_dir field to be an actual build dir

make it configurable so users can set build.build-dir option in bootstrap.toml
---
 src/tools/opt-dist/src/environment.rs |  2 +-
 src/tools/opt-dist/src/exec.rs        |  4 ++--
 src/tools/opt-dist/src/main.rs        | 12 +++++++++---
 src/tools/opt-dist/src/tests.rs       |  2 +-
 4 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/src/tools/opt-dist/src/environment.rs b/src/tools/opt-dist/src/environment.rs
index d41dc80e6b2..e6e4c711c0c 100644
--- a/src/tools/opt-dist/src/environment.rs
+++ b/src/tools/opt-dist/src/environment.rs
@@ -48,7 +48,7 @@ impl Environment {
     }
 
     pub fn build_artifacts(&self) -> Utf8PathBuf {
-        self.build_root().join("build").join(&self.host_tuple)
+        self.build_root().join(&self.host_tuple)
     }
 
     pub fn artifact_dir(&self) -> Utf8PathBuf {
diff --git a/src/tools/opt-dist/src/exec.rs b/src/tools/opt-dist/src/exec.rs
index 56eff2ca2a7..a8d4c93d160 100644
--- a/src/tools/opt-dist/src/exec.rs
+++ b/src/tools/opt-dist/src/exec.rs
@@ -99,7 +99,7 @@ pub struct Bootstrap {
 
 impl Bootstrap {
     pub fn build(env: &Environment) -> Self {
-        let metrics_path = env.build_root().join("build").join("metrics.json");
+        let metrics_path = env.build_root().join("metrics.json");
         let cmd = cmd(&[
             env.python_binary(),
             env.checkout_path().join("x.py").as_str(),
@@ -119,7 +119,7 @@ impl Bootstrap {
     }
 
     pub fn dist(env: &Environment, dist_args: &[String]) -> Self {
-        let metrics_path = env.build_root().join("build").join("metrics.json");
+        let metrics_path = env.build_root().join("metrics.json");
         let args = dist_args.iter().map(|arg| arg.as_str()).collect::<Vec<_>>();
         let cmd = cmd(&args).env("RUST_BACKTRACE", "full");
         let mut cmd = add_shared_x_flags(env, cmd);
diff --git a/src/tools/opt-dist/src/main.rs b/src/tools/opt-dist/src/main.rs
index 7857f196626..d0e6badede6 100644
--- a/src/tools/opt-dist/src/main.rs
+++ b/src/tools/opt-dist/src/main.rs
@@ -102,6 +102,11 @@ enum EnvironmentCmd {
         /// Will be LLVM built during the run?
         #[arg(long, default_value_t = true, action(clap::ArgAction::Set))]
         build_llvm: bool,
+
+        /// Set build artifacts dir. Relative to `checkout_dir`, should point to the directory set
+        /// in bootstrap.toml via `build.build-dir` option
+        #[arg(long, default_value = "build")]
+        build_dir: Utf8PathBuf,
     },
     /// Perform an optimized build on Linux CI, from inside Docker.
     LinuxCi {
@@ -138,6 +143,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
             shared,
             run_tests,
             build_llvm,
+            build_dir,
         } => {
             let env = EnvironmentBuilder::default()
                 .host_tuple(target_triple)
@@ -145,7 +151,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
                 .checkout_dir(checkout_dir.clone())
                 .host_llvm_dir(llvm_dir)
                 .artifact_dir(artifact_dir)
-                .build_dir(checkout_dir)
+                .build_dir(checkout_dir.join(build_dir))
                 .prebuilt_rustc_perf(rustc_perf_checkout_dir)
                 .shared_llvm(llvm_shared)
                 .use_bolt(use_bolt)
@@ -171,7 +177,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
                 .checkout_dir(checkout_dir.clone())
                 .host_llvm_dir(Utf8PathBuf::from("/rustroot"))
                 .artifact_dir(Utf8PathBuf::from("/tmp/tmp-multistage/opt-artifacts"))
-                .build_dir(checkout_dir.join("obj"))
+                .build_dir(checkout_dir.join("obj").join("build"))
                 .shared_llvm(true)
                 // FIXME: Enable bolt for aarch64 once it's fixed upstream. Broken as of December 2024.
                 .use_bolt(!is_aarch64)
@@ -194,7 +200,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
                 .checkout_dir(checkout_dir.clone())
                 .host_llvm_dir(checkout_dir.join("citools").join("clang-rust"))
                 .artifact_dir(checkout_dir.join("opt-artifacts"))
-                .build_dir(checkout_dir)
+                .build_dir(checkout_dir.join("build"))
                 .shared_llvm(false)
                 .use_bolt(false)
                 .skipped_tests(vec![])
diff --git a/src/tools/opt-dist/src/tests.rs b/src/tools/opt-dist/src/tests.rs
index 2d2aab86eda..c3c45d262dd 100644
--- a/src/tools/opt-dist/src/tests.rs
+++ b/src/tools/opt-dist/src/tests.rs
@@ -13,7 +13,7 @@ pub fn run_tests(env: &Environment) -> anyhow::Result<()> {
     // and then use that extracted rustc as a stage0 compiler.
     // Then we run a subset of tests using that compiler, to have a basic smoke test which checks
     // whether the optimization pipeline hasn't broken something.
-    let build_dir = env.build_root().join("build");
+    let build_dir = env.build_root();
     let dist_dir = build_dir.join("dist");
     let unpacked_dist_dir = build_dir.join("unpacked-dist");
     std::fs::create_dir_all(&unpacked_dist_dir)?;
-- 
cgit 1.4.1-3-g733a5


From 41ce1ed252f194756fb2f3e3e92bbdfb3940088d Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Thu, 6 Mar 2025 19:13:46 -0800
Subject: Ban projecting into SIMD types [MCP838]

---
 compiler/rustc_codegen_ssa/src/mir/operand.rs     | 19 ++++----------
 compiler/rustc_mir_transform/src/validate.rs      |  9 +++++++
 tests/codegen/simd/project-to-simd-array-field.rs | 31 -----------------------
 tests/ui/mir/validate/project-into-simd.rs        | 18 +++++++++++++
 tests/ui/simd/issue-105439.rs                     |  4 ++-
 5 files changed, 35 insertions(+), 46 deletions(-)
 delete mode 100644 tests/codegen/simd/project-to-simd-array-field.rs
 create mode 100644 tests/ui/mir/validate/project-into-simd.rs

diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index 6a3fdb6ede1..06bedaaa4a2 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -329,20 +329,11 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
         let offset = self.layout.fields.offset(i);
 
         if !bx.is_backend_ref(self.layout) && bx.is_backend_ref(field) {
-            if let BackendRepr::SimdVector { count, .. } = self.layout.backend_repr
-                && let BackendRepr::Memory { sized: true } = field.backend_repr
-                && count.is_power_of_two()
-            {
-                assert_eq!(field.size, self.layout.size);
-                // This is being deprecated, but for now stdarch still needs it for
-                // Newtype vector of array, e.g. #[repr(simd)] struct S([i32; 4]);
-                let place = PlaceRef::alloca(bx, field);
-                self.val.store(bx, place.val.with_type(self.layout));
-                return bx.load_operand(place);
-            } else {
-                // Part of https://github.com/rust-lang/compiler-team/issues/838
-                bug!("Non-ref type {self:?} cannot project to ref field type {field:?}");
-            }
+            // Part of https://github.com/rust-lang/compiler-team/issues/838
+            span_bug!(
+                fx.mir.span,
+                "Non-ref type {self:?} cannot project to ref field type {field:?}",
+            );
         }
 
         let val = if field.is_zst() {
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index 659ca4df159..5860072d541 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -721,6 +721,15 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                             );
                         }
 
+                        if adt_def.repr().simd() {
+                            self.fail(
+                                location,
+                                format!(
+                                    "Projecting into SIMD type {adt_def:?} is banned by MCP#838"
+                                ),
+                            );
+                        }
+
                         let var = parent_ty.variant_index.unwrap_or(FIRST_VARIANT);
                         let Some(field) = adt_def.variant(var).fields.get(f) else {
                             fail_out_of_bounds(self, location);
diff --git a/tests/codegen/simd/project-to-simd-array-field.rs b/tests/codegen/simd/project-to-simd-array-field.rs
deleted file mode 100644
index 29fab640633..00000000000
--- a/tests/codegen/simd/project-to-simd-array-field.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-
-#[allow(non_camel_case_types)]
-#[derive(Clone, Copy)]
-#[repr(simd)]
-struct i32x4([i32; 4]);
-
-#[inline(always)]
-fn to_array4(a: i32x4) -> [i32; 4] {
-    a.0
-}
-
-// CHECK-LABEL: simd_add_self_then_return_array(
-// CHECK-SAME: ptr{{.+}}sret{{.+}}%[[RET:.+]],
-// CHECK-SAME: ptr{{.+}}%a)
-#[no_mangle]
-pub fn simd_add_self_then_return_array(a: &i32x4) -> [i32; 4] {
-    // It would be nice to just ban `.0` into simd types,
-    // but until we do this has to keep working.
-    // See also <https://github.com/rust-lang/rust/issues/105439>
-
-    // CHECK: %[[T1:.+]] = load <4 x i32>, ptr %a
-    // CHECK: %[[T2:.+]] = shl <4 x i32> %[[T1]], {{splat \(i32 1\)|<i32 1, i32 1, i32 1, i32 1>}}
-    // CHECK: store <4 x i32> %[[T2]], ptr %[[RET]]
-    let a = *a;
-    let b = unsafe { core::intrinsics::simd::simd_add(a, a) };
-    to_array4(b)
-}
diff --git a/tests/ui/mir/validate/project-into-simd.rs b/tests/ui/mir/validate/project-into-simd.rs
new file mode 100644
index 00000000000..67766c8c4b0
--- /dev/null
+++ b/tests/ui/mir/validate/project-into-simd.rs
@@ -0,0 +1,18 @@
+// Optimized MIR shouldn't have critical call edges
+//
+//@ build-fail
+//@ edition: 2021
+//@ compile-flags: --crate-type=lib
+//@ failure-status: 101
+//@ dont-check-compiler-stderr
+
+#![feature(repr_simd)]
+
+#[repr(simd)]
+pub struct U32x4([u32; 4]);
+
+pub fn f(a: U32x4) -> [u32; 4] {
+    a.0
+    //~^ ERROR broken MIR in Item
+    //~| ERROR Projecting into SIMD type U32x4 is banned by MCP#838
+}
diff --git a/tests/ui/simd/issue-105439.rs b/tests/ui/simd/issue-105439.rs
index 0a44f36fb2e..1d57eff341c 100644
--- a/tests/ui/simd/issue-105439.rs
+++ b/tests/ui/simd/issue-105439.rs
@@ -10,7 +10,9 @@ struct i32x4([i32; 4]);
 
 #[inline(always)]
 fn to_array(a: i32x4) -> [i32; 4] {
-    a.0
+    // This was originally just `a.0`, but that ended up being annoying enough
+    // that it was banned by <https://github.com/rust-lang/compiler-team/issues/838>
+    unsafe { std::mem::transmute(a) }
 }
 
 fn main() {
-- 
cgit 1.4.1-3-g733a5


From 1e96d7a55304f8573b6dfeb5ccbdabdb407b89b9 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 20 Jul 2025 17:44:55 +0000
Subject: Consider param-env for fast path

---
 .../rustc_trait_selection/src/solve/delegate.rs    | 22 ++++++----------
 .../rustc_trait_selection/src/traits/fulfill.rs    |  2 +-
 .../src/traits/query/type_op/prove_predicate.rs    |  2 +-
 .../rustc_trait_selection/src/traits/select/mod.rs |  2 +-
 compiler/rustc_trait_selection/src/traits/util.rs  | 20 ++++++++++++++-
 compiler/rustc_traits/src/evaluate_obligation.rs   |  2 +-
 ...nce-issue-143992.current_sized_hierarchy.stderr | 17 +++++++++++++
 .../incomplete-inference-issue-143992.next.stderr  | 17 -------------
 ...erence-issue-143992.next_sized_hierarchy.stderr | 17 +++++++++++++
 .../incomplete-inference-issue-143992.rs           | 10 +++++---
 .../cycles/normalizes-to-is-not-productive.stderr  |  7 ------
 .../normalize/normalize-param-env-2.stderr         | 19 +-------------
 .../normalize/normalize-param-env-4.next.stderr    | 16 +-----------
 tests/ui/where-clauses/ignore-err-clauses.rs       |  2 +-
 tests/ui/where-clauses/ignore-err-clauses.stderr   | 29 +++++++++++++++++-----
 15 files changed, 97 insertions(+), 87 deletions(-)
 create mode 100644 tests/ui/sized-hierarchy/incomplete-inference-issue-143992.current_sized_hierarchy.stderr
 delete mode 100644 tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next.stderr
 create mode 100644 tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next_sized_hierarchy.stderr

diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
index 17429e15cce..7426504e139 100644
--- a/compiler/rustc_trait_selection/src/solve/delegate.rs
+++ b/compiler/rustc_trait_selection/src/solve/delegate.rs
@@ -12,11 +12,11 @@ use rustc_infer::traits::solve::Goal;
 use rustc_middle::traits::query::NoSolution;
 use rustc_middle::traits::solve::Certainty;
 use rustc_middle::ty::{
-    self, SizedTraitKind, Ty, TyCtxt, TypeFlags, TypeFoldable, TypeVisitableExt as _, TypingMode,
+    self, Ty, TyCtxt, TypeFlags, TypeFoldable, TypeVisitableExt as _, TypingMode,
 };
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 
-use crate::traits::{EvaluateConstErr, ObligationCause, specialization_graph};
+use crate::traits::{EvaluateConstErr, ObligationCause, sizedness_fast_path, specialization_graph};
 
 #[repr(transparent)]
 pub struct SolverDelegate<'tcx>(InferCtxt<'tcx>);
@@ -76,19 +76,11 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
 
             if trait_pred.polarity() == ty::PredicatePolarity::Positive {
                 match self.0.tcx.as_lang_item(trait_pred.def_id()) {
-                    Some(LangItem::Sized)
-                        if self
-                            .resolve_vars_if_possible(trait_pred.self_ty().skip_binder())
-                            .has_trivial_sizedness(self.0.tcx, SizedTraitKind::Sized) =>
-                    {
-                        return Some(Certainty::Yes);
-                    }
-                    Some(LangItem::MetaSized)
-                        if self
-                            .resolve_vars_if_possible(trait_pred.self_ty().skip_binder())
-                            .has_trivial_sizedness(self.0.tcx, SizedTraitKind::MetaSized) =>
-                    {
-                        return Some(Certainty::Yes);
+                    Some(LangItem::Sized) | Some(LangItem::MetaSized) => {
+                        let predicate = self.resolve_vars_if_possible(goal.predicate);
+                        if sizedness_fast_path(self.tcx, predicate, goal.param_env) {
+                            return Some(Certainty::Yes);
+                        }
                     }
                     Some(LangItem::Copy | LangItem::Clone) => {
                         let self_ty =
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index e35f89358e9..6b884b36080 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -363,7 +363,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
 
         let infcx = self.selcx.infcx;
 
-        if sizedness_fast_path(infcx.tcx, obligation.predicate) {
+        if sizedness_fast_path(infcx.tcx, obligation.predicate, obligation.param_env) {
             return ProcessResult::Changed(thin_vec![]);
         }
 
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs
index 22eeb285b37..f24214145ba 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs
@@ -15,7 +15,7 @@ impl<'tcx> super::QueryTypeOp<'tcx> for ProvePredicate<'tcx> {
         tcx: TyCtxt<'tcx>,
         key: &ParamEnvAnd<'tcx, Self>,
     ) -> Option<Self::QueryResponse> {
-        if sizedness_fast_path(tcx, key.value.predicate) {
+        if sizedness_fast_path(tcx, key.value.predicate, key.param_env) {
             return Some(());
         }
 
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 2b563c5b8d5..f90316f520b 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -597,7 +597,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             None => self.check_recursion_limit(&obligation, &obligation)?,
         }
 
-        if sizedness_fast_path(self.tcx(), obligation.predicate) {
+        if sizedness_fast_path(self.tcx(), obligation.predicate, obligation.param_env) {
             return Ok(EvaluatedToOk);
         }
 
diff --git a/compiler/rustc_trait_selection/src/traits/util.rs b/compiler/rustc_trait_selection/src/traits/util.rs
index 0c14b124e25..c3d60ec45c4 100644
--- a/compiler/rustc_trait_selection/src/traits/util.rs
+++ b/compiler/rustc_trait_selection/src/traits/util.rs
@@ -365,7 +365,11 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for PlaceholderReplacer<'_, 'tcx> {
     }
 }
 
-pub fn sizedness_fast_path<'tcx>(tcx: TyCtxt<'tcx>, predicate: ty::Predicate<'tcx>) -> bool {
+pub fn sizedness_fast_path<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    predicate: ty::Predicate<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+) -> bool {
     // Proving `Sized`/`MetaSized`, very often on "obviously sized" types like
     // `&T`, accounts for about 60% percentage of the predicates we have to prove. No need to
     // canonicalize and all that for such cases.
@@ -390,6 +394,20 @@ pub fn sizedness_fast_path<'tcx>(tcx: TyCtxt<'tcx>, predicate: ty::Predicate<'tc
             debug!("fast path -- trivial sizedness");
             return true;
         }
+
+        if matches!(trait_pred.self_ty().kind(), ty::Param(_) | ty::Placeholder(_)) {
+            for clause in param_env.caller_bounds() {
+                if let ty::ClauseKind::Trait(clause_pred) = clause.kind().skip_binder()
+                    && clause_pred.polarity == ty::PredicatePolarity::Positive
+                    && clause_pred.self_ty() == trait_pred.self_ty()
+                    && (clause_pred.def_id() == trait_pred.def_id()
+                        || (sizedness == SizedTraitKind::MetaSized
+                            && tcx.is_lang_item(clause_pred.def_id(), LangItem::Sized)))
+                {
+                    return true;
+                }
+            }
+        }
     }
 
     false
diff --git a/compiler/rustc_traits/src/evaluate_obligation.rs b/compiler/rustc_traits/src/evaluate_obligation.rs
index 7771db855d7..819b8e3231c 100644
--- a/compiler/rustc_traits/src/evaluate_obligation.rs
+++ b/compiler/rustc_traits/src/evaluate_obligation.rs
@@ -24,7 +24,7 @@ fn evaluate_obligation<'tcx>(
     debug!("evaluate_obligation: goal={:#?}", goal);
     let ParamEnvAnd { param_env, value: predicate } = goal;
 
-    if sizedness_fast_path(tcx, predicate) {
+    if sizedness_fast_path(tcx, predicate, param_env) {
         return Ok(EvaluationResult::EvaluatedToOk);
     }
 
diff --git a/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.current_sized_hierarchy.stderr b/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.current_sized_hierarchy.stderr
new file mode 100644
index 00000000000..b904b784df7
--- /dev/null
+++ b/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.current_sized_hierarchy.stderr
@@ -0,0 +1,17 @@
+error[E0308]: mismatched types
+  --> $DIR/incomplete-inference-issue-143992.rs:30:28
+   |
+LL |     let _x = T::Assoc::new(());
+   |              ------------- ^^ expected `[u32; 1]`, found `()`
+   |              |
+   |              arguments to this function are incorrect
+   |
+note: associated function defined here
+  --> $DIR/incomplete-inference-issue-143992.rs:21:8
+   |
+LL |     fn new(r: R) -> R {
+   |        ^^^ ----
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next.stderr b/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next.stderr
deleted file mode 100644
index cf56f42afc8..00000000000
--- a/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/incomplete-inference-issue-143992.rs:27:28
-   |
-LL |     let _x = T::Assoc::new(());
-   |              ------------- ^^ expected `[u32; 1]`, found `()`
-   |              |
-   |              arguments to this function are incorrect
-   |
-note: associated function defined here
-  --> $DIR/incomplete-inference-issue-143992.rs:18:8
-   |
-LL |     fn new(r: R) -> R {
-   |        ^^^ ----
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next_sized_hierarchy.stderr b/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next_sized_hierarchy.stderr
new file mode 100644
index 00000000000..b904b784df7
--- /dev/null
+++ b/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.next_sized_hierarchy.stderr
@@ -0,0 +1,17 @@
+error[E0308]: mismatched types
+  --> $DIR/incomplete-inference-issue-143992.rs:30:28
+   |
+LL |     let _x = T::Assoc::new(());
+   |              ------------- ^^ expected `[u32; 1]`, found `()`
+   |              |
+   |              arguments to this function are incorrect
+   |
+note: associated function defined here
+  --> $DIR/incomplete-inference-issue-143992.rs:21:8
+   |
+LL |     fn new(r: R) -> R {
+   |        ^^^ ----
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.rs b/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.rs
index 3e3e1dc50e5..b9e65ed2839 100644
--- a/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.rs
+++ b/tests/ui/sized-hierarchy/incomplete-inference-issue-143992.rs
@@ -1,9 +1,12 @@
 //@ compile-flags: --crate-type=lib
-//@ revisions: current next
+//@ revisions: current next current_sized_hierarchy next_sized_hierarchy
 //@ ignore-compare-mode-next-solver (explicit revisions)
 //@[current] check-pass
+//@[next] check-pass
 //@[next] compile-flags: -Znext-solver
-//@[next] check-fail
+//@[next_sized_hierarchy] compile-flags: -Znext-solver
+
+#![cfg_attr(any(current_sized_hierarchy, next_sized_hierarchy), feature(sized_hierarchy))]
 
 // Test that we avoid incomplete inference when normalizing. Without this,
 // `Trait`'s implicit `MetaSized` supertrait requires proving `T::Assoc<_>: MetaSized`
@@ -25,5 +28,6 @@ where
     T::Assoc<[u32; 1]>: Clone,
 {
     let _x = T::Assoc::new(());
-//[next]~^ ERROR mismatched types
+    //[next_sized_hierarchy]~^ ERROR mismatched types
+    //[current_sized_hierarchy]~^^ ERROR mismatched types
 }
diff --git a/tests/ui/traits/next-solver/cycles/normalizes-to-is-not-productive.stderr b/tests/ui/traits/next-solver/cycles/normalizes-to-is-not-productive.stderr
index 1eb445f4848..8901805a20f 100644
--- a/tests/ui/traits/next-solver/cycles/normalizes-to-is-not-productive.stderr
+++ b/tests/ui/traits/next-solver/cycles/normalizes-to-is-not-productive.stderr
@@ -12,13 +12,6 @@ LL | impl<T: Bound, U> Trait<U> for T {
    |         -----     ^^^^^^^^     ^
    |         |
    |         unsatisfied trait bound introduced here
-note: required by a bound in `Bound`
-  --> $DIR/normalizes-to-is-not-productive.rs:8:1
-   |
-LL | / trait Bound {
-LL | |     fn method();
-LL | | }
-   | |_^ required by this bound in `Bound`
 
 error[E0277]: the trait bound `Foo: Bound` is not satisfied
   --> $DIR/normalizes-to-is-not-productive.rs:47:19
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 8d8909625ff..d179c805962 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
@@ -19,23 +19,6 @@ 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: MetaSized`
-  --> $DIR/normalize-param-env-2.rs:24:22
-   |
-LL |         Self::Assoc: A<T>,
-   |                      ^^^^
-   |
-note: required by a bound in `A`
-  --> $DIR/normalize-param-env-2.rs:9:1
-   |
-LL | / trait A<T> {
-LL | |     type Assoc;
-LL | |
-LL | |     fn f()
-...  |
-LL | | }
-   | |_^ required by this bound in `A`
-
 error[E0275]: overflow evaluating the requirement `<() as A<T>>::Assoc well-formed`
   --> $DIR/normalize-param-env-2.rs:24:22
    |
@@ -63,6 +46,6 @@ LL |     where
 LL |         Self::Assoc: A<T>,
    |                      ^^^^ required by this bound in `A::f`
 
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/next-solver/normalize/normalize-param-env-4.next.stderr b/tests/ui/traits/next-solver/normalize/normalize-param-env-4.next.stderr
index 9f7f74f9466..f5fd9ce9864 100644
--- a/tests/ui/traits/next-solver/normalize/normalize-param-env-4.next.stderr
+++ b/tests/ui/traits/next-solver/normalize/normalize-param-env-4.next.stderr
@@ -4,20 +4,6 @@ error[E0275]: overflow evaluating the requirement `<T as Trait>::Assoc: Trait`
 LL |     <T as Trait>::Assoc: Trait,
    |                          ^^^^^
 
-error[E0275]: overflow evaluating the requirement `<T as Trait>::Assoc: MetaSized`
-  --> $DIR/normalize-param-env-4.rs:19:26
-   |
-LL |     <T as Trait>::Assoc: Trait,
-   |                          ^^^^^
-   |
-note: required by a bound in `Trait`
-  --> $DIR/normalize-param-env-4.rs:7:1
-   |
-LL | / trait Trait {
-LL | |     type Assoc;
-LL | | }
-   | |_^ required by this bound in `Trait`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/where-clauses/ignore-err-clauses.rs b/tests/ui/where-clauses/ignore-err-clauses.rs
index 428ebf4b408..6f21e5ccbaa 100644
--- a/tests/ui/where-clauses/ignore-err-clauses.rs
+++ b/tests/ui/where-clauses/ignore-err-clauses.rs
@@ -1,13 +1,13 @@
 use std::ops::Add;
 
 fn dbl<T>(x: T) -> <T as Add>::Output
-//~^ ERROR type annotations needed
 where
     T: Copy + Add,
     UUU: Copy,
     //~^ ERROR cannot find type `UUU` in this scope
 {
     x + x
+    //~^ ERROR use of moved value: `x`
 }
 
 fn main() {
diff --git a/tests/ui/where-clauses/ignore-err-clauses.stderr b/tests/ui/where-clauses/ignore-err-clauses.stderr
index fbf1b99334f..9c76c1c6a04 100644
--- a/tests/ui/where-clauses/ignore-err-clauses.stderr
+++ b/tests/ui/where-clauses/ignore-err-clauses.stderr
@@ -1,16 +1,33 @@
 error[E0412]: cannot find type `UUU` in this scope
-  --> $DIR/ignore-err-clauses.rs:7:5
+  --> $DIR/ignore-err-clauses.rs:6:5
    |
 LL |     UUU: Copy,
    |     ^^^ not found in this scope
 
-error[E0282]: type annotations needed
-  --> $DIR/ignore-err-clauses.rs:3:14
+error[E0382]: use of moved value: `x`
+  --> $DIR/ignore-err-clauses.rs:9:9
    |
 LL | fn dbl<T>(x: T) -> <T as Add>::Output
-   |              ^ cannot infer type for type parameter `T`
+   |           - move occurs because `x` has type `T`, which does not implement the `Copy` trait
+...
+LL |     x + x
+   |     ----^
+   |     |   |
+   |     |   value used here after move
+   |     `x` moved due to usage in operator
+   |
+help: if `T` implemented `Clone`, you could clone the value
+  --> $DIR/ignore-err-clauses.rs:3:8
+   |
+LL | fn dbl<T>(x: T) -> <T as Add>::Output
+   |        ^ consider constraining this type parameter with `Clone`
+...
+LL |     x + x
+   |     - you could clone this value
+note: calling this operator moves the left-hand side
+  --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
 
 error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0282, E0412.
-For more information about an error, try `rustc --explain E0282`.
+Some errors have detailed explanations: E0382, E0412.
+For more information about an error, try `rustc --explain E0382`.
-- 
cgit 1.4.1-3-g733a5


From f147716e7d5a3b4e1e4c0e8b5b5dd26da00cdab0 Mon Sep 17 00:00:00 2001
From: Marijn Schouten <mhkbst@gmail.com>
Date: Sun, 20 Jul 2025 05:33:25 +0000
Subject: flt2dec: use fill instead of loop

---
 library/core/src/num/flt2dec/mod.rs | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/library/core/src/num/flt2dec/mod.rs b/library/core/src/num/flt2dec/mod.rs
index 7601e3e2c58..e79a00a8659 100644
--- a/library/core/src/num/flt2dec/mod.rs
+++ b/library/core/src/num/flt2dec/mod.rs
@@ -150,23 +150,19 @@ pub fn round_up(d: &mut [u8]) -> Option<u8> {
         Some(i) => {
             // d[i+1..n] is all nines
             d[i] += 1;
-            for j in i + 1..d.len() {
-                d[j] = b'0';
-            }
+            d[i + 1..].fill(b'0');
             None
         }
-        None if d.len() > 0 => {
+        None if d.is_empty() => {
+            // an empty buffer rounds up (a bit strange but reasonable)
+            Some(b'1')
+        }
+        None => {
             // 999..999 rounds to 1000..000 with an increased exponent
             d[0] = b'1';
-            for j in 1..d.len() {
-                d[j] = b'0';
-            }
+            d[1..].fill(b'0');
             Some(b'0')
         }
-        None => {
-            // an empty buffer rounds up (a bit strange but reasonable)
-            Some(b'1')
-        }
     }
 }
 
-- 
cgit 1.4.1-3-g733a5


From 725523e9b0b7f8c415e238a09a61688a7f3d36a9 Mon Sep 17 00:00:00 2001
From: David Mládek <david.mladek.cz@gmail.com>
Date: Wed, 16 Jul 2025 17:49:47 +0200
Subject: tests: cover more `exported_private_dependencies` cases

---
 .../ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs  |   6 +
 tests/ui/privacy/pub-priv-dep/pub-priv1.rs         |  71 ++++++++-
 tests/ui/privacy/pub-priv-dep/pub-priv1.stderr     | 166 ++++++++++++++++++---
 3 files changed, 223 insertions(+), 20 deletions(-)

diff --git a/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs b/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs
index 75640147026..d389f8c861a 100644
--- a/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs
+++ b/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs
@@ -10,3 +10,9 @@ macro_rules! m {
 pub enum E {
     V1
 }
+
+struct PrivType;
+
+pub type Unit = ();
+pub type PubPub = OtherType;
+pub type PubPriv = PrivType;
diff --git a/tests/ui/privacy/pub-priv-dep/pub-priv1.rs b/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
index b85f2754fb1..eae0f9756a1 100644
--- a/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
+++ b/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
@@ -32,6 +32,33 @@ pub struct PublicType {
     pub other_field: PubType, // Type from public dependency - this is fine
 }
 
+pub struct PublicTuple(
+    pub OtherType,
+    //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface [exported_private_dependencies]
+    OtherType,
+    pub PubType,
+);
+
+pub enum PublicEnum {
+    OtherType,
+    ActualOtherType(OtherType, PubType),
+    //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface [exported_private_dependencies]
+    ActualOtherTypeStruct {
+        field: OtherType,
+        //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface [exported_private_dependencies]
+        other_field: PubType,
+    },
+}
+
+pub struct PublicGenericType<T, U>(pub T, U);
+pub type ReexportedPublicGeneric = PublicGenericType<OtherType, ()>;
+//~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+pub type ReexportedPrivateGeneric = PublicGenericType<(), OtherType>;
+//~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+
+pub struct PublicGenericBoundedType<T: OtherTrait>(T);
+//~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
+
 impl PublicType {
     pub fn pub_fn_param(param: OtherType) {}
     //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
@@ -46,9 +73,15 @@ pub trait MyPubTrait {
     type Foo: OtherTrait;
     //~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
 
-    fn required() -> impl OtherTrait;
+    fn required_impl_trait() -> impl OtherTrait;
 
-    fn provided() -> impl OtherTrait { OtherType }
+    fn provided_impl_trait() -> impl OtherTrait { OtherType }
+
+    fn required_concrete() -> OtherType;
+    //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+
+    fn provided_concrete() -> OtherType { OtherType }
+    //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
 }
 
 pub trait WithSuperTrait: OtherTrait {}
@@ -67,6 +100,12 @@ impl PubLocalTraitWithAssoc for PrivateAssoc {
 pub fn in_bounds<T: OtherTrait>(x: T) { unimplemented!() }
 //~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
 
+pub fn private_return_impl_trait() -> impl OtherTrait { OtherType }
+//~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
+
+pub fn private_return() -> OtherType { OtherType }
+//~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+
 pub fn private_in_generic() -> std::num::Saturating<OtherType> { unimplemented!() }
 //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
 
@@ -79,6 +118,9 @@ pub const CONST: OtherType = OtherType;
 pub type Alias = OtherType;
 //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
 
+pub type AliasOfAlias = priv_dep::PubPub;
+//~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+
 pub struct PublicWithPrivateImpl;
 
 impl OtherTrait for PublicWithPrivateImpl {}
@@ -90,6 +132,22 @@ impl PubTraitOnPrivate for OtherType {}
 //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
 //~| ERROR type `OtherType` from private dependency 'priv_dep' in public interface
 
+pub struct PublicWithStdImpl;
+
+impl From<OtherType> for PublicWithStdImpl {
+//~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+    fn from(val: OtherType) -> Self { Self }
+    //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+}
+
+impl From<PublicWithStdImpl> for OtherType {
+    //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+    //~| ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+    fn from(val: PublicWithStdImpl) -> Self { Self }
+    //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+    //~| ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+}
+
 pub struct AllowedPrivType {
     #[allow(exported_private_dependencies)]
     pub allowed: OtherType,
@@ -107,4 +165,13 @@ pub use pm::pm_attr;
 pub use priv_dep::E::V1;
 //~^ ERROR variant `V1` from private dependency 'priv_dep' is re-exported
 
+pub use priv_dep::Unit;
+//~^ ERROR type alias `Unit` from private dependency 'priv_dep' is re-exported
+pub use priv_dep::PubPub;
+//~^ ERROR type alias `PubPub` from private dependency 'priv_dep' is re-exported
+pub use priv_dep::PubPriv;
+//~^ ERROR type alias `PubPriv` from private dependency 'priv_dep' is re-exported
+pub use priv_dep::OtherType as Renamed;
+//~^ ERROR struct `Renamed` from private dependency 'priv_dep' is re-exported
+
 fn main() {}
diff --git a/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr b/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
index 24bd071567f..e66db53f65d 100644
--- a/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
+++ b/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
@@ -11,35 +11,59 @@ LL | #![deny(exported_private_dependencies)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: macro `m` from private dependency 'priv_dep' is re-exported
-  --> $DIR/pub-priv1.rs:98:9
+  --> $DIR/pub-priv1.rs:156:9
    |
 LL | pub use priv_dep::m;
    |         ^^^^^^^^^^^
 
 error: macro `fn_like` from private dependency 'pm' is re-exported
-  --> $DIR/pub-priv1.rs:100:9
+  --> $DIR/pub-priv1.rs:158:9
    |
 LL | pub use pm::fn_like;
    |         ^^^^^^^^^^^
 
 error: derive macro `PmDerive` from private dependency 'pm' is re-exported
-  --> $DIR/pub-priv1.rs:102:9
+  --> $DIR/pub-priv1.rs:160:9
    |
 LL | pub use pm::PmDerive;
    |         ^^^^^^^^^^^^
 
 error: attribute macro `pm_attr` from private dependency 'pm' is re-exported
-  --> $DIR/pub-priv1.rs:104:9
+  --> $DIR/pub-priv1.rs:162:9
    |
 LL | pub use pm::pm_attr;
    |         ^^^^^^^^^^^
 
 error: variant `V1` from private dependency 'priv_dep' is re-exported
-  --> $DIR/pub-priv1.rs:107:9
+  --> $DIR/pub-priv1.rs:165:9
    |
 LL | pub use priv_dep::E::V1;
    |         ^^^^^^^^^^^^^^^
 
+error: type alias `Unit` from private dependency 'priv_dep' is re-exported
+  --> $DIR/pub-priv1.rs:168:9
+   |
+LL | pub use priv_dep::Unit;
+   |         ^^^^^^^^^^^^^^
+
+error: type alias `PubPub` from private dependency 'priv_dep' is re-exported
+  --> $DIR/pub-priv1.rs:170:9
+   |
+LL | pub use priv_dep::PubPub;
+   |         ^^^^^^^^^^^^^^^^
+
+error: type alias `PubPriv` from private dependency 'priv_dep' is re-exported
+  --> $DIR/pub-priv1.rs:172:9
+   |
+LL | pub use priv_dep::PubPriv;
+   |         ^^^^^^^^^^^^^^^^^
+
+error: struct `Renamed` from private dependency 'priv_dep' is re-exported
+  --> $DIR/pub-priv1.rs:174:9
+   |
+LL | pub use priv_dep::OtherType as Renamed;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: type `OtherType` from private dependency 'priv_dep' in public interface
   --> $DIR/pub-priv1.rs:29:5
    |
@@ -49,82 +73,188 @@ LL |     pub field: OtherType,
 error: type `OtherType` from private dependency 'priv_dep' in public interface
   --> $DIR/pub-priv1.rs:36:5
    |
+LL |     pub OtherType,
+   |     ^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:44:21
+   |
+LL |     ActualOtherType(OtherType, PubType),
+   |                     ^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:47:9
+   |
+LL |         field: OtherType,
+   |         ^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:54:1
+   |
+LL | pub type ReexportedPublicGeneric = PublicGenericType<OtherType, ()>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:56:1
+   |
+LL | pub type ReexportedPrivateGeneric = PublicGenericType<(), OtherType>;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:59:1
+   |
+LL | pub struct PublicGenericBoundedType<T: OtherTrait>(T);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:63:5
+   |
 LL |     pub fn pub_fn_param(param: OtherType) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:39:5
+  --> $DIR/pub-priv1.rs:66:5
    |
 LL |     pub fn pub_fn_return() -> OtherType { OtherType }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:46:5
+  --> $DIR/pub-priv1.rs:73:5
    |
 LL |     type Foo: OtherTrait;
    |     ^^^^^^^^^^^^^^^^^^^^
 
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:80:5
+   |
+LL |     fn required_concrete() -> OtherType;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:83:5
+   |
+LL |     fn provided_concrete() -> OtherType { OtherType }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:54:1
+  --> $DIR/pub-priv1.rs:87:1
    |
 LL | pub trait WithSuperTrait: OtherTrait {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:63:5
+  --> $DIR/pub-priv1.rs:96:5
    |
 LL |     type X = OtherType;
    |     ^^^^^^
 
 error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:67:1
+  --> $DIR/pub-priv1.rs:100:1
    |
 LL | pub fn in_bounds<T: OtherTrait>(x: T) { unimplemented!() }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:103:1
+   |
+LL | pub fn private_return_impl_trait() -> impl OtherTrait { OtherType }
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:106:1
+   |
+LL | pub fn private_return() -> OtherType { OtherType }
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:70:1
+  --> $DIR/pub-priv1.rs:109:1
    |
 LL | pub fn private_in_generic() -> std::num::Saturating<OtherType> { unimplemented!() }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:73:1
+  --> $DIR/pub-priv1.rs:112:1
    |
 LL | pub static STATIC: OtherType = OtherType;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:76:1
+  --> $DIR/pub-priv1.rs:115:1
    |
 LL | pub const CONST: OtherType = OtherType;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:79:1
+  --> $DIR/pub-priv1.rs:118:1
    |
 LL | pub type Alias = OtherType;
    | ^^^^^^^^^^^^^^
 
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:121:1
+   |
+LL | pub type AliasOfAlias = priv_dep::PubPub;
+   | ^^^^^^^^^^^^^^^^^^^^^
+
 error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:84:1
+  --> $DIR/pub-priv1.rs:126:1
    |
 LL | impl OtherTrait for PublicWithPrivateImpl {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:89:1
+  --> $DIR/pub-priv1.rs:131:1
    |
 LL | impl PubTraitOnPrivate for OtherType {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `OtherType` from private dependency 'priv_dep' in public interface
-  --> $DIR/pub-priv1.rs:89:1
+  --> $DIR/pub-priv1.rs:131:1
    |
 LL | impl PubTraitOnPrivate for OtherType {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 20 previous errors
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:137:1
+   |
+LL | impl From<OtherType> for PublicWithStdImpl {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:139:5
+   |
+LL |     fn from(val: OtherType) -> Self { Self }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:143:1
+   |
+LL | impl From<PublicWithStdImpl> for OtherType {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:143:1
+   |
+LL | impl From<PublicWithStdImpl> for OtherType {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:146:5
+   |
+LL |     fn from(val: PublicWithStdImpl) -> Self { Self }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+  --> $DIR/pub-priv1.rs:146:5
+   |
+LL |     fn from(val: PublicWithStdImpl) -> Self { Self }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 41 previous errors
 
-- 
cgit 1.4.1-3-g733a5


From 3f9be406a6fd879a99a0eba33cc196fa2cb3957b Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 19 Jul 2025 20:04:08 +0200
Subject: fix handling of base address for TypeId allocations

---
 .../rustc_const_eval/src/const_eval/machine.rs     | 18 ++-----
 compiler/rustc_const_eval/src/interpret/memory.rs  | 16 ++++--
 src/tools/miri/src/alloc_addresses/mod.rs          | 58 +++++++++++++---------
 .../miri/src/borrow_tracker/stacked_borrows/mod.rs |  4 +-
 .../miri/src/borrow_tracker/tree_borrows/mod.rs    |  2 +-
 5 files changed, 55 insertions(+), 43 deletions(-)

diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index f24fb18f83b..a18ae79f318 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -279,23 +279,15 @@ impl<'tcx> CompileTimeInterpCx<'tcx> {
     fn guaranteed_cmp(&mut self, a: Scalar, b: Scalar) -> InterpResult<'tcx, u8> {
         interp_ok(match (a, b) {
             // Comparisons between integers are always known.
-            (Scalar::Int { .. }, Scalar::Int { .. }) => {
-                if a == b {
-                    1
-                } else {
-                    0
-                }
-            }
-            // Comparisons of abstract pointers with null pointers are known if the pointer
-            // is in bounds, because if they are in bounds, the pointer can't be null.
-            // Inequality with integers other than null can never be known for sure.
-            (Scalar::Int(int), ptr @ Scalar::Ptr(..))
-            | (ptr @ Scalar::Ptr(..), Scalar::Int(int))
+            (Scalar::Int(a), Scalar::Int(b)) => (a == b) as u8,
+            // Comparisons of null with an arbitrary scalar can be known if `scalar_may_be_null`
+            // indicates that the scalar can definitely *not* be null.
+            (Scalar::Int(int), ptr) | (ptr, Scalar::Int(int))
                 if int.is_null() && !self.scalar_may_be_null(ptr)? =>
             {
                 0
             }
-            // Equality with integers can never be known for sure.
+            // Other ways of comparing integers and pointers can never be known for sure.
             (Scalar::Int { .. }, Scalar::Ptr(..)) | (Scalar::Ptr(..), Scalar::Int { .. }) => 2,
             // FIXME: return a `1` for when both sides are the same pointer, *except* that
             // some things (like functions and vtables) do not have stable addresses
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 20c8e983cea..34297a61648 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -67,8 +67,10 @@ pub enum AllocKind {
     LiveData,
     /// A function allocation (that fn ptrs point to).
     Function,
-    /// A "virtual" allocation, used for vtables and TypeId.
-    Virtual,
+    /// A vtable allocation.
+    VTable,
+    /// A TypeId allocation.
+    TypeId,
     /// A dead allocation.
     Dead,
 }
@@ -952,7 +954,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             let kind = match global_alloc {
                 GlobalAlloc::Static { .. } | GlobalAlloc::Memory { .. } => AllocKind::LiveData,
                 GlobalAlloc::Function { .. } => bug!("We already checked function pointers above"),
-                GlobalAlloc::VTable { .. } | GlobalAlloc::TypeId { .. } => AllocKind::Virtual,
+                GlobalAlloc::VTable { .. } => AllocKind::VTable,
+                GlobalAlloc::TypeId { .. } => AllocKind::TypeId,
             };
             return AllocInfo::new(size, align, kind, mutbl);
         }
@@ -1617,6 +1620,13 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 match self.ptr_try_get_alloc_id(ptr, 0) {
                     Ok((alloc_id, offset, _)) => {
                         let info = self.get_alloc_info(alloc_id);
+                        if matches!(info.kind, AllocKind::TypeId) {
+                            // We *could* actually precisely answer this question since here,
+                            // the offset *is* the integer value. But the entire point of making
+                            // this a pointer is not to leak the integer value, so we say everything
+                            // might be null.
+                            return interp_ok(true);
+                        }
                         // If the pointer is in-bounds (including "at the end"), it is definitely not null.
                         if offset <= info.size {
                             return interp_ok(false);
diff --git a/src/tools/miri/src/alloc_addresses/mod.rs b/src/tools/miri/src/alloc_addresses/mod.rs
index 10339928ac2..334503d2994 100644
--- a/src/tools/miri/src/alloc_addresses/mod.rs
+++ b/src/tools/miri/src/alloc_addresses/mod.rs
@@ -116,14 +116,6 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let this = self.eval_context_ref();
         let info = this.get_alloc_info(alloc_id);
 
-        // Miri's address assignment leaks state across thread boundaries, which is incompatible
-        // with GenMC execution. So we instead let GenMC assign addresses to allocations.
-        if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
-            let addr = genmc_ctx.handle_alloc(&this.machine, info.size, info.align, memory_kind)?;
-            return interp_ok(addr);
-        }
-
-        let mut rng = this.machine.rng.borrow_mut();
         // This is either called immediately after allocation (and then cached), or when
         // adjusting `tcx` pointers (which never get freed). So assert that we are looking
         // at a live allocation. This also ensures that we never re-assign an address to an
@@ -131,6 +123,19 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // information was removed.
         assert!(!matches!(info.kind, AllocKind::Dead));
 
+        // TypeId allocations always have a "base address" of 0 (i.e., the relative offset is the
+        // hash fragment and therefore equal to the actual integer value).
+        if matches!(info.kind, AllocKind::TypeId) {
+            return interp_ok(0);
+        }
+
+        // Miri's address assignment leaks state across thread boundaries, which is incompatible
+        // with GenMC execution. So we instead let GenMC assign addresses to allocations.
+        if let Some(genmc_ctx) = this.machine.data_race.as_genmc_ref() {
+            let addr = genmc_ctx.handle_alloc(&this.machine, info.size, info.align, memory_kind)?;
+            return interp_ok(addr);
+        }
+
         // This allocation does not have a base address yet, pick or reuse one.
         if !this.machine.native_lib.is_empty() {
             // In native lib mode, we use the "real" address of the bytes for this allocation.
@@ -157,7 +162,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                         this.get_alloc_bytes_unchecked_raw(alloc_id)?
                     }
                 }
-                AllocKind::Function | AllocKind::Virtual => {
+                AllocKind::Function | AllocKind::VTable => {
                     // Allocate some dummy memory to get a unique address for this function/vtable.
                     let alloc_bytes = MiriAllocBytes::from_bytes(
                         &[0u8; 1],
@@ -169,12 +174,13 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     std::mem::forget(alloc_bytes);
                     ptr
                 }
-                AllocKind::Dead => unreachable!(),
+                AllocKind::TypeId | AllocKind::Dead => unreachable!(),
             };
             // We don't have to expose this pointer yet, we do that in `prepare_for_native_call`.
             return interp_ok(base_ptr.addr().to_u64());
         }
         // We are not in native lib mode, so we control the addresses ourselves.
+        let mut rng = this.machine.rng.borrow_mut();
         if let Some((reuse_addr, clock)) = global_state.reuse.take_addr(
             &mut *rng,
             info.size,
@@ -295,21 +301,25 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // Store address in cache.
                 global_state.base_addr.try_insert(alloc_id, base_addr).unwrap();
 
-                // Also maintain the opposite mapping in `int_to_ptr_map`, ensuring we keep it sorted.
-                // We have a fast-path for the common case that this address is bigger than all previous ones.
-                let pos = if global_state
-                    .int_to_ptr_map
-                    .last()
-                    .is_some_and(|(last_addr, _)| *last_addr < base_addr)
-                {
-                    global_state.int_to_ptr_map.len()
-                } else {
-                    global_state
+                // Also maintain the opposite mapping in `int_to_ptr_map`, ensuring we keep it
+                // sorted. We have a fast-path for the common case that this address is bigger than
+                // all previous ones. We skip this for allocations at address 0; those can't be
+                // real, they must be TypeId "fake allocations".
+                if base_addr != 0 {
+                    let pos = if global_state
                         .int_to_ptr_map
-                        .binary_search_by_key(&base_addr, |(addr, _)| *addr)
-                        .unwrap_err()
-                };
-                global_state.int_to_ptr_map.insert(pos, (base_addr, alloc_id));
+                        .last()
+                        .is_some_and(|(last_addr, _)| *last_addr < base_addr)
+                    {
+                        global_state.int_to_ptr_map.len()
+                    } else {
+                        global_state
+                            .int_to_ptr_map
+                            .binary_search_by_key(&base_addr, |(addr, _)| *addr)
+                            .unwrap_err()
+                    };
+                    global_state.int_to_ptr_map.insert(pos, (base_addr, alloc_id));
+                }
 
                 interp_ok(base_addr)
             }
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 e834fdffdd1..2977efaae04 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
@@ -650,7 +650,7 @@ trait EvalContextPrivExt<'tcx, 'ecx>: crate::MiriInterpCxExt<'tcx> {
                         dcx.log_protector();
                     }
                 },
-                AllocKind::Function | AllocKind::Virtual | AllocKind::Dead => {
+                AllocKind::Function | AllocKind::VTable | AllocKind::TypeId | AllocKind::Dead => {
                     // No stacked borrows on these allocations.
                 }
             }
@@ -1021,7 +1021,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 trace!("Stacked Borrows tag {tag:?} exposed in {alloc_id:?}");
                 alloc_extra.borrow_tracker_sb().borrow_mut().exposed_tags.insert(tag);
             }
-            AllocKind::Function | AllocKind::Virtual | AllocKind::Dead => {
+            AllocKind::Function | AllocKind::VTable | AllocKind::TypeId | AllocKind::Dead => {
                 // No stacked borrows on these allocations.
             }
         }
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 aa92f8a8c30..ad2a67160f4 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -673,7 +673,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 trace!("Tree Borrows tag {tag:?} exposed in {alloc_id:?}");
                 alloc_extra.borrow_tracker_tb().borrow_mut().expose_tag(tag);
             }
-            AllocKind::Function | AllocKind::Virtual | AllocKind::Dead => {
+            AllocKind::Function | AllocKind::VTable | AllocKind::TypeId | AllocKind::Dead => {
                 // No tree borrows on these allocations.
             }
         }
-- 
cgit 1.4.1-3-g733a5


From 7bf2dd6295d95ec5a92cc23b70a32a36035bc995 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 20 Jul 2025 22:27:43 +0200
Subject: update lockfile

---
 Cargo.lock | 159 +++++++++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 108 insertions(+), 51 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7d2fca8bb3f..43f8f30979f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -384,7 +384,7 @@ dependencies = [
 name = "cargo-miri"
 version = "0.1.0"
 dependencies = [
- "cargo_metadata 0.19.2",
+ "cargo_metadata 0.21.0",
  "directories",
  "rustc-build-sysroot",
  "rustc_tools_util 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -402,6 +402,31 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "cargo-platform"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84982c6c0ae343635a3a4ee6dedef965513735c8b183caa7289fa6e27399ebd4"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo-util-schemas"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dc1a6f7b5651af85774ae5a34b4e8be397d9cf4bc063b7e6dbd99a841837830"
+dependencies = [
+ "semver",
+ "serde",
+ "serde-untagged",
+ "serde-value",
+ "thiserror 2.0.12",
+ "toml 0.8.23",
+ "unicode-xid",
+ "url",
+]
+
 [[package]]
 name = "cargo_metadata"
 version = "0.18.1"
@@ -409,7 +434,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2d886547e41f740c616ae73108f6eb70afe6d940c7bc697cb30f13daec073037"
 dependencies = [
  "camino",
- "cargo-platform",
+ "cargo-platform 0.1.9",
  "semver",
  "serde",
  "serde_json",
@@ -423,7 +448,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
 dependencies = [
  "camino",
- "cargo-platform",
+ "cargo-platform 0.1.9",
+ "semver",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.12",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cfca2aaa699835ba88faf58a06342a314a950d2b9686165e038286c30316868"
+dependencies = [
+ "camino",
+ "cargo-platform 0.2.0",
+ "cargo-util-schemas",
  "semver",
  "serde",
  "serde_json",
@@ -572,7 +612,7 @@ dependencies = [
  "tempfile",
  "termize",
  "toml 0.7.8",
- "ui_test 0.30.2",
+ "ui_test",
  "walkdir",
 ]
 
@@ -714,6 +754,15 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "colored"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fde0e0ec90c9dfb3b4b1a0891a7dcd0e2bffde2f7efed5fe7c9bb00e5bfb915e"
+dependencies = [
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "comma"
 version = "1.0.0"
@@ -727,7 +776,7 @@ dependencies = [
  "anstyle-svg",
  "build_helper",
  "camino",
- "colored",
+ "colored 2.2.0",
  "diff",
  "getopts",
  "glob",
@@ -1154,6 +1203,16 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
+[[package]]
+name = "erased-serde"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e004d887f51fcb9fef17317a2f3525c887d8aa3f4f50fed920816a688284a5b7"
+dependencies = [
+ "serde",
+ "typeid",
+]
+
 [[package]]
 name = "errno"
 version = "0.3.13"
@@ -1842,17 +1901,16 @@ dependencies = [
 
 [[package]]
 name = "ipc-channel"
-version = "0.19.0"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8251fb7bcd9ccd3725ed8deae9fe7db8e586495c9eb5b0c52e6233e5e75ea"
+checksum = "5b1c98b70019c830a1fc39cecfe1f60ff99c4122f0a189697c810c90ec545c14"
 dependencies = [
  "bincode",
  "crossbeam-channel",
  "fnv",
- "lazy_static",
  "libc",
  "mio",
- "rand 0.8.5",
+ "rand 0.9.1",
  "serde",
  "tempfile",
  "uuid",
@@ -2251,7 +2309,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
 dependencies = [
  "libc",
- "log",
  "wasi 0.11.1+wasi-snapshot-preview1",
  "windows-sys 0.59.0",
 ]
@@ -2274,7 +2331,7 @@ dependencies = [
  "capstone",
  "chrono",
  "chrono-tz",
- "colored",
+ "colored 3.0.0",
  "directories",
  "getrandom 0.3.3",
  "ipc-channel",
@@ -2291,7 +2348,7 @@ dependencies = [
  "smallvec",
  "tempfile",
  "tikv-jemalloc-sys",
- "ui_test 0.29.2",
+ "ui_test",
 ]
 
 [[package]]
@@ -2571,6 +2628,15 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
+[[package]]
+name = "ordered-float"
+version = "2.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "overload"
 version = "0.1.1"
@@ -4847,6 +4913,27 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-untagged"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "299d9c19d7d466db4ab10addd5703e4c615dec2a5a16dbbafe191045e87ee66e"
+dependencies = [
+ "erased-serde",
+ "serde",
+ "typeid",
+]
+
+[[package]]
+name = "serde-value"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3a1a3341211875ef120e117ea7fd5228530ae7e7036a779fdc9117be6b3282c"
+dependencies = [
+ "ordered-float",
+ "serde",
+]
+
 [[package]]
 name = "serde_derive"
 version = "1.0.219"
@@ -4944,16 +5031,6 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "spanned"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86af297923fbcfd107c20a189a6e9c872160df71a7190ae4a7a6c5dce4b2feb6"
-dependencies = [
- "bstr",
- "color-eyre",
-]
-
 [[package]]
 name = "spanned"
 version = "0.4.1"
@@ -5531,6 +5608,12 @@ dependencies = [
  "rustc-hash 2.1.1",
 ]
 
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+
 [[package]]
 name = "typenum"
 version = "1.18.0"
@@ -5552,32 +5635,6 @@ version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
 
-[[package]]
-name = "ui_test"
-version = "0.29.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1211b1111c752c73b33073d2958072be08825fd97c9ab4d83444da361a06634b"
-dependencies = [
- "annotate-snippets 0.11.5",
- "anyhow",
- "bstr",
- "cargo-platform",
- "cargo_metadata 0.18.1",
- "color-eyre",
- "colored",
- "comma",
- "crossbeam-channel",
- "indicatif",
- "levenshtein",
- "prettydiff",
- "regex",
- "rustc_version",
- "rustfix",
- "serde",
- "serde_json",
- "spanned 0.3.0",
-]
-
 [[package]]
 name = "ui_test"
 version = "0.30.2"
@@ -5587,10 +5644,10 @@ dependencies = [
  "annotate-snippets 0.11.5",
  "anyhow",
  "bstr",
- "cargo-platform",
+ "cargo-platform 0.1.9",
  "cargo_metadata 0.18.1",
  "color-eyre",
- "colored",
+ "colored 2.2.0",
  "comma",
  "crossbeam-channel",
  "indicatif",
@@ -5601,7 +5658,7 @@ dependencies = [
  "rustfix",
  "serde",
  "serde_json",
- "spanned 0.4.1",
+ "spanned",
 ]
 
 [[package]]
-- 
cgit 1.4.1-3-g733a5


From d2be1c8d009997584112954b7ee806e07a322eda Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 20 Jul 2025 22:35:43 +0200
Subject: Option::as_slice: fix comment

---
 library/core/src/option.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 8036c59e893..0e481519f76 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -842,7 +842,7 @@ impl<T> Option<T> {
         // just needs to be aligned, which it is because `&self` is aligned and
         // the offset used is a multiple of alignment.
         //
-        // In the new version, the intrinsic always returns a pointer to an
+        // Here we assume that `offset_of!` always returns an offset to an
         // in-bounds and correctly aligned position for a `T` (even if in the
         // `None` case it's just padding).
         unsafe {
-- 
cgit 1.4.1-3-g733a5


From e68f5fe9edaa75e534572da2a3b7832e7d5cfc9b Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 11 Jul 2025 20:30:18 +0200
Subject: Implement `check::RustAnalyzer` using the `tool_check_step` macro

---
 src/bootstrap/src/core/build_steps/check.rs | 90 ++++++++---------------------
 src/bootstrap/src/core/builder/tests.rs     |  4 +-
 2 files changed, 25 insertions(+), 69 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index 2a19e17019e..a7f2c7b1b60 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -370,69 +370,6 @@ impl Step for CodegenBackend {
     }
 }
 
-/// Checks Rust analyzer that links to .rmetas from a checked rustc.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RustAnalyzer {
-    pub build_compiler: Compiler,
-    pub target: TargetSelection,
-}
-
-impl Step for RustAnalyzer {
-    type Output = ();
-    const ONLY_HOSTS: bool = true;
-    const DEFAULT: bool = true;
-
-    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        let builder = run.builder;
-        run.path("src/tools/rust-analyzer").default_condition(
-            builder
-                .config
-                .tools
-                .as_ref()
-                .is_none_or(|tools| tools.iter().any(|tool| tool == "rust-analyzer")),
-        )
-    }
-
-    fn make_run(run: RunConfig<'_>) {
-        let build_compiler = prepare_compiler_for_check(run.builder, run.target, Mode::ToolRustc);
-        run.builder.ensure(RustAnalyzer { build_compiler, target: run.target });
-    }
-
-    fn run(self, builder: &Builder<'_>) {
-        let build_compiler = self.build_compiler;
-        let target = self.target;
-
-        let mut cargo = prepare_tool_cargo(
-            builder,
-            build_compiler,
-            Mode::ToolRustc,
-            target,
-            builder.kind,
-            "src/tools/rust-analyzer",
-            SourceType::InTree,
-            &["in-rust-tree".to_owned()],
-        );
-
-        cargo.allow_features(crate::core::build_steps::tool::RustAnalyzer::ALLOW_FEATURES);
-
-        cargo.arg("--bins");
-        cargo.arg("--tests");
-        cargo.arg("--benches");
-
-        // Cargo's output path in a given stage, compiled by a particular
-        // compiler for the specified target.
-        let stamp = BuildStamp::new(&builder.cargo_out(build_compiler, Mode::ToolRustc, target))
-            .with_prefix("rust-analyzer-check");
-
-        let _guard = builder.msg_check("rust-analyzer artifacts", target, None);
-        run_cargo(builder, cargo, builder.config.free_args.clone(), &stamp, vec![], true, false);
-    }
-
-    fn metadata(&self) -> Option<StepMetadata> {
-        Some(StepMetadata::check("rust-analyzer", self.target).built_by(self.build_compiler))
-    }
-}
-
 macro_rules! tool_check_step {
     (
         $name:ident {
@@ -441,7 +378,10 @@ macro_rules! tool_check_step {
             $(, alt_path: $alt_path:literal )*
             // Closure that returns `Mode` based on the passed `&Builder<'_>`
             , mode: $mode:expr
+            // Subset of nightly features that are allowed to be used when checking
             $(, allow_features: $allow_features:expr )?
+            // Features that should be enabled when checking
+            $(, enable_features: [$($enable_features:expr),*] )?
             $(, default: $default:literal )?
             $( , )?
         }
@@ -485,8 +425,9 @@ macro_rules! tool_check_step {
                     $( _value = $allow_features; )?
                     _value
                 };
+                let extra_features: &[&str] = &[$($($enable_features),*)?];
                 let mode = $mode(builder);
-                run_tool_check_step(builder, build_compiler, target, $path, mode, allow_features);
+                run_tool_check_step(builder, build_compiler, target, $path, mode, allow_features, extra_features);
             }
 
             fn metadata(&self) -> Option<StepMetadata> {
@@ -504,9 +445,11 @@ fn run_tool_check_step(
     path: &str,
     mode: Mode,
     allow_features: &str,
+    extra_features: &[&str],
 ) {
     let display_name = path.rsplit('/').next().unwrap();
 
+    let extra_features = extra_features.iter().map(|f| f.to_string()).collect::<Vec<String>>();
     let mut cargo = prepare_tool_cargo(
         builder,
         build_compiler,
@@ -519,12 +462,19 @@ fn run_tool_check_step(
         // steps should probably be marked non-default so that the default
         // checks aren't affected by toolstate being broken.
         SourceType::InTree,
-        &[],
+        &extra_features,
     );
     cargo.allow_features(allow_features);
 
-    // FIXME: check bootstrap doesn't currently work with --all-targets
-    cargo.arg("--all-targets");
+    // FIXME: check bootstrap doesn't currently work when multiple targets are checked
+    // FIXME: rust-analyzer does not work with --all-targets
+    if display_name == "rust-analyzer" {
+        cargo.arg("--bins");
+        cargo.arg("--tests");
+        cargo.arg("--benches");
+    } else {
+        cargo.arg("--all-targets");
+    }
 
     let stamp = BuildStamp::new(&builder.cargo_out(build_compiler, mode, target))
         .with_prefix(&format!("{display_name}-check"));
@@ -553,6 +503,12 @@ tool_check_step!(Clippy { path: "src/tools/clippy", mode: |_builder| Mode::ToolR
 tool_check_step!(Miri { path: "src/tools/miri", mode: |_builder| Mode::ToolRustc });
 tool_check_step!(CargoMiri { path: "src/tools/miri/cargo-miri", mode: |_builder| Mode::ToolRustc });
 tool_check_step!(Rustfmt { path: "src/tools/rustfmt", mode: |_builder| Mode::ToolRustc });
+tool_check_step!(RustAnalyzer {
+    path: "src/tools/rust-analyzer",
+    mode: |_builder| Mode::ToolRustc,
+    allow_features: tool::RustAnalyzer::ALLOW_FEATURES,
+    enable_features: ["in-rust-tree"],
+});
 tool_check_step!(MiroptTestTools {
     path: "src/tools/miropt-test-tools",
     mode: |_builder| Mode::ToolBootstrap
diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index d27a2e65ed1..d3184e55506 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1377,7 +1377,7 @@ mod snapshot {
         [check] rustc 1 <host> -> Miri 2 <target1>
         [check] rustc 1 <host> -> CargoMiri 2 <target1>
         [check] rustc 1 <host> -> Rustfmt 2 <target1>
-        [check] rustc 1 <host> -> rust-analyzer 2 <target1>
+        [check] rustc 1 <host> -> RustAnalyzer 2 <target1>
         [check] rustc 1 <host> -> TestFloatParse 2 <target1>
         [check] rustc 1 <host> -> std 1 <target1>
         ");
@@ -1569,7 +1569,7 @@ mod snapshot {
                 .render_steps(), @r"
         [build] llvm <host>
         [check] rustc 0 <host> -> rustc 1 <host>
-        [check] rustc 0 <host> -> rust-analyzer 1 <host>
+        [check] rustc 0 <host> -> RustAnalyzer 1 <host>
         ");
     }
 
-- 
cgit 1.4.1-3-g733a5


From 192efbbd209eae7006b05205d507fb8c19802a60 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 16 Jul 2025 16:25:29 +0200
Subject: clippy: make tests work in stage 1

---
 src/bootstrap/src/core/build_steps/test.rs         | 44 ++++++++++------------
 src/tools/clippy/clippy_test_deps/Cargo.lock       |  1 +
 src/tools/clippy/clippy_test_deps/Cargo.toml       |  1 +
 src/tools/clippy/tests/compile-test.rs             | 29 +++++++++++++-
 .../clippy/tests/ui/auxiliary/proc_macro_derive.rs |  2 +-
 src/tools/clippy/tests/ui/cast_alignment.rs        |  3 --
 src/tools/clippy/tests/ui/cast_alignment.stderr    |  8 ++--
 src/tools/clippy/tests/ui/iter_over_hash_type.rs   | 11 ++++--
 .../clippy/tests/ui/iter_over_hash_type.stderr     | 26 ++++++-------
 .../clippy/tests/ui/strlen_on_c_strings.fixed      |  2 -
 src/tools/clippy/tests/ui/strlen_on_c_strings.rs   |  2 -
 .../clippy/tests/ui/strlen_on_c_strings.stderr     | 14 +++----
 src/tools/clippy/tests/ui/useless_attribute.fixed  |  2 +-
 src/tools/clippy/tests/ui/useless_attribute.rs     |  2 +-
 14 files changed, 84 insertions(+), 63 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 9e7ea5c115f..cc2c88f512c 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -739,7 +739,6 @@ impl Step for CompiletestTest {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Clippy {
-    stage: u32,
     host: TargetSelection,
 }
 
@@ -753,33 +752,23 @@ impl Step for Clippy {
     }
 
     fn make_run(run: RunConfig<'_>) {
-        // If stage is explicitly set or not lower than 2, keep it. Otherwise, make sure it's at least 2
-        // as tests for this step don't work with a lower stage.
-        let stage = if run.builder.config.is_explicit_stage() || run.builder.top_stage >= 2 {
-            run.builder.top_stage
-        } else {
-            2
-        };
-
-        run.builder.ensure(Clippy { stage, host: run.target });
+        run.builder.ensure(Clippy { host: run.target });
     }
 
     /// Runs `cargo test` for clippy.
     fn run(self, builder: &Builder<'_>) {
-        let stage = self.stage;
+        let stage = builder.top_stage;
         let host = self.host;
-        let compiler = builder.compiler(stage, host);
-
-        if stage < 2 {
-            eprintln!("WARNING: clippy tests on stage {stage} may not behave well.");
-            eprintln!("HELP: consider using stage 2");
-        }
+        // We need to carefully distinguish the compiler that builds clippy, and the compiler
+        // that is linked into the clippy being tested. `target_compiler` is the latter,
+        // and it must also be used by clippy's test runner to build tests and their dependencies.
+        let target_compiler = builder.compiler(stage, host);
 
-        let tool_result = builder.ensure(tool::Clippy { compiler, target: self.host });
-        let compiler = tool_result.build_compiler;
+        let tool_result = builder.ensure(tool::Clippy { compiler: target_compiler, target: host });
+        let tool_compiler = tool_result.build_compiler;
         let mut cargo = tool::prepare_tool_cargo(
             builder,
-            compiler,
+            tool_compiler,
             Mode::ToolRustc,
             host,
             Kind::Test,
@@ -788,11 +777,17 @@ impl Step for Clippy {
             &[],
         );
 
-        cargo.env("RUSTC_TEST_SUITE", builder.rustc(compiler));
-        cargo.env("RUSTC_LIB_PATH", builder.rustc_libdir(compiler));
-        let host_libs = builder.stage_out(compiler, Mode::ToolRustc).join(builder.cargo_dir());
+        cargo.env("RUSTC_TEST_SUITE", builder.rustc(tool_compiler));
+        cargo.env("RUSTC_LIB_PATH", builder.rustc_libdir(tool_compiler));
+        let host_libs = builder.stage_out(tool_compiler, Mode::ToolRustc).join(builder.cargo_dir());
         cargo.env("HOST_LIBS", host_libs);
 
+        // Build the standard library that the tests can use.
+        builder.std(target_compiler, host);
+        cargo.env("TEST_SYSROOT", builder.sysroot(target_compiler));
+        cargo.env("TEST_RUSTC", builder.rustc(target_compiler));
+        cargo.env("TEST_RUSTC_LIB", builder.rustc_libdir(target_compiler));
+
         // Collect paths of tests to run
         'partially_test: {
             let paths = &builder.config.paths[..];
@@ -813,7 +808,8 @@ impl Step for Clippy {
         cargo.add_rustc_lib_path(builder);
         let cargo = prepare_cargo_test(cargo, &[], &[], host, builder);
 
-        let _guard = builder.msg_sysroot_tool(Kind::Test, compiler.stage, "clippy", host, host);
+        let _guard =
+            builder.msg_sysroot_tool(Kind::Test, tool_compiler.stage, "clippy", host, host);
 
         // Clippy reports errors if it blessed the outputs
         if cargo.allow_failure().run(builder) {
diff --git a/src/tools/clippy/clippy_test_deps/Cargo.lock b/src/tools/clippy/clippy_test_deps/Cargo.lock
index a591dae3a1a..5be404f24e6 100644
--- a/src/tools/clippy/clippy_test_deps/Cargo.lock
+++ b/src/tools/clippy/clippy_test_deps/Cargo.lock
@@ -72,6 +72,7 @@ dependencies = [
  "futures",
  "if_chain",
  "itertools",
+ "libc",
  "parking_lot",
  "quote",
  "regex",
diff --git a/src/tools/clippy/clippy_test_deps/Cargo.toml b/src/tools/clippy/clippy_test_deps/Cargo.toml
index a23ffcaf2f9..fcedc5d4843 100644
--- a/src/tools/clippy/clippy_test_deps/Cargo.toml
+++ b/src/tools/clippy/clippy_test_deps/Cargo.toml
@@ -6,6 +6,7 @@ edition = "2021"
 # Add dependencies here to make them available in ui tests.
 
 [dependencies]
+libc = "0.2"
 regex = "1.5.5"
 serde = { version = "1.0.145", features = ["derive"] }
 if_chain = "1.0"
diff --git a/src/tools/clippy/tests/compile-test.rs b/src/tools/clippy/tests/compile-test.rs
index 57d623b2cfc..83f91ccaa7b 100644
--- a/src/tools/clippy/tests/compile-test.rs
+++ b/src/tools/clippy/tests/compile-test.rs
@@ -151,7 +151,31 @@ impl TestContext {
         defaults.set_custom(
             "dependencies",
             DependencyBuilder {
-                program: CommandBuilder::cargo(),
+                program: {
+                    let mut p = CommandBuilder::cargo();
+                    // If we run in bootstrap, we need to use the right compiler for building the
+                    // tests -- not the compiler that built clippy, but the compiler that got linked
+                    // into clippy. Just invoking TEST_RUSTC does not work because LD_LIBRARY_PATH
+                    // is set in a way that makes it pick the wrong sysroot. Sadly due to
+                    // <https://github.com/rust-lang/cargo/issues/4423> we cannot use RUSTFLAGS to
+                    // set `--sysroot`, so we need to use bootstrap's rustc wrapper. That wrapper
+                    // however has some staging logic that is hurting us here, so to work around
+                    // that we set both the "real" and "staging" rustc to TEST_RUSTC, including the
+                    // associated library paths.
+                    if let Some(rustc) = option_env!("TEST_RUSTC") {
+                        let libdir = option_env!("TEST_RUSTC_LIB").unwrap();
+                        let sysroot = option_env!("TEST_SYSROOT").unwrap();
+                        p.envs.push(("RUSTC_REAL".into(), Some(rustc.into())));
+                        p.envs.push(("RUSTC_REAL_LIBDIR".into(), Some(libdir.into())));
+                        p.envs.push(("RUSTC_SNAPSHOT".into(), Some(rustc.into())));
+                        p.envs.push(("RUSTC_SNAPSHOT_LIBDIR".into(), Some(libdir.into())));
+                        p.envs.push((
+                            "RUSTC_SYSROOT".into(),
+                            Some(sysroot.into()),
+                        ));
+                    }
+                    p
+                },
                 crate_manifest_path: Path::new("clippy_test_deps").join("Cargo.toml"),
                 build_std: None,
                 bless_lockfile: self.args.bless,
@@ -192,6 +216,9 @@ impl TestContext {
             let dep = format!("-Ldependency={}", Path::new(host_libs).join("deps").display());
             config.program.args.push(dep.into());
         }
+        if let Some(sysroot) = option_env!("TEST_SYSROOT") {
+            config.program.args.push(format!("--sysroot={sysroot}").into());
+        }
 
         config.program.program = profile_path.join(if cfg!(windows) {
             "clippy-driver.exe"
diff --git a/src/tools/clippy/tests/ui/auxiliary/proc_macro_derive.rs b/src/tools/clippy/tests/ui/auxiliary/proc_macro_derive.rs
index 5992d15935d..54650922871 100644
--- a/src/tools/clippy/tests/ui/auxiliary/proc_macro_derive.rs
+++ b/src/tools/clippy/tests/ui/auxiliary/proc_macro_derive.rs
@@ -16,7 +16,7 @@ pub fn derive(_: TokenStream) -> TokenStream {
     let output = quote! {
         // Should not trigger `useless_attribute`
         #[allow(dead_code)]
-        extern crate rustc_middle;
+        extern crate core;
     };
     output
 }
diff --git a/src/tools/clippy/tests/ui/cast_alignment.rs b/src/tools/clippy/tests/ui/cast_alignment.rs
index 5773ffddb91..ef667f5598a 100644
--- a/src/tools/clippy/tests/ui/cast_alignment.rs
+++ b/src/tools/clippy/tests/ui/cast_alignment.rs
@@ -1,6 +1,5 @@
 //! Test casts for alignment issues
 
-#![feature(rustc_private)]
 #![feature(core_intrinsics)]
 #![warn(clippy::cast_ptr_alignment)]
 #![allow(
@@ -10,8 +9,6 @@
     clippy::borrow_as_ptr
 )]
 
-extern crate libc;
-
 fn main() {
     /* These should be warned against */
 
diff --git a/src/tools/clippy/tests/ui/cast_alignment.stderr b/src/tools/clippy/tests/ui/cast_alignment.stderr
index 6d9a81f0ecf..ee4c3e9a77e 100644
--- a/src/tools/clippy/tests/ui/cast_alignment.stderr
+++ b/src/tools/clippy/tests/ui/cast_alignment.stderr
@@ -1,5 +1,5 @@
 error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
-  --> tests/ui/cast_alignment.rs:19:5
+  --> tests/ui/cast_alignment.rs:16:5
    |
 LL |     (&1u8 as *const u8) as *const u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -8,19 +8,19 @@ LL |     (&1u8 as *const u8) as *const u16;
    = help: to override `-D warnings` add `#[allow(clippy::cast_ptr_alignment)]`
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> tests/ui/cast_alignment.rs:22:5
+  --> tests/ui/cast_alignment.rs:19:5
    |
 LL |     (&mut 1u8 as *mut u8) as *mut u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`) (1 < 2 bytes)
-  --> tests/ui/cast_alignment.rs:26:5
+  --> tests/ui/cast_alignment.rs:23:5
    |
 LL |     (&1u8 as *const u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> tests/ui/cast_alignment.rs:29:5
+  --> tests/ui/cast_alignment.rs:26:5
    |
 LL |     (&mut 1u8 as *mut u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/iter_over_hash_type.rs b/src/tools/clippy/tests/ui/iter_over_hash_type.rs
index 914cc9df0de..9a3e7033cd8 100644
--- a/src/tools/clippy/tests/ui/iter_over_hash_type.rs
+++ b/src/tools/clippy/tests/ui/iter_over_hash_type.rs
@@ -3,15 +3,18 @@
 #![warn(clippy::iter_over_hash_type)]
 use std::collections::{HashMap, HashSet};
 
-extern crate rustc_data_structures;
-
 extern crate proc_macros;
 
+// Ensure it also works via type aliases (this isn't really the Fx hasher but that does not matter).
+type FxBuildHasher = std::collections::hash_map::RandomState;
+type FxHashMap<K, V> = HashMap<K, V, FxBuildHasher>;
+type FxHashSet<K> = HashSet<K, FxBuildHasher>;
+
 fn main() {
     let mut hash_set = HashSet::<i32>::new();
     let mut hash_map = HashMap::<i32, i32>::new();
-    let mut fx_hash_map = rustc_data_structures::fx::FxHashMap::<i32, i32>::default();
-    let mut fx_hash_set = rustc_data_structures::fx::FxHashMap::<i32, i32>::default();
+    let mut fx_hash_map = FxHashMap::<i32, i32>::default();
+    let mut fx_hash_set = FxHashSet::<i32>::default();
     let vec = Vec::<i32>::new();
 
     // test hashset
diff --git a/src/tools/clippy/tests/ui/iter_over_hash_type.stderr b/src/tools/clippy/tests/ui/iter_over_hash_type.stderr
index 1bc6f4588d4..3356186547d 100644
--- a/src/tools/clippy/tests/ui/iter_over_hash_type.stderr
+++ b/src/tools/clippy/tests/ui/iter_over_hash_type.stderr
@@ -1,5 +1,5 @@
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:18:5
+  --> tests/ui/iter_over_hash_type.rs:21:5
    |
 LL | /     for x in &hash_set {
 LL | |
@@ -11,7 +11,7 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::iter_over_hash_type)]`
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:22:5
+  --> tests/ui/iter_over_hash_type.rs:25:5
    |
 LL | /     for x in hash_set.iter() {
 LL | |
@@ -20,7 +20,7 @@ LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:26:5
+  --> tests/ui/iter_over_hash_type.rs:29:5
    |
 LL | /     for x in hash_set.clone() {
 LL | |
@@ -29,7 +29,7 @@ LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:30:5
+  --> tests/ui/iter_over_hash_type.rs:33:5
    |
 LL | /     for x in hash_set.drain() {
 LL | |
@@ -38,7 +38,7 @@ LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:36:5
+  --> tests/ui/iter_over_hash_type.rs:39:5
    |
 LL | /     for (x, y) in &hash_map {
 LL | |
@@ -47,7 +47,7 @@ LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:40:5
+  --> tests/ui/iter_over_hash_type.rs:43:5
    |
 LL | /     for x in hash_map.keys() {
 LL | |
@@ -56,7 +56,7 @@ LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:44:5
+  --> tests/ui/iter_over_hash_type.rs:47:5
    |
 LL | /     for x in hash_map.values() {
 LL | |
@@ -65,7 +65,7 @@ LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:48:5
+  --> tests/ui/iter_over_hash_type.rs:51:5
    |
 LL | /     for x in hash_map.values_mut() {
 LL | |
@@ -74,7 +74,7 @@ LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:52:5
+  --> tests/ui/iter_over_hash_type.rs:55:5
    |
 LL | /     for x in hash_map.iter() {
 LL | |
@@ -83,7 +83,7 @@ LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:56:5
+  --> tests/ui/iter_over_hash_type.rs:59:5
    |
 LL | /     for x in hash_map.clone() {
 LL | |
@@ -92,7 +92,7 @@ LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:60:5
+  --> tests/ui/iter_over_hash_type.rs:63:5
    |
 LL | /     for x in hash_map.drain() {
 LL | |
@@ -101,7 +101,7 @@ LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:66:5
+  --> tests/ui/iter_over_hash_type.rs:69:5
    |
 LL | /     for x in fx_hash_set {
 LL | |
@@ -110,7 +110,7 @@ LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:70:5
+  --> tests/ui/iter_over_hash_type.rs:73:5
    |
 LL | /     for x in fx_hash_map {
 LL | |
diff --git a/src/tools/clippy/tests/ui/strlen_on_c_strings.fixed b/src/tools/clippy/tests/ui/strlen_on_c_strings.fixed
index 31ed1cf03a2..17c1b541f77 100644
--- a/src/tools/clippy/tests/ui/strlen_on_c_strings.fixed
+++ b/src/tools/clippy/tests/ui/strlen_on_c_strings.fixed
@@ -1,7 +1,5 @@
 #![warn(clippy::strlen_on_c_strings)]
 #![allow(dead_code, clippy::manual_c_str_literals)]
-#![feature(rustc_private)]
-extern crate libc;
 
 #[allow(unused)]
 use libc::strlen;
diff --git a/src/tools/clippy/tests/ui/strlen_on_c_strings.rs b/src/tools/clippy/tests/ui/strlen_on_c_strings.rs
index 0f3798c9fd8..c641422f5df 100644
--- a/src/tools/clippy/tests/ui/strlen_on_c_strings.rs
+++ b/src/tools/clippy/tests/ui/strlen_on_c_strings.rs
@@ -1,7 +1,5 @@
 #![warn(clippy::strlen_on_c_strings)]
 #![allow(dead_code, clippy::manual_c_str_literals)]
-#![feature(rustc_private)]
-extern crate libc;
 
 #[allow(unused)]
 use libc::strlen;
diff --git a/src/tools/clippy/tests/ui/strlen_on_c_strings.stderr b/src/tools/clippy/tests/ui/strlen_on_c_strings.stderr
index b8619fa2df3..84a93b99ee3 100644
--- a/src/tools/clippy/tests/ui/strlen_on_c_strings.stderr
+++ b/src/tools/clippy/tests/ui/strlen_on_c_strings.stderr
@@ -1,5 +1,5 @@
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:13:13
+  --> tests/ui/strlen_on_c_strings.rs:11:13
    |
 LL |     let _ = unsafe { libc::strlen(cstring.as_ptr()) };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cstring.as_bytes().len()`
@@ -8,37 +8,37 @@ LL |     let _ = unsafe { libc::strlen(cstring.as_ptr()) };
    = help: to override `-D warnings` add `#[allow(clippy::strlen_on_c_strings)]`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:18:13
+  --> tests/ui/strlen_on_c_strings.rs:16:13
    |
 LL |     let _ = unsafe { libc::strlen(cstr.as_ptr()) };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cstr.to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:21:13
+  --> tests/ui/strlen_on_c_strings.rs:19:13
    |
 LL |     let _ = unsafe { strlen(cstr.as_ptr()) };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cstr.to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:25:22
+  --> tests/ui/strlen_on_c_strings.rs:23:22
    |
 LL |     let _ = unsafe { strlen((*pcstr).as_ptr()) };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(*pcstr).to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:31:22
+  --> tests/ui/strlen_on_c_strings.rs:29:22
    |
 LL |     let _ = unsafe { strlen(unsafe_identity(cstr).as_ptr()) };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unsafe_identity(cstr).to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:33:13
+  --> tests/ui/strlen_on_c_strings.rs:31:13
    |
 LL |     let _ = unsafe { strlen(unsafe { unsafe_identity(cstr) }.as_ptr()) };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unsafe { unsafe_identity(cstr) }.to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:37:22
+  --> tests/ui/strlen_on_c_strings.rs:35:22
    |
 LL |     let _ = unsafe { strlen(f(cstr).as_ptr()) };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `f(cstr).to_bytes().len()`
diff --git a/src/tools/clippy/tests/ui/useless_attribute.fixed b/src/tools/clippy/tests/ui/useless_attribute.fixed
index a96c8f46f55..930bc1eaecf 100644
--- a/src/tools/clippy/tests/ui/useless_attribute.fixed
+++ b/src/tools/clippy/tests/ui/useless_attribute.fixed
@@ -13,7 +13,7 @@
 #[allow(unused_imports)]
 #[allow(unused_extern_crates)]
 #[macro_use]
-extern crate rustc_middle;
+extern crate regex as regex_crate;
 
 #[macro_use]
 extern crate proc_macro_derive;
diff --git a/src/tools/clippy/tests/ui/useless_attribute.rs b/src/tools/clippy/tests/ui/useless_attribute.rs
index b26410134bb..50fafd478e5 100644
--- a/src/tools/clippy/tests/ui/useless_attribute.rs
+++ b/src/tools/clippy/tests/ui/useless_attribute.rs
@@ -13,7 +13,7 @@
 #[allow(unused_imports)]
 #[allow(unused_extern_crates)]
 #[macro_use]
-extern crate rustc_middle;
+extern crate regex as regex_crate;
 
 #[macro_use]
 extern crate proc_macro_derive;
-- 
cgit 1.4.1-3-g733a5


From a546a7cb255da0c4ea4fbfa918d786890bde928e Mon Sep 17 00:00:00 2001
From: Jens Reidel <adrian@travitia.xyz>
Date: Mon, 21 Jul 2025 02:01:42 +0200
Subject: Fix run-make tests on musl hosts

On musl hosts, we already set -Ctarget-feature=-crt-static and
IS_MUSL_HOST=1 in compiletest. However, in order for the run-make tests
to compile fine on musl hosts, we need to propagate this flag in our
rustc invocations to ensure we can generate cdylibs.

Signed-off-by: Jens Reidel <adrian@travitia.xyz>
---
 src/tools/run-make-support/src/external_deps/rustc.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/tools/run-make-support/src/external_deps/rustc.rs b/src/tools/run-make-support/src/external_deps/rustc.rs
index 1ea549ca7ea..08ba1388dc1 100644
--- a/src/tools/run-make-support/src/external_deps/rustc.rs
+++ b/src/tools/run-make-support/src/external_deps/rustc.rs
@@ -52,13 +52,20 @@ impl Rustc {
     // `rustc` invocation constructor methods
 
     /// Construct a new `rustc` invocation. This will automatically set the library
-    /// search path as `-L cwd()` and also the compilation target.
+    /// search path as `-L cwd()`, configure the compilation target and enable
+    /// dynamic linkage by default on musl hosts.
     /// Use [`bare_rustc`] to avoid this.
     #[track_caller]
     pub fn new() -> Self {
         let mut cmd = setup_common();
         cmd.arg("-L").arg(cwd());
 
+        // FIXME: On musl hosts, we currently default to static linkage, while
+        // for running run-make tests, we rely on dynamic linkage by default
+        if std::env::var("IS_MUSL_HOST").is_ok_and(|i| i == "1") {
+            cmd.arg("-Ctarget-feature=-crt-static");
+        }
+
         // Automatically default to cross-compilation
         Self { cmd, target: Some(target()) }
     }
-- 
cgit 1.4.1-3-g733a5


From 897d007f8f2d4018fba5f2884cb1b45846d8a371 Mon Sep 17 00:00:00 2001
From: The rustc-josh-sync Cronjob Bot <github-actions@github.com>
Date: Mon, 21 Jul 2025 04:17:44 +0000
Subject: Prepare for merging from rust-lang/rust

This updates the rust-version file to 460259d14de0274b97b8801e08cb2fe5f16fdac5.
---
 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 3f10132b684..f6b7efe51a1 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-fd2eb391d032181459773f3498c17b198513e0d0
+460259d14de0274b97b8801e08cb2fe5f16fdac5
-- 
cgit 1.4.1-3-g733a5


From 750c1e9c39633de1242acf086ef1c053961219b2 Mon Sep 17 00:00:00 2001
From: Laurențiu Nicola <lnicola@dend.ro>
Date: Mon, 21 Jul 2025 09:17:54 +0300
Subject: Preparing for merge from rust-lang/rust

---
 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 57ff326ce5a..c2b1c151b83 100644
--- a/src/tools/rust-analyzer/rust-version
+++ b/src/tools/rust-analyzer/rust-version
@@ -1 +1 @@
-a9fb6103b05c6ad6eee6bed4c0bb5a2e8e1024c6
+e05ab47e6c418fb2b9faa2eae9a7e70c65c98eaa
-- 
cgit 1.4.1-3-g733a5


From 1482809fc16f11ecedb92e688922cf52a2441ee0 Mon Sep 17 00:00:00 2001
From: Laurențiu Nicola <lnicola@dend.ro>
Date: Mon, 21 Jul 2025 09:19:24 +0300
Subject: Bump rustc crates

---
 src/tools/rust-analyzer/Cargo.lock | 40 ++++++++++++++++++++++----------------
 src/tools/rust-analyzer/Cargo.toml | 10 +++++-----
 2 files changed, 28 insertions(+), 22 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index e55cd80943d..f3adc4006ac 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1505,7 +1505,7 @@ dependencies = [
  "edition",
  "expect-test",
  "ra-ap-rustc_lexer",
- "rustc-literal-escaper",
+ "rustc-literal-escaper 0.0.4",
  "stdx",
  "tracing",
 ]
@@ -1756,9 +1756,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_abi"
-version = "0.121.0"
+version = "0.122.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ee51482d1c9d3e538acda8cce723db8eea1a81540544bf362bf4c3d841b2329"
+checksum = "fb01e1fec578003c85481c1cad4ff8cd8195b07c2dc85ae3f716108507ae15d5"
 dependencies = [
  "bitflags 2.9.1",
  "ra-ap-rustc_hashes",
@@ -1768,18 +1768,18 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_hashes"
-version = "0.121.0"
+version = "0.122.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19c8f1e0c28e24e1b4c55dc08058c6c9829df2204497d4034259f491d348c204"
+checksum = "e0ec056e72a472ffef8761ce96ece6c626eb07368c09d0105b6df30d27d07673"
 dependencies = [
  "rustc-stable-hash",
 ]
 
 [[package]]
 name = "ra-ap-rustc_index"
-version = "0.121.0"
+version = "0.122.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f33f429cec6b92fa2c7243883279fb29dd233fdc3e94099aff32aa91aa87f50"
+checksum = "0fcdd1001db0295e59052e9f53aeda588bbe81e362534f4687d41bd44777b5a7"
 dependencies = [
  "ra-ap-rustc_index_macros",
  "smallvec",
@@ -1787,9 +1787,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_index_macros"
-version = "0.121.0"
+version = "0.122.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9b55910dbe1fe7ef34bdc1d1bcb41e99b377eb680ea58a1218d95d6b4152257"
+checksum = "728d64dd98e25530b32e3f7c7c1e844e52722b269360daa1cdeba9dff9727a26"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1798,9 +1798,9 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_lexer"
-version = "0.121.0"
+version = "0.122.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22944e31fb91e9b3e75bcbc91e37d958b8c0825a6160927f2856831d2ce83b36"
+checksum = "415f0821f512608d825b3215489a6a6a2c18ed9f0045953d514e7ec23d4b90ab"
 dependencies = [
  "memchr",
  "unicode-properties",
@@ -1809,19 +1809,19 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_parse_format"
-version = "0.121.0"
+version = "0.122.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81057891bc2063ad9e353f29462fbc47a0f5072560af34428ae9313aaa5e9d97"
+checksum = "18d2c4b48fa26e031b1cca0c8ca7433770f5e35e33da56da8636dae2cd45d4e1"
 dependencies = [
  "ra-ap-rustc_lexer",
- "rustc-literal-escaper",
+ "rustc-literal-escaper 0.0.5",
 ]
 
 [[package]]
 name = "ra-ap-rustc_pattern_analysis"
-version = "0.121.0"
+version = "0.122.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe21a3542980d56d2435e96c2720773cac1c63fd4db666417e414729da192eb3"
+checksum = "4657fcfdfe06e2a02ec8180d4e7c95aecf4811ba50367e363d1a2300b7623284"
 dependencies = [
  "ra-ap-rustc_index",
  "rustc-hash 2.1.1",
@@ -1972,6 +1972,12 @@ version = "0.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab03008eb631b703dd16978282ae36c73282e7922fe101a4bd072a40ecea7b8b"
 
+[[package]]
+name = "rustc-literal-escaper"
+version = "0.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4ee29da77c5a54f42697493cd4c9b9f31b74df666a6c04dfc4fde77abe0438b"
+
 [[package]]
 name = "rustc-stable-hash"
 version = "0.1.2"
@@ -2259,7 +2265,7 @@ dependencies = [
  "rayon",
  "rowan",
  "rustc-hash 2.1.1",
- "rustc-literal-escaper",
+ "rustc-literal-escaper 0.0.4",
  "rustc_apfloat",
  "smol_str",
  "stdx",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index 41fa06a76a7..b21ac158d8e 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -89,11 +89,11 @@ vfs-notify = { path = "./crates/vfs-notify", version = "0.0.0" }
 vfs = { path = "./crates/vfs", version = "0.0.0" }
 edition = { path = "./crates/edition", version = "0.0.0" }
 
-ra-ap-rustc_lexer = { version = "0.121", default-features = false }
-ra-ap-rustc_parse_format = { version = "0.121", default-features = false }
-ra-ap-rustc_index = { version = "0.121", default-features = false }
-ra-ap-rustc_abi = { version = "0.121", default-features = false }
-ra-ap-rustc_pattern_analysis = { version = "0.121", default-features = false }
+ra-ap-rustc_lexer = { version = "0.122", default-features = false }
+ra-ap-rustc_parse_format = { version = "0.122", default-features = false }
+ra-ap-rustc_index = { version = "0.122", default-features = false }
+ra-ap-rustc_abi = { version = "0.122", default-features = false }
+ra-ap-rustc_pattern_analysis = { version = "0.122", default-features = false }
 
 # local crates that aren't published to crates.io. These should not have versions.
 
-- 
cgit 1.4.1-3-g733a5


From f2633640d6e4dbc544b7c722bcda491a8f564285 Mon Sep 17 00:00:00 2001
From: Laurențiu Nicola <lnicola@dend.ro>
Date: Mon, 21 Jul 2025 09:27:37 +0300
Subject: Bump rustc-literal-escaper

---
 src/tools/rust-analyzer/Cargo.lock                         | 12 +++---------
 src/tools/rust-analyzer/Cargo.toml                         |  2 +-
 src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs |  4 ++--
 3 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index f3adc4006ac..711d0322464 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1505,7 +1505,7 @@ dependencies = [
  "edition",
  "expect-test",
  "ra-ap-rustc_lexer",
- "rustc-literal-escaper 0.0.4",
+ "rustc-literal-escaper",
  "stdx",
  "tracing",
 ]
@@ -1814,7 +1814,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "18d2c4b48fa26e031b1cca0c8ca7433770f5e35e33da56da8636dae2cd45d4e1"
 dependencies = [
  "ra-ap-rustc_lexer",
- "rustc-literal-escaper 0.0.5",
+ "rustc-literal-escaper",
 ]
 
 [[package]]
@@ -1966,12 +1966,6 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
-[[package]]
-name = "rustc-literal-escaper"
-version = "0.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab03008eb631b703dd16978282ae36c73282e7922fe101a4bd072a40ecea7b8b"
-
 [[package]]
 name = "rustc-literal-escaper"
 version = "0.0.5"
@@ -2265,7 +2259,7 @@ dependencies = [
  "rayon",
  "rowan",
  "rustc-hash 2.1.1",
- "rustc-literal-escaper 0.0.4",
+ "rustc-literal-escaper",
  "rustc_apfloat",
  "smol_str",
  "stdx",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index b21ac158d8e..1ca258abf4b 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -149,7 +149,7 @@ serde = { version = "1.0.219" }
 serde_derive = { version = "1.0.219" }
 serde_json = "1.0.140"
 rustc-hash = "2.1.1"
-rustc-literal-escaper = "0.0.4"
+rustc-literal-escaper = "0.0.5"
 smallvec = { version = "1.15.1", features = [
   "const_new",
   "union",
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs
index 4afdda78a0e..742c452616e 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs
@@ -309,8 +309,8 @@ impl ast::CString {
         let mut prev_end = 0;
         let mut has_error = None;
         let extend_unit = |buf: &mut Vec<u8>, unit: MixedUnit| match unit {
-            MixedUnit::Char(c) => buf.extend(c.encode_utf8(&mut [0; 4]).as_bytes()),
-            MixedUnit::HighByte(b) => buf.push(b),
+            MixedUnit::Char(c) => buf.extend(c.get().encode_utf8(&mut [0; 4]).as_bytes()),
+            MixedUnit::HighByte(b) => buf.push(b.get()),
         };
         unescape_c_str(text, |char_range, unescaped| match (unescaped, buf.capacity() == 0) {
             (Ok(u), false) => extend_unit(&mut buf, u),
-- 
cgit 1.4.1-3-g733a5


From 2050358679088b319cde837f9c6e9d9e58249503 Mon Sep 17 00:00:00 2001
From: Laurențiu Nicola <lnicola@dend.ro>
Date: Mon, 21 Jul 2025 09:31:28 +0300
Subject: Revert "Bump rustc-literal-escaper"

This reverts commit 9f3adc540b51a4c2d0472d94033f6d9147b36f6e.
---
 src/tools/rust-analyzer/Cargo.lock                         | 12 +++++++++---
 src/tools/rust-analyzer/Cargo.toml                         |  2 +-
 src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs |  4 ++--
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index 711d0322464..f3adc4006ac 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1505,7 +1505,7 @@ dependencies = [
  "edition",
  "expect-test",
  "ra-ap-rustc_lexer",
- "rustc-literal-escaper",
+ "rustc-literal-escaper 0.0.4",
  "stdx",
  "tracing",
 ]
@@ -1814,7 +1814,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "18d2c4b48fa26e031b1cca0c8ca7433770f5e35e33da56da8636dae2cd45d4e1"
 dependencies = [
  "ra-ap-rustc_lexer",
- "rustc-literal-escaper",
+ "rustc-literal-escaper 0.0.5",
 ]
 
 [[package]]
@@ -1966,6 +1966,12 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
+[[package]]
+name = "rustc-literal-escaper"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab03008eb631b703dd16978282ae36c73282e7922fe101a4bd072a40ecea7b8b"
+
 [[package]]
 name = "rustc-literal-escaper"
 version = "0.0.5"
@@ -2259,7 +2265,7 @@ dependencies = [
  "rayon",
  "rowan",
  "rustc-hash 2.1.1",
- "rustc-literal-escaper",
+ "rustc-literal-escaper 0.0.4",
  "rustc_apfloat",
  "smol_str",
  "stdx",
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index 1ca258abf4b..b21ac158d8e 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -149,7 +149,7 @@ serde = { version = "1.0.219" }
 serde_derive = { version = "1.0.219" }
 serde_json = "1.0.140"
 rustc-hash = "2.1.1"
-rustc-literal-escaper = "0.0.5"
+rustc-literal-escaper = "0.0.4"
 smallvec = { version = "1.15.1", features = [
   "const_new",
   "union",
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs
index 742c452616e..4afdda78a0e 100644
--- a/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs
+++ b/src/tools/rust-analyzer/crates/syntax/src/ast/token_ext.rs
@@ -309,8 +309,8 @@ impl ast::CString {
         let mut prev_end = 0;
         let mut has_error = None;
         let extend_unit = |buf: &mut Vec<u8>, unit: MixedUnit| match unit {
-            MixedUnit::Char(c) => buf.extend(c.get().encode_utf8(&mut [0; 4]).as_bytes()),
-            MixedUnit::HighByte(b) => buf.push(b.get()),
+            MixedUnit::Char(c) => buf.extend(c.encode_utf8(&mut [0; 4]).as_bytes()),
+            MixedUnit::HighByte(b) => buf.push(b),
         };
         unescape_c_str(text, |char_range, unescaped| match (unescaped, buf.capacity() == 0) {
             (Ok(u), false) => extend_unit(&mut buf, u),
-- 
cgit 1.4.1-3-g733a5


From da90db796d0cf39658eac0074c63e5e9ffec2ff2 Mon Sep 17 00:00:00 2001
From: Laurențiu Nicola <lnicola@dend.ro>
Date: Mon, 21 Jul 2025 09:36:14 +0300
Subject: Downgrade ra-ap-rustc_parse_format

---
 src/tools/rust-analyzer/Cargo.lock | 37 +++++++++++++++++++++----------------
 src/tools/rust-analyzer/Cargo.toml |  2 +-
 2 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/src/tools/rust-analyzer/Cargo.lock b/src/tools/rust-analyzer/Cargo.lock
index f3adc4006ac..c471234bbe3 100644
--- a/src/tools/rust-analyzer/Cargo.lock
+++ b/src/tools/rust-analyzer/Cargo.lock
@@ -1268,7 +1268,7 @@ dependencies = [
  "expect-test",
  "intern",
  "parser",
- "ra-ap-rustc_lexer",
+ "ra-ap-rustc_lexer 0.122.0",
  "rustc-hash 2.1.1",
  "smallvec",
  "span",
@@ -1504,8 +1504,8 @@ dependencies = [
  "drop_bomb",
  "edition",
  "expect-test",
- "ra-ap-rustc_lexer",
- "rustc-literal-escaper 0.0.4",
+ "ra-ap-rustc_lexer 0.122.0",
+ "rustc-literal-escaper",
  "stdx",
  "tracing",
 ]
@@ -1614,7 +1614,7 @@ dependencies = [
  "object",
  "paths",
  "proc-macro-test",
- "ra-ap-rustc_lexer",
+ "ra-ap-rustc_lexer 0.122.0",
  "span",
  "syntax-bridge",
  "tt",
@@ -1796,6 +1796,17 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "ra-ap-rustc_lexer"
+version = "0.121.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22944e31fb91e9b3e75bcbc91e37d958b8c0825a6160927f2856831d2ce83b36"
+dependencies = [
+ "memchr",
+ "unicode-properties",
+ "unicode-xid",
+]
+
 [[package]]
 name = "ra-ap-rustc_lexer"
 version = "0.122.0"
@@ -1809,12 +1820,12 @@ dependencies = [
 
 [[package]]
 name = "ra-ap-rustc_parse_format"
-version = "0.122.0"
+version = "0.121.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18d2c4b48fa26e031b1cca0c8ca7433770f5e35e33da56da8636dae2cd45d4e1"
+checksum = "81057891bc2063ad9e353f29462fbc47a0f5072560af34428ae9313aaa5e9d97"
 dependencies = [
- "ra-ap-rustc_lexer",
- "rustc-literal-escaper 0.0.5",
+ "ra-ap-rustc_lexer 0.121.0",
+ "rustc-literal-escaper",
 ]
 
 [[package]]
@@ -1972,12 +1983,6 @@ version = "0.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab03008eb631b703dd16978282ae36c73282e7922fe101a4bd072a40ecea7b8b"
 
-[[package]]
-name = "rustc-literal-escaper"
-version = "0.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4ee29da77c5a54f42697493cd4c9b9f31b74df666a6c04dfc4fde77abe0438b"
-
 [[package]]
 name = "rustc-stable-hash"
 version = "0.1.2"
@@ -2265,7 +2270,7 @@ dependencies = [
  "rayon",
  "rowan",
  "rustc-hash 2.1.1",
- "rustc-literal-escaper 0.0.4",
+ "rustc-literal-escaper",
  "rustc_apfloat",
  "smol_str",
  "stdx",
@@ -2587,7 +2592,7 @@ version = "0.0.0"
 dependencies = [
  "arrayvec",
  "intern",
- "ra-ap-rustc_lexer",
+ "ra-ap-rustc_lexer 0.122.0",
  "stdx",
  "text-size",
 ]
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index b21ac158d8e..700c116ec18 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -90,7 +90,7 @@ vfs = { path = "./crates/vfs", version = "0.0.0" }
 edition = { path = "./crates/edition", version = "0.0.0" }
 
 ra-ap-rustc_lexer = { version = "0.122", default-features = false }
-ra-ap-rustc_parse_format = { version = "0.122", default-features = false }
+ra-ap-rustc_parse_format = { version = "0.121", default-features = false }
 ra-ap-rustc_index = { version = "0.122", default-features = false }
 ra-ap-rustc_abi = { version = "0.122", default-features = false }
 ra-ap-rustc_pattern_analysis = { version = "0.122", default-features = false }
-- 
cgit 1.4.1-3-g733a5


From 1fd06975d0ea9d78d0b611ab292df7a121116501 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Mon, 21 Jul 2025 07:57:11 +0000
Subject: Remove Retag for Unique

---
 compiler/rustc_mir_transform/src/add_retag.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/add_retag.rs b/compiler/rustc_mir_transform/src/add_retag.rs
index 3c29d4624b7..fc08c1df870 100644
--- a/compiler/rustc_mir_transform/src/add_retag.rs
+++ b/compiler/rustc_mir_transform/src/add_retag.rs
@@ -4,7 +4,6 @@
 //! of MIR building, and only after this pass we think of the program has having the
 //! normal MIR semantics.
 
-use rustc_hir::LangItem;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 
@@ -28,7 +27,6 @@ fn may_contain_reference<'tcx>(ty: Ty<'tcx>, depth: u32, tcx: TyCtxt<'tcx>) -> b
         // References and Boxes (`noalias` sources)
         ty::Ref(..) => true,
         ty::Adt(..) if ty.is_box() => true,
-        ty::Adt(adt, _) if tcx.is_lang_item(adt.did(), LangItem::PtrUnique) => true,
         // Compound types: recurse
         ty::Array(ty, _) | ty::Slice(ty) => {
             // This does not branch so we keep the depth the same.
-- 
cgit 1.4.1-3-g733a5


From 79e3c7df0b63dcce4c17c7133564882672c6de34 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <hopsi@tuta.io>
Date: Mon, 21 Jul 2025 10:53:11 +0200
Subject: fix some typos

---
 src/doc/rustc-dev-guide/src/building/suggested.md                   | 2 +-
 src/doc/rustc-dev-guide/src/hir/ambig-unambig-ty-and-consts.md      | 4 ++--
 src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md | 2 +-
 src/doc/rustc-dev-guide/src/tests/compiletest.md                    | 2 +-
 src/doc/rustc-dev-guide/src/ty_module/instantiating_binders.md      | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/doc/rustc-dev-guide/src/building/suggested.md b/src/doc/rustc-dev-guide/src/building/suggested.md
index 7f626314f71..c046161e77f 100644
--- a/src/doc/rustc-dev-guide/src/building/suggested.md
+++ b/src/doc/rustc-dev-guide/src/building/suggested.md
@@ -162,7 +162,7 @@ create a `.vim/coc-settings.json`. The settings can be edited with
 [`src/etc/rust_analyzer_settings.json`].
 
 Another way is without a plugin, and creating your own logic in your
-configuration. The following code will work for any checkout of rust-lang/rust (newer than Febuary 2025):
+configuration. The following code will work for any checkout of rust-lang/rust (newer than February 2025):
 
 ```lua
 local function expand_config_variables(option)
diff --git a/src/doc/rustc-dev-guide/src/hir/ambig-unambig-ty-and-consts.md b/src/doc/rustc-dev-guide/src/hir/ambig-unambig-ty-and-consts.md
index 709027883ae..d4f504ad2a9 100644
--- a/src/doc/rustc-dev-guide/src/hir/ambig-unambig-ty-and-consts.md
+++ b/src/doc/rustc-dev-guide/src/hir/ambig-unambig-ty-and-consts.md
@@ -38,7 +38,7 @@ Note that places 3 and 4 would never actually be possible to encounter as we alw
 This has a few failure modes:
 - People may write visitors which check for `GenericArg::Infer` but forget to check for `hir::TyKind/ConstArgKind::Infer`, only handling infers in ambig positions by accident.
 - People may write visitors which check for `hir::TyKind/ConstArgKind::Infer` but forget to check for `GenericArg::Infer`, only handling infers in unambig positions by accident.
-- People may write visitors which check for `GenerArg::Type/Const(TyKind/ConstArgKind::Infer)` and `GenerigArg::Infer`, not realising that we never represent inferred types/consts in ambig positions as a `GenericArg::Type/Const`.
+- People may write visitors which check for `GenericArg::Type/Const(TyKind/ConstArgKind::Infer)` and `GenericArg::Infer`, not realising that we never represent inferred types/consts in ambig positions as a `GenericArg::Type/Const`.
 - People may write visitors which check for *only* `TyKind::Infer` and not `ConstArgKind::Infer` forgetting that there are also inferred const arguments (and vice versa).
 
 To make writing HIR visitors less error prone when caring about inferred types/consts we have a relatively complex system:
@@ -60,4 +60,4 @@ This has a number of benefits:
 [ambig_arg]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir/enum.AmbigArg.html
 [visit_ty]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/intravisit/trait.Visitor.html#method.visit_ty
 [visit_const_arg]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/intravisit/trait.Visitor.html#method.visit_const_arg
-[visit_infer]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/intravisit/trait.Visitor.html#method.visit_infer
\ No newline at end of file
+[visit_infer]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/intravisit/trait.Visitor.html#method.visit_infer
diff --git a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md
index 4f44cf1701c..3ec5ebd799e 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc-internals/rustdoc-test-suite.md
@@ -20,7 +20,7 @@ Internally, [`compiletest`] invokes the supplementary checker script [`htmldocck
 
 Directives to HtmlDocCk are assertions that place constraints on the generated HTML.
 They look similar to those given to `compiletest` in that they take the form of `//@` comments
-but ultimately, they are completey distinct and processed by different programs.
+but ultimately, they are completely distinct and processed by different programs.
 
 [XPath] is used to query parts of the HTML document tree.
 
diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md
index ded30234e70..aa99347b2bb 100644
--- a/src/doc/rustc-dev-guide/src/tests/compiletest.md
+++ b/src/doc/rustc-dev-guide/src/tests/compiletest.md
@@ -29,7 +29,7 @@ on if or how to run the test, what behavior to expect, and more. See
 [directives](directives.md) and the test suite documentation below for more details
 on these annotations.
 
-See the [Adding new tests](adding.md) and [Best practies](best-practices.md)
+See the [Adding new tests](adding.md) and [Best practices](best-practices.md)
 chapters for a tutorial on creating a new test and advice on writing a good
 test, and the [Running tests](running.md) chapter on how to run the test suite.
 
diff --git a/src/doc/rustc-dev-guide/src/ty_module/instantiating_binders.md b/src/doc/rustc-dev-guide/src/ty_module/instantiating_binders.md
index e3f091ca45f..0d1108c72e0 100644
--- a/src/doc/rustc-dev-guide/src/ty_module/instantiating_binders.md
+++ b/src/doc/rustc-dev-guide/src/ty_module/instantiating_binders.md
@@ -77,7 +77,7 @@ This end result is incorrect as we had two separate binders introducing their ow
 
 While in theory we could make this work it would be quite involved and more complex than the current setup, we would have to:
 - "rewrite" bound variables to have a higher `DebruijnIndex` whenever instantiating a `Binder`/`EarlyBinder` with a `Bound` ty/const/region 
-- When inferring an inference variable to a bound var, if that bound var is from a binder enterred after creating the infer var, we would have to lower the `DebruijnIndex` of the var.
+- When inferring an inference variable to a bound var, if that bound var is from a binder entered after creating the infer var, we would have to lower the `DebruijnIndex` of the var.
 - Separately track what binder an inference variable was created inside of, also what the innermost binder it can name parameters from (currently we only have to track the latter)
 - When resolving inference variables rewrite any bound variables according to the current binder depth of the infcx
 - Maybe more (while writing this list items kept getting added so it seems naive to think this is exhaustive)
-- 
cgit 1.4.1-3-g733a5


From 74ba9cbae4306acf0f4ee34abb6762e05446abc4 Mon Sep 17 00:00:00 2001
From: Jieyou Xu <jieyouxu@outlook.com>
Date: Mon, 21 Jul 2025 16:58:54 +0800
Subject: Don't use another main test file as auxiliary

In this case, the exact extern crate isn't very important.

This is part of the changes needed to address the spurious failures from
a main test `../removing-extern-crate.rs` being both an auxiliary and a
main test file, causing fs races due to multiple `rustc` processes in
multiple test threads trying to build the main test file both as a main
test and also as an auxiliary at around the same time.
---
 tests/ui/rust-2018/removing-extern-crate-malformed-cfg.fixed |  2 +-
 tests/ui/rust-2018/removing-extern-crate-malformed-cfg.rs    |  6 +++---
 .../ui/rust-2018/removing-extern-crate-malformed-cfg.stderr  | 12 ++++++------
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.fixed b/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.fixed
index 26c1c9015da..028f86eb0a3 100644
--- a/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.fixed
+++ b/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.fixed
@@ -1,5 +1,5 @@
 //@ edition:2018
-//@ aux-build:../removing-extern-crate.rs
+//@ aux-build: remove-extern-crate.rs
 //@ run-rustfix
 
 #![warn(rust_2018_idioms)]
diff --git a/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.rs b/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.rs
index c5b629fa90b..1acf531a661 100644
--- a/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.rs
+++ b/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.rs
@@ -1,16 +1,16 @@
 //@ edition:2018
-//@ aux-build:../removing-extern-crate.rs
+//@ aux-build: remove-extern-crate.rs
 //@ run-rustfix
 
 #![warn(rust_2018_idioms)]
 
 #[cfg_attr(test, "macro_use")] //~ ERROR expected
-extern crate removing_extern_crate as foo; //~ WARNING unused extern crate
+extern crate remove_extern_crate as foo; //~ WARNING unused extern crate
 extern crate core; //~ WARNING unused extern crate
 
 mod another {
     #[cfg_attr(test)] //~ ERROR expected
-    extern crate removing_extern_crate as foo; //~ WARNING unused extern crate
+    extern crate remove_extern_crate as foo; //~ WARNING unused extern crate
     extern crate core; //~ WARNING unused extern crate
 }
 
diff --git a/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.stderr b/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.stderr
index 0e834707bf9..632ecd62322 100644
--- a/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.stderr
+++ b/tests/ui/rust-2018/removing-extern-crate-malformed-cfg.stderr
@@ -19,8 +19,8 @@ LL |     #[cfg_attr(test)]
 warning: unused extern crate
   --> $DIR/removing-extern-crate-malformed-cfg.rs:8:1
    |
-LL | extern crate removing_extern_crate as foo;
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unused
+LL | extern crate remove_extern_crate as foo;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unused
    |
 note: the lint level is defined here
   --> $DIR/removing-extern-crate-malformed-cfg.rs:5:9
@@ -31,7 +31,7 @@ LL | #![warn(rust_2018_idioms)]
 help: remove the unused `extern crate`
    |
 LL - #[cfg_attr(test, "macro_use")]
-LL - extern crate removing_extern_crate as foo;
+LL - extern crate remove_extern_crate as foo;
 LL +
    |
 
@@ -50,13 +50,13 @@ LL +
 warning: unused extern crate
   --> $DIR/removing-extern-crate-malformed-cfg.rs:13:5
    |
-LL |     extern crate removing_extern_crate as foo;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unused
+LL |     extern crate remove_extern_crate as foo;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unused
    |
 help: remove the unused `extern crate`
    |
 LL -     #[cfg_attr(test)]
-LL -     extern crate removing_extern_crate as foo;
+LL -     extern crate remove_extern_crate as foo;
 LL +
    |
 
-- 
cgit 1.4.1-3-g733a5


From 3c76e3d0026ea9904358b1614bbd9c4f8b7cedf5 Mon Sep 17 00:00:00 2001
From: Evgenii Zheltonozhskii <zheltonozhskiy@gmail.com>
Date: Mon, 21 Jul 2025 12:49:45 +0300
Subject: Constify Try, From, TryFrom

---
 library/core/src/array/mod.rs                      |  3 +-
 library/core/src/ascii/ascii_char.rs               |  3 +-
 library/core/src/char/convert.rs                   | 15 +++++---
 library/core/src/convert/mod.rs                    | 40 ++++++++++++++-------
 library/core/src/convert/num.rs                    | 24 ++++++++-----
 library/core/src/net/ip_addr.rs                    | 36 ++++++++++++-------
 library/core/src/net/socket_addr.rs                |  9 +++--
 library/core/src/num/error.rs                      |  6 ++--
 library/core/src/num/mod.rs                        |  3 +-
 library/core/src/num/nonzero.rs                    |  3 +-
 library/core/src/ops/try_trait.rs                  |  8 ++++-
 library/core/src/option.rs                         | 28 ++++++++++-----
 library/core/src/ptr/alignment.rs                  |  6 ++--
 library/core/src/result.rs                         | 26 +++++++++-----
 library/core/src/str/traits.rs                     |  2 ++
 library/core/src/sync/atomic.rs                    |  6 ++--
 tests/ui/consts/const-try-feature-gate.rs          |  2 ++
 tests/ui/consts/const-try-feature-gate.stderr      | 36 ++++++++++++++++---
 tests/ui/consts/const-try.rs                       |  8 ++---
 tests/ui/consts/const-try.stderr                   | 37 -------------------
 tests/ui/consts/control-flow/try.rs                |  9 ++---
 tests/ui/consts/control-flow/try.stderr            | 19 ----------
 tests/ui/consts/try-operator.rs                    |  3 +-
 tests/ui/consts/try-operator.stderr                | 42 ----------------------
 tests/ui/traits/const-traits/hir-const-check.rs    |  4 +--
 .../ui/traits/const-traits/hir-const-check.stderr  | 19 ----------
 .../const-traits/ice-119717-constant-lifetime.rs   |  5 ++-
 .../ice-119717-constant-lifetime.stderr            | 13 ++-----
 .../const-traits/ice-126148-failed-to-normalize.rs |  8 ++---
 .../ice-126148-failed-to-normalize.stderr          | 41 ++-------------------
 .../const-traits/trait-default-body-stability.rs   |  2 +-
 .../trait-default-body-stability.stderr            | 37 -------------------
 32 files changed, 204 insertions(+), 299 deletions(-)
 delete mode 100644 tests/ui/consts/const-try.stderr
 delete mode 100644 tests/ui/consts/control-flow/try.stderr
 delete mode 100644 tests/ui/consts/try-operator.stderr
 delete mode 100644 tests/ui/traits/const-traits/hir-const-check.stderr
 delete mode 100644 tests/ui/traits/const-traits/trait-default-body-stability.stderr

diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs
index 62203e132b7..1c23218552a 100644
--- a/library/core/src/array/mod.rs
+++ b/library/core/src/array/mod.rs
@@ -198,7 +198,8 @@ impl Error for TryFromSliceError {
 }
 
 #[stable(feature = "try_from_slice_error", since = "1.36.0")]
-impl From<Infallible> for TryFromSliceError {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<Infallible> for TryFromSliceError {
     fn from(x: Infallible) -> TryFromSliceError {
         match x {}
     }
diff --git a/library/core/src/ascii/ascii_char.rs b/library/core/src/ascii/ascii_char.rs
index 0b72b4780f1..054ddf84470 100644
--- a/library/core/src/ascii/ascii_char.rs
+++ b/library/core/src/ascii/ascii_char.rs
@@ -546,7 +546,8 @@ macro_rules! into_int_impl {
     ($($ty:ty)*) => {
         $(
             #[unstable(feature = "ascii_char", issue = "110998")]
-            impl From<AsciiChar> for $ty {
+            #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+            impl const From<AsciiChar> for $ty {
                 #[inline]
                 fn from(chr: AsciiChar) -> $ty {
                     chr as u8 as $ty
diff --git a/library/core/src/char/convert.rs b/library/core/src/char/convert.rs
index 78cd89fefae..23061cb663b 100644
--- a/library/core/src/char/convert.rs
+++ b/library/core/src/char/convert.rs
@@ -36,7 +36,8 @@ pub(super) const unsafe fn from_u32_unchecked(i: u32) -> char {
 }
 
 #[stable(feature = "char_convert", since = "1.13.0")]
-impl From<char> for u32 {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<char> for u32 {
     /// Converts a [`char`] into a [`u32`].
     ///
     /// # Examples
@@ -53,7 +54,8 @@ impl From<char> for u32 {
 }
 
 #[stable(feature = "more_char_conversions", since = "1.51.0")]
-impl From<char> for u64 {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<char> for u64 {
     /// Converts a [`char`] into a [`u64`].
     ///
     /// # Examples
@@ -72,7 +74,8 @@ impl From<char> for u64 {
 }
 
 #[stable(feature = "more_char_conversions", since = "1.51.0")]
-impl From<char> for u128 {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<char> for u128 {
     /// Converts a [`char`] into a [`u128`].
     ///
     /// # Examples
@@ -157,7 +160,8 @@ impl TryFrom<char> for u16 {
 /// for a superset of Windows-1252 that fills the remaining blanks with corresponding
 /// C0 and C1 control codes.
 #[stable(feature = "char_convert", since = "1.13.0")]
-impl From<u8> for char {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<u8> for char {
     /// Converts a [`u8`] into a [`char`].
     ///
     /// # Examples
@@ -247,7 +251,8 @@ const fn char_try_from_u32(i: u32) -> Result<char, CharTryFromError> {
 }
 
 #[stable(feature = "try_from", since = "1.34.0")]
-impl TryFrom<u32> for char {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const TryFrom<u32> for char {
     type Error = CharTryFromError;
 
     #[inline]
diff --git a/library/core/src/convert/mod.rs b/library/core/src/convert/mod.rs
index 38381dbdf23..220a24caf09 100644
--- a/library/core/src/convert/mod.rs
+++ b/library/core/src/convert/mod.rs
@@ -216,6 +216,8 @@ pub const fn identity<T>(x: T) -> T {
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "AsRef"]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
 pub trait AsRef<T: PointeeSized>: PointeeSized {
     /// Converts this type into a shared reference of the (usually inferred) input type.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -367,6 +369,8 @@ pub trait AsRef<T: PointeeSized>: PointeeSized {
 /// `&mut Vec<u8>`, for example, is the better choice (callers need to pass the correct type then).
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "AsMut"]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
 pub trait AsMut<T: PointeeSized>: PointeeSized {
     /// Converts this type into a mutable reference of the (usually inferred) input type.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -710,9 +714,10 @@ pub trait TryFrom<T>: Sized {
 
 // As lifts over &
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PointeeSized, U: PointeeSized> AsRef<U> for &T
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T: PointeeSized, U: PointeeSized> const AsRef<U> for &T
 where
-    T: AsRef<U>,
+    T: ~const AsRef<U>,
 {
     #[inline]
     fn as_ref(&self) -> &U {
@@ -722,9 +727,10 @@ where
 
 // As lifts over &mut
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PointeeSized, U: PointeeSized> AsRef<U> for &mut T
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T: PointeeSized, U: PointeeSized> const AsRef<U> for &mut T
 where
-    T: AsRef<U>,
+    T: ~const AsRef<U>,
 {
     #[inline]
     fn as_ref(&self) -> &U {
@@ -742,9 +748,10 @@ where
 
 // AsMut lifts over &mut
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PointeeSized, U: PointeeSized> AsMut<U> for &mut T
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T: PointeeSized, U: PointeeSized> const AsMut<U> for &mut T
 where
-    T: AsMut<U>,
+    T: ~const AsMut<U>,
 {
     #[inline]
     fn as_mut(&mut self) -> &mut U {
@@ -840,7 +847,8 @@ where
 ////////////////////////////////////////////////////////////////////////////////
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> AsRef<[T]> for [T] {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T> const AsRef<[T]> for [T] {
     #[inline(always)]
     fn as_ref(&self) -> &[T] {
         self
@@ -848,7 +856,8 @@ impl<T> AsRef<[T]> for [T] {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> AsMut<[T]> for [T] {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T> const AsMut<[T]> for [T] {
     #[inline(always)]
     fn as_mut(&mut self) -> &mut [T] {
         self
@@ -856,7 +865,8 @@ impl<T> AsMut<[T]> for [T] {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<str> for str {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const AsRef<str> for str {
     #[inline(always)]
     fn as_ref(&self) -> &str {
         self
@@ -864,7 +874,8 @@ impl AsRef<str> for str {
 }
 
 #[stable(feature = "as_mut_str_for_str", since = "1.51.0")]
-impl AsMut<str> for str {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const AsMut<str> for str {
     #[inline(always)]
     fn as_mut(&mut self) -> &mut str {
         self
@@ -925,7 +936,8 @@ impl AsMut<str> for str {
 pub enum Infallible {}
 
 #[stable(feature = "convert_infallible", since = "1.34.0")]
-impl Clone for Infallible {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const Clone for Infallible {
     fn clone(&self) -> Infallible {
         match *self {}
     }
@@ -953,7 +965,8 @@ impl Error for Infallible {
 }
 
 #[stable(feature = "convert_infallible", since = "1.34.0")]
-impl PartialEq for Infallible {
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
+impl const PartialEq for Infallible {
     fn eq(&self, _: &Infallible) -> bool {
         match *self {}
     }
@@ -977,7 +990,8 @@ impl Ord for Infallible {
 }
 
 #[stable(feature = "convert_infallible", since = "1.34.0")]
-impl From<!> for Infallible {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<!> for Infallible {
     #[inline]
     fn from(x: !) -> Self {
         x
diff --git a/library/core/src/convert/num.rs b/library/core/src/convert/num.rs
index 50616732b77..affb4eb64d3 100644
--- a/library/core/src/convert/num.rs
+++ b/library/core/src/convert/num.rs
@@ -69,7 +69,8 @@ macro_rules! impl_from {
     };
     ($Small:ty => $Large:ty, #[$attr:meta], $doc:expr $(,)?) => {
         #[$attr]
-        impl From<$Small> for $Large {
+        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        impl const From<$Small> for $Large {
             // Rustdocs on the impl block show a "[+] show undocumented items" toggle.
             // Rustdocs on functions do not.
             #[doc = $doc]
@@ -200,7 +201,8 @@ macro_rules! impl_float_from_bool {
         )?
     ) => {
         #[stable(feature = "float_from_bool", since = "1.68.0")]
-        impl From<bool> for $float {
+        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+            impl const From<bool> for $float {
             #[doc = concat!("Converts a [`bool`] to [`", stringify!($float),"`] losslessly.")]
             /// The resulting value is positive `0.0` for `false` and `1.0` for `true` values.
             ///
@@ -250,7 +252,8 @@ impl_float_from_bool!(
 macro_rules! impl_try_from_unbounded {
     ($source:ty => $($target:ty),+) => {$(
         #[stable(feature = "try_from", since = "1.34.0")]
-        impl TryFrom<$source> for $target {
+        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        impl const TryFrom<$source> for $target {
             type Error = TryFromIntError;
 
             /// Tries to create the target number type from a source
@@ -268,7 +271,8 @@ macro_rules! impl_try_from_unbounded {
 macro_rules! impl_try_from_lower_bounded {
     ($source:ty => $($target:ty),+) => {$(
         #[stable(feature = "try_from", since = "1.34.0")]
-        impl TryFrom<$source> for $target {
+        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        impl const TryFrom<$source> for $target {
             type Error = TryFromIntError;
 
             /// Tries to create the target number type from a source
@@ -290,7 +294,8 @@ macro_rules! impl_try_from_lower_bounded {
 macro_rules! impl_try_from_upper_bounded {
     ($source:ty => $($target:ty),+) => {$(
         #[stable(feature = "try_from", since = "1.34.0")]
-        impl TryFrom<$source> for $target {
+        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        impl const TryFrom<$source> for $target {
             type Error = TryFromIntError;
 
             /// Tries to create the target number type from a source
@@ -312,7 +317,8 @@ macro_rules! impl_try_from_upper_bounded {
 macro_rules! impl_try_from_both_bounded {
     ($source:ty => $($target:ty),+) => {$(
         #[stable(feature = "try_from", since = "1.34.0")]
-        impl TryFrom<$source> for $target {
+        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        impl const TryFrom<$source> for $target {
             type Error = TryFromIntError;
 
             /// Tries to create the target number type from a source
@@ -450,7 +456,8 @@ use crate::num::NonZero;
 macro_rules! impl_nonzero_int_from_nonzero_int {
     ($Small:ty => $Large:ty) => {
         #[stable(feature = "nz_int_conv", since = "1.41.0")]
-        impl From<NonZero<$Small>> for NonZero<$Large> {
+        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        impl const From<NonZero<$Small>> for NonZero<$Large> {
             // Rustdocs on the impl block show a "[+] show undocumented items" toggle.
             // Rustdocs on functions do not.
             #[doc = concat!("Converts <code>[NonZero]\\<[", stringify!($Small), "]></code> ")]
@@ -540,7 +547,8 @@ impl_nonzero_int_try_from_int!(isize);
 macro_rules! impl_nonzero_int_try_from_nonzero_int {
     ($source:ty => $($target:ty),+) => {$(
         #[stable(feature = "nzint_try_from_nzint_conv", since = "1.49.0")]
-        impl TryFrom<NonZero<$source>> for NonZero<$target> {
+        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        impl const TryFrom<NonZero<$source>> for NonZero<$target> {
             type Error = TryFromIntError;
 
             // Rustdocs on the impl block show a "[+] show undocumented items" toggle.
diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index aaa68e8d7d1..fef987153cb 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -1089,7 +1089,8 @@ impl fmt::Debug for IpAddr {
 }
 
 #[stable(feature = "ip_from_ip", since = "1.16.0")]
-impl From<Ipv4Addr> for IpAddr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<Ipv4Addr> for IpAddr {
     /// Copies this address to a new `IpAddr::V4`.
     ///
     /// # Examples
@@ -1111,7 +1112,8 @@ impl From<Ipv4Addr> for IpAddr {
 }
 
 #[stable(feature = "ip_from_ip", since = "1.16.0")]
-impl From<Ipv6Addr> for IpAddr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<Ipv6Addr> for IpAddr {
     /// Copies this address to a new `IpAddr::V6`.
     ///
     /// # Examples
@@ -1221,7 +1223,8 @@ impl Ord for Ipv4Addr {
 }
 
 #[stable(feature = "ip_u32", since = "1.1.0")]
-impl From<Ipv4Addr> for u32 {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<Ipv4Addr> for u32 {
     /// Uses [`Ipv4Addr::to_bits`] to convert an IPv4 address to a host byte order `u32`.
     #[inline]
     fn from(ip: Ipv4Addr) -> u32 {
@@ -1230,7 +1233,8 @@ impl From<Ipv4Addr> for u32 {
 }
 
 #[stable(feature = "ip_u32", since = "1.1.0")]
-impl From<u32> for Ipv4Addr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<u32> for Ipv4Addr {
     /// Uses [`Ipv4Addr::from_bits`] to convert a host byte order `u32` into an IPv4 address.
     #[inline]
     fn from(ip: u32) -> Ipv4Addr {
@@ -1239,7 +1243,8 @@ impl From<u32> for Ipv4Addr {
 }
 
 #[stable(feature = "from_slice_v4", since = "1.9.0")]
-impl From<[u8; 4]> for Ipv4Addr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<[u8; 4]> for Ipv4Addr {
     /// Creates an `Ipv4Addr` from a four element byte array.
     ///
     /// # Examples
@@ -1257,7 +1262,8 @@ impl From<[u8; 4]> for Ipv4Addr {
 }
 
 #[stable(feature = "ip_from_slice", since = "1.17.0")]
-impl From<[u8; 4]> for IpAddr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<[u8; 4]> for IpAddr {
     /// Creates an `IpAddr::V4` from a four element byte array.
     ///
     /// # Examples
@@ -2211,7 +2217,8 @@ impl Ord for Ipv6Addr {
 }
 
 #[stable(feature = "i128", since = "1.26.0")]
-impl From<Ipv6Addr> for u128 {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<Ipv6Addr> for u128 {
     /// Uses [`Ipv6Addr::to_bits`] to convert an IPv6 address to a host byte order `u128`.
     #[inline]
     fn from(ip: Ipv6Addr) -> u128 {
@@ -2219,7 +2226,8 @@ impl From<Ipv6Addr> for u128 {
     }
 }
 #[stable(feature = "i128", since = "1.26.0")]
-impl From<u128> for Ipv6Addr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<u128> for Ipv6Addr {
     /// Uses [`Ipv6Addr::from_bits`] to convert a host byte order `u128` to an IPv6 address.
     #[inline]
     fn from(ip: u128) -> Ipv6Addr {
@@ -2228,7 +2236,8 @@ impl From<u128> for Ipv6Addr {
 }
 
 #[stable(feature = "ipv6_from_octets", since = "1.9.0")]
-impl From<[u8; 16]> for Ipv6Addr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<[u8; 16]> for Ipv6Addr {
     /// Creates an `Ipv6Addr` from a sixteen element byte array.
     ///
     /// # Examples
@@ -2255,7 +2264,8 @@ impl From<[u8; 16]> for Ipv6Addr {
 }
 
 #[stable(feature = "ipv6_from_segments", since = "1.16.0")]
-impl From<[u16; 8]> for Ipv6Addr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<[u16; 8]> for Ipv6Addr {
     /// Creates an `Ipv6Addr` from an eight element 16-bit array.
     ///
     /// # Examples
@@ -2283,7 +2293,8 @@ impl From<[u16; 8]> for Ipv6Addr {
 }
 
 #[stable(feature = "ip_from_slice", since = "1.17.0")]
-impl From<[u8; 16]> for IpAddr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<[u8; 16]> for IpAddr {
     /// Creates an `IpAddr::V6` from a sixteen element byte array.
     ///
     /// # Examples
@@ -2310,7 +2321,8 @@ impl From<[u8; 16]> for IpAddr {
 }
 
 #[stable(feature = "ip_from_slice", since = "1.17.0")]
-impl From<[u16; 8]> for IpAddr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<[u16; 8]> for IpAddr {
     /// Creates an `IpAddr::V6` from an eight element 16-bit array.
     ///
     /// # Examples
diff --git a/library/core/src/net/socket_addr.rs b/library/core/src/net/socket_addr.rs
index 936f9f64930..69924199f99 100644
--- a/library/core/src/net/socket_addr.rs
+++ b/library/core/src/net/socket_addr.rs
@@ -592,7 +592,8 @@ impl SocketAddrV6 {
 }
 
 #[stable(feature = "ip_from_ip", since = "1.16.0")]
-impl From<SocketAddrV4> for SocketAddr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<SocketAddrV4> for SocketAddr {
     /// Converts a [`SocketAddrV4`] into a [`SocketAddr::V4`].
     #[inline]
     fn from(sock4: SocketAddrV4) -> SocketAddr {
@@ -601,7 +602,8 @@ impl From<SocketAddrV4> for SocketAddr {
 }
 
 #[stable(feature = "ip_from_ip", since = "1.16.0")]
-impl From<SocketAddrV6> for SocketAddr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<SocketAddrV6> for SocketAddr {
     /// Converts a [`SocketAddrV6`] into a [`SocketAddr::V6`].
     #[inline]
     fn from(sock6: SocketAddrV6) -> SocketAddr {
@@ -610,7 +612,8 @@ impl From<SocketAddrV6> for SocketAddr {
 }
 
 #[stable(feature = "addr_from_into_ip", since = "1.17.0")]
-impl<I: Into<IpAddr>> From<(I, u16)> for SocketAddr {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<I: ~const Into<IpAddr>> const From<(I, u16)> for SocketAddr {
     /// Converts a tuple struct (Into<[`IpAddr`]>, `u16`) into a [`SocketAddr`].
     ///
     /// This conversion creates a [`SocketAddr::V4`] for an [`IpAddr::V4`]
diff --git a/library/core/src/num/error.rs b/library/core/src/num/error.rs
index f9c4cdd0ebe..cfedd465cab 100644
--- a/library/core/src/num/error.rs
+++ b/library/core/src/num/error.rs
@@ -26,14 +26,16 @@ impl Error for TryFromIntError {
 }
 
 #[stable(feature = "try_from", since = "1.34.0")]
-impl From<Infallible> for TryFromIntError {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<Infallible> for TryFromIntError {
     fn from(x: Infallible) -> TryFromIntError {
         match x {}
     }
 }
 
 #[unstable(feature = "never_type", issue = "35121")]
-impl From<!> for TryFromIntError {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<!> for TryFromIntError {
     #[inline]
     fn from(never: !) -> TryFromIntError {
         // Match rather than coerce to make sure that code like
diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs
index faa41ddf13c..acfe38b7a37 100644
--- a/library/core/src/num/mod.rs
+++ b/library/core/src/num/mod.rs
@@ -1378,7 +1378,8 @@ const fn from_ascii_radix_panic(radix: u32) -> ! {
 macro_rules! from_str_int_impl {
     ($signedness:ident $($int_ty:ty)+) => {$(
         #[stable(feature = "rust1", since = "1.0.0")]
-        impl FromStr for $int_ty {
+        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        impl const FromStr for $int_ty {
             type Err = ParseIntError;
 
             /// Parses an integer from a string slice with decimal digits.
diff --git a/library/core/src/num/nonzero.rs b/library/core/src/num/nonzero.rs
index b8900c4113a..f793602de50 100644
--- a/library/core/src/num/nonzero.rs
+++ b/library/core/src/num/nonzero.rs
@@ -297,7 +297,8 @@ where
 }
 
 #[stable(feature = "from_nonzero", since = "1.31.0")]
-impl<T> From<NonZero<T>> for T
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T> const From<NonZero<T>> for T
 where
     T: ZeroablePrimitive,
 {
diff --git a/library/core/src/ops/try_trait.rs b/library/core/src/ops/try_trait.rs
index aebbddb4f1c..a889c824be5 100644
--- a/library/core/src/ops/try_trait.rs
+++ b/library/core/src/ops/try_trait.rs
@@ -128,7 +128,9 @@ use crate::ops::ControlFlow;
 )]
 #[doc(alias = "?")]
 #[lang = "Try"]
-pub trait Try: FromResidual {
+#[const_trait]
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+pub trait Try: ~const FromResidual {
     /// The type of the value produced by `?` when *not* short-circuiting.
     #[unstable(feature = "try_trait_v2", issue = "84277", old_name = "try_trait")]
     type Output;
@@ -304,6 +306,8 @@ pub trait Try: FromResidual {
 )]
 #[rustc_diagnostic_item = "FromResidual"]
 #[unstable(feature = "try_trait_v2", issue = "84277", old_name = "try_trait")]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
 pub trait FromResidual<R = <Self as Try>::Residual> {
     /// Constructs the type from a compatible `Residual` type.
     ///
@@ -357,6 +361,8 @@ where
 /// and in the other direction,
 /// `<Result<Infallible, E> as Residual<T>>::TryType = Result<T, E>`.
 #[unstable(feature = "try_trait_v2_residual", issue = "91285")]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
 pub trait Residual<O> {
     /// The "return" type of this meta-function.
     #[unstable(feature = "try_trait_v2_residual", issue = "91285")]
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 8036c59e893..7f8c30b95b2 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -2144,9 +2144,12 @@ const fn expect_failed(msg: &str) -> ! {
 /////////////////////////////////////////////////////////////////////////////
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Clone for Option<T>
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T> const Clone for Option<T>
 where
-    T: Clone,
+    // FIXME(const_hack): the T: ~const Destruct should be inferred from the Self: ~const Destruct in clone_from.
+    // See https://github.com/rust-lang/rust/issues/144207
+    T: ~const Clone + ~const Destruct,
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -2230,7 +2233,8 @@ impl<'a, T> IntoIterator for &'a mut Option<T> {
 }
 
 #[stable(since = "1.12.0", feature = "option_from")]
-impl<T> From<T> for Option<T> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T> const From<T> for Option<T> {
     /// Moves `val` into a new [`Some`].
     ///
     /// # Examples
@@ -2246,7 +2250,8 @@ impl<T> From<T> for Option<T> {
 }
 
 #[stable(feature = "option_ref_from_ref_option", since = "1.30.0")]
-impl<'a, T> From<&'a Option<T>> for Option<&'a T> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<'a, T> const From<&'a Option<T>> for Option<&'a T> {
     /// Converts from `&Option<T>` to `Option<&T>`.
     ///
     /// # Examples
@@ -2273,7 +2278,8 @@ impl<'a, T> From<&'a Option<T>> for Option<&'a T> {
 }
 
 #[stable(feature = "option_ref_from_ref_option", since = "1.30.0")]
-impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<'a, T> const From<&'a mut Option<T>> for Option<&'a mut T> {
     /// Converts from `&mut Option<T>` to `Option<&mut T>`
     ///
     /// # Examples
@@ -2593,7 +2599,8 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "84277", old_name = "try_trait")]
-impl<T> ops::Try for Option<T> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T> const ops::Try for Option<T> {
     type Output = T;
     type Residual = Option<convert::Infallible>;
 
@@ -2612,9 +2619,10 @@ impl<T> ops::Try for Option<T> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "84277", old_name = "try_trait")]
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
 // Note: manually specifying the residual type instead of using the default to work around
 // https://github.com/rust-lang/rust/issues/99940
-impl<T> ops::FromResidual<Option<convert::Infallible>> for Option<T> {
+impl<T> const ops::FromResidual<Option<convert::Infallible>> for Option<T> {
     #[inline]
     fn from_residual(residual: Option<convert::Infallible>) -> Self {
         match residual {
@@ -2625,7 +2633,8 @@ impl<T> ops::FromResidual<Option<convert::Infallible>> for Option<T> {
 
 #[diagnostic::do_not_recommend]
 #[unstable(feature = "try_trait_v2_yeet", issue = "96374")]
-impl<T> ops::FromResidual<ops::Yeet<()>> for Option<T> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T> const ops::FromResidual<ops::Yeet<()>> for Option<T> {
     #[inline]
     fn from_residual(ops::Yeet(()): ops::Yeet<()>) -> Self {
         None
@@ -2633,7 +2642,8 @@ impl<T> ops::FromResidual<ops::Yeet<()>> for Option<T> {
 }
 
 #[unstable(feature = "try_trait_v2_residual", issue = "91285")]
-impl<T> ops::Residual<T> for Option<convert::Infallible> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T> const ops::Residual<T> for Option<convert::Infallible> {
     type TryType = Option<T>;
 }
 
diff --git a/library/core/src/ptr/alignment.rs b/library/core/src/ptr/alignment.rs
index 6d473a4bd56..bd5b4e21baa 100644
--- a/library/core/src/ptr/alignment.rs
+++ b/library/core/src/ptr/alignment.rs
@@ -189,7 +189,8 @@ impl TryFrom<usize> for Alignment {
 }
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-impl From<Alignment> for NonZero<usize> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<Alignment> for NonZero<usize> {
     #[inline]
     fn from(align: Alignment) -> NonZero<usize> {
         align.as_nonzero()
@@ -197,7 +198,8 @@ impl From<Alignment> for NonZero<usize> {
 }
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-impl From<Alignment> for usize {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<Alignment> for usize {
     #[inline]
     fn from(align: Alignment) -> usize {
         align.as_usize()
diff --git a/library/core/src/result.rs b/library/core/src/result.rs
index 7f3f2964985..f65257ff59b 100644
--- a/library/core/src/result.rs
+++ b/library/core/src/result.rs
@@ -1288,9 +1288,11 @@ impl<T, E> Result<T, E> {
     /// ```
     #[unstable(feature = "unwrap_infallible", reason = "newly added", issue = "61695")]
     #[inline]
-    pub fn into_ok(self) -> T
+    #[rustc_allow_const_fn_unstable(const_precise_live_drops)]
+    #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+    pub const fn into_ok(self) -> T
     where
-        E: Into<!>,
+        E: ~const Into<!>,
     {
         match self {
             Ok(x) => x,
@@ -1323,9 +1325,11 @@ impl<T, E> Result<T, E> {
     /// ```
     #[unstable(feature = "unwrap_infallible", reason = "newly added", issue = "61695")]
     #[inline]
-    pub fn into_err(self) -> E
+    #[rustc_allow_const_fn_unstable(const_precise_live_drops)]
+    #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+    pub const fn into_err(self) -> E
     where
-        T: Into<!>,
+        T: ~const Into<!>,
     {
         match self {
             Ok(x) => x.into(),
@@ -2052,7 +2056,8 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "84277", old_name = "try_trait")]
-impl<T, E> ops::Try for Result<T, E> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T, E> const ops::Try for Result<T, E> {
     type Output = T;
     type Residual = Result<convert::Infallible, E>;
 
@@ -2071,7 +2076,10 @@ impl<T, E> ops::Try for Result<T, E> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "84277", old_name = "try_trait")]
-impl<T, E, F: From<E>> ops::FromResidual<Result<convert::Infallible, E>> for Result<T, F> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T, E, F: ~const From<E>> const ops::FromResidual<Result<convert::Infallible, E>>
+    for Result<T, F>
+{
     #[inline]
     #[track_caller]
     fn from_residual(residual: Result<convert::Infallible, E>) -> Self {
@@ -2082,7 +2090,8 @@ impl<T, E, F: From<E>> ops::FromResidual<Result<convert::Infallible, E>> for Res
 }
 #[diagnostic::do_not_recommend]
 #[unstable(feature = "try_trait_v2_yeet", issue = "96374")]
-impl<T, E, F: From<E>> ops::FromResidual<ops::Yeet<E>> for Result<T, F> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T, E, F: ~const From<E>> const ops::FromResidual<ops::Yeet<E>> for Result<T, F> {
     #[inline]
     fn from_residual(ops::Yeet(e): ops::Yeet<E>) -> Self {
         Err(From::from(e))
@@ -2090,6 +2099,7 @@ impl<T, E, F: From<E>> ops::FromResidual<ops::Yeet<E>> for Result<T, F> {
 }
 
 #[unstable(feature = "try_trait_v2_residual", issue = "91285")]
-impl<T, E> ops::Residual<T> for Result<convert::Infallible, E> {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl<T, E> const ops::Residual<T> for Result<convert::Infallible, E> {
     type TryType = Result<T, E>;
 }
diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs
index d0f2b9226bf..1597d1c1fa8 100644
--- a/library/core/src/str/traits.rs
+++ b/library/core/src/str/traits.rs
@@ -825,6 +825,8 @@ unsafe impl const SliceIndex<str> for ops::RangeToInclusive<usize> {
 /// assert!(Point::from_str("(1 2)").is_err());
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
+#[const_trait]
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
 pub trait FromStr: Sized {
     /// The associated error which can be returned from parsing.
     #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
index 04c8d1473b0..546f3d91a80 100644
--- a/library/core/src/sync/atomic.rs
+++ b/library/core/src/sync/atomic.rs
@@ -2518,7 +2518,8 @@ impl<T> AtomicPtr<T> {
 
 #[cfg(target_has_atomic_load_store = "8")]
 #[stable(feature = "atomic_bool_from", since = "1.24.0")]
-impl From<bool> for AtomicBool {
+#[rustc_const_unstable(feature = "const_try", issue = "74935")]
+impl const From<bool> for AtomicBool {
     /// Converts a `bool` into an `AtomicBool`.
     ///
     /// # Examples
@@ -2615,7 +2616,8 @@ macro_rules! atomic_int {
         }
 
         #[$stable_from]
-        impl From<$int_type> for $atomic_type {
+        #[rustc_const_unstable(feature = "const_try", issue = "74935")]
+        impl const From<$int_type> for $atomic_type {
             #[doc = concat!("Converts an `", stringify!($int_type), "` into an `", stringify!($atomic_type), "`.")]
             #[inline]
             fn from(v: $int_type) -> Self { Self::new(v) }
diff --git a/tests/ui/consts/const-try-feature-gate.rs b/tests/ui/consts/const-try-feature-gate.rs
index 09985079e8e..4a98185a18a 100644
--- a/tests/ui/consts/const-try-feature-gate.rs
+++ b/tests/ui/consts/const-try-feature-gate.rs
@@ -4,6 +4,8 @@ const fn t() -> Option<()> {
     Some(())?;
     //~^ ERROR `?` is not allowed
     //~| ERROR `?` is not allowed
+    //~| ERROR `Try` is not yet stable as a const trait
+    //~| ERROR `FromResidual` is not yet stable as a const trait
     None
 }
 
diff --git a/tests/ui/consts/const-try-feature-gate.stderr b/tests/ui/consts/const-try-feature-gate.stderr
index 0ad19d05b38..62a4a5fba4f 100644
--- a/tests/ui/consts/const-try-feature-gate.stderr
+++ b/tests/ui/consts/const-try-feature-gate.stderr
@@ -1,19 +1,47 @@
-error[E0015]: `?` is not allowed on `Option<()>` in constant functions
+error[E0658]: `?` is not allowed on `Option<()>` in constant functions
   --> $DIR/const-try-feature-gate.rs:4:5
    |
 LL |     Some(())?;
    |     ^^^^^^^^^
    |
    = note: calls in constant functions 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[E0015]: `?` is not allowed on `Option<()>` in constant functions
+error: `Try` is not yet stable as a const trait
+  --> $DIR/const-try-feature-gate.rs:4:5
+   |
+LL |     Some(())?;
+   |     ^^^^^^^^^
+   |
+help: add `#![feature(const_try)]` to the crate attributes to enable
+   |
+LL + #![feature(const_try)]
+   |
+
+error[E0658]: `?` is not allowed on `Option<()>` in constant functions
   --> $DIR/const-try-feature-gate.rs:4:5
    |
 LL |     Some(())?;
    |     ^^^^^^^^^
    |
    = note: calls in constant functions 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: `FromResidual` is not yet stable as a const trait
+  --> $DIR/const-try-feature-gate.rs:4:5
+   |
+LL |     Some(())?;
+   |     ^^^^^^^^^
+   |
+help: add `#![feature(const_try)]` to the crate attributes to enable
+   |
+LL + #![feature(const_try)]
+   |
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
-For more information about this error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/const-try.rs b/tests/ui/consts/const-try.rs
index e13fad78441..152400d702e 100644
--- a/tests/ui/consts/const-try.rs
+++ b/tests/ui/consts/const-try.rs
@@ -1,4 +1,6 @@
-//@ compile-flags: -Znext-solver
+//@ check-pass
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
 
 // Demonstrates what's needed to make use of `?` in const contexts.
 
@@ -13,14 +15,12 @@ struct TryMe;
 struct Error;
 
 impl const FromResidual<Error> for TryMe {
-    //~^ ERROR const `impl` for trait `FromResidual` which is not `const`
     fn from_residual(residual: Error) -> Self {
         TryMe
     }
 }
 
 impl const Try for TryMe {
-    //~^ ERROR const `impl` for trait `Try` which is not `const`
     type Output = ();
     type Residual = Error;
     fn from_output(output: Self::Output) -> Self {
@@ -33,8 +33,6 @@ impl const Try for TryMe {
 
 const fn t() -> TryMe {
     TryMe?;
-    //~^ ERROR `?` is not allowed on
-    //~| ERROR `?` is not allowed on
     TryMe
 }
 
diff --git a/tests/ui/consts/const-try.stderr b/tests/ui/consts/const-try.stderr
deleted file mode 100644
index 7004ea3e6db..00000000000
--- a/tests/ui/consts/const-try.stderr
+++ /dev/null
@@ -1,37 +0,0 @@
-error: const `impl` for trait `FromResidual` which is not `const`
-  --> $DIR/const-try.rs:15:12
-   |
-LL | impl const FromResidual<Error> for TryMe {
-   |            ^^^^^^^^^^^^^^^^^^^ this trait is not `const`
-   |
-   = note: marking a trait with `const` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
-error: const `impl` for trait `Try` which is not `const`
-  --> $DIR/const-try.rs:22:12
-   |
-LL | impl const Try for TryMe {
-   |            ^^^ this trait is not `const`
-   |
-   = note: marking a trait with `const` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
-error[E0015]: `?` is not allowed on `TryMe` in constant functions
-  --> $DIR/const-try.rs:35:5
-   |
-LL |     TryMe?;
-   |     ^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: `?` is not allowed on `TryMe` in constant functions
-  --> $DIR/const-try.rs:35:5
-   |
-LL |     TryMe?;
-   |     ^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 4 previous errors
-
-For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/control-flow/try.rs b/tests/ui/consts/control-flow/try.rs
index 67083e1a39b..6d762f9194e 100644
--- a/tests/ui/consts/control-flow/try.rs
+++ b/tests/ui/consts/control-flow/try.rs
@@ -1,11 +1,12 @@
-// The `?` operator is still not const-evaluatable because it calls `From::from` on the error
-// variant.
+//@ check-pass
+
+#![allow(dead_code)]
+#![feature(const_trait_impl)]
+#![feature(const_try)]
 
 const fn opt() -> Option<i32> {
     let x = Some(2);
     x?;
-    //~^ ERROR: `?` is not allowed
-    //~| ERROR: `?` is not allowed
     None
 }
 
diff --git a/tests/ui/consts/control-flow/try.stderr b/tests/ui/consts/control-flow/try.stderr
deleted file mode 100644
index 62a3e3ce6bc..00000000000
--- a/tests/ui/consts/control-flow/try.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0015]: `?` is not allowed on `Option<i32>` in constant functions
-  --> $DIR/try.rs:6:5
-   |
-LL |     x?;
-   |     ^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: `?` is not allowed on `Option<i32>` in constant functions
-  --> $DIR/try.rs:6:5
-   |
-LL |     x?;
-   |     ^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/try-operator.rs b/tests/ui/consts/try-operator.rs
index 352dbeefa8a..59d9fcb1cbd 100644
--- a/tests/ui/consts/try-operator.rs
+++ b/tests/ui/consts/try-operator.rs
@@ -1,9 +1,8 @@
-//@ known-bug: #110395
+//@ run-pass
 
 #![feature(try_trait_v2)]
 #![feature(const_trait_impl)]
 #![feature(const_try)]
-#![feature(const_convert)]
 
 fn main() {
     const fn result() -> Result<bool, ()> {
diff --git a/tests/ui/consts/try-operator.stderr b/tests/ui/consts/try-operator.stderr
deleted file mode 100644
index fc37039d260..00000000000
--- a/tests/ui/consts/try-operator.stderr
+++ /dev/null
@@ -1,42 +0,0 @@
-error[E0635]: unknown feature `const_convert`
-  --> $DIR/try-operator.rs:6:12
-   |
-LL | #![feature(const_convert)]
-   |            ^^^^^^^^^^^^^
-
-error[E0015]: `?` is not allowed on `Result<(), ()>` in constant functions
-  --> $DIR/try-operator.rs:10:9
-   |
-LL |         Err(())?;
-   |         ^^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: `?` is not allowed on `Result<bool, ()>` in constant functions
-  --> $DIR/try-operator.rs:10:9
-   |
-LL |         Err(())?;
-   |         ^^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: `?` is not allowed on `Option<()>` in constant functions
-  --> $DIR/try-operator.rs:18:9
-   |
-LL |         None?;
-   |         ^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: `?` is not allowed on `Option<()>` in constant functions
-  --> $DIR/try-operator.rs:18:9
-   |
-LL |         None?;
-   |         ^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 5 previous errors
-
-Some errors have detailed explanations: E0015, E0635.
-For more information about an error, try `rustc --explain E0015`.
diff --git a/tests/ui/traits/const-traits/hir-const-check.rs b/tests/ui/traits/const-traits/hir-const-check.rs
index c485fb12184..1b6fa1afab9 100644
--- a/tests/ui/traits/const-traits/hir-const-check.rs
+++ b/tests/ui/traits/const-traits/hir-const-check.rs
@@ -1,8 +1,10 @@
+//@ check-pass
 //@ compile-flags: -Znext-solver
 
 // Regression test for #69615.
 
 #![feature(const_trait_impl)]
+#![feature(const_try)]
 
 #[const_trait]
 pub trait MyTrait {
@@ -12,8 +14,6 @@ pub trait MyTrait {
 impl const MyTrait for () {
     fn method(&self) -> Option<()> {
         Some(())?;
-        //~^ ERROR `?` is not allowed on
-        //~| ERROR `?` is not allowed on
         None
     }
 }
diff --git a/tests/ui/traits/const-traits/hir-const-check.stderr b/tests/ui/traits/const-traits/hir-const-check.stderr
deleted file mode 100644
index d66a7ea3144..00000000000
--- a/tests/ui/traits/const-traits/hir-const-check.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0015]: `?` is not allowed on `Option<()>` in constant functions
-  --> $DIR/hir-const-check.rs:14:9
-   |
-LL |         Some(())?;
-   |         ^^^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: `?` is not allowed on `Option<()>` in constant functions
-  --> $DIR/hir-const-check.rs:14:9
-   |
-LL |         Some(())?;
-   |         ^^^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs
index 47c85980aca..af552ac0c5e 100644
--- a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs
+++ b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs
@@ -1,11 +1,10 @@
 #![allow(incomplete_features)]
-#![feature(const_trait_impl, try_trait_v2)]
+#![feature(const_trait_impl, const_try, try_trait_v2)]
 
 use std::ops::FromResidual;
 
 impl<T> const FromResidual for T {
-    //~^ ERROR const `impl` for trait `FromResidual` which is not `const`
-    //~| ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
     fn from_residual(t: T) -> _ {
         //~^ ERROR the placeholder `_` is not allowed
         t
diff --git a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr
index 5c5fba95f02..08fc73fe77b 100644
--- a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr
+++ b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr
@@ -1,12 +1,3 @@
-error: const `impl` for trait `FromResidual` which is not `const`
-  --> $DIR/ice-119717-constant-lifetime.rs:6:15
-   |
-LL | impl<T> const FromResidual for T {
-   |               ^^^^^^^^^^^^ this trait is not `const`
-   |
-   = note: marking a trait with `const` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
 error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
   --> $DIR/ice-119717-constant-lifetime.rs:6:6
    |
@@ -17,7 +8,7 @@ LL | impl<T> const FromResidual for T {
    = note: only traits defined in the current crate can be implemented for a type parameter
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for associated functions
-  --> $DIR/ice-119717-constant-lifetime.rs:9:31
+  --> $DIR/ice-119717-constant-lifetime.rs:8:31
    |
 LL |     fn from_residual(t: T) -> _ {
    |                               ^ not allowed in type signatures
@@ -28,7 +19,7 @@ LL -     fn from_residual(t: T) -> _ {
 LL +     fn from_residual(t: T) -> T {
    |
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
 Some errors have detailed explanations: E0121, E0210.
 For more information about an error, try `rustc --explain E0121`.
diff --git a/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.rs b/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.rs
index 5e368b9e6a9..bfce9dc9c73 100644
--- a/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.rs
+++ b/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.rs
@@ -6,20 +6,16 @@ struct TryMe;
 struct Error;
 
 impl const FromResidual<Error> for TryMe {}
-//~^ ERROR const `impl` for trait `FromResidual` which is not `const`
-//~| ERROR not all trait items implemented
+//~^ ERROR not all trait items implemented
 
 impl const Try for TryMe {
-    //~^ ERROR const `impl` for trait `Try` which is not `const`
-    //~| ERROR not all trait items implemented
+    //~^ ERROR not all trait items implemented
     type Output = ();
     type Residual = Error;
 }
 
 const fn t() -> TryMe {
     TryMe?;
-    //~^ ERROR `?` is not allowed on
-    //~| ERROR `?` is not allowed on
     TryMe
 }
 
diff --git a/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.stderr b/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.stderr
index 849d6522cd6..183203aa8ba 100644
--- a/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.stderr
+++ b/tests/ui/traits/const-traits/ice-126148-failed-to-normalize.stderr
@@ -1,12 +1,3 @@
-error: const `impl` for trait `FromResidual` which is not `const`
-  --> $DIR/ice-126148-failed-to-normalize.rs:8:12
-   |
-LL | impl const FromResidual<Error> for TryMe {}
-   |            ^^^^^^^^^^^^^^^^^^^ this trait is not `const`
-   |
-   = note: marking a trait with `const` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
 error[E0046]: not all trait items implemented, missing: `from_residual`
   --> $DIR/ice-126148-failed-to-normalize.rs:8:1
    |
@@ -15,17 +6,8 @@ LL | impl const FromResidual<Error> for TryMe {}
    |
    = help: implement the missing item: `fn from_residual(_: Error) -> Self { todo!() }`
 
-error: const `impl` for trait `Try` which is not `const`
-  --> $DIR/ice-126148-failed-to-normalize.rs:12:12
-   |
-LL | impl const Try for TryMe {
-   |            ^^^ this trait is not `const`
-   |
-   = note: marking a trait with `const` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
 error[E0046]: not all trait items implemented, missing: `from_output`, `branch`
-  --> $DIR/ice-126148-failed-to-normalize.rs:12:1
+  --> $DIR/ice-126148-failed-to-normalize.rs:11:1
    |
 LL | impl const Try for TryMe {
    | ^^^^^^^^^^^^^^^^^^^^^^^^ missing `from_output`, `branch` in implementation
@@ -33,23 +15,6 @@ LL | impl const Try for TryMe {
    = help: implement the missing item: `fn from_output(_: <Self as Try>::Output) -> Self { todo!() }`
    = help: implement the missing item: `fn branch(self) -> ControlFlow<<Self as Try>::Residual, <Self as Try>::Output> { todo!() }`
 
-error[E0015]: `?` is not allowed on `TryMe` in constant functions
-  --> $DIR/ice-126148-failed-to-normalize.rs:20:5
-   |
-LL |     TryMe?;
-   |     ^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: `?` is not allowed on `TryMe` in constant functions
-  --> $DIR/ice-126148-failed-to-normalize.rs:20:5
-   |
-LL |     TryMe?;
-   |     ^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 6 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0015, E0046.
-For more information about an error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/traits/const-traits/trait-default-body-stability.rs b/tests/ui/traits/const-traits/trait-default-body-stability.rs
index 567f1b3c284..a8157d37ce3 100644
--- a/tests/ui/traits/const-traits/trait-default-body-stability.rs
+++ b/tests/ui/traits/const-traits/trait-default-body-stability.rs
@@ -1,4 +1,4 @@
-//@ known-bug: #110395
+//@ check-pass
 //@ compile-flags: -Znext-solver
 #![allow(incomplete_features)]
 #![feature(staged_api)]
diff --git a/tests/ui/traits/const-traits/trait-default-body-stability.stderr b/tests/ui/traits/const-traits/trait-default-body-stability.stderr
deleted file mode 100644
index b995d6f4f3d..00000000000
--- a/tests/ui/traits/const-traits/trait-default-body-stability.stderr
+++ /dev/null
@@ -1,37 +0,0 @@
-error: const `impl` for trait `Try` which is not `const`
-  --> $DIR/trait-default-body-stability.rs:19:12
-   |
-LL | impl const Try for T {
-   |            ^^^ this trait is not `const`
-   |
-   = note: marking a trait with `const` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
-error: const `impl` for trait `FromResidual` which is not `const`
-  --> $DIR/trait-default-body-stability.rs:34:12
-   |
-LL | impl const FromResidual for T {
-   |            ^^^^^^^^^^^^ this trait is not `const`
-   |
-   = note: marking a trait with `const` ensures all default method bodies are `const`
-   = note: adding a non-const method body in the future would be a breaking change
-
-error[E0015]: `?` is not allowed on `T` in constant functions
-  --> $DIR/trait-default-body-stability.rs:46:9
-   |
-LL |         T?
-   |         ^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: `?` is not allowed on `T` in constant functions
-  --> $DIR/trait-default-body-stability.rs:46:9
-   |
-LL |         T?
-   |         ^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 4 previous errors
-
-For more information about this error, try `rustc --explain E0015`.
-- 
cgit 1.4.1-3-g733a5


From c193f3039f561aad497fdaced3f320bd889bdb0d Mon Sep 17 00:00:00 2001
From: Maksim Bondarenkov <maksapple2306@gmail.com>
Date: Mon, 21 Jul 2025 15:47:37 +0300
Subject: opt-dist: make `artifact-dir` an absolute path for `opt-dist local`

...like for CI environments. the same logic applied as for `build_dir`. fixes the issue where some
intermediate steps fail due to path being relative to an active directory
---
 src/tools/opt-dist/src/main.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/opt-dist/src/main.rs b/src/tools/opt-dist/src/main.rs
index d0e6badede6..42170ff39d7 100644
--- a/src/tools/opt-dist/src/main.rs
+++ b/src/tools/opt-dist/src/main.rs
@@ -62,7 +62,7 @@ enum EnvironmentCmd {
         python: String,
 
         /// Directory where artifacts (like PGO profiles or rustc-perf) of this workflow
-        /// will be stored.
+        /// will be stored. Relative to `checkout_dir`
         #[arg(long, default_value = "opt-artifacts")]
         artifact_dir: Utf8PathBuf,
 
@@ -150,7 +150,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
                 .python_binary(python)
                 .checkout_dir(checkout_dir.clone())
                 .host_llvm_dir(llvm_dir)
-                .artifact_dir(artifact_dir)
+                .artifact_dir(checkout_dir.join(artifact_dir))
                 .build_dir(checkout_dir.join(build_dir))
                 .prebuilt_rustc_perf(rustc_perf_checkout_dir)
                 .shared_llvm(llvm_shared)
-- 
cgit 1.4.1-3-g733a5


From fa924641d67a510a1101b79bbc2cea4f5360135e Mon Sep 17 00:00:00 2001
From: Maksim Bondarenkov <maksapple2306@gmail.com>
Date: Mon, 21 Jul 2025 15:58:38 +0300
Subject: opt-dist: add an option for setting path to stage0 root

in MSYS2 we have problems with stage0 for *-gnullvm hosts because prebuilt dist tarballs will be
available starting from 1.90.0-beta. also this change helps to match bootstrap.toml config
---
 src/tools/opt-dist/src/environment.rs | 16 ++++++++--------
 src/tools/opt-dist/src/main.rs        |  6 ++++++
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/tools/opt-dist/src/environment.rs b/src/tools/opt-dist/src/environment.rs
index e6e4c711c0c..2cae0785f33 100644
--- a/src/tools/opt-dist/src/environment.rs
+++ b/src/tools/opt-dist/src/environment.rs
@@ -28,6 +28,8 @@ pub struct Environment {
     run_tests: bool,
     fast_try_build: bool,
     build_llvm: bool,
+    #[builder(default)]
+    stage0_root: Option<Utf8PathBuf>,
 }
 
 impl Environment {
@@ -56,17 +58,11 @@ impl Environment {
     }
 
     pub fn cargo_stage_0(&self) -> Utf8PathBuf {
-        self.build_artifacts()
-            .join("stage0")
-            .join("bin")
-            .join(format!("cargo{}", executable_extension()))
+        self.stage0().join("bin").join(format!("cargo{}", executable_extension()))
     }
 
     pub fn rustc_stage_0(&self) -> Utf8PathBuf {
-        self.build_artifacts()
-            .join("stage0")
-            .join("bin")
-            .join(format!("rustc{}", executable_extension()))
+        self.stage0().join("bin").join(format!("rustc{}", executable_extension()))
     }
 
     pub fn rustc_stage_2(&self) -> Utf8PathBuf {
@@ -116,6 +112,10 @@ impl Environment {
     pub fn build_llvm(&self) -> bool {
         self.build_llvm
     }
+
+    pub fn stage0(&self) -> Utf8PathBuf {
+        self.stage0_root.clone().unwrap_or_else(|| self.build_artifacts().join("stage0"))
+    }
 }
 
 /// What is the extension of binary executables on this platform?
diff --git a/src/tools/opt-dist/src/main.rs b/src/tools/opt-dist/src/main.rs
index d0e6badede6..f46a86f507c 100644
--- a/src/tools/opt-dist/src/main.rs
+++ b/src/tools/opt-dist/src/main.rs
@@ -107,6 +107,10 @@ enum EnvironmentCmd {
         /// in bootstrap.toml via `build.build-dir` option
         #[arg(long, default_value = "build")]
         build_dir: Utf8PathBuf,
+
+        /// Path to custom stage0 root
+        #[arg(long)]
+        stage0_root: Option<Utf8PathBuf>,
     },
     /// Perform an optimized build on Linux CI, from inside Docker.
     LinuxCi {
@@ -144,6 +148,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
             run_tests,
             build_llvm,
             build_dir,
+            stage0_root,
         } => {
             let env = EnvironmentBuilder::default()
                 .host_tuple(target_triple)
@@ -160,6 +165,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
                 .run_tests(run_tests)
                 .fast_try_build(is_fast_try_build)
                 .build_llvm(build_llvm)
+                .stage0_root(stage0_root)
                 .build()?;
 
             (env, shared.build_args)
-- 
cgit 1.4.1-3-g733a5


From 4ca5afdc7ac807da8e1beac0813515cc36ef1ac0 Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Fri, 18 Jul 2025 17:09:29 +0530
Subject: add default_lld_opt_in_targets method and modified test accordingly

add test for lld opt in and also add thread_local defined state to change opt in targets

make the config lld test parameter smoother to work, and have no_llvm_config set even when target_config is not present
---
 src/bootstrap/src/core/builder/tests.rs    | 25 +++++++++++++++++++++++--
 src/bootstrap/src/core/config/toml/rust.rs | 30 ++++++++++++++++++++++++++++--
 2 files changed, 51 insertions(+), 4 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 7f0c6fbd854..81a526593b4 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -642,6 +642,7 @@ mod snapshot {
     };
     use crate::core::builder::{Builder, Kind, StepDescription, StepMetadata};
     use crate::core::config::TargetSelection;
+    use crate::core::config::toml::rust::with_lld_opt_in_targets;
     use crate::utils::cache::Cache;
     use crate::utils::helpers::get_host_target;
     use crate::utils::tests::{ConfigBuilder, TestCtx};
@@ -1638,12 +1639,33 @@ mod snapshot {
                 .render_steps(), @r"
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
-        [build] rustc 0 <host> -> LldWrapper 1 <host>
         [build] rustdoc 0 <host>
         [doc] std 1 <host> crates=[core]
         ");
     }
 
+    #[test]
+    fn test_lld_opt_in() {
+        let target: &'static str = Box::leak(Box::new(host_target()));
+        let slice: &'static [&'static str] = Box::leak(Box::new([target]));
+
+        with_lld_opt_in_targets(slice, || {
+            let ctx = TestCtx::new();
+
+            insta::assert_snapshot!(
+                ctx.config("doc")
+                    .path("core")
+                    .override_target_no_std(&host_target())
+                    .render_steps(), @r"
+            [build] llvm <host>
+            [build] rustc 0 <host> -> rustc 1 <host>
+            [build] rustc 0 <host> -> LldWrapper 1 <host>
+            [build] rustdoc 0 <host>
+            [doc] std 1 <host> crates=[core]
+            ");
+        });
+    }
+
     #[test]
     fn doc_library_no_std_target() {
         let ctx = TestCtx::new();
@@ -1654,7 +1676,6 @@ mod snapshot {
                 .render_steps(), @r"
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
-        [build] rustc 0 <host> -> LldWrapper 1 <host>
         [build] rustdoc 0 <host>
         [doc] std 1 <host> crates=[alloc,core]
         ");
diff --git a/src/bootstrap/src/core/config/toml/rust.rs b/src/bootstrap/src/core/config/toml/rust.rs
index 307aa52294b..60484ee9e90 100644
--- a/src/bootstrap/src/core/config/toml/rust.rs
+++ b/src/bootstrap/src/core/config/toml/rust.rs
@@ -410,6 +410,31 @@ pub(crate) fn validate_codegen_backends(backends: Vec<String>, section: &str) ->
     backends
 }
 
+#[cfg(not(test))]
+fn default_lld_opt_in_targets() -> Vec<String> {
+    vec!["x86_64-unknown-linux-gnu".to_string()]
+}
+
+#[cfg(test)]
+thread_local! {
+    static TEST_LLD_OPT_IN_TARGETS: std::cell::RefCell<Option<Vec<String>>> = std::cell::RefCell::new(None);
+}
+
+#[cfg(test)]
+fn default_lld_opt_in_targets() -> Vec<String> {
+    TEST_LLD_OPT_IN_TARGETS.with(|cell| cell.borrow().clone()).unwrap_or_default()
+}
+
+#[cfg(test)]
+pub fn with_lld_opt_in_targets<R>(targets: Vec<String>, f: impl FnOnce() -> R) -> R {
+    TEST_LLD_OPT_IN_TARGETS.with(|cell| {
+        let prev = cell.replace(Some(targets));
+        let result = f();
+        cell.replace(prev);
+        result
+    })
+}
+
 impl Config {
     pub fn apply_rust_config(&mut self, toml_rust: Option<Rust>, warnings: Warnings) {
         let mut debug = None;
@@ -609,12 +634,13 @@ impl Config {
         //   thus, disabled
         // - similarly, lld will not be built nor used by default when explicitly asked not to, e.g.
         //   when the config sets `rust.lld = false`
-        if self.host_target.triple == "x86_64-unknown-linux-gnu" && self.hosts == [self.host_target]
+        if default_lld_opt_in_targets().contains(&self.host_target.triple.to_string())
+            && self.hosts == [self.host_target]
         {
             let no_llvm_config = self
                 .target_config
                 .get(&self.host_target)
-                .is_some_and(|target_config| target_config.llvm_config.is_none());
+                .is_none_or(|target_config| target_config.llvm_config.is_none());
             let enable_lld = self.llvm_from_ci || no_llvm_config;
             // Prefer the config setting in case an explicit opt-out is needed.
             self.lld_enabled = lld_enabled.unwrap_or(enable_lld);
-- 
cgit 1.4.1-3-g733a5


From fb10084b84b23e042c8888490c771ae5a315cfab Mon Sep 17 00:00:00 2001
From: bit-aloo <sshourya17@gmail.com>
Date: Mon, 21 Jul 2025 20:10:58 +0530
Subject: add test_lld_opt_in test

---
 src/bootstrap/src/core/builder/tests.rs | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 81a526593b4..4cc57996f3f 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -1646,22 +1646,15 @@ mod snapshot {
 
     #[test]
     fn test_lld_opt_in() {
-        let target: &'static str = Box::leak(Box::new(host_target()));
-        let slice: &'static [&'static str] = Box::leak(Box::new([target]));
-
-        with_lld_opt_in_targets(slice, || {
+        with_lld_opt_in_targets(vec![host_target()], || {
             let ctx = TestCtx::new();
-
             insta::assert_snapshot!(
-                ctx.config("doc")
-                    .path("core")
-                    .override_target_no_std(&host_target())
+                ctx.config("build")
+                    .path("compiler")
                     .render_steps(), @r"
             [build] llvm <host>
             [build] rustc 0 <host> -> rustc 1 <host>
             [build] rustc 0 <host> -> LldWrapper 1 <host>
-            [build] rustdoc 0 <host>
-            [doc] std 1 <host> crates=[core]
             ");
         });
     }
-- 
cgit 1.4.1-3-g733a5


From b5d36e5294d3354ad8feec86b27c698e368c88a6 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 21 Jul 2025 16:07:12 +0000
Subject: Dont ICE on copy error being suppressed due to overflow

---
 compiler/rustc_borrowck/src/diagnostics/move_errors.rs |  9 +++++----
 tests/ui/borrowck/copy-overflow.rs                     | 16 ++++++++++++++++
 tests/ui/borrowck/copy-overflow.stderr                 | 15 +++++++++++++++
 3 files changed, 36 insertions(+), 4 deletions(-)
 create mode 100644 tests/ui/borrowck/copy-overflow.rs
 create mode 100644 tests/ui/borrowck/copy-overflow.stderr

diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
index 92ca868eb99..447bf7d091a 100644
--- a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
@@ -303,10 +303,11 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     }
 
     fn has_ambiguous_copy(&mut self, ty: Ty<'tcx>) -> bool {
-        let Some(copy_trait_def) = self.infcx.tcx.lang_items().copy_trait() else { return false };
-        // This is only going to be ambiguous if there are incoherent impls, because otherwise
-        // ambiguity should never happen in MIR.
-        self.infcx.type_implements_trait(copy_trait_def, [ty], self.infcx.param_env).may_apply()
+        let Some(copy_def_id) = self.infcx.tcx.lang_items().copy_trait() else { return false };
+
+        // Avoid bogus move errors because of an incoherent `Copy` impl.
+        self.infcx.type_implements_trait(copy_def_id, [ty], self.infcx.param_env).may_apply()
+            && self.infcx.tcx.coherent_trait(copy_def_id).is_err()
     }
 
     fn report_cannot_move_from_static(&mut self, place: Place<'tcx>, span: Span) -> Diag<'infcx> {
diff --git a/tests/ui/borrowck/copy-overflow.rs b/tests/ui/borrowck/copy-overflow.rs
new file mode 100644
index 00000000000..5aa1afdee68
--- /dev/null
+++ b/tests/ui/borrowck/copy-overflow.rs
@@ -0,0 +1,16 @@
+// Regression test for <https://github.com/rust-lang/rust/issues/144165>.
+
+// We were previously suppressing the copy error in the `Clone` impl because we assumed
+// that the only way we get `Copy` ambiguity errors was due to incoherent impls. This is
+// not true, since ambiguities can be encountered due to overflows (among other ways).
+
+struct S<T: 'static>(Option<&'static T>);
+
+impl<T: 'static> Copy for S<T> where S<T>: Copy + Clone {}
+impl<T: 'static> Clone for S<T> {
+    fn clone(&self) -> Self {
+        *self
+        //~^ ERROR cannot move out of `*self` which is behind a shared reference
+    }
+}
+fn main() {}
diff --git a/tests/ui/borrowck/copy-overflow.stderr b/tests/ui/borrowck/copy-overflow.stderr
new file mode 100644
index 00000000000..3f601276f8f
--- /dev/null
+++ b/tests/ui/borrowck/copy-overflow.stderr
@@ -0,0 +1,15 @@
+error[E0507]: cannot move out of `*self` which is behind a shared reference
+  --> $DIR/copy-overflow.rs:12:9
+   |
+LL |         *self
+   |         ^^^^^ move occurs because `*self` has type `S<T>`, which does not implement the `Copy` trait
+   |
+help: consider cloning the value if the performance cost is acceptable
+   |
+LL -         *self
+LL +         self.clone()
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0507`.
-- 
cgit 1.4.1-3-g733a5


From 3c81faec23161d3f997666e90e6e34747ace6d28 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 3 Jul 2025 22:24:21 +0000
Subject: Implement AST visitors using a derive macro.

---
 compiler/rustc_ast/src/ast.rs          |  285 ++--
 compiler/rustc_ast/src/format.rs       |   20 +-
 compiler/rustc_ast/src/mut_visit.rs    |  259 +++-
 compiler/rustc_ast/src/tokenstream.rs  |    4 +-
 compiler/rustc_ast/src/visit.rs        | 2235 +++++++++++---------------------
 compiler/rustc_macros/src/lib.rs       |   11 +
 compiler/rustc_macros/src/visitable.rs |   82 ++
 7 files changed, 1220 insertions(+), 1676 deletions(-)
 create mode 100644 compiler/rustc_macros/src/visitable.rs

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 8c2b521c560..97e07095875 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -28,7 +28,7 @@ use rustc_data_structures::packed::Pu128;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_data_structures::tagged_ptr::Tag;
-use rustc_macros::{Decodable, Encodable, HashStable_Generic};
+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};
@@ -39,6 +39,7 @@ use crate::ptr::P;
 use crate::token::{self, CommentKind, Delimiter};
 use crate::tokenstream::{DelimSpan, LazyAttrTokenStream, TokenStream};
 use crate::util::parser::{ExprPrecedence, Fixity};
+use crate::visit::{AssocCtxt, BoundKind, LifetimeCtxt};
 
 /// A "Label" is an identifier of some point in sources,
 /// e.g. in the following code:
@@ -50,7 +51,7 @@ use crate::util::parser::{ExprPrecedence, Fixity};
 /// ```
 ///
 /// `'outer` is a label.
-#[derive(Clone, Encodable, Decodable, Copy, HashStable_Generic, Eq, PartialEq)]
+#[derive(Clone, Encodable, Decodable, Copy, HashStable_Generic, Eq, PartialEq, Walkable)]
 pub struct Label {
     pub ident: Ident,
 }
@@ -63,7 +64,7 @@ impl fmt::Debug for Label {
 
 /// A "Lifetime" is an annotation of the scope in which variable
 /// can be used, e.g. `'a` in `&'a i32`.
-#[derive(Clone, Encodable, Decodable, Copy, PartialEq, Eq, Hash)]
+#[derive(Clone, Encodable, Decodable, Copy, PartialEq, Eq, Hash, Walkable)]
 pub struct Lifetime {
     pub id: NodeId,
     pub ident: Ident,
@@ -87,7 +88,7 @@ impl fmt::Display for Lifetime {
 /// along with a bunch of supporting information.
 ///
 /// E.g., `std::cmp::PartialEq`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Path {
     pub span: Span,
     /// The segments in the path: the things separated by `::`.
@@ -211,7 +212,7 @@ pub fn join_path_idents(path: impl IntoIterator<Item = impl Borrow<Ident>>) -> S
 /// A segment of a path: an identifier, an optional lifetime, and a set of types.
 ///
 /// E.g., `std`, `String` or `Box<T>`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct PathSegment {
     /// The identifier portion of this path segment.
     pub ident: Ident,
@@ -255,7 +256,7 @@ impl PathSegment {
 /// The generic arguments and associated item constraints of a path segment.
 ///
 /// E.g., `<A, B>` as in `Foo<A, B>` or `(A, B)` as in `Foo(A, B)`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum GenericArgs {
     /// The `<'a, A, B, C>` in `foo::bar::baz::<'a, A, B, C>`.
     AngleBracketed(AngleBracketedArgs),
@@ -280,10 +281,10 @@ impl GenericArgs {
 }
 
 /// Concrete argument in the sequence of generic args.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum GenericArg {
     /// `'a` in `Foo<'a>`.
-    Lifetime(Lifetime),
+    Lifetime(#[visitable(extra = LifetimeCtxt::GenericArg)] Lifetime),
     /// `Bar` in `Foo<Bar>`.
     Type(P<Ty>),
     /// `1` in `Foo<1>`.
@@ -301,7 +302,7 @@ impl GenericArg {
 }
 
 /// A path like `Foo<'a, T>`.
-#[derive(Clone, Encodable, Decodable, Debug, Default)]
+#[derive(Clone, Encodable, Decodable, Debug, Default, Walkable)]
 pub struct AngleBracketedArgs {
     /// The overall span.
     pub span: Span,
@@ -310,7 +311,7 @@ pub struct AngleBracketedArgs {
 }
 
 /// Either an argument for a generic parameter or a constraint on an associated item.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum AngleBracketedArg {
     /// A generic argument for a generic parameter.
     Arg(GenericArg),
@@ -340,7 +341,7 @@ impl From<ParenthesizedArgs> for P<GenericArgs> {
 }
 
 /// A path like `Foo(A, B) -> C`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct ParenthesizedArgs {
     /// ```text
     /// Foo(A, B) -> C
@@ -376,7 +377,7 @@ impl ParenthesizedArgs {
 pub use crate::node_id::{CRATE_NODE_ID, DUMMY_NODE_ID, NodeId};
 
 /// Modifiers on a trait bound like `[const]`, `?` and `!`.
-#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug, Walkable)]
 pub struct TraitBoundModifiers {
     pub constness: BoundConstness,
     pub asyncness: BoundAsyncness,
@@ -391,10 +392,10 @@ impl TraitBoundModifiers {
     };
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum GenericBound {
     Trait(PolyTraitRef),
-    Outlives(Lifetime),
+    Outlives(#[visitable(extra = LifetimeCtxt::Bound)] Lifetime),
     /// Precise capturing syntax: `impl Sized + use<'a>`
     Use(ThinVec<PreciseCapturingArg>, Span),
 }
@@ -429,7 +430,7 @@ impl fmt::Display for ParamKindOrd {
     }
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum GenericParamKind {
     /// A lifetime definition (e.g., `'a: 'b + 'c + 'd`).
     Lifetime,
@@ -445,11 +446,12 @@ pub enum GenericParamKind {
     },
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct GenericParam {
     pub id: NodeId,
     pub ident: Ident,
     pub attrs: AttrVec,
+    #[visitable(extra = BoundKind::Bound)]
     pub bounds: GenericBounds,
     pub is_placeholder: bool,
     pub kind: GenericParamKind,
@@ -470,7 +472,7 @@ impl GenericParam {
 
 /// Represents lifetime, type and const parameters attached to a declaration of
 /// a function, enum, trait, etc.
-#[derive(Clone, Encodable, Decodable, Debug, Default)]
+#[derive(Clone, Encodable, Decodable, Debug, Default, Walkable)]
 pub struct Generics {
     pub params: ThinVec<GenericParam>,
     pub where_clause: WhereClause,
@@ -478,7 +480,7 @@ pub struct Generics {
 }
 
 /// A where-clause in a definition.
-#[derive(Clone, Encodable, Decodable, Debug, Default)]
+#[derive(Clone, Encodable, Decodable, Debug, Default, Walkable)]
 pub struct WhereClause {
     /// `true` if we ate a `where` token.
     ///
@@ -496,7 +498,7 @@ impl WhereClause {
 }
 
 /// A single predicate in a where-clause.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct WherePredicate {
     pub attrs: AttrVec,
     pub kind: WherePredicateKind,
@@ -506,7 +508,7 @@ pub struct WherePredicate {
 }
 
 /// Predicate kind in where-clause.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum WherePredicateKind {
     /// A type bound (e.g., `for<'c> Foo: Send + Clone + 'c`).
     BoundPredicate(WhereBoundPredicate),
@@ -519,42 +521,45 @@ pub enum WherePredicateKind {
 /// A type bound.
 ///
 /// E.g., `for<'c> Foo: Send + Clone + 'c`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct WhereBoundPredicate {
     /// Any generics from a `for` binding.
     pub bound_generic_params: ThinVec<GenericParam>,
     /// The type being bounded.
     pub bounded_ty: P<Ty>,
     /// Trait and lifetime bounds (`Clone + Send + 'static`).
+    #[visitable(extra = BoundKind::Bound)]
     pub bounds: GenericBounds,
 }
 
 /// A lifetime predicate.
 ///
 /// E.g., `'a: 'b + 'c`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct WhereRegionPredicate {
+    #[visitable(extra = LifetimeCtxt::Bound)]
     pub lifetime: Lifetime,
+    #[visitable(extra = BoundKind::Bound)]
     pub bounds: GenericBounds,
 }
 
 /// An equality predicate (unsupported).
 ///
 /// E.g., `T = int`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct WhereEqPredicate {
     pub lhs_ty: P<Ty>,
     pub rhs_ty: P<Ty>,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Crate {
-    pub attrs: AttrVec,
-    pub items: ThinVec<P<Item>>,
-    pub spans: ModSpans,
     /// Must be equal to `CRATE_NODE_ID` after the crate root is expanded, but may hold
     /// expansion placeholders or an unassigned value (`DUMMY_NODE_ID`) before that.
     pub id: NodeId,
+    pub attrs: AttrVec,
+    pub items: ThinVec<P<Item>>,
+    pub spans: ModSpans,
     pub is_placeholder: bool,
 }
 
@@ -608,7 +613,7 @@ pub enum MetaItemInner {
 /// A block (`{ .. }`).
 ///
 /// E.g., `{ .. }` as in `fn foo() { .. }`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Block {
     /// The statements in the block.
     pub stmts: ThinVec<Stmt>,
@@ -622,7 +627,7 @@ pub struct Block {
 /// A match pattern.
 ///
 /// Patterns appear in match statements and some other contexts, such as `let` and `if let`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Pat {
     pub id: NodeId,
     pub kind: PatKind,
@@ -770,7 +775,7 @@ impl From<P<Pat>> for Pat {
 /// Patterns like the fields of `Foo { x, ref y, ref mut z }`
 /// are treated the same as `x: x, y: ref y, z: ref mut z`,
 /// except when `is_shorthand` is true.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct PatField {
     /// The identifier for the field.
     pub ident: Ident,
@@ -784,7 +789,7 @@ pub struct PatField {
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-#[derive(Encodable, Decodable, HashStable_Generic)]
+#[derive(Encodable, Decodable, HashStable_Generic, Walkable)]
 pub enum ByRef {
     Yes(Mutability),
     No,
@@ -806,7 +811,7 @@ impl ByRef {
 /// `.0` is the by-reference mode (`ref`, `ref mut`, or by value),
 /// `.1` is the mutability of the binding.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-#[derive(Encodable, Decodable, HashStable_Generic)]
+#[derive(Encodable, Decodable, HashStable_Generic, Walkable)]
 pub struct BindingMode(pub ByRef, pub Mutability);
 
 impl BindingMode {
@@ -829,7 +834,7 @@ impl BindingMode {
     }
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum RangeEnd {
     /// `..=` or `...`
     Included(RangeSyntax),
@@ -837,7 +842,7 @@ pub enum RangeEnd {
     Excluded,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum RangeSyntax {
     /// `...`
     DotDotDot,
@@ -848,7 +853,7 @@ pub enum RangeSyntax {
 /// All the different flavors of pattern that Rust recognizes.
 //
 // Adding a new variant? Please update `test_pat` in `tests/ui/macros/stringify.rs`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum PatKind {
     /// A missing pattern, e.g. for an anonymous param in a bare fn like `fn f(u32)`.
     Missing,
@@ -930,7 +935,7 @@ pub enum PatKind {
 }
 
 /// Whether the `..` is present in a struct fields pattern.
-#[derive(Clone, Copy, Encodable, Decodable, Debug, PartialEq)]
+#[derive(Clone, Copy, Encodable, Decodable, Debug, PartialEq, Walkable)]
 pub enum PatFieldsRest {
     /// `module::StructName { field, ..}`
     Rest,
@@ -943,7 +948,7 @@ pub enum PatFieldsRest {
 /// The kind of borrow in an `AddrOf` expression,
 /// e.g., `&place` or `&raw const place`.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
-#[derive(Encodable, Decodable, HashStable_Generic)]
+#[derive(Encodable, Decodable, HashStable_Generic, Walkable)]
 pub enum BorrowKind {
     /// A normal borrow, `&$expr` or `&mut $expr`.
     /// The resulting type is either `&'a T` or `&'a mut T`
@@ -959,7 +964,7 @@ pub enum BorrowKind {
     Pin,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)]
+#[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable, HashStable_Generic, Walkable)]
 pub enum BinOpKind {
     /// The `+` operator (addition)
     Add,
@@ -1089,7 +1094,7 @@ impl From<AssignOpKind> for BinOpKind {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)]
+#[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable, HashStable_Generic, Walkable)]
 pub enum AssignOpKind {
     /// The `+=` operator (addition)
     AddAssign,
@@ -1141,7 +1146,7 @@ pub type AssignOp = Spanned<AssignOpKind>;
 /// Unary operator.
 ///
 /// Note that `&data` is not an operator, it's an `AddrOf` expression.
-#[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)]
+#[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable, HashStable_Generic, Walkable)]
 pub enum UnOp {
     /// The `*` operator for dereferencing
     Deref,
@@ -1215,7 +1220,7 @@ impl Stmt {
 }
 
 // Adding a new variant? Please update `test_stmt` in `tests/ui/macros/stringify.rs`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum StmtKind {
     /// A local (let) binding.
     Let(P<Local>),
@@ -1231,7 +1236,7 @@ pub enum StmtKind {
     MacCall(P<MacCallStmt>),
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct MacCallStmt {
     pub mac: P<MacCall>,
     pub style: MacStmtStyle,
@@ -1239,7 +1244,7 @@ pub struct MacCallStmt {
     pub tokens: Option<LazyAttrTokenStream>,
 }
 
-#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug)]
+#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, Walkable)]
 pub enum MacStmtStyle {
     /// The macro statement had a trailing semicolon (e.g., `foo! { ... };`
     /// `foo!(...);`, `foo![...];`).
@@ -1253,7 +1258,7 @@ pub enum MacStmtStyle {
 }
 
 /// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Local {
     pub id: NodeId,
     pub super_: Option<Span>,
@@ -1266,7 +1271,7 @@ pub struct Local {
     pub tokens: Option<LazyAttrTokenStream>,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum LocalKind {
     /// Local declaration.
     /// Example: `let x;`
@@ -1306,7 +1311,7 @@ impl LocalKind {
 ///     _ => { println!("no match!") },
 /// }
 /// ```
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Arm {
     pub attrs: AttrVec,
     /// Match arm pattern, e.g. `10` in `match foo { 10 => {}, _ => {} }`.
@@ -1321,7 +1326,7 @@ pub struct Arm {
 }
 
 /// A single field in a struct expression, e.g. `x: value` and `y` in `Foo { x: value, y }`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct ExprField {
     pub attrs: AttrVec,
     pub id: NodeId,
@@ -1332,13 +1337,13 @@ pub struct ExprField {
     pub is_placeholder: bool,
 }
 
-#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)]
+#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy, Walkable)]
 pub enum BlockCheckMode {
     Default,
     Unsafe(UnsafeSource),
 }
 
-#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)]
+#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy, Walkable)]
 pub enum UnsafeSource {
     CompilerGenerated,
     UserProvided,
@@ -1349,7 +1354,7 @@ pub enum UnsafeSource {
 /// These are usually found nested inside types (e.g., array lengths)
 /// or expressions (e.g., repeat counts), and also used to define
 /// explicit discriminant values for enum variants.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct AnonConst {
     pub id: NodeId,
     pub value: P<Expr>,
@@ -1633,7 +1638,7 @@ impl From<P<Expr>> for Expr {
     }
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Closure {
     pub binder: ClosureBinder,
     pub capture_clause: CaptureBy,
@@ -1649,7 +1654,7 @@ pub struct Closure {
 }
 
 /// Limit types of a range (inclusive or exclusive).
-#[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug)]
+#[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, Walkable)]
 pub enum RangeLimits {
     /// Inclusive at the beginning, exclusive at the end.
     HalfOpen,
@@ -1680,7 +1685,7 @@ pub struct MethodCall {
     pub span: Span,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum StructRest {
     /// `..x`.
     Base(P<Expr>),
@@ -1690,7 +1695,7 @@ pub enum StructRest {
     None,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct StructExpr {
     pub qself: Option<P<QSelf>>,
     pub path: Path,
@@ -1880,14 +1885,14 @@ pub enum ExprKind {
 }
 
 /// Used to differentiate between `for` loops and `for await` loops.
-#[derive(Clone, Copy, Encodable, Decodable, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Encodable, Decodable, Debug, PartialEq, Eq, Walkable)]
 pub enum ForLoopKind {
     For,
     ForAwait,
 }
 
 /// Used to differentiate between `async {}` blocks and `gen {}` blocks.
-#[derive(Clone, Encodable, Decodable, Debug, PartialEq, Eq)]
+#[derive(Clone, Encodable, Decodable, Debug, PartialEq, Eq, Walkable)]
 pub enum GenBlockKind {
     Async,
     Gen,
@@ -1912,7 +1917,7 @@ impl GenBlockKind {
 
 /// Whether we're unwrapping or wrapping an unsafe binder
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[derive(Encodable, Decodable, HashStable_Generic)]
+#[derive(Encodable, Decodable, HashStable_Generic, Walkable)]
 pub enum UnsafeBinderCastKind {
     // e.g. `&i32` -> `unsafe<'a> &'a i32`
     Wrap,
@@ -1934,7 +1939,7 @@ pub enum UnsafeBinderCastKind {
 ///  ^~~~~    ^
 ///  ty       position = 0
 /// ```
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct QSelf {
     pub ty: P<Ty>,
 
@@ -1946,7 +1951,7 @@ pub struct QSelf {
 }
 
 /// A capture clause used in closures and `async` blocks.
-#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic, Walkable)]
 pub enum CaptureBy {
     /// `move |x| y + x`.
     Value {
@@ -1967,7 +1972,7 @@ pub enum CaptureBy {
 }
 
 /// Closure lifetime binder, `for<'a, 'b>` in `for<'a, 'b> |_: &'a (), _: &'b ()|`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum ClosureBinder {
     /// The binder is not present, all closure lifetimes are inferred.
     NotPresent,
@@ -1993,7 +1998,7 @@ pub enum ClosureBinder {
 
 /// Represents a macro invocation. The `path` indicates which macro
 /// is being invoked, and the `args` are arguments passed to it.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct MacCall {
     pub path: Path,
     pub args: P<DelimArgs>,
@@ -2006,7 +2011,7 @@ impl MacCall {
 }
 
 /// Arguments passed to an attribute macro.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum AttrArgs {
     /// No arguments: `#[attr]`.
     Empty,
@@ -2041,7 +2046,7 @@ impl AttrArgs {
 }
 
 /// Delimited arguments, as used in `#[attr()/[]/{}]` or `mac!()/[]/{}`.
-#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic, Walkable)]
 pub struct DelimArgs {
     pub dspan: DelimSpan,
     pub delim: Delimiter, // Note: `Delimiter::Invisible` never occurs
@@ -2057,7 +2062,7 @@ impl DelimArgs {
 }
 
 /// Represents a macro definition.
-#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic, Walkable)]
 pub struct MacroDef {
     pub body: P<DelimArgs>,
     /// `true` if macro was defined with `macro_rules`.
@@ -2065,7 +2070,7 @@ pub struct MacroDef {
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Copy, Hash, Eq, PartialEq)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, Walkable)]
 pub enum StrStyle {
     /// A regular string, like `"foo"`.
     Cooked,
@@ -2076,7 +2081,7 @@ pub enum StrStyle {
 }
 
 /// The kind of match expression
-#[derive(Clone, Copy, Encodable, Decodable, Debug, PartialEq)]
+#[derive(Clone, Copy, Encodable, Decodable, Debug, PartialEq, Walkable)]
 pub enum MatchKind {
     /// match expr { ... }
     Prefix,
@@ -2085,7 +2090,7 @@ pub enum MatchKind {
 }
 
 /// The kind of yield expression
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum YieldKind {
     /// yield expr { ... }
     Prefix(Option<P<Expr>>),
@@ -2136,7 +2141,7 @@ pub struct MetaItemLit {
 }
 
 /// Similar to `MetaItemLit`, but restricted to string literals.
-#[derive(Clone, Copy, Encodable, Decodable, Debug)]
+#[derive(Clone, Copy, Encodable, Decodable, Debug, Walkable)]
 pub struct StrLit {
     /// The original literal as written in source code.
     pub symbol: Symbol,
@@ -2265,7 +2270,7 @@ impl LitKind {
 
 // N.B., If you change this, you'll probably want to change the corresponding
 // type structure in `middle/ty.rs` as well.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct MutTy {
     pub ty: P<Ty>,
     pub mutbl: Mutability,
@@ -2389,7 +2394,7 @@ impl UintTy {
 /// * the `RetTy` in `Trait(ArgTy, ArgTy) -> RetTy`
 /// * the `C = { Ct }` in `Trait<C = { Ct }>` (feature `associated_const_equality`)
 /// * the `f(..): Bound` in `Trait<f(..): Bound>` (feature `return_type_notation`)
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct AssocItemConstraint {
     pub id: NodeId,
     pub ident: Ident,
@@ -2398,7 +2403,7 @@ pub struct AssocItemConstraint {
     pub span: Span,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum Term {
     Ty(P<Ty>),
     Const(AnonConst),
@@ -2417,7 +2422,7 @@ impl From<AnonConst> for Term {
 }
 
 /// The kind of [associated item constraint][AssocItemConstraint].
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum AssocItemConstraintKind {
     /// An equality constraint for an associated item (e.g., `AssocTy = Ty` in `Trait<AssocTy = Ty>`).
     ///
@@ -2427,10 +2432,13 @@ pub enum AssocItemConstraintKind {
     /// bindings*. Similarly with associated const equality constraints and *associated const bindings*.
     Equality { term: Term },
     /// A bound on an associated type (e.g., `AssocTy: Bound` in `Trait<AssocTy: Bound>`).
-    Bound { bounds: GenericBounds },
+    Bound {
+        #[visitable(extra = BoundKind::Bound)]
+        bounds: GenericBounds,
+    },
 }
 
-#[derive(Encodable, Decodable, Debug)]
+#[derive(Encodable, Decodable, Debug, Walkable)]
 pub struct Ty {
     pub id: NodeId,
     pub kind: TyKind,
@@ -2474,7 +2482,7 @@ impl Ty {
     }
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct FnPtrTy {
     pub safety: Safety,
     pub ext: Extern,
@@ -2485,7 +2493,7 @@ pub struct FnPtrTy {
     pub decl_span: Span,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct UnsafeBinderTy {
     pub generic_params: ThinVec<GenericParam>,
     pub inner_ty: P<Ty>,
@@ -2494,7 +2502,7 @@ pub struct UnsafeBinderTy {
 /// The various kinds of type recognized by the compiler.
 //
 // Adding a new variant? Please update `test_ty` in `tests/ui/macros/stringify.rs`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum TyKind {
     /// A variable-length slice (`[T]`).
     Slice(P<Ty>),
@@ -2503,11 +2511,11 @@ pub enum TyKind {
     /// A raw pointer (`*const T` or `*mut T`).
     Ptr(MutTy),
     /// A reference (`&'a T` or `&'a mut T`).
-    Ref(Option<Lifetime>, MutTy),
+    Ref(#[visitable(extra = LifetimeCtxt::Ref)] Option<Lifetime>, MutTy),
     /// A pinned reference (`&'a pin const T` or `&'a pin mut T`).
     ///
     /// Desugars into `Pin<&'a T>` or `Pin<&'a mut T>`.
-    PinnedRef(Option<Lifetime>, MutTy),
+    PinnedRef(#[visitable(extra = LifetimeCtxt::Ref)] Option<Lifetime>, MutTy),
     /// A function pointer type (e.g., `fn(usize) -> bool`).
     FnPtr(P<FnPtrTy>),
     /// An unsafe existential lifetime binder (e.g., `unsafe<'a> &'a ()`).
@@ -2523,14 +2531,14 @@ pub enum TyKind {
     Path(Option<P<QSelf>>, Path),
     /// A trait object type `Bound1 + Bound2 + Bound3`
     /// where `Bound` is a trait or a lifetime.
-    TraitObject(GenericBounds, TraitObjectSyntax),
+    TraitObject(#[visitable(extra = BoundKind::TraitObject)] GenericBounds, TraitObjectSyntax),
     /// An `impl Bound1 + Bound2 + Bound3` type
     /// where `Bound` is a trait or a lifetime.
     ///
     /// The `NodeId` exists to prevent lowering from having to
     /// generate `NodeId`s on the fly, which would complicate
     /// the generation of opaque `type Foo = impl Trait` items significantly.
-    ImplTrait(NodeId, GenericBounds),
+    ImplTrait(NodeId, #[visitable(extra = BoundKind::Impl)] GenericBounds),
     /// No-op; kept solely so that we can pretty-print faithfully.
     Paren(P<Ty>),
     /// Unused for now.
@@ -2608,7 +2616,7 @@ impl TyKind {
 }
 
 /// A pattern type pattern.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct TyPat {
     pub id: NodeId,
     pub kind: TyPatKind,
@@ -2619,7 +2627,7 @@ pub struct TyPat {
 /// All the different flavors of pattern that Rust recognizes.
 //
 // Adding a new variant? Please update `test_pat` in `tests/ui/macros/stringify.rs`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum TyPatKind {
     /// A range pattern (e.g., `1...2`, `1..2`, `1..`, `..2`, `1..=2`, `..=2`).
     Range(Option<P<AnonConst>>, Option<P<AnonConst>>, Spanned<RangeEnd>),
@@ -2631,7 +2639,7 @@ pub enum TyPatKind {
 }
 
 /// Syntax used to declare a trait object.
-#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic, Walkable)]
 #[repr(u8)]
 pub enum TraitObjectSyntax {
     // SAFETY: When adding new variants make sure to update the `Tag` impl.
@@ -2658,10 +2666,10 @@ unsafe impl Tag for TraitObjectSyntax {
     }
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum PreciseCapturingArg {
     /// Lifetime parameter.
-    Lifetime(Lifetime),
+    Lifetime(#[visitable(extra = LifetimeCtxt::GenericArg)] Lifetime),
     /// Type or const parameter.
     Arg(Path, NodeId),
 }
@@ -2669,7 +2677,7 @@ pub enum PreciseCapturingArg {
 /// Inline assembly operand explicit register or register class.
 ///
 /// E.g., `"eax"` as in `asm!("mov eax, 2", out("eax") result)`.
-#[derive(Clone, Copy, Encodable, Decodable, Debug)]
+#[derive(Clone, Copy, Encodable, Decodable, Debug, Walkable)]
 pub enum InlineAsmRegOrRegClass {
     Reg(Symbol),
     RegClass(Symbol),
@@ -2738,7 +2746,7 @@ impl std::fmt::Debug for InlineAsmOptions {
     }
 }
 
-#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Hash, HashStable_Generic)]
+#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Hash, HashStable_Generic, Walkable)]
 pub enum InlineAsmTemplatePiece {
     String(Cow<'static, str>),
     Placeholder { operand_idx: usize, modifier: Option<char>, span: Span },
@@ -2786,7 +2794,7 @@ impl InlineAsmTemplatePiece {
 /// `DefCollector`. Instead this is deferred until AST lowering where we
 /// lower it to an `AnonConst` (for functions) or a `Path` (for statics)
 /// depending on what the path resolves to.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct InlineAsmSym {
     pub id: NodeId,
     pub qself: Option<P<QSelf>>,
@@ -2796,7 +2804,7 @@ pub struct InlineAsmSym {
 /// Inline assembly operand.
 ///
 /// E.g., `out("eax") result` as in `asm!("mov eax, 2", out("eax") result)`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum InlineAsmOperand {
     In {
         reg: InlineAsmRegOrRegClass,
@@ -2841,7 +2849,7 @@ impl InlineAsmOperand {
     }
 }
 
-#[derive(Clone, Copy, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Clone, Copy, Encodable, Decodable, Debug, HashStable_Generic, Walkable)]
 pub enum AsmMacro {
     /// The `asm!` macro
     Asm,
@@ -2880,13 +2888,14 @@ impl AsmMacro {
 /// Inline assembly.
 ///
 /// E.g., `asm!("NOP");`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct InlineAsm {
     pub asm_macro: AsmMacro,
     pub template: Vec<InlineAsmTemplatePiece>,
     pub template_strs: Box<[(Symbol, Option<Symbol>, Span)]>,
     pub operands: Vec<(InlineAsmOperand, Span)>,
     pub clobber_abis: Vec<(Symbol, Span)>,
+    #[visitable(ignore)]
     pub options: InlineAsmOptions,
     pub line_spans: Vec<Span>,
 }
@@ -2894,7 +2903,7 @@ pub struct InlineAsm {
 /// A parameter in a function header.
 ///
 /// E.g., `bar: usize` as in `fn foo(bar: usize)`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Param {
     pub attrs: AttrVec,
     pub ty: P<Ty>,
@@ -3022,7 +3031,7 @@ impl Param {
 ///
 /// Please note that it's different from `FnHeader` structure
 /// which contains metadata about function safety, asyncness, constness and ABI.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct FnDecl {
     pub inputs: ThinVec<Param>,
     pub output: FnRetTy,
@@ -3038,7 +3047,7 @@ impl FnDecl {
 }
 
 /// Is the trait definition an auto trait?
-#[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic, Walkable)]
 pub enum IsAuto {
     Yes,
     No,
@@ -3046,7 +3055,7 @@ pub enum IsAuto {
 
 /// Safety of items.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable, Debug)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, Walkable)]
 pub enum Safety {
     /// `unsafe` an item is explicitly marked as `unsafe`.
     Unsafe(Span),
@@ -3062,7 +3071,7 @@ pub enum Safety {
 /// Coroutine markers are things that cause the function to generate a coroutine, such as `async`,
 /// which makes the function return `impl Future`, or `gen`, which makes the function return `impl
 /// Iterator`.
-#[derive(Copy, Clone, Encodable, Decodable, Debug)]
+#[derive(Copy, Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum CoroutineKind {
     /// `async`, which returns an `impl Future`.
     Async { span: Span, closure_id: NodeId, return_impl_trait_id: NodeId },
@@ -3111,7 +3120,7 @@ impl CoroutineKind {
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable, Debug)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, Walkable)]
 pub enum Const {
     Yes(Span),
     No,
@@ -3119,13 +3128,13 @@ pub enum Const {
 
 /// Item defaultness.
 /// For details see the [RFC #2532](https://github.com/rust-lang/rfcs/pull/2532).
-#[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
+#[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic, Walkable)]
 pub enum Defaultness {
     Default(Span),
     Final,
 }
 
-#[derive(Copy, Clone, PartialEq, Encodable, Decodable, HashStable_Generic)]
+#[derive(Copy, Clone, PartialEq, Encodable, Decodable, HashStable_Generic, Walkable)]
 pub enum ImplPolarity {
     /// `impl Trait for Type`
     Positive,
@@ -3144,7 +3153,7 @@ impl fmt::Debug for ImplPolarity {
 
 /// The polarity of a trait bound.
 #[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug, Hash)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, Walkable)]
 pub enum BoundPolarity {
     /// `Type: Trait`
     Positive,
@@ -3166,7 +3175,7 @@ impl BoundPolarity {
 
 /// The constness of a trait bound.
 #[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug, Hash)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, Walkable)]
 pub enum BoundConstness {
     /// `Type: Trait`
     Never,
@@ -3188,7 +3197,7 @@ impl BoundConstness {
 
 /// The asyncness of a trait bound.
 #[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, Walkable)]
 pub enum BoundAsyncness {
     /// `Type: Trait`
     Normal,
@@ -3205,7 +3214,7 @@ impl BoundAsyncness {
     }
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum FnRetTy {
     /// Returns type is not specified.
     ///
@@ -3225,14 +3234,14 @@ impl FnRetTy {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug)]
+#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, Walkable)]
 pub enum Inline {
     Yes,
     No,
 }
 
 /// Module item kind.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum ModKind {
     /// Module with inlined definition `mod foo { ... }`,
     /// or with definition outlined to a separate file `mod foo;` and already loaded from it.
@@ -3243,7 +3252,7 @@ pub enum ModKind {
     Unloaded,
 }
 
-#[derive(Copy, Clone, Encodable, Decodable, Debug, Default)]
+#[derive(Copy, Clone, Encodable, Decodable, Debug, Default, Walkable)]
 pub struct ModSpans {
     /// `inner_span` covers the body of the module; for a file module, its the whole file.
     /// For an inline module, its the span inside the `{ ... }`, not including the curly braces.
@@ -3254,7 +3263,7 @@ pub struct ModSpans {
 /// Foreign module declaration.
 ///
 /// E.g., `extern { .. }` or `extern "C" { .. }`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct ForeignMod {
     /// Span of the `extern` keyword.
     pub extern_span: Span,
@@ -3265,12 +3274,13 @@ pub struct ForeignMod {
     pub items: ThinVec<P<ForeignItem>>,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct EnumDef {
     pub variants: ThinVec<Variant>,
 }
+
 /// Enum variant.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Variant {
     /// Attributes of the variant.
     pub attrs: AttrVec,
@@ -3292,7 +3302,7 @@ pub struct Variant {
 }
 
 /// Part of `use` item to the right of its prefix.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum UseTreeKind {
     /// `use prefix` or `use prefix as rename`
     Simple(Option<Ident>),
@@ -3311,7 +3321,7 @@ pub enum UseTreeKind {
 
 /// A tree of paths sharing common prefixes.
 /// Used in `use` items both at top-level and inside of braces in import groups.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct UseTree {
     pub prefix: Path,
     pub kind: UseTreeKind,
@@ -3333,7 +3343,7 @@ impl UseTree {
 /// Distinguishes between `Attribute`s that decorate items and Attributes that
 /// are contained as statements within items. These two cases need to be
 /// distinguished for pretty-printing.
-#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy, HashStable_Generic)]
+#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy, HashStable_Generic, Walkable)]
 pub enum AttrStyle {
     Outer,
     Inner,
@@ -3343,7 +3353,7 @@ pub enum AttrStyle {
 pub type AttrVec = ThinVec<Attribute>;
 
 /// A syntax-level representation of an attribute.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Attribute {
     pub kind: AttrKind,
     pub id: AttrId,
@@ -3353,7 +3363,7 @@ pub struct Attribute {
     pub span: Span,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum AttrKind {
     /// A normal attribute.
     Normal(P<NormalAttr>),
@@ -3364,7 +3374,7 @@ pub enum AttrKind {
     DocComment(CommentKind, Symbol),
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct NormalAttr {
     pub item: AttrItem,
     // Tokens for the full attribute, e.g. `#[foo]`, `#![bar]`.
@@ -3385,7 +3395,7 @@ impl NormalAttr {
     }
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct AttrItem {
     pub unsafety: Safety,
     pub path: Path,
@@ -3411,20 +3421,20 @@ impl AttrItem {
 /// that the `ref_id` is for. The `impl_id` maps to the "self type" of this impl.
 /// If this impl is an `ItemKind::Impl`, the `impl_id` is redundant (it could be the
 /// same as the impl's `NodeId`).
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct TraitRef {
     pub path: Path,
     pub ref_id: NodeId,
 }
 
 /// Whether enclosing parentheses are present or not.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum Parens {
     Yes,
     No,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct PolyTraitRef {
     /// The `'a` in `for<'a> Foo<&'a T>`.
     pub bound_generic_params: ThinVec<GenericParam>,
@@ -3460,14 +3470,14 @@ impl PolyTraitRef {
     }
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Visibility {
     pub kind: VisibilityKind,
     pub span: Span,
     pub tokens: Option<LazyAttrTokenStream>,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum VisibilityKind {
     Public,
     Restricted { path: P<Path>, id: NodeId, shorthand: bool },
@@ -3483,7 +3493,7 @@ impl VisibilityKind {
 /// Field definition in a struct, variant or union.
 ///
 /// E.g., `bar: usize` as in `struct Foo { bar: usize }`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct FieldDef {
     pub attrs: AttrVec,
     pub id: NodeId,
@@ -3498,14 +3508,14 @@ pub struct FieldDef {
 }
 
 /// Was parsing recovery performed?
-#[derive(Copy, Clone, Debug, Encodable, Decodable, HashStable_Generic)]
+#[derive(Copy, Clone, Debug, Encodable, Decodable, HashStable_Generic, Walkable)]
 pub enum Recovered {
     No,
     Yes(ErrorGuaranteed),
 }
 
 /// Fields and constructor ids of enum variants and structs.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum VariantData {
     /// Struct variant.
     ///
@@ -3591,7 +3601,7 @@ impl Item {
 }
 
 /// `extern` qualifier on a function item or function type.
-#[derive(Clone, Copy, Encodable, Decodable, Debug)]
+#[derive(Clone, Copy, Encodable, Decodable, Debug, Walkable)]
 pub enum Extern {
     /// No explicit extern keyword was used.
     ///
@@ -3622,7 +3632,7 @@ impl Extern {
 ///
 /// All the information between the visibility and the name of the function is
 /// included in this struct (e.g., `async unsafe fn` or `const extern "C" fn`).
-#[derive(Clone, Copy, Encodable, Decodable, Debug)]
+#[derive(Clone, Copy, Encodable, Decodable, Debug, Walkable)]
 pub struct FnHeader {
     /// Whether this is `unsafe`, or has a default safety.
     pub safety: Safety,
@@ -3688,14 +3698,16 @@ impl Default for FnHeader {
     }
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Trait {
     pub constness: Const,
     pub safety: Safety,
     pub is_auto: IsAuto,
     pub ident: Ident,
     pub generics: Generics,
+    #[visitable(extra = BoundKind::SuperTraits)]
     pub bounds: GenericBounds,
+    #[visitable(extra = AssocCtxt::Trait)]
     pub items: ThinVec<P<AssocItem>>,
 }
 
@@ -3717,14 +3729,14 @@ pub struct Trait {
 /// ```
 ///
 /// If there is no where clause, then this is `false` with `DUMMY_SP`.
-#[derive(Copy, Clone, Encodable, Decodable, Debug, Default)]
+#[derive(Copy, Clone, Encodable, Decodable, Debug, Default, Walkable)]
 pub struct TyAliasWhereClause {
     pub has_where_token: bool,
     pub span: Span,
 }
 
 /// The span information for the two where clauses on a `TyAlias`.
-#[derive(Copy, Clone, Encodable, Decodable, Debug, Default)]
+#[derive(Copy, Clone, Encodable, Decodable, Debug, Default, Walkable)]
 pub struct TyAliasWhereClauses {
     /// Before the equals sign.
     pub before: TyAliasWhereClause,
@@ -3736,12 +3748,13 @@ pub struct TyAliasWhereClauses {
     pub split: usize,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct TyAlias {
     pub defaultness: Defaultness,
     pub ident: Ident,
     pub generics: Generics,
     pub where_clauses: TyAliasWhereClauses,
+    #[visitable(extra = BoundKind::Bound)]
     pub bounds: GenericBounds,
     pub ty: Option<P<Ty>>,
 }
@@ -3759,7 +3772,7 @@ pub struct Impl {
     pub items: ThinVec<P<AssocItem>>,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug, Default)]
+#[derive(Clone, Encodable, Decodable, Debug, Default, Walkable)]
 pub struct FnContract {
     pub requires: Option<P<Expr>>,
     pub ensures: Option<P<Expr>>,
@@ -3776,7 +3789,7 @@ pub struct Fn {
     pub body: Option<P<Block>>,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Delegation {
     /// Path resolution id.
     pub id: NodeId,
@@ -3789,7 +3802,7 @@ pub struct Delegation {
     pub from_glob: bool,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct DelegationMac {
     pub qself: Option<P<QSelf>>,
     pub prefix: Path,
@@ -3798,7 +3811,7 @@ pub struct DelegationMac {
     pub body: Option<P<Block>>,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct StaticItem {
     pub ident: Ident,
     pub ty: P<Ty>,
@@ -3808,7 +3821,7 @@ pub struct StaticItem {
     pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct ConstItem {
     pub defaultness: Defaultness,
     pub ident: Ident,
diff --git a/compiler/rustc_ast/src/format.rs b/compiler/rustc_ast/src/format.rs
index 28d260419c5..c2a1de60a98 100644
--- a/compiler/rustc_ast/src/format.rs
+++ b/compiler/rustc_ast/src/format.rs
@@ -1,5 +1,5 @@
 use rustc_data_structures::fx::FxHashMap;
-use rustc_macros::{Decodable, Encodable};
+use rustc_macros::{Decodable, Encodable, Walkable};
 use rustc_span::{Ident, Span, Symbol};
 
 use crate::Expr;
@@ -41,7 +41,7 @@ use crate::token::LitKind;
 /// Basically the "AST" for a complete `format_args!()`.
 ///
 /// E.g., `format_args!("hello {name}");`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct FormatArgs {
     pub span: Span,
     pub template: Vec<FormatArgsPiece>,
@@ -63,7 +63,7 @@ pub struct FormatArgs {
 /// A piece of a format template string.
 ///
 /// E.g. "hello" or "{name}".
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum FormatArgsPiece {
     Literal(Symbol),
     Placeholder(FormatPlaceholder),
@@ -73,7 +73,7 @@ pub enum FormatArgsPiece {
 ///
 /// E.g. `1, 2, name="ferris", n=3`,
 /// but also implicit captured arguments like `x` in `format_args!("{x}")`.
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct FormatArguments {
     arguments: Vec<FormatArgument>,
     num_unnamed_args: usize,
@@ -144,13 +144,13 @@ impl FormatArguments {
     }
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct FormatArgument {
     pub kind: FormatArgumentKind,
     pub expr: P<Expr>,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug)]
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum FormatArgumentKind {
     /// `format_args(…, arg)`
     Normal,
@@ -170,24 +170,28 @@ impl FormatArgumentKind {
     }
 }
 
-#[derive(Clone, Encodable, Decodable, Debug, PartialEq, Eq)]
+#[derive(Clone, Encodable, Decodable, Debug, PartialEq, Eq, Walkable)]
 pub struct FormatPlaceholder {
     /// Index into [`FormatArgs::arguments`].
     pub argument: FormatArgPosition,
     /// The span inside the format string for the full `{…}` placeholder.
     pub span: Option<Span>,
     /// `{}`, `{:?}`, or `{:x}`, etc.
+    #[visitable(ignore)]
     pub format_trait: FormatTrait,
     /// `{}` or `{:.5}` or `{:-^20}`, etc.
+    #[visitable(ignore)]
     pub format_options: FormatOptions,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug, PartialEq, Eq)]
+#[derive(Clone, Encodable, Decodable, Debug, PartialEq, Eq, Walkable)]
 pub struct FormatArgPosition {
     /// Which argument this position refers to (Ok),
     /// or would've referred to if it existed (Err).
+    #[visitable(ignore)]
     pub index: Result<usize, usize>,
     /// What kind of position this is. See [`FormatArgPositionKind`].
+    #[visitable(ignore)]
     pub kind: FormatArgPositionKind,
     /// The span of the name or number.
     pub span: Option<Span>,
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
index 3eae19f4daa..06708e2e703 100644
--- a/compiler/rustc_ast/src/mut_visit.rs
+++ b/compiler/rustc_ast/src/mut_visit.rs
@@ -12,14 +12,14 @@ use std::panic;
 
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_span::source_map::Spanned;
-use rustc_span::{Ident, Span};
+use rustc_span::{Ident, Span, Symbol};
 use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 
 use crate::ast::*;
 use crate::ptr::P;
 use crate::tokenstream::*;
-use crate::visit::{AssocCtxt, BoundKind, FnCtxt, VisitorResult, try_visit, visit_opt, walk_list};
+use crate::visit::{AssocCtxt, BoundKind, FnCtxt, LifetimeCtxt, VisitorResult, try_visit};
 
 mod sealed {
     use rustc_ast_ir::visit::VisitorResult;
@@ -36,11 +36,249 @@ mod sealed {
 
 use sealed::MutVisitorResult;
 
+pub(crate) trait MutVisitable<V: MutVisitor> {
+    type Extra: Copy;
+    fn visit_mut(&mut self, visitor: &mut V, extra: Self::Extra);
+}
+
+impl<V: MutVisitor, T: ?Sized> MutVisitable<V> for P<T>
+where
+    T: MutVisitable<V>,
+{
+    type Extra = T::Extra;
+    fn visit_mut(&mut self, visitor: &mut V, extra: Self::Extra) {
+        (**self).visit_mut(visitor, extra)
+    }
+}
+
+impl<V: MutVisitor, T> MutVisitable<V> for Option<T>
+where
+    T: MutVisitable<V>,
+{
+    type Extra = T::Extra;
+    fn visit_mut(&mut self, visitor: &mut V, extra: Self::Extra) {
+        if let Some(this) = self {
+            this.visit_mut(visitor, extra)
+        }
+    }
+}
+
+impl<V: MutVisitor, T> MutVisitable<V> for Spanned<T>
+where
+    T: MutVisitable<V>,
+{
+    type Extra = T::Extra;
+    fn visit_mut(&mut self, visitor: &mut V, extra: Self::Extra) {
+        let Spanned { span, node } = self;
+        span.visit_mut(visitor, ());
+        node.visit_mut(visitor, extra);
+    }
+}
+
+impl<V: MutVisitor, T> MutVisitable<V> for [T]
+where
+    T: MutVisitable<V>,
+{
+    type Extra = T::Extra;
+    fn visit_mut(&mut self, visitor: &mut V, extra: Self::Extra) {
+        for item in self {
+            item.visit_mut(visitor, extra);
+        }
+    }
+}
+
+impl<V: MutVisitor, T> MutVisitable<V> for Vec<T>
+where
+    T: MutVisitable<V>,
+{
+    type Extra = T::Extra;
+    fn visit_mut(&mut self, visitor: &mut V, extra: Self::Extra) {
+        for item in self {
+            item.visit_mut(visitor, extra);
+        }
+    }
+}
+
+impl<V: MutVisitor, T> MutVisitable<V> for (T,)
+where
+    T: MutVisitable<V>,
+{
+    type Extra = T::Extra;
+    fn visit_mut(&mut self, visitor: &mut V, extra: Self::Extra) {
+        self.0.visit_mut(visitor, extra);
+    }
+}
+
+impl<V: MutVisitor, T1, T2> MutVisitable<V> for (T1, T2)
+where
+    T1: MutVisitable<V, Extra = ()>,
+    T2: MutVisitable<V, Extra = ()>,
+{
+    type Extra = ();
+    fn visit_mut(&mut self, visitor: &mut V, extra: Self::Extra) {
+        self.0.visit_mut(visitor, extra);
+        self.1.visit_mut(visitor, extra);
+    }
+}
+
+impl<V: MutVisitor, T1, T2, T3> MutVisitable<V> for (T1, T2, T3)
+where
+    T1: MutVisitable<V, Extra = ()>,
+    T2: MutVisitable<V, Extra = ()>,
+    T3: MutVisitable<V, Extra = ()>,
+{
+    type Extra = ();
+    fn visit_mut(&mut self, visitor: &mut V, extra: Self::Extra) {
+        self.0.visit_mut(visitor, extra);
+        self.1.visit_mut(visitor, extra);
+        self.2.visit_mut(visitor, extra);
+    }
+}
+
+impl<V: MutVisitor, T1, T2, T3, T4> MutVisitable<V> for (T1, T2, T3, T4)
+where
+    T1: MutVisitable<V, Extra = ()>,
+    T2: MutVisitable<V, Extra = ()>,
+    T3: MutVisitable<V, Extra = ()>,
+    T4: MutVisitable<V, Extra = ()>,
+{
+    type Extra = ();
+    fn visit_mut(&mut self, visitor: &mut V, extra: Self::Extra) {
+        self.0.visit_mut(visitor, extra);
+        self.1.visit_mut(visitor, extra);
+        self.2.visit_mut(visitor, extra);
+        self.3.visit_mut(visitor, extra);
+    }
+}
+
+pub trait MutWalkable<V: MutVisitor> {
+    fn walk_mut(&mut self, visitor: &mut V);
+}
+
+macro_rules! visit_visitable {
+    (mut $visitor:expr, $($expr:expr),* $(,)?) => {{
+        $(MutVisitable::visit_mut($expr, $visitor, ());)*
+    }};
+}
+
+macro_rules! visit_visitable_with {
+    (mut $visitor:expr, $expr:expr, $extra:expr $(,)?) => {
+        MutVisitable::visit_mut($expr, $visitor, $extra)
+    };
+}
+
+macro_rules! walk_walkable {
+    ($visitor:expr, $expr:expr, mut) => {
+        MutWalkable::walk_mut($expr, $visitor)
+    };
+}
+
+macro_rules! impl_visitable {
+    (|&mut $self:ident: $self_ty:ty,
+      $vis:ident: &mut $vis_ty:ident,
+      $extra:ident: $extra_ty:ty| $block:block) => {
+        #[allow(unused_parens, non_local_definitions)]
+        impl<$vis_ty: MutVisitor> MutVisitable<$vis_ty> for $self_ty {
+            type Extra = $extra_ty;
+            fn visit_mut(&mut $self, $vis: &mut $vis_ty, $extra: Self::Extra) -> V::Result {
+                $block
+            }
+        }
+    };
+}
+
+macro_rules! impl_walkable {
+    ($(<$K:ident: $Kb:ident>)? |&mut $self:ident: $self_ty:ty,
+      $vis:ident: &mut $vis_ty:ident| $block:block) => {
+        #[allow(unused_parens, non_local_definitions)]
+        impl<$($K: $Kb,)? $vis_ty: MutVisitor> MutWalkable<$vis_ty> for $self_ty {
+            fn walk_mut(&mut $self, $vis: &mut $vis_ty) -> V::Result {
+                $block
+            }
+        }
+    };
+}
+
+macro_rules! impl_visitable_noop {
+    (<mut> $($ty:ty,)*) => {
+        $(
+            impl_visitable!(|&mut self: $ty, _vis: &mut V, _extra: ()| {});
+        )*
+    };
+}
+
+macro_rules! impl_visitable_list {
+    (<mut> $($ty:ty,)*) => {
+        $(impl<V: MutVisitor, T> MutVisitable<V> for $ty
+        where
+            for<'a> &'a mut $ty: IntoIterator<Item = &'a mut T>,
+            T: MutVisitable<V>,
+        {
+            type Extra = <T as MutVisitable<V>>::Extra;
+
+            #[inline]
+            fn visit_mut(&mut self, visitor: &mut V, extra: Self::Extra) {
+                for i in self {
+                    i.visit_mut(visitor, extra);
+                }
+            }
+        })*
+    }
+}
+
+macro_rules! impl_visitable_direct {
+    (<mut> $($ty:ty,)*) => {
+        $(impl_visitable!(
+            |&mut self: $ty, visitor: &mut V, _extra: ()| {
+                MutWalkable::walk_mut(self, visitor)
+            }
+        );)*
+    }
+}
+
+macro_rules! impl_visitable_calling_walkable {
+    (<mut>
+        $( fn $method:ident($ty:ty $(, $extra_name:ident: $extra_ty:ty)?); )*
+    ) => {
+        $(fn $method(&mut self, node: &mut $ty $(, $extra_name:$extra_ty)?) {
+            impl_visitable!(|&mut self: $ty, visitor: &mut V, extra: ($($extra_ty)?)| {
+                let ($($extra_name)?) = extra;
+                visitor.$method(self $(, $extra_name)?);
+            });
+            walk_walkable!(self, node, mut)
+        })*
+    }
+}
+
+macro_rules! define_named_walk {
+    ((mut) $Visitor:ident
+        $( pub fn $method:ident($ty:ty); )*
+    ) => {
+        $(pub fn $method<V: $Visitor>(visitor: &mut V, node: &mut $ty) {
+            walk_walkable!(visitor, node, mut)
+        })*
+    };
+}
+
 super::common_visitor_and_walkers!((mut) MutVisitor);
 
 macro_rules! generate_flat_map_visitor_fns {
     ($($name:ident, $Ty:ty, $flat_map_fn:ident$(, $param:ident: $ParamTy:ty)*;)+) => {
         $(
+            #[allow(unused_parens)]
+            impl<V: MutVisitor> MutVisitable<V> for ThinVec<$Ty> {
+                type Extra = ($($ParamTy),*);
+
+                #[inline]
+                fn visit_mut(
+                    &mut self,
+                    visitor: &mut V,
+                    ($($param),*): Self::Extra,
+                ) -> V::Result {
+                    $name(visitor, self $(, $param)*)
+                }
+            }
+
             fn $name<V: MutVisitor>(
                 vis: &mut V,
                 values: &mut ThinVec<$Ty>,
@@ -78,15 +316,6 @@ pub fn walk_flat_map_pat_field<T: MutVisitor>(
     smallvec![fp]
 }
 
-fn visit_nested_use_tree<V: MutVisitor>(
-    vis: &mut V,
-    nested_tree: &mut UseTree,
-    nested_id: &mut NodeId,
-) {
-    vis.visit_id(nested_id);
-    vis.visit_use_tree(nested_tree);
-}
-
 macro_rules! generate_walk_flat_map_fns {
     ($($fn_name:ident($Ty:ty$(,$extra_name:ident: $ExtraTy:ty)*) => $visit_fn_name:ident;)+) => {$(
         pub fn $fn_name<V: MutVisitor>(vis: &mut V, mut value: $Ty$(,$extra_name: $ExtraTy)*) -> SmallVec<[$Ty; 1]> {
@@ -109,14 +338,6 @@ generate_walk_flat_map_fns! {
     walk_flat_map_assoc_item(P<AssocItem>, ctxt: AssocCtxt) => visit_assoc_item;
 }
 
-fn walk_ty_alias_where_clauses<T: MutVisitor>(vis: &mut T, tawcs: &mut TyAliasWhereClauses) {
-    let TyAliasWhereClauses { before, after, split: _ } = tawcs;
-    let TyAliasWhereClause { has_where_token: _, span: span_before } = before;
-    let TyAliasWhereClause { has_where_token: _, span: span_after } = after;
-    vis.visit_span(span_before);
-    vis.visit_span(span_after);
-}
-
 pub fn walk_filter_map_expr<T: MutVisitor>(vis: &mut T, mut e: P<Expr>) -> Option<P<Expr>> {
     vis.visit_expr(&mut e);
     Some(e)
diff --git a/compiler/rustc_ast/src/tokenstream.rs b/compiler/rustc_ast/src/tokenstream.rs
index c60185cdde0..e55399adfb8 100644
--- a/compiler/rustc_ast/src/tokenstream.rs
+++ b/compiler/rustc_ast/src/tokenstream.rs
@@ -20,7 +20,7 @@ use std::{cmp, fmt, iter, mem};
 
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync;
-use rustc_macros::{Decodable, Encodable, HashStable_Generic};
+use rustc_macros::{Decodable, Encodable, HashStable_Generic, Walkable};
 use rustc_serialize::{Decodable, Encodable};
 use rustc_span::{DUMMY_SP, Span, SpanDecoder, SpanEncoder, Symbol, sym};
 use thin_vec::ThinVec;
@@ -977,7 +977,7 @@ impl TokenCursor {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Encodable, Decodable, HashStable_Generic)]
+#[derive(Debug, Copy, Clone, PartialEq, Encodable, Decodable, HashStable_Generic, Walkable)]
 pub struct DelimSpan {
     pub open: Span,
     pub close: Span,
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index a344f23c345..ab15cb28fa1 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -16,7 +16,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};
+use rustc_span::{Ident, Span, Symbol};
 use thin_vec::ThinVec;
 
 use crate::ast::*;
@@ -75,6 +75,241 @@ pub enum LifetimeCtxt {
     GenericArg,
 }
 
+pub(crate) trait Visitable<'a, V: Visitor<'a>> {
+    type Extra: Copy;
+
+    #[must_use]
+    fn visit(&'a self, visitor: &mut V, extra: Self::Extra) -> V::Result;
+}
+
+impl<'a, V: Visitor<'a>, T: ?Sized> Visitable<'a, V> for P<T>
+where
+    T: Visitable<'a, V>,
+{
+    type Extra = T::Extra;
+    fn visit(&'a self, visitor: &mut V, extra: Self::Extra) -> V::Result {
+        (**self).visit(visitor, extra)
+    }
+}
+
+impl<'a, V: Visitor<'a>, T> Visitable<'a, V> for Option<T>
+where
+    T: Visitable<'a, V>,
+{
+    type Extra = T::Extra;
+    fn visit(&'a self, visitor: &mut V, extra: Self::Extra) -> V::Result {
+        if let Some(this) = self {
+            try_visit!(this.visit(visitor, extra));
+        }
+        V::Result::output()
+    }
+}
+
+impl<'a, V: Visitor<'a>, T> Visitable<'a, V> for Spanned<T>
+where
+    T: Visitable<'a, V>,
+{
+    type Extra = T::Extra;
+    fn visit(&'a self, visitor: &mut V, extra: Self::Extra) -> V::Result {
+        let Spanned { span: _, node } = self;
+        node.visit(visitor, extra)
+    }
+}
+
+impl<'a, V: Visitor<'a>, T> Visitable<'a, V> for [T]
+where
+    T: Visitable<'a, V>,
+{
+    type Extra = T::Extra;
+    fn visit(&'a self, visitor: &mut V, extra: Self::Extra) -> V::Result {
+        for item in self {
+            try_visit!(item.visit(visitor, extra));
+        }
+        V::Result::output()
+    }
+}
+
+impl<'a, V: Visitor<'a>, T> Visitable<'a, V> for Vec<T>
+where
+    T: Visitable<'a, V>,
+{
+    type Extra = T::Extra;
+    fn visit(&'a self, visitor: &mut V, extra: Self::Extra) -> V::Result {
+        for item in self {
+            try_visit!(item.visit(visitor, extra));
+        }
+        V::Result::output()
+    }
+}
+
+impl<'a, V: Visitor<'a>, T> Visitable<'a, V> for (T,)
+where
+    T: Visitable<'a, V>,
+{
+    type Extra = T::Extra;
+    fn visit(&'a self, visitor: &mut V, extra: Self::Extra) -> V::Result {
+        self.0.visit(visitor, extra)
+    }
+}
+
+impl<'a, V: Visitor<'a>, T1, T2> Visitable<'a, V> for (T1, T2)
+where
+    T1: Visitable<'a, V, Extra = ()>,
+    T2: Visitable<'a, V, Extra = ()>,
+{
+    type Extra = ();
+    fn visit(&'a self, visitor: &mut V, extra: Self::Extra) -> V::Result {
+        try_visit!(self.0.visit(visitor, extra));
+        try_visit!(self.1.visit(visitor, extra));
+        V::Result::output()
+    }
+}
+
+impl<'a, V: Visitor<'a>, T1, T2, T3> Visitable<'a, V> for (T1, T2, T3)
+where
+    T1: Visitable<'a, V, Extra = ()>,
+    T2: Visitable<'a, V, Extra = ()>,
+    T3: Visitable<'a, V, Extra = ()>,
+{
+    type Extra = ();
+    fn visit(&'a self, visitor: &mut V, extra: Self::Extra) -> V::Result {
+        try_visit!(self.0.visit(visitor, extra));
+        try_visit!(self.1.visit(visitor, extra));
+        try_visit!(self.2.visit(visitor, extra));
+        V::Result::output()
+    }
+}
+
+impl<'a, V: Visitor<'a>, T1, T2, T3, T4> Visitable<'a, V> for (T1, T2, T3, T4)
+where
+    T1: Visitable<'a, V, Extra = ()>,
+    T2: Visitable<'a, V, Extra = ()>,
+    T3: Visitable<'a, V, Extra = ()>,
+    T4: Visitable<'a, V, Extra = ()>,
+{
+    type Extra = ();
+    fn visit(&'a self, visitor: &mut V, extra: Self::Extra) -> V::Result {
+        try_visit!(self.0.visit(visitor, extra));
+        try_visit!(self.1.visit(visitor, extra));
+        try_visit!(self.2.visit(visitor, extra));
+        try_visit!(self.3.visit(visitor, extra));
+        V::Result::output()
+    }
+}
+
+pub(crate) trait Walkable<'a, V: Visitor<'a>> {
+    #[must_use]
+    fn walk_ref(&'a self, visitor: &mut V) -> V::Result;
+}
+
+macro_rules! visit_visitable {
+    ($visitor:expr, $($expr:expr),* $(,)?) => {{
+        $(try_visit!(Visitable::visit($expr, $visitor, ()));)*
+    }};
+}
+
+macro_rules! visit_visitable_with {
+    ($visitor:expr, $expr:expr, $extra:expr $(,)?) => {
+        try_visit!(Visitable::visit($expr, $visitor, $extra))
+    };
+}
+
+macro_rules! walk_walkable {
+    ($visitor:expr, $expr:expr, ) => {
+        Walkable::walk_ref($expr, $visitor)
+    };
+}
+
+macro_rules! impl_visitable {
+    (|&$lt:lifetime $self:ident: $self_ty:ty,
+      $vis:ident: &mut $vis_ty:ident,
+      $extra:ident: $extra_ty:ty| $block:block) => {
+        #[allow(unused_parens, non_local_definitions)]
+        impl<$lt, $vis_ty: Visitor<$lt>> Visitable<$lt, $vis_ty> for $self_ty {
+            type Extra = $extra_ty;
+            fn visit(&$lt $self, $vis: &mut $vis_ty, $extra: Self::Extra) -> V::Result {
+                $block
+            }
+        }
+    };
+}
+
+macro_rules! impl_walkable {
+    ($(<$K:ident: $Kb:ident>)? |&$lt:lifetime $self:ident: $self_ty:ty,
+      $vis:ident: &mut $vis_ty:ident| $block:block) => {
+        #[allow(unused_parens, non_local_definitions)]
+        impl<$($K: $Kb,)? $lt, $vis_ty: Visitor<$lt>> Walkable<$lt, $vis_ty> for $self_ty {
+            fn walk_ref(&$lt $self, $vis: &mut $vis_ty) -> V::Result {
+                $block
+            }
+        }
+    };
+}
+
+macro_rules! impl_visitable_noop {
+    (<$lt:lifetime> $($ty:ty,)*) => {
+        $(
+            impl_visitable!(|&$lt self: $ty, _vis: &mut V, _extra: ()| {
+                V::Result::output()
+            });
+        )*
+    };
+}
+
+macro_rules! impl_visitable_list {
+    (<$lt:lifetime> $($ty:ty,)*) => {
+        $(impl<$lt, V: Visitor<$lt>, T> Visitable<$lt, V> for $ty
+        where
+            &$lt $ty: IntoIterator<Item = &$lt T>,
+            T: $lt + Visitable<$lt, V>,
+        {
+            type Extra = <T as Visitable<$lt, V>>::Extra;
+
+            #[inline]
+            fn visit(&$lt self, visitor: &mut V, extra: Self::Extra) -> V::Result {
+                for i in self {
+                    try_visit!(i.visit(visitor, extra));
+                }
+                V::Result::output()
+            }
+        })*
+    };
+}
+
+macro_rules! impl_visitable_direct {
+    (<$lt:lifetime> $($ty:ty,)*) => {
+        $(impl_visitable!(
+            |&$lt self: $ty, visitor: &mut V, _extra: ()| {
+                Walkable::walk_ref(self, visitor)
+            }
+        );)*
+    };
+}
+
+macro_rules! impl_visitable_calling_walkable {
+    (<$lt:lifetime>
+        $( fn $method:ident($ty:ty $(, $extra_name:ident: $extra_ty:ty)?); )*
+    ) => {
+        $(fn $method(&mut self, node: &$lt $ty $(, $extra_name:$extra_ty)?) -> Self::Result {
+            impl_visitable!(|&$lt self: $ty, visitor: &mut V, extra: ($($extra_ty)?)| {
+                let ($($extra_name)?) = extra;
+                visitor.$method(self $(, $extra_name)?)
+            });
+            walk_walkable!(self, node, )
+        })*
+    };
+}
+
+macro_rules! define_named_walk {
+    ($Visitor:ident<$lt:lifetime>
+        $( pub fn $method:ident($ty:ty); )*
+    ) => {
+        $(pub fn $method<$lt, V: $Visitor<$lt>>(visitor: &mut V, node: &$lt $ty) -> V::Result {
+            walk_walkable!(visitor, node,)
+        })*
+    };
+}
+
 #[macro_export]
 macro_rules! common_visitor_and_walkers {
     ($(($mut: ident))? $Visitor:ident$(<$lt:lifetime>)?) => {
@@ -120,6 +355,139 @@ macro_rules! common_visitor_and_walkers {
             }
         }
 
+        // This macro generates `impl Visitable` and `impl MutVisitable` that do nothing.
+        impl_visitable_noop!(<$($lt)? $($mut)?>
+            AttrId,
+            bool,
+            rustc_span::ByteSymbol,
+            char,
+            crate::token::CommentKind,
+            crate::token::Delimiter,
+            crate::token::Lit,
+            crate::token::LitKind,
+            crate::tokenstream::LazyAttrTokenStream,
+            crate::tokenstream::TokenStream,
+            Movability,
+            Mutability,
+            Result<(), rustc_span::ErrorGuaranteed>,
+            rustc_data_structures::fx::FxHashMap<Symbol, usize>,
+            rustc_span::ErrorGuaranteed,
+            std::borrow::Cow<'_, str>,
+            Symbol,
+            u8,
+            usize,
+        );
+        // `Span` is only a no-op for the non-mutable visitor.
+        $(impl_visitable_noop!(<$lt> Span,);)?
+
+        // This macro generates `impl Visitable` and `impl MutVisitable` that simply iterate over
+        // their contents. We do not use a generic impl for `ThinVec` because we want to allow
+        // custom visits for the `MutVisitor`.
+        impl_visitable_list!(<$($lt)? $($mut)?>
+            ThinVec<AngleBracketedArg>,
+            ThinVec<Attribute>,
+            ThinVec<(Ident, Option<Ident>)>,
+            ThinVec<(NodeId, Path)>,
+            ThinVec<PathSegment>,
+            ThinVec<PreciseCapturingArg>,
+            ThinVec<P<Pat>>,
+            ThinVec<P<Ty>>,
+            ThinVec<P<TyPat>>,
+        );
+
+        // This macro generates `impl Visitable` and `impl MutVisitable` that forward to `Walkable`
+        // or `MutWalkable`. By default, all types that do not have a custom visit method in the
+        // visitor should appear here.
+        impl_visitable_direct!(<$($lt)? $($mut)?>
+            AngleBracketedArg,
+            AngleBracketedArgs,
+            AsmMacro,
+            AssignOpKind,
+            AssocItemConstraintKind,
+            AttrArgs,
+            AttrItem,
+            AttrKind,
+            AttrStyle,
+            FnPtrTy,
+            BindingMode,
+            GenBlockKind,
+            RangeLimits,
+            UnsafeBinderCastKind,
+            BinOpKind,
+            BlockCheckMode,
+            BorrowKind,
+            BoundAsyncness,
+            BoundConstness,
+            BoundPolarity,
+            ByRef,
+            Closure,
+            Const,
+            ConstItem,
+            Defaultness,
+            Delegation,
+            DelegationMac,
+            DelimArgs,
+            DelimSpan,
+            EnumDef,
+            Extern,
+            ForLoopKind,
+            FormatArgPosition,
+            FormatArgsPiece,
+            FormatArgument,
+            FormatArgumentKind,
+            FormatArguments,
+            FormatPlaceholder,
+            GenericParamKind,
+            Impl,
+            ImplPolarity,
+            Inline,
+            InlineAsmOperand,
+            InlineAsmRegOrRegClass,
+            InlineAsmTemplatePiece,
+            IsAuto,
+            LocalKind,
+            MacCallStmt,
+            MacStmtStyle,
+            MatchKind,
+            MethodCall,
+            ModKind,
+            ModSpans,
+            MutTy,
+            NormalAttr,
+            Parens,
+            ParenthesizedArgs,
+            PatFieldsRest,
+            PatKind,
+            RangeEnd,
+            RangeSyntax,
+            Recovered,
+            Safety,
+            StaticItem,
+            StrLit,
+            StrStyle,
+            StructExpr,
+            StructRest,
+            Term,
+            Trait,
+            TraitBoundModifiers,
+            TraitObjectSyntax,
+            TyAlias,
+            TyAliasWhereClause,
+            TyAliasWhereClauses,
+            TyKind,
+            TyPatKind,
+            UnOp,
+            UnsafeBinderTy,
+            UnsafeSource,
+            UseTreeKind,
+            VisibilityKind,
+            WhereBoundPredicate,
+            WhereClause,
+            WhereEqPredicate,
+            WhereRegionPredicate,
+            YieldKind,
+        );
+
         /// Each method of this trait is a hook to be potentially
         /// overridden. Each method's default implementation recursively visits
         /// the substructure of the input via the corresponding `walk` method;
@@ -169,47 +537,82 @@ macro_rules! common_visitor_and_walkers {
             // field access version will continue working and it would be easy to
             // forget to add handling for it.
             fn visit_ident(&mut self, Ident { name: _, span }: &$($lt)? $($mut)? Ident) -> Self::Result {
+                impl_visitable!(|&$($lt)? $($mut)? self: Ident, visitor: &mut V, _extra: ()| {
+                    visitor.visit_ident(self)
+                });
                 visit_span(self, span)
             }
 
-            fn visit_foreign_mod(&mut self, nm: &$($lt)? $($mut)? ForeignMod) -> Self::Result {
-                walk_foreign_mod(self, nm)
-            }
-
-            fn visit_foreign_item(&mut self, i: &$($lt)? $($mut)? ForeignItem) -> Self::Result {
-                walk_item(self, i)
-            }
-
-            fn visit_item(&mut self, i: &$($lt)? $($mut)? Item) -> Self::Result {
-                walk_item(self, i)
-            }
-
-            fn visit_local(&mut self, l: &$($lt)? $($mut)? Local) -> Self::Result {
-                walk_local(self, l)
-            }
-
-            fn visit_block(&mut self, b: &$($lt)? $($mut)? Block) -> Self::Result {
-                walk_block(self, b)
-            }
-
-            fn visit_param(&mut self, param: &$($lt)? $($mut)? Param) -> Self::Result {
-                walk_param(self, param)
-            }
-
-            fn visit_arm(&mut self, a: &$($lt)? $($mut)? Arm) -> Self::Result {
-                walk_arm(self, a)
-            }
-
-            fn visit_pat(&mut self, p: &$($lt)? $($mut)? Pat) -> Self::Result {
-                walk_pat(self, p)
-            }
-
-            fn visit_anon_const(&mut self, c: &$($lt)? $($mut)? AnonConst) -> Self::Result {
-                walk_anon_const(self, c)
-            }
-
-            fn visit_expr(&mut self, ex: &$($lt)? $($mut)? Expr) -> Self::Result {
-                walk_expr(self, ex)
+            // This macro defines a custom visit method for each listed type.
+            // It implements `impl Visitable` and `impl MutVisitable` to call those methods on the
+            // visitor.
+            impl_visitable_calling_walkable!(<$($lt)? $($mut)?>
+                fn visit_anon_const(AnonConst);
+                fn visit_arm(Arm);
+                //fn visit_assoc_item(AssocItem, _ctxt: AssocCtxt);
+                fn visit_assoc_item_constraint(AssocItemConstraint);
+                fn visit_attribute(Attribute);
+                fn visit_block(Block);
+                //fn visit_nested_use_tree((UseTree, NodeId));
+                fn visit_capture_by(CaptureBy);
+                fn visit_closure_binder(ClosureBinder);
+                fn visit_contract(FnContract);
+                fn visit_coroutine_kind(CoroutineKind);
+                fn visit_crate(Crate);
+                fn visit_expr(Expr);
+                fn visit_expr_field(ExprField);
+                fn visit_field_def(FieldDef);
+                fn visit_fn_decl(FnDecl);
+                fn visit_fn_header(FnHeader);
+                fn visit_fn_ret_ty(FnRetTy);
+                //fn visit_foreign_item(ForeignItem);
+                fn visit_foreign_mod(ForeignMod);
+                fn visit_format_args(FormatArgs);
+                fn visit_generic_arg(GenericArg);
+                fn visit_generic_args(GenericArgs);
+                fn visit_generic_param(GenericParam);
+                fn visit_generics(Generics);
+                fn visit_inline_asm(InlineAsm);
+                fn visit_inline_asm_sym(InlineAsmSym);
+                //fn visit_item(Item);
+                fn visit_label(Label);
+                fn visit_lifetime(Lifetime, _ctxt: LifetimeCtxt);
+                fn visit_local(Local);
+                fn visit_mac_call(MacCall);
+                fn visit_macro_def(MacroDef);
+                fn visit_param_bound(GenericBound, _ctxt: BoundKind);
+                fn visit_param(Param);
+                fn visit_pat_field(PatField);
+                fn visit_path(Path);
+                fn visit_path_segment(PathSegment);
+                fn visit_pat(Pat);
+                fn visit_poly_trait_ref(PolyTraitRef);
+                fn visit_precise_capturing_arg(PreciseCapturingArg);
+                fn visit_qself(QSelf);
+                fn visit_trait_ref(TraitRef);
+                fn visit_ty_pat(TyPat);
+                fn visit_ty(Ty);
+                fn visit_use_tree(UseTree);
+                fn visit_variant_data(VariantData);
+                fn visit_variant(Variant);
+                fn visit_vis(Visibility);
+                fn visit_where_predicate_kind(WherePredicateKind);
+                fn visit_where_predicate(WherePredicate);
+            );
+
+            // We want `Visitor` to take the `NodeId` by value.
+            fn visit_id(&mut self, _id: $(&$mut)? NodeId) -> Self::Result {
+                $(impl_visitable!(
+                    |&$lt self: NodeId, visitor: &mut V, _extra: ()| {
+                        visitor.visit_id(*self)
+                    }
+                );)?
+                $(impl_visitable!(
+                    |&$mut self: NodeId, visitor: &mut V, _extra: ()| {
+                        visitor.visit_id(self)
+                    }
+                );)?
+                Self::Result::output()
             }
 
             /// This method is a hack to workaround unstable of `stmt_expr_attributes`.
@@ -218,34 +621,25 @@ macro_rules! common_visitor_and_walkers {
                 self.visit_expr(ex)
             }
 
-            fn visit_ty(&mut self, t: &$($lt)? $($mut)? Ty) -> Self::Result {
-                walk_ty(self, t)
-            }
-
-            fn visit_ty_pat(&mut self, t: &$($lt)? $($mut)? TyPat) -> Self::Result {
-                walk_ty_pat(self, t)
-            }
-
-            fn visit_generic_param(&mut self, param: &$($lt)? $($mut)? GenericParam) -> Self::Result {
-                walk_generic_param(self, param)
-            }
-
-            fn visit_generics(&mut self, g: &$($lt)? $($mut)? Generics) -> Self::Result {
-                walk_generics(self, g)
-            }
-            fn visit_closure_binder(&mut self, b: &$($lt)? $($mut)? ClosureBinder) -> Self::Result {
-                walk_closure_binder(self, b)
-            }
-            fn visit_contract(&mut self, c: &$($lt)? $($mut)? FnContract) -> Self::Result {
-                walk_contract(self, c)
+            fn visit_item(&mut self, item: &$($lt)? $($mut)? Item) -> Self::Result {
+                impl_visitable!(|&$($lt)? $($mut)? self: Item, vis: &mut V, _extra: ()| {
+                    vis.visit_item(self)
+                });
+                walk_item(self, item)
             }
 
-            fn visit_where_predicate(&mut self, p: &$($lt)? $($mut)? WherePredicate) -> Self::Result {
-                walk_where_predicate(self, p)
+            fn visit_foreign_item(&mut self, item: &$($lt)? $($mut)? ForeignItem) -> Self::Result {
+                impl_visitable!(|&$($lt)? $($mut)? self: ForeignItem, vis: &mut V, _extra: ()| {
+                    vis.visit_foreign_item(self)
+                });
+                walk_item(self, item)
             }
 
-            fn visit_where_predicate_kind(&mut self, k: &$($lt)? $($mut)? WherePredicateKind) -> Self::Result {
-                walk_where_predicate_kind(self, k)
+            fn visit_assoc_item(&mut self, item: &$($lt)? $($mut)? AssocItem, ctxt: AssocCtxt) -> Self::Result {
+                impl_visitable!(|&$($lt)? $($mut)? self: AssocItem, vis: &mut V, ctxt: AssocCtxt| {
+                    vis.visit_assoc_item(self, ctxt)
+                });
+                walk_assoc_item(self, item, ctxt)
             }
 
             // for `MutVisitor`: `Span` and `NodeId` are mutated at the caller site.
@@ -258,141 +652,6 @@ macro_rules! common_visitor_and_walkers {
                 walk_fn(self, fk)
             }
 
-            fn visit_assoc_item(&mut self, i: &$($lt)? $($mut)? AssocItem, ctxt: AssocCtxt) -> Self::Result {
-                walk_assoc_item(self, i, ctxt)
-            }
-
-            fn visit_trait_ref(&mut self, t: &$($lt)? $($mut)? TraitRef) -> Self::Result {
-                walk_trait_ref(self, t)
-            }
-
-            fn visit_param_bound(&mut self, bounds: &$($lt)? $($mut)? GenericBound, _ctxt: BoundKind) -> Self::Result {
-                walk_param_bound(self, bounds)
-            }
-
-            fn visit_precise_capturing_arg(&mut self, arg: &$($lt)? $($mut)? PreciseCapturingArg) -> Self::Result {
-                walk_precise_capturing_arg(self, arg)
-            }
-
-            fn visit_poly_trait_ref(&mut self, t: &$($lt)? $($mut)? PolyTraitRef) -> Self::Result {
-                walk_poly_trait_ref(self, t)
-            }
-
-            fn visit_variant_data(&mut self, s: &$($lt)? $($mut)? VariantData) -> Self::Result {
-                walk_variant_data(self, s)
-            }
-
-            fn visit_field_def(&mut self, s: &$($lt)? $($mut)? FieldDef) -> Self::Result {
-                walk_field_def(self, s)
-            }
-
-            fn visit_variant(&mut self, v: &$($lt)? $($mut)? Variant) -> Self::Result {
-                walk_variant(self, v)
-            }
-
-            fn visit_label(&mut self, label: &$($lt)? $($mut)? Label) -> Self::Result {
-                walk_label(self, label)
-            }
-
-            fn visit_lifetime(&mut self, lifetime: &$($lt)? $($mut)? Lifetime, $(${ignore($lt)} _: LifetimeCtxt )?) -> Self::Result {
-                walk_lifetime(self, lifetime)
-            }
-
-            fn visit_mac_call(&mut self, mac: &$($lt)? $($mut)? MacCall) -> Self::Result {
-                walk_mac(self, mac)
-            }
-
-            fn visit_id(&mut self, _id: $(&$mut)? NodeId) -> Self::Result {
-                Self::Result::output()
-            }
-
-            fn visit_macro_def(&mut self, macro_def: &$($lt)? $($mut)? MacroDef) -> Self::Result {
-                walk_macro_def(self, macro_def)
-            }
-
-            fn visit_path(&mut self, path: &$($lt)? $($mut)? Path) -> Self::Result {
-                walk_path(self, path)
-            }
-
-            fn visit_use_tree(&mut self, use_tree: &$($lt)? $($mut)? UseTree) -> Self::Result {
-                walk_use_tree(self, use_tree)
-            }
-
-            fn visit_path_segment(&mut self, path_segment: &$($lt)? $($mut)? PathSegment) -> Self::Result {
-                walk_path_segment(self, path_segment)
-            }
-
-            fn visit_generic_args(&mut self, generic_args: &$($lt)? $($mut)? GenericArgs) -> Self::Result {
-                walk_generic_args(self, generic_args)
-            }
-
-            fn visit_generic_arg(&mut self, generic_arg: &$($lt)? $($mut)? GenericArg) -> Self::Result {
-                walk_generic_arg(self, generic_arg)
-            }
-
-            fn visit_assoc_item_constraint(
-                &mut self,
-                constraint: &$($lt)? $($mut)? AssocItemConstraint,
-            ) -> Self::Result {
-                walk_assoc_item_constraint(self, constraint)
-            }
-
-            fn visit_attribute(&mut self, attr: &$($lt)? $($mut)? Attribute) -> Self::Result {
-                walk_attribute(self, attr)
-            }
-
-            fn visit_vis(&mut self, vis: &$($lt)? $($mut)? Visibility) -> Self::Result {
-                walk_vis(self, vis)
-            }
-
-            fn visit_fn_ret_ty(&mut self, ret_ty: &$($lt)? $($mut)? FnRetTy) -> Self::Result {
-                walk_fn_ret_ty(self, ret_ty)
-            }
-
-            fn visit_fn_header(&mut self, header: &$($lt)? $($mut)? FnHeader) -> Self::Result {
-                walk_fn_header(self, header)
-            }
-
-            fn visit_expr_field(&mut self, f: &$($lt)? $($mut)? ExprField) -> Self::Result {
-                walk_expr_field(self, f)
-            }
-
-            fn visit_pat_field(&mut self, fp: &$($lt)? $($mut)? PatField) -> Self::Result {
-                walk_pat_field(self, fp)
-            }
-
-            fn visit_crate(&mut self, krate: &$($lt)? $($mut)? Crate) -> Self::Result {
-                walk_crate(self, krate)
-            }
-
-            fn visit_inline_asm(&mut self, asm: &$($lt)? $($mut)? InlineAsm) -> Self::Result {
-                walk_inline_asm(self, asm)
-            }
-
-            fn visit_format_args(&mut self, fmt: &$($lt)? $($mut)? FormatArgs) -> Self::Result {
-                walk_format_args(self, fmt)
-            }
-
-            fn visit_inline_asm_sym(&mut self, sym: &$($lt)? $($mut)? InlineAsmSym) -> Self::Result {
-                walk_inline_asm_sym(self, sym)
-            }
-
-            fn visit_capture_by(&mut self, capture_by: &$($lt)? $($mut)? CaptureBy) -> Self::Result {
-                walk_capture_by(self, capture_by)
-            }
-
-            fn visit_coroutine_kind(&mut self, coroutine_kind: &$($lt)? $($mut)? CoroutineKind) -> Self::Result {
-                walk_coroutine_kind(self, coroutine_kind)
-            }
-
-            fn visit_fn_decl(&mut self, fn_decl: &$($lt)? $($mut)? FnDecl) -> Self::Result {
-                walk_fn_decl(self, fn_decl)
-            }
-
-            fn visit_qself(&mut self, qs: &$($lt)? $($mut)? Option<P<QSelf>>) -> Self::Result {
-                walk_qself(self, qs)
-            }
-
             // (non-mut) `Visitor`-only methods
             $(
                 fn visit_stmt(&mut self, s: &$lt Stmt) -> Self::Result {
@@ -407,6 +666,16 @@ macro_rules! common_visitor_and_walkers {
 
             // `MutVisitor`-only methods
             $(
+                // Span visiting is no longer used, but we keep it for now,
+                // in case it's needed for something like #127241.
+                #[inline]
+                fn visit_span(&mut self, _sp: &$mut Span) {
+                    impl_visitable!(|&mut self: Span, visitor: &mut V, _extra: ()| {
+                        visitor.visit_span(self)
+                    });
+                    // Do nothing.
+                }
+
                 fn flat_map_foreign_item(&mut self, ni: P<ForeignItem>) -> SmallVec<[P<ForeignItem>; 1]> {
                     walk_flat_map_foreign_item(self, ni)
                 }
@@ -462,12 +731,6 @@ macro_rules! common_visitor_and_walkers {
                     walk_flat_map_where_predicate(self, where_predicate)
                 }
 
-                // Span visiting is no longer used, but we keep it for now,
-                // in case it's needed for something like #127241.
-                fn visit_span(&mut self, _sp: &$mut Span) {
-                    // Do nothing.
-                }
-
                 fn flat_map_pat_field(&mut self, fp: PatField) -> SmallVec<[PatField; 1]> {
                     walk_flat_map_pat_field(self, fp)
                 }
@@ -492,148 +755,45 @@ macro_rules! common_visitor_and_walkers {
             #[inline]
         )?
         fn visit_span<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, span: &$($lt)? $($mut)? Span) -> V::Result {
-            $(
-                ${ignore($mut)}
-                vis.visit_span(span);
-            )?
-            V::Result::output()
-        }
-
-        /// helper since `Visitor` wants `NodeId` but `MutVisitor` wants `&mut NodeId`
-        $(${ignore($lt)}
-            #[expect(rustc::pass_by_value)]
-        )?
-        #[inline]
-        fn visit_id<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, id: &$($lt)? $($mut)? NodeId) -> V::Result {
-            // deref `&NodeId` into `NodeId` only for `Visitor`
-            vis.visit_id( $(${ignore($lt)} * )? id)
-        }
-
-        // this is only used by the MutVisitor. We include this symmetry here to make writing other functions easier
-        fn visit_safety<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, safety: &$($lt)? $($mut)? Safety) -> V::Result {
-            match safety {
-                Safety::Unsafe(span) => visit_span(vis, span),
-                Safety::Safe(span) => visit_span(vis, span),
-                Safety::Default => { V::Result::output() }
-            }
-        }
-
-        fn visit_constness<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, constness: &$($lt)? $($mut)? Const) -> V::Result {
-            match constness {
-                Const::Yes(span) => visit_span(vis, span),
-                Const::No => {
-                    V::Result::output()
-                }
-            }
-        }
-
-        fn visit_defaultness<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, defaultness: &$($lt)? $($mut)? Defaultness) -> V::Result {
-            match defaultness {
-                Defaultness::Default(span) => visit_span(vis, span),
-                Defaultness::Final => {
-                    V::Result::output()
-                }
-            }
-        }
-
-        fn visit_polarity<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            polarity: &$($lt)? $($mut)? ImplPolarity,
-        ) -> V::Result {
-            match polarity {
-                ImplPolarity::Positive => { V::Result::output() }
-                ImplPolarity::Negative(span) => visit_span(vis, span),
-            }
-        }
-
-        $(${ignore($lt)}
-            #[inline]
-        )?
-        fn visit_modifiers<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            m: &$($lt)? $($mut)? TraitBoundModifiers
-        ) -> V::Result {
-            let TraitBoundModifiers { constness, asyncness, polarity } = m;
-            match constness {
-                BoundConstness::Never => {}
-                BoundConstness::Always(span) | BoundConstness::Maybe(span) => try_visit!(visit_span(vis, span)),
-            }
-            match asyncness {
-                BoundAsyncness::Normal => {}
-                BoundAsyncness::Async(span) => try_visit!(visit_span(vis, span)),
-            }
-            match polarity {
-                BoundPolarity::Positive => {}
-                BoundPolarity::Negative(span) | BoundPolarity::Maybe(span) => try_visit!(visit_span(vis, span)),
-            }
+            $(${ignore($mut)} vis.visit_span(span))?;
             V::Result::output()
         }
 
-        $(${ignore($lt)}
-            #[inline]
-        )?
-        fn walk_capture_by<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            capture_by: &$($lt)? $($mut)? CaptureBy
-        ) -> V::Result {
-            match capture_by {
-                CaptureBy::Ref => { V::Result::output() }
-                CaptureBy::Value { move_kw } => {
-                    visit_span(vis, move_kw)
-                }
-                CaptureBy::Use { use_kw } => {
-                    visit_span(vis, use_kw)
-                }
+        $(impl_visitable!(|&$lt self: ThinVec<(UseTree, NodeId)>, vis: &mut V, _extra: ()| {
+            for (nested_tree, nested_id) in self {
+                try_visit!(vis.visit_nested_use_tree(nested_tree, *nested_id));
             }
-        }
-
-        fn visit_bounds<$($lt,)? V: $Visitor$(<$lt>)?>(visitor: &mut V, bounds: &$($lt)? $($mut)? GenericBounds, ctxt: BoundKind) -> V::Result {
-            walk_list!(visitor, visit_param_bound, bounds, ctxt);
             V::Result::output()
-        }
-
-        pub fn walk_label<$($lt,)? V: $Visitor$(<$lt>)?>(visitor: &mut V, Label { ident }: &$($lt)? $($mut)? Label) -> V::Result {
-            visitor.visit_ident(ident)
-        }
+        });)?
+        $(impl_visitable_list!(<$mut> ThinVec<(UseTree, NodeId)>,);)?
 
-        pub fn walk_fn_header<$($lt,)? V: $Visitor$(<$lt>)?>(visitor: &mut V, header: &$($lt)? $($mut)? FnHeader) -> V::Result {
-            let FnHeader { safety, coroutine_kind, constness, ext: _ } = header;
-            try_visit!(visit_constness(visitor, constness));
-            visit_opt!(visitor, visit_coroutine_kind, coroutine_kind);
-            visit_safety(visitor, safety)
-        }
-
-        pub fn walk_lifetime<$($lt,)? V: $Visitor$(<$lt>)?>(visitor: &mut V, Lifetime { id, ident }: &$($lt)? $($mut)? Lifetime) -> V::Result {
-            try_visit!(visit_id(visitor, id));
-            visitor.visit_ident(ident)
-        }
-
-        fn walk_item_ctxt<$($lt,)? V: $Visitor$(<$lt>)?, K: WalkItemKind>(
+        fn walk_item_inner<$($lt,)? K: WalkItemKind, V: $Visitor$(<$lt>)?>(
             visitor: &mut V,
             item: &$($mut)? $($lt)? Item<K>,
             ctxt: K::Ctxt,
         ) -> V::Result {
             let Item { attrs, id, kind, vis, span, tokens: _ } = item;
-            try_visit!(visit_id(visitor, id));
-            walk_list!(visitor, visit_attribute, attrs);
-            try_visit!(visitor.visit_vis(vis));
+            visit_visitable!($($mut)? visitor, id, attrs, vis);
             try_visit!(kind.walk(*span, *id, vis, ctxt, visitor));
-            visit_span(visitor, span)
+            visit_visitable!($($mut)? visitor, span);
+            V::Result::output()
         }
 
-        pub fn walk_item<$($lt,)? V: $Visitor$(<$lt>)?, K: WalkItemKind<Ctxt = ()>>(
+        // Do not implement `Walkable`/`MutWalkable` for *Item to avoid confusion.
+        pub fn walk_item<$($lt,)? K: WalkItemKind<Ctxt = ()>, V: $Visitor$(<$lt>)?>(
             visitor: &mut V,
             item: &$($mut)? $($lt)? Item<K>,
         ) -> V::Result {
-            walk_item_ctxt(visitor, item, ())
+            walk_item_inner(visitor, item, ())
         }
 
-        pub fn walk_assoc_item<$($lt,)? V: $Visitor$(<$lt>)?>(
+        // Do not implement `Walkable`/`MutWalkable` for *Item to avoid confusion.
+        pub fn walk_assoc_item<$($lt,)? K: WalkItemKind<Ctxt = AssocCtxt>, V: $Visitor$(<$lt>)?>(
             visitor: &mut V,
-            item: &$($mut)? $($lt)? AssocItem,
+            item: &$($mut)? $($lt)? Item<K>,
             ctxt: AssocCtxt,
         ) -> V::Result {
-            walk_item_ctxt(visitor, item, ctxt)
+            walk_item_inner(visitor, item, ctxt)
         }
 
         impl WalkItemKind for ItemKind {
@@ -647,180 +807,52 @@ macro_rules! common_visitor_and_walkers {
                 vis: &mut V,
             ) -> V::Result {
                 match self {
-                    ItemKind::ExternCrate(_orig_name, ident) => vis.visit_ident(ident),
-                    ItemKind::Use(use_tree) => vis.visit_use_tree(use_tree),
-                    ItemKind::Static(box StaticItem {
-                        ident,
-                        ty,
-                        safety: _,
-                        mutability: _,
-                        expr,
-                        define_opaque,
-                    }) => {
-                        try_visit!(vis.visit_ident(ident));
-                        try_visit!(vis.visit_ty(ty));
-                        visit_opt!(vis, visit_expr, expr);
-                        walk_define_opaques(vis, define_opaque)
-                    }
-                    ItemKind::Const(item) => {
-                        walk_const_item(vis, item)
-                    }
                     ItemKind::Fn(func) => {
                         let kind = FnKind::Fn(FnCtxt::Free, visibility, &$($mut)? *func);
-                        vis.visit_fn(kind, span, id)
-                    }
-                    ItemKind::Mod(safety, ident, mod_kind) => {
-                        try_visit!(visit_safety(vis, safety));
-                        try_visit!(vis.visit_ident(ident));
-                        match mod_kind {
-                            ModKind::Loaded(
-                                items,
-                                _inline,
-                                ModSpans { inner_span, inject_use_span },
-                                _,
-                            ) => {
-                                try_visit!(visit_items(vis, items));
-                                try_visit!(visit_span(vis, inner_span));
-                                try_visit!(visit_span(vis, inject_use_span));
-                            }
-                            ModKind::Unloaded => {}
-                        }
-                        V::Result::output()
-                    }
-                    ItemKind::ForeignMod(nm) => vis.visit_foreign_mod(nm),
-                    ItemKind::GlobalAsm(asm) => vis.visit_inline_asm(asm),
-                    ItemKind::TyAlias(box TyAlias {
-                        defaultness,
-                        ident,
-                        generics,
-                        $(${ignore($lt)} #[expect(unused)])?
-                        where_clauses,
-                        bounds,
-                        ty,
-                    }) => {
-                        try_visit!(visit_defaultness(vis, defaultness));
-                        try_visit!(vis.visit_ident(ident));
-                        try_visit!(vis.visit_generics(generics));
-                        try_visit!(visit_bounds(vis, bounds, BoundKind::Bound));
-                        visit_opt!(vis, visit_ty, ty);
-                        $(${ignore($mut)}
-                            walk_ty_alias_where_clauses(vis, where_clauses);
-                        )?
-                        V::Result::output()
-                    }
-                    ItemKind::Enum(ident, generics, enum_definition) => {
-                        try_visit!(vis.visit_ident(ident));
-                        try_visit!(vis.visit_generics(generics));
-                        visit_variants(vis, &$($mut)? enum_definition.variants)
+                        try_visit!(vis.visit_fn(kind, span, id));
                     }
+                    ItemKind::ExternCrate(orig_name, ident) =>
+                        visit_visitable!($($mut)? vis, orig_name, ident),
+                    ItemKind::Use(use_tree) =>
+                        visit_visitable!($($mut)? vis, use_tree),
+                    ItemKind::Static(item) =>
+                        visit_visitable!($($mut)? vis, item),
+                    ItemKind::Const(item) =>
+                        visit_visitable!($($mut)? vis, item),
+                    ItemKind::Mod(safety, ident, mod_kind) =>
+                        visit_visitable!($($mut)? vis, safety, ident, mod_kind),
+                    ItemKind::ForeignMod(nm) =>
+                        visit_visitable!($($mut)? vis, nm),
+                    ItemKind::GlobalAsm(asm) =>
+                        visit_visitable!($($mut)? vis, asm),
+                    ItemKind::TyAlias(ty_alias) =>
+                        visit_visitable!($($mut)? vis, ty_alias),
+                    ItemKind::Enum(ident, generics, enum_definition) =>
+                        visit_visitable!($($mut)? vis, ident, generics, enum_definition),
                     ItemKind::Struct(ident, generics, variant_data)
-                    | ItemKind::Union(ident, generics, variant_data) => {
-                        try_visit!(vis.visit_ident(ident));
-                        try_visit!(vis.visit_generics(generics));
-                        vis.visit_variant_data(variant_data)
-                    }
-                    ItemKind::Impl(box Impl {
-                        defaultness,
-                        safety,
-                        generics,
-                        constness,
-                        polarity,
-                        of_trait,
-                        self_ty,
-                        items,
-                    }) => {
-                        try_visit!(visit_defaultness(vis, defaultness));
-                        try_visit!(visit_safety(vis, safety));
-                        try_visit!(vis.visit_generics(generics));
-                        try_visit!(visit_constness(vis, constness));
-                        try_visit!(visit_polarity(vis, polarity));
-                        visit_opt!(vis, visit_trait_ref, of_trait);
-                        try_visit!(vis.visit_ty(self_ty));
-                        visit_assoc_items(vis, items, AssocCtxt::Impl { of_trait: of_trait.is_some() })
-                    }
-                    ItemKind::Trait(box Trait { constness, safety, is_auto: _, ident, generics, bounds, items }) => {
-                        try_visit!(visit_constness(vis, constness));
-                        try_visit!(visit_safety(vis, safety));
-                        try_visit!(vis.visit_ident(ident));
-                        try_visit!(vis.visit_generics(generics));
-                        try_visit!(visit_bounds(vis, bounds, BoundKind::Bound));
-                        visit_assoc_items(vis, items, AssocCtxt::Trait)
-                    }
+                    | ItemKind::Union(ident, generics, variant_data) =>
+                        visit_visitable!($($mut)? vis, ident, generics, variant_data),
+                    ItemKind::Impl(impl_) =>
+                        visit_visitable!($($mut)? vis, impl_),
+                    ItemKind::Trait(trait_) =>
+                        visit_visitable!($($mut)? vis, trait_),
                     ItemKind::TraitAlias(ident, generics, bounds) => {
-                        try_visit!(vis.visit_ident(ident));
-                        try_visit!(vis.visit_generics(generics));
-                        visit_bounds(vis, bounds, BoundKind::Bound)
-                    }
-                    ItemKind::MacCall(m) => vis.visit_mac_call(m),
-                    ItemKind::MacroDef(ident, def) => {
-                        try_visit!(vis.visit_ident(ident));
-                        vis.visit_macro_def(def)
-                    }
-                    ItemKind::Delegation(box Delegation {
-                        id,
-                        qself,
-                        path,
-                        ident,
-                        rename,
-                        body,
-                        from_glob: _,
-                    }) => {
-                        try_visit!(visit_id(vis, id));
-                        try_visit!(vis.visit_qself(qself));
-                        try_visit!(vis.visit_path(path));
-                        try_visit!(vis.visit_ident(ident));
-                        visit_opt!(vis, visit_ident, rename);
-                        visit_opt!(vis, visit_block, body);
-                        V::Result::output()
-                    }
-                    ItemKind::DelegationMac(box DelegationMac { qself, prefix, suffixes, body }) => {
-                        try_visit!(vis.visit_qself(qself));
-                        try_visit!(vis.visit_path(prefix));
-                        if let Some(suffixes) = suffixes {
-                            for (ident, rename) in suffixes {
-                                try_visit!(vis.visit_ident(ident));
-                                visit_opt!(vis, visit_ident, rename);
-                            }
-                        }
-                        visit_opt!(vis, visit_block, body);
-                        V::Result::output()
+                        visit_visitable!($($mut)? vis, ident, generics);
+                        visit_visitable_with!($($mut)? vis, bounds, BoundKind::Bound)
                     }
+                    ItemKind::MacCall(m) =>
+                        visit_visitable!($($mut)? vis, m),
+                    ItemKind::MacroDef(ident, def) =>
+                        visit_visitable!($($mut)? vis, ident, def),
+                    ItemKind::Delegation(delegation) =>
+                        visit_visitable!($($mut)? vis, delegation),
+                    ItemKind::DelegationMac(dm) =>
+                        visit_visitable!($($mut)? vis, dm),
                 }
+                V::Result::output()
             }
         }
 
-        fn walk_const_item<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            item: &$($lt)? $($mut)? ConstItem,
-        ) -> V::Result {
-            let ConstItem { defaultness, ident, generics, ty, expr, define_opaque } = item;
-            try_visit!(visit_defaultness(vis, defaultness));
-            try_visit!(vis.visit_ident(ident));
-            try_visit!(vis.visit_generics(generics));
-            try_visit!(vis.visit_ty(ty));
-            visit_opt!(vis, visit_expr, expr);
-            walk_define_opaques(vis, define_opaque)
-        }
-
-        fn walk_foreign_mod<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, foreign_mod: &$($lt)? $($mut)? ForeignMod) -> V::Result {
-            let ForeignMod { extern_span: _, safety, abi: _, items } = foreign_mod;
-            try_visit!(visit_safety(vis, safety));
-            visit_foreign_items(vis, items)
-        }
-
-        fn walk_define_opaques<$($lt,)? V: $Visitor$(<$lt>)?>(
-            visitor: &mut V,
-            define_opaque: &$($lt)? $($mut)? Option<ThinVec<(NodeId, Path)>>,
-        ) -> V::Result {
-            if let Some(define_opaque) = define_opaque {
-                for (id, path) in define_opaque {
-                    try_visit!(visit_id(visitor, id));
-                    try_visit!(visitor.visit_path(path));
-                }
-            }
-            V::Result::output()
-        }
-
         impl WalkItemKind for AssocItemKind {
             type Ctxt = AssocCtxt;
             fn walk<$($lt,)? V: $Visitor$(<$lt>)?>(
@@ -832,64 +864,22 @@ macro_rules! common_visitor_and_walkers {
                 vis: &mut V,
             ) -> V::Result {
                 match self {
-                    AssocItemKind::Const(item) => {
-                        walk_const_item(vis, item)
-                    }
+                    AssocItemKind::Const(item) =>
+                        visit_visitable!($($mut)? vis, item),
                     AssocItemKind::Fn(func) => {
-                        vis.visit_fn(FnKind::Fn(FnCtxt::Assoc(ctxt), visibility, &$($mut)? *func), span, id)
-                    }
-                    AssocItemKind::Type(box TyAlias {
-                        generics,
-                        ident,
-                        bounds,
-                        ty,
-                        defaultness,
-                        $(${ignore($lt)} #[expect(unused)])?
-                        where_clauses,
-                    }) => {
-                        try_visit!(visit_defaultness(vis, defaultness));
-                        try_visit!(vis.visit_ident(ident));
-                        try_visit!(vis.visit_generics(generics));
-                        try_visit!(visit_bounds(vis, bounds, BoundKind::Bound));
-                        visit_opt!(vis, visit_ty, ty);
-                        $(${ignore($mut)}
-                            walk_ty_alias_where_clauses(vis, where_clauses);
-                        )?
-                        V::Result::output()
-                    }
-                    AssocItemKind::MacCall(mac) => {
-                        vis.visit_mac_call(mac)
-                    }
-                    AssocItemKind::Delegation(box Delegation {
-                        id,
-                        qself,
-                        path,
-                        ident,
-                        rename,
-                        body,
-                        from_glob: _,
-                    }) => {
-                        try_visit!(visit_id(vis, id));
-                        try_visit!(vis.visit_qself(qself));
-                        try_visit!(vis.visit_path(path));
-                        try_visit!(vis.visit_ident(ident));
-                        visit_opt!(vis, visit_ident, rename);
-                        visit_opt!(vis, visit_block, body);
-                        V::Result::output()
-                    }
-                    AssocItemKind::DelegationMac(box DelegationMac { qself, prefix, suffixes, body }) => {
-                        try_visit!(vis.visit_qself(qself));
-                        try_visit!(vis.visit_path(prefix));
-                        if let Some(suffixes) = suffixes {
-                            for (ident, rename) in suffixes {
-                                try_visit!(vis.visit_ident(ident));
-                                visit_opt!(vis, visit_ident, rename);
-                            }
-                        }
-                        visit_opt!(vis, visit_block, body);
-                        V::Result::output()
+                        let kind = FnKind::Fn(FnCtxt::Assoc(ctxt), visibility, &$($mut)? *func);
+                        try_visit!(vis.visit_fn(kind, span, id))
                     }
+                    AssocItemKind::Type(alias) =>
+                        visit_visitable!($($mut)? vis, alias),
+                    AssocItemKind::MacCall(mac) =>
+                        visit_visitable!($($mut)? vis, mac),
+                    AssocItemKind::Delegation(delegation) =>
+                        visit_visitable!($($mut)? vis, delegation),
+                    AssocItemKind::DelegationMac(dm) =>
+                        visit_visitable!($($mut)? vis, dm),
                 }
+                V::Result::output()
             }
         }
 
@@ -904,545 +894,18 @@ macro_rules! common_visitor_and_walkers {
                 vis: &mut V,
             ) -> V::Result {
                 match self {
-                    ForeignItemKind::Static(box StaticItem {
-                        ident,
-                        ty,
-                        mutability: _,
-                        expr,
-                        safety: _,
-                        define_opaque,
-                    }) => {
-                        try_visit!(vis.visit_ident(ident));
-                        try_visit!(vis.visit_ty(ty));
-                        visit_opt!(vis, visit_expr, expr);
-                        walk_define_opaques(vis, define_opaque)
-                    }
+                    ForeignItemKind::Static(item) =>
+                        visit_visitable!($($mut)? vis, item),
                     ForeignItemKind::Fn(func) => {
-                        vis.visit_fn(FnKind::Fn(FnCtxt::Foreign, visibility, &$($mut)?*func), span, id)
-                    }
-                    ForeignItemKind::TyAlias(box TyAlias {
-                        defaultness,
-                        ident,
-                        generics,
-                        bounds,
-                        ty,
-                        $(${ignore($lt)} #[expect(unused)])?
-                        where_clauses,
-                    }) => {
-                        try_visit!(visit_defaultness(vis, defaultness));
-                        try_visit!(vis.visit_ident(ident));
-                        try_visit!(vis.visit_generics(generics));
-                        try_visit!(visit_bounds(vis, bounds, BoundKind::Bound));
-                        visit_opt!(vis, visit_ty, ty);
-                        $(${ignore($mut)}
-                            walk_ty_alias_where_clauses(vis, where_clauses);
-                        )?
-                        V::Result::output()
-                    }
-                    ForeignItemKind::MacCall(mac) => {
-                        vis.visit_mac_call(mac)
-                    }
-                }
-            }
-        }
-
-        fn walk_coroutine_kind<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            coroutine_kind: &$($lt)? $($mut)? CoroutineKind,
-        ) -> V::Result {
-            let (CoroutineKind::Async { span, closure_id, return_impl_trait_id }
-                | CoroutineKind::Gen { span, closure_id, return_impl_trait_id }
-                | CoroutineKind::AsyncGen { span, closure_id, return_impl_trait_id })
-                = coroutine_kind;
-            try_visit!(visit_id(vis, closure_id));
-            try_visit!(visit_id(vis, return_impl_trait_id));
-            visit_span(vis, span)
-        }
-
-        pub fn walk_pat<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            pattern: &$($lt)? $($mut)? Pat
-        ) -> V::Result {
-            let Pat { id, kind, span, tokens: _ } = pattern;
-            try_visit!(visit_id(vis, id));
-            match kind {
-                PatKind::Err(_guar) => {}
-                PatKind::Missing | PatKind::Wild | PatKind::Rest | PatKind::Never => {}
-                PatKind::Ident(_bmode, ident, optional_subpattern) => {
-                    try_visit!(vis.visit_ident(ident));
-                    visit_opt!(vis, visit_pat, optional_subpattern);
-                }
-                PatKind::Expr(expression) => try_visit!(vis.visit_expr(expression)),
-                PatKind::TupleStruct(opt_qself, path, elems) => {
-                    try_visit!(vis.visit_qself(opt_qself));
-                    try_visit!(vis.visit_path(path));
-                    walk_list!(vis, visit_pat, elems);
-                }
-                PatKind::Path(opt_qself, path) => {
-                    try_visit!(vis.visit_qself(opt_qself));
-                    try_visit!(vis.visit_path(path))
-                }
-                PatKind::Struct(opt_qself, path, fields, _rest) => {
-                    try_visit!(vis.visit_qself(opt_qself));
-                    try_visit!(vis.visit_path(path));
-                    try_visit!(visit_pat_fields(vis, fields));
-                }
-                PatKind::Box(subpattern) | PatKind::Deref(subpattern) | PatKind::Paren(subpattern) => {
-                    try_visit!(vis.visit_pat(subpattern));
-                }
-                PatKind::Ref(subpattern, _ /*mutbl*/) => {
-                    try_visit!(vis.visit_pat(subpattern));
-                }
-                PatKind::Range(lower_bound, upper_bound, _end) => {
-                    visit_opt!(vis, visit_expr, lower_bound);
-                    visit_opt!(vis, visit_expr, upper_bound);
-                    try_visit!(visit_span(vis, span));
-                }
-                PatKind::Guard(subpattern, guard_condition) => {
-                    try_visit!(vis.visit_pat(subpattern));
-                    try_visit!(vis.visit_expr(guard_condition));
-                }
-                PatKind::Tuple(elems) | PatKind::Slice(elems) | PatKind::Or(elems) => {
-                    walk_list!(vis, visit_pat, elems);
-                }
-                PatKind::MacCall(mac) => try_visit!(vis.visit_mac_call(mac)),
-            }
-            visit_span(vis, span)
-        }
-
-        pub fn walk_anon_const<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            constant: &$($lt)? $($mut)? AnonConst,
-        ) -> V::Result {
-            let AnonConst { id, value } = constant;
-            try_visit!(visit_id(vis, id));
-            vis.visit_expr(value)
-        }
-
-        pub fn walk_path_segment<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            segment: &$($lt)? $($mut)? PathSegment,
-        ) -> V::Result {
-            let PathSegment { ident, id, args } = segment;
-            try_visit!(visit_id(vis, id));
-            try_visit!(vis.visit_ident(ident));
-            visit_opt!(vis, visit_generic_args, args);
-            V::Result::output()
-        }
-
-        pub fn walk_block<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            block: &$($lt)? $($mut)? Block
-        ) -> V::Result {
-            let Block { stmts, id, rules: _, span, tokens: _ } = block;
-            try_visit!(visit_id(vis, id));
-            try_visit!(visit_stmts(vis, stmts));
-            visit_span(vis, span)
-        }
-
-
-        pub fn walk_ty<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V, ty: &$($lt)? $($mut)? Ty
-        ) -> V::Result {
-            let Ty { id, kind, span, tokens: _ } = ty;
-            try_visit!(visit_id(vis, id));
-            match kind {
-                TyKind::Err(_guar) => {}
-                TyKind::Infer | TyKind::ImplicitSelf | TyKind::Dummy | TyKind::Never | TyKind::CVarArgs => {}
-                TyKind::Slice(ty) | TyKind::Paren(ty) => try_visit!(vis.visit_ty(ty)),
-                TyKind::Ptr(MutTy { ty, mutbl: _ }) => try_visit!(vis.visit_ty(ty)),
-                TyKind::Ref(opt_lifetime, MutTy { ty, mutbl: _ })
-                | TyKind::PinnedRef(opt_lifetime, MutTy { ty, mutbl: _ }) => {
-                    // FIXME(fee1-dead) asymmetry
-                    visit_opt!(vis, visit_lifetime, opt_lifetime$(${ignore($lt)}, LifetimeCtxt::Ref)?);
-                    try_visit!(vis.visit_ty(ty));
-                }
-                TyKind::Tup(tuple_element_types) => {
-                    walk_list!(vis, visit_ty, tuple_element_types);
-                }
-                TyKind::FnPtr(function_declaration) => {
-                    let FnPtrTy { safety, ext: _, generic_params, decl, decl_span } =
-                        &$($mut)? **function_declaration;
-                    try_visit!(visit_safety(vis, safety));
-                    try_visit!(visit_generic_params(vis, generic_params));
-                    try_visit!(vis.visit_fn_decl(decl));
-                    try_visit!(visit_span(vis, decl_span));
-                }
-                TyKind::UnsafeBinder(binder) => {
-                    try_visit!(visit_generic_params(vis, &$($mut)? binder.generic_params));
-                    try_visit!(vis.visit_ty(&$($mut)? binder.inner_ty));
-                }
-                TyKind::Path(maybe_qself, path) => {
-                    try_visit!(vis.visit_qself(maybe_qself));
-                    try_visit!(vis.visit_path(path));
-                }
-                TyKind::Pat(ty, pat) => {
-                    try_visit!(vis.visit_ty(ty));
-                    try_visit!(vis.visit_ty_pat(pat));
-                }
-                TyKind::Array(ty, length) => {
-                    try_visit!(vis.visit_ty(ty));
-                    try_visit!(vis.visit_anon_const(length));
-                }
-                TyKind::TraitObject(bounds, _syntax) => {
-                    walk_list!(vis, visit_param_bound, bounds, BoundKind::TraitObject);
-                }
-                TyKind::ImplTrait(id, bounds) => {
-                    try_visit!(visit_id(vis, id));
-                    walk_list!(vis, visit_param_bound, bounds, BoundKind::Impl);
-                }
-                TyKind::Typeof(expression) => try_visit!(vis.visit_anon_const(expression)),
-
-                TyKind::MacCall(mac) => try_visit!(vis.visit_mac_call(mac)),
-            }
-            visit_span(vis, span)
-        }
-
-        pub fn walk_crate<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            krate: &$($lt)? $($mut)? Crate,
-        ) -> V::Result {
-            let Crate { attrs, items, spans, id, is_placeholder: _ } = krate;
-            try_visit!(visit_id(vis, id));
-            walk_list!(vis, visit_attribute, attrs);
-            try_visit!(visit_items(vis, items));
-            let ModSpans { inner_span, inject_use_span } = spans;
-            try_visit!(visit_span(vis, inner_span));
-            visit_span(vis, inject_use_span)
-        }
-
-        pub fn walk_local<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            local: &$($lt)? $($mut)? Local,
-        ) -> V::Result {
-            let Local { id, super_, pat, ty, kind, span, colon_sp, attrs, tokens: _ } = local;
-            if let Some(sp) = super_ {
-                try_visit!(visit_span(vis, sp));
-            }
-            try_visit!(visit_id(vis, id));
-            walk_list!(vis, visit_attribute, attrs);
-            try_visit!(vis.visit_pat(pat));
-            visit_opt!(vis, visit_ty, ty);
-            match kind {
-                LocalKind::Decl => {}
-                LocalKind::Init(init) => {
-                    try_visit!(vis.visit_expr(init))
-                }
-                LocalKind::InitElse(init, els) => {
-                    try_visit!(vis.visit_expr(init));
-                    try_visit!(vis.visit_block(els));
-                }
-            }
-            if let Some(sp) = colon_sp {
-                try_visit!(visit_span(vis, sp));
-            }
-            visit_span(vis, span)
-        }
-
-        pub fn walk_poly_trait_ref<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            p: &$($lt)? $($mut)? PolyTraitRef,
-        ) -> V::Result {
-            let PolyTraitRef { bound_generic_params, modifiers, trait_ref, span, parens: _ } = p;
-            try_visit!(visit_modifiers(vis, modifiers));
-            try_visit!(visit_generic_params(vis, bound_generic_params));
-            try_visit!(vis.visit_trait_ref(trait_ref));
-            visit_span(vis, span)
-        }
-
-        pub fn walk_trait_ref<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            TraitRef { path, ref_id }: &$($lt)? $($mut)? TraitRef,
-        ) -> V::Result {
-            try_visit!(vis.visit_path(path));
-            visit_id(vis, ref_id)
-        }
-
-        pub fn walk_variant<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            variant: &$($lt)? $($mut)? Variant,
-        ) -> V::Result {
-            let Variant { attrs, id, span, vis: visibility, ident, data, disr_expr, is_placeholder: _ } = variant;
-            try_visit!(visit_id(vis, id));
-            walk_list!(vis, visit_attribute, attrs);
-            try_visit!(vis.visit_vis(visibility));
-            try_visit!(vis.visit_ident(ident));
-            try_visit!(vis.visit_variant_data(data));
-            visit_opt!(vis, visit_anon_const, disr_expr);
-            visit_span(vis, span)
-        }
-
-        pub fn walk_expr_field<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            f: &$($lt)? $($mut)? ExprField,
-        ) -> V::Result {
-            let ExprField { attrs, id, span, ident, expr, is_shorthand: _, is_placeholder: _ } = f;
-            try_visit!(visit_id(vis, id));
-            walk_list!(vis, visit_attribute, attrs);
-            try_visit!(vis.visit_ident(ident));
-            try_visit!(vis.visit_expr(expr));
-            visit_span(vis, span)
-        }
-
-        pub fn walk_pat_field<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            fp: &$($lt)? $($mut)? PatField,
-        ) -> V::Result {
-            let PatField { ident, pat, is_shorthand: _, attrs, id, span, is_placeholder: _ } = fp;
-            try_visit!(visit_id(vis, id));
-            walk_list!(vis, visit_attribute, attrs);
-            try_visit!(vis.visit_ident(ident));
-            try_visit!(vis.visit_pat(pat));
-            visit_span(vis, span)
-        }
-
-        pub fn walk_ty_pat<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            tp: &$($lt)? $($mut)? TyPat,
-        ) -> V::Result {
-            let TyPat { id, kind, span, tokens: _ } = tp;
-            try_visit!(visit_id(vis, id));
-            match kind {
-                TyPatKind::Range(start, end, Spanned { span, node: _include_end }) => {
-                    visit_opt!(vis, visit_anon_const, start);
-                    visit_opt!(vis, visit_anon_const, end);
-                    try_visit!(visit_span(vis, span));
-                }
-                TyPatKind::Or(variants) => walk_list!(vis, visit_ty_pat, variants),
-                TyPatKind::Err(_) => {}
-            }
-            visit_span(vis, span)
-        }
-
-        fn walk_qself<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            qself: &$($lt)? $($mut)? Option<P<QSelf>>,
-        ) -> V::Result {
-            if let Some(qself) = qself {
-                let QSelf { ty, path_span, position: _ } = &$($mut)? **qself;
-                try_visit!(vis.visit_ty(ty));
-                try_visit!(visit_span(vis, path_span));
-            }
-            V::Result::output()
-        }
-
-        pub fn walk_path<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            path: &$($lt)? $($mut)? Path,
-        ) -> V::Result {
-            let Path { span, segments, tokens: _ } = path;
-            walk_list!(vis, visit_path_segment, segments);
-            visit_span(vis, span)
-        }
-
-        pub fn walk_use_tree<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            use_tree: &$($lt)? $($mut)? UseTree,
-        ) -> V::Result {
-            let UseTree { prefix, kind, span } = use_tree;
-            try_visit!(vis.visit_path(prefix));
-            match kind {
-                UseTreeKind::Simple(rename) => {
-                    // The extra IDs are handled during AST lowering.
-                    visit_opt!(vis, visit_ident, rename);
-                }
-                UseTreeKind::Glob => {}
-                UseTreeKind::Nested { items, span } => {
-                    for (nested_tree, nested_id) in items {
-                        try_visit!(visit_nested_use_tree(vis, nested_tree, nested_id));
+                        let kind = FnKind::Fn(FnCtxt::Foreign, visibility, &$($mut)?*func);
+                        try_visit!(vis.visit_fn(kind, span, id))
                     }
-                    try_visit!(visit_span(vis, span));
-                }
-            }
-            visit_span(vis, span)
-        }
-
-        pub fn walk_generic_args<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            generic_args: &$($lt)? $($mut)? GenericArgs
-        ) -> V::Result {
-            match generic_args {
-                GenericArgs::AngleBracketed(AngleBracketedArgs { span, args }) => {
-                    for arg in args {
-                        match arg {
-                            AngleBracketedArg::Arg(a) => try_visit!(vis.visit_generic_arg(a)),
-                            AngleBracketedArg::Constraint(c) => {
-                                try_visit!(vis.visit_assoc_item_constraint(c))
-                            }
-                        }
-                    }
-                    visit_span(vis, span)
-                }
-                GenericArgs::Parenthesized(data) => {
-                    let ParenthesizedArgs { span, inputs, inputs_span, output } = data;
-                    walk_list!(vis, visit_ty, inputs);
-                    try_visit!(vis.visit_fn_ret_ty(output));
-                    try_visit!(visit_span(vis, span));
-                    visit_span(vis, inputs_span)
-                }
-                GenericArgs::ParenthesizedElided(span) => visit_span(vis, span)
-            }
-        }
-
-        pub fn walk_generic_arg<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            generic_arg: &$($lt)? $($mut)? GenericArg,
-        ) -> V::Result {
-            match generic_arg {
-                GenericArg::Lifetime(lt) => vis.visit_lifetime(lt, $(${ignore($lt)} LifetimeCtxt::GenericArg)? ),
-                GenericArg::Type(ty) => vis.visit_ty(ty),
-                GenericArg::Const(ct) => vis.visit_anon_const(ct),
-            }
-        }
-
-        pub fn walk_assoc_item_constraint<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            constraint: &$($lt)? $($mut)? AssocItemConstraint,
-        ) -> V::Result {
-            let AssocItemConstraint { id, ident, gen_args, kind, span } = constraint;
-            try_visit!(visit_id(vis, id));
-            try_visit!(vis.visit_ident(ident));
-            visit_opt!(vis, visit_generic_args, gen_args);
-            match kind {
-                AssocItemConstraintKind::Equality { term } => match term {
-                    Term::Ty(ty) => try_visit!(vis.visit_ty(ty)),
-                    Term::Const(c) => try_visit!(vis.visit_anon_const(c)),
-                },
-                AssocItemConstraintKind::Bound { bounds } => {
-                    try_visit!(visit_bounds(vis, bounds, BoundKind::Bound));
-                }
-            }
-            visit_span(vis, span)
-        }
-
-        pub fn walk_param_bound<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, bound: &$($lt)? $($mut)? GenericBound) -> V::Result {
-            match bound {
-                GenericBound::Trait(trait_ref) => vis.visit_poly_trait_ref(trait_ref),
-                GenericBound::Outlives(lifetime) => vis.visit_lifetime(lifetime, $(${ignore($lt)} LifetimeCtxt::Bound)?),
-                GenericBound::Use(args, span) => {
-                    walk_list!(vis, visit_precise_capturing_arg, args);
-                    visit_span(vis, span)
-                }
-            }
-        }
-
-        pub fn walk_precise_capturing_arg<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            arg: &$($lt)? $($mut)? PreciseCapturingArg,
-        ) -> V::Result {
-            match arg {
-                PreciseCapturingArg::Lifetime(lt) => vis.visit_lifetime(lt, $(${ignore($lt)} LifetimeCtxt::GenericArg)?),
-                PreciseCapturingArg::Arg(path, id) => {
-                    try_visit!(visit_id(vis, id));
-                    vis.visit_path(path)
-                }
-            }
-        }
-
-        pub fn walk_generic_param<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            param: &$($lt)? $($mut)? GenericParam,
-        ) -> V::Result {
-            let GenericParam { id, ident, attrs, bounds, is_placeholder: _, kind, colon_span } =
-                param;
-            try_visit!(visit_id(vis, id));
-            walk_list!(vis, visit_attribute, attrs);
-            try_visit!(vis.visit_ident(ident));
-            walk_list!(vis, visit_param_bound, bounds, BoundKind::Bound);
-            match kind {
-                GenericParamKind::Lifetime => (),
-                GenericParamKind::Type { default } => visit_opt!(vis, visit_ty, default),
-                GenericParamKind::Const { ty, default, span } => {
-                    try_visit!(vis.visit_ty(ty));
-                    visit_opt!(vis, visit_anon_const, default);
-                    try_visit!(visit_span(vis, span));
-                }
-            }
-            if let Some(sp) = colon_span {
-                try_visit!(visit_span(vis, sp))
-            }
-            V::Result::output()
-        }
-
-        pub fn walk_generics<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, generics: &$($lt)? $($mut)? Generics) -> V::Result {
-            let Generics { params, where_clause, span } = generics;
-            let WhereClause { has_where_token: _, predicates, span: where_clause_span } = where_clause;
-            try_visit!(visit_generic_params(vis, params));
-            try_visit!(visit_where_predicates(vis, predicates));
-            try_visit!(visit_span(vis, span));
-            visit_span(vis, where_clause_span)
-        }
-
-        pub fn walk_contract<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, c: &$($lt)? $($mut)? FnContract) -> V::Result {
-            let FnContract { requires, ensures } = c;
-            visit_opt!(vis, visit_expr, requires);
-            visit_opt!(vis, visit_expr, ensures);
-            V::Result::output()
-        }
-
-        pub fn walk_where_predicate<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            predicate: &$($lt)? $($mut)? WherePredicate,
-        ) -> V::Result {
-            let WherePredicate { attrs, kind, id, span, is_placeholder: _ } = predicate;
-            try_visit!(visit_id(vis, id));
-            walk_list!(vis, visit_attribute, attrs);
-            try_visit!(visit_span(vis, span));
-            vis.visit_where_predicate_kind(kind)
-        }
-
-        pub fn walk_closure_binder<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            binder: &$($lt)? $($mut)? ClosureBinder,
-        ) -> V::Result {
-            match binder {
-                ClosureBinder::NotPresent => {}
-                ClosureBinder::For { generic_params, span } => {
-                    try_visit!(visit_generic_params(vis, generic_params));
-                    try_visit!(visit_span(vis, span));
-                }
-            }
-            V::Result::output()
-        }
-
-        pub fn walk_where_predicate_kind<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            kind: &$($lt)? $($mut)? WherePredicateKind,
-        ) -> V::Result {
-            match kind {
-                WherePredicateKind::BoundPredicate(WhereBoundPredicate {
-                    bounded_ty,
-                    bounds,
-                    bound_generic_params,
-                }) => {
-                    try_visit!(visit_generic_params(vis, bound_generic_params));
-                    try_visit!(vis.visit_ty(bounded_ty));
-                    walk_list!(vis, visit_param_bound, bounds, BoundKind::Bound);
+                    ForeignItemKind::TyAlias(alias) =>
+                        visit_visitable!($($mut)? vis, alias),
+                    ForeignItemKind::MacCall(mac) =>
+                        visit_visitable!($($mut)? vis, mac),
                 }
-                WherePredicateKind::RegionPredicate(WhereRegionPredicate { lifetime, bounds }) => {
-                    try_visit!(vis.visit_lifetime(lifetime, $(${ignore($lt)} LifetimeCtxt::Bound )?));
-                    walk_list!(vis, visit_param_bound, bounds, BoundKind::Bound);
-                }
-                WherePredicateKind::EqPredicate(WhereEqPredicate { lhs_ty, rhs_ty }) => {
-                    try_visit!(vis.visit_ty(lhs_ty));
-                    try_visit!(vis.visit_ty(rhs_ty));
-                }
-            }
-            V::Result::output()
-        }
-
-        pub fn walk_fn_decl<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            FnDecl { inputs, output }: &$($lt)? $($mut)? FnDecl,
-        ) -> V::Result {
-            try_visit!(visit_params(vis, inputs));
-            vis.visit_fn_ret_ty(output)
-        }
-
-        pub fn walk_fn_ret_ty<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, ret_ty: &$($lt)? $($mut)? FnRetTy) -> V::Result {
-            match ret_ty {
-                FnRetTy::Default(span) => visit_span(vis, span),
-                FnRetTy::Ty(output_ty) => vis.visit_ty(output_ty),
+                V::Result::output()
             }
         }
 
@@ -1450,455 +913,200 @@ macro_rules! common_visitor_and_walkers {
             match kind {
                 FnKind::Fn(
                     _ctxt,
+                    // Visibility is visited as a part of the item.
                     _vis,
-                    Fn {
-                        defaultness,
-                        ident,
-                        sig: FnSig { header, decl, span },
-                        generics,
-                        contract,
-                        body,
-                        define_opaque,
-                    },
+                    Fn { defaultness, ident, sig, generics, contract, body, define_opaque },
                 ) => {
-                    // Visibility is visited as a part of the item.
-                    try_visit!(visit_defaultness(vis, defaultness));
-                    try_visit!(vis.visit_ident(ident));
-                    try_visit!(vis.visit_fn_header(header));
-                    try_visit!(vis.visit_generics(generics));
-                    try_visit!(vis.visit_fn_decl(decl));
-                    visit_opt!(vis, visit_contract, contract);
-                    visit_opt!(vis, visit_block, body);
-                    try_visit!(visit_span(vis, span));
-                    walk_define_opaques(vis, define_opaque)
-                }
-                FnKind::Closure(binder, coroutine_kind, decl, body) => {
-                    try_visit!(vis.visit_closure_binder(binder));
-                    visit_opt!(vis, visit_coroutine_kind, coroutine_kind);
-                    try_visit!(vis.visit_fn_decl(decl));
-                    vis.visit_expr(body)
-                }
-            }
-        }
-
-        pub fn walk_variant_data<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, data: &$($lt)? $($mut)? VariantData) -> V::Result {
-            match data {
-                VariantData::Struct { fields, recovered: _ } => {
-                    visit_field_defs(vis, fields)
-                }
-                VariantData::Tuple(fields, id) => {
-                    try_visit!(visit_id(vis, id));
-                    visit_field_defs(vis, fields)
-                }
-                VariantData::Unit(id) => visit_id(vis, id),
-            }
-        }
-
-        pub fn walk_field_def<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, field: &$($lt)? $($mut)? FieldDef) -> V::Result {
-            let FieldDef { attrs, id, span, vis: visibility, ident, ty, is_placeholder: _, safety: _, default } =
-                field;
-            try_visit!(visit_id(vis, id));
-            walk_list!(vis, visit_attribute, attrs);
-            try_visit!(vis.visit_vis(visibility));
-            visit_opt!(vis, visit_ident, ident);
-            try_visit!(vis.visit_ty(ty));
-            visit_opt!(vis, visit_anon_const, default);
-            visit_span(vis, span)
-        }
-
-        fn visit_delim_args<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, args: &$($lt)? $($mut)? DelimArgs) -> V::Result {
-            let DelimArgs { dspan, delim: _, tokens: _ } = args;
-            let DelimSpan { open, close } = dspan;
-            try_visit!(visit_span(vis, open));
-            visit_span(vis, close)
-        }
-
-        pub fn walk_mac<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, mac: &$($lt)? $($mut)? MacCall) -> V::Result {
-            let MacCall { path, args } = mac;
-            try_visit!(vis.visit_path(path));
-            visit_delim_args(vis, args)
-        }
-
-        fn walk_macro_def<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, macro_def: &$($lt)? $($mut)? MacroDef) -> V::Result {
-            let MacroDef { body, macro_rules: _ } = macro_def;
-            visit_delim_args(vis, body)
-        }
-
-        pub fn walk_inline_asm<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, asm: &$($lt)? $($mut)? InlineAsm) -> V::Result {
-            let InlineAsm {
-                asm_macro: _,
-                template,
-                template_strs,
-                operands,
-                clobber_abis,
-                options: _,
-                line_spans,
-            } = asm;
-            for piece in template {
-                match piece {
-                    InlineAsmTemplatePiece::String(_str) => {}
-                    InlineAsmTemplatePiece::Placeholder { operand_idx: _, modifier: _, span } => {
-                        try_visit!(visit_span(vis, span));
-                    }
-                }
-            }
-            for (_s1, _s2, span) in template_strs {
-                try_visit!(visit_span(vis, span));
-            }
-            for (op, span) in operands {
-                match op {
-                    InlineAsmOperand::In { expr, reg: _ }
-                    | InlineAsmOperand::Out { expr: Some(expr), reg: _, late: _ }
-                    | InlineAsmOperand::InOut { expr, reg: _, late: _ } => {
-                        try_visit!(vis.visit_expr(expr))
-                    }
-                    InlineAsmOperand::Out { expr: None, reg: _, late: _ } => {}
-                    InlineAsmOperand::SplitInOut { in_expr, out_expr, reg: _, late: _ } => {
-                        try_visit!(vis.visit_expr(in_expr));
-                        visit_opt!(vis, visit_expr, out_expr);
-                    }
-                    InlineAsmOperand::Const { anon_const } => {
-                        try_visit!(vis.visit_anon_const(anon_const))
-                    }
-                    InlineAsmOperand::Sym { sym } => try_visit!(vis.visit_inline_asm_sym(sym)),
-                    InlineAsmOperand::Label { block } => try_visit!(vis.visit_block(block)),
+                    let FnSig { header, decl, span } = sig;
+                    visit_visitable!($($mut)? vis,
+                        defaultness, ident, header, generics, decl,
+                        contract, body, span, define_opaque
+                    )
                 }
-                try_visit!(visit_span(vis, span));
-            }
-            for (_s1, span) in clobber_abis {
-                try_visit!(visit_span(vis, span))
-            }
-            for span in line_spans {
-                try_visit!(visit_span(vis, span))
+                FnKind::Closure(binder, coroutine_kind, decl, body) =>
+                    visit_visitable!($($mut)? vis, binder, coroutine_kind, decl, body),
             }
             V::Result::output()
         }
 
-        pub fn walk_inline_asm_sym<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            InlineAsmSym { id, qself, path }: &$($lt)? $($mut)? InlineAsmSym,
-        ) -> V::Result {
-            try_visit!(visit_id(vis, id));
-            try_visit!(vis.visit_qself(qself));
-            vis.visit_path(path)
-        }
-
-        pub fn walk_format_args<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, fmt: &$($lt)? $($mut)? FormatArgs) -> V::Result {
-            let FormatArgs { span, template, arguments, uncooked_fmt_str: _, is_source_literal: _ } = fmt;
-
-            let args = $(${ignore($mut)} arguments.all_args_mut())? $(${ignore($lt)} arguments.all_args())? ;
-            for FormatArgument { kind, expr } in args {
-                match kind {
-                    FormatArgumentKind::Named(ident) | FormatArgumentKind::Captured(ident) => {
-                        try_visit!(vis.visit_ident(ident))
-                    }
-                    FormatArgumentKind::Normal => {}
-                }
-                try_visit!(vis.visit_expr(expr));
-            }
-            for piece in template {
-                match piece {
-                    FormatArgsPiece::Literal(_symbol) => {}
-                    FormatArgsPiece::Placeholder(placeholder) => try_visit!(walk_format_placeholder(vis, placeholder)),
-                }
-            }
-            visit_span(vis, span)
-        }
+        impl_walkable!(|&$($mut)? $($lt)? self: Impl, vis: &mut V| {
+            let Impl { defaultness, safety, generics, constness, polarity, of_trait, self_ty, items } = self;
+            visit_visitable!($($mut)? vis, defaultness, safety, generics, constness, polarity, of_trait, self_ty);
+            visit_visitable_with!($($mut)? vis, items, AssocCtxt::Impl { of_trait: of_trait.is_some() });
+            V::Result::output()
+        });
 
-        fn walk_format_placeholder<$($lt,)? V: $Visitor$(<$lt>)?>(
-            vis: &mut V,
-            placeholder: &$($lt)? $($mut)? FormatPlaceholder,
-        ) -> V::Result {
-            let FormatPlaceholder { argument, span, format_options, format_trait: _ } = placeholder;
-            if let Some(span) = span {
-                try_visit!(visit_span(vis, span));
-            }
-            let FormatArgPosition { span, index: _, kind: _ } = argument;
-            if let Some(span) = span {
-                try_visit!(visit_span(vis, span));
-            }
-            let FormatOptions {
-                width,
-                precision,
-                alignment: _,
-                fill: _,
-                sign: _,
-                alternate: _,
-                zero_pad: _,
-                debug_hex: _,
-            } = format_options;
-            match width {
-                None => {}
-                Some(FormatCount::Literal(_)) => {}
-                Some(FormatCount::Argument(FormatArgPosition { span, index: _, kind: _ })) => {
-                    if let Some(span) = span {
-                        try_visit!(visit_span(vis, span));
-                    }
-                }
-            }
-            match precision {
-                None => {}
-                Some(FormatCount::Literal(_)) => {}
-                Some(FormatCount::Argument(FormatArgPosition { span, index: _, kind: _ })) => {
-                    if let Some(span) = span {
-                        try_visit!(visit_span(vis, span));
-                    }
-                }
-            }
+        // Special case to call `visit_method_receiver_expr`.
+        impl_walkable!(|&$($mut)? $($lt)? self: MethodCall, vis: &mut V| {
+            let MethodCall { seg, receiver, args, span } = self;
+            try_visit!(vis.visit_method_receiver_expr(receiver));
+            visit_visitable!($($mut)? vis, seg, args, span);
             V::Result::output()
-        }
+        });
 
-        pub fn walk_expr<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, expression: &$($lt)? $($mut)? Expr) -> V::Result {
-            let Expr { id, kind, span, attrs, tokens: _ } = expression;
-            try_visit!(visit_id(vis, id));
-            walk_list!(vis, visit_attribute, attrs);
+        impl_walkable!(|&$($mut)? $($lt)? self: Expr, vis: &mut V| {
+            let Expr { id, kind, span, attrs, tokens: _ } = self;
+            visit_visitable!($($mut)? vis, id, attrs);
             match kind {
-                ExprKind::Array(exprs) => {
-                    try_visit!(visit_exprs(vis, exprs));
-                }
-                ExprKind::ConstBlock(anon_const) => try_visit!(vis.visit_anon_const(anon_const)),
-                ExprKind::Repeat(element, count) => {
-                    try_visit!(vis.visit_expr(element));
-                    try_visit!(vis.visit_anon_const(count));
-                }
-                ExprKind::Struct(se) => {
-                    let StructExpr { qself, path, fields, rest } = &$($mut)?**se;
-                    try_visit!(vis.visit_qself(qself));
-                    try_visit!(vis.visit_path(path));
-                    try_visit!(visit_expr_fields(vis, fields));
-                    match rest {
-                        StructRest::Base(expr) => try_visit!(vis.visit_expr(expr)),
-                        StructRest::Rest(span) => try_visit!(visit_span(vis, span)),
-                        StructRest::None => {}
-                    }
-                }
-                ExprKind::Tup(exprs) => {
-                    try_visit!(visit_exprs(vis, exprs));
-                }
-                ExprKind::Call(callee_expression, arguments) => {
-                    try_visit!(vis.visit_expr(callee_expression));
-                    try_visit!(visit_exprs(vis, arguments));
-                }
-                ExprKind::MethodCall(box MethodCall { seg, receiver, args, span }) => {
-                    try_visit!(vis.visit_method_receiver_expr(receiver));
-                    try_visit!(vis.visit_path_segment(seg));
-                    try_visit!(visit_exprs(vis, args));
-                    try_visit!(visit_span(vis, span));
-                }
-                ExprKind::Binary(Spanned { span, node: _ }, left_expression, right_expression) => {
-                    try_visit!(vis.visit_expr(left_expression));
-                    try_visit!(vis.visit_expr(right_expression));
-                    try_visit!(visit_span(vis, span))
-                }
-                ExprKind::AddrOf(_kind, _mutbl, subexpression) => {
-                    try_visit!(vis.visit_expr(subexpression));
-                }
-                ExprKind::Unary(_op, subexpression) => {
-                    try_visit!(vis.visit_expr(subexpression));
-                }
-                ExprKind::Cast(subexpression, typ) | ExprKind::Type(subexpression, typ) => {
-                    try_visit!(vis.visit_expr(subexpression));
-                    try_visit!(vis.visit_ty(typ));
-                }
-                ExprKind::Let(pat, expr, span, _recovered) => {
-                    try_visit!(vis.visit_pat(pat));
-                    try_visit!(vis.visit_expr(expr));
-                    try_visit!(visit_span(vis, span))
-                }
-                ExprKind::If(head_expression, if_block, optional_else) => {
-                    try_visit!(vis.visit_expr(head_expression));
-                    try_visit!(vis.visit_block(if_block));
-                    visit_opt!(vis, visit_expr, optional_else);
-                }
-                ExprKind::While(subexpression, block, opt_label) => {
-                    visit_opt!(vis, visit_label, opt_label);
-                    try_visit!(vis.visit_expr(subexpression));
-                    try_visit!(vis.visit_block(block));
-                }
-                ExprKind::ForLoop { pat, iter, body, label, kind: _ } => {
-                    visit_opt!(vis, visit_label, label);
-                    try_visit!(vis.visit_pat(pat));
-                    try_visit!(vis.visit_expr(iter));
-                    try_visit!(vis.visit_block(body));
-                }
-                ExprKind::Loop(block, opt_label, span) => {
-                    visit_opt!(vis, visit_label, opt_label);
-                    try_visit!(vis.visit_block(block));
-                    try_visit!(visit_span(vis, span))
-                }
-                ExprKind::Match(subexpression, arms, _kind) => {
-                    try_visit!(vis.visit_expr(subexpression));
-                    try_visit!(visit_arms(vis, arms));
-                }
+                ExprKind::Array(exprs) =>
+                    visit_visitable!($($mut)? vis, exprs),
+                ExprKind::ConstBlock(anon_const) =>
+                    visit_visitable!($($mut)? vis, anon_const),
+                ExprKind::Repeat(element, count) =>
+                    visit_visitable!($($mut)? vis, element, count),
+                ExprKind::Struct(se) =>
+                    visit_visitable!($($mut)? vis, se),
+                ExprKind::Tup(exprs) =>
+                    visit_visitable!($($mut)? vis, exprs),
+                ExprKind::Call(callee_expression, arguments) =>
+                    visit_visitable!($($mut)? vis, callee_expression, arguments),
+                ExprKind::MethodCall(mc) =>
+                    visit_visitable!($($mut)? vis, mc),
+                ExprKind::Binary(op, lhs, rhs) =>
+                    visit_visitable!($($mut)? vis, op, lhs, rhs),
+                ExprKind::AddrOf(kind, mutbl, subexpression) =>
+                    visit_visitable!($($mut)? vis, kind, mutbl, subexpression),
+                ExprKind::Unary(op, subexpression) =>
+                    visit_visitable!($($mut)? vis, op, subexpression),
+                ExprKind::Cast(subexpression, typ) | ExprKind::Type(subexpression, typ) =>
+                    visit_visitable!($($mut)? vis, subexpression, typ),
+                ExprKind::Let(pat, expr, span, _recovered) =>
+                    visit_visitable!($($mut)? vis, pat, expr, span),
+                ExprKind::If(head_expression, if_block, optional_else) =>
+                    visit_visitable!($($mut)? vis, head_expression, if_block, optional_else),
+                ExprKind::While(subexpression, block, opt_label) =>
+                    visit_visitable!($($mut)? vis, subexpression, block, opt_label),
+                ExprKind::ForLoop { pat, iter, body, label, kind } =>
+                    visit_visitable!($($mut)? vis, pat, iter, body, label, kind),
+                ExprKind::Loop(block, opt_label, span) =>
+                    visit_visitable!($($mut)? vis, block, opt_label, span),
+                ExprKind::Match(subexpression, arms, kind) =>
+                    visit_visitable!($($mut)? vis, subexpression, arms, kind),
                 ExprKind::Closure(box Closure {
                     binder,
                     capture_clause,
                     coroutine_kind,
                     constness,
-                    movability: _,
+                    movability,
                     fn_decl,
                     body,
                     fn_decl_span,
                     fn_arg_span,
                 }) => {
-                    try_visit!(visit_constness(vis, constness));
-                    try_visit!(vis.visit_capture_by(capture_clause));
-                    try_visit!(vis.visit_fn(
-                        FnKind::Closure(binder, coroutine_kind, fn_decl, body),
-                        *span,
-                        *id
-                    ));
-                    try_visit!(visit_span(vis, fn_decl_span));
-                    try_visit!(visit_span(vis, fn_arg_span));
-                }
-                ExprKind::Block(block, opt_label) => {
-                    visit_opt!(vis, visit_label, opt_label);
-                    try_visit!(vis.visit_block(block));
-                }
-                ExprKind::Gen(capture_clause, body, _kind, decl_span) => {
-                    try_visit!(vis.visit_capture_by(capture_clause));
-                    try_visit!(vis.visit_block(body));
-                    try_visit!(visit_span(vis, decl_span));
-                }
-                ExprKind::Await(expr, span) => {
-                    try_visit!(vis.visit_expr(expr));
-                    try_visit!(visit_span(vis, span));
-                }
-                ExprKind::Use(expr, span) => {
-                    try_visit!(vis.visit_expr(expr));
-                    try_visit!(visit_span(vis, span));
-                }
-                ExprKind::Assign(lhs, rhs, span) => {
-                    try_visit!(vis.visit_expr(lhs));
-                    try_visit!(vis.visit_expr(rhs));
-                    try_visit!(visit_span(vis, span));
-                }
-                ExprKind::AssignOp(Spanned { span, node: _ }, left_expression, right_expression) => {
-                    try_visit!(vis.visit_expr(left_expression));
-                    try_visit!(vis.visit_expr(right_expression));
-                    try_visit!(visit_span(vis, span));
-                }
-                ExprKind::Field(subexpression, ident) => {
-                    try_visit!(vis.visit_expr(subexpression));
-                    try_visit!(vis.visit_ident(ident));
-                }
-                ExprKind::Index(main_expression, index_expression, span) => {
-                    try_visit!(vis.visit_expr(main_expression));
-                    try_visit!(vis.visit_expr(index_expression));
-                    try_visit!(visit_span(vis, span));
-                }
-                ExprKind::Range(start, end, _limit) => {
-                    visit_opt!(vis, visit_expr, start);
-                    visit_opt!(vis, visit_expr, end);
-                }
+                    visit_visitable!($($mut)? vis, constness, movability, capture_clause);
+                    let kind = FnKind::Closure(binder, coroutine_kind, fn_decl, body);
+                    try_visit!(vis.visit_fn(kind, *span, *id));
+                    visit_visitable!($($mut)? vis, fn_decl_span, fn_arg_span);
+                }
+                ExprKind::Block(block, opt_label) =>
+                    visit_visitable!($($mut)? vis, block, opt_label),
+                ExprKind::Gen(capt, body, kind, decl_span) =>
+                    visit_visitable!($($mut)? vis, capt, body, kind, decl_span),
+                ExprKind::Await(expr, span) | ExprKind::Use(expr, span) =>
+                    visit_visitable!($($mut)? vis, expr, span),
+                ExprKind::Assign(lhs, rhs, span) =>
+                    visit_visitable!($($mut)? vis, lhs, rhs, span),
+                ExprKind::AssignOp(op, lhs, rhs) =>
+                    visit_visitable!($($mut)? vis, op, lhs, rhs),
+                ExprKind::Field(subexpression, ident) =>
+                    visit_visitable!($($mut)? vis, subexpression, ident),
+                ExprKind::Index(main_expression, index_expression, span) =>
+                    visit_visitable!($($mut)? vis, main_expression, index_expression, span),
+                ExprKind::Range(start, end, limit) =>
+                    visit_visitable!($($mut)? vis, start, end, limit),
                 ExprKind::Underscore => {}
-                ExprKind::Path(maybe_qself, path) => {
-                    try_visit!(vis.visit_qself(maybe_qself));
-                    try_visit!(vis.visit_path(path));
-                }
-                ExprKind::Break(opt_label, opt_expr) => {
-                    visit_opt!(vis, visit_label, opt_label);
-                    visit_opt!(vis, visit_expr, opt_expr);
-                }
-                ExprKind::Continue(opt_label) => {
-                    visit_opt!(vis, visit_label, opt_label);
-                }
-                ExprKind::Ret(optional_expression) => {
-                    visit_opt!(vis, visit_expr, optional_expression);
-                }
-                ExprKind::Yeet(optional_expression) => {
-                    visit_opt!(vis, visit_expr, optional_expression);
-                }
-                ExprKind::Become(expr) => try_visit!(vis.visit_expr(expr)),
-                ExprKind::MacCall(mac) => try_visit!(vis.visit_mac_call(mac)),
-                ExprKind::Paren(subexpression) => try_visit!(vis.visit_expr(subexpression)),
-                ExprKind::InlineAsm(asm) => try_visit!(vis.visit_inline_asm(asm)),
-                ExprKind::FormatArgs(f) => try_visit!(vis.visit_format_args(f)),
-                ExprKind::OffsetOf(container, fields) => {
-                    try_visit!(vis.visit_ty(container));
-                    walk_list!(vis, visit_ident, fields);
-                }
-                ExprKind::Yield(kind) => {
-                    match kind {
-                        YieldKind::Postfix(expr) => {
-                            try_visit!(vis.visit_expr(expr));
-                        }
-                        YieldKind::Prefix(expr) => {
-                            visit_opt!(vis, visit_expr, expr);
-                        }
-                    }
-                }
-                ExprKind::Try(subexpression) => try_visit!(vis.visit_expr(subexpression)),
-                ExprKind::TryBlock(body) => try_visit!(vis.visit_block(body)),
-                ExprKind::Lit(_token) => {}
-                ExprKind::IncludedBytes(_bytes) => {}
-                ExprKind::UnsafeBinderCast(_kind, expr, ty) => {
-                    try_visit!(vis.visit_expr(expr));
-                    visit_opt!(vis, visit_ty, ty);
-                }
+                ExprKind::Path(maybe_qself, path) =>
+                    visit_visitable!($($mut)? vis, maybe_qself, path),
+                ExprKind::Break(opt_label, opt_expr) =>
+                    visit_visitable!($($mut)? vis, opt_label, opt_expr),
+                ExprKind::Continue(opt_label) =>
+                    visit_visitable!($($mut)? vis, opt_label),
+                ExprKind::Ret(optional_expression) | ExprKind::Yeet(optional_expression) =>
+                    visit_visitable!($($mut)? vis, optional_expression),
+                ExprKind::Become(expr) =>
+                    visit_visitable!($($mut)? vis, expr),
+                ExprKind::MacCall(mac) =>
+                    visit_visitable!($($mut)? vis, mac),
+                ExprKind::Paren(subexpression) =>
+                    visit_visitable!($($mut)? vis, subexpression),
+                ExprKind::InlineAsm(asm) =>
+                    visit_visitable!($($mut)? vis, asm),
+                ExprKind::FormatArgs(f) =>
+                    visit_visitable!($($mut)? vis, f),
+                ExprKind::OffsetOf(container, fields) =>
+                    visit_visitable!($($mut)? vis, container, fields),
+                ExprKind::Yield(kind) =>
+                    visit_visitable!($($mut)? vis, kind),
+                ExprKind::Try(subexpression) =>
+                    visit_visitable!($($mut)? vis, subexpression),
+                ExprKind::TryBlock(body) =>
+                    visit_visitable!($($mut)? vis, body),
+                ExprKind::Lit(token) =>
+                    visit_visitable!($($mut)? vis, token),
+                ExprKind::IncludedBytes(bytes) =>
+                    visit_visitable!($($mut)? vis, bytes),
+                ExprKind::UnsafeBinderCast(kind, expr, ty) =>
+                    visit_visitable!($($mut)? vis, kind, expr, ty),
                 ExprKind::Err(_guar) => {}
                 ExprKind::Dummy => {}
             }
 
             visit_span(vis, span)
-        }
-
-        pub fn walk_param<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, param: &$($lt)? $($mut)? Param) -> V::Result {
-            let Param { attrs, ty, pat, id, span, is_placeholder: _ } = param;
-            try_visit!(visit_id(vis, id));
-            walk_list!(vis, visit_attribute, attrs);
-            try_visit!(vis.visit_pat(pat));
-            try_visit!(vis.visit_ty(ty));
-            visit_span(vis, span)
-        }
-
-        pub fn walk_arm<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, arm: &$($lt)? $($mut)? Arm) -> V::Result {
-            let Arm { attrs, pat, guard, body, span, id, is_placeholder: _ } = arm;
-            try_visit!(visit_id(vis, id));
-            walk_list!(vis, visit_attribute, attrs);
-            try_visit!(vis.visit_pat(pat));
-            visit_opt!(vis, visit_expr, guard);
-            visit_opt!(vis, visit_expr, body);
-            visit_span(vis, span)
-        }
-
-        pub fn walk_vis<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, visibility: &$($lt)? $($mut)? Visibility) -> V::Result {
-            let Visibility { kind, span, tokens: _ } = visibility;
-            match kind {
-                VisibilityKind::Restricted { path, id, shorthand: _ } => {
-                    try_visit!(visit_id(vis, id));
-                    try_visit!(vis.visit_path(path));
-                }
-                VisibilityKind::Public | VisibilityKind::Inherited => {}
-            }
-            visit_span(vis, span)
-        }
-
-        pub fn walk_attribute<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, attr: &$($lt)? $($mut)? Attribute) -> V::Result {
-            let Attribute { kind, id: _, style: _, span } = attr;
-            match kind {
-                AttrKind::Normal(normal) => {
-                    let NormalAttr { item, tokens: _ } = &$($mut)?**normal;
-                    let AttrItem { unsafety: _, path, args, tokens: _ } = item;
-                    try_visit!(vis.visit_path(path));
-                    try_visit!(walk_attr_args(vis, args));
-                }
-                AttrKind::DocComment(_kind, _sym) => {}
-            }
-            visit_span(vis, span)
-        }
-
-        pub fn walk_attr_args<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, args: &$($lt)? $($mut)? AttrArgs) -> V::Result {
-            match args {
-                AttrArgs::Empty => {}
-                AttrArgs::Delimited(args) => try_visit!(visit_delim_args(vis, args)),
-                AttrArgs::Eq { eq_span, expr } => {
-                    try_visit!(vis.visit_expr(expr));
-                    try_visit!(visit_span(vis, eq_span));
-                }
-            }
-            V::Result::output()
-        }
+        });
+
+        define_named_walk!($(($mut))? $Visitor$(<$lt>)?
+            pub fn walk_anon_const(AnonConst);
+            pub fn walk_arm(Arm);
+            //pub fn walk_assoc_item(AssocItem, _ctxt: AssocCtxt);
+            pub fn walk_assoc_item_constraint(AssocItemConstraint);
+            pub fn walk_attribute(Attribute);
+            pub fn walk_block(Block);
+            //pub fn walk_nested_use_tree((UseTree, NodeId));
+            pub fn walk_capture_by(CaptureBy);
+            pub fn walk_closure_binder(ClosureBinder);
+            pub fn walk_contract(FnContract);
+            pub fn walk_coroutine_kind(CoroutineKind);
+            pub fn walk_crate(Crate);
+            pub fn walk_expr(Expr);
+            pub fn walk_expr_field(ExprField);
+            pub fn walk_field_def(FieldDef);
+            pub fn walk_fn_decl(FnDecl);
+            pub fn walk_fn_header(FnHeader);
+            pub fn walk_fn_ret_ty(FnRetTy);
+            //pub fn walk_foreign_item(ForeignItem);
+            pub fn walk_foreign_mod(ForeignMod);
+            pub fn walk_format_args(FormatArgs);
+            pub fn walk_generic_arg(GenericArg);
+            pub fn walk_generic_args(GenericArgs);
+            pub fn walk_generic_param(GenericParam);
+            pub fn walk_generics(Generics);
+            pub fn walk_inline_asm(InlineAsm);
+            pub fn walk_inline_asm_sym(InlineAsmSym);
+            //pub fn walk_item(Item);
+            pub fn walk_label(Label);
+            pub fn walk_lifetime(Lifetime);
+            pub fn walk_local(Local);
+            pub fn walk_mac(MacCall);
+            pub fn walk_macro_def(MacroDef);
+            pub fn walk_param_bound(GenericBound);
+            pub fn walk_param(Param);
+            pub fn walk_pat_field(PatField);
+            pub fn walk_path(Path);
+            pub fn walk_path_segment(PathSegment);
+            pub fn walk_pat(Pat);
+            pub fn walk_poly_trait_ref(PolyTraitRef);
+            pub fn walk_precise_capturing_arg(PreciseCapturingArg);
+            pub fn walk_qself(QSelf);
+            pub fn walk_trait_ref(TraitRef);
+            pub fn walk_ty_pat(TyPat);
+            pub fn walk_ty(Ty);
+            pub fn walk_use_tree(UseTree);
+            pub fn walk_variant_data(VariantData);
+            pub fn walk_variant(Variant);
+            pub fn walk_vis(Visibility);
+            pub fn walk_where_predicate_kind(WherePredicateKind);
+            pub fn walk_where_predicate(WherePredicate);
+        );
     };
 }
 
@@ -1907,6 +1115,20 @@ common_visitor_and_walkers!(Visitor<'a>);
 macro_rules! generate_list_visit_fns {
     ($($name:ident, $Ty:ty, $visit_fn:ident$(, $param:ident: $ParamTy:ty)*;)+) => {
         $(
+            #[allow(unused_parens)]
+            impl<'a, V: Visitor<'a>> Visitable<'a, V> for ThinVec<$Ty> {
+                type Extra = ($($ParamTy),*);
+
+                #[inline]
+                fn visit(
+                    &'a self,
+                    visitor: &mut V,
+                    ($($param),*): Self::Extra,
+                ) -> V::Result {
+                    $name(visitor, self $(, $param)*)
+                }
+            }
+
             fn $name<'a, V: Visitor<'a>>(
                 vis: &mut V,
                 values: &'a ThinVec<$Ty>,
@@ -1937,18 +1159,9 @@ generate_list_visit_fns! {
     visit_arms, Arm, visit_arm;
 }
 
-#[expect(rustc::pass_by_value)] // needed for symmetry with mut_visit
-fn visit_nested_use_tree<'a, V: Visitor<'a>>(
-    vis: &mut V,
-    nested_tree: &'a UseTree,
-    &nested_id: &NodeId,
-) -> V::Result {
-    vis.visit_nested_use_tree(nested_tree, nested_id)
-}
-
 pub fn walk_stmt<'a, V: Visitor<'a>>(visitor: &mut V, statement: &'a Stmt) -> V::Result {
     let Stmt { id, kind, span: _ } = statement;
-    try_visit!(visit_id(visitor, id));
+    try_visit!(visitor.visit_id(*id));
     match kind {
         StmtKind::Let(local) => try_visit!(visitor.visit_local(local)),
         StmtKind::Item(item) => try_visit!(visitor.visit_item(item)),
diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs
index 1006ea3ba10..101f5ccb7a4 100644
--- a/compiler/rustc_macros/src/lib.rs
+++ b/compiler/rustc_macros/src/lib.rs
@@ -21,6 +21,7 @@ mod symbols;
 mod try_from;
 mod type_foldable;
 mod type_visitable;
+mod visitable;
 
 // Reads the rust version (e.g. "1.75.0") from the CFG_RELEASE env var and
 // produces a `RustcVersion` literal containing that version (e.g.
@@ -101,6 +102,16 @@ decl_derive!(
     /// visited (and its type is not required to implement `TypeVisitable`).
     type_visitable::type_visitable_derive
 );
+decl_derive!(
+    [Walkable, attributes(visitable)] =>
+    /// Derives `Walkable` for the annotated `struct` or `enum` (`union` is not supported).
+    ///
+    /// Each field of the struct or enum variant will be visited in definition order, using the
+    /// `Walkable` implementation for its type. However, if a field of a struct or an enum
+    /// variant is annotated with `#[visitable(ignore)]` then that field will not be
+    /// visited (and its type is not required to implement `Walkable`).
+    visitable::visitable_derive
+);
 decl_derive!([Lift, attributes(lift)] => lift::lift_derive);
 decl_derive!(
     [Diagnostic, attributes(
diff --git a/compiler/rustc_macros/src/visitable.rs b/compiler/rustc_macros/src/visitable.rs
new file mode 100644
index 00000000000..a7a82538eab
--- /dev/null
+++ b/compiler/rustc_macros/src/visitable.rs
@@ -0,0 +1,82 @@
+use quote::quote;
+use synstructure::BindingInfo;
+
+pub(super) fn visitable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
+    if let syn::Data::Union(_) = s.ast().data {
+        panic!("cannot derive on union")
+    }
+
+    let has_attr = |bind: &BindingInfo<'_>, name| {
+        let mut found = false;
+        bind.ast().attrs.iter().for_each(|attr| {
+            if !attr.path().is_ident("visitable") {
+                return;
+            }
+            let _ = attr.parse_nested_meta(|nested| {
+                if nested.path.is_ident(name) {
+                    found = true;
+                }
+                Ok(())
+            });
+        });
+        found
+    };
+
+    let get_attr = |bind: &BindingInfo<'_>, name: &str| {
+        let mut content = None;
+        bind.ast().attrs.iter().for_each(|attr| {
+            if !attr.path().is_ident("visitable") {
+                return;
+            }
+            let _ = attr.parse_nested_meta(|nested| {
+                if nested.path.is_ident(name) {
+                    let value = nested.value()?;
+                    let value = value.parse()?;
+                    content = Some(value);
+                }
+                Ok(())
+            });
+        });
+        content
+    };
+
+    s.add_bounds(synstructure::AddBounds::Generics);
+    s.bind_with(|_| synstructure::BindStyle::Ref);
+    let ref_visit = s.each(|bind| {
+        let extra = get_attr(bind, "extra").unwrap_or(quote! {});
+        if has_attr(bind, "ignore") {
+            quote! {}
+        } else {
+            quote! { rustc_ast_ir::try_visit!(crate::visit::Visitable::visit(#bind, __visitor, (#extra))) }
+        }
+    });
+
+    s.bind_with(|_| synstructure::BindStyle::RefMut);
+    let mut_visit = s.each(|bind| {
+        let extra = get_attr(bind, "extra").unwrap_or(quote! {});
+        if has_attr(bind, "ignore") {
+            quote! {}
+        } else {
+            quote! { crate::mut_visit::MutVisitable::visit_mut(#bind, __visitor, (#extra)) }
+        }
+    });
+
+    s.gen_impl(quote! {
+        gen impl<'__ast, __V> crate::visit::Walkable<'__ast, __V> for @Self
+            where __V: crate::visit::Visitor<'__ast>,
+        {
+            fn walk_ref(&'__ast self, __visitor: &mut __V) -> __V::Result {
+                match *self { #ref_visit }
+                <__V::Result as rustc_ast_ir::visit::VisitorResult>::output()
+            }
+        }
+
+        gen impl<__V> crate::mut_visit::MutWalkable<__V> for @Self
+            where __V: crate::mut_visit::MutVisitor,
+        {
+            fn walk_mut(&mut self, __visitor: &mut __V) {
+                match *self { #mut_visit }
+            }
+        }
+    })
+}
-- 
cgit 1.4.1-3-g733a5


From ed93c1783b404d728d4809973a0550eb33cd293f Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 21 Jul 2025 14:22:51 +0200
Subject: Rename `tests/assembly` into `tests/assembly-llvm`

---
 .../rustc_codegen_gcc/build_system/src/test.rs     |    2 +-
 src/bootstrap/src/core/build_steps/test.rs         |    7 +-
 src/bootstrap/src/core/builder/mod.rs              |    4 +-
 src/ci/docker/host-x86_64/test-various/Dockerfile  |    4 +-
 src/doc/rustc-dev-guide/src/asm.md                 |    4 +-
 src/doc/rustc-dev-guide/src/tests/compiletest.md   |    4 +-
 src/tools/opt-dist/src/tests.rs                    |    2 +-
 src/tools/tidy/src/target_policy.rs                |    6 +-
 tests/assembly-llvm/aarch64-pointer-auth.rs        |   30 +
 tests/assembly-llvm/aarch64-xray.rs                |   25 +
 tests/assembly-llvm/align_offset.rs                |   47 +
 tests/assembly-llvm/asm/aarch64-el2vmsa.rs         |   33 +
 tests/assembly-llvm/asm/aarch64-modifiers.rs       |  128 +++
 tests/assembly-llvm/asm/aarch64-outline-atomics.rs |   17 +
 tests/assembly-llvm/asm/aarch64-types.rs           |  633 +++++++++++
 tests/assembly-llvm/asm/arm-modifiers.rs           |  122 +++
 tests/assembly-llvm/asm/arm-types.rs               |  639 ++++++++++++
 tests/assembly-llvm/asm/avr-modifiers.rs           |   43 +
 tests/assembly-llvm/asm/avr-types.rs               |  205 ++++
 tests/assembly-llvm/asm/bpf-types.rs               |  133 +++
 tests/assembly-llvm/asm/comments.rs                |   12 +
 tests/assembly-llvm/asm/global_asm.rs              |   32 +
 tests/assembly-llvm/asm/hexagon-types.rs           |  139 +++
 tests/assembly-llvm/asm/inline-asm-avx.rs          |   25 +
 tests/assembly-llvm/asm/loongarch-type.rs          |  190 ++++
 tests/assembly-llvm/asm/m68k-types.rs              |   67 ++
 tests/assembly-llvm/asm/mips-types.rs              |  211 ++++
 tests/assembly-llvm/asm/msp430-types.rs            |  141 +++
 tests/assembly-llvm/asm/nvptx-types.rs             |  115 ++
 tests/assembly-llvm/asm/powerpc-types.rs           |  474 +++++++++
 tests/assembly-llvm/asm/riscv-types.rs             |  227 ++++
 tests/assembly-llvm/asm/s390x-types.rs             |  350 +++++++
 tests/assembly-llvm/asm/sparc-types.rs             |  145 +++
 tests/assembly-llvm/asm/wasm-types.rs              |  131 +++
 tests/assembly-llvm/asm/x86-modifiers.rs           |  184 ++++
 tests/assembly-llvm/asm/x86-types.rs               | 1095 ++++++++++++++++++++
 .../auxiliary/breakpoint-panic-handler.rs          |    8 +
 .../auxiliary/dwarf-mixed-versions-lto-aux.rs      |    5 +
 .../auxiliary/non-inline-dependency.rs             |   14 +
 tests/assembly-llvm/breakpoint.rs                  |   14 +
 .../closure-inherit-target-feature.rs              |   59 ++
 tests/assembly-llvm/cmse.rs                        |  100 ++
 .../compiletest-self-test/use-minicore-no-run.rs   |    5 +
 tests/assembly-llvm/cstring-merging.rs             |   30 +
 tests/assembly-llvm/dwarf-mixed-versions-lto.rs    |   20 +
 tests/assembly-llvm/dwarf4.rs                      |   23 +
 tests/assembly-llvm/dwarf5.rs                      |   20 +
 tests/assembly-llvm/emit-intel-att-syntax.rs       |   75 ++
 tests/assembly-llvm/is_aligned.rs                  |   55 +
 .../issue-83585-small-pod-struct-equality.rs       |   27 +
 .../assembly-llvm/libs/issue-115339-zip-arrays.rs  |   25 +
 .../libs/issue-140207-slice-min-simd.rs            |   13 +
 tests/assembly-llvm/manual-eq-efficient.rs         |   22 +
 .../aarch64-naked-fn-no-bti-prolog.rs              |   21 +
 tests/assembly-llvm/naked-functions/aix.rs         |   35 +
 tests/assembly-llvm/naked-functions/wasm32.rs      |  200 ++++
 .../x86_64-naked-fn-no-cet-prolog.rs               |   24 +
 tests/assembly-llvm/niche-prefer-zero.rs           |   25 +
 tests/assembly-llvm/nvptx-arch-default.rs          |   12 +
 tests/assembly-llvm/nvptx-arch-emit-asm.rs         |    9 +
 tests/assembly-llvm/nvptx-arch-link-arg.rs         |   13 +
 tests/assembly-llvm/nvptx-arch-target-cpu.rs       |   12 +
 tests/assembly-llvm/nvptx-atomics.rs               |   86 ++
 tests/assembly-llvm/nvptx-c-abi-arg-v7.rs          |  220 ++++
 tests/assembly-llvm/nvptx-c-abi-ret-v7.rs          |  244 +++++
 tests/assembly-llvm/nvptx-internalizing.rs         |   27 +
 .../nvptx-kernel-abi/nvptx-kernel-args-abi-v7.rs   |  251 +++++
 tests/assembly-llvm/nvptx-linking-binary.rs        |   40 +
 tests/assembly-llvm/nvptx-linking-cdylib.rs        |   39 +
 tests/assembly-llvm/nvptx-safe-naming.rs           |   37 +
 tests/assembly-llvm/panic-no-unwind-no-uwtable.rs  |    8 +
 tests/assembly-llvm/panic-unwind-no-uwtable.rs     |   12 +
 tests/assembly-llvm/pic-relocation-model.rs        |   31 +
 tests/assembly-llvm/pie-relocation-model.rs        |   34 +
 tests/assembly-llvm/powerpc64-struct-abi.rs        |  156 +++
 tests/assembly-llvm/riscv-float-struct-abi.rs      |  177 ++++
 .../riscv-soft-abi-with-float-features.rs          |   45 +
 tests/assembly-llvm/rust-abi-arg-attr.rs           |  110 ++
 tests/assembly-llvm/s390x-backchain-toggle.rs      |   50 +
 tests/assembly-llvm/s390x-vector-abi.rs            |  327 ++++++
 .../sanitizer/kcfi/emit-arity-indicator.rs         |   69 ++
 tests/assembly-llvm/simd-bitmask.rs                |  147 +++
 tests/assembly-llvm/simd-intrinsic-gather.rs       |   39 +
 tests/assembly-llvm/simd-intrinsic-mask-load.rs    |   83 ++
 tests/assembly-llvm/simd-intrinsic-mask-reduce.rs  |   59 ++
 tests/assembly-llvm/simd-intrinsic-mask-store.rs   |   82 ++
 tests/assembly-llvm/simd-intrinsic-scatter.rs      |   35 +
 tests/assembly-llvm/simd-intrinsic-select.rs       |  128 +++
 tests/assembly-llvm/simd/reduce-fadd-unordered.rs  |   31 +
 tests/assembly-llvm/slice-is_ascii.rs              |   33 +
 tests/assembly-llvm/small_data_threshold.rs        |   98 ++
 tests/assembly-llvm/sparc-struct-abi.rs            |   68 ++
 tests/assembly-llvm/stack-probes.rs                |   41 +
 ...ck-protector-heuristics-effect-windows-32bit.rs |  359 +++++++
 ...ck-protector-heuristics-effect-windows-64bit.rs |  366 +++++++
 .../stack-protector-heuristics-effect.rs           |  345 ++++++
 .../stack-protector-target-support.rs              |  281 +++++
 tests/assembly-llvm/static-relocation-model.rs     |   69 ++
 tests/assembly-llvm/strict_provenance.rs           |   37 +
 tests/assembly-llvm/target-feature-multiple.rs     |   40 +
 tests/assembly-llvm/targets/targets-amdgpu.rs      |   22 +
 tests/assembly-llvm/targets/targets-elf.rs         |  734 +++++++++++++
 tests/assembly-llvm/targets/targets-macho.rs       |   93 ++
 tests/assembly-llvm/targets/targets-nvptx.rs       |   22 +
 tests/assembly-llvm/targets/targets-pe.rs          |  103 ++
 tests/assembly-llvm/wasm_exceptions.rs             |   67 ++
 tests/assembly-llvm/x86-return-float.rs            |  343 ++++++
 .../x86_64-array-pair-load-store-merge.rs          |   20 +
 tests/assembly-llvm/x86_64-bigint-helpers.rs       |   61 ++
 tests/assembly-llvm/x86_64-cmp.rs                  |   79 ++
 tests/assembly-llvm/x86_64-floating-point-clamp.rs |   27 +
 ...x86_64-fortanix-unknown-sgx-lvi-generic-load.rs |   17 +
 .../x86_64-fortanix-unknown-sgx-lvi-generic-ret.rs |   12 +
 ..._64-fortanix-unknown-sgx-lvi-inline-assembly.rs |   34 +
 tests/assembly-llvm/x86_64-function-return.rs      |   30 +
 tests/assembly-llvm/x86_64-no-jump-tables.rs       |   35 +
 tests/assembly-llvm/x86_64-sse_crc.rs              |   12 +
 tests/assembly-llvm/x86_64-typed-swap.rs           |   81 ++
 tests/assembly-llvm/x86_64-windows-float-abi.rs    |   46 +
 tests/assembly-llvm/x86_64-windows-i128-abi.rs     |   26 +
 tests/assembly-llvm/x86_64-xray.rs                 |   25 +
 tests/assembly/aarch64-pointer-auth.rs             |   30 -
 tests/assembly/aarch64-xray.rs                     |   25 -
 tests/assembly/align_offset.rs                     |   47 -
 tests/assembly/asm/aarch64-el2vmsa.rs              |   33 -
 tests/assembly/asm/aarch64-modifiers.rs            |  128 ---
 tests/assembly/asm/aarch64-outline-atomics.rs      |   17 -
 tests/assembly/asm/aarch64-types.rs                |  633 -----------
 tests/assembly/asm/arm-modifiers.rs                |  122 ---
 tests/assembly/asm/arm-types.rs                    |  639 ------------
 tests/assembly/asm/avr-modifiers.rs                |   43 -
 tests/assembly/asm/avr-types.rs                    |  205 ----
 tests/assembly/asm/bpf-types.rs                    |  133 ---
 tests/assembly/asm/comments.rs                     |   12 -
 tests/assembly/asm/global_asm.rs                   |   32 -
 tests/assembly/asm/hexagon-types.rs                |  139 ---
 tests/assembly/asm/inline-asm-avx.rs               |   25 -
 tests/assembly/asm/loongarch-type.rs               |  190 ----
 tests/assembly/asm/m68k-types.rs                   |   67 --
 tests/assembly/asm/mips-types.rs                   |  211 ----
 tests/assembly/asm/msp430-types.rs                 |  141 ---
 tests/assembly/asm/nvptx-types.rs                  |  115 --
 tests/assembly/asm/powerpc-types.rs                |  474 ---------
 tests/assembly/asm/riscv-types.rs                  |  227 ----
 tests/assembly/asm/s390x-types.rs                  |  350 -------
 tests/assembly/asm/sparc-types.rs                  |  145 ---
 tests/assembly/asm/wasm-types.rs                   |  131 ---
 tests/assembly/asm/x86-modifiers.rs                |  184 ----
 tests/assembly/asm/x86-types.rs                    | 1095 --------------------
 .../assembly/auxiliary/breakpoint-panic-handler.rs |    8 -
 .../auxiliary/dwarf-mixed-versions-lto-aux.rs      |    5 -
 tests/assembly/auxiliary/non-inline-dependency.rs  |   14 -
 tests/assembly/breakpoint.rs                       |   14 -
 tests/assembly/closure-inherit-target-feature.rs   |   59 --
 tests/assembly/cmse.rs                             |  100 --
 .../compiletest-self-test/use-minicore-no-run.rs   |    5 -
 tests/assembly/cstring-merging.rs                  |   30 -
 tests/assembly/dwarf-mixed-versions-lto.rs         |   20 -
 tests/assembly/dwarf4.rs                           |   23 -
 tests/assembly/dwarf5.rs                           |   20 -
 tests/assembly/emit-intel-att-syntax.rs            |   75 --
 tests/assembly/is_aligned.rs                       |   55 -
 .../issue-83585-small-pod-struct-equality.rs       |   27 -
 tests/assembly/libs/issue-115339-zip-arrays.rs     |   25 -
 tests/assembly/libs/issue-140207-slice-min-simd.rs |   13 -
 tests/assembly/manual-eq-efficient.rs              |   22 -
 .../aarch64-naked-fn-no-bti-prolog.rs              |   21 -
 tests/assembly/naked-functions/aix.rs              |   35 -
 tests/assembly/naked-functions/wasm32.rs           |  200 ----
 .../x86_64-naked-fn-no-cet-prolog.rs               |   24 -
 tests/assembly/niche-prefer-zero.rs                |   25 -
 tests/assembly/nvptx-arch-default.rs               |   12 -
 tests/assembly/nvptx-arch-emit-asm.rs              |    9 -
 tests/assembly/nvptx-arch-link-arg.rs              |   13 -
 tests/assembly/nvptx-arch-target-cpu.rs            |   12 -
 tests/assembly/nvptx-atomics.rs                    |   86 --
 tests/assembly/nvptx-c-abi-arg-v7.rs               |  220 ----
 tests/assembly/nvptx-c-abi-ret-v7.rs               |  244 -----
 tests/assembly/nvptx-internalizing.rs              |   27 -
 .../nvptx-kernel-abi/nvptx-kernel-args-abi-v7.rs   |  251 -----
 tests/assembly/nvptx-linking-binary.rs             |   40 -
 tests/assembly/nvptx-linking-cdylib.rs             |   39 -
 tests/assembly/nvptx-safe-naming.rs                |   37 -
 tests/assembly/panic-no-unwind-no-uwtable.rs       |    8 -
 tests/assembly/panic-unwind-no-uwtable.rs          |   12 -
 tests/assembly/pic-relocation-model.rs             |   31 -
 tests/assembly/pie-relocation-model.rs             |   34 -
 tests/assembly/powerpc64-struct-abi.rs             |  156 ---
 tests/assembly/riscv-float-struct-abi.rs           |  177 ----
 .../assembly/riscv-soft-abi-with-float-features.rs |   45 -
 tests/assembly/rust-abi-arg-attr.rs                |  110 --
 tests/assembly/s390x-backchain-toggle.rs           |   50 -
 tests/assembly/s390x-vector-abi.rs                 |  327 ------
 .../sanitizer/kcfi/emit-arity-indicator.rs         |   69 --
 tests/assembly/simd-bitmask.rs                     |  147 ---
 tests/assembly/simd-intrinsic-gather.rs            |   39 -
 tests/assembly/simd-intrinsic-mask-load.rs         |   83 --
 tests/assembly/simd-intrinsic-mask-reduce.rs       |   59 --
 tests/assembly/simd-intrinsic-mask-store.rs        |   82 --
 tests/assembly/simd-intrinsic-scatter.rs           |   35 -
 tests/assembly/simd-intrinsic-select.rs            |  128 ---
 tests/assembly/simd/reduce-fadd-unordered.rs       |   31 -
 tests/assembly/slice-is_ascii.rs                   |   33 -
 tests/assembly/small_data_threshold.rs             |   98 --
 tests/assembly/sparc-struct-abi.rs                 |   68 --
 tests/assembly/stack-probes.rs                     |   41 -
 ...ck-protector-heuristics-effect-windows-32bit.rs |  359 -------
 ...ck-protector-heuristics-effect-windows-64bit.rs |  366 -------
 .../stack-protector-heuristics-effect.rs           |  345 ------
 .../stack-protector-target-support.rs              |  281 -----
 tests/assembly/static-relocation-model.rs          |   69 --
 tests/assembly/strict_provenance.rs                |   37 -
 tests/assembly/target-feature-multiple.rs          |   40 -
 tests/assembly/targets/targets-amdgpu.rs           |   22 -
 tests/assembly/targets/targets-elf.rs              |  734 -------------
 tests/assembly/targets/targets-macho.rs            |   93 --
 tests/assembly/targets/targets-nvptx.rs            |   22 -
 tests/assembly/targets/targets-pe.rs               |  103 --
 tests/assembly/wasm_exceptions.rs                  |   67 --
 tests/assembly/x86-return-float.rs                 |  343 ------
 .../assembly/x86_64-array-pair-load-store-merge.rs |   20 -
 tests/assembly/x86_64-bigint-helpers.rs            |   61 --
 tests/assembly/x86_64-cmp.rs                       |   79 --
 tests/assembly/x86_64-floating-point-clamp.rs      |   27 -
 ...x86_64-fortanix-unknown-sgx-lvi-generic-load.rs |   17 -
 .../x86_64-fortanix-unknown-sgx-lvi-generic-ret.rs |   12 -
 ..._64-fortanix-unknown-sgx-lvi-inline-assembly.rs |   34 -
 tests/assembly/x86_64-function-return.rs           |   30 -
 tests/assembly/x86_64-no-jump-tables.rs            |   35 -
 tests/assembly/x86_64-sse_crc.rs                   |   12 -
 tests/assembly/x86_64-typed-swap.rs                |   81 --
 tests/assembly/x86_64-windows-float-abi.rs         |   46 -
 tests/assembly/x86_64-windows-i128-abi.rs          |   26 -
 tests/assembly/x86_64-xray.rs                      |   25 -
 tests/codegen/target-feature-overrides.rs          |    2 +-
 tests/run-make/avr-rjmp-offset/rmake.rs            |    2 +-
 triagebot.toml                                     |    2 +-
 237 files changed, 12674 insertions(+), 12669 deletions(-)
 create mode 100644 tests/assembly-llvm/aarch64-pointer-auth.rs
 create mode 100644 tests/assembly-llvm/aarch64-xray.rs
 create mode 100644 tests/assembly-llvm/align_offset.rs
 create mode 100644 tests/assembly-llvm/asm/aarch64-el2vmsa.rs
 create mode 100644 tests/assembly-llvm/asm/aarch64-modifiers.rs
 create mode 100644 tests/assembly-llvm/asm/aarch64-outline-atomics.rs
 create mode 100644 tests/assembly-llvm/asm/aarch64-types.rs
 create mode 100644 tests/assembly-llvm/asm/arm-modifiers.rs
 create mode 100644 tests/assembly-llvm/asm/arm-types.rs
 create mode 100644 tests/assembly-llvm/asm/avr-modifiers.rs
 create mode 100644 tests/assembly-llvm/asm/avr-types.rs
 create mode 100644 tests/assembly-llvm/asm/bpf-types.rs
 create mode 100644 tests/assembly-llvm/asm/comments.rs
 create mode 100644 tests/assembly-llvm/asm/global_asm.rs
 create mode 100644 tests/assembly-llvm/asm/hexagon-types.rs
 create mode 100644 tests/assembly-llvm/asm/inline-asm-avx.rs
 create mode 100644 tests/assembly-llvm/asm/loongarch-type.rs
 create mode 100644 tests/assembly-llvm/asm/m68k-types.rs
 create mode 100644 tests/assembly-llvm/asm/mips-types.rs
 create mode 100644 tests/assembly-llvm/asm/msp430-types.rs
 create mode 100644 tests/assembly-llvm/asm/nvptx-types.rs
 create mode 100644 tests/assembly-llvm/asm/powerpc-types.rs
 create mode 100644 tests/assembly-llvm/asm/riscv-types.rs
 create mode 100644 tests/assembly-llvm/asm/s390x-types.rs
 create mode 100644 tests/assembly-llvm/asm/sparc-types.rs
 create mode 100644 tests/assembly-llvm/asm/wasm-types.rs
 create mode 100644 tests/assembly-llvm/asm/x86-modifiers.rs
 create mode 100644 tests/assembly-llvm/asm/x86-types.rs
 create mode 100644 tests/assembly-llvm/auxiliary/breakpoint-panic-handler.rs
 create mode 100644 tests/assembly-llvm/auxiliary/dwarf-mixed-versions-lto-aux.rs
 create mode 100644 tests/assembly-llvm/auxiliary/non-inline-dependency.rs
 create mode 100644 tests/assembly-llvm/breakpoint.rs
 create mode 100644 tests/assembly-llvm/closure-inherit-target-feature.rs
 create mode 100644 tests/assembly-llvm/cmse.rs
 create mode 100644 tests/assembly-llvm/compiletest-self-test/use-minicore-no-run.rs
 create mode 100644 tests/assembly-llvm/cstring-merging.rs
 create mode 100644 tests/assembly-llvm/dwarf-mixed-versions-lto.rs
 create mode 100644 tests/assembly-llvm/dwarf4.rs
 create mode 100644 tests/assembly-llvm/dwarf5.rs
 create mode 100644 tests/assembly-llvm/emit-intel-att-syntax.rs
 create mode 100644 tests/assembly-llvm/is_aligned.rs
 create mode 100644 tests/assembly-llvm/issue-83585-small-pod-struct-equality.rs
 create mode 100644 tests/assembly-llvm/libs/issue-115339-zip-arrays.rs
 create mode 100644 tests/assembly-llvm/libs/issue-140207-slice-min-simd.rs
 create mode 100644 tests/assembly-llvm/manual-eq-efficient.rs
 create mode 100644 tests/assembly-llvm/naked-functions/aarch64-naked-fn-no-bti-prolog.rs
 create mode 100644 tests/assembly-llvm/naked-functions/aix.rs
 create mode 100644 tests/assembly-llvm/naked-functions/wasm32.rs
 create mode 100644 tests/assembly-llvm/naked-functions/x86_64-naked-fn-no-cet-prolog.rs
 create mode 100644 tests/assembly-llvm/niche-prefer-zero.rs
 create mode 100644 tests/assembly-llvm/nvptx-arch-default.rs
 create mode 100644 tests/assembly-llvm/nvptx-arch-emit-asm.rs
 create mode 100644 tests/assembly-llvm/nvptx-arch-link-arg.rs
 create mode 100644 tests/assembly-llvm/nvptx-arch-target-cpu.rs
 create mode 100644 tests/assembly-llvm/nvptx-atomics.rs
 create mode 100644 tests/assembly-llvm/nvptx-c-abi-arg-v7.rs
 create mode 100644 tests/assembly-llvm/nvptx-c-abi-ret-v7.rs
 create mode 100644 tests/assembly-llvm/nvptx-internalizing.rs
 create mode 100644 tests/assembly-llvm/nvptx-kernel-abi/nvptx-kernel-args-abi-v7.rs
 create mode 100644 tests/assembly-llvm/nvptx-linking-binary.rs
 create mode 100644 tests/assembly-llvm/nvptx-linking-cdylib.rs
 create mode 100644 tests/assembly-llvm/nvptx-safe-naming.rs
 create mode 100644 tests/assembly-llvm/panic-no-unwind-no-uwtable.rs
 create mode 100644 tests/assembly-llvm/panic-unwind-no-uwtable.rs
 create mode 100644 tests/assembly-llvm/pic-relocation-model.rs
 create mode 100644 tests/assembly-llvm/pie-relocation-model.rs
 create mode 100644 tests/assembly-llvm/powerpc64-struct-abi.rs
 create mode 100644 tests/assembly-llvm/riscv-float-struct-abi.rs
 create mode 100644 tests/assembly-llvm/riscv-soft-abi-with-float-features.rs
 create mode 100644 tests/assembly-llvm/rust-abi-arg-attr.rs
 create mode 100644 tests/assembly-llvm/s390x-backchain-toggle.rs
 create mode 100644 tests/assembly-llvm/s390x-vector-abi.rs
 create mode 100644 tests/assembly-llvm/sanitizer/kcfi/emit-arity-indicator.rs
 create mode 100644 tests/assembly-llvm/simd-bitmask.rs
 create mode 100644 tests/assembly-llvm/simd-intrinsic-gather.rs
 create mode 100644 tests/assembly-llvm/simd-intrinsic-mask-load.rs
 create mode 100644 tests/assembly-llvm/simd-intrinsic-mask-reduce.rs
 create mode 100644 tests/assembly-llvm/simd-intrinsic-mask-store.rs
 create mode 100644 tests/assembly-llvm/simd-intrinsic-scatter.rs
 create mode 100644 tests/assembly-llvm/simd-intrinsic-select.rs
 create mode 100644 tests/assembly-llvm/simd/reduce-fadd-unordered.rs
 create mode 100644 tests/assembly-llvm/slice-is_ascii.rs
 create mode 100644 tests/assembly-llvm/small_data_threshold.rs
 create mode 100644 tests/assembly-llvm/sparc-struct-abi.rs
 create mode 100644 tests/assembly-llvm/stack-probes.rs
 create mode 100644 tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-windows-32bit.rs
 create mode 100644 tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-windows-64bit.rs
 create mode 100644 tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect.rs
 create mode 100644 tests/assembly-llvm/stack-protector/stack-protector-target-support.rs
 create mode 100644 tests/assembly-llvm/static-relocation-model.rs
 create mode 100644 tests/assembly-llvm/strict_provenance.rs
 create mode 100644 tests/assembly-llvm/target-feature-multiple.rs
 create mode 100644 tests/assembly-llvm/targets/targets-amdgpu.rs
 create mode 100644 tests/assembly-llvm/targets/targets-elf.rs
 create mode 100644 tests/assembly-llvm/targets/targets-macho.rs
 create mode 100644 tests/assembly-llvm/targets/targets-nvptx.rs
 create mode 100644 tests/assembly-llvm/targets/targets-pe.rs
 create mode 100644 tests/assembly-llvm/wasm_exceptions.rs
 create mode 100644 tests/assembly-llvm/x86-return-float.rs
 create mode 100644 tests/assembly-llvm/x86_64-array-pair-load-store-merge.rs
 create mode 100644 tests/assembly-llvm/x86_64-bigint-helpers.rs
 create mode 100644 tests/assembly-llvm/x86_64-cmp.rs
 create mode 100644 tests/assembly-llvm/x86_64-floating-point-clamp.rs
 create mode 100644 tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-generic-load.rs
 create mode 100644 tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-generic-ret.rs
 create mode 100644 tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-inline-assembly.rs
 create mode 100644 tests/assembly-llvm/x86_64-function-return.rs
 create mode 100644 tests/assembly-llvm/x86_64-no-jump-tables.rs
 create mode 100644 tests/assembly-llvm/x86_64-sse_crc.rs
 create mode 100644 tests/assembly-llvm/x86_64-typed-swap.rs
 create mode 100644 tests/assembly-llvm/x86_64-windows-float-abi.rs
 create mode 100644 tests/assembly-llvm/x86_64-windows-i128-abi.rs
 create mode 100644 tests/assembly-llvm/x86_64-xray.rs
 delete mode 100644 tests/assembly/aarch64-pointer-auth.rs
 delete mode 100644 tests/assembly/aarch64-xray.rs
 delete mode 100644 tests/assembly/align_offset.rs
 delete mode 100644 tests/assembly/asm/aarch64-el2vmsa.rs
 delete mode 100644 tests/assembly/asm/aarch64-modifiers.rs
 delete mode 100644 tests/assembly/asm/aarch64-outline-atomics.rs
 delete mode 100644 tests/assembly/asm/aarch64-types.rs
 delete mode 100644 tests/assembly/asm/arm-modifiers.rs
 delete mode 100644 tests/assembly/asm/arm-types.rs
 delete mode 100644 tests/assembly/asm/avr-modifiers.rs
 delete mode 100644 tests/assembly/asm/avr-types.rs
 delete mode 100644 tests/assembly/asm/bpf-types.rs
 delete mode 100644 tests/assembly/asm/comments.rs
 delete mode 100644 tests/assembly/asm/global_asm.rs
 delete mode 100644 tests/assembly/asm/hexagon-types.rs
 delete mode 100644 tests/assembly/asm/inline-asm-avx.rs
 delete mode 100644 tests/assembly/asm/loongarch-type.rs
 delete mode 100644 tests/assembly/asm/m68k-types.rs
 delete mode 100644 tests/assembly/asm/mips-types.rs
 delete mode 100644 tests/assembly/asm/msp430-types.rs
 delete mode 100644 tests/assembly/asm/nvptx-types.rs
 delete mode 100644 tests/assembly/asm/powerpc-types.rs
 delete mode 100644 tests/assembly/asm/riscv-types.rs
 delete mode 100644 tests/assembly/asm/s390x-types.rs
 delete mode 100644 tests/assembly/asm/sparc-types.rs
 delete mode 100644 tests/assembly/asm/wasm-types.rs
 delete mode 100644 tests/assembly/asm/x86-modifiers.rs
 delete mode 100644 tests/assembly/asm/x86-types.rs
 delete mode 100644 tests/assembly/auxiliary/breakpoint-panic-handler.rs
 delete mode 100644 tests/assembly/auxiliary/dwarf-mixed-versions-lto-aux.rs
 delete mode 100644 tests/assembly/auxiliary/non-inline-dependency.rs
 delete mode 100644 tests/assembly/breakpoint.rs
 delete mode 100644 tests/assembly/closure-inherit-target-feature.rs
 delete mode 100644 tests/assembly/cmse.rs
 delete mode 100644 tests/assembly/compiletest-self-test/use-minicore-no-run.rs
 delete mode 100644 tests/assembly/cstring-merging.rs
 delete mode 100644 tests/assembly/dwarf-mixed-versions-lto.rs
 delete mode 100644 tests/assembly/dwarf4.rs
 delete mode 100644 tests/assembly/dwarf5.rs
 delete mode 100644 tests/assembly/emit-intel-att-syntax.rs
 delete mode 100644 tests/assembly/is_aligned.rs
 delete mode 100644 tests/assembly/issue-83585-small-pod-struct-equality.rs
 delete mode 100644 tests/assembly/libs/issue-115339-zip-arrays.rs
 delete mode 100644 tests/assembly/libs/issue-140207-slice-min-simd.rs
 delete mode 100644 tests/assembly/manual-eq-efficient.rs
 delete mode 100644 tests/assembly/naked-functions/aarch64-naked-fn-no-bti-prolog.rs
 delete mode 100644 tests/assembly/naked-functions/aix.rs
 delete mode 100644 tests/assembly/naked-functions/wasm32.rs
 delete mode 100644 tests/assembly/naked-functions/x86_64-naked-fn-no-cet-prolog.rs
 delete mode 100644 tests/assembly/niche-prefer-zero.rs
 delete mode 100644 tests/assembly/nvptx-arch-default.rs
 delete mode 100644 tests/assembly/nvptx-arch-emit-asm.rs
 delete mode 100644 tests/assembly/nvptx-arch-link-arg.rs
 delete mode 100644 tests/assembly/nvptx-arch-target-cpu.rs
 delete mode 100644 tests/assembly/nvptx-atomics.rs
 delete mode 100644 tests/assembly/nvptx-c-abi-arg-v7.rs
 delete mode 100644 tests/assembly/nvptx-c-abi-ret-v7.rs
 delete mode 100644 tests/assembly/nvptx-internalizing.rs
 delete mode 100644 tests/assembly/nvptx-kernel-abi/nvptx-kernel-args-abi-v7.rs
 delete mode 100644 tests/assembly/nvptx-linking-binary.rs
 delete mode 100644 tests/assembly/nvptx-linking-cdylib.rs
 delete mode 100644 tests/assembly/nvptx-safe-naming.rs
 delete mode 100644 tests/assembly/panic-no-unwind-no-uwtable.rs
 delete mode 100644 tests/assembly/panic-unwind-no-uwtable.rs
 delete mode 100644 tests/assembly/pic-relocation-model.rs
 delete mode 100644 tests/assembly/pie-relocation-model.rs
 delete mode 100644 tests/assembly/powerpc64-struct-abi.rs
 delete mode 100644 tests/assembly/riscv-float-struct-abi.rs
 delete mode 100644 tests/assembly/riscv-soft-abi-with-float-features.rs
 delete mode 100644 tests/assembly/rust-abi-arg-attr.rs
 delete mode 100644 tests/assembly/s390x-backchain-toggle.rs
 delete mode 100644 tests/assembly/s390x-vector-abi.rs
 delete mode 100644 tests/assembly/sanitizer/kcfi/emit-arity-indicator.rs
 delete mode 100644 tests/assembly/simd-bitmask.rs
 delete mode 100644 tests/assembly/simd-intrinsic-gather.rs
 delete mode 100644 tests/assembly/simd-intrinsic-mask-load.rs
 delete mode 100644 tests/assembly/simd-intrinsic-mask-reduce.rs
 delete mode 100644 tests/assembly/simd-intrinsic-mask-store.rs
 delete mode 100644 tests/assembly/simd-intrinsic-scatter.rs
 delete mode 100644 tests/assembly/simd-intrinsic-select.rs
 delete mode 100644 tests/assembly/simd/reduce-fadd-unordered.rs
 delete mode 100644 tests/assembly/slice-is_ascii.rs
 delete mode 100644 tests/assembly/small_data_threshold.rs
 delete mode 100644 tests/assembly/sparc-struct-abi.rs
 delete mode 100644 tests/assembly/stack-probes.rs
 delete mode 100644 tests/assembly/stack-protector/stack-protector-heuristics-effect-windows-32bit.rs
 delete mode 100644 tests/assembly/stack-protector/stack-protector-heuristics-effect-windows-64bit.rs
 delete mode 100644 tests/assembly/stack-protector/stack-protector-heuristics-effect.rs
 delete mode 100644 tests/assembly/stack-protector/stack-protector-target-support.rs
 delete mode 100644 tests/assembly/static-relocation-model.rs
 delete mode 100644 tests/assembly/strict_provenance.rs
 delete mode 100644 tests/assembly/target-feature-multiple.rs
 delete mode 100644 tests/assembly/targets/targets-amdgpu.rs
 delete mode 100644 tests/assembly/targets/targets-elf.rs
 delete mode 100644 tests/assembly/targets/targets-macho.rs
 delete mode 100644 tests/assembly/targets/targets-nvptx.rs
 delete mode 100644 tests/assembly/targets/targets-pe.rs
 delete mode 100644 tests/assembly/wasm_exceptions.rs
 delete mode 100644 tests/assembly/x86-return-float.rs
 delete mode 100644 tests/assembly/x86_64-array-pair-load-store-merge.rs
 delete mode 100644 tests/assembly/x86_64-bigint-helpers.rs
 delete mode 100644 tests/assembly/x86_64-cmp.rs
 delete mode 100644 tests/assembly/x86_64-floating-point-clamp.rs
 delete mode 100644 tests/assembly/x86_64-fortanix-unknown-sgx-lvi-generic-load.rs
 delete mode 100644 tests/assembly/x86_64-fortanix-unknown-sgx-lvi-generic-ret.rs
 delete mode 100644 tests/assembly/x86_64-fortanix-unknown-sgx-lvi-inline-assembly.rs
 delete mode 100644 tests/assembly/x86_64-function-return.rs
 delete mode 100644 tests/assembly/x86_64-no-jump-tables.rs
 delete mode 100644 tests/assembly/x86_64-sse_crc.rs
 delete mode 100644 tests/assembly/x86_64-typed-swap.rs
 delete mode 100644 tests/assembly/x86_64-windows-float-abi.rs
 delete mode 100644 tests/assembly/x86_64-windows-i128-abi.rs
 delete mode 100644 tests/assembly/x86_64-xray.rs

diff --git a/compiler/rustc_codegen_gcc/build_system/src/test.rs b/compiler/rustc_codegen_gcc/build_system/src/test.rs
index cbb0f949383..bc0fdd40b6e 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/test.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/test.rs
@@ -588,7 +588,7 @@ fn asm_tests(env: &Env, args: &TestArg) -> Result<(), String> {
             &"always",
             &"--stage",
             &"0",
-            &"tests/assembly/asm",
+            &"tests/assembly-llvm/asm",
             &"--compiletest-rustc-args",
             &rustc_args,
         ],
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 8344b0e03b4..99c9e8ae92e 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1407,7 +1407,12 @@ test!(Pretty {
 
 test!(RunMake { path: "tests/run-make", mode: "run-make", suite: "run-make", default: true });
 
-test!(Assembly { path: "tests/assembly", mode: "assembly", suite: "assembly", default: true });
+test!(AssemblyLlvm {
+    path: "tests/assembly-llvm",
+    mode: "assembly",
+    suite: "assembly-llvm",
+    default: true
+});
 
 /// Runs the coverage test suite at `tests/coverage` in some or all of the
 /// coverage test modes.
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index d73e2bce25b..925e47a4164 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -411,7 +411,7 @@ const PATH_REMAP: &[(&str, &[&str])] = &[
         "tests",
         &[
             // tidy-alphabetical-start
-            "tests/assembly",
+            "tests/assembly-llvm",
             "tests/codegen",
             "tests/codegen-units",
             "tests/coverage",
@@ -1051,7 +1051,7 @@ impl<'a> Builder<'a> {
                 test::MirOpt,
                 test::Codegen,
                 test::CodegenUnits,
-                test::Assembly,
+                test::AssemblyLlvm,
                 test::Incremental,
                 test::Debuginfo,
                 test::UiFullDeps,
diff --git a/src/ci/docker/host-x86_64/test-various/Dockerfile b/src/ci/docker/host-x86_64/test-various/Dockerfile
index 8d2e45ae497..54ca7131608 100644
--- a/src/ci/docker/host-x86_64/test-various/Dockerfile
+++ b/src/ci/docker/host-x86_64/test-various/Dockerfile
@@ -66,13 +66,13 @@ ENV WASM_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $WASM_T
   tests/mir-opt \
   tests/codegen-units \
   tests/codegen \
-  tests/assembly \
+  tests/assembly-llvm \
   library/core
 
 ENV NVPTX_TARGETS=nvptx64-nvidia-cuda
 ENV NVPTX_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $NVPTX_TARGETS \
   tests/run-make \
-  tests/assembly
+  tests/assembly-llvm
 
 ENV MUSL_TARGETS=x86_64-unknown-linux-musl \
     CC_x86_64_unknown_linux_musl=x86_64-linux-musl-gcc \
diff --git a/src/doc/rustc-dev-guide/src/asm.md b/src/doc/rustc-dev-guide/src/asm.md
index eec9d448b0c..3d93d5a4c57 100644
--- a/src/doc/rustc-dev-guide/src/asm.md
+++ b/src/doc/rustc-dev-guide/src/asm.md
@@ -155,9 +155,9 @@ can't know ahead of time whether a function will require a frame/base pointer.
 
 Various tests for inline assembly are available:
 
-- `tests/assembly/asm`
+- `tests/assembly-llvm/asm`
 - `tests/ui/asm`
 - `tests/codegen/asm-*`
 
 Every architecture supported by inline assembly must have exhaustive tests in
-`tests/assembly/asm` which test all combinations of register classes and types.
+`tests/assembly-llvm/asm` which test all combinations of register classes and types.
diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md
index aa99347b2bb..6a60e7118d3 100644
--- a/src/doc/rustc-dev-guide/src/tests/compiletest.md
+++ b/src/doc/rustc-dev-guide/src/tests/compiletest.md
@@ -307,7 +307,7 @@ If you need to work with `#![no_std]` cross-compiling tests, consult the
 
 ### Assembly tests
 
-The tests in [`tests/assembly`] test LLVM assembly output. They compile the test
+The tests in [`tests/assembly-llvm`] test LLVM assembly output. They compile the test
 with the `--emit=asm` flag to emit a `.s` file with the assembly output. They
 then run the LLVM [FileCheck] tool.
 
@@ -324,7 +324,7 @@ See also the [codegen tests](#codegen-tests) for a similar set of tests.
 If you need to work with `#![no_std]` cross-compiling tests, consult the
 [`minicore` test auxiliary](./minicore.md) chapter.
 
-[`tests/assembly`]: https://github.com/rust-lang/rust/tree/master/tests/assembly
+[`tests/assembly-llvm`]: https://github.com/rust-lang/rust/tree/master/tests/assembly-llvm
 
 
 ### Codegen-units tests
diff --git a/src/tools/opt-dist/src/tests.rs b/src/tools/opt-dist/src/tests.rs
index c3c45d262dd..a70c257e52b 100644
--- a/src/tools/opt-dist/src/tests.rs
+++ b/src/tools/opt-dist/src/tests.rs
@@ -100,7 +100,7 @@ llvm-config = "{llvm_config}"
             env.host_tuple(),
             "--stage",
             "0",
-            "tests/assembly",
+            "tests/assembly-llvm",
             "tests/codegen",
             "tests/codegen-units",
             "tests/incremental",
diff --git a/src/tools/tidy/src/target_policy.rs b/src/tools/tidy/src/target_policy.rs
index 776221d3062..550932dbfdc 100644
--- a/src/tools/tidy/src/target_policy.rs
+++ b/src/tools/tidy/src/target_policy.rs
@@ -8,7 +8,7 @@ use std::path::Path;
 use crate::walk::{filter_not_rust, walk};
 
 const TARGET_DEFINITIONS_PATH: &str = "compiler/rustc_target/src/spec/targets/";
-const ASSEMBLY_TEST_PATH: &str = "tests/assembly/targets/";
+const ASSEMBLY_LLVM_TEST_PATH: &str = "tests/assembly-llvm/targets/";
 const REVISION_LINE_START: &str = "//@ revisions: ";
 const EXCEPTIONS: &[&str] = &[
     // FIXME: disabled since it fails on CI saying the csky component is missing
@@ -43,7 +43,7 @@ pub fn check(root_path: &Path, bad: &mut bool) {
         let _ = targets_to_find.insert(target_name);
     }
 
-    walk(&root_path.join(ASSEMBLY_TEST_PATH), |_, _| false, &mut |_, contents| {
+    walk(&root_path.join(ASSEMBLY_LLVM_TEST_PATH), |_, _| false, &mut |_, contents| {
         for line in contents.lines() {
             let Some(_) = line.find(REVISION_LINE_START) else {
                 continue;
@@ -55,7 +55,7 @@ pub fn check(root_path: &Path, bad: &mut bool) {
 
     for target in targets_to_find {
         if !EXCEPTIONS.contains(&target.as_str()) {
-            tidy_error!(bad, "{ASSEMBLY_TEST_PATH}: missing assembly test for {target}")
+            tidy_error!(bad, "{ASSEMBLY_LLVM_TEST_PATH}: missing assembly test for {target}")
         }
     }
 }
diff --git a/tests/assembly-llvm/aarch64-pointer-auth.rs b/tests/assembly-llvm/aarch64-pointer-auth.rs
new file mode 100644
index 00000000000..56a26df469f
--- /dev/null
+++ b/tests/assembly-llvm/aarch64-pointer-auth.rs
@@ -0,0 +1,30 @@
+// Test that PAC instructions are emitted when branch-protection is specified.
+
+//@ add-core-stubs
+//@ revisions: PACRET PAUTHLR_NOP PAUTHLR
+//@ assembly-output: emit-asm
+//@ needs-llvm-components: aarch64
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ [PACRET] compile-flags: -Z branch-protection=pac-ret,leaf
+//@ [PAUTHLR_NOP] compile-flags: -Z branch-protection=pac-ret,pc,leaf
+//@ [PAUTHLR] compile-flags: -C target-feature=+pauth-lr -Z branch-protection=pac-ret,pc,leaf
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+// PACRET: hint #25
+// PACRET: hint #29
+// PAUTHLR_NOP: hint #25
+// PAUTHLR_NOP: hint #39
+// PAUTHLR_NOP: hint #29
+// PAUTHLR: paciasppc
+// PAUTHLR: autiasppc
+#[no_mangle]
+pub fn test() -> u8 {
+    42
+}
diff --git a/tests/assembly-llvm/aarch64-xray.rs b/tests/assembly-llvm/aarch64-xray.rs
new file mode 100644
index 00000000000..d5ee0111843
--- /dev/null
+++ b/tests/assembly-llvm/aarch64-xray.rs
@@ -0,0 +1,25 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: -Zinstrument-xray=always
+
+//@ revisions: aarch64-linux
+//@[aarch64-linux] compile-flags: --target=aarch64-unknown-linux-gnu
+//@[aarch64-linux] needs-llvm-components: aarch64
+//@[aarch64-linux] only-aarch64-unknown-linux-gnu
+
+//@ revisions: aarch64-darwin
+//@[aarch64-darwin] compile-flags: --target=aarch64-apple-darwin
+//@[aarch64-darwin] needs-llvm-components: aarch64
+//@[aarch64-darwin] only-aarch64-apple-darwin
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: xray_func:
+#[no_mangle]
+pub fn xray_func() {
+    // CHECK: nop
+
+    std::hint::black_box(());
+
+    // CHECK: b #32
+    // CHECK-NEXT: nop
+}
diff --git a/tests/assembly-llvm/align_offset.rs b/tests/assembly-llvm/align_offset.rs
new file mode 100644
index 00000000000..d9902ce336b
--- /dev/null
+++ b/tests/assembly-llvm/align_offset.rs
@@ -0,0 +1,47 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=1
+//@ only-x86_64
+#![crate_type = "rlib"]
+
+// CHECK-LABEL: align_offset_byte_ptr
+// CHECK: leaq 31
+// CHECK: andq $-32
+// CHECK: subq
+#[no_mangle]
+pub fn align_offset_byte_ptr(ptr: *const u8) -> usize {
+    ptr.align_offset(32)
+}
+
+// CHECK-LABEL: align_offset_byte_slice
+// CHECK: leaq 31
+// CHECK: andq $-32
+// CHECK: subq
+#[no_mangle]
+pub fn align_offset_byte_slice(slice: &[u8]) -> usize {
+    slice.as_ptr().align_offset(32)
+}
+
+// CHECK-LABEL: align_offset_word_ptr
+// CHECK: leaq 31
+// CHECK: andq $-32
+// CHECK: subq
+// CHECK: shrq
+// This `ptr` is not known to be aligned, so it is required to check if it is at all possible to
+// align. LLVM applies a simple mask.
+// CHECK: orq
+#[no_mangle]
+pub fn align_offset_word_ptr(ptr: *const u32) -> usize {
+    ptr.align_offset(32)
+}
+
+// CHECK-LABEL: align_offset_word_slice
+// CHECK: leaq 31
+// CHECK: andq $-32
+// CHECK: subq
+// CHECK: shrq
+// `slice` is known to be aligned, so `!0` is not possible as a return
+// CHECK-NOT: orq
+#[no_mangle]
+pub fn align_offset_word_slice(slice: &[u32]) -> usize {
+    slice.as_ptr().align_offset(32)
+}
diff --git a/tests/assembly-llvm/asm/aarch64-el2vmsa.rs b/tests/assembly-llvm/asm/aarch64-el2vmsa.rs
new file mode 100644
index 00000000000..3652d58d85a
--- /dev/null
+++ b/tests/assembly-llvm/asm/aarch64-el2vmsa.rs
@@ -0,0 +1,33 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ needs-llvm-components: aarch64
+
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: ttbr0_el2:
+#[no_mangle]
+pub fn ttbr0_el2() {
+    // CHECK: //APP
+    // CHECK-NEXT: msr TTBR0_EL2, x0
+    // CHECK-NEXT: //NO_APP
+    unsafe {
+        asm!("msr ttbr0_el2, x0");
+    }
+}
+
+// CHECK-LABEL: vttbr_el2:
+#[no_mangle]
+pub fn vttbr_el2() {
+    // CHECK: //APP
+    // CHECK-NEXT: msr VTTBR_EL2, x0
+    // CHECK-NEXT: //NO_APP
+    unsafe {
+        asm!("msr vttbr_el2, x0");
+    }
+}
diff --git a/tests/assembly-llvm/asm/aarch64-modifiers.rs b/tests/assembly-llvm/asm/aarch64-modifiers.rs
new file mode 100644
index 00000000000..58f7c114d3a
--- /dev/null
+++ b/tests/assembly-llvm/asm/aarch64-modifiers.rs
@@ -0,0 +1,128 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3 -C panic=abort
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ compile-flags: -Zmerge-functions=disabled
+//@ needs-llvm-components: aarch64
+
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register)]
+
+extern crate minicore;
+use minicore::*;
+
+macro_rules! check {
+    ($func:ident $reg:ident $code:literal) => {
+        // -Copt-level=3 and extern "C" guarantee that the selected register is always r0/s0/d0/q0
+        #[no_mangle]
+        pub unsafe extern "C" fn $func() -> i32 {
+            let y;
+            asm!($code, out($reg) y);
+            y
+        }
+    };
+}
+
+// CHECK-LABEL: reg:
+// CHECK: //APP
+// CHECK: mov x0, x0
+// CHECK: //NO_APP
+check!(reg reg "mov {0}, {0}");
+
+// CHECK-LABEL: reg_w:
+// CHECK: //APP
+// CHECK: mov w0, w0
+// CHECK: //NO_APP
+check!(reg_w reg "mov {0:w}, {0:w}");
+
+// CHECK-LABEL: reg_x:
+// CHECK: //APP
+// CHECK: mov x0, x0
+// CHECK: //NO_APP
+check!(reg_x reg "mov {0:x}, {0:x}");
+
+// CHECK-LABEL: vreg:
+// CHECK: //APP
+// CHECK: add v0.4s, v0.4s, v0.4s
+// CHECK: //NO_APP
+check!(vreg vreg "add {0}.4s, {0}.4s, {0}.4s");
+
+// CHECK-LABEL: vreg_b:
+// CHECK: //APP
+// CHECK: ldr b0, [x0]
+// CHECK: //NO_APP
+check!(vreg_b vreg "ldr {:b}, [x0]");
+
+// CHECK-LABEL: vreg_h:
+// CHECK: //APP
+// CHECK: ldr h0, [x0]
+// CHECK: //NO_APP
+check!(vreg_h vreg "ldr {:h}, [x0]");
+
+// CHECK-LABEL: vreg_s:
+// CHECK: //APP
+// CHECK: ldr s0, [x0]
+// CHECK: //NO_APP
+check!(vreg_s vreg "ldr {:s}, [x0]");
+
+// CHECK-LABEL: vreg_d:
+// CHECK: //APP
+// CHECK: ldr d0, [x0]
+// CHECK: //NO_APP
+check!(vreg_d vreg "ldr {:d}, [x0]");
+
+// CHECK-LABEL: vreg_q:
+// CHECK: //APP
+// CHECK: ldr q0, [x0]
+// CHECK: //NO_APP
+check!(vreg_q vreg "ldr {:q}, [x0]");
+
+// CHECK-LABEL: vreg_v:
+// CHECK: //APP
+// CHECK: add v0.4s, v0.4s, v0.4s
+// CHECK: //NO_APP
+check!(vreg_v vreg "add {0:v}.4s, {0:v}.4s, {0:v}.4s");
+
+// CHECK-LABEL: vreg_low16:
+// CHECK: //APP
+// CHECK: add v0.4s, v0.4s, v0.4s
+// CHECK: //NO_APP
+check!(vreg_low16 vreg_low16 "add {0}.4s, {0}.4s, {0}.4s");
+
+// CHECK-LABEL: vreg_low16_b:
+// CHECK: //APP
+// CHECK: ldr b0, [x0]
+// CHECK: //NO_APP
+check!(vreg_low16_b vreg_low16 "ldr {:b}, [x0]");
+
+// CHECK-LABEL: vreg_low16_h:
+// CHECK: //APP
+// CHECK: ldr h0, [x0]
+// CHECK: //NO_APP
+check!(vreg_low16_h vreg_low16 "ldr {:h}, [x0]");
+
+// CHECK-LABEL: vreg_low16_s:
+// CHECK: //APP
+// CHECK: ldr s0, [x0]
+// CHECK: //NO_APP
+check!(vreg_low16_s vreg_low16 "ldr {:s}, [x0]");
+
+// CHECK-LABEL: vreg_low16_d:
+// CHECK: //APP
+// CHECK: ldr d0, [x0]
+// CHECK: //NO_APP
+check!(vreg_low16_d vreg_low16 "ldr {:d}, [x0]");
+
+// CHECK-LABEL: vreg_low16_q:
+// CHECK: //APP
+// CHECK: ldr q0, [x0]
+// CHECK: //NO_APP
+check!(vreg_low16_q vreg_low16 "ldr {:q}, [x0]");
+
+// CHECK-LABEL: vreg_low16_v:
+// CHECK: //APP
+// CHECK: add v0.4s, v0.4s, v0.4s
+// CHECK: //NO_APP
+check!(vreg_low16_v vreg_low16 "add {0:v}.4s, {0:v}.4s, {0:v}.4s");
diff --git a/tests/assembly-llvm/asm/aarch64-outline-atomics.rs b/tests/assembly-llvm/asm/aarch64-outline-atomics.rs
new file mode 100644
index 00000000000..5990fb84942
--- /dev/null
+++ b/tests/assembly-llvm/asm/aarch64-outline-atomics.rs
@@ -0,0 +1,17 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+//@ needs-llvm-components: aarch64
+//@ only-aarch64
+//@ only-linux
+
+#![crate_type = "rlib"]
+
+use std::sync::atomic::AtomicI32;
+use std::sync::atomic::Ordering::*;
+
+pub fn compare_exchange(a: &AtomicI32) {
+    // On AArch64 LLVM should outline atomic operations.
+    // CHECK: __aarch64_cas4_relax
+    let _ = a.compare_exchange(0, 10, Relaxed, Relaxed);
+}
diff --git a/tests/assembly-llvm/asm/aarch64-types.rs b/tests/assembly-llvm/asm/aarch64-types.rs
new file mode 100644
index 00000000000..b7abeb02298
--- /dev/null
+++ b/tests/assembly-llvm/asm/aarch64-types.rs
@@ -0,0 +1,633 @@
+//@ add-core-stubs
+//@ revisions: aarch64 arm64ec
+//@ assembly-output: emit-asm
+//@ [aarch64] compile-flags: --target aarch64-unknown-linux-gnu
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [arm64ec] compile-flags: --target arm64ec-pc-windows-msvc
+//@ [arm64ec] needs-llvm-components: aarch64
+//@ compile-flags: -Zmerge-functions=disabled
+
+#![feature(no_core, repr_simd, f16, f128)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register, non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *mut u8;
+
+#[repr(simd)]
+pub struct i8x8([i8; 8]);
+#[repr(simd)]
+pub struct i16x4([i16; 4]);
+#[repr(simd)]
+pub struct i32x2([i32; 2]);
+#[repr(simd)]
+pub struct i64x1([i64; 1]);
+#[repr(simd)]
+pub struct f16x4([f16; 4]);
+#[repr(simd)]
+pub struct f32x2([f32; 2]);
+#[repr(simd)]
+pub struct f64x1([f64; 1]);
+#[repr(simd)]
+pub struct i8x16([i8; 16]);
+#[repr(simd)]
+pub struct i16x8([i16; 8]);
+#[repr(simd)]
+pub struct i32x4([i32; 4]);
+#[repr(simd)]
+pub struct i64x2([i64; 2]);
+#[repr(simd)]
+pub struct f16x8([f16; 8]);
+#[repr(simd)]
+pub struct f32x4([f32; 4]);
+#[repr(simd)]
+pub struct f64x2([f64; 2]);
+
+impl Copy for i8x8 {}
+impl Copy for i16x4 {}
+impl Copy for i32x2 {}
+impl Copy for i64x1 {}
+impl Copy for f16x4 {}
+impl Copy for f32x2 {}
+impl Copy for f64x1 {}
+impl Copy for i8x16 {}
+impl Copy for i16x8 {}
+impl Copy for i32x4 {}
+impl Copy for i64x2 {}
+impl Copy for f16x8 {}
+impl Copy for f32x4 {}
+impl Copy for f64x2 {}
+
+extern "C" {
+    fn extern_func();
+    static extern_static: u8;
+}
+
+// CHECK-LABEL: {{("#)?}}sym_fn{{"?}}
+// CHECK: //APP
+// CHECK: bl extern_func
+// CHECK: //NO_APP
+#[no_mangle]
+pub unsafe fn sym_fn() {
+    asm!("bl {}", sym extern_func);
+}
+
+// CHECK-LABEL: {{("#)?}}sym_static{{"?}}
+// CHECK: //APP
+// CHECK: adr x0, extern_static
+// CHECK: //NO_APP
+#[no_mangle]
+pub unsafe fn sym_static() {
+    asm!("adr x0, {}", sym extern_static);
+}
+
+// Regression test for #75761
+// CHECK-LABEL: {{("#)?}}issue_75761{{"?}}
+// x29 holds the frame pointer, right next to x30, so ldp/stp happens sometimes
+// CHECK: st[[MAY_PAIR:(r|p).*]]x30
+// CHECK: //APP
+// CHECK: //NO_APP
+// CHECK: ld[[MAY_PAIR]]x30
+#[no_mangle]
+pub unsafe fn issue_75761() {
+    asm!("", out("v0") _, out("x30") _);
+}
+
+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.
+        // LLVM issue: <https://github.com/llvm/llvm-project/issues/94434>
+        #[no_mangle]
+        pub unsafe fn $func(inp: &$ty, out: &mut $ty) {
+            let x = *inp;
+            let y;
+            asm!(
+                concat!($mov, " {:", $modifier, "}, {:", $modifier, "}"),
+                out($class) y,
+                in($class) x
+            );
+            *out = y;
+        }
+    };
+}
+
+macro_rules! check_reg {
+    ($func:ident $ty:ident $reg:tt $mov:literal) => {
+        // FIXME(f16_f128): See FIXME in `check!`
+        #[no_mangle]
+        pub unsafe fn $func(inp: &$ty, out: &mut $ty) {
+            let x = *inp;
+            let y;
+            asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
+            *out = y;
+        }
+    };
+}
+
+// CHECK-LABEL: {{("#)?}}reg_i8{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check!(reg_i8 i8 reg "mov" "");
+
+// CHECK-LABEL: {{("#)?}}reg_i16{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check!(reg_i16 i16 reg "mov" "");
+
+// CHECK-LABEL: {{("#)?}}reg_f16{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check!(reg_f16 f16 reg "mov" "");
+
+// CHECK-LABEL: {{("#)?}}reg_i32{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check!(reg_i32 i32 reg "mov" "");
+
+// CHECK-LABEL: {{("#)?}}reg_f32{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check!(reg_f32 f32 reg "mov" "");
+
+// CHECK-LABEL: {{("#)?}}reg_i64{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check!(reg_i64 i64 reg "mov" "");
+
+// CHECK-LABEL: {{("#)?}}reg_f64{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check!(reg_f64 f64 reg "mov" "");
+
+// CHECK-LABEL: {{("#)?}}reg_ptr{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check!(reg_ptr ptr reg "mov" "");
+
+// CHECK-LABEL: {{("#)?}}vreg_i8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i8 i8 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_i16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i16 i16 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_f16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f16 f16 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_i32{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i32 i32 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_f32{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f32 f32 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_i64{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i64 i64 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_f64{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f64 f64 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_f128{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f128 f128 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_ptr{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_ptr ptr vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_i8x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i8x8 i8x8 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_i16x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i16x4 i16x4 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_i32x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i32x2 i32x2 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_i64x1{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i64x1 i64x1 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_f16x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f16x4 f16x4 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_f32x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f32x2 f32x2 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_f64x1{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f64x1 f64x1 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_i8x16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i8x16 i8x16 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_i16x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i16x8 i16x8 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_i32x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i32x4 i32x4 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_i64x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_i64x2 i64x2 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_f16x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f16x8 f16x8 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_f32x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f32x4 f32x4 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_f64x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f64x2 f64x2 vreg "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_i8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_i8 i8 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_i16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_i16 i16 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_f16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f16 f16 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_f32{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f32 f32 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_i64{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_i64 i64 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_f64{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f64 f64 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_f128{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f128 f128 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_ptr{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_ptr ptr vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_i8x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_i8x8 i8x8 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_i16x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_i16x4 i16x4 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_i32x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_i32x2 i32x2 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_i64x1{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_i64x1 i64x1 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_f16x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f16x4 f16x4 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_f32x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f32x2 f32x2 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_f64x1{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f64x1 f64x1 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_i8x16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_i8x16 i8x16 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_i16x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_i16x8 i16x8 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_i32x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_i32x4 i32x4 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_i64x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_i64x2 i64x2 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_f16x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f16x8 f16x8 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_f32x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f32x4 f32x4 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}vreg_low16_f64x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f64x2 f64x2 vreg_low16 "fmov" "s");
+
+// CHECK-LABEL: {{("#)?}}x0_i8{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check_reg!(x0_i8 i8 "x0" "mov");
+
+// CHECK-LABEL: {{("#)?}}x0_i16{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check_reg!(x0_i16 i16 "x0" "mov");
+
+// CHECK-LABEL: {{("#)?}}x0_f16{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check_reg!(x0_f16 f16 "x0" "mov");
+
+// CHECK-LABEL: {{("#)?}}x0_i32{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check_reg!(x0_i32 i32 "x0" "mov");
+
+// CHECK-LABEL: {{("#)?}}x0_f32{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check_reg!(x0_f32 f32 "x0" "mov");
+
+// CHECK-LABEL: {{("#)?}}x0_i64{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check_reg!(x0_i64 i64 "x0" "mov");
+
+// CHECK-LABEL: {{("#)?}}x0_f64{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check_reg!(x0_f64 f64 "x0" "mov");
+
+// CHECK-LABEL: {{("#)?}}x0_ptr{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check_reg!(x0_ptr ptr "x0" "mov");
+
+// CHECK-LABEL: {{("#)?}}v0_i8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i8 i8 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_i16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i16 i16 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_f16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f16 f16 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_i32{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i32 i32 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_f32{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f32 f32 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_i64{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i64 i64 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_f64{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f64 f64 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_f128{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f128 f128 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_ptr{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_ptr ptr "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_i8x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i8x8 i8x8 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_i16x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i16x4 i16x4 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_i32x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i32x2 i32x2 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_i64x1{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i64x1 i64x1 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_f16x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f16x4 f16x4 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_f32x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f32x2 f32x2 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_f64x1{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f64x1 f64x1 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_i8x16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i8x16 i8x16 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_i16x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i16x8 i16x8 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_i32x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i32x4 i32x4 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_i64x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_i64x2 i64x2 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_f16x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f16x8 f16x8 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_f32x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f32x4 f32x4 "s0" "fmov");
+
+// CHECK-LABEL: {{("#)?}}v0_f64x2{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f64x2 f64x2 "s0" "fmov");
diff --git a/tests/assembly-llvm/asm/arm-modifiers.rs b/tests/assembly-llvm/asm/arm-modifiers.rs
new file mode 100644
index 00000000000..32a36840492
--- /dev/null
+++ b/tests/assembly-llvm/asm/arm-modifiers.rs
@@ -0,0 +1,122 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3 -C panic=abort
+//@ compile-flags: --target armv7-unknown-linux-gnueabihf
+//@ compile-flags: -C target-feature=+neon
+//@ compile-flags: -Zmerge-functions=disabled
+//@ needs-llvm-components: arm
+
+#![feature(no_core, repr_simd)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register, non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(simd)]
+pub struct f32x4([f32; 4]);
+
+impl Copy for f32x4 {}
+
+macro_rules! check {
+    ($func:ident $modifier:literal $reg:ident $ty:ident $mov:literal) => {
+        // -Copt-level=3 and extern "C" guarantee that the selected register is always r0/s0/d0/q0
+        #[no_mangle]
+        pub unsafe extern "C" fn $func() -> $ty {
+            let y;
+            asm!(concat!($mov, " {0:", $modifier, "}, {0:", $modifier, "}"), out($reg) y);
+            y
+        }
+    };
+}
+
+// CHECK-LABEL: reg:
+// CHECK: @APP
+// CHECK: mov r0, r0
+// CHECK: @NO_APP
+check!(reg "" reg i32 "mov");
+
+// CHECK-LABEL: sreg:
+// CHECK: @APP
+// CHECK: vmov.f32 s0, s0
+// CHECK: @NO_APP
+check!(sreg "" sreg f32 "vmov.f32");
+
+// CHECK-LABEL: sreg_low16:
+// CHECK: @APP
+// CHECK: vmov.f32 s0, s0
+// CHECK: @NO_APP
+check!(sreg_low16 "" sreg_low16 f32 "vmov.f32");
+
+// CHECK-LABEL: dreg:
+// CHECK: @APP
+// CHECK: vmov.f64 d0, d0
+// CHECK: @NO_APP
+check!(dreg "" dreg f64 "vmov.f64");
+
+// CHECK-LABEL: dreg_low16:
+// CHECK: @APP
+// CHECK: vmov.f64 d0, d0
+// CHECK: @NO_APP
+check!(dreg_low16 "" dreg_low16 f64 "vmov.f64");
+
+// CHECK-LABEL: dreg_low8:
+// CHECK: @APP
+// CHECK: vmov.f64 d0, d0
+// CHECK: @NO_APP
+check!(dreg_low8 "" dreg_low8 f64 "vmov.f64");
+
+// CHECK-LABEL: qreg:
+// CHECK: @APP
+// CHECK: vorr q0, q0, q0
+// CHECK: @NO_APP
+check!(qreg "" qreg f32x4 "vmov");
+
+// CHECK-LABEL: qreg_e:
+// CHECK: @APP
+// CHECK: vmov.f64 d0, d0
+// CHECK: @NO_APP
+check!(qreg_e "e" qreg f32x4 "vmov.f64");
+
+// CHECK-LABEL: qreg_f:
+// CHECK: @APP
+// CHECK: vmov.f64 d1, d1
+// CHECK: @NO_APP
+check!(qreg_f "f" qreg f32x4 "vmov.f64");
+
+// CHECK-LABEL: qreg_low8:
+// CHECK: @APP
+// CHECK: vorr q0, q0, q0
+// CHECK: @NO_APP
+check!(qreg_low8 "" qreg_low8 f32x4 "vmov");
+
+// CHECK-LABEL: qreg_low8_e:
+// CHECK: @APP
+// CHECK: vmov.f64 d0, d0
+// CHECK: @NO_APP
+check!(qreg_low8_e "e" qreg_low8 f32x4 "vmov.f64");
+
+// CHECK-LABEL: qreg_low8_f:
+// CHECK: @APP
+// CHECK: vmov.f64 d1, d1
+// CHECK: @NO_APP
+check!(qreg_low8_f "f" qreg_low8 f32x4 "vmov.f64");
+
+// CHECK-LABEL: qreg_low4:
+// CHECK: @APP
+// CHECK: vorr q0, q0, q0
+// CHECK: @NO_APP
+check!(qreg_low4 "" qreg_low4 f32x4 "vmov");
+
+// CHECK-LABEL: qreg_low4_e:
+// CHECK: @APP
+// CHECK: vmov.f64 d0, d0
+// CHECK: @NO_APP
+check!(qreg_low4_e "e" qreg_low4 f32x4 "vmov.f64");
+
+// CHECK-LABEL: qreg_low4_f:
+// CHECK: @APP
+// CHECK: vmov.f64 d1, d1
+// CHECK: @NO_APP
+check!(qreg_low4_f "f" qreg_low4 f32x4 "vmov.f64");
diff --git a/tests/assembly-llvm/asm/arm-types.rs b/tests/assembly-llvm/asm/arm-types.rs
new file mode 100644
index 00000000000..fb93f474c20
--- /dev/null
+++ b/tests/assembly-llvm/asm/arm-types.rs
@@ -0,0 +1,639 @@
+//@ add-core-stubs
+//@ revisions: base d32 neon
+//@ assembly-output: emit-asm
+//@ compile-flags: --target armv7-unknown-linux-gnueabihf
+//@ compile-flags: -C opt-level=0
+//@ compile-flags: -Zmerge-functions=disabled
+//@[d32] compile-flags: -C target-feature=+d32
+//@[neon] compile-flags: -C target-feature=+neon --cfg d32
+//@[neon] filecheck-flags: --check-prefix d32
+//@ needs-llvm-components: arm
+
+#![feature(no_core, repr_simd, f16)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register, non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *mut u8;
+
+#[repr(simd)]
+pub struct i8x8([i8; 8]);
+#[repr(simd)]
+pub struct i16x4([i16; 4]);
+#[repr(simd)]
+pub struct i32x2([i32; 2]);
+#[repr(simd)]
+pub struct i64x1([i64; 1]);
+#[repr(simd)]
+pub struct f16x4([f16; 4]);
+#[repr(simd)]
+pub struct f32x2([f32; 2]);
+#[repr(simd)]
+pub struct i8x16([i8; 16]);
+#[repr(simd)]
+pub struct i16x8([i16; 8]);
+#[repr(simd)]
+pub struct i32x4([i32; 4]);
+#[repr(simd)]
+pub struct i64x2([i64; 2]);
+#[repr(simd)]
+pub struct f16x8([f16; 8]);
+#[repr(simd)]
+pub struct f32x4([f32; 4]);
+
+impl Copy for i8x8 {}
+impl Copy for i16x4 {}
+impl Copy for i32x2 {}
+impl Copy for i64x1 {}
+impl Copy for f16x4 {}
+impl Copy for f32x2 {}
+impl Copy for i8x16 {}
+impl Copy for i16x8 {}
+impl Copy for i32x4 {}
+impl Copy for i64x2 {}
+impl Copy for f16x8 {}
+impl Copy for f32x4 {}
+
+extern "C" {
+    fn extern_func();
+    static extern_static: u8;
+}
+
+// CHECK-LABEL: sym_fn:
+// CHECK: @APP
+// CHECK: bl extern_func
+// CHECK: @NO_APP
+#[no_mangle]
+pub unsafe fn sym_fn() {
+    asm!("bl {}", sym extern_func);
+}
+
+// CHECK-LABEL: sym_static:
+// CHECK: @APP
+// CHECK: adr r0, extern_static
+// CHECK: @NO_APP
+#[no_mangle]
+pub unsafe fn sym_static() {
+    asm!("adr r0, {}", sym extern_static);
+}
+
+// Regression test for #82052.
+// CHECK-LABEL: issue_82052
+// CHECK: push {{.*}}lr
+// CHECK: @APP
+// CHECK: @NO_APP
+pub unsafe fn issue_82052() {
+    asm!("", out("r14") _);
+}
+
+macro_rules! check {
+    ($func:ident $ty:ident $class:ident $mov:literal) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!($mov, " {}, {}"), out($class) y, in($class) x);
+            y
+        }
+    };
+}
+
+macro_rules! check_reg {
+    ($func:ident $ty:ident $reg:tt $mov:literal) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
+            y
+        }
+    };
+}
+
+// CHECK-LABEL: reg_i8:
+// CHECK: @APP
+// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: @NO_APP
+check!(reg_i8 i8 reg "mov");
+
+// CHECK-LABEL: reg_i16:
+// CHECK: @APP
+// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: @NO_APP
+check!(reg_i16 i16 reg "mov");
+
+// CHECK-LABEL: reg_i32:
+// CHECK: @APP
+// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: @NO_APP
+check!(reg_i32 i32 reg "mov");
+
+// CHECK-LABEL: reg_f16:
+// CHECK: @APP
+// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: @NO_APP
+check!(reg_f16 f16 reg "mov");
+
+// CHECK-LABEL: reg_f32:
+// CHECK: @APP
+// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: @NO_APP
+check!(reg_f32 f32 reg "mov");
+
+// CHECK-LABEL: reg_ptr:
+// CHECK: @APP
+// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: @NO_APP
+check!(reg_ptr ptr reg "mov");
+
+// CHECK-LABEL: sreg_i32:
+// CHECK: @APP
+// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: @NO_APP
+check!(sreg_i32 i32 sreg "vmov.f32");
+
+// CHECK-LABEL: sreg_f16:
+// CHECK: @APP
+// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: @NO_APP
+check!(sreg_f16 f16 sreg "vmov.f32");
+
+// CHECK-LABEL: sreg_f32:
+// CHECK: @APP
+// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: @NO_APP
+check!(sreg_f32 f32 sreg "vmov.f32");
+
+// CHECK-LABEL: sreg_ptr:
+// CHECK: @APP
+// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: @NO_APP
+check!(sreg_ptr ptr sreg "vmov.f32");
+
+// CHECK-LABEL: sreg_low16_i32:
+// CHECK: @APP
+// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: @NO_APP
+check!(sreg_low16_i32 i32 sreg_low16 "vmov.f32");
+
+// CHECK-LABEL: sreg_low16_f16:
+// CHECK: @APP
+// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: @NO_APP
+check!(sreg_low16_f16 f16 sreg_low16 "vmov.f32");
+
+// CHECK-LABEL: sreg_low16_f32:
+// CHECK: @APP
+// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: @NO_APP
+check!(sreg_low16_f32 f32 sreg_low16 "vmov.f32");
+
+// d32-LABEL: dreg_i64:
+// d32: @APP
+// d32: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// d32: @NO_APP
+#[cfg(d32)]
+check!(dreg_i64 i64 dreg "vmov.f64");
+
+// d32-LABEL: dreg_f64:
+// d32: @APP
+// d32: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// d32: @NO_APP
+#[cfg(d32)]
+check!(dreg_f64 f64 dreg "vmov.f64");
+
+// neon-LABEL: dreg_i8x8:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_i8x8 i8x8 dreg "vmov.f64");
+
+// neon-LABEL: dreg_i16x4:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_i16x4 i16x4 dreg "vmov.f64");
+
+// neon-LABEL: dreg_i32x2:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_i32x2 i32x2 dreg "vmov.f64");
+
+// neon-LABEL: dreg_i64x1:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_i64x1 i64x1 dreg "vmov.f64");
+
+// neon-LABEL: dreg_f16x4:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_f16x4 f16x4 dreg "vmov.f64");
+
+// neon-LABEL: dreg_f32x2:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_f32x2 f32x2 dreg "vmov.f64");
+
+// CHECK-LABEL: dreg_low16_i64:
+// CHECK: @APP
+// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// CHECK: @NO_APP
+check!(dreg_low16_i64 i64 dreg_low16 "vmov.f64");
+
+// CHECK-LABEL: dreg_low16_f64:
+// CHECK: @APP
+// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// CHECK: @NO_APP
+check!(dreg_low16_f64 f64 dreg_low16 "vmov.f64");
+
+// neon-LABEL: dreg_low16_i8x8:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low16_i8x8 i8x8 dreg_low16 "vmov.f64");
+
+// neon-LABEL: dreg_low16_i16x4:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low16_i16x4 i16x4 dreg_low16 "vmov.f64");
+
+// neon-LABEL: dreg_low16_i32x2:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low16_i32x2 i32x2 dreg_low16 "vmov.f64");
+
+// neon-LABEL: dreg_low16_i64x1:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low16_i64x1 i64x1 dreg_low16 "vmov.f64");
+
+// neon-LABEL: dreg_low16_f16x4:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low16_f16x4 f16x4 dreg_low16 "vmov.f64");
+
+// neon-LABEL: dreg_low16_f32x2:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low16_f32x2 f32x2 dreg_low16 "vmov.f64");
+
+// CHECK-LABEL: dreg_low8_i64:
+// CHECK: @APP
+// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// CHECK: @NO_APP
+check!(dreg_low8_i64 i64 dreg_low8 "vmov.f64");
+
+// CHECK-LABEL: dreg_low8_f64:
+// CHECK: @APP
+// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// CHECK: @NO_APP
+check!(dreg_low8_f64 f64 dreg_low8 "vmov.f64");
+
+// neon-LABEL: dreg_low8_i8x8:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low8_i8x8 i8x8 dreg_low8 "vmov.f64");
+
+// neon-LABEL: dreg_low8_i16x4:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low8_i16x4 i16x4 dreg_low8 "vmov.f64");
+
+// neon-LABEL: dreg_low8_i32x2:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low8_i32x2 i32x2 dreg_low8 "vmov.f64");
+
+// neon-LABEL: dreg_low8_i64x1:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low8_i64x1 i64x1 dreg_low8 "vmov.f64");
+
+// neon-LABEL: dreg_low8_f16x4:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low8_f16x4 f16x4 dreg_low8 "vmov.f64");
+
+// neon-LABEL: dreg_low8_f32x2:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(dreg_low8_f32x2 f32x2 dreg_low8 "vmov.f64");
+
+// neon-LABEL: qreg_i8x16:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_i8x16 i8x16 qreg "vmov");
+
+// neon-LABEL: qreg_i16x8:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_i16x8 i16x8 qreg "vmov");
+
+// neon-LABEL: qreg_i32x4:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_i32x4 i32x4 qreg "vmov");
+
+// neon-LABEL: qreg_i64x2:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_i64x2 i64x2 qreg "vmov");
+
+// neon-LABEL: qreg_f16x8:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_f16x8 f16x8 qreg "vmov");
+
+// neon-LABEL: qreg_f32x4:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_f32x4 f32x4 qreg "vmov");
+
+// neon-LABEL: qreg_low8_i8x16:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low8_i8x16 i8x16 qreg_low8 "vmov");
+
+// neon-LABEL: qreg_low8_i16x8:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low8_i16x8 i16x8 qreg_low8 "vmov");
+
+// neon-LABEL: qreg_low8_i32x4:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low8_i32x4 i32x4 qreg_low8 "vmov");
+
+// neon-LABEL: qreg_low8_i64x2:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low8_i64x2 i64x2 qreg_low8 "vmov");
+
+// neon-LABEL: qreg_low8_f16x8:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low8_f16x8 f16x8 qreg_low8 "vmov");
+
+// neon-LABEL: qreg_low8_f32x4:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low8_f32x4 f32x4 qreg_low8 "vmov");
+
+// neon-LABEL: qreg_low4_i8x16:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low4_i8x16 i8x16 qreg_low4 "vmov");
+
+// neon-LABEL: qreg_low4_i16x8:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low4_i16x8 i16x8 qreg_low4 "vmov");
+
+// neon-LABEL: qreg_low4_i32x4:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low4_i32x4 i32x4 qreg_low4 "vmov");
+
+// neon-LABEL: qreg_low4_i64x2:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low4_i64x2 i64x2 qreg_low4 "vmov");
+
+// neon-LABEL: qreg_low4_f16x8:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low4_f16x8 f16x8 qreg_low4 "vmov");
+
+// neon-LABEL: qreg_low4_f32x4:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(qreg_low4_f32x4 f32x4 qreg_low4 "vmov");
+
+// CHECK-LABEL: r0_i8:
+// CHECK: @APP
+// CHECK: mov r0, r0
+// CHECK: @NO_APP
+check_reg!(r0_i8 i8 "r0" "mov");
+
+// CHECK-LABEL: r0_i16:
+// CHECK: @APP
+// CHECK: mov r0, r0
+// CHECK: @NO_APP
+check_reg!(r0_i16 i16 "r0" "mov");
+
+// CHECK-LABEL: r0_i32:
+// CHECK: @APP
+// CHECK: mov r0, r0
+// CHECK: @NO_APP
+check_reg!(r0_i32 i32 "r0" "mov");
+
+// CHECK-LABEL: r0_f16:
+// CHECK: @APP
+// CHECK: mov r0, r0
+// CHECK: @NO_APP
+check_reg!(r0_f16 f16 "r0" "mov");
+
+// CHECK-LABEL: r0_f32:
+// CHECK: @APP
+// CHECK: mov r0, r0
+// CHECK: @NO_APP
+check_reg!(r0_f32 f32 "r0" "mov");
+
+// CHECK-LABEL: r0_ptr:
+// CHECK: @APP
+// CHECK: mov r0, r0
+// CHECK: @NO_APP
+check_reg!(r0_ptr ptr "r0" "mov");
+
+// CHECK-LABEL: s0_i32:
+// CHECK: @APP
+// CHECK: vmov.f32 s0, s0
+// CHECK: @NO_APP
+check_reg!(s0_i32 i32 "s0" "vmov.f32");
+
+// CHECK-LABEL: s0_f16:
+// CHECK: @APP
+// CHECK: vmov.f32 s0, s0
+// CHECK: @NO_APP
+check_reg!(s0_f16 f16 "s0" "vmov.f32");
+
+// CHECK-LABEL: s0_f32:
+// CHECK: @APP
+// CHECK: vmov.f32 s0, s0
+// CHECK: @NO_APP
+check_reg!(s0_f32 f32 "s0" "vmov.f32");
+
+// CHECK-LABEL: s0_ptr:
+// CHECK: @APP
+// CHECK: vmov.f32 s0, s0
+// CHECK: @NO_APP
+check_reg!(s0_ptr ptr "s0" "vmov.f32");
+
+// FIXME(#126797): "d0" should work with `i64` and `f64` even when `d32` is disabled.
+// d32-LABEL: d0_i64:
+// d32: @APP
+// d32: vmov.f64 d0, d0
+// d32: @NO_APP
+#[cfg(d32)]
+check_reg!(d0_i64 i64 "d0" "vmov.f64");
+
+// d32-LABEL: d0_f64:
+// d32: @APP
+// d32: vmov.f64 d0, d0
+// d32: @NO_APP
+#[cfg(d32)]
+check_reg!(d0_f64 f64 "d0" "vmov.f64");
+
+// neon-LABEL: d0_i8x8:
+// neon: @APP
+// neon: vmov.f64 d0, d0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(d0_i8x8 i8x8 "d0" "vmov.f64");
+
+// neon-LABEL: d0_i16x4:
+// neon: @APP
+// neon: vmov.f64 d0, d0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(d0_i16x4 i16x4 "d0" "vmov.f64");
+
+// neon-LABEL: d0_i32x2:
+// neon: @APP
+// neon: vmov.f64 d0, d0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(d0_i32x2 i32x2 "d0" "vmov.f64");
+
+// neon-LABEL: d0_i64x1:
+// neon: @APP
+// neon: vmov.f64 d0, d0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(d0_i64x1 i64x1 "d0" "vmov.f64");
+
+// neon-LABEL: d0_f16x4:
+// neon: @APP
+// neon: vmov.f64 d0, d0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(d0_f16x4 f16x4 "d0" "vmov.f64");
+
+// neon-LABEL: d0_f32x2:
+// neon: @APP
+// neon: vmov.f64 d0, d0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(d0_f32x2 f32x2 "d0" "vmov.f64");
+
+// neon-LABEL: q0_i8x16:
+// neon: @APP
+// neon: vorr q0, q0, q0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(q0_i8x16 i8x16 "q0" "vmov");
+
+// neon-LABEL: q0_i16x8:
+// neon: @APP
+// neon: vorr q0, q0, q0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(q0_i16x8 i16x8 "q0" "vmov");
+
+// neon-LABEL: q0_i32x4:
+// neon: @APP
+// neon: vorr q0, q0, q0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(q0_i32x4 i32x4 "q0" "vmov");
+
+// neon-LABEL: q0_i64x2:
+// neon: @APP
+// neon: vorr q0, q0, q0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(q0_i64x2 i64x2 "q0" "vmov");
+
+// neon-LABEL: q0_f16x8:
+// neon: @APP
+// neon: vorr q0, q0, q0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(q0_f16x8 f16x8 "q0" "vmov");
+
+// neon-LABEL: q0_f32x4:
+// neon: @APP
+// neon: vorr q0, q0, q0
+// neon: @NO_APP
+#[cfg(neon)]
+check_reg!(q0_f32x4 f32x4 "q0" "vmov");
diff --git a/tests/assembly-llvm/asm/avr-modifiers.rs b/tests/assembly-llvm/asm/avr-modifiers.rs
new file mode 100644
index 00000000000..124cad9bef6
--- /dev/null
+++ b/tests/assembly-llvm/asm/avr-modifiers.rs
@@ -0,0 +1,43 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target avr-none -C target-cpu=atmega328p
+//@ needs-llvm-components: avr
+
+#![feature(no_core, asm_experimental_arch)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *const u64;
+
+macro_rules! check {
+    ($func:ident $hi:literal $lo:literal $reg:tt) => {
+        #[no_mangle]
+        unsafe fn $func() -> i16 {
+            let y;
+            asm!(concat!("mov {0:", $hi, "}, {0:", $lo, "}"), out($reg) y);
+            y
+        }
+    };
+}
+
+// CHECK-LABEL: reg_pair_modifiers:
+// CHECK: ;APP
+// CHECK: mov r{{[1-9]?[13579]}}, r{{[1-9]?[24680]}}
+// CHECK: ;NO_APP
+check!(reg_pair_modifiers "h" "l" reg_pair);
+
+// CHECK-LABEL: reg_iw_modifiers:
+// CHECK: ;APP
+// CHECK: mov r{{[1-9]?[13579]}}, r{{[1-9]?[24680]}}
+// CHECK: ;NO_APP
+check!(reg_iw_modifiers "h" "l" reg_iw);
+
+// CHECK-LABEL: reg_ptr_modifiers:
+// CHECK: ;APP
+// CHECK: mov r{{[1-9]?[13579]}}, r{{[1-9]?[24680]}}
+// CHECK: ;NO_APP
+check!(reg_ptr_modifiers "h" "l" reg_ptr);
diff --git a/tests/assembly-llvm/asm/avr-types.rs b/tests/assembly-llvm/asm/avr-types.rs
new file mode 100644
index 00000000000..309405f4d51
--- /dev/null
+++ b/tests/assembly-llvm/asm/avr-types.rs
@@ -0,0 +1,205 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target avr-none -C target-cpu=atmega328p
+//@ needs-llvm-components: avr
+
+#![feature(no_core, asm_experimental_arch)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *const u64;
+
+macro_rules! check {
+    ($func:ident $ty:ident $class:ident) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!("mov {}, {}", lateout($class) y, in($class) x);
+            y
+        }
+    };
+}
+
+macro_rules! checkw {
+    ($func:ident $ty:ident $class:ident) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!("movw {}, {}", lateout($class) y, in($class) x);
+            y
+        }
+    };
+}
+
+macro_rules! check_reg {
+    ($func:ident $ty:ident $reg:tt) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!("mov ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
+            y
+        }
+    };
+}
+
+macro_rules! check_regw {
+    ($func:ident $ty:ident $reg:tt $reg_lit:tt) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!("movw ", $reg_lit, ", ", $reg_lit), lateout($reg) y, in($reg) x);
+            y
+        }
+    };
+}
+
+extern "C" {
+    fn extern_func();
+    static extern_static: i8;
+}
+
+// CHECK-LABEL: sym_fn
+// CHECK: ;APP
+// CHECK: call extern_func
+// CHECK: ;NO_APP
+#[no_mangle]
+pub unsafe fn sym_fn() {
+    asm!("call {}", sym extern_func);
+}
+
+// CHECK-LABEL: sym_static
+// CHECK: ;APP
+// CHECK: lds r{{[0-9]+}}, extern_static
+// CHECK: ;NO_APP
+#[no_mangle]
+pub unsafe fn sym_static() -> i8 {
+    let y;
+    asm!("lds {}, {}", lateout(reg) y, sym extern_static);
+    y
+}
+
+// CHECK-LABEL: ld_z:
+// CHECK: ;APP
+// CHECK: ld r{{[0-9]+}}, Z
+// CHECK: ;NO_APP
+#[no_mangle]
+pub unsafe fn ld_z(x: i16) -> i8 {
+    let y;
+    asm!("ld {}, Z", out(reg) y, in("Z") x);
+    y
+}
+
+// CHECK-LABEL: ldd_z:
+// CHECK: ;APP
+// CHECK: ldd r{{[0-9]+}}, Z+4
+// CHECK: ;NO_APP
+#[no_mangle]
+pub unsafe fn ldd_z(x: i16) -> i8 {
+    let y;
+    asm!("ldd {}, Z+4", out(reg) y, in("Z") x);
+    y
+}
+
+// CHECK-LABEL: ld_predecrement:
+// CHECK: ;APP
+// CHECK: ld r{{[0-9]+}}, -Z
+// CHECK: ;NO_APP
+#[no_mangle]
+pub unsafe fn ld_predecrement(x: i16) -> i8 {
+    let y;
+    asm!("ld {}, -Z", out(reg) y, in("Z") x);
+    y
+}
+
+// CHECK-LABEL: ld_postincrement:
+// CHECK: ;APP
+// CHECK: ld r{{[0-9]+}}, Z+
+// CHECK: ;NO_APP
+#[no_mangle]
+pub unsafe fn ld_postincrement(x: i16) -> i8 {
+    let y;
+    asm!("ld {}, Z+", out(reg) y, in("Z") x);
+    y
+}
+
+// CHECK-LABEL: muls_clobber:
+// CHECK: ;APP
+// CHECK: muls r{{[0-9]+}}, r{{[0-9]+}}
+// CHECK: movw r{{[0-9]+}}, r0
+// CHECK: ;NO_APP
+#[no_mangle]
+pub unsafe fn muls_clobber(x: i8, y: i8) -> i16 {
+    let z;
+    asm!(
+        "muls {}, {}",
+        "movw {}, r1:r0",
+        out(reg_iw) z,
+        in(reg) x,
+        in(reg) y,
+    );
+    z
+}
+
+// CHECK-LABEL: reg_i8:
+// CHECK: ;APP
+// CHECK: mov r{{[0-9]+}}, r{{[0-9]+}}
+// CHECK: ;NO_APP
+check!(reg_i8 i8 reg);
+
+// CHECK-LABEL: reg_upper_i8:
+// CHECK: ;APP
+// CHECK: mov r{{[1-3][0-9]}}, r{{[1-3][0-9]}}
+// CHECK: ;NO_APP
+check!(reg_upper_i8 i8 reg_upper);
+
+// CHECK-LABEL: reg_pair_i16:
+// CHECK: ;APP
+// CHECK: movw r{{[0-9]+}}, r{{[0-9]+}}
+// CHECK: ;NO_APP
+checkw!(reg_pair_i16 i16 reg_pair);
+
+// CHECK-LABEL: reg_iw_i16:
+// CHECK: ;APP
+// CHECK: movw r{{[0-9]+}}, r{{[0-9]+}}
+// CHECK: ;NO_APP
+checkw!(reg_iw_i16 i16 reg_iw);
+
+// CHECK-LABEL: reg_ptr_i16:
+// CHECK: ;APP
+// CHECK: movw r{{[0-9]+}}, r{{[0-9]+}}
+// CHECK: ;NO_APP
+checkw!(reg_ptr_i16 i16 reg_ptr);
+
+// CHECK-LABEL: r2_i8:
+// CHECK: ;APP
+// CHECK: mov r2, r2
+// CHECK: ;NO_APP
+check_reg!(r2_i8 i8 "r2");
+
+// CHECK-LABEL: xl_i8:
+// CHECK: ;APP
+// CHECK: mov r26, r26
+// CHECK: ;NO_APP
+check_reg!(xl_i8 i8 "XL");
+
+// CHECK-LABEL: xh_i8:
+// CHECK: ;APP
+// CHECK: mov r27, r27
+// CHECK: ;NO_APP
+check_reg!(xh_i8 i8 "XH");
+
+// CHECK-LABEL: x_i16:
+// CHECK: ;APP
+// CHECK: movw r26, r26
+// CHECK: ;NO_APP
+check_regw!(x_i16 i16 "X" "X");
+
+// CHECK-LABEL: r25r24_i16:
+// CHECK: ;APP
+// CHECK: movw r24, r24
+// CHECK: ;NO_APP
+check_regw!(r25r24_i16 i16 "r25r24" "r24");
diff --git a/tests/assembly-llvm/asm/bpf-types.rs b/tests/assembly-llvm/asm/bpf-types.rs
new file mode 100644
index 00000000000..07ea7bd5ce0
--- /dev/null
+++ b/tests/assembly-llvm/asm/bpf-types.rs
@@ -0,0 +1,133 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target bpfel-unknown-none -C target_feature=+alu32
+//@ needs-llvm-components: bpf
+
+#![feature(no_core, asm_experimental_arch)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register, non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *const u64;
+
+macro_rules! check {
+    ($func:ident $ty:ident $class:ident) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!("{} = {}", out($class) y, in($class) x);
+            y
+        }
+    };
+}
+
+macro_rules! check_reg {
+    ($func:ident $ty:ident $reg:tt) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!($reg, " = ", $reg), lateout($reg) y, in($reg) x);
+            y
+        }
+    };
+}
+
+extern "C" {
+    fn extern_func();
+}
+
+// CHECK-LABEL: sym_fn
+// CHECK: #APP
+// CHECK: call extern_func
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn sym_fn() {
+    asm!("call {}", sym extern_func);
+}
+
+// CHECK-LABEL: reg_i8:
+// CHECK: #APP
+// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i8 i8 reg);
+
+// CHECK-LABEL: reg_i16:
+// CHECK: #APP
+// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i16 i16 reg);
+
+// CHECK-LABEL: reg_i32:
+// CHECK: #APP
+// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i32 i32 reg);
+
+// CHECK-LABEL: reg_i64:
+// CHECK: #APP
+// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i64 i64 reg);
+
+// CHECK-LABEL: wreg_i8:
+// CHECK: #APP
+// CHECK: w{{[0-9]+}} = w{{[0-9]+}}
+// CHECK: #NO_APP
+check!(wreg_i8 i8 wreg);
+
+// CHECK-LABEL: wreg_i16:
+// CHECK: #APP
+// CHECK: w{{[0-9]+}} = w{{[0-9]+}}
+// CHECK: #NO_APP
+check!(wreg_i16 i16 wreg);
+
+// CHECK-LABEL: wreg_i32:
+// CHECK: #APP
+// CHECK: w{{[0-9]+}} = w{{[0-9]+}}
+// CHECK: #NO_APP
+check!(wreg_i32 i32 wreg);
+
+// CHECK-LABEL: r0_i8:
+// CHECK: #APP
+// CHECK: r0 = r0
+// CHECK: #NO_APP
+check_reg!(r0_i8 i8 "r0");
+
+// CHECK-LABEL: r0_i16:
+// CHECK: #APP
+// CHECK: r0 = r0
+// CHECK: #NO_APP
+check_reg!(r0_i16 i16 "r0");
+
+// CHECK-LABEL: r0_i32:
+// CHECK: #APP
+// CHECK: r0 = r0
+// CHECK: #NO_APP
+check_reg!(r0_i32 i32 "r0");
+
+// CHECK-LABEL: r0_i64:
+// CHECK: #APP
+// CHECK: r0 = r0
+// CHECK: #NO_APP
+check_reg!(r0_i64 i64 "r0");
+
+// CHECK-LABEL: w0_i8:
+// CHECK: #APP
+// CHECK: w0 = w0
+// CHECK: #NO_APP
+check_reg!(w0_i8 i8 "w0");
+
+// CHECK-LABEL: w0_i16:
+// CHECK: #APP
+// CHECK: w0 = w0
+// CHECK: #NO_APP
+check_reg!(w0_i16 i16 "w0");
+
+// CHECK-LABEL: w0_i32:
+// CHECK: #APP
+// CHECK: w0 = w0
+// CHECK: #NO_APP
+check_reg!(w0_i32 i32 "w0");
diff --git a/tests/assembly-llvm/asm/comments.rs b/tests/assembly-llvm/asm/comments.rs
new file mode 100644
index 00000000000..557009975dd
--- /dev/null
+++ b/tests/assembly-llvm/asm/comments.rs
@@ -0,0 +1,12 @@
+//@ assembly-output: emit-asm
+//@ only-x86_64
+// Check that comments in assembly get passed
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: test_comments:
+#[no_mangle]
+pub fn test_comments() {
+    // CHECK: example comment
+    unsafe { core::arch::asm!("nop // example comment") };
+}
diff --git a/tests/assembly-llvm/asm/global_asm.rs b/tests/assembly-llvm/asm/global_asm.rs
new file mode 100644
index 00000000000..8a4bf98c745
--- /dev/null
+++ b/tests/assembly-llvm/asm/global_asm.rs
@@ -0,0 +1,32 @@
+//@ only-x86_64
+//@ only-linux
+//@ assembly-output: emit-asm
+//@ compile-flags: -C llvm-args=--x86-asm-syntax=intel
+//@ compile-flags: -C symbol-mangling-version=v0
+
+#![crate_type = "rlib"]
+
+use std::arch::global_asm;
+
+#[no_mangle]
+fn my_func() {}
+
+#[no_mangle]
+static MY_STATIC: i32 = 0;
+
+// CHECK: mov eax, eax
+global_asm!("mov eax, eax");
+// CHECK: mov ebx, 5
+global_asm!("mov ebx, {}", const 5);
+// CHECK: mov ecx, 5
+global_asm!("movl ${}, %ecx", const 5, options(att_syntax));
+// CHECK: call my_func
+global_asm!("call {}", sym my_func);
+// CHECK: lea rax, [rip + MY_STATIC]
+global_asm!("lea rax, [rip + {}]", sym MY_STATIC);
+// CHECK: call _RNvC[[CRATE_IDENT:[a-zA-Z0-9]{12}]]_10global_asm6foobar
+global_asm!("call {}", sym foobar);
+// CHECK: _RNvC[[CRATE_IDENT]]_10global_asm6foobar:
+fn foobar() {
+    loop {}
+}
diff --git a/tests/assembly-llvm/asm/hexagon-types.rs b/tests/assembly-llvm/asm/hexagon-types.rs
new file mode 100644
index 00000000000..ce80fa75b35
--- /dev/null
+++ b/tests/assembly-llvm/asm/hexagon-types.rs
@@ -0,0 +1,139 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target hexagon-unknown-linux-musl
+//@ compile-flags: -Zmerge-functions=disabled
+//@ needs-llvm-components: hexagon
+
+#![feature(no_core, asm_experimental_arch)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register, non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *const i32;
+
+extern "C" {
+    fn extern_func();
+    static extern_static: u8;
+}
+
+macro_rules! check {
+    ($func:ident $ty:ident $class:ident) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!("{} = {}", out($class) y, in($class) x);
+            y
+        }
+    };
+}
+
+macro_rules! check_reg {
+    ($func:ident $ty:ident $reg:tt) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!($reg, " = ", $reg), lateout($reg) y, in($reg) x);
+            y
+        }
+    };
+}
+
+// CHECK-LABEL: sym_static:
+// CHECK: InlineAsm Start
+// CHECK: r0 = {{#+}}extern_static
+// CHECK: InlineAsm End
+#[no_mangle]
+pub unsafe fn sym_static() {
+    asm!("r0 = #{}", sym extern_static);
+}
+
+// CHECK-LABEL: sym_fn:
+// CHECK: InlineAsm Start
+// CHECK: r0 = {{#+}}extern_func
+// CHECK: InlineAsm End
+#[no_mangle]
+pub unsafe fn sym_fn() {
+    asm!("r0 = #{}", sym extern_func);
+}
+
+// This is a test for multi-instruction packets,
+// which require the escaped braces.
+//
+// CHECK-LABEL: packet:
+// CHECK: InlineAsm Start
+// CHECK: {
+// CHECK:   r{{[0-9]+}} = r0
+// CHECK:   memw(r1{{(\+#0)?}}) = r{{[0-9]+}}
+// CHECK: }
+// CHECK: InlineAsm End
+#[no_mangle]
+pub unsafe fn packet() {
+    let val = 1024;
+    asm!("{{
+        {} = r0
+        memw(r1) = {}
+    }}", out(reg) _, in(reg) &val);
+}
+
+// CHECK-LABEL: reg_ptr:
+// CHECK: InlineAsm Start
+// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
+// CHECK: InlineAsm End
+check!(reg_ptr ptr reg);
+
+// CHECK-LABEL: reg_f32:
+// CHECK: InlineAsm Start
+// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
+// CHECK: InlineAsm End
+check!(reg_f32 f32 reg);
+
+// CHECK-LABEL: reg_i32:
+// CHECK: InlineAsm Start
+// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
+// CHECK: InlineAsm End
+check!(reg_i32 i32 reg);
+
+// CHECK-LABEL: reg_i8:
+// CHECK: InlineAsm Start
+// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
+// CHECK: InlineAsm End
+check!(reg_i8 i8 reg);
+
+// CHECK-LABEL: reg_i16:
+// CHECK: InlineAsm Start
+// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
+// CHECK: InlineAsm End
+check!(reg_i16 i16 reg);
+
+// CHECK-LABEL: r0_ptr:
+// CHECK: InlineAsm Start
+// CHECK: r0 = r0
+// CHECK: InlineAsm End
+check_reg!(r0_ptr ptr "r0");
+
+// CHECK-LABEL: r0_f32:
+// CHECK: InlineAsm Start
+// CHECK: r0 = r0
+// CHECK: InlineAsm End
+check_reg!(r0_f32 f32 "r0");
+
+// CHECK-LABEL: r0_i32:
+// CHECK: InlineAsm Start
+// CHECK: r0 = r0
+// CHECK: InlineAsm End
+check_reg!(r0_i32 i32 "r0");
+
+// CHECK-LABEL: r0_i8:
+// CHECK: InlineAsm Start
+// CHECK: r0 = r0
+// CHECK: InlineAsm End
+check_reg!(r0_i8 i8 "r0");
+
+// CHECK-LABEL: r0_i16:
+// CHECK: InlineAsm Start
+// CHECK: r0 = r0
+// CHECK: InlineAsm End
+check_reg!(r0_i16 i16 "r0");
diff --git a/tests/assembly-llvm/asm/inline-asm-avx.rs b/tests/assembly-llvm/asm/inline-asm-avx.rs
new file mode 100644
index 00000000000..630acbb971a
--- /dev/null
+++ b/tests/assembly-llvm/asm/inline-asm-avx.rs
@@ -0,0 +1,25 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib
+//@ only-x86_64
+//@ ignore-sgx
+
+#![feature(portable_simd)]
+
+use std::arch::asm;
+use std::simd::Simd;
+
+#[target_feature(enable = "avx")]
+#[no_mangle]
+// CHECK-LABEL: convert:
+pub unsafe fn convert(a: *const f32) -> Simd<f32, 8> {
+    // CHECK: vbroadcastss (%{{[er][a-ds0-9][xpi0-9]?}}), {{%ymm[0-7]}}
+    let b: Simd<f32, 8>;
+    unsafe {
+        asm!(
+            "vbroadcastss {b}, [{a}]",
+            a = in(reg) a,
+            b = out(ymm_reg) b,
+        );
+    }
+    b
+}
diff --git a/tests/assembly-llvm/asm/loongarch-type.rs b/tests/assembly-llvm/asm/loongarch-type.rs
new file mode 100644
index 00000000000..c782be19f1d
--- /dev/null
+++ b/tests/assembly-llvm/asm/loongarch-type.rs
@@ -0,0 +1,190 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target loongarch64-unknown-linux-gnu
+//@ compile-flags: -Zmerge-functions=disabled
+//@ needs-llvm-components: loongarch
+
+#![feature(no_core, f16)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register, non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *const i32;
+
+extern "C" {
+    fn extern_func();
+    static extern_static: u8;
+}
+
+// CHECK-LABEL: sym_fn:
+// CHECK: #APP
+// CHECK: pcalau12i $t0, %got_pc_hi20(extern_func)
+// CHECK: ld.d $t0, $t0, %got_pc_lo12(extern_func)
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn sym_fn() {
+    asm!("la.got $r12, {}", sym extern_func);
+}
+
+// CHECK-LABEL: sym_static:
+// CHECK: #APP
+// CHECK: pcalau12i $t0, %got_pc_hi20(extern_static)
+// CHECK: ld.d $t0, $t0, %got_pc_lo12(extern_static)
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn sym_static() {
+    asm!("la.got $r12, {}", sym extern_static);
+}
+
+macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
+    #[no_mangle]
+    pub unsafe fn $func(x: $ty) -> $ty {
+        let y;
+        asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
+        y
+    }
+};}
+
+macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => {
+    #[no_mangle]
+    pub unsafe fn $func(x: $ty) -> $ty {
+        let y;
+        asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
+        y
+    }
+};}
+
+// CHECK-LABEL: reg_i8:
+// CHECK: #APP
+// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i8, i8, reg, "move");
+
+// CHECK-LABEL: reg_i16:
+// CHECK: #APP
+// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i16, i16, reg, "move");
+
+// CHECK-LABEL: reg_f16:
+// CHECK: #APP
+// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f16, f16, reg, "move");
+
+// CHECK-LABEL: reg_i32:
+// CHECK: #APP
+// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i32, i32, reg, "move");
+
+// CHECK-LABEL: reg_f32:
+// CHECK: #APP
+// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f32, f32, reg, "move");
+
+// CHECK-LABEL: reg_i64:
+// CHECK: #APP
+// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i64, i64, reg, "move");
+
+// CHECK-LABEL: reg_f64:
+// CHECK: #APP
+// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f64, f64, reg, "move");
+
+// CHECK-LABEL: reg_ptr:
+// CHECK: #APP
+// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_ptr, ptr, reg, "move");
+
+// CHECK-LABEL: freg_f16:
+// CHECK: #APP
+// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(freg_f16, f16, freg, "fmov.s");
+
+// CHECK-LABEL: freg_f32:
+// CHECK: #APP
+// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(freg_f32, f32, freg, "fmov.s");
+
+// CHECK-LABEL: freg_f64:
+// CHECK: #APP
+// CHECK: fmov.d $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(freg_f64, f64, freg, "fmov.d");
+
+// CHECK-LABEL: r4_i8:
+// CHECK: #APP
+// CHECK: move $a0, $a0
+// CHECK: #NO_APP
+check_reg!(r4_i8, i8, "$r4", "move");
+
+// CHECK-LABEL: r4_i16:
+// CHECK: #APP
+// CHECK: move $a0, $a0
+// CHECK: #NO_APP
+check_reg!(r4_i16, i16, "$r4", "move");
+
+// CHECK-LABEL: r4_f16:
+// CHECK: #APP
+// CHECK: move $a0, $a0
+// CHECK: #NO_APP
+check_reg!(r4_f16, f16, "$r4", "move");
+
+// CHECK-LABEL: r4_i32:
+// CHECK: #APP
+// CHECK: move $a0, $a0
+// CHECK: #NO_APP
+check_reg!(r4_i32, i32, "$r4", "move");
+
+// CHECK-LABEL: r4_f32:
+// CHECK: #APP
+// CHECK: move $a0, $a0
+// CHECK: #NO_APP
+check_reg!(r4_f32, f32, "$r4", "move");
+
+// CHECK-LABEL: r4_i64:
+// CHECK: #APP
+// CHECK: move $a0, $a0
+// CHECK: #NO_APP
+check_reg!(r4_i64, i64, "$r4", "move");
+
+// CHECK-LABEL: r4_f64:
+// CHECK: #APP
+// CHECK: move $a0, $a0
+// CHECK: #NO_APP
+check_reg!(r4_f64, f64, "$r4", "move");
+
+// CHECK-LABEL: r4_ptr:
+// CHECK: #APP
+// CHECK: move $a0, $a0
+// CHECK: #NO_APP
+check_reg!(r4_ptr, ptr, "$r4", "move");
+
+// CHECK-LABEL: f0_f16:
+// CHECK: #APP
+// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check_reg!(f0_f16, f16, "$f0", "fmov.s");
+
+// CHECK-LABEL: f0_f32:
+// CHECK: #APP
+// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check_reg!(f0_f32, f32, "$f0", "fmov.s");
+
+// CHECK-LABEL: f0_f64:
+// CHECK: #APP
+// CHECK: fmov.d $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check_reg!(f0_f64, f64, "$f0", "fmov.d");
diff --git a/tests/assembly-llvm/asm/m68k-types.rs b/tests/assembly-llvm/asm/m68k-types.rs
new file mode 100644
index 00000000000..9e4f6d9a1a9
--- /dev/null
+++ b/tests/assembly-llvm/asm/m68k-types.rs
@@ -0,0 +1,67 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target m68k-unknown-linux-gnu
+//@ needs-llvm-components: m68k
+
+#![feature(no_core, asm_experimental_arch)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *const u64;
+
+macro_rules! check {
+    ($func:ident $ty:ident $class:ident $mov:literal) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!($mov, " {}, {};"), out($class) y, in($class) x);
+            y
+        }
+    };
+}
+
+// CHECK-LABEL: reg_data_i8:
+// CHECK: ;APP
+// CHECK: move.b %d{{[0-9]}}, %d{{[0-9]}}
+// CHECK: ;NO_APP
+check!(reg_data_i8 i8 reg_data "move.b");
+
+// CHECK-LABEL: reg_data_i16:
+// CHECK: ;APP
+// CHECK: move.w %d{{[0-9]}}, %d{{[0-9]}}
+// CHECK: ;NO_APP
+check!(reg_data_i16 i16 reg_data "move.w");
+
+// CHECK-LABEL: reg_data_i32:
+// CHECK: ;APP
+// CHECK: move.l %d{{[0-9]}}, %d{{[0-9]}}
+// CHECK: ;NO_APP
+check!(reg_data_i32 i32 reg_data "move.l");
+
+// CHECK-LABEL: reg_addr_i16:
+// CHECK: ;APP
+// CHECK: move.w %a{{[0-9]}}, %a{{[0-9]}}
+// CHECK: ;NO_APP
+check!(reg_addr_i16 i16 reg_addr "move.w");
+
+// CHECK-LABEL: reg_addr_i32:
+// CHECK: ;APP
+// CHECK: move.l %a{{[0-9]}}, %a{{[0-9]}}
+// CHECK: ;NO_APP
+check!(reg_addr_i32 i32 reg_addr "move.l");
+
+// CHECK-LABEL: reg_i16:
+// CHECK: ;APP
+// CHECK: move.w %{{[da][0-9]}}, %{{[da][0-9]}}
+// CHECK: ;NO_APP
+check!(reg_i16 i16 reg "move.w");
+
+// CHECK-LABEL: reg_i32:
+// CHECK: ;APP
+// CHECK: move.l %{{[da][0-9]}}, %{{[da][0-9]}}
+// CHECK: ;NO_APP
+check!(reg_i32 i32 reg "move.l");
diff --git a/tests/assembly-llvm/asm/mips-types.rs b/tests/assembly-llvm/asm/mips-types.rs
new file mode 100644
index 00000000000..00e8ce0b874
--- /dev/null
+++ b/tests/assembly-llvm/asm/mips-types.rs
@@ -0,0 +1,211 @@
+//@ add-core-stubs
+//@ revisions: mips32 mips64
+//@ assembly-output: emit-asm
+//@[mips32] compile-flags: --target mips-unknown-linux-gnu
+//@[mips32] needs-llvm-components: mips
+//@[mips64] compile-flags: --target mips64-unknown-linux-gnuabi64
+//@[mips64] needs-llvm-components: mips
+//@ compile-flags: -Zmerge-functions=disabled
+
+#![feature(no_core, asm_experimental_arch)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register, non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *const i32;
+
+extern "C" {
+    fn extern_func();
+    static extern_static: u8;
+}
+
+macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
+    #[no_mangle]
+    pub unsafe fn $func(x: $ty) -> $ty {
+        let y;
+        asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
+        y
+    }
+};}
+
+macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => {
+    #[no_mangle]
+    pub unsafe fn $func(x: $ty) -> $ty {
+        let y;
+        asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
+        y
+    }
+};}
+
+// mips32-LABEL: sym_static_32:
+// mips32: #APP
+// mips32: lw $3, %got(extern_static)($gp)
+// mips32: #NO_APP
+#[cfg(mips32)]
+#[no_mangle]
+pub unsafe fn sym_static_32() {
+    asm!("lw $v1, {}", sym extern_static);
+}
+
+// mips32-LABEL: sym_fn_32:
+// mips32: #APP
+// mips32: lw $3, %got(extern_func)($gp)
+// mips32: #NO_APP
+#[cfg(mips32)]
+#[no_mangle]
+pub unsafe fn sym_fn_32() {
+    asm!("lw $v1, {}", sym extern_func);
+}
+
+// mips64-LABEL: sym_static_64:
+// mips64: #APP
+// mips64: lui    $3, %got_hi(extern_static)
+// mips64: daddu  $3, $3, $gp
+// mips64: ld     $3, %got_lo(extern_static)($3)
+// mips64: #NO_APP
+#[cfg(mips64)]
+#[no_mangle]
+pub unsafe fn sym_static_64() {
+    asm!("ld $v1, {}", sym extern_static);
+}
+
+// mips64-LABEL: sym_fn_64:
+// mips64: #APP
+// mips64: lui    $3, %got_hi(extern_func)
+// mips64: daddu  $3, $3, $gp
+// mips64: ld     $3, %got_lo(extern_func)($3)
+// mips64: #NO_APP
+#[cfg(mips64)]
+#[no_mangle]
+pub unsafe fn sym_fn_64() {
+    asm!("ld $v1, {}", sym extern_func);
+}
+
+// CHECK-LABEL: reg_f32:
+// CHECK: #APP
+// CHECK: mov.s $f{{[0-9]+}}, $f{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f32, f32, freg, "mov.s");
+
+// CHECK-LABEL: f0_f32:
+// CHECK: #APP
+// CHECK: mov.s $f0, $f0
+// CHECK: #NO_APP
+#[no_mangle]
+check_reg!(f0_f32, f32, "$f0", "mov.s");
+
+// CHECK-LABEL: reg_f32_64:
+// CHECK: #APP
+// CHECK: mov.d $f{{[0-9]+}}, $f{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f32_64, f32, freg, "mov.d");
+
+// CHECK-LABEL: f0_f32_64:
+// CHECK: #APP
+// CHECK: mov.d $f0, $f0
+// CHECK: #NO_APP
+#[no_mangle]
+check_reg!(f0_f32_64, f32, "$f0", "mov.d");
+
+// CHECK-LABEL: reg_f64:
+// CHECK: #APP
+// CHECK: mov.d $f{{[0-9]+}}, $f{{[0-9]+}}
+// CHECK: #NO_APP
+#[no_mangle]
+check!(reg_f64, f64, freg, "mov.d");
+
+// CHECK-LABEL: f0_f64:
+// CHECK: #APP
+// CHECK: mov.d $f0, $f0
+// CHECK: #NO_APP
+#[no_mangle]
+check_reg!(f0_f64, f64, "$f0", "mov.d");
+
+// CHECK-LABEL: reg_ptr:
+// CHECK: #APP
+// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_ptr, ptr, reg, "move");
+
+// CHECK-LABEL: reg_i32:
+// CHECK: #APP
+// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i32, i32, reg, "move");
+
+// CHECK-LABEL: reg_f32_soft:
+// CHECK: #APP
+// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f32_soft, f32, reg, "move");
+
+// mips64-LABEL: reg_f64_soft:
+// mips64: #APP
+// mips64: move ${{[0-9]+}}, ${{[0-9]+}}
+// mips64: #NO_APP
+#[cfg(mips64)]
+check!(reg_f64_soft, f64, reg, "move");
+
+// CHECK-LABEL: reg_i8:
+// CHECK: #APP
+// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i8, i8, reg, "move");
+
+// CHECK-LABEL: reg_u8:
+// CHECK: #APP
+// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_u8, u8, reg, "move");
+
+// CHECK-LABEL: reg_i16:
+// CHECK: #APP
+// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i16, i16, reg, "move");
+
+// mips64-LABEL: reg_i64:
+// mips64: #APP
+// mips64: move ${{[0-9]+}}, ${{[0-9]+}}
+// mips64: #NO_APP
+#[cfg(mips64)]
+check!(reg_i64, i64, reg, "move");
+
+// CHECK-LABEL: r8_ptr:
+// CHECK: #APP
+// CHECK: move $8, $8
+// CHECK: #NO_APP
+check_reg!(r8_ptr, ptr, "$8", "move");
+
+// CHECK-LABEL: r8_i32:
+// CHECK: #APP
+// CHECK: move $8, $8
+// CHECK: #NO_APP
+check_reg!(r8_i32, i32, "$8", "move");
+
+// CHECK-LABEL: r8_f32:
+// CHECK: #APP
+// CHECK: move $8, $8
+// CHECK: #NO_APP
+check_reg!(r8_f32, f32, "$8", "move");
+
+// CHECK-LABEL: r8_i8:
+// CHECK: #APP
+// CHECK: move $8, $8
+// CHECK: #NO_APP
+check_reg!(r8_i8, i8, "$8", "move");
+
+// CHECK-LABEL: r8_u8:
+// CHECK: #APP
+// CHECK: move $8, $8
+// CHECK: #NO_APP
+check_reg!(r8_u8, u8, "$8", "move");
+
+// CHECK-LABEL: r8_i16:
+// CHECK: #APP
+// CHECK: move $8, $8
+// CHECK: #NO_APP
+check_reg!(r8_i16, i16, "$8", "move");
diff --git a/tests/assembly-llvm/asm/msp430-types.rs b/tests/assembly-llvm/asm/msp430-types.rs
new file mode 100644
index 00000000000..442dc77999f
--- /dev/null
+++ b/tests/assembly-llvm/asm/msp430-types.rs
@@ -0,0 +1,141 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target msp430-none-elf
+//@ needs-llvm-components: msp430
+
+#![feature(no_core, asm_experimental_arch)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *const i16;
+
+macro_rules! check {
+    ($func:ident $ty:ident $class:ident) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!("mov {}, {}", lateout($class) y, in($class) x);
+            y
+        }
+    };
+}
+
+macro_rules! checkb {
+    ($func:ident $ty:ident $class:ident) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!("mov.b {}, {}", lateout($class) y, in($class) x);
+            y
+        }
+    };
+}
+
+macro_rules! check_reg {
+    ($func:ident $ty:ident $reg:tt) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!("mov ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
+            y
+        }
+    };
+}
+
+macro_rules! check_regb {
+    ($func:ident $ty:ident $reg:tt) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!("mov.b ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
+            y
+        }
+    };
+}
+
+extern "C" {
+    fn extern_func();
+    static extern_static: i8;
+}
+
+// CHECK-LABEL: sym_fn
+// CHECK: ;APP
+// CHECK: call extern_func
+// CHECK: ;NO_APP
+#[no_mangle]
+pub unsafe fn sym_fn() {
+    asm!("call {}", sym extern_func);
+}
+
+// CHECK-LABEL: sym_static
+// CHECK: ;APP
+// CHECK: mov.b extern_static, r{{[0-9]+}}
+// CHECK: ;NO_APP
+#[no_mangle]
+pub unsafe fn sym_static() -> i8 {
+    let y;
+    asm!("mov.b {1}, {0}", lateout(reg) y, sym extern_static);
+    y
+}
+
+// CHECK-LABEL: add_const:
+// CHECK: ;APP
+// CHECK: add.b #5, r{{[0-9]+}}
+// CHECK: ;NO_APP
+#[no_mangle]
+pub unsafe fn add_const() -> i8 {
+    let y;
+    asm!("add.b #{number}, {}", out(reg) y, number = const 5);
+    y
+}
+
+// CHECK-LABEL: mov_postincrement:
+// CHECK: ;APP
+// CHECK: mov @r5+, r{{[0-9]+}}
+// CHECK: ;NO_APP
+#[no_mangle]
+pub unsafe fn mov_postincrement(mut x: *const i16) -> (i16, *const i16) {
+    let y;
+    asm!("mov @r5+, {0}", out(reg) y, inlateout("r5") x);
+    (y, x)
+}
+
+// CHECK-LABEL: reg_i8:
+// CHECK: ;APP
+// CHECK: mov r{{[0-9]+}}, r{{[0-9]+}}
+// CHECK: ;NO_APP
+check!(reg_i8 i8 reg);
+
+// CHECK-LABEL: reg_i16:
+// CHECK: ;APP
+// CHECK: mov r{{[0-9]+}}, r{{[0-9]+}}
+// CHECK: ;NO_APP
+check!(reg_i16 i16 reg);
+
+// CHECK-LABEL: reg_i8b:
+// CHECK: ;APP
+// CHECK: mov.b r{{[0-9]+}}, r{{[0-9]+}}
+// CHECK: ;NO_APP
+checkb!(reg_i8b i8 reg);
+
+// CHECK-LABEL: r5_i8:
+// CHECK: ;APP
+// CHECK: mov r5, r5
+// CHECK: ;NO_APP
+check_reg!(r5_i8 i8 "r5");
+
+// CHECK-LABEL: r5_i16:
+// CHECK: ;APP
+// CHECK: mov r5, r5
+// CHECK: ;NO_APP
+check_reg!(r5_i16 i16 "r5");
+
+// CHECK-LABEL: r5_i8b:
+// CHECK: ;APP
+// CHECK: mov.b r5, r5
+// CHECK: ;NO_APP
+check_regb!(r5_i8b i8 "r5");
diff --git a/tests/assembly-llvm/asm/nvptx-types.rs b/tests/assembly-llvm/asm/nvptx-types.rs
new file mode 100644
index 00000000000..7e8ebd03024
--- /dev/null
+++ b/tests/assembly-llvm/asm/nvptx-types.rs
@@ -0,0 +1,115 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target nvptx64-nvidia-cuda
+//@ needs-llvm-components: nvptx
+
+#![feature(no_core, asm_experimental_arch)]
+#![crate_type = "rlib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *mut u8;
+
+// NVPTX does not support static variables
+#[no_mangle]
+fn extern_func() {}
+
+// CHECK-LABEL: .visible .func sym_fn()
+// CHECK: // begin inline asm
+// CHECK: call extern_func;
+// CHECK: // end inline asm
+#[no_mangle]
+pub unsafe fn sym_fn() {
+    asm!("call {};", sym extern_func);
+}
+
+macro_rules! check {
+    ($func:ident $ty:ident $class:ident $mov:literal) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!($mov, " {}, {};"), out($class) y, in($class) x);
+            y
+        }
+    };
+}
+
+// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg16_i8
+// CHECK: // begin inline asm
+// CHECK: mov.i16 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg16_i8 i8 reg16 "mov.i16");
+
+// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg16_i16
+// CHECK: // begin inline asm
+// CHECK: mov.i16 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg16_i16 i16 reg16 "mov.i16");
+
+// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_i8
+// CHECK: // begin inline asm
+// CHECK: mov.i32 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg32_i8 i8 reg32 "mov.i32");
+
+// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_i16
+// CHECK: // begin inline asm
+// CHECK: mov.i32 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg32_i16 i16 reg32 "mov.i32");
+
+// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_i32
+// CHECK: // begin inline asm
+// CHECK: mov.i32 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg32_i32 i32 reg32 "mov.i32");
+
+// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_f32
+// CHECK: // begin inline asm
+// CHECK: mov.i32 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg32_f32 f32 reg32 "mov.i32");
+
+// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i8
+// CHECK: // begin inline asm
+// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg64_i8 i8 reg64 "mov.i64");
+
+// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i16
+// CHECK: // begin inline asm
+// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg64_i16 i16 reg64 "mov.i64");
+
+// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i32
+// CHECK: // begin inline asm
+// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg64_i32 i32 reg64 "mov.i64");
+
+// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_f32
+// CHECK: // begin inline asm
+// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg64_f32 f32 reg64 "mov.i64");
+
+// CHECK-LABEL: .visible .func (.param .b64 func_retval0) reg64_i64
+// CHECK: // begin inline asm
+// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg64_i64 i64 reg64 "mov.i64");
+
+// CHECK-LABEL: .visible .func (.param .b64 func_retval0) reg64_f64
+// CHECK: // begin inline asm
+// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg64_f64 f64 reg64 "mov.i64");
+
+// CHECK-LABEL: .visible .func (.param .b64 func_retval0) reg64_ptr
+// CHECK: // begin inline asm
+// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
+// CHECK: // end inline asm
+check!(reg64_ptr ptr reg64 "mov.i64");
diff --git a/tests/assembly-llvm/asm/powerpc-types.rs b/tests/assembly-llvm/asm/powerpc-types.rs
new file mode 100644
index 00000000000..4291e4c02f3
--- /dev/null
+++ b/tests/assembly-llvm/asm/powerpc-types.rs
@@ -0,0 +1,474 @@
+//@ add-core-stubs
+//@ revisions: powerpc powerpc_altivec powerpc_vsx powerpc64 powerpc64_vsx
+//@ assembly-output: emit-asm
+//@[powerpc] compile-flags: --target powerpc-unknown-linux-gnu
+//@[powerpc] needs-llvm-components: powerpc
+//@[powerpc_altivec] compile-flags: --target powerpc-unknown-linux-gnu -C target-feature=+altivec --cfg altivec
+//@[powerpc_altivec] needs-llvm-components: powerpc
+//@[powerpc_vsx] compile-flags: --target powerpc-unknown-linux-gnu -C target-feature=+altivec,+vsx --cfg altivec --cfg vsx
+//@[powerpc_vsx] needs-llvm-components: powerpc
+//@[powerpc64] compile-flags: --target powerpc64-unknown-linux-gnu --cfg altivec
+//@[powerpc64] needs-llvm-components: powerpc
+//@[powerpc64_vsx] compile-flags: --target powerpc64-unknown-linux-gnu -C target-feature=+vsx --cfg altivec --cfg vsx
+//@[powerpc64_vsx] needs-llvm-components: powerpc
+//@ compile-flags: -Zmerge-functions=disabled
+
+#![feature(no_core, repr_simd, asm_experimental_arch)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register, non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+#[cfg_attr(altivec, cfg(not(target_feature = "altivec")))]
+#[cfg_attr(not(altivec), cfg(target_feature = "altivec"))]
+compile_error!("altivec cfg and target feature mismatch");
+#[cfg_attr(vsx, cfg(not(target_feature = "vsx")))]
+#[cfg_attr(not(vsx), cfg(target_feature = "vsx"))]
+compile_error!("vsx cfg and target feature mismatch");
+
+type ptr = *const i32;
+
+#[repr(simd)]
+pub struct i8x16([i8; 16]);
+#[repr(simd)]
+pub struct i16x8([i16; 8]);
+#[repr(simd)]
+pub struct i32x4([i32; 4]);
+#[repr(simd)]
+pub struct i64x2([i64; 2]);
+#[repr(simd)]
+pub struct f32x4([f32; 4]);
+#[repr(simd)]
+pub struct f64x2([f64; 2]);
+
+impl Copy for i8x16 {}
+impl Copy for i16x8 {}
+impl Copy for i32x4 {}
+impl Copy for i64x2 {}
+impl Copy for f32x4 {}
+impl Copy for f64x2 {}
+
+extern "C" {
+    fn extern_func();
+    static extern_static: u8;
+}
+
+macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
+    #[no_mangle]
+    pub unsafe fn $func(x: $ty) -> $ty {
+        let y;
+        asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
+        y
+    }
+};}
+
+macro_rules! check_reg { ($func:ident, $ty:ty, $rego:tt, $regc:tt, $mov:literal) => {
+    #[no_mangle]
+    pub unsafe fn $func(x: $ty) -> $ty {
+        let y;
+        asm!(concat!($mov, " ", $rego, ", ", $rego), lateout($regc) y, in($regc) x);
+        y
+    }
+};}
+
+// CHECK-LABEL: reg_i8:
+// CHECK: #APP
+// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i8, i8, reg, "mr");
+
+// CHECK-LABEL: reg_i16:
+// CHECK: #APP
+// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i16, i16, reg, "mr");
+
+// CHECK-LABEL: reg_i32:
+// CHECK: #APP
+// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i32, i32, reg, "mr");
+
+// powerpc64-LABEL: reg_i64:
+// powerpc64: #APP
+// powerpc64: mr {{[0-9]+}}, {{[0-9]+}}
+// powerpc64: #NO_APP
+#[cfg(powerpc64)]
+check!(reg_i64, i64, reg, "mr");
+
+// CHECK-LABEL: reg_i8_nz:
+// CHECK: #APP
+// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i8_nz, i8, reg_nonzero, "mr");
+
+// CHECK-LABEL: reg_i16_nz:
+// CHECK: #APP
+// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i16_nz, i16, reg_nonzero, "mr");
+
+// CHECK-LABEL: reg_i32_nz:
+// CHECK: #APP
+// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i32_nz, i32, reg_nonzero, "mr");
+
+// powerpc64-LABEL: reg_i64_nz:
+// powerpc64: #APP
+// powerpc64: mr {{[0-9]+}}, {{[0-9]+}}
+// powerpc64: #NO_APP
+#[cfg(powerpc64)]
+check!(reg_i64_nz, i64, reg_nonzero, "mr");
+
+// CHECK-LABEL: reg_f32:
+// CHECK: #APP
+// CHECK: fmr {{[0-9]+}}, {{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f32, f32, freg, "fmr");
+
+// CHECK-LABEL: reg_f64:
+// CHECK: #APP
+// CHECK: fmr {{[0-9]+}}, {{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f64, f64, freg, "fmr");
+
+// powerpc_altivec-LABEL: vreg_i8x16:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_i8x16:
+// powerpc64: #APP
+// powerpc64: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check!(vreg_i8x16, i8x16, vreg, "vmr");
+
+// powerpc_altivec-LABEL: vreg_i16x8:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_i16x8:
+// powerpc64: #APP
+// powerpc64: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check!(vreg_i16x8, i16x8, vreg, "vmr");
+
+// powerpc_altivec-LABEL: vreg_i32x4:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_i32x4:
+// powerpc64: #APP
+// powerpc64: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check!(vreg_i32x4, i32x4, vreg, "vmr");
+
+// powerpc_vsx-LABEL: vreg_i64x2:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_i64x2:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check!(vreg_i64x2, i64x2, vreg, "vmr");
+
+// powerpc_altivec-LABEL: vreg_f32x4:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_f32x4:
+// powerpc64: #APP
+// powerpc64: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check!(vreg_f32x4, f32x4, vreg, "vmr");
+
+// powerpc_vsx-LABEL: vreg_f64x2:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_f64x2:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check!(vreg_f64x2, f64x2, vreg, "vmr");
+
+// powerpc_vsx-LABEL: vreg_f32:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_f32:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check!(vreg_f32, f32, vreg, "vmr");
+
+// powerpc_vsx-LABEL: vreg_f64:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_f64:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check!(vreg_f64, f64, vreg, "vmr");
+
+// CHECK-LABEL: reg_i8_r0:
+// CHECK: #APP
+// CHECK: mr 0, 0
+// CHECK: #NO_APP
+check_reg!(reg_i8_r0, i8, "0", "0", "mr");
+
+// CHECK-LABEL: reg_i16_r0:
+// CHECK: #APP
+// CHECK: mr 0, 0
+// CHECK: #NO_APP
+check_reg!(reg_i16_r0, i16, "0", "0", "mr");
+
+// CHECK-LABEL: reg_i32_r0:
+// CHECK: #APP
+// CHECK: mr 0, 0
+// CHECK: #NO_APP
+check_reg!(reg_i32_r0, i32, "0", "0", "mr");
+
+// powerpc64-LABEL: reg_i64_r0:
+// powerpc64: #APP
+// powerpc64: mr 0, 0
+// powerpc64: #NO_APP
+#[cfg(powerpc64)]
+check_reg!(reg_i64_r0, i64, "0", "0", "mr");
+
+// CHECK-LABEL: reg_i8_r18:
+// CHECK: #APP
+// CHECK: mr 18, 18
+// CHECK: #NO_APP
+check_reg!(reg_i8_r18, i8, "18", "18", "mr");
+
+// CHECK-LABEL: reg_i16_r18:
+// CHECK: #APP
+// CHECK: mr 18, 18
+// CHECK: #NO_APP
+check_reg!(reg_i16_r18, i16, "18", "18", "mr");
+
+// CHECK-LABEL: reg_i32_r18:
+// CHECK: #APP
+// CHECK: mr 18, 18
+// CHECK: #NO_APP
+check_reg!(reg_i32_r18, i32, "18", "18", "mr");
+
+// powerpc64-LABEL: reg_i64_r18:
+// powerpc64: #APP
+// powerpc64: mr 18, 18
+// powerpc64: #NO_APP
+#[cfg(powerpc64)]
+check_reg!(reg_i64_r18, i64, "18", "18", "mr");
+
+// CHECK-LABEL: reg_f32_f0:
+// CHECK: #APP
+// CHECK: fmr 0, 0
+// CHECK: #NO_APP
+check_reg!(reg_f32_f0, f32, "0", "f0", "fmr");
+
+// CHECK-LABEL: reg_f64_f0:
+// CHECK: #APP
+// CHECK: fmr 0, 0
+// CHECK: #NO_APP
+check_reg!(reg_f64_f0, f64, "0", "f0", "fmr");
+
+// CHECK-LABEL: reg_f32_f18:
+// CHECK: #APP
+// CHECK: fmr 18, 18
+// CHECK: #NO_APP
+check_reg!(reg_f32_f18, f32, "18", "f18", "fmr");
+
+// CHECK-LABEL: reg_f64_f18:
+// CHECK: #APP
+// CHECK: fmr 18, 18
+// CHECK: #NO_APP
+check_reg!(reg_f64_f18, f64, "18", "f18", "fmr");
+
+// powerpc_altivec-LABEL: vreg_i8x16_v0:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr 0, 0
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_i8x16_v0:
+// powerpc64: #APP
+// powerpc64: vmr 0, 0
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check_reg!(vreg_i8x16_v0, i8x16, "0", "v0", "vmr");
+
+// powerpc_altivec-LABEL: vreg_i16x8_v0:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr 0, 0
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_i16x8_v0:
+// powerpc64: #APP
+// powerpc64: vmr 0, 0
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check_reg!(vreg_i16x8_v0, i16x8, "0", "v0", "vmr");
+
+// powerpc_altivec-LABEL: vreg_i32x4_v0:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr 0, 0
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_i32x4_v0:
+// powerpc64: #APP
+// powerpc64: vmr 0, 0
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check_reg!(vreg_i32x4_v0, i32x4, "0", "v0", "vmr");
+
+// powerpc_vsx-LABEL: vreg_i64x2_v0:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr 0, 0
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_i64x2_v0:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr 0, 0
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check_reg!(vreg_i64x2_v0, i64x2, "0", "v0", "vmr");
+
+// powerpc_altivec-LABEL: vreg_f32x4_v0:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr 0, 0
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_f32x4_v0:
+// powerpc64: #APP
+// powerpc64: vmr 0, 0
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check_reg!(vreg_f32x4_v0, f32x4, "0", "v0", "vmr");
+
+// powerpc_vsx-LABEL: vreg_f64x2_v0:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr 0, 0
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_f64x2_v0:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr 0, 0
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check_reg!(vreg_f64x2_v0, f64x2, "0", "v0", "vmr");
+
+// powerpc_vsx-LABEL: vreg_f32_v0:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr 0, 0
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_f32_v0:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr 0, 0
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check_reg!(vreg_f32_v0, f32, "0", "v0", "vmr");
+
+// powerpc_vsx-LABEL: vreg_f64_v0:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr 0, 0
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_f64_v0:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr 0, 0
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check_reg!(vreg_f64_v0, f64, "0", "v0", "vmr");
+
+// powerpc_altivec-LABEL: vreg_i8x16_v18:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr 18, 18
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_i8x16_v18:
+// powerpc64: #APP
+// powerpc64: vmr 18, 18
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check_reg!(vreg_i8x16_v18, i8x16, "18", "v18", "vmr");
+
+// powerpc_altivec-LABEL: vreg_i16x8_v18:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr 18, 18
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_i16x8_v18:
+// powerpc64: #APP
+// powerpc64: vmr 18, 18
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check_reg!(vreg_i16x8_v18, i16x8, "18", "v18", "vmr");
+
+// powerpc_altivec-LABEL: vreg_i32x4_v18:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr 18, 18
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_i32x4_v18:
+// powerpc64: #APP
+// powerpc64: vmr 18, 18
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check_reg!(vreg_i32x4_v18, i32x4, "18", "v18", "vmr");
+
+// powerpc_vsx-LABEL: vreg_i64x2_v18:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr 18, 18
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_i64x2_v18:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr 18, 18
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check_reg!(vreg_i64x2_v18, i64x2, "18", "v18", "vmr");
+
+// powerpc_altivec-LABEL: vreg_f32x4_v18:
+// powerpc_altivec: #APP
+// powerpc_altivec: vmr 18, 18
+// powerpc_altivec: #NO_APP
+// powerpc64-LABEL: vreg_f32x4_v18:
+// powerpc64: #APP
+// powerpc64: vmr 18, 18
+// powerpc64: #NO_APP
+#[cfg(altivec)]
+check_reg!(vreg_f32x4_v18, f32x4, "18", "v18", "vmr");
+
+// powerpc_vsx-LABEL: vreg_f64x2_v18:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr 18, 18
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_f64x2_v18:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr 18, 18
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check_reg!(vreg_f64x2_v18, f64x2, "18", "v18", "vmr");
+
+// powerpc_vsx-LABEL: vreg_f32_v18:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr 18, 18
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_f32_v18:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr 18, 18
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check_reg!(vreg_f32_v18, f32, "18", "v18", "vmr");
+
+// powerpc_vsx-LABEL: vreg_f64_v18:
+// powerpc_vsx: #APP
+// powerpc_vsx: vmr 18, 18
+// powerpc_vsx: #NO_APP
+// powerpc64_vsx-LABEL: vreg_f64_v18:
+// powerpc64_vsx: #APP
+// powerpc64_vsx: vmr 18, 18
+// powerpc64_vsx: #NO_APP
+#[cfg(vsx)]
+check_reg!(vreg_f64_v18, f64, "18", "v18", "vmr");
diff --git a/tests/assembly-llvm/asm/riscv-types.rs b/tests/assembly-llvm/asm/riscv-types.rs
new file mode 100644
index 00000000000..724aa154da8
--- /dev/null
+++ b/tests/assembly-llvm/asm/riscv-types.rs
@@ -0,0 +1,227 @@
+//@ add-core-stubs
+//@ revisions: riscv64 riscv32 riscv64-zfhmin riscv32-zfhmin riscv64-zfh riscv32-zfh
+//@ assembly-output: emit-asm
+
+//@[riscv64] compile-flags: --target riscv64imac-unknown-none-elf
+//@[riscv64] needs-llvm-components: riscv
+
+//@[riscv32] compile-flags: --target riscv32imac-unknown-none-elf
+//@[riscv32] needs-llvm-components: riscv
+
+//@[riscv64-zfhmin] compile-flags: --target riscv64imac-unknown-none-elf --cfg riscv64
+//@[riscv64-zfhmin] needs-llvm-components: riscv
+//@[riscv64-zfhmin] compile-flags: -C target-feature=+zfhmin
+//@[riscv64-zfhmin] filecheck-flags: --check-prefix riscv64
+
+//@[riscv32-zfhmin] compile-flags: --target riscv32imac-unknown-none-elf
+//@[riscv32-zfhmin] needs-llvm-components: riscv
+//@[riscv32-zfhmin] compile-flags: -C target-feature=+zfhmin
+
+//@[riscv64-zfh] compile-flags: --target riscv64imac-unknown-none-elf --cfg riscv64
+//@[riscv64-zfh] needs-llvm-components: riscv
+//@[riscv64-zfh] compile-flags: -C target-feature=+zfh
+//@[riscv64-zfh] filecheck-flags: --check-prefix riscv64 --check-prefix zfhmin
+
+//@[riscv32-zfh] compile-flags: --target riscv32imac-unknown-none-elf
+//@[riscv32-zfh] needs-llvm-components: riscv
+//@[riscv32-zfh] compile-flags: -C target-feature=+zfh
+//@[riscv32-zfh] filecheck-flags: --check-prefix zfhmin
+
+//@ compile-flags: -C target-feature=+d
+//@ compile-flags: -Zmerge-functions=disabled
+
+#![feature(no_core, f16)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *mut u8;
+
+extern "C" {
+    fn extern_func();
+    static extern_static: u8;
+}
+
+// CHECK-LABEL: sym_fn:
+// CHECK: #APP
+// CHECK: call extern_func
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn sym_fn() {
+    asm!("call {}", sym extern_func);
+}
+
+// CHECK-LABEL: sym_static:
+// CHECK: #APP
+// CHECK: auipc t0, %pcrel_hi(extern_static)
+// CHECK: lb t0, %pcrel_lo(.Lpcrel_hi{{[0-9]+}})(t0)
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn sym_static() {
+    asm!("lb t0, {}", sym extern_static);
+}
+
+macro_rules! check {
+    ($func:ident $ty:ident $class:ident $mov:literal) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!($mov, " {}, {}"), out($class) y, in($class) x);
+            y
+        }
+    };
+}
+
+macro_rules! check_reg {
+    ($func:ident $ty:ident $reg:tt $mov:literal) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
+            y
+        }
+    };
+}
+
+// CHECK-LABEL: reg_i8:
+// CHECK: #APP
+// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i8 i8 reg "mv");
+
+// CHECK-LABEL: reg_f16:
+// CHECK: #APP
+// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f16 f16 reg "mv");
+
+// CHECK-LABEL: reg_i16:
+// CHECK: #APP
+// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i16 i16 reg "mv");
+
+// CHECK-LABEL: reg_i32:
+// CHECK: #APP
+// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i32 i32 reg "mv");
+
+// CHECK-LABEL: reg_f32:
+// CHECK: #APP
+// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f32 f32 reg "mv");
+
+// riscv64-LABEL: reg_i64:
+// riscv64: #APP
+// riscv64: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// riscv64: #NO_APP
+#[cfg(riscv64)]
+check!(reg_i64 i64 reg "mv");
+
+// riscv64-LABEL: reg_f64:
+// riscv64: #APP
+// riscv64: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// riscv64: #NO_APP
+#[cfg(riscv64)]
+check!(reg_f64 f64 reg "mv");
+
+// CHECK-LABEL: reg_ptr:
+// CHECK: #APP
+// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_ptr ptr reg "mv");
+
+// CHECK-LABEL: freg_f16:
+// zfhmin-NOT: or
+// CHECK: #APP
+// CHECK: fmv.s f{{[a-z0-9]+}}, f{{[a-z0-9]+}}
+// CHECK: #NO_APP
+// zfhmin-NOT: or
+check!(freg_f16 f16 freg "fmv.s");
+
+// CHECK-LABEL: freg_f32:
+// CHECK: #APP
+// CHECK: fmv.s f{{[a-z0-9]+}}, f{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(freg_f32 f32 freg "fmv.s");
+
+// CHECK-LABEL: freg_f64:
+// CHECK: #APP
+// CHECK: fmv.d f{{[a-z0-9]+}}, f{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(freg_f64 f64 freg "fmv.d");
+
+// CHECK-LABEL: a0_i8:
+// CHECK: #APP
+// CHECK: mv a0, a0
+// CHECK: #NO_APP
+check_reg!(a0_i8 i8 "a0" "mv");
+
+// CHECK-LABEL: a0_i16:
+// CHECK: #APP
+// CHECK: mv a0, a0
+// CHECK: #NO_APP
+check_reg!(a0_i16 i16 "a0" "mv");
+
+// CHECK-LABEL: a0_f16:
+// CHECK: #APP
+// CHECK: mv a0, a0
+// CHECK: #NO_APP
+check_reg!(a0_f16 f16 "a0" "mv");
+
+// CHECK-LABEL: a0_i32:
+// CHECK: #APP
+// CHECK: mv a0, a0
+// CHECK: #NO_APP
+check_reg!(a0_i32 i32 "a0" "mv");
+
+// CHECK-LABEL: a0_f32:
+// CHECK: #APP
+// CHECK: mv a0, a0
+// CHECK: #NO_APP
+check_reg!(a0_f32 f32 "a0" "mv");
+
+// riscv64-LABEL: a0_i64:
+// riscv64: #APP
+// riscv64: mv a0, a0
+// riscv64: #NO_APP
+#[cfg(riscv64)]
+check_reg!(a0_i64 i64 "a0" "mv");
+
+// riscv64-LABEL: a0_f64:
+// riscv64: #APP
+// riscv64: mv a0, a0
+// riscv64: #NO_APP
+#[cfg(riscv64)]
+check_reg!(a0_f64 f64 "a0" "mv");
+
+// CHECK-LABEL: a0_ptr:
+// CHECK: #APP
+// CHECK: mv a0, a0
+// CHECK: #NO_APP
+check_reg!(a0_ptr ptr "a0" "mv");
+
+// CHECK-LABEL: fa0_f16:
+// zfhmin-NOT: or
+// CHECK: #APP
+// CHECK: fmv.s fa0, fa0
+// CHECK: #NO_APP
+// zfhmin-NOT: or
+check_reg!(fa0_f16 f16 "fa0" "fmv.s");
+
+// CHECK-LABEL: fa0_f32:
+// CHECK: #APP
+// CHECK: fmv.s fa0, fa0
+// CHECK: #NO_APP
+check_reg!(fa0_f32 f32 "fa0" "fmv.s");
+
+// CHECK-LABEL: fa0_f64:
+// CHECK: #APP
+// CHECK: fmv.d fa0, fa0
+// CHECK: #NO_APP
+check_reg!(fa0_f64 f64 "fa0" "fmv.d");
diff --git a/tests/assembly-llvm/asm/s390x-types.rs b/tests/assembly-llvm/asm/s390x-types.rs
new file mode 100644
index 00000000000..e6fe38ecb0d
--- /dev/null
+++ b/tests/assembly-llvm/asm/s390x-types.rs
@@ -0,0 +1,350 @@
+//@ add-core-stubs
+//@ revisions: s390x s390x_vector
+//@ assembly-output: emit-asm
+//@[s390x] compile-flags: --target s390x-unknown-linux-gnu
+//@[s390x] needs-llvm-components: systemz
+//@[s390x_vector] compile-flags: --target s390x-unknown-linux-gnu -C target-feature=+vector
+//@[s390x_vector] needs-llvm-components: systemz
+//@ compile-flags: -Zmerge-functions=disabled
+
+#![feature(no_core, repr_simd, f128)]
+#![cfg_attr(s390x_vector, feature(asm_experimental_reg))]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register, non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *const i32;
+
+#[repr(simd)]
+pub struct i8x16([i8; 16]);
+#[repr(simd)]
+pub struct i16x8([i16; 8]);
+#[repr(simd)]
+pub struct i32x4([i32; 4]);
+#[repr(simd)]
+pub struct i64x2([i64; 2]);
+#[repr(simd)]
+pub struct f32x4([f32; 4]);
+#[repr(simd)]
+pub struct f64x2([f64; 2]);
+
+impl Copy for i8x16 {}
+impl Copy for i16x8 {}
+impl Copy for i32x4 {}
+impl Copy for i64x2 {}
+impl Copy for f32x4 {}
+impl Copy for f64x2 {}
+
+extern "C" {
+    fn extern_func();
+    static extern_static: u8;
+}
+
+macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
+    #[no_mangle]
+    pub unsafe fn $func(x: $ty) -> $ty {
+        let y;
+        asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
+        y
+    }
+};}
+
+macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => {
+    #[no_mangle]
+    pub unsafe fn $func(x: $ty) -> $ty {
+        let y;
+        asm!(concat!($mov, " %", $reg, ", %", $reg), lateout($reg) y, in($reg) x);
+        y
+    }
+};}
+
+// CHECK-LABEL: sym_fn_32:
+// CHECK: #APP
+// CHECK: brasl %r14, extern_func
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn sym_fn_32() {
+    asm!("brasl %r14, {}", sym extern_func);
+}
+
+// CHECK-LABEL: sym_static:
+// CHECK: #APP
+// CHECK: brasl %r14, extern_static
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn sym_static() {
+    asm!("brasl %r14, {}", sym extern_static);
+}
+
+// CHECK-LABEL: reg_i8:
+// CHECK: #APP
+// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i8, i8, reg, "lgr");
+
+// CHECK-LABEL: reg_i16:
+// CHECK: #APP
+// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i16, i16, reg, "lgr");
+
+// CHECK-LABEL: reg_i32:
+// CHECK: #APP
+// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i32, i32, reg, "lgr");
+
+// CHECK-LABEL: reg_i64:
+// CHECK: #APP
+// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i64, i64, reg, "lgr");
+
+// CHECK-LABEL: reg_i8_addr:
+// CHECK: #APP
+// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i8_addr, i8, reg_addr, "lgr");
+
+// CHECK-LABEL: reg_i16_addr:
+// CHECK: #APP
+// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i16_addr, i16, reg_addr, "lgr");
+
+// CHECK-LABEL: reg_i32_addr:
+// CHECK: #APP
+// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i32_addr, i32, reg_addr, "lgr");
+
+// CHECK-LABEL: reg_i64_addr:
+// CHECK: #APP
+// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i64_addr, i64, reg_addr, "lgr");
+
+// CHECK-LABEL: reg_f32:
+// CHECK: #APP
+// CHECK: ler %f{{[0-9]+}}, %f{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f32, f32, freg, "ler");
+
+// CHECK-LABEL: reg_f64:
+// CHECK: #APP
+// CHECK: ldr %f{{[0-9]+}}, %f{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f64, f64, freg, "ldr");
+
+// CHECK-LABEL: reg_ptr:
+// CHECK: #APP
+// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
+// CHECK: #NO_APP
+check!(reg_ptr, ptr, reg, "lgr");
+
+// s390x_vector-LABEL: vreg_i8x16:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_i8x16, i8x16, vreg, "vlr");
+
+// s390x_vector-LABEL: vreg_i16x8:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_i16x8, i16x8, vreg, "vlr");
+
+// s390x_vector-LABEL: vreg_i32x4:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_i32x4, i32x4, vreg, "vlr");
+
+// s390x_vector-LABEL: vreg_i64x2:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_i64x2, i64x2, vreg, "vlr");
+
+// s390x_vector-LABEL: vreg_f32x4:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_f32x4, f32x4, vreg, "vlr");
+
+// s390x_vector-LABEL: vreg_f64x2:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_f64x2, f64x2, vreg, "vlr");
+
+// s390x_vector-LABEL: vreg_i32:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_i32, i32, vreg, "vlr");
+
+// s390x_vector-LABEL: vreg_i64:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_i64, i64, vreg, "vlr");
+
+// s390x_vector-LABEL: vreg_i128:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_i128, i128, vreg, "vlr");
+
+// s390x_vector-LABEL: vreg_f32:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_f32, f32, vreg, "vlr");
+
+// s390x_vector-LABEL: vreg_f64:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_f64, f64, vreg, "vlr");
+
+// s390x_vector-LABEL: vreg_f128:
+// s390x_vector: #APP
+// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check!(vreg_f128, f128, vreg, "vlr");
+
+// CHECK-LABEL: r0_i8:
+// CHECK: #APP
+// CHECK: lr %r0, %r0
+// CHECK: #NO_APP
+check_reg!(r0_i8, i8, "r0", "lr");
+
+// CHECK-LABEL: r0_i16:
+// CHECK: #APP
+// CHECK: lr %r0, %r0
+// CHECK: #NO_APP
+check_reg!(r0_i16, i16, "r0", "lr");
+
+// CHECK-LABEL: r0_i32:
+// CHECK: #APP
+// CHECK: lr %r0, %r0
+// CHECK: #NO_APP
+check_reg!(r0_i32, i32, "r0", "lr");
+
+// CHECK-LABEL: r0_i64:
+// CHECK: #APP
+// CHECK: lr %r0, %r0
+// CHECK: #NO_APP
+check_reg!(r0_i64, i64, "r0", "lr");
+
+// CHECK-LABEL: f0_f32:
+// CHECK: #APP
+// CHECK: ler %f0, %f0
+// CHECK: #NO_APP
+check_reg!(f0_f32, f32, "f0", "ler");
+
+// CHECK-LABEL: f0_f64:
+// CHECK: #APP
+// CHECK: ldr %f0, %f0
+// CHECK: #NO_APP
+check_reg!(f0_f64, f64, "f0", "ldr");
+
+// s390x_vector-LABEL: v0_i8x16:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_i8x16, i8x16, "v0", "vlr");
+
+// s390x_vector-LABEL: v0_i16x8:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_i16x8, i16x8, "v0", "vlr");
+
+// s390x_vector-LABEL: v0_i32x4:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_i32x4, i32x4, "v0", "vlr");
+
+// s390x_vector-LABEL: v0_i64x2:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_i64x2, i64x2, "v0", "vlr");
+
+// s390x_vector-LABEL: v0_f32x4:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_f32x4, f32x4, "v0", "vlr");
+
+// s390x_vector-LABEL: v0_f64x2:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_f64x2, f64x2, "v0", "vlr");
+
+// s390x_vector-LABEL: v0_i32:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_i32, i32, "v0", "vlr");
+
+// s390x_vector-LABEL: v0_i64:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_i64, i64, "v0", "vlr");
+
+// s390x_vector-LABEL: v0_i128:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_i128, i128, "v0", "vlr");
+
+// s390x_vector-LABEL: v0_f32:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_f32, f32, "v0", "vlr");
+
+// s390x_vector-LABEL: v0_f64:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_f64, f64, "v0", "vlr");
+
+// s390x_vector-LABEL: v0_f128:
+// s390x_vector: #APP
+// s390x_vector: vlr %v0, %v0
+// s390x_vector: #NO_APP
+#[cfg(s390x_vector)]
+check_reg!(v0_f128, f128, "v0", "vlr");
diff --git a/tests/assembly-llvm/asm/sparc-types.rs b/tests/assembly-llvm/asm/sparc-types.rs
new file mode 100644
index 00000000000..49cc377cd95
--- /dev/null
+++ b/tests/assembly-llvm/asm/sparc-types.rs
@@ -0,0 +1,145 @@
+//@ add-core-stubs
+//@ revisions: sparc sparcv8plus sparc64
+//@ assembly-output: emit-asm
+//@[sparc] compile-flags: --target sparc-unknown-none-elf
+//@[sparc] needs-llvm-components: sparc
+//@[sparcv8plus] compile-flags: --target sparc-unknown-linux-gnu
+//@[sparcv8plus] needs-llvm-components: sparc
+//@[sparc64] compile-flags: --target sparc64-unknown-linux-gnu
+//@[sparc64] needs-llvm-components: sparc
+//@ compile-flags: -Zmerge-functions=disabled
+
+#![feature(no_core, asm_experimental_arch)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register, non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *const i32;
+
+extern "C" {
+    fn extern_func();
+    static extern_static: u8;
+}
+
+macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
+    #[no_mangle]
+    pub unsafe fn $func(x: $ty) -> $ty {
+        let y;
+        asm!(concat!($mov," {}, {}"), in($class) x, out($class) y);
+        y
+    }
+};}
+
+macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => {
+    #[no_mangle]
+    pub unsafe fn $func(x: $ty) -> $ty {
+        let y;
+        asm!(concat!($mov, " %", $reg, ", %", $reg), in($reg) x, lateout($reg) y);
+        y
+    }
+};}
+
+// CHECK-LABEL: sym_fn_32:
+// CHECK: !APP
+// CHECK-NEXT: call extern_func
+// CHECK-NEXT: !NO_APP
+#[no_mangle]
+pub unsafe fn sym_fn_32() {
+    asm!("call {}", sym extern_func);
+}
+
+// CHECK-LABEL: sym_static:
+// CHECK: !APP
+// CHECK-NEXT: call extern_static
+// CHECK-NEXT: !NO_APP
+#[no_mangle]
+pub unsafe fn sym_static() {
+    asm!("call {}", sym extern_static);
+}
+
+// CHECK-LABEL: reg_i8:
+// CHECK: !APP
+// CHECK-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}}
+// CHECK-NEXT: !NO_APP
+check!(reg_i8, i8, reg, "mov");
+
+// CHECK-LABEL: reg_i16:
+// CHECK: !APP
+// CHECK-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}}
+// CHECK-NEXT: !NO_APP
+check!(reg_i16, i16, reg, "mov");
+
+// CHECK-LABEL: reg_i32:
+// CHECK: !APP
+// CHECK-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}}
+// CHECK-NEXT: !NO_APP
+check!(reg_i32, i32, reg, "mov");
+
+// FIXME: should be allowed for sparcv8plus but not yet supported in LLVM
+// sparc64-LABEL: reg_i64:
+// sparc64: !APP
+// sparc64-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}}
+// sparc64-NEXT: !NO_APP
+#[cfg(sparc64)]
+check!(reg_i64, i64, reg, "mov");
+
+// CHECK-LABEL: reg_ptr:
+// CHECK: !APP
+// CHECK-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}}
+// CHECK-NEXT: !NO_APP
+check!(reg_ptr, ptr, reg, "mov");
+
+// CHECK-LABEL: o0_i8:
+// CHECK: !APP
+// CHECK-NEXT: mov %o0, %o0
+// CHECK-NEXT: !NO_APP
+check_reg!(o0_i8, i8, "o0", "mov");
+
+// CHECK-LABEL: o0_i16:
+// CHECK: !APP
+// CHECK-NEXT: mov %o0, %o0
+// CHECK-NEXT: !NO_APP
+check_reg!(o0_i16, i16, "o0", "mov");
+
+// CHECK-LABEL: o0_i32:
+// CHECK: !APP
+// CHECK-NEXT: mov %o0, %o0
+// CHECK-NEXT: !NO_APP
+check_reg!(o0_i32, i32, "o0", "mov");
+
+// FIXME: should be allowed for sparcv8plus but not yet supported in LLVM
+// sparc64-LABEL: o0_i64:
+// sparc64: !APP
+// sparc64-NEXT: mov %o0, %o0
+// sparc64-NEXT: !NO_APP
+#[cfg(sparc64)]
+check_reg!(o0_i64, i64, "o0", "mov");
+
+// CHECK-LABEL: r9_i8:
+// CHECK: !APP
+// CHECK-NEXT: mov %o1, %o1
+// CHECK-NEXT: !NO_APP
+check_reg!(r9_i8, i8, "r9", "mov");
+
+// CHECK-LABEL: r9_i16:
+// CHECK: !APP
+// CHECK-NEXT: mov %o1, %o1
+// CHECK-NEXT: !NO_APP
+check_reg!(r9_i16, i16, "r9", "mov");
+
+// CHECK-LABEL: r9_i32:
+// CHECK: !APP
+// CHECK-NEXT: mov %o1, %o1
+// CHECK-NEXT: !NO_APP
+check_reg!(r9_i32, i32, "r9", "mov");
+
+// FIXME: should be allowed for sparcv8plus but not yet supported in LLVM
+// sparc64-LABEL: r9_i64:
+// sparc64: !APP
+// sparc64-NEXT: mov %o1, %o1
+// sparc64-NEXT: !NO_APP
+#[cfg(sparc64)]
+check_reg!(r9_i64, i64, "r9", "mov");
diff --git a/tests/assembly-llvm/asm/wasm-types.rs b/tests/assembly-llvm/asm/wasm-types.rs
new file mode 100644
index 00000000000..78e555c5317
--- /dev/null
+++ b/tests/assembly-llvm/asm/wasm-types.rs
@@ -0,0 +1,131 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target wasm32-unknown-unknown
+//@ needs-llvm-components: webassembly
+
+#![feature(no_core, asm_experimental_arch)]
+#![crate_type = "rlib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *mut u8;
+
+extern "C" {
+    fn extern_func();
+    static extern_static: u8;
+}
+
+// CHECK-LABEL: sym_fn:
+// CHECK: #APP
+// CHECK: call extern_func
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn sym_fn() {
+    asm!("call {}", sym extern_func);
+}
+
+// CHECK-LABEL: sym_static
+// CHECK: #APP
+// CHECK: i32.const 42
+// CHECK: i32.store extern_static
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn sym_static() {
+    asm!("
+        i32.const 42
+        i32.store {}
+    ", sym extern_static);
+}
+
+macro_rules! check {
+    ($func:ident $ty:ident $instr:literal) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!("local.get {}\n", $instr, "\nlocal.set {}"), in(local) x, out(local) y);
+            y
+        }
+    };
+}
+
+// CHECK-LABEL: i8_i32:
+// CHECK: #APP
+// CHECK: local.get {{[0-9]}}
+// CHECK: i32.clz
+// CHECK: local.set {{[0-9]}}
+// CHECK: #NO_APP
+check!(i8_i32 i8 "i32.clz");
+
+// CHECK-LABEL: i16_i32:
+// CHECK: #APP
+// CHECK: local.get {{[0-9]}}
+// CHECK: i32.clz
+// CHECK: local.set {{[0-9]}}
+// CHECK: #NO_APP
+check!(i16_i32 i16 "i32.clz");
+
+// CHECK-LABEL: i32_i32:
+// CHECK: #APP
+// CHECK: local.get {{[0-9]}}
+// CHECK: i32.clz
+// CHECK: local.set {{[0-9]}}
+// CHECK: #NO_APP
+check!(i32_i32 i32 "i32.clz");
+
+// CHECK-LABEL: i8_i64
+// CHECK: #APP
+// CHECK: local.get {{[0-9]}}
+// CHECK: i64.clz
+// CHECK: local.set {{[0-9]}}
+// CHECK: #NO_APP
+check!(i8_i64 i8 "i64.clz");
+
+// CHECK-LABEL: i16_i64
+// CHECK: #APP
+// CHECK: local.get {{[0-9]}}
+// CHECK: i64.clz
+// CHECK: local.set {{[0-9]}}
+// CHECK: #NO_APP
+check!(i16_i64 i16 "i64.clz");
+
+// CHECK-LABEL: i32_i64
+// CHECK: #APP
+// CHECK: local.get {{[0-9]}}
+// CHECK: i64.clz
+// CHECK: local.set {{[0-9]}}
+// CHECK: #NO_APP
+check!(i32_i64 i32 "i64.clz");
+
+// CHECK-LABEL: i64_i64
+// CHECK: #APP
+// CHECK: local.get {{[0-9]}}
+// CHECK: i64.clz
+// CHECK: local.set {{[0-9]}}
+// CHECK: #NO_APP
+check!(i64_i64 i64 "i64.clz");
+
+// CHECK-LABEL: f32_f32
+// CHECK: #APP
+// CHECK: local.get {{[0-9]}}
+// CHECK: f32.abs
+// CHECK: local.set {{[0-9]}}
+// CHECK: #NO_APP
+check!(f32_f32 f32 "f32.abs");
+
+// CHECK-LABEL: f64_f64
+// CHECK: #APP
+// CHECK: local.get {{[0-9]}}
+// CHECK: f64.abs
+// CHECK: local.set {{[0-9]}}
+// CHECK: #NO_APP
+check!(f64_f64 f64 "f64.abs");
+
+// CHECK-LABEL: i32_ptr
+// CHECK: #APP
+// CHECK: local.get {{[0-9]}}
+// CHECK: i32.eqz
+// CHECK: local.set {{[0-9]}}
+// CHECK: #NO_APP
+check!(i32_ptr ptr "i32.eqz");
diff --git a/tests/assembly-llvm/asm/x86-modifiers.rs b/tests/assembly-llvm/asm/x86-modifiers.rs
new file mode 100644
index 00000000000..5f68e5c7317
--- /dev/null
+++ b/tests/assembly-llvm/asm/x86-modifiers.rs
@@ -0,0 +1,184 @@
+//@ add-core-stubs
+//@ revisions: x86_64 i686
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3 -C panic=abort
+//@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu
+//@[x86_64] needs-llvm-components: x86
+//@[i686] compile-flags: --target i686-unknown-linux-gnu
+//@[i686] needs-llvm-components: x86
+//@ compile-flags: -C llvm-args=--x86-asm-syntax=intel
+//@ compile-flags: -C target-feature=+avx512bw
+//@ compile-flags: -Zmerge-functions=disabled
+
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register)]
+
+extern crate minicore;
+use minicore::*;
+
+macro_rules! check {
+    ($func:ident $modifier:literal $reg:ident $mov:literal) => {
+        // -Copt-level=3 and extern "C" guarantee that the selected register is always ax/xmm0
+        #[no_mangle]
+        pub unsafe extern "C" fn $func() -> i32 {
+            let y;
+            asm!(concat!($mov, " {0:", $modifier, "}, {0:", $modifier, "}"), out($reg) y);
+            y
+        }
+    };
+}
+
+// CHECK-LABEL: reg:
+// CHECK: #APP
+// x86_64: mov rax, rax
+// i686: mov eax, eax
+// CHECK: #NO_APP
+check!(reg "" reg "mov");
+
+// x86_64-LABEL: reg_l:
+// x86_64: #APP
+// x86_64: mov al, al
+// x86_64: #NO_APP
+#[cfg(x86_64)]
+check!(reg_l "l" reg "mov");
+
+// CHECK-LABEL: reg_x:
+// CHECK: #APP
+// CHECK: mov ax, ax
+// CHECK: #NO_APP
+check!(reg_x "x" reg "mov");
+
+// CHECK-LABEL: reg_e:
+// CHECK: #APP
+// CHECK: mov eax, eax
+// CHECK: #NO_APP
+check!(reg_e "e" reg "mov");
+
+// x86_64-LABEL: reg_r:
+// x86_64: #APP
+// x86_64: mov rax, rax
+// x86_64: #NO_APP
+#[cfg(x86_64)]
+check!(reg_r "r" reg "mov");
+
+// CHECK-LABEL: reg_abcd:
+// CHECK: #APP
+// x86_64: mov rax, rax
+// i686: mov eax, eax
+// CHECK: #NO_APP
+check!(reg_abcd "" reg_abcd "mov");
+
+// CHECK-LABEL: reg_abcd_l:
+// CHECK: #APP
+// CHECK: mov al, al
+// CHECK: #NO_APP
+check!(reg_abcd_l "l" reg_abcd "mov");
+
+// CHECK-LABEL: reg_abcd_h:
+// CHECK: #APP
+// CHECK: mov ah, ah
+// CHECK: #NO_APP
+check!(reg_abcd_h "h" reg_abcd "mov");
+
+// CHECK-LABEL: reg_abcd_x:
+// CHECK: #APP
+// CHECK: mov ax, ax
+// CHECK: #NO_APP
+check!(reg_abcd_x "x" reg_abcd "mov");
+
+// CHECK-LABEL: reg_abcd_e:
+// CHECK: #APP
+// CHECK: mov eax, eax
+// CHECK: #NO_APP
+check!(reg_abcd_e "e" reg_abcd "mov");
+
+// x86_64-LABEL: reg_abcd_r:
+// x86_64: #APP
+// x86_64: mov rax, rax
+// x86_64: #NO_APP
+#[cfg(x86_64)]
+check!(reg_abcd_r "r" reg_abcd "mov");
+
+// CHECK-LABEL: xmm_reg
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check!(xmm_reg "" xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_x
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check!(xmm_reg_x "x" xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_y
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check!(xmm_reg_y "y" xmm_reg "vmovaps");
+
+// CHECK-LABEL: xmm_reg_z
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check!(xmm_reg_z "z" xmm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg
+// CHECK: #APP
+// CHECK: movaps ymm0, ymm0
+// CHECK: #NO_APP
+check!(ymm_reg "" ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_x
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check!(ymm_reg_x "x" ymm_reg "movaps");
+
+// CHECK-LABEL: ymm_reg_y
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check!(ymm_reg_y "y" ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_z
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check!(ymm_reg_z "z" ymm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg
+// CHECK: #APP
+// CHECK: movaps zmm0, zmm0
+// CHECK: #NO_APP
+check!(zmm_reg "" zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_x
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check!(zmm_reg_x "x" zmm_reg "movaps");
+
+// CHECK-LABEL: zmm_reg_y
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check!(zmm_reg_y "y" zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_z
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check!(zmm_reg_z "z" zmm_reg "vmovaps");
+
+// Note: we don't have any way of ensuring that k1 is actually the register
+// chosen by the register allocator, so this check may fail if a different
+// register is chosen.
+
+// CHECK-LABEL: kreg:
+// CHECK: #APP
+// CHECK: kmovb k1, k1
+// CHECK: #NO_APP
+check!(kreg "" kreg "kmovb");
diff --git a/tests/assembly-llvm/asm/x86-types.rs b/tests/assembly-llvm/asm/x86-types.rs
new file mode 100644
index 00000000000..6120ed0d532
--- /dev/null
+++ b/tests/assembly-llvm/asm/x86-types.rs
@@ -0,0 +1,1095 @@
+//@ add-core-stubs
+//@ revisions: x86_64 i686
+//@ assembly-output: emit-asm
+//@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu
+//@[x86_64] needs-llvm-components: x86
+//@[i686] compile-flags: --target i686-unknown-linux-gnu
+//@[i686] needs-llvm-components: x86
+//@ compile-flags: -C llvm-args=--x86-asm-syntax=intel
+//@ compile-flags: -C target-feature=+avx512bw
+//@ compile-flags: -Zmerge-functions=disabled
+
+#![feature(no_core, repr_simd, f16, f128)]
+#![crate_type = "rlib"]
+#![no_core]
+#![allow(asm_sub_register, non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+type ptr = *mut u8;
+
+#[repr(simd)]
+pub struct i8x16([i8; 16]);
+#[repr(simd)]
+pub struct i16x8([i16; 8]);
+#[repr(simd)]
+pub struct i32x4([i32; 4]);
+#[repr(simd)]
+pub struct i64x2([i64; 2]);
+#[repr(simd)]
+pub struct f16x8([f16; 8]);
+#[repr(simd)]
+pub struct f32x4([f32; 4]);
+#[repr(simd)]
+pub struct f64x2([f64; 2]);
+
+#[repr(simd)]
+pub struct i8x32([i8; 32]);
+#[repr(simd)]
+pub struct i16x16([i16; 16]);
+#[repr(simd)]
+pub struct i32x8([i32; 8]);
+#[repr(simd)]
+pub struct i64x4([i64; 4]);
+#[repr(simd)]
+pub struct f16x16([f16; 16]);
+#[repr(simd)]
+pub struct f32x8([f32; 8]);
+#[repr(simd)]
+pub struct f64x4([f64; 4]);
+
+#[repr(simd)]
+pub struct i8x64([i8; 64]);
+#[repr(simd)]
+pub struct i16x32([i16; 32]);
+#[repr(simd)]
+pub struct i32x16([i32; 16]);
+#[repr(simd)]
+pub struct i64x8([i64; 8]);
+#[repr(simd)]
+pub struct f16x32([f16; 32]);
+#[repr(simd)]
+pub struct f32x16([f32; 16]);
+#[repr(simd)]
+pub struct f64x8([f64; 8]);
+
+macro_rules! impl_copy {
+    ($($ty:ident)*) => {
+        $(
+            impl Copy for $ty {}
+        )*
+    };
+}
+
+impl_copy!(
+    i8x16 i16x8 i32x4 i64x2 f16x8 f32x4 f64x2
+    i8x32 i16x16 i32x8 i64x4 f16x16 f32x8 f64x4
+    i8x64 i16x32 i32x16 i64x8 f16x32 f32x16 f64x8
+);
+
+extern "C" {
+    fn extern_func();
+    static extern_static: u8;
+}
+
+// CHECK-LABEL: sym_fn:
+// CHECK: #APP
+// CHECK: call extern_func
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn sym_fn() {
+    asm!("call {}", sym extern_func);
+}
+
+// CHECK-LABEL: sym_static:
+// CHECK: #APP
+// CHECK: mov al, byte ptr [extern_static]
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn sym_static() {
+    asm!("mov al, byte ptr [{}]", sym extern_static);
+}
+
+macro_rules! check {
+    ($func:ident $ty:ident $class:ident $mov:literal) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!($mov, " {}, {}"), lateout($class) y, in($class) x);
+            y
+        }
+    };
+}
+
+macro_rules! check_reg {
+    ($func:ident $ty:ident $reg:tt $mov:literal) => {
+        #[no_mangle]
+        pub unsafe fn $func(x: $ty) -> $ty {
+            let y;
+            asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
+            y
+        }
+    };
+}
+
+// CHECK-LABEL: reg_i16:
+// CHECK: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i16 i16 reg "mov");
+
+// CHECK-LABEL: reg_f16:
+// CHECK: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f16 f16 reg "mov");
+
+// CHECK-LABEL: reg_i32:
+// CHECK: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_i32 i32 reg "mov");
+
+// CHECK-LABEL: reg_f32:
+// CHECK: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_f32 f32 reg "mov");
+
+// x86_64-LABEL: reg_i64:
+// x86_64: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// x86_64: #NO_APP
+#[cfg(x86_64)]
+check!(reg_i64 i64 reg "mov");
+
+// x86_64-LABEL: reg_f64:
+// x86_64: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// x86_64: #NO_APP
+#[cfg(x86_64)]
+check!(reg_f64 f64 reg "mov");
+
+// CHECK-LABEL: reg_ptr:
+// CHECK: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_ptr ptr reg "mov");
+
+// CHECK-LABEL: reg_abcd_i16:
+// CHECK: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_abcd_i16 i16 reg_abcd "mov");
+
+// CHECK-LABEL: reg_abcd_f16:
+// CHECK: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_abcd_f16 f16 reg_abcd "mov");
+
+// CHECK-LABEL: reg_abcd_i32:
+// CHECK: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_abcd_i32 i32 reg_abcd "mov");
+
+// CHECK-LABEL: reg_abcd_f32:
+// CHECK: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_abcd_f32 f32 reg_abcd "mov");
+
+// x86_64-LABEL: reg_abcd_i64:
+// x86_64: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// x86_64: #NO_APP
+#[cfg(x86_64)]
+check!(reg_abcd_i64 i64 reg_abcd "mov");
+
+// x86_64-LABEL: reg_abcd_f64:
+// x86_64: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// x86_64: #NO_APP
+#[cfg(x86_64)]
+check!(reg_abcd_f64 f64 reg_abcd "mov");
+
+// CHECK-LABEL: reg_abcd_ptr:
+// CHECK: #APP
+// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
+// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_abcd_ptr ptr reg_abcd "mov");
+
+// CHECK-LABEL: reg_byte:
+// CHECK: #APP
+// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: #NO_APP
+check!(reg_byte i8 reg_byte "mov");
+
+// CHECK-LABEL: xmm_reg_f16:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_f16 f16 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_i32:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_i32 i32 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_f32:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_f32 f32 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_i64:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_i64 i64 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_f64:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_f64 f64 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_f128:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_f128 f128 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_ptr:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_ptr ptr xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_i8x16:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_i8x16 i8x16 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_i16x8:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_i16x8 i16x8 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_i32x4:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_i32x4 i32x4 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_i64x2:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_i64x2 i64x2 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_f16x8:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_f16x8 f16x8 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_f32x4:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_f32x4 f32x4 xmm_reg "movaps");
+
+// CHECK-LABEL: xmm_reg_f64x2:
+// CHECK: #APP
+// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(xmm_reg_f64x2 f64x2 xmm_reg "movaps");
+
+// CHECK-LABEL: ymm_reg_f16:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_f16 f16 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_i32:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_i32 i32 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_f32:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_f32 f32 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_i64:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_i64 i64 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_f64:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_f64 f64 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_f128:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_f128 f128 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_ptr:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_ptr ptr ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_i8x16:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_i8x16 i8x16 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_i16x8:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_i16x8 i16x8 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_i32x4:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_i32x4 i32x4 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_i64x2:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_i64x2 i64x2 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_f16x8:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_f16x8 f16x8 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_f32x4:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_f32x4 f32x4 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_f64x2:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_f64x2 f64x2 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_i8x32:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_i8x32 i8x32 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_i16x16:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_i16x16 i16x16 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_i32x8:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_i32x8 i32x8 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_i64x4:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_i64x4 i64x4 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_f16x16:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_f16x16 f16x16 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_f32x8:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_f32x8 f32x8 ymm_reg "vmovaps");
+
+// CHECK-LABEL: ymm_reg_f64x4:
+// CHECK: #APP
+// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(ymm_reg_f64x4 f64x4 ymm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f16:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f16 f16 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i32:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i32 i32 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f32:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f32 f32 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i64:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i64 i64 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f64:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f64 f64 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f128:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f128 f128 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_ptr:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_ptr ptr zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i8x16:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i8x16 i8x16 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i16x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i16x8 i16x8 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i32x4:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i32x4 i32x4 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i64x2:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i64x2 i64x2 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f16x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f16x8 f16x8 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f32x4:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f32x4 f32x4 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f64x2:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f64x2 f64x2 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i8x32:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i8x32 i8x32 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i16x16:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i16x16 i16x16 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i32x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i32x8 i32x8 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i64x4:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i64x4 i64x4 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f16x16:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f16x16 f16x16 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f32x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f32x8 f32x8 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f64x4:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f64x4 f64x4 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i8x64:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i8x64 i8x64 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i16x32:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i16x32 i16x32 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i32x16:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i32x16 i32x16 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_i64x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_i64x8 i64x8 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f16x32:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f16x32 f16x32 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f32x16:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f32x16 f32x16 zmm_reg "vmovaps");
+
+// CHECK-LABEL: zmm_reg_f64x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
+// CHECK: #NO_APP
+check!(zmm_reg_f64x8 f64x8 zmm_reg "vmovaps");
+
+// CHECK-LABEL: kreg_i8:
+// CHECK: #APP
+// CHECK: kmovb k{{[0-9]+}}, k{{[0-9]+}}
+// CHECK: #NO_APP
+check!(kreg_i8 i8 kreg "kmovb");
+
+// CHECK-LABEL: kreg_i16:
+// CHECK: #APP
+// CHECK: kmovw k{{[0-9]+}}, k{{[0-9]+}}
+// CHECK: #NO_APP
+check!(kreg_i16 i16 kreg "kmovw");
+
+// CHECK-LABEL: kreg_i32:
+// CHECK: #APP
+// CHECK: kmovd k{{[0-9]+}}, k{{[0-9]+}}
+// CHECK: #NO_APP
+check!(kreg_i32 i32 kreg "kmovd");
+
+// CHECK-LABEL: kreg_i64:
+// CHECK: #APP
+// CHECK: kmovq k{{[0-9]+}}, k{{[0-9]+}}
+// CHECK: #NO_APP
+check!(kreg_i64 i64 kreg "kmovq");
+
+// CHECK-LABEL: kreg_ptr:
+// CHECK: #APP
+// CHECK: kmovq k{{[0-9]+}}, k{{[0-9]+}}
+// CHECK: #NO_APP
+check!(kreg_ptr ptr kreg "kmovq");
+
+// CHECK-LABEL: eax_i16:
+// CHECK: #APP
+// CHECK: mov eax, eax
+// CHECK: #NO_APP
+check_reg!(eax_i16 i16 "eax" "mov");
+
+// CHECK-LABEL: eax_f16:
+// CHECK: #APP
+// CHECK: mov eax, eax
+// CHECK: #NO_APP
+check_reg!(eax_f16 f16 "eax" "mov");
+
+// CHECK-LABEL: eax_i32:
+// CHECK: #APP
+// CHECK: mov eax, eax
+// CHECK: #NO_APP
+check_reg!(eax_i32 i32 "eax" "mov");
+
+// CHECK-LABEL: eax_f32:
+// CHECK: #APP
+// CHECK: mov eax, eax
+// CHECK: #NO_APP
+check_reg!(eax_f32 f32 "eax" "mov");
+
+// x86_64-LABEL: eax_i64:
+// x86_64: #APP
+// x86_64: mov eax, eax
+// x86_64: #NO_APP
+#[cfg(x86_64)]
+check_reg!(eax_i64 i64 "eax" "mov");
+
+// x86_64-LABEL: eax_f64:
+// x86_64: #APP
+// x86_64: mov eax, eax
+// x86_64: #NO_APP
+#[cfg(x86_64)]
+check_reg!(eax_f64 f64 "eax" "mov");
+
+// CHECK-LABEL: eax_ptr:
+// CHECK: #APP
+// CHECK: mov eax, eax
+// CHECK: #NO_APP
+check_reg!(eax_ptr ptr "eax" "mov");
+
+// i686-LABEL: ah_byte:
+// i686: #APP
+// i686: mov ah, ah
+// i686: #NO_APP
+#[cfg(i686)]
+check_reg!(ah_byte i8 "ah" "mov");
+
+// CHECK-LABEL: xmm0_f16:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_f16 f16 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_i32:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_i32 i32 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_f32:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_f32 f32 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_i64:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_i64 i64 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_f64:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_f64 f64 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_f128:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_f128 f128 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_ptr:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_ptr ptr "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_i8x16:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_i8x16 i8x16 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_i16x8:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_i16x8 i16x8 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_i32x4:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_i32x4 i32x4 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_i64x2:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_i64x2 i64x2 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_f16x8:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_f16x8 f16x8 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_f32x4:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_f32x4 f32x4 "xmm0" "movaps");
+
+// CHECK-LABEL: xmm0_f64x2:
+// CHECK: #APP
+// CHECK: movaps xmm0, xmm0
+// CHECK: #NO_APP
+check_reg!(xmm0_f64x2 f64x2 "xmm0" "movaps");
+
+// CHECK-LABEL: ymm0_f16:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_f16 f16 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_i32:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_i32 i32 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_f32:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_f32 f32 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_i64:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_i64 i64 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_f64:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_f64 f64 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_f128:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_f128 f128 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_ptr:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_ptr ptr "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_i8x16:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_i8x16 i8x16 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_i16x8:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_i16x8 i16x8 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_i32x4:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_i32x4 i32x4 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_i64x2:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_i64x2 i64x2 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_f16x8:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_f16x8 f16x8 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_f32x4:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_f32x4 f32x4 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_f64x2:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_f64x2 f64x2 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_i8x32:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_i8x32 i8x32 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_i16x16:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_i16x16 i16x16 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_i32x8:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_i32x8 i32x8 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_i64x4:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_i64x4 i64x4 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_f16x16:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_f16x16 f16x16 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_f32x8:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_f32x8 f32x8 "ymm0" "vmovaps");
+
+// CHECK-LABEL: ymm0_f64x4:
+// CHECK: #APP
+// CHECK: vmovaps ymm0, ymm0
+// CHECK: #NO_APP
+check_reg!(ymm0_f64x4 f64x4 "ymm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f16:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f16 f16 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i32:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i32 i32 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f32:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f32 f32 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i64:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i64 i64 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f64:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f64 f64 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f128:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f128 f128 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_ptr:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_ptr ptr "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i8x16:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i8x16 i8x16 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i16x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i16x8 i16x8 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i32x4:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i32x4 i32x4 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i64x2:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i64x2 i64x2 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f16x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f16x8 f16x8 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f32x4:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f32x4 f32x4 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f64x2:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f64x2 f64x2 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i8x32:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i8x32 i8x32 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i16x16:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i16x16 i16x16 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i32x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i32x8 i32x8 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i64x4:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i64x4 i64x4 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f16x16:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f16x16 f16x16 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f32x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f32x8 f32x8 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f64x4:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f64x4 f64x4 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i8x64:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i8x64 i8x64 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i16x32:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i16x32 i16x32 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i32x16:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i32x16 i32x16 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_i64x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_i64x8 i64x8 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f16x32:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f16x32 f16x32 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f32x16:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f32x16 f32x16 "zmm0" "vmovaps");
+
+// CHECK-LABEL: zmm0_f64x8:
+// CHECK: #APP
+// CHECK: vmovaps zmm0, zmm0
+// CHECK: #NO_APP
+check_reg!(zmm0_f64x8 f64x8 "zmm0" "vmovaps");
+
+// CHECK-LABEL: k1_i8:
+// CHECK: #APP
+// CHECK: kmovb k1, k1
+// CHECK: #NO_APP
+check_reg!(k1_i8 i8 "k1" "kmovb");
+
+// CHECK-LABEL: k1_i16:
+// CHECK: #APP
+// CHECK: kmovw k1, k1
+// CHECK: #NO_APP
+check_reg!(k1_i16 i16 "k1" "kmovw");
+
+// CHECK-LABEL: k1_i32:
+// CHECK: #APP
+// CHECK: kmovd k1, k1
+// CHECK: #NO_APP
+check_reg!(k1_i32 i32 "k1" "kmovd");
+
+// CHECK-LABEL: k1_i64:
+// CHECK: #APP
+// CHECK: kmovq k1, k1
+// CHECK: #NO_APP
+check_reg!(k1_i64 i64 "k1" "kmovq");
+
+// CHECK-LABEL: k1_ptr:
+// CHECK: #APP
+// CHECK: kmovq k1, k1
+// CHECK: #NO_APP
+check_reg!(k1_ptr ptr "k1" "kmovq");
diff --git a/tests/assembly-llvm/auxiliary/breakpoint-panic-handler.rs b/tests/assembly-llvm/auxiliary/breakpoint-panic-handler.rs
new file mode 100644
index 00000000000..d54c1181e1a
--- /dev/null
+++ b/tests/assembly-llvm/auxiliary/breakpoint-panic-handler.rs
@@ -0,0 +1,8 @@
+#![feature(core_intrinsics)]
+#![no_std]
+
+#[panic_handler]
+unsafe fn breakpoint_panic_handler(_: &::core::panic::PanicInfo) -> ! {
+    core::intrinsics::breakpoint();
+    core::hint::unreachable_unchecked();
+}
diff --git a/tests/assembly-llvm/auxiliary/dwarf-mixed-versions-lto-aux.rs b/tests/assembly-llvm/auxiliary/dwarf-mixed-versions-lto-aux.rs
new file mode 100644
index 00000000000..257608f881f
--- /dev/null
+++ b/tests/assembly-llvm/auxiliary/dwarf-mixed-versions-lto-aux.rs
@@ -0,0 +1,5 @@
+//@ compile-flags: -g --crate-type=rlib -Cdwarf-version=4
+
+pub fn check_is_even(number: &u64) -> bool {
+    number % 2 == 0
+}
diff --git a/tests/assembly-llvm/auxiliary/non-inline-dependency.rs b/tests/assembly-llvm/auxiliary/non-inline-dependency.rs
new file mode 100644
index 00000000000..57f3ee87cdb
--- /dev/null
+++ b/tests/assembly-llvm/auxiliary/non-inline-dependency.rs
@@ -0,0 +1,14 @@
+#![no_std]
+#![deny(warnings)]
+
+#[inline(never)]
+#[no_mangle]
+pub fn wrapping_external_fn(a: u32) -> u32 {
+    a.wrapping_mul(a)
+}
+
+#[inline(never)]
+#[no_mangle]
+pub fn panicking_external_fn(a: u32) -> u32 {
+    a * a
+}
diff --git a/tests/assembly-llvm/breakpoint.rs b/tests/assembly-llvm/breakpoint.rs
new file mode 100644
index 00000000000..e0cc2d1eebb
--- /dev/null
+++ b/tests/assembly-llvm/breakpoint.rs
@@ -0,0 +1,14 @@
+//@ revisions: aarch64 x86_64
+//@ assembly-output: emit-asm
+//@[aarch64] only-aarch64
+//@[x86_64] only-x86_64
+
+#![feature(breakpoint)]
+#![crate_type = "lib"]
+
+// CHECK-LABEL: use_bp
+// aarch64: brk #0xf000
+// x86_64: int3
+pub fn use_bp() {
+    core::arch::breakpoint();
+}
diff --git a/tests/assembly-llvm/closure-inherit-target-feature.rs b/tests/assembly-llvm/closure-inherit-target-feature.rs
new file mode 100644
index 00000000000..069204bbd34
--- /dev/null
+++ b/tests/assembly-llvm/closure-inherit-target-feature.rs
@@ -0,0 +1,59 @@
+//@ only-x86_64
+//@ ignore-sgx Tests incompatible with LVI mitigations
+//@ assembly-output: emit-asm
+// make sure the feature is not enabled at compile-time
+//@ compile-flags: -C opt-level=3 -C target-feature=-sse4.1 -C llvm-args=-x86-asm-syntax=intel
+
+#![crate_type = "rlib"]
+
+use std::arch::x86_64::{__m128, _mm_blend_ps};
+
+// Use an explicit return pointer to prevent tail call optimization.
+#[no_mangle]
+pub unsafe fn sse41_blend_nofeature(x: __m128, y: __m128, ret: *mut __m128) {
+    let f = {
+        // check that _mm_blend_ps is not being inlined into the closure
+        // CHECK-LABEL: {{sse41_blend_nofeature.*closure.*:}}
+        // CHECK-NOT: blendps
+        // CHECK: {{call .*_mm_blend_ps.*}}
+        // CHECK-NOT: blendps
+        // CHECK: ret
+        #[inline(never)]
+        |x, y, ret: *mut __m128| unsafe { *ret = _mm_blend_ps(x, y, 0b0101) }
+    };
+    f(x, y, ret);
+}
+
+#[no_mangle]
+#[target_feature(enable = "sse4.1")]
+pub fn sse41_blend_noinline(x: __m128, y: __m128) -> __m128 {
+    let f = {
+        // check that _mm_blend_ps is being inlined into the closure
+        // CHECK-LABEL: {{sse41_blend_noinline.*closure.*:}}
+        // CHECK-NOT: _mm_blend_ps
+        // CHECK: blendps
+        // CHECK-NOT: _mm_blend_ps
+        // CHECK: ret
+        #[inline(never)]
+        |x, y| unsafe { _mm_blend_ps(x, y, 0b0101) }
+    };
+    f(x, y)
+}
+
+#[no_mangle]
+#[target_feature(enable = "sse4.1")]
+pub fn sse41_blend_doinline(x: __m128, y: __m128) -> __m128 {
+    // check that the closure and _mm_blend_ps are being inlined into the function
+    // CHECK-LABEL: sse41_blend_doinline:
+    // CHECK-NOT: {{sse41_blend_doinline.*closure.*}}
+    // CHECK-NOT: _mm_blend_ps
+    // CHECK: blendps
+    // CHECK-NOT: {{sse41_blend_doinline.*closure.*}}
+    // CHECK-NOT: _mm_blend_ps
+    // CHECK: ret
+    let f = {
+        #[inline]
+        |x, y| unsafe { _mm_blend_ps(x, y, 0b0101) }
+    };
+    f(x, y)
+}
diff --git a/tests/assembly-llvm/cmse.rs b/tests/assembly-llvm/cmse.rs
new file mode 100644
index 00000000000..a68ee99eac6
--- /dev/null
+++ b/tests/assembly-llvm/cmse.rs
@@ -0,0 +1,100 @@
+//@ add-core-stubs
+//@ revisions: hard soft
+//@ assembly-output: emit-asm
+//@ [hard] compile-flags: --target thumbv8m.main-none-eabihf --crate-type lib -Copt-level=1
+//@ [soft] compile-flags: --target thumbv8m.main-none-eabi --crate-type lib -Copt-level=1
+//@ [hard] needs-llvm-components: arm
+//@ [soft] needs-llvm-components: arm
+#![crate_type = "lib"]
+#![feature(abi_cmse_nonsecure_call, cmse_nonsecure_entry, no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: __acle_se_entry_point:
+// CHECK-NEXT: entry_point:
+//
+// Write return argument (two registers since 64bit integer)
+// CHECK: movs r0, #0
+// CHECK: movs r1, #0
+//
+// If we are using hard-float:
+// * Check if the float registers were touched (bit 3 in CONTROL)
+// hard: mrs     [[REG:r[0-9]+]], control
+// hard: tst.w   [[REG]], #8
+// hard: beq     [[LABEL:[\.a-zA-Z0-9_]+]]
+//
+// * If touched clear all float registers (d0..=d7)
+// hard: vmov    d0,
+// hard: vmov    d1,
+// hard: vmov    d2,
+// hard: vmov    d3,
+// hard: vmov    d4,
+// hard: vmov    d5,
+// hard: vmov    d6,
+// hard: vmov    d7,
+//
+// * If touched clear FPU status register
+// hard: vmrs    [[REG:r[0-9]+]], fpscr
+// hard: bic     [[REG]], [[REG]], #159
+// hard: bic     [[REG]], [[REG]], #4026531840
+// hard: vmsr    fpscr, [[REG]]
+// hard: [[LABEL]]:
+//
+// Clear all other registers that might have been used
+// CHECK: mov r2,
+// CHECK: mov r3,
+// CHECK: mov r12,
+//
+// Clear the flags
+// CHECK: msr apsr_nzcvq,
+//
+// Branch back to non-secure side
+// CHECK: bxns lr
+#[no_mangle]
+pub extern "cmse-nonsecure-entry" fn entry_point() -> i64 {
+    0
+}
+
+// NOTE for future codegen changes:
+// The specific register assignment is not important, however:
+// * all registers must be cleared before `blxns` is executed
+//     (either by writing arguments or any other value)
+// * the lowest bit on the address of the callee must be cleared
+// * the flags need to be overwritten
+// * `blxns` needs to be called with the callee address
+//     (with the lowest bit cleared)
+//
+// CHECK-LABEL: call_nonsecure
+// Save callee pointer
+// CHECK: mov r12, r0
+//
+// All arguments are written to (writes r0..=r3)
+// CHECK: movs r0, #0
+// CHECK: movs r1, #1
+// CHECK: movs r2, #2
+// CHECK: movs r3, #3
+//
+// Lowest bit gets cleared on callee address
+// CHECK: bic r12, r12, #1
+//
+// Ununsed registers get cleared (r4..=r11)
+// CHECK: mov r4,
+// CHECK: mov r5,
+// CHECK: mov r6,
+// CHECK: mov r7,
+// CHECK: mov r8,
+// CHECK: mov r9,
+// CHECK: mov r10,
+// CHECK: mov r11,
+//
+// Flags get cleared
+// CHECK: msr apsr_nzcvq,
+//
+// Call to non-secure
+// CHECK: blxns r12
+#[no_mangle]
+pub fn call_nonsecure(f: unsafe extern "cmse-nonsecure-call" fn(u32, u32, u32, u32) -> u64) -> u64 {
+    unsafe { f(0, 1, 2, 3) }
+}
diff --git a/tests/assembly-llvm/compiletest-self-test/use-minicore-no-run.rs b/tests/assembly-llvm/compiletest-self-test/use-minicore-no-run.rs
new file mode 100644
index 00000000000..0e4f05c4b37
--- /dev/null
+++ b/tests/assembly-llvm/compiletest-self-test/use-minicore-no-run.rs
@@ -0,0 +1,5 @@
+//! `compiletest` self-test to check that `add-core-stubs` is incompatible with run pass modes.
+
+//@ add-core-stubs
+//@ run-pass
+//@ should-fail
diff --git a/tests/assembly-llvm/cstring-merging.rs b/tests/assembly-llvm/cstring-merging.rs
new file mode 100644
index 00000000000..03688e0068b
--- /dev/null
+++ b/tests/assembly-llvm/cstring-merging.rs
@@ -0,0 +1,30 @@
+// MIPS assembler uses the label prefix `$anon.` for local anonymous variables
+// other architectures (including ARM and x86-64) use the prefix `.Lanon.`
+//@ only-linux
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -Cllvm-args=-enable-global-merge=0
+//@ edition: 2024
+
+use std::ffi::CStr;
+
+// CHECK: .section .rodata.str1.{{[12]}},"aMS"
+// CHECK: {{(\.L|\$)}}anon.{{.+}}:
+// CHECK-NEXT: .asciz "foo"
+#[unsafe(no_mangle)]
+static CSTR: &[u8; 4] = b"foo\0";
+
+// CHECK-NOT: .section
+// CHECK: {{(\.L|\$)}}anon.{{.+}}:
+// CHECK-NEXT: .asciz "bar"
+#[unsafe(no_mangle)]
+pub fn cstr() -> &'static CStr {
+    c"bar"
+}
+
+// CHECK-NOT: .section
+// CHECK: {{(\.L|\$)}}anon.{{.+}}:
+// CHECK-NEXT: .asciz "baz"
+#[unsafe(no_mangle)]
+pub fn manual_cstr() -> &'static str {
+    "baz\0"
+}
diff --git a/tests/assembly-llvm/dwarf-mixed-versions-lto.rs b/tests/assembly-llvm/dwarf-mixed-versions-lto.rs
new file mode 100644
index 00000000000..9910a6e2f5f
--- /dev/null
+++ b/tests/assembly-llvm/dwarf-mixed-versions-lto.rs
@@ -0,0 +1,20 @@
+// This test ensures that if LTO occurs between crates with different DWARF versions, we
+// will choose the highest DWARF version for the final binary. This matches Clang's behavior.
+// Note: `.2byte` directive is used on MIPS.
+
+//@ only-linux
+//@ aux-build:dwarf-mixed-versions-lto-aux.rs
+//@ compile-flags: -C lto -g -Cdwarf-version=5
+//@ assembly-output: emit-asm
+//@ no-prefer-dynamic
+
+extern crate dwarf_mixed_versions_lto_aux;
+
+fn main() {
+    dwarf_mixed_versions_lto_aux::check_is_even(&0);
+}
+
+// CHECK: .section .debug_info
+// CHECK-NOT: {{\.(short|hword|2byte)}} 2
+// CHECK-NOT: {{\.(short|hword|2byte)}} 4
+// CHECK: {{\.(short|hword|2byte)}} 5
diff --git a/tests/assembly-llvm/dwarf4.rs b/tests/assembly-llvm/dwarf4.rs
new file mode 100644
index 00000000000..03a388603b4
--- /dev/null
+++ b/tests/assembly-llvm/dwarf4.rs
@@ -0,0 +1,23 @@
+// Makes sure that `-C dwarf-version=4` causes `rustc` to emit DWARF version 4.
+//@ assembly-output: emit-asm
+//@ add-core-stubs
+//@ compile-flags: -g --target x86_64-unknown-linux-gnu -C dwarf-version=4 -Copt-level=0
+//@ needs-llvm-components: x86
+
+#![feature(no_core, lang_items)]
+#![crate_type = "rlib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn wibble() {}
+
+pub struct X;
+
+// CHECK: .section .debug_info
+// CHECK-NOT: .short 2
+// CHECK-NOT: .short 5
+// CHECK: .short 4
+// CHECK-NOT: .section .debug_pubnames
+// CHECK-NOT: .section .debug_pubtypes
diff --git a/tests/assembly-llvm/dwarf5.rs b/tests/assembly-llvm/dwarf5.rs
new file mode 100644
index 00000000000..9bd92cc0d09
--- /dev/null
+++ b/tests/assembly-llvm/dwarf5.rs
@@ -0,0 +1,20 @@
+// Makes sure that `-C dwarf-version=5` causes `rustc` to emit DWARF version 5.
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: -g --target x86_64-unknown-linux-gnu -C dwarf-version=5 -Copt-level=0
+//@ needs-llvm-components: x86
+
+#![feature(no_core, lang_items)]
+#![crate_type = "rlib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn wibble() {}
+
+// CHECK: .section .debug_info
+// CHECK-NOT: .short 2
+// CHECK-NOT: .short 4
+// CHECK: .short 5
+// CHECK: .section .debug_names
diff --git a/tests/assembly-llvm/emit-intel-att-syntax.rs b/tests/assembly-llvm/emit-intel-att-syntax.rs
new file mode 100644
index 00000000000..7b479a0f79e
--- /dev/null
+++ b/tests/assembly-llvm/emit-intel-att-syntax.rs
@@ -0,0 +1,75 @@
+//@ assembly-output: emit-asm
+//@ revisions: att intel
+//@ [att] compile-flags: -Cllvm-args=-x86-asm-syntax=att
+//@ [intel] compile-flags: -Cllvm-args=-x86-asm-syntax=intel
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: naked_att:
+// intel-CHECK: mov rax, qword ptr [rdi]
+// intel-CHECK: ret
+// att-CHECK: movq (%rdi), %rax
+// att-CHECK: retq
+
+#[unsafe(naked)]
+#[unsafe(no_mangle)]
+extern "sysv64" fn naked_att() {
+    std::arch::naked_asm!(
+        "
+        movq (%rdi), %rax
+        retq
+        ",
+        options(att_syntax),
+    );
+}
+
+// CHECK-LABEL: naked_intel:
+// intel-CHECK: mov rax, rdi
+// intel-CHECK: ret
+// att-CHECK: movq (%rdi), %rax
+// att-CHECK: retq
+
+#[unsafe(naked)]
+#[unsafe(no_mangle)]
+extern "sysv64" fn naked_intel() {
+    std::arch::naked_asm!(
+        "
+        mov rax, rdi
+        ret
+        ",
+        options(),
+    );
+}
+
+// CHECK-LABEL: global_att:
+// intel-CHECK: mov rax, rdi
+// intel-CHECK: ret
+// att-CHECK: movq (%rdi), %rax
+// att-CHECK: retq
+
+core::arch::global_asm!(
+    "
+    .globl global_att
+    global_att:
+        movq (%rdi), %rax
+        retq
+    ",
+    options(att_syntax),
+);
+
+// CHECK-LABEL: global_intel:
+// intel-CHECK: mov rax, rdi
+// intel-CHECK: ret
+// att-CHECK: movq (%rdi), %rax
+// att-CHECK: retq
+
+core::arch::global_asm!(
+    "
+    .globl global_intel
+    global_intel:
+        mov rax, rdi
+        ret
+    ",
+    options(),
+);
diff --git a/tests/assembly-llvm/is_aligned.rs b/tests/assembly-llvm/is_aligned.rs
new file mode 100644
index 00000000000..ab8f7dea808
--- /dev/null
+++ b/tests/assembly-llvm/is_aligned.rs
@@ -0,0 +1,55 @@
+//@ assembly-output: emit-asm
+//@ only-x86_64
+//@ ignore-sgx
+//@ revisions: opt-speed opt-size
+//@ [opt-speed] compile-flags: -Copt-level=2 -Cdebug-assertions=no
+//@ [opt-size] compile-flags: -Copt-level=s -Cdebug-assertions=no
+#![crate_type = "rlib"]
+#![feature(core_intrinsics)]
+#![feature(pointer_is_aligned_to)]
+
+// CHECK-LABEL: is_aligned_to_unchecked
+// CHECK: decq
+// CHECK-NEXT: testq
+// CHECK-NEXT: sete
+// CHECK: retq
+#[no_mangle]
+pub unsafe fn is_aligned_to_unchecked(ptr: *const u8, align: usize) -> bool {
+    unsafe { std::intrinsics::assume(align.is_power_of_two()) }
+    ptr.is_aligned_to(align)
+}
+
+// CHECK-LABEL: is_aligned_1
+// CHECK: movb $1
+// CHECK: retq
+#[no_mangle]
+pub fn is_aligned_1(ptr: *const u8) -> bool {
+    ptr.is_aligned()
+}
+
+// CHECK-LABEL: is_aligned_2
+// CHECK: testb $1
+// CHECK-NEXT: sete
+// CHECK: retq
+#[no_mangle]
+pub fn is_aligned_2(ptr: *const u16) -> bool {
+    ptr.is_aligned()
+}
+
+// CHECK-LABEL: is_aligned_4
+// CHECK: testb $3
+// CHECK-NEXT: sete
+// CHECK: retq
+#[no_mangle]
+pub fn is_aligned_4(ptr: *const u32) -> bool {
+    ptr.is_aligned()
+}
+
+// CHECK-LABEL: is_aligned_8
+// CHECK: testb $7
+// CHECK-NEXT: sete
+// CHECK: retq
+#[no_mangle]
+pub fn is_aligned_8(ptr: *const u64) -> bool {
+    ptr.is_aligned()
+}
diff --git a/tests/assembly-llvm/issue-83585-small-pod-struct-equality.rs b/tests/assembly-llvm/issue-83585-small-pod-struct-equality.rs
new file mode 100644
index 00000000000..14bec1337f0
--- /dev/null
+++ b/tests/assembly-llvm/issue-83585-small-pod-struct-equality.rs
@@ -0,0 +1,27 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+type T = u8;
+type T1 = (T, T, T, T, T, T, T, T);
+
+// CHECK-LABEL: foo1a
+// CHECK: cmpq
+// CHECK-NEXT: sete
+// CHECK-NEXT: {{retq|popq}}
+#[no_mangle]
+pub fn foo1a(a: T1, b: T1) -> bool {
+    a == b
+}
+
+// CHECK-LABEL: foo1b
+// CHECK: movq
+// CHECK: cmpq
+// CHECK-NEXT: sete
+// CHECK-NEXT: {{retq|popq}}
+#[no_mangle]
+pub fn foo1b(a: &T1, b: &T1) -> bool {
+    a == b
+}
diff --git a/tests/assembly-llvm/libs/issue-115339-zip-arrays.rs b/tests/assembly-llvm/libs/issue-115339-zip-arrays.rs
new file mode 100644
index 00000000000..098382502e8
--- /dev/null
+++ b/tests/assembly-llvm/libs/issue-115339-zip-arrays.rs
@@ -0,0 +1,25 @@
+//@ assembly-output: emit-asm
+// # zen3 previously exhibited odd vectorization
+//@ compile-flags: --crate-type=lib -Ctarget-cpu=znver3 -Copt-level=3
+//@ only-x86_64
+//@ ignore-sgx
+
+use std::iter;
+
+// previously this produced a long chain of
+// 56:  vpextrb $6, %xmm0, %ecx
+// 57:  orb %cl, 22(%rsi)
+// 58:  vpextrb $7, %xmm0, %ecx
+// 59:  orb %cl, 23(%rsi)
+// [...]
+
+// CHECK-LABEL: zip_arrays:
+#[no_mangle]
+pub fn zip_arrays(mut a: [u8; 32], b: [u8; 32]) -> [u8; 32] {
+    // CHECK-NOT: vpextrb
+    // CHECK-NOT: orb %cl
+    // CHECK: vorps
+    iter::zip(&mut a, b).for_each(|(a, b)| *a |= b);
+    // CHECK: retq
+    a
+}
diff --git a/tests/assembly-llvm/libs/issue-140207-slice-min-simd.rs b/tests/assembly-llvm/libs/issue-140207-slice-min-simd.rs
new file mode 100644
index 00000000000..86f067cac08
--- /dev/null
+++ b/tests/assembly-llvm/libs/issue-140207-slice-min-simd.rs
@@ -0,0 +1,13 @@
+//@ assembly-output: emit-asm
+// # avx has a dedicated instruction for this
+//@ compile-flags: --crate-type=lib -Ctarget-cpu=znver2 -Copt-level=3
+//@ only-x86_64
+//@ ignore-sgx
+// https://github.com/rust-lang/rust/issues/140207
+
+#[unsafe(no_mangle)]
+pub fn array_min(a: &[u16; 8]) -> u16 {
+    // CHECK: vphminposuw
+    // CHECK: ret
+    a.iter().copied().min().unwrap()
+}
diff --git a/tests/assembly-llvm/manual-eq-efficient.rs b/tests/assembly-llvm/manual-eq-efficient.rs
new file mode 100644
index 00000000000..8dafed354be
--- /dev/null
+++ b/tests/assembly-llvm/manual-eq-efficient.rs
@@ -0,0 +1,22 @@
+// Regression test for #106269
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C llvm-args=-x86-asm-syntax=intel
+//@ only-x86_64
+//@ ignore-sgx
+
+pub struct S {
+    a: u8,
+    b: u8,
+    c: u8,
+    d: u8,
+}
+
+// CHECK-LABEL: manual_eq:
+#[no_mangle]
+pub fn manual_eq(s1: &S, s2: &S) -> bool {
+    // CHECK: mov [[REG:[a-z0-9]+]], dword ptr [{{[a-z0-9]+}}]
+    // CHECK-NEXT: cmp [[REG]], dword ptr [{{[a-z0-9]+}}]
+    // CHECK-NEXT: sete al
+    // CHECK: ret
+    s1.a == s2.a && s1.b == s2.b && s1.c == s2.c && s1.d == s2.d
+}
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
new file mode 100644
index 00000000000..860ecc3cfcd
--- /dev/null
+++ b/tests/assembly-llvm/naked-functions/aarch64-naked-fn-no-bti-prolog.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -C no-prepopulate-passes -Zbranch-protection=bti
+//@ assembly-output: emit-asm
+//@ needs-asm-support
+//@ only-aarch64
+
+#![crate_type = "lib"]
+
+use std::arch::naked_asm;
+
+// The problem at hand: Rust has adopted a fairly strict meaning for "naked functions",
+// meaning "no prologue whatsoever, no, really, not one instruction."
+// Unfortunately, aarch64's "branch target identification" works via hints at landing sites.
+// LLVM implements this via making sure of that, even for functions with the naked attribute.
+// So, we must emit an appropriate instruction instead!
+#[no_mangle]
+#[unsafe(naked)]
+pub extern "C" fn _hlt() -> ! {
+    // CHECK-NOT: hint #34
+    // CHECK: hlt #0x1
+    naked_asm!("hlt #1")
+}
diff --git a/tests/assembly-llvm/naked-functions/aix.rs b/tests/assembly-llvm/naked-functions/aix.rs
new file mode 100644
index 00000000000..57ff0e183be
--- /dev/null
+++ b/tests/assembly-llvm/naked-functions/aix.rs
@@ -0,0 +1,35 @@
+//@ revisions: elfv1-be aix
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//
+//@[elfv1-be] compile-flags: --target powerpc64-unknown-linux-gnu
+//@[elfv1-be] needs-llvm-components: powerpc
+//
+//@[aix] compile-flags: --target powerpc64-ibm-aix
+//@[aix] needs-llvm-components: powerpc
+
+#![crate_type = "lib"]
+#![feature(no_core, asm_experimental_arch, f128, linkage, fn_align)]
+#![no_core]
+
+// tests that naked functions work for the `powerpc64-ibm-aix` target.
+//
+// This target is special because it uses the XCOFF binary format
+// It is tested alongside an elf powerpc target to pin down commonalities and differences.
+//
+// https://doc.rust-lang.org/rustc/platform-support/aix.html
+// https://www.ibm.com/docs/en/aix/7.2?topic=formats-xcoff-object-file-format
+
+extern crate minicore;
+use minicore::*;
+
+// elfv1-be: .p2align 2
+// aix: .align 2
+// CHECK: .globl blr
+// CHECK-LABEL: blr:
+// CHECK: blr
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn blr() {
+    naked_asm!("blr")
+}
diff --git a/tests/assembly-llvm/naked-functions/wasm32.rs b/tests/assembly-llvm/naked-functions/wasm32.rs
new file mode 100644
index 00000000000..77547e82041
--- /dev/null
+++ b/tests/assembly-llvm/naked-functions/wasm32.rs
@@ -0,0 +1,200 @@
+//@ revisions: wasm32-unknown wasm64-unknown wasm32-wasip1
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ [wasm32-unknown] compile-flags: --target wasm32-unknown-unknown
+//@ [wasm64-unknown] compile-flags: --target wasm64-unknown-unknown
+//@ [wasm32-wasip1] compile-flags: --target wasm32-wasip1
+//@ [wasm32-unknown] needs-llvm-components: webassembly
+//@ [wasm64-unknown] needs-llvm-components: webassembly
+//@ [wasm32-wasip1] needs-llvm-components: webassembly
+
+#![crate_type = "lib"]
+#![feature(no_core, asm_experimental_arch, f128, linkage, fn_align)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: .section  .text.nop,"",@
+// CHECK: .globl nop
+// CHECK-LABEL: nop:
+// CHECK: .functype nop () -> ()
+// CHECK-NOT: .size
+// CHECK: end_function
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn nop() {
+    naked_asm!("nop")
+}
+
+// CHECK: .section  .text.weak_nop,"",@
+// CHECK: .weak weak_nop
+// CHECK-LABEL: nop:
+// CHECK: .functype weak_nop () -> ()
+// CHECK-NOT: .size
+// CHECK: end_function
+#[no_mangle]
+#[unsafe(naked)]
+#[linkage = "weak"]
+extern "C" fn weak_nop() {
+    naked_asm!("nop")
+}
+
+// CHECK-LABEL: fn_i8_i8:
+// CHECK-NEXT: .functype fn_i8_i8 (i32) -> (i32)
+//
+// CHECK-NEXT: local.get 0
+// CHECK-NEXT: local.get 0
+// CHECK-NEXT: i32.mul
+//
+// CHECK-NEXT: end_function
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_i8_i8(num: i8) -> i8 {
+    naked_asm!("local.get 0", "local.get 0", "i32.mul")
+}
+
+// CHECK-LABEL: fn_i8_i8_i8:
+// CHECK: .functype fn_i8_i8_i8 (i32, i32) -> (i32)
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_i8_i8_i8(a: i8, b: i8) -> i8 {
+    naked_asm!("local.get 1", "local.get 0", "i32.mul")
+}
+
+// CHECK-LABEL: fn_unit_i8:
+// CHECK: .functype fn_unit_i8 () -> (i32)
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_unit_i8() -> i8 {
+    naked_asm!("i32.const 42")
+}
+
+// CHECK-LABEL: fn_i8_unit:
+// CHECK: .functype fn_i8_unit (i32) -> ()
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_i8_unit(_: i8) {
+    naked_asm!("nop")
+}
+
+// CHECK-LABEL: fn_i32_i32:
+// CHECK: .functype fn_i32_i32 (i32) -> (i32)
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_i32_i32(num: i32) -> i32 {
+    naked_asm!("local.get 0", "local.get 0", "i32.mul")
+}
+
+// CHECK-LABEL: fn_i64_i64:
+// CHECK: .functype fn_i64_i64 (i64) -> (i64)
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_i64_i64(num: i64) -> i64 {
+    naked_asm!("local.get 0", "local.get 0", "i64.mul")
+}
+
+// CHECK-LABEL: fn_i128_i128:
+// wasm32-unknown: .functype fn_i128_i128 (i32, i64, i64) -> ()
+// wasm32-wasip1: .functype fn_i128_i128 (i32, i64, i64) -> ()
+// wasm64-unknown: .functype fn_i128_i128 (i64, i64, i64) -> ()
+#[allow(improper_ctypes_definitions)]
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_i128_i128(num: i128) -> i128 {
+    naked_asm!(
+        "local.get       0",
+        "local.get       2",
+        "i64.store       8",
+        "local.get       0",
+        "local.get       1",
+        "i64.store       0",
+    )
+}
+
+// CHECK-LABEL: fn_f128_f128:
+// wasm32-unknown: .functype fn_f128_f128 (i32, i64, i64) -> ()
+// wasm32-wasip1: .functype fn_f128_f128 (i32, i64, i64) -> ()
+// wasm64-unknown: .functype fn_f128_f128 (i64, i64, i64) -> ()
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_f128_f128(num: f128) -> f128 {
+    naked_asm!(
+        "local.get       0",
+        "local.get       2",
+        "i64.store       8",
+        "local.get       0",
+        "local.get       1",
+        "i64.store       0",
+    )
+}
+
+#[repr(C)]
+struct Compound {
+    a: u16,
+    b: i64,
+}
+
+// CHECK-LABEL: fn_compound_compound:
+// wasm32-unknown: .functype fn_compound_compound (i32, i32) -> ()
+// wasm32-wasip1: .functype fn_compound_compound (i32, i32) -> ()
+// wasm64-unknown: .functype fn_compound_compound (i64, i64) -> ()
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_compound_compound(_: Compound) -> Compound {
+    // this is the wasm32-wasip1 assembly
+    naked_asm!(
+        "local.get       0",
+        "local.get       1",
+        "i64.load        8",
+        "i64.store       8",
+        "local.get       0",
+        "local.get       1",
+        "i32.load16_u    0",
+        "i32.store16     0",
+    )
+}
+
+#[repr(C)]
+struct WrapperI32(i32);
+
+// CHECK-LABEL: fn_wrapperi32_wrapperi32:
+// CHECK: .functype fn_wrapperi32_wrapperi32 (i32) -> (i32)
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_wrapperi32_wrapperi32(_: WrapperI32) -> WrapperI32 {
+    naked_asm!("local.get       0")
+}
+
+#[repr(C)]
+struct WrapperI64(i64);
+
+// CHECK-LABEL: fn_wrapperi64_wrapperi64:
+// CHECK: .functype fn_wrapperi64_wrapperi64 (i64) -> (i64)
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_wrapperi64_wrapperi64(_: WrapperI64) -> WrapperI64 {
+    naked_asm!("local.get       0")
+}
+
+#[repr(C)]
+struct WrapperF32(f32);
+
+// CHECK-LABEL: fn_wrapperf32_wrapperf32:
+// CHECK: .functype fn_wrapperf32_wrapperf32 (f32) -> (f32)
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_wrapperf32_wrapperf32(_: WrapperF32) -> WrapperF32 {
+    naked_asm!("local.get       0")
+}
+
+#[repr(C)]
+struct WrapperF64(f64);
+
+// CHECK-LABEL: fn_wrapperf64_wrapperf64:
+// CHECK: .functype fn_wrapperf64_wrapperf64 (f64) -> (f64)
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn fn_wrapperf64_wrapperf64(_: WrapperF64) -> WrapperF64 {
+    naked_asm!("local.get       0")
+}
diff --git a/tests/assembly-llvm/naked-functions/x86_64-naked-fn-no-cet-prolog.rs b/tests/assembly-llvm/naked-functions/x86_64-naked-fn-no-cet-prolog.rs
new file mode 100644
index 00000000000..81ee9b13b4e
--- /dev/null
+++ b/tests/assembly-llvm/naked-functions/x86_64-naked-fn-no-cet-prolog.rs
@@ -0,0 +1,24 @@
+//@ compile-flags: -C no-prepopulate-passes -Zcf-protection=full
+//@ assembly-output: emit-asm
+//@ needs-asm-support
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+use std::arch::naked_asm;
+
+// The problem at hand: Rust has adopted a fairly strict meaning for "naked functions",
+// meaning "no prologue whatsoever, no, really, not one instruction."
+// Unfortunately, x86's control-flow enforcement, specifically indirect branch protection,
+// works by using an instruction for each possible landing site,
+// and LLVM implements this via making sure of that.
+#[no_mangle]
+#[unsafe(naked)]
+pub extern "sysv64" fn will_halt() -> ! {
+    // CHECK-NOT: endbr{{32|64}}
+    // CHECK: hlt
+    naked_asm!("hlt")
+}
+
+// what about aarch64?
+// "branch-protection"=false
diff --git a/tests/assembly-llvm/niche-prefer-zero.rs b/tests/assembly-llvm/niche-prefer-zero.rs
new file mode 100644
index 00000000000..4e260ebc09b
--- /dev/null
+++ b/tests/assembly-llvm/niche-prefer-zero.rs
@@ -0,0 +1,25 @@
+// Check that niche selection prefers zero and that jumps are optimized away.
+// See https://github.com/rust-lang/rust/pull/87794
+//@ assembly-output: emit-asm
+//@ only-x86
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[repr(u8)]
+pub enum Size {
+    One = 1,
+    Two = 2,
+    Three = 3,
+}
+
+#[no_mangle]
+pub fn handle(x: Option<Size>) -> u8 {
+    match x {
+        None => 0,
+        Some(size) => size as u8,
+    }
+}
+
+// There should be no jumps in output
+// CHECK-NOT: j
diff --git a/tests/assembly-llvm/nvptx-arch-default.rs b/tests/assembly-llvm/nvptx-arch-default.rs
new file mode 100644
index 00000000000..a621fd6dcb2
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-arch-default.rs
@@ -0,0 +1,12 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type cdylib -Z unstable-options -Clinker-flavor=llbc
+//@ only-nvptx64
+
+#![no_std]
+
+//@ aux-build: breakpoint-panic-handler.rs
+extern crate breakpoint_panic_handler;
+
+// Verify default target arch with ptx-linker.
+// CHECK: .target sm_30
+// CHECK: .address_size 64
diff --git a/tests/assembly-llvm/nvptx-arch-emit-asm.rs b/tests/assembly-llvm/nvptx-arch-emit-asm.rs
new file mode 100644
index 00000000000..e47f8e78e36
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-arch-emit-asm.rs
@@ -0,0 +1,9 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type rlib
+//@ only-nvptx64
+
+#![no_std]
+
+// Verify default arch without ptx-linker involved.
+// CHECK: .target sm_30
+// CHECK: .address_size 64
diff --git a/tests/assembly-llvm/nvptx-arch-link-arg.rs b/tests/assembly-llvm/nvptx-arch-link-arg.rs
new file mode 100644
index 00000000000..3432e6161bf
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-arch-link-arg.rs
@@ -0,0 +1,13 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type cdylib -C link-arg=--arch=sm_60
+//@ only-nvptx64
+//@ ignore-nvptx64
+
+#![no_std]
+
+//@ aux-build: breakpoint-panic-handler.rs
+extern crate breakpoint_panic_handler;
+
+// Verify target arch override via `link-arg`.
+// CHECK: .target sm_60
+// CHECK: .address_size 64
diff --git a/tests/assembly-llvm/nvptx-arch-target-cpu.rs b/tests/assembly-llvm/nvptx-arch-target-cpu.rs
new file mode 100644
index 00000000000..609ab297e63
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-arch-target-cpu.rs
@@ -0,0 +1,12 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type cdylib -C target-cpu=sm_50 -Z unstable-options -Clinker-flavor=llbc
+//@ only-nvptx64
+
+#![no_std]
+
+//@ aux-build: breakpoint-panic-handler.rs
+extern crate breakpoint_panic_handler;
+
+// Verify target arch override via `target-cpu`.
+// CHECK: .target sm_50
+// CHECK: .address_size 64
diff --git a/tests/assembly-llvm/nvptx-atomics.rs b/tests/assembly-llvm/nvptx-atomics.rs
new file mode 100644
index 00000000000..52b8c86d8a9
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-atomics.rs
@@ -0,0 +1,86 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type cdylib
+//@ only-nvptx64
+//@ ignore-nvptx64
+
+#![feature(abi_ptx, core_intrinsics)]
+#![no_std]
+
+use core::intrinsics::*;
+
+//@ aux-build: breakpoint-panic-handler.rs
+extern crate breakpoint_panic_handler;
+
+// Currently, LLVM NVPTX backend can only emit atomic instructions with
+// `relaxed` (PTX default) ordering. But it's also useful to make sure
+// the backend won't fail with other orders. Apparently, the backend
+// doesn't support fences as well. As a workaround `llvm.nvvm.membar.*`
+// could work, and perhaps on the long run, all the atomic operations
+// should rather be provided by `core::arch::nvptx`.
+
+// Also, PTX ISA doesn't have atomic `load`, `store` and `nand`.
+
+// FIXME(denzp): add tests for `core::sync::atomic::*`.
+
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn atomics_kernel(a: *mut u32) {
+    // CHECK: atom.global.and.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    // CHECK: atom.global.and.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    atomic_and(a, 1);
+    atomic_and_relaxed(a, 1);
+
+    // CHECK: atom.global.cas.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1, 2;
+    // CHECK: atom.global.cas.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1, 2;
+    atomic_cxchg(a, 1, 2);
+    atomic_cxchg_relaxed(a, 1, 2);
+
+    // CHECK: atom.global.max.s32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    // CHECK: atom.global.max.s32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    atomic_max(a, 1);
+    atomic_max_relaxed(a, 1);
+
+    // CHECK: atom.global.min.s32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    // CHECK: atom.global.min.s32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    atomic_min(a, 1);
+    atomic_min_relaxed(a, 1);
+
+    // CHECK: atom.global.or.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    // CHECK: atom.global.or.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    atomic_or(a, 1);
+    atomic_or_relaxed(a, 1);
+
+    // CHECK: atom.global.max.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    // CHECK: atom.global.max.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    atomic_umax(a, 1);
+    atomic_umax_relaxed(a, 1);
+
+    // CHECK: atom.global.min.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    // CHECK: atom.global.min.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    atomic_umin(a, 1);
+    atomic_umin_relaxed(a, 1);
+
+    // CHECK: atom.global.add.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    // CHECK: atom.global.add.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    atomic_xadd(a, 1);
+    atomic_xadd_relaxed(a, 1);
+
+    // CHECK: atom.global.exch.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    // CHECK: atom.global.exch.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    atomic_xchg(a, 1);
+    atomic_xchg_relaxed(a, 1);
+
+    // CHECK: atom.global.xor.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    // CHECK: atom.global.xor.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
+    atomic_xor(a, 1);
+    atomic_xor_relaxed(a, 1);
+
+    // CHECK: mov.u32 %[[sub_0_arg:r[0-9]+]], 100;
+    // CHECK: neg.s32 temp, %[[sub_0_arg]];
+    // CHECK: atom.global.add.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], temp;
+    atomic_xsub(a, 100);
+
+    // CHECK: mov.u32 %[[sub_1_arg:r[0-9]+]], 200;
+    // CHECK: neg.s32 temp, %[[sub_1_arg]];
+    // CHECK: atom.global.add.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], temp;
+    atomic_xsub_relaxed(a, 200);
+}
diff --git a/tests/assembly-llvm/nvptx-c-abi-arg-v7.rs b/tests/assembly-llvm/nvptx-c-abi-arg-v7.rs
new file mode 100644
index 00000000000..be98b167470
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-c-abi-arg-v7.rs
@@ -0,0 +1,220 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type cdylib -C target-cpu=sm_86 -Z unstable-options -Clinker-flavor=llbc
+//@ only-nvptx64
+
+// The PTX ABI stability is tied to major versions of the PTX ISA
+// These tests assume major version 7
+
+// CHECK: .version 7
+
+#![feature(abi_ptx, lang_items, no_core)]
+#![no_core]
+
+#[lang = "pointee_sized"]
+trait PointeeSized {}
+#[lang = "meta_sized"]
+trait MetaSized: PointeeSized {}
+#[lang = "sized"]
+trait Sized: MetaSized {}
+#[lang = "copy"]
+trait Copy {}
+
+#[repr(C)]
+pub struct SingleU8 {
+    f: u8,
+}
+
+#[repr(C)]
+pub struct DoubleU8 {
+    f: u8,
+    g: u8,
+}
+
+#[repr(C)]
+pub struct TripleU8 {
+    f: u8,
+    g: u8,
+    h: u8,
+}
+
+#[repr(C)]
+pub struct TripleU16 {
+    f: u16,
+    g: u16,
+    h: u16,
+}
+#[repr(C)]
+pub struct DoubleI32 {
+    f: i32,
+    g: i32,
+}
+#[repr(C)]
+pub struct TripleU32 {
+    f: u32,
+    g: u32,
+    h: u32,
+}
+#[repr(C)]
+pub struct TripleU64 {
+    f: u64,
+    g: u64,
+    h: u64,
+}
+
+#[repr(C)]
+pub struct DoubleFloat {
+    f: f32,
+    g: f32,
+}
+
+#[repr(C)]
+pub struct TripleFloat {
+    f: f32,
+    g: f32,
+    h: f32,
+}
+
+#[repr(C)]
+pub struct TripleDouble {
+    f: f64,
+    g: f64,
+    h: f64,
+}
+
+#[repr(C)]
+pub struct ManyIntegers {
+    f: u8,
+    g: u16,
+    h: u32,
+    i: u64,
+}
+
+#[repr(C)]
+pub struct ManyNumerics {
+    f: u8,
+    g: u16,
+    h: u32,
+    i: u64,
+    j: f32,
+    k: f64,
+}
+
+// CHECK: .visible .func f_u8_arg(
+// CHECK: .param .b32 f_u8_arg_param_0
+#[no_mangle]
+pub unsafe extern "C" fn f_u8_arg(_a: u8) {}
+
+// CHECK: .visible .func f_u16_arg(
+// CHECK: .param .b32 f_u16_arg_param_0
+#[no_mangle]
+pub unsafe extern "C" fn f_u16_arg(_a: u16) {}
+
+// CHECK: .visible .func f_u32_arg(
+// CHECK: .param .b32 f_u32_arg_param_0
+#[no_mangle]
+pub unsafe extern "C" fn f_u32_arg(_a: u32) {}
+
+// CHECK: .visible .func f_u64_arg(
+// CHECK: .param .b64 f_u64_arg_param_0
+#[no_mangle]
+pub unsafe extern "C" fn f_u64_arg(_a: u64) {}
+
+// CHECK: .visible .func f_u128_arg(
+// CHECK: .param .align 16 .b8 f_u128_arg_param_0[16]
+#[no_mangle]
+pub unsafe extern "C" fn f_u128_arg(_a: u128) {}
+
+// CHECK: .visible .func f_i8_arg(
+// CHECK: .param .b32 f_i8_arg_param_0
+#[no_mangle]
+pub unsafe extern "C" fn f_i8_arg(_a: i8) {}
+
+// CHECK: .visible .func f_i16_arg(
+// CHECK: .param .b32 f_i16_arg_param_0
+#[no_mangle]
+pub unsafe extern "C" fn f_i16_arg(_a: i16) {}
+
+// CHECK: .visible .func f_i32_arg(
+// CHECK: .param .b32 f_i32_arg_param_0
+#[no_mangle]
+pub unsafe extern "C" fn f_i32_arg(_a: i32) {}
+
+// CHECK: .visible .func f_i64_arg(
+// CHECK: .param .b64 f_i64_arg_param_0
+#[no_mangle]
+pub unsafe extern "C" fn f_i64_arg(_a: i64) {}
+
+// CHECK: .visible .func f_i128_arg(
+// CHECK: .param .align 16 .b8 f_i128_arg_param_0[16]
+#[no_mangle]
+pub unsafe extern "C" fn f_i128_arg(_a: i128) {}
+
+// CHECK: .visible .func f_f32_arg(
+// CHECK: .param .b32 f_f32_arg_param_0
+#[no_mangle]
+pub unsafe extern "C" fn f_f32_arg(_a: f32) {}
+
+// CHECK: .visible .func f_f64_arg(
+// CHECK: .param .b64 f_f64_arg_param_0
+#[no_mangle]
+pub unsafe extern "C" fn f_f64_arg(_a: f64) {}
+
+// CHECK: .visible .func f_single_u8_arg(
+// CHECK: .param .align 1 .b8 f_single_u8_arg_param_0[1]
+#[no_mangle]
+pub unsafe extern "C" fn f_single_u8_arg(_a: SingleU8) {}
+
+// CHECK: .visible .func f_double_u8_arg(
+// CHECK: .param .align 1 .b8 f_double_u8_arg_param_0[2]
+#[no_mangle]
+pub unsafe extern "C" fn f_double_u8_arg(_a: DoubleU8) {}
+
+// CHECK: .visible .func f_triple_u8_arg(
+// CHECK: .param .align 1 .b8 f_triple_u8_arg_param_0[3]
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_u8_arg(_a: TripleU8) {}
+
+// CHECK: .visible .func f_triple_u16_arg(
+// CHECK: .param .align 2 .b8 f_triple_u16_arg_param_0[6]
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_u16_arg(_a: TripleU16) {}
+
+// CHECK: .visible .func f_triple_u32_arg(
+// CHECK: .param .align 4 .b8 f_triple_u32_arg_param_0[12]
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_u32_arg(_a: TripleU32) {}
+
+// CHECK: .visible .func f_double_i32_arg(
+// CHECK: .param .align 4 .b8 f_double_i32_arg_param_0[8]
+#[no_mangle]
+pub unsafe extern "C" fn f_double_i32_arg(_a: DoubleI32) {}
+
+// CHECK: .visible .func f_triple_u64_arg(
+// CHECK: .param .align 8 .b8 f_triple_u64_arg_param_0[24]
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_u64_arg(_a: TripleU64) {}
+
+// CHECK: .visible .func f_many_integers_arg(
+// CHECK: .param .align 8 .b8 f_many_integers_arg_param_0[16]
+#[no_mangle]
+pub unsafe extern "C" fn f_many_integers_arg(_a: ManyIntegers) {}
+
+// CHECK: .visible .func f_double_float_arg(
+// CHECK: .param .align 4 .b8 f_double_float_arg_param_0[8]
+#[no_mangle]
+pub unsafe extern "C" fn f_double_float_arg(_a: DoubleFloat) {}
+
+// CHECK: .visible .func f_triple_float_arg(
+// CHECK: .param .align 4 .b8 f_triple_float_arg_param_0[12]
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_float_arg(_a: TripleFloat) {}
+
+// CHECK: .visible .func f_triple_double_arg(
+// CHECK: .param .align 8 .b8 f_triple_double_arg_param_0[24]
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_double_arg(_a: TripleDouble) {}
+
+// CHECK: .visible .func f_many_numerics_arg(
+// CHECK: .param .align 8 .b8 f_many_numerics_arg_param_0[32]
+#[no_mangle]
+pub unsafe extern "C" fn f_many_numerics_arg(_a: ManyNumerics) {}
diff --git a/tests/assembly-llvm/nvptx-c-abi-ret-v7.rs b/tests/assembly-llvm/nvptx-c-abi-ret-v7.rs
new file mode 100644
index 00000000000..c68c71c872c
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-c-abi-ret-v7.rs
@@ -0,0 +1,244 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type cdylib -C target-cpu=sm_86 -Z unstable-options -Clinker-flavor=llbc
+//@ only-nvptx64
+
+// The PTX ABI stability is tied to major versions of the PTX ISA
+// These tests assume major version 7
+
+// CHECK: .version 7
+
+#![feature(abi_ptx, lang_items, no_core)]
+#![no_core]
+
+#[lang = "pointee_sized"]
+trait PointeeSized {}
+#[lang = "meta_sized"]
+trait MetaSized: PointeeSized {}
+#[lang = "sized"]
+trait Sized: MetaSized {}
+#[lang = "copy"]
+trait Copy {}
+
+#[repr(C)]
+pub struct SingleU8 {
+    f: u8,
+}
+
+#[repr(C)]
+pub struct DoubleU8 {
+    f: u8,
+    g: u8,
+}
+
+#[repr(C)]
+pub struct TripleU8 {
+    f: u8,
+    g: u8,
+    h: u8,
+}
+
+#[repr(C)]
+pub struct TripleU16 {
+    f: u16,
+    g: u16,
+    h: u16,
+}
+#[repr(C)]
+pub struct DoubleI32 {
+    f: i32,
+    g: i32,
+}
+#[repr(C)]
+pub struct TripleU32 {
+    f: u32,
+    g: u32,
+    h: u32,
+}
+#[repr(C)]
+pub struct TripleU64 {
+    f: u64,
+    g: u64,
+    h: u64,
+}
+
+#[repr(C)]
+pub struct DoubleFloat {
+    f: f32,
+    g: f32,
+}
+
+#[repr(C)]
+pub struct TripleFloat {
+    f: f32,
+    g: f32,
+    h: f32,
+}
+
+#[repr(C)]
+pub struct TripleDouble {
+    f: f64,
+    g: f64,
+    h: f64,
+}
+
+#[repr(C)]
+pub struct ManyIntegers {
+    f: u8,
+    g: u16,
+    h: u32,
+    i: u64,
+}
+
+#[repr(C)]
+pub struct ManyNumerics {
+    f: u8,
+    g: u16,
+    h: u32,
+    i: u64,
+    j: f32,
+    k: f64,
+}
+
+// CHECK: .visible .func (.param .b32 func_retval0) f_u8_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_u8_ret() -> u8 {
+    0
+}
+
+// CHECK: .visible .func (.param .b32 func_retval0) f_u16_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_u16_ret() -> u16 {
+    1
+}
+
+// CHECK: .visible .func (.param .b32 func_retval0) f_u32_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_u32_ret() -> u32 {
+    2
+}
+
+// CHECK: .visible .func (.param .b64 func_retval0) f_u64_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_u64_ret() -> u64 {
+    3
+}
+
+// CHECK: .visible .func (.param .align 16 .b8 func_retval0[16]) f_u128_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_u128_ret() -> u128 {
+    4
+}
+
+// CHECK: .visible .func (.param .b32 func_retval0) f_i8_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_i8_ret() -> i8 {
+    5
+}
+
+// CHECK: .visible .func (.param .b32 func_retval0) f_i16_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_i16_ret() -> i16 {
+    6
+}
+
+// CHECK: .visible .func (.param .b32 func_retval0) f_i32_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_i32_ret() -> i32 {
+    7
+}
+
+// CHECK: .visible .func (.param .b64 func_retval0) f_i64_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_i64_ret() -> i64 {
+    8
+}
+
+// CHECK: .visible .func  (.param .align 16 .b8 func_retval0[16]) f_i128_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_i128_ret() -> i128 {
+    9
+}
+
+// CHECK: .visible .func (.param .b32 func_retval0) f_f32_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_f32_ret() -> f32 {
+    10.0
+}
+
+// CHECK: .visible .func (.param .b64 func_retval0) f_f64_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_f64_ret() -> f64 {
+    11.0
+}
+
+// CHECK: .visible .func (.param .align 1 .b8 func_retval0[1]) f_single_u8_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_single_u8_ret() -> SingleU8 {
+    SingleU8 { f: 12 }
+}
+
+// CHECK: .visible .func (.param .align 1 .b8 func_retval0[2]) f_double_u8_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_double_u8_ret() -> DoubleU8 {
+    DoubleU8 { f: 13, g: 14 }
+}
+
+// CHECK: .visible .func (.param .align 1 .b8 func_retval0[3]) f_triple_u8_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_u8_ret() -> TripleU8 {
+    TripleU8 { f: 15, g: 16, h: 17 }
+}
+
+// CHECK: .visible .func (.param .align 2 .b8 func_retval0[6]) f_triple_u16_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_u16_ret() -> TripleU16 {
+    TripleU16 { f: 18, g: 19, h: 20 }
+}
+
+// CHECK: .visible .func (.param .align 4 .b8 func_retval0[8]) f_double_i32_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_double_i32_ret() -> DoubleI32 {
+    DoubleI32 { f: 1, g: 2 }
+}
+
+// CHECK: .visible .func (.param .align 4 .b8 func_retval0[12]) f_triple_u32_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_u32_ret() -> TripleU32 {
+    TripleU32 { f: 20, g: 21, h: 22 }
+}
+
+// CHECK: .visible .func (.param .align 8 .b8 func_retval0[24]) f_triple_u64_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_u64_ret() -> TripleU64 {
+    TripleU64 { f: 23, g: 24, h: 25 }
+}
+
+// CHECK: .visible .func (.param .align 8 .b8 func_retval0[16]) f_many_integers_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_many_integers_ret() -> ManyIntegers {
+    ManyIntegers { f: 26, g: 27, h: 28, i: 29 }
+}
+
+// CHECK: .visible .func (.param .align 4 .b8 func_retval0[8]) f_double_float_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_double_float_ret() -> DoubleFloat {
+    DoubleFloat { f: 29.0, g: 30.0 }
+}
+
+// CHECK: .visible .func (.param .align 4 .b8 func_retval0[12]) f_triple_float_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_float_ret() -> TripleFloat {
+    TripleFloat { f: 31.0, g: 32.0, h: 33.0 }
+}
+
+// CHECK: .visible .func (.param .align 8 .b8 func_retval0[24]) f_triple_double_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_triple_double_ret() -> TripleDouble {
+    TripleDouble { f: 34.0, g: 35.0, h: 36.0 }
+}
+
+// CHECK: .visible .func (.param .align 8 .b8 func_retval0[32]) f_many_numerics_ret(
+#[no_mangle]
+pub unsafe extern "C" fn f_many_numerics_ret() -> ManyNumerics {
+    ManyNumerics { f: 37, g: 38, h: 39, i: 40, j: 41.0, k: 43.0 }
+}
diff --git a/tests/assembly-llvm/nvptx-internalizing.rs b/tests/assembly-llvm/nvptx-internalizing.rs
new file mode 100644
index 00000000000..0acfd5c2443
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-internalizing.rs
@@ -0,0 +1,27 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type cdylib
+//@ only-nvptx64
+//@ ignore-nvptx64
+
+#![feature(abi_ptx)]
+#![no_std]
+
+//@ aux-build: breakpoint-panic-handler.rs
+extern crate breakpoint_panic_handler;
+
+//@ aux-build: non-inline-dependency.rs
+extern crate non_inline_dependency as dep;
+
+// Verify that no extra function declarations are present.
+// CHECK-NOT: .func
+
+// CHECK: .visible .entry top_kernel(
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn top_kernel(a: *const u32, b: *mut u32) {
+    // CHECK: add.s32 %{{r[0-9]+}}, %{{r[0-9]+}}, 5;
+    *b = *a + 5;
+}
+
+// Verify that no extra function definitions are here.
+// CHECK-NOT: .func
+// CHECK-NOT: .entry
diff --git a/tests/assembly-llvm/nvptx-kernel-abi/nvptx-kernel-args-abi-v7.rs b/tests/assembly-llvm/nvptx-kernel-abi/nvptx-kernel-args-abi-v7.rs
new file mode 100644
index 00000000000..f245b4460f2
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-kernel-abi/nvptx-kernel-args-abi-v7.rs
@@ -0,0 +1,251 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type cdylib -C target-cpu=sm_86 -Z unstable-options -Clinker-flavor=llbc
+//@ only-nvptx64
+
+// The following ABI tests are made with nvcc 11.6 does.
+//
+// The PTX ABI stability is tied to major versions of the PTX ISA
+// These tests assume major version 7
+//
+//
+// The following correspondence between types are assumed:
+// u<N> - uint<N>_t
+// i<N> - int<N>_t
+// [T, N] - std::array<T, N>
+// &T - T const*
+// &mut T - T*
+
+// CHECK: .version 7
+
+#![feature(abi_ptx, lang_items, no_core)]
+#![no_core]
+
+#[lang = "pointee_sized"]
+trait PointeeSized {}
+#[lang = "meta_sized"]
+trait MetaSized: PointeeSized {}
+#[lang = "sized"]
+trait Sized: MetaSized {}
+#[lang = "copy"]
+trait Copy {}
+
+#[repr(C)]
+pub struct SingleU8 {
+    f: u8,
+}
+
+#[repr(C)]
+pub struct DoubleU8 {
+    f: u8,
+    g: u8,
+}
+
+#[repr(C)]
+pub struct TripleU8 {
+    f: u8,
+    g: u8,
+    h: u8,
+}
+
+#[repr(C)]
+pub struct TripleU16 {
+    f: u16,
+    g: u16,
+    h: u16,
+}
+#[repr(C)]
+pub struct DoubleI32 {
+    f: i32,
+    g: i32,
+}
+#[repr(C)]
+pub struct TripleU32 {
+    f: u32,
+    g: u32,
+    h: u32,
+}
+#[repr(C)]
+pub struct TripleU64 {
+    f: u64,
+    g: u64,
+    h: u64,
+}
+
+#[repr(C)]
+pub struct DoubleFloat {
+    f: f32,
+    g: f32,
+}
+
+#[repr(C)]
+pub struct TripleFloat {
+    f: f32,
+    g: f32,
+    h: f32,
+}
+
+#[repr(C)]
+pub struct TripleDouble {
+    f: f64,
+    g: f64,
+    h: f64,
+}
+
+#[repr(C)]
+pub struct ManyIntegers {
+    f: u8,
+    g: u16,
+    h: u32,
+    i: u64,
+}
+
+#[repr(C)]
+pub struct ManyNumerics {
+    f: u8,
+    g: u16,
+    h: u32,
+    i: u64,
+    j: f32,
+    k: f64,
+}
+
+// CHECK: .visible .entry f_u8_arg(
+// CHECK: .param .u8 f_u8_arg_param_0
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_u8_arg(_a: u8) {}
+
+// CHECK: .visible .entry f_u16_arg(
+// CHECK: .param .u16 f_u16_arg_param_0
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_u16_arg(_a: u16) {}
+
+// CHECK: .visible .entry f_u32_arg(
+// CHECK: .param .u32 f_u32_arg_param_0
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_u32_arg(_a: u32) {}
+
+// CHECK: .visible .entry f_u64_arg(
+// CHECK: .param .u64 f_u64_arg_param_0
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_u64_arg(_a: u64) {}
+
+// CHECK: .visible .entry f_u128_arg(
+// CHECK: .param .align 16 .b8 f_u128_arg_param_0[16]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_u128_arg(_a: u128) {}
+
+// CHECK: .visible .entry f_i8_arg(
+// CHECK: .param .u8 f_i8_arg_param_0
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_i8_arg(_a: i8) {}
+
+// CHECK: .visible .entry f_i16_arg(
+// CHECK: .param .u16 f_i16_arg_param_0
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_i16_arg(_a: i16) {}
+
+// CHECK: .visible .entry f_i32_arg(
+// CHECK: .param .u32 f_i32_arg_param_0
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_i32_arg(_a: i32) {}
+
+// CHECK: .visible .entry f_i64_arg(
+// CHECK: .param .u64 f_i64_arg_param_0
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_i64_arg(_a: i64) {}
+
+// CHECK: .visible .entry f_i128_arg(
+// CHECK: .param .align 16 .b8 f_i128_arg_param_0[16]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_i128_arg(_a: i128) {}
+
+// CHECK: .visible .entry f_f32_arg(
+// CHECK: .param .f32 f_f32_arg_param_0
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_f32_arg(_a: f32) {}
+
+// CHECK: .visible .entry f_f64_arg(
+// CHECK: .param .f64 f_f64_arg_param_0
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_f64_arg(_a: f64) {}
+
+// CHECK: .visible .entry f_single_u8_arg(
+// CHECK: .param .align 1 .b8 f_single_u8_arg_param_0[1]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_single_u8_arg(_a: SingleU8) {}
+
+// CHECK: .visible .entry f_double_u8_arg(
+// CHECK: .param .align 1 .b8 f_double_u8_arg_param_0[2]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_double_u8_arg(_a: DoubleU8) {}
+
+// CHECK: .visible .entry f_triple_u8_arg(
+// CHECK: .param .align 1 .b8 f_triple_u8_arg_param_0[3]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_triple_u8_arg(_a: TripleU8) {}
+
+// CHECK: .visible .entry f_triple_u16_arg(
+// CHECK: .param .align 2 .b8 f_triple_u16_arg_param_0[6]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_triple_u16_arg(_a: TripleU16) {}
+
+// CHECK: .visible .entry f_double_i32_arg(
+// CHECK: .param .align 4 .b8 f_double_i32_arg_param_0[8]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_double_i32_arg(_a: DoubleI32) {}
+
+// CHECK: .visible .entry f_triple_u32_arg(
+// CHECK: .param .align 4 .b8 f_triple_u32_arg_param_0[12]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_triple_u32_arg(_a: TripleU32) {}
+
+// CHECK: .visible .entry f_triple_u64_arg(
+// CHECK: .param .align 8 .b8 f_triple_u64_arg_param_0[24]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_triple_u64_arg(_a: TripleU64) {}
+
+// CHECK: .visible .entry f_many_integers_arg(
+// CHECK: .param .align 8 .b8 f_many_integers_arg_param_0[16]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_many_integers_arg(_a: ManyIntegers) {}
+
+// CHECK: .visible .entry f_double_float_arg(
+// CHECK: .param .align 4 .b8 f_double_float_arg_param_0[8]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_double_float_arg(_a: DoubleFloat) {}
+
+// CHECK: .visible .entry f_triple_float_arg(
+// CHECK: .param .align 4 .b8 f_triple_float_arg_param_0[12]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_triple_float_arg(_a: TripleFloat) {}
+
+// CHECK: .visible .entry f_triple_double_arg(
+// CHECK: .param .align 8 .b8 f_triple_double_arg_param_0[24]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_triple_double_arg(_a: TripleDouble) {}
+
+// CHECK: .visible .entry f_many_numerics_arg(
+// CHECK: .param .align 8 .b8 f_many_numerics_arg_param_0[32]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_many_numerics_arg(_a: ManyNumerics) {}
+
+// CHECK: .visible .entry f_byte_array_arg(
+// CHECK: .param .align 1 .b8 f_byte_array_arg_param_0[5]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_byte_array_arg(_a: [u8; 5]) {}
+
+// CHECK: .visible .entry f_float_array_arg(
+// CHECK: .param .align 4 .b8 f_float_array_arg_param_0[20]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_float_array_arg(_a: [f32; 5]) {}
+
+// FIXME: u128 started to break compilation with disabled CI
+// NO_CHECK: .visible .entry f_u128_array_arg(
+// NO_CHECK: .param .align 16 .b8 f_u128_array_arg_param_0[80]
+//#[no_mangle]
+//pub unsafe extern "ptx-kernel" fn f_u128_array_arg(_a: [u128; 5]) {}
+
+// CHECK: .visible .entry f_u32_slice_arg(
+// CHECK: .param .align 8 .b8 f_u32_slice_arg_param_0[16]
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn f_u32_slice_arg(_a: &[u32]) {}
diff --git a/tests/assembly-llvm/nvptx-linking-binary.rs b/tests/assembly-llvm/nvptx-linking-binary.rs
new file mode 100644
index 00000000000..3b50b472ab1
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-linking-binary.rs
@@ -0,0 +1,40 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type bin
+//@ only-nvptx64
+//@ ignore-nvptx64
+
+#![feature(abi_ptx)]
+#![no_main]
+#![no_std]
+
+//@ aux-build: breakpoint-panic-handler.rs
+extern crate breakpoint_panic_handler;
+
+//@ aux-build: non-inline-dependency.rs
+extern crate non_inline_dependency as dep;
+
+// Make sure declarations are there.
+// CHECK: .func (.param .b32 func_retval0) wrapping_external_fn
+// CHECK: .func (.param .b32 func_retval0) panicking_external_fn
+
+// CHECK-LABEL: .visible .entry top_kernel(
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn top_kernel(a: *const u32, b: *mut u32) {
+    // CHECK:      call.uni (retval0),
+    // CHECK-NEXT: wrapping_external_fn
+    // CHECK:      ld.param.b32 %[[LHS:r[0-9]+]], [retval0+0];
+    let lhs = dep::wrapping_external_fn(*a);
+
+    // CHECK:      call.uni (retval0),
+    // CHECK-NEXT: panicking_external_fn
+    // CHECK:      ld.param.b32 %[[RHS:r[0-9]+]], [retval0+0];
+    let rhs = dep::panicking_external_fn(*a);
+
+    // CHECK: add.s32 %[[RES:r[0-9]+]], %[[RHS]], %[[LHS]];
+    // CHECK: st.global.u32 [%{{rd[0-9]+}}], %[[RES]];
+    *b = lhs + rhs;
+}
+
+// Verify that external function bodies are available.
+// CHECK: .func (.param .b32 func_retval0) wrapping_external_fn
+// CHECK: .func (.param .b32 func_retval0) panicking_external_fn
diff --git a/tests/assembly-llvm/nvptx-linking-cdylib.rs b/tests/assembly-llvm/nvptx-linking-cdylib.rs
new file mode 100644
index 00000000000..9742e26fb31
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-linking-cdylib.rs
@@ -0,0 +1,39 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type cdylib
+//@ only-nvptx64
+//@ ignore-nvptx64
+
+#![feature(abi_ptx)]
+#![no_std]
+
+//@ aux-build: breakpoint-panic-handler.rs
+extern crate breakpoint_panic_handler;
+
+//@ aux-build: non-inline-dependency.rs
+extern crate non_inline_dependency as dep;
+
+// Make sure declarations are there.
+// CHECK: .func (.param .b32 func_retval0) wrapping_external_fn
+// CHECK: .func (.param .b32 func_retval0) panicking_external_fn
+
+// CHECK-LABEL: .visible .entry top_kernel(
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn top_kernel(a: *const u32, b: *mut u32) {
+    // CHECK:      call.uni (retval0),
+    // CHECK-NEXT: wrapping_external_fn
+    // CHECK:      ld.param.b32 %[[LHS:r[0-9]+]], [retval0+0];
+    let lhs = dep::wrapping_external_fn(*a);
+
+    // CHECK:      call.uni (retval0),
+    // CHECK-NEXT: panicking_external_fn
+    // CHECK:      ld.param.b32 %[[RHS:r[0-9]+]], [retval0+0];
+    let rhs = dep::panicking_external_fn(*a);
+
+    // CHECK: add.s32 %[[RES:r[0-9]+]], %[[RHS]], %[[LHS]];
+    // CHECK: st.global.u32 [%{{rd[0-9]+}}], %[[RES]];
+    *b = lhs + rhs;
+}
+
+// Verify that external function bodies are available.
+// CHECK: .func (.param .b32 func_retval0) wrapping_external_fn
+// CHECK: .func (.param .b32 func_retval0) panicking_external_fn
diff --git a/tests/assembly-llvm/nvptx-safe-naming.rs b/tests/assembly-llvm/nvptx-safe-naming.rs
new file mode 100644
index 00000000000..d7b46aadd9c
--- /dev/null
+++ b/tests/assembly-llvm/nvptx-safe-naming.rs
@@ -0,0 +1,37 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type cdylib -Z unstable-options -Clinker-flavor=llbc
+//@ only-nvptx64
+
+#![feature(abi_ptx)]
+#![no_std]
+
+//@ aux-build: breakpoint-panic-handler.rs
+extern crate breakpoint_panic_handler;
+
+// Verify function name doesn't contain unacceaptable characters.
+// CHECK: .func (.param .b32 func_retval0) [[IMPL_FN:[a-zA-Z0-9$_]+square[a-zA-Z0-9$_]+]]
+
+// CHECK-LABEL: .visible .entry top_kernel(
+#[no_mangle]
+pub unsafe extern "ptx-kernel" fn top_kernel(a: *const u32, b: *mut u32) {
+    // CHECK:      call.uni (retval0),
+    // CHECK-NEXT: [[IMPL_FN]]
+    *b = deep::private::MyStruct::new(*a).square();
+}
+
+pub mod deep {
+    pub mod private {
+        pub struct MyStruct<T>(T);
+
+        impl MyStruct<u32> {
+            pub fn new(a: u32) -> Self {
+                MyStruct(a)
+            }
+
+            #[inline(never)]
+            pub fn square(&self) -> u32 {
+                self.0.wrapping_mul(self.0)
+            }
+        }
+    }
+}
diff --git a/tests/assembly-llvm/panic-no-unwind-no-uwtable.rs b/tests/assembly-llvm/panic-no-unwind-no-uwtable.rs
new file mode 100644
index 00000000000..b51b173e961
--- /dev/null
+++ b/tests/assembly-llvm/panic-no-unwind-no-uwtable.rs
@@ -0,0 +1,8 @@
+//@ assembly-output: emit-asm
+//@ only-x86_64-unknown-linux-gnu
+//@ compile-flags: -C panic=unwind -C force-unwind-tables=n -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-NOT: .cfi_startproc
+pub fn foo() {}
diff --git a/tests/assembly-llvm/panic-unwind-no-uwtable.rs b/tests/assembly-llvm/panic-unwind-no-uwtable.rs
new file mode 100644
index 00000000000..181656a8987
--- /dev/null
+++ b/tests/assembly-llvm/panic-unwind-no-uwtable.rs
@@ -0,0 +1,12 @@
+//@ assembly-output: emit-asm
+//@ only-x86_64-unknown-linux-gnu
+//@ compile-flags: -C panic=unwind -C force-unwind-tables=n
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: foo:
+// CHECK: .cfi_startproc
+#[no_mangle]
+fn foo() {
+    panic!();
+}
diff --git a/tests/assembly-llvm/pic-relocation-model.rs b/tests/assembly-llvm/pic-relocation-model.rs
new file mode 100644
index 00000000000..15a8723f756
--- /dev/null
+++ b/tests/assembly-llvm/pic-relocation-model.rs
@@ -0,0 +1,31 @@
+//@ add-core-stubs
+//@ revisions: x64
+//@ assembly-output: emit-asm
+//@ [x64] compile-flags: --target x86_64-unknown-linux-gnu -Crelocation-model=pic
+//@ [x64] needs-llvm-components: x86
+
+#![feature(no_core, lang_items)]
+#![no_core]
+#![crate_type = "rlib"]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: call_other_fn:
+// CHECK:       {{(jmpq|callq)}} *other_fn@GOTPCREL(%rip)
+#[no_mangle]
+pub fn call_other_fn() -> u8 {
+    unsafe { other_fn() }
+}
+
+// CHECK-LABEL: other_fn:
+// CHECK:       {{(jmpq|callq)}} *foreign_fn@GOTPCREL(%rip)
+#[no_mangle]
+#[inline(never)]
+pub fn other_fn() -> u8 {
+    unsafe { foreign_fn() }
+}
+
+extern "C" {
+    fn foreign_fn() -> u8;
+}
diff --git a/tests/assembly-llvm/pie-relocation-model.rs b/tests/assembly-llvm/pie-relocation-model.rs
new file mode 100644
index 00000000000..cbe0001041e
--- /dev/null
+++ b/tests/assembly-llvm/pie-relocation-model.rs
@@ -0,0 +1,34 @@
+//@ add-core-stubs
+//@ revisions: x64
+//@ assembly-output: emit-asm
+//@ [x64] compile-flags: --target x86_64-unknown-linux-gnu -Crelocation-model=pie
+//@ [x64] needs-llvm-components: x86
+
+#![feature(no_core, lang_items)]
+#![no_core]
+#![crate_type = "rlib"]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: call_other_fn:
+// With PIE local functions are called "directly".
+// CHECK:       {{(jmp|callq)}} other_fn
+#[no_mangle]
+pub fn call_other_fn() -> u8 {
+    unsafe { other_fn() }
+}
+
+// CHECK-LABEL: other_fn:
+// External functions are still called through GOT, since we don't know if the symbol
+// is defined in the binary or in the shared library.
+// CHECK:       {{(jmpq|callq)}} *foreign_fn@GOTPCREL(%rip)
+#[no_mangle]
+#[inline(never)]
+pub fn other_fn() -> u8 {
+    unsafe { foreign_fn() }
+}
+
+extern "C" {
+    fn foreign_fn() -> u8;
+}
diff --git a/tests/assembly-llvm/powerpc64-struct-abi.rs b/tests/assembly-llvm/powerpc64-struct-abi.rs
new file mode 100644
index 00000000000..ee4965deb4f
--- /dev/null
+++ b/tests/assembly-llvm/powerpc64-struct-abi.rs
@@ -0,0 +1,156 @@
+//@ add-core-stubs
+//@ revisions: elfv1-be elfv2-be elfv2-le aix
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3
+//@[elfv1-be] compile-flags: --target powerpc64-unknown-linux-gnu
+//@[elfv1-be] needs-llvm-components: powerpc
+//@[elfv2-be] compile-flags: --target powerpc64-unknown-linux-musl
+//@[elfv2-be] needs-llvm-components: powerpc
+//@[elfv2-le] compile-flags: --target powerpc64le-unknown-linux-gnu -C target-cpu=pwr8
+//@[elfv2-le] needs-llvm-components: powerpc
+//@[aix] compile-flags: --target powerpc64-ibm-aix
+//@[aix] needs-llvm-components: powerpc
+//@[elfv1-be] filecheck-flags: --check-prefix be
+//@[elfv2-be] filecheck-flags: --check-prefix be
+//@[elfv1-be] filecheck-flags: --check-prefix elf
+//@[elfv2-be] filecheck-flags: --check-prefix elf
+//@[elfv2-le] filecheck-flags: --check-prefix elf
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+impl Copy for FiveU32s {}
+impl Copy for FiveU16s {}
+impl Copy for ThreeU8s {}
+
+#[repr(C)]
+struct FiveU32s(u32, u32, u32, u32, u32);
+
+#[repr(C)]
+struct FiveU16s(u16, u16, u16, u16, u16);
+
+#[repr(C)]
+struct ThreeU8s(u8, u8, u8);
+
+// CHECK-LABEL: read_large
+// aix: lwz [[REG1:.*]], 16(4)
+// aix-NEXT: lxv{{d2x|w4x}} 0, 0, 4
+// aix-NEXT: stw [[REG1]], 16(3)
+// aix-NEXT: stxv{{d2x|w4x}} 0, 0, 3
+// be: lwz [[REG1:.*]], 16(4)
+// be-NEXT: stw [[REG1]], 16(3)
+// be-NEXT: ld [[REG2:.*]], 8(4)
+// be-NEXT: ld [[REG3:.*]], 0(4)
+// be-NEXT: std [[REG2]], 8(3)
+// be-NEXT: std [[REG3]], 0(3)
+// elfv2-le: lxvd2x [[REG1:.*]], 0, 4
+// elfv2-le-NEXT: lwz [[REG2:.*]], 16(4)
+// elfv2-le-NEXT: stw [[REG2]], 16(3)
+// elfv2-le-NEXT: stxvd2x [[REG1]], 0, 3
+// CHECK-NEXT: blr
+#[no_mangle]
+extern "C" fn read_large(x: &FiveU32s) -> FiveU32s {
+    *x
+}
+
+// CHECK-LABEL: read_medium
+// aix: lhz [[REG1:.*]], 8(4)
+// aix-NEXT: ld [[REG2:.*]], 0(4)
+// aix-NEXT: sth [[REG1]], 8(3)
+// aix-NEXT: std [[REG2]], 0(3)
+// elfv1-be: lhz [[REG1:.*]], 8(4)
+// elfv1-be-NEXT: ld [[REG2:.*]], 0(4)
+// elfv1-be-NEXT: sth [[REG1]], 8(3)
+// elfv1-be-NEXT: std [[REG2]], 0(3)
+// elfv2-be: lhz [[REG1:.*]], 8(3)
+// elfv2-be-NEXT: ld 3, 0(3)
+// elfv2-be-NEXT: sldi 4, [[REG1]], 48
+// elfv2-le: ld [[REG1:.*]], 0(3)
+// elfv2-le-NEXT: lhz 4, 8(3)
+// elfv2-le-NEXT: mr 3, [[REG1]]
+// CHECK-NEXT: blr
+#[no_mangle]
+extern "C" fn read_medium(x: &FiveU16s) -> FiveU16s {
+    *x
+}
+
+// CHECK-LABEL: read_small
+// aix: lbz [[REG1:.*]], 2(4)
+// aix-NEXT: lhz [[REG2:.*]], 0(4)
+// aix-NEXT: stb [[REG1]], 2(3)
+// aix-NEXT: sth [[REG2]], 0(3)
+// elfv1-be: lbz [[REG1:.*]], 2(4)
+// elfv1-be-NEXT: lhz [[REG2:.*]], 0(4)
+// elfv1-be-NEXT: stb [[REG1]], 2(3)
+// elfv1-be-NEXT: sth [[REG2]], 0(3)
+// elfv2-be: lhz [[REG1:.*]], 0(3)
+// elfv2-be-NEXT: lbz 3, 2(3)
+// elfv2-be-NEXT: rldimi 3, [[REG1]], 8, 0
+// elfv2-le: lbz [[REG1:.*]], 2(3)
+// elfv2-le-NEXT: lhz 3, 0(3)
+// elfv2-le-NEXT: rldimi 3, [[REG1]], 16, 0
+// CHECK-NEXT: blr
+#[no_mangle]
+extern "C" fn read_small(x: &ThreeU8s) -> ThreeU8s {
+    *x
+}
+
+// CHECK-LABEL: write_large
+// aix: std 3, 48(1)
+// aix-NEXT: rldicl [[REG1:.*]], 5, 32, 32
+// aix-NEXT: std 5, 64(1)
+// aix-NEXT: std 4, 56(1)
+// aix-NEXT: stw [[REG1]], 16(6)
+// aix-NEXT: addi [[REG2:.*]], 1, 48
+// aix-NEXT: lxv{{d2x|w4x}} 0, 0, [[REG2]]
+// aix-NEXT: stxv{{d2x|w4x}} 0, 0, 6
+// elf: std 3, 0(6)
+// be-NEXT: rldicl [[REG1:.*]], 5, 32, 32
+// elf-NEXT: std 4, 8(6)
+// be-NEXT: stw [[REG1]], 16(6)
+// elfv2-le-NEXT: stw 5, 16(6)
+// CHECK-NEXT: blr
+#[no_mangle]
+extern "C" fn write_large(x: FiveU32s, dest: &mut FiveU32s) {
+    *dest = x;
+}
+
+// CHECK-LABEL: write_medium
+// aix: std 4, 56(1)
+// aix-NEXT: rldicl [[REG1:.*]], 4, 16, 48
+// aix-NEXT: std 3, 48(1)
+// aix-NEXT: std 3, 0(5)
+// aix-NEXT: sth [[REG1]], 8(5)
+// elf: std 3, 0(5)
+// be-NEXT: rldicl [[REG1:.*]], 4, 16, 48
+// be-NEXT: sth [[REG1]], 8(5)
+// elfv2-le-NEXT: sth 4, 8(5)
+// CHECK-NEXT: blr
+#[no_mangle]
+extern "C" fn write_medium(x: FiveU16s, dest: &mut FiveU16s) {
+    *dest = x;
+}
+
+// CHECK-LABEL: write_small
+// aix: std 3, 48(1)
+// aix-NEXT: rldicl [[REG1:.*]], 3, 16, 48
+// aix-NEXT: sth 3, 0(4)
+// aix-NEXT: lbz 3, 50(1)
+// aix-NEXT: stb [[REG1]], 2(4)
+// be: stb 3, 2(4)
+// be-NEXT: srwi [[REG1:.*]], 3, 8
+// be-NEXT: sth [[REG1]], 0(4)
+// The order these instructions are emitted in changed in LLVM 18.
+// elfv2-le-DAG: sth 3, 0(4)
+// elfv2-le-DAG: srwi [[REG1:.*]], 3, 16
+// elfv2-le-NEXT: stb [[REG1]], 2(4)
+// CHECK-NEXT: blr
+#[no_mangle]
+extern "C" fn write_small(x: ThreeU8s, dest: &mut ThreeU8s) {
+    *dest = x;
+}
diff --git a/tests/assembly-llvm/riscv-float-struct-abi.rs b/tests/assembly-llvm/riscv-float-struct-abi.rs
new file mode 100644
index 00000000000..5d9ac9d70b8
--- /dev/null
+++ b/tests/assembly-llvm/riscv-float-struct-abi.rs
@@ -0,0 +1,177 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3 --target riscv64gc-unknown-linux-gnu
+//@ needs-llvm-components: riscv
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C, align(64))]
+struct Aligned(f64);
+
+#[repr(C)]
+struct Padded(u8, Aligned);
+
+#[repr(C, packed)]
+struct Packed(u8, f32);
+
+impl Copy for Aligned {}
+impl Copy for Padded {}
+impl Copy for Packed {}
+
+extern "C" {
+    fn take_padded(x: Padded);
+    fn get_padded() -> Padded;
+    fn take_packed(x: Packed);
+    fn get_packed() -> Packed;
+}
+
+// CHECK-LABEL: pass_padded
+#[unsafe(no_mangle)]
+extern "C" fn pass_padded(out: &mut Padded, x: Padded) {
+    // CHECK: sb a1, 0(a0)
+    // CHECK-NEXT: fsd fa0, 64(a0)
+    // CHECK-NEXT: ret
+    *out = x;
+}
+
+// CHECK-LABEL: ret_padded
+#[unsafe(no_mangle)]
+extern "C" fn ret_padded(x: &Padded) -> Padded {
+    // CHECK: fld fa0, 64(a0)
+    // CHECK-NEXT: lbu a0, 0(a0)
+    // CHECK-NEXT: ret
+    *x
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn call_padded(x: &Padded) {
+    // CHECK: fld fa0, 64(a0)
+    // CHECK-NEXT: lbu a0, 0(a0)
+    // CHECK-NEXT: tail take_padded
+    unsafe {
+        take_padded(*x);
+    }
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn receive_padded(out: &mut Padded) {
+    // CHECK: addi sp, sp, -16
+    // CHECK-NEXT: .cfi_def_cfa_offset 16
+    // CHECK-NEXT: sd ra, [[#%d,RA_SPILL:]](sp)
+    // CHECK-NEXT: sd [[TEMP:.*]], [[#%d,TEMP_SPILL:]](sp)
+    // CHECK-NEXT: .cfi_offset ra, [[#%d,RA_SPILL - 16]]
+    // CHECK-NEXT: .cfi_offset [[TEMP]], [[#%d,TEMP_SPILL - 16]]
+    // CHECK-NEXT: mv [[TEMP]], a0
+    // CHECK-NEXT: call get_padded
+    // CHECK-NEXT: sb a0, 0([[TEMP]])
+    // CHECK-NEXT: fsd fa0, 64([[TEMP]])
+    // CHECK-NEXT: ld ra, [[#%d,RA_SPILL]](sp)
+    // CHECK-NEXT: ld [[TEMP]], [[#%d,TEMP_SPILL]](sp)
+    // CHECK: addi sp, sp, 16
+    // CHECK: ret
+    unsafe {
+        *out = get_padded();
+    }
+}
+
+// CHECK-LABEL: pass_packed
+#[unsafe(no_mangle)]
+extern "C" fn pass_packed(out: &mut Packed, x: Packed) {
+    // CHECK: addi sp, sp, -16
+    // CHECK-NEXT: .cfi_def_cfa_offset 16
+    // CHECK-NEXT: sb a1, 0(a0)
+    // CHECK-NEXT: fsw fa0, 8(sp)
+    // CHECK-NEXT: lw [[VALUE:.*]], 8(sp)
+    // CHECK-DAG: srli [[BYTE4:.*]], [[VALUE]], 24
+    // CHECK-DAG: srli [[BYTE3:.*]], [[VALUE]], 16
+    // CHECK-DAG: srli [[BYTE2:.*]], [[VALUE]], 8
+    // CHECK-DAG: sb [[VALUE]], 1(a0)
+    // CHECK-DAG: sb [[BYTE2]], 2(a0)
+    // CHECK-DAG: sb [[BYTE3]], 3(a0)
+    // CHECK-DAG: sb [[BYTE4]], 4(a0)
+    // CHECK-NEXT: addi sp, sp, 16
+    // CHECK: ret
+    *out = x;
+}
+
+// CHECK-LABEL: ret_packed
+#[unsafe(no_mangle)]
+extern "C" fn ret_packed(x: &Packed) -> Packed {
+    // CHECK: addi sp, sp, -16
+    // CHECK-NEXT: .cfi_def_cfa_offset 16
+    // CHECK-NEXT: lbu [[BYTE2:.*]], 2(a0)
+    // CHECK-NEXT: lbu [[BYTE1:.*]], 1(a0)
+    // CHECK-NEXT: lbu [[BYTE3:.*]], 3(a0)
+    // CHECK-NEXT: lbu [[BYTE4:.*]], 4(a0)
+    // CHECK-NEXT: slli [[SHIFTED2:.*]], [[BYTE2]], 8
+    // CHECK-NEXT: or [[BYTE12:.*]], [[SHIFTED2]], [[BYTE1]]
+    // CHECK-NEXT: slli [[SHIFTED3:.*]], [[BYTE3]], 16
+    // CHECK-NEXT: slli [[SHIFTED4:.*]], [[BYTE4]], 24
+    // CHECK-NEXT: or [[BYTE34:.*]], [[SHIFTED3]], [[SHIFTED4]]
+    // CHECK-NEXT: or [[VALUE:.*]], [[BYTE12]], [[BYTE34]]
+    // CHECK-NEXT: sw [[VALUE]], 8(sp)
+    // CHECK-NEXT: flw fa0, 8(sp)
+    // CHECK-NEXT: lbu a0, 0(a0)
+    // CHECK-NEXT: addi sp, sp, 16
+    // CHECK: ret
+    *x
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn call_packed(x: &Packed) {
+    // CHECK: addi sp, sp, -16
+    // CHECK-NEXT: .cfi_def_cfa_offset 16
+    // CHECK-NEXT: lbu [[BYTE2:.*]], 2(a0)
+    // CHECK-NEXT: lbu [[BYTE1:.*]], 1(a0)
+    // CHECK-NEXT: lbu [[BYTE3:.*]], 3(a0)
+    // CHECK-NEXT: lbu [[BYTE4:.*]], 4(a0)
+    // CHECK-NEXT: slli [[SHIFTED2:.*]], [[BYTE2]], 8
+    // CHECK-NEXT: or [[BYTE12:.*]], [[SHIFTED2]], [[BYTE1]]
+    // CHECK-NEXT: slli [[SHIFTED3:.*]], [[BYTE3]], 16
+    // CHECK-NEXT: slli [[SHIFTED4:.*]], [[BYTE4]], 24
+    // CHECK-NEXT: or [[BYTE34:.*]], [[SHIFTED3]], [[SHIFTED4]]
+    // CHECK-NEXT: or [[VALUE:.*]], [[BYTE12]], [[BYTE34]]
+    // CHECK-NEXT: sw [[VALUE]], 8(sp)
+    // CHECK-NEXT: flw fa0, 8(sp)
+    // CHECK-NEXT: lbu a0, 0(a0)
+    // CHECK-NEXT: addi sp, sp, 16
+    // CHECK: tail take_packed
+    unsafe {
+        take_packed(*x);
+    }
+}
+
+#[unsafe(no_mangle)]
+extern "C" fn receive_packed(out: &mut Packed) {
+    // CHECK: addi sp, sp, -32
+    // CHECK-NEXT: .cfi_def_cfa_offset 32
+    // CHECK-NEXT: sd ra, [[#%d,RA_SPILL:]](sp)
+    // CHECK-NEXT: sd [[TEMP:.*]], [[#%d,TEMP_SPILL:]](sp)
+    // CHECK-NEXT: .cfi_offset ra, [[#%d,RA_SPILL - 32]]
+    // CHECK-NEXT: .cfi_offset [[TEMP]], [[#%d,TEMP_SPILL - 32]]
+    // CHECK-NEXT: mv [[TEMP]], a0
+    // CHECK-NEXT: call get_packed
+    // CHECK-NEXT: sb a0, 0([[TEMP]])
+    // CHECK-NEXT: fsw fa0, [[FLOAT_SPILL:.*]](sp)
+    // CHECK-NEXT: lw [[VALUE:.*]], [[FLOAT_SPILL]](sp)
+    // CHECK-DAG: srli [[BYTE4:.*]], [[VALUE]], 24
+    // CHECK-DAG: srli [[BYTE3:.*]], [[VALUE]], 16
+    // CHECK-DAG: srli [[BYTE2:.*]], [[VALUE]], 8
+    // CHECK-DAG: sb [[VALUE]], 1([[TEMP]])
+    // CHECK-DAG: sb [[BYTE2]], 2([[TEMP]])
+    // CHECK-DAG: sb [[BYTE3]], 3([[TEMP]])
+    // CHECK-DAG: sb [[BYTE4]], 4([[TEMP]])
+    // CHECK-NEXT: ld ra, [[#%d,RA_SPILL]](sp)
+    // CHECK-NEXT: ld [[TEMP]], [[#%d,TEMP_SPILL]](sp)
+    // CHECK: addi sp, sp, 32
+    // CHECK: ret
+    unsafe {
+        *out = get_packed();
+    }
+}
diff --git a/tests/assembly-llvm/riscv-soft-abi-with-float-features.rs b/tests/assembly-llvm/riscv-soft-abi-with-float-features.rs
new file mode 100644
index 00000000000..72cbd3841c1
--- /dev/null
+++ b/tests/assembly-llvm/riscv-soft-abi-with-float-features.rs
@@ -0,0 +1,45 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target riscv64imac-unknown-none-elf -Ctarget-feature=+f,+d
+//@ needs-llvm-components: riscv
+//@ revisions: LLVM-PRE-20 LLVM-POST-20
+//@ [LLVM-PRE-20] max-llvm-major-version: 19
+//@ [LLVM-POST-20] min-llvm-version: 20
+
+#![feature(no_core, lang_items, f16)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// This test checks that the floats are all returned in `a0` as required by the `lp64` ABI.
+
+// CHECK-LABEL: read_f16
+#[no_mangle]
+pub extern "C" fn read_f16(x: &f16) -> f16 {
+    // CHECK: lh a0, 0(a0)
+    // CHECK-NEXT: lui a1, 1048560
+    // CHECK-NEXT: or a0, a0, a1
+    // CHECK-NEXT: ret
+    *x
+}
+
+// CHECK-LABEL: read_f32
+#[no_mangle]
+pub extern "C" fn read_f32(x: &f32) -> f32 {
+    // LLVM-PRE-20: flw fa5, 0(a0)
+    // LLVM-PRE-20-NEXT: fmv.x.w a0, fa5
+    // LLVM-PRE-20-NEXT: ret
+    // LLVM-POST-20: lw a0, 0(a0)
+    // LLVM-POST-20-NEXT: ret
+    *x
+}
+
+// CHECK-LABEL: read_f64
+#[no_mangle]
+pub extern "C" fn read_f64(x: &f64) -> f64 {
+    // CHECK: ld a0, 0(a0)
+    // CHECK-NEXT: ret
+    *x
+}
diff --git a/tests/assembly-llvm/rust-abi-arg-attr.rs b/tests/assembly-llvm/rust-abi-arg-attr.rs
new file mode 100644
index 00000000000..4f3673ccfc3
--- /dev/null
+++ b/tests/assembly-llvm/rust-abi-arg-attr.rs
@@ -0,0 +1,110 @@
+//@ assembly-output: emit-asm
+//@ revisions: riscv64 riscv64-zbb loongarch64
+//@ compile-flags: -C opt-level=3
+//@ [riscv64] compile-flags: --target riscv64gc-unknown-linux-gnu
+//@ [riscv64] needs-llvm-components: riscv
+//@ [riscv64-zbb] compile-flags: --target riscv64gc-unknown-linux-gnu
+//@ [riscv64-zbb] compile-flags: -C target-feature=+zbb
+//@ [riscv64-zbb] needs-llvm-components: riscv
+//@ [loongarch64] compile-flags: --target loongarch64-unknown-linux-gnu
+//@ [loongarch64] needs-llvm-components: loongarch
+
+#![feature(no_core, lang_items, intrinsics, rustc_attrs)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+// FIXME: Migrate these code after PR #130693 is landed.
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+
+#[lang = "copy"]
+trait Copy {}
+
+impl Copy for i8 {}
+impl Copy for u32 {}
+impl Copy for i32 {}
+
+#[lang = "neg"]
+trait Neg {
+    type Output;
+
+    fn neg(self) -> Self::Output;
+}
+
+impl Neg for i8 {
+    type Output = i8;
+
+    fn neg(self) -> Self::Output {
+        -self
+    }
+}
+
+#[lang = "Ordering"]
+#[repr(i8)]
+enum Ordering {
+    Less = -1,
+    Equal = 0,
+    Greater = 1,
+}
+
+#[rustc_intrinsic]
+fn three_way_compare<T: Copy>(lhs: T, rhs: T) -> Ordering;
+
+// ^^^^^ core
+
+// Reimplementation of function `{integer}::max`.
+macro_rules! max {
+    ($a:expr, $b:expr) => {
+        match three_way_compare($a, $b) {
+            Ordering::Less | Ordering::Equal => $b,
+            Ordering::Greater => $a,
+        }
+    };
+}
+
+#[no_mangle]
+// CHECK-LABEL: issue_114508_u32:
+pub fn issue_114508_u32(a: u32, b: u32) -> u32 {
+    // CHECK-NEXT:       .cfi_startproc
+
+    // riscv64-NEXT:     bltu a1, a0, .[[RET:.+]]
+    // riscv64-NEXT:     mv a0, a1
+    // riscv64-NEXT: .[[RET]]:
+
+    // riscv64-zbb-NEXT: maxu a0, a0, a1
+
+    // loongarch64-NEXT: sltu $a2, $a1, $a0
+    // loongarch64-NEXT: masknez $a1, $a1, $a2
+    // loongarch64-NEXT: maskeqz $a0, $a0, $a2
+    // loongarch64-NEXT: or $a0, $a0, $a1
+
+    // CHECK-NEXT:       ret
+    max!(a, b)
+}
+
+#[no_mangle]
+// CHECK-LABEL: issue_114508_i32:
+pub fn issue_114508_i32(a: i32, b: i32) -> i32 {
+    // CHECK-NEXT:       .cfi_startproc
+
+    // riscv64-NEXT:     blt a1, a0, .[[RET:.+]]
+    // riscv64-NEXT:     mv a0, a1
+    // riscv64-NEXT: .[[RET]]:
+
+    // riscv64-zbb-NEXT: max a0, a0, a1
+
+    // loongarch64-NEXT: slt $a2, $a1, $a0
+    // loongarch64-NEXT: masknez $a1, $a1, $a2
+    // loongarch64-NEXT: maskeqz $a0, $a0, $a2
+    // loongarch64-NEXT: or $a0, $a0, $a1
+
+    // CHECK-NEXT:       ret
+    max!(a, b)
+}
diff --git a/tests/assembly-llvm/s390x-backchain-toggle.rs b/tests/assembly-llvm/s390x-backchain-toggle.rs
new file mode 100644
index 00000000000..9bae15b7d11
--- /dev/null
+++ b/tests/assembly-llvm/s390x-backchain-toggle.rs
@@ -0,0 +1,50 @@
+//@ add-core-stubs
+//@ revisions: enable-backchain disable-backchain default-backchain
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3 --crate-type=lib --target=s390x-unknown-linux-gnu
+//@ needs-llvm-components: systemz
+//@[enable-backchain] compile-flags: -Ctarget-feature=+backchain
+//@[disable-backchain] compile-flags: -Ctarget-feature=-backchain
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+extern "C" {
+    fn extern_func();
+}
+
+// CHECK-LABEL: test_backchain
+#[no_mangle]
+extern "C" fn test_backchain() -> i32 {
+    // Here we try to match if backchain register is saved to the parameter area (stored in r15/sp)
+    // And also if a new parameter area (160 bytes) is allocated for the upcoming function call
+    // enable-backchain: lgr [[REG1:.*]], %r15
+    // enable-backchain-NEXT: aghi %r15, -160
+    // enable-backchain: stg [[REG1]], 0(%r15)
+    // disable-backchain: aghi %r15, -160
+    // disable-backchain-NOT: stg %r{{.*}}, 0(%r15)
+    // default-backchain: aghi %r15, -160
+    // default-backchain-NOT: stg %r{{.*}}, 0(%r15)
+    unsafe {
+        extern_func();
+    }
+    // enable-backchain-NEXT: brasl %r{{.*}}, extern_func@PLT
+    // disable-backchain: brasl %r{{.*}}, extern_func@PLT
+
+    // Make sure that the expected return value is written into %r2 (return register):
+    // enable-backchain-NEXT: lghi %r2, 1
+    // disable-backchain: lghi %r2, 0
+    // default-backchain: lghi %r2, 0
+    #[cfg(target_feature = "backchain")]
+    {
+        1
+    }
+    #[cfg(not(target_feature = "backchain"))]
+    {
+        0
+    }
+    // CHECK: br %r{{.*}}
+}
diff --git a/tests/assembly-llvm/s390x-vector-abi.rs b/tests/assembly-llvm/s390x-vector-abi.rs
new file mode 100644
index 00000000000..fcf42664034
--- /dev/null
+++ b/tests/assembly-llvm/s390x-vector-abi.rs
@@ -0,0 +1,327 @@
+//@ revisions: z10 z10_vector z13 z13_no_vector
+// ignore-tidy-linelength
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+//@[z10] compile-flags: --target s390x-unknown-linux-gnu  -C target-cpu=z10 --cfg no_vector
+//@[z10] needs-llvm-components: systemz
+//@[z10_vector] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z10 -C target-feature=+vector
+//@[z10_vector] needs-llvm-components: systemz
+//@[z13] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z13
+//@[z13] needs-llvm-components: systemz
+//@[z13_no_vector] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z13 -C target-feature=-vector --cfg no_vector
+//@[z13_no_vector] needs-llvm-components: systemz
+
+#![feature(no_core, lang_items, repr_simd, s390x_target_feature)]
+#![no_core]
+#![crate_type = "lib"]
+#![allow(non_camel_case_types)]
+// Cases where vector feature is disabled are rejected.
+// See tests/ui/simd-abi-checks-s390x.rs for test for them.
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+#[lang = "copy"]
+pub trait Copy {}
+#[lang = "freeze"]
+pub trait Freeze {}
+
+impl<T: Copy, const N: usize> Copy for [T; N] {}
+
+#[lang = "phantom_data"]
+pub struct PhantomData<T: ?Sized>;
+impl<T: ?Sized> Copy for PhantomData<T> {}
+
+#[repr(simd)]
+pub struct i8x8([i8; 8]);
+#[repr(simd)]
+pub struct i8x16([i8; 16]);
+#[repr(simd)]
+pub struct i8x32([i8; 32]);
+#[repr(C)]
+pub struct Wrapper<T>(T);
+#[repr(C, align(16))]
+pub struct WrapperAlign16<T>(T);
+#[repr(C)]
+pub struct WrapperWithZst<T>(T, PhantomData<()>);
+#[repr(transparent)]
+pub struct TransparentWrapper<T>(T);
+
+impl Copy for i8 {}
+impl Copy for i64 {}
+impl Copy for i8x8 {}
+impl Copy for i8x16 {}
+impl Copy for i8x32 {}
+impl<T: Copy> Copy for Wrapper<T> {}
+impl<T: Copy> Copy for WrapperAlign16<T> {}
+impl<T: Copy> Copy for WrapperWithZst<T> {}
+impl<T: Copy> Copy for TransparentWrapper<T> {}
+
+// CHECK-LABEL: vector_ret_small:
+// CHECK: vlrepg %v24, 0(%r2)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
+    *x
+}
+// CHECK-LABEL: vector_ret:
+// CHECK: vl %v24, 0(%r2), 3
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
+    *x
+}
+// CHECK-LABEL: vector_ret_large:
+// z10: vl %v0, 16(%r3), 4
+// z10-NEXT: vl %v1, 0(%r3), 4
+// z10-NEXT: vst %v0, 16(%r2), 4
+// z10-NEXT: vst %v1, 0(%r2), 4
+// z10-NEXT: br %r14
+// z13: vl %v0, 0(%r3), 4
+// z13-NEXT: vl %v1, 16(%r3), 4
+// z13-NEXT: vst %v1, 16(%r2), 4
+// z13-NEXT: vst %v0, 0(%r2), 4
+// z13-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_ret_large(x: &i8x32) -> i8x32 {
+    *x
+}
+
+// CHECK-LABEL: vector_wrapper_ret_small:
+// CHECK: mvc 0(8,%r2), 0(%r3)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_ret_small(x: &Wrapper<i8x8>) -> Wrapper<i8x8> {
+    *x
+}
+// CHECK-LABEL: vector_wrapper_ret:
+// CHECK: mvc 0(16,%r2), 0(%r3)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_ret(x: &Wrapper<i8x16>) -> Wrapper<i8x16> {
+    *x
+}
+// CHECK-LABEL: vector_wrapper_ret_large:
+// z10: vl %v0, 16(%r3), 4
+// z10-NEXT: vl %v1, 0(%r3), 4
+// z10-NEXT: vst %v0, 16(%r2), 4
+// z10-NEXT: vst %v1, 0(%r2), 4
+// z10-NEXT: br %r14
+// z13: vl %v0, 16(%r3), 4
+// z13-NEXT: vst %v0, 16(%r2), 4
+// z13-NEXT: vl %v0, 0(%r3), 4
+// z13-NEXT: vst %v0, 0(%r2), 4
+// z13-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_ret_large(x: &Wrapper<i8x32>) -> Wrapper<i8x32> {
+    *x
+}
+
+// CHECK-LABEL: vector_wrapper_padding_ret:
+// CHECK: mvc 0(16,%r2), 0(%r3)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_padding_ret(x: &WrapperAlign16<i8x8>) -> WrapperAlign16<i8x8> {
+    *x
+}
+
+// CHECK-LABEL: vector_wrapper_with_zst_ret_small:
+// CHECK: mvc 0(8,%r2), 0(%r3)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_with_zst_ret_small(
+    x: &WrapperWithZst<i8x8>,
+) -> WrapperWithZst<i8x8> {
+    *x
+}
+// CHECK-LABEL: vector_wrapper_with_zst_ret:
+// CHECK: mvc 0(16,%r2), 0(%r3)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_with_zst_ret(
+    x: &WrapperWithZst<i8x16>,
+) -> WrapperWithZst<i8x16> {
+    *x
+}
+// CHECK-LABEL: vector_wrapper_with_zst_ret_large:
+// z10: vl %v0, 16(%r3), 4
+// z10-NEXT: vl %v1, 0(%r3), 4
+// z10-NEXT: vst %v0, 16(%r2), 4
+// z10-NEXT: vst %v1, 0(%r2), 4
+// z10-NEXT: br %r14
+// z13: vl %v0, 16(%r3), 4
+// z13-NEXT: vst %v0, 16(%r2), 4
+// z13-NEXT: vl %v0, 0(%r3), 4
+// z13-NEXT: vst %v0, 0(%r2), 4
+// z13-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_with_zst_ret_large(
+    x: &WrapperWithZst<i8x32>,
+) -> WrapperWithZst<i8x32> {
+    *x
+}
+
+// CHECK-LABEL: vector_transparent_wrapper_ret_small:
+// CHECK: vlrepg %v24, 0(%r2)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_transparent_wrapper_ret_small(
+    x: &TransparentWrapper<i8x8>,
+) -> TransparentWrapper<i8x8> {
+    *x
+}
+// CHECK-LABEL: vector_transparent_wrapper_ret:
+// CHECK: vl %v24, 0(%r2), 3
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_transparent_wrapper_ret(
+    x: &TransparentWrapper<i8x16>,
+) -> TransparentWrapper<i8x16> {
+    *x
+}
+// CHECK-LABEL: vector_transparent_wrapper_ret_large:
+// z10: vl %v0, 16(%r3), 4
+// z10-NEXT: vl %v1, 0(%r3), 4
+// z10-NEXT: vst %v0, 16(%r2), 4
+// z10-NEXT: vst %v1, 0(%r2), 4
+// z10-NEXT: br %r14
+// z13: vl %v0, 0(%r3), 4
+// z13-NEXT: vl %v1, 16(%r3), 4
+// z13-NEXT: vst %v1, 16(%r2), 4
+// z13-NEXT: vst %v0, 0(%r2), 4
+// z13-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_transparent_wrapper_ret_large(
+    x: &TransparentWrapper<i8x32>,
+) -> TransparentWrapper<i8x32> {
+    *x
+}
+
+// CHECK-LABEL: vector_arg_small:
+// CHECK: vlgvg %r2, %v24, 0
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_arg_small(x: i8x8) -> i64 {
+    unsafe { *(&x as *const i8x8 as *const i64) }
+}
+// CHECK-LABEL: vector_arg:
+// CHECK: vlgvg %r2, %v24, 0
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_arg(x: i8x16) -> i64 {
+    unsafe { *(&x as *const i8x16 as *const i64) }
+}
+// CHECK-LABEL: vector_arg_large:
+// CHECK: lg %r2, 0(%r2)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_arg_large(x: i8x32) -> i64 {
+    unsafe { *(&x as *const i8x32 as *const i64) }
+}
+
+// CHECK-LABEL: vector_wrapper_arg_small:
+// CHECK: vlgvg %r2, %v24, 0
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
+    unsafe { *(&x as *const Wrapper<i8x8> as *const i64) }
+}
+// CHECK-LABEL: vector_wrapper_arg:
+// CHECK: vlgvg %r2, %v24, 0
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
+    unsafe { *(&x as *const Wrapper<i8x16> as *const i64) }
+}
+// CHECK-LABEL: vector_wrapper_arg_large:
+// CHECK: lg %r2, 0(%r2)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_arg_large(x: Wrapper<i8x32>) -> i64 {
+    unsafe { *(&x as *const Wrapper<i8x32> as *const i64) }
+}
+
+// https://github.com/rust-lang/rust/pull/131586#discussion_r1837071121
+// CHECK-LABEL: vector_wrapper_padding_arg:
+// CHECK: lg %r2, 0(%r2)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_padding_arg(x: WrapperAlign16<i8x8>) -> i64 {
+    unsafe { *(&x as *const WrapperAlign16<i8x8> as *const i64) }
+}
+
+// CHECK-LABEL: vector_wrapper_with_zst_arg_small:
+// CHECK: .cfi_startproc
+// CHECK-NOT: vlgvg
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_with_zst_arg_small(x: WrapperWithZst<i8x8>) -> i64 {
+    unsafe { *(&x as *const WrapperWithZst<i8x8> as *const i64) }
+}
+// CHECK-LABEL: vector_wrapper_with_zst_arg:
+// CHECK: lg %r2, 0(%r2)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_with_zst_arg(x: WrapperWithZst<i8x16>) -> i64 {
+    unsafe { *(&x as *const WrapperWithZst<i8x16> as *const i64) }
+}
+// CHECK-LABEL: vector_wrapper_with_zst_arg_large:
+// CHECK: lg %r2, 0(%r2)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_wrapper_with_zst_arg_large(x: WrapperWithZst<i8x32>) -> i64 {
+    unsafe { *(&x as *const WrapperWithZst<i8x32> as *const i64) }
+}
+
+// CHECK-LABEL: vector_transparent_wrapper_arg_small:
+// CHECK: vlgvg %r2, %v24, 0
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
+    unsafe { *(&x as *const TransparentWrapper<i8x8> as *const i64) }
+}
+// CHECK-LABEL: vector_transparent_wrapper_arg:
+// CHECK: vlgvg %r2, %v24, 0
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
+    unsafe { *(&x as *const TransparentWrapper<i8x16> as *const i64) }
+}
+// CHECK-LABEL: vector_transparent_wrapper_arg_large:
+// CHECK: lg %r2, 0(%r2)
+// CHECK-NEXT: br %r14
+#[cfg_attr(no_vector, target_feature(enable = "vector"))]
+#[no_mangle]
+unsafe extern "C" fn vector_transparent_wrapper_arg_large(x: TransparentWrapper<i8x32>) -> i64 {
+    unsafe { *(&x as *const TransparentWrapper<i8x32> as *const i64) }
+}
diff --git a/tests/assembly-llvm/sanitizer/kcfi/emit-arity-indicator.rs b/tests/assembly-llvm/sanitizer/kcfi/emit-arity-indicator.rs
new file mode 100644
index 00000000000..f9966a23446
--- /dev/null
+++ b/tests/assembly-llvm/sanitizer/kcfi/emit-arity-indicator.rs
@@ -0,0 +1,69 @@
+// Verifies that KCFI arity indicator is emitted.
+//
+//@ add-core-stubs
+//@ revisions: x86_64
+//@ 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)]
+#![no_core]
+
+extern crate minicore;
+
+unsafe extern "C" {
+    safe fn add(x: i32, y: i32) -> i32;
+}
+
+pub fn add_one(x: i32) -> i32 {
+    // CHECK-LABEL: __cfi__{{.*}}7add_one{{.*}}:
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  mov ecx, 2628068948
+    add(x, 1)
+}
+
+pub fn add_two(x: i32, _y: i32) -> i32 {
+    // CHECK-LABEL: __cfi__{{.*}}7add_two{{.*}}:
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  mov edx, 2505940310
+    add(x, 2)
+}
+
+pub fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: __cfi__{{.*}}8do_twice{{.*}}:
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  nop
+    // CHECK-NEXT:  mov edx, 653723426
+    add(f(arg), f(arg))
+}
diff --git a/tests/assembly-llvm/simd-bitmask.rs b/tests/assembly-llvm/simd-bitmask.rs
new file mode 100644
index 00000000000..d3e20f6ae1a
--- /dev/null
+++ b/tests/assembly-llvm/simd-bitmask.rs
@@ -0,0 +1,147 @@
+//@ add-core-stubs
+//@ revisions: x86 x86-avx2 x86-avx512 aarch64
+//@ [x86] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@ [x86] needs-llvm-components: x86
+//@ [x86-avx2] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@ [x86-avx2] compile-flags: -C target-feature=+avx2
+//@ [x86-avx2] needs-llvm-components: x86
+//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
+//@ [x86-avx512] needs-llvm-components: x86
+//@ [aarch64] compile-flags: --target=aarch64-unknown-linux-gnu
+//@ [aarch64] needs-llvm-components: aarch64
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
+
+#![feature(no_core, lang_items, repr_simd, intrinsics)]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(simd)]
+pub struct m8x16([i8; 16]);
+
+#[repr(simd)]
+pub struct m8x64([i8; 64]);
+
+#[repr(simd)]
+pub struct m32x4([i32; 4]);
+
+#[repr(simd)]
+pub struct m64x2([i64; 2]);
+
+#[repr(simd)]
+pub struct m64x4([i64; 4]);
+
+#[rustc_intrinsic]
+unsafe fn simd_bitmask<V, B>(mask: V) -> B;
+
+// CHECK-LABEL: bitmask_m8x16
+#[no_mangle]
+pub unsafe extern "C" fn bitmask_m8x16(mask: m8x16) -> u16 {
+    // The simd_bitmask intrinsic already uses the most significant bit, so no shift is necessary.
+    // Note that x86 has no byte shift, llvm uses a word shift to move the least significant bit
+    // of each byte into the right position.
+    //
+    // x86-NOT: psllw
+    // x86: movmskb eax, xmm0
+    //
+    // x86-avx2-NOT: vpsllw
+    // x86-avx2: vpmovmskb eax, xmm0
+    //
+    // x86-avx512-NOT: vpsllw xmm0
+    // x86-avx512: vpmovmskb eax, xmm0
+    //
+    // aarch64: adrp
+    // aarch64-NEXT: cmlt
+    // aarch64-NEXT: ldr
+    // aarch64-NEXT: and
+    // aarch64-NEXT: ext
+    // aarch64-NEXT: zip1
+    // aarch64-NEXT: addv
+    // aarch64-NEXT: fmov
+    simd_bitmask(mask)
+}
+
+// x86-avx512-LABEL: bitmask_m8x64
+#[no_mangle]
+#[cfg(x86_avx512)]
+pub unsafe extern "C" fn bitmask_m8x64(mask: m8x64) -> u64 {
+    // The simd_bitmask intrinsic already uses the most significant bit, so no shift is necessary.
+    // Note that x86 has no byte shift, llvm uses a word shift to move the least significant bit
+    // of each byte into the right position.
+    //
+    // The parameter is a 512 bit vector which in the C abi is only valid for avx512 targets.
+    //
+    // x86-avx512-NOT: vpsllw
+    // x86-avx512: vpmovb2m k0, zmm0
+    // x86-avx512: kmovq rax, k0
+    simd_bitmask(mask)
+}
+
+// CHECK-LABEL: bitmask_m32x4
+#[no_mangle]
+pub unsafe extern "C" fn bitmask_m32x4(mask: m32x4) -> u8 {
+    // The simd_bitmask intrinsic already uses the most significant bit, so no shift is necessary.
+    //
+    // x86-NOT: psllq
+    // x86: movmskps eax, xmm0
+    //
+    // x86-avx2-NOT: vpsllq
+    // x86-avx2: vmovmskps eax, xmm0
+    //
+    // x86-avx512-NOT: vpsllq
+    // x86-avx512: vmovmskps eax, xmm0
+    //
+    // aarch64: adrp
+    // aarch64-NEXT: cmlt
+    // aarch64-NEXT: ldr
+    // aarch64-NEXT: and
+    // aarch64-NEXT: addv
+    // aarch64-NEXT: fmov
+    // aarch64-NEXT: and
+    simd_bitmask(mask)
+}
+
+// CHECK-LABEL: bitmask_m64x2
+#[no_mangle]
+pub unsafe extern "C" fn bitmask_m64x2(mask: m64x2) -> u8 {
+    // The simd_bitmask intrinsic already uses the most significant bit, so no shift is necessary.
+    //
+    // x86-NOT: psllq
+    // x86: movmskpd eax, xmm0
+    //
+    // x86-avx2-NOT: vpsllq
+    // x86-avx2: vmovmskpd eax, xmm0
+    //
+    // x86-avx512-NOT: vpsllq
+    // x86-avx512: vmovmskpd eax, xmm0
+    //
+    // aarch64: adrp
+    // aarch64-NEXT: cmlt
+    // aarch64-NEXT: ldr
+    // aarch64-NEXT: and
+    // aarch64-NEXT: addp
+    // aarch64-NEXT: fmov
+    // aarch64-NEXT: and
+    simd_bitmask(mask)
+}
+
+// x86-avx2-LABEL: bitmask_m64x4
+// x86-avx512-LABEL: bitmask_m64x4
+#[no_mangle]
+#[cfg(any(x86_avx2, x86_avx512))]
+pub unsafe extern "C" fn bitmask_m64x4(mask: m64x4) -> u8 {
+    // The simd_bitmask intrinsic already uses the most significant bit, so no shift is necessary.
+    //
+    // The parameter is a 256 bit vector which in the C abi is only valid for avx/avx512 targets.
+    //
+    // x86-avx2-NOT: vpsllq
+    // x86-avx2: vmovmskpd eax, ymm0
+    //
+    // x86-avx512-NOT: vpsllq
+    // x86-avx512: vmovmskpd eax, ymm0
+    simd_bitmask(mask)
+}
diff --git a/tests/assembly-llvm/simd-intrinsic-gather.rs b/tests/assembly-llvm/simd-intrinsic-gather.rs
new file mode 100644
index 00000000000..bcab0ba1cc0
--- /dev/null
+++ b/tests/assembly-llvm/simd-intrinsic-gather.rs
@@ -0,0 +1,39 @@
+//@ add-core-stubs
+//@ revisions: x86-avx512
+//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
+//@ [x86-avx512] needs-llvm-components: x86
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
+
+#![feature(no_core, lang_items, repr_simd, intrinsics)]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(simd)]
+pub struct f64x4([f64; 4]);
+
+#[repr(simd)]
+pub struct m64x4([i64; 4]);
+
+#[repr(simd)]
+pub struct pf64x4([*const f64; 4]);
+
+#[rustc_intrinsic]
+unsafe fn simd_gather<V, M, P>(values: V, mask: M, pointer: P) -> V;
+
+// CHECK-LABEL: gather_f64x4
+#[no_mangle]
+pub unsafe extern "C" fn gather_f64x4(mask: m64x4, ptrs: pf64x4) -> f64x4 {
+    // FIXME: This should also get checked to generate a gather instruction for avx2.
+    // Currently llvm scalarizes this code, see https://github.com/llvm/llvm-project/issues/59789
+    //
+    // x86-avx512-NOT: vpsllq
+    // x86-avx512: vpmovq2m k1, ymm0
+    // x86-avx512-NEXT: vpxor xmm0, xmm0, xmm0
+    // x86-avx512-NEXT: vgatherqpd ymm0 {k1}, {{(ymmword)|(qword)}} ptr [1*ymm1]
+    simd_gather(f64x4([0_f64, 0_f64, 0_f64, 0_f64]), ptrs, mask)
+}
diff --git a/tests/assembly-llvm/simd-intrinsic-mask-load.rs b/tests/assembly-llvm/simd-intrinsic-mask-load.rs
new file mode 100644
index 00000000000..d3f3453a780
--- /dev/null
+++ b/tests/assembly-llvm/simd-intrinsic-mask-load.rs
@@ -0,0 +1,83 @@
+//@ add-core-stubs
+//@ revisions: x86-avx2 x86-avx512
+//@ [x86-avx2] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@ [x86-avx2] compile-flags: -C target-feature=+avx2
+//@ [x86-avx2] needs-llvm-components: x86
+//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
+//@ [x86-avx512] needs-llvm-components: x86
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
+
+#![feature(no_core, lang_items, repr_simd, intrinsics)]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(simd)]
+pub struct i8x16([i8; 16]);
+
+#[repr(simd)]
+pub struct m8x16([i8; 16]);
+
+#[repr(simd)]
+pub struct f32x8([f32; 8]);
+
+#[repr(simd)]
+pub struct m32x8([i32; 8]);
+
+#[repr(simd)]
+pub struct f64x4([f64; 4]);
+
+#[repr(simd)]
+pub struct m64x4([i64; 4]);
+
+#[rustc_intrinsic]
+unsafe fn simd_masked_load<M, P, T>(mask: M, pointer: P, values: T) -> T;
+
+// CHECK-LABEL: load_i8x16
+#[no_mangle]
+pub unsafe extern "C" fn load_i8x16(mask: m8x16, pointer: *const i8) -> i8x16 {
+    // Since avx2 supports no masked loads for bytes, the code tests each individual bit
+    // and jumps to code that inserts individual bytes.
+    // x86-avx2-NOT: vpsllw
+    // x86-avx2-DAG: vpmovmskb eax
+    // x86-avx2-DAG: vpxor
+    // x86-avx2-NEXT: test al, 1
+    // x86-avx2-NEXT: jne
+    // x86-avx2-NEXT: test al, 2
+    // x86-avx2-NEXT: jne
+    // x86-avx2-DAG: movzx [[REG:[a-z]+]], byte ptr [rdi]
+    // x86-avx2-NEXT: vmovd xmm0, [[REG]]
+    // x86-avx2-DAG: vpinsrb xmm0, xmm0, byte ptr [rdi + 1], 1
+    //
+    // x86-avx512-NOT: vpsllw
+    // x86-avx512: vpmovb2m k1, xmm0
+    // x86-avx512-NEXT: vmovdqu8 xmm0 {k1} {z}, xmmword ptr [rdi]
+    simd_masked_load(mask, pointer, i8x16([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+}
+
+// CHECK-LABEL: load_f32x8
+#[no_mangle]
+pub unsafe extern "C" fn load_f32x8(mask: m32x8, pointer: *const f32) -> f32x8 {
+    // x86-avx2-NOT: vpslld
+    // x86-avx2: vmaskmovps ymm0, ymm0, ymmword ptr [rdi]
+    //
+    // x86-avx512-NOT: vpslld
+    // x86-avx512: vpmovd2m k1, ymm0
+    // x86-avx512-NEXT: vmovups ymm0 {k1} {z}, ymmword ptr [rdi]
+    simd_masked_load(mask, pointer, f32x8([0_f32, 0_f32, 0_f32, 0_f32, 0_f32, 0_f32, 0_f32, 0_f32]))
+}
+
+// CHECK-LABEL: load_f64x4
+#[no_mangle]
+pub unsafe extern "C" fn load_f64x4(mask: m64x4, pointer: *const f64) -> f64x4 {
+    // x86-avx2-NOT: vpsllq
+    // x86-avx2: vmaskmovpd ymm0, ymm0, ymmword ptr [rdi]
+    //
+    // x86-avx512-NOT: vpsllq
+    // x86-avx512: vpmovq2m k1, ymm0
+    simd_masked_load(mask, pointer, f64x4([0_f64, 0_f64, 0_f64, 0_f64]))
+}
diff --git a/tests/assembly-llvm/simd-intrinsic-mask-reduce.rs b/tests/assembly-llvm/simd-intrinsic-mask-reduce.rs
new file mode 100644
index 00000000000..8b15ed0a254
--- /dev/null
+++ b/tests/assembly-llvm/simd-intrinsic-mask-reduce.rs
@@ -0,0 +1,59 @@
+// verify that simd mask reductions do not introduce additional bit shift operations
+//@ add-core-stubs
+//@ revisions: x86 aarch64
+//@ [x86] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+// Set the base cpu explicitly, in case the default has been changed.
+//@ [x86] compile-flags: -C target-cpu=x86-64
+//@ [x86] needs-llvm-components: x86
+//@ [aarch64] compile-flags: --target=aarch64-unknown-linux-gnu
+//@ [aarch64] needs-llvm-components: aarch64
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
+
+#![feature(no_core, lang_items, repr_simd, intrinsics)]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(simd)]
+pub struct mask8x16([i8; 16]);
+
+#[rustc_intrinsic]
+unsafe fn simd_reduce_all<T>(x: T) -> bool;
+#[rustc_intrinsic]
+unsafe fn simd_reduce_any<T>(x: T) -> bool;
+
+// CHECK-LABEL: mask_reduce_all:
+#[no_mangle]
+pub unsafe extern "C" fn mask_reduce_all(m: mask8x16) -> bool {
+    // x86-NOT: psllw
+    // x86: pmovmskb eax, xmm0
+    // x86-NEXT: {{cmp ax, -1|cmp eax, 65535|xor eax, 65535}}
+    // x86-NEXT: sete al
+    //
+    // aarch64-NOT: shl
+    // aarch64: cmge v0.16b, v0.16b, #0
+    // aarch64-DAG: mov [[REG1:[a-z0-9]+]], #1
+    // aarch64-DAG: umaxv b0, v0.16b
+    // aarch64-NEXT: fmov [[REG2:[a-z0-9]+]], s0
+    // aarch64-NEXT: bic w0, [[REG1]], [[REG2]]
+    simd_reduce_all(m)
+}
+
+// CHECK-LABEL: mask_reduce_any:
+#[no_mangle]
+pub unsafe extern "C" fn mask_reduce_any(m: mask8x16) -> bool {
+    // x86-NOT: psllw
+    // x86: pmovmskb
+    // x86-NEXT: test eax, eax
+    // x86-NEXT: setne al
+    //
+    // aarch64-NOT: shl
+    // aarch64: cmlt v0.16b, v0.16b, #0
+    // aarch64-NEXT: umaxv b0, v0.16b
+    // aarch64-NEXT: fmov [[REG:[a-z0-9]+]], s0
+    // aarch64-NEXT: and w0, [[REG]], #0x1
+    simd_reduce_any(m)
+}
diff --git a/tests/assembly-llvm/simd-intrinsic-mask-store.rs b/tests/assembly-llvm/simd-intrinsic-mask-store.rs
new file mode 100644
index 00000000000..001762e5060
--- /dev/null
+++ b/tests/assembly-llvm/simd-intrinsic-mask-store.rs
@@ -0,0 +1,82 @@
+//@ add-core-stubs
+//@ revisions: x86-avx2 x86-avx512
+//@ [x86-avx2] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@ [x86-avx2] compile-flags: -C target-feature=+avx2
+//@ [x86-avx2] needs-llvm-components: x86
+//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
+//@ [x86-avx512] needs-llvm-components: x86
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
+
+#![feature(no_core, lang_items, repr_simd, intrinsics)]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(simd)]
+pub struct i8x16([i8; 16]);
+
+#[repr(simd)]
+pub struct m8x16([i8; 16]);
+
+#[repr(simd)]
+pub struct f32x8([f32; 8]);
+
+#[repr(simd)]
+pub struct m32x8([i32; 8]);
+
+#[repr(simd)]
+pub struct f64x4([f64; 4]);
+
+#[repr(simd)]
+pub struct m64x4([i64; 4]);
+
+#[rustc_intrinsic]
+unsafe fn simd_masked_store<M, P, T>(mask: M, pointer: P, values: T);
+
+// CHECK-LABEL: store_i8x16
+#[no_mangle]
+pub unsafe extern "C" fn store_i8x16(mask: m8x16, pointer: *mut i8, value: i8x16) {
+    // Since avx2 supports no masked stores for bytes, the code tests each individual bit
+    // and jumps to code that extracts individual bytes to memory.
+    // x86-avx2-NOT: vpsllw
+    // x86-avx2: vpmovmskb eax, xmm0
+    // x86-avx2-NEXT: test al, 1
+    // x86-avx2-NEXT: jne
+    // x86-avx2-NEXT: test al, 2
+    // x86-avx2-NEXT: jne
+    // x86-avx2-DAG: vpextrb byte ptr [rdi + 1], xmm1, 1
+    // x86-avx2-DAG: vpextrb byte ptr [rdi], xmm1, 0
+    //
+    // x86-avx512-NOT: vpsllw
+    // x86-avx512: vpmovb2m k1, xmm0
+    // x86-avx512-NEXT: vmovdqu8 xmmword ptr [rdi] {k1}, xmm1
+    simd_masked_store(mask, pointer, value)
+}
+
+// CHECK-LABEL: store_f32x8
+#[no_mangle]
+pub unsafe extern "C" fn store_f32x8(mask: m32x8, pointer: *mut f32, value: f32x8) {
+    // x86-avx2-NOT: vpslld
+    // x86-avx2: vmaskmovps ymmword ptr [rdi], ymm0, ymm1
+    //
+    // x86-avx512-NOT: vpslld
+    // x86-avx512: vpmovd2m k1, ymm0
+    // x86-avx512-NEXT: vmovups ymmword ptr [rdi] {k1}, ymm1
+    simd_masked_store(mask, pointer, value)
+}
+
+// CHECK-LABEL: store_f64x4
+#[no_mangle]
+pub unsafe extern "C" fn store_f64x4(mask: m64x4, pointer: *mut f64, value: f64x4) {
+    // x86-avx2-NOT: vpsllq
+    // x86-avx2: vmaskmovpd ymmword ptr [rdi], ymm0, ymm1
+    //
+    // x86-avx512-NOT: vpsllq
+    // x86-avx512: vpmovq2m k1, ymm0
+    // x86-avx512-NEXT: vmovupd ymmword ptr [rdi] {k1}, ymm1
+    simd_masked_store(mask, pointer, value)
+}
diff --git a/tests/assembly-llvm/simd-intrinsic-scatter.rs b/tests/assembly-llvm/simd-intrinsic-scatter.rs
new file mode 100644
index 00000000000..d77dfad3546
--- /dev/null
+++ b/tests/assembly-llvm/simd-intrinsic-scatter.rs
@@ -0,0 +1,35 @@
+//@ add-core-stubs
+//@ revisions: x86-avx512
+//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
+//@ [x86-avx512] needs-llvm-components: x86
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
+
+#![feature(no_core, lang_items, repr_simd, intrinsics)]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(simd)]
+pub struct f64x4([f64; 4]);
+
+#[repr(simd)]
+pub struct m64x4([i64; 4]);
+
+#[repr(simd)]
+pub struct pf64x4([*mut f64; 4]);
+
+#[rustc_intrinsic]
+unsafe fn simd_scatter<V, P, M>(values: V, pointer: P, mask: M);
+
+// CHECK-LABEL: scatter_f64x4
+#[no_mangle]
+pub unsafe extern "C" fn scatter_f64x4(values: f64x4, ptrs: pf64x4, mask: m64x4) {
+    // x86-avx512-NOT: vpsllq
+    // x86-avx512: vpmovq2m k1, ymm2
+    // x86-avx512-NEXT: vscatterqpd {{(ymmword)|(qword)}} ptr [1*ymm1] {k1}, ymm0
+    simd_scatter(values, ptrs, mask)
+}
diff --git a/tests/assembly-llvm/simd-intrinsic-select.rs b/tests/assembly-llvm/simd-intrinsic-select.rs
new file mode 100644
index 00000000000..e7c7b0db0d5
--- /dev/null
+++ b/tests/assembly-llvm/simd-intrinsic-select.rs
@@ -0,0 +1,128 @@
+//@ add-core-stubs
+//@ revisions: x86-avx2 x86-avx512 aarch64
+//@ [x86-avx2] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@ [x86-avx2] compile-flags: -C target-feature=+avx2
+//@ [x86-avx2] needs-llvm-components: x86
+//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
+//@ [x86-avx512] needs-llvm-components: x86
+//@ [aarch64] compile-flags: --target=aarch64-unknown-linux-gnu
+//@ [aarch64] needs-llvm-components: aarch64
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
+
+#![feature(no_core, lang_items, repr_simd, intrinsics)]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(simd)]
+pub struct i8x16([i8; 16]);
+
+#[repr(simd)]
+pub struct m8x16([i8; 16]);
+
+#[repr(simd)]
+pub struct f32x4([f32; 4]);
+
+#[repr(simd)]
+pub struct m32x4([i32; 4]);
+
+#[repr(simd)]
+pub struct f64x2([f64; 2]);
+
+#[repr(simd)]
+pub struct m64x2([i64; 2]);
+
+#[repr(simd)]
+pub struct f64x4([f64; 4]);
+
+#[repr(simd)]
+pub struct m64x4([i64; 4]);
+
+#[repr(simd)]
+pub struct f64x8([f64; 8]);
+
+#[repr(simd)]
+pub struct m64x8([i64; 8]);
+
+#[rustc_intrinsic]
+unsafe fn simd_select<M, V>(mask: M, a: V, b: V) -> V;
+
+// CHECK-LABEL: select_i8x16
+#[no_mangle]
+pub unsafe extern "C" fn select_i8x16(mask: m8x16, a: i8x16, b: i8x16) -> i8x16 {
+    // x86-avx2-NOT: vpsllw
+    // x86-avx2: vpblendvb xmm0, xmm2, xmm1, xmm0
+    //
+    // x86-avx512-NOT: vpsllw
+    // x86-avx512: vpmovb2m k1, xmm0
+    // x86-avx512-NEXT: vpblendmb xmm0 {k1}, xmm2, xmm1
+    //
+    // aarch64-NOT: shl
+    // aarch64: cmlt v0.16b, v0.16b, #0
+    // aarch64-NEXT: bsl v0.16b, v1.16b, v2.16b
+    simd_select(mask, a, b)
+}
+
+// CHECK-LABEL: select_f32x4
+#[no_mangle]
+pub unsafe extern "C" fn select_f32x4(mask: m32x4, a: f32x4, b: f32x4) -> f32x4 {
+    // x86-avx2-NOT: vpslld
+    // x86-avx2: vblendvps xmm0, xmm2, xmm1, xmm0
+    //
+    // x86-avx512-NOT: vpslld
+    // x86-avx512: vpmovd2m k1, xmm0
+    // x86-avx512-NEXT: vblendmps xmm0 {k1}, xmm2, xmm1
+    //
+    // aarch64-NOT: shl
+    // aarch64: cmlt v0.4s, v0.4s, #0
+    // aarch64-NEXT: bsl v0.16b, v1.16b, v2.16b
+    simd_select(mask, a, b)
+}
+
+// CHECK-LABEL: select_f64x2
+#[no_mangle]
+pub unsafe extern "C" fn select_f64x2(mask: m64x2, a: f64x2, b: f64x2) -> f64x2 {
+    // x86-avx2-NOT: vpsllq
+    // x86-avx2: vblendvpd xmm0, xmm2, xmm1, xmm0
+    //
+    // x86-avx512-NOT: vpsllq
+    // x86-avx512: vpmovq2m k1, xmm0
+    // x86-avx512-NEXT: vblendmpd xmm0 {k1}, xmm2, xmm1
+    //
+    // aarch64-NOT: shl
+    // aarch64: cmlt v0.2d, v0.2d, #0
+    // aarch64-NEXT: bsl v0.16b, v1.16b, v2.16b
+    simd_select(mask, a, b)
+}
+
+// x86-avx2-LABEL: select_f64x4
+// x86-avx512-LABEL: select_f64x4
+#[no_mangle]
+#[cfg(any(x86_avx2, x86_avx512))]
+pub unsafe extern "C" fn select_f64x4(mask: m64x4, a: f64x4, b: f64x4) -> f64x4 {
+    // The parameter is a 256 bit vector which in the C abi is only valid for avx targets.
+    //
+    // x86-avx2-NOT: vpsllq
+    // x86-avx2: vblendvpd ymm0, ymm2, ymm1, ymm0
+    //
+    // x86-avx512-NOT: vpsllq
+    // x86-avx512: vpmovq2m k1, ymm0
+    // x86-avx512-NEXT: vblendmpd ymm0 {k1}, ymm2, ymm1
+    simd_select(mask, a, b)
+}
+
+// x86-avx512-LABEL: select_f64x8
+#[no_mangle]
+#[cfg(x86_avx512)]
+pub unsafe extern "C" fn select_f64x8(mask: m64x8, a: f64x8, b: f64x8) -> f64x8 {
+    // The parameter is a 256 bit vector which in the C abi is only valid for avx512 targets.
+    //
+    // x86-avx512-NOT: vpsllq
+    // x86-avx512: vpmovq2m k1, zmm0
+    // x86-avx512-NEXT: vblendmpd zmm0 {k1}, zmm2, zmm1
+    simd_select(mask, a, b)
+}
diff --git a/tests/assembly-llvm/simd/reduce-fadd-unordered.rs b/tests/assembly-llvm/simd/reduce-fadd-unordered.rs
new file mode 100644
index 00000000000..e872826f6ef
--- /dev/null
+++ b/tests/assembly-llvm/simd/reduce-fadd-unordered.rs
@@ -0,0 +1,31 @@
+//@ revisions: x86_64 aarch64
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3
+
+//@[aarch64] only-aarch64
+//@[x86_64] only-x86_64
+//@[x86_64] compile-flags: -Ctarget-feature=+sse3
+//@ ignore-sgx Test incompatible with LVI mitigations
+#![feature(portable_simd)]
+#![feature(core_intrinsics)]
+use std::intrinsics::simd as intrinsics;
+use std::simd::*;
+// Regression test for https://github.com/rust-lang/rust/issues/130028
+// This intrinsic produces much worse code if you use +0.0 instead of -0.0 because
+// +0.0 isn't as easy to algebraically reassociate, even using LLVM's reassoc attribute!
+// It would emit about an extra fadd, depending on the architecture.
+
+// CHECK-LABEL: reduce_fadd_negative_zero
+pub unsafe fn reduce_fadd_negative_zero(v: f32x4) -> f32 {
+    // x86_64: addps
+    // x86_64-NEXT: movshdup
+    // x86_64-NEXT: addss
+    // x86_64-NOT: xorps
+
+    // aarch64: faddp
+    // aarch64-NEXT: faddp
+
+    // CHECK-NOT: {{f?}}add{{p?s*}}
+    // CHECK: ret
+    intrinsics::simd_reduce_add_unordered(v)
+}
diff --git a/tests/assembly-llvm/slice-is_ascii.rs b/tests/assembly-llvm/slice-is_ascii.rs
new file mode 100644
index 00000000000..e53cd5160cf
--- /dev/null
+++ b/tests/assembly-llvm/slice-is_ascii.rs
@@ -0,0 +1,33 @@
+//@ revisions: WIN LIN
+//@ [WIN] only-windows
+//@ [LIN] only-linux
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C llvm-args=-x86-asm-syntax=intel
+//@ only-x86_64
+//@ ignore-sgx
+
+#![feature(str_internals)]
+
+// CHECK-LABEL: is_ascii_simple_demo:
+#[no_mangle]
+pub fn is_ascii_simple_demo(bytes: &[u8]) -> bool {
+    // Linux (System V): pointer is rdi; length is rsi
+    // Windows: pointer is rcx; length is rdx.
+
+    // CHECK-NOT: mov
+    // CHECK-NOT: test
+    // CHECK-NOT: cmp
+
+    // CHECK: .[[LOOPHEAD:.+]]:
+    // CHECK-NEXT: mov [[TEMP:.+]], [[LEN:rsi|rdx]]
+    // CHECK-NEXT: sub [[LEN]], 1
+    // CHECK-NEXT: jb .[[LOOPEXIT:.+]]
+    // CHECK-NEXT: cmp byte ptr [{{rdi|rcx}} + [[TEMP]] - 1], 0
+    // CHECK-NEXT: jns .[[LOOPHEAD]]
+
+    // CHECK-NEXT: .[[LOOPEXIT]]:
+    // CHECK-NEXT: test [[TEMP]], [[TEMP]]
+    // CHECK-NEXT: sete al
+    // CHECK-NEXT: ret
+    core::slice::is_ascii_simple(bytes)
+}
diff --git a/tests/assembly-llvm/small_data_threshold.rs b/tests/assembly-llvm/small_data_threshold.rs
new file mode 100644
index 00000000000..2abe8687d8b
--- /dev/null
+++ b/tests/assembly-llvm/small_data_threshold.rs
@@ -0,0 +1,98 @@
+// Test for -Z small_data_threshold=...
+//@ revisions: RISCV MIPS HEXAGON M68K
+//@ assembly-output: emit-asm
+//@ compile-flags: -Z small_data_threshold=4
+//@ [RISCV] compile-flags: --target=riscv32im-unknown-none-elf
+//@ [RISCV] needs-llvm-components: riscv
+//@ [MIPS] compile-flags: --target=mips-unknown-linux-uclibc -C relocation-model=static
+//@ [MIPS] compile-flags: -C llvm-args=-mgpopt -C llvm-args=-mlocal-sdata
+//@ [MIPS] compile-flags: -C target-feature=+noabicalls
+//@ [MIPS] needs-llvm-components: mips
+//@ [HEXAGON] compile-flags: --target=hexagon-unknown-linux-musl -C target-feature=+small-data
+//@ [HEXAGON] compile-flags: -C llvm-args=--hexagon-statics-in-small-data
+//@ [HEXAGON] needs-llvm-components: hexagon
+//@ [M68K] compile-flags: --target=m68k-unknown-linux-gnu
+//@ [M68K] needs-llvm-components: m68k
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+
+#[lang = "drop_in_place"]
+fn drop_in_place<T>(_: *mut T) {}
+
+#[used]
+#[no_mangle]
+// U is below the threshold, should be in sdata
+static mut U: u16 = 123;
+
+#[used]
+#[no_mangle]
+// V is below the threshold, should be in sbss
+static mut V: u16 = 0;
+
+#[used]
+#[no_mangle]
+// W is at the threshold, should be in sdata
+static mut W: u32 = 123;
+
+#[used]
+#[no_mangle]
+// X is at the threshold, should be in sbss
+static mut X: u32 = 0;
+
+#[used]
+#[no_mangle]
+// Y is over the threshold, should be in its own .data section
+static mut Y: u64 = 123;
+
+#[used]
+#[no_mangle]
+// Z is over the threshold, should be in its own .bss section
+static mut Z: u64 = 0;
+
+// Currently, only MIPS and RISCV successfully put any objects in the small data
+// sections so the U/V/W/X tests are skipped on Hexagon and M68K
+
+// RISCV: .section .sdata
+// RISCV-NOT: .section
+// RISCV: U:
+// RISCV: .section .sbss
+// RISCV-NOT: .section
+// RISCV: V:
+// RISCV: .section .sdata
+// RISCV-NOT: .section
+// RISCV: W:
+// RISCV: .section .sbss
+// RISCV-NOT: .section
+// RISCV: X:
+
+// MIPS: .section .sdata
+// MIPS-NOT: .section
+// MIPS: U:
+// MIPS: .section .sbss
+// MIPS-NOT: .section
+// MIPS: V:
+// MIPS: .section .sdata
+// MIPS-NOT: .section
+// MIPS: W:
+// MIPS: .section .sbss
+// MIPS-NOT: .section
+// MIPS: X:
+
+// CHECK: .section .data.Y,
+// CHECK-NOT: .section
+// CHECK: Y:
+// CHECK: .section .bss.Z,
+// CHECK-NOT: .section
+// CHECK: Z:
diff --git a/tests/assembly-llvm/sparc-struct-abi.rs b/tests/assembly-llvm/sparc-struct-abi.rs
new file mode 100644
index 00000000000..b1594428811
--- /dev/null
+++ b/tests/assembly-llvm/sparc-struct-abi.rs
@@ -0,0 +1,68 @@
+// Test SPARC64 ABI
+// - float structure members are passes in floating point registers
+// (#86163)
+
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ needs-llvm-components: sparc
+//@ compile-flags: --target=sparcv9-sun-solaris -Copt-level=3
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C)]
+pub struct Franta {
+    a: f32,
+    b: f32,
+    c: f32,
+    d: f32,
+}
+
+// NB: due to delay slots the `ld` following the call is actually executed before the call.
+#[no_mangle]
+pub unsafe extern "C" fn callee(arg: Franta) {
+    // CHECK-LABEL: callee:
+    // CHECK: st %f3, [[PLACE_D:.*]]
+    // CHECK: st %f2, [[PLACE_C:.*]]
+    // CHECK: st %f1, [[PLACE_B:.*]]
+    // CHECK: st %f0, [[PLACE_A:.*]]
+    // CHECK: call tst_use
+    // CHECK-NEXT: ld [[PLACE_A]], %f1
+    // CHECK: call tst_use
+    // CHECK-NEXT: ld [[PLACE_B]], %f1
+    // CHECK: call tst_use
+    // CHECK-NEXT: ld [[PLACE_C]], %f1
+    // CHECK: call tst_use
+    // CHECK-NEXT: ld [[PLACE_D]], %f1
+    clobber();
+    tst_use(arg.a);
+    tst_use(arg.b);
+    tst_use(arg.c);
+    tst_use(arg.d);
+    tail_call_avoidance_fn();
+}
+
+extern "C" {
+    fn opaque_callee(arg: Franta, intarg: i32);
+    fn tst_use(arg: f32);
+    fn clobber();
+    // This exists so that post-https://reviews.llvm.org/D138741 LLVM doesn't
+    // tail-call away some of our assertions.
+    fn tail_call_avoidance_fn();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn caller() {
+    // CHECK-LABEL: caller:
+    // CHECK: ld [{{.*}}], %f0
+    // CHECK: ld [{{.*}}], %f1
+    // CHECK: ld [{{.*}}], %f2
+    // CHECK: ld [{{.*}}], %f3
+    // CHECK: call opaque_callee
+    // CHECK: mov     3, %o2
+    opaque_callee(Franta { a: 1.0, b: 2.0, c: 3.0, d: 4.0 }, 3);
+    tail_call_avoidance_fn();
+}
diff --git a/tests/assembly-llvm/stack-probes.rs b/tests/assembly-llvm/stack-probes.rs
new file mode 100644
index 00000000000..de245431f47
--- /dev/null
+++ b/tests/assembly-llvm/stack-probes.rs
@@ -0,0 +1,41 @@
+//@ add-core-stubs
+//@ revisions: x86_64 i686 aarch64
+//@ assembly-output: emit-asm
+//@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@[x86_64] needs-llvm-components: x86
+//@[i686] compile-flags: --target i686-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
+//@[i686] needs-llvm-components: x86
+//@[aarch64] compile-flags: --target aarch64-unknown-linux-gnu
+//@[aarch64] needs-llvm-components: aarch64
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// Check that inline-asm stack probes are generated correctly.
+// To avoid making this test fragile to slight asm changes,
+// we only check that the stack pointer is decremented by a page at a time,
+// instead of matching the whole probe sequence.
+
+// CHECK-LABEL: small_stack_probe:
+#[no_mangle]
+pub fn small_stack_probe(x: u8, f: fn(&mut [u8; 8192])) {
+    // CHECK-NOT: __rust_probestack
+    // x86_64: sub rsp, 4096
+    // i686: sub esp, 4096
+    // aarch64: sub sp, sp, #1, lsl #12
+    f(&mut [x; 8192]);
+}
+
+// CHECK-LABEL: big_stack_probe:
+#[no_mangle]
+pub fn big_stack_probe(x: u8, f: fn(&[u8; 65536])) {
+    // CHECK-NOT: __rust_probestack
+    // x86_64: sub rsp, 4096
+    // i686: sub esp, 4096
+    // aarch64: sub sp, sp, #1, lsl #12
+    f(&mut [x; 65536]);
+}
diff --git a/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-windows-32bit.rs b/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-windows-32bit.rs
new file mode 100644
index 00000000000..3287e018b40
--- /dev/null
+++ b/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-windows-32bit.rs
@@ -0,0 +1,359 @@
+//@ revisions: all strong basic none missing
+//@ assembly-output: emit-asm
+//@ only-windows
+//@ only-msvc
+//@ ignore-64bit 64-bit table based SEH has slightly different behaviors than classic SEH
+//@ [all] compile-flags: -Z stack-protector=all
+//@ [strong] compile-flags: -Z stack-protector=strong
+//@ [basic] compile-flags: -Z stack-protector=basic
+//@ [none] compile-flags: -Z stack-protector=none
+//@ compile-flags: -C opt-level=2 -Z merge-functions=disabled
+
+#![crate_type = "lib"]
+#![allow(internal_features)]
+#![feature(unsized_fn_params)]
+
+// CHECK-LABEL: emptyfn:
+#[no_mangle]
+pub fn emptyfn() {
+    // all: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: array_char
+#[no_mangle]
+pub fn array_char(f: fn(*const char)) {
+    let a = ['c'; 1];
+    let b = ['d'; 3];
+    let c = ['e'; 15];
+
+    f(&a as *const _);
+    f(&b as *const _);
+    f(&c as *const _);
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: array_u8_1
+#[no_mangle]
+pub fn array_u8_1(f: fn(*const u8)) {
+    let a = [0u8; 1];
+    f(&a as *const _);
+
+    // The 'strong' heuristic adds stack protection to functions with local
+    // array variables regardless of their size.
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: array_u8_small:
+#[no_mangle]
+pub fn array_u8_small(f: fn(*const u8)) {
+    let a = [0u8; 2];
+    let b = [0u8; 7];
+    f(&a as *const _);
+    f(&b as *const _);
+
+    // Small arrays do not lead to stack protection by the 'basic' heuristic.
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: array_u8_large:
+#[no_mangle]
+pub fn array_u8_large(f: fn(*const u8)) {
+    let a = [0u8; 9];
+    f(&a as *const _);
+
+    // Since `a` is a byte array with size greater than 8, the basic heuristic
+    // will also protect this function.
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+#[derive(Copy, Clone)]
+pub struct ByteSizedNewtype(u8);
+
+// CHECK-LABEL: array_bytesizednewtype_9:
+#[no_mangle]
+pub fn array_bytesizednewtype_9(f: fn(*const ByteSizedNewtype)) {
+    let a = [ByteSizedNewtype(0); 9];
+    f(&a as *const _);
+
+    // Since `a` is a byte array in the LLVM output, the basic heuristic will
+    // also protect this function.
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: local_var_addr_used_indirectly
+#[no_mangle]
+pub fn local_var_addr_used_indirectly(f: fn(bool)) {
+    let a = 5;
+    let a_addr = &a as *const _ as usize;
+    f(a_addr & 0x10 == 0);
+
+    // This function takes the address of a local variable taken. Although this
+    // address is never used as a way to refer to stack memory, the `strong`
+    // heuristic adds stack smash protection. This is also the case in C++:
+    // ```
+    // cat << EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
+    // #include <cstdint>
+    // void f(void (*g)(bool)) {
+    //     int32_t x;
+    //     g((reinterpret_cast<uintptr_t>(&x) & 0x10U) == 0);
+    // }
+    // EOF
+    // ```
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: local_string_addr_taken
+#[no_mangle]
+pub fn local_string_addr_taken(f: fn(&String)) {
+    let x = String::new();
+    f(&x);
+
+    // Taking the address of the local variable `x` leads to stack smash
+    // protection with the `strong` heuristic, but not with the `basic`
+    // heuristic. It does not matter that the reference is not mut.
+    //
+    // An interesting note is that a similar function in C++ *would* be
+    // protected by the `basic` heuristic, because `std::string` has a char
+    // array internally as a small object optimization:
+    // ```
+    // cat <<EOF | clang++ -O2 -fstack-protector -S -x c++ - -o - | grep stack_chk
+    // #include <string>
+    // void f(void (*g)(const std::string&)) {
+    //     std::string x;
+    //     g(x);
+    // }
+    // EOF
+    // ```
+    //
+
+    // all: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+pub trait SelfByRef {
+    fn f(&self) -> i32;
+}
+
+impl SelfByRef for i32 {
+    fn f(&self) -> i32 {
+        return self + 1;
+    }
+}
+
+// CHECK-LABEL: local_var_addr_taken_used_locally_only
+#[no_mangle]
+pub fn local_var_addr_taken_used_locally_only(factory: fn() -> i32, sink: fn(i32)) {
+    let x = factory();
+    let g = x.f();
+    sink(g);
+
+    // Even though the local variable conceptually has its address taken, as
+    // it's passed by reference to the trait function, the use of the reference
+    // is easily inlined. There is therefore no stack smash protection even with
+    // the `strong` heuristic.
+
+    // all: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+pub struct Gigastruct {
+    does: u64,
+    not: u64,
+    have: u64,
+    array: u64,
+    members: u64,
+}
+
+// CHECK-LABEL: local_large_var_moved
+#[no_mangle]
+pub fn local_large_var_moved(f: fn(Gigastruct)) {
+    let x = Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 };
+    f(x);
+
+    // Even though the local variable conceptually doesn't have its address
+    // taken, it's so large that the "move" is implemented with a reference to a
+    // stack-local variable in the ABI. Consequently, this function *is*
+    // protected. This is also the case for rvalue-references in C++,
+    // regardless of struct size:
+    // ```
+    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
+    // #include <cstdint>
+    // #include <utility>
+    // void f(void (*g)(uint64_t&&)) {
+    //     uint64_t x;
+    //     g(std::move(x));
+    // }
+    // EOF
+    // ```
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: local_large_var_cloned
+#[no_mangle]
+pub fn local_large_var_cloned(f: fn(Gigastruct)) {
+    f(Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 });
+
+    // A new instance of `Gigastruct` is passed to `f()`, without any apparent
+    // connection to this stack frame. Still, since instances of `Gigastruct`
+    // are sufficiently large, it is allocated in the caller stack frame and
+    // passed as a pointer. As such, this function is *also* protected, just
+    // like `local_large_var_moved`. This is also the case for pass-by-value
+    // of sufficiently large structs in C++:
+    // ```
+    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
+    // #include <cstdint>
+    // #include <utility>
+    // struct Gigastruct { uint64_t a, b, c, d, e; };
+    // void f(void (*g)(Gigastruct)) {
+    //     g(Gigastruct{});
+    // }
+    // EOF
+    // ```
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+extern "C" {
+    // A call to an external `alloca` function is *not* recognized as an
+    // `alloca(3)` operation. This function is a compiler built-in, as the
+    // man page explains. Clang translates it to an LLVM `alloca`
+    // instruction with a count argument, which is also what the LLVM stack
+    // protector heuristics looks for. The man page for `alloca(3)` details
+    // a way to avoid using the compiler built-in: pass a -std=c11
+    // argument, *and* don't include <alloca.h>. Though this leads to an
+    // external alloca() function being called, it doesn't lead to stack
+    // protection being included. It even fails with a linker error
+    // "undefined reference to `alloca'". Example:
+    // ```
+    // cat<<EOF | clang -fstack-protector-strong -x c -std=c11 - -o /dev/null
+    // #include <stdlib.h>
+    // void * alloca(size_t);
+    // void f(void (*g)(void*)) {
+    //     void * p = alloca(10);
+    //     g(p);
+    // }
+    // int main() { return 0; }
+    // EOF
+    // ```
+    // The following tests demonstrate that calls to an external `alloca`
+    // function in Rust also doesn't trigger stack protection.
+
+    fn alloca(size: usize) -> *mut ();
+}
+
+// CHECK-LABEL: alloca_small_compile_time_constant_arg
+#[no_mangle]
+pub fn alloca_small_compile_time_constant_arg(f: fn(*mut ())) {
+    f(unsafe { alloca(8) });
+
+    // all: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: alloca_large_compile_time_constant_arg
+#[no_mangle]
+pub fn alloca_large_compile_time_constant_arg(f: fn(*mut ())) {
+    f(unsafe { alloca(9) });
+
+    // all: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: alloca_dynamic_arg
+#[no_mangle]
+pub fn alloca_dynamic_arg(f: fn(*mut ()), n: usize) {
+    f(unsafe { alloca(n) });
+
+    // all: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// The question then is: in what ways can Rust code generate array-`alloca`
+// LLVM instructions? This appears to only be generated by
+// rustc_codegen_ssa::traits::Builder::array_alloca() through
+// rustc_codegen_ssa::mir::operand::OperandValue::store_unsized(). FWICT
+// this is support for the "unsized locals" unstable feature:
+// https://doc.rust-lang.org/unstable-book/language-features/unsized-locals.html.
+
+// CHECK-LABEL: unsized_fn_param
+#[no_mangle]
+pub fn unsized_fn_param(s: [u8], l: bool, f: fn([u8])) {
+    let n = if l { 1 } else { 2 };
+    f(*Box::<[u8]>::from(&s[0..n])); // slice-copy with Box::from
+
+    // Even though slices are conceptually passed by-value both into this
+    // function and into `f()`, this is implemented with pass-by-reference
+    // using a suitably constructed fat-pointer (as if the functions
+    // accepted &[u8]). This function therefore doesn't need dynamic array
+    // alloca, and is therefore not protected by the `strong` or `basic`
+    // heuristics.
+
+    // We should have a __security_check_cookie call in `all` and `strong` modes but
+    // LLVM does not support generating stack protectors in functions with funclet
+    // based EH personalities.
+    // https://github.com/llvm/llvm-project/blob/37fd3c96b917096d8a550038f6e61cdf0fc4174f/llvm/lib/CodeGen/StackProtector.cpp#L103C1-L109C4
+    // all-NOT: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
diff --git a/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-windows-64bit.rs b/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-windows-64bit.rs
new file mode 100644
index 00000000000..9a3dabc74dd
--- /dev/null
+++ b/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect-windows-64bit.rs
@@ -0,0 +1,366 @@
+//@ revisions: all strong basic none missing
+//@ assembly-output: emit-asm
+//@ only-windows
+//@ only-msvc
+//@ ignore-32bit 64-bit table based SEH has slightly different behaviors than classic SEH
+//@ [all] compile-flags: -Z stack-protector=all
+//@ [strong] compile-flags: -Z stack-protector=strong
+//@ [basic] compile-flags: -Z stack-protector=basic
+//@ [none] compile-flags: -Z stack-protector=none
+//@ compile-flags: -C opt-level=2 -Z merge-functions=disabled
+
+#![crate_type = "lib"]
+#![feature(unsized_fn_params)]
+
+// CHECK-LABEL: emptyfn:
+#[no_mangle]
+pub fn emptyfn() {
+    // all: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: array_char
+#[no_mangle]
+pub fn array_char(f: fn(*const char)) {
+    let a = ['c'; 1];
+    let b = ['d'; 3];
+    let c = ['e'; 15];
+
+    f(&a as *const _);
+    f(&b as *const _);
+    f(&c as *const _);
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: array_u8_1
+#[no_mangle]
+pub fn array_u8_1(f: fn(*const u8)) {
+    let a = [0u8; 1];
+    f(&a as *const _);
+
+    // The 'strong' heuristic adds stack protection to functions with local
+    // array variables regardless of their size.
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: array_u8_small:
+#[no_mangle]
+pub fn array_u8_small(f: fn(*const u8)) {
+    let a = [0u8; 2];
+    let b = [0u8; 7];
+    f(&a as *const _);
+    f(&b as *const _);
+
+    // Small arrays do not lead to stack protection by the 'basic' heuristic.
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: array_u8_large:
+#[no_mangle]
+pub fn array_u8_large(f: fn(*const u8)) {
+    let a = [0u8; 9];
+    f(&a as *const _);
+
+    // Since `a` is a byte array with size greater than 8, the basic heuristic
+    // will also protect this function.
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+#[derive(Copy, Clone)]
+pub struct ByteSizedNewtype(u8);
+
+// CHECK-LABEL: array_bytesizednewtype_9:
+#[no_mangle]
+pub fn array_bytesizednewtype_9(f: fn(*const ByteSizedNewtype)) {
+    let a = [ByteSizedNewtype(0); 9];
+    f(&a as *const _);
+
+    // Since `a` is a byte array in the LLVM output, the basic heuristic will
+    // also protect this function.
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: local_var_addr_used_indirectly
+#[no_mangle]
+pub fn local_var_addr_used_indirectly(f: fn(bool)) {
+    let a = 5;
+    let a_addr = &a as *const _ as usize;
+    f(a_addr & 0x10 == 0);
+
+    // This function takes the address of a local variable taken. Although this
+    // address is never used as a way to refer to stack memory, the `strong`
+    // heuristic adds stack smash protection. This is also the case in C++:
+    // ```
+    // cat << EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
+    // #include <cstdint>
+    // void f(void (*g)(bool)) {
+    //     int32_t x;
+    //     g((reinterpret_cast<uintptr_t>(&x) & 0x10U) == 0);
+    // }
+    // EOF
+    // ```
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: local_string_addr_taken
+#[no_mangle]
+pub fn local_string_addr_taken(f: fn(&String)) {
+    // CHECK-DAG: .seh_endprologue
+    let x = String::new();
+    f(&x);
+
+    // Taking the address of the local variable `x` leads to stack smash
+    // protection with the `strong` heuristic, but not with the `basic`
+    // heuristic. It does not matter that the reference is not mut.
+    //
+    // An interesting note is that a similar function in C++ *would* be
+    // protected by the `basic` heuristic, because `std::string` has a char
+    // array internally as a small object optimization:
+    // ```
+    // cat <<EOF | clang++ -O2 -fstack-protector -S -x c++ - -o - | grep stack_chk
+    // #include <string>
+    // void f(void (*g)(const std::string&)) {
+    //     std::string x;
+    //     g(x);
+    // }
+    // EOF
+    // ```
+    //
+
+    // We should have a __security_check_cookie call in `all` and `strong` modes but
+    // LLVM does not support generating stack protectors in functions with funclet
+    // based EH personalities.
+    // https://github.com/llvm/llvm-project/blob/37fd3c96b917096d8a550038f6e61cdf0fc4174f/llvm/lib/CodeGen/StackProtector.cpp#L103C1-L109C4
+    // all-NOT: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+
+    // CHECK-DAG: .seh_endproc
+}
+
+pub trait SelfByRef {
+    fn f(&self) -> i32;
+}
+
+impl SelfByRef for i32 {
+    fn f(&self) -> i32 {
+        return self + 1;
+    }
+}
+
+// CHECK-LABEL: local_var_addr_taken_used_locally_only
+#[no_mangle]
+pub fn local_var_addr_taken_used_locally_only(factory: fn() -> i32, sink: fn(i32)) {
+    let x = factory();
+    let g = x.f();
+    sink(g);
+
+    // Even though the local variable conceptually has its address taken, as
+    // it's passed by reference to the trait function, the use of the reference
+    // is easily inlined. There is therefore no stack smash protection even with
+    // the `strong` heuristic.
+
+    // all: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+pub struct Gigastruct {
+    does: u64,
+    not: u64,
+    have: u64,
+    array: u64,
+    members: u64,
+}
+
+// CHECK-LABEL: local_large_var_moved
+#[no_mangle]
+pub fn local_large_var_moved(f: fn(Gigastruct)) {
+    let x = Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 };
+    f(x);
+
+    // Even though the local variable conceptually doesn't have its address
+    // taken, it's so large that the "move" is implemented with a reference to a
+    // stack-local variable in the ABI. Consequently, this function *is*
+    // protected. This is also the case for rvalue-references in C++,
+    // regardless of struct size:
+    // ```
+    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
+    // #include <cstdint>
+    // #include <utility>
+    // void f(void (*g)(uint64_t&&)) {
+    //     uint64_t x;
+    //     g(std::move(x));
+    // }
+    // EOF
+    // ```
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: local_large_var_cloned
+#[no_mangle]
+pub fn local_large_var_cloned(f: fn(Gigastruct)) {
+    f(Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 });
+
+    // A new instance of `Gigastruct` is passed to `f()`, without any apparent
+    // connection to this stack frame. Still, since instances of `Gigastruct`
+    // are sufficiently large, it is allocated in the caller stack frame and
+    // passed as a pointer. As such, this function is *also* protected, just
+    // like `local_large_var_moved`. This is also the case for pass-by-value
+    // of sufficiently large structs in C++:
+    // ```
+    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
+    // #include <cstdint>
+    // #include <utility>
+    // struct Gigastruct { uint64_t a, b, c, d, e; };
+    // void f(void (*g)(Gigastruct)) {
+    //     g(Gigastruct{});
+    // }
+    // EOF
+    // ```
+
+    // all: __security_check_cookie
+    // strong: __security_check_cookie
+    // basic: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+extern "C" {
+    // A call to an external `alloca` function is *not* recognized as an
+    // `alloca(3)` operation. This function is a compiler built-in, as the
+    // man page explains. Clang translates it to an LLVM `alloca`
+    // instruction with a count argument, which is also what the LLVM stack
+    // protector heuristics looks for. The man page for `alloca(3)` details
+    // a way to avoid using the compiler built-in: pass a -std=c11
+    // argument, *and* don't include <alloca.h>. Though this leads to an
+    // external alloca() function being called, it doesn't lead to stack
+    // protection being included. It even fails with a linker error
+    // "undefined reference to `alloca'". Example:
+    // ```
+    // cat<<EOF | clang -fstack-protector-strong -x c -std=c11 - -o /dev/null
+    // #include <stdlib.h>
+    // void * alloca(size_t);
+    // void f(void (*g)(void*)) {
+    //     void * p = alloca(10);
+    //     g(p);
+    // }
+    // int main() { return 0; }
+    // EOF
+    // ```
+    // The following tests demonstrate that calls to an external `alloca`
+    // function in Rust also doesn't trigger stack protection.
+
+    fn alloca(size: usize) -> *mut ();
+}
+
+// CHECK-LABEL: alloca_small_compile_time_constant_arg
+#[no_mangle]
+pub fn alloca_small_compile_time_constant_arg(f: fn(*mut ())) {
+    f(unsafe { alloca(8) });
+
+    // all: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: alloca_large_compile_time_constant_arg
+#[no_mangle]
+pub fn alloca_large_compile_time_constant_arg(f: fn(*mut ())) {
+    f(unsafe { alloca(9) });
+
+    // all: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// CHECK-LABEL: alloca_dynamic_arg
+#[no_mangle]
+pub fn alloca_dynamic_arg(f: fn(*mut ()), n: usize) {
+    f(unsafe { alloca(n) });
+
+    // all: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
+
+// The question then is: in what ways can Rust code generate array-`alloca`
+// LLVM instructions? This appears to only be generated by
+// rustc_codegen_ssa::traits::Builder::array_alloca() through
+// rustc_codegen_ssa::mir::operand::OperandValue::store_unsized(). FWICT
+// this is support for the "unsized locals" unstable feature:
+// https://doc.rust-lang.org/unstable-book/language-features/unsized-locals.html.
+
+// CHECK-LABEL: unsized_fn_param
+#[no_mangle]
+pub fn unsized_fn_param(s: [u8], l: bool, f: fn([u8])) {
+    let n = if l { 1 } else { 2 };
+    f(*Box::<[u8]>::from(&s[0..n])); // slice-copy with Box::from
+
+    // Even though slices are conceptually passed by-value both into this
+    // function and into `f()`, this is implemented with pass-by-reference
+    // using a suitably constructed fat-pointer (as if the functions
+    // accepted &[u8]). This function therefore doesn't need dynamic array
+    // alloca, and is therefore not protected by the `strong` or `basic`
+    // heuristics.
+
+    // We should have a __security_check_cookie call in `all` and `strong` modes but
+    // LLVM does not support generating stack protectors in functions with funclet
+    // based EH personalities.
+    // https://github.com/llvm/llvm-project/blob/37fd3c96b917096d8a550038f6e61cdf0fc4174f/llvm/lib/CodeGen/StackProtector.cpp#L103C1-L109C4
+    // all-NOT: __security_check_cookie
+    // strong-NOT: __security_check_cookie
+
+    // basic-NOT: __security_check_cookie
+    // none-NOT: __security_check_cookie
+    // missing-NOT: __security_check_cookie
+}
diff --git a/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect.rs b/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect.rs
new file mode 100644
index 00000000000..ae281cb95da
--- /dev/null
+++ b/tests/assembly-llvm/stack-protector/stack-protector-heuristics-effect.rs
@@ -0,0 +1,345 @@
+//@ revisions: all strong basic none missing
+//@ assembly-output: emit-asm
+//@ ignore-apple slightly different policy on stack protection of arrays
+//@ ignore-msvc stack check code uses different function names
+//@ ignore-nvptx64 stack protector is not supported
+//@ ignore-wasm32-bare
+//@ [all] compile-flags: -Z stack-protector=all
+//@ [strong] compile-flags: -Z stack-protector=strong
+//@ [basic] compile-flags: -Z stack-protector=basic
+//@ [none] compile-flags: -Z stack-protector=none
+//@ compile-flags: -C opt-level=2 -Z merge-functions=disabled
+
+// NOTE: the heuristics for stack smash protection inappropriately rely on types in LLVM IR,
+// despite those types having no semantic meaning. This means that the `basic` and `strong`
+// settings do not behave in a coherent way. This is a known issue in LLVM.
+// See comments on https://github.com/rust-lang/rust/issues/114903.
+
+#![crate_type = "lib"]
+#![allow(internal_features)]
+#![feature(unsized_fn_params)]
+
+// CHECK-LABEL: emptyfn{{:|\[}}
+#[no_mangle]
+pub fn emptyfn() {
+    // all: __stack_chk_fail
+    // strong-NOT: __stack_chk_fail
+    // basic-NOT: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+// CHECK-LABEL: array_char{{:|\[}}
+#[no_mangle]
+pub fn array_char(f: fn(*const char)) {
+    let a = ['c'; 1];
+    let b = ['d'; 3];
+    let c = ['e'; 15];
+
+    f(&a as *const _);
+    f(&b as *const _);
+    f(&c as *const _);
+
+    // all: __stack_chk_fail
+    // strong: __stack_chk_fail
+    // basic: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+// CHECK-LABEL: array_u8_1{{:|\[}}
+#[no_mangle]
+pub fn array_u8_1(f: fn(*const u8)) {
+    let a = [0u8; 1];
+    f(&a as *const _);
+
+    // The 'strong' heuristic adds stack protection to functions with local
+    // array variables regardless of their size.
+
+    // all: __stack_chk_fail
+    // strong: __stack_chk_fail
+    // basic-NOT: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+// CHECK-LABEL: array_u8_small{{:|\[}}
+#[no_mangle]
+pub fn array_u8_small(f: fn(*const u8)) {
+    let a = [0u8; 2];
+    let b = [0u8; 7];
+    f(&a as *const _);
+    f(&b as *const _);
+
+    // Small arrays do not lead to stack protection by the 'basic' heuristic.
+
+    // all: __stack_chk_fail
+    // strong: __stack_chk_fail
+    // basic-NOT: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+// CHECK-LABEL: array_u8_large{{:|\[}}
+#[no_mangle]
+pub fn array_u8_large(f: fn(*const u8)) {
+    let a = [0u8; 9];
+    f(&a as *const _);
+
+    // Since `a` is a byte array with size greater than 8, the basic heuristic
+    // will also protect this function.
+
+    // all: __stack_chk_fail
+    // strong: __stack_chk_fail
+    // basic: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+#[derive(Copy, Clone)]
+pub struct ByteSizedNewtype(u8);
+
+// CHECK-LABEL: array_bytesizednewtype_9{{:|\[}}
+#[no_mangle]
+pub fn array_bytesizednewtype_9(f: fn(*const ByteSizedNewtype)) {
+    let a = [ByteSizedNewtype(0); 9];
+    f(&a as *const _);
+
+    // Since `a` is a byte array in the LLVM output, the basic heuristic will
+    // also protect this function.
+
+    // all: __stack_chk_fail
+    // strong: __stack_chk_fail
+    // basic: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+// CHECK-LABEL: local_var_addr_used_indirectly{{:|\[}}
+#[no_mangle]
+pub fn local_var_addr_used_indirectly(f: fn(bool)) {
+    let a = 5;
+    let a_addr = &a as *const _ as usize;
+    f(a_addr & 0x10 == 0);
+
+    // This function takes the address of a local variable taken. Although this
+    // address is never used as a way to refer to stack memory, the `strong`
+    // heuristic adds stack smash protection. This is also the case in C++:
+    // ```
+    // cat << EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
+    // #include <cstdint>
+    // void f(void (*g)(bool)) {
+    //     int32_t x;
+    //     g((reinterpret_cast<uintptr_t>(&x) & 0x10U) == 0);
+    // }
+    // EOF
+    // ```
+
+    // all: __stack_chk_fail
+    // strong: __stack_chk_fail
+    // basic-NOT: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+// CHECK-LABEL: local_string_addr_taken{{:|\[}}
+#[no_mangle]
+pub fn local_string_addr_taken(f: fn(&String)) {
+    let x = String::new();
+    f(&x);
+
+    // Taking the address of the local variable `x` leads to stack smash
+    // protection. It does not matter that the reference is not mut.
+
+    // all: __stack_chk_fail
+    // strong: __stack_chk_fail
+    // basic: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+pub trait SelfByRef {
+    fn f(&self) -> i32;
+}
+
+impl SelfByRef for i32 {
+    fn f(&self) -> i32 {
+        return self + 1;
+    }
+}
+
+// CHECK-LABEL: local_var_addr_taken_used_locally_only{{:|\[}}
+#[no_mangle]
+pub fn local_var_addr_taken_used_locally_only(factory: fn() -> i32, sink: fn(i32)) {
+    let x = factory();
+    let g = x.f();
+    sink(g);
+
+    // Even though the local variable conceptually has its address taken, as
+    // it's passed by reference to the trait function, the use of the reference
+    // is easily inlined. There is therefore no stack smash protection even with
+    // the `strong` heuristic.
+
+    // all: __stack_chk_fail
+    // strong-NOT: __stack_chk_fail
+    // basic-NOT: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+pub struct Gigastruct {
+    does: u64,
+    not: u64,
+    have: u64,
+    array: u64,
+    members: u64,
+}
+
+// CHECK-LABEL: local_large_var_moved{{:|\[}}
+#[no_mangle]
+pub fn local_large_var_moved(f: fn(Gigastruct)) {
+    let x = Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 };
+    f(x);
+
+    // Even though the local variable conceptually doesn't have its address
+    // taken, it's so large that the "move" is implemented with a reference to a
+    // stack-local variable in the ABI. Consequently, this function *is*
+    // protected. This is also the case for rvalue-references in C++,
+    // regardless of struct size:
+    // ```
+    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
+    // #include <cstdint>
+    // #include <utility>
+    // void f(void (*g)(uint64_t&&)) {
+    //     uint64_t x;
+    //     g(std::move(x));
+    // }
+    // EOF
+    // ```
+
+    // all: __stack_chk_fail
+    // strong: __stack_chk_fail
+    // basic: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+// CHECK-LABEL: local_large_var_cloned{{:|\[}}
+#[no_mangle]
+pub fn local_large_var_cloned(f: fn(Gigastruct)) {
+    f(Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 });
+
+    // A new instance of `Gigastruct` is passed to `f()`, without any apparent
+    // connection to this stack frame. Still, since instances of `Gigastruct`
+    // are sufficiently large, it is allocated in the caller stack frame and
+    // passed as a pointer. As such, this function is *also* protected, just
+    // like `local_large_var_moved`. This is also the case for pass-by-value
+    // of sufficiently large structs in C++:
+    // ```
+    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
+    // #include <cstdint>
+    // #include <utility>
+    // struct Gigastruct { uint64_t a, b, c, d, e; };
+    // void f(void (*g)(Gigastruct)) {
+    //     g(Gigastruct{});
+    // }
+    // EOF
+    // ```
+
+    // all: __stack_chk_fail
+    // strong: __stack_chk_fail
+    // basic: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+extern "C" {
+    // A call to an external `alloca` function is *not* recognized as an
+    // `alloca(3)` operation. This function is a compiler built-in, as the
+    // man page explains. Clang translates it to an LLVM `alloca`
+    // instruction with a count argument, which is also what the LLVM stack
+    // protector heuristics looks for. The man page for `alloca(3)` details
+    // a way to avoid using the compiler built-in: pass a -std=c11
+    // argument, *and* don't include <alloca.h>. Though this leads to an
+    // external alloca() function being called, it doesn't lead to stack
+    // protection being included. It even fails with a linker error
+    // "undefined reference to `alloca'". Example:
+    // ```
+    // cat<<EOF | clang -fstack-protector-strong -x c -std=c11 - -o /dev/null
+    // #include <stdlib.h>
+    // void * alloca(size_t);
+    // void f(void (*g)(void*)) {
+    //     void * p = alloca(10);
+    //     g(p);
+    // }
+    // int main() { return 0; }
+    // EOF
+    // ```
+    // The following tests demonstrate that calls to an external `alloca`
+    // function in Rust also doesn't trigger stack protection.
+
+    fn alloca(size: usize) -> *mut ();
+}
+
+// CHECK-LABEL: alloca_small_compile_time_constant_arg{{:|\[}}
+#[no_mangle]
+pub fn alloca_small_compile_time_constant_arg(f: fn(*mut ())) {
+    f(unsafe { alloca(8) });
+
+    // all: __stack_chk_fail
+    // strong-NOT: __stack_chk_fail
+    // basic-NOT: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+// CHECK-LABEL: alloca_large_compile_time_constant_arg{{:|\[}}
+#[no_mangle]
+pub fn alloca_large_compile_time_constant_arg(f: fn(*mut ())) {
+    f(unsafe { alloca(9) });
+
+    // all: __stack_chk_fail
+    // strong-NOT: __stack_chk_fail
+    // basic-NOT: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+// CHECK-LABEL: alloca_dynamic_arg{{:|\[}}
+#[no_mangle]
+pub fn alloca_dynamic_arg(f: fn(*mut ()), n: usize) {
+    f(unsafe { alloca(n) });
+
+    // all: __stack_chk_fail
+    // strong-NOT: __stack_chk_fail
+    // basic-NOT: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
+
+// The question then is: in what ways can Rust code generate array-`alloca`
+// LLVM instructions? This appears to only be generated by
+// rustc_codegen_ssa::traits::Builder::array_alloca() through
+// rustc_codegen_ssa::mir::operand::OperandValue::store_unsized(). FWICT
+// this is support for the "unsized locals" unstable feature:
+// https://doc.rust-lang.org/unstable-book/language-features/unsized-locals.html.
+
+// CHECK-LABEL: unsized_fn_param{{:|\[}}
+#[no_mangle]
+pub fn unsized_fn_param(s: [u8], l: bool, f: fn([u8])) {
+    let n = if l { 1 } else { 2 };
+    f(*Box::<[u8]>::from(&s[0..n])); // slice-copy with Box::from
+
+    // Even though slices are conceptually passed by-value both into this
+    // function and into `f()`, this is implemented with pass-by-reference
+    // using a suitably constructed fat-pointer (as if the functions
+    // accepted &[u8]). This function therefore doesn't need dynamic array
+    // alloca, and is therefore not protected by the `strong` or `basic`
+    // heuristics.
+
+    // all: __stack_chk_fail
+    // strong-NOT: __stack_chk_fail
+    // basic-NOT: __stack_chk_fail
+    // none-NOT: __stack_chk_fail
+    // missing-NOT: __stack_chk_fail
+}
diff --git a/tests/assembly-llvm/stack-protector/stack-protector-target-support.rs b/tests/assembly-llvm/stack-protector/stack-protector-target-support.rs
new file mode 100644
index 00000000000..a937256a60f
--- /dev/null
+++ b/tests/assembly-llvm/stack-protector/stack-protector-target-support.rs
@@ -0,0 +1,281 @@
+// Test that stack smash protection code is emitted for all tier1 and tier2
+// targets, with the exception of nvptx64-nvidia-cuda
+//
+//@ add-core-stubs
+//@ revisions: r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 r16 r17 r18 r19 r20 r21 r22 r23
+//@ revisions: r24 r25 r26 r27 r28 r29 r30 r31 r32 r33         r36 r37 r38 r39 r40 r41 r42 r43 r44
+//@ revisions: r45 r46 r47 r48 r49 r50 r51 r52 r53 r54 r55 r56 r57 r58 r59 r60 r61 r62 r63 r64 r65
+//@ revisions: r66 r67 r68 r69 r70 r71 r72 r73 r74 r75 r76 r77 r78 r79 r80 r81 r82 r83 r84 r85
+//@ assembly-output: emit-asm
+//@ [r1] compile-flags: --target aarch64-unknown-linux-gnu
+//@ [r1] needs-llvm-components: aarch64
+//@ [r2] compile-flags: --target i686-pc-windows-gnu
+//@ [r2] needs-llvm-components: x86
+//@ [r3] compile-flags: --target i686-pc-windows-msvc
+//@ [r3] needs-llvm-components: x86
+//@ [r4] compile-flags: --target i686-unknown-linux-gnu
+//@ [r4] needs-llvm-components: x86
+//@ [r5] compile-flags: --target x86_64-apple-darwin
+//@ [r5] needs-llvm-components: x86
+//@ [r6] compile-flags: --target x86_64-pc-windows-gnu
+//@ [r6] needs-llvm-components: x86
+//@ [r7] compile-flags: --target x86_64-pc-windows-msvc
+//@ [r7] needs-llvm-components: x86
+//@ [r8] compile-flags: --target x86_64-unknown-linux-gnu
+//@ [r8] needs-llvm-components: x86
+//@ [r9] compile-flags: --target aarch64-apple-darwin
+//@ [r9] needs-llvm-components: aarch64
+//@ [r10] compile-flags: --target aarch64-apple-ios
+//@ [r10] needs-llvm-components: aarch64
+//@ [r11] compile-flags: --target aarch64-unknown-fuchsia
+//@ [r11] needs-llvm-components: aarch64
+//@ [r12] compile-flags: --target aarch64-linux-android
+//@ [r12] needs-llvm-components: aarch64
+//@ [r13] compile-flags: --target aarch64-pc-windows-msvc
+//@ [r13] needs-llvm-components: aarch64
+//@ [r14] compile-flags: --target aarch64-unknown-linux-musl
+//@ [r14] needs-llvm-components: aarch64
+//@ [r15] compile-flags: --target aarch64-unknown-none
+//@ [r15] needs-llvm-components: aarch64
+//@ [r16] compile-flags: --target aarch64-unknown-none-softfloat
+//@ [r16] needs-llvm-components: aarch64
+//@ [r17] compile-flags: --target arm-linux-androideabi
+//@ [r17] needs-llvm-components: arm
+//@ [r18] compile-flags: --target arm-unknown-linux-gnueabi
+//@ [r18] needs-llvm-components: arm
+//@ [r19] compile-flags: --target arm-unknown-linux-gnueabihf
+//@ [r19] needs-llvm-components: arm
+//@ [r20] compile-flags: --target arm-unknown-linux-musleabi
+//@ [r20] needs-llvm-components: arm
+//@ [r21] compile-flags: --target arm-unknown-linux-musleabihf
+//@ [r21] needs-llvm-components: arm
+//@ [r22] compile-flags: --target armebv7r-none-eabi
+//@ [r22] needs-llvm-components: arm
+//@ [r23] compile-flags: --target armebv7r-none-eabihf
+//@ [r23] needs-llvm-components: arm
+//@ [r24] compile-flags: --target armv5te-unknown-linux-gnueabi
+//@ [r24] needs-llvm-components: arm
+//@ [r25] compile-flags: --target armv5te-unknown-linux-musleabi
+//@ [r25] needs-llvm-components: arm
+//@ [r26] compile-flags: --target armv7-linux-androideabi
+//@ [r26] needs-llvm-components: arm
+//@ [r27] compile-flags: --target armv7a-none-eabi
+//@ [r27] needs-llvm-components: arm
+//@ [r28] compile-flags: --target armv7r-none-eabi
+//@ [r28] needs-llvm-components: arm
+//@ [r29] compile-flags: --target armv7r-none-eabihf
+//@ [r29] needs-llvm-components: arm
+//@ [r30] compile-flags: --target armv7-unknown-linux-gnueabi
+//@ [r30] needs-llvm-components: arm
+//@ [r31] compile-flags: --target armv7-unknown-linux-gnueabihf
+//@ [r31] needs-llvm-components: arm
+//@ [r32] compile-flags: --target armv7-unknown-linux-musleabi
+//@ [r32] needs-llvm-components: arm
+//@ [r33] compile-flags: --target armv7-unknown-linux-musleabihf
+//@ [r33] needs-llvm-components: arm
+//@ [r36] compile-flags: --target i586-unknown-linux-gnu
+//@ [r36] needs-llvm-components: x86
+//@ [r37] compile-flags: --target i586-unknown-linux-musl
+//@ [r37] needs-llvm-components: x86
+//@ [r38] compile-flags: --target i686-linux-android
+//@ [r38] needs-llvm-components: x86
+//@ [r39] compile-flags: --target i686-unknown-freebsd
+//@ [r39] needs-llvm-components: x86
+//@ [r40] compile-flags: --target i686-unknown-linux-musl
+//@ [r40] needs-llvm-components: x86
+//@ [r41] compile-flags: --target mips-unknown-linux-gnu
+//@ [r41] needs-llvm-components: mips
+//@ [r42] compile-flags: --target mips-unknown-linux-musl
+//@ [r42] needs-llvm-components: mips
+//@ [r43] compile-flags: --target mips64-unknown-linux-gnuabi64
+//@ [r43] needs-llvm-components: mips
+//@ [r44] compile-flags: --target mips64-unknown-linux-muslabi64
+//@ [r44] needs-llvm-components: mips
+//@ [r45] compile-flags: --target mips64el-unknown-linux-gnuabi64
+//@ [r45] needs-llvm-components: mips
+//@ [r46] compile-flags: --target mips64el-unknown-linux-muslabi64
+//@ [r46] needs-llvm-components: mips
+//@ [r47] compile-flags: --target mipsel-unknown-linux-gnu
+//@ [r47] needs-llvm-components: mips
+//@ [r48] compile-flags: --target mipsel-unknown-linux-musl
+//@ [r48] needs-llvm-components: mips
+//@ [r49] compile-flags: --target nvptx64-nvidia-cuda
+//@ [r49] needs-llvm-components: nvptx
+//@ [r50] compile-flags: --target powerpc-unknown-linux-gnu
+//@ [r50] needs-llvm-components: powerpc
+//@ [r51] compile-flags: --target powerpc64-unknown-linux-gnu
+//@ [r51] needs-llvm-components: powerpc
+//@ [r52] compile-flags: --target powerpc64le-unknown-linux-gnu
+//@ [r52] needs-llvm-components: powerpc
+//@ [r53] compile-flags: --target riscv32i-unknown-none-elf
+//@ [r53] needs-llvm-components: riscv
+//@ [r54] compile-flags: --target riscv32imac-unknown-none-elf
+//@ [r54] needs-llvm-components: riscv
+//@ [r55] compile-flags:--target riscv32imc-unknown-none-elf
+//@ [r55] needs-llvm-components: riscv
+//@ [r56] compile-flags:--target riscv64gc-unknown-linux-gnu
+//@ [r56] needs-llvm-components: riscv
+//@ [r57] compile-flags:--target riscv64gc-unknown-none-elf
+//@ [r57] needs-llvm-components: riscv
+//@ [r58] compile-flags:--target riscv64imac-unknown-none-elf
+//@ [r58] needs-llvm-components: riscv
+//@ [r59] compile-flags:--target s390x-unknown-linux-gnu
+//@ [r59] needs-llvm-components: systemz
+//@ [r60] compile-flags:--target sparc64-unknown-linux-gnu
+//@ [r60] needs-llvm-components: sparc
+//@ [r61] compile-flags:--target sparcv9-sun-solaris
+//@ [r61] needs-llvm-components: sparc
+//@ [r62] compile-flags:--target thumbv6m-none-eabi
+//@ [r62] needs-llvm-components: arm
+//@ [r63] compile-flags:--target thumbv7em-none-eabi
+//@ [r63] needs-llvm-components: arm
+//@ [r64] compile-flags:--target thumbv7em-none-eabihf
+//@ [r64] needs-llvm-components: arm
+//@ [r65] compile-flags:--target thumbv7m-none-eabi
+//@ [r65] needs-llvm-components: arm
+//@ [r66] compile-flags:--target thumbv7neon-linux-androideabi
+//@ [r66] needs-llvm-components: arm
+//@ [r67] compile-flags:--target thumbv7neon-unknown-linux-gnueabihf
+//@ [r67] needs-llvm-components: arm
+//@ [r68] compile-flags:--target thumbv8m.base-none-eabi
+//@ [r68] needs-llvm-components: arm
+//@ [r69] compile-flags:--target thumbv8m.main-none-eabi
+//@ [r69] needs-llvm-components: arm
+//@ [r70] compile-flags:--target thumbv8m.main-none-eabihf
+//@ [r70] needs-llvm-components: arm
+//@ [r71] compile-flags:--target wasm32-unknown-emscripten
+//@ [r71] needs-llvm-components: webassembly
+//@ [r72] compile-flags:--target wasm32-unknown-unknown
+//@ [r72] needs-llvm-components: webassembly
+//@ [r73] compile-flags:--target wasm32-wasip1
+//@ [r73] needs-llvm-components: webassembly
+//@ [r74] compile-flags:--target wasm32-wasip1-threads
+//@ [r74] needs-llvm-components: webassembly
+//@ [r75] compile-flags:--target x86_64-apple-ios
+//@ [r75] needs-llvm-components: x86
+//@ [r76] compile-flags:--target x86_64-fortanix-unknown-sgx
+//@ [r76] needs-llvm-components: x86
+//@ [r77] compile-flags:--target x86_64-unknown-fuchsia
+//@ [r77] needs-llvm-components: x86
+//@ [r78] compile-flags:--target x86_64-linux-android
+//@ [r78] needs-llvm-components: x86
+//@ [r79] compile-flags:--target x86_64-pc-solaris
+//@ [r79] needs-llvm-components: x86
+//@ [r80] compile-flags:--target x86_64-unknown-freebsd
+//@ [r80] needs-llvm-components: x86
+//@ [r81] compile-flags:--target x86_64-unknown-illumos
+//@ [r81] needs-llvm-components: x86
+//@ [r82] compile-flags:--target x86_64-unknown-linux-gnux32
+//@ [r82] needs-llvm-components: x86
+//@ [r83] compile-flags:--target x86_64-unknown-linux-musl
+//@ [r83] needs-llvm-components: x86
+//@ [r84] compile-flags:--target x86_64-unknown-netbsd
+//@ [r84] needs-llvm-components: x86
+//@ [r85] compile-flags: --target x86_64-unknown-redox
+//@ [r85] needs-llvm-components: x86
+//@ compile-flags: -Z stack-protector=all
+//@ compile-flags: -C opt-level=2
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+pub fn foo() {
+    // CHECK: foo{{:|()}}
+
+    // MSVC does the stack checking within a stack-check function:
+    // r3: calll @__security_check_cookie
+    // r7: callq __security_check_cookie
+    // r13: bl __security_check_cookie
+
+    // cuda doesn't support stack-smash protection
+    // r49-NOT: __security_check_cookie
+    // r49-NOT: __stack_chk_fail
+
+    // Other targets do stack checking within the function, and call a failure function on error
+    // r1: __stack_chk_fail
+    // r2: __stack_chk_fail
+    // r4: __stack_chk_fail
+    // r5: __stack_chk_fail
+    // r6: __stack_chk_fail
+    // r8: __stack_chk_fail
+    // r9: __stack_chk_fail
+    // r10: __stack_chk_fail
+    // r11: __stack_chk_fail
+    // r12: __stack_chk_fail
+    // r14: __stack_chk_fail
+    // r15: __stack_chk_fail
+    // r16: __stack_chk_fail
+    // r17: __stack_chk_fail
+    // r18: __stack_chk_fail
+    // r19: __stack_chk_fail
+    // r20: __stack_chk_fail
+    // r21: __stack_chk_fail
+    // r22: __stack_chk_fail
+    // r23: __stack_chk_fail
+    // r24: __stack_chk_fail
+    // r25: __stack_chk_fail
+    // r26: __stack_chk_fail
+    // r27: __stack_chk_fail
+    // r28: __stack_chk_fail
+    // r29: __stack_chk_fail
+    // r30: __stack_chk_fail
+    // r31: __stack_chk_fail
+    // r32: __stack_chk_fail
+    // r33: __stack_chk_fail
+    // r34: __stack_chk_fail
+    // r36: __stack_chk_fail
+    // r37: __stack_chk_fail
+    // r38: __stack_chk_fail
+    // r39: __stack_chk_fail
+    // r40: __stack_chk_fail
+    // r41: __stack_chk_fail
+    // r42: __stack_chk_fail
+    // r43: __stack_chk_fail
+    // r44: __stack_chk_fail
+    // r45: __stack_chk_fail
+    // r46: __stack_chk_fail
+    // r47: __stack_chk_fail
+    // r48: __stack_chk_fail
+    // r50: __stack_chk_fail
+    // r51: __stack_chk_fail
+    // r52: __stack_chk_fail
+    // r53: __stack_chk_fail
+    // r54: __stack_chk_fail
+    // r55: __stack_chk_fail
+    // r56: __stack_chk_fail
+    // r57: __stack_chk_fail
+    // r58: __stack_chk_fail
+    // r59: __stack_chk_fail
+    // r60: __stack_chk_fail
+    // r61: __stack_chk_fail
+    // r62: __stack_chk_fail
+    // r63: __stack_chk_fail
+    // r64: __stack_chk_fail
+    // r65: __stack_chk_fail
+    // r66: __stack_chk_fail
+    // r67: __stack_chk_fail
+    // r68: __stack_chk_fail
+    // r69: __stack_chk_fail
+    // r70: __stack_chk_fail
+    // r71: __stack_chk_fail
+    // r72: __stack_chk_fail
+    // r73: __stack_chk_fail
+    // r74: __stack_chk_fail
+    // r75: __stack_chk_fail
+    // r76: __stack_chk_fail
+    // r77: __stack_chk_fail
+    // r78: __stack_chk_fail
+    // r79: __stack_chk_fail
+    // r80: __stack_chk_fail
+    // r81: __stack_chk_fail
+    // r82: __stack_chk_fail
+    // r83: __stack_chk_fail
+    // r84: __stack_chk_fail
+    // r85: __stack_chk_fail
+}
diff --git a/tests/assembly-llvm/static-relocation-model.rs b/tests/assembly-llvm/static-relocation-model.rs
new file mode 100644
index 00000000000..35ad94133b2
--- /dev/null
+++ b/tests/assembly-llvm/static-relocation-model.rs
@@ -0,0 +1,69 @@
+//@ add-core-stubs
+//@ revisions: x64 A64 ppc64le
+//@ assembly-output: emit-asm
+//@ [x64] compile-flags: --target x86_64-unknown-linux-gnu -Crelocation-model=static
+//@ [x64] needs-llvm-components: x86
+//@ [A64] compile-flags: --target aarch64-unknown-linux-gnu -Crelocation-model=static
+//@ [A64] needs-llvm-components: aarch64
+//@ [ppc64le] compile-flags: --target powerpc64le-unknown-linux-gnu -Crelocation-model=static
+//@ [ppc64le] needs-llvm-components: powerpc
+
+#![feature(no_core, lang_items)]
+#![no_core]
+#![crate_type = "rlib"]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+pub static PIERIS: u8 = 42;
+
+extern "C" {
+    static EXOCHORDA: *mut u8;
+
+    fn chaenomeles();
+}
+
+// CHECK-LABEL: banana:
+// LLVM may produce either kind of `mov` here, depending on version and optimization level.
+// x64: {{movb|movzbl}}   chaenomeles{{(\(%[a-z0-9]+\))?}}, %{{[a-z0-9]+}}
+// A64:      adrp    [[REG:[a-z0-9]+]], chaenomeles
+// A64-NEXT: ldrb    {{[a-z0-9]+}}, {{\[}}[[REG]], :lo12:chaenomeles]
+#[no_mangle]
+pub fn banana() -> u8 {
+    unsafe { *(chaenomeles as *mut u8) }
+}
+
+// CHECK-LABEL: peach:
+// x64: {{movb|movzbl}}    banana{{(\(%[a-z0-9]+\))?}}, %{{[a-z0-9]+}}
+// A64:      adrp    [[REG2:[a-z0-9]+]], banana
+// A64-NEXT: ldrb    {{[a-z0-9]+}}, {{\[}}[[REG2]], :lo12:banana]
+#[no_mangle]
+pub fn peach() -> u8 {
+    unsafe { *(banana as *mut u8) }
+}
+
+// CHECK-LABEL: mango:
+// x64:      movq    EXOCHORDA{{(\(%[a-z0-9]+\))?}}, %[[REG:[a-z0-9]+]]
+// x64-NEXT: {{movb|movzbl}}   (%[[REG]]), %{{[a-z0-9]+}}
+// A64:      adrp    [[REG2:[a-z0-9]+]], EXOCHORDA
+// A64-NEXT: ldr     {{[a-z0-9]+}}, {{\[}}[[REG2]], :lo12:EXOCHORDA]
+#[no_mangle]
+pub fn mango() -> u8 {
+    unsafe { *EXOCHORDA }
+}
+
+// CHECK-LABEL: orange:
+// x64: mov{{l|absq}}    $PIERIS, %{{[a-z0-9]+}}
+// A64:      adrp    [[REG2:[a-z0-9]+]], PIERIS
+// A64-NEXT: add     {{[a-z0-9]+}}, [[REG2]], :lo12:PIERIS
+#[no_mangle]
+pub fn orange() -> &'static u8 {
+    &PIERIS
+}
+
+// For ppc64 we need to make sure to generate TOC entries even with the static relocation model
+// ppc64le: .tc chaenomeles[TC],chaenomeles
+// ppc64le: .tc banana[TC],banana
+// ppc64le: .tc EXOCHORDA[TC],EXOCHORDA
+// ppc64le: .tc PIERIS[TC],PIERIS
diff --git a/tests/assembly-llvm/strict_provenance.rs b/tests/assembly-llvm/strict_provenance.rs
new file mode 100644
index 00000000000..1a797670962
--- /dev/null
+++ b/tests/assembly-llvm/strict_provenance.rs
@@ -0,0 +1,37 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=1
+//@ only-x86_64
+//@ ignore-sgx
+#![crate_type = "rlib"]
+
+// CHECK-LABEL: old_style
+// CHECK: movq %{{.*}}, %rax
+// CHECK: orq $1, %rax
+// CHECK: retq
+#[no_mangle]
+pub fn old_style(a: *mut u8) -> *mut u8 {
+    (a as usize | 1) as *mut u8
+}
+
+// CHECK-LABEL: cheri_compat
+// CHECK: movq %{{.*}}, %rax
+// CHECK: orq $1, %rax
+// CHECK: retq
+#[no_mangle]
+pub fn cheri_compat(a: *mut u8) -> *mut u8 {
+    let old = a as usize;
+    let new = old | 1;
+    let diff = new.wrapping_sub(old);
+    a.wrapping_add(diff)
+}
+
+// CHECK-LABEL: definitely_not_a_null_pointer
+// CHECK: movq %{{.*}}, %rax
+// CHECK: orq $1, %rax
+// CHECK: retq
+#[no_mangle]
+pub fn definitely_not_a_null_pointer(a: *mut u8) -> *mut u8 {
+    let old = a as usize;
+    let new = old | 1;
+    a.wrapping_sub(old).wrapping_add(new)
+}
diff --git a/tests/assembly-llvm/target-feature-multiple.rs b/tests/assembly-llvm/target-feature-multiple.rs
new file mode 100644
index 00000000000..bc432d21931
--- /dev/null
+++ b/tests/assembly-llvm/target-feature-multiple.rs
@@ -0,0 +1,40 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ needs-llvm-components: x86
+//@ revisions: TWOFLAGS SINGLEFLAG
+//@ compile-flags: --target=x86_64-unknown-linux-gnu
+//@ [TWOFLAGS] compile-flags: -C target-feature=+rdrnd -C target-feature=+rdseed
+//@ [SINGLEFLAG] compile-flags: -C target-feature=+rdrnd,+rdseed
+
+// Target features set via flags aren't necessarily reflected in the IR, so the only way to test
+// them is to build code that requires the features to be enabled to work.
+//
+// In this particular test if `rdrnd,rdseed` somehow didn't make it to LLVM, the instruction
+// selection should crash.
+//
+// > LLVM ERROR: Cannot select: 0x7f00f400c010: i32,i32,ch = X86ISD::RDSEED 0x7f00f400bfa8:2
+// > In function: foo
+//
+// See also tests/codegen/target-feature-overrides.rs
+#![feature(no_core, lang_items, link_llvm_intrinsics, abi_unadjusted)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// Use of these requires target features to be enabled
+extern "unadjusted" {
+    #[link_name = "llvm.x86.rdrand.32"]
+    fn x86_rdrand32_step() -> (u32, i32);
+    #[link_name = "llvm.x86.rdseed.32"]
+    fn x86_rdseed32_step() -> (u32, i32);
+}
+
+#[no_mangle]
+pub unsafe fn foo() -> (u32, u32) {
+    // CHECK-LABEL: foo:
+    // CHECK: rdrand
+    // CHECK: rdseed
+    (x86_rdrand32_step().0, x86_rdseed32_step().0)
+}
diff --git a/tests/assembly-llvm/targets/targets-amdgpu.rs b/tests/assembly-llvm/targets/targets-amdgpu.rs
new file mode 100644
index 00000000000..1d10b8fc315
--- /dev/null
+++ b/tests/assembly-llvm/targets/targets-amdgpu.rs
@@ -0,0 +1,22 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+// ignore-tidy-linelength
+//@ revisions: amdgcn_amd_amdhsa
+//@ [amdgcn_amd_amdhsa] compile-flags: --target amdgcn-amd-amdhsa -Ctarget-cpu=gfx900
+//@ [amdgcn_amd_amdhsa] needs-llvm-components: amdgpu
+
+// Sanity-check that each target can produce assembly code.
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn test() -> u8 {
+    42
+}
+
+// CHECK: .version
diff --git a/tests/assembly-llvm/targets/targets-elf.rs b/tests/assembly-llvm/targets/targets-elf.rs
new file mode 100644
index 00000000000..edf16548e7d
--- /dev/null
+++ b/tests/assembly-llvm/targets/targets-elf.rs
@@ -0,0 +1,734 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+// ignore-tidy-linelength
+//@ revisions: aarch64_be_unknown_linux_gnu
+//@ [aarch64_be_unknown_linux_gnu] compile-flags: --target aarch64_be-unknown-linux-gnu
+//@ [aarch64_be_unknown_linux_gnu] needs-llvm-components: aarch64
+//@ revisions: aarch64_be_unknown_linux_gnu_ilp32
+//@ [aarch64_be_unknown_linux_gnu_ilp32] compile-flags: --target aarch64_be-unknown-linux-gnu_ilp32
+//@ [aarch64_be_unknown_linux_gnu_ilp32] needs-llvm-components: aarch64
+//@ revisions: aarch64_be_unknown_netbsd
+//@ [aarch64_be_unknown_netbsd] compile-flags: --target aarch64_be-unknown-netbsd
+//@ [aarch64_be_unknown_netbsd] needs-llvm-components: aarch64
+//@ revisions: aarch64_kmc_solid_asp3
+//@ [aarch64_kmc_solid_asp3] compile-flags: --target aarch64-kmc-solid_asp3
+//@ [aarch64_kmc_solid_asp3] needs-llvm-components: aarch64
+//@ revisions: aarch64_linux_android
+//@ [aarch64_linux_android] compile-flags: --target aarch64-linux-android
+//@ [aarch64_linux_android] needs-llvm-components: aarch64
+//@ revisions: aarch64_nintendo_switch_freestanding
+//@ [aarch64_nintendo_switch_freestanding] compile-flags: --target aarch64-nintendo-switch-freestanding
+//@ [aarch64_nintendo_switch_freestanding] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_freebsd
+//@ [aarch64_unknown_freebsd] compile-flags: --target aarch64-unknown-freebsd
+//@ [aarch64_unknown_freebsd] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_fuchsia
+//@ [aarch64_unknown_fuchsia] compile-flags: --target aarch64-unknown-fuchsia
+//@ [aarch64_unknown_fuchsia] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_hermit
+//@ [aarch64_unknown_hermit] compile-flags: --target aarch64-unknown-hermit
+//@ [aarch64_unknown_hermit] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_illumos
+//@ [aarch64_unknown_illumos] compile-flags: --target aarch64-unknown-illumos
+//@ [aarch64_unknown_illumos] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_linux_gnu
+//@ [aarch64_unknown_linux_gnu] compile-flags: --target aarch64-unknown-linux-gnu
+//@ [aarch64_unknown_linux_gnu] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_linux_gnu_ilp32
+//@ [aarch64_unknown_linux_gnu_ilp32] compile-flags: --target aarch64-unknown-linux-gnu_ilp32
+//@ [aarch64_unknown_linux_gnu_ilp32] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_linux_musl
+//@ [aarch64_unknown_linux_musl] compile-flags: --target aarch64-unknown-linux-musl
+//@ [aarch64_unknown_linux_musl] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_linux_ohos
+//@ [aarch64_unknown_linux_ohos] compile-flags: --target aarch64-unknown-linux-ohos
+//@ [aarch64_unknown_linux_ohos] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_netbsd
+//@ [aarch64_unknown_netbsd] compile-flags: --target aarch64-unknown-netbsd
+//@ [aarch64_unknown_netbsd] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_none
+//@ [aarch64_unknown_none] compile-flags: --target aarch64-unknown-none
+//@ [aarch64_unknown_none] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_none_softfloat
+//@ [aarch64_unknown_none_softfloat] compile-flags: --target aarch64-unknown-none-softfloat
+//@ [aarch64_unknown_none_softfloat] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_nto_qnx700
+//@ [aarch64_unknown_nto_qnx700] compile-flags: --target aarch64-unknown-nto-qnx700
+//@ [aarch64_unknown_nto_qnx700] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_nto_qnx710
+//@ [aarch64_unknown_nto_qnx710] compile-flags: --target aarch64-unknown-nto-qnx710
+//@ [aarch64_unknown_nto_qnx710] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_nto_qnx710_iosock
+//@ [aarch64_unknown_nto_qnx710_iosock] compile-flags: --target aarch64-unknown-nto-qnx710_iosock
+//@ [aarch64_unknown_nto_qnx710_iosock] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_nto_qnx800
+//@ [aarch64_unknown_nto_qnx800] compile-flags: --target aarch64-unknown-nto-qnx800
+//@ [aarch64_unknown_nto_qnx800] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_openbsd
+//@ [aarch64_unknown_openbsd] compile-flags: --target aarch64-unknown-openbsd
+//@ [aarch64_unknown_openbsd] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_redox
+//@ [aarch64_unknown_redox] compile-flags: --target aarch64-unknown-redox
+//@ [aarch64_unknown_redox] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_teeos
+//@ [aarch64_unknown_teeos] compile-flags: --target aarch64-unknown-teeos
+//@ [aarch64_unknown_teeos] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_nuttx
+//@ [aarch64_unknown_nuttx] compile-flags: --target aarch64-unknown-nuttx
+//@ [aarch64_unknown_nuttx] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_trusty
+//@ [aarch64_unknown_trusty] compile-flags: --target aarch64-unknown-trusty
+//@ [aarch64_unknown_trusty] needs-llvm-components: aarch64
+//@ revisions: aarch64_wrs_vxworks
+//@ [aarch64_wrs_vxworks] compile-flags: --target aarch64-wrs-vxworks
+//@ [aarch64_wrs_vxworks] needs-llvm-components: aarch64
+//@ revisions: arm_linux_androideabi
+//@ [arm_linux_androideabi] compile-flags: --target arm-linux-androideabi
+//@ [arm_linux_androideabi] needs-llvm-components: arm
+//@ revisions: arm_unknown_linux_gnueabi
+//@ [arm_unknown_linux_gnueabi] compile-flags: --target arm-unknown-linux-gnueabi
+//@ [arm_unknown_linux_gnueabi] needs-llvm-components: arm
+//@ revisions: arm_unknown_linux_gnueabihf
+//@ [arm_unknown_linux_gnueabihf] compile-flags: --target arm-unknown-linux-gnueabihf
+//@ [arm_unknown_linux_gnueabihf] needs-llvm-components: arm
+//@ revisions: arm_unknown_linux_musleabi
+//@ [arm_unknown_linux_musleabi] compile-flags: --target arm-unknown-linux-musleabi
+//@ [arm_unknown_linux_musleabi] needs-llvm-components: arm
+//@ revisions: arm_unknown_linux_musleabihf
+//@ [arm_unknown_linux_musleabihf] compile-flags: --target arm-unknown-linux-musleabihf
+//@ [arm_unknown_linux_musleabihf] needs-llvm-components: arm
+//@ revisions: armeb_unknown_linux_gnueabi
+//@ [armeb_unknown_linux_gnueabi] compile-flags: --target armeb-unknown-linux-gnueabi
+//@ [armeb_unknown_linux_gnueabi] needs-llvm-components: arm
+//@ revisions: armebv7r_none_eabi
+//@ [armebv7r_none_eabi] compile-flags: --target armebv7r-none-eabi
+//@ [armebv7r_none_eabi] needs-llvm-components: arm
+//@ revisions: armebv7r_none_eabihf
+//@ [armebv7r_none_eabihf] compile-flags: --target armebv7r-none-eabihf
+//@ [armebv7r_none_eabihf] needs-llvm-components: arm
+//@ revisions: armv4t_none_eabi
+//@ [armv4t_none_eabi] compile-flags: --target armv4t-none-eabi
+//@ [armv4t_none_eabi] needs-llvm-components: arm
+//@ revisions: armv4t_unknown_linux_gnueabi
+//@ [armv4t_unknown_linux_gnueabi] compile-flags: --target armv4t-unknown-linux-gnueabi
+//@ [armv4t_unknown_linux_gnueabi] needs-llvm-components: arm
+//@ revisions: armv5te_none_eabi
+//@ [armv5te_none_eabi] compile-flags: --target armv5te-none-eabi
+//@ [armv5te_none_eabi] needs-llvm-components: arm
+//@ revisions: armv5te_unknown_linux_gnueabi
+//@ [armv5te_unknown_linux_gnueabi] compile-flags: --target armv5te-unknown-linux-gnueabi
+//@ [armv5te_unknown_linux_gnueabi] needs-llvm-components: arm
+//@ revisions: armv5te_unknown_linux_musleabi
+//@ [armv5te_unknown_linux_musleabi] compile-flags: --target armv5te-unknown-linux-musleabi
+//@ [armv5te_unknown_linux_musleabi] needs-llvm-components: arm
+//@ revisions: armv5te_unknown_linux_uclibceabi
+//@ [armv5te_unknown_linux_uclibceabi] compile-flags: --target armv5te-unknown-linux-uclibceabi
+//@ [armv5te_unknown_linux_uclibceabi] needs-llvm-components: arm
+//@ revisions: armv6_unknown_freebsd
+//@ [armv6_unknown_freebsd] compile-flags: --target armv6-unknown-freebsd
+//@ [armv6_unknown_freebsd] needs-llvm-components: arm
+//@ revisions: armv6_unknown_netbsd_eabihf
+//@ [armv6_unknown_netbsd_eabihf] compile-flags: --target armv6-unknown-netbsd-eabihf
+//@ [armv6_unknown_netbsd_eabihf] needs-llvm-components: arm
+//@ revisions: armv6k_nintendo_3ds
+//@ [armv6k_nintendo_3ds] compile-flags: --target armv6k-nintendo-3ds
+//@ [armv6k_nintendo_3ds] needs-llvm-components: arm
+//@ revisions: armv7_linux_androideabi
+//@ [armv7_linux_androideabi] compile-flags: --target armv7-linux-androideabi
+//@ [armv7_linux_androideabi] needs-llvm-components: arm
+//@ revisions: armv7_rtems_eabihf
+//@ [armv7_rtems_eabihf] compile-flags: --target armv7-rtems-eabihf
+//@ [armv7_rtems_eabihf] needs-llvm-components: arm
+//@ revisions: armv7_sony_vita_newlibeabihf
+//@ [armv7_sony_vita_newlibeabihf] compile-flags: --target armv7-sony-vita-newlibeabihf
+//@ [armv7_sony_vita_newlibeabihf] needs-llvm-components: arm
+//@ revisions: armv7_unknown_freebsd
+//@ [armv7_unknown_freebsd] compile-flags: --target armv7-unknown-freebsd
+//@ [armv7_unknown_freebsd] needs-llvm-components: arm
+//@ revisions: armv7_unknown_linux_gnueabi
+//@ [armv7_unknown_linux_gnueabi] compile-flags: --target armv7-unknown-linux-gnueabi
+//@ [armv7_unknown_linux_gnueabi] needs-llvm-components: arm
+//@ revisions: armv7_unknown_linux_gnueabihf
+//@ [armv7_unknown_linux_gnueabihf] compile-flags: --target armv7-unknown-linux-gnueabihf
+//@ [armv7_unknown_linux_gnueabihf] needs-llvm-components: arm
+//@ revisions: armv7_unknown_linux_musleabi
+//@ [armv7_unknown_linux_musleabi] compile-flags: --target armv7-unknown-linux-musleabi
+//@ [armv7_unknown_linux_musleabi] needs-llvm-components: arm
+//@ revisions: armv7_unknown_linux_musleabihf
+//@ [armv7_unknown_linux_musleabihf] compile-flags: --target armv7-unknown-linux-musleabihf
+//@ [armv7_unknown_linux_musleabihf] needs-llvm-components: arm
+//@ revisions: armv7_unknown_linux_ohos
+//@ [armv7_unknown_linux_ohos] compile-flags: --target armv7-unknown-linux-ohos
+//@ [armv7_unknown_linux_ohos] needs-llvm-components: arm
+//@ revisions: armv7_unknown_linux_uclibceabi
+//@ [armv7_unknown_linux_uclibceabi] compile-flags: --target armv7-unknown-linux-uclibceabi
+//@ [armv7_unknown_linux_uclibceabi] needs-llvm-components: arm
+//@ revisions: armv7_unknown_linux_uclibceabihf
+//@ [armv7_unknown_linux_uclibceabihf] compile-flags: --target armv7-unknown-linux-uclibceabihf
+//@ [armv7_unknown_linux_uclibceabihf] needs-llvm-components: arm
+//@ revisions: armv7_unknown_netbsd_eabihf
+//@ [armv7_unknown_netbsd_eabihf] compile-flags: --target armv7-unknown-netbsd-eabihf
+//@ [armv7_unknown_netbsd_eabihf] needs-llvm-components: arm
+//@ revisions: armv7_unknown_trusty
+//@ [armv7_unknown_trusty] compile-flags: --target armv7-unknown-trusty
+//@ [armv7_unknown_trusty] needs-llvm-components: arm
+//@ revisions: armv7_wrs_vxworks_eabihf
+//@ [armv7_wrs_vxworks_eabihf] compile-flags: --target armv7-wrs-vxworks-eabihf
+//@ [armv7_wrs_vxworks_eabihf] needs-llvm-components: arm
+//@ revisions: armv7a_kmc_solid_asp3_eabi
+//@ [armv7a_kmc_solid_asp3_eabi] compile-flags: --target armv7a-kmc-solid_asp3-eabi
+//@ [armv7a_kmc_solid_asp3_eabi] needs-llvm-components: arm
+//@ revisions: armv7a_kmc_solid_asp3_eabihf
+//@ [armv7a_kmc_solid_asp3_eabihf] compile-flags: --target armv7a-kmc-solid_asp3-eabihf
+//@ [armv7a_kmc_solid_asp3_eabihf] needs-llvm-components: arm
+//@ revisions: armv7a_none_eabi
+//@ [armv7a_none_eabi] compile-flags: --target armv7a-none-eabi
+//@ [armv7a_none_eabi] needs-llvm-components: arm
+//@ revisions: armv7a_none_eabihf
+//@ [armv7a_none_eabihf] compile-flags: --target armv7a-none-eabihf
+//@ [armv7a_none_eabihf] needs-llvm-components: arm
+//@ revisions: armv7a_nuttx_eabi
+//@ [armv7a_nuttx_eabi] compile-flags: --target armv7a-nuttx-eabi
+//@ [armv7a_nuttx_eabi] needs-llvm-components: arm
+//@ revisions: armv7a_nuttx_eabihf
+//@ [armv7a_nuttx_eabihf] compile-flags: --target armv7a-nuttx-eabihf
+//@ [armv7a_nuttx_eabihf] needs-llvm-components: arm
+//@ revisions: armv7r_none_eabi
+//@ [armv7r_none_eabi] compile-flags: --target armv7r-none-eabi
+//@ [armv7r_none_eabi] needs-llvm-components: arm
+//@ revisions: armv7r_none_eabihf
+//@ [armv7r_none_eabihf] compile-flags: --target armv7r-none-eabihf
+//@ [armv7r_none_eabihf] needs-llvm-components: arm
+//@ revisions: armv8r_none_eabihf
+//@ [armv8r_none_eabihf] compile-flags: --target armv8r-none-eabihf
+//@ [armv8r_none_eabihf] needs-llvm-components: arm
+// FIXME: disabled since it fails on CI saying the csky component is missing
+/*
+    revisions: csky_unknown_linux_gnuabiv2
+    [csky_unknown_linux_gnuabiv2] compile-flags: --target csky-unknown-linux-gnuabiv2
+    [csky_unknown_linux_gnuabiv2] needs-llvm-components: csky
+    revisions: csky_unknown_linux_gnuabiv2hf
+    [csky_unknown_linux_gnuabiv2hf] compile-flags: --target csky-unknown-linux-gnuabiv2hf
+    [csky_unknown_linux_gnuabiv2hf] needs-llvm-components: csky
+*/
+//@ revisions: hexagon_unknown_linux_musl
+//@ [hexagon_unknown_linux_musl] compile-flags: --target hexagon-unknown-linux-musl
+//@ [hexagon_unknown_linux_musl] needs-llvm-components: hexagon
+//@ revisions: hexagon_unknown_none_elf
+//@ [hexagon_unknown_none_elf] compile-flags: --target hexagon-unknown-none-elf
+//@ [hexagon_unknown_none_elf] needs-llvm-components: hexagon
+//@ revisions: i686_pc_nto_qnx700
+//@ [i686_pc_nto_qnx700] compile-flags: --target i686-pc-nto-qnx700
+//@ [i686_pc_nto_qnx700] needs-llvm-components: x86
+//@ revisions: i586_unknown_linux_gnu
+//@ [i586_unknown_linux_gnu] compile-flags: --target i586-unknown-linux-gnu
+//@ [i586_unknown_linux_gnu] needs-llvm-components: x86
+//@ revisions: i586_unknown_linux_musl
+//@ [i586_unknown_linux_musl] compile-flags: --target i586-unknown-linux-musl
+//@ [i586_unknown_linux_musl] needs-llvm-components: x86
+//@ revisions: i586_unknown_netbsd
+//@ [i586_unknown_netbsd] compile-flags: --target i586-unknown-netbsd
+//@ [i586_unknown_netbsd] needs-llvm-components: x86
+//@ revisions: i586_unknown_redox
+//@ [i586_unknown_redox] compile-flags: --target i586-unknown-redox
+//@ [i586_unknown_redox] needs-llvm-components: x86
+//@ revisions: i686_linux_android
+//@ [i686_linux_android] compile-flags: --target i686-linux-android
+//@ [i686_linux_android] needs-llvm-components: x86
+//@ revisions: i686_unknown_freebsd
+//@ [i686_unknown_freebsd] compile-flags: --target i686-unknown-freebsd
+//@ [i686_unknown_freebsd] needs-llvm-components: x86
+//@ revisions: i686_unknown_haiku
+//@ [i686_unknown_haiku] compile-flags: --target i686-unknown-haiku
+//@ [i686_unknown_haiku] needs-llvm-components: x86
+//@ revisions: i686_unknown_hurd_gnu
+//@ [i686_unknown_hurd_gnu] compile-flags: --target i686-unknown-hurd-gnu
+//@ [i686_unknown_hurd_gnu] needs-llvm-components: x86
+//@ revisions: i686_unknown_linux_gnu
+//@ [i686_unknown_linux_gnu] compile-flags: --target i686-unknown-linux-gnu
+//@ [i686_unknown_linux_gnu] needs-llvm-components: x86
+//@ revisions: i686_unknown_linux_musl
+//@ [i686_unknown_linux_musl] compile-flags: --target i686-unknown-linux-musl
+//@ [i686_unknown_linux_musl] needs-llvm-components: x86
+//@ revisions: i686_unknown_netbsd
+//@ [i686_unknown_netbsd] compile-flags: --target i686-unknown-netbsd
+//@ [i686_unknown_netbsd] needs-llvm-components: x86
+//@ revisions: i686_unknown_openbsd
+//@ [i686_unknown_openbsd] compile-flags: --target i686-unknown-openbsd
+//@ [i686_unknown_openbsd] needs-llvm-components: x86
+//@ revisions: i686_wrs_vxworks
+//@ [i686_wrs_vxworks] compile-flags: --target i686-wrs-vxworks
+//@ [i686_wrs_vxworks] needs-llvm-components: x86
+//@ revisions: loongarch32_unknown_none
+//@ [loongarch32_unknown_none] compile-flags: --target loongarch32-unknown-none
+//@ [loongarch32_unknown_none] needs-llvm-components: loongarch
+//@ revisions: loongarch32_unknown_none_softfloat
+//@ [loongarch32_unknown_none_softfloat] compile-flags: --target loongarch32-unknown-none-softfloat
+//@ [loongarch32_unknown_none_softfloat] needs-llvm-components: loongarch
+//@ revisions: loongarch64_unknown_linux_gnu
+//@ [loongarch64_unknown_linux_gnu] compile-flags: --target loongarch64-unknown-linux-gnu
+//@ [loongarch64_unknown_linux_gnu] needs-llvm-components: loongarch
+//@ revisions: loongarch64_unknown_linux_musl
+//@ [loongarch64_unknown_linux_musl] compile-flags: --target loongarch64-unknown-linux-musl
+//@ [loongarch64_unknown_linux_musl] needs-llvm-components: loongarch
+//@ revisions: loongarch64_unknown_linux_ohos
+//@ [loongarch64_unknown_linux_ohos] compile-flags: --target loongarch64-unknown-linux-ohos
+//@ [loongarch64_unknown_linux_ohos] needs-llvm-components: loongarch
+//@ revisions: loongarch64_unknown_none
+//@ [loongarch64_unknown_none] compile-flags: --target loongarch64-unknown-none
+//@ [loongarch64_unknown_none] needs-llvm-components: loongarch
+//@ revisions: loongarch64_unknown_none_softfloat
+//@ [loongarch64_unknown_none_softfloat] compile-flags: --target loongarch64-unknown-none-softfloat
+//@ [loongarch64_unknown_none_softfloat] needs-llvm-components: loongarch
+//@ revisions: m68k_unknown_linux_gnu
+//@ [m68k_unknown_linux_gnu] compile-flags: --target m68k-unknown-linux-gnu
+//@ [m68k_unknown_linux_gnu] needs-llvm-components: m68k
+//@ revisions: m68k_unknown_none_elf
+//@ [m68k_unknown_none_elf] compile-flags: --target m68k-unknown-none-elf
+//@ [m68k_unknown_none_elf] needs-llvm-components: m68k
+//@ revisions: mips64_openwrt_linux_musl
+//@ [mips64_openwrt_linux_musl] compile-flags: --target mips64-openwrt-linux-musl
+//@ [mips64_openwrt_linux_musl] needs-llvm-components: mips
+//@ revisions: mips64_unknown_linux_gnuabi64
+//@ [mips64_unknown_linux_gnuabi64] compile-flags: --target mips64-unknown-linux-gnuabi64
+//@ [mips64_unknown_linux_gnuabi64] needs-llvm-components: mips
+//@ revisions: mips64_unknown_linux_muslabi64
+//@ [mips64_unknown_linux_muslabi64] compile-flags: --target mips64-unknown-linux-muslabi64
+//@ [mips64_unknown_linux_muslabi64] needs-llvm-components: mips
+//@ revisions: mips64el_unknown_linux_gnuabi64
+//@ [mips64el_unknown_linux_gnuabi64] compile-flags: --target mips64el-unknown-linux-gnuabi64
+//@ [mips64el_unknown_linux_gnuabi64] needs-llvm-components: mips
+//@ revisions: mips64el_unknown_linux_muslabi64
+//@ [mips64el_unknown_linux_muslabi64] compile-flags: --target mips64el-unknown-linux-muslabi64
+//@ [mips64el_unknown_linux_muslabi64] needs-llvm-components: mips
+//@ revisions: mips_unknown_linux_gnu
+//@ [mips_unknown_linux_gnu] compile-flags: --target mips-unknown-linux-gnu
+//@ [mips_unknown_linux_gnu] needs-llvm-components: mips
+//@ revisions: mips_unknown_linux_musl
+//@ [mips_unknown_linux_musl] compile-flags: --target mips-unknown-linux-musl
+//@ [mips_unknown_linux_musl] needs-llvm-components: mips
+//@ revisions: mips_unknown_linux_uclibc
+//@ [mips_unknown_linux_uclibc] compile-flags: --target mips-unknown-linux-uclibc
+//@ [mips_unknown_linux_uclibc] needs-llvm-components: mips
+//@ revisions: mips_mti_none_elf
+//@ [mips_mti_none_elf] compile-flags: --target mips-mti-none-elf
+//@ [mips_mti_none_elf] needs-llvm-components: mips
+//@ revisions: mipsel_mti_none_elf
+//@ [mipsel_mti_none_elf] compile-flags: --target mipsel-mti-none-elf
+//@ [mipsel_mti_none_elf] needs-llvm-components: mips
+//@ revisions: mipsel_sony_psp
+//@ [mipsel_sony_psp] compile-flags: --target mipsel-sony-psp
+//@ [mipsel_sony_psp] needs-llvm-components: mips
+//@ revisions: mipsel_sony_psx
+//@ [mipsel_sony_psx] compile-flags: --target mipsel-sony-psx
+//@ [mipsel_sony_psx] needs-llvm-components: mips
+//@ revisions: mipsel_unknown_linux_gnu
+//@ [mipsel_unknown_linux_gnu] compile-flags: --target mipsel-unknown-linux-gnu
+//@ [mipsel_unknown_linux_gnu] needs-llvm-components: mips
+//@ revisions: mipsel_unknown_linux_musl
+//@ [mipsel_unknown_linux_musl] compile-flags: --target mipsel-unknown-linux-musl
+//@ [mipsel_unknown_linux_musl] needs-llvm-components: mips
+//@ revisions: mipsel_unknown_linux_uclibc
+//@ [mipsel_unknown_linux_uclibc] compile-flags: --target mipsel-unknown-linux-uclibc
+//@ [mipsel_unknown_linux_uclibc] needs-llvm-components: mips
+//@ revisions: mipsel_unknown_netbsd
+//@ [mipsel_unknown_netbsd] compile-flags: --target mipsel-unknown-netbsd
+//@ [mipsel_unknown_netbsd] needs-llvm-components: mips
+//@ revisions: mipsel_unknown_none
+//@ [mipsel_unknown_none] compile-flags: --target mipsel-unknown-none
+//@ [mipsel_unknown_none] needs-llvm-components: mips
+//@ revisions: mipsisa32r6_unknown_linux_gnu
+//@ [mipsisa32r6_unknown_linux_gnu] compile-flags: --target mipsisa32r6-unknown-linux-gnu
+//@ [mipsisa32r6_unknown_linux_gnu] needs-llvm-components: mips
+//@ revisions: mipsisa32r6el_unknown_linux_gnu
+//@ [mipsisa32r6el_unknown_linux_gnu] compile-flags: --target mipsisa32r6el-unknown-linux-gnu
+//@ [mipsisa32r6el_unknown_linux_gnu] needs-llvm-components: mips
+//@ revisions: mipsisa64r6_unknown_linux_gnuabi64
+//@ [mipsisa64r6_unknown_linux_gnuabi64] compile-flags: --target mipsisa64r6-unknown-linux-gnuabi64
+//@ [mipsisa64r6_unknown_linux_gnuabi64] needs-llvm-components: mips
+//@ revisions: mipsisa64r6el_unknown_linux_gnuabi64
+//@ [mipsisa64r6el_unknown_linux_gnuabi64] compile-flags: --target mipsisa64r6el-unknown-linux-gnuabi64
+//@ [mipsisa64r6el_unknown_linux_gnuabi64] needs-llvm-components: mips
+//@ revisions: msp430_none_elf
+//@ [msp430_none_elf] compile-flags: --target msp430-none-elf
+//@ [msp430_none_elf] needs-llvm-components: msp430
+//@ revisions: powerpc64_unknown_freebsd
+//@ [powerpc64_unknown_freebsd] compile-flags: --target powerpc64-unknown-freebsd
+//@ [powerpc64_unknown_freebsd] needs-llvm-components: powerpc
+//@ revisions: powerpc64_unknown_linux_gnu
+//@ [powerpc64_unknown_linux_gnu] compile-flags: --target powerpc64-unknown-linux-gnu
+//@ [powerpc64_unknown_linux_gnu] needs-llvm-components: powerpc
+//@ revisions: powerpc64_unknown_linux_musl
+//@ [powerpc64_unknown_linux_musl] compile-flags: --target powerpc64-unknown-linux-musl
+//@ [powerpc64_unknown_linux_musl] needs-llvm-components: powerpc
+//@ revisions: powerpc64_unknown_openbsd
+//@ [powerpc64_unknown_openbsd] compile-flags: --target powerpc64-unknown-openbsd
+//@ [powerpc64_unknown_openbsd] needs-llvm-components: powerpc
+//@ revisions: powerpc64_wrs_vxworks
+//@ [powerpc64_wrs_vxworks] compile-flags: --target powerpc64-wrs-vxworks
+//@ [powerpc64_wrs_vxworks] needs-llvm-components: powerpc
+//@ revisions: powerpc64le_unknown_freebsd
+//@ [powerpc64le_unknown_freebsd] compile-flags: --target powerpc64le-unknown-freebsd
+//@ [powerpc64le_unknown_freebsd] needs-llvm-components: powerpc
+//@ revisions: powerpc64le_unknown_linux_gnu
+//@ [powerpc64le_unknown_linux_gnu] compile-flags: --target powerpc64le-unknown-linux-gnu
+//@ [powerpc64le_unknown_linux_gnu] needs-llvm-components: powerpc
+//@ revisions: powerpc64le_unknown_linux_musl
+//@ [powerpc64le_unknown_linux_musl] compile-flags: --target powerpc64le-unknown-linux-musl
+//@ [powerpc64le_unknown_linux_musl] needs-llvm-components: powerpc
+//@ revisions: powerpc_unknown_freebsd
+//@ [powerpc_unknown_freebsd] compile-flags: --target powerpc-unknown-freebsd
+//@ [powerpc_unknown_freebsd] needs-llvm-components: powerpc
+//@ revisions: powerpc_unknown_linux_gnu
+//@ [powerpc_unknown_linux_gnu] compile-flags: --target powerpc-unknown-linux-gnu
+//@ [powerpc_unknown_linux_gnu] needs-llvm-components: powerpc
+//@ revisions: powerpc_unknown_linux_gnuspe
+//@ [powerpc_unknown_linux_gnuspe] compile-flags: --target powerpc-unknown-linux-gnuspe
+//@ [powerpc_unknown_linux_gnuspe] needs-llvm-components: powerpc
+//@ revisions: powerpc_unknown_linux_musl
+//@ [powerpc_unknown_linux_musl] compile-flags: --target powerpc-unknown-linux-musl
+//@ [powerpc_unknown_linux_musl] needs-llvm-components: powerpc
+//@ revisions: powerpc_unknown_linux_muslspe
+//@ [powerpc_unknown_linux_muslspe] compile-flags: --target powerpc-unknown-linux-muslspe
+//@ [powerpc_unknown_linux_muslspe] needs-llvm-components: powerpc
+//@ revisions: powerpc_unknown_netbsd
+//@ [powerpc_unknown_netbsd] compile-flags: --target powerpc-unknown-netbsd
+//@ [powerpc_unknown_netbsd] needs-llvm-components: powerpc
+//@ revisions: powerpc_unknown_openbsd
+//@ [powerpc_unknown_openbsd] compile-flags: --target powerpc-unknown-openbsd
+//@ [powerpc_unknown_openbsd] needs-llvm-components: powerpc
+//@ revisions: powerpc_wrs_vxworks
+//@ [powerpc_wrs_vxworks] compile-flags: --target powerpc-wrs-vxworks
+//@ [powerpc_wrs_vxworks] needs-llvm-components: powerpc
+//@ revisions: powerpc_wrs_vxworks_spe
+//@ [powerpc_wrs_vxworks_spe] compile-flags: --target powerpc-wrs-vxworks-spe
+//@ [powerpc_wrs_vxworks_spe] needs-llvm-components: powerpc
+//@ revisions: riscv32_wrs_vxworks
+//@ [riscv32_wrs_vxworks] compile-flags: --target riscv32-wrs-vxworks
+//@ [riscv32_wrs_vxworks] needs-llvm-components: riscv
+//@ revisions: riscv32e_unknown_none_elf
+//@ [riscv32e_unknown_none_elf] compile-flags: --target riscv32e-unknown-none-elf
+//@ [riscv32e_unknown_none_elf] needs-llvm-components: riscv
+//@ revisions: riscv32em_unknown_none_elf
+//@ [riscv32em_unknown_none_elf] compile-flags: --target riscv32em-unknown-none-elf
+//@ [riscv32em_unknown_none_elf] needs-llvm-components: riscv
+//@ revisions: riscv32emc_unknown_none_elf
+//@ [riscv32emc_unknown_none_elf] compile-flags: --target riscv32emc-unknown-none-elf
+//@ [riscv32emc_unknown_none_elf] needs-llvm-components: riscv
+//@ revisions: riscv32gc_unknown_linux_gnu
+//@ [riscv32gc_unknown_linux_gnu] compile-flags: --target riscv32gc-unknown-linux-gnu
+//@ [riscv32gc_unknown_linux_gnu] needs-llvm-components: riscv
+//@ revisions: riscv32gc_unknown_linux_musl
+//@ [riscv32gc_unknown_linux_musl] compile-flags: --target riscv32gc-unknown-linux-musl
+//@ [riscv32gc_unknown_linux_musl] needs-llvm-components: riscv
+//@ revisions: riscv32i_unknown_none_elf
+//@ [riscv32i_unknown_none_elf] compile-flags: --target riscv32i-unknown-none-elf
+//@ [riscv32i_unknown_none_elf] needs-llvm-components: riscv
+//@ revisions: riscv32im_risc0_zkvm_elf
+//@ [riscv32im_risc0_zkvm_elf] compile-flags: --target riscv32im-risc0-zkvm-elf
+//@ [riscv32im_risc0_zkvm_elf] needs-llvm-components: riscv
+//@ revisions: riscv32im_unknown_none_elf
+//@ [riscv32im_unknown_none_elf] compile-flags: --target riscv32im-unknown-none-elf
+//@ [riscv32im_unknown_none_elf] needs-llvm-components: riscv
+//@ revisions: riscv32ima_unknown_none_elf
+//@ [riscv32ima_unknown_none_elf] compile-flags: --target riscv32ima-unknown-none-elf
+//@ [riscv32ima_unknown_none_elf] needs-llvm-components: riscv
+//@ revisions: riscv32imac_esp_espidf
+//@ [riscv32imac_esp_espidf] compile-flags: --target riscv32imac-esp-espidf
+//@ [riscv32imac_esp_espidf] needs-llvm-components: riscv
+//@ revisions: riscv32imac_unknown_none_elf
+//@ [riscv32imac_unknown_none_elf] compile-flags: --target riscv32imac-unknown-none-elf
+//@ [riscv32imac_unknown_none_elf] needs-llvm-components: riscv
+//@ revisions: riscv32imac_unknown_xous_elf
+//@ [riscv32imac_unknown_xous_elf] compile-flags: --target riscv32imac-unknown-xous-elf
+//@ [riscv32imac_unknown_xous_elf] needs-llvm-components: riscv
+//@ revisions: riscv32imafc_unknown_none_elf
+//@ [riscv32imafc_unknown_none_elf] compile-flags: --target riscv32imafc-unknown-none-elf
+//@ [riscv32imafc_unknown_none_elf] needs-llvm-components: riscv
+//@ revisions: riscv32imafc_esp_espidf
+//@ [riscv32imafc_esp_espidf] compile-flags: --target riscv32imafc-esp-espidf
+//@ [riscv32imafc_esp_espidf] needs-llvm-components: riscv
+//@ revisions: riscv32imc_esp_espidf
+//@ [riscv32imc_esp_espidf] compile-flags: --target riscv32imc-esp-espidf
+//@ [riscv32imc_esp_espidf] needs-llvm-components: riscv
+//@ revisions: riscv32imc_unknown_none_elf
+//@ [riscv32imc_unknown_none_elf] compile-flags: --target riscv32imc-unknown-none-elf
+//@ [riscv32imc_unknown_none_elf] needs-llvm-components: riscv
+//@ revisions: riscv64_linux_android
+//@ [riscv64_linux_android] compile-flags: --target riscv64-linux-android
+//@ [riscv64_linux_android] needs-llvm-components: riscv
+//@ revisions: riscv64_wrs_vxworks
+//@ [riscv64_wrs_vxworks] compile-flags: --target riscv64-wrs-vxworks
+//@ [riscv64_wrs_vxworks] needs-llvm-components: riscv
+//@ revisions: riscv64gc_unknown_freebsd
+//@ [riscv64gc_unknown_freebsd] compile-flags: --target riscv64gc-unknown-freebsd
+//@ [riscv64gc_unknown_freebsd] needs-llvm-components: riscv
+//@ revisions: riscv64gc_unknown_fuchsia
+//@ [riscv64gc_unknown_fuchsia] compile-flags: --target riscv64gc-unknown-fuchsia
+//@ [riscv64gc_unknown_fuchsia] needs-llvm-components: riscv
+//@ revisions: riscv64gc_unknown_hermit
+//@ [riscv64gc_unknown_hermit] compile-flags: --target riscv64gc-unknown-hermit
+//@ [riscv64gc_unknown_hermit] needs-llvm-components: riscv
+//@ revisions: riscv64gc_unknown_linux_gnu
+//@ [riscv64gc_unknown_linux_gnu] compile-flags: --target riscv64gc-unknown-linux-gnu
+//@ [riscv64gc_unknown_linux_gnu] needs-llvm-components: riscv
+//@ revisions: riscv64gc_unknown_linux_musl
+//@ [riscv64gc_unknown_linux_musl] compile-flags: --target riscv64gc-unknown-linux-musl
+//@ [riscv64gc_unknown_linux_musl] needs-llvm-components: riscv
+//@ revisions: riscv64gc_unknown_netbsd
+//@ [riscv64gc_unknown_netbsd] compile-flags: --target riscv64gc-unknown-netbsd
+//@ [riscv64gc_unknown_netbsd] needs-llvm-components: riscv
+//@ revisions: riscv64gc_unknown_none_elf
+//@ [riscv64gc_unknown_none_elf] compile-flags: --target riscv64gc-unknown-none-elf
+//@ [riscv64gc_unknown_none_elf] needs-llvm-components: riscv
+//@ revisions: riscv64gc_unknown_openbsd
+//@ [riscv64gc_unknown_openbsd] compile-flags: --target riscv64gc-unknown-openbsd
+//@ [riscv64gc_unknown_openbsd] needs-llvm-components: riscv
+//@ revisions: riscv64imac_unknown_none_elf
+//@ [riscv64imac_unknown_none_elf] compile-flags: --target riscv64imac-unknown-none-elf
+//@ [riscv64imac_unknown_none_elf] needs-llvm-components: riscv
+//@ revisions: s390x_unknown_linux_gnu
+//@ [s390x_unknown_linux_gnu] compile-flags: --target s390x-unknown-linux-gnu
+//@ [s390x_unknown_linux_gnu] needs-llvm-components: systemz
+//@ revisions: s390x_unknown_linux_musl
+//@ [s390x_unknown_linux_musl] compile-flags: --target s390x-unknown-linux-musl
+//@ [s390x_unknown_linux_musl] needs-llvm-components: systemz
+//@ revisions: sparc64_unknown_linux_gnu
+//@ [sparc64_unknown_linux_gnu] compile-flags: --target sparc64-unknown-linux-gnu
+//@ [sparc64_unknown_linux_gnu] needs-llvm-components: sparc
+//@ revisions: sparc64_unknown_netbsd
+//@ [sparc64_unknown_netbsd] compile-flags: --target sparc64-unknown-netbsd
+//@ [sparc64_unknown_netbsd] needs-llvm-components: sparc
+//@ revisions: sparc64_unknown_openbsd
+//@ [sparc64_unknown_openbsd] compile-flags: --target sparc64-unknown-openbsd
+//@ [sparc64_unknown_openbsd] needs-llvm-components: sparc
+//@ revisions: sparc_unknown_linux_gnu
+//@ [sparc_unknown_linux_gnu] compile-flags: --target sparc-unknown-linux-gnu
+//@ [sparc_unknown_linux_gnu] needs-llvm-components: sparc
+//@ revisions: sparc_unknown_none_elf
+//@ [sparc_unknown_none_elf] compile-flags: --target sparc-unknown-none-elf
+//@ [sparc_unknown_none_elf] needs-llvm-components: sparc
+//@ revisions: sparcv9_sun_solaris
+//@ [sparcv9_sun_solaris] compile-flags: --target sparcv9-sun-solaris
+//@ [sparcv9_sun_solaris] needs-llvm-components: sparc
+//@ revisions: thumbv4t_none_eabi
+//@ [thumbv4t_none_eabi] compile-flags: --target thumbv4t-none-eabi
+//@ [thumbv4t_none_eabi] needs-llvm-components: arm
+//@ revisions: thumbv5te_none_eabi
+//@ [thumbv5te_none_eabi] compile-flags: --target thumbv5te-none-eabi
+//@ [thumbv5te_none_eabi] needs-llvm-components: arm
+//@ revisions: thumbv6m_none_eabi
+//@ [thumbv6m_none_eabi] compile-flags: --target thumbv6m-none-eabi
+//@ [thumbv6m_none_eabi] needs-llvm-components: arm
+//@ revisions: thumbv7em_none_eabi
+//@ [thumbv7em_none_eabi] compile-flags: --target thumbv7em-none-eabi
+//@ [thumbv7em_none_eabi] needs-llvm-components: arm
+//@ revisions: thumbv7em_none_eabihf
+//@ [thumbv7em_none_eabihf] compile-flags: --target thumbv7em-none-eabihf
+//@ [thumbv7em_none_eabihf] needs-llvm-components: arm
+//@ revisions: thumbv7m_none_eabi
+//@ [thumbv7m_none_eabi] compile-flags: --target thumbv7m-none-eabi
+//@ [thumbv7m_none_eabi] needs-llvm-components: arm
+//@ revisions: thumbv7neon_linux_androideabi
+//@ [thumbv7neon_linux_androideabi] compile-flags: --target thumbv7neon-linux-androideabi
+//@ [thumbv7neon_linux_androideabi] needs-llvm-components: arm
+//@ revisions: thumbv7neon_unknown_linux_gnueabihf
+//@ [thumbv7neon_unknown_linux_gnueabihf] compile-flags: --target thumbv7neon-unknown-linux-gnueabihf
+//@ [thumbv7neon_unknown_linux_gnueabihf] needs-llvm-components: arm
+//@ revisions: thumbv7neon_unknown_linux_musleabihf
+//@ [thumbv7neon_unknown_linux_musleabihf] compile-flags: --target thumbv7neon-unknown-linux-musleabihf
+//@ [thumbv7neon_unknown_linux_musleabihf] needs-llvm-components: arm
+//@ revisions: thumbv8m_base_none_eabi
+//@ [thumbv8m_base_none_eabi] compile-flags: --target thumbv8m.base-none-eabi
+//@ [thumbv8m_base_none_eabi] needs-llvm-components: arm
+//@ revisions: thumbv8m_main_none_eabi
+//@ [thumbv8m_main_none_eabi] compile-flags: --target thumbv8m.main-none-eabi
+//@ [thumbv8m_main_none_eabi] needs-llvm-components: arm
+//@ revisions: thumbv8m_main_none_eabihf
+//@ [thumbv8m_main_none_eabihf] compile-flags: --target thumbv8m.main-none-eabihf
+//@ [thumbv8m_main_none_eabihf] needs-llvm-components: arm
+//@ revisions: wasm32_unknown_emscripten
+//@ [wasm32_unknown_emscripten] compile-flags: --target wasm32-unknown-emscripten
+//@ [wasm32_unknown_emscripten] needs-llvm-components: webassembly
+//@ revisions: wasm32_unknown_unknown
+//@ [wasm32_unknown_unknown] compile-flags: --target wasm32-unknown-unknown
+//@ [wasm32_unknown_unknown] needs-llvm-components: webassembly
+//@ revisions: wasm32v1_none
+//@ [wasm32v1_none] compile-flags: --target wasm32v1-none
+//@ [wasm32v1_none] needs-llvm-components: webassembly
+//@ revisions: wasm32_wasip1
+//@ [wasm32_wasip1] compile-flags: --target wasm32-wasip1
+//@ [wasm32_wasip1] needs-llvm-components: webassembly
+//@ revisions: wasm32_wasip1_threads
+//@ [wasm32_wasip1_threads] compile-flags: --target wasm32-wasip1-threads
+//@ [wasm32_wasip1_threads] needs-llvm-components: webassembly
+//@ revisions: wasm32_wasip2
+//@ [wasm32_wasip2] compile-flags: --target wasm32-wasip2
+//@ [wasm32_wasip2] needs-llvm-components: webassembly
+//@ revisions: wasm32_wali_linux_musl
+//@ [wasm32_wali_linux_musl] compile-flags: --target wasm32-wali-linux-musl
+//@ [wasm32_wali_linux_musl] needs-llvm-components: webassembly
+//@ revisions: wasm64_unknown_unknown
+//@ [wasm64_unknown_unknown] compile-flags: --target wasm64-unknown-unknown
+//@ [wasm64_unknown_unknown] needs-llvm-components: webassembly
+//@ revisions: x86_64_fortanix_unknown_sgx
+//@ [x86_64_fortanix_unknown_sgx] compile-flags: --target x86_64-fortanix-unknown-sgx
+//@ [x86_64_fortanix_unknown_sgx] needs-llvm-components: x86
+//@ revisions: x86_64_linux_android
+//@ [x86_64_linux_android] compile-flags: --target x86_64-linux-android
+//@ [x86_64_linux_android] needs-llvm-components: x86
+//@ revisions: x86_64_lynx_lynxos178
+//@ [x86_64_lynx_lynxos178] compile-flags: --target x86_64-lynx-lynxos178
+//@ [x86_64_lynx_lynxos178] needs-llvm-components: x86
+//@ revisions: x86_64_pc_nto_qnx710
+//@ [x86_64_pc_nto_qnx710] compile-flags: --target x86_64-pc-nto-qnx710
+//@ [x86_64_pc_nto_qnx710] needs-llvm-components: x86
+//@ revisions: x86_64_pc_nto_qnx710_iosock
+//@ [x86_64_pc_nto_qnx710_iosock] compile-flags: --target x86_64-pc-nto-qnx710_iosock
+//@ [x86_64_pc_nto_qnx710_iosock] needs-llvm-components: x86
+//@ revisions: x86_64_pc_nto_qnx800
+//@ [x86_64_pc_nto_qnx800] compile-flags: --target x86_64-pc-nto-qnx800
+//@ [x86_64_pc_nto_qnx800] needs-llvm-components: x86
+//@ revisions: x86_64_pc_solaris
+//@ [x86_64_pc_solaris] compile-flags: --target x86_64-pc-solaris
+//@ [x86_64_pc_solaris] needs-llvm-components: x86
+//@ revisions: x86_64_unikraft_linux_musl
+//@ [x86_64_unikraft_linux_musl] compile-flags: --target x86_64-unikraft-linux-musl
+//@ [x86_64_unikraft_linux_musl] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_dragonfly
+//@ [x86_64_unknown_dragonfly] compile-flags: --target x86_64-unknown-dragonfly
+//@ [x86_64_unknown_dragonfly] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_freebsd
+//@ [x86_64_unknown_freebsd] compile-flags: --target x86_64-unknown-freebsd
+//@ [x86_64_unknown_freebsd] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_fuchsia
+//@ [x86_64_unknown_fuchsia] compile-flags: --target x86_64-unknown-fuchsia
+//@ [x86_64_unknown_fuchsia] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_haiku
+//@ [x86_64_unknown_haiku] compile-flags: --target x86_64-unknown-haiku
+//@ [x86_64_unknown_haiku] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_hurd_gnu
+//@ [x86_64_unknown_hurd_gnu] compile-flags: --target x86_64-unknown-hurd-gnu
+//@ [x86_64_unknown_hurd_gnu] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_hermit
+//@ [x86_64_unknown_hermit] compile-flags: --target x86_64-unknown-hermit
+//@ [x86_64_unknown_hermit] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_illumos
+//@ [x86_64_unknown_illumos] compile-flags: --target x86_64-unknown-illumos
+//@ [x86_64_unknown_illumos] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_l4re_uclibc
+//@ [x86_64_unknown_l4re_uclibc] compile-flags: --target x86_64-unknown-l4re-uclibc
+//@ [x86_64_unknown_l4re_uclibc] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_linux_gnu
+//@ [x86_64_unknown_linux_gnu] compile-flags: --target x86_64-unknown-linux-gnu
+//@ [x86_64_unknown_linux_gnu] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_linux_gnux32
+//@ [x86_64_unknown_linux_gnux32] compile-flags: --target x86_64-unknown-linux-gnux32
+//@ [x86_64_unknown_linux_gnux32] 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
+//@ revisions: x86_64_unknown_linux_ohos
+//@ [x86_64_unknown_linux_ohos] compile-flags: --target x86_64-unknown-linux-ohos
+//@ [x86_64_unknown_linux_ohos] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_linux_none
+//@ [x86_64_unknown_linux_none] compile-flags: --target x86_64-unknown-linux-none
+//@ [x86_64_unknown_linux_none] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_netbsd
+//@ [x86_64_unknown_netbsd] compile-flags: --target x86_64-unknown-netbsd
+//@ [x86_64_unknown_netbsd] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_none
+//@ [x86_64_unknown_none] compile-flags: --target x86_64-unknown-none
+//@ [x86_64_unknown_none] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_openbsd
+//@ [x86_64_unknown_openbsd] compile-flags: --target x86_64-unknown-openbsd
+//@ [x86_64_unknown_openbsd] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_redox
+//@ [x86_64_unknown_redox] compile-flags: --target x86_64-unknown-redox
+//@ [x86_64_unknown_redox] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_trusty
+//@ [x86_64_unknown_trusty] compile-flags: --target x86_64-unknown-trusty
+//@ [x86_64_unknown_trusty] needs-llvm-components: x86
+//@ revisions: x86_64_wrs_vxworks
+//@ [x86_64_wrs_vxworks] compile-flags: --target x86_64-wrs-vxworks
+//@ [x86_64_wrs_vxworks] needs-llvm-components: x86
+//@ revisions: thumbv6m_nuttx_eabi
+//@ [thumbv6m_nuttx_eabi] compile-flags: --target thumbv6m-nuttx-eabi
+//@ [thumbv6m_nuttx_eabi] needs-llvm-components: arm
+//@ revisions: thumbv7a_nuttx_eabi
+//@ [thumbv7a_nuttx_eabi] compile-flags: --target thumbv7a-nuttx-eabi
+//@ [thumbv7a_nuttx_eabi] needs-llvm-components: arm
+//@ revisions: thumbv7a_nuttx_eabihf
+//@ [thumbv7a_nuttx_eabihf] compile-flags: --target thumbv7a-nuttx-eabihf
+//@ [thumbv7a_nuttx_eabihf] needs-llvm-components: arm
+//@ revisions: thumbv7m_nuttx_eabi
+//@ [thumbv7m_nuttx_eabi] compile-flags: --target thumbv7m-nuttx-eabi
+//@ [thumbv7m_nuttx_eabi] needs-llvm-components: arm
+//@ revisions: thumbv7em_nuttx_eabi
+//@ [thumbv7em_nuttx_eabi] compile-flags: --target thumbv7em-nuttx-eabi
+//@ [thumbv7em_nuttx_eabi] needs-llvm-components: arm
+//@ revisions: thumbv7em_nuttx_eabihf
+//@ [thumbv7em_nuttx_eabihf] compile-flags: --target thumbv7em-nuttx-eabihf
+//@ [thumbv7em_nuttx_eabihf] needs-llvm-components: arm
+//@ revisions: thumbv8m_base_nuttx_eabi
+//@ [thumbv8m_base_nuttx_eabi] compile-flags: --target thumbv8m.base-nuttx-eabi
+//@ [thumbv8m_base_nuttx_eabi] needs-llvm-components: arm
+//@ revisions: thumbv8m_main_nuttx_eabi
+//@ [thumbv8m_main_nuttx_eabi] compile-flags: --target thumbv8m.main-nuttx-eabi
+//@ [thumbv8m_main_nuttx_eabi] needs-llvm-components: arm
+//@ revisions: thumbv8m_main_nuttx_eabihf
+//@ [thumbv8m_main_nuttx_eabihf] compile-flags: --target thumbv8m.main-nuttx-eabihf
+//@ [thumbv8m_main_nuttx_eabihf] needs-llvm-components: arm
+//@ revisions: riscv32imc_unknown_nuttx_elf
+//@ [riscv32imc_unknown_nuttx_elf] compile-flags: --target riscv32imc-unknown-nuttx-elf
+//@ [riscv32imc_unknown_nuttx_elf] needs-llvm-components: riscv
+//@ revisions: riscv32imac_unknown_nuttx_elf
+//@ [riscv32imac_unknown_nuttx_elf] compile-flags: --target riscv32imac-unknown-nuttx-elf
+//@ [riscv32imac_unknown_nuttx_elf] needs-llvm-components: riscv
+//@ revisions: riscv32imafc_unknown_nuttx_elf
+//@ [riscv32imafc_unknown_nuttx_elf] compile-flags: --target riscv32imafc-unknown-nuttx-elf
+//@ [riscv32imafc_unknown_nuttx_elf] needs-llvm-components: riscv
+//@ revisions: riscv64imac_unknown_nuttx_elf
+//@ [riscv64imac_unknown_nuttx_elf] compile-flags: --target riscv64imac-unknown-nuttx-elf
+//@ [riscv64imac_unknown_nuttx_elf] needs-llvm-components: riscv
+//@ revisions: riscv64gc_unknown_nuttx_elf
+//@ [riscv64gc_unknown_nuttx_elf] compile-flags: --target riscv64gc-unknown-nuttx-elf
+//@ [riscv64gc_unknown_nuttx_elf] needs-llvm-components: riscv
+// FIXME: disabled since it requires a custom LLVM until the upstream LLVM adds support for the target (https://github.com/espressif/llvm-project/issues/4)
+/*
+    revisions: xtensa_esp32_none_elf
+    [xtensa_esp32_none_elf] compile-flags: --target xtensa-esp32-none-elf
+    [xtensa_esp32_none_elf] needs-llvm-components: xtensa
+    revisions: xtensa_esp32_espidf
+    [xtensa_esp32_espidf] compile-flags: --target xtensa-esp32s2-espidf
+    [xtensa_esp32_espidf] needs-llvm-components: xtensa
+    revisions: xtensa_esp32s2_none_elf
+    [xtensa_esp32s2_none_elf] compile-flags: --target xtensa-esp32s2-none-elf
+    [xtensa_esp32s2_none_elf] needs-llvm-components: xtensa
+    revisions: xtensa_esp32s2_espidf
+    [xtensa_esp32s2_espidf] compile-flags: --target xtensa-esp32s2-espidf
+    [xtensa_esp32s2_espidf] needs-llvm-components: xtensa
+    revisions: xtensa_esp32s3_none_elf
+    [xtensa_esp32s3_none_elf] compile-flags: --target xtensa-esp32s3-none-elf
+    [xtensa_esp32s3_none_elf] needs-llvm-components: xtensa
+    revisions: xtensa_esp32s3_espidf
+    [xtensa_esp32s3_espidf] compile-flags: --target xtensa-esp32s3-espidf
+    [xtensa_esp32s3_espidf] needs-llvm-components: xtensa
+*/
+// Sanity-check that each target can produce assembly code.
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+// Force linkage to ensure code is actually generated
+#[no_mangle]
+pub fn test() -> u8 {
+    42
+}
+
+// CHECK: .text
diff --git a/tests/assembly-llvm/targets/targets-macho.rs b/tests/assembly-llvm/targets/targets-macho.rs
new file mode 100644
index 00000000000..92bde1c6971
--- /dev/null
+++ b/tests/assembly-llvm/targets/targets-macho.rs
@@ -0,0 +1,93 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+// ignore-tidy-linelength
+//@ revisions: aarch64_apple_darwin
+//@ [aarch64_apple_darwin] compile-flags: --target aarch64-apple-darwin
+//@ [aarch64_apple_darwin] needs-llvm-components: aarch64
+//@ revisions: aarch64_apple_ios
+//@ [aarch64_apple_ios] compile-flags: --target aarch64-apple-ios
+//@ [aarch64_apple_ios] needs-llvm-components: aarch64
+//@ revisions: aarch64_apple_ios_macabi
+//@ [aarch64_apple_ios_macabi] compile-flags: --target aarch64-apple-ios-macabi
+//@ [aarch64_apple_ios_macabi] needs-llvm-components: aarch64
+//@ revisions: aarch64_apple_ios_sim
+//@ [aarch64_apple_ios_sim] compile-flags: --target aarch64-apple-ios-sim
+//@ [aarch64_apple_ios_sim] needs-llvm-components: aarch64
+//@ revisions: aarch64_apple_tvos
+//@ [aarch64_apple_tvos] compile-flags: --target aarch64-apple-tvos
+//@ [aarch64_apple_tvos] needs-llvm-components: aarch64
+//@ revisions: aarch64_apple_tvos_sim
+//@ [aarch64_apple_tvos_sim] compile-flags: --target aarch64-apple-tvos-sim
+//@ [aarch64_apple_tvos_sim] needs-llvm-components: aarch64
+//@ revisions: arm64e_apple_tvos
+//@ [arm64e_apple_tvos] compile-flags: --target arm64e-apple-tvos
+//@ [arm64e_apple_tvos] needs-llvm-components: aarch64
+//@ revisions: aarch64_apple_watchos
+//@ [aarch64_apple_watchos] compile-flags: --target aarch64-apple-watchos
+//@ [aarch64_apple_watchos] needs-llvm-components: aarch64
+//@ revisions: aarch64_apple_watchos_sim
+//@ [aarch64_apple_watchos_sim] compile-flags: --target aarch64-apple-watchos-sim
+//@ [aarch64_apple_watchos_sim] needs-llvm-components: aarch64
+//@ revisions: arm64_32_apple_watchos
+//@ [arm64_32_apple_watchos] compile-flags: --target arm64_32-apple-watchos
+//@ [arm64_32_apple_watchos] needs-llvm-components: aarch64
+//@ revisions: aarch64_apple_visionos
+//@ [aarch64_apple_visionos] compile-flags: --target aarch64-apple-visionos
+//@ [aarch64_apple_visionos] needs-llvm-components: aarch64
+//@ revisions: aarch64_apple_visionos_sim
+//@ [aarch64_apple_visionos_sim] compile-flags: --target aarch64-apple-visionos-sim
+//@ [aarch64_apple_visionos_sim] needs-llvm-components: aarch64
+//@ revisions: arm64e_apple_darwin
+//@ [arm64e_apple_darwin] compile-flags: --target arm64e-apple-darwin
+//@ [arm64e_apple_darwin] needs-llvm-components: aarch64
+//@ revisions: arm64e_apple_ios
+//@ [arm64e_apple_ios] compile-flags: --target arm64e-apple-ios
+//@ [arm64e_apple_ios] needs-llvm-components: aarch64
+//@ revisions: armv7k_apple_watchos
+//@ [armv7k_apple_watchos] compile-flags: --target armv7k-apple-watchos
+//@ [armv7k_apple_watchos] needs-llvm-components: arm
+//@ revisions: armv7s_apple_ios
+//@ [armv7s_apple_ios] compile-flags: --target armv7s-apple-ios
+//@ [armv7s_apple_ios] needs-llvm-components: arm
+//@ revisions: i386_apple_ios
+//@ [i386_apple_ios] compile-flags: --target i386-apple-ios
+//@ [i386_apple_ios] needs-llvm-components: x86
+//@ revisions: i686_apple_darwin
+//@ [i686_apple_darwin] compile-flags: --target i686-apple-darwin
+//@ [i686_apple_darwin] needs-llvm-components: x86
+//@ revisions: x86_64_apple_darwin
+//@ [x86_64_apple_darwin] compile-flags: --target x86_64-apple-darwin
+//@ [x86_64_apple_darwin] needs-llvm-components: x86
+//@ revisions: x86_64_apple_ios
+//@ [x86_64_apple_ios] compile-flags: --target x86_64-apple-ios
+//@ [x86_64_apple_ios] needs-llvm-components: x86
+//@ revisions: x86_64_apple_ios_macabi
+//@ [x86_64_apple_ios_macabi] compile-flags: --target x86_64-apple-ios-macabi
+//@ [x86_64_apple_ios_macabi] needs-llvm-components: x86
+//@ revisions: x86_64_apple_tvos
+//@ [x86_64_apple_tvos] compile-flags: --target x86_64-apple-tvos
+//@ [x86_64_apple_tvos] needs-llvm-components: x86
+//@ revisions: x86_64_apple_watchos_sim
+//@ [x86_64_apple_watchos_sim] compile-flags: --target x86_64-apple-watchos-sim
+//@ [x86_64_apple_watchos_sim] needs-llvm-components: x86
+//@ revisions: x86_64h_apple_darwin
+//@ [x86_64h_apple_darwin] compile-flags: --target x86_64h-apple-darwin
+//@ [x86_64h_apple_darwin] needs-llvm-components: x86
+
+// Sanity-check that each target can produce assembly code.
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+// Force linkage to ensure code is actually generated
+#[no_mangle]
+pub fn test() -> u8 {
+    42
+}
+
+// CHECK: .section __TEXT,__text
diff --git a/tests/assembly-llvm/targets/targets-nvptx.rs b/tests/assembly-llvm/targets/targets-nvptx.rs
new file mode 100644
index 00000000000..49c12aebaaa
--- /dev/null
+++ b/tests/assembly-llvm/targets/targets-nvptx.rs
@@ -0,0 +1,22 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+// ignore-tidy-linelength
+//@ revisions: nvptx64_nvidia_cuda
+//@ [nvptx64_nvidia_cuda] compile-flags: --target nvptx64-nvidia-cuda
+//@ [nvptx64_nvidia_cuda] needs-llvm-components: nvptx
+
+// Sanity-check that each target can produce assembly code.
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn test() -> u8 {
+    42
+}
+
+// CHECK: .version
diff --git a/tests/assembly-llvm/targets/targets-pe.rs b/tests/assembly-llvm/targets/targets-pe.rs
new file mode 100644
index 00000000000..de29b9af502
--- /dev/null
+++ b/tests/assembly-llvm/targets/targets-pe.rs
@@ -0,0 +1,103 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+// ignore-tidy-linelength
+//@ revisions: aarch64_pc_windows_msvc
+//@ [aarch64_pc_windows_msvc] compile-flags: --target aarch64-pc-windows-msvc
+//@ [aarch64_pc_windows_msvc] needs-llvm-components: aarch64
+//@ revisions: aarch64_pc_windows_gnullvm
+//@ [aarch64_pc_windows_gnullvm] compile-flags: --target aarch64-pc-windows-gnullvm
+//@ [aarch64_pc_windows_gnullvm] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_uefi
+//@ [aarch64_unknown_uefi] compile-flags: --target aarch64-unknown-uefi
+//@ [aarch64_unknown_uefi] needs-llvm-components: aarch64
+//@ revisions: aarch64_uwp_windows_msvc
+//@ [aarch64_uwp_windows_msvc] compile-flags: --target aarch64-uwp-windows-msvc
+//@ [aarch64_uwp_windows_msvc] needs-llvm-components: aarch64
+//@ revisions: arm64ec_pc_windows_msvc
+//@ [arm64ec_pc_windows_msvc] compile-flags: --target arm64ec-pc-windows-msvc
+//@ [arm64ec_pc_windows_msvc] needs-llvm-components: aarch64
+//@ revisions: avr_none
+//@ [avr_none] compile-flags: --target avr-none -C target-cpu=atmega328p
+//@ [avr_none] needs-llvm-components: avr
+//@ revisions: bpfeb_unknown_none
+//@ [bpfeb_unknown_none] compile-flags: --target bpfeb-unknown-none
+//@ [bpfeb_unknown_none] needs-llvm-components: bpf
+//@ revisions: bpfel_unknown_none
+//@ [bpfel_unknown_none] compile-flags: --target bpfel-unknown-none
+//@ [bpfel_unknown_none] needs-llvm-components: bpf
+//@ revisions: i686_pc_windows_gnu
+//@ [i686_pc_windows_gnu] compile-flags: --target i686-pc-windows-gnu
+//@ [i686_pc_windows_gnu] needs-llvm-components: x86
+//@ revisions: i686_pc_windows_msvc
+//@ [i686_pc_windows_msvc] compile-flags: --target i686-pc-windows-msvc
+//@ [i686_pc_windows_msvc] needs-llvm-components: x86
+//@ revisions: i686_pc_windows_gnullvm
+//@ [i686_pc_windows_gnullvm] compile-flags: --target i686-pc-windows-gnullvm
+//@ [i686_pc_windows_gnullvm] needs-llvm-components: x86
+//@ revisions: i686_uwp_windows_gnu
+//@ [i686_uwp_windows_gnu] compile-flags: --target i686-uwp-windows-gnu
+//@ [i686_uwp_windows_gnu] needs-llvm-components: x86
+//@ revisions: i686_win7_windows_gnu
+//@ [i686_win7_windows_gnu] compile-flags: --target i686-win7-windows-gnu
+//@ [i686_win7_windows_gnu] needs-llvm-components: x86
+//@ revisions: i686_unknown_uefi
+//@ [i686_unknown_uefi] compile-flags: --target i686-unknown-uefi
+//@ [i686_unknown_uefi] needs-llvm-components: x86
+//@ revisions: i686_uwp_windows_msvc
+//@ [i686_uwp_windows_msvc] compile-flags: --target i686-uwp-windows-msvc
+//@ [i686_uwp_windows_msvc] needs-llvm-components: x86
+//@ revisions: i686_win7_windows_msvc
+//@ [i686_win7_windows_msvc] compile-flags: --target i686-win7-windows-msvc
+//@ [i686_win7_windows_msvc] needs-llvm-components: x86
+//@ revisions: powerpc64_ibm_aix
+//@ [powerpc64_ibm_aix] compile-flags: --target powerpc64-ibm-aix
+//@ [powerpc64_ibm_aix] needs-llvm-components: powerpc
+//@ revisions: thumbv7a_uwp_windows_msvc
+//@ [thumbv7a_uwp_windows_msvc] compile-flags: --target thumbv7a-uwp-windows-msvc
+//@ [thumbv7a_uwp_windows_msvc] needs-llvm-components: arm
+//@ revisions: thumbv7a_pc_windows_msvc
+//@ [thumbv7a_pc_windows_msvc] compile-flags: --target thumbv7a-pc-windows-msvc
+//@ [thumbv7a_pc_windows_msvc] needs-llvm-components: arm
+//@ revisions: x86_64_pc_windows_gnu
+//@ [x86_64_pc_windows_gnu] compile-flags: --target x86_64-pc-windows-gnu
+//@ [x86_64_pc_windows_gnu] needs-llvm-components: x86
+//@ revisions: x86_64_pc_windows_gnullvm
+//@ [x86_64_pc_windows_gnullvm] compile-flags: --target x86_64-pc-windows-gnullvm
+//@ [x86_64_pc_windows_gnullvm] needs-llvm-components: x86
+//@ revisions: x86_64_pc_windows_msvc
+//@ [x86_64_pc_windows_msvc] compile-flags: --target x86_64-pc-windows-msvc
+//@ [x86_64_pc_windows_msvc] needs-llvm-components: x86
+//@ revisions: x86_64_unknown_uefi
+//@ [x86_64_unknown_uefi] compile-flags: --target x86_64-unknown-uefi
+//@ [x86_64_unknown_uefi] needs-llvm-components: x86
+//@ revisions: x86_64_uwp_windows_gnu
+//@ [x86_64_uwp_windows_gnu] compile-flags: --target x86_64-uwp-windows-gnu
+//@ [x86_64_uwp_windows_gnu] needs-llvm-components: x86
+//@ revisions: x86_64_win7_windows_gnu
+//@ [x86_64_win7_windows_gnu] compile-flags: --target x86_64-win7-windows-gnu
+//@ [x86_64_win7_windows_gnu] needs-llvm-components: x86
+//@ revisions: x86_64_uwp_windows_msvc
+//@ [x86_64_uwp_windows_msvc] compile-flags: --target x86_64-uwp-windows-msvc
+//@ [x86_64_uwp_windows_msvc] needs-llvm-components: x86
+//@ revisions: x86_64_win7_windows_msvc
+//@ [x86_64_win7_windows_msvc] compile-flags: --target x86_64-win7-windows-msvc
+//@ [x86_64_win7_windows_msvc] needs-llvm-components: x86
+//@ revisions: x86_64_pc_cygwin
+//@ [x86_64_pc_cygwin] compile-flags: --target x86_64-pc-cygwin
+//@ [x86_64_pc_cygwin] needs-llvm-components: x86
+
+// Sanity-check that each target can produce assembly code.
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn test() -> u8 {
+    42
+}
+
+// CHECK: .file
diff --git a/tests/assembly-llvm/wasm_exceptions.rs b/tests/assembly-llvm/wasm_exceptions.rs
new file mode 100644
index 00000000000..704e8026f3f
--- /dev/null
+++ b/tests/assembly-llvm/wasm_exceptions.rs
@@ -0,0 +1,67 @@
+//@ only-wasm32
+//@ assembly-output: emit-asm
+//@ compile-flags: -C target-feature=+exception-handling
+//@ compile-flags: -C panic=unwind
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+extern "C-unwind" {
+    fn may_panic();
+}
+
+extern "C" {
+    fn log_number(number: usize);
+}
+
+struct LogOnDrop;
+
+impl Drop for LogOnDrop {
+    fn drop(&mut self) {
+        unsafe {
+            log_number(0);
+        }
+    }
+}
+
+// CHECK-LABEL: test_cleanup:
+#[no_mangle]
+pub fn test_cleanup() {
+    let _log_on_drop = LogOnDrop;
+    unsafe {
+        may_panic();
+    }
+
+    // CHECK-NOT: call
+    // CHECK: try
+    // CHECK: call may_panic
+    // CHECK: catch_all
+    // CHECK: rethrow
+    // CHECK: end_try
+}
+
+// CHECK-LABEL: test_rtry:
+#[no_mangle]
+pub fn test_rtry() {
+    unsafe {
+        core::intrinsics::catch_unwind(
+            |_| {
+                may_panic();
+            },
+            core::ptr::null_mut(),
+            |data, exception| {
+                log_number(data as usize);
+                log_number(exception as usize);
+            },
+        );
+    }
+
+    // CHECK-NOT: call
+    // CHECK: try
+    // CHECK: call may_panic
+    // CHECK: catch
+    // CHECK: call log_number
+    // CHECK: call log_number
+    // CHECK-NOT: rethrow
+    // CHECK: end_try
+}
diff --git a/tests/assembly-llvm/x86-return-float.rs b/tests/assembly-llvm/x86-return-float.rs
new file mode 100644
index 00000000000..165c11d2280
--- /dev/null
+++ b/tests/assembly-llvm/x86-return-float.rs
@@ -0,0 +1,343 @@
+//@ assembly-output: emit-asm
+// FIXME(#114479): LLVM miscompiles loading and storing `f32` and `f64` when SSE is disabled.
+// There's no compiletest directive to ignore a test on i586 only, so just always explicitly enable
+// SSE2.
+// Use the same target CPU as `i686` so that LLVM orders the instructions in the same order.
+//@ compile-flags: -Ctarget-feature=+sse2 -Ctarget-cpu=pentium4
+// Force frame pointers to make ASM more consistent between targets
+//@ compile-flags: -C force-frame-pointers
+// At opt-level=3, LLVM can merge two movss into one movsd, and we aren't testing for that.
+//@ compile-flags: -Copt-level=2
+//@ filecheck-flags: --implicit-check-not fld --implicit-check-not fst
+//@ revisions: linux win
+//@ add-core-stubs
+//@[linux] needs-llvm-components: x86
+//@[win] needs-llvm-components: x86
+//@[linux] compile-flags: --target i686-unknown-linux-gnu
+//@[win] compile-flags: --target i686-pc-windows-msvc
+
+#![crate_type = "lib"]
+#![feature(f16, f128)]
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// Tests that returning `f32` and `f64` with the "Rust" ABI on 32-bit x86 doesn't use the x87
+// floating point stack, as loading and storing `f32`s and `f64`s to and from the x87 stack quietens
+// signalling NaNs.
+
+// Returning individual floats
+
+// CHECK-LABEL: return_f32:
+#[no_mangle]
+pub fn return_f32(x: f32) -> f32 {
+    // CHECK: movss {{.*}}(%ebp), %xmm0
+    // CHECK-NEXT: popl %ebp
+    // linux-NEXT: .cfi_def_cfa
+    // CHECK-NEXT: retl
+    x
+}
+
+// CHECK-LABEL: return_f64:
+#[no_mangle]
+pub fn return_f64(x: f64) -> f64 {
+    // CHECK: movsd {{.*}}(%ebp), %xmm0
+    // CHECK-NEXT: popl %ebp
+    // linux-NEXT: .cfi_def_cfa
+    // CHECK-NEXT: retl
+    x
+}
+
+// Returning scalar pairs containing floats
+
+// CHECK-LABEL: return_f32_f32:
+#[no_mangle]
+pub fn return_f32_f32(x: (f32, f32)) -> (f32, f32) {
+    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
+    // CHECK-NEXT: movss [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
+    // CHECK-NEXT: movss [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
+    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movss %[[VAL2]], 4(%[[PTR]])
+    // CHECK: retl
+    x
+}
+
+// CHECK-LABEL: return_f64_f64:
+#[no_mangle]
+pub fn return_f64_f64(x: (f64, f64)) -> (f64, f64) {
+    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
+    // CHECK-NEXT: movsd [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
+    // CHECK-NEXT: movsd [[#%d,OFFSET+12]](%ebp), %[[VAL2:.*]]
+    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movsd %[[VAL2]], 8(%[[PTR]])
+    // CHECK: retl
+    x
+}
+
+// CHECK-LABEL: return_f32_f64:
+#[no_mangle]
+pub fn return_f32_f64(x: (f32, f64)) -> (f32, f64) {
+    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
+    // CHECK-NEXT: movss [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
+    // CHECK-NEXT: movsd [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
+    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movsd %[[VAL2]], {{4|8}}(%[[PTR]])
+    // CHECK: retl
+    x
+}
+
+// CHECK-LABEL: return_f64_f32:
+#[no_mangle]
+pub fn return_f64_f32(x: (f64, f32)) -> (f64, f32) {
+    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
+    // CHECK-NEXT: movsd [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
+    // CHECK-NEXT: movss [[#%d,OFFSET+12]](%ebp), %[[VAL2:.*]]
+    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movss %[[VAL2]], 8(%[[PTR]])
+    // CHECK: retl
+    x
+}
+
+// CHECK-LABEL: return_f32_other:
+#[no_mangle]
+pub fn return_f32_other(x: (f32, usize)) -> (f32, usize) {
+    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
+    // CHECK-NEXT: movss [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
+    // CHECK-NEXT: movl [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
+    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movl %[[VAL2]], 4(%[[PTR]])
+    // CHECK: retl
+    x
+}
+
+// CHECK-LABEL: return_f64_other:
+#[no_mangle]
+pub fn return_f64_other(x: (f64, usize)) -> (f64, usize) {
+    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
+    // CHECK-NEXT: movsd [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
+    // CHECK-NEXT: movl [[#%d,OFFSET+12]](%ebp), %[[VAL2:.*]]
+    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movl %[[VAL2]], 8(%[[PTR]])
+    // CHECK: retl
+    x
+}
+
+// CHECK-LABEL: return_other_f32:
+#[no_mangle]
+pub fn return_other_f32(x: (usize, f32)) -> (usize, f32) {
+    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
+    // CHECK-NEXT: movl [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
+    // CHECK-NEXT: movss [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
+    // CHECK-NEXT: movl %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movss %[[VAL2]], 4(%[[PTR]])
+    // CHECK: retl
+    x
+}
+
+// CHECK-LABEL: return_other_f64:
+#[no_mangle]
+pub fn return_other_f64(x: (usize, f64)) -> (usize, f64) {
+    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
+    // CHECK-NEXT: movl [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
+    // CHECK-NEXT: movsd [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
+    // CHECK-NEXT: movl %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movsd %[[VAL2]], {{4|8}}(%[[PTR]])
+    // CHECK: retl
+    x
+}
+
+// Calling functions returning floats
+
+// CHECK-LABEL: call_f32:
+#[no_mangle]
+pub unsafe fn call_f32(x: &mut f32) {
+    extern "Rust" {
+        fn get_f32() -> f32;
+    }
+    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
+    // CHECK: calll {{()|_}}get_f32
+    // CHECK-NEXT: movss %xmm0, (%[[PTR]])
+    *x = get_f32();
+}
+
+// CHECK-LABEL: call_f64:
+#[no_mangle]
+pub unsafe fn call_f64(x: &mut f64) {
+    extern "Rust" {
+        fn get_f64() -> f64;
+    }
+    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
+    // CHECK: calll {{()|_}}get_f64
+    // CHECK-NEXT: movlps %xmm0, (%[[PTR]])
+    *x = get_f64();
+}
+
+// Calling functions returning scalar pairs containing floats
+
+// CHECK-LABEL: call_f32_f32:
+#[no_mangle]
+pub unsafe fn call_f32_f32(x: &mut (f32, f32)) {
+    extern "Rust" {
+        fn get_f32_f32() -> (f32, f32);
+    }
+    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
+    // CHECK: calll {{()|_}}get_f32_f32
+    // CHECK: movss [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
+    // CHECK-NEXT: movss [[#%d,OFFSET+4]](%ebp), %[[VAL2:.*]]
+    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movss %[[VAL2]], 4(%[[PTR]])
+    *x = get_f32_f32();
+}
+
+// CHECK-LABEL: call_f64_f64:
+#[no_mangle]
+pub unsafe fn call_f64_f64(x: &mut (f64, f64)) {
+    extern "Rust" {
+        fn get_f64_f64() -> (f64, f64);
+    }
+    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
+    // CHECK: calll {{()|_}}get_f64_f64
+    // linux: movsd [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
+    // linux-NEXT: movsd [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
+    // win: movsd (%esp), %[[VAL1:.*]]
+    // win-NEXT: movsd 8(%esp), %[[VAL2:.*]]
+    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movsd %[[VAL2]], 8(%[[PTR]])
+    *x = get_f64_f64();
+}
+
+// CHECK-LABEL: call_f32_f64:
+#[no_mangle]
+pub unsafe fn call_f32_f64(x: &mut (f32, f64)) {
+    extern "Rust" {
+        fn get_f32_f64() -> (f32, f64);
+    }
+    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
+    // CHECK: calll {{()|_}}get_f32_f64
+    // linux: movss [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
+    // linux-NEXT: movsd [[#%d,OFFSET+4]](%ebp), %[[VAL2:.*]]
+    // win: movss (%esp), %[[VAL1:.*]]
+    // win-NEXT: movsd 8(%esp), %[[VAL2:.*]]
+    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
+    // linux-NEXT: movsd %[[VAL2]], 4(%[[PTR]])
+    // win-NEXT: movsd %[[VAL2]], 8(%[[PTR]])
+    *x = get_f32_f64();
+}
+
+// CHECK-LABEL: call_f64_f32:
+#[no_mangle]
+pub unsafe fn call_f64_f32(x: &mut (f64, f32)) {
+    extern "Rust" {
+        fn get_f64_f32() -> (f64, f32);
+    }
+    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
+    // CHECK: calll {{()|_}}get_f64_f32
+    // linux: movsd [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
+    // linux-NEXT: movss [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
+    // win: movsd (%esp), %[[VAL1:.*]]
+    // win-NEXT: movss 8(%esp), %[[VAL2:.*]]
+    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movss %[[VAL2]], 8(%[[PTR]])
+    *x = get_f64_f32();
+}
+
+// CHECK-LABEL: call_f32_other:
+#[no_mangle]
+pub unsafe fn call_f32_other(x: &mut (f32, usize)) {
+    extern "Rust" {
+        fn get_f32_other() -> (f32, usize);
+    }
+    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
+    // CHECK: calll {{()|_}}get_f32_other
+    // CHECK: movss [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
+    // CHECK-NEXT: movl [[#%d,OFFSET+4]](%ebp), %[[VAL2:.*]]
+    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movl %[[VAL2]], 4(%[[PTR]])
+    *x = get_f32_other();
+}
+
+// CHECK-LABEL: call_f64_other:
+#[no_mangle]
+pub unsafe fn call_f64_other(x: &mut (f64, usize)) {
+    extern "Rust" {
+        fn get_f64_other() -> (f64, usize);
+    }
+    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
+    // CHECK: calll {{()|_}}get_f64_other
+    // linux: movsd [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
+    // linux-NEXT: movl [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
+    // win: movsd (%esp), %[[VAL1:.*]]
+    // win-NEXT: movl 8(%esp), %[[VAL2:.*]]
+    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movl %[[VAL2]], 8(%[[PTR]])
+    *x = get_f64_other();
+}
+
+// CHECK-LABEL: call_other_f32:
+#[no_mangle]
+pub unsafe fn call_other_f32(x: &mut (usize, f32)) {
+    extern "Rust" {
+        fn get_other_f32() -> (usize, f32);
+    }
+    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
+    // CHECK: calll {{()|_}}get_other_f32
+    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
+    // CHECK-NEXT: movss [[#%d,OFFSET+4]](%ebp), %[[VAL2:.*]]
+    // CHECK-NEXT: movl %[[VAL1]], (%[[PTR]])
+    // CHECK-NEXT: movss %[[VAL2]], 4(%[[PTR]])
+    *x = get_other_f32();
+}
+
+// CHECK-LABEL: call_other_f64:
+#[no_mangle]
+pub unsafe fn call_other_f64(x: &mut (usize, f64)) {
+    extern "Rust" {
+        fn get_other_f64() -> (usize, f64);
+    }
+    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
+    // CHECK: calll {{()|_}}get_other_f64
+    // linux: movl [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
+    // linux-NEXT: movsd [[#%d,OFFSET+4]](%ebp), %[[VAL2:.*]]
+    // win: movl (%esp), %[[VAL1:.*]]
+    // win-NEXT: movsd 8(%esp), %[[VAL2:.*]]
+    // CHECK-NEXT: movl %[[VAL1]], (%[[PTR]])
+    // linux-NEXT: movsd %[[VAL2]], 4(%[[PTR]])
+    // win-NEXT: movsd %[[VAL2]], 8(%[[PTR]])
+    *x = get_other_f64();
+}
+
+// The "C" ABI for `f16` and `f128` on x86 has never used the x87 floating point stack. Do some
+// basic checks to ensure this remains the case for the "Rust" ABI.
+
+// CHECK-LABEL: return_f16:
+#[no_mangle]
+pub fn return_f16(x: f16) -> f16 {
+    // CHECK: pushl %ebp
+    // linux-NEXT: .cfi_def_cfa_offset
+    // linux-NEXT: .cfi_offset
+    // CHECK-NEXT: movl %esp, %ebp
+    // linux-NEXT: .cfi_def_cfa_register
+    // CHECK-NEXT: pinsrw $0, 8(%ebp), %xmm0
+    // CHECK-NEXT: popl %ebp
+    // linux-NEXT: .cfi_def_cfa
+    // CHECK-NEXT: retl
+    x
+}
+
+// CHECK-LABEL: return_f128:
+#[no_mangle]
+pub fn return_f128(x: f128) -> f128 {
+    // CHECK: pushl %ebp
+    // linux-NEXT: .cfi_def_cfa_offset
+    // linux-NEXT: .cfi_offset
+    // CHECK-NEXT: movl %esp, %ebp
+    // linux-NEXT: .cfi_def_cfa_register
+    // linux-NEXT: movaps 8(%ebp), %xmm0
+    // win-NEXT: movups 8(%ebp), %xmm0
+    // CHECK-NEXT: popl %ebp
+    // linux-NEXT: .cfi_def_cfa
+    // CHECK-NEXT: retl
+    x
+}
diff --git a/tests/assembly-llvm/x86_64-array-pair-load-store-merge.rs b/tests/assembly-llvm/x86_64-array-pair-load-store-merge.rs
new file mode 100644
index 00000000000..56a1a9e8206
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-array-pair-load-store-merge.rs
@@ -0,0 +1,20 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C llvm-args=-x86-asm-syntax=intel
+//@ only-x86_64
+//@ ignore-sgx
+//@ ignore-apple (manipulates rsp too)
+
+// Depending on various codegen choices, this might end up copying
+// a `<2 x i8>`, an `i16`, or two `i8`s.
+// Regardless of those choices, make sure the instructions use (2-byte) words.
+
+// CHECK-LABEL: array_copy_2_elements:
+#[no_mangle]
+pub fn array_copy_2_elements(a: &[u8; 2], p: &mut [u8; 2]) {
+    // CHECK-NOT: byte
+    // CHECK-NOT: mov
+    // CHECK: mov{{.+}}, word ptr
+    // CHECK-NEXT: mov word ptr
+    // CHECK-NEXT: ret
+    *p = *a;
+}
diff --git a/tests/assembly-llvm/x86_64-bigint-helpers.rs b/tests/assembly-llvm/x86_64-bigint-helpers.rs
new file mode 100644
index 00000000000..58785932bc2
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-bigint-helpers.rs
@@ -0,0 +1,61 @@
+//@ only-x86_64
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C target-cpu=x86-64-v4
+//@ compile-flags: -C llvm-args=-x86-asm-syntax=intel
+//@ revisions: llvm-pre-20 llvm-20
+//@ [llvm-20] min-llvm-version: 20
+//@ [llvm-pre-20] max-llvm-major-version: 19
+
+#![no_std]
+#![feature(bigint_helper_methods)]
+
+// This checks that the `carrying_add` and `borrowing_sub` implementation successfully chain,
+// to catch issues like <https://github.com/rust-lang/rust/issues/85532#issuecomment-2495119815>
+
+// This forces the ABI to avoid the windows-vs-linux ABI differences.
+
+// CHECK-LABEL: bigint_chain_carrying_add:
+#[no_mangle]
+pub unsafe extern "sysv64" fn bigint_chain_carrying_add(
+    dest: *mut u64,
+    src1: *const u64,
+    src2: *const u64,
+    n: usize,
+    mut carry: bool,
+) -> bool {
+    // llvm-pre-20: mov [[TEMP:r..]], qword ptr [rsi + 8*[[IND:r..]] + 8]
+    // llvm-pre-20: adc [[TEMP]], qword ptr [rdx + 8*[[IND]] + 8]
+    // llvm-pre-20: mov qword ptr [rdi + 8*[[IND]] + 8], [[TEMP]]
+    // llvm-pre-20: mov [[TEMP]], qword ptr [rsi + 8*[[IND]] + 16]
+    // llvm-pre-20: adc [[TEMP]], qword ptr [rdx + 8*[[IND]] + 16]
+    // llvm-pre-20: mov qword ptr [rdi + 8*[[IND]] + 16], [[TEMP]]
+    // llvm-20: adc [[TEMP:r..]], qword ptr [rdx + 8*[[IND:r..]]]
+    // llvm-20: mov qword ptr [rdi + 8*[[IND]]], [[TEMP]]
+    // llvm-20: mov [[TEMP]], qword ptr [rsi + 8*[[IND]] + 8]
+    // llvm-20: adc [[TEMP]], qword ptr [rdx + 8*[[IND]] + 8]
+    for i in 0..n {
+        (*dest.add(i), carry) = u64::carrying_add(*src1.add(i), *src2.add(i), carry);
+    }
+    carry
+}
+
+// CHECK-LABEL: bigint_chain_borrowing_sub:
+#[no_mangle]
+pub unsafe extern "sysv64" fn bigint_chain_borrowing_sub(
+    dest: *mut u64,
+    src1: *const u64,
+    src2: *const u64,
+    n: usize,
+    mut carry: bool,
+) -> bool {
+    // CHECK: mov [[TEMP:r..]], qword ptr [rsi + 8*[[IND:r..]] + 8]
+    // CHECK: sbb [[TEMP]], qword ptr [rdx + 8*[[IND]] + 8]
+    // CHECK: mov qword ptr [rdi + 8*[[IND]] + 8], [[TEMP]]
+    // CHECK: mov [[TEMP]], qword ptr [rsi + 8*[[IND]] + 16]
+    // CHECK: sbb [[TEMP]], qword ptr [rdx + 8*[[IND]] + 16]
+    // CHECK: mov qword ptr [rdi + 8*[[IND]] + 16], [[TEMP]]
+    for i in 0..n {
+        (*dest.add(i), carry) = u64::borrowing_sub(*src1.add(i), *src2.add(i), carry);
+    }
+    carry
+}
diff --git a/tests/assembly-llvm/x86_64-cmp.rs b/tests/assembly-llvm/x86_64-cmp.rs
new file mode 100644
index 00000000000..26c9013d96f
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-cmp.rs
@@ -0,0 +1,79 @@
+//@ revisions: LLVM-PRE-20-DEBUG LLVM-20-DEBUG LLVM-PRE-20-OPTIM LLVM-20-OPTIM
+//@ [LLVM-PRE-20-DEBUG] compile-flags: -C opt-level=0
+//@ [LLVM-PRE-20-DEBUG] max-llvm-major-version: 19
+//@ [LLVM-20-DEBUG] compile-flags: -C opt-level=0
+//@ [LLVM-20-DEBUG] min-llvm-version: 20
+//@ [LLVM-PRE-20-OPTIM] compile-flags: -C opt-level=3
+//@ [LLVM-PRE-20-OPTIM] max-llvm-major-version: 19
+//@ [LLVM-20-OPTIM] compile-flags: -C opt-level=3
+//@ [LLVM-20-OPTIM] min-llvm-version: 20
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -C llvm-args=-x86-asm-syntax=intel
+//@ only-x86_64
+//@ ignore-sgx
+
+#![feature(core_intrinsics)]
+
+use std::intrinsics::three_way_compare;
+
+#[no_mangle]
+// CHECK-LABEL: signed_cmp:
+pub fn signed_cmp(a: i16, b: i16) -> std::cmp::Ordering {
+    // LLVM-PRE-20-DEBUG: cmp
+    // LLVM-PRE-20-DEBUG: setg
+    // LLVM-PRE-20-DEBUG: and
+    // LLVM-PRE-20-DEBUG: cmp
+    // LLVM-PRE-20-DEBUG: setl
+    // LLVM-PRE-20-DEBUG: and
+    // LLVM-PRE-20-DEBUG: sub
+    //
+    // LLVM-20-DEBUG: sub
+    // LLVM-20-DEBUG: setl
+    // LLVM-20-DEBUG: setg
+    // LLVM-20-DEBUG: sub
+    // LLVM-20-DEBUG: ret
+
+    // LLVM-PRE-20-OPTIM: xor
+    // LLVM-PRE-20-OPTIM: cmp
+    // LLVM-PRE-20-OPTIM: setne
+    // LLVM-PRE-20-OPTIM: mov
+    // LLVM-PRE-20-OPTIM: cmovge
+    // LLVM-PRE-20-OPTIM: ret
+    //
+    // LLVM-20-OPTIM: cmp
+    // LLVM-20-OPTIM: setl
+    // LLVM-20-OPTIM: setg
+    // LLVM-20-OPTIM: sub
+    // LLVM-20-OPTIM: ret
+    three_way_compare(a, b)
+}
+
+#[no_mangle]
+// CHECK-LABEL: unsigned_cmp:
+pub fn unsigned_cmp(a: u16, b: u16) -> std::cmp::Ordering {
+    // LLVM-PRE-20-DEBUG: cmp
+    // LLVM-PRE-20-DEBUG: seta
+    // LLVM-PRE-20-DEBUG: and
+    // LLVM-PRE-20-DEBUG: cmp
+    // LLVM-PRE-20-DEBUG: setb
+    // LLVM-PRE-20-DEBUG: and
+    // LLVM-PRE-20-DEBUG: sub
+    //
+    // LLVM-20-DEBUG: sub
+    // LLVM-20-DEBUG: seta
+    // LLVM-20-DEBUG: sbb
+    // LLVM-20-DEBUG: ret
+
+    // LLVM-PRE-20-OPTIM: xor
+    // LLVM-PRE-20-OPTIM: cmp
+    // LLVM-PRE-20-OPTIM: setne
+    // LLVM-PRE-20-OPTIM: mov
+    // LLVM-PRE-20-OPTIM: cmovae
+    // LLVM-PRE-20-OPTIM: ret
+    //
+    // LLVM-20-OPTIM: cmp
+    // LLVM-20-OPTIM: seta
+    // LLVM-20-OPTIM: sbb
+    // LLVM-20-OPTIM: ret
+    three_way_compare(a, b)
+}
diff --git a/tests/assembly-llvm/x86_64-floating-point-clamp.rs b/tests/assembly-llvm/x86_64-floating-point-clamp.rs
new file mode 100644
index 00000000000..6b0c29c5f21
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-floating-point-clamp.rs
@@ -0,0 +1,27 @@
+// Floating-point clamp is designed to be implementable as max+min,
+// so check to make sure that's what it's actually emitting.
+
+//@ assembly-output: emit-asm
+// Set the base cpu explicitly, in case the default has been changed.
+//@ compile-flags: --crate-type=lib -Copt-level=3 -C llvm-args=-x86-asm-syntax=intel -C target-cpu=x86-64
+//@ only-x86_64
+//@ ignore-sgx
+
+// CHECK-LABEL: clamp_demo:
+#[no_mangle]
+pub fn clamp_demo(a: f32, x: f32, y: f32) -> f32 {
+    // CHECK: maxss
+    // CHECK: minss
+    a.clamp(x, y)
+}
+
+// CHECK-LABEL: clamp12_demo:
+#[no_mangle]
+pub fn clamp12_demo(a: f32) -> f32 {
+    // CHECK: movss   xmm1
+    // CHECK-NEXT: maxss   xmm1, xmm0
+    // CHECK-NEXT: movss   xmm0
+    // CHECK-NEXT: minss   xmm0, xmm1
+    // CHECK: ret
+    a.clamp(1.0, 2.0)
+}
diff --git a/tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-generic-load.rs b/tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-generic-load.rs
new file mode 100644
index 00000000000..f5e2f18e68e
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-generic-load.rs
@@ -0,0 +1,17 @@
+// Test LVI load hardening on SGX enclave code
+
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type staticlib
+//@ only-x86_64-fortanix-unknown-sgx
+
+#[no_mangle]
+pub extern "C" fn plus_one(r: &mut u64) {
+    *r = *r + 1;
+}
+
+// CHECK: plus_one
+// CHECK: lfence
+// CHECK-NEXT: incq
+// CHECK: popq [[REGISTER:%[a-z]+]]
+// CHECK-NEXT: lfence
+// CHECK-NEXT: jmpq *[[REGISTER]]
diff --git a/tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-generic-ret.rs b/tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-generic-ret.rs
new file mode 100644
index 00000000000..f16d68fa255
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-generic-ret.rs
@@ -0,0 +1,12 @@
+// Test LVI ret hardening on generic rust code
+
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type staticlib
+//@ only-x86_64-fortanix-unknown-sgx
+
+#[no_mangle]
+pub extern "C" fn myret() {}
+// CHECK: myret:
+// CHECK: popq [[REGISTER:%[a-z]+]]
+// CHECK-NEXT: lfence
+// CHECK-NEXT: jmpq *[[REGISTER]]
diff --git a/tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-inline-assembly.rs b/tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-inline-assembly.rs
new file mode 100644
index 00000000000..a729df8e166
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-fortanix-unknown-sgx-lvi-inline-assembly.rs
@@ -0,0 +1,34 @@
+// Test LVI load hardening on SGX inline assembly code
+
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type staticlib
+//@ only-x86_64-fortanix-unknown-sgx
+
+use std::arch::asm;
+
+#[no_mangle]
+pub extern "C" fn get(ptr: *const u64) -> u64 {
+    let value: u64;
+    unsafe {
+        asm!("mov {}, [{}]",
+            out(reg) value,
+            in(reg) ptr);
+    }
+    value
+}
+
+// CHECK: get
+// CHECK: movq
+// CHECK-NEXT: lfence
+
+#[no_mangle]
+pub extern "C" fn myret() {
+    unsafe {
+        asm!("ret");
+    }
+}
+
+// CHECK: myret
+// CHECK: shlq $0, (%rsp)
+// CHECK-NEXT: lfence
+// CHECK-NEXT: retq
diff --git a/tests/assembly-llvm/x86_64-function-return.rs b/tests/assembly-llvm/x86_64-function-return.rs
new file mode 100644
index 00000000000..7fd57200a9e
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-function-return.rs
@@ -0,0 +1,30 @@
+// Test that the function return is (not) converted into a jump to the thunk
+// when the `-Zfunction-return={keep,thunk-extern}` flag is (not) set.
+
+//@ revisions: unset keep thunk-extern keep-thunk-extern thunk-extern-keep
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3
+//@ [keep] compile-flags: -Zfunction-return=keep
+//@ [thunk-extern] compile-flags: -Zfunction-return=thunk-extern
+//@ [keep-thunk-extern] compile-flags: -Zfunction-return=keep -Zfunction-return=thunk-extern
+//@ [thunk-extern-keep] compile-flags: -Zfunction-return=thunk-extern -Zfunction-return=keep
+//@ only-x86_64
+//@ ignore-apple Symbol is called `___x86_return_thunk` (Darwin's extra underscore)
+//@ ignore-sgx Tests incompatible with LVI mitigations
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: foo:
+#[no_mangle]
+pub unsafe fn foo() {
+    // unset: ret
+    // unset-NOT: jmp __x86_return_thunk
+    // keep: ret
+    // keep-NOT: jmp __x86_return_thunk
+    // thunk-extern: jmp __x86_return_thunk
+    // thunk-extern-NOT: ret
+    // keep-thunk-extern: jmp __x86_return_thunk
+    // keep-thunk-extern-NOT: ret
+    // thunk-extern-keep: ret
+    // thunk-extern-keep-NOT: jmp __x86_return_thunk
+}
diff --git a/tests/assembly-llvm/x86_64-no-jump-tables.rs b/tests/assembly-llvm/x86_64-no-jump-tables.rs
new file mode 100644
index 00000000000..bb10042d8f6
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-no-jump-tables.rs
@@ -0,0 +1,35 @@
+// Test that jump tables are (not) emitted when the `-Zno-jump-tables`
+// flag is (not) set.
+
+//@ revisions: unset set
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3
+//@ [set] compile-flags: -Zno-jump-tables
+//@ only-x86_64
+//@ ignore-sgx
+
+#![crate_type = "lib"]
+
+extern "C" {
+    fn bar1();
+    fn bar2();
+    fn bar3();
+    fn bar4();
+    fn bar5();
+    fn bar6();
+}
+
+// CHECK-LABEL: foo:
+#[no_mangle]
+pub unsafe fn foo(x: i32) {
+    // unset: LJTI0_0
+    // set-NOT: LJTI0_0
+    match x {
+        1 => bar1(),
+        2 => bar2(),
+        3 => bar3(),
+        4 => bar4(),
+        5 => bar5(),
+        _ => bar6(),
+    }
+}
diff --git a/tests/assembly-llvm/x86_64-sse_crc.rs b/tests/assembly-llvm/x86_64-sse_crc.rs
new file mode 100644
index 00000000000..bde58955a21
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-sse_crc.rs
@@ -0,0 +1,12 @@
+//@ only-x86_64
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type staticlib -Ctarget-feature=+sse4.2
+
+// CHECK-LABEL: banana
+// CHECK: crc32
+#[no_mangle]
+pub unsafe fn banana(v: u8) -> u32 {
+    use std::arch::x86_64::*;
+    let out = !0u32;
+    _mm_crc32_u8(out, v)
+}
diff --git a/tests/assembly-llvm/x86_64-typed-swap.rs b/tests/assembly-llvm/x86_64-typed-swap.rs
new file mode 100644
index 00000000000..a6753011d36
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-typed-swap.rs
@@ -0,0 +1,81 @@
+//@ revisions: WIN LIN
+//@ [WIN] only-windows
+//@ [LIN] only-linux
+//@ only-x86_64
+//@ assembly-output: emit-asm
+//@ compile-flags: --crate-type=lib -Copt-level=3
+
+use std::arch::x86_64::__m128;
+use std::mem::swap;
+
+// CHECK-LABEL: swap_i32:
+#[no_mangle]
+pub fn swap_i32(x: &mut i32, y: &mut i32) {
+    // CHECK: movl (%[[ARG1:.+]]), %[[T1:.+]]
+    // CHECK-NEXT: movl (%[[ARG2:.+]]), %[[T2:.+]]
+    // CHECK-DAG: movl %[[T2]], (%[[ARG1]])
+    // CHECK-DAG: movl %[[T1]], (%[[ARG2]])
+    // CHECK-NEXT: retq
+    swap(x, y)
+}
+
+// CHECK-LABEL: swap_pair:
+#[no_mangle]
+pub fn swap_pair(x: &mut (i32, u32), y: &mut (i32, u32)) {
+    // CHECK: movq (%[[ARG1:r..?]]), %[[T1:.+]]
+    // CHECK-NEXT: movq (%[[ARG2:r..?]]), %[[T2:.+]]
+    // CHECK-DAG: movq %[[T2]], (%[[ARG1]])
+    // CHECK-DAG: movq %[[T1]], (%[[ARG2]])
+    // CHECK-NEXT: retq
+    swap(x, y)
+}
+
+// CHECK-LABEL: swap_str:
+#[no_mangle]
+pub fn swap_str<'a>(x: &mut &'a str, y: &mut &'a str) {
+    // CHECK: movups (%[[ARG1:r..?]]), %[[T1:xmm.]]
+    // CHECK-NEXT: movups (%[[ARG2:r..?]]), %[[T2:xmm.]]
+    // CHECK-DAG: movups %[[T2]], (%[[ARG1]])
+    // CHECK-DAG: movups %[[T1]], (%[[ARG2]])
+    // CHECK-NEXT: retq
+    swap(x, y)
+}
+
+// CHECK-LABEL: swap_simd:
+#[no_mangle]
+pub fn swap_simd(x: &mut __m128, y: &mut __m128) {
+    // CHECK: movaps (%[[ARG1:r..?]]), %[[T1:xmm.]]
+    // CHECK-NEXT: movaps (%[[ARG2:r..?]]), %[[T2:xmm.]]
+    // CHECK-DAG: movaps %[[T2]], (%[[ARG1]])
+    // CHECK-DAG: movaps %[[T1]], (%[[ARG2]])
+    // CHECK-NEXT: retq
+    swap(x, y)
+}
+
+// CHECK-LABEL: swap_string:
+#[no_mangle]
+pub fn swap_string(x: &mut String, y: &mut String) {
+    // CHECK-NOT: mov
+    // CHECK-COUNT-4: movups
+    // CHECK-NOT: mov
+    // CHECK-COUNT-4: movq
+    // CHECK-NOT: mov
+    swap(x, y)
+}
+
+// CHECK-LABEL: swap_44_bytes:
+#[no_mangle]
+pub fn swap_44_bytes(x: &mut [u8; 44], y: &mut [u8; 44]) {
+    // Ensure we do better than a long run of byte copies,
+    // see <https://github.com/rust-lang/rust/issues/134946>
+
+    // CHECK-NOT: movb
+    // CHECK-COUNT-8: movups{{.+}}xmm
+    // CHECK-NOT: movb
+    // CHECK-COUNT-4: movq
+    // CHECK-NOT: movb
+    // CHECK-COUNT-4: movl
+    // CHECK-NOT: movb
+    // CHECK: retq
+    swap(x, y)
+}
diff --git a/tests/assembly-llvm/x86_64-windows-float-abi.rs b/tests/assembly-llvm/x86_64-windows-float-abi.rs
new file mode 100644
index 00000000000..cbc80910851
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-windows-float-abi.rs
@@ -0,0 +1,46 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: -Copt-level=3
+//@ compile-flags: --target x86_64-pc-windows-msvc
+//@ needs-llvm-components: x86
+//@ add-core-stubs
+
+#![feature(f16, f128)]
+#![feature(no_core)]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: second_f16
+// CHECK: movaps %xmm1, %xmm0
+// CHECK-NEXT: retq
+#[no_mangle]
+pub extern "C" fn second_f16(_: f16, x: f16) -> f16 {
+    x
+}
+
+// CHECK-LABEL: second_f32
+// CHECK: movaps %xmm1, %xmm0
+// CHECK-NEXT: retq
+#[no_mangle]
+pub extern "C" fn second_f32(_: f32, x: f32) -> f32 {
+    x
+}
+
+// CHECK-LABEL: second_f64
+// CHECK: movaps %xmm1, %xmm0
+// CHECK-NEXT: retq
+#[no_mangle]
+pub extern "C" fn second_f64(_: f64, x: f64) -> f64 {
+    x
+}
+
+// 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-NEXT: retq
+#[no_mangle]
+pub extern "C" fn second_f128(_: f128, x: f128) -> f128 {
+    x
+}
diff --git a/tests/assembly-llvm/x86_64-windows-i128-abi.rs b/tests/assembly-llvm/x86_64-windows-i128-abi.rs
new file mode 100644
index 00000000000..d2aefb7daa6
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-windows-i128-abi.rs
@@ -0,0 +1,26 @@
+//@ assembly-output: emit-asm
+//@ add-core-stubs
+//@ revisions: msvc softfloat
+//@ compile-flags: -Copt-level=3
+//@[msvc] compile-flags: --target x86_64-pc-windows-msvc
+//@[msvc] needs-llvm-components: x86
+//@[softfloat] compile-flags: --target x86_64-unknown-uefi
+//@[softfloat] needs-llvm-components: x86
+
+#![feature(no_core)]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: ret_i128
+// Hardfloat targets return via xmm0, softfloat targets via rax and rdx.
+// msvc: movaps {{.*}}, %xmm0
+// softfloat: movq (%[[INPUT:.*]]), %rax
+// softfloat-NEXT: movq 8(%[[INPUT]]), %rdx
+// CHECK-NEXT: retq
+#[no_mangle]
+pub extern "C" fn ret_i128(x: &i128) -> i128 {
+    *x
+}
diff --git a/tests/assembly-llvm/x86_64-xray.rs b/tests/assembly-llvm/x86_64-xray.rs
new file mode 100644
index 00000000000..4cf3e8cda13
--- /dev/null
+++ b/tests/assembly-llvm/x86_64-xray.rs
@@ -0,0 +1,25 @@
+//@ assembly-output: emit-asm
+//@ compile-flags: -Zinstrument-xray=always -Cllvm-args=-x86-asm-syntax=intel
+
+//@ revisions: x86_64-linux
+//@[x86_64-linux] compile-flags: --target=x86_64-unknown-linux-gnu
+//@[x86_64-linux] needs-llvm-components: x86
+//@[x86_64-linux] only-x86_64-unknown-linux-gnu
+
+//@ revisions: x86_64-darwin
+//@[x86_64-darwin] compile-flags: --target=x86_64-apple-darwin
+//@[x86_64-darwin] needs-llvm-components: x86
+//@[x86_64-darwin] only-x86_64-apple-darwin
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: xray_func:
+#[no_mangle]
+pub fn xray_func() {
+    // CHECK: nop word ptr [rax + rax + 512]
+
+    std::hint::black_box(());
+
+    // CHECK: ret
+    // CHECK-NEXT: nop word ptr cs:[rax + rax + 512]
+}
diff --git a/tests/assembly/aarch64-pointer-auth.rs b/tests/assembly/aarch64-pointer-auth.rs
deleted file mode 100644
index 56a26df469f..00000000000
--- a/tests/assembly/aarch64-pointer-auth.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Test that PAC instructions are emitted when branch-protection is specified.
-
-//@ add-core-stubs
-//@ revisions: PACRET PAUTHLR_NOP PAUTHLR
-//@ assembly-output: emit-asm
-//@ needs-llvm-components: aarch64
-//@ compile-flags: --target aarch64-unknown-linux-gnu
-//@ [PACRET] compile-flags: -Z branch-protection=pac-ret,leaf
-//@ [PAUTHLR_NOP] compile-flags: -Z branch-protection=pac-ret,pc,leaf
-//@ [PAUTHLR] compile-flags: -C target-feature=+pauth-lr -Z branch-protection=pac-ret,pc,leaf
-
-#![feature(no_core, lang_items)]
-#![no_std]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-// PACRET: hint #25
-// PACRET: hint #29
-// PAUTHLR_NOP: hint #25
-// PAUTHLR_NOP: hint #39
-// PAUTHLR_NOP: hint #29
-// PAUTHLR: paciasppc
-// PAUTHLR: autiasppc
-#[no_mangle]
-pub fn test() -> u8 {
-    42
-}
diff --git a/tests/assembly/aarch64-xray.rs b/tests/assembly/aarch64-xray.rs
deleted file mode 100644
index d5ee0111843..00000000000
--- a/tests/assembly/aarch64-xray.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ assembly-output: emit-asm
-//@ compile-flags: -Zinstrument-xray=always
-
-//@ revisions: aarch64-linux
-//@[aarch64-linux] compile-flags: --target=aarch64-unknown-linux-gnu
-//@[aarch64-linux] needs-llvm-components: aarch64
-//@[aarch64-linux] only-aarch64-unknown-linux-gnu
-
-//@ revisions: aarch64-darwin
-//@[aarch64-darwin] compile-flags: --target=aarch64-apple-darwin
-//@[aarch64-darwin] needs-llvm-components: aarch64
-//@[aarch64-darwin] only-aarch64-apple-darwin
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: xray_func:
-#[no_mangle]
-pub fn xray_func() {
-    // CHECK: nop
-
-    std::hint::black_box(());
-
-    // CHECK: b #32
-    // CHECK-NEXT: nop
-}
diff --git a/tests/assembly/align_offset.rs b/tests/assembly/align_offset.rs
deleted file mode 100644
index d9902ce336b..00000000000
--- a/tests/assembly/align_offset.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=1
-//@ only-x86_64
-#![crate_type = "rlib"]
-
-// CHECK-LABEL: align_offset_byte_ptr
-// CHECK: leaq 31
-// CHECK: andq $-32
-// CHECK: subq
-#[no_mangle]
-pub fn align_offset_byte_ptr(ptr: *const u8) -> usize {
-    ptr.align_offset(32)
-}
-
-// CHECK-LABEL: align_offset_byte_slice
-// CHECK: leaq 31
-// CHECK: andq $-32
-// CHECK: subq
-#[no_mangle]
-pub fn align_offset_byte_slice(slice: &[u8]) -> usize {
-    slice.as_ptr().align_offset(32)
-}
-
-// CHECK-LABEL: align_offset_word_ptr
-// CHECK: leaq 31
-// CHECK: andq $-32
-// CHECK: subq
-// CHECK: shrq
-// This `ptr` is not known to be aligned, so it is required to check if it is at all possible to
-// align. LLVM applies a simple mask.
-// CHECK: orq
-#[no_mangle]
-pub fn align_offset_word_ptr(ptr: *const u32) -> usize {
-    ptr.align_offset(32)
-}
-
-// CHECK-LABEL: align_offset_word_slice
-// CHECK: leaq 31
-// CHECK: andq $-32
-// CHECK: subq
-// CHECK: shrq
-// `slice` is known to be aligned, so `!0` is not possible as a return
-// CHECK-NOT: orq
-#[no_mangle]
-pub fn align_offset_word_slice(slice: &[u32]) -> usize {
-    slice.as_ptr().align_offset(32)
-}
diff --git a/tests/assembly/asm/aarch64-el2vmsa.rs b/tests/assembly/asm/aarch64-el2vmsa.rs
deleted file mode 100644
index 3652d58d85a..00000000000
--- a/tests/assembly/asm/aarch64-el2vmsa.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target aarch64-unknown-linux-gnu
-//@ needs-llvm-components: aarch64
-
-#![feature(no_core)]
-#![crate_type = "rlib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: ttbr0_el2:
-#[no_mangle]
-pub fn ttbr0_el2() {
-    // CHECK: //APP
-    // CHECK-NEXT: msr TTBR0_EL2, x0
-    // CHECK-NEXT: //NO_APP
-    unsafe {
-        asm!("msr ttbr0_el2, x0");
-    }
-}
-
-// CHECK-LABEL: vttbr_el2:
-#[no_mangle]
-pub fn vttbr_el2() {
-    // CHECK: //APP
-    // CHECK-NEXT: msr VTTBR_EL2, x0
-    // CHECK-NEXT: //NO_APP
-    unsafe {
-        asm!("msr vttbr_el2, x0");
-    }
-}
diff --git a/tests/assembly/asm/aarch64-modifiers.rs b/tests/assembly/asm/aarch64-modifiers.rs
deleted file mode 100644
index 58f7c114d3a..00000000000
--- a/tests/assembly/asm/aarch64-modifiers.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3 -C panic=abort
-//@ compile-flags: --target aarch64-unknown-linux-gnu
-//@ compile-flags: -Zmerge-functions=disabled
-//@ needs-llvm-components: aarch64
-
-#![feature(no_core)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register)]
-
-extern crate minicore;
-use minicore::*;
-
-macro_rules! check {
-    ($func:ident $reg:ident $code:literal) => {
-        // -Copt-level=3 and extern "C" guarantee that the selected register is always r0/s0/d0/q0
-        #[no_mangle]
-        pub unsafe extern "C" fn $func() -> i32 {
-            let y;
-            asm!($code, out($reg) y);
-            y
-        }
-    };
-}
-
-// CHECK-LABEL: reg:
-// CHECK: //APP
-// CHECK: mov x0, x0
-// CHECK: //NO_APP
-check!(reg reg "mov {0}, {0}");
-
-// CHECK-LABEL: reg_w:
-// CHECK: //APP
-// CHECK: mov w0, w0
-// CHECK: //NO_APP
-check!(reg_w reg "mov {0:w}, {0:w}");
-
-// CHECK-LABEL: reg_x:
-// CHECK: //APP
-// CHECK: mov x0, x0
-// CHECK: //NO_APP
-check!(reg_x reg "mov {0:x}, {0:x}");
-
-// CHECK-LABEL: vreg:
-// CHECK: //APP
-// CHECK: add v0.4s, v0.4s, v0.4s
-// CHECK: //NO_APP
-check!(vreg vreg "add {0}.4s, {0}.4s, {0}.4s");
-
-// CHECK-LABEL: vreg_b:
-// CHECK: //APP
-// CHECK: ldr b0, [x0]
-// CHECK: //NO_APP
-check!(vreg_b vreg "ldr {:b}, [x0]");
-
-// CHECK-LABEL: vreg_h:
-// CHECK: //APP
-// CHECK: ldr h0, [x0]
-// CHECK: //NO_APP
-check!(vreg_h vreg "ldr {:h}, [x0]");
-
-// CHECK-LABEL: vreg_s:
-// CHECK: //APP
-// CHECK: ldr s0, [x0]
-// CHECK: //NO_APP
-check!(vreg_s vreg "ldr {:s}, [x0]");
-
-// CHECK-LABEL: vreg_d:
-// CHECK: //APP
-// CHECK: ldr d0, [x0]
-// CHECK: //NO_APP
-check!(vreg_d vreg "ldr {:d}, [x0]");
-
-// CHECK-LABEL: vreg_q:
-// CHECK: //APP
-// CHECK: ldr q0, [x0]
-// CHECK: //NO_APP
-check!(vreg_q vreg "ldr {:q}, [x0]");
-
-// CHECK-LABEL: vreg_v:
-// CHECK: //APP
-// CHECK: add v0.4s, v0.4s, v0.4s
-// CHECK: //NO_APP
-check!(vreg_v vreg "add {0:v}.4s, {0:v}.4s, {0:v}.4s");
-
-// CHECK-LABEL: vreg_low16:
-// CHECK: //APP
-// CHECK: add v0.4s, v0.4s, v0.4s
-// CHECK: //NO_APP
-check!(vreg_low16 vreg_low16 "add {0}.4s, {0}.4s, {0}.4s");
-
-// CHECK-LABEL: vreg_low16_b:
-// CHECK: //APP
-// CHECK: ldr b0, [x0]
-// CHECK: //NO_APP
-check!(vreg_low16_b vreg_low16 "ldr {:b}, [x0]");
-
-// CHECK-LABEL: vreg_low16_h:
-// CHECK: //APP
-// CHECK: ldr h0, [x0]
-// CHECK: //NO_APP
-check!(vreg_low16_h vreg_low16 "ldr {:h}, [x0]");
-
-// CHECK-LABEL: vreg_low16_s:
-// CHECK: //APP
-// CHECK: ldr s0, [x0]
-// CHECK: //NO_APP
-check!(vreg_low16_s vreg_low16 "ldr {:s}, [x0]");
-
-// CHECK-LABEL: vreg_low16_d:
-// CHECK: //APP
-// CHECK: ldr d0, [x0]
-// CHECK: //NO_APP
-check!(vreg_low16_d vreg_low16 "ldr {:d}, [x0]");
-
-// CHECK-LABEL: vreg_low16_q:
-// CHECK: //APP
-// CHECK: ldr q0, [x0]
-// CHECK: //NO_APP
-check!(vreg_low16_q vreg_low16 "ldr {:q}, [x0]");
-
-// CHECK-LABEL: vreg_low16_v:
-// CHECK: //APP
-// CHECK: add v0.4s, v0.4s, v0.4s
-// CHECK: //NO_APP
-check!(vreg_low16_v vreg_low16 "add {0:v}.4s, {0:v}.4s, {0:v}.4s");
diff --git a/tests/assembly/asm/aarch64-outline-atomics.rs b/tests/assembly/asm/aarch64-outline-atomics.rs
deleted file mode 100644
index 5990fb84942..00000000000
--- a/tests/assembly/asm/aarch64-outline-atomics.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3
-//@ compile-flags: --target aarch64-unknown-linux-gnu
-//@ needs-llvm-components: aarch64
-//@ only-aarch64
-//@ only-linux
-
-#![crate_type = "rlib"]
-
-use std::sync::atomic::AtomicI32;
-use std::sync::atomic::Ordering::*;
-
-pub fn compare_exchange(a: &AtomicI32) {
-    // On AArch64 LLVM should outline atomic operations.
-    // CHECK: __aarch64_cas4_relax
-    let _ = a.compare_exchange(0, 10, Relaxed, Relaxed);
-}
diff --git a/tests/assembly/asm/aarch64-types.rs b/tests/assembly/asm/aarch64-types.rs
deleted file mode 100644
index b7abeb02298..00000000000
--- a/tests/assembly/asm/aarch64-types.rs
+++ /dev/null
@@ -1,633 +0,0 @@
-//@ add-core-stubs
-//@ revisions: aarch64 arm64ec
-//@ assembly-output: emit-asm
-//@ [aarch64] compile-flags: --target aarch64-unknown-linux-gnu
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [arm64ec] compile-flags: --target arm64ec-pc-windows-msvc
-//@ [arm64ec] needs-llvm-components: aarch64
-//@ compile-flags: -Zmerge-functions=disabled
-
-#![feature(no_core, repr_simd, f16, f128)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register, non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *mut u8;
-
-#[repr(simd)]
-pub struct i8x8([i8; 8]);
-#[repr(simd)]
-pub struct i16x4([i16; 4]);
-#[repr(simd)]
-pub struct i32x2([i32; 2]);
-#[repr(simd)]
-pub struct i64x1([i64; 1]);
-#[repr(simd)]
-pub struct f16x4([f16; 4]);
-#[repr(simd)]
-pub struct f32x2([f32; 2]);
-#[repr(simd)]
-pub struct f64x1([f64; 1]);
-#[repr(simd)]
-pub struct i8x16([i8; 16]);
-#[repr(simd)]
-pub struct i16x8([i16; 8]);
-#[repr(simd)]
-pub struct i32x4([i32; 4]);
-#[repr(simd)]
-pub struct i64x2([i64; 2]);
-#[repr(simd)]
-pub struct f16x8([f16; 8]);
-#[repr(simd)]
-pub struct f32x4([f32; 4]);
-#[repr(simd)]
-pub struct f64x2([f64; 2]);
-
-impl Copy for i8x8 {}
-impl Copy for i16x4 {}
-impl Copy for i32x2 {}
-impl Copy for i64x1 {}
-impl Copy for f16x4 {}
-impl Copy for f32x2 {}
-impl Copy for f64x1 {}
-impl Copy for i8x16 {}
-impl Copy for i16x8 {}
-impl Copy for i32x4 {}
-impl Copy for i64x2 {}
-impl Copy for f16x8 {}
-impl Copy for f32x4 {}
-impl Copy for f64x2 {}
-
-extern "C" {
-    fn extern_func();
-    static extern_static: u8;
-}
-
-// CHECK-LABEL: {{("#)?}}sym_fn{{"?}}
-// CHECK: //APP
-// CHECK: bl extern_func
-// CHECK: //NO_APP
-#[no_mangle]
-pub unsafe fn sym_fn() {
-    asm!("bl {}", sym extern_func);
-}
-
-// CHECK-LABEL: {{("#)?}}sym_static{{"?}}
-// CHECK: //APP
-// CHECK: adr x0, extern_static
-// CHECK: //NO_APP
-#[no_mangle]
-pub unsafe fn sym_static() {
-    asm!("adr x0, {}", sym extern_static);
-}
-
-// Regression test for #75761
-// CHECK-LABEL: {{("#)?}}issue_75761{{"?}}
-// x29 holds the frame pointer, right next to x30, so ldp/stp happens sometimes
-// CHECK: st[[MAY_PAIR:(r|p).*]]x30
-// CHECK: //APP
-// CHECK: //NO_APP
-// CHECK: ld[[MAY_PAIR]]x30
-#[no_mangle]
-pub unsafe fn issue_75761() {
-    asm!("", out("v0") _, out("x30") _);
-}
-
-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.
-        // LLVM issue: <https://github.com/llvm/llvm-project/issues/94434>
-        #[no_mangle]
-        pub unsafe fn $func(inp: &$ty, out: &mut $ty) {
-            let x = *inp;
-            let y;
-            asm!(
-                concat!($mov, " {:", $modifier, "}, {:", $modifier, "}"),
-                out($class) y,
-                in($class) x
-            );
-            *out = y;
-        }
-    };
-}
-
-macro_rules! check_reg {
-    ($func:ident $ty:ident $reg:tt $mov:literal) => {
-        // FIXME(f16_f128): See FIXME in `check!`
-        #[no_mangle]
-        pub unsafe fn $func(inp: &$ty, out: &mut $ty) {
-            let x = *inp;
-            let y;
-            asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
-            *out = y;
-        }
-    };
-}
-
-// CHECK-LABEL: {{("#)?}}reg_i8{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check!(reg_i8 i8 reg "mov" "");
-
-// CHECK-LABEL: {{("#)?}}reg_i16{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check!(reg_i16 i16 reg "mov" "");
-
-// CHECK-LABEL: {{("#)?}}reg_f16{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check!(reg_f16 f16 reg "mov" "");
-
-// CHECK-LABEL: {{("#)?}}reg_i32{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check!(reg_i32 i32 reg "mov" "");
-
-// CHECK-LABEL: {{("#)?}}reg_f32{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check!(reg_f32 f32 reg "mov" "");
-
-// CHECK-LABEL: {{("#)?}}reg_i64{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check!(reg_i64 i64 reg "mov" "");
-
-// CHECK-LABEL: {{("#)?}}reg_f64{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check!(reg_f64 f64 reg "mov" "");
-
-// CHECK-LABEL: {{("#)?}}reg_ptr{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check!(reg_ptr ptr reg "mov" "");
-
-// CHECK-LABEL: {{("#)?}}vreg_i8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i8 i8 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_i16{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i16 i16 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_f16{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_f16 f16 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_i32{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i32 i32 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_f32{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_f32 f32 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_i64{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i64 i64 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_f64{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_f64 f64 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_f128{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_f128 f128 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_ptr{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_ptr ptr vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_i8x8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i8x8 i8x8 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_i16x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i16x4 i16x4 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_i32x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i32x2 i32x2 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_i64x1{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i64x1 i64x1 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_f16x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_f16x4 f16x4 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_f32x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_f32x2 f32x2 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_f64x1{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_f64x1 f64x1 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_i8x16{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i8x16 i8x16 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_i16x8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i16x8 i16x8 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_i32x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i32x4 i32x4 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_i64x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_i64x2 i64x2 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_f16x8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_f16x8 f16x8 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_f32x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_f32x4 f32x4 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_f64x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_f64x2 f64x2 vreg "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_i8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_i8 i8 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_i16{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_i16 i16 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_f16{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_f16 f16 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_f32{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_f32 f32 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_i64{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_i64 i64 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_f64{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_f64 f64 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_f128{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_f128 f128 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_ptr{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_ptr ptr vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_i8x8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_i8x8 i8x8 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_i16x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_i16x4 i16x4 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_i32x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_i32x2 i32x2 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_i64x1{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_i64x1 i64x1 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_f16x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_f16x4 f16x4 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_f32x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_f32x2 f32x2 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_f64x1{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_f64x1 f64x1 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_i8x16{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_i8x16 i8x16 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_i16x8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_i16x8 i16x8 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_i32x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_i32x4 i32x4 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_i64x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_i64x2 i64x2 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_f16x8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_f16x8 f16x8 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_f32x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_f32x4 f32x4 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}vreg_low16_f64x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: //NO_APP
-check!(vreg_low16_f64x2 f64x2 vreg_low16 "fmov" "s");
-
-// CHECK-LABEL: {{("#)?}}x0_i8{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check_reg!(x0_i8 i8 "x0" "mov");
-
-// CHECK-LABEL: {{("#)?}}x0_i16{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check_reg!(x0_i16 i16 "x0" "mov");
-
-// CHECK-LABEL: {{("#)?}}x0_f16{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check_reg!(x0_f16 f16 "x0" "mov");
-
-// CHECK-LABEL: {{("#)?}}x0_i32{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check_reg!(x0_i32 i32 "x0" "mov");
-
-// CHECK-LABEL: {{("#)?}}x0_f32{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check_reg!(x0_f32 f32 "x0" "mov");
-
-// CHECK-LABEL: {{("#)?}}x0_i64{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check_reg!(x0_i64 i64 "x0" "mov");
-
-// CHECK-LABEL: {{("#)?}}x0_f64{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check_reg!(x0_f64 f64 "x0" "mov");
-
-// CHECK-LABEL: {{("#)?}}x0_ptr{{"?}}
-// CHECK: //APP
-// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
-// CHECK: //NO_APP
-check_reg!(x0_ptr ptr "x0" "mov");
-
-// CHECK-LABEL: {{("#)?}}v0_i8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i8 i8 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_i16{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i16 i16 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_f16{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_f16 f16 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_i32{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i32 i32 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_f32{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_f32 f32 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_i64{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i64 i64 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_f64{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_f64 f64 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_f128{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_f128 f128 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_ptr{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_ptr ptr "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_i8x8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i8x8 i8x8 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_i16x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i16x4 i16x4 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_i32x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i32x2 i32x2 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_i64x1{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i64x1 i64x1 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_f16x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_f16x4 f16x4 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_f32x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_f32x2 f32x2 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_f64x1{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_f64x1 f64x1 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_i8x16{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i8x16 i8x16 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_i16x8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i16x8 i16x8 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_i32x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i32x4 i32x4 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_i64x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_i64x2 i64x2 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_f16x8{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_f16x8 f16x8 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_f32x4{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_f32x4 f32x4 "s0" "fmov");
-
-// CHECK-LABEL: {{("#)?}}v0_f64x2{{"?}}
-// CHECK: //APP
-// CHECK: fmov s0, s0
-// CHECK: //NO_APP
-check_reg!(v0_f64x2 f64x2 "s0" "fmov");
diff --git a/tests/assembly/asm/arm-modifiers.rs b/tests/assembly/asm/arm-modifiers.rs
deleted file mode 100644
index 32a36840492..00000000000
--- a/tests/assembly/asm/arm-modifiers.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3 -C panic=abort
-//@ compile-flags: --target armv7-unknown-linux-gnueabihf
-//@ compile-flags: -C target-feature=+neon
-//@ compile-flags: -Zmerge-functions=disabled
-//@ needs-llvm-components: arm
-
-#![feature(no_core, repr_simd)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register, non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(simd)]
-pub struct f32x4([f32; 4]);
-
-impl Copy for f32x4 {}
-
-macro_rules! check {
-    ($func:ident $modifier:literal $reg:ident $ty:ident $mov:literal) => {
-        // -Copt-level=3 and extern "C" guarantee that the selected register is always r0/s0/d0/q0
-        #[no_mangle]
-        pub unsafe extern "C" fn $func() -> $ty {
-            let y;
-            asm!(concat!($mov, " {0:", $modifier, "}, {0:", $modifier, "}"), out($reg) y);
-            y
-        }
-    };
-}
-
-// CHECK-LABEL: reg:
-// CHECK: @APP
-// CHECK: mov r0, r0
-// CHECK: @NO_APP
-check!(reg "" reg i32 "mov");
-
-// CHECK-LABEL: sreg:
-// CHECK: @APP
-// CHECK: vmov.f32 s0, s0
-// CHECK: @NO_APP
-check!(sreg "" sreg f32 "vmov.f32");
-
-// CHECK-LABEL: sreg_low16:
-// CHECK: @APP
-// CHECK: vmov.f32 s0, s0
-// CHECK: @NO_APP
-check!(sreg_low16 "" sreg_low16 f32 "vmov.f32");
-
-// CHECK-LABEL: dreg:
-// CHECK: @APP
-// CHECK: vmov.f64 d0, d0
-// CHECK: @NO_APP
-check!(dreg "" dreg f64 "vmov.f64");
-
-// CHECK-LABEL: dreg_low16:
-// CHECK: @APP
-// CHECK: vmov.f64 d0, d0
-// CHECK: @NO_APP
-check!(dreg_low16 "" dreg_low16 f64 "vmov.f64");
-
-// CHECK-LABEL: dreg_low8:
-// CHECK: @APP
-// CHECK: vmov.f64 d0, d0
-// CHECK: @NO_APP
-check!(dreg_low8 "" dreg_low8 f64 "vmov.f64");
-
-// CHECK-LABEL: qreg:
-// CHECK: @APP
-// CHECK: vorr q0, q0, q0
-// CHECK: @NO_APP
-check!(qreg "" qreg f32x4 "vmov");
-
-// CHECK-LABEL: qreg_e:
-// CHECK: @APP
-// CHECK: vmov.f64 d0, d0
-// CHECK: @NO_APP
-check!(qreg_e "e" qreg f32x4 "vmov.f64");
-
-// CHECK-LABEL: qreg_f:
-// CHECK: @APP
-// CHECK: vmov.f64 d1, d1
-// CHECK: @NO_APP
-check!(qreg_f "f" qreg f32x4 "vmov.f64");
-
-// CHECK-LABEL: qreg_low8:
-// CHECK: @APP
-// CHECK: vorr q0, q0, q0
-// CHECK: @NO_APP
-check!(qreg_low8 "" qreg_low8 f32x4 "vmov");
-
-// CHECK-LABEL: qreg_low8_e:
-// CHECK: @APP
-// CHECK: vmov.f64 d0, d0
-// CHECK: @NO_APP
-check!(qreg_low8_e "e" qreg_low8 f32x4 "vmov.f64");
-
-// CHECK-LABEL: qreg_low8_f:
-// CHECK: @APP
-// CHECK: vmov.f64 d1, d1
-// CHECK: @NO_APP
-check!(qreg_low8_f "f" qreg_low8 f32x4 "vmov.f64");
-
-// CHECK-LABEL: qreg_low4:
-// CHECK: @APP
-// CHECK: vorr q0, q0, q0
-// CHECK: @NO_APP
-check!(qreg_low4 "" qreg_low4 f32x4 "vmov");
-
-// CHECK-LABEL: qreg_low4_e:
-// CHECK: @APP
-// CHECK: vmov.f64 d0, d0
-// CHECK: @NO_APP
-check!(qreg_low4_e "e" qreg_low4 f32x4 "vmov.f64");
-
-// CHECK-LABEL: qreg_low4_f:
-// CHECK: @APP
-// CHECK: vmov.f64 d1, d1
-// CHECK: @NO_APP
-check!(qreg_low4_f "f" qreg_low4 f32x4 "vmov.f64");
diff --git a/tests/assembly/asm/arm-types.rs b/tests/assembly/asm/arm-types.rs
deleted file mode 100644
index fb93f474c20..00000000000
--- a/tests/assembly/asm/arm-types.rs
+++ /dev/null
@@ -1,639 +0,0 @@
-//@ add-core-stubs
-//@ revisions: base d32 neon
-//@ assembly-output: emit-asm
-//@ compile-flags: --target armv7-unknown-linux-gnueabihf
-//@ compile-flags: -C opt-level=0
-//@ compile-flags: -Zmerge-functions=disabled
-//@[d32] compile-flags: -C target-feature=+d32
-//@[neon] compile-flags: -C target-feature=+neon --cfg d32
-//@[neon] filecheck-flags: --check-prefix d32
-//@ needs-llvm-components: arm
-
-#![feature(no_core, repr_simd, f16)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register, non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *mut u8;
-
-#[repr(simd)]
-pub struct i8x8([i8; 8]);
-#[repr(simd)]
-pub struct i16x4([i16; 4]);
-#[repr(simd)]
-pub struct i32x2([i32; 2]);
-#[repr(simd)]
-pub struct i64x1([i64; 1]);
-#[repr(simd)]
-pub struct f16x4([f16; 4]);
-#[repr(simd)]
-pub struct f32x2([f32; 2]);
-#[repr(simd)]
-pub struct i8x16([i8; 16]);
-#[repr(simd)]
-pub struct i16x8([i16; 8]);
-#[repr(simd)]
-pub struct i32x4([i32; 4]);
-#[repr(simd)]
-pub struct i64x2([i64; 2]);
-#[repr(simd)]
-pub struct f16x8([f16; 8]);
-#[repr(simd)]
-pub struct f32x4([f32; 4]);
-
-impl Copy for i8x8 {}
-impl Copy for i16x4 {}
-impl Copy for i32x2 {}
-impl Copy for i64x1 {}
-impl Copy for f16x4 {}
-impl Copy for f32x2 {}
-impl Copy for i8x16 {}
-impl Copy for i16x8 {}
-impl Copy for i32x4 {}
-impl Copy for i64x2 {}
-impl Copy for f16x8 {}
-impl Copy for f32x4 {}
-
-extern "C" {
-    fn extern_func();
-    static extern_static: u8;
-}
-
-// CHECK-LABEL: sym_fn:
-// CHECK: @APP
-// CHECK: bl extern_func
-// CHECK: @NO_APP
-#[no_mangle]
-pub unsafe fn sym_fn() {
-    asm!("bl {}", sym extern_func);
-}
-
-// CHECK-LABEL: sym_static:
-// CHECK: @APP
-// CHECK: adr r0, extern_static
-// CHECK: @NO_APP
-#[no_mangle]
-pub unsafe fn sym_static() {
-    asm!("adr r0, {}", sym extern_static);
-}
-
-// Regression test for #82052.
-// CHECK-LABEL: issue_82052
-// CHECK: push {{.*}}lr
-// CHECK: @APP
-// CHECK: @NO_APP
-pub unsafe fn issue_82052() {
-    asm!("", out("r14") _);
-}
-
-macro_rules! check {
-    ($func:ident $ty:ident $class:ident $mov:literal) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!($mov, " {}, {}"), out($class) y, in($class) x);
-            y
-        }
-    };
-}
-
-macro_rules! check_reg {
-    ($func:ident $ty:ident $reg:tt $mov:literal) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
-            y
-        }
-    };
-}
-
-// CHECK-LABEL: reg_i8:
-// CHECK: @APP
-// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: @NO_APP
-check!(reg_i8 i8 reg "mov");
-
-// CHECK-LABEL: reg_i16:
-// CHECK: @APP
-// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: @NO_APP
-check!(reg_i16 i16 reg "mov");
-
-// CHECK-LABEL: reg_i32:
-// CHECK: @APP
-// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: @NO_APP
-check!(reg_i32 i32 reg "mov");
-
-// CHECK-LABEL: reg_f16:
-// CHECK: @APP
-// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: @NO_APP
-check!(reg_f16 f16 reg "mov");
-
-// CHECK-LABEL: reg_f32:
-// CHECK: @APP
-// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: @NO_APP
-check!(reg_f32 f32 reg "mov");
-
-// CHECK-LABEL: reg_ptr:
-// CHECK: @APP
-// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: @NO_APP
-check!(reg_ptr ptr reg "mov");
-
-// CHECK-LABEL: sreg_i32:
-// CHECK: @APP
-// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: @NO_APP
-check!(sreg_i32 i32 sreg "vmov.f32");
-
-// CHECK-LABEL: sreg_f16:
-// CHECK: @APP
-// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: @NO_APP
-check!(sreg_f16 f16 sreg "vmov.f32");
-
-// CHECK-LABEL: sreg_f32:
-// CHECK: @APP
-// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: @NO_APP
-check!(sreg_f32 f32 sreg "vmov.f32");
-
-// CHECK-LABEL: sreg_ptr:
-// CHECK: @APP
-// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: @NO_APP
-check!(sreg_ptr ptr sreg "vmov.f32");
-
-// CHECK-LABEL: sreg_low16_i32:
-// CHECK: @APP
-// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: @NO_APP
-check!(sreg_low16_i32 i32 sreg_low16 "vmov.f32");
-
-// CHECK-LABEL: sreg_low16_f16:
-// CHECK: @APP
-// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: @NO_APP
-check!(sreg_low16_f16 f16 sreg_low16 "vmov.f32");
-
-// CHECK-LABEL: sreg_low16_f32:
-// CHECK: @APP
-// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}}
-// CHECK: @NO_APP
-check!(sreg_low16_f32 f32 sreg_low16 "vmov.f32");
-
-// d32-LABEL: dreg_i64:
-// d32: @APP
-// d32: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// d32: @NO_APP
-#[cfg(d32)]
-check!(dreg_i64 i64 dreg "vmov.f64");
-
-// d32-LABEL: dreg_f64:
-// d32: @APP
-// d32: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// d32: @NO_APP
-#[cfg(d32)]
-check!(dreg_f64 f64 dreg "vmov.f64");
-
-// neon-LABEL: dreg_i8x8:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_i8x8 i8x8 dreg "vmov.f64");
-
-// neon-LABEL: dreg_i16x4:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_i16x4 i16x4 dreg "vmov.f64");
-
-// neon-LABEL: dreg_i32x2:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_i32x2 i32x2 dreg "vmov.f64");
-
-// neon-LABEL: dreg_i64x1:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_i64x1 i64x1 dreg "vmov.f64");
-
-// neon-LABEL: dreg_f16x4:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_f16x4 f16x4 dreg "vmov.f64");
-
-// neon-LABEL: dreg_f32x2:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_f32x2 f32x2 dreg "vmov.f64");
-
-// CHECK-LABEL: dreg_low16_i64:
-// CHECK: @APP
-// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// CHECK: @NO_APP
-check!(dreg_low16_i64 i64 dreg_low16 "vmov.f64");
-
-// CHECK-LABEL: dreg_low16_f64:
-// CHECK: @APP
-// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// CHECK: @NO_APP
-check!(dreg_low16_f64 f64 dreg_low16 "vmov.f64");
-
-// neon-LABEL: dreg_low16_i8x8:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low16_i8x8 i8x8 dreg_low16 "vmov.f64");
-
-// neon-LABEL: dreg_low16_i16x4:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low16_i16x4 i16x4 dreg_low16 "vmov.f64");
-
-// neon-LABEL: dreg_low16_i32x2:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low16_i32x2 i32x2 dreg_low16 "vmov.f64");
-
-// neon-LABEL: dreg_low16_i64x1:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low16_i64x1 i64x1 dreg_low16 "vmov.f64");
-
-// neon-LABEL: dreg_low16_f16x4:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low16_f16x4 f16x4 dreg_low16 "vmov.f64");
-
-// neon-LABEL: dreg_low16_f32x2:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low16_f32x2 f32x2 dreg_low16 "vmov.f64");
-
-// CHECK-LABEL: dreg_low8_i64:
-// CHECK: @APP
-// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// CHECK: @NO_APP
-check!(dreg_low8_i64 i64 dreg_low8 "vmov.f64");
-
-// CHECK-LABEL: dreg_low8_f64:
-// CHECK: @APP
-// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// CHECK: @NO_APP
-check!(dreg_low8_f64 f64 dreg_low8 "vmov.f64");
-
-// neon-LABEL: dreg_low8_i8x8:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low8_i8x8 i8x8 dreg_low8 "vmov.f64");
-
-// neon-LABEL: dreg_low8_i16x4:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low8_i16x4 i16x4 dreg_low8 "vmov.f64");
-
-// neon-LABEL: dreg_low8_i32x2:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low8_i32x2 i32x2 dreg_low8 "vmov.f64");
-
-// neon-LABEL: dreg_low8_i64x1:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low8_i64x1 i64x1 dreg_low8 "vmov.f64");
-
-// neon-LABEL: dreg_low8_f16x4:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low8_f16x4 f16x4 dreg_low8 "vmov.f64");
-
-// neon-LABEL: dreg_low8_f32x2:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(dreg_low8_f32x2 f32x2 dreg_low8 "vmov.f64");
-
-// neon-LABEL: qreg_i8x16:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_i8x16 i8x16 qreg "vmov");
-
-// neon-LABEL: qreg_i16x8:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_i16x8 i16x8 qreg "vmov");
-
-// neon-LABEL: qreg_i32x4:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_i32x4 i32x4 qreg "vmov");
-
-// neon-LABEL: qreg_i64x2:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_i64x2 i64x2 qreg "vmov");
-
-// neon-LABEL: qreg_f16x8:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_f16x8 f16x8 qreg "vmov");
-
-// neon-LABEL: qreg_f32x4:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_f32x4 f32x4 qreg "vmov");
-
-// neon-LABEL: qreg_low8_i8x16:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low8_i8x16 i8x16 qreg_low8 "vmov");
-
-// neon-LABEL: qreg_low8_i16x8:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low8_i16x8 i16x8 qreg_low8 "vmov");
-
-// neon-LABEL: qreg_low8_i32x4:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low8_i32x4 i32x4 qreg_low8 "vmov");
-
-// neon-LABEL: qreg_low8_i64x2:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low8_i64x2 i64x2 qreg_low8 "vmov");
-
-// neon-LABEL: qreg_low8_f16x8:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low8_f16x8 f16x8 qreg_low8 "vmov");
-
-// neon-LABEL: qreg_low8_f32x4:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low8_f32x4 f32x4 qreg_low8 "vmov");
-
-// neon-LABEL: qreg_low4_i8x16:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low4_i8x16 i8x16 qreg_low4 "vmov");
-
-// neon-LABEL: qreg_low4_i16x8:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low4_i16x8 i16x8 qreg_low4 "vmov");
-
-// neon-LABEL: qreg_low4_i32x4:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low4_i32x4 i32x4 qreg_low4 "vmov");
-
-// neon-LABEL: qreg_low4_i64x2:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low4_i64x2 i64x2 qreg_low4 "vmov");
-
-// neon-LABEL: qreg_low4_f16x8:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low4_f16x8 f16x8 qreg_low4 "vmov");
-
-// neon-LABEL: qreg_low4_f32x4:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(qreg_low4_f32x4 f32x4 qreg_low4 "vmov");
-
-// CHECK-LABEL: r0_i8:
-// CHECK: @APP
-// CHECK: mov r0, r0
-// CHECK: @NO_APP
-check_reg!(r0_i8 i8 "r0" "mov");
-
-// CHECK-LABEL: r0_i16:
-// CHECK: @APP
-// CHECK: mov r0, r0
-// CHECK: @NO_APP
-check_reg!(r0_i16 i16 "r0" "mov");
-
-// CHECK-LABEL: r0_i32:
-// CHECK: @APP
-// CHECK: mov r0, r0
-// CHECK: @NO_APP
-check_reg!(r0_i32 i32 "r0" "mov");
-
-// CHECK-LABEL: r0_f16:
-// CHECK: @APP
-// CHECK: mov r0, r0
-// CHECK: @NO_APP
-check_reg!(r0_f16 f16 "r0" "mov");
-
-// CHECK-LABEL: r0_f32:
-// CHECK: @APP
-// CHECK: mov r0, r0
-// CHECK: @NO_APP
-check_reg!(r0_f32 f32 "r0" "mov");
-
-// CHECK-LABEL: r0_ptr:
-// CHECK: @APP
-// CHECK: mov r0, r0
-// CHECK: @NO_APP
-check_reg!(r0_ptr ptr "r0" "mov");
-
-// CHECK-LABEL: s0_i32:
-// CHECK: @APP
-// CHECK: vmov.f32 s0, s0
-// CHECK: @NO_APP
-check_reg!(s0_i32 i32 "s0" "vmov.f32");
-
-// CHECK-LABEL: s0_f16:
-// CHECK: @APP
-// CHECK: vmov.f32 s0, s0
-// CHECK: @NO_APP
-check_reg!(s0_f16 f16 "s0" "vmov.f32");
-
-// CHECK-LABEL: s0_f32:
-// CHECK: @APP
-// CHECK: vmov.f32 s0, s0
-// CHECK: @NO_APP
-check_reg!(s0_f32 f32 "s0" "vmov.f32");
-
-// CHECK-LABEL: s0_ptr:
-// CHECK: @APP
-// CHECK: vmov.f32 s0, s0
-// CHECK: @NO_APP
-check_reg!(s0_ptr ptr "s0" "vmov.f32");
-
-// FIXME(#126797): "d0" should work with `i64` and `f64` even when `d32` is disabled.
-// d32-LABEL: d0_i64:
-// d32: @APP
-// d32: vmov.f64 d0, d0
-// d32: @NO_APP
-#[cfg(d32)]
-check_reg!(d0_i64 i64 "d0" "vmov.f64");
-
-// d32-LABEL: d0_f64:
-// d32: @APP
-// d32: vmov.f64 d0, d0
-// d32: @NO_APP
-#[cfg(d32)]
-check_reg!(d0_f64 f64 "d0" "vmov.f64");
-
-// neon-LABEL: d0_i8x8:
-// neon: @APP
-// neon: vmov.f64 d0, d0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(d0_i8x8 i8x8 "d0" "vmov.f64");
-
-// neon-LABEL: d0_i16x4:
-// neon: @APP
-// neon: vmov.f64 d0, d0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(d0_i16x4 i16x4 "d0" "vmov.f64");
-
-// neon-LABEL: d0_i32x2:
-// neon: @APP
-// neon: vmov.f64 d0, d0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(d0_i32x2 i32x2 "d0" "vmov.f64");
-
-// neon-LABEL: d0_i64x1:
-// neon: @APP
-// neon: vmov.f64 d0, d0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(d0_i64x1 i64x1 "d0" "vmov.f64");
-
-// neon-LABEL: d0_f16x4:
-// neon: @APP
-// neon: vmov.f64 d0, d0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(d0_f16x4 f16x4 "d0" "vmov.f64");
-
-// neon-LABEL: d0_f32x2:
-// neon: @APP
-// neon: vmov.f64 d0, d0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(d0_f32x2 f32x2 "d0" "vmov.f64");
-
-// neon-LABEL: q0_i8x16:
-// neon: @APP
-// neon: vorr q0, q0, q0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(q0_i8x16 i8x16 "q0" "vmov");
-
-// neon-LABEL: q0_i16x8:
-// neon: @APP
-// neon: vorr q0, q0, q0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(q0_i16x8 i16x8 "q0" "vmov");
-
-// neon-LABEL: q0_i32x4:
-// neon: @APP
-// neon: vorr q0, q0, q0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(q0_i32x4 i32x4 "q0" "vmov");
-
-// neon-LABEL: q0_i64x2:
-// neon: @APP
-// neon: vorr q0, q0, q0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(q0_i64x2 i64x2 "q0" "vmov");
-
-// neon-LABEL: q0_f16x8:
-// neon: @APP
-// neon: vorr q0, q0, q0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(q0_f16x8 f16x8 "q0" "vmov");
-
-// neon-LABEL: q0_f32x4:
-// neon: @APP
-// neon: vorr q0, q0, q0
-// neon: @NO_APP
-#[cfg(neon)]
-check_reg!(q0_f32x4 f32x4 "q0" "vmov");
diff --git a/tests/assembly/asm/avr-modifiers.rs b/tests/assembly/asm/avr-modifiers.rs
deleted file mode 100644
index 124cad9bef6..00000000000
--- a/tests/assembly/asm/avr-modifiers.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target avr-none -C target-cpu=atmega328p
-//@ needs-llvm-components: avr
-
-#![feature(no_core, asm_experimental_arch)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *const u64;
-
-macro_rules! check {
-    ($func:ident $hi:literal $lo:literal $reg:tt) => {
-        #[no_mangle]
-        unsafe fn $func() -> i16 {
-            let y;
-            asm!(concat!("mov {0:", $hi, "}, {0:", $lo, "}"), out($reg) y);
-            y
-        }
-    };
-}
-
-// CHECK-LABEL: reg_pair_modifiers:
-// CHECK: ;APP
-// CHECK: mov r{{[1-9]?[13579]}}, r{{[1-9]?[24680]}}
-// CHECK: ;NO_APP
-check!(reg_pair_modifiers "h" "l" reg_pair);
-
-// CHECK-LABEL: reg_iw_modifiers:
-// CHECK: ;APP
-// CHECK: mov r{{[1-9]?[13579]}}, r{{[1-9]?[24680]}}
-// CHECK: ;NO_APP
-check!(reg_iw_modifiers "h" "l" reg_iw);
-
-// CHECK-LABEL: reg_ptr_modifiers:
-// CHECK: ;APP
-// CHECK: mov r{{[1-9]?[13579]}}, r{{[1-9]?[24680]}}
-// CHECK: ;NO_APP
-check!(reg_ptr_modifiers "h" "l" reg_ptr);
diff --git a/tests/assembly/asm/avr-types.rs b/tests/assembly/asm/avr-types.rs
deleted file mode 100644
index 309405f4d51..00000000000
--- a/tests/assembly/asm/avr-types.rs
+++ /dev/null
@@ -1,205 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target avr-none -C target-cpu=atmega328p
-//@ needs-llvm-components: avr
-
-#![feature(no_core, asm_experimental_arch)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *const u64;
-
-macro_rules! check {
-    ($func:ident $ty:ident $class:ident) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!("mov {}, {}", lateout($class) y, in($class) x);
-            y
-        }
-    };
-}
-
-macro_rules! checkw {
-    ($func:ident $ty:ident $class:ident) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!("movw {}, {}", lateout($class) y, in($class) x);
-            y
-        }
-    };
-}
-
-macro_rules! check_reg {
-    ($func:ident $ty:ident $reg:tt) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!("mov ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
-            y
-        }
-    };
-}
-
-macro_rules! check_regw {
-    ($func:ident $ty:ident $reg:tt $reg_lit:tt) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!("movw ", $reg_lit, ", ", $reg_lit), lateout($reg) y, in($reg) x);
-            y
-        }
-    };
-}
-
-extern "C" {
-    fn extern_func();
-    static extern_static: i8;
-}
-
-// CHECK-LABEL: sym_fn
-// CHECK: ;APP
-// CHECK: call extern_func
-// CHECK: ;NO_APP
-#[no_mangle]
-pub unsafe fn sym_fn() {
-    asm!("call {}", sym extern_func);
-}
-
-// CHECK-LABEL: sym_static
-// CHECK: ;APP
-// CHECK: lds r{{[0-9]+}}, extern_static
-// CHECK: ;NO_APP
-#[no_mangle]
-pub unsafe fn sym_static() -> i8 {
-    let y;
-    asm!("lds {}, {}", lateout(reg) y, sym extern_static);
-    y
-}
-
-// CHECK-LABEL: ld_z:
-// CHECK: ;APP
-// CHECK: ld r{{[0-9]+}}, Z
-// CHECK: ;NO_APP
-#[no_mangle]
-pub unsafe fn ld_z(x: i16) -> i8 {
-    let y;
-    asm!("ld {}, Z", out(reg) y, in("Z") x);
-    y
-}
-
-// CHECK-LABEL: ldd_z:
-// CHECK: ;APP
-// CHECK: ldd r{{[0-9]+}}, Z+4
-// CHECK: ;NO_APP
-#[no_mangle]
-pub unsafe fn ldd_z(x: i16) -> i8 {
-    let y;
-    asm!("ldd {}, Z+4", out(reg) y, in("Z") x);
-    y
-}
-
-// CHECK-LABEL: ld_predecrement:
-// CHECK: ;APP
-// CHECK: ld r{{[0-9]+}}, -Z
-// CHECK: ;NO_APP
-#[no_mangle]
-pub unsafe fn ld_predecrement(x: i16) -> i8 {
-    let y;
-    asm!("ld {}, -Z", out(reg) y, in("Z") x);
-    y
-}
-
-// CHECK-LABEL: ld_postincrement:
-// CHECK: ;APP
-// CHECK: ld r{{[0-9]+}}, Z+
-// CHECK: ;NO_APP
-#[no_mangle]
-pub unsafe fn ld_postincrement(x: i16) -> i8 {
-    let y;
-    asm!("ld {}, Z+", out(reg) y, in("Z") x);
-    y
-}
-
-// CHECK-LABEL: muls_clobber:
-// CHECK: ;APP
-// CHECK: muls r{{[0-9]+}}, r{{[0-9]+}}
-// CHECK: movw r{{[0-9]+}}, r0
-// CHECK: ;NO_APP
-#[no_mangle]
-pub unsafe fn muls_clobber(x: i8, y: i8) -> i16 {
-    let z;
-    asm!(
-        "muls {}, {}",
-        "movw {}, r1:r0",
-        out(reg_iw) z,
-        in(reg) x,
-        in(reg) y,
-    );
-    z
-}
-
-// CHECK-LABEL: reg_i8:
-// CHECK: ;APP
-// CHECK: mov r{{[0-9]+}}, r{{[0-9]+}}
-// CHECK: ;NO_APP
-check!(reg_i8 i8 reg);
-
-// CHECK-LABEL: reg_upper_i8:
-// CHECK: ;APP
-// CHECK: mov r{{[1-3][0-9]}}, r{{[1-3][0-9]}}
-// CHECK: ;NO_APP
-check!(reg_upper_i8 i8 reg_upper);
-
-// CHECK-LABEL: reg_pair_i16:
-// CHECK: ;APP
-// CHECK: movw r{{[0-9]+}}, r{{[0-9]+}}
-// CHECK: ;NO_APP
-checkw!(reg_pair_i16 i16 reg_pair);
-
-// CHECK-LABEL: reg_iw_i16:
-// CHECK: ;APP
-// CHECK: movw r{{[0-9]+}}, r{{[0-9]+}}
-// CHECK: ;NO_APP
-checkw!(reg_iw_i16 i16 reg_iw);
-
-// CHECK-LABEL: reg_ptr_i16:
-// CHECK: ;APP
-// CHECK: movw r{{[0-9]+}}, r{{[0-9]+}}
-// CHECK: ;NO_APP
-checkw!(reg_ptr_i16 i16 reg_ptr);
-
-// CHECK-LABEL: r2_i8:
-// CHECK: ;APP
-// CHECK: mov r2, r2
-// CHECK: ;NO_APP
-check_reg!(r2_i8 i8 "r2");
-
-// CHECK-LABEL: xl_i8:
-// CHECK: ;APP
-// CHECK: mov r26, r26
-// CHECK: ;NO_APP
-check_reg!(xl_i8 i8 "XL");
-
-// CHECK-LABEL: xh_i8:
-// CHECK: ;APP
-// CHECK: mov r27, r27
-// CHECK: ;NO_APP
-check_reg!(xh_i8 i8 "XH");
-
-// CHECK-LABEL: x_i16:
-// CHECK: ;APP
-// CHECK: movw r26, r26
-// CHECK: ;NO_APP
-check_regw!(x_i16 i16 "X" "X");
-
-// CHECK-LABEL: r25r24_i16:
-// CHECK: ;APP
-// CHECK: movw r24, r24
-// CHECK: ;NO_APP
-check_regw!(r25r24_i16 i16 "r25r24" "r24");
diff --git a/tests/assembly/asm/bpf-types.rs b/tests/assembly/asm/bpf-types.rs
deleted file mode 100644
index 07ea7bd5ce0..00000000000
--- a/tests/assembly/asm/bpf-types.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target bpfel-unknown-none -C target_feature=+alu32
-//@ needs-llvm-components: bpf
-
-#![feature(no_core, asm_experimental_arch)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register, non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *const u64;
-
-macro_rules! check {
-    ($func:ident $ty:ident $class:ident) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!("{} = {}", out($class) y, in($class) x);
-            y
-        }
-    };
-}
-
-macro_rules! check_reg {
-    ($func:ident $ty:ident $reg:tt) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!($reg, " = ", $reg), lateout($reg) y, in($reg) x);
-            y
-        }
-    };
-}
-
-extern "C" {
-    fn extern_func();
-}
-
-// CHECK-LABEL: sym_fn
-// CHECK: #APP
-// CHECK: call extern_func
-// CHECK: #NO_APP
-#[no_mangle]
-pub unsafe fn sym_fn() {
-    asm!("call {}", sym extern_func);
-}
-
-// CHECK-LABEL: reg_i8:
-// CHECK: #APP
-// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i8 i8 reg);
-
-// CHECK-LABEL: reg_i16:
-// CHECK: #APP
-// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i16 i16 reg);
-
-// CHECK-LABEL: reg_i32:
-// CHECK: #APP
-// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i32 i32 reg);
-
-// CHECK-LABEL: reg_i64:
-// CHECK: #APP
-// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i64 i64 reg);
-
-// CHECK-LABEL: wreg_i8:
-// CHECK: #APP
-// CHECK: w{{[0-9]+}} = w{{[0-9]+}}
-// CHECK: #NO_APP
-check!(wreg_i8 i8 wreg);
-
-// CHECK-LABEL: wreg_i16:
-// CHECK: #APP
-// CHECK: w{{[0-9]+}} = w{{[0-9]+}}
-// CHECK: #NO_APP
-check!(wreg_i16 i16 wreg);
-
-// CHECK-LABEL: wreg_i32:
-// CHECK: #APP
-// CHECK: w{{[0-9]+}} = w{{[0-9]+}}
-// CHECK: #NO_APP
-check!(wreg_i32 i32 wreg);
-
-// CHECK-LABEL: r0_i8:
-// CHECK: #APP
-// CHECK: r0 = r0
-// CHECK: #NO_APP
-check_reg!(r0_i8 i8 "r0");
-
-// CHECK-LABEL: r0_i16:
-// CHECK: #APP
-// CHECK: r0 = r0
-// CHECK: #NO_APP
-check_reg!(r0_i16 i16 "r0");
-
-// CHECK-LABEL: r0_i32:
-// CHECK: #APP
-// CHECK: r0 = r0
-// CHECK: #NO_APP
-check_reg!(r0_i32 i32 "r0");
-
-// CHECK-LABEL: r0_i64:
-// CHECK: #APP
-// CHECK: r0 = r0
-// CHECK: #NO_APP
-check_reg!(r0_i64 i64 "r0");
-
-// CHECK-LABEL: w0_i8:
-// CHECK: #APP
-// CHECK: w0 = w0
-// CHECK: #NO_APP
-check_reg!(w0_i8 i8 "w0");
-
-// CHECK-LABEL: w0_i16:
-// CHECK: #APP
-// CHECK: w0 = w0
-// CHECK: #NO_APP
-check_reg!(w0_i16 i16 "w0");
-
-// CHECK-LABEL: w0_i32:
-// CHECK: #APP
-// CHECK: w0 = w0
-// CHECK: #NO_APP
-check_reg!(w0_i32 i32 "w0");
diff --git a/tests/assembly/asm/comments.rs b/tests/assembly/asm/comments.rs
deleted file mode 100644
index 557009975dd..00000000000
--- a/tests/assembly/asm/comments.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ assembly-output: emit-asm
-//@ only-x86_64
-// Check that comments in assembly get passed
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: test_comments:
-#[no_mangle]
-pub fn test_comments() {
-    // CHECK: example comment
-    unsafe { core::arch::asm!("nop // example comment") };
-}
diff --git a/tests/assembly/asm/global_asm.rs b/tests/assembly/asm/global_asm.rs
deleted file mode 100644
index 8a4bf98c745..00000000000
--- a/tests/assembly/asm/global_asm.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ only-x86_64
-//@ only-linux
-//@ assembly-output: emit-asm
-//@ compile-flags: -C llvm-args=--x86-asm-syntax=intel
-//@ compile-flags: -C symbol-mangling-version=v0
-
-#![crate_type = "rlib"]
-
-use std::arch::global_asm;
-
-#[no_mangle]
-fn my_func() {}
-
-#[no_mangle]
-static MY_STATIC: i32 = 0;
-
-// CHECK: mov eax, eax
-global_asm!("mov eax, eax");
-// CHECK: mov ebx, 5
-global_asm!("mov ebx, {}", const 5);
-// CHECK: mov ecx, 5
-global_asm!("movl ${}, %ecx", const 5, options(att_syntax));
-// CHECK: call my_func
-global_asm!("call {}", sym my_func);
-// CHECK: lea rax, [rip + MY_STATIC]
-global_asm!("lea rax, [rip + {}]", sym MY_STATIC);
-// CHECK: call _RNvC[[CRATE_IDENT:[a-zA-Z0-9]{12}]]_10global_asm6foobar
-global_asm!("call {}", sym foobar);
-// CHECK: _RNvC[[CRATE_IDENT]]_10global_asm6foobar:
-fn foobar() {
-    loop {}
-}
diff --git a/tests/assembly/asm/hexagon-types.rs b/tests/assembly/asm/hexagon-types.rs
deleted file mode 100644
index ce80fa75b35..00000000000
--- a/tests/assembly/asm/hexagon-types.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target hexagon-unknown-linux-musl
-//@ compile-flags: -Zmerge-functions=disabled
-//@ needs-llvm-components: hexagon
-
-#![feature(no_core, asm_experimental_arch)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register, non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *const i32;
-
-extern "C" {
-    fn extern_func();
-    static extern_static: u8;
-}
-
-macro_rules! check {
-    ($func:ident $ty:ident $class:ident) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!("{} = {}", out($class) y, in($class) x);
-            y
-        }
-    };
-}
-
-macro_rules! check_reg {
-    ($func:ident $ty:ident $reg:tt) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!($reg, " = ", $reg), lateout($reg) y, in($reg) x);
-            y
-        }
-    };
-}
-
-// CHECK-LABEL: sym_static:
-// CHECK: InlineAsm Start
-// CHECK: r0 = {{#+}}extern_static
-// CHECK: InlineAsm End
-#[no_mangle]
-pub unsafe fn sym_static() {
-    asm!("r0 = #{}", sym extern_static);
-}
-
-// CHECK-LABEL: sym_fn:
-// CHECK: InlineAsm Start
-// CHECK: r0 = {{#+}}extern_func
-// CHECK: InlineAsm End
-#[no_mangle]
-pub unsafe fn sym_fn() {
-    asm!("r0 = #{}", sym extern_func);
-}
-
-// This is a test for multi-instruction packets,
-// which require the escaped braces.
-//
-// CHECK-LABEL: packet:
-// CHECK: InlineAsm Start
-// CHECK: {
-// CHECK:   r{{[0-9]+}} = r0
-// CHECK:   memw(r1{{(\+#0)?}}) = r{{[0-9]+}}
-// CHECK: }
-// CHECK: InlineAsm End
-#[no_mangle]
-pub unsafe fn packet() {
-    let val = 1024;
-    asm!("{{
-        {} = r0
-        memw(r1) = {}
-    }}", out(reg) _, in(reg) &val);
-}
-
-// CHECK-LABEL: reg_ptr:
-// CHECK: InlineAsm Start
-// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
-// CHECK: InlineAsm End
-check!(reg_ptr ptr reg);
-
-// CHECK-LABEL: reg_f32:
-// CHECK: InlineAsm Start
-// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
-// CHECK: InlineAsm End
-check!(reg_f32 f32 reg);
-
-// CHECK-LABEL: reg_i32:
-// CHECK: InlineAsm Start
-// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
-// CHECK: InlineAsm End
-check!(reg_i32 i32 reg);
-
-// CHECK-LABEL: reg_i8:
-// CHECK: InlineAsm Start
-// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
-// CHECK: InlineAsm End
-check!(reg_i8 i8 reg);
-
-// CHECK-LABEL: reg_i16:
-// CHECK: InlineAsm Start
-// CHECK: r{{[0-9]+}} = r{{[0-9]+}}
-// CHECK: InlineAsm End
-check!(reg_i16 i16 reg);
-
-// CHECK-LABEL: r0_ptr:
-// CHECK: InlineAsm Start
-// CHECK: r0 = r0
-// CHECK: InlineAsm End
-check_reg!(r0_ptr ptr "r0");
-
-// CHECK-LABEL: r0_f32:
-// CHECK: InlineAsm Start
-// CHECK: r0 = r0
-// CHECK: InlineAsm End
-check_reg!(r0_f32 f32 "r0");
-
-// CHECK-LABEL: r0_i32:
-// CHECK: InlineAsm Start
-// CHECK: r0 = r0
-// CHECK: InlineAsm End
-check_reg!(r0_i32 i32 "r0");
-
-// CHECK-LABEL: r0_i8:
-// CHECK: InlineAsm Start
-// CHECK: r0 = r0
-// CHECK: InlineAsm End
-check_reg!(r0_i8 i8 "r0");
-
-// CHECK-LABEL: r0_i16:
-// CHECK: InlineAsm Start
-// CHECK: r0 = r0
-// CHECK: InlineAsm End
-check_reg!(r0_i16 i16 "r0");
diff --git a/tests/assembly/asm/inline-asm-avx.rs b/tests/assembly/asm/inline-asm-avx.rs
deleted file mode 100644
index 630acbb971a..00000000000
--- a/tests/assembly/asm/inline-asm-avx.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib
-//@ only-x86_64
-//@ ignore-sgx
-
-#![feature(portable_simd)]
-
-use std::arch::asm;
-use std::simd::Simd;
-
-#[target_feature(enable = "avx")]
-#[no_mangle]
-// CHECK-LABEL: convert:
-pub unsafe fn convert(a: *const f32) -> Simd<f32, 8> {
-    // CHECK: vbroadcastss (%{{[er][a-ds0-9][xpi0-9]?}}), {{%ymm[0-7]}}
-    let b: Simd<f32, 8>;
-    unsafe {
-        asm!(
-            "vbroadcastss {b}, [{a}]",
-            a = in(reg) a,
-            b = out(ymm_reg) b,
-        );
-    }
-    b
-}
diff --git a/tests/assembly/asm/loongarch-type.rs b/tests/assembly/asm/loongarch-type.rs
deleted file mode 100644
index c782be19f1d..00000000000
--- a/tests/assembly/asm/loongarch-type.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target loongarch64-unknown-linux-gnu
-//@ compile-flags: -Zmerge-functions=disabled
-//@ needs-llvm-components: loongarch
-
-#![feature(no_core, f16)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register, non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *const i32;
-
-extern "C" {
-    fn extern_func();
-    static extern_static: u8;
-}
-
-// CHECK-LABEL: sym_fn:
-// CHECK: #APP
-// CHECK: pcalau12i $t0, %got_pc_hi20(extern_func)
-// CHECK: ld.d $t0, $t0, %got_pc_lo12(extern_func)
-// CHECK: #NO_APP
-#[no_mangle]
-pub unsafe fn sym_fn() {
-    asm!("la.got $r12, {}", sym extern_func);
-}
-
-// CHECK-LABEL: sym_static:
-// CHECK: #APP
-// CHECK: pcalau12i $t0, %got_pc_hi20(extern_static)
-// CHECK: ld.d $t0, $t0, %got_pc_lo12(extern_static)
-// CHECK: #NO_APP
-#[no_mangle]
-pub unsafe fn sym_static() {
-    asm!("la.got $r12, {}", sym extern_static);
-}
-
-macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
-    #[no_mangle]
-    pub unsafe fn $func(x: $ty) -> $ty {
-        let y;
-        asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
-        y
-    }
-};}
-
-macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => {
-    #[no_mangle]
-    pub unsafe fn $func(x: $ty) -> $ty {
-        let y;
-        asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
-        y
-    }
-};}
-
-// CHECK-LABEL: reg_i8:
-// CHECK: #APP
-// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i8, i8, reg, "move");
-
-// CHECK-LABEL: reg_i16:
-// CHECK: #APP
-// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i16, i16, reg, "move");
-
-// CHECK-LABEL: reg_f16:
-// CHECK: #APP
-// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f16, f16, reg, "move");
-
-// CHECK-LABEL: reg_i32:
-// CHECK: #APP
-// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i32, i32, reg, "move");
-
-// CHECK-LABEL: reg_f32:
-// CHECK: #APP
-// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f32, f32, reg, "move");
-
-// CHECK-LABEL: reg_i64:
-// CHECK: #APP
-// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i64, i64, reg, "move");
-
-// CHECK-LABEL: reg_f64:
-// CHECK: #APP
-// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f64, f64, reg, "move");
-
-// CHECK-LABEL: reg_ptr:
-// CHECK: #APP
-// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_ptr, ptr, reg, "move");
-
-// CHECK-LABEL: freg_f16:
-// CHECK: #APP
-// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(freg_f16, f16, freg, "fmov.s");
-
-// CHECK-LABEL: freg_f32:
-// CHECK: #APP
-// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(freg_f32, f32, freg, "fmov.s");
-
-// CHECK-LABEL: freg_f64:
-// CHECK: #APP
-// CHECK: fmov.d $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(freg_f64, f64, freg, "fmov.d");
-
-// CHECK-LABEL: r4_i8:
-// CHECK: #APP
-// CHECK: move $a0, $a0
-// CHECK: #NO_APP
-check_reg!(r4_i8, i8, "$r4", "move");
-
-// CHECK-LABEL: r4_i16:
-// CHECK: #APP
-// CHECK: move $a0, $a0
-// CHECK: #NO_APP
-check_reg!(r4_i16, i16, "$r4", "move");
-
-// CHECK-LABEL: r4_f16:
-// CHECK: #APP
-// CHECK: move $a0, $a0
-// CHECK: #NO_APP
-check_reg!(r4_f16, f16, "$r4", "move");
-
-// CHECK-LABEL: r4_i32:
-// CHECK: #APP
-// CHECK: move $a0, $a0
-// CHECK: #NO_APP
-check_reg!(r4_i32, i32, "$r4", "move");
-
-// CHECK-LABEL: r4_f32:
-// CHECK: #APP
-// CHECK: move $a0, $a0
-// CHECK: #NO_APP
-check_reg!(r4_f32, f32, "$r4", "move");
-
-// CHECK-LABEL: r4_i64:
-// CHECK: #APP
-// CHECK: move $a0, $a0
-// CHECK: #NO_APP
-check_reg!(r4_i64, i64, "$r4", "move");
-
-// CHECK-LABEL: r4_f64:
-// CHECK: #APP
-// CHECK: move $a0, $a0
-// CHECK: #NO_APP
-check_reg!(r4_f64, f64, "$r4", "move");
-
-// CHECK-LABEL: r4_ptr:
-// CHECK: #APP
-// CHECK: move $a0, $a0
-// CHECK: #NO_APP
-check_reg!(r4_ptr, ptr, "$r4", "move");
-
-// CHECK-LABEL: f0_f16:
-// CHECK: #APP
-// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check_reg!(f0_f16, f16, "$f0", "fmov.s");
-
-// CHECK-LABEL: f0_f32:
-// CHECK: #APP
-// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check_reg!(f0_f32, f32, "$f0", "fmov.s");
-
-// CHECK-LABEL: f0_f64:
-// CHECK: #APP
-// CHECK: fmov.d $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check_reg!(f0_f64, f64, "$f0", "fmov.d");
diff --git a/tests/assembly/asm/m68k-types.rs b/tests/assembly/asm/m68k-types.rs
deleted file mode 100644
index 9e4f6d9a1a9..00000000000
--- a/tests/assembly/asm/m68k-types.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target m68k-unknown-linux-gnu
-//@ needs-llvm-components: m68k
-
-#![feature(no_core, asm_experimental_arch)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *const u64;
-
-macro_rules! check {
-    ($func:ident $ty:ident $class:ident $mov:literal) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!($mov, " {}, {};"), out($class) y, in($class) x);
-            y
-        }
-    };
-}
-
-// CHECK-LABEL: reg_data_i8:
-// CHECK: ;APP
-// CHECK: move.b %d{{[0-9]}}, %d{{[0-9]}}
-// CHECK: ;NO_APP
-check!(reg_data_i8 i8 reg_data "move.b");
-
-// CHECK-LABEL: reg_data_i16:
-// CHECK: ;APP
-// CHECK: move.w %d{{[0-9]}}, %d{{[0-9]}}
-// CHECK: ;NO_APP
-check!(reg_data_i16 i16 reg_data "move.w");
-
-// CHECK-LABEL: reg_data_i32:
-// CHECK: ;APP
-// CHECK: move.l %d{{[0-9]}}, %d{{[0-9]}}
-// CHECK: ;NO_APP
-check!(reg_data_i32 i32 reg_data "move.l");
-
-// CHECK-LABEL: reg_addr_i16:
-// CHECK: ;APP
-// CHECK: move.w %a{{[0-9]}}, %a{{[0-9]}}
-// CHECK: ;NO_APP
-check!(reg_addr_i16 i16 reg_addr "move.w");
-
-// CHECK-LABEL: reg_addr_i32:
-// CHECK: ;APP
-// CHECK: move.l %a{{[0-9]}}, %a{{[0-9]}}
-// CHECK: ;NO_APP
-check!(reg_addr_i32 i32 reg_addr "move.l");
-
-// CHECK-LABEL: reg_i16:
-// CHECK: ;APP
-// CHECK: move.w %{{[da][0-9]}}, %{{[da][0-9]}}
-// CHECK: ;NO_APP
-check!(reg_i16 i16 reg "move.w");
-
-// CHECK-LABEL: reg_i32:
-// CHECK: ;APP
-// CHECK: move.l %{{[da][0-9]}}, %{{[da][0-9]}}
-// CHECK: ;NO_APP
-check!(reg_i32 i32 reg "move.l");
diff --git a/tests/assembly/asm/mips-types.rs b/tests/assembly/asm/mips-types.rs
deleted file mode 100644
index 00e8ce0b874..00000000000
--- a/tests/assembly/asm/mips-types.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-//@ add-core-stubs
-//@ revisions: mips32 mips64
-//@ assembly-output: emit-asm
-//@[mips32] compile-flags: --target mips-unknown-linux-gnu
-//@[mips32] needs-llvm-components: mips
-//@[mips64] compile-flags: --target mips64-unknown-linux-gnuabi64
-//@[mips64] needs-llvm-components: mips
-//@ compile-flags: -Zmerge-functions=disabled
-
-#![feature(no_core, asm_experimental_arch)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register, non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *const i32;
-
-extern "C" {
-    fn extern_func();
-    static extern_static: u8;
-}
-
-macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
-    #[no_mangle]
-    pub unsafe fn $func(x: $ty) -> $ty {
-        let y;
-        asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
-        y
-    }
-};}
-
-macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => {
-    #[no_mangle]
-    pub unsafe fn $func(x: $ty) -> $ty {
-        let y;
-        asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
-        y
-    }
-};}
-
-// mips32-LABEL: sym_static_32:
-// mips32: #APP
-// mips32: lw $3, %got(extern_static)($gp)
-// mips32: #NO_APP
-#[cfg(mips32)]
-#[no_mangle]
-pub unsafe fn sym_static_32() {
-    asm!("lw $v1, {}", sym extern_static);
-}
-
-// mips32-LABEL: sym_fn_32:
-// mips32: #APP
-// mips32: lw $3, %got(extern_func)($gp)
-// mips32: #NO_APP
-#[cfg(mips32)]
-#[no_mangle]
-pub unsafe fn sym_fn_32() {
-    asm!("lw $v1, {}", sym extern_func);
-}
-
-// mips64-LABEL: sym_static_64:
-// mips64: #APP
-// mips64: lui    $3, %got_hi(extern_static)
-// mips64: daddu  $3, $3, $gp
-// mips64: ld     $3, %got_lo(extern_static)($3)
-// mips64: #NO_APP
-#[cfg(mips64)]
-#[no_mangle]
-pub unsafe fn sym_static_64() {
-    asm!("ld $v1, {}", sym extern_static);
-}
-
-// mips64-LABEL: sym_fn_64:
-// mips64: #APP
-// mips64: lui    $3, %got_hi(extern_func)
-// mips64: daddu  $3, $3, $gp
-// mips64: ld     $3, %got_lo(extern_func)($3)
-// mips64: #NO_APP
-#[cfg(mips64)]
-#[no_mangle]
-pub unsafe fn sym_fn_64() {
-    asm!("ld $v1, {}", sym extern_func);
-}
-
-// CHECK-LABEL: reg_f32:
-// CHECK: #APP
-// CHECK: mov.s $f{{[0-9]+}}, $f{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f32, f32, freg, "mov.s");
-
-// CHECK-LABEL: f0_f32:
-// CHECK: #APP
-// CHECK: mov.s $f0, $f0
-// CHECK: #NO_APP
-#[no_mangle]
-check_reg!(f0_f32, f32, "$f0", "mov.s");
-
-// CHECK-LABEL: reg_f32_64:
-// CHECK: #APP
-// CHECK: mov.d $f{{[0-9]+}}, $f{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f32_64, f32, freg, "mov.d");
-
-// CHECK-LABEL: f0_f32_64:
-// CHECK: #APP
-// CHECK: mov.d $f0, $f0
-// CHECK: #NO_APP
-#[no_mangle]
-check_reg!(f0_f32_64, f32, "$f0", "mov.d");
-
-// CHECK-LABEL: reg_f64:
-// CHECK: #APP
-// CHECK: mov.d $f{{[0-9]+}}, $f{{[0-9]+}}
-// CHECK: #NO_APP
-#[no_mangle]
-check!(reg_f64, f64, freg, "mov.d");
-
-// CHECK-LABEL: f0_f64:
-// CHECK: #APP
-// CHECK: mov.d $f0, $f0
-// CHECK: #NO_APP
-#[no_mangle]
-check_reg!(f0_f64, f64, "$f0", "mov.d");
-
-// CHECK-LABEL: reg_ptr:
-// CHECK: #APP
-// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_ptr, ptr, reg, "move");
-
-// CHECK-LABEL: reg_i32:
-// CHECK: #APP
-// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i32, i32, reg, "move");
-
-// CHECK-LABEL: reg_f32_soft:
-// CHECK: #APP
-// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f32_soft, f32, reg, "move");
-
-// mips64-LABEL: reg_f64_soft:
-// mips64: #APP
-// mips64: move ${{[0-9]+}}, ${{[0-9]+}}
-// mips64: #NO_APP
-#[cfg(mips64)]
-check!(reg_f64_soft, f64, reg, "move");
-
-// CHECK-LABEL: reg_i8:
-// CHECK: #APP
-// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i8, i8, reg, "move");
-
-// CHECK-LABEL: reg_u8:
-// CHECK: #APP
-// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_u8, u8, reg, "move");
-
-// CHECK-LABEL: reg_i16:
-// CHECK: #APP
-// CHECK: move ${{[0-9]+}}, ${{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i16, i16, reg, "move");
-
-// mips64-LABEL: reg_i64:
-// mips64: #APP
-// mips64: move ${{[0-9]+}}, ${{[0-9]+}}
-// mips64: #NO_APP
-#[cfg(mips64)]
-check!(reg_i64, i64, reg, "move");
-
-// CHECK-LABEL: r8_ptr:
-// CHECK: #APP
-// CHECK: move $8, $8
-// CHECK: #NO_APP
-check_reg!(r8_ptr, ptr, "$8", "move");
-
-// CHECK-LABEL: r8_i32:
-// CHECK: #APP
-// CHECK: move $8, $8
-// CHECK: #NO_APP
-check_reg!(r8_i32, i32, "$8", "move");
-
-// CHECK-LABEL: r8_f32:
-// CHECK: #APP
-// CHECK: move $8, $8
-// CHECK: #NO_APP
-check_reg!(r8_f32, f32, "$8", "move");
-
-// CHECK-LABEL: r8_i8:
-// CHECK: #APP
-// CHECK: move $8, $8
-// CHECK: #NO_APP
-check_reg!(r8_i8, i8, "$8", "move");
-
-// CHECK-LABEL: r8_u8:
-// CHECK: #APP
-// CHECK: move $8, $8
-// CHECK: #NO_APP
-check_reg!(r8_u8, u8, "$8", "move");
-
-// CHECK-LABEL: r8_i16:
-// CHECK: #APP
-// CHECK: move $8, $8
-// CHECK: #NO_APP
-check_reg!(r8_i16, i16, "$8", "move");
diff --git a/tests/assembly/asm/msp430-types.rs b/tests/assembly/asm/msp430-types.rs
deleted file mode 100644
index 442dc77999f..00000000000
--- a/tests/assembly/asm/msp430-types.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target msp430-none-elf
-//@ needs-llvm-components: msp430
-
-#![feature(no_core, asm_experimental_arch)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *const i16;
-
-macro_rules! check {
-    ($func:ident $ty:ident $class:ident) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!("mov {}, {}", lateout($class) y, in($class) x);
-            y
-        }
-    };
-}
-
-macro_rules! checkb {
-    ($func:ident $ty:ident $class:ident) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!("mov.b {}, {}", lateout($class) y, in($class) x);
-            y
-        }
-    };
-}
-
-macro_rules! check_reg {
-    ($func:ident $ty:ident $reg:tt) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!("mov ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
-            y
-        }
-    };
-}
-
-macro_rules! check_regb {
-    ($func:ident $ty:ident $reg:tt) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!("mov.b ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
-            y
-        }
-    };
-}
-
-extern "C" {
-    fn extern_func();
-    static extern_static: i8;
-}
-
-// CHECK-LABEL: sym_fn
-// CHECK: ;APP
-// CHECK: call extern_func
-// CHECK: ;NO_APP
-#[no_mangle]
-pub unsafe fn sym_fn() {
-    asm!("call {}", sym extern_func);
-}
-
-// CHECK-LABEL: sym_static
-// CHECK: ;APP
-// CHECK: mov.b extern_static, r{{[0-9]+}}
-// CHECK: ;NO_APP
-#[no_mangle]
-pub unsafe fn sym_static() -> i8 {
-    let y;
-    asm!("mov.b {1}, {0}", lateout(reg) y, sym extern_static);
-    y
-}
-
-// CHECK-LABEL: add_const:
-// CHECK: ;APP
-// CHECK: add.b #5, r{{[0-9]+}}
-// CHECK: ;NO_APP
-#[no_mangle]
-pub unsafe fn add_const() -> i8 {
-    let y;
-    asm!("add.b #{number}, {}", out(reg) y, number = const 5);
-    y
-}
-
-// CHECK-LABEL: mov_postincrement:
-// CHECK: ;APP
-// CHECK: mov @r5+, r{{[0-9]+}}
-// CHECK: ;NO_APP
-#[no_mangle]
-pub unsafe fn mov_postincrement(mut x: *const i16) -> (i16, *const i16) {
-    let y;
-    asm!("mov @r5+, {0}", out(reg) y, inlateout("r5") x);
-    (y, x)
-}
-
-// CHECK-LABEL: reg_i8:
-// CHECK: ;APP
-// CHECK: mov r{{[0-9]+}}, r{{[0-9]+}}
-// CHECK: ;NO_APP
-check!(reg_i8 i8 reg);
-
-// CHECK-LABEL: reg_i16:
-// CHECK: ;APP
-// CHECK: mov r{{[0-9]+}}, r{{[0-9]+}}
-// CHECK: ;NO_APP
-check!(reg_i16 i16 reg);
-
-// CHECK-LABEL: reg_i8b:
-// CHECK: ;APP
-// CHECK: mov.b r{{[0-9]+}}, r{{[0-9]+}}
-// CHECK: ;NO_APP
-checkb!(reg_i8b i8 reg);
-
-// CHECK-LABEL: r5_i8:
-// CHECK: ;APP
-// CHECK: mov r5, r5
-// CHECK: ;NO_APP
-check_reg!(r5_i8 i8 "r5");
-
-// CHECK-LABEL: r5_i16:
-// CHECK: ;APP
-// CHECK: mov r5, r5
-// CHECK: ;NO_APP
-check_reg!(r5_i16 i16 "r5");
-
-// CHECK-LABEL: r5_i8b:
-// CHECK: ;APP
-// CHECK: mov.b r5, r5
-// CHECK: ;NO_APP
-check_regb!(r5_i8b i8 "r5");
diff --git a/tests/assembly/asm/nvptx-types.rs b/tests/assembly/asm/nvptx-types.rs
deleted file mode 100644
index 7e8ebd03024..00000000000
--- a/tests/assembly/asm/nvptx-types.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target nvptx64-nvidia-cuda
-//@ needs-llvm-components: nvptx
-
-#![feature(no_core, asm_experimental_arch)]
-#![crate_type = "rlib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *mut u8;
-
-// NVPTX does not support static variables
-#[no_mangle]
-fn extern_func() {}
-
-// CHECK-LABEL: .visible .func sym_fn()
-// CHECK: // begin inline asm
-// CHECK: call extern_func;
-// CHECK: // end inline asm
-#[no_mangle]
-pub unsafe fn sym_fn() {
-    asm!("call {};", sym extern_func);
-}
-
-macro_rules! check {
-    ($func:ident $ty:ident $class:ident $mov:literal) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!($mov, " {}, {};"), out($class) y, in($class) x);
-            y
-        }
-    };
-}
-
-// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg16_i8
-// CHECK: // begin inline asm
-// CHECK: mov.i16 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg16_i8 i8 reg16 "mov.i16");
-
-// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg16_i16
-// CHECK: // begin inline asm
-// CHECK: mov.i16 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg16_i16 i16 reg16 "mov.i16");
-
-// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_i8
-// CHECK: // begin inline asm
-// CHECK: mov.i32 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg32_i8 i8 reg32 "mov.i32");
-
-// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_i16
-// CHECK: // begin inline asm
-// CHECK: mov.i32 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg32_i16 i16 reg32 "mov.i32");
-
-// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_i32
-// CHECK: // begin inline asm
-// CHECK: mov.i32 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg32_i32 i32 reg32 "mov.i32");
-
-// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_f32
-// CHECK: // begin inline asm
-// CHECK: mov.i32 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg32_f32 f32 reg32 "mov.i32");
-
-// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i8
-// CHECK: // begin inline asm
-// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg64_i8 i8 reg64 "mov.i64");
-
-// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i16
-// CHECK: // begin inline asm
-// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg64_i16 i16 reg64 "mov.i64");
-
-// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i32
-// CHECK: // begin inline asm
-// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg64_i32 i32 reg64 "mov.i64");
-
-// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_f32
-// CHECK: // begin inline asm
-// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg64_f32 f32 reg64 "mov.i64");
-
-// CHECK-LABEL: .visible .func (.param .b64 func_retval0) reg64_i64
-// CHECK: // begin inline asm
-// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg64_i64 i64 reg64 "mov.i64");
-
-// CHECK-LABEL: .visible .func (.param .b64 func_retval0) reg64_f64
-// CHECK: // begin inline asm
-// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg64_f64 f64 reg64 "mov.i64");
-
-// CHECK-LABEL: .visible .func (.param .b64 func_retval0) reg64_ptr
-// CHECK: // begin inline asm
-// CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}};
-// CHECK: // end inline asm
-check!(reg64_ptr ptr reg64 "mov.i64");
diff --git a/tests/assembly/asm/powerpc-types.rs b/tests/assembly/asm/powerpc-types.rs
deleted file mode 100644
index 4291e4c02f3..00000000000
--- a/tests/assembly/asm/powerpc-types.rs
+++ /dev/null
@@ -1,474 +0,0 @@
-//@ add-core-stubs
-//@ revisions: powerpc powerpc_altivec powerpc_vsx powerpc64 powerpc64_vsx
-//@ assembly-output: emit-asm
-//@[powerpc] compile-flags: --target powerpc-unknown-linux-gnu
-//@[powerpc] needs-llvm-components: powerpc
-//@[powerpc_altivec] compile-flags: --target powerpc-unknown-linux-gnu -C target-feature=+altivec --cfg altivec
-//@[powerpc_altivec] needs-llvm-components: powerpc
-//@[powerpc_vsx] compile-flags: --target powerpc-unknown-linux-gnu -C target-feature=+altivec,+vsx --cfg altivec --cfg vsx
-//@[powerpc_vsx] needs-llvm-components: powerpc
-//@[powerpc64] compile-flags: --target powerpc64-unknown-linux-gnu --cfg altivec
-//@[powerpc64] needs-llvm-components: powerpc
-//@[powerpc64_vsx] compile-flags: --target powerpc64-unknown-linux-gnu -C target-feature=+vsx --cfg altivec --cfg vsx
-//@[powerpc64_vsx] needs-llvm-components: powerpc
-//@ compile-flags: -Zmerge-functions=disabled
-
-#![feature(no_core, repr_simd, asm_experimental_arch)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register, non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-#[cfg_attr(altivec, cfg(not(target_feature = "altivec")))]
-#[cfg_attr(not(altivec), cfg(target_feature = "altivec"))]
-compile_error!("altivec cfg and target feature mismatch");
-#[cfg_attr(vsx, cfg(not(target_feature = "vsx")))]
-#[cfg_attr(not(vsx), cfg(target_feature = "vsx"))]
-compile_error!("vsx cfg and target feature mismatch");
-
-type ptr = *const i32;
-
-#[repr(simd)]
-pub struct i8x16([i8; 16]);
-#[repr(simd)]
-pub struct i16x8([i16; 8]);
-#[repr(simd)]
-pub struct i32x4([i32; 4]);
-#[repr(simd)]
-pub struct i64x2([i64; 2]);
-#[repr(simd)]
-pub struct f32x4([f32; 4]);
-#[repr(simd)]
-pub struct f64x2([f64; 2]);
-
-impl Copy for i8x16 {}
-impl Copy for i16x8 {}
-impl Copy for i32x4 {}
-impl Copy for i64x2 {}
-impl Copy for f32x4 {}
-impl Copy for f64x2 {}
-
-extern "C" {
-    fn extern_func();
-    static extern_static: u8;
-}
-
-macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
-    #[no_mangle]
-    pub unsafe fn $func(x: $ty) -> $ty {
-        let y;
-        asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
-        y
-    }
-};}
-
-macro_rules! check_reg { ($func:ident, $ty:ty, $rego:tt, $regc:tt, $mov:literal) => {
-    #[no_mangle]
-    pub unsafe fn $func(x: $ty) -> $ty {
-        let y;
-        asm!(concat!($mov, " ", $rego, ", ", $rego), lateout($regc) y, in($regc) x);
-        y
-    }
-};}
-
-// CHECK-LABEL: reg_i8:
-// CHECK: #APP
-// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i8, i8, reg, "mr");
-
-// CHECK-LABEL: reg_i16:
-// CHECK: #APP
-// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i16, i16, reg, "mr");
-
-// CHECK-LABEL: reg_i32:
-// CHECK: #APP
-// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i32, i32, reg, "mr");
-
-// powerpc64-LABEL: reg_i64:
-// powerpc64: #APP
-// powerpc64: mr {{[0-9]+}}, {{[0-9]+}}
-// powerpc64: #NO_APP
-#[cfg(powerpc64)]
-check!(reg_i64, i64, reg, "mr");
-
-// CHECK-LABEL: reg_i8_nz:
-// CHECK: #APP
-// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i8_nz, i8, reg_nonzero, "mr");
-
-// CHECK-LABEL: reg_i16_nz:
-// CHECK: #APP
-// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i16_nz, i16, reg_nonzero, "mr");
-
-// CHECK-LABEL: reg_i32_nz:
-// CHECK: #APP
-// CHECK: mr {{[0-9]+}}, {{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i32_nz, i32, reg_nonzero, "mr");
-
-// powerpc64-LABEL: reg_i64_nz:
-// powerpc64: #APP
-// powerpc64: mr {{[0-9]+}}, {{[0-9]+}}
-// powerpc64: #NO_APP
-#[cfg(powerpc64)]
-check!(reg_i64_nz, i64, reg_nonzero, "mr");
-
-// CHECK-LABEL: reg_f32:
-// CHECK: #APP
-// CHECK: fmr {{[0-9]+}}, {{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f32, f32, freg, "fmr");
-
-// CHECK-LABEL: reg_f64:
-// CHECK: #APP
-// CHECK: fmr {{[0-9]+}}, {{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f64, f64, freg, "fmr");
-
-// powerpc_altivec-LABEL: vreg_i8x16:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_i8x16:
-// powerpc64: #APP
-// powerpc64: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check!(vreg_i8x16, i8x16, vreg, "vmr");
-
-// powerpc_altivec-LABEL: vreg_i16x8:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_i16x8:
-// powerpc64: #APP
-// powerpc64: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check!(vreg_i16x8, i16x8, vreg, "vmr");
-
-// powerpc_altivec-LABEL: vreg_i32x4:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_i32x4:
-// powerpc64: #APP
-// powerpc64: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check!(vreg_i32x4, i32x4, vreg, "vmr");
-
-// powerpc_vsx-LABEL: vreg_i64x2:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_i64x2:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check!(vreg_i64x2, i64x2, vreg, "vmr");
-
-// powerpc_altivec-LABEL: vreg_f32x4:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_f32x4:
-// powerpc64: #APP
-// powerpc64: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check!(vreg_f32x4, f32x4, vreg, "vmr");
-
-// powerpc_vsx-LABEL: vreg_f64x2:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_f64x2:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check!(vreg_f64x2, f64x2, vreg, "vmr");
-
-// powerpc_vsx-LABEL: vreg_f32:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_f32:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check!(vreg_f32, f32, vreg, "vmr");
-
-// powerpc_vsx-LABEL: vreg_f64:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_f64:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}}
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check!(vreg_f64, f64, vreg, "vmr");
-
-// CHECK-LABEL: reg_i8_r0:
-// CHECK: #APP
-// CHECK: mr 0, 0
-// CHECK: #NO_APP
-check_reg!(reg_i8_r0, i8, "0", "0", "mr");
-
-// CHECK-LABEL: reg_i16_r0:
-// CHECK: #APP
-// CHECK: mr 0, 0
-// CHECK: #NO_APP
-check_reg!(reg_i16_r0, i16, "0", "0", "mr");
-
-// CHECK-LABEL: reg_i32_r0:
-// CHECK: #APP
-// CHECK: mr 0, 0
-// CHECK: #NO_APP
-check_reg!(reg_i32_r0, i32, "0", "0", "mr");
-
-// powerpc64-LABEL: reg_i64_r0:
-// powerpc64: #APP
-// powerpc64: mr 0, 0
-// powerpc64: #NO_APP
-#[cfg(powerpc64)]
-check_reg!(reg_i64_r0, i64, "0", "0", "mr");
-
-// CHECK-LABEL: reg_i8_r18:
-// CHECK: #APP
-// CHECK: mr 18, 18
-// CHECK: #NO_APP
-check_reg!(reg_i8_r18, i8, "18", "18", "mr");
-
-// CHECK-LABEL: reg_i16_r18:
-// CHECK: #APP
-// CHECK: mr 18, 18
-// CHECK: #NO_APP
-check_reg!(reg_i16_r18, i16, "18", "18", "mr");
-
-// CHECK-LABEL: reg_i32_r18:
-// CHECK: #APP
-// CHECK: mr 18, 18
-// CHECK: #NO_APP
-check_reg!(reg_i32_r18, i32, "18", "18", "mr");
-
-// powerpc64-LABEL: reg_i64_r18:
-// powerpc64: #APP
-// powerpc64: mr 18, 18
-// powerpc64: #NO_APP
-#[cfg(powerpc64)]
-check_reg!(reg_i64_r18, i64, "18", "18", "mr");
-
-// CHECK-LABEL: reg_f32_f0:
-// CHECK: #APP
-// CHECK: fmr 0, 0
-// CHECK: #NO_APP
-check_reg!(reg_f32_f0, f32, "0", "f0", "fmr");
-
-// CHECK-LABEL: reg_f64_f0:
-// CHECK: #APP
-// CHECK: fmr 0, 0
-// CHECK: #NO_APP
-check_reg!(reg_f64_f0, f64, "0", "f0", "fmr");
-
-// CHECK-LABEL: reg_f32_f18:
-// CHECK: #APP
-// CHECK: fmr 18, 18
-// CHECK: #NO_APP
-check_reg!(reg_f32_f18, f32, "18", "f18", "fmr");
-
-// CHECK-LABEL: reg_f64_f18:
-// CHECK: #APP
-// CHECK: fmr 18, 18
-// CHECK: #NO_APP
-check_reg!(reg_f64_f18, f64, "18", "f18", "fmr");
-
-// powerpc_altivec-LABEL: vreg_i8x16_v0:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr 0, 0
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_i8x16_v0:
-// powerpc64: #APP
-// powerpc64: vmr 0, 0
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check_reg!(vreg_i8x16_v0, i8x16, "0", "v0", "vmr");
-
-// powerpc_altivec-LABEL: vreg_i16x8_v0:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr 0, 0
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_i16x8_v0:
-// powerpc64: #APP
-// powerpc64: vmr 0, 0
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check_reg!(vreg_i16x8_v0, i16x8, "0", "v0", "vmr");
-
-// powerpc_altivec-LABEL: vreg_i32x4_v0:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr 0, 0
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_i32x4_v0:
-// powerpc64: #APP
-// powerpc64: vmr 0, 0
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check_reg!(vreg_i32x4_v0, i32x4, "0", "v0", "vmr");
-
-// powerpc_vsx-LABEL: vreg_i64x2_v0:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr 0, 0
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_i64x2_v0:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr 0, 0
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check_reg!(vreg_i64x2_v0, i64x2, "0", "v0", "vmr");
-
-// powerpc_altivec-LABEL: vreg_f32x4_v0:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr 0, 0
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_f32x4_v0:
-// powerpc64: #APP
-// powerpc64: vmr 0, 0
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check_reg!(vreg_f32x4_v0, f32x4, "0", "v0", "vmr");
-
-// powerpc_vsx-LABEL: vreg_f64x2_v0:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr 0, 0
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_f64x2_v0:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr 0, 0
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check_reg!(vreg_f64x2_v0, f64x2, "0", "v0", "vmr");
-
-// powerpc_vsx-LABEL: vreg_f32_v0:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr 0, 0
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_f32_v0:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr 0, 0
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check_reg!(vreg_f32_v0, f32, "0", "v0", "vmr");
-
-// powerpc_vsx-LABEL: vreg_f64_v0:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr 0, 0
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_f64_v0:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr 0, 0
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check_reg!(vreg_f64_v0, f64, "0", "v0", "vmr");
-
-// powerpc_altivec-LABEL: vreg_i8x16_v18:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr 18, 18
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_i8x16_v18:
-// powerpc64: #APP
-// powerpc64: vmr 18, 18
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check_reg!(vreg_i8x16_v18, i8x16, "18", "v18", "vmr");
-
-// powerpc_altivec-LABEL: vreg_i16x8_v18:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr 18, 18
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_i16x8_v18:
-// powerpc64: #APP
-// powerpc64: vmr 18, 18
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check_reg!(vreg_i16x8_v18, i16x8, "18", "v18", "vmr");
-
-// powerpc_altivec-LABEL: vreg_i32x4_v18:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr 18, 18
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_i32x4_v18:
-// powerpc64: #APP
-// powerpc64: vmr 18, 18
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check_reg!(vreg_i32x4_v18, i32x4, "18", "v18", "vmr");
-
-// powerpc_vsx-LABEL: vreg_i64x2_v18:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr 18, 18
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_i64x2_v18:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr 18, 18
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check_reg!(vreg_i64x2_v18, i64x2, "18", "v18", "vmr");
-
-// powerpc_altivec-LABEL: vreg_f32x4_v18:
-// powerpc_altivec: #APP
-// powerpc_altivec: vmr 18, 18
-// powerpc_altivec: #NO_APP
-// powerpc64-LABEL: vreg_f32x4_v18:
-// powerpc64: #APP
-// powerpc64: vmr 18, 18
-// powerpc64: #NO_APP
-#[cfg(altivec)]
-check_reg!(vreg_f32x4_v18, f32x4, "18", "v18", "vmr");
-
-// powerpc_vsx-LABEL: vreg_f64x2_v18:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr 18, 18
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_f64x2_v18:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr 18, 18
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check_reg!(vreg_f64x2_v18, f64x2, "18", "v18", "vmr");
-
-// powerpc_vsx-LABEL: vreg_f32_v18:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr 18, 18
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_f32_v18:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr 18, 18
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check_reg!(vreg_f32_v18, f32, "18", "v18", "vmr");
-
-// powerpc_vsx-LABEL: vreg_f64_v18:
-// powerpc_vsx: #APP
-// powerpc_vsx: vmr 18, 18
-// powerpc_vsx: #NO_APP
-// powerpc64_vsx-LABEL: vreg_f64_v18:
-// powerpc64_vsx: #APP
-// powerpc64_vsx: vmr 18, 18
-// powerpc64_vsx: #NO_APP
-#[cfg(vsx)]
-check_reg!(vreg_f64_v18, f64, "18", "v18", "vmr");
diff --git a/tests/assembly/asm/riscv-types.rs b/tests/assembly/asm/riscv-types.rs
deleted file mode 100644
index 724aa154da8..00000000000
--- a/tests/assembly/asm/riscv-types.rs
+++ /dev/null
@@ -1,227 +0,0 @@
-//@ add-core-stubs
-//@ revisions: riscv64 riscv32 riscv64-zfhmin riscv32-zfhmin riscv64-zfh riscv32-zfh
-//@ assembly-output: emit-asm
-
-//@[riscv64] compile-flags: --target riscv64imac-unknown-none-elf
-//@[riscv64] needs-llvm-components: riscv
-
-//@[riscv32] compile-flags: --target riscv32imac-unknown-none-elf
-//@[riscv32] needs-llvm-components: riscv
-
-//@[riscv64-zfhmin] compile-flags: --target riscv64imac-unknown-none-elf --cfg riscv64
-//@[riscv64-zfhmin] needs-llvm-components: riscv
-//@[riscv64-zfhmin] compile-flags: -C target-feature=+zfhmin
-//@[riscv64-zfhmin] filecheck-flags: --check-prefix riscv64
-
-//@[riscv32-zfhmin] compile-flags: --target riscv32imac-unknown-none-elf
-//@[riscv32-zfhmin] needs-llvm-components: riscv
-//@[riscv32-zfhmin] compile-flags: -C target-feature=+zfhmin
-
-//@[riscv64-zfh] compile-flags: --target riscv64imac-unknown-none-elf --cfg riscv64
-//@[riscv64-zfh] needs-llvm-components: riscv
-//@[riscv64-zfh] compile-flags: -C target-feature=+zfh
-//@[riscv64-zfh] filecheck-flags: --check-prefix riscv64 --check-prefix zfhmin
-
-//@[riscv32-zfh] compile-flags: --target riscv32imac-unknown-none-elf
-//@[riscv32-zfh] needs-llvm-components: riscv
-//@[riscv32-zfh] compile-flags: -C target-feature=+zfh
-//@[riscv32-zfh] filecheck-flags: --check-prefix zfhmin
-
-//@ compile-flags: -C target-feature=+d
-//@ compile-flags: -Zmerge-functions=disabled
-
-#![feature(no_core, f16)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *mut u8;
-
-extern "C" {
-    fn extern_func();
-    static extern_static: u8;
-}
-
-// CHECK-LABEL: sym_fn:
-// CHECK: #APP
-// CHECK: call extern_func
-// CHECK: #NO_APP
-#[no_mangle]
-pub unsafe fn sym_fn() {
-    asm!("call {}", sym extern_func);
-}
-
-// CHECK-LABEL: sym_static:
-// CHECK: #APP
-// CHECK: auipc t0, %pcrel_hi(extern_static)
-// CHECK: lb t0, %pcrel_lo(.Lpcrel_hi{{[0-9]+}})(t0)
-// CHECK: #NO_APP
-#[no_mangle]
-pub unsafe fn sym_static() {
-    asm!("lb t0, {}", sym extern_static);
-}
-
-macro_rules! check {
-    ($func:ident $ty:ident $class:ident $mov:literal) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!($mov, " {}, {}"), out($class) y, in($class) x);
-            y
-        }
-    };
-}
-
-macro_rules! check_reg {
-    ($func:ident $ty:ident $reg:tt $mov:literal) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
-            y
-        }
-    };
-}
-
-// CHECK-LABEL: reg_i8:
-// CHECK: #APP
-// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i8 i8 reg "mv");
-
-// CHECK-LABEL: reg_f16:
-// CHECK: #APP
-// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f16 f16 reg "mv");
-
-// CHECK-LABEL: reg_i16:
-// CHECK: #APP
-// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i16 i16 reg "mv");
-
-// CHECK-LABEL: reg_i32:
-// CHECK: #APP
-// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i32 i32 reg "mv");
-
-// CHECK-LABEL: reg_f32:
-// CHECK: #APP
-// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f32 f32 reg "mv");
-
-// riscv64-LABEL: reg_i64:
-// riscv64: #APP
-// riscv64: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// riscv64: #NO_APP
-#[cfg(riscv64)]
-check!(reg_i64 i64 reg "mv");
-
-// riscv64-LABEL: reg_f64:
-// riscv64: #APP
-// riscv64: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// riscv64: #NO_APP
-#[cfg(riscv64)]
-check!(reg_f64 f64 reg "mv");
-
-// CHECK-LABEL: reg_ptr:
-// CHECK: #APP
-// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_ptr ptr reg "mv");
-
-// CHECK-LABEL: freg_f16:
-// zfhmin-NOT: or
-// CHECK: #APP
-// CHECK: fmv.s f{{[a-z0-9]+}}, f{{[a-z0-9]+}}
-// CHECK: #NO_APP
-// zfhmin-NOT: or
-check!(freg_f16 f16 freg "fmv.s");
-
-// CHECK-LABEL: freg_f32:
-// CHECK: #APP
-// CHECK: fmv.s f{{[a-z0-9]+}}, f{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(freg_f32 f32 freg "fmv.s");
-
-// CHECK-LABEL: freg_f64:
-// CHECK: #APP
-// CHECK: fmv.d f{{[a-z0-9]+}}, f{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(freg_f64 f64 freg "fmv.d");
-
-// CHECK-LABEL: a0_i8:
-// CHECK: #APP
-// CHECK: mv a0, a0
-// CHECK: #NO_APP
-check_reg!(a0_i8 i8 "a0" "mv");
-
-// CHECK-LABEL: a0_i16:
-// CHECK: #APP
-// CHECK: mv a0, a0
-// CHECK: #NO_APP
-check_reg!(a0_i16 i16 "a0" "mv");
-
-// CHECK-LABEL: a0_f16:
-// CHECK: #APP
-// CHECK: mv a0, a0
-// CHECK: #NO_APP
-check_reg!(a0_f16 f16 "a0" "mv");
-
-// CHECK-LABEL: a0_i32:
-// CHECK: #APP
-// CHECK: mv a0, a0
-// CHECK: #NO_APP
-check_reg!(a0_i32 i32 "a0" "mv");
-
-// CHECK-LABEL: a0_f32:
-// CHECK: #APP
-// CHECK: mv a0, a0
-// CHECK: #NO_APP
-check_reg!(a0_f32 f32 "a0" "mv");
-
-// riscv64-LABEL: a0_i64:
-// riscv64: #APP
-// riscv64: mv a0, a0
-// riscv64: #NO_APP
-#[cfg(riscv64)]
-check_reg!(a0_i64 i64 "a0" "mv");
-
-// riscv64-LABEL: a0_f64:
-// riscv64: #APP
-// riscv64: mv a0, a0
-// riscv64: #NO_APP
-#[cfg(riscv64)]
-check_reg!(a0_f64 f64 "a0" "mv");
-
-// CHECK-LABEL: a0_ptr:
-// CHECK: #APP
-// CHECK: mv a0, a0
-// CHECK: #NO_APP
-check_reg!(a0_ptr ptr "a0" "mv");
-
-// CHECK-LABEL: fa0_f16:
-// zfhmin-NOT: or
-// CHECK: #APP
-// CHECK: fmv.s fa0, fa0
-// CHECK: #NO_APP
-// zfhmin-NOT: or
-check_reg!(fa0_f16 f16 "fa0" "fmv.s");
-
-// CHECK-LABEL: fa0_f32:
-// CHECK: #APP
-// CHECK: fmv.s fa0, fa0
-// CHECK: #NO_APP
-check_reg!(fa0_f32 f32 "fa0" "fmv.s");
-
-// CHECK-LABEL: fa0_f64:
-// CHECK: #APP
-// CHECK: fmv.d fa0, fa0
-// CHECK: #NO_APP
-check_reg!(fa0_f64 f64 "fa0" "fmv.d");
diff --git a/tests/assembly/asm/s390x-types.rs b/tests/assembly/asm/s390x-types.rs
deleted file mode 100644
index e6fe38ecb0d..00000000000
--- a/tests/assembly/asm/s390x-types.rs
+++ /dev/null
@@ -1,350 +0,0 @@
-//@ add-core-stubs
-//@ revisions: s390x s390x_vector
-//@ assembly-output: emit-asm
-//@[s390x] compile-flags: --target s390x-unknown-linux-gnu
-//@[s390x] needs-llvm-components: systemz
-//@[s390x_vector] compile-flags: --target s390x-unknown-linux-gnu -C target-feature=+vector
-//@[s390x_vector] needs-llvm-components: systemz
-//@ compile-flags: -Zmerge-functions=disabled
-
-#![feature(no_core, repr_simd, f128)]
-#![cfg_attr(s390x_vector, feature(asm_experimental_reg))]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register, non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *const i32;
-
-#[repr(simd)]
-pub struct i8x16([i8; 16]);
-#[repr(simd)]
-pub struct i16x8([i16; 8]);
-#[repr(simd)]
-pub struct i32x4([i32; 4]);
-#[repr(simd)]
-pub struct i64x2([i64; 2]);
-#[repr(simd)]
-pub struct f32x4([f32; 4]);
-#[repr(simd)]
-pub struct f64x2([f64; 2]);
-
-impl Copy for i8x16 {}
-impl Copy for i16x8 {}
-impl Copy for i32x4 {}
-impl Copy for i64x2 {}
-impl Copy for f32x4 {}
-impl Copy for f64x2 {}
-
-extern "C" {
-    fn extern_func();
-    static extern_static: u8;
-}
-
-macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
-    #[no_mangle]
-    pub unsafe fn $func(x: $ty) -> $ty {
-        let y;
-        asm!(concat!($mov," {}, {}"), out($class) y, in($class) x);
-        y
-    }
-};}
-
-macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => {
-    #[no_mangle]
-    pub unsafe fn $func(x: $ty) -> $ty {
-        let y;
-        asm!(concat!($mov, " %", $reg, ", %", $reg), lateout($reg) y, in($reg) x);
-        y
-    }
-};}
-
-// CHECK-LABEL: sym_fn_32:
-// CHECK: #APP
-// CHECK: brasl %r14, extern_func
-// CHECK: #NO_APP
-#[no_mangle]
-pub unsafe fn sym_fn_32() {
-    asm!("brasl %r14, {}", sym extern_func);
-}
-
-// CHECK-LABEL: sym_static:
-// CHECK: #APP
-// CHECK: brasl %r14, extern_static
-// CHECK: #NO_APP
-#[no_mangle]
-pub unsafe fn sym_static() {
-    asm!("brasl %r14, {}", sym extern_static);
-}
-
-// CHECK-LABEL: reg_i8:
-// CHECK: #APP
-// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i8, i8, reg, "lgr");
-
-// CHECK-LABEL: reg_i16:
-// CHECK: #APP
-// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i16, i16, reg, "lgr");
-
-// CHECK-LABEL: reg_i32:
-// CHECK: #APP
-// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i32, i32, reg, "lgr");
-
-// CHECK-LABEL: reg_i64:
-// CHECK: #APP
-// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i64, i64, reg, "lgr");
-
-// CHECK-LABEL: reg_i8_addr:
-// CHECK: #APP
-// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i8_addr, i8, reg_addr, "lgr");
-
-// CHECK-LABEL: reg_i16_addr:
-// CHECK: #APP
-// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i16_addr, i16, reg_addr, "lgr");
-
-// CHECK-LABEL: reg_i32_addr:
-// CHECK: #APP
-// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i32_addr, i32, reg_addr, "lgr");
-
-// CHECK-LABEL: reg_i64_addr:
-// CHECK: #APP
-// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i64_addr, i64, reg_addr, "lgr");
-
-// CHECK-LABEL: reg_f32:
-// CHECK: #APP
-// CHECK: ler %f{{[0-9]+}}, %f{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f32, f32, freg, "ler");
-
-// CHECK-LABEL: reg_f64:
-// CHECK: #APP
-// CHECK: ldr %f{{[0-9]+}}, %f{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f64, f64, freg, "ldr");
-
-// CHECK-LABEL: reg_ptr:
-// CHECK: #APP
-// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}}
-// CHECK: #NO_APP
-check!(reg_ptr, ptr, reg, "lgr");
-
-// s390x_vector-LABEL: vreg_i8x16:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_i8x16, i8x16, vreg, "vlr");
-
-// s390x_vector-LABEL: vreg_i16x8:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_i16x8, i16x8, vreg, "vlr");
-
-// s390x_vector-LABEL: vreg_i32x4:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_i32x4, i32x4, vreg, "vlr");
-
-// s390x_vector-LABEL: vreg_i64x2:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_i64x2, i64x2, vreg, "vlr");
-
-// s390x_vector-LABEL: vreg_f32x4:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_f32x4, f32x4, vreg, "vlr");
-
-// s390x_vector-LABEL: vreg_f64x2:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_f64x2, f64x2, vreg, "vlr");
-
-// s390x_vector-LABEL: vreg_i32:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_i32, i32, vreg, "vlr");
-
-// s390x_vector-LABEL: vreg_i64:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_i64, i64, vreg, "vlr");
-
-// s390x_vector-LABEL: vreg_i128:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_i128, i128, vreg, "vlr");
-
-// s390x_vector-LABEL: vreg_f32:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_f32, f32, vreg, "vlr");
-
-// s390x_vector-LABEL: vreg_f64:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_f64, f64, vreg, "vlr");
-
-// s390x_vector-LABEL: vreg_f128:
-// s390x_vector: #APP
-// s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}}
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check!(vreg_f128, f128, vreg, "vlr");
-
-// CHECK-LABEL: r0_i8:
-// CHECK: #APP
-// CHECK: lr %r0, %r0
-// CHECK: #NO_APP
-check_reg!(r0_i8, i8, "r0", "lr");
-
-// CHECK-LABEL: r0_i16:
-// CHECK: #APP
-// CHECK: lr %r0, %r0
-// CHECK: #NO_APP
-check_reg!(r0_i16, i16, "r0", "lr");
-
-// CHECK-LABEL: r0_i32:
-// CHECK: #APP
-// CHECK: lr %r0, %r0
-// CHECK: #NO_APP
-check_reg!(r0_i32, i32, "r0", "lr");
-
-// CHECK-LABEL: r0_i64:
-// CHECK: #APP
-// CHECK: lr %r0, %r0
-// CHECK: #NO_APP
-check_reg!(r0_i64, i64, "r0", "lr");
-
-// CHECK-LABEL: f0_f32:
-// CHECK: #APP
-// CHECK: ler %f0, %f0
-// CHECK: #NO_APP
-check_reg!(f0_f32, f32, "f0", "ler");
-
-// CHECK-LABEL: f0_f64:
-// CHECK: #APP
-// CHECK: ldr %f0, %f0
-// CHECK: #NO_APP
-check_reg!(f0_f64, f64, "f0", "ldr");
-
-// s390x_vector-LABEL: v0_i8x16:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_i8x16, i8x16, "v0", "vlr");
-
-// s390x_vector-LABEL: v0_i16x8:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_i16x8, i16x8, "v0", "vlr");
-
-// s390x_vector-LABEL: v0_i32x4:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_i32x4, i32x4, "v0", "vlr");
-
-// s390x_vector-LABEL: v0_i64x2:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_i64x2, i64x2, "v0", "vlr");
-
-// s390x_vector-LABEL: v0_f32x4:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_f32x4, f32x4, "v0", "vlr");
-
-// s390x_vector-LABEL: v0_f64x2:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_f64x2, f64x2, "v0", "vlr");
-
-// s390x_vector-LABEL: v0_i32:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_i32, i32, "v0", "vlr");
-
-// s390x_vector-LABEL: v0_i64:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_i64, i64, "v0", "vlr");
-
-// s390x_vector-LABEL: v0_i128:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_i128, i128, "v0", "vlr");
-
-// s390x_vector-LABEL: v0_f32:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_f32, f32, "v0", "vlr");
-
-// s390x_vector-LABEL: v0_f64:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_f64, f64, "v0", "vlr");
-
-// s390x_vector-LABEL: v0_f128:
-// s390x_vector: #APP
-// s390x_vector: vlr %v0, %v0
-// s390x_vector: #NO_APP
-#[cfg(s390x_vector)]
-check_reg!(v0_f128, f128, "v0", "vlr");
diff --git a/tests/assembly/asm/sparc-types.rs b/tests/assembly/asm/sparc-types.rs
deleted file mode 100644
index 49cc377cd95..00000000000
--- a/tests/assembly/asm/sparc-types.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-//@ add-core-stubs
-//@ revisions: sparc sparcv8plus sparc64
-//@ assembly-output: emit-asm
-//@[sparc] compile-flags: --target sparc-unknown-none-elf
-//@[sparc] needs-llvm-components: sparc
-//@[sparcv8plus] compile-flags: --target sparc-unknown-linux-gnu
-//@[sparcv8plus] needs-llvm-components: sparc
-//@[sparc64] compile-flags: --target sparc64-unknown-linux-gnu
-//@[sparc64] needs-llvm-components: sparc
-//@ compile-flags: -Zmerge-functions=disabled
-
-#![feature(no_core, asm_experimental_arch)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register, non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *const i32;
-
-extern "C" {
-    fn extern_func();
-    static extern_static: u8;
-}
-
-macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => {
-    #[no_mangle]
-    pub unsafe fn $func(x: $ty) -> $ty {
-        let y;
-        asm!(concat!($mov," {}, {}"), in($class) x, out($class) y);
-        y
-    }
-};}
-
-macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => {
-    #[no_mangle]
-    pub unsafe fn $func(x: $ty) -> $ty {
-        let y;
-        asm!(concat!($mov, " %", $reg, ", %", $reg), in($reg) x, lateout($reg) y);
-        y
-    }
-};}
-
-// CHECK-LABEL: sym_fn_32:
-// CHECK: !APP
-// CHECK-NEXT: call extern_func
-// CHECK-NEXT: !NO_APP
-#[no_mangle]
-pub unsafe fn sym_fn_32() {
-    asm!("call {}", sym extern_func);
-}
-
-// CHECK-LABEL: sym_static:
-// CHECK: !APP
-// CHECK-NEXT: call extern_static
-// CHECK-NEXT: !NO_APP
-#[no_mangle]
-pub unsafe fn sym_static() {
-    asm!("call {}", sym extern_static);
-}
-
-// CHECK-LABEL: reg_i8:
-// CHECK: !APP
-// CHECK-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}}
-// CHECK-NEXT: !NO_APP
-check!(reg_i8, i8, reg, "mov");
-
-// CHECK-LABEL: reg_i16:
-// CHECK: !APP
-// CHECK-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}}
-// CHECK-NEXT: !NO_APP
-check!(reg_i16, i16, reg, "mov");
-
-// CHECK-LABEL: reg_i32:
-// CHECK: !APP
-// CHECK-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}}
-// CHECK-NEXT: !NO_APP
-check!(reg_i32, i32, reg, "mov");
-
-// FIXME: should be allowed for sparcv8plus but not yet supported in LLVM
-// sparc64-LABEL: reg_i64:
-// sparc64: !APP
-// sparc64-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}}
-// sparc64-NEXT: !NO_APP
-#[cfg(sparc64)]
-check!(reg_i64, i64, reg, "mov");
-
-// CHECK-LABEL: reg_ptr:
-// CHECK: !APP
-// CHECK-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}}
-// CHECK-NEXT: !NO_APP
-check!(reg_ptr, ptr, reg, "mov");
-
-// CHECK-LABEL: o0_i8:
-// CHECK: !APP
-// CHECK-NEXT: mov %o0, %o0
-// CHECK-NEXT: !NO_APP
-check_reg!(o0_i8, i8, "o0", "mov");
-
-// CHECK-LABEL: o0_i16:
-// CHECK: !APP
-// CHECK-NEXT: mov %o0, %o0
-// CHECK-NEXT: !NO_APP
-check_reg!(o0_i16, i16, "o0", "mov");
-
-// CHECK-LABEL: o0_i32:
-// CHECK: !APP
-// CHECK-NEXT: mov %o0, %o0
-// CHECK-NEXT: !NO_APP
-check_reg!(o0_i32, i32, "o0", "mov");
-
-// FIXME: should be allowed for sparcv8plus but not yet supported in LLVM
-// sparc64-LABEL: o0_i64:
-// sparc64: !APP
-// sparc64-NEXT: mov %o0, %o0
-// sparc64-NEXT: !NO_APP
-#[cfg(sparc64)]
-check_reg!(o0_i64, i64, "o0", "mov");
-
-// CHECK-LABEL: r9_i8:
-// CHECK: !APP
-// CHECK-NEXT: mov %o1, %o1
-// CHECK-NEXT: !NO_APP
-check_reg!(r9_i8, i8, "r9", "mov");
-
-// CHECK-LABEL: r9_i16:
-// CHECK: !APP
-// CHECK-NEXT: mov %o1, %o1
-// CHECK-NEXT: !NO_APP
-check_reg!(r9_i16, i16, "r9", "mov");
-
-// CHECK-LABEL: r9_i32:
-// CHECK: !APP
-// CHECK-NEXT: mov %o1, %o1
-// CHECK-NEXT: !NO_APP
-check_reg!(r9_i32, i32, "r9", "mov");
-
-// FIXME: should be allowed for sparcv8plus but not yet supported in LLVM
-// sparc64-LABEL: r9_i64:
-// sparc64: !APP
-// sparc64-NEXT: mov %o1, %o1
-// sparc64-NEXT: !NO_APP
-#[cfg(sparc64)]
-check_reg!(r9_i64, i64, "r9", "mov");
diff --git a/tests/assembly/asm/wasm-types.rs b/tests/assembly/asm/wasm-types.rs
deleted file mode 100644
index 78e555c5317..00000000000
--- a/tests/assembly/asm/wasm-types.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target wasm32-unknown-unknown
-//@ needs-llvm-components: webassembly
-
-#![feature(no_core, asm_experimental_arch)]
-#![crate_type = "rlib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *mut u8;
-
-extern "C" {
-    fn extern_func();
-    static extern_static: u8;
-}
-
-// CHECK-LABEL: sym_fn:
-// CHECK: #APP
-// CHECK: call extern_func
-// CHECK: #NO_APP
-#[no_mangle]
-pub unsafe fn sym_fn() {
-    asm!("call {}", sym extern_func);
-}
-
-// CHECK-LABEL: sym_static
-// CHECK: #APP
-// CHECK: i32.const 42
-// CHECK: i32.store extern_static
-// CHECK: #NO_APP
-#[no_mangle]
-pub unsafe fn sym_static() {
-    asm!("
-        i32.const 42
-        i32.store {}
-    ", sym extern_static);
-}
-
-macro_rules! check {
-    ($func:ident $ty:ident $instr:literal) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!("local.get {}\n", $instr, "\nlocal.set {}"), in(local) x, out(local) y);
-            y
-        }
-    };
-}
-
-// CHECK-LABEL: i8_i32:
-// CHECK: #APP
-// CHECK: local.get {{[0-9]}}
-// CHECK: i32.clz
-// CHECK: local.set {{[0-9]}}
-// CHECK: #NO_APP
-check!(i8_i32 i8 "i32.clz");
-
-// CHECK-LABEL: i16_i32:
-// CHECK: #APP
-// CHECK: local.get {{[0-9]}}
-// CHECK: i32.clz
-// CHECK: local.set {{[0-9]}}
-// CHECK: #NO_APP
-check!(i16_i32 i16 "i32.clz");
-
-// CHECK-LABEL: i32_i32:
-// CHECK: #APP
-// CHECK: local.get {{[0-9]}}
-// CHECK: i32.clz
-// CHECK: local.set {{[0-9]}}
-// CHECK: #NO_APP
-check!(i32_i32 i32 "i32.clz");
-
-// CHECK-LABEL: i8_i64
-// CHECK: #APP
-// CHECK: local.get {{[0-9]}}
-// CHECK: i64.clz
-// CHECK: local.set {{[0-9]}}
-// CHECK: #NO_APP
-check!(i8_i64 i8 "i64.clz");
-
-// CHECK-LABEL: i16_i64
-// CHECK: #APP
-// CHECK: local.get {{[0-9]}}
-// CHECK: i64.clz
-// CHECK: local.set {{[0-9]}}
-// CHECK: #NO_APP
-check!(i16_i64 i16 "i64.clz");
-
-// CHECK-LABEL: i32_i64
-// CHECK: #APP
-// CHECK: local.get {{[0-9]}}
-// CHECK: i64.clz
-// CHECK: local.set {{[0-9]}}
-// CHECK: #NO_APP
-check!(i32_i64 i32 "i64.clz");
-
-// CHECK-LABEL: i64_i64
-// CHECK: #APP
-// CHECK: local.get {{[0-9]}}
-// CHECK: i64.clz
-// CHECK: local.set {{[0-9]}}
-// CHECK: #NO_APP
-check!(i64_i64 i64 "i64.clz");
-
-// CHECK-LABEL: f32_f32
-// CHECK: #APP
-// CHECK: local.get {{[0-9]}}
-// CHECK: f32.abs
-// CHECK: local.set {{[0-9]}}
-// CHECK: #NO_APP
-check!(f32_f32 f32 "f32.abs");
-
-// CHECK-LABEL: f64_f64
-// CHECK: #APP
-// CHECK: local.get {{[0-9]}}
-// CHECK: f64.abs
-// CHECK: local.set {{[0-9]}}
-// CHECK: #NO_APP
-check!(f64_f64 f64 "f64.abs");
-
-// CHECK-LABEL: i32_ptr
-// CHECK: #APP
-// CHECK: local.get {{[0-9]}}
-// CHECK: i32.eqz
-// CHECK: local.set {{[0-9]}}
-// CHECK: #NO_APP
-check!(i32_ptr ptr "i32.eqz");
diff --git a/tests/assembly/asm/x86-modifiers.rs b/tests/assembly/asm/x86-modifiers.rs
deleted file mode 100644
index 5f68e5c7317..00000000000
--- a/tests/assembly/asm/x86-modifiers.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x86_64 i686
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3 -C panic=abort
-//@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu
-//@[x86_64] needs-llvm-components: x86
-//@[i686] compile-flags: --target i686-unknown-linux-gnu
-//@[i686] needs-llvm-components: x86
-//@ compile-flags: -C llvm-args=--x86-asm-syntax=intel
-//@ compile-flags: -C target-feature=+avx512bw
-//@ compile-flags: -Zmerge-functions=disabled
-
-#![feature(no_core)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register)]
-
-extern crate minicore;
-use minicore::*;
-
-macro_rules! check {
-    ($func:ident $modifier:literal $reg:ident $mov:literal) => {
-        // -Copt-level=3 and extern "C" guarantee that the selected register is always ax/xmm0
-        #[no_mangle]
-        pub unsafe extern "C" fn $func() -> i32 {
-            let y;
-            asm!(concat!($mov, " {0:", $modifier, "}, {0:", $modifier, "}"), out($reg) y);
-            y
-        }
-    };
-}
-
-// CHECK-LABEL: reg:
-// CHECK: #APP
-// x86_64: mov rax, rax
-// i686: mov eax, eax
-// CHECK: #NO_APP
-check!(reg "" reg "mov");
-
-// x86_64-LABEL: reg_l:
-// x86_64: #APP
-// x86_64: mov al, al
-// x86_64: #NO_APP
-#[cfg(x86_64)]
-check!(reg_l "l" reg "mov");
-
-// CHECK-LABEL: reg_x:
-// CHECK: #APP
-// CHECK: mov ax, ax
-// CHECK: #NO_APP
-check!(reg_x "x" reg "mov");
-
-// CHECK-LABEL: reg_e:
-// CHECK: #APP
-// CHECK: mov eax, eax
-// CHECK: #NO_APP
-check!(reg_e "e" reg "mov");
-
-// x86_64-LABEL: reg_r:
-// x86_64: #APP
-// x86_64: mov rax, rax
-// x86_64: #NO_APP
-#[cfg(x86_64)]
-check!(reg_r "r" reg "mov");
-
-// CHECK-LABEL: reg_abcd:
-// CHECK: #APP
-// x86_64: mov rax, rax
-// i686: mov eax, eax
-// CHECK: #NO_APP
-check!(reg_abcd "" reg_abcd "mov");
-
-// CHECK-LABEL: reg_abcd_l:
-// CHECK: #APP
-// CHECK: mov al, al
-// CHECK: #NO_APP
-check!(reg_abcd_l "l" reg_abcd "mov");
-
-// CHECK-LABEL: reg_abcd_h:
-// CHECK: #APP
-// CHECK: mov ah, ah
-// CHECK: #NO_APP
-check!(reg_abcd_h "h" reg_abcd "mov");
-
-// CHECK-LABEL: reg_abcd_x:
-// CHECK: #APP
-// CHECK: mov ax, ax
-// CHECK: #NO_APP
-check!(reg_abcd_x "x" reg_abcd "mov");
-
-// CHECK-LABEL: reg_abcd_e:
-// CHECK: #APP
-// CHECK: mov eax, eax
-// CHECK: #NO_APP
-check!(reg_abcd_e "e" reg_abcd "mov");
-
-// x86_64-LABEL: reg_abcd_r:
-// x86_64: #APP
-// x86_64: mov rax, rax
-// x86_64: #NO_APP
-#[cfg(x86_64)]
-check!(reg_abcd_r "r" reg_abcd "mov");
-
-// CHECK-LABEL: xmm_reg
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check!(xmm_reg "" xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_x
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check!(xmm_reg_x "x" xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_y
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check!(xmm_reg_y "y" xmm_reg "vmovaps");
-
-// CHECK-LABEL: xmm_reg_z
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check!(xmm_reg_z "z" xmm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg
-// CHECK: #APP
-// CHECK: movaps ymm0, ymm0
-// CHECK: #NO_APP
-check!(ymm_reg "" ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_x
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check!(ymm_reg_x "x" ymm_reg "movaps");
-
-// CHECK-LABEL: ymm_reg_y
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check!(ymm_reg_y "y" ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_z
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check!(ymm_reg_z "z" ymm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg
-// CHECK: #APP
-// CHECK: movaps zmm0, zmm0
-// CHECK: #NO_APP
-check!(zmm_reg "" zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_x
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check!(zmm_reg_x "x" zmm_reg "movaps");
-
-// CHECK-LABEL: zmm_reg_y
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check!(zmm_reg_y "y" zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_z
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check!(zmm_reg_z "z" zmm_reg "vmovaps");
-
-// Note: we don't have any way of ensuring that k1 is actually the register
-// chosen by the register allocator, so this check may fail if a different
-// register is chosen.
-
-// CHECK-LABEL: kreg:
-// CHECK: #APP
-// CHECK: kmovb k1, k1
-// CHECK: #NO_APP
-check!(kreg "" kreg "kmovb");
diff --git a/tests/assembly/asm/x86-types.rs b/tests/assembly/asm/x86-types.rs
deleted file mode 100644
index 6120ed0d532..00000000000
--- a/tests/assembly/asm/x86-types.rs
+++ /dev/null
@@ -1,1095 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x86_64 i686
-//@ assembly-output: emit-asm
-//@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu
-//@[x86_64] needs-llvm-components: x86
-//@[i686] compile-flags: --target i686-unknown-linux-gnu
-//@[i686] needs-llvm-components: x86
-//@ compile-flags: -C llvm-args=--x86-asm-syntax=intel
-//@ compile-flags: -C target-feature=+avx512bw
-//@ compile-flags: -Zmerge-functions=disabled
-
-#![feature(no_core, repr_simd, f16, f128)]
-#![crate_type = "rlib"]
-#![no_core]
-#![allow(asm_sub_register, non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-type ptr = *mut u8;
-
-#[repr(simd)]
-pub struct i8x16([i8; 16]);
-#[repr(simd)]
-pub struct i16x8([i16; 8]);
-#[repr(simd)]
-pub struct i32x4([i32; 4]);
-#[repr(simd)]
-pub struct i64x2([i64; 2]);
-#[repr(simd)]
-pub struct f16x8([f16; 8]);
-#[repr(simd)]
-pub struct f32x4([f32; 4]);
-#[repr(simd)]
-pub struct f64x2([f64; 2]);
-
-#[repr(simd)]
-pub struct i8x32([i8; 32]);
-#[repr(simd)]
-pub struct i16x16([i16; 16]);
-#[repr(simd)]
-pub struct i32x8([i32; 8]);
-#[repr(simd)]
-pub struct i64x4([i64; 4]);
-#[repr(simd)]
-pub struct f16x16([f16; 16]);
-#[repr(simd)]
-pub struct f32x8([f32; 8]);
-#[repr(simd)]
-pub struct f64x4([f64; 4]);
-
-#[repr(simd)]
-pub struct i8x64([i8; 64]);
-#[repr(simd)]
-pub struct i16x32([i16; 32]);
-#[repr(simd)]
-pub struct i32x16([i32; 16]);
-#[repr(simd)]
-pub struct i64x8([i64; 8]);
-#[repr(simd)]
-pub struct f16x32([f16; 32]);
-#[repr(simd)]
-pub struct f32x16([f32; 16]);
-#[repr(simd)]
-pub struct f64x8([f64; 8]);
-
-macro_rules! impl_copy {
-    ($($ty:ident)*) => {
-        $(
-            impl Copy for $ty {}
-        )*
-    };
-}
-
-impl_copy!(
-    i8x16 i16x8 i32x4 i64x2 f16x8 f32x4 f64x2
-    i8x32 i16x16 i32x8 i64x4 f16x16 f32x8 f64x4
-    i8x64 i16x32 i32x16 i64x8 f16x32 f32x16 f64x8
-);
-
-extern "C" {
-    fn extern_func();
-    static extern_static: u8;
-}
-
-// CHECK-LABEL: sym_fn:
-// CHECK: #APP
-// CHECK: call extern_func
-// CHECK: #NO_APP
-#[no_mangle]
-pub unsafe fn sym_fn() {
-    asm!("call {}", sym extern_func);
-}
-
-// CHECK-LABEL: sym_static:
-// CHECK: #APP
-// CHECK: mov al, byte ptr [extern_static]
-// CHECK: #NO_APP
-#[no_mangle]
-pub unsafe fn sym_static() {
-    asm!("mov al, byte ptr [{}]", sym extern_static);
-}
-
-macro_rules! check {
-    ($func:ident $ty:ident $class:ident $mov:literal) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!($mov, " {}, {}"), lateout($class) y, in($class) x);
-            y
-        }
-    };
-}
-
-macro_rules! check_reg {
-    ($func:ident $ty:ident $reg:tt $mov:literal) => {
-        #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
-            let y;
-            asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
-            y
-        }
-    };
-}
-
-// CHECK-LABEL: reg_i16:
-// CHECK: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i16 i16 reg "mov");
-
-// CHECK-LABEL: reg_f16:
-// CHECK: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f16 f16 reg "mov");
-
-// CHECK-LABEL: reg_i32:
-// CHECK: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_i32 i32 reg "mov");
-
-// CHECK-LABEL: reg_f32:
-// CHECK: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_f32 f32 reg "mov");
-
-// x86_64-LABEL: reg_i64:
-// x86_64: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// x86_64: #NO_APP
-#[cfg(x86_64)]
-check!(reg_i64 i64 reg "mov");
-
-// x86_64-LABEL: reg_f64:
-// x86_64: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// x86_64: #NO_APP
-#[cfg(x86_64)]
-check!(reg_f64 f64 reg "mov");
-
-// CHECK-LABEL: reg_ptr:
-// CHECK: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_ptr ptr reg "mov");
-
-// CHECK-LABEL: reg_abcd_i16:
-// CHECK: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_abcd_i16 i16 reg_abcd "mov");
-
-// CHECK-LABEL: reg_abcd_f16:
-// CHECK: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_abcd_f16 f16 reg_abcd "mov");
-
-// CHECK-LABEL: reg_abcd_i32:
-// CHECK: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_abcd_i32 i32 reg_abcd "mov");
-
-// CHECK-LABEL: reg_abcd_f32:
-// CHECK: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_abcd_f32 f32 reg_abcd "mov");
-
-// x86_64-LABEL: reg_abcd_i64:
-// x86_64: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// x86_64: #NO_APP
-#[cfg(x86_64)]
-check!(reg_abcd_i64 i64 reg_abcd "mov");
-
-// x86_64-LABEL: reg_abcd_f64:
-// x86_64: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// x86_64: #NO_APP
-#[cfg(x86_64)]
-check!(reg_abcd_f64 f64 reg_abcd "mov");
-
-// CHECK-LABEL: reg_abcd_ptr:
-// CHECK: #APP
-// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}}
-// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_abcd_ptr ptr reg_abcd "mov");
-
-// CHECK-LABEL: reg_byte:
-// CHECK: #APP
-// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: #NO_APP
-check!(reg_byte i8 reg_byte "mov");
-
-// CHECK-LABEL: xmm_reg_f16:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_f16 f16 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_i32:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_i32 i32 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_f32:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_f32 f32 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_i64:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_i64 i64 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_f64:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_f64 f64 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_f128:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_f128 f128 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_ptr:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_ptr ptr xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_i8x16:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_i8x16 i8x16 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_i16x8:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_i16x8 i16x8 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_i32x4:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_i32x4 i32x4 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_i64x2:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_i64x2 i64x2 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_f16x8:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_f16x8 f16x8 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_f32x4:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_f32x4 f32x4 xmm_reg "movaps");
-
-// CHECK-LABEL: xmm_reg_f64x2:
-// CHECK: #APP
-// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(xmm_reg_f64x2 f64x2 xmm_reg "movaps");
-
-// CHECK-LABEL: ymm_reg_f16:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_f16 f16 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_i32:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_i32 i32 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_f32:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_f32 f32 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_i64:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_i64 i64 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_f64:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_f64 f64 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_f128:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_f128 f128 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_ptr:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_ptr ptr ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_i8x16:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_i8x16 i8x16 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_i16x8:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_i16x8 i16x8 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_i32x4:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_i32x4 i32x4 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_i64x2:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_i64x2 i64x2 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_f16x8:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_f16x8 f16x8 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_f32x4:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_f32x4 f32x4 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_f64x2:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_f64x2 f64x2 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_i8x32:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_i8x32 i8x32 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_i16x16:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_i16x16 i16x16 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_i32x8:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_i32x8 i32x8 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_i64x4:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_i64x4 i64x4 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_f16x16:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_f16x16 f16x16 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_f32x8:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_f32x8 f32x8 ymm_reg "vmovaps");
-
-// CHECK-LABEL: ymm_reg_f64x4:
-// CHECK: #APP
-// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(ymm_reg_f64x4 f64x4 ymm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f16:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f16 f16 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i32:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i32 i32 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f32:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f32 f32 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i64:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i64 i64 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f64:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f64 f64 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f128:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f128 f128 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_ptr:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_ptr ptr zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i8x16:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i8x16 i8x16 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i16x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i16x8 i16x8 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i32x4:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i32x4 i32x4 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i64x2:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i64x2 i64x2 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f16x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f16x8 f16x8 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f32x4:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f32x4 f32x4 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f64x2:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f64x2 f64x2 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i8x32:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i8x32 i8x32 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i16x16:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i16x16 i16x16 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i32x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i32x8 i32x8 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i64x4:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i64x4 i64x4 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f16x16:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f16x16 f16x16 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f32x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f32x8 f32x8 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f64x4:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f64x4 f64x4 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i8x64:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i8x64 i8x64 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i16x32:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i16x32 i16x32 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i32x16:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i32x16 i32x16 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_i64x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_i64x8 i64x8 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f16x32:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f16x32 f16x32 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f32x16:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f32x16 f32x16 zmm_reg "vmovaps");
-
-// CHECK-LABEL: zmm_reg_f64x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}}
-// CHECK: #NO_APP
-check!(zmm_reg_f64x8 f64x8 zmm_reg "vmovaps");
-
-// CHECK-LABEL: kreg_i8:
-// CHECK: #APP
-// CHECK: kmovb k{{[0-9]+}}, k{{[0-9]+}}
-// CHECK: #NO_APP
-check!(kreg_i8 i8 kreg "kmovb");
-
-// CHECK-LABEL: kreg_i16:
-// CHECK: #APP
-// CHECK: kmovw k{{[0-9]+}}, k{{[0-9]+}}
-// CHECK: #NO_APP
-check!(kreg_i16 i16 kreg "kmovw");
-
-// CHECK-LABEL: kreg_i32:
-// CHECK: #APP
-// CHECK: kmovd k{{[0-9]+}}, k{{[0-9]+}}
-// CHECK: #NO_APP
-check!(kreg_i32 i32 kreg "kmovd");
-
-// CHECK-LABEL: kreg_i64:
-// CHECK: #APP
-// CHECK: kmovq k{{[0-9]+}}, k{{[0-9]+}}
-// CHECK: #NO_APP
-check!(kreg_i64 i64 kreg "kmovq");
-
-// CHECK-LABEL: kreg_ptr:
-// CHECK: #APP
-// CHECK: kmovq k{{[0-9]+}}, k{{[0-9]+}}
-// CHECK: #NO_APP
-check!(kreg_ptr ptr kreg "kmovq");
-
-// CHECK-LABEL: eax_i16:
-// CHECK: #APP
-// CHECK: mov eax, eax
-// CHECK: #NO_APP
-check_reg!(eax_i16 i16 "eax" "mov");
-
-// CHECK-LABEL: eax_f16:
-// CHECK: #APP
-// CHECK: mov eax, eax
-// CHECK: #NO_APP
-check_reg!(eax_f16 f16 "eax" "mov");
-
-// CHECK-LABEL: eax_i32:
-// CHECK: #APP
-// CHECK: mov eax, eax
-// CHECK: #NO_APP
-check_reg!(eax_i32 i32 "eax" "mov");
-
-// CHECK-LABEL: eax_f32:
-// CHECK: #APP
-// CHECK: mov eax, eax
-// CHECK: #NO_APP
-check_reg!(eax_f32 f32 "eax" "mov");
-
-// x86_64-LABEL: eax_i64:
-// x86_64: #APP
-// x86_64: mov eax, eax
-// x86_64: #NO_APP
-#[cfg(x86_64)]
-check_reg!(eax_i64 i64 "eax" "mov");
-
-// x86_64-LABEL: eax_f64:
-// x86_64: #APP
-// x86_64: mov eax, eax
-// x86_64: #NO_APP
-#[cfg(x86_64)]
-check_reg!(eax_f64 f64 "eax" "mov");
-
-// CHECK-LABEL: eax_ptr:
-// CHECK: #APP
-// CHECK: mov eax, eax
-// CHECK: #NO_APP
-check_reg!(eax_ptr ptr "eax" "mov");
-
-// i686-LABEL: ah_byte:
-// i686: #APP
-// i686: mov ah, ah
-// i686: #NO_APP
-#[cfg(i686)]
-check_reg!(ah_byte i8 "ah" "mov");
-
-// CHECK-LABEL: xmm0_f16:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_f16 f16 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_i32:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_i32 i32 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_f32:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_f32 f32 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_i64:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_i64 i64 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_f64:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_f64 f64 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_f128:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_f128 f128 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_ptr:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_ptr ptr "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_i8x16:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_i8x16 i8x16 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_i16x8:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_i16x8 i16x8 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_i32x4:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_i32x4 i32x4 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_i64x2:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_i64x2 i64x2 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_f16x8:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_f16x8 f16x8 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_f32x4:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_f32x4 f32x4 "xmm0" "movaps");
-
-// CHECK-LABEL: xmm0_f64x2:
-// CHECK: #APP
-// CHECK: movaps xmm0, xmm0
-// CHECK: #NO_APP
-check_reg!(xmm0_f64x2 f64x2 "xmm0" "movaps");
-
-// CHECK-LABEL: ymm0_f16:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_f16 f16 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_i32:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_i32 i32 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_f32:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_f32 f32 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_i64:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_i64 i64 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_f64:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_f64 f64 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_f128:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_f128 f128 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_ptr:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_ptr ptr "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_i8x16:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_i8x16 i8x16 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_i16x8:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_i16x8 i16x8 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_i32x4:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_i32x4 i32x4 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_i64x2:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_i64x2 i64x2 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_f16x8:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_f16x8 f16x8 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_f32x4:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_f32x4 f32x4 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_f64x2:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_f64x2 f64x2 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_i8x32:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_i8x32 i8x32 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_i16x16:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_i16x16 i16x16 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_i32x8:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_i32x8 i32x8 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_i64x4:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_i64x4 i64x4 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_f16x16:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_f16x16 f16x16 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_f32x8:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_f32x8 f32x8 "ymm0" "vmovaps");
-
-// CHECK-LABEL: ymm0_f64x4:
-// CHECK: #APP
-// CHECK: vmovaps ymm0, ymm0
-// CHECK: #NO_APP
-check_reg!(ymm0_f64x4 f64x4 "ymm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f16:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f16 f16 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i32:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i32 i32 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f32:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f32 f32 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i64:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i64 i64 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f64:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f64 f64 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f128:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f128 f128 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_ptr:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_ptr ptr "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i8x16:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i8x16 i8x16 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i16x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i16x8 i16x8 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i32x4:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i32x4 i32x4 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i64x2:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i64x2 i64x2 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f16x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f16x8 f16x8 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f32x4:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f32x4 f32x4 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f64x2:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f64x2 f64x2 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i8x32:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i8x32 i8x32 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i16x16:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i16x16 i16x16 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i32x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i32x8 i32x8 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i64x4:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i64x4 i64x4 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f16x16:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f16x16 f16x16 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f32x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f32x8 f32x8 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f64x4:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f64x4 f64x4 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i8x64:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i8x64 i8x64 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i16x32:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i16x32 i16x32 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i32x16:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i32x16 i32x16 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_i64x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_i64x8 i64x8 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f16x32:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f16x32 f16x32 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f32x16:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f32x16 f32x16 "zmm0" "vmovaps");
-
-// CHECK-LABEL: zmm0_f64x8:
-// CHECK: #APP
-// CHECK: vmovaps zmm0, zmm0
-// CHECK: #NO_APP
-check_reg!(zmm0_f64x8 f64x8 "zmm0" "vmovaps");
-
-// CHECK-LABEL: k1_i8:
-// CHECK: #APP
-// CHECK: kmovb k1, k1
-// CHECK: #NO_APP
-check_reg!(k1_i8 i8 "k1" "kmovb");
-
-// CHECK-LABEL: k1_i16:
-// CHECK: #APP
-// CHECK: kmovw k1, k1
-// CHECK: #NO_APP
-check_reg!(k1_i16 i16 "k1" "kmovw");
-
-// CHECK-LABEL: k1_i32:
-// CHECK: #APP
-// CHECK: kmovd k1, k1
-// CHECK: #NO_APP
-check_reg!(k1_i32 i32 "k1" "kmovd");
-
-// CHECK-LABEL: k1_i64:
-// CHECK: #APP
-// CHECK: kmovq k1, k1
-// CHECK: #NO_APP
-check_reg!(k1_i64 i64 "k1" "kmovq");
-
-// CHECK-LABEL: k1_ptr:
-// CHECK: #APP
-// CHECK: kmovq k1, k1
-// CHECK: #NO_APP
-check_reg!(k1_ptr ptr "k1" "kmovq");
diff --git a/tests/assembly/auxiliary/breakpoint-panic-handler.rs b/tests/assembly/auxiliary/breakpoint-panic-handler.rs
deleted file mode 100644
index d54c1181e1a..00000000000
--- a/tests/assembly/auxiliary/breakpoint-panic-handler.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#![feature(core_intrinsics)]
-#![no_std]
-
-#[panic_handler]
-unsafe fn breakpoint_panic_handler(_: &::core::panic::PanicInfo) -> ! {
-    core::intrinsics::breakpoint();
-    core::hint::unreachable_unchecked();
-}
diff --git a/tests/assembly/auxiliary/dwarf-mixed-versions-lto-aux.rs b/tests/assembly/auxiliary/dwarf-mixed-versions-lto-aux.rs
deleted file mode 100644
index 257608f881f..00000000000
--- a/tests/assembly/auxiliary/dwarf-mixed-versions-lto-aux.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-//@ compile-flags: -g --crate-type=rlib -Cdwarf-version=4
-
-pub fn check_is_even(number: &u64) -> bool {
-    number % 2 == 0
-}
diff --git a/tests/assembly/auxiliary/non-inline-dependency.rs b/tests/assembly/auxiliary/non-inline-dependency.rs
deleted file mode 100644
index 57f3ee87cdb..00000000000
--- a/tests/assembly/auxiliary/non-inline-dependency.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-#![no_std]
-#![deny(warnings)]
-
-#[inline(never)]
-#[no_mangle]
-pub fn wrapping_external_fn(a: u32) -> u32 {
-    a.wrapping_mul(a)
-}
-
-#[inline(never)]
-#[no_mangle]
-pub fn panicking_external_fn(a: u32) -> u32 {
-    a * a
-}
diff --git a/tests/assembly/breakpoint.rs b/tests/assembly/breakpoint.rs
deleted file mode 100644
index e0cc2d1eebb..00000000000
--- a/tests/assembly/breakpoint.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ revisions: aarch64 x86_64
-//@ assembly-output: emit-asm
-//@[aarch64] only-aarch64
-//@[x86_64] only-x86_64
-
-#![feature(breakpoint)]
-#![crate_type = "lib"]
-
-// CHECK-LABEL: use_bp
-// aarch64: brk #0xf000
-// x86_64: int3
-pub fn use_bp() {
-    core::arch::breakpoint();
-}
diff --git a/tests/assembly/closure-inherit-target-feature.rs b/tests/assembly/closure-inherit-target-feature.rs
deleted file mode 100644
index 069204bbd34..00000000000
--- a/tests/assembly/closure-inherit-target-feature.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//@ only-x86_64
-//@ ignore-sgx Tests incompatible with LVI mitigations
-//@ assembly-output: emit-asm
-// make sure the feature is not enabled at compile-time
-//@ compile-flags: -C opt-level=3 -C target-feature=-sse4.1 -C llvm-args=-x86-asm-syntax=intel
-
-#![crate_type = "rlib"]
-
-use std::arch::x86_64::{__m128, _mm_blend_ps};
-
-// Use an explicit return pointer to prevent tail call optimization.
-#[no_mangle]
-pub unsafe fn sse41_blend_nofeature(x: __m128, y: __m128, ret: *mut __m128) {
-    let f = {
-        // check that _mm_blend_ps is not being inlined into the closure
-        // CHECK-LABEL: {{sse41_blend_nofeature.*closure.*:}}
-        // CHECK-NOT: blendps
-        // CHECK: {{call .*_mm_blend_ps.*}}
-        // CHECK-NOT: blendps
-        // CHECK: ret
-        #[inline(never)]
-        |x, y, ret: *mut __m128| unsafe { *ret = _mm_blend_ps(x, y, 0b0101) }
-    };
-    f(x, y, ret);
-}
-
-#[no_mangle]
-#[target_feature(enable = "sse4.1")]
-pub fn sse41_blend_noinline(x: __m128, y: __m128) -> __m128 {
-    let f = {
-        // check that _mm_blend_ps is being inlined into the closure
-        // CHECK-LABEL: {{sse41_blend_noinline.*closure.*:}}
-        // CHECK-NOT: _mm_blend_ps
-        // CHECK: blendps
-        // CHECK-NOT: _mm_blend_ps
-        // CHECK: ret
-        #[inline(never)]
-        |x, y| unsafe { _mm_blend_ps(x, y, 0b0101) }
-    };
-    f(x, y)
-}
-
-#[no_mangle]
-#[target_feature(enable = "sse4.1")]
-pub fn sse41_blend_doinline(x: __m128, y: __m128) -> __m128 {
-    // check that the closure and _mm_blend_ps are being inlined into the function
-    // CHECK-LABEL: sse41_blend_doinline:
-    // CHECK-NOT: {{sse41_blend_doinline.*closure.*}}
-    // CHECK-NOT: _mm_blend_ps
-    // CHECK: blendps
-    // CHECK-NOT: {{sse41_blend_doinline.*closure.*}}
-    // CHECK-NOT: _mm_blend_ps
-    // CHECK: ret
-    let f = {
-        #[inline]
-        |x, y| unsafe { _mm_blend_ps(x, y, 0b0101) }
-    };
-    f(x, y)
-}
diff --git a/tests/assembly/cmse.rs b/tests/assembly/cmse.rs
deleted file mode 100644
index a68ee99eac6..00000000000
--- a/tests/assembly/cmse.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-//@ add-core-stubs
-//@ revisions: hard soft
-//@ assembly-output: emit-asm
-//@ [hard] compile-flags: --target thumbv8m.main-none-eabihf --crate-type lib -Copt-level=1
-//@ [soft] compile-flags: --target thumbv8m.main-none-eabi --crate-type lib -Copt-level=1
-//@ [hard] needs-llvm-components: arm
-//@ [soft] needs-llvm-components: arm
-#![crate_type = "lib"]
-#![feature(abi_cmse_nonsecure_call, cmse_nonsecure_entry, no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: __acle_se_entry_point:
-// CHECK-NEXT: entry_point:
-//
-// Write return argument (two registers since 64bit integer)
-// CHECK: movs r0, #0
-// CHECK: movs r1, #0
-//
-// If we are using hard-float:
-// * Check if the float registers were touched (bit 3 in CONTROL)
-// hard: mrs     [[REG:r[0-9]+]], control
-// hard: tst.w   [[REG]], #8
-// hard: beq     [[LABEL:[\.a-zA-Z0-9_]+]]
-//
-// * If touched clear all float registers (d0..=d7)
-// hard: vmov    d0,
-// hard: vmov    d1,
-// hard: vmov    d2,
-// hard: vmov    d3,
-// hard: vmov    d4,
-// hard: vmov    d5,
-// hard: vmov    d6,
-// hard: vmov    d7,
-//
-// * If touched clear FPU status register
-// hard: vmrs    [[REG:r[0-9]+]], fpscr
-// hard: bic     [[REG]], [[REG]], #159
-// hard: bic     [[REG]], [[REG]], #4026531840
-// hard: vmsr    fpscr, [[REG]]
-// hard: [[LABEL]]:
-//
-// Clear all other registers that might have been used
-// CHECK: mov r2,
-// CHECK: mov r3,
-// CHECK: mov r12,
-//
-// Clear the flags
-// CHECK: msr apsr_nzcvq,
-//
-// Branch back to non-secure side
-// CHECK: bxns lr
-#[no_mangle]
-pub extern "cmse-nonsecure-entry" fn entry_point() -> i64 {
-    0
-}
-
-// NOTE for future codegen changes:
-// The specific register assignment is not important, however:
-// * all registers must be cleared before `blxns` is executed
-//     (either by writing arguments or any other value)
-// * the lowest bit on the address of the callee must be cleared
-// * the flags need to be overwritten
-// * `blxns` needs to be called with the callee address
-//     (with the lowest bit cleared)
-//
-// CHECK-LABEL: call_nonsecure
-// Save callee pointer
-// CHECK: mov r12, r0
-//
-// All arguments are written to (writes r0..=r3)
-// CHECK: movs r0, #0
-// CHECK: movs r1, #1
-// CHECK: movs r2, #2
-// CHECK: movs r3, #3
-//
-// Lowest bit gets cleared on callee address
-// CHECK: bic r12, r12, #1
-//
-// Ununsed registers get cleared (r4..=r11)
-// CHECK: mov r4,
-// CHECK: mov r5,
-// CHECK: mov r6,
-// CHECK: mov r7,
-// CHECK: mov r8,
-// CHECK: mov r9,
-// CHECK: mov r10,
-// CHECK: mov r11,
-//
-// Flags get cleared
-// CHECK: msr apsr_nzcvq,
-//
-// Call to non-secure
-// CHECK: blxns r12
-#[no_mangle]
-pub fn call_nonsecure(f: unsafe extern "cmse-nonsecure-call" fn(u32, u32, u32, u32) -> u64) -> u64 {
-    unsafe { f(0, 1, 2, 3) }
-}
diff --git a/tests/assembly/compiletest-self-test/use-minicore-no-run.rs b/tests/assembly/compiletest-self-test/use-minicore-no-run.rs
deleted file mode 100644
index 0e4f05c4b37..00000000000
--- a/tests/assembly/compiletest-self-test/use-minicore-no-run.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-//! `compiletest` self-test to check that `add-core-stubs` is incompatible with run pass modes.
-
-//@ add-core-stubs
-//@ run-pass
-//@ should-fail
diff --git a/tests/assembly/cstring-merging.rs b/tests/assembly/cstring-merging.rs
deleted file mode 100644
index 03688e0068b..00000000000
--- a/tests/assembly/cstring-merging.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// MIPS assembler uses the label prefix `$anon.` for local anonymous variables
-// other architectures (including ARM and x86-64) use the prefix `.Lanon.`
-//@ only-linux
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -Cllvm-args=-enable-global-merge=0
-//@ edition: 2024
-
-use std::ffi::CStr;
-
-// CHECK: .section .rodata.str1.{{[12]}},"aMS"
-// CHECK: {{(\.L|\$)}}anon.{{.+}}:
-// CHECK-NEXT: .asciz "foo"
-#[unsafe(no_mangle)]
-static CSTR: &[u8; 4] = b"foo\0";
-
-// CHECK-NOT: .section
-// CHECK: {{(\.L|\$)}}anon.{{.+}}:
-// CHECK-NEXT: .asciz "bar"
-#[unsafe(no_mangle)]
-pub fn cstr() -> &'static CStr {
-    c"bar"
-}
-
-// CHECK-NOT: .section
-// CHECK: {{(\.L|\$)}}anon.{{.+}}:
-// CHECK-NEXT: .asciz "baz"
-#[unsafe(no_mangle)]
-pub fn manual_cstr() -> &'static str {
-    "baz\0"
-}
diff --git a/tests/assembly/dwarf-mixed-versions-lto.rs b/tests/assembly/dwarf-mixed-versions-lto.rs
deleted file mode 100644
index 9910a6e2f5f..00000000000
--- a/tests/assembly/dwarf-mixed-versions-lto.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// This test ensures that if LTO occurs between crates with different DWARF versions, we
-// will choose the highest DWARF version for the final binary. This matches Clang's behavior.
-// Note: `.2byte` directive is used on MIPS.
-
-//@ only-linux
-//@ aux-build:dwarf-mixed-versions-lto-aux.rs
-//@ compile-flags: -C lto -g -Cdwarf-version=5
-//@ assembly-output: emit-asm
-//@ no-prefer-dynamic
-
-extern crate dwarf_mixed_versions_lto_aux;
-
-fn main() {
-    dwarf_mixed_versions_lto_aux::check_is_even(&0);
-}
-
-// CHECK: .section .debug_info
-// CHECK-NOT: {{\.(short|hword|2byte)}} 2
-// CHECK-NOT: {{\.(short|hword|2byte)}} 4
-// CHECK: {{\.(short|hword|2byte)}} 5
diff --git a/tests/assembly/dwarf4.rs b/tests/assembly/dwarf4.rs
deleted file mode 100644
index 03a388603b4..00000000000
--- a/tests/assembly/dwarf4.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Makes sure that `-C dwarf-version=4` causes `rustc` to emit DWARF version 4.
-//@ assembly-output: emit-asm
-//@ add-core-stubs
-//@ compile-flags: -g --target x86_64-unknown-linux-gnu -C dwarf-version=4 -Copt-level=0
-//@ needs-llvm-components: x86
-
-#![feature(no_core, lang_items)]
-#![crate_type = "rlib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn wibble() {}
-
-pub struct X;
-
-// CHECK: .section .debug_info
-// CHECK-NOT: .short 2
-// CHECK-NOT: .short 5
-// CHECK: .short 4
-// CHECK-NOT: .section .debug_pubnames
-// CHECK-NOT: .section .debug_pubtypes
diff --git a/tests/assembly/dwarf5.rs b/tests/assembly/dwarf5.rs
deleted file mode 100644
index 9bd92cc0d09..00000000000
--- a/tests/assembly/dwarf5.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Makes sure that `-C dwarf-version=5` causes `rustc` to emit DWARF version 5.
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: -g --target x86_64-unknown-linux-gnu -C dwarf-version=5 -Copt-level=0
-//@ needs-llvm-components: x86
-
-#![feature(no_core, lang_items)]
-#![crate_type = "rlib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn wibble() {}
-
-// CHECK: .section .debug_info
-// CHECK-NOT: .short 2
-// CHECK-NOT: .short 4
-// CHECK: .short 5
-// CHECK: .section .debug_names
diff --git a/tests/assembly/emit-intel-att-syntax.rs b/tests/assembly/emit-intel-att-syntax.rs
deleted file mode 100644
index 7b479a0f79e..00000000000
--- a/tests/assembly/emit-intel-att-syntax.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-//@ assembly-output: emit-asm
-//@ revisions: att intel
-//@ [att] compile-flags: -Cllvm-args=-x86-asm-syntax=att
-//@ [intel] compile-flags: -Cllvm-args=-x86-asm-syntax=intel
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: naked_att:
-// intel-CHECK: mov rax, qword ptr [rdi]
-// intel-CHECK: ret
-// att-CHECK: movq (%rdi), %rax
-// att-CHECK: retq
-
-#[unsafe(naked)]
-#[unsafe(no_mangle)]
-extern "sysv64" fn naked_att() {
-    std::arch::naked_asm!(
-        "
-        movq (%rdi), %rax
-        retq
-        ",
-        options(att_syntax),
-    );
-}
-
-// CHECK-LABEL: naked_intel:
-// intel-CHECK: mov rax, rdi
-// intel-CHECK: ret
-// att-CHECK: movq (%rdi), %rax
-// att-CHECK: retq
-
-#[unsafe(naked)]
-#[unsafe(no_mangle)]
-extern "sysv64" fn naked_intel() {
-    std::arch::naked_asm!(
-        "
-        mov rax, rdi
-        ret
-        ",
-        options(),
-    );
-}
-
-// CHECK-LABEL: global_att:
-// intel-CHECK: mov rax, rdi
-// intel-CHECK: ret
-// att-CHECK: movq (%rdi), %rax
-// att-CHECK: retq
-
-core::arch::global_asm!(
-    "
-    .globl global_att
-    global_att:
-        movq (%rdi), %rax
-        retq
-    ",
-    options(att_syntax),
-);
-
-// CHECK-LABEL: global_intel:
-// intel-CHECK: mov rax, rdi
-// intel-CHECK: ret
-// att-CHECK: movq (%rdi), %rax
-// att-CHECK: retq
-
-core::arch::global_asm!(
-    "
-    .globl global_intel
-    global_intel:
-        mov rax, rdi
-        ret
-    ",
-    options(),
-);
diff --git a/tests/assembly/is_aligned.rs b/tests/assembly/is_aligned.rs
deleted file mode 100644
index ab8f7dea808..00000000000
--- a/tests/assembly/is_aligned.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//@ assembly-output: emit-asm
-//@ only-x86_64
-//@ ignore-sgx
-//@ revisions: opt-speed opt-size
-//@ [opt-speed] compile-flags: -Copt-level=2 -Cdebug-assertions=no
-//@ [opt-size] compile-flags: -Copt-level=s -Cdebug-assertions=no
-#![crate_type = "rlib"]
-#![feature(core_intrinsics)]
-#![feature(pointer_is_aligned_to)]
-
-// CHECK-LABEL: is_aligned_to_unchecked
-// CHECK: decq
-// CHECK-NEXT: testq
-// CHECK-NEXT: sete
-// CHECK: retq
-#[no_mangle]
-pub unsafe fn is_aligned_to_unchecked(ptr: *const u8, align: usize) -> bool {
-    unsafe { std::intrinsics::assume(align.is_power_of_two()) }
-    ptr.is_aligned_to(align)
-}
-
-// CHECK-LABEL: is_aligned_1
-// CHECK: movb $1
-// CHECK: retq
-#[no_mangle]
-pub fn is_aligned_1(ptr: *const u8) -> bool {
-    ptr.is_aligned()
-}
-
-// CHECK-LABEL: is_aligned_2
-// CHECK: testb $1
-// CHECK-NEXT: sete
-// CHECK: retq
-#[no_mangle]
-pub fn is_aligned_2(ptr: *const u16) -> bool {
-    ptr.is_aligned()
-}
-
-// CHECK-LABEL: is_aligned_4
-// CHECK: testb $3
-// CHECK-NEXT: sete
-// CHECK: retq
-#[no_mangle]
-pub fn is_aligned_4(ptr: *const u32) -> bool {
-    ptr.is_aligned()
-}
-
-// CHECK-LABEL: is_aligned_8
-// CHECK: testb $7
-// CHECK-NEXT: sete
-// CHECK: retq
-#[no_mangle]
-pub fn is_aligned_8(ptr: *const u64) -> bool {
-    ptr.is_aligned()
-}
diff --git a/tests/assembly/issue-83585-small-pod-struct-equality.rs b/tests/assembly/issue-83585-small-pod-struct-equality.rs
deleted file mode 100644
index 14bec1337f0..00000000000
--- a/tests/assembly/issue-83585-small-pod-struct-equality.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-type T = u8;
-type T1 = (T, T, T, T, T, T, T, T);
-
-// CHECK-LABEL: foo1a
-// CHECK: cmpq
-// CHECK-NEXT: sete
-// CHECK-NEXT: {{retq|popq}}
-#[no_mangle]
-pub fn foo1a(a: T1, b: T1) -> bool {
-    a == b
-}
-
-// CHECK-LABEL: foo1b
-// CHECK: movq
-// CHECK: cmpq
-// CHECK-NEXT: sete
-// CHECK-NEXT: {{retq|popq}}
-#[no_mangle]
-pub fn foo1b(a: &T1, b: &T1) -> bool {
-    a == b
-}
diff --git a/tests/assembly/libs/issue-115339-zip-arrays.rs b/tests/assembly/libs/issue-115339-zip-arrays.rs
deleted file mode 100644
index 098382502e8..00000000000
--- a/tests/assembly/libs/issue-115339-zip-arrays.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ assembly-output: emit-asm
-// # zen3 previously exhibited odd vectorization
-//@ compile-flags: --crate-type=lib -Ctarget-cpu=znver3 -Copt-level=3
-//@ only-x86_64
-//@ ignore-sgx
-
-use std::iter;
-
-// previously this produced a long chain of
-// 56:  vpextrb $6, %xmm0, %ecx
-// 57:  orb %cl, 22(%rsi)
-// 58:  vpextrb $7, %xmm0, %ecx
-// 59:  orb %cl, 23(%rsi)
-// [...]
-
-// CHECK-LABEL: zip_arrays:
-#[no_mangle]
-pub fn zip_arrays(mut a: [u8; 32], b: [u8; 32]) -> [u8; 32] {
-    // CHECK-NOT: vpextrb
-    // CHECK-NOT: orb %cl
-    // CHECK: vorps
-    iter::zip(&mut a, b).for_each(|(a, b)| *a |= b);
-    // CHECK: retq
-    a
-}
diff --git a/tests/assembly/libs/issue-140207-slice-min-simd.rs b/tests/assembly/libs/issue-140207-slice-min-simd.rs
deleted file mode 100644
index 86f067cac08..00000000000
--- a/tests/assembly/libs/issue-140207-slice-min-simd.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ assembly-output: emit-asm
-// # avx has a dedicated instruction for this
-//@ compile-flags: --crate-type=lib -Ctarget-cpu=znver2 -Copt-level=3
-//@ only-x86_64
-//@ ignore-sgx
-// https://github.com/rust-lang/rust/issues/140207
-
-#[unsafe(no_mangle)]
-pub fn array_min(a: &[u16; 8]) -> u16 {
-    // CHECK: vphminposuw
-    // CHECK: ret
-    a.iter().copied().min().unwrap()
-}
diff --git a/tests/assembly/manual-eq-efficient.rs b/tests/assembly/manual-eq-efficient.rs
deleted file mode 100644
index 8dafed354be..00000000000
--- a/tests/assembly/manual-eq-efficient.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Regression test for #106269
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C llvm-args=-x86-asm-syntax=intel
-//@ only-x86_64
-//@ ignore-sgx
-
-pub struct S {
-    a: u8,
-    b: u8,
-    c: u8,
-    d: u8,
-}
-
-// CHECK-LABEL: manual_eq:
-#[no_mangle]
-pub fn manual_eq(s1: &S, s2: &S) -> bool {
-    // CHECK: mov [[REG:[a-z0-9]+]], dword ptr [{{[a-z0-9]+}}]
-    // CHECK-NEXT: cmp [[REG]], dword ptr [{{[a-z0-9]+}}]
-    // CHECK-NEXT: sete al
-    // CHECK: ret
-    s1.a == s2.a && s1.b == s2.b && s1.c == s2.c && s1.d == s2.d
-}
diff --git a/tests/assembly/naked-functions/aarch64-naked-fn-no-bti-prolog.rs b/tests/assembly/naked-functions/aarch64-naked-fn-no-bti-prolog.rs
deleted file mode 100644
index 860ecc3cfcd..00000000000
--- a/tests/assembly/naked-functions/aarch64-naked-fn-no-bti-prolog.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Zbranch-protection=bti
-//@ assembly-output: emit-asm
-//@ needs-asm-support
-//@ only-aarch64
-
-#![crate_type = "lib"]
-
-use std::arch::naked_asm;
-
-// The problem at hand: Rust has adopted a fairly strict meaning for "naked functions",
-// meaning "no prologue whatsoever, no, really, not one instruction."
-// Unfortunately, aarch64's "branch target identification" works via hints at landing sites.
-// LLVM implements this via making sure of that, even for functions with the naked attribute.
-// So, we must emit an appropriate instruction instead!
-#[no_mangle]
-#[unsafe(naked)]
-pub extern "C" fn _hlt() -> ! {
-    // CHECK-NOT: hint #34
-    // CHECK: hlt #0x1
-    naked_asm!("hlt #1")
-}
diff --git a/tests/assembly/naked-functions/aix.rs b/tests/assembly/naked-functions/aix.rs
deleted file mode 100644
index 57ff0e183be..00000000000
--- a/tests/assembly/naked-functions/aix.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ revisions: elfv1-be aix
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//
-//@[elfv1-be] compile-flags: --target powerpc64-unknown-linux-gnu
-//@[elfv1-be] needs-llvm-components: powerpc
-//
-//@[aix] compile-flags: --target powerpc64-ibm-aix
-//@[aix] needs-llvm-components: powerpc
-
-#![crate_type = "lib"]
-#![feature(no_core, asm_experimental_arch, f128, linkage, fn_align)]
-#![no_core]
-
-// tests that naked functions work for the `powerpc64-ibm-aix` target.
-//
-// This target is special because it uses the XCOFF binary format
-// It is tested alongside an elf powerpc target to pin down commonalities and differences.
-//
-// https://doc.rust-lang.org/rustc/platform-support/aix.html
-// https://www.ibm.com/docs/en/aix/7.2?topic=formats-xcoff-object-file-format
-
-extern crate minicore;
-use minicore::*;
-
-// elfv1-be: .p2align 2
-// aix: .align 2
-// CHECK: .globl blr
-// CHECK-LABEL: blr:
-// CHECK: blr
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn blr() {
-    naked_asm!("blr")
-}
diff --git a/tests/assembly/naked-functions/wasm32.rs b/tests/assembly/naked-functions/wasm32.rs
deleted file mode 100644
index 77547e82041..00000000000
--- a/tests/assembly/naked-functions/wasm32.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-//@ revisions: wasm32-unknown wasm64-unknown wasm32-wasip1
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ [wasm32-unknown] compile-flags: --target wasm32-unknown-unknown
-//@ [wasm64-unknown] compile-flags: --target wasm64-unknown-unknown
-//@ [wasm32-wasip1] compile-flags: --target wasm32-wasip1
-//@ [wasm32-unknown] needs-llvm-components: webassembly
-//@ [wasm64-unknown] needs-llvm-components: webassembly
-//@ [wasm32-wasip1] needs-llvm-components: webassembly
-
-#![crate_type = "lib"]
-#![feature(no_core, asm_experimental_arch, f128, linkage, fn_align)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: .section  .text.nop,"",@
-// CHECK: .globl nop
-// CHECK-LABEL: nop:
-// CHECK: .functype nop () -> ()
-// CHECK-NOT: .size
-// CHECK: end_function
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn nop() {
-    naked_asm!("nop")
-}
-
-// CHECK: .section  .text.weak_nop,"",@
-// CHECK: .weak weak_nop
-// CHECK-LABEL: nop:
-// CHECK: .functype weak_nop () -> ()
-// CHECK-NOT: .size
-// CHECK: end_function
-#[no_mangle]
-#[unsafe(naked)]
-#[linkage = "weak"]
-extern "C" fn weak_nop() {
-    naked_asm!("nop")
-}
-
-// CHECK-LABEL: fn_i8_i8:
-// CHECK-NEXT: .functype fn_i8_i8 (i32) -> (i32)
-//
-// CHECK-NEXT: local.get 0
-// CHECK-NEXT: local.get 0
-// CHECK-NEXT: i32.mul
-//
-// CHECK-NEXT: end_function
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_i8_i8(num: i8) -> i8 {
-    naked_asm!("local.get 0", "local.get 0", "i32.mul")
-}
-
-// CHECK-LABEL: fn_i8_i8_i8:
-// CHECK: .functype fn_i8_i8_i8 (i32, i32) -> (i32)
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_i8_i8_i8(a: i8, b: i8) -> i8 {
-    naked_asm!("local.get 1", "local.get 0", "i32.mul")
-}
-
-// CHECK-LABEL: fn_unit_i8:
-// CHECK: .functype fn_unit_i8 () -> (i32)
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_unit_i8() -> i8 {
-    naked_asm!("i32.const 42")
-}
-
-// CHECK-LABEL: fn_i8_unit:
-// CHECK: .functype fn_i8_unit (i32) -> ()
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_i8_unit(_: i8) {
-    naked_asm!("nop")
-}
-
-// CHECK-LABEL: fn_i32_i32:
-// CHECK: .functype fn_i32_i32 (i32) -> (i32)
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_i32_i32(num: i32) -> i32 {
-    naked_asm!("local.get 0", "local.get 0", "i32.mul")
-}
-
-// CHECK-LABEL: fn_i64_i64:
-// CHECK: .functype fn_i64_i64 (i64) -> (i64)
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_i64_i64(num: i64) -> i64 {
-    naked_asm!("local.get 0", "local.get 0", "i64.mul")
-}
-
-// CHECK-LABEL: fn_i128_i128:
-// wasm32-unknown: .functype fn_i128_i128 (i32, i64, i64) -> ()
-// wasm32-wasip1: .functype fn_i128_i128 (i32, i64, i64) -> ()
-// wasm64-unknown: .functype fn_i128_i128 (i64, i64, i64) -> ()
-#[allow(improper_ctypes_definitions)]
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_i128_i128(num: i128) -> i128 {
-    naked_asm!(
-        "local.get       0",
-        "local.get       2",
-        "i64.store       8",
-        "local.get       0",
-        "local.get       1",
-        "i64.store       0",
-    )
-}
-
-// CHECK-LABEL: fn_f128_f128:
-// wasm32-unknown: .functype fn_f128_f128 (i32, i64, i64) -> ()
-// wasm32-wasip1: .functype fn_f128_f128 (i32, i64, i64) -> ()
-// wasm64-unknown: .functype fn_f128_f128 (i64, i64, i64) -> ()
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_f128_f128(num: f128) -> f128 {
-    naked_asm!(
-        "local.get       0",
-        "local.get       2",
-        "i64.store       8",
-        "local.get       0",
-        "local.get       1",
-        "i64.store       0",
-    )
-}
-
-#[repr(C)]
-struct Compound {
-    a: u16,
-    b: i64,
-}
-
-// CHECK-LABEL: fn_compound_compound:
-// wasm32-unknown: .functype fn_compound_compound (i32, i32) -> ()
-// wasm32-wasip1: .functype fn_compound_compound (i32, i32) -> ()
-// wasm64-unknown: .functype fn_compound_compound (i64, i64) -> ()
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_compound_compound(_: Compound) -> Compound {
-    // this is the wasm32-wasip1 assembly
-    naked_asm!(
-        "local.get       0",
-        "local.get       1",
-        "i64.load        8",
-        "i64.store       8",
-        "local.get       0",
-        "local.get       1",
-        "i32.load16_u    0",
-        "i32.store16     0",
-    )
-}
-
-#[repr(C)]
-struct WrapperI32(i32);
-
-// CHECK-LABEL: fn_wrapperi32_wrapperi32:
-// CHECK: .functype fn_wrapperi32_wrapperi32 (i32) -> (i32)
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_wrapperi32_wrapperi32(_: WrapperI32) -> WrapperI32 {
-    naked_asm!("local.get       0")
-}
-
-#[repr(C)]
-struct WrapperI64(i64);
-
-// CHECK-LABEL: fn_wrapperi64_wrapperi64:
-// CHECK: .functype fn_wrapperi64_wrapperi64 (i64) -> (i64)
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_wrapperi64_wrapperi64(_: WrapperI64) -> WrapperI64 {
-    naked_asm!("local.get       0")
-}
-
-#[repr(C)]
-struct WrapperF32(f32);
-
-// CHECK-LABEL: fn_wrapperf32_wrapperf32:
-// CHECK: .functype fn_wrapperf32_wrapperf32 (f32) -> (f32)
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_wrapperf32_wrapperf32(_: WrapperF32) -> WrapperF32 {
-    naked_asm!("local.get       0")
-}
-
-#[repr(C)]
-struct WrapperF64(f64);
-
-// CHECK-LABEL: fn_wrapperf64_wrapperf64:
-// CHECK: .functype fn_wrapperf64_wrapperf64 (f64) -> (f64)
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn fn_wrapperf64_wrapperf64(_: WrapperF64) -> WrapperF64 {
-    naked_asm!("local.get       0")
-}
diff --git a/tests/assembly/naked-functions/x86_64-naked-fn-no-cet-prolog.rs b/tests/assembly/naked-functions/x86_64-naked-fn-no-cet-prolog.rs
deleted file mode 100644
index 81ee9b13b4e..00000000000
--- a/tests/assembly/naked-functions/x86_64-naked-fn-no-cet-prolog.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Zcf-protection=full
-//@ assembly-output: emit-asm
-//@ needs-asm-support
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-use std::arch::naked_asm;
-
-// The problem at hand: Rust has adopted a fairly strict meaning for "naked functions",
-// meaning "no prologue whatsoever, no, really, not one instruction."
-// Unfortunately, x86's control-flow enforcement, specifically indirect branch protection,
-// works by using an instruction for each possible landing site,
-// and LLVM implements this via making sure of that.
-#[no_mangle]
-#[unsafe(naked)]
-pub extern "sysv64" fn will_halt() -> ! {
-    // CHECK-NOT: endbr{{32|64}}
-    // CHECK: hlt
-    naked_asm!("hlt")
-}
-
-// what about aarch64?
-// "branch-protection"=false
diff --git a/tests/assembly/niche-prefer-zero.rs b/tests/assembly/niche-prefer-zero.rs
deleted file mode 100644
index 4e260ebc09b..00000000000
--- a/tests/assembly/niche-prefer-zero.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Check that niche selection prefers zero and that jumps are optimized away.
-// See https://github.com/rust-lang/rust/pull/87794
-//@ assembly-output: emit-asm
-//@ only-x86
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[repr(u8)]
-pub enum Size {
-    One = 1,
-    Two = 2,
-    Three = 3,
-}
-
-#[no_mangle]
-pub fn handle(x: Option<Size>) -> u8 {
-    match x {
-        None => 0,
-        Some(size) => size as u8,
-    }
-}
-
-// There should be no jumps in output
-// CHECK-NOT: j
diff --git a/tests/assembly/nvptx-arch-default.rs b/tests/assembly/nvptx-arch-default.rs
deleted file mode 100644
index a621fd6dcb2..00000000000
--- a/tests/assembly/nvptx-arch-default.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ assembly-output: ptx-linker
-//@ compile-flags: --crate-type cdylib -Z unstable-options -Clinker-flavor=llbc
-//@ only-nvptx64
-
-#![no_std]
-
-//@ aux-build: breakpoint-panic-handler.rs
-extern crate breakpoint_panic_handler;
-
-// Verify default target arch with ptx-linker.
-// CHECK: .target sm_30
-// CHECK: .address_size 64
diff --git a/tests/assembly/nvptx-arch-emit-asm.rs b/tests/assembly/nvptx-arch-emit-asm.rs
deleted file mode 100644
index e47f8e78e36..00000000000
--- a/tests/assembly/nvptx-arch-emit-asm.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type rlib
-//@ only-nvptx64
-
-#![no_std]
-
-// Verify default arch without ptx-linker involved.
-// CHECK: .target sm_30
-// CHECK: .address_size 64
diff --git a/tests/assembly/nvptx-arch-link-arg.rs b/tests/assembly/nvptx-arch-link-arg.rs
deleted file mode 100644
index 3432e6161bf..00000000000
--- a/tests/assembly/nvptx-arch-link-arg.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ assembly-output: ptx-linker
-//@ compile-flags: --crate-type cdylib -C link-arg=--arch=sm_60
-//@ only-nvptx64
-//@ ignore-nvptx64
-
-#![no_std]
-
-//@ aux-build: breakpoint-panic-handler.rs
-extern crate breakpoint_panic_handler;
-
-// Verify target arch override via `link-arg`.
-// CHECK: .target sm_60
-// CHECK: .address_size 64
diff --git a/tests/assembly/nvptx-arch-target-cpu.rs b/tests/assembly/nvptx-arch-target-cpu.rs
deleted file mode 100644
index 609ab297e63..00000000000
--- a/tests/assembly/nvptx-arch-target-cpu.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ assembly-output: ptx-linker
-//@ compile-flags: --crate-type cdylib -C target-cpu=sm_50 -Z unstable-options -Clinker-flavor=llbc
-//@ only-nvptx64
-
-#![no_std]
-
-//@ aux-build: breakpoint-panic-handler.rs
-extern crate breakpoint_panic_handler;
-
-// Verify target arch override via `target-cpu`.
-// CHECK: .target sm_50
-// CHECK: .address_size 64
diff --git a/tests/assembly/nvptx-atomics.rs b/tests/assembly/nvptx-atomics.rs
deleted file mode 100644
index 52b8c86d8a9..00000000000
--- a/tests/assembly/nvptx-atomics.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-//@ assembly-output: ptx-linker
-//@ compile-flags: --crate-type cdylib
-//@ only-nvptx64
-//@ ignore-nvptx64
-
-#![feature(abi_ptx, core_intrinsics)]
-#![no_std]
-
-use core::intrinsics::*;
-
-//@ aux-build: breakpoint-panic-handler.rs
-extern crate breakpoint_panic_handler;
-
-// Currently, LLVM NVPTX backend can only emit atomic instructions with
-// `relaxed` (PTX default) ordering. But it's also useful to make sure
-// the backend won't fail with other orders. Apparently, the backend
-// doesn't support fences as well. As a workaround `llvm.nvvm.membar.*`
-// could work, and perhaps on the long run, all the atomic operations
-// should rather be provided by `core::arch::nvptx`.
-
-// Also, PTX ISA doesn't have atomic `load`, `store` and `nand`.
-
-// FIXME(denzp): add tests for `core::sync::atomic::*`.
-
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn atomics_kernel(a: *mut u32) {
-    // CHECK: atom.global.and.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    // CHECK: atom.global.and.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    atomic_and(a, 1);
-    atomic_and_relaxed(a, 1);
-
-    // CHECK: atom.global.cas.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1, 2;
-    // CHECK: atom.global.cas.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1, 2;
-    atomic_cxchg(a, 1, 2);
-    atomic_cxchg_relaxed(a, 1, 2);
-
-    // CHECK: atom.global.max.s32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    // CHECK: atom.global.max.s32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    atomic_max(a, 1);
-    atomic_max_relaxed(a, 1);
-
-    // CHECK: atom.global.min.s32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    // CHECK: atom.global.min.s32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    atomic_min(a, 1);
-    atomic_min_relaxed(a, 1);
-
-    // CHECK: atom.global.or.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    // CHECK: atom.global.or.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    atomic_or(a, 1);
-    atomic_or_relaxed(a, 1);
-
-    // CHECK: atom.global.max.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    // CHECK: atom.global.max.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    atomic_umax(a, 1);
-    atomic_umax_relaxed(a, 1);
-
-    // CHECK: atom.global.min.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    // CHECK: atom.global.min.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    atomic_umin(a, 1);
-    atomic_umin_relaxed(a, 1);
-
-    // CHECK: atom.global.add.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    // CHECK: atom.global.add.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    atomic_xadd(a, 1);
-    atomic_xadd_relaxed(a, 1);
-
-    // CHECK: atom.global.exch.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    // CHECK: atom.global.exch.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    atomic_xchg(a, 1);
-    atomic_xchg_relaxed(a, 1);
-
-    // CHECK: atom.global.xor.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    // CHECK: atom.global.xor.b32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], 1;
-    atomic_xor(a, 1);
-    atomic_xor_relaxed(a, 1);
-
-    // CHECK: mov.u32 %[[sub_0_arg:r[0-9]+]], 100;
-    // CHECK: neg.s32 temp, %[[sub_0_arg]];
-    // CHECK: atom.global.add.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], temp;
-    atomic_xsub(a, 100);
-
-    // CHECK: mov.u32 %[[sub_1_arg:r[0-9]+]], 200;
-    // CHECK: neg.s32 temp, %[[sub_1_arg]];
-    // CHECK: atom.global.add.u32 %{{r[0-9]+}}, [%{{rd[0-9]+}}], temp;
-    atomic_xsub_relaxed(a, 200);
-}
diff --git a/tests/assembly/nvptx-c-abi-arg-v7.rs b/tests/assembly/nvptx-c-abi-arg-v7.rs
deleted file mode 100644
index be98b167470..00000000000
--- a/tests/assembly/nvptx-c-abi-arg-v7.rs
+++ /dev/null
@@ -1,220 +0,0 @@
-//@ assembly-output: ptx-linker
-//@ compile-flags: --crate-type cdylib -C target-cpu=sm_86 -Z unstable-options -Clinker-flavor=llbc
-//@ only-nvptx64
-
-// The PTX ABI stability is tied to major versions of the PTX ISA
-// These tests assume major version 7
-
-// CHECK: .version 7
-
-#![feature(abi_ptx, lang_items, no_core)]
-#![no_core]
-
-#[lang = "pointee_sized"]
-trait PointeeSized {}
-#[lang = "meta_sized"]
-trait MetaSized: PointeeSized {}
-#[lang = "sized"]
-trait Sized: MetaSized {}
-#[lang = "copy"]
-trait Copy {}
-
-#[repr(C)]
-pub struct SingleU8 {
-    f: u8,
-}
-
-#[repr(C)]
-pub struct DoubleU8 {
-    f: u8,
-    g: u8,
-}
-
-#[repr(C)]
-pub struct TripleU8 {
-    f: u8,
-    g: u8,
-    h: u8,
-}
-
-#[repr(C)]
-pub struct TripleU16 {
-    f: u16,
-    g: u16,
-    h: u16,
-}
-#[repr(C)]
-pub struct DoubleI32 {
-    f: i32,
-    g: i32,
-}
-#[repr(C)]
-pub struct TripleU32 {
-    f: u32,
-    g: u32,
-    h: u32,
-}
-#[repr(C)]
-pub struct TripleU64 {
-    f: u64,
-    g: u64,
-    h: u64,
-}
-
-#[repr(C)]
-pub struct DoubleFloat {
-    f: f32,
-    g: f32,
-}
-
-#[repr(C)]
-pub struct TripleFloat {
-    f: f32,
-    g: f32,
-    h: f32,
-}
-
-#[repr(C)]
-pub struct TripleDouble {
-    f: f64,
-    g: f64,
-    h: f64,
-}
-
-#[repr(C)]
-pub struct ManyIntegers {
-    f: u8,
-    g: u16,
-    h: u32,
-    i: u64,
-}
-
-#[repr(C)]
-pub struct ManyNumerics {
-    f: u8,
-    g: u16,
-    h: u32,
-    i: u64,
-    j: f32,
-    k: f64,
-}
-
-// CHECK: .visible .func f_u8_arg(
-// CHECK: .param .b32 f_u8_arg_param_0
-#[no_mangle]
-pub unsafe extern "C" fn f_u8_arg(_a: u8) {}
-
-// CHECK: .visible .func f_u16_arg(
-// CHECK: .param .b32 f_u16_arg_param_0
-#[no_mangle]
-pub unsafe extern "C" fn f_u16_arg(_a: u16) {}
-
-// CHECK: .visible .func f_u32_arg(
-// CHECK: .param .b32 f_u32_arg_param_0
-#[no_mangle]
-pub unsafe extern "C" fn f_u32_arg(_a: u32) {}
-
-// CHECK: .visible .func f_u64_arg(
-// CHECK: .param .b64 f_u64_arg_param_0
-#[no_mangle]
-pub unsafe extern "C" fn f_u64_arg(_a: u64) {}
-
-// CHECK: .visible .func f_u128_arg(
-// CHECK: .param .align 16 .b8 f_u128_arg_param_0[16]
-#[no_mangle]
-pub unsafe extern "C" fn f_u128_arg(_a: u128) {}
-
-// CHECK: .visible .func f_i8_arg(
-// CHECK: .param .b32 f_i8_arg_param_0
-#[no_mangle]
-pub unsafe extern "C" fn f_i8_arg(_a: i8) {}
-
-// CHECK: .visible .func f_i16_arg(
-// CHECK: .param .b32 f_i16_arg_param_0
-#[no_mangle]
-pub unsafe extern "C" fn f_i16_arg(_a: i16) {}
-
-// CHECK: .visible .func f_i32_arg(
-// CHECK: .param .b32 f_i32_arg_param_0
-#[no_mangle]
-pub unsafe extern "C" fn f_i32_arg(_a: i32) {}
-
-// CHECK: .visible .func f_i64_arg(
-// CHECK: .param .b64 f_i64_arg_param_0
-#[no_mangle]
-pub unsafe extern "C" fn f_i64_arg(_a: i64) {}
-
-// CHECK: .visible .func f_i128_arg(
-// CHECK: .param .align 16 .b8 f_i128_arg_param_0[16]
-#[no_mangle]
-pub unsafe extern "C" fn f_i128_arg(_a: i128) {}
-
-// CHECK: .visible .func f_f32_arg(
-// CHECK: .param .b32 f_f32_arg_param_0
-#[no_mangle]
-pub unsafe extern "C" fn f_f32_arg(_a: f32) {}
-
-// CHECK: .visible .func f_f64_arg(
-// CHECK: .param .b64 f_f64_arg_param_0
-#[no_mangle]
-pub unsafe extern "C" fn f_f64_arg(_a: f64) {}
-
-// CHECK: .visible .func f_single_u8_arg(
-// CHECK: .param .align 1 .b8 f_single_u8_arg_param_0[1]
-#[no_mangle]
-pub unsafe extern "C" fn f_single_u8_arg(_a: SingleU8) {}
-
-// CHECK: .visible .func f_double_u8_arg(
-// CHECK: .param .align 1 .b8 f_double_u8_arg_param_0[2]
-#[no_mangle]
-pub unsafe extern "C" fn f_double_u8_arg(_a: DoubleU8) {}
-
-// CHECK: .visible .func f_triple_u8_arg(
-// CHECK: .param .align 1 .b8 f_triple_u8_arg_param_0[3]
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_u8_arg(_a: TripleU8) {}
-
-// CHECK: .visible .func f_triple_u16_arg(
-// CHECK: .param .align 2 .b8 f_triple_u16_arg_param_0[6]
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_u16_arg(_a: TripleU16) {}
-
-// CHECK: .visible .func f_triple_u32_arg(
-// CHECK: .param .align 4 .b8 f_triple_u32_arg_param_0[12]
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_u32_arg(_a: TripleU32) {}
-
-// CHECK: .visible .func f_double_i32_arg(
-// CHECK: .param .align 4 .b8 f_double_i32_arg_param_0[8]
-#[no_mangle]
-pub unsafe extern "C" fn f_double_i32_arg(_a: DoubleI32) {}
-
-// CHECK: .visible .func f_triple_u64_arg(
-// CHECK: .param .align 8 .b8 f_triple_u64_arg_param_0[24]
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_u64_arg(_a: TripleU64) {}
-
-// CHECK: .visible .func f_many_integers_arg(
-// CHECK: .param .align 8 .b8 f_many_integers_arg_param_0[16]
-#[no_mangle]
-pub unsafe extern "C" fn f_many_integers_arg(_a: ManyIntegers) {}
-
-// CHECK: .visible .func f_double_float_arg(
-// CHECK: .param .align 4 .b8 f_double_float_arg_param_0[8]
-#[no_mangle]
-pub unsafe extern "C" fn f_double_float_arg(_a: DoubleFloat) {}
-
-// CHECK: .visible .func f_triple_float_arg(
-// CHECK: .param .align 4 .b8 f_triple_float_arg_param_0[12]
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_float_arg(_a: TripleFloat) {}
-
-// CHECK: .visible .func f_triple_double_arg(
-// CHECK: .param .align 8 .b8 f_triple_double_arg_param_0[24]
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_double_arg(_a: TripleDouble) {}
-
-// CHECK: .visible .func f_many_numerics_arg(
-// CHECK: .param .align 8 .b8 f_many_numerics_arg_param_0[32]
-#[no_mangle]
-pub unsafe extern "C" fn f_many_numerics_arg(_a: ManyNumerics) {}
diff --git a/tests/assembly/nvptx-c-abi-ret-v7.rs b/tests/assembly/nvptx-c-abi-ret-v7.rs
deleted file mode 100644
index c68c71c872c..00000000000
--- a/tests/assembly/nvptx-c-abi-ret-v7.rs
+++ /dev/null
@@ -1,244 +0,0 @@
-//@ assembly-output: ptx-linker
-//@ compile-flags: --crate-type cdylib -C target-cpu=sm_86 -Z unstable-options -Clinker-flavor=llbc
-//@ only-nvptx64
-
-// The PTX ABI stability is tied to major versions of the PTX ISA
-// These tests assume major version 7
-
-// CHECK: .version 7
-
-#![feature(abi_ptx, lang_items, no_core)]
-#![no_core]
-
-#[lang = "pointee_sized"]
-trait PointeeSized {}
-#[lang = "meta_sized"]
-trait MetaSized: PointeeSized {}
-#[lang = "sized"]
-trait Sized: MetaSized {}
-#[lang = "copy"]
-trait Copy {}
-
-#[repr(C)]
-pub struct SingleU8 {
-    f: u8,
-}
-
-#[repr(C)]
-pub struct DoubleU8 {
-    f: u8,
-    g: u8,
-}
-
-#[repr(C)]
-pub struct TripleU8 {
-    f: u8,
-    g: u8,
-    h: u8,
-}
-
-#[repr(C)]
-pub struct TripleU16 {
-    f: u16,
-    g: u16,
-    h: u16,
-}
-#[repr(C)]
-pub struct DoubleI32 {
-    f: i32,
-    g: i32,
-}
-#[repr(C)]
-pub struct TripleU32 {
-    f: u32,
-    g: u32,
-    h: u32,
-}
-#[repr(C)]
-pub struct TripleU64 {
-    f: u64,
-    g: u64,
-    h: u64,
-}
-
-#[repr(C)]
-pub struct DoubleFloat {
-    f: f32,
-    g: f32,
-}
-
-#[repr(C)]
-pub struct TripleFloat {
-    f: f32,
-    g: f32,
-    h: f32,
-}
-
-#[repr(C)]
-pub struct TripleDouble {
-    f: f64,
-    g: f64,
-    h: f64,
-}
-
-#[repr(C)]
-pub struct ManyIntegers {
-    f: u8,
-    g: u16,
-    h: u32,
-    i: u64,
-}
-
-#[repr(C)]
-pub struct ManyNumerics {
-    f: u8,
-    g: u16,
-    h: u32,
-    i: u64,
-    j: f32,
-    k: f64,
-}
-
-// CHECK: .visible .func (.param .b32 func_retval0) f_u8_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_u8_ret() -> u8 {
-    0
-}
-
-// CHECK: .visible .func (.param .b32 func_retval0) f_u16_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_u16_ret() -> u16 {
-    1
-}
-
-// CHECK: .visible .func (.param .b32 func_retval0) f_u32_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_u32_ret() -> u32 {
-    2
-}
-
-// CHECK: .visible .func (.param .b64 func_retval0) f_u64_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_u64_ret() -> u64 {
-    3
-}
-
-// CHECK: .visible .func (.param .align 16 .b8 func_retval0[16]) f_u128_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_u128_ret() -> u128 {
-    4
-}
-
-// CHECK: .visible .func (.param .b32 func_retval0) f_i8_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_i8_ret() -> i8 {
-    5
-}
-
-// CHECK: .visible .func (.param .b32 func_retval0) f_i16_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_i16_ret() -> i16 {
-    6
-}
-
-// CHECK: .visible .func (.param .b32 func_retval0) f_i32_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_i32_ret() -> i32 {
-    7
-}
-
-// CHECK: .visible .func (.param .b64 func_retval0) f_i64_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_i64_ret() -> i64 {
-    8
-}
-
-// CHECK: .visible .func  (.param .align 16 .b8 func_retval0[16]) f_i128_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_i128_ret() -> i128 {
-    9
-}
-
-// CHECK: .visible .func (.param .b32 func_retval0) f_f32_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_f32_ret() -> f32 {
-    10.0
-}
-
-// CHECK: .visible .func (.param .b64 func_retval0) f_f64_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_f64_ret() -> f64 {
-    11.0
-}
-
-// CHECK: .visible .func (.param .align 1 .b8 func_retval0[1]) f_single_u8_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_single_u8_ret() -> SingleU8 {
-    SingleU8 { f: 12 }
-}
-
-// CHECK: .visible .func (.param .align 1 .b8 func_retval0[2]) f_double_u8_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_double_u8_ret() -> DoubleU8 {
-    DoubleU8 { f: 13, g: 14 }
-}
-
-// CHECK: .visible .func (.param .align 1 .b8 func_retval0[3]) f_triple_u8_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_u8_ret() -> TripleU8 {
-    TripleU8 { f: 15, g: 16, h: 17 }
-}
-
-// CHECK: .visible .func (.param .align 2 .b8 func_retval0[6]) f_triple_u16_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_u16_ret() -> TripleU16 {
-    TripleU16 { f: 18, g: 19, h: 20 }
-}
-
-// CHECK: .visible .func (.param .align 4 .b8 func_retval0[8]) f_double_i32_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_double_i32_ret() -> DoubleI32 {
-    DoubleI32 { f: 1, g: 2 }
-}
-
-// CHECK: .visible .func (.param .align 4 .b8 func_retval0[12]) f_triple_u32_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_u32_ret() -> TripleU32 {
-    TripleU32 { f: 20, g: 21, h: 22 }
-}
-
-// CHECK: .visible .func (.param .align 8 .b8 func_retval0[24]) f_triple_u64_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_u64_ret() -> TripleU64 {
-    TripleU64 { f: 23, g: 24, h: 25 }
-}
-
-// CHECK: .visible .func (.param .align 8 .b8 func_retval0[16]) f_many_integers_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_many_integers_ret() -> ManyIntegers {
-    ManyIntegers { f: 26, g: 27, h: 28, i: 29 }
-}
-
-// CHECK: .visible .func (.param .align 4 .b8 func_retval0[8]) f_double_float_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_double_float_ret() -> DoubleFloat {
-    DoubleFloat { f: 29.0, g: 30.0 }
-}
-
-// CHECK: .visible .func (.param .align 4 .b8 func_retval0[12]) f_triple_float_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_float_ret() -> TripleFloat {
-    TripleFloat { f: 31.0, g: 32.0, h: 33.0 }
-}
-
-// CHECK: .visible .func (.param .align 8 .b8 func_retval0[24]) f_triple_double_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_triple_double_ret() -> TripleDouble {
-    TripleDouble { f: 34.0, g: 35.0, h: 36.0 }
-}
-
-// CHECK: .visible .func (.param .align 8 .b8 func_retval0[32]) f_many_numerics_ret(
-#[no_mangle]
-pub unsafe extern "C" fn f_many_numerics_ret() -> ManyNumerics {
-    ManyNumerics { f: 37, g: 38, h: 39, i: 40, j: 41.0, k: 43.0 }
-}
diff --git a/tests/assembly/nvptx-internalizing.rs b/tests/assembly/nvptx-internalizing.rs
deleted file mode 100644
index 0acfd5c2443..00000000000
--- a/tests/assembly/nvptx-internalizing.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ assembly-output: ptx-linker
-//@ compile-flags: --crate-type cdylib
-//@ only-nvptx64
-//@ ignore-nvptx64
-
-#![feature(abi_ptx)]
-#![no_std]
-
-//@ aux-build: breakpoint-panic-handler.rs
-extern crate breakpoint_panic_handler;
-
-//@ aux-build: non-inline-dependency.rs
-extern crate non_inline_dependency as dep;
-
-// Verify that no extra function declarations are present.
-// CHECK-NOT: .func
-
-// CHECK: .visible .entry top_kernel(
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn top_kernel(a: *const u32, b: *mut u32) {
-    // CHECK: add.s32 %{{r[0-9]+}}, %{{r[0-9]+}}, 5;
-    *b = *a + 5;
-}
-
-// Verify that no extra function definitions are here.
-// CHECK-NOT: .func
-// CHECK-NOT: .entry
diff --git a/tests/assembly/nvptx-kernel-abi/nvptx-kernel-args-abi-v7.rs b/tests/assembly/nvptx-kernel-abi/nvptx-kernel-args-abi-v7.rs
deleted file mode 100644
index f245b4460f2..00000000000
--- a/tests/assembly/nvptx-kernel-abi/nvptx-kernel-args-abi-v7.rs
+++ /dev/null
@@ -1,251 +0,0 @@
-//@ assembly-output: ptx-linker
-//@ compile-flags: --crate-type cdylib -C target-cpu=sm_86 -Z unstable-options -Clinker-flavor=llbc
-//@ only-nvptx64
-
-// The following ABI tests are made with nvcc 11.6 does.
-//
-// The PTX ABI stability is tied to major versions of the PTX ISA
-// These tests assume major version 7
-//
-//
-// The following correspondence between types are assumed:
-// u<N> - uint<N>_t
-// i<N> - int<N>_t
-// [T, N] - std::array<T, N>
-// &T - T const*
-// &mut T - T*
-
-// CHECK: .version 7
-
-#![feature(abi_ptx, lang_items, no_core)]
-#![no_core]
-
-#[lang = "pointee_sized"]
-trait PointeeSized {}
-#[lang = "meta_sized"]
-trait MetaSized: PointeeSized {}
-#[lang = "sized"]
-trait Sized: MetaSized {}
-#[lang = "copy"]
-trait Copy {}
-
-#[repr(C)]
-pub struct SingleU8 {
-    f: u8,
-}
-
-#[repr(C)]
-pub struct DoubleU8 {
-    f: u8,
-    g: u8,
-}
-
-#[repr(C)]
-pub struct TripleU8 {
-    f: u8,
-    g: u8,
-    h: u8,
-}
-
-#[repr(C)]
-pub struct TripleU16 {
-    f: u16,
-    g: u16,
-    h: u16,
-}
-#[repr(C)]
-pub struct DoubleI32 {
-    f: i32,
-    g: i32,
-}
-#[repr(C)]
-pub struct TripleU32 {
-    f: u32,
-    g: u32,
-    h: u32,
-}
-#[repr(C)]
-pub struct TripleU64 {
-    f: u64,
-    g: u64,
-    h: u64,
-}
-
-#[repr(C)]
-pub struct DoubleFloat {
-    f: f32,
-    g: f32,
-}
-
-#[repr(C)]
-pub struct TripleFloat {
-    f: f32,
-    g: f32,
-    h: f32,
-}
-
-#[repr(C)]
-pub struct TripleDouble {
-    f: f64,
-    g: f64,
-    h: f64,
-}
-
-#[repr(C)]
-pub struct ManyIntegers {
-    f: u8,
-    g: u16,
-    h: u32,
-    i: u64,
-}
-
-#[repr(C)]
-pub struct ManyNumerics {
-    f: u8,
-    g: u16,
-    h: u32,
-    i: u64,
-    j: f32,
-    k: f64,
-}
-
-// CHECK: .visible .entry f_u8_arg(
-// CHECK: .param .u8 f_u8_arg_param_0
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_u8_arg(_a: u8) {}
-
-// CHECK: .visible .entry f_u16_arg(
-// CHECK: .param .u16 f_u16_arg_param_0
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_u16_arg(_a: u16) {}
-
-// CHECK: .visible .entry f_u32_arg(
-// CHECK: .param .u32 f_u32_arg_param_0
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_u32_arg(_a: u32) {}
-
-// CHECK: .visible .entry f_u64_arg(
-// CHECK: .param .u64 f_u64_arg_param_0
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_u64_arg(_a: u64) {}
-
-// CHECK: .visible .entry f_u128_arg(
-// CHECK: .param .align 16 .b8 f_u128_arg_param_0[16]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_u128_arg(_a: u128) {}
-
-// CHECK: .visible .entry f_i8_arg(
-// CHECK: .param .u8 f_i8_arg_param_0
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_i8_arg(_a: i8) {}
-
-// CHECK: .visible .entry f_i16_arg(
-// CHECK: .param .u16 f_i16_arg_param_0
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_i16_arg(_a: i16) {}
-
-// CHECK: .visible .entry f_i32_arg(
-// CHECK: .param .u32 f_i32_arg_param_0
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_i32_arg(_a: i32) {}
-
-// CHECK: .visible .entry f_i64_arg(
-// CHECK: .param .u64 f_i64_arg_param_0
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_i64_arg(_a: i64) {}
-
-// CHECK: .visible .entry f_i128_arg(
-// CHECK: .param .align 16 .b8 f_i128_arg_param_0[16]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_i128_arg(_a: i128) {}
-
-// CHECK: .visible .entry f_f32_arg(
-// CHECK: .param .f32 f_f32_arg_param_0
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_f32_arg(_a: f32) {}
-
-// CHECK: .visible .entry f_f64_arg(
-// CHECK: .param .f64 f_f64_arg_param_0
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_f64_arg(_a: f64) {}
-
-// CHECK: .visible .entry f_single_u8_arg(
-// CHECK: .param .align 1 .b8 f_single_u8_arg_param_0[1]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_single_u8_arg(_a: SingleU8) {}
-
-// CHECK: .visible .entry f_double_u8_arg(
-// CHECK: .param .align 1 .b8 f_double_u8_arg_param_0[2]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_double_u8_arg(_a: DoubleU8) {}
-
-// CHECK: .visible .entry f_triple_u8_arg(
-// CHECK: .param .align 1 .b8 f_triple_u8_arg_param_0[3]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_triple_u8_arg(_a: TripleU8) {}
-
-// CHECK: .visible .entry f_triple_u16_arg(
-// CHECK: .param .align 2 .b8 f_triple_u16_arg_param_0[6]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_triple_u16_arg(_a: TripleU16) {}
-
-// CHECK: .visible .entry f_double_i32_arg(
-// CHECK: .param .align 4 .b8 f_double_i32_arg_param_0[8]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_double_i32_arg(_a: DoubleI32) {}
-
-// CHECK: .visible .entry f_triple_u32_arg(
-// CHECK: .param .align 4 .b8 f_triple_u32_arg_param_0[12]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_triple_u32_arg(_a: TripleU32) {}
-
-// CHECK: .visible .entry f_triple_u64_arg(
-// CHECK: .param .align 8 .b8 f_triple_u64_arg_param_0[24]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_triple_u64_arg(_a: TripleU64) {}
-
-// CHECK: .visible .entry f_many_integers_arg(
-// CHECK: .param .align 8 .b8 f_many_integers_arg_param_0[16]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_many_integers_arg(_a: ManyIntegers) {}
-
-// CHECK: .visible .entry f_double_float_arg(
-// CHECK: .param .align 4 .b8 f_double_float_arg_param_0[8]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_double_float_arg(_a: DoubleFloat) {}
-
-// CHECK: .visible .entry f_triple_float_arg(
-// CHECK: .param .align 4 .b8 f_triple_float_arg_param_0[12]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_triple_float_arg(_a: TripleFloat) {}
-
-// CHECK: .visible .entry f_triple_double_arg(
-// CHECK: .param .align 8 .b8 f_triple_double_arg_param_0[24]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_triple_double_arg(_a: TripleDouble) {}
-
-// CHECK: .visible .entry f_many_numerics_arg(
-// CHECK: .param .align 8 .b8 f_many_numerics_arg_param_0[32]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_many_numerics_arg(_a: ManyNumerics) {}
-
-// CHECK: .visible .entry f_byte_array_arg(
-// CHECK: .param .align 1 .b8 f_byte_array_arg_param_0[5]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_byte_array_arg(_a: [u8; 5]) {}
-
-// CHECK: .visible .entry f_float_array_arg(
-// CHECK: .param .align 4 .b8 f_float_array_arg_param_0[20]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_float_array_arg(_a: [f32; 5]) {}
-
-// FIXME: u128 started to break compilation with disabled CI
-// NO_CHECK: .visible .entry f_u128_array_arg(
-// NO_CHECK: .param .align 16 .b8 f_u128_array_arg_param_0[80]
-//#[no_mangle]
-//pub unsafe extern "ptx-kernel" fn f_u128_array_arg(_a: [u128; 5]) {}
-
-// CHECK: .visible .entry f_u32_slice_arg(
-// CHECK: .param .align 8 .b8 f_u32_slice_arg_param_0[16]
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn f_u32_slice_arg(_a: &[u32]) {}
diff --git a/tests/assembly/nvptx-linking-binary.rs b/tests/assembly/nvptx-linking-binary.rs
deleted file mode 100644
index 3b50b472ab1..00000000000
--- a/tests/assembly/nvptx-linking-binary.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//@ assembly-output: ptx-linker
-//@ compile-flags: --crate-type bin
-//@ only-nvptx64
-//@ ignore-nvptx64
-
-#![feature(abi_ptx)]
-#![no_main]
-#![no_std]
-
-//@ aux-build: breakpoint-panic-handler.rs
-extern crate breakpoint_panic_handler;
-
-//@ aux-build: non-inline-dependency.rs
-extern crate non_inline_dependency as dep;
-
-// Make sure declarations are there.
-// CHECK: .func (.param .b32 func_retval0) wrapping_external_fn
-// CHECK: .func (.param .b32 func_retval0) panicking_external_fn
-
-// CHECK-LABEL: .visible .entry top_kernel(
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn top_kernel(a: *const u32, b: *mut u32) {
-    // CHECK:      call.uni (retval0),
-    // CHECK-NEXT: wrapping_external_fn
-    // CHECK:      ld.param.b32 %[[LHS:r[0-9]+]], [retval0+0];
-    let lhs = dep::wrapping_external_fn(*a);
-
-    // CHECK:      call.uni (retval0),
-    // CHECK-NEXT: panicking_external_fn
-    // CHECK:      ld.param.b32 %[[RHS:r[0-9]+]], [retval0+0];
-    let rhs = dep::panicking_external_fn(*a);
-
-    // CHECK: add.s32 %[[RES:r[0-9]+]], %[[RHS]], %[[LHS]];
-    // CHECK: st.global.u32 [%{{rd[0-9]+}}], %[[RES]];
-    *b = lhs + rhs;
-}
-
-// Verify that external function bodies are available.
-// CHECK: .func (.param .b32 func_retval0) wrapping_external_fn
-// CHECK: .func (.param .b32 func_retval0) panicking_external_fn
diff --git a/tests/assembly/nvptx-linking-cdylib.rs b/tests/assembly/nvptx-linking-cdylib.rs
deleted file mode 100644
index 9742e26fb31..00000000000
--- a/tests/assembly/nvptx-linking-cdylib.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//@ assembly-output: ptx-linker
-//@ compile-flags: --crate-type cdylib
-//@ only-nvptx64
-//@ ignore-nvptx64
-
-#![feature(abi_ptx)]
-#![no_std]
-
-//@ aux-build: breakpoint-panic-handler.rs
-extern crate breakpoint_panic_handler;
-
-//@ aux-build: non-inline-dependency.rs
-extern crate non_inline_dependency as dep;
-
-// Make sure declarations are there.
-// CHECK: .func (.param .b32 func_retval0) wrapping_external_fn
-// CHECK: .func (.param .b32 func_retval0) panicking_external_fn
-
-// CHECK-LABEL: .visible .entry top_kernel(
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn top_kernel(a: *const u32, b: *mut u32) {
-    // CHECK:      call.uni (retval0),
-    // CHECK-NEXT: wrapping_external_fn
-    // CHECK:      ld.param.b32 %[[LHS:r[0-9]+]], [retval0+0];
-    let lhs = dep::wrapping_external_fn(*a);
-
-    // CHECK:      call.uni (retval0),
-    // CHECK-NEXT: panicking_external_fn
-    // CHECK:      ld.param.b32 %[[RHS:r[0-9]+]], [retval0+0];
-    let rhs = dep::panicking_external_fn(*a);
-
-    // CHECK: add.s32 %[[RES:r[0-9]+]], %[[RHS]], %[[LHS]];
-    // CHECK: st.global.u32 [%{{rd[0-9]+}}], %[[RES]];
-    *b = lhs + rhs;
-}
-
-// Verify that external function bodies are available.
-// CHECK: .func (.param .b32 func_retval0) wrapping_external_fn
-// CHECK: .func (.param .b32 func_retval0) panicking_external_fn
diff --git a/tests/assembly/nvptx-safe-naming.rs b/tests/assembly/nvptx-safe-naming.rs
deleted file mode 100644
index d7b46aadd9c..00000000000
--- a/tests/assembly/nvptx-safe-naming.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//@ assembly-output: ptx-linker
-//@ compile-flags: --crate-type cdylib -Z unstable-options -Clinker-flavor=llbc
-//@ only-nvptx64
-
-#![feature(abi_ptx)]
-#![no_std]
-
-//@ aux-build: breakpoint-panic-handler.rs
-extern crate breakpoint_panic_handler;
-
-// Verify function name doesn't contain unacceaptable characters.
-// CHECK: .func (.param .b32 func_retval0) [[IMPL_FN:[a-zA-Z0-9$_]+square[a-zA-Z0-9$_]+]]
-
-// CHECK-LABEL: .visible .entry top_kernel(
-#[no_mangle]
-pub unsafe extern "ptx-kernel" fn top_kernel(a: *const u32, b: *mut u32) {
-    // CHECK:      call.uni (retval0),
-    // CHECK-NEXT: [[IMPL_FN]]
-    *b = deep::private::MyStruct::new(*a).square();
-}
-
-pub mod deep {
-    pub mod private {
-        pub struct MyStruct<T>(T);
-
-        impl MyStruct<u32> {
-            pub fn new(a: u32) -> Self {
-                MyStruct(a)
-            }
-
-            #[inline(never)]
-            pub fn square(&self) -> u32 {
-                self.0.wrapping_mul(self.0)
-            }
-        }
-    }
-}
diff --git a/tests/assembly/panic-no-unwind-no-uwtable.rs b/tests/assembly/panic-no-unwind-no-uwtable.rs
deleted file mode 100644
index b51b173e961..00000000000
--- a/tests/assembly/panic-no-unwind-no-uwtable.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ assembly-output: emit-asm
-//@ only-x86_64-unknown-linux-gnu
-//@ compile-flags: -C panic=unwind -C force-unwind-tables=n -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-NOT: .cfi_startproc
-pub fn foo() {}
diff --git a/tests/assembly/panic-unwind-no-uwtable.rs b/tests/assembly/panic-unwind-no-uwtable.rs
deleted file mode 100644
index 181656a8987..00000000000
--- a/tests/assembly/panic-unwind-no-uwtable.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ assembly-output: emit-asm
-//@ only-x86_64-unknown-linux-gnu
-//@ compile-flags: -C panic=unwind -C force-unwind-tables=n
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: foo:
-// CHECK: .cfi_startproc
-#[no_mangle]
-fn foo() {
-    panic!();
-}
diff --git a/tests/assembly/pic-relocation-model.rs b/tests/assembly/pic-relocation-model.rs
deleted file mode 100644
index 15a8723f756..00000000000
--- a/tests/assembly/pic-relocation-model.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x64
-//@ assembly-output: emit-asm
-//@ [x64] compile-flags: --target x86_64-unknown-linux-gnu -Crelocation-model=pic
-//@ [x64] needs-llvm-components: x86
-
-#![feature(no_core, lang_items)]
-#![no_core]
-#![crate_type = "rlib"]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: call_other_fn:
-// CHECK:       {{(jmpq|callq)}} *other_fn@GOTPCREL(%rip)
-#[no_mangle]
-pub fn call_other_fn() -> u8 {
-    unsafe { other_fn() }
-}
-
-// CHECK-LABEL: other_fn:
-// CHECK:       {{(jmpq|callq)}} *foreign_fn@GOTPCREL(%rip)
-#[no_mangle]
-#[inline(never)]
-pub fn other_fn() -> u8 {
-    unsafe { foreign_fn() }
-}
-
-extern "C" {
-    fn foreign_fn() -> u8;
-}
diff --git a/tests/assembly/pie-relocation-model.rs b/tests/assembly/pie-relocation-model.rs
deleted file mode 100644
index cbe0001041e..00000000000
--- a/tests/assembly/pie-relocation-model.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x64
-//@ assembly-output: emit-asm
-//@ [x64] compile-flags: --target x86_64-unknown-linux-gnu -Crelocation-model=pie
-//@ [x64] needs-llvm-components: x86
-
-#![feature(no_core, lang_items)]
-#![no_core]
-#![crate_type = "rlib"]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: call_other_fn:
-// With PIE local functions are called "directly".
-// CHECK:       {{(jmp|callq)}} other_fn
-#[no_mangle]
-pub fn call_other_fn() -> u8 {
-    unsafe { other_fn() }
-}
-
-// CHECK-LABEL: other_fn:
-// External functions are still called through GOT, since we don't know if the symbol
-// is defined in the binary or in the shared library.
-// CHECK:       {{(jmpq|callq)}} *foreign_fn@GOTPCREL(%rip)
-#[no_mangle]
-#[inline(never)]
-pub fn other_fn() -> u8 {
-    unsafe { foreign_fn() }
-}
-
-extern "C" {
-    fn foreign_fn() -> u8;
-}
diff --git a/tests/assembly/powerpc64-struct-abi.rs b/tests/assembly/powerpc64-struct-abi.rs
deleted file mode 100644
index ee4965deb4f..00000000000
--- a/tests/assembly/powerpc64-struct-abi.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-//@ add-core-stubs
-//@ revisions: elfv1-be elfv2-be elfv2-le aix
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3
-//@[elfv1-be] compile-flags: --target powerpc64-unknown-linux-gnu
-//@[elfv1-be] needs-llvm-components: powerpc
-//@[elfv2-be] compile-flags: --target powerpc64-unknown-linux-musl
-//@[elfv2-be] needs-llvm-components: powerpc
-//@[elfv2-le] compile-flags: --target powerpc64le-unknown-linux-gnu -C target-cpu=pwr8
-//@[elfv2-le] needs-llvm-components: powerpc
-//@[aix] compile-flags: --target powerpc64-ibm-aix
-//@[aix] needs-llvm-components: powerpc
-//@[elfv1-be] filecheck-flags: --check-prefix be
-//@[elfv2-be] filecheck-flags: --check-prefix be
-//@[elfv1-be] filecheck-flags: --check-prefix elf
-//@[elfv2-be] filecheck-flags: --check-prefix elf
-//@[elfv2-le] filecheck-flags: --check-prefix elf
-
-#![feature(no_core, lang_items)]
-#![no_std]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-impl Copy for FiveU32s {}
-impl Copy for FiveU16s {}
-impl Copy for ThreeU8s {}
-
-#[repr(C)]
-struct FiveU32s(u32, u32, u32, u32, u32);
-
-#[repr(C)]
-struct FiveU16s(u16, u16, u16, u16, u16);
-
-#[repr(C)]
-struct ThreeU8s(u8, u8, u8);
-
-// CHECK-LABEL: read_large
-// aix: lwz [[REG1:.*]], 16(4)
-// aix-NEXT: lxv{{d2x|w4x}} 0, 0, 4
-// aix-NEXT: stw [[REG1]], 16(3)
-// aix-NEXT: stxv{{d2x|w4x}} 0, 0, 3
-// be: lwz [[REG1:.*]], 16(4)
-// be-NEXT: stw [[REG1]], 16(3)
-// be-NEXT: ld [[REG2:.*]], 8(4)
-// be-NEXT: ld [[REG3:.*]], 0(4)
-// be-NEXT: std [[REG2]], 8(3)
-// be-NEXT: std [[REG3]], 0(3)
-// elfv2-le: lxvd2x [[REG1:.*]], 0, 4
-// elfv2-le-NEXT: lwz [[REG2:.*]], 16(4)
-// elfv2-le-NEXT: stw [[REG2]], 16(3)
-// elfv2-le-NEXT: stxvd2x [[REG1]], 0, 3
-// CHECK-NEXT: blr
-#[no_mangle]
-extern "C" fn read_large(x: &FiveU32s) -> FiveU32s {
-    *x
-}
-
-// CHECK-LABEL: read_medium
-// aix: lhz [[REG1:.*]], 8(4)
-// aix-NEXT: ld [[REG2:.*]], 0(4)
-// aix-NEXT: sth [[REG1]], 8(3)
-// aix-NEXT: std [[REG2]], 0(3)
-// elfv1-be: lhz [[REG1:.*]], 8(4)
-// elfv1-be-NEXT: ld [[REG2:.*]], 0(4)
-// elfv1-be-NEXT: sth [[REG1]], 8(3)
-// elfv1-be-NEXT: std [[REG2]], 0(3)
-// elfv2-be: lhz [[REG1:.*]], 8(3)
-// elfv2-be-NEXT: ld 3, 0(3)
-// elfv2-be-NEXT: sldi 4, [[REG1]], 48
-// elfv2-le: ld [[REG1:.*]], 0(3)
-// elfv2-le-NEXT: lhz 4, 8(3)
-// elfv2-le-NEXT: mr 3, [[REG1]]
-// CHECK-NEXT: blr
-#[no_mangle]
-extern "C" fn read_medium(x: &FiveU16s) -> FiveU16s {
-    *x
-}
-
-// CHECK-LABEL: read_small
-// aix: lbz [[REG1:.*]], 2(4)
-// aix-NEXT: lhz [[REG2:.*]], 0(4)
-// aix-NEXT: stb [[REG1]], 2(3)
-// aix-NEXT: sth [[REG2]], 0(3)
-// elfv1-be: lbz [[REG1:.*]], 2(4)
-// elfv1-be-NEXT: lhz [[REG2:.*]], 0(4)
-// elfv1-be-NEXT: stb [[REG1]], 2(3)
-// elfv1-be-NEXT: sth [[REG2]], 0(3)
-// elfv2-be: lhz [[REG1:.*]], 0(3)
-// elfv2-be-NEXT: lbz 3, 2(3)
-// elfv2-be-NEXT: rldimi 3, [[REG1]], 8, 0
-// elfv2-le: lbz [[REG1:.*]], 2(3)
-// elfv2-le-NEXT: lhz 3, 0(3)
-// elfv2-le-NEXT: rldimi 3, [[REG1]], 16, 0
-// CHECK-NEXT: blr
-#[no_mangle]
-extern "C" fn read_small(x: &ThreeU8s) -> ThreeU8s {
-    *x
-}
-
-// CHECK-LABEL: write_large
-// aix: std 3, 48(1)
-// aix-NEXT: rldicl [[REG1:.*]], 5, 32, 32
-// aix-NEXT: std 5, 64(1)
-// aix-NEXT: std 4, 56(1)
-// aix-NEXT: stw [[REG1]], 16(6)
-// aix-NEXT: addi [[REG2:.*]], 1, 48
-// aix-NEXT: lxv{{d2x|w4x}} 0, 0, [[REG2]]
-// aix-NEXT: stxv{{d2x|w4x}} 0, 0, 6
-// elf: std 3, 0(6)
-// be-NEXT: rldicl [[REG1:.*]], 5, 32, 32
-// elf-NEXT: std 4, 8(6)
-// be-NEXT: stw [[REG1]], 16(6)
-// elfv2-le-NEXT: stw 5, 16(6)
-// CHECK-NEXT: blr
-#[no_mangle]
-extern "C" fn write_large(x: FiveU32s, dest: &mut FiveU32s) {
-    *dest = x;
-}
-
-// CHECK-LABEL: write_medium
-// aix: std 4, 56(1)
-// aix-NEXT: rldicl [[REG1:.*]], 4, 16, 48
-// aix-NEXT: std 3, 48(1)
-// aix-NEXT: std 3, 0(5)
-// aix-NEXT: sth [[REG1]], 8(5)
-// elf: std 3, 0(5)
-// be-NEXT: rldicl [[REG1:.*]], 4, 16, 48
-// be-NEXT: sth [[REG1]], 8(5)
-// elfv2-le-NEXT: sth 4, 8(5)
-// CHECK-NEXT: blr
-#[no_mangle]
-extern "C" fn write_medium(x: FiveU16s, dest: &mut FiveU16s) {
-    *dest = x;
-}
-
-// CHECK-LABEL: write_small
-// aix: std 3, 48(1)
-// aix-NEXT: rldicl [[REG1:.*]], 3, 16, 48
-// aix-NEXT: sth 3, 0(4)
-// aix-NEXT: lbz 3, 50(1)
-// aix-NEXT: stb [[REG1]], 2(4)
-// be: stb 3, 2(4)
-// be-NEXT: srwi [[REG1:.*]], 3, 8
-// be-NEXT: sth [[REG1]], 0(4)
-// The order these instructions are emitted in changed in LLVM 18.
-// elfv2-le-DAG: sth 3, 0(4)
-// elfv2-le-DAG: srwi [[REG1:.*]], 3, 16
-// elfv2-le-NEXT: stb [[REG1]], 2(4)
-// CHECK-NEXT: blr
-#[no_mangle]
-extern "C" fn write_small(x: ThreeU8s, dest: &mut ThreeU8s) {
-    *dest = x;
-}
diff --git a/tests/assembly/riscv-float-struct-abi.rs b/tests/assembly/riscv-float-struct-abi.rs
deleted file mode 100644
index 5d9ac9d70b8..00000000000
--- a/tests/assembly/riscv-float-struct-abi.rs
+++ /dev/null
@@ -1,177 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3 --target riscv64gc-unknown-linux-gnu
-//@ needs-llvm-components: riscv
-
-#![feature(no_core, lang_items)]
-#![no_std]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C, align(64))]
-struct Aligned(f64);
-
-#[repr(C)]
-struct Padded(u8, Aligned);
-
-#[repr(C, packed)]
-struct Packed(u8, f32);
-
-impl Copy for Aligned {}
-impl Copy for Padded {}
-impl Copy for Packed {}
-
-extern "C" {
-    fn take_padded(x: Padded);
-    fn get_padded() -> Padded;
-    fn take_packed(x: Packed);
-    fn get_packed() -> Packed;
-}
-
-// CHECK-LABEL: pass_padded
-#[unsafe(no_mangle)]
-extern "C" fn pass_padded(out: &mut Padded, x: Padded) {
-    // CHECK: sb a1, 0(a0)
-    // CHECK-NEXT: fsd fa0, 64(a0)
-    // CHECK-NEXT: ret
-    *out = x;
-}
-
-// CHECK-LABEL: ret_padded
-#[unsafe(no_mangle)]
-extern "C" fn ret_padded(x: &Padded) -> Padded {
-    // CHECK: fld fa0, 64(a0)
-    // CHECK-NEXT: lbu a0, 0(a0)
-    // CHECK-NEXT: ret
-    *x
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn call_padded(x: &Padded) {
-    // CHECK: fld fa0, 64(a0)
-    // CHECK-NEXT: lbu a0, 0(a0)
-    // CHECK-NEXT: tail take_padded
-    unsafe {
-        take_padded(*x);
-    }
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn receive_padded(out: &mut Padded) {
-    // CHECK: addi sp, sp, -16
-    // CHECK-NEXT: .cfi_def_cfa_offset 16
-    // CHECK-NEXT: sd ra, [[#%d,RA_SPILL:]](sp)
-    // CHECK-NEXT: sd [[TEMP:.*]], [[#%d,TEMP_SPILL:]](sp)
-    // CHECK-NEXT: .cfi_offset ra, [[#%d,RA_SPILL - 16]]
-    // CHECK-NEXT: .cfi_offset [[TEMP]], [[#%d,TEMP_SPILL - 16]]
-    // CHECK-NEXT: mv [[TEMP]], a0
-    // CHECK-NEXT: call get_padded
-    // CHECK-NEXT: sb a0, 0([[TEMP]])
-    // CHECK-NEXT: fsd fa0, 64([[TEMP]])
-    // CHECK-NEXT: ld ra, [[#%d,RA_SPILL]](sp)
-    // CHECK-NEXT: ld [[TEMP]], [[#%d,TEMP_SPILL]](sp)
-    // CHECK: addi sp, sp, 16
-    // CHECK: ret
-    unsafe {
-        *out = get_padded();
-    }
-}
-
-// CHECK-LABEL: pass_packed
-#[unsafe(no_mangle)]
-extern "C" fn pass_packed(out: &mut Packed, x: Packed) {
-    // CHECK: addi sp, sp, -16
-    // CHECK-NEXT: .cfi_def_cfa_offset 16
-    // CHECK-NEXT: sb a1, 0(a0)
-    // CHECK-NEXT: fsw fa0, 8(sp)
-    // CHECK-NEXT: lw [[VALUE:.*]], 8(sp)
-    // CHECK-DAG: srli [[BYTE4:.*]], [[VALUE]], 24
-    // CHECK-DAG: srli [[BYTE3:.*]], [[VALUE]], 16
-    // CHECK-DAG: srli [[BYTE2:.*]], [[VALUE]], 8
-    // CHECK-DAG: sb [[VALUE]], 1(a0)
-    // CHECK-DAG: sb [[BYTE2]], 2(a0)
-    // CHECK-DAG: sb [[BYTE3]], 3(a0)
-    // CHECK-DAG: sb [[BYTE4]], 4(a0)
-    // CHECK-NEXT: addi sp, sp, 16
-    // CHECK: ret
-    *out = x;
-}
-
-// CHECK-LABEL: ret_packed
-#[unsafe(no_mangle)]
-extern "C" fn ret_packed(x: &Packed) -> Packed {
-    // CHECK: addi sp, sp, -16
-    // CHECK-NEXT: .cfi_def_cfa_offset 16
-    // CHECK-NEXT: lbu [[BYTE2:.*]], 2(a0)
-    // CHECK-NEXT: lbu [[BYTE1:.*]], 1(a0)
-    // CHECK-NEXT: lbu [[BYTE3:.*]], 3(a0)
-    // CHECK-NEXT: lbu [[BYTE4:.*]], 4(a0)
-    // CHECK-NEXT: slli [[SHIFTED2:.*]], [[BYTE2]], 8
-    // CHECK-NEXT: or [[BYTE12:.*]], [[SHIFTED2]], [[BYTE1]]
-    // CHECK-NEXT: slli [[SHIFTED3:.*]], [[BYTE3]], 16
-    // CHECK-NEXT: slli [[SHIFTED4:.*]], [[BYTE4]], 24
-    // CHECK-NEXT: or [[BYTE34:.*]], [[SHIFTED3]], [[SHIFTED4]]
-    // CHECK-NEXT: or [[VALUE:.*]], [[BYTE12]], [[BYTE34]]
-    // CHECK-NEXT: sw [[VALUE]], 8(sp)
-    // CHECK-NEXT: flw fa0, 8(sp)
-    // CHECK-NEXT: lbu a0, 0(a0)
-    // CHECK-NEXT: addi sp, sp, 16
-    // CHECK: ret
-    *x
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn call_packed(x: &Packed) {
-    // CHECK: addi sp, sp, -16
-    // CHECK-NEXT: .cfi_def_cfa_offset 16
-    // CHECK-NEXT: lbu [[BYTE2:.*]], 2(a0)
-    // CHECK-NEXT: lbu [[BYTE1:.*]], 1(a0)
-    // CHECK-NEXT: lbu [[BYTE3:.*]], 3(a0)
-    // CHECK-NEXT: lbu [[BYTE4:.*]], 4(a0)
-    // CHECK-NEXT: slli [[SHIFTED2:.*]], [[BYTE2]], 8
-    // CHECK-NEXT: or [[BYTE12:.*]], [[SHIFTED2]], [[BYTE1]]
-    // CHECK-NEXT: slli [[SHIFTED3:.*]], [[BYTE3]], 16
-    // CHECK-NEXT: slli [[SHIFTED4:.*]], [[BYTE4]], 24
-    // CHECK-NEXT: or [[BYTE34:.*]], [[SHIFTED3]], [[SHIFTED4]]
-    // CHECK-NEXT: or [[VALUE:.*]], [[BYTE12]], [[BYTE34]]
-    // CHECK-NEXT: sw [[VALUE]], 8(sp)
-    // CHECK-NEXT: flw fa0, 8(sp)
-    // CHECK-NEXT: lbu a0, 0(a0)
-    // CHECK-NEXT: addi sp, sp, 16
-    // CHECK: tail take_packed
-    unsafe {
-        take_packed(*x);
-    }
-}
-
-#[unsafe(no_mangle)]
-extern "C" fn receive_packed(out: &mut Packed) {
-    // CHECK: addi sp, sp, -32
-    // CHECK-NEXT: .cfi_def_cfa_offset 32
-    // CHECK-NEXT: sd ra, [[#%d,RA_SPILL:]](sp)
-    // CHECK-NEXT: sd [[TEMP:.*]], [[#%d,TEMP_SPILL:]](sp)
-    // CHECK-NEXT: .cfi_offset ra, [[#%d,RA_SPILL - 32]]
-    // CHECK-NEXT: .cfi_offset [[TEMP]], [[#%d,TEMP_SPILL - 32]]
-    // CHECK-NEXT: mv [[TEMP]], a0
-    // CHECK-NEXT: call get_packed
-    // CHECK-NEXT: sb a0, 0([[TEMP]])
-    // CHECK-NEXT: fsw fa0, [[FLOAT_SPILL:.*]](sp)
-    // CHECK-NEXT: lw [[VALUE:.*]], [[FLOAT_SPILL]](sp)
-    // CHECK-DAG: srli [[BYTE4:.*]], [[VALUE]], 24
-    // CHECK-DAG: srli [[BYTE3:.*]], [[VALUE]], 16
-    // CHECK-DAG: srli [[BYTE2:.*]], [[VALUE]], 8
-    // CHECK-DAG: sb [[VALUE]], 1([[TEMP]])
-    // CHECK-DAG: sb [[BYTE2]], 2([[TEMP]])
-    // CHECK-DAG: sb [[BYTE3]], 3([[TEMP]])
-    // CHECK-DAG: sb [[BYTE4]], 4([[TEMP]])
-    // CHECK-NEXT: ld ra, [[#%d,RA_SPILL]](sp)
-    // CHECK-NEXT: ld [[TEMP]], [[#%d,TEMP_SPILL]](sp)
-    // CHECK: addi sp, sp, 32
-    // CHECK: ret
-    unsafe {
-        *out = get_packed();
-    }
-}
diff --git a/tests/assembly/riscv-soft-abi-with-float-features.rs b/tests/assembly/riscv-soft-abi-with-float-features.rs
deleted file mode 100644
index 72cbd3841c1..00000000000
--- a/tests/assembly/riscv-soft-abi-with-float-features.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target riscv64imac-unknown-none-elf -Ctarget-feature=+f,+d
-//@ needs-llvm-components: riscv
-//@ revisions: LLVM-PRE-20 LLVM-POST-20
-//@ [LLVM-PRE-20] max-llvm-major-version: 19
-//@ [LLVM-POST-20] min-llvm-version: 20
-
-#![feature(no_core, lang_items, f16)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// This test checks that the floats are all returned in `a0` as required by the `lp64` ABI.
-
-// CHECK-LABEL: read_f16
-#[no_mangle]
-pub extern "C" fn read_f16(x: &f16) -> f16 {
-    // CHECK: lh a0, 0(a0)
-    // CHECK-NEXT: lui a1, 1048560
-    // CHECK-NEXT: or a0, a0, a1
-    // CHECK-NEXT: ret
-    *x
-}
-
-// CHECK-LABEL: read_f32
-#[no_mangle]
-pub extern "C" fn read_f32(x: &f32) -> f32 {
-    // LLVM-PRE-20: flw fa5, 0(a0)
-    // LLVM-PRE-20-NEXT: fmv.x.w a0, fa5
-    // LLVM-PRE-20-NEXT: ret
-    // LLVM-POST-20: lw a0, 0(a0)
-    // LLVM-POST-20-NEXT: ret
-    *x
-}
-
-// CHECK-LABEL: read_f64
-#[no_mangle]
-pub extern "C" fn read_f64(x: &f64) -> f64 {
-    // CHECK: ld a0, 0(a0)
-    // CHECK-NEXT: ret
-    *x
-}
diff --git a/tests/assembly/rust-abi-arg-attr.rs b/tests/assembly/rust-abi-arg-attr.rs
deleted file mode 100644
index 4f3673ccfc3..00000000000
--- a/tests/assembly/rust-abi-arg-attr.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-//@ assembly-output: emit-asm
-//@ revisions: riscv64 riscv64-zbb loongarch64
-//@ compile-flags: -C opt-level=3
-//@ [riscv64] compile-flags: --target riscv64gc-unknown-linux-gnu
-//@ [riscv64] needs-llvm-components: riscv
-//@ [riscv64-zbb] compile-flags: --target riscv64gc-unknown-linux-gnu
-//@ [riscv64-zbb] compile-flags: -C target-feature=+zbb
-//@ [riscv64-zbb] needs-llvm-components: riscv
-//@ [loongarch64] compile-flags: --target loongarch64-unknown-linux-gnu
-//@ [loongarch64] needs-llvm-components: loongarch
-
-#![feature(no_core, lang_items, intrinsics, rustc_attrs)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-// FIXME: Migrate these code after PR #130693 is landed.
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for i8 {}
-impl Copy for u32 {}
-impl Copy for i32 {}
-
-#[lang = "neg"]
-trait Neg {
-    type Output;
-
-    fn neg(self) -> Self::Output;
-}
-
-impl Neg for i8 {
-    type Output = i8;
-
-    fn neg(self) -> Self::Output {
-        -self
-    }
-}
-
-#[lang = "Ordering"]
-#[repr(i8)]
-enum Ordering {
-    Less = -1,
-    Equal = 0,
-    Greater = 1,
-}
-
-#[rustc_intrinsic]
-fn three_way_compare<T: Copy>(lhs: T, rhs: T) -> Ordering;
-
-// ^^^^^ core
-
-// Reimplementation of function `{integer}::max`.
-macro_rules! max {
-    ($a:expr, $b:expr) => {
-        match three_way_compare($a, $b) {
-            Ordering::Less | Ordering::Equal => $b,
-            Ordering::Greater => $a,
-        }
-    };
-}
-
-#[no_mangle]
-// CHECK-LABEL: issue_114508_u32:
-pub fn issue_114508_u32(a: u32, b: u32) -> u32 {
-    // CHECK-NEXT:       .cfi_startproc
-
-    // riscv64-NEXT:     bltu a1, a0, .[[RET:.+]]
-    // riscv64-NEXT:     mv a0, a1
-    // riscv64-NEXT: .[[RET]]:
-
-    // riscv64-zbb-NEXT: maxu a0, a0, a1
-
-    // loongarch64-NEXT: sltu $a2, $a1, $a0
-    // loongarch64-NEXT: masknez $a1, $a1, $a2
-    // loongarch64-NEXT: maskeqz $a0, $a0, $a2
-    // loongarch64-NEXT: or $a0, $a0, $a1
-
-    // CHECK-NEXT:       ret
-    max!(a, b)
-}
-
-#[no_mangle]
-// CHECK-LABEL: issue_114508_i32:
-pub fn issue_114508_i32(a: i32, b: i32) -> i32 {
-    // CHECK-NEXT:       .cfi_startproc
-
-    // riscv64-NEXT:     blt a1, a0, .[[RET:.+]]
-    // riscv64-NEXT:     mv a0, a1
-    // riscv64-NEXT: .[[RET]]:
-
-    // riscv64-zbb-NEXT: max a0, a0, a1
-
-    // loongarch64-NEXT: slt $a2, $a1, $a0
-    // loongarch64-NEXT: masknez $a1, $a1, $a2
-    // loongarch64-NEXT: maskeqz $a0, $a0, $a2
-    // loongarch64-NEXT: or $a0, $a0, $a1
-
-    // CHECK-NEXT:       ret
-    max!(a, b)
-}
diff --git a/tests/assembly/s390x-backchain-toggle.rs b/tests/assembly/s390x-backchain-toggle.rs
deleted file mode 100644
index 9bae15b7d11..00000000000
--- a/tests/assembly/s390x-backchain-toggle.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-//@ add-core-stubs
-//@ revisions: enable-backchain disable-backchain default-backchain
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3 --crate-type=lib --target=s390x-unknown-linux-gnu
-//@ needs-llvm-components: systemz
-//@[enable-backchain] compile-flags: -Ctarget-feature=+backchain
-//@[disable-backchain] compile-flags: -Ctarget-feature=-backchain
-#![feature(no_core, lang_items)]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-extern "C" {
-    fn extern_func();
-}
-
-// CHECK-LABEL: test_backchain
-#[no_mangle]
-extern "C" fn test_backchain() -> i32 {
-    // Here we try to match if backchain register is saved to the parameter area (stored in r15/sp)
-    // And also if a new parameter area (160 bytes) is allocated for the upcoming function call
-    // enable-backchain: lgr [[REG1:.*]], %r15
-    // enable-backchain-NEXT: aghi %r15, -160
-    // enable-backchain: stg [[REG1]], 0(%r15)
-    // disable-backchain: aghi %r15, -160
-    // disable-backchain-NOT: stg %r{{.*}}, 0(%r15)
-    // default-backchain: aghi %r15, -160
-    // default-backchain-NOT: stg %r{{.*}}, 0(%r15)
-    unsafe {
-        extern_func();
-    }
-    // enable-backchain-NEXT: brasl %r{{.*}}, extern_func@PLT
-    // disable-backchain: brasl %r{{.*}}, extern_func@PLT
-
-    // Make sure that the expected return value is written into %r2 (return register):
-    // enable-backchain-NEXT: lghi %r2, 1
-    // disable-backchain: lghi %r2, 0
-    // default-backchain: lghi %r2, 0
-    #[cfg(target_feature = "backchain")]
-    {
-        1
-    }
-    #[cfg(not(target_feature = "backchain"))]
-    {
-        0
-    }
-    // CHECK: br %r{{.*}}
-}
diff --git a/tests/assembly/s390x-vector-abi.rs b/tests/assembly/s390x-vector-abi.rs
deleted file mode 100644
index fcf42664034..00000000000
--- a/tests/assembly/s390x-vector-abi.rs
+++ /dev/null
@@ -1,327 +0,0 @@
-//@ revisions: z10 z10_vector z13 z13_no_vector
-// ignore-tidy-linelength
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-//@[z10] compile-flags: --target s390x-unknown-linux-gnu  -C target-cpu=z10 --cfg no_vector
-//@[z10] needs-llvm-components: systemz
-//@[z10_vector] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z10 -C target-feature=+vector
-//@[z10_vector] needs-llvm-components: systemz
-//@[z13] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z13
-//@[z13] needs-llvm-components: systemz
-//@[z13_no_vector] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z13 -C target-feature=-vector --cfg no_vector
-//@[z13_no_vector] needs-llvm-components: systemz
-
-#![feature(no_core, lang_items, repr_simd, s390x_target_feature)]
-#![no_core]
-#![crate_type = "lib"]
-#![allow(non_camel_case_types)]
-// Cases where vector feature is disabled are rejected.
-// See tests/ui/simd-abi-checks-s390x.rs for test for them.
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-#[lang = "copy"]
-pub trait Copy {}
-#[lang = "freeze"]
-pub trait Freeze {}
-
-impl<T: Copy, const N: usize> Copy for [T; N] {}
-
-#[lang = "phantom_data"]
-pub struct PhantomData<T: ?Sized>;
-impl<T: ?Sized> Copy for PhantomData<T> {}
-
-#[repr(simd)]
-pub struct i8x8([i8; 8]);
-#[repr(simd)]
-pub struct i8x16([i8; 16]);
-#[repr(simd)]
-pub struct i8x32([i8; 32]);
-#[repr(C)]
-pub struct Wrapper<T>(T);
-#[repr(C, align(16))]
-pub struct WrapperAlign16<T>(T);
-#[repr(C)]
-pub struct WrapperWithZst<T>(T, PhantomData<()>);
-#[repr(transparent)]
-pub struct TransparentWrapper<T>(T);
-
-impl Copy for i8 {}
-impl Copy for i64 {}
-impl Copy for i8x8 {}
-impl Copy for i8x16 {}
-impl Copy for i8x32 {}
-impl<T: Copy> Copy for Wrapper<T> {}
-impl<T: Copy> Copy for WrapperAlign16<T> {}
-impl<T: Copy> Copy for WrapperWithZst<T> {}
-impl<T: Copy> Copy for TransparentWrapper<T> {}
-
-// CHECK-LABEL: vector_ret_small:
-// CHECK: vlrepg %v24, 0(%r2)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_ret_small(x: &i8x8) -> i8x8 {
-    *x
-}
-// CHECK-LABEL: vector_ret:
-// CHECK: vl %v24, 0(%r2), 3
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_ret(x: &i8x16) -> i8x16 {
-    *x
-}
-// CHECK-LABEL: vector_ret_large:
-// z10: vl %v0, 16(%r3), 4
-// z10-NEXT: vl %v1, 0(%r3), 4
-// z10-NEXT: vst %v0, 16(%r2), 4
-// z10-NEXT: vst %v1, 0(%r2), 4
-// z10-NEXT: br %r14
-// z13: vl %v0, 0(%r3), 4
-// z13-NEXT: vl %v1, 16(%r3), 4
-// z13-NEXT: vst %v1, 16(%r2), 4
-// z13-NEXT: vst %v0, 0(%r2), 4
-// z13-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_ret_large(x: &i8x32) -> i8x32 {
-    *x
-}
-
-// CHECK-LABEL: vector_wrapper_ret_small:
-// CHECK: mvc 0(8,%r2), 0(%r3)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_ret_small(x: &Wrapper<i8x8>) -> Wrapper<i8x8> {
-    *x
-}
-// CHECK-LABEL: vector_wrapper_ret:
-// CHECK: mvc 0(16,%r2), 0(%r3)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_ret(x: &Wrapper<i8x16>) -> Wrapper<i8x16> {
-    *x
-}
-// CHECK-LABEL: vector_wrapper_ret_large:
-// z10: vl %v0, 16(%r3), 4
-// z10-NEXT: vl %v1, 0(%r3), 4
-// z10-NEXT: vst %v0, 16(%r2), 4
-// z10-NEXT: vst %v1, 0(%r2), 4
-// z10-NEXT: br %r14
-// z13: vl %v0, 16(%r3), 4
-// z13-NEXT: vst %v0, 16(%r2), 4
-// z13-NEXT: vl %v0, 0(%r3), 4
-// z13-NEXT: vst %v0, 0(%r2), 4
-// z13-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_ret_large(x: &Wrapper<i8x32>) -> Wrapper<i8x32> {
-    *x
-}
-
-// CHECK-LABEL: vector_wrapper_padding_ret:
-// CHECK: mvc 0(16,%r2), 0(%r3)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_padding_ret(x: &WrapperAlign16<i8x8>) -> WrapperAlign16<i8x8> {
-    *x
-}
-
-// CHECK-LABEL: vector_wrapper_with_zst_ret_small:
-// CHECK: mvc 0(8,%r2), 0(%r3)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_with_zst_ret_small(
-    x: &WrapperWithZst<i8x8>,
-) -> WrapperWithZst<i8x8> {
-    *x
-}
-// CHECK-LABEL: vector_wrapper_with_zst_ret:
-// CHECK: mvc 0(16,%r2), 0(%r3)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_with_zst_ret(
-    x: &WrapperWithZst<i8x16>,
-) -> WrapperWithZst<i8x16> {
-    *x
-}
-// CHECK-LABEL: vector_wrapper_with_zst_ret_large:
-// z10: vl %v0, 16(%r3), 4
-// z10-NEXT: vl %v1, 0(%r3), 4
-// z10-NEXT: vst %v0, 16(%r2), 4
-// z10-NEXT: vst %v1, 0(%r2), 4
-// z10-NEXT: br %r14
-// z13: vl %v0, 16(%r3), 4
-// z13-NEXT: vst %v0, 16(%r2), 4
-// z13-NEXT: vl %v0, 0(%r3), 4
-// z13-NEXT: vst %v0, 0(%r2), 4
-// z13-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_with_zst_ret_large(
-    x: &WrapperWithZst<i8x32>,
-) -> WrapperWithZst<i8x32> {
-    *x
-}
-
-// CHECK-LABEL: vector_transparent_wrapper_ret_small:
-// CHECK: vlrepg %v24, 0(%r2)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_transparent_wrapper_ret_small(
-    x: &TransparentWrapper<i8x8>,
-) -> TransparentWrapper<i8x8> {
-    *x
-}
-// CHECK-LABEL: vector_transparent_wrapper_ret:
-// CHECK: vl %v24, 0(%r2), 3
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_transparent_wrapper_ret(
-    x: &TransparentWrapper<i8x16>,
-) -> TransparentWrapper<i8x16> {
-    *x
-}
-// CHECK-LABEL: vector_transparent_wrapper_ret_large:
-// z10: vl %v0, 16(%r3), 4
-// z10-NEXT: vl %v1, 0(%r3), 4
-// z10-NEXT: vst %v0, 16(%r2), 4
-// z10-NEXT: vst %v1, 0(%r2), 4
-// z10-NEXT: br %r14
-// z13: vl %v0, 0(%r3), 4
-// z13-NEXT: vl %v1, 16(%r3), 4
-// z13-NEXT: vst %v1, 16(%r2), 4
-// z13-NEXT: vst %v0, 0(%r2), 4
-// z13-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_transparent_wrapper_ret_large(
-    x: &TransparentWrapper<i8x32>,
-) -> TransparentWrapper<i8x32> {
-    *x
-}
-
-// CHECK-LABEL: vector_arg_small:
-// CHECK: vlgvg %r2, %v24, 0
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_arg_small(x: i8x8) -> i64 {
-    unsafe { *(&x as *const i8x8 as *const i64) }
-}
-// CHECK-LABEL: vector_arg:
-// CHECK: vlgvg %r2, %v24, 0
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_arg(x: i8x16) -> i64 {
-    unsafe { *(&x as *const i8x16 as *const i64) }
-}
-// CHECK-LABEL: vector_arg_large:
-// CHECK: lg %r2, 0(%r2)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_arg_large(x: i8x32) -> i64 {
-    unsafe { *(&x as *const i8x32 as *const i64) }
-}
-
-// CHECK-LABEL: vector_wrapper_arg_small:
-// CHECK: vlgvg %r2, %v24, 0
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_arg_small(x: Wrapper<i8x8>) -> i64 {
-    unsafe { *(&x as *const Wrapper<i8x8> as *const i64) }
-}
-// CHECK-LABEL: vector_wrapper_arg:
-// CHECK: vlgvg %r2, %v24, 0
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_arg(x: Wrapper<i8x16>) -> i64 {
-    unsafe { *(&x as *const Wrapper<i8x16> as *const i64) }
-}
-// CHECK-LABEL: vector_wrapper_arg_large:
-// CHECK: lg %r2, 0(%r2)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_arg_large(x: Wrapper<i8x32>) -> i64 {
-    unsafe { *(&x as *const Wrapper<i8x32> as *const i64) }
-}
-
-// https://github.com/rust-lang/rust/pull/131586#discussion_r1837071121
-// CHECK-LABEL: vector_wrapper_padding_arg:
-// CHECK: lg %r2, 0(%r2)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_padding_arg(x: WrapperAlign16<i8x8>) -> i64 {
-    unsafe { *(&x as *const WrapperAlign16<i8x8> as *const i64) }
-}
-
-// CHECK-LABEL: vector_wrapper_with_zst_arg_small:
-// CHECK: .cfi_startproc
-// CHECK-NOT: vlgvg
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_with_zst_arg_small(x: WrapperWithZst<i8x8>) -> i64 {
-    unsafe { *(&x as *const WrapperWithZst<i8x8> as *const i64) }
-}
-// CHECK-LABEL: vector_wrapper_with_zst_arg:
-// CHECK: lg %r2, 0(%r2)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_with_zst_arg(x: WrapperWithZst<i8x16>) -> i64 {
-    unsafe { *(&x as *const WrapperWithZst<i8x16> as *const i64) }
-}
-// CHECK-LABEL: vector_wrapper_with_zst_arg_large:
-// CHECK: lg %r2, 0(%r2)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_wrapper_with_zst_arg_large(x: WrapperWithZst<i8x32>) -> i64 {
-    unsafe { *(&x as *const WrapperWithZst<i8x32> as *const i64) }
-}
-
-// CHECK-LABEL: vector_transparent_wrapper_arg_small:
-// CHECK: vlgvg %r2, %v24, 0
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_transparent_wrapper_arg_small(x: TransparentWrapper<i8x8>) -> i64 {
-    unsafe { *(&x as *const TransparentWrapper<i8x8> as *const i64) }
-}
-// CHECK-LABEL: vector_transparent_wrapper_arg:
-// CHECK: vlgvg %r2, %v24, 0
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_transparent_wrapper_arg(x: TransparentWrapper<i8x16>) -> i64 {
-    unsafe { *(&x as *const TransparentWrapper<i8x16> as *const i64) }
-}
-// CHECK-LABEL: vector_transparent_wrapper_arg_large:
-// CHECK: lg %r2, 0(%r2)
-// CHECK-NEXT: br %r14
-#[cfg_attr(no_vector, target_feature(enable = "vector"))]
-#[no_mangle]
-unsafe extern "C" fn vector_transparent_wrapper_arg_large(x: TransparentWrapper<i8x32>) -> i64 {
-    unsafe { *(&x as *const TransparentWrapper<i8x32> as *const i64) }
-}
diff --git a/tests/assembly/sanitizer/kcfi/emit-arity-indicator.rs b/tests/assembly/sanitizer/kcfi/emit-arity-indicator.rs
deleted file mode 100644
index f9966a23446..00000000000
--- a/tests/assembly/sanitizer/kcfi/emit-arity-indicator.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Verifies that KCFI arity indicator is emitted.
-//
-//@ add-core-stubs
-//@ revisions: x86_64
-//@ 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)]
-#![no_core]
-
-extern crate minicore;
-
-unsafe extern "C" {
-    safe fn add(x: i32, y: i32) -> i32;
-}
-
-pub fn add_one(x: i32) -> i32 {
-    // CHECK-LABEL: __cfi__{{.*}}7add_one{{.*}}:
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  mov ecx, 2628068948
-    add(x, 1)
-}
-
-pub fn add_two(x: i32, _y: i32) -> i32 {
-    // CHECK-LABEL: __cfi__{{.*}}7add_two{{.*}}:
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  mov edx, 2505940310
-    add(x, 2)
-}
-
-pub fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: __cfi__{{.*}}8do_twice{{.*}}:
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  nop
-    // CHECK-NEXT:  mov edx, 653723426
-    add(f(arg), f(arg))
-}
diff --git a/tests/assembly/simd-bitmask.rs b/tests/assembly/simd-bitmask.rs
deleted file mode 100644
index d3e20f6ae1a..00000000000
--- a/tests/assembly/simd-bitmask.rs
+++ /dev/null
@@ -1,147 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x86 x86-avx2 x86-avx512 aarch64
-//@ [x86] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@ [x86] needs-llvm-components: x86
-//@ [x86-avx2] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@ [x86-avx2] compile-flags: -C target-feature=+avx2
-//@ [x86-avx2] needs-llvm-components: x86
-//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
-//@ [x86-avx512] needs-llvm-components: x86
-//@ [aarch64] compile-flags: --target=aarch64-unknown-linux-gnu
-//@ [aarch64] needs-llvm-components: aarch64
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
-
-#![feature(no_core, lang_items, repr_simd, intrinsics)]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(simd)]
-pub struct m8x16([i8; 16]);
-
-#[repr(simd)]
-pub struct m8x64([i8; 64]);
-
-#[repr(simd)]
-pub struct m32x4([i32; 4]);
-
-#[repr(simd)]
-pub struct m64x2([i64; 2]);
-
-#[repr(simd)]
-pub struct m64x4([i64; 4]);
-
-#[rustc_intrinsic]
-unsafe fn simd_bitmask<V, B>(mask: V) -> B;
-
-// CHECK-LABEL: bitmask_m8x16
-#[no_mangle]
-pub unsafe extern "C" fn bitmask_m8x16(mask: m8x16) -> u16 {
-    // The simd_bitmask intrinsic already uses the most significant bit, so no shift is necessary.
-    // Note that x86 has no byte shift, llvm uses a word shift to move the least significant bit
-    // of each byte into the right position.
-    //
-    // x86-NOT: psllw
-    // x86: movmskb eax, xmm0
-    //
-    // x86-avx2-NOT: vpsllw
-    // x86-avx2: vpmovmskb eax, xmm0
-    //
-    // x86-avx512-NOT: vpsllw xmm0
-    // x86-avx512: vpmovmskb eax, xmm0
-    //
-    // aarch64: adrp
-    // aarch64-NEXT: cmlt
-    // aarch64-NEXT: ldr
-    // aarch64-NEXT: and
-    // aarch64-NEXT: ext
-    // aarch64-NEXT: zip1
-    // aarch64-NEXT: addv
-    // aarch64-NEXT: fmov
-    simd_bitmask(mask)
-}
-
-// x86-avx512-LABEL: bitmask_m8x64
-#[no_mangle]
-#[cfg(x86_avx512)]
-pub unsafe extern "C" fn bitmask_m8x64(mask: m8x64) -> u64 {
-    // The simd_bitmask intrinsic already uses the most significant bit, so no shift is necessary.
-    // Note that x86 has no byte shift, llvm uses a word shift to move the least significant bit
-    // of each byte into the right position.
-    //
-    // The parameter is a 512 bit vector which in the C abi is only valid for avx512 targets.
-    //
-    // x86-avx512-NOT: vpsllw
-    // x86-avx512: vpmovb2m k0, zmm0
-    // x86-avx512: kmovq rax, k0
-    simd_bitmask(mask)
-}
-
-// CHECK-LABEL: bitmask_m32x4
-#[no_mangle]
-pub unsafe extern "C" fn bitmask_m32x4(mask: m32x4) -> u8 {
-    // The simd_bitmask intrinsic already uses the most significant bit, so no shift is necessary.
-    //
-    // x86-NOT: psllq
-    // x86: movmskps eax, xmm0
-    //
-    // x86-avx2-NOT: vpsllq
-    // x86-avx2: vmovmskps eax, xmm0
-    //
-    // x86-avx512-NOT: vpsllq
-    // x86-avx512: vmovmskps eax, xmm0
-    //
-    // aarch64: adrp
-    // aarch64-NEXT: cmlt
-    // aarch64-NEXT: ldr
-    // aarch64-NEXT: and
-    // aarch64-NEXT: addv
-    // aarch64-NEXT: fmov
-    // aarch64-NEXT: and
-    simd_bitmask(mask)
-}
-
-// CHECK-LABEL: bitmask_m64x2
-#[no_mangle]
-pub unsafe extern "C" fn bitmask_m64x2(mask: m64x2) -> u8 {
-    // The simd_bitmask intrinsic already uses the most significant bit, so no shift is necessary.
-    //
-    // x86-NOT: psllq
-    // x86: movmskpd eax, xmm0
-    //
-    // x86-avx2-NOT: vpsllq
-    // x86-avx2: vmovmskpd eax, xmm0
-    //
-    // x86-avx512-NOT: vpsllq
-    // x86-avx512: vmovmskpd eax, xmm0
-    //
-    // aarch64: adrp
-    // aarch64-NEXT: cmlt
-    // aarch64-NEXT: ldr
-    // aarch64-NEXT: and
-    // aarch64-NEXT: addp
-    // aarch64-NEXT: fmov
-    // aarch64-NEXT: and
-    simd_bitmask(mask)
-}
-
-// x86-avx2-LABEL: bitmask_m64x4
-// x86-avx512-LABEL: bitmask_m64x4
-#[no_mangle]
-#[cfg(any(x86_avx2, x86_avx512))]
-pub unsafe extern "C" fn bitmask_m64x4(mask: m64x4) -> u8 {
-    // The simd_bitmask intrinsic already uses the most significant bit, so no shift is necessary.
-    //
-    // The parameter is a 256 bit vector which in the C abi is only valid for avx/avx512 targets.
-    //
-    // x86-avx2-NOT: vpsllq
-    // x86-avx2: vmovmskpd eax, ymm0
-    //
-    // x86-avx512-NOT: vpsllq
-    // x86-avx512: vmovmskpd eax, ymm0
-    simd_bitmask(mask)
-}
diff --git a/tests/assembly/simd-intrinsic-gather.rs b/tests/assembly/simd-intrinsic-gather.rs
deleted file mode 100644
index bcab0ba1cc0..00000000000
--- a/tests/assembly/simd-intrinsic-gather.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x86-avx512
-//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
-//@ [x86-avx512] needs-llvm-components: x86
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
-
-#![feature(no_core, lang_items, repr_simd, intrinsics)]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(simd)]
-pub struct f64x4([f64; 4]);
-
-#[repr(simd)]
-pub struct m64x4([i64; 4]);
-
-#[repr(simd)]
-pub struct pf64x4([*const f64; 4]);
-
-#[rustc_intrinsic]
-unsafe fn simd_gather<V, M, P>(values: V, mask: M, pointer: P) -> V;
-
-// CHECK-LABEL: gather_f64x4
-#[no_mangle]
-pub unsafe extern "C" fn gather_f64x4(mask: m64x4, ptrs: pf64x4) -> f64x4 {
-    // FIXME: This should also get checked to generate a gather instruction for avx2.
-    // Currently llvm scalarizes this code, see https://github.com/llvm/llvm-project/issues/59789
-    //
-    // x86-avx512-NOT: vpsllq
-    // x86-avx512: vpmovq2m k1, ymm0
-    // x86-avx512-NEXT: vpxor xmm0, xmm0, xmm0
-    // x86-avx512-NEXT: vgatherqpd ymm0 {k1}, {{(ymmword)|(qword)}} ptr [1*ymm1]
-    simd_gather(f64x4([0_f64, 0_f64, 0_f64, 0_f64]), ptrs, mask)
-}
diff --git a/tests/assembly/simd-intrinsic-mask-load.rs b/tests/assembly/simd-intrinsic-mask-load.rs
deleted file mode 100644
index d3f3453a780..00000000000
--- a/tests/assembly/simd-intrinsic-mask-load.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x86-avx2 x86-avx512
-//@ [x86-avx2] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@ [x86-avx2] compile-flags: -C target-feature=+avx2
-//@ [x86-avx2] needs-llvm-components: x86
-//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
-//@ [x86-avx512] needs-llvm-components: x86
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
-
-#![feature(no_core, lang_items, repr_simd, intrinsics)]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(simd)]
-pub struct i8x16([i8; 16]);
-
-#[repr(simd)]
-pub struct m8x16([i8; 16]);
-
-#[repr(simd)]
-pub struct f32x8([f32; 8]);
-
-#[repr(simd)]
-pub struct m32x8([i32; 8]);
-
-#[repr(simd)]
-pub struct f64x4([f64; 4]);
-
-#[repr(simd)]
-pub struct m64x4([i64; 4]);
-
-#[rustc_intrinsic]
-unsafe fn simd_masked_load<M, P, T>(mask: M, pointer: P, values: T) -> T;
-
-// CHECK-LABEL: load_i8x16
-#[no_mangle]
-pub unsafe extern "C" fn load_i8x16(mask: m8x16, pointer: *const i8) -> i8x16 {
-    // Since avx2 supports no masked loads for bytes, the code tests each individual bit
-    // and jumps to code that inserts individual bytes.
-    // x86-avx2-NOT: vpsllw
-    // x86-avx2-DAG: vpmovmskb eax
-    // x86-avx2-DAG: vpxor
-    // x86-avx2-NEXT: test al, 1
-    // x86-avx2-NEXT: jne
-    // x86-avx2-NEXT: test al, 2
-    // x86-avx2-NEXT: jne
-    // x86-avx2-DAG: movzx [[REG:[a-z]+]], byte ptr [rdi]
-    // x86-avx2-NEXT: vmovd xmm0, [[REG]]
-    // x86-avx2-DAG: vpinsrb xmm0, xmm0, byte ptr [rdi + 1], 1
-    //
-    // x86-avx512-NOT: vpsllw
-    // x86-avx512: vpmovb2m k1, xmm0
-    // x86-avx512-NEXT: vmovdqu8 xmm0 {k1} {z}, xmmword ptr [rdi]
-    simd_masked_load(mask, pointer, i8x16([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
-}
-
-// CHECK-LABEL: load_f32x8
-#[no_mangle]
-pub unsafe extern "C" fn load_f32x8(mask: m32x8, pointer: *const f32) -> f32x8 {
-    // x86-avx2-NOT: vpslld
-    // x86-avx2: vmaskmovps ymm0, ymm0, ymmword ptr [rdi]
-    //
-    // x86-avx512-NOT: vpslld
-    // x86-avx512: vpmovd2m k1, ymm0
-    // x86-avx512-NEXT: vmovups ymm0 {k1} {z}, ymmword ptr [rdi]
-    simd_masked_load(mask, pointer, f32x8([0_f32, 0_f32, 0_f32, 0_f32, 0_f32, 0_f32, 0_f32, 0_f32]))
-}
-
-// CHECK-LABEL: load_f64x4
-#[no_mangle]
-pub unsafe extern "C" fn load_f64x4(mask: m64x4, pointer: *const f64) -> f64x4 {
-    // x86-avx2-NOT: vpsllq
-    // x86-avx2: vmaskmovpd ymm0, ymm0, ymmword ptr [rdi]
-    //
-    // x86-avx512-NOT: vpsllq
-    // x86-avx512: vpmovq2m k1, ymm0
-    simd_masked_load(mask, pointer, f64x4([0_f64, 0_f64, 0_f64, 0_f64]))
-}
diff --git a/tests/assembly/simd-intrinsic-mask-reduce.rs b/tests/assembly/simd-intrinsic-mask-reduce.rs
deleted file mode 100644
index 8b15ed0a254..00000000000
--- a/tests/assembly/simd-intrinsic-mask-reduce.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-// verify that simd mask reductions do not introduce additional bit shift operations
-//@ add-core-stubs
-//@ revisions: x86 aarch64
-//@ [x86] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-// Set the base cpu explicitly, in case the default has been changed.
-//@ [x86] compile-flags: -C target-cpu=x86-64
-//@ [x86] needs-llvm-components: x86
-//@ [aarch64] compile-flags: --target=aarch64-unknown-linux-gnu
-//@ [aarch64] needs-llvm-components: aarch64
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
-
-#![feature(no_core, lang_items, repr_simd, intrinsics)]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(simd)]
-pub struct mask8x16([i8; 16]);
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_all<T>(x: T) -> bool;
-#[rustc_intrinsic]
-unsafe fn simd_reduce_any<T>(x: T) -> bool;
-
-// CHECK-LABEL: mask_reduce_all:
-#[no_mangle]
-pub unsafe extern "C" fn mask_reduce_all(m: mask8x16) -> bool {
-    // x86-NOT: psllw
-    // x86: pmovmskb eax, xmm0
-    // x86-NEXT: {{cmp ax, -1|cmp eax, 65535|xor eax, 65535}}
-    // x86-NEXT: sete al
-    //
-    // aarch64-NOT: shl
-    // aarch64: cmge v0.16b, v0.16b, #0
-    // aarch64-DAG: mov [[REG1:[a-z0-9]+]], #1
-    // aarch64-DAG: umaxv b0, v0.16b
-    // aarch64-NEXT: fmov [[REG2:[a-z0-9]+]], s0
-    // aarch64-NEXT: bic w0, [[REG1]], [[REG2]]
-    simd_reduce_all(m)
-}
-
-// CHECK-LABEL: mask_reduce_any:
-#[no_mangle]
-pub unsafe extern "C" fn mask_reduce_any(m: mask8x16) -> bool {
-    // x86-NOT: psllw
-    // x86: pmovmskb
-    // x86-NEXT: test eax, eax
-    // x86-NEXT: setne al
-    //
-    // aarch64-NOT: shl
-    // aarch64: cmlt v0.16b, v0.16b, #0
-    // aarch64-NEXT: umaxv b0, v0.16b
-    // aarch64-NEXT: fmov [[REG:[a-z0-9]+]], s0
-    // aarch64-NEXT: and w0, [[REG]], #0x1
-    simd_reduce_any(m)
-}
diff --git a/tests/assembly/simd-intrinsic-mask-store.rs b/tests/assembly/simd-intrinsic-mask-store.rs
deleted file mode 100644
index 001762e5060..00000000000
--- a/tests/assembly/simd-intrinsic-mask-store.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x86-avx2 x86-avx512
-//@ [x86-avx2] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@ [x86-avx2] compile-flags: -C target-feature=+avx2
-//@ [x86-avx2] needs-llvm-components: x86
-//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
-//@ [x86-avx512] needs-llvm-components: x86
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
-
-#![feature(no_core, lang_items, repr_simd, intrinsics)]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(simd)]
-pub struct i8x16([i8; 16]);
-
-#[repr(simd)]
-pub struct m8x16([i8; 16]);
-
-#[repr(simd)]
-pub struct f32x8([f32; 8]);
-
-#[repr(simd)]
-pub struct m32x8([i32; 8]);
-
-#[repr(simd)]
-pub struct f64x4([f64; 4]);
-
-#[repr(simd)]
-pub struct m64x4([i64; 4]);
-
-#[rustc_intrinsic]
-unsafe fn simd_masked_store<M, P, T>(mask: M, pointer: P, values: T);
-
-// CHECK-LABEL: store_i8x16
-#[no_mangle]
-pub unsafe extern "C" fn store_i8x16(mask: m8x16, pointer: *mut i8, value: i8x16) {
-    // Since avx2 supports no masked stores for bytes, the code tests each individual bit
-    // and jumps to code that extracts individual bytes to memory.
-    // x86-avx2-NOT: vpsllw
-    // x86-avx2: vpmovmskb eax, xmm0
-    // x86-avx2-NEXT: test al, 1
-    // x86-avx2-NEXT: jne
-    // x86-avx2-NEXT: test al, 2
-    // x86-avx2-NEXT: jne
-    // x86-avx2-DAG: vpextrb byte ptr [rdi + 1], xmm1, 1
-    // x86-avx2-DAG: vpextrb byte ptr [rdi], xmm1, 0
-    //
-    // x86-avx512-NOT: vpsllw
-    // x86-avx512: vpmovb2m k1, xmm0
-    // x86-avx512-NEXT: vmovdqu8 xmmword ptr [rdi] {k1}, xmm1
-    simd_masked_store(mask, pointer, value)
-}
-
-// CHECK-LABEL: store_f32x8
-#[no_mangle]
-pub unsafe extern "C" fn store_f32x8(mask: m32x8, pointer: *mut f32, value: f32x8) {
-    // x86-avx2-NOT: vpslld
-    // x86-avx2: vmaskmovps ymmword ptr [rdi], ymm0, ymm1
-    //
-    // x86-avx512-NOT: vpslld
-    // x86-avx512: vpmovd2m k1, ymm0
-    // x86-avx512-NEXT: vmovups ymmword ptr [rdi] {k1}, ymm1
-    simd_masked_store(mask, pointer, value)
-}
-
-// CHECK-LABEL: store_f64x4
-#[no_mangle]
-pub unsafe extern "C" fn store_f64x4(mask: m64x4, pointer: *mut f64, value: f64x4) {
-    // x86-avx2-NOT: vpsllq
-    // x86-avx2: vmaskmovpd ymmword ptr [rdi], ymm0, ymm1
-    //
-    // x86-avx512-NOT: vpsllq
-    // x86-avx512: vpmovq2m k1, ymm0
-    // x86-avx512-NEXT: vmovupd ymmword ptr [rdi] {k1}, ymm1
-    simd_masked_store(mask, pointer, value)
-}
diff --git a/tests/assembly/simd-intrinsic-scatter.rs b/tests/assembly/simd-intrinsic-scatter.rs
deleted file mode 100644
index d77dfad3546..00000000000
--- a/tests/assembly/simd-intrinsic-scatter.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x86-avx512
-//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
-//@ [x86-avx512] needs-llvm-components: x86
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
-
-#![feature(no_core, lang_items, repr_simd, intrinsics)]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(simd)]
-pub struct f64x4([f64; 4]);
-
-#[repr(simd)]
-pub struct m64x4([i64; 4]);
-
-#[repr(simd)]
-pub struct pf64x4([*mut f64; 4]);
-
-#[rustc_intrinsic]
-unsafe fn simd_scatter<V, P, M>(values: V, pointer: P, mask: M);
-
-// CHECK-LABEL: scatter_f64x4
-#[no_mangle]
-pub unsafe extern "C" fn scatter_f64x4(values: f64x4, ptrs: pf64x4, mask: m64x4) {
-    // x86-avx512-NOT: vpsllq
-    // x86-avx512: vpmovq2m k1, ymm2
-    // x86-avx512-NEXT: vscatterqpd {{(ymmword)|(qword)}} ptr [1*ymm1] {k1}, ymm0
-    simd_scatter(values, ptrs, mask)
-}
diff --git a/tests/assembly/simd-intrinsic-select.rs b/tests/assembly/simd-intrinsic-select.rs
deleted file mode 100644
index e7c7b0db0d5..00000000000
--- a/tests/assembly/simd-intrinsic-select.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x86-avx2 x86-avx512 aarch64
-//@ [x86-avx2] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@ [x86-avx2] compile-flags: -C target-feature=+avx2
-//@ [x86-avx2] needs-llvm-components: x86
-//@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
-//@ [x86-avx512] needs-llvm-components: x86
-//@ [aarch64] compile-flags: --target=aarch64-unknown-linux-gnu
-//@ [aarch64] needs-llvm-components: aarch64
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C panic=abort
-
-#![feature(no_core, lang_items, repr_simd, intrinsics)]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(simd)]
-pub struct i8x16([i8; 16]);
-
-#[repr(simd)]
-pub struct m8x16([i8; 16]);
-
-#[repr(simd)]
-pub struct f32x4([f32; 4]);
-
-#[repr(simd)]
-pub struct m32x4([i32; 4]);
-
-#[repr(simd)]
-pub struct f64x2([f64; 2]);
-
-#[repr(simd)]
-pub struct m64x2([i64; 2]);
-
-#[repr(simd)]
-pub struct f64x4([f64; 4]);
-
-#[repr(simd)]
-pub struct m64x4([i64; 4]);
-
-#[repr(simd)]
-pub struct f64x8([f64; 8]);
-
-#[repr(simd)]
-pub struct m64x8([i64; 8]);
-
-#[rustc_intrinsic]
-unsafe fn simd_select<M, V>(mask: M, a: V, b: V) -> V;
-
-// CHECK-LABEL: select_i8x16
-#[no_mangle]
-pub unsafe extern "C" fn select_i8x16(mask: m8x16, a: i8x16, b: i8x16) -> i8x16 {
-    // x86-avx2-NOT: vpsllw
-    // x86-avx2: vpblendvb xmm0, xmm2, xmm1, xmm0
-    //
-    // x86-avx512-NOT: vpsllw
-    // x86-avx512: vpmovb2m k1, xmm0
-    // x86-avx512-NEXT: vpblendmb xmm0 {k1}, xmm2, xmm1
-    //
-    // aarch64-NOT: shl
-    // aarch64: cmlt v0.16b, v0.16b, #0
-    // aarch64-NEXT: bsl v0.16b, v1.16b, v2.16b
-    simd_select(mask, a, b)
-}
-
-// CHECK-LABEL: select_f32x4
-#[no_mangle]
-pub unsafe extern "C" fn select_f32x4(mask: m32x4, a: f32x4, b: f32x4) -> f32x4 {
-    // x86-avx2-NOT: vpslld
-    // x86-avx2: vblendvps xmm0, xmm2, xmm1, xmm0
-    //
-    // x86-avx512-NOT: vpslld
-    // x86-avx512: vpmovd2m k1, xmm0
-    // x86-avx512-NEXT: vblendmps xmm0 {k1}, xmm2, xmm1
-    //
-    // aarch64-NOT: shl
-    // aarch64: cmlt v0.4s, v0.4s, #0
-    // aarch64-NEXT: bsl v0.16b, v1.16b, v2.16b
-    simd_select(mask, a, b)
-}
-
-// CHECK-LABEL: select_f64x2
-#[no_mangle]
-pub unsafe extern "C" fn select_f64x2(mask: m64x2, a: f64x2, b: f64x2) -> f64x2 {
-    // x86-avx2-NOT: vpsllq
-    // x86-avx2: vblendvpd xmm0, xmm2, xmm1, xmm0
-    //
-    // x86-avx512-NOT: vpsllq
-    // x86-avx512: vpmovq2m k1, xmm0
-    // x86-avx512-NEXT: vblendmpd xmm0 {k1}, xmm2, xmm1
-    //
-    // aarch64-NOT: shl
-    // aarch64: cmlt v0.2d, v0.2d, #0
-    // aarch64-NEXT: bsl v0.16b, v1.16b, v2.16b
-    simd_select(mask, a, b)
-}
-
-// x86-avx2-LABEL: select_f64x4
-// x86-avx512-LABEL: select_f64x4
-#[no_mangle]
-#[cfg(any(x86_avx2, x86_avx512))]
-pub unsafe extern "C" fn select_f64x4(mask: m64x4, a: f64x4, b: f64x4) -> f64x4 {
-    // The parameter is a 256 bit vector which in the C abi is only valid for avx targets.
-    //
-    // x86-avx2-NOT: vpsllq
-    // x86-avx2: vblendvpd ymm0, ymm2, ymm1, ymm0
-    //
-    // x86-avx512-NOT: vpsllq
-    // x86-avx512: vpmovq2m k1, ymm0
-    // x86-avx512-NEXT: vblendmpd ymm0 {k1}, ymm2, ymm1
-    simd_select(mask, a, b)
-}
-
-// x86-avx512-LABEL: select_f64x8
-#[no_mangle]
-#[cfg(x86_avx512)]
-pub unsafe extern "C" fn select_f64x8(mask: m64x8, a: f64x8, b: f64x8) -> f64x8 {
-    // The parameter is a 256 bit vector which in the C abi is only valid for avx512 targets.
-    //
-    // x86-avx512-NOT: vpsllq
-    // x86-avx512: vpmovq2m k1, zmm0
-    // x86-avx512-NEXT: vblendmpd zmm0 {k1}, zmm2, zmm1
-    simd_select(mask, a, b)
-}
diff --git a/tests/assembly/simd/reduce-fadd-unordered.rs b/tests/assembly/simd/reduce-fadd-unordered.rs
deleted file mode 100644
index e872826f6ef..00000000000
--- a/tests/assembly/simd/reduce-fadd-unordered.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ revisions: x86_64 aarch64
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3
-
-//@[aarch64] only-aarch64
-//@[x86_64] only-x86_64
-//@[x86_64] compile-flags: -Ctarget-feature=+sse3
-//@ ignore-sgx Test incompatible with LVI mitigations
-#![feature(portable_simd)]
-#![feature(core_intrinsics)]
-use std::intrinsics::simd as intrinsics;
-use std::simd::*;
-// Regression test for https://github.com/rust-lang/rust/issues/130028
-// This intrinsic produces much worse code if you use +0.0 instead of -0.0 because
-// +0.0 isn't as easy to algebraically reassociate, even using LLVM's reassoc attribute!
-// It would emit about an extra fadd, depending on the architecture.
-
-// CHECK-LABEL: reduce_fadd_negative_zero
-pub unsafe fn reduce_fadd_negative_zero(v: f32x4) -> f32 {
-    // x86_64: addps
-    // x86_64-NEXT: movshdup
-    // x86_64-NEXT: addss
-    // x86_64-NOT: xorps
-
-    // aarch64: faddp
-    // aarch64-NEXT: faddp
-
-    // CHECK-NOT: {{f?}}add{{p?s*}}
-    // CHECK: ret
-    intrinsics::simd_reduce_add_unordered(v)
-}
diff --git a/tests/assembly/slice-is_ascii.rs b/tests/assembly/slice-is_ascii.rs
deleted file mode 100644
index e53cd5160cf..00000000000
--- a/tests/assembly/slice-is_ascii.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ revisions: WIN LIN
-//@ [WIN] only-windows
-//@ [LIN] only-linux
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C llvm-args=-x86-asm-syntax=intel
-//@ only-x86_64
-//@ ignore-sgx
-
-#![feature(str_internals)]
-
-// CHECK-LABEL: is_ascii_simple_demo:
-#[no_mangle]
-pub fn is_ascii_simple_demo(bytes: &[u8]) -> bool {
-    // Linux (System V): pointer is rdi; length is rsi
-    // Windows: pointer is rcx; length is rdx.
-
-    // CHECK-NOT: mov
-    // CHECK-NOT: test
-    // CHECK-NOT: cmp
-
-    // CHECK: .[[LOOPHEAD:.+]]:
-    // CHECK-NEXT: mov [[TEMP:.+]], [[LEN:rsi|rdx]]
-    // CHECK-NEXT: sub [[LEN]], 1
-    // CHECK-NEXT: jb .[[LOOPEXIT:.+]]
-    // CHECK-NEXT: cmp byte ptr [{{rdi|rcx}} + [[TEMP]] - 1], 0
-    // CHECK-NEXT: jns .[[LOOPHEAD]]
-
-    // CHECK-NEXT: .[[LOOPEXIT]]:
-    // CHECK-NEXT: test [[TEMP]], [[TEMP]]
-    // CHECK-NEXT: sete al
-    // CHECK-NEXT: ret
-    core::slice::is_ascii_simple(bytes)
-}
diff --git a/tests/assembly/small_data_threshold.rs b/tests/assembly/small_data_threshold.rs
deleted file mode 100644
index 2abe8687d8b..00000000000
--- a/tests/assembly/small_data_threshold.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-// Test for -Z small_data_threshold=...
-//@ revisions: RISCV MIPS HEXAGON M68K
-//@ assembly-output: emit-asm
-//@ compile-flags: -Z small_data_threshold=4
-//@ [RISCV] compile-flags: --target=riscv32im-unknown-none-elf
-//@ [RISCV] needs-llvm-components: riscv
-//@ [MIPS] compile-flags: --target=mips-unknown-linux-uclibc -C relocation-model=static
-//@ [MIPS] compile-flags: -C llvm-args=-mgpopt -C llvm-args=-mlocal-sdata
-//@ [MIPS] compile-flags: -C target-feature=+noabicalls
-//@ [MIPS] needs-llvm-components: mips
-//@ [HEXAGON] compile-flags: --target=hexagon-unknown-linux-musl -C target-feature=+small-data
-//@ [HEXAGON] compile-flags: -C llvm-args=--hexagon-statics-in-small-data
-//@ [HEXAGON] needs-llvm-components: hexagon
-//@ [M68K] compile-flags: --target=m68k-unknown-linux-gnu
-//@ [M68K] needs-llvm-components: m68k
-
-#![feature(no_core, lang_items)]
-#![no_std]
-#![no_core]
-#![crate_type = "lib"]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-#[lang = "drop_in_place"]
-fn drop_in_place<T>(_: *mut T) {}
-
-#[used]
-#[no_mangle]
-// U is below the threshold, should be in sdata
-static mut U: u16 = 123;
-
-#[used]
-#[no_mangle]
-// V is below the threshold, should be in sbss
-static mut V: u16 = 0;
-
-#[used]
-#[no_mangle]
-// W is at the threshold, should be in sdata
-static mut W: u32 = 123;
-
-#[used]
-#[no_mangle]
-// X is at the threshold, should be in sbss
-static mut X: u32 = 0;
-
-#[used]
-#[no_mangle]
-// Y is over the threshold, should be in its own .data section
-static mut Y: u64 = 123;
-
-#[used]
-#[no_mangle]
-// Z is over the threshold, should be in its own .bss section
-static mut Z: u64 = 0;
-
-// Currently, only MIPS and RISCV successfully put any objects in the small data
-// sections so the U/V/W/X tests are skipped on Hexagon and M68K
-
-// RISCV: .section .sdata
-// RISCV-NOT: .section
-// RISCV: U:
-// RISCV: .section .sbss
-// RISCV-NOT: .section
-// RISCV: V:
-// RISCV: .section .sdata
-// RISCV-NOT: .section
-// RISCV: W:
-// RISCV: .section .sbss
-// RISCV-NOT: .section
-// RISCV: X:
-
-// MIPS: .section .sdata
-// MIPS-NOT: .section
-// MIPS: U:
-// MIPS: .section .sbss
-// MIPS-NOT: .section
-// MIPS: V:
-// MIPS: .section .sdata
-// MIPS-NOT: .section
-// MIPS: W:
-// MIPS: .section .sbss
-// MIPS-NOT: .section
-// MIPS: X:
-
-// CHECK: .section .data.Y,
-// CHECK-NOT: .section
-// CHECK: Y:
-// CHECK: .section .bss.Z,
-// CHECK-NOT: .section
-// CHECK: Z:
diff --git a/tests/assembly/sparc-struct-abi.rs b/tests/assembly/sparc-struct-abi.rs
deleted file mode 100644
index b1594428811..00000000000
--- a/tests/assembly/sparc-struct-abi.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-// Test SPARC64 ABI
-// - float structure members are passes in floating point registers
-// (#86163)
-
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ needs-llvm-components: sparc
-//@ compile-flags: --target=sparcv9-sun-solaris -Copt-level=3
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C)]
-pub struct Franta {
-    a: f32,
-    b: f32,
-    c: f32,
-    d: f32,
-}
-
-// NB: due to delay slots the `ld` following the call is actually executed before the call.
-#[no_mangle]
-pub unsafe extern "C" fn callee(arg: Franta) {
-    // CHECK-LABEL: callee:
-    // CHECK: st %f3, [[PLACE_D:.*]]
-    // CHECK: st %f2, [[PLACE_C:.*]]
-    // CHECK: st %f1, [[PLACE_B:.*]]
-    // CHECK: st %f0, [[PLACE_A:.*]]
-    // CHECK: call tst_use
-    // CHECK-NEXT: ld [[PLACE_A]], %f1
-    // CHECK: call tst_use
-    // CHECK-NEXT: ld [[PLACE_B]], %f1
-    // CHECK: call tst_use
-    // CHECK-NEXT: ld [[PLACE_C]], %f1
-    // CHECK: call tst_use
-    // CHECK-NEXT: ld [[PLACE_D]], %f1
-    clobber();
-    tst_use(arg.a);
-    tst_use(arg.b);
-    tst_use(arg.c);
-    tst_use(arg.d);
-    tail_call_avoidance_fn();
-}
-
-extern "C" {
-    fn opaque_callee(arg: Franta, intarg: i32);
-    fn tst_use(arg: f32);
-    fn clobber();
-    // This exists so that post-https://reviews.llvm.org/D138741 LLVM doesn't
-    // tail-call away some of our assertions.
-    fn tail_call_avoidance_fn();
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn caller() {
-    // CHECK-LABEL: caller:
-    // CHECK: ld [{{.*}}], %f0
-    // CHECK: ld [{{.*}}], %f1
-    // CHECK: ld [{{.*}}], %f2
-    // CHECK: ld [{{.*}}], %f3
-    // CHECK: call opaque_callee
-    // CHECK: mov     3, %o2
-    opaque_callee(Franta { a: 1.0, b: 2.0, c: 3.0, d: 4.0 }, 3);
-    tail_call_avoidance_fn();
-}
diff --git a/tests/assembly/stack-probes.rs b/tests/assembly/stack-probes.rs
deleted file mode 100644
index de245431f47..00000000000
--- a/tests/assembly/stack-probes.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x86_64 i686 aarch64
-//@ assembly-output: emit-asm
-//@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@[x86_64] needs-llvm-components: x86
-//@[i686] compile-flags: --target i686-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
-//@[i686] needs-llvm-components: x86
-//@[aarch64] compile-flags: --target aarch64-unknown-linux-gnu
-//@[aarch64] needs-llvm-components: aarch64
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// Check that inline-asm stack probes are generated correctly.
-// To avoid making this test fragile to slight asm changes,
-// we only check that the stack pointer is decremented by a page at a time,
-// instead of matching the whole probe sequence.
-
-// CHECK-LABEL: small_stack_probe:
-#[no_mangle]
-pub fn small_stack_probe(x: u8, f: fn(&mut [u8; 8192])) {
-    // CHECK-NOT: __rust_probestack
-    // x86_64: sub rsp, 4096
-    // i686: sub esp, 4096
-    // aarch64: sub sp, sp, #1, lsl #12
-    f(&mut [x; 8192]);
-}
-
-// CHECK-LABEL: big_stack_probe:
-#[no_mangle]
-pub fn big_stack_probe(x: u8, f: fn(&[u8; 65536])) {
-    // CHECK-NOT: __rust_probestack
-    // x86_64: sub rsp, 4096
-    // i686: sub esp, 4096
-    // aarch64: sub sp, sp, #1, lsl #12
-    f(&mut [x; 65536]);
-}
diff --git a/tests/assembly/stack-protector/stack-protector-heuristics-effect-windows-32bit.rs b/tests/assembly/stack-protector/stack-protector-heuristics-effect-windows-32bit.rs
deleted file mode 100644
index 3287e018b40..00000000000
--- a/tests/assembly/stack-protector/stack-protector-heuristics-effect-windows-32bit.rs
+++ /dev/null
@@ -1,359 +0,0 @@
-//@ revisions: all strong basic none missing
-//@ assembly-output: emit-asm
-//@ only-windows
-//@ only-msvc
-//@ ignore-64bit 64-bit table based SEH has slightly different behaviors than classic SEH
-//@ [all] compile-flags: -Z stack-protector=all
-//@ [strong] compile-flags: -Z stack-protector=strong
-//@ [basic] compile-flags: -Z stack-protector=basic
-//@ [none] compile-flags: -Z stack-protector=none
-//@ compile-flags: -C opt-level=2 -Z merge-functions=disabled
-
-#![crate_type = "lib"]
-#![allow(internal_features)]
-#![feature(unsized_fn_params)]
-
-// CHECK-LABEL: emptyfn:
-#[no_mangle]
-pub fn emptyfn() {
-    // all: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: array_char
-#[no_mangle]
-pub fn array_char(f: fn(*const char)) {
-    let a = ['c'; 1];
-    let b = ['d'; 3];
-    let c = ['e'; 15];
-
-    f(&a as *const _);
-    f(&b as *const _);
-    f(&c as *const _);
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: array_u8_1
-#[no_mangle]
-pub fn array_u8_1(f: fn(*const u8)) {
-    let a = [0u8; 1];
-    f(&a as *const _);
-
-    // The 'strong' heuristic adds stack protection to functions with local
-    // array variables regardless of their size.
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: array_u8_small:
-#[no_mangle]
-pub fn array_u8_small(f: fn(*const u8)) {
-    let a = [0u8; 2];
-    let b = [0u8; 7];
-    f(&a as *const _);
-    f(&b as *const _);
-
-    // Small arrays do not lead to stack protection by the 'basic' heuristic.
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: array_u8_large:
-#[no_mangle]
-pub fn array_u8_large(f: fn(*const u8)) {
-    let a = [0u8; 9];
-    f(&a as *const _);
-
-    // Since `a` is a byte array with size greater than 8, the basic heuristic
-    // will also protect this function.
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-#[derive(Copy, Clone)]
-pub struct ByteSizedNewtype(u8);
-
-// CHECK-LABEL: array_bytesizednewtype_9:
-#[no_mangle]
-pub fn array_bytesizednewtype_9(f: fn(*const ByteSizedNewtype)) {
-    let a = [ByteSizedNewtype(0); 9];
-    f(&a as *const _);
-
-    // Since `a` is a byte array in the LLVM output, the basic heuristic will
-    // also protect this function.
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: local_var_addr_used_indirectly
-#[no_mangle]
-pub fn local_var_addr_used_indirectly(f: fn(bool)) {
-    let a = 5;
-    let a_addr = &a as *const _ as usize;
-    f(a_addr & 0x10 == 0);
-
-    // This function takes the address of a local variable taken. Although this
-    // address is never used as a way to refer to stack memory, the `strong`
-    // heuristic adds stack smash protection. This is also the case in C++:
-    // ```
-    // cat << EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
-    // #include <cstdint>
-    // void f(void (*g)(bool)) {
-    //     int32_t x;
-    //     g((reinterpret_cast<uintptr_t>(&x) & 0x10U) == 0);
-    // }
-    // EOF
-    // ```
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: local_string_addr_taken
-#[no_mangle]
-pub fn local_string_addr_taken(f: fn(&String)) {
-    let x = String::new();
-    f(&x);
-
-    // Taking the address of the local variable `x` leads to stack smash
-    // protection with the `strong` heuristic, but not with the `basic`
-    // heuristic. It does not matter that the reference is not mut.
-    //
-    // An interesting note is that a similar function in C++ *would* be
-    // protected by the `basic` heuristic, because `std::string` has a char
-    // array internally as a small object optimization:
-    // ```
-    // cat <<EOF | clang++ -O2 -fstack-protector -S -x c++ - -o - | grep stack_chk
-    // #include <string>
-    // void f(void (*g)(const std::string&)) {
-    //     std::string x;
-    //     g(x);
-    // }
-    // EOF
-    // ```
-    //
-
-    // all: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-pub trait SelfByRef {
-    fn f(&self) -> i32;
-}
-
-impl SelfByRef for i32 {
-    fn f(&self) -> i32 {
-        return self + 1;
-    }
-}
-
-// CHECK-LABEL: local_var_addr_taken_used_locally_only
-#[no_mangle]
-pub fn local_var_addr_taken_used_locally_only(factory: fn() -> i32, sink: fn(i32)) {
-    let x = factory();
-    let g = x.f();
-    sink(g);
-
-    // Even though the local variable conceptually has its address taken, as
-    // it's passed by reference to the trait function, the use of the reference
-    // is easily inlined. There is therefore no stack smash protection even with
-    // the `strong` heuristic.
-
-    // all: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-pub struct Gigastruct {
-    does: u64,
-    not: u64,
-    have: u64,
-    array: u64,
-    members: u64,
-}
-
-// CHECK-LABEL: local_large_var_moved
-#[no_mangle]
-pub fn local_large_var_moved(f: fn(Gigastruct)) {
-    let x = Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 };
-    f(x);
-
-    // Even though the local variable conceptually doesn't have its address
-    // taken, it's so large that the "move" is implemented with a reference to a
-    // stack-local variable in the ABI. Consequently, this function *is*
-    // protected. This is also the case for rvalue-references in C++,
-    // regardless of struct size:
-    // ```
-    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
-    // #include <cstdint>
-    // #include <utility>
-    // void f(void (*g)(uint64_t&&)) {
-    //     uint64_t x;
-    //     g(std::move(x));
-    // }
-    // EOF
-    // ```
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: local_large_var_cloned
-#[no_mangle]
-pub fn local_large_var_cloned(f: fn(Gigastruct)) {
-    f(Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 });
-
-    // A new instance of `Gigastruct` is passed to `f()`, without any apparent
-    // connection to this stack frame. Still, since instances of `Gigastruct`
-    // are sufficiently large, it is allocated in the caller stack frame and
-    // passed as a pointer. As such, this function is *also* protected, just
-    // like `local_large_var_moved`. This is also the case for pass-by-value
-    // of sufficiently large structs in C++:
-    // ```
-    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
-    // #include <cstdint>
-    // #include <utility>
-    // struct Gigastruct { uint64_t a, b, c, d, e; };
-    // void f(void (*g)(Gigastruct)) {
-    //     g(Gigastruct{});
-    // }
-    // EOF
-    // ```
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-extern "C" {
-    // A call to an external `alloca` function is *not* recognized as an
-    // `alloca(3)` operation. This function is a compiler built-in, as the
-    // man page explains. Clang translates it to an LLVM `alloca`
-    // instruction with a count argument, which is also what the LLVM stack
-    // protector heuristics looks for. The man page for `alloca(3)` details
-    // a way to avoid using the compiler built-in: pass a -std=c11
-    // argument, *and* don't include <alloca.h>. Though this leads to an
-    // external alloca() function being called, it doesn't lead to stack
-    // protection being included. It even fails with a linker error
-    // "undefined reference to `alloca'". Example:
-    // ```
-    // cat<<EOF | clang -fstack-protector-strong -x c -std=c11 - -o /dev/null
-    // #include <stdlib.h>
-    // void * alloca(size_t);
-    // void f(void (*g)(void*)) {
-    //     void * p = alloca(10);
-    //     g(p);
-    // }
-    // int main() { return 0; }
-    // EOF
-    // ```
-    // The following tests demonstrate that calls to an external `alloca`
-    // function in Rust also doesn't trigger stack protection.
-
-    fn alloca(size: usize) -> *mut ();
-}
-
-// CHECK-LABEL: alloca_small_compile_time_constant_arg
-#[no_mangle]
-pub fn alloca_small_compile_time_constant_arg(f: fn(*mut ())) {
-    f(unsafe { alloca(8) });
-
-    // all: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: alloca_large_compile_time_constant_arg
-#[no_mangle]
-pub fn alloca_large_compile_time_constant_arg(f: fn(*mut ())) {
-    f(unsafe { alloca(9) });
-
-    // all: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: alloca_dynamic_arg
-#[no_mangle]
-pub fn alloca_dynamic_arg(f: fn(*mut ()), n: usize) {
-    f(unsafe { alloca(n) });
-
-    // all: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// The question then is: in what ways can Rust code generate array-`alloca`
-// LLVM instructions? This appears to only be generated by
-// rustc_codegen_ssa::traits::Builder::array_alloca() through
-// rustc_codegen_ssa::mir::operand::OperandValue::store_unsized(). FWICT
-// this is support for the "unsized locals" unstable feature:
-// https://doc.rust-lang.org/unstable-book/language-features/unsized-locals.html.
-
-// CHECK-LABEL: unsized_fn_param
-#[no_mangle]
-pub fn unsized_fn_param(s: [u8], l: bool, f: fn([u8])) {
-    let n = if l { 1 } else { 2 };
-    f(*Box::<[u8]>::from(&s[0..n])); // slice-copy with Box::from
-
-    // Even though slices are conceptually passed by-value both into this
-    // function and into `f()`, this is implemented with pass-by-reference
-    // using a suitably constructed fat-pointer (as if the functions
-    // accepted &[u8]). This function therefore doesn't need dynamic array
-    // alloca, and is therefore not protected by the `strong` or `basic`
-    // heuristics.
-
-    // We should have a __security_check_cookie call in `all` and `strong` modes but
-    // LLVM does not support generating stack protectors in functions with funclet
-    // based EH personalities.
-    // https://github.com/llvm/llvm-project/blob/37fd3c96b917096d8a550038f6e61cdf0fc4174f/llvm/lib/CodeGen/StackProtector.cpp#L103C1-L109C4
-    // all-NOT: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
diff --git a/tests/assembly/stack-protector/stack-protector-heuristics-effect-windows-64bit.rs b/tests/assembly/stack-protector/stack-protector-heuristics-effect-windows-64bit.rs
deleted file mode 100644
index 9a3dabc74dd..00000000000
--- a/tests/assembly/stack-protector/stack-protector-heuristics-effect-windows-64bit.rs
+++ /dev/null
@@ -1,366 +0,0 @@
-//@ revisions: all strong basic none missing
-//@ assembly-output: emit-asm
-//@ only-windows
-//@ only-msvc
-//@ ignore-32bit 64-bit table based SEH has slightly different behaviors than classic SEH
-//@ [all] compile-flags: -Z stack-protector=all
-//@ [strong] compile-flags: -Z stack-protector=strong
-//@ [basic] compile-flags: -Z stack-protector=basic
-//@ [none] compile-flags: -Z stack-protector=none
-//@ compile-flags: -C opt-level=2 -Z merge-functions=disabled
-
-#![crate_type = "lib"]
-#![feature(unsized_fn_params)]
-
-// CHECK-LABEL: emptyfn:
-#[no_mangle]
-pub fn emptyfn() {
-    // all: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: array_char
-#[no_mangle]
-pub fn array_char(f: fn(*const char)) {
-    let a = ['c'; 1];
-    let b = ['d'; 3];
-    let c = ['e'; 15];
-
-    f(&a as *const _);
-    f(&b as *const _);
-    f(&c as *const _);
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: array_u8_1
-#[no_mangle]
-pub fn array_u8_1(f: fn(*const u8)) {
-    let a = [0u8; 1];
-    f(&a as *const _);
-
-    // The 'strong' heuristic adds stack protection to functions with local
-    // array variables regardless of their size.
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: array_u8_small:
-#[no_mangle]
-pub fn array_u8_small(f: fn(*const u8)) {
-    let a = [0u8; 2];
-    let b = [0u8; 7];
-    f(&a as *const _);
-    f(&b as *const _);
-
-    // Small arrays do not lead to stack protection by the 'basic' heuristic.
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: array_u8_large:
-#[no_mangle]
-pub fn array_u8_large(f: fn(*const u8)) {
-    let a = [0u8; 9];
-    f(&a as *const _);
-
-    // Since `a` is a byte array with size greater than 8, the basic heuristic
-    // will also protect this function.
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-#[derive(Copy, Clone)]
-pub struct ByteSizedNewtype(u8);
-
-// CHECK-LABEL: array_bytesizednewtype_9:
-#[no_mangle]
-pub fn array_bytesizednewtype_9(f: fn(*const ByteSizedNewtype)) {
-    let a = [ByteSizedNewtype(0); 9];
-    f(&a as *const _);
-
-    // Since `a` is a byte array in the LLVM output, the basic heuristic will
-    // also protect this function.
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: local_var_addr_used_indirectly
-#[no_mangle]
-pub fn local_var_addr_used_indirectly(f: fn(bool)) {
-    let a = 5;
-    let a_addr = &a as *const _ as usize;
-    f(a_addr & 0x10 == 0);
-
-    // This function takes the address of a local variable taken. Although this
-    // address is never used as a way to refer to stack memory, the `strong`
-    // heuristic adds stack smash protection. This is also the case in C++:
-    // ```
-    // cat << EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
-    // #include <cstdint>
-    // void f(void (*g)(bool)) {
-    //     int32_t x;
-    //     g((reinterpret_cast<uintptr_t>(&x) & 0x10U) == 0);
-    // }
-    // EOF
-    // ```
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: local_string_addr_taken
-#[no_mangle]
-pub fn local_string_addr_taken(f: fn(&String)) {
-    // CHECK-DAG: .seh_endprologue
-    let x = String::new();
-    f(&x);
-
-    // Taking the address of the local variable `x` leads to stack smash
-    // protection with the `strong` heuristic, but not with the `basic`
-    // heuristic. It does not matter that the reference is not mut.
-    //
-    // An interesting note is that a similar function in C++ *would* be
-    // protected by the `basic` heuristic, because `std::string` has a char
-    // array internally as a small object optimization:
-    // ```
-    // cat <<EOF | clang++ -O2 -fstack-protector -S -x c++ - -o - | grep stack_chk
-    // #include <string>
-    // void f(void (*g)(const std::string&)) {
-    //     std::string x;
-    //     g(x);
-    // }
-    // EOF
-    // ```
-    //
-
-    // We should have a __security_check_cookie call in `all` and `strong` modes but
-    // LLVM does not support generating stack protectors in functions with funclet
-    // based EH personalities.
-    // https://github.com/llvm/llvm-project/blob/37fd3c96b917096d8a550038f6e61cdf0fc4174f/llvm/lib/CodeGen/StackProtector.cpp#L103C1-L109C4
-    // all-NOT: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-
-    // CHECK-DAG: .seh_endproc
-}
-
-pub trait SelfByRef {
-    fn f(&self) -> i32;
-}
-
-impl SelfByRef for i32 {
-    fn f(&self) -> i32 {
-        return self + 1;
-    }
-}
-
-// CHECK-LABEL: local_var_addr_taken_used_locally_only
-#[no_mangle]
-pub fn local_var_addr_taken_used_locally_only(factory: fn() -> i32, sink: fn(i32)) {
-    let x = factory();
-    let g = x.f();
-    sink(g);
-
-    // Even though the local variable conceptually has its address taken, as
-    // it's passed by reference to the trait function, the use of the reference
-    // is easily inlined. There is therefore no stack smash protection even with
-    // the `strong` heuristic.
-
-    // all: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-pub struct Gigastruct {
-    does: u64,
-    not: u64,
-    have: u64,
-    array: u64,
-    members: u64,
-}
-
-// CHECK-LABEL: local_large_var_moved
-#[no_mangle]
-pub fn local_large_var_moved(f: fn(Gigastruct)) {
-    let x = Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 };
-    f(x);
-
-    // Even though the local variable conceptually doesn't have its address
-    // taken, it's so large that the "move" is implemented with a reference to a
-    // stack-local variable in the ABI. Consequently, this function *is*
-    // protected. This is also the case for rvalue-references in C++,
-    // regardless of struct size:
-    // ```
-    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
-    // #include <cstdint>
-    // #include <utility>
-    // void f(void (*g)(uint64_t&&)) {
-    //     uint64_t x;
-    //     g(std::move(x));
-    // }
-    // EOF
-    // ```
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: local_large_var_cloned
-#[no_mangle]
-pub fn local_large_var_cloned(f: fn(Gigastruct)) {
-    f(Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 });
-
-    // A new instance of `Gigastruct` is passed to `f()`, without any apparent
-    // connection to this stack frame. Still, since instances of `Gigastruct`
-    // are sufficiently large, it is allocated in the caller stack frame and
-    // passed as a pointer. As such, this function is *also* protected, just
-    // like `local_large_var_moved`. This is also the case for pass-by-value
-    // of sufficiently large structs in C++:
-    // ```
-    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
-    // #include <cstdint>
-    // #include <utility>
-    // struct Gigastruct { uint64_t a, b, c, d, e; };
-    // void f(void (*g)(Gigastruct)) {
-    //     g(Gigastruct{});
-    // }
-    // EOF
-    // ```
-
-    // all: __security_check_cookie
-    // strong: __security_check_cookie
-    // basic: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-extern "C" {
-    // A call to an external `alloca` function is *not* recognized as an
-    // `alloca(3)` operation. This function is a compiler built-in, as the
-    // man page explains. Clang translates it to an LLVM `alloca`
-    // instruction with a count argument, which is also what the LLVM stack
-    // protector heuristics looks for. The man page for `alloca(3)` details
-    // a way to avoid using the compiler built-in: pass a -std=c11
-    // argument, *and* don't include <alloca.h>. Though this leads to an
-    // external alloca() function being called, it doesn't lead to stack
-    // protection being included. It even fails with a linker error
-    // "undefined reference to `alloca'". Example:
-    // ```
-    // cat<<EOF | clang -fstack-protector-strong -x c -std=c11 - -o /dev/null
-    // #include <stdlib.h>
-    // void * alloca(size_t);
-    // void f(void (*g)(void*)) {
-    //     void * p = alloca(10);
-    //     g(p);
-    // }
-    // int main() { return 0; }
-    // EOF
-    // ```
-    // The following tests demonstrate that calls to an external `alloca`
-    // function in Rust also doesn't trigger stack protection.
-
-    fn alloca(size: usize) -> *mut ();
-}
-
-// CHECK-LABEL: alloca_small_compile_time_constant_arg
-#[no_mangle]
-pub fn alloca_small_compile_time_constant_arg(f: fn(*mut ())) {
-    f(unsafe { alloca(8) });
-
-    // all: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: alloca_large_compile_time_constant_arg
-#[no_mangle]
-pub fn alloca_large_compile_time_constant_arg(f: fn(*mut ())) {
-    f(unsafe { alloca(9) });
-
-    // all: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// CHECK-LABEL: alloca_dynamic_arg
-#[no_mangle]
-pub fn alloca_dynamic_arg(f: fn(*mut ()), n: usize) {
-    f(unsafe { alloca(n) });
-
-    // all: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
-
-// The question then is: in what ways can Rust code generate array-`alloca`
-// LLVM instructions? This appears to only be generated by
-// rustc_codegen_ssa::traits::Builder::array_alloca() through
-// rustc_codegen_ssa::mir::operand::OperandValue::store_unsized(). FWICT
-// this is support for the "unsized locals" unstable feature:
-// https://doc.rust-lang.org/unstable-book/language-features/unsized-locals.html.
-
-// CHECK-LABEL: unsized_fn_param
-#[no_mangle]
-pub fn unsized_fn_param(s: [u8], l: bool, f: fn([u8])) {
-    let n = if l { 1 } else { 2 };
-    f(*Box::<[u8]>::from(&s[0..n])); // slice-copy with Box::from
-
-    // Even though slices are conceptually passed by-value both into this
-    // function and into `f()`, this is implemented with pass-by-reference
-    // using a suitably constructed fat-pointer (as if the functions
-    // accepted &[u8]). This function therefore doesn't need dynamic array
-    // alloca, and is therefore not protected by the `strong` or `basic`
-    // heuristics.
-
-    // We should have a __security_check_cookie call in `all` and `strong` modes but
-    // LLVM does not support generating stack protectors in functions with funclet
-    // based EH personalities.
-    // https://github.com/llvm/llvm-project/blob/37fd3c96b917096d8a550038f6e61cdf0fc4174f/llvm/lib/CodeGen/StackProtector.cpp#L103C1-L109C4
-    // all-NOT: __security_check_cookie
-    // strong-NOT: __security_check_cookie
-
-    // basic-NOT: __security_check_cookie
-    // none-NOT: __security_check_cookie
-    // missing-NOT: __security_check_cookie
-}
diff --git a/tests/assembly/stack-protector/stack-protector-heuristics-effect.rs b/tests/assembly/stack-protector/stack-protector-heuristics-effect.rs
deleted file mode 100644
index ae281cb95da..00000000000
--- a/tests/assembly/stack-protector/stack-protector-heuristics-effect.rs
+++ /dev/null
@@ -1,345 +0,0 @@
-//@ revisions: all strong basic none missing
-//@ assembly-output: emit-asm
-//@ ignore-apple slightly different policy on stack protection of arrays
-//@ ignore-msvc stack check code uses different function names
-//@ ignore-nvptx64 stack protector is not supported
-//@ ignore-wasm32-bare
-//@ [all] compile-flags: -Z stack-protector=all
-//@ [strong] compile-flags: -Z stack-protector=strong
-//@ [basic] compile-flags: -Z stack-protector=basic
-//@ [none] compile-flags: -Z stack-protector=none
-//@ compile-flags: -C opt-level=2 -Z merge-functions=disabled
-
-// NOTE: the heuristics for stack smash protection inappropriately rely on types in LLVM IR,
-// despite those types having no semantic meaning. This means that the `basic` and `strong`
-// settings do not behave in a coherent way. This is a known issue in LLVM.
-// See comments on https://github.com/rust-lang/rust/issues/114903.
-
-#![crate_type = "lib"]
-#![allow(internal_features)]
-#![feature(unsized_fn_params)]
-
-// CHECK-LABEL: emptyfn{{:|\[}}
-#[no_mangle]
-pub fn emptyfn() {
-    // all: __stack_chk_fail
-    // strong-NOT: __stack_chk_fail
-    // basic-NOT: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-// CHECK-LABEL: array_char{{:|\[}}
-#[no_mangle]
-pub fn array_char(f: fn(*const char)) {
-    let a = ['c'; 1];
-    let b = ['d'; 3];
-    let c = ['e'; 15];
-
-    f(&a as *const _);
-    f(&b as *const _);
-    f(&c as *const _);
-
-    // all: __stack_chk_fail
-    // strong: __stack_chk_fail
-    // basic: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-// CHECK-LABEL: array_u8_1{{:|\[}}
-#[no_mangle]
-pub fn array_u8_1(f: fn(*const u8)) {
-    let a = [0u8; 1];
-    f(&a as *const _);
-
-    // The 'strong' heuristic adds stack protection to functions with local
-    // array variables regardless of their size.
-
-    // all: __stack_chk_fail
-    // strong: __stack_chk_fail
-    // basic-NOT: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-// CHECK-LABEL: array_u8_small{{:|\[}}
-#[no_mangle]
-pub fn array_u8_small(f: fn(*const u8)) {
-    let a = [0u8; 2];
-    let b = [0u8; 7];
-    f(&a as *const _);
-    f(&b as *const _);
-
-    // Small arrays do not lead to stack protection by the 'basic' heuristic.
-
-    // all: __stack_chk_fail
-    // strong: __stack_chk_fail
-    // basic-NOT: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-// CHECK-LABEL: array_u8_large{{:|\[}}
-#[no_mangle]
-pub fn array_u8_large(f: fn(*const u8)) {
-    let a = [0u8; 9];
-    f(&a as *const _);
-
-    // Since `a` is a byte array with size greater than 8, the basic heuristic
-    // will also protect this function.
-
-    // all: __stack_chk_fail
-    // strong: __stack_chk_fail
-    // basic: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-#[derive(Copy, Clone)]
-pub struct ByteSizedNewtype(u8);
-
-// CHECK-LABEL: array_bytesizednewtype_9{{:|\[}}
-#[no_mangle]
-pub fn array_bytesizednewtype_9(f: fn(*const ByteSizedNewtype)) {
-    let a = [ByteSizedNewtype(0); 9];
-    f(&a as *const _);
-
-    // Since `a` is a byte array in the LLVM output, the basic heuristic will
-    // also protect this function.
-
-    // all: __stack_chk_fail
-    // strong: __stack_chk_fail
-    // basic: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-// CHECK-LABEL: local_var_addr_used_indirectly{{:|\[}}
-#[no_mangle]
-pub fn local_var_addr_used_indirectly(f: fn(bool)) {
-    let a = 5;
-    let a_addr = &a as *const _ as usize;
-    f(a_addr & 0x10 == 0);
-
-    // This function takes the address of a local variable taken. Although this
-    // address is never used as a way to refer to stack memory, the `strong`
-    // heuristic adds stack smash protection. This is also the case in C++:
-    // ```
-    // cat << EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
-    // #include <cstdint>
-    // void f(void (*g)(bool)) {
-    //     int32_t x;
-    //     g((reinterpret_cast<uintptr_t>(&x) & 0x10U) == 0);
-    // }
-    // EOF
-    // ```
-
-    // all: __stack_chk_fail
-    // strong: __stack_chk_fail
-    // basic-NOT: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-// CHECK-LABEL: local_string_addr_taken{{:|\[}}
-#[no_mangle]
-pub fn local_string_addr_taken(f: fn(&String)) {
-    let x = String::new();
-    f(&x);
-
-    // Taking the address of the local variable `x` leads to stack smash
-    // protection. It does not matter that the reference is not mut.
-
-    // all: __stack_chk_fail
-    // strong: __stack_chk_fail
-    // basic: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-pub trait SelfByRef {
-    fn f(&self) -> i32;
-}
-
-impl SelfByRef for i32 {
-    fn f(&self) -> i32 {
-        return self + 1;
-    }
-}
-
-// CHECK-LABEL: local_var_addr_taken_used_locally_only{{:|\[}}
-#[no_mangle]
-pub fn local_var_addr_taken_used_locally_only(factory: fn() -> i32, sink: fn(i32)) {
-    let x = factory();
-    let g = x.f();
-    sink(g);
-
-    // Even though the local variable conceptually has its address taken, as
-    // it's passed by reference to the trait function, the use of the reference
-    // is easily inlined. There is therefore no stack smash protection even with
-    // the `strong` heuristic.
-
-    // all: __stack_chk_fail
-    // strong-NOT: __stack_chk_fail
-    // basic-NOT: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-pub struct Gigastruct {
-    does: u64,
-    not: u64,
-    have: u64,
-    array: u64,
-    members: u64,
-}
-
-// CHECK-LABEL: local_large_var_moved{{:|\[}}
-#[no_mangle]
-pub fn local_large_var_moved(f: fn(Gigastruct)) {
-    let x = Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 };
-    f(x);
-
-    // Even though the local variable conceptually doesn't have its address
-    // taken, it's so large that the "move" is implemented with a reference to a
-    // stack-local variable in the ABI. Consequently, this function *is*
-    // protected. This is also the case for rvalue-references in C++,
-    // regardless of struct size:
-    // ```
-    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
-    // #include <cstdint>
-    // #include <utility>
-    // void f(void (*g)(uint64_t&&)) {
-    //     uint64_t x;
-    //     g(std::move(x));
-    // }
-    // EOF
-    // ```
-
-    // all: __stack_chk_fail
-    // strong: __stack_chk_fail
-    // basic: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-// CHECK-LABEL: local_large_var_cloned{{:|\[}}
-#[no_mangle]
-pub fn local_large_var_cloned(f: fn(Gigastruct)) {
-    f(Gigastruct { does: 0, not: 1, have: 2, array: 3, members: 4 });
-
-    // A new instance of `Gigastruct` is passed to `f()`, without any apparent
-    // connection to this stack frame. Still, since instances of `Gigastruct`
-    // are sufficiently large, it is allocated in the caller stack frame and
-    // passed as a pointer. As such, this function is *also* protected, just
-    // like `local_large_var_moved`. This is also the case for pass-by-value
-    // of sufficiently large structs in C++:
-    // ```
-    // cat <<EOF | clang++ -O2 -fstack-protector-strong -S -x c++ - -o - | grep stack_chk
-    // #include <cstdint>
-    // #include <utility>
-    // struct Gigastruct { uint64_t a, b, c, d, e; };
-    // void f(void (*g)(Gigastruct)) {
-    //     g(Gigastruct{});
-    // }
-    // EOF
-    // ```
-
-    // all: __stack_chk_fail
-    // strong: __stack_chk_fail
-    // basic: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-extern "C" {
-    // A call to an external `alloca` function is *not* recognized as an
-    // `alloca(3)` operation. This function is a compiler built-in, as the
-    // man page explains. Clang translates it to an LLVM `alloca`
-    // instruction with a count argument, which is also what the LLVM stack
-    // protector heuristics looks for. The man page for `alloca(3)` details
-    // a way to avoid using the compiler built-in: pass a -std=c11
-    // argument, *and* don't include <alloca.h>. Though this leads to an
-    // external alloca() function being called, it doesn't lead to stack
-    // protection being included. It even fails with a linker error
-    // "undefined reference to `alloca'". Example:
-    // ```
-    // cat<<EOF | clang -fstack-protector-strong -x c -std=c11 - -o /dev/null
-    // #include <stdlib.h>
-    // void * alloca(size_t);
-    // void f(void (*g)(void*)) {
-    //     void * p = alloca(10);
-    //     g(p);
-    // }
-    // int main() { return 0; }
-    // EOF
-    // ```
-    // The following tests demonstrate that calls to an external `alloca`
-    // function in Rust also doesn't trigger stack protection.
-
-    fn alloca(size: usize) -> *mut ();
-}
-
-// CHECK-LABEL: alloca_small_compile_time_constant_arg{{:|\[}}
-#[no_mangle]
-pub fn alloca_small_compile_time_constant_arg(f: fn(*mut ())) {
-    f(unsafe { alloca(8) });
-
-    // all: __stack_chk_fail
-    // strong-NOT: __stack_chk_fail
-    // basic-NOT: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-// CHECK-LABEL: alloca_large_compile_time_constant_arg{{:|\[}}
-#[no_mangle]
-pub fn alloca_large_compile_time_constant_arg(f: fn(*mut ())) {
-    f(unsafe { alloca(9) });
-
-    // all: __stack_chk_fail
-    // strong-NOT: __stack_chk_fail
-    // basic-NOT: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-// CHECK-LABEL: alloca_dynamic_arg{{:|\[}}
-#[no_mangle]
-pub fn alloca_dynamic_arg(f: fn(*mut ()), n: usize) {
-    f(unsafe { alloca(n) });
-
-    // all: __stack_chk_fail
-    // strong-NOT: __stack_chk_fail
-    // basic-NOT: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
-
-// The question then is: in what ways can Rust code generate array-`alloca`
-// LLVM instructions? This appears to only be generated by
-// rustc_codegen_ssa::traits::Builder::array_alloca() through
-// rustc_codegen_ssa::mir::operand::OperandValue::store_unsized(). FWICT
-// this is support for the "unsized locals" unstable feature:
-// https://doc.rust-lang.org/unstable-book/language-features/unsized-locals.html.
-
-// CHECK-LABEL: unsized_fn_param{{:|\[}}
-#[no_mangle]
-pub fn unsized_fn_param(s: [u8], l: bool, f: fn([u8])) {
-    let n = if l { 1 } else { 2 };
-    f(*Box::<[u8]>::from(&s[0..n])); // slice-copy with Box::from
-
-    // Even though slices are conceptually passed by-value both into this
-    // function and into `f()`, this is implemented with pass-by-reference
-    // using a suitably constructed fat-pointer (as if the functions
-    // accepted &[u8]). This function therefore doesn't need dynamic array
-    // alloca, and is therefore not protected by the `strong` or `basic`
-    // heuristics.
-
-    // all: __stack_chk_fail
-    // strong-NOT: __stack_chk_fail
-    // basic-NOT: __stack_chk_fail
-    // none-NOT: __stack_chk_fail
-    // missing-NOT: __stack_chk_fail
-}
diff --git a/tests/assembly/stack-protector/stack-protector-target-support.rs b/tests/assembly/stack-protector/stack-protector-target-support.rs
deleted file mode 100644
index a937256a60f..00000000000
--- a/tests/assembly/stack-protector/stack-protector-target-support.rs
+++ /dev/null
@@ -1,281 +0,0 @@
-// Test that stack smash protection code is emitted for all tier1 and tier2
-// targets, with the exception of nvptx64-nvidia-cuda
-//
-//@ add-core-stubs
-//@ revisions: r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 r16 r17 r18 r19 r20 r21 r22 r23
-//@ revisions: r24 r25 r26 r27 r28 r29 r30 r31 r32 r33         r36 r37 r38 r39 r40 r41 r42 r43 r44
-//@ revisions: r45 r46 r47 r48 r49 r50 r51 r52 r53 r54 r55 r56 r57 r58 r59 r60 r61 r62 r63 r64 r65
-//@ revisions: r66 r67 r68 r69 r70 r71 r72 r73 r74 r75 r76 r77 r78 r79 r80 r81 r82 r83 r84 r85
-//@ assembly-output: emit-asm
-//@ [r1] compile-flags: --target aarch64-unknown-linux-gnu
-//@ [r1] needs-llvm-components: aarch64
-//@ [r2] compile-flags: --target i686-pc-windows-gnu
-//@ [r2] needs-llvm-components: x86
-//@ [r3] compile-flags: --target i686-pc-windows-msvc
-//@ [r3] needs-llvm-components: x86
-//@ [r4] compile-flags: --target i686-unknown-linux-gnu
-//@ [r4] needs-llvm-components: x86
-//@ [r5] compile-flags: --target x86_64-apple-darwin
-//@ [r5] needs-llvm-components: x86
-//@ [r6] compile-flags: --target x86_64-pc-windows-gnu
-//@ [r6] needs-llvm-components: x86
-//@ [r7] compile-flags: --target x86_64-pc-windows-msvc
-//@ [r7] needs-llvm-components: x86
-//@ [r8] compile-flags: --target x86_64-unknown-linux-gnu
-//@ [r8] needs-llvm-components: x86
-//@ [r9] compile-flags: --target aarch64-apple-darwin
-//@ [r9] needs-llvm-components: aarch64
-//@ [r10] compile-flags: --target aarch64-apple-ios
-//@ [r10] needs-llvm-components: aarch64
-//@ [r11] compile-flags: --target aarch64-unknown-fuchsia
-//@ [r11] needs-llvm-components: aarch64
-//@ [r12] compile-flags: --target aarch64-linux-android
-//@ [r12] needs-llvm-components: aarch64
-//@ [r13] compile-flags: --target aarch64-pc-windows-msvc
-//@ [r13] needs-llvm-components: aarch64
-//@ [r14] compile-flags: --target aarch64-unknown-linux-musl
-//@ [r14] needs-llvm-components: aarch64
-//@ [r15] compile-flags: --target aarch64-unknown-none
-//@ [r15] needs-llvm-components: aarch64
-//@ [r16] compile-flags: --target aarch64-unknown-none-softfloat
-//@ [r16] needs-llvm-components: aarch64
-//@ [r17] compile-flags: --target arm-linux-androideabi
-//@ [r17] needs-llvm-components: arm
-//@ [r18] compile-flags: --target arm-unknown-linux-gnueabi
-//@ [r18] needs-llvm-components: arm
-//@ [r19] compile-flags: --target arm-unknown-linux-gnueabihf
-//@ [r19] needs-llvm-components: arm
-//@ [r20] compile-flags: --target arm-unknown-linux-musleabi
-//@ [r20] needs-llvm-components: arm
-//@ [r21] compile-flags: --target arm-unknown-linux-musleabihf
-//@ [r21] needs-llvm-components: arm
-//@ [r22] compile-flags: --target armebv7r-none-eabi
-//@ [r22] needs-llvm-components: arm
-//@ [r23] compile-flags: --target armebv7r-none-eabihf
-//@ [r23] needs-llvm-components: arm
-//@ [r24] compile-flags: --target armv5te-unknown-linux-gnueabi
-//@ [r24] needs-llvm-components: arm
-//@ [r25] compile-flags: --target armv5te-unknown-linux-musleabi
-//@ [r25] needs-llvm-components: arm
-//@ [r26] compile-flags: --target armv7-linux-androideabi
-//@ [r26] needs-llvm-components: arm
-//@ [r27] compile-flags: --target armv7a-none-eabi
-//@ [r27] needs-llvm-components: arm
-//@ [r28] compile-flags: --target armv7r-none-eabi
-//@ [r28] needs-llvm-components: arm
-//@ [r29] compile-flags: --target armv7r-none-eabihf
-//@ [r29] needs-llvm-components: arm
-//@ [r30] compile-flags: --target armv7-unknown-linux-gnueabi
-//@ [r30] needs-llvm-components: arm
-//@ [r31] compile-flags: --target armv7-unknown-linux-gnueabihf
-//@ [r31] needs-llvm-components: arm
-//@ [r32] compile-flags: --target armv7-unknown-linux-musleabi
-//@ [r32] needs-llvm-components: arm
-//@ [r33] compile-flags: --target armv7-unknown-linux-musleabihf
-//@ [r33] needs-llvm-components: arm
-//@ [r36] compile-flags: --target i586-unknown-linux-gnu
-//@ [r36] needs-llvm-components: x86
-//@ [r37] compile-flags: --target i586-unknown-linux-musl
-//@ [r37] needs-llvm-components: x86
-//@ [r38] compile-flags: --target i686-linux-android
-//@ [r38] needs-llvm-components: x86
-//@ [r39] compile-flags: --target i686-unknown-freebsd
-//@ [r39] needs-llvm-components: x86
-//@ [r40] compile-flags: --target i686-unknown-linux-musl
-//@ [r40] needs-llvm-components: x86
-//@ [r41] compile-flags: --target mips-unknown-linux-gnu
-//@ [r41] needs-llvm-components: mips
-//@ [r42] compile-flags: --target mips-unknown-linux-musl
-//@ [r42] needs-llvm-components: mips
-//@ [r43] compile-flags: --target mips64-unknown-linux-gnuabi64
-//@ [r43] needs-llvm-components: mips
-//@ [r44] compile-flags: --target mips64-unknown-linux-muslabi64
-//@ [r44] needs-llvm-components: mips
-//@ [r45] compile-flags: --target mips64el-unknown-linux-gnuabi64
-//@ [r45] needs-llvm-components: mips
-//@ [r46] compile-flags: --target mips64el-unknown-linux-muslabi64
-//@ [r46] needs-llvm-components: mips
-//@ [r47] compile-flags: --target mipsel-unknown-linux-gnu
-//@ [r47] needs-llvm-components: mips
-//@ [r48] compile-flags: --target mipsel-unknown-linux-musl
-//@ [r48] needs-llvm-components: mips
-//@ [r49] compile-flags: --target nvptx64-nvidia-cuda
-//@ [r49] needs-llvm-components: nvptx
-//@ [r50] compile-flags: --target powerpc-unknown-linux-gnu
-//@ [r50] needs-llvm-components: powerpc
-//@ [r51] compile-flags: --target powerpc64-unknown-linux-gnu
-//@ [r51] needs-llvm-components: powerpc
-//@ [r52] compile-flags: --target powerpc64le-unknown-linux-gnu
-//@ [r52] needs-llvm-components: powerpc
-//@ [r53] compile-flags: --target riscv32i-unknown-none-elf
-//@ [r53] needs-llvm-components: riscv
-//@ [r54] compile-flags: --target riscv32imac-unknown-none-elf
-//@ [r54] needs-llvm-components: riscv
-//@ [r55] compile-flags:--target riscv32imc-unknown-none-elf
-//@ [r55] needs-llvm-components: riscv
-//@ [r56] compile-flags:--target riscv64gc-unknown-linux-gnu
-//@ [r56] needs-llvm-components: riscv
-//@ [r57] compile-flags:--target riscv64gc-unknown-none-elf
-//@ [r57] needs-llvm-components: riscv
-//@ [r58] compile-flags:--target riscv64imac-unknown-none-elf
-//@ [r58] needs-llvm-components: riscv
-//@ [r59] compile-flags:--target s390x-unknown-linux-gnu
-//@ [r59] needs-llvm-components: systemz
-//@ [r60] compile-flags:--target sparc64-unknown-linux-gnu
-//@ [r60] needs-llvm-components: sparc
-//@ [r61] compile-flags:--target sparcv9-sun-solaris
-//@ [r61] needs-llvm-components: sparc
-//@ [r62] compile-flags:--target thumbv6m-none-eabi
-//@ [r62] needs-llvm-components: arm
-//@ [r63] compile-flags:--target thumbv7em-none-eabi
-//@ [r63] needs-llvm-components: arm
-//@ [r64] compile-flags:--target thumbv7em-none-eabihf
-//@ [r64] needs-llvm-components: arm
-//@ [r65] compile-flags:--target thumbv7m-none-eabi
-//@ [r65] needs-llvm-components: arm
-//@ [r66] compile-flags:--target thumbv7neon-linux-androideabi
-//@ [r66] needs-llvm-components: arm
-//@ [r67] compile-flags:--target thumbv7neon-unknown-linux-gnueabihf
-//@ [r67] needs-llvm-components: arm
-//@ [r68] compile-flags:--target thumbv8m.base-none-eabi
-//@ [r68] needs-llvm-components: arm
-//@ [r69] compile-flags:--target thumbv8m.main-none-eabi
-//@ [r69] needs-llvm-components: arm
-//@ [r70] compile-flags:--target thumbv8m.main-none-eabihf
-//@ [r70] needs-llvm-components: arm
-//@ [r71] compile-flags:--target wasm32-unknown-emscripten
-//@ [r71] needs-llvm-components: webassembly
-//@ [r72] compile-flags:--target wasm32-unknown-unknown
-//@ [r72] needs-llvm-components: webassembly
-//@ [r73] compile-flags:--target wasm32-wasip1
-//@ [r73] needs-llvm-components: webassembly
-//@ [r74] compile-flags:--target wasm32-wasip1-threads
-//@ [r74] needs-llvm-components: webassembly
-//@ [r75] compile-flags:--target x86_64-apple-ios
-//@ [r75] needs-llvm-components: x86
-//@ [r76] compile-flags:--target x86_64-fortanix-unknown-sgx
-//@ [r76] needs-llvm-components: x86
-//@ [r77] compile-flags:--target x86_64-unknown-fuchsia
-//@ [r77] needs-llvm-components: x86
-//@ [r78] compile-flags:--target x86_64-linux-android
-//@ [r78] needs-llvm-components: x86
-//@ [r79] compile-flags:--target x86_64-pc-solaris
-//@ [r79] needs-llvm-components: x86
-//@ [r80] compile-flags:--target x86_64-unknown-freebsd
-//@ [r80] needs-llvm-components: x86
-//@ [r81] compile-flags:--target x86_64-unknown-illumos
-//@ [r81] needs-llvm-components: x86
-//@ [r82] compile-flags:--target x86_64-unknown-linux-gnux32
-//@ [r82] needs-llvm-components: x86
-//@ [r83] compile-flags:--target x86_64-unknown-linux-musl
-//@ [r83] needs-llvm-components: x86
-//@ [r84] compile-flags:--target x86_64-unknown-netbsd
-//@ [r84] needs-llvm-components: x86
-//@ [r85] compile-flags: --target x86_64-unknown-redox
-//@ [r85] needs-llvm-components: x86
-//@ compile-flags: -Z stack-protector=all
-//@ compile-flags: -C opt-level=2
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[no_mangle]
-pub fn foo() {
-    // CHECK: foo{{:|()}}
-
-    // MSVC does the stack checking within a stack-check function:
-    // r3: calll @__security_check_cookie
-    // r7: callq __security_check_cookie
-    // r13: bl __security_check_cookie
-
-    // cuda doesn't support stack-smash protection
-    // r49-NOT: __security_check_cookie
-    // r49-NOT: __stack_chk_fail
-
-    // Other targets do stack checking within the function, and call a failure function on error
-    // r1: __stack_chk_fail
-    // r2: __stack_chk_fail
-    // r4: __stack_chk_fail
-    // r5: __stack_chk_fail
-    // r6: __stack_chk_fail
-    // r8: __stack_chk_fail
-    // r9: __stack_chk_fail
-    // r10: __stack_chk_fail
-    // r11: __stack_chk_fail
-    // r12: __stack_chk_fail
-    // r14: __stack_chk_fail
-    // r15: __stack_chk_fail
-    // r16: __stack_chk_fail
-    // r17: __stack_chk_fail
-    // r18: __stack_chk_fail
-    // r19: __stack_chk_fail
-    // r20: __stack_chk_fail
-    // r21: __stack_chk_fail
-    // r22: __stack_chk_fail
-    // r23: __stack_chk_fail
-    // r24: __stack_chk_fail
-    // r25: __stack_chk_fail
-    // r26: __stack_chk_fail
-    // r27: __stack_chk_fail
-    // r28: __stack_chk_fail
-    // r29: __stack_chk_fail
-    // r30: __stack_chk_fail
-    // r31: __stack_chk_fail
-    // r32: __stack_chk_fail
-    // r33: __stack_chk_fail
-    // r34: __stack_chk_fail
-    // r36: __stack_chk_fail
-    // r37: __stack_chk_fail
-    // r38: __stack_chk_fail
-    // r39: __stack_chk_fail
-    // r40: __stack_chk_fail
-    // r41: __stack_chk_fail
-    // r42: __stack_chk_fail
-    // r43: __stack_chk_fail
-    // r44: __stack_chk_fail
-    // r45: __stack_chk_fail
-    // r46: __stack_chk_fail
-    // r47: __stack_chk_fail
-    // r48: __stack_chk_fail
-    // r50: __stack_chk_fail
-    // r51: __stack_chk_fail
-    // r52: __stack_chk_fail
-    // r53: __stack_chk_fail
-    // r54: __stack_chk_fail
-    // r55: __stack_chk_fail
-    // r56: __stack_chk_fail
-    // r57: __stack_chk_fail
-    // r58: __stack_chk_fail
-    // r59: __stack_chk_fail
-    // r60: __stack_chk_fail
-    // r61: __stack_chk_fail
-    // r62: __stack_chk_fail
-    // r63: __stack_chk_fail
-    // r64: __stack_chk_fail
-    // r65: __stack_chk_fail
-    // r66: __stack_chk_fail
-    // r67: __stack_chk_fail
-    // r68: __stack_chk_fail
-    // r69: __stack_chk_fail
-    // r70: __stack_chk_fail
-    // r71: __stack_chk_fail
-    // r72: __stack_chk_fail
-    // r73: __stack_chk_fail
-    // r74: __stack_chk_fail
-    // r75: __stack_chk_fail
-    // r76: __stack_chk_fail
-    // r77: __stack_chk_fail
-    // r78: __stack_chk_fail
-    // r79: __stack_chk_fail
-    // r80: __stack_chk_fail
-    // r81: __stack_chk_fail
-    // r82: __stack_chk_fail
-    // r83: __stack_chk_fail
-    // r84: __stack_chk_fail
-    // r85: __stack_chk_fail
-}
diff --git a/tests/assembly/static-relocation-model.rs b/tests/assembly/static-relocation-model.rs
deleted file mode 100644
index 35ad94133b2..00000000000
--- a/tests/assembly/static-relocation-model.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-//@ add-core-stubs
-//@ revisions: x64 A64 ppc64le
-//@ assembly-output: emit-asm
-//@ [x64] compile-flags: --target x86_64-unknown-linux-gnu -Crelocation-model=static
-//@ [x64] needs-llvm-components: x86
-//@ [A64] compile-flags: --target aarch64-unknown-linux-gnu -Crelocation-model=static
-//@ [A64] needs-llvm-components: aarch64
-//@ [ppc64le] compile-flags: --target powerpc64le-unknown-linux-gnu -Crelocation-model=static
-//@ [ppc64le] needs-llvm-components: powerpc
-
-#![feature(no_core, lang_items)]
-#![no_core]
-#![crate_type = "rlib"]
-
-extern crate minicore;
-use minicore::*;
-
-#[no_mangle]
-pub static PIERIS: u8 = 42;
-
-extern "C" {
-    static EXOCHORDA: *mut u8;
-
-    fn chaenomeles();
-}
-
-// CHECK-LABEL: banana:
-// LLVM may produce either kind of `mov` here, depending on version and optimization level.
-// x64: {{movb|movzbl}}   chaenomeles{{(\(%[a-z0-9]+\))?}}, %{{[a-z0-9]+}}
-// A64:      adrp    [[REG:[a-z0-9]+]], chaenomeles
-// A64-NEXT: ldrb    {{[a-z0-9]+}}, {{\[}}[[REG]], :lo12:chaenomeles]
-#[no_mangle]
-pub fn banana() -> u8 {
-    unsafe { *(chaenomeles as *mut u8) }
-}
-
-// CHECK-LABEL: peach:
-// x64: {{movb|movzbl}}    banana{{(\(%[a-z0-9]+\))?}}, %{{[a-z0-9]+}}
-// A64:      adrp    [[REG2:[a-z0-9]+]], banana
-// A64-NEXT: ldrb    {{[a-z0-9]+}}, {{\[}}[[REG2]], :lo12:banana]
-#[no_mangle]
-pub fn peach() -> u8 {
-    unsafe { *(banana as *mut u8) }
-}
-
-// CHECK-LABEL: mango:
-// x64:      movq    EXOCHORDA{{(\(%[a-z0-9]+\))?}}, %[[REG:[a-z0-9]+]]
-// x64-NEXT: {{movb|movzbl}}   (%[[REG]]), %{{[a-z0-9]+}}
-// A64:      adrp    [[REG2:[a-z0-9]+]], EXOCHORDA
-// A64-NEXT: ldr     {{[a-z0-9]+}}, {{\[}}[[REG2]], :lo12:EXOCHORDA]
-#[no_mangle]
-pub fn mango() -> u8 {
-    unsafe { *EXOCHORDA }
-}
-
-// CHECK-LABEL: orange:
-// x64: mov{{l|absq}}    $PIERIS, %{{[a-z0-9]+}}
-// A64:      adrp    [[REG2:[a-z0-9]+]], PIERIS
-// A64-NEXT: add     {{[a-z0-9]+}}, [[REG2]], :lo12:PIERIS
-#[no_mangle]
-pub fn orange() -> &'static u8 {
-    &PIERIS
-}
-
-// For ppc64 we need to make sure to generate TOC entries even with the static relocation model
-// ppc64le: .tc chaenomeles[TC],chaenomeles
-// ppc64le: .tc banana[TC],banana
-// ppc64le: .tc EXOCHORDA[TC],EXOCHORDA
-// ppc64le: .tc PIERIS[TC],PIERIS
diff --git a/tests/assembly/strict_provenance.rs b/tests/assembly/strict_provenance.rs
deleted file mode 100644
index 1a797670962..00000000000
--- a/tests/assembly/strict_provenance.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=1
-//@ only-x86_64
-//@ ignore-sgx
-#![crate_type = "rlib"]
-
-// CHECK-LABEL: old_style
-// CHECK: movq %{{.*}}, %rax
-// CHECK: orq $1, %rax
-// CHECK: retq
-#[no_mangle]
-pub fn old_style(a: *mut u8) -> *mut u8 {
-    (a as usize | 1) as *mut u8
-}
-
-// CHECK-LABEL: cheri_compat
-// CHECK: movq %{{.*}}, %rax
-// CHECK: orq $1, %rax
-// CHECK: retq
-#[no_mangle]
-pub fn cheri_compat(a: *mut u8) -> *mut u8 {
-    let old = a as usize;
-    let new = old | 1;
-    let diff = new.wrapping_sub(old);
-    a.wrapping_add(diff)
-}
-
-// CHECK-LABEL: definitely_not_a_null_pointer
-// CHECK: movq %{{.*}}, %rax
-// CHECK: orq $1, %rax
-// CHECK: retq
-#[no_mangle]
-pub fn definitely_not_a_null_pointer(a: *mut u8) -> *mut u8 {
-    let old = a as usize;
-    let new = old | 1;
-    a.wrapping_sub(old).wrapping_add(new)
-}
diff --git a/tests/assembly/target-feature-multiple.rs b/tests/assembly/target-feature-multiple.rs
deleted file mode 100644
index bc432d21931..00000000000
--- a/tests/assembly/target-feature-multiple.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ needs-llvm-components: x86
-//@ revisions: TWOFLAGS SINGLEFLAG
-//@ compile-flags: --target=x86_64-unknown-linux-gnu
-//@ [TWOFLAGS] compile-flags: -C target-feature=+rdrnd -C target-feature=+rdseed
-//@ [SINGLEFLAG] compile-flags: -C target-feature=+rdrnd,+rdseed
-
-// Target features set via flags aren't necessarily reflected in the IR, so the only way to test
-// them is to build code that requires the features to be enabled to work.
-//
-// In this particular test if `rdrnd,rdseed` somehow didn't make it to LLVM, the instruction
-// selection should crash.
-//
-// > LLVM ERROR: Cannot select: 0x7f00f400c010: i32,i32,ch = X86ISD::RDSEED 0x7f00f400bfa8:2
-// > In function: foo
-//
-// See also tests/codegen/target-feature-overrides.rs
-#![feature(no_core, lang_items, link_llvm_intrinsics, abi_unadjusted)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// Use of these requires target features to be enabled
-extern "unadjusted" {
-    #[link_name = "llvm.x86.rdrand.32"]
-    fn x86_rdrand32_step() -> (u32, i32);
-    #[link_name = "llvm.x86.rdseed.32"]
-    fn x86_rdseed32_step() -> (u32, i32);
-}
-
-#[no_mangle]
-pub unsafe fn foo() -> (u32, u32) {
-    // CHECK-LABEL: foo:
-    // CHECK: rdrand
-    // CHECK: rdseed
-    (x86_rdrand32_step().0, x86_rdseed32_step().0)
-}
diff --git a/tests/assembly/targets/targets-amdgpu.rs b/tests/assembly/targets/targets-amdgpu.rs
deleted file mode 100644
index 1d10b8fc315..00000000000
--- a/tests/assembly/targets/targets-amdgpu.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-// ignore-tidy-linelength
-//@ revisions: amdgcn_amd_amdhsa
-//@ [amdgcn_amd_amdhsa] compile-flags: --target amdgcn-amd-amdhsa -Ctarget-cpu=gfx900
-//@ [amdgcn_amd_amdhsa] needs-llvm-components: amdgpu
-
-// Sanity-check that each target can produce assembly code.
-
-#![feature(no_core, lang_items)]
-#![no_std]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn test() -> u8 {
-    42
-}
-
-// CHECK: .version
diff --git a/tests/assembly/targets/targets-elf.rs b/tests/assembly/targets/targets-elf.rs
deleted file mode 100644
index edf16548e7d..00000000000
--- a/tests/assembly/targets/targets-elf.rs
+++ /dev/null
@@ -1,734 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-// ignore-tidy-linelength
-//@ revisions: aarch64_be_unknown_linux_gnu
-//@ [aarch64_be_unknown_linux_gnu] compile-flags: --target aarch64_be-unknown-linux-gnu
-//@ [aarch64_be_unknown_linux_gnu] needs-llvm-components: aarch64
-//@ revisions: aarch64_be_unknown_linux_gnu_ilp32
-//@ [aarch64_be_unknown_linux_gnu_ilp32] compile-flags: --target aarch64_be-unknown-linux-gnu_ilp32
-//@ [aarch64_be_unknown_linux_gnu_ilp32] needs-llvm-components: aarch64
-//@ revisions: aarch64_be_unknown_netbsd
-//@ [aarch64_be_unknown_netbsd] compile-flags: --target aarch64_be-unknown-netbsd
-//@ [aarch64_be_unknown_netbsd] needs-llvm-components: aarch64
-//@ revisions: aarch64_kmc_solid_asp3
-//@ [aarch64_kmc_solid_asp3] compile-flags: --target aarch64-kmc-solid_asp3
-//@ [aarch64_kmc_solid_asp3] needs-llvm-components: aarch64
-//@ revisions: aarch64_linux_android
-//@ [aarch64_linux_android] compile-flags: --target aarch64-linux-android
-//@ [aarch64_linux_android] needs-llvm-components: aarch64
-//@ revisions: aarch64_nintendo_switch_freestanding
-//@ [aarch64_nintendo_switch_freestanding] compile-flags: --target aarch64-nintendo-switch-freestanding
-//@ [aarch64_nintendo_switch_freestanding] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_freebsd
-//@ [aarch64_unknown_freebsd] compile-flags: --target aarch64-unknown-freebsd
-//@ [aarch64_unknown_freebsd] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_fuchsia
-//@ [aarch64_unknown_fuchsia] compile-flags: --target aarch64-unknown-fuchsia
-//@ [aarch64_unknown_fuchsia] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_hermit
-//@ [aarch64_unknown_hermit] compile-flags: --target aarch64-unknown-hermit
-//@ [aarch64_unknown_hermit] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_illumos
-//@ [aarch64_unknown_illumos] compile-flags: --target aarch64-unknown-illumos
-//@ [aarch64_unknown_illumos] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_linux_gnu
-//@ [aarch64_unknown_linux_gnu] compile-flags: --target aarch64-unknown-linux-gnu
-//@ [aarch64_unknown_linux_gnu] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_linux_gnu_ilp32
-//@ [aarch64_unknown_linux_gnu_ilp32] compile-flags: --target aarch64-unknown-linux-gnu_ilp32
-//@ [aarch64_unknown_linux_gnu_ilp32] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_linux_musl
-//@ [aarch64_unknown_linux_musl] compile-flags: --target aarch64-unknown-linux-musl
-//@ [aarch64_unknown_linux_musl] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_linux_ohos
-//@ [aarch64_unknown_linux_ohos] compile-flags: --target aarch64-unknown-linux-ohos
-//@ [aarch64_unknown_linux_ohos] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_netbsd
-//@ [aarch64_unknown_netbsd] compile-flags: --target aarch64-unknown-netbsd
-//@ [aarch64_unknown_netbsd] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_none
-//@ [aarch64_unknown_none] compile-flags: --target aarch64-unknown-none
-//@ [aarch64_unknown_none] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_none_softfloat
-//@ [aarch64_unknown_none_softfloat] compile-flags: --target aarch64-unknown-none-softfloat
-//@ [aarch64_unknown_none_softfloat] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_nto_qnx700
-//@ [aarch64_unknown_nto_qnx700] compile-flags: --target aarch64-unknown-nto-qnx700
-//@ [aarch64_unknown_nto_qnx700] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_nto_qnx710
-//@ [aarch64_unknown_nto_qnx710] compile-flags: --target aarch64-unknown-nto-qnx710
-//@ [aarch64_unknown_nto_qnx710] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_nto_qnx710_iosock
-//@ [aarch64_unknown_nto_qnx710_iosock] compile-flags: --target aarch64-unknown-nto-qnx710_iosock
-//@ [aarch64_unknown_nto_qnx710_iosock] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_nto_qnx800
-//@ [aarch64_unknown_nto_qnx800] compile-flags: --target aarch64-unknown-nto-qnx800
-//@ [aarch64_unknown_nto_qnx800] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_openbsd
-//@ [aarch64_unknown_openbsd] compile-flags: --target aarch64-unknown-openbsd
-//@ [aarch64_unknown_openbsd] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_redox
-//@ [aarch64_unknown_redox] compile-flags: --target aarch64-unknown-redox
-//@ [aarch64_unknown_redox] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_teeos
-//@ [aarch64_unknown_teeos] compile-flags: --target aarch64-unknown-teeos
-//@ [aarch64_unknown_teeos] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_nuttx
-//@ [aarch64_unknown_nuttx] compile-flags: --target aarch64-unknown-nuttx
-//@ [aarch64_unknown_nuttx] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_trusty
-//@ [aarch64_unknown_trusty] compile-flags: --target aarch64-unknown-trusty
-//@ [aarch64_unknown_trusty] needs-llvm-components: aarch64
-//@ revisions: aarch64_wrs_vxworks
-//@ [aarch64_wrs_vxworks] compile-flags: --target aarch64-wrs-vxworks
-//@ [aarch64_wrs_vxworks] needs-llvm-components: aarch64
-//@ revisions: arm_linux_androideabi
-//@ [arm_linux_androideabi] compile-flags: --target arm-linux-androideabi
-//@ [arm_linux_androideabi] needs-llvm-components: arm
-//@ revisions: arm_unknown_linux_gnueabi
-//@ [arm_unknown_linux_gnueabi] compile-flags: --target arm-unknown-linux-gnueabi
-//@ [arm_unknown_linux_gnueabi] needs-llvm-components: arm
-//@ revisions: arm_unknown_linux_gnueabihf
-//@ [arm_unknown_linux_gnueabihf] compile-flags: --target arm-unknown-linux-gnueabihf
-//@ [arm_unknown_linux_gnueabihf] needs-llvm-components: arm
-//@ revisions: arm_unknown_linux_musleabi
-//@ [arm_unknown_linux_musleabi] compile-flags: --target arm-unknown-linux-musleabi
-//@ [arm_unknown_linux_musleabi] needs-llvm-components: arm
-//@ revisions: arm_unknown_linux_musleabihf
-//@ [arm_unknown_linux_musleabihf] compile-flags: --target arm-unknown-linux-musleabihf
-//@ [arm_unknown_linux_musleabihf] needs-llvm-components: arm
-//@ revisions: armeb_unknown_linux_gnueabi
-//@ [armeb_unknown_linux_gnueabi] compile-flags: --target armeb-unknown-linux-gnueabi
-//@ [armeb_unknown_linux_gnueabi] needs-llvm-components: arm
-//@ revisions: armebv7r_none_eabi
-//@ [armebv7r_none_eabi] compile-flags: --target armebv7r-none-eabi
-//@ [armebv7r_none_eabi] needs-llvm-components: arm
-//@ revisions: armebv7r_none_eabihf
-//@ [armebv7r_none_eabihf] compile-flags: --target armebv7r-none-eabihf
-//@ [armebv7r_none_eabihf] needs-llvm-components: arm
-//@ revisions: armv4t_none_eabi
-//@ [armv4t_none_eabi] compile-flags: --target armv4t-none-eabi
-//@ [armv4t_none_eabi] needs-llvm-components: arm
-//@ revisions: armv4t_unknown_linux_gnueabi
-//@ [armv4t_unknown_linux_gnueabi] compile-flags: --target armv4t-unknown-linux-gnueabi
-//@ [armv4t_unknown_linux_gnueabi] needs-llvm-components: arm
-//@ revisions: armv5te_none_eabi
-//@ [armv5te_none_eabi] compile-flags: --target armv5te-none-eabi
-//@ [armv5te_none_eabi] needs-llvm-components: arm
-//@ revisions: armv5te_unknown_linux_gnueabi
-//@ [armv5te_unknown_linux_gnueabi] compile-flags: --target armv5te-unknown-linux-gnueabi
-//@ [armv5te_unknown_linux_gnueabi] needs-llvm-components: arm
-//@ revisions: armv5te_unknown_linux_musleabi
-//@ [armv5te_unknown_linux_musleabi] compile-flags: --target armv5te-unknown-linux-musleabi
-//@ [armv5te_unknown_linux_musleabi] needs-llvm-components: arm
-//@ revisions: armv5te_unknown_linux_uclibceabi
-//@ [armv5te_unknown_linux_uclibceabi] compile-flags: --target armv5te-unknown-linux-uclibceabi
-//@ [armv5te_unknown_linux_uclibceabi] needs-llvm-components: arm
-//@ revisions: armv6_unknown_freebsd
-//@ [armv6_unknown_freebsd] compile-flags: --target armv6-unknown-freebsd
-//@ [armv6_unknown_freebsd] needs-llvm-components: arm
-//@ revisions: armv6_unknown_netbsd_eabihf
-//@ [armv6_unknown_netbsd_eabihf] compile-flags: --target armv6-unknown-netbsd-eabihf
-//@ [armv6_unknown_netbsd_eabihf] needs-llvm-components: arm
-//@ revisions: armv6k_nintendo_3ds
-//@ [armv6k_nintendo_3ds] compile-flags: --target armv6k-nintendo-3ds
-//@ [armv6k_nintendo_3ds] needs-llvm-components: arm
-//@ revisions: armv7_linux_androideabi
-//@ [armv7_linux_androideabi] compile-flags: --target armv7-linux-androideabi
-//@ [armv7_linux_androideabi] needs-llvm-components: arm
-//@ revisions: armv7_rtems_eabihf
-//@ [armv7_rtems_eabihf] compile-flags: --target armv7-rtems-eabihf
-//@ [armv7_rtems_eabihf] needs-llvm-components: arm
-//@ revisions: armv7_sony_vita_newlibeabihf
-//@ [armv7_sony_vita_newlibeabihf] compile-flags: --target armv7-sony-vita-newlibeabihf
-//@ [armv7_sony_vita_newlibeabihf] needs-llvm-components: arm
-//@ revisions: armv7_unknown_freebsd
-//@ [armv7_unknown_freebsd] compile-flags: --target armv7-unknown-freebsd
-//@ [armv7_unknown_freebsd] needs-llvm-components: arm
-//@ revisions: armv7_unknown_linux_gnueabi
-//@ [armv7_unknown_linux_gnueabi] compile-flags: --target armv7-unknown-linux-gnueabi
-//@ [armv7_unknown_linux_gnueabi] needs-llvm-components: arm
-//@ revisions: armv7_unknown_linux_gnueabihf
-//@ [armv7_unknown_linux_gnueabihf] compile-flags: --target armv7-unknown-linux-gnueabihf
-//@ [armv7_unknown_linux_gnueabihf] needs-llvm-components: arm
-//@ revisions: armv7_unknown_linux_musleabi
-//@ [armv7_unknown_linux_musleabi] compile-flags: --target armv7-unknown-linux-musleabi
-//@ [armv7_unknown_linux_musleabi] needs-llvm-components: arm
-//@ revisions: armv7_unknown_linux_musleabihf
-//@ [armv7_unknown_linux_musleabihf] compile-flags: --target armv7-unknown-linux-musleabihf
-//@ [armv7_unknown_linux_musleabihf] needs-llvm-components: arm
-//@ revisions: armv7_unknown_linux_ohos
-//@ [armv7_unknown_linux_ohos] compile-flags: --target armv7-unknown-linux-ohos
-//@ [armv7_unknown_linux_ohos] needs-llvm-components: arm
-//@ revisions: armv7_unknown_linux_uclibceabi
-//@ [armv7_unknown_linux_uclibceabi] compile-flags: --target armv7-unknown-linux-uclibceabi
-//@ [armv7_unknown_linux_uclibceabi] needs-llvm-components: arm
-//@ revisions: armv7_unknown_linux_uclibceabihf
-//@ [armv7_unknown_linux_uclibceabihf] compile-flags: --target armv7-unknown-linux-uclibceabihf
-//@ [armv7_unknown_linux_uclibceabihf] needs-llvm-components: arm
-//@ revisions: armv7_unknown_netbsd_eabihf
-//@ [armv7_unknown_netbsd_eabihf] compile-flags: --target armv7-unknown-netbsd-eabihf
-//@ [armv7_unknown_netbsd_eabihf] needs-llvm-components: arm
-//@ revisions: armv7_unknown_trusty
-//@ [armv7_unknown_trusty] compile-flags: --target armv7-unknown-trusty
-//@ [armv7_unknown_trusty] needs-llvm-components: arm
-//@ revisions: armv7_wrs_vxworks_eabihf
-//@ [armv7_wrs_vxworks_eabihf] compile-flags: --target armv7-wrs-vxworks-eabihf
-//@ [armv7_wrs_vxworks_eabihf] needs-llvm-components: arm
-//@ revisions: armv7a_kmc_solid_asp3_eabi
-//@ [armv7a_kmc_solid_asp3_eabi] compile-flags: --target armv7a-kmc-solid_asp3-eabi
-//@ [armv7a_kmc_solid_asp3_eabi] needs-llvm-components: arm
-//@ revisions: armv7a_kmc_solid_asp3_eabihf
-//@ [armv7a_kmc_solid_asp3_eabihf] compile-flags: --target armv7a-kmc-solid_asp3-eabihf
-//@ [armv7a_kmc_solid_asp3_eabihf] needs-llvm-components: arm
-//@ revisions: armv7a_none_eabi
-//@ [armv7a_none_eabi] compile-flags: --target armv7a-none-eabi
-//@ [armv7a_none_eabi] needs-llvm-components: arm
-//@ revisions: armv7a_none_eabihf
-//@ [armv7a_none_eabihf] compile-flags: --target armv7a-none-eabihf
-//@ [armv7a_none_eabihf] needs-llvm-components: arm
-//@ revisions: armv7a_nuttx_eabi
-//@ [armv7a_nuttx_eabi] compile-flags: --target armv7a-nuttx-eabi
-//@ [armv7a_nuttx_eabi] needs-llvm-components: arm
-//@ revisions: armv7a_nuttx_eabihf
-//@ [armv7a_nuttx_eabihf] compile-flags: --target armv7a-nuttx-eabihf
-//@ [armv7a_nuttx_eabihf] needs-llvm-components: arm
-//@ revisions: armv7r_none_eabi
-//@ [armv7r_none_eabi] compile-flags: --target armv7r-none-eabi
-//@ [armv7r_none_eabi] needs-llvm-components: arm
-//@ revisions: armv7r_none_eabihf
-//@ [armv7r_none_eabihf] compile-flags: --target armv7r-none-eabihf
-//@ [armv7r_none_eabihf] needs-llvm-components: arm
-//@ revisions: armv8r_none_eabihf
-//@ [armv8r_none_eabihf] compile-flags: --target armv8r-none-eabihf
-//@ [armv8r_none_eabihf] needs-llvm-components: arm
-// FIXME: disabled since it fails on CI saying the csky component is missing
-/*
-    revisions: csky_unknown_linux_gnuabiv2
-    [csky_unknown_linux_gnuabiv2] compile-flags: --target csky-unknown-linux-gnuabiv2
-    [csky_unknown_linux_gnuabiv2] needs-llvm-components: csky
-    revisions: csky_unknown_linux_gnuabiv2hf
-    [csky_unknown_linux_gnuabiv2hf] compile-flags: --target csky-unknown-linux-gnuabiv2hf
-    [csky_unknown_linux_gnuabiv2hf] needs-llvm-components: csky
-*/
-//@ revisions: hexagon_unknown_linux_musl
-//@ [hexagon_unknown_linux_musl] compile-flags: --target hexagon-unknown-linux-musl
-//@ [hexagon_unknown_linux_musl] needs-llvm-components: hexagon
-//@ revisions: hexagon_unknown_none_elf
-//@ [hexagon_unknown_none_elf] compile-flags: --target hexagon-unknown-none-elf
-//@ [hexagon_unknown_none_elf] needs-llvm-components: hexagon
-//@ revisions: i686_pc_nto_qnx700
-//@ [i686_pc_nto_qnx700] compile-flags: --target i686-pc-nto-qnx700
-//@ [i686_pc_nto_qnx700] needs-llvm-components: x86
-//@ revisions: i586_unknown_linux_gnu
-//@ [i586_unknown_linux_gnu] compile-flags: --target i586-unknown-linux-gnu
-//@ [i586_unknown_linux_gnu] needs-llvm-components: x86
-//@ revisions: i586_unknown_linux_musl
-//@ [i586_unknown_linux_musl] compile-flags: --target i586-unknown-linux-musl
-//@ [i586_unknown_linux_musl] needs-llvm-components: x86
-//@ revisions: i586_unknown_netbsd
-//@ [i586_unknown_netbsd] compile-flags: --target i586-unknown-netbsd
-//@ [i586_unknown_netbsd] needs-llvm-components: x86
-//@ revisions: i586_unknown_redox
-//@ [i586_unknown_redox] compile-flags: --target i586-unknown-redox
-//@ [i586_unknown_redox] needs-llvm-components: x86
-//@ revisions: i686_linux_android
-//@ [i686_linux_android] compile-flags: --target i686-linux-android
-//@ [i686_linux_android] needs-llvm-components: x86
-//@ revisions: i686_unknown_freebsd
-//@ [i686_unknown_freebsd] compile-flags: --target i686-unknown-freebsd
-//@ [i686_unknown_freebsd] needs-llvm-components: x86
-//@ revisions: i686_unknown_haiku
-//@ [i686_unknown_haiku] compile-flags: --target i686-unknown-haiku
-//@ [i686_unknown_haiku] needs-llvm-components: x86
-//@ revisions: i686_unknown_hurd_gnu
-//@ [i686_unknown_hurd_gnu] compile-flags: --target i686-unknown-hurd-gnu
-//@ [i686_unknown_hurd_gnu] needs-llvm-components: x86
-//@ revisions: i686_unknown_linux_gnu
-//@ [i686_unknown_linux_gnu] compile-flags: --target i686-unknown-linux-gnu
-//@ [i686_unknown_linux_gnu] needs-llvm-components: x86
-//@ revisions: i686_unknown_linux_musl
-//@ [i686_unknown_linux_musl] compile-flags: --target i686-unknown-linux-musl
-//@ [i686_unknown_linux_musl] needs-llvm-components: x86
-//@ revisions: i686_unknown_netbsd
-//@ [i686_unknown_netbsd] compile-flags: --target i686-unknown-netbsd
-//@ [i686_unknown_netbsd] needs-llvm-components: x86
-//@ revisions: i686_unknown_openbsd
-//@ [i686_unknown_openbsd] compile-flags: --target i686-unknown-openbsd
-//@ [i686_unknown_openbsd] needs-llvm-components: x86
-//@ revisions: i686_wrs_vxworks
-//@ [i686_wrs_vxworks] compile-flags: --target i686-wrs-vxworks
-//@ [i686_wrs_vxworks] needs-llvm-components: x86
-//@ revisions: loongarch32_unknown_none
-//@ [loongarch32_unknown_none] compile-flags: --target loongarch32-unknown-none
-//@ [loongarch32_unknown_none] needs-llvm-components: loongarch
-//@ revisions: loongarch32_unknown_none_softfloat
-//@ [loongarch32_unknown_none_softfloat] compile-flags: --target loongarch32-unknown-none-softfloat
-//@ [loongarch32_unknown_none_softfloat] needs-llvm-components: loongarch
-//@ revisions: loongarch64_unknown_linux_gnu
-//@ [loongarch64_unknown_linux_gnu] compile-flags: --target loongarch64-unknown-linux-gnu
-//@ [loongarch64_unknown_linux_gnu] needs-llvm-components: loongarch
-//@ revisions: loongarch64_unknown_linux_musl
-//@ [loongarch64_unknown_linux_musl] compile-flags: --target loongarch64-unknown-linux-musl
-//@ [loongarch64_unknown_linux_musl] needs-llvm-components: loongarch
-//@ revisions: loongarch64_unknown_linux_ohos
-//@ [loongarch64_unknown_linux_ohos] compile-flags: --target loongarch64-unknown-linux-ohos
-//@ [loongarch64_unknown_linux_ohos] needs-llvm-components: loongarch
-//@ revisions: loongarch64_unknown_none
-//@ [loongarch64_unknown_none] compile-flags: --target loongarch64-unknown-none
-//@ [loongarch64_unknown_none] needs-llvm-components: loongarch
-//@ revisions: loongarch64_unknown_none_softfloat
-//@ [loongarch64_unknown_none_softfloat] compile-flags: --target loongarch64-unknown-none-softfloat
-//@ [loongarch64_unknown_none_softfloat] needs-llvm-components: loongarch
-//@ revisions: m68k_unknown_linux_gnu
-//@ [m68k_unknown_linux_gnu] compile-flags: --target m68k-unknown-linux-gnu
-//@ [m68k_unknown_linux_gnu] needs-llvm-components: m68k
-//@ revisions: m68k_unknown_none_elf
-//@ [m68k_unknown_none_elf] compile-flags: --target m68k-unknown-none-elf
-//@ [m68k_unknown_none_elf] needs-llvm-components: m68k
-//@ revisions: mips64_openwrt_linux_musl
-//@ [mips64_openwrt_linux_musl] compile-flags: --target mips64-openwrt-linux-musl
-//@ [mips64_openwrt_linux_musl] needs-llvm-components: mips
-//@ revisions: mips64_unknown_linux_gnuabi64
-//@ [mips64_unknown_linux_gnuabi64] compile-flags: --target mips64-unknown-linux-gnuabi64
-//@ [mips64_unknown_linux_gnuabi64] needs-llvm-components: mips
-//@ revisions: mips64_unknown_linux_muslabi64
-//@ [mips64_unknown_linux_muslabi64] compile-flags: --target mips64-unknown-linux-muslabi64
-//@ [mips64_unknown_linux_muslabi64] needs-llvm-components: mips
-//@ revisions: mips64el_unknown_linux_gnuabi64
-//@ [mips64el_unknown_linux_gnuabi64] compile-flags: --target mips64el-unknown-linux-gnuabi64
-//@ [mips64el_unknown_linux_gnuabi64] needs-llvm-components: mips
-//@ revisions: mips64el_unknown_linux_muslabi64
-//@ [mips64el_unknown_linux_muslabi64] compile-flags: --target mips64el-unknown-linux-muslabi64
-//@ [mips64el_unknown_linux_muslabi64] needs-llvm-components: mips
-//@ revisions: mips_unknown_linux_gnu
-//@ [mips_unknown_linux_gnu] compile-flags: --target mips-unknown-linux-gnu
-//@ [mips_unknown_linux_gnu] needs-llvm-components: mips
-//@ revisions: mips_unknown_linux_musl
-//@ [mips_unknown_linux_musl] compile-flags: --target mips-unknown-linux-musl
-//@ [mips_unknown_linux_musl] needs-llvm-components: mips
-//@ revisions: mips_unknown_linux_uclibc
-//@ [mips_unknown_linux_uclibc] compile-flags: --target mips-unknown-linux-uclibc
-//@ [mips_unknown_linux_uclibc] needs-llvm-components: mips
-//@ revisions: mips_mti_none_elf
-//@ [mips_mti_none_elf] compile-flags: --target mips-mti-none-elf
-//@ [mips_mti_none_elf] needs-llvm-components: mips
-//@ revisions: mipsel_mti_none_elf
-//@ [mipsel_mti_none_elf] compile-flags: --target mipsel-mti-none-elf
-//@ [mipsel_mti_none_elf] needs-llvm-components: mips
-//@ revisions: mipsel_sony_psp
-//@ [mipsel_sony_psp] compile-flags: --target mipsel-sony-psp
-//@ [mipsel_sony_psp] needs-llvm-components: mips
-//@ revisions: mipsel_sony_psx
-//@ [mipsel_sony_psx] compile-flags: --target mipsel-sony-psx
-//@ [mipsel_sony_psx] needs-llvm-components: mips
-//@ revisions: mipsel_unknown_linux_gnu
-//@ [mipsel_unknown_linux_gnu] compile-flags: --target mipsel-unknown-linux-gnu
-//@ [mipsel_unknown_linux_gnu] needs-llvm-components: mips
-//@ revisions: mipsel_unknown_linux_musl
-//@ [mipsel_unknown_linux_musl] compile-flags: --target mipsel-unknown-linux-musl
-//@ [mipsel_unknown_linux_musl] needs-llvm-components: mips
-//@ revisions: mipsel_unknown_linux_uclibc
-//@ [mipsel_unknown_linux_uclibc] compile-flags: --target mipsel-unknown-linux-uclibc
-//@ [mipsel_unknown_linux_uclibc] needs-llvm-components: mips
-//@ revisions: mipsel_unknown_netbsd
-//@ [mipsel_unknown_netbsd] compile-flags: --target mipsel-unknown-netbsd
-//@ [mipsel_unknown_netbsd] needs-llvm-components: mips
-//@ revisions: mipsel_unknown_none
-//@ [mipsel_unknown_none] compile-flags: --target mipsel-unknown-none
-//@ [mipsel_unknown_none] needs-llvm-components: mips
-//@ revisions: mipsisa32r6_unknown_linux_gnu
-//@ [mipsisa32r6_unknown_linux_gnu] compile-flags: --target mipsisa32r6-unknown-linux-gnu
-//@ [mipsisa32r6_unknown_linux_gnu] needs-llvm-components: mips
-//@ revisions: mipsisa32r6el_unknown_linux_gnu
-//@ [mipsisa32r6el_unknown_linux_gnu] compile-flags: --target mipsisa32r6el-unknown-linux-gnu
-//@ [mipsisa32r6el_unknown_linux_gnu] needs-llvm-components: mips
-//@ revisions: mipsisa64r6_unknown_linux_gnuabi64
-//@ [mipsisa64r6_unknown_linux_gnuabi64] compile-flags: --target mipsisa64r6-unknown-linux-gnuabi64
-//@ [mipsisa64r6_unknown_linux_gnuabi64] needs-llvm-components: mips
-//@ revisions: mipsisa64r6el_unknown_linux_gnuabi64
-//@ [mipsisa64r6el_unknown_linux_gnuabi64] compile-flags: --target mipsisa64r6el-unknown-linux-gnuabi64
-//@ [mipsisa64r6el_unknown_linux_gnuabi64] needs-llvm-components: mips
-//@ revisions: msp430_none_elf
-//@ [msp430_none_elf] compile-flags: --target msp430-none-elf
-//@ [msp430_none_elf] needs-llvm-components: msp430
-//@ revisions: powerpc64_unknown_freebsd
-//@ [powerpc64_unknown_freebsd] compile-flags: --target powerpc64-unknown-freebsd
-//@ [powerpc64_unknown_freebsd] needs-llvm-components: powerpc
-//@ revisions: powerpc64_unknown_linux_gnu
-//@ [powerpc64_unknown_linux_gnu] compile-flags: --target powerpc64-unknown-linux-gnu
-//@ [powerpc64_unknown_linux_gnu] needs-llvm-components: powerpc
-//@ revisions: powerpc64_unknown_linux_musl
-//@ [powerpc64_unknown_linux_musl] compile-flags: --target powerpc64-unknown-linux-musl
-//@ [powerpc64_unknown_linux_musl] needs-llvm-components: powerpc
-//@ revisions: powerpc64_unknown_openbsd
-//@ [powerpc64_unknown_openbsd] compile-flags: --target powerpc64-unknown-openbsd
-//@ [powerpc64_unknown_openbsd] needs-llvm-components: powerpc
-//@ revisions: powerpc64_wrs_vxworks
-//@ [powerpc64_wrs_vxworks] compile-flags: --target powerpc64-wrs-vxworks
-//@ [powerpc64_wrs_vxworks] needs-llvm-components: powerpc
-//@ revisions: powerpc64le_unknown_freebsd
-//@ [powerpc64le_unknown_freebsd] compile-flags: --target powerpc64le-unknown-freebsd
-//@ [powerpc64le_unknown_freebsd] needs-llvm-components: powerpc
-//@ revisions: powerpc64le_unknown_linux_gnu
-//@ [powerpc64le_unknown_linux_gnu] compile-flags: --target powerpc64le-unknown-linux-gnu
-//@ [powerpc64le_unknown_linux_gnu] needs-llvm-components: powerpc
-//@ revisions: powerpc64le_unknown_linux_musl
-//@ [powerpc64le_unknown_linux_musl] compile-flags: --target powerpc64le-unknown-linux-musl
-//@ [powerpc64le_unknown_linux_musl] needs-llvm-components: powerpc
-//@ revisions: powerpc_unknown_freebsd
-//@ [powerpc_unknown_freebsd] compile-flags: --target powerpc-unknown-freebsd
-//@ [powerpc_unknown_freebsd] needs-llvm-components: powerpc
-//@ revisions: powerpc_unknown_linux_gnu
-//@ [powerpc_unknown_linux_gnu] compile-flags: --target powerpc-unknown-linux-gnu
-//@ [powerpc_unknown_linux_gnu] needs-llvm-components: powerpc
-//@ revisions: powerpc_unknown_linux_gnuspe
-//@ [powerpc_unknown_linux_gnuspe] compile-flags: --target powerpc-unknown-linux-gnuspe
-//@ [powerpc_unknown_linux_gnuspe] needs-llvm-components: powerpc
-//@ revisions: powerpc_unknown_linux_musl
-//@ [powerpc_unknown_linux_musl] compile-flags: --target powerpc-unknown-linux-musl
-//@ [powerpc_unknown_linux_musl] needs-llvm-components: powerpc
-//@ revisions: powerpc_unknown_linux_muslspe
-//@ [powerpc_unknown_linux_muslspe] compile-flags: --target powerpc-unknown-linux-muslspe
-//@ [powerpc_unknown_linux_muslspe] needs-llvm-components: powerpc
-//@ revisions: powerpc_unknown_netbsd
-//@ [powerpc_unknown_netbsd] compile-flags: --target powerpc-unknown-netbsd
-//@ [powerpc_unknown_netbsd] needs-llvm-components: powerpc
-//@ revisions: powerpc_unknown_openbsd
-//@ [powerpc_unknown_openbsd] compile-flags: --target powerpc-unknown-openbsd
-//@ [powerpc_unknown_openbsd] needs-llvm-components: powerpc
-//@ revisions: powerpc_wrs_vxworks
-//@ [powerpc_wrs_vxworks] compile-flags: --target powerpc-wrs-vxworks
-//@ [powerpc_wrs_vxworks] needs-llvm-components: powerpc
-//@ revisions: powerpc_wrs_vxworks_spe
-//@ [powerpc_wrs_vxworks_spe] compile-flags: --target powerpc-wrs-vxworks-spe
-//@ [powerpc_wrs_vxworks_spe] needs-llvm-components: powerpc
-//@ revisions: riscv32_wrs_vxworks
-//@ [riscv32_wrs_vxworks] compile-flags: --target riscv32-wrs-vxworks
-//@ [riscv32_wrs_vxworks] needs-llvm-components: riscv
-//@ revisions: riscv32e_unknown_none_elf
-//@ [riscv32e_unknown_none_elf] compile-flags: --target riscv32e-unknown-none-elf
-//@ [riscv32e_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: riscv32em_unknown_none_elf
-//@ [riscv32em_unknown_none_elf] compile-flags: --target riscv32em-unknown-none-elf
-//@ [riscv32em_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: riscv32emc_unknown_none_elf
-//@ [riscv32emc_unknown_none_elf] compile-flags: --target riscv32emc-unknown-none-elf
-//@ [riscv32emc_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: riscv32gc_unknown_linux_gnu
-//@ [riscv32gc_unknown_linux_gnu] compile-flags: --target riscv32gc-unknown-linux-gnu
-//@ [riscv32gc_unknown_linux_gnu] needs-llvm-components: riscv
-//@ revisions: riscv32gc_unknown_linux_musl
-//@ [riscv32gc_unknown_linux_musl] compile-flags: --target riscv32gc-unknown-linux-musl
-//@ [riscv32gc_unknown_linux_musl] needs-llvm-components: riscv
-//@ revisions: riscv32i_unknown_none_elf
-//@ [riscv32i_unknown_none_elf] compile-flags: --target riscv32i-unknown-none-elf
-//@ [riscv32i_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: riscv32im_risc0_zkvm_elf
-//@ [riscv32im_risc0_zkvm_elf] compile-flags: --target riscv32im-risc0-zkvm-elf
-//@ [riscv32im_risc0_zkvm_elf] needs-llvm-components: riscv
-//@ revisions: riscv32im_unknown_none_elf
-//@ [riscv32im_unknown_none_elf] compile-flags: --target riscv32im-unknown-none-elf
-//@ [riscv32im_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: riscv32ima_unknown_none_elf
-//@ [riscv32ima_unknown_none_elf] compile-flags: --target riscv32ima-unknown-none-elf
-//@ [riscv32ima_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: riscv32imac_esp_espidf
-//@ [riscv32imac_esp_espidf] compile-flags: --target riscv32imac-esp-espidf
-//@ [riscv32imac_esp_espidf] needs-llvm-components: riscv
-//@ revisions: riscv32imac_unknown_none_elf
-//@ [riscv32imac_unknown_none_elf] compile-flags: --target riscv32imac-unknown-none-elf
-//@ [riscv32imac_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: riscv32imac_unknown_xous_elf
-//@ [riscv32imac_unknown_xous_elf] compile-flags: --target riscv32imac-unknown-xous-elf
-//@ [riscv32imac_unknown_xous_elf] needs-llvm-components: riscv
-//@ revisions: riscv32imafc_unknown_none_elf
-//@ [riscv32imafc_unknown_none_elf] compile-flags: --target riscv32imafc-unknown-none-elf
-//@ [riscv32imafc_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: riscv32imafc_esp_espidf
-//@ [riscv32imafc_esp_espidf] compile-flags: --target riscv32imafc-esp-espidf
-//@ [riscv32imafc_esp_espidf] needs-llvm-components: riscv
-//@ revisions: riscv32imc_esp_espidf
-//@ [riscv32imc_esp_espidf] compile-flags: --target riscv32imc-esp-espidf
-//@ [riscv32imc_esp_espidf] needs-llvm-components: riscv
-//@ revisions: riscv32imc_unknown_none_elf
-//@ [riscv32imc_unknown_none_elf] compile-flags: --target riscv32imc-unknown-none-elf
-//@ [riscv32imc_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: riscv64_linux_android
-//@ [riscv64_linux_android] compile-flags: --target riscv64-linux-android
-//@ [riscv64_linux_android] needs-llvm-components: riscv
-//@ revisions: riscv64_wrs_vxworks
-//@ [riscv64_wrs_vxworks] compile-flags: --target riscv64-wrs-vxworks
-//@ [riscv64_wrs_vxworks] needs-llvm-components: riscv
-//@ revisions: riscv64gc_unknown_freebsd
-//@ [riscv64gc_unknown_freebsd] compile-flags: --target riscv64gc-unknown-freebsd
-//@ [riscv64gc_unknown_freebsd] needs-llvm-components: riscv
-//@ revisions: riscv64gc_unknown_fuchsia
-//@ [riscv64gc_unknown_fuchsia] compile-flags: --target riscv64gc-unknown-fuchsia
-//@ [riscv64gc_unknown_fuchsia] needs-llvm-components: riscv
-//@ revisions: riscv64gc_unknown_hermit
-//@ [riscv64gc_unknown_hermit] compile-flags: --target riscv64gc-unknown-hermit
-//@ [riscv64gc_unknown_hermit] needs-llvm-components: riscv
-//@ revisions: riscv64gc_unknown_linux_gnu
-//@ [riscv64gc_unknown_linux_gnu] compile-flags: --target riscv64gc-unknown-linux-gnu
-//@ [riscv64gc_unknown_linux_gnu] needs-llvm-components: riscv
-//@ revisions: riscv64gc_unknown_linux_musl
-//@ [riscv64gc_unknown_linux_musl] compile-flags: --target riscv64gc-unknown-linux-musl
-//@ [riscv64gc_unknown_linux_musl] needs-llvm-components: riscv
-//@ revisions: riscv64gc_unknown_netbsd
-//@ [riscv64gc_unknown_netbsd] compile-flags: --target riscv64gc-unknown-netbsd
-//@ [riscv64gc_unknown_netbsd] needs-llvm-components: riscv
-//@ revisions: riscv64gc_unknown_none_elf
-//@ [riscv64gc_unknown_none_elf] compile-flags: --target riscv64gc-unknown-none-elf
-//@ [riscv64gc_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: riscv64gc_unknown_openbsd
-//@ [riscv64gc_unknown_openbsd] compile-flags: --target riscv64gc-unknown-openbsd
-//@ [riscv64gc_unknown_openbsd] needs-llvm-components: riscv
-//@ revisions: riscv64imac_unknown_none_elf
-//@ [riscv64imac_unknown_none_elf] compile-flags: --target riscv64imac-unknown-none-elf
-//@ [riscv64imac_unknown_none_elf] needs-llvm-components: riscv
-//@ revisions: s390x_unknown_linux_gnu
-//@ [s390x_unknown_linux_gnu] compile-flags: --target s390x-unknown-linux-gnu
-//@ [s390x_unknown_linux_gnu] needs-llvm-components: systemz
-//@ revisions: s390x_unknown_linux_musl
-//@ [s390x_unknown_linux_musl] compile-flags: --target s390x-unknown-linux-musl
-//@ [s390x_unknown_linux_musl] needs-llvm-components: systemz
-//@ revisions: sparc64_unknown_linux_gnu
-//@ [sparc64_unknown_linux_gnu] compile-flags: --target sparc64-unknown-linux-gnu
-//@ [sparc64_unknown_linux_gnu] needs-llvm-components: sparc
-//@ revisions: sparc64_unknown_netbsd
-//@ [sparc64_unknown_netbsd] compile-flags: --target sparc64-unknown-netbsd
-//@ [sparc64_unknown_netbsd] needs-llvm-components: sparc
-//@ revisions: sparc64_unknown_openbsd
-//@ [sparc64_unknown_openbsd] compile-flags: --target sparc64-unknown-openbsd
-//@ [sparc64_unknown_openbsd] needs-llvm-components: sparc
-//@ revisions: sparc_unknown_linux_gnu
-//@ [sparc_unknown_linux_gnu] compile-flags: --target sparc-unknown-linux-gnu
-//@ [sparc_unknown_linux_gnu] needs-llvm-components: sparc
-//@ revisions: sparc_unknown_none_elf
-//@ [sparc_unknown_none_elf] compile-flags: --target sparc-unknown-none-elf
-//@ [sparc_unknown_none_elf] needs-llvm-components: sparc
-//@ revisions: sparcv9_sun_solaris
-//@ [sparcv9_sun_solaris] compile-flags: --target sparcv9-sun-solaris
-//@ [sparcv9_sun_solaris] needs-llvm-components: sparc
-//@ revisions: thumbv4t_none_eabi
-//@ [thumbv4t_none_eabi] compile-flags: --target thumbv4t-none-eabi
-//@ [thumbv4t_none_eabi] needs-llvm-components: arm
-//@ revisions: thumbv5te_none_eabi
-//@ [thumbv5te_none_eabi] compile-flags: --target thumbv5te-none-eabi
-//@ [thumbv5te_none_eabi] needs-llvm-components: arm
-//@ revisions: thumbv6m_none_eabi
-//@ [thumbv6m_none_eabi] compile-flags: --target thumbv6m-none-eabi
-//@ [thumbv6m_none_eabi] needs-llvm-components: arm
-//@ revisions: thumbv7em_none_eabi
-//@ [thumbv7em_none_eabi] compile-flags: --target thumbv7em-none-eabi
-//@ [thumbv7em_none_eabi] needs-llvm-components: arm
-//@ revisions: thumbv7em_none_eabihf
-//@ [thumbv7em_none_eabihf] compile-flags: --target thumbv7em-none-eabihf
-//@ [thumbv7em_none_eabihf] needs-llvm-components: arm
-//@ revisions: thumbv7m_none_eabi
-//@ [thumbv7m_none_eabi] compile-flags: --target thumbv7m-none-eabi
-//@ [thumbv7m_none_eabi] needs-llvm-components: arm
-//@ revisions: thumbv7neon_linux_androideabi
-//@ [thumbv7neon_linux_androideabi] compile-flags: --target thumbv7neon-linux-androideabi
-//@ [thumbv7neon_linux_androideabi] needs-llvm-components: arm
-//@ revisions: thumbv7neon_unknown_linux_gnueabihf
-//@ [thumbv7neon_unknown_linux_gnueabihf] compile-flags: --target thumbv7neon-unknown-linux-gnueabihf
-//@ [thumbv7neon_unknown_linux_gnueabihf] needs-llvm-components: arm
-//@ revisions: thumbv7neon_unknown_linux_musleabihf
-//@ [thumbv7neon_unknown_linux_musleabihf] compile-flags: --target thumbv7neon-unknown-linux-musleabihf
-//@ [thumbv7neon_unknown_linux_musleabihf] needs-llvm-components: arm
-//@ revisions: thumbv8m_base_none_eabi
-//@ [thumbv8m_base_none_eabi] compile-flags: --target thumbv8m.base-none-eabi
-//@ [thumbv8m_base_none_eabi] needs-llvm-components: arm
-//@ revisions: thumbv8m_main_none_eabi
-//@ [thumbv8m_main_none_eabi] compile-flags: --target thumbv8m.main-none-eabi
-//@ [thumbv8m_main_none_eabi] needs-llvm-components: arm
-//@ revisions: thumbv8m_main_none_eabihf
-//@ [thumbv8m_main_none_eabihf] compile-flags: --target thumbv8m.main-none-eabihf
-//@ [thumbv8m_main_none_eabihf] needs-llvm-components: arm
-//@ revisions: wasm32_unknown_emscripten
-//@ [wasm32_unknown_emscripten] compile-flags: --target wasm32-unknown-emscripten
-//@ [wasm32_unknown_emscripten] needs-llvm-components: webassembly
-//@ revisions: wasm32_unknown_unknown
-//@ [wasm32_unknown_unknown] compile-flags: --target wasm32-unknown-unknown
-//@ [wasm32_unknown_unknown] needs-llvm-components: webassembly
-//@ revisions: wasm32v1_none
-//@ [wasm32v1_none] compile-flags: --target wasm32v1-none
-//@ [wasm32v1_none] needs-llvm-components: webassembly
-//@ revisions: wasm32_wasip1
-//@ [wasm32_wasip1] compile-flags: --target wasm32-wasip1
-//@ [wasm32_wasip1] needs-llvm-components: webassembly
-//@ revisions: wasm32_wasip1_threads
-//@ [wasm32_wasip1_threads] compile-flags: --target wasm32-wasip1-threads
-//@ [wasm32_wasip1_threads] needs-llvm-components: webassembly
-//@ revisions: wasm32_wasip2
-//@ [wasm32_wasip2] compile-flags: --target wasm32-wasip2
-//@ [wasm32_wasip2] needs-llvm-components: webassembly
-//@ revisions: wasm32_wali_linux_musl
-//@ [wasm32_wali_linux_musl] compile-flags: --target wasm32-wali-linux-musl
-//@ [wasm32_wali_linux_musl] needs-llvm-components: webassembly
-//@ revisions: wasm64_unknown_unknown
-//@ [wasm64_unknown_unknown] compile-flags: --target wasm64-unknown-unknown
-//@ [wasm64_unknown_unknown] needs-llvm-components: webassembly
-//@ revisions: x86_64_fortanix_unknown_sgx
-//@ [x86_64_fortanix_unknown_sgx] compile-flags: --target x86_64-fortanix-unknown-sgx
-//@ [x86_64_fortanix_unknown_sgx] needs-llvm-components: x86
-//@ revisions: x86_64_linux_android
-//@ [x86_64_linux_android] compile-flags: --target x86_64-linux-android
-//@ [x86_64_linux_android] needs-llvm-components: x86
-//@ revisions: x86_64_lynx_lynxos178
-//@ [x86_64_lynx_lynxos178] compile-flags: --target x86_64-lynx-lynxos178
-//@ [x86_64_lynx_lynxos178] needs-llvm-components: x86
-//@ revisions: x86_64_pc_nto_qnx710
-//@ [x86_64_pc_nto_qnx710] compile-flags: --target x86_64-pc-nto-qnx710
-//@ [x86_64_pc_nto_qnx710] needs-llvm-components: x86
-//@ revisions: x86_64_pc_nto_qnx710_iosock
-//@ [x86_64_pc_nto_qnx710_iosock] compile-flags: --target x86_64-pc-nto-qnx710_iosock
-//@ [x86_64_pc_nto_qnx710_iosock] needs-llvm-components: x86
-//@ revisions: x86_64_pc_nto_qnx800
-//@ [x86_64_pc_nto_qnx800] compile-flags: --target x86_64-pc-nto-qnx800
-//@ [x86_64_pc_nto_qnx800] needs-llvm-components: x86
-//@ revisions: x86_64_pc_solaris
-//@ [x86_64_pc_solaris] compile-flags: --target x86_64-pc-solaris
-//@ [x86_64_pc_solaris] needs-llvm-components: x86
-//@ revisions: x86_64_unikraft_linux_musl
-//@ [x86_64_unikraft_linux_musl] compile-flags: --target x86_64-unikraft-linux-musl
-//@ [x86_64_unikraft_linux_musl] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_dragonfly
-//@ [x86_64_unknown_dragonfly] compile-flags: --target x86_64-unknown-dragonfly
-//@ [x86_64_unknown_dragonfly] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_freebsd
-//@ [x86_64_unknown_freebsd] compile-flags: --target x86_64-unknown-freebsd
-//@ [x86_64_unknown_freebsd] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_fuchsia
-//@ [x86_64_unknown_fuchsia] compile-flags: --target x86_64-unknown-fuchsia
-//@ [x86_64_unknown_fuchsia] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_haiku
-//@ [x86_64_unknown_haiku] compile-flags: --target x86_64-unknown-haiku
-//@ [x86_64_unknown_haiku] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_hurd_gnu
-//@ [x86_64_unknown_hurd_gnu] compile-flags: --target x86_64-unknown-hurd-gnu
-//@ [x86_64_unknown_hurd_gnu] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_hermit
-//@ [x86_64_unknown_hermit] compile-flags: --target x86_64-unknown-hermit
-//@ [x86_64_unknown_hermit] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_illumos
-//@ [x86_64_unknown_illumos] compile-flags: --target x86_64-unknown-illumos
-//@ [x86_64_unknown_illumos] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_l4re_uclibc
-//@ [x86_64_unknown_l4re_uclibc] compile-flags: --target x86_64-unknown-l4re-uclibc
-//@ [x86_64_unknown_l4re_uclibc] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_linux_gnu
-//@ [x86_64_unknown_linux_gnu] compile-flags: --target x86_64-unknown-linux-gnu
-//@ [x86_64_unknown_linux_gnu] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_linux_gnux32
-//@ [x86_64_unknown_linux_gnux32] compile-flags: --target x86_64-unknown-linux-gnux32
-//@ [x86_64_unknown_linux_gnux32] 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
-//@ revisions: x86_64_unknown_linux_ohos
-//@ [x86_64_unknown_linux_ohos] compile-flags: --target x86_64-unknown-linux-ohos
-//@ [x86_64_unknown_linux_ohos] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_linux_none
-//@ [x86_64_unknown_linux_none] compile-flags: --target x86_64-unknown-linux-none
-//@ [x86_64_unknown_linux_none] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_netbsd
-//@ [x86_64_unknown_netbsd] compile-flags: --target x86_64-unknown-netbsd
-//@ [x86_64_unknown_netbsd] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_none
-//@ [x86_64_unknown_none] compile-flags: --target x86_64-unknown-none
-//@ [x86_64_unknown_none] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_openbsd
-//@ [x86_64_unknown_openbsd] compile-flags: --target x86_64-unknown-openbsd
-//@ [x86_64_unknown_openbsd] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_redox
-//@ [x86_64_unknown_redox] compile-flags: --target x86_64-unknown-redox
-//@ [x86_64_unknown_redox] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_trusty
-//@ [x86_64_unknown_trusty] compile-flags: --target x86_64-unknown-trusty
-//@ [x86_64_unknown_trusty] needs-llvm-components: x86
-//@ revisions: x86_64_wrs_vxworks
-//@ [x86_64_wrs_vxworks] compile-flags: --target x86_64-wrs-vxworks
-//@ [x86_64_wrs_vxworks] needs-llvm-components: x86
-//@ revisions: thumbv6m_nuttx_eabi
-//@ [thumbv6m_nuttx_eabi] compile-flags: --target thumbv6m-nuttx-eabi
-//@ [thumbv6m_nuttx_eabi] needs-llvm-components: arm
-//@ revisions: thumbv7a_nuttx_eabi
-//@ [thumbv7a_nuttx_eabi] compile-flags: --target thumbv7a-nuttx-eabi
-//@ [thumbv7a_nuttx_eabi] needs-llvm-components: arm
-//@ revisions: thumbv7a_nuttx_eabihf
-//@ [thumbv7a_nuttx_eabihf] compile-flags: --target thumbv7a-nuttx-eabihf
-//@ [thumbv7a_nuttx_eabihf] needs-llvm-components: arm
-//@ revisions: thumbv7m_nuttx_eabi
-//@ [thumbv7m_nuttx_eabi] compile-flags: --target thumbv7m-nuttx-eabi
-//@ [thumbv7m_nuttx_eabi] needs-llvm-components: arm
-//@ revisions: thumbv7em_nuttx_eabi
-//@ [thumbv7em_nuttx_eabi] compile-flags: --target thumbv7em-nuttx-eabi
-//@ [thumbv7em_nuttx_eabi] needs-llvm-components: arm
-//@ revisions: thumbv7em_nuttx_eabihf
-//@ [thumbv7em_nuttx_eabihf] compile-flags: --target thumbv7em-nuttx-eabihf
-//@ [thumbv7em_nuttx_eabihf] needs-llvm-components: arm
-//@ revisions: thumbv8m_base_nuttx_eabi
-//@ [thumbv8m_base_nuttx_eabi] compile-flags: --target thumbv8m.base-nuttx-eabi
-//@ [thumbv8m_base_nuttx_eabi] needs-llvm-components: arm
-//@ revisions: thumbv8m_main_nuttx_eabi
-//@ [thumbv8m_main_nuttx_eabi] compile-flags: --target thumbv8m.main-nuttx-eabi
-//@ [thumbv8m_main_nuttx_eabi] needs-llvm-components: arm
-//@ revisions: thumbv8m_main_nuttx_eabihf
-//@ [thumbv8m_main_nuttx_eabihf] compile-flags: --target thumbv8m.main-nuttx-eabihf
-//@ [thumbv8m_main_nuttx_eabihf] needs-llvm-components: arm
-//@ revisions: riscv32imc_unknown_nuttx_elf
-//@ [riscv32imc_unknown_nuttx_elf] compile-flags: --target riscv32imc-unknown-nuttx-elf
-//@ [riscv32imc_unknown_nuttx_elf] needs-llvm-components: riscv
-//@ revisions: riscv32imac_unknown_nuttx_elf
-//@ [riscv32imac_unknown_nuttx_elf] compile-flags: --target riscv32imac-unknown-nuttx-elf
-//@ [riscv32imac_unknown_nuttx_elf] needs-llvm-components: riscv
-//@ revisions: riscv32imafc_unknown_nuttx_elf
-//@ [riscv32imafc_unknown_nuttx_elf] compile-flags: --target riscv32imafc-unknown-nuttx-elf
-//@ [riscv32imafc_unknown_nuttx_elf] needs-llvm-components: riscv
-//@ revisions: riscv64imac_unknown_nuttx_elf
-//@ [riscv64imac_unknown_nuttx_elf] compile-flags: --target riscv64imac-unknown-nuttx-elf
-//@ [riscv64imac_unknown_nuttx_elf] needs-llvm-components: riscv
-//@ revisions: riscv64gc_unknown_nuttx_elf
-//@ [riscv64gc_unknown_nuttx_elf] compile-flags: --target riscv64gc-unknown-nuttx-elf
-//@ [riscv64gc_unknown_nuttx_elf] needs-llvm-components: riscv
-// FIXME: disabled since it requires a custom LLVM until the upstream LLVM adds support for the target (https://github.com/espressif/llvm-project/issues/4)
-/*
-    revisions: xtensa_esp32_none_elf
-    [xtensa_esp32_none_elf] compile-flags: --target xtensa-esp32-none-elf
-    [xtensa_esp32_none_elf] needs-llvm-components: xtensa
-    revisions: xtensa_esp32_espidf
-    [xtensa_esp32_espidf] compile-flags: --target xtensa-esp32s2-espidf
-    [xtensa_esp32_espidf] needs-llvm-components: xtensa
-    revisions: xtensa_esp32s2_none_elf
-    [xtensa_esp32s2_none_elf] compile-flags: --target xtensa-esp32s2-none-elf
-    [xtensa_esp32s2_none_elf] needs-llvm-components: xtensa
-    revisions: xtensa_esp32s2_espidf
-    [xtensa_esp32s2_espidf] compile-flags: --target xtensa-esp32s2-espidf
-    [xtensa_esp32s2_espidf] needs-llvm-components: xtensa
-    revisions: xtensa_esp32s3_none_elf
-    [xtensa_esp32s3_none_elf] compile-flags: --target xtensa-esp32s3-none-elf
-    [xtensa_esp32s3_none_elf] needs-llvm-components: xtensa
-    revisions: xtensa_esp32s3_espidf
-    [xtensa_esp32s3_espidf] compile-flags: --target xtensa-esp32s3-espidf
-    [xtensa_esp32s3_espidf] needs-llvm-components: xtensa
-*/
-// Sanity-check that each target can produce assembly code.
-
-#![feature(no_core, lang_items)]
-#![no_std]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-// Force linkage to ensure code is actually generated
-#[no_mangle]
-pub fn test() -> u8 {
-    42
-}
-
-// CHECK: .text
diff --git a/tests/assembly/targets/targets-macho.rs b/tests/assembly/targets/targets-macho.rs
deleted file mode 100644
index 92bde1c6971..00000000000
--- a/tests/assembly/targets/targets-macho.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-// ignore-tidy-linelength
-//@ revisions: aarch64_apple_darwin
-//@ [aarch64_apple_darwin] compile-flags: --target aarch64-apple-darwin
-//@ [aarch64_apple_darwin] needs-llvm-components: aarch64
-//@ revisions: aarch64_apple_ios
-//@ [aarch64_apple_ios] compile-flags: --target aarch64-apple-ios
-//@ [aarch64_apple_ios] needs-llvm-components: aarch64
-//@ revisions: aarch64_apple_ios_macabi
-//@ [aarch64_apple_ios_macabi] compile-flags: --target aarch64-apple-ios-macabi
-//@ [aarch64_apple_ios_macabi] needs-llvm-components: aarch64
-//@ revisions: aarch64_apple_ios_sim
-//@ [aarch64_apple_ios_sim] compile-flags: --target aarch64-apple-ios-sim
-//@ [aarch64_apple_ios_sim] needs-llvm-components: aarch64
-//@ revisions: aarch64_apple_tvos
-//@ [aarch64_apple_tvos] compile-flags: --target aarch64-apple-tvos
-//@ [aarch64_apple_tvos] needs-llvm-components: aarch64
-//@ revisions: aarch64_apple_tvos_sim
-//@ [aarch64_apple_tvos_sim] compile-flags: --target aarch64-apple-tvos-sim
-//@ [aarch64_apple_tvos_sim] needs-llvm-components: aarch64
-//@ revisions: arm64e_apple_tvos
-//@ [arm64e_apple_tvos] compile-flags: --target arm64e-apple-tvos
-//@ [arm64e_apple_tvos] needs-llvm-components: aarch64
-//@ revisions: aarch64_apple_watchos
-//@ [aarch64_apple_watchos] compile-flags: --target aarch64-apple-watchos
-//@ [aarch64_apple_watchos] needs-llvm-components: aarch64
-//@ revisions: aarch64_apple_watchos_sim
-//@ [aarch64_apple_watchos_sim] compile-flags: --target aarch64-apple-watchos-sim
-//@ [aarch64_apple_watchos_sim] needs-llvm-components: aarch64
-//@ revisions: arm64_32_apple_watchos
-//@ [arm64_32_apple_watchos] compile-flags: --target arm64_32-apple-watchos
-//@ [arm64_32_apple_watchos] needs-llvm-components: aarch64
-//@ revisions: aarch64_apple_visionos
-//@ [aarch64_apple_visionos] compile-flags: --target aarch64-apple-visionos
-//@ [aarch64_apple_visionos] needs-llvm-components: aarch64
-//@ revisions: aarch64_apple_visionos_sim
-//@ [aarch64_apple_visionos_sim] compile-flags: --target aarch64-apple-visionos-sim
-//@ [aarch64_apple_visionos_sim] needs-llvm-components: aarch64
-//@ revisions: arm64e_apple_darwin
-//@ [arm64e_apple_darwin] compile-flags: --target arm64e-apple-darwin
-//@ [arm64e_apple_darwin] needs-llvm-components: aarch64
-//@ revisions: arm64e_apple_ios
-//@ [arm64e_apple_ios] compile-flags: --target arm64e-apple-ios
-//@ [arm64e_apple_ios] needs-llvm-components: aarch64
-//@ revisions: armv7k_apple_watchos
-//@ [armv7k_apple_watchos] compile-flags: --target armv7k-apple-watchos
-//@ [armv7k_apple_watchos] needs-llvm-components: arm
-//@ revisions: armv7s_apple_ios
-//@ [armv7s_apple_ios] compile-flags: --target armv7s-apple-ios
-//@ [armv7s_apple_ios] needs-llvm-components: arm
-//@ revisions: i386_apple_ios
-//@ [i386_apple_ios] compile-flags: --target i386-apple-ios
-//@ [i386_apple_ios] needs-llvm-components: x86
-//@ revisions: i686_apple_darwin
-//@ [i686_apple_darwin] compile-flags: --target i686-apple-darwin
-//@ [i686_apple_darwin] needs-llvm-components: x86
-//@ revisions: x86_64_apple_darwin
-//@ [x86_64_apple_darwin] compile-flags: --target x86_64-apple-darwin
-//@ [x86_64_apple_darwin] needs-llvm-components: x86
-//@ revisions: x86_64_apple_ios
-//@ [x86_64_apple_ios] compile-flags: --target x86_64-apple-ios
-//@ [x86_64_apple_ios] needs-llvm-components: x86
-//@ revisions: x86_64_apple_ios_macabi
-//@ [x86_64_apple_ios_macabi] compile-flags: --target x86_64-apple-ios-macabi
-//@ [x86_64_apple_ios_macabi] needs-llvm-components: x86
-//@ revisions: x86_64_apple_tvos
-//@ [x86_64_apple_tvos] compile-flags: --target x86_64-apple-tvos
-//@ [x86_64_apple_tvos] needs-llvm-components: x86
-//@ revisions: x86_64_apple_watchos_sim
-//@ [x86_64_apple_watchos_sim] compile-flags: --target x86_64-apple-watchos-sim
-//@ [x86_64_apple_watchos_sim] needs-llvm-components: x86
-//@ revisions: x86_64h_apple_darwin
-//@ [x86_64h_apple_darwin] compile-flags: --target x86_64h-apple-darwin
-//@ [x86_64h_apple_darwin] needs-llvm-components: x86
-
-// Sanity-check that each target can produce assembly code.
-
-#![feature(no_core, lang_items)]
-#![no_std]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-// Force linkage to ensure code is actually generated
-#[no_mangle]
-pub fn test() -> u8 {
-    42
-}
-
-// CHECK: .section __TEXT,__text
diff --git a/tests/assembly/targets/targets-nvptx.rs b/tests/assembly/targets/targets-nvptx.rs
deleted file mode 100644
index 49c12aebaaa..00000000000
--- a/tests/assembly/targets/targets-nvptx.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-// ignore-tidy-linelength
-//@ revisions: nvptx64_nvidia_cuda
-//@ [nvptx64_nvidia_cuda] compile-flags: --target nvptx64-nvidia-cuda
-//@ [nvptx64_nvidia_cuda] needs-llvm-components: nvptx
-
-// Sanity-check that each target can produce assembly code.
-
-#![feature(no_core, lang_items)]
-#![no_std]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn test() -> u8 {
-    42
-}
-
-// CHECK: .version
diff --git a/tests/assembly/targets/targets-pe.rs b/tests/assembly/targets/targets-pe.rs
deleted file mode 100644
index de29b9af502..00000000000
--- a/tests/assembly/targets/targets-pe.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-// ignore-tidy-linelength
-//@ revisions: aarch64_pc_windows_msvc
-//@ [aarch64_pc_windows_msvc] compile-flags: --target aarch64-pc-windows-msvc
-//@ [aarch64_pc_windows_msvc] needs-llvm-components: aarch64
-//@ revisions: aarch64_pc_windows_gnullvm
-//@ [aarch64_pc_windows_gnullvm] compile-flags: --target aarch64-pc-windows-gnullvm
-//@ [aarch64_pc_windows_gnullvm] needs-llvm-components: aarch64
-//@ revisions: aarch64_unknown_uefi
-//@ [aarch64_unknown_uefi] compile-flags: --target aarch64-unknown-uefi
-//@ [aarch64_unknown_uefi] needs-llvm-components: aarch64
-//@ revisions: aarch64_uwp_windows_msvc
-//@ [aarch64_uwp_windows_msvc] compile-flags: --target aarch64-uwp-windows-msvc
-//@ [aarch64_uwp_windows_msvc] needs-llvm-components: aarch64
-//@ revisions: arm64ec_pc_windows_msvc
-//@ [arm64ec_pc_windows_msvc] compile-flags: --target arm64ec-pc-windows-msvc
-//@ [arm64ec_pc_windows_msvc] needs-llvm-components: aarch64
-//@ revisions: avr_none
-//@ [avr_none] compile-flags: --target avr-none -C target-cpu=atmega328p
-//@ [avr_none] needs-llvm-components: avr
-//@ revisions: bpfeb_unknown_none
-//@ [bpfeb_unknown_none] compile-flags: --target bpfeb-unknown-none
-//@ [bpfeb_unknown_none] needs-llvm-components: bpf
-//@ revisions: bpfel_unknown_none
-//@ [bpfel_unknown_none] compile-flags: --target bpfel-unknown-none
-//@ [bpfel_unknown_none] needs-llvm-components: bpf
-//@ revisions: i686_pc_windows_gnu
-//@ [i686_pc_windows_gnu] compile-flags: --target i686-pc-windows-gnu
-//@ [i686_pc_windows_gnu] needs-llvm-components: x86
-//@ revisions: i686_pc_windows_msvc
-//@ [i686_pc_windows_msvc] compile-flags: --target i686-pc-windows-msvc
-//@ [i686_pc_windows_msvc] needs-llvm-components: x86
-//@ revisions: i686_pc_windows_gnullvm
-//@ [i686_pc_windows_gnullvm] compile-flags: --target i686-pc-windows-gnullvm
-//@ [i686_pc_windows_gnullvm] needs-llvm-components: x86
-//@ revisions: i686_uwp_windows_gnu
-//@ [i686_uwp_windows_gnu] compile-flags: --target i686-uwp-windows-gnu
-//@ [i686_uwp_windows_gnu] needs-llvm-components: x86
-//@ revisions: i686_win7_windows_gnu
-//@ [i686_win7_windows_gnu] compile-flags: --target i686-win7-windows-gnu
-//@ [i686_win7_windows_gnu] needs-llvm-components: x86
-//@ revisions: i686_unknown_uefi
-//@ [i686_unknown_uefi] compile-flags: --target i686-unknown-uefi
-//@ [i686_unknown_uefi] needs-llvm-components: x86
-//@ revisions: i686_uwp_windows_msvc
-//@ [i686_uwp_windows_msvc] compile-flags: --target i686-uwp-windows-msvc
-//@ [i686_uwp_windows_msvc] needs-llvm-components: x86
-//@ revisions: i686_win7_windows_msvc
-//@ [i686_win7_windows_msvc] compile-flags: --target i686-win7-windows-msvc
-//@ [i686_win7_windows_msvc] needs-llvm-components: x86
-//@ revisions: powerpc64_ibm_aix
-//@ [powerpc64_ibm_aix] compile-flags: --target powerpc64-ibm-aix
-//@ [powerpc64_ibm_aix] needs-llvm-components: powerpc
-//@ revisions: thumbv7a_uwp_windows_msvc
-//@ [thumbv7a_uwp_windows_msvc] compile-flags: --target thumbv7a-uwp-windows-msvc
-//@ [thumbv7a_uwp_windows_msvc] needs-llvm-components: arm
-//@ revisions: thumbv7a_pc_windows_msvc
-//@ [thumbv7a_pc_windows_msvc] compile-flags: --target thumbv7a-pc-windows-msvc
-//@ [thumbv7a_pc_windows_msvc] needs-llvm-components: arm
-//@ revisions: x86_64_pc_windows_gnu
-//@ [x86_64_pc_windows_gnu] compile-flags: --target x86_64-pc-windows-gnu
-//@ [x86_64_pc_windows_gnu] needs-llvm-components: x86
-//@ revisions: x86_64_pc_windows_gnullvm
-//@ [x86_64_pc_windows_gnullvm] compile-flags: --target x86_64-pc-windows-gnullvm
-//@ [x86_64_pc_windows_gnullvm] needs-llvm-components: x86
-//@ revisions: x86_64_pc_windows_msvc
-//@ [x86_64_pc_windows_msvc] compile-flags: --target x86_64-pc-windows-msvc
-//@ [x86_64_pc_windows_msvc] needs-llvm-components: x86
-//@ revisions: x86_64_unknown_uefi
-//@ [x86_64_unknown_uefi] compile-flags: --target x86_64-unknown-uefi
-//@ [x86_64_unknown_uefi] needs-llvm-components: x86
-//@ revisions: x86_64_uwp_windows_gnu
-//@ [x86_64_uwp_windows_gnu] compile-flags: --target x86_64-uwp-windows-gnu
-//@ [x86_64_uwp_windows_gnu] needs-llvm-components: x86
-//@ revisions: x86_64_win7_windows_gnu
-//@ [x86_64_win7_windows_gnu] compile-flags: --target x86_64-win7-windows-gnu
-//@ [x86_64_win7_windows_gnu] needs-llvm-components: x86
-//@ revisions: x86_64_uwp_windows_msvc
-//@ [x86_64_uwp_windows_msvc] compile-flags: --target x86_64-uwp-windows-msvc
-//@ [x86_64_uwp_windows_msvc] needs-llvm-components: x86
-//@ revisions: x86_64_win7_windows_msvc
-//@ [x86_64_win7_windows_msvc] compile-flags: --target x86_64-win7-windows-msvc
-//@ [x86_64_win7_windows_msvc] needs-llvm-components: x86
-//@ revisions: x86_64_pc_cygwin
-//@ [x86_64_pc_cygwin] compile-flags: --target x86_64-pc-cygwin
-//@ [x86_64_pc_cygwin] needs-llvm-components: x86
-
-// Sanity-check that each target can produce assembly code.
-
-#![feature(no_core, lang_items)]
-#![no_std]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn test() -> u8 {
-    42
-}
-
-// CHECK: .file
diff --git a/tests/assembly/wasm_exceptions.rs b/tests/assembly/wasm_exceptions.rs
deleted file mode 100644
index 704e8026f3f..00000000000
--- a/tests/assembly/wasm_exceptions.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-//@ only-wasm32
-//@ assembly-output: emit-asm
-//@ compile-flags: -C target-feature=+exception-handling
-//@ compile-flags: -C panic=unwind
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-extern "C-unwind" {
-    fn may_panic();
-}
-
-extern "C" {
-    fn log_number(number: usize);
-}
-
-struct LogOnDrop;
-
-impl Drop for LogOnDrop {
-    fn drop(&mut self) {
-        unsafe {
-            log_number(0);
-        }
-    }
-}
-
-// CHECK-LABEL: test_cleanup:
-#[no_mangle]
-pub fn test_cleanup() {
-    let _log_on_drop = LogOnDrop;
-    unsafe {
-        may_panic();
-    }
-
-    // CHECK-NOT: call
-    // CHECK: try
-    // CHECK: call may_panic
-    // CHECK: catch_all
-    // CHECK: rethrow
-    // CHECK: end_try
-}
-
-// CHECK-LABEL: test_rtry:
-#[no_mangle]
-pub fn test_rtry() {
-    unsafe {
-        core::intrinsics::catch_unwind(
-            |_| {
-                may_panic();
-            },
-            core::ptr::null_mut(),
-            |data, exception| {
-                log_number(data as usize);
-                log_number(exception as usize);
-            },
-        );
-    }
-
-    // CHECK-NOT: call
-    // CHECK: try
-    // CHECK: call may_panic
-    // CHECK: catch
-    // CHECK: call log_number
-    // CHECK: call log_number
-    // CHECK-NOT: rethrow
-    // CHECK: end_try
-}
diff --git a/tests/assembly/x86-return-float.rs b/tests/assembly/x86-return-float.rs
deleted file mode 100644
index 165c11d2280..00000000000
--- a/tests/assembly/x86-return-float.rs
+++ /dev/null
@@ -1,343 +0,0 @@
-//@ assembly-output: emit-asm
-// FIXME(#114479): LLVM miscompiles loading and storing `f32` and `f64` when SSE is disabled.
-// There's no compiletest directive to ignore a test on i586 only, so just always explicitly enable
-// SSE2.
-// Use the same target CPU as `i686` so that LLVM orders the instructions in the same order.
-//@ compile-flags: -Ctarget-feature=+sse2 -Ctarget-cpu=pentium4
-// Force frame pointers to make ASM more consistent between targets
-//@ compile-flags: -C force-frame-pointers
-// At opt-level=3, LLVM can merge two movss into one movsd, and we aren't testing for that.
-//@ compile-flags: -Copt-level=2
-//@ filecheck-flags: --implicit-check-not fld --implicit-check-not fst
-//@ revisions: linux win
-//@ add-core-stubs
-//@[linux] needs-llvm-components: x86
-//@[win] needs-llvm-components: x86
-//@[linux] compile-flags: --target i686-unknown-linux-gnu
-//@[win] compile-flags: --target i686-pc-windows-msvc
-
-#![crate_type = "lib"]
-#![feature(f16, f128)]
-#![feature(no_core)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// Tests that returning `f32` and `f64` with the "Rust" ABI on 32-bit x86 doesn't use the x87
-// floating point stack, as loading and storing `f32`s and `f64`s to and from the x87 stack quietens
-// signalling NaNs.
-
-// Returning individual floats
-
-// CHECK-LABEL: return_f32:
-#[no_mangle]
-pub fn return_f32(x: f32) -> f32 {
-    // CHECK: movss {{.*}}(%ebp), %xmm0
-    // CHECK-NEXT: popl %ebp
-    // linux-NEXT: .cfi_def_cfa
-    // CHECK-NEXT: retl
-    x
-}
-
-// CHECK-LABEL: return_f64:
-#[no_mangle]
-pub fn return_f64(x: f64) -> f64 {
-    // CHECK: movsd {{.*}}(%ebp), %xmm0
-    // CHECK-NEXT: popl %ebp
-    // linux-NEXT: .cfi_def_cfa
-    // CHECK-NEXT: retl
-    x
-}
-
-// Returning scalar pairs containing floats
-
-// CHECK-LABEL: return_f32_f32:
-#[no_mangle]
-pub fn return_f32_f32(x: (f32, f32)) -> (f32, f32) {
-    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
-    // CHECK-NEXT: movss [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
-    // CHECK-NEXT: movss [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
-    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movss %[[VAL2]], 4(%[[PTR]])
-    // CHECK: retl
-    x
-}
-
-// CHECK-LABEL: return_f64_f64:
-#[no_mangle]
-pub fn return_f64_f64(x: (f64, f64)) -> (f64, f64) {
-    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
-    // CHECK-NEXT: movsd [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
-    // CHECK-NEXT: movsd [[#%d,OFFSET+12]](%ebp), %[[VAL2:.*]]
-    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movsd %[[VAL2]], 8(%[[PTR]])
-    // CHECK: retl
-    x
-}
-
-// CHECK-LABEL: return_f32_f64:
-#[no_mangle]
-pub fn return_f32_f64(x: (f32, f64)) -> (f32, f64) {
-    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
-    // CHECK-NEXT: movss [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
-    // CHECK-NEXT: movsd [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
-    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movsd %[[VAL2]], {{4|8}}(%[[PTR]])
-    // CHECK: retl
-    x
-}
-
-// CHECK-LABEL: return_f64_f32:
-#[no_mangle]
-pub fn return_f64_f32(x: (f64, f32)) -> (f64, f32) {
-    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
-    // CHECK-NEXT: movsd [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
-    // CHECK-NEXT: movss [[#%d,OFFSET+12]](%ebp), %[[VAL2:.*]]
-    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movss %[[VAL2]], 8(%[[PTR]])
-    // CHECK: retl
-    x
-}
-
-// CHECK-LABEL: return_f32_other:
-#[no_mangle]
-pub fn return_f32_other(x: (f32, usize)) -> (f32, usize) {
-    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
-    // CHECK-NEXT: movss [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
-    // CHECK-NEXT: movl [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
-    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movl %[[VAL2]], 4(%[[PTR]])
-    // CHECK: retl
-    x
-}
-
-// CHECK-LABEL: return_f64_other:
-#[no_mangle]
-pub fn return_f64_other(x: (f64, usize)) -> (f64, usize) {
-    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
-    // CHECK-NEXT: movsd [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
-    // CHECK-NEXT: movl [[#%d,OFFSET+12]](%ebp), %[[VAL2:.*]]
-    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movl %[[VAL2]], 8(%[[PTR]])
-    // CHECK: retl
-    x
-}
-
-// CHECK-LABEL: return_other_f32:
-#[no_mangle]
-pub fn return_other_f32(x: (usize, f32)) -> (usize, f32) {
-    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
-    // CHECK-NEXT: movl [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
-    // CHECK-NEXT: movss [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
-    // CHECK-NEXT: movl %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movss %[[VAL2]], 4(%[[PTR]])
-    // CHECK: retl
-    x
-}
-
-// CHECK-LABEL: return_other_f64:
-#[no_mangle]
-pub fn return_other_f64(x: (usize, f64)) -> (usize, f64) {
-    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[PTR:.*]]
-    // CHECK-NEXT: movl [[#%d,OFFSET+4]](%ebp), %[[VAL1:.*]]
-    // CHECK-NEXT: movsd [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
-    // CHECK-NEXT: movl %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movsd %[[VAL2]], {{4|8}}(%[[PTR]])
-    // CHECK: retl
-    x
-}
-
-// Calling functions returning floats
-
-// CHECK-LABEL: call_f32:
-#[no_mangle]
-pub unsafe fn call_f32(x: &mut f32) {
-    extern "Rust" {
-        fn get_f32() -> f32;
-    }
-    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
-    // CHECK: calll {{()|_}}get_f32
-    // CHECK-NEXT: movss %xmm0, (%[[PTR]])
-    *x = get_f32();
-}
-
-// CHECK-LABEL: call_f64:
-#[no_mangle]
-pub unsafe fn call_f64(x: &mut f64) {
-    extern "Rust" {
-        fn get_f64() -> f64;
-    }
-    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
-    // CHECK: calll {{()|_}}get_f64
-    // CHECK-NEXT: movlps %xmm0, (%[[PTR]])
-    *x = get_f64();
-}
-
-// Calling functions returning scalar pairs containing floats
-
-// CHECK-LABEL: call_f32_f32:
-#[no_mangle]
-pub unsafe fn call_f32_f32(x: &mut (f32, f32)) {
-    extern "Rust" {
-        fn get_f32_f32() -> (f32, f32);
-    }
-    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
-    // CHECK: calll {{()|_}}get_f32_f32
-    // CHECK: movss [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
-    // CHECK-NEXT: movss [[#%d,OFFSET+4]](%ebp), %[[VAL2:.*]]
-    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movss %[[VAL2]], 4(%[[PTR]])
-    *x = get_f32_f32();
-}
-
-// CHECK-LABEL: call_f64_f64:
-#[no_mangle]
-pub unsafe fn call_f64_f64(x: &mut (f64, f64)) {
-    extern "Rust" {
-        fn get_f64_f64() -> (f64, f64);
-    }
-    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
-    // CHECK: calll {{()|_}}get_f64_f64
-    // linux: movsd [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
-    // linux-NEXT: movsd [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
-    // win: movsd (%esp), %[[VAL1:.*]]
-    // win-NEXT: movsd 8(%esp), %[[VAL2:.*]]
-    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movsd %[[VAL2]], 8(%[[PTR]])
-    *x = get_f64_f64();
-}
-
-// CHECK-LABEL: call_f32_f64:
-#[no_mangle]
-pub unsafe fn call_f32_f64(x: &mut (f32, f64)) {
-    extern "Rust" {
-        fn get_f32_f64() -> (f32, f64);
-    }
-    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
-    // CHECK: calll {{()|_}}get_f32_f64
-    // linux: movss [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
-    // linux-NEXT: movsd [[#%d,OFFSET+4]](%ebp), %[[VAL2:.*]]
-    // win: movss (%esp), %[[VAL1:.*]]
-    // win-NEXT: movsd 8(%esp), %[[VAL2:.*]]
-    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
-    // linux-NEXT: movsd %[[VAL2]], 4(%[[PTR]])
-    // win-NEXT: movsd %[[VAL2]], 8(%[[PTR]])
-    *x = get_f32_f64();
-}
-
-// CHECK-LABEL: call_f64_f32:
-#[no_mangle]
-pub unsafe fn call_f64_f32(x: &mut (f64, f32)) {
-    extern "Rust" {
-        fn get_f64_f32() -> (f64, f32);
-    }
-    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
-    // CHECK: calll {{()|_}}get_f64_f32
-    // linux: movsd [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
-    // linux-NEXT: movss [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
-    // win: movsd (%esp), %[[VAL1:.*]]
-    // win-NEXT: movss 8(%esp), %[[VAL2:.*]]
-    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movss %[[VAL2]], 8(%[[PTR]])
-    *x = get_f64_f32();
-}
-
-// CHECK-LABEL: call_f32_other:
-#[no_mangle]
-pub unsafe fn call_f32_other(x: &mut (f32, usize)) {
-    extern "Rust" {
-        fn get_f32_other() -> (f32, usize);
-    }
-    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
-    // CHECK: calll {{()|_}}get_f32_other
-    // CHECK: movss [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
-    // CHECK-NEXT: movl [[#%d,OFFSET+4]](%ebp), %[[VAL2:.*]]
-    // CHECK-NEXT: movss %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movl %[[VAL2]], 4(%[[PTR]])
-    *x = get_f32_other();
-}
-
-// CHECK-LABEL: call_f64_other:
-#[no_mangle]
-pub unsafe fn call_f64_other(x: &mut (f64, usize)) {
-    extern "Rust" {
-        fn get_f64_other() -> (f64, usize);
-    }
-    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
-    // CHECK: calll {{()|_}}get_f64_other
-    // linux: movsd [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
-    // linux-NEXT: movl [[#%d,OFFSET+8]](%ebp), %[[VAL2:.*]]
-    // win: movsd (%esp), %[[VAL1:.*]]
-    // win-NEXT: movl 8(%esp), %[[VAL2:.*]]
-    // CHECK-NEXT: movsd %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movl %[[VAL2]], 8(%[[PTR]])
-    *x = get_f64_other();
-}
-
-// CHECK-LABEL: call_other_f32:
-#[no_mangle]
-pub unsafe fn call_other_f32(x: &mut (usize, f32)) {
-    extern "Rust" {
-        fn get_other_f32() -> (usize, f32);
-    }
-    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
-    // CHECK: calll {{()|_}}get_other_f32
-    // CHECK: movl [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
-    // CHECK-NEXT: movss [[#%d,OFFSET+4]](%ebp), %[[VAL2:.*]]
-    // CHECK-NEXT: movl %[[VAL1]], (%[[PTR]])
-    // CHECK-NEXT: movss %[[VAL2]], 4(%[[PTR]])
-    *x = get_other_f32();
-}
-
-// CHECK-LABEL: call_other_f64:
-#[no_mangle]
-pub unsafe fn call_other_f64(x: &mut (usize, f64)) {
-    extern "Rust" {
-        fn get_other_f64() -> (usize, f64);
-    }
-    // CHECK: movl {{.*}}(%ebp), %[[PTR:.*]]
-    // CHECK: calll {{()|_}}get_other_f64
-    // linux: movl [[#%d,OFFSET:]](%ebp), %[[VAL1:.*]]
-    // linux-NEXT: movsd [[#%d,OFFSET+4]](%ebp), %[[VAL2:.*]]
-    // win: movl (%esp), %[[VAL1:.*]]
-    // win-NEXT: movsd 8(%esp), %[[VAL2:.*]]
-    // CHECK-NEXT: movl %[[VAL1]], (%[[PTR]])
-    // linux-NEXT: movsd %[[VAL2]], 4(%[[PTR]])
-    // win-NEXT: movsd %[[VAL2]], 8(%[[PTR]])
-    *x = get_other_f64();
-}
-
-// The "C" ABI for `f16` and `f128` on x86 has never used the x87 floating point stack. Do some
-// basic checks to ensure this remains the case for the "Rust" ABI.
-
-// CHECK-LABEL: return_f16:
-#[no_mangle]
-pub fn return_f16(x: f16) -> f16 {
-    // CHECK: pushl %ebp
-    // linux-NEXT: .cfi_def_cfa_offset
-    // linux-NEXT: .cfi_offset
-    // CHECK-NEXT: movl %esp, %ebp
-    // linux-NEXT: .cfi_def_cfa_register
-    // CHECK-NEXT: pinsrw $0, 8(%ebp), %xmm0
-    // CHECK-NEXT: popl %ebp
-    // linux-NEXT: .cfi_def_cfa
-    // CHECK-NEXT: retl
-    x
-}
-
-// CHECK-LABEL: return_f128:
-#[no_mangle]
-pub fn return_f128(x: f128) -> f128 {
-    // CHECK: pushl %ebp
-    // linux-NEXT: .cfi_def_cfa_offset
-    // linux-NEXT: .cfi_offset
-    // CHECK-NEXT: movl %esp, %ebp
-    // linux-NEXT: .cfi_def_cfa_register
-    // linux-NEXT: movaps 8(%ebp), %xmm0
-    // win-NEXT: movups 8(%ebp), %xmm0
-    // CHECK-NEXT: popl %ebp
-    // linux-NEXT: .cfi_def_cfa
-    // CHECK-NEXT: retl
-    x
-}
diff --git a/tests/assembly/x86_64-array-pair-load-store-merge.rs b/tests/assembly/x86_64-array-pair-load-store-merge.rs
deleted file mode 100644
index 56a1a9e8206..00000000000
--- a/tests/assembly/x86_64-array-pair-load-store-merge.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C llvm-args=-x86-asm-syntax=intel
-//@ only-x86_64
-//@ ignore-sgx
-//@ ignore-apple (manipulates rsp too)
-
-// Depending on various codegen choices, this might end up copying
-// a `<2 x i8>`, an `i16`, or two `i8`s.
-// Regardless of those choices, make sure the instructions use (2-byte) words.
-
-// CHECK-LABEL: array_copy_2_elements:
-#[no_mangle]
-pub fn array_copy_2_elements(a: &[u8; 2], p: &mut [u8; 2]) {
-    // CHECK-NOT: byte
-    // CHECK-NOT: mov
-    // CHECK: mov{{.+}}, word ptr
-    // CHECK-NEXT: mov word ptr
-    // CHECK-NEXT: ret
-    *p = *a;
-}
diff --git a/tests/assembly/x86_64-bigint-helpers.rs b/tests/assembly/x86_64-bigint-helpers.rs
deleted file mode 100644
index 58785932bc2..00000000000
--- a/tests/assembly/x86_64-bigint-helpers.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-//@ only-x86_64
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C target-cpu=x86-64-v4
-//@ compile-flags: -C llvm-args=-x86-asm-syntax=intel
-//@ revisions: llvm-pre-20 llvm-20
-//@ [llvm-20] min-llvm-version: 20
-//@ [llvm-pre-20] max-llvm-major-version: 19
-
-#![no_std]
-#![feature(bigint_helper_methods)]
-
-// This checks that the `carrying_add` and `borrowing_sub` implementation successfully chain,
-// to catch issues like <https://github.com/rust-lang/rust/issues/85532#issuecomment-2495119815>
-
-// This forces the ABI to avoid the windows-vs-linux ABI differences.
-
-// CHECK-LABEL: bigint_chain_carrying_add:
-#[no_mangle]
-pub unsafe extern "sysv64" fn bigint_chain_carrying_add(
-    dest: *mut u64,
-    src1: *const u64,
-    src2: *const u64,
-    n: usize,
-    mut carry: bool,
-) -> bool {
-    // llvm-pre-20: mov [[TEMP:r..]], qword ptr [rsi + 8*[[IND:r..]] + 8]
-    // llvm-pre-20: adc [[TEMP]], qword ptr [rdx + 8*[[IND]] + 8]
-    // llvm-pre-20: mov qword ptr [rdi + 8*[[IND]] + 8], [[TEMP]]
-    // llvm-pre-20: mov [[TEMP]], qword ptr [rsi + 8*[[IND]] + 16]
-    // llvm-pre-20: adc [[TEMP]], qword ptr [rdx + 8*[[IND]] + 16]
-    // llvm-pre-20: mov qword ptr [rdi + 8*[[IND]] + 16], [[TEMP]]
-    // llvm-20: adc [[TEMP:r..]], qword ptr [rdx + 8*[[IND:r..]]]
-    // llvm-20: mov qword ptr [rdi + 8*[[IND]]], [[TEMP]]
-    // llvm-20: mov [[TEMP]], qword ptr [rsi + 8*[[IND]] + 8]
-    // llvm-20: adc [[TEMP]], qword ptr [rdx + 8*[[IND]] + 8]
-    for i in 0..n {
-        (*dest.add(i), carry) = u64::carrying_add(*src1.add(i), *src2.add(i), carry);
-    }
-    carry
-}
-
-// CHECK-LABEL: bigint_chain_borrowing_sub:
-#[no_mangle]
-pub unsafe extern "sysv64" fn bigint_chain_borrowing_sub(
-    dest: *mut u64,
-    src1: *const u64,
-    src2: *const u64,
-    n: usize,
-    mut carry: bool,
-) -> bool {
-    // CHECK: mov [[TEMP:r..]], qword ptr [rsi + 8*[[IND:r..]] + 8]
-    // CHECK: sbb [[TEMP]], qword ptr [rdx + 8*[[IND]] + 8]
-    // CHECK: mov qword ptr [rdi + 8*[[IND]] + 8], [[TEMP]]
-    // CHECK: mov [[TEMP]], qword ptr [rsi + 8*[[IND]] + 16]
-    // CHECK: sbb [[TEMP]], qword ptr [rdx + 8*[[IND]] + 16]
-    // CHECK: mov qword ptr [rdi + 8*[[IND]] + 16], [[TEMP]]
-    for i in 0..n {
-        (*dest.add(i), carry) = u64::borrowing_sub(*src1.add(i), *src2.add(i), carry);
-    }
-    carry
-}
diff --git a/tests/assembly/x86_64-cmp.rs b/tests/assembly/x86_64-cmp.rs
deleted file mode 100644
index 26c9013d96f..00000000000
--- a/tests/assembly/x86_64-cmp.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-//@ revisions: LLVM-PRE-20-DEBUG LLVM-20-DEBUG LLVM-PRE-20-OPTIM LLVM-20-OPTIM
-//@ [LLVM-PRE-20-DEBUG] compile-flags: -C opt-level=0
-//@ [LLVM-PRE-20-DEBUG] max-llvm-major-version: 19
-//@ [LLVM-20-DEBUG] compile-flags: -C opt-level=0
-//@ [LLVM-20-DEBUG] min-llvm-version: 20
-//@ [LLVM-PRE-20-OPTIM] compile-flags: -C opt-level=3
-//@ [LLVM-PRE-20-OPTIM] max-llvm-major-version: 19
-//@ [LLVM-20-OPTIM] compile-flags: -C opt-level=3
-//@ [LLVM-20-OPTIM] min-llvm-version: 20
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -C llvm-args=-x86-asm-syntax=intel
-//@ only-x86_64
-//@ ignore-sgx
-
-#![feature(core_intrinsics)]
-
-use std::intrinsics::three_way_compare;
-
-#[no_mangle]
-// CHECK-LABEL: signed_cmp:
-pub fn signed_cmp(a: i16, b: i16) -> std::cmp::Ordering {
-    // LLVM-PRE-20-DEBUG: cmp
-    // LLVM-PRE-20-DEBUG: setg
-    // LLVM-PRE-20-DEBUG: and
-    // LLVM-PRE-20-DEBUG: cmp
-    // LLVM-PRE-20-DEBUG: setl
-    // LLVM-PRE-20-DEBUG: and
-    // LLVM-PRE-20-DEBUG: sub
-    //
-    // LLVM-20-DEBUG: sub
-    // LLVM-20-DEBUG: setl
-    // LLVM-20-DEBUG: setg
-    // LLVM-20-DEBUG: sub
-    // LLVM-20-DEBUG: ret
-
-    // LLVM-PRE-20-OPTIM: xor
-    // LLVM-PRE-20-OPTIM: cmp
-    // LLVM-PRE-20-OPTIM: setne
-    // LLVM-PRE-20-OPTIM: mov
-    // LLVM-PRE-20-OPTIM: cmovge
-    // LLVM-PRE-20-OPTIM: ret
-    //
-    // LLVM-20-OPTIM: cmp
-    // LLVM-20-OPTIM: setl
-    // LLVM-20-OPTIM: setg
-    // LLVM-20-OPTIM: sub
-    // LLVM-20-OPTIM: ret
-    three_way_compare(a, b)
-}
-
-#[no_mangle]
-// CHECK-LABEL: unsigned_cmp:
-pub fn unsigned_cmp(a: u16, b: u16) -> std::cmp::Ordering {
-    // LLVM-PRE-20-DEBUG: cmp
-    // LLVM-PRE-20-DEBUG: seta
-    // LLVM-PRE-20-DEBUG: and
-    // LLVM-PRE-20-DEBUG: cmp
-    // LLVM-PRE-20-DEBUG: setb
-    // LLVM-PRE-20-DEBUG: and
-    // LLVM-PRE-20-DEBUG: sub
-    //
-    // LLVM-20-DEBUG: sub
-    // LLVM-20-DEBUG: seta
-    // LLVM-20-DEBUG: sbb
-    // LLVM-20-DEBUG: ret
-
-    // LLVM-PRE-20-OPTIM: xor
-    // LLVM-PRE-20-OPTIM: cmp
-    // LLVM-PRE-20-OPTIM: setne
-    // LLVM-PRE-20-OPTIM: mov
-    // LLVM-PRE-20-OPTIM: cmovae
-    // LLVM-PRE-20-OPTIM: ret
-    //
-    // LLVM-20-OPTIM: cmp
-    // LLVM-20-OPTIM: seta
-    // LLVM-20-OPTIM: sbb
-    // LLVM-20-OPTIM: ret
-    three_way_compare(a, b)
-}
diff --git a/tests/assembly/x86_64-floating-point-clamp.rs b/tests/assembly/x86_64-floating-point-clamp.rs
deleted file mode 100644
index 6b0c29c5f21..00000000000
--- a/tests/assembly/x86_64-floating-point-clamp.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Floating-point clamp is designed to be implementable as max+min,
-// so check to make sure that's what it's actually emitting.
-
-//@ assembly-output: emit-asm
-// Set the base cpu explicitly, in case the default has been changed.
-//@ compile-flags: --crate-type=lib -Copt-level=3 -C llvm-args=-x86-asm-syntax=intel -C target-cpu=x86-64
-//@ only-x86_64
-//@ ignore-sgx
-
-// CHECK-LABEL: clamp_demo:
-#[no_mangle]
-pub fn clamp_demo(a: f32, x: f32, y: f32) -> f32 {
-    // CHECK: maxss
-    // CHECK: minss
-    a.clamp(x, y)
-}
-
-// CHECK-LABEL: clamp12_demo:
-#[no_mangle]
-pub fn clamp12_demo(a: f32) -> f32 {
-    // CHECK: movss   xmm1
-    // CHECK-NEXT: maxss   xmm1, xmm0
-    // CHECK-NEXT: movss   xmm0
-    // CHECK-NEXT: minss   xmm0, xmm1
-    // CHECK: ret
-    a.clamp(1.0, 2.0)
-}
diff --git a/tests/assembly/x86_64-fortanix-unknown-sgx-lvi-generic-load.rs b/tests/assembly/x86_64-fortanix-unknown-sgx-lvi-generic-load.rs
deleted file mode 100644
index f5e2f18e68e..00000000000
--- a/tests/assembly/x86_64-fortanix-unknown-sgx-lvi-generic-load.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Test LVI load hardening on SGX enclave code
-
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type staticlib
-//@ only-x86_64-fortanix-unknown-sgx
-
-#[no_mangle]
-pub extern "C" fn plus_one(r: &mut u64) {
-    *r = *r + 1;
-}
-
-// CHECK: plus_one
-// CHECK: lfence
-// CHECK-NEXT: incq
-// CHECK: popq [[REGISTER:%[a-z]+]]
-// CHECK-NEXT: lfence
-// CHECK-NEXT: jmpq *[[REGISTER]]
diff --git a/tests/assembly/x86_64-fortanix-unknown-sgx-lvi-generic-ret.rs b/tests/assembly/x86_64-fortanix-unknown-sgx-lvi-generic-ret.rs
deleted file mode 100644
index f16d68fa255..00000000000
--- a/tests/assembly/x86_64-fortanix-unknown-sgx-lvi-generic-ret.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Test LVI ret hardening on generic rust code
-
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type staticlib
-//@ only-x86_64-fortanix-unknown-sgx
-
-#[no_mangle]
-pub extern "C" fn myret() {}
-// CHECK: myret:
-// CHECK: popq [[REGISTER:%[a-z]+]]
-// CHECK-NEXT: lfence
-// CHECK-NEXT: jmpq *[[REGISTER]]
diff --git a/tests/assembly/x86_64-fortanix-unknown-sgx-lvi-inline-assembly.rs b/tests/assembly/x86_64-fortanix-unknown-sgx-lvi-inline-assembly.rs
deleted file mode 100644
index a729df8e166..00000000000
--- a/tests/assembly/x86_64-fortanix-unknown-sgx-lvi-inline-assembly.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Test LVI load hardening on SGX inline assembly code
-
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type staticlib
-//@ only-x86_64-fortanix-unknown-sgx
-
-use std::arch::asm;
-
-#[no_mangle]
-pub extern "C" fn get(ptr: *const u64) -> u64 {
-    let value: u64;
-    unsafe {
-        asm!("mov {}, [{}]",
-            out(reg) value,
-            in(reg) ptr);
-    }
-    value
-}
-
-// CHECK: get
-// CHECK: movq
-// CHECK-NEXT: lfence
-
-#[no_mangle]
-pub extern "C" fn myret() {
-    unsafe {
-        asm!("ret");
-    }
-}
-
-// CHECK: myret
-// CHECK: shlq $0, (%rsp)
-// CHECK-NEXT: lfence
-// CHECK-NEXT: retq
diff --git a/tests/assembly/x86_64-function-return.rs b/tests/assembly/x86_64-function-return.rs
deleted file mode 100644
index 7fd57200a9e..00000000000
--- a/tests/assembly/x86_64-function-return.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Test that the function return is (not) converted into a jump to the thunk
-// when the `-Zfunction-return={keep,thunk-extern}` flag is (not) set.
-
-//@ revisions: unset keep thunk-extern keep-thunk-extern thunk-extern-keep
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3
-//@ [keep] compile-flags: -Zfunction-return=keep
-//@ [thunk-extern] compile-flags: -Zfunction-return=thunk-extern
-//@ [keep-thunk-extern] compile-flags: -Zfunction-return=keep -Zfunction-return=thunk-extern
-//@ [thunk-extern-keep] compile-flags: -Zfunction-return=thunk-extern -Zfunction-return=keep
-//@ only-x86_64
-//@ ignore-apple Symbol is called `___x86_return_thunk` (Darwin's extra underscore)
-//@ ignore-sgx Tests incompatible with LVI mitigations
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: foo:
-#[no_mangle]
-pub unsafe fn foo() {
-    // unset: ret
-    // unset-NOT: jmp __x86_return_thunk
-    // keep: ret
-    // keep-NOT: jmp __x86_return_thunk
-    // thunk-extern: jmp __x86_return_thunk
-    // thunk-extern-NOT: ret
-    // keep-thunk-extern: jmp __x86_return_thunk
-    // keep-thunk-extern-NOT: ret
-    // thunk-extern-keep: ret
-    // thunk-extern-keep-NOT: jmp __x86_return_thunk
-}
diff --git a/tests/assembly/x86_64-no-jump-tables.rs b/tests/assembly/x86_64-no-jump-tables.rs
deleted file mode 100644
index bb10042d8f6..00000000000
--- a/tests/assembly/x86_64-no-jump-tables.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Test that jump tables are (not) emitted when the `-Zno-jump-tables`
-// flag is (not) set.
-
-//@ revisions: unset set
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3
-//@ [set] compile-flags: -Zno-jump-tables
-//@ only-x86_64
-//@ ignore-sgx
-
-#![crate_type = "lib"]
-
-extern "C" {
-    fn bar1();
-    fn bar2();
-    fn bar3();
-    fn bar4();
-    fn bar5();
-    fn bar6();
-}
-
-// CHECK-LABEL: foo:
-#[no_mangle]
-pub unsafe fn foo(x: i32) {
-    // unset: LJTI0_0
-    // set-NOT: LJTI0_0
-    match x {
-        1 => bar1(),
-        2 => bar2(),
-        3 => bar3(),
-        4 => bar4(),
-        5 => bar5(),
-        _ => bar6(),
-    }
-}
diff --git a/tests/assembly/x86_64-sse_crc.rs b/tests/assembly/x86_64-sse_crc.rs
deleted file mode 100644
index bde58955a21..00000000000
--- a/tests/assembly/x86_64-sse_crc.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ only-x86_64
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type staticlib -Ctarget-feature=+sse4.2
-
-// CHECK-LABEL: banana
-// CHECK: crc32
-#[no_mangle]
-pub unsafe fn banana(v: u8) -> u32 {
-    use std::arch::x86_64::*;
-    let out = !0u32;
-    _mm_crc32_u8(out, v)
-}
diff --git a/tests/assembly/x86_64-typed-swap.rs b/tests/assembly/x86_64-typed-swap.rs
deleted file mode 100644
index a6753011d36..00000000000
--- a/tests/assembly/x86_64-typed-swap.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-//@ revisions: WIN LIN
-//@ [WIN] only-windows
-//@ [LIN] only-linux
-//@ only-x86_64
-//@ assembly-output: emit-asm
-//@ compile-flags: --crate-type=lib -Copt-level=3
-
-use std::arch::x86_64::__m128;
-use std::mem::swap;
-
-// CHECK-LABEL: swap_i32:
-#[no_mangle]
-pub fn swap_i32(x: &mut i32, y: &mut i32) {
-    // CHECK: movl (%[[ARG1:.+]]), %[[T1:.+]]
-    // CHECK-NEXT: movl (%[[ARG2:.+]]), %[[T2:.+]]
-    // CHECK-DAG: movl %[[T2]], (%[[ARG1]])
-    // CHECK-DAG: movl %[[T1]], (%[[ARG2]])
-    // CHECK-NEXT: retq
-    swap(x, y)
-}
-
-// CHECK-LABEL: swap_pair:
-#[no_mangle]
-pub fn swap_pair(x: &mut (i32, u32), y: &mut (i32, u32)) {
-    // CHECK: movq (%[[ARG1:r..?]]), %[[T1:.+]]
-    // CHECK-NEXT: movq (%[[ARG2:r..?]]), %[[T2:.+]]
-    // CHECK-DAG: movq %[[T2]], (%[[ARG1]])
-    // CHECK-DAG: movq %[[T1]], (%[[ARG2]])
-    // CHECK-NEXT: retq
-    swap(x, y)
-}
-
-// CHECK-LABEL: swap_str:
-#[no_mangle]
-pub fn swap_str<'a>(x: &mut &'a str, y: &mut &'a str) {
-    // CHECK: movups (%[[ARG1:r..?]]), %[[T1:xmm.]]
-    // CHECK-NEXT: movups (%[[ARG2:r..?]]), %[[T2:xmm.]]
-    // CHECK-DAG: movups %[[T2]], (%[[ARG1]])
-    // CHECK-DAG: movups %[[T1]], (%[[ARG2]])
-    // CHECK-NEXT: retq
-    swap(x, y)
-}
-
-// CHECK-LABEL: swap_simd:
-#[no_mangle]
-pub fn swap_simd(x: &mut __m128, y: &mut __m128) {
-    // CHECK: movaps (%[[ARG1:r..?]]), %[[T1:xmm.]]
-    // CHECK-NEXT: movaps (%[[ARG2:r..?]]), %[[T2:xmm.]]
-    // CHECK-DAG: movaps %[[T2]], (%[[ARG1]])
-    // CHECK-DAG: movaps %[[T1]], (%[[ARG2]])
-    // CHECK-NEXT: retq
-    swap(x, y)
-}
-
-// CHECK-LABEL: swap_string:
-#[no_mangle]
-pub fn swap_string(x: &mut String, y: &mut String) {
-    // CHECK-NOT: mov
-    // CHECK-COUNT-4: movups
-    // CHECK-NOT: mov
-    // CHECK-COUNT-4: movq
-    // CHECK-NOT: mov
-    swap(x, y)
-}
-
-// CHECK-LABEL: swap_44_bytes:
-#[no_mangle]
-pub fn swap_44_bytes(x: &mut [u8; 44], y: &mut [u8; 44]) {
-    // Ensure we do better than a long run of byte copies,
-    // see <https://github.com/rust-lang/rust/issues/134946>
-
-    // CHECK-NOT: movb
-    // CHECK-COUNT-8: movups{{.+}}xmm
-    // CHECK-NOT: movb
-    // CHECK-COUNT-4: movq
-    // CHECK-NOT: movb
-    // CHECK-COUNT-4: movl
-    // CHECK-NOT: movb
-    // CHECK: retq
-    swap(x, y)
-}
diff --git a/tests/assembly/x86_64-windows-float-abi.rs b/tests/assembly/x86_64-windows-float-abi.rs
deleted file mode 100644
index cbc80910851..00000000000
--- a/tests/assembly/x86_64-windows-float-abi.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-//@ assembly-output: emit-asm
-//@ compile-flags: -Copt-level=3
-//@ compile-flags: --target x86_64-pc-windows-msvc
-//@ needs-llvm-components: x86
-//@ add-core-stubs
-
-#![feature(f16, f128)]
-#![feature(no_core)]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: second_f16
-// CHECK: movaps %xmm1, %xmm0
-// CHECK-NEXT: retq
-#[no_mangle]
-pub extern "C" fn second_f16(_: f16, x: f16) -> f16 {
-    x
-}
-
-// CHECK-LABEL: second_f32
-// CHECK: movaps %xmm1, %xmm0
-// CHECK-NEXT: retq
-#[no_mangle]
-pub extern "C" fn second_f32(_: f32, x: f32) -> f32 {
-    x
-}
-
-// CHECK-LABEL: second_f64
-// CHECK: movaps %xmm1, %xmm0
-// CHECK-NEXT: retq
-#[no_mangle]
-pub extern "C" fn second_f64(_: f64, x: f64) -> f64 {
-    x
-}
-
-// 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-NEXT: retq
-#[no_mangle]
-pub extern "C" fn second_f128(_: f128, x: f128) -> f128 {
-    x
-}
diff --git a/tests/assembly/x86_64-windows-i128-abi.rs b/tests/assembly/x86_64-windows-i128-abi.rs
deleted file mode 100644
index d2aefb7daa6..00000000000
--- a/tests/assembly/x86_64-windows-i128-abi.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//@ assembly-output: emit-asm
-//@ add-core-stubs
-//@ revisions: msvc softfloat
-//@ compile-flags: -Copt-level=3
-//@[msvc] compile-flags: --target x86_64-pc-windows-msvc
-//@[msvc] needs-llvm-components: x86
-//@[softfloat] compile-flags: --target x86_64-unknown-uefi
-//@[softfloat] needs-llvm-components: x86
-
-#![feature(no_core)]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: ret_i128
-// Hardfloat targets return via xmm0, softfloat targets via rax and rdx.
-// msvc: movaps {{.*}}, %xmm0
-// softfloat: movq (%[[INPUT:.*]]), %rax
-// softfloat-NEXT: movq 8(%[[INPUT]]), %rdx
-// CHECK-NEXT: retq
-#[no_mangle]
-pub extern "C" fn ret_i128(x: &i128) -> i128 {
-    *x
-}
diff --git a/tests/assembly/x86_64-xray.rs b/tests/assembly/x86_64-xray.rs
deleted file mode 100644
index 4cf3e8cda13..00000000000
--- a/tests/assembly/x86_64-xray.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ assembly-output: emit-asm
-//@ compile-flags: -Zinstrument-xray=always -Cllvm-args=-x86-asm-syntax=intel
-
-//@ revisions: x86_64-linux
-//@[x86_64-linux] compile-flags: --target=x86_64-unknown-linux-gnu
-//@[x86_64-linux] needs-llvm-components: x86
-//@[x86_64-linux] only-x86_64-unknown-linux-gnu
-
-//@ revisions: x86_64-darwin
-//@[x86_64-darwin] compile-flags: --target=x86_64-apple-darwin
-//@[x86_64-darwin] needs-llvm-components: x86
-//@[x86_64-darwin] only-x86_64-apple-darwin
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: xray_func:
-#[no_mangle]
-pub fn xray_func() {
-    // CHECK: nop word ptr [rax + rax + 512]
-
-    std::hint::black_box(());
-
-    // CHECK: ret
-    // CHECK-NEXT: nop word ptr cs:[rax + rax + 512]
-}
diff --git a/tests/codegen/target-feature-overrides.rs b/tests/codegen/target-feature-overrides.rs
index eb19b0de2fa..63a586d388b 100644
--- a/tests/codegen/target-feature-overrides.rs
+++ b/tests/codegen/target-feature-overrides.rs
@@ -6,7 +6,7 @@
 //@ [COMPAT] compile-flags: -Ctarget-feature=+avx2
 //@ [INCOMPAT] compile-flags: -Ctarget-feature=-avx2,-avx
 
-// See also tests/assembly/target-feature-multiple.rs
+// See also tests/assembly-llvm/target-feature-multiple.rs
 #![feature(no_core, lang_items)]
 #![crate_type = "lib"]
 #![no_core]
diff --git a/tests/run-make/avr-rjmp-offset/rmake.rs b/tests/run-make/avr-rjmp-offset/rmake.rs
index da314f26ca7..86d85e89f78 100644
--- a/tests/run-make/avr-rjmp-offset/rmake.rs
+++ b/tests/run-make/avr-rjmp-offset/rmake.rs
@@ -6,7 +6,7 @@
 //! loop instruction to be missed. This test therefore contains a simple loop
 //! with trivial instructions in it, to see, where the label is placed.
 //!
-//! This must be a `rmake`-test and cannot be a `tests/assembly`-test, since the
+//! This must be a `rmake`-test and cannot be a `tests/assembly-llvm/`-test, since the
 //! wrong output is only produced with direct assembly generation, but not when
 //! "emit-asm" is used, as described in the issue description of #129301:
 //! https://github.com/rust-lang/rust/issues/129301#issue-2475070770
diff --git a/triagebot.toml b/triagebot.toml
index 61d8a814c89..e34e4a88f42 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -302,7 +302,7 @@ trigger_files = [
     "compiler",
 
     # Tests
-    "tests/assembly",
+    "tests/assembly-llvm",
     "tests/auxiliary",
     "tests/codegen",
     "tests/codegen-units",
-- 
cgit 1.4.1-3-g733a5


From a27f3e3fd1e4d16160f8885b6b06665b5319f56c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 21 Jul 2025 14:34:12 +0200
Subject: Rename `tests/codegen` into `tests/codegen-llvm`

---
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs       |   2 +-
 .../rustc_mir_transform/src/unreachable_prop.rs    |   2 +-
 library/alloc/src/collections/vec_deque/drain.rs   |   2 +-
 library/alloc/src/raw_vec/mod.rs                   |   2 +-
 rustfmt.toml                                       |   4 +-
 src/bootstrap/src/core/build_steps/test.rs         |  11 +-
 src/bootstrap/src/core/builder/mod.rs              |   4 +-
 src/ci/docker/host-x86_64/test-various/Dockerfile  |   2 +-
 src/doc/rustc-dev-guide/src/asm.md                 |   2 +-
 .../rustc-dev-guide/src/autodiff/installation.md   |   2 +-
 .../src/llvm-coverage-instrumentation.md           |   4 +-
 .../rustc-dev-guide/src/offload/installation.md    |   2 +-
 .../src/profile-guided-optimization.md             |   2 +-
 src/doc/rustc-dev-guide/src/sanitizers.md          |   4 +-
 src/doc/rustc-dev-guide/src/tests/compiletest.md   |   6 +-
 src/tools/opt-dist/src/tests.rs                    |   2 +-
 tests/assembly-llvm/target-feature-multiple.rs     |   2 +-
 tests/codegen-llvm/README.md                       |  24 +
 tests/codegen-llvm/aarch64-softfloat.rs            |  45 ++
 tests/codegen-llvm/aarch64-struct-align-128.rs     | 145 ++++
 tests/codegen-llvm/abi-efiapi.rs                   |  30 +
 .../codegen-llvm/abi-main-signature-16bit-c-int.rs |  11 +
 .../codegen-llvm/abi-main-signature-32bit-c-int.rs |  11 +
 tests/codegen-llvm/abi-repr-ext.rs                 |  56 ++
 tests/codegen-llvm/abi-sysv64.rs                   |  20 +
 tests/codegen-llvm/abi-win64-zst.rs                |  54 ++
 tests/codegen-llvm/abi-x86-interrupt.rs            |  18 +
 tests/codegen-llvm/abi-x86-sse.rs                  |  43 ++
 tests/codegen-llvm/abi-x86_64_sysv.rs              |  29 +
 tests/codegen-llvm/addr-of-mutate.rs               |  33 +
 tests/codegen-llvm/adjustments.rs                  |  28 +
 .../codegen-llvm/align-byval-alignment-mismatch.rs | 126 ++++
 tests/codegen-llvm/align-byval-vector.rs           |  55 ++
 tests/codegen-llvm/align-byval.rs                  | 315 +++++++++
 tests/codegen-llvm/align-enum.rs                   |  33 +
 tests/codegen-llvm/align-fn.rs                     | 143 ++++
 tests/codegen-llvm/align-offset.rs                 |  75 ++
 tests/codegen-llvm/align-struct.rs                 |  70 ++
 tests/codegen-llvm/alloc-optimisation.rs           |  13 +
 tests/codegen-llvm/amdgpu-addrspacecast.rs         |  18 +
 tests/codegen-llvm/array-clone.rs                  |  15 +
 tests/codegen-llvm/array-cmp.rs                    |  74 ++
 tests/codegen-llvm/array-codegen.rs                |  62 ++
 tests/codegen-llvm/array-equality.rs               | 101 +++
 tests/codegen-llvm/array-from_fn.rs                |  13 +
 tests/codegen-llvm/array-map.rs                    |  35 +
 tests/codegen-llvm/array-optimized.rs              |  33 +
 tests/codegen-llvm/array-repeat.rs                 |  15 +
 tests/codegen-llvm/ascii-char.rs                   |  36 +
 tests/codegen-llvm/asm/aarch64-clobbers.rs         |  47 ++
 tests/codegen-llvm/asm/avr-clobbers.rs             |  39 ++
 tests/codegen-llvm/asm/bpf-clobbers.rs             |  31 +
 tests/codegen-llvm/asm/critical.rs                 |  36 +
 tests/codegen-llvm/asm/csky-clobbers.rs            |  24 +
 tests/codegen-llvm/asm/foo.s                       |   3 +
 tests/codegen-llvm/asm/global_asm.rs               |  28 +
 tests/codegen-llvm/asm/global_asm_include.rs       |  21 +
 tests/codegen-llvm/asm/global_asm_x2.rs            |  47 ++
 tests/codegen-llvm/asm/goto.rs                     |  63 ++
 tests/codegen-llvm/asm/hexagon-clobbers.rs         |  33 +
 tests/codegen-llvm/asm/may_unwind.rs               |  39 ++
 tests/codegen-llvm/asm/maybe-uninit.rs             |  27 +
 tests/codegen-llvm/asm/msp430-clobbers.rs          |  32 +
 tests/codegen-llvm/asm/multiple-options.rs         |  54 ++
 tests/codegen-llvm/asm/options.rs                  | 104 +++
 tests/codegen-llvm/asm/powerpc-clobbers.rs         |  68 ++
 tests/codegen-llvm/asm/riscv-clobbers.rs           |  40 ++
 tests/codegen-llvm/asm/s390x-clobbers.rs           |  46 ++
 tests/codegen-llvm/asm/sanitize-llvm.rs            |  24 +
 tests/codegen-llvm/asm/sparc-clobbers.rs           |  36 +
 tests/codegen-llvm/asm/x86-clobber_abi.rs          |  36 +
 tests/codegen-llvm/asm/x86-clobbers.rs             |  20 +
 tests/codegen-llvm/asm/x86-target-clobbers.rs      |  29 +
 tests/codegen-llvm/assign-desugar-debuginfo.rs     |  18 +
 tests/codegen-llvm/async-closure-debug.rs          |  20 +
 tests/codegen-llvm/async-fn-debug-awaitee-field.rs |  28 +
 tests/codegen-llvm/async-fn-debug-msvc.rs          |  55 ++
 tests/codegen-llvm/async-fn-debug.rs               |  59 ++
 tests/codegen-llvm/atomic-operations.rs            |  84 +++
 tests/codegen-llvm/atomicptr.rs                    |  36 +
 tests/codegen-llvm/autodiff/batched.rs             | 116 +++
 tests/codegen-llvm/autodiff/generic.rs             |  42 ++
 tests/codegen-llvm/autodiff/identical_fnc.rs       |  45 ++
 tests/codegen-llvm/autodiff/inline.rs              |  23 +
 tests/codegen-llvm/autodiff/scalar.rs              |  33 +
 tests/codegen-llvm/autodiff/sret.rs                |  45 ++
 tests/codegen-llvm/autodiffv2.rs                   | 113 +++
 .../autovec/dont-shuffle-bswaps-opt2.rs            |  31 +
 .../autovec/dont-shuffle-bswaps-opt3.rs            |  42 ++
 tests/codegen-llvm/autovectorize-f32x4.rs          |  37 +
 tests/codegen-llvm/auxiliary/extern_decl.rs        |  13 +
 tests/codegen-llvm/auxiliary/nounwind.rs           |   2 +
 tests/codegen-llvm/auxiliary/thread_local_aux.rs   |   5 +
 tests/codegen-llvm/avr/avr-func-addrspace.rs       | 106 +++
 tests/codegen-llvm/bigint-helpers.rs               |  13 +
 .../binary-heap-peek-mut-pop-no-panic.rs           |  13 +
 .../binary-search-index-no-bound-check.rs          |  35 +
 tests/codegen-llvm/bool-cmp.rs                     |  18 +
 .../bounds-checking/gep-issue-133979.rs            |  22 +
 tests/codegen-llvm/box-default-debug-copies.rs     |  28 +
 tests/codegen-llvm/box-uninit-bytes.rs             |  46 ++
 tests/codegen-llvm/bpf-alu32.rs                    |  11 +
 tests/codegen-llvm/branch-protection.rs            |  94 +++
 tests/codegen-llvm/call-llvm-intrinsics.rs         |  30 +
 tests/codegen-llvm/call-tmps-lifetime.rs           |  68 ++
 tests/codegen-llvm/cast-optimized.rs               |  33 +
 tests/codegen-llvm/cast-target-abi.rs              | 599 ++++++++++++++++
 tests/codegen-llvm/catch-unwind.rs                 |  32 +
 tests/codegen-llvm/cdylib-external-inline-fns.rs   |  43 ++
 tests/codegen-llvm/cf-protection.rs                |  38 +
 tests/codegen-llvm/cffi/c-variadic-copy.rs         |  16 +
 tests/codegen-llvm/cffi/c-variadic-naked.rs        |  15 +
 tests/codegen-llvm/cffi/c-variadic-opt.rs          |  30 +
 tests/codegen-llvm/cffi/c-variadic.rs              |  71 ++
 tests/codegen-llvm/cffi/ffi-const.rs               |  15 +
 tests/codegen-llvm/cffi/ffi-out-of-bounds-loads.rs |  41 ++
 tests/codegen-llvm/cffi/ffi-pure.rs                |  15 +
 tests/codegen-llvm/cfguard-checks.rs               |  10 +
 tests/codegen-llvm/cfguard-disabled.rs             |  10 +
 tests/codegen-llvm/cfguard-nochecks.rs             |  10 +
 tests/codegen-llvm/cfguard-non-msvc.rs             |  10 +
 tests/codegen-llvm/char-ascii-branchless.rs        |  47 ++
 .../char-escape-debug-no-bounds-check.rs           |  14 +
 tests/codegen-llvm/checked_ilog.rs                 |  20 +
 tests/codegen-llvm/checked_math.rs                 | 100 +++
 tests/codegen-llvm/clone-shims.rs                  |  15 +
 tests/codegen-llvm/clone_as_copy.rs                |  40 ++
 tests/codegen-llvm/codemodels.rs                   |  20 +
 tests/codegen-llvm/coercions.rs                    |  19 +
 tests/codegen-llvm/cold-call-declare-and-call.rs   |  27 +
 tests/codegen-llvm/common_prim_int_ptr.rs          |  51 ++
 .../codegen-llvm/comparison-operators-2-struct.rs  |  61 ++
 tests/codegen-llvm/comparison-operators-2-tuple.rs | 117 ++++
 tests/codegen-llvm/comparison-operators-newtype.rs |  48 ++
 .../compiletest-self-test/minicore-smoke-test.rs   |  20 +
 tests/codegen-llvm/const-array.rs                  |  15 +
 tests/codegen-llvm/const-vector.rs                 |  78 +++
 tests/codegen-llvm/const_scalar_pair.rs            |   8 +
 tests/codegen-llvm/constant-branch.rs              |  49 ++
 tests/codegen-llvm/consts.rs                       |  55 ++
 tests/codegen-llvm/coroutine-debug-msvc.rs         |  60 ++
 tests/codegen-llvm/coroutine-debug.rs              |  64 ++
 .../cross-crate-inlining/always-inline.rs          |  13 +
 .../cross-crate-inlining/auxiliary/always.rs       |  20 +
 .../cross-crate-inlining/auxiliary/leaf.rs         |  20 +
 .../cross-crate-inlining/auxiliary/never.rs        |  20 +
 .../cross-crate-inlining/leaf-inlining.rs          |  20 +
 .../cross-crate-inlining/never-inline.rs           |  13 +
 tests/codegen-llvm/dealloc-no-unwind.rs            |  25 +
 .../codegen-llvm/debug-accessibility/crate-enum.rs |  28 +
 .../debug-accessibility/crate-struct.rs            |  23 +
 .../debug-accessibility/private-enum.rs            |  22 +
 .../debug-accessibility/private-struct.rs          |  17 +
 .../debug-accessibility/public-enum.rs             |  23 +
 .../debug-accessibility/public-struct.rs           |  17 +
 .../debug-accessibility/struct-fields.rs           |  30 +
 .../codegen-llvm/debug-accessibility/super-enum.rs |  28 +
 .../debug-accessibility/super-struct.rs            |  23 +
 .../debug-accessibility/tuple-fields.rs            |  24 +
 tests/codegen-llvm/debug-alignment.rs              |   8 +
 tests/codegen-llvm/debug-column-msvc.rs            |  16 +
 tests/codegen-llvm/debug-column.rs                 |  25 +
 tests/codegen-llvm/debug-compile-unit-path.rs      |   9 +
 tests/codegen-llvm/debug-fndef-size.rs             |  20 +
 tests/codegen-llvm/debug-limited.rs                |  27 +
 tests/codegen-llvm/debug-line-directives-only.rs   |  27 +
 tests/codegen-llvm/debug-line-tables-only.rs       |  27 +
 tests/codegen-llvm/debug-linkage-name.rs           |  42 ++
 tests/codegen-llvm/debug-vtable.rs                 | 117 ++++
 tests/codegen-llvm/debuginfo-constant-locals.rs    |  28 +
 .../debuginfo-generic-closure-env-names.rs         |  90 +++
 .../debuginfo-inline-callsite-location.rs          |  27 +
 .../debuginfo-proc-macro/auxiliary/macro_def.rs    |   7 +
 .../mir_inlined_twice_var_locs.rs                  |  52 ++
 tests/codegen-llvm/deduced-param-attrs.rs          |  60 ++
 tests/codegen-llvm/default-requires-uwtable.rs     |  17 +
 tests/codegen-llvm/default-visibility.rs           |  49 ++
 tests/codegen-llvm/direct-access-external-data.rs  |  21 +
 tests/codegen-llvm/dllimports/auxiliary/dummy.rs   |   6 +
 tests/codegen-llvm/dllimports/auxiliary/wrapper.rs |  14 +
 tests/codegen-llvm/dllimports/main.rs              |  43 ++
 ...gen_private_const_fn_only_used_in_const_eval.rs |  27 +
 tests/codegen-llvm/drop-in-place-noalias.rs        |  38 +
 tests/codegen-llvm/drop.rs                         |  36 +
 tests/codegen-llvm/dst-offset.rs                   |  84 +++
 tests/codegen-llvm/dst-vtable-align-nonzero.rs     |  67 ++
 tests/codegen-llvm/dst-vtable-size-range.rs        |  35 +
 tests/codegen-llvm/ehcontguard_disabled.rs         |   9 +
 tests/codegen-llvm/ehcontguard_enabled.rs          |   9 +
 .../codegen-llvm/emscripten-catch-unwind-js-eh.rs  |  71 ++
 .../emscripten-catch-unwind-wasm-eh.rs             |  69 ++
 tests/codegen-llvm/enable-lto-unit-splitting.rs    |   9 +
 tests/codegen-llvm/enum/enum-aggregate.rs          | 126 ++++
 .../enum/enum-bounds-check-derived-idx.rs          |  24 +
 .../enum/enum-bounds-check-issue-13926.rs          |  18 +
 .../enum/enum-bounds-check-issue-82871.rs          |  18 +
 tests/codegen-llvm/enum/enum-bounds-check.rs       |  27 +
 tests/codegen-llvm/enum/enum-debug-clike.rs        |  28 +
 tests/codegen-llvm/enum/enum-debug-niche-2.rs      |  47 ++
 tests/codegen-llvm/enum/enum-debug-niche.rs        |  35 +
 tests/codegen-llvm/enum/enum-debug-tagged.rs       |  31 +
 tests/codegen-llvm/enum/enum-discriminant-eq.rs    | 223 ++++++
 tests/codegen-llvm/enum/enum-discriminant-value.rs |  27 +
 .../enum/enum-early-otherwise-branch.rs            |  25 +
 tests/codegen-llvm/enum/enum-match.rs              | 779 +++++++++++++++++++++
 tests/codegen-llvm/enum/enum-two-variants-match.rs | 130 ++++
 tests/codegen-llvm/enum/enum-u128.rs               |  25 +
 .../enum/unreachable_enum_default_branch.rs        |  40 ++
 tests/codegen-llvm/ergonomic-clones/closure.rs     |  55 ++
 tests/codegen-llvm/error-provide.rs                |  50 ++
 tests/codegen-llvm/export-no-mangle.rs             |  31 +
 tests/codegen-llvm/external-no-mangle-fns.rs       |  75 ++
 tests/codegen-llvm/external-no-mangle-statics.rs   |  77 ++
 tests/codegen-llvm/f128-wasm32-callconv.rs         |  49 ++
 tests/codegen-llvm/fastcall-inreg.rs               |  40 ++
 tests/codegen-llvm/fatptr.rs                       |  12 +
 tests/codegen-llvm/fewer-names.rs                  |  19 +
 tests/codegen-llvm/fixed-x18.rs                    |  23 +
 tests/codegen-llvm/float/algebraic.rs              | 149 ++++
 tests/codegen-llvm/float/f128.rs                   | 441 ++++++++++++
 tests/codegen-llvm/float/f16-f128-inline.rs        |  29 +
 tests/codegen-llvm/float/f16.rs                    | 364 ++++++++++
 tests/codegen-llvm/float_math.rs                   |  87 +++
 tests/codegen-llvm/fn-impl-trait-self.rs           |  17 +
 .../fn-parameters-on-different-lines-debuginfo.rs  |  22 +
 tests/codegen-llvm/force-frame-pointers.rs         |  18 +
 tests/codegen-llvm/force-no-unwind-tables.rs       |  11 +
 tests/codegen-llvm/force-unwind-tables.rs          |   6 +
 tests/codegen-llvm/frame-pointer-cli-control.rs    |  61 ++
 tests/codegen-llvm/frame-pointer.rs                |  35 +
 tests/codegen-llvm/function-arguments-noopt.rs     |  69 ++
 tests/codegen-llvm/function-arguments.rs           | 278 ++++++++
 tests/codegen-llvm/function-return.rs              |  35 +
 tests/codegen-llvm/gdb_debug_script_load.rs        |  37 +
 tests/codegen-llvm/generic-debug.rs                |  17 +
 tests/codegen-llvm/gep-index.rs                    |  37 +
 tests/codegen-llvm/gpu-kernel-abi.rs               |  15 +
 tests/codegen-llvm/gpu_offload/gpu_host.rs         |  80 +++
 tests/codegen-llvm/hint/cold_path.rs               |  54 ++
 tests/codegen-llvm/hint/likely.rs                  |  81 +++
 tests/codegen-llvm/hint/unlikely.rs                |  80 +++
 tests/codegen-llvm/i128-wasm32-callconv.rs         |  49 ++
 tests/codegen-llvm/i128-x86-align.rs               | 105 +++
 tests/codegen-llvm/i128-x86-callconv.rs            |  87 +++
 tests/codegen-llvm/infallible-unwrap-in-opt-z.rs   |  26 +
 tests/codegen-llvm/inherit_overflow.rs             |  14 +
 tests/codegen-llvm/inline-always-works-always.rs   |  21 +
 tests/codegen-llvm/inline-debuginfo.rs             |  17 +
 .../inline-function-args-debug-info.rs             |  23 +
 tests/codegen-llvm/inline-hint.rs                  |  31 +
 .../instrument-coverage/instrument-coverage-off.rs |  21 +
 .../instrument-coverage/instrument-coverage.rs     |  22 +
 tests/codegen-llvm/instrument-coverage/testprog.rs | 118 ++++
 tests/codegen-llvm/instrument-mcount.rs            |   7 +
 tests/codegen-llvm/instrument-xray/basic.rs        |   9 +
 .../instrument-xray/options-combine.rs             |  12 +
 .../instrument-xray/options-override.rs            |  11 +
 tests/codegen-llvm/integer-cmp.rs                  |  62 ++
 tests/codegen-llvm/integer-overflow.rs             |  24 +
 tests/codegen-llvm/internalize-closures.rs         |  13 +
 tests/codegen-llvm/intrinsic-no-unnamed-attr.rs    |  13 +
 .../intrinsics/aggregate-thin-pointer.rs           |  23 +
 tests/codegen-llvm/intrinsics/carrying_mul_add.rs  | 136 ++++
 tests/codegen-llvm/intrinsics/cold_path.rs         |  13 +
 tests/codegen-llvm/intrinsics/cold_path2.rs        |  37 +
 tests/codegen-llvm/intrinsics/cold_path3.rs        |  87 +++
 tests/codegen-llvm/intrinsics/compare_bytes.rs     |  34 +
 tests/codegen-llvm/intrinsics/const_eval_select.rs |  22 +
 tests/codegen-llvm/intrinsics/ctlz.rs              |  56 ++
 tests/codegen-llvm/intrinsics/ctpop.rs             |  31 +
 tests/codegen-llvm/intrinsics/disjoint_bitor.rs    |  30 +
 tests/codegen-llvm/intrinsics/exact_div.rs         |  20 +
 tests/codegen-llvm/intrinsics/likely.rs            |  35 +
 tests/codegen-llvm/intrinsics/likely_assert.rs     |  17 +
 tests/codegen-llvm/intrinsics/mask.rs              |  12 +
 tests/codegen-llvm/intrinsics/nontemporal.rs       |  32 +
 tests/codegen-llvm/intrinsics/offset.rs            |  33 +
 tests/codegen-llvm/intrinsics/offset_from.rs       |  36 +
 tests/codegen-llvm/intrinsics/prefetch.rs          |  64 ++
 tests/codegen-llvm/intrinsics/ptr_metadata.rs      |  36 +
 tests/codegen-llvm/intrinsics/rotate_left.rs       |  31 +
 .../rustc_intrinsic_must_be_overridden.rs          |  14 +
 .../intrinsics/select_unpredictable.rs             |  71 ++
 tests/codegen-llvm/intrinsics/three_way_compare.rs |  28 +
 tests/codegen-llvm/intrinsics/transmute-niched.rs  | 223 ++++++
 tests/codegen-llvm/intrinsics/transmute-x64.rs     |  28 +
 tests/codegen-llvm/intrinsics/transmute.rs         | 497 +++++++++++++
 tests/codegen-llvm/intrinsics/typed_swap.rs        |  77 ++
 tests/codegen-llvm/intrinsics/unchecked_math.rs    |  46 ++
 tests/codegen-llvm/intrinsics/unlikely.rs          |  35 +
 tests/codegen-llvm/intrinsics/volatile.rs          |  55 ++
 tests/codegen-llvm/intrinsics/volatile_order.rs    |  18 +
 tests/codegen-llvm/is_val_statically_known.rs      | 163 +++++
 tests/codegen-llvm/issue-97217.rs                  |  20 +
 tests/codegen-llvm/issues/issue-101048.rs          |  12 +
 tests/codegen-llvm/issues/issue-101082.rs          |  42 ++
 tests/codegen-llvm/issues/issue-101814.rs          |  18 +
 tests/codegen-llvm/issues/issue-103132.rs          |  15 +
 .../issues/issue-103285-ptr-addr-overflow-check.rs |  15 +
 tests/codegen-llvm/issues/issue-103327.rs          |  13 +
 tests/codegen-llvm/issues/issue-103840.rs          |   9 +
 .../issues/issue-105386-ub-in-debuginfo.rs         |  24 +
 tests/codegen-llvm/issues/issue-106369.rs          |  14 +
 .../issues/issue-107681-unwrap_unchecked.rs        |  19 +
 .../issues/issue-108395-branchy-bool-match.rs      |  27 +
 .../issues/issue-109328-split_first.rs             |  16 +
 .../issues/issue-110797-enum-jump-same.rs          |  25 +
 tests/codegen-llvm/issues/issue-111603.rs          |  40 ++
 .../issues/issue-112509-slice-get-andthen-get.rs   |  16 +
 .../issue-113757-bounds-check-after-cmp-max.rs     |  18 +
 tests/codegen-llvm/issues/issue-114312.rs          |  25 +
 .../issues/issue-115385-llvm-jump-threading.rs     |  46 ++
 tests/codegen-llvm/issues/issue-116878.rs          |  11 +
 tests/codegen-llvm/issues/issue-118306.rs          |  22 +
 tests/codegen-llvm/issues/issue-118392.rs          |  10 +
 tests/codegen-llvm/issues/issue-119422.rs          |  83 +++
 .../issues/issue-121719-common-field-offset.rs     |  44 ++
 .../issues/issue-122600-ptr-discriminant-update.rs |  43 ++
 .../issue-123712-str-to-lower-autovectorization.rs |  23 +
 tests/codegen-llvm/issues/issue-126585.rs          |  23 +
 tests/codegen-llvm/issues/issue-129795.rs          |  17 +
 tests/codegen-llvm/issues/issue-13018.rs           |  14 +
 .../issues/issue-136329-optnone-noinline.rs        |  21 +
 tests/codegen-llvm/issues/issue-15953.rs           |  29 +
 tests/codegen-llvm/issues/issue-27130.rs           |  21 +
 tests/codegen-llvm/issues/issue-32031.rs           |  29 +
 tests/codegen-llvm/issues/issue-32364.rs           |  17 +
 tests/codegen-llvm/issues/issue-34634.rs           |  16 +
 tests/codegen-llvm/issues/issue-34947-pow-i32.rs   |  13 +
 .../issues/issue-36010-some-box-is_some.rs         |  28 +
 tests/codegen-llvm/issues/issue-37945.rs           |  34 +
 tests/codegen-llvm/issues/issue-45222.rs           |  62 ++
 tests/codegen-llvm/issues/issue-45466.rs           |  14 +
 .../issues/issue-45964-bounds-check-slice-pos.rs   |  38 +
 tests/codegen-llvm/issues/issue-47278.rs           |  11 +
 tests/codegen-llvm/issues/issue-47442.rs           |  22 +
 tests/codegen-llvm/issues/issue-56267-2.rs         |  18 +
 tests/codegen-llvm/issues/issue-56267.rs           |  18 +
 tests/codegen-llvm/issues/issue-56927.rs           |  46 ++
 tests/codegen-llvm/issues/issue-58881.rs           |  20 +
 tests/codegen-llvm/issues/issue-59352.rs           |  18 +
 ...4219-fn-ptr-call-returning-never-is-noreturn.rs |  19 +
 .../issues/issue-68667-unwrap-combinators.rs       |  15 +
 .../issues/issue-69101-bounds-check.rs             |  42 ++
 tests/codegen-llvm/issues/issue-73031.rs           |  22 +
 tests/codegen-llvm/issues/issue-73258.rs           |  40 ++
 .../issues/issue-73338-effecient-cmp.rs            |  39 ++
 .../issue-73396-bounds-check-after-position.rs     |  70 ++
 .../issue-73827-bounds-check-index-in-subexpr.rs   |  17 +
 .../issues/issue-74938-array-split-at.rs           |  14 +
 .../issues/issue-75525-bounds-checks.rs            |  26 +
 tests/codegen-llvm/issues/issue-75546.rs           |  17 +
 tests/codegen-llvm/issues/issue-75659.rs           |  63 ++
 tests/codegen-llvm/issues/issue-75978.rs           |  18 +
 tests/codegen-llvm/issues/issue-77812.rs           |  32 +
 tests/codegen-llvm/issues/issue-84268.rs           |  18 +
 .../issues/issue-85872-multiple-reverse.rs         |  19 +
 tests/codegen-llvm/issues/issue-86106.rs           |  63 ++
 .../issue-86109-eliminate-div-by-zero-check.rs     |  26 +
 .../issues/issue-93036-assert-index.rs             |  14 +
 tests/codegen-llvm/issues/issue-96274.rs           |  15 +
 .../issues/issue-96497-slice-size-nowrap.rs        |  38 +
 .../issue-98294-get-mut-copy-from-slice-opt.rs     |  17 +
 tests/codegen-llvm/issues/issue-98678-async.rs     |  27 +
 .../issues/issue-98678-closure-coroutine.rs        |  25 +
 tests/codegen-llvm/issues/issue-98678-enum.rs      |  42 ++
 .../issues/issue-98678-struct-union.rs             |  27 +
 tests/codegen-llvm/issues/issue-99960.rs           |  10 +
 .../issues/looping-over-ne-bytes-133528.rs         |  17 +
 tests/codegen-llvm/issues/str-to-string-128690.rs  |  38 +
 tests/codegen-llvm/iter-repeat-n-trivial-drop.rs   |  70 ++
 tests/codegen-llvm/layout-size-checks.rs           |  30 +
 tests/codegen-llvm/lib-optimizations/iter-sum.rs   |  13 +
 .../codegen-llvm/lib-optimizations/slice_rotate.rs |  30 +
 tests/codegen-llvm/lifetime_start_end.rs           |  34 +
 tests/codegen-llvm/link-dead-code.rs               |  28 +
 tests/codegen-llvm/link_section.rs                 |  35 +
 tests/codegen-llvm/llvm-ident.rs                   |  15 +
 tests/codegen-llvm/llvm_module_flags.rs            |   7 +
 tests/codegen-llvm/loads.rs                        | 152 ++++
 .../local-generics-in-exe-internalized.rs          |  14 +
 .../loongarch-abi/call-llvm-intrinsics.rs          |  31 +
 .../loongarch-abi/loongarch64-lp64d-abi.rs         | 299 ++++++++
 tests/codegen-llvm/lto-removes-invokes.rs          |  21 +
 .../macos/i686-macosx-deployment-target.rs         |  23 +
 .../macos/i686-no-macosx-deployment-target.rs      |  23 +
 .../macos/x86_64-macosx-deployment-target.rs       |  23 +
 .../macos/x86_64-no-macosx-deployment-target.rs    |  23 +
 tests/codegen-llvm/mainsubprogram.rs               |  12 +
 tests/codegen-llvm/match-optimized.rs              |  60 ++
 tests/codegen-llvm/match-optimizes-away.rs         |  41 ++
 tests/codegen-llvm/match-unoptimized.rs            |  23 +
 tests/codegen-llvm/maybeuninit-rvo.rs              |  34 +
 tests/codegen-llvm/mem-replace-big-type.rs         |  36 +
 tests/codegen-llvm/mem-replace-simple-type.rs      |  54 ++
 tests/codegen-llvm/merge-functions.rs              |  16 +
 tests/codegen-llvm/meta-filecheck/check-prefix.rs  |   4 +
 .../codegen-llvm/meta-filecheck/filecheck-flags.rs |   8 +
 .../codegen-llvm/meta-filecheck/msvc-prefix-bad.rs |   7 +
 tests/codegen-llvm/meta-filecheck/no-directives.rs |   5 +
 .../codegen-llvm/meta-filecheck/revision-prefix.rs |   8 +
 tests/codegen-llvm/method-declaration.rs           |  26 +
 tests/codegen-llvm/min-function-alignment.rs       |  48 ++
 tests/codegen-llvm/mir-aggregate-no-alloca.rs      | 137 ++++
 tests/codegen-llvm/mir-inlined-line-numbers.rs     |  25 +
 tests/codegen-llvm/mir_zst_stores.rs               |  19 +
 .../codegen-llvm/move-before-nocapture-ref-arg.rs  |  21 +
 tests/codegen-llvm/move-operands.rs                |  13 +
 tests/codegen-llvm/naked-asan.rs                   |  30 +
 tests/codegen-llvm/naked-fn/aligned.rs             |  21 +
 tests/codegen-llvm/naked-fn/generics.rs            | 111 +++
 tests/codegen-llvm/naked-fn/instruction-set.rs     |  53 ++
 .../naked-fn/min-function-alignment.rs             |  47 ++
 tests/codegen-llvm/naked-fn/naked-functions.rs     | 165 +++++
 tests/codegen-llvm/no-alloca-inside-if-false.rs    |  27 +
 tests/codegen-llvm/no-assumes-on-casts.rs          |  19 +
 .../codegen-llvm/no-dllimport-w-cross-lang-lto.rs  |  13 +
 tests/codegen-llvm/no-jump-tables.rs               |  23 +
 tests/codegen-llvm/no-plt.rs                       |  17 +
 .../no-redundant-item-monomorphization.rs          |  33 +
 tests/codegen-llvm/no_builtins-at-crate.rs         |  24 +
 tests/codegen-llvm/noalias-box-off.rs              |  11 +
 tests/codegen-llvm/noalias-box.rs                  |   8 +
 tests/codegen-llvm/noalias-flag.rs                 |  23 +
 tests/codegen-llvm/noalias-freeze.rs               |  23 +
 tests/codegen-llvm/noalias-refcell.rs              |  14 +
 tests/codegen-llvm/noalias-rwlockreadguard.rs      |  14 +
 tests/codegen-llvm/noalias-unpin.rs                |  15 +
 .../codegen-llvm/non-terminate/infinite-loop-1.rs  |  17 +
 .../codegen-llvm/non-terminate/infinite-loop-2.rs  |  19 +
 .../non-terminate/infinite-recursion.rs            |  13 +
 .../non-terminate/nonempty-infinite-loop.rs        |  28 +
 tests/codegen-llvm/noreturn-uninhabited.rs         |  31 +
 tests/codegen-llvm/noreturnflag.rs                 |  22 +
 tests/codegen-llvm/nounwind.rs                     |  15 +
 tests/codegen-llvm/nrvo.rs                         |  17 +
 tests/codegen-llvm/optimize-attr-1.rs              |  59 ++
 tests/codegen-llvm/option-as-slice.rs              |  71 ++
 tests/codegen-llvm/option-niche-eq.rs              |  87 +++
 .../option-niche-unfixed/option-nonzero-eq.rs      |  24 +
 tests/codegen-llvm/overaligned-constant.rs         |  35 +
 tests/codegen-llvm/packed.rs                       | 153 ++++
 tests/codegen-llvm/panic-abort-windows.rs          |  16 +
 tests/codegen-llvm/panic-in-drop-abort.rs          |  57 ++
 tests/codegen-llvm/panic-unwind-default-uwtable.rs |   6 +
 .../patchable-function-entry-both-flags.rs         |  64 ++
 .../patchable-function-entry-no-flag.rs            |  39 ++
 .../patchable-function-entry-one-flag.rs           |  66 ++
 tests/codegen-llvm/pattern_type_symbols.rs         |  22 +
 tests/codegen-llvm/personality_lifetimes.rs        |  32 +
 tests/codegen-llvm/pgo-counter-bias.rs             |  10 +
 tests/codegen-llvm/pgo-instrumentation.rs          |  20 +
 tests/codegen-llvm/pic-relocation-model.rs         |  19 +
 tests/codegen-llvm/pie-relocation-model.rs         |  22 +
 tests/codegen-llvm/placement-new.rs                |  39 ++
 tests/codegen-llvm/powerpc64le-struct-align-128.rs |  96 +++
 tests/codegen-llvm/precondition-checks.rs          |  25 +
 tests/codegen-llvm/ptr-arithmetic.rs               |  33 +
 tests/codegen-llvm/ptr-read-metadata.rs            |  94 +++
 tests/codegen-llvm/range-attribute.rs              |  74 ++
 tests/codegen-llvm/range-loop.rs                   |  44 ++
 tests/codegen-llvm/range_to_inclusive.rs           |  28 +
 tests/codegen-llvm/refs.rs                         |  21 +
 tests/codegen-llvm/reg-struct-return.rs            | 206 ++++++
 tests/codegen-llvm/regparm-inreg.rs                | 125 ++++
 tests/codegen-llvm/remap_path_prefix/aux_mod.rs    |   6 +
 .../auxiliary/remap_path_prefix_aux.rs             |   8 +
 .../remap_path_prefix/auxiliary/xcrate-generic.rs  |   8 +
 .../remap_path_prefix/issue-73167-remap-std.rs     |  15 +
 tests/codegen-llvm/remap_path_prefix/main.rs       |  28 +
 .../remap_path_prefix/xcrate-generic.rs            |  14 +
 tests/codegen-llvm/repeat-operand-zero-len.rs      |  28 +
 tests/codegen-llvm/repeat-operand-zst-elem.rs      |  28 +
 tests/codegen-llvm/repeat-trusted-len.rs           |  20 +
 .../repr/transparent-byval-struct-ptr.rs           | 111 +++
 tests/codegen-llvm/repr/transparent-imm-array.rs   | 116 +++
 tests/codegen-llvm/repr/transparent-mips64.rs      | 103 +++
 tests/codegen-llvm/repr/transparent-opaque-ptr.rs  | 109 +++
 tests/codegen-llvm/repr/transparent-sparc64.rs     | 113 +++
 tests/codegen-llvm/repr/transparent-sysv64.rs      |  49 ++
 tests/codegen-llvm/repr/transparent.rs             | 221 ++++++
 tests/codegen-llvm/retpoline.rs                    |  27 +
 .../codegen-llvm/riscv-abi/call-llvm-intrinsics.rs |  30 +
 .../riscv-abi/cast-local-large-enough.rs           |  44 ++
 .../riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs      | 176 +++++
 tests/codegen-llvm/riscv-abi/riscv64-lp64d-abi.rs  | 299 ++++++++
 .../riscv-abi/riscv64-lp64f-lp64d-abi.rs           | 283 ++++++++
 tests/codegen-llvm/riscv-target-abi.rs             |  21 +
 .../rust-abi-arch-specific-adjustment.rs           | 111 +++
 tests/codegen-llvm/s390x-simd.rs                   | 143 ++++
 .../aarch64-shadow-call-stack-with-fixed-x18.rs    |  20 +
 .../address-sanitizer-globals-tracking.rs          |  44 ++
 .../cfi/add-canonical-jump-tables-flag.rs          |  10 +
 .../cfi/add-cfi-normalize-integers-flag.rs         |  10 +
 .../cfi/add-enable-split-lto-unit-flag.rs          |  10 +
 .../sanitizer/cfi/dbg-location-on-cfi-blocks.rs    |  19 +
 .../cfi/emit-type-checks-attr-no-sanitize.rs       |  18 +
 .../codegen-llvm/sanitizer/cfi/emit-type-checks.rs |  19 +
 .../cfi/emit-type-metadata-attr-cfi-encoding.rs    |  73 ++
 ...e-metadata-id-itanium-cxx-abi-const-generics.rs |  32 +
 ...pe-metadata-id-itanium-cxx-abi-drop-in-place.rs |  31 +
 ...e-metadata-id-itanium-cxx-abi-function-types.rs |  45 ++
 ...t-type-metadata-id-itanium-cxx-abi-lifetimes.rs |  29 +
 ...a-id-itanium-cxx-abi-method-secondary-typeid.rs |  21 +
 .../emit-type-metadata-id-itanium-cxx-abi-paths.rs |  86 +++
 ...pe-metadata-id-itanium-cxx-abi-pointer-types.rs |  54 ++
 ...-metadata-id-itanium-cxx-abi-primitive-types.rs | 190 +++++
 ...ta-id-itanium-cxx-abi-repr-transparent-types.rs |  79 +++
 ...e-metadata-id-itanium-cxx-abi-sequence-types.rs |  36 +
 ...type-metadata-id-itanium-cxx-abi-trait-types.rs | 175 +++++
 ...tadata-id-itanium-cxx-abi-user-defined-types.rs |  62 ++
 ...it-type-metadata-itanium-cxx-abi-generalized.rs |  31 +
 ...adata-itanium-cxx-abi-normalized-generalized.rs |  31 +
 ...mit-type-metadata-itanium-cxx-abi-normalized.rs |  31 +
 .../cfi/emit-type-metadata-itanium-cxx-abi.rs      |  31 +
 .../cfi/emit-type-metadata-trait-objects.rs        | 145 ++++
 .../sanitizer/cfi/external_weak_symbols.rs         |  24 +
 .../sanitizer/cfi/generalize-pointers.rs           |  46 ++
 .../sanitizer/cfi/normalize-integers.rs            |  46 ++
 .../sanitizer/dataflow-instrument-functions.rs     |   9 +
 .../sanitizer/kasan-emits-instrumentation.rs       |  41 ++
 .../kcfi/add-cfi-normalize-integers-flag.rs        |  20 +
 .../sanitizer/kcfi/add-kcfi-arity-flag.rs          |  19 +
 tests/codegen-llvm/sanitizer/kcfi/add-kcfi-flag.rs |  20 +
 .../sanitizer/kcfi/add-kcfi-offset-flag.rs         |  20 +
 .../emit-kcfi-operand-bundle-attr-no-sanitize.rs   |  27 +
 ...i-operand-bundle-itanium-cxx-abi-generalized.rs |  41 ++
 ...undle-itanium-cxx-abi-normalized-generalized.rs |  41 ++
 ...fi-operand-bundle-itanium-cxx-abi-normalized.rs |  41 ++
 .../emit-kcfi-operand-bundle-itanium-cxx-abi.rs    |  41 ++
 .../sanitizer/kcfi/emit-kcfi-operand-bundle.rs     |  24 +
 .../kcfi/emit-type-metadata-trait-objects.rs       | 155 ++++
 .../codegen-llvm/sanitizer/kcfi/naked-function.rs  |  47 ++
 .../codegen-llvm/sanitizer/memory-track-origins.rs |  31 +
 tests/codegen-llvm/sanitizer/memtag-attr-check.rs  |  12 +
 .../codegen-llvm/sanitizer/no-sanitize-inlining.rs |  31 +
 tests/codegen-llvm/sanitizer/no-sanitize.rs        |  39 ++
 .../sanitizer/riscv64-shadow-call-stack.rs         |  18 +
 .../codegen-llvm/sanitizer/safestack-attr-check.rs |  11 +
 tests/codegen-llvm/sanitizer/sanitizer-recover.rs  |  50 ++
 tests/codegen-llvm/sanitizer/scs-attr-check.rs     |  17 +
 tests/codegen-llvm/scalar-pair-bool.rs             |  45 ++
 tests/codegen-llvm/set-discriminant-invalid.rs     |  34 +
 .../simd-intrinsic/simd-intrinsic-float-abs.rs     |  60 ++
 .../simd-intrinsic/simd-intrinsic-float-ceil.rs    |  60 ++
 .../simd-intrinsic/simd-intrinsic-float-cos.rs     |  60 ++
 .../simd-intrinsic/simd-intrinsic-float-exp.rs     |  60 ++
 .../simd-intrinsic/simd-intrinsic-float-exp2.rs    |  60 ++
 .../simd-intrinsic/simd-intrinsic-float-floor.rs   |  60 ++
 .../simd-intrinsic/simd-intrinsic-float-fma.rs     |  60 ++
 .../simd-intrinsic/simd-intrinsic-float-fsqrt.rs   |  60 ++
 .../simd-intrinsic/simd-intrinsic-float-log.rs     |  60 ++
 .../simd-intrinsic/simd-intrinsic-float-log10.rs   |  60 ++
 .../simd-intrinsic/simd-intrinsic-float-log2.rs    |  60 ++
 .../simd-intrinsic/simd-intrinsic-float-minmax.rs  |  25 +
 .../simd-intrinsic/simd-intrinsic-float-sin.rs     |  60 ++
 ...simd-intrinsic-generic-arithmetic-saturating.rs | 579 +++++++++++++++
 .../simd-intrinsic-generic-bitmask.rs              |  48 ++
 .../simd-intrinsic-generic-gather.rs               |  55 ++
 .../simd-intrinsic-generic-masked-load.rs          |  49 ++
 .../simd-intrinsic-generic-masked-store.rs         |  41 ++
 .../simd-intrinsic-generic-scatter.rs              |  47 ++
 .../simd-intrinsic-generic-select.rs               |  48 ++
 .../simd-intrinsic/simd-intrinsic-mask-reduce.rs   |  60 ++
 .../simd-intrinsic-transmute-array.rs              |  58 ++
 tests/codegen-llvm/simd/aggregate-simd.rs          | 102 +++
 tests/codegen-llvm/simd/extract-insert-dyn.rs      | 121 ++++
 tests/codegen-llvm/simd/packed-simd-alignment.rs   |  44 ++
 tests/codegen-llvm/simd/packed-simd.rs             |  56 ++
 tests/codegen-llvm/simd/simd-wide-sum.rs           |  59 ++
 tests/codegen-llvm/simd/simd_arith_offset.rs       |  22 +
 tests/codegen-llvm/simd/swap-simd-types.rs         |  40 ++
 tests/codegen-llvm/simd/unpadded-simd.rs           |  19 +
 tests/codegen-llvm/skip-mono-inside-if-false.rs    |  41 ++
 tests/codegen-llvm/slice-as_chunks.rs              |  30 +
 tests/codegen-llvm/slice-indexing.rs               |  99 +++
 tests/codegen-llvm/slice-init.rs                   | 108 +++
 tests/codegen-llvm/slice-is-ascii.rs               |  16 +
 tests/codegen-llvm/slice-iter-fold.rs              |  12 +
 tests/codegen-llvm/slice-iter-len-eq-zero.rs       |  60 ++
 tests/codegen-llvm/slice-iter-nonnull.rs           | 115 +++
 .../slice-last-elements-optimization.rs            |  37 +
 tests/codegen-llvm/slice-pointer-nonnull-unwrap.rs |  18 +
 tests/codegen-llvm/slice-position-bounds-check.rs  |  25 +
 tests/codegen-llvm/slice-ref-equality.rs           |  90 +++
 tests/codegen-llvm/slice-reverse.rs                |  27 +
 tests/codegen-llvm/slice-split-at.rs               |  24 +
 .../codegen-llvm/slice-windows-no-bounds-check.rs  |  32 +
 tests/codegen-llvm/slice_as_from_ptr_range.rs      |  21 +
 .../some-abis-do-extend-params-to-32-bits.rs       | 236 +++++++
 tests/codegen-llvm/some-global-nonnull.rs          |  25 +
 tests/codegen-llvm/sparc-struct-abi.rs             |  97 +++
 tests/codegen-llvm/split-lto-unit.rs               |  10 +
 .../src-hash-algorithm/src-hash-algorithm-md5.rs   |   6 +
 .../src-hash-algorithm/src-hash-algorithm-sha1.rs  |   6 +
 .../src-hash-algorithm-sha256.rs                   |   6 +
 tests/codegen-llvm/sroa-fragment-debuginfo.rs      |  46 ++
 tests/codegen-llvm/sse42-implies-crc32.rs          |  15 +
 tests/codegen-llvm/stack-probes-inline.rs          |  33 +
 tests/codegen-llvm/stack-protector.rs              |  34 +
 tests/codegen-llvm/static-relocation-model-msvc.rs |  24 +
 .../codegen-llvm/staticlib-external-inline-fns.rs  |  43 ++
 tests/codegen-llvm/step_by-overflow-checks.rs      |  26 +
 tests/codegen-llvm/stores.rs                       |  35 +
 tests/codegen-llvm/string-push.rs                  |  11 +
 tests/codegen-llvm/swap-large-types.rs             | 116 +++
 tests/codegen-llvm/swap-small-types.rs             | 182 +++++
 tests/codegen-llvm/target-cpu-on-functions.rs      |  22 +
 .../codegen-llvm/target-feature-inline-closure.rs  |  33 +
 .../target-feature-negative-implication.rs         |  20 +
 tests/codegen-llvm/target-feature-overrides.rs     |  46 ++
 tests/codegen-llvm/terminating-catchpad.rs         |  43 ++
 tests/codegen-llvm/thread-local.rs                 |  54 ++
 tests/codegen-llvm/tied-features-strength.rs       |  34 +
 tests/codegen-llvm/to_vec.rs                       |  10 +
 tests/codegen-llvm/trailing_zeros.rs               |  21 +
 tests/codegen-llvm/transmute-optimized.rs          | 120 ++++
 tests/codegen-llvm/transmute-scalar.rs             | 143 ++++
 tests/codegen-llvm/try_question_mark_nop.rs        | 243 +++++++
 tests/codegen-llvm/tune-cpu-on-functions.rs        |  21 +
 tests/codegen-llvm/tuple-layout-opt.rs             |  57 ++
 tests/codegen-llvm/ub-checks.rs                    |  28 +
 tests/codegen-llvm/unchecked-float-casts.rs        |  36 +
 tests/codegen-llvm/unchecked_shifts.rs             | 100 +++
 .../uninhabited-transparent-return-abi.rs          |  44 ++
 tests/codegen-llvm/uninit-consts.rs                |  54 ++
 tests/codegen-llvm/uninit-repeat-in-aggregate.rs   |  21 +
 tests/codegen-llvm/union-abi.rs                    | 145 ++++
 tests/codegen-llvm/union-aggregate.rs              | 108 +++
 tests/codegen-llvm/unwind-abis/aapcs-unwind-abi.rs |  36 +
 .../unwind-abis/c-unwind-abi-panic-abort.rs        |  27 +
 tests/codegen-llvm/unwind-abis/c-unwind-abi.rs     |  27 +
 tests/codegen-llvm/unwind-abis/cdecl-unwind-abi.rs |  27 +
 .../unwind-abis/fastcall-unwind-abi.rs             |  36 +
 .../unwind-abis/nounwind-on-stable-panic-abort.rs  |  15 +
 tests/codegen-llvm/unwind-abis/nounwind.rs         |  16 +
 .../codegen-llvm/unwind-abis/stdcall-unwind-abi.rs |  36 +
 .../codegen-llvm/unwind-abis/system-unwind-abi.rs  |  27 +
 .../codegen-llvm/unwind-abis/sysv64-unwind-abi.rs  |  36 +
 .../unwind-abis/thiscall-unwind-abi.rs             |  36 +
 .../unwind-abis/vectorcall-unwind-abi.rs           |  36 +
 tests/codegen-llvm/unwind-abis/win64-unwind-abi.rs |  36 +
 tests/codegen-llvm/unwind-and-panic-abort.rs       |  16 +
 tests/codegen-llvm/unwind-extern-exports.rs        |  15 +
 tests/codegen-llvm/unwind-extern-imports.rs        |  21 +
 tests/codegen-llvm/unwind-landingpad-cold.rs       |  15 +
 tests/codegen-llvm/unwind-landingpad-inline.rs     |  39 ++
 tests/codegen-llvm/used_with_arg.rs                |  10 +
 tests/codegen-llvm/var-names.rs                    |  15 +
 tests/codegen-llvm/vec-as-ptr.rs                   |  19 +
 tests/codegen-llvm/vec-calloc.rs                   | 182 +++++
 tests/codegen-llvm/vec-in-place.rs                 | 161 +++++
 tests/codegen-llvm/vec-iter-collect-len.rs         |  12 +
 tests/codegen-llvm/vec-iter.rs                     |  58 ++
 tests/codegen-llvm/vec-len-invariant.rs            |  16 +
 tests/codegen-llvm/vec-optimizes-away.rs           |  12 +
 tests/codegen-llvm/vec-reserve-extend.rs           |  14 +
 tests/codegen-llvm/vec-shrink-panik.rs             |  31 +
 tests/codegen-llvm/vec-with-capacity.rs            |  35 +
 tests/codegen-llvm/vec_pop_push_noop.rs            |  24 +
 tests/codegen-llvm/vecdeque-drain.rs               |  70 ++
 .../codegen-llvm/vecdeque-nonempty-get-no-panic.rs |  16 +
 tests/codegen-llvm/vecdeque_no_panic.rs            |  19 +
 tests/codegen-llvm/vecdeque_pop_push.rs            |  67 ++
 .../virtual-call-attrs-issue-137646.rs             |  37 +
 .../virtual-function-elimination-32bit.rs          |  35 +
 tests/codegen-llvm/virtual-function-elimination.rs |  98 +++
 tests/codegen-llvm/vtable-loads.rs                 |  16 +
 tests/codegen-llvm/vtable-upcast.rs                |  84 +++
 tests/codegen-llvm/wasm_casts_trapping.rs          | 157 +++++
 tests/codegen-llvm/wasm_exceptions.rs              |  59 ++
 tests/codegen-llvm/zip.rs                          |  21 +
 tests/codegen-llvm/zst-offset.rs                   |  42 ++
 tests/codegen/README.md                            |  24 -
 tests/codegen/aarch64-softfloat.rs                 |  45 --
 tests/codegen/aarch64-struct-align-128.rs          | 145 ----
 tests/codegen/abi-efiapi.rs                        |  30 -
 tests/codegen/abi-main-signature-16bit-c-int.rs    |  11 -
 tests/codegen/abi-main-signature-32bit-c-int.rs    |  11 -
 tests/codegen/abi-repr-ext.rs                      |  56 --
 tests/codegen/abi-sysv64.rs                        |  20 -
 tests/codegen/abi-win64-zst.rs                     |  54 --
 tests/codegen/abi-x86-interrupt.rs                 |  18 -
 tests/codegen/abi-x86-sse.rs                       |  43 --
 tests/codegen/abi-x86_64_sysv.rs                   |  29 -
 tests/codegen/addr-of-mutate.rs                    |  33 -
 tests/codegen/adjustments.rs                       |  28 -
 tests/codegen/align-byval-alignment-mismatch.rs    | 126 ----
 tests/codegen/align-byval-vector.rs                |  55 --
 tests/codegen/align-byval.rs                       | 315 ---------
 tests/codegen/align-enum.rs                        |  33 -
 tests/codegen/align-fn.rs                          | 143 ----
 tests/codegen/align-offset.rs                      |  75 --
 tests/codegen/align-struct.rs                      |  70 --
 tests/codegen/alloc-optimisation.rs                |  13 -
 tests/codegen/amdgpu-addrspacecast.rs              |  18 -
 tests/codegen/array-clone.rs                       |  15 -
 tests/codegen/array-cmp.rs                         |  74 --
 tests/codegen/array-codegen.rs                     |  62 --
 tests/codegen/array-equality.rs                    | 101 ---
 tests/codegen/array-from_fn.rs                     |  13 -
 tests/codegen/array-map.rs                         |  35 -
 tests/codegen/array-optimized.rs                   |  33 -
 tests/codegen/array-repeat.rs                      |  15 -
 tests/codegen/ascii-char.rs                        |  36 -
 tests/codegen/asm/aarch64-clobbers.rs              |  47 --
 tests/codegen/asm/avr-clobbers.rs                  |  39 --
 tests/codegen/asm/bpf-clobbers.rs                  |  31 -
 tests/codegen/asm/critical.rs                      |  36 -
 tests/codegen/asm/csky-clobbers.rs                 |  24 -
 tests/codegen/asm/foo.s                            |   3 -
 tests/codegen/asm/global_asm.rs                    |  28 -
 tests/codegen/asm/global_asm_include.rs            |  21 -
 tests/codegen/asm/global_asm_x2.rs                 |  47 --
 tests/codegen/asm/goto.rs                          |  63 --
 tests/codegen/asm/hexagon-clobbers.rs              |  33 -
 tests/codegen/asm/may_unwind.rs                    |  39 --
 tests/codegen/asm/maybe-uninit.rs                  |  27 -
 tests/codegen/asm/msp430-clobbers.rs               |  32 -
 tests/codegen/asm/multiple-options.rs              |  54 --
 tests/codegen/asm/options.rs                       | 104 ---
 tests/codegen/asm/powerpc-clobbers.rs              |  68 --
 tests/codegen/asm/riscv-clobbers.rs                |  40 --
 tests/codegen/asm/s390x-clobbers.rs                |  46 --
 tests/codegen/asm/sanitize-llvm.rs                 |  24 -
 tests/codegen/asm/sparc-clobbers.rs                |  36 -
 tests/codegen/asm/x86-clobber_abi.rs               |  36 -
 tests/codegen/asm/x86-clobbers.rs                  |  20 -
 tests/codegen/asm/x86-target-clobbers.rs           |  29 -
 tests/codegen/assign-desugar-debuginfo.rs          |  18 -
 tests/codegen/async-closure-debug.rs               |  20 -
 tests/codegen/async-fn-debug-awaitee-field.rs      |  28 -
 tests/codegen/async-fn-debug-msvc.rs               |  55 --
 tests/codegen/async-fn-debug.rs                    |  59 --
 tests/codegen/atomic-operations.rs                 |  84 ---
 tests/codegen/atomicptr.rs                         |  36 -
 tests/codegen/autodiff/batched.rs                  | 116 ---
 tests/codegen/autodiff/generic.rs                  |  42 --
 tests/codegen/autodiff/identical_fnc.rs            |  45 --
 tests/codegen/autodiff/inline.rs                   |  23 -
 tests/codegen/autodiff/scalar.rs                   |  33 -
 tests/codegen/autodiff/sret.rs                     |  45 --
 tests/codegen/autodiffv2.rs                        | 113 ---
 tests/codegen/autovec/dont-shuffle-bswaps-opt2.rs  |  31 -
 tests/codegen/autovec/dont-shuffle-bswaps-opt3.rs  |  42 --
 tests/codegen/autovectorize-f32x4.rs               |  37 -
 tests/codegen/auxiliary/extern_decl.rs             |  13 -
 tests/codegen/auxiliary/nounwind.rs                |   2 -
 tests/codegen/auxiliary/thread_local_aux.rs        |   5 -
 tests/codegen/avr/avr-func-addrspace.rs            | 106 ---
 tests/codegen/bigint-helpers.rs                    |  13 -
 tests/codegen/binary-heap-peek-mut-pop-no-panic.rs |  13 -
 .../codegen/binary-search-index-no-bound-check.rs  |  35 -
 tests/codegen/bool-cmp.rs                          |  18 -
 tests/codegen/bounds-checking/gep-issue-133979.rs  |  22 -
 tests/codegen/box-default-debug-copies.rs          |  28 -
 tests/codegen/box-uninit-bytes.rs                  |  46 --
 tests/codegen/bpf-alu32.rs                         |  11 -
 tests/codegen/branch-protection.rs                 |  94 ---
 tests/codegen/call-llvm-intrinsics.rs              |  30 -
 tests/codegen/call-tmps-lifetime.rs                |  68 --
 tests/codegen/cast-optimized.rs                    |  33 -
 tests/codegen/cast-target-abi.rs                   | 599 ----------------
 tests/codegen/catch-unwind.rs                      |  32 -
 tests/codegen/cdylib-external-inline-fns.rs        |  43 --
 tests/codegen/cf-protection.rs                     |  38 -
 tests/codegen/cffi/c-variadic-copy.rs              |  16 -
 tests/codegen/cffi/c-variadic-naked.rs             |  15 -
 tests/codegen/cffi/c-variadic-opt.rs               |  30 -
 tests/codegen/cffi/c-variadic.rs                   |  71 --
 tests/codegen/cffi/ffi-const.rs                    |  15 -
 tests/codegen/cffi/ffi-out-of-bounds-loads.rs      |  41 --
 tests/codegen/cffi/ffi-pure.rs                     |  15 -
 tests/codegen/cfguard-checks.rs                    |  10 -
 tests/codegen/cfguard-disabled.rs                  |  10 -
 tests/codegen/cfguard-nochecks.rs                  |  10 -
 tests/codegen/cfguard-non-msvc.rs                  |  10 -
 tests/codegen/char-ascii-branchless.rs             |  47 --
 tests/codegen/char-escape-debug-no-bounds-check.rs |  14 -
 tests/codegen/checked_ilog.rs                      |  20 -
 tests/codegen/checked_math.rs                      | 100 ---
 tests/codegen/clone-shims.rs                       |  15 -
 tests/codegen/clone_as_copy.rs                     |  40 --
 tests/codegen/codemodels.rs                        |  20 -
 tests/codegen/coercions.rs                         |  19 -
 tests/codegen/cold-call-declare-and-call.rs        |  27 -
 tests/codegen/common_prim_int_ptr.rs               |  51 --
 tests/codegen/comparison-operators-2-struct.rs     |  61 --
 tests/codegen/comparison-operators-2-tuple.rs      | 117 ----
 tests/codegen/comparison-operators-newtype.rs      |  48 --
 .../compiletest-self-test/minicore-smoke-test.rs   |  20 -
 tests/codegen/const-array.rs                       |  15 -
 tests/codegen/const-vector.rs                      |  78 ---
 tests/codegen/const_scalar_pair.rs                 |   8 -
 tests/codegen/constant-branch.rs                   |  49 --
 tests/codegen/consts.rs                            |  55 --
 tests/codegen/coroutine-debug-msvc.rs              |  60 --
 tests/codegen/coroutine-debug.rs                   |  64 --
 .../codegen/cross-crate-inlining/always-inline.rs  |  13 -
 .../cross-crate-inlining/auxiliary/always.rs       |  20 -
 .../codegen/cross-crate-inlining/auxiliary/leaf.rs |  20 -
 .../cross-crate-inlining/auxiliary/never.rs        |  20 -
 .../codegen/cross-crate-inlining/leaf-inlining.rs  |  20 -
 tests/codegen/cross-crate-inlining/never-inline.rs |  13 -
 tests/codegen/dealloc-no-unwind.rs                 |  25 -
 tests/codegen/debug-accessibility/crate-enum.rs    |  28 -
 tests/codegen/debug-accessibility/crate-struct.rs  |  23 -
 tests/codegen/debug-accessibility/private-enum.rs  |  22 -
 .../codegen/debug-accessibility/private-struct.rs  |  17 -
 tests/codegen/debug-accessibility/public-enum.rs   |  23 -
 tests/codegen/debug-accessibility/public-struct.rs |  17 -
 tests/codegen/debug-accessibility/struct-fields.rs |  30 -
 tests/codegen/debug-accessibility/super-enum.rs    |  28 -
 tests/codegen/debug-accessibility/super-struct.rs  |  23 -
 tests/codegen/debug-accessibility/tuple-fields.rs  |  24 -
 tests/codegen/debug-alignment.rs                   |   8 -
 tests/codegen/debug-column-msvc.rs                 |  16 -
 tests/codegen/debug-column.rs                      |  25 -
 tests/codegen/debug-compile-unit-path.rs           |   9 -
 tests/codegen/debug-fndef-size.rs                  |  20 -
 tests/codegen/debug-limited.rs                     |  27 -
 tests/codegen/debug-line-directives-only.rs        |  27 -
 tests/codegen/debug-line-tables-only.rs            |  27 -
 tests/codegen/debug-linkage-name.rs                |  42 --
 tests/codegen/debug-vtable.rs                      | 117 ----
 tests/codegen/debuginfo-constant-locals.rs         |  28 -
 .../codegen/debuginfo-generic-closure-env-names.rs |  90 ---
 .../codegen/debuginfo-inline-callsite-location.rs  |  27 -
 .../debuginfo-proc-macro/auxiliary/macro_def.rs    |   7 -
 .../mir_inlined_twice_var_locs.rs                  |  52 --
 tests/codegen/deduced-param-attrs.rs               |  60 --
 tests/codegen/default-requires-uwtable.rs          |  17 -
 tests/codegen/default-visibility.rs                |  49 --
 tests/codegen/direct-access-external-data.rs       |  21 -
 tests/codegen/dllimports/auxiliary/dummy.rs        |   6 -
 tests/codegen/dllimports/auxiliary/wrapper.rs      |  14 -
 tests/codegen/dllimports/main.rs                   |  43 --
 ...gen_private_const_fn_only_used_in_const_eval.rs |  27 -
 tests/codegen/drop-in-place-noalias.rs             |  38 -
 tests/codegen/drop.rs                              |  36 -
 tests/codegen/dst-offset.rs                        |  84 ---
 tests/codegen/dst-vtable-align-nonzero.rs          |  67 --
 tests/codegen/dst-vtable-size-range.rs             |  35 -
 tests/codegen/ehcontguard_disabled.rs              |   9 -
 tests/codegen/ehcontguard_enabled.rs               |   9 -
 tests/codegen/emscripten-catch-unwind-js-eh.rs     |  71 --
 tests/codegen/emscripten-catch-unwind-wasm-eh.rs   |  69 --
 tests/codegen/enable-lto-unit-splitting.rs         |   9 -
 tests/codegen/enum/enum-aggregate.rs               | 126 ----
 .../codegen/enum/enum-bounds-check-derived-idx.rs  |  24 -
 .../codegen/enum/enum-bounds-check-issue-13926.rs  |  18 -
 .../codegen/enum/enum-bounds-check-issue-82871.rs  |  18 -
 tests/codegen/enum/enum-bounds-check.rs            |  27 -
 tests/codegen/enum/enum-debug-clike.rs             |  28 -
 tests/codegen/enum/enum-debug-niche-2.rs           |  47 --
 tests/codegen/enum/enum-debug-niche.rs             |  35 -
 tests/codegen/enum/enum-debug-tagged.rs            |  31 -
 tests/codegen/enum/enum-discriminant-eq.rs         | 223 ------
 tests/codegen/enum/enum-discriminant-value.rs      |  27 -
 tests/codegen/enum/enum-early-otherwise-branch.rs  |  25 -
 tests/codegen/enum/enum-match.rs                   | 779 ---------------------
 tests/codegen/enum/enum-two-variants-match.rs      | 130 ----
 tests/codegen/enum/enum-u128.rs                    |  25 -
 .../enum/unreachable_enum_default_branch.rs        |  40 --
 tests/codegen/ergonomic-clones/closure.rs          |  55 --
 tests/codegen/error-provide.rs                     |  50 --
 tests/codegen/export-no-mangle.rs                  |  31 -
 tests/codegen/external-no-mangle-fns.rs            |  75 --
 tests/codegen/external-no-mangle-statics.rs        |  77 --
 tests/codegen/f128-wasm32-callconv.rs              |  49 --
 tests/codegen/fastcall-inreg.rs                    |  40 --
 tests/codegen/fatptr.rs                            |  12 -
 tests/codegen/fewer-names.rs                       |  19 -
 tests/codegen/fixed-x18.rs                         |  23 -
 tests/codegen/float/algebraic.rs                   | 149 ----
 tests/codegen/float/f128.rs                        | 441 ------------
 tests/codegen/float/f16-f128-inline.rs             |  29 -
 tests/codegen/float/f16.rs                         | 364 ----------
 tests/codegen/float_math.rs                        |  87 ---
 tests/codegen/fn-impl-trait-self.rs                |  17 -
 .../fn-parameters-on-different-lines-debuginfo.rs  |  22 -
 tests/codegen/force-frame-pointers.rs              |  18 -
 tests/codegen/force-no-unwind-tables.rs            |  11 -
 tests/codegen/force-unwind-tables.rs               |   6 -
 tests/codegen/frame-pointer-cli-control.rs         |  61 --
 tests/codegen/frame-pointer.rs                     |  35 -
 tests/codegen/function-arguments-noopt.rs          |  69 --
 tests/codegen/function-arguments.rs                | 278 --------
 tests/codegen/function-return.rs                   |  35 -
 tests/codegen/gdb_debug_script_load.rs             |  37 -
 tests/codegen/generic-debug.rs                     |  17 -
 tests/codegen/gep-index.rs                         |  37 -
 tests/codegen/gpu-kernel-abi.rs                    |  15 -
 tests/codegen/gpu_offload/gpu_host.rs              |  80 ---
 tests/codegen/hint/cold_path.rs                    |  54 --
 tests/codegen/hint/likely.rs                       |  81 ---
 tests/codegen/hint/unlikely.rs                     |  80 ---
 tests/codegen/i128-wasm32-callconv.rs              |  49 --
 tests/codegen/i128-x86-align.rs                    | 105 ---
 tests/codegen/i128-x86-callconv.rs                 |  87 ---
 tests/codegen/infallible-unwrap-in-opt-z.rs        |  26 -
 tests/codegen/inherit_overflow.rs                  |  14 -
 tests/codegen/inline-always-works-always.rs        |  21 -
 tests/codegen/inline-debuginfo.rs                  |  17 -
 tests/codegen/inline-function-args-debug-info.rs   |  23 -
 tests/codegen/inline-hint.rs                       |  31 -
 .../instrument-coverage/instrument-coverage-off.rs |  21 -
 .../instrument-coverage/instrument-coverage.rs     |  22 -
 tests/codegen/instrument-coverage/testprog.rs      | 118 ----
 tests/codegen/instrument-mcount.rs                 |   7 -
 tests/codegen/instrument-xray/basic.rs             |   9 -
 tests/codegen/instrument-xray/options-combine.rs   |  12 -
 tests/codegen/instrument-xray/options-override.rs  |  11 -
 tests/codegen/integer-cmp.rs                       |  62 --
 tests/codegen/integer-overflow.rs                  |  24 -
 tests/codegen/internalize-closures.rs              |  13 -
 tests/codegen/intrinsic-no-unnamed-attr.rs         |  13 -
 tests/codegen/intrinsics/aggregate-thin-pointer.rs |  23 -
 tests/codegen/intrinsics/carrying_mul_add.rs       | 136 ----
 tests/codegen/intrinsics/cold_path.rs              |  13 -
 tests/codegen/intrinsics/cold_path2.rs             |  37 -
 tests/codegen/intrinsics/cold_path3.rs             |  87 ---
 tests/codegen/intrinsics/compare_bytes.rs          |  34 -
 tests/codegen/intrinsics/const_eval_select.rs      |  22 -
 tests/codegen/intrinsics/ctlz.rs                   |  56 --
 tests/codegen/intrinsics/ctpop.rs                  |  31 -
 tests/codegen/intrinsics/disjoint_bitor.rs         |  30 -
 tests/codegen/intrinsics/exact_div.rs              |  20 -
 tests/codegen/intrinsics/likely.rs                 |  35 -
 tests/codegen/intrinsics/likely_assert.rs          |  17 -
 tests/codegen/intrinsics/mask.rs                   |  12 -
 tests/codegen/intrinsics/nontemporal.rs            |  32 -
 tests/codegen/intrinsics/offset.rs                 |  33 -
 tests/codegen/intrinsics/offset_from.rs            |  36 -
 tests/codegen/intrinsics/prefetch.rs               |  64 --
 tests/codegen/intrinsics/ptr_metadata.rs           |  36 -
 tests/codegen/intrinsics/rotate_left.rs            |  31 -
 .../rustc_intrinsic_must_be_overridden.rs          |  14 -
 tests/codegen/intrinsics/select_unpredictable.rs   |  71 --
 tests/codegen/intrinsics/three_way_compare.rs      |  28 -
 tests/codegen/intrinsics/transmute-niched.rs       | 223 ------
 tests/codegen/intrinsics/transmute-x64.rs          |  28 -
 tests/codegen/intrinsics/transmute.rs              | 497 -------------
 tests/codegen/intrinsics/typed_swap.rs             |  77 --
 tests/codegen/intrinsics/unchecked_math.rs         |  46 --
 tests/codegen/intrinsics/unlikely.rs               |  35 -
 tests/codegen/intrinsics/volatile.rs               |  55 --
 tests/codegen/intrinsics/volatile_order.rs         |  18 -
 tests/codegen/is_val_statically_known.rs           | 163 -----
 tests/codegen/issue-97217.rs                       |  20 -
 tests/codegen/issues/issue-101048.rs               |  12 -
 tests/codegen/issues/issue-101082.rs               |  42 --
 tests/codegen/issues/issue-101814.rs               |  18 -
 tests/codegen/issues/issue-103132.rs               |  15 -
 .../issues/issue-103285-ptr-addr-overflow-check.rs |  15 -
 tests/codegen/issues/issue-103327.rs               |  13 -
 tests/codegen/issues/issue-103840.rs               |   9 -
 .../codegen/issues/issue-105386-ub-in-debuginfo.rs |  24 -
 tests/codegen/issues/issue-106369.rs               |  14 -
 .../issues/issue-107681-unwrap_unchecked.rs        |  19 -
 .../issues/issue-108395-branchy-bool-match.rs      |  27 -
 tests/codegen/issues/issue-109328-split_first.rs   |  16 -
 .../codegen/issues/issue-110797-enum-jump-same.rs  |  25 -
 tests/codegen/issues/issue-111603.rs               |  40 --
 .../issues/issue-112509-slice-get-andthen-get.rs   |  16 -
 .../issue-113757-bounds-check-after-cmp-max.rs     |  18 -
 tests/codegen/issues/issue-114312.rs               |  25 -
 .../issues/issue-115385-llvm-jump-threading.rs     |  46 --
 tests/codegen/issues/issue-116878.rs               |  11 -
 tests/codegen/issues/issue-118306.rs               |  22 -
 tests/codegen/issues/issue-118392.rs               |  10 -
 tests/codegen/issues/issue-119422.rs               |  83 ---
 .../issues/issue-121719-common-field-offset.rs     |  44 --
 .../issues/issue-122600-ptr-discriminant-update.rs |  43 --
 .../issue-123712-str-to-lower-autovectorization.rs |  23 -
 tests/codegen/issues/issue-126585.rs               |  23 -
 tests/codegen/issues/issue-129795.rs               |  17 -
 tests/codegen/issues/issue-13018.rs                |  14 -
 .../issues/issue-136329-optnone-noinline.rs        |  21 -
 tests/codegen/issues/issue-15953.rs                |  29 -
 tests/codegen/issues/issue-27130.rs                |  21 -
 tests/codegen/issues/issue-32031.rs                |  29 -
 tests/codegen/issues/issue-32364.rs                |  17 -
 tests/codegen/issues/issue-34634.rs                |  16 -
 tests/codegen/issues/issue-34947-pow-i32.rs        |  13 -
 .../codegen/issues/issue-36010-some-box-is_some.rs |  28 -
 tests/codegen/issues/issue-37945.rs                |  34 -
 tests/codegen/issues/issue-45222.rs                |  62 --
 tests/codegen/issues/issue-45466.rs                |  14 -
 .../issues/issue-45964-bounds-check-slice-pos.rs   |  38 -
 tests/codegen/issues/issue-47278.rs                |  11 -
 tests/codegen/issues/issue-47442.rs                |  22 -
 tests/codegen/issues/issue-56267-2.rs              |  18 -
 tests/codegen/issues/issue-56267.rs                |  18 -
 tests/codegen/issues/issue-56927.rs                |  46 --
 tests/codegen/issues/issue-58881.rs                |  20 -
 tests/codegen/issues/issue-59352.rs                |  18 -
 ...4219-fn-ptr-call-returning-never-is-noreturn.rs |  19 -
 .../issues/issue-68667-unwrap-combinators.rs       |  15 -
 tests/codegen/issues/issue-69101-bounds-check.rs   |  42 --
 tests/codegen/issues/issue-73031.rs                |  22 -
 tests/codegen/issues/issue-73258.rs                |  40 --
 tests/codegen/issues/issue-73338-effecient-cmp.rs  |  39 --
 .../issue-73396-bounds-check-after-position.rs     |  70 --
 .../issue-73827-bounds-check-index-in-subexpr.rs   |  17 -
 tests/codegen/issues/issue-74938-array-split-at.rs |  14 -
 tests/codegen/issues/issue-75525-bounds-checks.rs  |  26 -
 tests/codegen/issues/issue-75546.rs                |  17 -
 tests/codegen/issues/issue-75659.rs                |  63 --
 tests/codegen/issues/issue-75978.rs                |  18 -
 tests/codegen/issues/issue-77812.rs                |  32 -
 tests/codegen/issues/issue-84268.rs                |  18 -
 .../codegen/issues/issue-85872-multiple-reverse.rs |  19 -
 tests/codegen/issues/issue-86106.rs                |  63 --
 .../issue-86109-eliminate-div-by-zero-check.rs     |  26 -
 tests/codegen/issues/issue-93036-assert-index.rs   |  14 -
 tests/codegen/issues/issue-96274.rs                |  15 -
 .../issues/issue-96497-slice-size-nowrap.rs        |  38 -
 .../issue-98294-get-mut-copy-from-slice-opt.rs     |  17 -
 tests/codegen/issues/issue-98678-async.rs          |  27 -
 .../issues/issue-98678-closure-coroutine.rs        |  25 -
 tests/codegen/issues/issue-98678-enum.rs           |  42 --
 tests/codegen/issues/issue-98678-struct-union.rs   |  27 -
 tests/codegen/issues/issue-99960.rs                |  10 -
 .../codegen/issues/looping-over-ne-bytes-133528.rs |  17 -
 tests/codegen/issues/str-to-string-128690.rs       |  38 -
 tests/codegen/iter-repeat-n-trivial-drop.rs        |  70 --
 tests/codegen/layout-size-checks.rs                |  30 -
 tests/codegen/lib-optimizations/iter-sum.rs        |  13 -
 tests/codegen/lib-optimizations/slice_rotate.rs    |  30 -
 tests/codegen/lifetime_start_end.rs                |  34 -
 tests/codegen/link-dead-code.rs                    |  28 -
 tests/codegen/link_section.rs                      |  35 -
 tests/codegen/llvm-ident.rs                        |  15 -
 tests/codegen/llvm_module_flags.rs                 |   7 -
 tests/codegen/loads.rs                             | 152 ----
 .../codegen/local-generics-in-exe-internalized.rs  |  14 -
 .../codegen/loongarch-abi/call-llvm-intrinsics.rs  |  31 -
 .../codegen/loongarch-abi/loongarch64-lp64d-abi.rs | 299 --------
 tests/codegen/lto-removes-invokes.rs               |  21 -
 .../codegen/macos/i686-macosx-deployment-target.rs |  23 -
 .../macos/i686-no-macosx-deployment-target.rs      |  23 -
 .../macos/x86_64-macosx-deployment-target.rs       |  23 -
 .../macos/x86_64-no-macosx-deployment-target.rs    |  23 -
 tests/codegen/mainsubprogram.rs                    |  12 -
 tests/codegen/match-optimized.rs                   |  60 --
 tests/codegen/match-optimizes-away.rs              |  41 --
 tests/codegen/match-unoptimized.rs                 |  23 -
 tests/codegen/maybeuninit-rvo.rs                   |  34 -
 tests/codegen/mem-replace-big-type.rs              |  36 -
 tests/codegen/mem-replace-simple-type.rs           |  54 --
 tests/codegen/merge-functions.rs                   |  16 -
 tests/codegen/meta-filecheck/check-prefix.rs       |   4 -
 tests/codegen/meta-filecheck/filecheck-flags.rs    |   8 -
 tests/codegen/meta-filecheck/msvc-prefix-bad.rs    |   7 -
 tests/codegen/meta-filecheck/no-directives.rs      |   5 -
 tests/codegen/meta-filecheck/revision-prefix.rs    |   8 -
 tests/codegen/method-declaration.rs                |  26 -
 tests/codegen/min-function-alignment.rs            |  48 --
 tests/codegen/mir-aggregate-no-alloca.rs           | 137 ----
 tests/codegen/mir-inlined-line-numbers.rs          |  25 -
 tests/codegen/mir_zst_stores.rs                    |  19 -
 tests/codegen/move-before-nocapture-ref-arg.rs     |  21 -
 tests/codegen/move-operands.rs                     |  13 -
 tests/codegen/naked-asan.rs                        |  30 -
 tests/codegen/naked-fn/aligned.rs                  |  21 -
 tests/codegen/naked-fn/generics.rs                 | 111 ---
 tests/codegen/naked-fn/instruction-set.rs          |  53 --
 tests/codegen/naked-fn/min-function-alignment.rs   |  47 --
 tests/codegen/naked-fn/naked-functions.rs          | 165 -----
 tests/codegen/no-alloca-inside-if-false.rs         |  27 -
 tests/codegen/no-assumes-on-casts.rs               |  19 -
 tests/codegen/no-dllimport-w-cross-lang-lto.rs     |  13 -
 tests/codegen/no-jump-tables.rs                    |  23 -
 tests/codegen/no-plt.rs                            |  17 -
 .../codegen/no-redundant-item-monomorphization.rs  |  33 -
 tests/codegen/no_builtins-at-crate.rs              |  24 -
 tests/codegen/noalias-box-off.rs                   |  11 -
 tests/codegen/noalias-box.rs                       |   8 -
 tests/codegen/noalias-flag.rs                      |  23 -
 tests/codegen/noalias-freeze.rs                    |  23 -
 tests/codegen/noalias-refcell.rs                   |  14 -
 tests/codegen/noalias-rwlockreadguard.rs           |  14 -
 tests/codegen/noalias-unpin.rs                     |  15 -
 tests/codegen/non-terminate/infinite-loop-1.rs     |  17 -
 tests/codegen/non-terminate/infinite-loop-2.rs     |  19 -
 tests/codegen/non-terminate/infinite-recursion.rs  |  13 -
 .../non-terminate/nonempty-infinite-loop.rs        |  28 -
 tests/codegen/noreturn-uninhabited.rs              |  31 -
 tests/codegen/noreturnflag.rs                      |  22 -
 tests/codegen/nounwind.rs                          |  15 -
 tests/codegen/nrvo.rs                              |  17 -
 tests/codegen/optimize-attr-1.rs                   |  59 --
 tests/codegen/option-as-slice.rs                   |  71 --
 tests/codegen/option-niche-eq.rs                   |  87 ---
 .../option-niche-unfixed/option-nonzero-eq.rs      |  24 -
 tests/codegen/overaligned-constant.rs              |  35 -
 tests/codegen/packed.rs                            | 153 ----
 tests/codegen/panic-abort-windows.rs               |  16 -
 tests/codegen/panic-in-drop-abort.rs               |  57 --
 tests/codegen/panic-unwind-default-uwtable.rs      |   6 -
 .../patchable-function-entry-both-flags.rs         |  64 --
 .../patchable-function-entry-no-flag.rs            |  39 --
 .../patchable-function-entry-one-flag.rs           |  66 --
 tests/codegen/pattern_type_symbols.rs              |  22 -
 tests/codegen/personality_lifetimes.rs             |  32 -
 tests/codegen/pgo-counter-bias.rs                  |  10 -
 tests/codegen/pgo-instrumentation.rs               |  20 -
 tests/codegen/pic-relocation-model.rs              |  19 -
 tests/codegen/pie-relocation-model.rs              |  22 -
 tests/codegen/placement-new.rs                     |  39 --
 tests/codegen/powerpc64le-struct-align-128.rs      |  96 ---
 tests/codegen/precondition-checks.rs               |  25 -
 tests/codegen/ptr-arithmetic.rs                    |  33 -
 tests/codegen/ptr-read-metadata.rs                 |  94 ---
 tests/codegen/range-attribute.rs                   |  74 --
 tests/codegen/range-loop.rs                        |  44 --
 tests/codegen/range_to_inclusive.rs                |  28 -
 tests/codegen/refs.rs                              |  21 -
 tests/codegen/reg-struct-return.rs                 | 206 ------
 tests/codegen/regparm-inreg.rs                     | 125 ----
 tests/codegen/remap_path_prefix/aux_mod.rs         |   6 -
 .../auxiliary/remap_path_prefix_aux.rs             |   8 -
 .../remap_path_prefix/auxiliary/xcrate-generic.rs  |   8 -
 .../remap_path_prefix/issue-73167-remap-std.rs     |  15 -
 tests/codegen/remap_path_prefix/main.rs            |  28 -
 tests/codegen/remap_path_prefix/xcrate-generic.rs  |  14 -
 tests/codegen/repeat-operand-zero-len.rs           |  28 -
 tests/codegen/repeat-operand-zst-elem.rs           |  28 -
 tests/codegen/repeat-trusted-len.rs                |  20 -
 tests/codegen/repr/transparent-byval-struct-ptr.rs | 111 ---
 tests/codegen/repr/transparent-imm-array.rs        | 116 ---
 tests/codegen/repr/transparent-mips64.rs           | 103 ---
 tests/codegen/repr/transparent-opaque-ptr.rs       | 109 ---
 tests/codegen/repr/transparent-sparc64.rs          | 113 ---
 tests/codegen/repr/transparent-sysv64.rs           |  49 --
 tests/codegen/repr/transparent.rs                  | 221 ------
 tests/codegen/retpoline.rs                         |  27 -
 tests/codegen/riscv-abi/call-llvm-intrinsics.rs    |  30 -
 tests/codegen/riscv-abi/cast-local-large-enough.rs |  44 --
 .../riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs      | 176 -----
 tests/codegen/riscv-abi/riscv64-lp64d-abi.rs       | 299 --------
 tests/codegen/riscv-abi/riscv64-lp64f-lp64d-abi.rs | 283 --------
 tests/codegen/riscv-target-abi.rs                  |  21 -
 tests/codegen/rust-abi-arch-specific-adjustment.rs | 111 ---
 tests/codegen/s390x-simd.rs                        | 143 ----
 .../aarch64-shadow-call-stack-with-fixed-x18.rs    |  20 -
 .../address-sanitizer-globals-tracking.rs          |  44 --
 .../cfi/add-canonical-jump-tables-flag.rs          |  10 -
 .../cfi/add-cfi-normalize-integers-flag.rs         |  10 -
 .../cfi/add-enable-split-lto-unit-flag.rs          |  10 -
 .../sanitizer/cfi/dbg-location-on-cfi-blocks.rs    |  19 -
 .../cfi/emit-type-checks-attr-no-sanitize.rs       |  18 -
 tests/codegen/sanitizer/cfi/emit-type-checks.rs    |  19 -
 .../cfi/emit-type-metadata-attr-cfi-encoding.rs    |  73 --
 ...e-metadata-id-itanium-cxx-abi-const-generics.rs |  32 -
 ...pe-metadata-id-itanium-cxx-abi-drop-in-place.rs |  31 -
 ...e-metadata-id-itanium-cxx-abi-function-types.rs |  45 --
 ...t-type-metadata-id-itanium-cxx-abi-lifetimes.rs |  29 -
 ...a-id-itanium-cxx-abi-method-secondary-typeid.rs |  21 -
 .../emit-type-metadata-id-itanium-cxx-abi-paths.rs |  86 ---
 ...pe-metadata-id-itanium-cxx-abi-pointer-types.rs |  54 --
 ...-metadata-id-itanium-cxx-abi-primitive-types.rs | 190 -----
 ...ta-id-itanium-cxx-abi-repr-transparent-types.rs |  79 ---
 ...e-metadata-id-itanium-cxx-abi-sequence-types.rs |  36 -
 ...type-metadata-id-itanium-cxx-abi-trait-types.rs | 175 -----
 ...tadata-id-itanium-cxx-abi-user-defined-types.rs |  62 --
 ...it-type-metadata-itanium-cxx-abi-generalized.rs |  31 -
 ...adata-itanium-cxx-abi-normalized-generalized.rs |  31 -
 ...mit-type-metadata-itanium-cxx-abi-normalized.rs |  31 -
 .../cfi/emit-type-metadata-itanium-cxx-abi.rs      |  31 -
 .../cfi/emit-type-metadata-trait-objects.rs        | 145 ----
 .../codegen/sanitizer/cfi/external_weak_symbols.rs |  24 -
 tests/codegen/sanitizer/cfi/generalize-pointers.rs |  46 --
 tests/codegen/sanitizer/cfi/normalize-integers.rs  |  46 --
 .../sanitizer/dataflow-instrument-functions.rs     |   9 -
 .../sanitizer/kasan-emits-instrumentation.rs       |  41 --
 .../kcfi/add-cfi-normalize-integers-flag.rs        |  20 -
 .../codegen/sanitizer/kcfi/add-kcfi-arity-flag.rs  |  19 -
 tests/codegen/sanitizer/kcfi/add-kcfi-flag.rs      |  20 -
 .../codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs |  20 -
 .../emit-kcfi-operand-bundle-attr-no-sanitize.rs   |  27 -
 ...i-operand-bundle-itanium-cxx-abi-generalized.rs |  41 --
 ...undle-itanium-cxx-abi-normalized-generalized.rs |  41 --
 ...fi-operand-bundle-itanium-cxx-abi-normalized.rs |  41 --
 .../emit-kcfi-operand-bundle-itanium-cxx-abi.rs    |  41 --
 .../sanitizer/kcfi/emit-kcfi-operand-bundle.rs     |  24 -
 .../kcfi/emit-type-metadata-trait-objects.rs       | 155 ----
 tests/codegen/sanitizer/kcfi/naked-function.rs     |  47 --
 tests/codegen/sanitizer/memory-track-origins.rs    |  31 -
 tests/codegen/sanitizer/memtag-attr-check.rs       |  12 -
 tests/codegen/sanitizer/no-sanitize-inlining.rs    |  31 -
 tests/codegen/sanitizer/no-sanitize.rs             |  39 --
 .../codegen/sanitizer/riscv64-shadow-call-stack.rs |  18 -
 tests/codegen/sanitizer/safestack-attr-check.rs    |  11 -
 tests/codegen/sanitizer/sanitizer-recover.rs       |  50 --
 tests/codegen/sanitizer/scs-attr-check.rs          |  17 -
 tests/codegen/scalar-pair-bool.rs                  |  45 --
 tests/codegen/set-discriminant-invalid.rs          |  34 -
 .../simd-intrinsic/simd-intrinsic-float-abs.rs     |  60 --
 .../simd-intrinsic/simd-intrinsic-float-ceil.rs    |  60 --
 .../simd-intrinsic/simd-intrinsic-float-cos.rs     |  60 --
 .../simd-intrinsic/simd-intrinsic-float-exp.rs     |  60 --
 .../simd-intrinsic/simd-intrinsic-float-exp2.rs    |  60 --
 .../simd-intrinsic/simd-intrinsic-float-floor.rs   |  60 --
 .../simd-intrinsic/simd-intrinsic-float-fma.rs     |  60 --
 .../simd-intrinsic/simd-intrinsic-float-fsqrt.rs   |  60 --
 .../simd-intrinsic/simd-intrinsic-float-log.rs     |  60 --
 .../simd-intrinsic/simd-intrinsic-float-log10.rs   |  60 --
 .../simd-intrinsic/simd-intrinsic-float-log2.rs    |  60 --
 .../simd-intrinsic/simd-intrinsic-float-minmax.rs  |  25 -
 .../simd-intrinsic/simd-intrinsic-float-sin.rs     |  60 --
 ...simd-intrinsic-generic-arithmetic-saturating.rs | 579 ---------------
 .../simd-intrinsic-generic-bitmask.rs              |  48 --
 .../simd-intrinsic-generic-gather.rs               |  55 --
 .../simd-intrinsic-generic-masked-load.rs          |  49 --
 .../simd-intrinsic-generic-masked-store.rs         |  41 --
 .../simd-intrinsic-generic-scatter.rs              |  47 --
 .../simd-intrinsic-generic-select.rs               |  48 --
 .../simd-intrinsic/simd-intrinsic-mask-reduce.rs   |  60 --
 .../simd-intrinsic-transmute-array.rs              |  58 --
 tests/codegen/simd/aggregate-simd.rs               | 102 ---
 tests/codegen/simd/extract-insert-dyn.rs           | 121 ----
 tests/codegen/simd/packed-simd-alignment.rs        |  44 --
 tests/codegen/simd/packed-simd.rs                  |  56 --
 tests/codegen/simd/simd-wide-sum.rs                |  59 --
 tests/codegen/simd/simd_arith_offset.rs            |  22 -
 tests/codegen/simd/swap-simd-types.rs              |  40 --
 tests/codegen/simd/unpadded-simd.rs                |  19 -
 tests/codegen/skip-mono-inside-if-false.rs         |  41 --
 tests/codegen/slice-as_chunks.rs                   |  30 -
 tests/codegen/slice-indexing.rs                    |  99 ---
 tests/codegen/slice-init.rs                        | 108 ---
 tests/codegen/slice-is-ascii.rs                    |  16 -
 tests/codegen/slice-iter-fold.rs                   |  12 -
 tests/codegen/slice-iter-len-eq-zero.rs            |  60 --
 tests/codegen/slice-iter-nonnull.rs                | 115 ---
 tests/codegen/slice-last-elements-optimization.rs  |  37 -
 tests/codegen/slice-pointer-nonnull-unwrap.rs      |  18 -
 tests/codegen/slice-position-bounds-check.rs       |  25 -
 tests/codegen/slice-ref-equality.rs                |  90 ---
 tests/codegen/slice-reverse.rs                     |  27 -
 tests/codegen/slice-split-at.rs                    |  24 -
 tests/codegen/slice-windows-no-bounds-check.rs     |  32 -
 tests/codegen/slice_as_from_ptr_range.rs           |  21 -
 .../some-abis-do-extend-params-to-32-bits.rs       | 236 -------
 tests/codegen/some-global-nonnull.rs               |  25 -
 tests/codegen/sparc-struct-abi.rs                  |  97 ---
 tests/codegen/split-lto-unit.rs                    |  10 -
 .../src-hash-algorithm/src-hash-algorithm-md5.rs   |   6 -
 .../src-hash-algorithm/src-hash-algorithm-sha1.rs  |   6 -
 .../src-hash-algorithm-sha256.rs                   |   6 -
 tests/codegen/sroa-fragment-debuginfo.rs           |  46 --
 tests/codegen/sse42-implies-crc32.rs               |  15 -
 tests/codegen/stack-probes-inline.rs               |  33 -
 tests/codegen/stack-protector.rs                   |  34 -
 tests/codegen/static-relocation-model-msvc.rs      |  24 -
 tests/codegen/staticlib-external-inline-fns.rs     |  43 --
 tests/codegen/step_by-overflow-checks.rs           |  26 -
 tests/codegen/stores.rs                            |  35 -
 tests/codegen/string-push.rs                       |  11 -
 tests/codegen/swap-large-types.rs                  | 116 ---
 tests/codegen/swap-small-types.rs                  | 182 -----
 tests/codegen/target-cpu-on-functions.rs           |  22 -
 tests/codegen/target-feature-inline-closure.rs     |  33 -
 .../codegen/target-feature-negative-implication.rs |  20 -
 tests/codegen/target-feature-overrides.rs          |  46 --
 tests/codegen/terminating-catchpad.rs              |  43 --
 tests/codegen/thread-local.rs                      |  54 --
 tests/codegen/tied-features-strength.rs            |  34 -
 tests/codegen/to_vec.rs                            |  10 -
 tests/codegen/trailing_zeros.rs                    |  21 -
 tests/codegen/transmute-optimized.rs               | 120 ----
 tests/codegen/transmute-scalar.rs                  | 143 ----
 tests/codegen/try_question_mark_nop.rs             | 243 -------
 tests/codegen/tune-cpu-on-functions.rs             |  21 -
 tests/codegen/tuple-layout-opt.rs                  |  57 --
 tests/codegen/ub-checks.rs                         |  28 -
 tests/codegen/unchecked-float-casts.rs             |  36 -
 tests/codegen/unchecked_shifts.rs                  | 100 ---
 .../codegen/uninhabited-transparent-return-abi.rs  |  44 --
 tests/codegen/uninit-consts.rs                     |  54 --
 tests/codegen/uninit-repeat-in-aggregate.rs        |  21 -
 tests/codegen/union-abi.rs                         | 145 ----
 tests/codegen/union-aggregate.rs                   | 108 ---
 tests/codegen/unwind-abis/aapcs-unwind-abi.rs      |  36 -
 .../unwind-abis/c-unwind-abi-panic-abort.rs        |  27 -
 tests/codegen/unwind-abis/c-unwind-abi.rs          |  27 -
 tests/codegen/unwind-abis/cdecl-unwind-abi.rs      |  27 -
 tests/codegen/unwind-abis/fastcall-unwind-abi.rs   |  36 -
 .../unwind-abis/nounwind-on-stable-panic-abort.rs  |  15 -
 tests/codegen/unwind-abis/nounwind.rs              |  16 -
 tests/codegen/unwind-abis/stdcall-unwind-abi.rs    |  36 -
 tests/codegen/unwind-abis/system-unwind-abi.rs     |  27 -
 tests/codegen/unwind-abis/sysv64-unwind-abi.rs     |  36 -
 tests/codegen/unwind-abis/thiscall-unwind-abi.rs   |  36 -
 tests/codegen/unwind-abis/vectorcall-unwind-abi.rs |  36 -
 tests/codegen/unwind-abis/win64-unwind-abi.rs      |  36 -
 tests/codegen/unwind-and-panic-abort.rs            |  16 -
 tests/codegen/unwind-extern-exports.rs             |  15 -
 tests/codegen/unwind-extern-imports.rs             |  21 -
 tests/codegen/unwind-landingpad-cold.rs            |  15 -
 tests/codegen/unwind-landingpad-inline.rs          |  39 --
 tests/codegen/used_with_arg.rs                     |  10 -
 tests/codegen/var-names.rs                         |  15 -
 tests/codegen/vec-as-ptr.rs                        |  19 -
 tests/codegen/vec-calloc.rs                        | 182 -----
 tests/codegen/vec-in-place.rs                      | 161 -----
 tests/codegen/vec-iter-collect-len.rs              |  12 -
 tests/codegen/vec-iter.rs                          |  58 --
 tests/codegen/vec-len-invariant.rs                 |  16 -
 tests/codegen/vec-optimizes-away.rs                |  12 -
 tests/codegen/vec-reserve-extend.rs                |  14 -
 tests/codegen/vec-shrink-panik.rs                  |  31 -
 tests/codegen/vec-with-capacity.rs                 |  35 -
 tests/codegen/vec_pop_push_noop.rs                 |  24 -
 tests/codegen/vecdeque-drain.rs                    |  70 --
 tests/codegen/vecdeque-nonempty-get-no-panic.rs    |  16 -
 tests/codegen/vecdeque_no_panic.rs                 |  19 -
 tests/codegen/vecdeque_pop_push.rs                 |  67 --
 tests/codegen/virtual-call-attrs-issue-137646.rs   |  37 -
 .../codegen/virtual-function-elimination-32bit.rs  |  35 -
 tests/codegen/virtual-function-elimination.rs      |  98 ---
 tests/codegen/vtable-loads.rs                      |  16 -
 tests/codegen/vtable-upcast.rs                     |  84 ---
 tests/codegen/wasm_casts_trapping.rs               | 157 -----
 tests/codegen/wasm_exceptions.rs                   |  59 --
 tests/codegen/zip.rs                               |  21 -
 tests/codegen/zst-offset.rs                        |  42 --
 tests/run-make/llvm-ident/rmake.rs                 |   2 +-
 tests/ui/abi/fixed_x18.rs                          |   2 +-
 triagebot.toml                                     |  18 +-
 1332 files changed, 31747 insertions(+), 31742 deletions(-)
 create mode 100644 tests/codegen-llvm/README.md
 create mode 100644 tests/codegen-llvm/aarch64-softfloat.rs
 create mode 100644 tests/codegen-llvm/aarch64-struct-align-128.rs
 create mode 100644 tests/codegen-llvm/abi-efiapi.rs
 create mode 100644 tests/codegen-llvm/abi-main-signature-16bit-c-int.rs
 create mode 100644 tests/codegen-llvm/abi-main-signature-32bit-c-int.rs
 create mode 100644 tests/codegen-llvm/abi-repr-ext.rs
 create mode 100644 tests/codegen-llvm/abi-sysv64.rs
 create mode 100644 tests/codegen-llvm/abi-win64-zst.rs
 create mode 100644 tests/codegen-llvm/abi-x86-interrupt.rs
 create mode 100644 tests/codegen-llvm/abi-x86-sse.rs
 create mode 100644 tests/codegen-llvm/abi-x86_64_sysv.rs
 create mode 100644 tests/codegen-llvm/addr-of-mutate.rs
 create mode 100644 tests/codegen-llvm/adjustments.rs
 create mode 100644 tests/codegen-llvm/align-byval-alignment-mismatch.rs
 create mode 100644 tests/codegen-llvm/align-byval-vector.rs
 create mode 100644 tests/codegen-llvm/align-byval.rs
 create mode 100644 tests/codegen-llvm/align-enum.rs
 create mode 100644 tests/codegen-llvm/align-fn.rs
 create mode 100644 tests/codegen-llvm/align-offset.rs
 create mode 100644 tests/codegen-llvm/align-struct.rs
 create mode 100644 tests/codegen-llvm/alloc-optimisation.rs
 create mode 100644 tests/codegen-llvm/amdgpu-addrspacecast.rs
 create mode 100644 tests/codegen-llvm/array-clone.rs
 create mode 100644 tests/codegen-llvm/array-cmp.rs
 create mode 100644 tests/codegen-llvm/array-codegen.rs
 create mode 100644 tests/codegen-llvm/array-equality.rs
 create mode 100644 tests/codegen-llvm/array-from_fn.rs
 create mode 100644 tests/codegen-llvm/array-map.rs
 create mode 100644 tests/codegen-llvm/array-optimized.rs
 create mode 100644 tests/codegen-llvm/array-repeat.rs
 create mode 100644 tests/codegen-llvm/ascii-char.rs
 create mode 100644 tests/codegen-llvm/asm/aarch64-clobbers.rs
 create mode 100644 tests/codegen-llvm/asm/avr-clobbers.rs
 create mode 100644 tests/codegen-llvm/asm/bpf-clobbers.rs
 create mode 100644 tests/codegen-llvm/asm/critical.rs
 create mode 100644 tests/codegen-llvm/asm/csky-clobbers.rs
 create mode 100644 tests/codegen-llvm/asm/foo.s
 create mode 100644 tests/codegen-llvm/asm/global_asm.rs
 create mode 100644 tests/codegen-llvm/asm/global_asm_include.rs
 create mode 100644 tests/codegen-llvm/asm/global_asm_x2.rs
 create mode 100644 tests/codegen-llvm/asm/goto.rs
 create mode 100644 tests/codegen-llvm/asm/hexagon-clobbers.rs
 create mode 100644 tests/codegen-llvm/asm/may_unwind.rs
 create mode 100644 tests/codegen-llvm/asm/maybe-uninit.rs
 create mode 100644 tests/codegen-llvm/asm/msp430-clobbers.rs
 create mode 100644 tests/codegen-llvm/asm/multiple-options.rs
 create mode 100644 tests/codegen-llvm/asm/options.rs
 create mode 100644 tests/codegen-llvm/asm/powerpc-clobbers.rs
 create mode 100644 tests/codegen-llvm/asm/riscv-clobbers.rs
 create mode 100644 tests/codegen-llvm/asm/s390x-clobbers.rs
 create mode 100644 tests/codegen-llvm/asm/sanitize-llvm.rs
 create mode 100644 tests/codegen-llvm/asm/sparc-clobbers.rs
 create mode 100644 tests/codegen-llvm/asm/x86-clobber_abi.rs
 create mode 100644 tests/codegen-llvm/asm/x86-clobbers.rs
 create mode 100644 tests/codegen-llvm/asm/x86-target-clobbers.rs
 create mode 100644 tests/codegen-llvm/assign-desugar-debuginfo.rs
 create mode 100644 tests/codegen-llvm/async-closure-debug.rs
 create mode 100644 tests/codegen-llvm/async-fn-debug-awaitee-field.rs
 create mode 100644 tests/codegen-llvm/async-fn-debug-msvc.rs
 create mode 100644 tests/codegen-llvm/async-fn-debug.rs
 create mode 100644 tests/codegen-llvm/atomic-operations.rs
 create mode 100644 tests/codegen-llvm/atomicptr.rs
 create mode 100644 tests/codegen-llvm/autodiff/batched.rs
 create mode 100644 tests/codegen-llvm/autodiff/generic.rs
 create mode 100644 tests/codegen-llvm/autodiff/identical_fnc.rs
 create mode 100644 tests/codegen-llvm/autodiff/inline.rs
 create mode 100644 tests/codegen-llvm/autodiff/scalar.rs
 create mode 100644 tests/codegen-llvm/autodiff/sret.rs
 create mode 100644 tests/codegen-llvm/autodiffv2.rs
 create mode 100644 tests/codegen-llvm/autovec/dont-shuffle-bswaps-opt2.rs
 create mode 100644 tests/codegen-llvm/autovec/dont-shuffle-bswaps-opt3.rs
 create mode 100644 tests/codegen-llvm/autovectorize-f32x4.rs
 create mode 100644 tests/codegen-llvm/auxiliary/extern_decl.rs
 create mode 100644 tests/codegen-llvm/auxiliary/nounwind.rs
 create mode 100644 tests/codegen-llvm/auxiliary/thread_local_aux.rs
 create mode 100644 tests/codegen-llvm/avr/avr-func-addrspace.rs
 create mode 100644 tests/codegen-llvm/bigint-helpers.rs
 create mode 100644 tests/codegen-llvm/binary-heap-peek-mut-pop-no-panic.rs
 create mode 100644 tests/codegen-llvm/binary-search-index-no-bound-check.rs
 create mode 100644 tests/codegen-llvm/bool-cmp.rs
 create mode 100644 tests/codegen-llvm/bounds-checking/gep-issue-133979.rs
 create mode 100644 tests/codegen-llvm/box-default-debug-copies.rs
 create mode 100644 tests/codegen-llvm/box-uninit-bytes.rs
 create mode 100644 tests/codegen-llvm/bpf-alu32.rs
 create mode 100644 tests/codegen-llvm/branch-protection.rs
 create mode 100644 tests/codegen-llvm/call-llvm-intrinsics.rs
 create mode 100644 tests/codegen-llvm/call-tmps-lifetime.rs
 create mode 100644 tests/codegen-llvm/cast-optimized.rs
 create mode 100644 tests/codegen-llvm/cast-target-abi.rs
 create mode 100644 tests/codegen-llvm/catch-unwind.rs
 create mode 100644 tests/codegen-llvm/cdylib-external-inline-fns.rs
 create mode 100644 tests/codegen-llvm/cf-protection.rs
 create mode 100644 tests/codegen-llvm/cffi/c-variadic-copy.rs
 create mode 100644 tests/codegen-llvm/cffi/c-variadic-naked.rs
 create mode 100644 tests/codegen-llvm/cffi/c-variadic-opt.rs
 create mode 100644 tests/codegen-llvm/cffi/c-variadic.rs
 create mode 100644 tests/codegen-llvm/cffi/ffi-const.rs
 create mode 100644 tests/codegen-llvm/cffi/ffi-out-of-bounds-loads.rs
 create mode 100644 tests/codegen-llvm/cffi/ffi-pure.rs
 create mode 100644 tests/codegen-llvm/cfguard-checks.rs
 create mode 100644 tests/codegen-llvm/cfguard-disabled.rs
 create mode 100644 tests/codegen-llvm/cfguard-nochecks.rs
 create mode 100644 tests/codegen-llvm/cfguard-non-msvc.rs
 create mode 100644 tests/codegen-llvm/char-ascii-branchless.rs
 create mode 100644 tests/codegen-llvm/char-escape-debug-no-bounds-check.rs
 create mode 100644 tests/codegen-llvm/checked_ilog.rs
 create mode 100644 tests/codegen-llvm/checked_math.rs
 create mode 100644 tests/codegen-llvm/clone-shims.rs
 create mode 100644 tests/codegen-llvm/clone_as_copy.rs
 create mode 100644 tests/codegen-llvm/codemodels.rs
 create mode 100644 tests/codegen-llvm/coercions.rs
 create mode 100644 tests/codegen-llvm/cold-call-declare-and-call.rs
 create mode 100644 tests/codegen-llvm/common_prim_int_ptr.rs
 create mode 100644 tests/codegen-llvm/comparison-operators-2-struct.rs
 create mode 100644 tests/codegen-llvm/comparison-operators-2-tuple.rs
 create mode 100644 tests/codegen-llvm/comparison-operators-newtype.rs
 create mode 100644 tests/codegen-llvm/compiletest-self-test/minicore-smoke-test.rs
 create mode 100644 tests/codegen-llvm/const-array.rs
 create mode 100644 tests/codegen-llvm/const-vector.rs
 create mode 100644 tests/codegen-llvm/const_scalar_pair.rs
 create mode 100644 tests/codegen-llvm/constant-branch.rs
 create mode 100644 tests/codegen-llvm/consts.rs
 create mode 100644 tests/codegen-llvm/coroutine-debug-msvc.rs
 create mode 100644 tests/codegen-llvm/coroutine-debug.rs
 create mode 100644 tests/codegen-llvm/cross-crate-inlining/always-inline.rs
 create mode 100644 tests/codegen-llvm/cross-crate-inlining/auxiliary/always.rs
 create mode 100644 tests/codegen-llvm/cross-crate-inlining/auxiliary/leaf.rs
 create mode 100644 tests/codegen-llvm/cross-crate-inlining/auxiliary/never.rs
 create mode 100644 tests/codegen-llvm/cross-crate-inlining/leaf-inlining.rs
 create mode 100644 tests/codegen-llvm/cross-crate-inlining/never-inline.rs
 create mode 100644 tests/codegen-llvm/dealloc-no-unwind.rs
 create mode 100644 tests/codegen-llvm/debug-accessibility/crate-enum.rs
 create mode 100644 tests/codegen-llvm/debug-accessibility/crate-struct.rs
 create mode 100644 tests/codegen-llvm/debug-accessibility/private-enum.rs
 create mode 100644 tests/codegen-llvm/debug-accessibility/private-struct.rs
 create mode 100644 tests/codegen-llvm/debug-accessibility/public-enum.rs
 create mode 100644 tests/codegen-llvm/debug-accessibility/public-struct.rs
 create mode 100644 tests/codegen-llvm/debug-accessibility/struct-fields.rs
 create mode 100644 tests/codegen-llvm/debug-accessibility/super-enum.rs
 create mode 100644 tests/codegen-llvm/debug-accessibility/super-struct.rs
 create mode 100644 tests/codegen-llvm/debug-accessibility/tuple-fields.rs
 create mode 100644 tests/codegen-llvm/debug-alignment.rs
 create mode 100644 tests/codegen-llvm/debug-column-msvc.rs
 create mode 100644 tests/codegen-llvm/debug-column.rs
 create mode 100644 tests/codegen-llvm/debug-compile-unit-path.rs
 create mode 100644 tests/codegen-llvm/debug-fndef-size.rs
 create mode 100644 tests/codegen-llvm/debug-limited.rs
 create mode 100644 tests/codegen-llvm/debug-line-directives-only.rs
 create mode 100644 tests/codegen-llvm/debug-line-tables-only.rs
 create mode 100644 tests/codegen-llvm/debug-linkage-name.rs
 create mode 100644 tests/codegen-llvm/debug-vtable.rs
 create mode 100644 tests/codegen-llvm/debuginfo-constant-locals.rs
 create mode 100644 tests/codegen-llvm/debuginfo-generic-closure-env-names.rs
 create mode 100644 tests/codegen-llvm/debuginfo-inline-callsite-location.rs
 create mode 100644 tests/codegen-llvm/debuginfo-proc-macro/auxiliary/macro_def.rs
 create mode 100644 tests/codegen-llvm/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs
 create mode 100644 tests/codegen-llvm/deduced-param-attrs.rs
 create mode 100644 tests/codegen-llvm/default-requires-uwtable.rs
 create mode 100644 tests/codegen-llvm/default-visibility.rs
 create mode 100644 tests/codegen-llvm/direct-access-external-data.rs
 create mode 100644 tests/codegen-llvm/dllimports/auxiliary/dummy.rs
 create mode 100644 tests/codegen-llvm/dllimports/auxiliary/wrapper.rs
 create mode 100644 tests/codegen-llvm/dllimports/main.rs
 create mode 100644 tests/codegen-llvm/dont_codegen_private_const_fn_only_used_in_const_eval.rs
 create mode 100644 tests/codegen-llvm/drop-in-place-noalias.rs
 create mode 100644 tests/codegen-llvm/drop.rs
 create mode 100644 tests/codegen-llvm/dst-offset.rs
 create mode 100644 tests/codegen-llvm/dst-vtable-align-nonzero.rs
 create mode 100644 tests/codegen-llvm/dst-vtable-size-range.rs
 create mode 100644 tests/codegen-llvm/ehcontguard_disabled.rs
 create mode 100644 tests/codegen-llvm/ehcontguard_enabled.rs
 create mode 100644 tests/codegen-llvm/emscripten-catch-unwind-js-eh.rs
 create mode 100644 tests/codegen-llvm/emscripten-catch-unwind-wasm-eh.rs
 create mode 100644 tests/codegen-llvm/enable-lto-unit-splitting.rs
 create mode 100644 tests/codegen-llvm/enum/enum-aggregate.rs
 create mode 100644 tests/codegen-llvm/enum/enum-bounds-check-derived-idx.rs
 create mode 100644 tests/codegen-llvm/enum/enum-bounds-check-issue-13926.rs
 create mode 100644 tests/codegen-llvm/enum/enum-bounds-check-issue-82871.rs
 create mode 100644 tests/codegen-llvm/enum/enum-bounds-check.rs
 create mode 100644 tests/codegen-llvm/enum/enum-debug-clike.rs
 create mode 100644 tests/codegen-llvm/enum/enum-debug-niche-2.rs
 create mode 100644 tests/codegen-llvm/enum/enum-debug-niche.rs
 create mode 100644 tests/codegen-llvm/enum/enum-debug-tagged.rs
 create mode 100644 tests/codegen-llvm/enum/enum-discriminant-eq.rs
 create mode 100644 tests/codegen-llvm/enum/enum-discriminant-value.rs
 create mode 100644 tests/codegen-llvm/enum/enum-early-otherwise-branch.rs
 create mode 100644 tests/codegen-llvm/enum/enum-match.rs
 create mode 100644 tests/codegen-llvm/enum/enum-two-variants-match.rs
 create mode 100644 tests/codegen-llvm/enum/enum-u128.rs
 create mode 100644 tests/codegen-llvm/enum/unreachable_enum_default_branch.rs
 create mode 100644 tests/codegen-llvm/ergonomic-clones/closure.rs
 create mode 100644 tests/codegen-llvm/error-provide.rs
 create mode 100644 tests/codegen-llvm/export-no-mangle.rs
 create mode 100644 tests/codegen-llvm/external-no-mangle-fns.rs
 create mode 100644 tests/codegen-llvm/external-no-mangle-statics.rs
 create mode 100644 tests/codegen-llvm/f128-wasm32-callconv.rs
 create mode 100644 tests/codegen-llvm/fastcall-inreg.rs
 create mode 100644 tests/codegen-llvm/fatptr.rs
 create mode 100644 tests/codegen-llvm/fewer-names.rs
 create mode 100644 tests/codegen-llvm/fixed-x18.rs
 create mode 100644 tests/codegen-llvm/float/algebraic.rs
 create mode 100644 tests/codegen-llvm/float/f128.rs
 create mode 100644 tests/codegen-llvm/float/f16-f128-inline.rs
 create mode 100644 tests/codegen-llvm/float/f16.rs
 create mode 100644 tests/codegen-llvm/float_math.rs
 create mode 100644 tests/codegen-llvm/fn-impl-trait-self.rs
 create mode 100644 tests/codegen-llvm/fn-parameters-on-different-lines-debuginfo.rs
 create mode 100644 tests/codegen-llvm/force-frame-pointers.rs
 create mode 100644 tests/codegen-llvm/force-no-unwind-tables.rs
 create mode 100644 tests/codegen-llvm/force-unwind-tables.rs
 create mode 100644 tests/codegen-llvm/frame-pointer-cli-control.rs
 create mode 100644 tests/codegen-llvm/frame-pointer.rs
 create mode 100644 tests/codegen-llvm/function-arguments-noopt.rs
 create mode 100644 tests/codegen-llvm/function-arguments.rs
 create mode 100644 tests/codegen-llvm/function-return.rs
 create mode 100644 tests/codegen-llvm/gdb_debug_script_load.rs
 create mode 100644 tests/codegen-llvm/generic-debug.rs
 create mode 100644 tests/codegen-llvm/gep-index.rs
 create mode 100644 tests/codegen-llvm/gpu-kernel-abi.rs
 create mode 100644 tests/codegen-llvm/gpu_offload/gpu_host.rs
 create mode 100644 tests/codegen-llvm/hint/cold_path.rs
 create mode 100644 tests/codegen-llvm/hint/likely.rs
 create mode 100644 tests/codegen-llvm/hint/unlikely.rs
 create mode 100644 tests/codegen-llvm/i128-wasm32-callconv.rs
 create mode 100644 tests/codegen-llvm/i128-x86-align.rs
 create mode 100644 tests/codegen-llvm/i128-x86-callconv.rs
 create mode 100644 tests/codegen-llvm/infallible-unwrap-in-opt-z.rs
 create mode 100644 tests/codegen-llvm/inherit_overflow.rs
 create mode 100644 tests/codegen-llvm/inline-always-works-always.rs
 create mode 100644 tests/codegen-llvm/inline-debuginfo.rs
 create mode 100644 tests/codegen-llvm/inline-function-args-debug-info.rs
 create mode 100644 tests/codegen-llvm/inline-hint.rs
 create mode 100644 tests/codegen-llvm/instrument-coverage/instrument-coverage-off.rs
 create mode 100644 tests/codegen-llvm/instrument-coverage/instrument-coverage.rs
 create mode 100644 tests/codegen-llvm/instrument-coverage/testprog.rs
 create mode 100644 tests/codegen-llvm/instrument-mcount.rs
 create mode 100644 tests/codegen-llvm/instrument-xray/basic.rs
 create mode 100644 tests/codegen-llvm/instrument-xray/options-combine.rs
 create mode 100644 tests/codegen-llvm/instrument-xray/options-override.rs
 create mode 100644 tests/codegen-llvm/integer-cmp.rs
 create mode 100644 tests/codegen-llvm/integer-overflow.rs
 create mode 100644 tests/codegen-llvm/internalize-closures.rs
 create mode 100644 tests/codegen-llvm/intrinsic-no-unnamed-attr.rs
 create mode 100644 tests/codegen-llvm/intrinsics/aggregate-thin-pointer.rs
 create mode 100644 tests/codegen-llvm/intrinsics/carrying_mul_add.rs
 create mode 100644 tests/codegen-llvm/intrinsics/cold_path.rs
 create mode 100644 tests/codegen-llvm/intrinsics/cold_path2.rs
 create mode 100644 tests/codegen-llvm/intrinsics/cold_path3.rs
 create mode 100644 tests/codegen-llvm/intrinsics/compare_bytes.rs
 create mode 100644 tests/codegen-llvm/intrinsics/const_eval_select.rs
 create mode 100644 tests/codegen-llvm/intrinsics/ctlz.rs
 create mode 100644 tests/codegen-llvm/intrinsics/ctpop.rs
 create mode 100644 tests/codegen-llvm/intrinsics/disjoint_bitor.rs
 create mode 100644 tests/codegen-llvm/intrinsics/exact_div.rs
 create mode 100644 tests/codegen-llvm/intrinsics/likely.rs
 create mode 100644 tests/codegen-llvm/intrinsics/likely_assert.rs
 create mode 100644 tests/codegen-llvm/intrinsics/mask.rs
 create mode 100644 tests/codegen-llvm/intrinsics/nontemporal.rs
 create mode 100644 tests/codegen-llvm/intrinsics/offset.rs
 create mode 100644 tests/codegen-llvm/intrinsics/offset_from.rs
 create mode 100644 tests/codegen-llvm/intrinsics/prefetch.rs
 create mode 100644 tests/codegen-llvm/intrinsics/ptr_metadata.rs
 create mode 100644 tests/codegen-llvm/intrinsics/rotate_left.rs
 create mode 100644 tests/codegen-llvm/intrinsics/rustc_intrinsic_must_be_overridden.rs
 create mode 100644 tests/codegen-llvm/intrinsics/select_unpredictable.rs
 create mode 100644 tests/codegen-llvm/intrinsics/three_way_compare.rs
 create mode 100644 tests/codegen-llvm/intrinsics/transmute-niched.rs
 create mode 100644 tests/codegen-llvm/intrinsics/transmute-x64.rs
 create mode 100644 tests/codegen-llvm/intrinsics/transmute.rs
 create mode 100644 tests/codegen-llvm/intrinsics/typed_swap.rs
 create mode 100644 tests/codegen-llvm/intrinsics/unchecked_math.rs
 create mode 100644 tests/codegen-llvm/intrinsics/unlikely.rs
 create mode 100644 tests/codegen-llvm/intrinsics/volatile.rs
 create mode 100644 tests/codegen-llvm/intrinsics/volatile_order.rs
 create mode 100644 tests/codegen-llvm/is_val_statically_known.rs
 create mode 100644 tests/codegen-llvm/issue-97217.rs
 create mode 100644 tests/codegen-llvm/issues/issue-101048.rs
 create mode 100644 tests/codegen-llvm/issues/issue-101082.rs
 create mode 100644 tests/codegen-llvm/issues/issue-101814.rs
 create mode 100644 tests/codegen-llvm/issues/issue-103132.rs
 create mode 100644 tests/codegen-llvm/issues/issue-103285-ptr-addr-overflow-check.rs
 create mode 100644 tests/codegen-llvm/issues/issue-103327.rs
 create mode 100644 tests/codegen-llvm/issues/issue-103840.rs
 create mode 100644 tests/codegen-llvm/issues/issue-105386-ub-in-debuginfo.rs
 create mode 100644 tests/codegen-llvm/issues/issue-106369.rs
 create mode 100644 tests/codegen-llvm/issues/issue-107681-unwrap_unchecked.rs
 create mode 100644 tests/codegen-llvm/issues/issue-108395-branchy-bool-match.rs
 create mode 100644 tests/codegen-llvm/issues/issue-109328-split_first.rs
 create mode 100644 tests/codegen-llvm/issues/issue-110797-enum-jump-same.rs
 create mode 100644 tests/codegen-llvm/issues/issue-111603.rs
 create mode 100644 tests/codegen-llvm/issues/issue-112509-slice-get-andthen-get.rs
 create mode 100644 tests/codegen-llvm/issues/issue-113757-bounds-check-after-cmp-max.rs
 create mode 100644 tests/codegen-llvm/issues/issue-114312.rs
 create mode 100644 tests/codegen-llvm/issues/issue-115385-llvm-jump-threading.rs
 create mode 100644 tests/codegen-llvm/issues/issue-116878.rs
 create mode 100644 tests/codegen-llvm/issues/issue-118306.rs
 create mode 100644 tests/codegen-llvm/issues/issue-118392.rs
 create mode 100644 tests/codegen-llvm/issues/issue-119422.rs
 create mode 100644 tests/codegen-llvm/issues/issue-121719-common-field-offset.rs
 create mode 100644 tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs
 create mode 100644 tests/codegen-llvm/issues/issue-123712-str-to-lower-autovectorization.rs
 create mode 100644 tests/codegen-llvm/issues/issue-126585.rs
 create mode 100644 tests/codegen-llvm/issues/issue-129795.rs
 create mode 100644 tests/codegen-llvm/issues/issue-13018.rs
 create mode 100644 tests/codegen-llvm/issues/issue-136329-optnone-noinline.rs
 create mode 100644 tests/codegen-llvm/issues/issue-15953.rs
 create mode 100644 tests/codegen-llvm/issues/issue-27130.rs
 create mode 100644 tests/codegen-llvm/issues/issue-32031.rs
 create mode 100644 tests/codegen-llvm/issues/issue-32364.rs
 create mode 100644 tests/codegen-llvm/issues/issue-34634.rs
 create mode 100644 tests/codegen-llvm/issues/issue-34947-pow-i32.rs
 create mode 100644 tests/codegen-llvm/issues/issue-36010-some-box-is_some.rs
 create mode 100644 tests/codegen-llvm/issues/issue-37945.rs
 create mode 100644 tests/codegen-llvm/issues/issue-45222.rs
 create mode 100644 tests/codegen-llvm/issues/issue-45466.rs
 create mode 100644 tests/codegen-llvm/issues/issue-45964-bounds-check-slice-pos.rs
 create mode 100644 tests/codegen-llvm/issues/issue-47278.rs
 create mode 100644 tests/codegen-llvm/issues/issue-47442.rs
 create mode 100644 tests/codegen-llvm/issues/issue-56267-2.rs
 create mode 100644 tests/codegen-llvm/issues/issue-56267.rs
 create mode 100644 tests/codegen-llvm/issues/issue-56927.rs
 create mode 100644 tests/codegen-llvm/issues/issue-58881.rs
 create mode 100644 tests/codegen-llvm/issues/issue-59352.rs
 create mode 100644 tests/codegen-llvm/issues/issue-64219-fn-ptr-call-returning-never-is-noreturn.rs
 create mode 100644 tests/codegen-llvm/issues/issue-68667-unwrap-combinators.rs
 create mode 100644 tests/codegen-llvm/issues/issue-69101-bounds-check.rs
 create mode 100644 tests/codegen-llvm/issues/issue-73031.rs
 create mode 100644 tests/codegen-llvm/issues/issue-73258.rs
 create mode 100644 tests/codegen-llvm/issues/issue-73338-effecient-cmp.rs
 create mode 100644 tests/codegen-llvm/issues/issue-73396-bounds-check-after-position.rs
 create mode 100644 tests/codegen-llvm/issues/issue-73827-bounds-check-index-in-subexpr.rs
 create mode 100644 tests/codegen-llvm/issues/issue-74938-array-split-at.rs
 create mode 100644 tests/codegen-llvm/issues/issue-75525-bounds-checks.rs
 create mode 100644 tests/codegen-llvm/issues/issue-75546.rs
 create mode 100644 tests/codegen-llvm/issues/issue-75659.rs
 create mode 100644 tests/codegen-llvm/issues/issue-75978.rs
 create mode 100644 tests/codegen-llvm/issues/issue-77812.rs
 create mode 100644 tests/codegen-llvm/issues/issue-84268.rs
 create mode 100644 tests/codegen-llvm/issues/issue-85872-multiple-reverse.rs
 create mode 100644 tests/codegen-llvm/issues/issue-86106.rs
 create mode 100644 tests/codegen-llvm/issues/issue-86109-eliminate-div-by-zero-check.rs
 create mode 100644 tests/codegen-llvm/issues/issue-93036-assert-index.rs
 create mode 100644 tests/codegen-llvm/issues/issue-96274.rs
 create mode 100644 tests/codegen-llvm/issues/issue-96497-slice-size-nowrap.rs
 create mode 100644 tests/codegen-llvm/issues/issue-98294-get-mut-copy-from-slice-opt.rs
 create mode 100644 tests/codegen-llvm/issues/issue-98678-async.rs
 create mode 100644 tests/codegen-llvm/issues/issue-98678-closure-coroutine.rs
 create mode 100644 tests/codegen-llvm/issues/issue-98678-enum.rs
 create mode 100644 tests/codegen-llvm/issues/issue-98678-struct-union.rs
 create mode 100644 tests/codegen-llvm/issues/issue-99960.rs
 create mode 100644 tests/codegen-llvm/issues/looping-over-ne-bytes-133528.rs
 create mode 100644 tests/codegen-llvm/issues/str-to-string-128690.rs
 create mode 100644 tests/codegen-llvm/iter-repeat-n-trivial-drop.rs
 create mode 100644 tests/codegen-llvm/layout-size-checks.rs
 create mode 100644 tests/codegen-llvm/lib-optimizations/iter-sum.rs
 create mode 100644 tests/codegen-llvm/lib-optimizations/slice_rotate.rs
 create mode 100644 tests/codegen-llvm/lifetime_start_end.rs
 create mode 100644 tests/codegen-llvm/link-dead-code.rs
 create mode 100644 tests/codegen-llvm/link_section.rs
 create mode 100644 tests/codegen-llvm/llvm-ident.rs
 create mode 100644 tests/codegen-llvm/llvm_module_flags.rs
 create mode 100644 tests/codegen-llvm/loads.rs
 create mode 100644 tests/codegen-llvm/local-generics-in-exe-internalized.rs
 create mode 100644 tests/codegen-llvm/loongarch-abi/call-llvm-intrinsics.rs
 create mode 100644 tests/codegen-llvm/loongarch-abi/loongarch64-lp64d-abi.rs
 create mode 100644 tests/codegen-llvm/lto-removes-invokes.rs
 create mode 100644 tests/codegen-llvm/macos/i686-macosx-deployment-target.rs
 create mode 100644 tests/codegen-llvm/macos/i686-no-macosx-deployment-target.rs
 create mode 100644 tests/codegen-llvm/macos/x86_64-macosx-deployment-target.rs
 create mode 100644 tests/codegen-llvm/macos/x86_64-no-macosx-deployment-target.rs
 create mode 100644 tests/codegen-llvm/mainsubprogram.rs
 create mode 100644 tests/codegen-llvm/match-optimized.rs
 create mode 100644 tests/codegen-llvm/match-optimizes-away.rs
 create mode 100644 tests/codegen-llvm/match-unoptimized.rs
 create mode 100644 tests/codegen-llvm/maybeuninit-rvo.rs
 create mode 100644 tests/codegen-llvm/mem-replace-big-type.rs
 create mode 100644 tests/codegen-llvm/mem-replace-simple-type.rs
 create mode 100644 tests/codegen-llvm/merge-functions.rs
 create mode 100644 tests/codegen-llvm/meta-filecheck/check-prefix.rs
 create mode 100644 tests/codegen-llvm/meta-filecheck/filecheck-flags.rs
 create mode 100644 tests/codegen-llvm/meta-filecheck/msvc-prefix-bad.rs
 create mode 100644 tests/codegen-llvm/meta-filecheck/no-directives.rs
 create mode 100644 tests/codegen-llvm/meta-filecheck/revision-prefix.rs
 create mode 100644 tests/codegen-llvm/method-declaration.rs
 create mode 100644 tests/codegen-llvm/min-function-alignment.rs
 create mode 100644 tests/codegen-llvm/mir-aggregate-no-alloca.rs
 create mode 100644 tests/codegen-llvm/mir-inlined-line-numbers.rs
 create mode 100644 tests/codegen-llvm/mir_zst_stores.rs
 create mode 100644 tests/codegen-llvm/move-before-nocapture-ref-arg.rs
 create mode 100644 tests/codegen-llvm/move-operands.rs
 create mode 100644 tests/codegen-llvm/naked-asan.rs
 create mode 100644 tests/codegen-llvm/naked-fn/aligned.rs
 create mode 100644 tests/codegen-llvm/naked-fn/generics.rs
 create mode 100644 tests/codegen-llvm/naked-fn/instruction-set.rs
 create mode 100644 tests/codegen-llvm/naked-fn/min-function-alignment.rs
 create mode 100644 tests/codegen-llvm/naked-fn/naked-functions.rs
 create mode 100644 tests/codegen-llvm/no-alloca-inside-if-false.rs
 create mode 100644 tests/codegen-llvm/no-assumes-on-casts.rs
 create mode 100644 tests/codegen-llvm/no-dllimport-w-cross-lang-lto.rs
 create mode 100644 tests/codegen-llvm/no-jump-tables.rs
 create mode 100644 tests/codegen-llvm/no-plt.rs
 create mode 100644 tests/codegen-llvm/no-redundant-item-monomorphization.rs
 create mode 100644 tests/codegen-llvm/no_builtins-at-crate.rs
 create mode 100644 tests/codegen-llvm/noalias-box-off.rs
 create mode 100644 tests/codegen-llvm/noalias-box.rs
 create mode 100644 tests/codegen-llvm/noalias-flag.rs
 create mode 100644 tests/codegen-llvm/noalias-freeze.rs
 create mode 100644 tests/codegen-llvm/noalias-refcell.rs
 create mode 100644 tests/codegen-llvm/noalias-rwlockreadguard.rs
 create mode 100644 tests/codegen-llvm/noalias-unpin.rs
 create mode 100644 tests/codegen-llvm/non-terminate/infinite-loop-1.rs
 create mode 100644 tests/codegen-llvm/non-terminate/infinite-loop-2.rs
 create mode 100644 tests/codegen-llvm/non-terminate/infinite-recursion.rs
 create mode 100644 tests/codegen-llvm/non-terminate/nonempty-infinite-loop.rs
 create mode 100644 tests/codegen-llvm/noreturn-uninhabited.rs
 create mode 100644 tests/codegen-llvm/noreturnflag.rs
 create mode 100644 tests/codegen-llvm/nounwind.rs
 create mode 100644 tests/codegen-llvm/nrvo.rs
 create mode 100644 tests/codegen-llvm/optimize-attr-1.rs
 create mode 100644 tests/codegen-llvm/option-as-slice.rs
 create mode 100644 tests/codegen-llvm/option-niche-eq.rs
 create mode 100644 tests/codegen-llvm/option-niche-unfixed/option-nonzero-eq.rs
 create mode 100644 tests/codegen-llvm/overaligned-constant.rs
 create mode 100644 tests/codegen-llvm/packed.rs
 create mode 100644 tests/codegen-llvm/panic-abort-windows.rs
 create mode 100644 tests/codegen-llvm/panic-in-drop-abort.rs
 create mode 100644 tests/codegen-llvm/panic-unwind-default-uwtable.rs
 create mode 100644 tests/codegen-llvm/patchable-function-entry/patchable-function-entry-both-flags.rs
 create mode 100644 tests/codegen-llvm/patchable-function-entry/patchable-function-entry-no-flag.rs
 create mode 100644 tests/codegen-llvm/patchable-function-entry/patchable-function-entry-one-flag.rs
 create mode 100644 tests/codegen-llvm/pattern_type_symbols.rs
 create mode 100644 tests/codegen-llvm/personality_lifetimes.rs
 create mode 100644 tests/codegen-llvm/pgo-counter-bias.rs
 create mode 100644 tests/codegen-llvm/pgo-instrumentation.rs
 create mode 100644 tests/codegen-llvm/pic-relocation-model.rs
 create mode 100644 tests/codegen-llvm/pie-relocation-model.rs
 create mode 100644 tests/codegen-llvm/placement-new.rs
 create mode 100644 tests/codegen-llvm/powerpc64le-struct-align-128.rs
 create mode 100644 tests/codegen-llvm/precondition-checks.rs
 create mode 100644 tests/codegen-llvm/ptr-arithmetic.rs
 create mode 100644 tests/codegen-llvm/ptr-read-metadata.rs
 create mode 100644 tests/codegen-llvm/range-attribute.rs
 create mode 100644 tests/codegen-llvm/range-loop.rs
 create mode 100644 tests/codegen-llvm/range_to_inclusive.rs
 create mode 100644 tests/codegen-llvm/refs.rs
 create mode 100644 tests/codegen-llvm/reg-struct-return.rs
 create mode 100644 tests/codegen-llvm/regparm-inreg.rs
 create mode 100644 tests/codegen-llvm/remap_path_prefix/aux_mod.rs
 create mode 100644 tests/codegen-llvm/remap_path_prefix/auxiliary/remap_path_prefix_aux.rs
 create mode 100644 tests/codegen-llvm/remap_path_prefix/auxiliary/xcrate-generic.rs
 create mode 100644 tests/codegen-llvm/remap_path_prefix/issue-73167-remap-std.rs
 create mode 100644 tests/codegen-llvm/remap_path_prefix/main.rs
 create mode 100644 tests/codegen-llvm/remap_path_prefix/xcrate-generic.rs
 create mode 100644 tests/codegen-llvm/repeat-operand-zero-len.rs
 create mode 100644 tests/codegen-llvm/repeat-operand-zst-elem.rs
 create mode 100644 tests/codegen-llvm/repeat-trusted-len.rs
 create mode 100644 tests/codegen-llvm/repr/transparent-byval-struct-ptr.rs
 create mode 100644 tests/codegen-llvm/repr/transparent-imm-array.rs
 create mode 100644 tests/codegen-llvm/repr/transparent-mips64.rs
 create mode 100644 tests/codegen-llvm/repr/transparent-opaque-ptr.rs
 create mode 100644 tests/codegen-llvm/repr/transparent-sparc64.rs
 create mode 100644 tests/codegen-llvm/repr/transparent-sysv64.rs
 create mode 100644 tests/codegen-llvm/repr/transparent.rs
 create mode 100644 tests/codegen-llvm/retpoline.rs
 create mode 100644 tests/codegen-llvm/riscv-abi/call-llvm-intrinsics.rs
 create mode 100644 tests/codegen-llvm/riscv-abi/cast-local-large-enough.rs
 create mode 100644 tests/codegen-llvm/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
 create mode 100644 tests/codegen-llvm/riscv-abi/riscv64-lp64d-abi.rs
 create mode 100644 tests/codegen-llvm/riscv-abi/riscv64-lp64f-lp64d-abi.rs
 create mode 100644 tests/codegen-llvm/riscv-target-abi.rs
 create mode 100644 tests/codegen-llvm/rust-abi-arch-specific-adjustment.rs
 create mode 100644 tests/codegen-llvm/s390x-simd.rs
 create mode 100644 tests/codegen-llvm/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
 create mode 100644 tests/codegen-llvm/sanitizer/address-sanitizer-globals-tracking.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/add-canonical-jump-tables-flag.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/add-enable-split-lto-unit-flag.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/dbg-location-on-cfi-blocks.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-checks-attr-no-sanitize.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-checks.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-trait-objects.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/external_weak_symbols.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/generalize-pointers.rs
 create mode 100644 tests/codegen-llvm/sanitizer/cfi/normalize-integers.rs
 create mode 100644 tests/codegen-llvm/sanitizer/dataflow-instrument-functions.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kasan-emits-instrumentation.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/add-kcfi-arity-flag.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/add-kcfi-flag.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/add-kcfi-offset-flag.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/emit-type-metadata-trait-objects.rs
 create mode 100644 tests/codegen-llvm/sanitizer/kcfi/naked-function.rs
 create mode 100644 tests/codegen-llvm/sanitizer/memory-track-origins.rs
 create mode 100644 tests/codegen-llvm/sanitizer/memtag-attr-check.rs
 create mode 100644 tests/codegen-llvm/sanitizer/no-sanitize-inlining.rs
 create mode 100644 tests/codegen-llvm/sanitizer/no-sanitize.rs
 create mode 100644 tests/codegen-llvm/sanitizer/riscv64-shadow-call-stack.rs
 create mode 100644 tests/codegen-llvm/sanitizer/safestack-attr-check.rs
 create mode 100644 tests/codegen-llvm/sanitizer/sanitizer-recover.rs
 create mode 100644 tests/codegen-llvm/sanitizer/scs-attr-check.rs
 create mode 100644 tests/codegen-llvm/scalar-pair-bool.rs
 create mode 100644 tests/codegen-llvm/set-discriminant-invalid.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-abs.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-ceil.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-cos.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-exp.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-exp2.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-floor.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-fma.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log10.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log2.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-minmax.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-sin.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-gather.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-scatter.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-select.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-mask-reduce.rs
 create mode 100644 tests/codegen-llvm/simd-intrinsic/simd-intrinsic-transmute-array.rs
 create mode 100644 tests/codegen-llvm/simd/aggregate-simd.rs
 create mode 100644 tests/codegen-llvm/simd/extract-insert-dyn.rs
 create mode 100644 tests/codegen-llvm/simd/packed-simd-alignment.rs
 create mode 100644 tests/codegen-llvm/simd/packed-simd.rs
 create mode 100644 tests/codegen-llvm/simd/simd-wide-sum.rs
 create mode 100644 tests/codegen-llvm/simd/simd_arith_offset.rs
 create mode 100644 tests/codegen-llvm/simd/swap-simd-types.rs
 create mode 100644 tests/codegen-llvm/simd/unpadded-simd.rs
 create mode 100644 tests/codegen-llvm/skip-mono-inside-if-false.rs
 create mode 100644 tests/codegen-llvm/slice-as_chunks.rs
 create mode 100644 tests/codegen-llvm/slice-indexing.rs
 create mode 100644 tests/codegen-llvm/slice-init.rs
 create mode 100644 tests/codegen-llvm/slice-is-ascii.rs
 create mode 100644 tests/codegen-llvm/slice-iter-fold.rs
 create mode 100644 tests/codegen-llvm/slice-iter-len-eq-zero.rs
 create mode 100644 tests/codegen-llvm/slice-iter-nonnull.rs
 create mode 100644 tests/codegen-llvm/slice-last-elements-optimization.rs
 create mode 100644 tests/codegen-llvm/slice-pointer-nonnull-unwrap.rs
 create mode 100644 tests/codegen-llvm/slice-position-bounds-check.rs
 create mode 100644 tests/codegen-llvm/slice-ref-equality.rs
 create mode 100644 tests/codegen-llvm/slice-reverse.rs
 create mode 100644 tests/codegen-llvm/slice-split-at.rs
 create mode 100644 tests/codegen-llvm/slice-windows-no-bounds-check.rs
 create mode 100644 tests/codegen-llvm/slice_as_from_ptr_range.rs
 create mode 100644 tests/codegen-llvm/some-abis-do-extend-params-to-32-bits.rs
 create mode 100644 tests/codegen-llvm/some-global-nonnull.rs
 create mode 100644 tests/codegen-llvm/sparc-struct-abi.rs
 create mode 100644 tests/codegen-llvm/split-lto-unit.rs
 create mode 100644 tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-md5.rs
 create mode 100644 tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-sha1.rs
 create mode 100644 tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-sha256.rs
 create mode 100644 tests/codegen-llvm/sroa-fragment-debuginfo.rs
 create mode 100644 tests/codegen-llvm/sse42-implies-crc32.rs
 create mode 100644 tests/codegen-llvm/stack-probes-inline.rs
 create mode 100644 tests/codegen-llvm/stack-protector.rs
 create mode 100644 tests/codegen-llvm/static-relocation-model-msvc.rs
 create mode 100644 tests/codegen-llvm/staticlib-external-inline-fns.rs
 create mode 100644 tests/codegen-llvm/step_by-overflow-checks.rs
 create mode 100644 tests/codegen-llvm/stores.rs
 create mode 100644 tests/codegen-llvm/string-push.rs
 create mode 100644 tests/codegen-llvm/swap-large-types.rs
 create mode 100644 tests/codegen-llvm/swap-small-types.rs
 create mode 100644 tests/codegen-llvm/target-cpu-on-functions.rs
 create mode 100644 tests/codegen-llvm/target-feature-inline-closure.rs
 create mode 100644 tests/codegen-llvm/target-feature-negative-implication.rs
 create mode 100644 tests/codegen-llvm/target-feature-overrides.rs
 create mode 100644 tests/codegen-llvm/terminating-catchpad.rs
 create mode 100644 tests/codegen-llvm/thread-local.rs
 create mode 100644 tests/codegen-llvm/tied-features-strength.rs
 create mode 100644 tests/codegen-llvm/to_vec.rs
 create mode 100644 tests/codegen-llvm/trailing_zeros.rs
 create mode 100644 tests/codegen-llvm/transmute-optimized.rs
 create mode 100644 tests/codegen-llvm/transmute-scalar.rs
 create mode 100644 tests/codegen-llvm/try_question_mark_nop.rs
 create mode 100644 tests/codegen-llvm/tune-cpu-on-functions.rs
 create mode 100644 tests/codegen-llvm/tuple-layout-opt.rs
 create mode 100644 tests/codegen-llvm/ub-checks.rs
 create mode 100644 tests/codegen-llvm/unchecked-float-casts.rs
 create mode 100644 tests/codegen-llvm/unchecked_shifts.rs
 create mode 100644 tests/codegen-llvm/uninhabited-transparent-return-abi.rs
 create mode 100644 tests/codegen-llvm/uninit-consts.rs
 create mode 100644 tests/codegen-llvm/uninit-repeat-in-aggregate.rs
 create mode 100644 tests/codegen-llvm/union-abi.rs
 create mode 100644 tests/codegen-llvm/union-aggregate.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/aapcs-unwind-abi.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/c-unwind-abi-panic-abort.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/c-unwind-abi.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/cdecl-unwind-abi.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/fastcall-unwind-abi.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/nounwind-on-stable-panic-abort.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/nounwind.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/stdcall-unwind-abi.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/system-unwind-abi.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/sysv64-unwind-abi.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/thiscall-unwind-abi.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/vectorcall-unwind-abi.rs
 create mode 100644 tests/codegen-llvm/unwind-abis/win64-unwind-abi.rs
 create mode 100644 tests/codegen-llvm/unwind-and-panic-abort.rs
 create mode 100644 tests/codegen-llvm/unwind-extern-exports.rs
 create mode 100644 tests/codegen-llvm/unwind-extern-imports.rs
 create mode 100644 tests/codegen-llvm/unwind-landingpad-cold.rs
 create mode 100644 tests/codegen-llvm/unwind-landingpad-inline.rs
 create mode 100644 tests/codegen-llvm/used_with_arg.rs
 create mode 100644 tests/codegen-llvm/var-names.rs
 create mode 100644 tests/codegen-llvm/vec-as-ptr.rs
 create mode 100644 tests/codegen-llvm/vec-calloc.rs
 create mode 100644 tests/codegen-llvm/vec-in-place.rs
 create mode 100644 tests/codegen-llvm/vec-iter-collect-len.rs
 create mode 100644 tests/codegen-llvm/vec-iter.rs
 create mode 100644 tests/codegen-llvm/vec-len-invariant.rs
 create mode 100644 tests/codegen-llvm/vec-optimizes-away.rs
 create mode 100644 tests/codegen-llvm/vec-reserve-extend.rs
 create mode 100644 tests/codegen-llvm/vec-shrink-panik.rs
 create mode 100644 tests/codegen-llvm/vec-with-capacity.rs
 create mode 100644 tests/codegen-llvm/vec_pop_push_noop.rs
 create mode 100644 tests/codegen-llvm/vecdeque-drain.rs
 create mode 100644 tests/codegen-llvm/vecdeque-nonempty-get-no-panic.rs
 create mode 100644 tests/codegen-llvm/vecdeque_no_panic.rs
 create mode 100644 tests/codegen-llvm/vecdeque_pop_push.rs
 create mode 100644 tests/codegen-llvm/virtual-call-attrs-issue-137646.rs
 create mode 100644 tests/codegen-llvm/virtual-function-elimination-32bit.rs
 create mode 100644 tests/codegen-llvm/virtual-function-elimination.rs
 create mode 100644 tests/codegen-llvm/vtable-loads.rs
 create mode 100644 tests/codegen-llvm/vtable-upcast.rs
 create mode 100644 tests/codegen-llvm/wasm_casts_trapping.rs
 create mode 100644 tests/codegen-llvm/wasm_exceptions.rs
 create mode 100644 tests/codegen-llvm/zip.rs
 create mode 100644 tests/codegen-llvm/zst-offset.rs
 delete mode 100644 tests/codegen/README.md
 delete mode 100644 tests/codegen/aarch64-softfloat.rs
 delete mode 100644 tests/codegen/aarch64-struct-align-128.rs
 delete mode 100644 tests/codegen/abi-efiapi.rs
 delete mode 100644 tests/codegen/abi-main-signature-16bit-c-int.rs
 delete mode 100644 tests/codegen/abi-main-signature-32bit-c-int.rs
 delete mode 100644 tests/codegen/abi-repr-ext.rs
 delete mode 100644 tests/codegen/abi-sysv64.rs
 delete mode 100644 tests/codegen/abi-win64-zst.rs
 delete mode 100644 tests/codegen/abi-x86-interrupt.rs
 delete mode 100644 tests/codegen/abi-x86-sse.rs
 delete mode 100644 tests/codegen/abi-x86_64_sysv.rs
 delete mode 100644 tests/codegen/addr-of-mutate.rs
 delete mode 100644 tests/codegen/adjustments.rs
 delete mode 100644 tests/codegen/align-byval-alignment-mismatch.rs
 delete mode 100644 tests/codegen/align-byval-vector.rs
 delete mode 100644 tests/codegen/align-byval.rs
 delete mode 100644 tests/codegen/align-enum.rs
 delete mode 100644 tests/codegen/align-fn.rs
 delete mode 100644 tests/codegen/align-offset.rs
 delete mode 100644 tests/codegen/align-struct.rs
 delete mode 100644 tests/codegen/alloc-optimisation.rs
 delete mode 100644 tests/codegen/amdgpu-addrspacecast.rs
 delete mode 100644 tests/codegen/array-clone.rs
 delete mode 100644 tests/codegen/array-cmp.rs
 delete mode 100644 tests/codegen/array-codegen.rs
 delete mode 100644 tests/codegen/array-equality.rs
 delete mode 100644 tests/codegen/array-from_fn.rs
 delete mode 100644 tests/codegen/array-map.rs
 delete mode 100644 tests/codegen/array-optimized.rs
 delete mode 100644 tests/codegen/array-repeat.rs
 delete mode 100644 tests/codegen/ascii-char.rs
 delete mode 100644 tests/codegen/asm/aarch64-clobbers.rs
 delete mode 100644 tests/codegen/asm/avr-clobbers.rs
 delete mode 100644 tests/codegen/asm/bpf-clobbers.rs
 delete mode 100644 tests/codegen/asm/critical.rs
 delete mode 100644 tests/codegen/asm/csky-clobbers.rs
 delete mode 100644 tests/codegen/asm/foo.s
 delete mode 100644 tests/codegen/asm/global_asm.rs
 delete mode 100644 tests/codegen/asm/global_asm_include.rs
 delete mode 100644 tests/codegen/asm/global_asm_x2.rs
 delete mode 100644 tests/codegen/asm/goto.rs
 delete mode 100644 tests/codegen/asm/hexagon-clobbers.rs
 delete mode 100644 tests/codegen/asm/may_unwind.rs
 delete mode 100644 tests/codegen/asm/maybe-uninit.rs
 delete mode 100644 tests/codegen/asm/msp430-clobbers.rs
 delete mode 100644 tests/codegen/asm/multiple-options.rs
 delete mode 100644 tests/codegen/asm/options.rs
 delete mode 100644 tests/codegen/asm/powerpc-clobbers.rs
 delete mode 100644 tests/codegen/asm/riscv-clobbers.rs
 delete mode 100644 tests/codegen/asm/s390x-clobbers.rs
 delete mode 100644 tests/codegen/asm/sanitize-llvm.rs
 delete mode 100644 tests/codegen/asm/sparc-clobbers.rs
 delete mode 100644 tests/codegen/asm/x86-clobber_abi.rs
 delete mode 100644 tests/codegen/asm/x86-clobbers.rs
 delete mode 100644 tests/codegen/asm/x86-target-clobbers.rs
 delete mode 100644 tests/codegen/assign-desugar-debuginfo.rs
 delete mode 100644 tests/codegen/async-closure-debug.rs
 delete mode 100644 tests/codegen/async-fn-debug-awaitee-field.rs
 delete mode 100644 tests/codegen/async-fn-debug-msvc.rs
 delete mode 100644 tests/codegen/async-fn-debug.rs
 delete mode 100644 tests/codegen/atomic-operations.rs
 delete mode 100644 tests/codegen/atomicptr.rs
 delete mode 100644 tests/codegen/autodiff/batched.rs
 delete mode 100644 tests/codegen/autodiff/generic.rs
 delete mode 100644 tests/codegen/autodiff/identical_fnc.rs
 delete mode 100644 tests/codegen/autodiff/inline.rs
 delete mode 100644 tests/codegen/autodiff/scalar.rs
 delete mode 100644 tests/codegen/autodiff/sret.rs
 delete mode 100644 tests/codegen/autodiffv2.rs
 delete mode 100644 tests/codegen/autovec/dont-shuffle-bswaps-opt2.rs
 delete mode 100644 tests/codegen/autovec/dont-shuffle-bswaps-opt3.rs
 delete mode 100644 tests/codegen/autovectorize-f32x4.rs
 delete mode 100644 tests/codegen/auxiliary/extern_decl.rs
 delete mode 100644 tests/codegen/auxiliary/nounwind.rs
 delete mode 100644 tests/codegen/auxiliary/thread_local_aux.rs
 delete mode 100644 tests/codegen/avr/avr-func-addrspace.rs
 delete mode 100644 tests/codegen/bigint-helpers.rs
 delete mode 100644 tests/codegen/binary-heap-peek-mut-pop-no-panic.rs
 delete mode 100644 tests/codegen/binary-search-index-no-bound-check.rs
 delete mode 100644 tests/codegen/bool-cmp.rs
 delete mode 100644 tests/codegen/bounds-checking/gep-issue-133979.rs
 delete mode 100644 tests/codegen/box-default-debug-copies.rs
 delete mode 100644 tests/codegen/box-uninit-bytes.rs
 delete mode 100644 tests/codegen/bpf-alu32.rs
 delete mode 100644 tests/codegen/branch-protection.rs
 delete mode 100644 tests/codegen/call-llvm-intrinsics.rs
 delete mode 100644 tests/codegen/call-tmps-lifetime.rs
 delete mode 100644 tests/codegen/cast-optimized.rs
 delete mode 100644 tests/codegen/cast-target-abi.rs
 delete mode 100644 tests/codegen/catch-unwind.rs
 delete mode 100644 tests/codegen/cdylib-external-inline-fns.rs
 delete mode 100644 tests/codegen/cf-protection.rs
 delete mode 100644 tests/codegen/cffi/c-variadic-copy.rs
 delete mode 100644 tests/codegen/cffi/c-variadic-naked.rs
 delete mode 100644 tests/codegen/cffi/c-variadic-opt.rs
 delete mode 100644 tests/codegen/cffi/c-variadic.rs
 delete mode 100644 tests/codegen/cffi/ffi-const.rs
 delete mode 100644 tests/codegen/cffi/ffi-out-of-bounds-loads.rs
 delete mode 100644 tests/codegen/cffi/ffi-pure.rs
 delete mode 100644 tests/codegen/cfguard-checks.rs
 delete mode 100644 tests/codegen/cfguard-disabled.rs
 delete mode 100644 tests/codegen/cfguard-nochecks.rs
 delete mode 100644 tests/codegen/cfguard-non-msvc.rs
 delete mode 100644 tests/codegen/char-ascii-branchless.rs
 delete mode 100644 tests/codegen/char-escape-debug-no-bounds-check.rs
 delete mode 100644 tests/codegen/checked_ilog.rs
 delete mode 100644 tests/codegen/checked_math.rs
 delete mode 100644 tests/codegen/clone-shims.rs
 delete mode 100644 tests/codegen/clone_as_copy.rs
 delete mode 100644 tests/codegen/codemodels.rs
 delete mode 100644 tests/codegen/coercions.rs
 delete mode 100644 tests/codegen/cold-call-declare-and-call.rs
 delete mode 100644 tests/codegen/common_prim_int_ptr.rs
 delete mode 100644 tests/codegen/comparison-operators-2-struct.rs
 delete mode 100644 tests/codegen/comparison-operators-2-tuple.rs
 delete mode 100644 tests/codegen/comparison-operators-newtype.rs
 delete mode 100644 tests/codegen/compiletest-self-test/minicore-smoke-test.rs
 delete mode 100644 tests/codegen/const-array.rs
 delete mode 100644 tests/codegen/const-vector.rs
 delete mode 100644 tests/codegen/const_scalar_pair.rs
 delete mode 100644 tests/codegen/constant-branch.rs
 delete mode 100644 tests/codegen/consts.rs
 delete mode 100644 tests/codegen/coroutine-debug-msvc.rs
 delete mode 100644 tests/codegen/coroutine-debug.rs
 delete mode 100644 tests/codegen/cross-crate-inlining/always-inline.rs
 delete mode 100644 tests/codegen/cross-crate-inlining/auxiliary/always.rs
 delete mode 100644 tests/codegen/cross-crate-inlining/auxiliary/leaf.rs
 delete mode 100644 tests/codegen/cross-crate-inlining/auxiliary/never.rs
 delete mode 100644 tests/codegen/cross-crate-inlining/leaf-inlining.rs
 delete mode 100644 tests/codegen/cross-crate-inlining/never-inline.rs
 delete mode 100644 tests/codegen/dealloc-no-unwind.rs
 delete mode 100644 tests/codegen/debug-accessibility/crate-enum.rs
 delete mode 100644 tests/codegen/debug-accessibility/crate-struct.rs
 delete mode 100644 tests/codegen/debug-accessibility/private-enum.rs
 delete mode 100644 tests/codegen/debug-accessibility/private-struct.rs
 delete mode 100644 tests/codegen/debug-accessibility/public-enum.rs
 delete mode 100644 tests/codegen/debug-accessibility/public-struct.rs
 delete mode 100644 tests/codegen/debug-accessibility/struct-fields.rs
 delete mode 100644 tests/codegen/debug-accessibility/super-enum.rs
 delete mode 100644 tests/codegen/debug-accessibility/super-struct.rs
 delete mode 100644 tests/codegen/debug-accessibility/tuple-fields.rs
 delete mode 100644 tests/codegen/debug-alignment.rs
 delete mode 100644 tests/codegen/debug-column-msvc.rs
 delete mode 100644 tests/codegen/debug-column.rs
 delete mode 100644 tests/codegen/debug-compile-unit-path.rs
 delete mode 100644 tests/codegen/debug-fndef-size.rs
 delete mode 100644 tests/codegen/debug-limited.rs
 delete mode 100644 tests/codegen/debug-line-directives-only.rs
 delete mode 100644 tests/codegen/debug-line-tables-only.rs
 delete mode 100644 tests/codegen/debug-linkage-name.rs
 delete mode 100644 tests/codegen/debug-vtable.rs
 delete mode 100644 tests/codegen/debuginfo-constant-locals.rs
 delete mode 100644 tests/codegen/debuginfo-generic-closure-env-names.rs
 delete mode 100644 tests/codegen/debuginfo-inline-callsite-location.rs
 delete mode 100644 tests/codegen/debuginfo-proc-macro/auxiliary/macro_def.rs
 delete mode 100644 tests/codegen/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs
 delete mode 100644 tests/codegen/deduced-param-attrs.rs
 delete mode 100644 tests/codegen/default-requires-uwtable.rs
 delete mode 100644 tests/codegen/default-visibility.rs
 delete mode 100644 tests/codegen/direct-access-external-data.rs
 delete mode 100644 tests/codegen/dllimports/auxiliary/dummy.rs
 delete mode 100644 tests/codegen/dllimports/auxiliary/wrapper.rs
 delete mode 100644 tests/codegen/dllimports/main.rs
 delete mode 100644 tests/codegen/dont_codegen_private_const_fn_only_used_in_const_eval.rs
 delete mode 100644 tests/codegen/drop-in-place-noalias.rs
 delete mode 100644 tests/codegen/drop.rs
 delete mode 100644 tests/codegen/dst-offset.rs
 delete mode 100644 tests/codegen/dst-vtable-align-nonzero.rs
 delete mode 100644 tests/codegen/dst-vtable-size-range.rs
 delete mode 100644 tests/codegen/ehcontguard_disabled.rs
 delete mode 100644 tests/codegen/ehcontguard_enabled.rs
 delete mode 100644 tests/codegen/emscripten-catch-unwind-js-eh.rs
 delete mode 100644 tests/codegen/emscripten-catch-unwind-wasm-eh.rs
 delete mode 100644 tests/codegen/enable-lto-unit-splitting.rs
 delete mode 100644 tests/codegen/enum/enum-aggregate.rs
 delete mode 100644 tests/codegen/enum/enum-bounds-check-derived-idx.rs
 delete mode 100644 tests/codegen/enum/enum-bounds-check-issue-13926.rs
 delete mode 100644 tests/codegen/enum/enum-bounds-check-issue-82871.rs
 delete mode 100644 tests/codegen/enum/enum-bounds-check.rs
 delete mode 100644 tests/codegen/enum/enum-debug-clike.rs
 delete mode 100644 tests/codegen/enum/enum-debug-niche-2.rs
 delete mode 100644 tests/codegen/enum/enum-debug-niche.rs
 delete mode 100644 tests/codegen/enum/enum-debug-tagged.rs
 delete mode 100644 tests/codegen/enum/enum-discriminant-eq.rs
 delete mode 100644 tests/codegen/enum/enum-discriminant-value.rs
 delete mode 100644 tests/codegen/enum/enum-early-otherwise-branch.rs
 delete mode 100644 tests/codegen/enum/enum-match.rs
 delete mode 100644 tests/codegen/enum/enum-two-variants-match.rs
 delete mode 100644 tests/codegen/enum/enum-u128.rs
 delete mode 100644 tests/codegen/enum/unreachable_enum_default_branch.rs
 delete mode 100644 tests/codegen/ergonomic-clones/closure.rs
 delete mode 100644 tests/codegen/error-provide.rs
 delete mode 100644 tests/codegen/export-no-mangle.rs
 delete mode 100644 tests/codegen/external-no-mangle-fns.rs
 delete mode 100644 tests/codegen/external-no-mangle-statics.rs
 delete mode 100644 tests/codegen/f128-wasm32-callconv.rs
 delete mode 100644 tests/codegen/fastcall-inreg.rs
 delete mode 100644 tests/codegen/fatptr.rs
 delete mode 100644 tests/codegen/fewer-names.rs
 delete mode 100644 tests/codegen/fixed-x18.rs
 delete mode 100644 tests/codegen/float/algebraic.rs
 delete mode 100644 tests/codegen/float/f128.rs
 delete mode 100644 tests/codegen/float/f16-f128-inline.rs
 delete mode 100644 tests/codegen/float/f16.rs
 delete mode 100644 tests/codegen/float_math.rs
 delete mode 100644 tests/codegen/fn-impl-trait-self.rs
 delete mode 100644 tests/codegen/fn-parameters-on-different-lines-debuginfo.rs
 delete mode 100644 tests/codegen/force-frame-pointers.rs
 delete mode 100644 tests/codegen/force-no-unwind-tables.rs
 delete mode 100644 tests/codegen/force-unwind-tables.rs
 delete mode 100644 tests/codegen/frame-pointer-cli-control.rs
 delete mode 100644 tests/codegen/frame-pointer.rs
 delete mode 100644 tests/codegen/function-arguments-noopt.rs
 delete mode 100644 tests/codegen/function-arguments.rs
 delete mode 100644 tests/codegen/function-return.rs
 delete mode 100644 tests/codegen/gdb_debug_script_load.rs
 delete mode 100644 tests/codegen/generic-debug.rs
 delete mode 100644 tests/codegen/gep-index.rs
 delete mode 100644 tests/codegen/gpu-kernel-abi.rs
 delete mode 100644 tests/codegen/gpu_offload/gpu_host.rs
 delete mode 100644 tests/codegen/hint/cold_path.rs
 delete mode 100644 tests/codegen/hint/likely.rs
 delete mode 100644 tests/codegen/hint/unlikely.rs
 delete mode 100644 tests/codegen/i128-wasm32-callconv.rs
 delete mode 100644 tests/codegen/i128-x86-align.rs
 delete mode 100644 tests/codegen/i128-x86-callconv.rs
 delete mode 100644 tests/codegen/infallible-unwrap-in-opt-z.rs
 delete mode 100644 tests/codegen/inherit_overflow.rs
 delete mode 100644 tests/codegen/inline-always-works-always.rs
 delete mode 100644 tests/codegen/inline-debuginfo.rs
 delete mode 100644 tests/codegen/inline-function-args-debug-info.rs
 delete mode 100644 tests/codegen/inline-hint.rs
 delete mode 100644 tests/codegen/instrument-coverage/instrument-coverage-off.rs
 delete mode 100644 tests/codegen/instrument-coverage/instrument-coverage.rs
 delete mode 100644 tests/codegen/instrument-coverage/testprog.rs
 delete mode 100644 tests/codegen/instrument-mcount.rs
 delete mode 100644 tests/codegen/instrument-xray/basic.rs
 delete mode 100644 tests/codegen/instrument-xray/options-combine.rs
 delete mode 100644 tests/codegen/instrument-xray/options-override.rs
 delete mode 100644 tests/codegen/integer-cmp.rs
 delete mode 100644 tests/codegen/integer-overflow.rs
 delete mode 100644 tests/codegen/internalize-closures.rs
 delete mode 100644 tests/codegen/intrinsic-no-unnamed-attr.rs
 delete mode 100644 tests/codegen/intrinsics/aggregate-thin-pointer.rs
 delete mode 100644 tests/codegen/intrinsics/carrying_mul_add.rs
 delete mode 100644 tests/codegen/intrinsics/cold_path.rs
 delete mode 100644 tests/codegen/intrinsics/cold_path2.rs
 delete mode 100644 tests/codegen/intrinsics/cold_path3.rs
 delete mode 100644 tests/codegen/intrinsics/compare_bytes.rs
 delete mode 100644 tests/codegen/intrinsics/const_eval_select.rs
 delete mode 100644 tests/codegen/intrinsics/ctlz.rs
 delete mode 100644 tests/codegen/intrinsics/ctpop.rs
 delete mode 100644 tests/codegen/intrinsics/disjoint_bitor.rs
 delete mode 100644 tests/codegen/intrinsics/exact_div.rs
 delete mode 100644 tests/codegen/intrinsics/likely.rs
 delete mode 100644 tests/codegen/intrinsics/likely_assert.rs
 delete mode 100644 tests/codegen/intrinsics/mask.rs
 delete mode 100644 tests/codegen/intrinsics/nontemporal.rs
 delete mode 100644 tests/codegen/intrinsics/offset.rs
 delete mode 100644 tests/codegen/intrinsics/offset_from.rs
 delete mode 100644 tests/codegen/intrinsics/prefetch.rs
 delete mode 100644 tests/codegen/intrinsics/ptr_metadata.rs
 delete mode 100644 tests/codegen/intrinsics/rotate_left.rs
 delete mode 100644 tests/codegen/intrinsics/rustc_intrinsic_must_be_overridden.rs
 delete mode 100644 tests/codegen/intrinsics/select_unpredictable.rs
 delete mode 100644 tests/codegen/intrinsics/three_way_compare.rs
 delete mode 100644 tests/codegen/intrinsics/transmute-niched.rs
 delete mode 100644 tests/codegen/intrinsics/transmute-x64.rs
 delete mode 100644 tests/codegen/intrinsics/transmute.rs
 delete mode 100644 tests/codegen/intrinsics/typed_swap.rs
 delete mode 100644 tests/codegen/intrinsics/unchecked_math.rs
 delete mode 100644 tests/codegen/intrinsics/unlikely.rs
 delete mode 100644 tests/codegen/intrinsics/volatile.rs
 delete mode 100644 tests/codegen/intrinsics/volatile_order.rs
 delete mode 100644 tests/codegen/is_val_statically_known.rs
 delete mode 100644 tests/codegen/issue-97217.rs
 delete mode 100644 tests/codegen/issues/issue-101048.rs
 delete mode 100644 tests/codegen/issues/issue-101082.rs
 delete mode 100644 tests/codegen/issues/issue-101814.rs
 delete mode 100644 tests/codegen/issues/issue-103132.rs
 delete mode 100644 tests/codegen/issues/issue-103285-ptr-addr-overflow-check.rs
 delete mode 100644 tests/codegen/issues/issue-103327.rs
 delete mode 100644 tests/codegen/issues/issue-103840.rs
 delete mode 100644 tests/codegen/issues/issue-105386-ub-in-debuginfo.rs
 delete mode 100644 tests/codegen/issues/issue-106369.rs
 delete mode 100644 tests/codegen/issues/issue-107681-unwrap_unchecked.rs
 delete mode 100644 tests/codegen/issues/issue-108395-branchy-bool-match.rs
 delete mode 100644 tests/codegen/issues/issue-109328-split_first.rs
 delete mode 100644 tests/codegen/issues/issue-110797-enum-jump-same.rs
 delete mode 100644 tests/codegen/issues/issue-111603.rs
 delete mode 100644 tests/codegen/issues/issue-112509-slice-get-andthen-get.rs
 delete mode 100644 tests/codegen/issues/issue-113757-bounds-check-after-cmp-max.rs
 delete mode 100644 tests/codegen/issues/issue-114312.rs
 delete mode 100644 tests/codegen/issues/issue-115385-llvm-jump-threading.rs
 delete mode 100644 tests/codegen/issues/issue-116878.rs
 delete mode 100644 tests/codegen/issues/issue-118306.rs
 delete mode 100644 tests/codegen/issues/issue-118392.rs
 delete mode 100644 tests/codegen/issues/issue-119422.rs
 delete mode 100644 tests/codegen/issues/issue-121719-common-field-offset.rs
 delete mode 100644 tests/codegen/issues/issue-122600-ptr-discriminant-update.rs
 delete mode 100644 tests/codegen/issues/issue-123712-str-to-lower-autovectorization.rs
 delete mode 100644 tests/codegen/issues/issue-126585.rs
 delete mode 100644 tests/codegen/issues/issue-129795.rs
 delete mode 100644 tests/codegen/issues/issue-13018.rs
 delete mode 100644 tests/codegen/issues/issue-136329-optnone-noinline.rs
 delete mode 100644 tests/codegen/issues/issue-15953.rs
 delete mode 100644 tests/codegen/issues/issue-27130.rs
 delete mode 100644 tests/codegen/issues/issue-32031.rs
 delete mode 100644 tests/codegen/issues/issue-32364.rs
 delete mode 100644 tests/codegen/issues/issue-34634.rs
 delete mode 100644 tests/codegen/issues/issue-34947-pow-i32.rs
 delete mode 100644 tests/codegen/issues/issue-36010-some-box-is_some.rs
 delete mode 100644 tests/codegen/issues/issue-37945.rs
 delete mode 100644 tests/codegen/issues/issue-45222.rs
 delete mode 100644 tests/codegen/issues/issue-45466.rs
 delete mode 100644 tests/codegen/issues/issue-45964-bounds-check-slice-pos.rs
 delete mode 100644 tests/codegen/issues/issue-47278.rs
 delete mode 100644 tests/codegen/issues/issue-47442.rs
 delete mode 100644 tests/codegen/issues/issue-56267-2.rs
 delete mode 100644 tests/codegen/issues/issue-56267.rs
 delete mode 100644 tests/codegen/issues/issue-56927.rs
 delete mode 100644 tests/codegen/issues/issue-58881.rs
 delete mode 100644 tests/codegen/issues/issue-59352.rs
 delete mode 100644 tests/codegen/issues/issue-64219-fn-ptr-call-returning-never-is-noreturn.rs
 delete mode 100644 tests/codegen/issues/issue-68667-unwrap-combinators.rs
 delete mode 100644 tests/codegen/issues/issue-69101-bounds-check.rs
 delete mode 100644 tests/codegen/issues/issue-73031.rs
 delete mode 100644 tests/codegen/issues/issue-73258.rs
 delete mode 100644 tests/codegen/issues/issue-73338-effecient-cmp.rs
 delete mode 100644 tests/codegen/issues/issue-73396-bounds-check-after-position.rs
 delete mode 100644 tests/codegen/issues/issue-73827-bounds-check-index-in-subexpr.rs
 delete mode 100644 tests/codegen/issues/issue-74938-array-split-at.rs
 delete mode 100644 tests/codegen/issues/issue-75525-bounds-checks.rs
 delete mode 100644 tests/codegen/issues/issue-75546.rs
 delete mode 100644 tests/codegen/issues/issue-75659.rs
 delete mode 100644 tests/codegen/issues/issue-75978.rs
 delete mode 100644 tests/codegen/issues/issue-77812.rs
 delete mode 100644 tests/codegen/issues/issue-84268.rs
 delete mode 100644 tests/codegen/issues/issue-85872-multiple-reverse.rs
 delete mode 100644 tests/codegen/issues/issue-86106.rs
 delete mode 100644 tests/codegen/issues/issue-86109-eliminate-div-by-zero-check.rs
 delete mode 100644 tests/codegen/issues/issue-93036-assert-index.rs
 delete mode 100644 tests/codegen/issues/issue-96274.rs
 delete mode 100644 tests/codegen/issues/issue-96497-slice-size-nowrap.rs
 delete mode 100644 tests/codegen/issues/issue-98294-get-mut-copy-from-slice-opt.rs
 delete mode 100644 tests/codegen/issues/issue-98678-async.rs
 delete mode 100644 tests/codegen/issues/issue-98678-closure-coroutine.rs
 delete mode 100644 tests/codegen/issues/issue-98678-enum.rs
 delete mode 100644 tests/codegen/issues/issue-98678-struct-union.rs
 delete mode 100644 tests/codegen/issues/issue-99960.rs
 delete mode 100644 tests/codegen/issues/looping-over-ne-bytes-133528.rs
 delete mode 100644 tests/codegen/issues/str-to-string-128690.rs
 delete mode 100644 tests/codegen/iter-repeat-n-trivial-drop.rs
 delete mode 100644 tests/codegen/layout-size-checks.rs
 delete mode 100644 tests/codegen/lib-optimizations/iter-sum.rs
 delete mode 100644 tests/codegen/lib-optimizations/slice_rotate.rs
 delete mode 100644 tests/codegen/lifetime_start_end.rs
 delete mode 100644 tests/codegen/link-dead-code.rs
 delete mode 100644 tests/codegen/link_section.rs
 delete mode 100644 tests/codegen/llvm-ident.rs
 delete mode 100644 tests/codegen/llvm_module_flags.rs
 delete mode 100644 tests/codegen/loads.rs
 delete mode 100644 tests/codegen/local-generics-in-exe-internalized.rs
 delete mode 100644 tests/codegen/loongarch-abi/call-llvm-intrinsics.rs
 delete mode 100644 tests/codegen/loongarch-abi/loongarch64-lp64d-abi.rs
 delete mode 100644 tests/codegen/lto-removes-invokes.rs
 delete mode 100644 tests/codegen/macos/i686-macosx-deployment-target.rs
 delete mode 100644 tests/codegen/macos/i686-no-macosx-deployment-target.rs
 delete mode 100644 tests/codegen/macos/x86_64-macosx-deployment-target.rs
 delete mode 100644 tests/codegen/macos/x86_64-no-macosx-deployment-target.rs
 delete mode 100644 tests/codegen/mainsubprogram.rs
 delete mode 100644 tests/codegen/match-optimized.rs
 delete mode 100644 tests/codegen/match-optimizes-away.rs
 delete mode 100644 tests/codegen/match-unoptimized.rs
 delete mode 100644 tests/codegen/maybeuninit-rvo.rs
 delete mode 100644 tests/codegen/mem-replace-big-type.rs
 delete mode 100644 tests/codegen/mem-replace-simple-type.rs
 delete mode 100644 tests/codegen/merge-functions.rs
 delete mode 100644 tests/codegen/meta-filecheck/check-prefix.rs
 delete mode 100644 tests/codegen/meta-filecheck/filecheck-flags.rs
 delete mode 100644 tests/codegen/meta-filecheck/msvc-prefix-bad.rs
 delete mode 100644 tests/codegen/meta-filecheck/no-directives.rs
 delete mode 100644 tests/codegen/meta-filecheck/revision-prefix.rs
 delete mode 100644 tests/codegen/method-declaration.rs
 delete mode 100644 tests/codegen/min-function-alignment.rs
 delete mode 100644 tests/codegen/mir-aggregate-no-alloca.rs
 delete mode 100644 tests/codegen/mir-inlined-line-numbers.rs
 delete mode 100644 tests/codegen/mir_zst_stores.rs
 delete mode 100644 tests/codegen/move-before-nocapture-ref-arg.rs
 delete mode 100644 tests/codegen/move-operands.rs
 delete mode 100644 tests/codegen/naked-asan.rs
 delete mode 100644 tests/codegen/naked-fn/aligned.rs
 delete mode 100644 tests/codegen/naked-fn/generics.rs
 delete mode 100644 tests/codegen/naked-fn/instruction-set.rs
 delete mode 100644 tests/codegen/naked-fn/min-function-alignment.rs
 delete mode 100644 tests/codegen/naked-fn/naked-functions.rs
 delete mode 100644 tests/codegen/no-alloca-inside-if-false.rs
 delete mode 100644 tests/codegen/no-assumes-on-casts.rs
 delete mode 100644 tests/codegen/no-dllimport-w-cross-lang-lto.rs
 delete mode 100644 tests/codegen/no-jump-tables.rs
 delete mode 100644 tests/codegen/no-plt.rs
 delete mode 100644 tests/codegen/no-redundant-item-monomorphization.rs
 delete mode 100644 tests/codegen/no_builtins-at-crate.rs
 delete mode 100644 tests/codegen/noalias-box-off.rs
 delete mode 100644 tests/codegen/noalias-box.rs
 delete mode 100644 tests/codegen/noalias-flag.rs
 delete mode 100644 tests/codegen/noalias-freeze.rs
 delete mode 100644 tests/codegen/noalias-refcell.rs
 delete mode 100644 tests/codegen/noalias-rwlockreadguard.rs
 delete mode 100644 tests/codegen/noalias-unpin.rs
 delete mode 100644 tests/codegen/non-terminate/infinite-loop-1.rs
 delete mode 100644 tests/codegen/non-terminate/infinite-loop-2.rs
 delete mode 100644 tests/codegen/non-terminate/infinite-recursion.rs
 delete mode 100644 tests/codegen/non-terminate/nonempty-infinite-loop.rs
 delete mode 100644 tests/codegen/noreturn-uninhabited.rs
 delete mode 100644 tests/codegen/noreturnflag.rs
 delete mode 100644 tests/codegen/nounwind.rs
 delete mode 100644 tests/codegen/nrvo.rs
 delete mode 100644 tests/codegen/optimize-attr-1.rs
 delete mode 100644 tests/codegen/option-as-slice.rs
 delete mode 100644 tests/codegen/option-niche-eq.rs
 delete mode 100644 tests/codegen/option-niche-unfixed/option-nonzero-eq.rs
 delete mode 100644 tests/codegen/overaligned-constant.rs
 delete mode 100644 tests/codegen/packed.rs
 delete mode 100644 tests/codegen/panic-abort-windows.rs
 delete mode 100644 tests/codegen/panic-in-drop-abort.rs
 delete mode 100644 tests/codegen/panic-unwind-default-uwtable.rs
 delete mode 100644 tests/codegen/patchable-function-entry/patchable-function-entry-both-flags.rs
 delete mode 100644 tests/codegen/patchable-function-entry/patchable-function-entry-no-flag.rs
 delete mode 100644 tests/codegen/patchable-function-entry/patchable-function-entry-one-flag.rs
 delete mode 100644 tests/codegen/pattern_type_symbols.rs
 delete mode 100644 tests/codegen/personality_lifetimes.rs
 delete mode 100644 tests/codegen/pgo-counter-bias.rs
 delete mode 100644 tests/codegen/pgo-instrumentation.rs
 delete mode 100644 tests/codegen/pic-relocation-model.rs
 delete mode 100644 tests/codegen/pie-relocation-model.rs
 delete mode 100644 tests/codegen/placement-new.rs
 delete mode 100644 tests/codegen/powerpc64le-struct-align-128.rs
 delete mode 100644 tests/codegen/precondition-checks.rs
 delete mode 100644 tests/codegen/ptr-arithmetic.rs
 delete mode 100644 tests/codegen/ptr-read-metadata.rs
 delete mode 100644 tests/codegen/range-attribute.rs
 delete mode 100644 tests/codegen/range-loop.rs
 delete mode 100644 tests/codegen/range_to_inclusive.rs
 delete mode 100644 tests/codegen/refs.rs
 delete mode 100644 tests/codegen/reg-struct-return.rs
 delete mode 100644 tests/codegen/regparm-inreg.rs
 delete mode 100644 tests/codegen/remap_path_prefix/aux_mod.rs
 delete mode 100644 tests/codegen/remap_path_prefix/auxiliary/remap_path_prefix_aux.rs
 delete mode 100644 tests/codegen/remap_path_prefix/auxiliary/xcrate-generic.rs
 delete mode 100644 tests/codegen/remap_path_prefix/issue-73167-remap-std.rs
 delete mode 100644 tests/codegen/remap_path_prefix/main.rs
 delete mode 100644 tests/codegen/remap_path_prefix/xcrate-generic.rs
 delete mode 100644 tests/codegen/repeat-operand-zero-len.rs
 delete mode 100644 tests/codegen/repeat-operand-zst-elem.rs
 delete mode 100644 tests/codegen/repeat-trusted-len.rs
 delete mode 100644 tests/codegen/repr/transparent-byval-struct-ptr.rs
 delete mode 100644 tests/codegen/repr/transparent-imm-array.rs
 delete mode 100644 tests/codegen/repr/transparent-mips64.rs
 delete mode 100644 tests/codegen/repr/transparent-opaque-ptr.rs
 delete mode 100644 tests/codegen/repr/transparent-sparc64.rs
 delete mode 100644 tests/codegen/repr/transparent-sysv64.rs
 delete mode 100644 tests/codegen/repr/transparent.rs
 delete mode 100644 tests/codegen/retpoline.rs
 delete mode 100644 tests/codegen/riscv-abi/call-llvm-intrinsics.rs
 delete mode 100644 tests/codegen/riscv-abi/cast-local-large-enough.rs
 delete mode 100644 tests/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
 delete mode 100644 tests/codegen/riscv-abi/riscv64-lp64d-abi.rs
 delete mode 100644 tests/codegen/riscv-abi/riscv64-lp64f-lp64d-abi.rs
 delete mode 100644 tests/codegen/riscv-target-abi.rs
 delete mode 100644 tests/codegen/rust-abi-arch-specific-adjustment.rs
 delete mode 100644 tests/codegen/s390x-simd.rs
 delete mode 100644 tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
 delete mode 100644 tests/codegen/sanitizer/address-sanitizer-globals-tracking.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/add-canonical-jump-tables-flag.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/add-enable-split-lto-unit-flag.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/dbg-location-on-cfi-blocks.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-checks-attr-no-sanitize.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-checks.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/emit-type-metadata-trait-objects.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/external_weak_symbols.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/generalize-pointers.rs
 delete mode 100644 tests/codegen/sanitizer/cfi/normalize-integers.rs
 delete mode 100644 tests/codegen/sanitizer/dataflow-instrument-functions.rs
 delete mode 100644 tests/codegen/sanitizer/kasan-emits-instrumentation.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/add-kcfi-arity-flag.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/add-kcfi-flag.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/emit-type-metadata-trait-objects.rs
 delete mode 100644 tests/codegen/sanitizer/kcfi/naked-function.rs
 delete mode 100644 tests/codegen/sanitizer/memory-track-origins.rs
 delete mode 100644 tests/codegen/sanitizer/memtag-attr-check.rs
 delete mode 100644 tests/codegen/sanitizer/no-sanitize-inlining.rs
 delete mode 100644 tests/codegen/sanitizer/no-sanitize.rs
 delete mode 100644 tests/codegen/sanitizer/riscv64-shadow-call-stack.rs
 delete mode 100644 tests/codegen/sanitizer/safestack-attr-check.rs
 delete mode 100644 tests/codegen/sanitizer/sanitizer-recover.rs
 delete mode 100644 tests/codegen/sanitizer/scs-attr-check.rs
 delete mode 100644 tests/codegen/scalar-pair-bool.rs
 delete mode 100644 tests/codegen/set-discriminant-invalid.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs
 delete mode 100644 tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
 delete mode 100644 tests/codegen/simd/aggregate-simd.rs
 delete mode 100644 tests/codegen/simd/extract-insert-dyn.rs
 delete mode 100644 tests/codegen/simd/packed-simd-alignment.rs
 delete mode 100644 tests/codegen/simd/packed-simd.rs
 delete mode 100644 tests/codegen/simd/simd-wide-sum.rs
 delete mode 100644 tests/codegen/simd/simd_arith_offset.rs
 delete mode 100644 tests/codegen/simd/swap-simd-types.rs
 delete mode 100644 tests/codegen/simd/unpadded-simd.rs
 delete mode 100644 tests/codegen/skip-mono-inside-if-false.rs
 delete mode 100644 tests/codegen/slice-as_chunks.rs
 delete mode 100644 tests/codegen/slice-indexing.rs
 delete mode 100644 tests/codegen/slice-init.rs
 delete mode 100644 tests/codegen/slice-is-ascii.rs
 delete mode 100644 tests/codegen/slice-iter-fold.rs
 delete mode 100644 tests/codegen/slice-iter-len-eq-zero.rs
 delete mode 100644 tests/codegen/slice-iter-nonnull.rs
 delete mode 100644 tests/codegen/slice-last-elements-optimization.rs
 delete mode 100644 tests/codegen/slice-pointer-nonnull-unwrap.rs
 delete mode 100644 tests/codegen/slice-position-bounds-check.rs
 delete mode 100644 tests/codegen/slice-ref-equality.rs
 delete mode 100644 tests/codegen/slice-reverse.rs
 delete mode 100644 tests/codegen/slice-split-at.rs
 delete mode 100644 tests/codegen/slice-windows-no-bounds-check.rs
 delete mode 100644 tests/codegen/slice_as_from_ptr_range.rs
 delete mode 100644 tests/codegen/some-abis-do-extend-params-to-32-bits.rs
 delete mode 100644 tests/codegen/some-global-nonnull.rs
 delete mode 100644 tests/codegen/sparc-struct-abi.rs
 delete mode 100644 tests/codegen/split-lto-unit.rs
 delete mode 100644 tests/codegen/src-hash-algorithm/src-hash-algorithm-md5.rs
 delete mode 100644 tests/codegen/src-hash-algorithm/src-hash-algorithm-sha1.rs
 delete mode 100644 tests/codegen/src-hash-algorithm/src-hash-algorithm-sha256.rs
 delete mode 100644 tests/codegen/sroa-fragment-debuginfo.rs
 delete mode 100644 tests/codegen/sse42-implies-crc32.rs
 delete mode 100644 tests/codegen/stack-probes-inline.rs
 delete mode 100644 tests/codegen/stack-protector.rs
 delete mode 100644 tests/codegen/static-relocation-model-msvc.rs
 delete mode 100644 tests/codegen/staticlib-external-inline-fns.rs
 delete mode 100644 tests/codegen/step_by-overflow-checks.rs
 delete mode 100644 tests/codegen/stores.rs
 delete mode 100644 tests/codegen/string-push.rs
 delete mode 100644 tests/codegen/swap-large-types.rs
 delete mode 100644 tests/codegen/swap-small-types.rs
 delete mode 100644 tests/codegen/target-cpu-on-functions.rs
 delete mode 100644 tests/codegen/target-feature-inline-closure.rs
 delete mode 100644 tests/codegen/target-feature-negative-implication.rs
 delete mode 100644 tests/codegen/target-feature-overrides.rs
 delete mode 100644 tests/codegen/terminating-catchpad.rs
 delete mode 100644 tests/codegen/thread-local.rs
 delete mode 100644 tests/codegen/tied-features-strength.rs
 delete mode 100644 tests/codegen/to_vec.rs
 delete mode 100644 tests/codegen/trailing_zeros.rs
 delete mode 100644 tests/codegen/transmute-optimized.rs
 delete mode 100644 tests/codegen/transmute-scalar.rs
 delete mode 100644 tests/codegen/try_question_mark_nop.rs
 delete mode 100644 tests/codegen/tune-cpu-on-functions.rs
 delete mode 100644 tests/codegen/tuple-layout-opt.rs
 delete mode 100644 tests/codegen/ub-checks.rs
 delete mode 100644 tests/codegen/unchecked-float-casts.rs
 delete mode 100644 tests/codegen/unchecked_shifts.rs
 delete mode 100644 tests/codegen/uninhabited-transparent-return-abi.rs
 delete mode 100644 tests/codegen/uninit-consts.rs
 delete mode 100644 tests/codegen/uninit-repeat-in-aggregate.rs
 delete mode 100644 tests/codegen/union-abi.rs
 delete mode 100644 tests/codegen/union-aggregate.rs
 delete mode 100644 tests/codegen/unwind-abis/aapcs-unwind-abi.rs
 delete mode 100644 tests/codegen/unwind-abis/c-unwind-abi-panic-abort.rs
 delete mode 100644 tests/codegen/unwind-abis/c-unwind-abi.rs
 delete mode 100644 tests/codegen/unwind-abis/cdecl-unwind-abi.rs
 delete mode 100644 tests/codegen/unwind-abis/fastcall-unwind-abi.rs
 delete mode 100644 tests/codegen/unwind-abis/nounwind-on-stable-panic-abort.rs
 delete mode 100644 tests/codegen/unwind-abis/nounwind.rs
 delete mode 100644 tests/codegen/unwind-abis/stdcall-unwind-abi.rs
 delete mode 100644 tests/codegen/unwind-abis/system-unwind-abi.rs
 delete mode 100644 tests/codegen/unwind-abis/sysv64-unwind-abi.rs
 delete mode 100644 tests/codegen/unwind-abis/thiscall-unwind-abi.rs
 delete mode 100644 tests/codegen/unwind-abis/vectorcall-unwind-abi.rs
 delete mode 100644 tests/codegen/unwind-abis/win64-unwind-abi.rs
 delete mode 100644 tests/codegen/unwind-and-panic-abort.rs
 delete mode 100644 tests/codegen/unwind-extern-exports.rs
 delete mode 100644 tests/codegen/unwind-extern-imports.rs
 delete mode 100644 tests/codegen/unwind-landingpad-cold.rs
 delete mode 100644 tests/codegen/unwind-landingpad-inline.rs
 delete mode 100644 tests/codegen/used_with_arg.rs
 delete mode 100644 tests/codegen/var-names.rs
 delete mode 100644 tests/codegen/vec-as-ptr.rs
 delete mode 100644 tests/codegen/vec-calloc.rs
 delete mode 100644 tests/codegen/vec-in-place.rs
 delete mode 100644 tests/codegen/vec-iter-collect-len.rs
 delete mode 100644 tests/codegen/vec-iter.rs
 delete mode 100644 tests/codegen/vec-len-invariant.rs
 delete mode 100644 tests/codegen/vec-optimizes-away.rs
 delete mode 100644 tests/codegen/vec-reserve-extend.rs
 delete mode 100644 tests/codegen/vec-shrink-panik.rs
 delete mode 100644 tests/codegen/vec-with-capacity.rs
 delete mode 100644 tests/codegen/vec_pop_push_noop.rs
 delete mode 100644 tests/codegen/vecdeque-drain.rs
 delete mode 100644 tests/codegen/vecdeque-nonempty-get-no-panic.rs
 delete mode 100644 tests/codegen/vecdeque_no_panic.rs
 delete mode 100644 tests/codegen/vecdeque_pop_push.rs
 delete mode 100644 tests/codegen/virtual-call-attrs-issue-137646.rs
 delete mode 100644 tests/codegen/virtual-function-elimination-32bit.rs
 delete mode 100644 tests/codegen/virtual-function-elimination.rs
 delete mode 100644 tests/codegen/vtable-loads.rs
 delete mode 100644 tests/codegen/vtable-upcast.rs
 delete mode 100644 tests/codegen/wasm_casts_trapping.rs
 delete mode 100644 tests/codegen/wasm_exceptions.rs
 delete mode 100644 tests/codegen/zip.rs
 delete mode 100644 tests/codegen/zst-offset.rs

diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index e872f8434e5..610e2fd2311 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -869,7 +869,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     let ltext = bx.zext(is_lt, bx.type_i8());
                     bx.unchecked_ssub(gtext, ltext)
                 } else {
-                    // These operations are those expected by `tests/codegen/integer-cmp.rs`,
+                    // These operations are those expected by `tests/codegen-llvm/integer-cmp.rs`,
                     // from <https://github.com/rust-lang/rust/pull/63767>.
                     let is_lt = bx.icmp(pred(mir::BinOp::Lt), lhs, rhs);
                     let is_ne = bx.icmp(pred(mir::BinOp::Ne), lhs, rhs);
diff --git a/compiler/rustc_mir_transform/src/unreachable_prop.rs b/compiler/rustc_mir_transform/src/unreachable_prop.rs
index 13fb5b3e56f..c417a9272f2 100644
--- a/compiler/rustc_mir_transform/src/unreachable_prop.rs
+++ b/compiler/rustc_mir_transform/src/unreachable_prop.rs
@@ -75,7 +75,7 @@ fn remove_successors_from_switch<'tcx>(
     let is_unreachable = |bb| unreachable_blocks.contains(&bb);
 
     // If there are multiple targets, we want to keep information about reachability for codegen.
-    // For example (see tests/codegen/match-optimizes-away.rs)
+    // For example (see tests/codegen-llvm/match-optimizes-away.rs)
     //
     // pub enum Two { A, B }
     // pub fn identity(x: Two) -> Two {
diff --git a/library/alloc/src/collections/vec_deque/drain.rs b/library/alloc/src/collections/vec_deque/drain.rs
index 44fcef4ed7d..321621d18be 100644
--- a/library/alloc/src/collections/vec_deque/drain.rs
+++ b/library/alloc/src/collections/vec_deque/drain.rs
@@ -192,7 +192,7 @@ impl<T, A: Allocator> Drop for Drain<'_, T, A> {
                     // this branch is never taken.
                     // We use `#[cold]` instead of `#[inline(never)]`, because inlining this
                     // function into the general case (`.drain(n..m)`) is fine.
-                    // See `tests/codegen/vecdeque-drain.rs` for a test.
+                    // See `tests/codegen-llvm/vecdeque-drain.rs` for a test.
                     #[cold]
                     fn join_head_and_tail_wrapping<T, A: Allocator>(
                         source_deque: &mut VecDeque<T, A>,
diff --git a/library/alloc/src/raw_vec/mod.rs b/library/alloc/src/raw_vec/mod.rs
index 3e006a2d1bd..40716755aad 100644
--- a/library/alloc/src/raw_vec/mod.rs
+++ b/library/alloc/src/raw_vec/mod.rs
@@ -761,7 +761,7 @@ impl<A: Allocator> RawVecInner<A> {
 }
 
 // not marked inline(never) since we want optimizers to be able to observe the specifics of this
-// function, see tests/codegen/vec-reserve-extend.rs.
+// function, see tests/codegen-llvm/vec-reserve-extend.rs.
 #[cold]
 fn finish_grow<A>(
     new_layout: Layout,
diff --git a/rustfmt.toml b/rustfmt.toml
index 689e390b990..6172a2bb3bf 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -14,7 +14,7 @@ ignore = [
     "/vendor/",
 
     # Some tests are not formatted, for various reasons.
-    "/tests/codegen/simd-intrinsic/", # Many types like `u8x64` are better hand-formatted.
+    "/tests/codegen-llvm/simd-intrinsic/", # Many types like `u8x64` are better hand-formatted.
     "/tests/crashes/",                # Many of these tests contain syntax errors.
     "/tests/debuginfo/",              # These tests are somewhat sensitive to source code layout.
     "/tests/incremental/",            # These tests are somewhat sensitive to source code layout.
@@ -58,5 +58,5 @@ ignore = [
 
     # Rustfmt doesn't support use closures yet
     "tests/mir-opt/ergonomic-clones/closure.rs",
-    "tests/codegen/ergonomic-clones/closure.rs",
+    "tests/codegen-llvm/ergonomic-clones/closure.rs",
 ]
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 99c9e8ae92e..d346062761c 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1342,7 +1342,12 @@ test!(Ui { path: "tests/ui", mode: "ui", suite: "ui", default: true });
 
 test!(Crashes { path: "tests/crashes", mode: "crashes", suite: "crashes", default: true });
 
-test!(Codegen { path: "tests/codegen", mode: "codegen", suite: "codegen", default: true });
+test!(CodegenLlvm {
+    path: "tests/codegen-llvm",
+    mode: "codegen",
+    suite: "codegen-llvm",
+    default: true
+});
 
 test!(CodegenUnits {
     path: "tests/codegen-units",
@@ -1620,7 +1625,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         let suite_path = self.path;
 
         // Skip codegen tests if they aren't enabled in configuration.
-        if !builder.config.codegen_tests && suite == "codegen" {
+        if !builder.config.codegen_tests && mode == "codegen" {
             return;
         }
 
@@ -1817,7 +1822,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         let mut flags = if is_rustdoc { Vec::new() } else { vec!["-Crpath".to_string()] };
         flags.push(format!(
             "-Cdebuginfo={}",
-            if suite == "codegen" {
+            if mode == "codegen" {
                 // codegen tests typically check LLVM IR and are sensitive to additional debuginfo.
                 // So do not apply `rust.debuginfo-level-tests` for codegen tests.
                 if builder.config.rust_debuginfo_level_tests
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 925e47a4164..923c3a9a935 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -412,7 +412,7 @@ const PATH_REMAP: &[(&str, &[&str])] = &[
         &[
             // tidy-alphabetical-start
             "tests/assembly-llvm",
-            "tests/codegen",
+            "tests/codegen-llvm",
             "tests/codegen-units",
             "tests/coverage",
             "tests/coverage-run-rustdoc",
@@ -1049,7 +1049,7 @@ impl<'a> Builder<'a> {
                 test::Crashes,
                 test::Coverage,
                 test::MirOpt,
-                test::Codegen,
+                test::CodegenLlvm,
                 test::CodegenUnits,
                 test::AssemblyLlvm,
                 test::Incremental,
diff --git a/src/ci/docker/host-x86_64/test-various/Dockerfile b/src/ci/docker/host-x86_64/test-various/Dockerfile
index 54ca7131608..4d09bea69c0 100644
--- a/src/ci/docker/host-x86_64/test-various/Dockerfile
+++ b/src/ci/docker/host-x86_64/test-various/Dockerfile
@@ -65,7 +65,7 @@ ENV WASM_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $WASM_T
   tests/ui \
   tests/mir-opt \
   tests/codegen-units \
-  tests/codegen \
+  tests/codegen-llvm \
   tests/assembly-llvm \
   library/core
 
diff --git a/src/doc/rustc-dev-guide/src/asm.md b/src/doc/rustc-dev-guide/src/asm.md
index 3d93d5a4c57..1bb493e73d5 100644
--- a/src/doc/rustc-dev-guide/src/asm.md
+++ b/src/doc/rustc-dev-guide/src/asm.md
@@ -157,7 +157,7 @@ Various tests for inline assembly are available:
 
 - `tests/assembly-llvm/asm`
 - `tests/ui/asm`
-- `tests/codegen/asm-*`
+- `tests/codegen-llvm/asm-*`
 
 Every architecture supported by inline assembly must have exhaustive tests in
 `tests/assembly-llvm/asm` which test all combinations of register classes and types.
diff --git a/src/doc/rustc-dev-guide/src/autodiff/installation.md b/src/doc/rustc-dev-guide/src/autodiff/installation.md
index a550f6d233e..ddbb3a05424 100644
--- a/src/doc/rustc-dev-guide/src/autodiff/installation.md
+++ b/src/doc/rustc-dev-guide/src/autodiff/installation.md
@@ -25,7 +25,7 @@ rustup toolchain install nightly # enables -Z unstable-options
 You can then run our test cases:
 
 ```bash
-./x test --stage 1 tests/codegen/autodiff
+./x test --stage 1 tests/codegen-llvm/autodiff
 ./x test --stage 1 tests/pretty/autodiff
 ./x test --stage 1 tests/ui/autodiff
 ./x test --stage 1 tests/ui/feature-gates/feature-gate-autodiff.rs
diff --git a/src/doc/rustc-dev-guide/src/llvm-coverage-instrumentation.md b/src/doc/rustc-dev-guide/src/llvm-coverage-instrumentation.md
index 28e0e7a908d..880363b94bf 100644
--- a/src/doc/rustc-dev-guide/src/llvm-coverage-instrumentation.md
+++ b/src/doc/rustc-dev-guide/src/llvm-coverage-instrumentation.md
@@ -117,7 +117,7 @@ human-readable coverage report.
 > directive, so they will be skipped if the profiler runtime has not been
 > [enabled in `bootstrap.toml`](#recommended-configtoml-settings).
 
-Finally, the [`tests/codegen/instrument-coverage/testprog.rs`] test compiles a simple Rust program
+Finally, the [`tests/codegen-llvm/instrument-coverage/testprog.rs`] test compiles a simple Rust program
 with `-C instrument-coverage` and compares the compiled program's LLVM IR to
 expected LLVM IR instructions and structured data for a coverage-enabled
 program, including various checks for Coverage Map-related metadata and the LLVM
@@ -136,4 +136,4 @@ and `mir-opt` tests can be refreshed by running:
 [`tests/coverage`]: https://github.com/rust-lang/rust/tree/master/tests/coverage
 [`src/tools/coverage-dump`]: https://github.com/rust-lang/rust/tree/master/src/tools/coverage-dump
 [`tests/coverage-run-rustdoc`]: https://github.com/rust-lang/rust/tree/master/tests/coverage-run-rustdoc
-[`tests/codegen/instrument-coverage/testprog.rs`]: https://github.com/rust-lang/rust/blob/master/tests/mir-opt/coverage/instrument_coverage.rs
+[`tests/codegen-llvm/instrument-coverage/testprog.rs`]: https://github.com/rust-lang/rust/blob/master/tests/mir-opt/coverage/instrument_coverage.rs
diff --git a/src/doc/rustc-dev-guide/src/offload/installation.md b/src/doc/rustc-dev-guide/src/offload/installation.md
index 1962314c70a..1e792de3c8c 100644
--- a/src/doc/rustc-dev-guide/src/offload/installation.md
+++ b/src/doc/rustc-dev-guide/src/offload/installation.md
@@ -40,7 +40,7 @@ This gives you a working LLVM build.
 ## Testing
 run
 ```
-./x test --stage 1 tests/codegen/gpu_offload
+./x test --stage 1 tests/codegen-llvm/gpu_offload
 ```
 
 ## Usage
diff --git a/src/doc/rustc-dev-guide/src/profile-guided-optimization.md b/src/doc/rustc-dev-guide/src/profile-guided-optimization.md
index d279786ac45..2fa81021045 100644
--- a/src/doc/rustc-dev-guide/src/profile-guided-optimization.md
+++ b/src/doc/rustc-dev-guide/src/profile-guided-optimization.md
@@ -132,7 +132,7 @@ There is also a [codegen test][codegen-test] that checks that some expected
 instrumentation artifacts show up in LLVM IR.
 
 [rmake-tests]: https://github.com/rust-lang/rust/tree/master/tests/run-make
-[codegen-test]: https://github.com/rust-lang/rust/blob/master/tests/codegen/pgo-instrumentation.rs
+[codegen-test]: https://github.com/rust-lang/rust/blob/master/tests/codegen-llvm/pgo-instrumentation.rs
 
 ## Additional information
 
diff --git a/src/doc/rustc-dev-guide/src/sanitizers.md b/src/doc/rustc-dev-guide/src/sanitizers.md
index 664b4feac4f..29d9056c15d 100644
--- a/src/doc/rustc-dev-guide/src/sanitizers.md
+++ b/src/doc/rustc-dev-guide/src/sanitizers.md
@@ -76,7 +76,7 @@ implementation:
 ## Testing sanitizers
 
 Sanitizers are validated by code generation tests in
-[`tests/codegen/sanitize*.rs`][test-cg] and end-to-end functional tests in
+[`tests/codegen-llvm/sanitize*.rs`][test-cg] and end-to-end functional tests in
 [`tests/ui/sanitizer/`][test-ui] directory.
 
 Testing sanitizer functionality requires the sanitizer runtimes (built when
@@ -85,7 +85,7 @@ sanitizer. When sanitizer is unsupported on given target, sanitizers tests will
 be ignored. This behaviour is controlled by compiletest `needs-sanitizer-*`
 directives.
 
-[test-cg]: https://github.com/rust-lang/rust/tree/master/tests/codegen
+[test-cg]: https://github.com/rust-lang/rust/tree/master/tests/codegen-llvm
 [test-ui]: https://github.com/rust-lang/rust/tree/master/tests/ui/sanitizer
 
 ## Enabling sanitizer on a new target
diff --git a/src/doc/rustc-dev-guide/src/tests/compiletest.md b/src/doc/rustc-dev-guide/src/tests/compiletest.md
index 6a60e7118d3..a108dfdef9b 100644
--- a/src/doc/rustc-dev-guide/src/tests/compiletest.md
+++ b/src/doc/rustc-dev-guide/src/tests/compiletest.md
@@ -68,7 +68,7 @@ The following test suites are available, with links for more information:
 | [`pretty`](#pretty-printer-tests)         | Check pretty printing                                                                                               |
 | [`incremental`](#incremental-tests)       | Check incremental compilation behavior                                                                              |
 | [`debuginfo`](#debuginfo-tests)           | Check debuginfo generation running debuggers                                                                        |
-| [`codegen`](#codegen-tests)               | Check code generation                                                                                               |
+| [`codegen-*`](#codegen-tests)             | Check code generation                                                                                               |
 | [`codegen-units`](#codegen-units-tests)   | Check codegen unit partitioning                                                                                     |
 | [`assembly`](#assembly-tests)             | Check assembly output                                                                                               |
 | [`mir-opt`](#mir-opt-tests)               | Check MIR generation and optimizations                                                                              |
@@ -290,7 +290,7 @@ For example, `./x test tests/debuginfo -- --debugger gdb` will only test GDB com
 
 ### Codegen tests
 
-The tests in [`tests/codegen`] test LLVM code generation. They compile the test
+The tests in [`tests/codegen-llvm`] test LLVM code generation. They compile the test
 with the `--emit=llvm-ir` flag to emit LLVM IR. They then run the LLVM
 [FileCheck] tool. The test is annotated with various `// CHECK` comments to
 check the generated code. See the [FileCheck] documentation for a tutorial and
@@ -301,7 +301,7 @@ See also the [assembly tests](#assembly-tests) for a similar set of tests.
 If you need to work with `#![no_std]` cross-compiling tests, consult the
 [`minicore` test auxiliary](./minicore.md) chapter.
 
-[`tests/codegen`]: https://github.com/rust-lang/rust/tree/master/tests/codegen
+[`tests/codegen-llvm`]: https://github.com/rust-lang/rust/tree/master/tests/codegen-llvm
 [FileCheck]: https://llvm.org/docs/CommandGuide/FileCheck.html
 
 
diff --git a/src/tools/opt-dist/src/tests.rs b/src/tools/opt-dist/src/tests.rs
index a70c257e52b..c9a21fc6fb2 100644
--- a/src/tools/opt-dist/src/tests.rs
+++ b/src/tools/opt-dist/src/tests.rs
@@ -101,7 +101,7 @@ llvm-config = "{llvm_config}"
             "--stage",
             "0",
             "tests/assembly-llvm",
-            "tests/codegen",
+            "tests/codegen-llvm",
             "tests/codegen-units",
             "tests/incremental",
             "tests/mir-opt",
diff --git a/tests/assembly-llvm/target-feature-multiple.rs b/tests/assembly-llvm/target-feature-multiple.rs
index bc432d21931..9a941c52bda 100644
--- a/tests/assembly-llvm/target-feature-multiple.rs
+++ b/tests/assembly-llvm/target-feature-multiple.rs
@@ -15,7 +15,7 @@
 // > LLVM ERROR: Cannot select: 0x7f00f400c010: i32,i32,ch = X86ISD::RDSEED 0x7f00f400bfa8:2
 // > In function: foo
 //
-// See also tests/codegen/target-feature-overrides.rs
+// See also tests/codegen-llvm/target-feature-overrides.rs
 #![feature(no_core, lang_items, link_llvm_intrinsics, abi_unadjusted)]
 #![crate_type = "lib"]
 #![no_core]
diff --git a/tests/codegen-llvm/README.md b/tests/codegen-llvm/README.md
new file mode 100644
index 00000000000..8f2daaafcc7
--- /dev/null
+++ b/tests/codegen-llvm/README.md
@@ -0,0 +1,24 @@
+The files here use the LLVM FileCheck framework, documented at
+<https://llvm.org/docs/CommandGuide/FileCheck.html>.
+
+One extension worth noting is the use of revisions as custom prefixes for
+FileCheck. If your codegen test has different behavior based on the chosen
+target or different compiler flags that you want to exercise, you can use a
+revisions annotation, like so:
+
+```rust
+// revisions: aaa bbb
+// [bbb] compile-flags: --flags-for-bbb
+```
+
+After specifying those variations, you can write different expected, or
+explicitly *unexpected* output by using `<prefix>-SAME:` and `<prefix>-NOT:`,
+like so:
+
+```rust
+// CHECK: expected code
+// aaa-SAME: emitted-only-for-aaa
+// aaa-NOT:                        emitted-only-for-bbb
+// bbb-NOT:  emitted-only-for-aaa
+// bbb-SAME:                       emitted-only-for-bbb
+```
diff --git a/tests/codegen-llvm/aarch64-softfloat.rs b/tests/codegen-llvm/aarch64-softfloat.rs
new file mode 100644
index 00000000000..4f5366e047f
--- /dev/null
+++ b/tests/codegen-llvm/aarch64-softfloat.rs
@@ -0,0 +1,45 @@
+//@ add-core-stubs
+//@ compile-flags: --target aarch64-unknown-none-softfloat -Zmerge-functions=disabled
+//@ needs-llvm-components: aarch64
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: i64 @pass_f64_C(i64 {{[^,]*}})
+#[no_mangle]
+extern "C" fn pass_f64_C(x: f64) -> f64 {
+    x
+}
+
+// CHECK: i64 @pass_f32_pair_C(i64 {{[^,]*}})
+#[no_mangle]
+extern "C" fn pass_f32_pair_C(x: (f32, f32)) -> (f32, f32) {
+    x
+}
+
+// CHECK: [2 x i64] @pass_f64_pair_C([2 x i64] {{[^,]*}})
+#[no_mangle]
+extern "C" fn pass_f64_pair_C(x: (f64, f64)) -> (f64, f64) {
+    x
+}
+
+// CHECK: i64 @pass_f64_Rust(i64 {{[^,]*}})
+#[no_mangle]
+fn pass_f64_Rust(x: f64) -> f64 {
+    x
+}
+
+// CHECK: i64 @pass_f32_pair_Rust(i64 {{[^,]*}})
+#[no_mangle]
+fn pass_f32_pair_Rust(x: (f32, f32)) -> (f32, f32) {
+    x
+}
+
+// CHECK: void @pass_f64_pair_Rust(ptr {{.*}}%{{[^ ]+}}, ptr {{.*}}%{{[^ ]+}})
+#[no_mangle]
+fn pass_f64_pair_Rust(x: (f64, f64)) -> (f64, f64) {
+    x
+}
diff --git a/tests/codegen-llvm/aarch64-struct-align-128.rs b/tests/codegen-llvm/aarch64-struct-align-128.rs
new file mode 100644
index 00000000000..ba1d19680f4
--- /dev/null
+++ b/tests/codegen-llvm/aarch64-struct-align-128.rs
@@ -0,0 +1,145 @@
+// Test that structs aligned to 128 bits are passed with the correct ABI on aarch64.
+
+//@ add-core-stubs
+//@ revisions: linux darwin win
+//@[linux] compile-flags: --target aarch64-unknown-linux-gnu
+//@[darwin] compile-flags: --target aarch64-apple-darwin
+//@[win] compile-flags: --target aarch64-pc-windows-msvc
+//@[linux] needs-llvm-components: aarch64
+//@[darwin] needs-llvm-components: aarch64
+//@[win] needs-llvm-components: aarch64
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// Passed as `[i64 x 2]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
+#[repr(C)]
+pub struct Align8 {
+    pub a: u64,
+    pub b: u64,
+}
+
+// repr(transparent), so same as above.
+#[repr(transparent)]
+pub struct Transparent8 {
+    a: Align8,
+}
+
+// Passed as `[i64 x 2]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
+#[repr(C)]
+pub struct Wrapped8 {
+    a: Align8,
+}
+
+extern "C" {
+    // linux:  declare void @test_8([2 x i64], [2 x i64], [2 x i64])
+    // darwin: declare void @test_8([2 x i64], [2 x i64], [2 x i64])
+    // win:    declare void @test_8([2 x i64], [2 x i64], [2 x i64])
+    fn test_8(a: Align8, b: Transparent8, c: Wrapped8);
+}
+
+// Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
+// EXCEPT on Linux, where there's a special case to use its unadjusted alignment,
+// making it the same as `Align8`, so it's be passed as `[i64 x 2]`.
+#[repr(C)]
+#[repr(align(16))]
+pub struct Align16 {
+    pub a: u64,
+    pub b: u64,
+}
+
+// repr(transparent), so same as above.
+#[repr(transparent)]
+pub struct Transparent16 {
+    a: Align16,
+}
+
+// Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
+// On Linux, the "unadjustedness" doesn't recurse into fields, so this is passed as `i128`.
+#[repr(C)]
+pub struct Wrapped16 {
+    pub a: Align16,
+}
+
+extern "C" {
+    // linux:  declare void @test_16([2 x i64], [2 x i64], i128)
+    // darwin: declare void @test_16(i128, i128, i128)
+    // win:    declare void @test_16(i128, i128, i128)
+    fn test_16(a: Align16, b: Transparent16, c: Wrapped16);
+}
+
+// Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
+#[repr(C)]
+pub struct I128 {
+    pub a: i128,
+}
+
+// repr(transparent), so same as above.
+#[repr(transparent)]
+pub struct TransparentI128 {
+    a: I128,
+}
+
+// Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
+#[repr(C)]
+pub struct WrappedI128 {
+    pub a: I128,
+}
+
+extern "C" {
+    // linux:  declare void @test_i128(i128, i128, i128)
+    // darwin: declare void @test_i128(i128, i128, i128)
+    // win:    declare void @test_i128(i128, i128, i128)
+    fn test_i128(a: I128, b: TransparentI128, c: WrappedI128);
+}
+
+// Passed as `[2 x i64]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
+// Note that the Linux special case does not apply, because packing is not considered "adjustment".
+#[repr(C)]
+#[repr(packed)]
+pub struct Packed {
+    pub a: i128,
+}
+
+// repr(transparent), so same as above.
+#[repr(transparent)]
+pub struct TransparentPacked {
+    a: Packed,
+}
+
+// Passed as `[2 x i64]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
+#[repr(C)]
+pub struct WrappedPacked {
+    pub a: Packed,
+}
+
+extern "C" {
+    // linux:  declare void @test_packed([2 x i64], [2 x i64], [2 x i64])
+    // darwin: declare void @test_packed([2 x i64], [2 x i64], [2 x i64])
+    // win:    declare void @test_packed([2 x i64], [2 x i64], [2 x i64])
+    fn test_packed(a: Packed, b: TransparentPacked, c: WrappedPacked);
+}
+
+pub unsafe fn main(
+    a1: Align8,
+    a2: Transparent8,
+    a3: Wrapped8,
+    b1: Align16,
+    b2: Transparent16,
+    b3: Wrapped16,
+    c1: I128,
+    c2: TransparentI128,
+    c3: WrappedI128,
+    d1: Packed,
+    d2: TransparentPacked,
+    d3: WrappedPacked,
+) {
+    test_8(a1, a2, a3);
+    test_16(b1, b2, b3);
+    test_i128(c1, c2, c3);
+    test_packed(d1, d2, d3);
+}
diff --git a/tests/codegen-llvm/abi-efiapi.rs b/tests/codegen-llvm/abi-efiapi.rs
new file mode 100644
index 00000000000..1736f0daf0f
--- /dev/null
+++ b/tests/codegen-llvm/abi-efiapi.rs
@@ -0,0 +1,30 @@
+// Checks if the correct annotation for the efiapi ABI is passed to llvm.
+
+//@ add-core-stubs
+//@ revisions:x86_64 i686 aarch64 arm riscv
+//@[x86_64] compile-flags: --target x86_64-unknown-uefi
+//@[x86_64] needs-llvm-components: aarch64 arm riscv
+//@[i686] compile-flags: --target i686-unknown-linux-musl
+//@[i686] needs-llvm-components: aarch64 arm riscv
+//@[aarch64] compile-flags: --target aarch64-unknown-none
+//@[aarch64] needs-llvm-components: aarch64 arm riscv
+//@[arm] compile-flags: --target armv7r-none-eabi
+//@[arm] needs-llvm-components: aarch64 arm riscv
+//@[riscv] compile-flags: --target riscv64gc-unknown-none-elf
+//@[riscv] needs-llvm-components: aarch64 arm riscv
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+//x86_64: define win64cc void @has_efiapi
+//i686: define void @has_efiapi
+//aarch64: define dso_local void @has_efiapi
+//arm: define dso_local arm_aapcscc void @has_efiapi
+//riscv: define dso_local void @has_efiapi
+#[no_mangle]
+pub extern "efiapi" fn has_efiapi() {}
diff --git a/tests/codegen-llvm/abi-main-signature-16bit-c-int.rs b/tests/codegen-llvm/abi-main-signature-16bit-c-int.rs
new file mode 100644
index 00000000000..d44b80475e4
--- /dev/null
+++ b/tests/codegen-llvm/abi-main-signature-16bit-c-int.rs
@@ -0,0 +1,11 @@
+// Checks the signature of the implicitly generated native main()
+// entry point. It must match C's `int main(int, char **)`.
+
+// This test is for targets with 16bit c_int only.
+//@ revisions: avr msp
+//@[avr] only-avr
+//@[msp] only-msp430
+
+fn main() {}
+
+// CHECK: define i16 @main(i16, i8**)
diff --git a/tests/codegen-llvm/abi-main-signature-32bit-c-int.rs b/tests/codegen-llvm/abi-main-signature-32bit-c-int.rs
new file mode 100644
index 00000000000..ce475adde44
--- /dev/null
+++ b/tests/codegen-llvm/abi-main-signature-32bit-c-int.rs
@@ -0,0 +1,11 @@
+// Checks the signature of the implicitly generated native main()
+// entry point. It must match C's `int main(int, char **)`.
+
+// This test is for targets with 32bit c_int only.
+//@ ignore-msp430
+//@ ignore-avr
+//@ ignore-wasi wasi codegens the main symbol differently
+
+fn main() {}
+
+// CHECK: define{{( hidden| noundef)*}} i32 @main(i32{{( %0)?}}, ptr{{( %1)?}})
diff --git a/tests/codegen-llvm/abi-repr-ext.rs b/tests/codegen-llvm/abi-repr-ext.rs
new file mode 100644
index 00000000000..1da28a94d9d
--- /dev/null
+++ b/tests/codegen-llvm/abi-repr-ext.rs
@@ -0,0 +1,56 @@
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3
+
+//@ revisions:x86_64 i686 aarch64-apple aarch64-windows aarch64-linux arm riscv
+
+//@[x86_64] compile-flags: --target x86_64-unknown-uefi
+//@[x86_64] needs-llvm-components: x86
+//@[i686] compile-flags: --target i686-unknown-linux-musl
+//@[i686] needs-llvm-components: x86
+//@[aarch64-windows] compile-flags: --target aarch64-pc-windows-msvc
+//@[aarch64-windows] needs-llvm-components: aarch64
+//@[aarch64-linux] compile-flags: --target aarch64-unknown-linux-gnu
+//@[aarch64-linux] needs-llvm-components: aarch64
+//@[aarch64-apple] compile-flags: --target aarch64-apple-darwin
+//@[aarch64-apple] needs-llvm-components: aarch64
+//@[arm] compile-flags: --target armv7r-none-eabi
+//@[arm] needs-llvm-components: arm
+//@[riscv] compile-flags: --target riscv64gc-unknown-none-elf
+//@[riscv] needs-llvm-components: riscv
+
+// See bottom of file for a corresponding C source file that is meant to yield
+// equivalent declarations.
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(i8)]
+pub enum Type {
+    Type1 = 0,
+    Type2 = 1,
+}
+
+// To accommodate rust#97800, one might consider writing the below as:
+//
+// `define{{( dso_local)?}} noundef{{( signext)?}} i8 @test()`
+//
+// but based on rust#80556, it seems important to actually check for the
+// presence of the `signext` for those targets where we expect it.
+
+// CHECK: define{{( dso_local)?}} noundef
+// x86_64-SAME:                 signext
+// aarch64-apple-SAME:          signext
+// aarch64-windows-NOT: signext
+// aarch64-linux-NOT:   signext
+// arm-SAME:                    signext
+// riscv-SAME:                  signext
+// CHECK-SAME: i8 @test()
+
+#[no_mangle]
+pub extern "C" fn test() -> Type {
+    Type::Type1
+}
diff --git a/tests/codegen-llvm/abi-sysv64.rs b/tests/codegen-llvm/abi-sysv64.rs
new file mode 100644
index 00000000000..7ade17f2bae
--- /dev/null
+++ b/tests/codegen-llvm/abi-sysv64.rs
@@ -0,0 +1,20 @@
+// Checks if the correct annotation for the sysv64 ABI is passed to
+// llvm. Also checks that the abi-sysv64 feature gate allows usage
+// of the sysv64 abi.
+//
+//@ add-core-stubs
+//@ needs-llvm-components: x86
+//@ compile-flags: -C no-prepopulate-passes --target=x86_64-unknown-linux-gnu -Copt-level=0
+
+#![crate_type = "lib"]
+#![no_core]
+#![feature(abi_x86_interrupt, no_core, lang_items)]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: define x86_64_sysvcc i64 @has_sysv64_abi
+#[no_mangle]
+pub extern "sysv64" fn has_sysv64_abi(a: i64) -> i64 {
+    a
+}
diff --git a/tests/codegen-llvm/abi-win64-zst.rs b/tests/codegen-llvm/abi-win64-zst.rs
new file mode 100644
index 00000000000..e46f9666d42
--- /dev/null
+++ b/tests/codegen-llvm/abi-win64-zst.rs
@@ -0,0 +1,54 @@
+//@ add-core-stubs
+//@ compile-flags: -Z merge-functions=disabled
+//@ add-core-stubs
+
+//@ revisions: windows-gnu
+//@[windows-gnu] compile-flags: --target x86_64-pc-windows-gnu
+//@[windows-gnu] needs-llvm-components: x86
+
+//@ revisions: windows-msvc
+//@[windows-msvc] compile-flags: --target x86_64-pc-windows-msvc
+//@[windows-msvc] needs-llvm-components: x86
+
+// Also test what happens when using a Windows ABI on Linux.
+//@ revisions: linux
+//@[linux] compile-flags: --target x86_64-unknown-linux-gnu
+//@[linux] needs-llvm-components: x86
+
+#![feature(no_core, rustc_attrs, abi_vectorcall)]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+// Make sure the argument is always passed when explicitly requesting a Windows ABI.
+// Our goal here is to match clang: <https://clang.godbolt.org/z/Wr4jMWq3P>.
+
+// CHECK: define win64cc void @pass_zst_win64(ptr {{[^,]*}})
+#[no_mangle]
+extern "win64" fn pass_zst_win64(_: ()) {}
+
+// CHECK: define x86_vectorcallcc void @pass_zst_vectorcall(ptr {{[^,]*}})
+#[no_mangle]
+extern "vectorcall" fn pass_zst_vectorcall(_: ()) {}
+
+// windows-gnu: define void @pass_zst_fastcall(ptr {{[^,]*}})
+// windows-msvc: define void @pass_zst_fastcall(ptr {{[^,]*}})
+#[no_mangle]
+#[cfg(windows)] // "fastcall" is not valid on 64bit Linux
+extern "fastcall" fn pass_zst_fastcall(_: ()) {}
+
+// The sysv64 ABI ignores ZST.
+
+// CHECK: define x86_64_sysvcc void @pass_zst_sysv64()
+#[no_mangle]
+extern "sysv64" fn pass_zst_sysv64(_: ()) {}
+
+// For `extern "C"` functions, ZST are ignored on Linux put passed on Windows.
+
+// linux: define void @pass_zst_c()
+// windows-msvc: define void @pass_zst_c(ptr {{[^,]*}})
+// windows-gnu: define void @pass_zst_c(ptr {{[^,]*}})
+#[no_mangle]
+extern "C" fn pass_zst_c(_: ()) {}
diff --git a/tests/codegen-llvm/abi-x86-interrupt.rs b/tests/codegen-llvm/abi-x86-interrupt.rs
new file mode 100644
index 00000000000..9a1ded2c9e3
--- /dev/null
+++ b/tests/codegen-llvm/abi-x86-interrupt.rs
@@ -0,0 +1,18 @@
+// Checks if the correct annotation for the x86-interrupt ABI is passed to
+// llvm. Also checks that the abi_x86_interrupt feature gate allows usage
+// of the x86-interrupt abi.
+
+//@ add-core-stubs
+//@ needs-llvm-components: x86
+//@ compile-flags: -C no-prepopulate-passes --target=x86_64-unknown-linux-gnu -Copt-level=0
+
+#![crate_type = "lib"]
+#![no_core]
+#![feature(abi_x86_interrupt, no_core, lang_items)]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: define x86_intrcc void @has_x86_interrupt_abi
+#[no_mangle]
+pub extern "x86-interrupt" fn has_x86_interrupt_abi() {}
diff --git a/tests/codegen-llvm/abi-x86-sse.rs b/tests/codegen-llvm/abi-x86-sse.rs
new file mode 100644
index 00000000000..68d2acfb527
--- /dev/null
+++ b/tests/codegen-llvm/abi-x86-sse.rs
@@ -0,0 +1,43 @@
+//@ compile-flags: -Z merge-functions=disabled
+
+//@ revisions: x86-64
+//@[x86-64] compile-flags: --target x86_64-unknown-linux-gnu
+//@[x86-64] needs-llvm-components: x86
+
+//@ revisions: x86-32
+//@[x86-32] compile-flags: --target i686-unknown-linux-gnu
+//@[x86-32] needs-llvm-components: x86
+
+//@ revisions: x86-32-nosse
+//@[x86-32-nosse] compile-flags: --target i586-unknown-linux-gnu
+//@[x86-32-nosse] needs-llvm-components: x86
+
+#![feature(no_core, lang_items, rustc_attrs, repr_simd)]
+#![no_core]
+#![crate_type = "lib"]
+
+#[lang = "sized"]
+trait Sized: MetaSized {}
+
+#[lang = "meta_sized"]
+trait MetaSized: PointeeSized {}
+
+#[lang = "pointee_sized"]
+trait PointeeSized {}
+
+#[lang = "copy"]
+trait Copy {}
+
+// Ensure this type is passed without ptr indirection on targets that
+// require SSE2.
+#[repr(simd)]
+pub struct Sse([f32; 4]);
+
+// FIXME: due to #139029 we are passing them all indirectly.
+// x86-64: void @sse_id(ptr{{( [^,]*)?}} sret([16 x i8]){{( .*)?}}, ptr{{( [^,]*)?}})
+// x86-32: void @sse_id(ptr{{( [^,]*)?}} sret([16 x i8]){{( .*)?}}, ptr{{( [^,]*)?}})
+// x86-32-nosse: void @sse_id(ptr{{( [^,]*)?}} sret([16 x i8]){{( .*)?}}, ptr{{( [^,]*)?}})
+#[no_mangle]
+pub fn sse_id(x: Sse) -> Sse {
+    x
+}
diff --git a/tests/codegen-llvm/abi-x86_64_sysv.rs b/tests/codegen-llvm/abi-x86_64_sysv.rs
new file mode 100644
index 00000000000..09909f994d6
--- /dev/null
+++ b/tests/codegen-llvm/abi-x86_64_sysv.rs
@@ -0,0 +1,29 @@
+//@ only-x86_64
+
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+pub struct S24 {
+    a: i8,
+    b: i8,
+    c: i8,
+}
+
+pub struct S48 {
+    a: i16,
+    b: i16,
+    c: i8,
+}
+
+// CHECK: i24 @struct_24_bits(i24
+#[no_mangle]
+pub extern "sysv64" fn struct_24_bits(a: S24) -> S24 {
+    a
+}
+
+// CHECK: i48 @struct_48_bits(i48
+#[no_mangle]
+pub extern "sysv64" fn struct_48_bits(a: S48) -> S48 {
+    a
+}
diff --git a/tests/codegen-llvm/addr-of-mutate.rs b/tests/codegen-llvm/addr-of-mutate.rs
new file mode 100644
index 00000000000..14bc4b8ab28
--- /dev/null
+++ b/tests/codegen-llvm/addr-of-mutate.rs
@@ -0,0 +1,33 @@
+//@ compile-flags: -C opt-level=3 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+// Test for the absence of `readonly` on the argument when it is mutated via `&raw const`.
+// See <https://github.com/rust-lang/rust/issues/111502>.
+
+// CHECK: i8 @foo(ptr noalias{{( nocapture)?}} noundef align 1{{( captures\(none\))?}} dereferenceable(128) %x)
+#[no_mangle]
+pub fn foo(x: [u8; 128]) -> u8 {
+    let ptr = core::ptr::addr_of!(x).cast_mut();
+    unsafe {
+        (*ptr)[0] = 1;
+    }
+    x[0]
+}
+
+// CHECK: i1 @second(ptr noalias{{( nocapture)?}} noundef align {{[0-9]+}}{{( captures\(none\))?}} dereferenceable({{[0-9]+}}) %a_ptr_and_b)
+#[no_mangle]
+pub unsafe fn second(a_ptr_and_b: (*mut (i32, bool), (i64, bool))) -> bool {
+    let b_bool_ptr = core::ptr::addr_of!(a_ptr_and_b.1.1).cast_mut();
+    (*b_bool_ptr) = true;
+    a_ptr_and_b.1.1
+}
+
+// If going through a deref (and there are no other mutating accesses), then `readonly` is fine.
+// CHECK: i1 @third(ptr noalias{{( nocapture)?}} noundef readonly align {{[0-9]+}}{{( captures\(none\))?}} dereferenceable({{[0-9]+}}) %a_ptr_and_b)
+#[no_mangle]
+pub unsafe fn third(a_ptr_and_b: (*mut (i32, bool), (i64, bool))) -> bool {
+    let b_bool_ptr = core::ptr::addr_of!((*a_ptr_and_b.0).1).cast_mut();
+    (*b_bool_ptr) = true;
+    a_ptr_and_b.1.1
+}
diff --git a/tests/codegen-llvm/adjustments.rs b/tests/codegen-llvm/adjustments.rs
new file mode 100644
index 00000000000..7f7831def08
--- /dev/null
+++ b/tests/codegen-llvm/adjustments.rs
@@ -0,0 +1,28 @@
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+
+#![crate_type = "lib"]
+
+// Hack to get the correct size for the length part in slices
+// CHECK: @helper([[USIZE:i[0-9]+]] %_1)
+#[no_mangle]
+pub fn helper(_: usize) {}
+
+// CHECK-LABEL: @no_op_slice_adjustment
+#[no_mangle]
+pub fn no_op_slice_adjustment(x: &[u8]) -> &[u8] {
+    // We used to generate an extra alloca and memcpy for the block's trailing expression value, so
+    // check that we copy directly to the return value slot
+    // CHECK: %0 = insertvalue { ptr, [[USIZE]] } poison, ptr %x.0, 0
+    // CHECK: %1 = insertvalue { ptr, [[USIZE]] } %0, [[USIZE]] %x.1, 1
+    // CHECK: ret { ptr, [[USIZE]] } %1
+    { x }
+}
+
+// CHECK-LABEL: @no_op_slice_adjustment2
+#[no_mangle]
+pub fn no_op_slice_adjustment2(x: &[u8]) -> &[u8] {
+    // We used to generate an extra alloca and memcpy for the function's return value, so check
+    // that there's no memcpy (the slice is written to sret_slot element-wise)
+    // CHECK-NOT: call void @llvm.memcpy.
+    no_op_slice_adjustment(x)
+}
diff --git a/tests/codegen-llvm/align-byval-alignment-mismatch.rs b/tests/codegen-llvm/align-byval-alignment-mismatch.rs
new file mode 100644
index 00000000000..c69fc2de9d2
--- /dev/null
+++ b/tests/codegen-llvm/align-byval-alignment-mismatch.rs
@@ -0,0 +1,126 @@
+// ignore-tidy-linelength
+//@ add-core-stubs
+//@ revisions:i686-linux x86_64-linux
+
+//@ compile-flags: -Cno-prepopulate-passes -Copt-level=1 -Cpanic=abort
+//@[i686-linux] compile-flags: --target i686-unknown-linux-gnu
+//@[i686-linux] needs-llvm-components: x86
+//@[x86_64-linux] compile-flags: --target x86_64-unknown-linux-gnu
+//@[x86_64-linux] needs-llvm-components: x86
+
+// Tests that we correctly copy arguments into allocas when the alignment of the byval argument
+// is different from the alignment of the Rust type.
+
+// For the following test cases:
+// All of the `*_decreases_alignment` functions should codegen to a direct call, since the
+// alignment is already sufficient.
+// All off the `*_increases_alignment` functions should copy the argument to an alloca
+// on i686-unknown-linux-gnu, since the alignment needs to be increased, and should codegen
+// to a direct call on x86_64-unknown-linux-gnu, where byval alignment matches Rust alignment.
+
+#![feature(no_core)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+// This type has align 1 in Rust, but as a byval argument on i686-linux, it will have align 4.
+#[repr(C)]
+#[repr(packed)]
+struct Align1 {
+    x: u128,
+    y: u128,
+    z: u128,
+}
+
+// This type has align 16 in Rust, but as a byval argument on i686-linux, it will have align 4.
+#[repr(C)]
+#[repr(align(16))]
+struct Align16 {
+    x: u128,
+    y: u128,
+    z: u128,
+}
+
+extern "C" {
+    fn extern_c_align1(x: Align1);
+    fn extern_c_align16(x: Align16);
+}
+
+// CHECK-LABEL: @rust_to_c_increases_alignment
+#[no_mangle]
+pub unsafe fn rust_to_c_increases_alignment(x: Align1) {
+    // i686-linux: start:
+    // i686-linux-NEXT: [[ALLOCA:%[0-9a-z]+]] = alloca [48 x i8], align 4
+    // i686-linux-NEXT: call void @llvm.lifetime.start.p0(i64 48, ptr {{.*}}[[ALLOCA]])
+    // i686-linux-NEXT: call void @llvm.memcpy.{{.+}}(ptr {{.*}}align 4 {{.*}}[[ALLOCA]], ptr {{.*}}align 1 {{.*}}%x
+    // i686-linux-NEXT: call void @extern_c_align1({{.+}} [[ALLOCA]])
+    // i686-linux-NEXT: call void @llvm.lifetime.end.p0(i64 48, ptr {{.*}}[[ALLOCA]])
+
+    // x86_64-linux: start:
+    // x86_64-linux-NEXT: call void @extern_c_align1
+    extern_c_align1(x);
+}
+
+// CHECK-LABEL: @rust_to_c_decreases_alignment
+#[no_mangle]
+pub unsafe fn rust_to_c_decreases_alignment(x: Align16) {
+    // CHECK: start:
+    // CHECK-NEXT: call void @extern_c_align16
+    extern_c_align16(x);
+}
+
+extern "Rust" {
+    fn extern_rust_align1(x: Align1);
+    fn extern_rust_align16(x: Align16);
+}
+
+// CHECK-LABEL: @c_to_rust_decreases_alignment
+#[no_mangle]
+pub unsafe extern "C" fn c_to_rust_decreases_alignment(x: Align1) {
+    // CHECK: start:
+    // CHECK-NEXT: call void @extern_rust_align1
+    extern_rust_align1(x);
+}
+
+// CHECK-LABEL: @c_to_rust_increases_alignment
+#[no_mangle]
+pub unsafe extern "C" fn c_to_rust_increases_alignment(x: Align16) {
+    // i686-linux: start:
+    // i686-linux-NEXT: [[ALLOCA:%[0-9a-z]+]] = alloca [48 x i8], align 16
+    // i686-linux-NEXT: call void @llvm.memcpy.{{.+}}(ptr {{.*}}align 16 {{.*}}[[ALLOCA]], ptr {{.*}}align 4 {{.*}}%0
+    // i686-linux-NEXT: call void @extern_rust_align16({{.+}} [[ALLOCA]])
+
+    // x86_64-linux: start:
+    // x86_64-linux-NEXT: call void @extern_rust_align16
+    extern_rust_align16(x);
+}
+
+extern "Rust" {
+    fn extern_rust_ref_align1(x: &Align1);
+    fn extern_rust_ref_align16(x: &Align16);
+}
+
+// CHECK-LABEL: @c_to_rust_ref_decreases_alignment
+#[no_mangle]
+pub unsafe extern "C" fn c_to_rust_ref_decreases_alignment(x: Align1) {
+    // CHECK: start:
+    // CHECK-NEXT: call void @extern_rust_ref_align1
+    extern_rust_ref_align1(&x);
+}
+
+// CHECK-LABEL: @c_to_rust_ref_increases_alignment
+#[no_mangle]
+pub unsafe extern "C" fn c_to_rust_ref_increases_alignment(x: Align16) {
+    // i686-linux: start:
+    // i686-linux-NEXT: [[ALLOCA:%[0-9a-z]+]] = alloca [48 x i8], align 16
+    // i686-linux-NEXT: call void @llvm.memcpy.{{.+}}(ptr {{.*}}align 16 {{.*}}[[ALLOCA]], ptr {{.*}}align 4 {{.*}}%0
+    // i686-linux-NEXT: call void @extern_rust_ref_align16({{.+}} [[ALLOCA]])
+
+    // x86_64-linux: start:
+    // x86_64-linux-NEXT: call void @extern_rust_ref_align16
+    extern_rust_ref_align16(&x);
+}
diff --git a/tests/codegen-llvm/align-byval-vector.rs b/tests/codegen-llvm/align-byval-vector.rs
new file mode 100644
index 00000000000..c33b41a7bbe
--- /dev/null
+++ b/tests/codegen-llvm/align-byval-vector.rs
@@ -0,0 +1,55 @@
+//@ add-core-stubs
+//@ revisions:x86-linux x86-darwin
+
+//@[x86-linux] compile-flags: --target i686-unknown-linux-gnu
+//@[x86-linux] needs-llvm-components: x86
+//@[x86-darwin] compile-flags: --target i686-apple-darwin
+//@[x86-darwin] needs-llvm-components: x86
+
+// Tests that aggregates containing vector types get their alignment increased to 16 on Darwin.
+
+#![feature(no_core, repr_simd, simd_ffi)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+#![allow(non_camel_case_types)]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(simd)]
+pub struct i32x4([i32; 4]);
+
+#[repr(C)]
+pub struct Foo {
+    a: i32x4,
+    b: i8,
+}
+
+// This tests that we recursively check for vector types, not just at the top level.
+#[repr(C)]
+pub struct DoubleFoo {
+    one: Foo,
+    two: Foo,
+}
+
+extern "C" {
+    // x86-linux: declare void @f({{.*}}byval([32 x i8]) align 4{{.*}})
+    // x86-darwin: declare void @f({{.*}}byval([32 x i8]) align 16{{.*}})
+    fn f(foo: Foo);
+
+    // x86-linux: declare void @g({{.*}}byval([64 x i8]) align 4{{.*}})
+    // x86-darwin: declare void @g({{.*}}byval([64 x i8]) align 16{{.*}})
+    fn g(foo: DoubleFoo);
+}
+
+pub fn main() {
+    unsafe { f(Foo { a: i32x4([1, 2, 3, 4]), b: 0 }) }
+
+    unsafe {
+        g(DoubleFoo {
+            one: Foo { a: i32x4([1, 2, 3, 4]), b: 0 },
+            two: Foo { a: i32x4([1, 2, 3, 4]), b: 0 },
+        })
+    }
+}
diff --git a/tests/codegen-llvm/align-byval.rs b/tests/codegen-llvm/align-byval.rs
new file mode 100644
index 00000000000..75dabd74a79
--- /dev/null
+++ b/tests/codegen-llvm/align-byval.rs
@@ -0,0 +1,315 @@
+// ignore-tidy-linelength
+//@ add-core-stubs
+//@ revisions:m68k x86_64-linux x86_64-windows i686-linux i686-windows
+
+//@[m68k] compile-flags: --target m68k-unknown-linux-gnu
+//@[m68k] needs-llvm-components: m68k
+//@[x86_64-linux] compile-flags: --target x86_64-unknown-linux-gnu
+//@[x86_64-linux] needs-llvm-components: x86
+//@[x86_64-windows] compile-flags: --target x86_64-pc-windows-msvc
+//@[x86_64-windows] needs-llvm-components: x86
+//@[i686-linux] compile-flags: --target i686-unknown-linux-gnu
+//@[i686-linux] needs-llvm-components: x86
+//@[i686-windows] compile-flags: --target i686-pc-windows-msvc
+//@[i686-windows] needs-llvm-components: x86
+
+// Tests that `byval` alignment is properly specified (#80127).
+// The only targets that use `byval` are m68k, x86-64, and x86.
+// Note also that Windows mandates a by-ref ABI here, so it does not use byval.
+
+#![feature(no_core)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// This struct can be represented as a pair, so it exercises the OperandValue::Pair
+// codepath in `codegen_argument`.
+#[repr(C)]
+pub struct NaturalAlign1 {
+    a: i8,
+    b: i8,
+}
+
+// This struct cannot be represented as an immediate, so it exercises the OperandValue::Ref
+// codepath in `codegen_argument`.
+#[repr(C)]
+pub struct NaturalAlign2 {
+    a: [i16; 16],
+    b: i16,
+}
+
+#[repr(C)]
+#[repr(align(4))]
+pub struct ForceAlign4 {
+    a: [i8; 16],
+    b: i8,
+}
+
+// On i686-windows, this is passed on stack using `byval`
+#[repr(C)]
+pub struct NaturalAlign8 {
+    a: i64,
+    b: i64,
+    c: i64,
+}
+
+// On i686-windows, this is passed by reference (because alignment is >4 and requested/forced),
+// even though it has the exact same layout as `NaturalAlign8`!
+#[repr(C)]
+#[repr(align(8))]
+pub struct ForceAlign8 {
+    a: i64,
+    b: i64,
+    c: i64,
+}
+
+// On i686-windows, this is passed on stack, because requested alignment is <=4.
+#[repr(C)]
+#[repr(align(4))]
+pub struct LowerFA8 {
+    a: i64,
+    b: i64,
+    c: i64,
+}
+
+// On i686-windows, this is passed by reference, because it contains a field with
+// requested/forced alignment.
+#[repr(C)]
+pub struct WrappedFA8 {
+    a: ForceAlign8,
+}
+
+// On i686-windows, this has the same ABI as ForceAlign8, i.e. passed by reference.
+#[repr(transparent)]
+pub struct TransparentFA8 {
+    _0: (),
+    a: ForceAlign8,
+}
+
+#[repr(C)]
+#[repr(align(16))]
+pub struct ForceAlign16 {
+    a: [i32; 16],
+    b: i8,
+}
+
+// CHECK-LABEL: @call_na1
+#[no_mangle]
+pub unsafe fn call_na1(x: NaturalAlign1) {
+    // CHECK: start:
+
+    // m68k: [[ALLOCA:%[a-z0-9+]]] = alloca [2 x i8], align 1
+    // m68k: call void @natural_align_1({{.*}}byval([2 x i8]) align 1{{.*}} [[ALLOCA]])
+
+    // x86_64-linux: call void @natural_align_1(i16
+
+    // x86_64-windows: call void @natural_align_1(i16
+
+    // i686-linux: [[ALLOCA:%[a-z0-9+]]] = alloca [2 x i8], align 4
+    // i686-linux: call void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}} [[ALLOCA]])
+
+    // i686-windows: [[ALLOCA:%[a-z0-9+]]] = alloca [2 x i8], align 4
+    // i686-windows: call void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}} [[ALLOCA]])
+    natural_align_1(x);
+}
+
+// CHECK-LABEL: @call_na2
+#[no_mangle]
+pub unsafe fn call_na2(x: NaturalAlign2) {
+    // CHECK: start:
+
+    // m68k-NEXT: call void @natural_align_2
+    // x86_64-linux-NEXT: call void @natural_align_2
+    // x86_64-windows-NEXT: call void @natural_align_2
+
+    // i686-linux: [[ALLOCA:%[0-9]+]] = alloca [34 x i8], align 4
+    // i686-linux: call void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}} [[ALLOCA]])
+
+    // i686-windows: [[ALLOCA:%[0-9]+]] = alloca [34 x i8], align 4
+    // i686-windows: call void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}} [[ALLOCA]])
+    natural_align_2(x);
+}
+
+// CHECK-LABEL: @call_fa4
+#[no_mangle]
+pub unsafe fn call_fa4(x: ForceAlign4) {
+    // CHECK: start:
+    // CHECK-NEXT: call void @force_align_4
+    force_align_4(x);
+}
+
+// CHECK-LABEL: @call_na8
+#[no_mangle]
+pub unsafe fn call_na8(x: NaturalAlign8) {
+    // CHECK: start:
+    // CHECK-NEXT: call void @natural_align_8
+    natural_align_8(x);
+}
+
+// CHECK-LABEL: @call_fa8
+#[no_mangle]
+pub unsafe fn call_fa8(x: ForceAlign8) {
+    // CHECK: start:
+    // CHECK-NEXT: call void @force_align_8
+    force_align_8(x);
+}
+
+// CHECK-LABEL: @call_lfa8
+#[no_mangle]
+pub unsafe fn call_lfa8(x: LowerFA8) {
+    // CHECK: start:
+    // CHECK-NEXT: call void @lower_fa8
+    lower_fa8(x);
+}
+
+// CHECK-LABEL: @call_wfa8
+#[no_mangle]
+pub unsafe fn call_wfa8(x: WrappedFA8) {
+    // CHECK: start:
+    // CHECK-NEXT: call void @wrapped_fa8
+    wrapped_fa8(x);
+}
+
+// CHECK-LABEL: @call_tfa8
+#[no_mangle]
+pub unsafe fn call_tfa8(x: TransparentFA8) {
+    // CHECK: start:
+    // CHECK-NEXT: call void @transparent_fa8
+    transparent_fa8(x);
+}
+
+// CHECK-LABEL: @call_fa16
+#[no_mangle]
+pub unsafe fn call_fa16(x: ForceAlign16) {
+    // CHECK: start:
+    // CHECK-NEXT: call void @force_align_16
+    force_align_16(x);
+}
+
+extern "C" {
+    // m68k: declare void @natural_align_1({{.*}}byval([2 x i8]) align 1{{.*}})
+
+    // x86_64-linux: declare void @natural_align_1(i16)
+
+    // x86_64-windows: declare void @natural_align_1(i16)
+
+    // i686-linux: declare void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}})
+
+    // i686-windows: declare void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}})
+    fn natural_align_1(x: NaturalAlign1);
+
+    // m68k: declare void @natural_align_2({{.*}}byval([34 x i8]) align 2{{.*}})
+
+    // x86_64-linux: declare void @natural_align_2({{.*}}byval([34 x i8]) align 2{{.*}})
+
+    // x86_64-windows: declare void @natural_align_2(
+    // x86_64-windows-NOT: byval
+    // x86_64-windows-SAME: align 2{{.*}})
+
+    // i686-linux: declare void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}})
+
+    // i686-windows: declare void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}})
+    fn natural_align_2(x: NaturalAlign2);
+
+    // m68k: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
+
+    // x86_64-linux: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
+
+    // x86_64-windows: declare void @force_align_4(
+    // x86_64-windows-NOT: byval
+    // x86_64-windows-SAME: align 4{{.*}})
+
+    // i686-linux: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
+
+    // i686-windows: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
+    fn force_align_4(x: ForceAlign4);
+
+    // m68k: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
+
+    // x86_64-linux: declare void @natural_align_8({{.*}}byval([24 x i8]) align 8{{.*}})
+
+    // x86_64-windows: declare void @natural_align_8(
+    // x86_64-windows-NOT: byval
+    // x86_64-windows-SAME: align 8{{.*}})
+
+    // i686-linux: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
+
+    // i686-windows: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
+    fn natural_align_8(x: NaturalAlign8);
+
+    // m68k: declare void @force_align_8({{.*}}byval([24 x i8]) align 8{{.*}})
+
+    // x86_64-linux: declare void @force_align_8({{.*}}byval([24 x i8]) align 8{{.*}})
+
+    // x86_64-windows: declare void @force_align_8(
+    // x86_64-windows-NOT: byval
+    // x86_64-windows-SAME: align 8{{.*}})
+
+    // i686-linux: declare void @force_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
+
+    // i686-windows: declare void @force_align_8(
+    // i686-windows-NOT: byval
+    // i686-windows-SAME: align 8{{.*}})
+    fn force_align_8(x: ForceAlign8);
+
+    // m68k: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
+
+    // x86_64-linux: declare void @lower_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
+
+    // x86_64-windows: declare void @lower_fa8(
+    // x86_64-windows-NOT: byval
+    // x86_64-windows-SAME: align 8{{.*}})
+
+    // i686-linux: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
+
+    // i686-windows: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
+    fn lower_fa8(x: LowerFA8);
+
+    // m68k: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
+
+    // x86_64-linux: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
+
+    // x86_64-windows: declare void @wrapped_fa8(
+    // x86_64-windows-NOT: byval
+    // x86_64-windows-SAME: align 8{{.*}})
+
+    // i686-linux: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
+
+    // i686-windows: declare void @wrapped_fa8(
+    // i686-windows-NOT: byval
+    // i686-windows-SAME: align 8{{.*}})
+    fn wrapped_fa8(x: WrappedFA8);
+
+    // m68k: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
+
+    // x86_64-linux: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
+
+    // x86_64-windows: declare void @transparent_fa8(
+    // x86_64-windows-NOT: byval
+    // x86_64-windows-SAME: align 8{{.*}})
+
+    // i686-linux: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
+
+    // i686-windows: declare void @transparent_fa8(
+    // i686-windows-NOT: byval
+    // i686-windows-SAME: align 8{{.*}})
+    fn transparent_fa8(x: TransparentFA8);
+
+    // m68k: declare void @force_align_16({{.*}}byval([80 x i8]) align 16{{.*}})
+
+    // x86_64-linux: declare void @force_align_16({{.*}}byval([80 x i8]) align 16{{.*}})
+
+    // x86_64-windows: declare void @force_align_16(
+    // x86_64-windows-NOT: byval
+    // x86_64-windows-SAME: align 16{{.*}})
+
+    // i686-linux: declare void @force_align_16({{.*}}byval([80 x i8]) align 4{{.*}})
+
+    // i686-windows: declare void @force_align_16(
+    // i686-windows-NOT: byval
+    // i686-windows-SAME: align 16{{.*}})
+    fn force_align_16(x: ForceAlign16);
+}
diff --git a/tests/codegen-llvm/align-enum.rs b/tests/codegen-llvm/align-enum.rs
new file mode 100644
index 00000000000..e8dd95d3afb
--- /dev/null
+++ b/tests/codegen-llvm/align-enum.rs
@@ -0,0 +1,33 @@
+//@ compile-flags: -C no-prepopulate-passes -Z mir-opt-level=0
+//
+
+#![crate_type = "lib"]
+
+#[repr(align(64))]
+pub enum Align64 {
+    A(u32),
+    B(u32),
+}
+
+pub struct Nested64 {
+    a: u8,
+    b: Align64,
+    c: u16,
+}
+
+// CHECK-LABEL: @align64
+#[no_mangle]
+pub fn align64(a: u32) -> Align64 {
+    // CHECK: %a64 = alloca [64 x i8], align 64
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 64 %{{.*}}, ptr align 64 %{{.*}}, i{{[0-9]+}} 64, i1 false)
+    let a64 = Align64::A(a);
+    a64
+}
+
+// CHECK-LABEL: @nested64
+#[no_mangle]
+pub fn nested64(a: u8, b: u32, c: u16) -> Nested64 {
+    // CHECK: %n64 = alloca [128 x i8], align 64
+    let n64 = Nested64 { a, b: Align64::B(b), c };
+    n64
+}
diff --git a/tests/codegen-llvm/align-fn.rs b/tests/codegen-llvm/align-fn.rs
new file mode 100644
index 00000000000..cbc24e2ae2e
--- /dev/null
+++ b/tests/codegen-llvm/align-fn.rs
@@ -0,0 +1,143 @@
+//@ compile-flags: -C no-prepopulate-passes -Z mir-opt-level=0 -Clink-dead-code
+//@ edition: 2024
+//@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
+
+#![crate_type = "lib"]
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+#![feature(rustc_attrs)]
+#![feature(fn_align)]
+
+// CHECK: align 16
+#[unsafe(no_mangle)]
+#[rustc_align(16)]
+pub fn fn_align() {}
+
+pub struct A;
+
+impl A {
+    // CHECK: align 16
+    #[unsafe(no_mangle)]
+    #[rustc_align(16)]
+    pub fn method_align(self) {}
+
+    // CHECK: align 16
+    #[unsafe(no_mangle)]
+    #[rustc_align(16)]
+    pub fn associated_fn() {}
+}
+
+trait T: Sized {
+    fn trait_fn() {}
+
+    fn trait_method(self) {}
+
+    #[rustc_align(8)]
+    fn trait_method_inherit_low(self);
+
+    #[rustc_align(32)]
+    fn trait_method_inherit_high(self);
+
+    #[rustc_align(32)]
+    fn trait_method_inherit_default(self) {}
+
+    #[rustc_align(4)]
+    #[rustc_align(128)]
+    #[rustc_align(8)]
+    fn inherit_highest(self) {}
+}
+
+impl T for A {
+    // CHECK-LABEL: trait_fn
+    // CHECK-SAME: align 16
+    #[unsafe(no_mangle)]
+    #[rustc_align(16)]
+    fn trait_fn() {}
+
+    // CHECK-LABEL: trait_method
+    // CHECK-SAME: align 16
+    #[unsafe(no_mangle)]
+    #[rustc_align(16)]
+    fn trait_method(self) {}
+
+    // The prototype's align is ignored because the align here is higher.
+    // CHECK-LABEL: trait_method_inherit_low
+    // CHECK-SAME: align 16
+    #[unsafe(no_mangle)]
+    #[rustc_align(16)]
+    fn trait_method_inherit_low(self) {}
+
+    // The prototype's align is used because it is higher.
+    // CHECK-LABEL: trait_method_inherit_high
+    // CHECK-SAME: align 32
+    #[unsafe(no_mangle)]
+    #[rustc_align(16)]
+    fn trait_method_inherit_high(self) {}
+
+    // The prototype's align inherited.
+    // CHECK-LABEL: trait_method_inherit_default
+    // CHECK-SAME: align 32
+    #[unsafe(no_mangle)]
+    fn trait_method_inherit_default(self) {}
+
+    // The prototype's highest align inherited.
+    // CHECK-LABEL: inherit_highest
+    // CHECK-SAME: align 128
+    #[unsafe(no_mangle)]
+    #[rustc_align(32)]
+    #[rustc_align(64)]
+    fn inherit_highest(self) {}
+}
+
+trait HasDefaultImpl: Sized {
+    // CHECK-LABEL: inherit_from_default_method
+    // CHECK-LABEL: inherit_from_default_method
+    // CHECK-SAME: align 32
+    #[rustc_align(32)]
+    fn inherit_from_default_method(self) {}
+}
+
+pub struct InstantiateDefaultMethods;
+
+impl HasDefaultImpl for InstantiateDefaultMethods {}
+
+// CHECK-LABEL: align_specified_twice_1
+// CHECK-SAME: align 64
+#[unsafe(no_mangle)]
+#[rustc_align(32)]
+#[rustc_align(64)]
+pub fn align_specified_twice_1() {}
+
+// CHECK-LABEL: align_specified_twice_2
+// CHECK-SAME: align 128
+#[unsafe(no_mangle)]
+#[rustc_align(128)]
+#[rustc_align(32)]
+pub fn align_specified_twice_2() {}
+
+// CHECK-LABEL: align_specified_twice_3
+// CHECK-SAME: align 256
+#[unsafe(no_mangle)]
+#[rustc_align(32)]
+#[rustc_align(256)]
+pub fn align_specified_twice_3() {}
+
+const _: () = {
+    // CHECK-LABEL: align_unmangled
+    // CHECK-SAME: align 256
+    #[unsafe(no_mangle)]
+    #[rustc_align(32)]
+    #[rustc_align(256)]
+    extern "C" fn align_unmangled() {}
+};
+
+unsafe extern "C" {
+    #[rustc_align(256)]
+    fn align_unmangled();
+}
+
+// FIXME also check `gen` et al
+// CHECK-LABEL: async_align
+// CHECK-SAME: align 64
+#[unsafe(no_mangle)]
+#[rustc_align(64)]
+pub async fn async_align() {}
diff --git a/tests/codegen-llvm/align-offset.rs b/tests/codegen-llvm/align-offset.rs
new file mode 100644
index 00000000000..21062cc0a91
--- /dev/null
+++ b/tests/codegen-llvm/align-offset.rs
@@ -0,0 +1,75 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @align8
+#[no_mangle]
+pub fn align8(p: *const u8) -> bool {
+    // CHECK: ret i1 true
+    p.align_offset(8) < 8
+}
+
+#[repr(align(4))]
+pub struct Align4([u8; 4]);
+
+// CHECK-LABEL: @align_to4
+#[no_mangle]
+pub fn align_to4(x: &[u8]) -> bool {
+    // CHECK: ret i1 true
+    let (prefix, _middle, suffix) = unsafe { x.align_to::<Align4>() };
+    prefix.len() < 4 && suffix.len() < 4
+}
+
+// CHECK-LABEL: @align_offset_byte_ptr(ptr{{.+}}%ptr)
+#[no_mangle]
+pub fn align_offset_byte_ptr(ptr: *const u8) -> usize {
+    // CHECK: %[[ADDR:.+]] = ptrtoint ptr %ptr to [[USIZE:i[0-9]+]]
+    // CHECK: %[[UP:.+]] = add [[USIZE]] %[[ADDR]], 31
+    // CHECK: %[[ALIGNED:.+]] = and [[USIZE]] %[[UP]], -32
+    // CHECK: %[[OFFSET:.+]] = sub [[USIZE]] %[[ALIGNED]], %[[ADDR]]
+
+    // Since we're offsetting a byte pointer, there's no further fixups
+    // CHECK-NOT: shr
+    // CHECK-NOT: div
+    // CHECK-NOT: select
+
+    // CHECK: ret [[USIZE]] %[[OFFSET]]
+    ptr.align_offset(32)
+}
+
+// CHECK-LABEL: @align_offset_word_slice(ptr{{.+}}align 4{{.+}}%slice.0
+#[no_mangle]
+pub fn align_offset_word_slice(slice: &[Align4]) -> usize {
+    // CHECK: %[[ADDR:.+]] = ptrtoint ptr %slice.0 to [[USIZE]]
+    // CHECK: %[[UP:.+]] = add [[USIZE]] %[[ADDR]], 31
+    // CHECK: %[[ALIGNED:.+]] = and [[USIZE]] %[[UP]], -32
+    // CHECK: %[[BOFFSET:.+]] = sub [[USIZE]] %[[ALIGNED]], %[[ADDR]]
+    // CHECK: %[[OFFSET:.+]] = lshr exact [[USIZE]] %[[BOFFSET]], 2
+
+    // Slices are known to be aligned, so we don't need the "maybe -1" path
+    // CHECK-NOT: select
+
+    // CHECK: ret [[USIZE]] %[[OFFSET]]
+    slice.as_ptr().align_offset(32)
+}
+
+// CHECK-LABEL: @align_offset_word_ptr(ptr{{.+}}%ptr
+#[no_mangle]
+pub fn align_offset_word_ptr(ptr: *const Align4) -> usize {
+    // CHECK: %[[ADDR:.+]] = ptrtoint ptr %ptr to [[USIZE]]
+    // CHECK: %[[UP:.+]] = add [[USIZE]] %[[ADDR]], 31
+    // CHECK: %[[ALIGNED:.+]] = and [[USIZE]] %[[UP]], -32
+    // CHECK: %[[BOFFSET:.+]] = sub [[USIZE]] %[[ALIGNED]], %[[ADDR]]
+
+    // While we can always get a *byte* offset that will work, if the original
+    // pointer is unaligned it might be impossible to return an *element* offset
+    // that will make it aligned. We want it to be a `select`, not a `br`, so
+    // that the assembly will be branchless.
+    // CHECK: %[[LOW:.+]] = and [[USIZE]] %[[ADDR]], 3
+    // CHECK: %[[ORIGINAL_ALIGNED:.+]] = icmp eq [[USIZE]] %[[LOW]], 0
+    // CHECK: %[[OFFSET:.+]] = lshr exact [[USIZE]] %[[BOFFSET]], 2
+    // CHECK: %[[R:.+]] = select i1 %[[ORIGINAL_ALIGNED]], [[USIZE]] %[[OFFSET]], [[USIZE]] -1
+
+    // CHECK: ret [[USIZE]] %[[R]]
+    ptr.align_offset(32)
+}
diff --git a/tests/codegen-llvm/align-struct.rs b/tests/codegen-llvm/align-struct.rs
new file mode 100644
index 00000000000..d4cc65e9158
--- /dev/null
+++ b/tests/codegen-llvm/align-struct.rs
@@ -0,0 +1,70 @@
+//@ compile-flags: -C no-prepopulate-passes -Z mir-opt-level=0
+// 32bit MSVC does not align things properly so we suppress high alignment annotations (#112480)
+//@ ignore-i686-pc-windows-msvc
+//@ ignore-i686-pc-windows-gnu
+
+#![crate_type = "lib"]
+
+#[repr(align(64))]
+pub struct Align64(i32);
+
+pub struct Nested64 {
+    a: Align64,
+    b: i32,
+    c: i32,
+    d: i8,
+}
+
+// This has the extra field in B to ensure it's not ScalarPair,
+// and thus that the test actually emits it via memory, not `insertvalue`.
+pub enum Enum4 {
+    A(i32),
+    B(i32, i32),
+}
+
+pub enum Enum64 {
+    A(Align64),
+    B(i32),
+}
+
+// CHECK-LABEL: @align64
+#[no_mangle]
+pub fn align64(i: i32) -> Align64 {
+    // CHECK: %a64 = alloca [64 x i8], align 64
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 64 %{{.*}}, ptr align 64 %{{.*}}, i{{[0-9]+}} 64, i1 false)
+    let a64 = Align64(i);
+    a64
+}
+
+// For issue 54028: make sure that we are specifying the correct alignment for fields of aligned
+// structs
+// CHECK-LABEL: @align64_load
+#[no_mangle]
+pub fn align64_load(a: Align64) -> i32 {
+    // CHECK: {{%.*}} = load i32, ptr {{%.*}}, align 64
+    a.0
+}
+
+// CHECK-LABEL: @nested64
+#[no_mangle]
+pub fn nested64(a: Align64, b: i32, c: i32, d: i8) -> Nested64 {
+    // CHECK: %n64 = alloca [128 x i8], align 64
+    let n64 = Nested64 { a, b, c, d };
+    n64
+}
+
+// CHECK-LABEL: @enum4
+#[no_mangle]
+pub fn enum4(a: i32) -> Enum4 {
+    // CHECK: %e4 = alloca [12 x i8], align 4
+    let e4 = Enum4::A(a);
+    e4
+}
+
+// CHECK-LABEL: @enum64
+#[no_mangle]
+pub fn enum64(a: Align64) -> Enum64 {
+    // CHECK: %e64 = alloca [128 x i8], align 64
+    let e64 = Enum64::A(a);
+    e64
+}
diff --git a/tests/codegen-llvm/alloc-optimisation.rs b/tests/codegen-llvm/alloc-optimisation.rs
new file mode 100644
index 00000000000..3735860d510
--- /dev/null
+++ b/tests/codegen-llvm/alloc-optimisation.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn alloc_test(data: u32) {
+    // CHECK-LABEL: @alloc_test
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ; call __rustc::__rust_no_alloc_shim_is_unstable_v2
+    // CHECK-NEXT: tail call void @_R{{.+}}__rust_no_alloc_shim_is_unstable_v2()
+    // CHECK-NEXT: ret void
+    let x = Box::new(data);
+    drop(x);
+}
diff --git a/tests/codegen-llvm/amdgpu-addrspacecast.rs b/tests/codegen-llvm/amdgpu-addrspacecast.rs
new file mode 100644
index 00000000000..7fe630a7efa
--- /dev/null
+++ b/tests/codegen-llvm/amdgpu-addrspacecast.rs
@@ -0,0 +1,18 @@
+// Check that pointers are casted to addrspace(0) before they are used
+
+//@ compile-flags: --crate-type=rlib --target=amdgcn-amd-amdhsa -Ctarget-cpu=gfx900
+//@ needs-llvm-components: amdgpu
+//@ add-core-stubs
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+
+// CHECK-LABEL: @ref_of_local
+// CHECK: [[alloca:%[0-9]]] = alloca
+// CHECK: %i = addrspacecast ptr addrspace(5) [[alloca]] to ptr
+#[no_mangle]
+pub fn ref_of_local(f: fn(&i32)) {
+    let i = 0;
+    f(&i);
+}
diff --git a/tests/codegen-llvm/array-clone.rs b/tests/codegen-llvm/array-clone.rs
new file mode 100644
index 00000000000..35445174684
--- /dev/null
+++ b/tests/codegen-llvm/array-clone.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @array_clone
+#[no_mangle]
+pub fn array_clone(a: &[u8; 2]) -> [u8; 2] {
+    // CHECK-NOT: getelementptr
+    // CHECK-NOT: load i8
+    // CHECK-NOT: zext
+    // CHECK-NOT: shl
+    // CHECK: load i16
+    // CHECK-NEXT: ret i16
+    a.clone()
+}
diff --git a/tests/codegen-llvm/array-cmp.rs b/tests/codegen-llvm/array-cmp.rs
new file mode 100644
index 00000000000..0d337655401
--- /dev/null
+++ b/tests/codegen-llvm/array-cmp.rs
@@ -0,0 +1,74 @@
+// Ensure the asm for array comparisons is properly optimized.
+
+//@ compile-flags: -C opt-level=2
+//@ needs-deterministic-layouts (checks depend on tuple layout)
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @compare
+// CHECK: start:
+// CHECK-NEXT: ret i1 true
+#[no_mangle]
+pub fn compare() -> bool {
+    let bytes = 12.5f32.to_ne_bytes();
+    bytes
+        == if cfg!(target_endian = "big") {
+            [0x41, 0x48, 0x00, 0x00]
+        } else {
+            [0x00, 0x00, 0x48, 0x41]
+        }
+}
+
+// CHECK-LABEL: @array_of_tuple_le
+#[no_mangle]
+pub fn array_of_tuple_le(a: &[(i16, u16); 2], b: &[(i16, u16); 2]) -> bool {
+    // Ensure that, after all the optimizations have run, the happy path just checks
+    // `eq` on each corresponding pair and moves onto the next one if it is.
+    // Then there's a dedup'd comparison for the place that's different.
+    // (As opposed to, say, running a full `[su]cmp` as part of checking equality.)
+
+    // This is written quite specifically because different library code was triggering
+    // <https://github.com/llvm/llvm-project/issues/132678> along the way, so this
+    // has enough checks to make sure that's not happening. It doesn't need to be
+    // *exactly* this IR, but be careful if you ever need to update these checks.
+
+    // CHECK: start:
+    // CHECK: %[[A00:.+]] = load i16, ptr %a
+    // CHECK: %[[B00:.+]] = load i16, ptr %b
+    // CHECK-NOT: cmp
+    // 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]]
+    // CHECK: %[[B10:.+]] = load i16, ptr %[[PB10]]
+    // CHECK-NOT: cmp
+    // CHECK: %[[EQ10:.+]] = icmp eq i16 %[[A10]], %[[B10]]
+    // CHECK-NEXT: br i1 %[[EQ10]], label %[[L11:.+]], label %[[EXIT_S]]
+
+    // CHECK: [[L11]]:
+    // CHECK: %[[PA11:.+]] = getelementptr{{.+}}i8, ptr %a, {{i32|i64}} 6
+    // CHECK: %[[PB11:.+]] = getelementptr{{.+}}i8, ptr %b, {{i32|i64}} 6
+    // CHECK: %[[A11:.+]] = load i16, ptr %[[PA11]]
+    // 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: [[DONE]]:
+    // CHECK: %[[RET:.+]] = phi i1 [ %{{.+}}, %[[EXIT_S]] ], [ %{{.+}}, %[[EXIT_U]] ], [ true, %[[L11]] ]
+    // CHECK: ret i1 %[[RET]]
+
+    a <= b
+}
diff --git a/tests/codegen-llvm/array-codegen.rs b/tests/codegen-llvm/array-codegen.rs
new file mode 100644
index 00000000000..9b0c6e8c347
--- /dev/null
+++ b/tests/codegen-llvm/array-codegen.rs
@@ -0,0 +1,62 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @array_load
+#[no_mangle]
+pub fn array_load(a: &[u8; 4]) -> [u8; 4] {
+    // CHECK-NOT: alloca
+    // CHECK: %[[ALLOCA:.+]] = alloca [4 x i8], align 1
+    // CHECK-NOT: alloca
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %[[ALLOCA]], ptr align 1 %a, {{.+}} 4, i1 false)
+    // CHECK: %[[TEMP:.+]] = load i32, ptr %[[ALLOCA]], align 1
+    // CHECK: ret i32 %[[TEMP]]
+    *a
+}
+
+// CHECK-LABEL: @array_store
+#[no_mangle]
+pub fn array_store(a: [u8; 4], p: &mut [u8; 4]) {
+    // CHECK-NOT: alloca
+    // CHECK: %[[TEMP:.+]] = alloca [4 x i8], [[TEMPALIGN:align [0-9]+]]
+    // CHECK-NOT: alloca
+    // CHECK: %a = alloca [4 x i8]
+    // CHECK-NOT: alloca
+    // store i32 %0, ptr %[[TEMP]]
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %a, ptr [[TEMPALIGN]] %[[TEMP]], {{.+}} 4, i1 false)
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %p, ptr align 1 %a, {{.+}} 4, i1 false)
+    *p = a;
+}
+
+// CHECK-LABEL: @array_copy
+#[no_mangle]
+pub fn array_copy(a: &[u8; 4], p: &mut [u8; 4]) {
+    // CHECK-NOT: alloca
+    // CHECK: %[[LOCAL:.+]] = alloca [4 x i8], align 1
+    // CHECK-NOT: alloca
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %[[LOCAL]], ptr align 1 %a, {{.+}} 4, i1 false)
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %p, ptr align 1 %[[LOCAL]], {{.+}} 4, i1 false)
+    *p = *a;
+}
+
+// CHECK-LABEL: @array_copy_1_element
+#[no_mangle]
+pub fn array_copy_1_element(a: &[u8; 1], p: &mut [u8; 1]) {
+    // CHECK-NOT: alloca
+    // CHECK: %[[LOCAL:.+]] = alloca [1 x i8], align 1
+    // CHECK-NOT: alloca
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %[[LOCAL]], ptr align 1 %a, {{.+}} 1, i1 false)
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %p, ptr align 1 %[[LOCAL]], {{.+}} 1, i1 false)
+    *p = *a;
+}
+
+// CHECK-LABEL: @array_copy_2_elements
+#[no_mangle]
+pub fn array_copy_2_elements(a: &[u8; 2], p: &mut [u8; 2]) {
+    // CHECK-NOT: alloca
+    // CHECK: %[[LOCAL:.+]] = alloca [2 x i8], align 1
+    // CHECK-NOT: alloca
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %[[LOCAL]], ptr align 1 %a, {{.+}} 2, i1 false)
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %p, ptr align 1 %[[LOCAL]], {{.+}} 2, i1 false)
+    *p = *a;
+}
diff --git a/tests/codegen-llvm/array-equality.rs b/tests/codegen-llvm/array-equality.rs
new file mode 100644
index 00000000000..fa0475bf480
--- /dev/null
+++ b/tests/codegen-llvm/array-equality.rs
@@ -0,0 +1,101 @@
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+//@ only-x86_64
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @array_eq_value
+#[no_mangle]
+pub fn array_eq_value(a: [u16; 3], b: [u16; 3]) -> bool {
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %2 = icmp eq i48 %0, %1
+    // CHECK-NEXT: ret i1 %2
+    a == b
+}
+
+// CHECK-LABEL: @array_eq_ref
+#[no_mangle]
+pub fn array_eq_ref(a: &[u16; 3], b: &[u16; 3]) -> bool {
+    // CHECK: start:
+    // CHECK: load i48, ptr %{{.+}}, align 2
+    // CHECK: load i48, ptr %{{.+}}, align 2
+    // CHECK: icmp eq i48
+    // CHECK-NEXT: ret
+    a == b
+}
+
+// CHECK-LABEL: @array_eq_value_still_passed_by_pointer
+#[no_mangle]
+pub fn array_eq_value_still_passed_by_pointer(a: [u16; 9], b: [u16; 9]) -> bool {
+    // CHECK-NEXT: start:
+    // CHECK: %[[CMP:.+]] = tail call i32 @{{bcmp|memcmp}}(ptr {{.*}} dereferenceable(18) %{{.+}}, ptr {{.*}} dereferenceable(18) %{{.+}}, i64 18)
+    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[CMP]], 0
+    // CHECK-NEXT: ret i1 %[[EQ]]
+    a == b
+}
+
+// CHECK-LABEL: @array_eq_long
+#[no_mangle]
+pub fn array_eq_long(a: &[u16; 1234], b: &[u16; 1234]) -> bool {
+    // CHECK-NEXT: start:
+    // CHECK: %[[CMP:.+]] = tail call i32 @{{bcmp|memcmp}}(ptr {{.*}} dereferenceable(2468) %{{.+}}, ptr {{.*}} dereferenceable(2468) %{{.+}}, i64 2468)
+    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[CMP]], 0
+    // CHECK-NEXT: ret i1 %[[EQ]]
+    a == b
+}
+
+// CHECK-LABEL: @array_char_eq
+#[no_mangle]
+pub fn array_char_eq(a: [char; 2], b: [char; 2]) -> bool {
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i64 %0, %1
+    // CHECK-NEXT: ret i1 %[[EQ]]
+    a == b
+}
+
+// CHECK-LABEL: @array_eq_zero_short(i48
+#[no_mangle]
+pub fn array_eq_zero_short(x: [u16; 3]) -> bool {
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i48 %0, 0
+    // CHECK-NEXT: ret i1 %[[EQ]]
+    x == [0; 3]
+}
+
+// CHECK-LABEL: @array_eq_none_short(i40
+#[no_mangle]
+pub fn array_eq_none_short(x: [Option<std::num::NonZero<u8>>; 5]) -> bool {
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i40 %0, 0
+    // CHECK-NEXT: ret i1 %[[EQ]]
+    x == [None; 5]
+}
+
+// CHECK-LABEL: @array_eq_zero_nested(
+#[no_mangle]
+pub fn array_eq_zero_nested(x: [[u8; 3]; 3]) -> bool {
+    // CHECK: %[[VAL:.+]] = load i72
+    // CHECK-SAME: align 1
+    // CHECK: %[[EQ:.+]] = icmp eq i72 %[[VAL]], 0
+    // CHECK: ret i1 %[[EQ]]
+    x == [[0; 3]; 3]
+}
+
+// CHECK-LABEL: @array_eq_zero_mid(
+#[no_mangle]
+pub fn array_eq_zero_mid(x: [u16; 8]) -> bool {
+    // CHECK-NEXT: start:
+    // CHECK: %[[LOAD:.+]] = load i128,
+    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i128 %[[LOAD]], 0
+    // CHECK-NEXT: ret i1 %[[EQ]]
+    x == [0; 8]
+}
+
+// CHECK-LABEL: @array_eq_zero_long(
+#[no_mangle]
+pub fn array_eq_zero_long(x: [u16; 1234]) -> bool {
+    // CHECK-NEXT: start:
+    // CHECK-NOT: alloca
+    // CHECK: %[[CMP:.+]] = tail call i32 @{{bcmp|memcmp}}(
+    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[CMP]], 0
+    // CHECK-NEXT: ret i1 %[[EQ]]
+    x == [0; 1234]
+}
diff --git a/tests/codegen-llvm/array-from_fn.rs b/tests/codegen-llvm/array-from_fn.rs
new file mode 100644
index 00000000000..7202d0c67e6
--- /dev/null
+++ b/tests/codegen-llvm/array-from_fn.rs
@@ -0,0 +1,13 @@
+//@ revisions: NORMAL OPT
+//@ [NORMAL] compile-flags: -C opt-level=0 -C debuginfo=2
+//@ [OPT] compile-flags: -C opt-level=s -C debuginfo=0
+
+#![crate_type = "lib"]
+#![feature(array_from_fn)]
+
+#[no_mangle]
+pub fn iota() -> [u8; 16] {
+    // OPT-NOT: core..array..Guard
+    // NORMAL: core..array..Guard
+    std::array::from_fn(|i| i as _)
+}
diff --git a/tests/codegen-llvm/array-map.rs b/tests/codegen-llvm/array-map.rs
new file mode 100644
index 00000000000..f49dddcfc20
--- /dev/null
+++ b/tests/codegen-llvm/array-map.rs
@@ -0,0 +1,35 @@
+//@ compile-flags: -C opt-level=3 -C target-cpu=x86-64-v3
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @short_integer_map
+#[no_mangle]
+pub fn short_integer_map(x: [u32; 8]) -> [u32; 8] {
+    // CHECK: load <8 x i32>
+    // CHECK: shl <8 x i32>
+    // CHECK: or{{( disjoint)?}} <8 x i32>
+    // CHECK: store <8 x i32>
+    x.map(|x| 2 * x + 1)
+}
+
+// This test is checking that LLVM can SRoA away a bunch of the overhead,
+// like fully moving the iterators to registers.  Notably, previous implementations
+// of `map` ended up `alloca`ing the whole `array::IntoIterator`, meaning both a
+// hard-to-eliminate `memcpy` and that the iteration counts needed to be written
+// out to stack every iteration, even for infallible operations on `Copy` types.
+//
+// This is still imperfect, as there's more copies than would be ideal,
+// but hopefully work like #103830 will improve that in future,
+// and update this test to be stricter.
+//
+// CHECK-LABEL: @long_integer_map
+#[no_mangle]
+pub fn long_integer_map(x: [u32; 512]) -> [u32; 512] {
+    // CHECK: start:
+    // CHECK-NEXT: alloca [2048 x i8]
+    // CHECK-NOT: alloca
+    // CHECK: mul <{{[0-9]+}} x i32>
+    // CHECK: add <{{[0-9]+}} x i32>
+    x.map(|x| 13 * x + 7)
+}
diff --git a/tests/codegen-llvm/array-optimized.rs b/tests/codegen-llvm/array-optimized.rs
new file mode 100644
index 00000000000..000163d5519
--- /dev/null
+++ b/tests/codegen-llvm/array-optimized.rs
@@ -0,0 +1,33 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @array_copy_1_element
+#[no_mangle]
+pub fn array_copy_1_element(a: &[u8; 1], p: &mut [u8; 1]) {
+    // CHECK-NOT: alloca
+    // CHECK: %[[TEMP:.+]] = load i8, ptr %a, align 1
+    // CHECK: store i8 %[[TEMP]], ptr %p, align 1
+    // CHECK: ret
+    *p = *a;
+}
+
+// CHECK-LABEL: @array_copy_2_elements
+#[no_mangle]
+pub fn array_copy_2_elements(a: &[u8; 2], p: &mut [u8; 2]) {
+    // CHECK-NOT: alloca
+    // CHECK: %[[TEMP:.+]] = load i16, ptr %a, align 1
+    // CHECK: store i16 %[[TEMP]], ptr %p, align 1
+    // CHECK: ret
+    *p = *a;
+}
+
+// CHECK-LABEL: @array_copy_4_elements
+#[no_mangle]
+pub fn array_copy_4_elements(a: &[u8; 4], p: &mut [u8; 4]) {
+    // CHECK-NOT: alloca
+    // CHECK: %[[TEMP:.+]] = load i32, ptr %a, align 1
+    // CHECK: store i32 %[[TEMP]], ptr %p, align 1
+    // CHECK: ret
+    *p = *a;
+}
diff --git a/tests/codegen-llvm/array-repeat.rs b/tests/codegen-llvm/array-repeat.rs
new file mode 100644
index 00000000000..4c755df9390
--- /dev/null
+++ b/tests/codegen-llvm/array-repeat.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+#![feature(array_repeat)]
+
+use std::array::repeat;
+
+// CHECK-LABEL: @byte_repeat
+#[no_mangle]
+fn byte_repeat(b: u8) -> [u8; 1024] {
+    // CHECK-NOT: alloca
+    // CHECK-NOT: store
+    // CHECK: memset
+    repeat(b)
+}
diff --git a/tests/codegen-llvm/ascii-char.rs b/tests/codegen-llvm/ascii-char.rs
new file mode 100644
index 00000000000..86ec9d73afe
--- /dev/null
+++ b/tests/codegen-llvm/ascii-char.rs
@@ -0,0 +1,36 @@
+//@ compile-flags: -C opt-level=1
+
+#![crate_type = "lib"]
+#![feature(ascii_char)]
+
+use std::ascii::Char as AsciiChar;
+
+// CHECK-LABEL: i8 @unwrap_digit_from_remainder(i32
+#[no_mangle]
+pub fn unwrap_digit_from_remainder(v: u32) -> AsciiChar {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: panic
+
+    // CHECK: %[[R:.+]] = urem i32 %v, 10
+    // CHECK-NEXT: %[[T:.+]] = trunc{{( nuw)?( nsw)?}} i32 %[[R]] to i8
+    // CHECK-NEXT: %[[D:.+]] = or{{( disjoint)?}} i8 %[[T]], 48
+    // CHECK-NEXT: ret i8 %[[D]]
+
+    // CHECK-NOT: icmp
+    // CHECK-NOT: panic
+    AsciiChar::digit((v % 10) as u8).unwrap()
+}
+
+// CHECK-LABEL: i8 @unwrap_from_masked(i8
+#[no_mangle]
+pub fn unwrap_from_masked(b: u8) -> AsciiChar {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: panic
+
+    // CHECK: %[[M:.+]] = and i8 %b, 127
+    // CHECK-NEXT: ret i8 %[[M]]
+
+    // CHECK-NOT: icmp
+    // CHECK-NOT: panic
+    AsciiChar::from_u8(b & 0x7f).unwrap()
+}
diff --git a/tests/codegen-llvm/asm/aarch64-clobbers.rs b/tests/codegen-llvm/asm/aarch64-clobbers.rs
new file mode 100644
index 00000000000..dd3ba1510b5
--- /dev/null
+++ b/tests/codegen-llvm/asm/aarch64-clobbers.rs
@@ -0,0 +1,47 @@
+//@ add-core-stubs
+//@ revisions: aarch64 aarch64_fixed_x18 aarch64_no_x18 aarch64_reserve_x18 arm64ec
+//@[aarch64] compile-flags: --target aarch64-unknown-linux-gnu
+//@[aarch64] needs-llvm-components: aarch64
+//@[aarch64_fixed_x18] compile-flags: --target aarch64-unknown-linux-gnu -Zfixed-x18
+//@[aarch64_fixed_x18] needs-llvm-components: aarch64
+//@[aarch64_no_x18] compile-flags: --target aarch64-pc-windows-msvc
+//@[aarch64_no_x18] needs-llvm-components: aarch64
+// aarch64-unknown-trusty uses aarch64-unknown-unknown-musl which doesn't
+// reserve x18 by default as llvm_target, and pass +reserve-x18 in target-spec.
+//@[aarch64_reserve_x18] compile-flags: --target aarch64-unknown-trusty
+//@[aarch64_reserve_x18] needs-llvm-components: aarch64
+//@[arm64ec] compile-flags: --target arm64ec-pc-windows-msvc
+//@[arm64ec] needs-llvm-components: aarch64
+// ignore-tidy-linelength
+
+#![crate_type = "rlib"]
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: @cc_clobber
+// CHECK: call void asm sideeffect "", "~{cc}"()
+#[no_mangle]
+pub unsafe fn cc_clobber() {
+    asm!("", options(nostack, nomem));
+}
+
+// CHECK-LABEL: @no_clobber
+// CHECK: call void asm sideeffect "", ""()
+#[no_mangle]
+pub unsafe fn no_clobber() {
+    asm!("", options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @clobber_abi
+// aarch64: asm sideeffect "", "={w0},={w1},={w2},={w3},={w4},={w5},={w6},={w7},={w8},={w9},={w10},={w11},={w12},={w13},={w14},={w15},={w16},={w17},={w18},={w30},={q0},={q1},={q2},={q3},={q4},={q5},={q6},={q7},={q8},={q9},={q10},={q11},={q12},={q13},={q14},={q15},={q16},={q17},={q18},={q19},={q20},={q21},={q22},={q23},={q24},={q25},={q26},={q27},={q28},={q29},={q30},={q31},~{p0},~{p1},~{p2},~{p3},~{p4},~{p5},~{p6},~{p7},~{p8},~{p9},~{p10},~{p11},~{p12},~{p13},~{p14},~{p15},~{ffr}"()
+// aarch64_fixed_x18: asm sideeffect "", "={w0},={w1},={w2},={w3},={w4},={w5},={w6},={w7},={w8},={w9},={w10},={w11},={w12},={w13},={w14},={w15},={w16},={w17},={w30},={q0},={q1},={q2},={q3},={q4},={q5},={q6},={q7},={q8},={q9},={q10},={q11},={q12},={q13},={q14},={q15},={q16},={q17},={q18},={q19},={q20},={q21},={q22},={q23},={q24},={q25},={q26},={q27},={q28},={q29},={q30},={q31},~{p0},~{p1},~{p2},~{p3},~{p4},~{p5},~{p6},~{p7},~{p8},~{p9},~{p10},~{p11},~{p12},~{p13},~{p14},~{p15},~{ffr}"()
+// aarch64_no_x18: asm sideeffect "", "={w0},={w1},={w2},={w3},={w4},={w5},={w6},={w7},={w8},={w9},={w10},={w11},={w12},={w13},={w14},={w15},={w16},={w17},={w30},={q0},={q1},={q2},={q3},={q4},={q5},={q6},={q7},={q8},={q9},={q10},={q11},={q12},={q13},={q14},={q15},={q16},={q17},={q18},={q19},={q20},={q21},={q22},={q23},={q24},={q25},={q26},={q27},={q28},={q29},={q30},={q31},~{p0},~{p1},~{p2},~{p3},~{p4},~{p5},~{p6},~{p7},~{p8},~{p9},~{p10},~{p11},~{p12},~{p13},~{p14},~{p15},~{ffr}"()
+// aarch64_reserve_x18: asm sideeffect "", "={w0},={w1},={w2},={w3},={w4},={w5},={w6},={w7},={w8},={w9},={w10},={w11},={w12},={w13},={w14},={w15},={w16},={w17},={w30},={q0},={q1},={q2},={q3},={q4},={q5},={q6},={q7},={q8},={q9},={q10},={q11},={q12},={q13},={q14},={q15},={q16},={q17},={q18},={q19},={q20},={q21},={q22},={q23},={q24},={q25},={q26},={q27},={q28},={q29},={q30},={q31},~{p0},~{p1},~{p2},~{p3},~{p4},~{p5},~{p6},~{p7},~{p8},~{p9},~{p10},~{p11},~{p12},~{p13},~{p14},~{p15},~{ffr}"()
+// arm64ec: asm sideeffect "", "={w0},={w1},={w2},={w3},={w4},={w5},={w6},={w7},={w8},={w9},={w10},={w11},={w12},={w15},={w16},={w17},={w30},={q0},={q1},={q2},={q3},={q4},={q5},={q6},={q7},={q8},={q9},={q10},={q11},={q12},={q13},={q14},={q15}"()
+#[no_mangle]
+pub unsafe fn clobber_abi() {
+    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
+}
diff --git a/tests/codegen-llvm/asm/avr-clobbers.rs b/tests/codegen-llvm/asm/avr-clobbers.rs
new file mode 100644
index 00000000000..9451127bf04
--- /dev/null
+++ b/tests/codegen-llvm/asm/avr-clobbers.rs
@@ -0,0 +1,39 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target avr-none -C target-cpu=atmega328p
+//@ needs-llvm-components: avr
+
+#![crate_type = "rlib"]
+#![feature(no_core, asm_experimental_arch)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: @sreg_is_clobbered
+// CHECK: void asm sideeffect "", "~{sreg}"()
+#[no_mangle]
+pub unsafe fn sreg_is_clobbered() {
+    asm!("", options(nostack, nomem));
+}
+
+// CHECK-LABEL: @sreg_is_not_clobbered_if_preserve_flags_is_used
+// CHECK: void asm sideeffect "", ""()
+#[no_mangle]
+pub unsafe fn sreg_is_not_clobbered_if_preserve_flags_is_used() {
+    asm!("", options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @clobber_abi
+// CHECK: asm sideeffect "", "={r18},={r19},={r20},={r21},={r22},={r23},={r24},={r25},={r26},={r27},={r30},={r31},~{sreg}"()
+#[no_mangle]
+pub unsafe fn clobber_abi() {
+    asm!("", clobber_abi("C"), options(nostack, nomem));
+}
+
+// CHECK-LABEL: @clobber_abi_with_preserved_flags
+// CHECK: asm sideeffect "", "={r18},={r19},={r20},={r21},={r22},={r23},={r24},={r25},={r26},={r27},={r30},={r31}"()
+#[no_mangle]
+pub unsafe fn clobber_abi_with_preserved_flags() {
+    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
+}
diff --git a/tests/codegen-llvm/asm/bpf-clobbers.rs b/tests/codegen-llvm/asm/bpf-clobbers.rs
new file mode 100644
index 00000000000..1117549b1ec
--- /dev/null
+++ b/tests/codegen-llvm/asm/bpf-clobbers.rs
@@ -0,0 +1,31 @@
+//@ add-core-stubs
+//@ compile-flags: --target bpfel-unknown-none
+//@ needs-llvm-components: bpf
+
+#![crate_type = "rlib"]
+#![feature(no_core, asm_experimental_arch)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: @flags_clobber
+// CHECK: call void asm sideeffect "", ""()
+#[no_mangle]
+pub unsafe fn flags_clobber() {
+    asm!("", options(nostack, nomem));
+}
+
+// CHECK-LABEL: @no_clobber
+// CHECK: call void asm sideeffect "", ""()
+#[no_mangle]
+pub unsafe fn no_clobber() {
+    asm!("", options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @clobber_abi
+// CHECK: asm sideeffect "", "={r0},={r1},={r2},={r3},={r4},={r5}"()
+#[no_mangle]
+pub unsafe fn clobber_abi() {
+    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
+}
diff --git a/tests/codegen-llvm/asm/critical.rs b/tests/codegen-llvm/asm/critical.rs
new file mode 100644
index 00000000000..0f29d7c69b4
--- /dev/null
+++ b/tests/codegen-llvm/asm/critical.rs
@@ -0,0 +1,36 @@
+//@ only-x86_64
+//@ compile-flags: -C no-prepopulate-passes
+#![feature(asm_goto_with_outputs)]
+#![crate_type = "lib"]
+use std::arch::asm;
+
+// Regression test for #137867. Check that critical edges have been split before code generation,
+// and so all stores to the asm output occur on disjoint paths without any of them jumping to
+// another callbr label.
+//
+// CHECK-LABEL: @f(
+// CHECK:        [[OUT:%.*]] = callbr i32 asm
+// CHECK-NEXT:   to label %[[BB0:.*]] [label %[[BB1:.*]], label %[[BB2:.*]]],
+// CHECK:       [[BB1]]:
+// CHECK-NEXT:    store i32 [[OUT]], ptr %a
+// CHECK-NEXT:    br label %[[BBR:.*]]
+// CHECK:       [[BB2]]:
+// CHECK-NEXT:    store i32 [[OUT]], ptr %a
+// CHECK-NEXT:    br label %[[BBR]]
+// CHECK:       [[BB0]]:
+// CHECK-NEXT:    store i32 [[OUT]], ptr %a
+// CHECK-NEXT:    br label %[[BBR]]
+// CHECK:       [[BBR]]:
+// CHECK-NEXT:    [[RET:%.*]] = load i32, ptr %a
+// CHECK-NEXT:    ret i32 [[RET]]
+#[unsafe(no_mangle)]
+pub unsafe fn f(mut a: u32) -> u32 {
+    asm!(
+        "jmp {}
+         jmp {}",
+        label {},
+        label {},
+        inout("eax") a,
+    );
+    a
+}
diff --git a/tests/codegen-llvm/asm/csky-clobbers.rs b/tests/codegen-llvm/asm/csky-clobbers.rs
new file mode 100644
index 00000000000..4986d0fe56d
--- /dev/null
+++ b/tests/codegen-llvm/asm/csky-clobbers.rs
@@ -0,0 +1,24 @@
+//@ add-core-stubs
+//@ compile-flags: --target csky-unknown-linux-gnuabiv2
+//@ needs-llvm-components: csky
+
+#![crate_type = "rlib"]
+#![feature(no_core, asm_experimental_arch)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: @flags_clobber
+// CHECK: call void asm sideeffect "", "~{psr}"()
+#[no_mangle]
+pub unsafe fn flags_clobber() {
+    asm!("", options(nostack, nomem));
+}
+
+// CHECK-LABEL: @no_clobber
+// CHECK: call void asm sideeffect "", ""()
+#[no_mangle]
+pub unsafe fn no_clobber() {
+    asm!("", options(nostack, nomem, preserves_flags));
+}
diff --git a/tests/codegen-llvm/asm/foo.s b/tests/codegen-llvm/asm/foo.s
new file mode 100644
index 00000000000..304d82aa0c6
--- /dev/null
+++ b/tests/codegen-llvm/asm/foo.s
@@ -0,0 +1,3 @@
+.global foo
+foo:
+    jmp baz
diff --git a/tests/codegen-llvm/asm/global_asm.rs b/tests/codegen-llvm/asm/global_asm.rs
new file mode 100644
index 00000000000..32075daa3cf
--- /dev/null
+++ b/tests/codegen-llvm/asm/global_asm.rs
@@ -0,0 +1,28 @@
+//@ revisions: x32 x64
+//@[x32] only-x86
+//@[x64] only-x86_64
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+use std::arch::global_asm;
+
+// CHECK-LABEL: foo
+// CHECK: module asm
+// this regex will capture the correct unconditional branch inst.
+// CHECK: module asm "{{[[:space:]]+}}jmp baz"
+global_asm!(
+    r#"
+    .global foo
+foo:
+    jmp baz
+"#
+);
+
+extern "C" {
+    fn foo();
+}
+
+// CHECK-LABEL: @baz
+#[no_mangle]
+pub unsafe extern "C" fn baz() {}
diff --git a/tests/codegen-llvm/asm/global_asm_include.rs b/tests/codegen-llvm/asm/global_asm_include.rs
new file mode 100644
index 00000000000..98be9c3e333
--- /dev/null
+++ b/tests/codegen-llvm/asm/global_asm_include.rs
@@ -0,0 +1,21 @@
+//@ revisions: x32 x64
+//@[x32] only-x86
+//@[x64] only-x86_64
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+use std::arch::global_asm;
+
+// CHECK-LABEL: foo
+// CHECK: module asm
+// CHECK: module asm "{{[[:space:]]+}}jmp baz"
+global_asm!(include_str!("foo.s"));
+
+extern "C" {
+    fn foo();
+}
+
+// CHECK-LABEL: @baz
+#[no_mangle]
+pub unsafe extern "C" fn baz() {}
diff --git a/tests/codegen-llvm/asm/global_asm_x2.rs b/tests/codegen-llvm/asm/global_asm_x2.rs
new file mode 100644
index 00000000000..9e3a00f0680
--- /dev/null
+++ b/tests/codegen-llvm/asm/global_asm_x2.rs
@@ -0,0 +1,47 @@
+//@ revisions: x32 x64
+//@[x32] only-x86
+//@[x64] only-x86_64
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![no_std]
+
+use core::arch::global_asm;
+
+// CHECK-LABEL: foo
+// CHECK: module asm
+// CHECK: module asm "{{[[:space:]]+}}jmp baz"
+// any other global_asm will be appended to this first block, so:
+// CHECK-LABEL: bar
+// CHECK: module asm "{{[[:space:]]+}}jmp quux"
+global_asm!(
+    r#"
+    .global foo
+foo:
+    jmp baz
+"#
+);
+
+extern "C" {
+    fn foo();
+}
+
+// CHECK-LABEL: @baz
+#[no_mangle]
+pub unsafe extern "C" fn baz() {}
+
+// no checks here; this has been appended to the first occurrence
+global_asm!(
+    r#"
+    .global bar
+bar:
+    jmp quux
+"#
+);
+
+extern "C" {
+    fn bar();
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn quux() {}
diff --git a/tests/codegen-llvm/asm/goto.rs b/tests/codegen-llvm/asm/goto.rs
new file mode 100644
index 00000000000..f68c399c920
--- /dev/null
+++ b/tests/codegen-llvm/asm/goto.rs
@@ -0,0 +1,63 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "rlib"]
+#![feature(asm_goto_with_outputs)]
+
+use std::arch::asm;
+
+// CHECK-LABEL: @asm_goto
+#[no_mangle]
+pub unsafe fn asm_goto() {
+    // CHECK: callbr void asm sideeffect alignstack inteldialect "
+    // CHECK-NEXT: to label %[[FALLTHROUGHBB:[a-b0-9]+]] [label %[[JUMPBB:[a-b0-9]+]]]
+    asm!("jmp {}", label {});
+}
+
+// CHECK-LABEL: @asm_goto_with_outputs
+#[no_mangle]
+pub unsafe fn asm_goto_with_outputs() -> u64 {
+    let out: u64;
+    // CHECK: [[RES:%[0-9]+]] = callbr i64 asm sideeffect alignstack inteldialect "
+    // CHECK-NEXT: to label %[[FALLTHROUGHBB:[a-b0-9]+]] [label %[[JUMPBB:[a-b0-9]+]]]
+    asm!("{} /* {} */", out(reg) out, label { return 1; });
+    // CHECK: [[JUMPBB]]:
+    // CHECK-NEXT: [[RET:%.+]] = phi i64 [ [[RES]], %[[FALLTHROUGHBB]] ], [ 1, %start ]
+    // CHECK-NEXT: ret i64 [[RET]]
+    out
+}
+
+// CHECK-LABEL: @asm_goto_with_outputs_use_in_label
+#[no_mangle]
+pub unsafe fn asm_goto_with_outputs_use_in_label() -> u64 {
+    let out: u64;
+    // CHECK: [[RES:%[0-9]+]] = callbr i64 asm sideeffect alignstack inteldialect "
+    // CHECK-NEXT: to label %[[FALLTHROUGHBB:[a-b0-9]+]] [label %[[JUMPBB:[a-b0-9]+]]]
+    asm!("{} /* {} */", out(reg) out, label { return out; });
+    // CHECK: [[JUMPBB]]:
+    // CHECK-NEXT: [[RET:%.+]] = phi i64 [ 1, %[[FALLTHROUGHBB]] ], [ [[RES]], %start ]
+    // CHECK-NEXT: ret i64 [[RET]]
+    1
+}
+
+// CHECK-LABEL: @asm_goto_noreturn
+#[no_mangle]
+pub unsafe fn asm_goto_noreturn() -> u64 {
+    // CHECK: callbr void asm sideeffect alignstack inteldialect "
+    // CHECK-NEXT: to label %unreachable [label %[[JUMPBB:[a-b0-9]+]]]
+    asm!("jmp {}", label { return 1; }, options(noreturn));
+    // CHECK: [[JUMPBB]]:
+    // CHECK-NEXT: ret i64 1
+}
+
+// CHECK-LABEL: @asm_goto_noreturn_with_outputs
+#[no_mangle]
+pub unsafe fn asm_goto_noreturn_with_outputs() -> u64 {
+    let out: u64;
+    // CHECK: [[RES:%[0-9]+]] = callbr i64 asm sideeffect alignstack inteldialect "
+    // CHECK-NEXT: to label %[[FALLTHROUGHBB:[a-b0-9]+]] [label %[[JUMPBB:[a-b0-9]+]]]
+    asm!("mov {}, 1", "jmp {}", out(reg) out, label { return out; });
+    // CHECK: [[JUMPBB]]:
+    // CHECK-NEXT: ret i64 [[RES]]
+    out
+}
diff --git a/tests/codegen-llvm/asm/hexagon-clobbers.rs b/tests/codegen-llvm/asm/hexagon-clobbers.rs
new file mode 100644
index 00000000000..800b8964669
--- /dev/null
+++ b/tests/codegen-llvm/asm/hexagon-clobbers.rs
@@ -0,0 +1,33 @@
+//@ add-core-stubs
+//@ revisions: hexagon
+//@[hexagon] compile-flags: --target hexagon-unknown-linux-musl
+//@[hexagon] needs-llvm-components: hexagon
+//@ compile-flags: -Zmerge-functions=disabled
+
+#![crate_type = "rlib"]
+#![feature(no_core, asm_experimental_arch)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: @flags_clobber
+// CHECK: call void asm sideeffect "", ""()
+#[no_mangle]
+pub unsafe fn flags_clobber() {
+    asm!("", options(nostack, nomem));
+}
+
+// CHECK-LABEL: @no_clobber
+// CHECK: call void asm sideeffect "", ""()
+#[no_mangle]
+pub unsafe fn no_clobber() {
+    asm!("", options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @p0_clobber
+// CHECK: call void asm sideeffect "", "~{p0}"()
+#[no_mangle]
+pub unsafe fn p0_clobber() {
+    asm!("", out("p0") _, options(nostack, nomem, preserves_flags));
+}
diff --git a/tests/codegen-llvm/asm/may_unwind.rs b/tests/codegen-llvm/asm/may_unwind.rs
new file mode 100644
index 00000000000..63cdec7584c
--- /dev/null
+++ b/tests/codegen-llvm/asm/may_unwind.rs
@@ -0,0 +1,39 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "rlib"]
+#![feature(asm_unwind)]
+
+use std::arch::asm;
+
+#[no_mangle]
+pub extern "C" fn panicky() {}
+
+struct Foo;
+
+impl Drop for Foo {
+    fn drop(&mut self) {
+        println!();
+    }
+}
+
+// CHECK-LABEL: @asm_may_unwind
+#[no_mangle]
+pub unsafe fn asm_may_unwind() {
+    let _m = Foo;
+    // CHECK: invoke void asm sideeffect alignstack inteldialect unwind ""
+    asm!("", options(may_unwind));
+}
+
+// CHECK-LABEL: @asm_with_result_may_unwind
+#[no_mangle]
+pub unsafe fn asm_with_result_may_unwind() -> u64 {
+    let _m = Foo;
+    let res: u64;
+    // CHECK: [[RES:%[0-9]+]] = invoke i64 asm sideeffect alignstack inteldialect unwind
+    // CHECK-NEXT: to label %[[NORMALBB:[a-b0-9]+]]
+    asm!("mov {}, 1", out(reg) res, options(may_unwind));
+    // CHECK: [[NORMALBB]]:
+    // CHECK: ret i64 [[RES:%[0-9]+]]
+    res
+}
diff --git a/tests/codegen-llvm/asm/maybe-uninit.rs b/tests/codegen-llvm/asm/maybe-uninit.rs
new file mode 100644
index 00000000000..d76d5cb1312
--- /dev/null
+++ b/tests/codegen-llvm/asm/maybe-uninit.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "rlib"]
+#![allow(asm_sub_register)]
+
+use std::arch::asm;
+use std::mem::MaybeUninit;
+
+// CHECK-LABEL: @int
+#[no_mangle]
+pub unsafe fn int(x: MaybeUninit<i32>) -> MaybeUninit<i32> {
+    let y: MaybeUninit<i32>;
+    asm!("/*{}{}*/", in(reg) x, out(reg) y);
+    y
+}
+
+// CHECK-LABEL: @inout
+#[no_mangle]
+pub unsafe fn inout(mut x: i32) -> MaybeUninit<u32> {
+    let mut y: MaybeUninit<u32>;
+    asm!("/*{}*/", inout(reg) x => y);
+    asm!("/*{}*/", inout(reg) y => x);
+    asm!("/*{}*/", inlateout(reg) x => y);
+    asm!("/*{}*/", inlateout(reg) y => x);
+    y
+}
diff --git a/tests/codegen-llvm/asm/msp430-clobbers.rs b/tests/codegen-llvm/asm/msp430-clobbers.rs
new file mode 100644
index 00000000000..2c8d29cffc4
--- /dev/null
+++ b/tests/codegen-llvm/asm/msp430-clobbers.rs
@@ -0,0 +1,32 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ compile-flags: --target msp430-none-elf
+//@ needs-llvm-components: msp430
+
+#![crate_type = "rlib"]
+#![feature(no_core, asm_experimental_arch)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: @sr_clobber
+// CHECK: call void asm sideeffect "", "~{sr}"()
+#[no_mangle]
+pub unsafe fn sr_clobber() {
+    asm!("", options(nostack, nomem));
+}
+
+// CHECK-LABEL: @no_clobber
+// CHECK: call void asm sideeffect "", ""()
+#[no_mangle]
+pub unsafe fn no_clobber() {
+    asm!("", options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @clobber_abi
+// CHECK: asm sideeffect "", "={r11},={r12},={r13},={r14},={r15}"()
+#[no_mangle]
+pub unsafe fn clobber_abi() {
+    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
+}
diff --git a/tests/codegen-llvm/asm/multiple-options.rs b/tests/codegen-llvm/asm/multiple-options.rs
new file mode 100644
index 00000000000..4d87471a193
--- /dev/null
+++ b/tests/codegen-llvm/asm/multiple-options.rs
@@ -0,0 +1,54 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "rlib"]
+
+use std::arch::asm;
+
+// CHECK-LABEL: @pure
+// CHECK-NOT: asm
+// CHECK: ret void
+#[no_mangle]
+pub unsafe fn pure(x: i32) {
+    let y: i32;
+    asm!("", out("ax") y, in("cx") x, options(pure), options(nomem));
+}
+
+pub static mut VAR: i32 = 0;
+pub static mut DUMMY_OUTPUT: i32 = 0;
+
+// CHECK-LABEL: @readonly
+// CHECK: call i32 asm
+// CHECK: ret i32 1
+#[no_mangle]
+pub unsafe fn readonly() -> i32 {
+    VAR = 1;
+    asm!("", out("ax") DUMMY_OUTPUT, options(pure), options(readonly));
+    VAR
+}
+
+// CHECK-LABEL: @nomem
+// CHECK-NOT: store
+// CHECK: call i32 asm
+// CHECK: store
+// CHECK: ret i32 2
+#[no_mangle]
+pub unsafe fn nomem() -> i32 {
+    VAR = 1;
+    asm!("", out("ax") DUMMY_OUTPUT, options(pure), options(nomem));
+    VAR = 2;
+    VAR
+}
+
+// CHECK-LABEL: @not_nomem
+// CHECK: store
+// CHECK: call i32 asm
+// CHECK: store
+// CHECK: ret i32 2
+#[no_mangle]
+pub unsafe fn not_nomem() -> i32 {
+    VAR = 1;
+    asm!("", out("ax") DUMMY_OUTPUT, options(pure), options(readonly));
+    VAR = 2;
+    VAR
+}
diff --git a/tests/codegen-llvm/asm/options.rs b/tests/codegen-llvm/asm/options.rs
new file mode 100644
index 00000000000..c087f91fd43
--- /dev/null
+++ b/tests/codegen-llvm/asm/options.rs
@@ -0,0 +1,104 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "rlib"]
+
+use std::arch::asm;
+
+// CHECK-LABEL: @pure
+// CHECK-NOT: asm
+// CHECK: ret void
+#[no_mangle]
+pub unsafe fn pure(x: i32) {
+    let y: i32;
+    asm!("", out("ax") y, in("cx") x, options(pure, nomem));
+}
+
+// CHECK-LABEL: @noreturn
+// CHECK: call void asm
+// CHECK-NEXT: unreachable
+#[no_mangle]
+pub unsafe fn noreturn() {
+    asm!("", options(noreturn));
+}
+
+pub static mut VAR: i32 = 0;
+pub static mut DUMMY_OUTPUT: i32 = 0;
+
+// CHECK-LABEL: @readonly
+// CHECK: call i32 asm
+// CHECK: ret i32 1
+#[no_mangle]
+pub unsafe fn readonly() -> i32 {
+    VAR = 1;
+    asm!("", out("ax") DUMMY_OUTPUT, options(pure, readonly));
+    VAR
+}
+
+// CHECK-LABEL: @not_readonly
+// CHECK: call i32 asm
+// CHECK: ret i32 %
+#[no_mangle]
+pub unsafe fn not_readonly() -> i32 {
+    VAR = 1;
+    asm!("", out("ax") DUMMY_OUTPUT, options());
+    VAR
+}
+
+// CHECK-LABEL: @nomem
+// CHECK-NOT: store
+// CHECK: call i32 asm
+// CHECK: store
+// CHECK: ret i32 2
+#[no_mangle]
+pub unsafe fn nomem() -> i32 {
+    VAR = 1;
+    asm!("", out("ax") DUMMY_OUTPUT, options(pure, nomem));
+    VAR = 2;
+    VAR
+}
+
+// CHECK-LABEL: @nomem_nopure
+// CHECK-NOT: store
+// CHECK: call i32 asm
+// CHECK: store
+// CHECK: ret i32 2
+#[no_mangle]
+pub unsafe fn nomem_nopure() -> i32 {
+    VAR = 1;
+    asm!("", out("ax") DUMMY_OUTPUT, options(nomem));
+    VAR = 2;
+    VAR
+}
+
+// CHECK-LABEL: @not_nomem
+// CHECK: store
+// CHECK: call i32 asm
+// CHECK: store
+// CHECK: ret i32 2
+#[no_mangle]
+pub unsafe fn not_nomem() -> i32 {
+    VAR = 1;
+    asm!("", out("ax") DUMMY_OUTPUT, options(pure, readonly));
+    VAR = 2;
+    VAR
+}
+
+// CHECK-LABEL: @dont_remove_nonpure
+// CHECK: call void asm
+// CHECK: call void asm
+// CHECK: call void asm
+// CHECK: ret void
+#[no_mangle]
+pub unsafe fn dont_remove_nonpure() {
+    asm!("", options());
+    asm!("", options(nomem));
+    asm!("", options(readonly));
+}
+
+// CHECK-LABEL: @raw
+// CHECK: call void asm sideeffect inteldialect "{} {}", ""()
+#[no_mangle]
+pub unsafe fn raw() {
+    asm!("{} {}", options(nostack, nomem, preserves_flags, raw));
+}
diff --git a/tests/codegen-llvm/asm/powerpc-clobbers.rs b/tests/codegen-llvm/asm/powerpc-clobbers.rs
new file mode 100644
index 00000000000..f7fc7eea5d5
--- /dev/null
+++ b/tests/codegen-llvm/asm/powerpc-clobbers.rs
@@ -0,0 +1,68 @@
+//@ add-core-stubs
+//@ revisions: powerpc powerpc64 powerpc64le aix64
+//@[powerpc] compile-flags: --target powerpc-unknown-linux-gnu
+//@[powerpc] needs-llvm-components: powerpc
+//@[powerpc64] compile-flags: --target powerpc64-unknown-linux-gnu
+//@[powerpc64] needs-llvm-components: powerpc
+//@[powerpc64le] compile-flags: --target powerpc64le-unknown-linux-gnu
+//@[powerpc64le] needs-llvm-components: powerpc
+//@[aix64] compile-flags: --target powerpc64-ibm-aix
+//@[aix64] needs-llvm-components: powerpc
+// ignore-tidy-linelength
+
+#![crate_type = "rlib"]
+#![feature(no_core, asm_experimental_arch)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: @cr_clobber
+// CHECK: call void asm sideeffect "", "~{cr}"()
+#[no_mangle]
+pub unsafe fn cr_clobber() {
+    asm!("", out("cr") _, options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @cr0_clobber
+// CHECK: call void asm sideeffect "", "~{cr0}"()
+#[no_mangle]
+pub unsafe fn cr0_clobber() {
+    asm!("", out("cr0") _, options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @cr5_clobber
+// CHECK: call void asm sideeffect "", "~{cr5}"()
+#[no_mangle]
+pub unsafe fn cr5_clobber() {
+    asm!("", out("cr5") _, options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @xer_clobber
+// CHECK: call void asm sideeffect "", "~{xer}"()
+#[no_mangle]
+pub unsafe fn xer_clobber() {
+    asm!("", out("xer") _, options(nostack, nomem, preserves_flags));
+}
+
+// Output format depends on the availability of altivec.
+// CHECK-LABEL: @v0_clobber
+// powerpc: call void asm sideeffect "", "~{v0}"()
+// powerpc64: call <4 x i32> asm sideeffect "", "=&{v0}"()
+// powerpc64le: call <4 x i32> asm sideeffect "", "=&{v0}"()
+// aix64: call <4 x i32> asm sideeffect "", "=&{v0}"()
+#[no_mangle]
+pub unsafe fn v0_clobber() {
+    asm!("", out("v0") _, options(nostack, nomem, preserves_flags));
+}
+
+// Output format depends on the availability of altivec.
+// CHECK-LABEL: @clobber_abi
+// powerpc: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
+// powerpc64: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
+// powerpc64le: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
+// aix64: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
+#[no_mangle]
+pub unsafe fn clobber_abi() {
+    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
+}
diff --git a/tests/codegen-llvm/asm/riscv-clobbers.rs b/tests/codegen-llvm/asm/riscv-clobbers.rs
new file mode 100644
index 00000000000..e55b6731098
--- /dev/null
+++ b/tests/codegen-llvm/asm/riscv-clobbers.rs
@@ -0,0 +1,40 @@
+//@ add-core-stubs
+//@ assembly-output: emit-asm
+//@ revisions: rv32i rv64i rv32e
+//@[rv32i] compile-flags: --target riscv32i-unknown-none-elf
+//@[rv32i] needs-llvm-components: riscv
+//@[rv64i] compile-flags: --target riscv64imac-unknown-none-elf
+//@[rv64i] needs-llvm-components: riscv
+//@[rv32e] compile-flags: --target riscv32e-unknown-none-elf
+//@[rv32e] needs-llvm-components: riscv
+// ignore-tidy-linelength
+
+#![crate_type = "rlib"]
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: @flags_clobber
+// CHECK: call void asm sideeffect "", "~{vtype},~{vl},~{vxsat},~{vxrm}"()
+#[no_mangle]
+pub unsafe fn flags_clobber() {
+    asm!("", options(nostack, nomem));
+}
+
+// CHECK-LABEL: @no_clobber
+// CHECK: call void asm sideeffect "", ""()
+#[no_mangle]
+pub unsafe fn no_clobber() {
+    asm!("", options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @clobber_abi
+// rv32i: asm sideeffect "", "={x1},={x5},={x6},={x7},={x10},={x11},={x12},={x13},={x14},={x15},={x16},={x17},={x28},={x29},={x30},={x31},~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f28},~{f29},~{f30},~{f31},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
+// rv64i: asm sideeffect "", "={x1},={x5},={x6},={x7},={x10},={x11},={x12},={x13},={x14},={x15},={x16},={x17},={x28},={x29},={x30},={x31},~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f28},~{f29},~{f30},~{f31},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
+// rv32e: asm sideeffect "", "={x1},={x5},={x6},={x7},={x10},={x11},={x12},={x13},={x14},={x15},~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f28},~{f29},~{f30},~{f31},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
+#[no_mangle]
+pub unsafe fn clobber_abi() {
+    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
+}
diff --git a/tests/codegen-llvm/asm/s390x-clobbers.rs b/tests/codegen-llvm/asm/s390x-clobbers.rs
new file mode 100644
index 00000000000..0ba22a32abf
--- /dev/null
+++ b/tests/codegen-llvm/asm/s390x-clobbers.rs
@@ -0,0 +1,46 @@
+//@ add-core-stubs
+//@ revisions: s390x
+//@[s390x] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z10
+//@[s390x] needs-llvm-components: systemz
+
+#![crate_type = "rlib"]
+#![feature(no_core)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: @cc_clobber
+// CHECK: call void asm sideeffect "", "~{cc}"()
+#[no_mangle]
+pub unsafe fn cc_clobber() {
+    asm!("", options(nostack, nomem));
+}
+
+// CHECK-LABEL: @no_clobber
+// CHECK: call void asm sideeffect "", ""()
+#[no_mangle]
+pub unsafe fn no_clobber() {
+    asm!("", options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @a2_clobber
+// CHECK: call void asm sideeffect "", "~{a2}"()
+#[no_mangle]
+pub unsafe fn a2_clobber() {
+    asm!("", out("a2") _, options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @v0_clobber
+// CHECK: call void asm sideeffect "", "~{v0}"()
+#[no_mangle]
+pub unsafe fn v0_clobber() {
+    asm!("", out("v0") _, options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @clobber_abi
+// CHECK: asm sideeffect "", "={r0},={r1},={r2},={r3},={r4},={r5},={r14},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{a2},~{a3},~{a4},~{a5},~{a6},~{a7},~{a8},~{a9},~{a10},~{a11},~{a12},~{a13},~{a14},~{a15}"()
+#[no_mangle]
+pub unsafe fn clobber_abi() {
+    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
+}
diff --git a/tests/codegen-llvm/asm/sanitize-llvm.rs b/tests/codegen-llvm/asm/sanitize-llvm.rs
new file mode 100644
index 00000000000..97a77033284
--- /dev/null
+++ b/tests/codegen-llvm/asm/sanitize-llvm.rs
@@ -0,0 +1,24 @@
+//@ add-core-stubs
+// FIXME(nagisa): remove the flags below once all targets support `asm!`.
+//@ compile-flags: --target x86_64-unknown-linux-gnu -Copt-level=0
+//@ needs-llvm-components: x86
+
+// Verify we sanitize the special tokens for the LLVM inline-assembly, ensuring people won't
+// inadvertently rely on the LLVM-specific syntax and features.
+#![no_core]
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![allow(named_asm_labels)]
+
+extern crate minicore;
+use minicore::*;
+
+pub unsafe fn we_escape_dollar_signs() {
+    // CHECK: call void asm sideeffect alignstack inteldialect "banana$$:"
+    asm!(r"banana$:",)
+}
+
+pub unsafe fn we_escape_escapes_too() {
+    // CHECK: call void asm sideeffect alignstack inteldialect "banana\{{(\\|5C)}}36:"
+    asm!(r"banana\36:",)
+}
diff --git a/tests/codegen-llvm/asm/sparc-clobbers.rs b/tests/codegen-llvm/asm/sparc-clobbers.rs
new file mode 100644
index 00000000000..a71715ed94d
--- /dev/null
+++ b/tests/codegen-llvm/asm/sparc-clobbers.rs
@@ -0,0 +1,36 @@
+//@ add-core-stubs
+//@ revisions: sparc sparcv8plus sparc64
+//@[sparc] compile-flags: --target sparc-unknown-none-elf
+//@[sparc] needs-llvm-components: sparc
+//@[sparcv8plus] compile-flags: --target sparc-unknown-linux-gnu
+//@[sparcv8plus] needs-llvm-components: sparc
+//@[sparc64] compile-flags: --target sparc64-unknown-linux-gnu
+//@[sparc64] needs-llvm-components: sparc
+
+#![crate_type = "rlib"]
+#![feature(no_core, asm_experimental_arch)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: @cc_clobber
+// CHECK: call void asm sideeffect "", "~{icc},~{fcc0},~{fcc1},~{fcc2},~{fcc3}"()
+#[no_mangle]
+pub unsafe fn cc_clobber() {
+    asm!("", options(nostack, nomem));
+}
+
+// CHECK-LABEL: @no_clobber
+// CHECK: call void asm sideeffect "", ""()
+#[no_mangle]
+pub unsafe fn no_clobber() {
+    asm!("", options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @y_clobber
+// CHECK: call void asm sideeffect "", "~{y}"()
+#[no_mangle]
+pub unsafe fn y_clobber() {
+    asm!("", out("y") _, options(nostack, nomem, preserves_flags));
+}
diff --git a/tests/codegen-llvm/asm/x86-clobber_abi.rs b/tests/codegen-llvm/asm/x86-clobber_abi.rs
new file mode 100644
index 00000000000..5b34b4e8ef3
--- /dev/null
+++ b/tests/codegen-llvm/asm/x86-clobber_abi.rs
@@ -0,0 +1,36 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "rlib"]
+
+use std::arch::asm;
+
+// CHECK-LABEL: @clobber_sysv64
+// CHECK: ={ax},={cx},={dx},={si},={di},={r8},={r9},={r10},={r11},={xmm0},={xmm1},={xmm2},={xmm3},={xmm4},={xmm5},={xmm6},={xmm7},={xmm8},={xmm9},={xmm10},={xmm11},={xmm12},={xmm13},={xmm14},={xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{k0},~{k1},~{k2},~{k3},~{k4},~{k5},~{k6},~{k7},~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)},~{tmm0},~{tmm1},~{tmm2},~{tmm3},~{tmm4},~{tmm5},~{tmm6},~{tmm7},~{dirflag},~{fpsr},~{flags},~{memory}
+#[no_mangle]
+pub unsafe fn clobber_sysv64() {
+    asm!("", clobber_abi("sysv64"));
+}
+
+// CHECK-LABEL: @clobber_win64
+// CHECK: ={ax},={cx},={dx},={r8},={r9},={r10},={r11},={xmm0},={xmm1},={xmm2},={xmm3},={xmm4},={xmm5},={xmm6},={xmm7},={xmm8},={xmm9},={xmm10},={xmm11},={xmm12},={xmm13},={xmm14},={xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{k0},~{k1},~{k2},~{k3},~{k4},~{k5},~{k6},~{k7},~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)},~{tmm0},~{tmm1},~{tmm2},~{tmm3},~{tmm4},~{tmm5},~{tmm6},~{tmm7},~{dirflag},~{fpsr},~{flags},~{memory}
+#[no_mangle]
+pub unsafe fn clobber_win64() {
+    asm!("", clobber_abi("win64"));
+}
+
+// CHECK-LABEL: @clobber_sysv64
+// CHECK: =&{dx},={ax},={cx},={si},={di},={r8},={r9},={r10},={r11},={xmm0},={xmm1},={xmm2},={xmm3},={xmm4},={xmm5},={xmm6},={xmm7},={xmm8},={xmm9},={xmm10},={xmm11},={xmm12},={xmm13},={xmm14},={xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{k0},~{k1},~{k2},~{k3},~{k4},~{k5},~{k6},~{k7},~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)},~{tmm0},~{tmm1},~{tmm2},~{tmm3},~{tmm4},~{tmm5},~{tmm6},~{tmm7},~{dirflag},~{fpsr},~{flags},~{memory}
+#[no_mangle]
+pub unsafe fn clobber_sysv64_edx() {
+    let foo: i32;
+    asm!("", out("edx") foo, clobber_abi("sysv64"));
+}
+
+// CHECK-LABEL: @clobber_win64
+// CHECK: =&{dx},={ax},={cx},={r8},={r9},={r10},={r11},={xmm0},={xmm1},={xmm2},={xmm3},={xmm4},={xmm5},={xmm6},={xmm7},={xmm8},={xmm9},={xmm10},={xmm11},={xmm12},={xmm13},={xmm14},={xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{k0},~{k1},~{k2},~{k3},~{k4},~{k5},~{k6},~{k7},~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)},~{tmm0},~{tmm1},~{tmm2},~{tmm3},~{tmm4},~{tmm5},~{tmm6},~{tmm7},~{dirflag},~{fpsr},~{flags},~{memory}
+#[no_mangle]
+pub unsafe fn clobber_win64_edx() {
+    let foo: i32;
+    asm!("", out("edx") foo, clobber_abi("win64"));
+}
diff --git a/tests/codegen-llvm/asm/x86-clobbers.rs b/tests/codegen-llvm/asm/x86-clobbers.rs
new file mode 100644
index 00000000000..50163b646b2
--- /dev/null
+++ b/tests/codegen-llvm/asm/x86-clobbers.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "rlib"]
+
+use std::arch::asm;
+
+// CHECK-LABEL: @x87_clobber
+// CHECK: ~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)}
+#[no_mangle]
+pub unsafe fn x87_clobber() {
+    asm!("foo", out("st") _);
+}
+
+// CHECK-LABEL: @mmx_clobber
+// CHECK: ~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)}
+#[no_mangle]
+pub unsafe fn mmx_clobber() {
+    asm!("bar", out("mm0") _, out("mm1") _);
+}
diff --git a/tests/codegen-llvm/asm/x86-target-clobbers.rs b/tests/codegen-llvm/asm/x86-target-clobbers.rs
new file mode 100644
index 00000000000..119372491ff
--- /dev/null
+++ b/tests/codegen-llvm/asm/x86-target-clobbers.rs
@@ -0,0 +1,29 @@
+//@ only-x86_64
+//@ revisions: base avx512
+//@ [avx512]compile-flags: -C target-feature=+avx512f
+
+#![crate_type = "rlib"]
+
+use std::arch::asm;
+
+// CHECK-LABEL: @amx_clobber
+// base: call void asm sideeffect inteldialect "", "~{tmm0}"()
+#[no_mangle]
+pub unsafe fn amx_clobber() {
+    asm!("", out("tmm0") _, options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @avx512_clobber
+// base: call void asm sideeffect inteldialect "", "~{xmm31}"()
+// avx512: call float asm sideeffect inteldialect "", "=&{xmm31}"()
+#[no_mangle]
+pub unsafe fn avx512_clobber() {
+    asm!("", out("zmm31") _, options(nostack, nomem, preserves_flags));
+}
+
+// CHECK-LABEL: @eax_clobber
+// CHECK: call i32 asm sideeffect inteldialect "", "=&{ax}"()
+#[no_mangle]
+pub unsafe fn eax_clobber() {
+    asm!("", out("eax") _, options(nostack, nomem, preserves_flags));
+}
diff --git a/tests/codegen-llvm/assign-desugar-debuginfo.rs b/tests/codegen-llvm/assign-desugar-debuginfo.rs
new file mode 100644
index 00000000000..77ee8758b3b
--- /dev/null
+++ b/tests/codegen-llvm/assign-desugar-debuginfo.rs
@@ -0,0 +1,18 @@
+//@ compile-flags: -g -Zmir-opt-level=0
+
+#![crate_type = "lib"]
+
+#[inline(never)]
+fn swizzle(a: u32, b: u32, c: u32) -> (u32, (u32, u32)) {
+    (b, (c, a))
+}
+
+pub fn work() {
+    let mut a = 1;
+    let mut b = 2;
+    let mut c = 3;
+    (a, (b, c)) = swizzle(a, b, c);
+    println!("{a} {b} {c}");
+}
+
+// CHECK-NOT: !DILocalVariable(name: "lhs",
diff --git a/tests/codegen-llvm/async-closure-debug.rs b/tests/codegen-llvm/async-closure-debug.rs
new file mode 100644
index 00000000000..b5b369e6e54
--- /dev/null
+++ b/tests/codegen-llvm/async-closure-debug.rs
@@ -0,0 +1,20 @@
+// Just make sure that async closures don't ICE.
+//
+//@ compile-flags: -C debuginfo=2
+//@ edition: 2018
+//@ ignore-msvc
+
+// CHECK-DAG:  [[GEN_FN:!.*]] = !DINamespace(name: "async_closure_test"
+// CHECK-DAG:  [[CLOSURE:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}", scope: [[GEN_FN]]
+// CHECK-DAG:  [[UPVAR:!.*]] = !DIDerivedType(tag: DW_TAG_member, name: "upvar", scope: [[CLOSURE]]
+
+fn async_closure_test(upvar: &str) -> impl AsyncFn() + '_ {
+    async move || {
+        let hello = String::from("hello");
+        println!("{hello}, {upvar}");
+    }
+}
+
+fn main() {
+    let _async_closure = async_closure_test("world");
+}
diff --git a/tests/codegen-llvm/async-fn-debug-awaitee-field.rs b/tests/codegen-llvm/async-fn-debug-awaitee-field.rs
new file mode 100644
index 00000000000..50860c90662
--- /dev/null
+++ b/tests/codegen-llvm/async-fn-debug-awaitee-field.rs
@@ -0,0 +1,28 @@
+// ignore-tidy-linelength
+//! This test makes sure that the coroutine field capturing the awaitee in a `.await` expression
+//! is called `__awaitee` in debuginfo. This name must not be changed since debuggers and debugger
+//! extensions rely on the field having this name.
+
+//@ revisions: MSVC NONMSVC
+//@[MSVC] only-msvc
+//@[NONMSVC] ignore-msvc
+
+//@ compile-flags: -C debuginfo=2 -Copt-level=0
+//@ edition: 2018
+
+#![crate_type = "lib"]
+
+pub async fn async_fn_test() {
+    foo().await;
+}
+
+pub async fn foo() {}
+
+// NONMSVC: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}", scope: [[GEN_SCOPE:![0-9]*]],
+// MSVC: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<async_fn_debug_awaitee_field::async_fn_test::async_fn_env$0>",
+// NONMSVC: [[GEN_SCOPE:!.*]] = !DINamespace(name: "async_fn_test",
+// CHECK: [[SUSPEND_STRUCT:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend0", scope: [[GEN]],
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__awaitee", scope: [[SUSPEND_STRUCT]], {{.*}}, baseType: [[AWAITEE_TYPE:![0-9]*]],
+// NONMSVC: [[AWAITEE_TYPE]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}", scope: [[AWAITEE_SCOPE:![0-9]*]],
+// MSVC: [[AWAITEE_TYPE]] = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<async_fn_debug_awaitee_field::foo::async_fn_env$0>",
+// NONMSVC: [[AWAITEE_SCOPE]] = !DINamespace(name: "foo",
diff --git a/tests/codegen-llvm/async-fn-debug-msvc.rs b/tests/codegen-llvm/async-fn-debug-msvc.rs
new file mode 100644
index 00000000000..e0c601146f8
--- /dev/null
+++ b/tests/codegen-llvm/async-fn-debug-msvc.rs
@@ -0,0 +1,55 @@
+// Verify debuginfo for coroutines:
+//  - Each variant points to the file and line of its yield point
+//  - The discriminants are marked artificial
+//  - Other fields are not marked artificial
+//
+//
+//@ compile-flags: -C debuginfo=2
+//@ edition: 2018
+//@ only-msvc
+
+async fn foo() {}
+async fn async_fn_test() {
+    foo().await;
+    let s = String::from("foo");
+    foo().await;
+}
+
+// FIXME: No way to reliably check the filename.
+
+// CHECK-DAG:  [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<async_fn_debug_msvc::async_fn_test::async_fn_env$0>",
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant0", scope: [[GEN]],
+// For brevity, we only check the struct name and members of the last variant.
+// CHECK-SAME: file: [[FILE:![0-9]*]], line: 12,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant1", scope: [[GEN]],
+// CHECK-SAME: file: [[FILE]], line: 16,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant2", scope: [[GEN]],
+// CHECK-SAME: file: [[FILE]], line: 16,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant3", scope: [[GEN]],
+// CHECK-SAME: file: [[FILE]], line: 13,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant4", scope: [[GEN]],
+// CHECK-SAME: file: [[FILE]], line: 15,
+// CHECK-SAME: baseType: [[VARIANT_WRAPPER:![0-9]*]]
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "value", scope: [[VARIANT_WRAPPER]], file: !2, baseType: [[VARIANT:![0-9]*]],
+// CHECK:      [[VARIANT]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[GEN]],
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[VARIANT]]
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "tag", scope: [[GEN]],
+// CHECK-NOT: flags: DIFlagArtificial
+
+fn main() {
+    let _dummy = async_fn_test();
+}
diff --git a/tests/codegen-llvm/async-fn-debug.rs b/tests/codegen-llvm/async-fn-debug.rs
new file mode 100644
index 00000000000..ed704c7cc8b
--- /dev/null
+++ b/tests/codegen-llvm/async-fn-debug.rs
@@ -0,0 +1,59 @@
+// Verify debuginfo for async fn:
+//  - Each variant points to the file and line of its yield point
+//  - The discriminants are marked artificial
+//  - Other fields are not marked artificial
+//
+//
+//@ compile-flags: -C debuginfo=2
+//@ edition: 2018
+//@ ignore-msvc
+
+async fn foo() {}
+async fn async_fn_test() {
+    foo().await;
+    let s = String::from("foo");
+    foo().await;
+}
+
+// FIXME: No way to reliably check the filename.
+
+// CHECK-DAG:  [[ASYNC_FN:!.*]] = !DINamespace(name: "async_fn_test"
+// CHECK-DAG:  [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}", scope: [[ASYNC_FN]]
+// CHECK:      [[VARIANT:!.*]] = !DICompositeType(tag: DW_TAG_variant_part, scope: [[GEN]],
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: discriminator: [[DISC:![0-9]*]]
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "0", scope: [[VARIANT]],
+// CHECK-SAME: file: [[FILE:![0-9]*]], line: 12,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "Unresumed", scope: [[GEN]],
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "1", scope: [[VARIANT]],
+// CHECK-SAME: file: [[FILE]], line: 16,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "2", scope: [[VARIANT]],
+// CHECK-SAME: file: [[FILE]], line: 16,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "3", scope: [[VARIANT]],
+// CHECK-SAME: file: [[FILE]], line: 13,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "4", scope: [[VARIANT]],
+// CHECK-SAME: file: [[FILE]], line: 15,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      [[S1:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[GEN]],
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[S1]]
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      [[DISC]] = !DIDerivedType(tag: DW_TAG_member, name: "__state", scope: [[GEN]],
+// CHECK-SAME: flags: DIFlagArtificial
+
+fn main() {
+    let _dummy = async_fn_test();
+}
diff --git a/tests/codegen-llvm/atomic-operations.rs b/tests/codegen-llvm/atomic-operations.rs
new file mode 100644
index 00000000000..8771b8b2419
--- /dev/null
+++ b/tests/codegen-llvm/atomic-operations.rs
@@ -0,0 +1,84 @@
+// Code generation of atomic operations.
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+use std::sync::atomic::AtomicI32;
+use std::sync::atomic::Ordering::*;
+
+// CHECK-LABEL: @compare_exchange
+#[no_mangle]
+pub fn compare_exchange(a: &AtomicI32) {
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 10 monotonic monotonic
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 11 monotonic acquire
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 12 monotonic seq_cst
+    let _ = a.compare_exchange(0, 10, Relaxed, Relaxed);
+    let _ = a.compare_exchange(0, 11, Relaxed, Acquire);
+    let _ = a.compare_exchange(0, 12, Relaxed, SeqCst);
+
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 20 release monotonic
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 21 release acquire
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 22 release seq_cst
+    let _ = a.compare_exchange(0, 20, Release, Relaxed);
+    let _ = a.compare_exchange(0, 21, Release, Acquire);
+    let _ = a.compare_exchange(0, 22, Release, SeqCst);
+
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 30 acquire monotonic
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 31 acquire acquire
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 32 acquire seq_cst
+    let _ = a.compare_exchange(0, 30, Acquire, Relaxed);
+    let _ = a.compare_exchange(0, 31, Acquire, Acquire);
+    let _ = a.compare_exchange(0, 32, Acquire, SeqCst);
+
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 40 acq_rel monotonic
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 41 acq_rel acquire
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 42 acq_rel seq_cst
+    let _ = a.compare_exchange(0, 40, AcqRel, Relaxed);
+    let _ = a.compare_exchange(0, 41, AcqRel, Acquire);
+    let _ = a.compare_exchange(0, 42, AcqRel, SeqCst);
+
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 50 seq_cst monotonic
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 51 seq_cst acquire
+    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 52 seq_cst seq_cst
+    let _ = a.compare_exchange(0, 50, SeqCst, Relaxed);
+    let _ = a.compare_exchange(0, 51, SeqCst, Acquire);
+    let _ = a.compare_exchange(0, 52, SeqCst, SeqCst);
+}
+
+// CHECK-LABEL: @compare_exchange_weak
+#[no_mangle]
+pub fn compare_exchange_weak(w: &AtomicI32) {
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 10 monotonic monotonic
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 11 monotonic acquire
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 12 monotonic seq_cst
+    let _ = w.compare_exchange_weak(1, 10, Relaxed, Relaxed);
+    let _ = w.compare_exchange_weak(1, 11, Relaxed, Acquire);
+    let _ = w.compare_exchange_weak(1, 12, Relaxed, SeqCst);
+
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 20 release monotonic
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 21 release acquire
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 22 release seq_cst
+    let _ = w.compare_exchange_weak(1, 20, Release, Relaxed);
+    let _ = w.compare_exchange_weak(1, 21, Release, Acquire);
+    let _ = w.compare_exchange_weak(1, 22, Release, SeqCst);
+
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 30 acquire monotonic
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 31 acquire acquire
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 32 acquire seq_cst
+    let _ = w.compare_exchange_weak(1, 30, Acquire, Relaxed);
+    let _ = w.compare_exchange_weak(1, 31, Acquire, Acquire);
+    let _ = w.compare_exchange_weak(1, 32, Acquire, SeqCst);
+
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 40 acq_rel monotonic
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 41 acq_rel acquire
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 42 acq_rel seq_cst
+    let _ = w.compare_exchange_weak(1, 40, AcqRel, Relaxed);
+    let _ = w.compare_exchange_weak(1, 41, AcqRel, Acquire);
+    let _ = w.compare_exchange_weak(1, 42, AcqRel, SeqCst);
+
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 50 seq_cst monotonic
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 51 seq_cst acquire
+    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 52 seq_cst seq_cst
+    let _ = w.compare_exchange_weak(1, 50, SeqCst, Relaxed);
+    let _ = w.compare_exchange_weak(1, 51, SeqCst, Acquire);
+    let _ = w.compare_exchange_weak(1, 52, SeqCst, SeqCst);
+}
diff --git a/tests/codegen-llvm/atomicptr.rs b/tests/codegen-llvm/atomicptr.rs
new file mode 100644
index 00000000000..4819af40ca2
--- /dev/null
+++ b/tests/codegen-llvm/atomicptr.rs
@@ -0,0 +1,36 @@
+// LLVM does not support some atomic RMW operations on pointers, so inside codegen we lower those
+// to integer atomics, surrounded by casts to and from integer type.
+// This test ensures that we do the round-trip correctly for AtomicPtr::fetch_byte_add, and also
+// ensures that we do not have such a round-trip for AtomicPtr::swap, because LLVM supports pointer
+// arguments to `atomicrmw xchg`.
+
+//@ compile-flags: -Copt-level=3 -Cno-prepopulate-passes
+#![crate_type = "lib"]
+#![feature(strict_provenance_atomic_ptr)]
+
+use std::ptr::without_provenance_mut;
+use std::sync::atomic::AtomicPtr;
+use std::sync::atomic::Ordering::Relaxed;
+
+// Portability hack so that we can say [[USIZE]] instead of i64/i32/i16 for usize.
+// CHECK: @helper([[USIZE:i[0-9]+]] noundef %_1)
+#[no_mangle]
+pub fn helper(_: usize) {}
+
+// CHECK-LABEL: @atomicptr_fetch_byte_add
+#[no_mangle]
+pub fn atomicptr_fetch_byte_add(a: &AtomicPtr<u8>, v: usize) -> *mut u8 {
+    // CHECK: %[[INTPTR:.*]] = ptrtoint ptr %{{.*}} to [[USIZE]]
+    // CHECK-NEXT: %[[RET:.*]] = atomicrmw add ptr %{{.*}}, [[USIZE]] %[[INTPTR]]
+    // CHECK-NEXT: inttoptr [[USIZE]] %[[RET]] to ptr
+    a.fetch_byte_add(v, Relaxed)
+}
+
+// CHECK-LABEL: @atomicptr_swap
+#[no_mangle]
+pub fn atomicptr_swap(a: &AtomicPtr<u8>, ptr: *mut u8) -> *mut u8 {
+    // CHECK-NOT: ptrtoint
+    // CHECK: atomicrmw xchg ptr %{{.*}}, ptr %{{.*}} monotonic
+    // CHECK-NOT: inttoptr
+    a.swap(ptr, Relaxed)
+}
diff --git a/tests/codegen-llvm/autodiff/batched.rs b/tests/codegen-llvm/autodiff/batched.rs
new file mode 100644
index 00000000000..d27aed50e6c
--- /dev/null
+++ b/tests/codegen-llvm/autodiff/batched.rs
@@ -0,0 +1,116 @@
+//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+//
+// In Enzyme, we test against a large range of LLVM versions (5+) and don't have overly many
+// breakages. One benefit is that we match the IR generated by Enzyme only after running it
+// through LLVM's O3 pipeline, which will remove most of the noise.
+// However, our integration test could also be affected by changes in how rustc lowers MIR into
+// LLVM-IR, which could cause additional noise and thus breakages. If that's the case, we should
+// reduce this test to only match the first lines and the ret instructions.
+
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_forward;
+
+#[autodiff_forward(d_square3, Dual, DualOnly)]
+#[autodiff_forward(d_square2, 4, Dual, DualOnly)]
+#[autodiff_forward(d_square1, 4, Dual, Dual)]
+#[no_mangle]
+fn square(x: &f32) -> f32 {
+    x * x
+}
+
+// d_sqaure2
+// CHECK: define internal fastcc [4 x float] @fwddiffe4square(float %x.0.val, [4 x ptr] %"x'")
+// CHECK-NEXT: start:
+// CHECK-NEXT:   %0 = extractvalue [4 x ptr] %"x'", 0
+// CHECK-NEXT:   %"_2'ipl" = load float, ptr %0, align 4
+// CHECK-NEXT:   %1 = extractvalue [4 x ptr] %"x'", 1
+// CHECK-NEXT:   %"_2'ipl1" = load float, ptr %1, align 4
+// CHECK-NEXT:   %2 = extractvalue [4 x ptr] %"x'", 2
+// CHECK-NEXT:   %"_2'ipl2" = load float, ptr %2, align 4
+// CHECK-NEXT:   %3 = extractvalue [4 x ptr] %"x'", 3
+// CHECK-NEXT:   %"_2'ipl3" = load float, ptr %3, align 4
+// CHECK-NEXT:   %4 = insertelement <4 x float> poison, float %"_2'ipl", i64 0
+// CHECK-NEXT:   %5 = insertelement <4 x float> %4, float %"_2'ipl1", i64 1
+// CHECK-NEXT:   %6 = insertelement <4 x float> %5, float %"_2'ipl2", i64 2
+// CHECK-NEXT:   %7 = insertelement <4 x float> %6, float %"_2'ipl3", i64 3
+// CHECK-NEXT:   %8 = fadd fast <4 x float> %7, %7
+// CHECK-NEXT:   %9 = insertelement <4 x float> poison, float %x.0.val, i64 0
+// CHECK-NEXT:   %10 = shufflevector <4 x float> %9, <4 x float> poison, <4 x i32> zeroinitializer
+// CHECK-NEXT:   %11 = fmul fast <4 x float> %8, %10
+// CHECK-NEXT:   %12 = extractelement <4 x float> %11, i64 0
+// CHECK-NEXT:   %13 = insertvalue [4 x float] undef, float %12, 0
+// CHECK-NEXT:   %14 = extractelement <4 x float> %11, i64 1
+// CHECK-NEXT:   %15 = insertvalue [4 x float] %13, float %14, 1
+// CHECK-NEXT:   %16 = extractelement <4 x float> %11, i64 2
+// CHECK-NEXT:   %17 = insertvalue [4 x float] %15, float %16, 2
+// CHECK-NEXT:   %18 = extractelement <4 x float> %11, i64 3
+// CHECK-NEXT:   %19 = insertvalue [4 x float] %17, float %18, 3
+// CHECK-NEXT:   ret [4 x float] %19
+// CHECK-NEXT: }
+
+// d_square3, the extra float is the original return value (x * x)
+// CHECK: define internal fastcc { float, [4 x float] } @fwddiffe4square.1(float %x.0.val, [4 x ptr] %"x'")
+// CHECK-NEXT: start:
+// CHECK-NEXT:   %0 = extractvalue [4 x ptr] %"x'", 0
+// CHECK-NEXT:   %"_2'ipl" = load float, ptr %0, align 4
+// CHECK-NEXT:   %1 = extractvalue [4 x ptr] %"x'", 1
+// CHECK-NEXT:   %"_2'ipl1" = load float, ptr %1, align 4
+// CHECK-NEXT:   %2 = extractvalue [4 x ptr] %"x'", 2
+// CHECK-NEXT:   %"_2'ipl2" = load float, ptr %2, align 4
+// CHECK-NEXT:   %3 = extractvalue [4 x ptr] %"x'", 3
+// CHECK-NEXT:   %"_2'ipl3" = load float, ptr %3, align 4
+// CHECK-NEXT:   %_0 = fmul float %x.0.val, %x.0.val
+// CHECK-NEXT:   %4 = insertelement <4 x float> poison, float %"_2'ipl", i64 0
+// CHECK-NEXT:   %5 = insertelement <4 x float> %4, float %"_2'ipl1", i64 1
+// CHECK-NEXT:   %6 = insertelement <4 x float> %5, float %"_2'ipl2", i64 2
+// CHECK-NEXT:   %7 = insertelement <4 x float> %6, float %"_2'ipl3", i64 3
+// CHECK-NEXT:   %8 = fadd fast <4 x float> %7, %7
+// CHECK-NEXT:   %9 = insertelement <4 x float> poison, float %x.0.val, i64 0
+// CHECK-NEXT:   %10 = shufflevector <4 x float> %9, <4 x float> poison, <4 x i32> zeroinitializer
+// CHECK-NEXT:   %11 = fmul fast <4 x float> %8, %10
+// CHECK-NEXT:   %12 = extractelement <4 x float> %11, i64 0
+// CHECK-NEXT:   %13 = insertvalue [4 x float] undef, float %12, 0
+// CHECK-NEXT:   %14 = extractelement <4 x float> %11, i64 1
+// CHECK-NEXT:   %15 = insertvalue [4 x float] %13, float %14, 1
+// CHECK-NEXT:   %16 = extractelement <4 x float> %11, i64 2
+// CHECK-NEXT:   %17 = insertvalue [4 x float] %15, float %16, 2
+// CHECK-NEXT:   %18 = extractelement <4 x float> %11, i64 3
+// CHECK-NEXT:   %19 = insertvalue [4 x float] %17, float %18, 3
+// CHECK-NEXT:   %20 = insertvalue { float, [4 x float] } undef, float %_0, 0
+// CHECK-NEXT:   %21 = insertvalue { float, [4 x float] } %20, [4 x float] %19, 1
+// CHECK-NEXT:   ret { float, [4 x float] } %21
+// CHECK-NEXT: }
+
+fn main() {
+    let x = std::hint::black_box(3.0);
+    let output = square(&x);
+    dbg!(&output);
+    assert_eq!(9.0, output);
+    dbg!(square(&x));
+
+    let mut df_dx1 = 1.0;
+    let mut df_dx2 = 2.0;
+    let mut df_dx3 = 3.0;
+    let mut df_dx4 = 0.0;
+    let [o1, o2, o3, o4] = d_square2(&x, &mut df_dx1, &mut df_dx2, &mut df_dx3, &mut df_dx4);
+    dbg!(o1, o2, o3, o4);
+    let [output2, o1, o2, o3, o4] =
+        d_square1(&x, &mut df_dx1, &mut df_dx2, &mut df_dx3, &mut df_dx4);
+    dbg!(o1, o2, o3, o4);
+    assert_eq!(output, output2);
+    assert!((6.0 - o1).abs() < 1e-10);
+    assert!((12.0 - o2).abs() < 1e-10);
+    assert!((18.0 - o3).abs() < 1e-10);
+    assert!((0.0 - o4).abs() < 1e-10);
+    assert_eq!(1.0, df_dx1);
+    assert_eq!(2.0, df_dx2);
+    assert_eq!(3.0, df_dx3);
+    assert_eq!(0.0, df_dx4);
+    assert_eq!(d_square3(&x, &mut df_dx1), 2.0 * o1);
+    assert_eq!(d_square3(&x, &mut df_dx2), 2.0 * o2);
+    assert_eq!(d_square3(&x, &mut df_dx3), 2.0 * o3);
+    assert_eq!(d_square3(&x, &mut df_dx4), 2.0 * o4);
+}
diff --git a/tests/codegen-llvm/autodiff/generic.rs b/tests/codegen-llvm/autodiff/generic.rs
new file mode 100644
index 00000000000..2f674079be0
--- /dev/null
+++ b/tests/codegen-llvm/autodiff/generic.rs
@@ -0,0 +1,42 @@
+//@ compile-flags: -Zautodiff=Enable -Zautodiff=NoPostopt -C opt-level=3 -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+fn square<T: std::ops::Mul<Output = T> + Copy>(x: &T) -> T {
+    *x * *x
+}
+
+// Ensure that `d_square::<f64>` code is generated even if `square::<f64>` was never called
+//
+// CHECK: ; generic::square
+// CHECK-NEXT: ; Function Attrs:
+// CHECK-NEXT: define internal {{.*}} double
+// CHECK-NEXT: start:
+// CHECK-NOT: ret
+// CHECK: fmul double
+
+// Ensure that `d_square::<f32>` code is generated
+//
+// CHECK: ; generic::square
+// CHECK-NEXT: ; Function Attrs: {{.*}}
+// CHECK-NEXT: define internal {{.*}} float
+// CHECK-NEXT: start:
+// CHECK-NOT: ret
+// CHECK: fmul float
+
+fn main() {
+    let xf32: f32 = std::hint::black_box(3.0);
+    let xf64: f64 = std::hint::black_box(3.0);
+
+    let outputf32 = square::<f32>(&xf32);
+    assert_eq!(9.0, outputf32);
+
+    let mut df_dxf64: f64 = std::hint::black_box(0.0);
+
+    let output_f64 = d_square::<f64>(&xf64, &mut df_dxf64, 1.0);
+    assert_eq!(6.0, df_dxf64);
+}
diff --git a/tests/codegen-llvm/autodiff/identical_fnc.rs b/tests/codegen-llvm/autodiff/identical_fnc.rs
new file mode 100644
index 00000000000..1c25b3d09ab
--- /dev/null
+++ b/tests/codegen-llvm/autodiff/identical_fnc.rs
@@ -0,0 +1,45 @@
+//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+//
+// Each autodiff invocation creates a new placeholder function, which we will replace on llvm-ir
+// level. If a user tries to differentiate two identical functions within the same compilation unit,
+// then LLVM might merge them in release mode before AD. In that case we can't rewrite one of the
+// merged placeholder function anymore, and compilation would fail. We prevent this by disabling
+// LLVM's merge_function pass before AD. Here we implicetely test that our solution keeps working.
+// We also explicetly test that we keep running merge_function after AD, by checking for two
+// identical function calls in the LLVM-IR, while having two different calls in the Rust code.
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+fn square(x: &f64) -> f64 {
+    x * x
+}
+
+#[autodiff_reverse(d_square2, Duplicated, Active)]
+fn square2(x: &f64) -> f64 {
+    x * x
+}
+
+// CHECK:; identical_fnc::main
+// CHECK-NEXT:; Function Attrs:
+// CHECK-NEXT:define internal void @_ZN13identical_fnc4main17hf4dbc69c8d2f9130E()
+// CHECK-NEXT:start:
+// CHECK-NOT:br
+// CHECK-NOT:ret
+// CHECK:; call identical_fnc::d_square
+// CHECK-NEXT:  call fastcc void @_ZN13identical_fnc8d_square17h4c364207a2f8e06dE(double %x.val, ptr noalias noundef nonnull align 8 dereferenceable(8) %dx1)
+// CHECK-NEXT:; call identical_fnc::d_square
+// CHECK-NEXT:  call fastcc void @_ZN13identical_fnc8d_square17h4c364207a2f8e06dE(double %x.val, ptr noalias noundef nonnull align 8 dereferenceable(8) %dx2)
+
+fn main() {
+    let x = std::hint::black_box(3.0);
+    let mut dx1 = std::hint::black_box(1.0);
+    let mut dx2 = std::hint::black_box(1.0);
+    let _ = d_square(&x, &mut dx1, 1.0);
+    let _ = d_square2(&x, &mut dx2, 1.0);
+    assert_eq!(dx1, 6.0);
+    assert_eq!(dx2, 6.0);
+}
diff --git a/tests/codegen-llvm/autodiff/inline.rs b/tests/codegen-llvm/autodiff/inline.rs
new file mode 100644
index 00000000000..65bed170207
--- /dev/null
+++ b/tests/codegen-llvm/autodiff/inline.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat -Zautodiff=NoPostopt
+//@ no-prefer-dynamic
+//@ needs-enzyme
+
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+fn square(x: &f64) -> f64 {
+    x * x
+}
+
+// CHECK: ; inline::d_square
+// CHECK-NEXT: ; Function Attrs: alwaysinline
+// CHECK-NOT: noinline
+// CHECK-NEXT: define internal fastcc void @_ZN6inline8d_square17h021c74e92c259cdeE
+fn main() {
+    let x = std::hint::black_box(3.0);
+    let mut dx1 = std::hint::black_box(1.0);
+    let _ = d_square(&x, &mut dx1, 1.0);
+    assert_eq!(dx1, 6.0);
+}
diff --git a/tests/codegen-llvm/autodiff/scalar.rs b/tests/codegen-llvm/autodiff/scalar.rs
new file mode 100644
index 00000000000..096b4209e84
--- /dev/null
+++ b/tests/codegen-llvm/autodiff/scalar.rs
@@ -0,0 +1,33 @@
+//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[autodiff_reverse(d_square, Duplicated, Active)]
+#[no_mangle]
+fn square(x: &f64) -> f64 {
+    x * x
+}
+
+// CHECK:define internal fastcc double @diffesquare(double %x.0.val, ptr nocapture nonnull align 8 %"x'"
+// CHECK-NEXT:invertstart:
+// CHECK-NEXT:  %_0 = fmul double %x.0.val, %x.0.val
+// CHECK-NEXT:  %0 = fadd fast double %x.0.val, %x.0.val
+// CHECK-NEXT:  %1 = load double, ptr %"x'", align 8
+// CHECK-NEXT:  %2 = fadd fast double %1, %0
+// CHECK-NEXT:  store double %2, ptr %"x'", align 8
+// CHECK-NEXT:  ret double %_0
+// CHECK-NEXT:}
+
+fn main() {
+    let x = std::hint::black_box(3.0);
+    let output = square(&x);
+    assert_eq!(9.0, output);
+
+    let mut df_dx = 0.0;
+    let output_ = d_square(&x, &mut df_dx, 1.0);
+    assert_eq!(output, output_);
+    assert_eq!(6.0, df_dx);
+}
diff --git a/tests/codegen-llvm/autodiff/sret.rs b/tests/codegen-llvm/autodiff/sret.rs
new file mode 100644
index 00000000000..d2fa85e3e37
--- /dev/null
+++ b/tests/codegen-llvm/autodiff/sret.rs
@@ -0,0 +1,45 @@
+//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+
+// This test is almost identical to the scalar.rs one,
+// but we intentionally add a few more floats.
+// `df` would ret `{ f64, f32, f32 }`, but is lowered as an sret.
+// We therefore use this test to verify some of our sret handling.
+
+#![feature(autodiff)]
+
+use std::autodiff::autodiff_reverse;
+
+#[no_mangle]
+#[autodiff_reverse(df, Active, Active, Active)]
+fn primal(x: f32, y: f32) -> f64 {
+    (x * x * y) as f64
+}
+
+// CHECK:define internal fastcc void @_ZN4sret2df17h93be4316dd8ea006E(ptr dead_on_unwind noalias nocapture noundef nonnull writable writeonly align 8 dereferenceable(16) initializes((0, 16)) %_0, float noundef %x, float noundef %y)
+// CHECK-NEXT:start:
+// CHECK-NEXT:  %0 = tail call fastcc { double, float, float } @diffeprimal(float %x, float %y)
+// CHECK-NEXT:  %.elt = extractvalue { double, float, float } %0, 0
+// CHECK-NEXT:  store double %.elt, ptr %_0, align 8
+// CHECK-NEXT:  %_0.repack1 = getelementptr inbounds nuw i8, ptr %_0, i64 8
+// CHECK-NEXT:  %.elt2 = extractvalue { double, float, float } %0, 1
+// CHECK-NEXT:  store float %.elt2, ptr %_0.repack1, align 8
+// CHECK-NEXT:  %_0.repack3 = getelementptr inbounds nuw i8, ptr %_0, i64 12
+// CHECK-NEXT:  %.elt4 = extractvalue { double, float, float } %0, 2
+// CHECK-NEXT:  store float %.elt4, ptr %_0.repack3, align 4
+// CHECK-NEXT:  ret void
+// CHECK-NEXT:}
+
+fn main() {
+    let x = std::hint::black_box(3.0);
+    let y = std::hint::black_box(2.5);
+    let scalar = std::hint::black_box(1.0);
+    let (r1, r2, r3) = df(x, y, scalar);
+    // 3*3*1.5 = 22.5
+    assert_eq!(r1, 22.5);
+    // 2*x*y = 2*3*2.5 = 15.0
+    assert_eq!(r2, 15.0);
+    // x*x*1 = 3*3 = 9
+    assert_eq!(r3, 9.0);
+}
diff --git a/tests/codegen-llvm/autodiffv2.rs b/tests/codegen-llvm/autodiffv2.rs
new file mode 100644
index 00000000000..a40d19d3be3
--- /dev/null
+++ b/tests/codegen-llvm/autodiffv2.rs
@@ -0,0 +1,113 @@
+//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+//
+// In Enzyme, we test against a large range of LLVM versions (5+) and don't have overly many
+// breakages. One benefit is that we match the IR generated by Enzyme only after running it
+// through LLVM's O3 pipeline, which will remove most of the noise.
+// However, our integration test could also be affected by changes in how rustc lowers MIR into
+// LLVM-IR, which could cause additional noise and thus breakages. If that's the case, we should
+// reduce this test to only match the first lines and the ret instructions.
+//
+// The function tested here has 4 inputs and 5 outputs, so we could either call forward-mode
+// autodiff 4 times, or reverse mode 5 times. Since a forward-mode call is usually faster than
+// reverse mode, we prefer it here. This file also tests a new optimization (batch mode), which
+// allows us to call forward-mode autodiff only once, and get all 5 outputs in a single call.
+//
+// We support 2 different batch modes. `d_square2` has the same interface as scalar forward-mode,
+// but each shadow argument is `width` times larger (thus 16 and 20 elements here).
+// `d_square3` instead takes `width` (4) shadow arguments, which are all the same size as the
+// original function arguments.
+//
+// FIXME(autodiff): We currently can't test `d_square1` and `d_square3` in the same file, since they
+// generate the same dummy functions which get merged by LLVM, breaking pieces of our pipeline which
+// try to rewrite the dummy functions later. We should consider to change to pure declarations both
+// in our frontend and in the llvm backend to avoid these issues.
+
+#![feature(autodiff)]
+
+use std::autodiff::autodiff;
+
+#[no_mangle]
+//#[autodiff(d_square1, Forward, Dual, Dual)]
+#[autodiff(d_square2, Forward, 4, Dualv, Dualv)]
+#[autodiff(d_square3, Forward, 4, Dual, Dual)]
+fn square(x: &[f32], y: &mut [f32]) {
+    assert!(x.len() >= 4);
+    assert!(y.len() >= 5);
+    y[0] = 4.3 * x[0] + 1.2 * x[1] + 3.4 * x[2] + 2.1 * x[3];
+    y[1] = 2.3 * x[0] + 4.5 * x[1] + 1.7 * x[2] + 6.4 * x[3];
+    y[2] = 1.1 * x[0] + 3.3 * x[1] + 2.5 * x[2] + 4.7 * x[3];
+    y[3] = 5.2 * x[0] + 1.4 * x[1] + 2.6 * x[2] + 3.8 * x[3];
+    y[4] = 1.0 * x[0] + 2.0 * x[1] + 3.0 * x[2] + 4.0 * x[3];
+}
+
+fn main() {
+    let x1 = std::hint::black_box(vec![0.0, 1.0, 2.0, 3.0]);
+
+    let dx1 = std::hint::black_box(vec![1.0; 12]);
+
+    let z1 = std::hint::black_box(vec![1.0, 0.0, 0.0, 0.0]);
+    let z2 = std::hint::black_box(vec![0.0, 1.0, 0.0, 0.0]);
+    let z3 = std::hint::black_box(vec![0.0, 0.0, 1.0, 0.0]);
+    let z4 = std::hint::black_box(vec![0.0, 0.0, 0.0, 1.0]);
+
+    let z5 = std::hint::black_box(vec![
+        1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
+    ]);
+
+    let mut y1 = std::hint::black_box(vec![0.0; 5]);
+    let mut y2 = std::hint::black_box(vec![0.0; 5]);
+    let mut y3 = std::hint::black_box(vec![0.0; 5]);
+    let mut y4 = std::hint::black_box(vec![0.0; 5]);
+
+    let mut y5 = std::hint::black_box(vec![0.0; 5]);
+
+    let mut y6 = std::hint::black_box(vec![0.0; 5]);
+
+    let mut dy1_1 = std::hint::black_box(vec![0.0; 5]);
+    let mut dy1_2 = std::hint::black_box(vec![0.0; 5]);
+    let mut dy1_3 = std::hint::black_box(vec![0.0; 5]);
+    let mut dy1_4 = std::hint::black_box(vec![0.0; 5]);
+
+    let mut dy2 = std::hint::black_box(vec![0.0; 20]);
+
+    let mut dy3_1 = std::hint::black_box(vec![0.0; 5]);
+    let mut dy3_2 = std::hint::black_box(vec![0.0; 5]);
+    let mut dy3_3 = std::hint::black_box(vec![0.0; 5]);
+    let mut dy3_4 = std::hint::black_box(vec![0.0; 5]);
+
+    // scalar.
+    //d_square1(&x1, &z1, &mut y1, &mut dy1_1);
+    //d_square1(&x1, &z2, &mut y2, &mut dy1_2);
+    //d_square1(&x1, &z3, &mut y3, &mut dy1_3);
+    //d_square1(&x1, &z4, &mut y4, &mut dy1_4);
+
+    // assert y1 == y2 == y3 == y4
+    //for i in 0..5 {
+    //    assert_eq!(y1[i], y2[i]);
+    //    assert_eq!(y1[i], y3[i]);
+    //    assert_eq!(y1[i], y4[i]);
+    //}
+
+    // batch mode A)
+    d_square2(&x1, &z5, &mut y5, &mut dy2);
+
+    // assert y1 == y2 == y3 == y4 == y5
+    //for i in 0..5 {
+    //    assert_eq!(y1[i], y5[i]);
+    //}
+
+    // batch mode B)
+    d_square3(&x1, &z1, &z2, &z3, &z4, &mut y6, &mut dy3_1, &mut dy3_2, &mut dy3_3, &mut dy3_4);
+    for i in 0..5 {
+        assert_eq!(y5[i], y6[i]);
+    }
+
+    for i in 0..5 {
+        assert_eq!(dy2[0..5][i], dy3_1[i]);
+        assert_eq!(dy2[5..10][i], dy3_2[i]);
+        assert_eq!(dy2[10..15][i], dy3_3[i]);
+        assert_eq!(dy2[15..20][i], dy3_4[i]);
+    }
+}
diff --git a/tests/codegen-llvm/autovec/dont-shuffle-bswaps-opt2.rs b/tests/codegen-llvm/autovec/dont-shuffle-bswaps-opt2.rs
new file mode 100644
index 00000000000..c354228acc5
--- /dev/null
+++ b/tests/codegen-llvm/autovec/dont-shuffle-bswaps-opt2.rs
@@ -0,0 +1,31 @@
+//@ compile-flags: -Copt-level=2
+
+#![crate_type = "lib"]
+#![no_std]
+
+// This test is paired with the arch-specific -opt3.rs test.
+
+// The code is from https://github.com/rust-lang/rust/issues/122805.
+// Ensure we do not generate the shufflevector instruction
+// to avoid complicating the code.
+
+// CHECK-LABEL: define{{.*}}void @convert(
+// CHECK-NOT: shufflevector
+#[no_mangle]
+pub fn convert(value: [u16; 8]) -> [u8; 16] {
+    #[cfg(target_endian = "little")]
+    let bswap = u16::to_be;
+    #[cfg(target_endian = "big")]
+    let bswap = u16::to_le;
+    let addr16 = [
+        bswap(value[0]),
+        bswap(value[1]),
+        bswap(value[2]),
+        bswap(value[3]),
+        bswap(value[4]),
+        bswap(value[5]),
+        bswap(value[6]),
+        bswap(value[7]),
+    ];
+    unsafe { core::mem::transmute::<_, [u8; 16]>(addr16) }
+}
diff --git a/tests/codegen-llvm/autovec/dont-shuffle-bswaps-opt3.rs b/tests/codegen-llvm/autovec/dont-shuffle-bswaps-opt3.rs
new file mode 100644
index 00000000000..203d12005de
--- /dev/null
+++ b/tests/codegen-llvm/autovec/dont-shuffle-bswaps-opt3.rs
@@ -0,0 +1,42 @@
+//@ revisions: AARCH64 X86_64 Z13
+//@ compile-flags: -Copt-level=3
+//@[AARCH64] only-aarch64
+//@[X86_64] only-x86_64
+//@[Z13] only-s390x
+//@[Z13] compile-flags: -Ctarget-cpu=z13
+
+#![crate_type = "lib"]
+#![no_std]
+
+// This test is paired with the arch-neutral -opt2.rs test
+
+// The code is from https://github.com/rust-lang/rust/issues/122805.
+// Ensure we do not generate the shufflevector instruction
+// to avoid complicating the code.
+
+// CHECK-LABEL: define{{.*}}void @convert(
+// CHECK-NOT: shufflevector
+
+// On higher opt levels, this should just be a bswap:
+// CHECK: load <8 x i16>
+// CHECK-NEXT: call <8 x i16> @llvm.bswap
+// CHECK-NEXT: store <8 x i16>
+// CHECK-NEXT: ret void
+#[no_mangle]
+pub fn convert(value: [u16; 8]) -> [u8; 16] {
+    #[cfg(target_endian = "little")]
+    let bswap = u16::to_be;
+    #[cfg(target_endian = "big")]
+    let bswap = u16::to_le;
+    let addr16 = [
+        bswap(value[0]),
+        bswap(value[1]),
+        bswap(value[2]),
+        bswap(value[3]),
+        bswap(value[4]),
+        bswap(value[5]),
+        bswap(value[6]),
+        bswap(value[7]),
+    ];
+    unsafe { core::mem::transmute::<_, [u8; 16]>(addr16) }
+}
diff --git a/tests/codegen-llvm/autovectorize-f32x4.rs b/tests/codegen-llvm/autovectorize-f32x4.rs
new file mode 100644
index 00000000000..254362842f9
--- /dev/null
+++ b/tests/codegen-llvm/autovectorize-f32x4.rs
@@ -0,0 +1,37 @@
+//@ compile-flags: -C opt-level=3 -Z merge-functions=disabled
+//@ only-x86_64
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @auto_vectorize_direct
+#[no_mangle]
+pub fn auto_vectorize_direct(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
+    // CHECK: load <4 x float>
+    // CHECK: load <4 x float>
+    // CHECK: fadd <4 x float>
+    // CHECK: store <4 x float>
+    [a[0] + b[0], a[1] + b[1], a[2] + b[2], a[3] + b[3]]
+}
+
+// CHECK-LABEL: @auto_vectorize_loop
+#[no_mangle]
+pub fn auto_vectorize_loop(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
+    // CHECK: load <4 x float>
+    // CHECK: load <4 x float>
+    // CHECK: fadd <4 x float>
+    // CHECK: store <4 x float>
+    let mut c = [0.0; 4];
+    for i in 0..4 {
+        c[i] = a[i] + b[i];
+    }
+    c
+}
+
+// CHECK-LABEL: @auto_vectorize_array_from_fn
+#[no_mangle]
+pub fn auto_vectorize_array_from_fn(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
+    // CHECK: load <4 x float>
+    // CHECK: load <4 x float>
+    // CHECK: fadd <4 x float>
+    // CHECK: store <4 x float>
+    std::array::from_fn(|i| a[i] + b[i])
+}
diff --git a/tests/codegen-llvm/auxiliary/extern_decl.rs b/tests/codegen-llvm/auxiliary/extern_decl.rs
new file mode 100644
index 00000000000..d17e77b1444
--- /dev/null
+++ b/tests/codegen-llvm/auxiliary/extern_decl.rs
@@ -0,0 +1,13 @@
+// Auxiliary crate that exports a function and static. Both always
+// evaluate to `71`. We force mutability on the static to prevent
+// it from being inlined as constant.
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn extern_fn() -> u8 {
+    unsafe { extern_static }
+}
+
+#[no_mangle]
+pub static mut extern_static: u8 = 71;
diff --git a/tests/codegen-llvm/auxiliary/nounwind.rs b/tests/codegen-llvm/auxiliary/nounwind.rs
new file mode 100644
index 00000000000..40f66442c6e
--- /dev/null
+++ b/tests/codegen-llvm/auxiliary/nounwind.rs
@@ -0,0 +1,2 @@
+#[no_mangle]
+pub fn bar() {}
diff --git a/tests/codegen-llvm/auxiliary/thread_local_aux.rs b/tests/codegen-llvm/auxiliary/thread_local_aux.rs
new file mode 100644
index 00000000000..bebaa7754dd
--- /dev/null
+++ b/tests/codegen-llvm/auxiliary/thread_local_aux.rs
@@ -0,0 +1,5 @@
+#![crate_type = "lib"]
+
+use std::cell::Cell;
+
+thread_local!(pub static A: Cell<u64> = const { Cell::new(0) });
diff --git a/tests/codegen-llvm/avr/avr-func-addrspace.rs b/tests/codegen-llvm/avr/avr-func-addrspace.rs
new file mode 100644
index 00000000000..e0192f8b45a
--- /dev/null
+++ b/tests/codegen-llvm/avr/avr-func-addrspace.rs
@@ -0,0 +1,106 @@
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 --target=avr-none -C target-cpu=atmega328p --crate-type=rlib -C panic=abort
+//@ needs-llvm-components: avr
+
+// This test validates that function pointers can be stored in global variables
+// and called upon. It ensures that Rust emits function pointers in the correct
+// address space to LLVM so that an assertion error relating to casting is
+// not triggered.
+//
+// It also validates that functions can be called through function pointers
+// through traits.
+
+#![feature(no_core, lang_items, intrinsics, unboxed_closures, arbitrary_self_types)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[rustc_intrinsic]
+pub unsafe fn transmute<Src, Dst>(src: Src) -> Dst;
+
+pub static mut STORAGE_FOO: fn(&usize, &mut u32) -> Result<(), ()> = arbitrary_black_box;
+pub static mut STORAGE_BAR: u32 = 12;
+
+fn arbitrary_black_box(ptr: &usize, _: &mut u32) -> Result<(), ()> {
+    let raw_ptr = ptr as *const usize;
+    let _v: usize = unsafe { *raw_ptr };
+    loop {}
+}
+
+#[inline(never)]
+#[no_mangle]
+fn call_through_fn_trait(a: &mut impl Fn<(), Output = ()>) {
+    (*a)()
+}
+
+#[inline(never)]
+fn update_bar_value() {
+    unsafe {
+        STORAGE_BAR = 88;
+    }
+}
+
+// CHECK: define dso_local void @test(){{.+}}addrspace(1)
+#[no_mangle]
+pub extern "C" fn test() {
+    let mut buf = 7;
+
+    // A call through the Fn trait must use address space 1.
+    //
+    // CHECK: call{{.+}}addrspace(1) void @call_through_fn_trait({{.*}})
+    call_through_fn_trait(&mut update_bar_value);
+
+    // A call through a global variable must use address space 1.
+    // CHECK: load {{.*}}addrspace(1){{.+}}FOO
+    unsafe {
+        STORAGE_FOO(&1, &mut buf);
+    }
+}
+
+// Validate that we can codegen transmutes between data ptrs and fn ptrs.
+
+// CHECK: define{{.+}}ptr addrspace(1) @transmute_data_ptr_to_fn(ptr{{.*}} %x)
+#[no_mangle]
+pub unsafe fn transmute_data_ptr_to_fn(x: *const ()) -> fn() {
+    // It doesn't matter precisely how this is codegenned (through memory or an addrspacecast),
+    // as long as it doesn't cause a verifier error by using `bitcast`.
+    transmute(x)
+}
+
+// CHECK: define{{.+}}ptr @transmute_fn_ptr_to_data(ptr addrspace(1){{.*}} %x)
+#[no_mangle]
+pub unsafe fn transmute_fn_ptr_to_data(x: fn()) -> *const () {
+    // It doesn't matter precisely how this is codegenned (through memory or an addrspacecast),
+    // as long as it doesn't cause a verifier error by using `bitcast`.
+    transmute(x)
+}
+
+pub enum Either<T, U> {
+    A(T),
+    B(U),
+}
+
+// Previously, we would codegen this as passing/returning a scalar pair of `{ i8, ptr }`,
+// with the `ptr` field representing both `&i32` and `fn()` depending on the variant.
+// This is incorrect, because `fn()` should be `ptr addrspace(1)`, not `ptr`.
+
+// CHECK: define{{.+}}void @should_not_combine_addrspace(ptr{{.+}}sret{{.+}}%_0, ptr{{.+}}%x)
+#[no_mangle]
+#[inline(never)]
+pub fn should_not_combine_addrspace(x: Either<&i32, fn()>) -> Either<&i32, fn()> {
+    x
+}
+
+// The incorrectness described above would result in us producing (after optimizations)
+// a `ptrtoint`/`inttoptr` roundtrip to convert from `ptr` to `ptr addrspace(1)`.
+
+// CHECK-LABEL: @call_with_fn_ptr
+#[no_mangle]
+pub fn call_with_fn_ptr<'a>(f: fn()) -> Either<&'a i32, fn()> {
+    // CHECK-NOT: ptrtoint
+    // CHECK-NOT: inttoptr
+    // CHECK: call addrspace(1) void @should_not_combine_addrspace
+    should_not_combine_addrspace(Either::B(f))
+}
diff --git a/tests/codegen-llvm/bigint-helpers.rs b/tests/codegen-llvm/bigint-helpers.rs
new file mode 100644
index 00000000000..355cccb8150
--- /dev/null
+++ b/tests/codegen-llvm/bigint-helpers.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -C opt-level=3
+
+#![crate_type = "lib"]
+#![feature(bigint_helper_methods)]
+
+// CHECK-LABEL: @u32_carrying_add
+#[no_mangle]
+pub fn u32_carrying_add(a: u32, b: u32, c: bool) -> (u32, bool) {
+    // CHECK: @llvm.uadd.with.overflow.i32
+    // CHECK: @llvm.uadd.with.overflow.i32
+    // CHECK: or disjoint i1
+    u32::carrying_add(a, b, c)
+}
diff --git a/tests/codegen-llvm/binary-heap-peek-mut-pop-no-panic.rs b/tests/codegen-llvm/binary-heap-peek-mut-pop-no-panic.rs
new file mode 100644
index 00000000000..2c40327f624
--- /dev/null
+++ b/tests/codegen-llvm/binary-heap-peek-mut-pop-no-panic.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -Copt-level=3
+//@ ignore-std-debug-assertions
+#![crate_type = "lib"]
+
+use std::collections::binary_heap::PeekMut;
+
+// CHECK-LABEL: @peek_mut_pop
+#[no_mangle]
+pub fn peek_mut_pop(peek_mut: PeekMut<u32>) -> u32 {
+    // CHECK-NOT: panic
+    // CHECK-NOT: unwrap_failed
+    PeekMut::pop(peek_mut)
+}
diff --git a/tests/codegen-llvm/binary-search-index-no-bound-check.rs b/tests/codegen-llvm/binary-search-index-no-bound-check.rs
new file mode 100644
index 00000000000..d59c0beec64
--- /dev/null
+++ b/tests/codegen-llvm/binary-search-index-no-bound-check.rs
@@ -0,0 +1,35 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// Make sure no bounds checks are emitted when slicing or indexing
+// with an index from `binary_search`.
+
+// CHECK-LABEL: @binary_search_index_no_bounds_check
+#[no_mangle]
+pub fn binary_search_index_no_bounds_check(s: &[u8]) -> u8 {
+    // CHECK-NOT: panic
+    // CHECK-NOT: slice_start_index_len_fail
+    // CHECK-NOT: slice_end_index_len_fail
+    // CHECK-NOT: panic_bounds_check
+    if let Ok(idx) = s.binary_search(&b'\\') { s[idx] } else { 42 }
+}
+
+// Similarly, check that `partition_point` is known to return a valid fencepost.
+
+// CHECK-LABEL: @unknown_split
+#[no_mangle]
+pub fn unknown_split(x: &[i32], i: usize) -> (&[i32], &[i32]) {
+    // This just makes sure that the subsequent function is looking for the
+    // absence of something that might actually be there.
+
+    // CHECK: call core::panicking::panic
+    x.split_at(i)
+}
+
+// CHECK-LABEL: @partition_point_split_no_bounds_check
+#[no_mangle]
+pub fn partition_point_split_no_bounds_check(x: &[i32], needle: i32) -> (&[i32], &[i32]) {
+    // CHECK-NOT: call core::panicking::panic
+    let i = x.partition_point(|p| p < &needle);
+    x.split_at(i)
+}
diff --git a/tests/codegen-llvm/bool-cmp.rs b/tests/codegen-llvm/bool-cmp.rs
new file mode 100644
index 00000000000..71d3411689f
--- /dev/null
+++ b/tests/codegen-llvm/bool-cmp.rs
@@ -0,0 +1,18 @@
+// This is a test for optimal Ord trait implementation for bool.
+// See <https://github.com/rust-lang/rust/issues/66780> for more info.
+
+//@ compile-flags: -C opt-level=3
+
+#![crate_type = "lib"]
+
+use std::cmp::Ordering;
+
+// CHECK-LABEL: @cmp_bool
+#[no_mangle]
+pub fn cmp_bool(a: bool, b: bool) -> Ordering {
+    // LLVM 10 produces (zext a) + (sext b), but the final lowering is (zext a) - (zext b).
+    // CHECK: zext i1
+    // CHECK: {{z|s}}ext i1
+    // CHECK: {{sub|add}} nsw
+    a.cmp(&b)
+}
diff --git a/tests/codegen-llvm/bounds-checking/gep-issue-133979.rs b/tests/codegen-llvm/bounds-checking/gep-issue-133979.rs
new file mode 100644
index 00000000000..876bdbfb0e1
--- /dev/null
+++ b/tests/codegen-llvm/bounds-checking/gep-issue-133979.rs
@@ -0,0 +1,22 @@
+//! Issue: <https://github.com/rust-lang/rust/issues/133979>
+//! Check that bounds checking are eliminated.
+
+//@ compile-flags: -Copt-level=2
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @test(
+#[no_mangle]
+fn test(a: &[&[u8]]) -> u32 {
+    // CHECK-NOT: panic_bounds_check
+    a.iter()
+        .enumerate()
+        .map(|(y, b)| {
+            b.iter()
+                .enumerate()
+                .filter(|(_, c)| **c == b'A')
+                .map(|(x, _)| a[y][x] as u32)
+                .sum::<u32>()
+        })
+        .sum()
+}
diff --git a/tests/codegen-llvm/box-default-debug-copies.rs b/tests/codegen-llvm/box-default-debug-copies.rs
new file mode 100644
index 00000000000..06cc41b21c0
--- /dev/null
+++ b/tests/codegen-llvm/box-default-debug-copies.rs
@@ -0,0 +1,28 @@
+//@ compile-flags: -Copt-level=0
+
+// Test to make sure that `<Box<T>>::default` does not create too many copies of `T` on the stack.
+// in debug mode. This regressed in dd0620b86721ae8cae86736443acd3f72ba6fc32 to
+// four `T` allocas.
+//
+// See https://github.com/rust-lang/rust/issues/136043 for more context.
+//
+// FIXME: This test only wants to ensure that there are at most two allocas of `T` created, instead
+// of checking for exactly two.
+
+#![crate_type = "lib"]
+
+#[allow(dead_code)]
+pub struct Thing([u8; 1000000]);
+
+impl Default for Thing {
+    fn default() -> Self {
+        Thing([0; 1000000])
+    }
+}
+
+// CHECK-COUNT-2: %{{.*}} = alloca {{.*}}1000000
+// CHECK-NOT: %{{.*}} = alloca {{.*}}1000000
+#[no_mangle]
+pub fn box_default_single_copy() -> Box<Thing> {
+    Box::default()
+}
diff --git a/tests/codegen-llvm/box-uninit-bytes.rs b/tests/codegen-llvm/box-uninit-bytes.rs
new file mode 100644
index 00000000000..0cc01148595
--- /dev/null
+++ b/tests/codegen-llvm/box-uninit-bytes.rs
@@ -0,0 +1,46 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+use std::mem::MaybeUninit;
+
+// Boxing a `MaybeUninit` value should not copy junk from the stack
+#[no_mangle]
+pub fn box_uninitialized() -> Box<MaybeUninit<usize>> {
+    // CHECK-LABEL: @box_uninitialized
+    // CHECK-NOT: store
+    // CHECK-NOT: alloca
+    // CHECK-NOT: memcpy
+    // CHECK-NOT: memset
+    Box::new(MaybeUninit::uninit())
+}
+
+// https://github.com/rust-lang/rust/issues/58201
+#[no_mangle]
+pub fn box_uninitialized2() -> Box<MaybeUninit<[usize; 1024 * 1024]>> {
+    // CHECK-LABEL: @box_uninitialized2
+    // CHECK-NOT: store
+    // CHECK-NOT: alloca
+    // CHECK-NOT: memcpy
+    // CHECK-NOT: memset
+    Box::new(MaybeUninit::uninit())
+}
+
+#[repr(align(1024))]
+pub struct LotsaPadding(usize);
+
+// Boxing a value with padding should not copy junk from the stack
+#[no_mangle]
+pub fn box_lotsa_padding() -> Box<LotsaPadding> {
+    // CHECK-LABEL: @box_lotsa_padding
+    // CHECK-NOT: alloca
+    // CHECK-NOT: getelementptr
+    // CHECK-NOT: memcpy
+    // CHECK-NOT: memset
+    Box::new(LotsaPadding(42))
+}
+
+// Hide the `allocalign` attribute in the declaration of __rust_alloc
+// from the CHECK-NOT above, and also verify the attributes got set reasonably.
+// CHECK: declare {{(dso_local )?}}noalias noundef ptr @{{.*}}__rust_alloc(i{{[0-9]+}} noundef, i{{[0-9]+}} allocalign noundef) unnamed_addr [[RUST_ALLOC_ATTRS:#[0-9]+]]
+
+// CHECK-DAG: attributes [[RUST_ALLOC_ATTRS]] = { {{.*}} allockind("alloc,uninitialized,aligned") allocsize(0) {{(uwtable )?}}"alloc-family"="__rust_alloc" {{.*}} }
diff --git a/tests/codegen-llvm/bpf-alu32.rs b/tests/codegen-llvm/bpf-alu32.rs
new file mode 100644
index 00000000000..5955bf3317f
--- /dev/null
+++ b/tests/codegen-llvm/bpf-alu32.rs
@@ -0,0 +1,11 @@
+//@ only-bpf
+#![crate_type = "lib"]
+#![feature(bpf_target_feature)]
+#![no_std]
+
+#[no_mangle]
+#[target_feature(enable = "alu32")]
+// CHECK: define i8 @foo(i8 returned %arg) unnamed_addr #0 {
+pub unsafe fn foo(arg: u8) -> u8 {
+    arg
+}
diff --git a/tests/codegen-llvm/branch-protection.rs b/tests/codegen-llvm/branch-protection.rs
new file mode 100644
index 00000000000..d67e494cc0d
--- /dev/null
+++ b/tests/codegen-llvm/branch-protection.rs
@@ -0,0 +1,94 @@
+// Test that the correct module flags are emitted with different branch protection flags.
+
+//@ add-core-stubs
+//@ revisions: BTI PACRET LEAF BKEY PAUTHLR PAUTHLR_BKEY PAUTHLR_LEAF PAUTHLR_BTI NONE
+//@ needs-llvm-components: aarch64
+//@ [BTI] compile-flags: -Z branch-protection=bti
+//@ [PACRET] compile-flags: -Z branch-protection=pac-ret
+//@ [LEAF] compile-flags: -Z branch-protection=pac-ret,leaf
+//@ [BKEY] compile-flags: -Z branch-protection=pac-ret,b-key
+//@ [PAUTHLR] compile-flags: -Z branch-protection=pac-ret,pc
+//@ [PAUTHLR_BKEY] compile-flags: -Z branch-protection=pac-ret,pc,b-key
+//@ [PAUTHLR_LEAF] compile-flags: -Z branch-protection=pac-ret,pc,leaf
+//@ [PAUTHLR_BTI] compile-flags: -Z branch-protection=bti,pac-ret,pc
+//@ compile-flags: --target aarch64-unknown-linux-gnu
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// A basic test function.
+// CHECK: @test(){{.*}} [[ATTR:#[0-9]+]] {
+#[no_mangle]
+pub fn test() {}
+
+// BTI: attributes [[ATTR]] = {{.*}} "branch-target-enforcement"
+// BTI: !"branch-target-enforcement", i32 1
+// BTI: !"sign-return-address", i32 0
+// BTI: !"branch-protection-pauth-lr", i32 0
+// BTI: !"sign-return-address-all", i32 0
+// BTI: !"sign-return-address-with-bkey", i32 0
+
+// PACRET: attributes [[ATTR]] = {{.*}} "sign-return-address"="non-leaf"
+// PACRET-SAME: "sign-return-address-key"="a_key"
+// PACRET: !"branch-target-enforcement", i32 0
+// PACRET: !"sign-return-address", i32 1
+// PACRET: !"branch-protection-pauth-lr", i32 0
+// PACRET: !"sign-return-address-all", i32 0
+// PACRET: !"sign-return-address-with-bkey", i32 0
+
+// LEAF: attributes [[ATTR]] = {{.*}} "sign-return-address"="all"
+// LEAF-SAME: "sign-return-address-key"="a_key"
+// LEAF: !"branch-target-enforcement", i32 0
+// LEAF: !"sign-return-address", i32 1
+// LEAF: !"branch-protection-pauth-lr", i32 0
+// LEAF: !"sign-return-address-all", i32 1
+// LEAF: !"sign-return-address-with-bkey", i32 0
+
+// BKEY: attributes [[ATTR]] = {{.*}} "sign-return-address"="non-leaf"
+// BKEY-SAME: "sign-return-address-key"="b_key"
+// BKEY: !"branch-target-enforcement", i32 0
+// BKEY: !"sign-return-address", i32 1
+// BKEY: !"branch-protection-pauth-lr", i32 0
+// BKEY: !"sign-return-address-all", i32 0
+// BKEY: !"sign-return-address-with-bkey", i32 1
+
+// PAUTHLR: attributes [[ATTR]] = {{.*}} "sign-return-address"="non-leaf"
+// PAUTHLR-SAME: "sign-return-address-key"="a_key"
+// PAUTHLR: !"branch-target-enforcement", i32 0
+// PAUTHLR: !"sign-return-address", i32 1
+// PAUTHLR: !"branch-protection-pauth-lr", i32 1
+// PAUTHLR: !"sign-return-address-all", i32 0
+// PAUTHLR: !"sign-return-address-with-bkey", i32 0
+
+// PAUTHLR_BKEY: attributes [[ATTR]] = {{.*}} "sign-return-address"="non-leaf"
+// PAUTHLR_BKEY-SAME: "sign-return-address-key"="b_key"
+// PAUTHLR_BKEY: !"branch-target-enforcement", i32 0
+// PAUTHLR_BKEY: !"sign-return-address", i32 1
+// PAUTHLR_BKEY: !"branch-protection-pauth-lr", i32 1
+// PAUTHLR_BKEY: !"sign-return-address-all", i32 0
+// PAUTHLR_BKEY: !"sign-return-address-with-bkey", i32 1
+
+// PAUTHLR_LEAF: attributes [[ATTR]] = {{.*}} "sign-return-address"="all"
+// PAUTHLR_LEAF-SAME: "sign-return-address-key"="a_key"
+// PAUTHLR_LEAF: !"branch-target-enforcement", i32 0
+// PAUTHLR_LEAF: !"sign-return-address", i32 1
+// PAUTHLR_LEAF: !"branch-protection-pauth-lr", i32 1
+// PAUTHLR_LEAF: !"sign-return-address-all", i32 1
+// PAUTHLR_LEAF: !"sign-return-address-with-bkey", i32 0
+
+// PAUTHLR_BTI: attributes [[ATTR]] = {{.*}} "sign-return-address"="non-leaf"
+// PAUTHLR_BTI-SAME: "sign-return-address-key"="a_key"
+// PAUTHLR_BTI: !"branch-target-enforcement", i32 1
+// PAUTHLR_BTI: !"sign-return-address", i32 1
+// PAUTHLR_BTI: !"branch-protection-pauth-lr", i32 1
+// PAUTHLR_BTI: !"sign-return-address-all", i32 0
+// PAUTHLR_BTI: !"sign-return-address-with-bkey", i32 0
+
+// NONE-NOT: branch-target-enforcement
+// NONE-NOT: sign-return-address
+// NONE-NOT: sign-return-address-all
+// NONE-NOT: sign-return-address-with-bkey
diff --git a/tests/codegen-llvm/call-llvm-intrinsics.rs b/tests/codegen-llvm/call-llvm-intrinsics.rs
new file mode 100644
index 00000000000..dc7e0249cb6
--- /dev/null
+++ b/tests/codegen-llvm/call-llvm-intrinsics.rs
@@ -0,0 +1,30 @@
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+
+//@ ignore-riscv64
+//@ ignore-loongarch64
+
+#![feature(link_llvm_intrinsics)]
+#![crate_type = "lib"]
+
+struct A;
+
+impl Drop for A {
+    fn drop(&mut self) {
+        println!("A");
+    }
+}
+
+extern "C" {
+    #[link_name = "llvm.sqrt.f32"]
+    fn sqrt(x: f32) -> f32;
+}
+
+pub fn do_call() {
+    let _a = A;
+
+    unsafe {
+        // Ensure that we `call` LLVM intrinsics instead of trying to `invoke` them
+        // CHECK: call float @llvm.sqrt.f32(float 4.000000e+00
+        sqrt(4.0);
+    }
+}
diff --git a/tests/codegen-llvm/call-tmps-lifetime.rs b/tests/codegen-llvm/call-tmps-lifetime.rs
new file mode 100644
index 00000000000..7b7b6e17bdd
--- /dev/null
+++ b/tests/codegen-llvm/call-tmps-lifetime.rs
@@ -0,0 +1,68 @@
+// Test that temporary allocas used for call arguments have their lifetimes described by
+// intrinsics.
+//
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=1 -Cno-prepopulate-passes --crate-type=lib --target i686-unknown-linux-gnu
+//@ needs-llvm-components: x86
+#![feature(no_core)]
+#![no_std]
+#![no_core]
+extern crate minicore;
+use minicore::*;
+
+// Const operand. Regression test for #98156.
+//
+// CHECK-LABEL: define void @const_indirect(
+// CHECK-NEXT: start:
+// CHECK-NEXT: [[B:%.*]] = alloca
+// CHECK-NEXT: [[A:%.*]] = alloca
+// CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4096, ptr [[A]])
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[A]], ptr align 4 {{.*}}, i32 4096, i1 false)
+// CHECK-NEXT: call void %h(ptr {{.*}} [[A]])
+// CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4096, ptr [[A]])
+// CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4096, ptr [[B]])
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[B]], ptr align 4 {{.*}}, i32 4096, i1 false)
+// CHECK-NEXT: call void %h(ptr {{.*}} [[B]])
+// CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4096, ptr [[B]])
+#[no_mangle]
+pub fn const_indirect(h: extern "C" fn([u32; 1024])) {
+    const C: [u32; 1024] = [0; 1024];
+    h(C);
+    h(C);
+}
+
+#[repr(C)]
+pub struct Str {
+    pub ptr: *const u8,
+    pub len: usize,
+}
+
+// Pair of immediates. Regression test for #132014.
+//
+// CHECK-LABEL: define void @immediate_indirect(ptr {{.*}}%s.0, i32 {{.*}}%s.1, ptr {{.*}}%g)
+// CHECK-NEXT: start:
+// CHECK-NEXT: [[A:%.*]] = alloca
+// CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 8, ptr [[A]])
+// CHECK-NEXT: store ptr %s.0, ptr [[A]]
+// CHECK-NEXT: [[B:%.]] = getelementptr inbounds i8, ptr [[A]], i32 4
+// CHECK-NEXT: store i32 %s.1, ptr [[B]]
+// CHECK-NEXT: call void %g(ptr {{.*}} [[A]])
+// CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 8, ptr [[A]])
+#[no_mangle]
+pub fn immediate_indirect(s: Str, g: extern "C" fn(Str)) {
+    g(s);
+}
+
+// Indirect argument with a higher alignment requirement than the type's.
+//
+// CHECK-LABEL: define void @align_indirect(ptr{{.*}} align 1{{.*}} %a, ptr{{.*}} %fun)
+// CHECK-NEXT: start:
+// CHECK-NEXT: [[A:%.*]] = alloca [1024 x i8], align 4
+// CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 1024, ptr [[A]])
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[A]], ptr align 1 %a, i32 1024, i1 false)
+// CHECK-NEXT: call void %fun(ptr {{.*}} [[A]])
+// CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 1024, ptr [[A]])
+#[no_mangle]
+pub fn align_indirect(a: [u8; 1024], fun: extern "C" fn([u8; 1024])) {
+    fun(a);
+}
diff --git a/tests/codegen-llvm/cast-optimized.rs b/tests/codegen-llvm/cast-optimized.rs
new file mode 100644
index 00000000000..11220c4a922
--- /dev/null
+++ b/tests/codegen-llvm/cast-optimized.rs
@@ -0,0 +1,33 @@
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+#![crate_type = "lib"]
+
+// This tests that LLVM can optimize based on the niches in the source or
+// destination types for casts.
+
+// CHECK-LABEL: @u32_index
+#[no_mangle]
+pub fn u32_index(c: u32) -> [bool; 22] {
+    let mut array = [false; 22];
+
+    let index = 32 - c.leading_zeros();
+
+    // CHECK: call core::panicking::panic
+    array[index as usize] = true;
+
+    array
+}
+
+// CHECK-LABEL: @char_as_u32_index
+#[no_mangle]
+pub fn char_as_u32_index(c: char) -> [bool; 22] {
+    let c = c as u32;
+
+    let mut array = [false; 22];
+
+    let index = 32 - c.leading_zeros();
+
+    // CHECK-NOT: call core::panicking::panic
+    array[index as usize] = true;
+
+    array
+}
diff --git a/tests/codegen-llvm/cast-target-abi.rs b/tests/codegen-llvm/cast-target-abi.rs
new file mode 100644
index 00000000000..cbd49e2f022
--- /dev/null
+++ b/tests/codegen-llvm/cast-target-abi.rs
@@ -0,0 +1,599 @@
+// ignore-tidy-linelength
+//@ add-core-stubs
+//@ revisions:aarch64 loongarch64 powerpc64 sparc64 x86_64
+//@ compile-flags: -Copt-level=3 -Cno-prepopulate-passes -Zlint-llvm-ir
+
+//@[aarch64] compile-flags: --target aarch64-unknown-linux-gnu
+//@[aarch64] needs-llvm-components: arm
+//@[loongarch64] compile-flags: --target loongarch64-unknown-linux-gnu
+//@[loongarch64] needs-llvm-components: loongarch
+//@[powerpc64] compile-flags: --target powerpc64-unknown-linux-gnu
+//@[powerpc64] needs-llvm-components: powerpc
+//@[sparc64] compile-flags: --target sparc64-unknown-linux-gnu
+//@[sparc64] needs-llvm-components: sparc
+//@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu
+//@[x86_64] needs-llvm-components: x86
+
+// Tests that arguments with `PassMode::Cast` are handled correctly.
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// This struct will be passed as a single `i64` or `i32`.
+// This may be (if `i64)) larger than the Rust layout, which is just `{ i16, i16 }`.
+#[repr(C)]
+pub struct TwoU16s {
+    a: u16,
+    b: u16,
+}
+
+// This struct will be passed as `[2 x i64]`.
+// This is larger than the Rust layout.
+#[repr(C)]
+pub struct FiveU16s {
+    a: u16,
+    b: u16,
+    c: u16,
+    d: u16,
+    e: u16,
+}
+
+// This struct will be passed as `[2 x double]`.
+// This is the same as the Rust layout.
+#[repr(C)]
+pub struct DoubleDouble {
+    f: f64,
+    g: f64,
+}
+
+// On loongarch, this struct will be passed as `{ double, float }`.
+// This is smaller than the Rust layout, which has trailing padding (`{ f64, f32, <f32 padding> }`)
+#[repr(C)]
+pub struct DoubleFloat {
+    f: f64,
+    g: f32,
+}
+
+// On x86_64, this struct will be passed as `{ i64, i32 }`.
+// The load and store instructions will access 16 bytes, so we should allocate 16 bytes.
+#[repr(C)]
+pub struct Three32s {
+    a: u32,
+    b: u32,
+    c: u32,
+}
+
+// CHECK-LABEL: @receives_twou16s
+// aarch64-SAME:     ([[ABI_TYPE:i64]] {{.*}}[[ABI_VALUE:%.+]])
+// loongarch64-SAME: ([[ABI_TYPE:i64]] {{.*}}[[ABI_VALUE:%.+]])
+// powerpc64-SAME:   ([[ABI_TYPE:i32]] {{.*}}[[ABI_VALUE:%.+]])
+// sparc64-SAME:     ([[ABI_TYPE:i64]] {{.*}}[[ABI_VALUE:%.+]])
+// x86_64-SAME:      ([[ABI_TYPE:i32]] {{.*}}[[ABI_VALUE:%.+]])
+#[no_mangle]
+#[inline(never)]
+pub extern "C" fn receives_twou16s(x: TwoU16s) {
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
+    // powerpc64:   [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:4]]
+    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:4]]
+
+    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
+
+    // CHECK: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 4, i1 false)
+}
+
+// CHECK-LABEL: @returns_twou16s
+// powerpc64-SAME: sret([4 x i8]) align [[RUST_ALIGN:2]] {{.*}}[[RET_PTR:%.*]])
+#[no_mangle]
+#[inline(never)]
+pub extern "C" fn returns_twou16s() -> TwoU16s {
+    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
+    // The other targets copy the cast ABI type to an alloca.
+
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:2]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:2]]
+    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:2]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:2]]
+
+    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i32]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // loongarch64: ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // sparc64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // x86_64:      ret [[ABI_TYPE]] [[ABI_VALUE]]
+    TwoU16s { a: 0, b: 1 }
+}
+
+// CHECK-LABEL: @receives_fiveu16s
+// aarch64-SAME:     ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
+// loongarch64-SAME: ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
+// powerpc64-SAME:   ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
+// sparc64-SAME:     ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
+// x86_64-SAME:      ([[ABI_TYPE:{ i64, i16 }]] {{.*}}[[ABI_VALUE:%.+]])
+#[no_mangle]
+#[inline(never)]
+pub extern "C" fn receives_fiveu16s(x: FiveU16s) {
+    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [10 x i8], align [[RUST_ALIGN:2]]
+
+    // CHECK: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 10, i1 false)
+}
+
+// CHECK-LABEL: @returns_fiveu16s
+// powerpc64-SAME: sret([10 x i8]) align [[RUST_ALIGN:2]] {{.*}}[[RET_PTR:%.*]])
+#[no_mangle]
+#[inline(never)]
+pub extern "C" fn returns_fiveu16s() -> FiveU16s {
+    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
+    // The other targets copy the cast ABI type to an alloca.
+
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:2]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:2]]
+    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:2]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:2]]
+
+    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ i64, i16 }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // loongarch64: ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // sparc64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // x86_64:      ret [[ABI_TYPE]] [[ABI_VALUE]]
+    FiveU16s { a: 0, b: 1, c: 2, d: 3, e: 4 }
+}
+
+// CHECK-LABEL: @receives_doubledouble
+// aarch64-SAME:     ([[ABI_TYPE:\[2 x double\]]] {{.*}}[[ABI_VALUE:%.+]])
+// loongarch64-SAME: ([[ABI_TYPE:{ double, double }]] {{.*}}[[ABI_VALUE:%.+]])
+// powerpc64-SAME:   ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
+// sparc64-SAME:     ([[ABI_TYPE:{ double, double }]] {{.*}}[[ABI_VALUE:%.+]])
+// x86_64-SAME:      ([[ABI_TYPE:{ double, double }]] {{.*}}[[ABI_VALUE:%.+]])
+#[no_mangle]
+#[inline(never)]
+pub extern "C" fn receives_doubledouble(x: DoubleDouble) {
+    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+
+    // CHECK: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
+}
+
+// CHECK-LABEL: @returns_doubledouble
+// powerpc64-SAME: sret([16 x i8]) align [[RUST_ALIGN:8]] {{.*}}[[RET_PTR:%.*]])
+#[no_mangle]
+#[inline(never)]
+pub extern "C" fn returns_doubledouble() -> DoubleDouble {
+    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
+    // The other targets copy the cast ABI type to an alloca.
+
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x double\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // loongarch64: ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // sparc64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // x86_64:      ret [[ABI_TYPE]] [[ABI_VALUE]]
+    DoubleDouble { f: 0., g: 1. }
+}
+
+// CHECK-LABEL: @receives_three32s
+// aarch64-SAME:     ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
+// loongarch64-SAME: ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
+// powerpc64-SAME:   ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
+// sparc64-SAME:     ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
+// x86_64-SAME:      ([[ABI_TYPE:{ i64, i32 }]] {{.*}}[[ABI_VALUE:%.+]])
+#[no_mangle]
+#[inline(never)]
+pub extern "C" fn receives_three32s(x: Three32s) {
+    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [12 x i8], align [[RUST_ALIGN:4]]
+
+    // CHECK: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
+}
+
+// CHECK-LABEL: @returns_three32s
+// powerpc64-SAME: sret([12 x i8]) align [[RUST_ALIGN:4]] {{.*}}[[RET_PTR:%.*]])
+#[no_mangle]
+#[inline(never)]
+pub extern "C" fn returns_three32s() -> Three32s {
+    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
+    // The other targets copy the cast ABI type to an alloca.
+
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:4]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:4]]
+    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:4]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:4]]
+
+    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ i64, i32 }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // loongarch64: ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // sparc64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // x86_64:      ret [[ABI_TYPE]] [[ABI_VALUE]]
+    Three32s { a: 0, b: 0, c: 0 }
+}
+
+// These functions cause an ICE in sparc64 ABI code (https://github.com/rust-lang/rust/issues/122620)
+#[cfg(not(target_arch = "sparc64"))]
+// aarch64-LABEL:     @receives_doublefloat
+// loongarch64-LABEL: @receives_doublefloat
+// powerpc64-LABEL:   @receives_doublefloat
+// x86_64-LABEL:      @receives_doublefloat
+
+// aarch64-SAME:     ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
+// loongarch64-SAME: ([[ABI_TYPE:{ double, float }]] {{.*}}[[ABI_VALUE:%.+]])
+// powerpc64-SAME:   ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
+// x86_64-SAME:      ([[ABI_TYPE:{ double, double }]] {{.*}}[[ABI_VALUE:%.+]])
+#[no_mangle]
+#[inline(never)]
+pub extern "C" fn receives_doublefloat(x: DoubleFloat) {
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // powerpc64:   [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // aarch64:     [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+    // loongarch64: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+    // powerpc64:   [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+    // x86_64:      [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+
+    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // powerpc64:   store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
+    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
+    // powerpc64:   call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
+    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
+}
+
+#[cfg(not(target_arch = "sparc64"))]
+// aarch64-LABEL:     @returns_doublefloat
+// loongarch64-LABEL: @returns_doublefloat
+// powerpc64-LABEL:   @returns_doublefloat
+// x86_64-LABEL:      @returns_doublefloat
+
+// powerpc64-SAME: sret([16 x i8]) align [[RUST_ALIGN:8]] {{.*}}[[RET_PTR:%.*]])
+#[no_mangle]
+#[inline(never)]
+pub extern "C" fn returns_doublefloat() -> DoubleFloat {
+    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
+    // The other targets copy the cast ABI type to an alloca.
+
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, float }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // loongarch64: ret [[ABI_TYPE]] [[ABI_VALUE]]
+    // x86_64:      ret [[ABI_TYPE]] [[ABI_VALUE]]
+    DoubleFloat { f: 0., g: 0. }
+}
+
+// CHECK-LABEL: @call_twou16s
+#[no_mangle]
+pub fn call_twou16s() {
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
+    // powerpc64:   [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:4]]
+    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:4]]
+
+    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
+
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 4, i1 false)
+
+    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i32]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i32]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // CHECK: call void @receives_twou16s([[ABI_TYPE]] [[ABI_VALUE]])
+    let x = TwoU16s { a: 1, b: 2 };
+    receives_twou16s(x);
+}
+
+// CHECK-LABEL: @return_twou16s
+#[no_mangle]
+pub fn return_twou16s() -> TwoU16s {
+    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
+
+    // powerpc64: [[RETVAL:%.+]] = alloca [4 x i8], align 2
+    // powerpc64: call void @returns_twou16s(ptr {{.+}} [[RETVAL]])
+
+    // The other targets copy the cast ABI type to an alloca.
+
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
+    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:4]]
+
+    // aarch64:     [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
+    // loongarch64: [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
+    // sparc64:     [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
+    // x86_64:      [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
+
+    // aarch64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:i64]] @returns_twou16s()
+    // loongarch64: [[ABI_VALUE:%.+]] = call [[ABI_TYPE:i64]] @returns_twou16s()
+    // sparc64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:i64]] @returns_twou16s()
+    // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:i32]] @returns_twou16s()
+
+    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 4, i1 false)
+    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 4, i1 false)
+    // sparc64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 4, i1 false)
+    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 4, i1 false)
+    returns_twou16s()
+}
+
+// CHECK-LABEL: @call_fiveu16s
+#[no_mangle]
+pub fn call_fiveu16s() {
+    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [10 x i8], align 2
+
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 10, i1 false)
+
+    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ i64, i16 }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // CHECK: call void @receives_fiveu16s([[ABI_TYPE]] [[ABI_VALUE]])
+    let x = FiveU16s { a: 1, b: 2, c: 3, d: 4, e: 5 };
+    receives_fiveu16s(x);
+}
+
+// CHECK-LABEL: @return_fiveu16s
+// CHECK-SAME: (ptr {{.+}} sret([10 x i8]) align [[RUST_ALIGN:2]] {{.*}}dereferenceable(10) [[RET_PTR:%.+]])
+#[no_mangle]
+pub fn return_fiveu16s() -> FiveU16s {
+    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
+
+    // powerpc64: call void @returns_fiveu16s(ptr {{.+}} [[RET_PTR]])
+
+    // The other targets copy the cast ABI type to the sret pointer.
+
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // aarch64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_fiveu16s()
+    // loongarch64: [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_fiveu16s()
+    // sparc64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_fiveu16s()
+    // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ i64, i16 }]] @returns_fiveu16s()
+
+    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RET_PTR]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 10, i1 false)
+    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RET_PTR]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 10, i1 false)
+    // sparc64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RET_PTR]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 10, i1 false)
+    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RET_PTR]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 10, i1 false)
+    returns_fiveu16s()
+}
+
+// CHECK-LABEL: @call_doubledouble
+#[no_mangle]
+pub fn call_doubledouble() {
+    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 16, i1 false)
+
+    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x double\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // CHECK: call void @receives_doubledouble([[ABI_TYPE]] [[ABI_VALUE]])
+    let x = DoubleDouble { f: 1., g: 2. };
+    receives_doubledouble(x);
+}
+
+// CHECK-LABEL: @return_doubledouble
+#[no_mangle]
+pub fn return_doubledouble() -> DoubleDouble {
+    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
+
+    // powerpc64: [[RETVAL:%.+]] = alloca [16 x i8], align 8
+    // powerpc64: call void @returns_doubledouble(ptr {{.+}} [[RETVAL]])
+
+    // The other targets copy the cast ABI type to an alloca.
+
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // aarch64:     [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+    // loongarch64: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+    // sparc64:     [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+    // x86_64:      [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+
+    // aarch64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x double\]]] @returns_doubledouble()
+    // loongarch64: [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, double }]] @returns_doubledouble()
+    // sparc64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, double }]] @returns_doubledouble()
+    // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, double }]] @returns_doubledouble()
+
+    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
+    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
+    // sparc64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
+    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
+    returns_doubledouble()
+}
+
+// This test causes an ICE in sparc64 ABI code (https://github.com/rust-lang/rust/issues/122620)
+#[cfg(not(target_arch = "sparc64"))]
+// aarch64-LABEL:     @call_doublefloat
+// loongarch64-LABEL: @call_doublefloat
+// powerpc64-LABEL:   @call_doublefloat
+// x86_64-LABEL:      @call_doublefloat
+#[no_mangle]
+pub fn call_doublefloat() {
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // powerpc64:   [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // aarch64:     [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+    // loongarch64: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+    // powerpc64:   [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+    // x86_64:      [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+
+    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 16, i1 false)
+    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 12, i1 false)
+    // powerpc64:   call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 16, i1 false)
+    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 16, i1 false)
+
+    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, float }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     call void @receives_doublefloat([[ABI_TYPE]] {{(inreg )?}}[[ABI_VALUE]])
+    // loongarch64: call void @receives_doublefloat([[ABI_TYPE]] {{(inreg )?}}[[ABI_VALUE]])
+    // powerpc64:   call void @receives_doublefloat([[ABI_TYPE]] {{(inreg )?}}[[ABI_VALUE]])
+    // x86_64:      call void @receives_doublefloat([[ABI_TYPE]] {{(inreg )?}}[[ABI_VALUE]])
+    let x = DoubleFloat { f: 1., g: 2. };
+    receives_doublefloat(x);
+}
+
+// This test causes an ICE in sparc64 ABI code (https://github.com/rust-lang/rust/issues/122620)
+#[cfg(not(target_arch = "sparc64"))]
+// aarch64-LABEL:     @return_doublefloat
+// loongarch64-LABEL: @return_doublefloat
+// powerpc64-LABEL:   @return_doublefloat
+// x86_64-LABEL:      @return_doublefloat
+#[no_mangle]
+pub fn return_doublefloat() -> DoubleFloat {
+    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
+
+    // powerpc64: [[RETVAL:%.+]] = alloca [16 x i8], align 8
+    // powerpc64: call void @returns_doublefloat(ptr {{.+}} [[RETVAL]])
+
+    // The other targets copy the cast ABI type to an alloca.
+
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // aarch64:     [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+    // loongarch64: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+    // x86_64:      [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
+
+    // aarch64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_doublefloat()
+    // loongarch64: [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, float }]] @returns_doublefloat()
+    // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, double }]] @returns_doublefloat()
+
+    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
+    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
+    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
+    returns_doublefloat()
+}
+
+// CHECK-LABEL: @call_three32s
+#[no_mangle]
+pub fn call_three32s() {
+    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [12 x i8], align [[RUST_ALIGN:4]]
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 12, i1 false)
+
+    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ i64, i32 }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // CHECK: call void @receives_three32s([[ABI_TYPE]] [[ABI_VALUE]])
+    let x = Three32s { a: 1, b: 2, c: 3 };
+    receives_three32s(x);
+}
+
+// Regression test for #75839
+// CHECK-LABEL: @return_three32s(
+// CHECK-SAME: sret([12 x i8]) align [[RUST_ALIGN:4]] {{.*}}[[RUST_RETVAL:%.*]])
+#[no_mangle]
+pub fn return_three32s() -> Three32s {
+    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
+
+    // powerpc64: call void @returns_three32s(ptr {{.+}} [[RUST_RETVAL]])
+
+    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
+
+    // aarch64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_three32s()
+    // loongarch64: [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_three32s()
+    // sparc64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_three32s()
+    // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ i64, i32 }]] @returns_three32s()
+
+    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // sparc64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
+
+    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_RETVAL]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
+    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_RETVAL]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
+    // sparc64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_RETVAL]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
+    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_RETVAL]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
+    returns_three32s()
+}
diff --git a/tests/codegen-llvm/catch-unwind.rs b/tests/codegen-llvm/catch-unwind.rs
new file mode 100644
index 00000000000..d1ff55bcc28
--- /dev/null
+++ b/tests/codegen-llvm/catch-unwind.rs
@@ -0,0 +1,32 @@
+//@ compile-flags: -Copt-level=3
+
+// On x86 the closure is inlined in foo() producing something like
+// define i32 @foo() [...] {
+// tail call void @bar() [...]
+// ret i32 0
+// }
+// On riscv the closure is another function, placed before fn foo so CHECK can't
+// find it
+//@ ignore-riscv64 FIXME
+// On s390x the closure is also in another function
+//@ ignore-s390x FIXME
+// On loongarch64 the closure is also in another function
+//@ ignore-loongarch64 FIXME
+
+#![crate_type = "lib"]
+
+extern "C" {
+    fn bar();
+}
+
+// CHECK-LABEL: @foo
+#[no_mangle]
+pub unsafe fn foo() -> i32 {
+    // CHECK: call void @bar
+    // CHECK: ret i32 0
+    std::panic::catch_unwind(|| {
+        bar();
+        0
+    })
+    .unwrap()
+}
diff --git a/tests/codegen-llvm/cdylib-external-inline-fns.rs b/tests/codegen-llvm/cdylib-external-inline-fns.rs
new file mode 100644
index 00000000000..2e472ea68e8
--- /dev/null
+++ b/tests/codegen-llvm/cdylib-external-inline-fns.rs
@@ -0,0 +1,43 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "cdylib"]
+
+// CHECK: define{{( dso_local)?}} void @a()
+#[no_mangle]
+#[inline]
+pub extern "C" fn a() {}
+
+// CHECK: define{{( dso_local)?}} void @b()
+#[export_name = "b"]
+#[inline]
+pub extern "C" fn b() {}
+
+// CHECK: define{{( dso_local)?}} void @c()
+#[no_mangle]
+#[inline]
+extern "C" fn c() {}
+
+// CHECK: define{{( dso_local)?}} void @d()
+#[export_name = "d"]
+#[inline]
+extern "C" fn d() {}
+
+// CHECK: define{{( dso_local)?}} void @e()
+#[no_mangle]
+#[inline(always)]
+pub extern "C" fn e() {}
+
+// CHECK: define{{( dso_local)?}} void @f()
+#[export_name = "f"]
+#[inline(always)]
+pub extern "C" fn f() {}
+
+// CHECK: define{{( dso_local)?}} void @g()
+#[no_mangle]
+#[inline(always)]
+extern "C" fn g() {}
+
+// CHECK: define{{( dso_local)?}} void @h()
+#[export_name = "h"]
+#[inline(always)]
+extern "C" fn h() {}
diff --git a/tests/codegen-llvm/cf-protection.rs b/tests/codegen-llvm/cf-protection.rs
new file mode 100644
index 00000000000..f1349a5dcb9
--- /dev/null
+++ b/tests/codegen-llvm/cf-protection.rs
@@ -0,0 +1,38 @@
+// Test that the correct module flags are emitted with different control-flow protection flags.
+
+//@ add-core-stubs
+//@ revisions: undefined none branch return full
+//@ needs-llvm-components: x86
+//@ [undefined] compile-flags:
+//@ [none] compile-flags: -Z cf-protection=none
+//@ [branch] compile-flags: -Z cf-protection=branch
+//@ [return] compile-flags: -Z cf-protection=return
+//@ [full] compile-flags: -Z cf-protection=full
+//@ compile-flags: --target x86_64-unknown-linux-gnu
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// A basic test function.
+pub fn test() {}
+
+// undefined-NOT: !"cf-protection-branch"
+// undefined-NOT: !"cf-protection-return"
+
+// none-NOT: !"cf-protection-branch"
+// none-NOT: !"cf-protection-return"
+
+// branch-NOT: !"cf-protection-return"
+// branch: !"cf-protection-branch", i32 1
+// branch-NOT: !"cf-protection-return"
+
+// return-NOT: !"cf-protection-branch"
+// return: !"cf-protection-return", i32 1
+// return-NOT: !"cf-protection-branch"
+
+// full: !"cf-protection-branch", i32 1
+// full: !"cf-protection-return", i32 1
diff --git a/tests/codegen-llvm/cffi/c-variadic-copy.rs b/tests/codegen-llvm/cffi/c-variadic-copy.rs
new file mode 100644
index 00000000000..4c61c4fcf68
--- /dev/null
+++ b/tests/codegen-llvm/cffi/c-variadic-copy.rs
@@ -0,0 +1,16 @@
+// Tests that `VaListImpl::clone` gets inlined into a call to `llvm.va_copy`
+
+#![crate_type = "lib"]
+#![feature(c_variadic)]
+#![no_std]
+use core::ffi::VaList;
+
+extern "C" {
+    fn foreign_c_variadic_1(_: VaList, ...);
+}
+
+pub unsafe extern "C" fn clone_variadic(ap: VaList) {
+    let mut ap2 = ap.clone();
+    // CHECK: call void @llvm.va_copy
+    foreign_c_variadic_1(ap2.as_va_list(), 42i32);
+}
diff --git a/tests/codegen-llvm/cffi/c-variadic-naked.rs b/tests/codegen-llvm/cffi/c-variadic-naked.rs
new file mode 100644
index 00000000000..5843628b633
--- /dev/null
+++ b/tests/codegen-llvm/cffi/c-variadic-naked.rs
@@ -0,0 +1,15 @@
+//@ needs-asm-support
+//@ only-x86_64
+
+// tests that `va_start` is not injected into naked functions
+
+#![crate_type = "lib"]
+#![feature(c_variadic)]
+#![no_std]
+
+#[unsafe(naked)]
+pub unsafe extern "C" fn c_variadic(_: usize, _: ...) {
+    // CHECK-NOT: va_start
+    // CHECK-NOT: alloca
+    core::arch::naked_asm!("ret")
+}
diff --git a/tests/codegen-llvm/cffi/c-variadic-opt.rs b/tests/codegen-llvm/cffi/c-variadic-opt.rs
new file mode 100644
index 00000000000..7e544ee7f37
--- /dev/null
+++ b/tests/codegen-llvm/cffi/c-variadic-opt.rs
@@ -0,0 +1,30 @@
+//@ compile-flags: -C opt-level=3
+
+#![crate_type = "lib"]
+#![feature(c_variadic)]
+#![no_std]
+use core::ffi::VaList;
+
+extern "C" {
+    fn vprintf(fmt: *const i8, ap: VaList) -> i32;
+}
+
+// Ensure that `va_start` and `va_end` are properly injected even
+// when the "spoofed" `VaListImpl` is not used.
+#[no_mangle]
+pub unsafe extern "C" fn c_variadic_no_use(fmt: *const i8, mut ap: ...) -> i32 {
+    // CHECK: call void @llvm.va_start
+    vprintf(fmt, ap.as_va_list())
+    // CHECK: call void @llvm.va_end
+}
+
+// Check that `VaListImpl::clone` gets inlined into a direct call to `llvm.va_copy`
+#[no_mangle]
+pub unsafe extern "C" fn c_variadic_clone(fmt: *const i8, mut ap: ...) -> i32 {
+    // CHECK: call void @llvm.va_start
+    let mut ap2 = ap.clone();
+    // CHECK: call void @llvm.va_copy
+    let res = vprintf(fmt, ap2.as_va_list());
+    res
+    // CHECK: call void @llvm.va_end
+}
diff --git a/tests/codegen-llvm/cffi/c-variadic.rs b/tests/codegen-llvm/cffi/c-variadic.rs
new file mode 100644
index 00000000000..140d2f37f46
--- /dev/null
+++ b/tests/codegen-llvm/cffi/c-variadic.rs
@@ -0,0 +1,71 @@
+//@ needs-unwind
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+//
+
+#![crate_type = "lib"]
+#![feature(c_variadic)]
+#![no_std]
+use core::ffi::VaList;
+
+extern "C" {
+    fn foreign_c_variadic_0(_: i32, ...);
+    fn foreign_c_variadic_1(_: VaList, ...);
+}
+
+pub unsafe extern "C" fn use_foreign_c_variadic_0() {
+    // Ensure that we correctly call foreign C-variadic functions.
+    // CHECK: call void (i32, ...) @foreign_c_variadic_0([[PARAM:i32( signext)?]] 0)
+    foreign_c_variadic_0(0);
+    // CHECK: call void (i32, ...) @foreign_c_variadic_0([[PARAM]] 0, [[PARAM]] 42)
+    foreign_c_variadic_0(0, 42i32);
+    // CHECK: call void (i32, ...) @foreign_c_variadic_0([[PARAM]] 0, [[PARAM]] 42, [[PARAM]] 1024)
+    foreign_c_variadic_0(0, 42i32, 1024i32);
+    // CHECK: call void (i32, ...) @foreign_c_variadic_0([[PARAM]] 0, [[PARAM]] 42, [[PARAM]] 1024, [[PARAM]] 0)
+    foreign_c_variadic_0(0, 42i32, 1024i32, 0i32);
+}
+
+// Ensure that we do not remove the `va_list` passed to the foreign function when
+// removing the "spoofed" `VaListImpl` that is used by Rust defined C-variadics.
+pub unsafe extern "C" fn use_foreign_c_variadic_1_0(ap: VaList) {
+    // CHECK: call void ({{.*}}, ...) @foreign_c_variadic_1({{.*}} %ap)
+    foreign_c_variadic_1(ap);
+}
+
+pub unsafe extern "C" fn use_foreign_c_variadic_1_1(ap: VaList) {
+    // CHECK: call void ({{.*}}, ...) @foreign_c_variadic_1({{.*}} %ap, [[PARAM]] 42)
+    foreign_c_variadic_1(ap, 42i32);
+}
+pub unsafe extern "C" fn use_foreign_c_variadic_1_2(ap: VaList) {
+    // CHECK: call void ({{.*}}, ...) @foreign_c_variadic_1({{.*}} %ap, [[PARAM]] 2, [[PARAM]] 42)
+    foreign_c_variadic_1(ap, 2i32, 42i32);
+}
+
+pub unsafe extern "C" fn use_foreign_c_variadic_1_3(ap: VaList) {
+    // CHECK: call void ({{.*}}, ...) @foreign_c_variadic_1({{.*}} %ap, [[PARAM]] 2, [[PARAM]] 42, [[PARAM]] 0)
+    foreign_c_variadic_1(ap, 2i32, 42i32, 0i32);
+}
+
+// Ensure that `va_start` and `va_end` are properly injected.
+#[no_mangle]
+pub unsafe extern "C" fn c_variadic(n: i32, mut ap: ...) -> i32 {
+    // CHECK: call void @llvm.va_start
+    let mut sum = 0;
+    for _ in 0..n {
+        sum += ap.arg::<i32>();
+    }
+    sum
+    // CHECK: call void @llvm.va_end
+}
+
+// Ensure that we generate the correct `call` signature when calling a Rust
+// defined C-variadic.
+pub unsafe fn test_c_variadic_call() {
+    // CHECK: call [[RET:(signext )?i32]] (i32, ...) @c_variadic([[PARAM]] 0)
+    c_variadic(0);
+    // CHECK: call [[RET]] (i32, ...) @c_variadic([[PARAM]] 0, [[PARAM]] 42)
+    c_variadic(0, 42i32);
+    // CHECK: call [[RET]] (i32, ...) @c_variadic([[PARAM]] 0, [[PARAM]] 42, [[PARAM]] 1024)
+    c_variadic(0, 42i32, 1024i32);
+    // CHECK: call [[RET]] (i32, ...) @c_variadic([[PARAM]] 0, [[PARAM]] 42, [[PARAM]] 1024, [[PARAM]] 0)
+    c_variadic(0, 42i32, 1024i32, 0i32);
+}
diff --git a/tests/codegen-llvm/cffi/ffi-const.rs b/tests/codegen-llvm/cffi/ffi-const.rs
new file mode 100644
index 00000000000..3ea9d517ec2
--- /dev/null
+++ b/tests/codegen-llvm/cffi/ffi-const.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -C no-prepopulate-passes
+#![crate_type = "lib"]
+#![feature(ffi_const)]
+
+pub fn bar() {
+    unsafe { foo() }
+}
+
+extern "C" {
+    // CHECK-LABEL: declare{{.*}}void @foo()
+    // CHECK-SAME: [[ATTRS:#[0-9]+]]
+    // CHECK-DAG: attributes [[ATTRS]] = { {{.*}}memory(none){{.*}} }
+    #[unsafe(ffi_const)]
+    pub fn foo();
+}
diff --git a/tests/codegen-llvm/cffi/ffi-out-of-bounds-loads.rs b/tests/codegen-llvm/cffi/ffi-out-of-bounds-loads.rs
new file mode 100644
index 00000000000..859386d2df8
--- /dev/null
+++ b/tests/codegen-llvm/cffi/ffi-out-of-bounds-loads.rs
@@ -0,0 +1,41 @@
+//@ add-core-stubs
+//@ revisions: linux apple
+//@ compile-flags: -Copt-level=0 -Cno-prepopulate-passes -Zlint-llvm-ir
+
+//@[linux] compile-flags: --target x86_64-unknown-linux-gnu
+//@[linux] needs-llvm-components: x86
+//@[apple] compile-flags: --target x86_64-apple-darwin
+//@[apple] needs-llvm-components: x86
+
+// Regression test for #29988
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C)]
+struct S {
+    f1: i32,
+    f2: i32,
+    f3: i32,
+}
+
+extern "C" {
+    fn foo(s: S);
+}
+
+// CHECK-LABEL: @test
+#[no_mangle]
+pub fn test() {
+    let s = S { f1: 1, f2: 2, f3: 3 };
+    unsafe {
+        // CHECK: [[ALLOCA:%.+]] = alloca [16 x i8], align 8
+        // CHECK: [[LOAD:%.+]] = load { i64, i32 }, ptr [[ALLOCA]], align 8
+        // CHECK: call void @foo({ i64, i32 } [[LOAD]])
+        foo(s);
+    }
+}
diff --git a/tests/codegen-llvm/cffi/ffi-pure.rs b/tests/codegen-llvm/cffi/ffi-pure.rs
new file mode 100644
index 00000000000..a61e80ecf65
--- /dev/null
+++ b/tests/codegen-llvm/cffi/ffi-pure.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -C no-prepopulate-passes
+#![crate_type = "lib"]
+#![feature(ffi_pure)]
+
+pub fn bar() {
+    unsafe { foo() }
+}
+
+extern "C" {
+    // CHECK-LABEL: declare{{.*}}void @foo()
+    // CHECK-SAME: [[ATTRS:#[0-9]+]]
+    // CHECK-DAG: attributes [[ATTRS]] = { {{.*}}memory(read){{.*}} }
+    #[unsafe(ffi_pure)]
+    pub fn foo();
+}
diff --git a/tests/codegen-llvm/cfguard-checks.rs b/tests/codegen-llvm/cfguard-checks.rs
new file mode 100644
index 00000000000..cdf6406ad61
--- /dev/null
+++ b/tests/codegen-llvm/cfguard-checks.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: -C control-flow-guard=checks
+//@ only-msvc
+
+#![crate_type = "lib"]
+
+// A basic test function.
+pub fn test() {}
+
+// Ensure the module flag cfguard=2 is present
+// CHECK: !"cfguard", i32 2
diff --git a/tests/codegen-llvm/cfguard-disabled.rs b/tests/codegen-llvm/cfguard-disabled.rs
new file mode 100644
index 00000000000..90915c0f0c6
--- /dev/null
+++ b/tests/codegen-llvm/cfguard-disabled.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: -C control-flow-guard=no
+//@ only-msvc
+
+#![crate_type = "lib"]
+
+// A basic test function.
+pub fn test() {}
+
+// Ensure the module flag cfguard is not present
+// CHECK-NOT: !"cfguard"
diff --git a/tests/codegen-llvm/cfguard-nochecks.rs b/tests/codegen-llvm/cfguard-nochecks.rs
new file mode 100644
index 00000000000..5f386533ec1
--- /dev/null
+++ b/tests/codegen-llvm/cfguard-nochecks.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: -C control-flow-guard=nochecks
+//@ only-msvc
+
+#![crate_type = "lib"]
+
+// A basic test function.
+pub fn test() {}
+
+// Ensure the module flag cfguard=1 is present
+// CHECK: !"cfguard", i32 1
diff --git a/tests/codegen-llvm/cfguard-non-msvc.rs b/tests/codegen-llvm/cfguard-non-msvc.rs
new file mode 100644
index 00000000000..1e6559aaf5d
--- /dev/null
+++ b/tests/codegen-llvm/cfguard-non-msvc.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: -C control-flow-guard
+//@ ignore-msvc
+
+#![crate_type = "lib"]
+
+// A basic test function.
+pub fn test() {}
+
+// Ensure the cfguard module flag is not added for non-MSVC targets.
+// CHECK-NOT: !"cfguard"
diff --git a/tests/codegen-llvm/char-ascii-branchless.rs b/tests/codegen-llvm/char-ascii-branchless.rs
new file mode 100644
index 00000000000..f99066aa9aa
--- /dev/null
+++ b/tests/codegen-llvm/char-ascii-branchless.rs
@@ -0,0 +1,47 @@
+// Checks that these functions are branchless.
+//
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @is_ascii_alphanumeric_char
+#[no_mangle]
+pub fn is_ascii_alphanumeric_char(x: char) -> bool {
+    // CHECK-NOT: br
+    x.is_ascii_alphanumeric()
+}
+
+// CHECK-LABEL: @is_ascii_alphanumeric_u8
+#[no_mangle]
+pub fn is_ascii_alphanumeric_u8(x: u8) -> bool {
+    // CHECK-NOT: br
+    x.is_ascii_alphanumeric()
+}
+
+// CHECK-LABEL: @is_ascii_hexdigit_char
+#[no_mangle]
+pub fn is_ascii_hexdigit_char(x: char) -> bool {
+    // CHECK-NOT: br
+    x.is_ascii_hexdigit()
+}
+
+// CHECK-LABEL: @is_ascii_hexdigit_u8
+#[no_mangle]
+pub fn is_ascii_hexdigit_u8(x: u8) -> bool {
+    // CHECK-NOT: br
+    x.is_ascii_hexdigit()
+}
+
+// CHECK-LABEL: @is_ascii_punctuation_char
+#[no_mangle]
+pub fn is_ascii_punctuation_char(x: char) -> bool {
+    // CHECK-NOT: br
+    x.is_ascii_punctuation()
+}
+
+// CHECK-LABEL: @is_ascii_punctuation_u8
+#[no_mangle]
+pub fn is_ascii_punctuation_u8(x: u8) -> bool {
+    // CHECK-NOT: br
+    x.is_ascii_punctuation()
+}
diff --git a/tests/codegen-llvm/char-escape-debug-no-bounds-check.rs b/tests/codegen-llvm/char-escape-debug-no-bounds-check.rs
new file mode 100644
index 00000000000..cfde46045e5
--- /dev/null
+++ b/tests/codegen-llvm/char-escape-debug-no-bounds-check.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+use std::char::EscapeDebug;
+
+// Make sure no bounds checks are emitted when escaping a character.
+
+// CHECK-LABEL: @char_escape_debug_no_bounds_check
+#[no_mangle]
+pub fn char_escape_debug_no_bounds_check(c: char) -> EscapeDebug {
+    // CHECK-NOT: panic
+    // CHECK-NOT: panic_bounds_check
+    c.escape_debug()
+}
diff --git a/tests/codegen-llvm/checked_ilog.rs b/tests/codegen-llvm/checked_ilog.rs
new file mode 100644
index 00000000000..e340a45b6a9
--- /dev/null
+++ b/tests/codegen-llvm/checked_ilog.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// Ensure that when val < base, we do not divide or multiply.
+
+// CHECK-LABEL: @checked_ilog
+// CHECK-SAME: (i16{{.*}} %val, i16{{.*}} %base)
+#[no_mangle]
+pub fn checked_ilog(val: u16, base: u16) -> Option<u32> {
+    // CHECK-NOT: udiv
+    // CHECK-NOT: mul
+    // CHECK: %[[IS_LESS:.+]] = icmp ult i16 %val, %base
+    // CHECK-NEXT: br i1 %[[IS_LESS]], label %[[TRUE:.+]], label %[[FALSE:.+]]
+    // CHECK: [[TRUE]]:
+    // CHECK-NOT: udiv
+    // CHECK-NOT: mul
+    // CHECK: ret { i32, i32 }
+    val.checked_ilog(base)
+}
diff --git a/tests/codegen-llvm/checked_math.rs b/tests/codegen-llvm/checked_math.rs
new file mode 100644
index 00000000000..66667c69488
--- /dev/null
+++ b/tests/codegen-llvm/checked_math.rs
@@ -0,0 +1,100 @@
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+
+#![crate_type = "lib"]
+#![feature(unchecked_shifts)]
+
+// Because the result of something like `u32::checked_sub` can only be used if it
+// didn't overflow, make sure that LLVM actually knows that in optimized builds.
+// Thanks to poison semantics, this doesn't even need branches.
+
+// CHECK-LABEL: @checked_sub_unsigned
+// CHECK-SAME: (i16{{.*}} %a, i16{{.*}} %b)
+#[no_mangle]
+pub fn checked_sub_unsigned(a: u16, b: u16) -> Option<u16> {
+    // CHECK-DAG: %[[IS_SOME:.+]] = icmp uge i16 %a, %b
+    // CHECK-DAG: %[[DIFF_P:.+]] = sub nuw i16 %a, %b
+    // CHECK-DAG: %[[DISCR:.+]] = zext i1 %[[IS_SOME]] to i16
+    // CHECK-DAG: %[[DIFF_U:.+]] = select i1 %[[IS_SOME]], i16 %[[DIFF_P]], i16 undef
+
+    // CHECK: %[[R0:.+]] = insertvalue { i16, i16 } poison, i16 %[[DISCR]], 0
+    // CHECK: %[[R1:.+]] = insertvalue { i16, i16 } %[[R0]], i16 %[[DIFF_U]], 1
+    // CHECK: ret { i16, i16 } %[[R1]]
+    a.checked_sub(b)
+}
+
+// Note that `shl` and `shr` in LLVM are already unchecked. So rather than
+// looking for no-wrap flags, we just need there to not be any masking.
+
+// CHECK-LABEL: @checked_shl_unsigned
+// CHECK-SAME: (i32{{.*}} %a, i32{{.*}} %b)
+#[no_mangle]
+pub fn checked_shl_unsigned(a: u32, b: u32) -> Option<u32> {
+    // CHECK-DAG: %[[IS_SOME:.+]] = icmp ult i32 %b, 32
+    // CHECK-DAG: %[[SHIFTED_P:.+]] = shl i32 %a, %b
+    // CHECK-DAG: %[[DISCR:.+]] = zext i1 %[[IS_SOME]] to i32
+    // CHECK-DAG: %[[SHIFTED_U:.+]] = select i1 %[[IS_SOME]], i32 %[[SHIFTED_P]], i32 undef
+
+    // CHECK: %[[R0:.+]] = insertvalue { i32, i32 } poison, i32 %[[DISCR]], 0
+    // CHECK: %[[R1:.+]] = insertvalue { i32, i32 } %[[R0]], i32 %[[SHIFTED_U]], 1
+    // CHECK: ret { i32, i32 } %[[R1]]
+    a.checked_shl(b)
+}
+
+// CHECK-LABEL: @checked_shr_unsigned
+// CHECK-SAME: (i32{{.*}} %a, i32{{.*}} %b)
+#[no_mangle]
+pub fn checked_shr_unsigned(a: u32, b: u32) -> Option<u32> {
+    // CHECK-DAG: %[[IS_SOME:.+]] = icmp ult i32 %b, 32
+    // CHECK-DAG: %[[SHIFTED_P:.+]] = lshr i32 %a, %b
+    // CHECK-DAG: %[[DISCR:.+]] = zext i1 %[[IS_SOME]] to i32
+    // CHECK-DAG: %[[SHIFTED_U:.+]] = select i1 %[[IS_SOME]], i32 %[[SHIFTED_P]], i32 undef
+
+    // CHECK: %[[R0:.+]] = insertvalue { i32, i32 } poison, i32 %[[DISCR]], 0
+    // CHECK: %[[R1:.+]] = insertvalue { i32, i32 } %[[R0]], i32 %[[SHIFTED_U]], 1
+    // CHECK: ret { i32, i32 } %[[R1]]
+    a.checked_shr(b)
+}
+
+// CHECK-LABEL: @checked_shl_signed
+// CHECK-SAME: (i32{{.*}} %a, i32{{.*}} %b)
+#[no_mangle]
+pub fn checked_shl_signed(a: i32, b: u32) -> Option<i32> {
+    // CHECK-DAG: %[[IS_SOME:.+]] = icmp ult i32 %b, 32
+    // CHECK-DAG: %[[SHIFTED_P:.+]] = shl i32 %a, %b
+    // CHECK-DAG: %[[DISCR:.+]] = zext i1 %[[IS_SOME]] to i32
+    // CHECK-DAG: %[[SHIFTED_U:.+]] = select i1 %[[IS_SOME]], i32 %[[SHIFTED_P]], i32 undef
+
+    // CHECK: %[[R0:.+]] = insertvalue { i32, i32 } poison, i32 %[[DISCR]], 0
+    // CHECK: %[[R1:.+]] = insertvalue { i32, i32 } %[[R0]], i32 %[[SHIFTED_U]], 1
+    // CHECK: ret { i32, i32 } %[[R1]]
+    a.checked_shl(b)
+}
+
+// CHECK-LABEL: @checked_shr_signed
+// CHECK-SAME: (i32{{.*}} %a, i32{{.*}} %b)
+#[no_mangle]
+pub fn checked_shr_signed(a: i32, b: u32) -> Option<i32> {
+    // CHECK-DAG: %[[IS_SOME:.+]] = icmp ult i32 %b, 32
+    // CHECK-DAG: %[[SHIFTED_P:.+]] = ashr i32 %a, %b
+    // CHECK-DAG: %[[DISCR:.+]] = zext i1 %[[IS_SOME]] to i32
+    // CHECK-DAG: %[[SHIFTED_U:.+]] = select i1 %[[IS_SOME]], i32 %[[SHIFTED_P]], i32 undef
+
+    // CHECK: %[[R0:.+]] = insertvalue { i32, i32 } poison, i32 %[[DISCR]], 0
+    // CHECK: %[[R1:.+]] = insertvalue { i32, i32 } %[[R0]], i32 %[[SHIFTED_U]], 1
+    // CHECK: ret { i32, i32 } %[[R1]]
+    a.checked_shr(b)
+}
+
+// CHECK-LABEL: @checked_add_one_unwrap_unsigned
+// CHECK-SAME: (i32{{.*}} %x)
+#[no_mangle]
+pub fn checked_add_one_unwrap_unsigned(x: u32) -> u32 {
+    // CHECK: %[[IS_MAX:.+]] = icmp eq i32 %x, -1
+    // CHECK: br i1 %[[IS_MAX]], label %[[NONE_BB:.+]], label %[[SOME_BB:.+]],
+    // CHECK: [[SOME_BB]]:
+    // CHECK: %[[R:.+]] = add nuw i32 %x, 1
+    // CHECK: ret i32 %[[R]]
+    // CHECK: [[NONE_BB]]:
+    // CHECK: call {{.+}}unwrap_failed
+    x.checked_add(1).unwrap()
+}
diff --git a/tests/codegen-llvm/clone-shims.rs b/tests/codegen-llvm/clone-shims.rs
new file mode 100644
index 00000000000..06c959f9ee7
--- /dev/null
+++ b/tests/codegen-llvm/clone-shims.rs
@@ -0,0 +1,15 @@
+// Clone shims for aggregates are generated by just calling the Clone shims for all their members.
+// Those calls generate a lot of unnecessary IR if the members are Copy. This test ensures that we
+// optimize away those inner calls without needing to inline them.
+
+//@ compile-flags: -Cno-prepopulate-passes -Csymbol-mangling-version=v0 -Zinline-mir=no
+#![crate_type = "lib"]
+
+pub type Test = (i32, i32, *const i32);
+pub static TEST: fn(&Test) -> Test = <Test as core::clone::Clone>::clone;
+
+// CHECK-NOT: call <i32 as core::clone::Clone>::clone
+// CHECK-NOT: call <*const i32 as core::clone::Clone>::clone
+// CHECK:     ; <(i32, i32, *const i32) as core::clone::Clone>::clone
+// CHECK-NOT: call <i32 as core::clone::Clone>::clone
+// CHECK-NOT: call <*const i32 as core::clone::Clone>::clone
diff --git a/tests/codegen-llvm/clone_as_copy.rs b/tests/codegen-llvm/clone_as_copy.rs
new file mode 100644
index 00000000000..ef834ef5912
--- /dev/null
+++ b/tests/codegen-llvm/clone_as_copy.rs
@@ -0,0 +1,40 @@
+//@ revisions: DEBUGINFO NODEBUGINFO
+//@ compile-flags: -Copt-level=3 -Cno-prepopulate-passes
+//@ [DEBUGINFO] compile-flags: -Cdebuginfo=full
+
+// From https://github.com/rust-lang/rust/issues/128081.
+// Ensure that we only generate a memcpy instruction.
+
+#![crate_type = "lib"]
+
+#[derive(Clone)]
+struct SubCloneAndCopy {
+    v1: u32,
+    v2: u32,
+}
+
+#[derive(Clone)]
+struct CloneOnly {
+    v1: u8,
+    v2: u8,
+    v3: u8,
+    v4: u8,
+    v5: u8,
+    v6: u8,
+    v7: u8,
+    v8: u8,
+    v9: u8,
+    v_sub: SubCloneAndCopy,
+    v_large: [u8; 256],
+}
+
+// CHECK-LABEL: define {{.*}}@clone_only(
+#[no_mangle]
+pub fn clone_only(v: &CloneOnly) -> CloneOnly {
+    // CHECK-NOT: call {{.*}}clone
+    // CHECK-NOT: store i8
+    // CHECK-NOT: store i32
+    // CHECK: call void @llvm.memcpy
+    // CHECK-NEXT: ret void
+    v.clone()
+}
diff --git a/tests/codegen-llvm/codemodels.rs b/tests/codegen-llvm/codemodels.rs
new file mode 100644
index 00000000000..06d2eade78a
--- /dev/null
+++ b/tests/codegen-llvm/codemodels.rs
@@ -0,0 +1,20 @@
+//@ only-x86_64
+
+//@ revisions: NOMODEL MODEL-SMALL MODEL-KERNEL MODEL-MEDIUM MODEL-LARGE
+//@[NOMODEL] compile-flags:
+//@[MODEL-SMALL] compile-flags: -C code-model=small
+//@[MODEL-KERNEL] compile-flags: -C code-model=kernel
+//@[MODEL-MEDIUM] compile-flags: -C code-model=medium
+//@[MODEL-LARGE] compile-flags: -C code-model=large
+
+#![crate_type = "lib"]
+
+// MODEL-SMALL: !llvm.module.flags = !{{{.*}}}
+// MODEL-SMALL: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 1}
+// MODEL-KERNEL: !llvm.module.flags = !{{{.*}}}
+// MODEL-KERNEL: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 2}
+// MODEL-MEDIUM: !llvm.module.flags = !{{{.*}}}
+// MODEL-MEDIUM: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 3}
+// MODEL-LARGE: !llvm.module.flags = !{{{.*}}}
+// MODEL-LARGE: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 4}
+// NOMODEL-NOT: Code Model
diff --git a/tests/codegen-llvm/coercions.rs b/tests/codegen-llvm/coercions.rs
new file mode 100644
index 00000000000..63c1742c639
--- /dev/null
+++ b/tests/codegen-llvm/coercions.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+static X: i32 = 5;
+
+// CHECK-LABEL: @raw_ptr_to_raw_ptr_noop
+// CHECK-NOT: alloca
+#[no_mangle]
+pub fn raw_ptr_to_raw_ptr_noop() -> *const i32 {
+    &X as *const i32
+}
+
+// CHECK-LABEL: @reference_to_raw_ptr_noop
+// CHECK-NOT: alloca
+#[no_mangle]
+pub fn reference_to_raw_ptr_noop() -> *const i32 {
+    &X
+}
diff --git a/tests/codegen-llvm/cold-call-declare-and-call.rs b/tests/codegen-llvm/cold-call-declare-and-call.rs
new file mode 100644
index 00000000000..b18565ee6c3
--- /dev/null
+++ b/tests/codegen-llvm/cold-call-declare-and-call.rs
@@ -0,0 +1,27 @@
+//@ revisions: NORMAL WIN
+//@ compile-flags: -C no-prepopulate-passes
+//@[NORMAL] ignore-windows
+//@[WIN] only-windows
+//@[WIN] only-x86_64
+
+#![crate_type = "lib"]
+#![feature(rust_cold_cc)]
+
+// wasm marks the definition as `dso_local`, so allow that as optional.
+
+// NORMAL: define{{( dso_local)?}} preserve_mostcc void @this_should_never_happen(i16
+// NORMAL: call preserve_mostcc void @this_should_never_happen(i16
+
+// See the comment in `Target::adjust_abi` for why this differs
+
+// WIN: define void @this_should_never_happen(i16
+// WIN: call void @this_should_never_happen(i16
+
+#[no_mangle]
+pub extern "rust-cold" fn this_should_never_happen(x: u16) {}
+
+pub fn do_things(x: u16) {
+    if x == 12345 {
+        this_should_never_happen(54321);
+    }
+}
diff --git a/tests/codegen-llvm/common_prim_int_ptr.rs b/tests/codegen-llvm/common_prim_int_ptr.rs
new file mode 100644
index 00000000000..53716adccbf
--- /dev/null
+++ b/tests/codegen-llvm/common_prim_int_ptr.rs
@@ -0,0 +1,51 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+// Tests that codegen works properly when enums like `Result<usize, Box<()>>`
+// are represented as `{ u64, ptr }`, i.e., for `Ok(123)`, `123` is stored
+// as a pointer.
+
+// CHECK-LABEL: @insert_int
+#[no_mangle]
+pub fn insert_int(x: usize) -> Result<usize, Box<()>> {
+    // CHECK: start:
+    // CHECK-NEXT: %[[WO_PROV:.+]] = getelementptr i8, ptr null, [[USIZE:i[0-9]+]] %x
+    // CHECK-NEXT: %[[R:.+]] = insertvalue { [[USIZE]], ptr } { [[USIZE]] 0, ptr poison }, ptr %[[WO_PROV]], 1
+    // CHECK-NEXT: ret { [[USIZE]], ptr } %[[R]]
+    Ok(x)
+}
+
+// CHECK-LABEL: @insert_box
+#[no_mangle]
+pub fn insert_box(x: Box<()>) -> Result<usize, Box<()>> {
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue { i{{[0-9]+}}, ptr }
+    // CHECK-NEXT: ret
+    Err(x)
+}
+
+// CHECK-LABEL: @extract_int
+// CHECK-NOT: nonnull
+// CHECK-SAME: (i{{[0-9]+}} {{[^%]+}} [[DISCRIMINANT:%[0-9]+]], ptr {{[^,]+}} [[PAYLOAD:%[0-9]+]])
+#[no_mangle]
+pub unsafe fn extract_int(x: Result<usize, Box<()>>) -> usize {
+    // CHECK: [[TEMP:%.+]] = ptrtoint ptr [[PAYLOAD]] to [[USIZE:i[0-9]+]]
+    // CHECK: ret [[USIZE]] [[TEMP]]
+    match x {
+        Ok(v) => v,
+        Err(_) => std::intrinsics::unreachable(),
+    }
+}
+
+// CHECK-LABEL: @extract_box
+// CHECK-SAME: (i{{[0-9]+}} {{[^%]+}} [[DISCRIMINANT:%[0-9]+]], ptr {{[^%]+}} [[PAYLOAD:%[0-9]+]])
+#[no_mangle]
+pub unsafe fn extract_box(x: Result<usize, Box<i32>>) -> Box<i32> {
+    // CHECK: ret ptr [[PAYLOAD]]
+    match x {
+        Ok(_) => std::intrinsics::unreachable(),
+        Err(e) => e,
+    }
+}
diff --git a/tests/codegen-llvm/comparison-operators-2-struct.rs b/tests/codegen-llvm/comparison-operators-2-struct.rs
new file mode 100644
index 00000000000..e179066ebfd
--- /dev/null
+++ b/tests/codegen-llvm/comparison-operators-2-struct.rs
@@ -0,0 +1,61 @@
+//@ compile-flags: -C opt-level=1
+//@ min-llvm-version: 20
+
+// The `derive(PartialOrd)` for a 2-field type doesn't override `lt`/`le`/`gt`/`ge`.
+// This double-checks that the `Option<Ordering>` intermediate values used
+// in the operators for such a type all optimize away.
+
+#![crate_type = "lib"]
+
+use std::cmp::Ordering;
+
+#[derive(PartialOrd, PartialEq)]
+pub struct Foo(i32, u32);
+
+// CHECK-LABEL: @check_lt(
+// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
+#[no_mangle]
+pub fn check_lt(a: Foo, b: Foo) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R0:.+]] = icmp slt i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R1:.+]] = icmp ult i32 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a < b
+}
+
+// CHECK-LABEL: @check_le(
+// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
+#[no_mangle]
+pub fn check_le(a: Foo, b: Foo) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R0:.+]] = icmp sle i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R1:.+]] = icmp ule i32 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a <= b
+}
+
+// CHECK-LABEL: @check_gt(
+// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
+#[no_mangle]
+pub fn check_gt(a: Foo, b: Foo) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R0:.+]] = icmp sgt i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R1:.+]] = icmp ugt i32 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a > b
+}
+
+// CHECK-LABEL: @check_ge(
+// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
+#[no_mangle]
+pub fn check_ge(a: Foo, b: Foo) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R0:.+]] = icmp sge i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R1:.+]] = icmp uge i32 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a >= b
+}
diff --git a/tests/codegen-llvm/comparison-operators-2-tuple.rs b/tests/codegen-llvm/comparison-operators-2-tuple.rs
new file mode 100644
index 00000000000..6a7e489c82d
--- /dev/null
+++ b/tests/codegen-llvm/comparison-operators-2-tuple.rs
@@ -0,0 +1,117 @@
+//@ compile-flags: -C opt-level=1 -Z merge-functions=disabled
+//@ min-llvm-version: 20
+
+#![crate_type = "lib"]
+
+use std::cmp::Ordering;
+
+type TwoTuple = (i16, u16);
+
+//
+// The operators are all overridden directly, so should optimize easily.
+//
+// slt-vs-sle and sgt-vs-sge don't matter because they're only used in the side
+// of the select where we know the values are not equal, and thus the tests
+// use a regex to allow either, since unimportant changes to the implementation
+// sometimes result in changing what LLVM decides to emit for this.
+//
+
+// CHECK-LABEL: @check_lt_direct
+// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
+#[no_mangle]
+pub fn check_lt_direct(a: TwoTuple, b: TwoTuple) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP0:.+]] = icmp {{slt|sle}} i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP1:.+]] = icmp ult i16 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
+    // CHECK: ret i1 %[[R]]
+    a < b
+}
+
+// CHECK-LABEL: @check_le_direct
+// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
+#[no_mangle]
+pub fn check_le_direct(a: TwoTuple, b: TwoTuple) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP0:.+]] = icmp {{slt|sle}} i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP1:.+]] = icmp ule i16 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
+    // CHECK: ret i1 %[[R]]
+    a <= b
+}
+
+// CHECK-LABEL: @check_gt_direct
+// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
+#[no_mangle]
+pub fn check_gt_direct(a: TwoTuple, b: TwoTuple) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP0:.+]] = icmp {{sgt|sge}} i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP1:.+]] = icmp ugt i16 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
+    // CHECK: ret i1 %[[R]]
+    a > b
+}
+
+// CHECK-LABEL: @check_ge_direct
+// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
+#[no_mangle]
+pub fn check_ge_direct(a: TwoTuple, b: TwoTuple) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP0:.+]] = icmp {{sgt|sge}} i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP1:.+]] = icmp uge i16 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
+    // CHECK: ret i1 %[[R]]
+    a >= b
+}
+
+//
+// These used to not optimize as well, but thanks to LLVM 20 they work now 🎉
+//
+
+// CHECK-LABEL: @check_lt_via_cmp
+// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
+#[no_mangle]
+pub fn check_lt_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP0:.+]] = icmp slt i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP1:.+]] = icmp ult i16 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
+    // CHECK: ret i1 %[[R]]
+    Ord::cmp(&a, &b).is_lt()
+}
+
+// CHECK-LABEL: @check_le_via_cmp
+// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
+#[no_mangle]
+pub fn check_le_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP0:.+]] = icmp sle i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP1:.+]] = icmp ule i16 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
+    // CHECK: ret i1 %[[R]]
+    Ord::cmp(&a, &b).is_le()
+}
+
+// CHECK-LABEL: @check_gt_via_cmp
+// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
+#[no_mangle]
+pub fn check_gt_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP0:.+]] = icmp sgt i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP1:.+]] = icmp ugt i16 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
+    // CHECK: ret i1 %[[R]]
+    Ord::cmp(&a, &b).is_gt()
+}
+
+// CHECK-LABEL: @check_ge_via_cmp
+// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
+#[no_mangle]
+pub fn check_ge_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP0:.+]] = icmp sge i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP1:.+]] = icmp uge i16 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
+    // CHECK: ret i1 %[[R]]
+    Ord::cmp(&a, &b).is_ge()
+}
diff --git a/tests/codegen-llvm/comparison-operators-newtype.rs b/tests/codegen-llvm/comparison-operators-newtype.rs
new file mode 100644
index 00000000000..acce0cb5946
--- /dev/null
+++ b/tests/codegen-llvm/comparison-operators-newtype.rs
@@ -0,0 +1,48 @@
+// The `derive(PartialOrd)` for a newtype doesn't override `lt`/`le`/`gt`/`ge`.
+// This double-checks that the `Option<Ordering>` intermediate values used
+// in the operators for such a type all optimize away.
+
+//@ compile-flags: -C opt-level=1
+
+#![crate_type = "lib"]
+
+use std::cmp::Ordering;
+
+#[derive(PartialOrd, PartialEq)]
+pub struct Foo(u16);
+
+// CHECK-LABEL: @check_lt
+// CHECK-SAME: (i16{{.*}} %[[A:.+]], i16{{.*}} %[[B:.+]])
+#[no_mangle]
+pub fn check_lt(a: Foo, b: Foo) -> bool {
+    // CHECK: %[[R:.+]] = icmp ult i16 %[[A]], %[[B]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a < b
+}
+
+// CHECK-LABEL: @check_le
+// CHECK-SAME: (i16{{.*}} %[[A:.+]], i16{{.*}} %[[B:.+]])
+#[no_mangle]
+pub fn check_le(a: Foo, b: Foo) -> bool {
+    // CHECK: %[[R:.+]] = icmp ule i16 %[[A]], %[[B]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a <= b
+}
+
+// CHECK-LABEL: @check_gt
+// CHECK-SAME: (i16{{.*}} %[[A:.+]], i16{{.*}} %[[B:.+]])
+#[no_mangle]
+pub fn check_gt(a: Foo, b: Foo) -> bool {
+    // CHECK: %[[R:.+]] = icmp ugt i16 %[[A]], %[[B]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a > b
+}
+
+// CHECK-LABEL: @check_ge
+// CHECK-SAME: (i16{{.*}} %[[A:.+]], i16{{.*}} %[[B:.+]])
+#[no_mangle]
+pub fn check_ge(a: Foo, b: Foo) -> bool {
+    // CHECK: %[[R:.+]] = icmp uge i16 %[[A]], %[[B]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a >= b
+}
diff --git a/tests/codegen-llvm/compiletest-self-test/minicore-smoke-test.rs b/tests/codegen-llvm/compiletest-self-test/minicore-smoke-test.rs
new file mode 100644
index 00000000000..9dd1bf29c6c
--- /dev/null
+++ b/tests/codegen-llvm/compiletest-self-test/minicore-smoke-test.rs
@@ -0,0 +1,20 @@
+//! Basic smoke test for `minicore` test auxiliary.
+
+//@ add-core-stubs
+//@ compile-flags: --target=x86_64-unknown-linux-gnu
+//@ needs-llvm-components: x86
+
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+struct Meow;
+impl Copy for Meow {}
+
+// CHECK-LABEL: meow
+#[no_mangle]
+fn meow() {}
diff --git a/tests/codegen-llvm/const-array.rs b/tests/codegen-llvm/const-array.rs
new file mode 100644
index 00000000000..b3df76c3d8e
--- /dev/null
+++ b/tests/codegen-llvm/const-array.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+const LUT: [u8; 4] = [1, 1, 1, 1];
+
+// CHECK-LABEL: @decode
+#[no_mangle]
+pub fn decode(i: u8) -> u8 {
+    // CHECK: start:
+    // CHECK-NEXT: icmp
+    // CHECK-NEXT: select
+    // CHECK-NEXT: ret
+    if i < 4 { LUT[i as usize] } else { 2 }
+}
diff --git a/tests/codegen-llvm/const-vector.rs b/tests/codegen-llvm/const-vector.rs
new file mode 100644
index 00000000000..a2249f4fff7
--- /dev/null
+++ b/tests/codegen-llvm/const-vector.rs
@@ -0,0 +1,78 @@
+//@ revisions: OPT0 OPT0_S390X
+//@ [OPT0] ignore-s390x
+//@ [OPT0_S390X] only-s390x
+//@ [OPT0] compile-flags: -C no-prepopulate-passes -Copt-level=0
+//@ [OPT0_S390X] compile-flags: -C no-prepopulate-passes -Copt-level=0 -C target-cpu=z13
+
+// This test checks that constants of SIMD type are passed as immediate vectors.
+// We ensure that both vector representations (struct with fields and struct wrapping array) work.
+#![crate_type = "lib"]
+#![feature(abi_unadjusted)]
+#![feature(const_trait_impl)]
+#![feature(repr_simd)]
+#![feature(rustc_attrs)]
+#![feature(simd_ffi)]
+#![feature(arm_target_feature)]
+#![feature(mips_target_feature)]
+#![allow(non_camel_case_types)]
+
+#[path = "../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::{PackedSimd as Simd, f32x2, i8x2};
+
+// The following functions are required for the tests to ensure
+// that they are called with a const vector
+
+extern "unadjusted" {
+    fn test_i8x2(a: i8x2);
+    fn test_i8x2_two_args(a: i8x2, b: i8x2);
+    fn test_i8x2_mixed_args(a: i8x2, c: i32, b: i8x2);
+    fn test_i8x2_arr(a: i8x2);
+    fn test_f32x2(a: f32x2);
+    fn test_f32x2_arr(a: f32x2);
+    fn test_simd(a: Simd<i32, 4>);
+    fn test_simd_unaligned(a: Simd<i32, 3>);
+}
+
+// Ensure the packed variant of the simd struct does not become a const vector
+// if the size is not a power of 2
+// CHECK: %"minisimd::PackedSimd<i32, 3>" = type { [3 x i32] }
+
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+pub fn do_call() {
+    unsafe {
+        // CHECK: call void @test_i8x2(<2 x i8> <i8 32, i8 64>
+        test_i8x2(const { i8x2::from_array([32, 64]) });
+
+        // CHECK: call void @test_i8x2_two_args(<2 x i8> <i8 32, i8 64>, <2 x i8> <i8 8, i8 16>
+        test_i8x2_two_args(
+            const { i8x2::from_array([32, 64]) },
+            const { i8x2::from_array([8, 16]) },
+        );
+
+        // CHECK: call void @test_i8x2_mixed_args(<2 x i8> <i8 32, i8 64>, i32 43, <2 x i8> <i8 8, i8 16>
+        test_i8x2_mixed_args(
+            const { i8x2::from_array([32, 64]) },
+            43,
+            const { i8x2::from_array([8, 16]) },
+        );
+
+        // CHECK: call void @test_i8x2_arr(<2 x i8> <i8 32, i8 64>
+        test_i8x2_arr(const { i8x2::from_array([32, 64]) });
+
+        // CHECK: call void @test_f32x2(<2 x float> <float 0x3FD47AE140000000, float 0x3FE47AE140000000>
+        test_f32x2(const { f32x2::from_array([0.32, 0.64]) });
+
+        // CHECK: void @test_f32x2_arr(<2 x float> <float 0x3FD47AE140000000, float 0x3FE47AE140000000>
+        test_f32x2_arr(const { f32x2::from_array([0.32, 0.64]) });
+
+        // CHECK: call void @test_simd(<4 x i32> <i32 2, i32 4, i32 6, i32 8>
+        test_simd(const { Simd::<i32, 4>([2, 4, 6, 8]) });
+
+        // CHECK: call void @test_simd_unaligned(%"minisimd::PackedSimd<i32, 3>" %1
+        test_simd_unaligned(const { Simd::<i32, 3>([2, 4, 6]) });
+    }
+}
diff --git a/tests/codegen-llvm/const_scalar_pair.rs b/tests/codegen-llvm/const_scalar_pair.rs
new file mode 100644
index 00000000000..f142896c31f
--- /dev/null
+++ b/tests/codegen-llvm/const_scalar_pair.rs
@@ -0,0 +1,8 @@
+//@ compile-flags: --crate-type=lib -Copt-level=0 -Zmir-opt-level=0 -C debuginfo=2
+
+// Test that we don't generate a memory allocation for the constant
+// and read the fields from that, but instead just create the value pair directly.
+pub fn foo() -> (i32, i32) {
+    // CHECK: ret { i32, i32 } { i32 1, i32 2 }
+    const { (1, 2) }
+}
diff --git a/tests/codegen-llvm/constant-branch.rs b/tests/codegen-llvm/constant-branch.rs
new file mode 100644
index 00000000000..8fc8fb4f57a
--- /dev/null
+++ b/tests/codegen-llvm/constant-branch.rs
@@ -0,0 +1,49 @@
+//@ compile-flags: -Zmir-opt-level=0 -C no-prepopulate-passes -Copt-level=0
+// make sure that branching on a constant does not emit a conditional
+// branch or a switch
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @if_bool
+#[no_mangle]
+pub fn if_bool() {
+    // CHECK-NOT: br i1
+    // CHECK-NOT: switch
+    _ = if true { 0 } else { 1 };
+
+    _ = if false { 0 } else { 1 };
+}
+
+// CHECK-LABEL: @if_constant_int_eq
+#[no_mangle]
+pub fn if_constant_int_eq() {
+    // CHECK-NOT: br i1
+    // CHECK-NOT: switch
+    let val = 0;
+    _ = if val == 0 { 0 } else { 1 };
+
+    // CHECK: br label %{{.+}}
+    _ = if val == 1 { 0 } else { 1 };
+}
+
+// CHECK-LABEL: @if_constant_match
+#[no_mangle]
+pub fn if_constant_match() {
+    // CHECK-NOT: br i1
+    // CHECK-NOT: switch
+    _ = match 1 {
+        1 => 2,
+        2 => 3,
+        _ => 4,
+    };
+
+    _ = match 1 {
+        2 => 3,
+        _ => 4,
+    };
+
+    _ = match -1 {
+        -1 => 1,
+        _ => 0,
+    }
+}
diff --git a/tests/codegen-llvm/consts.rs b/tests/codegen-llvm/consts.rs
new file mode 100644
index 00000000000..42ce7679d1a
--- /dev/null
+++ b/tests/codegen-llvm/consts.rs
@@ -0,0 +1,55 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+// Below, these constants are defined as enum variants that by itself would
+// have a lower alignment than the enum type. Ensure that we mark them
+// correctly with the higher alignment of the enum.
+
+// CHECK: @STATIC = {{.*}}, align 4
+
+// This checks the constants from inline_enum_const
+// CHECK: @alloc_[[INLINE_ENUM_HASH:[a-f0-9]{32}]] = {{.*}}, align 2
+
+// This checks the constants from {low,high}_align_const, they share the same
+// constant, but the alignment differs, so the higher one should be used
+// CHECK: [[LOW_HIGH:@alloc_[a-f0-9]{32}]] = {{.*}}, align 4
+
+#[derive(Copy, Clone)]
+// repr(i16) is required for the {low,high}_align_const test
+#[repr(i16)]
+pub enum E<A, B> {
+    A(A),
+    B(B),
+}
+
+#[no_mangle]
+pub static STATIC: E<i16, i32> = E::A(0);
+
+// CHECK-LABEL: @static_enum_const
+#[no_mangle]
+pub fn static_enum_const() -> E<i16, i32> {
+    STATIC
+}
+
+// CHECK-LABEL: @inline_enum_const
+#[no_mangle]
+pub fn inline_enum_const() -> E<i8, i16> {
+    *&E::A(0)
+}
+
+// CHECK-LABEL: @low_align_const
+#[no_mangle]
+pub fn low_align_const() -> E<i16, [i16; 3]> {
+    // Check that low_align_const and high_align_const use the same constant
+    // CHECK: memcpy.{{.+}}(ptr align 2 %_0, ptr align 2 {{.*}}[[LOW_HIGH]]{{.*}}, i{{(32|64)}} 8, i1 false)
+    *&E::A(0)
+}
+
+// CHECK-LABEL: @high_align_const
+#[no_mangle]
+pub fn high_align_const() -> E<i16, i32> {
+    // Check that low_align_const and high_align_const use the same constant
+    // CHECK: memcpy.{{.+}}(ptr align 4 %_0, ptr align 4 {{.*}}[[LOW_HIGH]]{{.*}}, i{{(32|64)}} 8, i1 false)
+    *&E::A(0)
+}
diff --git a/tests/codegen-llvm/coroutine-debug-msvc.rs b/tests/codegen-llvm/coroutine-debug-msvc.rs
new file mode 100644
index 00000000000..9e2ec3ea28a
--- /dev/null
+++ b/tests/codegen-llvm/coroutine-debug-msvc.rs
@@ -0,0 +1,60 @@
+// Verify debuginfo for coroutines:
+//  - Each variant points to the file and line of its yield point
+//  - The discriminants are marked artificial
+//  - Other fields are not marked artificial
+//
+//
+//@ compile-flags: -C debuginfo=2
+//@ only-msvc
+
+#![feature(coroutines, coroutine_trait)]
+use std::ops::Coroutine;
+
+fn coroutine_test() -> impl Coroutine<Yield = i32, Return = ()> {
+    #[coroutine]
+    || {
+        yield 0;
+        let s = String::from("foo");
+        yield 1;
+    }
+}
+
+// FIXME: No way to reliably check the filename.
+
+// CHECK-DAG:  [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<coroutine_debug_msvc::coroutine_test::coroutine_env$0>"
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant0", scope: [[GEN]],
+// For brevity, we only check the struct name and members of the last variant.
+// CHECK-SAME: file: [[FILE:![0-9]*]], line: 15,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant1", scope: [[GEN]],
+// CHECK-SAME: file: [[FILE]], line: 19,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant2", scope: [[GEN]],
+// CHECK-SAME: file: [[FILE]], line: 19,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant3", scope: [[GEN]],
+// CHECK-SAME: file: [[FILE]], line: 16,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant4", scope: [[GEN]],
+// CHECK-SAME: file: [[FILE]], line: 18,
+// CHECK-SAME: baseType: [[VARIANT_WRAPPER:![0-9]*]]
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      [[VARIANT_WRAPPER]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Variant4", scope: [[GEN]],
+// CHECK:      !DIDerivedType(tag: DW_TAG_member, name: "value", scope: [[VARIANT_WRAPPER]], {{.*}}, baseType: [[VARIANT:![0-9]*]],
+// CHECK:      [[VARIANT]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[GEN]],
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[VARIANT]]
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "tag", scope: [[GEN]],
+// CHECK-NOT: flags: DIFlagArtificial
+
+fn main() {
+    let _dummy = coroutine_test();
+}
diff --git a/tests/codegen-llvm/coroutine-debug.rs b/tests/codegen-llvm/coroutine-debug.rs
new file mode 100644
index 00000000000..ff62e9709b4
--- /dev/null
+++ b/tests/codegen-llvm/coroutine-debug.rs
@@ -0,0 +1,64 @@
+// Verify debuginfo for coroutines:
+//  - Each variant points to the file and line of its yield point
+//  - The discriminants are marked artificial
+//  - Other fields are not marked artificial
+//
+//
+//@ compile-flags: -C debuginfo=2
+//@ edition: 2018
+//@ ignore-msvc
+
+#![feature(coroutines, coroutine_trait)]
+use std::ops::Coroutine;
+
+fn coroutine_test() -> impl Coroutine<Yield = i32, Return = ()> {
+    #[coroutine]
+    || {
+        yield 0;
+        let s = String::from("foo");
+        yield 1;
+    }
+}
+
+// FIXME: No way to reliably check the filename.
+
+// CHECK-DAG:  [[GEN_FN:!.*]] = !DINamespace(name: "coroutine_test"
+// CHECK-DAG:  [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{coroutine_env#0}", scope: [[GEN_FN]]
+// CHECK:      [[VARIANT:!.*]] = !DICompositeType(tag: DW_TAG_variant_part, scope: [[GEN]],
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: discriminator: [[DISC:![0-9]*]]
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "0", scope: [[VARIANT]],
+// CHECK-SAME: file: [[FILE:![0-9]*]], line: 16,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "Unresumed", scope: [[GEN]],
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "1", scope: [[VARIANT]],
+// CHECK-SAME: file: [[FILE]], line: 20,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "2", scope: [[VARIANT]],
+// CHECK-SAME: file: [[FILE]], line: 20,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "3", scope: [[VARIANT]],
+// CHECK-SAME: file: [[FILE]], line: 17,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "4", scope: [[VARIANT]],
+// CHECK-SAME: file: [[FILE]], line: 19,
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      [[S1:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[GEN]],
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[S1]]
+// CHECK-NOT:  flags: DIFlagArtificial
+// CHECK-SAME: )
+// CHECK:      [[DISC]] = !DIDerivedType(tag: DW_TAG_member, name: "__state", scope: [[GEN]],
+// CHECK-SAME: flags: DIFlagArtificial
+
+fn main() {
+    let _dummy = coroutine_test();
+}
diff --git a/tests/codegen-llvm/cross-crate-inlining/always-inline.rs b/tests/codegen-llvm/cross-crate-inlining/always-inline.rs
new file mode 100644
index 00000000000..df28b3fe197
--- /dev/null
+++ b/tests/codegen-llvm/cross-crate-inlining/always-inline.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -Copt-level=3
+//@ aux-build:always.rs
+
+#![crate_type = "lib"]
+
+extern crate always;
+
+// Check that we inline a cross-crate call, even though it isn't a leaf
+#[no_mangle]
+pub fn outer() -> String {
+    // CHECK-NOT: call {{.*}}stem_fn
+    always::stem_fn()
+}
diff --git a/tests/codegen-llvm/cross-crate-inlining/auxiliary/always.rs b/tests/codegen-llvm/cross-crate-inlining/auxiliary/always.rs
new file mode 100644
index 00000000000..6ee3f81e3c8
--- /dev/null
+++ b/tests/codegen-llvm/cross-crate-inlining/auxiliary/always.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -Copt-level=3 -Zcross-crate-inline-threshold=always
+
+#![crate_type = "lib"]
+
+// This function *looks* like it contains a call, but that call will be optimized out by MIR
+// optimizations.
+pub fn leaf_fn() -> String {
+    String::new()
+}
+
+// This function contains a call, even after MIR optimizations. It is only eligible for
+// cross-crate-inlining with "always".
+pub fn stem_fn() -> String {
+    inner()
+}
+
+#[inline(never)]
+fn inner() -> String {
+    String::from("test")
+}
diff --git a/tests/codegen-llvm/cross-crate-inlining/auxiliary/leaf.rs b/tests/codegen-llvm/cross-crate-inlining/auxiliary/leaf.rs
new file mode 100644
index 00000000000..d059a3d0a73
--- /dev/null
+++ b/tests/codegen-llvm/cross-crate-inlining/auxiliary/leaf.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// This function *looks* like it contains a call, but that call will be optimized out by MIR
+// optimizations.
+pub fn leaf_fn() -> String {
+    String::new()
+}
+
+// This function contains a call, even after MIR optimizations. It is only eligible for
+// cross-crate-inlining with "always".
+pub fn stem_fn() -> String {
+    inner()
+}
+
+#[inline(never)]
+fn inner() -> String {
+    String::from("test")
+}
diff --git a/tests/codegen-llvm/cross-crate-inlining/auxiliary/never.rs b/tests/codegen-llvm/cross-crate-inlining/auxiliary/never.rs
new file mode 100644
index 00000000000..55c90809ec1
--- /dev/null
+++ b/tests/codegen-llvm/cross-crate-inlining/auxiliary/never.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -Copt-level=3 -Zcross-crate-inline-threshold=never
+
+#![crate_type = "lib"]
+
+// This function *looks* like it contains a call, but that call will be optimized out by MIR
+// optimizations.
+pub fn leaf_fn() -> String {
+    String::new()
+}
+
+// This function contains a call, even after MIR optimizations. It is only eligible for
+// cross-crate-inlining with "always".
+pub fn stem_fn() -> String {
+    inner()
+}
+
+#[inline(never)]
+fn inner() -> String {
+    String::from("test")
+}
diff --git a/tests/codegen-llvm/cross-crate-inlining/leaf-inlining.rs b/tests/codegen-llvm/cross-crate-inlining/leaf-inlining.rs
new file mode 100644
index 00000000000..37132312ca9
--- /dev/null
+++ b/tests/codegen-llvm/cross-crate-inlining/leaf-inlining.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -Copt-level=3 -Zcross-crate-inline-threshold=yes
+//@ aux-build:leaf.rs
+
+#![crate_type = "lib"]
+
+extern crate leaf;
+
+// Check that we inline a leaf cross-crate call
+#[no_mangle]
+pub fn leaf_outer() -> String {
+    // CHECK-NOT: call {{.*}}leaf_fn
+    leaf::leaf_fn()
+}
+
+// Check that we do not inline a non-leaf cross-crate call
+#[no_mangle]
+pub fn stem_outer() -> String {
+    // CHECK: call {{.*}}stem_fn
+    leaf::stem_fn()
+}
diff --git a/tests/codegen-llvm/cross-crate-inlining/never-inline.rs b/tests/codegen-llvm/cross-crate-inlining/never-inline.rs
new file mode 100644
index 00000000000..759f65d9d42
--- /dev/null
+++ b/tests/codegen-llvm/cross-crate-inlining/never-inline.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -Copt-level=3
+//@ aux-build:never.rs
+
+#![crate_type = "lib"]
+
+extern crate never;
+
+// Check that we do not inline a cross-crate call, even though it is a leaf
+#[no_mangle]
+pub fn outer() -> String {
+    // CHECK: call {{.*}}leaf_fn
+    never::leaf_fn()
+}
diff --git a/tests/codegen-llvm/dealloc-no-unwind.rs b/tests/codegen-llvm/dealloc-no-unwind.rs
new file mode 100644
index 00000000000..68597817d6f
--- /dev/null
+++ b/tests/codegen-llvm/dealloc-no-unwind.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+struct A;
+
+impl Drop for A {
+    fn drop(&mut self) {
+        extern "C" {
+            fn foo();
+        }
+        unsafe {
+            foo();
+        }
+    }
+}
+
+#[no_mangle]
+pub fn a(a: Box<i32>) {
+    // CHECK-LABEL: define{{.*}}void @a
+    // CHECK: call void @{{.*}}__rust_dealloc
+    // CHECK-NEXT: call void @foo
+    let _a = A;
+    drop(a);
+}
diff --git a/tests/codegen-llvm/debug-accessibility/crate-enum.rs b/tests/codegen-llvm/debug-accessibility/crate-enum.rs
new file mode 100644
index 00000000000..9ad5a6fd0ff
--- /dev/null
+++ b/tests/codegen-llvm/debug-accessibility/crate-enum.rs
@@ -0,0 +1,28 @@
+// ignore-tidy-linelength
+//! Checks that visibility information is present in the debuginfo for crate-visibility enums.
+
+//@ revisions: MSVC NONMSVC
+//@[MSVC] only-msvc
+//@[NONMSVC] ignore-msvc
+
+//@ compile-flags: -C debuginfo=2
+
+mod module {
+    use std::hint::black_box;
+
+    pub(crate) enum CrateFooEnum {
+        A,
+        B(u32),
+        C { x: u32 },
+    }
+
+    // NONMSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "CrateFooEnum"{{.*}}flags: DIFlagProtected{{.*}})
+    // MSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<crate_enum::module::CrateFooEnum>"{{.*}}flags: DIFlagProtected{{.*}})
+    pub fn use_everything() {
+        black_box(CrateFooEnum::A);
+    }
+}
+
+fn main() {
+    module::use_everything();
+}
diff --git a/tests/codegen-llvm/debug-accessibility/crate-struct.rs b/tests/codegen-llvm/debug-accessibility/crate-struct.rs
new file mode 100644
index 00000000000..73a8ce852ed
--- /dev/null
+++ b/tests/codegen-llvm/debug-accessibility/crate-struct.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -C debuginfo=2
+
+#![allow(dead_code)]
+
+// Checks that visibility information is present in the debuginfo for crate-visibility structs.
+
+mod module {
+    use std::hint::black_box;
+
+    pub(crate) struct CrateFooStruct {
+        x: u32,
+    }
+
+    // CHECK: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "CrateFooStruct"{{.*}}flags: DIFlagProtected{{.*}})
+
+    pub fn use_everything() {
+        black_box(CrateFooStruct { x: 2 });
+    }
+}
+
+fn main() {
+    module::use_everything();
+}
diff --git a/tests/codegen-llvm/debug-accessibility/private-enum.rs b/tests/codegen-llvm/debug-accessibility/private-enum.rs
new file mode 100644
index 00000000000..002336c03b3
--- /dev/null
+++ b/tests/codegen-llvm/debug-accessibility/private-enum.rs
@@ -0,0 +1,22 @@
+// ignore-tidy-linelength
+//! Checks that visibility information is present in the debuginfo for private enums.
+
+//@ revisions: MSVC NONMSVC
+//@[MSVC] only-msvc
+//@[NONMSVC] ignore-msvc
+//@ compile-flags: -C debuginfo=2
+
+use std::hint::black_box;
+
+enum PrivateFooEnum {
+    A,
+    B(u32),
+    C { x: u32 },
+}
+
+// NONMSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "PrivateFooEnum"{{.*}}flags: DIFlagPrivate{{.*}})
+// MSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<private_enum::PrivateFooEnum>"{{.*}}flags: DIFlagPrivate{{.*}})
+
+fn main() {
+    black_box(PrivateFooEnum::A);
+}
diff --git a/tests/codegen-llvm/debug-accessibility/private-struct.rs b/tests/codegen-llvm/debug-accessibility/private-struct.rs
new file mode 100644
index 00000000000..488a680e81c
--- /dev/null
+++ b/tests/codegen-llvm/debug-accessibility/private-struct.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -C debuginfo=2
+
+#![allow(dead_code)]
+
+// Checks that visibility information is present in the debuginfo for private structs.
+
+use std::hint::black_box;
+
+struct PrivateFooStruct {
+    x: u32,
+}
+
+// CHECK: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "PrivateFooStruct"{{.*}}flags: DIFlagPrivate{{.*}})
+
+fn main() {
+    black_box(PrivateFooStruct { x: 1 });
+}
diff --git a/tests/codegen-llvm/debug-accessibility/public-enum.rs b/tests/codegen-llvm/debug-accessibility/public-enum.rs
new file mode 100644
index 00000000000..e5cd1ab7350
--- /dev/null
+++ b/tests/codegen-llvm/debug-accessibility/public-enum.rs
@@ -0,0 +1,23 @@
+// ignore-tidy-linelength
+//! Checks that visibility information is present in the debuginfo for types and their fields.
+
+//@ revisions: MSVC NONMSVC
+//@[MSVC] only-msvc
+//@[NONMSVC] ignore-msvc
+
+//@ compile-flags: -C debuginfo=2
+
+use std::hint::black_box;
+
+pub enum PublicFooEnum {
+    A,
+    B(u32),
+    C { x: u32 },
+}
+
+// NONMSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "PublicFooEnum"{{.*}}flags: DIFlagPublic{{.*}})
+// MSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<public_enum::PublicFooEnum>"{{.*}}flags: DIFlagPublic{{.*}})
+
+fn main() {
+    black_box(PublicFooEnum::A);
+}
diff --git a/tests/codegen-llvm/debug-accessibility/public-struct.rs b/tests/codegen-llvm/debug-accessibility/public-struct.rs
new file mode 100644
index 00000000000..8b2a53f993c
--- /dev/null
+++ b/tests/codegen-llvm/debug-accessibility/public-struct.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -C debuginfo=2
+
+#![allow(dead_code)]
+
+// Checks that visibility information is present in the debuginfo for public structs.
+
+use std::hint::black_box;
+
+pub struct PublicFooStruct {
+    x: u32,
+}
+
+// CHECK: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "PublicFooStruct"{{.*}}flags: DIFlagPublic{{.*}})
+
+fn main() {
+    black_box(PublicFooStruct { x: 4 });
+}
diff --git a/tests/codegen-llvm/debug-accessibility/struct-fields.rs b/tests/codegen-llvm/debug-accessibility/struct-fields.rs
new file mode 100644
index 00000000000..f68bb3438be
--- /dev/null
+++ b/tests/codegen-llvm/debug-accessibility/struct-fields.rs
@@ -0,0 +1,30 @@
+//@ compile-flags: -C debuginfo=2
+
+#![allow(dead_code)]
+
+// Checks that visibility information is present in the debuginfo for struct fields.
+
+mod module {
+    use std::hint::black_box;
+
+    struct StructFields {
+        a: u32,
+        pub(crate) b: u32,
+        pub(super) c: u32,
+        pub d: u32,
+    }
+
+    // CHECK: [[StructFields:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "StructFields"{{.*}}flags: DIFlagPrivate{{.*}})
+    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: [[StructFields]]{{.*}}flags: DIFlagPrivate{{.*}})
+    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: [[StructFields]]{{.*}}flags: DIFlagProtected{{.*}})
+    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "c", scope: [[StructFields]]{{.*}}flags: DIFlagProtected{{.*}})
+    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "d", scope: [[StructFields]]{{.*}}flags: DIFlagPublic{{.*}})
+
+    pub fn use_everything() {
+        black_box(StructFields { a: 1, b: 2, c: 3, d: 4 });
+    }
+}
+
+fn main() {
+    module::use_everything();
+}
diff --git a/tests/codegen-llvm/debug-accessibility/super-enum.rs b/tests/codegen-llvm/debug-accessibility/super-enum.rs
new file mode 100644
index 00000000000..8e34d8be01f
--- /dev/null
+++ b/tests/codegen-llvm/debug-accessibility/super-enum.rs
@@ -0,0 +1,28 @@
+// ignore-tidy-linelength
+//! Checks that visibility information is present in the debuginfo for super-visibility enums.
+
+//@ revisions: MSVC NONMSVC
+//@[MSVC] only-msvc
+//@[NONMSVC] ignore-msvc
+//@ compile-flags: -C debuginfo=2
+
+mod module {
+    use std::hint::black_box;
+
+    pub(super) enum SuperFooEnum {
+        A,
+        B(u32),
+        C { x: u32 },
+    }
+
+    // NONMSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "SuperFooEnum"{{.*}}flags: DIFlagProtected{{.*}})
+    // MSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<super_enum::module::SuperFooEnum>"{{.*}}flags: DIFlagProtected{{.*}})
+
+    pub fn use_everything() {
+        black_box(SuperFooEnum::A);
+    }
+}
+
+fn main() {
+    module::use_everything();
+}
diff --git a/tests/codegen-llvm/debug-accessibility/super-struct.rs b/tests/codegen-llvm/debug-accessibility/super-struct.rs
new file mode 100644
index 00000000000..63954bfb203
--- /dev/null
+++ b/tests/codegen-llvm/debug-accessibility/super-struct.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -C debuginfo=2
+
+#![allow(dead_code)]
+
+// Checks that visibility information is present in the debuginfo for super-visibility structs.
+
+mod module {
+    use std::hint::black_box;
+
+    pub(super) struct SuperFooStruct {
+        x: u32,
+    }
+
+    // CHECK: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "SuperFooStruct"{{.*}}flags: DIFlagProtected{{.*}})
+
+    pub fn use_everything() {
+        black_box(SuperFooStruct { x: 3 });
+    }
+}
+
+fn main() {
+    module::use_everything();
+}
diff --git a/tests/codegen-llvm/debug-accessibility/tuple-fields.rs b/tests/codegen-llvm/debug-accessibility/tuple-fields.rs
new file mode 100644
index 00000000000..feec6e9eb41
--- /dev/null
+++ b/tests/codegen-llvm/debug-accessibility/tuple-fields.rs
@@ -0,0 +1,24 @@
+//@ compile-flags: -C debuginfo=2
+
+#![allow(dead_code)]
+
+// Checks that visibility information is present in the debuginfo for tuple struct fields.
+
+mod module {
+    use std::hint::black_box;
+
+    struct TupleFields(u32, pub(crate) u32, pub(super) u32, pub u32);
+
+    // CHECK: [[TupleFields:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "TupleFields"{{.*}}flags: DIFlagPrivate{{.*}})
+    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "__0", scope: [[TupleFields]]{{.*}}flags: DIFlagPrivate{{.*}})
+    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "__1", scope: [[TupleFields]]{{.*}}flags: DIFlagProtected{{.*}})
+    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "__2", scope: [[TupleFields]]{{.*}}flags: DIFlagProtected{{.*}})
+    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "__3", scope: [[TupleFields]]{{.*}}flags: DIFlagPublic{{.*}})
+    pub fn use_everything() {
+        black_box(TupleFields(1, 2, 3, 4));
+    }
+}
+
+fn main() {
+    module::use_everything();
+}
diff --git a/tests/codegen-llvm/debug-alignment.rs b/tests/codegen-llvm/debug-alignment.rs
new file mode 100644
index 00000000000..02fe05832a3
--- /dev/null
+++ b/tests/codegen-llvm/debug-alignment.rs
@@ -0,0 +1,8 @@
+// Verifies that DWARF alignment is specified properly.
+//
+//@ compile-flags: -C debuginfo=2
+#![crate_type = "lib"]
+
+// CHECK: !DIGlobalVariable
+// CHECK: align: 32
+pub static A: u32 = 1;
diff --git a/tests/codegen-llvm/debug-column-msvc.rs b/tests/codegen-llvm/debug-column-msvc.rs
new file mode 100644
index 00000000000..39f77f41329
--- /dev/null
+++ b/tests/codegen-llvm/debug-column-msvc.rs
@@ -0,0 +1,16 @@
+// Verify that no column information is emitted for MSVC targets
+//
+//@ only-msvc
+//@ compile-flags: -C debuginfo=2
+
+// CHECK-NOT: !DILexicalBlock({{.*}}column: {{.*}})
+// CHECK-NOT: !DILocation({{.*}}column: {{.*}})
+
+pub fn add(a: u32, b: u32) -> u32 {
+    a + b
+}
+
+fn main() {
+    let c = add(1, 2);
+    println!("{}", c);
+}
diff --git a/tests/codegen-llvm/debug-column.rs b/tests/codegen-llvm/debug-column.rs
new file mode 100644
index 00000000000..2aa0a8a864c
--- /dev/null
+++ b/tests/codegen-llvm/debug-column.rs
@@ -0,0 +1,25 @@
+// Verify that debuginfo column numbers are 1-based byte offsets.
+//
+//@ ignore-msvc
+//@ compile-flags: -C debuginfo=2
+
+#[rustfmt::skip]
+fn main() {
+    unsafe {
+        // Column numbers are 1-based. Regression test for #65437.
+        // CHECK: call void @giraffe(){{( #[0-9]+)?}}, !dbg [[A:!.*]]
+        giraffe();
+
+        // Column numbers use byte offests. Regression test for #67360
+        // CHECK: call void @turtle(){{( #[0-9]+)?}}, !dbg [[B:!.*]]
+/* ż */ turtle();
+
+        // CHECK: [[A]] = !DILocation(line: 11, column: 9,
+        // CHECK: [[B]] = !DILocation(line: 15, column: 10,
+    }
+}
+
+extern "C" {
+    fn giraffe();
+    fn turtle();
+}
diff --git a/tests/codegen-llvm/debug-compile-unit-path.rs b/tests/codegen-llvm/debug-compile-unit-path.rs
new file mode 100644
index 00000000000..6131d9d7351
--- /dev/null
+++ b/tests/codegen-llvm/debug-compile-unit-path.rs
@@ -0,0 +1,9 @@
+//@ compile-flags: -g --remap-path-prefix={{cwd}}=/cwd/ --remap-path-prefix={{src-base}}=/base/
+//
+//
+// Ensure that we remap the compile unit directory and that we set it to the compilers current
+// working directory and not something else.
+#![crate_type = "rlib"]
+
+// CHECK-DAG: [[FILE:![0-9]*]] = !DIFile(filename: "/base/debug-compile-unit-path.rs{{.*}}", directory: "/cwd/")
+// CHECK-DAG: {{![0-9]*}} = distinct !DICompileUnit({{.*}}file: [[FILE]]
diff --git a/tests/codegen-llvm/debug-fndef-size.rs b/tests/codegen-llvm/debug-fndef-size.rs
new file mode 100644
index 00000000000..8f716c34e7b
--- /dev/null
+++ b/tests/codegen-llvm/debug-fndef-size.rs
@@ -0,0 +1,20 @@
+// Verify that `i32::cmp` FnDef type is declared with a size of 0 and an
+// alignment of 8 bits (1 byte) in LLVM debuginfo.
+
+//@ compile-flags: -Copt-level=3 -g -Cno-prepopulate-passes
+//@ ignore-msvc the types are mangled differently
+
+use std::cmp::Ordering;
+
+fn foo<F: FnOnce(&i32, &i32) -> Ordering>(v1: i32, v2: i32, compare: F) -> Ordering {
+    compare(&v1, &v2)
+}
+
+pub fn main() {
+    foo(0, 1, i32::cmp);
+}
+
+// CHECK: %compare.dbg.spill = alloca [0 x i8], align 1
+// CHECK: dbg{{.}}declare({{(metadata )?}}ptr %compare.dbg.spill, {{(metadata )?}}![[VAR:.*]], {{(metadata )?}}!DIExpression()
+// CHECK: ![[TYPE:.*]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "fn(&i32, &i32) -> core::cmp::Ordering", baseType: !{{.*}}, align: 8, dwarfAddressSpace: {{.*}})
+// CHECK: ![[VAR]] = !DILocalVariable(name: "compare", scope: !{{.*}}, file: !{{.*}}, line: {{.*}}, type: ![[TYPE]], align: 8)
diff --git a/tests/codegen-llvm/debug-limited.rs b/tests/codegen-llvm/debug-limited.rs
new file mode 100644
index 00000000000..89a4ef0ca90
--- /dev/null
+++ b/tests/codegen-llvm/debug-limited.rs
@@ -0,0 +1,27 @@
+// Verify that the limited debuginfo option emits llvm's FullDebugInfo, but no type info.
+//
+//@ compile-flags: -C debuginfo=limited
+
+#[repr(C)]
+struct StructType {
+    a: i64,
+    b: i32,
+}
+
+extern "C" {
+    fn creator() -> *mut StructType;
+    fn save(p: *const StructType);
+}
+
+fn main() {
+    unsafe {
+        let value: &mut StructType = &mut *creator();
+        value.a = 7;
+        save(value as *const StructType)
+    }
+}
+
+// CHECK: !DICompileUnit
+// CHECK: emissionKind: FullDebug
+// CHECK: !DILocation
+// CHECK-NOT: !DIBasicType
diff --git a/tests/codegen-llvm/debug-line-directives-only.rs b/tests/codegen-llvm/debug-line-directives-only.rs
new file mode 100644
index 00000000000..709c8789bf8
--- /dev/null
+++ b/tests/codegen-llvm/debug-line-directives-only.rs
@@ -0,0 +1,27 @@
+// Verify that the only debuginfo generated are the line directives.
+//
+//@ compile-flags: -C debuginfo=line-directives-only
+
+#[repr(C)]
+struct StructType {
+    a: i64,
+    b: i32,
+}
+
+extern "C" {
+    fn creator() -> *mut StructType;
+    fn save(p: *const StructType);
+}
+
+fn main() {
+    unsafe {
+        let value: &mut StructType = &mut *creator();
+        value.a = 7;
+        save(value as *const StructType)
+    }
+}
+
+// CHECK: !DICompileUnit
+// CHECK: emissionKind: DebugDirectivesOnly
+// CHECK: !DILocation
+// CHECK-NOT: !DIBasicType
diff --git a/tests/codegen-llvm/debug-line-tables-only.rs b/tests/codegen-llvm/debug-line-tables-only.rs
new file mode 100644
index 00000000000..d50bffe6e60
--- /dev/null
+++ b/tests/codegen-llvm/debug-line-tables-only.rs
@@ -0,0 +1,27 @@
+// Verify that the only debuginfo generated are the line tables.
+//
+//@ compile-flags: -C debuginfo=line-tables-only
+
+#[repr(C)]
+struct StructType {
+    a: i64,
+    b: i32,
+}
+
+extern "C" {
+    fn creator() -> *mut StructType;
+    fn save(p: *const StructType);
+}
+
+fn main() {
+    unsafe {
+        let value: &mut StructType = &mut *creator();
+        value.a = 7;
+        save(value as *const StructType)
+    }
+}
+
+// CHECK: !DICompileUnit
+// CHECK: emissionKind: LineTablesOnly
+// CHECK: !DILocation
+// CHECK-NOT: !DIBasicType
diff --git a/tests/codegen-llvm/debug-linkage-name.rs b/tests/codegen-llvm/debug-linkage-name.rs
new file mode 100644
index 00000000000..e706040f331
--- /dev/null
+++ b/tests/codegen-llvm/debug-linkage-name.rs
@@ -0,0 +1,42 @@
+// Verifies that linkage name is omitted when it is
+// the same as variable / function name.
+//
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+//@ compile-flags: -C debuginfo=2 -Copt-level=0
+#![crate_type = "lib"]
+
+pub mod xyz {
+    // CHECK: !DIGlobalVariable(name: "A",
+    // CHECK:                   linkageName:
+    // CHECK-SAME:              line: 12,
+    pub static A: u32 = 1;
+
+    // CHECK: !DIGlobalVariable(name: "B",
+    // CHECK-NOT:               linkageName:
+    // CHECK-SAME:              line: 18,
+    #[no_mangle]
+    pub static B: u32 = 2;
+
+    // CHECK: !DIGlobalVariable(name: "C",
+    // CHECK-NOT:               linkageName:
+    // CHECK-SAME:              line: 24,
+    #[export_name = "C"]
+    pub static C: u32 = 2;
+
+    // CHECK: !DISubprogram(name: "e",
+    // CHECK:               linkageName:
+    // CHECK-SAME:          line: 29,
+    pub extern "C" fn e() {}
+
+    // CHECK: !DISubprogram(name: "f",
+    // CHECK-NOT:           linkageName:
+    // CHECK-SAME:          line: 35,
+    #[no_mangle]
+    pub extern "C" fn f() {}
+
+    // CHECK: !DISubprogram(name: "g",
+    // CHECK-NOT:           linkageName:
+    // CHECK-SAME:          line: 41,
+    #[export_name = "g"]
+    pub extern "C" fn g() {}
+}
diff --git a/tests/codegen-llvm/debug-vtable.rs b/tests/codegen-llvm/debug-vtable.rs
new file mode 100644
index 00000000000..8a7b1cc3c4b
--- /dev/null
+++ b/tests/codegen-llvm/debug-vtable.rs
@@ -0,0 +1,117 @@
+// ignore-tidy-linelength
+//! This test checks the debuginfo for the expected 3 vtables is generated for correct names and
+//! number of entries.
+
+//@ revisions: MSVC NONMSVC
+//@[MSVC] only-msvc
+//@[NONMSVC] ignore-msvc
+
+// Use the v0 symbol mangling scheme to codegen order independent of rustc version.
+// Unnamed items like shims are generated in lexicographical order of their symbol name and in the
+// legacy mangling scheme rustc version and generic parameters are both hashed into a single part
+// of the name, thus randomizing item order with respect to rustc version.
+
+//@ compile-flags: -Cdebuginfo=2 -Copt-level=0 -Csymbol-mangling-version=v0
+
+// Make sure that vtables don't have the unnamed_addr attribute when debuginfo is enabled.
+// This helps debuggers more reliably map from dyn pointer to concrete type.
+// CHECK: @vtable.2 = private constant [
+// CHECK: @vtable.3 = private constant <{
+// CHECK: @vtable.4 = private constant <{
+
+// NONMSVC: ![[USIZE:[0-9]+]] = !DIBasicType(name: "usize"
+// MSVC: ![[USIZE:[0-9]+]] = !DIDerivedType(tag: DW_TAG_typedef, name: "usize"
+// NONMSVC: ![[PTR:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "*const ()"
+// MSVC: ![[PTR:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "ptr_const$<tuple$<> >"
+
+// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as debug_vtable::SomeTrait>::{vtable}"
+// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, debug_vtable::SomeTrait>::vtable$"
+
+// NONMSVC: ![[VTABLE_TY0:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "<debug_vtable::Foo as debug_vtable::SomeTrait>::{vtable_type}", {{.*}} size: {{320|160}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}} vtableHolder: ![[FOO_TYPE:[0-9]+]],
+// MSVC: ![[VTABLE_TY0:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "impl$<debug_vtable::Foo, debug_vtable::SomeTrait>::vtable_type$", {{.*}} size: {{320|160}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}} vtableHolder: ![[FOO_TYPE:[0-9]+]],
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "drop_in_place", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}})
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "size", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{64|32}})
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "align", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{128|64}})
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__method3", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}}, offset: {{192|96}})
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__method4", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}}, offset: {{256|128}})
+// CHECK: ![[FOO_TYPE]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Foo",
+
+// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as debug_vtable::SomeTraitWithGenerics<u64, i8>>::{vtable}"
+// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, debug_vtable::SomeTraitWithGenerics<u64,i8> >::vtable$"
+
+// NONMSVC: ![[VTABLE_TY1:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "<debug_vtable::Foo as debug_vtable::SomeTraitWithGenerics<u64, i8>>::{vtable_type}", {{.*}}, size: {{256|128}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
+// MSVC: ![[VTABLE_TY1:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "impl$<debug_vtable::Foo, debug_vtable::SomeTraitWithGenerics<u64,i8> >::vtable_type$", {{.*}}, size: {{256|128}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "drop_in_place", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}})
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "size", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{64|32}})
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "align", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{128|64}})
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__method3", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}}, offset: {{192|96}})
+
+// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as _>::{vtable}"
+// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, _>::vtable$"
+
+// NONMSVC: ![[VTABLE_TY2:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "<debug_vtable::Foo as _>::{vtable_type}", {{.*}}, size: {{192|96}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
+// MSVC: ![[VTABLE_TY2:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "impl$<debug_vtable::Foo, _>::vtable_type$", {{.*}}, size: {{192|96}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "drop_in_place", scope: ![[VTABLE_TY2]], {{.*}}, baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}})
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "size", scope: ![[VTABLE_TY2]], {{.*}}, baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{64|32}})
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "align", scope: ![[VTABLE_TY2]], {{.*}}, baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{128|64}})
+
+// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::bar::{closure_env#0} as core::ops::function::FnOnce<(core::option::Option<&dyn core::ops::function::Fn<(), Output=()>>)>>::{vtable}"
+// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::bar::closure_env$0, core::ops::function::FnOnce<tuple$<enum2$<core::option::Option<ref$<dyn$<core::ops::function::Fn<tuple$<>,assoc$<Output,tuple$<> > > > > > > > > >::vtable$"
+
+// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::generic_closure::{closure_env#0}<bool> as core::ops::function::FnOnce<()>>::{vtable}"
+// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::generic_closure::closure_env$0<bool>, core::ops::function::FnOnce<tuple$<> > >::vtable$
+
+// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::generic_closure::{closure_env#0}<u32> as core::ops::function::FnOnce<()>>::{vtable}"
+// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::generic_closure::closure_env$0<u32>, core::ops::function::FnOnce<tuple$<> > >::vtable$
+
+#![crate_type = "lib"]
+
+// Force emission for debuginfo for usize and *const() early..
+pub static mut XYZ: Option<(usize, *const ())> = None;
+
+pub struct Foo;
+
+pub trait SomeTrait {
+    fn method1(&self) -> u32;
+    fn method2(&self) -> u32;
+}
+
+impl SomeTrait for Foo {
+    fn method1(&self) -> u32 {
+        1
+    }
+    fn method2(&self) -> u32 {
+        2
+    }
+}
+
+pub trait SomeTraitWithGenerics<T, U> {
+    fn method1(&self) -> (T, U);
+}
+
+impl SomeTraitWithGenerics<u64, i8> for Foo {
+    fn method1(&self) -> (u64, i8) {
+        (1, 2)
+    }
+}
+
+pub fn foo(x: &Foo) -> (u32, (u64, i8), &dyn Send) {
+    let y: &dyn SomeTrait = x;
+    let z: &dyn SomeTraitWithGenerics<u64, i8> = x;
+    (y.method1(), z.method1(), x as &dyn Send)
+}
+
+// Constructing the debuginfo name for the FnOnce vtable below initially caused an ICE on MSVC
+// because the trait type contains a late bound region that needed to be erased before the type
+// layout for the niche enum `Option<&dyn Fn()>` could be computed.
+pub fn bar() -> Box<dyn FnOnce(Option<&dyn Fn()>)> {
+    Box::new(|_x: Option<&dyn Fn()>| {})
+}
+
+fn generic_closure<T: 'static>(x: T) -> Box<dyn FnOnce() -> T> {
+    Box::new(move || x)
+}
+
+pub fn instantiate_generic_closures() -> (Box<dyn FnOnce() -> u32>, Box<dyn FnOnce() -> bool>) {
+    (generic_closure(1u32), generic_closure(false))
+}
diff --git a/tests/codegen-llvm/debuginfo-constant-locals.rs b/tests/codegen-llvm/debuginfo-constant-locals.rs
new file mode 100644
index 00000000000..580c69c05a5
--- /dev/null
+++ b/tests/codegen-llvm/debuginfo-constant-locals.rs
@@ -0,0 +1,28 @@
+//@ compile-flags: -g -Copt-level=3
+
+// Check that simple constant values are preserved in debuginfo across both MIR opts and LLVM opts
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn check_it() {
+    let a = 1;
+    let b = 42;
+
+    foo(a + b);
+}
+
+#[inline(never)]
+fn foo(x: i32) {
+    std::process::exit(x);
+}
+
+// CHECK-LABEL: @check_it
+// CHECK: dbg{{.}}value({{(metadata )?}}i32 1, {{(metadata )?}}![[a_metadata:[0-9]+]], {{(metadata )?}}!DIExpression()
+// CHECK: dbg{{.}}value({{(metadata )?}}i32 42, {{(metadata )?}}![[b_metadata:[0-9]+]], {{(metadata )?}}!DIExpression()
+
+// CHECK: ![[a_metadata]] = !DILocalVariable(name: "a"
+// CHECK-SAME: line: 9
+
+// CHECK: ![[b_metadata]] = !DILocalVariable(name: "b"
+// CHECK-SAME: line: 10
diff --git a/tests/codegen-llvm/debuginfo-generic-closure-env-names.rs b/tests/codegen-llvm/debuginfo-generic-closure-env-names.rs
new file mode 100644
index 00000000000..64bc58e1df7
--- /dev/null
+++ b/tests/codegen-llvm/debuginfo-generic-closure-env-names.rs
@@ -0,0 +1,90 @@
+// ignore-tidy-linelength
+//! This test checks that we get proper type names for closure environments and
+//! async-fn environments in debuginfo, especially making sure that generic arguments
+//! of the enclosing functions don't get lost.
+//!
+//! Unfortunately, the order that debuginfo gets emitted into LLVM IR becomes a bit hard
+//! to predict once async fns are involved, so DAG allows any order.
+//!
+//! Note that the test does not check async-fns when targeting MSVC because debuginfo for
+//! those does not follow the enum-fallback encoding yet and thus is incomplete.
+
+//@ revisions: MSVC NONMSVC
+//@[MSVC] only-msvc
+//@[NONMSVC] ignore-msvc
+
+// Use the v0 symbol mangling scheme to codegen order independent of rustc version.
+// Unnamed items like shims are generated in lexicographical order of their symbol name and in the
+// legacy mangling scheme rustc version and generic parameters are both hashed into a single part
+// of the name, thus randomizing item order with respect to rustc version.
+
+//@ compile-flags: -Cdebuginfo=2 -Copt-level=0 -Csymbol-mangling-version=v0
+//@ edition: 2021
+
+// non_generic_closure()
+// NONMSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}", scope: ![[non_generic_closure_NAMESPACE:[0-9]+]],
+// MSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "closure_env$0", scope: ![[non_generic_closure_NAMESPACE:[0-9]+]],
+// CHECK: ![[non_generic_closure_NAMESPACE]] = !DINamespace(name: "non_generic_closure"
+
+// CHECK: ![[function_containing_closure_NAMESPACE:[0-9]+]] = !DINamespace(name: "function_containing_closure"
+// CHECK: ![[generic_async_function_NAMESPACE:[0-9]+]] = !DINamespace(name: "generic_async_function"
+// CHECK: ![[generic_async_block_NAMESPACE:[0-9]+]] = !DINamespace(name: "generic_async_block"
+
+// function_containing_closure<u32>()
+// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}<u32>", scope: ![[function_containing_closure_NAMESPACE]]
+// MSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "closure_env$0<u32>", scope: ![[function_containing_closure_NAMESPACE]]
+
+// generic_async_function<Foo>()
+// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}<debuginfo_generic_closure_env_names::Foo>", scope: ![[generic_async_function_NAMESPACE]]
+
+// generic_async_function<u32>()
+// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}<u32>", scope: ![[generic_async_function_NAMESPACE]]
+
+// generic_async_block<Foo>()
+// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_block_env#0}<debuginfo_generic_closure_env_names::Foo>", scope: ![[generic_async_block_NAMESPACE]]
+
+// generic_async_block<u32>()
+// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_block_env#0}<u32>", scope: ![[generic_async_block_NAMESPACE]]
+
+// function_containing_closure<Foo>()
+// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}<debuginfo_generic_closure_env_names::Foo>", scope: ![[function_containing_closure_NAMESPACE]]
+// MSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "closure_env$0<debuginfo_generic_closure_env_names::Foo>", scope: ![[function_containing_closure_NAMESPACE]]
+
+#![crate_type = "lib"]
+use std::future::Future;
+
+pub struct Foo;
+
+pub fn non_generic_closure(x: Foo) -> Box<dyn FnOnce() -> Foo> {
+    return Box::new(move || x);
+}
+
+fn function_containing_closure<T: 'static>(x: T) -> impl FnOnce() -> T {
+    // This static only exists to trigger generating the namespace debuginfo for
+    // `function_containing_closure` at a predictable, early point, which makes
+    // writing the FileCheck tests above simpler.
+    static _X: u8 = 0;
+
+    return move || x;
+}
+
+async fn generic_async_function<T: 'static>(x: T) -> T {
+    static _X: u8 = 0; // Same as above
+    x
+}
+
+fn generic_async_block<T: 'static>(x: T) -> impl Future<Output = T> {
+    static _X: u8 = 0; // Same as above
+    async move { x }
+}
+
+pub fn instantiate_generics() {
+    let _closure_u32 = function_containing_closure(7u32);
+    let _closure_foo = function_containing_closure(Foo);
+
+    let _async_fn_u32 = generic_async_function(42u32);
+    let _async_fn_foo = generic_async_function(Foo);
+
+    let _async_block_u32 = generic_async_block(64u32);
+    let _async_block_foo = generic_async_block(Foo);
+}
diff --git a/tests/codegen-llvm/debuginfo-inline-callsite-location.rs b/tests/codegen-llvm/debuginfo-inline-callsite-location.rs
new file mode 100644
index 00000000000..59ade52ad32
--- /dev/null
+++ b/tests/codegen-llvm/debuginfo-inline-callsite-location.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -g -Copt-level=3 -C panic=abort
+
+// Check that each inline call site for the same function uses the same "sub-program" so that LLVM
+// can correctly merge the debug info if it merges the inlined code (e.g., for merging of tail
+// calls to panic.
+
+// CHECK:       tail call void @{{[A-Za-z0-9_]+4core6option13unwrap_failed}}
+// CHECK-SAME:  !dbg ![[#first_dbg:]]
+// CHECK:       tail call void @{{[A-Za-z0-9_]+4core6option13unwrap_failed}}
+// CHECK-SAME:  !dbg ![[#second_dbg:]]
+
+// CHECK-DAG:   ![[#func_scope:]] = distinct !DISubprogram(name: "unwrap<i32>"
+// CHECK-DAG:   ![[#]] = !DILocalVariable(name: "self",{{( arg: 1,)?}} scope: ![[#func_scope]]
+// CHECK:       ![[#first_dbg]] = !DILocation(line: [[#]]
+// CHECK-SAME:  scope: ![[#func_scope]], inlinedAt: ![[#]])
+// CHECK:       ![[#second_dbg]] = !DILocation(line: [[#]]
+// CHECK-SAME:  scope: ![[#func_scope]], inlinedAt: ![[#]])
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+extern "C" fn add_numbers(x: &Option<i32>, y: &Option<i32>) -> i32 {
+    let x1 = x.unwrap();
+    let y1 = y.unwrap();
+
+    x1 + y1
+}
diff --git a/tests/codegen-llvm/debuginfo-proc-macro/auxiliary/macro_def.rs b/tests/codegen-llvm/debuginfo-proc-macro/auxiliary/macro_def.rs
new file mode 100644
index 00000000000..c0691b23275
--- /dev/null
+++ b/tests/codegen-llvm/debuginfo-proc-macro/auxiliary/macro_def.rs
@@ -0,0 +1,7 @@
+extern crate proc_macro;
+use proc_macro::*;
+
+#[proc_macro]
+pub fn square_twice(_item: TokenStream) -> TokenStream {
+    "(square(env::vars().count() as i32), square(env::vars().count() as i32))".parse().unwrap()
+}
diff --git a/tests/codegen-llvm/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs b/tests/codegen-llvm/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs
new file mode 100644
index 00000000000..7530689d574
--- /dev/null
+++ b/tests/codegen-llvm/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs
@@ -0,0 +1,52 @@
+//@ compile-flags: -Cdebuginfo=2 -Copt-level=0 -Zmir-enable-passes=+Inline
+// MSVC is different because of the individual allocas.
+//@ ignore-msvc
+
+//@ proc-macro: macro_def.rs
+
+// Find the variable.
+// CHECK-DAG: ![[#var_dbg:]] = !DILocalVariable(name: "n",{{( arg: 1,)?}} scope: ![[#var_scope:]]
+
+// Find both dbg_declares. These will proceed the variable metadata, of course, so we're looking
+// backwards.
+// CHECK-DAG: dbg_declare(ptr %n.dbg.spill{{[0-9]}}, ![[#var_dbg]], !DIExpression(), ![[#var_loc2:]])
+// CHECK-DAG: dbg_declare(ptr %n.dbg.spill, ![[#var_dbg]], !DIExpression(), ![[#var_loc1:]])
+
+// Find the first location definition, looking forwards again.
+// CHECK: ![[#var_loc1]] = !DILocation
+// CHECK-SAME: scope: ![[#var_scope:]], inlinedAt: ![[#var_inlinedAt1:]]
+
+// Find the first location's inlinedAt
+// NB: If we fail here it's *probably* because we failed to produce two
+// different locations and ended up reusing an earlier one.
+// CHECK: ![[#var_inlinedAt1]] = !DILocation
+// CHECK-SAME: scope: ![[var_inlinedAt1_scope:]]
+
+// Find the second location definition, still looking forwards.
+// NB: If we failed to produce two different locations, the test will
+// definitely fail by this point (if it hasn't already) because we won't
+// be able to find the same line again.
+// CHECK: ![[#var_loc2]] = !DILocation
+// CHECK-SAME: scope: ![[#var_scope]], inlinedAt: ![[#var_inlinedAt2:]]
+
+// Find the second location's inlinedAt.
+// CHECK: ![[#var_inlinedAt2]] = !DILocation
+// CHECK-SAME: scope: ![[#var_inlinedAt2_scope:]]
+
+// Finally, check that a discriminator was emitted for the second scope.
+// FIXMEkhuey ideally we would check that *either* scope has a discriminator
+// but I don't know that it's possible to check that with FileCheck.
+// CHECK: ![[#var_inlinedAt2_scope]] = !DILexicalBlockFile
+// CHECK-SAME: discriminator: [[#]]
+extern crate macro_def;
+
+use std::env;
+
+fn square(n: i32) -> i32 {
+    n * n
+}
+
+fn main() {
+    let (z1, z2) = macro_def::square_twice!();
+    println!("{z1} == {z2}");
+}
diff --git a/tests/codegen-llvm/deduced-param-attrs.rs b/tests/codegen-llvm/deduced-param-attrs.rs
new file mode 100644
index 00000000000..34504c80fad
--- /dev/null
+++ b/tests/codegen-llvm/deduced-param-attrs.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+#![allow(internal_features)]
+#![feature(unsized_fn_params)]
+
+use std::cell::Cell;
+use std::hint;
+
+// Check to make sure that we can deduce the `readonly` attribute from function bodies for
+// parameters passed indirectly.
+
+pub struct BigStruct {
+    blah: [i32; 1024],
+}
+
+pub struct BigCellContainer {
+    blah: [Cell<i32>; 1024],
+}
+
+// The by-value parameter for this big struct can be marked readonly.
+//
+// CHECK: @use_big_struct_immutably({{.*}} readonly {{.*}} %big_struct)
+#[no_mangle]
+pub fn use_big_struct_immutably(big_struct: BigStruct) {
+    hint::black_box(&big_struct);
+}
+
+// The by-value parameter for this big struct can't be marked readonly, because we mutate it.
+//
+// CHECK-NOT: @use_big_struct_mutably({{.*}} readonly {{.*}} %big_struct)
+#[no_mangle]
+pub fn use_big_struct_mutably(mut big_struct: BigStruct) {
+    big_struct.blah[987] = 654;
+    hint::black_box(&big_struct);
+}
+
+// The by-value parameter for this big struct can't be marked readonly, because it contains
+// UnsafeCell.
+//
+// CHECK-NOT: @use_big_cell_container({{.*}} readonly {{.*}} %big_cell_container)
+#[no_mangle]
+pub fn use_big_cell_container(big_cell_container: BigCellContainer) {
+    hint::black_box(&big_cell_container);
+}
+
+// Make sure that we don't mistakenly mark a big struct as `readonly` when passed through a generic
+// type parameter if it contains UnsafeCell.
+//
+// CHECK-NOT: @use_something({{.*}} readonly {{.*}} %something)
+#[no_mangle]
+#[inline(never)]
+pub fn use_something<T>(something: T) {
+    hint::black_box(&something);
+}
+
+#[no_mangle]
+pub fn forward_big_cell_container(big_cell_container: BigCellContainer) {
+    use_something(big_cell_container)
+}
diff --git a/tests/codegen-llvm/default-requires-uwtable.rs b/tests/codegen-llvm/default-requires-uwtable.rs
new file mode 100644
index 00000000000..54a6e171db6
--- /dev/null
+++ b/tests/codegen-llvm/default-requires-uwtable.rs
@@ -0,0 +1,17 @@
+//@ add-core-stubs
+//@ revisions: WINDOWS_ ANDROID_
+//@ compile-flags: -C panic=abort -Copt-level=0
+//@ [WINDOWS_] compile-flags: --target=x86_64-pc-windows-msvc
+//@ [WINDOWS_] needs-llvm-components: x86
+//@ [ANDROID_] compile-flags: --target=armv7-linux-androideabi
+//@ [ANDROID_] needs-llvm-components: arm
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: attributes #{{.*}} uwtable
+pub fn foo() {}
diff --git a/tests/codegen-llvm/default-visibility.rs b/tests/codegen-llvm/default-visibility.rs
new file mode 100644
index 00000000000..88ff9fee254
--- /dev/null
+++ b/tests/codegen-llvm/default-visibility.rs
@@ -0,0 +1,49 @@
+// Verifies that `Session::default_visibility` is affected when using the related cmdline
+// flag.  This is a regression test for https://github.com/rust-lang/compiler-team/issues/782.  See
+// also https://github.com/rust-lang/rust/issues/73295 and
+// https://github.com/rust-lang/rust/issues/37530.
+
+//@ revisions:DEFAULT HIDDEN PROTECTED INTERPOSABLE
+//@[HIDDEN] compile-flags: -Zdefault-visibility=hidden
+//@[PROTECTED] compile-flags: -Zdefault-visibility=protected
+//@[INTERPOSABLE] compile-flags: -Zdefault-visibility=interposable
+
+// The test scenario is specifically about visibility of symbols exported out of dynamically linked
+// libraries.
+#![crate_type = "dylib"]
+
+// The test scenario needs to use a Rust-public, but non-explicitly-exported symbol
+// (e.g. the test doesn't use `#[no_mangle]`, because currently it implies that
+// the symbol should be exported;  we don't want that - we want to test the *default*
+// export setting instead).
+#[used]
+pub static tested_symbol: [u8; 6] = *b"foobar";
+
+// Exact LLVM IR differs depending on the target triple (e.g. `hidden constant`
+// vs `internal constant` vs `constant`).  Because of this, we only apply the
+// specific test expectations below to one specific target triple.  If needed,
+// additional targets can be covered by adding copies of this test file with
+// a different `only-X` directive.
+//
+//@     only-x86_64-unknown-linux-gnu
+
+// HIDDEN:       @{{.*}}default_visibility{{.*}}tested_symbol{{.*}} = hidden constant
+// PROTECTED:    @{{.*}}default_visibility{{.*}}tested_symbol{{.*}} = protected constant
+// INTERPOSABLE: @{{.*}}default_visibility{{.*}}tested_symbol{{.*}} = constant
+// DEFAULT:      @{{.*}}default_visibility{{.*}}tested_symbol{{.*}} = constant
+
+pub fn do_memcmp(left: &[u8], right: &[u8]) -> i32 {
+    left.cmp(right) as i32
+}
+
+// CHECK: define {{.*}} @{{.*}}do_memcmp{{.*}} {
+// CHECK: }
+
+// `do_memcmp` should invoke core::intrinsic::compare_bytes which emits a call
+// to the C symbol `memcmp` (at least on x86_64-unknown-linux-gnu). This symbol
+// should *not* be declared hidden or protected.
+
+// HIDDEN:       declare i32 @memcmp
+// PROTECTED:    declare i32 @memcmp
+// INTERPOSABLE: declare i32 @memcmp
+// DEFAULT:      declare i32 @memcmp
diff --git a/tests/codegen-llvm/direct-access-external-data.rs b/tests/codegen-llvm/direct-access-external-data.rs
new file mode 100644
index 00000000000..5b2ff41ef05
--- /dev/null
+++ b/tests/codegen-llvm/direct-access-external-data.rs
@@ -0,0 +1,21 @@
+//@ only-loongarch64-unknown-linux-gnu
+
+//@ revisions: DEFAULT DIRECT INDIRECT
+//@ [DEFAULT] compile-flags: -C relocation-model=static
+//@ [DIRECT] compile-flags: -C relocation-model=static -Z direct-access-external-data=yes
+//@ [INDIRECT] compile-flags: -C relocation-model=static -Z direct-access-external-data=no
+
+#![crate_type = "rlib"]
+
+// DEFAULT: @VAR = external {{.*}} global i32
+// DIRECT: @VAR = external dso_local {{.*}} global i32
+// INDIRECT: @VAR = external {{.*}} global i32
+
+extern "C" {
+    static VAR: i32;
+}
+
+#[no_mangle]
+pub fn get() -> i32 {
+    unsafe { VAR }
+}
diff --git a/tests/codegen-llvm/dllimports/auxiliary/dummy.rs b/tests/codegen-llvm/dllimports/auxiliary/dummy.rs
new file mode 100644
index 00000000000..ab3dbc6a300
--- /dev/null
+++ b/tests/codegen-llvm/dllimports/auxiliary/dummy.rs
@@ -0,0 +1,6 @@
+//@ no-prefer-dynamic
+#![crate_type = "staticlib"]
+
+// Since codegen tests don't actually perform linking, this library doesn't need to export
+// any symbols.  It's here just to satisfy the compiler looking for a .lib file when processing
+// #[link(...)] attributes in wrapper.rs.
diff --git a/tests/codegen-llvm/dllimports/auxiliary/wrapper.rs b/tests/codegen-llvm/dllimports/auxiliary/wrapper.rs
new file mode 100644
index 00000000000..00a29f7ee7e
--- /dev/null
+++ b/tests/codegen-llvm/dllimports/auxiliary/wrapper.rs
@@ -0,0 +1,14 @@
+//@ no-prefer-dynamic
+#![crate_type = "rlib"]
+
+#[link(name = "dummy", kind = "dylib")]
+extern "C" {
+    pub fn dylib_func2(x: i32) -> i32;
+    pub static dylib_global2: i32;
+}
+
+#[link(name = "dummy", kind = "static")]
+extern "C" {
+    pub fn static_func2(x: i32) -> i32;
+    pub static static_global2: i32;
+}
diff --git a/tests/codegen-llvm/dllimports/main.rs b/tests/codegen-llvm/dllimports/main.rs
new file mode 100644
index 00000000000..93d350a2238
--- /dev/null
+++ b/tests/codegen-llvm/dllimports/main.rs
@@ -0,0 +1,43 @@
+// This test is for *-windows-msvc only.
+//@ only-windows
+//@ ignore-gnu
+
+//@ aux-build:dummy.rs
+//@ aux-build:wrapper.rs
+
+extern crate wrapper;
+
+// Check that external symbols coming from foreign dylibs are adorned with 'dllimport',
+// whereas symbols coming from foreign staticlibs are not. (RFC-1717)
+
+// CHECK: @dylib_global1 = external dllimport local_unnamed_addr global i32
+// CHECK: @dylib_global2 = external dllimport local_unnamed_addr global i32
+// CHECK: @static_global1 = external local_unnamed_addr global i32
+// CHECK: @static_global2 = external local_unnamed_addr global i32
+
+// CHECK: declare dllimport noundef i32 @dylib_func1(i32 noundef)
+// CHECK: declare dllimport noundef i32 @dylib_func2(i32 noundef)
+// CHECK: declare noundef i32 @static_func1(i32 noundef)
+// CHECK: declare noundef i32 @static_func2(i32 noundef)
+
+#[link(name = "dummy", kind = "dylib")]
+extern "C" {
+    pub fn dylib_func1(x: i32) -> i32;
+    pub static dylib_global1: i32;
+}
+
+#[link(name = "dummy", kind = "static")]
+extern "C" {
+    pub fn static_func1(x: i32) -> i32;
+    pub static static_global1: i32;
+}
+
+fn main() {
+    unsafe {
+        dylib_func1(dylib_global1);
+        wrapper::dylib_func2(wrapper::dylib_global2);
+
+        static_func1(static_global1);
+        wrapper::static_func2(wrapper::static_global2);
+    }
+}
diff --git a/tests/codegen-llvm/dont_codegen_private_const_fn_only_used_in_const_eval.rs b/tests/codegen-llvm/dont_codegen_private_const_fn_only_used_in_const_eval.rs
new file mode 100644
index 00000000000..df50b4af809
--- /dev/null
+++ b/tests/codegen-llvm/dont_codegen_private_const_fn_only_used_in_const_eval.rs
@@ -0,0 +1,27 @@
+//! This test checks that we do not monomorphize functions that are only
+//! used to evaluate static items, but never used in runtime code.
+
+//@compile-flags: --crate-type=lib -Copt-level=0
+
+#![feature(generic_const_items)]
+
+const fn foo() {}
+
+pub static FOO: () = foo();
+
+// CHECK-NOT: define{{.*}}foo{{.*}}
+
+const fn bar() {}
+
+pub const BAR: () = bar();
+
+// CHECK-NOT: define{{.*}}bar{{.*}}
+
+const fn baz() {}
+
+#[rustfmt::skip]
+pub const BAZ<const C: bool>: () = if C {
+    baz()
+};
+
+// CHECK: define{{.*}}baz{{.*}}
diff --git a/tests/codegen-llvm/drop-in-place-noalias.rs b/tests/codegen-llvm/drop-in-place-noalias.rs
new file mode 100644
index 00000000000..bff2f52781f
--- /dev/null
+++ b/tests/codegen-llvm/drop-in-place-noalias.rs
@@ -0,0 +1,38 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+// Tests that the compiler can apply `noalias` and other &mut attributes to `drop_in_place`.
+// Note that non-Unpin types should not get `noalias`, matching &mut behavior.
+
+#![crate_type = "lib"]
+
+use std::marker::PhantomPinned;
+
+// CHECK: define internal void @{{.*}}core{{.*}}ptr{{.*}}drop_in_place{{.*}}StructUnpin{{.*}}(ptr noalias noundef align 4 dereferenceable(12) %{{.+}})
+
+// CHECK: define internal void @{{.*}}core{{.*}}ptr{{.*}}drop_in_place{{.*}}StructNotUnpin{{.*}}(ptr noundef nonnull align 4 %{{.+}})
+
+pub struct StructUnpin {
+    a: i32,
+    b: i32,
+    c: i32,
+}
+
+impl Drop for StructUnpin {
+    fn drop(&mut self) {}
+}
+
+pub struct StructNotUnpin {
+    a: i32,
+    b: i32,
+    c: i32,
+    p: PhantomPinned,
+}
+
+impl Drop for StructNotUnpin {
+    fn drop(&mut self) {}
+}
+
+pub unsafe fn main(x: StructUnpin, y: StructNotUnpin) {
+    drop(x);
+    drop(y);
+}
diff --git a/tests/codegen-llvm/drop.rs b/tests/codegen-llvm/drop.rs
new file mode 100644
index 00000000000..b22a8ef27d2
--- /dev/null
+++ b/tests/codegen-llvm/drop.rs
@@ -0,0 +1,36 @@
+//@ needs-unwind - this test verifies the amount of drop calls when unwinding is used
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+struct SomeUniqueName;
+
+impl Drop for SomeUniqueName {
+    #[inline(never)]
+    fn drop(&mut self) {}
+}
+
+#[inline(never)]
+pub fn possibly_unwinding() {}
+
+// CHECK-LABEL: @droppy
+#[no_mangle]
+pub fn droppy() {
+    // Check that there are exactly 6 drop calls. The cleanups for the unwinding should be reused,
+    // so that's one new drop call per call to possibly_unwinding(), and finally 3 drop calls for
+    // the regular function exit. We used to have problems with quadratic growths of drop calls in
+    // such functions.
+    // FIXME(eddyb) the `void @` forces a match on the instruction, instead of the
+    // comment, that's `; call core::ptr::drop_in_place::<drop::SomeUniqueName>`
+    // for the `v0` mangling, should switch to matching on that once `legacy` is gone.
+    // CHECK-COUNT-6: {{(call|invoke) void @.*}}drop_in_place{{.*}}SomeUniqueName
+    // CHECK-NOT: {{(call|invoke) void @.*}}drop_in_place{{.*}}SomeUniqueName
+    // The next line checks for the } that ends the function definition
+    // CHECK-LABEL: {{^[}]}}
+    let _s = SomeUniqueName;
+    possibly_unwinding();
+    let _s = SomeUniqueName;
+    possibly_unwinding();
+    let _s = SomeUniqueName;
+    possibly_unwinding();
+}
diff --git a/tests/codegen-llvm/dst-offset.rs b/tests/codegen-llvm/dst-offset.rs
new file mode 100644
index 00000000000..2cf5fa9fac6
--- /dev/null
+++ b/tests/codegen-llvm/dst-offset.rs
@@ -0,0 +1,84 @@
+//! This file tests that we correctly generate GEP instructions for DST
+//! field offsets.
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(extern_types, sized_hierarchy)]
+
+use std::marker::PointeeSized;
+use std::ptr::addr_of;
+
+// Hack to get the correct type for usize
+// CHECK: @helper([[USIZE:i[0-9]+]] %_1)
+#[no_mangle]
+pub fn helper(_: usize) {}
+
+struct Dst<T: PointeeSized> {
+    x: u32,
+    y: u8,
+    z: T,
+}
+
+// CHECK: @dst_dyn_trait_offset(ptr align {{[0-9]+}} [[DATA_PTR:%.+]], ptr align {{[0-9]+}} [[VTABLE_PTR:%.+]])
+#[no_mangle]
+pub fn dst_dyn_trait_offset(s: &Dst<dyn Drop>) -> &dyn Drop {
+    // The alignment of dyn trait is unknown, so we compute the offset based on align from the
+    // vtable.
+
+    // CHECK: [[SIZE_PTR:%[0-9]+]] = getelementptr inbounds i8, ptr [[VTABLE_PTR]]
+    // CHECK: load [[USIZE]], ptr [[SIZE_PTR]]
+    // CHECK: [[ALIGN_PTR:%[0-9]+]] = getelementptr inbounds i8, ptr [[VTABLE_PTR]]
+    // CHECK: load [[USIZE]], ptr [[ALIGN_PTR]]
+
+    // CHECK: getelementptr inbounds i8, ptr [[DATA_PTR]]
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: ret
+    &s.z
+}
+
+// CHECK-LABEL: @dst_slice_offset
+#[no_mangle]
+pub fn dst_slice_offset(s: &Dst<[u16]>) -> &[u16] {
+    // The alignment of [u16] is known, so we generate a GEP directly.
+
+    // CHECK: start:
+    // CHECK-NEXT: getelementptr inbounds i8, {{.+}}, [[USIZE]] 6
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: ret
+    &s.z
+}
+
+#[repr(packed)]
+struct PackedDstSlice {
+    x: u32,
+    y: u8,
+    z: [u16],
+}
+
+// CHECK-LABEL: @packed_dst_slice_offset
+#[no_mangle]
+pub fn packed_dst_slice_offset(s: &PackedDstSlice) -> *const [u16] {
+    // The alignment of [u16] is known, so we generate a GEP directly.
+
+    // CHECK: start:
+    // CHECK-NEXT: getelementptr inbounds i8, {{.+}}, [[USIZE]] 5
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: ret
+    addr_of!(s.z)
+}
+
+extern "C" {
+    pub type Extern;
+}
+
+// CHECK-LABEL: @dst_extern
+#[no_mangle]
+pub fn dst_extern(s: &Dst<Extern>) -> &Extern {
+    // Computing the alignment of an extern type is currently unsupported and just panics.
+
+    // CHECK: call void @{{.+}}panic
+    &s.z
+}
diff --git a/tests/codegen-llvm/dst-vtable-align-nonzero.rs b/tests/codegen-llvm/dst-vtable-align-nonzero.rs
new file mode 100644
index 00000000000..1404bd64f50
--- /dev/null
+++ b/tests/codegen-llvm/dst-vtable-align-nonzero.rs
@@ -0,0 +1,67 @@
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+// This test checks that we annotate alignment loads from vtables with nonzero range metadata,
+// and that this allows LLVM to eliminate redundant `align >= 1` checks.
+
+pub trait Trait {
+    fn f(&self);
+}
+
+pub struct WrapperWithAlign1<T: ?Sized> {
+    x: u8,
+    y: T,
+}
+
+pub struct WrapperWithAlign2<T: ?Sized> {
+    x: u16,
+    y: T,
+}
+
+pub struct Struct<W: ?Sized> {
+    _field: i8,
+    dst: W,
+}
+
+// CHECK-LABEL: @eliminates_runtime_check_when_align_1
+#[no_mangle]
+pub fn eliminates_runtime_check_when_align_1(
+    x: &Struct<WrapperWithAlign1<dyn Trait>>,
+) -> &WrapperWithAlign1<dyn Trait> {
+    // CHECK: load [[USIZE:i[0-9]+]], {{.+}} !range [[RANGE_META:![0-9]+]]
+    // CHECK-NOT: llvm.umax
+    // CHECK-NOT: icmp
+    // CHECK-NOT: select
+    // CHECK: ret
+    &x.dst
+}
+
+// CHECK-LABEL: @does_not_eliminate_runtime_check_when_align_2
+#[no_mangle]
+pub fn does_not_eliminate_runtime_check_when_align_2(
+    x: &Struct<WrapperWithAlign2<dyn Trait>>,
+) -> &WrapperWithAlign2<dyn Trait> {
+    // CHECK: [[X0:%[0-9]+]] = load [[USIZE]], {{.+}} !range [[RANGE_META]]
+    // CHECK: {{icmp|llvm.umax}}
+    // CHECK: ret
+    &x.dst
+}
+
+// CHECK-LABEL: @align_load_from_align_of_val
+#[no_mangle]
+pub fn align_load_from_align_of_val(x: &dyn Trait) -> usize {
+    // CHECK: {{%[0-9]+}} = load [[USIZE]], {{.+}} !range [[RANGE_META]]
+    core::mem::align_of_val(x)
+}
+
+// CHECK-LABEL: @align_load_from_vtable_align_intrinsic
+#[no_mangle]
+pub unsafe fn align_load_from_vtable_align_intrinsic(x: &dyn Trait) -> usize {
+    let (data, vtable): (*const (), *const ()) = core::mem::transmute(x);
+    // CHECK: {{%[0-9]+}} = load [[USIZE]], {{.+}} !range [[RANGE_META]]
+    core::intrinsics::vtable_align(vtable)
+}
+
+// CHECK: [[RANGE_META]] = !{[[USIZE]] 1, [[USIZE]] 0}
diff --git a/tests/codegen-llvm/dst-vtable-size-range.rs b/tests/codegen-llvm/dst-vtable-size-range.rs
new file mode 100644
index 00000000000..670f5e8d553
--- /dev/null
+++ b/tests/codegen-llvm/dst-vtable-size-range.rs
@@ -0,0 +1,35 @@
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+// Check that we annotate size loads from vtables with 0..(isize::MAX + 1) range metadata.
+
+pub trait Trait {
+    fn f(&self);
+}
+
+// Note that rustc uses inclusive bounds, but LLVM uses exclusive bounds for range metadata.
+// CHECK-LABEL: @generate_exclusive_bound
+#[no_mangle]
+pub fn generate_exclusive_bound() -> usize {
+    // CHECK: ret [[USIZE:i[0-9]+]] [[EXCLUSIVE_BOUND:[-0-9]+]]
+    isize::MAX as usize + 1
+}
+
+// CHECK-LABEL: @size_load_from_size_of_val
+#[no_mangle]
+pub fn size_load_from_size_of_val(x: &dyn Trait) -> usize {
+    // CHECK: {{%[0-9]+}} = load [[USIZE]], {{.+}} !range [[RANGE_META:![0-9]+]]
+    core::mem::size_of_val(x)
+}
+
+// CHECK-LABEL: @size_load_from_vtable_size_intrinsic
+#[no_mangle]
+pub unsafe fn size_load_from_vtable_size_intrinsic(x: &dyn Trait) -> usize {
+    let (data, vtable): (*const (), *const ()) = core::mem::transmute(x);
+    // CHECK: {{%[0-9]+}} = load [[USIZE]], {{.+}} !range [[RANGE_META]]
+    core::intrinsics::vtable_size(vtable)
+}
+
+// CHECK: [[RANGE_META]] = !{[[USIZE]] 0, [[USIZE]] [[EXCLUSIVE_BOUND]]}
diff --git a/tests/codegen-llvm/ehcontguard_disabled.rs b/tests/codegen-llvm/ehcontguard_disabled.rs
new file mode 100644
index 00000000000..9efb2721b3e
--- /dev/null
+++ b/tests/codegen-llvm/ehcontguard_disabled.rs
@@ -0,0 +1,9 @@
+//@ compile-flags:
+
+#![crate_type = "lib"]
+
+// A basic test function.
+pub fn test() {}
+
+// Ensure the module flag ehcontguard is not present
+// CHECK-NOT: !"ehcontguard"
diff --git a/tests/codegen-llvm/ehcontguard_enabled.rs b/tests/codegen-llvm/ehcontguard_enabled.rs
new file mode 100644
index 00000000000..ecc5512fd5d
--- /dev/null
+++ b/tests/codegen-llvm/ehcontguard_enabled.rs
@@ -0,0 +1,9 @@
+//@ compile-flags: -Z ehcont-guard
+
+#![crate_type = "lib"]
+
+// A basic test function.
+pub fn test() {}
+
+// Ensure the module flag ehcontguard=1 is present
+// CHECK: !"ehcontguard", i32 1
diff --git a/tests/codegen-llvm/emscripten-catch-unwind-js-eh.rs b/tests/codegen-llvm/emscripten-catch-unwind-js-eh.rs
new file mode 100644
index 00000000000..f43869cf218
--- /dev/null
+++ b/tests/codegen-llvm/emscripten-catch-unwind-js-eh.rs
@@ -0,0 +1,71 @@
+//@ compile-flags: -Copt-level=3 --target wasm32-unknown-emscripten
+//@ needs-llvm-components: webassembly
+
+// Emscripten has its own unique implementation of catch_unwind (in `codegen_emcc_try`),
+// make sure it generates something reasonable.
+
+#![feature(no_core, lang_items, intrinsics, rustc_attrs)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+#[lang = "freeze"]
+trait Freeze {}
+#[lang = "copy"]
+trait Copy {}
+
+impl<T> Copy for *mut T {}
+
+#[rustc_intrinsic]
+fn size_of<T>() -> usize {
+    loop {}
+}
+
+#[rustc_intrinsic]
+unsafe fn catch_unwind(
+    try_fn: fn(_: *mut u8),
+    data: *mut u8,
+    catch_fn: fn(_: *mut u8, _: *mut u8),
+) -> i32;
+
+// CHECK-LABEL: @ptr_size
+#[no_mangle]
+pub fn ptr_size() -> usize {
+    // CHECK: ret [[PTR_SIZE:.*]]
+    size_of::<*mut u8>()
+}
+
+// CHECK-LABEL: @test_catch_unwind
+#[no_mangle]
+pub unsafe fn test_catch_unwind(
+    try_fn: fn(_: *mut u8),
+    data: *mut u8,
+    catch_fn: fn(_: *mut u8, _: *mut u8),
+) -> i32 {
+    // CHECK: start:
+    // CHECK: [[ALLOCA:%.*]] = alloca
+
+    // CHECK: catch.i:
+    // CHECK: [[LANDINGPAD:%.*]] = landingpad
+    // CHECK: [[EXCEPTION:%.*]] = extractvalue {{.*}} [[LANDINGPAD]], 0
+    // CHECK: [[SELECTOR:%.*]] = extractvalue {{.*}} [[LANDINGPAD]], 1
+
+    // CHECK: [[IS_RUST_EXN:%.*]] = icmp eq {{.*}}[[SELECTOR]]
+    // CHECK: [[IS_RUST_EXN_I8:%.*]] = zext i1 [[IS_RUST_EXN]] to i8
+
+    // CHECK: store ptr [[EXCEPTION]], ptr [[ALLOCA]]
+    // CHECK: [[IS_RUST_SLOT:%.*]] = getelementptr inbounds{{( nuw)?}} i8, ptr [[ALLOCA]], [[PTR_SIZE]]
+    // CHECK: store i8 [[IS_RUST_EXN_I8]], ptr [[IS_RUST_SLOT]]
+
+    // CHECK: call void %catch_fn(ptr %data, ptr nonnull [[ALLOCA]])
+
+    catch_unwind(try_fn, data, catch_fn)
+}
diff --git a/tests/codegen-llvm/emscripten-catch-unwind-wasm-eh.rs b/tests/codegen-llvm/emscripten-catch-unwind-wasm-eh.rs
new file mode 100644
index 00000000000..b0750d52268
--- /dev/null
+++ b/tests/codegen-llvm/emscripten-catch-unwind-wasm-eh.rs
@@ -0,0 +1,69 @@
+//@ compile-flags: -Copt-level=3 --target wasm32-unknown-emscripten -Z emscripten-wasm-eh
+//@ needs-llvm-components: webassembly
+
+// Emscripten catch_unwind using wasm exceptions
+
+#![feature(no_core, lang_items, intrinsics, rustc_attrs)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+#[lang = "freeze"]
+trait Freeze {}
+#[lang = "copy"]
+trait Copy {}
+
+impl<T> Copy for *mut T {}
+
+#[rustc_intrinsic]
+fn size_of<T>() -> usize {
+    loop {}
+}
+#[rustc_intrinsic]
+unsafe fn catch_unwind(
+    try_fn: fn(_: *mut u8),
+    data: *mut u8,
+    catch_fn: fn(_: *mut u8, _: *mut u8),
+) -> i32;
+
+// CHECK-LABEL: @ptr_size
+#[no_mangle]
+pub fn ptr_size() -> usize {
+    // CHECK: ret [[PTR_SIZE:.*]]
+    size_of::<*mut u8>()
+}
+
+// CHECK-LABEL: @test_catch_unwind
+#[no_mangle]
+pub unsafe fn test_catch_unwind(
+    try_fn: fn(_: *mut u8),
+    data: *mut u8,
+    catch_fn: fn(_: *mut u8, _: *mut u8),
+) -> i32 {
+    // CHECK: start:
+    // CHECK: invoke void %try_fn(ptr %data)
+    // CHECK:         to label %__rust_try.exit unwind label %catchswitch.i
+    // CHECK:   catchswitch.i:                                    ; preds = %start
+    // CHECK:   %catchswitch1.i = catchswitch within none [label %catchpad.i] unwind to caller
+
+    // CHECK: catchpad.i:                                       ; preds = %catchswitch.i
+    // CHECK:   %catchpad2.i = catchpad within %catchswitch1.i [ptr null]
+    // CHECK:   %0 = tail call ptr @llvm.wasm.get.exception(token %catchpad2.i)
+    // CHECK:   %1 = tail call i32 @llvm.wasm.get.ehselector(token %catchpad2.i)
+    // CHECK:   call void %catch_fn(ptr %data, ptr %0) [ "funclet"(token %catchpad2.i) ]
+    // CHECK:   catchret from %catchpad2.i to label %__rust_try.exit
+
+    // CHECK: __rust_try.exit:                                  ; preds = %start, %catchpad.i
+    // CHECK:   %common.ret.op.i = phi i32 [ 0, %start ], [ 1, %catchpad.i ]
+    // CHECK:   ret i32 %common.ret.op.i
+
+    catch_unwind(try_fn, data, catch_fn)
+}
diff --git a/tests/codegen-llvm/enable-lto-unit-splitting.rs b/tests/codegen-llvm/enable-lto-unit-splitting.rs
new file mode 100644
index 00000000000..51c2671bc4e
--- /dev/null
+++ b/tests/codegen-llvm/enable-lto-unit-splitting.rs
@@ -0,0 +1,9 @@
+// Verifies that "EnableSplitLTOUnit" module flag is added.
+//
+//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsplit-lto-unit
+
+#![crate_type = "lib"]
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"EnableSplitLTOUnit", i32 1}
diff --git a/tests/codegen-llvm/enum/enum-aggregate.rs b/tests/codegen-llvm/enum/enum-aggregate.rs
new file mode 100644
index 00000000000..0161e5f3fa1
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-aggregate.rs
@@ -0,0 +1,126 @@
+//@ compile-flags: -Copt-level=0 -Cno-prepopulate-passes
+//@ min-llvm-version: 19
+//@ only-64bit
+
+#![crate_type = "lib"]
+
+use std::cmp::Ordering;
+use std::num::NonZero;
+use std::ptr::NonNull;
+
+#[no_mangle]
+fn make_some_bool(x: bool) -> Option<bool> {
+    // CHECK-LABEL: i8 @make_some_bool(i1 zeroext %x)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %[[WIDER:.+]] = zext i1 %x to i8
+    // CHECK-NEXT: ret i8 %[[WIDER]]
+    Some(x)
+}
+
+#[no_mangle]
+fn make_none_bool() -> Option<bool> {
+    // CHECK-LABEL: i8 @make_none_bool()
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret i8 2
+    None
+}
+
+#[no_mangle]
+fn make_some_ordering(x: Ordering) -> Option<Ordering> {
+    // CHECK-LABEL: i8 @make_some_ordering(i8 %x)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret i8 %x
+    Some(x)
+}
+
+#[no_mangle]
+fn make_some_u16(x: u16) -> Option<u16> {
+    // CHECK-LABEL: { i16, i16 } @make_some_u16(i16 %x)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %0 = insertvalue { i16, i16 } { i16 1, i16 poison }, i16 %x, 1
+    // CHECK-NEXT: ret { i16, i16 } %0
+    Some(x)
+}
+
+#[no_mangle]
+fn make_none_u16() -> Option<u16> {
+    // CHECK-LABEL: { i16, i16 } @make_none_u16()
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret { i16, i16 } { i16 0, i16 undef }
+    None
+}
+
+#[no_mangle]
+fn make_some_nzu32(x: NonZero<u32>) -> Option<NonZero<u32>> {
+    // CHECK-LABEL: i32 @make_some_nzu32(i32 %x)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret i32 %x
+    Some(x)
+}
+
+#[no_mangle]
+fn make_ok_ptr(x: NonNull<u16>) -> Result<NonNull<u16>, usize> {
+    // CHECK-LABEL: { i64, ptr } @make_ok_ptr(ptr %x)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %0 = insertvalue { i64, ptr } { i64 0, ptr poison }, ptr %x, 1
+    // CHECK-NEXT: ret { i64, ptr } %0
+    Ok(x)
+}
+
+#[no_mangle]
+fn make_ok_int(x: usize) -> Result<usize, NonNull<u16>> {
+    // CHECK-LABEL: { i64, ptr } @make_ok_int(i64 %x)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %[[NOPROV:.+]] = getelementptr i8, ptr null, i64 %x
+    // CHECK-NEXT: %[[R:.+]] = insertvalue { i64, ptr } { i64 0, ptr poison }, ptr %[[NOPROV]], 1
+    // CHECK-NEXT: ret { i64, ptr } %[[R]]
+    Ok(x)
+}
+
+#[no_mangle]
+fn make_some_ref(x: &u16) -> Option<&u16> {
+    // CHECK-LABEL: ptr @make_some_ref(ptr align 2 %x)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret ptr %x
+    Some(x)
+}
+
+#[no_mangle]
+fn make_none_ref<'a>() -> Option<&'a u16> {
+    // CHECK-LABEL: ptr @make_none_ref()
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret ptr null
+    None
+}
+
+#[inline(never)]
+fn make_err_generic<E>(e: E) -> Result<u32, E> {
+    // CHECK-LABEL: define{{.+}}make_err_generic
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: call void @llvm.trap()
+    // CHECK-NEXT: ret i32 poison
+    Err(e)
+}
+
+#[no_mangle]
+fn make_uninhabited_err_indirectly(n: Never) -> Result<u32, Never> {
+    // CHECK-LABEL: i32 @make_uninhabited_err_indirectly()
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: call{{.+}}make_err_generic
+    make_err_generic(n)
+}
+
+#[no_mangle]
+fn make_fully_uninhabited_result(v: u32, n: Never) -> Result<(u32, Never), (Never, u32)> {
+    // Actually reaching this would be UB, so we don't actually build a result.
+
+    // CHECK-LABEL: { i32, i32 } @make_fully_uninhabited_result(i32 %v)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: call void @llvm.trap()
+    // CHECK-NEXT: call void @llvm.trap()
+    // CHECK-NEXT: call void @llvm.trap()
+    // CHECK-NEXT: unreachable
+    Ok((v, n))
+}
+
+enum Never {}
diff --git a/tests/codegen-llvm/enum/enum-bounds-check-derived-idx.rs b/tests/codegen-llvm/enum/enum-bounds-check-derived-idx.rs
new file mode 100644
index 00000000000..a5785f4addf
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-bounds-check-derived-idx.rs
@@ -0,0 +1,24 @@
+// This test checks an optimization that is not guaranteed to work. This test case should not block
+// a future LLVM update.
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+pub enum Bar {
+    A = 1,
+    B = 3,
+}
+
+// CHECK-LABEL: @lookup_inc
+#[no_mangle]
+pub fn lookup_inc(buf: &[u8; 5], f: Bar) -> u8 {
+    // CHECK-NOT: panic_bounds_check
+    buf[f as usize + 1]
+}
+
+// CHECK-LABEL: @lookup_dec
+#[no_mangle]
+pub fn lookup_dec(buf: &[u8; 5], f: Bar) -> u8 {
+    // CHECK-NOT: panic_bounds_check
+    buf[f as usize - 1]
+}
diff --git a/tests/codegen-llvm/enum/enum-bounds-check-issue-13926.rs b/tests/codegen-llvm/enum/enum-bounds-check-issue-13926.rs
new file mode 100644
index 00000000000..6e8e5035b0d
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-bounds-check-issue-13926.rs
@@ -0,0 +1,18 @@
+// This test checks an optimization that is not guaranteed to work. This test case should not block
+// a future LLVM update.
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[repr(u8)]
+pub enum Exception {
+    Low = 5,
+    High = 10,
+}
+
+// CHECK-LABEL: @access
+#[no_mangle]
+pub fn access(array: &[usize; 12], exc: Exception) -> usize {
+    // CHECK-NOT: panic_bounds_check
+    array[(exc as u8 - 4) as usize]
+}
diff --git a/tests/codegen-llvm/enum/enum-bounds-check-issue-82871.rs b/tests/codegen-llvm/enum/enum-bounds-check-issue-82871.rs
new file mode 100644
index 00000000000..3b8a146838a
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-bounds-check-issue-82871.rs
@@ -0,0 +1,18 @@
+//@ compile-flags: -C opt-level=0
+
+#![crate_type = "lib"]
+
+#[repr(C)]
+pub enum E {
+    A,
+}
+
+// CHECK-LABEL: @index
+#[no_mangle]
+pub fn index(x: &[u32; 3], ind: E) -> u32 {
+    // Canary: we should be able to optimize out the bounds check, but we need
+    // to track the range of the discriminant result in order to be able to do that.
+    // oli-obk tried to add that, but that caused miscompilations all over the place.
+    // CHECK: panic_bounds_check
+    x[ind as usize]
+}
diff --git a/tests/codegen-llvm/enum/enum-bounds-check.rs b/tests/codegen-llvm/enum/enum-bounds-check.rs
new file mode 100644
index 00000000000..5362598ca7c
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-bounds-check.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+pub enum Foo {
+    A,
+    B,
+}
+
+// CHECK-LABEL: @lookup
+#[no_mangle]
+pub fn lookup(buf: &[u8; 2], f: Foo) -> u8 {
+    // CHECK-NOT: panic_bounds_check
+    buf[f as usize]
+}
+
+pub enum Bar {
+    A = 2,
+    B = 3,
+}
+
+// CHECK-LABEL: @lookup_unmodified
+#[no_mangle]
+pub fn lookup_unmodified(buf: &[u8; 5], f: Bar) -> u8 {
+    // CHECK-NOT: panic_bounds_check
+    buf[f as usize]
+}
diff --git a/tests/codegen-llvm/enum/enum-debug-clike.rs b/tests/codegen-llvm/enum/enum-debug-clike.rs
new file mode 100644
index 00000000000..89c803cce5e
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-debug-clike.rs
@@ -0,0 +1,28 @@
+// This tests that debug info for "c-like" enums is properly emitted.
+// This is ignored for the fallback mode on MSVC due to problems with PDB.
+
+//
+//@ ignore-msvc
+//@ ignore-wasi wasi codegens the main symbol differently
+
+//@ compile-flags: -g -C no-prepopulate-passes
+
+// CHECK-LABEL: @main
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_enumeration_type,{{.*}}name: "E",{{.*}}flags: DIFlagEnumClass,{{.*}}
+// CHECK: {{.*}}DIEnumerator{{.*}}name: "A",{{.*}}value: {{[0-9].*}}
+// CHECK: {{.*}}DIEnumerator{{.*}}name: "B",{{.*}}value: {{[0-9].*}}
+// CHECK: {{.*}}DIEnumerator{{.*}}name: "C",{{.*}}value: {{[0-9].*}}
+
+#![allow(dead_code)]
+#![allow(unused_variables)]
+#![allow(unused_assignments)]
+
+enum E {
+    A,
+    B,
+    C,
+}
+
+pub fn main() {
+    let e = E::C;
+}
diff --git a/tests/codegen-llvm/enum/enum-debug-niche-2.rs b/tests/codegen-llvm/enum/enum-debug-niche-2.rs
new file mode 100644
index 00000000000..80a4081f15b
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-debug-niche-2.rs
@@ -0,0 +1,47 @@
+//! This tests that optimized enum debug info accurately reflects the enum layout.
+//! This is ignored for the fallback mode on MSVC due to problems with PDB.
+//!
+//@ compile-flags: -g -C no-prepopulate-passes
+//@ ignore-msvc
+//
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_variant_part,{{.*}}size: 32,{{.*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "Placeholder",{{.*}}extraData: i32 -1{{[,)].*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "Error",{{.*}}extraData: i32 0{{[,)].*}}
+#![feature(never_type)]
+
+#[derive(Copy, Clone)]
+pub struct Entity {
+    private: std::num::NonZero<u32>,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct Declaration;
+
+impl TypeFamily for Declaration {
+    type Base = Base;
+    type Placeholder = !;
+
+    fn intern_base_data(_: BaseKind<Self>) {}
+}
+
+#[derive(Copy, Clone)]
+pub struct Base;
+
+pub trait TypeFamily: Copy + 'static {
+    type Base: Copy;
+    type Placeholder: Copy;
+
+    fn intern_base_data(_: BaseKind<Self>);
+}
+
+#[derive(Copy, Clone)]
+pub enum BaseKind<F: TypeFamily> {
+    Named(Entity),
+    Placeholder(F::Placeholder),
+    Error,
+}
+
+pub fn main() {
+    let x = BaseKind::Error::<Declaration>;
+    let y = 7;
+}
diff --git a/tests/codegen-llvm/enum/enum-debug-niche.rs b/tests/codegen-llvm/enum/enum-debug-niche.rs
new file mode 100644
index 00000000000..59e8b8a78b4
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-debug-niche.rs
@@ -0,0 +1,35 @@
+// This tests that optimized enum debug info accurately reflects the enum layout.
+// This is ignored for the fallback mode on MSVC due to problems with PDB.
+
+//@ ignore-msvc
+//@ ignore-wasi wasi codegens the main symbol differently
+
+//@ compile-flags: -g -C no-prepopulate-passes
+
+// CHECK-LABEL: @main
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_variant_part,{{.*}}discriminator:{{.*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "A",{{.*}}extraData:{{.*}}
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "A",{{.*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "B",{{.*}}extraData:{{.*}}
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "B",{{.*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "C",{{.*}}extraData:{{.*}}
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "C",{{.*}}
+// CHECK-NOT: {{.*}}DIDerivedType{{.*}}name: "D",{{.*}}extraData:{{.*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "D",{{.*}}
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "D",{{.*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}flags: DIFlagArtificial{{.*}}
+
+#![allow(dead_code)]
+#![allow(unused_variables)]
+#![allow(unused_assignments)]
+
+enum E {
+    A,
+    B,
+    C,
+    D(bool),
+}
+
+pub fn main() {
+    let e = E::D(true);
+}
diff --git a/tests/codegen-llvm/enum/enum-debug-tagged.rs b/tests/codegen-llvm/enum/enum-debug-tagged.rs
new file mode 100644
index 00000000000..e8f147665b0
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-debug-tagged.rs
@@ -0,0 +1,31 @@
+// This tests that debug info for tagged (ordinary) enums is properly emitted.
+// This is ignored for the fallback mode on MSVC due to problems with PDB.
+
+//@ ignore-msvc
+//@ ignore-wasi wasi codegens the main symbol differently
+
+//@ compile-flags: -g -C no-prepopulate-passes
+
+// CHECK-LABEL: @main
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "E",{{.*}}
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_variant_part,{{.*}}discriminator:{{.*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "A",{{.*}}extraData:{{.*}}
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "A",{{.*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "__0",{{.*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "B",{{.*}}extraData:{{.*}}
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "B",{{.*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "__0",{{.*}}
+// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}flags: DIFlagArtificial{{.*}}
+
+#![allow(dead_code)]
+#![allow(unused_variables)]
+#![allow(unused_assignments)]
+
+enum E {
+    A(u32),
+    B(u32),
+}
+
+pub fn main() {
+    let e = E::A(23);
+}
diff --git a/tests/codegen-llvm/enum/enum-discriminant-eq.rs b/tests/codegen-llvm/enum/enum-discriminant-eq.rs
new file mode 100644
index 00000000000..0494c5f551b
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-discriminant-eq.rs
@@ -0,0 +1,223 @@
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+//@ min-llvm-version: 20
+//@ only-64bit
+
+// The `derive(PartialEq)` on enums with field-less variants compares discriminants,
+// so make sure we emit that in some reasonable way.
+
+#![crate_type = "lib"]
+#![feature(ascii_char)]
+#![feature(core_intrinsics)]
+#![feature(repr128)]
+
+use std::ascii::Char as AC;
+use std::cmp::Ordering;
+use std::intrinsics::discriminant_value;
+use std::num::NonZero;
+
+// A type that's bigger than `isize`, unlike the usual cases that have small tags.
+#[repr(u128)]
+pub enum Giant {
+    Two = 2,
+    Three = 3,
+    Four = 4,
+}
+
+#[unsafe(no_mangle)]
+pub fn opt_bool_eq_discr(a: Option<bool>, b: Option<bool>) -> bool {
+    // CHECK-LABEL: @opt_bool_eq_discr(
+    // CHECK: %[[A:.+]] = icmp ne i8 %a, 2
+    // CHECK: %[[B:.+]] = icmp eq i8 %b, 2
+    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
+    // CHECK: ret i1 %[[R]]
+
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn opt_ord_eq_discr(a: Option<Ordering>, b: Option<Ordering>) -> bool {
+    // CHECK-LABEL: @opt_ord_eq_discr(
+    // CHECK: %[[A:.+]] = icmp ne i8 %a, 2
+    // CHECK: %[[B:.+]] = icmp eq i8 %b, 2
+    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
+    // CHECK: ret i1 %[[R]]
+
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn opt_nz32_eq_discr(a: Option<NonZero<u32>>, b: Option<NonZero<u32>>) -> bool {
+    // CHECK-LABEL: @opt_nz32_eq_discr(
+    // CHECK: %[[A:.+]] = icmp ne i32 %a, 0
+    // CHECK: %[[B:.+]] = icmp eq i32 %b, 0
+    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
+    // CHECK: ret i1 %[[R]]
+
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn opt_ac_eq_discr(a: Option<AC>, b: Option<AC>) -> bool {
+    // CHECK-LABEL: @opt_ac_eq_discr(
+    // CHECK: %[[A:.+]] = icmp ne i8 %a, -128
+    // CHECK: %[[B:.+]] = icmp eq i8 %b, -128
+    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
+    // CHECK: ret i1 %[[R]]
+
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn opt_giant_eq_discr(a: Option<Giant>, b: Option<Giant>) -> bool {
+    // CHECK-LABEL: @opt_giant_eq_discr(
+    // CHECK: %[[A:.+]] = icmp ne i128 %a, 1
+    // CHECK: %[[B:.+]] = icmp eq i128 %b, 1
+    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
+    // CHECK: ret i1 %[[R]]
+
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+pub enum Mid<T> {
+    Before,
+    Thing(T),
+    After,
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_bool_eq_discr(a: Mid<bool>, b: Mid<bool>) -> bool {
+    // CHECK-LABEL: @mid_bool_eq_discr(
+
+    // CHECK: %[[A_REL_DISCR:.+]] = add nsw i8 %a, -2
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp samesign ugt i8 %a, 1
+    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %[[A_REL_DISCR]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
+    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
+
+    // CHECK: %[[B_REL_DISCR:.+]] = add nsw i8 %b, -2
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp samesign ugt i8 %b, 1
+    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %[[B_REL_DISCR]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
+    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
+
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_ord_eq_discr(a: Mid<Ordering>, b: Mid<Ordering>) -> bool {
+    // CHECK-LABEL: @mid_ord_eq_discr(
+
+    // CHECK: %[[A_REL_DISCR:.+]] = add nsw i8 %a, -2
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp sgt i8 %a, 1
+    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %[[A_REL_DISCR]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
+    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
+
+    // CHECK: %[[B_REL_DISCR:.+]] = add nsw i8 %b, -2
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp sgt i8 %b, 1
+    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %[[B_REL_DISCR]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
+    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
+
+    // CHECK: %[[R:.+]] = icmp eq i8 %[[A_DISCR]], %[[B_DISCR]]
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_nz32_eq_discr(a: Mid<NonZero<u32>>, b: Mid<NonZero<u32>>) -> bool {
+    // CHECK-LABEL: @mid_nz32_eq_discr(
+    // CHECK: %[[R:.+]] = icmp eq i32 %a.0, %b.0
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_ac_eq_discr(a: Mid<AC>, b: Mid<AC>) -> bool {
+    // CHECK-LABEL: @mid_ac_eq_discr(
+
+    // CHECK: %[[A_REL_DISCR:.+]] = xor i8 %a, -128
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp slt i8 %a, 0
+    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %a, -127
+    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
+    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
+
+    // CHECK: %[[B_REL_DISCR:.+]] = xor i8 %b, -128
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp slt i8 %b, 0
+    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %b, -127
+    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
+    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
+
+    // CHECK: %[[R:.+]] = icmp eq i8 %[[A_DISCR]], %[[B_DISCR]]
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+// FIXME: This should be improved once our LLVM fork picks up the fix for
+// <https://github.com/llvm/llvm-project/issues/134024>
+#[unsafe(no_mangle)]
+pub fn mid_giant_eq_discr(a: Mid<Giant>, b: Mid<Giant>) -> bool {
+    // CHECK-LABEL: @mid_giant_eq_discr(
+
+    // CHECK: %[[A_TRUNC:.+]] = trunc nuw nsw i128 %a to i64
+    // CHECK: %[[A_REL_DISCR:.+]] = add nsw i64 %[[A_TRUNC]], -5
+    // CHECK: %[[A_IS_NICHE:.+]] = icmp samesign ugt i128 %a, 4
+    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i64 %[[A_REL_DISCR]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
+    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i64 %[[A_REL_DISCR]], i64 1
+
+    // CHECK: %[[B_TRUNC:.+]] = trunc nuw nsw i128 %b to i64
+    // CHECK: %[[B_REL_DISCR:.+]] = add nsw i64 %[[B_TRUNC]], -5
+    // CHECK: %[[B_IS_NICHE:.+]] = icmp samesign ugt i128 %b, 4
+    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i64 %[[B_REL_DISCR]], 1
+    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
+    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i64 %[[B_REL_DISCR]], i64 1
+
+    // CHECK: %[[R:.+]] = icmp eq i64 %[[A_DISCR]], %[[B_DISCR]]
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == discriminant_value(&b)
+}
+
+// In niche-encoded enums, testing for the untagged variant should optimize to a
+// straight-forward comparison looking for the natural range of the payload value.
+
+#[unsafe(no_mangle)]
+pub fn mid_bool_is_thing(a: Mid<bool>) -> bool {
+    // CHECK-LABEL: @mid_bool_is_thing(
+    // CHECK: %[[R:.+]] = icmp samesign ult i8 %a, 2
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == 1
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_ord_is_thing(a: Mid<Ordering>) -> bool {
+    // CHECK-LABEL: @mid_ord_is_thing(
+    // CHECK: %[[R:.+]] = icmp slt i8 %a, 2
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == 1
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_nz32_is_thing(a: Mid<NonZero<u32>>) -> bool {
+    // CHECK-LABEL: @mid_nz32_is_thing(
+    // CHECK: %[[R:.+]] = icmp eq i32 %a.0, 1
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == 1
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_ac_is_thing(a: Mid<AC>) -> bool {
+    // CHECK-LABEL: @mid_ac_is_thing(
+    // CHECK: %[[R:.+]] = icmp sgt i8 %a, -1
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == 1
+}
+
+#[unsafe(no_mangle)]
+pub fn mid_giant_is_thing(a: Mid<Giant>) -> bool {
+    // CHECK-LABEL: @mid_giant_is_thing(
+    // CHECK: %[[R:.+]] = icmp samesign ult i128 %a, 5
+    // CHECK: ret i1 %[[R]]
+    discriminant_value(&a) == 1
+}
diff --git a/tests/codegen-llvm/enum/enum-discriminant-value.rs b/tests/codegen-llvm/enum/enum-discriminant-value.rs
new file mode 100644
index 00000000000..d6b0c6d6c10
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-discriminant-value.rs
@@ -0,0 +1,27 @@
+// Verify that DIEnumerator uses isUnsigned flag when appropriate.
+//
+//@ compile-flags: -g -C no-prepopulate-passes
+
+#[repr(i64)]
+pub enum I64 {
+    I64Min = i64::MIN,
+    I64Max = i64::MAX,
+}
+
+#[repr(u64)]
+pub enum U64 {
+    U64Min = u64::MIN,
+    U64Max = u64::MAX,
+}
+
+fn main() {
+    let _a = I64::I64Min;
+    let _b = I64::I64Max;
+    let _c = U64::U64Min;
+    let _d = U64::U64Max;
+}
+
+// CHECK: !DIEnumerator(name: "I64Min", value: -9223372036854775808)
+// CHECK: !DIEnumerator(name: "I64Max", value: 9223372036854775807)
+// CHECK: !DIEnumerator(name: "U64Min", value: 0, isUnsigned: true)
+// CHECK: !DIEnumerator(name: "U64Max", value: 18446744073709551615, isUnsigned: true)
diff --git a/tests/codegen-llvm/enum/enum-early-otherwise-branch.rs b/tests/codegen-llvm/enum/enum-early-otherwise-branch.rs
new file mode 100644
index 00000000000..8d39d8e9b74
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-early-otherwise-branch.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+pub enum Enum {
+    A(u32),
+    B(u32),
+    C(u32),
+}
+
+#[no_mangle]
+pub fn foo(lhs: &Enum, rhs: &Enum) -> bool {
+    // CHECK-LABEL: define{{.*}}i1 @foo(
+    // CHECK-NOT: switch
+    // CHECK-NOT: br
+    // CHECK: [[SELECT:%.*]] = select
+    // CHECK-NEXT: ret i1 [[SELECT]]
+    // CHECK-NEXT: }
+    match (lhs, rhs) {
+        (Enum::A(lhs), Enum::A(rhs)) => lhs == rhs,
+        (Enum::B(lhs), Enum::B(rhs)) => lhs == rhs,
+        (Enum::C(lhs), Enum::C(rhs)) => lhs == rhs,
+        _ => false,
+    }
+}
diff --git a/tests/codegen-llvm/enum/enum-match.rs b/tests/codegen-llvm/enum/enum-match.rs
new file mode 100644
index 00000000000..57db44ec74e
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-match.rs
@@ -0,0 +1,779 @@
+//@ compile-flags: -Copt-level=1
+//@ only-64bit
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+// Check each of the 3 cases for `codegen_get_discr`.
+
+// FIXME: once our min-bar LLVM has `range` attributes, update the various
+// tests here to no longer have the `range`s and `nsw`s as optional.
+
+// Case 0: One tagged variant.
+pub enum Enum0 {
+    A(bool),
+    B,
+}
+
+// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match0(i8{{.+}}%0)
+// CHECK-NEXT: start:
+// CHECK-NEXT: %[[IS_B:.+]] = icmp eq i8 %0, 2
+// CHECK-NEXT: %[[TRUNC:.+]] = and i8 %0, 1
+// CHECK-NEXT: %[[R:.+]] = select i1 %[[IS_B]], i8 13, i8 %[[TRUNC]]
+// CHECK-NEXT: ret i8 %[[R]]
+#[no_mangle]
+pub fn match0(e: Enum0) -> u8 {
+    use Enum0::*;
+    match e {
+        A(b) => b as u8,
+        B => 13,
+    }
+}
+
+// Case 1: Niche values are on a boundary for `range`.
+pub enum Enum1 {
+    A(bool),
+    B,
+    C,
+}
+
+// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match1(i8{{.+}}%0)
+// CHECK-NEXT: start:
+// CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
+// CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
+// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp{{( samesign)?}} ugt i8 %0, 1
+// CHECK-NEXT: %[[NICHE_DISCR:.+]] = add nuw nsw i64 %[[REL_VAR_WIDE]], 1
+// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i64 %[[NICHE_DISCR]], i64 0
+// CHECK-NEXT: switch i64 %[[DISCR]]
+#[no_mangle]
+pub fn match1(e: Enum1) -> u8 {
+    use Enum1::*;
+    match e {
+        A(b) => b as u8,
+        B => 13,
+        C => 100,
+    }
+}
+
+// Case 2: Special cases don't apply.
+#[rustfmt::skip]
+pub enum X {
+    _2=2, _3, _4, _5, _6, _7, _8, _9, _10, _11,
+    _12, _13, _14, _15, _16, _17, _18, _19, _20,
+    _21, _22, _23, _24, _25, _26, _27, _28, _29,
+    _30, _31, _32, _33, _34, _35, _36, _37, _38,
+    _39, _40, _41, _42, _43, _44, _45, _46, _47,
+    _48, _49, _50, _51, _52, _53, _54, _55, _56,
+    _57, _58, _59, _60, _61, _62, _63, _64, _65,
+    _66, _67, _68, _69, _70, _71, _72, _73, _74,
+    _75, _76, _77, _78, _79, _80, _81, _82, _83,
+    _84, _85, _86, _87, _88, _89, _90, _91, _92,
+    _93, _94, _95, _96, _97, _98, _99, _100, _101,
+    _102, _103, _104, _105, _106, _107, _108, _109,
+    _110, _111, _112, _113, _114, _115, _116, _117,
+    _118, _119, _120, _121, _122, _123, _124, _125,
+    _126, _127, _128, _129, _130, _131, _132, _133,
+    _134, _135, _136, _137, _138, _139, _140, _141,
+    _142, _143, _144, _145, _146, _147, _148, _149,
+    _150, _151, _152, _153, _154, _155, _156, _157,
+    _158, _159, _160, _161, _162, _163, _164, _165,
+    _166, _167, _168, _169, _170, _171, _172, _173,
+    _174, _175, _176, _177, _178, _179, _180, _181,
+    _182, _183, _184, _185, _186, _187, _188, _189,
+    _190, _191, _192, _193, _194, _195, _196, _197,
+    _198, _199, _200, _201, _202, _203, _204, _205,
+    _206, _207, _208, _209, _210, _211, _212, _213,
+    _214, _215, _216, _217, _218, _219, _220, _221,
+    _222, _223, _224, _225, _226, _227, _228, _229,
+    _230, _231, _232, _233, _234, _235, _236, _237,
+    _238, _239, _240, _241, _242, _243, _244, _245,
+    _246, _247, _248, _249, _250, _251, _252, _253,
+}
+
+pub enum Enum2 {
+    A(X),
+    B,
+    C,
+    D,
+    E,
+}
+
+// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, -?[0-9]+\))?}} i8 @match2(i8{{.+}}%0)
+// CHECK-NEXT: start:
+// CHECK-NEXT: %[[REL_VAR:.+]] = add i8 %0, 2
+// CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
+// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp ult i8 %[[REL_VAR]], 4
+// CHECK-NEXT: %[[NICHE_DISCR:.+]] = add nuw nsw i64 %[[REL_VAR_WIDE]], 1
+// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i64 %[[NICHE_DISCR]], i64 0
+// CHECK-NEXT: switch i64 %[[DISCR]]
+#[no_mangle]
+pub fn match2(e: Enum2) -> u8 {
+    use Enum2::*;
+    match e {
+        A(b) => b as u8,
+        B => 13,
+        C => 100,
+        D => 200,
+        E => 250,
+    }
+}
+
+// And make sure it works even if the niched scalar is a pointer.
+// (For example, that we don't try to `sub` on pointers.)
+
+// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i16 -?[0-9]+, -?[0-9]+\))?}} i16 @match3(ptr{{.+}}%0)
+// CHECK-NEXT: start:
+// CHECK-NEXT: %[[IS_NULL:.+]] = icmp eq ptr %0, null
+// CHECK-NEXT: br i1 %[[IS_NULL]]
+#[no_mangle]
+pub fn match3(e: Option<&u8>) -> i16 {
+    match e {
+        Some(r) => *r as _,
+        None => -1,
+    }
+}
+
+// If the untagged variant is in the middle, there's an impossible value that's
+// not reflected in the `range` parameter attribute, so we assume it away.
+
+#[derive(PartialEq)]
+pub enum MiddleNiche {
+    A,
+    B,
+    C(bool),
+    D,
+    E,
+}
+
+// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 -?[0-9]+, -?[0-9]+\))?}} i8 @match4(i8{{.+}}%0)
+// CHECK-NEXT: start:
+// CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
+// CHECK-NEXT: %[[NOT_IMPOSSIBLE:.+]] = icmp ne i8 %[[REL_VAR]], 2
+// CHECK-NEXT: call void @llvm.assume(i1 %[[NOT_IMPOSSIBLE]])
+// CHECK-NEXT: %[[NOT_NICHE:.+]] = icmp{{( samesign)?}} ult i8 %0, 2
+// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[NOT_NICHE]], i8 2, i8 %[[REL_VAR]]
+// CHECK-NEXT: switch i8 %[[DISCR]]
+#[no_mangle]
+pub fn match4(e: MiddleNiche) -> u8 {
+    use MiddleNiche::*;
+    match e {
+        A => 13,
+        B => 100,
+        C(b) => b as u8,
+        D => 200,
+        E => 250,
+    }
+}
+
+// CHECK-LABEL: define{{.+}}i1 @match4_is_c(i8{{.+}}%e)
+// CHECK-NEXT: start
+// CHECK-NEXT: %[[NOT_IMPOSSIBLE:.+]] = icmp ne i8 %e, 4
+// CHECK-NEXT: call void @llvm.assume(i1 %[[NOT_IMPOSSIBLE]])
+// CHECK-NEXT: %[[IS_C:.+]] = icmp{{( samesign)?}} ult i8 %e, 2
+// CHECK-NEXT: ret i1 %[[IS_C]]
+#[no_mangle]
+pub fn match4_is_c(e: MiddleNiche) -> bool {
+    // Before #139098, this couldn't optimize out the `select` because it looked
+    // like it was possible for a `2` to be produced on both sides.
+
+    std::intrinsics::discriminant_value(&e) == 2
+}
+
+// You have to do something pretty obnoxious to get a variant index that doesn't
+// fit in the tag size, but it's possible
+
+pub enum Never {}
+
+pub enum HugeVariantIndex {
+    V000(Never),
+    V001(Never),
+    V002(Never),
+    V003(Never),
+    V004(Never),
+    V005(Never),
+    V006(Never),
+    V007(Never),
+    V008(Never),
+    V009(Never),
+    V010(Never),
+    V011(Never),
+    V012(Never),
+    V013(Never),
+    V014(Never),
+    V015(Never),
+    V016(Never),
+    V017(Never),
+    V018(Never),
+    V019(Never),
+    V020(Never),
+    V021(Never),
+    V022(Never),
+    V023(Never),
+    V024(Never),
+    V025(Never),
+    V026(Never),
+    V027(Never),
+    V028(Never),
+    V029(Never),
+    V030(Never),
+    V031(Never),
+    V032(Never),
+    V033(Never),
+    V034(Never),
+    V035(Never),
+    V036(Never),
+    V037(Never),
+    V038(Never),
+    V039(Never),
+    V040(Never),
+    V041(Never),
+    V042(Never),
+    V043(Never),
+    V044(Never),
+    V045(Never),
+    V046(Never),
+    V047(Never),
+    V048(Never),
+    V049(Never),
+    V050(Never),
+    V051(Never),
+    V052(Never),
+    V053(Never),
+    V054(Never),
+    V055(Never),
+    V056(Never),
+    V057(Never),
+    V058(Never),
+    V059(Never),
+    V060(Never),
+    V061(Never),
+    V062(Never),
+    V063(Never),
+    V064(Never),
+    V065(Never),
+    V066(Never),
+    V067(Never),
+    V068(Never),
+    V069(Never),
+    V070(Never),
+    V071(Never),
+    V072(Never),
+    V073(Never),
+    V074(Never),
+    V075(Never),
+    V076(Never),
+    V077(Never),
+    V078(Never),
+    V079(Never),
+    V080(Never),
+    V081(Never),
+    V082(Never),
+    V083(Never),
+    V084(Never),
+    V085(Never),
+    V086(Never),
+    V087(Never),
+    V088(Never),
+    V089(Never),
+    V090(Never),
+    V091(Never),
+    V092(Never),
+    V093(Never),
+    V094(Never),
+    V095(Never),
+    V096(Never),
+    V097(Never),
+    V098(Never),
+    V099(Never),
+    V100(Never),
+    V101(Never),
+    V102(Never),
+    V103(Never),
+    V104(Never),
+    V105(Never),
+    V106(Never),
+    V107(Never),
+    V108(Never),
+    V109(Never),
+    V110(Never),
+    V111(Never),
+    V112(Never),
+    V113(Never),
+    V114(Never),
+    V115(Never),
+    V116(Never),
+    V117(Never),
+    V118(Never),
+    V119(Never),
+    V120(Never),
+    V121(Never),
+    V122(Never),
+    V123(Never),
+    V124(Never),
+    V125(Never),
+    V126(Never),
+    V127(Never),
+    V128(Never),
+    V129(Never),
+    V130(Never),
+    V131(Never),
+    V132(Never),
+    V133(Never),
+    V134(Never),
+    V135(Never),
+    V136(Never),
+    V137(Never),
+    V138(Never),
+    V139(Never),
+    V140(Never),
+    V141(Never),
+    V142(Never),
+    V143(Never),
+    V144(Never),
+    V145(Never),
+    V146(Never),
+    V147(Never),
+    V148(Never),
+    V149(Never),
+    V150(Never),
+    V151(Never),
+    V152(Never),
+    V153(Never),
+    V154(Never),
+    V155(Never),
+    V156(Never),
+    V157(Never),
+    V158(Never),
+    V159(Never),
+    V160(Never),
+    V161(Never),
+    V162(Never),
+    V163(Never),
+    V164(Never),
+    V165(Never),
+    V166(Never),
+    V167(Never),
+    V168(Never),
+    V169(Never),
+    V170(Never),
+    V171(Never),
+    V172(Never),
+    V173(Never),
+    V174(Never),
+    V175(Never),
+    V176(Never),
+    V177(Never),
+    V178(Never),
+    V179(Never),
+    V180(Never),
+    V181(Never),
+    V182(Never),
+    V183(Never),
+    V184(Never),
+    V185(Never),
+    V186(Never),
+    V187(Never),
+    V188(Never),
+    V189(Never),
+    V190(Never),
+    V191(Never),
+    V192(Never),
+    V193(Never),
+    V194(Never),
+    V195(Never),
+    V196(Never),
+    V197(Never),
+    V198(Never),
+    V199(Never),
+    V200(Never),
+    V201(Never),
+    V202(Never),
+    V203(Never),
+    V204(Never),
+    V205(Never),
+    V206(Never),
+    V207(Never),
+    V208(Never),
+    V209(Never),
+    V210(Never),
+    V211(Never),
+    V212(Never),
+    V213(Never),
+    V214(Never),
+    V215(Never),
+    V216(Never),
+    V217(Never),
+    V218(Never),
+    V219(Never),
+    V220(Never),
+    V221(Never),
+    V222(Never),
+    V223(Never),
+    V224(Never),
+    V225(Never),
+    V226(Never),
+    V227(Never),
+    V228(Never),
+    V229(Never),
+    V230(Never),
+    V231(Never),
+    V232(Never),
+    V233(Never),
+    V234(Never),
+    V235(Never),
+    V236(Never),
+    V237(Never),
+    V238(Never),
+    V239(Never),
+    V240(Never),
+    V241(Never),
+    V242(Never),
+    V243(Never),
+    V244(Never),
+    V245(Never),
+    V246(Never),
+    V247(Never),
+    V248(Never),
+    V249(Never),
+    V250(Never),
+    V251(Never),
+    V252(Never),
+    V253(Never),
+    V254(Never),
+    V255(Never),
+    V256(Never),
+
+    Possible257,
+    Bool258(bool),
+    Possible259,
+}
+
+// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match5(i8{{.+}}%0)
+// CHECK-NEXT: start:
+// CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
+// CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
+// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp{{( samesign)?}} ugt i8 %0, 1
+// CHECK-NEXT: %[[NICHE_DISCR:.+]] = add nuw nsw i64 %[[REL_VAR_WIDE]], 257
+// CHECK-NEXT: %[[NOT_IMPOSSIBLE:.+]] = icmp ne i64 %[[NICHE_DISCR]], 258
+// CHECK-NEXT: call void @llvm.assume(i1 %[[NOT_IMPOSSIBLE]])
+// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i64 %[[NICHE_DISCR]], i64 258
+// CHECK-NEXT: switch i64 %[[DISCR]],
+// CHECK-NEXT:   i64 257,
+// CHECK-NEXT:   i64 258,
+// CHECK-NEXT:   i64 259,
+#[no_mangle]
+pub fn match5(e: HugeVariantIndex) -> u8 {
+    use HugeVariantIndex::*;
+    match e {
+        Possible257 => 13,
+        Bool258(b) => b as u8,
+        Possible259 => 100,
+    }
+}
+
+// Make an enum where the niche tags wrap both as signed and as unsigned, to hit
+// the most-fallback case where there's just nothing smart to do.
+
+pub enum E10Through65 {
+    D10 = 10,
+    D11 = 11,
+    D12 = 12,
+    D13 = 13,
+    D14 = 14,
+    D15 = 15,
+    D16 = 16,
+    D17 = 17,
+    D18 = 18,
+    D19 = 19,
+    D20 = 20,
+    D21 = 21,
+    D22 = 22,
+    D23 = 23,
+    D24 = 24,
+    D25 = 25,
+    D26 = 26,
+    D27 = 27,
+    D28 = 28,
+    D29 = 29,
+    D30 = 30,
+    D31 = 31,
+    D32 = 32,
+    D33 = 33,
+    D34 = 34,
+    D35 = 35,
+    D36 = 36,
+    D37 = 37,
+    D38 = 38,
+    D39 = 39,
+    D40 = 40,
+    D41 = 41,
+    D42 = 42,
+    D43 = 43,
+    D44 = 44,
+    D45 = 45,
+    D46 = 46,
+    D47 = 47,
+    D48 = 48,
+    D49 = 49,
+    D50 = 50,
+    D51 = 51,
+    D52 = 52,
+    D53 = 53,
+    D54 = 54,
+    D55 = 55,
+    D56 = 56,
+    D57 = 57,
+    D58 = 58,
+    D59 = 59,
+    D60 = 60,
+    D61 = 61,
+    D62 = 62,
+    D63 = 63,
+    D64 = 64,
+    D65 = 65,
+}
+
+pub enum Tricky {
+    Untagged(E10Through65),
+    V001,
+    V002,
+    V003,
+    V004,
+    V005,
+    V006,
+    V007,
+    V008,
+    V009,
+    V010,
+    V011,
+    V012,
+    V013,
+    V014,
+    V015,
+    V016,
+    V017,
+    V018,
+    V019,
+    V020,
+    V021,
+    V022,
+    V023,
+    V024,
+    V025,
+    V026,
+    V027,
+    V028,
+    V029,
+    V030,
+    V031,
+    V032,
+    V033,
+    V034,
+    V035,
+    V036,
+    V037,
+    V038,
+    V039,
+    V040,
+    V041,
+    V042,
+    V043,
+    V044,
+    V045,
+    V046,
+    V047,
+    V048,
+    V049,
+    V050,
+    V051,
+    V052,
+    V053,
+    V054,
+    V055,
+    V056,
+    V057,
+    V058,
+    V059,
+    V060,
+    V061,
+    V062,
+    V063,
+    V064,
+    V065,
+    V066,
+    V067,
+    V068,
+    V069,
+    V070,
+    V071,
+    V072,
+    V073,
+    V074,
+    V075,
+    V076,
+    V077,
+    V078,
+    V079,
+    V080,
+    V081,
+    V082,
+    V083,
+    V084,
+    V085,
+    V086,
+    V087,
+    V088,
+    V089,
+    V090,
+    V091,
+    V092,
+    V093,
+    V094,
+    V095,
+    V096,
+    V097,
+    V098,
+    V099,
+    V100,
+    V101,
+    V102,
+    V103,
+    V104,
+    V105,
+    V106,
+    V107,
+    V108,
+    V109,
+    V110,
+    V111,
+    V112,
+    V113,
+    V114,
+    V115,
+    V116,
+    V117,
+    V118,
+    V119,
+    V120,
+    V121,
+    V122,
+    V123,
+    V124,
+    V125,
+    V126,
+    V127,
+    V128,
+    V129,
+    V130,
+    V131,
+    V132,
+    V133,
+    V134,
+    V135,
+    V136,
+    V137,
+    V138,
+    V139,
+    V140,
+    V141,
+    V142,
+    V143,
+    V144,
+    V145,
+    V146,
+    V147,
+    V148,
+    V149,
+    V150,
+    V151,
+    V152,
+    V153,
+    V154,
+    V155,
+    V156,
+    V157,
+    V158,
+    V159,
+    V160,
+    V161,
+    V162,
+    V163,
+    V164,
+    V165,
+    V166,
+    V167,
+    V168,
+    V169,
+    V170,
+    V171,
+    V172,
+    V173,
+    V174,
+    V175,
+    V176,
+    V177,
+    V178,
+    V179,
+    V180,
+    V181,
+    V182,
+    V183,
+    V184,
+    V185,
+    V186,
+    V187,
+    V188,
+    V189,
+    V190,
+    V191,
+    V192,
+    V193,
+    V194,
+    V195,
+    V196,
+    V197,
+    V198,
+    V199,
+    V200,
+}
+
+const _: () = assert!(std::intrinsics::discriminant_value(&Tricky::V100) == 100);
+
+// CHECK-LABEL: define noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @discriminant6(i8 noundef %e)
+// CHECK-NEXT: start:
+// CHECK-NEXT: %[[REL_VAR:.+]] = add i8 %e, -66
+// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp ult i8 %[[REL_VAR]], -56
+// CHECK-NEXT: %[[TAGGED_DISCR:.+]] = add i8 %e, -65
+// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i8 %[[TAGGED_DISCR]], i8 0
+// CHECK-NEXT: ret i8 %[[DISCR]]
+#[no_mangle]
+pub fn discriminant6(e: Tricky) -> u8 {
+    std::intrinsics::discriminant_value(&e) as _
+}
+
+// Case from <https://github.com/rust-lang/rust/issues/104519>,
+// where sign-extension is important.
+
+pub enum OpenResult {
+    Ok(()),
+    Err(()),
+    TransportErr(TransportErr),
+}
+
+#[repr(i32)]
+pub enum TransportErr {
+    UnknownMethod = -2,
+}
+
+#[no_mangle]
+pub fn match7(result: OpenResult) -> u8 {
+    // CHECK-LABEL: define 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
+    // CHECK-NEXT: ret i8 %[[RET]]
+    match result {
+        OpenResult::Ok(()) => 0,
+        _ => 1,
+    }
+}
diff --git a/tests/codegen-llvm/enum/enum-two-variants-match.rs b/tests/codegen-llvm/enum/enum-two-variants-match.rs
new file mode 100644
index 00000000000..12d9edc4d62
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-two-variants-match.rs
@@ -0,0 +1,130 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+//@ only-64bit (because these discriminants are isize)
+
+#![crate_type = "lib"]
+
+// This directly tests what we emit for these matches, rather than what happens
+// after optimization, so it doesn't need to worry about extra flags on the
+// instructions and is less susceptible to being broken on LLVM updates.
+
+// CHECK-LABEL: @option_match
+#[no_mangle]
+pub fn option_match(x: Option<i32>) -> u16 {
+    // CHECK-NOT: %x = alloca
+    // CHECK: %[[OUT:.+]] = alloca [2 x i8]
+    // CHECK-NOT: %x = alloca
+
+    // CHECK: %[[DISCR:.+]] = zext i32 %x.0 to i64
+    // CHECK: %[[COND:.+]] = trunc nuw i64 %[[DISCR]] to i1
+    // CHECK: br i1 %[[COND]], label %[[TRUE:[a-z0-9]+]], label %[[FALSE:[a-z0-9]+]]
+
+    // CHECK: [[TRUE]]:
+    // CHECK: store i16 13, ptr %[[OUT]]
+
+    // CHECK: [[FALSE]]:
+    // CHECK: store i16 42, ptr %[[OUT]]
+
+    // CHECK: %[[RET:.+]] = load i16, ptr %[[OUT]]
+    // CHECK: ret i16 %[[RET]]
+    match x {
+        Some(_) => 13,
+        None => 42,
+    }
+}
+
+// CHECK-LABEL: @result_match
+#[no_mangle]
+pub fn result_match(x: Result<u64, i64>) -> u16 {
+    // CHECK-NOT: %x = alloca
+    // CHECK: %[[OUT:.+]] = alloca [2 x i8]
+    // CHECK-NOT: %x = alloca
+
+    // CHECK: %[[COND:.+]] = trunc nuw i64 %x.0 to i1
+    // CHECK: br i1 %[[COND]], label %[[TRUE:[a-z0-9]+]], label %[[FALSE:[a-z0-9]+]]
+
+    // CHECK: [[TRUE]]:
+    // CHECK: store i16 13, ptr %[[OUT]]
+
+    // CHECK: [[FALSE]]:
+    // CHECK: store i16 42, ptr %[[OUT]]
+
+    // CHECK: %[[RET:.+]] = load i16, ptr %[[OUT]]
+    // CHECK: ret i16 %[[RET]]
+    match x {
+        Err(_) => 13,
+        Ok(_) => 42,
+    }
+}
+
+// CHECK-LABEL: @option_bool_match(
+#[no_mangle]
+pub fn option_bool_match(x: Option<bool>) -> char {
+    // CHECK: %[[RAW:.+]] = load i8, ptr %x
+    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %[[RAW]], 2
+    // CHECK: %[[OPT_DISCR:.+]] = select i1 %[[IS_NONE]], i64 0, i64 1
+    // CHECK: %[[OPT_DISCR_T:.+]] = trunc nuw i64 %[[OPT_DISCR]] to i1
+    // CHECK: br i1 %[[OPT_DISCR_T]], label %[[BB_SOME:.+]], label %[[BB_NONE:.+]]
+
+    // CHECK: [[BB_SOME]]:
+    // CHECK: %[[FIELD:.+]] = load i8, ptr %x
+    // CHECK: %[[FIELD_T:.+]] = trunc nuw i8 %[[FIELD]] to i1
+    // CHECK: br i1 %[[FIELD_T]]
+    match x {
+        None => 'n',
+        Some(false) => 'f',
+        Some(true) => 't',
+    }
+}
+
+use std::cmp::Ordering::{self, *};
+// CHECK-LABEL: @option_ordering_match(
+#[no_mangle]
+pub fn option_ordering_match(x: Option<Ordering>) -> char {
+    // CHECK: %[[RAW:.+]] = load i8, ptr %x
+    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %[[RAW]], 2
+    // CHECK: %[[OPT_DISCR:.+]] = select i1 %[[IS_NONE]], i64 0, i64 1
+    // CHECK: %[[OPT_DISCR_T:.+]] = trunc nuw i64 %[[OPT_DISCR]] to i1
+    // CHECK: br i1 %[[OPT_DISCR_T]], label %[[BB_SOME:.+]], label %[[BB_NONE:.+]]
+
+    // CHECK: [[BB_SOME]]:
+    // CHECK: %[[FIELD:.+]] = load i8, ptr %x
+    // CHECK: switch i8 %[[FIELD]], label %[[UNREACHABLE:.+]] [
+    // CHECK-NEXT: i8 -1, label
+    // CHECK-NEXT: i8 0, label
+    // CHECK-NEXT: i8 1, label
+    // CHECK-NEXT: ]
+
+    // CHECK: [[UNREACHABLE]]:
+    // CHECK-NEXT: unreachable
+    match x {
+        None => '?',
+        Some(Less) => '<',
+        Some(Equal) => '=',
+        Some(Greater) => '>',
+    }
+}
+
+// CHECK-LABEL: @option_nonzero_match(
+#[no_mangle]
+pub fn option_nonzero_match(x: Option<std::num::NonZero<u16>>) -> u16 {
+    // CHECK: %[[OUT:.+]] = alloca [2 x i8]
+
+    // CHECK: %[[IS_NONE:.+]] = icmp eq i16 %x, 0
+    // CHECK: %[[OPT_DISCR:.+]] = select i1 %[[IS_NONE]], i64 0, i64 1
+    // CHECK: %[[OPT_DISCR_T:.+]] = trunc nuw i64 %[[OPT_DISCR]] to i1
+    // CHECK: br i1 %[[OPT_DISCR_T]], label %[[BB_SOME:.+]], label %[[BB_NONE:.+]]
+
+    // CHECK: [[BB_SOME]]:
+    // CHECK: store i16 987, ptr %[[OUT]]
+
+    // CHECK: [[BB_NONE]]:
+    // CHECK: store i16 123, ptr %[[OUT]]
+
+    // CHECK: %[[RET:.+]] = load i16, ptr %[[OUT]]
+    // CHECK: ret i16 %[[RET]]
+
+    match x {
+        None => 123,
+        Some(_) => 987,
+    }
+}
diff --git a/tests/codegen-llvm/enum/enum-u128.rs b/tests/codegen-llvm/enum/enum-u128.rs
new file mode 100644
index 00000000000..2676669f3e3
--- /dev/null
+++ b/tests/codegen-llvm/enum/enum-u128.rs
@@ -0,0 +1,25 @@
+// This tests that debug info for "c-like" 128bit enums is properly emitted.
+// This is ignored for the fallback mode on MSVC due to problems with PDB.
+
+//
+//@ ignore-msvc
+//@ ignore-wasi wasi codegens the main symbol differently
+
+//@ compile-flags: -g -C no-prepopulate-passes
+
+// CHECK-LABEL: @main
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_enumeration_type,{{.*}}name: "Foo",{{.*}}flags: DIFlagEnumClass,{{.*}}
+// CHECK: {{.*}}DIEnumerator{{.*}}name: "Lo",{{.*}}value: 0,{{.*}}
+// CHECK: {{.*}}DIEnumerator{{.*}}name: "Hi",{{.*}}value: 18446744073709551616,{{.*}}
+// CHECK: {{.*}}DIEnumerator{{.*}}name: "Bar",{{.*}}value: 18446745000000000123,{{.*}}
+
+#[repr(u128)]
+pub enum Foo {
+    Lo,
+    Hi = 1 << 64,
+    Bar = 18_446_745_000_000_000_123,
+}
+
+pub fn main() {
+    let foo = Foo::Bar;
+}
diff --git a/tests/codegen-llvm/enum/unreachable_enum_default_branch.rs b/tests/codegen-llvm/enum/unreachable_enum_default_branch.rs
new file mode 100644
index 00000000000..55b165fc111
--- /dev/null
+++ b/tests/codegen-llvm/enum/unreachable_enum_default_branch.rs
@@ -0,0 +1,40 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Int(u32);
+
+const A: Int = Int(201);
+const B: Int = Int(270);
+const C: Int = Int(153);
+
+// The code is from https://github.com/rust-lang/rust/issues/119520.
+// This code will basically turn into `matches!(x.partial_cmp(&A), Some(Greater | Equal))`.
+// The otherwise branch must be `Less`.
+// CHECK-LABEL: @implicit_match(
+// CHECK-SAME: [[TMP0:%.*]])
+// CHECK-NEXT:  start:
+// CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[TMP0]], -201
+// CHECK-NEXT:    icmp ult i32 [[TMP1]], 70
+// CHECK-NEXT:    icmp eq i32 [[TMP0]], 153
+// CHECK-NEXT:    [[SPEC_SELECT:%.*]] = or i1
+// CHECK-NEXT:    ret i1 [[SPEC_SELECT]]
+#[no_mangle]
+pub fn implicit_match(x: Int) -> bool {
+    (x >= A && x <= B) || x == C
+}
+
+// The code is from https://github.com/rust-lang/rust/issues/110097.
+// We expect it to generate the same optimized code as a full match.
+// CHECK-LABEL: @if_let(
+// CHECK: start:
+// CHECK-NOT: zext
+// CHECK: select
+// CHECK-NEXT: insertvalue
+// CHECK-NEXT: insertvalue
+// CHECK-NEXT: ret
+#[no_mangle]
+pub fn if_let(val: Result<i32, ()>) -> Result<i32, ()> {
+    if let Ok(x) = val { Ok(x * 2) } else { Err(()) }
+}
diff --git a/tests/codegen-llvm/ergonomic-clones/closure.rs b/tests/codegen-llvm/ergonomic-clones/closure.rs
new file mode 100644
index 00000000000..b6fc8172641
--- /dev/null
+++ b/tests/codegen-llvm/ergonomic-clones/closure.rs
@@ -0,0 +1,55 @@
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0 -Zmir-opt-level=0
+
+#![crate_type = "lib"]
+
+#![feature(ergonomic_clones)]
+#![allow(incomplete_features)]
+
+use std::clone::UseCloned;
+
+pub fn ergonomic_clone_closure_move() -> String {
+    let s = String::from("hi");
+
+    // CHECK-NOT: ; call core::clone::impls::<impl core::clone::Clone for String>::clone
+    let cl = use || s;
+    cl()
+}
+
+#[derive(Clone)]
+struct Foo;
+
+impl UseCloned for Foo {}
+
+pub fn ergonomic_clone_closure_use_cloned() -> Foo {
+    let f = Foo;
+
+    // CHECK: ; call <closure::Foo as core::clone::Clone>::clone
+    let f1 = use || f;
+
+    // CHECK: ; call <closure::Foo as core::clone::Clone>::clone
+    let f2 = use || f;
+
+    f
+}
+
+pub fn ergonomic_clone_closure_copy() -> i32 {
+    let i = 1;
+
+    // CHECK-NOT: ; call core::clone::impls::<impl core::clone::Clone for i32>::clone
+    let i1 = use || i;
+
+    // CHECK-NOT: ; call core::clone::impls::<impl core::clone::Clone for i32>::clone
+    let i2 = use || i;
+
+    i
+}
+
+pub fn ergonomic_clone_closure_use_cloned_generics<T: UseCloned>(f: T) -> T {
+    // CHECK-NOT: ; call core::clone::impls::<impl core::clone::Clone for i32>::clone
+    let f1 = use || f;
+
+    // CHECK-NOT: ; call core::clone::impls::<impl core::clone::Clone for i32>::clone
+    let f2 = use || f;
+
+    f
+}
diff --git a/tests/codegen-llvm/error-provide.rs b/tests/codegen-llvm/error-provide.rs
new file mode 100644
index 00000000000..7f091e34359
--- /dev/null
+++ b/tests/codegen-llvm/error-provide.rs
@@ -0,0 +1,50 @@
+// Codegen test for #126242
+
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+#![feature(error_generic_member_access)]
+use std::error::Request;
+use std::fmt;
+
+#[derive(Debug)]
+struct MyBacktrace1 {}
+
+#[derive(Debug)]
+struct MyBacktrace2 {}
+
+#[derive(Debug)]
+struct MyBacktrace3 {}
+
+#[derive(Debug)]
+struct MyError {
+    backtrace1: MyBacktrace1,
+    backtrace2: MyBacktrace2,
+    backtrace3: MyBacktrace3,
+    other: MyBacktrace3,
+}
+
+impl fmt::Display for MyError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Example Error")
+    }
+}
+
+impl std::error::Error for MyError {
+    // CHECK-LABEL: @provide
+    #[no_mangle]
+    fn provide<'a>(&'a self, request: &mut Request<'a>) {
+        // LLVM should be able to optimize multiple .provide_* calls into a switch table
+        // and eliminate redundant ones, rather than compare one-by-one.
+
+        // CHECK-NEXT: start:
+        // CHECK-NEXT: %[[SCRUTINEE:[^ ]+]] = load i128, ptr
+        // CHECK-NEXT: switch i128 %[[SCRUTINEE]], label %{{.*}} [
+        // CHECK-COUNT-3: i128 {{.*}}, label %{{.*}}
+        // CHECK-NEXT: ]
+        request
+            .provide_ref::<MyBacktrace1>(&self.backtrace1)
+            .provide_ref::<MyBacktrace3>(&self.other)
+            .provide_ref::<MyBacktrace2>(&self.backtrace2)
+            .provide_ref::<MyBacktrace3>(&self.backtrace3);
+    }
+}
diff --git a/tests/codegen-llvm/export-no-mangle.rs b/tests/codegen-llvm/export-no-mangle.rs
new file mode 100644
index 00000000000..5040684f52e
--- /dev/null
+++ b/tests/codegen-llvm/export-no-mangle.rs
@@ -0,0 +1,31 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+mod private {
+    // CHECK: @FOO =
+    #[no_mangle]
+    pub static FOO: u32 = 3;
+
+    // CHECK: @BAR =
+    #[export_name = "BAR"]
+    static BAR: u32 = 3;
+
+    // CHECK: void @a()
+    #[no_mangle]
+    pub extern "C" fn a() {}
+
+    // CHECK: void @b()
+    #[export_name = "b"]
+    extern "C" fn b() {}
+
+    // CHECK: void @c()
+    #[export_name = "c"]
+    #[inline]
+    extern "C" fn c() {}
+
+    // CHECK: void @d()
+    #[export_name = "d"]
+    #[inline(always)]
+    extern "C" fn d() {}
+}
diff --git a/tests/codegen-llvm/external-no-mangle-fns.rs b/tests/codegen-llvm/external-no-mangle-fns.rs
new file mode 100644
index 00000000000..35ab0fd7909
--- /dev/null
+++ b/tests/codegen-llvm/external-no-mangle-fns.rs
@@ -0,0 +1,75 @@
+//@ compile-flags: -C no-prepopulate-passes
+// `#[no_mangle]`d functions always have external linkage, i.e., no `internal` in their `define`s
+
+#![crate_type = "lib"]
+#![no_std]
+
+// CHECK: define{{( dso_local)?}} void @a()
+#[no_mangle]
+fn a() {}
+
+// CHECK: define{{( dso_local)?}} void @b()
+#[no_mangle]
+pub fn b() {}
+
+mod private {
+    // CHECK: define{{( dso_local)?}} void @c()
+    #[no_mangle]
+    fn c() {}
+
+    // CHECK: define{{( dso_local)?}} void @d()
+    #[no_mangle]
+    pub fn d() {}
+}
+
+const HIDDEN: () = {
+    // CHECK: define{{( dso_local)?}} void @e()
+    #[no_mangle]
+    fn e() {}
+
+    // CHECK: define{{( dso_local)?}} void @f()
+    #[no_mangle]
+    pub fn f() {}
+};
+
+// The surrounding item should not accidentally become external
+// CHECK-LABEL: ; external_no_mangle_fns::x
+// CHECK-NEXT: ; Function Attrs:
+// CHECK-NEXT: define internal
+#[inline(never)]
+fn x() {
+    // CHECK: define{{( dso_local)?}} void @g()
+    #[no_mangle]
+    fn g() {
+        x();
+    }
+
+    // CHECK: define{{( dso_local)?}} void @h()
+    #[no_mangle]
+    pub fn h() {}
+
+    // side effect to keep `x` around
+    unsafe {
+        core::ptr::read_volatile(&42);
+    }
+}
+
+// CHECK: define{{( dso_local)?}} void @i()
+#[no_mangle]
+#[inline]
+fn i() {}
+
+// CHECK: define{{( dso_local)?}} void @j()
+#[no_mangle]
+#[inline]
+pub fn j() {}
+
+// CHECK: define{{( dso_local)?}} void @k()
+#[no_mangle]
+#[inline(always)]
+fn k() {}
+
+// CHECK: define{{( dso_local)?}} void @l()
+#[no_mangle]
+#[inline(always)]
+pub fn l() {}
diff --git a/tests/codegen-llvm/external-no-mangle-statics.rs b/tests/codegen-llvm/external-no-mangle-statics.rs
new file mode 100644
index 00000000000..49f42ee977d
--- /dev/null
+++ b/tests/codegen-llvm/external-no-mangle-statics.rs
@@ -0,0 +1,77 @@
+//@ revisions: lib staticlib
+//@ ignore-emscripten default visibility is hidden
+//@ compile-flags: -Copt-level=3
+//@ [lib] compile-flags: --crate-type lib
+//@ [staticlib] compile-flags: --crate-type staticlib
+// `#[no_mangle]`d static variables always have external linkage, i.e., no `internal` in their
+// definitions
+
+// CHECK-DAG: @A = {{(dso_local )?}}local_unnamed_addr constant
+#[no_mangle]
+static A: u8 = 0;
+
+// CHECK-DAG: @B = {{(dso_local )?}}local_unnamed_addr global
+#[no_mangle]
+static mut B: u8 = 0;
+
+// CHECK-DAG: @C = {{(dso_local )?}}local_unnamed_addr constant
+#[no_mangle]
+pub static C: u8 = 0;
+
+// CHECK-DAG: @D = {{(dso_local )?}}local_unnamed_addr global
+#[no_mangle]
+pub static mut D: u8 = 0;
+
+mod private {
+    // CHECK-DAG: @E = {{(dso_local )?}}local_unnamed_addr constant
+    #[no_mangle]
+    static E: u8 = 0;
+
+    // CHECK-DAG: @F = {{(dso_local )?}}local_unnamed_addr global
+    #[no_mangle]
+    static mut F: u8 = 0;
+
+    // CHECK-DAG: @G = {{(dso_local )?}}local_unnamed_addr constant
+    #[no_mangle]
+    pub static G: u8 = 0;
+
+    // CHECK-DAG: @H = {{(dso_local )?}}local_unnamed_addr global
+    #[no_mangle]
+    pub static mut H: u8 = 0;
+}
+
+const HIDDEN: () = {
+    // CHECK-DAG: @I = {{(dso_local )?}}local_unnamed_addr constant
+    #[no_mangle]
+    static I: u8 = 0;
+
+    // CHECK-DAG: @J = {{(dso_local )?}}local_unnamed_addr global
+    #[no_mangle]
+    static mut J: u8 = 0;
+
+    // CHECK-DAG: @K = {{(dso_local )?}}local_unnamed_addr constant
+    #[no_mangle]
+    pub static K: u8 = 0;
+
+    // CHECK-DAG: @L = {{(dso_local )?}}local_unnamed_addr global
+    #[no_mangle]
+    pub static mut L: u8 = 0;
+};
+
+fn x() {
+    // CHECK-DAG: @M = {{(dso_local )?}}local_unnamed_addr constant
+    #[no_mangle]
+    static M: fn() = x;
+
+    // CHECK-DAG: @N = {{(dso_local )?}}local_unnamed_addr global
+    #[no_mangle]
+    static mut N: u8 = 0;
+
+    // CHECK-DAG: @O = {{(dso_local )?}}local_unnamed_addr constant
+    #[no_mangle]
+    pub static O: u8 = 0;
+
+    // CHECK-DAG: @P = {{(dso_local )?}}local_unnamed_addr global
+    #[no_mangle]
+    pub static mut P: u8 = 0;
+}
diff --git a/tests/codegen-llvm/f128-wasm32-callconv.rs b/tests/codegen-llvm/f128-wasm32-callconv.rs
new file mode 100644
index 00000000000..7dccbda18f1
--- /dev/null
+++ b/tests/codegen-llvm/f128-wasm32-callconv.rs
@@ -0,0 +1,49 @@
+//! Verify that Rust implements the expected calling convention for `f128`
+
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 --target wasm32-wasip1
+//@ needs-llvm-components: webassembly
+
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+#![feature(no_core, lang_items, f128)]
+
+extern crate minicore;
+
+extern "C" {
+    fn extern_call(arg0: f128);
+    fn extern_ret() -> f128;
+}
+
+#[no_mangle]
+pub extern "C" fn pass(_arg0: u32, arg1: f128) {
+    // CHECK-LABEL: @pass(
+    // an f128 is passed via registers
+    // CHECK-SAME: fp128 noundef %arg1
+    // CHECK: call void @extern_call
+    unsafe { extern_call(arg1) };
+}
+
+// Check that we produce the correct return ABI
+#[no_mangle]
+pub extern "C" fn ret(_arg0: u32, arg1: f128) -> f128 {
+    // CHECK-LABEL: @ret(
+    // but an f128 is returned via the stack
+    // CHECK-SAME: sret
+    // CHECK: store fp128 %arg1
+    // CHECK-NEXT: ret void
+    arg1
+}
+
+// Check that we consume the correct return ABI
+#[no_mangle]
+pub extern "C" fn forward(dst: *mut f128) {
+    // CHECK-LABEL: @forward
+    // CHECK-SAME: ptr{{.*}} %dst)
+    // without optimizatons, an intermediate alloca is used
+    // CHECK: call void @extern_ret
+    // CHECK: store fp128
+    // CHECK: ret void
+    unsafe { *dst = extern_ret() };
+}
diff --git a/tests/codegen-llvm/fastcall-inreg.rs b/tests/codegen-llvm/fastcall-inreg.rs
new file mode 100644
index 00000000000..066943d6e7e
--- /dev/null
+++ b/tests/codegen-llvm/fastcall-inreg.rs
@@ -0,0 +1,40 @@
+// Checks if the "fastcall" calling convention marks function arguments
+// as "inreg" like the C/C++ compilers for the platforms.
+// x86 only.
+
+//@ add-core-stubs
+//@ compile-flags: --target i686-unknown-linux-gnu -Cno-prepopulate-passes -Copt-level=3
+//@ needs-llvm-components: x86
+
+#![crate_type = "lib"]
+#![no_core]
+#![feature(no_core, lang_items)]
+
+extern crate minicore;
+use minicore::*;
+
+pub mod tests {
+    // CHECK: @f1(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
+    #[no_mangle]
+    pub extern "fastcall" fn f1(_: i32, _: i32, _: i32) {}
+
+    // CHECK: @f2(ptr inreg noundef %_1, ptr inreg noundef %_2, ptr noundef %_3)
+    #[no_mangle]
+    pub extern "fastcall" fn f2(_: *const i32, _: *const i32, _: *const i32) {}
+
+    // CHECK: @f3(float noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3, i32 noundef %_4)
+    #[no_mangle]
+    pub extern "fastcall" fn f3(_: f32, _: i32, _: i32, _: i32) {}
+
+    // CHECK: @f4(i32 inreg noundef %_1, float noundef %_2, i32 inreg noundef %_3, i32 noundef %_4)
+    #[no_mangle]
+    pub extern "fastcall" fn f4(_: i32, _: f32, _: i32, _: i32) {}
+
+    // CHECK: @f5(i64 noundef %_1, i32 noundef %_2)
+    #[no_mangle]
+    pub extern "fastcall" fn f5(_: i64, _: i32) {}
+
+    // CHECK: @f6(i1 inreg noundef zeroext %_1, i32 inreg noundef %_2, i32 noundef %_3)
+    #[no_mangle]
+    pub extern "fastcall" fn f6(_: bool, _: i32, _: i32) {}
+}
diff --git a/tests/codegen-llvm/fatptr.rs b/tests/codegen-llvm/fatptr.rs
new file mode 100644
index 00000000000..041807202b8
--- /dev/null
+++ b/tests/codegen-llvm/fatptr.rs
@@ -0,0 +1,12 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+pub trait T {}
+
+// CHECK-LABEL: @copy_fat_ptr
+#[no_mangle]
+pub fn copy_fat_ptr(x: &T) {
+    // CHECK-NOT: extractvalue
+    let x2 = x;
+}
diff --git a/tests/codegen-llvm/fewer-names.rs b/tests/codegen-llvm/fewer-names.rs
new file mode 100644
index 00000000000..ff7a916b619
--- /dev/null
+++ b/tests/codegen-llvm/fewer-names.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: -Coverflow-checks=no -Copt-level=3
+//@ revisions: YES NO
+//@ [YES]compile-flags: -Zfewer-names=yes
+//@ [NO] compile-flags: -Zfewer-names=no
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn sum(x: u32, y: u32) -> u32 {
+    // YES-LABEL: define{{.*}}i32 @sum(i32{{.*}} %0, i32{{.*}} %1)
+    // YES-NEXT:    %3 = add i32 %1, %0
+    // YES-NEXT:    ret i32 %3
+
+    // NO-LABEL: define{{.*}}i32 @sum(i32{{.*}} %x, i32{{.*}} %y)
+    // NO-NEXT:  start:
+    // NO-NEXT:    %z = add i32 %y, %x
+    // NO-NEXT:    ret i32 %z
+    let z = x + y;
+    z
+}
diff --git a/tests/codegen-llvm/fixed-x18.rs b/tests/codegen-llvm/fixed-x18.rs
new file mode 100644
index 00000000000..a5767cfa456
--- /dev/null
+++ b/tests/codegen-llvm/fixed-x18.rs
@@ -0,0 +1,23 @@
+// Test that the `reserve-x18` target feature is (not) emitted when
+// the `-Zfixed-x18` flag is (not) set.
+
+//@ add-core-stubs
+//@ revisions: unset set
+//@ needs-llvm-components: aarch64
+//@ compile-flags: --target aarch64-unknown-none
+//@ [set] compile-flags: -Zfixed-x18
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+pub fn foo() {
+    // CHECK: @foo() unnamed_addr #0
+
+    // unset-NOT: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+reserve-x18{{.*}} }
+    // set: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+reserve-x18{{.*}} }
+}
diff --git a/tests/codegen-llvm/float/algebraic.rs b/tests/codegen-llvm/float/algebraic.rs
new file mode 100644
index 00000000000..818a4bcdfe3
--- /dev/null
+++ b/tests/codegen-llvm/float/algebraic.rs
@@ -0,0 +1,149 @@
+// Verify that algebraic intrinsics generate the correct LLVM calls
+
+// Ensure operations get inlined
+//@ compile-flags: -Copt-level=1
+
+#![crate_type = "lib"]
+#![feature(f16)]
+#![feature(f128)]
+#![feature(float_algebraic)]
+
+// CHECK-LABEL: @f16_algebraic_add
+#[no_mangle]
+pub fn f16_algebraic_add(a: f16, b: f16) -> f16 {
+    // CHECK: fadd reassoc nsz arcp contract half %{{.+}}, %{{.+}}
+    a.algebraic_add(b)
+}
+
+// CHECK-LABEL: @f16_algebraic_sub
+#[no_mangle]
+pub fn f16_algebraic_sub(a: f16, b: f16) -> f16 {
+    // CHECK: fsub reassoc nsz arcp contract half %{{.+}}, %{{.+}}
+    a.algebraic_sub(b)
+}
+
+// CHECK-LABEL: @f16_algebraic_mul
+#[no_mangle]
+pub fn f16_algebraic_mul(a: f16, b: f16) -> f16 {
+    // CHECK: fmul reassoc nsz arcp contract half %{{.+}}, %{{.+}}
+    a.algebraic_mul(b)
+}
+
+// CHECK-LABEL: @f16_algebraic_div
+#[no_mangle]
+pub fn f16_algebraic_div(a: f16, b: f16) -> f16 {
+    // CHECK: fdiv reassoc nsz arcp contract half %{{.+}}, %{{.+}}
+    a.algebraic_div(b)
+}
+
+// CHECK-LABEL: @f16_algebraic_rem
+#[no_mangle]
+pub fn f16_algebraic_rem(a: f16, b: f16) -> f16 {
+    // CHECK: frem reassoc nsz arcp contract half %{{.+}}, %{{.+}}
+    a.algebraic_rem(b)
+}
+
+// CHECK-LABEL: @f32_algebraic_add
+#[no_mangle]
+pub fn f32_algebraic_add(a: f32, b: f32) -> f32 {
+    // CHECK: fadd reassoc nsz arcp contract float %{{.+}}, %{{.+}}
+    a.algebraic_add(b)
+}
+
+// CHECK-LABEL: @f32_algebraic_sub
+#[no_mangle]
+pub fn f32_algebraic_sub(a: f32, b: f32) -> f32 {
+    // CHECK: fsub reassoc nsz arcp contract float %{{.+}}, %{{.+}}
+    a.algebraic_sub(b)
+}
+
+// CHECK-LABEL: @f32_algebraic_mul
+#[no_mangle]
+pub fn f32_algebraic_mul(a: f32, b: f32) -> f32 {
+    // CHECK: fmul reassoc nsz arcp contract float %{{.+}}, %{{.+}}
+    a.algebraic_mul(b)
+}
+
+// CHECK-LABEL: @f32_algebraic_div
+#[no_mangle]
+pub fn f32_algebraic_div(a: f32, b: f32) -> f32 {
+    // CHECK: fdiv reassoc nsz arcp contract float %{{.+}}, %{{.+}}
+    a.algebraic_div(b)
+}
+
+// CHECK-LABEL: @f32_algebraic_rem
+#[no_mangle]
+pub fn f32_algebraic_rem(a: f32, b: f32) -> f32 {
+    // CHECK: frem reassoc nsz arcp contract float %{{.+}}, %{{.+}}
+    a.algebraic_rem(b)
+}
+
+// CHECK-LABEL: @f64_algebraic_add
+#[no_mangle]
+pub fn f64_algebraic_add(a: f64, b: f64) -> f64 {
+    // CHECK: fadd reassoc nsz arcp contract double %{{.+}}, %{{.+}}
+    a.algebraic_add(b)
+}
+
+// CHECK-LABEL: @f64_algebraic_sub
+#[no_mangle]
+pub fn f64_algebraic_sub(a: f64, b: f64) -> f64 {
+    // CHECK: fsub reassoc nsz arcp contract double %{{.+}}, %{{.+}}
+    a.algebraic_sub(b)
+}
+
+// CHECK-LABEL: @f64_algebraic_mul
+#[no_mangle]
+pub fn f64_algebraic_mul(a: f64, b: f64) -> f64 {
+    // CHECK: fmul reassoc nsz arcp contract double %{{.+}}, %{{.+}}
+    a.algebraic_mul(b)
+}
+
+// CHECK-LABEL: @f64_algebraic_div
+#[no_mangle]
+pub fn f64_algebraic_div(a: f64, b: f64) -> f64 {
+    // CHECK: fdiv reassoc nsz arcp contract double %{{.+}}, %{{.+}}
+    a.algebraic_div(b)
+}
+
+// CHECK-LABEL: @f64_algebraic_rem
+#[no_mangle]
+pub fn f64_algebraic_rem(a: f64, b: f64) -> f64 {
+    // CHECK: frem reassoc nsz arcp contract double %{{.+}}, %{{.+}}
+    a.algebraic_rem(b)
+}
+
+// CHECK-LABEL: @f128_algebraic_add
+#[no_mangle]
+pub fn f128_algebraic_add(a: f128, b: f128) -> f128 {
+    // CHECK: fadd reassoc nsz arcp contract fp128 %{{.+}}, %{{.+}}
+    a.algebraic_add(b)
+}
+
+// CHECK-LABEL: @f128_algebraic_sub
+#[no_mangle]
+pub fn f128_algebraic_sub(a: f128, b: f128) -> f128 {
+    // CHECK: fsub reassoc nsz arcp contract fp128 %{{.+}}, %{{.+}}
+    a.algebraic_sub(b)
+}
+
+// CHECK-LABEL: @f128_algebraic_mul
+#[no_mangle]
+pub fn f128_algebraic_mul(a: f128, b: f128) -> f128 {
+    // CHECK: fmul reassoc nsz arcp contract fp128 %{{.+}}, %{{.+}}
+    a.algebraic_mul(b)
+}
+
+// CHECK-LABEL: @f128_algebraic_div
+#[no_mangle]
+pub fn f128_algebraic_div(a: f128, b: f128) -> f128 {
+    // CHECK: fdiv reassoc nsz arcp contract fp128 %{{.+}}, %{{.+}}
+    a.algebraic_div(b)
+}
+
+// CHECK-LABEL: @f128_algebraic_rem
+#[no_mangle]
+pub fn f128_algebraic_rem(a: f128, b: f128) -> f128 {
+    // CHECK: frem reassoc nsz arcp contract fp128 %{{.+}}, %{{.+}}
+    a.algebraic_rem(b)
+}
diff --git a/tests/codegen-llvm/float/f128.rs b/tests/codegen-llvm/float/f128.rs
new file mode 100644
index 00000000000..d87bab1172a
--- /dev/null
+++ b/tests/codegen-llvm/float/f128.rs
@@ -0,0 +1,441 @@
+// 32-bit x86 returns float types differently to avoid the x87 stack.
+// 32-bit systems will return 128bit values using a return area pointer.
+// Emscripten aligns f128 to 8 bytes, not 16.
+//@ revisions: x86-sse x86-nosse bit32 bit64 emscripten
+//@[x86-sse] only-x86
+//@[x86-sse] only-rustc_abi-x86-sse2
+//@[x86-nosse] only-x86
+//@[x86-nosse] ignore-rustc_abi-x86-sse2
+//@[bit32] ignore-x86
+//@[bit32] ignore-emscripten
+//@[bit32] only-32bit
+//@[bit64] ignore-x86
+//@[bit64] ignore-emscripten
+//@[bit64] only-64bit
+//@[emscripten] only-emscripten
+
+// Verify that our intrinsics generate the correct LLVM calls for f128
+
+#![crate_type = "lib"]
+#![feature(f128)]
+#![feature(f16)]
+#![feature(core_intrinsics)]
+
+// CHECK-LABEL: i1 @f128_eq(
+#[no_mangle]
+pub fn f128_eq(a: f128, b: f128) -> bool {
+    // CHECK: fcmp oeq fp128 %{{.+}}, %{{.+}}
+    a == b
+}
+
+// CHECK-LABEL: i1 @f128_ne(
+#[no_mangle]
+pub fn f128_ne(a: f128, b: f128) -> bool {
+    // CHECK: fcmp une fp128 %{{.+}}, %{{.+}}
+    a != b
+}
+
+// CHECK-LABEL: i1 @f128_gt(
+#[no_mangle]
+pub fn f128_gt(a: f128, b: f128) -> bool {
+    // CHECK: fcmp ogt fp128 %{{.+}}, %{{.+}}
+    a > b
+}
+
+// CHECK-LABEL: i1 @f128_ge(
+#[no_mangle]
+pub fn f128_ge(a: f128, b: f128) -> bool {
+    // CHECK: fcmp oge fp128 %{{.+}}, %{{.+}}
+    a >= b
+}
+
+// CHECK-LABEL: i1 @f128_lt(
+#[no_mangle]
+pub fn f128_lt(a: f128, b: f128) -> bool {
+    // CHECK: fcmp olt fp128 %{{.+}}, %{{.+}}
+    a < b
+}
+
+// CHECK-LABEL: i1 @f128_le(
+#[no_mangle]
+pub fn f128_le(a: f128, b: f128) -> bool {
+    // CHECK: fcmp ole fp128 %{{.+}}, %{{.+}}
+    a <= b
+}
+
+// x86-nosse-LABEL: void @f128_neg({{.*}}sret([16 x i8])
+// x86-sse-LABEL: <16 x i8> @f128_neg(fp128
+// bit32-LABEL: void @f128_neg({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @f128_neg(
+// emscripten-LABEL: void @f128_neg({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f128_neg(a: f128) -> f128 {
+    // CHECK: fneg fp128
+    -a
+}
+
+// x86-nosse-LABEL: void @f128_add({{.*}}sret([16 x i8])
+// x86-sse-LABEL: <16 x i8> @f128_add(fp128
+// bit32-LABEL: void @f128_add({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @f128_add(
+// emscripten-LABEL: void @f128_add({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f128_add(a: f128, b: f128) -> f128 {
+    // CHECK: fadd fp128 %{{.+}}, %{{.+}}
+    a + b
+}
+
+// x86-nosse-LABEL: void @f128_sub({{.*}}sret([16 x i8])
+// x86-sse-LABEL: <16 x i8> @f128_sub(fp128
+// bit32-LABEL: void @f128_sub({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @f128_sub(
+// emscripten-LABEL: void @f128_sub({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f128_sub(a: f128, b: f128) -> f128 {
+    // CHECK: fsub fp128 %{{.+}}, %{{.+}}
+    a - b
+}
+
+// x86-nosse-LABEL: void @f128_mul({{.*}}sret([16 x i8])
+// x86-sse-LABEL: <16 x i8> @f128_mul(fp128
+// bit32-LABEL: void @f128_mul({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @f128_mul(
+// emscripten-LABEL: void @f128_mul({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f128_mul(a: f128, b: f128) -> f128 {
+    // CHECK: fmul fp128 %{{.+}}, %{{.+}}
+    a * b
+}
+
+// x86-nosse-LABEL: void @f128_div({{.*}}sret([16 x i8])
+// x86-sse-LABEL: <16 x i8> @f128_div(fp128
+// bit32-LABEL: void @f128_div({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @f128_div(
+// emscripten-LABEL: void @f128_div({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f128_div(a: f128, b: f128) -> f128 {
+    // CHECK: fdiv fp128 %{{.+}}, %{{.+}}
+    a / b
+}
+
+// x86-nosse-LABEL: void @f128_rem({{.*}}sret([16 x i8])
+// x86-sse-LABEL: <16 x i8> @f128_rem(fp128
+// bit32-LABEL: void @f128_rem({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @f128_rem(
+// emscripten-LABEL: void @f128_rem({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f128_rem(a: f128, b: f128) -> f128 {
+    // CHECK: frem fp128 %{{.+}}, %{{.+}}
+    a % b
+}
+
+// CHECK-LABEL: void @f128_add_assign(
+#[no_mangle]
+pub fn f128_add_assign(a: &mut f128, b: f128) {
+    // CHECK: fadd fp128 %{{.+}}, %{{.+}}
+    // CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
+    *a += b;
+}
+
+// CHECK-LABEL: void @f128_sub_assign(
+#[no_mangle]
+pub fn f128_sub_assign(a: &mut f128, b: f128) {
+    // CHECK: fsub fp128 %{{.+}}, %{{.+}}
+    // CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
+    *a -= b;
+}
+
+// CHECK-LABEL: void @f128_mul_assign(
+#[no_mangle]
+pub fn f128_mul_assign(a: &mut f128, b: f128) {
+    // CHECK: fmul fp128 %{{.+}}, %{{.+}}
+    // CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
+    *a *= b
+}
+
+// CHECK-LABEL: void @f128_div_assign(
+#[no_mangle]
+pub fn f128_div_assign(a: &mut f128, b: f128) {
+    // CHECK: fdiv fp128 %{{.+}}, %{{.+}}
+    // CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
+    *a /= b
+}
+
+// CHECK-LABEL: void @f128_rem_assign(
+#[no_mangle]
+pub fn f128_rem_assign(a: &mut f128, b: f128) {
+    // CHECK: frem fp128 %{{.+}}, %{{.+}}
+    // CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
+    *a %= b
+}
+
+/* float to float conversions */
+
+// x86-sse-LABEL: <2 x i8> @f128_as_f16(
+// x86-nosse-LABEL: i16 @f128_as_f16(
+// bits32-LABEL: half @f128_as_f16(
+// bits64-LABEL: half @f128_as_f16(
+#[no_mangle]
+pub fn f128_as_f16(a: f128) -> f16 {
+    // CHECK: fptrunc fp128 %{{.+}} to half
+    a as f16
+}
+
+// x86-sse-LABEL: <4 x i8> @f128_as_f32(
+// x86-nosse-LABEL: i32 @f128_as_f32(
+// bit32-LABEL: float @f128_as_f32(
+// bit64-LABEL: float @f128_as_f32(
+// emscripten-LABEL: float @f128_as_f32(
+#[no_mangle]
+pub fn f128_as_f32(a: f128) -> f32 {
+    // CHECK: fptrunc fp128 %{{.+}} to float
+    a as f32
+}
+
+// x86-sse-LABEL: <8 x i8> @f128_as_f64(
+// x86-nosse-LABEL: void @f128_as_f64({{.*}}sret([8 x i8])
+// bit32-LABEL: double @f128_as_f64(
+// bit64-LABEL: double @f128_as_f64(
+// emscripten-LABEL: double @f128_as_f64(
+#[no_mangle]
+pub fn f128_as_f64(a: f128) -> f64 {
+    // CHECK: fptrunc fp128 %{{.+}} to double
+    a as f64
+}
+
+// x86-sse-LABEL: <16 x i8> @f128_as_self(
+// x86-nosse-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
+// bit32-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @f128_as_self(
+// emscripten-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f128_as_self(a: f128) -> f128 {
+    // x86: store fp128 %a, ptr %_0, align 16
+    // bit32: store fp128 %a, ptr %_0, align 16
+    // bit64: ret fp128 %{{.+}}
+    // emscripten: store fp128 %a, ptr %_0, align 8
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @f16_as_f128(
+// x86-nosse-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @f16_as_f128(
+// emscripten-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f16_as_f128(a: f16) -> f128 {
+    // CHECK: fpext half %{{.+}} to fp128
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @f32_as_f128(
+// x86-nosse-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @f32_as_f128(
+// emscripten-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f32_as_f128(a: f32) -> f128 {
+    // CHECK: fpext float %{{.+}} to fp128
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @f64_as_f128(
+// x86-nosse-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @f64_as_f128(
+// emscripten-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f64_as_f128(a: f64) -> f128 {
+    // CHECK: fpext double %{{.+}} to fp128
+    a as f128
+}
+
+/* float to int conversions */
+
+// CHECK-LABEL: i8 @f128_as_u8(
+#[no_mangle]
+pub fn f128_as_u8(a: f128) -> u8 {
+    // CHECK: call i8 @llvm.fptoui.sat.i8.f128(fp128 %{{.+}})
+    a as u8
+}
+
+#[no_mangle]
+pub fn f128_as_u16(a: f128) -> u16 {
+    // CHECK: call i16 @llvm.fptoui.sat.i16.f128(fp128 %{{.+}})
+    a as u16
+}
+
+// CHECK-LABEL: i32 @f128_as_u32(
+#[no_mangle]
+pub fn f128_as_u32(a: f128) -> u32 {
+    // CHECK: call i32 @llvm.fptoui.sat.i32.f128(fp128 %{{.+}})
+    a as u32
+}
+
+// CHECK-LABEL: i64 @f128_as_u64(
+#[no_mangle]
+pub fn f128_as_u64(a: f128) -> u64 {
+    // CHECK: call i64 @llvm.fptoui.sat.i64.f128(fp128 %{{.+}})
+    a as u64
+}
+
+// x86-sse-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
+// x86-nosse-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
+// bit64-LABEL: i128 @f128_as_u128(
+// emscripten-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f128_as_u128(a: f128) -> u128 {
+    // CHECK: call i128 @llvm.fptoui.sat.i128.f128(fp128 %{{.+}})
+    a as u128
+}
+
+// CHECK-LABEL: i8 @f128_as_i8(
+#[no_mangle]
+pub fn f128_as_i8(a: f128) -> i8 {
+    // CHECK: call i8 @llvm.fptosi.sat.i8.f128(fp128 %{{.+}})
+    a as i8
+}
+
+// CHECK-LABEL: i16 @f128_as_i16(
+#[no_mangle]
+pub fn f128_as_i16(a: f128) -> i16 {
+    // CHECK: call i16 @llvm.fptosi.sat.i16.f128(fp128 %{{.+}})
+    a as i16
+}
+// CHECK-LABEL: i32 @f128_as_i32(
+#[no_mangle]
+pub fn f128_as_i32(a: f128) -> i32 {
+    // CHECK: call i32 @llvm.fptosi.sat.i32.f128(fp128 %{{.+}})
+    a as i32
+}
+
+// CHECK-LABEL: i64 @f128_as_i64(
+#[no_mangle]
+pub fn f128_as_i64(a: f128) -> i64 {
+    // CHECK: call i64 @llvm.fptosi.sat.i64.f128(fp128 %{{.+}})
+    a as i64
+}
+
+// x86-sse-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
+// x86-nosse-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
+// bit64-LABEL: i128 @f128_as_i128(
+// emscripten-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn f128_as_i128(a: f128) -> i128 {
+    // CHECK: call i128 @llvm.fptosi.sat.i128.f128(fp128 %{{.+}})
+    a as i128
+}
+
+/* int to float conversions */
+
+// x86-sse-LABEL: <16 x i8> @u8_as_f128(
+// x86-nosse-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @u8_as_f128(
+// emscripten-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn u8_as_f128(a: u8) -> f128 {
+    // CHECK: uitofp i8 %{{.+}} to fp128
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @u16_as_f128(
+// x86-nosse-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @u16_as_f128(
+// emscripten-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn u16_as_f128(a: u16) -> f128 {
+    // CHECK: uitofp i16 %{{.+}} to fp128
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @u32_as_f128(
+// x86-nosse-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @u32_as_f128(
+// emscripten-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn u32_as_f128(a: u32) -> f128 {
+    // CHECK: uitofp i32 %{{.+}} to fp128
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @u64_as_f128(
+// x86-nosse-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @u64_as_f128(
+// emscripten-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn u64_as_f128(a: u64) -> f128 {
+    // CHECK: uitofp i64 %{{.+}} to fp128
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @u128_as_f128(
+// x86-nosse-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @u128_as_f128(
+// emscripten-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn u128_as_f128(a: u128) -> f128 {
+    // CHECK: uitofp i128 %{{.+}} to fp128
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @i8_as_f128(
+// x86-nosse-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @i8_as_f128(
+// emscripten-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn i8_as_f128(a: i8) -> f128 {
+    // CHECK: sitofp i8 %{{.+}} to fp128
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @i16_as_f128(
+// x86-nosse-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @i16_as_f128(
+// emscripten-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn i16_as_f128(a: i16) -> f128 {
+    // CHECK: sitofp i16 %{{.+}} to fp128
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @i32_as_f128(
+// x86-nosse-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @i32_as_f128(
+// emscripten-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn i32_as_f128(a: i32) -> f128 {
+    // CHECK: sitofp i32 %{{.+}} to fp128
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @i64_as_f128(
+// x86-nosse-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @i64_as_f128(
+// emscripten-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn i64_as_f128(a: i64) -> f128 {
+    // CHECK: sitofp i64 %{{.+}} to fp128
+    a as f128
+}
+
+// x86-sse-LABEL: <16 x i8> @i128_as_f128(
+// x86-nosse-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @i128_as_f128(
+// emscripten-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
+#[no_mangle]
+pub fn i128_as_f128(a: i128) -> f128 {
+    // CHECK: sitofp i128 %{{.+}} to fp128
+    a as f128
+}
diff --git a/tests/codegen-llvm/float/f16-f128-inline.rs b/tests/codegen-llvm/float/f16-f128-inline.rs
new file mode 100644
index 00000000000..aa2c38c209e
--- /dev/null
+++ b/tests/codegen-llvm/float/f16-f128-inline.rs
@@ -0,0 +1,29 @@
+//@ revisions: default nopt
+//@[nopt] compile-flags: -Copt-level=0 -Zcross-crate-inline-threshold=never -Zmir-opt-level=0 -Cno-prepopulate-passes
+
+// Ensure that functions using `f16` and `f128` are always inlined to avoid crashes
+// when the backend does not support these types.
+
+#![crate_type = "lib"]
+#![feature(f128)]
+#![feature(f16)]
+
+pub fn f16_arg(_a: f16) {
+    // CHECK-NOT: f16_arg
+    todo!()
+}
+
+pub fn f16_ret() -> f16 {
+    // CHECK-NOT: f16_ret
+    todo!()
+}
+
+pub fn f128_arg(_a: f128) {
+    // CHECK-NOT: f128_arg
+    todo!()
+}
+
+pub fn f128_ret() -> f128 {
+    // CHECK-NOT: f128_ret
+    todo!()
+}
diff --git a/tests/codegen-llvm/float/f16.rs b/tests/codegen-llvm/float/f16.rs
new file mode 100644
index 00000000000..0c40606ad8a
--- /dev/null
+++ b/tests/codegen-llvm/float/f16.rs
@@ -0,0 +1,364 @@
+// 32-bit x86 returns float types differently to avoid the x87 stack.
+// 32-bit systems will return 128bit values using a return area pointer.
+//@ revisions: x86-sse x86-nosse bit32 bit64
+//@[x86-sse] only-x86
+//@[x86-sse] only-rustc_abi-x86-sse2
+//@[x86-nosse] only-x86
+//@[x86-nosse] ignore-rustc_abi-x86-sse2
+//@[bit32] ignore-x86
+//@[bit32] only-32bit
+//@[bit64] ignore-x86
+//@[bit64] only-64bit
+
+// Verify that our intrinsics generate the correct LLVM calls for f16
+
+#![crate_type = "lib"]
+#![feature(f128)]
+#![feature(f16)]
+#![feature(core_intrinsics)]
+
+/* arithmetic */
+
+// CHECK-LABEL: i1 @f16_eq(
+#[no_mangle]
+pub fn f16_eq(a: f16, b: f16) -> bool {
+    // CHECK: fcmp oeq half %{{.+}}, %{{.+}}
+    a == b
+}
+
+// CHECK-LABEL: i1 @f16_ne(
+#[no_mangle]
+pub fn f16_ne(a: f16, b: f16) -> bool {
+    // CHECK: fcmp une half %{{.+}}, %{{.+}}
+    a != b
+}
+
+// CHECK-LABEL: i1 @f16_gt(
+#[no_mangle]
+pub fn f16_gt(a: f16, b: f16) -> bool {
+    // CHECK: fcmp ogt half %{{.+}}, %{{.+}}
+    a > b
+}
+
+// CHECK-LABEL: i1 @f16_ge(
+#[no_mangle]
+pub fn f16_ge(a: f16, b: f16) -> bool {
+    // CHECK: fcmp oge half %{{.+}}, %{{.+}}
+    a >= b
+}
+
+// CHECK-LABEL: i1 @f16_lt(
+#[no_mangle]
+pub fn f16_lt(a: f16, b: f16) -> bool {
+    // CHECK: fcmp olt half %{{.+}}, %{{.+}}
+    a < b
+}
+
+// CHECK-LABEL: i1 @f16_le(
+#[no_mangle]
+pub fn f16_le(a: f16, b: f16) -> bool {
+    // CHECK: fcmp ole half %{{.+}}, %{{.+}}
+    a <= b
+}
+
+// This is where we check the argument and return ABI for f16.
+// bit32-LABEL: half @f16_neg(half
+// bit64-LABEL: half @f16_neg(half
+// x86-sse-LABEL: <2 x i8> @f16_neg(half
+// x86-nosse-LABEL: i16 @f16_neg(half
+#[no_mangle]
+pub fn f16_neg(a: f16) -> f16 {
+    // CHECK: fneg half %{{.+}}
+    -a
+}
+
+// CHECK-LABEL: @f16_add
+#[no_mangle]
+pub fn f16_add(a: f16, b: f16) -> f16 {
+    // CHECK: fadd half %{{.+}}, %{{.+}}
+    a + b
+}
+
+// CHECK-LABEL: @f16_sub
+#[no_mangle]
+pub fn f16_sub(a: f16, b: f16) -> f16 {
+    // CHECK: fsub half %{{.+}}, %{{.+}}
+    a - b
+}
+
+// CHECK-LABEL: @f16_mul
+#[no_mangle]
+pub fn f16_mul(a: f16, b: f16) -> f16 {
+    // CHECK: fmul half %{{.+}}, %{{.+}}
+    a * b
+}
+
+// CHECK-LABEL: @f16_div
+#[no_mangle]
+pub fn f16_div(a: f16, b: f16) -> f16 {
+    // CHECK: fdiv half %{{.+}}, %{{.+}}
+    a / b
+}
+
+// CHECK-LABEL: @f16_rem
+#[no_mangle]
+pub fn f16_rem(a: f16, b: f16) -> f16 {
+    // CHECK: frem half %{{.+}}, %{{.+}}
+    a % b
+}
+
+// CHECK-LABEL: void @f16_add_assign(
+#[no_mangle]
+pub fn f16_add_assign(a: &mut f16, b: f16) {
+    // CHECK: fadd half %{{.+}}, %{{.+}}
+    // CHECK-NEXT: store half %{{.+}}, ptr %{{.+}}
+    *a += b;
+}
+
+// CHECK-LABEL: void @f16_sub_assign(
+#[no_mangle]
+pub fn f16_sub_assign(a: &mut f16, b: f16) {
+    // CHECK: fsub half %{{.+}}, %{{.+}}
+    // CHECK-NEXT: store half %{{.+}}, ptr %{{.+}}
+    *a -= b;
+}
+
+// CHECK-LABEL: void @f16_mul_assign(
+#[no_mangle]
+pub fn f16_mul_assign(a: &mut f16, b: f16) {
+    // CHECK: fmul half %{{.+}}, %{{.+}}
+    // CHECK-NEXT: store half %{{.+}}, ptr %{{.+}}
+    *a *= b;
+}
+
+// CHECK-LABEL: void @f16_div_assign(
+#[no_mangle]
+pub fn f16_div_assign(a: &mut f16, b: f16) {
+    // CHECK: fdiv half %{{.+}}, %{{.+}}
+    // CHECK-NEXT: store half %{{.+}}, ptr %{{.+}}
+    *a /= b;
+}
+
+// CHECK-LABEL: void @f16_rem_assign(
+#[no_mangle]
+pub fn f16_rem_assign(a: &mut f16, b: f16) {
+    // CHECK: frem half %{{.+}}, %{{.+}}
+    // CHECK-NEXT: store half %{{.+}}, ptr %{{.+}}
+    *a %= b;
+}
+
+/* float to float conversions */
+
+// bit32-LABEL: half @f16_as_self(
+// bit64-LABEL: half @f16_as_self(
+// x86-sse-LABEL: <2 x i8> @f16_as_self(
+// x86-nosse-LABEL: i16 @f16_as_self(
+#[no_mangle]
+pub fn f16_as_self(a: f16) -> f16 {
+    // bit32-CHECK: ret half %{{.+}}
+    // bit64-CHECK: ret half %{{.+}}
+    // x86-sse-CHECK: bitcast half
+    // x86-nosse-CHECK: bitcast half
+    // x86-sse-CHECK: ret i16
+    // x86-nosse-CHECK: ret i16
+    a as f16
+}
+
+// x86-sse-LABEL: <4 x i8> @f16_as_f32(
+// x86-nosse-LABEL: i32 @f16_as_f32(
+// bit32-LABEL: float @f16_as_f32(
+// bit64-LABEL: float @f16_as_f32(
+#[no_mangle]
+pub fn f16_as_f32(a: f16) -> f32 {
+    // CHECK: fpext half %{{.+}} to float
+    a as f32
+}
+
+// x86-sse-LABEL: <8 x i8> @f16_as_f64(
+// x86-nosse-LABEL: void @f16_as_f64({{.*}}sret([8 x i8])
+// bit32-LABEL: double @f16_as_f64(
+// bit64-LABEL: double @f16_as_f64(
+#[no_mangle]
+pub fn f16_as_f64(a: f16) -> f64 {
+    // CHECK: fpext half %{{.+}} to double
+    a as f64
+}
+
+// x86-sse-LABEL: <16 x i8> @f16_as_f128(
+// x86-nosse-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
+// bit64-LABEL: fp128 @f16_as_f128(
+#[no_mangle]
+pub fn f16_as_f128(a: f16) -> f128 {
+    // CHECK: fpext half %{{.+}} to fp128
+    a as f128
+}
+
+// CHECK-LABEL: @f32_as_f16
+#[no_mangle]
+pub fn f32_as_f16(a: f32) -> f16 {
+    // CHECK: fptrunc float %{{.+}} to half
+    a as f16
+}
+
+// CHECK-LABEL: @f64_as_f16
+#[no_mangle]
+pub fn f64_as_f16(a: f64) -> f16 {
+    // CHECK: fptrunc double %{{.+}} to half
+    a as f16
+}
+
+// CHECK-LABEL: @f128_as_f16
+#[no_mangle]
+pub fn f128_as_f16(a: f128) -> f16 {
+    // CHECK: fptrunc fp128 %{{.+}} to half
+    a as f16
+}
+
+/* float to int conversions */
+
+// CHECK-LABEL: i8 @f16_as_u8(
+#[no_mangle]
+pub fn f16_as_u8(a: f16) -> u8 {
+    // CHECK: call i8 @llvm.fptoui.sat.i8.f16(half %{{.+}})
+    a as u8
+}
+
+#[no_mangle]
+pub fn f16_as_u16(a: f16) -> u16 {
+    // CHECK: call i16 @llvm.fptoui.sat.i16.f16(half %{{.+}})
+    a as u16
+}
+
+// CHECK-LABEL: i32 @f16_as_u32(
+#[no_mangle]
+pub fn f16_as_u32(a: f16) -> u32 {
+    // CHECK: call i32 @llvm.fptoui.sat.i32.f16(half %{{.+}})
+    a as u32
+}
+
+// CHECK-LABEL: i64 @f16_as_u64(
+#[no_mangle]
+pub fn f16_as_u64(a: f16) -> u64 {
+    // CHECK: call i64 @llvm.fptoui.sat.i64.f16(half %{{.+}})
+    a as u64
+}
+
+// x86-sse-LABEL: void @f16_as_u128({{.*}}sret([16 x i8])
+// x86-nosse-LABEL: void @f16_as_u128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @f16_as_u128({{.*}}sret([16 x i8])
+// bit64-LABEL: i128 @f16_as_u128(
+#[no_mangle]
+pub fn f16_as_u128(a: f16) -> u128 {
+    // CHECK: call i128 @llvm.fptoui.sat.i128.f16(half %{{.+}})
+    a as u128
+}
+
+// CHECK-LABEL: i8 @f16_as_i8(
+#[no_mangle]
+pub fn f16_as_i8(a: f16) -> i8 {
+    // CHECK: call i8 @llvm.fptosi.sat.i8.f16(half %{{.+}})
+    a as i8
+}
+
+// CHECK-LABEL: i16 @f16_as_i16(
+#[no_mangle]
+pub fn f16_as_i16(a: f16) -> i16 {
+    // CHECK: call i16 @llvm.fptosi.sat.i16.f16(half %{{.+}})
+    a as i16
+}
+// CHECK-LABEL: i32 @f16_as_i32(
+#[no_mangle]
+pub fn f16_as_i32(a: f16) -> i32 {
+    // CHECK: call i32 @llvm.fptosi.sat.i32.f16(half %{{.+}})
+    a as i32
+}
+
+// CHECK-LABEL: i64 @f16_as_i64(
+#[no_mangle]
+pub fn f16_as_i64(a: f16) -> i64 {
+    // CHECK: call i64 @llvm.fptosi.sat.i64.f16(half %{{.+}})
+    a as i64
+}
+
+// x86-sse-LABEL: void @f16_as_i128({{.*}}sret([16 x i8])
+// x86-nosse-LABEL: void @f16_as_i128({{.*}}sret([16 x i8])
+// bit32-LABEL: void @f16_as_i128({{.*}}sret([16 x i8])
+// bit64-LABEL: i128 @f16_as_i128(
+#[no_mangle]
+pub fn f16_as_i128(a: f16) -> i128 {
+    // CHECK: call i128 @llvm.fptosi.sat.i128.f16(half %{{.+}})
+    a as i128
+}
+
+/* int to float conversions */
+
+// CHECK-LABEL: @u8_as_f16
+#[no_mangle]
+pub fn u8_as_f16(a: u8) -> f16 {
+    // CHECK: uitofp i8 %{{.+}} to half
+    a as f16
+}
+
+// CHECK-LABEL: @u16_as_f16
+#[no_mangle]
+pub fn u16_as_f16(a: u16) -> f16 {
+    // CHECK: uitofp i16 %{{.+}} to half
+    a as f16
+}
+
+// CHECK-LABEL: @u32_as_f16
+#[no_mangle]
+pub fn u32_as_f16(a: u32) -> f16 {
+    // CHECK: uitofp i32 %{{.+}} to half
+    a as f16
+}
+
+// CHECK-LABEL: @u64_as_f16
+#[no_mangle]
+pub fn u64_as_f16(a: u64) -> f16 {
+    // CHECK: uitofp i64 %{{.+}} to half
+    a as f16
+}
+
+// CHECK-LABEL: @u128_as_f16
+#[no_mangle]
+pub fn u128_as_f16(a: u128) -> f16 {
+    // CHECK: uitofp i128 %{{.+}} to half
+    a as f16
+}
+
+// CHECK-LABEL: @i8_as_f16
+#[no_mangle]
+pub fn i8_as_f16(a: i8) -> f16 {
+    // CHECK: sitofp i8 %{{.+}} to half
+    a as f16
+}
+
+// CHECK-LABEL: @i16_as_f16
+#[no_mangle]
+pub fn i16_as_f16(a: i16) -> f16 {
+    // CHECK: sitofp i16 %{{.+}} to half
+    a as f16
+}
+
+// CHECK-LABEL: @i32_as_f16
+#[no_mangle]
+pub fn i32_as_f16(a: i32) -> f16 {
+    // CHECK: sitofp i32 %{{.+}} to half
+    a as f16
+}
+
+// CHECK-LABEL: @i64_as_f16
+#[no_mangle]
+pub fn i64_as_f16(a: i64) -> f16 {
+    // CHECK: sitofp i64 %{{.+}} to half
+    a as f16
+}
+
+// CHECK-LABEL: @i128_as_f16
+#[no_mangle]
+pub fn i128_as_f16(a: i128) -> f16 {
+    // CHECK: sitofp i128 %{{.+}} to half
+    a as f16
+}
diff --git a/tests/codegen-llvm/float_math.rs b/tests/codegen-llvm/float_math.rs
new file mode 100644
index 00000000000..9a1e0b4d2d0
--- /dev/null
+++ b/tests/codegen-llvm/float_math.rs
@@ -0,0 +1,87 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::{
+    fadd_algebraic, fadd_fast, fdiv_algebraic, fdiv_fast, fmul_algebraic, fmul_fast,
+    frem_algebraic, frem_fast, fsub_algebraic, fsub_fast,
+};
+
+// CHECK-LABEL: @add
+#[no_mangle]
+pub fn add(x: f32, y: f32) -> f32 {
+    // CHECK: fadd float
+    // CHECK-NOT: fast
+    x + y
+}
+
+// CHECK-LABEL: @test_fadd_algebraic
+#[no_mangle]
+pub fn test_fadd_algebraic(x: f32, y: f32) -> f32 {
+    // CHECK: fadd reassoc nsz arcp contract float %x, %y
+    fadd_algebraic(x, y)
+}
+
+// CHECK-LABEL: @test_fsub_algebraic
+#[no_mangle]
+pub fn test_fsub_algebraic(x: f32, y: f32) -> f32 {
+    // CHECK: fsub reassoc nsz arcp contract float %x, %y
+    fsub_algebraic(x, y)
+}
+
+// CHECK-LABEL: @test_fmul_algebraic
+#[no_mangle]
+pub fn test_fmul_algebraic(x: f32, y: f32) -> f32 {
+    // CHECK: fmul reassoc nsz arcp contract float %x, %y
+    fmul_algebraic(x, y)
+}
+
+// CHECK-LABEL: @test_fdiv_algebraic
+#[no_mangle]
+pub fn test_fdiv_algebraic(x: f32, y: f32) -> f32 {
+    // CHECK: fdiv reassoc nsz arcp contract float %x, %y
+    fdiv_algebraic(x, y)
+}
+
+// CHECK-LABEL: @test_frem_algebraic
+#[no_mangle]
+pub fn test_frem_algebraic(x: f32, y: f32) -> f32 {
+    // CHECK: frem reassoc nsz arcp contract float %x, %y
+    frem_algebraic(x, y)
+}
+
+// CHECK-LABEL: @test_fadd_fast
+#[no_mangle]
+pub fn test_fadd_fast(x: f32, y: f32) -> f32 {
+    // CHECK: fadd fast float %x, %y
+    unsafe { fadd_fast(x, y) }
+}
+
+// CHECK-LABEL: @test_fsub_fast
+#[no_mangle]
+pub fn test_fsub_fast(x: f32, y: f32) -> f32 {
+    // CHECK: fsub fast float %x, %y
+    unsafe { fsub_fast(x, y) }
+}
+
+// CHECK-LABEL: @test_fmul_fast
+#[no_mangle]
+pub fn test_fmul_fast(x: f32, y: f32) -> f32 {
+    // CHECK: fmul fast float %x, %y
+    unsafe { fmul_fast(x, y) }
+}
+
+// CHECK-LABEL: @test_fdiv_fast
+#[no_mangle]
+pub fn test_fdiv_fast(x: f32, y: f32) -> f32 {
+    // CHECK: fdiv fast float %x, %y
+    unsafe { fdiv_fast(x, y) }
+}
+
+// CHECK-LABEL: @test_frem_fast
+#[no_mangle]
+pub fn test_frem_fast(x: f32, y: f32) -> f32 {
+    // CHECK: frem fast float %x, %y
+    unsafe { frem_fast(x, y) }
+}
diff --git a/tests/codegen-llvm/fn-impl-trait-self.rs b/tests/codegen-llvm/fn-impl-trait-self.rs
new file mode 100644
index 00000000000..5799d23b5a0
--- /dev/null
+++ b/tests/codegen-llvm/fn-impl-trait-self.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -g
+//@ ignore-wasi wasi codegens the main symbol differently
+//
+// CHECK-LABEL: @main
+// MSVC: {{.*}}DIDerivedType(tag: DW_TAG_pointer_type, name: "recursive_type$ (*)()",{{.*}}
+// NONMSVC: {{.*}}DIDerivedType(tag: DW_TAG_pointer_type, name: "fn() -> <recursive_type>",{{.*}}
+//
+// CHECK: {{.*}}DISubroutineType{{.*}}
+// CHECK: {{.*}}DIBasicType(name: "<recur_type>", size: {{32|64}}, encoding: DW_ATE_unsigned)
+
+pub fn foo() -> impl Copy {
+    foo
+}
+
+fn main() {
+    let my_res = foo();
+}
diff --git a/tests/codegen-llvm/fn-parameters-on-different-lines-debuginfo.rs b/tests/codegen-llvm/fn-parameters-on-different-lines-debuginfo.rs
new file mode 100644
index 00000000000..2097567f322
--- /dev/null
+++ b/tests/codegen-llvm/fn-parameters-on-different-lines-debuginfo.rs
@@ -0,0 +1,22 @@
+//! Make sure that line debuginfo of function parameters are correct even if
+//! they are not on the same line. Regression test for
+// <https://github.com/rust-lang/rust/issues/45010>.
+
+//@ compile-flags: -g -Copt-level=0
+
+#[rustfmt::skip] // Having parameters on different lines is crucial for this test.
+pub fn foo(
+    x_parameter_not_in_std: i32,
+    y_parameter_not_in_std: i32,
+) -> i32 {
+    x_parameter_not_in_std + y_parameter_not_in_std
+}
+
+fn main() {
+    foo(42, 43); // Ensure `wasm32-wasip1` keeps `foo()` (even if `-Copt-level=0`)
+}
+
+// CHECK: !DILocalVariable(name: "x_parameter_not_in_std", arg: 1,
+// CHECK-SAME: line: 9
+// CHECK: !DILocalVariable(name: "y_parameter_not_in_std", arg: 2,
+// CHECK-SAME: line: 10
diff --git a/tests/codegen-llvm/force-frame-pointers.rs b/tests/codegen-llvm/force-frame-pointers.rs
new file mode 100644
index 00000000000..88c918945d6
--- /dev/null
+++ b/tests/codegen-llvm/force-frame-pointers.rs
@@ -0,0 +1,18 @@
+//@ revisions: Always NonLeaf
+//@ [Always] compile-flags: -Cforce-frame-pointers=yes
+//@ [NonLeaf] compile-flags: -Cforce-frame-pointers=non-leaf
+//@ compile-flags: -Zunstable-options
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+//@ [NonLeaf] ignore-illumos
+//@ [NonLeaf] ignore-openbsd
+//@ [NonLeaf] ignore-x86
+//@ [NonLeaf] ignore-x86_64-apple-darwin
+//@ [NonLeaf] ignore-windows-gnu
+//@ [NonLeaf] ignore-thumb
+// result is platform-dependent based on platform's frame pointer settings
+
+#![crate_type = "lib"]
+
+// Always: attributes #{{.*}} "frame-pointer"="all"
+// NonLeaf: attributes #{{.*}} "frame-pointer"="non-leaf"
+pub fn foo() {}
diff --git a/tests/codegen-llvm/force-no-unwind-tables.rs b/tests/codegen-llvm/force-no-unwind-tables.rs
new file mode 100644
index 00000000000..1de5e0858e0
--- /dev/null
+++ b/tests/codegen-llvm/force-no-unwind-tables.rs
@@ -0,0 +1,11 @@
+//@ compile-flags: -C no-prepopulate-passes -C panic=abort -C force-unwind-tables=n
+//@ ignore-windows: unwind tables are required for panics on Windows
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: define{{.*}}void @foo
+// CHECK-NOT: attributes #{{.*}} uwtable
+#[no_mangle]
+fn foo() {
+    panic!();
+}
diff --git a/tests/codegen-llvm/force-unwind-tables.rs b/tests/codegen-llvm/force-unwind-tables.rs
new file mode 100644
index 00000000000..a2ef8a10454
--- /dev/null
+++ b/tests/codegen-llvm/force-unwind-tables.rs
@@ -0,0 +1,6 @@
+//@ compile-flags: -C no-prepopulate-passes -C force-unwind-tables=y -Copt-level=0
+
+#![crate_type = "lib"]
+
+// CHECK: attributes #{{.*}} uwtable
+pub fn foo() {}
diff --git a/tests/codegen-llvm/frame-pointer-cli-control.rs b/tests/codegen-llvm/frame-pointer-cli-control.rs
new file mode 100644
index 00000000000..a65dd132763
--- /dev/null
+++ b/tests/codegen-llvm/frame-pointer-cli-control.rs
@@ -0,0 +1,61 @@
+//@ add-core-stubs
+//@ compile-flags: --crate-type=rlib -Copt-level=0
+//@ revisions: force-on aarch64-apple aarch64-apple-on aarch64-apple-off
+//@ [force-on] compile-flags: -Cforce-frame-pointers=on
+//@ [aarch64-apple] needs-llvm-components: aarch64
+//@ [aarch64-apple] compile-flags: --target=aarch64-apple-darwin
+//@ [aarch64-apple-on] needs-llvm-components: aarch64
+//@ [aarch64-apple-on] compile-flags: --target=aarch64-apple-darwin -Cforce-frame-pointers=on
+//@ [aarch64-apple-off] needs-llvm-components: aarch64
+//@ [aarch64-apple-off] compile-flags: --target=aarch64-apple-darwin -Cforce-frame-pointers=off
+/*!
+
+Tests the extent to which frame pointers can be controlled by the CLI.
+The behavior of our frame pointer options, at present, is an irreversible ratchet, where
+a "weaker" option that allows omitting frame pointers may be overridden by the target demanding
+that all code (or all non-leaf code, more often) must be compiled with frame pointers.
+This was discussed on 2025-05-22 in the T-compiler meeting and accepted as an intentional change,
+ratifying the prior decisions by compiler contributors and reviewers as correct,
+though it was also acknowledged that the flag allows somewhat confusing inputs.
+
+We find aarch64-apple-darwin useful because of its icy-clear policy regarding frame pointers,
+e.g. <https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms> says:
+
+* The frame pointer register (x29) must always address a valid frame record. Some functions —
+  such as leaf functions or tail calls — may opt not to create an entry in this list.
+  As a result, stack traces are always meaningful, even without debug information.
+
+Many Rust fn, if externally visible, may be expected to follow target ABI by tools or asm code!
+This can make it a problem to generate ABI-incorrect code, which may mean "with frame pointers".
+For this and other reasons, `-Cforce-frame-pointers=off` cannot override the target definition.
+This can cause some confusion because it is "reverse polarity" relative to C compilers, which have
+commands like `-fomit-frame-pointer`, `-fomit-leaf-frame-pointer`, or `-fno-omit-frame-pointer`!
+
+Specific cases where platforms or tools rely on frame pointers for sound or correct unwinding:
+- illumos: <https://smartos.org/bugview/OS-7515>
+- aarch64-windows: <https://github.com/rust-lang/rust/issues/123686>
+- aarch64-linux: <https://github.com/rust-lang/rust/issues/123733>
+- dtrace (freebsd and openbsd): <https://github.com/rust-lang/rust/issues/97723>
+- openbsd: <https://github.com/rust-lang/rust/issues/43575>
+- i686-msvc <https://github.com/rust-lang/backtrace-rs/pull/584#issuecomment-1966177530>
+- i686-mingw: <https://github.com/rust-lang/rust/commit/3f1d3948d6d434b34dd47f132c126a6cb6b8a4ab>
+*/
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+
+// CHECK: i32 @peach{{.*}}[[PEACH_ATTRS:\#[0-9]+]] {
+#[no_mangle]
+pub fn peach(x: u32) -> u32 {
+    x
+}
+
+// CHECK: attributes [[PEACH_ATTRS]] = {
+// force-on-SAME: {{.*}}"frame-pointer"="all"
+// aarch64-apple-SAME: {{.*}}"frame-pointer"="non-leaf"
+// aarch64-apple-on-SAME: {{.*}}"frame-pointer"="all"
+//
+// yes, we are testing this doesn't do anything:
+// aarch64-apple-off-SAME: {{.*}}"frame-pointer"="non-leaf"
+// CHECK-SAME: }
diff --git a/tests/codegen-llvm/frame-pointer.rs b/tests/codegen-llvm/frame-pointer.rs
new file mode 100644
index 00000000000..23989653fa8
--- /dev/null
+++ b/tests/codegen-llvm/frame-pointer.rs
@@ -0,0 +1,35 @@
+//@ add-core-stubs
+//@ compile-flags: --crate-type=rlib -Copt-level=0
+//@ revisions: aarch64-apple aarch64-linux force x64-apple x64-linux
+//@ [aarch64-apple] needs-llvm-components: aarch64
+//@ [aarch64-apple] compile-flags: --target=aarch64-apple-darwin
+//@ [aarch64-linux] needs-llvm-components: aarch64
+//@ [aarch64-linux] compile-flags: --target=aarch64-unknown-linux-gnu
+//@ [force] needs-llvm-components: x86
+//@ [force] compile-flags: --target=x86_64-unknown-linux-gnu -Cforce-frame-pointers=yes
+//@ [x64-apple] needs-llvm-components: x86
+//@ [x64-apple] compile-flags: --target=x86_64-apple-darwin
+//@ [x64-linux] needs-llvm-components: x86
+//@ [x64-linux] compile-flags: --target=x86_64-unknown-linux-gnu
+
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: define i32 @peach{{.*}}[[PEACH_ATTRS:\#[0-9]+]] {
+#[no_mangle]
+pub fn peach(x: u32) -> u32 {
+    x
+}
+
+// CHECK: attributes [[PEACH_ATTRS]] = {
+// x64-linux-NOT: {{.*}}"frame-pointer"{{.*}}
+// x64-apple-SAME: {{.*}}"frame-pointer"="all"
+// force-SAME: {{.*}}"frame-pointer"="all"
+//
+// AAPCS64 demands frame pointers:
+// aarch64-linux-SAME: {{.*}}"frame-pointer"="non-leaf"
+// aarch64-apple-SAME: {{.*}}"frame-pointer"="non-leaf"
+// CHECK-SAME: }
diff --git a/tests/codegen-llvm/function-arguments-noopt.rs b/tests/codegen-llvm/function-arguments-noopt.rs
new file mode 100644
index 00000000000..c80f119696d
--- /dev/null
+++ b/tests/codegen-llvm/function-arguments-noopt.rs
@@ -0,0 +1,69 @@
+//@ compile-flags: -C opt-level=0 -C no-prepopulate-passes
+
+// This test checks that arguments/returns in opt-level=0 builds,
+// while lacking attributes used for optimization, still have ABI-affecting attributes.
+
+#![crate_type = "lib"]
+#![feature(rustc_attrs)]
+
+pub struct S {
+    _field: [i32; 8],
+}
+
+// CHECK: zeroext i1 @boolean(i1 zeroext %x)
+#[no_mangle]
+pub fn boolean(x: bool) -> bool {
+    x
+}
+
+// CHECK-LABEL: @boolean_call
+#[no_mangle]
+pub fn boolean_call(x: bool, f: fn(bool) -> bool) -> bool {
+    // CHECK: call zeroext i1 %f(i1 zeroext %x)
+    f(x)
+}
+
+// CHECK: align 4 ptr @borrow(ptr align 4 %x)
+#[no_mangle]
+pub fn borrow(x: &i32) -> &i32 {
+    x
+}
+
+// CHECK: align 4 ptr @borrow_mut(ptr align 4 %x)
+#[no_mangle]
+pub fn borrow_mut(x: &mut i32) -> &mut i32 {
+    x
+}
+
+// CHECK-LABEL: @borrow_call
+#[no_mangle]
+pub fn borrow_call(x: &i32, f: fn(&i32) -> &i32) -> &i32 {
+    // CHECK: call align 4 ptr %f(ptr align 4 %x)
+    f(x)
+}
+
+// CHECK: void @struct_(ptr sret([32 x i8]) align 4{{( %_0)?}}, ptr align 4 %x)
+#[no_mangle]
+pub fn struct_(x: S) -> S {
+    x
+}
+
+// CHECK-LABEL: @struct_call
+#[no_mangle]
+pub fn struct_call(x: S, f: fn(S) -> S) -> S {
+    // CHECK: call void %f(ptr sret([32 x i8]) align 4{{( %_0)?}}, ptr align 4 %{{.+}})
+    f(x)
+}
+
+// CHECK: { i1, i8 } @enum_(i1 zeroext %x.0, i8 %x.1)
+#[no_mangle]
+pub fn enum_(x: Option<u8>) -> Option<u8> {
+    x
+}
+
+// CHECK-LABEL: @enum_call
+#[no_mangle]
+pub fn enum_call(x: Option<u8>, f: fn(Option<u8>) -> Option<u8>) -> Option<u8> {
+    // CHECK: call { i1, i8 } %f(i1 zeroext %x.0, i8 %x.1)
+    f(x)
+}
diff --git a/tests/codegen-llvm/function-arguments.rs b/tests/codegen-llvm/function-arguments.rs
new file mode 100644
index 00000000000..c8cd8526ae5
--- /dev/null
+++ b/tests/codegen-llvm/function-arguments.rs
@@ -0,0 +1,278 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+#![crate_type = "lib"]
+#![feature(rustc_attrs)]
+#![feature(allocator_api)]
+
+use std::marker::PhantomPinned;
+use std::mem::MaybeUninit;
+use std::num::NonZero;
+use std::ptr::NonNull;
+
+pub struct S {
+    _field: [i32; 8],
+}
+
+pub struct UnsafeInner {
+    _field: std::cell::UnsafeCell<i16>,
+}
+
+pub struct NotUnpin {
+    _field: i32,
+    _marker: PhantomPinned,
+}
+
+pub enum MyBool {
+    True,
+    False,
+}
+
+// CHECK: noundef zeroext i1 @boolean(i1 noundef zeroext %x)
+#[no_mangle]
+pub fn boolean(x: bool) -> bool {
+    x
+}
+
+// CHECK: i8 @maybeuninit_boolean(i8{{.*}} %x)
+#[no_mangle]
+pub fn maybeuninit_boolean(x: MaybeUninit<bool>) -> MaybeUninit<bool> {
+    x
+}
+
+// CHECK: noundef zeroext i1 @enum_bool(i1 noundef zeroext %x)
+#[no_mangle]
+pub fn enum_bool(x: MyBool) -> MyBool {
+    x
+}
+
+// CHECK: i8 @maybeuninit_enum_bool(i8{{.*}} %x)
+#[no_mangle]
+pub fn maybeuninit_enum_bool(x: MaybeUninit<MyBool>) -> MaybeUninit<MyBool> {
+    x
+}
+
+// CHECK: noundef{{( range\(i32 0, 1114112\))?}} i32 @char(i32{{.*}}{{( range\(i32 0, 1114112\))?}} %x)
+#[no_mangle]
+pub fn char(x: char) -> char {
+    x
+}
+
+// CHECK: i32 @maybeuninit_char(i32{{.*}} %x)
+#[no_mangle]
+pub fn maybeuninit_char(x: MaybeUninit<char>) -> MaybeUninit<char> {
+    x
+}
+
+// CHECK: noundef i64 @int(i64 noundef %x)
+#[no_mangle]
+pub fn int(x: u64) -> u64 {
+    x
+}
+
+// CHECK: noundef{{( range\(i64 1, 0\))?}} i64 @nonzero_int(i64 noundef{{( range\(i64 1, 0\))?}} %x)
+#[no_mangle]
+pub fn nonzero_int(x: NonZero<u64>) -> NonZero<u64> {
+    x
+}
+
+// CHECK: noundef i64 @option_nonzero_int(i64 noundef %x)
+#[no_mangle]
+pub fn option_nonzero_int(x: Option<NonZero<u64>>) -> Option<NonZero<u64>> {
+    x
+}
+
+// CHECK: @readonly_borrow(ptr noalias noundef readonly align 4 dereferenceable(4) %_1)
+// FIXME #25759 This should also have `nocapture`
+#[no_mangle]
+pub fn readonly_borrow(_: &i32) {}
+
+// CHECK: noundef align 4 dereferenceable(4) ptr @readonly_borrow_ret()
+#[no_mangle]
+pub fn readonly_borrow_ret() -> &'static i32 {
+    loop {}
+}
+
+// CHECK: @static_borrow(ptr noalias noundef readonly align 4 dereferenceable(4) %_1)
+// static borrow may be captured
+#[no_mangle]
+pub fn static_borrow(_: &'static i32) {}
+
+// CHECK: @named_borrow(ptr noalias noundef readonly align 4 dereferenceable(4) %_1)
+// borrow with named lifetime may be captured
+#[no_mangle]
+pub fn named_borrow<'r>(_: &'r i32) {}
+
+// CHECK: @unsafe_borrow(ptr noundef nonnull align 2 %_1)
+// unsafe interior means this isn't actually readonly and there may be aliases ...
+#[no_mangle]
+pub fn unsafe_borrow(_: &UnsafeInner) {}
+
+// CHECK: @mutable_unsafe_borrow(ptr noalias noundef align 2 dereferenceable(2) %_1)
+// ... unless this is a mutable borrow, those never alias
+#[no_mangle]
+pub fn mutable_unsafe_borrow(_: &mut UnsafeInner) {}
+
+// CHECK: @mutable_borrow(ptr noalias noundef align 4 dereferenceable(4) %_1)
+// FIXME #25759 This should also have `nocapture`
+#[no_mangle]
+pub fn mutable_borrow(_: &mut i32) {}
+
+// CHECK: noundef align 4 dereferenceable(4) ptr @mutable_borrow_ret()
+#[no_mangle]
+pub fn mutable_borrow_ret() -> &'static mut i32 {
+    loop {}
+}
+
+#[no_mangle]
+// CHECK: @mutable_notunpin_borrow(ptr noundef nonnull align 4 %_1)
+// This one is *not* `noalias` because it might be self-referential.
+// It is also not `dereferenceable` due to
+// <https://github.com/rust-lang/unsafe-code-guidelines/issues/381>.
+pub fn mutable_notunpin_borrow(_: &mut NotUnpin) {}
+
+// CHECK: @notunpin_borrow(ptr noalias noundef readonly align 4 dereferenceable(4) %_1)
+// But `&NotUnpin` behaves perfectly normal.
+#[no_mangle]
+pub fn notunpin_borrow(_: &NotUnpin) {}
+
+// CHECK: @indirect_struct(ptr noalias{{( nocapture)?}} noundef readonly align 4{{( captures\(none\))?}} dereferenceable(32) %_1)
+#[no_mangle]
+pub fn indirect_struct(_: S) {}
+
+// CHECK: @borrowed_struct(ptr noalias noundef readonly align 4 dereferenceable(32) %_1)
+// FIXME #25759 This should also have `nocapture`
+#[no_mangle]
+pub fn borrowed_struct(_: &S) {}
+
+// CHECK: @option_borrow(ptr noalias noundef readonly align 4 dereferenceable_or_null(4) %_x)
+#[no_mangle]
+pub fn option_borrow(_x: Option<&i32>) {}
+
+// CHECK: @option_borrow_mut(ptr noalias noundef align 4 dereferenceable_or_null(4) %_x)
+#[no_mangle]
+pub fn option_borrow_mut(_x: Option<&mut i32>) {}
+
+// Function that must NOT have `dereferenceable` or `align`.
+#[rustc_layout_scalar_valid_range_start(16)]
+pub struct RestrictedAddress(&'static i16);
+enum E {
+    A(RestrictedAddress),
+    B,
+    C,
+}
+// If the `nonnull` ever goes missing, you might have to tweak the
+// scalar_valid_range on `RestrictedAddress` to get it back. You
+// might even have to add a `rustc_layout_scalar_valid_range_end`.
+// CHECK: @nonnull_and_nondereferenceable(ptr noundef nonnull %_x)
+#[no_mangle]
+pub fn nonnull_and_nondereferenceable(_x: E) {}
+
+// CHECK: @raw_struct(ptr noundef %_1)
+#[no_mangle]
+pub fn raw_struct(_: *const S) {}
+
+// CHECK: @raw_option_nonnull_struct(ptr noundef %_1)
+#[no_mangle]
+pub fn raw_option_nonnull_struct(_: Option<NonNull<S>>) {}
+
+// `Box` can get deallocated during execution of the function, so it should
+// not get `dereferenceable`.
+// CHECK: noundef nonnull align 4 ptr @_box(ptr noalias noundef nonnull align 4 %x)
+#[no_mangle]
+pub fn _box(x: Box<i32>) -> Box<i32> {
+    x
+}
+
+// With a custom allocator, it should *not* have `noalias`. (See
+// <https://github.com/rust-lang/miri/issues/3341> for why.) The second argument is the allocator,
+// which is a reference here that still carries `noalias` as usual.
+// CHECK: @_box_custom(ptr noundef nonnull align 4 %x.0, ptr noalias noundef nonnull readonly align 1 %x.1)
+#[no_mangle]
+pub fn _box_custom(x: Box<i32, &std::alloc::Global>) {
+    drop(x)
+}
+
+// CHECK: noundef nonnull align 4 ptr @notunpin_box(ptr noundef nonnull align 4 %x)
+#[no_mangle]
+pub fn notunpin_box(x: Box<NotUnpin>) -> Box<NotUnpin> {
+    x
+}
+
+// CHECK: @struct_return(ptr{{( dead_on_unwind)?}} noalias{{( nocapture)?}} noundef{{( writable)?}} sret([32 x i8]) align 4{{( captures\(none\))?}} dereferenceable(32){{( %_0)?}})
+#[no_mangle]
+pub fn struct_return() -> S {
+    S { _field: [0, 0, 0, 0, 0, 0, 0, 0] }
+}
+
+// Hack to get the correct size for the length part in slices
+// CHECK: @helper([[USIZE:i[0-9]+]] noundef %_1)
+#[no_mangle]
+pub fn helper(_: usize) {}
+
+// CHECK: @slice(ptr noalias noundef nonnull readonly align 1 %_1.0, [[USIZE]] noundef %_1.1)
+// FIXME #25759 This should also have `nocapture`
+#[no_mangle]
+pub fn slice(_: &[u8]) {}
+
+// CHECK: @mutable_slice(ptr noalias noundef nonnull align 1 %_1.0, [[USIZE]] noundef %_1.1)
+// FIXME #25759 This should also have `nocapture`
+#[no_mangle]
+pub fn mutable_slice(_: &mut [u8]) {}
+
+// CHECK: @unsafe_slice(ptr noundef nonnull align 2 %_1.0, [[USIZE]] noundef %_1.1)
+// unsafe interior means this isn't actually readonly and there may be aliases ...
+#[no_mangle]
+pub fn unsafe_slice(_: &[UnsafeInner]) {}
+
+// CHECK: @raw_slice(ptr noundef %_1.0, [[USIZE]] noundef %_1.1)
+#[no_mangle]
+pub fn raw_slice(_: *const [u8]) {}
+
+// CHECK: @str(ptr noalias noundef nonnull readonly align 1 %_1.0, [[USIZE]] noundef %_1.1)
+// FIXME #25759 This should also have `nocapture`
+#[no_mangle]
+pub fn str(_: &[u8]) {}
+
+// CHECK: @trait_borrow(ptr noundef nonnull align 1 %_1.0, {{.+}} noalias noundef readonly align {{.*}} dereferenceable({{.*}}) %_1.1)
+// FIXME #25759 This should also have `nocapture`
+#[no_mangle]
+pub fn trait_borrow(_: &dyn Drop) {}
+
+// CHECK: @option_trait_borrow(ptr noundef align 1 %x.0, ptr %x.1)
+#[no_mangle]
+pub fn option_trait_borrow(x: Option<&dyn Drop>) {}
+
+// CHECK: @option_trait_borrow_mut(ptr noundef align 1 %x.0, ptr %x.1)
+#[no_mangle]
+pub fn option_trait_borrow_mut(x: Option<&mut dyn Drop>) {}
+
+// CHECK: @trait_raw(ptr noundef %_1.0, {{.+}} noalias noundef readonly align {{.*}} dereferenceable({{.*}}) %_1.1)
+#[no_mangle]
+pub fn trait_raw(_: *const dyn Drop) {}
+
+// CHECK: @trait_box(ptr noalias noundef nonnull align 1{{( %0)?}}, {{.+}} noalias noundef readonly align {{.*}} dereferenceable({{.*}}){{( %1)?}})
+#[no_mangle]
+pub fn trait_box(_: Box<dyn Drop + Unpin>) {}
+
+// CHECK: { ptr, ptr } @trait_option(ptr noalias noundef align 1 %x.0, ptr %x.1)
+#[no_mangle]
+pub fn trait_option(x: Option<Box<dyn Drop + Unpin>>) -> Option<Box<dyn Drop + Unpin>> {
+    x
+}
+
+// CHECK: { ptr, [[USIZE]] } @return_slice(ptr noalias noundef nonnull readonly align 2 %x.0, [[USIZE]] noundef %x.1)
+#[no_mangle]
+pub fn return_slice(x: &[u16]) -> &[u16] {
+    x
+}
+
+// CHECK: { i16, i16 } @enum_id_1(i16 noundef{{( range\(i16 0, 3\))?}} %x.0, i16 %x.1)
+#[no_mangle]
+pub fn enum_id_1(x: Option<Result<u16, u16>>) -> Option<Result<u16, u16>> {
+    x
+}
+
+// CHECK: { i1, i8 } @enum_id_2(i1 noundef zeroext %x.0, i8 %x.1)
+#[no_mangle]
+pub fn enum_id_2(x: Option<u8>) -> Option<u8> {
+    x
+}
diff --git a/tests/codegen-llvm/function-return.rs b/tests/codegen-llvm/function-return.rs
new file mode 100644
index 00000000000..4127f516038
--- /dev/null
+++ b/tests/codegen-llvm/function-return.rs
@@ -0,0 +1,35 @@
+// Test that the `fn_ret_thunk_extern` function attribute is (not) emitted when
+// the `-Zfunction-return={keep,thunk-extern}` flag is (not) set.
+
+//@ add-core-stubs
+//@ revisions: unset keep thunk-extern keep-thunk-extern thunk-extern-keep
+//@ needs-llvm-components: x86
+//@ compile-flags: --target x86_64-unknown-linux-gnu
+//@ [keep] compile-flags: -Zfunction-return=keep
+//@ [thunk-extern] compile-flags: -Zfunction-return=thunk-extern
+//@ [keep-thunk-extern] compile-flags: -Zfunction-return=keep -Zfunction-return=thunk-extern
+//@ [thunk-extern-keep] compile-flags: -Zfunction-return=thunk-extern -Zfunction-return=keep
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+pub fn foo() {
+    // CHECK: @foo() unnamed_addr #0
+
+    // unset-NOT: fn_ret_thunk_extern
+    // keep-NOT: fn_ret_thunk_extern
+    // thunk-extern: attributes #0 = { {{.*}}fn_ret_thunk_extern{{.*}} }
+    // keep-thunk-extern: attributes #0 = { {{.*}}fn_ret_thunk_extern{{.*}} }
+    // thunk-extern-keep-NOT: fn_ret_thunk_extern
+}
+
+// unset-NOT: !{{[0-9]+}} = !{i32 4, !"function_return_thunk_extern", i32 1}
+// keep-NOT: !{{[0-9]+}} = !{i32 4, !"function_return_thunk_extern", i32 1}
+// thunk-extern: !{{[0-9]+}} = !{i32 4, !"function_return_thunk_extern", i32 1}
+// keep-thunk-extern: !{{[0-9]+}} = !{i32 4, !"function_return_thunk_extern", i32 1}
+// thunk-extern-keep-NOT: !{{[0-9]+}} = !{i32 4, !"function_return_thunk_extern", i32 1}
diff --git a/tests/codegen-llvm/gdb_debug_script_load.rs b/tests/codegen-llvm/gdb_debug_script_load.rs
new file mode 100644
index 00000000000..3e92eba10b1
--- /dev/null
+++ b/tests/codegen-llvm/gdb_debug_script_load.rs
@@ -0,0 +1,37 @@
+//
+//@ ignore-windows
+//@ ignore-apple
+//@ ignore-wasm
+//@ ignore-emscripten
+
+//@ compile-flags: -g -C no-prepopulate-passes -Cpanic=abort
+
+#![feature(lang_items)]
+#![no_std]
+
+#[panic_handler]
+fn panic_handler(_: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+#[no_mangle]
+extern "C" fn rust_eh_personality() {
+    loop {}
+}
+
+// Needs rustc to generate `main` as that's where the magic load is inserted.
+// IOW, we cannot write this test with `#![no_main]`.
+// CHECK-LABEL: @main
+// CHECK: load volatile i8, {{.+}} @__rustc_debug_gdb_scripts_section__
+
+#[lang = "start"]
+fn lang_start<T: 'static>(
+    _main: fn() -> T,
+    _argc: isize,
+    _argv: *const *const u8,
+    _sigpipe: u8,
+) -> isize {
+    return 0;
+}
+
+fn main() {}
diff --git a/tests/codegen-llvm/generic-debug.rs b/tests/codegen-llvm/generic-debug.rs
new file mode 100644
index 00000000000..0ad0b074657
--- /dev/null
+++ b/tests/codegen-llvm/generic-debug.rs
@@ -0,0 +1,17 @@
+//@ ignore-wasi wasi codegens the main symbol differently
+
+//@ compile-flags: -g -C no-prepopulate-passes
+
+// CHECK-LABEL: @main
+// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "Generic<i32>",{{.*}}
+// CHECK: {{.*}}DITemplateTypeParameter{{.*}}name: "Type",{{.*}}
+
+#![allow(dead_code)]
+#![allow(unused_variables)]
+#![allow(unused_assignments)]
+
+pub struct Generic<Type>(Type);
+
+fn main() {
+    let generic = Generic(10);
+}
diff --git a/tests/codegen-llvm/gep-index.rs b/tests/codegen-llvm/gep-index.rs
new file mode 100644
index 00000000000..bfb2511af87
--- /dev/null
+++ b/tests/codegen-llvm/gep-index.rs
@@ -0,0 +1,37 @@
+//! Check that index and offset use the same getelementptr format.
+
+//@ revisions: NO-OPT OPT
+//@[NO-OPT] compile-flags: -Copt-level=0
+//@[OPT] compile-flags: -Copt-level=1
+
+#![crate_type = "lib"]
+
+struct Foo(i32, i32);
+
+// 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
+    &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
+    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
+    &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
+    unsafe { a.add(index) }
+}
diff --git a/tests/codegen-llvm/gpu-kernel-abi.rs b/tests/codegen-llvm/gpu-kernel-abi.rs
new file mode 100644
index 00000000000..8ac376d9338
--- /dev/null
+++ b/tests/codegen-llvm/gpu-kernel-abi.rs
@@ -0,0 +1,15 @@
+// Checks that the gpu-kernel calling convention correctly translates to LLVM calling conventions.
+
+//@ add-core-stubs
+//@ revisions: nvptx
+//@ [nvptx] compile-flags: --crate-type=rlib --target=nvptx64-nvidia-cuda
+//@ [nvptx] needs-llvm-components: nvptx
+#![feature(no_core, lang_items, abi_gpu_kernel)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// nvptx: define ptx_kernel void @fun(i32
+#[no_mangle]
+pub extern "gpu-kernel" fn fun(_: i32) {}
diff --git a/tests/codegen-llvm/gpu_offload/gpu_host.rs b/tests/codegen-llvm/gpu_offload/gpu_host.rs
new file mode 100644
index 00000000000..513e27426bc
--- /dev/null
+++ b/tests/codegen-llvm/gpu_offload/gpu_host.rs
@@ -0,0 +1,80 @@
+//@ compile-flags: -Zoffload=Enable -Zunstable-options -C opt-level=3  -Clto=fat
+//@ no-prefer-dynamic
+//@ needs-enzyme
+
+// This test is verifying that we generate __tgt_target_data_*_mapper before and after a call to the
+// kernel_1. Better documentation to what each global or variable means is available in the gpu
+// offlaod code, or the LLVM offload documentation. This code does not launch any GPU kernels yet,
+// and will be rewritten once a proper offload frontend has landed.
+//
+// We currently only handle memory transfer for specific calls to functions named `kernel_{num}`,
+// when inside of a function called main. This, too, is a temporary workaround for not having a
+// frontend.
+
+#![no_main]
+
+#[unsafe(no_mangle)]
+fn main() {
+    let mut x = [3.0; 256];
+    kernel_1(&mut x);
+    core::hint::black_box(&x);
+}
+
+// CHECK: %struct.__tgt_offload_entry = type { i64, i16, i16, i32, ptr, ptr, i64, i64, ptr }
+// CHECK: %struct.__tgt_kernel_arguments = type { i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, i64, i64, [3 x i32], [3 x i32], i32 }
+// CHECK: %struct.ident_t = type { i32, i32, i32, i32, ptr }
+// CHECK: %struct.__tgt_bin_desc = type { i32, ptr, ptr, ptr }
+
+// CHECK: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 1024]
+// CHECK: @.offload_maptypes.1 = private unnamed_addr constant [1 x i64] [i64 3]
+// CHECK: @.kernel_1.region_id = weak unnamed_addr constant i8 0
+// CHECK: @.offloading.entry_name.1 = internal unnamed_addr constant [9 x i8] c"kernel_1\00", section ".llvm.rodata.offloading", align 1
+// CHECK: @.offloading.entry.kernel_1 = weak constant %struct.__tgt_offload_entry { i64 0, i16 1, i16 1, i32 0, ptr @.kernel_1.region_id, ptr @.offloading.entry_name.1, i64 0, i64 0, ptr null }, section ".omp_offloading_entries", align 1
+// CHECK: @my_struct_global2 = external global %struct.__tgt_kernel_arguments
+// CHECK: @0 = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00", align 1
+// CHECK: @1 = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 22, ptr @0 }, align 8
+
+// CHECK:  Function Attrs:
+// CHECK-NEXT: define{{( dso_local)?}} void @main()
+// CHECK-NEXT: start:
+// CHECK-NEXT:   %0 = alloca [8 x i8], align 8
+// CHECK-NEXT:   %x = alloca [1024 x i8], align 16
+// CHECK-NEXT:   %EmptyDesc = alloca %struct.__tgt_bin_desc, align 8
+// CHECK-NEXT:   %.offload_baseptrs = alloca [1 x ptr], align 8
+// CHECK-NEXT:   %.offload_ptrs = alloca [1 x ptr], align 8
+// CHECK-NEXT:   %.offload_sizes = alloca [1 x i64], align 8
+// CHECK-NEXT:   %x.addr = alloca ptr, align 8
+// CHECK-NEXT:   store ptr %x, ptr %x.addr, align 8
+// CHECK-NEXT:   %1 = load ptr, ptr %x.addr, align 8
+// CHECK-NEXT:   %2 = getelementptr inbounds float, ptr %1, i32 0
+// CHECK:        call void @llvm.memset.p0.i64(ptr align 8 %EmptyDesc, i8 0, i64 32, i1 false)
+// CHECK-NEXT:   call void @__tgt_register_lib(ptr %EmptyDesc)
+// CHECK-NEXT:   call void @__tgt_init_all_rtls()
+// CHECK-NEXT:   %3 = getelementptr inbounds [1 x ptr], ptr %.offload_baseptrs, i32 0, i32 0
+// CHECK-NEXT:   store ptr %1, ptr %3, align 8
+// CHECK-NEXT:   %4 = getelementptr inbounds [1 x ptr], ptr %.offload_ptrs, i32 0, i32 0
+// CHECK-NEXT:   store ptr %2, ptr %4, align 8
+// CHECK-NEXT:   %5 = getelementptr inbounds [1 x i64], ptr %.offload_sizes, i32 0, i32 0
+// CHECK-NEXT:   store i64 1024, ptr %5, align 8
+// CHECK-NEXT:   %6 = getelementptr inbounds [1 x ptr], ptr %.offload_baseptrs, i32 0, i32 0
+// CHECK-NEXT:   %7 = getelementptr inbounds [1 x ptr], ptr %.offload_ptrs, i32 0, i32 0
+// CHECK-NEXT:   %8 = getelementptr inbounds [1 x i64], ptr %.offload_sizes, i32 0, i32 0
+// CHECK-NEXT:   call void @__tgt_target_data_begin_mapper(ptr @1, i64 -1, i32 1, ptr %6, ptr %7, ptr %8, ptr @.offload_maptypes.1, ptr null, ptr null)
+// CHECK-NEXT:   call void @kernel_1(ptr noalias noundef nonnull align 4 dereferenceable(1024) %x)
+// CHECK-NEXT:   %9 = getelementptr inbounds [1 x ptr], ptr %.offload_baseptrs, i32 0, i32 0
+// CHECK-NEXT:   %10 = getelementptr inbounds [1 x ptr], ptr %.offload_ptrs, i32 0, i32 0
+// CHECK-NEXT:   %11 = getelementptr inbounds [1 x i64], ptr %.offload_sizes, i32 0, i32 0
+// CHECK-NEXT:   call void @__tgt_target_data_end_mapper(ptr @1, i64 -1, i32 1, ptr %9, ptr %10, ptr %11, ptr @.offload_maptypes.1, ptr null, ptr null)
+// CHECK-NEXT:   call void @__tgt_unregister_lib(ptr %EmptyDesc)
+// CHECK:        store ptr %x, ptr %0, align 8
+// CHECK-NEXT:   call void asm sideeffect "", "r,~{memory}"(ptr nonnull %0)
+// CHECK:        ret void
+// CHECK-NEXT: }
+
+#[unsafe(no_mangle)]
+#[inline(never)]
+pub fn kernel_1(x: &mut [f32; 256]) {
+    for i in 0..256 {
+        x[i] = 21.0;
+    }
+}
diff --git a/tests/codegen-llvm/hint/cold_path.rs b/tests/codegen-llvm/hint/cold_path.rs
new file mode 100644
index 00000000000..149abe474f6
--- /dev/null
+++ b/tests/codegen-llvm/hint/cold_path.rs
@@ -0,0 +1,54 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+#![feature(cold_path)]
+
+use std::hint::cold_path;
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_a() {
+    println!("path a");
+}
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_b() {
+    println!("path b");
+}
+
+#[no_mangle]
+pub fn test1(x: bool) {
+    if x {
+        path_a();
+    } else {
+        cold_path();
+        path_b();
+    }
+
+    // CHECK-LABEL: @test1(
+    // CHECK: br i1 %x, label %bb1, label %bb2, !prof ![[NUM:[0-9]+]]
+    // CHECK: bb2:
+    // CHECK: path_b
+    // CHECK: bb1:
+    // CHECK: path_a
+}
+
+#[no_mangle]
+pub fn test2(x: i32) {
+    match x > 0 {
+        true => path_a(),
+        false => {
+            cold_path();
+            path_b()
+        }
+    }
+
+    // CHECK-LABEL: @test2(
+    // CHECK: br i1 %_2, label %bb2, label %bb1, !prof ![[NUM]]
+    // CHECK: bb1:
+    // CHECK: path_b
+    // CHECK: bb2:
+    // CHECK: path_a
+}
+
+// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 2000, i32 1}
diff --git a/tests/codegen-llvm/hint/likely.rs b/tests/codegen-llvm/hint/likely.rs
new file mode 100644
index 00000000000..75f9e7aae36
--- /dev/null
+++ b/tests/codegen-llvm/hint/likely.rs
@@ -0,0 +1,81 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+#![feature(likely_unlikely)]
+
+use std::hint::likely;
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_a() {
+    println!("path a");
+}
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_b() {
+    println!("path b");
+}
+
+#[no_mangle]
+pub fn test1(x: bool) {
+    if likely(x) {
+        path_a();
+    } else {
+        path_b();
+    }
+
+    // CHECK-LABEL: @test1(
+    // CHECK: br i1 %x, label %bb2, label %bb3, !prof ![[NUM:[0-9]+]]
+    // CHECK: bb3:
+    // CHECK: path_b
+    // CHECK: bb2:
+    // CHECK: path_a
+}
+
+#[no_mangle]
+pub fn test2(x: i32) {
+    match likely(x > 0) {
+        true => path_a(),
+        false => path_b(),
+    }
+
+    // CHECK-LABEL: @test2(
+    // CHECK: br i1 %_2, label %bb2, label %bb3, !prof ![[NUM]]
+    // CHECK: bb3:
+    // CHECK: path_b
+    // CHECK: bb2:
+    // CHECK: path_a
+}
+
+#[no_mangle]
+pub fn test3(x: i8) {
+    match likely(x < 7) {
+        true => path_a(),
+        _ => path_b(),
+    }
+
+    // CHECK-LABEL: @test3(
+    // CHECK: br i1 %_2, label %bb2, label %bb3, !prof ![[NUM]]
+    // CHECK: bb3:
+    // CHECK: path_b
+    // CHECK: bb2:
+    // CHECK: path_a
+}
+
+#[no_mangle]
+pub fn test4(x: u64) {
+    match likely(x != 33) {
+        false => path_a(),
+        _ => path_b(),
+    }
+
+    // CHECK-LABEL: @test4(
+    // CHECK: br i1 %0, label %bb3, label %bb2, !prof ![[NUM2:[0-9]+]]
+    // CHECK: bb3:
+    // CHECK: path_a
+    // CHECK: bb2:
+    // CHECK: path_b
+}
+
+// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 2000, i32 1}
+// CHECK: ![[NUM2]] = !{!"branch_weights", {{(!"expected", )?}}i32 1, i32 2000}
diff --git a/tests/codegen-llvm/hint/unlikely.rs b/tests/codegen-llvm/hint/unlikely.rs
new file mode 100644
index 00000000000..248b1e2537e
--- /dev/null
+++ b/tests/codegen-llvm/hint/unlikely.rs
@@ -0,0 +1,80 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+#![feature(likely_unlikely)]
+
+use std::hint::unlikely;
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_a() {
+    println!("path a");
+}
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_b() {
+    println!("path b");
+}
+
+#[no_mangle]
+pub fn test1(x: bool) {
+    if unlikely(x) {
+        path_a();
+    } else {
+        path_b();
+    }
+
+    // CHECK-LABEL: @test1(
+    // CHECK: br i1 %x, label %bb2, label %bb4, !prof ![[NUM:[0-9]+]]
+    // CHECK: bb4:
+    // CHECK: path_b
+    // CHECK: bb2:
+    // CHECK: path_a
+}
+
+#[no_mangle]
+pub fn test2(x: i32) {
+    match unlikely(x > 0) {
+        true => path_a(),
+        false => path_b(),
+    }
+
+    // CHECK-LABEL: @test2(
+    // CHECK: br i1 %_2, label %bb2, label %bb4, !prof ![[NUM]]
+    // CHECK: bb4:
+    // CHECK: path_b
+    // CHECK: bb2:
+    // CHECK: path_a
+}
+
+#[no_mangle]
+pub fn test3(x: i8) {
+    match unlikely(x < 7) {
+        true => path_a(),
+        _ => path_b(),
+    }
+
+    // CHECK-LABEL: @test3(
+    // CHECK: br i1 %_2, label %bb2, label %bb4, !prof ![[NUM]]
+    // CHECK: bb4:
+    // CHECK: path_b
+    // CHECK: bb2:
+    // CHECK: path_a
+}
+
+#[no_mangle]
+pub fn test4(x: u64) {
+    match unlikely(x != 33) {
+        false => path_a(),
+        _ => path_b(),
+    }
+
+    // CHECK-LABEL: @test4(
+    // CHECK: br i1 %0, label %bb4, label %bb2, !prof ![[NUM2:[0-9]+]]
+    // CHECK: bb4:
+    // CHECK: path_a
+    // CHECK: bb2:
+    // CHECK: path_b
+}
+
+// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 1, i32 2000}
diff --git a/tests/codegen-llvm/i128-wasm32-callconv.rs b/tests/codegen-llvm/i128-wasm32-callconv.rs
new file mode 100644
index 00000000000..9d73d270ef3
--- /dev/null
+++ b/tests/codegen-llvm/i128-wasm32-callconv.rs
@@ -0,0 +1,49 @@
+//! Verify that Rust implements the expected calling convention for `i128`/`u128`.
+
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 --target wasm32-wasip1
+//@ needs-llvm-components: webassembly
+
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+#![feature(no_core, lang_items)]
+
+extern crate minicore;
+
+extern "C" {
+    fn extern_call(arg0: i128);
+    fn extern_ret() -> i128;
+}
+
+#[no_mangle]
+pub extern "C" fn pass(_arg0: u32, arg1: i128) {
+    // CHECK-LABEL: @pass(
+    // an i128 is passed via registers
+    // CHECK-SAME: i128 noundef %arg1
+    // CHECK: call void @extern_call
+    unsafe { extern_call(arg1) };
+}
+
+// Check that we produce the correct return ABI
+#[no_mangle]
+pub extern "C" fn ret(_arg0: u32, arg1: i128) -> i128 {
+    // CHECK-LABEL: @ret(
+    // but an i128 is returned via the stack
+    // CHECK-SAME: sret
+    // CHECK: store i128 %arg1
+    // CHECK-NEXT: ret void
+    arg1
+}
+
+// Check that we consume the correct return ABI
+#[no_mangle]
+pub extern "C" fn forward(dst: *mut i128) {
+    // CHECK-LABEL: @forward
+    // CHECK-SAME: ptr{{.*}} %dst)
+    // without optimizatons, an intermediate alloca is used
+    // CHECK: call void @extern_ret
+    // CHECK: store i128
+    // CHECK: ret void
+    unsafe { *dst = extern_ret() };
+}
diff --git a/tests/codegen-llvm/i128-x86-align.rs b/tests/codegen-llvm/i128-x86-align.rs
new file mode 100644
index 00000000000..75802b0c505
--- /dev/null
+++ b/tests/codegen-llvm/i128-x86-align.rs
@@ -0,0 +1,105 @@
+//@ only-x86_64
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --crate-type=lib
+
+// On LLVM 17 and earlier LLVM's own data layout specifies that i128 has 8 byte alignment,
+// while rustc wants it to have 16 byte alignment. This test checks that we handle this
+// correctly.
+
+// CHECK: %ScalarPair = type { i32, [3 x i32], i128 }
+
+#![feature(core_intrinsics)]
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct ScalarPair {
+    a: i32,
+    b: i128,
+}
+
+#[no_mangle]
+pub fn load(x: &ScalarPair) -> ScalarPair {
+    // CHECK-LABEL: @load(
+    // CHECK-SAME: sret([32 x i8]) align 16
+    // CHECK-SAME: dereferenceable(32) %_0,
+    // CHECK-SAME: align 16
+    // CHECK-SAME: dereferenceable(32) %x
+    // CHECK:      [[A:%.*]] = load i32, ptr %x, align 16
+    // CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr %x, i64 16
+    // CHECK-NEXT: [[B:%.*]] = load i128, ptr [[GEP]], align 16
+    // CHECK-NEXT: store i32 [[A]], ptr %_0, align 16
+    // CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr %_0, i64 16
+    // CHECK-NEXT: store i128 [[B]], ptr [[GEP]], align 16
+    // CHECK-NEXT: ret void
+    *x
+}
+
+#[no_mangle]
+pub fn store(x: &mut ScalarPair) {
+    // CHECK-LABEL: @store(
+    // CHECK-SAME: align 16
+    // CHECK-SAME: dereferenceable(32) %x
+    // CHECK:      store i32 1, ptr %x, align 16
+    // CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr %x, i64 16
+    // CHECK-NEXT: store i128 2, ptr [[GEP]], align 16
+    *x = ScalarPair { a: 1, b: 2 };
+}
+
+#[no_mangle]
+pub fn alloca() {
+    // CHECK-LABEL: @alloca(
+    // CHECK:      [[X:%.*]] = alloca [32 x i8], align 16
+    // CHECK:      store i32 1, ptr %x, align 16
+    // CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr %x, i64 16
+    // CHECK-NEXT: store i128 2, ptr [[GEP]], align 16
+    let mut x = ScalarPair { a: 1, b: 2 };
+    store(&mut x);
+}
+
+#[no_mangle]
+pub fn load_volatile(x: &ScalarPair) -> ScalarPair {
+    // CHECK-LABEL: @load_volatile(
+    // CHECK-SAME: sret([32 x i8]) align 16
+    // CHECK-SAME: dereferenceable(32) %_0,
+    // CHECK-SAME: align 16
+    // CHECK-SAME: dereferenceable(32) %x
+    // CHECK:      [[LOAD:%.*]] = load volatile %ScalarPair, ptr %x, align 16
+    // CHECK-NEXT: store %ScalarPair [[LOAD]], ptr %_0, align 16
+    // CHECK-NEXT: ret void
+    unsafe { std::intrinsics::volatile_load(x) }
+}
+
+#[no_mangle]
+pub fn transmute(x: ScalarPair) -> (std::mem::MaybeUninit<i128>, i128) {
+    // CHECK-LABEL: @transmute(
+    // CHECK-SAME:  sret([32 x i8]) align 16
+    // CHECK-SAME:  dereferenceable(32) %_0,
+    // CHECK-SAME:  i32 noundef %x.0, i128 noundef %x.1
+    // CHECK:       store i32 %x.0, ptr %_0, align 16
+    // CHECK-NEXT:  [[GEP:%.*]] = getelementptr inbounds i8, ptr %_0, i64 16
+    // CHECK-NEXT:  store i128 %x.1, ptr [[GEP]], align 16
+    // CHECK-NEXT:  ret void
+    unsafe { std::mem::transmute(x) }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct Struct {
+    a: i32,
+    b: i32,
+    c: i128,
+}
+
+#[no_mangle]
+pub fn store_struct(x: &mut Struct) {
+    // CHECK-LABEL: @store_struct(
+    // CHECK-SAME: align 16
+    // CHECK-SAME: dereferenceable(32) %x
+    // CHECK:      [[TMP:%.*]] = alloca [32 x i8], align 16
+    // CHECK:      store i32 1, ptr [[TMP]], align 16
+    // CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds i8, ptr [[TMP]], i64 4
+    // CHECK-NEXT: store i32 2, ptr [[GEP1]], align 4
+    // CHECK-NEXT: [[GEP2:%.*]] = getelementptr inbounds i8, ptr [[TMP]], i64 16
+    // CHECK-NEXT: store i128 3, ptr [[GEP2]], align 16
+    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 16 %x, ptr align 16 [[TMP]], i64 32, i1 false)
+    *x = Struct { a: 1, b: 2, c: 3 };
+}
diff --git a/tests/codegen-llvm/i128-x86-callconv.rs b/tests/codegen-llvm/i128-x86-callconv.rs
new file mode 100644
index 00000000000..41c30c09c1a
--- /dev/null
+++ b/tests/codegen-llvm/i128-x86-callconv.rs
@@ -0,0 +1,87 @@
+//! Verify that Rust implements the expected calling convention for `i128`/`u128`.
+
+// Eliminate intermediate instructions during `nop` tests
+//@ compile-flags: -Copt-level=1
+
+//@ add-core-stubs
+//@ revisions: MSVC MINGW softfloat
+//@ [MSVC] needs-llvm-components: x86
+//@ [MSVC] compile-flags: --target x86_64-pc-windows-msvc
+// Use `WIN` as a common prefix for MSVC and MINGW but *not* the softfloat test.
+//@ [MSVC] filecheck-flags: --check-prefix=WIN
+//@ [MINGW] needs-llvm-components: x86
+//@ [MINGW] compile-flags: --target x86_64-pc-windows-gnu
+//@ [MINGW] filecheck-flags: --check-prefix=WIN
+// The `x86_64-unknown-uefi` target also uses the Windows calling convention,
+// but does not have SSE registers available.
+//@ [softfloat] needs-llvm-components: x86
+//@ [softfloat] compile-flags: --target x86_64-unknown-uefi
+
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+#![feature(no_core, lang_items)]
+
+extern crate minicore;
+
+extern "C" {
+    fn extern_call(arg0: i128);
+    fn extern_ret() -> i128;
+}
+
+#[no_mangle]
+pub extern "C" fn pass(_arg0: u32, arg1: i128) {
+    // CHECK-LABEL: @pass(
+    // i128 is passed indirectly on Windows. It should load the pointer to the stack and pass
+    // a pointer to that allocation. The softfloat ABI works the same.
+    // CHECK-SAME: %_arg0, ptr{{.*}} %arg1)
+    // CHECK: [[PASS:%[_0-9]+]] = alloca [16 x i8], align 16
+    // CHECK: [[LOADED:%[_0-9]+]] = load i128, ptr %arg1
+    // CHECK: store i128 [[LOADED]], ptr [[PASS]]
+    // CHECK: call void @extern_call
+    unsafe { extern_call(arg1) };
+}
+
+// Check that we produce the correct return ABI
+#[no_mangle]
+pub extern "C" fn ret(_arg0: u32, arg1: i128) -> i128 {
+    // WIN-LABEL: @ret(
+    // i128 is returned in xmm0 on Windows
+    // FIXME(#134288): This may change for the `-msvc` targets in the future.
+    // WIN-SAME: i32{{.*}} %_arg0, ptr{{.*}} %arg1)
+    // WIN: [[LOADED:%[_0-9]+]] = load <16 x i8>, ptr %arg1
+    // WIN-NEXT: ret <16 x i8> [[LOADED]]
+    // The softfloat ABI returns this indirectly.
+    // softfloat-LABEL: i128 @ret(i32{{.*}} %_arg0, ptr{{.*}} %arg1)
+    arg1
+}
+
+// Check that we consume the correct return ABI
+#[no_mangle]
+pub extern "C" fn forward(dst: *mut i128) {
+    // CHECK-LABEL: @forward
+    // WIN-SAME: ptr{{.*}} %dst)
+    // WIN: [[RETURNED:%[_0-9]+]] = tail call <16 x i8> @extern_ret()
+    // WIN: store <16 x i8> [[RETURNED]], ptr %dst
+    // WIN: ret void
+    // softfloat: [[RETURNED:%[_0-9]+]] = tail call {{.*}}i128 @extern_ret()
+    unsafe { *dst = extern_ret() };
+}
+
+#[repr(C)]
+struct RetAggregate {
+    a: i32,
+    b: i128,
+}
+
+#[no_mangle]
+pub extern "C" fn ret_aggregate(_arg0: u32, arg1: i128) -> RetAggregate {
+    // CHECK-LABEL: @ret_aggregate(
+    // Aggregates should also be returned indirectly
+    // CHECK-SAME: ptr{{.*}}sret([32 x i8]){{.*}}[[RET:%[_0-9]+]], i32{{.*}}%_arg0, ptr{{.*}}%arg1)
+    // CHECK: [[LOADED:%[_0-9]+]] = load i128, ptr %arg1
+    // CHECK: [[GEP:%[_0-9]+]] = getelementptr{{.*}}, ptr [[RET]]
+    // CHECK: store i128 [[LOADED]], ptr [[GEP]]
+    // CHECK: ret void
+    RetAggregate { a: 1, b: arg1 }
+}
diff --git a/tests/codegen-llvm/infallible-unwrap-in-opt-z.rs b/tests/codegen-llvm/infallible-unwrap-in-opt-z.rs
new file mode 100644
index 00000000000..c2297c58e77
--- /dev/null
+++ b/tests/codegen-llvm/infallible-unwrap-in-opt-z.rs
@@ -0,0 +1,26 @@
+//@ compile-flags: -C opt-level=z
+//@ edition: 2021
+
+#![crate_type = "lib"]
+
+// From <https://github.com/rust-lang/rust/issues/115463>
+
+// CHECK-LABEL: @read_up_to_8(
+#[no_mangle]
+pub fn read_up_to_8(buf: &[u8]) -> u64 {
+    // CHECK-NOT: unwrap_failed
+    if buf.len() < 4 {
+        // actual instance has more code.
+        return 0;
+    }
+    let lo = u32::from_le_bytes(buf[..4].try_into().unwrap()) as u64;
+    let hi = u32::from_le_bytes(buf[buf.len() - 4..][..4].try_into().unwrap()) as u64;
+    lo | (hi << 8 * (buf.len() as u64 - 4))
+}
+
+// CHECK-LABEL: @checking_unwrap_expectation(
+#[no_mangle]
+pub fn checking_unwrap_expectation(buf: &[u8]) -> &[u8; 4] {
+    // CHECK: call void @{{.*core6result13unwrap_failed}}
+    buf.try_into().unwrap()
+}
diff --git a/tests/codegen-llvm/inherit_overflow.rs b/tests/codegen-llvm/inherit_overflow.rs
new file mode 100644
index 00000000000..e4a5ef39fc5
--- /dev/null
+++ b/tests/codegen-llvm/inherit_overflow.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: -Zmir-enable-passes=+Inline,+GVN --crate-type lib
+//@ revisions: ASSERT NOASSERT
+//@[ASSERT] compile-flags: -Coverflow-checks=on
+//@[NOASSERT] compile-flags: -Coverflow-checks=off
+
+// CHECK-LABEL: define{{.*}} @assertion
+// ASSERT: call void @{{.*4core9panicking11panic_const24panic_const_add_overflow}}
+// NOASSERT: ret i8 0
+#[no_mangle]
+pub fn assertion() -> u8 {
+    // Optimized MIR will replace this `CheckedBinaryOp` by `const (0, true)`.
+    // Verify that codegen does or does not emit the panic.
+    <u8 as std::ops::Add>::add(255, 1)
+}
diff --git a/tests/codegen-llvm/inline-always-works-always.rs b/tests/codegen-llvm/inline-always-works-always.rs
new file mode 100644
index 00000000000..07200fd9e37
--- /dev/null
+++ b/tests/codegen-llvm/inline-always-works-always.rs
@@ -0,0 +1,21 @@
+//@ revisions: NO-OPT SIZE-OPT SPEED-OPT
+//@[NO-OPT] compile-flags: -Copt-level=0
+//@[SIZE-OPT] compile-flags: -Copt-level=s
+//@[SPEED-OPT] compile-flags: -Copt-level=3
+
+#![crate_type = "rlib"]
+
+#[no_mangle]
+#[inline(always)]
+pub extern "C" fn callee() -> u32 {
+    4 + 4
+}
+
+// CHECK-LABEL: caller
+// SIZE-OPT: ret i32 8
+// SPEED-OPT: ret i32 8
+// NO-OPT: ret i32 8
+#[no_mangle]
+pub extern "C" fn caller() -> u32 {
+    callee()
+}
diff --git a/tests/codegen-llvm/inline-debuginfo.rs b/tests/codegen-llvm/inline-debuginfo.rs
new file mode 100644
index 00000000000..1e1c9037f5c
--- /dev/null
+++ b/tests/codegen-llvm/inline-debuginfo.rs
@@ -0,0 +1,17 @@
+#![crate_type = "rlib"]
+//@ compile-flags: -Copt-level=3 -g
+//
+
+#[no_mangle]
+#[inline(always)]
+pub extern "C" fn callee(x: u32) -> u32 {
+    x + 4
+}
+
+// CHECK-LABEL: caller
+// CHECK: dbg{{.}}value({{(metadata )?}}i32 %y, {{(metadata )?}}!{{.*}}, {{(metadata )?}}!DIExpression(DW_OP_constu, 3, DW_OP_minus, DW_OP_stack_value){{.*}} [[A:![0-9]+]]
+// CHECK: [[A]] = !DILocation(line: {{.*}}, scope: {{.*}}, inlinedAt: {{.*}})
+#[no_mangle]
+pub extern "C" fn caller(y: u32) -> u32 {
+    callee(y - 3)
+}
diff --git a/tests/codegen-llvm/inline-function-args-debug-info.rs b/tests/codegen-llvm/inline-function-args-debug-info.rs
new file mode 100644
index 00000000000..c31419cb914
--- /dev/null
+++ b/tests/codegen-llvm/inline-function-args-debug-info.rs
@@ -0,0 +1,23 @@
+// This test checks that debug information includes function argument indexes even if the function
+// gets inlined by MIR inlining. Without function argument indexes, `info args` in gdb won't show
+// arguments and their values for the current function.
+
+//@ compile-flags: -Zinline-mir=yes -Cdebuginfo=2
+//@ edition: 2021
+
+#![crate_type = "lib"]
+
+#[inline(never)]
+pub fn outer_function(x: usize, y: usize) -> usize {
+    inner_function(x, y) + 1
+}
+
+#[inline]
+fn inner_function(aaaa: usize, bbbb: usize) -> usize {
+    // CHECK: !DILocalVariable(name: "aaaa", arg: 1
+    // CHECK-SAME: line: 16
+    // CHECK-NOT: !DILexicalBlock(
+    // CHECK: !DILocalVariable(name: "bbbb", arg: 2
+    // CHECK-SAME: line: 16
+    aaaa + bbbb
+}
diff --git a/tests/codegen-llvm/inline-hint.rs b/tests/codegen-llvm/inline-hint.rs
new file mode 100644
index 00000000000..3d46885d5a2
--- /dev/null
+++ b/tests/codegen-llvm/inline-hint.rs
@@ -0,0 +1,31 @@
+// Checks that closures, constructors, and shims except
+// for a drop glue receive inline hint by default.
+//
+//@ compile-flags: -Cno-prepopulate-passes -Csymbol-mangling-version=v0 -Zinline-mir=no
+#![crate_type = "lib"]
+
+pub fn f() {
+    let a = A;
+    let b = (0i32, 1i32, 2i32, 3 as *const i32);
+    let c = || {};
+
+    a(String::new(), String::new());
+    b.clone();
+    c();
+}
+
+struct A(String, String);
+
+// CHECK:      ; core::ptr::drop_in_place::<inline_hint::A>
+// CHECK-NEXT: ; Function Attrs:
+// CHECK-NOT:  inlinehint
+// CHECK-SAME: {{$}}
+
+// CHECK:      ; <(i32, i32, i32, *const i{{16|32|64}}) as core::clone::Clone>::clone
+// CHECK-NEXT: ; Function Attrs: inlinehint
+
+// CHECK:      ; inline_hint::f::{closure#0}
+// CHECK-NEXT: ; Function Attrs: inlinehint
+
+// CHECK:      ; inline_hint::A
+// CHECK-NEXT: ; Function Attrs: inlinehint
diff --git a/tests/codegen-llvm/instrument-coverage/instrument-coverage-off.rs b/tests/codegen-llvm/instrument-coverage/instrument-coverage-off.rs
new file mode 100644
index 00000000000..e44d6c65874
--- /dev/null
+++ b/tests/codegen-llvm/instrument-coverage/instrument-coverage-off.rs
@@ -0,0 +1,21 @@
+// Test that `-Cinstrument-coverage=off` does not add coverage instrumentation to LLVM IR.
+
+//@ compile-flags: -Zno-profiler-runtime
+//@ revisions: n no off false_ zero
+//@ [n] compile-flags: -Cinstrument-coverage=n
+//@ [no] compile-flags: -Cinstrument-coverage=no
+//@ [off] compile-flags: -Cinstrument-coverage=off
+//@ [false_] compile-flags: -Cinstrument-coverage=false
+//@ [zero] compile-flags: -Cinstrument-coverage=0
+
+// CHECK-NOT: __llvm_profile_filename
+// CHECK-NOT: __llvm_coverage_mapping
+
+#![crate_type = "lib"]
+
+#[inline(never)]
+fn some_function() {}
+
+pub fn some_other_function() {
+    some_function();
+}
diff --git a/tests/codegen-llvm/instrument-coverage/instrument-coverage.rs b/tests/codegen-llvm/instrument-coverage/instrument-coverage.rs
new file mode 100644
index 00000000000..23d23651c72
--- /dev/null
+++ b/tests/codegen-llvm/instrument-coverage/instrument-coverage.rs
@@ -0,0 +1,22 @@
+// Test that `-Cinstrument-coverage` creates expected __llvm_profile_filename symbol in LLVM IR.
+
+//@ compile-flags: -Zno-profiler-runtime
+//@ revisions: default y yes on true_ all
+//@ [default] compile-flags: -Cinstrument-coverage
+//@ [y] compile-flags: -Cinstrument-coverage=y
+//@ [yes] compile-flags: -Cinstrument-coverage=yes
+//@ [on] compile-flags: -Cinstrument-coverage=on
+//@ [true_] compile-flags: -Cinstrument-coverage=true
+//@ [all] compile-flags: -Cinstrument-coverage=all
+
+// CHECK-DAG: @__llvm_coverage_mapping
+// CHECK-DAG: @__llvm_profile_filename = {{.*}}"default_%m_%p.profraw\00"{{.*}}
+
+#![crate_type = "lib"]
+
+#[inline(never)]
+fn some_function() {}
+
+pub fn some_other_function() {
+    some_function();
+}
diff --git a/tests/codegen-llvm/instrument-coverage/testprog.rs b/tests/codegen-llvm/instrument-coverage/testprog.rs
new file mode 100644
index 00000000000..9e918499d57
--- /dev/null
+++ b/tests/codegen-llvm/instrument-coverage/testprog.rs
@@ -0,0 +1,118 @@
+//@ edition: 2021
+//@ compile-flags: -Zno-profiler-runtime
+//@ compile-flags: -Cinstrument-coverage -Copt-level=0
+//@ revisions: LINUX DARWIN WIN
+
+//@ [LINUX] only-linux
+//@ [LINUX] filecheck-flags: -DINSTR_PROF_DATA=__llvm_prf_data
+//@ [LINUX] filecheck-flags: -DINSTR_PROF_NAME=__llvm_prf_names
+//@ [LINUX] filecheck-flags: -DINSTR_PROF_CNTS=__llvm_prf_cnts
+//@ [LINUX] filecheck-flags: -DINSTR_PROF_COVMAP=__llvm_covmap
+//@ [LINUX] filecheck-flags: -DINSTR_PROF_COVFUN=__llvm_covfun
+//@ [LINUX] filecheck-flags: '-DCOMDAT_IF_SUPPORTED=, comdat'
+
+//@ [DARWIN] only-apple
+//@ [DARWIN] filecheck-flags: -DINSTR_PROF_DATA=__DATA,__llvm_prf_data,regular,live_support
+//@ [DARWIN] filecheck-flags: -DINSTR_PROF_NAME=__DATA,__llvm_prf_names
+//@ [DARWIN] filecheck-flags: -DINSTR_PROF_CNTS=__DATA,__llvm_prf_cnts
+//@ [DARWIN] filecheck-flags: -DINSTR_PROF_COVMAP=__LLVM_COV,__llvm_covmap
+//@ [DARWIN] filecheck-flags: -DINSTR_PROF_COVFUN=__LLVM_COV,__llvm_covfun
+//@ [DARWIN] filecheck-flags: -DCOMDAT_IF_SUPPORTED=
+
+//@ [WIN] only-windows
+//@ [WIN] filecheck-flags: -DINSTR_PROF_DATA=.lprfd$M
+//@ [WIN] filecheck-flags: -DINSTR_PROF_NAME=.lprfn$M
+//@ [WIN] filecheck-flags: -DINSTR_PROF_CNTS=.lprfc$M
+//@ [WIN] filecheck-flags: -DINSTR_PROF_COVMAP=.lcovmap$M
+//@ [WIN] filecheck-flags: -DINSTR_PROF_COVFUN=.lcovfun$M
+//@ [WIN] filecheck-flags: '-DCOMDAT_IF_SUPPORTED=, comdat'
+
+// ignore-tidy-linelength
+
+pub fn will_be_called() -> &'static str {
+    let val = "called";
+    println!("{}", val);
+    val
+}
+
+pub fn will_not_be_called() -> bool {
+    println!("should not have been called");
+    false
+}
+
+pub fn print<T>(left: &str, value: T, right: &str)
+where
+    T: std::fmt::Display,
+{
+    println!("{}{}{}", left, value, right);
+}
+
+pub fn wrap_with<F, T>(inner: T, should_wrap: bool, wrapper: F)
+where
+    F: FnOnce(&T),
+{
+    if should_wrap {
+        wrapper(&inner)
+    }
+}
+
+fn main() {
+    let less = 1;
+    let more = 100;
+
+    if less < more {
+        wrap_with(will_be_called(), less < more, |inner| print(" ***", inner, "*** "));
+        wrap_with(will_be_called(), more < less, |inner| print(" ***", inner, "*** "));
+    } else {
+        wrap_with(will_not_be_called(), true, |inner| print("wrapped result is: ", inner, ""));
+    }
+}
+
+// Check for metadata, variables, declarations, and function definitions injected
+// into LLVM IR when compiling with -Cinstrument-coverage.
+
+// WIN:          $__llvm_profile_runtime_user = comdat any
+
+// CHECK-DAG:    @__llvm_coverage_mapping = private constant {{.*}}, section "[[INSTR_PROF_COVMAP]]", align 8
+
+// CHECK-DAG:    @__covrec_{{[A-F0-9]+}}u = linkonce_odr hidden constant {{.*}}, section "[[INSTR_PROF_COVFUN]]"[[COMDAT_IF_SUPPORTED]], align 8
+
+// WIN:          @__llvm_profile_runtime = external{{.*}}global i32
+
+// CHECK:        @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called = {{private|internal}} global
+// CHECK-SAME:   section "[[INSTR_PROF_CNTS]]"{{.*}}, align 8
+
+// CHECK:        @__profd__R{{[a-zA-Z0-9_]+}}testprog14will_be_called = {{private|internal}} global
+// CHECK-SAME:   @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called
+// CHECK-SAME:   section "[[INSTR_PROF_DATA]]"{{.*}}, align 8
+
+// CHECK:        @__profc__R{{[a-zA-Z0-9_]+}}testprog4main = {{private|internal}} global
+// CHECK-SAME:   section "[[INSTR_PROF_CNTS]]"{{.*}}, align 8
+
+// CHECK:        @__profd__R{{[a-zA-Z0-9_]+}}testprog4main = {{private|internal}} global
+// CHECK-SAME:   @__profc__R{{[a-zA-Z0-9_]+}}testprog4main
+// CHECK-SAME:   section "[[INSTR_PROF_DATA]]"{{.*}}, align 8
+
+// CHECK:        @__llvm_prf_nm = private constant
+// CHECK-SAME:   section "[[INSTR_PROF_NAME]]", align 1
+
+// CHECK:        @llvm.used = appending global
+// CHECK-SAME:   @__llvm_coverage_mapping
+// CHECK-SAME:   @__llvm_prf_nm
+// CHECK-SAME:   section "llvm.metadata"
+
+// CHECK:        define internal { {{.*}} } @_R{{[a-zA-Z0-9_]+}}testprog14will_be_called() unnamed_addr #{{[0-9]+}} {
+// CHECK-NEXT:   start:
+// CHECK-NOT:    define internal
+// CHECK:        atomicrmw add ptr
+// CHECK-SAME:   @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called,
+
+// CHECK:        declare void @llvm.instrprof.increment(ptr, i64, i32, i32) #[[LLVM_INSTRPROF_INCREMENT_ATTR:[0-9]+]]
+
+// WIN:          define linkonce_odr hidden i32 @__llvm_profile_runtime_user() #[[LLVM_PROFILE_RUNTIME_USER_ATTR:[0-9]+]] comdat {
+// WIN-NEXT:     %1 = load i32, ptr @__llvm_profile_runtime
+// WIN-NEXT:     ret i32 %1
+// WIN-NEXT:     }
+
+// CHECK:        attributes #[[LLVM_INSTRPROF_INCREMENT_ATTR]] = { nounwind }
+// WIN:          attributes #[[LLVM_PROFILE_RUNTIME_USER_ATTR]] = { noinline }
diff --git a/tests/codegen-llvm/instrument-mcount.rs b/tests/codegen-llvm/instrument-mcount.rs
new file mode 100644
index 00000000000..8c97535d4a8
--- /dev/null
+++ b/tests/codegen-llvm/instrument-mcount.rs
@@ -0,0 +1,7 @@
+//
+//@ compile-flags: -Z instrument-mcount -Copt-level=0
+
+#![crate_type = "lib"]
+
+// CHECK: attributes #{{.*}} "frame-pointer"="all" "instrument-function-entry-inlined"="{{.*}}mcount{{.*}}"
+pub fn foo() {}
diff --git a/tests/codegen-llvm/instrument-xray/basic.rs b/tests/codegen-llvm/instrument-xray/basic.rs
new file mode 100644
index 00000000000..7aaebf41e36
--- /dev/null
+++ b/tests/codegen-llvm/instrument-xray/basic.rs
@@ -0,0 +1,9 @@
+// Checks that `-Z instrument-xray` produces expected instrumentation.
+//
+//@ needs-xray
+//@ compile-flags: -Z instrument-xray=always -Copt-level=0
+
+#![crate_type = "lib"]
+
+// CHECK: attributes #{{.*}} "function-instrument"="xray-always"
+pub fn function() {}
diff --git a/tests/codegen-llvm/instrument-xray/options-combine.rs b/tests/codegen-llvm/instrument-xray/options-combine.rs
new file mode 100644
index 00000000000..d1e3b78e6b2
--- /dev/null
+++ b/tests/codegen-llvm/instrument-xray/options-combine.rs
@@ -0,0 +1,12 @@
+// Checks that `-Z instrument-xray` options can be specified multiple times.
+//
+//@ needs-xray
+//@ compile-flags: -Z instrument-xray=skip-exit -Copt-level=0
+//@ compile-flags: -Z instrument-xray=instruction-threshold=123 -Copt-level=0
+//@ compile-flags: -Z instrument-xray=instruction-threshold=456 -Copt-level=0
+
+#![crate_type = "lib"]
+
+// CHECK:      attributes #{{.*}} "xray-instruction-threshold"="456" "xray-skip-exit"
+// CHECK-NOT:  attributes #{{.*}} "xray-instruction-threshold"="123"
+pub fn function() {}
diff --git a/tests/codegen-llvm/instrument-xray/options-override.rs b/tests/codegen-llvm/instrument-xray/options-override.rs
new file mode 100644
index 00000000000..428fb723edb
--- /dev/null
+++ b/tests/codegen-llvm/instrument-xray/options-override.rs
@@ -0,0 +1,11 @@
+// Checks that the last `-Z instrument-xray` option wins.
+//
+//@ needs-xray
+//@ compile-flags: -Z instrument-xray=always -Copt-level=0
+//@ compile-flags: -Z instrument-xray=never -Copt-level=0
+
+#![crate_type = "lib"]
+
+// CHECK:      attributes #{{.*}} "function-instrument"="xray-never"
+// CHECK-NOT:  attributes #{{.*}} "function-instrument"="xray-always"
+pub fn function() {}
diff --git a/tests/codegen-llvm/integer-cmp.rs b/tests/codegen-llvm/integer-cmp.rs
new file mode 100644
index 00000000000..812fa8e4a42
--- /dev/null
+++ b/tests/codegen-llvm/integer-cmp.rs
@@ -0,0 +1,62 @@
+// This is test for more optimal Ord implementation for integers.
+// See <https://github.com/rust-lang/rust/issues/63758> for more info.
+
+//@ revisions: llvm-pre-20 llvm-20
+//@ [llvm-20] min-llvm-version: 20
+//@ [llvm-pre-20] max-llvm-major-version: 19
+//@ compile-flags: -C opt-level=3 -Zmerge-functions=disabled
+
+#![crate_type = "lib"]
+
+use std::cmp::Ordering;
+
+// CHECK-LABEL: @cmp_signed
+#[no_mangle]
+pub fn cmp_signed(a: i64, b: i64) -> Ordering {
+    // llvm-20: call{{.*}} i8 @llvm.scmp.i8.i64
+    // llvm-pre-20: icmp slt
+    // llvm-pre-20: icmp ne
+    // llvm-pre-20: zext i1
+    // llvm-pre-20: select i1
+    a.cmp(&b)
+}
+
+// CHECK-LABEL: @cmp_unsigned
+#[no_mangle]
+pub fn cmp_unsigned(a: u32, b: u32) -> Ordering {
+    // llvm-20: call{{.*}} i8 @llvm.ucmp.i8.i32
+    // llvm-pre-20: icmp ult
+    // llvm-pre-20: icmp ne
+    // llvm-pre-20: zext i1
+    // llvm-pre-20: select i1
+    a.cmp(&b)
+}
+
+// CHECK-LABEL: @cmp_char
+#[no_mangle]
+pub fn cmp_char(a: char, b: char) -> Ordering {
+    // llvm-20: call{{.*}} i8 @llvm.ucmp.i8.i32
+    // llvm-pre-20: icmp ult
+    // llvm-pre-20: icmp ne
+    // llvm-pre-20: zext i1
+    // llvm-pre-20: select i1
+    a.cmp(&b)
+}
+
+// CHECK-LABEL: @cmp_tuple
+#[no_mangle]
+pub fn cmp_tuple(a: (i16, u16), b: (i16, u16)) -> Ordering {
+    // llvm-20-DAG: call{{.*}} i8 @llvm.ucmp.i8.i16
+    // llvm-20-DAG: call{{.*}} i8 @llvm.scmp.i8.i16
+    // llvm-20: ret i8
+    // llvm-pre-20: icmp slt
+    // llvm-pre-20: icmp ne
+    // llvm-pre-20: zext i1
+    // llvm-pre-20: select i1
+    // llvm-pre-20: icmp ult
+    // llvm-pre-20: icmp ne
+    // llvm-pre-20: zext i1
+    // llvm-pre-20: select i1
+    // llvm-pre-20: select i1
+    a.cmp(&b)
+}
diff --git a/tests/codegen-llvm/integer-overflow.rs b/tests/codegen-llvm/integer-overflow.rs
new file mode 100644
index 00000000000..80362247a86
--- /dev/null
+++ b/tests/codegen-llvm/integer-overflow.rs
@@ -0,0 +1,24 @@
+//@ compile-flags: -Copt-level=3 -C overflow-checks=on
+
+#![crate_type = "lib"]
+
+pub struct S1<'a> {
+    data: &'a [u8],
+    position: usize,
+}
+
+// CHECK-LABEL: @slice_no_index_order
+#[no_mangle]
+pub fn slice_no_index_order<'a>(s: &'a mut S1, n: usize) -> &'a [u8] {
+    // CHECK-NOT: slice_index_order_fail
+    let d = &s.data[s.position..s.position + n];
+    s.position += n;
+    return d;
+}
+
+// CHECK-LABEL: @test_check
+#[no_mangle]
+pub fn test_check<'a>(s: &'a mut S1, x: usize, y: usize) -> &'a [u8] {
+    // CHECK: slice_index_order_fail
+    &s.data[x..y]
+}
diff --git a/tests/codegen-llvm/internalize-closures.rs b/tests/codegen-llvm/internalize-closures.rs
new file mode 100644
index 00000000000..f226ea6faac
--- /dev/null
+++ b/tests/codegen-llvm/internalize-closures.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -C no-prepopulate-passes -Zmir-opt-level=0
+
+pub fn main() {
+    // We want to make sure that closures get 'internal' linkage instead of
+    // 'weak_odr' when they are not shared between codegen units
+    // FIXME(eddyb) `legacy` mangling uses `{{closure}}`, while `v0`
+    // uses `{closure#0}`, switch to the latter once `legacy` is gone.
+    // CHECK-LABEL: ; internalize_closures::main::{{.*}}closure
+    // CHECK-NEXT: ; Function Attrs:
+    // CHECK-NEXT: define internal
+    let c = |x: i32| x + 1;
+    let _ = c(1);
+}
diff --git a/tests/codegen-llvm/intrinsic-no-unnamed-attr.rs b/tests/codegen-llvm/intrinsic-no-unnamed-attr.rs
new file mode 100644
index 00000000000..4bec579831d
--- /dev/null
+++ b/tests/codegen-llvm/intrinsic-no-unnamed-attr.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![feature(core_intrinsics)]
+
+use std::intrinsics::sqrtf32;
+
+// CHECK: @llvm.sqrt.f32(float) #{{[0-9]*}}
+
+fn main() {
+    unsafe {
+        sqrtf32(0.0f32);
+    }
+}
diff --git a/tests/codegen-llvm/intrinsics/aggregate-thin-pointer.rs b/tests/codegen-llvm/intrinsics/aggregate-thin-pointer.rs
new file mode 100644
index 00000000000..bd590ce9180
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/aggregate-thin-pointer.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Z mir-enable-passes=-InstSimplify
+//@ only-64bit (so I don't need to worry about usize)
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::aggregate_raw_ptr;
+
+// InstSimplify replaces these with casts if it can, which means they're almost
+// never seen in codegen, but PR#121571 found a way, so add a test for it.
+
+#[inline(never)]
+pub fn opaque(_p: &*const i32) {}
+
+// CHECK-LABEL: @thin_ptr_via_aggregate(
+#[no_mangle]
+pub unsafe fn thin_ptr_via_aggregate(p: *const ()) {
+    // CHECK: %mem = alloca
+    // CHECK: store ptr %p, ptr %mem
+    // CHECK: call {{.+}}aggregate_thin_pointer{{.+}} %mem)
+    let mem = aggregate_raw_ptr(p, ());
+    opaque(&mem);
+}
diff --git a/tests/codegen-llvm/intrinsics/carrying_mul_add.rs b/tests/codegen-llvm/intrinsics/carrying_mul_add.rs
new file mode 100644
index 00000000000..21fb49a3786
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/carrying_mul_add.rs
@@ -0,0 +1,136 @@
+//@ revisions: RAW OPT
+//@ compile-flags: -C opt-level=1
+//@[RAW] compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+#![feature(core_intrinsics_fallbacks)]
+
+// Note that LLVM seems to sometimes permute the order of arguments to mul and add,
+// so these tests don't check the arguments in the optimized revision.
+
+use std::intrinsics::{carrying_mul_add, fallback};
+
+// The fallbacks are emitted even when they're never used, but optimize out.
+
+// RAW: wide_mul_u128
+// OPT-NOT: wide_mul_u128
+
+// CHECK-LABEL: @cma_u8
+#[no_mangle]
+pub unsafe fn cma_u8(a: u8, b: u8, c: u8, d: u8) -> (u8, u8) {
+    // CHECK: [[A:%.+]] = zext i8 %a to i16
+    // CHECK: [[B:%.+]] = zext i8 %b to i16
+    // CHECK: [[C:%.+]] = zext i8 %c to i16
+    // CHECK: [[D:%.+]] = zext i8 %d to i16
+    // CHECK: [[AB:%.+]] = mul nuw i16
+    // RAW-SAME: [[A]], [[B]]
+    // CHECK: [[ABC:%.+]] = add nuw i16
+    // RAW-SAME: [[AB]], [[C]]
+    // CHECK: [[ABCD:%.+]] = add nuw i16
+    // RAW-SAME: [[ABC]], [[D]]
+    // CHECK: [[LOW:%.+]] = trunc i16 [[ABCD]] to i8
+    // CHECK: [[HIGHW:%.+]] = lshr i16 [[ABCD]], 8
+    // RAW: [[HIGH:%.+]] = trunc i16 [[HIGHW]] to i8
+    // OPT: [[HIGH:%.+]] = trunc nuw i16 [[HIGHW]] to i8
+    // CHECK: [[PAIR0:%.+]] = insertvalue { i8, i8 } poison, i8 [[LOW]], 0
+    // CHECK: [[PAIR1:%.+]] = insertvalue { i8, i8 } [[PAIR0]], i8 [[HIGH]], 1
+    // OPT: ret { i8, i8 } [[PAIR1]]
+    carrying_mul_add(a, b, c, d)
+}
+
+// CHECK-LABEL: @cma_u32
+#[no_mangle]
+pub unsafe fn cma_u32(a: u32, b: u32, c: u32, d: u32) -> (u32, u32) {
+    // CHECK: [[A:%.+]] = zext i32 %a to i64
+    // CHECK: [[B:%.+]] = zext i32 %b to i64
+    // CHECK: [[C:%.+]] = zext i32 %c to i64
+    // CHECK: [[D:%.+]] = zext i32 %d to i64
+    // CHECK: [[AB:%.+]] = mul nuw i64
+    // RAW-SAME: [[A]], [[B]]
+    // CHECK: [[ABC:%.+]] = add nuw i64
+    // RAW-SAME: [[AB]], [[C]]
+    // CHECK: [[ABCD:%.+]] = add nuw i64
+    // RAW-SAME: [[ABC]], [[D]]
+    // CHECK: [[LOW:%.+]] = trunc i64 [[ABCD]] to i32
+    // CHECK: [[HIGHW:%.+]] = lshr i64 [[ABCD]], 32
+    // RAW: [[HIGH:%.+]] = trunc i64 [[HIGHW]] to i32
+    // OPT: [[HIGH:%.+]] = trunc nuw i64 [[HIGHW]] to i32
+    // CHECK: [[PAIR0:%.+]] = insertvalue { i32, i32 } poison, i32 [[LOW]], 0
+    // CHECK: [[PAIR1:%.+]] = insertvalue { i32, i32 } [[PAIR0]], i32 [[HIGH]], 1
+    // OPT: ret { i32, i32 } [[PAIR1]]
+    carrying_mul_add(a, b, c, d)
+}
+
+// CHECK-LABEL: @cma_u128
+// CHECK-SAME: sret{{.+}}dereferenceable(32){{.+}}%_0,{{.+}}%a,{{.+}}%b,{{.+}}%c,{{.+}}%d
+#[no_mangle]
+pub unsafe fn cma_u128(a: u128, b: u128, c: u128, d: u128) -> (u128, u128) {
+    // CHECK: [[A:%.+]] = zext i128 %a to i256
+    // CHECK: [[B:%.+]] = zext i128 %b to i256
+    // CHECK: [[C:%.+]] = zext i128 %c to i256
+    // CHECK: [[D:%.+]] = zext i128 %d to i256
+    // CHECK: [[AB:%.+]] = mul nuw i256
+    // RAW-SAME: [[A]], [[B]]
+    // CHECK: [[ABC:%.+]] = add nuw i256
+    // RAW-SAME: [[AB]], [[C]]
+    // CHECK: [[ABCD:%.+]] = add nuw i256
+    // RAW-SAME: [[ABC]], [[D]]
+    // CHECK: [[LOW:%.+]] = trunc i256 [[ABCD]] to i128
+    // CHECK: [[HIGHW:%.+]] = lshr i256 [[ABCD]], 128
+    // RAW: [[HIGH:%.+]] = trunc i256 [[HIGHW]] to i128
+    // OPT: [[HIGH:%.+]] = trunc nuw i256 [[HIGHW]] to i128
+    // RAW: [[PAIR0:%.+]] = insertvalue { i128, i128 } poison, i128 [[LOW]], 0
+    // RAW: [[PAIR1:%.+]] = insertvalue { i128, i128 } [[PAIR0]], i128 [[HIGH]], 1
+    // OPT: store i128 [[LOW]], ptr %_0
+    // OPT: [[P1:%.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %_0, {{i32|i64}} 16
+    // OPT: store i128 [[HIGH]], ptr [[P1]]
+    // CHECK: ret void
+    carrying_mul_add(a, b, c, d)
+}
+
+// CHECK-LABEL: @cma_i128
+// CHECK-SAME: sret{{.+}}dereferenceable(32){{.+}}%_0,{{.+}}%a,{{.+}}%b,{{.+}}%c,{{.+}}%d
+#[no_mangle]
+pub unsafe fn cma_i128(a: i128, b: i128, c: i128, d: i128) -> (u128, i128) {
+    // CHECK: [[A:%.+]] = sext i128 %a to i256
+    // CHECK: [[B:%.+]] = sext i128 %b to i256
+    // CHECK: [[C:%.+]] = sext i128 %c to i256
+    // CHECK: [[D:%.+]] = sext i128 %d to i256
+    // CHECK: [[AB:%.+]] = mul nsw i256
+    // RAW-SAME: [[A]], [[B]]
+    // CHECK: [[ABC:%.+]] = add nsw i256
+    // RAW-SAME: [[AB]], [[C]]
+    // CHECK: [[ABCD:%.+]] = add nsw i256
+    // RAW-SAME: [[ABC]], [[D]]
+    // CHECK: [[LOW:%.+]] = trunc i256 [[ABCD]] to i128
+    // CHECK: [[HIGHW:%.+]] = lshr i256 [[ABCD]], 128
+    // RAW: [[HIGH:%.+]] = trunc i256 [[HIGHW]] to i128
+    // OPT: [[HIGH:%.+]] = trunc nuw i256 [[HIGHW]] to i128
+    // RAW: [[PAIR0:%.+]] = insertvalue { i128, i128 } poison, i128 [[LOW]], 0
+    // RAW: [[PAIR1:%.+]] = insertvalue { i128, i128 } [[PAIR0]], i128 [[HIGH]], 1
+    // OPT: store i128 [[LOW]], ptr %_0
+    // OPT: [[P1:%.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %_0, {{i32|i64}} 16
+    // OPT: store i128 [[HIGH]], ptr [[P1]]
+    // CHECK: ret void
+    carrying_mul_add(a, b, c, d)
+}
+
+// CHECK-LABEL: @fallback_cma_u32
+#[no_mangle]
+pub unsafe fn fallback_cma_u32(a: u32, b: u32, c: u32, d: u32) -> (u32, u32) {
+    // OPT-DAG: [[A:%.+]] = zext i32 %a to i64
+    // OPT-DAG: [[B:%.+]] = zext i32 %b to i64
+    // OPT-DAG: [[AB:%.+]] = mul nuw i64
+    // OPT-DAG: [[C:%.+]] = zext i32 %c to i64
+    // OPT-DAG: [[ABC:%.+]] = add nuw i64{{.+}}[[C]]
+    // OPT-DAG: [[D:%.+]] = zext i32 %d to i64
+    // OPT-DAG: [[ABCD:%.+]] = add nuw i64{{.+}}[[D]]
+    // OPT-DAG: [[LOW:%.+]] = trunc i64 [[ABCD]] to i32
+    // OPT-DAG: [[HIGHW:%.+]] = lshr i64 [[ABCD]], 32
+    // OPT-DAG: [[HIGH:%.+]] = trunc nuw i64 [[HIGHW]] to i32
+    // OPT-DAG: [[PAIR0:%.+]] = insertvalue { i32, i32 } poison, i32 [[LOW]], 0
+    // OPT-DAG: [[PAIR1:%.+]] = insertvalue { i32, i32 } [[PAIR0]], i32 [[HIGH]], 1
+    // OPT-DAG: ret { i32, i32 } [[PAIR1]]
+    fallback::CarryingMulAdd::carrying_mul_add(a, b, c, d)
+}
diff --git a/tests/codegen-llvm/intrinsics/cold_path.rs b/tests/codegen-llvm/intrinsics/cold_path.rs
new file mode 100644
index 00000000000..fd75324b671
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/cold_path.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::cold_path;
+
+#[no_mangle]
+pub fn test_cold_path(x: bool) {
+    cold_path();
+}
+
+// CHECK-LABEL: @test_cold_path(
+// CHECK-NOT: cold_path
diff --git a/tests/codegen-llvm/intrinsics/cold_path2.rs b/tests/codegen-llvm/intrinsics/cold_path2.rs
new file mode 100644
index 00000000000..0891c878fd9
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/cold_path2.rs
@@ -0,0 +1,37 @@
+//@ compile-flags: -O
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::cold_path;
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_a() {
+    println!("path a");
+}
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_b() {
+    println!("path b");
+}
+
+#[no_mangle]
+pub fn test(x: Option<bool>) {
+    if let Some(_) = x {
+        path_a();
+    } else {
+        cold_path();
+        path_b();
+    }
+
+    // CHECK-LABEL: void @test(i8{{.+}}%x)
+    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %x, 2
+    // CHECK: br i1 %[[IS_NONE]], label %bb2, label %bb1, !prof ![[NUM:[0-9]+]]
+    // CHECK: bb1:
+    // CHECK: path_a
+    // CHECK: bb2:
+    // CHECK: path_b
+}
+
+// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 1, i32 2000}
diff --git a/tests/codegen-llvm/intrinsics/cold_path3.rs b/tests/codegen-llvm/intrinsics/cold_path3.rs
new file mode 100644
index 00000000000..bf3347de665
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/cold_path3.rs
@@ -0,0 +1,87 @@
+//@ compile-flags: -O
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::cold_path;
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_a() {
+    println!("path a");
+}
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_b() {
+    println!("path b");
+}
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_c() {
+    println!("path c");
+}
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_d() {
+    println!("path d");
+}
+
+#[no_mangle]
+pub fn test(x: Option<u32>) {
+    match x {
+        Some(0) => path_a(),
+        Some(1) => {
+            cold_path();
+            path_b()
+        }
+        Some(2) => path_c(),
+        Some(3) => {
+            cold_path();
+            path_d()
+        }
+        _ => path_a(),
+    }
+
+    // CHECK-LABEL: @test(
+    // CHECK: switch i32 %1, label %bb1 [
+    // CHECK: i32 0, label %bb6
+    // CHECK: i32 1, label %bb5
+    // CHECK: i32 2, label %bb4
+    // CHECK: i32 3, label %bb3
+    // CHECK: ], !prof ![[NUM1:[0-9]+]]
+}
+
+#[no_mangle]
+pub fn test2(x: Option<u32>) {
+    match x {
+        Some(10) => path_a(),
+        Some(11) => {
+            cold_path();
+            path_b()
+        }
+        Some(12) => {
+            unsafe { core::intrinsics::unreachable() };
+            path_c()
+        }
+        Some(13) => {
+            cold_path();
+            path_d()
+        }
+        _ => {
+            cold_path();
+            path_a()
+        }
+    }
+
+    // CHECK-LABEL: @test2(
+    // CHECK: switch i32 %1, label %bb1 [
+    // CHECK: i32 10, label %bb5
+    // CHECK: i32 11, label %bb4
+    // CHECK: i32 13, label %bb3
+    // CHECK: ], !prof ![[NUM2:[0-9]+]]
+}
+
+// CHECK: ![[NUM1]] = !{!"branch_weights", i32 2000, i32 2000, i32 1, i32 2000, i32 1}
+// CHECK: ![[NUM2]] = !{!"branch_weights", i32 1, i32 2000, i32 1, i32 1}
diff --git a/tests/codegen-llvm/intrinsics/compare_bytes.rs b/tests/codegen-llvm/intrinsics/compare_bytes.rs
new file mode 100644
index 00000000000..3ab0e4e97e0
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/compare_bytes.rs
@@ -0,0 +1,34 @@
+//@ revisions: INT32 INT16
+//@ compile-flags: -Copt-level=3
+//@ [INT32] ignore-16bit
+//@ [INT16] only-16bit
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::compare_bytes;
+
+#[no_mangle]
+// CHECK-LABEL: @bytes_cmp(
+pub unsafe fn bytes_cmp(a: *const u8, b: *const u8, n: usize) -> i32 {
+    // INT32: %[[TEMP:.+]] = tail call i32 @memcmp(ptr %a, ptr %b, {{i32|i64}} %n)
+    // INT32-NOT: sext
+    // INT32: ret i32 %[[TEMP]]
+
+    // INT16: %[[TEMP1:.+]] = tail call i16 @memcmp(ptr %a, ptr %b, i16 %n)
+    // INT16: %[[TEMP2:.+]] = sext i16 %[[TEMP1]] to i32
+    // INT16: ret i32 %[[TEMP2]]
+    compare_bytes(a, b, n)
+}
+
+// Ensure that, even though there's an `sext` emitted by the intrinsic,
+// that doesn't end up pessiming checks against zero.
+#[no_mangle]
+// CHECK-LABEL: @bytes_eq(
+pub unsafe fn bytes_eq(a: *const u8, b: *const u8, n: usize) -> bool {
+    // CHECK: call {{.+}} @{{bcmp|memcmp}}(ptr %a, ptr %b, {{i16|i32|i64}} %n)
+    // CHECK-NOT: sext
+    // INT32: icmp eq i32
+    // INT16: icmp eq i16
+    compare_bytes(a, b, n) == 0_i32
+}
diff --git a/tests/codegen-llvm/intrinsics/const_eval_select.rs b/tests/codegen-llvm/intrinsics/const_eval_select.rs
new file mode 100644
index 00000000000..baa985b00cd
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/const_eval_select.rs
@@ -0,0 +1,22 @@
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(const_eval_select)]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::const_eval_select;
+
+const fn foo(_: i32) -> i32 {
+    1
+}
+
+#[no_mangle]
+pub fn hi(n: i32) -> i32 {
+    n
+}
+
+#[no_mangle]
+pub unsafe fn hey() {
+    // CHECK: call i32 @hi(i32
+    const_eval_select((42,), foo, hi);
+}
diff --git a/tests/codegen-llvm/intrinsics/ctlz.rs b/tests/codegen-llvm/intrinsics/ctlz.rs
new file mode 100644
index 00000000000..0d54d21ce12
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/ctlz.rs
@@ -0,0 +1,56 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::{ctlz, ctlz_nonzero};
+
+// CHECK-LABEL: @ctlz_u16
+#[no_mangle]
+pub unsafe fn ctlz_u16(x: u16) -> u32 {
+    // CHECK: %[[tmp:.*]] = call i16 @llvm.ctlz.i16(i16 %x, i1 false)
+    // CHECK: zext i16 %[[tmp]] to i32
+    ctlz(x)
+}
+
+// CHECK-LABEL: @ctlz_nzu16
+#[no_mangle]
+pub unsafe fn ctlz_nzu16(x: u16) -> u32 {
+    // CHECK: %[[tmp:.*]] = call i16 @llvm.ctlz.i16(i16 %x, i1 true)
+    // CHECK: zext i16 %[[tmp]] to i32
+    ctlz_nonzero(x)
+}
+
+// CHECK-LABEL: @ctlz_u32
+#[no_mangle]
+pub unsafe fn ctlz_u32(x: u32) -> u32 {
+    // CHECK: call i32 @llvm.ctlz.i32(i32 %x, i1 false)
+    // CHECK-NOT: zext
+    // CHECK-NOT: trunc
+    ctlz(x)
+}
+
+// CHECK-LABEL: @ctlz_nzu32
+#[no_mangle]
+pub unsafe fn ctlz_nzu32(x: u32) -> u32 {
+    // CHECK: call i32 @llvm.ctlz.i32(i32 %x, i1 true)
+    // CHECK-NOT: zext
+    // CHECK-NOT: trunc
+    ctlz_nonzero(x)
+}
+
+// CHECK-LABEL: @ctlz_u64
+#[no_mangle]
+pub unsafe fn ctlz_u64(x: u64) -> u32 {
+    // CHECK: %[[tmp:.*]] = call i64 @llvm.ctlz.i64(i64 %x, i1 false)
+    // CHECK: trunc i64 %[[tmp]] to i32
+    ctlz(x)
+}
+
+// CHECK-LABEL: @ctlz_nzu64
+#[no_mangle]
+pub unsafe fn ctlz_nzu64(x: u64) -> u32 {
+    // CHECK: %[[tmp:.*]] = call i64 @llvm.ctlz.i64(i64 %x, i1 true)
+    // CHECK: trunc i64 %[[tmp]] to i32
+    ctlz_nonzero(x)
+}
diff --git a/tests/codegen-llvm/intrinsics/ctpop.rs b/tests/codegen-llvm/intrinsics/ctpop.rs
new file mode 100644
index 00000000000..f4043325de9
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/ctpop.rs
@@ -0,0 +1,31 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::ctpop;
+
+// CHECK-LABEL: @ctpop_u16
+#[no_mangle]
+pub unsafe fn ctpop_u16(x: u16) -> u32 {
+    // CHECK: %[[tmp:.*]] = call i16 @llvm.ctpop.i16(i16 %x)
+    // CHECK: zext i16 %[[tmp]] to i32
+    ctpop(x)
+}
+
+// CHECK-LABEL: @ctpop_u32
+#[no_mangle]
+pub unsafe fn ctpop_u32(x: u32) -> u32 {
+    // CHECK: call i32 @llvm.ctpop.i32(i32 %x)
+    // CHECK-NOT: zext
+    // CHECK-NOT: trunc
+    ctpop(x)
+}
+
+// CHECK-LABEL: @ctpop_u64
+#[no_mangle]
+pub unsafe fn ctpop_u64(x: u64) -> u32 {
+    // CHECK: %[[tmp:.*]] = call i64 @llvm.ctpop.i64(i64 %x)
+    // CHECK: trunc i64 %[[tmp]] to i32
+    ctpop(x)
+}
diff --git a/tests/codegen-llvm/intrinsics/disjoint_bitor.rs b/tests/codegen-llvm/intrinsics/disjoint_bitor.rs
new file mode 100644
index 00000000000..fc45439ee0b
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/disjoint_bitor.rs
@@ -0,0 +1,30 @@
+//@ compile-flags: -C no-prepopulate-passes -Z mir-opt-level=0
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::disjoint_bitor;
+
+// CHECK-LABEL: @disjoint_bitor_signed
+#[no_mangle]
+pub unsafe fn disjoint_bitor_signed(x: i32, y: i32) -> i32 {
+    // CHECK: or disjoint i32 %x, %y
+    disjoint_bitor(x, y)
+}
+
+// CHECK-LABEL: @disjoint_bitor_unsigned
+#[no_mangle]
+pub unsafe fn disjoint_bitor_unsigned(x: u64, y: u64) -> u64 {
+    // CHECK: or disjoint i64 %x, %y
+    disjoint_bitor(x, y)
+}
+
+// CHECK-LABEL: @disjoint_bitor_literal
+#[no_mangle]
+pub unsafe fn disjoint_bitor_literal() -> u8 {
+    // This is a separate check because even without any passes,
+    // LLVM will fold so it's not an instruction, which can assert in LLVM.
+
+    // CHECK: store i8 3
+    disjoint_bitor(1, 2)
+}
diff --git a/tests/codegen-llvm/intrinsics/exact_div.rs b/tests/codegen-llvm/intrinsics/exact_div.rs
new file mode 100644
index 00000000000..dc625ba7fe4
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/exact_div.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::exact_div;
+
+// CHECK-LABEL: @exact_sdiv
+#[no_mangle]
+pub unsafe fn exact_sdiv(x: i32, y: i32) -> i32 {
+    // CHECK: sdiv exact
+    exact_div(x, y)
+}
+
+// CHECK-LABEL: @exact_udiv
+#[no_mangle]
+pub unsafe fn exact_udiv(x: u32, y: u32) -> u32 {
+    // CHECK: udiv exact
+    exact_div(x, y)
+}
diff --git a/tests/codegen-llvm/intrinsics/likely.rs b/tests/codegen-llvm/intrinsics/likely.rs
new file mode 100644
index 00000000000..c5e3c466f45
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/likely.rs
@@ -0,0 +1,35 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::likely;
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_a() {
+    println!("path a");
+}
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_b() {
+    println!("path b");
+}
+
+#[no_mangle]
+pub fn test_likely(x: bool) {
+    if likely(x) {
+        path_a();
+    } else {
+        path_b();
+    }
+}
+
+// CHECK-LABEL: @test_likely(
+// CHECK: br i1 %x, label %bb2, label %bb3, !prof ![[NUM:[0-9]+]]
+// CHECK: bb3:
+// CHECK-NOT: cold_path
+// CHECK: path_b
+// CHECK: bb2:
+// CHECK: path_a
+// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 2000, i32 1}
diff --git a/tests/codegen-llvm/intrinsics/likely_assert.rs b/tests/codegen-llvm/intrinsics/likely_assert.rs
new file mode 100644
index 00000000000..87ffb4ee3fb
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/likely_assert.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn test_assert(x: bool) {
+    assert!(x);
+}
+
+// check that assert! emits branch weights
+
+// CHECK-LABEL: @test_assert(
+// CHECK: br i1 %x, label %bb2, label %bb1, !prof ![[NUM:[0-9]+]]
+// CHECK: bb1:
+// CHECK: panic
+// CHECK: bb2:
+// CHECK: ret void
+// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 2000, i32 1}
diff --git a/tests/codegen-llvm/intrinsics/mask.rs b/tests/codegen-llvm/intrinsics/mask.rs
new file mode 100644
index 00000000000..5344274678c
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/mask.rs
@@ -0,0 +1,12 @@
+//@ compile-flags: -Copt-level=0
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+// CHECK-LABEL: @mask_ptr
+// CHECK-SAME: [[WORD:i[0-9]+]] %mask
+#[no_mangle]
+pub fn mask_ptr(ptr: *const u16, mask: usize) -> *const u16 {
+    // CHECK: call
+    // CHECK-SAME: @llvm.ptrmask.{{p0|p0i8}}.[[WORD]](ptr {{%ptr|%1}}, [[WORD]] %mask)
+    core::intrinsics::ptr_mask(ptr, mask)
+}
diff --git a/tests/codegen-llvm/intrinsics/nontemporal.rs b/tests/codegen-llvm/intrinsics/nontemporal.rs
new file mode 100644
index 00000000000..a151d4bd297
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/nontemporal.rs
@@ -0,0 +1,32 @@
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3
+//@revisions: with_nontemporal without_nontemporal
+//@[with_nontemporal] compile-flags: --target aarch64-unknown-linux-gnu
+//@[with_nontemporal] needs-llvm-components: aarch64
+//@[without_nontemporal] compile-flags: --target x86_64-unknown-linux-gnu
+//@[without_nontemporal] needs-llvm-components: x86
+
+// Ensure that we *do* emit the `!nontemporal` flag on architectures where it
+// is well-behaved, but do *not* emit it on architectures where it is ill-behaved.
+// For more context, see <https://github.com/rust-lang/rust/issues/114582> and
+// <https://github.com/llvm/llvm-project/issues/64521>.
+
+#![feature(no_core, lang_items, intrinsics)]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+#[rustc_intrinsic]
+pub unsafe fn nontemporal_store<T>(ptr: *mut T, val: T);
+
+#[no_mangle]
+pub fn a(a: &mut u32, b: u32) {
+    // CHECK-LABEL: define{{.*}}void @a
+    // with_nontemporal: store i32 %b, ptr %a, align 4, !nontemporal
+    // without_nontemporal-NOT: nontemporal
+    unsafe {
+        nontemporal_store(a, b);
+    }
+}
diff --git a/tests/codegen-llvm/intrinsics/offset.rs b/tests/codegen-llvm/intrinsics/offset.rs
new file mode 100644
index 00000000000..cf0c7c7ac7d
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/offset.rs
@@ -0,0 +1,33 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::offset;
+
+// CHECK-LABEL: ptr @offset_zst
+// CHECK-SAME: (ptr noundef %p, [[SIZE:i[0-9]+]] noundef %d)
+#[no_mangle]
+pub unsafe fn offset_zst(p: *const (), d: usize) -> *const () {
+    // CHECK-NOT: getelementptr
+    // CHECK: ret ptr %p
+    offset(p, d)
+}
+
+// CHECK-LABEL: ptr @offset_isize
+// CHECK-SAME: (ptr noundef %p, [[SIZE]] noundef %d)
+#[no_mangle]
+pub unsafe fn offset_isize(p: *const u32, d: isize) -> *const u32 {
+    // CHECK: %[[R:.*]] = getelementptr inbounds i32, ptr %p, [[SIZE]] %d
+    // CHECK-NEXT: ret ptr %[[R]]
+    offset(p, d)
+}
+
+// CHECK-LABEL: ptr @offset_usize
+// CHECK-SAME: (ptr noundef %p, [[SIZE]] noundef %d)
+#[no_mangle]
+pub unsafe fn offset_usize(p: *const u64, d: usize) -> *const u64 {
+    // CHECK: %[[R:.*]] = getelementptr inbounds{{( nuw)?}} i64, ptr %p, [[SIZE]] %d
+    // CHECK-NEXT: ret ptr %[[R]]
+    offset(p, d)
+}
diff --git a/tests/codegen-llvm/intrinsics/offset_from.rs b/tests/codegen-llvm/intrinsics/offset_from.rs
new file mode 100644
index 00000000000..ef1a77ef184
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/offset_from.rs
@@ -0,0 +1,36 @@
+//@ compile-flags: -C opt-level=1
+//@ only-64bit (because we're using [ui]size)
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+//! Basic optimizations are enabled because otherwise `x86_64-gnu-nopt` had an alloca.
+//! Uses a type with non-power-of-two size to avoid normalizations to shifts.
+
+use std::intrinsics::*;
+
+type RGB = [u8; 3];
+
+// CHECK-LABEL: @offset_from_odd_size
+#[no_mangle]
+pub unsafe fn offset_from_odd_size(a: *const RGB, b: *const RGB) -> isize {
+    // CHECK: start
+    // CHECK-NEXT: ptrtoint
+    // CHECK-NEXT: ptrtoint
+    // CHECK-NEXT: sub i64
+    // CHECK-NEXT: sdiv exact i64 %{{[0-9]+}}, 3
+    // CHECK-NEXT: ret i64
+    ptr_offset_from(a, b)
+}
+
+// CHECK-LABEL: @offset_from_unsigned_odd_size
+#[no_mangle]
+pub unsafe fn offset_from_unsigned_odd_size(a: *const RGB, b: *const RGB) -> usize {
+    // CHECK: start
+    // CHECK-NEXT: ptrtoint
+    // CHECK-NEXT: ptrtoint
+    // CHECK-NEXT: sub nuw i64
+    // CHECK-NEXT: udiv exact i64 %{{[0-9]+}}, 3
+    // CHECK-NEXT: ret i64
+    ptr_offset_from_unsigned(a, b)
+}
diff --git a/tests/codegen-llvm/intrinsics/prefetch.rs b/tests/codegen-llvm/intrinsics/prefetch.rs
new file mode 100644
index 00000000000..3f9f21c85cb
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/prefetch.rs
@@ -0,0 +1,64 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::{
+    prefetch_read_data, prefetch_read_instruction, prefetch_write_data, prefetch_write_instruction,
+};
+
+#[no_mangle]
+pub fn check_prefetch_read_data(data: &[i8]) {
+    unsafe {
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 0, i32 1)
+        prefetch_read_data(data.as_ptr(), 0);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 1, i32 1)
+        prefetch_read_data(data.as_ptr(), 1);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 2, i32 1)
+        prefetch_read_data(data.as_ptr(), 2);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 3, i32 1)
+        prefetch_read_data(data.as_ptr(), 3);
+    }
+}
+
+#[no_mangle]
+pub fn check_prefetch_write_data(data: &[i8]) {
+    unsafe {
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 0, i32 1)
+        prefetch_write_data(data.as_ptr(), 0);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 1, i32 1)
+        prefetch_write_data(data.as_ptr(), 1);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 2, i32 1)
+        prefetch_write_data(data.as_ptr(), 2);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 3, i32 1)
+        prefetch_write_data(data.as_ptr(), 3);
+    }
+}
+
+#[no_mangle]
+pub fn check_prefetch_read_instruction(data: &[i8]) {
+    unsafe {
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 0, i32 0)
+        prefetch_read_instruction(data.as_ptr(), 0);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 1, i32 0)
+        prefetch_read_instruction(data.as_ptr(), 1);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 2, i32 0)
+        prefetch_read_instruction(data.as_ptr(), 2);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 3, i32 0)
+        prefetch_read_instruction(data.as_ptr(), 3);
+    }
+}
+
+#[no_mangle]
+pub fn check_prefetch_write_instruction(data: &[i8]) {
+    unsafe {
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 0, i32 0)
+        prefetch_write_instruction(data.as_ptr(), 0);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 1, i32 0)
+        prefetch_write_instruction(data.as_ptr(), 1);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 2, i32 0)
+        prefetch_write_instruction(data.as_ptr(), 2);
+        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 3, i32 0)
+        prefetch_write_instruction(data.as_ptr(), 3);
+    }
+}
diff --git a/tests/codegen-llvm/intrinsics/ptr_metadata.rs b/tests/codegen-llvm/intrinsics/ptr_metadata.rs
new file mode 100644
index 00000000000..044dbc20486
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/ptr_metadata.rs
@@ -0,0 +1,36 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Z inline-mir
+//@ only-64bit (so I don't need to worry about usize)
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::ptr_metadata;
+
+// CHECK-LABEL: @thin_metadata(
+#[no_mangle]
+pub fn thin_metadata(p: *const ()) {
+    // CHECK: start
+    // CHECK-NEXT: ret void
+    ptr_metadata(p)
+}
+
+// CHECK-LABEL: @slice_metadata(
+#[no_mangle]
+pub fn slice_metadata(p: *const [u8]) -> usize {
+    // CHECK: start
+    // CHECK-NEXT: ret i64 %p.1
+    ptr_metadata(p)
+}
+
+// CHECK-LABEL: @dyn_byte_offset(
+#[no_mangle]
+pub unsafe fn dyn_byte_offset(
+    p: *const dyn std::fmt::Debug,
+    n: usize,
+) -> *const dyn std::fmt::Debug {
+    // CHECK: %[[Q:.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %p.0, i64 %n
+    // CHECK: %[[TEMP1:.+]] = insertvalue { ptr, ptr } poison, ptr %[[Q]], 0
+    // CHECK: %[[TEMP2:.+]] = insertvalue { ptr, ptr } %[[TEMP1]], ptr %p.1, 1
+    // CHECK: ret { ptr, ptr } %[[TEMP2]]
+    p.byte_add(n)
+}
diff --git a/tests/codegen-llvm/intrinsics/rotate_left.rs b/tests/codegen-llvm/intrinsics/rotate_left.rs
new file mode 100644
index 00000000000..4f6c5cbaed6
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/rotate_left.rs
@@ -0,0 +1,31 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::rotate_left;
+
+// CHECK-LABEL: @rotate_left_u16
+#[no_mangle]
+pub unsafe fn rotate_left_u16(x: u16, shift: u32) -> u16 {
+    // CHECK: %[[tmp:.*]] = trunc i32 %shift to i16
+    // CHECK: call i16 @llvm.fshl.i16(i16 %x, i16 %x, i16 %[[tmp]])
+    rotate_left(x, shift)
+}
+
+// CHECK-LABEL: @rotate_left_u32
+#[no_mangle]
+pub unsafe fn rotate_left_u32(x: u32, shift: u32) -> u32 {
+    // CHECK-NOT: trunc
+    // CHECK-NOT: zext
+    // CHECK: call i32 @llvm.fshl.i32(i32 %x, i32 %x, i32 %shift)
+    rotate_left(x, shift)
+}
+
+// CHECK-LABEL: @rotate_left_u64
+#[no_mangle]
+pub unsafe fn rotate_left_u64(x: u64, shift: u32) -> u64 {
+    // CHECK: %[[tmp:.*]] = zext i32 %shift to i64
+    // CHECK: call i64 @llvm.fshl.i64(i64 %x, i64 %x, i64 %[[tmp]])
+    rotate_left(x, shift)
+}
diff --git a/tests/codegen-llvm/intrinsics/rustc_intrinsic_must_be_overridden.rs b/tests/codegen-llvm/intrinsics/rustc_intrinsic_must_be_overridden.rs
new file mode 100644
index 00000000000..b41e441d309
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/rustc_intrinsic_must_be_overridden.rs
@@ -0,0 +1,14 @@
+//@ revisions: OPT0 OPT1
+//@ [OPT0] compile-flags: -Copt-level=0
+//@ [OPT1] compile-flags: -Copt-level=1
+//@ compile-flags: -Cno-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+// CHECK-NOT: core::intrinsics::size_of_val
+
+#[no_mangle]
+pub unsafe fn size_of_val(ptr: *const i32) -> usize {
+    core::intrinsics::size_of_val(ptr)
+}
diff --git a/tests/codegen-llvm/intrinsics/select_unpredictable.rs b/tests/codegen-llvm/intrinsics/select_unpredictable.rs
new file mode 100644
index 00000000000..ad7120c6fb8
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/select_unpredictable.rs
@@ -0,0 +1,71 @@
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+
+#![feature(core_intrinsics)]
+#![crate_type = "lib"]
+
+/* Test the intrinsic */
+
+#[no_mangle]
+pub fn test_int(p: bool, a: u64, b: u64) -> u64 {
+    // CHECK-LABEL: define{{.*}} @test_int
+    // CHECK: select i1 %p, i64 %a, i64 %b, !unpredictable
+    core::intrinsics::select_unpredictable(p, a, b)
+}
+
+#[no_mangle]
+pub fn test_pair(p: bool, a: (u64, u64), b: (u64, u64)) -> (u64, u64) {
+    // CHECK-LABEL: define{{.*}} @test_pair
+    // CHECK: select i1 %p, {{.*}}, !unpredictable
+    core::intrinsics::select_unpredictable(p, a, b)
+}
+
+struct Large {
+    e: [u64; 100],
+}
+
+#[no_mangle]
+pub fn test_struct(p: bool, a: Large, b: Large) -> Large {
+    // CHECK-LABEL: define{{.*}} @test_struct
+    // CHECK: select i1 %p, {{.*}}, !unpredictable
+    core::intrinsics::select_unpredictable(p, a, b)
+}
+
+// ZSTs should not need a `select` expression.
+#[no_mangle]
+pub fn test_zst(p: bool, a: (), b: ()) -> () {
+    // CHECK-LABEL: define{{.*}} @test_zst
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret void
+    core::intrinsics::select_unpredictable(p, a, b)
+}
+
+/* Test the user-facing version */
+
+#[no_mangle]
+pub fn test_int2(p: bool, a: u64, b: u64) -> u64 {
+    // CHECK-LABEL: define{{.*}} @test_int2
+    // CHECK: select i1 %p, i64 %a, i64 %b, !unpredictable
+    core::hint::select_unpredictable(p, a, b)
+}
+
+#[no_mangle]
+pub fn test_pair2(p: bool, a: (u64, u64), b: (u64, u64)) -> (u64, u64) {
+    // CHECK-LABEL: define{{.*}} @test_pair2
+    // CHECK: select i1 %p, {{.*}}, !unpredictable
+    core::hint::select_unpredictable(p, a, b)
+}
+
+#[no_mangle]
+pub fn test_struct2(p: bool, a: Large, b: Large) -> Large {
+    // CHECK-LABEL: define{{.*}} @test_struct2
+    // CHECK: select i1 %p, {{.*}}, !unpredictable
+    core::hint::select_unpredictable(p, a, b)
+}
+
+#[no_mangle]
+pub fn test_zst2(p: bool, a: (), b: ()) -> () {
+    // CHECK-LABEL: define{{.*}} @test_zst2
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret void
+    core::hint::select_unpredictable(p, a, b)
+}
diff --git a/tests/codegen-llvm/intrinsics/three_way_compare.rs b/tests/codegen-llvm/intrinsics/three_way_compare.rs
new file mode 100644
index 00000000000..95fcb636f7c
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/three_way_compare.rs
@@ -0,0 +1,28 @@
+//@ revisions: DEBUG OPTIM
+//@ [DEBUG] compile-flags: -C opt-level=0
+//@ [OPTIM] compile-flags: -C opt-level=3
+//@ compile-flags: -C no-prepopulate-passes
+//@ min-llvm-version: 20
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::three_way_compare;
+
+#[no_mangle]
+// CHECK-LABEL: @signed_cmp
+// CHECK-SAME: (i16{{.*}} %a, i16{{.*}} %b)
+pub fn signed_cmp(a: i16, b: i16) -> std::cmp::Ordering {
+    // CHECK: %[[CMP:.+]] = call i8 @llvm.scmp.i8.i16(i16 %a, i16 %b)
+    // CHECK-NEXT: ret i8 %[[CMP]]
+    three_way_compare(a, b)
+}
+
+#[no_mangle]
+// CHECK-LABEL: @unsigned_cmp
+// CHECK-SAME: (i16{{.*}} %a, i16{{.*}} %b)
+pub fn unsigned_cmp(a: u16, b: u16) -> std::cmp::Ordering {
+    // CHECK: %[[CMP:.+]] = call i8 @llvm.ucmp.i8.i16(i16 %a, i16 %b)
+    // CHECK-NEXT: ret i8 %[[CMP]]
+    three_way_compare(a, b)
+}
diff --git a/tests/codegen-llvm/intrinsics/transmute-niched.rs b/tests/codegen-llvm/intrinsics/transmute-niched.rs
new file mode 100644
index 00000000000..8ff5cc8ee4f
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/transmute-niched.rs
@@ -0,0 +1,223 @@
+//@ revisions: OPT DBG
+//@ [OPT] compile-flags: -C opt-level=3 -C no-prepopulate-passes
+//@ [DBG] compile-flags: -C opt-level=0 -C no-prepopulate-passes
+//@ only-64bit (so I don't need to worry about usize)
+#![crate_type = "lib"]
+
+use std::mem::transmute;
+use std::num::NonZero;
+use std::ptr::NonNull;
+
+#[repr(u8)]
+pub enum SmallEnum {
+    A = 10,
+    B = 11,
+    C = 12,
+}
+
+// CHECK-LABEL: @check_to_enum(
+#[no_mangle]
+pub unsafe fn check_to_enum(x: i8) -> SmallEnum {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // OPT: %0 = sub i8 %x, 10
+    // OPT: %1 = icmp ule i8 %0, 2
+    // OPT: call void @llvm.assume(i1 %1)
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // CHECK: ret i8 %x
+
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_from_enum(
+#[no_mangle]
+pub unsafe fn check_from_enum(x: SmallEnum) -> i8 {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // OPT: %0 = sub i8 %x, 10
+    // OPT: %1 = icmp ule i8 %0, 2
+    // OPT: call void @llvm.assume(i1 %1)
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // CHECK: ret i8 %x
+
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_to_ordering(
+#[no_mangle]
+pub unsafe fn check_to_ordering(x: u8) -> std::cmp::Ordering {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // OPT: %0 = sub i8 %x, -1
+    // OPT: %1 = icmp ule i8 %0, 2
+    // OPT: call void @llvm.assume(i1 %1)
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // CHECK: ret i8 %x
+
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_from_ordering(
+#[no_mangle]
+pub unsafe fn check_from_ordering(x: std::cmp::Ordering) -> u8 {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // OPT: %0 = sub i8 %x, -1
+    // OPT: %1 = icmp ule i8 %0, 2
+    // OPT: call void @llvm.assume(i1 %1)
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // CHECK: ret i8 %x
+
+    transmute(x)
+}
+
+#[repr(i32)]
+pub enum Minus100ToPlus100 {
+    A = -100,
+    B = -90,
+    C = -80,
+    D = -70,
+    E = -60,
+    F = -50,
+    G = -40,
+    H = -30,
+    I = -20,
+    J = -10,
+    K = 0,
+    L = 10,
+    M = 20,
+    N = 30,
+    O = 40,
+    P = 50,
+    Q = 60,
+    R = 70,
+    S = 80,
+    T = 90,
+    U = 100,
+}
+
+// CHECK-LABEL: @check_enum_from_char(
+#[no_mangle]
+pub unsafe fn check_enum_from_char(x: char) -> Minus100ToPlus100 {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // OPT: %0 = icmp ule i32 %x, 1114111
+    // OPT: call void @llvm.assume(i1 %0)
+    // OPT: %1 = sub i32 %x, -100
+    // OPT: %2 = icmp ule i32 %1, 200
+    // OPT: call void @llvm.assume(i1 %2)
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // CHECK: ret i32 %x
+
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_enum_to_char(
+#[no_mangle]
+pub unsafe fn check_enum_to_char(x: Minus100ToPlus100) -> char {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // OPT: %0 = sub i32 %x, -100
+    // OPT: %1 = icmp ule i32 %0, 200
+    // OPT: call void @llvm.assume(i1 %1)
+    // OPT: %2 = icmp ule i32 %x, 1114111
+    // OPT: call void @llvm.assume(i1 %2)
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // CHECK: ret i32 %x
+
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_swap_pair(
+#[no_mangle]
+pub unsafe fn check_swap_pair(x: (char, NonZero<u32>)) -> (NonZero<u32>, char) {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // OPT: %0 = icmp ule i32 %x.0, 1114111
+    // OPT: call void @llvm.assume(i1 %0)
+    // OPT: %1 = sub i32 %x.0, 1
+    // OPT: %2 = icmp ule i32 %1, -2
+    // OPT: call void @llvm.assume(i1 %2)
+    // OPT: %3 = sub i32 %x.1, 1
+    // OPT: %4 = icmp ule i32 %3, -2
+    // OPT: call void @llvm.assume(i1 %4)
+    // OPT: %5 = icmp ule i32 %x.1, 1114111
+    // OPT: call void @llvm.assume(i1 %5)
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // CHECK: %[[P1:.+]] = insertvalue { i32, i32 } poison, i32 %x.0, 0
+    // CHECK: %[[P2:.+]] = insertvalue { i32, i32 } %[[P1]], i32 %x.1, 1
+    // CHECK: ret { i32, i32 } %[[P2]]
+
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_bool_from_ordering(
+#[no_mangle]
+pub unsafe fn check_bool_from_ordering(x: std::cmp::Ordering) -> bool {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // OPT: %0 = sub i8 %x, -1
+    // OPT: %1 = icmp ule i8 %0, 2
+    // OPT: call void @llvm.assume(i1 %1)
+    // OPT: %2 = icmp ule i8 %x, 1
+    // OPT: call void @llvm.assume(i1 %2)
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // CHECK: %[[R:.+]] = trunc{{( nuw)?}} i8 %x to i1
+    // CHECK: ret i1 %[[R]]
+
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_bool_to_ordering(
+#[no_mangle]
+pub unsafe fn check_bool_to_ordering(x: bool) -> std::cmp::Ordering {
+    // CHECK: %_0 = zext i1 %x to i8
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // OPT: %0 = icmp ule i8 %_0, 1
+    // OPT: call void @llvm.assume(i1 %0)
+    // OPT: %1 = sub i8 %_0, -1
+    // OPT: %2 = icmp ule i8 %1, 2
+    // OPT: call void @llvm.assume(i1 %2)
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // CHECK: ret i8 %_0
+
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_nonnull_to_ptr(
+#[no_mangle]
+pub unsafe fn check_nonnull_to_ptr(x: NonNull<u8>) -> *const u8 {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // OPT: %0 = icmp ne ptr %x, null
+    // OPT: call void @llvm.assume(i1 %0)
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // CHECK: ret ptr %x
+
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_ptr_to_nonnull(
+#[no_mangle]
+pub unsafe fn check_ptr_to_nonnull(x: *const u8) -> NonNull<u8> {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // OPT: %0 = icmp ne ptr %x, null
+    // OPT: call void @llvm.assume(i1 %0)
+    // CHECK-NOT: icmp
+    // CHECK-NOT: assume
+    // CHECK: ret ptr %x
+
+    transmute(x)
+}
diff --git a/tests/codegen-llvm/intrinsics/transmute-x64.rs b/tests/codegen-llvm/intrinsics/transmute-x64.rs
new file mode 100644
index 00000000000..8c9480ab091
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/transmute-x64.rs
@@ -0,0 +1,28 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+//@ only-x86_64 (it's using arch-specific types)
+
+#![crate_type = "lib"]
+
+use std::arch::x86_64::{__m128, __m128i, __m256i};
+use std::mem::transmute;
+
+// CHECK-LABEL: @check_sse_pair_to_avx(
+#[no_mangle]
+pub unsafe fn check_sse_pair_to_avx(x: (__m128i, __m128i)) -> __m256i {
+    // CHECK: start:
+    // CHECK-NOT: alloca
+    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 32 %_0, ptr align 16 %x, i64 32, i1 false)
+    // CHECK-NEXT: ret void
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_sse_pair_from_avx(
+#[no_mangle]
+pub unsafe fn check_sse_pair_from_avx(x: __m256i) -> (__m128i, __m128i) {
+    // CHECK: start:
+    // CHECK-NOT: alloca
+    // CHECK-NEXT: %[[TEMP:.+]] = load <4 x i64>, ptr %x, align 32
+    // CHECK-NEXT: store <4 x i64> %[[TEMP]], ptr %_0, align 16
+    // CHECK-NEXT: ret void
+    transmute(x)
+}
diff --git a/tests/codegen-llvm/intrinsics/transmute.rs b/tests/codegen-llvm/intrinsics/transmute.rs
new file mode 100644
index 00000000000..c9a1cd58af3
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/transmute.rs
@@ -0,0 +1,497 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+//@ only-64bit (so I don't need to worry about usize)
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+#![feature(custom_mir)]
+#![allow(unreachable_code)]
+
+// Some of these need custom MIR to not get removed by MIR optimizations.
+use std::intrinsics::mir::*;
+use std::intrinsics::{transmute, transmute_unchecked};
+use std::mem::MaybeUninit;
+use std::num::NonZero;
+
+pub enum ZstNever {}
+
+#[repr(align(2))]
+pub struct BigNever(ZstNever, u16, ZstNever);
+
+#[repr(align(8))]
+pub struct Scalar64(i64);
+
+#[repr(C, align(4))]
+pub struct Aggregate64(u16, u8, i8, f32);
+
+#[repr(C)]
+pub struct Aggregate8(u8);
+
+// CHECK-LABEL: @check_bigger_size(
+#[no_mangle]
+pub unsafe fn check_bigger_size(x: u16) -> u32 {
+    // CHECK: store i1 true, ptr poison, align 1
+    transmute_unchecked(x)
+}
+
+// CHECK-LABEL: @check_smaller_size(
+#[no_mangle]
+pub unsafe fn check_smaller_size(x: u32) -> u16 {
+    // CHECK: store i1 true, ptr poison, align 1
+    transmute_unchecked(x)
+}
+
+// CHECK-LABEL: @check_smaller_array(
+#[no_mangle]
+pub unsafe fn check_smaller_array(x: [u32; 7]) -> [u32; 3] {
+    // CHECK: store i1 true, ptr poison, align 1
+    transmute_unchecked(x)
+}
+
+// CHECK-LABEL: @check_bigger_array(
+#[no_mangle]
+pub unsafe fn check_bigger_array(x: [u32; 3]) -> [u32; 7] {
+    // CHECK: store i1 true, ptr poison, align 1
+    transmute_unchecked(x)
+}
+
+// CHECK-LABEL: @check_to_empty_array(
+#[no_mangle]
+#[custom_mir(dialect = "runtime", phase = "optimized")]
+pub unsafe fn check_to_empty_array(x: [u32; 5]) -> [u32; 0] {
+    // CHECK: start
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
+    // CHECK-NEXT: ret void
+    mir! {
+        {
+            RET = CastTransmute(x);
+            Return()
+        }
+    }
+}
+
+// CHECK-LABEL: @check_from_empty_array(
+#[no_mangle]
+#[custom_mir(dialect = "runtime", phase = "optimized")]
+pub unsafe fn check_from_empty_array(x: [u32; 0]) -> [u32; 5] {
+    // CHECK: start
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
+    // CHECK-NEXT: ret void
+    mir! {
+        {
+            RET = CastTransmute(x);
+            Return()
+        }
+    }
+}
+
+// CHECK-LABEL: @check_to_uninhabited(
+#[no_mangle]
+#[custom_mir(dialect = "runtime", phase = "optimized")]
+pub unsafe fn check_to_uninhabited(x: u16) {
+    // CHECK: start
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
+    // CHECK-NEXT: ret void
+    mir! {
+        let temp: BigNever;
+        {
+            temp = CastTransmute(x);
+            Return()
+        }
+    }
+}
+
+// CHECK-LABEL: @check_from_uninhabited(
+#[no_mangle]
+#[custom_mir(dialect = "runtime", phase = "optimized")]
+pub unsafe fn check_from_uninhabited(x: BigNever) -> u16 {
+    // CHECK: start
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
+    // CHECK-NEXT: ret i16 poison
+    mir! {
+        {
+            RET = CastTransmute(x);
+            Return()
+        }
+    }
+}
+
+// CHECK-LABEL: @check_intermediate_passthrough(
+#[no_mangle]
+pub unsafe fn check_intermediate_passthrough(x: u32) -> i32 {
+    // CHECK: start
+    // CHECK: %[[TMP:.+]] = add i32 1, %x
+    // CHECK: %[[RET:.+]] = add i32 %[[TMP]], 1
+    // CHECK: ret i32 %[[RET]]
+    unsafe { transmute::<u32, i32>(1 + x) + 1 }
+}
+
+// CHECK-LABEL: @check_nop_pair(
+#[no_mangle]
+pub unsafe fn check_nop_pair(x: (u8, i8)) -> (i8, u8) {
+    // CHECK-NOT: alloca
+    // CHECK: %0 = insertvalue { i8, i8 } poison, i8 %x.0, 0
+    // CHECK: %1 = insertvalue { i8, i8 } %0, i8 %x.1, 1
+    // CHECK: ret { i8, i8 } %1
+    unsafe { transmute(x) }
+}
+
+// CHECK-LABEL: @check_to_newtype(
+#[no_mangle]
+pub unsafe fn check_to_newtype(x: u64) -> Scalar64 {
+    // CHECK-NOT: alloca
+    // CHECK: ret i64 %x
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_from_newtype(
+#[no_mangle]
+pub unsafe fn check_from_newtype(x: Scalar64) -> u64 {
+    // CHECK-NOT: alloca
+    // CHECK: ret i64 %x
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_aggregate_to_bool(
+#[no_mangle]
+pub unsafe fn check_aggregate_to_bool(x: Aggregate8) -> bool {
+    // CHECK: %x = alloca [1 x i8], align 1
+    // CHECK: %[[BYTE:.+]] = load i8, ptr %x, align 1
+    // CHECK: %[[BOOL:.+]] = trunc nuw i8 %[[BYTE]] to i1
+    // CHECK: ret i1 %[[BOOL]]
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_aggregate_from_bool(
+#[no_mangle]
+pub unsafe fn check_aggregate_from_bool(x: bool) -> Aggregate8 {
+    // CHECK: %_0 = alloca [1 x i8], align 1
+    // CHECK: %[[BYTE:.+]] = zext i1 %x to i8
+    // CHECK: store i8 %[[BYTE]], ptr %_0, align 1
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_byte_to_bool(
+#[no_mangle]
+pub unsafe fn check_byte_to_bool(x: u8) -> bool {
+    // CHECK-NOT: alloca
+    // CHECK: %[[R:.+]] = trunc nuw i8 %x to i1
+    // CHECK: ret i1 %[[R]]
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_byte_from_bool(
+#[no_mangle]
+pub unsafe fn check_byte_from_bool(x: bool) -> u8 {
+    // CHECK-NOT: alloca
+    // CHECK: %[[R:.+]] = zext i1 %x to i8
+    // CHECK: ret i8 %[[R:.+]]
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_to_pair(
+#[no_mangle]
+pub unsafe fn check_to_pair(x: u64) -> Option<i32> {
+    // CHECK: %_0 = alloca [8 x i8], align 4
+    // CHECK: store i64 %x, ptr %_0, align 4
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_from_pair(
+#[no_mangle]
+pub unsafe fn check_from_pair(x: Option<i32>) -> u64 {
+    // The two arguments are of types that are only 4-aligned, but they're
+    // immediates so we can write using the destination alloca's alignment.
+    const { assert!(std::mem::align_of::<Option<i32>>() == 4) };
+
+    // CHECK: %_0 = alloca [8 x i8], align 8
+    // CHECK: store i32 %x.0, ptr %_0, align 8
+    // CHECK: store i32 %x.1, ptr %0, align 4
+    // CHECK: %[[R:.+]] = load i64, ptr %_0, align 8
+    // CHECK: ret i64 %[[R]]
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_to_float(
+#[no_mangle]
+pub unsafe fn check_to_float(x: u32) -> f32 {
+    // CHECK-NOT: alloca
+    // CHECK: %_0 = bitcast i32 %x to float
+    // CHECK: ret float %_0
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_from_float(
+#[no_mangle]
+pub unsafe fn check_from_float(x: f32) -> u32 {
+    // CHECK-NOT: alloca
+    // CHECK: %_0 = bitcast float %x to i32
+    // CHECK: ret i32 %_0
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_to_bytes(
+#[no_mangle]
+pub unsafe fn check_to_bytes(x: u32) -> [u8; 4] {
+    // CHECK: %_0 = alloca [4 x i8], align 1
+    // CHECK: store i32 %x, ptr %_0, align 1
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_from_bytes(
+#[no_mangle]
+pub unsafe fn check_from_bytes(x: [u8; 4]) -> u32 {
+    // CHECK: %x = alloca [4 x i8], align 1
+    // CHECK: %[[VAL:.+]] = load i32, ptr %x, align 1
+    // CHECK: ret i32 %[[VAL]]
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_to_aggregate(
+#[no_mangle]
+pub unsafe fn check_to_aggregate(x: u64) -> Aggregate64 {
+    // CHECK: %_0 = alloca [8 x i8], align 4
+    // CHECK: store i64 %x, ptr %_0, align 4
+    // CHECK: %0 = load i64, ptr %_0, align 4
+    // CHECK: ret i64 %0
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_from_aggregate(
+#[no_mangle]
+pub unsafe fn check_from_aggregate(x: Aggregate64) -> u64 {
+    // CHECK: %x = alloca [8 x i8], align 4
+    // CHECK: %[[VAL:.+]] = load i64, ptr %x, align 4
+    // CHECK: ret i64 %[[VAL]]
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_long_array_less_aligned(
+#[no_mangle]
+pub unsafe fn check_long_array_less_aligned(x: [u64; 100]) -> [u16; 400] {
+    // CHECK-NEXT: start
+    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 2 %_0, ptr align 8 %x, i64 800, i1 false)
+    // CHECK-NEXT: ret void
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_long_array_more_aligned(
+#[no_mangle]
+pub unsafe fn check_long_array_more_aligned(x: [u8; 100]) -> [u32; 25] {
+    // CHECK-NEXT: start
+    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %_0, ptr align 1 %x, i64 100, i1 false)
+    // CHECK-NEXT: ret void
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_pair_with_bool(
+#[no_mangle]
+pub unsafe fn check_pair_with_bool(x: (u8, bool)) -> (bool, i8) {
+    // CHECK-NOT: alloca
+    // CHECK: trunc nuw i8 %x.0 to i1
+    // CHECK: zext i1 %x.1 to i8
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_float_to_pointer(
+#[no_mangle]
+pub unsafe fn check_float_to_pointer(x: f64) -> *const () {
+    // CHECK-NOT: alloca
+    // CHECK: %0 = bitcast double %x to i64
+    // CHECK: %_0 = getelementptr i8, ptr null, i64 %0
+    // CHECK: ret ptr %_0
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_float_from_pointer(
+#[no_mangle]
+pub unsafe fn check_float_from_pointer(x: *const ()) -> f64 {
+    // CHECK-NOT: alloca
+    // CHECK: %0 = ptrtoint ptr %x to i64
+    // CHECK: %_0 = bitcast i64 %0 to double
+    // CHECK: ret double %_0
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_array_to_pair(
+#[no_mangle]
+pub unsafe fn check_array_to_pair(x: [u8; 16]) -> (i64, u64) {
+    // CHECK-NOT: alloca
+    // CHECK: %[[FST:.+]] = load i64, ptr %{{.+}}, align 1, !noundef !
+    // CHECK: %[[SND:.+]] = load i64, ptr %{{.+}}, align 1, !noundef !
+    // CHECK: %[[PAIR0:.+]] = insertvalue { i64, i64 } poison, i64 %[[FST]], 0
+    // CHECK: %[[PAIR01:.+]] = insertvalue { i64, i64 } %[[PAIR0]], i64 %[[SND]], 1
+    // CHECK: ret { i64, i64 } %[[PAIR01]]
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_pair_to_array(
+#[no_mangle]
+pub unsafe fn check_pair_to_array(x: (i64, u64)) -> [u8; 16] {
+    // CHECK-NOT: alloca
+    // CHECK: store i64 %x.0, ptr %{{.+}}, align 1
+    // CHECK: store i64 %x.1, ptr %{{.+}}, align 1
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_heterogeneous_integer_pair(
+#[no_mangle]
+pub unsafe fn check_heterogeneous_integer_pair(x: (i32, bool)) -> (bool, u32) {
+    // CHECK: store i32 %x.0
+    // CHECK: %[[WIDER:.+]] = zext i1 %x.1 to i8
+    // CHECK: store i8 %[[WIDER]]
+
+    // CHECK: %[[BYTE:.+]] = load i8
+    // CHECK: trunc nuw i8 %[[BYTE:.+]] to i1
+    // CHECK: load i32
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_heterogeneous_float_pair(
+#[no_mangle]
+pub unsafe fn check_heterogeneous_float_pair(x: (f64, f32)) -> (f32, f64) {
+    // CHECK: store double %x.0
+    // CHECK: store float %x.1
+    // CHECK: %[[A:.+]] = load float
+    // CHECK: %[[B:.+]] = load double
+    // CHECK: %[[P:.+]] = insertvalue { float, double } poison, float %[[A]], 0
+    // CHECK: insertvalue { float, double } %[[P]], double %[[B]], 1
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_issue_110005(
+#[no_mangle]
+pub unsafe fn check_issue_110005(x: (usize, bool)) -> Option<Box<[u8]>> {
+    // CHECK: store i64 %x.0
+    // CHECK: %[[WIDER:.+]] = zext i1 %x.1 to i8
+    // CHECK: store i8 %[[WIDER]]
+    // CHECK: load ptr
+    // CHECK: load i64
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_pair_to_dst_ref(
+#[no_mangle]
+pub unsafe fn check_pair_to_dst_ref<'a>(x: (usize, usize)) -> &'a [u8] {
+    // CHECK: %_0.0 = getelementptr i8, ptr null, i64 %x.0
+    // CHECK: %0 = icmp ne ptr %_0.0, null
+    // CHECK: call void @llvm.assume(i1 %0)
+    // CHECK: %1 = insertvalue { ptr, i64 } poison, ptr %_0.0, 0
+    // CHECK: %2 = insertvalue { ptr, i64 } %1, i64 %x.1, 1
+    // CHECK: ret { ptr, i64 } %2
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_issue_109992(
+#[no_mangle]
+#[custom_mir(dialect = "runtime", phase = "optimized")]
+pub unsafe fn check_issue_109992(x: ()) -> [(); 1] {
+    // This uses custom MIR to avoid MIR optimizations having removed ZST ops.
+
+    // CHECK: start
+    // CHECK-NEXT: ret void
+    mir! {
+        {
+            RET = CastTransmute(x);
+            Return()
+        }
+    }
+}
+
+// CHECK-LABEL: @check_unit_to_never(
+#[no_mangle]
+#[custom_mir(dialect = "runtime", phase = "optimized")]
+pub unsafe fn check_unit_to_never(x: ()) {
+    // This uses custom MIR to avoid MIR optimizations having removed ZST ops.
+
+    // CHECK: start
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
+    // CHECK-NEXT: ret void
+    mir! {
+        let temp: ZstNever;
+        {
+            temp = CastTransmute(x);
+            Return()
+        }
+    }
+}
+
+// CHECK-LABEL: @check_unit_from_never(
+#[no_mangle]
+#[custom_mir(dialect = "runtime", phase = "optimized")]
+pub unsafe fn check_unit_from_never(x: ZstNever) -> () {
+    // This uses custom MIR to avoid MIR optimizations having removed ZST ops.
+
+    // CHECK: start
+    // CHECK-NEXT: store i1 true, ptr poison, align 1
+    // CHECK-NEXT: ret void
+    mir! {
+        {
+            RET = CastTransmute(x);
+            Return()
+        }
+    }
+}
+
+// CHECK-LABEL: @check_maybe_uninit_pair(i16 %x.0, i64 %x.1)
+#[no_mangle]
+pub unsafe fn check_maybe_uninit_pair(
+    x: (MaybeUninit<u16>, MaybeUninit<u64>),
+) -> (MaybeUninit<i64>, MaybeUninit<i16>) {
+    // Thanks to `MaybeUninit` this is actually defined behaviour,
+    // unlike the examples above with pairs of primitives.
+
+    // CHECK: store i16 %x.0
+    // CHECK: store i64 %x.1
+    // CHECK: load i64
+    // CHECK-NOT: noundef
+    // CHECK: load i16
+    // CHECK-NOT: noundef
+    // CHECK: ret { i64, i16 }
+    transmute(x)
+}
+
+#[repr(align(8))]
+pub struct HighAlignScalar(u8);
+
+// CHECK-LABEL: @check_to_overalign(
+#[no_mangle]
+pub unsafe fn check_to_overalign(x: u64) -> HighAlignScalar {
+    // CHECK: %_0 = alloca [8 x i8], align 8
+    // CHECK: store i64 %x, ptr %_0, align 8
+    // CHECK: %0 = load i64, ptr %_0, align 8
+    // CHECK: ret i64 %0
+    transmute(x)
+}
+
+// CHECK-LABEL: @check_from_overalign(
+#[no_mangle]
+pub unsafe fn check_from_overalign(x: HighAlignScalar) -> u64 {
+    // CHECK: %x = alloca [8 x i8], align 8
+    // CHECK: %[[VAL:.+]] = load i64, ptr %x, align 8
+    // CHECK: ret i64 %[[VAL]]
+    transmute(x)
+}
+
+#[repr(transparent)]
+struct Level1(std::num::NonZero<u32>);
+#[repr(transparent)]
+struct Level2(Level1);
+#[repr(transparent)]
+struct Level3(Level2);
+
+// CHECK-LABEL: @repeatedly_transparent_transmute
+// CHECK-SAME: (i32{{.+}}%[[ARG:[^)]+]])
+#[no_mangle]
+#[custom_mir(dialect = "runtime", phase = "optimized")]
+pub unsafe fn repeatedly_transparent_transmute(x: NonZero<u32>) -> Level3 {
+    // CHECK: start
+    // CHECK-NEXT: ret i32 %[[ARG]]
+    mir! {
+        {
+            let A = CastTransmute::<NonZero<u32>, Level1>(x);
+            let B = CastTransmute::<Level1, Level2>(A);
+            RET = CastTransmute::<Level2, Level3>(B);
+            Return()
+        }
+    }
+}
diff --git a/tests/codegen-llvm/intrinsics/typed_swap.rs b/tests/codegen-llvm/intrinsics/typed_swap.rs
new file mode 100644
index 00000000000..6b55078407a
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/typed_swap.rs
@@ -0,0 +1,77 @@
+//@ revisions: OPT0 OPT3
+//@ [OPT0] compile-flags: -Copt-level=0
+//@ [OPT3] compile-flags: -Copt-level=3
+//@ compile-flags: -C no-prepopulate-passes
+//@ only-64bit (so I don't need to worry about usize)
+// ignore-tidy-linelength (the memcpy calls get long)
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::typed_swap_nonoverlapping;
+
+// CHECK-LABEL: @swap_unit(
+#[no_mangle]
+pub unsafe fn swap_unit(x: &mut (), y: &mut ()) {
+    // CHECK: start
+    // CHECK-NEXT: ret void
+    typed_swap_nonoverlapping(x, y)
+}
+
+// CHECK-LABEL: @swap_i32(
+#[no_mangle]
+pub unsafe fn swap_i32(x: &mut i32, y: &mut i32) {
+    // CHECK-NOT: alloca
+
+    // CHECK: %[[TEMP:.+]] = load i32, ptr %x, align 4
+    // OPT3-SAME: !noundef
+    // OPT0: %[[TEMP2:.+]] = load i32, ptr %y, align 4
+    // OPT0: store i32 %[[TEMP2]], ptr %x, align 4
+    // OPT0-NOT: memcpy
+    // OPT3-NOT: load
+    // OPT3: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %x, ptr align 4 %y, i64 4, i1 false)
+    // CHECK: store i32 %[[TEMP]], ptr %y, align 4
+    // CHECK: ret void
+    typed_swap_nonoverlapping(x, y)
+}
+
+// CHECK-LABEL: @swap_pair(
+#[no_mangle]
+pub unsafe fn swap_pair(x: &mut (i32, u32), y: &mut (i32, u32)) {
+    // CHECK-NOT: alloca
+
+    // CHECK: load i32
+    // OPT3-SAME: !noundef
+    // CHECK: load i32
+    // OPT3-SAME: !noundef
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %x, ptr align 4 %y, i64 8, i1 false)
+    // CHECK: store i32
+    // CHECK: store i32
+    typed_swap_nonoverlapping(x, y)
+}
+
+// CHECK-LABEL: @swap_str(
+#[no_mangle]
+pub unsafe fn swap_str<'a>(x: &mut &'a str, y: &mut &'a str) {
+    // CHECK-NOT: alloca
+
+    // CHECK: load ptr
+    // OPT3-SAME: !nonnull
+    // OPT3-SAME: !noundef
+    // CHECK: load i64
+    // OPT3-SAME: !noundef
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %x, ptr align 8 %y, i64 16, i1 false)
+    // CHECK: store ptr
+    // CHECK: store i64
+    typed_swap_nonoverlapping(x, y)
+}
+
+// OPT0-LABEL: @swap_string(
+#[no_mangle]
+pub unsafe fn swap_string(x: &mut String, y: &mut String) {
+    // OPT0: %[[TEMP:.+]] = alloca {{.+}}, align 8
+    // OPT0: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %[[TEMP]], ptr align 8 %x, i64 24, i1 false)
+    // OPT0: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %x, ptr align 8 %y, i64 24, i1 false)
+    // OPT0: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %y, ptr align 8 %[[TEMP]], i64 24, i1 false)
+    typed_swap_nonoverlapping(x, y)
+}
diff --git a/tests/codegen-llvm/intrinsics/unchecked_math.rs b/tests/codegen-llvm/intrinsics/unchecked_math.rs
new file mode 100644
index 00000000000..419c120ede9
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/unchecked_math.rs
@@ -0,0 +1,46 @@
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::*;
+
+// CHECK-LABEL: @unchecked_add_signed
+#[no_mangle]
+pub unsafe fn unchecked_add_signed(a: i32, b: i32) -> i32 {
+    // CHECK: add nsw
+    unchecked_add(a, b)
+}
+
+// CHECK-LABEL: @unchecked_add_unsigned
+#[no_mangle]
+pub unsafe fn unchecked_add_unsigned(a: u32, b: u32) -> u32 {
+    // CHECK: add nuw
+    unchecked_add(a, b)
+}
+
+// CHECK-LABEL: @unchecked_sub_signed
+#[no_mangle]
+pub unsafe fn unchecked_sub_signed(a: i32, b: i32) -> i32 {
+    // CHECK: sub nsw
+    unchecked_sub(a, b)
+}
+
+// CHECK-LABEL: @unchecked_sub_unsigned
+#[no_mangle]
+pub unsafe fn unchecked_sub_unsigned(a: u32, b: u32) -> u32 {
+    // CHECK: sub nuw
+    unchecked_sub(a, b)
+}
+
+// CHECK-LABEL: @unchecked_mul_signed
+#[no_mangle]
+pub unsafe fn unchecked_mul_signed(a: i32, b: i32) -> i32 {
+    // CHECK: mul nsw
+    unchecked_mul(a, b)
+}
+
+// CHECK-LABEL: @unchecked_mul_unsigned
+#[no_mangle]
+pub unsafe fn unchecked_mul_unsigned(a: u32, b: u32) -> u32 {
+    // CHECK: mul nuw
+    unchecked_mul(a, b)
+}
diff --git a/tests/codegen-llvm/intrinsics/unlikely.rs b/tests/codegen-llvm/intrinsics/unlikely.rs
new file mode 100644
index 00000000000..90ebf070d27
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/unlikely.rs
@@ -0,0 +1,35 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::unlikely;
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_a() {
+    println!("path a");
+}
+
+#[inline(never)]
+#[no_mangle]
+pub fn path_b() {
+    println!("path b");
+}
+
+#[no_mangle]
+pub fn test_unlikely(x: bool) {
+    if unlikely(x) {
+        path_a();
+    } else {
+        path_b();
+    }
+}
+
+// CHECK-LABEL: @test_unlikely(
+// CHECK: br i1 %x, label %bb2, label %bb4, !prof ![[NUM:[0-9]+]]
+// CHECK: bb4:
+// CHECK: path_b
+// CHECK: bb2:
+// CHECK-NOT: cold_path
+// CHECK: path_a
+// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 1, i32 2000}
diff --git a/tests/codegen-llvm/intrinsics/volatile.rs b/tests/codegen-llvm/intrinsics/volatile.rs
new file mode 100644
index 00000000000..2dea5ecb2ca
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/volatile.rs
@@ -0,0 +1,55 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics;
+
+// CHECK-LABEL: @volatile_copy_memory
+#[no_mangle]
+pub unsafe fn volatile_copy_memory(a: *mut u8, b: *const u8) {
+    // CHECK: llvm.memmove.{{\w*(.*true)}}
+    intrinsics::volatile_copy_memory(a, b, 1)
+}
+
+// CHECK-LABEL: @volatile_copy_nonoverlapping_memory
+#[no_mangle]
+pub unsafe fn volatile_copy_nonoverlapping_memory(a: *mut u8, b: *const u8) {
+    // CHECK: llvm.memcpy.{{\w*(.*true)}}
+    intrinsics::volatile_copy_nonoverlapping_memory(a, b, 1)
+}
+
+// CHECK-LABEL: @volatile_set_memory
+#[no_mangle]
+pub unsafe fn volatile_set_memory(a: *mut u8, b: u8) {
+    // CHECK: llvm.memset.{{\w*(.*true)}}
+    intrinsics::volatile_set_memory(a, b, 1)
+}
+
+// CHECK-LABEL: @volatile_load
+#[no_mangle]
+pub unsafe fn volatile_load(a: *const u8) -> u8 {
+    // CHECK: load volatile
+    intrinsics::volatile_load(a)
+}
+
+// CHECK-LABEL: @volatile_store
+#[no_mangle]
+pub unsafe fn volatile_store(a: *mut u8, b: u8) {
+    // CHECK: store volatile
+    intrinsics::volatile_store(a, b)
+}
+
+// CHECK-LABEL: @unaligned_volatile_load
+#[no_mangle]
+pub unsafe fn unaligned_volatile_load(a: *const u8) -> u8 {
+    // CHECK: load volatile
+    intrinsics::unaligned_volatile_load(a)
+}
+
+// CHECK-LABEL: @unaligned_volatile_store
+#[no_mangle]
+pub unsafe fn unaligned_volatile_store(a: *mut u8, b: u8) {
+    // CHECK: store volatile
+    intrinsics::unaligned_volatile_store(a, b)
+}
diff --git a/tests/codegen-llvm/intrinsics/volatile_order.rs b/tests/codegen-llvm/intrinsics/volatile_order.rs
new file mode 100644
index 00000000000..99469831a6c
--- /dev/null
+++ b/tests/codegen-llvm/intrinsics/volatile_order.rs
@@ -0,0 +1,18 @@
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+use std::intrinsics::*;
+
+pub unsafe fn test_volatile_order() {
+    let mut a: Box<u8> = Box::new(0);
+    // CHECK: load volatile
+    let x = volatile_load(&*a);
+    // CHECK: load volatile
+    let x = volatile_load(&*a);
+    // CHECK: store volatile
+    volatile_store(&mut *a, 12);
+    // CHECK: store volatile
+    unaligned_volatile_store(&mut *a, 12);
+    // CHECK: llvm.memset.p0
+    volatile_set_memory(&mut *a, 12, 1)
+}
diff --git a/tests/codegen-llvm/is_val_statically_known.rs b/tests/codegen-llvm/is_val_statically_known.rs
new file mode 100644
index 00000000000..8119d3a3bf6
--- /dev/null
+++ b/tests/codegen-llvm/is_val_statically_known.rs
@@ -0,0 +1,163 @@
+//@ compile-flags: --crate-type=lib -Zmerge-functions=disabled -Copt-level=3
+
+#![feature(core_intrinsics)]
+#![feature(f16, f128)]
+
+use std::intrinsics::is_val_statically_known;
+
+pub struct A(u32);
+pub enum B {
+    Ye(u32),
+}
+
+#[inline]
+pub fn _u32(a: u32) -> i32 {
+    if is_val_statically_known(a) { 1 } else { 0 }
+}
+
+// CHECK-LABEL: @_u32_true(
+#[no_mangle]
+pub fn _u32_true() -> i32 {
+    // CHECK: ret i32 1
+    _u32(1)
+}
+
+// CHECK-LABEL: @_u32_false(
+#[no_mangle]
+pub fn _u32_false(a: u32) -> i32 {
+    // CHECK: ret i32 0
+    _u32(a)
+}
+
+#[inline]
+pub fn _bool(b: bool) -> i32 {
+    if is_val_statically_known(b) { 3 } else { 2 }
+}
+
+// CHECK-LABEL: @_bool_true(
+#[no_mangle]
+pub fn _bool_true() -> i32 {
+    // CHECK: ret i32 3
+    _bool(true)
+}
+
+// CHECK-LABEL: @_bool_false(
+#[no_mangle]
+pub fn _bool_false(b: bool) -> i32 {
+    // CHECK: ret i32 2
+    _bool(b)
+}
+
+#[inline]
+pub fn _iref(a: &u8) -> i32 {
+    if is_val_statically_known(a) { 5 } else { 4 }
+}
+
+// CHECK-LABEL: @_iref_borrow(
+#[no_mangle]
+pub fn _iref_borrow() -> i32 {
+    // CHECK: ret i32 4
+    _iref(&0)
+}
+
+// CHECK-LABEL: @_iref_arg(
+#[no_mangle]
+pub fn _iref_arg(a: &u8) -> i32 {
+    // CHECK: ret i32 4
+    _iref(a)
+}
+
+#[inline]
+pub fn _slice_ref(a: &[u8]) -> i32 {
+    if is_val_statically_known(a) { 7 } else { 6 }
+}
+
+// CHECK-LABEL: @_slice_ref_borrow(
+#[no_mangle]
+pub fn _slice_ref_borrow() -> i32 {
+    // CHECK: ret i32 6
+    _slice_ref(&[0; 3])
+}
+
+// CHECK-LABEL: @_slice_ref_arg(
+#[no_mangle]
+pub fn _slice_ref_arg(a: &[u8]) -> i32 {
+    // CHECK: ret i32 6
+    _slice_ref(a)
+}
+
+#[inline]
+pub fn _f16(a: f16) -> i32 {
+    if is_val_statically_known(a) { 1 } else { 0 }
+}
+
+// CHECK-LABEL: @_f16_true(
+#[no_mangle]
+pub fn _f16_true() -> i32 {
+    // CHECK: ret i32 1
+    _f16(1.0)
+}
+
+// CHECK-LABEL: @_f16_false(
+#[no_mangle]
+pub fn _f16_false(a: f16) -> i32 {
+    // CHECK: ret i32 0
+    _f16(a)
+}
+
+#[inline]
+pub fn _f32(a: f32) -> i32 {
+    if is_val_statically_known(a) { 1 } else { 0 }
+}
+
+// CHECK-LABEL: @_f32_true(
+#[no_mangle]
+pub fn _f32_true() -> i32 {
+    // CHECK: ret i32 1
+    _f32(1.0)
+}
+
+// CHECK-LABEL: @_f32_false(
+#[no_mangle]
+pub fn _f32_false(a: f32) -> i32 {
+    // CHECK: ret i32 0
+    _f32(a)
+}
+
+#[inline]
+pub fn _f64(a: f64) -> i32 {
+    if is_val_statically_known(a) { 1 } else { 0 }
+}
+
+// CHECK-LABEL: @_f64_true(
+#[no_mangle]
+pub fn _f64_true() -> i32 {
+    // CHECK: ret i32 1
+    _f64(1.0)
+}
+
+// CHECK-LABEL: @_f64_false(
+#[no_mangle]
+pub fn _f64_false(a: f64) -> i32 {
+    // CHECK: ret i32 0
+    _f64(a)
+}
+
+#[inline]
+pub fn _f128(a: f128) -> i32 {
+    if is_val_statically_known(a) { 1 } else { 0 }
+}
+
+// CHECK-LABEL: @_f128_true(
+#[no_mangle]
+pub fn _f128_true() -> i32 {
+    // CHECK: ret i32 1
+    _f128(1.0)
+}
+
+// CHECK-LABEL: @_f128_false(
+#[no_mangle]
+pub fn _f128_false(a: f128) -> i32 {
+    // CHECK: ret i32 0
+    _f128(a)
+}
diff --git a/tests/codegen-llvm/issue-97217.rs b/tests/codegen-llvm/issue-97217.rs
new file mode 100644
index 00000000000..ef9acc5fc93
--- /dev/null
+++ b/tests/codegen-llvm/issue-97217.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -C opt-level=3
+#![crate_type = "lib"]
+
+// Regression test for issue 97217 (the following should result in no allocations)
+
+// CHECK-LABEL: @issue97217
+#[no_mangle]
+pub fn issue97217() -> i32 {
+    // drop_in_place should be inlined and never appear
+    // CHECK-NOT: drop_in_place
+
+    // __rust_alloc should be optimized out
+    // CHECK-NOT: __rust_alloc
+
+    let v1 = vec![5, 6, 7];
+    let v1_iter = v1.iter();
+    let total: i32 = v1_iter.sum();
+    println!("{}", total);
+    total
+}
diff --git a/tests/codegen-llvm/issues/issue-101048.rs b/tests/codegen-llvm/issues/issue-101048.rs
new file mode 100644
index 00000000000..cfe65e758fd
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-101048.rs
@@ -0,0 +1,12 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn all_zero(data: &[u64]) -> bool {
+    // CHECK-LABEL: @all_zero(
+    // CHECK: [[PHI:%.*]] = phi i1
+    // CHECK-NOT: phi i8
+    // CHECK-NOT: zext
+    data.iter().copied().fold(true, |acc, x| acc & (x == 0))
+}
diff --git a/tests/codegen-llvm/issues/issue-101082.rs b/tests/codegen-llvm/issues/issue-101082.rs
new file mode 100644
index 00000000000..8d15921ddb4
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-101082.rs
@@ -0,0 +1,42 @@
+//@ compile-flags: -Copt-level=3
+//@ revisions: host x86-64 x86-64-v3
+//@ min-llvm-version: 20
+
+//@[host] ignore-x86_64
+
+// Set the base cpu explicitly, in case the default has been changed.
+//@[x86-64] only-x86_64
+//@[x86-64] compile-flags: -Ctarget-cpu=x86-64
+
+// FIXME(cuviper) x86-64-v3 in particular regressed in #131563, and the workaround
+// 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"]
+
+#[no_mangle]
+pub fn test() -> usize {
+    // CHECK-LABEL: @test(
+    // CHECK: ret {{i64|i32}} 165
+    let values = [23, 16, 54, 3, 60, 9];
+    let mut acc = 0;
+    for item in values {
+        acc += item;
+    }
+    acc
+}
+
+#[no_mangle]
+pub fn test_eight() -> usize {
+    // CHECK-LABEL: @test_eight(
+    // CHECK: ret {{i64|i32}} 220
+    let values = [23, 16, 54, 3, 60, 9, 13, 42];
+    let mut acc = 0;
+    for item in values {
+        acc += item;
+    }
+    acc
+}
diff --git a/tests/codegen-llvm/issues/issue-101814.rs b/tests/codegen-llvm/issues/issue-101814.rs
new file mode 100644
index 00000000000..668ec8476e8
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-101814.rs
@@ -0,0 +1,18 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn test(a: [i32; 10]) -> i32 {
+    // CHECK-LABEL: @test(
+    // CHECK: [[L1:%.+]] = load i32
+    // CHECK: [[L2:%.+]] = load i32
+    // CHECK: [[R:%.+]] = add i32 [[L1]], [[L2]]
+    // CHECK: ret i32 [[R]]
+    let mut sum = 0;
+    for v in a.iter().skip(8) {
+        sum += v;
+    }
+
+    sum
+}
diff --git a/tests/codegen-llvm/issues/issue-103132.rs b/tests/codegen-llvm/issues/issue-103132.rs
new file mode 100644
index 00000000000..623cab92806
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-103132.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -Copt-level=3 -C overflow-checks
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn test(arr: &[u8], weight: u32) {
+    // CHECK-LABEL: @test(
+    // CHECK-NOT: panic
+    let weight = weight.min(256 * 256 * 256);
+
+    for x in arr {
+        assert!(weight <= 256 * 256 * 256);
+        let result = *x as u32 * weight;
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-103285-ptr-addr-overflow-check.rs b/tests/codegen-llvm/issues/issue-103285-ptr-addr-overflow-check.rs
new file mode 100644
index 00000000000..3ada5412e83
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-103285-ptr-addr-overflow-check.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -Copt-level=3 -C debug-assertions=yes
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn test(src: *const u8, dst: *const u8) -> usize {
+    // CHECK-LABEL: @test(
+    // CHECK-NOT: panic
+    let src_usize = src.addr();
+    let dst_usize = dst.addr();
+    if src_usize > dst_usize {
+        return src_usize - dst_usize;
+    }
+    return 0;
+}
diff --git a/tests/codegen-llvm/issues/issue-103327.rs b/tests/codegen-llvm/issues/issue-103327.rs
new file mode 100644
index 00000000000..4de3cfd12a0
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-103327.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn test(a: i32, b: i32) -> bool {
+    // CHECK-LABEL: @test(
+    // CHECK: ret i1 true
+    let c1 = (a >= 0) && (a <= 10);
+    let c2 = (b >= 0) && (b <= 20);
+
+    if c1 & c2 { a + 100 != b } else { true }
+}
diff --git a/tests/codegen-llvm/issues/issue-103840.rs b/tests/codegen-llvm/issues/issue-103840.rs
new file mode 100644
index 00000000000..c6c5098bdd0
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-103840.rs
@@ -0,0 +1,9 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+pub fn foo(t: &mut Vec<usize>) {
+    // CHECK-NOT: __rust_dealloc
+    let mut taken = std::mem::take(t);
+    taken.pop();
+    *t = taken;
+}
diff --git a/tests/codegen-llvm/issues/issue-105386-ub-in-debuginfo.rs b/tests/codegen-llvm/issues/issue-105386-ub-in-debuginfo.rs
new file mode 100644
index 00000000000..848aa910b58
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-105386-ub-in-debuginfo.rs
@@ -0,0 +1,24 @@
+//@ compile-flags: --crate-type=lib -Copt-level=3 -Cdebuginfo=2 -Cno-prepopulate-passes -Zmir-enable-passes=-ScalarReplacementOfAggregates
+// MIR SROA will decompose the closure
+#![feature(stmt_expr_attributes)]
+
+pub struct S([usize; 8]);
+
+#[no_mangle]
+pub fn outer_function(x: S, y: S) -> usize {
+    (#[inline(always)]
+    || {
+        let _z = x;
+        y.0[0]
+    })()
+}
+
+// Check that we do not attempt to load from the spilled arg before it is assigned to
+// when generating debuginfo.
+// CHECK-LABEL: @outer_function
+// CHECK: [[spill:%.*]] = alloca
+// CHECK-NOT: [[ptr_tmp:%.*]] = getelementptr inbounds i8, ptr [[spill]]
+// CHECK-NOT: [[load:%.*]] = load ptr, ptr
+// CHECK: call void @llvm.lifetime.start{{.*}}({{.*}}, ptr [[spill]])
+// CHECK: [[inner:%.*]] = getelementptr inbounds i8, ptr [[spill]]
+// CHECK: call void @llvm.memcpy{{.*}}(ptr {{align .*}} [[inner]], ptr {{align .*}} %x
diff --git a/tests/codegen-llvm/issues/issue-106369.rs b/tests/codegen-llvm/issues/issue-106369.rs
new file mode 100644
index 00000000000..3583d20c9fa
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-106369.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// From <https://github.com/rust-lang/rust/issues/106369#issuecomment-1369095304>
+
+// CHECK-LABEL: @issue_106369(
+#[no_mangle]
+pub unsafe fn issue_106369(ptr: *const &i32) -> bool {
+    // CHECK-NOT: icmp
+    // CHECK: ret i1 true
+    // CHECK-NOT: icmp
+    Some(std::ptr::read(ptr)).is_some()
+}
diff --git a/tests/codegen-llvm/issues/issue-107681-unwrap_unchecked.rs b/tests/codegen-llvm/issues/issue-107681-unwrap_unchecked.rs
new file mode 100644
index 00000000000..69aefc6b1fb
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-107681-unwrap_unchecked.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: -Copt-level=3
+
+// Test for #107681.
+// Make sure we don't create `br` or `select` instructions.
+
+#![crate_type = "lib"]
+
+use std::iter::Copied;
+use std::slice::Iter;
+
+#[no_mangle]
+pub unsafe fn foo(x: &mut Copied<Iter<'_, u32>>) -> u32 {
+    // CHECK-LABEL: @foo(
+    // CHECK-NOT: br
+    // CHECK-NOT: select
+    // CHECK: [[RET:%.*]] = load i32, ptr
+    // CHECK-NEXT: ret i32 [[RET]]
+    x.next().unwrap_unchecked()
+}
diff --git a/tests/codegen-llvm/issues/issue-108395-branchy-bool-match.rs b/tests/codegen-llvm/issues/issue-108395-branchy-bool-match.rs
new file mode 100644
index 00000000000..96387e791b0
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-108395-branchy-bool-match.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+//! Test for <https://github.com/rust-lang/rust/issues/108395>. Check that
+//! matching on two bools with wildcards does not produce branches.
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @wildcard(
+#[no_mangle]
+pub fn wildcard(a: u16, b: u16, v: u16) -> u16 {
+    // CHECK-NOT: br
+    match (a == v, b == v) {
+        (true, false) => 0,
+        (false, true) => u16::MAX,
+        _ => 1 << 15, // half
+    }
+}
+
+// CHECK-LABEL: @exhaustive(
+#[no_mangle]
+pub fn exhaustive(a: u16, b: u16, v: u16) -> u16 {
+    // CHECK-NOT: br
+    match (a == v, b == v) {
+        (true, false) => 0,
+        (false, true) => u16::MAX,
+        (true, true) => 1 << 15,
+        (false, false) => 1 << 15,
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-109328-split_first.rs b/tests/codegen-llvm/issues/issue-109328-split_first.rs
new file mode 100644
index 00000000000..26235edfc19
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-109328-split_first.rs
@@ -0,0 +1,16 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @foo
+// CHECK-NEXT: {{.*}}:
+// CHECK-NEXT: getelementptr inbounds
+// CHECK-NEXT: load [[TYPE:i(32|64)]]
+// CHECK-NEXT: icmp eq [[TYPE]]
+// CHECK-NEXT: br i1
+#[no_mangle]
+pub fn foo(input: &mut &[u64]) -> Option<u64> {
+    let (first, rest) = input.split_first()?;
+    *input = rest;
+    Some(*first)
+}
diff --git a/tests/codegen-llvm/issues/issue-110797-enum-jump-same.rs b/tests/codegen-llvm/issues/issue-110797-enum-jump-same.rs
new file mode 100644
index 00000000000..b5f7c08795b
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-110797-enum-jump-same.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+pub enum K {
+    A(Box<[i32]>),
+    B(Box<[u8]>),
+    C(Box<[String]>),
+    D(Box<[u16]>),
+}
+
+// CHECK-LABEL: @get_len
+// CHECK-NEXT: {{.*}}:
+// CHECK-NEXT: getelementptr inbounds
+// CHECK-NEXT: load [[TYPE:i(32|64)]]
+// CHECK-NEXT: ret [[TYPE]]
+#[no_mangle]
+pub fn get_len(arg: &K) -> usize {
+    match arg {
+        K::A(ref lst) => lst.len(),
+        K::B(ref lst) => lst.len(),
+        K::C(ref lst) => lst.len(),
+        K::D(ref lst) => lst.len(),
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-111603.rs b/tests/codegen-llvm/issues/issue-111603.rs
new file mode 100644
index 00000000000..2ba5a3f876a
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-111603.rs
@@ -0,0 +1,40 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+#![feature(get_mut_unchecked, new_uninit)]
+
+use std::sync::Arc;
+
+// CHECK-LABEL: @new_from_array
+#[no_mangle]
+pub fn new_from_array(x: u64) -> Arc<[u64]> {
+    // Ensure that we only generate one alloca for the array.
+
+    // CHECK: alloca
+    // CHECK-SAME: [8000 x i8]
+    // CHECK-NOT: alloca
+    let array = [x; 1000];
+    Arc::new(array)
+}
+
+// CHECK-LABEL: @new_uninit
+#[no_mangle]
+pub fn new_uninit(x: u64) -> Arc<[u64; 1000]> {
+    // CHECK: call alloc::sync::arcinner_layout_for_value_layout
+    // CHECK-NOT: call alloc::sync::arcinner_layout_for_value_layout
+    let mut arc = Arc::new_uninit();
+    unsafe { Arc::get_mut_unchecked(&mut arc) }.write([x; 1000]);
+    unsafe { arc.assume_init() }
+}
+
+// CHECK-LABEL: @new_uninit_slice
+#[no_mangle]
+pub fn new_uninit_slice(x: u64) -> Arc<[u64]> {
+    // CHECK: call alloc::sync::arcinner_layout_for_value_layout
+    // CHECK-NOT: call alloc::sync::arcinner_layout_for_value_layout
+    let mut arc = Arc::new_uninit_slice(1000);
+    for elem in unsafe { Arc::get_mut_unchecked(&mut arc) } {
+        elem.write(x);
+    }
+    unsafe { arc.assume_init() }
+}
diff --git a/tests/codegen-llvm/issues/issue-112509-slice-get-andthen-get.rs b/tests/codegen-llvm/issues/issue-112509-slice-get-andthen-get.rs
new file mode 100644
index 00000000000..3909b203d08
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-112509-slice-get-andthen-get.rs
@@ -0,0 +1,16 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @write_u8_variant_a
+// CHECK-NEXT: {{.*}}:
+// CHECK-NEXT: icmp ugt
+// CHECK-NEXT: getelementptr
+// CHECK-NEXT: select i1 {{.+}} null
+// CHECK-NEXT: insertvalue
+// CHECK-NEXT: insertvalue
+// CHECK-NEXT: ret
+#[no_mangle]
+pub fn write_u8_variant_a(bytes: &mut [u8], buf: u8, offset: usize) -> Option<&mut [u8]> {
+    let buf = buf.to_le_bytes();
+    bytes.get_mut(offset..).and_then(|bytes| bytes.get_mut(..buf.len()))
+}
diff --git a/tests/codegen-llvm/issues/issue-113757-bounds-check-after-cmp-max.rs b/tests/codegen-llvm/issues/issue-113757-bounds-check-after-cmp-max.rs
new file mode 100644
index 00000000000..d495adf9980
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-113757-bounds-check-after-cmp-max.rs
@@ -0,0 +1,18 @@
+// in Rust 1.73, -O and opt-level=3 optimizes differently
+//@ compile-flags: -C opt-level=3
+#![crate_type = "lib"]
+
+use std::cmp::max;
+
+// CHECK-LABEL: @foo
+// CHECK-NOT: slice_start_index_len_fail
+// CHECK-NOT: unreachable
+#[no_mangle]
+pub fn foo(v: &mut Vec<u8>, size: usize) -> Option<&mut [u8]> {
+    if v.len() > max(1, size) {
+        let start = v.len() - size;
+        Some(&mut v[start..])
+    } else {
+        None
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-114312.rs b/tests/codegen-llvm/issues/issue-114312.rs
new file mode 100644
index 00000000000..61355dd5873
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-114312.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64-unknown-linux-gnu
+
+// We want to check that this function does not mis-optimize to loop jumping.
+
+#![crate_type = "lib"]
+
+#[repr(C)]
+pub enum Expr {
+    Sum,
+    // must have more than usize data
+    Sub(usize, u8),
+}
+
+#[no_mangle]
+pub extern "C" fn issue_114312(expr: Expr) {
+    // CHECK-LABEL: @issue_114312(
+    // CHECK-SAME: byval
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret void
+    match expr {
+        Expr::Sum => {}
+        Expr::Sub(_, _) => issue_114312(Expr::Sum),
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-115385-llvm-jump-threading.rs b/tests/codegen-llvm/issues/issue-115385-llvm-jump-threading.rs
new file mode 100644
index 00000000000..8cabd94f202
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-115385-llvm-jump-threading.rs
@@ -0,0 +1,46 @@
+//@ compile-flags: -Copt-level=3 -Ccodegen-units=1
+
+#![crate_type = "lib"]
+
+#[repr(i64)]
+pub enum Boolean {
+    False = 0,
+    True = 1,
+}
+
+impl Clone for Boolean {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl Copy for Boolean {}
+
+extern "C" {
+    fn set_value(foo: *mut i64);
+    fn bar();
+}
+
+pub fn foo(x: bool) {
+    let mut foo = core::mem::MaybeUninit::<i64>::uninit();
+    unsafe {
+        set_value(foo.as_mut_ptr());
+    }
+
+    if x {
+        let l1 = unsafe { *foo.as_mut_ptr().cast::<Boolean>() };
+        if matches!(l1, Boolean::False) {
+            unsafe {
+                *foo.as_mut_ptr() = 0;
+            }
+        }
+    }
+
+    let l2 = unsafe { *foo.as_mut_ptr() };
+    if l2 == 2 {
+        // CHECK: call void @bar
+        unsafe {
+            bar();
+        }
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-116878.rs b/tests/codegen-llvm/issues/issue-116878.rs
new file mode 100644
index 00000000000..daf46c8bb55
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-116878.rs
@@ -0,0 +1,11 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+/// Make sure no bounds checks are emitted after a `get_unchecked`.
+// CHECK-LABEL: @unchecked_slice_no_bounds_check
+#[no_mangle]
+pub unsafe fn unchecked_slice_no_bounds_check(s: &[u8]) -> u8 {
+    let a = *s.get_unchecked(1);
+    // CHECK-NOT: panic_bounds_check
+    a + s[0]
+}
diff --git a/tests/codegen-llvm/issues/issue-118306.rs b/tests/codegen-llvm/issues/issue-118306.rs
new file mode 100644
index 00000000000..f12dc7cdfe2
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-118306.rs
@@ -0,0 +1,22 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+// Test for #118306.
+// Make sure we don't create `br` or `select` instructions.
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+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], 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 {
+        1 | 2 => 1,
+        3 => 2,
+        _ => 0,
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-118392.rs b/tests/codegen-llvm/issues/issue-118392.rs
new file mode 100644
index 00000000000..07de8d9b237
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-118392.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @div2
+// CHECK: ashr i32 %a, 1
+// CHECK-NEXT: ret i32
+#[no_mangle]
+pub fn div2(a: i32) -> i32 {
+    a.div_euclid(2)
+}
diff --git a/tests/codegen-llvm/issues/issue-119422.rs b/tests/codegen-llvm/issues/issue-119422.rs
new file mode 100644
index 00000000000..17ae71605b5
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-119422.rs
@@ -0,0 +1,83 @@
+//! This test checks that compiler don't generate useless compares to zeros
+//! for `NonZero` integer types.
+//!
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+//@ edition: 2021
+//@ only-64bit (because the LLVM type of i64 for usize shows up)
+#![crate_type = "lib"]
+
+use core::num::NonZero;
+use core::ptr::NonNull;
+
+// CHECK-LABEL: @check_non_null
+#[no_mangle]
+pub fn check_non_null(x: NonNull<u8>) -> bool {
+    // CHECK: ret i1 false
+    x.as_ptr().is_null()
+}
+
+// CHECK-LABEL: @equals_zero_is_false_u8
+#[no_mangle]
+pub fn equals_zero_is_false_u8(x: NonZero<u8>) -> bool {
+    // CHECK-NOT: br
+    // CHECK: ret i1 false
+    // CHECK-NOT: br
+    x.get() == 0
+}
+
+// CHECK-LABEL: @not_equals_zero_is_true_u8
+#[no_mangle]
+pub fn not_equals_zero_is_true_u8(x: NonZero<u8>) -> bool {
+    // CHECK-NOT: br
+    // CHECK: ret i1 true
+    // CHECK-NOT: br
+    x.get() != 0
+}
+
+// CHECK-LABEL: @equals_zero_is_false_i8
+#[no_mangle]
+pub fn equals_zero_is_false_i8(x: NonZero<i8>) -> bool {
+    // CHECK-NOT: br
+    // CHECK: ret i1 false
+    // CHECK-NOT: br
+    x.get() == 0
+}
+
+// CHECK-LABEL: @not_equals_zero_is_true_i8
+#[no_mangle]
+pub fn not_equals_zero_is_true_i8(x: NonZero<i8>) -> bool {
+    // CHECK-NOT: br
+    // CHECK: ret i1 true
+    // CHECK-NOT: br
+    x.get() != 0
+}
+
+// CHECK-LABEL: @usize_try_from_u32
+#[no_mangle]
+pub fn usize_try_from_u32(x: NonZero<u32>) -> NonZero<usize> {
+    // CHECK-NOT: br
+    // CHECK: zext i32 %{{.*}} to i64
+    // CHECK-NOT: br
+    // CHECK: ret i64
+    x.try_into().unwrap()
+}
+
+// CHECK-LABEL: @isize_try_from_i32
+#[no_mangle]
+pub fn isize_try_from_i32(x: NonZero<i32>) -> NonZero<isize> {
+    // CHECK-NOT: br
+    // CHECK: sext i32 %{{.*}} to i64
+    // CHECK-NOT: br
+    // CHECK: ret i64
+    x.try_into().unwrap()
+}
+
+// CHECK-LABEL: @u64_from_nonzero_is_not_zero
+#[no_mangle]
+pub fn u64_from_nonzero_is_not_zero(x: NonZero<u64>) -> bool {
+    // CHECK-NOT: br
+    // CHECK: ret i1 false
+    // CHECK-NOT: br
+    let v: u64 = x.into();
+    v == 0
+}
diff --git a/tests/codegen-llvm/issues/issue-121719-common-field-offset.rs b/tests/codegen-llvm/issues/issue-121719-common-field-offset.rs
new file mode 100644
index 00000000000..9f5f44e0375
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-121719-common-field-offset.rs
@@ -0,0 +1,44 @@
+//! This test checks that match branches which all access a field
+//! at the same offset are merged together.
+//!
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+#[repr(C)]
+pub struct A {
+    x: f64,
+    y: u64,
+}
+#[repr(C)]
+pub struct B {
+    x: f64,
+    y: u32,
+}
+#[repr(C)]
+pub struct C {
+    x: f64,
+    y: u16,
+}
+#[repr(C)]
+pub struct D {
+    x: f64,
+    y: u8,
+}
+
+pub enum E {
+    A(A),
+    B(B),
+    C(C),
+    D(D),
+}
+
+// CHECK-LABEL: @match_on_e
+#[no_mangle]
+pub fn match_on_e(e: &E) -> &f64 {
+    // CHECK: start:
+    // CHECK-NEXT: getelementptr
+    // CHECK-NEXT: ret
+    match e {
+        E::A(A { x, .. }) | E::B(B { x, .. }) | E::C(C { x, .. }) | E::D(D { x, .. }) => x,
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs b/tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs
new file mode 100644
index 00000000000..853a1ff36b1
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-122600-ptr-discriminant-update.rs
@@ -0,0 +1,43 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// The bug here was that it was loading and storing the whole value.
+// It's ok for it to load the discriminant,
+// to preserve the UB from `unreachable_unchecked`,
+// but it better only store the constant discriminant of `B`.
+
+pub enum State {
+    A([u8; 753]),
+    B([u8; 753]),
+}
+
+// CHECK-LABEL: @update
+#[no_mangle]
+pub unsafe fn update(s: *mut State) {
+    // CHECK-NOT: alloca
+
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+    // CHECK-NOT: memcpy
+    // CHECK-NOT: 75{{3|4}}
+
+    // CHECK: %[[TAG:.+]] = load i8, ptr %s, align 1
+    // CHECK-NEXT: trunc nuw i8 %[[TAG]] to i1
+
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+    // CHECK-NOT: memcpy
+    // CHECK-NOT: 75{{3|4}}
+
+    // CHECK: store i8 1, ptr %s, align 1
+
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+    // CHECK-NOT: memcpy
+    // CHECK-NOT: 75{{3|4}}
+
+    // CHECK: ret
+    let State::A(v) = s.read() else { std::hint::unreachable_unchecked() };
+    s.write(State::B(v));
+}
diff --git a/tests/codegen-llvm/issues/issue-123712-str-to-lower-autovectorization.rs b/tests/codegen-llvm/issues/issue-123712-str-to-lower-autovectorization.rs
new file mode 100644
index 00000000000..11ee10e8cc3
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-123712-str-to-lower-autovectorization.rs
@@ -0,0 +1,23 @@
+//@ only-x86_64
+//@ compile-flags: -C opt-level=3
+#![crate_type = "lib"]
+#![no_std]
+#![feature(str_internals)]
+
+extern crate alloc;
+
+/// Ensure that the ascii-prefix loop for `str::to_lowercase` and `str::to_uppercase` uses vector
+/// instructions.
+///
+/// The llvm ir should be the same for all targets that support some form of simd. Only targets
+/// without any simd instructions would see scalarized ir.
+/// Unfortunately, there is no `only-simd` directive to only run this test on only such platforms,
+/// and using test revisions would still require the core libraries for all platforms.
+// CHECK-LABEL: @lower_while_ascii
+// CHECK: [[A:%[0-9]]] = load <16 x i8>
+// CHECK-NEXT: [[B:%[0-9]]] = icmp slt <16 x i8> [[A]], zeroinitializer
+// CHECK-NEXT: [[C:%[0-9]]] = bitcast <16 x i1> [[B]] to i16
+#[no_mangle]
+pub fn lower_while_ascii(s: &str) -> (alloc::string::String, &str) {
+    alloc::str::convert_while_ascii(s, u8::to_ascii_lowercase)
+}
diff --git a/tests/codegen-llvm/issues/issue-126585.rs b/tests/codegen-llvm/issues/issue-126585.rs
new file mode 100644
index 00000000000..466dab64cdc
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-126585.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -Copt-level=s
+//@ only-x86_64
+
+// Test for #126585.
+// Ensure that this IR doesn't have extra undef phi input, which also guarantees that this asm
+// doesn't have subsequent labels and unnecessary `jmp` instructions.
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+fn checked_div_round(a: u64, b: u64) -> Option<u64> {
+    // CHECK-LABEL: @checked_div_round
+    // CHECK: phi
+    // CHECK-NOT: undef
+    // CHECK: phi
+    // CHECK-NOT: undef
+    match b {
+        0 => None,
+        1 => Some(a),
+        // `a / b` is computable and `(a % b) * 2` can not overflow since `b >= 2`.
+        b => Some(a / b + if (a % b) * 2 >= b { 1 } else { 0 }),
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-129795.rs b/tests/codegen-llvm/issues/issue-129795.rs
new file mode 100644
index 00000000000..dc64ee35c97
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-129795.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -Copt-level=3
+//@ min-llvm-version: 20
+#![crate_type = "lib"]
+
+// Ensure that a modulo operation with an operand that is known to be
+// a power-of-two is properly optimized.
+
+// CHECK-LABEL: @modulo_with_power_of_two_divisor
+// CHECK: add i64 %divisor, -1
+// CHECK-NEXT: and i64
+// CHECK-NEXT: ret i64
+#[no_mangle]
+pub fn modulo_with_power_of_two_divisor(dividend: u64, divisor: u64) -> u64 {
+    assert!(divisor.is_power_of_two());
+    // should be optimized to (dividend & (divisor - 1))
+    dividend % divisor
+}
diff --git a/tests/codegen-llvm/issues/issue-13018.rs b/tests/codegen-llvm/issues/issue-13018.rs
new file mode 100644
index 00000000000..8040018b931
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-13018.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: -Copt-level=3
+
+// A drop([...].clone()) sequence on an Rc should be a no-op
+// In particular, no call to __rust_dealloc should be emitted
+//
+// We use a cdylib since it's a leaf unit for Rust purposes, so doesn't codegen -Zshare-generics
+// code.
+#![crate_type = "cdylib"]
+use std::rc::Rc;
+
+pub fn foo(t: &Rc<Vec<usize>>) {
+    // CHECK-NOT: __rust_dealloc
+    drop(t.clone());
+}
diff --git a/tests/codegen-llvm/issues/issue-136329-optnone-noinline.rs b/tests/codegen-llvm/issues/issue-136329-optnone-noinline.rs
new file mode 100644
index 00000000000..57c9e47a499
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-136329-optnone-noinline.rs
@@ -0,0 +1,21 @@
+//! Ensure that `#[optimize(none)]` functions are never inlined
+
+//@ compile-flags: -Copt-level=3
+
+#![feature(optimize_attribute)]
+
+#[optimize(none)]
+pub fn foo() {
+    let _x = 123;
+}
+
+// CHECK-LABEL: define{{.*}}void @bar
+// CHECK: start:
+// CHECK: {{.*}}call {{.*}}void
+// CHECK: ret void
+#[no_mangle]
+pub fn bar() {
+    foo();
+}
+
+fn main() {}
diff --git a/tests/codegen-llvm/issues/issue-15953.rs b/tests/codegen-llvm/issues/issue-15953.rs
new file mode 100644
index 00000000000..70e597ac1dd
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-15953.rs
@@ -0,0 +1,29 @@
+// Test that llvm generates `memcpy` for moving a value
+// inside a function and moving an argument.
+
+struct Foo {
+    x: Vec<i32>,
+}
+
+#[inline(never)]
+#[no_mangle]
+// CHECK: memcpy
+fn interior(x: Vec<i32>) -> Vec<i32> {
+    let Foo { x } = Foo { x };
+    x
+}
+
+#[inline(never)]
+#[no_mangle]
+// CHECK: memcpy
+fn exterior(x: Vec<i32>) -> Vec<i32> {
+    x
+}
+
+fn main() {
+    let x = interior(Vec::new());
+    println!("{:?}", x);
+
+    let x = exterior(Vec::new());
+    println!("{:?}", x);
+}
diff --git a/tests/codegen-llvm/issues/issue-27130.rs b/tests/codegen-llvm/issues/issue-27130.rs
new file mode 100644
index 00000000000..594e02af097
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-27130.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @trim_in_place
+#[no_mangle]
+pub fn trim_in_place(a: &mut &[u8]) {
+    while a.first() == Some(&42) {
+        // CHECK-NOT: slice_index_order_fail
+        *a = &a[1..];
+    }
+}
+
+// CHECK-LABEL: @trim_in_place2
+#[no_mangle]
+pub fn trim_in_place2(a: &mut &[u8]) {
+    while let Some(&42) = a.first() {
+        // CHECK-NOT: slice_index_order_fail
+        *a = &a[2..];
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-32031.rs b/tests/codegen-llvm/issues/issue-32031.rs
new file mode 100644
index 00000000000..559e8d947fb
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-32031.rs
@@ -0,0 +1,29 @@
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+// 32-bit x86 returns `f32` and `f64` differently to avoid the x87 stack.
+//@ revisions: x86 other
+//@[x86] only-rustc_abi-x86-sse2
+//@[other] ignore-x86
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub struct F32(f32);
+
+// other: define{{.*}}float @add_newtype_f32(float %a, float %b)
+// x86: define{{.*}}<4 x i8> @add_newtype_f32(float %a, float %b)
+#[inline(never)]
+#[no_mangle]
+pub fn add_newtype_f32(a: F32, b: F32) -> F32 {
+    F32(a.0 + b.0)
+}
+
+#[no_mangle]
+pub struct F64(f64);
+
+// other: define{{.*}}double @add_newtype_f64(double %a, double %b)
+// x86: define{{.*}}<8 x i8> @add_newtype_f64(double %a, double %b)
+#[inline(never)]
+#[no_mangle]
+pub fn add_newtype_f64(a: F64, b: F64) -> F64 {
+    F64(a.0 + b.0)
+}
diff --git a/tests/codegen-llvm/issues/issue-32364.rs b/tests/codegen-llvm/issues/issue-32364.rs
new file mode 100644
index 00000000000..016981d1947
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-32364.rs
@@ -0,0 +1,17 @@
+// Test that `extern "stdcall"` is properly translated.
+
+//@ only-x86
+
+//@ compile-flags: -C no-prepopulate-passes
+
+struct Foo;
+
+impl Foo {
+    // CHECK: define internal x86_stdcallcc void @{{.*}}foo{{.*}}()
+    #[inline(never)]
+    pub extern "stdcall" fn foo<T>() {}
+}
+
+fn main() {
+    Foo::foo::<Foo>();
+}
diff --git a/tests/codegen-llvm/issues/issue-34634.rs b/tests/codegen-llvm/issues/issue-34634.rs
new file mode 100644
index 00000000000..d32fa97ec38
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-34634.rs
@@ -0,0 +1,16 @@
+// Test that `wrapping_div` only checks divisor once.
+// This test checks that there is only a single compare against -1 and -1 is not present as a
+// switch case (the second check present until rustc 1.12).
+// This test also verifies that a single panic call is generated (for the division by zero case).
+
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @f
+#[no_mangle]
+pub fn f(x: i32, y: i32) -> i32 {
+    // CHECK-COUNT-1: icmp eq i32 %y, -1
+    // CHECK-COUNT-1: panic
+    // CHECK-NOT: i32 -1, label
+    x.wrapping_div(y)
+}
diff --git a/tests/codegen-llvm/issues/issue-34947-pow-i32.rs b/tests/codegen-llvm/issues/issue-34947-pow-i32.rs
new file mode 100644
index 00000000000..b4750cd35bc
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-34947-pow-i32.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @issue_34947
+#[no_mangle]
+pub fn issue_34947(x: i32) -> i32 {
+    // CHECK: mul
+    // CHECK-NEXT: mul
+    // CHECK-NEXT: mul
+    // CHECK-NEXT: ret
+    x.pow(5)
+}
diff --git a/tests/codegen-llvm/issues/issue-36010-some-box-is_some.rs b/tests/codegen-llvm/issues/issue-36010-some-box-is_some.rs
new file mode 100644
index 00000000000..c9a8262162d
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-36010-some-box-is_some.rs
@@ -0,0 +1,28 @@
+#![crate_type = "lib"]
+
+//@ compile-flags: -Copt-level=3
+
+use std::mem;
+
+fn foo<T>(a: &mut T, b: T) -> bool {
+    let b = Some(mem::replace(a, b));
+    let ret = b.is_some();
+    mem::forget(b);
+    return ret;
+}
+
+// CHECK-LABEL: @foo_u32
+// CHECK: store i32
+// CHECK-NEXT: ret i1 true
+#[no_mangle]
+pub fn foo_u32(a: &mut u32, b: u32) -> bool {
+    foo(a, b)
+}
+
+// CHECK-LABEL: @foo_box
+// CHECK: store ptr
+// CHECK-NEXT: ret i1 true
+#[no_mangle]
+pub fn foo_box(a: &mut Box<u32>, b: Box<u32>) -> bool {
+    foo(a, b)
+}
diff --git a/tests/codegen-llvm/issues/issue-37945.rs b/tests/codegen-llvm/issues/issue-37945.rs
new file mode 100644
index 00000000000..23d0eab8ae4
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-37945.rs
@@ -0,0 +1,34 @@
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+//@ ignore-32bit LLVM has a bug with them
+
+// Check that LLVM understands that `Iter` pointer is not null. Issue #37945.
+
+#![crate_type = "lib"]
+
+use std::slice::Iter;
+
+#[no_mangle]
+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]])
+    // 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}}
+    // CHECK-NEXT:    ret i1 [[B:%.*]]
+    { xs }.next().is_none()
+}
+
+#[no_mangle]
+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]])
+    // 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}}
+    // CHECK-NEXT:    ret i1 [[D:%.*]]
+    xs.map(|&x| x).next().is_none()
+}
diff --git a/tests/codegen-llvm/issues/issue-45222.rs b/tests/codegen-llvm/issues/issue-45222.rs
new file mode 100644
index 00000000000..0201363c41a
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-45222.rs
@@ -0,0 +1,62 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// verify that LLVM recognizes a loop involving 0..=n and will const-fold it.
+
+// Example from original issue #45222
+
+fn foo2(n: u64) -> u64 {
+    let mut count = 0;
+    for _ in 0..n {
+        for j in (0..=n).rev() {
+            count += j;
+        }
+    }
+    count
+}
+
+// CHECK-LABEL: @check_foo2
+#[no_mangle]
+pub fn check_foo2() -> u64 {
+    // CHECK: ret i64 500005000000000
+    foo2(100000)
+}
+
+// Simplified example of #45222
+//
+// Temporarily disabled in #68835 to fix a soundness hole.
+//
+// fn triangle_inc(n: u64) -> u64 {
+//     let mut count = 0;
+//     for j in 0 ..= n {
+//         count += j;
+//     }
+//     count
+// }
+//
+// // COMMENTEDCHECK-LABEL: @check_triangle_inc
+// #[no_mangle]
+// pub fn check_triangle_inc() -> u64 {
+//     // COMMENTEDCHECK: ret i64 5000050000
+//     triangle_inc(100000)
+// }
+
+// Demo in #48012
+
+fn foo3r(n: u64) -> u64 {
+    let mut count = 0;
+    (0..n).for_each(|_| {
+        (0..=n).rev().for_each(|j| {
+            count += j;
+        })
+    });
+    count
+}
+
+// CHECK-LABEL: @check_foo3r
+#[no_mangle]
+pub fn check_foo3r() -> u64 {
+    // CHECK: ret i64 500050000000
+    foo3r(10000)
+}
diff --git a/tests/codegen-llvm/issues/issue-45466.rs b/tests/codegen-llvm/issues/issue-45466.rs
new file mode 100644
index 00000000000..164a27ef5d4
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-45466.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "rlib"]
+
+// CHECK-LABEL: @memzero
+// CHECK-NOT: store
+// CHECK: call void @llvm.memset
+// CHECK-NOT: store
+#[no_mangle]
+pub fn memzero(data: &mut [u8]) {
+    for i in 0..data.len() {
+        data[i] = 0;
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-45964-bounds-check-slice-pos.rs b/tests/codegen-llvm/issues/issue-45964-bounds-check-slice-pos.rs
new file mode 100644
index 00000000000..a48bb2a1ccf
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-45964-bounds-check-slice-pos.rs
@@ -0,0 +1,38 @@
+// This test case checks that slice::{r}position functions do not
+// prevent optimizing away bounds checks
+
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "rlib"]
+
+// CHECK-LABEL: @test
+#[no_mangle]
+pub fn test(y: &[u32], x: &u32, z: &u32) -> bool {
+    let result = match y.iter().position(|a| a == x) {
+        Some(p) => Ok(p),
+        None => Err(()),
+    };
+
+    if let Ok(p) = result {
+        // CHECK-NOT: panic
+        y[p] == *z
+    } else {
+        false
+    }
+}
+
+// CHECK-LABEL: @rtest
+#[no_mangle]
+pub fn rtest(y: &[u32], x: &u32, z: &u32) -> bool {
+    let result = match y.iter().rposition(|a| a == x) {
+        Some(p) => Ok(p),
+        None => Err(()),
+    };
+
+    if let Ok(p) = result {
+        // CHECK-NOT: panic
+        y[p] == *z
+    } else {
+        false
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-47278.rs b/tests/codegen-llvm/issues/issue-47278.rs
new file mode 100644
index 00000000000..4f0a5bdf36f
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-47278.rs
@@ -0,0 +1,11 @@
+// -C no-prepopulate-passes
+#![crate_type = "staticlib"]
+
+#[repr(C)]
+pub struct Foo(u64);
+
+// CHECK: define {{.*}} @foo(
+#[no_mangle]
+pub extern "C" fn foo(_: Foo) -> Foo {
+    loop {}
+}
diff --git a/tests/codegen-llvm/issues/issue-47442.rs b/tests/codegen-llvm/issues/issue-47442.rs
new file mode 100644
index 00000000000..445234e55ad
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-47442.rs
@@ -0,0 +1,22 @@
+// check that we don't emit unneeded `resume` cleanup blocks for every
+// destructor.
+
+// CHECK-NOT: Unwind
+
+#![feature(test)]
+#![crate_type = "rlib"]
+
+extern crate test;
+
+struct Foo {}
+
+impl Drop for Foo {
+    fn drop(&mut self) {
+        test::black_box(());
+    }
+}
+
+#[no_mangle]
+pub fn foo() {
+    let _foo = Foo {};
+}
diff --git a/tests/codegen-llvm/issues/issue-56267-2.rs b/tests/codegen-llvm/issues/issue-56267-2.rs
new file mode 100644
index 00000000000..98e3732777e
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-56267-2.rs
@@ -0,0 +1,18 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "rlib"]
+
+#[allow(dead_code)]
+pub struct Foo<T> {
+    foo: u64,
+    bar: T,
+}
+
+// The load from bar.1 should have alignment 4. Not checking
+// other loads here, as the alignment will be platform-dependent.
+
+// CHECK: %{{.+}} = load i32, ptr %{{.+}}, align 4
+#[no_mangle]
+pub fn test(x: Foo<(i32, i32)>) -> (i32, i32) {
+    x.bar
+}
diff --git a/tests/codegen-llvm/issues/issue-56267.rs b/tests/codegen-llvm/issues/issue-56267.rs
new file mode 100644
index 00000000000..cabcc298482
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-56267.rs
@@ -0,0 +1,18 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "rlib"]
+
+#[allow(dead_code)]
+pub struct Foo<T> {
+    foo: u64,
+    bar: T,
+}
+
+// The store writing to bar.1 should have alignment 4. Not checking
+// other stores here, as the alignment will be platform-dependent.
+
+// CHECK: store i32 [[TMP1:%.+]], ptr [[TMP2:%.+]], align 4
+#[no_mangle]
+pub fn test(x: (i32, i32)) -> Foo<(i32, i32)> {
+    Foo { foo: 0, bar: x }
+}
diff --git a/tests/codegen-llvm/issues/issue-56927.rs b/tests/codegen-llvm/issues/issue-56927.rs
new file mode 100644
index 00000000000..415ef073e03
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-56927.rs
@@ -0,0 +1,46 @@
+//@ compile-flags: -C no-prepopulate-passes
+// 32bit MSVC does not align things properly so we suppress high alignment annotations (#112480)
+//@ ignore-i686-pc-windows-msvc
+//@ ignore-i686-pc-windows-gnu
+
+#![crate_type = "rlib"]
+
+#[repr(align(16))]
+pub struct S {
+    arr: [u32; 4],
+}
+
+// CHECK-LABEL: @test1
+// CHECK: store i32 0, ptr %{{.+}}, align 16
+// CHECK: store i32 1, ptr %{{.+}}, align 4
+// CHECK: store i32 2, ptr %{{.+}}, align 8
+// CHECK: store i32 3, ptr %{{.+}}, align 4
+#[no_mangle]
+pub fn test1(s: &mut S) {
+    s.arr[0] = 0;
+    s.arr[1] = 1;
+    s.arr[2] = 2;
+    s.arr[3] = 3;
+}
+
+// CHECK-LABEL: @test2
+// CHECK: store i32 4, ptr %{{.+}}, align 4
+#[allow(unconditional_panic)]
+#[no_mangle]
+pub fn test2(s: &mut S) {
+    s.arr[usize::MAX / 4 + 1] = 4;
+}
+
+// CHECK-LABEL: @test3
+// CHECK: store i32 5, ptr %{{.+}}, align 4
+#[no_mangle]
+pub fn test3(s: &mut S, i: usize) {
+    s.arr[i] = 5;
+}
+
+// CHECK-LABEL: @test4
+// CHECK: store i32 6, ptr %{{.+}}, align 4
+#[no_mangle]
+pub fn test4(s: &mut S) {
+    s.arr = [6; 4];
+}
diff --git a/tests/codegen-llvm/issues/issue-58881.rs b/tests/codegen-llvm/issues/issue-58881.rs
new file mode 100644
index 00000000000..ba6285f3972
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-58881.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+//
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+extern "C" {
+    fn variadic_fn(_: i32, ...);
+}
+
+#[repr(C)]
+struct Foo(u8);
+#[repr(C)]
+struct Bar(u64, u64, u64);
+
+// Ensure that emit arguments of the correct type.
+pub unsafe fn test_call_variadic() {
+    // CHECK: call void (i32, ...) @variadic_fn(i32 0, i8 {{.*}}, ptr {{.*}})
+    variadic_fn(0, Foo(0), Bar(0, 0, 0))
+}
diff --git a/tests/codegen-llvm/issues/issue-59352.rs b/tests/codegen-llvm/issues/issue-59352.rs
new file mode 100644
index 00000000000..cb4383d4a30
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-59352.rs
@@ -0,0 +1,18 @@
+// This test is a mirror of mir-opt/issues/issue-59352.rs. The LLVM inliner doesn't inline
+// `char::method::is_digit()` and `char::method::to_digit()`, probably because of their size.
+//
+// Currently, the MIR optimizer isn't capable of removing the unreachable panic in this test case.
+// Once the optimizer can do that, mir-opt/issues/issue-59352.rs will need to be updated and this
+// test case should be removed as it will become redundant.
+
+// mir-opt-level=3 enables inlining and enables LLVM to optimize away the unreachable panic call.
+//@ compile-flags: -Copt-level=3 -Z mir-opt-level=3
+
+#![crate_type = "rlib"]
+
+// CHECK-LABEL: @num_to_digit
+#[no_mangle]
+pub fn num_to_digit(num: char) -> u32 {
+    // CHECK-NOT: panic
+    if num.is_digit(8) { num.to_digit(8).unwrap() } else { 0 }
+}
diff --git a/tests/codegen-llvm/issues/issue-64219-fn-ptr-call-returning-never-is-noreturn.rs b/tests/codegen-llvm/issues/issue-64219-fn-ptr-call-returning-never-is-noreturn.rs
new file mode 100644
index 00000000000..86d020e1751
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-64219-fn-ptr-call-returning-never-is-noreturn.rs
@@ -0,0 +1,19 @@
+//! Test for https://github.com/rust-lang/rust/issues/64219
+//! Check if `noreturn` attribute is applied on calls to
+//! function pointers returning `!` (never type).
+
+#![crate_type = "lib"]
+
+extern "C" {
+    static FOO: fn() -> !;
+}
+
+// CHECK-LABEL: @foo
+#[no_mangle]
+pub unsafe fn foo() {
+    // CHECK: call
+    // CHECK-SAME: [[NUM:#[0-9]+$]]
+    FOO();
+}
+
+// CHECK: attributes [[NUM]] = {{{.*}} noreturn {{.*}}}
diff --git a/tests/codegen-llvm/issues/issue-68667-unwrap-combinators.rs b/tests/codegen-llvm/issues/issue-68667-unwrap-combinators.rs
new file mode 100644
index 00000000000..7f4a32109fe
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-68667-unwrap-combinators.rs
@@ -0,0 +1,15 @@
+#![crate_type = "lib"]
+
+//@ compile-flags: -Copt-level=3
+
+// MIR inlining now optimizes this code.
+
+// CHECK-LABEL: @unwrap_combinators
+// CHECK: {{icmp|trunc}}
+// CHECK-NEXT: icmp
+// CHECK-NEXT: select i1
+// CHECK-NEXT: ret i1
+#[no_mangle]
+pub fn unwrap_combinators(a: Option<i32>, b: i32) -> bool {
+    a.map(|t| t >= b).unwrap_or(false)
+}
diff --git a/tests/codegen-llvm/issues/issue-69101-bounds-check.rs b/tests/codegen-llvm/issues/issue-69101-bounds-check.rs
new file mode 100644
index 00000000000..953b79aa263
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-69101-bounds-check.rs
@@ -0,0 +1,42 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// Make sure no bounds checks are emitted in the loop when upfront slicing
+// ensures that the slices are big enough.
+// In particular, bounds checks were not always optimized out if the upfront
+// check was for a greater len than the loop requires.
+// (i.e. `already_sliced_no_bounds_check` was not always optimized even when
+// `already_sliced_no_bounds_check_exact` was)
+// CHECK-LABEL: @already_sliced_no_bounds_check
+#[no_mangle]
+pub fn already_sliced_no_bounds_check(a: &[u8], b: &[u8], c: &mut [u8]) {
+    // CHECK: slice_end_index_len_fail
+    // CHECK-NOT: panic_bounds_check
+    let _ = (&a[..2048], &b[..2048], &mut c[..2048]);
+    for i in 0..1024 {
+        c[i] = a[i] ^ b[i];
+    }
+}
+
+// CHECK-LABEL: @already_sliced_no_bounds_check_exact
+#[no_mangle]
+pub fn already_sliced_no_bounds_check_exact(a: &[u8], b: &[u8], c: &mut [u8]) {
+    // CHECK: slice_end_index_len_fail
+    // CHECK-NOT: panic_bounds_check
+    let _ = (&a[..1024], &b[..1024], &mut c[..1024]);
+    for i in 0..1024 {
+        c[i] = a[i] ^ b[i];
+    }
+}
+
+// Make sure we're checking for the right thing: there can be a panic if the slice is too small.
+// CHECK-LABEL: @already_sliced_bounds_check
+#[no_mangle]
+pub fn already_sliced_bounds_check(a: &[u8], b: &[u8], c: &mut [u8]) {
+    // CHECK: slice_end_index_len_fail
+    // CHECK: panic_bounds_check
+    let _ = (&a[..1023], &b[..2048], &mut c[..2048]);
+    for i in 0..1024 {
+        c[i] = a[i] ^ b[i];
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-73031.rs b/tests/codegen-llvm/issues/issue-73031.rs
new file mode 100644
index 00000000000..80dea9b5bc2
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-73031.rs
@@ -0,0 +1,22 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// Test that LLVM can eliminate the unreachable `All::None` branch.
+
+pub enum All {
+    None,
+    Foo,
+    Bar,
+}
+
+// CHECK-LABEL: @issue_73031
+#[no_mangle]
+pub fn issue_73031(a: &mut All, q: i32) -> i32 {
+    *a = if q == 5 { All::Foo } else { All::Bar };
+    match *a {
+        // CHECK-NOT: panic
+        All::None => panic!(),
+        All::Foo => 1,
+        All::Bar => 2,
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-73258.rs b/tests/codegen-llvm/issues/issue-73258.rs
new file mode 100644
index 00000000000..936a7554496
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-73258.rs
@@ -0,0 +1,40 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// Adapted from <https://github.com/rust-lang/rust/issues/73258#issue-637346014>
+
+#[derive(Clone, Copy)]
+#[repr(u8)]
+pub enum Foo {
+    A,
+    B,
+    C,
+    D,
+}
+
+// CHECK-LABEL: @issue_73258(
+#[no_mangle]
+pub unsafe fn issue_73258(ptr: *const Foo) -> Foo {
+    // CHECK-NOT: icmp
+    // CHECK-NOT: call
+    // CHECK-NOT: br
+    // CHECK-NOT: select
+
+    // CHECK: %[[R:.+]] = load i8
+    // CHECK-SAME: !range !
+
+    // CHECK-NOT: icmp
+    // CHECK-NOT: call
+    // CHECK-NOT: br
+    // CHECK-NOT: select
+
+    // CHECK: ret i8 %[[R]]
+
+    // CHECK-NOT: icmp
+    // CHECK-NOT: call
+    // CHECK-NOT: br
+    // CHECK-NOT: select
+    let k: Option<Foo> = Some(ptr.read());
+    return k.unwrap();
+}
diff --git a/tests/codegen-llvm/issues/issue-73338-effecient-cmp.rs b/tests/codegen-llvm/issues/issue-73338-effecient-cmp.rs
new file mode 100644
index 00000000000..71641a5457b
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-73338-effecient-cmp.rs
@@ -0,0 +1,39 @@
+// This test checks that comparison operation
+// generated by #[derive(PartialOrd)]
+// doesn't contain jumps for C enums
+
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[repr(u32)]
+#[derive(Copy, Clone, Eq, PartialEq, PartialOrd)]
+pub enum Foo {
+    Zero,
+    One,
+    Two,
+}
+
+#[no_mangle]
+pub fn compare_less(a: Foo, b: Foo) -> bool {
+    // CHECK-NOT: br {{.*}}
+    a < b
+}
+
+#[no_mangle]
+pub fn compare_le(a: Foo, b: Foo) -> bool {
+    // CHECK-NOT: br {{.*}}
+    a <= b
+}
+
+#[no_mangle]
+pub fn compare_ge(a: Foo, b: Foo) -> bool {
+    // CHECK-NOT: br {{.*}}
+    a >= b
+}
+
+#[no_mangle]
+pub fn compare_greater(a: Foo, b: Foo) -> bool {
+    // CHECK-NOT: br {{.*}}
+    a > b
+}
diff --git a/tests/codegen-llvm/issues/issue-73396-bounds-check-after-position.rs b/tests/codegen-llvm/issues/issue-73396-bounds-check-after-position.rs
new file mode 100644
index 00000000000..1e2c25babe0
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-73396-bounds-check-after-position.rs
@@ -0,0 +1,70 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// Make sure no bounds checks are emitted when slicing or indexing
+// with an index from `position()` or `rposition()`.
+
+// CHECK-LABEL: @position_slice_to_no_bounds_check
+#[no_mangle]
+pub fn position_slice_to_no_bounds_check(s: &[u8]) -> &[u8] {
+    // CHECK-NOT: panic
+    // CHECK-NOT: slice_start_index_len_fail
+    // CHECK-NOT: slice_end_index_len_fail
+    // CHECK-NOT: panic_bounds_check
+    // CHECK-NOT: unreachable
+    if let Some(idx) = s.iter().position(|b| *b == b'\\') { &s[..idx] } else { s }
+}
+
+// CHECK-LABEL: @position_slice_from_no_bounds_check
+#[no_mangle]
+pub fn position_slice_from_no_bounds_check(s: &[u8]) -> &[u8] {
+    // CHECK-NOT: panic
+    // CHECK-NOT: slice_start_index_len_fail
+    // CHECK-NOT: slice_end_index_len_fail
+    // CHECK-NOT: panic_bounds_check
+    // CHECK-NOT: unreachable
+    if let Some(idx) = s.iter().position(|b| *b == b'\\') { &s[idx..] } else { s }
+}
+
+// CHECK-LABEL: @position_index_no_bounds_check
+#[no_mangle]
+pub fn position_index_no_bounds_check(s: &[u8]) -> u8 {
+    // CHECK-NOT: panic
+    // CHECK-NOT: slice_start_index_len_fail
+    // CHECK-NOT: slice_end_index_len_fail
+    // CHECK-NOT: panic_bounds_check
+    // CHECK-NOT: unreachable
+    if let Some(idx) = s.iter().position(|b| *b == b'\\') { s[idx] } else { 42 }
+}
+// CHECK-LABEL: @rposition_slice_to_no_bounds_check
+#[no_mangle]
+pub fn rposition_slice_to_no_bounds_check(s: &[u8]) -> &[u8] {
+    // CHECK-NOT: panic
+    // CHECK-NOT: slice_start_index_len_fail
+    // CHECK-NOT: slice_end_index_len_fail
+    // CHECK-NOT: panic_bounds_check
+    // CHECK-NOT: unreachable
+    if let Some(idx) = s.iter().rposition(|b| *b == b'\\') { &s[..idx] } else { s }
+}
+
+// CHECK-LABEL: @rposition_slice_from_no_bounds_check
+#[no_mangle]
+pub fn rposition_slice_from_no_bounds_check(s: &[u8]) -> &[u8] {
+    // CHECK-NOT: panic
+    // CHECK-NOT: slice_start_index_len_fail
+    // CHECK-NOT: slice_end_index_len_fail
+    // CHECK-NOT: panic_bounds_check
+    // CHECK-NOT: unreachable
+    if let Some(idx) = s.iter().rposition(|b| *b == b'\\') { &s[idx..] } else { s }
+}
+
+// CHECK-LABEL: @rposition_index_no_bounds_check
+#[no_mangle]
+pub fn rposition_index_no_bounds_check(s: &[u8]) -> u8 {
+    // CHECK-NOT: panic
+    // CHECK-NOT: slice_start_index_len_fail
+    // CHECK-NOT: slice_end_index_len_fail
+    // CHECK-NOT: panic_bounds_check
+    // CHECK-NOT: unreachable
+    if let Some(idx) = s.iter().rposition(|b| *b == b'\\') { s[idx] } else { 42 }
+}
diff --git a/tests/codegen-llvm/issues/issue-73827-bounds-check-index-in-subexpr.rs b/tests/codegen-llvm/issues/issue-73827-bounds-check-index-in-subexpr.rs
new file mode 100644
index 00000000000..e9dd0d1bf23
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-73827-bounds-check-index-in-subexpr.rs
@@ -0,0 +1,17 @@
+// This test checks that bounds checks are elided when
+// index is part of a (x | y) < C style condition
+
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @get
+#[no_mangle]
+pub fn get(array: &[u8; 8], x: usize, y: usize) -> u8 {
+    if x > 7 || y > 7 {
+        0
+    } else {
+        // CHECK-NOT: panic_bounds_check
+        array[y]
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-74938-array-split-at.rs b/tests/codegen-llvm/issues/issue-74938-array-split-at.rs
new file mode 100644
index 00000000000..9d3e23d642b
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-74938-array-split-at.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+const N: usize = 3;
+pub type T = u8;
+
+// CHECK-LABEL: @split_multiple
+// CHECK-NOT: unreachable
+#[no_mangle]
+pub fn split_multiple(slice: &[T]) -> (&[T], &[T]) {
+    let len = slice.len() / N;
+    slice.split_at(len * N)
+}
diff --git a/tests/codegen-llvm/issues/issue-75525-bounds-checks.rs b/tests/codegen-llvm/issues/issue-75525-bounds-checks.rs
new file mode 100644
index 00000000000..5dfbd350010
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-75525-bounds-checks.rs
@@ -0,0 +1,26 @@
+// Regression test for #75525, verifies that no bounds checks are generated.
+
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @f0
+// CHECK-NOT: panic
+#[no_mangle]
+pub fn f0(idx: usize, buf: &[u8; 10]) -> u8 {
+    if idx < 8 { buf[idx + 1] } else { 0 }
+}
+
+// CHECK-LABEL: @f1
+// CHECK-NOT: panic
+#[no_mangle]
+pub fn f1(idx: usize, buf: &[u8; 10]) -> u8 {
+    if idx > 5 && idx < 8 { buf[idx - 1] } else { 0 }
+}
+
+// CHECK-LABEL: @f2
+// CHECK-NOT: panic
+#[no_mangle]
+pub fn f2(idx: usize, buf: &[u8; 10]) -> u8 {
+    if idx > 5 && idx < 8 { buf[idx] } else { 0 }
+}
diff --git a/tests/codegen-llvm/issues/issue-75546.rs b/tests/codegen-llvm/issues/issue-75546.rs
new file mode 100644
index 00000000000..1e1e6543a88
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-75546.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// Test that LLVM can eliminate the impossible `i == 0` check.
+
+// CHECK-LABEL: @issue_75546
+#[no_mangle]
+pub fn issue_75546() {
+    let mut i = 1u32;
+    while i < u32::MAX {
+        // CHECK-NOT: panic
+        if i == 0 {
+            panic!();
+        }
+        i += 1;
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-75659.rs b/tests/codegen-llvm/issues/issue-75659.rs
new file mode 100644
index 00000000000..0960bfdb6b0
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-75659.rs
@@ -0,0 +1,63 @@
+// This test checks that the call to memchr/slice_contains is optimized away
+// when searching in small slices.
+
+//@ compile-flags: -Copt-level=3 -Zinline-mir=false
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @foo1
+#[no_mangle]
+pub fn foo1(x: u8, data: &[u8; 1]) -> bool {
+    // CHECK-NOT: memchr
+    // CHECK-NOT: slice_contains
+    data.contains(&x)
+}
+
+// CHECK-LABEL: @foo2
+#[no_mangle]
+pub fn foo2(x: u8, data: &[u8; 2]) -> bool {
+    // CHECK-NOT: memchr
+    // CHECK-NOT: slice_contains
+    data.contains(&x)
+}
+
+// CHECK-LABEL: @foo3
+#[no_mangle]
+pub fn foo3(x: u8, data: &[u8; 3]) -> bool {
+    // CHECK-NOT: memchr
+    // CHECK-NOT: slice_contains
+    data.contains(&x)
+}
+
+// CHECK-LABEL: @foo4
+#[no_mangle]
+pub fn foo4(x: u8, data: &[u8; 4]) -> bool {
+    // CHECK-NOT: memchr
+    // CHECK-NOT: slice_contains
+    data.contains(&x)
+}
+
+// CHECK-LABEL: @foo8
+#[no_mangle]
+pub fn foo8(x: u8, data: &[u8; 8]) -> bool {
+    // CHECK-NOT: memchr
+    // CHECK-NOT: slice_contains
+    data.contains(&x)
+}
+
+// CHECK-LABEL: @foo8_i8
+#[no_mangle]
+pub fn foo8_i8(x: i8, data: &[i8; 8]) -> bool {
+    // CHECK-NOT: memchr
+    // CHECK-NOT: slice_contains
+    !data.contains(&x)
+}
+
+// Check that the general case isn't inlined
+// CHECK-LABEL: @foo80
+#[no_mangle]
+pub fn foo80(x: u8, data: &[u8; 80]) -> bool {
+    // CHECK: call core::slice::memchr
+    data.contains(&x)
+}
diff --git a/tests/codegen-llvm/issues/issue-75978.rs b/tests/codegen-llvm/issues/issue-75978.rs
new file mode 100644
index 00000000000..f4b0bc36329
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-75978.rs
@@ -0,0 +1,18 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn test() -> u32 {
+    // CHECK-LABEL: @test(
+    // CHECK: ret i32 13
+    let s = [1, 2, 3, 4, 5, 6, 7];
+
+    let mut iter = s.iter();
+    let mut sum = 0;
+    while let Some(_) = iter.next() {
+        sum += iter.next().map_or(1, |&x| x)
+    }
+
+    sum
+}
diff --git a/tests/codegen-llvm/issues/issue-77812.rs b/tests/codegen-llvm/issues/issue-77812.rs
new file mode 100644
index 00000000000..09e2376c30d
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-77812.rs
@@ -0,0 +1,32 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// Test that LLVM can eliminate the unreachable `Variant::Zero` branch.
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub enum Variant {
+    Zero,
+    One,
+    Two,
+}
+
+extern "C" {
+    fn exf1();
+    fn exf2();
+}
+
+pub static mut GLOBAL: Variant = Variant::Zero;
+
+// CHECK-LABEL: @issue_77812
+#[no_mangle]
+pub unsafe fn issue_77812() {
+    let g = GLOBAL;
+    if g != Variant::Zero {
+        match g {
+            Variant::One => exf1(),
+            Variant::Two => exf2(),
+            // CHECK-NOT: panic
+            Variant::Zero => panic!(),
+        }
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-84268.rs b/tests/codegen-llvm/issues/issue-84268.rs
new file mode 100644
index 00000000000..1dc55a909ad
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-84268.rs
@@ -0,0 +1,18 @@
+//@ compile-flags: -Copt-level=3 --crate-type=rlib
+#![feature(core_intrinsics, repr_simd)]
+
+use std::intrinsics::simd::{simd_eq, simd_fabs};
+
+#[repr(simd)]
+pub struct V([f32; 4]);
+
+#[repr(simd)]
+pub struct M([i32; 4]);
+
+#[no_mangle]
+// CHECK-LABEL: @is_infinite
+pub fn is_infinite(v: V) -> M {
+    // CHECK: fabs
+    // CHECK: cmp oeq
+    unsafe { simd_eq(simd_fabs(v), V([f32::INFINITY; 4])) }
+}
diff --git a/tests/codegen-llvm/issues/issue-85872-multiple-reverse.rs b/tests/codegen-llvm/issues/issue-85872-multiple-reverse.rs
new file mode 100644
index 00000000000..6f566ddee6b
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-85872-multiple-reverse.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn u16_be_to_arch(mut data: [u8; 2]) -> [u8; 2] {
+    // CHECK-LABEL: @u16_be_to_arch
+    // CHECK: @llvm.bswap.i16
+    data.reverse();
+    data
+}
+
+#[no_mangle]
+pub fn u32_be_to_arch(mut data: [u8; 4]) -> [u8; 4] {
+    // CHECK-LABEL: @u32_be_to_arch
+    // CHECK: @llvm.bswap.i32
+    data.reverse();
+    data
+}
diff --git a/tests/codegen-llvm/issues/issue-86106.rs b/tests/codegen-llvm/issues/issue-86106.rs
new file mode 100644
index 00000000000..8d1ce116d26
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-86106.rs
@@ -0,0 +1,63 @@
+//@ only-64bit llvm appears to use stores instead of memset on 32bit
+//@ compile-flags: -C opt-level=3 -Z merge-functions=disabled
+//@ needs-deterministic-layouts
+
+// The below two functions ensure that both `String::new()` and `"".to_string()`
+// produce the identical code.
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: define {{(dso_local )?}}void @string_new
+#[no_mangle]
+pub fn string_new() -> String {
+    // CHECK-NOT: load i8
+    // CHECK: store i{{32|64}}
+    // CHECK-NEXT: getelementptr
+    // CHECK-NEXT: store ptr
+    // CHECK-NEXT: getelementptr
+    // CHECK-NEXT: store i{{32|64}}
+    // CHECK-NEXT: ret void
+    String::new()
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}void @empty_to_string
+#[no_mangle]
+pub fn empty_to_string() -> String {
+    // CHECK-NOT: load i8
+    // CHECK: store i{{32|64}}
+    // CHECK-NEXT: getelementptr
+    // CHECK-NEXT: store ptr
+    // CHECK-NEXT: getelementptr
+    // CHECK-NEXT: store i{{32|64}}
+    // CHECK-NEXT: ret void
+    "".to_string()
+}
+
+// The below two functions ensure that both `vec![]` and `vec![].clone()`
+// produce the identical code.
+
+// CHECK-LABEL: @empty_vec
+#[no_mangle]
+pub fn empty_vec() -> Vec<u8> {
+    // CHECK: store i{{32|64}}
+    // CHECK-NOT: load i8
+    // CHECK-NEXT: getelementptr
+    // CHECK-NEXT: store ptr
+    // CHECK-NEXT: getelementptr
+    // CHECK-NEXT: store i{{32|64}}
+    // CHECK-NEXT: ret void
+    vec![]
+}
+
+// CHECK-LABEL: @empty_vec_clone
+#[no_mangle]
+pub fn empty_vec_clone() -> Vec<u8> {
+    // CHECK: store i{{32|64}}
+    // CHECK-NOT: load i8
+    // CHECK-NEXT: getelementptr
+    // CHECK-NEXT: store ptr
+    // CHECK-NEXT: getelementptr
+    // CHECK-NEXT: store i{{32|64}}
+    // CHECK-NEXT: ret void
+    vec![].clone()
+}
diff --git a/tests/codegen-llvm/issues/issue-86109-eliminate-div-by-zero-check.rs b/tests/codegen-llvm/issues/issue-86109-eliminate-div-by-zero-check.rs
new file mode 100644
index 00000000000..345c09738b6
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-86109-eliminate-div-by-zero-check.rs
@@ -0,0 +1,26 @@
+//@ compile-flags: -Copt-level=3
+//! Test for https://github.com/rust-lang/rust/issues/86109
+//! Check LLVM can eliminate the impossible division by zero check by
+//! ensuring there is no call (to panic) instruction.
+//!
+//! This has been fixed since `rustc 1.70.0`.
+
+#![crate_type = "lib"]
+
+type T = i16;
+
+// CHECK-LABEL: @foo
+#[no_mangle]
+pub fn foo(start: T) -> T {
+    // CHECK-NOT: panic
+    if start <= 0 {
+        return 0;
+    }
+    let mut count = 0;
+    for i in start..10_000 {
+        if 752 % i != 0 {
+            count += 1;
+        }
+    }
+    count
+}
diff --git a/tests/codegen-llvm/issues/issue-93036-assert-index.rs b/tests/codegen-llvm/issues/issue-93036-assert-index.rs
new file mode 100644
index 00000000000..46f45c2f06e
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-93036-assert-index.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+// CHECK-LABEL: @foo
+// CHECK-NOT: unreachable
+pub fn foo(arr: &mut [u32]) {
+    for i in 0..arr.len() {
+        for j in 0..i {
+            assert!(j < arr.len());
+        }
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-96274.rs b/tests/codegen-llvm/issues/issue-96274.rs
new file mode 100644
index 00000000000..2425ec53e4e
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-96274.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+use std::mem::MaybeUninit;
+
+pub fn maybe_uninit() -> [MaybeUninit<u8>; 3000] {
+    // CHECK-NOT: memset
+    [MaybeUninit::uninit(); 3000]
+}
+
+pub fn maybe_uninit_const<T>() -> [MaybeUninit<T>; 8192] {
+    // CHECK-NOT: memset
+    [const { MaybeUninit::uninit() }; 8192]
+}
diff --git a/tests/codegen-llvm/issues/issue-96497-slice-size-nowrap.rs b/tests/codegen-llvm/issues/issue-96497-slice-size-nowrap.rs
new file mode 100644
index 00000000000..7b3a20a295e
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-96497-slice-size-nowrap.rs
@@ -0,0 +1,38 @@
+// This test case checks that LLVM is aware that computing the size of a slice cannot wrap.
+// The possibility of wrapping results in an additional branch when dropping boxed slices
+// in some situations, see https://github.com/rust-lang/rust/issues/96497#issuecomment-1112865218
+
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @simple_size_of_nowrap
+#[no_mangle]
+pub fn simple_size_of_nowrap(x: &[u32]) -> usize {
+    // Make sure the shift used to compute the size has a nowrap flag.
+
+    // CHECK: [[A:%.*]] = shl nuw nsw {{.*}}, 2
+    // CHECK-NEXT: ret {{.*}} [[A]]
+    core::mem::size_of_val(x)
+}
+
+// CHECK-LABEL: @drop_write
+#[no_mangle]
+pub fn drop_write(mut x: Box<[u32]>) {
+    // Check that this write is optimized out.
+    // This depends on the size calculation not wrapping,
+    // since otherwise LLVM can't tell that the memory is always deallocated if the slice len > 0.
+
+    // CHECK-NOT: store i32 42
+    x[1] = 42;
+}
+
+// CHECK-LABEL: @slice_size_plus_2
+#[no_mangle]
+pub fn slice_size_plus_2(x: &[u16]) -> usize {
+    // Before #136575 this didn't get the `nuw` in the add.
+
+    // CHECK: [[BYTES:%.+]] = shl nuw nsw {{i16|i32|i64}} %x.1, 1
+    // CHECK: = add nuw {{i16|i32|i64}} [[BYTES]], 2
+    core::mem::size_of_val(x) + 2
+}
diff --git a/tests/codegen-llvm/issues/issue-98294-get-mut-copy-from-slice-opt.rs b/tests/codegen-llvm/issues/issue-98294-get-mut-copy-from-slice-opt.rs
new file mode 100644
index 00000000000..76adcf9fd45
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-98294-get-mut-copy-from-slice-opt.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// There should be no calls to panic / len_mismatch_fail.
+
+#[no_mangle]
+pub fn test(a: &mut [u8], offset: usize, bytes: &[u8]) {
+    // CHECK-LABEL: @test(
+    // CHECK-NOT: call
+    // CHECK: call void @llvm.memcpy
+    // CHECK-NOT: call
+    // CHECK: }
+    if let Some(dst) = a.get_mut(offset..offset + bytes.len()) {
+        dst.copy_from_slice(bytes);
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-98678-async.rs b/tests/codegen-llvm/issues/issue-98678-async.rs
new file mode 100644
index 00000000000..3dd06bb5194
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-98678-async.rs
@@ -0,0 +1,27 @@
+// ignore-tidy-linelength
+//! This test verifies the accuracy of emitted file and line debuginfo metadata for async blocks and
+//! async functions.
+
+//@ revisions: MSVC NONMSVC
+//@[MSVC] only-msvc
+//@[NONMSVC] ignore-msvc
+//@ edition:2021
+//@ compile-flags: --crate-type=lib -Copt-level=0 -Cdebuginfo=2 -Zdebug-info-type-line-numbers=true
+
+// NONMSVC-DAG: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*[/\\]}}issue-98678-async.rs{{".*}})
+// MSVC: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*}}\\issue-98678-async.rs{{".*}})
+
+// NONMSVC-DAG: !DISubprogram(name: "foo",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+// MSVC-DAG: !DISubprogram(name: "foo",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+pub async fn foo() -> u8 {
+    5
+}
+
+pub fn bar() -> impl std::future::Future<Output = u8> {
+    // NONMSVC: !DICompositeType({{.*"}}{async_block_env#0}{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+    // MSVC-DAG: !DICompositeType({{.*"}}enum2$<issue_98678_async::bar::async_block_env$0>{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+    async {
+        let x: u8 = foo().await;
+        x + 5
+    }
+}
diff --git a/tests/codegen-llvm/issues/issue-98678-closure-coroutine.rs b/tests/codegen-llvm/issues/issue-98678-closure-coroutine.rs
new file mode 100644
index 00000000000..8763bcb799d
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-98678-closure-coroutine.rs
@@ -0,0 +1,25 @@
+// ignore-tidy-linelength
+//! This test verifies the accuracy of emitted file and line debuginfo metadata for closures and
+//! coroutines.
+
+#![feature(coroutines, stmt_expr_attributes)]
+
+//@ revisions: MSVC NONMSVC
+//@[MSVC] only-msvc
+//@[NONMSVC] ignore-msvc
+//@ compile-flags: --crate-type=lib -Copt-level=0 -Cdebuginfo=2 -Zdebug-info-type-line-numbers=true
+
+// NONMSVC-DAG: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*[/\\]}}issue-98678-closure-coroutine.rs{{".*}})
+// MSVC-DAG: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*}}\\issue-98678-closure-coroutine.rs{{".*}})
+
+pub fn foo() {
+    // NONMSVC-DAG: !DICompositeType({{.*"}}{closure_env#0}{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+    // MSVC-DAG: !DICompositeType({{.*"}}closure_env$0{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+    let closure = |x| x;
+    closure(0);
+
+    // NONMSVC-DAG: !DICompositeType({{.*"[{]}}coroutine_env#1{{[}]".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 3]],
+    // MSVC-DAG: !DICompositeType({{.*".*foo::}}coroutine_env$1>{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+    let _coroutine = #[coroutine]
+    || yield 1;
+}
diff --git a/tests/codegen-llvm/issues/issue-98678-enum.rs b/tests/codegen-llvm/issues/issue-98678-enum.rs
new file mode 100644
index 00000000000..87bf8797293
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-98678-enum.rs
@@ -0,0 +1,42 @@
+// ignore-tidy-linelength
+//! This test verifies the accuracy of emitted file and line debuginfo metadata enums.
+
+//@ revisions: MSVC NONMSVC
+//@[MSVC] only-msvc
+//@[NONMSVC] ignore-msvc
+//@ compile-flags: --crate-type=lib -Copt-level=0 -Cdebuginfo=2 -Zdebug-info-type-line-numbers=true
+
+// NONMSVC: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*[/\\]}}issue-98678-enum.rs{{".*}})
+// MSVC: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*}}\\issue-98678-enum.rs{{".*}})
+
+// NONMSVC: !DICompositeType({{.*"}}SingleCase{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+// MSVC: !DICompositeType({{.*"}}enum2$<issue_98678_enum::SingleCase>{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+pub enum SingleCase {
+    // NONMSVC: !DIDerivedType(tag: DW_TAG_member, name: "One",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+    // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "One",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+    One,
+}
+
+// NONMSVC: !DICompositeType({{.*"}}MultipleDataCases{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+// MSVC: !DICompositeType({{.*"}}enum2$<issue_98678_enum::MultipleDataCases>{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+pub enum MultipleDataCases {
+    // NONMSVC: !DIDerivedType(tag: DW_TAG_member, name: "Case1",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+    // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Case1",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+    Case1(u32),
+    // NONMSVC: !DIDerivedType(tag: DW_TAG_member, name: "Case2",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+    // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Case2",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+    Case2(i64),
+}
+
+// NONMSVC: !DICompositeType({{.*"}}NicheLayout{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+// MSVC: !DICompositeType({{.*"}}enum2$<issue_98678_enum::NicheLayout>{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+pub enum NicheLayout {
+    // NONMSVC: !DIDerivedType(tag: DW_TAG_member, name: "Something",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+    // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Something",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+    Something(&'static u32),
+    // NONMSVC: !DIDerivedType(tag: DW_TAG_member, name: "Nothing",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
+    // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Nothing",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+    Nothing,
+}
+
+pub fn foo(_: SingleCase, _: MultipleDataCases, _: NicheLayout) {}
diff --git a/tests/codegen-llvm/issues/issue-98678-struct-union.rs b/tests/codegen-llvm/issues/issue-98678-struct-union.rs
new file mode 100644
index 00000000000..a83a585a433
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-98678-struct-union.rs
@@ -0,0 +1,27 @@
+// ignore-tidy-linelength
+//! This test verifies the accuracy of emitted file and line debuginfo metadata for structs and
+//! unions.
+
+//@ revisions: MSVC NONMSVC
+//@[MSVC] only-msvc
+//@[NONMSVC] ignore-msvc
+//@ compile-flags: --crate-type=lib -Copt-level=0 -Cdebuginfo=2 -Zdebug-info-type-line-numbers=true
+
+// NONMSVC: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*[/\\]}}issue-98678-struct-union.rs{{".*}})
+// MSVC: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*}}\\issue-98678-struct-union.rs{{".*}})
+
+// CHECK: !DICompositeType({{.*"}}MyType{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+pub struct MyType {
+    // CHECK: !DIDerivedType({{.*"}}i{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+    i: i32,
+}
+
+// CHECK: !DICompositeType({{.*"}}MyUnion{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+pub union MyUnion {
+    // CHECK: !DIDerivedType({{.*"}}i{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+    i: i32,
+    // CHECK: !DIDerivedType({{.*"}}f{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
+    f: f32,
+}
+
+pub fn foo(_: MyType, _: MyUnion) {}
diff --git a/tests/codegen-llvm/issues/issue-99960.rs b/tests/codegen-llvm/issues/issue-99960.rs
new file mode 100644
index 00000000000..571a9be967d
--- /dev/null
+++ b/tests/codegen-llvm/issues/issue-99960.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn test(dividend: i64, divisor: i64) -> Option<i64> {
+    // CHECK-LABEL: @test(
+    // CHECK-NOT: panic
+    if dividend > i64::min_value() && divisor != 0 { Some(dividend / divisor) } else { None }
+}
diff --git a/tests/codegen-llvm/issues/looping-over-ne-bytes-133528.rs b/tests/codegen-llvm/issues/looping-over-ne-bytes-133528.rs
new file mode 100644
index 00000000000..35acf765d69
--- /dev/null
+++ b/tests/codegen-llvm/issues/looping-over-ne-bytes-133528.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -Copt-level=3
+//@ min-llvm-version: 20
+#![crate_type = "lib"]
+
+/// Ensure the function is properly optimized
+/// In the issue #133528, the function was not getting optimized
+/// whereas, a version with `bytes` wrapped into a `black_box` was optimized
+/// It was probably a LLVM bug that was fixed in LLVM 20
+
+// CHECK-LABEL: @looping_over_ne_bytes
+// CHECK: icmp eq i64 %input, -1
+// CHECK-NEXT: ret i1
+#[no_mangle]
+fn looping_over_ne_bytes(input: u64) -> bool {
+    let bytes = input.to_ne_bytes();
+    bytes.iter().all(|x| *x == !0)
+}
diff --git a/tests/codegen-llvm/issues/str-to-string-128690.rs b/tests/codegen-llvm/issues/str-to-string-128690.rs
new file mode 100644
index 00000000000..d9e69764be2
--- /dev/null
+++ b/tests/codegen-llvm/issues/str-to-string-128690.rs
@@ -0,0 +1,38 @@
+//@ compile-flags: -C opt-level=3 -Z merge-functions=disabled
+#![crate_type = "lib"]
+
+//! Make sure str::to_string is specialized not to use fmt machinery.
+//!
+//! Note that the `CHECK-NOT`s here try to match on calls to functions under `core::fmt`.
+
+// CHECK-LABEL: define {{(dso_local )?}}void @one_ref
+#[no_mangle]
+pub fn one_ref(input: &str) -> String {
+    // CHECK-NOT: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
+    input.to_string()
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}void @two_ref
+#[no_mangle]
+pub fn two_ref(input: &&str) -> String {
+    // CHECK-NOT: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
+    input.to_string()
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}void @thirteen_ref
+#[no_mangle]
+pub fn thirteen_ref(input: &&&&&&&&&&&&&str) -> String {
+    // CHECK-NOT: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
+    input.to_string()
+}
+
+// This is a known performance cliff because of the macro-generated
+// specialized impl. If this test suddenly starts failing,
+// consider removing the `to_string_str!` macro in `alloc/str/string.rs`.
+//
+// CHECK-LABEL: define {{(dso_local )?}}void @fourteen_ref
+#[no_mangle]
+pub fn fourteen_ref(input: &&&&&&&&&&&&&&str) -> String {
+    // CHECK: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
+    input.to_string()
+}
diff --git a/tests/codegen-llvm/iter-repeat-n-trivial-drop.rs b/tests/codegen-llvm/iter-repeat-n-trivial-drop.rs
new file mode 100644
index 00000000000..28173530324
--- /dev/null
+++ b/tests/codegen-llvm/iter-repeat-n-trivial-drop.rs
@@ -0,0 +1,70 @@
+//@ compile-flags: -C opt-level=3
+//@ only-x86_64
+//@ needs-deterministic-layouts
+
+#![crate_type = "lib"]
+#![feature(iter_repeat_n)]
+#![feature(array_repeat)]
+
+#[derive(Clone)]
+pub struct NotCopy(u16);
+
+impl Drop for NotCopy {
+    fn drop(&mut self) {}
+}
+
+// For a type where `Drop::drop` doesn't do anything observable and a clone is the
+// same as a move, make sure that the extra case for the last item disappears.
+
+#[no_mangle]
+// CHECK-LABEL: @iter_repeat_n_next
+pub fn iter_repeat_n_next(it: &mut std::iter::RepeatN<NotCopy>) -> Option<NotCopy> {
+    // CHECK-NEXT: start:
+    // CHECK-NOT: br
+    // CHECK: %[[COUNT:.+]] = load i64
+    // CHECK-NEXT: %[[COUNT_ZERO:.+]] = icmp eq i64 %[[COUNT]], 0
+    // CHECK-NEXT: br i1 %[[COUNT_ZERO]], label %[[EMPTY:.+]], label %[[NOT_EMPTY:.+]]
+
+    // CHECK: [[NOT_EMPTY]]:
+    // CHECK-NOT: br
+    // CHECK: %[[DEC:.+]] = add i64 %[[COUNT]], -1
+    // CHECK-NEXT: %[[VAL:.+]] = load i16
+    // CHECK-NEXT: store i64 %[[DEC]]
+    // CHECK-NEXT: br label %[[EMPTY]]
+
+    // CHECK: [[EMPTY]]:
+    // CHECK-NOT: br
+    // CHECK: phi i16
+    // CHECK-SAME: [ %[[VAL]], %[[NOT_EMPTY]] ]
+    // CHECK-NOT: br
+    // CHECK: ret
+
+    it.next()
+}
+
+// And as a result, using the iterator can optimize without special cases for
+// the last iteration, like `memset`ing all the items in one call.
+
+#[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 1, 0\) )?}}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;
+    let mut v = Vec::with_capacity(n);
+    v.extend(std::iter::repeat_n(42_u8, n));
+    v
+}
+
+// Array repeat uses `RepeatN::next_unchecked` internally,
+// so also check that the distinction disappears there.
+
+#[no_mangle]
+// CHECK-LABEL: @array_repeat_not_copy
+pub unsafe fn array_repeat_not_copy(item: NotCopy) -> [NotCopy; 8] {
+    // CHECK: insertelement {{.+}} i16 %item
+    // CHECK: shufflevector <8 x i16> {{.+}} zeroinitializer
+    // CHECK: store <8 x i16>
+    std::array::repeat(item)
+}
diff --git a/tests/codegen-llvm/layout-size-checks.rs b/tests/codegen-llvm/layout-size-checks.rs
new file mode 100644
index 00000000000..d64a7055e0b
--- /dev/null
+++ b/tests/codegen-llvm/layout-size-checks.rs
@@ -0,0 +1,30 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+use std::alloc::Layout;
+
+type RGB48 = [u16; 3];
+
+// CHECK-LABEL: @layout_array_rgb48
+#[no_mangle]
+pub fn layout_array_rgb48(n: usize) -> Layout {
+    // CHECK-NOT: llvm.umul.with.overflow.i64
+    // CHECK: icmp ugt i64 %n, 1537228672809129301
+    // CHECK-NOT: llvm.umul.with.overflow.i64
+    // CHECK: mul nuw nsw i64 %n, 6
+    // CHECK-NOT: llvm.umul.with.overflow.i64
+    Layout::array::<RGB48>(n).unwrap()
+}
+
+// CHECK-LABEL: @layout_array_i32
+#[no_mangle]
+pub fn layout_array_i32(n: usize) -> Layout {
+    // CHECK-NOT: llvm.umul.with.overflow.i64
+    // CHECK: icmp ugt i64 %n, 2305843009213693951
+    // CHECK-NOT: llvm.umul.with.overflow.i64
+    // CHECK: shl nuw nsw i64 %n, 2
+    // CHECK-NOT: llvm.umul.with.overflow.i64
+    Layout::array::<i32>(n).unwrap()
+}
diff --git a/tests/codegen-llvm/lib-optimizations/iter-sum.rs b/tests/codegen-llvm/lib-optimizations/iter-sum.rs
new file mode 100644
index 00000000000..a054ffffe74
--- /dev/null
+++ b/tests/codegen-llvm/lib-optimizations/iter-sum.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64 (vectorization varies between architectures)
+#![crate_type = "lib"]
+
+// Ensure that slice + take + sum gets vectorized.
+// Currently this relies on the slice::Iter::try_fold implementation
+// CHECK-LABEL: @slice_take_sum
+#[no_mangle]
+pub fn slice_take_sum(s: &[u64], l: usize) -> u64 {
+    // CHECK: vector.body:
+    // CHECK: ret
+    s.iter().take(l).sum()
+}
diff --git a/tests/codegen-llvm/lib-optimizations/slice_rotate.rs b/tests/codegen-llvm/lib-optimizations/slice_rotate.rs
new file mode 100644
index 00000000000..aa4bb3b528c
--- /dev/null
+++ b/tests/codegen-llvm/lib-optimizations/slice_rotate.rs
@@ -0,0 +1,30 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// Ensure that the simple case of rotating by a constant 1 optimizes to the obvious thing
+
+// CHECK-LABEL: @rotate_left_by_one
+#[no_mangle]
+pub fn rotate_left_by_one(slice: &mut [i32]) {
+    // CHECK-NOT: phi
+    // CHECK-NOT: call
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+    // CHECK-NOT: getelementptr
+    // CHECK: %[[END:.+]] = getelementptr
+    // CHECK-NEXT: %[[DIM:.+]] = getelementptr
+    // CHECK-NEXT: %[[LAST:.+]] = load
+    // CHECK-NEXT: %[[FIRST:.+]] = shl
+    // CHECK-NEXT: call void @llvm.memmove
+    // CHECK-NEXT: store i32 %[[LAST]], ptr %[[DIM:.+]]
+    // CHECK-NOT: phi
+    // CHECK-NOT: call
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+    // CHECK-NOT: getelementptr
+    // CHECK: ret void
+    if !slice.is_empty() {
+        slice.rotate_left(1);
+    }
+}
diff --git a/tests/codegen-llvm/lifetime_start_end.rs b/tests/codegen-llvm/lifetime_start_end.rs
new file mode 100644
index 00000000000..0639e7640aa
--- /dev/null
+++ b/tests/codegen-llvm/lifetime_start_end.rs
@@ -0,0 +1,34 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Zmir-opt-level=0
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @test
+#[no_mangle]
+pub fn test() {
+    let a = 0u8;
+    &a; // keep variable in an alloca
+
+    // CHECK: call void @llvm.lifetime.start{{.*}}(i{{[0-9 ]+}}, ptr %a)
+
+    {
+        let b = &Some(a);
+        &b; // keep variable in an alloca
+
+        // CHECK: call void @llvm.lifetime.start{{.*}}(i{{[0-9 ]+}}, {{.*}})
+
+        // CHECK: call void @llvm.lifetime.start{{.*}}(i{{[0-9 ]+}}, {{.*}})
+
+        // CHECK: call void @llvm.lifetime.end{{.*}}(i{{[0-9 ]+}}, {{.*}})
+
+        // CHECK: call void @llvm.lifetime.end{{.*}}(i{{[0-9 ]+}}, {{.*}})
+    }
+
+    let c = 1u8;
+    &c; // keep variable in an alloca
+
+    // CHECK: call void @llvm.lifetime.start{{.*}}(i{{[0-9 ]+}}, ptr %c)
+
+    // CHECK: call void @llvm.lifetime.end{{.*}}(i{{[0-9 ]+}}, ptr %c)
+
+    // CHECK: call void @llvm.lifetime.end{{.*}}(i{{[0-9 ]+}}, ptr %a)
+}
diff --git a/tests/codegen-llvm/link-dead-code.rs b/tests/codegen-llvm/link-dead-code.rs
new file mode 100644
index 00000000000..93e1d84d9c7
--- /dev/null
+++ b/tests/codegen-llvm/link-dead-code.rs
@@ -0,0 +1,28 @@
+//@ compile-flags:-Clink-dead-code
+
+#![crate_type = "rlib"]
+
+// This test makes sure that, when -Clink-dead-code is specified, we generate
+// code for functions that would otherwise be skipped.
+
+// CHECK-LABEL: ; link_dead_code::const_fn
+// CHECK-NEXT: ; Function Attrs:
+// CHECK-NEXT: define hidden
+const fn const_fn() -> i32 {
+    1
+}
+
+// CHECK-LABEL: ; link_dead_code::inline_fn
+// CHECK-NEXT: ; Function Attrs:
+// CHECK-NEXT: define hidden
+#[inline]
+fn inline_fn() -> i32 {
+    2
+}
+
+// CHECK-LABEL: ; link_dead_code::private_fn
+// CHECK-NEXT: ; Function Attrs:
+// CHECK-NEXT: define hidden
+fn private_fn() -> i32 {
+    3
+}
diff --git a/tests/codegen-llvm/link_section.rs b/tests/codegen-llvm/link_section.rs
new file mode 100644
index 00000000000..f62f6948079
--- /dev/null
+++ b/tests/codegen-llvm/link_section.rs
@@ -0,0 +1,35 @@
+//@ ignore-wasm32 custom sections work differently on wasm
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+// CHECK: @VAR1 = {{(dso_local )?}}constant [4 x i8] c"\01\00\00\00", section ".test_one"
+#[no_mangle]
+#[link_section = ".test_one"]
+#[cfg(target_endian = "little")]
+pub static VAR1: u32 = 1;
+
+#[no_mangle]
+#[link_section = ".test_one"]
+#[cfg(target_endian = "big")]
+pub static VAR1: u32 = 0x01000000;
+
+pub enum E {
+    A(u32),
+    B(f32),
+}
+
+// CHECK: @VAR2 = {{(dso_local )?}}constant {{.*}}, section ".test_two"
+#[no_mangle]
+#[link_section = ".test_two"]
+pub static VAR2: E = E::A(666);
+
+// CHECK: @VAR3 = {{(dso_local )?}}constant {{.*}}, section ".test_three"
+#[no_mangle]
+#[link_section = ".test_three"]
+pub static VAR3: E = E::B(1.);
+
+// CHECK: define {{(dso_local )?}}void @fn1() {{.*}} section ".test_four" {
+#[no_mangle]
+#[link_section = ".test_four"]
+pub fn fn1() {}
diff --git a/tests/codegen-llvm/llvm-ident.rs b/tests/codegen-llvm/llvm-ident.rs
new file mode 100644
index 00000000000..923e99bb282
--- /dev/null
+++ b/tests/codegen-llvm/llvm-ident.rs
@@ -0,0 +1,15 @@
+// Verifies that the `!llvm.ident` named metadata is emitted.
+//
+//@ revisions: NONE OPT DEBUG
+//
+//@ [OPT] compile-flags: -Copt-level=2
+//@ [DEBUG] compile-flags: -Cdebuginfo=2
+
+// The named metadata should contain a single metadata node (see
+// `LLVMRustPrepareThinLTOImport` for details).
+// CHECK: !llvm.ident = !{![[ID:[0-9]+]]}
+
+// In addition, check that the metadata node has the expected content.
+// CHECK: ![[ID]] = !{!"rustc version 1.{{.*}}"}
+
+fn main() {}
diff --git a/tests/codegen-llvm/llvm_module_flags.rs b/tests/codegen-llvm/llvm_module_flags.rs
new file mode 100644
index 00000000000..d3fae0c3927
--- /dev/null
+++ b/tests/codegen-llvm/llvm_module_flags.rs
@@ -0,0 +1,7 @@
+// Test for -Z llvm_module_flags
+//@ compile-flags: -Z llvm_module_flag=foo:u32:123:error -Z llvm_module_flag=bar:u32:42:max
+
+fn main() {}
+
+// CHECK: !{i32 1, !"foo", i32 123}
+// CHECK: !{i32 7, !"bar", i32 42}
diff --git a/tests/codegen-llvm/loads.rs b/tests/codegen-llvm/loads.rs
new file mode 100644
index 00000000000..88d67642b72
--- /dev/null
+++ b/tests/codegen-llvm/loads.rs
@@ -0,0 +1,152 @@
+//@ compile-flags: -C no-prepopulate-passes -Zmir-opt-level=0 -Copt-level=3
+
+#![crate_type = "lib"]
+
+use std::mem::MaybeUninit;
+use std::num::NonZero;
+
+pub struct Bytes {
+    a: u8,
+    b: u8,
+    c: u8,
+    d: u8,
+}
+
+#[derive(Copy, Clone)]
+pub enum MyBool {
+    True,
+    False,
+}
+
+#[repr(align(16))]
+pub struct Align16(u128);
+
+// CHECK: @ptr_alignment_helper({{.*}}align [[PTR_ALIGNMENT:[0-9]+]]
+#[no_mangle]
+pub fn ptr_alignment_helper(x: &&()) {}
+
+// CHECK-LABEL: @load_ref
+#[no_mangle]
+pub fn load_ref<'a>(x: &&'a i32) -> &'a i32 {
+    // CHECK: load ptr, ptr %x, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_4_META:[0-9]+]], !noundef !{{[0-9]+}}
+    *x
+}
+
+// CHECK-LABEL: @load_ref_higher_alignment
+#[no_mangle]
+pub fn load_ref_higher_alignment<'a>(x: &&'a Align16) -> &'a Align16 {
+    // CHECK: load ptr, ptr %x, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_16_META:[0-9]+]], !noundef !{{[0-9]+}}
+    *x
+}
+
+// CHECK-LABEL: @load_scalar_pair
+#[no_mangle]
+pub fn load_scalar_pair<'a>(x: &(&'a i32, &'a Align16)) -> (&'a i32, &'a Align16) {
+    // CHECK: load ptr, ptr %{{.+}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_4_META]], !noundef !{{[0-9]+}}
+    // CHECK: load ptr, ptr %{{.+}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_16_META]], !noundef !{{[0-9]+}}
+    *x
+}
+
+// CHECK-LABEL: @load_raw_pointer
+#[no_mangle]
+pub fn load_raw_pointer<'a>(x: &*const i32) -> *const i32 {
+    // loaded raw pointer should not have !nonnull or !align metadata
+    // CHECK: load ptr, ptr %x, align [[PTR_ALIGNMENT]], !noundef ![[NOUNDEF:[0-9]+]]{{$}}
+    *x
+}
+
+// CHECK-LABEL: @load_box
+#[no_mangle]
+pub fn load_box<'a>(x: Box<Box<i32>>) -> Box<i32> {
+    // CHECK: load ptr, ptr %{{.*}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_4_META]], !noundef !{{[0-9]+}}
+    *x
+}
+
+// CHECK-LABEL: @load_bool
+#[no_mangle]
+pub fn load_bool(x: &bool) -> bool {
+    // CHECK: load i8, ptr %x, align 1, !range ![[BOOL_RANGE:[0-9]+]], !noundef !{{[0-9]+}}
+    *x
+}
+
+// CHECK-LABEL: @load_maybeuninit_bool
+#[no_mangle]
+pub fn load_maybeuninit_bool(x: &MaybeUninit<bool>) -> MaybeUninit<bool> {
+    // CHECK: load i8, ptr %x, align 1{{$}}
+    *x
+}
+
+// CHECK-LABEL: @load_enum_bool
+#[no_mangle]
+pub fn load_enum_bool(x: &MyBool) -> MyBool {
+    // CHECK: load i8, ptr %x, align 1, !range ![[BOOL_RANGE]], !noundef !{{[0-9]+}}
+    *x
+}
+
+// CHECK-LABEL: @load_maybeuninit_enum_bool
+#[no_mangle]
+pub fn load_maybeuninit_enum_bool(x: &MaybeUninit<MyBool>) -> MaybeUninit<MyBool> {
+    // CHECK: load i8, ptr %x, align 1{{$}}
+    *x
+}
+
+// CHECK-LABEL: @load_int
+#[no_mangle]
+pub fn load_int(x: &u16) -> u16 {
+    // CHECK: load i16, ptr %x, align 2, !noundef ![[NOUNDEF]]{{$}}
+    *x
+}
+
+// CHECK-LABEL: @load_nonzero_int
+#[no_mangle]
+pub fn load_nonzero_int(x: &NonZero<u16>) -> NonZero<u16> {
+    // CHECK: load i16, ptr %x, align 2, !range ![[NONZEROU16_RANGE:[0-9]+]], !noundef !{{[0-9]+}}
+    *x
+}
+
+// CHECK-LABEL: @load_option_nonzero_int
+#[no_mangle]
+pub fn load_option_nonzero_int(x: &Option<NonZero<u16>>) -> Option<NonZero<u16>> {
+    // CHECK: load i16, ptr %x, align 2, !noundef ![[NOUNDEF]]{{$}}
+    *x
+}
+
+// CHECK-LABEL: @borrow
+#[no_mangle]
+pub fn borrow(x: &i32) -> &i32 {
+    // CHECK: load ptr, ptr %x{{.*}}, !nonnull
+    &x; // keep variable in an alloca
+    x
+}
+
+// CHECK-LABEL: @_box
+#[no_mangle]
+pub fn _box(x: Box<i32>) -> i32 {
+    // CHECK: load ptr, ptr %x{{.*}}, align [[PTR_ALIGNMENT]]
+    *x
+}
+
+// CHECK-LABEL: small_array_alignment
+// The array is loaded as i32, but its alignment is lower, go with 1 byte to avoid target
+// dependent alignment
+#[no_mangle]
+pub fn small_array_alignment(x: [i8; 4]) -> [i8; 4] {
+    // CHECK: [[VAR:%[0-9]+]] = load i32, ptr %{{.*}}, align 1
+    // CHECK: ret i32 [[VAR]]
+    x
+}
+
+// CHECK-LABEL: small_struct_alignment
+// The struct is loaded as i32, but its alignment is lower, go with 1 byte to avoid target
+// dependent alignment
+#[no_mangle]
+pub fn small_struct_alignment(x: Bytes) -> Bytes {
+    // CHECK: [[VAR:%[0-9]+]] = load i32, ptr %{{.*}}, align 1
+    // CHECK: ret i32 [[VAR]]
+    x
+}
+
+// CHECK-DAG: ![[BOOL_RANGE]] = !{i8 0, i8 2}
+// CHECK-DAG: ![[NONZEROU16_RANGE]] = !{i16 1, i16 0}
+// CHECK-DAG: ![[ALIGN_4_META]] = !{i64 4}
+// CHECK-DAG: ![[ALIGN_16_META]] = !{i64 16}
diff --git a/tests/codegen-llvm/local-generics-in-exe-internalized.rs b/tests/codegen-llvm/local-generics-in-exe-internalized.rs
new file mode 100644
index 00000000000..8dbc41382b5
--- /dev/null
+++ b/tests/codegen-llvm/local-generics-in-exe-internalized.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: -C no-prepopulate-passes -Zshare-generics=yes -Zinline-mir=no
+
+// Check that local generics are internalized if they are in the same CGU
+
+// CHECK-LABEL: ; local_generics_in_exe_internalized::foo
+// CHECK-NEXT: ; Function Attrs:
+// CHECK-NEXT: define internal
+pub fn foo<T>(x: T, y: T) -> (T, T) {
+    (x, y)
+}
+
+fn main() {
+    let _ = foo(0u8, 1u8);
+}
diff --git a/tests/codegen-llvm/loongarch-abi/call-llvm-intrinsics.rs b/tests/codegen-llvm/loongarch-abi/call-llvm-intrinsics.rs
new file mode 100644
index 00000000000..9a50f7b8e3a
--- /dev/null
+++ b/tests/codegen-llvm/loongarch-abi/call-llvm-intrinsics.rs
@@ -0,0 +1,31 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+//@ only-loongarch64
+
+#![feature(link_llvm_intrinsics)]
+#![crate_type = "lib"]
+
+struct A;
+
+impl Drop for A {
+    fn drop(&mut self) {
+        println!("A");
+    }
+}
+
+extern "C" {
+    #[link_name = "llvm.sqrt.f32"]
+    fn sqrt(x: f32) -> f32;
+}
+
+pub fn do_call() {
+    let _a = A;
+
+    unsafe {
+        // Ensure that we `call` LLVM intrinsics instead of trying to `invoke` them
+        // CHECK: store float 4.000000e+00, ptr %{{.}}, align 4
+        // CHECK: load float, ptr %{{.}}, align 4
+        // CHECK: call float @llvm.sqrt.f32(float %{{.}}
+        sqrt(4.0);
+    }
+}
diff --git a/tests/codegen-llvm/loongarch-abi/loongarch64-lp64d-abi.rs b/tests/codegen-llvm/loongarch-abi/loongarch64-lp64d-abi.rs
new file mode 100644
index 00000000000..93c8d60930b
--- /dev/null
+++ b/tests/codegen-llvm/loongarch-abi/loongarch64-lp64d-abi.rs
@@ -0,0 +1,299 @@
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target loongarch64-unknown-linux-gnu
+//@ needs-llvm-components: loongarch
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: define void @f_fpr_tracking(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, i8 noundef zeroext %i)
+#[no_mangle]
+pub extern "C" fn f_fpr_tracking(
+    a: f64,
+    b: f64,
+    c: f64,
+    d: f64,
+    e: f64,
+    f: f64,
+    g: f64,
+    h: f64,
+    i: u8,
+) {
+}
+
+#[repr(C)]
+pub struct Double {
+    f: f64,
+}
+
+#[repr(C)]
+pub struct DoubleDouble {
+    f: f64,
+    g: f64,
+}
+
+#[repr(C)]
+pub struct DoubleFloat {
+    f: f64,
+    g: f32,
+}
+
+// CHECK: define void @f_double_s_arg(double %0)
+#[no_mangle]
+pub extern "C" fn f_double_s_arg(a: Double) {}
+
+// CHECK: define double @f_ret_double_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_s() -> Double {
+    Double { f: 1. }
+}
+
+// CHECK: define void @f_double_double_s_arg({ double, double } %0)
+#[no_mangle]
+pub extern "C" fn f_double_double_s_arg(a: DoubleDouble) {}
+
+// CHECK: define { double, double } @f_ret_double_double_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_double_s() -> DoubleDouble {
+    DoubleDouble { f: 1., g: 2. }
+}
+
+// CHECK: define void @f_double_float_s_arg({ double, float } %0)
+#[no_mangle]
+pub extern "C" fn f_double_float_s_arg(a: DoubleFloat) {}
+
+// CHECK: define { double, float } @f_ret_double_float_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_float_s() -> DoubleFloat {
+    DoubleFloat { f: 1., g: 2. }
+}
+
+// CHECK: define void @f_double_double_s_arg_insufficient_fprs(double %0, double %1, double %2, double %3, double %4, double %5, double %6, [2 x i64] %7)
+#[no_mangle]
+pub extern "C" fn f_double_double_s_arg_insufficient_fprs(
+    a: f64,
+    b: f64,
+    c: f64,
+    d: f64,
+    e: f64,
+    f: f64,
+    g: f64,
+    h: DoubleDouble,
+) {
+}
+
+#[repr(C)]
+pub struct DoubleInt8 {
+    f: f64,
+    i: i8,
+}
+
+#[repr(C)]
+pub struct DoubleUInt8 {
+    f: f64,
+    i: u8,
+}
+
+#[repr(C)]
+pub struct DoubleInt32 {
+    f: f64,
+    i: i32,
+}
+
+#[repr(C)]
+pub struct DoubleInt64 {
+    f: f64,
+    i: i64,
+}
+
+// CHECK: define void @f_double_int8_s_arg({ double, i8 } %0)
+#[no_mangle]
+pub extern "C" fn f_double_int8_s_arg(a: DoubleInt8) {}
+
+// CHECK: define { double, i8 } @f_ret_double_int8_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_int8_s() -> DoubleInt8 {
+    DoubleInt8 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_double_int32_s_arg({ double, i32 } %0)
+#[no_mangle]
+pub extern "C" fn f_double_int32_s_arg(a: DoubleInt32) {}
+
+// CHECK: define { double, i32 } @f_ret_double_int32_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_int32_s() -> DoubleInt32 {
+    DoubleInt32 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_double_uint8_s_arg({ double, i8 } %0)
+#[no_mangle]
+pub extern "C" fn f_double_uint8_s_arg(a: DoubleUInt8) {}
+
+// CHECK: define { double, i8 } @f_ret_double_uint8_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_uint8_s() -> DoubleUInt8 {
+    DoubleUInt8 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_double_int64_s_arg({ double, i64 } %0)
+#[no_mangle]
+pub extern "C" fn f_double_int64_s_arg(a: DoubleInt64) {}
+
+// CHECK: define { double, i64 } @f_ret_double_int64_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_int64_s() -> DoubleInt64 {
+    DoubleInt64 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_double_int8_s_arg_insufficient_gprs(i32 noundef signext %a, i32 noundef signext %b, i32 noundef signext %c, i32 noundef signext %d, i32 noundef signext %e, i32 noundef signext %f, i32 noundef signext %g, i32 noundef signext %h, [2 x i64] %0)
+#[no_mangle]
+pub extern "C" fn f_double_int8_s_arg_insufficient_gprs(
+    a: i32,
+    b: i32,
+    c: i32,
+    d: i32,
+    e: i32,
+    f: i32,
+    g: i32,
+    h: i32,
+    i: DoubleInt8,
+) {
+}
+
+// CHECK: define void @f_struct_double_int8_insufficient_fprs(float %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, [2 x i64] %8)
+#[no_mangle]
+pub extern "C" fn f_struct_double_int8_insufficient_fprs(
+    a: f32,
+    b: f64,
+    c: f64,
+    d: f64,
+    e: f64,
+    f: f64,
+    g: f64,
+    h: f64,
+    i: DoubleInt8,
+) {
+}
+
+#[repr(C)]
+pub struct DoubleArr1 {
+    a: [f64; 1],
+}
+
+// CHECK: define void @f_doublearr1_s_arg(double %0)
+#[no_mangle]
+pub extern "C" fn f_doublearr1_s_arg(a: DoubleArr1) {}
+
+// CHECK: define double @f_ret_doublearr1_s()
+#[no_mangle]
+pub extern "C" fn f_ret_doublearr1_s() -> DoubleArr1 {
+    DoubleArr1 { a: [1.] }
+}
+
+#[repr(C)]
+pub struct DoubleArr2 {
+    a: [f64; 2],
+}
+
+// CHECK: define void @f_doublearr2_s_arg({ double, double } %0)
+#[no_mangle]
+pub extern "C" fn f_doublearr2_s_arg(a: DoubleArr2) {}
+
+// CHECK: define { double, double } @f_ret_doublearr2_s()
+#[no_mangle]
+pub extern "C" fn f_ret_doublearr2_s() -> DoubleArr2 {
+    DoubleArr2 { a: [1., 2.] }
+}
+
+#[repr(C)]
+pub struct Tricky1 {
+    f: [f64; 1],
+}
+
+#[repr(C)]
+pub struct DoubleArr2Tricky1 {
+    g: [Tricky1; 2],
+}
+
+// CHECK: define void @f_doublearr2_tricky1_s_arg({ double, double } %0)
+#[no_mangle]
+pub extern "C" fn f_doublearr2_tricky1_s_arg(a: DoubleArr2Tricky1) {}
+
+// CHECK: define { double, double } @f_ret_doublearr2_tricky1_s()
+#[no_mangle]
+pub extern "C" fn f_ret_doublearr2_tricky1_s() -> DoubleArr2Tricky1 {
+    DoubleArr2Tricky1 { g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
+}
+
+#[repr(C)]
+pub struct EmptyStruct {}
+
+#[repr(C)]
+pub struct DoubleArr2Tricky2 {
+    s: EmptyStruct,
+    g: [Tricky1; 2],
+}
+
+// CHECK: define void @f_doublearr2_tricky2_s_arg({ double, double } %0)
+#[no_mangle]
+pub extern "C" fn f_doublearr2_tricky2_s_arg(a: DoubleArr2Tricky2) {}
+
+// CHECK: define { double, double } @f_ret_doublearr2_tricky2_s()
+#[no_mangle]
+pub extern "C" fn f_ret_doublearr2_tricky2_s() -> DoubleArr2Tricky2 {
+    DoubleArr2Tricky2 { s: EmptyStruct {}, g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
+}
+
+#[repr(C)]
+pub struct IntDoubleInt {
+    a: i32,
+    b: f64,
+    c: i32,
+}
+
+// CHECK: define void @f_int_double_int_s_arg(ptr noalias{{( nocapture)?}} noundef align 8{{( captures\(none\))?}} dereferenceable(24) %a)
+#[no_mangle]
+pub extern "C" fn f_int_double_int_s_arg(a: IntDoubleInt) {}
+
+// CHECK: define void @f_ret_int_double_int_s(ptr{{( dead_on_unwind)?}} noalias{{( nocapture)?}} noundef{{( writable)?}} sret([24 x i8]) align 8{{( captures\(none\))?}} dereferenceable(24) %_0)
+#[no_mangle]
+pub extern "C" fn f_ret_int_double_int_s() -> IntDoubleInt {
+    IntDoubleInt { a: 1, b: 2., c: 3 }
+}
+
+#[repr(C)]
+pub struct CharCharDouble {
+    a: u8,
+    b: u8,
+    c: f64,
+}
+
+// CHECK: define void @f_char_char_double_s_arg([2 x i64] %0)
+#[no_mangle]
+pub extern "C" fn f_char_char_double_s_arg(a: CharCharDouble) {}
+
+// CHECK: define [2 x i64] @f_ret_char_char_double_s()
+#[no_mangle]
+pub extern "C" fn f_ret_char_char_double_s() -> CharCharDouble {
+    CharCharDouble { a: 1, b: 2, c: 3. }
+}
+
+#[repr(C)]
+pub union DoubleU {
+    a: f64,
+}
+
+// CHECK: define void @f_double_u_arg(i64 %0)
+#[no_mangle]
+pub extern "C" fn f_double_u_arg(a: DoubleU) {}
+
+// CHECK: define i64 @f_ret_double_u()
+#[no_mangle]
+pub extern "C" fn f_ret_double_u() -> DoubleU {
+    unsafe { DoubleU { a: 1. } }
+}
diff --git a/tests/codegen-llvm/lto-removes-invokes.rs b/tests/codegen-llvm/lto-removes-invokes.rs
new file mode 100644
index 00000000000..3640bd1ab86
--- /dev/null
+++ b/tests/codegen-llvm/lto-removes-invokes.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -C lto -C panic=abort -Copt-level=3
+//@ no-prefer-dynamic
+
+fn main() {
+    foo();
+}
+
+#[no_mangle]
+#[inline(never)]
+fn foo() {
+    let _a = Box::new(3);
+    bar();
+    // CHECK-LABEL: define dso_local void @foo
+    // CHECK: call void @bar
+}
+
+#[inline(never)]
+#[no_mangle]
+fn bar() {
+    println!("hello!");
+}
diff --git a/tests/codegen-llvm/macos/i686-macosx-deployment-target.rs b/tests/codegen-llvm/macos/i686-macosx-deployment-target.rs
new file mode 100644
index 00000000000..cfa91e61cb0
--- /dev/null
+++ b/tests/codegen-llvm/macos/i686-macosx-deployment-target.rs
@@ -0,0 +1,23 @@
+// Checks that we correctly modify the target when MACOSX_DEPLOYMENT_TARGET is set.
+// See issue #60235.
+
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 --target=i686-apple-darwin --crate-type=rlib
+//@ needs-llvm-components: x86
+//@ rustc-env:MACOSX_DEPLOYMENT_TARGET=10.14
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C)]
+pub struct Bool {
+    b: bool,
+}
+
+// CHECK: target triple = "i686-apple-macosx10.14.0"
+#[no_mangle]
+pub extern "C" fn structbool() -> Bool {
+    Bool { b: true }
+}
diff --git a/tests/codegen-llvm/macos/i686-no-macosx-deployment-target.rs b/tests/codegen-llvm/macos/i686-no-macosx-deployment-target.rs
new file mode 100644
index 00000000000..25ec5f6acbb
--- /dev/null
+++ b/tests/codegen-llvm/macos/i686-no-macosx-deployment-target.rs
@@ -0,0 +1,23 @@
+// Checks that we leave the target alone MACOSX_DEPLOYMENT_TARGET is unset.
+// See issue #60235.
+
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 --target=i686-apple-darwin --crate-type=rlib
+//@ needs-llvm-components: x86
+//@ unset-rustc-env:MACOSX_DEPLOYMENT_TARGET
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C)]
+pub struct Bool {
+    b: bool,
+}
+
+// CHECK: target triple = "i686-apple-macosx10.12.0"
+#[no_mangle]
+pub extern "C" fn structbool() -> Bool {
+    Bool { b: true }
+}
diff --git a/tests/codegen-llvm/macos/x86_64-macosx-deployment-target.rs b/tests/codegen-llvm/macos/x86_64-macosx-deployment-target.rs
new file mode 100644
index 00000000000..8ea95ba0575
--- /dev/null
+++ b/tests/codegen-llvm/macos/x86_64-macosx-deployment-target.rs
@@ -0,0 +1,23 @@
+// Checks that we correctly modify the target when MACOSX_DEPLOYMENT_TARGET is set.
+// See issue #60235.
+
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 --target=x86_64-apple-darwin --crate-type=rlib
+//@ needs-llvm-components: x86
+//@ rustc-env:MACOSX_DEPLOYMENT_TARGET=10.14
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C)]
+pub struct Bool {
+    b: bool,
+}
+
+// CHECK: target triple = "x86_64-apple-macosx10.14.0"
+#[no_mangle]
+pub extern "C" fn structbool() -> Bool {
+    Bool { b: true }
+}
diff --git a/tests/codegen-llvm/macos/x86_64-no-macosx-deployment-target.rs b/tests/codegen-llvm/macos/x86_64-no-macosx-deployment-target.rs
new file mode 100644
index 00000000000..474094957ae
--- /dev/null
+++ b/tests/codegen-llvm/macos/x86_64-no-macosx-deployment-target.rs
@@ -0,0 +1,23 @@
+// Checks that we leave the target alone when MACOSX_DEPLOYMENT_TARGET is unset.
+// See issue #60235.
+
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 --target=x86_64-apple-darwin --crate-type=rlib
+//@ needs-llvm-components: x86
+//@ unset-rustc-env:MACOSX_DEPLOYMENT_TARGET
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C)]
+pub struct Bool {
+    b: bool,
+}
+
+// CHECK: target triple = "x86_64-apple-macosx10.12.0"
+#[no_mangle]
+pub extern "C" fn structbool() -> Bool {
+    Bool { b: true }
+}
diff --git a/tests/codegen-llvm/mainsubprogram.rs b/tests/codegen-llvm/mainsubprogram.rs
new file mode 100644
index 00000000000..ce3fe3c8608
--- /dev/null
+++ b/tests/codegen-llvm/mainsubprogram.rs
@@ -0,0 +1,12 @@
+// This test depends on a patch that was committed to upstream LLVM
+// before 4.0, formerly backported to the Rust LLVM fork.
+
+//@ ignore-apple
+//@ ignore-wasi
+
+//@ compile-flags: -g -C no-prepopulate-passes
+
+// CHECK-LABEL: @main
+// CHECK: {{.*}}DISubprogram{{.*}}name: "main",{{.*}}DI{{(SP)?}}FlagMainSubprogram{{.*}}
+
+pub fn main() {}
diff --git a/tests/codegen-llvm/match-optimized.rs b/tests/codegen-llvm/match-optimized.rs
new file mode 100644
index 00000000000..7b409e619a8
--- /dev/null
+++ b/tests/codegen-llvm/match-optimized.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -Cno-prepopulate-passes -Copt-level=3
+
+#![crate_type = "lib"]
+
+pub enum E {
+    A,
+    B,
+    C,
+}
+
+// CHECK-LABEL: @exhaustive_match
+#[no_mangle]
+pub fn exhaustive_match(e: E) -> u8 {
+    // CHECK: switch{{.*}}, label %[[OTHERWISE:[a-zA-Z0-9_]+]] [
+    // CHECK-NEXT: i[[TY:[0-9]+]] [[DISCR:[0-9]+]], label %[[A:[a-zA-Z0-9_]+]]
+    // CHECK-NEXT: i[[TY:[0-9]+]] [[DISCR:[0-9]+]], label %[[B:[a-zA-Z0-9_]+]]
+    // CHECK-NEXT: i[[TY:[0-9]+]] [[DISCR:[0-9]+]], label %[[C:[a-zA-Z0-9_]+]]
+    // CHECK-NEXT: ]
+    // CHECK: [[OTHERWISE]]:
+    // CHECK-NEXT: unreachable
+    //
+    // CHECK: [[A]]:
+    // CHECK-NEXT: store i8 0, ptr %_0, align 1
+    // CHECK-NEXT: br label %[[EXIT:[a-zA-Z0-9_]+]]
+    // CHECK: [[B]]:
+    // CHECK-NEXT: store i8 1, ptr %_0, align 1
+    // CHECK-NEXT: br label %[[EXIT]]
+    // CHECK: [[C]]:
+    // CHECK-NEXT: store i8 3, ptr %_0, align 1
+    // CHECK-NEXT: br label %[[EXIT]]
+    match e {
+        E::A => 0,
+        E::B => 1,
+        E::C => 3,
+    }
+}
+
+#[repr(u16)]
+pub enum E2 {
+    A = 13,
+    B = 42,
+}
+
+// For optimized code we produce a switch with an unreachable target as the `otherwise` so LLVM
+// knows the possible values. Compare with `tests/codegen/match-unoptimized.rs`.
+
+// CHECK-LABEL: @exhaustive_match_2
+#[no_mangle]
+pub fn exhaustive_match_2(e: E2) -> u8 {
+    // CHECK: switch i16 %{{.+}}, label %[[UNREACH:.+]] [
+    // CHECK-NEXT: i16 13,
+    // CHECK-NEXT: i16 42,
+    // CHECK-NEXT: ]
+    // CHECK: [[UNREACH]]:
+    // CHECK-NEXT: unreachable
+    match e {
+        E2::A => 0,
+        E2::B => 1,
+    }
+}
diff --git a/tests/codegen-llvm/match-optimizes-away.rs b/tests/codegen-llvm/match-optimizes-away.rs
new file mode 100644
index 00000000000..5e9be72a09f
--- /dev/null
+++ b/tests/codegen-llvm/match-optimizes-away.rs
@@ -0,0 +1,41 @@
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+#![crate_type = "lib"]
+
+pub enum Three {
+    A,
+    B,
+    C,
+}
+
+#[repr(u16)]
+pub enum Four {
+    A,
+    B,
+    C,
+    D,
+}
+
+#[no_mangle]
+pub fn three_valued(x: Three) -> Three {
+    // CHECK-LABEL: i8 @three_valued(i8{{.+}}%x)
+    // CHECK-NEXT: {{^.*:$}}
+    // CHECK-NEXT: ret i8 %x
+    match x {
+        Three::A => Three::A,
+        Three::B => Three::B,
+        Three::C => Three::C,
+    }
+}
+
+#[no_mangle]
+pub fn four_valued(x: Four) -> Four {
+    // CHECK-LABEL: i16 @four_valued(i16{{.+}}%x)
+    // CHECK-NEXT: {{^.*:$}}
+    // CHECK-NEXT: ret i16 %x
+    match x {
+        Four::A => Four::A,
+        Four::B => Four::B,
+        Four::C => Four::C,
+        Four::D => Four::D,
+    }
+}
diff --git a/tests/codegen-llvm/match-unoptimized.rs b/tests/codegen-llvm/match-unoptimized.rs
new file mode 100644
index 00000000000..3dfe78c3e16
--- /dev/null
+++ b/tests/codegen-llvm/match-unoptimized.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+
+#![crate_type = "lib"]
+
+#[repr(u16)]
+pub enum E2 {
+    A = 13,
+    B = 42,
+}
+
+// For unoptimized code we produce a `br` instead of a `switch`. Compare with
+// `tests/codegen/match-optimized.rs`
+
+// CHECK-LABEL: @exhaustive_match_2
+#[no_mangle]
+pub fn exhaustive_match_2(e: E2) -> u8 {
+    // CHECK: %[[CMP:.+]] = icmp eq i16 %{{.+}}, 13
+    // CHECK-NEXT: br i1 %[[CMP:.+]],
+    match e {
+        E2::A => 0,
+        E2::B => 1,
+    }
+}
diff --git a/tests/codegen-llvm/maybeuninit-rvo.rs b/tests/codegen-llvm/maybeuninit-rvo.rs
new file mode 100644
index 00000000000..097aa610f1b
--- /dev/null
+++ b/tests/codegen-llvm/maybeuninit-rvo.rs
@@ -0,0 +1,34 @@
+//@ compile-flags: -Copt-level=3
+//@ needs-unwind
+#![feature(c_unwind)]
+#![crate_type = "lib"]
+
+pub struct Foo([u8; 1000]);
+
+extern "C" {
+    fn init(p: *mut Foo);
+}
+
+pub fn new_from_uninit() -> Foo {
+    // CHECK-LABEL: new_from_uninit
+    // CHECK-NOT: call void @llvm.memcpy.
+    let mut x = std::mem::MaybeUninit::uninit();
+    unsafe {
+        init(x.as_mut_ptr());
+        x.assume_init()
+    }
+}
+
+extern "C-unwind" {
+    fn init_unwind(p: *mut Foo);
+}
+
+pub fn new_from_uninit_unwind() -> Foo {
+    // CHECK-LABEL: new_from_uninit_unwind
+    // CHECK-NOT: call void @llvm.memcpy.
+    let mut x = std::mem::MaybeUninit::uninit();
+    unsafe {
+        init_unwind(x.as_mut_ptr());
+        x.assume_init()
+    }
+}
diff --git a/tests/codegen-llvm/mem-replace-big-type.rs b/tests/codegen-llvm/mem-replace-big-type.rs
new file mode 100644
index 00000000000..0b2229ba7d1
--- /dev/null
+++ b/tests/codegen-llvm/mem-replace-big-type.rs
@@ -0,0 +1,36 @@
+// This test ensures that `mem::replace::<T>` only ever calls `@llvm.memcpy`
+// with `size_of::<T>()` as the size, and never goes through any wrapper that
+// may e.g. multiply `size_of::<T>()` with a variable "count" (which is only
+// known to be `1` after inlining).
+
+//@ compile-flags: -C no-prepopulate-passes -Zinline-mir=no
+//@ ignore-std-debug-assertions
+// Reason: precondition checks in ptr::read make them a bad candidate for MIR inlining
+//@ needs-deterministic-layouts
+
+#![crate_type = "lib"]
+
+#[repr(C, align(8))]
+pub struct Big([u64; 7]);
+pub fn replace_big(dst: &mut Big, src: Big) -> Big {
+    // Back in 1.68, this emitted six `memcpy`s.
+    // `read_via_copy` in 1.69 got that down to three.
+    // `write_via_move` and nvro get this down to the essential two.
+    std::mem::replace(dst, src)
+}
+
+// NOTE(eddyb) the `CHECK-NOT`s ensure that the only calls of `@llvm.memcpy` in
+// the entire output, are the direct calls we want, from `ptr::replace`.
+
+// CHECK-NOT: call void @llvm.memcpy
+
+// For a large type, we expect exactly three `memcpy`s
+// CHECK-LABEL: define internal void @{{.+}}mem{{.+}}replace{{.+}}(ptr
+// CHECK-SAME: sret([56 x i8]){{.+}}[[RESULT:%.+]], ptr{{.+}}%dest, ptr{{.+}}%src)
+// CHECK-NOT: call void @llvm.memcpy
+// CHECK: call void @llvm.memcpy.{{.+}}(ptr align 8 [[RESULT]], ptr align 8 %dest, i{{.*}} 56, i1 false)
+// CHECK-NOT: call void @llvm.memcpy
+// CHECK: call void @llvm.memcpy.{{.+}}(ptr align 8 %dest, ptr align 8 %src, i{{.*}} 56, i1 false)
+// CHECK-NOT: call void @llvm.memcpy
+
+// CHECK-NOT: call void @llvm.memcpy
diff --git a/tests/codegen-llvm/mem-replace-simple-type.rs b/tests/codegen-llvm/mem-replace-simple-type.rs
new file mode 100644
index 00000000000..9f3c6bacb71
--- /dev/null
+++ b/tests/codegen-llvm/mem-replace-simple-type.rs
@@ -0,0 +1,54 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+//@ only-x86_64 (to not worry about usize differing)
+//@ ignore-std-debug-assertions
+// Reason: precondition checks make mem::replace not a candidate for MIR inlining
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+// CHECK-LABEL: @replace_usize(
+pub fn replace_usize(r: &mut usize, v: usize) -> usize {
+    // CHECK-NOT: alloca
+    // CHECK: %[[R:.+]] = load i64, ptr %r
+    // CHECK: store i64 %v, ptr %r
+    // CHECK: ret i64 %[[R]]
+    std::mem::replace(r, v)
+}
+
+#[no_mangle]
+// CHECK-LABEL: @replace_ref_str(
+pub fn replace_ref_str<'a>(r: &mut &'a str, v: &'a str) -> &'a str {
+    // CHECK-NOT: alloca
+    // CHECK: %[[A:.+]] = load ptr
+    // CHECK: %[[B:.+]] = load i64
+    // CHECK-NOT: store
+    // CHECK-NOT: load
+    // CHECK: store ptr
+    // CHECK: store i64
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+    // CHECK: %[[P1:.+]] = insertvalue { ptr, i64 } poison, ptr %[[A]], 0
+    // CHECK: %[[P2:.+]] = insertvalue { ptr, i64 } %[[P1]], i64 %[[B]], 1
+    // CHECK: ret { ptr, i64 } %[[P2]]
+    std::mem::replace(r, v)
+}
+
+#[no_mangle]
+// CHECK-LABEL: @replace_short_array_3(
+// CHECK-SAME: ptr{{.+}}sret{{.+}}%[[RET:.+]], ptr{{.+}}%r, ptr{{.+}}%v
+pub fn replace_short_array_3(r: &mut [u32; 3], v: [u32; 3]) -> [u32; 3] {
+    // CHECK-NOT: alloca
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %[[RET]], ptr align 4 %r, i64 12, i1 false)
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %r, ptr align 4 %v, i64 12, i1 false)
+    std::mem::replace(r, v)
+}
+
+#[no_mangle]
+// CHECK-LABEL: @replace_short_array_4(
+// CHECK-SAME: ptr{{.+}}sret{{.+}}%[[RET:.+]], ptr{{.+}}%r, ptr{{.+}}%v
+pub fn replace_short_array_4(r: &mut [u32; 4], v: [u32; 4]) -> [u32; 4] {
+    // CHECK-NOT: alloca
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %[[RET]], ptr align 4 %r, i64 16, i1 false)
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %r, ptr align 4 %v, i64 16, i1 false)
+    std::mem::replace(r, v)
+}
diff --git a/tests/codegen-llvm/merge-functions.rs b/tests/codegen-llvm/merge-functions.rs
new file mode 100644
index 00000000000..b9d3727ce11
--- /dev/null
+++ b/tests/codegen-llvm/merge-functions.rs
@@ -0,0 +1,16 @@
+//@ revisions: O Os
+//@[Os] compile-flags: -Copt-level=s
+//@[O] compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// CHECK: @func{{2|1}} = {{.*}}alias{{.*}}@func{{1|2}}
+
+#[no_mangle]
+pub fn func1(c: char) -> bool {
+    c == 's' || c == 'm' || c == 'h' || c == 'd' || c == 'w'
+}
+
+#[no_mangle]
+pub fn func2(c: char) -> bool {
+    matches!(c, 's' | 'm' | 'h' | 'd' | 'w')
+}
diff --git a/tests/codegen-llvm/meta-filecheck/check-prefix.rs b/tests/codegen-llvm/meta-filecheck/check-prefix.rs
new file mode 100644
index 00000000000..98bec68627e
--- /dev/null
+++ b/tests/codegen-llvm/meta-filecheck/check-prefix.rs
@@ -0,0 +1,4 @@
+// Simple test that uses the default CHECK prefix and should always succeed.
+
+// CHECK: main
+fn main() {}
diff --git a/tests/codegen-llvm/meta-filecheck/filecheck-flags.rs b/tests/codegen-llvm/meta-filecheck/filecheck-flags.rs
new file mode 100644
index 00000000000..8e451cf4fdc
--- /dev/null
+++ b/tests/codegen-llvm/meta-filecheck/filecheck-flags.rs
@@ -0,0 +1,8 @@
+// Arguments provided via `filecheck-flags` should be passed to `filecheck`.
+
+//@ revisions: good bad
+//@ [good] filecheck-flags: --check-prefix=CUSTOM
+//@ [bad] should-fail
+
+// CUSTOM: main
+fn main() {}
diff --git a/tests/codegen-llvm/meta-filecheck/msvc-prefix-bad.rs b/tests/codegen-llvm/meta-filecheck/msvc-prefix-bad.rs
new file mode 100644
index 00000000000..f9984c74e2a
--- /dev/null
+++ b/tests/codegen-llvm/meta-filecheck/msvc-prefix-bad.rs
@@ -0,0 +1,7 @@
+// This is exactly like `msvc-prefix-good.rs`, except that it should always fail.
+
+//@ should-fail
+
+// MSVC: text that should not match
+// NONMSVC: text that should not match
+fn main() {}
diff --git a/tests/codegen-llvm/meta-filecheck/no-directives.rs b/tests/codegen-llvm/meta-filecheck/no-directives.rs
new file mode 100644
index 00000000000..2cab263604e
--- /dev/null
+++ b/tests/codegen-llvm/meta-filecheck/no-directives.rs
@@ -0,0 +1,5 @@
+// A test that doesn't include any filecheck directives should fail.
+
+//@ should-fail
+
+fn main() {}
diff --git a/tests/codegen-llvm/meta-filecheck/revision-prefix.rs b/tests/codegen-llvm/meta-filecheck/revision-prefix.rs
new file mode 100644
index 00000000000..431066e3acc
--- /dev/null
+++ b/tests/codegen-llvm/meta-filecheck/revision-prefix.rs
@@ -0,0 +1,8 @@
+// The current revision name is registered as a filecheck prefix.
+
+//@ revisions: GOOD BAD
+//@ [BAD] should-fail
+
+// GOOD: main
+// BAD: text that should not match
+fn main() {}
diff --git a/tests/codegen-llvm/method-declaration.rs b/tests/codegen-llvm/method-declaration.rs
new file mode 100644
index 00000000000..de2f96a5151
--- /dev/null
+++ b/tests/codegen-llvm/method-declaration.rs
@@ -0,0 +1,26 @@
+//@ compile-flags: -g -Cno-prepopulate-passes
+
+// Verify that we added a declaration for a method.
+
+// CHECK: define{{.*}}@method{{.*}} !dbg ![[METHOD_DEF_DBG:[0-9]+]]
+// CHECK: define{{.*}}@function{{.*}} !dbg ![[FUNC_DEF_DBG:[0-9]+]]
+
+#![crate_type = "lib"]
+
+// CHECK-DAG: ![[FOO_DBG:[0-9]+]] = !DICompositeType(tag: {{.*}} name: "Foo", {{.*}} identifier:
+pub struct Foo;
+
+impl Foo {
+    // CHECK-DAG: ![[METHOD_DEF_DBG]] = distinct !DISubprogram(name: "method"{{.*}}, scope: ![[FOO_DBG]]{{.*}}DISPFlagDefinition{{.*}}, declaration: ![[METHOD_DECL_DBG:[0-9]+]]
+    // CHECK-DAG: ![[METHOD_DECL_DBG]] = !DISubprogram(name: "method"{{.*}}, scope: ![[FOO_DBG]]
+    #[no_mangle]
+    pub fn method() {}
+}
+
+// CHECK: ![[FUNC_DEF_DBG]] = distinct !DISubprogram(name: "function"
+// CHECK-NOT: declaration
+// CHECK-SAME: DISPFlagDefinition
+// CHECK-NOT: declaration
+// CHECK-SAME: )
+#[no_mangle]
+pub fn function() {}
diff --git a/tests/codegen-llvm/min-function-alignment.rs b/tests/codegen-llvm/min-function-alignment.rs
new file mode 100644
index 00000000000..ea5f957e81f
--- /dev/null
+++ b/tests/codegen-llvm/min-function-alignment.rs
@@ -0,0 +1,48 @@
+//@ revisions: align16 align1024
+//@ compile-flags: -C no-prepopulate-passes -Z mir-opt-level=0 -Clink-dead-code
+//@ [align16] compile-flags: -Zmin-function-alignment=16
+//@ [align1024] compile-flags: -Zmin-function-alignment=1024
+//@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
+
+#![crate_type = "lib"]
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+#![feature(rustc_attrs)]
+#![feature(fn_align)]
+
+// Functions without explicit alignment use the global minimum.
+//
+// NOTE: this function deliberately has zero (0) attributes! That is to make sure that
+// `-Zmin-function-alignment` is applied regardless of whether attributes are used.
+//
+// CHECK-LABEL: no_explicit_align
+// align16: align 16
+// align1024: align 1024
+pub fn no_explicit_align() {}
+
+// CHECK-LABEL: @lower_align
+// align16: align 16
+// align1024: align 1024
+#[no_mangle]
+#[rustc_align(8)]
+pub fn lower_align() {}
+
+// the higher value of min-function-alignment and the align attribute wins out
+//
+// CHECK-LABEL: @higher_align
+// align16: align 32
+// align1024: align 1024
+#[no_mangle]
+#[rustc_align(32)]
+pub fn higher_align() {}
+
+// cold functions follow the same rules as other functions
+//
+// in GCC, the `-falign-functions` does not apply to cold functions, but
+// `-Zmin-function-alignment` applies to all functions.
+//
+// CHECK-LABEL: @no_explicit_align_cold
+// align16: align 16
+// align1024: align 1024
+#[no_mangle]
+#[cold]
+pub fn no_explicit_align_cold() {}
diff --git a/tests/codegen-llvm/mir-aggregate-no-alloca.rs b/tests/codegen-llvm/mir-aggregate-no-alloca.rs
new file mode 100644
index 00000000000..77d367ed5da
--- /dev/null
+++ b/tests/codegen-llvm/mir-aggregate-no-alloca.rs
@@ -0,0 +1,137 @@
+// 32-bit systems will return 128bit values using a return area pointer.
+//@ revisions: bit32 bit64
+//@[bit32] only-32bit
+//@[bit64] only-64bit
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Z randomize-layout=no
+
+#![crate_type = "lib"]
+
+#[repr(transparent)]
+pub struct Transparent32(u32);
+
+// CHECK: i32 @make_transparent(i32{{.*}} %x)
+#[no_mangle]
+pub fn make_transparent(x: u32) -> Transparent32 {
+    // CHECK-NOT: alloca
+    // CHECK: ret i32 %x
+    let a = Transparent32(x);
+    a
+}
+
+// CHECK: i32 @make_closure(i32{{.*}} %x)
+#[no_mangle]
+pub fn make_closure(x: i32) -> impl Fn(i32) -> i32 {
+    // CHECK-NOT: alloca
+    // CHECK: ret i32 %x
+    move |y| x + y
+}
+
+#[repr(transparent)]
+pub struct TransparentPair((), (u16, u16), ());
+
+// CHECK: { i16, i16 } @make_transparent_pair(i16 noundef %x.0, i16 noundef %x.1)
+#[no_mangle]
+pub fn make_transparent_pair(x: (u16, u16)) -> TransparentPair {
+    // CHECK-NOT: alloca
+    // CHECK: %[[TEMP0:.+]] = insertvalue { i16, i16 } poison, i16 %x.0, 0
+    // CHECK: %[[TEMP1:.+]] = insertvalue { i16, i16 } %[[TEMP0]], i16 %x.1, 1
+    // CHECK: ret { i16, i16 } %[[TEMP1]]
+    let a = TransparentPair((), x, ());
+    a
+}
+
+// CHECK-LABEL: { i32, i32 } @make_2_tuple(i32{{.*}} %x)
+#[no_mangle]
+pub fn make_2_tuple(x: u32) -> (u32, u32) {
+    // CHECK-NOT: alloca
+    // CHECK: %[[TEMP0:.+]] = insertvalue { i32, i32 } poison, i32 %x, 0
+    // CHECK: %[[TEMP1:.+]] = insertvalue { i32, i32 } %[[TEMP0]], i32 %x, 1
+    // CHECK: ret { i32, i32 } %[[TEMP1]]
+    let pair = (x, x);
+    pair
+}
+
+// CHECK-LABEL: i8 @make_cell_of_bool(i1 noundef zeroext %b)
+#[no_mangle]
+pub fn make_cell_of_bool(b: bool) -> std::cell::Cell<bool> {
+    // CHECK: %[[BYTE:.+]] = zext i1 %b to i8
+    // CHECK: ret i8 %[[BYTE]]
+    std::cell::Cell::new(b)
+}
+
+// CHECK-LABEL: { i8, i16 } @make_cell_of_bool_and_short(i1 noundef zeroext %b, i16{{.*}} %s)
+#[no_mangle]
+pub fn make_cell_of_bool_and_short(b: bool, s: u16) -> std::cell::Cell<(bool, u16)> {
+    // CHECK-NOT: alloca
+    // CHECK: %[[BYTE:.+]] = zext i1 %b to i8
+    // CHECK: %[[TEMP0:.+]] = insertvalue { i8, i16 } poison, i8 %[[BYTE]], 0
+    // CHECK: %[[TEMP1:.+]] = insertvalue { i8, i16 } %[[TEMP0]], i16 %s, 1
+    // CHECK: ret { i8, i16 } %[[TEMP1]]
+    std::cell::Cell::new((b, s))
+}
+
+// CHECK-LABEL: { i1, i1 } @make_tuple_of_bools(i1 noundef zeroext %a, i1 noundef zeroext %b)
+#[no_mangle]
+pub fn make_tuple_of_bools(a: bool, b: bool) -> (bool, bool) {
+    // CHECK-NOT: alloca
+    // CHECK: %[[TEMP0:.+]] = insertvalue { i1, i1 } poison, i1 %a, 0
+    // CHECK: %[[TEMP1:.+]] = insertvalue { i1, i1 } %[[TEMP0]], i1 %b, 1
+    // CHECK: ret { i1, i1 } %[[TEMP1]]
+    (a, b)
+}
+
+pub struct Struct0();
+
+// CHECK-LABEL: void @make_struct_0()
+#[no_mangle]
+pub fn make_struct_0() -> Struct0 {
+    // CHECK: ret void
+    let s = Struct0();
+    s
+}
+
+pub struct Struct1(i32);
+
+// CHECK-LABEL: i32 @make_struct_1(i32{{.*}} %a)
+#[no_mangle]
+pub fn make_struct_1(a: i32) -> Struct1 {
+    // CHECK: ret i32 %a
+    let s = Struct1(a);
+    s
+}
+
+pub struct Struct2Asc(i16, i64);
+
+// bit32-LABEL: void @make_struct_2_asc({{.*}} sret({{[^,]*}}) {{.*}} %s,
+// bit64-LABEL: { i64, i16 } @make_struct_2_asc(
+// CHECK-SAME: i16{{.*}} %a, i64 noundef %b)
+#[no_mangle]
+pub fn make_struct_2_asc(a: i16, b: i64) -> Struct2Asc {
+    // CHECK-NOT: alloca
+    // bit32: %[[GEP:.+]] = getelementptr inbounds i8, ptr %s, i32 8
+    // bit32: store i16 %a, ptr %[[GEP]]
+    // bit32: store i64 %b, ptr %s
+    // bit64: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %b, 0
+    // bit64: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %a, 1
+    // bit64: ret { i64, i16 } %[[TEMP1]]
+    let s = Struct2Asc(a, b);
+    s
+}
+
+pub struct Struct2Desc(i64, i16);
+
+// bit32-LABEL: void @make_struct_2_desc({{.*}} sret({{[^,]*}}) {{.*}} %s,
+// bit64-LABEL: { i64, i16 } @make_struct_2_desc(
+// CHECK-SAME: i64 noundef %a, i16{{.*}} %b)
+#[no_mangle]
+pub fn make_struct_2_desc(a: i64, b: i16) -> Struct2Desc {
+    // CHECK-NOT: alloca
+    // bit32: store i64 %a, ptr %s
+    // bit32: %[[GEP:.+]] = getelementptr inbounds i8, ptr %s, i32 8
+    // bit32: store i16 %b, ptr %[[GEP]]
+    // bit64: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %a, 0
+    // bit64: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %b, 1
+    // bit64: ret { i64, i16 } %[[TEMP1]]
+    let s = Struct2Desc(a, b);
+    s
+}
diff --git a/tests/codegen-llvm/mir-inlined-line-numbers.rs b/tests/codegen-llvm/mir-inlined-line-numbers.rs
new file mode 100644
index 00000000000..cfe43a6cf89
--- /dev/null
+++ b/tests/codegen-llvm/mir-inlined-line-numbers.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Copt-level=3 -g
+
+#![crate_type = "lib"]
+
+#[inline(always)]
+fn foo() {
+    bar();
+}
+
+#[inline(never)]
+#[no_mangle]
+fn bar() {
+    panic!();
+}
+
+#[no_mangle]
+pub fn example() {
+    foo();
+}
+
+// CHECK-LABEL: @example
+// CHECK:   tail call void @bar(){{( #[0-9]+)?}}, !dbg [[DBG_ID:![0-9]+]]
+// CHECK: [[DBG_ID]] = !DILocation(line: 7,
+// CHECK-SAME:                     inlinedAt: [[INLINE_ID:![0-9]+]])
+// CHECK: [[INLINE_ID]] = !DILocation(line: 18,
diff --git a/tests/codegen-llvm/mir_zst_stores.rs b/tests/codegen-llvm/mir_zst_stores.rs
new file mode 100644
index 00000000000..ff1d429cffd
--- /dev/null
+++ b/tests/codegen-llvm/mir_zst_stores.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+use std::marker::PhantomData;
+
+#[derive(Copy, Clone)]
+struct Zst {
+    phantom: PhantomData<Zst>,
+}
+
+// CHECK-LABEL: @mir
+// CHECK-NOT: store{{.*}}undef
+#[no_mangle]
+pub fn mir() {
+    let x = Zst { phantom: PhantomData };
+    let y = (x, 0);
+    drop(y);
+    drop((0, x));
+}
diff --git a/tests/codegen-llvm/move-before-nocapture-ref-arg.rs b/tests/codegen-llvm/move-before-nocapture-ref-arg.rs
new file mode 100644
index 00000000000..2ebd645e1c3
--- /dev/null
+++ b/tests/codegen-llvm/move-before-nocapture-ref-arg.rs
@@ -0,0 +1,21 @@
+// Verify that move before the call of the function with noalias, nocapture, readonly.
+// #107436
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[repr(C)]
+pub struct ThreeSlices<'a>(&'a [u32], &'a [u32], &'a [u32]);
+
+#[no_mangle]
+pub fn sum_slices(val: ThreeSlices) -> u32 {
+    // CHECK-NOT: memcpy
+    let val = val;
+    sum(&val)
+}
+
+#[no_mangle]
+#[inline(never)]
+pub fn sum(val: &ThreeSlices) -> u32 {
+    val.0.iter().sum::<u32>() + val.1.iter().sum::<u32>() + val.2.iter().sum::<u32>()
+}
diff --git a/tests/codegen-llvm/move-operands.rs b/tests/codegen-llvm/move-operands.rs
new file mode 100644
index 00000000000..ddad231b762
--- /dev/null
+++ b/tests/codegen-llvm/move-operands.rs
@@ -0,0 +1,13 @@
+// Verify that optimized MIR only copies `a` once.
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+type T = [u8; 256];
+
+#[no_mangle]
+pub fn f(a: T, b: fn(_: T, _: T)) {
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 %{{.*}}, ptr align 1 %{{.*}}, {{.*}} 256, i1 false)
+    // CHECK-NOT: call void @llvm.memcpy.{{.*}}(ptr align 1 %{{.*}}, ptr align 1 %{{.*}}, {{.*}} 256, i1 false)
+    b(a, a)
+}
diff --git a/tests/codegen-llvm/naked-asan.rs b/tests/codegen-llvm/naked-asan.rs
new file mode 100644
index 00000000000..46218cf79d6
--- /dev/null
+++ b/tests/codegen-llvm/naked-asan.rs
@@ -0,0 +1,30 @@
+//@ add-core-stubs
+//@ needs-llvm-components: x86
+//@ compile-flags: --target x86_64-unknown-linux-gnu -Zsanitizer=address -Ctarget-feature=-crt-static
+
+// Make sure we do not request sanitizers for naked functions.
+
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_std]
+#![no_core]
+#![feature(abi_x86_interrupt)]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+pub fn caller() {
+    unsafe { asm!("call {}", sym page_fault_handler) }
+}
+
+// CHECK: declare x86_intrcc void @page_fault_handler(){{.*}}#[[ATTRS:[0-9]+]]
+#[unsafe(naked)]
+#[no_mangle]
+pub extern "x86-interrupt" fn page_fault_handler() {
+    naked_asm!("ud2")
+}
+
+// CHECK: #[[ATTRS]] =
+// CHECK-NOT: sanitize_address
+// CHECK: !llvm.module.flags
diff --git a/tests/codegen-llvm/naked-fn/aligned.rs b/tests/codegen-llvm/naked-fn/aligned.rs
new file mode 100644
index 00000000000..d7281c4219a
--- /dev/null
+++ b/tests/codegen-llvm/naked-fn/aligned.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+//@ needs-asm-support
+//@ ignore-arm no "ret" mnemonic
+//@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
+
+#![crate_type = "lib"]
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+#![feature(rustc_attrs)]
+#![feature(fn_align)]
+
+use std::arch::naked_asm;
+
+// CHECK: .balign 16
+// CHECK-LABEL: naked_empty:
+#[rustc_align(16)]
+#[no_mangle]
+#[unsafe(naked)]
+pub extern "C" fn naked_empty() {
+    // CHECK: ret
+    naked_asm!("ret")
+}
diff --git a/tests/codegen-llvm/naked-fn/generics.rs b/tests/codegen-llvm/naked-fn/generics.rs
new file mode 100644
index 00000000000..865be00d91e
--- /dev/null
+++ b/tests/codegen-llvm/naked-fn/generics.rs
@@ -0,0 +1,111 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+use std::arch::naked_asm;
+
+#[no_mangle]
+fn test(x: u64) {
+    // just making sure these symbols get used
+    using_const_generics::<1>(x);
+    using_const_generics::<2>(x);
+
+    generic_function::<i64>(x as i64);
+
+    let foo = Foo(x);
+
+    foo.method();
+    foo.trait_method();
+}
+
+// CHECK: .balign 4
+// CHECK: add rax, 2
+// CHECK: add rax, 42
+
+// CHECK: .balign 4
+// CHECK: add rax, 1
+// CHECK: add rax, 42
+
+#[unsafe(naked)]
+pub extern "C" fn using_const_generics<const N: u64>(x: u64) -> u64 {
+    const M: u64 = 42;
+
+    naked_asm!(
+        "xor rax, rax",
+        "add rax, rdi",
+        "add rax, {}",
+        "add rax, {}",
+        "ret",
+        const N,
+        const M,
+    )
+}
+
+trait Invert {
+    fn invert(self) -> Self;
+}
+
+impl Invert for i64 {
+    fn invert(self) -> Self {
+        -1 * self
+    }
+}
+
+// CHECK: .balign 4
+// CHECK-LABEL: generic_function:
+// CHECK: call
+// CHECK: ret
+
+#[unsafe(naked)]
+#[no_mangle]
+pub extern "C" fn generic_function<T: Invert>(x: i64) -> i64 {
+    naked_asm!(
+        "call {}",
+        "ret",
+        sym <T as Invert>::invert,
+    )
+}
+
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+struct Foo(u64);
+
+// CHECK: .balign 4
+// CHECK-LABEL: method:
+// CHECK: mov rax, rdi
+
+impl Foo {
+    #[unsafe(naked)]
+    #[no_mangle]
+    extern "C" fn method(self) -> u64 {
+        naked_asm!("mov rax, rdi", "ret")
+    }
+}
+
+// CHECK: .balign 4
+// CHECK-LABEL: trait_method:
+// CHECK: mov rax, rdi
+
+trait Bar {
+    extern "C" fn trait_method(self) -> u64;
+}
+
+impl Bar for Foo {
+    #[unsafe(naked)]
+    #[no_mangle]
+    extern "C" fn trait_method(self) -> u64 {
+        naked_asm!("mov rax, rdi", "ret")
+    }
+}
+
+// CHECK: .balign 4
+// CHECK-LABEL: naked_with_args_and_return:
+// CHECK: lea rax, [rdi + rsi]
+
+// this previously ICE'd, see https://github.com/rust-lang/rust/issues/124375
+#[unsafe(naked)]
+#[no_mangle]
+pub unsafe extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize {
+    naked_asm!("lea rax, [rdi + rsi]", "ret");
+}
diff --git a/tests/codegen-llvm/naked-fn/instruction-set.rs b/tests/codegen-llvm/naked-fn/instruction-set.rs
new file mode 100644
index 00000000000..67560c5aba7
--- /dev/null
+++ b/tests/codegen-llvm/naked-fn/instruction-set.rs
@@ -0,0 +1,53 @@
+//@ add-core-stubs
+//@ revisions: arm-mode thumb-mode
+//@ [arm-mode] compile-flags: --target armv5te-none-eabi
+//@ [thumb-mode] compile-flags: --target thumbv5te-none-eabi
+//@ [arm-mode] needs-llvm-components: arm
+//@ [thumb-mode] needs-llvm-components: arm
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items, rustc_attrs)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// arm-mode: .arm
+// thumb-mode: .thumb
+// CHECK-LABEL: test_unspecified:
+// CHECK: bx lr
+// CHECK: .popsection
+// arm-mode: .arm
+// thumb-mode: .thumb
+#[no_mangle]
+#[unsafe(naked)]
+extern "C" fn test_unspecified() {
+    naked_asm!("bx lr");
+}
+
+// CHECK: .thumb
+// CHECK: .thumb_func
+// CHECK-LABEL: test_thumb:
+// CHECK: bx lr
+// CHECK: .popsection
+// arm-mode: .arm
+// thumb-mode: .thumb
+#[no_mangle]
+#[unsafe(naked)]
+#[instruction_set(arm::t32)]
+extern "C" fn test_thumb() {
+    naked_asm!("bx lr");
+}
+
+// CHECK: .arm
+// CHECK-LABEL: test_arm:
+// CHECK: bx lr
+// CHECK: .popsection
+// arm-mode: .arm
+// thumb-mode: .thumb
+#[no_mangle]
+#[unsafe(naked)]
+#[instruction_set(arm::a32)]
+extern "C" fn test_arm() {
+    naked_asm!("bx lr");
+}
diff --git a/tests/codegen-llvm/naked-fn/min-function-alignment.rs b/tests/codegen-llvm/naked-fn/min-function-alignment.rs
new file mode 100644
index 00000000000..406e9334fa5
--- /dev/null
+++ b/tests/codegen-llvm/naked-fn/min-function-alignment.rs
@@ -0,0 +1,47 @@
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0 -Zmin-function-alignment=16
+//@ needs-asm-support
+//@ ignore-arm no "ret" mnemonic
+//@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
+
+// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
+#![feature(rustc_attrs)]
+#![feature(fn_align)]
+#![crate_type = "lib"]
+
+// functions without explicit alignment use the global minimum
+//
+// CHECK: .balign 16
+#[no_mangle]
+#[unsafe(naked)]
+pub extern "C" fn naked_no_explicit_align() {
+    core::arch::naked_asm!("ret")
+}
+
+// CHECK: .balign 16
+#[no_mangle]
+#[rustc_align(8)]
+#[unsafe(naked)]
+pub extern "C" fn naked_lower_align() {
+    core::arch::naked_asm!("ret")
+}
+
+// CHECK: .balign 32
+#[no_mangle]
+#[rustc_align(32)]
+#[unsafe(naked)]
+pub extern "C" fn naked_higher_align() {
+    core::arch::naked_asm!("ret")
+}
+
+// cold functions follow the same rules as other functions
+//
+// in GCC, the `-falign-functions` does not apply to cold functions, but
+// `-Zmin-function-alignment` applies to all functions.
+//
+// CHECK: .balign 16
+#[no_mangle]
+#[cold]
+#[unsafe(naked)]
+pub extern "C" fn no_explicit_align_cold() {
+    core::arch::naked_asm!("ret")
+}
diff --git a/tests/codegen-llvm/naked-fn/naked-functions.rs b/tests/codegen-llvm/naked-fn/naked-functions.rs
new file mode 100644
index 00000000000..344af6eb42f
--- /dev/null
+++ b/tests/codegen-llvm/naked-fn/naked-functions.rs
@@ -0,0 +1,165 @@
+//@ add-core-stubs
+//@ revisions: linux win_x86 win_i686 macos thumb
+//
+//@[linux] compile-flags: --target x86_64-unknown-linux-gnu
+//@[linux] needs-llvm-components: x86
+//@[win_x86] compile-flags: --target x86_64-pc-windows-gnu
+//@[win_x86] needs-llvm-components: x86
+//@[win_i686] compile-flags: --target i686-pc-windows-gnu
+//@[win_i686] needs-llvm-components: x86
+//@[macos] compile-flags: --target aarch64-apple-darwin
+//@[macos] needs-llvm-components: arm
+//@[thumb] compile-flags: --target thumbv7em-none-eabi
+//@[thumb] needs-llvm-components: arm
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items, rustc_attrs)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// linux,win: .intel_syntax
+//
+// linux:    .pushsection .text.naked_empty,\22ax\22, @progbits
+// macos:    .pushsection __TEXT,__text,regular,pure_instructions
+// win_x86:  .pushsection .text.naked_empty,\22xr\22
+// win_i686: .pushsection .text._naked_empty,\22xr\22
+// thumb:    .pushsection .text.naked_empty,\22ax\22, %progbits
+//
+// CHECK: .balign 4
+//
+// linux,win,thumb: .globl naked_empty
+// macos: .globl _naked_empty
+//
+// CHECK-NOT: .private_extern
+// CHECK-NOT: .hidden
+//
+// linux: .type naked_empty, @function
+//
+// win_x86:  .def naked_empty
+// win_i686: .def _naked_empty
+//
+// win_x86,win_i686: .scl 2
+// win_x86,win_i686: .type 32
+// win_x86,win_i686: .endef
+//
+// thumb: .type naked_empty, %function
+// thumb: .thumb
+// thumb: .thumb_func
+//
+// CHECK-LABEL: naked_empty:
+//
+// linux,macos,win: ret
+// thumb: bx lr
+//
+// CHECK: .popsection
+//
+// thumb: .thumb
+//
+// linux,win: .att_syntax
+
+#[no_mangle]
+#[unsafe(naked)]
+pub extern "C" fn naked_empty() {
+    #[cfg(not(all(target_arch = "arm", target_feature = "thumb-mode")))]
+    naked_asm!("ret");
+
+    #[cfg(all(target_arch = "arm", target_feature = "thumb-mode"))]
+    naked_asm!("bx lr");
+}
+
+// linux,win: .intel_syntax
+//
+// linux:    .pushsection .text.naked_with_args_and_return,\22ax\22, @progbits
+// macos:    .pushsection __TEXT,__text,regular,pure_instructions
+// win_x86:  .pushsection .text.naked_with_args_and_return,\22xr\22
+// win_i686: .pushsection .text._naked_with_args_and_return,\22xr\22
+// thumb:    .pushsection .text.naked_with_args_and_return,\22ax\22, %progbits
+//
+// CHECK: .balign 4
+//
+// linux,win,thumb: .globl naked_with_args_and_return
+// macos: .globl _naked_with_args_and_return
+//
+// CHECK-NOT: .private_extern
+// CHECK-NOT: .hidden
+//
+// linux: .type naked_with_args_and_return, @function
+//
+// win_x86:  .def naked_with_args_and_return
+// win_i686: .def _naked_with_args_and_return
+//
+// win_x86,win_i686: .scl 2
+// win_x86,win_i686: .type 32
+// win_x86,win_i686: .endef
+//
+// thumb: .type naked_with_args_and_return, %function
+// thumb: .thumb
+// thumb: .thumb_func
+//
+// CHECK-LABEL: naked_with_args_and_return:
+//
+// linux, win_x86,win_i686: lea rax, [rdi + rsi]
+// macos: add x0, x0, x1
+// thumb: adds r0, r0, r1
+//
+// linux,macos,win: ret
+// thumb: bx lr
+//
+// CHECK: .popsection
+//
+// thumb: .thumb
+//
+// linux,win: .att_syntax
+
+#[no_mangle]
+#[unsafe(naked)]
+pub extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize {
+    #[cfg(any(target_os = "windows", target_os = "linux"))]
+    {
+        naked_asm!("lea rax, [rdi + rsi]", "ret")
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        naked_asm!("add x0, x0, x1", "ret")
+    }
+
+    #[cfg(all(target_arch = "arm", target_feature = "thumb-mode"))]
+    {
+        naked_asm!("adds r0, r0, r1", "bx lr")
+    }
+}
+
+// linux:            .pushsection .text.some_different_name,\22ax\22, @progbits
+// macos:            .pushsection .text.some_different_name,regular,pure_instructions
+// win_x86,win_i686: .pushsection .text.some_different_name,\22xr\22
+// thumb:            .pushsection .text.some_different_name,\22ax\22, %progbits
+// CHECK-LABEL: test_link_section:
+#[no_mangle]
+#[unsafe(naked)]
+#[link_section = ".text.some_different_name"]
+pub extern "C" fn test_link_section() {
+    #[cfg(not(all(target_arch = "arm", target_feature = "thumb-mode")))]
+    naked_asm!("ret");
+
+    #[cfg(all(target_arch = "arm", target_feature = "thumb-mode"))]
+    naked_asm!("bx lr");
+}
+
+// win_x86:  .def fastcall_cc
+// win_i686: .def @fastcall_cc@4
+//
+// win_x86,win_i686: .scl 2
+// win_x86,win_i686: .type 32
+// win_x86,win_i686: .endef
+//
+// win_x86-LABEL: fastcall_cc:
+// win_i686-LABEL: @fastcall_cc@4:
+#[cfg(target_os = "windows")]
+#[no_mangle]
+#[unsafe(naked)]
+pub extern "fastcall" fn fastcall_cc(x: i32) -> i32 {
+    naked_asm!("ret");
+}
diff --git a/tests/codegen-llvm/no-alloca-inside-if-false.rs b/tests/codegen-llvm/no-alloca-inside-if-false.rs
new file mode 100644
index 00000000000..a231c7e808a
--- /dev/null
+++ b/tests/codegen-llvm/no-alloca-inside-if-false.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -Cno-prepopulate-passes -Copt-level=0 -Cpanic=abort
+// Check that there's an alloca for the reference and the vector, but nothing else.
+// We use panic=abort because unwinding panics give hint::black_box a cleanup block, which has
+// another alloca.
+
+#![crate_type = "lib"]
+
+#[inline(never)]
+fn test<const SIZE: usize>() {
+    // CHECK-LABEL: no_alloca_inside_if_false::test
+    // CHECK: start:
+    // CHECK-NEXT: alloca [{{12|24}} x i8]
+    // CHECK-NOT: alloca
+    if const { SIZE < 4096 } {
+        let arr = [0u8; SIZE];
+        std::hint::black_box(&arr);
+    } else {
+        let vec = vec![0u8; SIZE];
+        std::hint::black_box(&vec);
+    }
+}
+
+// CHECK-LABEL: @main
+#[no_mangle]
+pub fn main() {
+    test::<8192>();
+}
diff --git a/tests/codegen-llvm/no-assumes-on-casts.rs b/tests/codegen-llvm/no-assumes-on-casts.rs
new file mode 100644
index 00000000000..9c00dc2c015
--- /dev/null
+++ b/tests/codegen-llvm/no-assumes-on-casts.rs
@@ -0,0 +1,19 @@
+#![crate_type = "lib"]
+
+//@ compile-flags: -Cno-prepopulate-passes
+
+// CHECK-LABEL: fna
+#[no_mangle]
+pub fn fna(a: i16) -> i32 {
+    a as i32
+    // CHECK-NOT: assume
+    // CHECK: sext
+}
+
+// CHECK-LABEL: fnb
+#[no_mangle]
+pub fn fnb(a: u16) -> u32 {
+    a as u32
+    // CHECK-NOT: assume
+    // CHECK: zext
+}
diff --git a/tests/codegen-llvm/no-dllimport-w-cross-lang-lto.rs b/tests/codegen-llvm/no-dllimport-w-cross-lang-lto.rs
new file mode 100644
index 00000000000..c71eddfa287
--- /dev/null
+++ b/tests/codegen-llvm/no-dllimport-w-cross-lang-lto.rs
@@ -0,0 +1,13 @@
+// This test makes sure that functions get annotated with the proper
+// "target-cpu" attribute in LLVM.
+
+//@ no-prefer-dynamic
+//@ only-msvc
+//@ compile-flags: -C linker-plugin-lto
+
+#![crate_type = "rlib"]
+
+// CHECK-NOT: @{{.*}}__imp_{{.*}}GLOBAL{{.*}} = global i8*
+
+pub static GLOBAL: u32 = 0;
+pub static mut GLOBAL2: u32 = 0;
diff --git a/tests/codegen-llvm/no-jump-tables.rs b/tests/codegen-llvm/no-jump-tables.rs
new file mode 100644
index 00000000000..e49de7e9dc1
--- /dev/null
+++ b/tests/codegen-llvm/no-jump-tables.rs
@@ -0,0 +1,23 @@
+// Test that the `no-jump-tables` function attribute are (not) emitted when
+// the `-Zno-jump-tables` flag is (not) set.
+
+//@ add-core-stubs
+//@ revisions: unset set
+//@ needs-llvm-components: x86
+//@ compile-flags: --target x86_64-unknown-linux-gnu
+//@ [set] compile-flags: -Zno-jump-tables
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+pub fn foo() {
+    // CHECK: @foo() unnamed_addr #0
+
+    // unset-NOT: attributes #0 = { {{.*}}"no-jump-tables"="true"{{.*}} }
+    // set: attributes #0 = { {{.*}}"no-jump-tables"="true"{{.*}} }
+}
diff --git a/tests/codegen-llvm/no-plt.rs b/tests/codegen-llvm/no-plt.rs
new file mode 100644
index 00000000000..3a3546ff7c4
--- /dev/null
+++ b/tests/codegen-llvm/no-plt.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -C relocation-model=pic -Z plt=no
+
+#![crate_type = "lib"]
+
+// We need a function which is normally called through the PLT.
+extern "C" {
+    // CHECK: Function Attrs:{{.*}}nonlazybind
+    fn getenv(name: *const u8) -> *mut u8;
+}
+
+// Ensure the function gets referenced.
+pub unsafe fn call_through_plt() -> *mut u8 {
+    getenv(b"\0".as_ptr())
+}
+
+// Ensure intrinsics also skip the PLT
+// CHECK: !"RtLibUseGOT"
diff --git a/tests/codegen-llvm/no-redundant-item-monomorphization.rs b/tests/codegen-llvm/no-redundant-item-monomorphization.rs
new file mode 100644
index 00000000000..466037c3770
--- /dev/null
+++ b/tests/codegen-llvm/no-redundant-item-monomorphization.rs
@@ -0,0 +1,33 @@
+// Test to make sure that inner functions within a polymorphic outer function
+// don't get re-codegened when the outer function is monomorphized. The test
+// code monomorphizes the outer functions several times, but the magic constants
+// used in the inner functions should each appear only once in the generated IR.
+
+// issue: rust-lang/rust#7349
+//@ compile-flags: -Cno-prepopulate-passes -Copt-level=0
+
+// CHECK-COUNT-1: ret i32 8675309
+// CHECK-COUNT-1: ret i32 11235813
+
+fn outer<T>() {
+    #[allow(dead_code)]
+    fn inner() -> u32 {
+        8675309
+    }
+    inner();
+}
+
+extern "C" fn outer_foreign<T>() {
+    #[allow(dead_code)]
+    fn inner() -> u32 {
+        11235813
+    }
+    inner();
+}
+
+fn main() {
+    outer::<isize>();
+    outer::<usize>();
+    outer_foreign::<isize>();
+    outer_foreign::<usize>();
+}
diff --git a/tests/codegen-llvm/no_builtins-at-crate.rs b/tests/codegen-llvm/no_builtins-at-crate.rs
new file mode 100644
index 00000000000..ba1d31f60c3
--- /dev/null
+++ b/tests/codegen-llvm/no_builtins-at-crate.rs
@@ -0,0 +1,24 @@
+//@ compile-flags: -C opt-level=1
+
+#![no_builtins]
+#![crate_type = "lib"]
+
+// CHECK: define
+// CHECK-SAME: @__aeabi_memcpy
+// CHECK-SAME: #0
+#[no_mangle]
+pub unsafe extern "C" fn __aeabi_memcpy(dest: *mut u8, src: *const u8, size: usize) {
+    // CHECK: call
+    // CHECK-SAME: @memcpy(
+    memcpy(dest, src, size);
+}
+
+// CHECK: declare
+// CHECK-SAME: @memcpy
+// CHECK-SAME: #0
+extern "C" {
+    pub fn memcpy(dest: *mut u8, src: *const u8, n: usize) -> *mut u8;
+}
+
+// CHECK: attributes #0
+// CHECK-SAME: "no-builtins"
diff --git a/tests/codegen-llvm/noalias-box-off.rs b/tests/codegen-llvm/noalias-box-off.rs
new file mode 100644
index 00000000000..664c7950280
--- /dev/null
+++ b/tests/codegen-llvm/noalias-box-off.rs
@@ -0,0 +1,11 @@
+//@ compile-flags: -Copt-level=3 -Z box-noalias=no
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @box_should_not_have_noalias_if_disabled(
+// CHECK-NOT: noalias
+// CHECK-SAME: %foo)
+#[no_mangle]
+pub fn box_should_not_have_noalias_if_disabled(foo: Box<u8>) {
+    drop(foo);
+}
diff --git a/tests/codegen-llvm/noalias-box.rs b/tests/codegen-llvm/noalias-box.rs
new file mode 100644
index 00000000000..cccde775977
--- /dev/null
+++ b/tests/codegen-llvm/noalias-box.rs
@@ -0,0 +1,8 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @box_should_have_noalias_by_default(
+// CHECK: noalias
+#[no_mangle]
+pub fn box_should_have_noalias_by_default(_b: Box<u8>) {}
diff --git a/tests/codegen-llvm/noalias-flag.rs b/tests/codegen-llvm/noalias-flag.rs
new file mode 100644
index 00000000000..67ba68ee6f8
--- /dev/null
+++ b/tests/codegen-llvm/noalias-flag.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -Copt-level=3 -Zmutable-noalias=no
+
+#![crate_type = "lib"]
+
+// `-Zmutable-noalias=no` should disable noalias on mut refs...
+
+// CHECK-LABEL: @test_mut_ref(
+// CHECK-NOT: noalias
+// CHECK-SAME: %x
+#[no_mangle]
+pub fn test_mut_ref(x: &mut i32) -> &mut i32 {
+    x
+}
+
+// ...but not on shared refs
+
+// CHECK-LABEL: @test_ref(
+// CHECK-SAME: noalias
+// CHECK-SAME: %x
+#[no_mangle]
+pub fn test_ref(x: &i32) -> &i32 {
+    x
+}
diff --git a/tests/codegen-llvm/noalias-freeze.rs b/tests/codegen-llvm/noalias-freeze.rs
new file mode 100644
index 00000000000..32c84014026
--- /dev/null
+++ b/tests/codegen-llvm/noalias-freeze.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -Copt-level=1
+
+// References returned by a Frozen pointer type
+// could be marked as "noalias", which caused miscompilation errors.
+// This test runs the most minimal possible code that can reproduce this bug,
+// and checks that noalias does not appear.
+// See https://github.com/rust-lang/rust/issues/46239
+
+#![crate_type = "lib"]
+
+fn project<T>(x: &(T,)) -> &T {
+    &x.0
+}
+
+fn dummy() {}
+
+// CHECK-LABEL: @foo(
+// CHECK-NOT: noalias
+#[no_mangle]
+pub fn foo() {
+    let f = (dummy as fn(),);
+    (*project(&f))();
+}
diff --git a/tests/codegen-llvm/noalias-refcell.rs b/tests/codegen-llvm/noalias-refcell.rs
new file mode 100644
index 00000000000..b37adf92b9c
--- /dev/null
+++ b/tests/codegen-llvm/noalias-refcell.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Z mutable-noalias=yes
+
+#![crate_type = "lib"]
+
+use std::cell::{Ref, RefCell, RefMut};
+
+// Make sure that none of the arguments get a `noalias` attribute, because
+// the `RefCell` might alias writes after either `Ref`/`RefMut` is dropped.
+
+// CHECK-LABEL: @maybe_aliased(
+// CHECK-NOT: noalias
+// CHECK-SAME: %_refcell
+#[no_mangle]
+pub unsafe fn maybe_aliased(_: Ref<'_, i32>, _: RefMut<'_, i32>, _refcell: &RefCell<i32>) {}
diff --git a/tests/codegen-llvm/noalias-rwlockreadguard.rs b/tests/codegen-llvm/noalias-rwlockreadguard.rs
new file mode 100644
index 00000000000..c676dc32399
--- /dev/null
+++ b/tests/codegen-llvm/noalias-rwlockreadguard.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Z mutable-noalias=yes
+
+#![crate_type = "lib"]
+
+use std::sync::{RwLock, RwLockReadGuard};
+
+// Make sure that `RwLockReadGuard` does not get a `noalias` attribute, because
+// the `RwLock` might alias writes after it is dropped.
+
+// CHECK-LABEL: @maybe_aliased(
+// CHECK-NOT: noalias
+// CHECK-SAME: %_data
+#[no_mangle]
+pub unsafe fn maybe_aliased(_: RwLockReadGuard<'_, i32>, _data: &RwLock<i32>) {}
diff --git a/tests/codegen-llvm/noalias-unpin.rs b/tests/codegen-llvm/noalias-unpin.rs
new file mode 100644
index 00000000000..30a8b399b97
--- /dev/null
+++ b/tests/codegen-llvm/noalias-unpin.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -Copt-level=3 -Z mutable-noalias=yes
+
+#![crate_type = "lib"]
+
+pub struct SelfRef {
+    self_ref: *mut SelfRef,
+    _pin: std::marker::PhantomPinned,
+}
+
+// CHECK-LABEL: @test_self_ref(
+// CHECK-NOT: noalias
+#[no_mangle]
+pub unsafe fn test_self_ref(s: &mut SelfRef) {
+    (*s.self_ref).self_ref = std::ptr::null_mut();
+}
diff --git a/tests/codegen-llvm/non-terminate/infinite-loop-1.rs b/tests/codegen-llvm/non-terminate/infinite-loop-1.rs
new file mode 100644
index 00000000000..9eab4939aee
--- /dev/null
+++ b/tests/codegen-llvm/non-terminate/infinite-loop-1.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -C opt-level=3
+
+#![crate_type = "lib"]
+
+fn infinite_loop() -> u8 {
+    loop {}
+}
+
+// CHECK-LABEL: @test
+#[no_mangle]
+fn test() -> u8 {
+    // CHECK-NOT: unreachable
+    // CHECK: br label %{{.+}}
+    // CHECK-NOT: unreachable
+    let x = infinite_loop();
+    x
+}
diff --git a/tests/codegen-llvm/non-terminate/infinite-loop-2.rs b/tests/codegen-llvm/non-terminate/infinite-loop-2.rs
new file mode 100644
index 00000000000..da29361cc96
--- /dev/null
+++ b/tests/codegen-llvm/non-terminate/infinite-loop-2.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: -C opt-level=3
+
+#![crate_type = "lib"]
+
+fn infinite_loop() -> u8 {
+    let i = 2;
+    while i > 1 {}
+    1
+}
+
+// CHECK-LABEL: @test
+#[no_mangle]
+fn test() -> u8 {
+    // CHECK-NOT: unreachable
+    // CHECK: br label %{{.+}}
+    // CHECK-NOT: unreachable
+    let x = infinite_loop();
+    x
+}
diff --git a/tests/codegen-llvm/non-terminate/infinite-recursion.rs b/tests/codegen-llvm/non-terminate/infinite-recursion.rs
new file mode 100644
index 00000000000..19123639896
--- /dev/null
+++ b/tests/codegen-llvm/non-terminate/infinite-recursion.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: -C opt-level=3
+
+#![crate_type = "lib"]
+#![allow(unconditional_recursion)]
+
+// CHECK-LABEL: @infinite_recursion
+#[no_mangle]
+fn infinite_recursion() -> u8 {
+    // CHECK-NOT: ret i8 undef
+    // CHECK: br label %{{.+}}
+    // CHECK-NOT: ret i8 undef
+    infinite_recursion()
+}
diff --git a/tests/codegen-llvm/non-terminate/nonempty-infinite-loop.rs b/tests/codegen-llvm/non-terminate/nonempty-infinite-loop.rs
new file mode 100644
index 00000000000..0db4ee61b1b
--- /dev/null
+++ b/tests/codegen-llvm/non-terminate/nonempty-infinite-loop.rs
@@ -0,0 +1,28 @@
+//@ compile-flags: -C opt-level=3
+
+#![crate_type = "lib"]
+
+// Verify that we don't miscompile this even if rustc didn't apply the trivial loop detection to
+// insert the sideeffect intrinsic.
+
+fn infinite_loop() -> u8 {
+    let mut x = 0;
+    // CHECK-NOT: sideeffect
+    loop {
+        if x == 42 {
+            x = 0;
+        } else {
+            x = 42;
+        }
+    }
+}
+
+// CHECK-LABEL: @test
+#[no_mangle]
+fn test() -> u8 {
+    // CHECK-NOT: unreachable
+    // CHECK: br label %{{.+}}
+    // CHECK-NOT: unreachable
+    let x = infinite_loop();
+    x
+}
diff --git a/tests/codegen-llvm/noreturn-uninhabited.rs b/tests/codegen-llvm/noreturn-uninhabited.rs
new file mode 100644
index 00000000000..a10795d3f3c
--- /dev/null
+++ b/tests/codegen-llvm/noreturn-uninhabited.rs
@@ -0,0 +1,31 @@
+//@ compile-flags: -g -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+#[derive(Clone, Copy)]
+pub enum EmptyEnum {}
+
+#[no_mangle]
+pub fn empty(x: &EmptyEnum) -> EmptyEnum {
+    // CHECK: @empty({{.*}}) unnamed_addr #0
+    // CHECK-NOT: ret void
+    // CHECK: call void @llvm.trap()
+    // CHECK: unreachable
+    *x
+}
+
+pub struct Foo(String, EmptyEnum);
+
+#[no_mangle]
+pub fn foo(x: String, y: &EmptyEnum) -> Foo {
+    // CHECK: @foo({{.*}}) unnamed_addr #0
+    // CHECK-NOT: ret %Foo
+    // CHECK: call void @llvm.trap()
+    // CHECK: unreachable
+    Foo(x, *y)
+}
+
+// CHECK: attributes #0 = {{{.*}} noreturn {{.*}}}
+
+// CHECK: DISubprogram(name: "empty", {{.*}} DIFlagNoReturn
+// CHECK: DISubprogram(name: "foo", {{.*}} DIFlagNoReturn
diff --git a/tests/codegen-llvm/noreturnflag.rs b/tests/codegen-llvm/noreturnflag.rs
new file mode 100644
index 00000000000..d9bb30b2703
--- /dev/null
+++ b/tests/codegen-llvm/noreturnflag.rs
@@ -0,0 +1,22 @@
+//@ compile-flags: -g -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn foo() -> ! {
+    // CHECK: @foo() unnamed_addr #0
+    loop {}
+}
+
+pub enum EmptyEnum {}
+
+#[no_mangle]
+pub fn bar() -> EmptyEnum {
+    // CHECK: @bar() unnamed_addr #0
+    loop {}
+}
+
+// CHECK: attributes #0 = {{{.*}} noreturn {{.*}}}
+
+// CHECK: DISubprogram(name: "foo", {{.*}} DIFlagNoReturn
+// CHECK: DISubprogram(name: "bar", {{.*}} DIFlagNoReturn
diff --git a/tests/codegen-llvm/nounwind.rs b/tests/codegen-llvm/nounwind.rs
new file mode 100644
index 00000000000..c910644458a
--- /dev/null
+++ b/tests/codegen-llvm/nounwind.rs
@@ -0,0 +1,15 @@
+//@ aux-build:nounwind.rs
+//@ compile-flags: -C no-prepopulate-passes -C panic=abort -C metadata=a
+//@ ignore-android
+
+#![crate_type = "lib"]
+
+extern crate nounwind;
+
+#[no_mangle]
+pub fn foo() {
+    nounwind::bar();
+    // CHECK: @foo() unnamed_addr #0
+    // CHECK: @bar() unnamed_addr #0
+    // CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
+}
diff --git a/tests/codegen-llvm/nrvo.rs b/tests/codegen-llvm/nrvo.rs
new file mode 100644
index 00000000000..7972186bfe5
--- /dev/null
+++ b/tests/codegen-llvm/nrvo.rs
@@ -0,0 +1,17 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// Ensure that we do not call `memcpy` for the following function.
+// `memset` and `init` should be called directly on the return pointer.
+#[no_mangle]
+pub fn nrvo(init: fn(&mut [u8; 4096])) -> [u8; 4096] {
+    // CHECK-LABEL: nrvo
+    // CHECK: @llvm.memset
+    // FIXME: turn on nrvo then check-not: @llvm.memcpy
+    // CHECK: ret
+    // CHECK-EMPTY
+    let mut buf = [0; 4096];
+    init(&mut buf);
+    buf
+}
diff --git a/tests/codegen-llvm/optimize-attr-1.rs b/tests/codegen-llvm/optimize-attr-1.rs
new file mode 100644
index 00000000000..db6bdcf9a8b
--- /dev/null
+++ b/tests/codegen-llvm/optimize-attr-1.rs
@@ -0,0 +1,59 @@
+//@ revisions: NO-OPT SIZE-OPT SPEED-OPT
+//@[NO-OPT] compile-flags: -Copt-level=0 -Ccodegen-units=1
+//@[SIZE-OPT] compile-flags: -Copt-level=s -Ccodegen-units=1
+//@[SPEED-OPT] compile-flags: -Copt-level=3 -Ccodegen-units=1
+
+#![feature(optimize_attribute)]
+#![crate_type = "rlib"]
+
+// CHECK-LABEL: define{{.*}}i32 @nothing
+// CHECK-SAME: [[NOTHING_ATTRS:#[0-9]+]]
+// SIZE-OPT: ret i32 4
+// SPEED-OPT: ret i32 4
+#[no_mangle]
+pub fn nothing() -> i32 {
+    2 + 2
+}
+
+// CHECK-LABEL: define{{.*}}i32 @size
+// CHECK-SAME: [[SIZE_ATTRS:#[0-9]+]]
+// SIZE-OPT: ret i32 6
+// SPEED-OPT: ret i32 6
+#[optimize(size)]
+#[no_mangle]
+pub fn size() -> i32 {
+    3 + 3
+}
+
+// CHECK-LABEL: define{{.*}}i32 @speed
+// NO-OPT-SAME: [[NOTHING_ATTRS]]
+// SPEED-OPT-SAME: [[NOTHING_ATTRS]]
+// SIZE-OPT-SAME: [[SPEED_ATTRS:#[0-9]+]]
+// SIZE-OPT: ret i32 8
+// SPEED-OPT: ret i32 8
+#[optimize(speed)]
+#[no_mangle]
+pub fn speed() -> i32 {
+    4 + 4
+}
+
+// CHECK-LABEL: define{{.*}}i32 @none
+// CHECK-SAME: [[NONE_ATTRS:#[0-9]+]]
+// SIZE-OPT: alloca
+// SPEED-OPT: alloca
+#[no_mangle]
+#[optimize(none)]
+pub fn none() -> i32 {
+    let arr = [0, 1, 2, 3, 4];
+    arr[4]
+}
+
+// NO-OPT-DAG: attributes [[SIZE_ATTRS]] = {{.*}}minsize{{.*}}optsize{{.*}}
+// SPEED-OPT-DAG: attributes [[SIZE_ATTRS]] = {{.*}}minsize{{.*}}optsize{{.*}}
+// SIZE-OPT-DAG: attributes [[NOTHING_ATTRS]] = {{.*}}optsize{{.*}}
+// SIZE-OPT-DAG: attributes [[SIZE_ATTRS]] = {{.*}}minsize{{.*}}optsize{{.*}}
+// CHECK-DAG: attributes [[NONE_ATTRS]] = {{.*}}noinline{{.*}}optnone{{.*}}
+
+// SIZE-OPT-DAG: attributes [[SPEED_ATTRS]]
+// SIZE-OPT-NOT: minsize
+// SIZE-OPT-NOT: optsize
diff --git a/tests/codegen-llvm/option-as-slice.rs b/tests/codegen-llvm/option-as-slice.rs
new file mode 100644
index 00000000000..39b34a2035b
--- /dev/null
+++ b/tests/codegen-llvm/option-as-slice.rs
@@ -0,0 +1,71 @@
+//@ compile-flags: -Copt-level=3 -Z randomize-layout=no
+//@ only-x86_64
+#![crate_type = "lib"]
+
+extern crate core;
+
+use core::num::NonZero;
+use core::option::Option;
+
+// CHECK-LABEL: @u64_opt_as_slice
+#[no_mangle]
+pub fn u64_opt_as_slice(o: &Option<u64>) -> &[u64] {
+    // CHECK-NOT: select
+    // CHECK-NOT: br
+    // CHECK-NOT: switch
+    // CHECK-NOT: icmp
+    // CHECK: %[[LEN:.+]] = load i64
+    // CHECK-SAME: !range ![[META_U64:[0-9]+]],
+    // CHECK-SAME: !noundef
+    // CHECK-NOT: select
+    // CHECK-NOT: br
+    // CHECK-NOT: switch
+    // CHECK-NOT: icmp
+    // CHECK: %[[T0:.+]] = insertvalue { ptr, i64 } poison, ptr %{{.+}}, 0
+    // CHECK-NEXT: %[[T1:.+]] = insertvalue { ptr, i64 } %[[T0]], i64 %[[LEN]], 1
+    // CHECK-NEXT: ret { ptr, i64 } %[[T1]]
+    o.as_slice()
+}
+
+// CHECK-LABEL: @nonzero_u64_opt_as_slice
+#[no_mangle]
+pub fn nonzero_u64_opt_as_slice(o: &Option<NonZero<u64>>) -> &[NonZero<u64>] {
+    // CHECK-NOT: select
+    // CHECK-NOT: br
+    // CHECK-NOT: switch
+    // CHECK-NOT: icmp
+    // CHECK: %[[NZ:.+]] = icmp ne i64 %{{.+}}, 0
+    // CHECK-NEXT: %[[LEN:.+]] = zext i1 %[[NZ]] to i64
+    // CHECK-NOT: select
+    // CHECK-NOT: br
+    // CHECK-NOT: switch
+    // CHECK-NOT: icmp
+    // CHECK: %[[T0:.+]] = insertvalue { ptr, i64 } poison, ptr %o, 0
+    // CHECK-NEXT: %[[T1:.+]] = insertvalue { ptr, i64 } %[[T0]], i64 %[[LEN]], 1
+    // CHECK-NEXT: ret { ptr, i64 } %[[T1]]
+    o.as_slice()
+}
+
+// CHECK-LABEL: @u8_opt_as_slice
+#[no_mangle]
+pub fn u8_opt_as_slice(o: &Option<u8>) -> &[u8] {
+    // CHECK-NOT: select
+    // CHECK-NOT: br
+    // CHECK-NOT: switch
+    // CHECK-NOT: icmp
+    // CHECK: %[[TAG:.+]] = load i8
+    // CHECK-SAME: !range ![[META_U8:[0-9]+]],
+    // CHECK-SAME: !noundef
+    // CHECK: %[[LEN:.+]] = zext{{.*}} i8 %[[TAG]] to i64
+    // CHECK-NOT: select
+    // CHECK-NOT: br
+    // CHECK-NOT: switch
+    // CHECK-NOT: icmp
+    // CHECK: %[[T0:.+]] = insertvalue { ptr, i64 } poison, ptr %{{.+}}, 0
+    // CHECK-NEXT: %[[T1:.+]] = insertvalue { ptr, i64 } %[[T0]], i64 %[[LEN]], 1
+    // CHECK-NEXT: ret { ptr, i64 } %[[T1]]
+    o.as_slice()
+}
+
+// CHECK: ![[META_U64]] = !{i64 0, i64 2}
+// CHECK: ![[META_U8]] = !{i8 0, i8 2}
diff --git a/tests/codegen-llvm/option-niche-eq.rs b/tests/codegen-llvm/option-niche-eq.rs
new file mode 100644
index 00000000000..3900cb79aa2
--- /dev/null
+++ b/tests/codegen-llvm/option-niche-eq.rs
@@ -0,0 +1,87 @@
+//@ revisions: REGULAR LLVM21
+//@ min-llvm-version: 20
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+//@ [LLVM21] min-llvm-version: 21
+#![crate_type = "lib"]
+
+extern crate core;
+use core::cmp::Ordering;
+use core::num::NonZero;
+use core::ptr::NonNull;
+
+// CHECK-LABEL: @non_zero_eq
+#[no_mangle]
+pub fn non_zero_eq(l: Option<NonZero<u32>>, r: Option<NonZero<u32>>) -> bool {
+    // CHECK: start:
+    // CHECK-NEXT: icmp eq i32
+    // CHECK-NEXT: ret i1
+    l == r
+}
+
+// CHECK-LABEL: @non_zero_signed_eq
+#[no_mangle]
+pub fn non_zero_signed_eq(l: Option<NonZero<i64>>, r: Option<NonZero<i64>>) -> bool {
+    // CHECK: start:
+    // CHECK-NEXT: icmp eq i64
+    // CHECK-NEXT: ret i1
+    l == r
+}
+
+// FIXME(#49892)
+// This currently relies on a manual implementation of `PartialOrd`/`Ord` for `Option`
+// Once LLVM is better able to optimize this pattern, we can return to using a derive.
+// CHECK-LABEL: @non_zero_ord
+#[no_mangle]
+pub fn non_zero_ord(a: Option<NonZero<u32>>, b: Option<NonZero<u32>>) -> bool {
+    // CHECK: start:
+    // CHECK-NEXT: icmp ult i32
+    // CHECK-NEXT: ret i1
+    a < b
+}
+
+// CHECK-LABEL: @non_null_eq
+#[no_mangle]
+pub fn non_null_eq(l: Option<NonNull<u8>>, r: Option<NonNull<u8>>) -> bool {
+    // CHECK: start:
+    // CHECK-NEXT: icmp eq ptr
+    // CHECK-NEXT: ret i1
+    l == r
+}
+
+// CHECK-LABEL: @ordering_eq
+#[no_mangle]
+pub fn ordering_eq(l: Option<Ordering>, r: Option<Ordering>) -> bool {
+    // CHECK: start:
+    // CHECK-NEXT: icmp eq i8
+    // CHECK-NEXT: ret i1
+    l == r
+}
+
+#[derive(PartialEq)]
+pub enum EnumWithNiche {
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    G,
+}
+
+// CHECK-LABEL: @niche_eq
+#[no_mangle]
+pub fn niche_eq(l: Option<EnumWithNiche>, r: Option<EnumWithNiche>) -> bool {
+    // CHECK: start:
+    // CHECK-NEXT: icmp eq i8
+    // CHECK-NEXT: ret i1
+    l == r
+}
+
+// LLVM21-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
+    l == r
+}
diff --git a/tests/codegen-llvm/option-niche-unfixed/option-nonzero-eq.rs b/tests/codegen-llvm/option-niche-unfixed/option-nonzero-eq.rs
new file mode 100644
index 00000000000..308856cfb7e
--- /dev/null
+++ b/tests/codegen-llvm/option-niche-unfixed/option-nonzero-eq.rs
@@ -0,0 +1,24 @@
+//@ should-fail
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+//! FIXME(#49892)
+//! Test that the derived implementation of `PartialEq` for `Option` is not fully
+//! optimized by LLVM. If this starts passing, the test and manual impl should
+//! be removed.
+#![crate_type = "lib"]
+
+use std::num::NonZero;
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum Option<T> {
+    None,
+    Some(T),
+}
+
+// CHECK-LABEL: @non_zero_eq
+#[no_mangle]
+pub fn non_zero_eq(l: Option<NonZero<u32>>, r: Option<NonZero<u32>>) -> bool {
+    // CHECK: start:
+    // CHECK-NEXT: icmp eq i32
+    // CHECK-NEXT: ret i1
+    l == r
+}
diff --git a/tests/codegen-llvm/overaligned-constant.rs b/tests/codegen-llvm/overaligned-constant.rs
new file mode 100644
index 00000000000..0f5977880f2
--- /dev/null
+++ b/tests/codegen-llvm/overaligned-constant.rs
@@ -0,0 +1,35 @@
+// GVN may create indirect constants with higher alignment than their type requires. Verify that we
+// do not ICE during codegen, and that the LLVM constant has the higher alignment.
+//
+//@ compile-flags: -Zmir-opt-level=0 -Zmir-enable-passes=+GVN
+//@ compile-flags: -Cno-prepopulate-passes --crate-type=lib
+//@ only-64bit
+
+struct S(i32);
+
+struct SmallStruct(f32, Option<S>, &'static [f32]);
+
+// CHECK: [[const:@.*]] = private unnamed_addr constant
+// CHECK-SAME: , align 8
+
+#[no_mangle]
+pub fn overaligned_constant() {
+    // CHECK-LABEL: @overaligned_constant
+    // CHECK: [[full:%_.*]] = alloca [32 x i8], align 8
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[full]], ptr align 8 [[const]], i64 32, i1 false)
+    let mut s = S(1);
+
+    s.0 = 3;
+
+    // SMALL_VAL corresponds to a MIR allocation with alignment 8.
+    const SMALL_VAL: SmallStruct = SmallStruct(4., Some(S(1)), &[]);
+
+    // In pre-codegen MIR:
+    // `a` is a scalar 4.
+    // `b` is an indirect constant at `SMALL_VAL`'s alloc with 0 offset.
+    // `c` is the empty slice.
+    //
+    // As a consequence, during codegen, we create a LLVM allocation for `SMALL_VAL`, with
+    // alignment 8, but only use the `Option<S>` field, at offset 0 with alignment 4.
+    let SmallStruct(a, b, c) = SMALL_VAL;
+}
diff --git a/tests/codegen-llvm/packed.rs b/tests/codegen-llvm/packed.rs
new file mode 100644
index 00000000000..6f62719282e
--- /dev/null
+++ b/tests/codegen-llvm/packed.rs
@@ -0,0 +1,153 @@
+//
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+#[repr(packed)]
+pub struct Packed1 {
+    dealign: u8,
+    data: u32,
+}
+
+#[repr(packed(2))]
+pub struct Packed2 {
+    dealign: u8,
+    data: u32,
+}
+
+// CHECK-LABEL: @write_pkd1
+#[no_mangle]
+pub fn write_pkd1(pkd: &mut Packed1) -> u32 {
+    // CHECK: %{{.*}} = load i32, ptr %{{.*}}, align 1
+    // CHECK: store i32 42, ptr %{{.*}}, align 1
+    let result = pkd.data;
+    pkd.data = 42;
+    result
+}
+
+// CHECK-LABEL: @write_pkd2
+#[no_mangle]
+pub fn write_pkd2(pkd: &mut Packed2) -> u32 {
+    // CHECK: %{{.*}} = load i32, ptr %{{.*}}, align 2
+    // CHECK: store i32 42, ptr %{{.*}}, align 2
+    let result = pkd.data;
+    pkd.data = 42;
+    result
+}
+
+pub struct Array([i32; 8]);
+#[repr(packed)]
+pub struct BigPacked1 {
+    dealign: u8,
+    data: Array,
+}
+
+#[repr(packed(2))]
+pub struct BigPacked2 {
+    dealign: u8,
+    data: Array,
+}
+
+// CHECK-LABEL: @call_pkd1
+#[no_mangle]
+pub fn call_pkd1(f: fn() -> Array) -> BigPacked1 {
+    // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca [32 x i8]
+    // CHECK: call void %{{.*}}(ptr{{( captures(none))?}} noalias{{( nocapture)?}} noundef sret{{.*}} dereferenceable(32) [[ALLOCA]])
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 %{{.*}}, ptr align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false)
+    // check that calls whose destination is a field of a packed struct
+    // go through an alloca rather than calling the function with an
+    // unaligned destination.
+    BigPacked1 { dealign: 0, data: f() }
+}
+
+// CHECK-LABEL: @call_pkd2
+#[no_mangle]
+pub fn call_pkd2(f: fn() -> Array) -> BigPacked2 {
+    // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca [32 x i8]
+    // CHECK: call void %{{.*}}(ptr{{( captures(none))?}} noalias{{( nocapture)?}} noundef sret{{.*}} dereferenceable(32) [[ALLOCA]])
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 2 %{{.*}}, ptr align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false)
+    // check that calls whose destination is a field of a packed struct
+    // go through an alloca rather than calling the function with an
+    // unaligned destination.
+    BigPacked2 { dealign: 0, data: f() }
+}
+
+// CHECK-LABEL: @write_packed_array1
+// CHECK: store i32 0, ptr %{{.+}}, align 1
+// CHECK: store i32 1, ptr %{{.+}}, align 1
+// CHECK: store i32 2, ptr %{{.+}}, align 1
+#[no_mangle]
+pub fn write_packed_array1(p: &mut BigPacked1) {
+    p.data.0[0] = 0;
+    p.data.0[1] = 1;
+    p.data.0[2] = 2;
+}
+
+// CHECK-LABEL: @write_packed_array2
+// CHECK: store i32 0, ptr %{{.+}}, align 2
+// CHECK: store i32 1, ptr %{{.+}}, align 2
+// CHECK: store i32 2, ptr %{{.+}}, align 2
+#[no_mangle]
+pub fn write_packed_array2(p: &mut BigPacked2) {
+    p.data.0[0] = 0;
+    p.data.0[1] = 1;
+    p.data.0[2] = 2;
+}
+
+// CHECK-LABEL: @repeat_packed_array1
+// CHECK: store i32 42, ptr %{{.+}}, align 1
+#[no_mangle]
+pub fn repeat_packed_array1(p: &mut BigPacked1) {
+    p.data.0 = [42; 8];
+}
+
+// CHECK-LABEL: @repeat_packed_array2
+// CHECK: store i32 42, ptr %{{.+}}, align 2
+#[no_mangle]
+pub fn repeat_packed_array2(p: &mut BigPacked2) {
+    p.data.0 = [42; 8];
+}
+
+#[repr(packed)]
+#[derive(Copy, Clone)]
+pub struct Packed1Pair(u8, u32);
+
+#[repr(packed(2))]
+#[derive(Copy, Clone)]
+pub struct Packed2Pair(u8, u32);
+
+// CHECK-LABEL: @pkd1_pair
+#[no_mangle]
+pub fn pkd1_pair(pair1: &mut Packed1Pair, pair2: &mut Packed1Pair) {
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 %{{.*}}, ptr align 1 %{{.*}}, i{{[0-9]+}} 5, i1 false)
+    *pair2 = *pair1;
+}
+
+// CHECK-LABEL: @pkd2_pair
+#[no_mangle]
+pub fn pkd2_pair(pair1: &mut Packed2Pair, pair2: &mut Packed2Pair) {
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 2 %{{.*}}, ptr align 2 %{{.*}}, i{{[0-9]+}} 6, i1 false)
+    *pair2 = *pair1;
+}
+
+#[repr(packed)]
+#[derive(Copy, Clone)]
+pub struct Packed1NestedPair((u32, u32));
+
+#[repr(packed(2))]
+#[derive(Copy, Clone)]
+pub struct Packed2NestedPair((u32, u32));
+
+// CHECK-LABEL: @pkd1_nested_pair
+#[no_mangle]
+pub fn pkd1_nested_pair(pair1: &mut Packed1NestedPair, pair2: &mut Packed1NestedPair) {
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 %{{.*}}, ptr align 1 %{{.*}}, i{{[0-9]+}} 8, i1 false)
+    *pair2 = *pair1;
+}
+
+// CHECK-LABEL: @pkd2_nested_pair
+#[no_mangle]
+pub fn pkd2_nested_pair(pair1: &mut Packed2NestedPair, pair2: &mut Packed2NestedPair) {
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 2 %{{.*}}, ptr align 2 %{{.*}}, i{{[0-9]+}} 8, i1 false)
+    *pair2 = *pair1;
+}
diff --git a/tests/codegen-llvm/panic-abort-windows.rs b/tests/codegen-llvm/panic-abort-windows.rs
new file mode 100644
index 00000000000..17fdd9cc726
--- /dev/null
+++ b/tests/codegen-llvm/panic-abort-windows.rs
@@ -0,0 +1,16 @@
+// This test is for *-windows only.
+//@ only-windows
+
+//@ compile-flags: -C no-prepopulate-passes -C panic=abort -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK: Function Attrs: nounwind uwtable
+// CHECK-NEXT: define void @normal_uwtable()
+#[no_mangle]
+pub fn normal_uwtable() {}
+
+// CHECK: Function Attrs: nounwind uwtable
+// CHECK-NEXT: define void @extern_uwtable()
+#[no_mangle]
+pub extern "C" fn extern_uwtable() {}
diff --git a/tests/codegen-llvm/panic-in-drop-abort.rs b/tests/codegen-llvm/panic-in-drop-abort.rs
new file mode 100644
index 00000000000..e89170e56ed
--- /dev/null
+++ b/tests/codegen-llvm/panic-in-drop-abort.rs
@@ -0,0 +1,57 @@
+//@ compile-flags: -Z panic-in-drop=abort -Copt-level=3
+//@ ignore-msvc
+
+// Ensure that unwinding code paths are eliminated from the output after
+// optimization.
+
+// This test uses ignore-msvc, because the expected optimization does not happen on targets using
+// SEH exceptions with the new LLVM pass manager anymore, see
+// https://github.com/llvm/llvm-project/issues/51311.
+
+// CHECK-NOT: {{(call|invoke).*}}should_not_appear_in_output
+
+#![crate_type = "lib"]
+use std::any::Any;
+use std::mem::forget;
+
+pub struct ExternDrop;
+impl Drop for ExternDrop {
+    #[inline(always)]
+    fn drop(&mut self) {
+        // This call may potentially unwind.
+        extern "Rust" {
+            fn extern_drop();
+        }
+        unsafe {
+            extern_drop();
+        }
+    }
+}
+
+struct AssertNeverDrop;
+impl Drop for AssertNeverDrop {
+    #[inline(always)]
+    fn drop(&mut self) {
+        // This call should be optimized away as unreachable.
+        extern "C" {
+            fn should_not_appear_in_output();
+        }
+        unsafe {
+            should_not_appear_in_output();
+        }
+    }
+}
+
+#[no_mangle]
+pub fn normal_drop(x: ExternDrop) {
+    let guard = AssertNeverDrop;
+    drop(x);
+    forget(guard);
+}
+
+#[no_mangle]
+pub fn indirect_drop(x: Box<dyn Any>) {
+    let guard = AssertNeverDrop;
+    drop(x);
+    forget(guard);
+}
diff --git a/tests/codegen-llvm/panic-unwind-default-uwtable.rs b/tests/codegen-llvm/panic-unwind-default-uwtable.rs
new file mode 100644
index 00000000000..06f616c519b
--- /dev/null
+++ b/tests/codegen-llvm/panic-unwind-default-uwtable.rs
@@ -0,0 +1,6 @@
+//@ compile-flags: -C panic=unwind -C no-prepopulate-passes -Copt-level=0
+
+#![crate_type = "lib"]
+
+// CHECK: attributes #{{.*}} uwtable
+pub fn foo() {}
diff --git a/tests/codegen-llvm/patchable-function-entry/patchable-function-entry-both-flags.rs b/tests/codegen-llvm/patchable-function-entry/patchable-function-entry-both-flags.rs
new file mode 100644
index 00000000000..72204c78a49
--- /dev/null
+++ b/tests/codegen-llvm/patchable-function-entry/patchable-function-entry-both-flags.rs
@@ -0,0 +1,64 @@
+//@ compile-flags: -Z patchable-function-entry=15,10
+
+#![feature(patchable_function_entry)]
+#![crate_type = "lib"]
+
+// This should have the default, as set by the compile flags
+#[no_mangle]
+pub fn fun0() {}
+
+// The attribute should override the compile flags
+#[no_mangle]
+#[patchable_function_entry(prefix_nops = 1, entry_nops = 2)]
+pub fn fun1() {}
+
+// If we override an attribute to 0 or unset, the attribute should go away
+#[no_mangle]
+#[patchable_function_entry(entry_nops = 0)]
+pub fn fun2() {}
+
+// The attribute should override the compile flags
+#[no_mangle]
+#[patchable_function_entry(prefix_nops = 20, entry_nops = 1)]
+pub fn fun3() {}
+
+// The attribute should override the compile flags
+#[no_mangle]
+#[patchable_function_entry(prefix_nops = 2, entry_nops = 19)]
+pub fn fun4() {}
+
+// The attribute should override patchable-function-entry to 3 and
+// patchable-function-prefix to the default of 0, clearing it entirely
+#[no_mangle]
+#[patchable_function_entry(entry_nops = 3)]
+pub fn fun5() {}
+
+// The attribute should override patchable-function-prefix to 4
+// and patchable-function-entry to the default of 0, clearing it entirely
+#[no_mangle]
+#[patchable_function_entry(prefix_nops = 4)]
+pub fn fun6() {}
+
+// CHECK: @fun0() unnamed_addr #0
+// CHECK: @fun1() unnamed_addr #1
+// CHECK: @fun2() unnamed_addr #2
+// CHECK: @fun3() unnamed_addr #3
+// CHECK: @fun4() unnamed_addr #4
+// CHECK: @fun5() unnamed_addr #5
+// CHECK: @fun6() unnamed_addr #6
+
+// CHECK: attributes #0 = { {{.*}}"patchable-function-entry"="5"{{.*}}"patchable-function-prefix"="10" {{.*}} }
+// CHECK: attributes #1 = { {{.*}}"patchable-function-entry"="2"{{.*}}"patchable-function-prefix"="1" {{.*}} }
+
+// CHECK-NOT: attributes #2 = { {{.*}}patchable-function-entry{{.*}} }
+// CHECK-NOT: attributes #2 = { {{.*}}patchable-function-prefix{{.*}} }
+// CHECK: attributes #2 = { {{.*}} }
+
+// CHECK: attributes #3 = { {{.*}}"patchable-function-entry"="1"{{.*}}"patchable-function-prefix"="20" {{.*}} }
+// CHECK: attributes #4 = { {{.*}}"patchable-function-entry"="19"{{.*}}"patchable-function-prefix"="2" {{.*}} }
+
+// CHECK: attributes #5 = { {{.*}}"patchable-function-entry"="3"{{.*}} }
+// CHECK-NOT: attributes #5 = { {{.*}}patchable-function-prefix{{.*}} }
+
+// CHECK: attributes #6 = { {{.*}}"patchable-function-prefix"="4"{{.*}} }
+// CHECK-NOT: attributes #6 = { {{.*}}patchable-function-entry{{.*}} }
diff --git a/tests/codegen-llvm/patchable-function-entry/patchable-function-entry-no-flag.rs b/tests/codegen-llvm/patchable-function-entry/patchable-function-entry-no-flag.rs
new file mode 100644
index 00000000000..3a7078fe551
--- /dev/null
+++ b/tests/codegen-llvm/patchable-function-entry/patchable-function-entry-no-flag.rs
@@ -0,0 +1,39 @@
+#![feature(patchable_function_entry)]
+#![crate_type = "lib"]
+
+// No patchable function entry should be set
+#[no_mangle]
+pub fn fun0() {}
+
+// The attribute should work even without compiler flags
+#[no_mangle]
+#[patchable_function_entry(prefix_nops = 1, entry_nops = 2)]
+pub fn fun1() {}
+
+// The attribute should work even without compiler flags
+// and only set patchable-function-entry to 3.
+#[no_mangle]
+#[patchable_function_entry(entry_nops = 3)]
+pub fn fun2() {}
+
+// The attribute should work even without compiler flags
+// and only set patchable-function-prefix to 4.
+#[no_mangle]
+#[patchable_function_entry(prefix_nops = 4)]
+pub fn fun3() {}
+
+// CHECK: @fun0() unnamed_addr #0
+// CHECK: @fun1() unnamed_addr #1
+// CHECK: @fun2() unnamed_addr #2
+// CHECK: @fun3() unnamed_addr #3
+
+// CHECK-NOT: attributes #0 = { {{.*}}patchable-function-entry{{.*}} }
+// CHECK-NOT: attributes #0 = { {{.*}}patchable-function-prefix{{.*}} }
+
+// CHECK: attributes #1 = { {{.*}}"patchable-function-entry"="2"{{.*}}"patchable-function-prefix"="1" {{.*}} }
+
+// CHECK: attributes #2 = { {{.*}}"patchable-function-entry"="3"{{.*}} }
+// CHECK-NOT: attributes #2 = { {{.*}}patchable-function-prefix{{.*}} }
+
+// CHECK: attributes #3 = { {{.*}}"patchable-function-prefix"="4"{{.*}} }
+// CHECK-NOT: attributes #3 = { {{.*}}patchable-function-entry{{.*}} }
diff --git a/tests/codegen-llvm/patchable-function-entry/patchable-function-entry-one-flag.rs b/tests/codegen-llvm/patchable-function-entry/patchable-function-entry-one-flag.rs
new file mode 100644
index 00000000000..8bdd61e461b
--- /dev/null
+++ b/tests/codegen-llvm/patchable-function-entry/patchable-function-entry-one-flag.rs
@@ -0,0 +1,66 @@
+//@ compile-flags: -Z patchable-function-entry=15
+
+#![feature(patchable_function_entry)]
+#![crate_type = "lib"]
+
+// This should have the default, as set by the compile flags
+#[no_mangle]
+pub fn fun0() {}
+
+// The attribute should override the compile flags
+#[no_mangle]
+#[patchable_function_entry(prefix_nops = 1, entry_nops = 2)]
+pub fn fun1() {}
+
+// If we override an attribute to 0 or unset, the attribute should go away
+#[no_mangle]
+#[patchable_function_entry(entry_nops = 0)]
+pub fn fun2() {}
+
+// The attribute should override the compile flags
+#[no_mangle]
+#[patchable_function_entry(prefix_nops = 20, entry_nops = 1)]
+pub fn fun3() {}
+
+// The attribute should override the compile flags
+#[no_mangle]
+#[patchable_function_entry(prefix_nops = 2, entry_nops = 19)]
+pub fn fun4() {}
+
+// The attribute should override patchable-function-entry to 3
+// and patchable-function-prefix to the default of 0, clearing it entirely
+#[no_mangle]
+#[patchable_function_entry(entry_nops = 3)]
+pub fn fun5() {}
+
+// The attribute should override patchable-function-prefix to 4
+// and patchable-function-entry to the default of 0, clearing it entirely
+#[no_mangle]
+#[patchable_function_entry(prefix_nops = 4)]
+pub fn fun6() {}
+
+// CHECK: @fun0() unnamed_addr #0
+// CHECK: @fun1() unnamed_addr #1
+// CHECK: @fun2() unnamed_addr #2
+// CHECK: @fun3() unnamed_addr #3
+// CHECK: @fun4() unnamed_addr #4
+// CHECK: @fun5() unnamed_addr #5
+// CHECK: @fun6() unnamed_addr #6
+
+// CHECK: attributes #0 = { {{.*}}"patchable-function-entry"="15" {{.*}} }
+// CHECK-NOT: attributes #0 = { {{.*}}patchable-function-prefix{{.*}} }
+
+// CHECK: attributes #1 = { {{.*}}"patchable-function-entry"="2"{{.*}}"patchable-function-prefix"="1" {{.*}} }
+
+// CHECK-NOT: attributes #2 = { {{.*}}patchable-function-entry{{.*}} }
+// CHECK-NOT: attributes #2 = { {{.*}}patchable-function-prefix{{.*}} }
+// CHECK: attributes #2 = { {{.*}} }
+
+// CHECK: attributes #3 = { {{.*}}"patchable-function-entry"="1"{{.*}}"patchable-function-prefix"="20" {{.*}} }
+// CHECK: attributes #4 = { {{.*}}"patchable-function-entry"="19"{{.*}}"patchable-function-prefix"="2" {{.*}} }
+
+// CHECK: attributes #5 = { {{.*}}"patchable-function-entry"="3"{{.*}} }
+// CHECK-NOT: attributes #5 = { {{.*}}patchable-function-prefix{{.*}} }
+
+// CHECK: attributes #6 = { {{.*}}"patchable-function-prefix"="4"{{.*}} }
+// CHECK-NOT: attributes #6 = { {{.*}}patchable-function-entry{{.*}} }
diff --git a/tests/codegen-llvm/pattern_type_symbols.rs b/tests/codegen-llvm/pattern_type_symbols.rs
new file mode 100644
index 00000000000..e86a9ef27de
--- /dev/null
+++ b/tests/codegen-llvm/pattern_type_symbols.rs
@@ -0,0 +1,22 @@
+//! Check that symbol names with pattern types in them are
+//! different from the same symbol with the base type
+
+//@ compile-flags: -Csymbol-mangling-version=v0 -Copt-level=0 --crate-type=lib
+
+#![feature(pattern_types)]
+#![feature(pattern_type_macro)]
+
+use std::pat::pattern_type;
+
+type NanoU32 = crate::pattern_type!(u32 is 0..=999_999_999);
+
+fn foo<T>() {}
+
+pub fn bar() {
+    // CHECK: call pattern_type_symbols::foo::<u32>
+    // CHECK: call void @_RINvC[[CRATE_IDENT:[a-zA-Z0-9]{12}]]_20pattern_type_symbols3foomEB2_
+    foo::<u32>();
+    // CHECK: call pattern_type_symbols::foo::<(u32, [(); 0], [(); 999999999])>
+    // CHECK: call void @_RINvC[[CRATE_IDENT]]_20pattern_type_symbols3fooTmAum0_Aum3b9ac9ff_EEB2_
+    foo::<NanoU32>();
+}
diff --git a/tests/codegen-llvm/personality_lifetimes.rs b/tests/codegen-llvm/personality_lifetimes.rs
new file mode 100644
index 00000000000..cd81db63953
--- /dev/null
+++ b/tests/codegen-llvm/personality_lifetimes.rs
@@ -0,0 +1,32 @@
+//@ ignore-msvc
+//@ needs-unwind
+
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+struct S;
+
+impl Drop for S {
+    #[inline(never)]
+    fn drop(&mut self) {}
+}
+
+#[inline(never)]
+fn might_unwind() {}
+
+// CHECK-LABEL: @test
+#[no_mangle]
+pub fn test() {
+    let _s = S;
+    // Check that the personality slot alloca gets a lifetime start in each cleanup block, not just
+    // in the first one.
+    // CHECK: [[SLOT:%[0-9]+]] = alloca [{{[0-9]+}} x i8]
+    // CHECK-LABEL: cleanup:
+    // CHECK: call void @llvm.lifetime.start.{{.*}}({{.*}})
+    // CHECK-LABEL: cleanup1:
+    // CHECK: call void @llvm.lifetime.start.{{.*}}({{.*}})
+    might_unwind();
+    let _t = S;
+    might_unwind();
+}
diff --git a/tests/codegen-llvm/pgo-counter-bias.rs b/tests/codegen-llvm/pgo-counter-bias.rs
new file mode 100644
index 00000000000..48e815dda04
--- /dev/null
+++ b/tests/codegen-llvm/pgo-counter-bias.rs
@@ -0,0 +1,10 @@
+// Test that __llvm_profile_counter_bias does not get internalized by lto.
+
+//@ ignore-apple -runtime-counter-relocation not honored on Mach-O
+//@ compile-flags: -Cprofile-generate -Cllvm-args=-runtime-counter-relocation -Clto=fat
+//@ compile-flags: -Zno-profiler-runtime
+//@ no-prefer-dynamic
+
+// CHECK: @__llvm_profile_counter_bias = {{.*}}global
+
+pub fn main() {}
diff --git a/tests/codegen-llvm/pgo-instrumentation.rs b/tests/codegen-llvm/pgo-instrumentation.rs
new file mode 100644
index 00000000000..a8f12ccce1c
--- /dev/null
+++ b/tests/codegen-llvm/pgo-instrumentation.rs
@@ -0,0 +1,20 @@
+// Test that `-Cprofile-generate` creates expected instrumentation artifacts in LLVM IR.
+
+//@ compile-flags: -Zno-profiler-runtime
+//@ compile-flags: -Cprofile-generate -Ccodegen-units=1
+
+// CHECK: @__llvm_profile_raw_version =
+// CHECK-DAG: @__profc_{{.*}}pgo_instrumentation{{.*}}some_function{{.*}} = {{.*}}global
+// CHECK-DAG: @__profd_{{.*}}pgo_instrumentation{{.*}}some_function{{.*}} = {{.*}}global
+// CHECK-DAG: @__profc_{{.*}}pgo_instrumentation{{.*}}some_other_function{{.*}} = {{.*}}global
+// CHECK-DAG: @__profd_{{.*}}pgo_instrumentation{{.*}}some_other_function{{.*}} = {{.*}}global
+// CHECK: @__llvm_profile_filename = {{.*}}"default_%m.profraw\00"{{.*}}
+
+#![crate_type = "lib"]
+
+#[inline(never)]
+fn some_function() {}
+
+pub fn some_other_function() {
+    some_function();
+}
diff --git a/tests/codegen-llvm/pic-relocation-model.rs b/tests/codegen-llvm/pic-relocation-model.rs
new file mode 100644
index 00000000000..a1d1678a6bd
--- /dev/null
+++ b/tests/codegen-llvm/pic-relocation-model.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: -C relocation-model=pic -Copt-level=0
+
+#![crate_type = "rlib"]
+
+// CHECK: define i8 @call_foreign_fn()
+#[no_mangle]
+pub fn call_foreign_fn() -> u8 {
+    unsafe { foreign_fn() }
+}
+
+// (Allow but do not require `zeroext` here, because it is not worth effort to
+// spell out which targets have it and which ones do not; see rust#97800.)
+
+// CHECK: declare{{( zeroext)?}} i8 @foreign_fn()
+extern "C" {
+    fn foreign_fn() -> u8;
+}
+
+// CHECK: !{i32 {{[78]}}, !"PIC Level", i32 2}
diff --git a/tests/codegen-llvm/pie-relocation-model.rs b/tests/codegen-llvm/pie-relocation-model.rs
new file mode 100644
index 00000000000..cb8de91ccd7
--- /dev/null
+++ b/tests/codegen-llvm/pie-relocation-model.rs
@@ -0,0 +1,22 @@
+//@ compile-flags: -C relocation-model=pie -Copt-level=0
+//@ only-x86_64-unknown-linux-gnu
+
+#![crate_type = "rlib"]
+
+// With PIE we know local functions cannot be interpositioned, we can mark them
+// as dso_local.
+// CHECK: define dso_local i8 @call_foreign_fn()
+#[no_mangle]
+pub fn call_foreign_fn() -> u8 {
+    unsafe { foreign_fn() }
+}
+
+// External functions are still marked as non-dso_local, since we don't know if the symbol
+// is defined in the binary or in the shared library.
+// CHECK: declare i8 @foreign_fn()
+extern "C" {
+    fn foreign_fn() -> u8;
+}
+
+// CHECK: !{i32 {{[78]}}, !"PIC Level", i32 2}
+// CHECK: !{i32 7, !"PIE Level", i32 2}
diff --git a/tests/codegen-llvm/placement-new.rs b/tests/codegen-llvm/placement-new.rs
new file mode 100644
index 00000000000..7f7f0033bec
--- /dev/null
+++ b/tests/codegen-llvm/placement-new.rs
@@ -0,0 +1,39 @@
+//@ compile-flags: -Copt-level=3
+//@ compile-flags: -Zmerge-functions=disabled
+#![crate_type = "lib"]
+
+// Test to check that types with "complex" destructors, but trivial `Default` impls
+// are constructed directly into the allocation in `Box::default` and `Arc::default`.
+
+use std::rc::Rc;
+use std::sync::Arc;
+
+// CHECK-LABEL: @box_default_inplace
+#[no_mangle]
+pub fn box_default_inplace() -> Box<(String, String)> {
+    // CHECK-NOT: alloca
+    // CHECK: [[BOX:%.*]] = {{.*}}call {{.*}}__rust_alloc(
+    // CHECK-NOT: call void @llvm.memcpy
+    // CHECK: ret ptr [[BOX]]
+    Box::default()
+}
+
+// CHECK-LABEL: @rc_default_inplace
+#[no_mangle]
+pub fn rc_default_inplace() -> Rc<(String, String)> {
+    // CHECK-NOT: alloca
+    // CHECK: [[RC:%.*]] = {{.*}}call {{.*}}__rust_alloc(
+    // CHECK-NOT: call void @llvm.memcpy
+    // CHECK: ret ptr [[RC]]
+    Rc::default()
+}
+
+// CHECK-LABEL: @arc_default_inplace
+#[no_mangle]
+pub fn arc_default_inplace() -> Arc<(String, String)> {
+    // CHECK-NOT: alloca
+    // CHECK: [[ARC:%.*]] = {{.*}}call {{.*}}__rust_alloc(
+    // CHECK-NOT: call void @llvm.memcpy
+    // CHECK: ret ptr [[ARC]]
+    Arc::default()
+}
diff --git a/tests/codegen-llvm/powerpc64le-struct-align-128.rs b/tests/codegen-llvm/powerpc64le-struct-align-128.rs
new file mode 100644
index 00000000000..c1c1ac26485
--- /dev/null
+++ b/tests/codegen-llvm/powerpc64le-struct-align-128.rs
@@ -0,0 +1,96 @@
+// Test that structs aligned to 128 bits are passed with the correct ABI on powerpc64le.
+// This is similar to aarch64-struct-align-128.rs, but for ppc.
+
+//@ add-core-stubs
+//@ compile-flags: --target powerpc64le-unknown-linux-gnu
+//@ needs-llvm-components: powerpc
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C)]
+pub struct Align8 {
+    pub a: u64,
+    pub b: u64,
+}
+
+#[repr(transparent)]
+pub struct Transparent8 {
+    a: Align8,
+}
+
+#[repr(C)]
+pub struct Wrapped8 {
+    a: Align8,
+}
+
+extern "C" {
+    // CHECK: declare void @test_8([2 x i64], [2 x i64], [2 x i64])
+    fn test_8(a: Align8, b: Transparent8, c: Wrapped8);
+}
+
+#[repr(C)]
+#[repr(align(16))]
+pub struct Align16 {
+    pub a: u64,
+    pub b: u64,
+}
+
+#[repr(transparent)]
+pub struct Transparent16 {
+    a: Align16,
+}
+
+#[repr(C)]
+pub struct Wrapped16 {
+    pub a: Align16,
+}
+
+extern "C" {
+    // It's important that this produces [1 x i128]  rather than just i128!
+    // CHECK: declare void @test_16([1 x i128], [1 x i128], [1 x i128])
+    fn test_16(a: Align16, b: Transparent16, c: Wrapped16);
+}
+
+#[repr(C)]
+#[repr(align(32))]
+pub struct Align32 {
+    pub a: u64,
+    pub b: u64,
+    pub c: u64,
+}
+
+#[repr(transparent)]
+pub struct Transparent32 {
+    a: Align32,
+}
+
+#[repr(C)]
+pub struct Wrapped32 {
+    pub a: Align32,
+}
+
+extern "C" {
+    // CHECK: declare void @test_32([2 x i128], [2 x i128], [2 x i128])
+    fn test_32(a: Align32, b: Transparent32, c: Wrapped32);
+}
+
+pub unsafe fn main(
+    a1: Align8,
+    a2: Transparent8,
+    a3: Wrapped8,
+    b1: Align16,
+    b2: Transparent16,
+    b3: Wrapped16,
+    c1: Align32,
+    c2: Transparent32,
+    c3: Wrapped32,
+) {
+    test_8(a1, a2, a3);
+    test_16(b1, b2, b3);
+    test_32(c1, c2, c3);
+}
diff --git a/tests/codegen-llvm/precondition-checks.rs b/tests/codegen-llvm/precondition-checks.rs
new file mode 100644
index 00000000000..16812ca1720
--- /dev/null
+++ b/tests/codegen-llvm/precondition-checks.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Cno-prepopulate-passes -Copt-level=0 -Cdebug-assertions=no
+
+// This test ensures that in a debug build which turns off debug assertions, we do not monomorphize
+// any of the standard library's unsafe precondition checks.
+// The naive codegen of those checks contains the actual check underneath an `if false`, which
+// could be optimized out if optimizations are enabled. But if we rely on optimizations to remove
+// panic branches, then we can't link compiler_builtins without optimizing it, which means that
+// -Zbuild-std doesn't work with -Copt-level=0.
+//
+// In other words, this tests for a mandatory optimization.
+
+#![crate_type = "lib"]
+
+use std::ptr::NonNull;
+
+// CHECK-LABEL: ; core::ptr::non_null::NonNull<T>::new_unchecked
+// CHECK-NOT: call
+// CHECK: }
+
+// CHECK-LABEL: @nonnull_new
+#[no_mangle]
+pub unsafe fn nonnull_new(ptr: *mut u8) -> NonNull<u8> {
+    // CHECK: ; call core::ptr::non_null::NonNull<T>::new_unchecked
+    unsafe { NonNull::new_unchecked(ptr) }
+}
diff --git a/tests/codegen-llvm/ptr-arithmetic.rs b/tests/codegen-llvm/ptr-arithmetic.rs
new file mode 100644
index 00000000000..fc4441ef448
--- /dev/null
+++ b/tests/codegen-llvm/ptr-arithmetic.rs
@@ -0,0 +1,33 @@
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: ptr @i32_add(
+// 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: ret ptr %[[TEMP]]
+    p.add(n)
+}
+
+// Ensure we tell LLVM that the negation in `sub` can't overflow.
+
+// CHECK-LABEL: ptr @i32_sub(
+// CHECK-SAME: [[WORD:i[0-9]+]] noundef %n)
+#[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: ret ptr %[[TEMP]]
+    p.sub(n)
+}
+
+// CHECK-LABEL: ptr @i32_offset(
+// 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: ret ptr %[[TEMP]]
+    p.offset(d)
+}
diff --git a/tests/codegen-llvm/ptr-read-metadata.rs b/tests/codegen-llvm/ptr-read-metadata.rs
new file mode 100644
index 00000000000..b38cfdbff88
--- /dev/null
+++ b/tests/codegen-llvm/ptr-read-metadata.rs
@@ -0,0 +1,94 @@
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+
+#![crate_type = "lib"]
+
+// Ensure that various forms of reading pointers correctly annotate the `load`s
+// with `!noundef` and `!range` metadata to enable extra optimization.
+
+use std::mem::MaybeUninit;
+
+// CHECK-LABEL: define {{(dso_local )?}}noundef i8 @copy_byte(
+#[no_mangle]
+pub unsafe fn copy_byte(p: *const u8) -> u8 {
+    // CHECK-NOT: load
+    // CHECK: load i8, ptr %p, align 1
+    // CHECK-SAME: !noundef !
+    // CHECK-NOT: load
+    *p
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}noundef i8 @read_byte(
+#[no_mangle]
+pub unsafe fn read_byte(p: *const u8) -> u8 {
+    // CHECK-NOT: load
+    // CHECK: load i8, ptr %p, align 1
+    // CHECK-SAME: !noundef !
+    // CHECK-NOT: load
+    p.read()
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}i8 @read_byte_maybe_uninit(
+#[no_mangle]
+pub unsafe fn read_byte_maybe_uninit(p: *const MaybeUninit<u8>) -> MaybeUninit<u8> {
+    // CHECK-NOT: load
+    // CHECK: load i8, ptr %p, align 1
+    // CHECK-NOT: noundef
+    // CHECK-NOT: load
+    p.read()
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}noundef i8 @read_byte_assume_init(
+#[no_mangle]
+pub unsafe fn read_byte_assume_init(p: &MaybeUninit<u8>) -> u8 {
+    // CHECK-NOT: load
+    // CHECK: load i8, ptr %p, align 1
+    // CHECK-SAME: !noundef !
+    // CHECK-NOT: load
+    p.assume_init_read()
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}noundef {{(range\(.*\) )?}}i32 @copy_char(
+#[no_mangle]
+pub unsafe fn copy_char(p: *const char) -> char {
+    // CHECK-NOT: load
+    // CHECK: load i32, ptr %p
+    // CHECK-SAME: !range ![[RANGE:[0-9]+]]
+    // CHECK-SAME: !noundef !
+    // CHECK-NOT: load
+    *p
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}noundef {{(range\(.*\) )?}}i32 @read_char(
+#[no_mangle]
+pub unsafe fn read_char(p: *const char) -> char {
+    // CHECK-NOT: load
+    // CHECK: load i32, ptr %p
+    // CHECK-SAME: !range ![[RANGE]]
+    // CHECK-SAME: !noundef !
+    // CHECK-NOT: load
+    p.read()
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}i32 @read_char_maybe_uninit(
+#[no_mangle]
+pub unsafe fn read_char_maybe_uninit(p: *const MaybeUninit<char>) -> MaybeUninit<char> {
+    // CHECK-NOT: load
+    // CHECK: load i32, ptr %p
+    // CHECK-NOT: range
+    // CHECK-NOT: noundef
+    // CHECK-NOT: load
+    p.read()
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}noundef {{(range\(.*\) )?}}i32 @read_char_assume_init(
+#[no_mangle]
+pub unsafe fn read_char_assume_init(p: &MaybeUninit<char>) -> char {
+    // CHECK-NOT: load
+    // CHECK: load i32, ptr %p
+    // CHECK-SAME: !range ![[RANGE]]
+    // CHECK-SAME: !noundef !
+    // CHECK-NOT: load
+    p.assume_init_read()
+}
+
+// CHECK: ![[RANGE]] = !{i32 0, i32 1114112}
diff --git a/tests/codegen-llvm/range-attribute.rs b/tests/codegen-llvm/range-attribute.rs
new file mode 100644
index 00000000000..b81ff9ab3e2
--- /dev/null
+++ b/tests/codegen-llvm/range-attribute.rs
@@ -0,0 +1,74 @@
+// Checks that range metadata gets emitted on functions result and arguments
+// with scalar value.
+
+// 32-bit systems will return 128bit values using a return area pointer.
+//@ revisions: bit32 bit64
+//@[bit32] only-32bit
+//@[bit64] only-64bit
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+use std::num::NonZero;
+
+// Hack to get the correct size for usize
+// CHECK: @helper([[USIZE:i[0-9]+]] noundef %_1)
+#[no_mangle]
+pub fn helper(_: usize) {}
+
+// bit32: void @nonzero_int({{.*}} sret([16 x i8]) {{.*}}, i128 noundef range(i128 1, 0) %x)
+// bit64: noundef range(i128 1, 0) i128 @nonzero_int(i128 noundef range(i128 1, 0) %x)
+#[no_mangle]
+pub fn nonzero_int(x: NonZero<u128>) -> NonZero<u128> {
+    x
+}
+
+// CHECK: noundef range(i8 0, 3) i8 @optional_bool(i8{{.*}} range(i8 0, 3) %x)
+#[no_mangle]
+pub fn optional_bool(x: Option<bool>) -> Option<bool> {
+    x
+}
+
+pub enum Enum0 {
+    A(bool),
+    B,
+    C,
+}
+
+// CHECK: noundef range(i8 0, 4) i8 @enum0_value(i8{{.*}} range(i8 0, 4) %x)
+#[no_mangle]
+pub fn enum0_value(x: Enum0) -> Enum0 {
+    x
+}
+
+pub enum Enum1 {
+    A(u64),
+    B(u64),
+    C(u64),
+}
+
+// bit32: void @enum1_value({{.*}} sret({{[^,]*}}) {{[^,]*}}, [[ENUM1_TYP:i[0-9]+]]
+// bit64: { [[ENUM1_TYP:i[0-9]+]], i64 } @enum1_value([[ENUM1_TYP]]
+// CHECK-SAME: noundef range([[ENUM1_TYP]] 0, 3) %x.0, i64 noundef %x.1)
+#[no_mangle]
+pub fn enum1_value(x: Enum1) -> Enum1 {
+    x
+}
+
+pub enum Enum2 {
+    A(Enum0),
+    B(Enum0),
+    C(Enum0),
+}
+
+// CHECK: { i8, i8 } @enum2_value(i8 noundef range(i8 0, 3) %x.0, i8 noundef %x.1)
+#[no_mangle]
+pub fn enum2_value(x: Enum2) -> Enum2 {
+    x
+}
+
+// CHECK: noundef [[USIZE]] @takes_slice(ptr noalias noundef nonnull readonly align 4 %x.0, [[USIZE]] noundef %x.1)
+#[no_mangle]
+pub fn takes_slice(x: &[i32]) -> usize {
+    x.len()
+}
diff --git a/tests/codegen-llvm/range-loop.rs b/tests/codegen-llvm/range-loop.rs
new file mode 100644
index 00000000000..b131beb40dd
--- /dev/null
+++ b/tests/codegen-llvm/range-loop.rs
@@ -0,0 +1,44 @@
+//@ ignore-std-debug-assertions
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+// Ensure that MIR optimizations have cleaned things up enough that the IR we
+// emit is good even without running the LLVM optimizations.
+
+// CHECK-NOT: define
+
+// CHECK-LABEL: define{{.+}}void @call_for_zero_to_n
+#[no_mangle]
+pub fn call_for_zero_to_n(n: u32, f: fn(u32)) {
+    // CHECK: start:
+    // CHECK-NOT: alloca
+    // CHECK: %[[IND:.+]] = alloca [4 x i8]
+    // CHECK-NEXT: %[[ALWAYS_SOME_OPTION:.+]] = alloca
+    // CHECK-NOT: alloca
+    // CHECK: store i32 0, ptr %[[IND]],
+    // CHECK: br label %[[HEAD:.+]]
+
+    // CHECK: [[HEAD]]:
+    // CHECK: %[[T1:.+]] = load i32, ptr %[[IND]],
+    // CHECK: %[[NOT_DONE:.+]] = icmp ult i32 %[[T1]], %n
+    // CHECK: br i1 %[[NOT_DONE]], label %[[BODY:.+]], label %[[BREAK:.+]]
+
+    // CHECK: [[BREAK]]:
+    // CHECK: ret void
+
+    // CHECK: [[BODY]]:
+    // CHECK: %[[T2:.+]] = load i32, ptr %[[IND]],
+    // CHECK: %[[T3:.+]] = add nuw i32 %[[T2]], 1
+    // CHECK: store i32 %[[T3]], ptr %[[IND]],
+
+    // CHECK: store i32 %[[T2]]
+    // CHECK: %[[T4:.+]] = load i32
+    // CHECK: call void %f(i32{{.+}}%[[T4]])
+
+    for i in 0..n {
+        f(i);
+    }
+}
+
+// CHECK-NOT: define
diff --git a/tests/codegen-llvm/range_to_inclusive.rs b/tests/codegen-llvm/range_to_inclusive.rs
new file mode 100644
index 00000000000..6d939f40f55
--- /dev/null
+++ b/tests/codegen-llvm/range_to_inclusive.rs
@@ -0,0 +1,28 @@
+//! Test that `RangeTo` and `RangeToInclusive` generate identical
+//! (and optimal) code; #63646
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+#![crate_type = "lib"]
+
+#[no_mangle]
+// CHECK-LABEL: range_to(
+pub fn range_to(a: i32, mut b: i32) -> i32 {
+    // CHECK: %1 = and i32 %0, %a
+    // CHECK-NEXT: ret i32 %1
+    for _ in 0..65 {
+        b &= a;
+    }
+
+    b
+}
+
+#[no_mangle]
+// CHECK-LABEL: range_to_inclusive(
+pub fn range_to_inclusive(a: i32, mut b: i32) -> i32 {
+    // CHECK: %1 = and i32 %0, %a
+    // CHECK-NEXT: ret i32 %1
+    for _ in 0..=64 {
+        b &= a;
+    }
+
+    b
+}
diff --git a/tests/codegen-llvm/refs.rs b/tests/codegen-llvm/refs.rs
new file mode 100644
index 00000000000..97c36295085
--- /dev/null
+++ b/tests/codegen-llvm/refs.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -C no-prepopulate-passes -Zmir-opt-level=0 -Copt-level=0
+
+#![crate_type = "lib"]
+
+// Hack to get the correct size for the length part in slices
+// CHECK: @helper([[USIZE:i[0-9]+]] %_1)
+#[no_mangle]
+pub fn helper(_: usize) {}
+
+// CHECK-LABEL: @ref_dst
+#[no_mangle]
+pub fn ref_dst(s: &[u8]) {
+    // We used to generate an extra alloca and memcpy to ref the dst, so check that we copy
+    // directly to the alloca for "x"
+    // CHECK: store ptr %s.0, {{.*}} %x
+    // CHECK: [[X1:%[0-9]+]] = getelementptr inbounds i8, {{.*}} %x, {{i32 4|i64 8}}
+    // CHECK: store [[USIZE]] %s.1, {{.*}} [[X1]]
+
+    let x = &*s;
+    &x; // keep variable in an alloca
+}
diff --git a/tests/codegen-llvm/reg-struct-return.rs b/tests/codegen-llvm/reg-struct-return.rs
new file mode 100644
index 00000000000..dfc9f8c519c
--- /dev/null
+++ b/tests/codegen-llvm/reg-struct-return.rs
@@ -0,0 +1,206 @@
+// Checks how `reg-struct-return` flag works with different calling conventions:
+// Return struct with 8/16/32/64 bit size will be converted into i8/i16/i32/i64
+// (like abi_return_struct_as_int target spec).
+// x86 only.
+
+//@ revisions: ENABLED DISABLED
+//@ add-core-stubs
+//@ compile-flags: --target i686-unknown-linux-gnu -Cno-prepopulate-passes -Copt-level=3
+//@ [ENABLED] compile-flags: -Zreg-struct-return
+//@ needs-llvm-components: x86
+
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+#![feature(no_core, lang_items)]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C)]
+pub struct Foo {
+    x: u32,
+    y: u32,
+}
+
+#[repr(C)]
+pub struct Foo1 {
+    x: u32,
+}
+
+#[repr(C)]
+pub struct Foo2 {
+    x: bool,
+    y: bool,
+    z: i16,
+}
+
+#[repr(C)]
+pub struct Foo3 {
+    x: i16,
+    y: bool,
+    z: bool,
+}
+
+#[repr(C)]
+pub struct Foo4 {
+    x: char,
+    y: bool,
+    z: u8,
+}
+
+#[repr(C)]
+pub struct Foo5 {
+    x: u32,
+    y: u16,
+    z: u8,
+    a: bool,
+}
+
+#[repr(C)]
+pub struct FooOversize1 {
+    x: u32,
+    y: u32,
+    z: u32,
+}
+
+#[repr(C)]
+pub struct FooOversize2 {
+    f0: u16,
+    f1: u16,
+    f2: u16,
+    f3: u16,
+    f4: u16,
+}
+
+#[repr(C)]
+pub struct FooFloat1 {
+    x: f32,
+    y: f32,
+}
+
+#[repr(C)]
+pub struct FooFloat2 {
+    x: f64,
+}
+
+#[repr(C)]
+pub struct FooFloat3 {
+    x: f32,
+}
+
+pub mod tests {
+    use {
+        Foo, Foo1, Foo2, Foo3, Foo4, Foo5, FooFloat1, FooFloat2, FooFloat3, FooOversize1,
+        FooOversize2,
+    };
+
+    // ENABLED: i64 @f1()
+    // DISABLED: void @f1(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "fastcall" fn f1() -> Foo {
+        Foo { x: 1, y: 2 }
+    }
+
+    // CHECK: { i32, i32 } @f2()
+    #[no_mangle]
+    pub extern "Rust" fn f2() -> Foo {
+        Foo { x: 1, y: 2 }
+    }
+
+    // ENABLED: i64 @f3()
+    // DISABLED: void @f3(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "C" fn f3() -> Foo {
+        Foo { x: 1, y: 2 }
+    }
+
+    // ENABLED: i64 @f4()
+    // DISABLED: void @f4(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "cdecl" fn f4() -> Foo {
+        Foo { x: 1, y: 2 }
+    }
+
+    // ENABLED: i64 @f5()
+    // DISABLED: void @f5(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "stdcall" fn f5() -> Foo {
+        Foo { x: 1, y: 2 }
+    }
+
+    // ENABLED: i64 @f6()
+    // DISABLED: void @f6(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "thiscall" fn f6() -> Foo {
+        Foo { x: 1, y: 2 }
+    }
+
+    // ENABLED: i32 @f7()
+    // DISABLED: void @f7(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "C" fn f7() -> Foo1 {
+        Foo1 { x: 1 }
+    }
+
+    // ENABLED: i32 @f8()
+    // DISABLED: void @f8(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "C" fn f8() -> Foo2 {
+        Foo2 { x: true, y: false, z: 5 }
+    }
+
+    // ENABLED: i32 @f9()
+    // DISABLED: void @f9(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "C" fn f9() -> Foo3 {
+        Foo3 { x: 5, y: false, z: true }
+    }
+
+    // ENABLED: i64 @f10()
+    // DISABLED: void @f10(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "C" fn f10() -> Foo4 {
+        Foo4 { x: 'x', y: true, z: 170 }
+    }
+
+    // ENABLED: i64 @f11()
+    // DISABLED: void @f11(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "C" fn f11() -> Foo5 {
+        Foo5 { x: 1, y: 2, z: 3, a: true }
+    }
+
+    // CHECK: void @f12(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "C" fn f12() -> FooOversize1 {
+        FooOversize1 { x: 1, y: 2, z: 3 }
+    }
+
+    // CHECK: void @f13(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "C" fn f13() -> FooOversize2 {
+        FooOversize2 { f0: 1, f1: 2, f2: 3, f3: 4, f4: 5 }
+    }
+
+    // ENABLED: i64 @f14()
+    // DISABLED: void @f14(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "C" fn f14() -> FooFloat1 {
+        FooFloat1 { x: 1.0, y: 1.0 }
+    }
+
+    // ENABLED: double @f15()
+    // DISABLED: void @f15(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "C" fn f15() -> FooFloat2 {
+        FooFloat2 { x: 1.0 }
+    }
+
+    // ENABLED: float @f16()
+    // DISABLED: void @f16(ptr {{.*}}sret
+    #[no_mangle]
+    pub extern "C" fn f16() -> FooFloat3 {
+        FooFloat3 { x: 1.0 }
+    }
+}
diff --git a/tests/codegen-llvm/regparm-inreg.rs b/tests/codegen-llvm/regparm-inreg.rs
new file mode 100644
index 00000000000..15702804dfd
--- /dev/null
+++ b/tests/codegen-llvm/regparm-inreg.rs
@@ -0,0 +1,125 @@
+// Checks how `regparm` flag works with different calling conventions:
+// marks function arguments as "inreg" like the C/C++ compilers for the platforms.
+// x86 only.
+
+//@ add-core-stubs
+//@ compile-flags: --target i686-unknown-linux-gnu -Cno-prepopulate-passes -Copt-level=3 -Ctarget-feature=+avx
+//@ needs-llvm-components: x86
+
+//@ revisions:regparm0 regparm1 regparm2 regparm3
+//@[regparm0] compile-flags: -Zregparm=0
+//@[regparm1] compile-flags: -Zregparm=1
+//@[regparm2] compile-flags: -Zregparm=2
+//@[regparm3] compile-flags: -Zregparm=3
+
+#![crate_type = "lib"]
+#![no_core]
+#![feature(no_core, lang_items, repr_simd)]
+
+extern crate minicore;
+use minicore::*;
+
+pub mod tests {
+    // regparm doesn't work for "fastcall" calling conv (only 2 inregs)
+    // CHECK: @f1(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
+    #[no_mangle]
+    pub extern "fastcall" fn f1(_: i32, _: i32, _: i32) {}
+
+    // regparm0: @f3(i32 noundef %_1, i32 noundef %_2, i32 noundef %_3)
+    // regparm1: @f3(i32 inreg noundef %_1, i32 noundef %_2, i32 noundef %_3)
+    // regparm2: @f3(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
+    // regparm3: @f3(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3)
+    #[no_mangle]
+    pub extern "C" fn f3(_: i32, _: i32, _: i32) {}
+
+    // regparm0: @f4(i32 noundef %_1, i32 noundef %_2, i32 noundef %_3)
+    // regparm1: @f4(i32 inreg noundef %_1, i32 noundef %_2, i32 noundef %_3)
+    // regparm2: @f4(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
+    // regparm3: @f4(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3)
+    #[no_mangle]
+    pub extern "cdecl" fn f4(_: i32, _: i32, _: i32) {}
+
+    // regparm0: @f5(i32 noundef %_1, i32 noundef %_2, i32 noundef %_3)
+    // regparm1: @f5(i32 inreg noundef %_1, i32 noundef %_2, i32 noundef %_3)
+    // regparm2: @f5(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
+    // regparm3: @f5(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3)
+    #[no_mangle]
+    pub extern "stdcall" fn f5(_: i32, _: i32, _: i32) {}
+
+    // regparm doesn't work for thiscall
+    // CHECK: @f6(i32 noundef %_1, i32 noundef %_2, i32 noundef %_3)
+    #[no_mangle]
+    pub extern "thiscall" fn f6(_: i32, _: i32, _: i32) {}
+
+    struct S1 {
+        x1: i32,
+    }
+    // regparm0: @f7(i32 noundef %_1, i32 noundef %_2, i32 noundef %_3, i32 noundef %_4)
+    // regparm1: @f7(i32 inreg noundef %_1, i32 noundef %_2, i32 noundef %_3, i32 noundef %_4)
+    // regparm2: @f7(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3, i32 noundef %_4)
+    // regparm3: @f7(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3,
+    // regparm3-SAME: i32 noundef %_4)
+    #[no_mangle]
+    pub extern "C" fn f7(_: i32, _: i32, _: S1, _: i32) {}
+
+    #[repr(C)]
+    struct S2 {
+        x1: i32,
+        x2: i32,
+    }
+    // regparm0: @f8(i32 noundef %_1, i32 noundef %_2, ptr {{.*}} %_3, i32 noundef %_4)
+    // regparm1: @f8(i32 inreg noundef %_1, i32 noundef %_2, ptr {{.*}} %_3, i32 noundef %_4)
+    // regparm2: @f8(i32 inreg noundef %_1, i32 inreg noundef %_2, ptr {{.*}} %_3, i32 noundef %_4)
+    // regparm3: @f8(i32 inreg noundef %_1, i32 inreg noundef %_2, ptr {{.*}} %_3,
+    // regparm3-SAME: i32 inreg noundef %_4)
+    #[no_mangle]
+    pub extern "C" fn f8(_: i32, _: i32, _: S2, _: i32) {}
+
+    // regparm0: @f9(i1 noundef zeroext %_1, i16 noundef signext %_2, i64 noundef %_3,
+    // regparm0-SAME: i128 noundef %_4)
+    // regparm1: @f9(i1 inreg noundef zeroext %_1, i16 noundef signext %_2, i64 noundef %_3,
+    // regparm1-SAME: i128 noundef %_4)
+    // regparm2: @f9(i1 inreg noundef zeroext %_1, i16 inreg noundef signext %_2, i64 noundef %_3,
+    // regparm2-SAME: i128 noundef %_4)
+    // regparm3: @f9(i1 inreg noundef zeroext %_1, i16 inreg noundef signext %_2, i64 noundef %_3,
+    // regparm3-SAME: i128 noundef %_4)
+    #[no_mangle]
+    pub extern "C" fn f9(_: bool, _: i16, _: i64, _: u128) {}
+
+    // regparm0: @f10(float noundef %_1, double noundef %_2, i1 noundef zeroext %_3,
+    // regparm0-SAME: i16 noundef signext %_4)
+    // regparm1: @f10(float noundef %_1, double noundef %_2, i1 inreg noundef zeroext %_3,
+    // regparm1-SAME: i16 noundef signext %_4)
+    // regparm2: @f10(float noundef %_1, double noundef %_2, i1 inreg noundef zeroext %_3,
+    // regparm2-SAME: i16 inreg noundef signext %_4)
+    // regparm3: @f10(float noundef %_1, double noundef %_2, i1 inreg noundef zeroext %_3,
+    // regparm3-SAME: i16 inreg noundef signext %_4)
+    #[no_mangle]
+    pub extern "C" fn f10(_: f32, _: f64, _: bool, _: i16) {}
+
+    #[allow(non_camel_case_types)]
+    #[repr(simd)]
+    pub struct __m128([f32; 4]);
+
+    // regparm0: @f11(i32 noundef %_1, <4 x float> %_2, i32 noundef %_3, i32 noundef %_4)
+    // regparm1: @f11(i32 inreg noundef %_1, <4 x float> %_2, i32 noundef %_3, i32 noundef %_4)
+    // regparm2: @f11(i32 inreg noundef %_1, <4 x float> %_2, i32 inreg noundef %_3,
+    // regparm2-SAME: i32 noundef %_4)
+    // regparm3: @f11(i32 inreg noundef %_1, <4 x float> %_2, i32 inreg noundef %_3,
+    // regparm3-SAME: i32 inreg noundef %_4)
+    #[no_mangle]
+    pub extern "C" fn f11(_: i32, _: __m128, _: i32, _: i32) {}
+
+    #[allow(non_camel_case_types)]
+    #[repr(simd)]
+    pub struct __m256([f32; 8]);
+
+    // regparm0: @f12(i32 noundef %_1, <8 x float> %_2, i32 noundef %_3, i32 noundef %_4)
+    // regparm1: @f12(i32 inreg noundef %_1, <8 x float> %_2, i32 noundef %_3, i32 noundef %_4)
+    // regparm2: @f12(i32 inreg noundef %_1, <8 x float> %_2, i32 inreg noundef %_3,
+    // regparm2-SAME: i32 noundef %_4)
+    // regparm3: @f12(i32 inreg noundef %_1, <8 x float> %_2, i32 inreg noundef %_3,
+    // regparm3-SAME: i32 inreg noundef %_4)
+    #[no_mangle]
+    pub extern "C" fn f12(_: i32, _: __m256, _: i32, _: i32) {}
+}
diff --git a/tests/codegen-llvm/remap_path_prefix/aux_mod.rs b/tests/codegen-llvm/remap_path_prefix/aux_mod.rs
new file mode 100644
index 00000000000..3217e9e51e7
--- /dev/null
+++ b/tests/codegen-llvm/remap_path_prefix/aux_mod.rs
@@ -0,0 +1,6 @@
+//@ ignore-auxiliary (used by `./main.rs`)
+
+#[inline]
+pub fn some_aux_mod_function() -> i32 {
+    1234
+}
diff --git a/tests/codegen-llvm/remap_path_prefix/auxiliary/remap_path_prefix_aux.rs b/tests/codegen-llvm/remap_path_prefix/auxiliary/remap_path_prefix_aux.rs
new file mode 100644
index 00000000000..7afc16ec72f
--- /dev/null
+++ b/tests/codegen-llvm/remap_path_prefix/auxiliary/remap_path_prefix_aux.rs
@@ -0,0 +1,8 @@
+//
+
+//@ compile-flags: -g  --remap-path-prefix={{cwd}}=/the/aux-cwd --remap-path-prefix={{src-base}}/remap_path_prefix/auxiliary=/the/aux-src
+
+#[inline]
+pub fn some_aux_function() -> i32 {
+    1234
+}
diff --git a/tests/codegen-llvm/remap_path_prefix/auxiliary/xcrate-generic.rs b/tests/codegen-llvm/remap_path_prefix/auxiliary/xcrate-generic.rs
new file mode 100644
index 00000000000..9d5cdfe063b
--- /dev/null
+++ b/tests/codegen-llvm/remap_path_prefix/auxiliary/xcrate-generic.rs
@@ -0,0 +1,8 @@
+//
+//@ compile-flags: -g  --remap-path-prefix={{cwd}}=/the/aux-cwd --remap-path-prefix={{src-base}}/remap_path_prefix/auxiliary=/the/aux-src
+
+#![crate_type = "lib"]
+
+pub fn foo<T: Default>() -> T {
+    T::default()
+}
diff --git a/tests/codegen-llvm/remap_path_prefix/issue-73167-remap-std.rs b/tests/codegen-llvm/remap_path_prefix/issue-73167-remap-std.rs
new file mode 100644
index 00000000000..eb610168dd3
--- /dev/null
+++ b/tests/codegen-llvm/remap_path_prefix/issue-73167-remap-std.rs
@@ -0,0 +1,15 @@
+//@ ignore-windows
+
+//@ compile-flags: -g  -C no-prepopulate-passes -Z simulate-remapped-rust-src-base=/rustc/xyz
+
+// Here we check that importing std will not cause real path to std source files
+// to leak. If rustc was compiled with remap-debuginfo = true, this should be
+// true automatically. If paths to std library hasn't been remapped, we use the
+// above simulate-remapped-rust-src-base option to do it temporarily
+
+// CHECK: !DIFile(filename: "{{/rustc/.*/library/std/src/panic.rs}}"
+fn main() {
+    std::thread::spawn(|| {
+        println!("hello");
+    });
+}
diff --git a/tests/codegen-llvm/remap_path_prefix/main.rs b/tests/codegen-llvm/remap_path_prefix/main.rs
new file mode 100644
index 00000000000..7d17b3b67cf
--- /dev/null
+++ b/tests/codegen-llvm/remap_path_prefix/main.rs
@@ -0,0 +1,28 @@
+//@ ignore-windows
+//
+
+//@ compile-flags: -g  -C no-prepopulate-passes --remap-path-prefix={{cwd}}=/the/cwd --remap-path-prefix={{src-base}}=/the/src -Zinline-mir=no
+//@ aux-build:remap_path_prefix_aux.rs
+
+extern crate remap_path_prefix_aux;
+
+// Here we check that submodules and include files are found using the path without
+// remapping. This test requires that rustc is called with an absolute path.
+mod aux_mod;
+include!("aux_mod.rs");
+
+// Here we check that the expansion of the file!() macro is mapped.
+// CHECK: @alloc_5761061597a97f66e13ef2ff92712c4b = private unnamed_addr constant [34 x i8] c"/the/src/remap_path_prefix/main.rs"
+pub static FILE_PATH: &'static str = file!();
+
+fn main() {
+    remap_path_prefix_aux::some_aux_function();
+    aux_mod::some_aux_mod_function();
+    some_aux_mod_function();
+}
+
+// Here we check that local debuginfo is mapped correctly.
+// CHECK: !DIFile(filename: "/the/src/remap_path_prefix/main.rs", directory: ""
+
+// And here that debuginfo from other crates are expanded to absolute paths.
+// CHECK: !DIFile(filename: "/the/aux-src/remap_path_prefix_aux.rs", directory: ""
diff --git a/tests/codegen-llvm/remap_path_prefix/xcrate-generic.rs b/tests/codegen-llvm/remap_path_prefix/xcrate-generic.rs
new file mode 100644
index 00000000000..db69b72d904
--- /dev/null
+++ b/tests/codegen-llvm/remap_path_prefix/xcrate-generic.rs
@@ -0,0 +1,14 @@
+//@ ignore-windows
+//@ compile-flags: -g -C metadata=foo -C no-prepopulate-passes
+//@ aux-build:xcrate-generic.rs
+
+#![crate_type = "lib"]
+
+extern crate xcrate_generic;
+
+pub fn foo() {
+    println!("{}", xcrate_generic::foo::<u32>());
+}
+
+// Here we check that local debuginfo is mapped correctly.
+// CHECK: !DIFile(filename: "/the/aux-src/xcrate-generic.rs", directory: ""
diff --git a/tests/codegen-llvm/repeat-operand-zero-len.rs b/tests/codegen-llvm/repeat-operand-zero-len.rs
new file mode 100644
index 00000000000..b4cec42a07c
--- /dev/null
+++ b/tests/codegen-llvm/repeat-operand-zero-len.rs
@@ -0,0 +1,28 @@
+//@ compile-flags: -Copt-level=1 -Cno-prepopulate-passes
+
+// This test is here to hit the `Rvalue::Repeat` case in `codegen_rvalue_operand`.
+// It only applies when the resulting array is a ZST, so the test is written in
+// such a way as to keep MIR optimizations from seeing that fact and removing
+// the local and statement altogether. (At the time of writing, no other codegen
+// test hit that code path, nor did a stage 2 build of the compiler.)
+
+#![crate_type = "lib"]
+
+#[repr(transparent)]
+pub struct Wrapper<T, const N: usize>([T; N]);
+
+// CHECK-LABEL: define {{.+}}do_repeat{{.+}}(i32 noundef %x)
+// CHECK-NEXT: start:
+// CHECK-NOT: alloca
+// CHECK-NEXT: ret void
+#[inline(never)]
+pub fn do_repeat<T: Copy, const N: usize>(x: T) -> Wrapper<T, N> {
+    Wrapper([x; N])
+}
+
+// CHECK-LABEL: @trigger_repeat_zero_len
+#[no_mangle]
+pub fn trigger_repeat_zero_len() -> Wrapper<u32, 0> {
+    // CHECK: call void {{.+}}do_repeat{{.+}}(i32 noundef 4)
+    do_repeat(4)
+}
diff --git a/tests/codegen-llvm/repeat-operand-zst-elem.rs b/tests/codegen-llvm/repeat-operand-zst-elem.rs
new file mode 100644
index 00000000000..c3637759afa
--- /dev/null
+++ b/tests/codegen-llvm/repeat-operand-zst-elem.rs
@@ -0,0 +1,28 @@
+//@ compile-flags: -Copt-level=1 -Cno-prepopulate-passes
+
+// This test is here to hit the `Rvalue::Repeat` case in `codegen_rvalue_operand`.
+// It only applies when the resulting array is a ZST, so the test is written in
+// such a way as to keep MIR optimizations from seeing that fact and removing
+// the local and statement altogether. (At the time of writing, no other codegen
+// test hit that code path, nor did a stage 2 build of the compiler.)
+
+#![crate_type = "lib"]
+
+#[repr(transparent)]
+pub struct Wrapper<T, const N: usize>([T; N]);
+
+// CHECK-LABEL: define {{.+}}do_repeat{{.+}}()
+// CHECK-NEXT: start:
+// CHECK-NOT: alloca
+// CHECK-NEXT: ret void
+#[inline(never)]
+pub fn do_repeat<T: Copy, const N: usize>(x: T) -> Wrapper<T, N> {
+    Wrapper([x; N])
+}
+
+// CHECK-LABEL: @trigger_repeat_zst_elem
+#[no_mangle]
+pub fn trigger_repeat_zst_elem() -> Wrapper<(), 8> {
+    // CHECK: call void {{.+}}do_repeat{{.+}}()
+    do_repeat(())
+}
diff --git a/tests/codegen-llvm/repeat-trusted-len.rs b/tests/codegen-llvm/repeat-trusted-len.rs
new file mode 100644
index 00000000000..95379535971
--- /dev/null
+++ b/tests/codegen-llvm/repeat-trusted-len.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -Copt-level=3
+//
+
+#![crate_type = "lib"]
+
+use std::iter;
+
+// CHECK-LABEL: @repeat_take_collect
+#[no_mangle]
+pub fn repeat_take_collect() -> Vec<u8> {
+    // CHECK: call void @llvm.memset.{{.+}}(ptr {{.*}}align 1{{.*}} %{{.*}}, i8 42, i{{[0-9]+}} 100000, i1 false)
+    iter::repeat(42).take(100000).collect()
+}
+
+// CHECK-LABEL: @repeat_with_take_collect
+#[no_mangle]
+pub fn repeat_with_take_collect() -> Vec<u8> {
+    // CHECK: call void @llvm.memset.{{.+}}(ptr {{.*}}align 1{{.*}} %{{.*}}, i8 13, i{{[0-9]+}} 12345, i1 false)
+    iter::repeat_with(|| 13).take(12345).collect()
+}
diff --git a/tests/codegen-llvm/repr/transparent-byval-struct-ptr.rs b/tests/codegen-llvm/repr/transparent-byval-struct-ptr.rs
new file mode 100644
index 00000000000..0918884144f
--- /dev/null
+++ b/tests/codegen-llvm/repr/transparent-byval-struct-ptr.rs
@@ -0,0 +1,111 @@
+//@ add-core-stubs
+//@ revisions: i686-linux i686-freebsd x64-linux x64-apple
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+//@[i686-linux] compile-flags: --target i686-unknown-linux-gnu
+//@[i686-linux] needs-llvm-components: x86
+//@[i686-freebsd] compile-flags: --target i686-unknown-freebsd
+//@[i686-freebsd] needs-llvm-components: x86
+//@[x64-linux] compile-flags: --target x86_64-unknown-linux-gnu
+//@[x64-linux] needs-llvm-components: x86
+//@[x64-apple] compile-flags: --target x86_64-apple-darwin
+//@[x64-apple] needs-llvm-components: x86
+
+// See ./transparent.rs
+// Some platforms pass large aggregates using immediate arrays in LLVMIR
+// Other platforms pass large aggregates using by-value struct pointer in LLVMIR
+// Yet more platforms pass large aggregates using opaque pointer in LLVMIR
+// This covers the "by-value struct pointer" case.
+
+#![feature(no_core, lang_items, transparent_unions)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+impl Copy for BigS {}
+impl Copy for BigU {}
+
+#[repr(C)]
+pub struct BigS([u32; 16]);
+
+#[repr(transparent)]
+pub struct TsBigS(BigS);
+
+#[repr(transparent)]
+pub union TuBigS {
+    field: BigS,
+}
+
+#[repr(transparent)]
+pub enum TeBigS {
+    Variant(BigS),
+}
+
+// CHECK: define{{.*}}void @test_BigS(ptr [[BIGS_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGS_RET_ATTRS2:.*]], ptr [[BIGS_ARG_ATTRS1:.*]] byval([64 x i8]) [[BIGS_ARG_ATTRS2:.*]])
+#[no_mangle]
+pub extern "C" fn test_BigS(_: BigS) -> BigS {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TsBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]] byval([64 x i8]) [[BIGS_ARG_ATTRS2:.*]])
+#[no_mangle]
+pub extern "C" fn test_TsBigS(_: TsBigS) -> TsBigS {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TuBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]] byval([64 x i8]) [[BIGS_ARG_ATTRS2:.*]])
+#[no_mangle]
+pub extern "C" fn test_TuBigS(_: TuBigS) -> TuBigS {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TeBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]] byval([64 x i8]) [[BIGS_ARG_ATTRS2]])
+#[no_mangle]
+pub extern "C" fn test_TeBigS(_: TeBigS) -> TeBigS {
+    loop {}
+}
+
+#[repr(C)]
+pub union BigU {
+    foo: [u32; 16],
+}
+
+#[repr(transparent)]
+pub struct TsBigU(BigU);
+
+#[repr(transparent)]
+pub union TuBigU {
+    field: BigU,
+}
+
+#[repr(transparent)]
+pub enum TeBigU {
+    Variant(BigU),
+}
+
+// CHECK: define{{.*}}void @test_BigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1:.*]] byval([64 x i8]) [[BIGU_ARG_ATTRS2:.*]])
+#[no_mangle]
+pub extern "C" fn test_BigU(_: BigU) -> BigU {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TsBigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]] byval([64 x i8]) [[BIGU_ARG_ATTRS2]])
+#[no_mangle]
+pub extern "C" fn test_TsBigU(_: TsBigU) -> TsBigU {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TuBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]] byval([64 x i8]) [[BIGU_ARG_ATTRS2]])
+#[no_mangle]
+pub extern "C" fn test_TuBigU(_: TuBigU) -> TuBigU {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TeBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]] byval([64 x i8]) [[BIGU_ARG_ATTRS2]])
+#[no_mangle]
+pub extern "C" fn test_TeBigU(_: TeBigU) -> TeBigU {
+    loop {}
+}
diff --git a/tests/codegen-llvm/repr/transparent-imm-array.rs b/tests/codegen-llvm/repr/transparent-imm-array.rs
new file mode 100644
index 00000000000..6dad0447784
--- /dev/null
+++ b/tests/codegen-llvm/repr/transparent-imm-array.rs
@@ -0,0 +1,116 @@
+//@ add-core-stubs
+//@ revisions: arm-linux arm-android armv7-linux armv7-android mips thumb sparc
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+//@[arm-linux] compile-flags: --target arm-unknown-linux-gnueabi
+//@[arm-linux] needs-llvm-components: arm
+//@[arm-android] compile-flags: --target arm-linux-androideabi
+//@[arm-android] needs-llvm-components: arm
+//@[armv7-linux] compile-flags: --target armv7-unknown-linux-gnueabi
+//@[armv7-linux] needs-llvm-components: arm
+//@[armv7-android] compile-flags: --target armv7-linux-androideabi
+//@[armv7-android] needs-llvm-components: arm
+//@[mips] compile-flags: --target mips-unknown-linux-gnu
+//@[mips] needs-llvm-components: mips
+//@[thumb] compile-flags: --target thumbv7neon-linux-androideabi
+//@[thumb] needs-llvm-components: arm
+//@[sparc] compile-flags: --target sparc-unknown-linux-gnu
+//@[sparc] needs-llvm-components: sparc
+
+// See ./transparent.rs
+// Some platforms pass large aggregates using immediate arrays in LLVMIR
+// Other platforms pass large aggregates using by-value struct pointer in LLVMIR
+// Yet more platforms pass large aggregates using opaque pointer in LLVMIR
+// This covers the "immediate array" case.
+
+#![feature(no_core, lang_items, transparent_unions)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+impl Copy for BigS {}
+impl Copy for BigU {}
+
+#[repr(C)]
+pub struct BigS([u32; 16]);
+
+#[repr(transparent)]
+pub struct TsBigS(BigS);
+
+#[repr(transparent)]
+pub union TuBigS {
+    field: BigS,
+}
+
+#[repr(transparent)]
+pub enum TeBigS {
+    Variant(BigS),
+}
+
+// CHECK: define void @test_BigS(ptr [[BIGS_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGS_RET_ATTRS2:.*]], [16 x i32]
+#[no_mangle]
+pub extern "C" fn test_BigS(_: BigS) -> BigS {
+    loop {}
+}
+
+// CHECK: define void @test_TsBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [16 x i32]
+#[no_mangle]
+pub extern "C" fn test_TsBigS(_: TsBigS) -> TsBigS {
+    loop {}
+}
+
+// CHECK: define void @test_TuBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [16 x i32]
+#[no_mangle]
+pub extern "C" fn test_TuBigS(_: TuBigS) -> TuBigS {
+    loop {}
+}
+
+// CHECK: define void @test_TeBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [16 x i32]
+#[no_mangle]
+pub extern "C" fn test_TeBigS(_: TeBigS) -> TeBigS {
+    loop {}
+}
+
+#[repr(C)]
+pub union BigU {
+    foo: [u32; 16],
+}
+
+#[repr(transparent)]
+pub struct TsBigU(BigU);
+
+#[repr(transparent)]
+pub union TuBigU {
+    field: BigU,
+}
+
+#[repr(transparent)]
+pub enum TeBigU {
+    Variant(BigU),
+}
+
+// CHECK: define void @test_BigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], [16 x i32]
+#[no_mangle]
+pub extern "C" fn test_BigU(_: BigU) -> BigU {
+    loop {}
+}
+
+// CHECK: define void @test_TsBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [16 x i32]
+#[no_mangle]
+pub extern "C" fn test_TsBigU(_: TsBigU) -> TsBigU {
+    loop {}
+}
+
+// CHECK: define void @test_TuBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [16 x i32]
+#[no_mangle]
+pub extern "C" fn test_TuBigU(_: TuBigU) -> TuBigU {
+    loop {}
+}
+
+// CHECK: define void @test_TeBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [16 x i32]
+#[no_mangle]
+pub extern "C" fn test_TeBigU(_: TeBigU) -> TeBigU {
+    loop {}
+}
diff --git a/tests/codegen-llvm/repr/transparent-mips64.rs b/tests/codegen-llvm/repr/transparent-mips64.rs
new file mode 100644
index 00000000000..98901350154
--- /dev/null
+++ b/tests/codegen-llvm/repr/transparent-mips64.rs
@@ -0,0 +1,103 @@
+//@ add-core-stubs
+//@ revisions: mips64 mips64el
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+//@[mips64] compile-flags: --target mips64-unknown-linux-gnuabi64
+//@[mips64] needs-llvm-components: mips
+//@[mips64el] compile-flags: --target mips64el-unknown-linux-gnuabi64
+//@[mips64el] needs-llvm-components: mips
+
+// See ./transparent.rs
+
+#![feature(no_core, lang_items, transparent_unions)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+impl Copy for BigS {}
+impl Copy for BigU {}
+
+#[repr(C)]
+pub struct BigS([u32; 16]);
+
+#[repr(transparent)]
+pub struct TsBigS(BigS);
+
+#[repr(transparent)]
+pub union TuBigS {
+    field: BigS,
+}
+
+#[repr(transparent)]
+pub enum TeBigS {
+    Variant(BigS),
+}
+
+// CHECK: define void @test_BigS(ptr [[BIGS_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGS_RET_ATTRS2:.*]], [8 x i64]
+#[no_mangle]
+pub extern "C" fn test_BigS(_: BigS) -> BigS {
+    loop {}
+}
+
+// CHECK: define void @test_TsBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [8 x i64]
+#[no_mangle]
+pub extern "C" fn test_TsBigS(_: TsBigS) -> TsBigS {
+    loop {}
+}
+
+// CHECK: define void @test_TuBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [8 x i64]
+#[no_mangle]
+pub extern "C" fn test_TuBigS(_: TuBigS) -> TuBigS {
+    loop {}
+}
+
+// CHECK: define void @test_TeBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [8 x i64]
+#[no_mangle]
+pub extern "C" fn test_TeBigS(_: TeBigS) -> TeBigS {
+    loop {}
+}
+
+#[repr(C)]
+pub union BigU {
+    foo: [u32; 16],
+}
+
+#[repr(transparent)]
+pub struct TsBigU(BigU);
+
+#[repr(transparent)]
+pub union TuBigU {
+    field: BigU,
+}
+
+#[repr(transparent)]
+pub enum TeBigU {
+    Variant(BigU),
+}
+
+// CHECK: define void @test_BigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], [8 x i64]
+#[no_mangle]
+pub extern "C" fn test_BigU(_: BigU) -> BigU {
+    loop {}
+}
+
+// CHECK: define void @test_TsBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [8 x i64]
+#[no_mangle]
+pub extern "C" fn test_TsBigU(_: TsBigU) -> TsBigU {
+    loop {}
+}
+
+// CHECK: define void @test_TuBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [8 x i64]
+#[no_mangle]
+pub extern "C" fn test_TuBigU(_: TuBigU) -> TuBigU {
+    loop {}
+}
+
+// CHECK: define void @test_TeBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [8 x i64]
+#[no_mangle]
+pub extern "C" fn test_TeBigU(_: TeBigU) -> TeBigU {
+    loop {}
+}
diff --git a/tests/codegen-llvm/repr/transparent-opaque-ptr.rs b/tests/codegen-llvm/repr/transparent-opaque-ptr.rs
new file mode 100644
index 00000000000..7911370c478
--- /dev/null
+++ b/tests/codegen-llvm/repr/transparent-opaque-ptr.rs
@@ -0,0 +1,109 @@
+//@ add-core-stubs
+//@ revisions: aarch64-linux aarch64-darwin wasm32-wasip1
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+//@[aarch64-linux] compile-flags: --target aarch64-unknown-linux-gnu
+//@[aarch64-linux] needs-llvm-components: aarch64
+//@[aarch64-darwin] compile-flags: --target aarch64-apple-darwin
+//@[aarch64-darwin] needs-llvm-components: aarch64
+//@[wasm32-wasip1] compile-flags: --target wasm32-wasip1
+//@[wasm32-wasip1] needs-llvm-components: webassembly
+
+// See ./transparent.rs
+// Some platforms pass large aggregates using immediate arrays in LLVMIR
+// Other platforms pass large aggregates using by-value struct pointer in LLVMIR
+// Yet more platforms pass large aggregates using opaque pointer in LLVMIR
+// This covers the "opaque pointer" case.
+
+#![feature(no_core, lang_items, transparent_unions)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+impl Copy for BigS {}
+impl Copy for BigU {}
+
+#[repr(C)]
+pub struct BigS([u32; 16]);
+
+#[repr(transparent)]
+pub struct TsBigS(BigS);
+
+#[repr(transparent)]
+pub union TuBigS {
+    field: BigS,
+}
+
+#[repr(transparent)]
+pub enum TeBigS {
+    Variant(BigS),
+}
+
+// CHECK: define{{.*}}void @test_BigS(ptr [[BIGS_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGS_RET_ATTRS2:.*]], ptr [[BIGS_ARG_ATTRS1:.*]])
+#[no_mangle]
+pub extern "C" fn test_BigS(_: BigS) -> BigS {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TsBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]])
+#[no_mangle]
+pub extern "C" fn test_TsBigS(_: TsBigS) -> TsBigS {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TuBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]])
+#[no_mangle]
+pub extern "C" fn test_TuBigS(_: TuBigS) -> TuBigS {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TeBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]])
+#[no_mangle]
+pub extern "C" fn test_TeBigS(_: TeBigS) -> TeBigS {
+    loop {}
+}
+
+#[repr(C)]
+pub union BigU {
+    foo: [u32; 16],
+}
+
+#[repr(transparent)]
+pub struct TsBigU(BigU);
+
+#[repr(transparent)]
+pub union TuBigU {
+    field: BigU,
+}
+
+#[repr(transparent)]
+pub enum TeBigU {
+    Variant(BigU),
+}
+
+// CHECK: define{{.*}}void @test_BigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1:.*]])
+#[no_mangle]
+pub extern "C" fn test_BigU(_: BigU) -> BigU {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TsBigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]])
+#[no_mangle]
+pub extern "C" fn test_TsBigU(_: TsBigU) -> TsBigU {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TuBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]])
+#[no_mangle]
+pub extern "C" fn test_TuBigU(_: TuBigU) -> TuBigU {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TeBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]])
+#[no_mangle]
+pub extern "C" fn test_TeBigU(_: TeBigU) -> TeBigU {
+    loop {}
+}
diff --git a/tests/codegen-llvm/repr/transparent-sparc64.rs b/tests/codegen-llvm/repr/transparent-sparc64.rs
new file mode 100644
index 00000000000..62bfc8a5fce
--- /dev/null
+++ b/tests/codegen-llvm/repr/transparent-sparc64.rs
@@ -0,0 +1,113 @@
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target sparc64-unknown-linux-gnu
+//@ needs-llvm-components: sparc
+
+// See ./transparent.rs
+
+#![feature(no_core, lang_items, transparent_unions)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+impl Copy for BigS {}
+impl Copy for BigU {}
+
+#[repr(C)]
+pub struct BigS([u32; 16]);
+
+#[repr(transparent)]
+pub struct TsBigS(BigS);
+
+#[repr(transparent)]
+pub union TuBigS {
+    field: BigS,
+}
+
+#[repr(transparent)]
+pub enum TeBigS {
+    Variant(BigS),
+}
+
+// CHECK: define{{.*}}void @test_BigS(ptr [[BIGS_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGS_RET_ATTRS2:.*]], ptr
+// CHECK-NOT: byval
+// CHECK-SAME: %{{[0-9a-z_]+}})
+#[no_mangle]
+pub extern "C" fn test_BigS(_: BigS) -> BigS {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TsBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr
+// CHECK-NOT: byval
+// CHECK-SAME: %{{[0-9a-z_]+}})
+#[no_mangle]
+pub extern "C" fn test_TsBigS(_: TsBigS) -> TsBigS {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TuBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr
+// CHECK-NOT: byval
+// CHECK-SAME: %{{[0-9a-z_]+}})
+#[no_mangle]
+pub extern "C" fn test_TuBigS(_: TuBigS) -> TuBigS {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TeBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr
+// CHECK-NOT: byval
+// CHECK-SAME: %{{[0-9a-z_]+}})
+#[no_mangle]
+pub extern "C" fn test_TeBigS(_: TeBigS) -> TeBigS {
+    loop {}
+}
+
+#[repr(C)]
+pub union BigU {
+    foo: [u32; 16],
+}
+
+#[repr(transparent)]
+pub struct TsBigU(BigU);
+
+#[repr(transparent)]
+pub union TuBigU {
+    field: BigU,
+}
+
+#[repr(transparent)]
+pub enum TeBigU {
+    Variant(BigU),
+}
+
+// CHECK: define{{.*}}void @test_BigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr
+// CHECK-NOT: byval
+// CHECK-SAME: %{{[0-9a-z_]+}})
+#[no_mangle]
+pub extern "C" fn test_BigU(_: BigU) -> BigU {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TsBigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr
+// CHECK-NOT: byval
+// CHECK-SAME: %{{[0-9a-z_]+}})
+#[no_mangle]
+pub extern "C" fn test_TsBigU(_: TsBigU) -> TsBigU {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TuBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr
+// CHECK-NOT: byval
+// CHECK-SAME: %{{[0-9a-z_]+}})
+#[no_mangle]
+pub extern "C" fn test_TuBigU(_: TuBigU) -> TuBigU {
+    loop {}
+}
+
+// CHECK: define{{.*}}void @test_TeBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr
+// CHECK-NOT: byval
+// CHECK-SAME: %{{[0-9a-z_]+}})
+#[no_mangle]
+pub extern "C" fn test_TeBigU(_: TeBigU) -> TeBigU {
+    loop {}
+}
diff --git a/tests/codegen-llvm/repr/transparent-sysv64.rs b/tests/codegen-llvm/repr/transparent-sysv64.rs
new file mode 100644
index 00000000000..3efc3f7c391
--- /dev/null
+++ b/tests/codegen-llvm/repr/transparent-sysv64.rs
@@ -0,0 +1,49 @@
+//@ add-core-stubs
+//@ revisions: linux apple win
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+//@[linux] compile-flags: --target x86_64-unknown-linux-gnu
+//@[linux] needs-llvm-components: x86
+//@[apple] compile-flags: --target x86_64-apple-darwin
+//@[apple] needs-llvm-components: x86
+//@[win] compile-flags: --target x86_64-pc-windows-msvc
+//@[win] needs-llvm-components: x86
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C)]
+pub struct Rgb8 {
+    r: u8,
+    g: u8,
+    b: u8,
+}
+
+#[repr(transparent)]
+pub struct Rgb8Wrap(Rgb8);
+
+// CHECK: i24 @test_Rgb8Wrap(i24{{( %0)?}})
+#[no_mangle]
+pub extern "sysv64" fn test_Rgb8Wrap(_: Rgb8Wrap) -> Rgb8Wrap {
+    loop {}
+}
+
+#[repr(C)]
+pub union FloatBits {
+    float: f32,
+    bits: u32,
+}
+
+#[repr(transparent)]
+pub struct SmallUnion(FloatBits);
+
+// CHECK: i32 @test_SmallUnion(i32{{( %0)?}})
+#[no_mangle]
+pub extern "sysv64" fn test_SmallUnion(_: SmallUnion) -> SmallUnion {
+    loop {}
+}
diff --git a/tests/codegen-llvm/repr/transparent.rs b/tests/codegen-llvm/repr/transparent.rs
new file mode 100644
index 00000000000..29b627462a4
--- /dev/null
+++ b/tests/codegen-llvm/repr/transparent.rs
@@ -0,0 +1,221 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+//@ ignore-riscv64 riscv64 has an i128 type used with test_Vector
+//@ ignore-s390x s390x with default march passes vector types per reference
+//@ ignore-loongarch64 see codegen/loongarch-abi for loongarch function call tests
+
+// This codegen test embeds assumptions about how certain "C" psABIs are handled
+// so it doesn't apply to all architectures or even all OS
+// For RISCV: see codegen/riscv-abi
+// For LoongArch: see codegen/loongarch-abi
+
+#![crate_type = "lib"]
+#![feature(repr_simd, transparent_unions, arm_target_feature, mips_target_feature)]
+
+use std::marker::PhantomData;
+
+#[derive(Copy, Clone)]
+pub struct Zst1;
+#[derive(Copy, Clone)]
+pub struct Zst2(());
+
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct F32(f32);
+
+// CHECK: define{{.*}}float @test_F32(float noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_F32(_: F32) -> F32 {
+    loop {}
+}
+
+#[repr(transparent)]
+pub struct Ptr(*mut u8);
+
+// CHECK: define{{.*}}ptr @test_Ptr(ptr noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_Ptr(_: Ptr) -> Ptr {
+    loop {}
+}
+
+#[repr(transparent)]
+pub struct WithZst(u64, Zst1);
+
+// CHECK: define{{.*}}i64 @test_WithZst(i64 noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_WithZst(_: WithZst) -> WithZst {
+    loop {}
+}
+
+#[repr(transparent)]
+pub struct WithZeroSizedArray(*const f32, [i8; 0]);
+
+// CHECK: define{{.*}}ptr @test_WithZeroSizedArray(ptr noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_WithZeroSizedArray(_: WithZeroSizedArray) -> WithZeroSizedArray {
+    loop {}
+}
+
+#[repr(transparent)]
+pub struct Generic<T>(T);
+
+// CHECK: define{{.*}}double @test_Generic(double noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_Generic(_: Generic<f64>) -> Generic<f64> {
+    loop {}
+}
+
+#[repr(transparent)]
+pub struct GenericPlusZst<T>(T, Zst2);
+
+#[repr(u8)]
+pub enum Bool {
+    True,
+    False,
+    FileNotFound,
+}
+
+// CHECK: define{{( dso_local)?}} noundef{{( zeroext)?( range\(i8 0, 3\))?}} i8 @test_Gpz(i8 noundef{{( zeroext)?( range\(i8 0, 3\))?}} %_1)
+#[no_mangle]
+pub extern "C" fn test_Gpz(_: GenericPlusZst<Bool>) -> GenericPlusZst<Bool> {
+    loop {}
+}
+
+#[repr(transparent)]
+pub struct LifetimePhantom<'a, T: 'a>(*const T, PhantomData<&'a T>);
+
+// CHECK: define{{.*}}ptr @test_LifetimePhantom(ptr noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_LifetimePhantom(_: LifetimePhantom<i16>) -> LifetimePhantom<i16> {
+    loop {}
+}
+
+// This works despite current alignment resrictions because PhantomData is always align(1)
+#[repr(transparent)]
+pub struct UnitPhantom<T, U> {
+    val: T,
+    unit: PhantomData<U>,
+}
+
+pub struct Px;
+
+// CHECK: define{{.*}}float @test_UnitPhantom(float noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_UnitPhantom(_: UnitPhantom<f32, Px>) -> UnitPhantom<f32, Px> {
+    loop {}
+}
+
+#[repr(transparent)]
+pub struct TwoZsts(Zst1, i8, Zst2);
+
+// CHECK: define{{( dso_local)?}} noundef{{( signext)?}} i8 @test_TwoZsts(i8 noundef{{( signext)?}} %_1)
+#[no_mangle]
+pub extern "C" fn test_TwoZsts(_: TwoZsts) -> TwoZsts {
+    loop {}
+}
+
+#[repr(transparent)]
+pub struct Nested1(Zst2, Generic<f64>);
+
+// CHECK: define{{.*}}double @test_Nested1(double noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_Nested1(_: Nested1) -> Nested1 {
+    loop {}
+}
+
+#[repr(transparent)]
+pub struct Nested2(Nested1, Zst1);
+
+// CHECK: define{{.*}}double @test_Nested2(double noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_Nested2(_: Nested2) -> Nested2 {
+    loop {}
+}
+
+#[repr(simd)]
+struct f32x4([f32; 4]);
+
+#[repr(transparent)]
+pub struct Vector(f32x4);
+
+// CHECK: define{{.*}}<4 x float> @test_Vector(<4 x float> %_1)
+#[no_mangle]
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+pub extern "C" fn test_Vector(_: Vector) -> Vector {
+    loop {}
+}
+
+trait Mirror {
+    type It: ?Sized;
+}
+impl<T: ?Sized> Mirror for T {
+    type It = Self;
+}
+
+#[repr(transparent)]
+pub struct StructWithProjection(<f32 as Mirror>::It);
+
+// CHECK: define{{.*}}float @test_Projection(float noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_Projection(_: StructWithProjection) -> StructWithProjection {
+    loop {}
+}
+
+#[repr(transparent)]
+pub enum EnumF32 {
+    Variant(F32),
+}
+
+// CHECK: define{{.*}}float @test_EnumF32(float noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_EnumF32(_: EnumF32) -> EnumF32 {
+    loop {}
+}
+
+#[repr(transparent)]
+pub enum EnumF32WithZsts {
+    Variant(Zst1, F32, Zst2),
+}
+
+// CHECK: define{{.*}}float @test_EnumF32WithZsts(float noundef %_1)
+#[no_mangle]
+pub extern "C" fn test_EnumF32WithZsts(_: EnumF32WithZsts) -> EnumF32WithZsts {
+    loop {}
+}
+
+#[repr(transparent)]
+pub union UnionF32 {
+    field: F32,
+}
+
+// CHECK: define{{.*}} float @test_UnionF32(float %_1)
+#[no_mangle]
+pub extern "C" fn test_UnionF32(_: UnionF32) -> UnionF32 {
+    loop {}
+}
+
+#[repr(transparent)]
+pub union UnionF32WithZsts {
+    zst1: Zst1,
+    field: F32,
+    zst2: Zst2,
+}
+
+// CHECK: define{{.*}}float @test_UnionF32WithZsts(float %_1)
+#[no_mangle]
+pub extern "C" fn test_UnionF32WithZsts(_: UnionF32WithZsts) -> UnionF32WithZsts {
+    loop {}
+}
+
+// All that remains to be tested are aggregates. They are tested in separate files called
+// transparent-*.rs  with `only-*` or `ignore-*` directives, because the expected LLVM IR
+// function signatures vary so much that it's not reasonably possible to cover all of them with a
+// single CHECK line.
+//
+// You may be wondering why we don't just compare the return types and argument types for equality
+// with FileCheck regex captures. Well, rustc doesn't perform newtype unwrapping on newtypes
+// containing aggregates. This is OK on all ABIs we support, but because LLVM has not gotten rid of
+// pointee types yet, the IR function signature will be syntactically different (%Foo* vs
+// %FooWrapper*).
diff --git a/tests/codegen-llvm/retpoline.rs b/tests/codegen-llvm/retpoline.rs
new file mode 100644
index 00000000000..915c2c3d797
--- /dev/null
+++ b/tests/codegen-llvm/retpoline.rs
@@ -0,0 +1,27 @@
+// ignore-tidy-linelength
+// Test that the
+// `retpoline-external-thunk`, `retpoline-indirect-branches`, `retpoline-indirect-calls`
+// target features are (not) emitted when the `retpoline/retpoline-external-thunk` flag is (not) set.
+
+//@ add-core-stubs
+//@ revisions: disabled enabled_retpoline enabled_retpoline_external_thunk
+//@ needs-llvm-components: x86
+//@ compile-flags: --target x86_64-unknown-linux-gnu
+//@ [enabled_retpoline] compile-flags: -Zretpoline
+//@ [enabled_retpoline_external_thunk] compile-flags: -Zretpoline-external-thunk
+#![crate_type = "lib"]
+#![feature(no_core)]
+#![no_core]
+extern crate minicore;
+
+#[no_mangle]
+pub fn foo() {
+    // CHECK: @foo() unnamed_addr #0
+
+    // disabled-NOT: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+retpoline-external-thunk{{.*}} }
+    // disabled-NOT: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+retpoline-indirect-branches{{.*}} }
+    // disabled-NOT: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+retpoline-indirect-calls{{.*}} }
+
+    // enabled_retpoline: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+retpoline-indirect-branches,+retpoline-indirect-calls{{.*}} }
+    // enabled_retpoline_external_thunk: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+retpoline-external-thunk,+retpoline-indirect-branches,+retpoline-indirect-calls{{.*}} }
+}
diff --git a/tests/codegen-llvm/riscv-abi/call-llvm-intrinsics.rs b/tests/codegen-llvm/riscv-abi/call-llvm-intrinsics.rs
new file mode 100644
index 00000000000..e72a649a530
--- /dev/null
+++ b/tests/codegen-llvm/riscv-abi/call-llvm-intrinsics.rs
@@ -0,0 +1,30 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+//@ only-riscv64
+
+#![feature(link_llvm_intrinsics)]
+#![crate_type = "lib"]
+
+struct A;
+
+impl Drop for A {
+    fn drop(&mut self) {
+        println!("A");
+    }
+}
+
+extern "C" {
+    #[link_name = "llvm.sqrt.f32"]
+    fn sqrt(x: f32) -> f32;
+}
+
+pub fn do_call() {
+    let _a = A;
+
+    unsafe {
+        // Ensure that we `call` LLVM intrinsics instead of trying to `invoke` them
+        // CHECK: store float 4.000000e+00, ptr %{{.}}, align 4
+        // CHECK: call float @llvm.sqrt.f32(float %{{.}}
+        sqrt(4.0);
+    }
+}
diff --git a/tests/codegen-llvm/riscv-abi/cast-local-large-enough.rs b/tests/codegen-llvm/riscv-abi/cast-local-large-enough.rs
new file mode 100644
index 00000000000..9d21d73b459
--- /dev/null
+++ b/tests/codegen-llvm/riscv-abi/cast-local-large-enough.rs
@@ -0,0 +1,44 @@
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=0 -Cdebuginfo=0 --target riscv64gc-unknown-linux-gnu
+//@ needs-llvm-components: riscv
+
+#![feature(no_core, lang_items)]
+#![no_std]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C, align(64))]
+struct Aligned(f64);
+
+#[repr(C, align(64))]
+struct AlignedPair(f32, f64);
+
+impl Copy for Aligned {}
+impl Copy for AlignedPair {}
+
+// CHECK-LABEL: define double @read_aligned
+#[unsafe(no_mangle)]
+pub extern "C" fn read_aligned(x: &Aligned) -> Aligned {
+    // CHECK: %[[TEMP:.*]] = alloca [64 x i8], align 64
+    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 64 %[[TEMP]], ptr align 64 %[[PTR:.*]], i64 64, i1 false)
+    // CHECK-NEXT: %[[RES:.*]] = load double, ptr %[[TEMP]], align 64
+    // CHECK-NEXT: ret double %[[RES]]
+    *x
+}
+
+// CHECK-LABEL: define { float, double } @read_aligned_pair
+#[unsafe(no_mangle)]
+pub extern "C" fn read_aligned_pair(x: &AlignedPair) -> AlignedPair {
+    // CHECK: %[[TEMP:.*]] = alloca [64 x i8], align 64
+    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 64 %[[TEMP]], ptr align 64 %[[PTR:.*]], i64 64, i1 false)
+    // CHECK-NEXT: %[[FIRST:.*]] = load float, ptr %[[TEMP]], align 64
+    // CHECK-NEXT: %[[SECOND_PTR:.*]] = getelementptr inbounds i8, ptr %[[TEMP]], i64 8
+    // CHECK-NEXT: %[[SECOND:.*]] = load double, ptr %[[SECOND_PTR]], align 8
+    // CHECK-NEXT: %[[RES1:.*]] = insertvalue { float, double } poison, float %[[FIRST]], 0
+    // CHECK-NEXT: %[[RES2:.*]] = insertvalue { float, double } %[[RES1]], double %[[SECOND]], 1
+    // CHECK-NEXT: ret { float, double } %[[RES2]]
+    *x
+}
diff --git a/tests/codegen-llvm/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs b/tests/codegen-llvm/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
new file mode 100644
index 00000000000..df99f6969fc
--- /dev/null
+++ b/tests/codegen-llvm/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
@@ -0,0 +1,176 @@
+//@ add-core-stubs
+//@ compile-flags: --target riscv64gc-unknown-linux-gnu -Copt-level=3 -C no-prepopulate-passes -C panic=abort
+//@ needs-llvm-components: riscv
+
+#![crate_type = "lib"]
+#![no_core]
+#![feature(no_core, lang_items)]
+#![allow(improper_ctypes)]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: define void @f_void()
+#[no_mangle]
+pub extern "C" fn f_void() {}
+
+// CHECK: define noundef zeroext i1 @f_scalar_0(i1 noundef zeroext %a)
+#[no_mangle]
+pub extern "C" fn f_scalar_0(a: bool) -> bool {
+    a
+}
+
+// CHECK: define noundef signext i8 @f_scalar_1(i8 noundef signext %x)
+#[no_mangle]
+pub extern "C" fn f_scalar_1(x: i8) -> i8 {
+    x
+}
+
+// CHECK: define noundef zeroext i8 @f_scalar_2(i8 noundef zeroext %x)
+#[no_mangle]
+pub extern "C" fn f_scalar_2(x: u8) -> u8 {
+    x
+}
+
+// CHECK: define noundef signext i32 @f_scalar_3(i32 noundef signext %x)
+#[no_mangle]
+pub extern "C" fn f_scalar_3(x: i32) -> u32 {
+    x as u32
+}
+
+// CHECK: define noundef i64 @f_scalar_4(i64 noundef %x)
+#[no_mangle]
+pub extern "C" fn f_scalar_4(x: i64) -> i64 {
+    x
+}
+
+// CHECK: define float @f_fp_scalar_1(float %0)
+#[no_mangle]
+pub extern "C" fn f_fp_scalar_1(x: f32) -> f32 {
+    x
+}
+// CHECK: define double @f_fp_scalar_2(double %0)
+#[no_mangle]
+pub extern "C" fn f_fp_scalar_2(x: f64) -> f64 {
+    x
+}
+
+#[repr(C)]
+pub struct Empty {}
+
+// CHECK: define void @f_agg_empty_struct()
+#[no_mangle]
+pub extern "C" fn f_agg_empty_struct(e: Empty) -> Empty {
+    e
+}
+
+#[repr(C)]
+pub struct Tiny {
+    a: u16,
+    b: u16,
+    c: u16,
+    d: u16,
+}
+
+// CHECK: define void @f_agg_tiny(i64 %0)
+#[no_mangle]
+pub extern "C" fn f_agg_tiny(mut e: Tiny) {}
+
+// CHECK: define i64 @f_agg_tiny_ret()
+#[no_mangle]
+pub extern "C" fn f_agg_tiny_ret() -> Tiny {
+    Tiny { a: 1, b: 2, c: 3, d: 4 }
+}
+
+#[repr(C)]
+pub struct Small {
+    a: i64,
+    b: *mut i64,
+}
+
+// CHECK: define void @f_agg_small([2 x i64] %0)
+#[no_mangle]
+pub extern "C" fn f_agg_small(mut x: Small) {}
+
+// CHECK: define [2 x i64] @f_agg_small_ret()
+#[no_mangle]
+pub extern "C" fn f_agg_small_ret() -> Small {
+    Small { a: 1, b: 0 as *mut _ }
+}
+
+#[repr(C)]
+pub struct SmallAligned {
+    a: i128,
+}
+
+// CHECK: define void @f_agg_small_aligned(i128 %0)
+#[no_mangle]
+pub extern "C" fn f_agg_small_aligned(mut x: SmallAligned) {}
+
+#[repr(C)]
+pub struct Large {
+    a: i64,
+    b: i64,
+    c: i64,
+    d: i64,
+}
+
+// CHECK: define void @f_agg_large(ptr {{.*}}%x)
+#[no_mangle]
+pub extern "C" fn f_agg_large(mut x: Large) {}
+
+// CHECK: define void @f_agg_large_ret(ptr {{.*}}sret{{.*}}, i32 noundef signext %i, i8 noundef signext %j)
+#[no_mangle]
+pub extern "C" fn f_agg_large_ret(i: i32, j: i8) -> Large {
+    Large { a: 1, b: 2, c: 3, d: 4 }
+}
+
+// CHECK: define void @f_scalar_stack_1(i64 %0, [2 x i64] %1, i128 %2, ptr {{.*}}%d, i8 noundef zeroext %e, i8 noundef signext %f, i8 noundef %g, i8 noundef %h)
+#[no_mangle]
+pub extern "C" fn f_scalar_stack_1(
+    a: Tiny,
+    b: Small,
+    c: SmallAligned,
+    d: Large,
+    e: u8,
+    f: i8,
+    g: u8,
+    h: i8,
+) {
+}
+
+// CHECK: define void @f_scalar_stack_2(ptr {{.*}}sret{{.*}} %_0, i64 noundef %a, i128 %0, i128 %1, i64 noundef %d, i8 noundef zeroext %e, i8 noundef %f, i8 noundef %g)
+#[no_mangle]
+pub extern "C" fn f_scalar_stack_2(
+    a: u64,
+    b: SmallAligned,
+    c: SmallAligned,
+    d: u64,
+    e: u8,
+    f: i8,
+    g: u8,
+) -> Large {
+    Large { a: a as i64, b: e as i64, c: f as i64, d: g as i64 }
+}
+
+extern "C" {
+    fn f_va_callee(_: i32, ...) -> i32;
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn f_va_caller() {
+    // CHECK: call noundef signext i32 (i32, ...) @f_va_callee(i32 noundef signext 1, i32 noundef signext 2, i64 noundef 3, double {{.*}}, double {{.*}}, i64 {{.*}}, [2 x i64] {{.*}}, i128 {{.*}}, ptr {{.*}})
+    f_va_callee(
+        1,
+        2i32,
+        3i64,
+        4.0f64,
+        5.0f64,
+        Tiny { a: 1, b: 2, c: 3, d: 4 },
+        Small { a: 10, b: 0 as *mut _ },
+        SmallAligned { a: 11 },
+        Large { a: 12, b: 13, c: 14, d: 15 },
+    );
+    // CHECK: call noundef signext i32 (i32, ...) @f_va_callee(i32 noundef signext 1, i32 noundef signext 2, i32 noundef signext 3, i32 noundef signext 4, i128 {{.*}}, i32 noundef signext 6, i32 noundef signext 7, i32 noundef 8, i32 noundef 9)
+    f_va_callee(1, 2i32, 3i32, 4i32, SmallAligned { a: 5 }, 6i32, 7i32, 8i32, 9i32);
+}
diff --git a/tests/codegen-llvm/riscv-abi/riscv64-lp64d-abi.rs b/tests/codegen-llvm/riscv-abi/riscv64-lp64d-abi.rs
new file mode 100644
index 00000000000..d768ab9381a
--- /dev/null
+++ b/tests/codegen-llvm/riscv-abi/riscv64-lp64d-abi.rs
@@ -0,0 +1,299 @@
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target riscv64gc-unknown-linux-gnu
+//@ needs-llvm-components: riscv
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: define void @f_fpr_tracking(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, i8 noundef zeroext %i)
+#[no_mangle]
+pub extern "C" fn f_fpr_tracking(
+    a: f64,
+    b: f64,
+    c: f64,
+    d: f64,
+    e: f64,
+    f: f64,
+    g: f64,
+    h: f64,
+    i: u8,
+) {
+}
+
+#[repr(C)]
+pub struct Double {
+    f: f64,
+}
+
+#[repr(C)]
+pub struct DoubleDouble {
+    f: f64,
+    g: f64,
+}
+
+#[repr(C)]
+pub struct DoubleFloat {
+    f: f64,
+    g: f32,
+}
+
+// CHECK: define void @f_double_s_arg(double %0)
+#[no_mangle]
+pub extern "C" fn f_double_s_arg(a: Double) {}
+
+// CHECK: define double @f_ret_double_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_s() -> Double {
+    Double { f: 1. }
+}
+
+// CHECK: define void @f_double_double_s_arg({ double, double } %0)
+#[no_mangle]
+pub extern "C" fn f_double_double_s_arg(a: DoubleDouble) {}
+
+// CHECK: define { double, double } @f_ret_double_double_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_double_s() -> DoubleDouble {
+    DoubleDouble { f: 1., g: 2. }
+}
+
+// CHECK: define void @f_double_float_s_arg({ double, float } %0)
+#[no_mangle]
+pub extern "C" fn f_double_float_s_arg(a: DoubleFloat) {}
+
+// CHECK: define { double, float } @f_ret_double_float_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_float_s() -> DoubleFloat {
+    DoubleFloat { f: 1., g: 2. }
+}
+
+// CHECK: define void @f_double_double_s_arg_insufficient_fprs(double %0, double %1, double %2, double %3, double %4, double %5, double %6, [2 x i64] %7)
+#[no_mangle]
+pub extern "C" fn f_double_double_s_arg_insufficient_fprs(
+    a: f64,
+    b: f64,
+    c: f64,
+    d: f64,
+    e: f64,
+    f: f64,
+    g: f64,
+    h: DoubleDouble,
+) {
+}
+
+#[repr(C)]
+pub struct DoubleInt8 {
+    f: f64,
+    i: i8,
+}
+
+#[repr(C)]
+pub struct DoubleUInt8 {
+    f: f64,
+    i: u8,
+}
+
+#[repr(C)]
+pub struct DoubleInt32 {
+    f: f64,
+    i: i32,
+}
+
+#[repr(C)]
+pub struct DoubleInt64 {
+    f: f64,
+    i: i64,
+}
+
+// CHECK: define void @f_double_int8_s_arg({ double, i8 } %0)
+#[no_mangle]
+pub extern "C" fn f_double_int8_s_arg(a: DoubleInt8) {}
+
+// CHECK: define { double, i8 } @f_ret_double_int8_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_int8_s() -> DoubleInt8 {
+    DoubleInt8 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_double_int32_s_arg({ double, i32 } %0)
+#[no_mangle]
+pub extern "C" fn f_double_int32_s_arg(a: DoubleInt32) {}
+
+// CHECK: define { double, i32 } @f_ret_double_int32_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_int32_s() -> DoubleInt32 {
+    DoubleInt32 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_double_uint8_s_arg({ double, i8 } %0)
+#[no_mangle]
+pub extern "C" fn f_double_uint8_s_arg(a: DoubleUInt8) {}
+
+// CHECK: define { double, i8 } @f_ret_double_uint8_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_uint8_s() -> DoubleUInt8 {
+    DoubleUInt8 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_double_int64_s_arg({ double, i64 } %0)
+#[no_mangle]
+pub extern "C" fn f_double_int64_s_arg(a: DoubleInt64) {}
+
+// CHECK: define { double, i64 } @f_ret_double_int64_s()
+#[no_mangle]
+pub extern "C" fn f_ret_double_int64_s() -> DoubleInt64 {
+    DoubleInt64 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_double_int8_s_arg_insufficient_gprs(i32 noundef signext %a, i32 noundef signext %b, i32 noundef signext %c, i32 noundef signext %d, i32 noundef signext %e, i32 noundef signext %f, i32 noundef signext %g, i32 noundef signext %h, [2 x i64] %0)
+#[no_mangle]
+pub extern "C" fn f_double_int8_s_arg_insufficient_gprs(
+    a: i32,
+    b: i32,
+    c: i32,
+    d: i32,
+    e: i32,
+    f: i32,
+    g: i32,
+    h: i32,
+    i: DoubleInt8,
+) {
+}
+
+// CHECK: define void @f_struct_double_int8_insufficient_fprs(float %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, [2 x i64] %8)
+#[no_mangle]
+pub extern "C" fn f_struct_double_int8_insufficient_fprs(
+    a: f32,
+    b: f64,
+    c: f64,
+    d: f64,
+    e: f64,
+    f: f64,
+    g: f64,
+    h: f64,
+    i: DoubleInt8,
+) {
+}
+
+#[repr(C)]
+pub struct DoubleArr1 {
+    a: [f64; 1],
+}
+
+// CHECK: define void @f_doublearr1_s_arg(double %0)
+#[no_mangle]
+pub extern "C" fn f_doublearr1_s_arg(a: DoubleArr1) {}
+
+// CHECK: define double @f_ret_doublearr1_s()
+#[no_mangle]
+pub extern "C" fn f_ret_doublearr1_s() -> DoubleArr1 {
+    DoubleArr1 { a: [1.] }
+}
+
+#[repr(C)]
+pub struct DoubleArr2 {
+    a: [f64; 2],
+}
+
+// CHECK: define void @f_doublearr2_s_arg({ double, double } %0)
+#[no_mangle]
+pub extern "C" fn f_doublearr2_s_arg(a: DoubleArr2) {}
+
+// CHECK: define { double, double } @f_ret_doublearr2_s()
+#[no_mangle]
+pub extern "C" fn f_ret_doublearr2_s() -> DoubleArr2 {
+    DoubleArr2 { a: [1., 2.] }
+}
+
+#[repr(C)]
+pub struct Tricky1 {
+    f: [f64; 1],
+}
+
+#[repr(C)]
+pub struct DoubleArr2Tricky1 {
+    g: [Tricky1; 2],
+}
+
+// CHECK: define void @f_doublearr2_tricky1_s_arg({ double, double } %0)
+#[no_mangle]
+pub extern "C" fn f_doublearr2_tricky1_s_arg(a: DoubleArr2Tricky1) {}
+
+// CHECK: define { double, double } @f_ret_doublearr2_tricky1_s()
+#[no_mangle]
+pub extern "C" fn f_ret_doublearr2_tricky1_s() -> DoubleArr2Tricky1 {
+    DoubleArr2Tricky1 { g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
+}
+
+#[repr(C)]
+pub struct EmptyStruct {}
+
+#[repr(C)]
+pub struct DoubleArr2Tricky2 {
+    s: EmptyStruct,
+    g: [Tricky1; 2],
+}
+
+// CHECK: define void @f_doublearr2_tricky2_s_arg({ double, double } %0)
+#[no_mangle]
+pub extern "C" fn f_doublearr2_tricky2_s_arg(a: DoubleArr2Tricky2) {}
+
+// CHECK: define { double, double } @f_ret_doublearr2_tricky2_s()
+#[no_mangle]
+pub extern "C" fn f_ret_doublearr2_tricky2_s() -> DoubleArr2Tricky2 {
+    DoubleArr2Tricky2 { s: EmptyStruct {}, g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
+}
+
+#[repr(C)]
+pub struct IntDoubleInt {
+    a: i32,
+    b: f64,
+    c: i32,
+}
+
+// CHECK: define void @f_int_double_int_s_arg(ptr {{.*}} %a)
+#[no_mangle]
+pub extern "C" fn f_int_double_int_s_arg(a: IntDoubleInt) {}
+
+// CHECK: define void @f_ret_int_double_int_s(ptr {{.*}} sret([24 x i8]) align 8 {{.*}}dereferenceable(24) %_0)
+#[no_mangle]
+pub extern "C" fn f_ret_int_double_int_s() -> IntDoubleInt {
+    IntDoubleInt { a: 1, b: 2., c: 3 }
+}
+
+#[repr(C)]
+pub struct CharCharDouble {
+    a: u8,
+    b: u8,
+    c: f64,
+}
+
+// CHECK: define void @f_char_char_double_s_arg([2 x i64] %0)
+#[no_mangle]
+pub extern "C" fn f_char_char_double_s_arg(a: CharCharDouble) {}
+
+// CHECK: define [2 x i64] @f_ret_char_char_double_s()
+#[no_mangle]
+pub extern "C" fn f_ret_char_char_double_s() -> CharCharDouble {
+    CharCharDouble { a: 1, b: 2, c: 3. }
+}
+
+#[repr(C)]
+pub union DoubleU {
+    a: f64,
+}
+
+// CHECK: define void @f_double_u_arg(i64 %0)
+#[no_mangle]
+pub extern "C" fn f_double_u_arg(a: DoubleU) {}
+
+// CHECK: define i64 @f_ret_double_u()
+#[no_mangle]
+pub extern "C" fn f_ret_double_u() -> DoubleU {
+    unsafe { DoubleU { a: 1. } }
+}
diff --git a/tests/codegen-llvm/riscv-abi/riscv64-lp64f-lp64d-abi.rs b/tests/codegen-llvm/riscv-abi/riscv64-lp64f-lp64d-abi.rs
new file mode 100644
index 00000000000..361f0322690
--- /dev/null
+++ b/tests/codegen-llvm/riscv-abi/riscv64-lp64f-lp64d-abi.rs
@@ -0,0 +1,283 @@
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target riscv64gc-unknown-linux-gnu
+//@ needs-llvm-components: riscv
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: define void @f_fpr_tracking(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, i8 noundef zeroext %i)
+#[no_mangle]
+pub extern "C" fn f_fpr_tracking(
+    a: f32,
+    b: f32,
+    c: f32,
+    d: f32,
+    e: f32,
+    f: f32,
+    g: f32,
+    h: f32,
+    i: u8,
+) {
+}
+
+#[repr(C)]
+pub struct Float {
+    f: f32,
+}
+
+#[repr(C)]
+pub struct FloatFloat {
+    f: f32,
+    g: f32,
+}
+
+// CHECK: define void @f_float_s_arg(float %0)
+#[no_mangle]
+pub extern "C" fn f_float_s_arg(a: Float) {}
+
+// CHECK: define float @f_ret_float_s()
+#[no_mangle]
+pub extern "C" fn f_ret_float_s() -> Float {
+    Float { f: 1. }
+}
+
+// CHECK: define void @f_float_float_s_arg({ float, float } %0)
+#[no_mangle]
+pub extern "C" fn f_float_float_s_arg(a: FloatFloat) {}
+
+// CHECK: define { float, float } @f_ret_float_float_s()
+#[no_mangle]
+pub extern "C" fn f_ret_float_float_s() -> FloatFloat {
+    FloatFloat { f: 1., g: 2. }
+}
+
+// CHECK: define void @f_float_float_s_arg_insufficient_fprs(float %0, float %1, float %2, float %3, float %4, float %5, float %6, i64 %7)
+#[no_mangle]
+pub extern "C" fn f_float_float_s_arg_insufficient_fprs(
+    a: f32,
+    b: f32,
+    c: f32,
+    d: f32,
+    e: f32,
+    f: f32,
+    g: f32,
+    h: FloatFloat,
+) {
+}
+
+#[repr(C)]
+pub struct FloatInt8 {
+    f: f32,
+    i: i8,
+}
+
+#[repr(C)]
+pub struct FloatUInt8 {
+    f: f32,
+    i: u8,
+}
+
+#[repr(C)]
+pub struct FloatInt32 {
+    f: f32,
+    i: i32,
+}
+
+#[repr(C)]
+pub struct FloatInt64 {
+    f: f32,
+    i: i64,
+}
+
+// CHECK: define void @f_float_int8_s_arg({ float, i8 } %0)
+#[no_mangle]
+pub extern "C" fn f_float_int8_s_arg(a: FloatInt8) {}
+
+// CHECK: define { float, i8 } @f_ret_float_int8_s()
+#[no_mangle]
+pub extern "C" fn f_ret_float_int8_s() -> FloatInt8 {
+    FloatInt8 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_float_int32_s_arg({ float, i32 } %0)
+#[no_mangle]
+pub extern "C" fn f_float_int32_s_arg(a: FloatInt32) {}
+
+// CHECK: define { float, i32 } @f_ret_float_int32_s()
+#[no_mangle]
+pub extern "C" fn f_ret_float_int32_s() -> FloatInt32 {
+    FloatInt32 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_float_uint8_s_arg({ float, i8 } %0)
+#[no_mangle]
+pub extern "C" fn f_float_uint8_s_arg(a: FloatUInt8) {}
+
+// CHECK: define { float, i8 } @f_ret_float_uint8_s()
+#[no_mangle]
+pub extern "C" fn f_ret_float_uint8_s() -> FloatUInt8 {
+    FloatUInt8 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_float_int64_s_arg({ float, i64 } %0)
+#[no_mangle]
+pub extern "C" fn f_float_int64_s_arg(a: FloatInt64) {}
+
+// CHECK: define { float, i64 } @f_ret_float_int64_s()
+#[no_mangle]
+pub extern "C" fn f_ret_float_int64_s() -> FloatInt64 {
+    FloatInt64 { f: 1., i: 2 }
+}
+
+// CHECK: define void @f_float_int8_s_arg_insufficient_gprs(i32 noundef signext %a, i32 noundef signext %b, i32 noundef signext %c, i32 noundef signext %d, i32 noundef signext %e, i32 noundef signext %f, i32 noundef signext %g, i32 noundef signext %h, i64 %0)
+#[no_mangle]
+pub extern "C" fn f_float_int8_s_arg_insufficient_gprs(
+    a: i32,
+    b: i32,
+    c: i32,
+    d: i32,
+    e: i32,
+    f: i32,
+    g: i32,
+    h: i32,
+    i: FloatInt8,
+) {
+}
+
+// CHECK: define void @f_struct_float_int8_insufficient_fprs(float %0, float %1, float %2,  float %3, float %4, float %5, float %6, float %7, i64 %8)
+#[no_mangle]
+pub extern "C" fn f_struct_float_int8_insufficient_fprs(
+    a: f32,
+    b: f32,
+    c: f32,
+    d: f32,
+    e: f32,
+    f: f32,
+    g: f32,
+    h: f32,
+    i: FloatInt8,
+) {
+}
+
+#[repr(C)]
+pub struct FloatArr1 {
+    a: [f32; 1],
+}
+
+// CHECK: define void @f_floatarr1_s_arg(float %0)
+#[no_mangle]
+pub extern "C" fn f_floatarr1_s_arg(a: FloatArr1) {}
+
+// CHECK: define float @f_ret_floatarr1_s()
+#[no_mangle]
+pub extern "C" fn f_ret_floatarr1_s() -> FloatArr1 {
+    FloatArr1 { a: [1.] }
+}
+
+#[repr(C)]
+pub struct FloatArr2 {
+    a: [f32; 2],
+}
+
+// CHECK: define void @f_floatarr2_s_arg({ float, float } %0)
+#[no_mangle]
+pub extern "C" fn f_floatarr2_s_arg(a: FloatArr2) {}
+
+// CHECK: define { float, float } @f_ret_floatarr2_s()
+#[no_mangle]
+pub extern "C" fn f_ret_floatarr2_s() -> FloatArr2 {
+    FloatArr2 { a: [1., 2.] }
+}
+
+#[repr(C)]
+pub struct Tricky1 {
+    f: [f32; 1],
+}
+
+#[repr(C)]
+pub struct FloatArr2Tricky1 {
+    g: [Tricky1; 2],
+}
+
+// CHECK: define void @f_floatarr2_tricky1_s_arg({ float, float } %0)
+#[no_mangle]
+pub extern "C" fn f_floatarr2_tricky1_s_arg(a: FloatArr2Tricky1) {}
+
+// CHECK: define { float, float } @f_ret_floatarr2_tricky1_s()
+#[no_mangle]
+pub extern "C" fn f_ret_floatarr2_tricky1_s() -> FloatArr2Tricky1 {
+    FloatArr2Tricky1 { g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
+}
+
+#[repr(C)]
+pub struct EmptyStruct {}
+
+#[repr(C)]
+pub struct FloatArr2Tricky2 {
+    s: EmptyStruct,
+    g: [Tricky1; 2],
+}
+
+// CHECK: define void @f_floatarr2_tricky2_s_arg({ float, float } %0)
+#[no_mangle]
+pub extern "C" fn f_floatarr2_tricky2_s_arg(a: FloatArr2Tricky2) {}
+
+// CHECK: define { float, float } @f_ret_floatarr2_tricky2_s()
+#[no_mangle]
+pub extern "C" fn f_ret_floatarr2_tricky2_s() -> FloatArr2Tricky2 {
+    FloatArr2Tricky2 { s: EmptyStruct {}, g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
+}
+
+#[repr(C)]
+pub struct IntFloatInt {
+    a: i32,
+    b: f32,
+    c: i32,
+}
+
+// CHECK: define void @f_int_float_int_s_arg([2 x i64] %0)
+#[no_mangle]
+pub extern "C" fn f_int_float_int_s_arg(a: IntFloatInt) {}
+
+// CHECK: define [2 x i64] @f_ret_int_float_int_s()
+#[no_mangle]
+pub extern "C" fn f_ret_int_float_int_s() -> IntFloatInt {
+    IntFloatInt { a: 1, b: 2., c: 3 }
+}
+
+#[repr(C)]
+pub struct CharCharFloat {
+    a: u8,
+    b: u8,
+    c: f32,
+}
+
+// CHECK: define void @f_char_char_float_s_arg(i64 %0)
+#[no_mangle]
+pub extern "C" fn f_char_char_float_s_arg(a: CharCharFloat) {}
+
+// CHECK: define i64 @f_ret_char_char_float_s()
+#[no_mangle]
+pub extern "C" fn f_ret_char_char_float_s() -> CharCharFloat {
+    CharCharFloat { a: 1, b: 2, c: 3. }
+}
+
+#[repr(C)]
+pub union FloatU {
+    a: f32,
+}
+
+// CHECK: define void @f_float_u_arg(i64 %0)
+#[no_mangle]
+pub extern "C" fn f_float_u_arg(a: FloatU) {}
+
+// CHECK: define i64 @f_ret_float_u()
+#[no_mangle]
+pub extern "C" fn f_ret_float_u() -> FloatU {
+    unsafe { FloatU { a: 1. } }
+}
diff --git a/tests/codegen-llvm/riscv-target-abi.rs b/tests/codegen-llvm/riscv-target-abi.rs
new file mode 100644
index 00000000000..d41fcb4dd84
--- /dev/null
+++ b/tests/codegen-llvm/riscv-target-abi.rs
@@ -0,0 +1,21 @@
+//@ add-core-stubs
+//@ revisions:riscv64gc riscv32gc riscv32imac
+
+//@[riscv64gc] compile-flags: --target=riscv64gc-unknown-linux-gnu
+//@[riscv64gc] needs-llvm-components: riscv
+// riscv64gc: !{i32 1, !"target-abi", !"lp64d"}
+
+//@[riscv32gc] compile-flags: --target=riscv32gc-unknown-linux-musl
+//@[riscv32gc] needs-llvm-components: riscv
+// riscv32gc: !{i32 1, !"target-abi", !"ilp32d"}
+
+//@[riscv32imac] compile-flags: --target=riscv32imac-unknown-none-elf
+//@[riscv32imac] needs-llvm-components: riscv
+// riscv32imac: !{i32 1, !"target-abi", !"ilp32"}
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
diff --git a/tests/codegen-llvm/rust-abi-arch-specific-adjustment.rs b/tests/codegen-llvm/rust-abi-arch-specific-adjustment.rs
new file mode 100644
index 00000000000..561f081c700
--- /dev/null
+++ b/tests/codegen-llvm/rust-abi-arch-specific-adjustment.rs
@@ -0,0 +1,111 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+//@ revisions: riscv64 loongarch64
+
+//@[riscv64] only-riscv64
+//@[riscv64] compile-flags: --target riscv64gc-unknown-linux-gnu
+//@[riscv64] needs-llvm-components: riscv
+
+//@[loongarch64] only-loongarch64
+//@[loongarch64] compile-flags: --target loongarch64-unknown-linux-gnu
+//@[loongarch64] needs-llvm-components: loongarch
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+// riscv64:     define noundef i8 @arg_attr_u8(i8 noundef zeroext %x)
+// loongarch64: define noundef i8 @arg_attr_u8(i8 noundef zeroext %x)
+pub fn arg_attr_u8(x: u8) -> u8 {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef i16 @arg_attr_u16(i16 noundef zeroext %x)
+// loongarch64: define noundef i16 @arg_attr_u16(i16 noundef zeroext %x)
+pub fn arg_attr_u16(x: u16) -> u16 {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef i32 @arg_attr_u32(i32 noundef signext %x)
+// loongarch64: define noundef i32 @arg_attr_u32(i32 noundef signext %x)
+pub fn arg_attr_u32(x: u32) -> u32 {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef i64 @arg_attr_u64(i64 noundef %x)
+// loongarch64: define noundef i64 @arg_attr_u64(i64 noundef %x)
+pub fn arg_attr_u64(x: u64) -> u64 {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef i128 @arg_attr_u128(i128 noundef %x)
+// loongarch64: define noundef i128 @arg_attr_u128(i128 noundef %x)
+pub fn arg_attr_u128(x: u128) -> u128 {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef i8 @arg_attr_i8(i8 noundef signext %x)
+// loongarch64: define noundef i8 @arg_attr_i8(i8 noundef signext %x)
+pub fn arg_attr_i8(x: i8) -> i8 {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef i16 @arg_attr_i16(i16 noundef signext %x)
+// loongarch64: define noundef i16 @arg_attr_i16(i16 noundef signext %x)
+pub fn arg_attr_i16(x: i16) -> i16 {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef i32 @arg_attr_i32(i32 noundef signext %x)
+// loongarch64: define noundef i32 @arg_attr_i32(i32 noundef signext %x)
+pub fn arg_attr_i32(x: i32) -> i32 {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef i64 @arg_attr_i64(i64 noundef %x)
+// loongarch64: define noundef i64 @arg_attr_i64(i64 noundef %x)
+pub fn arg_attr_i64(x: i64) -> i64 {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef i128 @arg_attr_i128(i128 noundef %x)
+// loongarch64: define noundef i128 @arg_attr_i128(i128 noundef %x)
+pub fn arg_attr_i128(x: i128) -> i128 {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef zeroext i1 @arg_attr_bool(i1 noundef zeroext %x)
+// loongarch64: define noundef zeroext i1 @arg_attr_bool(i1 noundef zeroext %x)
+pub fn arg_attr_bool(x: bool) -> bool {
+    x
+}
+
+#[no_mangle]
+// ignore-tidy-linelength
+// riscv64:     define noundef{{( range\(i32 0, 1114112\))?}} i32 @arg_attr_char(i32 noundef signext{{( range\(i32 0, 1114112\))?}} %x)
+// loongarch64: define noundef{{( range\(i32 0, 1114112\))?}} i32 @arg_attr_char(i32 noundef signext{{( range\(i32 0, 1114112\))?}} %x)
+pub fn arg_attr_char(x: char) -> char {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef float @arg_attr_f32(float noundef %x)
+// loongarch64: define noundef float @arg_attr_f32(float noundef %x)
+pub fn arg_attr_f32(x: f32) -> f32 {
+    x
+}
+
+#[no_mangle]
+// riscv64:     define noundef double @arg_attr_f64(double noundef %x)
+// loongarch64: define noundef double @arg_attr_f64(double noundef %x)
+pub fn arg_attr_f64(x: f64) -> f64 {
+    x
+}
diff --git a/tests/codegen-llvm/s390x-simd.rs b/tests/codegen-llvm/s390x-simd.rs
new file mode 100644
index 00000000000..ac39357519e
--- /dev/null
+++ b/tests/codegen-llvm/s390x-simd.rs
@@ -0,0 +1,143 @@
+//! test that s390x vector types are passed using `PassMode::Direct`
+//! see also https://github.com/rust-lang/rust/issues/135744
+//@ add-core-stubs
+//@ compile-flags: --target s390x-unknown-linux-gnu -Copt-level=3
+//@ needs-llvm-components: systemz
+
+#![crate_type = "rlib"]
+#![feature(no_core, asm_experimental_arch)]
+#![feature(s390x_target_feature, simd_ffi, link_llvm_intrinsics, repr_simd)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(simd)]
+struct i8x16([i8; 16]);
+
+#[repr(simd)]
+struct i16x8([i16; 8]);
+
+#[repr(simd)]
+struct i32x4([i32; 4]);
+
+#[repr(simd)]
+struct i64x2([i64; 2]);
+
+#[repr(simd)]
+struct f32x4([f32; 4]);
+
+#[repr(simd)]
+struct f64x2([f64; 2]);
+
+#[allow(improper_ctypes)]
+extern "C" {
+    #[link_name = "llvm.smax.v16i8"]
+    fn vmxb(a: i8x16, b: i8x16) -> i8x16;
+    #[link_name = "llvm.smax.v8i16"]
+    fn vmxh(a: i16x8, b: i16x8) -> i16x8;
+    #[link_name = "llvm.smax.v4i32"]
+    fn vmxf(a: i32x4, b: i32x4) -> i32x4;
+    #[link_name = "llvm.smax.v2i64"]
+    fn vmxg(a: i64x2, b: i64x2) -> i64x2;
+}
+
+// CHECK-LABEL: define <16 x i8> @max_i8x16
+// CHECK-SAME: <16 x i8> %a, <16 x i8> %b
+// CHECK: call <16 x i8> @llvm.smax.v16i8(<16 x i8> %a, <16 x i8> %b)
+#[no_mangle]
+#[target_feature(enable = "vector")]
+pub unsafe extern "C" fn max_i8x16(a: i8x16, b: i8x16) -> i8x16 {
+    vmxb(a, b)
+}
+
+// CHECK-LABEL: define <8 x i16> @max_i16x8
+// CHECK-SAME: <8 x i16> %a, <8 x i16> %b
+// CHECK: call <8 x i16> @llvm.smax.v8i16(<8 x i16> %a, <8 x i16> %b)
+#[no_mangle]
+#[target_feature(enable = "vector")]
+pub unsafe extern "C" fn max_i16x8(a: i16x8, b: i16x8) -> i16x8 {
+    vmxh(a, b)
+}
+
+// CHECK-LABEL: define <4 x i32> @max_i32x4
+// CHECK-SAME: <4 x i32> %a, <4 x i32> %b
+// CHECK: call <4 x i32> @llvm.smax.v4i32(<4 x i32> %a, <4 x i32> %b)
+#[no_mangle]
+#[target_feature(enable = "vector")]
+pub unsafe extern "C" fn max_i32x4(a: i32x4, b: i32x4) -> i32x4 {
+    vmxf(a, b)
+}
+
+// CHECK-LABEL: define <2 x i64> @max_i64x2
+// CHECK-SAME: <2 x i64> %a, <2 x i64> %b
+// CHECK: call <2 x i64> @llvm.smax.v2i64(<2 x i64> %a, <2 x i64> %b)
+#[no_mangle]
+#[target_feature(enable = "vector")]
+pub unsafe extern "C" fn max_i64x2(a: i64x2, b: i64x2) -> i64x2 {
+    vmxg(a, b)
+}
+
+// CHECK-LABEL: define <4 x float> @choose_f32x4
+// CHECK-SAME: <4 x float> %a, <4 x float> %b
+#[no_mangle]
+#[target_feature(enable = "vector")]
+pub unsafe extern "C" fn choose_f32x4(a: f32x4, b: f32x4, c: bool) -> f32x4 {
+    if c { a } else { b }
+}
+
+// CHECK-LABEL: define <2 x double> @choose_f64x2
+// CHECK-SAME: <2 x double> %a, <2 x double> %b
+#[no_mangle]
+#[target_feature(enable = "vector")]
+pub unsafe extern "C" fn choose_f64x2(a: f64x2, b: f64x2, c: bool) -> f64x2 {
+    if c { a } else { b }
+}
+
+#[repr(C)]
+struct Wrapper<T>(T);
+
+#[no_mangle]
+#[inline(never)]
+#[target_feature(enable = "vector")]
+pub unsafe extern "C" fn max_wrapper_i8x16(a: Wrapper<i8x16>, b: Wrapper<i8x16>) -> Wrapper<i8x16> {
+    // CHECK-LABEL: max_wrapper_i8x16
+    // CHECK-SAME: sret([16 x i8])
+    // CHECK-SAME: <16 x i8>
+    // CHECK-SAME: <16 x i8>
+    // CHECK: call <16 x i8> @llvm.smax.v16i8
+    // CHECK-SAME: <16 x i8>
+    // CHECK-SAME: <16 x i8>
+    Wrapper(vmxb(a.0, b.0))
+}
+
+#[no_mangle]
+#[inline(never)]
+#[target_feature(enable = "vector")]
+pub unsafe extern "C" fn max_wrapper_i64x2(a: Wrapper<i64x2>, b: Wrapper<i64x2>) -> Wrapper<i64x2> {
+    // CHECK-LABEL: max_wrapper_i64x2
+    // CHECK-SAME: sret([16 x i8])
+    // CHECK-SAME: <16 x i8>
+    // CHECK-SAME: <16 x i8>
+    // CHECK: call <2 x i64> @llvm.smax.v2i64
+    // CHECK-SAME: <2 x i64>
+    // CHECK-SAME: <2 x i64>
+    Wrapper(vmxg(a.0, b.0))
+}
+
+#[no_mangle]
+#[inline(never)]
+#[target_feature(enable = "vector")]
+pub unsafe extern "C" fn choose_wrapper_f64x2(
+    a: Wrapper<f64x2>,
+    b: Wrapper<f64x2>,
+    c: bool,
+) -> Wrapper<f64x2> {
+    // CHECK-LABEL: choose_wrapper_f64x2
+    // CHECK-SAME: sret([16 x i8])
+    // CHECK-SAME: <16 x i8>
+    // CHECK-SAME: <16 x i8>
+    Wrapper(choose_f64x2(a.0, b.0, c))
+}
+
+// CHECK: declare <2 x i64> @llvm.smax.v2i64(<2 x i64>, <2 x i64>)
diff --git a/tests/codegen-llvm/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs b/tests/codegen-llvm/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
new file mode 100644
index 00000000000..e1d7dc2d631
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
@@ -0,0 +1,20 @@
+//@ add-core-stubs
+//@ revisions: aarch64 android
+//@[aarch64] compile-flags: --target aarch64-unknown-none -Zfixed-x18 -Zsanitizer=shadow-call-stack
+//@[aarch64] needs-llvm-components: aarch64
+//@[android] compile-flags: --target aarch64-linux-android -Zsanitizer=shadow-call-stack
+//@[android] needs-llvm-components: aarch64
+
+#![allow(internal_features)]
+#![crate_type = "rlib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: ; Function Attrs:{{.*}}shadowcallstack
+#[no_mangle]
+pub fn foo() {}
+
+// CHECK: attributes #0 = {{.*}}shadowcallstack{{.*}}
diff --git a/tests/codegen-llvm/sanitizer/address-sanitizer-globals-tracking.rs b/tests/codegen-llvm/sanitizer/address-sanitizer-globals-tracking.rs
new file mode 100644
index 00000000000..f319306f93f
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/address-sanitizer-globals-tracking.rs
@@ -0,0 +1,44 @@
+// Verifies that AddressSanitizer symbols show up as expected in LLVM IR with `-Zsanitizer`.
+// This is a regression test for https://github.com/rust-lang/rust/issues/113404
+//
+// Notes about the `compile-flags` below:
+//
+// * The original issue only reproed with LTO - this is why this angle has
+//   extra test coverage via different `revisions`
+// * To observe the failure/repro at LLVM-IR level we need to use `staticlib`
+//   which necessitates `-C prefer-dynamic=false` - without the latter flag,
+//   we would have run into "cannot prefer dynamic linking when performing LTO".
+//
+// The test is restricted to `only-linux`, because the sanitizer-related instrumentation is target
+// specific.  In particular, `___asan_globals_registered` is only used in the
+// `InstrumentGlobalsELF` and `InstrumentGlobalsMachO` code paths.  The `only-linux` filter is
+// narrower than really needed (i.e. narrower than ELF-or-MachO), but this seems ok - having a
+// linux-only regression test should be sufficient here.
+//
+//@ needs-sanitizer-address
+//@ only-linux
+//
+//@ revisions:ASAN ASAN-FAT-LTO
+//@                compile-flags: -Zsanitizer=address -Ctarget-feature=-crt-static
+//@[ASAN]          compile-flags:
+//@[ASAN-FAT-LTO]  compile-flags: -Cprefer-dynamic=false -Clto=fat
+
+#![crate_type = "staticlib"]
+
+// The test below mimics `CACHED_POW10` from `library/core/src/num/flt2dec/strategy/grisu.rs` which
+// (because of incorrect handling of `___asan_globals_registered` during LTO) was incorrectly
+// reported as an ODR violation in https://crbug.com/1459233#c1.  Before this bug was fixed,
+// `___asan_globals_registered` would show up as `internal global i64` rather than `common hidden
+// global i64`.  (The test expectations ignore the exact type because on `arm-android` the type
+// is `i32` rather than `i64`.)
+//
+// CHECK: @___asan_globals_registered = common hidden global
+// CHECK: @__start_asan_globals = extern_weak hidden global
+// CHECK: @__stop_asan_globals = extern_weak hidden global
+#[no_mangle]
+pub static CACHED_POW10: [(u64, i16, i16); 4] = [
+    (0xe61acf033d1a45df, -1087, -308),
+    (0xab70fe17c79ac6ca, -1060, -300),
+    (0xff77b1fcbebcdc4f, -1034, -292),
+    (0xbe5691ef416bd60c, -1007, -284),
+];
diff --git a/tests/codegen-llvm/sanitizer/cfi/add-canonical-jump-tables-flag.rs b/tests/codegen-llvm/sanitizer/cfi/add-canonical-jump-tables-flag.rs
new file mode 100644
index 00000000000..22577e2a3c4
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/add-canonical-jump-tables-flag.rs
@@ -0,0 +1,10 @@
+// Verifies that "CFI Canonical Jump Tables" module flag is added.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
+
+#![crate_type = "lib"]
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"CFI Canonical Jump Tables", i32 1}
diff --git a/tests/codegen-llvm/sanitizer/cfi/add-cfi-normalize-integers-flag.rs b/tests/codegen-llvm/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
new file mode 100644
index 00000000000..a54a6d84a80
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
@@ -0,0 +1,10 @@
+// Verifies that "cfi-normalize-integers" module flag is added.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers
+
+#![crate_type = "lib"]
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"cfi-normalize-integers", i32 1}
diff --git a/tests/codegen-llvm/sanitizer/cfi/add-enable-split-lto-unit-flag.rs b/tests/codegen-llvm/sanitizer/cfi/add-enable-split-lto-unit-flag.rs
new file mode 100644
index 00000000000..283b8f26102
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/add-enable-split-lto-unit-flag.rs
@@ -0,0 +1,10 @@
+// Verifies that "EnableSplitLTOUnit" module flag is added.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
+
+#![crate_type = "lib"]
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"EnableSplitLTOUnit", i32 1}
diff --git a/tests/codegen-llvm/sanitizer/cfi/dbg-location-on-cfi-blocks.rs b/tests/codegen-llvm/sanitizer/cfi/dbg-location-on-cfi-blocks.rs
new file mode 100644
index 00000000000..df65960dfe0
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/dbg-location-on-cfi-blocks.rs
@@ -0,0 +1,19 @@
+// Verifies that the parent block's debug information are assigned to the inserted cfi block.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -Cdebuginfo=1
+
+#![crate_type = "lib"]
+
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}foo{{.*}}!dbg !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+    // CHECK:       start:
+    // CHECK:       [[TT:%.+]] = call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"{{[[:print:]]+}}"), !dbg !{{[0-9]+}}
+    // CHECK-NEXT:  br i1 [[TT]], label %type_test.pass, label %type_test.fail, !dbg !{{[0-9]+}}
+    // CHECK:       type_test.pass:                                   ; preds = %start
+    // CHECK-NEXT:  {{%.+}} = call i32 %f(i32{{.*}} %arg), !dbg !{{[0-9]+}}
+    // CHECK:       type_test.fail:                                   ; preds = %start
+    // CHECK-NEXT:  call void @llvm.trap(), !dbg !{{[0-9]+}}
+    // CHECK-NEXT:  unreachable, !dbg !{{[0-9]+}}
+    f(arg)
+}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-attr-no-sanitize.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-attr-no-sanitize.rs
new file mode 100644
index 00000000000..71ccdc8ca62
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks-attr-no-sanitize.rs
@@ -0,0 +1,18 @@
+// Verifies that pointer type membership tests for indirect calls are omitted.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(no_sanitize)]
+
+#[no_sanitize(cfi)]
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: emit_type_checks_attr_no_sanitize::foo
+    // CHECK:       Function Attrs: {{.*}}
+    // CHECK-LABEL: define{{.*}}foo{{.*}}!type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+    // CHECK:       start:
+    // CHECK-NEXT:  {{%.+}} = call i32 %f(i32{{.*}} %arg)
+    // CHECK-NEXT:  ret i32 {{%.+}}
+    f(arg)
+}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-checks.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks.rs
new file mode 100644
index 00000000000..ebc66a015df
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-checks.rs
@@ -0,0 +1,19 @@
+// Verifies that pointer type membership tests for indirect calls are emitted.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
+
+#![crate_type = "lib"]
+
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}foo{{.*}}!type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+    // CHECK:       start:
+    // CHECK:       [[TT:%.+]] = call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"{{[[:print:]]+}}")
+    // CHECK-NEXT:  br i1 [[TT]], label %type_test.pass, label %type_test.fail
+    // CHECK:       type_test.pass:
+    // CHECK-NEXT:  {{%.+}} = call i32 %f(i32{{.*}} %arg)
+    // CHECK:       type_test.fail:
+    // CHECK-NEXT:  call void @llvm.trap()
+    // CHECK-NEXT:  unreachable
+    f(arg)
+}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs
new file mode 100644
index 00000000000..9bc2e42db0f
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs
@@ -0,0 +1,73 @@
+// Verifies that user-defined CFI encoding for types are emitted.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(cfi_encoding, extern_types)]
+
+#[cfi_encoding = "3Foo"]
+pub struct Type1(i32);
+
+extern "C" {
+    #[cfi_encoding = "3Bar"]
+    type Type2;
+}
+
+#[cfi_encoding = "3Baz"]
+#[repr(transparent)]
+pub struct Type3(i32);
+
+#[cfi_encoding = "i"]
+pub struct Type4(i32);
+
+#[cfi_encoding = "j"]
+#[repr(transparent)]
+pub struct Type5(u32);
+
+pub fn foo0(_: Type1) {}
+// CHECK: define{{.*}}foo0{{.*}}!type ![[TYPE0:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo1(_: Type1, _: Type1) {}
+// CHECK: define{{.*}}foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: Type1, _: Type1, _: Type1) {}
+// CHECK: define{{.*}}foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: *mut Type2) {}
+// CHECK: define{{.*}}foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo4(_: *mut Type2, _: *mut Type2) {}
+// CHECK: define{{.*}}foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo5(_: *mut Type2, _: *mut Type2, _: *mut Type2) {}
+// CHECK: define{{.*}}foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo6(_: *mut Type3) {}
+// CHECK: define{{.*}}foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo7(_: *mut Type3, _: *mut Type3) {}
+// CHECK: define{{.*}}foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo8(_: *mut Type3, _: *mut Type3, _: *mut Type3) {}
+// CHECK: define{{.*}}foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo9(_: Type4) {}
+// CHECK: define{{.*}}foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo10(_: Type4, _: Type4) {}
+// CHECK: define{{.*}}foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo11(_: Type4, _: Type4, _: Type4) {}
+// CHECK: define{{.*}}foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo12(_: Type5) {}
+// CHECK: define{{.*}}foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo13(_: Type5, _: Type5) {}
+// CHECK: define{{.*}}foo13{{.*}}!type ![[TYPE13:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo14(_: Type5, _: Type5, _: Type5) {}
+// CHECK: define{{.*}}foo14{{.*}}!type ![[TYPE14:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE0]] = !{i64 0, !"_ZTSFv3FooE"}
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFv3FooS_E"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFv3FooS_S_E"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvP3BarE"}
+// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvP3BarS0_E"}
+// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvP3BarS0_S0_E"}
+// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvP3BazE"}
+// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvP3BazS0_E"}
+// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvP3BazS0_S0_E"}
+// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFviE"}
+// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFviiE"}
+// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFviiiE"}
+// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvjE"}
+// CHECK: ![[TYPE13]] = !{i64 0, !"_ZTSFvjjE"}
+// CHECK: ![[TYPE14]] = !{i64 0, !"_ZTSFvjjjE"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs
new file mode 100644
index 00000000000..9048c6a1f18
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs
@@ -0,0 +1,32 @@
+// Verifies that type metadata identifiers for functions are emitted correctly
+// for const generics.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(type_alias_impl_trait)]
+
+extern crate core;
+
+pub type Type1 = impl Send;
+
+#[define_opaque(Type1)]
+pub fn foo()
+where
+    Type1: 'static,
+{
+    pub struct Foo<T, const N: usize>([T; N]);
+    let _: Type1 = Foo([0; 32]);
+}
+
+pub fn foo1(_: Type1) {}
+// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: Type1, _: Type1) {}
+// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: Type1, _: Type1, _: Type1) {}
+// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo3FooIu3i32Lu5usize32EEE"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo3FooIu3i32Lu5usize32EES2_E"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo3FooIu3i32Lu5usize32EES2_S2_E"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs
new file mode 100644
index 00000000000..8fec275fd06
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs
@@ -0,0 +1,31 @@
+// Verifies that type metadata identifiers for drop functions are emitted correctly.
+//
+// Non needs_drop drop glue isn't codegen'd at all, so we don't try to check the IDs there. But we
+// do check it's not emitted which should help catch bugs if we do start generating it again in the
+// future.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: define{{.*}}4core3ptr47drop_in_place$LT$dyn$u20$core..marker..Send$GT$
+// CHECK-SAME:  {{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+// CHECK:       call i1 @llvm.type.test(ptr {{%.+}}, metadata !"_ZTSFvPu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops4drop4Dropu6regionEE")
+
+struct EmptyDrop;
+// CHECK-NOT: define{{.*}}4core3ptr{{[0-9]+}}drop_in_place$LT${{.*}}EmptyDrop$GT${{.*}}!type ![[TYPE1]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+struct PresentDrop;
+
+impl Drop for PresentDrop {
+    fn drop(&mut self) {}
+    // CHECK: define{{.*}}4core3ptr{{[0-9]+}}drop_in_place$LT${{.*}}PresentDrop$GT${{.*}}!type ![[TYPE1]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+}
+
+pub fn foo() {
+    let _ = Box::new(EmptyDrop) as Box<dyn Send>;
+    let _ = Box::new(PresentDrop) as Box<dyn Send>;
+}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvPu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops4drop4Dropu6regionEE"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs
new file mode 100644
index 00000000000..7e60aafff68
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs
@@ -0,0 +1,45 @@
+// Verifies that type metadata identifiers for functions are emitted correctly
+// for function types.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+
+#![crate_type = "lib"]
+
+pub fn foo1(_: fn(i32) -> i32) {}
+// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: fn(i32) -> i32, _: fn(i32) -> i32) {}
+// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: fn(i32) -> i32, _: fn(i32) -> i32, _: fn(i32) -> i32) {}
+// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo4(_: &dyn Fn(i32) -> i32) {}
+// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo5(_: &dyn Fn(i32) -> i32, _: &dyn Fn(i32) -> i32) {}
+// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo6(_: &dyn Fn(i32) -> i32, _: &dyn Fn(i32) -> i32, _: &dyn Fn(i32) -> i32) {}
+// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo7(_: &dyn FnMut(i32) -> i32) {}
+// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo8(_: &dyn FnMut(i32) -> i32, _: &dyn FnMut(i32) -> i32) {}
+// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo9(_: &dyn FnMut(i32) -> i32, _: &dyn FnMut(i32) -> i32, _: &dyn FnMut(i32) -> i32) {}
+// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo10(_: &dyn FnOnce(i32) -> i32) {}
+// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo11(_: &dyn FnOnce(i32) -> i32, _: &dyn FnOnce(i32) -> i32) {}
+// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo12(_: &dyn FnOnce(i32) -> i32, _: &dyn FnOnce(i32) -> i32, _: &dyn FnOnce(i32) -> i32) {}
+// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvPFu3i32S_EE"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvPFu3i32S_ES0_E"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvPFu3i32S_ES0_S0_E"}
+// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function2FnIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEEE"}
+// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function2FnIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_E"}
+// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function2FnIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_S5_E"}
+// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function5FnMutIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEEE"}
+// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function5FnMutIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_E"}
+// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function5FnMutIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_S5_E"}
+// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnceIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEEE"}
+// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnceIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_E"}
+// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnceIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_S5_E"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs
new file mode 100644
index 00000000000..36d2e8c9f25
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs
@@ -0,0 +1,29 @@
+// Verifies that type metadata identifiers for functions are emitted correctly
+// for lifetimes/regions.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(type_alias_impl_trait)]
+
+extern crate core;
+
+pub type Type1 = impl Send;
+
+#[define_opaque(Type1)]
+pub fn foo<'a>()
+where
+    Type1: 'static,
+{
+    pub struct Foo<'a>(&'a i32);
+    pub struct Bar<'a, 'b>(&'a i32, &'b Foo<'b>);
+    let _: Type1 = Bar;
+}
+
+pub fn foo1(_: Type1) {}
+// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: Type1, _: Type1) {}
+// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: Type1, _: Type1, _: Type1) {}
+// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs
new file mode 100644
index 00000000000..9d611777ff0
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs
@@ -0,0 +1,21 @@
+// Verifies that a secondary type metadata identifier is assigned to methods with their concrete
+// self so they can be used as function pointers.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+
+#![crate_type = "lib"]
+
+trait Trait1 {
+    fn foo(&self);
+}
+
+struct Type1;
+
+impl Trait1 for Type1 {
+    fn foo(&self) {}
+    // CHECK: define{{.*}}3foo{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u6regionEEE"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type1EE"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
new file mode 100644
index 00000000000..a8ba8db1be3
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
@@ -0,0 +1,86 @@
+// Verifies that type metadata identifiers for functions are emitted correctly
+// for paths.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+
+#![crate_type = "lib"]
+#![feature(type_alias_impl_trait)]
+
+extern crate core;
+
+pub type Type1 = impl Send;
+pub type Type2 = impl Send;
+pub type Type3 = impl Send;
+pub type Type4 = impl Send;
+
+#[define_opaque(Type1, Type2, Type4)]
+pub fn foo() {
+    // Type in extern path
+    extern "C" {
+        fn bar();
+    }
+    let _: Type1 = bar;
+
+    // Type in closure path
+    || {
+        pub struct Foo;
+        let _: Type2 = Foo;
+    };
+
+    // Type in const path
+    const {
+        pub struct Foo;
+        #[define_opaque(Type3)]
+        fn bar() -> Type3 {
+            Foo
+        }
+    };
+
+    // Type in impl path
+    struct Foo;
+    impl Foo {
+        fn bar(&self) {}
+    }
+    let _: Type4 = <Foo>::bar;
+}
+
+// Force arguments to be passed by using a reference. Otherwise, they may end up PassMode::Ignore
+
+pub fn foo1(_: &Type1) {}
+// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: &Type1, _: &Type1) {}
+// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: &Type1, _: &Type1, _: &Type1) {}
+// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo4(_: &Type2) {}
+// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo5(_: &Type2, _: &Type2) {}
+// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo6(_: &Type2, _: &Type2, _: &Type2) {}
+// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo7(_: &Type3) {}
+// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo8(_: &Type3, _: &Type3) {}
+// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo9(_: &Type3, _: &Type3, _: &Type3) {}
+// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo10(_: &Type4) {}
+// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo11(_: &Type4, _: &Type4) {}
+// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo12(_: &Type4, _: &Type4, _: &Type4) {}
+// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNFNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo10{{[{}][{}]}}extern{{[}][}]}}3barEE"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNFNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo10{{[{}][{}]}}extern{{[}][}]}}3barES0_E"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNFNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo10{{[{}][{}]}}extern{{[}][}]}}3barES0_S0_E"}
+// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNCNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo11{{[{}][{}]}}closure{{[}][}]}}3FooEE"}
+// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNCNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo11{{[{}][{}]}}closure{{[}][}]}}3FooES0_E"}
+// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNCNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo11{{[{}][{}]}}closure{{[}][}]}}3FooES0_S0_E"}
+// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNkNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo12{{[{}][{}]}}constant{{[}][}]}}3FooEE"}
+// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNkNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo12{{[{}][{}]}}constant{{[}][}]}}3FooES0_E"}
+// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNkNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo12{{[{}][{}]}}constant{{[}][}]}}3FooES0_S0_E"}
+// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNINvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo8{{[{}][{}]}}impl{{[}][}]}}3barEE"}
+// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNINvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo8{{[{}][{}]}}impl{{[}][}]}}3barES0_E"}
+// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNINvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo8{{[{}][{}]}}impl{{[}][}]}}3barES0_S0_E"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs
new file mode 100644
index 00000000000..d37bb740f55
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs
@@ -0,0 +1,54 @@
+// Verifies that type metadata identifiers for functions are emitted correctly
+// for pointer types.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+
+#![crate_type = "lib"]
+
+pub fn foo1(_: &mut i32) {}
+// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: &mut i32, _: &i32) {}
+// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: &mut i32, _: &i32, _: &i32) {}
+// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo4(_: &i32) {}
+// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo5(_: &i32, _: &mut i32) {}
+// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo6(_: &i32, _: &mut i32, _: &mut i32) {}
+// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo7(_: *mut i32) {}
+// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo8(_: *mut i32, _: *const i32) {}
+// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo9(_: *mut i32, _: *const i32, _: *const i32) {}
+// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo10(_: *const i32) {}
+// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo11(_: *const i32, _: *mut i32) {}
+// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo12(_: *const i32, _: *mut i32, _: *mut i32) {}
+// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo13(_: fn(i32) -> i32) {}
+// CHECK: define{{.*}}5foo13{{.*}}!type ![[TYPE13:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo14(_: fn(i32) -> i32, _: fn(i32) -> i32) {}
+// CHECK: define{{.*}}5foo14{{.*}}!type ![[TYPE14:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo15(_: fn(i32) -> i32, _: fn(i32) -> i32, _: fn(i32) -> i32) {}
+// CHECK: define{{.*}}5foo15{{.*}}!type ![[TYPE15:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvU3mutu3refIu3i32EE"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvU3mutu3refIu3i32ES0_E"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvU3mutu3refIu3i32ES0_S0_E"}
+// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIu3i32EE"}
+// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIu3i32EU3mutS0_E"}
+// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIu3i32EU3mutS0_S1_E"}
+// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvPu3i32E"}
+// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvPu3i32PKS_E"}
+// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvPu3i32PKS_S2_E"}
+// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvPKu3i32E"}
+// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvPKu3i32PS_E"}
+// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvPKu3i32PS_S2_E"}
+// CHECK: ![[TYPE13]] = !{i64 0, !"_ZTSFvPFu3i32S_EE"}
+// CHECK: ![[TYPE14]] = !{i64 0, !"_ZTSFvPFu3i32S_ES0_E"}
+// CHECK: ![[TYPE15]] = !{i64 0, !"_ZTSFvPFu3i32S_ES0_S0_E"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
new file mode 100644
index 00000000000..7d9e4d05872
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
@@ -0,0 +1,190 @@
+// Verifies that type metadata identifiers for functions are emitted correctly
+// for primitive types.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+
+#![crate_type = "lib"]
+
+extern crate core;
+use core::ffi::*;
+
+pub fn foo1(_: ()) {}
+// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: (), _: c_void) {}
+// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: (), _: c_void, _: c_void) {}
+// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo4(_: *mut ()) {}
+// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo5(_: *mut (), _: *mut c_void) {}
+// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo6(_: *mut (), _: *mut c_void, _: *mut c_void) {}
+// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo7(_: *const ()) {}
+// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo8(_: *const (), _: *const c_void) {}
+// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo9(_: *const (), _: *const c_void, _: *const c_void) {}
+// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo10(_: bool) {}
+// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo11(_: bool, _: bool) {}
+// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo12(_: bool, _: bool, _: bool) {}
+// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo13(_: i8) {}
+// CHECK: define{{.*}}5foo13{{.*}}!type ![[TYPE13:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo14(_: i8, _: i8) {}
+// CHECK: define{{.*}}5foo14{{.*}}!type ![[TYPE14:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo15(_: i8, _: i8, _: i8) {}
+// CHECK: define{{.*}}5foo15{{.*}}!type ![[TYPE15:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo16(_: i16) {}
+// CHECK: define{{.*}}5foo16{{.*}}!type ![[TYPE16:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo17(_: i16, _: i16) {}
+// CHECK: define{{.*}}5foo17{{.*}}!type ![[TYPE17:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo18(_: i16, _: i16, _: i16) {}
+// CHECK: define{{.*}}5foo18{{.*}}!type ![[TYPE18:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo19(_: i32) {}
+// CHECK: define{{.*}}5foo19{{.*}}!type ![[TYPE19:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo20(_: i32, _: i32) {}
+// CHECK: define{{.*}}5foo20{{.*}}!type ![[TYPE20:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo21(_: i32, _: i32, _: i32) {}
+// CHECK: define{{.*}}5foo21{{.*}}!type ![[TYPE21:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo22(_: i64) {}
+// CHECK: define{{.*}}5foo22{{.*}}!type ![[TYPE22:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo23(_: i64, _: i64) {}
+// CHECK: define{{.*}}5foo23{{.*}}!type ![[TYPE23:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo24(_: i64, _: i64, _: i64) {}
+// CHECK: define{{.*}}5foo24{{.*}}!type ![[TYPE24:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo25(_: i128) {}
+// CHECK: define{{.*}}5foo25{{.*}}!type ![[TYPE25:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo26(_: i128, _: i128) {}
+// CHECK: define{{.*}}5foo26{{.*}}!type ![[TYPE26:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo27(_: i128, _: i128, _: i128) {}
+// CHECK: define{{.*}}5foo27{{.*}}!type ![[TYPE27:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo28(_: isize) {}
+// CHECK: define{{.*}}5foo28{{.*}}!type ![[TYPE28:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo29(_: isize, _: isize) {}
+// CHECK: define{{.*}}5foo29{{.*}}!type ![[TYPE29:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo30(_: isize, _: isize, _: isize) {}
+// CHECK: define{{.*}}5foo30{{.*}}!type ![[TYPE30:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo31(_: u8) {}
+// CHECK: define{{.*}}5foo31{{.*}}!type ![[TYPE31:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo32(_: u8, _: u8) {}
+// CHECK: define{{.*}}5foo32{{.*}}!type ![[TYPE32:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo33(_: u8, _: u8, _: u8) {}
+// CHECK: define{{.*}}5foo33{{.*}}!type ![[TYPE33:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo34(_: u16) {}
+// CHECK: define{{.*}}5foo34{{.*}}!type ![[TYPE34:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo35(_: u16, _: u16) {}
+// CHECK: define{{.*}}5foo35{{.*}}!type ![[TYPE35:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo36(_: u16, _: u16, _: u16) {}
+// CHECK: define{{.*}}5foo36{{.*}}!type ![[TYPE36:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo37(_: u32) {}
+// CHECK: define{{.*}}5foo37{{.*}}!type ![[TYPE37:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo38(_: u32, _: u32) {}
+// CHECK: define{{.*}}5foo38{{.*}}!type ![[TYPE38:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo39(_: u32, _: u32, _: u32) {}
+// CHECK: define{{.*}}5foo39{{.*}}!type ![[TYPE39:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo40(_: u64) {}
+// CHECK: define{{.*}}5foo40{{.*}}!type ![[TYPE40:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo41(_: u64, _: u64) {}
+// CHECK: define{{.*}}5foo41{{.*}}!type ![[TYPE41:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo42(_: u64, _: u64, _: u64) {}
+// CHECK: define{{.*}}5foo42{{.*}}!type ![[TYPE42:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo43(_: u128) {}
+// CHECK: define{{.*}}5foo43{{.*}}!type ![[TYPE43:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo44(_: u128, _: u128) {}
+// CHECK: define{{.*}}5foo44{{.*}}!type ![[TYPE44:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo45(_: u128, _: u128, _: u128) {}
+// CHECK: define{{.*}}5foo45{{.*}}!type ![[TYPE45:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo46(_: usize) {}
+// CHECK: define{{.*}}5foo46{{.*}}!type ![[TYPE46:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo47(_: usize, _: usize) {}
+// CHECK: define{{.*}}5foo47{{.*}}!type ![[TYPE47:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo48(_: usize, _: usize, _: usize) {}
+// CHECK: define{{.*}}5foo48{{.*}}!type ![[TYPE48:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo49(_: f32) {}
+// CHECK: define{{.*}}5foo49{{.*}}!type ![[TYPE49:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo50(_: f32, _: f32) {}
+// CHECK: define{{.*}}5foo50{{.*}}!type ![[TYPE50:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo51(_: f32, _: f32, _: f32) {}
+// CHECK: define{{.*}}5foo51{{.*}}!type ![[TYPE51:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo52(_: f64) {}
+// CHECK: define{{.*}}5foo52{{.*}}!type ![[TYPE52:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo53(_: f64, _: f64) {}
+// CHECK: define{{.*}}5foo53{{.*}}!type ![[TYPE53:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo54(_: f64, _: f64, _: f64) {}
+// CHECK: define{{.*}}5foo54{{.*}}!type ![[TYPE54:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo55(_: char) {}
+// CHECK: define{{.*}}5foo55{{.*}}!type ![[TYPE55:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo56(_: char, _: char) {}
+// CHECK: define{{.*}}5foo56{{.*}}!type ![[TYPE56:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo57(_: char, _: char, _: char) {}
+// CHECK: define{{.*}}5foo57{{.*}}!type ![[TYPE57:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo58(_: &str) {}
+// CHECK: define{{.*}}5foo58{{.*}}!type ![[TYPE58:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo59(_: &str, _: &str) {}
+// CHECK: define{{.*}}5foo59{{.*}}!type ![[TYPE59:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo60(_: &str, _: &str, _: &str) {}
+// CHECK: define{{.*}}5foo60{{.*}}!type ![[TYPE60:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvvE"}
+// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvPvE"}
+// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvPvS_E"}
+// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvPvS_S_E"}
+// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvPKvE"}
+// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvPKvS0_E"}
+// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvPKvS0_S0_E"}
+// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvbE"}
+// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvbbE"}
+// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvbbbE"}
+// CHECK: ![[TYPE13]] = !{i64 0, !"_ZTSFvu2i8E"}
+// CHECK: ![[TYPE14]] = !{i64 0, !"_ZTSFvu2i8S_E"}
+// CHECK: ![[TYPE15]] = !{i64 0, !"_ZTSFvu2i8S_S_E"}
+// CHECK: ![[TYPE16]] = !{i64 0, !"_ZTSFvu3i16E"}
+// CHECK: ![[TYPE17]] = !{i64 0, !"_ZTSFvu3i16S_E"}
+// CHECK: ![[TYPE18]] = !{i64 0, !"_ZTSFvu3i16S_S_E"}
+// CHECK: ![[TYPE19]] = !{i64 0, !"_ZTSFvu3i32E"}
+// CHECK: ![[TYPE20]] = !{i64 0, !"_ZTSFvu3i32S_E"}
+// CHECK: ![[TYPE21]] = !{i64 0, !"_ZTSFvu3i32S_S_E"}
+// CHECK: ![[TYPE22]] = !{i64 0, !"_ZTSFvu3i64E"}
+// CHECK: ![[TYPE23]] = !{i64 0, !"_ZTSFvu3i64S_E"}
+// CHECK: ![[TYPE24]] = !{i64 0, !"_ZTSFvu3i64S_S_E"}
+// CHECK: ![[TYPE25]] = !{i64 0, !"_ZTSFvu4i128E"}
+// CHECK: ![[TYPE26]] = !{i64 0, !"_ZTSFvu4i128S_E"}
+// CHECK: ![[TYPE27]] = !{i64 0, !"_ZTSFvu4i128S_S_E"}
+// CHECK: ![[TYPE28]] = !{i64 0, !"_ZTSFvu5isizeE"}
+// CHECK: ![[TYPE29]] = !{i64 0, !"_ZTSFvu5isizeS_E"}
+// CHECK: ![[TYPE30]] = !{i64 0, !"_ZTSFvu5isizeS_S_E"}
+// CHECK: ![[TYPE31]] = !{i64 0, !"_ZTSFvu2u8E"}
+// CHECK: ![[TYPE32]] = !{i64 0, !"_ZTSFvu2u8S_E"}
+// CHECK: ![[TYPE33]] = !{i64 0, !"_ZTSFvu2u8S_S_E"}
+// CHECK: ![[TYPE34]] = !{i64 0, !"_ZTSFvu3u16E"}
+// CHECK: ![[TYPE35]] = !{i64 0, !"_ZTSFvu3u16S_E"}
+// CHECK: ![[TYPE36]] = !{i64 0, !"_ZTSFvu3u16S_S_E"}
+// CHECK: ![[TYPE37]] = !{i64 0, !"_ZTSFvu3u32E"}
+// CHECK: ![[TYPE38]] = !{i64 0, !"_ZTSFvu3u32S_E"}
+// CHECK: ![[TYPE39]] = !{i64 0, !"_ZTSFvu3u32S_S_E"}
+// CHECK: ![[TYPE40]] = !{i64 0, !"_ZTSFvu3u64E"}
+// CHECK: ![[TYPE41]] = !{i64 0, !"_ZTSFvu3u64S_E"}
+// CHECK: ![[TYPE42]] = !{i64 0, !"_ZTSFvu3u64S_S_E"}
+// CHECK: ![[TYPE43]] = !{i64 0, !"_ZTSFvu4u128E"}
+// CHECK: ![[TYPE44]] = !{i64 0, !"_ZTSFvu4u128S_E"}
+// CHECK: ![[TYPE45]] = !{i64 0, !"_ZTSFvu4u128S_S_E"}
+// CHECK: ![[TYPE46]] = !{i64 0, !"_ZTSFvu5usizeE"}
+// CHECK: ![[TYPE47]] = !{i64 0, !"_ZTSFvu5usizeS_E"}
+// CHECK: ![[TYPE48]] = !{i64 0, !"_ZTSFvu5usizeS_S_E"}
+// CHECK: ![[TYPE49]] = !{i64 0, !"_ZTSFvfE"}
+// CHECK: ![[TYPE50]] = !{i64 0, !"_ZTSFvffE"}
+// CHECK: ![[TYPE51]] = !{i64 0, !"_ZTSFvfffE"}
+// CHECK: ![[TYPE52]] = !{i64 0, !"_ZTSFvdE"}
+// CHECK: ![[TYPE53]] = !{i64 0, !"_ZTSFvddE"}
+// CHECK: ![[TYPE54]] = !{i64 0, !"_ZTSFvdddE"}
+// CHECK: ![[TYPE55]] = !{i64 0, !"_ZTSFvu4charE"}
+// CHECK: ![[TYPE56]] = !{i64 0, !"_ZTSFvu4charS_E"}
+// CHECK: ![[TYPE57]] = !{i64 0, !"_ZTSFvu4charS_S_E"}
+// CHECK: ![[TYPE58]] = !{i64 0, !"_ZTSFvu3refIu3strEE"}
+// CHECK: ![[TYPE59]] = !{i64 0, !"_ZTSFvu3refIu3strES0_E"}
+// CHECK: ![[TYPE60]] = !{i64 0, !"_ZTSFvu3refIu3strES0_S0_E"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs
new file mode 100644
index 00000000000..0f97c70f3f9
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs
@@ -0,0 +1,79 @@
+// Verifies that type metadata identifiers for functions are emitted correctly
+// for repr transparent types.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+
+#![crate_type = "lib"]
+
+extern crate core;
+use core::ffi::*;
+use std::marker::PhantomData;
+
+struct Foo(i32);
+
+// repr(transparent) user-defined type
+#[repr(transparent)]
+pub struct Type1 {
+    member1: (),
+    member2: PhantomData<i32>,
+    member3: Foo,
+}
+
+// Self-referencing repr(transparent) user-defined type
+#[repr(transparent)]
+pub struct Type2<'a> {
+    member1: (),
+    member2: PhantomData<i32>,
+    member3: &'a Type2<'a>,
+}
+
+pub struct Bar(i32);
+
+// repr(transparent) user-defined generic type
+#[repr(transparent)]
+pub struct Type3<T>(T);
+
+// repr(transparent) wrapper which engages in self-reference
+#[repr(transparent)]
+pub struct Type4(Type4Helper<Type4>);
+#[repr(transparent)]
+pub struct Type4Helper<T>(*mut T);
+
+pub fn foo1(_: Type1) {}
+// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: Type1, _: Type1) {}
+// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: Type1, _: Type1, _: Type1) {}
+// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo4(_: Type2) {}
+// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo5(_: Type2, _: Type2) {}
+// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo6(_: Type2, _: Type2, _: Type2) {}
+// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo7(_: Type3<Bar>) {}
+// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo8(_: Type3<Bar>, _: Type3<Bar>) {}
+// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo9(_: Type3<Bar>, _: Type3<Bar>, _: Type3<Bar>) {}
+// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo10(_: Type4) {}
+// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo11(_: Type4, _: Type4) {}
+// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo12(_: Type4, _: Type4, _: Type4) {}
+// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3FooE"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3FooS_E"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3FooS_S_E"}
+// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIvEE"}
+// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIvES_E"}
+// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIvES_S_E"}
+// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3BarE"}
+// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3BarS_E"}
+// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3BarS_S_E"}
+// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvPu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4E"}
+// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvPu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4S0_E"}
+// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvPu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4S0_S0_E"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs
new file mode 100644
index 00000000000..bdee3f47a83
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs
@@ -0,0 +1,36 @@
+// Verifies that type metadata identifiers for functions are emitted correctly
+// for sequence types.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+
+#![crate_type = "lib"]
+
+pub fn foo1(_: (i32, i32)) {}
+// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: (i32, i32), _: (i32, i32)) {}
+// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: (i32, i32), _: (i32, i32), _: (i32, i32)) {}
+// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo4(_: [i32; 32]) {}
+// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo5(_: [i32; 32], _: [i32; 32]) {}
+// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo6(_: [i32; 32], _: [i32; 32], _: [i32; 32]) {}
+// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo7(_: &[i32]) {}
+// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo8(_: &[i32], _: &[i32]) {}
+// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo9(_: &[i32], _: &[i32], _: &[i32]) {}
+// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu5tupleIu3i32S_EE"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu5tupleIu3i32S_ES0_E"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu5tupleIu3i32S_ES0_S0_E"}
+// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvA32u3i32E"}
+// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvA32u3i32S0_E"}
+// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvA32u3i32S0_S0_E"}
+// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu3refIu5sliceIu3i32EEE"}
+// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu3refIu5sliceIu3i32EES1_E"}
+// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu3refIu5sliceIu3i32EES1_S1_E"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs
new file mode 100644
index 00000000000..55e816178f8
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs
@@ -0,0 +1,175 @@
+// Verifies that type metadata identifiers for functions are emitted correctly
+// for trait types.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+
+#![crate_type = "lib"]
+
+extern crate core;
+
+pub trait Trait1 {
+    fn foo(&self);
+}
+
+#[derive(Clone, Copy)]
+pub struct Type1;
+
+impl Trait1 for Type1 {
+    fn foo(&self) {}
+}
+
+pub trait Trait2<T> {
+    fn bar(&self);
+}
+
+pub struct Type2;
+
+impl Trait2<i32> for Type2 {
+    fn bar(&self) {}
+}
+
+pub trait Trait3<T> {
+    fn baz(&self, _: &T);
+}
+
+pub struct Type3;
+
+impl<T, U> Trait3<U> for T {
+    fn baz(&self, _: &U) {}
+}
+
+pub trait Trait4<'a, T> {
+    type Output: 'a;
+    fn qux(&self, _: &T) -> Self::Output;
+}
+
+pub struct Type4;
+
+impl<'a, T, U> Trait4<'a, U> for T {
+    type Output = &'a i32;
+    fn qux(&self, _: &U) -> Self::Output {
+        &0
+    }
+}
+
+pub trait Trait5<T, const N: usize> {
+    fn quux(&self, _: &[T; N]);
+}
+
+#[derive(Copy, Clone)]
+pub struct Type5;
+
+impl<T, U, const N: usize> Trait5<U, N> for T {
+    fn quux(&self, _: &[U; N]) {}
+}
+
+pub fn foo1(_: &dyn Send) {}
+// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: &dyn Send, _: &dyn Send) {}
+// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: &dyn Send, _: &dyn Send, _: &dyn Send) {}
+// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo4(_: &(dyn Send + Sync)) {}
+// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo5(_: &(dyn Send + Sync), _: &(dyn Sync + Send)) {}
+// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo6(_: &(dyn Send + Sync), _: &(dyn Sync + Send), _: &(dyn Sync + Send)) {}
+// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo7(_: &(dyn Trait1 + Send)) {}
+// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo8(_: &(dyn Trait1 + Send), _: &(dyn Trait1 + Send)) {}
+// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo9(_: &(dyn Trait1 + Send), _: &(dyn Trait1 + Send), _: &(dyn Trait1 + Send)) {}
+// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo10(_: &(dyn Trait1 + Send + Sync)) {}
+// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo11(_: &(dyn Trait1 + Send + Sync), _: &(dyn Trait1 + Sync + Send)) {}
+// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo12(
+    _: &(dyn Trait1 + Send + Sync),
+    _: &(dyn Trait1 + Sync + Send),
+    _: &(dyn Trait1 + Sync + Send),
+) {
+}
+// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo13(_: &dyn Trait1) {}
+// CHECK: define{{.*}}5foo13{{.*}}!type ![[TYPE13:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo14(_: &dyn Trait1, _: &dyn Trait1) {}
+// CHECK: define{{.*}}5foo14{{.*}}!type ![[TYPE14:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo15(_: &dyn Trait1, _: &dyn Trait1, _: &dyn Trait1) {}
+// CHECK: define{{.*}}5foo15{{.*}}!type ![[TYPE15:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo16<T>(_: &dyn Trait2<T>) {}
+pub fn bar16() {
+    let a = Type2;
+    foo16(&a);
+}
+// CHECK: define{{.*}}5foo16{{.*}}!type ![[TYPE16:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo17<T>(_: &dyn Trait2<T>, _: &dyn Trait2<T>) {}
+pub fn bar17() {
+    let a = Type2;
+    foo17(&a, &a);
+}
+// CHECK: define{{.*}}5foo17{{.*}}!type ![[TYPE17:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo18<T>(_: &dyn Trait2<T>, _: &dyn Trait2<T>, _: &dyn Trait2<T>) {}
+pub fn bar18() {
+    let a = Type2;
+    foo18(&a, &a, &a);
+}
+// CHECK: define{{.*}}5foo18{{.*}}!type ![[TYPE18:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo19(_: &dyn Trait3<Type3>) {}
+// CHECK: define{{.*}}5foo19{{.*}}!type ![[TYPE19:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo20(_: &dyn Trait3<Type3>, _: &dyn Trait3<Type3>) {}
+// CHECK: define{{.*}}5foo20{{.*}}!type ![[TYPE20:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo21(_: &dyn Trait3<Type3>, _: &dyn Trait3<Type3>, _: &dyn Trait3<Type3>) {}
+// CHECK: define{{.*}}5foo21{{.*}}!type ![[TYPE21:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo22<'a>(_: &dyn Trait4<'a, Type4, Output = &'a i32>) {}
+// CHECK: define{{.*}}5foo22{{.*}}!type ![[TYPE22:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo23<'a>(
+    _: &dyn Trait4<'a, Type4, Output = &'a i32>,
+    _: &dyn Trait4<'a, Type4, Output = &'a i32>,
+) {
+}
+// CHECK: define{{.*}}5foo23{{.*}}!type ![[TYPE23:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo24<'a>(
+    _: &dyn Trait4<'a, Type4, Output = &'a i32>,
+    _: &dyn Trait4<'a, Type4, Output = &'a i32>,
+    _: &dyn Trait4<'a, Type4, Output = &'a i32>,
+) {
+}
+// CHECK: define{{.*}}5foo24{{.*}}!type ![[TYPE24:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo25(_: &dyn Trait5<Type5, 32>) {}
+// CHECK: define{{.*}}5foo25{{.*}}!type ![[TYPE25:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo26(_: &dyn Trait5<Type5, 32>, _: &dyn Trait5<Type5, 32>) {}
+// CHECK: define{{.*}}5foo26{{.*}}!type ![[TYPE26:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo27(_: &dyn Trait5<Type5, 32>, _: &dyn Trait5<Type5, 32>, _: &dyn Trait5<Type5, 32>) {}
+// CHECK: define{{.*}}5foo27{{.*}}!type ![[TYPE27:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE13]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u6regionEEE"}
+// CHECK: ![[TYPE16]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait2Iu3i32Eu6regionEEE"}
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEEE"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEES2_E"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEES2_S2_E"}
+// FIXME(rcvalle): Enforce autotraits ordering when encoding (e.g., alphabetical order)
+// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEEE"}
+// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEES3_E"}
+// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEES3_S3_E"}
+// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEEE"}
+// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEES3_E"}
+// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEES3_S3_E"}
+// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEEE"}
+// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEES4_E"}
+// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEES4_S4_E"}
+// CHECK: ![[TYPE14]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u6regionEES2_E"}
+// CHECK: ![[TYPE15]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u6regionEES2_S2_E"}
+// CHECK: ![[TYPE17]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait2Iu3i32Eu6regionEES3_E"}
+// CHECK: ![[TYPE18]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait2Iu3i32Eu6regionEES3_S3_E"}
+// CHECK: ![[TYPE19]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait3Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type3Eu6regionEEE"}
+// CHECK: ![[TYPE20]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait3Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type3Eu6regionEES3_E"}
+// CHECK: ![[TYPE21]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait3Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type3Eu6regionEES3_S3_E"}
+// CHECK: ![[TYPE22]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait4Iu6regionu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4Eu{{[0-9]+}}NtNtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait46OutputIS_S0_Eu3refIu3i32ES_EEE"}
+// CHECK: ![[TYPE23]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait4Iu6regionu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4Eu{{[0-9]+}}NtNtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait46OutputIS_S0_Eu3refIu3i32ES_EES6_E"}
+// CHECK: ![[TYPE24]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait4Iu6regionu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4Eu{{[0-9]+}}NtNtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait46OutputIS_S0_Eu3refIu3i32ES_EES6_S6_E"}
+// CHECK: ![[TYPE25]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait5Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type5Lu5usize32EEu6regionEEE"}
+// CHECK: ![[TYPE26]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait5Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type5Lu5usize32EEu6regionEES5_E"}
+// CHECK: ![[TYPE27]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait5Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type5Lu5usize32EEu6regionEES5_S5_E"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs
new file mode 100644
index 00000000000..c1f3ca61afe
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs
@@ -0,0 +1,62 @@
+// Verifies that type metadata identifiers for functions are emitted correctly
+// for user-defined types.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+
+#![crate_type = "lib"]
+#![feature(extern_types)]
+
+pub struct Struct1<T> {
+    member1: T,
+}
+
+pub enum Enum1<T> {
+    Variant1(T),
+}
+
+pub union Union1<T> {
+    member1: std::mem::ManuallyDrop<T>,
+}
+
+extern "C" {
+    pub type type1;
+}
+
+pub fn foo1(_: &Struct1<i32>) {}
+// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: &Struct1<i32>, _: &Struct1<i32>) {}
+// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: &Struct1<i32>, _: &Struct1<i32>, _: &Struct1<i32>) {}
+// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo4(_: &Enum1<i32>) {}
+// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo5(_: &Enum1<i32>, _: &Enum1<i32>) {}
+// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo6(_: &Enum1<i32>, _: &Enum1<i32>, _: &Enum1<i32>) {}
+// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo7(_: &Union1<i32>) {}
+// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo8(_: &Union1<i32>, _: &Union1<i32>) {}
+// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo9(_: &Union1<i32>, _: &Union1<i32>, _: &Union1<i32>) {}
+// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo10(_: *mut type1) {}
+// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo11(_: *mut type1, _: *mut type1) {}
+// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo12(_: *mut type1, _: *mut type1, _: *mut type1) {}
+// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}7Struct1Iu3i32EEE"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}7Struct1Iu3i32EES1_E"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}7Struct1Iu3i32EES1_S1_E"}
+// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Enum1Iu3i32EEE"}
+// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Enum1Iu3i32EES1_E"}
+// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Enum1Iu3i32EES1_S1_E"}
+// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Union1Iu3i32EEE"}
+// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Union1Iu3i32EES1_E"}
+// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Union1Iu3i32EES1_S1_E"}
+// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvP5type1E"}
+// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvP5type1S0_E"}
+// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvP5type1S0_S0_E"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs
new file mode 100644
index 00000000000..32637b64b3e
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs
@@ -0,0 +1,31 @@
+// Verifies that generalized type metadata for functions are emitted.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-generalize-pointers
+
+#![crate_type = "lib"]
+
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}foo
+    // CHECK-SAME:  {{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_E.generalized")
+    f(arg)
+}
+
+pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}bar
+    // CHECK-SAME:  {{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_E.generalized")
+    f(arg1, arg2)
+}
+
+pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}baz
+    // CHECK-SAME:  {{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_S_E.generalized")
+    f(arg1, arg2, arg3)
+}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFu3i32PKvS_E.generalized"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFu3i32PKvS_S_E.generalized"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFu3i32PKvS_S_S_E.generalized"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
new file mode 100644
index 00000000000..51121b0aef1
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
@@ -0,0 +1,31 @@
+// Verifies that normalized and generalized type metadata for functions are emitted.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers -Zsanitizer-cfi-generalize-pointers
+
+#![crate_type = "lib"]
+
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}foo
+    // CHECK-SAME:  {{.*}}![[TYPE1:[0-9]+]]
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_E.normalized.generalized")
+    f(arg)
+}
+
+pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}bar
+    // CHECK-SAME:  {{.*}}![[TYPE2:[0-9]+]]
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_E.normalized.generalized")
+    f(arg1, arg2)
+}
+
+pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}baz
+    // CHECK-SAME:  {{.*}}![[TYPE3:[0-9]+]]
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_S_E.normalized.generalized")
+    f(arg1, arg2, arg3)
+}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFu3i32PKvS_E.normalized.generalized"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFu3i32PKvS_S_E.normalized.generalized"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFu3i32PKvS_S_S_E.normalized.generalized"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs
new file mode 100644
index 00000000000..1cfdd23006e
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs
@@ -0,0 +1,31 @@
+// Verifies that normalized type metadata for functions are emitted.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers
+
+#![crate_type = "lib"]
+
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}foo
+    // CHECK-SAME:  {{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_E.normalized")
+    f(arg)
+}
+
+pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}bar
+    // CHECK-SAME:  {{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_E.normalized")
+    f(arg1, arg2)
+}
+
+pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}baz
+    // CHECK-SAME:  {{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_S_E.normalized")
+    f(arg1, arg2, arg3)
+}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFu3i32PFS_S_ES_E.normalized"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFu3i32PFS_S_S_ES_S_E.normalized"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFu3i32PFS_S_S_S_ES_S_S_E.normalized"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs
new file mode 100644
index 00000000000..56ab1ce4b35
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs
@@ -0,0 +1,31 @@
+// Verifies that type metadata for functions are emitted.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi
+
+#![crate_type = "lib"]
+
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}foo
+    // CHECK-SAME:  {{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_E")
+    f(arg)
+}
+
+pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}bar
+    // CHECK-SAME:  {{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_E")
+    f(arg1, arg2)
+}
+
+pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}baz
+    // CHECK-SAME:  {{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_S_E")
+    f(arg1, arg2, arg3)
+}
+
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFu3i32PFS_S_ES_E"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFu3i32PFS_S_S_ES_S_E"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFu3i32PFS_S_S_S_ES_S_S_E"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-trait-objects.rs b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-trait-objects.rs
new file mode 100644
index 00000000000..0e57ce322d1
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-trait-objects.rs
@@ -0,0 +1,145 @@
+// Verifies that type metadata identifiers for trait objects are emitted correctly.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Ctarget-feature=-crt-static -Zsanitizer=cfi
+
+#![crate_type = "lib"]
+
+pub trait Trait1 {
+    fn foo(&self);
+}
+
+#[derive(Clone, Copy)]
+pub struct Type1;
+
+impl Trait1 for Type1 {
+    fn foo(&self) {}
+}
+
+pub trait Trait2<T> {
+    fn bar(&self);
+}
+
+pub struct Type2;
+
+impl Trait2<i32> for Type2 {
+    fn bar(&self) {}
+}
+
+pub trait Trait3<T> {
+    fn baz(&self, _: &T);
+}
+
+pub struct Type3;
+
+impl<T, U> Trait3<U> for T {
+    fn baz(&self, _: &U) {}
+}
+
+pub trait Trait4<'a, T> {
+    type Output: 'a;
+    fn qux(&self, _: &T) -> Self::Output;
+}
+
+pub struct Type4;
+
+impl<'a, T, U> Trait4<'a, U> for T {
+    type Output = &'a i32;
+    fn qux(&self, _: &U) -> Self::Output {
+        &0
+    }
+}
+
+pub trait Trait5<T, const N: usize> {
+    fn quux(&self, _: &[T; N]);
+}
+
+#[derive(Copy, Clone)]
+pub struct Type5;
+
+impl<T, U, const N: usize> Trait5<U, N> for T {
+    fn quux(&self, _: &[U; N]) {}
+}
+
+pub fn foo1(a: &dyn Trait1) {
+    a.foo();
+    // CHECK-LABEL: define{{.*}}4foo1{{.*}}!type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE1:[[:print:]]+]]")
+}
+
+pub fn bar1() {
+    let a = Type1;
+    let b = &a as &dyn Trait1;
+    b.foo();
+    // CHECK-LABEL: define{{.*}}4bar1{{.*}}!type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE2:[[:print:]]+]]")
+}
+
+pub fn foo2<T>(a: &dyn Trait2<T>) {
+    a.bar();
+    // CHECK-LABEL: define{{.*}}4foo2{{.*}}!type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE2:[[:print:]]+]]")
+}
+
+pub fn bar2() {
+    let a = Type2;
+    foo2(&a);
+    let b = &a as &dyn Trait2<i32>;
+    b.bar();
+    // CHECK-LABEL: define{{.*}}4bar2{{.*}}!type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE2:[[:print:]]+]]")
+}
+
+pub fn foo3(a: &dyn Trait3<Type3>) {
+    let b = Type3;
+    a.baz(&b);
+    // CHECK-LABEL: define{{.*}}4foo3{{.*}}!type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE3:[[:print:]]+]]")
+}
+
+pub fn bar3() {
+    let a = Type3;
+    foo3(&a);
+    let b = &a as &dyn Trait3<Type3>;
+    b.baz(&a);
+    // CHECK-LABEL: define{{.*}}4bar3{{.*}}!type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE3:[[:print:]]+]]")
+}
+
+pub fn foo4<'a>(a: &dyn Trait4<'a, Type4, Output = &'a i32>) {
+    let b = Type4;
+    a.qux(&b);
+    // CHECK-LABEL: define{{.*}}4foo4{{.*}}!type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE4:[[:print:]]+]]")
+}
+
+pub fn bar4<'a>() {
+    let a = Type4;
+    foo4(&a);
+    let b = &a as &dyn Trait4<'a, Type4, Output = &'a i32>;
+    b.qux(&a);
+    // CHECK-LABEL: define{{.*}}4bar4{{.*}}!type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE4:[[:print:]]+]]")
+}
+
+pub fn foo5(a: &dyn Trait5<Type5, 32>) {
+    let b = &[Type5; 32];
+    a.quux(&b);
+    // CHECK-LABEL: define{{.*}}4foo5{{.*}}!type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE5:[[:print:]]+]]")
+}
+
+pub fn bar5() {
+    let a = &[Type5; 32];
+    foo5(&a);
+    let b = &a as &dyn Trait5<Type5, 32>;
+    b.quux(&a);
+    // CHECK-LABEL: define{{.*}}4bar5{{.*}}!type !{{[0-9]+}}
+    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE5:[[:print:]]+]]")
+}
+
+// CHECK: !{{[0-9]+}} = !{i64 0, !"[[TYPE1]]"}
+// CHECK: !{{[0-9]+}} = !{i64 0, !"[[TYPE2]]"}
+// CHECK: !{{[0-9]+}} = !{i64 0, !"[[TYPE3]]"}
+// CHECK: !{{[0-9]+}} = !{i64 0, !"[[TYPE4]]"}
+// CHECK: !{{[0-9]+}} = !{i64 0, !"[[TYPE5]]"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/external_weak_symbols.rs b/tests/codegen-llvm/sanitizer/cfi/external_weak_symbols.rs
new file mode 100644
index 00000000000..00e9b5029af
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/external_weak_symbols.rs
@@ -0,0 +1,24 @@
+// Verifies that type metadata identifiers for for weakly-linked symbols are
+// emitted correctly.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clinker-plugin-lto -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
+#![crate_type = "bin"]
+#![feature(linkage)]
+
+unsafe extern "C" {
+    #[linkage = "extern_weak"]
+    static FOO: Option<unsafe extern "C" fn(f64) -> ()>;
+}
+// CHECK: @_rust_extern_with_linkage_FOO = internal global ptr @FOO
+
+fn main() {
+    unsafe {
+        if let Some(method) = FOO {
+            method(4.2);
+            // CHECK: call i1 @llvm.type.test(ptr {{%method|%0}}, metadata !"_ZTSFvdE")
+        }
+    }
+}
+
+// CHECK: declare !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} extern_weak void @FOO(double) unnamed_addr #{{[0-9]+}}
diff --git a/tests/codegen-llvm/sanitizer/cfi/generalize-pointers.rs b/tests/codegen-llvm/sanitizer/cfi/generalize-pointers.rs
new file mode 100644
index 00000000000..57004da6f8e
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/generalize-pointers.rs
@@ -0,0 +1,46 @@
+// Verifies that pointer types are generalized.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-generalize-pointers -Copt-level=0
+
+#![crate_type = "lib"]
+
+extern crate core;
+
+pub fn foo0(_: &mut i32) {}
+// CHECK: define{{.*}}foo0{{.*}}!type ![[TYPE0:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo1(_: &mut i32, _: &mut i32) {}
+// CHECK: define{{.*}}foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo2(_: &mut i32, _: &mut i32, _: &mut i32) {}
+// CHECK: define{{.*}}foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo3(_: &i32) {}
+// CHECK: define{{.*}}foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo4(_: &i32, _: &i32) {}
+// CHECK: define{{.*}}foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo5(_: &i32, _: &i32, _: &i32) {}
+// CHECK: define{{.*}}foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo6(_: *mut i32) {}
+// CHECK: define{{.*}}foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo7(_: *mut i32, _: *mut i32) {}
+// CHECK: define{{.*}}foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo8(_: *mut i32, _: *mut i32, _: *mut i32) {}
+// CHECK: define{{.*}}foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo9(_: *const i32) {}
+// CHECK: define{{.*}}foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo10(_: *const i32, _: *const i32) {}
+// CHECK: define{{.*}}foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+pub fn foo11(_: *const i32, _: *const i32, _: *const i32) {}
+// CHECK: define{{.*}}foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE0]] = !{i64 0, !"_ZTSFvU3mutu3refIvEE.generalized"}
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvU3mutu3refIvES0_E.generalized"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvU3mutu3refIvES0_S0_E.generalized"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu3refIvEE.generalized"}
+// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIvES_E.generalized"}
+// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIvES_S_E.generalized"}
+// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvPvE.generalized"}
+// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvPvS_E.generalized"}
+// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvPvS_S_E.generalized"}
+// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvPKvE.generalized"}
+// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvPKvS0_E.generalized"}
+// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvPKvS0_S0_E.generalized"}
diff --git a/tests/codegen-llvm/sanitizer/cfi/normalize-integers.rs b/tests/codegen-llvm/sanitizer/cfi/normalize-integers.rs
new file mode 100644
index 00000000000..770ee4e64e0
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/cfi/normalize-integers.rs
@@ -0,0 +1,46 @@
+// Verifies that integer types are normalized.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers -Copt-level=0
+
+#![crate_type = "lib"]
+
+extern crate core;
+
+pub fn foo0(_: bool) {}
+// CHECK: define{{.*}}foo0{{.*}}!type ![[TYPE0:[0-9]+]] !type !{{[0-9]+}}
+pub fn foo1(_: bool, _: bool) {}
+// CHECK: define{{.*}}foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}}
+pub fn foo2(_: bool, _: bool, _: bool) {}
+// CHECK: define{{.*}}foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}}
+pub fn foo3(_: char) {}
+// CHECK: define{{.*}}foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}}
+pub fn foo4(_: char, _: char) {}
+// CHECK: define{{.*}}foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}}
+pub fn foo5(_: char, _: char, _: char) {}
+// CHECK: define{{.*}}foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}}
+pub fn foo6(_: isize) {}
+// CHECK: define{{.*}}foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}}
+pub fn foo7(_: isize, _: isize) {}
+// CHECK: define{{.*}}foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}}
+pub fn foo8(_: isize, _: isize, _: isize) {}
+// CHECK: define{{.*}}foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}}
+pub fn foo9(_: (), _: usize) {}
+// CHECK: define{{.*}}foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}}
+pub fn foo10(_: (), _: usize, _: usize) {}
+// CHECK: define{{.*}}foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}}
+pub fn foo11(_: (), _: usize, _: usize, _: usize) {}
+// CHECK: define{{.*}}foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}}
+
+// CHECK: ![[TYPE0]] = !{i64 0, !"_ZTSFvu2u8E.normalized"}
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu2u8S_E.normalized"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu2u8S_S_E.normalized"}
+// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu3u32E.normalized"}
+// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3u32S_E.normalized"}
+// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3u32S_S_E.normalized"}
+// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64|u4i128}}E.normalized"}
+// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64|u4i128}}S_E.normalized"}
+// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64|u4i128}}S_S_E.normalized"}
+// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64|u4u128}}E.normalized"}
+// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64|u4u128}}S_E.normalized"}
+// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64|u4u128}}S_S_E.normalized"}
diff --git a/tests/codegen-llvm/sanitizer/dataflow-instrument-functions.rs b/tests/codegen-llvm/sanitizer/dataflow-instrument-functions.rs
new file mode 100644
index 00000000000..a2d0d63cc17
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/dataflow-instrument-functions.rs
@@ -0,0 +1,9 @@
+// Verifies that functions are instrumented.
+//
+//@ needs-sanitizer-dataflow
+//@ compile-flags: -Copt-level=0 -Zsanitizer=dataflow
+
+#![crate_type = "lib"]
+
+pub fn foo() {}
+// CHECK: define{{.*}}foo{{.*}}.dfsan
diff --git a/tests/codegen-llvm/sanitizer/kasan-emits-instrumentation.rs b/tests/codegen-llvm/sanitizer/kasan-emits-instrumentation.rs
new file mode 100644
index 00000000000..774c9ab53f1
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kasan-emits-instrumentation.rs
@@ -0,0 +1,41 @@
+// Verifies that `-Zsanitizer=kernel-address` emits sanitizer instrumentation.
+
+//@ add-core-stubs
+//@ compile-flags: -Zsanitizer=kernel-address -Copt-level=0
+//@ revisions: aarch64 riscv64imac riscv64gc x86_64
+//@[aarch64] compile-flags: --target aarch64-unknown-none
+//@[aarch64] needs-llvm-components: aarch64
+//@[riscv64imac] compile-flags: --target riscv64imac-unknown-none-elf
+//@[riscv64imac] needs-llvm-components: riscv
+//@[riscv64gc] compile-flags: --target riscv64gc-unknown-none-elf
+//@[riscv64gc] needs-llvm-components: riscv
+//@[x86_64] compile-flags: --target x86_64-unknown-none
+//@[x86_64] needs-llvm-components: x86
+
+#![crate_type = "rlib"]
+#![feature(no_core, no_sanitize, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK-LABEL: ; kasan_emits_instrumentation::unsanitized
+// CHECK-NEXT:  ; Function Attrs:
+// CHECK-NOT:   sanitize_address
+// CHECK:       start:
+// CHECK-NOT:   call void @__asan_report_load
+// CHECK:       }
+#[no_sanitize(address)]
+pub fn unsanitized(b: &mut u8) -> u8 {
+    *b
+}
+
+// CHECK-LABEL: ; kasan_emits_instrumentation::sanitized
+// CHECK-NEXT:  ; Function Attrs:
+// CHECK:       sanitize_address
+// CHECK:       start:
+// CHECK:       call void @__asan_report_load
+// CHECK:       }
+pub fn sanitized(b: &mut u8) -> u8 {
+    *b
+}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs b/tests/codegen-llvm/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
new file mode 100644
index 00000000000..0be1ff19774
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
@@ -0,0 +1,20 @@
+// Verifies that "cfi-normalize-integers" module flag is added.
+//
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components: x86
+//@ compile-flags: -Ctarget-feature=-crt-static -Zsanitizer=kcfi -Zsanitizer-cfi-normalize-integers
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"cfi-normalize-integers", i32 1}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-arity-flag.rs b/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-arity-flag.rs
new file mode 100644
index 00000000000..9a2290901d6
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-arity-flag.rs
@@ -0,0 +1,19 @@
+// Verifies that "kcfi-arity" module flag is added.
+//
+//@ add-core-stubs
+//@ revisions: x86_64
+//@ [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"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"kcfi-arity", i32 1}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-flag.rs b/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-flag.rs
new file mode 100644
index 00000000000..eabe0409c9a
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-flag.rs
@@ -0,0 +1,20 @@
+// Verifies that "kcfi" module flag is added.
+//
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components: x86
+//@ compile-flags: -Ctarget-feature=-crt-static -Zsanitizer=kcfi
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"kcfi", i32 1}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-offset-flag.rs b/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-offset-flag.rs
new file mode 100644
index 00000000000..2f18c9d84b9
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/add-kcfi-offset-flag.rs
@@ -0,0 +1,20 @@
+// Verifies that "kcfi-offset" module flag is added.
+//
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components: x86
+//@ compile-flags: -Ctarget-feature=-crt-static -Zsanitizer=kcfi -Z patchable-function-entry=4,3
+
+#![feature(no_core, lang_items, patchable_function_entry)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"kcfi-offset", i32 3}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs
new file mode 100644
index 00000000000..6b40918dd3a
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs
@@ -0,0 +1,27 @@
+// Verifies that KCFI operand bundles are omitted.
+//
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components:
+//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(no_core, no_sanitize, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_sanitize(kcfi)]
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: emit_kcfi_operand_bundle_attr_no_sanitize::foo
+    // CHECK:       Function Attrs: {{.*}}
+    // CHECK-LABEL: define{{.*}}foo{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       start:
+    // CHECK-NOT:   {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 {{[-0-9]+}}) ]
+    // CHECK:       ret i32 {{%.+}}
+    f(arg)
+}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs
new file mode 100644
index 00000000000..942b50deb02
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs
@@ -0,0 +1,41 @@
+// Verifies that generalized KCFI type metadata for functions are emitted.
+//
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components:
+//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Zsanitizer-cfi-generalize-pointers
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}foo
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE1:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 233085384) ]
+    f(arg)
+}
+
+pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}bar
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE2:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2){{.*}}[ "kcfi"(i32 435418021) ]
+    f(arg1, arg2)
+}
+
+pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}baz
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE3:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2, i32 {{(noundef )*}}%arg3){{.*}}[ "kcfi"(i32 -1003721339) ]
+    f(arg1, arg2, arg3)
+}
+
+// CHECK: ![[TYPE1]] = !{i32 -1741689296}
+// CHECK: ![[TYPE2]] = !{i32 489439372}
+// CHECK: ![[TYPE3]] = !{i32 2026563871}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs
new file mode 100644
index 00000000000..c89d9bdd121
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs
@@ -0,0 +1,41 @@
+// Verifies that normalized and generalized KCFI type metadata for functions are emitted.
+//
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components:
+//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Zsanitizer-cfi-normalize-integers -Zsanitizer-cfi-generalize-pointers
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}foo
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE1:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 -686570305) ]
+    f(arg)
+}
+
+pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}bar
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE2:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2){{.*}}[ "kcfi"(i32 1281038450) ]
+    f(arg1, arg2)
+}
+
+pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}baz
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE3:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2, i32 {{(noundef )*}}%arg3){{.*}}[ "kcfi"(i32 -1751512973) ]
+    f(arg1, arg2, arg3)
+}
+
+// CHECK: ![[TYPE1]] = !{i32 975484707}
+// CHECK: ![[TYPE2]] = !{i32 1658833102}
+// CHECK: ![[TYPE3]] = !{i32 230429758}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs
new file mode 100644
index 00000000000..220cae1a4fa
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs
@@ -0,0 +1,41 @@
+// Verifies that normalized KCFI type metadata for functions are emitted.
+//
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components:
+//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Zsanitizer-cfi-normalize-integers
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}foo
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE1:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 -841055669) ]
+    f(arg)
+}
+
+pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}bar
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE2:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2){{.*}}[ "kcfi"(i32 1390819368) ]
+    f(arg1, arg2)
+}
+
+pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}baz
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE3:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2, i32 {{(noundef )*}}%arg3){{.*}}[ "kcfi"(i32 586925835) ]
+    f(arg1, arg2, arg3)
+}
+
+// CHECK: ![[TYPE1]] = !{i32 -458317079}
+// CHECK: ![[TYPE2]] = !{i32 1737138182}
+// CHECK: ![[TYPE3]] = !{i32 197182412}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs
new file mode 100644
index 00000000000..bb9a0005903
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs
@@ -0,0 +1,41 @@
+// Verifies that KCFI type metadata for functions are emitted.
+//
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components:
+//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}foo
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE1:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 -1666898348) ]
+    f(arg)
+}
+
+pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}bar
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE2:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2){{.*}}[ "kcfi"(i32 -1789026986) ]
+    f(arg1, arg2)
+}
+
+pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}baz
+    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE3:[0-9]+]]
+    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2, i32 {{(noundef )*}}%arg3){{.*}}[ "kcfi"(i32 1248878270) ]
+    f(arg1, arg2, arg3)
+}
+
+// CHECK: ![[TYPE1]] = !{i32 653723426}
+// CHECK: ![[TYPE2]] = !{i32 412174924}
+// CHECK: ![[TYPE3]] = !{i32 -636668840}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle.rs b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle.rs
new file mode 100644
index 00000000000..8b844b99142
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/emit-kcfi-operand-bundle.rs
@@ -0,0 +1,24 @@
+// Verifies that KCFI operand bundles are emitted.
+//
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components:
+//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
+    // CHECK-LABEL: define{{.*}}foo{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       start:
+    // CHECK-NEXT:  {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 {{[-0-9]+}}) ]
+    // CHECK-NEXT:  ret i32 {{%.+}}
+    f(arg)
+}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/emit-type-metadata-trait-objects.rs b/tests/codegen-llvm/sanitizer/kcfi/emit-type-metadata-trait-objects.rs
new file mode 100644
index 00000000000..15c107bea15
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/emit-type-metadata-trait-objects.rs
@@ -0,0 +1,155 @@
+// Verifies that type metadata identifiers for trait objects are emitted correctly.
+//
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components:
+//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(arbitrary_self_types, no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub trait Trait1 {
+    fn foo(&self);
+}
+
+pub struct Type1;
+
+impl Trait1 for Type1 {
+    fn foo(&self) {}
+}
+
+pub trait Trait2<T> {
+    fn bar(&self);
+}
+
+pub struct Type2;
+
+impl Trait2<i32> for Type2 {
+    fn bar(&self) {}
+}
+
+pub trait Trait3<T> {
+    fn baz(&self, _: &T);
+}
+
+pub struct Type3;
+
+impl<T, U> Trait3<U> for T {
+    fn baz(&self, _: &U) {}
+}
+
+pub trait Trait4<'a, T> {
+    type Output: 'a;
+    fn qux(&self, _: &T) -> Self::Output;
+}
+
+pub struct Type4;
+
+impl<'a, T, U> Trait4<'a, U> for T {
+    type Output = &'a i32;
+    fn qux(&self, _: &U) -> Self::Output {
+        &0
+    }
+}
+
+pub trait Trait5<T, const N: usize> {
+    fn quux(&self, _: &[T; N]);
+}
+
+pub struct Type5;
+
+impl Copy for Type5 {}
+
+impl<T, U, const N: usize> Trait5<U, N> for T {
+    fn quux(&self, _: &[U; N]) {}
+}
+
+pub fn foo1(a: &dyn Trait1) {
+    a.foo();
+    // CHECK-LABEL: define{{.*}}4foo1{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE1:[[:print:]]+]]) ]
+}
+
+pub fn bar1() {
+    let a = Type1;
+    let b = &a as &dyn Trait1;
+    b.foo();
+    // CHECK-LABEL: define{{.*}}4bar1{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE1:[[:print:]]+]]) ]
+}
+
+pub fn foo2<T>(a: &dyn Trait2<T>) {
+    a.bar();
+    // CHECK-LABEL: define{{.*}}4foo2{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE2:[[:print:]]+]]) ]
+}
+
+pub fn bar2() {
+    let a = Type2;
+    foo2(&a);
+    let b = &a as &dyn Trait2<i32>;
+    b.bar();
+    // CHECK-LABEL: define{{.*}}4bar2{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE2:[[:print:]]+]]) ]
+}
+
+pub fn foo3(a: &dyn Trait3<Type3>) {
+    let b = Type3;
+    a.baz(&b);
+    // CHECK-LABEL: define{{.*}}4foo3{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}, ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE3:[[:print:]]+]]) ]
+}
+
+pub fn bar3() {
+    let a = Type3;
+    foo3(&a);
+    let b = &a as &dyn Trait3<Type3>;
+    b.baz(&a);
+    // CHECK-LABEL: define{{.*}}4bar3{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}, ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE3:[[:print:]]+]]) ]
+}
+
+pub fn foo4<'a>(a: &dyn Trait4<'a, Type4, Output = &'a i32>) {
+    let b = Type4;
+    a.qux(&b);
+    // CHECK-LABEL: define{{.*}}4foo4{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       call align 4 ptr %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}, ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE4:[[:print:]]+]]) ]
+}
+
+pub fn bar4<'a>() {
+    let a = Type4;
+    foo4(&a);
+    let b = &a as &dyn Trait4<'a, Type4, Output = &'a i32>;
+    b.qux(&a);
+    // CHECK-LABEL: define{{.*}}4bar4{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       call align 4 ptr %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}, ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE4:[[:print:]]+]]) ]
+}
+
+pub fn foo5(a: &dyn Trait5<Type5, 32>) {
+    let b = &[Type5; 32];
+    a.quux(&b);
+    // CHECK-LABEL: define{{.*}}4foo5{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z](\.0)*|%_[0-9]+]}}, ptr align 1 {{%[a-z](\.0)*|%_[0-9]+}}){{.*}}[ "kcfi"(i32 [[TYPE5:[[:print:]]+]]) ]
+}
+
+pub fn bar5() {
+    let a = &[Type5; 32];
+    foo5(&a);
+    let b = &a as &dyn Trait5<Type5, 32>;
+    b.quux(&a);
+    // CHECK-LABEL: define{{.*}}4bar5{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
+    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z](\.0)*|%_[0-9]+]}}, ptr align 1 {{%[a-z](\.0)*|%_[0-9]+}}){{.*}}[ "kcfi"(i32 [[TYPE5:[[:print:]]+]]) ]
+}
+
+// CHECK: !{{[0-9]+}} = !{i32 [[TYPE1]]}
+// CHECK: !{{[0-9]+}} = !{i32 [[TYPE2]]}
+// CHECK: !{{[0-9]+}} = !{i32 [[TYPE3]]}
+// CHECK: !{{[0-9]+}} = !{i32 [[TYPE4]]}
+// CHECK: !{{[0-9]+}} = !{i32 [[TYPE5]]}
diff --git a/tests/codegen-llvm/sanitizer/kcfi/naked-function.rs b/tests/codegen-llvm/sanitizer/kcfi/naked-function.rs
new file mode 100644
index 00000000000..2c8cdc919b8
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/kcfi/naked-function.rs
@@ -0,0 +1,47 @@
+//@ add-core-stubs
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components: x86
+//@ compile-flags: -Ctarget-feature=-crt-static -Zsanitizer=kcfi -Cno-prepopulate-passes -Copt-level=0
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+struct Thing;
+trait MyTrait {
+    #[unsafe(naked)]
+    extern "C" fn my_naked_function() {
+        // the real function is defined
+        // CHECK: .globl
+        // CHECK-SAME: my_naked_function
+        naked_asm!("ret")
+    }
+}
+impl MyTrait for Thing {}
+
+// the shim calls the real function
+// CHECK-LABEL: define
+// CHECK-SAME: my_naked_function
+// CHECK-SAME: reify.shim.fnptr
+
+// CHECK-LABEL: main
+#[unsafe(no_mangle)]
+pub fn main() {
+    // Trick the compiler into generating an indirect call.
+    const F: extern "C" fn() = Thing::my_naked_function;
+
+    // main calls the shim function
+    // CHECK: call void
+    // CHECK-SAME: my_naked_function
+    // CHECK-SAME: reify.shim.fnptr
+    (F)();
+}
+
+// CHECK: declare !kcfi_type
+// CHECK-SAME: my_naked_function
diff --git a/tests/codegen-llvm/sanitizer/memory-track-origins.rs b/tests/codegen-llvm/sanitizer/memory-track-origins.rs
new file mode 100644
index 00000000000..318c277e10c
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/memory-track-origins.rs
@@ -0,0 +1,31 @@
+// Verifies that MemorySanitizer track-origins level can be controlled
+// with -Zsanitizer-memory-track-origins option.
+//
+//@ needs-sanitizer-memory
+//@ revisions:MSAN-0 MSAN-1 MSAN-2 MSAN-1-LTO MSAN-2-LTO
+//
+//@ compile-flags: -Zsanitizer=memory -Ctarget-feature=-crt-static
+//@[MSAN-0] compile-flags:
+//@[MSAN-1] compile-flags: -Zsanitizer-memory-track-origins=1
+//@[MSAN-2] compile-flags: -Zsanitizer-memory-track-origins
+//@[MSAN-1-LTO] compile-flags: -Zsanitizer-memory-track-origins=1 -C lto=fat
+//@[MSAN-2-LTO] compile-flags: -Zsanitizer-memory-track-origins -C lto=fat
+
+#![crate_type = "lib"]
+
+// MSAN-0-NOT: @__msan_track_origins
+// MSAN-1:     @__msan_track_origins = weak_odr {{.*}}constant i32 1
+// MSAN-2:     @__msan_track_origins = weak_odr {{.*}}constant i32 2
+// MSAN-1-LTO: @__msan_track_origins = weak_odr {{.*}}constant i32 1
+// MSAN-2-LTO: @__msan_track_origins = weak_odr {{.*}}constant i32 2
+//
+// MSAN-0-LABEL: define void @copy(
+// MSAN-1-LABEL: define void @copy(
+// MSAN-2-LABEL: define void @copy(
+#[no_mangle]
+pub fn copy(dst: &mut i32, src: &i32) {
+    // MSAN-0-NOT: call i32 @__msan_chain_origin(
+    // MSAN-1-NOT: call i32 @__msan_chain_origin(
+    // MSAN-2:     call i32 @__msan_chain_origin(
+    *dst = *src;
+}
diff --git a/tests/codegen-llvm/sanitizer/memtag-attr-check.rs b/tests/codegen-llvm/sanitizer/memtag-attr-check.rs
new file mode 100644
index 00000000000..ffe3a2322a2
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/memtag-attr-check.rs
@@ -0,0 +1,12 @@
+// This tests that the sanitize_memtag attribute is
+// applied when enabling the memtag sanitizer.
+//
+//@ needs-sanitizer-memtag
+//@ compile-flags: -Zsanitizer=memtag -Ctarget-feature=+mte -Copt-level=0
+
+#![crate_type = "lib"]
+
+// CHECK: ; Function Attrs:{{.*}}sanitize_memtag
+pub fn tagged() {}
+
+// CHECK: attributes #0 = {{.*}}sanitize_memtag
diff --git a/tests/codegen-llvm/sanitizer/no-sanitize-inlining.rs b/tests/codegen-llvm/sanitizer/no-sanitize-inlining.rs
new file mode 100644
index 00000000000..4bd832d2ab1
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/no-sanitize-inlining.rs
@@ -0,0 +1,31 @@
+// Verifies that no_sanitize attribute prevents inlining when
+// given sanitizer is enabled, but has no effect on inlining otherwise.
+//
+//@ needs-sanitizer-address
+//@ needs-sanitizer-leak
+//@ revisions: ASAN LSAN
+//@       compile-flags: -Copt-level=3 -Zmir-opt-level=4 -Ctarget-feature=-crt-static
+//@[ASAN] compile-flags: -Zsanitizer=address
+//@[LSAN] compile-flags: -Zsanitizer=leak
+
+#![crate_type = "lib"]
+#![feature(no_sanitize)]
+
+// ASAN-LABEL: define void @test
+// ASAN:         call {{.*}} @random_inline
+// ASAN:       }
+//
+// LSAN-LABEL: define void @test
+// LSAN-NOT:     call
+// LSAN:       }
+#[no_mangle]
+pub fn test(n: &mut u32) {
+    random_inline(n);
+}
+
+#[no_sanitize(address)]
+#[inline]
+#[no_mangle]
+pub fn random_inline(n: &mut u32) {
+    *n = 42;
+}
diff --git a/tests/codegen-llvm/sanitizer/no-sanitize.rs b/tests/codegen-llvm/sanitizer/no-sanitize.rs
new file mode 100644
index 00000000000..2a309f6b9c6
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/no-sanitize.rs
@@ -0,0 +1,39 @@
+// Verifies that no_sanitize attribute can be used to
+// selectively disable sanitizer instrumentation.
+//
+//@ needs-sanitizer-address
+//@ compile-flags: -Zsanitizer=address -Ctarget-feature=-crt-static -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(no_sanitize)]
+
+// CHECK:     @UNSANITIZED = constant{{.*}} no_sanitize_address
+// CHECK-NOT: @__asan_global_UNSANITIZED
+#[no_mangle]
+#[no_sanitize(address)]
+pub static UNSANITIZED: u32 = 0;
+
+// CHECK: @__asan_global_SANITIZED
+#[no_mangle]
+pub static SANITIZED: u32 = 0;
+
+// CHECK-LABEL: ; no_sanitize::unsanitized
+// CHECK-NEXT:  ; Function Attrs:
+// CHECK-NOT:   sanitize_address
+// CHECK:       start:
+// CHECK-NOT:   call void @__asan_report_load
+// CHECK:       }
+#[no_sanitize(address)]
+pub fn unsanitized(b: &mut u8) -> u8 {
+    *b
+}
+
+// CHECK-LABEL: ; no_sanitize::sanitized
+// CHECK-NEXT:  ; Function Attrs:
+// CHECK:       sanitize_address
+// CHECK:       start:
+// CHECK:       call void @__asan_report_load
+// CHECK:       }
+pub fn sanitized(b: &mut u8) -> u8 {
+    *b
+}
diff --git a/tests/codegen-llvm/sanitizer/riscv64-shadow-call-stack.rs b/tests/codegen-llvm/sanitizer/riscv64-shadow-call-stack.rs
new file mode 100644
index 00000000000..945e46218d0
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/riscv64-shadow-call-stack.rs
@@ -0,0 +1,18 @@
+//@ add-core-stubs
+//@ compile-flags: --target riscv64imac-unknown-none-elf -Zsanitizer=shadow-call-stack
+//@ needs-llvm-components: riscv
+
+#![allow(internal_features)]
+#![crate_type = "rlib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// CHECK: ; Function Attrs:{{.*}}shadowcallstack
+// CHECK: define dso_local void @foo() unnamed_addr #0
+#[no_mangle]
+pub fn foo() {}
+
+// CHECK: attributes #0 = {{.*}}shadowcallstack{{.*}}
diff --git a/tests/codegen-llvm/sanitizer/safestack-attr-check.rs b/tests/codegen-llvm/sanitizer/safestack-attr-check.rs
new file mode 100644
index 00000000000..050a60333af
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/safestack-attr-check.rs
@@ -0,0 +1,11 @@
+// This tests that the safestack attribute is applied when enabling the safe-stack sanitizer.
+//
+//@ needs-sanitizer-safestack
+//@ compile-flags: -Zsanitizer=safestack -Copt-level=0
+
+#![crate_type = "lib"]
+
+// CHECK: ; Function Attrs:{{.*}}safestack
+pub fn tagged() {}
+
+// CHECK: attributes #0 = {{.*}}safestack
diff --git a/tests/codegen-llvm/sanitizer/sanitizer-recover.rs b/tests/codegen-llvm/sanitizer/sanitizer-recover.rs
new file mode 100644
index 00000000000..6b659320481
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/sanitizer-recover.rs
@@ -0,0 +1,50 @@
+// Verifies that AddressSanitizer and MemorySanitizer
+// recovery mode can be enabled with -Zsanitizer-recover.
+//
+//@ needs-sanitizer-address
+//@ needs-sanitizer-memory
+//@ revisions:ASAN ASAN-RECOVER MSAN MSAN-RECOVER MSAN-RECOVER-LTO
+//@ no-prefer-dynamic
+//
+//@                   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
+//@[MSAN]             compile-flags: -Zsanitizer=memory
+//@[MSAN-RECOVER]     compile-flags: -Zsanitizer=memory  -Zsanitizer-recover=memory
+//@[MSAN-RECOVER-LTO] compile-flags: -Zsanitizer=memory  -Zsanitizer-recover=memory -C lto=fat
+//
+// MSAN-NOT:         @__msan_keep_going
+// MSAN-RECOVER:     @__msan_keep_going = weak_odr {{.*}}constant i32 1
+// MSAN-RECOVER-LTO: @__msan_keep_going = weak_odr {{.*}}constant i32 1
+
+// ASAN-LABEL: define dso_local i32 @penguin(
+// ASAN:         call void @__asan_report_load4(i64 %0)
+// ASAN:         unreachable
+// ASAN:       }
+//
+// ASAN-RECOVER-LABEL: define dso_local i32 @penguin(
+// ASAN-RECOVER:         call void @__asan_report_load4_noabort(
+// ASAN-RECOVER-NOT:     unreachable
+// ASAN:               }
+//
+// MSAN-LABEL: define dso_local noundef i32 @penguin(
+// MSAN:         call void @__msan_warning{{(_with_origin_noreturn\(i32 0\)|_noreturn\(\))}}
+// MSAN:         unreachable
+// MSAN:       }
+//
+// MSAN-RECOVER-LABEL: define dso_local noundef i32 @penguin(
+// MSAN-RECOVER:         call void @__msan_warning{{(_with_origin\(i32 0\)|\(\))}}
+// MSAN-RECOVER-NOT:     unreachable
+// MSAN-RECOVER:       }
+//
+// MSAN-RECOVER-LTO-LABEL: define dso_local noundef i32 @penguin(
+// MSAN-RECOVER-LTO:          call void @__msan_warning{{(_with_origin\(i32 0\)|\(\))}}
+// MSAN-RECOVER-LTO-NOT:      unreachable
+// MSAN-RECOVER-LTO:       }
+//
+#[no_mangle]
+pub fn penguin(p: &mut i32) -> i32 {
+    *p
+}
+
+fn main() {}
diff --git a/tests/codegen-llvm/sanitizer/scs-attr-check.rs b/tests/codegen-llvm/sanitizer/scs-attr-check.rs
new file mode 100644
index 00000000000..6f4cbc2c0a6
--- /dev/null
+++ b/tests/codegen-llvm/sanitizer/scs-attr-check.rs
@@ -0,0 +1,17 @@
+// This tests that the shadowcallstack attribute is
+// applied when enabling the shadow-call-stack sanitizer.
+//
+//@ needs-sanitizer-shadow-call-stack
+//@ compile-flags: -Zsanitizer=shadow-call-stack
+
+#![crate_type = "lib"]
+#![feature(no_sanitize)]
+
+// CHECK: ; sanitizer_scs_attr_check::scs
+// CHECK-NEXT: ; Function Attrs:{{.*}}shadowcallstack
+pub fn scs() {}
+
+// CHECK: ; sanitizer_scs_attr_check::no_scs
+// CHECK-NOT: ; Function Attrs:{{.*}}shadowcallstack
+#[no_sanitize(shadow_call_stack)]
+pub fn no_scs() {}
diff --git a/tests/codegen-llvm/scalar-pair-bool.rs b/tests/codegen-llvm/scalar-pair-bool.rs
new file mode 100644
index 00000000000..def3b32f71a
--- /dev/null
+++ b/tests/codegen-llvm/scalar-pair-bool.rs
@@ -0,0 +1,45 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK: define{{.*}}{ i1, i1 } @pair_bool_bool(i1 noundef zeroext %pair.0, i1 noundef zeroext %pair.1)
+#[no_mangle]
+pub fn pair_bool_bool(pair: (bool, bool)) -> (bool, bool) {
+    pair
+}
+
+// CHECK: define{{.*}}{ i1, i32 } @pair_bool_i32(i1 noundef zeroext %pair.0, i32 noundef %pair.1)
+#[no_mangle]
+pub fn pair_bool_i32(pair: (bool, i32)) -> (bool, i32) {
+    pair
+}
+
+// CHECK: define{{.*}}{ i32, i1 } @pair_i32_bool(i32 noundef %pair.0, i1 noundef zeroext %pair.1)
+#[no_mangle]
+pub fn pair_i32_bool(pair: (i32, bool)) -> (i32, bool) {
+    pair
+}
+
+// CHECK: define{{.*}}{ i1, i1 } @pair_and_or(i1 noundef zeroext %_1.0, i1 noundef zeroext %_1.1)
+#[no_mangle]
+pub fn pair_and_or((a, b): (bool, bool)) -> (bool, bool) {
+    // Make sure it can operate directly on the unpacked args
+    // (but it might not be using simple and/or instructions)
+    // CHECK-DAG: %_1.0
+    // CHECK-DAG: %_1.1
+    (a && b, a || b)
+}
+
+// CHECK: define{{.*}}void @pair_branches(i1 noundef zeroext %_1.0, i1 noundef zeroext %_1.1)
+#[no_mangle]
+pub fn pair_branches((a, b): (bool, bool)) {
+    // Make sure it can branch directly on the unpacked bool args
+    // CHECK: br i1 %_1.0
+    if a {
+        println!("Hello!");
+    }
+    // CHECK: br i1 %_1.1
+    if b {
+        println!("Goodbye!");
+    }
+}
diff --git a/tests/codegen-llvm/set-discriminant-invalid.rs b/tests/codegen-llvm/set-discriminant-invalid.rs
new file mode 100644
index 00000000000..dd584ef1c14
--- /dev/null
+++ b/tests/codegen-llvm/set-discriminant-invalid.rs
@@ -0,0 +1,34 @@
+//@ compile-flags: -C opt-level=0
+#![crate_type = "lib"]
+
+pub enum ApiError {}
+#[allow(dead_code)]
+pub struct TokioError {
+    b: bool,
+}
+pub enum Error {
+    Api { source: ApiError },
+    Ethereum,
+    Tokio { source: TokioError },
+}
+struct Api;
+impl IntoError<Error> for Api {
+    type Source = ApiError;
+    // CHECK-LABEL: @into_error
+    // CHECK: llvm.trap()
+    // Also check the next instruction to make sure we do not match against `trap`
+    // elsewhere in the code.
+    // CHECK-NEXT: ret i8 poison
+    #[no_mangle]
+    fn into_error(self, error: Self::Source) -> Error {
+        Error::Api { source: error }
+    }
+}
+
+pub trait IntoError<E> {
+    /// The underlying error
+    type Source;
+
+    /// Combine the information to produce the error
+    fn into_error(self, source: Self::Source) -> E;
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-abs.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-abs.rs
new file mode 100644
index 00000000000..baf445d0a1b
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-abs.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_fabs;
+
+// CHECK-LABEL: @fabs_32x2
+#[no_mangle]
+pub unsafe fn fabs_32x2(a: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.fabs.v2f32
+    simd_fabs(a)
+}
+
+// CHECK-LABEL: @fabs_32x4
+#[no_mangle]
+pub unsafe fn fabs_32x4(a: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.fabs.v4f32
+    simd_fabs(a)
+}
+
+// CHECK-LABEL: @fabs_32x8
+#[no_mangle]
+pub unsafe fn fabs_32x8(a: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.fabs.v8f32
+    simd_fabs(a)
+}
+
+// CHECK-LABEL: @fabs_32x16
+#[no_mangle]
+pub unsafe fn fabs_32x16(a: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.fabs.v16f32
+    simd_fabs(a)
+}
+
+// CHECK-LABEL: @fabs_64x4
+#[no_mangle]
+pub unsafe fn fabs_64x4(a: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.fabs.v4f64
+    simd_fabs(a)
+}
+
+// CHECK-LABEL: @fabs_64x2
+#[no_mangle]
+pub unsafe fn fabs_64x2(a: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.fabs.v2f64
+    simd_fabs(a)
+}
+
+// CHECK-LABEL: @fabs_64x8
+#[no_mangle]
+pub unsafe fn fabs_64x8(a: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.fabs.v8f64
+    simd_fabs(a)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-ceil.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-ceil.rs
new file mode 100644
index 00000000000..096de569274
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-ceil.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_ceil;
+
+// CHECK-LABEL: @ceil_32x2
+#[no_mangle]
+pub unsafe fn ceil_32x2(a: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.ceil.v2f32
+    simd_ceil(a)
+}
+
+// CHECK-LABEL: @ceil_32x4
+#[no_mangle]
+pub unsafe fn ceil_32x4(a: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.ceil.v4f32
+    simd_ceil(a)
+}
+
+// CHECK-LABEL: @ceil_32x8
+#[no_mangle]
+pub unsafe fn ceil_32x8(a: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.ceil.v8f32
+    simd_ceil(a)
+}
+
+// CHECK-LABEL: @ceil_32x16
+#[no_mangle]
+pub unsafe fn ceil_32x16(a: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.ceil.v16f32
+    simd_ceil(a)
+}
+
+// CHECK-LABEL: @ceil_64x4
+#[no_mangle]
+pub unsafe fn ceil_64x4(a: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.ceil.v4f64
+    simd_ceil(a)
+}
+
+// CHECK-LABEL: @ceil_64x2
+#[no_mangle]
+pub unsafe fn ceil_64x2(a: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.ceil.v2f64
+    simd_ceil(a)
+}
+
+// CHECK-LABEL: @ceil_64x8
+#[no_mangle]
+pub unsafe fn ceil_64x8(a: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.ceil.v8f64
+    simd_ceil(a)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-cos.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-cos.rs
new file mode 100644
index 00000000000..5b2197924bc
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-cos.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_fcos;
+
+// CHECK-LABEL: @fcos_32x2
+#[no_mangle]
+pub unsafe fn fcos_32x2(a: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.cos.v2f32
+    simd_fcos(a)
+}
+
+// CHECK-LABEL: @fcos_32x4
+#[no_mangle]
+pub unsafe fn fcos_32x4(a: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.cos.v4f32
+    simd_fcos(a)
+}
+
+// CHECK-LABEL: @fcos_32x8
+#[no_mangle]
+pub unsafe fn fcos_32x8(a: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.cos.v8f32
+    simd_fcos(a)
+}
+
+// CHECK-LABEL: @fcos_32x16
+#[no_mangle]
+pub unsafe fn fcos_32x16(a: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.cos.v16f32
+    simd_fcos(a)
+}
+
+// CHECK-LABEL: @fcos_64x4
+#[no_mangle]
+pub unsafe fn fcos_64x4(a: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.cos.v4f64
+    simd_fcos(a)
+}
+
+// CHECK-LABEL: @fcos_64x2
+#[no_mangle]
+pub unsafe fn fcos_64x2(a: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.cos.v2f64
+    simd_fcos(a)
+}
+
+// CHECK-LABEL: @fcos_64x8
+#[no_mangle]
+pub unsafe fn fcos_64x8(a: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.cos.v8f64
+    simd_fcos(a)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-exp.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-exp.rs
new file mode 100644
index 00000000000..d4eadb36c65
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-exp.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_fexp;
+
+// CHECK-LABEL: @exp_32x2
+#[no_mangle]
+pub unsafe fn exp_32x2(a: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.exp.v2f32
+    simd_fexp(a)
+}
+
+// CHECK-LABEL: @exp_32x4
+#[no_mangle]
+pub unsafe fn exp_32x4(a: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.exp.v4f32
+    simd_fexp(a)
+}
+
+// CHECK-LABEL: @exp_32x8
+#[no_mangle]
+pub unsafe fn exp_32x8(a: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.exp.v8f32
+    simd_fexp(a)
+}
+
+// CHECK-LABEL: @exp_32x16
+#[no_mangle]
+pub unsafe fn exp_32x16(a: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.exp.v16f32
+    simd_fexp(a)
+}
+
+// CHECK-LABEL: @exp_64x4
+#[no_mangle]
+pub unsafe fn exp_64x4(a: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.exp.v4f64
+    simd_fexp(a)
+}
+
+// CHECK-LABEL: @exp_64x2
+#[no_mangle]
+pub unsafe fn exp_64x2(a: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.exp.v2f64
+    simd_fexp(a)
+}
+
+// CHECK-LABEL: @exp_64x8
+#[no_mangle]
+pub unsafe fn exp_64x8(a: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.exp.v8f64
+    simd_fexp(a)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-exp2.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-exp2.rs
new file mode 100644
index 00000000000..d32015b7990
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-exp2.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_fexp2;
+
+// CHECK-LABEL: @exp2_32x2
+#[no_mangle]
+pub unsafe fn exp2_32x2(a: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.exp2.v2f32
+    simd_fexp2(a)
+}
+
+// CHECK-LABEL: @exp2_32x4
+#[no_mangle]
+pub unsafe fn exp2_32x4(a: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.exp2.v4f32
+    simd_fexp2(a)
+}
+
+// CHECK-LABEL: @exp2_32x8
+#[no_mangle]
+pub unsafe fn exp2_32x8(a: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.exp2.v8f32
+    simd_fexp2(a)
+}
+
+// CHECK-LABEL: @exp2_32x16
+#[no_mangle]
+pub unsafe fn exp2_32x16(a: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.exp2.v16f32
+    simd_fexp2(a)
+}
+
+// CHECK-LABEL: @exp2_64x4
+#[no_mangle]
+pub unsafe fn exp2_64x4(a: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.exp2.v4f64
+    simd_fexp2(a)
+}
+
+// CHECK-LABEL: @exp2_64x2
+#[no_mangle]
+pub unsafe fn exp2_64x2(a: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.exp2.v2f64
+    simd_fexp2(a)
+}
+
+// CHECK-LABEL: @exp2_64x8
+#[no_mangle]
+pub unsafe fn exp2_64x8(a: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.exp2.v8f64
+    simd_fexp2(a)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-floor.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-floor.rs
new file mode 100644
index 00000000000..1e1c8ce0c35
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-floor.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_floor;
+
+// CHECK-LABEL: @floor_32x2
+#[no_mangle]
+pub unsafe fn floor_32x2(a: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.floor.v2f32
+    simd_floor(a)
+}
+
+// CHECK-LABEL: @floor_32x4
+#[no_mangle]
+pub unsafe fn floor_32x4(a: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.floor.v4f32
+    simd_floor(a)
+}
+
+// CHECK-LABEL: @floor_32x8
+#[no_mangle]
+pub unsafe fn floor_32x8(a: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.floor.v8f32
+    simd_floor(a)
+}
+
+// CHECK-LABEL: @floor_32x16
+#[no_mangle]
+pub unsafe fn floor_32x16(a: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.floor.v16f32
+    simd_floor(a)
+}
+
+// CHECK-LABEL: @floor_64x4
+#[no_mangle]
+pub unsafe fn floor_64x4(a: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.floor.v4f64
+    simd_floor(a)
+}
+
+// CHECK-LABEL: @floor_64x2
+#[no_mangle]
+pub unsafe fn floor_64x2(a: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.floor.v2f64
+    simd_floor(a)
+}
+
+// CHECK-LABEL: @floor_64x8
+#[no_mangle]
+pub unsafe fn floor_64x8(a: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.floor.v8f64
+    simd_floor(a)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-fma.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-fma.rs
new file mode 100644
index 00000000000..982077d81f9
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-fma.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_fma;
+
+// CHECK-LABEL: @fma_32x2
+#[no_mangle]
+pub unsafe fn fma_32x2(a: f32x2, b: f32x2, c: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.fma.v2f32
+    simd_fma(a, b, c)
+}
+
+// CHECK-LABEL: @fma_32x4
+#[no_mangle]
+pub unsafe fn fma_32x4(a: f32x4, b: f32x4, c: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.fma.v4f32
+    simd_fma(a, b, c)
+}
+
+// CHECK-LABEL: @fma_32x8
+#[no_mangle]
+pub unsafe fn fma_32x8(a: f32x8, b: f32x8, c: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.fma.v8f32
+    simd_fma(a, b, c)
+}
+
+// CHECK-LABEL: @fma_32x16
+#[no_mangle]
+pub unsafe fn fma_32x16(a: f32x16, b: f32x16, c: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.fma.v16f32
+    simd_fma(a, b, c)
+}
+
+// CHECK-LABEL: @fma_64x4
+#[no_mangle]
+pub unsafe fn fma_64x4(a: f64x4, b: f64x4, c: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.fma.v4f64
+    simd_fma(a, b, c)
+}
+
+// CHECK-LABEL: @fma_64x2
+#[no_mangle]
+pub unsafe fn fma_64x2(a: f64x2, b: f64x2, c: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.fma.v2f64
+    simd_fma(a, b, c)
+}
+
+// CHECK-LABEL: @fma_64x8
+#[no_mangle]
+pub unsafe fn fma_64x8(a: f64x8, b: f64x8, c: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.fma.v8f64
+    simd_fma(a, b, c)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-fsqrt.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
new file mode 100644
index 00000000000..e20a591f573
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_fsqrt;
+
+// CHECK-LABEL: @fsqrt_32x2
+#[no_mangle]
+pub unsafe fn fsqrt_32x2(a: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.sqrt.v2f32
+    simd_fsqrt(a)
+}
+
+// CHECK-LABEL: @fsqrt_32x4
+#[no_mangle]
+pub unsafe fn fsqrt_32x4(a: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.sqrt.v4f32
+    simd_fsqrt(a)
+}
+
+// CHECK-LABEL: @fsqrt_32x8
+#[no_mangle]
+pub unsafe fn fsqrt_32x8(a: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.sqrt.v8f32
+    simd_fsqrt(a)
+}
+
+// CHECK-LABEL: @fsqrt_32x16
+#[no_mangle]
+pub unsafe fn fsqrt_32x16(a: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.sqrt.v16f32
+    simd_fsqrt(a)
+}
+
+// CHECK-LABEL: @fsqrt_64x4
+#[no_mangle]
+pub unsafe fn fsqrt_64x4(a: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.sqrt.v4f64
+    simd_fsqrt(a)
+}
+
+// CHECK-LABEL: @fsqrt_64x2
+#[no_mangle]
+pub unsafe fn fsqrt_64x2(a: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.sqrt.v2f64
+    simd_fsqrt(a)
+}
+
+// CHECK-LABEL: @fsqrt_64x8
+#[no_mangle]
+pub unsafe fn fsqrt_64x8(a: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.sqrt.v8f64
+    simd_fsqrt(a)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log.rs
new file mode 100644
index 00000000000..bf1ffc76330
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_flog;
+
+// CHECK-LABEL: @log_32x2
+#[no_mangle]
+pub unsafe fn log_32x2(a: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.log.v2f32
+    simd_flog(a)
+}
+
+// CHECK-LABEL: @log_32x4
+#[no_mangle]
+pub unsafe fn log_32x4(a: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.log.v4f32
+    simd_flog(a)
+}
+
+// CHECK-LABEL: @log_32x8
+#[no_mangle]
+pub unsafe fn log_32x8(a: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.log.v8f32
+    simd_flog(a)
+}
+
+// CHECK-LABEL: @log_32x16
+#[no_mangle]
+pub unsafe fn log_32x16(a: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.log.v16f32
+    simd_flog(a)
+}
+
+// CHECK-LABEL: @log_64x4
+#[no_mangle]
+pub unsafe fn log_64x4(a: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.log.v4f64
+    simd_flog(a)
+}
+
+// CHECK-LABEL: @log_64x2
+#[no_mangle]
+pub unsafe fn log_64x2(a: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.log.v2f64
+    simd_flog(a)
+}
+
+// CHECK-LABEL: @log_64x8
+#[no_mangle]
+pub unsafe fn log_64x8(a: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.log.v8f64
+    simd_flog(a)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log10.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log10.rs
new file mode 100644
index 00000000000..ccf484e0e41
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log10.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_flog10;
+
+// CHECK-LABEL: @log10_32x2
+#[no_mangle]
+pub unsafe fn log10_32x2(a: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.log10.v2f32
+    simd_flog10(a)
+}
+
+// CHECK-LABEL: @log10_32x4
+#[no_mangle]
+pub unsafe fn log10_32x4(a: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.log10.v4f32
+    simd_flog10(a)
+}
+
+// CHECK-LABEL: @log10_32x8
+#[no_mangle]
+pub unsafe fn log10_32x8(a: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.log10.v8f32
+    simd_flog10(a)
+}
+
+// CHECK-LABEL: @log10_32x16
+#[no_mangle]
+pub unsafe fn log10_32x16(a: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.log10.v16f32
+    simd_flog10(a)
+}
+
+// CHECK-LABEL: @log10_64x4
+#[no_mangle]
+pub unsafe fn log10_64x4(a: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.log10.v4f64
+    simd_flog10(a)
+}
+
+// CHECK-LABEL: @log10_64x2
+#[no_mangle]
+pub unsafe fn log10_64x2(a: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.log10.v2f64
+    simd_flog10(a)
+}
+
+// CHECK-LABEL: @log10_64x8
+#[no_mangle]
+pub unsafe fn log10_64x8(a: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.log10.v8f64
+    simd_flog10(a)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log2.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log2.rs
new file mode 100644
index 00000000000..677d8b01e84
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-log2.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_flog2;
+
+// CHECK-LABEL: @log2_32x2
+#[no_mangle]
+pub unsafe fn log2_32x2(a: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.log2.v2f32
+    simd_flog2(a)
+}
+
+// CHECK-LABEL: @log2_32x4
+#[no_mangle]
+pub unsafe fn log2_32x4(a: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.log2.v4f32
+    simd_flog2(a)
+}
+
+// CHECK-LABEL: @log2_32x8
+#[no_mangle]
+pub unsafe fn log2_32x8(a: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.log2.v8f32
+    simd_flog2(a)
+}
+
+// CHECK-LABEL: @log2_32x16
+#[no_mangle]
+pub unsafe fn log2_32x16(a: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.log2.v16f32
+    simd_flog2(a)
+}
+
+// CHECK-LABEL: @log2_64x4
+#[no_mangle]
+pub unsafe fn log2_64x4(a: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.log2.v4f64
+    simd_flog2(a)
+}
+
+// CHECK-LABEL: @log2_64x2
+#[no_mangle]
+pub unsafe fn log2_64x2(a: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.log2.v2f64
+    simd_flog2(a)
+}
+
+// CHECK-LABEL: @log2_64x8
+#[no_mangle]
+pub unsafe fn log2_64x8(a: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.log2.v8f64
+    simd_flog2(a)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-minmax.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-minmax.rs
new file mode 100644
index 00000000000..8dd464a1bff
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-minmax.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::{simd_fmax, simd_fmin};
+
+// 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-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)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-sin.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-sin.rs
new file mode 100644
index 00000000000..48becc72c0b
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-float-sin.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_fsin;
+
+// CHECK-LABEL: @fsin_32x2
+#[no_mangle]
+pub unsafe fn fsin_32x2(a: f32x2) -> f32x2 {
+    // CHECK: call <2 x float> @llvm.sin.v2f32
+    simd_fsin(a)
+}
+
+// CHECK-LABEL: @fsin_32x4
+#[no_mangle]
+pub unsafe fn fsin_32x4(a: f32x4) -> f32x4 {
+    // CHECK: call <4 x float> @llvm.sin.v4f32
+    simd_fsin(a)
+}
+
+// CHECK-LABEL: @fsin_32x8
+#[no_mangle]
+pub unsafe fn fsin_32x8(a: f32x8) -> f32x8 {
+    // CHECK: call <8 x float> @llvm.sin.v8f32
+    simd_fsin(a)
+}
+
+// CHECK-LABEL: @fsin_32x16
+#[no_mangle]
+pub unsafe fn fsin_32x16(a: f32x16) -> f32x16 {
+    // CHECK: call <16 x float> @llvm.sin.v16f32
+    simd_fsin(a)
+}
+
+// CHECK-LABEL: @fsin_64x4
+#[no_mangle]
+pub unsafe fn fsin_64x4(a: f64x4) -> f64x4 {
+    // CHECK: call <4 x double> @llvm.sin.v4f64
+    simd_fsin(a)
+}
+
+// CHECK-LABEL: @fsin_64x2
+#[no_mangle]
+pub unsafe fn fsin_64x2(a: f64x2) -> f64x2 {
+    // CHECK: call <2 x double> @llvm.sin.v2f64
+    simd_fsin(a)
+}
+
+// CHECK-LABEL: @fsin_64x8
+#[no_mangle]
+pub unsafe fn fsin_64x8(a: f64x8) -> f64x8 {
+    // CHECK: call <8 x double> @llvm.sin.v8f64
+    simd_fsin(a)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
new file mode 100644
index 00000000000..06d46889715
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
@@ -0,0 +1,579 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+#![deny(unused)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
+
+// NOTE(eddyb) `%{{x|0}}` is used because on some targets (e.g. WASM)
+// SIMD vectors are passed directly, resulting in `%x` being a vector,
+// while on others they're passed indirectly, resulting in `%x` being
+// a pointer to a vector, and `%0` a vector loaded from that pointer.
+// This is controlled by the target spec option `simd_types_indirect`.
+// The same applies to `%{{y|1}}` as well.
+
+// CHECK-LABEL: @sadd_i8x2
+#[no_mangle]
+pub unsafe fn sadd_i8x2(x: i8x2, y: i8x2) -> i8x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %{{x|0}}, <2 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i8x4
+#[no_mangle]
+pub unsafe fn sadd_i8x4(x: i8x4, y: i8x4) -> i8x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.sadd.sat.v4i8(<4 x i8> %{{x|0}}, <4 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i8x8
+#[no_mangle]
+pub unsafe fn sadd_i8x8(x: i8x8, y: i8x8) -> i8x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.sadd.sat.v8i8(<8 x i8> %{{x|0}}, <8 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i8x16
+#[no_mangle]
+pub unsafe fn sadd_i8x16(x: i8x16, y: i8x16) -> i8x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.sadd.sat.v16i8(<16 x i8> %{{x|0}}, <16 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i8x32
+#[no_mangle]
+pub unsafe fn sadd_i8x32(x: i8x32, y: i8x32) -> i8x32 {
+    // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.sadd.sat.v32i8(<32 x i8> %{{x|0}}, <32 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i8x64
+#[no_mangle]
+pub unsafe fn sadd_i8x64(x: i8x64, y: i8x64) -> i8x64 {
+    // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.sadd.sat.v64i8(<64 x i8> %{{x|0}}, <64 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i16x2
+#[no_mangle]
+pub unsafe fn sadd_i16x2(x: i16x2, y: i16x2) -> i16x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.sadd.sat.v2i16(<2 x i16> %{{x|0}}, <2 x i16> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i16x4
+#[no_mangle]
+pub unsafe fn sadd_i16x4(x: i16x4, y: i16x4) -> i16x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.sadd.sat.v4i16(<4 x i16> %{{x|0}}, <4 x i16> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i16x8
+#[no_mangle]
+pub unsafe fn sadd_i16x8(x: i16x8, y: i16x8) -> i16x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.sadd.sat.v8i16(<8 x i16> %{{x|0}}, <8 x i16> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i16x16
+#[no_mangle]
+pub unsafe fn sadd_i16x16(x: i16x16, y: i16x16) -> i16x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.sadd.sat.v16i16(<16 x i16> %{{x|0}}, <16 x i16> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i16x32
+#[no_mangle]
+pub unsafe fn sadd_i16x32(x: i16x32, y: i16x32) -> i16x32 {
+    // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.sadd.sat.v32i16(<32 x i16> %{{x|0}}, <32 x i16> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i32x2
+#[no_mangle]
+pub unsafe fn sadd_i32x2(x: i32x2, y: i32x2) -> i32x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.sadd.sat.v2i32(<2 x i32> %{{x|0}}, <2 x i32> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i32x4
+#[no_mangle]
+pub unsafe fn sadd_i32x4(x: i32x4, y: i32x4) -> i32x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.sadd.sat.v4i32(<4 x i32> %{{x|0}}, <4 x i32> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i32x8
+#[no_mangle]
+pub unsafe fn sadd_i32x8(x: i32x8, y: i32x8) -> i32x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.sadd.sat.v8i32(<8 x i32> %{{x|0}}, <8 x i32> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i32x16
+#[no_mangle]
+pub unsafe fn sadd_i32x16(x: i32x16, y: i32x16) -> i32x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.sadd.sat.v16i32(<16 x i32> %{{x|0}}, <16 x i32> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i64x2
+#[no_mangle]
+pub unsafe fn sadd_i64x2(x: i64x2, y: i64x2) -> i64x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.sadd.sat.v2i64(<2 x i64> %{{x|0}}, <2 x i64> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i64x4
+#[no_mangle]
+pub unsafe fn sadd_i64x4(x: i64x4, y: i64x4) -> i64x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.sadd.sat.v4i64(<4 x i64> %{{x|0}}, <4 x i64> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i64x8
+#[no_mangle]
+pub unsafe fn sadd_i64x8(x: i64x8, y: i64x8) -> i64x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.sadd.sat.v8i64(<8 x i64> %{{x|0}}, <8 x i64> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i128x2
+#[no_mangle]
+pub unsafe fn sadd_i128x2(x: i128x2, y: i128x2) -> i128x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.sadd.sat.v2i128(<2 x i128> %{{x|0}}, <2 x i128> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @sadd_i128x4
+#[no_mangle]
+pub unsafe fn sadd_i128x4(x: i128x4, y: i128x4) -> i128x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.sadd.sat.v4i128(<4 x i128> %{{x|0}}, <4 x i128> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u8x2
+#[no_mangle]
+pub unsafe fn uadd_u8x2(x: u8x2, y: u8x2) -> u8x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %{{x|0}}, <2 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u8x4
+#[no_mangle]
+pub unsafe fn uadd_u8x4(x: u8x4, y: u8x4) -> u8x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.uadd.sat.v4i8(<4 x i8> %{{x|0}}, <4 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u8x8
+#[no_mangle]
+pub unsafe fn uadd_u8x8(x: u8x8, y: u8x8) -> u8x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.uadd.sat.v8i8(<8 x i8> %{{x|0}}, <8 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u8x16
+#[no_mangle]
+pub unsafe fn uadd_u8x16(x: u8x16, y: u8x16) -> u8x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.uadd.sat.v16i8(<16 x i8> %{{x|0}}, <16 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u8x32
+#[no_mangle]
+pub unsafe fn uadd_u8x32(x: u8x32, y: u8x32) -> u8x32 {
+    // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.uadd.sat.v32i8(<32 x i8> %{{x|0}}, <32 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u8x64
+#[no_mangle]
+pub unsafe fn uadd_u8x64(x: u8x64, y: u8x64) -> u8x64 {
+    // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.uadd.sat.v64i8(<64 x i8> %{{x|0}}, <64 x i8> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u16x2
+#[no_mangle]
+pub unsafe fn uadd_u16x2(x: u16x2, y: u16x2) -> u16x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.uadd.sat.v2i16(<2 x i16> %{{x|0}}, <2 x i16> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u16x4
+#[no_mangle]
+pub unsafe fn uadd_u16x4(x: u16x4, y: u16x4) -> u16x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.uadd.sat.v4i16(<4 x i16> %{{x|0}}, <4 x i16> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u16x8
+#[no_mangle]
+pub unsafe fn uadd_u16x8(x: u16x8, y: u16x8) -> u16x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.uadd.sat.v8i16(<8 x i16> %{{x|0}}, <8 x i16> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u16x16
+#[no_mangle]
+pub unsafe fn uadd_u16x16(x: u16x16, y: u16x16) -> u16x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.uadd.sat.v16i16(<16 x i16> %{{x|0}}, <16 x i16> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u16x32
+#[no_mangle]
+pub unsafe fn uadd_u16x32(x: u16x32, y: u16x32) -> u16x32 {
+    // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.uadd.sat.v32i16(<32 x i16> %{{x|0}}, <32 x i16> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u32x2
+#[no_mangle]
+pub unsafe fn uadd_u32x2(x: u32x2, y: u32x2) -> u32x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.uadd.sat.v2i32(<2 x i32> %{{x|0}}, <2 x i32> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u32x4
+#[no_mangle]
+pub unsafe fn uadd_u32x4(x: u32x4, y: u32x4) -> u32x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.uadd.sat.v4i32(<4 x i32> %{{x|0}}, <4 x i32> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u32x8
+#[no_mangle]
+pub unsafe fn uadd_u32x8(x: u32x8, y: u32x8) -> u32x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.uadd.sat.v8i32(<8 x i32> %{{x|0}}, <8 x i32> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u32x16
+#[no_mangle]
+pub unsafe fn uadd_u32x16(x: u32x16, y: u32x16) -> u32x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.uadd.sat.v16i32(<16 x i32> %{{x|0}}, <16 x i32> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u64x2
+#[no_mangle]
+pub unsafe fn uadd_u64x2(x: u64x2, y: u64x2) -> u64x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.uadd.sat.v2i64(<2 x i64> %{{x|0}}, <2 x i64> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u64x4
+#[no_mangle]
+pub unsafe fn uadd_u64x4(x: u64x4, y: u64x4) -> u64x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.uadd.sat.v4i64(<4 x i64> %{{x|0}}, <4 x i64> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u64x8
+#[no_mangle]
+pub unsafe fn uadd_u64x8(x: u64x8, y: u64x8) -> u64x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.uadd.sat.v8i64(<8 x i64> %{{x|0}}, <8 x i64> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u128x2
+#[no_mangle]
+pub unsafe fn uadd_u128x2(x: u128x2, y: u128x2) -> u128x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.uadd.sat.v2i128(<2 x i128> %{{x|0}}, <2 x i128> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @uadd_u128x4
+#[no_mangle]
+pub unsafe fn uadd_u128x4(x: u128x4, y: u128x4) -> u128x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.uadd.sat.v4i128(<4 x i128> %{{x|0}}, <4 x i128> %{{y|1}})
+    simd_saturating_add(x, y)
+}
+
+// CHECK-LABEL: @ssub_i8x2
+#[no_mangle]
+pub unsafe fn ssub_i8x2(x: i8x2, y: i8x2) -> i8x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %{{x|0}}, <2 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i8x4
+#[no_mangle]
+pub unsafe fn ssub_i8x4(x: i8x4, y: i8x4) -> i8x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.ssub.sat.v4i8(<4 x i8> %{{x|0}}, <4 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i8x8
+#[no_mangle]
+pub unsafe fn ssub_i8x8(x: i8x8, y: i8x8) -> i8x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.ssub.sat.v8i8(<8 x i8> %{{x|0}}, <8 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i8x16
+#[no_mangle]
+pub unsafe fn ssub_i8x16(x: i8x16, y: i8x16) -> i8x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.ssub.sat.v16i8(<16 x i8> %{{x|0}}, <16 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i8x32
+#[no_mangle]
+pub unsafe fn ssub_i8x32(x: i8x32, y: i8x32) -> i8x32 {
+    // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.ssub.sat.v32i8(<32 x i8> %{{x|0}}, <32 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i8x64
+#[no_mangle]
+pub unsafe fn ssub_i8x64(x: i8x64, y: i8x64) -> i8x64 {
+    // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.ssub.sat.v64i8(<64 x i8> %{{x|0}}, <64 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i16x2
+#[no_mangle]
+pub unsafe fn ssub_i16x2(x: i16x2, y: i16x2) -> i16x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.ssub.sat.v2i16(<2 x i16> %{{x|0}}, <2 x i16> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i16x4
+#[no_mangle]
+pub unsafe fn ssub_i16x4(x: i16x4, y: i16x4) -> i16x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.ssub.sat.v4i16(<4 x i16> %{{x|0}}, <4 x i16> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i16x8
+#[no_mangle]
+pub unsafe fn ssub_i16x8(x: i16x8, y: i16x8) -> i16x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.ssub.sat.v8i16(<8 x i16> %{{x|0}}, <8 x i16> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i16x16
+#[no_mangle]
+pub unsafe fn ssub_i16x16(x: i16x16, y: i16x16) -> i16x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.ssub.sat.v16i16(<16 x i16> %{{x|0}}, <16 x i16> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i16x32
+#[no_mangle]
+pub unsafe fn ssub_i16x32(x: i16x32, y: i16x32) -> i16x32 {
+    // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.ssub.sat.v32i16(<32 x i16> %{{x|0}}, <32 x i16> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i32x2
+#[no_mangle]
+pub unsafe fn ssub_i32x2(x: i32x2, y: i32x2) -> i32x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.ssub.sat.v2i32(<2 x i32> %{{x|0}}, <2 x i32> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i32x4
+#[no_mangle]
+pub unsafe fn ssub_i32x4(x: i32x4, y: i32x4) -> i32x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.ssub.sat.v4i32(<4 x i32> %{{x|0}}, <4 x i32> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i32x8
+#[no_mangle]
+pub unsafe fn ssub_i32x8(x: i32x8, y: i32x8) -> i32x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.ssub.sat.v8i32(<8 x i32> %{{x|0}}, <8 x i32> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i32x16
+#[no_mangle]
+pub unsafe fn ssub_i32x16(x: i32x16, y: i32x16) -> i32x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.ssub.sat.v16i32(<16 x i32> %{{x|0}}, <16 x i32> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i64x2
+#[no_mangle]
+pub unsafe fn ssub_i64x2(x: i64x2, y: i64x2) -> i64x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.ssub.sat.v2i64(<2 x i64> %{{x|0}}, <2 x i64> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i64x4
+#[no_mangle]
+pub unsafe fn ssub_i64x4(x: i64x4, y: i64x4) -> i64x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.ssub.sat.v4i64(<4 x i64> %{{x|0}}, <4 x i64> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i64x8
+#[no_mangle]
+pub unsafe fn ssub_i64x8(x: i64x8, y: i64x8) -> i64x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.ssub.sat.v8i64(<8 x i64> %{{x|0}}, <8 x i64> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i128x2
+#[no_mangle]
+pub unsafe fn ssub_i128x2(x: i128x2, y: i128x2) -> i128x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.ssub.sat.v2i128(<2 x i128> %{{x|0}}, <2 x i128> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @ssub_i128x4
+#[no_mangle]
+pub unsafe fn ssub_i128x4(x: i128x4, y: i128x4) -> i128x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.ssub.sat.v4i128(<4 x i128> %{{x|0}}, <4 x i128> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u8x2
+#[no_mangle]
+pub unsafe fn usub_u8x2(x: u8x2, y: u8x2) -> u8x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %{{x|0}}, <2 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u8x4
+#[no_mangle]
+pub unsafe fn usub_u8x4(x: u8x4, y: u8x4) -> u8x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.usub.sat.v4i8(<4 x i8> %{{x|0}}, <4 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u8x8
+#[no_mangle]
+pub unsafe fn usub_u8x8(x: u8x8, y: u8x8) -> u8x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.usub.sat.v8i8(<8 x i8> %{{x|0}}, <8 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u8x16
+#[no_mangle]
+pub unsafe fn usub_u8x16(x: u8x16, y: u8x16) -> u8x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.usub.sat.v16i8(<16 x i8> %{{x|0}}, <16 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u8x32
+#[no_mangle]
+pub unsafe fn usub_u8x32(x: u8x32, y: u8x32) -> u8x32 {
+    // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.usub.sat.v32i8(<32 x i8> %{{x|0}}, <32 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u8x64
+#[no_mangle]
+pub unsafe fn usub_u8x64(x: u8x64, y: u8x64) -> u8x64 {
+    // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.usub.sat.v64i8(<64 x i8> %{{x|0}}, <64 x i8> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u16x2
+#[no_mangle]
+pub unsafe fn usub_u16x2(x: u16x2, y: u16x2) -> u16x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.usub.sat.v2i16(<2 x i16> %{{x|0}}, <2 x i16> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u16x4
+#[no_mangle]
+pub unsafe fn usub_u16x4(x: u16x4, y: u16x4) -> u16x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.usub.sat.v4i16(<4 x i16> %{{x|0}}, <4 x i16> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u16x8
+#[no_mangle]
+pub unsafe fn usub_u16x8(x: u16x8, y: u16x8) -> u16x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.usub.sat.v8i16(<8 x i16> %{{x|0}}, <8 x i16> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u16x16
+#[no_mangle]
+pub unsafe fn usub_u16x16(x: u16x16, y: u16x16) -> u16x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.usub.sat.v16i16(<16 x i16> %{{x|0}}, <16 x i16> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u16x32
+#[no_mangle]
+pub unsafe fn usub_u16x32(x: u16x32, y: u16x32) -> u16x32 {
+    // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.usub.sat.v32i16(<32 x i16> %{{x|0}}, <32 x i16> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u32x2
+#[no_mangle]
+pub unsafe fn usub_u32x2(x: u32x2, y: u32x2) -> u32x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.usub.sat.v2i32(<2 x i32> %{{x|0}}, <2 x i32> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u32x4
+#[no_mangle]
+pub unsafe fn usub_u32x4(x: u32x4, y: u32x4) -> u32x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.usub.sat.v4i32(<4 x i32> %{{x|0}}, <4 x i32> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u32x8
+#[no_mangle]
+pub unsafe fn usub_u32x8(x: u32x8, y: u32x8) -> u32x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.usub.sat.v8i32(<8 x i32> %{{x|0}}, <8 x i32> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u32x16
+#[no_mangle]
+pub unsafe fn usub_u32x16(x: u32x16, y: u32x16) -> u32x16 {
+    // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.usub.sat.v16i32(<16 x i32> %{{x|0}}, <16 x i32> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u64x2
+#[no_mangle]
+pub unsafe fn usub_u64x2(x: u64x2, y: u64x2) -> u64x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.usub.sat.v2i64(<2 x i64> %{{x|0}}, <2 x i64> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u64x4
+#[no_mangle]
+pub unsafe fn usub_u64x4(x: u64x4, y: u64x4) -> u64x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.usub.sat.v4i64(<4 x i64> %{{x|0}}, <4 x i64> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u64x8
+#[no_mangle]
+pub unsafe fn usub_u64x8(x: u64x8, y: u64x8) -> u64x8 {
+    // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.usub.sat.v8i64(<8 x i64> %{{x|0}}, <8 x i64> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u128x2
+#[no_mangle]
+pub unsafe fn usub_u128x2(x: u128x2, y: u128x2) -> u128x2 {
+    // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.usub.sat.v2i128(<2 x i128> %{{x|0}}, <2 x i128> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
+
+// CHECK-LABEL: @usub_u128x4
+#[no_mangle]
+pub unsafe fn usub_u128x4(x: u128x4, y: u128x4) -> u128x4 {
+    // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.usub.sat.v4i128(<4 x i128> %{{x|0}}, <4 x i128> %{{y|1}})
+    simd_saturating_sub(x, y)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-bitmask.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
new file mode 100644
index 00000000000..294262d8152
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
@@ -0,0 +1,48 @@
+//@ compile-flags: -C no-prepopulate-passes
+//
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_bitmask;
+
+// NOTE(eddyb) `%{{x|1}}` is used because on some targets (e.g. WASM)
+// SIMD vectors are passed directly, resulting in `%x` being a vector,
+// while on others they're passed indirectly, resulting in `%x` being
+// a pointer to a vector, and `%1` a vector loaded from that pointer.
+// This is controlled by the target spec option `simd_types_indirect`.
+
+// CHECK-LABEL: @bitmask_int
+#[no_mangle]
+pub unsafe fn bitmask_int(x: i32x2) -> u8 {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{x|1}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: [[C:%[0-9]+]] = bitcast <2 x i1> [[B]] to i2
+    // CHECK: %{{[0-9]+}} = zext i2 [[C]] to i8
+    simd_bitmask(x)
+}
+
+// CHECK-LABEL: @bitmask_uint
+#[no_mangle]
+pub unsafe fn bitmask_uint(x: u32x2) -> u8 {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{x|1}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: [[C:%[0-9]+]] = bitcast <2 x i1> [[B]] to i2
+    // CHECK: %{{[0-9]+}} = zext i2 [[C]] to i8
+    simd_bitmask(x)
+}
+
+// CHECK-LABEL: @bitmask_int16
+#[no_mangle]
+pub unsafe fn bitmask_int16(x: i8x16) -> u16 {
+    // CHECK: [[A:%[0-9]+]] = lshr <16 x i8> %{{x|1|2}}, {{<i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>|splat \(i8 7\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <16 x i8> [[A]] to <16 x i1>
+    // CHECK: %{{[0-9]+}} = bitcast <16 x i1> [[B]] to i16
+    // CHECK-NOT: zext
+    simd_bitmask(x)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-gather.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-gather.rs
new file mode 100644
index 00000000000..690bfb432f9
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-gather.rs
@@ -0,0 +1,55 @@
+//
+
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_gather;
+
+pub type Vec2<T> = Simd<T, 2>;
+pub type Vec4<T> = Simd<T, 4>;
+
+// CHECK-LABEL: @gather_f32x2
+#[no_mangle]
+pub unsafe fn gather_f32x2(
+    pointers: Vec2<*const f32>,
+    mask: Vec2<i32>,
+    values: Vec2<f32>,
+) -> Vec2<f32> {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: call <2 x float> @llvm.masked.gather.v2f32.v2p0(<2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]], <2 x float> {{.*}})
+    simd_gather(values, pointers, mask)
+}
+
+// CHECK-LABEL: @gather_f32x2_unsigned
+#[no_mangle]
+pub unsafe fn gather_f32x2_unsigned(
+    pointers: Vec2<*const f32>,
+    mask: Vec2<u32>,
+    values: Vec2<f32>,
+) -> Vec2<f32> {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: call <2 x float> @llvm.masked.gather.v2f32.v2p0(<2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]], <2 x float> {{.*}})
+    simd_gather(values, pointers, mask)
+}
+
+// CHECK-LABEL: @gather_pf32x2
+#[no_mangle]
+pub unsafe fn gather_pf32x2(
+    pointers: Vec2<*const *const f32>,
+    mask: Vec2<i32>,
+    values: Vec2<*const f32>,
+) -> Vec2<*const f32> {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: call <2 x ptr> @llvm.masked.gather.v2p0.v2p0(<2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]], <2 x ptr> {{.*}})
+    simd_gather(values, pointers, mask)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-masked-load.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
new file mode 100644
index 00000000000..fda315dc66c
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
@@ -0,0 +1,49 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_masked_load;
+
+pub type Vec2<T> = Simd<T, 2>;
+pub type Vec4<T> = Simd<T, 4>;
+
+// CHECK-LABEL: @load_f32x2
+#[no_mangle]
+pub unsafe fn load_f32x2(mask: Vec2<i32>, pointer: *const f32, values: Vec2<f32>) -> Vec2<f32> {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: call <2 x float> @llvm.masked.load.v2f32.p0(ptr {{.*}}, i32 4, <2 x i1> [[B]], <2 x float> {{.*}})
+    simd_masked_load(mask, pointer, values)
+}
+
+// CHECK-LABEL: @load_f32x2_unsigned
+#[no_mangle]
+pub unsafe fn load_f32x2_unsigned(
+    mask: Vec2<u32>,
+    pointer: *const f32,
+    values: Vec2<f32>,
+) -> Vec2<f32> {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: call <2 x float> @llvm.masked.load.v2f32.p0(ptr {{.*}}, i32 4, <2 x i1> [[B]], <2 x float> {{.*}})
+    simd_masked_load(mask, pointer, values)
+}
+
+// CHECK-LABEL: @load_pf32x4
+#[no_mangle]
+pub unsafe fn load_pf32x4(
+    mask: Vec4<i32>,
+    pointer: *const *const f32,
+    values: Vec4<*const f32>,
+) -> Vec4<*const f32> {
+    // CHECK: [[A:%[0-9]+]] = lshr <4 x i32> {{.*}}, {{<i32 31, i32 31, i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <4 x i32> [[A]] to <4 x i1>
+    // CHECK: call <4 x ptr> @llvm.masked.load.v4p0.p0(ptr {{.*}}, i32 {{.*}}, <4 x i1> [[B]], <4 x ptr> {{.*}})
+    simd_masked_load(mask, pointer, values)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-masked-store.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
new file mode 100644
index 00000000000..6ca7388d464
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
@@ -0,0 +1,41 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_masked_store;
+
+pub type Vec2<T> = Simd<T, 2>;
+pub type Vec4<T> = Simd<T, 4>;
+
+// CHECK-LABEL: @store_f32x2
+#[no_mangle]
+pub unsafe fn store_f32x2(mask: Vec2<i32>, pointer: *mut f32, values: Vec2<f32>) {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: call void @llvm.masked.store.v2f32.p0(<2 x float> {{.*}}, ptr {{.*}}, i32 4, <2 x i1> [[B]])
+    simd_masked_store(mask, pointer, values)
+}
+
+// CHECK-LABEL: @store_f32x2_unsigned
+#[no_mangle]
+pub unsafe fn store_f32x2_unsigned(mask: Vec2<u32>, pointer: *mut f32, values: Vec2<f32>) {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: call void @llvm.masked.store.v2f32.p0(<2 x float> {{.*}}, ptr {{.*}}, i32 4, <2 x i1> [[B]])
+    simd_masked_store(mask, pointer, values)
+}
+
+// CHECK-LABEL: @store_pf32x4
+#[no_mangle]
+pub unsafe fn store_pf32x4(mask: Vec4<i32>, pointer: *mut *const f32, values: Vec4<*const f32>) {
+    // CHECK: [[A:%[0-9]+]] = lshr <4 x i32> {{.*}}, {{<i32 31, i32 31, i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <4 x i32> [[A]] to <4 x i1>
+    // CHECK: call void @llvm.masked.store.v4p0.p0(<4 x ptr> {{.*}}, ptr {{.*}}, i32 {{.*}}, <4 x i1> [[B]])
+    simd_masked_store(mask, pointer, values)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-scatter.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-scatter.rs
new file mode 100644
index 00000000000..743652966e1
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-scatter.rs
@@ -0,0 +1,47 @@
+//
+
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::simd_scatter;
+
+pub type Vec2<T> = Simd<T, 2>;
+pub type Vec4<T> = Simd<T, 4>;
+
+// CHECK-LABEL: @scatter_f32x2
+#[no_mangle]
+pub unsafe fn scatter_f32x2(pointers: Vec2<*mut f32>, mask: Vec2<i32>, values: Vec2<f32>) {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: call void @llvm.masked.scatter.v2f32.v2p0(<2 x float> {{.*}}, <2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]]
+    simd_scatter(values, pointers, mask)
+}
+
+// CHECK-LABEL: @scatter_f32x2_unsigned
+#[no_mangle]
+pub unsafe fn scatter_f32x2_unsigned(pointers: Vec2<*mut f32>, mask: Vec2<u32>, values: Vec2<f32>) {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: call void @llvm.masked.scatter.v2f32.v2p0(<2 x float> {{.*}}, <2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]]
+    simd_scatter(values, pointers, mask)
+}
+
+// CHECK-LABEL: @scatter_pf32x2
+#[no_mangle]
+pub unsafe fn scatter_pf32x2(
+    pointers: Vec2<*mut *const f32>,
+    mask: Vec2<i32>,
+    values: Vec2<*const f32>,
+) {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: call void @llvm.masked.scatter.v2p0.v2p0(<2 x ptr> {{.*}}, <2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]]
+    simd_scatter(values, pointers, mask)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-select.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-select.rs
new file mode 100644
index 00000000000..2c0bad21f44
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-generic-select.rs
@@ -0,0 +1,48 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::{simd_select, simd_select_bitmask};
+
+pub type b8x4 = i8x4;
+
+// CHECK-LABEL: @select_m8
+#[no_mangle]
+pub unsafe fn select_m8(m: b8x4, a: f32x4, b: f32x4) -> f32x4 {
+    // CHECK: [[A:%[0-9]+]] = lshr <4 x i8> %{{.*}}, {{<i8 7, i8 7, i8 7, i8 7>|splat \(i8 7\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <4 x i8> [[A]] to <4 x i1>
+    // CHECK: select <4 x i1> [[B]]
+    simd_select(m, a, b)
+}
+
+// CHECK-LABEL: @select_m32
+#[no_mangle]
+pub unsafe fn select_m32(m: i32x4, a: f32x4, b: f32x4) -> f32x4 {
+    // CHECK: [[A:%[0-9]+]] = lshr <4 x i32> %{{.*}}, {{<i32 31, i32 31, i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <4 x i32> [[A]] to <4 x i1>
+    // CHECK: select <4 x i1> [[B]]
+    simd_select(m, a, b)
+}
+
+// CHECK-LABEL: @select_m32_unsigned
+#[no_mangle]
+pub unsafe fn select_m32_unsigned(m: u32x4, a: f32x4, b: f32x4) -> f32x4 {
+    // CHECK: [[A:%[0-9]+]] = lshr <4 x i32> %{{.*}}, {{<i32 31, i32 31, i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <4 x i32> [[A]] to <4 x i1>
+    // CHECK: select <4 x i1> [[B]]
+    simd_select(m, a, b)
+}
+
+// CHECK-LABEL: @select_bitmask
+#[no_mangle]
+pub unsafe fn select_bitmask(m: i8, a: f32x8, b: f32x8) -> f32x8 {
+    // CHECK: [[A:%[0-9]+]] = bitcast i8 {{.*}} to <8 x i1>
+    // CHECK: select <8 x i1> [[A]]
+    simd_select_bitmask(m, a, b)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-mask-reduce.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-mask-reduce.rs
new file mode 100644
index 00000000000..79f00a6ed60
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-mask-reduce.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+#![allow(non_camel_case_types)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+use std::intrinsics::simd::{simd_reduce_all, simd_reduce_any};
+
+pub type mask32x2 = Simd<i32, 2>;
+pub type mask8x16 = Simd<i8, 16>;
+
+// NOTE(eddyb) `%{{x|1}}` is used because on some targets (e.g. WASM)
+// SIMD vectors are passed directly, resulting in `%x` being a vector,
+// while on others they're passed indirectly, resulting in `%x` being
+// a pointer to a vector, and `%1` a vector loaded from that pointer.
+// This is controlled by the target spec option `simd_types_indirect`.
+
+// CHECK-LABEL: @reduce_any_32x2
+#[no_mangle]
+pub unsafe fn reduce_any_32x2(x: mask32x2) -> bool {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{x|1}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: [[C:%[0-9]+]] = call i1 @llvm.vector.reduce.or.v2i1(<2 x i1> [[B]])
+    // CHECK: %{{[0-9]+}} = zext i1 [[C]] to i8
+    simd_reduce_any(x)
+}
+
+// CHECK-LABEL: @reduce_all_32x2
+#[no_mangle]
+pub unsafe fn reduce_all_32x2(x: mask32x2) -> bool {
+    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{x|1}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
+    // CHECK: [[C:%[0-9]+]] = call i1 @llvm.vector.reduce.and.v2i1(<2 x i1> [[B]])
+    // CHECK: %{{[0-9]+}} = zext i1 [[C]] to i8
+    simd_reduce_all(x)
+}
+
+// CHECK-LABEL: @reduce_any_8x16
+#[no_mangle]
+pub unsafe fn reduce_any_8x16(x: mask8x16) -> bool {
+    // CHECK: [[A:%[0-9]+]] = lshr <16 x i8> %{{x|1}}, {{<i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>|splat \(i8 7\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <16 x i8> [[A]] to <16 x i1>
+    // CHECK: [[C:%[0-9]+]] = call i1 @llvm.vector.reduce.or.v16i1(<16 x i1> [[B]])
+    // CHECK: %{{[0-9]+}} = zext i1 [[C]] to i8
+    simd_reduce_any(x)
+}
+
+// CHECK-LABEL: @reduce_all_8x16
+#[no_mangle]
+pub unsafe fn reduce_all_8x16(x: mask8x16) -> bool {
+    // CHECK: [[A:%[0-9]+]] = lshr <16 x i8> %{{x|1}}, {{<i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>|splat \(i8 7\)}}
+    // CHECK: [[B:%[0-9]+]] = trunc <16 x i8> [[A]] to <16 x i1>
+    // CHECK: [[C:%[0-9]+]] = call i1 @llvm.vector.reduce.and.v16i1(<16 x i1> [[B]])
+    // CHECK: %{{[0-9]+}} = zext i1 [[C]] to i8
+    simd_reduce_all(x)
+}
diff --git a/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-transmute-array.rs b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-transmute-array.rs
new file mode 100644
index 00000000000..05c2f7e1bdf
--- /dev/null
+++ b/tests/codegen-llvm/simd-intrinsic/simd-intrinsic-transmute-array.rs
@@ -0,0 +1,58 @@
+//
+//@ compile-flags: -C no-prepopulate-passes
+// 32bit MSVC does not align things properly so we suppress high alignment annotations (#112480)
+//@ ignore-i686-pc-windows-msvc
+//@ ignore-i686-pc-windows-gnu
+
+#![crate_type = "lib"]
+#![allow(non_camel_case_types)]
+#![feature(repr_simd, core_intrinsics)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
+
+pub type S<const N: usize> = Simd<f32, N>;
+pub type T = Simd<f32, 4>;
+
+// CHECK-LABEL: @array_align(
+#[no_mangle]
+pub fn array_align() -> usize {
+    // CHECK: ret [[USIZE:i[0-9]+]] [[ARRAY_ALIGN:[0-9]+]]
+    const { std::mem::align_of::<f32>() }
+}
+
+// CHECK-LABEL: @vector_align(
+#[no_mangle]
+pub fn vector_align() -> usize {
+    // CHECK: ret [[USIZE]] [[VECTOR_ALIGN:[0-9]+]]
+    const { std::mem::align_of::<T>() }
+}
+
+// CHECK-LABEL: @build_array_s
+#[no_mangle]
+pub fn build_array_s(x: [f32; 4]) -> S<4> {
+    // CHECK: call void @llvm.memcpy.{{.+}}({{.*}} align [[VECTOR_ALIGN]] {{.*}} align [[ARRAY_ALIGN]] {{.*}}, [[USIZE]] 16, i1 false)
+    Simd(x)
+}
+
+// CHECK-LABEL: @build_array_transmute_s
+#[no_mangle]
+pub fn build_array_transmute_s(x: [f32; 4]) -> S<4> {
+    // CHECK: call void @llvm.memcpy.{{.+}}({{.*}} align [[VECTOR_ALIGN]] {{.*}} align [[ARRAY_ALIGN]] {{.*}}, [[USIZE]] 16, i1 false)
+    unsafe { std::mem::transmute(x) }
+}
+
+// CHECK-LABEL: @build_array_t
+#[no_mangle]
+pub fn build_array_t(x: [f32; 4]) -> T {
+    // CHECK: call void @llvm.memcpy.{{.+}}({{.*}} align [[VECTOR_ALIGN]] {{.*}} align [[ARRAY_ALIGN]] {{.*}}, [[USIZE]] 16, i1 false)
+    Simd(x)
+}
+
+// CHECK-LABEL: @build_array_transmute_t
+#[no_mangle]
+pub fn build_array_transmute_t(x: [f32; 4]) -> T {
+    // CHECK: call void @llvm.memcpy.{{.+}}({{.*}} align [[VECTOR_ALIGN]] {{.*}} align [[ARRAY_ALIGN]] {{.*}}, [[USIZE]] 16, i1 false)
+    unsafe { std::mem::transmute(x) }
+}
diff --git a/tests/codegen-llvm/simd/aggregate-simd.rs b/tests/codegen-llvm/simd/aggregate-simd.rs
new file mode 100644
index 00000000000..57a301d634c
--- /dev/null
+++ b/tests/codegen-llvm/simd/aggregate-simd.rs
@@ -0,0 +1,102 @@
+//@ compile-flags: -C opt-level=3 -C no-prepopulate-passes
+//@ only-64bit
+
+#![feature(core_intrinsics, repr_simd)]
+#![no_std]
+#![crate_type = "lib"]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use core::intrinsics::simd::{simd_add, simd_extract};
+
+use minisimd::*;
+
+#[repr(transparent)]
+pub struct Transparent<T>(T);
+
+// These tests don't actually care about the add/extract, but it ensures the
+// aggregated temporaries are only used in potentially-SSA ways.
+
+#[no_mangle]
+pub fn simd_aggregate_pot(x: [u32; 4], y: [u32; 4]) -> u32 {
+    // CHECK-LABEL: simd_aggregate_pot
+    // CHECK: %a = load <4 x i32>, ptr %x, align 4
+    // CHECK: %b = load <4 x i32>, ptr %y, align 4
+    // CHECK: add <4 x i32> %a, %b
+
+    unsafe {
+        let a = Simd(x);
+        let b = Simd(y);
+        let c = simd_add(a, b);
+        simd_extract(c, 1)
+    }
+}
+
+#[no_mangle]
+pub fn simd_aggregate_npot(x: [u32; 7], y: [u32; 7]) -> u32 {
+    // CHECK-LABEL: simd_aggregate_npot
+    // CHECK: %a = load <7 x i32>, ptr %x, align 4
+    // CHECK: %b = load <7 x i32>, ptr %y, align 4
+    // CHECK: add <7 x i32> %a, %b
+
+    unsafe {
+        let a = Simd(x);
+        let b = Simd(y);
+        let c = simd_add(a, b);
+        simd_extract(c, 1)
+    }
+}
+
+#[no_mangle]
+pub fn packed_simd_aggregate_pot(x: [u32; 4], y: [u32; 4]) -> u32 {
+    // CHECK-LABEL: packed_simd_aggregate_pot
+    // CHECK: %a = load <4 x i32>, ptr %x, align 4
+    // CHECK: %b = load <4 x i32>, ptr %y, align 4
+    // CHECK: add <4 x i32> %a, %b
+
+    unsafe {
+        let a = PackedSimd(x);
+        let b = PackedSimd(y);
+        let c = simd_add(a, b);
+        simd_extract(c, 1)
+    }
+}
+
+#[no_mangle]
+pub fn packed_simd_aggregate_npot(x: [u32; 7], y: [u32; 7]) -> u32 {
+    // CHECK-LABEL: packed_simd_aggregate_npot
+    // CHECK: %b = alloca [28 x i8], align 4
+    // CHECK: %a = alloca [28 x i8], align 4
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a, ptr align 4 %x, i64 28, i1 false)
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %b, ptr align 4 %y, i64 28, i1 false)
+    // CHECK: %[[TEMPA:.+]] = load <7 x i32>, ptr %a, align 4
+    // CHECK: %[[TEMPB:.+]] = load <7 x i32>, ptr %b, align 4
+    // CHECK: add <7 x i32> %[[TEMPA]], %[[TEMPB]]
+
+    unsafe {
+        let a = PackedSimd(x);
+        let b = PackedSimd(y);
+        let c = simd_add(a, b);
+        simd_extract(c, 1)
+    }
+}
+
+#[no_mangle]
+pub fn transparent_simd_aggregate(x: [u32; 4]) -> u32 {
+    // The transparent wrapper can just use the same SSA value as its field.
+    // No extra processing or spilling needed.
+
+    // CHECK-LABEL: transparent_simd_aggregate
+    // CHECK-NOT: alloca
+    // CHECK: %[[RET:.+]] = alloca [4 x i8]
+    // CHECK-NOT: alloca
+    // CHECK: %a = load <4 x i32>, ptr %x, align 4
+    // CHECK: %[[TEMP:.+]] = extractelement <4 x i32> %a, i32 1
+    // CHECK: store i32 %[[TEMP]], ptr %[[RET]]
+
+    unsafe {
+        let a = Simd(x);
+        let b = Transparent(a);
+        simd_extract(b.0, 1)
+    }
+}
diff --git a/tests/codegen-llvm/simd/extract-insert-dyn.rs b/tests/codegen-llvm/simd/extract-insert-dyn.rs
new file mode 100644
index 00000000000..729f0145314
--- /dev/null
+++ b/tests/codegen-llvm/simd/extract-insert-dyn.rs
@@ -0,0 +1,121 @@
+//@compile-flags: -C opt-level=3 -C no-prepopulate-passes
+
+#![feature(
+    core_intrinsics,
+    repr_simd,
+    arm_target_feature,
+    mips_target_feature,
+    s390x_target_feature
+)]
+#![no_std]
+#![crate_type = "lib"]
+#![allow(non_camel_case_types)]
+
+// Test that `core::intrinsics::simd::{simd_extract_dyn, simd_insert_dyn}`
+// lower to an LLVM extractelement or insertelement operation.
+
+use core::intrinsics::simd::{simd_extract, simd_extract_dyn, simd_insert, simd_insert_dyn};
+
+#[repr(simd)]
+#[derive(Clone, Copy)]
+pub struct u32x16([u32; 16]);
+
+#[repr(simd)]
+#[derive(Clone, Copy)]
+pub struct i8x16([i8; 16]);
+
+// CHECK-LABEL: dyn_simd_extract
+// CHECK: extractelement <16 x i8> %x, i32 %idx
+#[no_mangle]
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
+unsafe extern "C" fn dyn_simd_extract(x: i8x16, idx: u32) -> i8 {
+    simd_extract_dyn(x, idx)
+}
+
+// CHECK-LABEL: literal_dyn_simd_extract
+// CHECK: extractelement <16 x i8> %x, i32 7
+#[no_mangle]
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
+unsafe extern "C" fn literal_dyn_simd_extract(x: i8x16) -> i8 {
+    simd_extract_dyn(x, 7)
+}
+
+// CHECK-LABEL: const_dyn_simd_extract
+// CHECK: extractelement <16 x i8> %x, i32 7
+#[no_mangle]
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
+unsafe extern "C" fn const_dyn_simd_extract(x: i8x16) -> i8 {
+    simd_extract_dyn(x, const { 3 + 4 })
+}
+
+// CHECK-LABEL: const_simd_extract
+// CHECK: extractelement <16 x i8> %x, i32 7
+#[no_mangle]
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
+unsafe extern "C" fn const_simd_extract(x: i8x16) -> i8 {
+    simd_extract(x, const { 3 + 4 })
+}
+
+// CHECK-LABEL: dyn_simd_insert
+// CHECK: insertelement <16 x i8> %x, i8 %e, i32 %idx
+#[no_mangle]
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
+unsafe extern "C" fn dyn_simd_insert(x: i8x16, e: i8, idx: u32) -> i8x16 {
+    simd_insert_dyn(x, idx, e)
+}
+
+// CHECK-LABEL: literal_dyn_simd_insert
+// CHECK: insertelement <16 x i8> %x, i8 %e, i32 7
+#[no_mangle]
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
+unsafe extern "C" fn literal_dyn_simd_insert(x: i8x16, e: i8) -> i8x16 {
+    simd_insert_dyn(x, 7, e)
+}
+
+// CHECK-LABEL: const_dyn_simd_insert
+// CHECK: insertelement <16 x i8> %x, i8 %e, i32 7
+#[no_mangle]
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
+unsafe extern "C" fn const_dyn_simd_insert(x: i8x16, e: i8) -> i8x16 {
+    simd_insert_dyn(x, const { 3 + 4 }, e)
+}
+
+// CHECK-LABEL: const_simd_insert
+// CHECK: insertelement <16 x i8> %x, i8 %e, i32 7
+#[no_mangle]
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
+unsafe extern "C" fn const_simd_insert(x: i8x16, e: i8) -> i8x16 {
+    simd_insert(x, const { 3 + 4 }, e)
+}
diff --git a/tests/codegen-llvm/simd/packed-simd-alignment.rs b/tests/codegen-llvm/simd/packed-simd-alignment.rs
new file mode 100644
index 00000000000..53e88d8e5cf
--- /dev/null
+++ b/tests/codegen-llvm/simd/packed-simd-alignment.rs
@@ -0,0 +1,44 @@
+//@ compile-flags: -Cno-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+// make sure that codegen emits correctly-aligned loads and stores for repr(packed, simd) types
+// the alignment of a load should be no less than T, and no more than the size of the vector type
+use std::intrinsics::simd as intrinsics;
+
+#[derive(Copy, Clone)]
+#[repr(packed, simd)]
+struct f32x3([f32; 3]);
+
+#[derive(Copy, Clone)]
+#[repr(packed, simd)]
+struct f32x4([f32; 4]);
+
+// CHECK-LABEL: load_f32x3
+#[no_mangle]
+pub fn load_f32x3(floats: &f32x3) -> f32x3 {
+    // FIXME: Is a memcpy really the best we can do?
+    // CHECK: @llvm.memcpy.{{.*}}ptr align 4 {{.*}}ptr align 4
+    *floats
+}
+
+// CHECK-LABEL: load_f32x4
+#[no_mangle]
+pub fn load_f32x4(floats: &f32x4) -> f32x4 {
+    // CHECK: load <4 x float>, ptr %{{[a-z0-9_]*}}, align {{4|8|16}}
+    *floats
+}
+
+// CHECK-LABEL: add_f32x3
+#[no_mangle]
+pub fn add_f32x3(x: f32x3, y: f32x3) -> f32x3 {
+    // CHECK: load <3 x float>, ptr %{{[a-z0-9_]*}}, align 4
+    unsafe { intrinsics::simd_add(x, y) }
+}
+
+// CHECK-LABEL: add_f32x4
+#[no_mangle]
+pub fn add_f32x4(x: f32x4, y: f32x4) -> f32x4 {
+    // CHECK: load <4 x float>, ptr %{{[a-z0-9_]*}}, align {{4|8|16}}
+    unsafe { intrinsics::simd_add(x, y) }
+}
diff --git a/tests/codegen-llvm/simd/packed-simd.rs b/tests/codegen-llvm/simd/packed-simd.rs
new file mode 100644
index 00000000000..70c03fcc955
--- /dev/null
+++ b/tests/codegen-llvm/simd/packed-simd.rs
@@ -0,0 +1,56 @@
+//@ revisions:opt3 noopt
+//@ only-x86_64
+//@[opt3] compile-flags: -Copt-level=3
+//@[noopt] compile-flags: -Cno-prepopulate-passes
+
+#![crate_type = "lib"]
+#![no_std]
+#![feature(repr_simd, core_intrinsics)]
+use core::intrinsics::simd as intrinsics;
+use core::{mem, ptr};
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::{PackedSimd, Simd as FullSimd};
+
+// Test codegen for not only "packed" but also "fully aligned" SIMD types, and conversion between
+// them. A repr(packed,simd) type with 3 elements can't exceed its element alignment, whereas the
+// same type as repr(simd) will instead have padding.
+
+// non-powers-of-two have padding and need to be expanded to full vectors
+fn load<T, const N: usize>(v: PackedSimd<T, N>) -> FullSimd<T, N> {
+    unsafe {
+        let mut tmp = mem::MaybeUninit::<FullSimd<T, N>>::uninit();
+        ptr::copy_nonoverlapping(&v as *const _, tmp.as_mut_ptr().cast(), 1);
+        tmp.assume_init()
+    }
+}
+
+// CHECK-LABEL: square_packed_full
+// CHECK-SAME: ptr{{[a-z_ ]*}} sret([[RET_TYPE:[^)]+]]) [[RET_ALIGN:align (8|16)]]{{[^%]*}} [[RET_VREG:%[_0-9]*]]
+// CHECK-SAME: ptr{{[a-z_ ]*}} align 4
+#[no_mangle]
+pub fn square_packed_full(x: PackedSimd<f32, 3>) -> FullSimd<f32, 3> {
+    // CHECK-NEXT: start
+    // noopt: alloca [[RET_TYPE]], [[RET_ALIGN]]
+    // CHECK: load <3 x float>
+    let x = load(x);
+    // CHECK: [[VREG:%[a-z0-9_]+]] = fmul <3 x float>
+    // CHECK-NEXT: store <3 x float> [[VREG]], ptr [[RET_VREG]], [[RET_ALIGN]]
+    // CHECK-NEXT: ret void
+    unsafe { intrinsics::simd_mul(x, x) }
+}
+
+// CHECK-LABEL: square_packed
+// CHECK-SAME: ptr{{[a-z_ ]*}} sret([[RET_TYPE:[^)]+]]) [[RET_ALIGN:align 4]]{{[^%]*}} [[RET_VREG:%[_0-9]*]]
+// CHECK-SAME: ptr{{[a-z_ ]*}} align 4
+#[no_mangle]
+pub fn square_packed(x: PackedSimd<f32, 3>) -> PackedSimd<f32, 3> {
+    // CHECK-NEXT: start
+    // CHECK-NEXT: load <3 x float>
+    // noopt-NEXT: load <3 x float>
+    // CHECK-NEXT: [[VREG:%[a-z0-9_]+]] = fmul <3 x float>
+    // CHECK-NEXT: store <3 x float> [[VREG]], ptr [[RET_VREG]], [[RET_ALIGN]]
+    // CHECK-NEXT: ret void
+    unsafe { intrinsics::simd_mul(x, x) }
+}
diff --git a/tests/codegen-llvm/simd/simd-wide-sum.rs b/tests/codegen-llvm/simd/simd-wide-sum.rs
new file mode 100644
index 00000000000..95117b2c748
--- /dev/null
+++ b/tests/codegen-llvm/simd/simd-wide-sum.rs
@@ -0,0 +1,59 @@
+//@ revisions: llvm mir-opt3
+//@ compile-flags: -C opt-level=3 -Z merge-functions=disabled
+//@ edition: 2021
+//@ only-x86_64
+//@ [mir-opt3]compile-flags: -Zmir-opt-level=3
+//@ [mir-opt3]build-pass
+
+// mir-opt3 is a regression test for https://github.com/rust-lang/rust/issues/98016
+
+#![crate_type = "lib"]
+#![feature(portable_simd)]
+
+use std::simd::prelude::*;
+const N: usize = 16;
+
+#[no_mangle]
+// CHECK-LABEL: @wider_reduce_simd
+pub fn wider_reduce_simd(x: Simd<u8, N>) -> u16 {
+    // CHECK: zext <16 x i8>
+    // CHECK-SAME: to <16 x i16>
+    // CHECK: call i16 @llvm.vector.reduce.add.v16i16(<16 x i16>
+    let x: Simd<u16, N> = x.cast();
+    x.reduce_sum()
+}
+
+#[no_mangle]
+// CHECK-LABEL: @wider_reduce_loop
+pub fn wider_reduce_loop(x: Simd<u8, N>) -> u16 {
+    // CHECK: zext <16 x i8>
+    // CHECK-SAME: to <16 x i16>
+    // CHECK: call i16 @llvm.vector.reduce.add.v16i16(<16 x i16>
+    let mut sum = 0_u16;
+    for i in 0..N {
+        sum += u16::from(x[i]);
+    }
+    sum
+}
+
+#[no_mangle]
+// CHECK-LABEL: @wider_reduce_iter
+pub fn wider_reduce_iter(x: Simd<u8, N>) -> u16 {
+    // CHECK: zext <16 x i8>
+    // CHECK-SAME: to <16 x i16>
+    // CHECK: call i16 @llvm.vector.reduce.add.v16i16(<16 x i16>
+    x.as_array().iter().copied().map(u16::from).sum()
+}
+
+// This iterator one is the most interesting, as it's the one
+// which used to not auto-vectorize due to a suboptimality in the
+// `<array::IntoIter as Iterator>::fold` implementation.
+
+#[no_mangle]
+// CHECK-LABEL: @wider_reduce_into_iter
+pub fn wider_reduce_into_iter(x: Simd<u8, N>) -> u16 {
+    // CHECK: zext <16 x i8>
+    // CHECK-SAME: to <16 x i16>
+    // CHECK: call i16 @llvm.vector.reduce.add.v16i16(<16 x i16>
+    x.to_array().into_iter().map(u16::from).sum()
+}
diff --git a/tests/codegen-llvm/simd/simd_arith_offset.rs b/tests/codegen-llvm/simd/simd_arith_offset.rs
new file mode 100644
index 00000000000..210b4e9bb50
--- /dev/null
+++ b/tests/codegen-llvm/simd/simd_arith_offset.rs
@@ -0,0 +1,22 @@
+//@ compile-flags: -C no-prepopulate-passes
+//@ only-64bit (because the LLVM type of i64 for usize shows up)
+//
+
+#![crate_type = "lib"]
+#![feature(repr_simd, core_intrinsics)]
+
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use std::intrinsics::simd::simd_arith_offset;
+
+use minisimd::*;
+
+/// A vector of *const T.
+pub type SimdConstPtr<T, const LANES: usize> = Simd<*const T, LANES>;
+
+// CHECK-LABEL: smoke
+#[no_mangle]
+pub fn smoke(ptrs: SimdConstPtr<u8, 8>, offsets: Simd<usize, 8>) -> SimdConstPtr<u8, 8> {
+    // CHECK: getelementptr i8, <8 x ptr> %0, <8 x i64> %1
+    unsafe { simd_arith_offset(ptrs, offsets) }
+}
diff --git a/tests/codegen-llvm/simd/swap-simd-types.rs b/tests/codegen-llvm/simd/swap-simd-types.rs
new file mode 100644
index 00000000000..c063cc683a6
--- /dev/null
+++ b/tests/codegen-llvm/simd/swap-simd-types.rs
@@ -0,0 +1,40 @@
+//@ compile-flags: -Copt-level=3 -C target-feature=+avx
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+use std::mem::swap;
+
+// SIMD types are highly-aligned already, so make sure the swap code leaves their
+// types alone and doesn't pessimize them (such as by swapping them as `usize`s).
+extern crate core;
+use core::arch::x86_64::__m256;
+
+// CHECK-LABEL: @swap_single_m256
+#[no_mangle]
+pub fn swap_single_m256(x: &mut __m256, y: &mut __m256) {
+    // CHECK-NOT: alloca
+    // CHECK: load <8 x float>{{.+}}align 32
+    // CHECK: store <8 x float>{{.+}}align 32
+    swap(x, y)
+}
+
+// CHECK-LABEL: @swap_m256_slice
+#[no_mangle]
+pub fn swap_m256_slice(x: &mut [__m256], y: &mut [__m256]) {
+    // CHECK-NOT: alloca
+    // CHECK-COUNT-2: load <4 x i64>{{.+}}align 32
+    // CHECK-COUNT-2: store <4 x i64>{{.+}}align 32
+    if x.len() == y.len() {
+        x.swap_with_slice(y);
+    }
+}
+
+// CHECK-LABEL: @swap_bytes32
+#[no_mangle]
+pub fn swap_bytes32(x: &mut [u8; 32], y: &mut [u8; 32]) {
+    // CHECK-NOT: alloca
+    // CHECK-COUNT-2: load <4 x i64>{{.+}}align 1
+    // CHECK-COUNT-2: store <4 x i64>{{.+}}align 1
+    swap(x, y)
+}
diff --git a/tests/codegen-llvm/simd/unpadded-simd.rs b/tests/codegen-llvm/simd/unpadded-simd.rs
new file mode 100644
index 00000000000..ef067a15702
--- /dev/null
+++ b/tests/codegen-llvm/simd/unpadded-simd.rs
@@ -0,0 +1,19 @@
+// Make sure that no 0-sized padding is inserted in structs and that
+// structs are represented as expected by Neon intrinsics in LLVM.
+// See #87254.
+
+#![crate_type = "lib"]
+#![feature(repr_simd, abi_unadjusted)]
+
+#[derive(Copy, Clone)]
+#[repr(simd)]
+pub struct int16x4_t(pub [i16; 4]);
+
+#[derive(Copy, Clone)]
+pub struct int16x4x2_t(pub int16x4_t, pub int16x4_t);
+
+// CHECK: %int16x4x2_t = type { <4 x i16>, <4 x i16> }
+#[no_mangle]
+extern "unadjusted" fn takes_int16x4x2_t(t: int16x4x2_t) -> int16x4x2_t {
+    t
+}
diff --git a/tests/codegen-llvm/skip-mono-inside-if-false.rs b/tests/codegen-llvm/skip-mono-inside-if-false.rs
new file mode 100644
index 00000000000..8b95de99dd3
--- /dev/null
+++ b/tests/codegen-llvm/skip-mono-inside-if-false.rs
@@ -0,0 +1,41 @@
+//@ compile-flags: -Cno-prepopulate-passes -Copt-level=0
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn demo_for_i32() {
+    generic_impl::<i32>();
+}
+
+// Two important things here:
+// - We replace the "then" block with `unreachable` to avoid linking problems
+// - We neither declare nor define the `big_impl` that said block "calls".
+
+// CHECK-LABEL: ; skip_mono_inside_if_false::generic_impl
+// CHECK: start:
+// CHECK-NEXT: br label %[[ELSE_BRANCH:bb[0-9]+]]
+// CHECK: [[ELSE_BRANCH]]:
+// CHECK-NEXT: call skip_mono_inside_if_false::small_impl
+// CHECK: bb{{[0-9]+}}:
+// CHECK-NEXT: ret void
+// CHECK: bb{{[0-9+]}}:
+// CHECK-NEXT: unreachable
+
+fn generic_impl<T>() {
+    trait MagicTrait {
+        const IS_BIG: bool;
+    }
+    impl<T> MagicTrait for T {
+        const IS_BIG: bool = std::mem::size_of::<T>() > 10;
+    }
+    if T::IS_BIG {
+        big_impl::<T>();
+    } else {
+        small_impl::<T>();
+    }
+}
+
+#[inline(never)]
+fn small_impl<T>() {}
+#[inline(never)]
+fn big_impl<T>() {}
diff --git a/tests/codegen-llvm/slice-as_chunks.rs b/tests/codegen-llvm/slice-as_chunks.rs
new file mode 100644
index 00000000000..337eb8981f6
--- /dev/null
+++ b/tests/codegen-llvm/slice-as_chunks.rs
@@ -0,0 +1,30 @@
+//@ compile-flags: -Copt-level=3
+//@ only-64bit (because the LLVM type of i64 for usize shows up)
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @chunks4
+#[no_mangle]
+pub fn chunks4(x: &[u8]) -> &[[u8; 4]] {
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: lshr i64 %x.1, 2
+    // CHECK-NOT: shl
+    // CHECK-NOT: mul
+    // CHECK-NOT: udiv
+    // CHECK-NOT: urem
+    // CHECK: ret
+    x.as_chunks().0
+}
+
+// CHECK-LABEL: @chunks4_with_remainder
+#[no_mangle]
+pub fn chunks4_with_remainder(x: &[u8]) -> (&[[u8; 4]], &[u8]) {
+    // CHECK-DAG: and i64 %x.1, -4
+    // CHECK-DAG: and i64 %x.1, 3
+    // CHECK-DAG: lshr
+    // CHECK-NOT: mul
+    // CHECK-NOT: udiv
+    // CHECK-NOT: urem
+    // CHECK: ret
+    x.as_chunks()
+}
diff --git a/tests/codegen-llvm/slice-indexing.rs b/tests/codegen-llvm/slice-indexing.rs
new file mode 100644
index 00000000000..d957ccfb5ef
--- /dev/null
+++ b/tests/codegen-llvm/slice-indexing.rs
@@ -0,0 +1,99 @@
+//@ compile-flags: -Copt-level=3
+//@ only-64bit (because the LLVM type of i64 for usize shows up)
+
+#![crate_type = "lib"]
+
+use std::ops::Range;
+
+// CHECK-LABEL: @index_by_range(
+#[no_mangle]
+pub fn index_by_range(x: &[u16], r: Range<usize>) -> &[u16] {
+    // CHECK: sub nuw i64
+    &x[r]
+}
+
+// CHECK-LABEL: @get_unchecked_by_range(
+#[no_mangle]
+pub unsafe fn get_unchecked_by_range(x: &[u16], r: Range<usize>) -> &[u16] {
+    // CHECK: sub nuw i64
+    x.get_unchecked(r)
+}
+
+// CHECK-LABEL: @index_mut_by_range(
+#[no_mangle]
+pub fn index_mut_by_range(x: &mut [i32], r: Range<usize>) -> &mut [i32] {
+    // CHECK: sub nuw i64
+    &mut x[r]
+}
+
+// CHECK-LABEL: @get_unchecked_mut_by_range(
+#[no_mangle]
+pub unsafe fn get_unchecked_mut_by_range(x: &mut [i32], r: Range<usize>) -> &mut [i32] {
+    // CHECK: sub nuw i64
+    x.get_unchecked_mut(r)
+}
+
+// CHECK-LABEL: @str_index_by_range(
+#[no_mangle]
+pub fn str_index_by_range(x: &str, r: Range<usize>) -> &str {
+    // CHECK: sub nuw i64
+    &x[r]
+}
+
+// CHECK-LABEL: @str_get_unchecked_by_range(
+#[no_mangle]
+pub unsafe fn str_get_unchecked_by_range(x: &str, r: Range<usize>) -> &str {
+    // CHECK: sub nuw i64
+    x.get_unchecked(r)
+}
+
+// CHECK-LABEL: @str_index_mut_by_range(
+#[no_mangle]
+pub fn str_index_mut_by_range(x: &mut str, r: Range<usize>) -> &mut str {
+    // CHECK: sub nuw i64
+    &mut x[r]
+}
+
+// CHECK-LABEL: @str_get_unchecked_mut_by_range(
+#[no_mangle]
+pub unsafe fn str_get_unchecked_mut_by_range(x: &mut str, r: Range<usize>) -> &mut str {
+    // CHECK: sub nuw i64
+    x.get_unchecked_mut(r)
+}
+
+// CHECK-LABEL: @slice_repeated_indexing(
+#[no_mangle]
+pub fn slice_repeated_indexing(dst: &mut [u8], offset: usize) {
+    let mut i = offset;
+    // CHECK: panic_bounds_check
+    dst[i] = 1;
+    i += 1;
+    // CHECK: panic_bounds_check
+    dst[i] = 2;
+    i += 1;
+    // CHECK: panic_bounds_check
+    dst[i] = 3;
+    i += 1;
+    // CHECK: panic_bounds_check
+    dst[i] = 4;
+}
+
+// CHECK-LABEL: @slice_repeated_indexing_coalesced(
+#[no_mangle]
+pub fn slice_repeated_indexing_coalesced(dst: &mut [u8], offset: usize) {
+    let mut i = offset;
+    if i.checked_add(4).unwrap() <= dst.len() {
+        // CHECK-NOT: panic_bounds_check
+        dst[i] = 1;
+        i += 1;
+        // CHECK-NOT: panic_bounds_check
+        dst[i] = 2;
+        i += 1;
+        // CHECK-NOT: panic_bounds_check
+        dst[i] = 3;
+        i += 1;
+        // CHECK-NOT: panic_bounds_check
+        dst[i] = 4;
+    }
+    // CHECK: ret
+}
diff --git a/tests/codegen-llvm/slice-init.rs b/tests/codegen-llvm/slice-init.rs
new file mode 100644
index 00000000000..950e0b0c10d
--- /dev/null
+++ b/tests/codegen-llvm/slice-init.rs
@@ -0,0 +1,108 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @zero_sized_elem
+#[no_mangle]
+pub fn zero_sized_elem() {
+    // CHECK-NOT: br label %repeat_loop_header{{.*}}
+    // CHECK-NOT: call void @llvm.memset.p0
+    let x = [(); 4];
+    opaque(&x);
+}
+
+// CHECK-LABEL: @zero_len_array
+#[no_mangle]
+pub fn zero_len_array() {
+    // CHECK-NOT: br label %repeat_loop_header{{.*}}
+    // CHECK-NOT: call void @llvm.memset.p0
+    let x = [4; 0];
+    opaque(&x);
+}
+
+// CHECK-LABEL: @byte_array
+#[no_mangle]
+pub fn byte_array() {
+    // CHECK: call void @llvm.memset.{{.+}}(ptr {{.*}}, i8 7, i{{[0-9]+}} 4
+    // CHECK-NOT: br label %repeat_loop_header{{.*}}
+    let x = [7u8; 4];
+    opaque(&x);
+}
+
+#[allow(dead_code)]
+#[derive(Copy, Clone)]
+enum Init {
+    Loop,
+    Memset,
+}
+
+// CHECK-LABEL: @byte_enum_array
+#[no_mangle]
+pub fn byte_enum_array() {
+    // CHECK: call void @llvm.memset.{{.+}}(ptr {{.*}}, i8 {{.*}}, i{{[0-9]+}} 4
+    // CHECK-NOT: br label %repeat_loop_header{{.*}}
+    let x = [Init::Memset; 4];
+    opaque(&x);
+}
+
+// CHECK-LABEL: @zeroed_integer_array
+#[no_mangle]
+pub fn zeroed_integer_array() {
+    // CHECK: call void @llvm.memset.{{.+}}(ptr {{.*}}, i8 0, i{{[0-9]+}} 16
+    // CHECK-NOT: br label %repeat_loop_header{{.*}}
+    let x = [0u32; 4];
+    opaque(&x);
+}
+
+// CHECK-LABEL: @nonzero_integer_array
+#[no_mangle]
+pub fn nonzero_integer_array() {
+    // CHECK: br label %repeat_loop_header{{.*}}
+    // CHECK-NOT: call void @llvm.memset.p0
+    let x = [0x1a_2b_3c_4d_u32; 4];
+    opaque(&x);
+}
+
+const N: usize = 100;
+
+// CHECK-LABEL: @u16_init_one_bytes
+#[no_mangle]
+pub fn u16_init_one_bytes() -> [u16; N] {
+    // CHECK-NOT: select
+    // CHECK-NOT: br
+    // CHECK-NOT: switch
+    // CHECK-NOT: icmp
+    // CHECK: call void @llvm.memset.p0
+    [const { u16::from_be_bytes([1, 1]) }; N]
+}
+
+// FIXME: undef bytes can just be initialized with the same value as the
+// defined bytes, if the defines bytes are all the same.
+// CHECK-LABEL: @option_none_init
+#[no_mangle]
+pub fn option_none_init() -> [Option<u8>; N] {
+    // CHECK-NOT: select
+    // CHECK: br label %repeat_loop_header{{.*}}
+    // CHECK-NOT: switch
+    // CHECK: icmp
+    // CHECK-NOT: call void @llvm.memset.p0
+    [None; N]
+}
+
+use std::mem::MaybeUninit;
+
+// FIXME: This could be optimized into a memset.
+// Regression test for <https://github.com/rust-lang/rust/issues/137892>.
+#[no_mangle]
+pub fn half_uninit() -> [(u128, MaybeUninit<u128>); N] {
+    // CHECK-NOT: select
+    // CHECK: br label %repeat_loop_header{{.*}}
+    // CHECK-NOT: switch
+    // CHECK: icmp
+    // CHECK-NOT: call void @llvm.memset.p0
+    [const { (0, MaybeUninit::uninit()) }; N]
+}
+
+// Use an opaque function to prevent rustc from removing useless drops.
+#[inline(never)]
+pub fn opaque(_: impl Sized) {}
diff --git a/tests/codegen-llvm/slice-is-ascii.rs b/tests/codegen-llvm/slice-is-ascii.rs
new file mode 100644
index 00000000000..67537c871a0
--- /dev/null
+++ b/tests/codegen-llvm/slice-is-ascii.rs
@@ -0,0 +1,16 @@
+//@ only-x86_64
+//@ compile-flags: -C opt-level=3 -C target-cpu=x86-64
+#![crate_type = "lib"]
+
+/// Check that the fast-path of `is_ascii` uses a `pmovmskb` instruction.
+/// Platforms lacking an equivalent instruction use other techniques for
+/// optimizing `is_ascii`.
+// CHECK-LABEL: @is_ascii_autovectorized
+#[no_mangle]
+pub fn is_ascii_autovectorized(s: &[u8]) -> bool {
+    // CHECK: load <32 x i8>
+    // CHECK-NEXT: icmp slt <32 x i8>
+    // CHECK-NEXT: bitcast <32 x i1>
+    // CHECK-NEXT: icmp eq i32
+    s.is_ascii()
+}
diff --git a/tests/codegen-llvm/slice-iter-fold.rs b/tests/codegen-llvm/slice-iter-fold.rs
new file mode 100644
index 00000000000..55ab34661c3
--- /dev/null
+++ b/tests/codegen-llvm/slice-iter-fold.rs
@@ -0,0 +1,12 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @slice_fold_to_last
+#[no_mangle]
+pub fn slice_fold_to_last(slice: &[i32]) -> Option<&i32> {
+    // CHECK-NOT: loop
+    // CHECK-NOT: br
+    // CHECK-NOT: call
+    // CHECK: ret
+    slice.iter().fold(None, |_, i| Some(i))
+}
diff --git a/tests/codegen-llvm/slice-iter-len-eq-zero.rs b/tests/codegen-llvm/slice-iter-len-eq-zero.rs
new file mode 100644
index 00000000000..6998d98e498
--- /dev/null
+++ b/tests/codegen-llvm/slice-iter-len-eq-zero.rs
@@ -0,0 +1,60 @@
+//@ compile-flags: -Copt-level=3
+//@ needs-deterministic-layouts (opposite scalar pair orders breaks it)
+#![crate_type = "lib"]
+
+type Demo = [u8; 3];
+
+// CHECK-LABEL: @slice_iter_len_eq_zero
+#[no_mangle]
+pub fn slice_iter_len_eq_zero(y: std::slice::Iter<'_, Demo>) -> bool {
+    // CHECK-NOT: sub
+    // CHECK: %[[RET:.+]] = icmp eq ptr {{%y.0, %y.1|%y.1, %y.0}}
+    // CHECK: ret i1 %[[RET]]
+    y.len() == 0
+}
+
+// CHECK-LABEL: @slice_iter_len_eq_zero_ref
+#[no_mangle]
+pub fn slice_iter_len_eq_zero_ref(y: &mut std::slice::Iter<'_, Demo>) -> bool {
+    // CHECK-NOT: sub
+    // CHECK: %[[A:.+]] = load ptr
+    // CHECK-SAME: !nonnull
+    // CHECK: %[[B:.+]] = load ptr
+    // CHECK-SAME: !nonnull
+    // CHECK: %[[RET:.+]] = icmp eq ptr %[[A]], %[[B]]
+    // CHECK: ret i1 %[[RET]]
+    y.len() == 0
+}
+
+struct MyZST;
+
+// CHECK-LABEL: @slice_zst_iter_len_eq_zero
+#[no_mangle]
+pub fn slice_zst_iter_len_eq_zero(y: std::slice::Iter<'_, MyZST>) -> bool {
+    // CHECK: %[[RET:.+]] = icmp eq ptr %y.1, null
+    // CHECK: ret i1 %[[RET]]
+    y.len() == 0
+}
+
+// CHECK-LABEL: @slice_zst_iter_len_eq_zero_ref
+#[no_mangle]
+pub fn slice_zst_iter_len_eq_zero_ref(y: &mut std::slice::Iter<'_, MyZST>) -> bool {
+    // CHECK: %[[LEN:.+]] = load ptr
+    // CHECK-NOT: !nonnull
+    // CHECK: %[[RET:.+]] = icmp eq ptr %[[LEN]], null
+    // CHECK: ret i1 %[[RET]]
+    y.len() == 0
+}
+
+// CHECK-LABEL: @array_into_iter_len_eq_zero
+#[no_mangle]
+pub fn array_into_iter_len_eq_zero(y: std::array::IntoIter<Demo, 123>) -> bool {
+    // This should be able to just check that the indexes are equal, and not
+    // need any subtractions or comparisons to handle `start > end`.
+
+    // CHECK-NOT: icmp
+    // CHECK-NOT: sub
+    // CHECK: %_0 = icmp eq {{i16|i32|i64}}
+    // CHECK: ret i1 %_0
+    y.len() == 0
+}
diff --git a/tests/codegen-llvm/slice-iter-nonnull.rs b/tests/codegen-llvm/slice-iter-nonnull.rs
new file mode 100644
index 00000000000..87907e7ad0a
--- /dev/null
+++ b/tests/codegen-llvm/slice-iter-nonnull.rs
@@ -0,0 +1,115 @@
+//@ compile-flags: -Copt-level=3
+//@ needs-deterministic-layouts
+#![crate_type = "lib"]
+#![feature(exact_size_is_empty)]
+
+// The slice iterator used to `assume` that the `start` pointer was non-null.
+// That ought to be unneeded, though, since the type is `NonNull`, so this test
+// confirms that the appropriate metadata is included to denote that.
+
+// It also used to `assume` the `end` pointer was non-null, but that's no longer
+// needed as the code changed to read it as a `NonNull`, and thus gets the
+// appropriate `!nonnull` annotations naturally.
+
+// CHECK-LABEL: @slice_iter_next(
+#[no_mangle]
+pub fn slice_iter_next<'a>(it: &mut std::slice::Iter<'a, u32>) -> Option<&'a u32> {
+    // CHECK: %[[START:.+]] = load ptr, ptr %it,
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: %[[ENDP:.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %it, {{i32 4|i64 8}}
+    // CHECK: %[[END:.+]] = load ptr, ptr %[[ENDP]]
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: icmp eq ptr %[[START]], %[[END]]
+
+    // CHECK: store ptr{{.+}}, ptr %it,
+
+    it.next()
+}
+
+// CHECK-LABEL: @slice_iter_next_back(
+#[no_mangle]
+pub fn slice_iter_next_back<'a>(it: &mut std::slice::Iter<'a, u32>) -> Option<&'a u32> {
+    // CHECK: %[[ENDP:.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %it, {{i32 4|i64 8}}
+    // CHECK: %[[END:.+]] = load ptr, ptr %[[ENDP]]
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: %[[START:.+]] = load ptr, ptr %it,
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: icmp eq ptr %[[START]], %[[END]]
+
+    // CHECK: store ptr{{.+}}, ptr %[[ENDP]],
+
+    it.next_back()
+}
+
+// The slice iterator `new` methods used to `assume` that the pointer is non-null,
+// but passing slices already requires that, to the extent that LLVM actually
+// removed the `call @llvm.assume` anyway.  These tests just demonstrate that the
+// attribute is there, and confirms adding the assume back doesn't do anything.
+
+// CHECK-LABEL: @slice_iter_new
+// CHECK-SAME: (ptr noalias noundef nonnull {{.+}} %slice.0, {{.+}} noundef %slice.1)
+#[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-NOT: slice
+    // CHECK: insertvalue {{.+}} ptr %slice.0, 0
+    // CHECK-NOT: slice
+    // CHECK: insertvalue {{.+}} ptr %[[END]], 1
+    // CHECK-NOT: slice
+    // CHECK: }
+    slice.iter()
+}
+
+// CHECK-LABEL: @slice_iter_mut_new
+// CHECK-SAME: (ptr noalias noundef nonnull {{.+}} %slice.0, {{.+}} noundef %slice.1)
+#[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-NOT: slice
+    // CHECK: insertvalue {{.+}} ptr %slice.0, 0
+    // CHECK-NOT: slice
+    // CHECK: insertvalue {{.+}} ptr %[[END]], 1
+    // CHECK-NOT: slice
+    // CHECK: }
+    slice.iter_mut()
+}
+
+// CHECK-LABEL: @slice_iter_is_empty
+#[no_mangle]
+pub fn slice_iter_is_empty(it: &std::slice::Iter<'_, u32>) -> bool {
+    // CHECK: %[[ENDP:.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %it, {{i32 4|i64 8}}
+    // CHECK: %[[END:.+]] = load ptr, ptr %[[ENDP]]
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: %[[START:.+]] = load ptr, ptr %it,
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+
+    // CHECK: %[[RET:.+]] = icmp eq ptr %[[START]], %[[END]]
+    // CHECK: ret i1 %[[RET]]
+    it.is_empty()
+}
+
+// CHECK-LABEL: @slice_iter_len
+#[no_mangle]
+pub fn slice_iter_len(it: &std::slice::Iter<'_, u32>) -> usize {
+    // CHECK: %[[ENDP:.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %it, {{i32 4|i64 8}}
+    // CHECK: %[[END:.+]] = load ptr, ptr %[[ENDP]]
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: %[[START:.+]] = load ptr, ptr %it,
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+
+    // CHECK: ptrtoint
+    // CHECK: ptrtoint
+    // CHECK: sub nuw
+    // CHECK: lshr exact
+    it.len()
+}
diff --git a/tests/codegen-llvm/slice-last-elements-optimization.rs b/tests/codegen-llvm/slice-last-elements-optimization.rs
new file mode 100644
index 00000000000..b90f91d7b17
--- /dev/null
+++ b/tests/codegen-llvm/slice-last-elements-optimization.rs
@@ -0,0 +1,37 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+//@ min-llvm-version: 20
+#![crate_type = "lib"]
+
+// This test verifies that LLVM 20 properly optimizes the bounds check
+// when accessing the last few elements of a slice with proper conditions.
+// Previously, this would generate an unreachable branch to
+// slice_start_index_len_fail even when the bounds check was provably safe.
+
+// CHECK-LABEL: @last_four_initial(
+#[no_mangle]
+pub fn last_four_initial(s: &[u8]) -> &[u8] {
+    // Previously this would generate a branch to slice_start_index_len_fail
+    // that is unreachable. The LLVM 20 fix should eliminate this branch.
+    // CHECK-NOT: slice_start_index_len_fail
+    // CHECK-NOT: unreachable
+    let start = if s.len() <= 4 { 0 } else { s.len() - 4 };
+    &s[start..]
+}
+
+// CHECK-LABEL: @last_four_optimized(
+#[no_mangle]
+pub fn last_four_optimized(s: &[u8]) -> &[u8] {
+    // This version was already correctly optimized before the fix in LLVM 20.
+    // CHECK-NOT: slice_start_index_len_fail
+    // CHECK-NOT: unreachable
+    if s.len() <= 4 { &s[0..] } else { &s[s.len() - 4..] }
+}
+
+// Just to verify we're correctly checking for the right thing
+// CHECK-LABEL: @test_bounds_check_happens(
+#[no_mangle]
+pub fn test_bounds_check_happens(s: &[u8], i: usize) -> &[u8] {
+    // CHECK: slice_start_index_len_fail
+    &s[i..]
+}
diff --git a/tests/codegen-llvm/slice-pointer-nonnull-unwrap.rs b/tests/codegen-llvm/slice-pointer-nonnull-unwrap.rs
new file mode 100644
index 00000000000..35e4bf2c661
--- /dev/null
+++ b/tests/codegen-llvm/slice-pointer-nonnull-unwrap.rs
@@ -0,0 +1,18 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+use std::ptr::NonNull;
+
+// CHECK-LABEL: @slice_ptr_len_1
+// CHECK-NEXT: {{.*}}:
+// CHECK-NEXT: ret {{i(32|64)}} %ptr.1
+#[no_mangle]
+pub fn slice_ptr_len_1(ptr: *const [u8]) -> usize {
+    let ptr = ptr.cast_mut();
+    if let Some(ptr) = NonNull::new(ptr) {
+        ptr.len()
+    } else {
+        // We know ptr is null, so we know ptr.wrapping_byte_add(1) is not null.
+        NonNull::new(ptr.wrapping_byte_add(1)).unwrap().len()
+    }
+}
diff --git a/tests/codegen-llvm/slice-position-bounds-check.rs b/tests/codegen-llvm/slice-position-bounds-check.rs
new file mode 100644
index 00000000000..0d1d1d869ae
--- /dev/null
+++ b/tests/codegen-llvm/slice-position-bounds-check.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Copt-level=3 -C panic=abort
+#![crate_type = "lib"]
+
+fn search<T: Ord + Eq>(arr: &mut [T], a: &T) -> Result<usize, ()> {
+    match arr.iter().position(|x| x == a) {
+        Some(p) => Ok(p),
+        None => Err(()),
+    }
+}
+
+// CHECK-LABEL: @position_no_bounds_check
+#[no_mangle]
+pub fn position_no_bounds_check(y: &mut [u32], x: &u32, z: &u32) -> bool {
+    // This contains "call assume" so we cannot just rule out all calls
+    // CHECK-NOT: panic_bounds_check
+    if let Ok(p) = search(y, x) { y[p] == *z } else { false }
+}
+
+// just to make sure that panicking really emits "panic_bounds_check" somewhere in the IR
+// CHECK-LABEL: @test_check
+#[no_mangle]
+pub fn test_check(y: &[i32]) -> i32 {
+    // CHECK: panic_bounds_check
+    y[12]
+}
diff --git a/tests/codegen-llvm/slice-ref-equality.rs b/tests/codegen-llvm/slice-ref-equality.rs
new file mode 100644
index 00000000000..2940378da3c
--- /dev/null
+++ b/tests/codegen-llvm/slice-ref-equality.rs
@@ -0,0 +1,90 @@
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+#![crate_type = "lib"]
+
+use std::num::NonZero;
+
+// #71602 reported a simple array comparison just generating a loop.
+// This was originally fixed by ensuring it generates a single bcmp,
+// but we now generate it as a load+icmp instead. `is_zero_slice` was
+// tweaked to still test the case of comparison against a slice,
+// and `is_zero_array` tests the new array-specific behaviour.
+// The optimization was then extended to short slice-to-array comparisons,
+// so the first test here now has a long slice to still get the bcmp.
+
+// CHECK-LABEL: @is_zero_slice_long
+#[no_mangle]
+pub fn is_zero_slice_long(data: &[u8; 456]) -> bool {
+    // CHECK: %[[BCMP:.+]] = tail call i32 @{{bcmp|memcmp}}({{.+}})
+    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[BCMP]], 0
+    // CHECK-NEXT: ret i1 %[[EQ]]
+    &data[..] == [0; 456]
+}
+
+// CHECK-LABEL: @is_zero_slice_short
+#[no_mangle]
+pub fn is_zero_slice_short(data: &[u8; 4]) -> bool {
+    // CHECK: %[[LOAD:.+]] = load i32, ptr %{{.+}}, align 1
+    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[LOAD]], 0
+    // CHECK-NEXT: ret i1 %[[EQ]]
+    &data[..] == [0; 4]
+}
+
+// CHECK-LABEL: @is_zero_array
+#[no_mangle]
+pub fn is_zero_array(data: &[u8; 4]) -> bool {
+    // CHECK: %[[LOAD:.+]] = load i32, ptr %{{.+}}, align 1
+    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[LOAD]], 0
+    // CHECK-NEXT: ret i1 %[[EQ]]
+    *data == [0; 4]
+}
+
+// The following test the extra specializations to make sure that slice
+// equality for non-byte types also just emit a `bcmp`, not a loop.
+
+// CHECK-LABEL: @eq_slice_of_nested_u8(
+// CHECK-SAME: [[USIZE:i16|i32|i64]] noundef %x.1
+// CHECK-SAME: [[USIZE]] noundef %y.1
+#[no_mangle]
+fn eq_slice_of_nested_u8(x: &[[u8; 3]], y: &[[u8; 3]]) -> bool {
+    // CHECK: icmp eq [[USIZE]] %x.1, %y.1
+    // CHECK: %[[BYTES:.+]] = mul nuw nsw [[USIZE]] {{%x.1|%y.1}}, 3
+    // CHECK: tail call{{( noundef)?}} i32 @{{bcmp|memcmp}}(ptr
+    // CHECK-SAME: , [[USIZE]]{{( noundef)?}} %[[BYTES]])
+    x == y
+}
+
+// CHECK-LABEL: @eq_slice_of_i32(
+// CHECK-SAME: [[USIZE:i16|i32|i64]] noundef %x.1
+// CHECK-SAME: [[USIZE]] noundef %y.1
+#[no_mangle]
+fn eq_slice_of_i32(x: &[i32], y: &[i32]) -> bool {
+    // CHECK: icmp eq [[USIZE]] %x.1, %y.1
+    // CHECK: %[[BYTES:.+]] = shl nuw nsw [[USIZE]] {{%x.1|%y.1}}, 2
+    // CHECK: tail call{{( noundef)?}} i32 @{{bcmp|memcmp}}(ptr
+    // CHECK-SAME: , [[USIZE]]{{( noundef)?}} %[[BYTES]])
+    x == y
+}
+
+// CHECK-LABEL: @eq_slice_of_nonzero(
+// CHECK-SAME: [[USIZE:i16|i32|i64]] noundef %x.1
+// CHECK-SAME: [[USIZE]] noundef %y.1
+#[no_mangle]
+fn eq_slice_of_nonzero(x: &[NonZero<i32>], y: &[NonZero<i32>]) -> bool {
+    // CHECK: icmp eq [[USIZE]] %x.1, %y.1
+    // CHECK: %[[BYTES:.+]] = shl nuw nsw [[USIZE]] {{%x.1|%y.1}}, 2
+    // CHECK: tail call{{( noundef)?}} i32 @{{bcmp|memcmp}}(ptr
+    // CHECK-SAME: , [[USIZE]]{{( noundef)?}} %[[BYTES]])
+    x == y
+}
+
+// CHECK-LABEL: @eq_slice_of_option_of_nonzero(
+// CHECK-SAME: [[USIZE:i16|i32|i64]] noundef %x.1
+// CHECK-SAME: [[USIZE]] noundef %y.1
+#[no_mangle]
+fn eq_slice_of_option_of_nonzero(x: &[Option<NonZero<i16>>], y: &[Option<NonZero<i16>>]) -> bool {
+    // CHECK: icmp eq [[USIZE]] %x.1, %y.1
+    // CHECK: %[[BYTES:.+]] = shl nuw nsw [[USIZE]] {{%x.1|%y.1}}, 1
+    // CHECK: tail call{{( noundef)?}} i32 @{{bcmp|memcmp}}(ptr
+    // CHECK-SAME: , [[USIZE]]{{( noundef)?}} %[[BYTES]])
+    x == y
+}
diff --git a/tests/codegen-llvm/slice-reverse.rs b/tests/codegen-llvm/slice-reverse.rs
new file mode 100644
index 00000000000..e58d1c1d9d8
--- /dev/null
+++ b/tests/codegen-llvm/slice-reverse.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+//@ ignore-std-debug-assertions (debug assertions prevent generating shufflevector)
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @slice_reverse_u8
+#[no_mangle]
+pub fn slice_reverse_u8(slice: &mut [u8]) {
+    // CHECK-NOT: panic_bounds_check
+    // CHECK-NOT: slice_end_index_len_fail
+    // CHECK: shufflevector <{{[0-9]+}} x i8>
+    // CHECK-NOT: panic_bounds_check
+    // CHECK-NOT: slice_end_index_len_fail
+    slice.reverse();
+}
+
+// CHECK-LABEL: @slice_reverse_i32
+#[no_mangle]
+pub fn slice_reverse_i32(slice: &mut [i32]) {
+    // CHECK-NOT: panic_bounds_check
+    // CHECK-NOT: slice_end_index_len_fail
+    // CHECK: shufflevector <{{[0-9]+}} x i32>
+    // CHECK-NOT: panic_bounds_check
+    // CHECK-NOT: slice_end_index_len_fail
+    slice.reverse();
+}
diff --git a/tests/codegen-llvm/slice-split-at.rs b/tests/codegen-llvm/slice-split-at.rs
new file mode 100644
index 00000000000..07018cf9c91
--- /dev/null
+++ b/tests/codegen-llvm/slice-split-at.rs
@@ -0,0 +1,24 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// Check that no panic is generated in `split_at` when calculating the index for
+// the tail chunk using `checked_sub`.
+//
+// Tests written for refactored implementations of:
+// `<[T]>::{split_last_chunk, split_last_chunk_mut, last_chunk, last_chunk_mut}`
+
+// CHECK-LABEL: @split_at_last_chunk
+#[no_mangle]
+pub fn split_at_last_chunk(s: &[u8], chunk_size: usize) -> Option<(&[u8], &[u8])> {
+    // CHECK-NOT: panic
+    let Some(index) = s.len().checked_sub(chunk_size) else { return None };
+    Some(s.split_at(index))
+}
+
+// CHECK-LABEL: @split_at_mut_last_chunk
+#[no_mangle]
+pub fn split_at_mut_last_chunk(s: &mut [u8], chunk_size: usize) -> Option<(&mut [u8], &mut [u8])> {
+    // CHECK-NOT: panic
+    let Some(index) = s.len().checked_sub(chunk_size) else { return None };
+    Some(s.split_at_mut(index))
+}
diff --git a/tests/codegen-llvm/slice-windows-no-bounds-check.rs b/tests/codegen-llvm/slice-windows-no-bounds-check.rs
new file mode 100644
index 00000000000..87e89b14f06
--- /dev/null
+++ b/tests/codegen-llvm/slice-windows-no-bounds-check.rs
@@ -0,0 +1,32 @@
+#![crate_type = "lib"]
+
+//@ compile-flags: -Copt-level=3
+
+use std::slice::Windows;
+
+// CHECK-LABEL: @naive_string_search
+#[no_mangle]
+pub fn naive_string_search(haystack: &str, needle: &str) -> Option<usize> {
+    if needle.is_empty() {
+        return Some(0);
+    }
+    // CHECK-NOT: panic
+    // CHECK-NOT: fail
+    haystack.as_bytes().windows(needle.len()).position(|sub| sub == needle.as_bytes())
+}
+
+// CHECK-LABEL: @next
+#[no_mangle]
+pub fn next<'a>(w: &mut Windows<'a, u32>) -> Option<&'a [u32]> {
+    // CHECK-NOT: panic
+    // CHECK-NOT: fail
+    w.next()
+}
+
+// CHECK-LABEL: @next_back
+#[no_mangle]
+pub fn next_back<'a>(w: &mut Windows<'a, u32>) -> Option<&'a [u32]> {
+    // CHECK-NOT: panic
+    // CHECK-NOT: fail
+    w.next_back()
+}
diff --git a/tests/codegen-llvm/slice_as_from_ptr_range.rs b/tests/codegen-llvm/slice_as_from_ptr_range.rs
new file mode 100644
index 00000000000..2073f05c07f
--- /dev/null
+++ b/tests/codegen-llvm/slice_as_from_ptr_range.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -Copt-level=3
+//@ only-64bit (because we're using [ui]size)
+
+#![crate_type = "lib"]
+#![feature(slice_from_ptr_range)]
+
+// This is intentionally using a non-power-of-two array length,
+// as that's where the optimization differences show up
+
+// CHECK-LABEL: @flatten_via_ptr_range
+#[no_mangle]
+pub fn flatten_via_ptr_range(slice_of_arrays: &[[i32; 13]]) -> &[i32] {
+    // CHECK-NOT: lshr
+    // CHECK-NOT: udiv
+    // CHECK: mul nuw nsw i64 %{{.+}}, 13
+    // CHECK-NOT: lshr
+    // CHECK-NOT: udiv
+    let r = slice_of_arrays.as_ptr_range();
+    let r = r.start.cast()..r.end.cast();
+    unsafe { core::slice::from_ptr_range(r) }
+}
diff --git a/tests/codegen-llvm/some-abis-do-extend-params-to-32-bits.rs b/tests/codegen-llvm/some-abis-do-extend-params-to-32-bits.rs
new file mode 100644
index 00000000000..6ca6697588f
--- /dev/null
+++ b/tests/codegen-llvm/some-abis-do-extend-params-to-32-bits.rs
@@ -0,0 +1,236 @@
+//@ add-core-stubs
+//@ compile-flags: -Cno-prepopulate-passes -Copt-level=0
+
+//@ revisions:x86_64 i686 aarch64-apple aarch64-windows aarch64-linux arm riscv
+
+//@[x86_64] compile-flags: --target x86_64-unknown-uefi
+//@[x86_64] needs-llvm-components: x86
+//@[i686] compile-flags: --target i686-unknown-linux-musl
+//@[i686] needs-llvm-components: x86
+//@[aarch64-windows] compile-flags: --target aarch64-pc-windows-msvc
+//@[aarch64-windows] needs-llvm-components: aarch64
+//@[aarch64-linux] compile-flags: --target aarch64-unknown-linux-gnu
+//@[aarch64-linux] needs-llvm-components: aarch64
+//@[aarch64-apple] compile-flags: --target aarch64-apple-darwin
+//@[aarch64-apple] needs-llvm-components: aarch64
+//@[arm] compile-flags: --target armv7r-none-eabi
+//@[arm] needs-llvm-components: arm
+//@[riscv] compile-flags: --target riscv64gc-unknown-none-elf
+//@[riscv] needs-llvm-components: riscv
+
+// See bottom of file for a corresponding C source file that is meant to yield
+// equivalent declarations.
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+// The patterns in this file are written in the style of a table to make the
+// uniformities and distinctions more apparent.
+//
+//                  ZERO/SIGN-EXTENDING TO 32 BITS            NON-EXTENDING
+//                  ==============================  =======================
+// x86_64:          void @c_arg_u8(i8 zeroext %_a)
+// i686:            void @c_arg_u8(i8 zeroext %_a)
+// aarch64-apple:   void @c_arg_u8(i8 zeroext %_a)
+// aarch64-windows:                                  void @c_arg_u8(i8 %_a)
+// aarch64-linux:                                    void @c_arg_u8(i8 %_a)
+// arm:             void @c_arg_u8(i8 zeroext %_a)
+// riscv:           void @c_arg_u8(i8 zeroext %_a)
+#[no_mangle]
+pub extern "C" fn c_arg_u8(_a: u8) {}
+
+// x86_64:          void @c_arg_u16(i16 zeroext %_a)
+// i686:            void @c_arg_u16(i16 zeroext %_a)
+// aarch64-apple:   void @c_arg_u16(i16 zeroext %_a)
+// aarch64-windows:                                 void @c_arg_u16(i16 %_a)
+// aarch64-linux:                                   void @c_arg_u16(i16 %_a)
+// arm:             void @c_arg_u16(i16 zeroext %_a)
+// riscv:           void @c_arg_u16(i16 zeroext %_a)
+#[no_mangle]
+pub extern "C" fn c_arg_u16(_a: u16) {}
+
+// x86_64:          void @c_arg_u32(i32 %_a)
+// i686:            void @c_arg_u32(i32 %_a)
+// aarch64-apple:   void @c_arg_u32(i32 %_a)
+// aarch64-windows:                                 void @c_arg_u32(i32 %_a)
+// aarch64-linux:                                   void @c_arg_u32(i32 %_a)
+// arm:             void @c_arg_u32(i32 %_a)
+// riscv:           void @c_arg_u32(i32 signext %_a)
+#[no_mangle]
+pub extern "C" fn c_arg_u32(_a: u32) {}
+
+// x86_64:          void @c_arg_u64(i64 %_a)
+// i686:            void @c_arg_u64(i64 %_a)
+// aarch64-apple:   void @c_arg_u64(i64 %_a)
+// aarch64-windows:                                 void @c_arg_u64(i64 %_a)
+// aarch64-linux:                                   void @c_arg_u64(i64 %_a)
+// arm:             void @c_arg_u64(i64 %_a)
+// riscv:           void @c_arg_u64(i64 %_a)
+#[no_mangle]
+pub extern "C" fn c_arg_u64(_a: u64) {}
+
+// x86_64:          void @c_arg_i8(i8 signext %_a)
+// i686:            void @c_arg_i8(i8 signext %_a)
+// aarch64-apple:   void @c_arg_i8(i8 signext %_a)
+// aarch64-windows:                                  void @c_arg_i8(i8 %_a)
+// aarch64-linux:                                    void @c_arg_i8(i8 %_a)
+// arm:             void @c_arg_i8(i8 signext %_a)
+// riscv:           void @c_arg_i8(i8 signext %_a)
+#[no_mangle]
+pub extern "C" fn c_arg_i8(_a: i8) {}
+
+// x86_64:          void @c_arg_i16(i16 signext %_a)
+// i686:            void @c_arg_i16(i16 signext %_a)
+// aarch64-apple:   void @c_arg_i16(i16 signext %_a)
+// aarch64-windows:                                 void @c_arg_i16(i16 %_a)
+// aarch64-linux:                                   void @c_arg_i16(i16 %_a)
+// arm:             void @c_arg_i16(i16 signext %_a)
+// riscv:           void @c_arg_i16(i16 signext %_a)
+#[no_mangle]
+pub extern "C" fn c_arg_i16(_a: i16) {}
+
+// x86_64:          void @c_arg_i32(i32 %_a)
+// i686:            void @c_arg_i32(i32 %_a)
+// aarch64-apple:   void @c_arg_i32(i32 %_a)
+// aarch64-windows:                                 void @c_arg_i32(i32 %_a)
+// aarch64-linux:                                   void @c_arg_i32(i32 %_a)
+// arm:             void @c_arg_i32(i32 %_a)
+// riscv:           void @c_arg_i32(i32 signext %_a)
+#[no_mangle]
+pub extern "C" fn c_arg_i32(_a: i32) {}
+
+// x86_64:          void @c_arg_i64(i64 %_a)
+// i686:            void @c_arg_i64(i64 %_a)
+// aarch64-apple:   void @c_arg_i64(i64 %_a)
+// aarch64-windows:                                 void @c_arg_i64(i64 %_a)
+// aarch64-linux:                                   void @c_arg_i64(i64 %_a)
+// arm:             void @c_arg_i64(i64 %_a)
+// riscv:           void @c_arg_i64(i64 %_a)
+#[no_mangle]
+pub extern "C" fn c_arg_i64(_a: i64) {}
+
+// x86_64:          zeroext i8 @c_ret_u8()
+// i686:            zeroext i8 @c_ret_u8()
+// aarch64-apple:   zeroext i8 @c_ret_u8()
+// aarch64-windows:                                 i8 @c_ret_u8()
+// aarch64-linux:                                   i8 @c_ret_u8()
+// arm:             zeroext i8 @c_ret_u8()
+// riscv:           zeroext i8 @c_ret_u8()
+#[no_mangle]
+pub extern "C" fn c_ret_u8() -> u8 {
+    0
+}
+
+// x86_64:          zeroext i16 @c_ret_u16()
+// i686:            zeroext i16 @c_ret_u16()
+// aarch64-apple:   zeroext i16 @c_ret_u16()
+// aarch64-windows:                                 i16 @c_ret_u16()
+// aarch64-linux:                                   i16 @c_ret_u16()
+// arm:             zeroext i16 @c_ret_u16()
+// riscv:           zeroext i16 @c_ret_u16()
+#[no_mangle]
+pub extern "C" fn c_ret_u16() -> u16 {
+    0
+}
+
+// x86_64:          i32 @c_ret_u32()
+// i686:            i32 @c_ret_u32()
+// aarch64-apple:   i32 @c_ret_u32()
+// aarch64-windows:                                 i32 @c_ret_u32()
+// aarch64-linux:                                   i32 @c_ret_u32()
+// arm:             i32 @c_ret_u32()
+// riscv:           signext i32 @c_ret_u32()
+#[no_mangle]
+pub extern "C" fn c_ret_u32() -> u32 {
+    0
+}
+
+// x86_64:          i64 @c_ret_u64()
+// i686:            i64 @c_ret_u64()
+// aarch64-apple:   i64 @c_ret_u64()
+// aarch64-windows:                                 i64 @c_ret_u64()
+// aarch64-linux:                                   i64 @c_ret_u64()
+// arm:             i64 @c_ret_u64()
+// riscv:           i64 @c_ret_u64()
+#[no_mangle]
+pub extern "C" fn c_ret_u64() -> u64 {
+    0
+}
+
+// x86_64:          signext i8 @c_ret_i8()
+// i686:            signext i8 @c_ret_i8()
+// aarch64-apple:   signext i8 @c_ret_i8()
+// aarch64-windows:                                 i8 @c_ret_i8()
+// aarch64-linux:                                   i8 @c_ret_i8()
+// arm:             signext i8 @c_ret_i8()
+// riscv:           signext i8 @c_ret_i8()
+#[no_mangle]
+pub extern "C" fn c_ret_i8() -> i8 {
+    0
+}
+
+// x86_64:          signext i16 @c_ret_i16()
+// i686:            signext i16 @c_ret_i16()
+// aarch64-apple:   signext i16 @c_ret_i16()
+// aarch64-windows:                                 i16 @c_ret_i16()
+// aarch64-linux:                                   i16 @c_ret_i16()
+// arm:             signext i16 @c_ret_i16()
+// riscv:           signext i16 @c_ret_i16()
+#[no_mangle]
+pub extern "C" fn c_ret_i16() -> i16 {
+    0
+}
+
+// x86_64:          i32 @c_ret_i32()
+// i686:            i32 @c_ret_i32()
+// aarch64-apple:   i32 @c_ret_i32()
+// aarch64-windows:                                 i32 @c_ret_i32()
+// aarch64-linux:                                   i32 @c_ret_i32()
+// arm:             i32 @c_ret_i32()
+// riscv:           signext i32 @c_ret_i32()
+#[no_mangle]
+pub extern "C" fn c_ret_i32() -> i32 {
+    0
+}
+
+// x86_64:          i64 @c_ret_i64()
+// i686:            i64 @c_ret_i64()
+// aarch64-apple:   i64 @c_ret_i64()
+// aarch64-windows:                                 i64 @c_ret_i64()
+// aarch64-linux:                                   i64 @c_ret_i64()
+// arm:             i64 @c_ret_i64()
+// riscv:           i64 @c_ret_i64()
+#[no_mangle]
+pub extern "C" fn c_ret_i64() -> i64 {
+    0
+}
+
+const C_SOURCE_FILE: &'static str = r##"
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+
+void c_arg_u8(uint8_t _a) { }
+void c_arg_u16(uint16_t _a) { }
+void c_arg_u32(uint32_t _a) { }
+void c_arg_u64(uint64_t _a) { }
+
+void c_arg_i8(int8_t _a) { }
+void c_arg_i16(int16_t _a) { }
+void c_arg_i32(int32_t _a) { }
+void c_arg_i64(int64_t _a) { }
+
+uint8_t  c_ret_u8()  { return 0; }
+uint16_t c_ret_u16() { return 0; }
+uint32_t c_ret_u32() { return 0; }
+uint64_t c_ret_u64() { return 0; }
+
+int8_t   c_ret_i8()  { return 0; }
+int16_t  c_ret_i16() { return 0; }
+int32_t  c_ret_i32() { return 0; }
+int64_t  c_ret_i64() { return 0; }
+"##;
diff --git a/tests/codegen-llvm/some-global-nonnull.rs b/tests/codegen-llvm/some-global-nonnull.rs
new file mode 100644
index 00000000000..bb4d12e1c76
--- /dev/null
+++ b/tests/codegen-llvm/some-global-nonnull.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @test
+// CHECK-NEXT: start:
+// CHECK-NEXT: tail call void @ext_fn0()
+#[no_mangle]
+pub fn test() {
+    test_inner(Some(inner0));
+}
+
+fn test_inner(f_maybe: Option<fn()>) {
+    if let Some(f) = f_maybe {
+        f();
+    }
+}
+
+fn inner0() {
+    unsafe { ext_fn0() };
+}
+
+extern "C" {
+    fn ext_fn0();
+}
diff --git a/tests/codegen-llvm/sparc-struct-abi.rs b/tests/codegen-llvm/sparc-struct-abi.rs
new file mode 100644
index 00000000000..32d2c5bb0ef
--- /dev/null
+++ b/tests/codegen-llvm/sparc-struct-abi.rs
@@ -0,0 +1,97 @@
+// Checks that we correctly codegen extern "C" functions returning structs.
+// See issues #52638 and #86163.
+
+//@ add-core-stubs
+//@ compile-flags: -Copt-level=3 --target=sparc64-unknown-linux-gnu --crate-type=rlib
+//@ needs-llvm-components: sparc
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[repr(C)]
+pub struct Bool {
+    b: bool,
+}
+
+// CHECK: define{{.*}} i64 @structbool()
+// CHECK-NEXT: start:
+// CHECK-NEXT: ret i64 72057594037927936
+#[no_mangle]
+pub extern "C" fn structbool() -> Bool {
+    Bool { b: true }
+}
+
+#[repr(C)]
+pub struct BoolFloat {
+    b: bool,
+    f: f32,
+}
+
+// CHECK: define inreg { i32, float } @structboolfloat()
+// CHECK-NEXT: start:
+// CHECK-NEXT: ret { i32, float } { i32 16777216, float 0x40091EB860000000 }
+#[no_mangle]
+pub extern "C" fn structboolfloat() -> BoolFloat {
+    BoolFloat { b: true, f: 3.14 }
+}
+
+// CHECK: define void @structboolfloat_input({ i32, float } inreg %0)
+// CHECK-NEXT: start:
+#[no_mangle]
+pub extern "C" fn structboolfloat_input(a: BoolFloat) {}
+
+#[repr(C)]
+pub struct ShortDouble {
+    s: i16,
+    d: f64,
+}
+
+// CHECK: define { i64, double } @structshortdouble()
+// CHECK-NEXT: start:
+// CHECK-NEXT: ret { i64, double } { i64 34621422135410688, double 3.140000e+00 }
+#[no_mangle]
+pub extern "C" fn structshortdouble() -> ShortDouble {
+    ShortDouble { s: 123, d: 3.14 }
+}
+
+// CHECK: define void @structshortdouble_input({ i64, double } %0)
+// CHECK-NEXT: start:
+#[no_mangle]
+pub extern "C" fn structshortdouble_input(a: ShortDouble) {}
+
+#[repr(C)]
+pub struct FloatLongFloat {
+    f: f32,
+    i: i64,
+    g: f32,
+}
+
+// CHECK: define inreg { float, i32, i64, float, i32 } @structfloatlongfloat()
+// CHECK-NEXT: start:
+// CHECK-NEXT: ret { float, i32, i64, float, i32 } { float 0x3FB99999A0000000, i32 undef, i64 123, float 0x40091EB860000000, i32 undef }
+#[no_mangle]
+pub extern "C" fn structfloatlongfloat() -> FloatLongFloat {
+    FloatLongFloat { f: 0.1, i: 123, g: 3.14 }
+}
+
+#[repr(C)]
+pub struct FloatFloat {
+    f: f32,
+    g: f32,
+}
+
+#[repr(C)]
+pub struct NestedStructs {
+    a: FloatFloat,
+    b: FloatFloat,
+}
+
+// CHECK: define inreg { float, float, float, float } @structnestestructs()
+// CHECK-NEXT: start:
+// CHECK-NEXT: ret { float, float, float, float } { float 0x3FB99999A0000000, float 0x3FF19999A0000000, float 0x40019999A0000000, float 0x400A666660000000 }
+#[no_mangle]
+pub extern "C" fn structnestestructs() -> NestedStructs {
+    NestedStructs { a: FloatFloat { f: 0.1, g: 1.1 }, b: FloatFloat { f: 2.2, g: 3.3 } }
+}
diff --git a/tests/codegen-llvm/split-lto-unit.rs b/tests/codegen-llvm/split-lto-unit.rs
new file mode 100644
index 00000000000..7858a0e7b79
--- /dev/null
+++ b/tests/codegen-llvm/split-lto-unit.rs
@@ -0,0 +1,10 @@
+// Verifies that "EnableSplitLTOUnit" module flag is added.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsplit-lto-unit
+
+#![crate_type = "lib"]
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"EnableSplitLTOUnit", i32 1}
diff --git a/tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-md5.rs b/tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-md5.rs
new file mode 100644
index 00000000000..7aec8d545dc
--- /dev/null
+++ b/tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-md5.rs
@@ -0,0 +1,6 @@
+//@ compile-flags: -g -Z src-hash-algorithm=md5 -Copt-level=0
+
+#![crate_type = "lib"]
+
+pub fn test() {}
+// CHECK: checksumkind: CSK_MD5
diff --git a/tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-sha1.rs b/tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-sha1.rs
new file mode 100644
index 00000000000..5389c32f938
--- /dev/null
+++ b/tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-sha1.rs
@@ -0,0 +1,6 @@
+//@ compile-flags: -g -Z src-hash-algorithm=sha1 -Copt-level=0
+
+#![crate_type = "lib"]
+
+pub fn test() {}
+// CHECK: checksumkind: CSK_SHA1
diff --git a/tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-sha256.rs b/tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-sha256.rs
new file mode 100644
index 00000000000..520890c47f1
--- /dev/null
+++ b/tests/codegen-llvm/src-hash-algorithm/src-hash-algorithm-sha256.rs
@@ -0,0 +1,6 @@
+//@ compile-flags: -g -Z src-hash-algorithm=sha256 -Copt-level=0
+
+#![crate_type = "lib"]
+
+pub fn test() {}
+// CHECK: checksumkind: CSK_SHA256
diff --git a/tests/codegen-llvm/sroa-fragment-debuginfo.rs b/tests/codegen-llvm/sroa-fragment-debuginfo.rs
new file mode 100644
index 00000000000..0413cf96894
--- /dev/null
+++ b/tests/codegen-llvm/sroa-fragment-debuginfo.rs
@@ -0,0 +1,46 @@
+//@ compile-flags: -g -Zmir-opt-level=0 -Zmir-enable-passes=+ScalarReplacementOfAggregates
+//@ compile-flags: -Cno-prepopulate-passes
+//
+// Tested offsets are only correct for x86_64.
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+pub struct ExtraSlice<'input> {
+    slice: &'input [u8],
+    extra: u32,
+}
+
+#[no_mangle]
+pub fn extra(s: &[u8]) {
+    // CHECK: void @extra(
+    // CHECK: %slice.dbg.spill1 = alloca [4 x i8],
+    // CHECK: %slice.dbg.spill = alloca [16 x i8],
+    // CHECK: %s.dbg.spill = alloca [16 x i8],
+    // CHECK: dbg{{.}}declare({{(metadata )?}}ptr %s.dbg.spill, {{(metadata )?}}![[S_EXTRA:.*]], {{(metadata )?}}!DIExpression()
+    // CHECK: dbg{{.}}declare({{(metadata )?}}ptr %slice.dbg.spill, {{(metadata )?}}![[SLICE_EXTRA:.*]], {{(metadata )?}}!DIExpression(DW_OP_LLVM_fragment, 0, 128)
+    // CHECK: dbg{{.}}declare({{(metadata )?}}ptr %slice.dbg.spill1, {{(metadata )?}}![[SLICE_EXTRA]], {{(metadata )?}}!DIExpression(DW_OP_LLVM_fragment, 128, 32)
+    let slice = ExtraSlice { slice: s, extra: s.len() as u32 };
+}
+
+struct Zst;
+
+pub struct ZstSlice<'input> {
+    slice: &'input [u8],
+    extra: Zst,
+}
+
+#[no_mangle]
+pub fn zst(s: &[u8]) {
+    // The field `extra` is a ZST. The fragment for the field `slice` encompasses the whole
+    // variable, so is not a fragment. In that case, the variable must have no fragment.
+
+    // CHECK: void @zst(
+    // CHECK-NOT: dbg{{.}}declare({{(metadata )?}}ptr %slice.dbg.spill, {{(metadata )?}}!{}, {{(metadata )?}}!DIExpression(DW_OP_LLVM_fragment,
+    // CHECK: dbg{{.}}declare({{(metadata )?}}ptr %{{.*}}, {{(metadata )?}}![[SLICE_ZST:.*]], {{(metadata )?}}!DIExpression()
+    // CHECK-NOT: dbg{{.}}declare({{(metadata )?}}ptr %{{.*}}, {{(metadata )?}}![[SLICE_ZST]],
+    let slice = ZstSlice { slice: s, extra: Zst };
+}
+
+// CHECK: ![[S_EXTRA]] = !DILocalVariable(name: "s",
+// CHECK: ![[SLICE_EXTRA]] = !DILocalVariable(name: "slice",
diff --git a/tests/codegen-llvm/sse42-implies-crc32.rs b/tests/codegen-llvm/sse42-implies-crc32.rs
new file mode 100644
index 00000000000..8a9c496a3a5
--- /dev/null
+++ b/tests/codegen-llvm/sse42-implies-crc32.rs
@@ -0,0 +1,15 @@
+//@ only-x86_64
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "sse4.2")]
+#[no_mangle]
+pub unsafe fn crc32sse(v: u8) -> u32 {
+    use std::arch::x86_64::*;
+    let out = !0u32;
+    _mm_crc32_u8(out, v)
+}
+
+// CHECK: attributes #0 {{.*"target-features"=".*\+sse4.2,\+crc32.*"}}
diff --git a/tests/codegen-llvm/stack-probes-inline.rs b/tests/codegen-llvm/stack-probes-inline.rs
new file mode 100644
index 00000000000..746272b0994
--- /dev/null
+++ b/tests/codegen-llvm/stack-probes-inline.rs
@@ -0,0 +1,33 @@
+// Check the "probe-stack" attribute for targets with `StackProbeType::Inline`,
+// or `StackProbeType::InlineOrCall` when running on newer LLVM.
+
+//@ add-core-stubs
+//@ compile-flags: -C no-prepopulate-passes
+//@ revisions: aarch64 powerpc powerpc64 powerpc64le s390x i686 x86_64
+//@[aarch64] compile-flags: --target aarch64-unknown-linux-gnu
+//@[aarch64] needs-llvm-components: aarch64
+//@[powerpc] compile-flags: --target powerpc-unknown-linux-gnu
+//@[powerpc] needs-llvm-components: powerpc
+//@[powerpc64] compile-flags: --target powerpc64-unknown-linux-gnu
+//@[powerpc64] needs-llvm-components: powerpc
+//@[powerpc64le] compile-flags: --target powerpc64le-unknown-linux-gnu
+//@[powerpc64le] needs-llvm-components: powerpc
+//@[s390x] compile-flags: --target s390x-unknown-linux-gnu
+//@[s390x] needs-llvm-components: systemz
+//@[i686] compile-flags: --target i686-unknown-linux-gnu
+//@[i686] needs-llvm-components: x86
+//@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu
+//@[x86_64] needs-llvm-components: x86
+
+#![crate_type = "rlib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+pub fn foo() {
+    // CHECK: @foo() unnamed_addr #0
+    // CHECK: attributes #0 = { {{.*}}"probe-stack"="inline-asm"{{.*}} }
+}
diff --git a/tests/codegen-llvm/stack-protector.rs b/tests/codegen-llvm/stack-protector.rs
new file mode 100644
index 00000000000..8ab25b470cd
--- /dev/null
+++ b/tests/codegen-llvm/stack-protector.rs
@@ -0,0 +1,34 @@
+//@ revisions: all strong basic none
+//@ ignore-nvptx64 stack protector not supported
+//@ [all] compile-flags: -Z stack-protector=all
+//@ [strong] compile-flags: -Z stack-protector=strong
+//@ [basic] compile-flags: -Z stack-protector=basic
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn foo() {
+    // CHECK: @foo() unnamed_addr #0
+
+    // all-NOT: attributes #0 = { {{.*}}sspstrong {{.*}} }
+    // all-NOT: attributes #0 = { {{.*}}ssp {{.*}} }
+    // all: attributes #0 = { {{.*}}sspreq {{.*}} }
+    // all-NOT: attributes #0 = { {{.*}}sspstrong {{.*}} }
+    // all-NOT: attributes #0 = { {{.*}}ssp {{.*}} }
+
+    // strong-NOT: attributes #0 = { {{.*}}sspreq {{.*}} }
+    // strong-NOT: attributes #0 = { {{.*}}ssp {{.*}} }
+    // strong: attributes #0 = { {{.*}}sspstrong {{.*}} }
+    // strong-NOT: attributes #0 = { {{.*}}sspreq {{.*}} }
+    // strong-NOT: attributes #0 = { {{.*}}ssp {{.*}} }
+
+    // basic-NOT: attributes #0 = { {{.*}}sspreq {{.*}} }
+    // basic-NOT: attributes #0 = { {{.*}}sspstrong {{.*}} }
+    // basic: attributes #0 = { {{.*}}ssp {{.*}} }
+    // basic-NOT: attributes #0 = { {{.*}}sspreq {{.*}} }
+    // basic-NOT: attributes #0 = { {{.*}}sspstrong {{.*}} }
+
+    // none-NOT: attributes #0 = { {{.*}}sspreq {{.*}} }
+    // none-NOT: attributes #0 = { {{.*}}sspstrong {{.*}} }
+    // none-NOT: attributes #0 = { {{.*}}ssp {{.*}} }
+}
diff --git a/tests/codegen-llvm/static-relocation-model-msvc.rs b/tests/codegen-llvm/static-relocation-model-msvc.rs
new file mode 100644
index 00000000000..4d30e6ec505
--- /dev/null
+++ b/tests/codegen-llvm/static-relocation-model-msvc.rs
@@ -0,0 +1,24 @@
+// Verify linkage of external symbols in the static relocation model on MSVC.
+//
+//@ compile-flags: -Copt-level=3 -C relocation-model=static
+//@ aux-build: extern_decl.rs
+//@ only-x86_64-pc-windows-msvc
+
+#![crate_type = "rlib"]
+
+extern crate extern_decl;
+
+// The `extern_decl` definitions are imported from a statically linked rust
+// crate, thus they are expected to be marked `dso_local` without `dllimport`.
+//
+// The `access_extern()` symbol is from this compilation unit, thus we expect
+// it to be marked `dso_local` as well, given the static relocation model.
+//
+// CHECK: @extern_static = external dso_local local_unnamed_addr global i8
+// CHECK: define dso_local noundef i8 @access_extern() {{.*}}
+// CHECK: declare dso_local noundef i8 @extern_fn() {{.*}}
+
+#[no_mangle]
+pub fn access_extern() -> u8 {
+    unsafe { extern_decl::extern_fn() + extern_decl::extern_static }
+}
diff --git a/tests/codegen-llvm/staticlib-external-inline-fns.rs b/tests/codegen-llvm/staticlib-external-inline-fns.rs
new file mode 100644
index 00000000000..23316a2d9a5
--- /dev/null
+++ b/tests/codegen-llvm/staticlib-external-inline-fns.rs
@@ -0,0 +1,43 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+#![crate_type = "staticlib"]
+
+// CHECK: define{{.*}}void @a()
+#[no_mangle]
+#[inline]
+pub extern "C" fn a() {}
+
+// CHECK: define{{.*}}void @b()
+#[export_name = "b"]
+#[inline]
+pub extern "C" fn b() {}
+
+// CHECK: define{{.*}}void @c()
+#[no_mangle]
+#[inline]
+extern "C" fn c() {}
+
+// CHECK: define{{.*}}void @d()
+#[export_name = "d"]
+#[inline]
+extern "C" fn d() {}
+
+// CHECK: define{{.*}}void @e()
+#[no_mangle]
+#[inline(always)]
+pub extern "C" fn e() {}
+
+// CHECK: define{{.*}}void @f()
+#[export_name = "f"]
+#[inline(always)]
+pub extern "C" fn f() {}
+
+// CHECK: define{{.*}}void @g()
+#[no_mangle]
+#[inline(always)]
+extern "C" fn g() {}
+
+// CHECK: define{{.*}}void @h()
+#[export_name = "h"]
+#[inline(always)]
+extern "C" fn h() {}
diff --git a/tests/codegen-llvm/step_by-overflow-checks.rs b/tests/codegen-llvm/step_by-overflow-checks.rs
new file mode 100644
index 00000000000..53800e9f879
--- /dev/null
+++ b/tests/codegen-llvm/step_by-overflow-checks.rs
@@ -0,0 +1,26 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+use std::iter::StepBy;
+use std::slice::Iter;
+
+// The constructor for `StepBy` ensures we can never end up needing to do zero
+// checks on denominators, so check that the code isn't emitting panic paths.
+
+// CHECK-LABEL: @step_by_len_std
+#[no_mangle]
+pub fn step_by_len_std(x: &StepBy<Iter<i32>>) -> usize {
+    // CHECK-NOT: div_by_zero
+    // CHECK: udiv
+    // CHECK-NOT: div_by_zero
+    x.len()
+}
+
+// CHECK-LABEL: @step_by_len_naive
+#[no_mangle]
+pub fn step_by_len_naive(x: Iter<i32>, step_minus_one: usize) -> usize {
+    // CHECK: udiv
+    // CHECK: call{{.+}}div_by_zero
+    x.len() / (step_minus_one + 1)
+}
diff --git a/tests/codegen-llvm/stores.rs b/tests/codegen-llvm/stores.rs
new file mode 100644
index 00000000000..aa3090db6d3
--- /dev/null
+++ b/tests/codegen-llvm/stores.rs
@@ -0,0 +1,35 @@
+//@ compile-flags: -C no-prepopulate-passes
+//
+
+#![crate_type = "lib"]
+
+pub struct Bytes {
+    a: u8,
+    b: u8,
+    c: u8,
+    d: u8,
+}
+
+// CHECK-LABEL: small_array_alignment
+// The array is stored as i32, but its alignment is lower, go with 1 byte to avoid target
+// dependent alignment
+#[no_mangle]
+pub fn small_array_alignment(x: &mut [i8; 4], y: [i8; 4]) {
+    // CHECK: [[TMP:%.+]] = alloca [4 x i8], align 4
+    // CHECK: %y = alloca [4 x i8], align 1
+    // CHECK: store i32 %0, ptr [[TMP]]
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 {{.+}}, ptr align 4 {{.+}}, i{{[0-9]+}} 4, i1 false)
+    *x = y;
+}
+
+// CHECK-LABEL: small_struct_alignment
+// The struct is stored as i32, but its alignment is lower, go with 1 byte to avoid target
+// dependent alignment
+#[no_mangle]
+pub fn small_struct_alignment(x: &mut Bytes, y: Bytes) {
+    // CHECK: [[TMP:%.+]] = alloca [4 x i8], align 4
+    // CHECK: %y = alloca [4 x i8], align 1
+    // CHECK: store i32 %0, ptr [[TMP]]
+    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 {{.+}}, ptr align 4 {{.+}}, i{{[0-9]+}} 4, i1 false)
+    *x = y;
+}
diff --git a/tests/codegen-llvm/string-push.rs b/tests/codegen-llvm/string-push.rs
new file mode 100644
index 00000000000..cf5f6bb1aa3
--- /dev/null
+++ b/tests/codegen-llvm/string-push.rs
@@ -0,0 +1,11 @@
+//! Check that `String::push` is optimized enough not to call `memcpy`.
+
+//@ compile-flags: -O
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @string_push_does_not_call_memcpy
+#[no_mangle]
+pub fn string_push_does_not_call_memcpy(s: &mut String, ch: char) {
+    // CHECK-NOT: call void @llvm.memcpy
+    s.push(ch);
+}
diff --git a/tests/codegen-llvm/swap-large-types.rs b/tests/codegen-llvm/swap-large-types.rs
new file mode 100644
index 00000000000..08c486affd9
--- /dev/null
+++ b/tests/codegen-llvm/swap-large-types.rs
@@ -0,0 +1,116 @@
+//@ compile-flags: -Copt-level=3
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+use std::mem::swap;
+use std::ptr::{copy_nonoverlapping, read, write};
+
+type KeccakBuffer = [[u64; 5]; 5];
+
+// A basic read+copy+write swap implementation ends up copying one of the values
+// to stack for large types, which is completely unnecessary as the lack of
+// overlap means we can just do whatever fits in registers at a time.
+
+// The tests here (after the first one showing that the problem still exists)
+// are less about testing *exactly* what the codegen is, and more about testing
+// 1) That things are swapped directly from one argument to the other,
+//    never going through stack along the way, and
+// 2) That we're doing the swapping for big things using large vector types,
+//    rather then `i64` or `<8 x i8>` (or, even worse, `i8`) at a time.
+//
+// (There are separate tests for intrinsics::typed_swap_nonoverlapping that
+//  check that it, as an intrinsic, are emitting exactly what it should.)
+
+// CHECK-LABEL: @swap_basic
+#[no_mangle]
+pub fn swap_basic(x: &mut KeccakBuffer, y: &mut KeccakBuffer) {
+    // CHECK: alloca [200 x i8]
+
+    // SAFETY: exclusive references are always valid to read/write,
+    // are non-overlapping, and nothing here panics so it's drop-safe.
+    unsafe {
+        let z = read(x);
+        copy_nonoverlapping(y, x, 1);
+        write(y, z);
+    }
+}
+
+// CHECK-LABEL: @swap_std
+#[no_mangle]
+pub fn swap_std(x: &mut KeccakBuffer, y: &mut KeccakBuffer) {
+    // CHECK-NOT: alloca
+    // CHECK: load <{{2|4}} x i64>
+    // CHECK: store <{{2|4}} x i64>
+    swap(x, y)
+}
+
+// CHECK-LABEL: @swap_slice
+#[no_mangle]
+pub fn swap_slice(x: &mut [KeccakBuffer], y: &mut [KeccakBuffer]) {
+    // CHECK-NOT: alloca
+    // CHECK: load <{{2|4}} x i64>
+    // CHECK: store <{{2|4}} x i64>
+    if x.len() == y.len() {
+        x.swap_with_slice(y);
+    }
+}
+
+type OneKilobyteBuffer = [u8; 1024];
+
+// CHECK-LABEL: @swap_1kb_slices
+#[no_mangle]
+pub fn swap_1kb_slices(x: &mut [OneKilobyteBuffer], y: &mut [OneKilobyteBuffer]) {
+    // CHECK-NOT: alloca
+
+    // CHECK-NOT: load i32
+    // CHECK-NOT: store i32
+    // CHECK-NOT: load i16
+    // CHECK-NOT: store i16
+    // CHECK-NOT: load i8
+    // CHECK-NOT: store i8
+
+    // CHECK: load <{{2|4}} x i64>{{.+}}align 1,
+    // CHECK: store <{{2|4}} x i64>{{.+}}align 1,
+
+    // CHECK-NOT: load i32
+    // CHECK-NOT: store i32
+    // CHECK-NOT: load i16
+    // CHECK-NOT: store i16
+    // CHECK-NOT: load i8
+    // CHECK-NOT: store i8
+
+    if x.len() == y.len() {
+        x.swap_with_slice(y);
+    }
+}
+
+#[repr(align(64))]
+pub struct BigButHighlyAligned([u8; 64 * 3]);
+
+// CHECK-LABEL: @swap_big_aligned
+#[no_mangle]
+pub fn swap_big_aligned(x: &mut BigButHighlyAligned, y: &mut BigButHighlyAligned) {
+    // CHECK-NOT: call void @llvm.memcpy
+    // CHECK-NOT: load i32
+    // CHECK-NOT: store i32
+    // CHECK-NOT: load i16
+    // CHECK-NOT: store i16
+    // CHECK-NOT: load i8
+    // CHECK-NOT: store i8
+
+    // CHECK-COUNT-2: load <{{2|4}} x i64>{{.+}}align 64,
+    // CHECK-COUNT-2: store <{{2|4}} x i64>{{.+}}align 64,
+
+    // CHECK-COUNT-2: load <{{2|4}} x i64>{{.+}}align 32,
+    // CHECK-COUNT-2: store <{{2|4}} x i64>{{.+}}align 32,
+
+    // CHECK-NOT: load i32
+    // CHECK-NOT: store i32
+    // CHECK-NOT: load i16
+    // CHECK-NOT: store i16
+    // CHECK-NOT: load i8
+    // CHECK-NOT: store i8
+    // CHECK-NOT: call void @llvm.memcpy
+    swap(x, y)
+}
diff --git a/tests/codegen-llvm/swap-small-types.rs b/tests/codegen-llvm/swap-small-types.rs
new file mode 100644
index 00000000000..7aa613ae9c2
--- /dev/null
+++ b/tests/codegen-llvm/swap-small-types.rs
@@ -0,0 +1,182 @@
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+//@ only-x86_64
+//@ min-llvm-version: 20
+//@ ignore-std-debug-assertions (`ptr::swap_nonoverlapping` has one which blocks some optimizations)
+
+#![crate_type = "lib"]
+
+use std::mem::swap;
+
+type RGB48 = [u16; 3];
+
+// CHECK-LABEL: @swap_rgb48_manually(
+#[no_mangle]
+pub fn swap_rgb48_manually(x: &mut RGB48, y: &mut RGB48) {
+    // FIXME: See #115212 for why this has an alloca again
+
+    // CHECK: alloca [6 x i8], align 2
+    // CHECK: call void @llvm.memcpy.p0.p0.i64({{.+}}, i64 6, i1 false)
+    // CHECK: call void @llvm.memcpy.p0.p0.i64({{.+}}, i64 6, i1 false)
+    // CHECK: call void @llvm.memcpy.p0.p0.i64({{.+}}, i64 6, i1 false)
+
+    let temp = *x;
+    *x = *y;
+    *y = temp;
+}
+
+// CHECK-LABEL: @swap_rgb48
+#[no_mangle]
+pub fn swap_rgb48(x: &mut RGB48, y: &mut RGB48) {
+    // CHECK-NOT: alloca
+
+    // Swapping `i48` might be cleaner in LLVM-IR here, but `i32`+`i16` isn't bad,
+    // and is closer to the assembly it generates anyway.
+
+    // CHECK-NOT: load{{ }}
+    // CHECK: load i32{{.+}}align 2
+    // CHECK-NEXT: load i32{{.+}}align 2
+    // CHECK-NEXT: store i32{{.+}}align 2
+    // CHECK-NEXT: store i32{{.+}}align 2
+    // CHECK: load i16{{.+}}align 2
+    // CHECK-NEXT: load i16{{.+}}align 2
+    // CHECK-NEXT: store i16{{.+}}align 2
+    // CHECK-NEXT: store i16{{.+}}align 2
+    // CHECK-NOT: store{{ }}
+    swap(x, y)
+}
+
+type RGBA64 = [u16; 4];
+
+// CHECK-LABEL: @swap_rgba64
+#[no_mangle]
+pub fn swap_rgba64(x: &mut RGBA64, y: &mut RGBA64) {
+    // CHECK-NOT: alloca
+    // CHECK-DAG: %[[XVAL:.+]] = load i64, ptr %x, align 2
+    // CHECK-DAG: %[[YVAL:.+]] = load i64, ptr %y, align 2
+    // CHECK-DAG: store i64 %[[YVAL]], ptr %x, align 2
+    // CHECK-DAG: store i64 %[[XVAL]], ptr %y, align 2
+    swap(x, y)
+}
+
+// CHECK-LABEL: @swap_vecs
+#[no_mangle]
+pub fn swap_vecs(x: &mut Vec<u32>, y: &mut Vec<u32>) {
+    // CHECK-NOT: alloca
+    // There are plenty more loads and stores than just these,
+    // but at least one sure better be 64-bit (for size or capacity).
+    // CHECK: load i64
+    // CHECK: load i64
+    // CHECK: store i64
+    // CHECK: store i64
+    // CHECK: ret void
+    swap(x, y)
+}
+
+// CHECK-LABEL: @swap_slices
+#[no_mangle]
+pub fn swap_slices<'a>(x: &mut &'a [u32], y: &mut &'a [u32]) {
+    // CHECK-NOT: alloca
+    // CHECK: load ptr
+    // CHECK: load i64
+    // CHECK: call void @llvm.memcpy.p0.p0.i64({{.+}}, i64 16, i1 false)
+    // CHECK: store ptr
+    // CHECK: store i64
+    swap(x, y)
+}
+
+type RGB24 = [u8; 3];
+
+// CHECK-LABEL: @swap_rgb24_slices
+#[no_mangle]
+pub fn swap_rgb24_slices(x: &mut [RGB24], y: &mut [RGB24]) {
+    // CHECK-NOT: alloca
+
+    // CHECK: mul nuw nsw i64 %{{x|y}}.1, 3
+
+    // CHECK: load <{{[0-9]+}} x i64>
+    // CHECK: store <{{[0-9]+}} x i64>
+
+    // CHECK-COUNT-2: load i32
+    // CHECK-COUNT-2: store i32
+    // CHECK-COUNT-2: load i16
+    // CHECK-COUNT-2: store i16
+    // CHECK-COUNT-2: load i8
+    // CHECK-COUNT-2: store i8
+    if x.len() == y.len() {
+        x.swap_with_slice(y);
+    }
+}
+
+type RGBA32 = [u8; 4];
+
+// CHECK-LABEL: @swap_rgba32_slices
+#[no_mangle]
+pub fn swap_rgba32_slices(x: &mut [RGBA32], y: &mut [RGBA32]) {
+    // CHECK-NOT: alloca
+
+    // Because the size in bytes in a multiple of 4, we can skip the smallest sizes.
+
+    // CHECK: load <{{[0-9]+}} x i64>
+    // CHECK: store <{{[0-9]+}} x i64>
+
+    // CHECK-COUNT-2: load i32
+    // CHECK-COUNT-2: store i32
+
+    // CHECK-NOT: load i16
+    // CHECK-NOT: store i16
+    // CHECK-NOT: load i8
+    // CHECK-NOT: store i8
+
+    if x.len() == y.len() {
+        x.swap_with_slice(y);
+    }
+}
+
+// Strings have a non-power-of-two size, but have pointer alignment,
+// so we swap usizes instead of dropping all the way down to bytes.
+const _: () = assert!(!std::mem::size_of::<String>().is_power_of_two());
+
+// CHECK-LABEL: @swap_string_slices
+#[no_mangle]
+pub fn swap_string_slices(x: &mut [String], y: &mut [String]) {
+    // CHECK-NOT: alloca
+    // CHECK: load <{{[0-9]+}} x i64>{{.+}}, align 8,
+    // CHECK: store <{{[0-9]+}} x i64>{{.+}}, align 8,
+    if x.len() == y.len() {
+        x.swap_with_slice(y);
+    }
+}
+
+#[repr(C, packed)]
+pub struct Packed {
+    pub first: bool,
+    pub second: usize,
+}
+
+// CHECK-LABEL: @swap_packed_structs
+#[no_mangle]
+pub fn swap_packed_structs(x: &mut Packed, y: &mut Packed) {
+    // CHECK-NOT: alloca
+
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+
+    // CHECK: %[[A:.+]] = load i64, ptr %x, align 1,
+    // CHECK-NEXT: %[[B:.+]] = load i64, ptr %y, align 1,
+    // CHECK-NEXT: store i64 %[[B]], ptr %x, align 1,
+    // CHECK-NEXT: store i64 %[[A]], ptr %y, align 1,
+
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+
+    // CHECK: %[[C:.+]] = load i8, ptr %[[X8:.+]], align 1,
+    // CHECK-NEXT: %[[D:.+]] = load i8, ptr %[[Y8:.+]], align 1,
+    // CHECK-NEXT: store i8 %[[D]], ptr %[[X8]], align 1,
+    // CHECK-NEXT: store i8 %[[C]], ptr %[[Y8]], align 1,
+
+    // CHECK-NOT: load
+    // CHECK-NOT: store
+
+    // CHECK: ret void
+    swap(x, y)
+}
diff --git a/tests/codegen-llvm/target-cpu-on-functions.rs b/tests/codegen-llvm/target-cpu-on-functions.rs
new file mode 100644
index 00000000000..25c10e7ce44
--- /dev/null
+++ b/tests/codegen-llvm/target-cpu-on-functions.rs
@@ -0,0 +1,22 @@
+// This test makes sure that functions get annotated with the proper
+// "target-cpu" attribute in LLVM.
+
+//@ no-prefer-dynamic
+//
+//@ compile-flags: -C no-prepopulate-passes -C panic=abort -C linker-plugin-lto -Cpasses=name-anon-globals
+
+#![crate_type = "staticlib"]
+
+// CHECK-LABEL: define {{.*}} @exported() {{.*}} #0
+#[no_mangle]
+pub extern "C" fn exported() {
+    not_exported();
+}
+
+// CHECK-LABEL: ; target_cpu_on_functions::not_exported
+// CHECK-NEXT: ; Function Attrs:
+// CHECK-NEXT: define {{.*}}() {{.*}} #1
+#[inline(never)]
+fn not_exported() {}
+
+// CHECK: attributes #0 = {{.*}} "target-cpu"="{{.*}}"
diff --git a/tests/codegen-llvm/target-feature-inline-closure.rs b/tests/codegen-llvm/target-feature-inline-closure.rs
new file mode 100644
index 00000000000..5d54444f994
--- /dev/null
+++ b/tests/codegen-llvm/target-feature-inline-closure.rs
@@ -0,0 +1,33 @@
+//@ only-x86_64
+// Set the base cpu explicitly, in case the default has been changed.
+//@ compile-flags: -Copt-level=3 -Ctarget-cpu=x86-64
+
+#![crate_type = "lib"]
+
+#[cfg(target_arch = "x86_64")]
+use std::arch::x86_64::*;
+
+// CHECK-LABEL: @with_avx
+#[no_mangle]
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "avx")]
+fn with_avx(x: __m256) -> __m256 {
+    // CHECK: fadd <8 x float>
+    let add = {
+        #[inline(always)]
+        |x, y| unsafe { _mm256_add_ps(x, y) }
+    };
+    add(x, x)
+}
+
+// CHECK-LABEL: @without_avx
+#[no_mangle]
+#[cfg(target_arch = "x86_64")]
+unsafe fn without_avx(x: __m256) -> __m256 {
+    // CHECK-NOT: fadd <8 x float>
+    let add = {
+        #[inline(always)]
+        |x, y| unsafe { _mm256_add_ps(x, y) }
+    };
+    add(x, x)
+}
diff --git a/tests/codegen-llvm/target-feature-negative-implication.rs b/tests/codegen-llvm/target-feature-negative-implication.rs
new file mode 100644
index 00000000000..36cd82dd8cf
--- /dev/null
+++ b/tests/codegen-llvm/target-feature-negative-implication.rs
@@ -0,0 +1,20 @@
+//@ add-core-stubs
+//@ needs-llvm-components: x86
+//@ compile-flags: --target=x86_64-unknown-linux-gnu
+//@ compile-flags: -Ctarget-feature=-avx2
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+#[no_mangle]
+pub unsafe fn banana() {
+    // CHECK-LABEL: @banana()
+    // CHECK-SAME: [[BANANAATTRS:#[0-9]+]] {
+}
+
+// CHECK: attributes [[BANANAATTRS]]
+// CHECK-SAME: -avx512
diff --git a/tests/codegen-llvm/target-feature-overrides.rs b/tests/codegen-llvm/target-feature-overrides.rs
new file mode 100644
index 00000000000..63a586d388b
--- /dev/null
+++ b/tests/codegen-llvm/target-feature-overrides.rs
@@ -0,0 +1,46 @@
+// ignore-tidy-linelength
+//@ add-core-stubs
+//@ revisions: COMPAT INCOMPAT
+//@ needs-llvm-components: x86
+//@ compile-flags: --target=x86_64-unknown-linux-gnu -Copt-level=3
+//@ [COMPAT] compile-flags: -Ctarget-feature=+avx2
+//@ [INCOMPAT] compile-flags: -Ctarget-feature=-avx2,-avx
+
+// See also tests/assembly-llvm/target-feature-multiple.rs
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+extern "C" {
+    fn peach() -> u32;
+}
+
+#[inline]
+#[target_feature(enable = "avx")]
+#[no_mangle]
+pub unsafe fn apple() -> u32 {
+    // CHECK-LABEL: @apple()
+    // CHECK-SAME: [[APPLEATTRS:#[0-9]+]] {
+    // CHECK: {{.*}}call{{.*}}@peach
+    peach()
+}
+
+// target features same as global
+#[no_mangle]
+pub unsafe fn banana() -> u32 {
+    // CHECK-LABEL: @banana()
+    // CHECK-SAME: [[BANANAATTRS:#[0-9]+]] {
+    // COMPAT: {{.*}}call{{.*}}@peach
+    // INCOMPAT: {{.*}}call{{.*}}@apple
+    apple() // Compatible for inline in COMPAT revision and can't be inlined in INCOMPAT
+}
+
+// CHECK: attributes [[APPLEATTRS]]
+// COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
+// INCOMPAT-SAME: "target-features"="{{(-[^,]+,)*}}-avx2{{(,-[^,]+)*}},-avx{{(,-[^,]+)*}},+avx{{(,\+[^,]+)*}}"
+// CHECK: attributes [[BANANAATTRS]]
+// COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
+// INCOMPAT-SAME: "target-features"="{{(-[^,]+,)*}}-avx2{{(,-[^,]+)*}},-avx{{(,-[^,]+)*}}"
diff --git a/tests/codegen-llvm/terminating-catchpad.rs b/tests/codegen-llvm/terminating-catchpad.rs
new file mode 100644
index 00000000000..a2ec19871d1
--- /dev/null
+++ b/tests/codegen-llvm/terminating-catchpad.rs
@@ -0,0 +1,43 @@
+//@ revisions: emscripten wasi seh
+//@[emscripten] compile-flags: --target wasm32-unknown-emscripten -Z emscripten-wasm-eh
+//@[wasi] compile-flags: --target wasm32-wasip1 -C panic=unwind
+//@[seh] compile-flags: --target x86_64-pc-windows-msvc
+//@[emscripten] needs-llvm-components: webassembly
+//@[wasi] needs-llvm-components: webassembly
+//@[seh] needs-llvm-components: x86
+
+// Ensure a catch-all generates:
+// - `catchpad ... [ptr null]` on Wasm (otherwise LLVM gets confused)
+// - `catchpad ... [ptr null, i32 64, ptr null]` on Windows (otherwise we catch SEH exceptions)
+
+#![feature(no_core, lang_items, rustc_attrs)]
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+
+unsafe extern "C-unwind" {
+    safe fn unwinds();
+}
+
+#[lang = "panic_cannot_unwind"]
+fn panic_cannot_unwind() -> ! {
+    loop {}
+}
+
+#[no_mangle]
+#[rustc_nounwind]
+pub fn doesnt_unwind() {
+    // emscripten: %catchpad = catchpad within %catchswitch [ptr null]
+    // wasi: %catchpad = catchpad within %catchswitch [ptr null]
+    // seh: %catchpad = catchpad within %catchswitch [ptr null, i32 64, ptr null]
+    unwinds();
+}
diff --git a/tests/codegen-llvm/thread-local.rs b/tests/codegen-llvm/thread-local.rs
new file mode 100644
index 00000000000..41df8c9be1b
--- /dev/null
+++ b/tests/codegen-llvm/thread-local.rs
@@ -0,0 +1,54 @@
+//@ compile-flags: -Copt-level=3
+//@ aux-build:thread_local_aux.rs
+//@ ignore-windows FIXME(#134939)
+//@ ignore-wasm globals are used instead of thread locals
+//@ ignore-emscripten globals are used instead of thread locals
+//@ ignore-android does not use #[thread_local]
+//@ ignore-nto does not use #[thread_local]
+
+#![crate_type = "lib"]
+
+extern crate thread_local_aux as aux;
+
+use std::cell::Cell;
+
+thread_local!(static A: Cell<u32> = const { Cell::new(1) });
+
+// CHECK: [[TLS_AUX:@.+]] = external thread_local{{.*}} global i64
+// CHECK: [[TLS:@.+]] = internal thread_local{{.*}} global
+
+// CHECK-LABEL: @get
+#[no_mangle]
+fn get() -> u32 {
+    // CHECK: [[PTR:%.+]] = tail call {{.*}} ptr @llvm.threadlocal.address.p0(ptr [[TLS]])
+    // CHECK-NEXT: [[RET_0:%.+]] = load i32, ptr [[PTR]]
+    // CHECK-NEXT: ret i32 [[RET_0]]
+    A.with(|a| a.get())
+}
+
+// CHECK-LABEL: @set
+#[no_mangle]
+fn set(v: u32) {
+    // CHECK: [[PTR:%.+]] = tail call {{.*}} ptr @llvm.threadlocal.address.p0(ptr [[TLS]])
+    // CHECK-NEXT: store i32 %0, ptr [[PTR]]
+    // CHECK-NEXT: ret void
+    A.with(|a| a.set(v))
+}
+
+// CHECK-LABEL: @get_aux
+#[no_mangle]
+fn get_aux() -> u64 {
+    // CHECK: [[PTR:%.+]] = tail call {{.*}} ptr @llvm.threadlocal.address.p0(ptr [[TLS_AUX]])
+    // CHECK-NEXT: [[RET_1:%.+]] = load i64, ptr [[PTR]]
+    // CHECK-NEXT: ret i64 [[RET_1]]
+    aux::A.with(|a| a.get())
+}
+
+// CHECK-LABEL: @set_aux
+#[no_mangle]
+fn set_aux(v: u64) {
+    // CHECK: [[PTR:%.+]] = tail call {{.*}} ptr @llvm.threadlocal.address.p0(ptr [[TLS_AUX]])
+    // CHECK-NEXT: store i64 %0, ptr [[PTR]]
+    // CHECK-NEXT: ret void
+    aux::A.with(|a| a.set(v))
+}
diff --git a/tests/codegen-llvm/tied-features-strength.rs b/tests/codegen-llvm/tied-features-strength.rs
new file mode 100644
index 00000000000..81499c070d1
--- /dev/null
+++ b/tests/codegen-llvm/tied-features-strength.rs
@@ -0,0 +1,34 @@
+// ignore-tidy-linelength
+//@ add-core-stubs
+//@ revisions: ENABLE_SVE DISABLE_SVE DISABLE_NEON ENABLE_NEON
+//@ compile-flags: --crate-type=rlib --target=aarch64-unknown-linux-gnu
+//@ needs-llvm-components: aarch64
+
+// Rust made SVE require neon.
+//@ [ENABLE_SVE] compile-flags: -C target-feature=+sve -Copt-level=0
+// ENABLE_SVE: attributes #0
+// ENABLE_SVE-SAME: +neon
+// ENABLE_SVE-SAME: +sve
+
+// However, disabling SVE does not disable neon.
+//@ [DISABLE_SVE] compile-flags: -C target-feature=-sve -Copt-level=0
+// DISABLE_SVE: attributes #0
+// DISABLE_SVE-NOT: -neon
+// DISABLE_SVE-SAME: -sve
+
+// OTOH, neon fn `fp-armv8` are fully tied; toggling neon must toggle `fp-armv8` the same way.
+//@ [DISABLE_NEON] compile-flags: -C target-feature=-neon -Copt-level=0
+// DISABLE_NEON: attributes #0
+// DISABLE_NEON-SAME: -neon
+// DISABLE_NEON-SAME: -fp-armv8
+
+//@ [ENABLE_NEON] compile-flags: -C target-feature=+neon -Copt-level=0
+// ENABLE_NEON: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fp-armv8,?)|(\+neon,?))*}}" }
+
+#![feature(no_core, lang_items)]
+#![no_core]
+
+extern crate minicore;
+use minicore::*;
+
+pub fn test() {}
diff --git a/tests/codegen-llvm/to_vec.rs b/tests/codegen-llvm/to_vec.rs
new file mode 100644
index 00000000000..4f6e77188d8
--- /dev/null
+++ b/tests/codegen-llvm/to_vec.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @copy_to_vec
+#[no_mangle]
+fn copy_to_vec(s: &[u64]) -> Vec<u64> {
+    s.to_vec()
+    // CHECK: call void @llvm.memcpy
+}
diff --git a/tests/codegen-llvm/trailing_zeros.rs b/tests/codegen-llvm/trailing_zeros.rs
new file mode 100644
index 00000000000..0816a980992
--- /dev/null
+++ b/tests/codegen-llvm/trailing_zeros.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @trailing_zeros_ge
+#[no_mangle]
+pub fn trailing_zeros_ge(val: u32) -> bool {
+    // CHECK: %[[AND:.*]] = and i32 %val, 7
+    // CHECK: %[[ICMP:.*]] = icmp eq i32 %[[AND]], 0
+    // CHECK: ret i1 %[[ICMP]]
+    val.trailing_zeros() >= 3
+}
+
+// CHECK-LABEL: @trailing_zeros_gt
+#[no_mangle]
+pub fn trailing_zeros_gt(val: u64) -> bool {
+    // CHECK: %[[AND:.*]] = and i64 %val, 15
+    // CHECK: %[[ICMP:.*]] = icmp eq i64 %[[AND]], 0
+    // CHECK: ret i1 %[[ICMP]]
+    val.trailing_zeros() > 3
+}
diff --git a/tests/codegen-llvm/transmute-optimized.rs b/tests/codegen-llvm/transmute-optimized.rs
new file mode 100644
index 00000000000..477fdc6de90
--- /dev/null
+++ b/tests/codegen-llvm/transmute-optimized.rs
@@ -0,0 +1,120 @@
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+#![crate_type = "lib"]
+
+// This tests that LLVM can optimize based on the niches in the source or
+// destination types for transmutes.
+
+#[repr(u32)]
+pub enum AlwaysZero32 {
+    X = 0,
+}
+
+// CHECK-LABEL: i32 @issue_109958(i32
+#[no_mangle]
+pub fn issue_109958(x: AlwaysZero32) -> i32 {
+    // CHECK: ret i32 0
+    unsafe { std::mem::transmute(x) }
+}
+
+// CHECK-LABEL: i1 @reference_is_null(ptr
+#[no_mangle]
+pub fn reference_is_null(x: &i32) -> bool {
+    // CHECK: ret i1 false
+    let p: *const i32 = unsafe { std::mem::transmute(x) };
+    p.is_null()
+}
+
+// CHECK-LABEL: i1 @non_null_is_null(ptr
+#[no_mangle]
+pub fn non_null_is_null(x: std::ptr::NonNull<i32>) -> bool {
+    // CHECK: ret i1 false
+    let p: *const i32 = unsafe { std::mem::transmute(x) };
+    p.is_null()
+}
+
+// CHECK-LABEL: i1 @non_zero_is_null(
+#[no_mangle]
+pub fn non_zero_is_null(x: std::num::NonZero<usize>) -> bool {
+    // CHECK: ret i1 false
+    let p: *const i32 = unsafe { std::mem::transmute(x) };
+    p.is_null()
+}
+
+// CHECK-LABEL: i1 @non_null_is_zero(ptr
+#[no_mangle]
+pub fn non_null_is_zero(x: std::ptr::NonNull<i32>) -> bool {
+    // CHECK: ret i1 false
+    let a: isize = unsafe { std::mem::transmute(x) };
+    a == 0
+}
+
+// CHECK-LABEL: i1 @bool_ordering_is_ge(i1
+#[no_mangle]
+pub fn bool_ordering_is_ge(x: bool) -> bool {
+    // CHECK: ret i1 true
+    let y: std::cmp::Ordering = unsafe { std::mem::transmute(x) };
+    y.is_ge()
+}
+
+// CHECK-LABEL: i1 @ordering_is_ge_then_transmute_to_bool(i8
+#[no_mangle]
+pub fn ordering_is_ge_then_transmute_to_bool(x: std::cmp::Ordering) -> bool {
+    let r = x.is_ge();
+    let _: bool = unsafe { std::mem::transmute(x) };
+    r
+}
+
+// CHECK-LABEL: i32 @normal_div(i32
+#[no_mangle]
+pub fn normal_div(a: u32, b: u32) -> u32 {
+    // CHECK: call core::panicking::panic
+    a / b
+}
+
+// CHECK-LABEL: i32 @div_transmute_nonzero(i32
+#[no_mangle]
+pub fn div_transmute_nonzero(a: u32, b: std::num::NonZero<i32>) -> u32 {
+    // CHECK-NOT: call core::panicking::panic
+    // CHECK: %[[R:.+]] = udiv i32 %a, %b
+    // CHECK-NEXT: ret i32 %[[R]]
+    // CHECK-NOT: call core::panicking::panic
+    let d: u32 = unsafe { std::mem::transmute(b) };
+    a / d
+}
+
+#[repr(i8)]
+pub enum OneTwoThree {
+    One = 1,
+    Two = 2,
+    Three = 3,
+}
+
+// CHECK-LABEL: i8 @ordering_transmute_onetwothree(i8
+#[no_mangle]
+pub unsafe fn ordering_transmute_onetwothree(x: std::cmp::Ordering) -> OneTwoThree {
+    // CHECK: ret i8 1
+    std::mem::transmute(x)
+}
+
+// CHECK-LABEL: i8 @onetwothree_transmute_ordering(i8
+#[no_mangle]
+pub unsafe fn onetwothree_transmute_ordering(x: OneTwoThree) -> std::cmp::Ordering {
+    // CHECK: ret i8 1
+    std::mem::transmute(x)
+}
+
+// CHECK-LABEL: i1 @char_is_negative(i32
+#[no_mangle]
+pub fn char_is_negative(c: char) -> bool {
+    // CHECK: ret i1 false
+    let x: i32 = unsafe { std::mem::transmute(c) };
+    x < 0
+}
+
+// CHECK-LABEL: i1 @transmute_to_char_is_negative(i32
+#[no_mangle]
+pub fn transmute_to_char_is_negative(x: i32) -> bool {
+    // CHECK: ret i1 false
+    let _c: char = unsafe { std::mem::transmute(x) };
+    x < 0
+}
diff --git a/tests/codegen-llvm/transmute-scalar.rs b/tests/codegen-llvm/transmute-scalar.rs
new file mode 100644
index 00000000000..ce1b0558b2e
--- /dev/null
+++ b/tests/codegen-llvm/transmute-scalar.rs
@@ -0,0 +1,143 @@
+//@ add-core-stubs
+//@ compile-flags: -C opt-level=0 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(no_core, repr_simd, arm_target_feature, mips_target_feature, s390x_target_feature)]
+#![no_core]
+extern crate minicore;
+
+use minicore::*;
+
+// With opaque ptrs in LLVM, `transmute` can load/store any `alloca` as any type,
+// without needing to pointercast, and SRoA will turn that into a `bitcast`.
+// Thus memory-to-memory transmutes don't need to generate them ourselves.
+
+// However, `bitcast`s and `ptrtoint`s and `inttoptr`s are still worth doing when
+// that allows us to avoid the `alloca`s entirely; see `rvalue_creates_operand`.
+
+// CHECK-LABEL: define{{.*}}i32 @f32_to_bits(float %x)
+// CHECK: %_0 = bitcast float %x to i32
+// CHECK-NEXT: ret i32 %_0
+#[no_mangle]
+pub fn f32_to_bits(x: f32) -> u32 {
+    unsafe { mem::transmute(x) }
+}
+
+// CHECK-LABEL: define{{.*}}i8 @bool_to_byte(i1 zeroext %b)
+// CHECK: %_0 = zext i1 %b to i8
+// CHECK-NEXT: ret i8 %_0
+#[no_mangle]
+pub fn bool_to_byte(b: bool) -> u8 {
+    unsafe { mem::transmute(b) }
+}
+
+// CHECK-LABEL: define{{.*}}zeroext i1 @byte_to_bool(i8{{.*}} %byte)
+// CHECK: %_0 = trunc{{( nuw)?}} i8 %byte to i1
+// CHECK-NEXT: ret i1 %_0
+#[no_mangle]
+pub unsafe fn byte_to_bool(byte: u8) -> bool {
+    mem::transmute(byte)
+}
+
+// CHECK-LABEL: define{{.*}}ptr @ptr_to_ptr(ptr %p)
+// CHECK: ret ptr %p
+#[no_mangle]
+pub fn ptr_to_ptr(p: *mut u16) -> *mut u8 {
+    unsafe { mem::transmute(p) }
+}
+
+// CHECK: define{{.*}}[[USIZE:i[0-9]+]] @ptr_to_int(ptr %p)
+// CHECK: %_0 = ptrtoint ptr %p to [[USIZE]]
+// CHECK-NEXT: ret [[USIZE]] %_0
+#[no_mangle]
+pub fn ptr_to_int(p: *mut u16) -> usize {
+    unsafe { mem::transmute(p) }
+}
+
+// CHECK: define{{.*}}ptr @int_to_ptr([[USIZE]] %i)
+// CHECK: %_0 = getelementptr i8, ptr null, [[USIZE]] %i
+// CHECK-NEXT: ret ptr %_0
+#[no_mangle]
+pub fn int_to_ptr(i: usize) -> *mut u16 {
+    unsafe { mem::transmute(i) }
+}
+
+// This is the one case where signedness matters to transmuting:
+// the LLVM type is `i8` here because of `repr(i8)`,
+// whereas below with the `repr(u8)` it's `i1` in LLVM instead.
+#[repr(i8)]
+pub enum FakeBoolSigned {
+    False = 0,
+    True = 1,
+}
+
+// CHECK-LABEL: define{{.*}}i8 @bool_to_fake_bool_signed(i1 zeroext %b)
+// CHECK: %_0 = zext i1 %b to i8
+// CHECK-NEXT: ret i8 %_0
+#[no_mangle]
+pub fn bool_to_fake_bool_signed(b: bool) -> FakeBoolSigned {
+    unsafe { mem::transmute(b) }
+}
+
+// CHECK-LABEL: define{{.*}}i1 @fake_bool_signed_to_bool(i8 %b)
+// CHECK: %_0 = trunc nuw i8 %b to i1
+// CHECK-NEXT: ret i1 %_0
+#[no_mangle]
+pub fn fake_bool_signed_to_bool(b: FakeBoolSigned) -> bool {
+    unsafe { mem::transmute(b) }
+}
+
+#[repr(u8)]
+pub enum FakeBoolUnsigned {
+    False = 0,
+    True = 1,
+}
+
+// CHECK-LABEL: define{{.*}}i1 @bool_to_fake_bool_unsigned(i1 zeroext %b)
+// CHECK: ret i1 %b
+#[no_mangle]
+pub fn bool_to_fake_bool_unsigned(b: bool) -> FakeBoolUnsigned {
+    unsafe { mem::transmute(b) }
+}
+
+// CHECK-LABEL: define{{.*}}i1 @fake_bool_unsigned_to_bool(i1 zeroext %b)
+// CHECK: ret i1 %b
+#[no_mangle]
+pub fn fake_bool_unsigned_to_bool(b: FakeBoolUnsigned) -> bool {
+    unsafe { mem::transmute(b) }
+}
+
+#[repr(simd)]
+struct S([i64; 1]);
+
+// CHECK-LABEL: define{{.*}}i64 @single_element_simd_to_scalar(<1 x i64> %b)
+// CHECK-NEXT: start:
+// CHECK-NEXT: %[[RET:.+]] = alloca [8 x i8]
+// CHECK-NEXT: store <1 x i64> %b, ptr %[[RET]]
+// CHECK-NEXT: %[[TEMP:.+]] = load i64, ptr %[[RET]]
+// CHECK-NEXT: ret i64 %[[TEMP]]
+#[no_mangle]
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
+pub extern "C" fn single_element_simd_to_scalar(b: S) -> i64 {
+    unsafe { mem::transmute(b) }
+}
+
+// CHECK-LABEL: define{{.*}}<1 x i64> @scalar_to_single_element_simd(i64 %b)
+// CHECK-NEXT: start:
+// CHECK-NEXT: %[[RET:.+]] = alloca [8 x i8]
+// CHECK-NEXT: store i64 %b, ptr %[[RET]]
+// CHECK-NEXT: %[[TEMP:.+]] = load <1 x i64>, ptr %[[RET]]
+// CHECK-NEXT: ret <1 x i64> %[[TEMP]]
+#[no_mangle]
+#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
+#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
+#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
+#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
+#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
+pub extern "C" fn scalar_to_single_element_simd(b: i64) -> S {
+    unsafe { mem::transmute(b) }
+}
diff --git a/tests/codegen-llvm/try_question_mark_nop.rs b/tests/codegen-llvm/try_question_mark_nop.rs
new file mode 100644
index 00000000000..398c9a580bc
--- /dev/null
+++ b/tests/codegen-llvm/try_question_mark_nop.rs
@@ -0,0 +1,243 @@
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+//@ edition: 2021
+//@ only-x86_64
+//@ revisions: NINETEEN TWENTY
+//@[NINETEEN] exact-llvm-major-version: 19
+//@[TWENTY] min-llvm-version: 20
+
+#![crate_type = "lib"]
+#![feature(try_blocks)]
+
+use std::ops::ControlFlow::{self, Break, Continue};
+use std::ptr::NonNull;
+
+// CHECK-LABEL: @option_nop_match_32
+#[no_mangle]
+pub fn option_nop_match_32(x: Option<u32>) -> Option<u32> {
+    // CHECK: start:
+    // CHECK-NEXT: [[TRUNC:%.*]] = trunc nuw i32 %0 to i1
+
+    // NINETEEN-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i32 %0, i32 0
+    // NINETEEN-NEXT: [[REG2:%.*]] = insertvalue { i32, i32 } poison, i32 [[SELECT]], 0
+    // NINETEEN-NEXT: [[REG3:%.*]] = insertvalue { i32, i32 } [[REG2]], i32 %1, 1
+
+    // TWENTY-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i32 %1, i32 undef
+    // TWENTY-NEXT: [[REG2:%.*]] = insertvalue { i32, i32 } poison, i32 %0, 0
+    // TWENTY-NEXT: [[REG3:%.*]] = insertvalue { i32, i32 } [[REG2]], i32 [[SELECT]], 1
+
+    // CHECK-NEXT: ret { i32, i32 } [[REG3]]
+    match x {
+        Some(x) => Some(x),
+        None => None,
+    }
+}
+
+// CHECK-LABEL: @option_nop_traits_32
+#[no_mangle]
+pub fn option_nop_traits_32(x: Option<u32>) -> Option<u32> {
+    // CHECK: start:
+    // TWENTY-NEXT: %[[IS_SOME:.+]] = trunc nuw i32 %0 to i1
+    // TWENTY-NEXT: select i1 %[[IS_SOME]], i32 %1, i32 undef
+    // CHECK-NEXT: insertvalue { i32, i32 }
+    // CHECK-NEXT: insertvalue { i32, i32 }
+    // CHECK-NEXT: ret { i32, i32 }
+    try { x? }
+}
+
+// CHECK-LABEL: @result_nop_match_32
+#[no_mangle]
+pub fn result_nop_match_32(x: Result<i32, u32>) -> Result<i32, u32> {
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue { i32, i32 }
+    // CHECK-NEXT: insertvalue { i32, i32 }
+    // CHECK-NEXT: ret { i32, i32 }
+    match x {
+        Ok(x) => Ok(x),
+        Err(x) => Err(x),
+    }
+}
+
+// CHECK-LABEL: @result_nop_traits_32
+#[no_mangle]
+pub fn result_nop_traits_32(x: Result<i32, u32>) -> Result<i32, u32> {
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue { i32, i32 }
+    // CHECK-NEXT: insertvalue { i32, i32 }
+    // CHECK-NEXT: ret { i32, i32 }
+    try { x? }
+}
+
+// CHECK-LABEL: @control_flow_nop_match_32
+#[no_mangle]
+pub fn control_flow_nop_match_32(x: ControlFlow<i32, u32>) -> ControlFlow<i32, u32> {
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue { i32, i32 }
+    // CHECK-NEXT: insertvalue { i32, i32 }
+    // CHECK-NEXT: ret { i32, i32 }
+    match x {
+        Continue(x) => Continue(x),
+        Break(x) => Break(x),
+    }
+}
+
+// CHECK-LABEL: @control_flow_nop_traits_32
+#[no_mangle]
+pub fn control_flow_nop_traits_32(x: ControlFlow<i32, u32>) -> ControlFlow<i32, u32> {
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue { i32, i32 }
+    // CHECK-NEXT: insertvalue { i32, i32 }
+    // CHECK-NEXT: ret { i32, i32 }
+    try { x? }
+}
+
+// CHECK-LABEL: @option_nop_match_64
+#[no_mangle]
+pub fn option_nop_match_64(x: Option<u64>) -> Option<u64> {
+    // CHECK: start:
+    // CHECK-NEXT: [[TRUNC:%.*]] = trunc nuw i64 %0 to i1
+
+    // NINETEEN-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i64 %0, i64 0
+    // NINETEEN-NEXT: [[REG2:%.*]] = insertvalue { i64, i64 } poison, i64 [[SELECT]], 0
+    // NINETEEN-NEXT: [[REG3:%.*]] = insertvalue { i64, i64 } [[REG2]], i64 %1, 1
+
+    // TWENTY-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i64 %1, i64 undef
+    // TWENTY-NEXT: [[REG2:%.*]] = insertvalue { i64, i64 } poison, i64 %0, 0
+    // TWENTY-NEXT: [[REG3:%.*]] = insertvalue { i64, i64 } [[REG2]], i64 [[SELECT]], 1
+
+    // CHECK-NEXT: ret { i64, i64 } [[REG3]]
+    match x {
+        Some(x) => Some(x),
+        None => None,
+    }
+}
+
+// CHECK-LABEL: @option_nop_traits_64
+#[no_mangle]
+pub fn option_nop_traits_64(x: Option<u64>) -> Option<u64> {
+    // CHECK: start:
+    // TWENTY-NEXT: %[[TRUNC:[0-9]+]] = trunc nuw i64 %0 to i1
+    // TWENTY-NEXT: %[[SEL:\.[0-9]+]] = select i1 %[[TRUNC]], i64 %1, i64 undef
+    // CHECK-NEXT: insertvalue { i64, i64 }
+    // CHECK-NEXT: insertvalue { i64, i64 }
+    // CHECK-NEXT: ret { i64, i64 }
+    try { x? }
+}
+
+// CHECK-LABEL: @result_nop_match_64
+#[no_mangle]
+pub fn result_nop_match_64(x: Result<i64, u64>) -> Result<i64, u64> {
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue { i64, i64 }
+    // CHECK-NEXT: insertvalue { i64, i64 }
+    // CHECK-NEXT: ret { i64, i64 }
+    match x {
+        Ok(x) => Ok(x),
+        Err(x) => Err(x),
+    }
+}
+
+// CHECK-LABEL: @result_nop_traits_64
+#[no_mangle]
+pub fn result_nop_traits_64(x: Result<i64, u64>) -> Result<i64, u64> {
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue { i64, i64 }
+    // CHECK-NEXT: insertvalue { i64, i64 }
+    // CHECK-NEXT: ret { i64, i64 }
+    try { x? }
+}
+
+// CHECK-LABEL: @control_flow_nop_match_64
+#[no_mangle]
+pub fn control_flow_nop_match_64(x: ControlFlow<i64, u64>) -> ControlFlow<i64, u64> {
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue { i64, i64 }
+    // CHECK-NEXT: insertvalue { i64, i64 }
+    // CHECK-NEXT: ret { i64, i64 }
+    match x {
+        Continue(x) => Continue(x),
+        Break(x) => Break(x),
+    }
+}
+
+// CHECK-LABEL: @control_flow_nop_traits_64
+#[no_mangle]
+pub fn control_flow_nop_traits_64(x: ControlFlow<i64, u64>) -> ControlFlow<i64, u64> {
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue { i64, i64 }
+    // CHECK-NEXT: insertvalue { i64, i64 }
+    // CHECK-NEXT: ret { i64, i64 }
+    try { x? }
+}
+
+// CHECK-LABEL: @result_nop_match_128
+#[no_mangle]
+pub fn result_nop_match_128(x: Result<i128, u128>) -> Result<i128, u128> {
+    // CHECK: start:
+    // CHECK-NEXT: store i128
+    // CHECK-NEXT: getelementptr inbounds {{(nuw )?}}i8
+    // CHECK-NEXT: store i128
+    // CHECK-NEXT: ret void
+    match x {
+        Ok(x) => Ok(x),
+        Err(x) => Err(x),
+    }
+}
+
+// CHECK-LABEL: @result_nop_traits_128
+#[no_mangle]
+pub fn result_nop_traits_128(x: Result<i128, u128>) -> Result<i128, u128> {
+    // CHECK: start:
+    // CHECK-NEXT: getelementptr inbounds {{(nuw )?}}i8
+    // CHECK-NEXT: store i128
+    // CHECK-NEXT: store i128
+    // CHECK-NEXT: ret void
+    try { x? }
+}
+
+// CHECK-LABEL: @control_flow_nop_match_128
+#[no_mangle]
+pub fn control_flow_nop_match_128(x: ControlFlow<i128, u128>) -> ControlFlow<i128, u128> {
+    // CHECK: start:
+    // CHECK-NEXT: store i128
+    // CHECK-NEXT: getelementptr inbounds {{(nuw )?}}i8
+    // CHECK-NEXT: store i128
+    // CHECK-NEXT: ret void
+    match x {
+        Continue(x) => Continue(x),
+        Break(x) => Break(x),
+    }
+}
+
+// CHECK-LABEL: @control_flow_nop_traits_128
+#[no_mangle]
+pub fn control_flow_nop_traits_128(x: ControlFlow<i128, u128>) -> ControlFlow<i128, u128> {
+    // CHECK: start:
+    // CHECK-NEXT: getelementptr inbounds {{(nuw )?}}i8
+    // CHECK-NEXT: store i128
+    // CHECK-NEXT: store i128
+    // CHECK-NEXT: ret void
+    try { x? }
+}
+
+// CHECK-LABEL: @result_nop_match_ptr
+#[no_mangle]
+pub fn result_nop_match_ptr(x: Result<usize, Box<()>>) -> Result<usize, Box<()>> {
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue { i{{[0-9]+}}, ptr }
+    // CHECK-NEXT: insertvalue { i{{[0-9]+}}, ptr }
+    // CHECK-NEXT: ret
+    match x {
+        Ok(x) => Ok(x),
+        Err(x) => Err(x),
+    }
+}
+
+// CHECK-LABEL: @result_nop_traits_ptr
+#[no_mangle]
+pub fn result_nop_traits_ptr(x: Result<u64, NonNull<()>>) -> Result<u64, NonNull<()>> {
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue { i{{[0-9]+}}, ptr }
+    // CHECK-NEXT: insertvalue { i{{[0-9]+}}, ptr }
+    // CHECK-NEXT: ret
+    try { x? }
+}
diff --git a/tests/codegen-llvm/tune-cpu-on-functions.rs b/tests/codegen-llvm/tune-cpu-on-functions.rs
new file mode 100644
index 00000000000..f50245b797f
--- /dev/null
+++ b/tests/codegen-llvm/tune-cpu-on-functions.rs
@@ -0,0 +1,21 @@
+// This test makes sure that functions get annotated with the proper
+// "tune-cpu" attribute in LLVM.
+
+//@ no-prefer-dynamic
+//
+//@ compile-flags: -C no-prepopulate-passes -C panic=abort -C linker-plugin-lto -Cpasses=name-anon-globals -Z tune-cpu=generic -Copt-level=0
+
+#![crate_type = "staticlib"]
+
+// CHECK-LABEL: define {{.*}} @exported() {{.*}} #0
+#[no_mangle]
+pub extern "C" fn exported() {
+    not_exported();
+}
+
+// CHECK-LABEL: ; tune_cpu_on_functions::not_exported
+// CHECK-NEXT: ; Function Attrs:
+// CHECK-NEXT: define {{.*}}() {{.*}} #0
+fn not_exported() {}
+
+// CHECK: attributes #0 = {{.*}} "tune-cpu"="{{.*}}"
diff --git a/tests/codegen-llvm/tuple-layout-opt.rs b/tests/codegen-llvm/tuple-layout-opt.rs
new file mode 100644
index 00000000000..5b2f65e7aa7
--- /dev/null
+++ b/tests/codegen-llvm/tuple-layout-opt.rs
@@ -0,0 +1,57 @@
+// 32-bit systems will return 128bit values using a return area pointer.
+//@ revisions: bit32 bit64
+//@[bit32] only-32bit
+//@[bit64] only-64bit
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+
+// Test that tuples get optimized layout, in particular with a ZST in the last field (#63244)
+
+#![crate_type = "lib"]
+
+type ScalarZstLast = (u128, ());
+// bit32: define {{(dso_local )?}}void @test_ScalarZstLast({{.*}} sret([16 x i8]) {{.*}}, i128 %_1)
+// bit64: define {{(dso_local )?}}i128 @test_ScalarZstLast(i128 %_1)
+#[no_mangle]
+pub fn test_ScalarZstLast(_: ScalarZstLast) -> ScalarZstLast {
+    loop {}
+}
+
+type ScalarZstFirst = ((), u128);
+// bit32: define {{(dso_local )?}}void @test_ScalarZstFirst({{.*}} sret([16 x i8]) {{.*}}, i128 %_1)
+// bit64: define {{(dso_local )?}}i128 @test_ScalarZstFirst(i128 %_1)
+#[no_mangle]
+pub fn test_ScalarZstFirst(_: ScalarZstFirst) -> ScalarZstFirst {
+    loop {}
+}
+
+type ScalarPairZstLast = (u8, u128, ());
+// CHECK: define {{(dso_local )?}}void @test_ScalarPairZstLast(ptr sret({{[^,]*}})
+// CHECK-SAME: %_0, i128 %_1.0, i8 %_1.1)
+#[no_mangle]
+pub fn test_ScalarPairZstLast(_: ScalarPairZstLast) -> ScalarPairZstLast {
+    loop {}
+}
+
+type ScalarPairZstFirst = ((), u8, u128);
+// CHECK: define {{(dso_local )?}}void @test_ScalarPairZstFirst(ptr sret({{[^,]*}})
+// CHECK-SAME: %_0, i8 %_1.0, i128 %_1.1)
+#[no_mangle]
+pub fn test_ScalarPairZstFirst(_: ScalarPairZstFirst) -> ScalarPairZstFirst {
+    loop {}
+}
+
+type ScalarPairLotsOfZsts = ((), u8, (), u128, ());
+// CHECK: define {{(dso_local )?}}void @test_ScalarPairLotsOfZsts(ptr sret({{[^,]*}})
+// CHECK-SAME: %_0, i128 %_1.0, i8 %_1.1)
+#[no_mangle]
+pub fn test_ScalarPairLotsOfZsts(_: ScalarPairLotsOfZsts) -> ScalarPairLotsOfZsts {
+    loop {}
+}
+
+type ScalarPairLottaNesting = (((), ((), u8, (), u128, ())), ());
+// CHECK: define {{(dso_local )?}}void @test_ScalarPairLottaNesting(ptr sret({{[^,]*}})
+// CHECK-SAME: %_0, i128 %_1.0, i8 %_1.1)
+#[no_mangle]
+pub fn test_ScalarPairLottaNesting(_: ScalarPairLottaNesting) -> ScalarPairLottaNesting {
+    loop {}
+}
diff --git a/tests/codegen-llvm/ub-checks.rs b/tests/codegen-llvm/ub-checks.rs
new file mode 100644
index 00000000000..67f5bff08d5
--- /dev/null
+++ b/tests/codegen-llvm/ub-checks.rs
@@ -0,0 +1,28 @@
+// With -Zub-checks=yes (enabled by default by -Cdebug-assertions=yes) we will produce a runtime
+// check that the index to slice::get_unchecked is in-bounds of the slice. That is tested for by
+// tests/ui/precondition-checks/out-of-bounds-get-unchecked.rs
+//
+// This test ensures that such a runtime check is *not* emitted when debug-assertions are enabled,
+// but ub-checks are explicitly disabled.
+
+//@ revisions: DEBUG NOCHECKS
+//@ [DEBUG] compile-flags:
+//@ [NOCHECKS] compile-flags: -Zub-checks=no
+//@ compile-flags: -Copt-level=3 -Cdebug-assertions=yes
+
+#![crate_type = "lib"]
+
+use std::ops::Range;
+
+// CHECK-LABEL: @slice_get_unchecked(
+#[no_mangle]
+pub unsafe fn slice_get_unchecked(x: &[i32], i: usize) -> &i32 {
+    //    CHECK: icmp ult
+    // NOCHECKS: tail call void @llvm.assume
+    //    DEBUG: br i1
+    //    DEBUG: call core::panicking::panic_nounwind
+    //    DEBUG: unreachable
+    //    CHECK: getelementptr inbounds
+    //    CHECK: ret ptr
+    x.get_unchecked(i)
+}
diff --git a/tests/codegen-llvm/unchecked-float-casts.rs b/tests/codegen-llvm/unchecked-float-casts.rs
new file mode 100644
index 00000000000..d1869abc87b
--- /dev/null
+++ b/tests/codegen-llvm/unchecked-float-casts.rs
@@ -0,0 +1,36 @@
+// This file tests that we don't generate any code for saturation when using the
+// unchecked intrinsics.
+
+//@ compile-flags: -C opt-level=3
+//@ ignore-wasm32 the wasm target is tested in `wasm_casts_*`
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @f32_to_u32
+#[no_mangle]
+pub fn f32_to_u32(x: f32) -> u32 {
+    // CHECK: fptoui
+    // CHECK-NOT: fcmp
+    // CHECK-NOT: icmp
+    // CHECK-NOT: select
+    unsafe { x.to_int_unchecked() }
+}
+
+// CHECK-LABEL: @f32_to_i32
+#[no_mangle]
+pub fn f32_to_i32(x: f32) -> i32 {
+    // CHECK: fptosi
+    // CHECK-NOT: fcmp
+    // CHECK-NOT: icmp
+    // CHECK-NOT: select
+    unsafe { x.to_int_unchecked() }
+}
+
+#[no_mangle]
+pub fn f64_to_u16(x: f64) -> u16 {
+    // CHECK: fptoui
+    // CHECK-NOT: fcmp
+    // CHECK-NOT: icmp
+    // CHECK-NOT: select
+    unsafe { x.to_int_unchecked() }
+}
diff --git a/tests/codegen-llvm/unchecked_shifts.rs b/tests/codegen-llvm/unchecked_shifts.rs
new file mode 100644
index 00000000000..3f533718a2d
--- /dev/null
+++ b/tests/codegen-llvm/unchecked_shifts.rs
@@ -0,0 +1,100 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+// This runs mir-opts to inline the standard library call, but doesn't run LLVM
+// optimizations so it doesn't need to worry about them adding more flags.
+
+#![crate_type = "lib"]
+#![feature(unchecked_shifts)]
+#![feature(core_intrinsics)]
+
+// CHECK-LABEL: @unchecked_shl_unsigned_same
+#[no_mangle]
+pub unsafe fn unchecked_shl_unsigned_same(a: u32, b: u32) -> u32 {
+    // CHECK-NOT: assume
+    // CHECK-NOT: and i32
+    // CHECK: shl i32 %a, %b
+    // CHECK-NOT: and i32
+    a.unchecked_shl(b)
+}
+
+// CHECK-LABEL: @unchecked_shl_unsigned_smaller
+#[no_mangle]
+pub unsafe fn unchecked_shl_unsigned_smaller(a: u16, b: u32) -> u16 {
+    // CHECK-NOT: assume
+    // CHECK: %[[TRUNC:.+]] = trunc nuw i32 %b to i16
+    // CHECK: shl i16 %a, %[[TRUNC]]
+    a.unchecked_shl(b)
+}
+
+// CHECK-LABEL: @unchecked_shl_unsigned_bigger
+#[no_mangle]
+pub unsafe fn unchecked_shl_unsigned_bigger(a: u64, b: u32) -> u64 {
+    // CHECK-NOT: assume
+    // CHECK: %[[EXT:.+]] = zext i32 %b to i64
+    // CHECK: shl i64 %a, %[[EXT]]
+    a.unchecked_shl(b)
+}
+
+// CHECK-LABEL: @unchecked_shr_signed_same
+#[no_mangle]
+pub unsafe fn unchecked_shr_signed_same(a: i32, b: u32) -> i32 {
+    // CHECK-NOT: assume
+    // CHECK-NOT: and i32
+    // CHECK: ashr i32 %a, %b
+    // CHECK-NOT: and i32
+    a.unchecked_shr(b)
+}
+
+// CHECK-LABEL: @unchecked_shr_signed_smaller
+#[no_mangle]
+pub unsafe fn unchecked_shr_signed_smaller(a: i16, b: u32) -> i16 {
+    // CHECK-NOT: assume
+    // CHECK: %[[TRUNC:.+]] = trunc nuw i32 %b to i16
+    // CHECK: ashr i16 %a, %[[TRUNC]]
+    a.unchecked_shr(b)
+}
+
+// CHECK-LABEL: @unchecked_shr_signed_bigger
+#[no_mangle]
+pub unsafe fn unchecked_shr_signed_bigger(a: i64, b: u32) -> i64 {
+    // CHECK-NOT: assume
+    // CHECK: %[[EXT:.+]] = zext i32 %b to i64
+    // CHECK: ashr i64 %a, %[[EXT]]
+    a.unchecked_shr(b)
+}
+
+// CHECK-LABEL: @unchecked_shr_u128_i8
+#[no_mangle]
+pub unsafe fn unchecked_shr_u128_i8(a: u128, b: i8) -> u128 {
+    // CHECK-NOT: assume
+    // CHECK: %[[EXT:.+]] = zext i8 %b to i128
+    // CHECK: lshr i128 %a, %[[EXT]]
+    std::intrinsics::unchecked_shr(a, b)
+}
+
+// CHECK-LABEL: @unchecked_shl_i128_u8
+#[no_mangle]
+pub unsafe fn unchecked_shl_i128_u8(a: i128, b: u8) -> i128 {
+    // CHECK-NOT: assume
+    // CHECK: %[[EXT:.+]] = zext i8 %b to i128
+    // CHECK: shl i128 %a, %[[EXT]]
+    std::intrinsics::unchecked_shl(a, b)
+}
+
+// CHECK-LABEL: @unchecked_shl_u8_i128
+#[no_mangle]
+pub unsafe fn unchecked_shl_u8_i128(a: u8, b: i128) -> u8 {
+    // CHECK-NOT: assume
+    // CHECK: %[[TRUNC:.+]] = trunc nuw i128 %b to i8
+    // CHECK: shl i8 %a, %[[TRUNC]]
+    std::intrinsics::unchecked_shl(a, b)
+}
+
+// CHECK-LABEL: @unchecked_shr_i8_u128
+#[no_mangle]
+pub unsafe fn unchecked_shr_i8_u128(a: i8, b: u128) -> i8 {
+    // CHECK-NOT: assume
+    // CHECK: %[[TRUNC:.+]] = trunc nuw i128 %b to i8
+    // CHECK: ashr i8 %a, %[[TRUNC]]
+    std::intrinsics::unchecked_shr(a, b)
+}
diff --git a/tests/codegen-llvm/uninhabited-transparent-return-abi.rs b/tests/codegen-llvm/uninhabited-transparent-return-abi.rs
new file mode 100644
index 00000000000..face1577c3f
--- /dev/null
+++ b/tests/codegen-llvm/uninhabited-transparent-return-abi.rs
@@ -0,0 +1,44 @@
+//@ compile-flags: -Copt-level=3
+
+// See https://github.com/rust-lang/rust/issues/135802
+
+#![crate_type = "lib"]
+
+enum Void {}
+
+// Should be ABI-compatible with T, but wasn't prior to the PR adding this test.
+#[repr(transparent)]
+struct NoReturn<T>(T, Void);
+
+// Returned by invisible reference (in most ABIs)
+#[allow(dead_code)]
+struct Large(u64, u64, u64);
+
+extern "Rust" {
+    fn opaque() -> NoReturn<Large>;
+    fn opaque_with_arg(rsi: u32) -> NoReturn<Large>;
+}
+
+// CHECK-LABEL: @test_uninhabited_ret_by_ref
+#[no_mangle]
+pub fn test_uninhabited_ret_by_ref() {
+    // CHECK: %_1 = alloca [24 x i8], align {{8|4}}
+    // CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %_1)
+    // CHECK-NEXT: call void @opaque({{.*}} sret([24 x i8]) {{.*}} %_1) #2
+    // CHECK-NEXT: unreachable
+    unsafe {
+        opaque();
+    }
+}
+
+// CHECK-LABEL: @test_uninhabited_ret_by_ref_with_arg
+#[no_mangle]
+pub fn test_uninhabited_ret_by_ref_with_arg(rsi: u32) {
+    // CHECK: %_2 = alloca [24 x i8], align {{8|4}}
+    // CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %_2)
+    // CHECK-NEXT: call void @opaque_with_arg({{.*}} sret([24 x i8]) {{.*}} %_2, i32 noundef %rsi) #2
+    // CHECK-NEXT: unreachable
+    unsafe {
+        opaque_with_arg(rsi);
+    }
+}
diff --git a/tests/codegen-llvm/uninit-consts.rs b/tests/codegen-llvm/uninit-consts.rs
new file mode 100644
index 00000000000..bde71a35c47
--- /dev/null
+++ b/tests/codegen-llvm/uninit-consts.rs
@@ -0,0 +1,54 @@
+//@ compile-flags: -C no-prepopulate-passes
+
+// Check that we use undef (and not zero) for uninitialized bytes in constants.
+
+#![crate_type = "lib"]
+
+use std::mem::MaybeUninit;
+
+pub struct PartiallyUninit {
+    x: u32,
+    y: MaybeUninit<[u8; 10]>,
+}
+
+// CHECK: [[FULLY_UNINIT:@.*]] = private unnamed_addr constant [10 x i8] undef
+
+// CHECK: [[PARTIALLY_UNINIT:@.*]] = private unnamed_addr constant <{ [4 x i8], [12 x i8] }> <{ [4 x i8] c"{{\\EF\\BE\\AD\\DE|\\DE\\AD\\BE\\EF}}", [12 x i8] undef }>, align 4
+
+// This shouldn't contain undef, since it contains more chunks
+// than the default value of uninit_const_chunk_threshold.
+// CHECK: [[UNINIT_PADDING_HUGE:@.*]] = private unnamed_addr constant [32768 x i8] c"{{.+}}", align 4
+
+// CHECK: [[FULLY_UNINIT_HUGE:@.*]] = private unnamed_addr constant [16384 x i8] undef
+
+// CHECK-LABEL: @fully_uninit
+#[no_mangle]
+pub const fn fully_uninit() -> MaybeUninit<[u8; 10]> {
+    const M: MaybeUninit<[u8; 10]> = MaybeUninit::uninit();
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %_0, ptr align 1 {{.*}}[[FULLY_UNINIT]]{{.*}}, i{{(32|64)}} 10, i1 false)
+    M
+}
+
+// CHECK-LABEL: @partially_uninit
+#[no_mangle]
+pub const fn partially_uninit() -> PartiallyUninit {
+    const X: PartiallyUninit = PartiallyUninit { x: 0xdeadbeef, y: MaybeUninit::uninit() };
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 4 %_0, ptr align 4 {{.*}}[[PARTIALLY_UNINIT]]{{.*}}, i{{(32|64)}} 16, i1 false)
+    X
+}
+
+// CHECK-LABEL: @uninit_padding_huge
+#[no_mangle]
+pub const fn uninit_padding_huge() -> [(u32, u8); 4096] {
+    const X: [(u32, u8); 4096] = [(123, 45); 4096];
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 4 %_0, ptr align 4 {{.*}}[[UNINIT_PADDING_HUGE]]{{.*}}, i{{(32|64)}} 32768, i1 false)
+    X
+}
+
+// CHECK-LABEL: @fully_uninit_huge
+#[no_mangle]
+pub const fn fully_uninit_huge() -> MaybeUninit<[u32; 4096]> {
+    const F: MaybeUninit<[u32; 4096]> = MaybeUninit::uninit();
+    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 4 %_0, ptr align 4 {{.*}}[[FULLY_UNINIT_HUGE]]{{.*}}, i{{(32|64)}} 16384, i1 false)
+    F
+}
diff --git a/tests/codegen-llvm/uninit-repeat-in-aggregate.rs b/tests/codegen-llvm/uninit-repeat-in-aggregate.rs
new file mode 100644
index 00000000000..0fa2eb7d56c
--- /dev/null
+++ b/tests/codegen-llvm/uninit-repeat-in-aggregate.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+use std::mem::MaybeUninit;
+
+// We need to make sure len is at offset 0, otherwise codegen needs an extra instruction
+#[repr(C)]
+pub struct SmallVec<T> {
+    pub len: u64,
+    pub arr: [MaybeUninit<T>; 24],
+}
+
+// CHECK-LABEL: @uninit_arr_via_const
+#[no_mangle]
+pub fn uninit_arr_via_const() -> SmallVec<String> {
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: store i64 0,
+    // CHECK-NEXT: ret
+    SmallVec { len: 0, arr: [const { MaybeUninit::uninit() }; 24] }
+}
diff --git a/tests/codegen-llvm/union-abi.rs b/tests/codegen-llvm/union-abi.rs
new file mode 100644
index 00000000000..28acc4de2f3
--- /dev/null
+++ b/tests/codegen-llvm/union-abi.rs
@@ -0,0 +1,145 @@
+//@ ignore-emscripten vectors passed directly
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+// 32-bit x86 returns `f32` differently to avoid the x87 stack.
+// 32-bit systems will return 128bit values using a return area pointer.
+//@ revisions: x86-sse x86-nosse bit32 bit64
+//@[x86-sse] only-x86
+//@[x86-sse] only-rustc_abi-x86-sse2
+//@[x86-nosse] only-x86
+//@[x86-nosse] ignore-rustc_abi-x86-sse2
+//@[bit32] ignore-x86
+//@[bit32] only-32bit
+//@[bit64] ignore-x86
+//@[bit64] only-64bit
+
+// This test that using union forward the abi of the inner type, as
+// discussed in #54668
+
+#![crate_type = "lib"]
+#![feature(repr_simd)]
+
+#[derive(Copy, Clone)]
+pub enum Unhab {}
+
+#[repr(simd)]
+#[derive(Copy, Clone)]
+pub struct i64x4([i64; 4]);
+
+#[derive(Copy, Clone)]
+pub union UnionI64x4 {
+    a: (),
+    b: i64x4,
+}
+
+// CHECK: define {{(dso_local )?}}void @test_UnionI64x4(ptr {{.*}} %_1)
+#[no_mangle]
+pub fn test_UnionI64x4(_: UnionI64x4) {
+    loop {}
+}
+
+pub union UnionI64x4_ {
+    a: i64x4,
+    b: (),
+    c: i64x4,
+    d: Unhab,
+    e: ((), ()),
+    f: UnionI64x4,
+}
+
+// CHECK: define {{(dso_local )?}}void @test_UnionI64x4_(ptr {{.*}} %_1)
+#[no_mangle]
+pub fn test_UnionI64x4_(_: UnionI64x4_) {
+    loop {}
+}
+
+pub union UnionI64x4I64 {
+    a: i64x4,
+    b: i64,
+}
+
+// CHECK: define {{(dso_local )?}}void @test_UnionI64x4I64(ptr {{.*}} %_1)
+#[no_mangle]
+pub fn test_UnionI64x4I64(_: UnionI64x4I64) {
+    loop {}
+}
+
+pub union UnionI64x4Tuple {
+    a: i64x4,
+    b: (i64, i64, i64, i64),
+}
+
+// CHECK: define {{(dso_local )?}}void @test_UnionI64x4Tuple(ptr {{.*}} %_1)
+#[no_mangle]
+pub fn test_UnionI64x4Tuple(_: UnionI64x4Tuple) {
+    loop {}
+}
+
+pub union UnionF32 {
+    a: f32,
+}
+
+// x86-sse: define {{(dso_local )?}}<4 x i8> @test_UnionF32(float %_1)
+// x86-nosse: define {{(dso_local )?}}i32 @test_UnionF32(float %_1)
+// bit32: define {{(dso_local )?}}float @test_UnionF32(float %_1)
+// bit64: define {{(dso_local )?}}float @test_UnionF32(float %_1)
+#[no_mangle]
+pub fn test_UnionF32(_: UnionF32) -> UnionF32 {
+    loop {}
+}
+
+pub union UnionF32F32 {
+    a: f32,
+    b: f32,
+}
+
+// x86-sse: define {{(dso_local )?}}<4 x i8> @test_UnionF32F32(float %_1)
+// x86-nosse: define {{(dso_local )?}}i32 @test_UnionF32F32(float %_1)
+// bit32: define {{(dso_local )?}}float @test_UnionF32F32(float %_1)
+// bit64: define {{(dso_local )?}}float @test_UnionF32F32(float %_1)
+#[no_mangle]
+pub fn test_UnionF32F32(_: UnionF32F32) -> UnionF32F32 {
+    loop {}
+}
+
+pub union UnionF32U32 {
+    a: f32,
+    b: u32,
+}
+
+// CHECK: define {{(dso_local )?}}i32 @test_UnionF32U32(i32{{( %0)?}})
+#[no_mangle]
+pub fn test_UnionF32U32(_: UnionF32U32) -> UnionF32U32 {
+    loop {}
+}
+
+pub union UnionU128 {
+    a: u128,
+}
+// x86-sse: define {{(dso_local )?}}void @test_UnionU128({{.*}}sret([16 x i8]){{.*}}, i128 %_1)
+// x86-nosse: define {{(dso_local )?}}void @test_UnionU128({{.*}}sret([16 x i8]){{.*}}, i128 %_1)
+// bit32: define {{(dso_local )?}}void @test_UnionU128({{.*}}sret([16 x i8]){{.*}}, i128 %_1)
+// bit64: define {{(dso_local )?}}i128 @test_UnionU128(i128 %_1)
+#[no_mangle]
+pub fn test_UnionU128(_: UnionU128) -> UnionU128 {
+    loop {}
+}
+
+#[repr(C)]
+pub union CUnionU128 {
+    a: u128,
+}
+// CHECK: define {{(dso_local )?}}void @test_CUnionU128(ptr {{.*}} %_1)
+#[no_mangle]
+pub fn test_CUnionU128(_: CUnionU128) {
+    loop {}
+}
+
+pub union UnionBool {
+    b: bool,
+}
+// CHECK: define {{(dso_local )?}}noundef zeroext i1 @test_UnionBool(i8{{.*}} %b)
+#[no_mangle]
+pub fn test_UnionBool(b: UnionBool) -> bool {
+    unsafe { b.b }
+}
+// CHECK: %_0 = trunc{{( nuw)?}} i8 %b to i1
diff --git a/tests/codegen-llvm/union-aggregate.rs b/tests/codegen-llvm/union-aggregate.rs
new file mode 100644
index 00000000000..aac66c5dcdd
--- /dev/null
+++ b/tests/codegen-llvm/union-aggregate.rs
@@ -0,0 +1,108 @@
+//@ compile-flags: -Copt-level=0 -Cno-prepopulate-passes
+//@ min-llvm-version: 19
+//@ only-64bit
+
+#![crate_type = "lib"]
+#![feature(transparent_unions)]
+#![feature(repr_simd)]
+
+#[repr(transparent)]
+union MU<T: Copy> {
+    uninit: (),
+    value: T,
+}
+
+use std::cmp::Ordering;
+use std::num::NonZero;
+use std::ptr::NonNull;
+
+#[no_mangle]
+fn make_mu_bool(x: bool) -> MU<bool> {
+    // CHECK-LABEL: i8 @make_mu_bool(i1 zeroext %x)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %[[WIDER:.+]] = zext i1 %x to i8
+    // CHECK-NEXT: ret i8 %[[WIDER]]
+    MU { value: x }
+}
+
+#[no_mangle]
+fn make_mu_bool_uninit() -> MU<bool> {
+    // CHECK-LABEL: i8 @make_mu_bool_uninit()
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret i8 undef
+    MU { uninit: () }
+}
+
+#[no_mangle]
+fn make_mu_ref(x: &u16) -> MU<&u16> {
+    // CHECK-LABEL: ptr @make_mu_ref(ptr align 2 %x)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret ptr %x
+    MU { value: x }
+}
+
+#[no_mangle]
+fn make_mu_ref_uninit<'a>() -> MU<&'a u16> {
+    // CHECK-LABEL: ptr @make_mu_ref_uninit()
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret ptr undef
+    MU { uninit: () }
+}
+
+#[no_mangle]
+fn make_mu_str(x: &str) -> MU<&str> {
+    // CHECK-LABEL: { ptr, i64 } @make_mu_str(ptr align 1 %x.0, i64 %x.1)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %0 = insertvalue { ptr, i64 } poison, ptr %x.0, 0
+    // CHECK-NEXT: %1 = insertvalue { ptr, i64 } %0, i64 %x.1, 1
+    // CHECK-NEXT: ret { ptr, i64 } %1
+    MU { value: x }
+}
+
+#[no_mangle]
+fn make_mu_str_uninit<'a>() -> MU<&'a str> {
+    // CHECK-LABEL: { ptr, i64 } @make_mu_str_uninit()
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret { ptr, i64 } undef
+    MU { uninit: () }
+}
+
+#[no_mangle]
+fn make_mu_pair(x: (u8, u32)) -> MU<(u8, u32)> {
+    // CHECK-LABEL: { i8, i32 } @make_mu_pair(i8 %x.0, i32 %x.1)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %0 = insertvalue { i8, i32 } poison, i8 %x.0, 0
+    // CHECK-NEXT: %1 = insertvalue { i8, i32 } %0, i32 %x.1, 1
+    // CHECK-NEXT: ret { i8, i32 } %1
+    MU { value: x }
+}
+
+#[no_mangle]
+fn make_mu_pair_uninit() -> MU<(u8, u32)> {
+    // CHECK-LABEL: { i8, i32 } @make_mu_pair_uninit()
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret { i8, i32 } undef
+    MU { uninit: () }
+}
+
+#[repr(simd)]
+#[derive(Copy, Clone)]
+struct I32X32([i32; 32]);
+
+#[no_mangle]
+fn make_mu_simd(x: I32X32) -> MU<I32X32> {
+    // CHECK-LABEL: void @make_mu_simd(ptr{{.+}}%_0, ptr{{.+}}%x)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: %[[TEMP:.+]] = load <32 x i32>, ptr %x,
+    // CHECK-NEXT: store <32 x i32> %[[TEMP]], ptr %_0,
+    // CHECK-NEXT: ret void
+    MU { value: x }
+}
+
+#[no_mangle]
+fn make_mu_simd_uninit() -> MU<I32X32> {
+    // CHECK-LABEL: void @make_mu_simd_uninit(ptr{{.+}}%_0)
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ret void
+    MU { uninit: () }
+}
diff --git a/tests/codegen-llvm/unwind-abis/aapcs-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/aapcs-unwind-abi.rs
new file mode 100644
index 00000000000..ecace722e0d
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/aapcs-unwind-abi.rs
@@ -0,0 +1,36 @@
+//@ needs-llvm-components: arm
+//@ compile-flags: --target=armv7-unknown-linux-gnueabihf --crate-type=rlib -Cno-prepopulate-passes
+#![no_core]
+#![feature(no_core, lang_items)]
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+
+// Test that `nounwind` attributes are correctly applied to exported `aapcs` and
+// `aapcs-unwind` extern functions. `aapcs-unwind` functions MUST NOT have this attribute. We
+// disable optimizations above to prevent LLVM from inferring the attribute.
+
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+#[no_mangle]
+pub extern "aapcs" fn rust_item_that_cannot_unwind() {}
+
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+#[no_mangle]
+pub extern "aapcs-unwind" fn rust_item_that_can_unwind() {}
+
+// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
+// sure that the first item is correctly marked with the `nounwind` attribute:
+//
+// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
+//
+// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
+//
+// CHECK: attributes #1 = {
+// CHECK-NOT: nounwind
+// CHECK: }
diff --git a/tests/codegen-llvm/unwind-abis/c-unwind-abi-panic-abort.rs b/tests/codegen-llvm/unwind-abis/c-unwind-abi-panic-abort.rs
new file mode 100644
index 00000000000..8d2745ba2f7
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/c-unwind-abi-panic-abort.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -C panic=abort
+
+// Test that `nounwind` attributes are also applied to extern `C-unwind` Rust functions
+// when the code is compiled with `panic=abort`.
+
+#![crate_type = "lib"]
+
+// CHECK: @rust_item_that_can_unwind() unnamed_addr [[ATTR0:#[0-9]+]]
+#[no_mangle]
+pub unsafe extern "C-unwind" fn rust_item_that_can_unwind() {
+    // Handle both legacy and v0 symbol mangling.
+    // CHECK: call void @{{.*core9panicking19panic_cannot_unwind}}
+    may_unwind();
+}
+
+extern "C-unwind" {
+    // CHECK: @may_unwind() unnamed_addr [[ATTR1:#[0-9]+]]
+    fn may_unwind();
+}
+
+// Now, make sure that the LLVM attributes for this functions are correct.  First, make
+// sure that the first item is correctly marked with the `nounwind` attribute:
+//
+// CHECK: attributes [[ATTR0]] = { {{.*}}nounwind{{.*}} }
+//
+// Now, check that foreign item is correctly marked without the `nounwind` attribute.
+// CHECK-NOT: attributes [[ATTR1]] = { {{.*}}nounwind{{.*}} }
diff --git a/tests/codegen-llvm/unwind-abis/c-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/c-unwind-abi.rs
new file mode 100644
index 00000000000..46c08b5fc4f
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/c-unwind-abi.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -C opt-level=0
+//@ needs-unwind
+
+// Test that `nounwind` attributes are correctly applied to exported `C` and `C-unwind` extern
+// functions. `C-unwind` functions MUST NOT have this attribute. We disable optimizations above
+// to prevent LLVM from inferring the attribute.
+
+#![crate_type = "lib"]
+
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+#[no_mangle]
+pub extern "C" fn rust_item_that_cannot_unwind() {}
+
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+#[no_mangle]
+pub extern "C-unwind" fn rust_item_that_can_unwind() {}
+
+// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
+// sure that the first item is correctly marked with the `nounwind` attribute:
+//
+// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
+//
+// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
+//
+// CHECK: attributes #1 = {
+// CHECK-NOT: nounwind
+// CHECK: }
diff --git a/tests/codegen-llvm/unwind-abis/cdecl-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/cdecl-unwind-abi.rs
new file mode 100644
index 00000000000..8e643d6ce49
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/cdecl-unwind-abi.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -C opt-level=0
+//@ needs-unwind
+
+// Test that `nounwind` attributes are correctly applied to exported `cdecl` and
+// `cdecl-unwind` extern functions. `cdecl-unwind` functions MUST NOT have this attribute. We
+// disable optimizations above to prevent LLVM from inferring the attribute.
+
+#![crate_type = "lib"]
+
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+#[no_mangle]
+pub extern "cdecl" fn rust_item_that_cannot_unwind() {}
+
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+#[no_mangle]
+pub extern "cdecl-unwind" fn rust_item_that_can_unwind() {}
+
+// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
+// sure that the first item is correctly marked with the `nounwind` attribute:
+//
+// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
+//
+// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
+//
+// CHECK: attributes #1 = {
+// CHECK-NOT: nounwind
+// CHECK: }
diff --git a/tests/codegen-llvm/unwind-abis/fastcall-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/fastcall-unwind-abi.rs
new file mode 100644
index 00000000000..7df46813ed1
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/fastcall-unwind-abi.rs
@@ -0,0 +1,36 @@
+//@ needs-llvm-components: x86
+//@ compile-flags: --target=i686-pc-windows-msvc --crate-type=rlib -Cno-prepopulate-passes
+#![no_core]
+#![feature(no_core, lang_items)]
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+
+// Test that `nounwind` attributes are correctly applied to exported `fastcall` and
+// `fastcall-unwind` extern functions. `fastcall-unwind` functions MUST NOT have this attribute. We
+// disable optimizations above to prevent LLVM from inferring the attribute.
+
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+#[no_mangle]
+pub extern "fastcall" fn rust_item_that_cannot_unwind() {}
+
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+#[no_mangle]
+pub extern "fastcall-unwind" fn rust_item_that_can_unwind() {}
+
+// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
+// sure that the first item is correctly marked with the `nounwind` attribute:
+//
+// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
+//
+// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
+//
+// CHECK: attributes #1 = {
+// CHECK-NOT: nounwind
+// CHECK: }
diff --git a/tests/codegen-llvm/unwind-abis/nounwind-on-stable-panic-abort.rs b/tests/codegen-llvm/unwind-abis/nounwind-on-stable-panic-abort.rs
new file mode 100644
index 00000000000..d27cbd60437
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/nounwind-on-stable-panic-abort.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -C opt-level=0 -Cpanic=abort
+
+#![crate_type = "lib"]
+
+// We disable optimizations to prevent LLVM from inferring the attribute.
+
+// CHECK: Function Attrs:{{.*}}nounwind
+// CHECK-NEXT: @foo
+#[no_mangle]
+pub extern "C" fn foo() {}
+
+// CHECK: Function Attrs:{{.*}}nounwind
+// CHECK-NEXT: @bar
+#[no_mangle]
+pub fn bar() {}
diff --git a/tests/codegen-llvm/unwind-abis/nounwind.rs b/tests/codegen-llvm/unwind-abis/nounwind.rs
new file mode 100644
index 00000000000..e40ed48ca73
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/nounwind.rs
@@ -0,0 +1,16 @@
+//@ compile-flags: -C opt-level=0 -Cpanic=abort
+//@ needs-unwind
+
+#![crate_type = "lib"]
+
+// We disable optimizations to prevent LLVM from inferring the attribute.
+
+// CHECK: Function Attrs:{{.*}}nounwind
+// CHECK-NEXT: @foo
+#[no_mangle]
+pub extern "C" fn foo() {}
+
+// CHECK: Function Attrs:{{.*}}nounwind
+// CHECK-NEXT: @bar
+#[no_mangle]
+pub fn bar() {}
diff --git a/tests/codegen-llvm/unwind-abis/stdcall-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/stdcall-unwind-abi.rs
new file mode 100644
index 00000000000..cc06ee12549
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/stdcall-unwind-abi.rs
@@ -0,0 +1,36 @@
+//@ needs-llvm-components: x86
+//@ compile-flags: --target=i686-pc-windows-msvc --crate-type=rlib -Cno-prepopulate-passes
+#![no_core]
+#![feature(no_core, lang_items)]
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+
+// Test that `nounwind` attributes are correctly applied to exported `stdcall` and `stdcall-unwind`
+// extern functions. `stdcall-unwind` functions MUST NOT have this attribute. We disable
+// optimizations above to prevent LLVM from inferring the attribute.
+
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+#[no_mangle]
+pub extern "stdcall" fn rust_item_that_cannot_unwind() {}
+
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+#[no_mangle]
+pub extern "stdcall-unwind" fn rust_item_that_can_unwind() {}
+
+// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
+// sure that the first item is correctly marked with the `nounwind` attribute:
+//
+// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
+//
+// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
+//
+// CHECK: attributes #1 = {
+// CHECK-NOT: nounwind
+// CHECK: }
diff --git a/tests/codegen-llvm/unwind-abis/system-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/system-unwind-abi.rs
new file mode 100644
index 00000000000..5f910248346
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/system-unwind-abi.rs
@@ -0,0 +1,27 @@
+//@ compile-flags: -C opt-level=0
+//@ needs-unwind
+
+// Test that `nounwind` attributes are correctly applied to exported `system` and `system-unwind`
+// extern functions. `system-unwind` functions MUST NOT have this attribute. We disable
+// optimizations above to prevent LLVM from inferring the attribute.
+
+#![crate_type = "lib"]
+
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+#[no_mangle]
+pub extern "system" fn rust_item_that_cannot_unwind() {}
+
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+#[no_mangle]
+pub extern "system-unwind" fn rust_item_that_can_unwind() {}
+
+// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
+// sure that the first item is correctly marked with the `nounwind` attribute:
+//
+// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
+//
+// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
+//
+// CHECK: attributes #1 = {
+// CHECK-NOT: nounwind
+// CHECK: }
diff --git a/tests/codegen-llvm/unwind-abis/sysv64-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/sysv64-unwind-abi.rs
new file mode 100644
index 00000000000..69bfaf80b4b
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/sysv64-unwind-abi.rs
@@ -0,0 +1,36 @@
+//@ needs-llvm-components: x86
+//@ compile-flags: --target=x86_64-unknown-linux-gnu --crate-type=rlib -Cno-prepopulate-passes
+#![no_core]
+#![feature(no_core, lang_items)]
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+
+// Test that `nounwind` attributes are correctly applied to exported `sysv64` and
+// `sysv64-unwind` extern functions. `sysv64-unwind` functions MUST NOT have this attribute. We
+// disable optimizations above to prevent LLVM from inferring the attribute.
+
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+#[no_mangle]
+pub extern "sysv64" fn rust_item_that_cannot_unwind() {}
+
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+#[no_mangle]
+pub extern "sysv64-unwind" fn rust_item_that_can_unwind() {}
+
+// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
+// sure that the first item is correctly marked with the `nounwind` attribute:
+//
+// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
+//
+// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
+//
+// CHECK: attributes #1 = {
+// CHECK-NOT: nounwind
+// CHECK: }
diff --git a/tests/codegen-llvm/unwind-abis/thiscall-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/thiscall-unwind-abi.rs
new file mode 100644
index 00000000000..05f6b8b70e1
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/thiscall-unwind-abi.rs
@@ -0,0 +1,36 @@
+//@ needs-llvm-components: x86
+//@ compile-flags: --target=i686-pc-windows-msvc --crate-type=rlib -Cno-prepopulate-passes
+#![no_core]
+#![feature(no_core, lang_items)]
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+
+// Test that `nounwind` attributes are correctly applied to exported `thiscall` and
+// `thiscall-unwind` extern functions. `thiscall-unwind` functions MUST NOT have this attribute. We
+// disable optimizations above to prevent LLVM from inferring the attribute.
+
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+#[no_mangle]
+pub extern "thiscall" fn rust_item_that_cannot_unwind() {}
+
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+#[no_mangle]
+pub extern "thiscall-unwind" fn rust_item_that_can_unwind() {}
+
+// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
+// sure that the first item is correctly marked with the `nounwind` attribute:
+//
+// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
+//
+// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
+//
+// CHECK: attributes #1 = {
+// CHECK-NOT: nounwind
+// CHECK: }
diff --git a/tests/codegen-llvm/unwind-abis/vectorcall-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/vectorcall-unwind-abi.rs
new file mode 100644
index 00000000000..d001a16b32a
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/vectorcall-unwind-abi.rs
@@ -0,0 +1,36 @@
+//@ needs-llvm-components: x86
+//@ compile-flags: --target=i686-pc-windows-msvc --crate-type=rlib -Cno-prepopulate-passes
+#![no_core]
+#![feature(no_core, lang_items, abi_vectorcall)]
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+
+// Test that `nounwind` attributes are correctly applied to exported `vectorcall` and
+// `vectorcall-unwind` extern functions. `vectorcall-unwind` functions MUST NOT have this attribute.
+// We disable optimizations above to prevent LLVM from inferring the attribute.
+
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+#[no_mangle]
+pub extern "vectorcall" fn rust_item_that_cannot_unwind() {}
+
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+#[no_mangle]
+pub extern "vectorcall-unwind" fn rust_item_that_can_unwind() {}
+
+// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
+// sure that the first item is correctly marked with the `nounwind` attribute:
+//
+// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
+//
+// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
+//
+// CHECK: attributes #1 = {
+// CHECK-NOT: nounwind
+// CHECK: }
diff --git a/tests/codegen-llvm/unwind-abis/win64-unwind-abi.rs b/tests/codegen-llvm/unwind-abis/win64-unwind-abi.rs
new file mode 100644
index 00000000000..257f00b54e4
--- /dev/null
+++ b/tests/codegen-llvm/unwind-abis/win64-unwind-abi.rs
@@ -0,0 +1,36 @@
+//@ needs-llvm-components: x86
+//@ compile-flags: --target=x86_64-unknown-linux-gnu --crate-type=rlib -Cno-prepopulate-passes
+#![no_core]
+#![feature(no_core, lang_items)]
+
+#[lang = "pointee_sized"]
+pub trait PointeeSized {}
+
+#[lang = "meta_sized"]
+pub trait MetaSized: PointeeSized {}
+
+#[lang = "sized"]
+pub trait Sized: MetaSized {}
+
+// Test that `nounwind` attributes are correctly applied to exported `win64` and
+// `win64-unwind` extern functions. `win64-unwind` functions MUST NOT have this attribute. We
+// disable optimizations above to prevent LLVM from inferring the attribute.
+
+// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
+#[no_mangle]
+pub extern "win64" fn rust_item_that_cannot_unwind() {}
+
+// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
+#[no_mangle]
+pub extern "win64-unwind" fn rust_item_that_can_unwind() {}
+
+// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
+// sure that the first item is correctly marked with the `nounwind` attribute:
+//
+// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
+//
+// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
+//
+// CHECK: attributes #1 = {
+// CHECK-NOT: nounwind
+// CHECK: }
diff --git a/tests/codegen-llvm/unwind-and-panic-abort.rs b/tests/codegen-llvm/unwind-and-panic-abort.rs
new file mode 100644
index 00000000000..8efa140058a
--- /dev/null
+++ b/tests/codegen-llvm/unwind-and-panic-abort.rs
@@ -0,0 +1,16 @@
+//@ compile-flags: -C panic=abort
+
+#![crate_type = "lib"]
+
+extern "C-unwind" {
+    fn bar();
+}
+
+// CHECK: Function Attrs:{{.*}}nounwind
+// CHECK-NEXT: define{{.*}}void @foo
+// Handle both legacy and v0 symbol mangling.
+// CHECK: call void @{{.*core9panicking19panic_cannot_unwind}}
+#[no_mangle]
+pub unsafe extern "C" fn foo() {
+    bar();
+}
diff --git a/tests/codegen-llvm/unwind-extern-exports.rs b/tests/codegen-llvm/unwind-extern-exports.rs
new file mode 100644
index 00000000000..e692fd1a547
--- /dev/null
+++ b/tests/codegen-llvm/unwind-extern-exports.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -C opt-level=0
+//@ needs-unwind
+
+#![crate_type = "lib"]
+
+// Make sure these all do *not* get the attribute.
+// We disable optimizations to prevent LLVM from inferring the attribute.
+// CHECK-NOT: nounwind
+
+// "C" ABI
+pub extern "C-unwind" fn foo_unwind() {}
+
+// "Rust"
+// (`extern "Rust"` could be removed as all `fn` get it implicitly; we leave it in for clarity.)
+pub fn bar() {}
diff --git a/tests/codegen-llvm/unwind-extern-imports.rs b/tests/codegen-llvm/unwind-extern-imports.rs
new file mode 100644
index 00000000000..dfae8aae64a
--- /dev/null
+++ b/tests/codegen-llvm/unwind-extern-imports.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -C no-prepopulate-passes
+//@ needs-unwind
+
+#![crate_type = "lib"]
+
+extern "C" {
+    // CHECK: Function Attrs:{{.*}}nounwind
+    // CHECK-NEXT: declare{{.*}}void @extern_fn
+    fn extern_fn();
+}
+
+extern "C-unwind" {
+    // CHECK-NOT: nounwind
+    // CHECK: declare{{.*}}void @c_unwind_extern_fn
+    fn c_unwind_extern_fn();
+}
+
+pub unsafe fn force_declare() {
+    extern_fn();
+    c_unwind_extern_fn();
+}
diff --git a/tests/codegen-llvm/unwind-landingpad-cold.rs b/tests/codegen-llvm/unwind-landingpad-cold.rs
new file mode 100644
index 00000000000..fb095e04650
--- /dev/null
+++ b/tests/codegen-llvm/unwind-landingpad-cold.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -Cno-prepopulate-passes
+//@ needs-unwind
+#![crate_type = "lib"]
+
+// This test checks that drop calls in unwind landing pads
+// get the `cold` attribute.
+
+// CHECK-LABEL: @check_cold
+// CHECK: {{(call|invoke) void .+}}drop_in_place{{.+}} [[ATTRIBUTES:#[0-9]+]]
+// CHECK: attributes [[ATTRIBUTES]] = { cold }
+#[no_mangle]
+pub fn check_cold(f: fn(), x: Box<u32>) {
+    // this may unwind
+    f();
+}
diff --git a/tests/codegen-llvm/unwind-landingpad-inline.rs b/tests/codegen-llvm/unwind-landingpad-inline.rs
new file mode 100644
index 00000000000..1cf606279e6
--- /dev/null
+++ b/tests/codegen-llvm/unwind-landingpad-inline.rs
@@ -0,0 +1,39 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+// This test checks that we can inline drop_in_place in
+// unwind landing pads.
+
+// Without inlining, the box pointers escape via the call to drop_in_place,
+// and LLVM will not optimize out the pointer comparison.
+// With inlining, everything should be optimized out.
+// See https://github.com/rust-lang/rust/issues/46515
+// CHECK-LABEL: @check_no_escape_in_landingpad
+// CHECK: start:
+// CHECK-NEXT: ; call __rustc::__rust_no_alloc_shim_is_unstable_v2
+// CHECK-NEXT: tail call void @[[NO_ALLOC_SHIM:_R.+__rust_no_alloc_shim_is_unstable_v2]]()
+// CHECK-NEXT: ; call __rustc::__rust_no_alloc_shim_is_unstable_v2
+// CHECK-NEXT: tail call void @[[NO_ALLOC_SHIM]]()
+// CHECK-NEXT: ret void
+#[no_mangle]
+pub fn check_no_escape_in_landingpad(f: fn()) {
+    let x = &*Box::new(0);
+    let y = &*Box::new(0);
+
+    if x as *const _ == y as *const _ {
+        f();
+    }
+}
+
+// Without inlining, the compiler can't tell that
+// dropping an empty string (in a landing pad) does nothing.
+// With inlining, the landing pad should be optimized out.
+// See https://github.com/rust-lang/rust/issues/87055
+// CHECK-LABEL: @check_eliminate_noop_drop
+// CHECK: call void %g()
+// CHECK-NEXT: ret void
+#[no_mangle]
+pub fn check_eliminate_noop_drop(g: fn()) {
+    let _var = String::new();
+    g();
+}
diff --git a/tests/codegen-llvm/used_with_arg.rs b/tests/codegen-llvm/used_with_arg.rs
new file mode 100644
index 00000000000..4515cb2aed0
--- /dev/null
+++ b/tests/codegen-llvm/used_with_arg.rs
@@ -0,0 +1,10 @@
+#![crate_type = "lib"]
+#![feature(used_with_arg)]
+
+// CHECK: @llvm.used = appending global {{.*}}USED_LINKER
+#[used(linker)]
+static mut USED_LINKER: [usize; 1] = [0];
+
+// CHECK-NEXT: @llvm.compiler.used = appending global {{.*}}USED_COMPILER
+#[used(compiler)]
+static mut USED_COMPILER: [usize; 1] = [0];
diff --git a/tests/codegen-llvm/var-names.rs b/tests/codegen-llvm/var-names.rs
new file mode 100644
index 00000000000..40720e19761
--- /dev/null
+++ b/tests/codegen-llvm/var-names.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: define{{.*}}i32 @test(i32{{.*}} %a, i32{{.*}} %b)
+#[no_mangle]
+pub fn test(a: u32, b: u32) -> u32 {
+    let c = a + b;
+    // CHECK: %c = add i32 %a, %b
+    let d = c;
+    let e = d * a;
+    // CHECK-NEXT: %e = mul i32 %c, %a
+    e
+    // CHECK-NEXT: ret i32 %e
+}
diff --git a/tests/codegen-llvm/vec-as-ptr.rs b/tests/codegen-llvm/vec-as-ptr.rs
new file mode 100644
index 00000000000..5c997802640
--- /dev/null
+++ b/tests/codegen-llvm/vec-as-ptr.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+
+#![crate_type = "lib"]
+
+// Test that even though we return a *const u8 not a &[u8] or a NonNull<u8>, LLVM knows that this
+// pointer is nonnull.
+// CHECK: nonnull ptr @vec_as_ptr
+#[no_mangle]
+pub fn vec_as_ptr(v: &Vec<u8>) -> *const u8 {
+    v.as_ptr()
+}
+
+// Test that even though we return a *const u8 not a &[u8] or a NonNull<u8>, LLVM knows that this
+// pointer is nonnull.
+// CHECK: nonnull ptr @vec_as_mut_ptr
+#[no_mangle]
+pub fn vec_as_mut_ptr(v: &mut Vec<u8>) -> *mut u8 {
+    v.as_mut_ptr()
+}
diff --git a/tests/codegen-llvm/vec-calloc.rs b/tests/codegen-llvm/vec-calloc.rs
new file mode 100644
index 00000000000..d1c320ead01
--- /dev/null
+++ b/tests/codegen-llvm/vec-calloc.rs
@@ -0,0 +1,182 @@
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+//@ only-x86_64
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @vec_zero_bytes
+#[no_mangle]
+pub fn vec_zero_bytes(n: usize) -> Vec<u8> {
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+    // CHECK-NOT: call {{.*}}llvm.memset
+
+    // CHECK: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+    // CHECK-NOT: call {{.*}}llvm.memset
+
+    // CHECK: ret void
+    vec![0; n]
+}
+
+// CHECK-LABEL: @vec_one_bytes
+#[no_mangle]
+pub fn vec_one_bytes(n: usize) -> Vec<u8> {
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK: call {{.*}}__rust_alloc(
+    // CHECK: call {{.*}}llvm.memset
+
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK: ret void
+    vec![1; n]
+}
+
+// CHECK-LABEL: @vec_zero_scalar
+#[no_mangle]
+pub fn vec_zero_scalar(n: usize) -> Vec<i32> {
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: ret void
+    vec![0; n]
+}
+
+// CHECK-LABEL: @vec_one_scalar
+#[no_mangle]
+pub fn vec_one_scalar(n: usize) -> Vec<i32> {
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK: call {{.*}}__rust_alloc(
+
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK: ret void
+    vec![1; n]
+}
+
+// CHECK-LABEL: @vec_zero_rgb48
+#[no_mangle]
+pub fn vec_zero_rgb48(n: usize) -> Vec<[u16; 3]> {
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: ret void
+    vec![[0, 0, 0]; n]
+}
+
+// CHECK-LABEL: @vec_zero_array_16
+#[no_mangle]
+pub fn vec_zero_array_16(n: usize) -> Vec<[i64; 16]> {
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: ret void
+    vec![[0_i64; 16]; n]
+}
+
+// CHECK-LABEL: @vec_zero_tuple
+#[no_mangle]
+pub fn vec_zero_tuple(n: usize) -> Vec<(i16, u8, char)> {
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: ret void
+    vec![(0, 0, '\0'); n]
+}
+
+// CHECK-LABEL: @vec_non_zero_tuple
+#[no_mangle]
+pub fn vec_non_zero_tuple(n: usize) -> Vec<(i16, u8, char)> {
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK: call {{.*}}__rust_alloc(
+
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK: ret void
+    vec![(0, 0, 'A'); n]
+}
+
+// CHECK-LABEL: @vec_option_bool
+#[no_mangle]
+pub fn vec_option_bool(n: usize) -> Vec<Option<bool>> {
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: ret void
+    vec![Some(false); n]
+}
+
+// CHECK-LABEL: @vec_option_i32
+#[no_mangle]
+pub fn vec_option_i32(n: usize) -> Vec<Option<i32>> {
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: call {{.*}}__rust_alloc_zeroed(
+
+    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+
+    // CHECK: ret void
+    vec![None; n]
+}
+
+// Ensure that __rust_alloc_zeroed gets the right attributes for LLVM to optimize it away.
+// CHECK: declare noalias noundef ptr @{{.*}}__rust_alloc_zeroed(i64 noundef, i64 allocalign noundef) unnamed_addr [[RUST_ALLOC_ZEROED_ATTRS:#[0-9]+]]
+
+// CHECK-DAG: attributes [[RUST_ALLOC_ZEROED_ATTRS]] = { {{.*}} allockind("alloc,zeroed,aligned") allocsize(0) uwtable "alloc-family"="__rust_alloc" {{.*}} }
diff --git a/tests/codegen-llvm/vec-in-place.rs b/tests/codegen-llvm/vec-in-place.rs
new file mode 100644
index 00000000000..a5ef8653b99
--- /dev/null
+++ b/tests/codegen-llvm/vec-in-place.rs
@@ -0,0 +1,161 @@
+//@ ignore-std-debug-assertions (FIXME: checks for call detect scoped noalias metadata)
+//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
+#![crate_type = "lib"]
+
+// Ensure that trivial casts of vec elements are O(1)
+
+pub struct Wrapper<T>(T);
+
+// previously repr(C) caused the optimization to fail
+#[repr(C)]
+pub struct Foo {
+    a: u64,
+    b: u64,
+    c: u64,
+    d: u64,
+}
+
+// implementing Copy exercises the TrustedRandomAccess specialization inside the in-place
+// specialization
+#[derive(Copy, Clone)]
+pub struct Bar {
+    a: u64,
+    b: u64,
+    c: u64,
+    d: u64,
+}
+
+// this exercises the try-fold codepath
+pub struct Baz {
+    a: u64,
+    b: u64,
+    c: u64,
+    d: u64,
+}
+
+// CHECK-LABEL: @vec_iterator_cast_primitive
+#[no_mangle]
+pub fn vec_iterator_cast_primitive(vec: Vec<i8>) -> Vec<u8> {
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+    vec.into_iter().map(|e| e as u8).collect()
+}
+
+// CHECK-LABEL: @vec_iterator_cast_wrapper
+#[no_mangle]
+pub fn vec_iterator_cast_wrapper(vec: Vec<u8>) -> Vec<Wrapper<u8>> {
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+    vec.into_iter().map(|e| Wrapper(e)).collect()
+}
+
+// CHECK-LABEL: @vec_iterator_cast_signed
+#[no_mangle]
+pub fn vec_iterator_cast_signed(vec: Vec<i32>) -> Vec<u32> {
+    // CHECK-NOT: and i{{[0-9]+}} %{{.*}}, {{[0-9]+}}
+    vec.into_iter().map(|e| u32::from_ne_bytes(e.to_ne_bytes())).collect()
+}
+
+// CHECK-LABEL: @vec_iterator_cast_signed_nested
+#[no_mangle]
+pub fn vec_iterator_cast_signed_nested(vec: Vec<Vec<i32>>) -> Vec<Vec<u32>> {
+    // CHECK-NOT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
+    // CHECK-NOT: %{{.*}} = udiv
+    vec.into_iter()
+        .map(|e| e.into_iter().map(|e| u32::from_ne_bytes(e.to_ne_bytes())).collect())
+        .collect()
+}
+
+// CHECK-LABEL: @vec_iterator_cast_unwrap
+#[no_mangle]
+pub fn vec_iterator_cast_unwrap(vec: Vec<Wrapper<u8>>) -> Vec<u8> {
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+    vec.into_iter().map(|e| e.0).collect()
+}
+
+// CHECK-LABEL: @vec_iterator_cast_aggregate
+#[no_mangle]
+pub fn vec_iterator_cast_aggregate(vec: Vec<[u64; 4]>) -> Vec<Foo> {
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+    vec.into_iter().map(|e| unsafe { std::mem::transmute(e) }).collect()
+}
+
+// CHECK-LABEL: @vec_iterator_cast_deaggregate_tra
+#[no_mangle]
+pub fn vec_iterator_cast_deaggregate_tra(vec: Vec<Bar>) -> Vec<[u64; 4]> {
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+
+    // Safety: For the purpose of this test we assume that Bar layout matches [u64; 4].
+    // This currently is not guaranteed for repr(Rust) types, but it happens to work here and
+    // the UCG may add additional guarantees for homogenous types in the future that would make this
+    // correct.
+    vec.into_iter().map(|e| unsafe { std::mem::transmute(e) }).collect()
+}
+
+// CHECK-LABEL: @vec_iterator_cast_deaggregate_fold
+#[no_mangle]
+pub fn vec_iterator_cast_deaggregate_fold(vec: Vec<Baz>) -> Vec<[u64; 4]> {
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
+    // CHECK-NOT: loop
+    // CHECK-NOT: call
+
+    // Safety: For the purpose of this test we assume that Bar layout matches [u64; 4].
+    // This currently is not guaranteed for repr(Rust) types, but it happens to work here and
+    // the UCG may add additional guarantees for homogenous types in the future that would make this
+    // correct.
+    vec.into_iter().map(|e| unsafe { std::mem::transmute(e) }).collect()
+}
+
+// CHECK-LABEL: @vec_iterator_cast_unwrap_drop
+#[no_mangle]
+pub fn vec_iterator_cast_unwrap_drop(vec: Vec<Wrapper<String>>) -> Vec<String> {
+    // CHECK-NOT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
+    // CHECK-NOT: %{{.*}} = mul
+    // CHECK-NOT: %{{.*}} = udiv
+    // CHECK: call
+    // CHECK-SAME: void @llvm.assume(i1 %{{.+}})
+    // CHECK-NOT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
+    // CHECK-NOT: call
+    // CHECK-NOT: %{{.*}} = mul
+    // CHECK-NOT: %{{.*}} = udiv
+    // CHECK: ret void
+
+    vec.into_iter().map(|Wrapper(e)| e).collect()
+}
+
+// CHECK-LABEL: @vec_iterator_cast_wrap_drop
+#[no_mangle]
+pub fn vec_iterator_cast_wrap_drop(vec: Vec<String>) -> Vec<Wrapper<String>> {
+    // CHECK-NOT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
+    // CHECK-NOT: %{{.*}} = mul
+    // CHECK-NOT: %{{.*}} = udiv
+    // CHECK: call
+    // CHECK-SAME: void @llvm.assume(i1 %{{.+}})
+    // CHECK-NOT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
+    // CHECK-NOT: call
+    // CHECK-NOT: %{{.*}} = mul
+    // CHECK-NOT: %{{.*}} = udiv
+    // CHECK: ret void
+
+    vec.into_iter().map(Wrapper).collect()
+}
diff --git a/tests/codegen-llvm/vec-iter-collect-len.rs b/tests/codegen-llvm/vec-iter-collect-len.rs
new file mode 100644
index 00000000000..807548ef883
--- /dev/null
+++ b/tests/codegen-llvm/vec-iter-collect-len.rs
@@ -0,0 +1,12 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn get_len() -> usize {
+    // CHECK-LABEL: @get_len
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: ; call __rustc::__rust_no_alloc_shim_is_unstable_v2
+    // CHECK-NEXT: tail call void @_R{{.+}}__rust_no_alloc_shim_is_unstable_v2()
+    // CHECK-NEXT: ret i{{[0-9]+}} 3
+    [1, 2, 3].iter().collect::<Vec<_>>().len()
+}
diff --git a/tests/codegen-llvm/vec-iter.rs b/tests/codegen-llvm/vec-iter.rs
new file mode 100644
index 00000000000..4ed00d2d34f
--- /dev/null
+++ b/tests/codegen-llvm/vec-iter.rs
@@ -0,0 +1,58 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+#![feature(exact_size_is_empty)]
+
+use std::vec;
+
+// CHECK-LABEL: @vec_iter_len_nonnull
+#[no_mangle]
+pub fn vec_iter_len_nonnull(it: &vec::IntoIter<u8>) -> usize {
+    // CHECK: load ptr
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: load ptr
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: sub nuw
+    // CHECK: ret
+    it.len()
+}
+
+// CHECK-LABEL: @vec_iter_is_empty_nonnull
+#[no_mangle]
+pub fn vec_iter_is_empty_nonnull(it: &vec::IntoIter<u8>) -> bool {
+    // CHECK: load ptr
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: load ptr
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: ret
+    it.is_empty()
+}
+
+// CHECK-LABEL: @vec_iter_next_nonnull
+#[no_mangle]
+pub fn vec_iter_next_nonnull(it: &mut vec::IntoIter<u8>) -> Option<u8> {
+    // CHECK: load ptr
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: load ptr
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: ret
+    it.next()
+}
+
+// CHECK-LABEL: @vec_iter_next_back_nonnull
+#[no_mangle]
+pub fn vec_iter_next_back_nonnull(it: &mut vec::IntoIter<u8>) -> Option<u8> {
+    // CHECK: load ptr
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: load ptr
+    // CHECK-SAME: !nonnull
+    // CHECK-SAME: !noundef
+    // CHECK: ret
+    it.next_back()
+}
diff --git a/tests/codegen-llvm/vec-len-invariant.rs b/tests/codegen-llvm/vec-len-invariant.rs
new file mode 100644
index 00000000000..033181c2bfb
--- /dev/null
+++ b/tests/codegen-llvm/vec-len-invariant.rs
@@ -0,0 +1,16 @@
+//@ compile-flags: -Copt-level=3
+//@ only-64bit
+//
+// This test confirms that we do not reload the length of a Vec after growing it in push.
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @should_load_once
+#[no_mangle]
+pub fn should_load_once(v: &mut Vec<u8>) {
+    // CHECK: load i64
+    // CHECK: call {{.*}}grow_one
+    // CHECK-NOT: load i64
+    // CHECK: add {{.*}}, 1
+    v.push(1);
+}
diff --git a/tests/codegen-llvm/vec-optimizes-away.rs b/tests/codegen-llvm/vec-optimizes-away.rs
new file mode 100644
index 00000000000..93b55454b10
--- /dev/null
+++ b/tests/codegen-llvm/vec-optimizes-away.rs
@@ -0,0 +1,12 @@
+//@ compile-flags: -Copt-level=3
+#![crate_type = "lib"]
+
+#[no_mangle]
+pub fn sum_me() -> i32 {
+    // CHECK-LABEL: @sum_me
+    // CHECK-NEXT: {{^.*:$}}
+    // CHECK-NEXT: ; call __rustc::__rust_no_alloc_shim_is_unstable_v2
+    // CHECK-NEXT: tail call void @_R{{.+}}__rust_no_alloc_shim_is_unstable_v2()
+    // CHECK-NEXT: ret i32 6
+    vec![1, 2, 3].iter().sum::<i32>()
+}
diff --git a/tests/codegen-llvm/vec-reserve-extend.rs b/tests/codegen-llvm/vec-reserve-extend.rs
new file mode 100644
index 00000000000..4d3f23ccecf
--- /dev/null
+++ b/tests/codegen-llvm/vec-reserve-extend.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @should_reserve_once
+#[no_mangle]
+pub fn should_reserve_once(v: &mut Vec<u8>) {
+    // CHECK: tail call void @llvm.assume
+    v.try_reserve(3).unwrap();
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: call {{.*}}do_reserve_and_handle
+    // CHECK-NOT: call {{.*}}__rust_alloc(
+    v.extend([1, 2, 3]);
+}
diff --git a/tests/codegen-llvm/vec-shrink-panik.rs b/tests/codegen-llvm/vec-shrink-panik.rs
new file mode 100644
index 00000000000..23dd300d48c
--- /dev/null
+++ b/tests/codegen-llvm/vec-shrink-panik.rs
@@ -0,0 +1,31 @@
+// LLVM 17 realizes double panic is not possible and doesn't generate calls
+// to panic_cannot_unwind.
+//@ compile-flags: -Copt-level=3
+//@ ignore-std-debug-assertions (plain old debug assertions)
+//@ needs-unwind
+#![crate_type = "lib"]
+#![feature(shrink_to)]
+
+// Make sure that `Vec::shrink_to_fit` never emits panics via `RawVec::shrink_to_fit`,
+// "Tried to shrink to a larger capacity", because the length is *always* <= capacity.
+
+// CHECK-LABEL: @shrink_to_fit
+#[no_mangle]
+pub fn shrink_to_fit(vec: &mut Vec<u32>) {
+    // CHECK-NOT: panic
+    vec.shrink_to_fit();
+}
+
+// CHECK-LABEL: @issue71861
+#[no_mangle]
+pub fn issue71861(vec: Vec<u32>) -> Box<[u32]> {
+    // CHECK-NOT: panic
+    vec.into_boxed_slice()
+}
+
+// CHECK-LABEL: @issue75636
+#[no_mangle]
+pub fn issue75636<'a>(iter: &[&'a str]) -> Box<[&'a str]> {
+    // CHECK-NOT: panic
+    iter.iter().copied().collect()
+}
diff --git a/tests/codegen-llvm/vec-with-capacity.rs b/tests/codegen-llvm/vec-with-capacity.rs
new file mode 100644
index 00000000000..777bbcc4fcb
--- /dev/null
+++ b/tests/codegen-llvm/vec-with-capacity.rs
@@ -0,0 +1,35 @@
+//@ compile-flags: -Copt-level=3
+//@ ignore-std-debug-assertions
+// (with debug assertions turned on, `assert_unchecked` generates a real assertion)
+
+#![crate_type = "lib"]
+#![feature(try_with_capacity)]
+
+// CHECK-LABEL: @with_capacity_does_not_grow1
+#[no_mangle]
+pub fn with_capacity_does_not_grow1() -> Vec<u32> {
+    let v = Vec::with_capacity(1234);
+    // CHECK: call {{.*}}__rust_alloc(
+    // CHECK-NOT: call {{.*}}__rust_realloc
+    // CHECK-NOT: call {{.*}}capacity_overflow
+    // CHECK-NOT: call {{.*}}finish_grow
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: memcpy
+    // CHECK-NOT: memset
+    v
+}
+
+// CHECK-LABEL: @try_with_capacity_does_not_grow2
+#[no_mangle]
+pub fn try_with_capacity_does_not_grow2() -> Option<Vec<Vec<u8>>> {
+    let v = Vec::try_with_capacity(1234).ok()?;
+    // CHECK: call {{.*}}__rust_alloc(
+    // CHECK-NOT: call {{.*}}__rust_realloc
+    // CHECK-NOT: call {{.*}}capacity_overflow
+    // CHECK-NOT: call {{.*}}finish_grow
+    // CHECK-NOT: call {{.*}}handle_alloc_error
+    // CHECK-NOT: call {{.*}}reserve
+    // CHECK-NOT: memcpy
+    // CHECK-NOT: memset
+    Some(v)
+}
diff --git a/tests/codegen-llvm/vec_pop_push_noop.rs b/tests/codegen-llvm/vec_pop_push_noop.rs
new file mode 100644
index 00000000000..3e375219fe0
--- /dev/null
+++ b/tests/codegen-llvm/vec_pop_push_noop.rs
@@ -0,0 +1,24 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+#[no_mangle]
+// CHECK-LABEL: @noop(
+pub fn noop(v: &mut Vec<u8>) {
+    // CHECK-NOT: grow_one
+    // CHECK-NOT: call
+    // CHECK: tail call void @llvm.assume
+    // CHECK-NOT: grow_one
+    // CHECK-NOT: call
+    // CHECK: {{ret|[}]}}
+    if let Some(x) = v.pop() {
+        v.push(x)
+    }
+}
+
+#[no_mangle]
+// CHECK-LABEL: @push_byte(
+pub fn push_byte(v: &mut Vec<u8>) {
+    // CHECK: call {{.*}}grow_one
+    v.push(3);
+}
diff --git a/tests/codegen-llvm/vecdeque-drain.rs b/tests/codegen-llvm/vecdeque-drain.rs
new file mode 100644
index 00000000000..a5e5da65013
--- /dev/null
+++ b/tests/codegen-llvm/vecdeque-drain.rs
@@ -0,0 +1,70 @@
+// Check that draining at the front or back doesn't copy memory.
+
+//@ compile-flags: -Copt-level=3
+//@ needs-deterministic-layouts
+//@ ignore-std-debug-assertions (FIXME: checks for call detect scoped noalias metadata)
+
+#![crate_type = "lib"]
+
+use std::collections::VecDeque;
+
+// CHECK-LABEL: @clear
+// CHECK-NOT: call
+// CHECK-NOT: br
+// CHECK: getelementptr inbounds
+// CHECK-NEXT: {{call void @llvm.memset|store}}
+// CHECK-NEXT: ret void
+#[no_mangle]
+pub fn clear(v: &mut VecDeque<i32>) {
+    v.drain(..);
+}
+
+// CHECK-LABEL: @truncate
+// CHECK-NOT: call
+// CHECK: br
+// CHECK-NOT: call
+// CHECK: br
+// CHECK-NOT: call
+// CHECK: br
+// CHECK-NOT: call
+// CHECK: br
+// CHECK-NOT: call
+// CHECK-NOT: br
+// CHECK: ret void
+#[no_mangle]
+pub fn truncate(v: &mut VecDeque<i32>, n: usize) {
+    if n < v.len() {
+        v.drain(n..);
+    }
+}
+
+// CHECK-LABEL: @advance
+// CHECK-NOT: call
+// CHECK: br
+// CHECK-NOT: call
+// CHECK: br
+// CHECK-NOT: call
+// CHECK: br
+// CHECK-NOT: call
+// CHECK: br
+// CHECK-NOT: call
+// CHECK: br
+// CHECK-NOT: call
+// CHECK-NOT: br
+// CHECK: ret void
+#[no_mangle]
+pub fn advance(v: &mut VecDeque<i32>, n: usize) {
+    if n < v.len() {
+        v.drain(..n);
+    } else {
+        v.clear();
+    }
+}
+
+// CHECK-LABEL: @remove
+// CHECK: call
+// CHECK: ret void
+#[no_mangle]
+pub fn remove(v: &mut VecDeque<i32>, a: usize, b: usize) {
+    v.drain(a..b);
+}
diff --git a/tests/codegen-llvm/vecdeque-nonempty-get-no-panic.rs b/tests/codegen-llvm/vecdeque-nonempty-get-no-panic.rs
new file mode 100644
index 00000000000..1f886b096bb
--- /dev/null
+++ b/tests/codegen-llvm/vecdeque-nonempty-get-no-panic.rs
@@ -0,0 +1,16 @@
+// Guards against regression for optimization discussed in issue #80836
+
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+use std::collections::VecDeque;
+
+// CHECK-LABEL: @front
+// CHECK: ret void
+#[no_mangle]
+pub fn front(v: VecDeque<usize>) {
+    if !v.is_empty() {
+        v.get(0).unwrap();
+    }
+}
diff --git a/tests/codegen-llvm/vecdeque_no_panic.rs b/tests/codegen-llvm/vecdeque_no_panic.rs
new file mode 100644
index 00000000000..3166842afca
--- /dev/null
+++ b/tests/codegen-llvm/vecdeque_no_panic.rs
@@ -0,0 +1,19 @@
+// This test checks that `VecDeque::front[_mut]()` and `VecDeque::back[_mut]()` can't panic.
+
+//@ compile-flags: -Copt-level=3
+//@ ignore-std-debug-assertions (plain old debug assertions)
+
+#![crate_type = "lib"]
+
+use std::collections::VecDeque;
+
+// CHECK-LABEL: @dont_panic
+#[no_mangle]
+pub fn dont_panic(v: &mut VecDeque<usize>) {
+    // CHECK-NOT: expect
+    // CHECK-NOT: panic
+    v.front();
+    v.front_mut();
+    v.back();
+    v.back_mut();
+}
diff --git a/tests/codegen-llvm/vecdeque_pop_push.rs b/tests/codegen-llvm/vecdeque_pop_push.rs
new file mode 100644
index 00000000000..5afa1b2248b
--- /dev/null
+++ b/tests/codegen-llvm/vecdeque_pop_push.rs
@@ -0,0 +1,67 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+use std::collections::VecDeque;
+
+#[no_mangle]
+// CHECK-LABEL: @noop_back(
+pub fn noop_back(v: &mut VecDeque<u8>) {
+    // CHECK-NOT: grow
+    // CHECK: tail call void @llvm.assume
+    // CHECK-NOT: grow
+    // CHECK: ret
+    if let Some(x) = v.pop_back() {
+        v.push_back(x);
+    }
+}
+
+#[no_mangle]
+// CHECK-LABEL: @noop_front(
+pub fn noop_front(v: &mut VecDeque<u8>) {
+    // CHECK-NOT: grow
+    // CHECK: tail call void @llvm.assume
+    // CHECK-NOT: grow
+    // CHECK: ret
+    if let Some(x) = v.pop_front() {
+        v.push_front(x);
+    }
+}
+
+#[no_mangle]
+// CHECK-LABEL: @move_byte_front_to_back(
+pub fn move_byte_front_to_back(v: &mut VecDeque<u8>) {
+    // CHECK-NOT: grow
+    // CHECK: tail call void @llvm.assume
+    // CHECK-NOT: grow
+    // CHECK: ret
+    if let Some(x) = v.pop_front() {
+        v.push_back(x);
+    }
+}
+
+#[no_mangle]
+// CHECK-LABEL: @move_byte_back_to_front(
+pub fn move_byte_back_to_front(v: &mut VecDeque<u8>) {
+    // CHECK-NOT: grow
+    // CHECK: tail call void @llvm.assume
+    // CHECK-NOT: grow
+    // CHECK: ret
+    if let Some(x) = v.pop_back() {
+        v.push_front(x);
+    }
+}
+
+#[no_mangle]
+// CHECK-LABEL: @push_back_byte(
+pub fn push_back_byte(v: &mut VecDeque<u8>) {
+    // CHECK: call {{.*}}grow
+    v.push_back(3);
+}
+
+#[no_mangle]
+// CHECK-LABEL: @push_front_byte(
+pub fn push_front_byte(v: &mut VecDeque<u8>) {
+    // CHECK: call {{.*}}grow
+    v.push_front(3);
+}
diff --git a/tests/codegen-llvm/virtual-call-attrs-issue-137646.rs b/tests/codegen-llvm/virtual-call-attrs-issue-137646.rs
new file mode 100644
index 00000000000..5e453947f27
--- /dev/null
+++ b/tests/codegen-llvm/virtual-call-attrs-issue-137646.rs
@@ -0,0 +1,37 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/137646.
+//! Since we don't know the exact implementation of the virtual call,
+//! it might write to parameters, we can't infer the readonly attribute.
+//@ compile-flags: -C opt-level=3 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(rustc_attrs)]
+
+pub trait Trait {
+    #[rustc_nounwind]
+    fn m(&self, _: (i32, i32, i32)) {}
+}
+
+#[no_mangle]
+pub fn foo(trait_: &dyn Trait) {
+    // CHECK-LABEL: @foo(
+    // CHECK: call void
+    // CHECK-NOT: readonly
+    trait_.m((1, 1, 1));
+}
+
+#[no_mangle]
+#[rustc_nounwind]
+pub fn foo_nounwind(trait_: &dyn Trait) {
+    // CHECK-LABEL: @foo_nounwind(
+    // FIXME: Here should be invoke.
+    // COM: CHECK: invoke
+    trait_.m((1, 1, 1));
+}
+
+#[no_mangle]
+pub extern "C" fn c_nounwind(trait_: &dyn Trait) {
+    // CHECK-LABEL: @c_nounwind(
+    // FIXME: Here should be invoke.
+    // COM: CHECK: invoke
+    trait_.m((1, 1, 1));
+}
diff --git a/tests/codegen-llvm/virtual-function-elimination-32bit.rs b/tests/codegen-llvm/virtual-function-elimination-32bit.rs
new file mode 100644
index 00000000000..c9919cecccf
--- /dev/null
+++ b/tests/codegen-llvm/virtual-function-elimination-32bit.rs
@@ -0,0 +1,35 @@
+//@ compile-flags: -Zvirtual-function-elimination -Clto -Copt-level=3 -Csymbol-mangling-version=v0
+//@ ignore-64bit
+
+// CHECK: @vtable.0 = {{.*}}, !type ![[TYPE0:[0-9]+]], !vcall_visibility ![[VCALL_VIS0:[0-9]+]]
+
+#![crate_type = "lib"]
+
+trait T {
+    // CHECK-LABEL: ; <virtual_function_elimination_32bit::S as virtual_function_elimination_32bit::T>::used
+    fn used(&self) -> i32 {
+        1
+    }
+    // CHECK-LABEL-NOT: {{.*}}::unused
+    fn unused(&self) -> i32 {
+        2
+    }
+}
+
+#[derive(Copy, Clone)]
+struct S;
+
+impl T for S {}
+
+fn taking_t(t: &dyn T) -> i32 {
+    // CHECK: @llvm.type.checked.load({{.*}}, i32 12, metadata !"[[MANGLED_TYPE0:[0-9a-zA-Z_]+]]")
+    t.used()
+}
+
+pub fn main() {
+    let s = S;
+    taking_t(&s);
+}
+
+// CHECK: ![[TYPE0]] = !{i32 0, !"[[MANGLED_TYPE0]]"}
+// CHECK: ![[VCALL_VIS0]] = !{i64 2}
diff --git a/tests/codegen-llvm/virtual-function-elimination.rs b/tests/codegen-llvm/virtual-function-elimination.rs
new file mode 100644
index 00000000000..26604478c11
--- /dev/null
+++ b/tests/codegen-llvm/virtual-function-elimination.rs
@@ -0,0 +1,98 @@
+//@ compile-flags: -Zvirtual-function-elimination -Clto -Copt-level=3 -Csymbol-mangling-version=v0
+//@ ignore-32bit
+
+// CHECK: @vtable.0 = {{.*}}, !type ![[TYPE0:[0-9]+]], !vcall_visibility ![[VCALL_VIS0:[0-9]+]]
+// CHECK: @vtable.1 = {{.*}}, !type ![[TYPE1:[0-9]+]], !vcall_visibility ![[VCALL_VIS0:[0-9]+]]
+// CHECK: @vtable.2 = {{.*}}, !type ![[TYPE2:[0-9]+]], !vcall_visibility ![[VCALL_VIS2:[0-9]+]]
+
+#![crate_type = "lib"]
+
+use std::rc::Rc;
+
+trait T {
+    // CHECK-LABEL: ; <virtual_function_elimination::S as virtual_function_elimination::T>::used
+    fn used(&self) -> i32 {
+        1
+    }
+    // CHECK-LABEL: ; <virtual_function_elimination::S as virtual_function_elimination::T>::used_through_sub_trait
+    fn used_through_sub_trait(&self) -> i32 {
+        3
+    }
+    // CHECK-LABEL: ; <virtual_function_elimination::S as virtual_function_elimination::T>::by_rc
+    fn by_rc(self: Rc<Self>) -> i32 {
+        self.used() + self.used()
+    }
+    // CHECK-LABEL-NOT: {{.*}}::unused
+    fn unused(&self) -> i32 {
+        2
+    }
+    // CHECK-LABEL-NOT: {{.*}}::by_rc_unused
+    fn by_rc_unused(self: Rc<Self>) -> i32 {
+        self.by_rc()
+    }
+}
+
+trait U: T {
+    // CHECK-LABEL: ; <virtual_function_elimination::S as virtual_function_elimination::U>::subtrait_used
+    fn subtrait_used(&self) -> i32 {
+        4
+    }
+    // CHECK-LABEL-NOT: {{.*}}::subtrait_unused
+    fn subtrait_unused(&self) -> i32 {
+        5
+    }
+}
+
+pub trait V {
+    // CHECK-LABEL: ; <virtual_function_elimination::S as virtual_function_elimination::V>::public_function
+    fn public_function(&self) -> i32;
+}
+
+#[derive(Copy, Clone)]
+struct S;
+
+impl T for S {}
+
+impl U for S {}
+
+impl V for S {
+    fn public_function(&self) -> i32 {
+        6
+    }
+}
+
+fn taking_t(t: &dyn T) -> i32 {
+    // CHECK: @llvm.type.checked.load({{.*}}, i32 24, metadata !"[[MANGLED_TYPE0:[0-9a-zA-Z_]+]]")
+    t.used()
+}
+
+fn taking_rc_t(t: Rc<dyn T>) -> i32 {
+    // CHECK: @llvm.type.checked.load({{.*}}, i32 40, metadata !"[[MANGLED_TYPE0:[0-9a-zA-Z_]+]]")
+    t.by_rc()
+}
+
+fn taking_u(u: &dyn U) -> i32 {
+    // CHECK: @llvm.type.checked.load({{.*}}, i32 64, metadata !"[[MANGLED_TYPE1:[0-9a-zA-Z_]+]]")
+    // CHECK: @llvm.type.checked.load({{.*}}, i32 24, metadata !"[[MANGLED_TYPE1:[0-9a-zA-Z_]+]]")
+    // CHECK: @llvm.type.checked.load({{.*}}, i32 32, metadata !"[[MANGLED_TYPE1:[0-9a-zA-Z_]+]]")
+    u.subtrait_used() + u.used() + u.used_through_sub_trait()
+}
+
+pub fn taking_v(v: &dyn V) -> i32 {
+    // CHECK: @llvm.type.checked.load({{.*}}, i32 24, metadata !"NtC[[CRATE_IDENT:[a-zA-Z0-9]{12}]]_28virtual_function_elimination1V")
+    v.public_function()
+}
+
+pub fn main() {
+    let s = S;
+    taking_t(&s);
+    taking_rc_t(Rc::new(s));
+    taking_u(&s);
+    taking_v(&s);
+}
+
+// CHECK: ![[TYPE0]] = !{i64 0, !"[[MANGLED_TYPE0]]"}
+// CHECK: ![[VCALL_VIS0]] = !{i64 2}
+// CHECK: ![[TYPE1]] = !{i64 0, !"[[MANGLED_TYPE1]]"}
+// CHECK: ![[TYPE2]] = !{i64 0, !"NtC[[CRATE_IDENT]]_28virtual_function_elimination1V"}
+// CHECK: ![[VCALL_VIS2]] = !{i64 1}
diff --git a/tests/codegen-llvm/vtable-loads.rs b/tests/codegen-llvm/vtable-loads.rs
new file mode 100644
index 00000000000..aa103ec6f7c
--- /dev/null
+++ b/tests/codegen-llvm/vtable-loads.rs
@@ -0,0 +1,16 @@
+//@ compile-flags: -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @loop_skips_vtable_load
+#[no_mangle]
+pub fn loop_skips_vtable_load(x: &dyn Fn()) {
+    // CHECK: load ptr, ptr %0{{.*}}, !invariant.load
+    // CHECK-NEXT: tail call void %1
+    // CHECK-NOT: load ptr
+    x();
+    for _ in 0..100 {
+        // CHECK: tail call void %1
+        x();
+    }
+}
diff --git a/tests/codegen-llvm/vtable-upcast.rs b/tests/codegen-llvm/vtable-upcast.rs
new file mode 100644
index 00000000000..9e13e8dd68a
--- /dev/null
+++ b/tests/codegen-llvm/vtable-upcast.rs
@@ -0,0 +1,84 @@
+//! This file tests that we correctly generate GEP instructions for vtable upcasting.
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+
+#![crate_type = "lib"]
+
+pub trait Base {
+    fn base(&self);
+}
+
+pub trait A: Base {
+    fn a(&self);
+}
+
+pub trait B: Base {
+    fn b(&self);
+}
+
+pub trait Diamond: A + B {
+    fn diamond(&self);
+}
+
+// CHECK-LABEL: upcast_a_to_base
+#[no_mangle]
+pub fn upcast_a_to_base(x: &dyn A) -> &dyn Base {
+    // Requires no adjustment, since its vtable is extended from `Base`.
+
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: ret
+    x as &dyn Base
+}
+
+// CHECK-LABEL: upcast_b_to_base
+#[no_mangle]
+pub fn upcast_b_to_base(x: &dyn B) -> &dyn Base {
+    // Requires no adjustment, since its vtable is extended from `Base`.
+
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: ret
+    x as &dyn Base
+}
+
+// CHECK-LABEL: upcast_diamond_to_a
+#[no_mangle]
+pub fn upcast_diamond_to_a(x: &dyn Diamond) -> &dyn A {
+    // Requires no adjustment, since its vtable is extended from `A` (as the first supertrait).
+
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: ret
+    x as &dyn A
+}
+
+// CHECK-LABEL: upcast_diamond_to_b
+// CHECK-SAME: (ptr align {{[0-9]+}} [[DATA_PTR:%.+]], ptr align {{[0-9]+}} [[VTABLE_PTR:%.+]])
+#[no_mangle]
+pub fn upcast_diamond_to_b(x: &dyn Diamond) -> &dyn B {
+    // Requires adjustment, since it's a non-first supertrait.
+
+    // CHECK: start:
+    // CHECK-NEXT: [[UPCAST_SLOT_PTR:%.+]] = getelementptr inbounds i8, ptr [[VTABLE_PTR]]
+    // CHECK-NEXT: [[UPCAST_VTABLE_PTR:%.+]] = load ptr, ptr [[UPCAST_SLOT_PTR]]
+    // CHECK-NEXT: [[FAT_PTR_1:%.+]] = insertvalue { ptr, ptr } poison, ptr [[DATA_PTR]], 0
+    // CHECK-NEXT: [[FAT_PTR_2:%.+]] = insertvalue { ptr, ptr } [[FAT_PTR_1]], ptr [[UPCAST_VTABLE_PTR]], 1
+    // CHECK-NEXT: ret { ptr, ptr } [[FAT_PTR_2]]
+    x as &dyn B
+}
+
+// CHECK-LABEL: upcast_diamond_to_b
+#[no_mangle]
+pub fn upcast_diamond_to_base(x: &dyn Diamond) -> &dyn Base {
+    // Requires no adjustment, since `Base` is the first supertrait of `A`,
+    // which is the first supertrait of `Diamond`.
+
+    // CHECK: start:
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: insertvalue
+    // CHECK-NEXT: ret
+    x as &dyn Base
+}
diff --git a/tests/codegen-llvm/wasm_casts_trapping.rs b/tests/codegen-llvm/wasm_casts_trapping.rs
new file mode 100644
index 00000000000..0908acd85fc
--- /dev/null
+++ b/tests/codegen-llvm/wasm_casts_trapping.rs
@@ -0,0 +1,157 @@
+//@ only-wasm32
+//@ compile-flags: -C target-feature=-nontrapping-fptoint
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @cast_f64_i64
+#[no_mangle]
+pub fn cast_f64_i64(a: f64) -> i64 {
+    // CHECK-NOT: fptosi double {{.*}} to i64
+    // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
+    // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i64.f64{{.*}}
+    a as _
+}
+
+// CHECK-LABEL: @cast_f64_i32
+#[no_mangle]
+pub fn cast_f64_i32(a: f64) -> i32 {
+    // CHECK-NOT: fptosi double {{.*}} to i32
+    // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
+    // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i32.f64{{.*}}
+    a as _
+}
+
+// CHECK-LABEL: @cast_f32_i64
+#[no_mangle]
+pub fn cast_f32_i64(a: f32) -> i64 {
+    // CHECK-NOT: fptosi float {{.*}} to i64
+    // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
+    // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i64.f32{{.*}}
+    a as _
+}
+
+// CHECK-LABEL: @cast_f32_i32
+#[no_mangle]
+pub fn cast_f32_i32(a: f32) -> i32 {
+    // CHECK-NOT: fptosi float {{.*}} to i32
+    // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
+    // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i32.f32{{.*}}
+    a as _
+}
+
+// CHECK-LABEL: @cast_f64_u64
+#[no_mangle]
+pub fn cast_f64_u64(a: f64) -> u64 {
+    // CHECK-NOT: fptoui double {{.*}} to i64
+    // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
+    // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i64.f64{{.*}}
+    a as _
+}
+
+// CHECK-LABEL: @cast_f64_u32
+#[no_mangle]
+pub fn cast_f64_u32(a: f64) -> u32 {
+    // CHECK-NOT: fptoui double {{.*}} to i32
+    // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
+    // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i32.f64{{.*}}
+    a as _
+}
+
+// CHECK-LABEL: @cast_f32_u64
+#[no_mangle]
+pub fn cast_f32_u64(a: f32) -> u64 {
+    // CHECK-NOT: fptoui float {{.*}} to i64
+    // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
+    // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i64.f32{{.*}}
+    a as _
+}
+
+// CHECK-LABEL: @cast_f32_u32
+#[no_mangle]
+pub fn cast_f32_u32(a: f32) -> u32 {
+    // CHECK-NOT: fptoui float {{.*}} to i32
+    // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
+    // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i32.f32{{.*}}
+    a as _
+}
+
+// CHECK-LABEL: @cast_f32_u8
+#[no_mangle]
+pub fn cast_f32_u8(a: f32) -> u8 {
+    // CHECK-NOT: fptoui float {{.*}} to i8
+    // CHECK-NOT: select i1 {{.*}}, i8 {{.*}}, i8 {{.*}}
+    // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i8.f32{{.*}}
+    a as _
+}
+
+// CHECK-LABEL: @cast_unchecked_f64_i64
+#[no_mangle]
+pub unsafe fn cast_unchecked_f64_i64(a: f64) -> i64 {
+    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
+    // CHECK-NEXT: ret i64 {{.*}}
+    a.to_int_unchecked()
+}
+
+// CHECK-LABEL: @cast_unchecked_f64_i32
+#[no_mangle]
+pub unsafe fn cast_unchecked_f64_i32(a: f64) -> i32 {
+    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
+    // CHECK-NEXT: ret i32 {{.*}}
+    a.to_int_unchecked()
+}
+
+// CHECK-LABEL: @cast_unchecked_f32_i64
+#[no_mangle]
+pub unsafe fn cast_unchecked_f32_i64(a: f32) -> i64 {
+    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
+    // CHECK-NEXT: ret i64 {{.*}}
+    a.to_int_unchecked()
+}
+
+// CHECK-LABEL: @cast_unchecked_f32_i32
+#[no_mangle]
+pub unsafe fn cast_unchecked_f32_i32(a: f32) -> i32 {
+    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
+    // CHECK-NEXT: ret i32 {{.*}}
+    a.to_int_unchecked()
+}
+
+// CHECK-LABEL: @cast_unchecked_f64_u64
+#[no_mangle]
+pub unsafe fn cast_unchecked_f64_u64(a: f64) -> u64 {
+    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
+    // CHECK-NEXT: ret i64 {{.*}}
+    a.to_int_unchecked()
+}
+
+// CHECK-LABEL: @cast_unchecked_f64_u32
+#[no_mangle]
+pub unsafe fn cast_unchecked_f64_u32(a: f64) -> u32 {
+    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
+    // CHECK-NEXT: ret i32 {{.*}}
+    a.to_int_unchecked()
+}
+
+// CHECK-LABEL: @cast_unchecked_f32_u64
+#[no_mangle]
+pub unsafe fn cast_unchecked_f32_u64(a: f32) -> u64 {
+    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
+    // CHECK-NEXT: ret i64 {{.*}}
+    a.to_int_unchecked()
+}
+
+// CHECK-LABEL: @cast_unchecked_f32_u32
+#[no_mangle]
+pub unsafe fn cast_unchecked_f32_u32(a: f32) -> u32 {
+    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
+    // CHECK-NEXT: ret i32 {{.*}}
+    a.to_int_unchecked()
+}
+
+// CHECK-LABEL: @cast_unchecked_f32_u8
+#[no_mangle]
+pub unsafe fn cast_unchecked_f32_u8(a: f32) -> u8 {
+    // CHECK-NOT: {{.*}} call {{.*}} @llvm.wasm.trunc.{{.*}}
+    // CHECK: fptoui float {{.*}} to i8
+    // CHECK-NEXT: ret i8 {{.*}}
+    a.to_int_unchecked()
+}
diff --git a/tests/codegen-llvm/wasm_exceptions.rs b/tests/codegen-llvm/wasm_exceptions.rs
new file mode 100644
index 00000000000..07b8ae6e9d7
--- /dev/null
+++ b/tests/codegen-llvm/wasm_exceptions.rs
@@ -0,0 +1,59 @@
+//@ only-wasm32
+//@ compile-flags: -C panic=unwind -Z emscripten-wasm-eh
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+extern "C-unwind" {
+    fn may_panic();
+}
+
+extern "C" {
+    fn log_number(number: usize);
+}
+
+struct LogOnDrop;
+
+impl Drop for LogOnDrop {
+    fn drop(&mut self) {
+        unsafe {
+            log_number(0);
+        }
+    }
+}
+
+// CHECK-LABEL: @test_cleanup() {{.*}} @__gxx_wasm_personality_v0
+#[no_mangle]
+pub fn test_cleanup() {
+    let _log_on_drop = LogOnDrop;
+    unsafe {
+        may_panic();
+    }
+
+    // CHECK-NOT: call
+    // CHECK: invoke void @may_panic()
+    // CHECK: %cleanuppad = cleanuppad within none []
+}
+
+// CHECK-LABEL: @test_rtry() {{.*}} @__gxx_wasm_personality_v0
+#[no_mangle]
+pub fn test_rtry() {
+    unsafe {
+        core::intrinsics::catch_unwind(
+            |_| {
+                may_panic();
+            },
+            core::ptr::null_mut(),
+            |data, exception| {
+                log_number(data as usize);
+                log_number(exception as usize);
+            },
+        );
+    }
+
+    // CHECK-NOT: call
+    // CHECK: invoke void @may_panic()
+    // CHECK: {{.*}} = catchswitch within none [label {{.*}}] unwind to caller
+    // CHECK: {{.*}} = catchpad within {{.*}} [ptr null]
+    // CHECK: catchret
+}
diff --git a/tests/codegen-llvm/zip.rs b/tests/codegen-llvm/zip.rs
new file mode 100644
index 00000000000..38ecf7c15c6
--- /dev/null
+++ b/tests/codegen-llvm/zip.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -Cno-prepopulate-passes -Copt-level=3
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @zip_copy
+#[no_mangle]
+pub fn zip_copy(xs: &[u8], ys: &mut [u8]) {
+    // CHECK: memcpy
+    for (x, y) in xs.iter().zip(ys) {
+        *y = *x;
+    }
+}
+
+// CHECK-LABEL: @zip_copy_mapped
+#[no_mangle]
+pub fn zip_copy_mapped(xs: &[u8], ys: &mut [u8]) {
+    // CHECK: memcpy
+    for (x, y) in xs.iter().map(|&x| x).zip(ys) {
+        *y = x;
+    }
+}
diff --git a/tests/codegen-llvm/zst-offset.rs b/tests/codegen-llvm/zst-offset.rs
new file mode 100644
index 00000000000..475394a8815
--- /dev/null
+++ b/tests/codegen-llvm/zst-offset.rs
@@ -0,0 +1,42 @@
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+
+#![crate_type = "lib"]
+#![feature(repr_simd)]
+
+// Hack to get the correct size for the length part in slices
+// CHECK: @helper([[USIZE:i[0-9]+]] %_1)
+#[no_mangle]
+pub fn helper(_: usize) {}
+
+// Check that we correctly generate a GEP for a ZST that is not included in Scalar layout
+// CHECK-LABEL: @scalar_layout
+#[no_mangle]
+pub fn scalar_layout(s: &(u64, ())) {
+    // CHECK: getelementptr inbounds i8, {{.+}}, [[USIZE]] 8
+    let x = &s.1;
+    witness(&x); // keep variable in an alloca
+}
+
+// Check that we correctly generate a GEP for a ZST that is not included in ScalarPair layout
+// CHECK-LABEL: @scalarpair_layout
+#[no_mangle]
+pub fn scalarpair_layout(s: &(u64, u32, ())) {
+    // CHECK: getelementptr inbounds i8, {{.+}}, [[USIZE]] 12
+    let x = &s.2;
+    witness(&x); // keep variable in an alloca
+}
+
+#[repr(simd)]
+pub struct U64x4([u64; 4]);
+
+// Check that we correctly generate a GEP for a ZST that is not included in Vector layout
+// CHECK-LABEL: @vector_layout
+#[no_mangle]
+pub fn vector_layout(s: &(U64x4, ())) {
+    // CHECK: getelementptr inbounds i8, {{.+}}, [[USIZE]] 32
+    let x = &s.1;
+    witness(&x); // keep variable in an alloca
+}
+
+#[inline(never)]
+fn witness(_: &impl Sized) {}
diff --git a/tests/codegen/README.md b/tests/codegen/README.md
deleted file mode 100644
index 8f2daaafcc7..00000000000
--- a/tests/codegen/README.md
+++ /dev/null
@@ -1,24 +0,0 @@
-The files here use the LLVM FileCheck framework, documented at
-<https://llvm.org/docs/CommandGuide/FileCheck.html>.
-
-One extension worth noting is the use of revisions as custom prefixes for
-FileCheck. If your codegen test has different behavior based on the chosen
-target or different compiler flags that you want to exercise, you can use a
-revisions annotation, like so:
-
-```rust
-// revisions: aaa bbb
-// [bbb] compile-flags: --flags-for-bbb
-```
-
-After specifying those variations, you can write different expected, or
-explicitly *unexpected* output by using `<prefix>-SAME:` and `<prefix>-NOT:`,
-like so:
-
-```rust
-// CHECK: expected code
-// aaa-SAME: emitted-only-for-aaa
-// aaa-NOT:                        emitted-only-for-bbb
-// bbb-NOT:  emitted-only-for-aaa
-// bbb-SAME:                       emitted-only-for-bbb
-```
diff --git a/tests/codegen/aarch64-softfloat.rs b/tests/codegen/aarch64-softfloat.rs
deleted file mode 100644
index 4f5366e047f..00000000000
--- a/tests/codegen/aarch64-softfloat.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: --target aarch64-unknown-none-softfloat -Zmerge-functions=disabled
-//@ needs-llvm-components: aarch64
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: i64 @pass_f64_C(i64 {{[^,]*}})
-#[no_mangle]
-extern "C" fn pass_f64_C(x: f64) -> f64 {
-    x
-}
-
-// CHECK: i64 @pass_f32_pair_C(i64 {{[^,]*}})
-#[no_mangle]
-extern "C" fn pass_f32_pair_C(x: (f32, f32)) -> (f32, f32) {
-    x
-}
-
-// CHECK: [2 x i64] @pass_f64_pair_C([2 x i64] {{[^,]*}})
-#[no_mangle]
-extern "C" fn pass_f64_pair_C(x: (f64, f64)) -> (f64, f64) {
-    x
-}
-
-// CHECK: i64 @pass_f64_Rust(i64 {{[^,]*}})
-#[no_mangle]
-fn pass_f64_Rust(x: f64) -> f64 {
-    x
-}
-
-// CHECK: i64 @pass_f32_pair_Rust(i64 {{[^,]*}})
-#[no_mangle]
-fn pass_f32_pair_Rust(x: (f32, f32)) -> (f32, f32) {
-    x
-}
-
-// CHECK: void @pass_f64_pair_Rust(ptr {{.*}}%{{[^ ]+}}, ptr {{.*}}%{{[^ ]+}})
-#[no_mangle]
-fn pass_f64_pair_Rust(x: (f64, f64)) -> (f64, f64) {
-    x
-}
diff --git a/tests/codegen/aarch64-struct-align-128.rs b/tests/codegen/aarch64-struct-align-128.rs
deleted file mode 100644
index ba1d19680f4..00000000000
--- a/tests/codegen/aarch64-struct-align-128.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-// Test that structs aligned to 128 bits are passed with the correct ABI on aarch64.
-
-//@ add-core-stubs
-//@ revisions: linux darwin win
-//@[linux] compile-flags: --target aarch64-unknown-linux-gnu
-//@[darwin] compile-flags: --target aarch64-apple-darwin
-//@[win] compile-flags: --target aarch64-pc-windows-msvc
-//@[linux] needs-llvm-components: aarch64
-//@[darwin] needs-llvm-components: aarch64
-//@[win] needs-llvm-components: aarch64
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// Passed as `[i64 x 2]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
-#[repr(C)]
-pub struct Align8 {
-    pub a: u64,
-    pub b: u64,
-}
-
-// repr(transparent), so same as above.
-#[repr(transparent)]
-pub struct Transparent8 {
-    a: Align8,
-}
-
-// Passed as `[i64 x 2]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
-#[repr(C)]
-pub struct Wrapped8 {
-    a: Align8,
-}
-
-extern "C" {
-    // linux:  declare void @test_8([2 x i64], [2 x i64], [2 x i64])
-    // darwin: declare void @test_8([2 x i64], [2 x i64], [2 x i64])
-    // win:    declare void @test_8([2 x i64], [2 x i64], [2 x i64])
-    fn test_8(a: Align8, b: Transparent8, c: Wrapped8);
-}
-
-// Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
-// EXCEPT on Linux, where there's a special case to use its unadjusted alignment,
-// making it the same as `Align8`, so it's be passed as `[i64 x 2]`.
-#[repr(C)]
-#[repr(align(16))]
-pub struct Align16 {
-    pub a: u64,
-    pub b: u64,
-}
-
-// repr(transparent), so same as above.
-#[repr(transparent)]
-pub struct Transparent16 {
-    a: Align16,
-}
-
-// Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
-// On Linux, the "unadjustedness" doesn't recurse into fields, so this is passed as `i128`.
-#[repr(C)]
-pub struct Wrapped16 {
-    pub a: Align16,
-}
-
-extern "C" {
-    // linux:  declare void @test_16([2 x i64], [2 x i64], i128)
-    // darwin: declare void @test_16(i128, i128, i128)
-    // win:    declare void @test_16(i128, i128, i128)
-    fn test_16(a: Align16, b: Transparent16, c: Wrapped16);
-}
-
-// Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
-#[repr(C)]
-pub struct I128 {
-    pub a: i128,
-}
-
-// repr(transparent), so same as above.
-#[repr(transparent)]
-pub struct TransparentI128 {
-    a: I128,
-}
-
-// Passed as `i128`, since it's an aggregate with size <= 128 bits, align = 128 bits.
-#[repr(C)]
-pub struct WrappedI128 {
-    pub a: I128,
-}
-
-extern "C" {
-    // linux:  declare void @test_i128(i128, i128, i128)
-    // darwin: declare void @test_i128(i128, i128, i128)
-    // win:    declare void @test_i128(i128, i128, i128)
-    fn test_i128(a: I128, b: TransparentI128, c: WrappedI128);
-}
-
-// Passed as `[2 x i64]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
-// Note that the Linux special case does not apply, because packing is not considered "adjustment".
-#[repr(C)]
-#[repr(packed)]
-pub struct Packed {
-    pub a: i128,
-}
-
-// repr(transparent), so same as above.
-#[repr(transparent)]
-pub struct TransparentPacked {
-    a: Packed,
-}
-
-// Passed as `[2 x i64]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
-#[repr(C)]
-pub struct WrappedPacked {
-    pub a: Packed,
-}
-
-extern "C" {
-    // linux:  declare void @test_packed([2 x i64], [2 x i64], [2 x i64])
-    // darwin: declare void @test_packed([2 x i64], [2 x i64], [2 x i64])
-    // win:    declare void @test_packed([2 x i64], [2 x i64], [2 x i64])
-    fn test_packed(a: Packed, b: TransparentPacked, c: WrappedPacked);
-}
-
-pub unsafe fn main(
-    a1: Align8,
-    a2: Transparent8,
-    a3: Wrapped8,
-    b1: Align16,
-    b2: Transparent16,
-    b3: Wrapped16,
-    c1: I128,
-    c2: TransparentI128,
-    c3: WrappedI128,
-    d1: Packed,
-    d2: TransparentPacked,
-    d3: WrappedPacked,
-) {
-    test_8(a1, a2, a3);
-    test_16(b1, b2, b3);
-    test_i128(c1, c2, c3);
-    test_packed(d1, d2, d3);
-}
diff --git a/tests/codegen/abi-efiapi.rs b/tests/codegen/abi-efiapi.rs
deleted file mode 100644
index 1736f0daf0f..00000000000
--- a/tests/codegen/abi-efiapi.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Checks if the correct annotation for the efiapi ABI is passed to llvm.
-
-//@ add-core-stubs
-//@ revisions:x86_64 i686 aarch64 arm riscv
-//@[x86_64] compile-flags: --target x86_64-unknown-uefi
-//@[x86_64] needs-llvm-components: aarch64 arm riscv
-//@[i686] compile-flags: --target i686-unknown-linux-musl
-//@[i686] needs-llvm-components: aarch64 arm riscv
-//@[aarch64] compile-flags: --target aarch64-unknown-none
-//@[aarch64] needs-llvm-components: aarch64 arm riscv
-//@[arm] compile-flags: --target armv7r-none-eabi
-//@[arm] needs-llvm-components: aarch64 arm riscv
-//@[riscv] compile-flags: --target riscv64gc-unknown-none-elf
-//@[riscv] needs-llvm-components: aarch64 arm riscv
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-//x86_64: define win64cc void @has_efiapi
-//i686: define void @has_efiapi
-//aarch64: define dso_local void @has_efiapi
-//arm: define dso_local arm_aapcscc void @has_efiapi
-//riscv: define dso_local void @has_efiapi
-#[no_mangle]
-pub extern "efiapi" fn has_efiapi() {}
diff --git a/tests/codegen/abi-main-signature-16bit-c-int.rs b/tests/codegen/abi-main-signature-16bit-c-int.rs
deleted file mode 100644
index d44b80475e4..00000000000
--- a/tests/codegen/abi-main-signature-16bit-c-int.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Checks the signature of the implicitly generated native main()
-// entry point. It must match C's `int main(int, char **)`.
-
-// This test is for targets with 16bit c_int only.
-//@ revisions: avr msp
-//@[avr] only-avr
-//@[msp] only-msp430
-
-fn main() {}
-
-// CHECK: define i16 @main(i16, i8**)
diff --git a/tests/codegen/abi-main-signature-32bit-c-int.rs b/tests/codegen/abi-main-signature-32bit-c-int.rs
deleted file mode 100644
index ce475adde44..00000000000
--- a/tests/codegen/abi-main-signature-32bit-c-int.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Checks the signature of the implicitly generated native main()
-// entry point. It must match C's `int main(int, char **)`.
-
-// This test is for targets with 32bit c_int only.
-//@ ignore-msp430
-//@ ignore-avr
-//@ ignore-wasi wasi codegens the main symbol differently
-
-fn main() {}
-
-// CHECK: define{{( hidden| noundef)*}} i32 @main(i32{{( %0)?}}, ptr{{( %1)?}})
diff --git a/tests/codegen/abi-repr-ext.rs b/tests/codegen/abi-repr-ext.rs
deleted file mode 100644
index 1da28a94d9d..00000000000
--- a/tests/codegen/abi-repr-ext.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3
-
-//@ revisions:x86_64 i686 aarch64-apple aarch64-windows aarch64-linux arm riscv
-
-//@[x86_64] compile-flags: --target x86_64-unknown-uefi
-//@[x86_64] needs-llvm-components: x86
-//@[i686] compile-flags: --target i686-unknown-linux-musl
-//@[i686] needs-llvm-components: x86
-//@[aarch64-windows] compile-flags: --target aarch64-pc-windows-msvc
-//@[aarch64-windows] needs-llvm-components: aarch64
-//@[aarch64-linux] compile-flags: --target aarch64-unknown-linux-gnu
-//@[aarch64-linux] needs-llvm-components: aarch64
-//@[aarch64-apple] compile-flags: --target aarch64-apple-darwin
-//@[aarch64-apple] needs-llvm-components: aarch64
-//@[arm] compile-flags: --target armv7r-none-eabi
-//@[arm] needs-llvm-components: arm
-//@[riscv] compile-flags: --target riscv64gc-unknown-none-elf
-//@[riscv] needs-llvm-components: riscv
-
-// See bottom of file for a corresponding C source file that is meant to yield
-// equivalent declarations.
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(i8)]
-pub enum Type {
-    Type1 = 0,
-    Type2 = 1,
-}
-
-// To accommodate rust#97800, one might consider writing the below as:
-//
-// `define{{( dso_local)?}} noundef{{( signext)?}} i8 @test()`
-//
-// but based on rust#80556, it seems important to actually check for the
-// presence of the `signext` for those targets where we expect it.
-
-// CHECK: define{{( dso_local)?}} noundef
-// x86_64-SAME:                 signext
-// aarch64-apple-SAME:          signext
-// aarch64-windows-NOT: signext
-// aarch64-linux-NOT:   signext
-// arm-SAME:                    signext
-// riscv-SAME:                  signext
-// CHECK-SAME: i8 @test()
-
-#[no_mangle]
-pub extern "C" fn test() -> Type {
-    Type::Type1
-}
diff --git a/tests/codegen/abi-sysv64.rs b/tests/codegen/abi-sysv64.rs
deleted file mode 100644
index 7ade17f2bae..00000000000
--- a/tests/codegen/abi-sysv64.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Checks if the correct annotation for the sysv64 ABI is passed to
-// llvm. Also checks that the abi-sysv64 feature gate allows usage
-// of the sysv64 abi.
-//
-//@ add-core-stubs
-//@ needs-llvm-components: x86
-//@ compile-flags: -C no-prepopulate-passes --target=x86_64-unknown-linux-gnu -Copt-level=0
-
-#![crate_type = "lib"]
-#![no_core]
-#![feature(abi_x86_interrupt, no_core, lang_items)]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: define x86_64_sysvcc i64 @has_sysv64_abi
-#[no_mangle]
-pub extern "sysv64" fn has_sysv64_abi(a: i64) -> i64 {
-    a
-}
diff --git a/tests/codegen/abi-win64-zst.rs b/tests/codegen/abi-win64-zst.rs
deleted file mode 100644
index e46f9666d42..00000000000
--- a/tests/codegen/abi-win64-zst.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: -Z merge-functions=disabled
-//@ add-core-stubs
-
-//@ revisions: windows-gnu
-//@[windows-gnu] compile-flags: --target x86_64-pc-windows-gnu
-//@[windows-gnu] needs-llvm-components: x86
-
-//@ revisions: windows-msvc
-//@[windows-msvc] compile-flags: --target x86_64-pc-windows-msvc
-//@[windows-msvc] needs-llvm-components: x86
-
-// Also test what happens when using a Windows ABI on Linux.
-//@ revisions: linux
-//@[linux] compile-flags: --target x86_64-unknown-linux-gnu
-//@[linux] needs-llvm-components: x86
-
-#![feature(no_core, rustc_attrs, abi_vectorcall)]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-// Make sure the argument is always passed when explicitly requesting a Windows ABI.
-// Our goal here is to match clang: <https://clang.godbolt.org/z/Wr4jMWq3P>.
-
-// CHECK: define win64cc void @pass_zst_win64(ptr {{[^,]*}})
-#[no_mangle]
-extern "win64" fn pass_zst_win64(_: ()) {}
-
-// CHECK: define x86_vectorcallcc void @pass_zst_vectorcall(ptr {{[^,]*}})
-#[no_mangle]
-extern "vectorcall" fn pass_zst_vectorcall(_: ()) {}
-
-// windows-gnu: define void @pass_zst_fastcall(ptr {{[^,]*}})
-// windows-msvc: define void @pass_zst_fastcall(ptr {{[^,]*}})
-#[no_mangle]
-#[cfg(windows)] // "fastcall" is not valid on 64bit Linux
-extern "fastcall" fn pass_zst_fastcall(_: ()) {}
-
-// The sysv64 ABI ignores ZST.
-
-// CHECK: define x86_64_sysvcc void @pass_zst_sysv64()
-#[no_mangle]
-extern "sysv64" fn pass_zst_sysv64(_: ()) {}
-
-// For `extern "C"` functions, ZST are ignored on Linux put passed on Windows.
-
-// linux: define void @pass_zst_c()
-// windows-msvc: define void @pass_zst_c(ptr {{[^,]*}})
-// windows-gnu: define void @pass_zst_c(ptr {{[^,]*}})
-#[no_mangle]
-extern "C" fn pass_zst_c(_: ()) {}
diff --git a/tests/codegen/abi-x86-interrupt.rs b/tests/codegen/abi-x86-interrupt.rs
deleted file mode 100644
index 9a1ded2c9e3..00000000000
--- a/tests/codegen/abi-x86-interrupt.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Checks if the correct annotation for the x86-interrupt ABI is passed to
-// llvm. Also checks that the abi_x86_interrupt feature gate allows usage
-// of the x86-interrupt abi.
-
-//@ add-core-stubs
-//@ needs-llvm-components: x86
-//@ compile-flags: -C no-prepopulate-passes --target=x86_64-unknown-linux-gnu -Copt-level=0
-
-#![crate_type = "lib"]
-#![no_core]
-#![feature(abi_x86_interrupt, no_core, lang_items)]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: define x86_intrcc void @has_x86_interrupt_abi
-#[no_mangle]
-pub extern "x86-interrupt" fn has_x86_interrupt_abi() {}
diff --git a/tests/codegen/abi-x86-sse.rs b/tests/codegen/abi-x86-sse.rs
deleted file mode 100644
index 68d2acfb527..00000000000
--- a/tests/codegen/abi-x86-sse.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//@ compile-flags: -Z merge-functions=disabled
-
-//@ revisions: x86-64
-//@[x86-64] compile-flags: --target x86_64-unknown-linux-gnu
-//@[x86-64] needs-llvm-components: x86
-
-//@ revisions: x86-32
-//@[x86-32] compile-flags: --target i686-unknown-linux-gnu
-//@[x86-32] needs-llvm-components: x86
-
-//@ revisions: x86-32-nosse
-//@[x86-32-nosse] compile-flags: --target i586-unknown-linux-gnu
-//@[x86-32-nosse] needs-llvm-components: x86
-
-#![feature(no_core, lang_items, rustc_attrs, repr_simd)]
-#![no_core]
-#![crate_type = "lib"]
-
-#[lang = "sized"]
-trait Sized: MetaSized {}
-
-#[lang = "meta_sized"]
-trait MetaSized: PointeeSized {}
-
-#[lang = "pointee_sized"]
-trait PointeeSized {}
-
-#[lang = "copy"]
-trait Copy {}
-
-// Ensure this type is passed without ptr indirection on targets that
-// require SSE2.
-#[repr(simd)]
-pub struct Sse([f32; 4]);
-
-// FIXME: due to #139029 we are passing them all indirectly.
-// x86-64: void @sse_id(ptr{{( [^,]*)?}} sret([16 x i8]){{( .*)?}}, ptr{{( [^,]*)?}})
-// x86-32: void @sse_id(ptr{{( [^,]*)?}} sret([16 x i8]){{( .*)?}}, ptr{{( [^,]*)?}})
-// x86-32-nosse: void @sse_id(ptr{{( [^,]*)?}} sret([16 x i8]){{( .*)?}}, ptr{{( [^,]*)?}})
-#[no_mangle]
-pub fn sse_id(x: Sse) -> Sse {
-    x
-}
diff --git a/tests/codegen/abi-x86_64_sysv.rs b/tests/codegen/abi-x86_64_sysv.rs
deleted file mode 100644
index 09909f994d6..00000000000
--- a/tests/codegen/abi-x86_64_sysv.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//@ only-x86_64
-
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-pub struct S24 {
-    a: i8,
-    b: i8,
-    c: i8,
-}
-
-pub struct S48 {
-    a: i16,
-    b: i16,
-    c: i8,
-}
-
-// CHECK: i24 @struct_24_bits(i24
-#[no_mangle]
-pub extern "sysv64" fn struct_24_bits(a: S24) -> S24 {
-    a
-}
-
-// CHECK: i48 @struct_48_bits(i48
-#[no_mangle]
-pub extern "sysv64" fn struct_48_bits(a: S48) -> S48 {
-    a
-}
diff --git a/tests/codegen/addr-of-mutate.rs b/tests/codegen/addr-of-mutate.rs
deleted file mode 100644
index 14bc4b8ab28..00000000000
--- a/tests/codegen/addr-of-mutate.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ compile-flags: -C opt-level=3 -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-// Test for the absence of `readonly` on the argument when it is mutated via `&raw const`.
-// See <https://github.com/rust-lang/rust/issues/111502>.
-
-// CHECK: i8 @foo(ptr noalias{{( nocapture)?}} noundef align 1{{( captures\(none\))?}} dereferenceable(128) %x)
-#[no_mangle]
-pub fn foo(x: [u8; 128]) -> u8 {
-    let ptr = core::ptr::addr_of!(x).cast_mut();
-    unsafe {
-        (*ptr)[0] = 1;
-    }
-    x[0]
-}
-
-// CHECK: i1 @second(ptr noalias{{( nocapture)?}} noundef align {{[0-9]+}}{{( captures\(none\))?}} dereferenceable({{[0-9]+}}) %a_ptr_and_b)
-#[no_mangle]
-pub unsafe fn second(a_ptr_and_b: (*mut (i32, bool), (i64, bool))) -> bool {
-    let b_bool_ptr = core::ptr::addr_of!(a_ptr_and_b.1.1).cast_mut();
-    (*b_bool_ptr) = true;
-    a_ptr_and_b.1.1
-}
-
-// If going through a deref (and there are no other mutating accesses), then `readonly` is fine.
-// CHECK: i1 @third(ptr noalias{{( nocapture)?}} noundef readonly align {{[0-9]+}}{{( captures\(none\))?}} dereferenceable({{[0-9]+}}) %a_ptr_and_b)
-#[no_mangle]
-pub unsafe fn third(a_ptr_and_b: (*mut (i32, bool), (i64, bool))) -> bool {
-    let b_bool_ptr = core::ptr::addr_of!((*a_ptr_and_b.0).1).cast_mut();
-    (*b_bool_ptr) = true;
-    a_ptr_and_b.1.1
-}
diff --git a/tests/codegen/adjustments.rs b/tests/codegen/adjustments.rs
deleted file mode 100644
index 7f7831def08..00000000000
--- a/tests/codegen/adjustments.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-
-#![crate_type = "lib"]
-
-// Hack to get the correct size for the length part in slices
-// CHECK: @helper([[USIZE:i[0-9]+]] %_1)
-#[no_mangle]
-pub fn helper(_: usize) {}
-
-// CHECK-LABEL: @no_op_slice_adjustment
-#[no_mangle]
-pub fn no_op_slice_adjustment(x: &[u8]) -> &[u8] {
-    // We used to generate an extra alloca and memcpy for the block's trailing expression value, so
-    // check that we copy directly to the return value slot
-    // CHECK: %0 = insertvalue { ptr, [[USIZE]] } poison, ptr %x.0, 0
-    // CHECK: %1 = insertvalue { ptr, [[USIZE]] } %0, [[USIZE]] %x.1, 1
-    // CHECK: ret { ptr, [[USIZE]] } %1
-    { x }
-}
-
-// CHECK-LABEL: @no_op_slice_adjustment2
-#[no_mangle]
-pub fn no_op_slice_adjustment2(x: &[u8]) -> &[u8] {
-    // We used to generate an extra alloca and memcpy for the function's return value, so check
-    // that there's no memcpy (the slice is written to sret_slot element-wise)
-    // CHECK-NOT: call void @llvm.memcpy.
-    no_op_slice_adjustment(x)
-}
diff --git a/tests/codegen/align-byval-alignment-mismatch.rs b/tests/codegen/align-byval-alignment-mismatch.rs
deleted file mode 100644
index c69fc2de9d2..00000000000
--- a/tests/codegen/align-byval-alignment-mismatch.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-// ignore-tidy-linelength
-//@ add-core-stubs
-//@ revisions:i686-linux x86_64-linux
-
-//@ compile-flags: -Cno-prepopulate-passes -Copt-level=1 -Cpanic=abort
-//@[i686-linux] compile-flags: --target i686-unknown-linux-gnu
-//@[i686-linux] needs-llvm-components: x86
-//@[x86_64-linux] compile-flags: --target x86_64-unknown-linux-gnu
-//@[x86_64-linux] needs-llvm-components: x86
-
-// Tests that we correctly copy arguments into allocas when the alignment of the byval argument
-// is different from the alignment of the Rust type.
-
-// For the following test cases:
-// All of the `*_decreases_alignment` functions should codegen to a direct call, since the
-// alignment is already sufficient.
-// All off the `*_increases_alignment` functions should copy the argument to an alloca
-// on i686-unknown-linux-gnu, since the alignment needs to be increased, and should codegen
-// to a direct call on x86_64-unknown-linux-gnu, where byval alignment matches Rust alignment.
-
-#![feature(no_core)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-// This type has align 1 in Rust, but as a byval argument on i686-linux, it will have align 4.
-#[repr(C)]
-#[repr(packed)]
-struct Align1 {
-    x: u128,
-    y: u128,
-    z: u128,
-}
-
-// This type has align 16 in Rust, but as a byval argument on i686-linux, it will have align 4.
-#[repr(C)]
-#[repr(align(16))]
-struct Align16 {
-    x: u128,
-    y: u128,
-    z: u128,
-}
-
-extern "C" {
-    fn extern_c_align1(x: Align1);
-    fn extern_c_align16(x: Align16);
-}
-
-// CHECK-LABEL: @rust_to_c_increases_alignment
-#[no_mangle]
-pub unsafe fn rust_to_c_increases_alignment(x: Align1) {
-    // i686-linux: start:
-    // i686-linux-NEXT: [[ALLOCA:%[0-9a-z]+]] = alloca [48 x i8], align 4
-    // i686-linux-NEXT: call void @llvm.lifetime.start.p0(i64 48, ptr {{.*}}[[ALLOCA]])
-    // i686-linux-NEXT: call void @llvm.memcpy.{{.+}}(ptr {{.*}}align 4 {{.*}}[[ALLOCA]], ptr {{.*}}align 1 {{.*}}%x
-    // i686-linux-NEXT: call void @extern_c_align1({{.+}} [[ALLOCA]])
-    // i686-linux-NEXT: call void @llvm.lifetime.end.p0(i64 48, ptr {{.*}}[[ALLOCA]])
-
-    // x86_64-linux: start:
-    // x86_64-linux-NEXT: call void @extern_c_align1
-    extern_c_align1(x);
-}
-
-// CHECK-LABEL: @rust_to_c_decreases_alignment
-#[no_mangle]
-pub unsafe fn rust_to_c_decreases_alignment(x: Align16) {
-    // CHECK: start:
-    // CHECK-NEXT: call void @extern_c_align16
-    extern_c_align16(x);
-}
-
-extern "Rust" {
-    fn extern_rust_align1(x: Align1);
-    fn extern_rust_align16(x: Align16);
-}
-
-// CHECK-LABEL: @c_to_rust_decreases_alignment
-#[no_mangle]
-pub unsafe extern "C" fn c_to_rust_decreases_alignment(x: Align1) {
-    // CHECK: start:
-    // CHECK-NEXT: call void @extern_rust_align1
-    extern_rust_align1(x);
-}
-
-// CHECK-LABEL: @c_to_rust_increases_alignment
-#[no_mangle]
-pub unsafe extern "C" fn c_to_rust_increases_alignment(x: Align16) {
-    // i686-linux: start:
-    // i686-linux-NEXT: [[ALLOCA:%[0-9a-z]+]] = alloca [48 x i8], align 16
-    // i686-linux-NEXT: call void @llvm.memcpy.{{.+}}(ptr {{.*}}align 16 {{.*}}[[ALLOCA]], ptr {{.*}}align 4 {{.*}}%0
-    // i686-linux-NEXT: call void @extern_rust_align16({{.+}} [[ALLOCA]])
-
-    // x86_64-linux: start:
-    // x86_64-linux-NEXT: call void @extern_rust_align16
-    extern_rust_align16(x);
-}
-
-extern "Rust" {
-    fn extern_rust_ref_align1(x: &Align1);
-    fn extern_rust_ref_align16(x: &Align16);
-}
-
-// CHECK-LABEL: @c_to_rust_ref_decreases_alignment
-#[no_mangle]
-pub unsafe extern "C" fn c_to_rust_ref_decreases_alignment(x: Align1) {
-    // CHECK: start:
-    // CHECK-NEXT: call void @extern_rust_ref_align1
-    extern_rust_ref_align1(&x);
-}
-
-// CHECK-LABEL: @c_to_rust_ref_increases_alignment
-#[no_mangle]
-pub unsafe extern "C" fn c_to_rust_ref_increases_alignment(x: Align16) {
-    // i686-linux: start:
-    // i686-linux-NEXT: [[ALLOCA:%[0-9a-z]+]] = alloca [48 x i8], align 16
-    // i686-linux-NEXT: call void @llvm.memcpy.{{.+}}(ptr {{.*}}align 16 {{.*}}[[ALLOCA]], ptr {{.*}}align 4 {{.*}}%0
-    // i686-linux-NEXT: call void @extern_rust_ref_align16({{.+}} [[ALLOCA]])
-
-    // x86_64-linux: start:
-    // x86_64-linux-NEXT: call void @extern_rust_ref_align16
-    extern_rust_ref_align16(&x);
-}
diff --git a/tests/codegen/align-byval-vector.rs b/tests/codegen/align-byval-vector.rs
deleted file mode 100644
index c33b41a7bbe..00000000000
--- a/tests/codegen/align-byval-vector.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//@ add-core-stubs
-//@ revisions:x86-linux x86-darwin
-
-//@[x86-linux] compile-flags: --target i686-unknown-linux-gnu
-//@[x86-linux] needs-llvm-components: x86
-//@[x86-darwin] compile-flags: --target i686-apple-darwin
-//@[x86-darwin] needs-llvm-components: x86
-
-// Tests that aggregates containing vector types get their alignment increased to 16 on Darwin.
-
-#![feature(no_core, repr_simd, simd_ffi)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-#![allow(non_camel_case_types)]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(simd)]
-pub struct i32x4([i32; 4]);
-
-#[repr(C)]
-pub struct Foo {
-    a: i32x4,
-    b: i8,
-}
-
-// This tests that we recursively check for vector types, not just at the top level.
-#[repr(C)]
-pub struct DoubleFoo {
-    one: Foo,
-    two: Foo,
-}
-
-extern "C" {
-    // x86-linux: declare void @f({{.*}}byval([32 x i8]) align 4{{.*}})
-    // x86-darwin: declare void @f({{.*}}byval([32 x i8]) align 16{{.*}})
-    fn f(foo: Foo);
-
-    // x86-linux: declare void @g({{.*}}byval([64 x i8]) align 4{{.*}})
-    // x86-darwin: declare void @g({{.*}}byval([64 x i8]) align 16{{.*}})
-    fn g(foo: DoubleFoo);
-}
-
-pub fn main() {
-    unsafe { f(Foo { a: i32x4([1, 2, 3, 4]), b: 0 }) }
-
-    unsafe {
-        g(DoubleFoo {
-            one: Foo { a: i32x4([1, 2, 3, 4]), b: 0 },
-            two: Foo { a: i32x4([1, 2, 3, 4]), b: 0 },
-        })
-    }
-}
diff --git a/tests/codegen/align-byval.rs b/tests/codegen/align-byval.rs
deleted file mode 100644
index 75dabd74a79..00000000000
--- a/tests/codegen/align-byval.rs
+++ /dev/null
@@ -1,315 +0,0 @@
-// ignore-tidy-linelength
-//@ add-core-stubs
-//@ revisions:m68k x86_64-linux x86_64-windows i686-linux i686-windows
-
-//@[m68k] compile-flags: --target m68k-unknown-linux-gnu
-//@[m68k] needs-llvm-components: m68k
-//@[x86_64-linux] compile-flags: --target x86_64-unknown-linux-gnu
-//@[x86_64-linux] needs-llvm-components: x86
-//@[x86_64-windows] compile-flags: --target x86_64-pc-windows-msvc
-//@[x86_64-windows] needs-llvm-components: x86
-//@[i686-linux] compile-flags: --target i686-unknown-linux-gnu
-//@[i686-linux] needs-llvm-components: x86
-//@[i686-windows] compile-flags: --target i686-pc-windows-msvc
-//@[i686-windows] needs-llvm-components: x86
-
-// Tests that `byval` alignment is properly specified (#80127).
-// The only targets that use `byval` are m68k, x86-64, and x86.
-// Note also that Windows mandates a by-ref ABI here, so it does not use byval.
-
-#![feature(no_core)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// This struct can be represented as a pair, so it exercises the OperandValue::Pair
-// codepath in `codegen_argument`.
-#[repr(C)]
-pub struct NaturalAlign1 {
-    a: i8,
-    b: i8,
-}
-
-// This struct cannot be represented as an immediate, so it exercises the OperandValue::Ref
-// codepath in `codegen_argument`.
-#[repr(C)]
-pub struct NaturalAlign2 {
-    a: [i16; 16],
-    b: i16,
-}
-
-#[repr(C)]
-#[repr(align(4))]
-pub struct ForceAlign4 {
-    a: [i8; 16],
-    b: i8,
-}
-
-// On i686-windows, this is passed on stack using `byval`
-#[repr(C)]
-pub struct NaturalAlign8 {
-    a: i64,
-    b: i64,
-    c: i64,
-}
-
-// On i686-windows, this is passed by reference (because alignment is >4 and requested/forced),
-// even though it has the exact same layout as `NaturalAlign8`!
-#[repr(C)]
-#[repr(align(8))]
-pub struct ForceAlign8 {
-    a: i64,
-    b: i64,
-    c: i64,
-}
-
-// On i686-windows, this is passed on stack, because requested alignment is <=4.
-#[repr(C)]
-#[repr(align(4))]
-pub struct LowerFA8 {
-    a: i64,
-    b: i64,
-    c: i64,
-}
-
-// On i686-windows, this is passed by reference, because it contains a field with
-// requested/forced alignment.
-#[repr(C)]
-pub struct WrappedFA8 {
-    a: ForceAlign8,
-}
-
-// On i686-windows, this has the same ABI as ForceAlign8, i.e. passed by reference.
-#[repr(transparent)]
-pub struct TransparentFA8 {
-    _0: (),
-    a: ForceAlign8,
-}
-
-#[repr(C)]
-#[repr(align(16))]
-pub struct ForceAlign16 {
-    a: [i32; 16],
-    b: i8,
-}
-
-// CHECK-LABEL: @call_na1
-#[no_mangle]
-pub unsafe fn call_na1(x: NaturalAlign1) {
-    // CHECK: start:
-
-    // m68k: [[ALLOCA:%[a-z0-9+]]] = alloca [2 x i8], align 1
-    // m68k: call void @natural_align_1({{.*}}byval([2 x i8]) align 1{{.*}} [[ALLOCA]])
-
-    // x86_64-linux: call void @natural_align_1(i16
-
-    // x86_64-windows: call void @natural_align_1(i16
-
-    // i686-linux: [[ALLOCA:%[a-z0-9+]]] = alloca [2 x i8], align 4
-    // i686-linux: call void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}} [[ALLOCA]])
-
-    // i686-windows: [[ALLOCA:%[a-z0-9+]]] = alloca [2 x i8], align 4
-    // i686-windows: call void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}} [[ALLOCA]])
-    natural_align_1(x);
-}
-
-// CHECK-LABEL: @call_na2
-#[no_mangle]
-pub unsafe fn call_na2(x: NaturalAlign2) {
-    // CHECK: start:
-
-    // m68k-NEXT: call void @natural_align_2
-    // x86_64-linux-NEXT: call void @natural_align_2
-    // x86_64-windows-NEXT: call void @natural_align_2
-
-    // i686-linux: [[ALLOCA:%[0-9]+]] = alloca [34 x i8], align 4
-    // i686-linux: call void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}} [[ALLOCA]])
-
-    // i686-windows: [[ALLOCA:%[0-9]+]] = alloca [34 x i8], align 4
-    // i686-windows: call void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}} [[ALLOCA]])
-    natural_align_2(x);
-}
-
-// CHECK-LABEL: @call_fa4
-#[no_mangle]
-pub unsafe fn call_fa4(x: ForceAlign4) {
-    // CHECK: start:
-    // CHECK-NEXT: call void @force_align_4
-    force_align_4(x);
-}
-
-// CHECK-LABEL: @call_na8
-#[no_mangle]
-pub unsafe fn call_na8(x: NaturalAlign8) {
-    // CHECK: start:
-    // CHECK-NEXT: call void @natural_align_8
-    natural_align_8(x);
-}
-
-// CHECK-LABEL: @call_fa8
-#[no_mangle]
-pub unsafe fn call_fa8(x: ForceAlign8) {
-    // CHECK: start:
-    // CHECK-NEXT: call void @force_align_8
-    force_align_8(x);
-}
-
-// CHECK-LABEL: @call_lfa8
-#[no_mangle]
-pub unsafe fn call_lfa8(x: LowerFA8) {
-    // CHECK: start:
-    // CHECK-NEXT: call void @lower_fa8
-    lower_fa8(x);
-}
-
-// CHECK-LABEL: @call_wfa8
-#[no_mangle]
-pub unsafe fn call_wfa8(x: WrappedFA8) {
-    // CHECK: start:
-    // CHECK-NEXT: call void @wrapped_fa8
-    wrapped_fa8(x);
-}
-
-// CHECK-LABEL: @call_tfa8
-#[no_mangle]
-pub unsafe fn call_tfa8(x: TransparentFA8) {
-    // CHECK: start:
-    // CHECK-NEXT: call void @transparent_fa8
-    transparent_fa8(x);
-}
-
-// CHECK-LABEL: @call_fa16
-#[no_mangle]
-pub unsafe fn call_fa16(x: ForceAlign16) {
-    // CHECK: start:
-    // CHECK-NEXT: call void @force_align_16
-    force_align_16(x);
-}
-
-extern "C" {
-    // m68k: declare void @natural_align_1({{.*}}byval([2 x i8]) align 1{{.*}})
-
-    // x86_64-linux: declare void @natural_align_1(i16)
-
-    // x86_64-windows: declare void @natural_align_1(i16)
-
-    // i686-linux: declare void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}})
-
-    // i686-windows: declare void @natural_align_1({{.*}}byval([2 x i8]) align 4{{.*}})
-    fn natural_align_1(x: NaturalAlign1);
-
-    // m68k: declare void @natural_align_2({{.*}}byval([34 x i8]) align 2{{.*}})
-
-    // x86_64-linux: declare void @natural_align_2({{.*}}byval([34 x i8]) align 2{{.*}})
-
-    // x86_64-windows: declare void @natural_align_2(
-    // x86_64-windows-NOT: byval
-    // x86_64-windows-SAME: align 2{{.*}})
-
-    // i686-linux: declare void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}})
-
-    // i686-windows: declare void @natural_align_2({{.*}}byval([34 x i8]) align 4{{.*}})
-    fn natural_align_2(x: NaturalAlign2);
-
-    // m68k: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
-
-    // x86_64-linux: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
-
-    // x86_64-windows: declare void @force_align_4(
-    // x86_64-windows-NOT: byval
-    // x86_64-windows-SAME: align 4{{.*}})
-
-    // i686-linux: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
-
-    // i686-windows: declare void @force_align_4({{.*}}byval([20 x i8]) align 4{{.*}})
-    fn force_align_4(x: ForceAlign4);
-
-    // m68k: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
-
-    // x86_64-linux: declare void @natural_align_8({{.*}}byval([24 x i8]) align 8{{.*}})
-
-    // x86_64-windows: declare void @natural_align_8(
-    // x86_64-windows-NOT: byval
-    // x86_64-windows-SAME: align 8{{.*}})
-
-    // i686-linux: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
-
-    // i686-windows: declare void @natural_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
-    fn natural_align_8(x: NaturalAlign8);
-
-    // m68k: declare void @force_align_8({{.*}}byval([24 x i8]) align 8{{.*}})
-
-    // x86_64-linux: declare void @force_align_8({{.*}}byval([24 x i8]) align 8{{.*}})
-
-    // x86_64-windows: declare void @force_align_8(
-    // x86_64-windows-NOT: byval
-    // x86_64-windows-SAME: align 8{{.*}})
-
-    // i686-linux: declare void @force_align_8({{.*}}byval([24 x i8]) align 4{{.*}})
-
-    // i686-windows: declare void @force_align_8(
-    // i686-windows-NOT: byval
-    // i686-windows-SAME: align 8{{.*}})
-    fn force_align_8(x: ForceAlign8);
-
-    // m68k: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
-
-    // x86_64-linux: declare void @lower_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
-
-    // x86_64-windows: declare void @lower_fa8(
-    // x86_64-windows-NOT: byval
-    // x86_64-windows-SAME: align 8{{.*}})
-
-    // i686-linux: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
-
-    // i686-windows: declare void @lower_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
-    fn lower_fa8(x: LowerFA8);
-
-    // m68k: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
-
-    // x86_64-linux: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
-
-    // x86_64-windows: declare void @wrapped_fa8(
-    // x86_64-windows-NOT: byval
-    // x86_64-windows-SAME: align 8{{.*}})
-
-    // i686-linux: declare void @wrapped_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
-
-    // i686-windows: declare void @wrapped_fa8(
-    // i686-windows-NOT: byval
-    // i686-windows-SAME: align 8{{.*}})
-    fn wrapped_fa8(x: WrappedFA8);
-
-    // m68k: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
-
-    // x86_64-linux: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 8{{.*}})
-
-    // x86_64-windows: declare void @transparent_fa8(
-    // x86_64-windows-NOT: byval
-    // x86_64-windows-SAME: align 8{{.*}})
-
-    // i686-linux: declare void @transparent_fa8({{.*}}byval([24 x i8]) align 4{{.*}})
-
-    // i686-windows: declare void @transparent_fa8(
-    // i686-windows-NOT: byval
-    // i686-windows-SAME: align 8{{.*}})
-    fn transparent_fa8(x: TransparentFA8);
-
-    // m68k: declare void @force_align_16({{.*}}byval([80 x i8]) align 16{{.*}})
-
-    // x86_64-linux: declare void @force_align_16({{.*}}byval([80 x i8]) align 16{{.*}})
-
-    // x86_64-windows: declare void @force_align_16(
-    // x86_64-windows-NOT: byval
-    // x86_64-windows-SAME: align 16{{.*}})
-
-    // i686-linux: declare void @force_align_16({{.*}}byval([80 x i8]) align 4{{.*}})
-
-    // i686-windows: declare void @force_align_16(
-    // i686-windows-NOT: byval
-    // i686-windows-SAME: align 16{{.*}})
-    fn force_align_16(x: ForceAlign16);
-}
diff --git a/tests/codegen/align-enum.rs b/tests/codegen/align-enum.rs
deleted file mode 100644
index e8dd95d3afb..00000000000
--- a/tests/codegen/align-enum.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Z mir-opt-level=0
-//
-
-#![crate_type = "lib"]
-
-#[repr(align(64))]
-pub enum Align64 {
-    A(u32),
-    B(u32),
-}
-
-pub struct Nested64 {
-    a: u8,
-    b: Align64,
-    c: u16,
-}
-
-// CHECK-LABEL: @align64
-#[no_mangle]
-pub fn align64(a: u32) -> Align64 {
-    // CHECK: %a64 = alloca [64 x i8], align 64
-    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 64 %{{.*}}, ptr align 64 %{{.*}}, i{{[0-9]+}} 64, i1 false)
-    let a64 = Align64::A(a);
-    a64
-}
-
-// CHECK-LABEL: @nested64
-#[no_mangle]
-pub fn nested64(a: u8, b: u32, c: u16) -> Nested64 {
-    // CHECK: %n64 = alloca [128 x i8], align 64
-    let n64 = Nested64 { a, b: Align64::B(b), c };
-    n64
-}
diff --git a/tests/codegen/align-fn.rs b/tests/codegen/align-fn.rs
deleted file mode 100644
index cbc24e2ae2e..00000000000
--- a/tests/codegen/align-fn.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Z mir-opt-level=0 -Clink-dead-code
-//@ edition: 2024
-//@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
-
-#![crate_type = "lib"]
-// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
-#![feature(rustc_attrs)]
-#![feature(fn_align)]
-
-// CHECK: align 16
-#[unsafe(no_mangle)]
-#[rustc_align(16)]
-pub fn fn_align() {}
-
-pub struct A;
-
-impl A {
-    // CHECK: align 16
-    #[unsafe(no_mangle)]
-    #[rustc_align(16)]
-    pub fn method_align(self) {}
-
-    // CHECK: align 16
-    #[unsafe(no_mangle)]
-    #[rustc_align(16)]
-    pub fn associated_fn() {}
-}
-
-trait T: Sized {
-    fn trait_fn() {}
-
-    fn trait_method(self) {}
-
-    #[rustc_align(8)]
-    fn trait_method_inherit_low(self);
-
-    #[rustc_align(32)]
-    fn trait_method_inherit_high(self);
-
-    #[rustc_align(32)]
-    fn trait_method_inherit_default(self) {}
-
-    #[rustc_align(4)]
-    #[rustc_align(128)]
-    #[rustc_align(8)]
-    fn inherit_highest(self) {}
-}
-
-impl T for A {
-    // CHECK-LABEL: trait_fn
-    // CHECK-SAME: align 16
-    #[unsafe(no_mangle)]
-    #[rustc_align(16)]
-    fn trait_fn() {}
-
-    // CHECK-LABEL: trait_method
-    // CHECK-SAME: align 16
-    #[unsafe(no_mangle)]
-    #[rustc_align(16)]
-    fn trait_method(self) {}
-
-    // The prototype's align is ignored because the align here is higher.
-    // CHECK-LABEL: trait_method_inherit_low
-    // CHECK-SAME: align 16
-    #[unsafe(no_mangle)]
-    #[rustc_align(16)]
-    fn trait_method_inherit_low(self) {}
-
-    // The prototype's align is used because it is higher.
-    // CHECK-LABEL: trait_method_inherit_high
-    // CHECK-SAME: align 32
-    #[unsafe(no_mangle)]
-    #[rustc_align(16)]
-    fn trait_method_inherit_high(self) {}
-
-    // The prototype's align inherited.
-    // CHECK-LABEL: trait_method_inherit_default
-    // CHECK-SAME: align 32
-    #[unsafe(no_mangle)]
-    fn trait_method_inherit_default(self) {}
-
-    // The prototype's highest align inherited.
-    // CHECK-LABEL: inherit_highest
-    // CHECK-SAME: align 128
-    #[unsafe(no_mangle)]
-    #[rustc_align(32)]
-    #[rustc_align(64)]
-    fn inherit_highest(self) {}
-}
-
-trait HasDefaultImpl: Sized {
-    // CHECK-LABEL: inherit_from_default_method
-    // CHECK-LABEL: inherit_from_default_method
-    // CHECK-SAME: align 32
-    #[rustc_align(32)]
-    fn inherit_from_default_method(self) {}
-}
-
-pub struct InstantiateDefaultMethods;
-
-impl HasDefaultImpl for InstantiateDefaultMethods {}
-
-// CHECK-LABEL: align_specified_twice_1
-// CHECK-SAME: align 64
-#[unsafe(no_mangle)]
-#[rustc_align(32)]
-#[rustc_align(64)]
-pub fn align_specified_twice_1() {}
-
-// CHECK-LABEL: align_specified_twice_2
-// CHECK-SAME: align 128
-#[unsafe(no_mangle)]
-#[rustc_align(128)]
-#[rustc_align(32)]
-pub fn align_specified_twice_2() {}
-
-// CHECK-LABEL: align_specified_twice_3
-// CHECK-SAME: align 256
-#[unsafe(no_mangle)]
-#[rustc_align(32)]
-#[rustc_align(256)]
-pub fn align_specified_twice_3() {}
-
-const _: () = {
-    // CHECK-LABEL: align_unmangled
-    // CHECK-SAME: align 256
-    #[unsafe(no_mangle)]
-    #[rustc_align(32)]
-    #[rustc_align(256)]
-    extern "C" fn align_unmangled() {}
-};
-
-unsafe extern "C" {
-    #[rustc_align(256)]
-    fn align_unmangled();
-}
-
-// FIXME also check `gen` et al
-// CHECK-LABEL: async_align
-// CHECK-SAME: align 64
-#[unsafe(no_mangle)]
-#[rustc_align(64)]
-pub async fn async_align() {}
diff --git a/tests/codegen/align-offset.rs b/tests/codegen/align-offset.rs
deleted file mode 100644
index 21062cc0a91..00000000000
--- a/tests/codegen/align-offset.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @align8
-#[no_mangle]
-pub fn align8(p: *const u8) -> bool {
-    // CHECK: ret i1 true
-    p.align_offset(8) < 8
-}
-
-#[repr(align(4))]
-pub struct Align4([u8; 4]);
-
-// CHECK-LABEL: @align_to4
-#[no_mangle]
-pub fn align_to4(x: &[u8]) -> bool {
-    // CHECK: ret i1 true
-    let (prefix, _middle, suffix) = unsafe { x.align_to::<Align4>() };
-    prefix.len() < 4 && suffix.len() < 4
-}
-
-// CHECK-LABEL: @align_offset_byte_ptr(ptr{{.+}}%ptr)
-#[no_mangle]
-pub fn align_offset_byte_ptr(ptr: *const u8) -> usize {
-    // CHECK: %[[ADDR:.+]] = ptrtoint ptr %ptr to [[USIZE:i[0-9]+]]
-    // CHECK: %[[UP:.+]] = add [[USIZE]] %[[ADDR]], 31
-    // CHECK: %[[ALIGNED:.+]] = and [[USIZE]] %[[UP]], -32
-    // CHECK: %[[OFFSET:.+]] = sub [[USIZE]] %[[ALIGNED]], %[[ADDR]]
-
-    // Since we're offsetting a byte pointer, there's no further fixups
-    // CHECK-NOT: shr
-    // CHECK-NOT: div
-    // CHECK-NOT: select
-
-    // CHECK: ret [[USIZE]] %[[OFFSET]]
-    ptr.align_offset(32)
-}
-
-// CHECK-LABEL: @align_offset_word_slice(ptr{{.+}}align 4{{.+}}%slice.0
-#[no_mangle]
-pub fn align_offset_word_slice(slice: &[Align4]) -> usize {
-    // CHECK: %[[ADDR:.+]] = ptrtoint ptr %slice.0 to [[USIZE]]
-    // CHECK: %[[UP:.+]] = add [[USIZE]] %[[ADDR]], 31
-    // CHECK: %[[ALIGNED:.+]] = and [[USIZE]] %[[UP]], -32
-    // CHECK: %[[BOFFSET:.+]] = sub [[USIZE]] %[[ALIGNED]], %[[ADDR]]
-    // CHECK: %[[OFFSET:.+]] = lshr exact [[USIZE]] %[[BOFFSET]], 2
-
-    // Slices are known to be aligned, so we don't need the "maybe -1" path
-    // CHECK-NOT: select
-
-    // CHECK: ret [[USIZE]] %[[OFFSET]]
-    slice.as_ptr().align_offset(32)
-}
-
-// CHECK-LABEL: @align_offset_word_ptr(ptr{{.+}}%ptr
-#[no_mangle]
-pub fn align_offset_word_ptr(ptr: *const Align4) -> usize {
-    // CHECK: %[[ADDR:.+]] = ptrtoint ptr %ptr to [[USIZE]]
-    // CHECK: %[[UP:.+]] = add [[USIZE]] %[[ADDR]], 31
-    // CHECK: %[[ALIGNED:.+]] = and [[USIZE]] %[[UP]], -32
-    // CHECK: %[[BOFFSET:.+]] = sub [[USIZE]] %[[ALIGNED]], %[[ADDR]]
-
-    // While we can always get a *byte* offset that will work, if the original
-    // pointer is unaligned it might be impossible to return an *element* offset
-    // that will make it aligned. We want it to be a `select`, not a `br`, so
-    // that the assembly will be branchless.
-    // CHECK: %[[LOW:.+]] = and [[USIZE]] %[[ADDR]], 3
-    // CHECK: %[[ORIGINAL_ALIGNED:.+]] = icmp eq [[USIZE]] %[[LOW]], 0
-    // CHECK: %[[OFFSET:.+]] = lshr exact [[USIZE]] %[[BOFFSET]], 2
-    // CHECK: %[[R:.+]] = select i1 %[[ORIGINAL_ALIGNED]], [[USIZE]] %[[OFFSET]], [[USIZE]] -1
-
-    // CHECK: ret [[USIZE]] %[[R]]
-    ptr.align_offset(32)
-}
diff --git a/tests/codegen/align-struct.rs b/tests/codegen/align-struct.rs
deleted file mode 100644
index d4cc65e9158..00000000000
--- a/tests/codegen/align-struct.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Z mir-opt-level=0
-// 32bit MSVC does not align things properly so we suppress high alignment annotations (#112480)
-//@ ignore-i686-pc-windows-msvc
-//@ ignore-i686-pc-windows-gnu
-
-#![crate_type = "lib"]
-
-#[repr(align(64))]
-pub struct Align64(i32);
-
-pub struct Nested64 {
-    a: Align64,
-    b: i32,
-    c: i32,
-    d: i8,
-}
-
-// This has the extra field in B to ensure it's not ScalarPair,
-// and thus that the test actually emits it via memory, not `insertvalue`.
-pub enum Enum4 {
-    A(i32),
-    B(i32, i32),
-}
-
-pub enum Enum64 {
-    A(Align64),
-    B(i32),
-}
-
-// CHECK-LABEL: @align64
-#[no_mangle]
-pub fn align64(i: i32) -> Align64 {
-    // CHECK: %a64 = alloca [64 x i8], align 64
-    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 64 %{{.*}}, ptr align 64 %{{.*}}, i{{[0-9]+}} 64, i1 false)
-    let a64 = Align64(i);
-    a64
-}
-
-// For issue 54028: make sure that we are specifying the correct alignment for fields of aligned
-// structs
-// CHECK-LABEL: @align64_load
-#[no_mangle]
-pub fn align64_load(a: Align64) -> i32 {
-    // CHECK: {{%.*}} = load i32, ptr {{%.*}}, align 64
-    a.0
-}
-
-// CHECK-LABEL: @nested64
-#[no_mangle]
-pub fn nested64(a: Align64, b: i32, c: i32, d: i8) -> Nested64 {
-    // CHECK: %n64 = alloca [128 x i8], align 64
-    let n64 = Nested64 { a, b, c, d };
-    n64
-}
-
-// CHECK-LABEL: @enum4
-#[no_mangle]
-pub fn enum4(a: i32) -> Enum4 {
-    // CHECK: %e4 = alloca [12 x i8], align 4
-    let e4 = Enum4::A(a);
-    e4
-}
-
-// CHECK-LABEL: @enum64
-#[no_mangle]
-pub fn enum64(a: Align64) -> Enum64 {
-    // CHECK: %e64 = alloca [128 x i8], align 64
-    let e64 = Enum64::A(a);
-    e64
-}
diff --git a/tests/codegen/alloc-optimisation.rs b/tests/codegen/alloc-optimisation.rs
deleted file mode 100644
index 3735860d510..00000000000
--- a/tests/codegen/alloc-optimisation.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn alloc_test(data: u32) {
-    // CHECK-LABEL: @alloc_test
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ; call __rustc::__rust_no_alloc_shim_is_unstable_v2
-    // CHECK-NEXT: tail call void @_R{{.+}}__rust_no_alloc_shim_is_unstable_v2()
-    // CHECK-NEXT: ret void
-    let x = Box::new(data);
-    drop(x);
-}
diff --git a/tests/codegen/amdgpu-addrspacecast.rs b/tests/codegen/amdgpu-addrspacecast.rs
deleted file mode 100644
index 7fe630a7efa..00000000000
--- a/tests/codegen/amdgpu-addrspacecast.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Check that pointers are casted to addrspace(0) before they are used
-
-//@ compile-flags: --crate-type=rlib --target=amdgcn-amd-amdhsa -Ctarget-cpu=gfx900
-//@ needs-llvm-components: amdgpu
-//@ add-core-stubs
-#![feature(no_core)]
-#![no_core]
-
-extern crate minicore;
-
-// CHECK-LABEL: @ref_of_local
-// CHECK: [[alloca:%[0-9]]] = alloca
-// CHECK: %i = addrspacecast ptr addrspace(5) [[alloca]] to ptr
-#[no_mangle]
-pub fn ref_of_local(f: fn(&i32)) {
-    let i = 0;
-    f(&i);
-}
diff --git a/tests/codegen/array-clone.rs b/tests/codegen/array-clone.rs
deleted file mode 100644
index 35445174684..00000000000
--- a/tests/codegen/array-clone.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @array_clone
-#[no_mangle]
-pub fn array_clone(a: &[u8; 2]) -> [u8; 2] {
-    // CHECK-NOT: getelementptr
-    // CHECK-NOT: load i8
-    // CHECK-NOT: zext
-    // CHECK-NOT: shl
-    // CHECK: load i16
-    // CHECK-NEXT: ret i16
-    a.clone()
-}
diff --git a/tests/codegen/array-cmp.rs b/tests/codegen/array-cmp.rs
deleted file mode 100644
index 0d337655401..00000000000
--- a/tests/codegen/array-cmp.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Ensure the asm for array comparisons is properly optimized.
-
-//@ compile-flags: -C opt-level=2
-//@ needs-deterministic-layouts (checks depend on tuple layout)
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @compare
-// CHECK: start:
-// CHECK-NEXT: ret i1 true
-#[no_mangle]
-pub fn compare() -> bool {
-    let bytes = 12.5f32.to_ne_bytes();
-    bytes
-        == if cfg!(target_endian = "big") {
-            [0x41, 0x48, 0x00, 0x00]
-        } else {
-            [0x00, 0x00, 0x48, 0x41]
-        }
-}
-
-// CHECK-LABEL: @array_of_tuple_le
-#[no_mangle]
-pub fn array_of_tuple_le(a: &[(i16, u16); 2], b: &[(i16, u16); 2]) -> bool {
-    // Ensure that, after all the optimizations have run, the happy path just checks
-    // `eq` on each corresponding pair and moves onto the next one if it is.
-    // Then there's a dedup'd comparison for the place that's different.
-    // (As opposed to, say, running a full `[su]cmp` as part of checking equality.)
-
-    // This is written quite specifically because different library code was triggering
-    // <https://github.com/llvm/llvm-project/issues/132678> along the way, so this
-    // has enough checks to make sure that's not happening. It doesn't need to be
-    // *exactly* this IR, but be careful if you ever need to update these checks.
-
-    // CHECK: start:
-    // CHECK: %[[A00:.+]] = load i16, ptr %a
-    // CHECK: %[[B00:.+]] = load i16, ptr %b
-    // CHECK-NOT: cmp
-    // 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]]
-    // CHECK: %[[B10:.+]] = load i16, ptr %[[PB10]]
-    // CHECK-NOT: cmp
-    // CHECK: %[[EQ10:.+]] = icmp eq i16 %[[A10]], %[[B10]]
-    // CHECK-NEXT: br i1 %[[EQ10]], label %[[L11:.+]], label %[[EXIT_S]]
-
-    // CHECK: [[L11]]:
-    // CHECK: %[[PA11:.+]] = getelementptr{{.+}}i8, ptr %a, {{i32|i64}} 6
-    // CHECK: %[[PB11:.+]] = getelementptr{{.+}}i8, ptr %b, {{i32|i64}} 6
-    // CHECK: %[[A11:.+]] = load i16, ptr %[[PA11]]
-    // 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: [[DONE]]:
-    // CHECK: %[[RET:.+]] = phi i1 [ %{{.+}}, %[[EXIT_S]] ], [ %{{.+}}, %[[EXIT_U]] ], [ true, %[[L11]] ]
-    // CHECK: ret i1 %[[RET]]
-
-    a <= b
-}
diff --git a/tests/codegen/array-codegen.rs b/tests/codegen/array-codegen.rs
deleted file mode 100644
index 9b0c6e8c347..00000000000
--- a/tests/codegen/array-codegen.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @array_load
-#[no_mangle]
-pub fn array_load(a: &[u8; 4]) -> [u8; 4] {
-    // CHECK-NOT: alloca
-    // CHECK: %[[ALLOCA:.+]] = alloca [4 x i8], align 1
-    // CHECK-NOT: alloca
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %[[ALLOCA]], ptr align 1 %a, {{.+}} 4, i1 false)
-    // CHECK: %[[TEMP:.+]] = load i32, ptr %[[ALLOCA]], align 1
-    // CHECK: ret i32 %[[TEMP]]
-    *a
-}
-
-// CHECK-LABEL: @array_store
-#[no_mangle]
-pub fn array_store(a: [u8; 4], p: &mut [u8; 4]) {
-    // CHECK-NOT: alloca
-    // CHECK: %[[TEMP:.+]] = alloca [4 x i8], [[TEMPALIGN:align [0-9]+]]
-    // CHECK-NOT: alloca
-    // CHECK: %a = alloca [4 x i8]
-    // CHECK-NOT: alloca
-    // store i32 %0, ptr %[[TEMP]]
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %a, ptr [[TEMPALIGN]] %[[TEMP]], {{.+}} 4, i1 false)
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %p, ptr align 1 %a, {{.+}} 4, i1 false)
-    *p = a;
-}
-
-// CHECK-LABEL: @array_copy
-#[no_mangle]
-pub fn array_copy(a: &[u8; 4], p: &mut [u8; 4]) {
-    // CHECK-NOT: alloca
-    // CHECK: %[[LOCAL:.+]] = alloca [4 x i8], align 1
-    // CHECK-NOT: alloca
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %[[LOCAL]], ptr align 1 %a, {{.+}} 4, i1 false)
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %p, ptr align 1 %[[LOCAL]], {{.+}} 4, i1 false)
-    *p = *a;
-}
-
-// CHECK-LABEL: @array_copy_1_element
-#[no_mangle]
-pub fn array_copy_1_element(a: &[u8; 1], p: &mut [u8; 1]) {
-    // CHECK-NOT: alloca
-    // CHECK: %[[LOCAL:.+]] = alloca [1 x i8], align 1
-    // CHECK-NOT: alloca
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %[[LOCAL]], ptr align 1 %a, {{.+}} 1, i1 false)
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %p, ptr align 1 %[[LOCAL]], {{.+}} 1, i1 false)
-    *p = *a;
-}
-
-// CHECK-LABEL: @array_copy_2_elements
-#[no_mangle]
-pub fn array_copy_2_elements(a: &[u8; 2], p: &mut [u8; 2]) {
-    // CHECK-NOT: alloca
-    // CHECK: %[[LOCAL:.+]] = alloca [2 x i8], align 1
-    // CHECK-NOT: alloca
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %[[LOCAL]], ptr align 1 %a, {{.+}} 2, i1 false)
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %p, ptr align 1 %[[LOCAL]], {{.+}} 2, i1 false)
-    *p = *a;
-}
diff --git a/tests/codegen/array-equality.rs b/tests/codegen/array-equality.rs
deleted file mode 100644
index fa0475bf480..00000000000
--- a/tests/codegen/array-equality.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-//@ only-x86_64
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @array_eq_value
-#[no_mangle]
-pub fn array_eq_value(a: [u16; 3], b: [u16; 3]) -> bool {
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %2 = icmp eq i48 %0, %1
-    // CHECK-NEXT: ret i1 %2
-    a == b
-}
-
-// CHECK-LABEL: @array_eq_ref
-#[no_mangle]
-pub fn array_eq_ref(a: &[u16; 3], b: &[u16; 3]) -> bool {
-    // CHECK: start:
-    // CHECK: load i48, ptr %{{.+}}, align 2
-    // CHECK: load i48, ptr %{{.+}}, align 2
-    // CHECK: icmp eq i48
-    // CHECK-NEXT: ret
-    a == b
-}
-
-// CHECK-LABEL: @array_eq_value_still_passed_by_pointer
-#[no_mangle]
-pub fn array_eq_value_still_passed_by_pointer(a: [u16; 9], b: [u16; 9]) -> bool {
-    // CHECK-NEXT: start:
-    // CHECK: %[[CMP:.+]] = tail call i32 @{{bcmp|memcmp}}(ptr {{.*}} dereferenceable(18) %{{.+}}, ptr {{.*}} dereferenceable(18) %{{.+}}, i64 18)
-    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[CMP]], 0
-    // CHECK-NEXT: ret i1 %[[EQ]]
-    a == b
-}
-
-// CHECK-LABEL: @array_eq_long
-#[no_mangle]
-pub fn array_eq_long(a: &[u16; 1234], b: &[u16; 1234]) -> bool {
-    // CHECK-NEXT: start:
-    // CHECK: %[[CMP:.+]] = tail call i32 @{{bcmp|memcmp}}(ptr {{.*}} dereferenceable(2468) %{{.+}}, ptr {{.*}} dereferenceable(2468) %{{.+}}, i64 2468)
-    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[CMP]], 0
-    // CHECK-NEXT: ret i1 %[[EQ]]
-    a == b
-}
-
-// CHECK-LABEL: @array_char_eq
-#[no_mangle]
-pub fn array_char_eq(a: [char; 2], b: [char; 2]) -> bool {
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i64 %0, %1
-    // CHECK-NEXT: ret i1 %[[EQ]]
-    a == b
-}
-
-// CHECK-LABEL: @array_eq_zero_short(i48
-#[no_mangle]
-pub fn array_eq_zero_short(x: [u16; 3]) -> bool {
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i48 %0, 0
-    // CHECK-NEXT: ret i1 %[[EQ]]
-    x == [0; 3]
-}
-
-// CHECK-LABEL: @array_eq_none_short(i40
-#[no_mangle]
-pub fn array_eq_none_short(x: [Option<std::num::NonZero<u8>>; 5]) -> bool {
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i40 %0, 0
-    // CHECK-NEXT: ret i1 %[[EQ]]
-    x == [None; 5]
-}
-
-// CHECK-LABEL: @array_eq_zero_nested(
-#[no_mangle]
-pub fn array_eq_zero_nested(x: [[u8; 3]; 3]) -> bool {
-    // CHECK: %[[VAL:.+]] = load i72
-    // CHECK-SAME: align 1
-    // CHECK: %[[EQ:.+]] = icmp eq i72 %[[VAL]], 0
-    // CHECK: ret i1 %[[EQ]]
-    x == [[0; 3]; 3]
-}
-
-// CHECK-LABEL: @array_eq_zero_mid(
-#[no_mangle]
-pub fn array_eq_zero_mid(x: [u16; 8]) -> bool {
-    // CHECK-NEXT: start:
-    // CHECK: %[[LOAD:.+]] = load i128,
-    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i128 %[[LOAD]], 0
-    // CHECK-NEXT: ret i1 %[[EQ]]
-    x == [0; 8]
-}
-
-// CHECK-LABEL: @array_eq_zero_long(
-#[no_mangle]
-pub fn array_eq_zero_long(x: [u16; 1234]) -> bool {
-    // CHECK-NEXT: start:
-    // CHECK-NOT: alloca
-    // CHECK: %[[CMP:.+]] = tail call i32 @{{bcmp|memcmp}}(
-    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[CMP]], 0
-    // CHECK-NEXT: ret i1 %[[EQ]]
-    x == [0; 1234]
-}
diff --git a/tests/codegen/array-from_fn.rs b/tests/codegen/array-from_fn.rs
deleted file mode 100644
index 7202d0c67e6..00000000000
--- a/tests/codegen/array-from_fn.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ revisions: NORMAL OPT
-//@ [NORMAL] compile-flags: -C opt-level=0 -C debuginfo=2
-//@ [OPT] compile-flags: -C opt-level=s -C debuginfo=0
-
-#![crate_type = "lib"]
-#![feature(array_from_fn)]
-
-#[no_mangle]
-pub fn iota() -> [u8; 16] {
-    // OPT-NOT: core..array..Guard
-    // NORMAL: core..array..Guard
-    std::array::from_fn(|i| i as _)
-}
diff --git a/tests/codegen/array-map.rs b/tests/codegen/array-map.rs
deleted file mode 100644
index f49dddcfc20..00000000000
--- a/tests/codegen/array-map.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ compile-flags: -C opt-level=3 -C target-cpu=x86-64-v3
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @short_integer_map
-#[no_mangle]
-pub fn short_integer_map(x: [u32; 8]) -> [u32; 8] {
-    // CHECK: load <8 x i32>
-    // CHECK: shl <8 x i32>
-    // CHECK: or{{( disjoint)?}} <8 x i32>
-    // CHECK: store <8 x i32>
-    x.map(|x| 2 * x + 1)
-}
-
-// This test is checking that LLVM can SRoA away a bunch of the overhead,
-// like fully moving the iterators to registers.  Notably, previous implementations
-// of `map` ended up `alloca`ing the whole `array::IntoIterator`, meaning both a
-// hard-to-eliminate `memcpy` and that the iteration counts needed to be written
-// out to stack every iteration, even for infallible operations on `Copy` types.
-//
-// This is still imperfect, as there's more copies than would be ideal,
-// but hopefully work like #103830 will improve that in future,
-// and update this test to be stricter.
-//
-// CHECK-LABEL: @long_integer_map
-#[no_mangle]
-pub fn long_integer_map(x: [u32; 512]) -> [u32; 512] {
-    // CHECK: start:
-    // CHECK-NEXT: alloca [2048 x i8]
-    // CHECK-NOT: alloca
-    // CHECK: mul <{{[0-9]+}} x i32>
-    // CHECK: add <{{[0-9]+}} x i32>
-    x.map(|x| 13 * x + 7)
-}
diff --git a/tests/codegen/array-optimized.rs b/tests/codegen/array-optimized.rs
deleted file mode 100644
index 000163d5519..00000000000
--- a/tests/codegen/array-optimized.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @array_copy_1_element
-#[no_mangle]
-pub fn array_copy_1_element(a: &[u8; 1], p: &mut [u8; 1]) {
-    // CHECK-NOT: alloca
-    // CHECK: %[[TEMP:.+]] = load i8, ptr %a, align 1
-    // CHECK: store i8 %[[TEMP]], ptr %p, align 1
-    // CHECK: ret
-    *p = *a;
-}
-
-// CHECK-LABEL: @array_copy_2_elements
-#[no_mangle]
-pub fn array_copy_2_elements(a: &[u8; 2], p: &mut [u8; 2]) {
-    // CHECK-NOT: alloca
-    // CHECK: %[[TEMP:.+]] = load i16, ptr %a, align 1
-    // CHECK: store i16 %[[TEMP]], ptr %p, align 1
-    // CHECK: ret
-    *p = *a;
-}
-
-// CHECK-LABEL: @array_copy_4_elements
-#[no_mangle]
-pub fn array_copy_4_elements(a: &[u8; 4], p: &mut [u8; 4]) {
-    // CHECK-NOT: alloca
-    // CHECK: %[[TEMP:.+]] = load i32, ptr %a, align 1
-    // CHECK: store i32 %[[TEMP]], ptr %p, align 1
-    // CHECK: ret
-    *p = *a;
-}
diff --git a/tests/codegen/array-repeat.rs b/tests/codegen/array-repeat.rs
deleted file mode 100644
index 4c755df9390..00000000000
--- a/tests/codegen/array-repeat.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-#![feature(array_repeat)]
-
-use std::array::repeat;
-
-// CHECK-LABEL: @byte_repeat
-#[no_mangle]
-fn byte_repeat(b: u8) -> [u8; 1024] {
-    // CHECK-NOT: alloca
-    // CHECK-NOT: store
-    // CHECK: memset
-    repeat(b)
-}
diff --git a/tests/codegen/ascii-char.rs b/tests/codegen/ascii-char.rs
deleted file mode 100644
index 86ec9d73afe..00000000000
--- a/tests/codegen/ascii-char.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ compile-flags: -C opt-level=1
-
-#![crate_type = "lib"]
-#![feature(ascii_char)]
-
-use std::ascii::Char as AsciiChar;
-
-// CHECK-LABEL: i8 @unwrap_digit_from_remainder(i32
-#[no_mangle]
-pub fn unwrap_digit_from_remainder(v: u32) -> AsciiChar {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: panic
-
-    // CHECK: %[[R:.+]] = urem i32 %v, 10
-    // CHECK-NEXT: %[[T:.+]] = trunc{{( nuw)?( nsw)?}} i32 %[[R]] to i8
-    // CHECK-NEXT: %[[D:.+]] = or{{( disjoint)?}} i8 %[[T]], 48
-    // CHECK-NEXT: ret i8 %[[D]]
-
-    // CHECK-NOT: icmp
-    // CHECK-NOT: panic
-    AsciiChar::digit((v % 10) as u8).unwrap()
-}
-
-// CHECK-LABEL: i8 @unwrap_from_masked(i8
-#[no_mangle]
-pub fn unwrap_from_masked(b: u8) -> AsciiChar {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: panic
-
-    // CHECK: %[[M:.+]] = and i8 %b, 127
-    // CHECK-NEXT: ret i8 %[[M]]
-
-    // CHECK-NOT: icmp
-    // CHECK-NOT: panic
-    AsciiChar::from_u8(b & 0x7f).unwrap()
-}
diff --git a/tests/codegen/asm/aarch64-clobbers.rs b/tests/codegen/asm/aarch64-clobbers.rs
deleted file mode 100644
index dd3ba1510b5..00000000000
--- a/tests/codegen/asm/aarch64-clobbers.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-//@ add-core-stubs
-//@ revisions: aarch64 aarch64_fixed_x18 aarch64_no_x18 aarch64_reserve_x18 arm64ec
-//@[aarch64] compile-flags: --target aarch64-unknown-linux-gnu
-//@[aarch64] needs-llvm-components: aarch64
-//@[aarch64_fixed_x18] compile-flags: --target aarch64-unknown-linux-gnu -Zfixed-x18
-//@[aarch64_fixed_x18] needs-llvm-components: aarch64
-//@[aarch64_no_x18] compile-flags: --target aarch64-pc-windows-msvc
-//@[aarch64_no_x18] needs-llvm-components: aarch64
-// aarch64-unknown-trusty uses aarch64-unknown-unknown-musl which doesn't
-// reserve x18 by default as llvm_target, and pass +reserve-x18 in target-spec.
-//@[aarch64_reserve_x18] compile-flags: --target aarch64-unknown-trusty
-//@[aarch64_reserve_x18] needs-llvm-components: aarch64
-//@[arm64ec] compile-flags: --target arm64ec-pc-windows-msvc
-//@[arm64ec] needs-llvm-components: aarch64
-// ignore-tidy-linelength
-
-#![crate_type = "rlib"]
-#![feature(no_core)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: @cc_clobber
-// CHECK: call void asm sideeffect "", "~{cc}"()
-#[no_mangle]
-pub unsafe fn cc_clobber() {
-    asm!("", options(nostack, nomem));
-}
-
-// CHECK-LABEL: @no_clobber
-// CHECK: call void asm sideeffect "", ""()
-#[no_mangle]
-pub unsafe fn no_clobber() {
-    asm!("", options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @clobber_abi
-// aarch64: asm sideeffect "", "={w0},={w1},={w2},={w3},={w4},={w5},={w6},={w7},={w8},={w9},={w10},={w11},={w12},={w13},={w14},={w15},={w16},={w17},={w18},={w30},={q0},={q1},={q2},={q3},={q4},={q5},={q6},={q7},={q8},={q9},={q10},={q11},={q12},={q13},={q14},={q15},={q16},={q17},={q18},={q19},={q20},={q21},={q22},={q23},={q24},={q25},={q26},={q27},={q28},={q29},={q30},={q31},~{p0},~{p1},~{p2},~{p3},~{p4},~{p5},~{p6},~{p7},~{p8},~{p9},~{p10},~{p11},~{p12},~{p13},~{p14},~{p15},~{ffr}"()
-// aarch64_fixed_x18: asm sideeffect "", "={w0},={w1},={w2},={w3},={w4},={w5},={w6},={w7},={w8},={w9},={w10},={w11},={w12},={w13},={w14},={w15},={w16},={w17},={w30},={q0},={q1},={q2},={q3},={q4},={q5},={q6},={q7},={q8},={q9},={q10},={q11},={q12},={q13},={q14},={q15},={q16},={q17},={q18},={q19},={q20},={q21},={q22},={q23},={q24},={q25},={q26},={q27},={q28},={q29},={q30},={q31},~{p0},~{p1},~{p2},~{p3},~{p4},~{p5},~{p6},~{p7},~{p8},~{p9},~{p10},~{p11},~{p12},~{p13},~{p14},~{p15},~{ffr}"()
-// aarch64_no_x18: asm sideeffect "", "={w0},={w1},={w2},={w3},={w4},={w5},={w6},={w7},={w8},={w9},={w10},={w11},={w12},={w13},={w14},={w15},={w16},={w17},={w30},={q0},={q1},={q2},={q3},={q4},={q5},={q6},={q7},={q8},={q9},={q10},={q11},={q12},={q13},={q14},={q15},={q16},={q17},={q18},={q19},={q20},={q21},={q22},={q23},={q24},={q25},={q26},={q27},={q28},={q29},={q30},={q31},~{p0},~{p1},~{p2},~{p3},~{p4},~{p5},~{p6},~{p7},~{p8},~{p9},~{p10},~{p11},~{p12},~{p13},~{p14},~{p15},~{ffr}"()
-// aarch64_reserve_x18: asm sideeffect "", "={w0},={w1},={w2},={w3},={w4},={w5},={w6},={w7},={w8},={w9},={w10},={w11},={w12},={w13},={w14},={w15},={w16},={w17},={w30},={q0},={q1},={q2},={q3},={q4},={q5},={q6},={q7},={q8},={q9},={q10},={q11},={q12},={q13},={q14},={q15},={q16},={q17},={q18},={q19},={q20},={q21},={q22},={q23},={q24},={q25},={q26},={q27},={q28},={q29},={q30},={q31},~{p0},~{p1},~{p2},~{p3},~{p4},~{p5},~{p6},~{p7},~{p8},~{p9},~{p10},~{p11},~{p12},~{p13},~{p14},~{p15},~{ffr}"()
-// arm64ec: asm sideeffect "", "={w0},={w1},={w2},={w3},={w4},={w5},={w6},={w7},={w8},={w9},={w10},={w11},={w12},={w15},={w16},={w17},={w30},={q0},={q1},={q2},={q3},={q4},={q5},={q6},={q7},={q8},={q9},={q10},={q11},={q12},={q13},={q14},={q15}"()
-#[no_mangle]
-pub unsafe fn clobber_abi() {
-    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
-}
diff --git a/tests/codegen/asm/avr-clobbers.rs b/tests/codegen/asm/avr-clobbers.rs
deleted file mode 100644
index 9451127bf04..00000000000
--- a/tests/codegen/asm/avr-clobbers.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target avr-none -C target-cpu=atmega328p
-//@ needs-llvm-components: avr
-
-#![crate_type = "rlib"]
-#![feature(no_core, asm_experimental_arch)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: @sreg_is_clobbered
-// CHECK: void asm sideeffect "", "~{sreg}"()
-#[no_mangle]
-pub unsafe fn sreg_is_clobbered() {
-    asm!("", options(nostack, nomem));
-}
-
-// CHECK-LABEL: @sreg_is_not_clobbered_if_preserve_flags_is_used
-// CHECK: void asm sideeffect "", ""()
-#[no_mangle]
-pub unsafe fn sreg_is_not_clobbered_if_preserve_flags_is_used() {
-    asm!("", options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @clobber_abi
-// CHECK: asm sideeffect "", "={r18},={r19},={r20},={r21},={r22},={r23},={r24},={r25},={r26},={r27},={r30},={r31},~{sreg}"()
-#[no_mangle]
-pub unsafe fn clobber_abi() {
-    asm!("", clobber_abi("C"), options(nostack, nomem));
-}
-
-// CHECK-LABEL: @clobber_abi_with_preserved_flags
-// CHECK: asm sideeffect "", "={r18},={r19},={r20},={r21},={r22},={r23},={r24},={r25},={r26},={r27},={r30},={r31}"()
-#[no_mangle]
-pub unsafe fn clobber_abi_with_preserved_flags() {
-    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
-}
diff --git a/tests/codegen/asm/bpf-clobbers.rs b/tests/codegen/asm/bpf-clobbers.rs
deleted file mode 100644
index 1117549b1ec..00000000000
--- a/tests/codegen/asm/bpf-clobbers.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: --target bpfel-unknown-none
-//@ needs-llvm-components: bpf
-
-#![crate_type = "rlib"]
-#![feature(no_core, asm_experimental_arch)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: @flags_clobber
-// CHECK: call void asm sideeffect "", ""()
-#[no_mangle]
-pub unsafe fn flags_clobber() {
-    asm!("", options(nostack, nomem));
-}
-
-// CHECK-LABEL: @no_clobber
-// CHECK: call void asm sideeffect "", ""()
-#[no_mangle]
-pub unsafe fn no_clobber() {
-    asm!("", options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @clobber_abi
-// CHECK: asm sideeffect "", "={r0},={r1},={r2},={r3},={r4},={r5}"()
-#[no_mangle]
-pub unsafe fn clobber_abi() {
-    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
-}
diff --git a/tests/codegen/asm/critical.rs b/tests/codegen/asm/critical.rs
deleted file mode 100644
index 0f29d7c69b4..00000000000
--- a/tests/codegen/asm/critical.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ only-x86_64
-//@ compile-flags: -C no-prepopulate-passes
-#![feature(asm_goto_with_outputs)]
-#![crate_type = "lib"]
-use std::arch::asm;
-
-// Regression test for #137867. Check that critical edges have been split before code generation,
-// and so all stores to the asm output occur on disjoint paths without any of them jumping to
-// another callbr label.
-//
-// CHECK-LABEL: @f(
-// CHECK:        [[OUT:%.*]] = callbr i32 asm
-// CHECK-NEXT:   to label %[[BB0:.*]] [label %[[BB1:.*]], label %[[BB2:.*]]],
-// CHECK:       [[BB1]]:
-// CHECK-NEXT:    store i32 [[OUT]], ptr %a
-// CHECK-NEXT:    br label %[[BBR:.*]]
-// CHECK:       [[BB2]]:
-// CHECK-NEXT:    store i32 [[OUT]], ptr %a
-// CHECK-NEXT:    br label %[[BBR]]
-// CHECK:       [[BB0]]:
-// CHECK-NEXT:    store i32 [[OUT]], ptr %a
-// CHECK-NEXT:    br label %[[BBR]]
-// CHECK:       [[BBR]]:
-// CHECK-NEXT:    [[RET:%.*]] = load i32, ptr %a
-// CHECK-NEXT:    ret i32 [[RET]]
-#[unsafe(no_mangle)]
-pub unsafe fn f(mut a: u32) -> u32 {
-    asm!(
-        "jmp {}
-         jmp {}",
-        label {},
-        label {},
-        inout("eax") a,
-    );
-    a
-}
diff --git a/tests/codegen/asm/csky-clobbers.rs b/tests/codegen/asm/csky-clobbers.rs
deleted file mode 100644
index 4986d0fe56d..00000000000
--- a/tests/codegen/asm/csky-clobbers.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: --target csky-unknown-linux-gnuabiv2
-//@ needs-llvm-components: csky
-
-#![crate_type = "rlib"]
-#![feature(no_core, asm_experimental_arch)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: @flags_clobber
-// CHECK: call void asm sideeffect "", "~{psr}"()
-#[no_mangle]
-pub unsafe fn flags_clobber() {
-    asm!("", options(nostack, nomem));
-}
-
-// CHECK-LABEL: @no_clobber
-// CHECK: call void asm sideeffect "", ""()
-#[no_mangle]
-pub unsafe fn no_clobber() {
-    asm!("", options(nostack, nomem, preserves_flags));
-}
diff --git a/tests/codegen/asm/foo.s b/tests/codegen/asm/foo.s
deleted file mode 100644
index 304d82aa0c6..00000000000
--- a/tests/codegen/asm/foo.s
+++ /dev/null
@@ -1,3 +0,0 @@
-.global foo
-foo:
-    jmp baz
diff --git a/tests/codegen/asm/global_asm.rs b/tests/codegen/asm/global_asm.rs
deleted file mode 100644
index 32075daa3cf..00000000000
--- a/tests/codegen/asm/global_asm.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ revisions: x32 x64
-//@[x32] only-x86
-//@[x64] only-x86_64
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-use std::arch::global_asm;
-
-// CHECK-LABEL: foo
-// CHECK: module asm
-// this regex will capture the correct unconditional branch inst.
-// CHECK: module asm "{{[[:space:]]+}}jmp baz"
-global_asm!(
-    r#"
-    .global foo
-foo:
-    jmp baz
-"#
-);
-
-extern "C" {
-    fn foo();
-}
-
-// CHECK-LABEL: @baz
-#[no_mangle]
-pub unsafe extern "C" fn baz() {}
diff --git a/tests/codegen/asm/global_asm_include.rs b/tests/codegen/asm/global_asm_include.rs
deleted file mode 100644
index 98be9c3e333..00000000000
--- a/tests/codegen/asm/global_asm_include.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ revisions: x32 x64
-//@[x32] only-x86
-//@[x64] only-x86_64
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-use std::arch::global_asm;
-
-// CHECK-LABEL: foo
-// CHECK: module asm
-// CHECK: module asm "{{[[:space:]]+}}jmp baz"
-global_asm!(include_str!("foo.s"));
-
-extern "C" {
-    fn foo();
-}
-
-// CHECK-LABEL: @baz
-#[no_mangle]
-pub unsafe extern "C" fn baz() {}
diff --git a/tests/codegen/asm/global_asm_x2.rs b/tests/codegen/asm/global_asm_x2.rs
deleted file mode 100644
index 9e3a00f0680..00000000000
--- a/tests/codegen/asm/global_asm_x2.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-//@ revisions: x32 x64
-//@[x32] only-x86
-//@[x64] only-x86_64
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![no_std]
-
-use core::arch::global_asm;
-
-// CHECK-LABEL: foo
-// CHECK: module asm
-// CHECK: module asm "{{[[:space:]]+}}jmp baz"
-// any other global_asm will be appended to this first block, so:
-// CHECK-LABEL: bar
-// CHECK: module asm "{{[[:space:]]+}}jmp quux"
-global_asm!(
-    r#"
-    .global foo
-foo:
-    jmp baz
-"#
-);
-
-extern "C" {
-    fn foo();
-}
-
-// CHECK-LABEL: @baz
-#[no_mangle]
-pub unsafe extern "C" fn baz() {}
-
-// no checks here; this has been appended to the first occurrence
-global_asm!(
-    r#"
-    .global bar
-bar:
-    jmp quux
-"#
-);
-
-extern "C" {
-    fn bar();
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn quux() {}
diff --git a/tests/codegen/asm/goto.rs b/tests/codegen/asm/goto.rs
deleted file mode 100644
index f68c399c920..00000000000
--- a/tests/codegen/asm/goto.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-#![crate_type = "rlib"]
-#![feature(asm_goto_with_outputs)]
-
-use std::arch::asm;
-
-// CHECK-LABEL: @asm_goto
-#[no_mangle]
-pub unsafe fn asm_goto() {
-    // CHECK: callbr void asm sideeffect alignstack inteldialect "
-    // CHECK-NEXT: to label %[[FALLTHROUGHBB:[a-b0-9]+]] [label %[[JUMPBB:[a-b0-9]+]]]
-    asm!("jmp {}", label {});
-}
-
-// CHECK-LABEL: @asm_goto_with_outputs
-#[no_mangle]
-pub unsafe fn asm_goto_with_outputs() -> u64 {
-    let out: u64;
-    // CHECK: [[RES:%[0-9]+]] = callbr i64 asm sideeffect alignstack inteldialect "
-    // CHECK-NEXT: to label %[[FALLTHROUGHBB:[a-b0-9]+]] [label %[[JUMPBB:[a-b0-9]+]]]
-    asm!("{} /* {} */", out(reg) out, label { return 1; });
-    // CHECK: [[JUMPBB]]:
-    // CHECK-NEXT: [[RET:%.+]] = phi i64 [ [[RES]], %[[FALLTHROUGHBB]] ], [ 1, %start ]
-    // CHECK-NEXT: ret i64 [[RET]]
-    out
-}
-
-// CHECK-LABEL: @asm_goto_with_outputs_use_in_label
-#[no_mangle]
-pub unsafe fn asm_goto_with_outputs_use_in_label() -> u64 {
-    let out: u64;
-    // CHECK: [[RES:%[0-9]+]] = callbr i64 asm sideeffect alignstack inteldialect "
-    // CHECK-NEXT: to label %[[FALLTHROUGHBB:[a-b0-9]+]] [label %[[JUMPBB:[a-b0-9]+]]]
-    asm!("{} /* {} */", out(reg) out, label { return out; });
-    // CHECK: [[JUMPBB]]:
-    // CHECK-NEXT: [[RET:%.+]] = phi i64 [ 1, %[[FALLTHROUGHBB]] ], [ [[RES]], %start ]
-    // CHECK-NEXT: ret i64 [[RET]]
-    1
-}
-
-// CHECK-LABEL: @asm_goto_noreturn
-#[no_mangle]
-pub unsafe fn asm_goto_noreturn() -> u64 {
-    // CHECK: callbr void asm sideeffect alignstack inteldialect "
-    // CHECK-NEXT: to label %unreachable [label %[[JUMPBB:[a-b0-9]+]]]
-    asm!("jmp {}", label { return 1; }, options(noreturn));
-    // CHECK: [[JUMPBB]]:
-    // CHECK-NEXT: ret i64 1
-}
-
-// CHECK-LABEL: @asm_goto_noreturn_with_outputs
-#[no_mangle]
-pub unsafe fn asm_goto_noreturn_with_outputs() -> u64 {
-    let out: u64;
-    // CHECK: [[RES:%[0-9]+]] = callbr i64 asm sideeffect alignstack inteldialect "
-    // CHECK-NEXT: to label %[[FALLTHROUGHBB:[a-b0-9]+]] [label %[[JUMPBB:[a-b0-9]+]]]
-    asm!("mov {}, 1", "jmp {}", out(reg) out, label { return out; });
-    // CHECK: [[JUMPBB]]:
-    // CHECK-NEXT: ret i64 [[RES]]
-    out
-}
diff --git a/tests/codegen/asm/hexagon-clobbers.rs b/tests/codegen/asm/hexagon-clobbers.rs
deleted file mode 100644
index 800b8964669..00000000000
--- a/tests/codegen/asm/hexagon-clobbers.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ add-core-stubs
-//@ revisions: hexagon
-//@[hexagon] compile-flags: --target hexagon-unknown-linux-musl
-//@[hexagon] needs-llvm-components: hexagon
-//@ compile-flags: -Zmerge-functions=disabled
-
-#![crate_type = "rlib"]
-#![feature(no_core, asm_experimental_arch)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: @flags_clobber
-// CHECK: call void asm sideeffect "", ""()
-#[no_mangle]
-pub unsafe fn flags_clobber() {
-    asm!("", options(nostack, nomem));
-}
-
-// CHECK-LABEL: @no_clobber
-// CHECK: call void asm sideeffect "", ""()
-#[no_mangle]
-pub unsafe fn no_clobber() {
-    asm!("", options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @p0_clobber
-// CHECK: call void asm sideeffect "", "~{p0}"()
-#[no_mangle]
-pub unsafe fn p0_clobber() {
-    asm!("", out("p0") _, options(nostack, nomem, preserves_flags));
-}
diff --git a/tests/codegen/asm/may_unwind.rs b/tests/codegen/asm/may_unwind.rs
deleted file mode 100644
index 63cdec7584c..00000000000
--- a/tests/codegen/asm/may_unwind.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-#![crate_type = "rlib"]
-#![feature(asm_unwind)]
-
-use std::arch::asm;
-
-#[no_mangle]
-pub extern "C" fn panicky() {}
-
-struct Foo;
-
-impl Drop for Foo {
-    fn drop(&mut self) {
-        println!();
-    }
-}
-
-// CHECK-LABEL: @asm_may_unwind
-#[no_mangle]
-pub unsafe fn asm_may_unwind() {
-    let _m = Foo;
-    // CHECK: invoke void asm sideeffect alignstack inteldialect unwind ""
-    asm!("", options(may_unwind));
-}
-
-// CHECK-LABEL: @asm_with_result_may_unwind
-#[no_mangle]
-pub unsafe fn asm_with_result_may_unwind() -> u64 {
-    let _m = Foo;
-    let res: u64;
-    // CHECK: [[RES:%[0-9]+]] = invoke i64 asm sideeffect alignstack inteldialect unwind
-    // CHECK-NEXT: to label %[[NORMALBB:[a-b0-9]+]]
-    asm!("mov {}, 1", out(reg) res, options(may_unwind));
-    // CHECK: [[NORMALBB]]:
-    // CHECK: ret i64 [[RES:%[0-9]+]]
-    res
-}
diff --git a/tests/codegen/asm/maybe-uninit.rs b/tests/codegen/asm/maybe-uninit.rs
deleted file mode 100644
index d76d5cb1312..00000000000
--- a/tests/codegen/asm/maybe-uninit.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-#![crate_type = "rlib"]
-#![allow(asm_sub_register)]
-
-use std::arch::asm;
-use std::mem::MaybeUninit;
-
-// CHECK-LABEL: @int
-#[no_mangle]
-pub unsafe fn int(x: MaybeUninit<i32>) -> MaybeUninit<i32> {
-    let y: MaybeUninit<i32>;
-    asm!("/*{}{}*/", in(reg) x, out(reg) y);
-    y
-}
-
-// CHECK-LABEL: @inout
-#[no_mangle]
-pub unsafe fn inout(mut x: i32) -> MaybeUninit<u32> {
-    let mut y: MaybeUninit<u32>;
-    asm!("/*{}*/", inout(reg) x => y);
-    asm!("/*{}*/", inout(reg) y => x);
-    asm!("/*{}*/", inlateout(reg) x => y);
-    asm!("/*{}*/", inlateout(reg) y => x);
-    y
-}
diff --git a/tests/codegen/asm/msp430-clobbers.rs b/tests/codegen/asm/msp430-clobbers.rs
deleted file mode 100644
index 2c8d29cffc4..00000000000
--- a/tests/codegen/asm/msp430-clobbers.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ compile-flags: --target msp430-none-elf
-//@ needs-llvm-components: msp430
-
-#![crate_type = "rlib"]
-#![feature(no_core, asm_experimental_arch)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: @sr_clobber
-// CHECK: call void asm sideeffect "", "~{sr}"()
-#[no_mangle]
-pub unsafe fn sr_clobber() {
-    asm!("", options(nostack, nomem));
-}
-
-// CHECK-LABEL: @no_clobber
-// CHECK: call void asm sideeffect "", ""()
-#[no_mangle]
-pub unsafe fn no_clobber() {
-    asm!("", options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @clobber_abi
-// CHECK: asm sideeffect "", "={r11},={r12},={r13},={r14},={r15}"()
-#[no_mangle]
-pub unsafe fn clobber_abi() {
-    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
-}
diff --git a/tests/codegen/asm/multiple-options.rs b/tests/codegen/asm/multiple-options.rs
deleted file mode 100644
index 4d87471a193..00000000000
--- a/tests/codegen/asm/multiple-options.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-#![crate_type = "rlib"]
-
-use std::arch::asm;
-
-// CHECK-LABEL: @pure
-// CHECK-NOT: asm
-// CHECK: ret void
-#[no_mangle]
-pub unsafe fn pure(x: i32) {
-    let y: i32;
-    asm!("", out("ax") y, in("cx") x, options(pure), options(nomem));
-}
-
-pub static mut VAR: i32 = 0;
-pub static mut DUMMY_OUTPUT: i32 = 0;
-
-// CHECK-LABEL: @readonly
-// CHECK: call i32 asm
-// CHECK: ret i32 1
-#[no_mangle]
-pub unsafe fn readonly() -> i32 {
-    VAR = 1;
-    asm!("", out("ax") DUMMY_OUTPUT, options(pure), options(readonly));
-    VAR
-}
-
-// CHECK-LABEL: @nomem
-// CHECK-NOT: store
-// CHECK: call i32 asm
-// CHECK: store
-// CHECK: ret i32 2
-#[no_mangle]
-pub unsafe fn nomem() -> i32 {
-    VAR = 1;
-    asm!("", out("ax") DUMMY_OUTPUT, options(pure), options(nomem));
-    VAR = 2;
-    VAR
-}
-
-// CHECK-LABEL: @not_nomem
-// CHECK: store
-// CHECK: call i32 asm
-// CHECK: store
-// CHECK: ret i32 2
-#[no_mangle]
-pub unsafe fn not_nomem() -> i32 {
-    VAR = 1;
-    asm!("", out("ax") DUMMY_OUTPUT, options(pure), options(readonly));
-    VAR = 2;
-    VAR
-}
diff --git a/tests/codegen/asm/options.rs b/tests/codegen/asm/options.rs
deleted file mode 100644
index c087f91fd43..00000000000
--- a/tests/codegen/asm/options.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-#![crate_type = "rlib"]
-
-use std::arch::asm;
-
-// CHECK-LABEL: @pure
-// CHECK-NOT: asm
-// CHECK: ret void
-#[no_mangle]
-pub unsafe fn pure(x: i32) {
-    let y: i32;
-    asm!("", out("ax") y, in("cx") x, options(pure, nomem));
-}
-
-// CHECK-LABEL: @noreturn
-// CHECK: call void asm
-// CHECK-NEXT: unreachable
-#[no_mangle]
-pub unsafe fn noreturn() {
-    asm!("", options(noreturn));
-}
-
-pub static mut VAR: i32 = 0;
-pub static mut DUMMY_OUTPUT: i32 = 0;
-
-// CHECK-LABEL: @readonly
-// CHECK: call i32 asm
-// CHECK: ret i32 1
-#[no_mangle]
-pub unsafe fn readonly() -> i32 {
-    VAR = 1;
-    asm!("", out("ax") DUMMY_OUTPUT, options(pure, readonly));
-    VAR
-}
-
-// CHECK-LABEL: @not_readonly
-// CHECK: call i32 asm
-// CHECK: ret i32 %
-#[no_mangle]
-pub unsafe fn not_readonly() -> i32 {
-    VAR = 1;
-    asm!("", out("ax") DUMMY_OUTPUT, options());
-    VAR
-}
-
-// CHECK-LABEL: @nomem
-// CHECK-NOT: store
-// CHECK: call i32 asm
-// CHECK: store
-// CHECK: ret i32 2
-#[no_mangle]
-pub unsafe fn nomem() -> i32 {
-    VAR = 1;
-    asm!("", out("ax") DUMMY_OUTPUT, options(pure, nomem));
-    VAR = 2;
-    VAR
-}
-
-// CHECK-LABEL: @nomem_nopure
-// CHECK-NOT: store
-// CHECK: call i32 asm
-// CHECK: store
-// CHECK: ret i32 2
-#[no_mangle]
-pub unsafe fn nomem_nopure() -> i32 {
-    VAR = 1;
-    asm!("", out("ax") DUMMY_OUTPUT, options(nomem));
-    VAR = 2;
-    VAR
-}
-
-// CHECK-LABEL: @not_nomem
-// CHECK: store
-// CHECK: call i32 asm
-// CHECK: store
-// CHECK: ret i32 2
-#[no_mangle]
-pub unsafe fn not_nomem() -> i32 {
-    VAR = 1;
-    asm!("", out("ax") DUMMY_OUTPUT, options(pure, readonly));
-    VAR = 2;
-    VAR
-}
-
-// CHECK-LABEL: @dont_remove_nonpure
-// CHECK: call void asm
-// CHECK: call void asm
-// CHECK: call void asm
-// CHECK: ret void
-#[no_mangle]
-pub unsafe fn dont_remove_nonpure() {
-    asm!("", options());
-    asm!("", options(nomem));
-    asm!("", options(readonly));
-}
-
-// CHECK-LABEL: @raw
-// CHECK: call void asm sideeffect inteldialect "{} {}", ""()
-#[no_mangle]
-pub unsafe fn raw() {
-    asm!("{} {}", options(nostack, nomem, preserves_flags, raw));
-}
diff --git a/tests/codegen/asm/powerpc-clobbers.rs b/tests/codegen/asm/powerpc-clobbers.rs
deleted file mode 100644
index f7fc7eea5d5..00000000000
--- a/tests/codegen/asm/powerpc-clobbers.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//@ add-core-stubs
-//@ revisions: powerpc powerpc64 powerpc64le aix64
-//@[powerpc] compile-flags: --target powerpc-unknown-linux-gnu
-//@[powerpc] needs-llvm-components: powerpc
-//@[powerpc64] compile-flags: --target powerpc64-unknown-linux-gnu
-//@[powerpc64] needs-llvm-components: powerpc
-//@[powerpc64le] compile-flags: --target powerpc64le-unknown-linux-gnu
-//@[powerpc64le] needs-llvm-components: powerpc
-//@[aix64] compile-flags: --target powerpc64-ibm-aix
-//@[aix64] needs-llvm-components: powerpc
-// ignore-tidy-linelength
-
-#![crate_type = "rlib"]
-#![feature(no_core, asm_experimental_arch)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: @cr_clobber
-// CHECK: call void asm sideeffect "", "~{cr}"()
-#[no_mangle]
-pub unsafe fn cr_clobber() {
-    asm!("", out("cr") _, options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @cr0_clobber
-// CHECK: call void asm sideeffect "", "~{cr0}"()
-#[no_mangle]
-pub unsafe fn cr0_clobber() {
-    asm!("", out("cr0") _, options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @cr5_clobber
-// CHECK: call void asm sideeffect "", "~{cr5}"()
-#[no_mangle]
-pub unsafe fn cr5_clobber() {
-    asm!("", out("cr5") _, options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @xer_clobber
-// CHECK: call void asm sideeffect "", "~{xer}"()
-#[no_mangle]
-pub unsafe fn xer_clobber() {
-    asm!("", out("xer") _, options(nostack, nomem, preserves_flags));
-}
-
-// Output format depends on the availability of altivec.
-// CHECK-LABEL: @v0_clobber
-// powerpc: call void asm sideeffect "", "~{v0}"()
-// powerpc64: call <4 x i32> asm sideeffect "", "=&{v0}"()
-// powerpc64le: call <4 x i32> asm sideeffect "", "=&{v0}"()
-// aix64: call <4 x i32> asm sideeffect "", "=&{v0}"()
-#[no_mangle]
-pub unsafe fn v0_clobber() {
-    asm!("", out("v0") _, options(nostack, nomem, preserves_flags));
-}
-
-// Output format depends on the availability of altivec.
-// CHECK-LABEL: @clobber_abi
-// powerpc: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
-// powerpc64: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
-// powerpc64le: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
-// aix64: asm sideeffect "", "={r0},={r3},={r4},={r5},={r6},={r7},={r8},={r9},={r10},={r11},={r12},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},={f8},={f9},={f10},={f11},={f12},={f13},={v0},={v1},={v2},={v3},={v4},={v5},={v6},={v7},={v8},={v9},={v10},={v11},={v12},={v13},={v14},={v15},={v16},={v17},={v18},={v19},~{cr0},~{cr1},~{cr5},~{cr6},~{cr7},~{xer}"()
-#[no_mangle]
-pub unsafe fn clobber_abi() {
-    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
-}
diff --git a/tests/codegen/asm/riscv-clobbers.rs b/tests/codegen/asm/riscv-clobbers.rs
deleted file mode 100644
index e55b6731098..00000000000
--- a/tests/codegen/asm/riscv-clobbers.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//@ add-core-stubs
-//@ assembly-output: emit-asm
-//@ revisions: rv32i rv64i rv32e
-//@[rv32i] compile-flags: --target riscv32i-unknown-none-elf
-//@[rv32i] needs-llvm-components: riscv
-//@[rv64i] compile-flags: --target riscv64imac-unknown-none-elf
-//@[rv64i] needs-llvm-components: riscv
-//@[rv32e] compile-flags: --target riscv32e-unknown-none-elf
-//@[rv32e] needs-llvm-components: riscv
-// ignore-tidy-linelength
-
-#![crate_type = "rlib"]
-#![feature(no_core)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: @flags_clobber
-// CHECK: call void asm sideeffect "", "~{vtype},~{vl},~{vxsat},~{vxrm}"()
-#[no_mangle]
-pub unsafe fn flags_clobber() {
-    asm!("", options(nostack, nomem));
-}
-
-// CHECK-LABEL: @no_clobber
-// CHECK: call void asm sideeffect "", ""()
-#[no_mangle]
-pub unsafe fn no_clobber() {
-    asm!("", options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @clobber_abi
-// rv32i: asm sideeffect "", "={x1},={x5},={x6},={x7},={x10},={x11},={x12},={x13},={x14},={x15},={x16},={x17},={x28},={x29},={x30},={x31},~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f28},~{f29},~{f30},~{f31},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
-// rv64i: asm sideeffect "", "={x1},={x5},={x6},={x7},={x10},={x11},={x12},={x13},={x14},={x15},={x16},={x17},={x28},={x29},={x30},={x31},~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f28},~{f29},~{f30},~{f31},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
-// rv32e: asm sideeffect "", "={x1},={x5},={x6},={x7},={x10},={x11},={x12},={x13},={x14},={x15},~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f28},~{f29},~{f30},~{f31},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31}"()
-#[no_mangle]
-pub unsafe fn clobber_abi() {
-    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
-}
diff --git a/tests/codegen/asm/s390x-clobbers.rs b/tests/codegen/asm/s390x-clobbers.rs
deleted file mode 100644
index 0ba22a32abf..00000000000
--- a/tests/codegen/asm/s390x-clobbers.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-//@ add-core-stubs
-//@ revisions: s390x
-//@[s390x] compile-flags: --target s390x-unknown-linux-gnu -C target-cpu=z10
-//@[s390x] needs-llvm-components: systemz
-
-#![crate_type = "rlib"]
-#![feature(no_core)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: @cc_clobber
-// CHECK: call void asm sideeffect "", "~{cc}"()
-#[no_mangle]
-pub unsafe fn cc_clobber() {
-    asm!("", options(nostack, nomem));
-}
-
-// CHECK-LABEL: @no_clobber
-// CHECK: call void asm sideeffect "", ""()
-#[no_mangle]
-pub unsafe fn no_clobber() {
-    asm!("", options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @a2_clobber
-// CHECK: call void asm sideeffect "", "~{a2}"()
-#[no_mangle]
-pub unsafe fn a2_clobber() {
-    asm!("", out("a2") _, options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @v0_clobber
-// CHECK: call void asm sideeffect "", "~{v0}"()
-#[no_mangle]
-pub unsafe fn v0_clobber() {
-    asm!("", out("v0") _, options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @clobber_abi
-// CHECK: asm sideeffect "", "={r0},={r1},={r2},={r3},={r4},={r5},={r14},={f0},={f1},={f2},={f3},={f4},={f5},={f6},={f7},~{v0},~{v1},~{v2},~{v3},~{v4},~{v5},~{v6},~{v7},~{v8},~{v9},~{v10},~{v11},~{v12},~{v13},~{v14},~{v15},~{v16},~{v17},~{v18},~{v19},~{v20},~{v21},~{v22},~{v23},~{v24},~{v25},~{v26},~{v27},~{v28},~{v29},~{v30},~{v31},~{a2},~{a3},~{a4},~{a5},~{a6},~{a7},~{a8},~{a9},~{a10},~{a11},~{a12},~{a13},~{a14},~{a15}"()
-#[no_mangle]
-pub unsafe fn clobber_abi() {
-    asm!("", clobber_abi("C"), options(nostack, nomem, preserves_flags));
-}
diff --git a/tests/codegen/asm/sanitize-llvm.rs b/tests/codegen/asm/sanitize-llvm.rs
deleted file mode 100644
index 97a77033284..00000000000
--- a/tests/codegen/asm/sanitize-llvm.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ add-core-stubs
-// FIXME(nagisa): remove the flags below once all targets support `asm!`.
-//@ compile-flags: --target x86_64-unknown-linux-gnu -Copt-level=0
-//@ needs-llvm-components: x86
-
-// Verify we sanitize the special tokens for the LLVM inline-assembly, ensuring people won't
-// inadvertently rely on the LLVM-specific syntax and features.
-#![no_core]
-#![feature(no_core)]
-#![crate_type = "rlib"]
-#![allow(named_asm_labels)]
-
-extern crate minicore;
-use minicore::*;
-
-pub unsafe fn we_escape_dollar_signs() {
-    // CHECK: call void asm sideeffect alignstack inteldialect "banana$$:"
-    asm!(r"banana$:",)
-}
-
-pub unsafe fn we_escape_escapes_too() {
-    // CHECK: call void asm sideeffect alignstack inteldialect "banana\{{(\\|5C)}}36:"
-    asm!(r"banana\36:",)
-}
diff --git a/tests/codegen/asm/sparc-clobbers.rs b/tests/codegen/asm/sparc-clobbers.rs
deleted file mode 100644
index a71715ed94d..00000000000
--- a/tests/codegen/asm/sparc-clobbers.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ add-core-stubs
-//@ revisions: sparc sparcv8plus sparc64
-//@[sparc] compile-flags: --target sparc-unknown-none-elf
-//@[sparc] needs-llvm-components: sparc
-//@[sparcv8plus] compile-flags: --target sparc-unknown-linux-gnu
-//@[sparcv8plus] needs-llvm-components: sparc
-//@[sparc64] compile-flags: --target sparc64-unknown-linux-gnu
-//@[sparc64] needs-llvm-components: sparc
-
-#![crate_type = "rlib"]
-#![feature(no_core, asm_experimental_arch)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: @cc_clobber
-// CHECK: call void asm sideeffect "", "~{icc},~{fcc0},~{fcc1},~{fcc2},~{fcc3}"()
-#[no_mangle]
-pub unsafe fn cc_clobber() {
-    asm!("", options(nostack, nomem));
-}
-
-// CHECK-LABEL: @no_clobber
-// CHECK: call void asm sideeffect "", ""()
-#[no_mangle]
-pub unsafe fn no_clobber() {
-    asm!("", options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @y_clobber
-// CHECK: call void asm sideeffect "", "~{y}"()
-#[no_mangle]
-pub unsafe fn y_clobber() {
-    asm!("", out("y") _, options(nostack, nomem, preserves_flags));
-}
diff --git a/tests/codegen/asm/x86-clobber_abi.rs b/tests/codegen/asm/x86-clobber_abi.rs
deleted file mode 100644
index 5b34b4e8ef3..00000000000
--- a/tests/codegen/asm/x86-clobber_abi.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-#![crate_type = "rlib"]
-
-use std::arch::asm;
-
-// CHECK-LABEL: @clobber_sysv64
-// CHECK: ={ax},={cx},={dx},={si},={di},={r8},={r9},={r10},={r11},={xmm0},={xmm1},={xmm2},={xmm3},={xmm4},={xmm5},={xmm6},={xmm7},={xmm8},={xmm9},={xmm10},={xmm11},={xmm12},={xmm13},={xmm14},={xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{k0},~{k1},~{k2},~{k3},~{k4},~{k5},~{k6},~{k7},~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)},~{tmm0},~{tmm1},~{tmm2},~{tmm3},~{tmm4},~{tmm5},~{tmm6},~{tmm7},~{dirflag},~{fpsr},~{flags},~{memory}
-#[no_mangle]
-pub unsafe fn clobber_sysv64() {
-    asm!("", clobber_abi("sysv64"));
-}
-
-// CHECK-LABEL: @clobber_win64
-// CHECK: ={ax},={cx},={dx},={r8},={r9},={r10},={r11},={xmm0},={xmm1},={xmm2},={xmm3},={xmm4},={xmm5},={xmm6},={xmm7},={xmm8},={xmm9},={xmm10},={xmm11},={xmm12},={xmm13},={xmm14},={xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{k0},~{k1},~{k2},~{k3},~{k4},~{k5},~{k6},~{k7},~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)},~{tmm0},~{tmm1},~{tmm2},~{tmm3},~{tmm4},~{tmm5},~{tmm6},~{tmm7},~{dirflag},~{fpsr},~{flags},~{memory}
-#[no_mangle]
-pub unsafe fn clobber_win64() {
-    asm!("", clobber_abi("win64"));
-}
-
-// CHECK-LABEL: @clobber_sysv64
-// CHECK: =&{dx},={ax},={cx},={si},={di},={r8},={r9},={r10},={r11},={xmm0},={xmm1},={xmm2},={xmm3},={xmm4},={xmm5},={xmm6},={xmm7},={xmm8},={xmm9},={xmm10},={xmm11},={xmm12},={xmm13},={xmm14},={xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{k0},~{k1},~{k2},~{k3},~{k4},~{k5},~{k6},~{k7},~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)},~{tmm0},~{tmm1},~{tmm2},~{tmm3},~{tmm4},~{tmm5},~{tmm6},~{tmm7},~{dirflag},~{fpsr},~{flags},~{memory}
-#[no_mangle]
-pub unsafe fn clobber_sysv64_edx() {
-    let foo: i32;
-    asm!("", out("edx") foo, clobber_abi("sysv64"));
-}
-
-// CHECK-LABEL: @clobber_win64
-// CHECK: =&{dx},={ax},={cx},={r8},={r9},={r10},={r11},={xmm0},={xmm1},={xmm2},={xmm3},={xmm4},={xmm5},={xmm6},={xmm7},={xmm8},={xmm9},={xmm10},={xmm11},={xmm12},={xmm13},={xmm14},={xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{k0},~{k1},~{k2},~{k3},~{k4},~{k5},~{k6},~{k7},~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)},~{tmm0},~{tmm1},~{tmm2},~{tmm3},~{tmm4},~{tmm5},~{tmm6},~{tmm7},~{dirflag},~{fpsr},~{flags},~{memory}
-#[no_mangle]
-pub unsafe fn clobber_win64_edx() {
-    let foo: i32;
-    asm!("", out("edx") foo, clobber_abi("win64"));
-}
diff --git a/tests/codegen/asm/x86-clobbers.rs b/tests/codegen/asm/x86-clobbers.rs
deleted file mode 100644
index 50163b646b2..00000000000
--- a/tests/codegen/asm/x86-clobbers.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-#![crate_type = "rlib"]
-
-use std::arch::asm;
-
-// CHECK-LABEL: @x87_clobber
-// CHECK: ~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)}
-#[no_mangle]
-pub unsafe fn x87_clobber() {
-    asm!("foo", out("st") _);
-}
-
-// CHECK-LABEL: @mmx_clobber
-// CHECK: ~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)}
-#[no_mangle]
-pub unsafe fn mmx_clobber() {
-    asm!("bar", out("mm0") _, out("mm1") _);
-}
diff --git a/tests/codegen/asm/x86-target-clobbers.rs b/tests/codegen/asm/x86-target-clobbers.rs
deleted file mode 100644
index 119372491ff..00000000000
--- a/tests/codegen/asm/x86-target-clobbers.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//@ only-x86_64
-//@ revisions: base avx512
-//@ [avx512]compile-flags: -C target-feature=+avx512f
-
-#![crate_type = "rlib"]
-
-use std::arch::asm;
-
-// CHECK-LABEL: @amx_clobber
-// base: call void asm sideeffect inteldialect "", "~{tmm0}"()
-#[no_mangle]
-pub unsafe fn amx_clobber() {
-    asm!("", out("tmm0") _, options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @avx512_clobber
-// base: call void asm sideeffect inteldialect "", "~{xmm31}"()
-// avx512: call float asm sideeffect inteldialect "", "=&{xmm31}"()
-#[no_mangle]
-pub unsafe fn avx512_clobber() {
-    asm!("", out("zmm31") _, options(nostack, nomem, preserves_flags));
-}
-
-// CHECK-LABEL: @eax_clobber
-// CHECK: call i32 asm sideeffect inteldialect "", "=&{ax}"()
-#[no_mangle]
-pub unsafe fn eax_clobber() {
-    asm!("", out("eax") _, options(nostack, nomem, preserves_flags));
-}
diff --git a/tests/codegen/assign-desugar-debuginfo.rs b/tests/codegen/assign-desugar-debuginfo.rs
deleted file mode 100644
index 77ee8758b3b..00000000000
--- a/tests/codegen/assign-desugar-debuginfo.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ compile-flags: -g -Zmir-opt-level=0
-
-#![crate_type = "lib"]
-
-#[inline(never)]
-fn swizzle(a: u32, b: u32, c: u32) -> (u32, (u32, u32)) {
-    (b, (c, a))
-}
-
-pub fn work() {
-    let mut a = 1;
-    let mut b = 2;
-    let mut c = 3;
-    (a, (b, c)) = swizzle(a, b, c);
-    println!("{a} {b} {c}");
-}
-
-// CHECK-NOT: !DILocalVariable(name: "lhs",
diff --git a/tests/codegen/async-closure-debug.rs b/tests/codegen/async-closure-debug.rs
deleted file mode 100644
index b5b369e6e54..00000000000
--- a/tests/codegen/async-closure-debug.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Just make sure that async closures don't ICE.
-//
-//@ compile-flags: -C debuginfo=2
-//@ edition: 2018
-//@ ignore-msvc
-
-// CHECK-DAG:  [[GEN_FN:!.*]] = !DINamespace(name: "async_closure_test"
-// CHECK-DAG:  [[CLOSURE:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}", scope: [[GEN_FN]]
-// CHECK-DAG:  [[UPVAR:!.*]] = !DIDerivedType(tag: DW_TAG_member, name: "upvar", scope: [[CLOSURE]]
-
-fn async_closure_test(upvar: &str) -> impl AsyncFn() + '_ {
-    async move || {
-        let hello = String::from("hello");
-        println!("{hello}, {upvar}");
-    }
-}
-
-fn main() {
-    let _async_closure = async_closure_test("world");
-}
diff --git a/tests/codegen/async-fn-debug-awaitee-field.rs b/tests/codegen/async-fn-debug-awaitee-field.rs
deleted file mode 100644
index 50860c90662..00000000000
--- a/tests/codegen/async-fn-debug-awaitee-field.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// ignore-tidy-linelength
-//! This test makes sure that the coroutine field capturing the awaitee in a `.await` expression
-//! is called `__awaitee` in debuginfo. This name must not be changed since debuggers and debugger
-//! extensions rely on the field having this name.
-
-//@ revisions: MSVC NONMSVC
-//@[MSVC] only-msvc
-//@[NONMSVC] ignore-msvc
-
-//@ compile-flags: -C debuginfo=2 -Copt-level=0
-//@ edition: 2018
-
-#![crate_type = "lib"]
-
-pub async fn async_fn_test() {
-    foo().await;
-}
-
-pub async fn foo() {}
-
-// NONMSVC: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}", scope: [[GEN_SCOPE:![0-9]*]],
-// MSVC: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<async_fn_debug_awaitee_field::async_fn_test::async_fn_env$0>",
-// NONMSVC: [[GEN_SCOPE:!.*]] = !DINamespace(name: "async_fn_test",
-// CHECK: [[SUSPEND_STRUCT:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend0", scope: [[GEN]],
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__awaitee", scope: [[SUSPEND_STRUCT]], {{.*}}, baseType: [[AWAITEE_TYPE:![0-9]*]],
-// NONMSVC: [[AWAITEE_TYPE]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}", scope: [[AWAITEE_SCOPE:![0-9]*]],
-// MSVC: [[AWAITEE_TYPE]] = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<async_fn_debug_awaitee_field::foo::async_fn_env$0>",
-// NONMSVC: [[AWAITEE_SCOPE]] = !DINamespace(name: "foo",
diff --git a/tests/codegen/async-fn-debug-msvc.rs b/tests/codegen/async-fn-debug-msvc.rs
deleted file mode 100644
index e0c601146f8..00000000000
--- a/tests/codegen/async-fn-debug-msvc.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Verify debuginfo for coroutines:
-//  - Each variant points to the file and line of its yield point
-//  - The discriminants are marked artificial
-//  - Other fields are not marked artificial
-//
-//
-//@ compile-flags: -C debuginfo=2
-//@ edition: 2018
-//@ only-msvc
-
-async fn foo() {}
-async fn async_fn_test() {
-    foo().await;
-    let s = String::from("foo");
-    foo().await;
-}
-
-// FIXME: No way to reliably check the filename.
-
-// CHECK-DAG:  [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<async_fn_debug_msvc::async_fn_test::async_fn_env$0>",
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant0", scope: [[GEN]],
-// For brevity, we only check the struct name and members of the last variant.
-// CHECK-SAME: file: [[FILE:![0-9]*]], line: 12,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant1", scope: [[GEN]],
-// CHECK-SAME: file: [[FILE]], line: 16,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant2", scope: [[GEN]],
-// CHECK-SAME: file: [[FILE]], line: 16,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant3", scope: [[GEN]],
-// CHECK-SAME: file: [[FILE]], line: 13,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant4", scope: [[GEN]],
-// CHECK-SAME: file: [[FILE]], line: 15,
-// CHECK-SAME: baseType: [[VARIANT_WRAPPER:![0-9]*]]
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "value", scope: [[VARIANT_WRAPPER]], file: !2, baseType: [[VARIANT:![0-9]*]],
-// CHECK:      [[VARIANT]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[GEN]],
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[VARIANT]]
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "tag", scope: [[GEN]],
-// CHECK-NOT: flags: DIFlagArtificial
-
-fn main() {
-    let _dummy = async_fn_test();
-}
diff --git a/tests/codegen/async-fn-debug.rs b/tests/codegen/async-fn-debug.rs
deleted file mode 100644
index ed704c7cc8b..00000000000
--- a/tests/codegen/async-fn-debug.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-// Verify debuginfo for async fn:
-//  - Each variant points to the file and line of its yield point
-//  - The discriminants are marked artificial
-//  - Other fields are not marked artificial
-//
-//
-//@ compile-flags: -C debuginfo=2
-//@ edition: 2018
-//@ ignore-msvc
-
-async fn foo() {}
-async fn async_fn_test() {
-    foo().await;
-    let s = String::from("foo");
-    foo().await;
-}
-
-// FIXME: No way to reliably check the filename.
-
-// CHECK-DAG:  [[ASYNC_FN:!.*]] = !DINamespace(name: "async_fn_test"
-// CHECK-DAG:  [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}", scope: [[ASYNC_FN]]
-// CHECK:      [[VARIANT:!.*]] = !DICompositeType(tag: DW_TAG_variant_part, scope: [[GEN]],
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: discriminator: [[DISC:![0-9]*]]
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "0", scope: [[VARIANT]],
-// CHECK-SAME: file: [[FILE:![0-9]*]], line: 12,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "Unresumed", scope: [[GEN]],
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "1", scope: [[VARIANT]],
-// CHECK-SAME: file: [[FILE]], line: 16,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "2", scope: [[VARIANT]],
-// CHECK-SAME: file: [[FILE]], line: 16,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "3", scope: [[VARIANT]],
-// CHECK-SAME: file: [[FILE]], line: 13,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "4", scope: [[VARIANT]],
-// CHECK-SAME: file: [[FILE]], line: 15,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      [[S1:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[GEN]],
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[S1]]
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      [[DISC]] = !DIDerivedType(tag: DW_TAG_member, name: "__state", scope: [[GEN]],
-// CHECK-SAME: flags: DIFlagArtificial
-
-fn main() {
-    let _dummy = async_fn_test();
-}
diff --git a/tests/codegen/atomic-operations.rs b/tests/codegen/atomic-operations.rs
deleted file mode 100644
index 8771b8b2419..00000000000
--- a/tests/codegen/atomic-operations.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-// Code generation of atomic operations.
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-use std::sync::atomic::AtomicI32;
-use std::sync::atomic::Ordering::*;
-
-// CHECK-LABEL: @compare_exchange
-#[no_mangle]
-pub fn compare_exchange(a: &AtomicI32) {
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 10 monotonic monotonic
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 11 monotonic acquire
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 12 monotonic seq_cst
-    let _ = a.compare_exchange(0, 10, Relaxed, Relaxed);
-    let _ = a.compare_exchange(0, 11, Relaxed, Acquire);
-    let _ = a.compare_exchange(0, 12, Relaxed, SeqCst);
-
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 20 release monotonic
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 21 release acquire
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 22 release seq_cst
-    let _ = a.compare_exchange(0, 20, Release, Relaxed);
-    let _ = a.compare_exchange(0, 21, Release, Acquire);
-    let _ = a.compare_exchange(0, 22, Release, SeqCst);
-
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 30 acquire monotonic
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 31 acquire acquire
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 32 acquire seq_cst
-    let _ = a.compare_exchange(0, 30, Acquire, Relaxed);
-    let _ = a.compare_exchange(0, 31, Acquire, Acquire);
-    let _ = a.compare_exchange(0, 32, Acquire, SeqCst);
-
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 40 acq_rel monotonic
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 41 acq_rel acquire
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 42 acq_rel seq_cst
-    let _ = a.compare_exchange(0, 40, AcqRel, Relaxed);
-    let _ = a.compare_exchange(0, 41, AcqRel, Acquire);
-    let _ = a.compare_exchange(0, 42, AcqRel, SeqCst);
-
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 50 seq_cst monotonic
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 51 seq_cst acquire
-    // CHECK: cmpxchg ptr %{{.*}}, i32 0, i32 52 seq_cst seq_cst
-    let _ = a.compare_exchange(0, 50, SeqCst, Relaxed);
-    let _ = a.compare_exchange(0, 51, SeqCst, Acquire);
-    let _ = a.compare_exchange(0, 52, SeqCst, SeqCst);
-}
-
-// CHECK-LABEL: @compare_exchange_weak
-#[no_mangle]
-pub fn compare_exchange_weak(w: &AtomicI32) {
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 10 monotonic monotonic
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 11 monotonic acquire
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 12 monotonic seq_cst
-    let _ = w.compare_exchange_weak(1, 10, Relaxed, Relaxed);
-    let _ = w.compare_exchange_weak(1, 11, Relaxed, Acquire);
-    let _ = w.compare_exchange_weak(1, 12, Relaxed, SeqCst);
-
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 20 release monotonic
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 21 release acquire
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 22 release seq_cst
-    let _ = w.compare_exchange_weak(1, 20, Release, Relaxed);
-    let _ = w.compare_exchange_weak(1, 21, Release, Acquire);
-    let _ = w.compare_exchange_weak(1, 22, Release, SeqCst);
-
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 30 acquire monotonic
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 31 acquire acquire
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 32 acquire seq_cst
-    let _ = w.compare_exchange_weak(1, 30, Acquire, Relaxed);
-    let _ = w.compare_exchange_weak(1, 31, Acquire, Acquire);
-    let _ = w.compare_exchange_weak(1, 32, Acquire, SeqCst);
-
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 40 acq_rel monotonic
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 41 acq_rel acquire
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 42 acq_rel seq_cst
-    let _ = w.compare_exchange_weak(1, 40, AcqRel, Relaxed);
-    let _ = w.compare_exchange_weak(1, 41, AcqRel, Acquire);
-    let _ = w.compare_exchange_weak(1, 42, AcqRel, SeqCst);
-
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 50 seq_cst monotonic
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 51 seq_cst acquire
-    // CHECK: cmpxchg weak ptr %{{.*}}, i32 1, i32 52 seq_cst seq_cst
-    let _ = w.compare_exchange_weak(1, 50, SeqCst, Relaxed);
-    let _ = w.compare_exchange_weak(1, 51, SeqCst, Acquire);
-    let _ = w.compare_exchange_weak(1, 52, SeqCst, SeqCst);
-}
diff --git a/tests/codegen/atomicptr.rs b/tests/codegen/atomicptr.rs
deleted file mode 100644
index 4819af40ca2..00000000000
--- a/tests/codegen/atomicptr.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// LLVM does not support some atomic RMW operations on pointers, so inside codegen we lower those
-// to integer atomics, surrounded by casts to and from integer type.
-// This test ensures that we do the round-trip correctly for AtomicPtr::fetch_byte_add, and also
-// ensures that we do not have such a round-trip for AtomicPtr::swap, because LLVM supports pointer
-// arguments to `atomicrmw xchg`.
-
-//@ compile-flags: -Copt-level=3 -Cno-prepopulate-passes
-#![crate_type = "lib"]
-#![feature(strict_provenance_atomic_ptr)]
-
-use std::ptr::without_provenance_mut;
-use std::sync::atomic::AtomicPtr;
-use std::sync::atomic::Ordering::Relaxed;
-
-// Portability hack so that we can say [[USIZE]] instead of i64/i32/i16 for usize.
-// CHECK: @helper([[USIZE:i[0-9]+]] noundef %_1)
-#[no_mangle]
-pub fn helper(_: usize) {}
-
-// CHECK-LABEL: @atomicptr_fetch_byte_add
-#[no_mangle]
-pub fn atomicptr_fetch_byte_add(a: &AtomicPtr<u8>, v: usize) -> *mut u8 {
-    // CHECK: %[[INTPTR:.*]] = ptrtoint ptr %{{.*}} to [[USIZE]]
-    // CHECK-NEXT: %[[RET:.*]] = atomicrmw add ptr %{{.*}}, [[USIZE]] %[[INTPTR]]
-    // CHECK-NEXT: inttoptr [[USIZE]] %[[RET]] to ptr
-    a.fetch_byte_add(v, Relaxed)
-}
-
-// CHECK-LABEL: @atomicptr_swap
-#[no_mangle]
-pub fn atomicptr_swap(a: &AtomicPtr<u8>, ptr: *mut u8) -> *mut u8 {
-    // CHECK-NOT: ptrtoint
-    // CHECK: atomicrmw xchg ptr %{{.*}}, ptr %{{.*}} monotonic
-    // CHECK-NOT: inttoptr
-    a.swap(ptr, Relaxed)
-}
diff --git a/tests/codegen/autodiff/batched.rs b/tests/codegen/autodiff/batched.rs
deleted file mode 100644
index d27aed50e6c..00000000000
--- a/tests/codegen/autodiff/batched.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
-//@ no-prefer-dynamic
-//@ needs-enzyme
-//
-// In Enzyme, we test against a large range of LLVM versions (5+) and don't have overly many
-// breakages. One benefit is that we match the IR generated by Enzyme only after running it
-// through LLVM's O3 pipeline, which will remove most of the noise.
-// However, our integration test could also be affected by changes in how rustc lowers MIR into
-// LLVM-IR, which could cause additional noise and thus breakages. If that's the case, we should
-// reduce this test to only match the first lines and the ret instructions.
-
-#![feature(autodiff)]
-
-use std::autodiff::autodiff_forward;
-
-#[autodiff_forward(d_square3, Dual, DualOnly)]
-#[autodiff_forward(d_square2, 4, Dual, DualOnly)]
-#[autodiff_forward(d_square1, 4, Dual, Dual)]
-#[no_mangle]
-fn square(x: &f32) -> f32 {
-    x * x
-}
-
-// d_sqaure2
-// CHECK: define internal fastcc [4 x float] @fwddiffe4square(float %x.0.val, [4 x ptr] %"x'")
-// CHECK-NEXT: start:
-// CHECK-NEXT:   %0 = extractvalue [4 x ptr] %"x'", 0
-// CHECK-NEXT:   %"_2'ipl" = load float, ptr %0, align 4
-// CHECK-NEXT:   %1 = extractvalue [4 x ptr] %"x'", 1
-// CHECK-NEXT:   %"_2'ipl1" = load float, ptr %1, align 4
-// CHECK-NEXT:   %2 = extractvalue [4 x ptr] %"x'", 2
-// CHECK-NEXT:   %"_2'ipl2" = load float, ptr %2, align 4
-// CHECK-NEXT:   %3 = extractvalue [4 x ptr] %"x'", 3
-// CHECK-NEXT:   %"_2'ipl3" = load float, ptr %3, align 4
-// CHECK-NEXT:   %4 = insertelement <4 x float> poison, float %"_2'ipl", i64 0
-// CHECK-NEXT:   %5 = insertelement <4 x float> %4, float %"_2'ipl1", i64 1
-// CHECK-NEXT:   %6 = insertelement <4 x float> %5, float %"_2'ipl2", i64 2
-// CHECK-NEXT:   %7 = insertelement <4 x float> %6, float %"_2'ipl3", i64 3
-// CHECK-NEXT:   %8 = fadd fast <4 x float> %7, %7
-// CHECK-NEXT:   %9 = insertelement <4 x float> poison, float %x.0.val, i64 0
-// CHECK-NEXT:   %10 = shufflevector <4 x float> %9, <4 x float> poison, <4 x i32> zeroinitializer
-// CHECK-NEXT:   %11 = fmul fast <4 x float> %8, %10
-// CHECK-NEXT:   %12 = extractelement <4 x float> %11, i64 0
-// CHECK-NEXT:   %13 = insertvalue [4 x float] undef, float %12, 0
-// CHECK-NEXT:   %14 = extractelement <4 x float> %11, i64 1
-// CHECK-NEXT:   %15 = insertvalue [4 x float] %13, float %14, 1
-// CHECK-NEXT:   %16 = extractelement <4 x float> %11, i64 2
-// CHECK-NEXT:   %17 = insertvalue [4 x float] %15, float %16, 2
-// CHECK-NEXT:   %18 = extractelement <4 x float> %11, i64 3
-// CHECK-NEXT:   %19 = insertvalue [4 x float] %17, float %18, 3
-// CHECK-NEXT:   ret [4 x float] %19
-// CHECK-NEXT: }
-
-// d_square3, the extra float is the original return value (x * x)
-// CHECK: define internal fastcc { float, [4 x float] } @fwddiffe4square.1(float %x.0.val, [4 x ptr] %"x'")
-// CHECK-NEXT: start:
-// CHECK-NEXT:   %0 = extractvalue [4 x ptr] %"x'", 0
-// CHECK-NEXT:   %"_2'ipl" = load float, ptr %0, align 4
-// CHECK-NEXT:   %1 = extractvalue [4 x ptr] %"x'", 1
-// CHECK-NEXT:   %"_2'ipl1" = load float, ptr %1, align 4
-// CHECK-NEXT:   %2 = extractvalue [4 x ptr] %"x'", 2
-// CHECK-NEXT:   %"_2'ipl2" = load float, ptr %2, align 4
-// CHECK-NEXT:   %3 = extractvalue [4 x ptr] %"x'", 3
-// CHECK-NEXT:   %"_2'ipl3" = load float, ptr %3, align 4
-// CHECK-NEXT:   %_0 = fmul float %x.0.val, %x.0.val
-// CHECK-NEXT:   %4 = insertelement <4 x float> poison, float %"_2'ipl", i64 0
-// CHECK-NEXT:   %5 = insertelement <4 x float> %4, float %"_2'ipl1", i64 1
-// CHECK-NEXT:   %6 = insertelement <4 x float> %5, float %"_2'ipl2", i64 2
-// CHECK-NEXT:   %7 = insertelement <4 x float> %6, float %"_2'ipl3", i64 3
-// CHECK-NEXT:   %8 = fadd fast <4 x float> %7, %7
-// CHECK-NEXT:   %9 = insertelement <4 x float> poison, float %x.0.val, i64 0
-// CHECK-NEXT:   %10 = shufflevector <4 x float> %9, <4 x float> poison, <4 x i32> zeroinitializer
-// CHECK-NEXT:   %11 = fmul fast <4 x float> %8, %10
-// CHECK-NEXT:   %12 = extractelement <4 x float> %11, i64 0
-// CHECK-NEXT:   %13 = insertvalue [4 x float] undef, float %12, 0
-// CHECK-NEXT:   %14 = extractelement <4 x float> %11, i64 1
-// CHECK-NEXT:   %15 = insertvalue [4 x float] %13, float %14, 1
-// CHECK-NEXT:   %16 = extractelement <4 x float> %11, i64 2
-// CHECK-NEXT:   %17 = insertvalue [4 x float] %15, float %16, 2
-// CHECK-NEXT:   %18 = extractelement <4 x float> %11, i64 3
-// CHECK-NEXT:   %19 = insertvalue [4 x float] %17, float %18, 3
-// CHECK-NEXT:   %20 = insertvalue { float, [4 x float] } undef, float %_0, 0
-// CHECK-NEXT:   %21 = insertvalue { float, [4 x float] } %20, [4 x float] %19, 1
-// CHECK-NEXT:   ret { float, [4 x float] } %21
-// CHECK-NEXT: }
-
-fn main() {
-    let x = std::hint::black_box(3.0);
-    let output = square(&x);
-    dbg!(&output);
-    assert_eq!(9.0, output);
-    dbg!(square(&x));
-
-    let mut df_dx1 = 1.0;
-    let mut df_dx2 = 2.0;
-    let mut df_dx3 = 3.0;
-    let mut df_dx4 = 0.0;
-    let [o1, o2, o3, o4] = d_square2(&x, &mut df_dx1, &mut df_dx2, &mut df_dx3, &mut df_dx4);
-    dbg!(o1, o2, o3, o4);
-    let [output2, o1, o2, o3, o4] =
-        d_square1(&x, &mut df_dx1, &mut df_dx2, &mut df_dx3, &mut df_dx4);
-    dbg!(o1, o2, o3, o4);
-    assert_eq!(output, output2);
-    assert!((6.0 - o1).abs() < 1e-10);
-    assert!((12.0 - o2).abs() < 1e-10);
-    assert!((18.0 - o3).abs() < 1e-10);
-    assert!((0.0 - o4).abs() < 1e-10);
-    assert_eq!(1.0, df_dx1);
-    assert_eq!(2.0, df_dx2);
-    assert_eq!(3.0, df_dx3);
-    assert_eq!(0.0, df_dx4);
-    assert_eq!(d_square3(&x, &mut df_dx1), 2.0 * o1);
-    assert_eq!(d_square3(&x, &mut df_dx2), 2.0 * o2);
-    assert_eq!(d_square3(&x, &mut df_dx3), 2.0 * o3);
-    assert_eq!(d_square3(&x, &mut df_dx4), 2.0 * o4);
-}
diff --git a/tests/codegen/autodiff/generic.rs b/tests/codegen/autodiff/generic.rs
deleted file mode 100644
index 2f674079be0..00000000000
--- a/tests/codegen/autodiff/generic.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//@ compile-flags: -Zautodiff=Enable -Zautodiff=NoPostopt -C opt-level=3 -Clto=fat
-//@ no-prefer-dynamic
-//@ needs-enzyme
-#![feature(autodiff)]
-
-use std::autodiff::autodiff_reverse;
-
-#[autodiff_reverse(d_square, Duplicated, Active)]
-fn square<T: std::ops::Mul<Output = T> + Copy>(x: &T) -> T {
-    *x * *x
-}
-
-// Ensure that `d_square::<f64>` code is generated even if `square::<f64>` was never called
-//
-// CHECK: ; generic::square
-// CHECK-NEXT: ; Function Attrs:
-// CHECK-NEXT: define internal {{.*}} double
-// CHECK-NEXT: start:
-// CHECK-NOT: ret
-// CHECK: fmul double
-
-// Ensure that `d_square::<f32>` code is generated
-//
-// CHECK: ; generic::square
-// CHECK-NEXT: ; Function Attrs: {{.*}}
-// CHECK-NEXT: define internal {{.*}} float
-// CHECK-NEXT: start:
-// CHECK-NOT: ret
-// CHECK: fmul float
-
-fn main() {
-    let xf32: f32 = std::hint::black_box(3.0);
-    let xf64: f64 = std::hint::black_box(3.0);
-
-    let outputf32 = square::<f32>(&xf32);
-    assert_eq!(9.0, outputf32);
-
-    let mut df_dxf64: f64 = std::hint::black_box(0.0);
-
-    let output_f64 = d_square::<f64>(&xf64, &mut df_dxf64, 1.0);
-    assert_eq!(6.0, df_dxf64);
-}
diff --git a/tests/codegen/autodiff/identical_fnc.rs b/tests/codegen/autodiff/identical_fnc.rs
deleted file mode 100644
index 1c25b3d09ab..00000000000
--- a/tests/codegen/autodiff/identical_fnc.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
-//@ no-prefer-dynamic
-//@ needs-enzyme
-//
-// Each autodiff invocation creates a new placeholder function, which we will replace on llvm-ir
-// level. If a user tries to differentiate two identical functions within the same compilation unit,
-// then LLVM might merge them in release mode before AD. In that case we can't rewrite one of the
-// merged placeholder function anymore, and compilation would fail. We prevent this by disabling
-// LLVM's merge_function pass before AD. Here we implicetely test that our solution keeps working.
-// We also explicetly test that we keep running merge_function after AD, by checking for two
-// identical function calls in the LLVM-IR, while having two different calls in the Rust code.
-#![feature(autodiff)]
-
-use std::autodiff::autodiff_reverse;
-
-#[autodiff_reverse(d_square, Duplicated, Active)]
-fn square(x: &f64) -> f64 {
-    x * x
-}
-
-#[autodiff_reverse(d_square2, Duplicated, Active)]
-fn square2(x: &f64) -> f64 {
-    x * x
-}
-
-// CHECK:; identical_fnc::main
-// CHECK-NEXT:; Function Attrs:
-// CHECK-NEXT:define internal void @_ZN13identical_fnc4main17hf4dbc69c8d2f9130E()
-// CHECK-NEXT:start:
-// CHECK-NOT:br
-// CHECK-NOT:ret
-// CHECK:; call identical_fnc::d_square
-// CHECK-NEXT:  call fastcc void @_ZN13identical_fnc8d_square17h4c364207a2f8e06dE(double %x.val, ptr noalias noundef nonnull align 8 dereferenceable(8) %dx1)
-// CHECK-NEXT:; call identical_fnc::d_square
-// CHECK-NEXT:  call fastcc void @_ZN13identical_fnc8d_square17h4c364207a2f8e06dE(double %x.val, ptr noalias noundef nonnull align 8 dereferenceable(8) %dx2)
-
-fn main() {
-    let x = std::hint::black_box(3.0);
-    let mut dx1 = std::hint::black_box(1.0);
-    let mut dx2 = std::hint::black_box(1.0);
-    let _ = d_square(&x, &mut dx1, 1.0);
-    let _ = d_square2(&x, &mut dx2, 1.0);
-    assert_eq!(dx1, 6.0);
-    assert_eq!(dx2, 6.0);
-}
diff --git a/tests/codegen/autodiff/inline.rs b/tests/codegen/autodiff/inline.rs
deleted file mode 100644
index 65bed170207..00000000000
--- a/tests/codegen/autodiff/inline.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat -Zautodiff=NoPostopt
-//@ no-prefer-dynamic
-//@ needs-enzyme
-
-#![feature(autodiff)]
-
-use std::autodiff::autodiff_reverse;
-
-#[autodiff_reverse(d_square, Duplicated, Active)]
-fn square(x: &f64) -> f64 {
-    x * x
-}
-
-// CHECK: ; inline::d_square
-// CHECK-NEXT: ; Function Attrs: alwaysinline
-// CHECK-NOT: noinline
-// CHECK-NEXT: define internal fastcc void @_ZN6inline8d_square17h021c74e92c259cdeE
-fn main() {
-    let x = std::hint::black_box(3.0);
-    let mut dx1 = std::hint::black_box(1.0);
-    let _ = d_square(&x, &mut dx1, 1.0);
-    assert_eq!(dx1, 6.0);
-}
diff --git a/tests/codegen/autodiff/scalar.rs b/tests/codegen/autodiff/scalar.rs
deleted file mode 100644
index 096b4209e84..00000000000
--- a/tests/codegen/autodiff/scalar.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
-//@ no-prefer-dynamic
-//@ needs-enzyme
-#![feature(autodiff)]
-
-use std::autodiff::autodiff_reverse;
-
-#[autodiff_reverse(d_square, Duplicated, Active)]
-#[no_mangle]
-fn square(x: &f64) -> f64 {
-    x * x
-}
-
-// CHECK:define internal fastcc double @diffesquare(double %x.0.val, ptr nocapture nonnull align 8 %"x'"
-// CHECK-NEXT:invertstart:
-// CHECK-NEXT:  %_0 = fmul double %x.0.val, %x.0.val
-// CHECK-NEXT:  %0 = fadd fast double %x.0.val, %x.0.val
-// CHECK-NEXT:  %1 = load double, ptr %"x'", align 8
-// CHECK-NEXT:  %2 = fadd fast double %1, %0
-// CHECK-NEXT:  store double %2, ptr %"x'", align 8
-// CHECK-NEXT:  ret double %_0
-// CHECK-NEXT:}
-
-fn main() {
-    let x = std::hint::black_box(3.0);
-    let output = square(&x);
-    assert_eq!(9.0, output);
-
-    let mut df_dx = 0.0;
-    let output_ = d_square(&x, &mut df_dx, 1.0);
-    assert_eq!(output, output_);
-    assert_eq!(6.0, df_dx);
-}
diff --git a/tests/codegen/autodiff/sret.rs b/tests/codegen/autodiff/sret.rs
deleted file mode 100644
index d2fa85e3e37..00000000000
--- a/tests/codegen/autodiff/sret.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
-//@ no-prefer-dynamic
-//@ needs-enzyme
-
-// This test is almost identical to the scalar.rs one,
-// but we intentionally add a few more floats.
-// `df` would ret `{ f64, f32, f32 }`, but is lowered as an sret.
-// We therefore use this test to verify some of our sret handling.
-
-#![feature(autodiff)]
-
-use std::autodiff::autodiff_reverse;
-
-#[no_mangle]
-#[autodiff_reverse(df, Active, Active, Active)]
-fn primal(x: f32, y: f32) -> f64 {
-    (x * x * y) as f64
-}
-
-// CHECK:define internal fastcc void @_ZN4sret2df17h93be4316dd8ea006E(ptr dead_on_unwind noalias nocapture noundef nonnull writable writeonly align 8 dereferenceable(16) initializes((0, 16)) %_0, float noundef %x, float noundef %y)
-// CHECK-NEXT:start:
-// CHECK-NEXT:  %0 = tail call fastcc { double, float, float } @diffeprimal(float %x, float %y)
-// CHECK-NEXT:  %.elt = extractvalue { double, float, float } %0, 0
-// CHECK-NEXT:  store double %.elt, ptr %_0, align 8
-// CHECK-NEXT:  %_0.repack1 = getelementptr inbounds nuw i8, ptr %_0, i64 8
-// CHECK-NEXT:  %.elt2 = extractvalue { double, float, float } %0, 1
-// CHECK-NEXT:  store float %.elt2, ptr %_0.repack1, align 8
-// CHECK-NEXT:  %_0.repack3 = getelementptr inbounds nuw i8, ptr %_0, i64 12
-// CHECK-NEXT:  %.elt4 = extractvalue { double, float, float } %0, 2
-// CHECK-NEXT:  store float %.elt4, ptr %_0.repack3, align 4
-// CHECK-NEXT:  ret void
-// CHECK-NEXT:}
-
-fn main() {
-    let x = std::hint::black_box(3.0);
-    let y = std::hint::black_box(2.5);
-    let scalar = std::hint::black_box(1.0);
-    let (r1, r2, r3) = df(x, y, scalar);
-    // 3*3*1.5 = 22.5
-    assert_eq!(r1, 22.5);
-    // 2*x*y = 2*3*2.5 = 15.0
-    assert_eq!(r2, 15.0);
-    // x*x*1 = 3*3 = 9
-    assert_eq!(r3, 9.0);
-}
diff --git a/tests/codegen/autodiffv2.rs b/tests/codegen/autodiffv2.rs
deleted file mode 100644
index a40d19d3be3..00000000000
--- a/tests/codegen/autodiffv2.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-//@ compile-flags: -Zautodiff=Enable -C opt-level=3  -Clto=fat
-//@ no-prefer-dynamic
-//@ needs-enzyme
-//
-// In Enzyme, we test against a large range of LLVM versions (5+) and don't have overly many
-// breakages. One benefit is that we match the IR generated by Enzyme only after running it
-// through LLVM's O3 pipeline, which will remove most of the noise.
-// However, our integration test could also be affected by changes in how rustc lowers MIR into
-// LLVM-IR, which could cause additional noise and thus breakages. If that's the case, we should
-// reduce this test to only match the first lines and the ret instructions.
-//
-// The function tested here has 4 inputs and 5 outputs, so we could either call forward-mode
-// autodiff 4 times, or reverse mode 5 times. Since a forward-mode call is usually faster than
-// reverse mode, we prefer it here. This file also tests a new optimization (batch mode), which
-// allows us to call forward-mode autodiff only once, and get all 5 outputs in a single call.
-//
-// We support 2 different batch modes. `d_square2` has the same interface as scalar forward-mode,
-// but each shadow argument is `width` times larger (thus 16 and 20 elements here).
-// `d_square3` instead takes `width` (4) shadow arguments, which are all the same size as the
-// original function arguments.
-//
-// FIXME(autodiff): We currently can't test `d_square1` and `d_square3` in the same file, since they
-// generate the same dummy functions which get merged by LLVM, breaking pieces of our pipeline which
-// try to rewrite the dummy functions later. We should consider to change to pure declarations both
-// in our frontend and in the llvm backend to avoid these issues.
-
-#![feature(autodiff)]
-
-use std::autodiff::autodiff;
-
-#[no_mangle]
-//#[autodiff(d_square1, Forward, Dual, Dual)]
-#[autodiff(d_square2, Forward, 4, Dualv, Dualv)]
-#[autodiff(d_square3, Forward, 4, Dual, Dual)]
-fn square(x: &[f32], y: &mut [f32]) {
-    assert!(x.len() >= 4);
-    assert!(y.len() >= 5);
-    y[0] = 4.3 * x[0] + 1.2 * x[1] + 3.4 * x[2] + 2.1 * x[3];
-    y[1] = 2.3 * x[0] + 4.5 * x[1] + 1.7 * x[2] + 6.4 * x[3];
-    y[2] = 1.1 * x[0] + 3.3 * x[1] + 2.5 * x[2] + 4.7 * x[3];
-    y[3] = 5.2 * x[0] + 1.4 * x[1] + 2.6 * x[2] + 3.8 * x[3];
-    y[4] = 1.0 * x[0] + 2.0 * x[1] + 3.0 * x[2] + 4.0 * x[3];
-}
-
-fn main() {
-    let x1 = std::hint::black_box(vec![0.0, 1.0, 2.0, 3.0]);
-
-    let dx1 = std::hint::black_box(vec![1.0; 12]);
-
-    let z1 = std::hint::black_box(vec![1.0, 0.0, 0.0, 0.0]);
-    let z2 = std::hint::black_box(vec![0.0, 1.0, 0.0, 0.0]);
-    let z3 = std::hint::black_box(vec![0.0, 0.0, 1.0, 0.0]);
-    let z4 = std::hint::black_box(vec![0.0, 0.0, 0.0, 1.0]);
-
-    let z5 = std::hint::black_box(vec![
-        1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
-    ]);
-
-    let mut y1 = std::hint::black_box(vec![0.0; 5]);
-    let mut y2 = std::hint::black_box(vec![0.0; 5]);
-    let mut y3 = std::hint::black_box(vec![0.0; 5]);
-    let mut y4 = std::hint::black_box(vec![0.0; 5]);
-
-    let mut y5 = std::hint::black_box(vec![0.0; 5]);
-
-    let mut y6 = std::hint::black_box(vec![0.0; 5]);
-
-    let mut dy1_1 = std::hint::black_box(vec![0.0; 5]);
-    let mut dy1_2 = std::hint::black_box(vec![0.0; 5]);
-    let mut dy1_3 = std::hint::black_box(vec![0.0; 5]);
-    let mut dy1_4 = std::hint::black_box(vec![0.0; 5]);
-
-    let mut dy2 = std::hint::black_box(vec![0.0; 20]);
-
-    let mut dy3_1 = std::hint::black_box(vec![0.0; 5]);
-    let mut dy3_2 = std::hint::black_box(vec![0.0; 5]);
-    let mut dy3_3 = std::hint::black_box(vec![0.0; 5]);
-    let mut dy3_4 = std::hint::black_box(vec![0.0; 5]);
-
-    // scalar.
-    //d_square1(&x1, &z1, &mut y1, &mut dy1_1);
-    //d_square1(&x1, &z2, &mut y2, &mut dy1_2);
-    //d_square1(&x1, &z3, &mut y3, &mut dy1_3);
-    //d_square1(&x1, &z4, &mut y4, &mut dy1_4);
-
-    // assert y1 == y2 == y3 == y4
-    //for i in 0..5 {
-    //    assert_eq!(y1[i], y2[i]);
-    //    assert_eq!(y1[i], y3[i]);
-    //    assert_eq!(y1[i], y4[i]);
-    //}
-
-    // batch mode A)
-    d_square2(&x1, &z5, &mut y5, &mut dy2);
-
-    // assert y1 == y2 == y3 == y4 == y5
-    //for i in 0..5 {
-    //    assert_eq!(y1[i], y5[i]);
-    //}
-
-    // batch mode B)
-    d_square3(&x1, &z1, &z2, &z3, &z4, &mut y6, &mut dy3_1, &mut dy3_2, &mut dy3_3, &mut dy3_4);
-    for i in 0..5 {
-        assert_eq!(y5[i], y6[i]);
-    }
-
-    for i in 0..5 {
-        assert_eq!(dy2[0..5][i], dy3_1[i]);
-        assert_eq!(dy2[5..10][i], dy3_2[i]);
-        assert_eq!(dy2[10..15][i], dy3_3[i]);
-        assert_eq!(dy2[15..20][i], dy3_4[i]);
-    }
-}
diff --git a/tests/codegen/autovec/dont-shuffle-bswaps-opt2.rs b/tests/codegen/autovec/dont-shuffle-bswaps-opt2.rs
deleted file mode 100644
index c354228acc5..00000000000
--- a/tests/codegen/autovec/dont-shuffle-bswaps-opt2.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ compile-flags: -Copt-level=2
-
-#![crate_type = "lib"]
-#![no_std]
-
-// This test is paired with the arch-specific -opt3.rs test.
-
-// The code is from https://github.com/rust-lang/rust/issues/122805.
-// Ensure we do not generate the shufflevector instruction
-// to avoid complicating the code.
-
-// CHECK-LABEL: define{{.*}}void @convert(
-// CHECK-NOT: shufflevector
-#[no_mangle]
-pub fn convert(value: [u16; 8]) -> [u8; 16] {
-    #[cfg(target_endian = "little")]
-    let bswap = u16::to_be;
-    #[cfg(target_endian = "big")]
-    let bswap = u16::to_le;
-    let addr16 = [
-        bswap(value[0]),
-        bswap(value[1]),
-        bswap(value[2]),
-        bswap(value[3]),
-        bswap(value[4]),
-        bswap(value[5]),
-        bswap(value[6]),
-        bswap(value[7]),
-    ];
-    unsafe { core::mem::transmute::<_, [u8; 16]>(addr16) }
-}
diff --git a/tests/codegen/autovec/dont-shuffle-bswaps-opt3.rs b/tests/codegen/autovec/dont-shuffle-bswaps-opt3.rs
deleted file mode 100644
index 203d12005de..00000000000
--- a/tests/codegen/autovec/dont-shuffle-bswaps-opt3.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//@ revisions: AARCH64 X86_64 Z13
-//@ compile-flags: -Copt-level=3
-//@[AARCH64] only-aarch64
-//@[X86_64] only-x86_64
-//@[Z13] only-s390x
-//@[Z13] compile-flags: -Ctarget-cpu=z13
-
-#![crate_type = "lib"]
-#![no_std]
-
-// This test is paired with the arch-neutral -opt2.rs test
-
-// The code is from https://github.com/rust-lang/rust/issues/122805.
-// Ensure we do not generate the shufflevector instruction
-// to avoid complicating the code.
-
-// CHECK-LABEL: define{{.*}}void @convert(
-// CHECK-NOT: shufflevector
-
-// On higher opt levels, this should just be a bswap:
-// CHECK: load <8 x i16>
-// CHECK-NEXT: call <8 x i16> @llvm.bswap
-// CHECK-NEXT: store <8 x i16>
-// CHECK-NEXT: ret void
-#[no_mangle]
-pub fn convert(value: [u16; 8]) -> [u8; 16] {
-    #[cfg(target_endian = "little")]
-    let bswap = u16::to_be;
-    #[cfg(target_endian = "big")]
-    let bswap = u16::to_le;
-    let addr16 = [
-        bswap(value[0]),
-        bswap(value[1]),
-        bswap(value[2]),
-        bswap(value[3]),
-        bswap(value[4]),
-        bswap(value[5]),
-        bswap(value[6]),
-        bswap(value[7]),
-    ];
-    unsafe { core::mem::transmute::<_, [u8; 16]>(addr16) }
-}
diff --git a/tests/codegen/autovectorize-f32x4.rs b/tests/codegen/autovectorize-f32x4.rs
deleted file mode 100644
index 254362842f9..00000000000
--- a/tests/codegen/autovectorize-f32x4.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//@ compile-flags: -C opt-level=3 -Z merge-functions=disabled
-//@ only-x86_64
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @auto_vectorize_direct
-#[no_mangle]
-pub fn auto_vectorize_direct(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
-    // CHECK: load <4 x float>
-    // CHECK: load <4 x float>
-    // CHECK: fadd <4 x float>
-    // CHECK: store <4 x float>
-    [a[0] + b[0], a[1] + b[1], a[2] + b[2], a[3] + b[3]]
-}
-
-// CHECK-LABEL: @auto_vectorize_loop
-#[no_mangle]
-pub fn auto_vectorize_loop(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
-    // CHECK: load <4 x float>
-    // CHECK: load <4 x float>
-    // CHECK: fadd <4 x float>
-    // CHECK: store <4 x float>
-    let mut c = [0.0; 4];
-    for i in 0..4 {
-        c[i] = a[i] + b[i];
-    }
-    c
-}
-
-// CHECK-LABEL: @auto_vectorize_array_from_fn
-#[no_mangle]
-pub fn auto_vectorize_array_from_fn(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
-    // CHECK: load <4 x float>
-    // CHECK: load <4 x float>
-    // CHECK: fadd <4 x float>
-    // CHECK: store <4 x float>
-    std::array::from_fn(|i| a[i] + b[i])
-}
diff --git a/tests/codegen/auxiliary/extern_decl.rs b/tests/codegen/auxiliary/extern_decl.rs
deleted file mode 100644
index d17e77b1444..00000000000
--- a/tests/codegen/auxiliary/extern_decl.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Auxiliary crate that exports a function and static. Both always
-// evaluate to `71`. We force mutability on the static to prevent
-// it from being inlined as constant.
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn extern_fn() -> u8 {
-    unsafe { extern_static }
-}
-
-#[no_mangle]
-pub static mut extern_static: u8 = 71;
diff --git a/tests/codegen/auxiliary/nounwind.rs b/tests/codegen/auxiliary/nounwind.rs
deleted file mode 100644
index 40f66442c6e..00000000000
--- a/tests/codegen/auxiliary/nounwind.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-#[no_mangle]
-pub fn bar() {}
diff --git a/tests/codegen/auxiliary/thread_local_aux.rs b/tests/codegen/auxiliary/thread_local_aux.rs
deleted file mode 100644
index bebaa7754dd..00000000000
--- a/tests/codegen/auxiliary/thread_local_aux.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#![crate_type = "lib"]
-
-use std::cell::Cell;
-
-thread_local!(pub static A: Cell<u64> = const { Cell::new(0) });
diff --git a/tests/codegen/avr/avr-func-addrspace.rs b/tests/codegen/avr/avr-func-addrspace.rs
deleted file mode 100644
index e0192f8b45a..00000000000
--- a/tests/codegen/avr/avr-func-addrspace.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 --target=avr-none -C target-cpu=atmega328p --crate-type=rlib -C panic=abort
-//@ needs-llvm-components: avr
-
-// This test validates that function pointers can be stored in global variables
-// and called upon. It ensures that Rust emits function pointers in the correct
-// address space to LLVM so that an assertion error relating to casting is
-// not triggered.
-//
-// It also validates that functions can be called through function pointers
-// through traits.
-
-#![feature(no_core, lang_items, intrinsics, unboxed_closures, arbitrary_self_types)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[rustc_intrinsic]
-pub unsafe fn transmute<Src, Dst>(src: Src) -> Dst;
-
-pub static mut STORAGE_FOO: fn(&usize, &mut u32) -> Result<(), ()> = arbitrary_black_box;
-pub static mut STORAGE_BAR: u32 = 12;
-
-fn arbitrary_black_box(ptr: &usize, _: &mut u32) -> Result<(), ()> {
-    let raw_ptr = ptr as *const usize;
-    let _v: usize = unsafe { *raw_ptr };
-    loop {}
-}
-
-#[inline(never)]
-#[no_mangle]
-fn call_through_fn_trait(a: &mut impl Fn<(), Output = ()>) {
-    (*a)()
-}
-
-#[inline(never)]
-fn update_bar_value() {
-    unsafe {
-        STORAGE_BAR = 88;
-    }
-}
-
-// CHECK: define dso_local void @test(){{.+}}addrspace(1)
-#[no_mangle]
-pub extern "C" fn test() {
-    let mut buf = 7;
-
-    // A call through the Fn trait must use address space 1.
-    //
-    // CHECK: call{{.+}}addrspace(1) void @call_through_fn_trait({{.*}})
-    call_through_fn_trait(&mut update_bar_value);
-
-    // A call through a global variable must use address space 1.
-    // CHECK: load {{.*}}addrspace(1){{.+}}FOO
-    unsafe {
-        STORAGE_FOO(&1, &mut buf);
-    }
-}
-
-// Validate that we can codegen transmutes between data ptrs and fn ptrs.
-
-// CHECK: define{{.+}}ptr addrspace(1) @transmute_data_ptr_to_fn(ptr{{.*}} %x)
-#[no_mangle]
-pub unsafe fn transmute_data_ptr_to_fn(x: *const ()) -> fn() {
-    // It doesn't matter precisely how this is codegenned (through memory or an addrspacecast),
-    // as long as it doesn't cause a verifier error by using `bitcast`.
-    transmute(x)
-}
-
-// CHECK: define{{.+}}ptr @transmute_fn_ptr_to_data(ptr addrspace(1){{.*}} %x)
-#[no_mangle]
-pub unsafe fn transmute_fn_ptr_to_data(x: fn()) -> *const () {
-    // It doesn't matter precisely how this is codegenned (through memory or an addrspacecast),
-    // as long as it doesn't cause a verifier error by using `bitcast`.
-    transmute(x)
-}
-
-pub enum Either<T, U> {
-    A(T),
-    B(U),
-}
-
-// Previously, we would codegen this as passing/returning a scalar pair of `{ i8, ptr }`,
-// with the `ptr` field representing both `&i32` and `fn()` depending on the variant.
-// This is incorrect, because `fn()` should be `ptr addrspace(1)`, not `ptr`.
-
-// CHECK: define{{.+}}void @should_not_combine_addrspace(ptr{{.+}}sret{{.+}}%_0, ptr{{.+}}%x)
-#[no_mangle]
-#[inline(never)]
-pub fn should_not_combine_addrspace(x: Either<&i32, fn()>) -> Either<&i32, fn()> {
-    x
-}
-
-// The incorrectness described above would result in us producing (after optimizations)
-// a `ptrtoint`/`inttoptr` roundtrip to convert from `ptr` to `ptr addrspace(1)`.
-
-// CHECK-LABEL: @call_with_fn_ptr
-#[no_mangle]
-pub fn call_with_fn_ptr<'a>(f: fn()) -> Either<&'a i32, fn()> {
-    // CHECK-NOT: ptrtoint
-    // CHECK-NOT: inttoptr
-    // CHECK: call addrspace(1) void @should_not_combine_addrspace
-    should_not_combine_addrspace(Either::B(f))
-}
diff --git a/tests/codegen/bigint-helpers.rs b/tests/codegen/bigint-helpers.rs
deleted file mode 100644
index 355cccb8150..00000000000
--- a/tests/codegen/bigint-helpers.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -C opt-level=3
-
-#![crate_type = "lib"]
-#![feature(bigint_helper_methods)]
-
-// CHECK-LABEL: @u32_carrying_add
-#[no_mangle]
-pub fn u32_carrying_add(a: u32, b: u32, c: bool) -> (u32, bool) {
-    // CHECK: @llvm.uadd.with.overflow.i32
-    // CHECK: @llvm.uadd.with.overflow.i32
-    // CHECK: or disjoint i1
-    u32::carrying_add(a, b, c)
-}
diff --git a/tests/codegen/binary-heap-peek-mut-pop-no-panic.rs b/tests/codegen/binary-heap-peek-mut-pop-no-panic.rs
deleted file mode 100644
index 2c40327f624..00000000000
--- a/tests/codegen/binary-heap-peek-mut-pop-no-panic.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ ignore-std-debug-assertions
-#![crate_type = "lib"]
-
-use std::collections::binary_heap::PeekMut;
-
-// CHECK-LABEL: @peek_mut_pop
-#[no_mangle]
-pub fn peek_mut_pop(peek_mut: PeekMut<u32>) -> u32 {
-    // CHECK-NOT: panic
-    // CHECK-NOT: unwrap_failed
-    PeekMut::pop(peek_mut)
-}
diff --git a/tests/codegen/binary-search-index-no-bound-check.rs b/tests/codegen/binary-search-index-no-bound-check.rs
deleted file mode 100644
index d59c0beec64..00000000000
--- a/tests/codegen/binary-search-index-no-bound-check.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// Make sure no bounds checks are emitted when slicing or indexing
-// with an index from `binary_search`.
-
-// CHECK-LABEL: @binary_search_index_no_bounds_check
-#[no_mangle]
-pub fn binary_search_index_no_bounds_check(s: &[u8]) -> u8 {
-    // CHECK-NOT: panic
-    // CHECK-NOT: slice_start_index_len_fail
-    // CHECK-NOT: slice_end_index_len_fail
-    // CHECK-NOT: panic_bounds_check
-    if let Ok(idx) = s.binary_search(&b'\\') { s[idx] } else { 42 }
-}
-
-// Similarly, check that `partition_point` is known to return a valid fencepost.
-
-// CHECK-LABEL: @unknown_split
-#[no_mangle]
-pub fn unknown_split(x: &[i32], i: usize) -> (&[i32], &[i32]) {
-    // This just makes sure that the subsequent function is looking for the
-    // absence of something that might actually be there.
-
-    // CHECK: call core::panicking::panic
-    x.split_at(i)
-}
-
-// CHECK-LABEL: @partition_point_split_no_bounds_check
-#[no_mangle]
-pub fn partition_point_split_no_bounds_check(x: &[i32], needle: i32) -> (&[i32], &[i32]) {
-    // CHECK-NOT: call core::panicking::panic
-    let i = x.partition_point(|p| p < &needle);
-    x.split_at(i)
-}
diff --git a/tests/codegen/bool-cmp.rs b/tests/codegen/bool-cmp.rs
deleted file mode 100644
index 71d3411689f..00000000000
--- a/tests/codegen/bool-cmp.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// This is a test for optimal Ord trait implementation for bool.
-// See <https://github.com/rust-lang/rust/issues/66780> for more info.
-
-//@ compile-flags: -C opt-level=3
-
-#![crate_type = "lib"]
-
-use std::cmp::Ordering;
-
-// CHECK-LABEL: @cmp_bool
-#[no_mangle]
-pub fn cmp_bool(a: bool, b: bool) -> Ordering {
-    // LLVM 10 produces (zext a) + (sext b), but the final lowering is (zext a) - (zext b).
-    // CHECK: zext i1
-    // CHECK: {{z|s}}ext i1
-    // CHECK: {{sub|add}} nsw
-    a.cmp(&b)
-}
diff --git a/tests/codegen/bounds-checking/gep-issue-133979.rs b/tests/codegen/bounds-checking/gep-issue-133979.rs
deleted file mode 100644
index 876bdbfb0e1..00000000000
--- a/tests/codegen/bounds-checking/gep-issue-133979.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//! Issue: <https://github.com/rust-lang/rust/issues/133979>
-//! Check that bounds checking are eliminated.
-
-//@ compile-flags: -Copt-level=2
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @test(
-#[no_mangle]
-fn test(a: &[&[u8]]) -> u32 {
-    // CHECK-NOT: panic_bounds_check
-    a.iter()
-        .enumerate()
-        .map(|(y, b)| {
-            b.iter()
-                .enumerate()
-                .filter(|(_, c)| **c == b'A')
-                .map(|(x, _)| a[y][x] as u32)
-                .sum::<u32>()
-        })
-        .sum()
-}
diff --git a/tests/codegen/box-default-debug-copies.rs b/tests/codegen/box-default-debug-copies.rs
deleted file mode 100644
index 06cc41b21c0..00000000000
--- a/tests/codegen/box-default-debug-copies.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ compile-flags: -Copt-level=0
-
-// Test to make sure that `<Box<T>>::default` does not create too many copies of `T` on the stack.
-// in debug mode. This regressed in dd0620b86721ae8cae86736443acd3f72ba6fc32 to
-// four `T` allocas.
-//
-// See https://github.com/rust-lang/rust/issues/136043 for more context.
-//
-// FIXME: This test only wants to ensure that there are at most two allocas of `T` created, instead
-// of checking for exactly two.
-
-#![crate_type = "lib"]
-
-#[allow(dead_code)]
-pub struct Thing([u8; 1000000]);
-
-impl Default for Thing {
-    fn default() -> Self {
-        Thing([0; 1000000])
-    }
-}
-
-// CHECK-COUNT-2: %{{.*}} = alloca {{.*}}1000000
-// CHECK-NOT: %{{.*}} = alloca {{.*}}1000000
-#[no_mangle]
-pub fn box_default_single_copy() -> Box<Thing> {
-    Box::default()
-}
diff --git a/tests/codegen/box-uninit-bytes.rs b/tests/codegen/box-uninit-bytes.rs
deleted file mode 100644
index 0cc01148595..00000000000
--- a/tests/codegen/box-uninit-bytes.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-use std::mem::MaybeUninit;
-
-// Boxing a `MaybeUninit` value should not copy junk from the stack
-#[no_mangle]
-pub fn box_uninitialized() -> Box<MaybeUninit<usize>> {
-    // CHECK-LABEL: @box_uninitialized
-    // CHECK-NOT: store
-    // CHECK-NOT: alloca
-    // CHECK-NOT: memcpy
-    // CHECK-NOT: memset
-    Box::new(MaybeUninit::uninit())
-}
-
-// https://github.com/rust-lang/rust/issues/58201
-#[no_mangle]
-pub fn box_uninitialized2() -> Box<MaybeUninit<[usize; 1024 * 1024]>> {
-    // CHECK-LABEL: @box_uninitialized2
-    // CHECK-NOT: store
-    // CHECK-NOT: alloca
-    // CHECK-NOT: memcpy
-    // CHECK-NOT: memset
-    Box::new(MaybeUninit::uninit())
-}
-
-#[repr(align(1024))]
-pub struct LotsaPadding(usize);
-
-// Boxing a value with padding should not copy junk from the stack
-#[no_mangle]
-pub fn box_lotsa_padding() -> Box<LotsaPadding> {
-    // CHECK-LABEL: @box_lotsa_padding
-    // CHECK-NOT: alloca
-    // CHECK-NOT: getelementptr
-    // CHECK-NOT: memcpy
-    // CHECK-NOT: memset
-    Box::new(LotsaPadding(42))
-}
-
-// Hide the `allocalign` attribute in the declaration of __rust_alloc
-// from the CHECK-NOT above, and also verify the attributes got set reasonably.
-// CHECK: declare {{(dso_local )?}}noalias noundef ptr @{{.*}}__rust_alloc(i{{[0-9]+}} noundef, i{{[0-9]+}} allocalign noundef) unnamed_addr [[RUST_ALLOC_ATTRS:#[0-9]+]]
-
-// CHECK-DAG: attributes [[RUST_ALLOC_ATTRS]] = { {{.*}} allockind("alloc,uninitialized,aligned") allocsize(0) {{(uwtable )?}}"alloc-family"="__rust_alloc" {{.*}} }
diff --git a/tests/codegen/bpf-alu32.rs b/tests/codegen/bpf-alu32.rs
deleted file mode 100644
index 5955bf3317f..00000000000
--- a/tests/codegen/bpf-alu32.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ only-bpf
-#![crate_type = "lib"]
-#![feature(bpf_target_feature)]
-#![no_std]
-
-#[no_mangle]
-#[target_feature(enable = "alu32")]
-// CHECK: define i8 @foo(i8 returned %arg) unnamed_addr #0 {
-pub unsafe fn foo(arg: u8) -> u8 {
-    arg
-}
diff --git a/tests/codegen/branch-protection.rs b/tests/codegen/branch-protection.rs
deleted file mode 100644
index d67e494cc0d..00000000000
--- a/tests/codegen/branch-protection.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-// Test that the correct module flags are emitted with different branch protection flags.
-
-//@ add-core-stubs
-//@ revisions: BTI PACRET LEAF BKEY PAUTHLR PAUTHLR_BKEY PAUTHLR_LEAF PAUTHLR_BTI NONE
-//@ needs-llvm-components: aarch64
-//@ [BTI] compile-flags: -Z branch-protection=bti
-//@ [PACRET] compile-flags: -Z branch-protection=pac-ret
-//@ [LEAF] compile-flags: -Z branch-protection=pac-ret,leaf
-//@ [BKEY] compile-flags: -Z branch-protection=pac-ret,b-key
-//@ [PAUTHLR] compile-flags: -Z branch-protection=pac-ret,pc
-//@ [PAUTHLR_BKEY] compile-flags: -Z branch-protection=pac-ret,pc,b-key
-//@ [PAUTHLR_LEAF] compile-flags: -Z branch-protection=pac-ret,pc,leaf
-//@ [PAUTHLR_BTI] compile-flags: -Z branch-protection=bti,pac-ret,pc
-//@ compile-flags: --target aarch64-unknown-linux-gnu
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// A basic test function.
-// CHECK: @test(){{.*}} [[ATTR:#[0-9]+]] {
-#[no_mangle]
-pub fn test() {}
-
-// BTI: attributes [[ATTR]] = {{.*}} "branch-target-enforcement"
-// BTI: !"branch-target-enforcement", i32 1
-// BTI: !"sign-return-address", i32 0
-// BTI: !"branch-protection-pauth-lr", i32 0
-// BTI: !"sign-return-address-all", i32 0
-// BTI: !"sign-return-address-with-bkey", i32 0
-
-// PACRET: attributes [[ATTR]] = {{.*}} "sign-return-address"="non-leaf"
-// PACRET-SAME: "sign-return-address-key"="a_key"
-// PACRET: !"branch-target-enforcement", i32 0
-// PACRET: !"sign-return-address", i32 1
-// PACRET: !"branch-protection-pauth-lr", i32 0
-// PACRET: !"sign-return-address-all", i32 0
-// PACRET: !"sign-return-address-with-bkey", i32 0
-
-// LEAF: attributes [[ATTR]] = {{.*}} "sign-return-address"="all"
-// LEAF-SAME: "sign-return-address-key"="a_key"
-// LEAF: !"branch-target-enforcement", i32 0
-// LEAF: !"sign-return-address", i32 1
-// LEAF: !"branch-protection-pauth-lr", i32 0
-// LEAF: !"sign-return-address-all", i32 1
-// LEAF: !"sign-return-address-with-bkey", i32 0
-
-// BKEY: attributes [[ATTR]] = {{.*}} "sign-return-address"="non-leaf"
-// BKEY-SAME: "sign-return-address-key"="b_key"
-// BKEY: !"branch-target-enforcement", i32 0
-// BKEY: !"sign-return-address", i32 1
-// BKEY: !"branch-protection-pauth-lr", i32 0
-// BKEY: !"sign-return-address-all", i32 0
-// BKEY: !"sign-return-address-with-bkey", i32 1
-
-// PAUTHLR: attributes [[ATTR]] = {{.*}} "sign-return-address"="non-leaf"
-// PAUTHLR-SAME: "sign-return-address-key"="a_key"
-// PAUTHLR: !"branch-target-enforcement", i32 0
-// PAUTHLR: !"sign-return-address", i32 1
-// PAUTHLR: !"branch-protection-pauth-lr", i32 1
-// PAUTHLR: !"sign-return-address-all", i32 0
-// PAUTHLR: !"sign-return-address-with-bkey", i32 0
-
-// PAUTHLR_BKEY: attributes [[ATTR]] = {{.*}} "sign-return-address"="non-leaf"
-// PAUTHLR_BKEY-SAME: "sign-return-address-key"="b_key"
-// PAUTHLR_BKEY: !"branch-target-enforcement", i32 0
-// PAUTHLR_BKEY: !"sign-return-address", i32 1
-// PAUTHLR_BKEY: !"branch-protection-pauth-lr", i32 1
-// PAUTHLR_BKEY: !"sign-return-address-all", i32 0
-// PAUTHLR_BKEY: !"sign-return-address-with-bkey", i32 1
-
-// PAUTHLR_LEAF: attributes [[ATTR]] = {{.*}} "sign-return-address"="all"
-// PAUTHLR_LEAF-SAME: "sign-return-address-key"="a_key"
-// PAUTHLR_LEAF: !"branch-target-enforcement", i32 0
-// PAUTHLR_LEAF: !"sign-return-address", i32 1
-// PAUTHLR_LEAF: !"branch-protection-pauth-lr", i32 1
-// PAUTHLR_LEAF: !"sign-return-address-all", i32 1
-// PAUTHLR_LEAF: !"sign-return-address-with-bkey", i32 0
-
-// PAUTHLR_BTI: attributes [[ATTR]] = {{.*}} "sign-return-address"="non-leaf"
-// PAUTHLR_BTI-SAME: "sign-return-address-key"="a_key"
-// PAUTHLR_BTI: !"branch-target-enforcement", i32 1
-// PAUTHLR_BTI: !"sign-return-address", i32 1
-// PAUTHLR_BTI: !"branch-protection-pauth-lr", i32 1
-// PAUTHLR_BTI: !"sign-return-address-all", i32 0
-// PAUTHLR_BTI: !"sign-return-address-with-bkey", i32 0
-
-// NONE-NOT: branch-target-enforcement
-// NONE-NOT: sign-return-address
-// NONE-NOT: sign-return-address-all
-// NONE-NOT: sign-return-address-with-bkey
diff --git a/tests/codegen/call-llvm-intrinsics.rs b/tests/codegen/call-llvm-intrinsics.rs
deleted file mode 100644
index dc7e0249cb6..00000000000
--- a/tests/codegen/call-llvm-intrinsics.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-
-//@ ignore-riscv64
-//@ ignore-loongarch64
-
-#![feature(link_llvm_intrinsics)]
-#![crate_type = "lib"]
-
-struct A;
-
-impl Drop for A {
-    fn drop(&mut self) {
-        println!("A");
-    }
-}
-
-extern "C" {
-    #[link_name = "llvm.sqrt.f32"]
-    fn sqrt(x: f32) -> f32;
-}
-
-pub fn do_call() {
-    let _a = A;
-
-    unsafe {
-        // Ensure that we `call` LLVM intrinsics instead of trying to `invoke` them
-        // CHECK: call float @llvm.sqrt.f32(float 4.000000e+00
-        sqrt(4.0);
-    }
-}
diff --git a/tests/codegen/call-tmps-lifetime.rs b/tests/codegen/call-tmps-lifetime.rs
deleted file mode 100644
index 7b7b6e17bdd..00000000000
--- a/tests/codegen/call-tmps-lifetime.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-// Test that temporary allocas used for call arguments have their lifetimes described by
-// intrinsics.
-//
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=1 -Cno-prepopulate-passes --crate-type=lib --target i686-unknown-linux-gnu
-//@ needs-llvm-components: x86
-#![feature(no_core)]
-#![no_std]
-#![no_core]
-extern crate minicore;
-use minicore::*;
-
-// Const operand. Regression test for #98156.
-//
-// CHECK-LABEL: define void @const_indirect(
-// CHECK-NEXT: start:
-// CHECK-NEXT: [[B:%.*]] = alloca
-// CHECK-NEXT: [[A:%.*]] = alloca
-// CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4096, ptr [[A]])
-// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[A]], ptr align 4 {{.*}}, i32 4096, i1 false)
-// CHECK-NEXT: call void %h(ptr {{.*}} [[A]])
-// CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4096, ptr [[A]])
-// CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4096, ptr [[B]])
-// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[B]], ptr align 4 {{.*}}, i32 4096, i1 false)
-// CHECK-NEXT: call void %h(ptr {{.*}} [[B]])
-// CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4096, ptr [[B]])
-#[no_mangle]
-pub fn const_indirect(h: extern "C" fn([u32; 1024])) {
-    const C: [u32; 1024] = [0; 1024];
-    h(C);
-    h(C);
-}
-
-#[repr(C)]
-pub struct Str {
-    pub ptr: *const u8,
-    pub len: usize,
-}
-
-// Pair of immediates. Regression test for #132014.
-//
-// CHECK-LABEL: define void @immediate_indirect(ptr {{.*}}%s.0, i32 {{.*}}%s.1, ptr {{.*}}%g)
-// CHECK-NEXT: start:
-// CHECK-NEXT: [[A:%.*]] = alloca
-// CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 8, ptr [[A]])
-// CHECK-NEXT: store ptr %s.0, ptr [[A]]
-// CHECK-NEXT: [[B:%.]] = getelementptr inbounds i8, ptr [[A]], i32 4
-// CHECK-NEXT: store i32 %s.1, ptr [[B]]
-// CHECK-NEXT: call void %g(ptr {{.*}} [[A]])
-// CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 8, ptr [[A]])
-#[no_mangle]
-pub fn immediate_indirect(s: Str, g: extern "C" fn(Str)) {
-    g(s);
-}
-
-// Indirect argument with a higher alignment requirement than the type's.
-//
-// CHECK-LABEL: define void @align_indirect(ptr{{.*}} align 1{{.*}} %a, ptr{{.*}} %fun)
-// CHECK-NEXT: start:
-// CHECK-NEXT: [[A:%.*]] = alloca [1024 x i8], align 4
-// CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 1024, ptr [[A]])
-// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[A]], ptr align 1 %a, i32 1024, i1 false)
-// CHECK-NEXT: call void %fun(ptr {{.*}} [[A]])
-// CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 1024, ptr [[A]])
-#[no_mangle]
-pub fn align_indirect(a: [u8; 1024], fun: extern "C" fn([u8; 1024])) {
-    fun(a);
-}
diff --git a/tests/codegen/cast-optimized.rs b/tests/codegen/cast-optimized.rs
deleted file mode 100644
index 11220c4a922..00000000000
--- a/tests/codegen/cast-optimized.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-#![crate_type = "lib"]
-
-// This tests that LLVM can optimize based on the niches in the source or
-// destination types for casts.
-
-// CHECK-LABEL: @u32_index
-#[no_mangle]
-pub fn u32_index(c: u32) -> [bool; 22] {
-    let mut array = [false; 22];
-
-    let index = 32 - c.leading_zeros();
-
-    // CHECK: call core::panicking::panic
-    array[index as usize] = true;
-
-    array
-}
-
-// CHECK-LABEL: @char_as_u32_index
-#[no_mangle]
-pub fn char_as_u32_index(c: char) -> [bool; 22] {
-    let c = c as u32;
-
-    let mut array = [false; 22];
-
-    let index = 32 - c.leading_zeros();
-
-    // CHECK-NOT: call core::panicking::panic
-    array[index as usize] = true;
-
-    array
-}
diff --git a/tests/codegen/cast-target-abi.rs b/tests/codegen/cast-target-abi.rs
deleted file mode 100644
index cbd49e2f022..00000000000
--- a/tests/codegen/cast-target-abi.rs
+++ /dev/null
@@ -1,599 +0,0 @@
-// ignore-tidy-linelength
-//@ add-core-stubs
-//@ revisions:aarch64 loongarch64 powerpc64 sparc64 x86_64
-//@ compile-flags: -Copt-level=3 -Cno-prepopulate-passes -Zlint-llvm-ir
-
-//@[aarch64] compile-flags: --target aarch64-unknown-linux-gnu
-//@[aarch64] needs-llvm-components: arm
-//@[loongarch64] compile-flags: --target loongarch64-unknown-linux-gnu
-//@[loongarch64] needs-llvm-components: loongarch
-//@[powerpc64] compile-flags: --target powerpc64-unknown-linux-gnu
-//@[powerpc64] needs-llvm-components: powerpc
-//@[sparc64] compile-flags: --target sparc64-unknown-linux-gnu
-//@[sparc64] needs-llvm-components: sparc
-//@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu
-//@[x86_64] needs-llvm-components: x86
-
-// Tests that arguments with `PassMode::Cast` are handled correctly.
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// This struct will be passed as a single `i64` or `i32`.
-// This may be (if `i64)) larger than the Rust layout, which is just `{ i16, i16 }`.
-#[repr(C)]
-pub struct TwoU16s {
-    a: u16,
-    b: u16,
-}
-
-// This struct will be passed as `[2 x i64]`.
-// This is larger than the Rust layout.
-#[repr(C)]
-pub struct FiveU16s {
-    a: u16,
-    b: u16,
-    c: u16,
-    d: u16,
-    e: u16,
-}
-
-// This struct will be passed as `[2 x double]`.
-// This is the same as the Rust layout.
-#[repr(C)]
-pub struct DoubleDouble {
-    f: f64,
-    g: f64,
-}
-
-// On loongarch, this struct will be passed as `{ double, float }`.
-// This is smaller than the Rust layout, which has trailing padding (`{ f64, f32, <f32 padding> }`)
-#[repr(C)]
-pub struct DoubleFloat {
-    f: f64,
-    g: f32,
-}
-
-// On x86_64, this struct will be passed as `{ i64, i32 }`.
-// The load and store instructions will access 16 bytes, so we should allocate 16 bytes.
-#[repr(C)]
-pub struct Three32s {
-    a: u32,
-    b: u32,
-    c: u32,
-}
-
-// CHECK-LABEL: @receives_twou16s
-// aarch64-SAME:     ([[ABI_TYPE:i64]] {{.*}}[[ABI_VALUE:%.+]])
-// loongarch64-SAME: ([[ABI_TYPE:i64]] {{.*}}[[ABI_VALUE:%.+]])
-// powerpc64-SAME:   ([[ABI_TYPE:i32]] {{.*}}[[ABI_VALUE:%.+]])
-// sparc64-SAME:     ([[ABI_TYPE:i64]] {{.*}}[[ABI_VALUE:%.+]])
-// x86_64-SAME:      ([[ABI_TYPE:i32]] {{.*}}[[ABI_VALUE:%.+]])
-#[no_mangle]
-#[inline(never)]
-pub extern "C" fn receives_twou16s(x: TwoU16s) {
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
-    // powerpc64:   [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:4]]
-    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:4]]
-
-    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
-
-    // CHECK: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 4, i1 false)
-}
-
-// CHECK-LABEL: @returns_twou16s
-// powerpc64-SAME: sret([4 x i8]) align [[RUST_ALIGN:2]] {{.*}}[[RET_PTR:%.*]])
-#[no_mangle]
-#[inline(never)]
-pub extern "C" fn returns_twou16s() -> TwoU16s {
-    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
-    // The other targets copy the cast ABI type to an alloca.
-
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:2]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:2]]
-    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:2]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:2]]
-
-    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i32]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // loongarch64: ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // sparc64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // x86_64:      ret [[ABI_TYPE]] [[ABI_VALUE]]
-    TwoU16s { a: 0, b: 1 }
-}
-
-// CHECK-LABEL: @receives_fiveu16s
-// aarch64-SAME:     ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
-// loongarch64-SAME: ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
-// powerpc64-SAME:   ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
-// sparc64-SAME:     ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
-// x86_64-SAME:      ([[ABI_TYPE:{ i64, i16 }]] {{.*}}[[ABI_VALUE:%.+]])
-#[no_mangle]
-#[inline(never)]
-pub extern "C" fn receives_fiveu16s(x: FiveU16s) {
-    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [10 x i8], align [[RUST_ALIGN:2]]
-
-    // CHECK: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 10, i1 false)
-}
-
-// CHECK-LABEL: @returns_fiveu16s
-// powerpc64-SAME: sret([10 x i8]) align [[RUST_ALIGN:2]] {{.*}}[[RET_PTR:%.*]])
-#[no_mangle]
-#[inline(never)]
-pub extern "C" fn returns_fiveu16s() -> FiveU16s {
-    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
-    // The other targets copy the cast ABI type to an alloca.
-
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:2]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:2]]
-    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:2]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:2]]
-
-    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ i64, i16 }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // loongarch64: ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // sparc64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // x86_64:      ret [[ABI_TYPE]] [[ABI_VALUE]]
-    FiveU16s { a: 0, b: 1, c: 2, d: 3, e: 4 }
-}
-
-// CHECK-LABEL: @receives_doubledouble
-// aarch64-SAME:     ([[ABI_TYPE:\[2 x double\]]] {{.*}}[[ABI_VALUE:%.+]])
-// loongarch64-SAME: ([[ABI_TYPE:{ double, double }]] {{.*}}[[ABI_VALUE:%.+]])
-// powerpc64-SAME:   ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
-// sparc64-SAME:     ([[ABI_TYPE:{ double, double }]] {{.*}}[[ABI_VALUE:%.+]])
-// x86_64-SAME:      ([[ABI_TYPE:{ double, double }]] {{.*}}[[ABI_VALUE:%.+]])
-#[no_mangle]
-#[inline(never)]
-pub extern "C" fn receives_doubledouble(x: DoubleDouble) {
-    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-
-    // CHECK: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
-}
-
-// CHECK-LABEL: @returns_doubledouble
-// powerpc64-SAME: sret([16 x i8]) align [[RUST_ALIGN:8]] {{.*}}[[RET_PTR:%.*]])
-#[no_mangle]
-#[inline(never)]
-pub extern "C" fn returns_doubledouble() -> DoubleDouble {
-    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
-    // The other targets copy the cast ABI type to an alloca.
-
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x double\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // loongarch64: ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // sparc64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // x86_64:      ret [[ABI_TYPE]] [[ABI_VALUE]]
-    DoubleDouble { f: 0., g: 1. }
-}
-
-// CHECK-LABEL: @receives_three32s
-// aarch64-SAME:     ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
-// loongarch64-SAME: ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
-// powerpc64-SAME:   ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
-// sparc64-SAME:     ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
-// x86_64-SAME:      ([[ABI_TYPE:{ i64, i32 }]] {{.*}}[[ABI_VALUE:%.+]])
-#[no_mangle]
-#[inline(never)]
-pub extern "C" fn receives_three32s(x: Three32s) {
-    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [12 x i8], align [[RUST_ALIGN:4]]
-
-    // CHECK: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
-}
-
-// CHECK-LABEL: @returns_three32s
-// powerpc64-SAME: sret([12 x i8]) align [[RUST_ALIGN:4]] {{.*}}[[RET_PTR:%.*]])
-#[no_mangle]
-#[inline(never)]
-pub extern "C" fn returns_three32s() -> Three32s {
-    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
-    // The other targets copy the cast ABI type to an alloca.
-
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:4]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:4]]
-    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:4]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:4]]
-
-    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ i64, i32 }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // loongarch64: ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // sparc64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // x86_64:      ret [[ABI_TYPE]] [[ABI_VALUE]]
-    Three32s { a: 0, b: 0, c: 0 }
-}
-
-// These functions cause an ICE in sparc64 ABI code (https://github.com/rust-lang/rust/issues/122620)
-#[cfg(not(target_arch = "sparc64"))]
-// aarch64-LABEL:     @receives_doublefloat
-// loongarch64-LABEL: @receives_doublefloat
-// powerpc64-LABEL:   @receives_doublefloat
-// x86_64-LABEL:      @receives_doublefloat
-
-// aarch64-SAME:     ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
-// loongarch64-SAME: ([[ABI_TYPE:{ double, float }]] {{.*}}[[ABI_VALUE:%.+]])
-// powerpc64-SAME:   ([[ABI_TYPE:\[2 x i64\]]] {{.*}}[[ABI_VALUE:%.+]])
-// x86_64-SAME:      ([[ABI_TYPE:{ double, double }]] {{.*}}[[ABI_VALUE:%.+]])
-#[no_mangle]
-#[inline(never)]
-pub extern "C" fn receives_doublefloat(x: DoubleFloat) {
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // powerpc64:   [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // aarch64:     [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-    // loongarch64: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-    // powerpc64:   [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-    // x86_64:      [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-
-    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // powerpc64:   store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
-    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
-    // powerpc64:   call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
-    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
-}
-
-#[cfg(not(target_arch = "sparc64"))]
-// aarch64-LABEL:     @returns_doublefloat
-// loongarch64-LABEL: @returns_doublefloat
-// powerpc64-LABEL:   @returns_doublefloat
-// x86_64-LABEL:      @returns_doublefloat
-
-// powerpc64-SAME: sret([16 x i8]) align [[RUST_ALIGN:8]] {{.*}}[[RET_PTR:%.*]])
-#[no_mangle]
-#[inline(never)]
-pub extern "C" fn returns_doublefloat() -> DoubleFloat {
-    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
-    // The other targets copy the cast ABI type to an alloca.
-
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, float }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // loongarch64: ret [[ABI_TYPE]] [[ABI_VALUE]]
-    // x86_64:      ret [[ABI_TYPE]] [[ABI_VALUE]]
-    DoubleFloat { f: 0., g: 0. }
-}
-
-// CHECK-LABEL: @call_twou16s
-#[no_mangle]
-pub fn call_twou16s() {
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
-    // powerpc64:   [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:4]]
-    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:4]]
-
-    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
-
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 4, i1 false)
-
-    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i32]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i64]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:i32]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // CHECK: call void @receives_twou16s([[ABI_TYPE]] [[ABI_VALUE]])
-    let x = TwoU16s { a: 1, b: 2 };
-    receives_twou16s(x);
-}
-
-// CHECK-LABEL: @return_twou16s
-#[no_mangle]
-pub fn return_twou16s() -> TwoU16s {
-    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
-
-    // powerpc64: [[RETVAL:%.+]] = alloca [4 x i8], align 2
-    // powerpc64: call void @returns_twou16s(ptr {{.+}} [[RETVAL]])
-
-    // The other targets copy the cast ABI type to an alloca.
-
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
-    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [8 x i8], align [[ABI_ALIGN:8]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [4 x i8], align [[ABI_ALIGN:4]]
-
-    // aarch64:     [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
-    // loongarch64: [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
-    // sparc64:     [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
-    // x86_64:      [[RUST_ALLOCA:%.+]] = alloca [4 x i8], align [[RUST_ALIGN:2]]
-
-    // aarch64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:i64]] @returns_twou16s()
-    // loongarch64: [[ABI_VALUE:%.+]] = call [[ABI_TYPE:i64]] @returns_twou16s()
-    // sparc64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:i64]] @returns_twou16s()
-    // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:i32]] @returns_twou16s()
-
-    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 4, i1 false)
-    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 4, i1 false)
-    // sparc64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 4, i1 false)
-    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 4, i1 false)
-    returns_twou16s()
-}
-
-// CHECK-LABEL: @call_fiveu16s
-#[no_mangle]
-pub fn call_fiveu16s() {
-    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [10 x i8], align 2
-
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 10, i1 false)
-
-    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ i64, i16 }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // CHECK: call void @receives_fiveu16s([[ABI_TYPE]] [[ABI_VALUE]])
-    let x = FiveU16s { a: 1, b: 2, c: 3, d: 4, e: 5 };
-    receives_fiveu16s(x);
-}
-
-// CHECK-LABEL: @return_fiveu16s
-// CHECK-SAME: (ptr {{.+}} sret([10 x i8]) align [[RUST_ALIGN:2]] {{.*}}dereferenceable(10) [[RET_PTR:%.+]])
-#[no_mangle]
-pub fn return_fiveu16s() -> FiveU16s {
-    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
-
-    // powerpc64: call void @returns_fiveu16s(ptr {{.+}} [[RET_PTR]])
-
-    // The other targets copy the cast ABI type to the sret pointer.
-
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // aarch64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_fiveu16s()
-    // loongarch64: [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_fiveu16s()
-    // sparc64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_fiveu16s()
-    // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ i64, i16 }]] @returns_fiveu16s()
-
-    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RET_PTR]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 10, i1 false)
-    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RET_PTR]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 10, i1 false)
-    // sparc64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RET_PTR]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 10, i1 false)
-    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RET_PTR]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 10, i1 false)
-    returns_fiveu16s()
-}
-
-// CHECK-LABEL: @call_doubledouble
-#[no_mangle]
-pub fn call_doubledouble() {
-    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 16, i1 false)
-
-    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x double\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // CHECK: call void @receives_doubledouble([[ABI_TYPE]] [[ABI_VALUE]])
-    let x = DoubleDouble { f: 1., g: 2. };
-    receives_doubledouble(x);
-}
-
-// CHECK-LABEL: @return_doubledouble
-#[no_mangle]
-pub fn return_doubledouble() -> DoubleDouble {
-    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
-
-    // powerpc64: [[RETVAL:%.+]] = alloca [16 x i8], align 8
-    // powerpc64: call void @returns_doubledouble(ptr {{.+}} [[RETVAL]])
-
-    // The other targets copy the cast ABI type to an alloca.
-
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // aarch64:     [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-    // loongarch64: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-    // sparc64:     [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-    // x86_64:      [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-
-    // aarch64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x double\]]] @returns_doubledouble()
-    // loongarch64: [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, double }]] @returns_doubledouble()
-    // sparc64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, double }]] @returns_doubledouble()
-    // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, double }]] @returns_doubledouble()
-
-    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
-    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
-    // sparc64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
-    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
-    returns_doubledouble()
-}
-
-// This test causes an ICE in sparc64 ABI code (https://github.com/rust-lang/rust/issues/122620)
-#[cfg(not(target_arch = "sparc64"))]
-// aarch64-LABEL:     @call_doublefloat
-// loongarch64-LABEL: @call_doublefloat
-// powerpc64-LABEL:   @call_doublefloat
-// x86_64-LABEL:      @call_doublefloat
-#[no_mangle]
-pub fn call_doublefloat() {
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // powerpc64:   [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // aarch64:     [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-    // loongarch64: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-    // powerpc64:   [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-    // x86_64:      [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-
-    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 16, i1 false)
-    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 12, i1 false)
-    // powerpc64:   call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 16, i1 false)
-    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 16, i1 false)
-
-    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, float }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ double, double }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     call void @receives_doublefloat([[ABI_TYPE]] {{(inreg )?}}[[ABI_VALUE]])
-    // loongarch64: call void @receives_doublefloat([[ABI_TYPE]] {{(inreg )?}}[[ABI_VALUE]])
-    // powerpc64:   call void @receives_doublefloat([[ABI_TYPE]] {{(inreg )?}}[[ABI_VALUE]])
-    // x86_64:      call void @receives_doublefloat([[ABI_TYPE]] {{(inreg )?}}[[ABI_VALUE]])
-    let x = DoubleFloat { f: 1., g: 2. };
-    receives_doublefloat(x);
-}
-
-// This test causes an ICE in sparc64 ABI code (https://github.com/rust-lang/rust/issues/122620)
-#[cfg(not(target_arch = "sparc64"))]
-// aarch64-LABEL:     @return_doublefloat
-// loongarch64-LABEL: @return_doublefloat
-// powerpc64-LABEL:   @return_doublefloat
-// x86_64-LABEL:      @return_doublefloat
-#[no_mangle]
-pub fn return_doublefloat() -> DoubleFloat {
-    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
-
-    // powerpc64: [[RETVAL:%.+]] = alloca [16 x i8], align 8
-    // powerpc64: call void @returns_doublefloat(ptr {{.+}} [[RETVAL]])
-
-    // The other targets copy the cast ABI type to an alloca.
-
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // aarch64:     [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-    // loongarch64: [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-    // x86_64:      [[RUST_ALLOCA:%.+]] = alloca [16 x i8], align [[RUST_ALIGN:8]]
-
-    // aarch64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_doublefloat()
-    // loongarch64: [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, float }]] @returns_doublefloat()
-    // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ double, double }]] @returns_doublefloat()
-
-    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
-    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
-    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 16, i1 false)
-    returns_doublefloat()
-}
-
-// CHECK-LABEL: @call_three32s
-#[no_mangle]
-pub fn call_three32s() {
-    // CHECK: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // CHECK: [[RUST_ALLOCA:%.+]] = alloca [12 x i8], align [[RUST_ALIGN:4]]
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], ptr align [[RUST_ALIGN]] [[RUST_ALLOCA]], i64 12, i1 false)
-
-    // aarch64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // powerpc64:   [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     [[ABI_VALUE:%.+]] = load [[ABI_TYPE:\[2 x i64\]]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      [[ABI_VALUE:%.+]] = load [[ABI_TYPE:{ i64, i32 }]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // CHECK: call void @receives_three32s([[ABI_TYPE]] [[ABI_VALUE]])
-    let x = Three32s { a: 1, b: 2, c: 3 };
-    receives_three32s(x);
-}
-
-// Regression test for #75839
-// CHECK-LABEL: @return_three32s(
-// CHECK-SAME: sret([12 x i8]) align [[RUST_ALIGN:4]] {{.*}}[[RUST_RETVAL:%.*]])
-#[no_mangle]
-pub fn return_three32s() -> Three32s {
-    // powerpc returns this struct via sret pointer, it doesn't use the cast ABI.
-
-    // powerpc64: call void @returns_three32s(ptr {{.+}} [[RUST_RETVAL]])
-
-    // aarch64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // loongarch64: [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // sparc64:     [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-    // x86_64:      [[ABI_ALLOCA:%.+]] = alloca [16 x i8], align [[ABI_ALIGN:8]]
-
-    // aarch64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_three32s()
-    // loongarch64: [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_three32s()
-    // sparc64:     [[ABI_VALUE:%.+]] = call [[ABI_TYPE:\[2 x i64\]]] @returns_three32s()
-    // x86_64:      [[ABI_VALUE:%.+]] = call [[ABI_TYPE:{ i64, i32 }]] @returns_three32s()
-
-    // aarch64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // loongarch64: store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // sparc64:     store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-    // x86_64:      store [[ABI_TYPE]] [[ABI_VALUE]], ptr [[ABI_ALLOCA]], align [[ABI_ALIGN]]
-
-    // aarch64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_RETVAL]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
-    // loongarch64: call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_RETVAL]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
-    // sparc64:     call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_RETVAL]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
-    // x86_64:      call void @llvm.memcpy.{{.+}}(ptr align [[RUST_ALIGN]] [[RUST_RETVAL]], ptr align [[ABI_ALIGN]] [[ABI_ALLOCA]], i64 12, i1 false)
-    returns_three32s()
-}
diff --git a/tests/codegen/catch-unwind.rs b/tests/codegen/catch-unwind.rs
deleted file mode 100644
index d1ff55bcc28..00000000000
--- a/tests/codegen/catch-unwind.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-// On x86 the closure is inlined in foo() producing something like
-// define i32 @foo() [...] {
-// tail call void @bar() [...]
-// ret i32 0
-// }
-// On riscv the closure is another function, placed before fn foo so CHECK can't
-// find it
-//@ ignore-riscv64 FIXME
-// On s390x the closure is also in another function
-//@ ignore-s390x FIXME
-// On loongarch64 the closure is also in another function
-//@ ignore-loongarch64 FIXME
-
-#![crate_type = "lib"]
-
-extern "C" {
-    fn bar();
-}
-
-// CHECK-LABEL: @foo
-#[no_mangle]
-pub unsafe fn foo() -> i32 {
-    // CHECK: call void @bar
-    // CHECK: ret i32 0
-    std::panic::catch_unwind(|| {
-        bar();
-        0
-    })
-    .unwrap()
-}
diff --git a/tests/codegen/cdylib-external-inline-fns.rs b/tests/codegen/cdylib-external-inline-fns.rs
deleted file mode 100644
index 2e472ea68e8..00000000000
--- a/tests/codegen/cdylib-external-inline-fns.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "cdylib"]
-
-// CHECK: define{{( dso_local)?}} void @a()
-#[no_mangle]
-#[inline]
-pub extern "C" fn a() {}
-
-// CHECK: define{{( dso_local)?}} void @b()
-#[export_name = "b"]
-#[inline]
-pub extern "C" fn b() {}
-
-// CHECK: define{{( dso_local)?}} void @c()
-#[no_mangle]
-#[inline]
-extern "C" fn c() {}
-
-// CHECK: define{{( dso_local)?}} void @d()
-#[export_name = "d"]
-#[inline]
-extern "C" fn d() {}
-
-// CHECK: define{{( dso_local)?}} void @e()
-#[no_mangle]
-#[inline(always)]
-pub extern "C" fn e() {}
-
-// CHECK: define{{( dso_local)?}} void @f()
-#[export_name = "f"]
-#[inline(always)]
-pub extern "C" fn f() {}
-
-// CHECK: define{{( dso_local)?}} void @g()
-#[no_mangle]
-#[inline(always)]
-extern "C" fn g() {}
-
-// CHECK: define{{( dso_local)?}} void @h()
-#[export_name = "h"]
-#[inline(always)]
-extern "C" fn h() {}
diff --git a/tests/codegen/cf-protection.rs b/tests/codegen/cf-protection.rs
deleted file mode 100644
index f1349a5dcb9..00000000000
--- a/tests/codegen/cf-protection.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Test that the correct module flags are emitted with different control-flow protection flags.
-
-//@ add-core-stubs
-//@ revisions: undefined none branch return full
-//@ needs-llvm-components: x86
-//@ [undefined] compile-flags:
-//@ [none] compile-flags: -Z cf-protection=none
-//@ [branch] compile-flags: -Z cf-protection=branch
-//@ [return] compile-flags: -Z cf-protection=return
-//@ [full] compile-flags: -Z cf-protection=full
-//@ compile-flags: --target x86_64-unknown-linux-gnu
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// A basic test function.
-pub fn test() {}
-
-// undefined-NOT: !"cf-protection-branch"
-// undefined-NOT: !"cf-protection-return"
-
-// none-NOT: !"cf-protection-branch"
-// none-NOT: !"cf-protection-return"
-
-// branch-NOT: !"cf-protection-return"
-// branch: !"cf-protection-branch", i32 1
-// branch-NOT: !"cf-protection-return"
-
-// return-NOT: !"cf-protection-branch"
-// return: !"cf-protection-return", i32 1
-// return-NOT: !"cf-protection-branch"
-
-// full: !"cf-protection-branch", i32 1
-// full: !"cf-protection-return", i32 1
diff --git a/tests/codegen/cffi/c-variadic-copy.rs b/tests/codegen/cffi/c-variadic-copy.rs
deleted file mode 100644
index 4c61c4fcf68..00000000000
--- a/tests/codegen/cffi/c-variadic-copy.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Tests that `VaListImpl::clone` gets inlined into a call to `llvm.va_copy`
-
-#![crate_type = "lib"]
-#![feature(c_variadic)]
-#![no_std]
-use core::ffi::VaList;
-
-extern "C" {
-    fn foreign_c_variadic_1(_: VaList, ...);
-}
-
-pub unsafe extern "C" fn clone_variadic(ap: VaList) {
-    let mut ap2 = ap.clone();
-    // CHECK: call void @llvm.va_copy
-    foreign_c_variadic_1(ap2.as_va_list(), 42i32);
-}
diff --git a/tests/codegen/cffi/c-variadic-naked.rs b/tests/codegen/cffi/c-variadic-naked.rs
deleted file mode 100644
index 5843628b633..00000000000
--- a/tests/codegen/cffi/c-variadic-naked.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ needs-asm-support
-//@ only-x86_64
-
-// tests that `va_start` is not injected into naked functions
-
-#![crate_type = "lib"]
-#![feature(c_variadic)]
-#![no_std]
-
-#[unsafe(naked)]
-pub unsafe extern "C" fn c_variadic(_: usize, _: ...) {
-    // CHECK-NOT: va_start
-    // CHECK-NOT: alloca
-    core::arch::naked_asm!("ret")
-}
diff --git a/tests/codegen/cffi/c-variadic-opt.rs b/tests/codegen/cffi/c-variadic-opt.rs
deleted file mode 100644
index 7e544ee7f37..00000000000
--- a/tests/codegen/cffi/c-variadic-opt.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//@ compile-flags: -C opt-level=3
-
-#![crate_type = "lib"]
-#![feature(c_variadic)]
-#![no_std]
-use core::ffi::VaList;
-
-extern "C" {
-    fn vprintf(fmt: *const i8, ap: VaList) -> i32;
-}
-
-// Ensure that `va_start` and `va_end` are properly injected even
-// when the "spoofed" `VaListImpl` is not used.
-#[no_mangle]
-pub unsafe extern "C" fn c_variadic_no_use(fmt: *const i8, mut ap: ...) -> i32 {
-    // CHECK: call void @llvm.va_start
-    vprintf(fmt, ap.as_va_list())
-    // CHECK: call void @llvm.va_end
-}
-
-// Check that `VaListImpl::clone` gets inlined into a direct call to `llvm.va_copy`
-#[no_mangle]
-pub unsafe extern "C" fn c_variadic_clone(fmt: *const i8, mut ap: ...) -> i32 {
-    // CHECK: call void @llvm.va_start
-    let mut ap2 = ap.clone();
-    // CHECK: call void @llvm.va_copy
-    let res = vprintf(fmt, ap2.as_va_list());
-    res
-    // CHECK: call void @llvm.va_end
-}
diff --git a/tests/codegen/cffi/c-variadic.rs b/tests/codegen/cffi/c-variadic.rs
deleted file mode 100644
index 140d2f37f46..00000000000
--- a/tests/codegen/cffi/c-variadic.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-//@ needs-unwind
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-//
-
-#![crate_type = "lib"]
-#![feature(c_variadic)]
-#![no_std]
-use core::ffi::VaList;
-
-extern "C" {
-    fn foreign_c_variadic_0(_: i32, ...);
-    fn foreign_c_variadic_1(_: VaList, ...);
-}
-
-pub unsafe extern "C" fn use_foreign_c_variadic_0() {
-    // Ensure that we correctly call foreign C-variadic functions.
-    // CHECK: call void (i32, ...) @foreign_c_variadic_0([[PARAM:i32( signext)?]] 0)
-    foreign_c_variadic_0(0);
-    // CHECK: call void (i32, ...) @foreign_c_variadic_0([[PARAM]] 0, [[PARAM]] 42)
-    foreign_c_variadic_0(0, 42i32);
-    // CHECK: call void (i32, ...) @foreign_c_variadic_0([[PARAM]] 0, [[PARAM]] 42, [[PARAM]] 1024)
-    foreign_c_variadic_0(0, 42i32, 1024i32);
-    // CHECK: call void (i32, ...) @foreign_c_variadic_0([[PARAM]] 0, [[PARAM]] 42, [[PARAM]] 1024, [[PARAM]] 0)
-    foreign_c_variadic_0(0, 42i32, 1024i32, 0i32);
-}
-
-// Ensure that we do not remove the `va_list` passed to the foreign function when
-// removing the "spoofed" `VaListImpl` that is used by Rust defined C-variadics.
-pub unsafe extern "C" fn use_foreign_c_variadic_1_0(ap: VaList) {
-    // CHECK: call void ({{.*}}, ...) @foreign_c_variadic_1({{.*}} %ap)
-    foreign_c_variadic_1(ap);
-}
-
-pub unsafe extern "C" fn use_foreign_c_variadic_1_1(ap: VaList) {
-    // CHECK: call void ({{.*}}, ...) @foreign_c_variadic_1({{.*}} %ap, [[PARAM]] 42)
-    foreign_c_variadic_1(ap, 42i32);
-}
-pub unsafe extern "C" fn use_foreign_c_variadic_1_2(ap: VaList) {
-    // CHECK: call void ({{.*}}, ...) @foreign_c_variadic_1({{.*}} %ap, [[PARAM]] 2, [[PARAM]] 42)
-    foreign_c_variadic_1(ap, 2i32, 42i32);
-}
-
-pub unsafe extern "C" fn use_foreign_c_variadic_1_3(ap: VaList) {
-    // CHECK: call void ({{.*}}, ...) @foreign_c_variadic_1({{.*}} %ap, [[PARAM]] 2, [[PARAM]] 42, [[PARAM]] 0)
-    foreign_c_variadic_1(ap, 2i32, 42i32, 0i32);
-}
-
-// Ensure that `va_start` and `va_end` are properly injected.
-#[no_mangle]
-pub unsafe extern "C" fn c_variadic(n: i32, mut ap: ...) -> i32 {
-    // CHECK: call void @llvm.va_start
-    let mut sum = 0;
-    for _ in 0..n {
-        sum += ap.arg::<i32>();
-    }
-    sum
-    // CHECK: call void @llvm.va_end
-}
-
-// Ensure that we generate the correct `call` signature when calling a Rust
-// defined C-variadic.
-pub unsafe fn test_c_variadic_call() {
-    // CHECK: call [[RET:(signext )?i32]] (i32, ...) @c_variadic([[PARAM]] 0)
-    c_variadic(0);
-    // CHECK: call [[RET]] (i32, ...) @c_variadic([[PARAM]] 0, [[PARAM]] 42)
-    c_variadic(0, 42i32);
-    // CHECK: call [[RET]] (i32, ...) @c_variadic([[PARAM]] 0, [[PARAM]] 42, [[PARAM]] 1024)
-    c_variadic(0, 42i32, 1024i32);
-    // CHECK: call [[RET]] (i32, ...) @c_variadic([[PARAM]] 0, [[PARAM]] 42, [[PARAM]] 1024, [[PARAM]] 0)
-    c_variadic(0, 42i32, 1024i32, 0i32);
-}
diff --git a/tests/codegen/cffi/ffi-const.rs b/tests/codegen/cffi/ffi-const.rs
deleted file mode 100644
index 3ea9d517ec2..00000000000
--- a/tests/codegen/cffi/ffi-const.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-#![crate_type = "lib"]
-#![feature(ffi_const)]
-
-pub fn bar() {
-    unsafe { foo() }
-}
-
-extern "C" {
-    // CHECK-LABEL: declare{{.*}}void @foo()
-    // CHECK-SAME: [[ATTRS:#[0-9]+]]
-    // CHECK-DAG: attributes [[ATTRS]] = { {{.*}}memory(none){{.*}} }
-    #[unsafe(ffi_const)]
-    pub fn foo();
-}
diff --git a/tests/codegen/cffi/ffi-out-of-bounds-loads.rs b/tests/codegen/cffi/ffi-out-of-bounds-loads.rs
deleted file mode 100644
index 859386d2df8..00000000000
--- a/tests/codegen/cffi/ffi-out-of-bounds-loads.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-//@ add-core-stubs
-//@ revisions: linux apple
-//@ compile-flags: -Copt-level=0 -Cno-prepopulate-passes -Zlint-llvm-ir
-
-//@[linux] compile-flags: --target x86_64-unknown-linux-gnu
-//@[linux] needs-llvm-components: x86
-//@[apple] compile-flags: --target x86_64-apple-darwin
-//@[apple] needs-llvm-components: x86
-
-// Regression test for #29988
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C)]
-struct S {
-    f1: i32,
-    f2: i32,
-    f3: i32,
-}
-
-extern "C" {
-    fn foo(s: S);
-}
-
-// CHECK-LABEL: @test
-#[no_mangle]
-pub fn test() {
-    let s = S { f1: 1, f2: 2, f3: 3 };
-    unsafe {
-        // CHECK: [[ALLOCA:%.+]] = alloca [16 x i8], align 8
-        // CHECK: [[LOAD:%.+]] = load { i64, i32 }, ptr [[ALLOCA]], align 8
-        // CHECK: call void @foo({ i64, i32 } [[LOAD]])
-        foo(s);
-    }
-}
diff --git a/tests/codegen/cffi/ffi-pure.rs b/tests/codegen/cffi/ffi-pure.rs
deleted file mode 100644
index a61e80ecf65..00000000000
--- a/tests/codegen/cffi/ffi-pure.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-#![crate_type = "lib"]
-#![feature(ffi_pure)]
-
-pub fn bar() {
-    unsafe { foo() }
-}
-
-extern "C" {
-    // CHECK-LABEL: declare{{.*}}void @foo()
-    // CHECK-SAME: [[ATTRS:#[0-9]+]]
-    // CHECK-DAG: attributes [[ATTRS]] = { {{.*}}memory(read){{.*}} }
-    #[unsafe(ffi_pure)]
-    pub fn foo();
-}
diff --git a/tests/codegen/cfguard-checks.rs b/tests/codegen/cfguard-checks.rs
deleted file mode 100644
index cdf6406ad61..00000000000
--- a/tests/codegen/cfguard-checks.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ compile-flags: -C control-flow-guard=checks
-//@ only-msvc
-
-#![crate_type = "lib"]
-
-// A basic test function.
-pub fn test() {}
-
-// Ensure the module flag cfguard=2 is present
-// CHECK: !"cfguard", i32 2
diff --git a/tests/codegen/cfguard-disabled.rs b/tests/codegen/cfguard-disabled.rs
deleted file mode 100644
index 90915c0f0c6..00000000000
--- a/tests/codegen/cfguard-disabled.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ compile-flags: -C control-flow-guard=no
-//@ only-msvc
-
-#![crate_type = "lib"]
-
-// A basic test function.
-pub fn test() {}
-
-// Ensure the module flag cfguard is not present
-// CHECK-NOT: !"cfguard"
diff --git a/tests/codegen/cfguard-nochecks.rs b/tests/codegen/cfguard-nochecks.rs
deleted file mode 100644
index 5f386533ec1..00000000000
--- a/tests/codegen/cfguard-nochecks.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ compile-flags: -C control-flow-guard=nochecks
-//@ only-msvc
-
-#![crate_type = "lib"]
-
-// A basic test function.
-pub fn test() {}
-
-// Ensure the module flag cfguard=1 is present
-// CHECK: !"cfguard", i32 1
diff --git a/tests/codegen/cfguard-non-msvc.rs b/tests/codegen/cfguard-non-msvc.rs
deleted file mode 100644
index 1e6559aaf5d..00000000000
--- a/tests/codegen/cfguard-non-msvc.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ compile-flags: -C control-flow-guard
-//@ ignore-msvc
-
-#![crate_type = "lib"]
-
-// A basic test function.
-pub fn test() {}
-
-// Ensure the cfguard module flag is not added for non-MSVC targets.
-// CHECK-NOT: !"cfguard"
diff --git a/tests/codegen/char-ascii-branchless.rs b/tests/codegen/char-ascii-branchless.rs
deleted file mode 100644
index f99066aa9aa..00000000000
--- a/tests/codegen/char-ascii-branchless.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Checks that these functions are branchless.
-//
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @is_ascii_alphanumeric_char
-#[no_mangle]
-pub fn is_ascii_alphanumeric_char(x: char) -> bool {
-    // CHECK-NOT: br
-    x.is_ascii_alphanumeric()
-}
-
-// CHECK-LABEL: @is_ascii_alphanumeric_u8
-#[no_mangle]
-pub fn is_ascii_alphanumeric_u8(x: u8) -> bool {
-    // CHECK-NOT: br
-    x.is_ascii_alphanumeric()
-}
-
-// CHECK-LABEL: @is_ascii_hexdigit_char
-#[no_mangle]
-pub fn is_ascii_hexdigit_char(x: char) -> bool {
-    // CHECK-NOT: br
-    x.is_ascii_hexdigit()
-}
-
-// CHECK-LABEL: @is_ascii_hexdigit_u8
-#[no_mangle]
-pub fn is_ascii_hexdigit_u8(x: u8) -> bool {
-    // CHECK-NOT: br
-    x.is_ascii_hexdigit()
-}
-
-// CHECK-LABEL: @is_ascii_punctuation_char
-#[no_mangle]
-pub fn is_ascii_punctuation_char(x: char) -> bool {
-    // CHECK-NOT: br
-    x.is_ascii_punctuation()
-}
-
-// CHECK-LABEL: @is_ascii_punctuation_u8
-#[no_mangle]
-pub fn is_ascii_punctuation_u8(x: u8) -> bool {
-    // CHECK-NOT: br
-    x.is_ascii_punctuation()
-}
diff --git a/tests/codegen/char-escape-debug-no-bounds-check.rs b/tests/codegen/char-escape-debug-no-bounds-check.rs
deleted file mode 100644
index cfde46045e5..00000000000
--- a/tests/codegen/char-escape-debug-no-bounds-check.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-use std::char::EscapeDebug;
-
-// Make sure no bounds checks are emitted when escaping a character.
-
-// CHECK-LABEL: @char_escape_debug_no_bounds_check
-#[no_mangle]
-pub fn char_escape_debug_no_bounds_check(c: char) -> EscapeDebug {
-    // CHECK-NOT: panic
-    // CHECK-NOT: panic_bounds_check
-    c.escape_debug()
-}
diff --git a/tests/codegen/checked_ilog.rs b/tests/codegen/checked_ilog.rs
deleted file mode 100644
index e340a45b6a9..00000000000
--- a/tests/codegen/checked_ilog.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// Ensure that when val < base, we do not divide or multiply.
-
-// CHECK-LABEL: @checked_ilog
-// CHECK-SAME: (i16{{.*}} %val, i16{{.*}} %base)
-#[no_mangle]
-pub fn checked_ilog(val: u16, base: u16) -> Option<u32> {
-    // CHECK-NOT: udiv
-    // CHECK-NOT: mul
-    // CHECK: %[[IS_LESS:.+]] = icmp ult i16 %val, %base
-    // CHECK-NEXT: br i1 %[[IS_LESS]], label %[[TRUE:.+]], label %[[FALSE:.+]]
-    // CHECK: [[TRUE]]:
-    // CHECK-NOT: udiv
-    // CHECK-NOT: mul
-    // CHECK: ret { i32, i32 }
-    val.checked_ilog(base)
-}
diff --git a/tests/codegen/checked_math.rs b/tests/codegen/checked_math.rs
deleted file mode 100644
index 66667c69488..00000000000
--- a/tests/codegen/checked_math.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-
-#![crate_type = "lib"]
-#![feature(unchecked_shifts)]
-
-// Because the result of something like `u32::checked_sub` can only be used if it
-// didn't overflow, make sure that LLVM actually knows that in optimized builds.
-// Thanks to poison semantics, this doesn't even need branches.
-
-// CHECK-LABEL: @checked_sub_unsigned
-// CHECK-SAME: (i16{{.*}} %a, i16{{.*}} %b)
-#[no_mangle]
-pub fn checked_sub_unsigned(a: u16, b: u16) -> Option<u16> {
-    // CHECK-DAG: %[[IS_SOME:.+]] = icmp uge i16 %a, %b
-    // CHECK-DAG: %[[DIFF_P:.+]] = sub nuw i16 %a, %b
-    // CHECK-DAG: %[[DISCR:.+]] = zext i1 %[[IS_SOME]] to i16
-    // CHECK-DAG: %[[DIFF_U:.+]] = select i1 %[[IS_SOME]], i16 %[[DIFF_P]], i16 undef
-
-    // CHECK: %[[R0:.+]] = insertvalue { i16, i16 } poison, i16 %[[DISCR]], 0
-    // CHECK: %[[R1:.+]] = insertvalue { i16, i16 } %[[R0]], i16 %[[DIFF_U]], 1
-    // CHECK: ret { i16, i16 } %[[R1]]
-    a.checked_sub(b)
-}
-
-// Note that `shl` and `shr` in LLVM are already unchecked. So rather than
-// looking for no-wrap flags, we just need there to not be any masking.
-
-// CHECK-LABEL: @checked_shl_unsigned
-// CHECK-SAME: (i32{{.*}} %a, i32{{.*}} %b)
-#[no_mangle]
-pub fn checked_shl_unsigned(a: u32, b: u32) -> Option<u32> {
-    // CHECK-DAG: %[[IS_SOME:.+]] = icmp ult i32 %b, 32
-    // CHECK-DAG: %[[SHIFTED_P:.+]] = shl i32 %a, %b
-    // CHECK-DAG: %[[DISCR:.+]] = zext i1 %[[IS_SOME]] to i32
-    // CHECK-DAG: %[[SHIFTED_U:.+]] = select i1 %[[IS_SOME]], i32 %[[SHIFTED_P]], i32 undef
-
-    // CHECK: %[[R0:.+]] = insertvalue { i32, i32 } poison, i32 %[[DISCR]], 0
-    // CHECK: %[[R1:.+]] = insertvalue { i32, i32 } %[[R0]], i32 %[[SHIFTED_U]], 1
-    // CHECK: ret { i32, i32 } %[[R1]]
-    a.checked_shl(b)
-}
-
-// CHECK-LABEL: @checked_shr_unsigned
-// CHECK-SAME: (i32{{.*}} %a, i32{{.*}} %b)
-#[no_mangle]
-pub fn checked_shr_unsigned(a: u32, b: u32) -> Option<u32> {
-    // CHECK-DAG: %[[IS_SOME:.+]] = icmp ult i32 %b, 32
-    // CHECK-DAG: %[[SHIFTED_P:.+]] = lshr i32 %a, %b
-    // CHECK-DAG: %[[DISCR:.+]] = zext i1 %[[IS_SOME]] to i32
-    // CHECK-DAG: %[[SHIFTED_U:.+]] = select i1 %[[IS_SOME]], i32 %[[SHIFTED_P]], i32 undef
-
-    // CHECK: %[[R0:.+]] = insertvalue { i32, i32 } poison, i32 %[[DISCR]], 0
-    // CHECK: %[[R1:.+]] = insertvalue { i32, i32 } %[[R0]], i32 %[[SHIFTED_U]], 1
-    // CHECK: ret { i32, i32 } %[[R1]]
-    a.checked_shr(b)
-}
-
-// CHECK-LABEL: @checked_shl_signed
-// CHECK-SAME: (i32{{.*}} %a, i32{{.*}} %b)
-#[no_mangle]
-pub fn checked_shl_signed(a: i32, b: u32) -> Option<i32> {
-    // CHECK-DAG: %[[IS_SOME:.+]] = icmp ult i32 %b, 32
-    // CHECK-DAG: %[[SHIFTED_P:.+]] = shl i32 %a, %b
-    // CHECK-DAG: %[[DISCR:.+]] = zext i1 %[[IS_SOME]] to i32
-    // CHECK-DAG: %[[SHIFTED_U:.+]] = select i1 %[[IS_SOME]], i32 %[[SHIFTED_P]], i32 undef
-
-    // CHECK: %[[R0:.+]] = insertvalue { i32, i32 } poison, i32 %[[DISCR]], 0
-    // CHECK: %[[R1:.+]] = insertvalue { i32, i32 } %[[R0]], i32 %[[SHIFTED_U]], 1
-    // CHECK: ret { i32, i32 } %[[R1]]
-    a.checked_shl(b)
-}
-
-// CHECK-LABEL: @checked_shr_signed
-// CHECK-SAME: (i32{{.*}} %a, i32{{.*}} %b)
-#[no_mangle]
-pub fn checked_shr_signed(a: i32, b: u32) -> Option<i32> {
-    // CHECK-DAG: %[[IS_SOME:.+]] = icmp ult i32 %b, 32
-    // CHECK-DAG: %[[SHIFTED_P:.+]] = ashr i32 %a, %b
-    // CHECK-DAG: %[[DISCR:.+]] = zext i1 %[[IS_SOME]] to i32
-    // CHECK-DAG: %[[SHIFTED_U:.+]] = select i1 %[[IS_SOME]], i32 %[[SHIFTED_P]], i32 undef
-
-    // CHECK: %[[R0:.+]] = insertvalue { i32, i32 } poison, i32 %[[DISCR]], 0
-    // CHECK: %[[R1:.+]] = insertvalue { i32, i32 } %[[R0]], i32 %[[SHIFTED_U]], 1
-    // CHECK: ret { i32, i32 } %[[R1]]
-    a.checked_shr(b)
-}
-
-// CHECK-LABEL: @checked_add_one_unwrap_unsigned
-// CHECK-SAME: (i32{{.*}} %x)
-#[no_mangle]
-pub fn checked_add_one_unwrap_unsigned(x: u32) -> u32 {
-    // CHECK: %[[IS_MAX:.+]] = icmp eq i32 %x, -1
-    // CHECK: br i1 %[[IS_MAX]], label %[[NONE_BB:.+]], label %[[SOME_BB:.+]],
-    // CHECK: [[SOME_BB]]:
-    // CHECK: %[[R:.+]] = add nuw i32 %x, 1
-    // CHECK: ret i32 %[[R]]
-    // CHECK: [[NONE_BB]]:
-    // CHECK: call {{.+}}unwrap_failed
-    x.checked_add(1).unwrap()
-}
diff --git a/tests/codegen/clone-shims.rs b/tests/codegen/clone-shims.rs
deleted file mode 100644
index 06c959f9ee7..00000000000
--- a/tests/codegen/clone-shims.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Clone shims for aggregates are generated by just calling the Clone shims for all their members.
-// Those calls generate a lot of unnecessary IR if the members are Copy. This test ensures that we
-// optimize away those inner calls without needing to inline them.
-
-//@ compile-flags: -Cno-prepopulate-passes -Csymbol-mangling-version=v0 -Zinline-mir=no
-#![crate_type = "lib"]
-
-pub type Test = (i32, i32, *const i32);
-pub static TEST: fn(&Test) -> Test = <Test as core::clone::Clone>::clone;
-
-// CHECK-NOT: call <i32 as core::clone::Clone>::clone
-// CHECK-NOT: call <*const i32 as core::clone::Clone>::clone
-// CHECK:     ; <(i32, i32, *const i32) as core::clone::Clone>::clone
-// CHECK-NOT: call <i32 as core::clone::Clone>::clone
-// CHECK-NOT: call <*const i32 as core::clone::Clone>::clone
diff --git a/tests/codegen/clone_as_copy.rs b/tests/codegen/clone_as_copy.rs
deleted file mode 100644
index ef834ef5912..00000000000
--- a/tests/codegen/clone_as_copy.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//@ revisions: DEBUGINFO NODEBUGINFO
-//@ compile-flags: -Copt-level=3 -Cno-prepopulate-passes
-//@ [DEBUGINFO] compile-flags: -Cdebuginfo=full
-
-// From https://github.com/rust-lang/rust/issues/128081.
-// Ensure that we only generate a memcpy instruction.
-
-#![crate_type = "lib"]
-
-#[derive(Clone)]
-struct SubCloneAndCopy {
-    v1: u32,
-    v2: u32,
-}
-
-#[derive(Clone)]
-struct CloneOnly {
-    v1: u8,
-    v2: u8,
-    v3: u8,
-    v4: u8,
-    v5: u8,
-    v6: u8,
-    v7: u8,
-    v8: u8,
-    v9: u8,
-    v_sub: SubCloneAndCopy,
-    v_large: [u8; 256],
-}
-
-// CHECK-LABEL: define {{.*}}@clone_only(
-#[no_mangle]
-pub fn clone_only(v: &CloneOnly) -> CloneOnly {
-    // CHECK-NOT: call {{.*}}clone
-    // CHECK-NOT: store i8
-    // CHECK-NOT: store i32
-    // CHECK: call void @llvm.memcpy
-    // CHECK-NEXT: ret void
-    v.clone()
-}
diff --git a/tests/codegen/codemodels.rs b/tests/codegen/codemodels.rs
deleted file mode 100644
index 06d2eade78a..00000000000
--- a/tests/codegen/codemodels.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ only-x86_64
-
-//@ revisions: NOMODEL MODEL-SMALL MODEL-KERNEL MODEL-MEDIUM MODEL-LARGE
-//@[NOMODEL] compile-flags:
-//@[MODEL-SMALL] compile-flags: -C code-model=small
-//@[MODEL-KERNEL] compile-flags: -C code-model=kernel
-//@[MODEL-MEDIUM] compile-flags: -C code-model=medium
-//@[MODEL-LARGE] compile-flags: -C code-model=large
-
-#![crate_type = "lib"]
-
-// MODEL-SMALL: !llvm.module.flags = !{{{.*}}}
-// MODEL-SMALL: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 1}
-// MODEL-KERNEL: !llvm.module.flags = !{{{.*}}}
-// MODEL-KERNEL: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 2}
-// MODEL-MEDIUM: !llvm.module.flags = !{{{.*}}}
-// MODEL-MEDIUM: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 3}
-// MODEL-LARGE: !llvm.module.flags = !{{{.*}}}
-// MODEL-LARGE: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 4}
-// NOMODEL-NOT: Code Model
diff --git a/tests/codegen/coercions.rs b/tests/codegen/coercions.rs
deleted file mode 100644
index 63c1742c639..00000000000
--- a/tests/codegen/coercions.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-static X: i32 = 5;
-
-// CHECK-LABEL: @raw_ptr_to_raw_ptr_noop
-// CHECK-NOT: alloca
-#[no_mangle]
-pub fn raw_ptr_to_raw_ptr_noop() -> *const i32 {
-    &X as *const i32
-}
-
-// CHECK-LABEL: @reference_to_raw_ptr_noop
-// CHECK-NOT: alloca
-#[no_mangle]
-pub fn reference_to_raw_ptr_noop() -> *const i32 {
-    &X
-}
diff --git a/tests/codegen/cold-call-declare-and-call.rs b/tests/codegen/cold-call-declare-and-call.rs
deleted file mode 100644
index b18565ee6c3..00000000000
--- a/tests/codegen/cold-call-declare-and-call.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ revisions: NORMAL WIN
-//@ compile-flags: -C no-prepopulate-passes
-//@[NORMAL] ignore-windows
-//@[WIN] only-windows
-//@[WIN] only-x86_64
-
-#![crate_type = "lib"]
-#![feature(rust_cold_cc)]
-
-// wasm marks the definition as `dso_local`, so allow that as optional.
-
-// NORMAL: define{{( dso_local)?}} preserve_mostcc void @this_should_never_happen(i16
-// NORMAL: call preserve_mostcc void @this_should_never_happen(i16
-
-// See the comment in `Target::adjust_abi` for why this differs
-
-// WIN: define void @this_should_never_happen(i16
-// WIN: call void @this_should_never_happen(i16
-
-#[no_mangle]
-pub extern "rust-cold" fn this_should_never_happen(x: u16) {}
-
-pub fn do_things(x: u16) {
-    if x == 12345 {
-        this_should_never_happen(54321);
-    }
-}
diff --git a/tests/codegen/common_prim_int_ptr.rs b/tests/codegen/common_prim_int_ptr.rs
deleted file mode 100644
index 53716adccbf..00000000000
--- a/tests/codegen/common_prim_int_ptr.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-// Tests that codegen works properly when enums like `Result<usize, Box<()>>`
-// are represented as `{ u64, ptr }`, i.e., for `Ok(123)`, `123` is stored
-// as a pointer.
-
-// CHECK-LABEL: @insert_int
-#[no_mangle]
-pub fn insert_int(x: usize) -> Result<usize, Box<()>> {
-    // CHECK: start:
-    // CHECK-NEXT: %[[WO_PROV:.+]] = getelementptr i8, ptr null, [[USIZE:i[0-9]+]] %x
-    // CHECK-NEXT: %[[R:.+]] = insertvalue { [[USIZE]], ptr } { [[USIZE]] 0, ptr poison }, ptr %[[WO_PROV]], 1
-    // CHECK-NEXT: ret { [[USIZE]], ptr } %[[R]]
-    Ok(x)
-}
-
-// CHECK-LABEL: @insert_box
-#[no_mangle]
-pub fn insert_box(x: Box<()>) -> Result<usize, Box<()>> {
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue { i{{[0-9]+}}, ptr }
-    // CHECK-NEXT: ret
-    Err(x)
-}
-
-// CHECK-LABEL: @extract_int
-// CHECK-NOT: nonnull
-// CHECK-SAME: (i{{[0-9]+}} {{[^%]+}} [[DISCRIMINANT:%[0-9]+]], ptr {{[^,]+}} [[PAYLOAD:%[0-9]+]])
-#[no_mangle]
-pub unsafe fn extract_int(x: Result<usize, Box<()>>) -> usize {
-    // CHECK: [[TEMP:%.+]] = ptrtoint ptr [[PAYLOAD]] to [[USIZE:i[0-9]+]]
-    // CHECK: ret [[USIZE]] [[TEMP]]
-    match x {
-        Ok(v) => v,
-        Err(_) => std::intrinsics::unreachable(),
-    }
-}
-
-// CHECK-LABEL: @extract_box
-// CHECK-SAME: (i{{[0-9]+}} {{[^%]+}} [[DISCRIMINANT:%[0-9]+]], ptr {{[^%]+}} [[PAYLOAD:%[0-9]+]])
-#[no_mangle]
-pub unsafe fn extract_box(x: Result<usize, Box<i32>>) -> Box<i32> {
-    // CHECK: ret ptr [[PAYLOAD]]
-    match x {
-        Ok(_) => std::intrinsics::unreachable(),
-        Err(e) => e,
-    }
-}
diff --git a/tests/codegen/comparison-operators-2-struct.rs b/tests/codegen/comparison-operators-2-struct.rs
deleted file mode 100644
index e179066ebfd..00000000000
--- a/tests/codegen/comparison-operators-2-struct.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-//@ compile-flags: -C opt-level=1
-//@ min-llvm-version: 20
-
-// The `derive(PartialOrd)` for a 2-field type doesn't override `lt`/`le`/`gt`/`ge`.
-// This double-checks that the `Option<Ordering>` intermediate values used
-// in the operators for such a type all optimize away.
-
-#![crate_type = "lib"]
-
-use std::cmp::Ordering;
-
-#[derive(PartialOrd, PartialEq)]
-pub struct Foo(i32, u32);
-
-// CHECK-LABEL: @check_lt(
-// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
-#[no_mangle]
-pub fn check_lt(a: Foo, b: Foo) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[R0:.+]] = icmp slt i32 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[R1:.+]] = icmp ult i32 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
-    // CHECK-NEXT: ret i1 %[[R]]
-    a < b
-}
-
-// CHECK-LABEL: @check_le(
-// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
-#[no_mangle]
-pub fn check_le(a: Foo, b: Foo) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[R0:.+]] = icmp sle i32 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[R1:.+]] = icmp ule i32 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
-    // CHECK-NEXT: ret i1 %[[R]]
-    a <= b
-}
-
-// CHECK-LABEL: @check_gt(
-// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
-#[no_mangle]
-pub fn check_gt(a: Foo, b: Foo) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[R0:.+]] = icmp sgt i32 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[R1:.+]] = icmp ugt i32 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
-    // CHECK-NEXT: ret i1 %[[R]]
-    a > b
-}
-
-// CHECK-LABEL: @check_ge(
-// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
-#[no_mangle]
-pub fn check_ge(a: Foo, b: Foo) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[R0:.+]] = icmp sge i32 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[R1:.+]] = icmp uge i32 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
-    // CHECK-NEXT: ret i1 %[[R]]
-    a >= b
-}
diff --git a/tests/codegen/comparison-operators-2-tuple.rs b/tests/codegen/comparison-operators-2-tuple.rs
deleted file mode 100644
index 6a7e489c82d..00000000000
--- a/tests/codegen/comparison-operators-2-tuple.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-//@ compile-flags: -C opt-level=1 -Z merge-functions=disabled
-//@ min-llvm-version: 20
-
-#![crate_type = "lib"]
-
-use std::cmp::Ordering;
-
-type TwoTuple = (i16, u16);
-
-//
-// The operators are all overridden directly, so should optimize easily.
-//
-// slt-vs-sle and sgt-vs-sge don't matter because they're only used in the side
-// of the select where we know the values are not equal, and thus the tests
-// use a regex to allow either, since unimportant changes to the implementation
-// sometimes result in changing what LLVM decides to emit for this.
-//
-
-// CHECK-LABEL: @check_lt_direct
-// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
-#[no_mangle]
-pub fn check_lt_direct(a: TwoTuple, b: TwoTuple) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP0:.+]] = icmp {{slt|sle}} i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP1:.+]] = icmp ult i16 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
-    // CHECK: ret i1 %[[R]]
-    a < b
-}
-
-// CHECK-LABEL: @check_le_direct
-// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
-#[no_mangle]
-pub fn check_le_direct(a: TwoTuple, b: TwoTuple) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP0:.+]] = icmp {{slt|sle}} i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP1:.+]] = icmp ule i16 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
-    // CHECK: ret i1 %[[R]]
-    a <= b
-}
-
-// CHECK-LABEL: @check_gt_direct
-// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
-#[no_mangle]
-pub fn check_gt_direct(a: TwoTuple, b: TwoTuple) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP0:.+]] = icmp {{sgt|sge}} i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP1:.+]] = icmp ugt i16 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
-    // CHECK: ret i1 %[[R]]
-    a > b
-}
-
-// CHECK-LABEL: @check_ge_direct
-// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
-#[no_mangle]
-pub fn check_ge_direct(a: TwoTuple, b: TwoTuple) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP0:.+]] = icmp {{sgt|sge}} i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP1:.+]] = icmp uge i16 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
-    // CHECK: ret i1 %[[R]]
-    a >= b
-}
-
-//
-// These used to not optimize as well, but thanks to LLVM 20 they work now 🎉
-//
-
-// CHECK-LABEL: @check_lt_via_cmp
-// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
-#[no_mangle]
-pub fn check_lt_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP0:.+]] = icmp slt i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP1:.+]] = icmp ult i16 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
-    // CHECK: ret i1 %[[R]]
-    Ord::cmp(&a, &b).is_lt()
-}
-
-// CHECK-LABEL: @check_le_via_cmp
-// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
-#[no_mangle]
-pub fn check_le_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP0:.+]] = icmp sle i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP1:.+]] = icmp ule i16 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
-    // CHECK: ret i1 %[[R]]
-    Ord::cmp(&a, &b).is_le()
-}
-
-// CHECK-LABEL: @check_gt_via_cmp
-// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
-#[no_mangle]
-pub fn check_gt_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP0:.+]] = icmp sgt i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP1:.+]] = icmp ugt i16 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
-    // CHECK: ret i1 %[[R]]
-    Ord::cmp(&a, &b).is_gt()
-}
-
-// CHECK-LABEL: @check_ge_via_cmp
-// CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
-#[no_mangle]
-pub fn check_ge_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
-    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP0:.+]] = icmp sge i16 %[[A0]], %[[B0]]
-    // CHECK-DAG: %[[CMP1:.+]] = icmp uge i16 %[[A1]], %[[B1]]
-    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
-    // CHECK: ret i1 %[[R]]
-    Ord::cmp(&a, &b).is_ge()
-}
diff --git a/tests/codegen/comparison-operators-newtype.rs b/tests/codegen/comparison-operators-newtype.rs
deleted file mode 100644
index acce0cb5946..00000000000
--- a/tests/codegen/comparison-operators-newtype.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-// The `derive(PartialOrd)` for a newtype doesn't override `lt`/`le`/`gt`/`ge`.
-// This double-checks that the `Option<Ordering>` intermediate values used
-// in the operators for such a type all optimize away.
-
-//@ compile-flags: -C opt-level=1
-
-#![crate_type = "lib"]
-
-use std::cmp::Ordering;
-
-#[derive(PartialOrd, PartialEq)]
-pub struct Foo(u16);
-
-// CHECK-LABEL: @check_lt
-// CHECK-SAME: (i16{{.*}} %[[A:.+]], i16{{.*}} %[[B:.+]])
-#[no_mangle]
-pub fn check_lt(a: Foo, b: Foo) -> bool {
-    // CHECK: %[[R:.+]] = icmp ult i16 %[[A]], %[[B]]
-    // CHECK-NEXT: ret i1 %[[R]]
-    a < b
-}
-
-// CHECK-LABEL: @check_le
-// CHECK-SAME: (i16{{.*}} %[[A:.+]], i16{{.*}} %[[B:.+]])
-#[no_mangle]
-pub fn check_le(a: Foo, b: Foo) -> bool {
-    // CHECK: %[[R:.+]] = icmp ule i16 %[[A]], %[[B]]
-    // CHECK-NEXT: ret i1 %[[R]]
-    a <= b
-}
-
-// CHECK-LABEL: @check_gt
-// CHECK-SAME: (i16{{.*}} %[[A:.+]], i16{{.*}} %[[B:.+]])
-#[no_mangle]
-pub fn check_gt(a: Foo, b: Foo) -> bool {
-    // CHECK: %[[R:.+]] = icmp ugt i16 %[[A]], %[[B]]
-    // CHECK-NEXT: ret i1 %[[R]]
-    a > b
-}
-
-// CHECK-LABEL: @check_ge
-// CHECK-SAME: (i16{{.*}} %[[A:.+]], i16{{.*}} %[[B:.+]])
-#[no_mangle]
-pub fn check_ge(a: Foo, b: Foo) -> bool {
-    // CHECK: %[[R:.+]] = icmp uge i16 %[[A]], %[[B]]
-    // CHECK-NEXT: ret i1 %[[R]]
-    a >= b
-}
diff --git a/tests/codegen/compiletest-self-test/minicore-smoke-test.rs b/tests/codegen/compiletest-self-test/minicore-smoke-test.rs
deleted file mode 100644
index 9dd1bf29c6c..00000000000
--- a/tests/codegen/compiletest-self-test/minicore-smoke-test.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//! Basic smoke test for `minicore` test auxiliary.
-
-//@ add-core-stubs
-//@ compile-flags: --target=x86_64-unknown-linux-gnu
-//@ needs-llvm-components: x86
-
-#![crate_type = "lib"]
-#![feature(no_core)]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-struct Meow;
-impl Copy for Meow {}
-
-// CHECK-LABEL: meow
-#[no_mangle]
-fn meow() {}
diff --git a/tests/codegen/const-array.rs b/tests/codegen/const-array.rs
deleted file mode 100644
index b3df76c3d8e..00000000000
--- a/tests/codegen/const-array.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-const LUT: [u8; 4] = [1, 1, 1, 1];
-
-// CHECK-LABEL: @decode
-#[no_mangle]
-pub fn decode(i: u8) -> u8 {
-    // CHECK: start:
-    // CHECK-NEXT: icmp
-    // CHECK-NEXT: select
-    // CHECK-NEXT: ret
-    if i < 4 { LUT[i as usize] } else { 2 }
-}
diff --git a/tests/codegen/const-vector.rs b/tests/codegen/const-vector.rs
deleted file mode 100644
index a2249f4fff7..00000000000
--- a/tests/codegen/const-vector.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-//@ revisions: OPT0 OPT0_S390X
-//@ [OPT0] ignore-s390x
-//@ [OPT0_S390X] only-s390x
-//@ [OPT0] compile-flags: -C no-prepopulate-passes -Copt-level=0
-//@ [OPT0_S390X] compile-flags: -C no-prepopulate-passes -Copt-level=0 -C target-cpu=z13
-
-// This test checks that constants of SIMD type are passed as immediate vectors.
-// We ensure that both vector representations (struct with fields and struct wrapping array) work.
-#![crate_type = "lib"]
-#![feature(abi_unadjusted)]
-#![feature(const_trait_impl)]
-#![feature(repr_simd)]
-#![feature(rustc_attrs)]
-#![feature(simd_ffi)]
-#![feature(arm_target_feature)]
-#![feature(mips_target_feature)]
-#![allow(non_camel_case_types)]
-
-#[path = "../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::{PackedSimd as Simd, f32x2, i8x2};
-
-// The following functions are required for the tests to ensure
-// that they are called with a const vector
-
-extern "unadjusted" {
-    fn test_i8x2(a: i8x2);
-    fn test_i8x2_two_args(a: i8x2, b: i8x2);
-    fn test_i8x2_mixed_args(a: i8x2, c: i32, b: i8x2);
-    fn test_i8x2_arr(a: i8x2);
-    fn test_f32x2(a: f32x2);
-    fn test_f32x2_arr(a: f32x2);
-    fn test_simd(a: Simd<i32, 4>);
-    fn test_simd_unaligned(a: Simd<i32, 3>);
-}
-
-// Ensure the packed variant of the simd struct does not become a const vector
-// if the size is not a power of 2
-// CHECK: %"minisimd::PackedSimd<i32, 3>" = type { [3 x i32] }
-
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-pub fn do_call() {
-    unsafe {
-        // CHECK: call void @test_i8x2(<2 x i8> <i8 32, i8 64>
-        test_i8x2(const { i8x2::from_array([32, 64]) });
-
-        // CHECK: call void @test_i8x2_two_args(<2 x i8> <i8 32, i8 64>, <2 x i8> <i8 8, i8 16>
-        test_i8x2_two_args(
-            const { i8x2::from_array([32, 64]) },
-            const { i8x2::from_array([8, 16]) },
-        );
-
-        // CHECK: call void @test_i8x2_mixed_args(<2 x i8> <i8 32, i8 64>, i32 43, <2 x i8> <i8 8, i8 16>
-        test_i8x2_mixed_args(
-            const { i8x2::from_array([32, 64]) },
-            43,
-            const { i8x2::from_array([8, 16]) },
-        );
-
-        // CHECK: call void @test_i8x2_arr(<2 x i8> <i8 32, i8 64>
-        test_i8x2_arr(const { i8x2::from_array([32, 64]) });
-
-        // CHECK: call void @test_f32x2(<2 x float> <float 0x3FD47AE140000000, float 0x3FE47AE140000000>
-        test_f32x2(const { f32x2::from_array([0.32, 0.64]) });
-
-        // CHECK: void @test_f32x2_arr(<2 x float> <float 0x3FD47AE140000000, float 0x3FE47AE140000000>
-        test_f32x2_arr(const { f32x2::from_array([0.32, 0.64]) });
-
-        // CHECK: call void @test_simd(<4 x i32> <i32 2, i32 4, i32 6, i32 8>
-        test_simd(const { Simd::<i32, 4>([2, 4, 6, 8]) });
-
-        // CHECK: call void @test_simd_unaligned(%"minisimd::PackedSimd<i32, 3>" %1
-        test_simd_unaligned(const { Simd::<i32, 3>([2, 4, 6]) });
-    }
-}
diff --git a/tests/codegen/const_scalar_pair.rs b/tests/codegen/const_scalar_pair.rs
deleted file mode 100644
index f142896c31f..00000000000
--- a/tests/codegen/const_scalar_pair.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ compile-flags: --crate-type=lib -Copt-level=0 -Zmir-opt-level=0 -C debuginfo=2
-
-// Test that we don't generate a memory allocation for the constant
-// and read the fields from that, but instead just create the value pair directly.
-pub fn foo() -> (i32, i32) {
-    // CHECK: ret { i32, i32 } { i32 1, i32 2 }
-    const { (1, 2) }
-}
diff --git a/tests/codegen/constant-branch.rs b/tests/codegen/constant-branch.rs
deleted file mode 100644
index 8fc8fb4f57a..00000000000
--- a/tests/codegen/constant-branch.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//@ compile-flags: -Zmir-opt-level=0 -C no-prepopulate-passes -Copt-level=0
-// make sure that branching on a constant does not emit a conditional
-// branch or a switch
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @if_bool
-#[no_mangle]
-pub fn if_bool() {
-    // CHECK-NOT: br i1
-    // CHECK-NOT: switch
-    _ = if true { 0 } else { 1 };
-
-    _ = if false { 0 } else { 1 };
-}
-
-// CHECK-LABEL: @if_constant_int_eq
-#[no_mangle]
-pub fn if_constant_int_eq() {
-    // CHECK-NOT: br i1
-    // CHECK-NOT: switch
-    let val = 0;
-    _ = if val == 0 { 0 } else { 1 };
-
-    // CHECK: br label %{{.+}}
-    _ = if val == 1 { 0 } else { 1 };
-}
-
-// CHECK-LABEL: @if_constant_match
-#[no_mangle]
-pub fn if_constant_match() {
-    // CHECK-NOT: br i1
-    // CHECK-NOT: switch
-    _ = match 1 {
-        1 => 2,
-        2 => 3,
-        _ => 4,
-    };
-
-    _ = match 1 {
-        2 => 3,
-        _ => 4,
-    };
-
-    _ = match -1 {
-        -1 => 1,
-        _ => 0,
-    }
-}
diff --git a/tests/codegen/consts.rs b/tests/codegen/consts.rs
deleted file mode 100644
index 42ce7679d1a..00000000000
--- a/tests/codegen/consts.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-// Below, these constants are defined as enum variants that by itself would
-// have a lower alignment than the enum type. Ensure that we mark them
-// correctly with the higher alignment of the enum.
-
-// CHECK: @STATIC = {{.*}}, align 4
-
-// This checks the constants from inline_enum_const
-// CHECK: @alloc_[[INLINE_ENUM_HASH:[a-f0-9]{32}]] = {{.*}}, align 2
-
-// This checks the constants from {low,high}_align_const, they share the same
-// constant, but the alignment differs, so the higher one should be used
-// CHECK: [[LOW_HIGH:@alloc_[a-f0-9]{32}]] = {{.*}}, align 4
-
-#[derive(Copy, Clone)]
-// repr(i16) is required for the {low,high}_align_const test
-#[repr(i16)]
-pub enum E<A, B> {
-    A(A),
-    B(B),
-}
-
-#[no_mangle]
-pub static STATIC: E<i16, i32> = E::A(0);
-
-// CHECK-LABEL: @static_enum_const
-#[no_mangle]
-pub fn static_enum_const() -> E<i16, i32> {
-    STATIC
-}
-
-// CHECK-LABEL: @inline_enum_const
-#[no_mangle]
-pub fn inline_enum_const() -> E<i8, i16> {
-    *&E::A(0)
-}
-
-// CHECK-LABEL: @low_align_const
-#[no_mangle]
-pub fn low_align_const() -> E<i16, [i16; 3]> {
-    // Check that low_align_const and high_align_const use the same constant
-    // CHECK: memcpy.{{.+}}(ptr align 2 %_0, ptr align 2 {{.*}}[[LOW_HIGH]]{{.*}}, i{{(32|64)}} 8, i1 false)
-    *&E::A(0)
-}
-
-// CHECK-LABEL: @high_align_const
-#[no_mangle]
-pub fn high_align_const() -> E<i16, i32> {
-    // Check that low_align_const and high_align_const use the same constant
-    // CHECK: memcpy.{{.+}}(ptr align 4 %_0, ptr align 4 {{.*}}[[LOW_HIGH]]{{.*}}, i{{(32|64)}} 8, i1 false)
-    *&E::A(0)
-}
diff --git a/tests/codegen/coroutine-debug-msvc.rs b/tests/codegen/coroutine-debug-msvc.rs
deleted file mode 100644
index 9e2ec3ea28a..00000000000
--- a/tests/codegen/coroutine-debug-msvc.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-// Verify debuginfo for coroutines:
-//  - Each variant points to the file and line of its yield point
-//  - The discriminants are marked artificial
-//  - Other fields are not marked artificial
-//
-//
-//@ compile-flags: -C debuginfo=2
-//@ only-msvc
-
-#![feature(coroutines, coroutine_trait)]
-use std::ops::Coroutine;
-
-fn coroutine_test() -> impl Coroutine<Yield = i32, Return = ()> {
-    #[coroutine]
-    || {
-        yield 0;
-        let s = String::from("foo");
-        yield 1;
-    }
-}
-
-// FIXME: No way to reliably check the filename.
-
-// CHECK-DAG:  [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<coroutine_debug_msvc::coroutine_test::coroutine_env$0>"
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant0", scope: [[GEN]],
-// For brevity, we only check the struct name and members of the last variant.
-// CHECK-SAME: file: [[FILE:![0-9]*]], line: 15,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant1", scope: [[GEN]],
-// CHECK-SAME: file: [[FILE]], line: 19,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant2", scope: [[GEN]],
-// CHECK-SAME: file: [[FILE]], line: 19,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant3", scope: [[GEN]],
-// CHECK-SAME: file: [[FILE]], line: 16,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant4", scope: [[GEN]],
-// CHECK-SAME: file: [[FILE]], line: 18,
-// CHECK-SAME: baseType: [[VARIANT_WRAPPER:![0-9]*]]
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      [[VARIANT_WRAPPER]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Variant4", scope: [[GEN]],
-// CHECK:      !DIDerivedType(tag: DW_TAG_member, name: "value", scope: [[VARIANT_WRAPPER]], {{.*}}, baseType: [[VARIANT:![0-9]*]],
-// CHECK:      [[VARIANT]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[GEN]],
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[VARIANT]]
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "tag", scope: [[GEN]],
-// CHECK-NOT: flags: DIFlagArtificial
-
-fn main() {
-    let _dummy = coroutine_test();
-}
diff --git a/tests/codegen/coroutine-debug.rs b/tests/codegen/coroutine-debug.rs
deleted file mode 100644
index ff62e9709b4..00000000000
--- a/tests/codegen/coroutine-debug.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Verify debuginfo for coroutines:
-//  - Each variant points to the file and line of its yield point
-//  - The discriminants are marked artificial
-//  - Other fields are not marked artificial
-//
-//
-//@ compile-flags: -C debuginfo=2
-//@ edition: 2018
-//@ ignore-msvc
-
-#![feature(coroutines, coroutine_trait)]
-use std::ops::Coroutine;
-
-fn coroutine_test() -> impl Coroutine<Yield = i32, Return = ()> {
-    #[coroutine]
-    || {
-        yield 0;
-        let s = String::from("foo");
-        yield 1;
-    }
-}
-
-// FIXME: No way to reliably check the filename.
-
-// CHECK-DAG:  [[GEN_FN:!.*]] = !DINamespace(name: "coroutine_test"
-// CHECK-DAG:  [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{coroutine_env#0}", scope: [[GEN_FN]]
-// CHECK:      [[VARIANT:!.*]] = !DICompositeType(tag: DW_TAG_variant_part, scope: [[GEN]],
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: discriminator: [[DISC:![0-9]*]]
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "0", scope: [[VARIANT]],
-// CHECK-SAME: file: [[FILE:![0-9]*]], line: 16,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "Unresumed", scope: [[GEN]],
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "1", scope: [[VARIANT]],
-// CHECK-SAME: file: [[FILE]], line: 20,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "2", scope: [[VARIANT]],
-// CHECK-SAME: file: [[FILE]], line: 20,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "3", scope: [[VARIANT]],
-// CHECK-SAME: file: [[FILE]], line: 17,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "4", scope: [[VARIANT]],
-// CHECK-SAME: file: [[FILE]], line: 19,
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      [[S1:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[GEN]],
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[S1]]
-// CHECK-NOT:  flags: DIFlagArtificial
-// CHECK-SAME: )
-// CHECK:      [[DISC]] = !DIDerivedType(tag: DW_TAG_member, name: "__state", scope: [[GEN]],
-// CHECK-SAME: flags: DIFlagArtificial
-
-fn main() {
-    let _dummy = coroutine_test();
-}
diff --git a/tests/codegen/cross-crate-inlining/always-inline.rs b/tests/codegen/cross-crate-inlining/always-inline.rs
deleted file mode 100644
index df28b3fe197..00000000000
--- a/tests/codegen/cross-crate-inlining/always-inline.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ aux-build:always.rs
-
-#![crate_type = "lib"]
-
-extern crate always;
-
-// Check that we inline a cross-crate call, even though it isn't a leaf
-#[no_mangle]
-pub fn outer() -> String {
-    // CHECK-NOT: call {{.*}}stem_fn
-    always::stem_fn()
-}
diff --git a/tests/codegen/cross-crate-inlining/auxiliary/always.rs b/tests/codegen/cross-crate-inlining/auxiliary/always.rs
deleted file mode 100644
index 6ee3f81e3c8..00000000000
--- a/tests/codegen/cross-crate-inlining/auxiliary/always.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Zcross-crate-inline-threshold=always
-
-#![crate_type = "lib"]
-
-// This function *looks* like it contains a call, but that call will be optimized out by MIR
-// optimizations.
-pub fn leaf_fn() -> String {
-    String::new()
-}
-
-// This function contains a call, even after MIR optimizations. It is only eligible for
-// cross-crate-inlining with "always".
-pub fn stem_fn() -> String {
-    inner()
-}
-
-#[inline(never)]
-fn inner() -> String {
-    String::from("test")
-}
diff --git a/tests/codegen/cross-crate-inlining/auxiliary/leaf.rs b/tests/codegen/cross-crate-inlining/auxiliary/leaf.rs
deleted file mode 100644
index d059a3d0a73..00000000000
--- a/tests/codegen/cross-crate-inlining/auxiliary/leaf.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// This function *looks* like it contains a call, but that call will be optimized out by MIR
-// optimizations.
-pub fn leaf_fn() -> String {
-    String::new()
-}
-
-// This function contains a call, even after MIR optimizations. It is only eligible for
-// cross-crate-inlining with "always".
-pub fn stem_fn() -> String {
-    inner()
-}
-
-#[inline(never)]
-fn inner() -> String {
-    String::from("test")
-}
diff --git a/tests/codegen/cross-crate-inlining/auxiliary/never.rs b/tests/codegen/cross-crate-inlining/auxiliary/never.rs
deleted file mode 100644
index 55c90809ec1..00000000000
--- a/tests/codegen/cross-crate-inlining/auxiliary/never.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Zcross-crate-inline-threshold=never
-
-#![crate_type = "lib"]
-
-// This function *looks* like it contains a call, but that call will be optimized out by MIR
-// optimizations.
-pub fn leaf_fn() -> String {
-    String::new()
-}
-
-// This function contains a call, even after MIR optimizations. It is only eligible for
-// cross-crate-inlining with "always".
-pub fn stem_fn() -> String {
-    inner()
-}
-
-#[inline(never)]
-fn inner() -> String {
-    String::from("test")
-}
diff --git a/tests/codegen/cross-crate-inlining/leaf-inlining.rs b/tests/codegen/cross-crate-inlining/leaf-inlining.rs
deleted file mode 100644
index 37132312ca9..00000000000
--- a/tests/codegen/cross-crate-inlining/leaf-inlining.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Zcross-crate-inline-threshold=yes
-//@ aux-build:leaf.rs
-
-#![crate_type = "lib"]
-
-extern crate leaf;
-
-// Check that we inline a leaf cross-crate call
-#[no_mangle]
-pub fn leaf_outer() -> String {
-    // CHECK-NOT: call {{.*}}leaf_fn
-    leaf::leaf_fn()
-}
-
-// Check that we do not inline a non-leaf cross-crate call
-#[no_mangle]
-pub fn stem_outer() -> String {
-    // CHECK: call {{.*}}stem_fn
-    leaf::stem_fn()
-}
diff --git a/tests/codegen/cross-crate-inlining/never-inline.rs b/tests/codegen/cross-crate-inlining/never-inline.rs
deleted file mode 100644
index 759f65d9d42..00000000000
--- a/tests/codegen/cross-crate-inlining/never-inline.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ aux-build:never.rs
-
-#![crate_type = "lib"]
-
-extern crate never;
-
-// Check that we do not inline a cross-crate call, even though it is a leaf
-#[no_mangle]
-pub fn outer() -> String {
-    // CHECK: call {{.*}}leaf_fn
-    never::leaf_fn()
-}
diff --git a/tests/codegen/dealloc-no-unwind.rs b/tests/codegen/dealloc-no-unwind.rs
deleted file mode 100644
index 68597817d6f..00000000000
--- a/tests/codegen/dealloc-no-unwind.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-struct A;
-
-impl Drop for A {
-    fn drop(&mut self) {
-        extern "C" {
-            fn foo();
-        }
-        unsafe {
-            foo();
-        }
-    }
-}
-
-#[no_mangle]
-pub fn a(a: Box<i32>) {
-    // CHECK-LABEL: define{{.*}}void @a
-    // CHECK: call void @{{.*}}__rust_dealloc
-    // CHECK-NEXT: call void @foo
-    let _a = A;
-    drop(a);
-}
diff --git a/tests/codegen/debug-accessibility/crate-enum.rs b/tests/codegen/debug-accessibility/crate-enum.rs
deleted file mode 100644
index 9ad5a6fd0ff..00000000000
--- a/tests/codegen/debug-accessibility/crate-enum.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// ignore-tidy-linelength
-//! Checks that visibility information is present in the debuginfo for crate-visibility enums.
-
-//@ revisions: MSVC NONMSVC
-//@[MSVC] only-msvc
-//@[NONMSVC] ignore-msvc
-
-//@ compile-flags: -C debuginfo=2
-
-mod module {
-    use std::hint::black_box;
-
-    pub(crate) enum CrateFooEnum {
-        A,
-        B(u32),
-        C { x: u32 },
-    }
-
-    // NONMSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "CrateFooEnum"{{.*}}flags: DIFlagProtected{{.*}})
-    // MSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<crate_enum::module::CrateFooEnum>"{{.*}}flags: DIFlagProtected{{.*}})
-    pub fn use_everything() {
-        black_box(CrateFooEnum::A);
-    }
-}
-
-fn main() {
-    module::use_everything();
-}
diff --git a/tests/codegen/debug-accessibility/crate-struct.rs b/tests/codegen/debug-accessibility/crate-struct.rs
deleted file mode 100644
index 73a8ce852ed..00000000000
--- a/tests/codegen/debug-accessibility/crate-struct.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ compile-flags: -C debuginfo=2
-
-#![allow(dead_code)]
-
-// Checks that visibility information is present in the debuginfo for crate-visibility structs.
-
-mod module {
-    use std::hint::black_box;
-
-    pub(crate) struct CrateFooStruct {
-        x: u32,
-    }
-
-    // CHECK: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "CrateFooStruct"{{.*}}flags: DIFlagProtected{{.*}})
-
-    pub fn use_everything() {
-        black_box(CrateFooStruct { x: 2 });
-    }
-}
-
-fn main() {
-    module::use_everything();
-}
diff --git a/tests/codegen/debug-accessibility/private-enum.rs b/tests/codegen/debug-accessibility/private-enum.rs
deleted file mode 100644
index 002336c03b3..00000000000
--- a/tests/codegen/debug-accessibility/private-enum.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// ignore-tidy-linelength
-//! Checks that visibility information is present in the debuginfo for private enums.
-
-//@ revisions: MSVC NONMSVC
-//@[MSVC] only-msvc
-//@[NONMSVC] ignore-msvc
-//@ compile-flags: -C debuginfo=2
-
-use std::hint::black_box;
-
-enum PrivateFooEnum {
-    A,
-    B(u32),
-    C { x: u32 },
-}
-
-// NONMSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "PrivateFooEnum"{{.*}}flags: DIFlagPrivate{{.*}})
-// MSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<private_enum::PrivateFooEnum>"{{.*}}flags: DIFlagPrivate{{.*}})
-
-fn main() {
-    black_box(PrivateFooEnum::A);
-}
diff --git a/tests/codegen/debug-accessibility/private-struct.rs b/tests/codegen/debug-accessibility/private-struct.rs
deleted file mode 100644
index 488a680e81c..00000000000
--- a/tests/codegen/debug-accessibility/private-struct.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -C debuginfo=2
-
-#![allow(dead_code)]
-
-// Checks that visibility information is present in the debuginfo for private structs.
-
-use std::hint::black_box;
-
-struct PrivateFooStruct {
-    x: u32,
-}
-
-// CHECK: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "PrivateFooStruct"{{.*}}flags: DIFlagPrivate{{.*}})
-
-fn main() {
-    black_box(PrivateFooStruct { x: 1 });
-}
diff --git a/tests/codegen/debug-accessibility/public-enum.rs b/tests/codegen/debug-accessibility/public-enum.rs
deleted file mode 100644
index e5cd1ab7350..00000000000
--- a/tests/codegen/debug-accessibility/public-enum.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// ignore-tidy-linelength
-//! Checks that visibility information is present in the debuginfo for types and their fields.
-
-//@ revisions: MSVC NONMSVC
-//@[MSVC] only-msvc
-//@[NONMSVC] ignore-msvc
-
-//@ compile-flags: -C debuginfo=2
-
-use std::hint::black_box;
-
-pub enum PublicFooEnum {
-    A,
-    B(u32),
-    C { x: u32 },
-}
-
-// NONMSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "PublicFooEnum"{{.*}}flags: DIFlagPublic{{.*}})
-// MSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<public_enum::PublicFooEnum>"{{.*}}flags: DIFlagPublic{{.*}})
-
-fn main() {
-    black_box(PublicFooEnum::A);
-}
diff --git a/tests/codegen/debug-accessibility/public-struct.rs b/tests/codegen/debug-accessibility/public-struct.rs
deleted file mode 100644
index 8b2a53f993c..00000000000
--- a/tests/codegen/debug-accessibility/public-struct.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -C debuginfo=2
-
-#![allow(dead_code)]
-
-// Checks that visibility information is present in the debuginfo for public structs.
-
-use std::hint::black_box;
-
-pub struct PublicFooStruct {
-    x: u32,
-}
-
-// CHECK: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "PublicFooStruct"{{.*}}flags: DIFlagPublic{{.*}})
-
-fn main() {
-    black_box(PublicFooStruct { x: 4 });
-}
diff --git a/tests/codegen/debug-accessibility/struct-fields.rs b/tests/codegen/debug-accessibility/struct-fields.rs
deleted file mode 100644
index f68bb3438be..00000000000
--- a/tests/codegen/debug-accessibility/struct-fields.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//@ compile-flags: -C debuginfo=2
-
-#![allow(dead_code)]
-
-// Checks that visibility information is present in the debuginfo for struct fields.
-
-mod module {
-    use std::hint::black_box;
-
-    struct StructFields {
-        a: u32,
-        pub(crate) b: u32,
-        pub(super) c: u32,
-        pub d: u32,
-    }
-
-    // CHECK: [[StructFields:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "StructFields"{{.*}}flags: DIFlagPrivate{{.*}})
-    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: [[StructFields]]{{.*}}flags: DIFlagPrivate{{.*}})
-    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: [[StructFields]]{{.*}}flags: DIFlagProtected{{.*}})
-    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "c", scope: [[StructFields]]{{.*}}flags: DIFlagProtected{{.*}})
-    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "d", scope: [[StructFields]]{{.*}}flags: DIFlagPublic{{.*}})
-
-    pub fn use_everything() {
-        black_box(StructFields { a: 1, b: 2, c: 3, d: 4 });
-    }
-}
-
-fn main() {
-    module::use_everything();
-}
diff --git a/tests/codegen/debug-accessibility/super-enum.rs b/tests/codegen/debug-accessibility/super-enum.rs
deleted file mode 100644
index 8e34d8be01f..00000000000
--- a/tests/codegen/debug-accessibility/super-enum.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// ignore-tidy-linelength
-//! Checks that visibility information is present in the debuginfo for super-visibility enums.
-
-//@ revisions: MSVC NONMSVC
-//@[MSVC] only-msvc
-//@[NONMSVC] ignore-msvc
-//@ compile-flags: -C debuginfo=2
-
-mod module {
-    use std::hint::black_box;
-
-    pub(super) enum SuperFooEnum {
-        A,
-        B(u32),
-        C { x: u32 },
-    }
-
-    // NONMSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "SuperFooEnum"{{.*}}flags: DIFlagProtected{{.*}})
-    // MSVC: {{!.*}} = !DICompositeType(tag: DW_TAG_union_type, name: "enum2$<super_enum::module::SuperFooEnum>"{{.*}}flags: DIFlagProtected{{.*}})
-
-    pub fn use_everything() {
-        black_box(SuperFooEnum::A);
-    }
-}
-
-fn main() {
-    module::use_everything();
-}
diff --git a/tests/codegen/debug-accessibility/super-struct.rs b/tests/codegen/debug-accessibility/super-struct.rs
deleted file mode 100644
index 63954bfb203..00000000000
--- a/tests/codegen/debug-accessibility/super-struct.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ compile-flags: -C debuginfo=2
-
-#![allow(dead_code)]
-
-// Checks that visibility information is present in the debuginfo for super-visibility structs.
-
-mod module {
-    use std::hint::black_box;
-
-    pub(super) struct SuperFooStruct {
-        x: u32,
-    }
-
-    // CHECK: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "SuperFooStruct"{{.*}}flags: DIFlagProtected{{.*}})
-
-    pub fn use_everything() {
-        black_box(SuperFooStruct { x: 3 });
-    }
-}
-
-fn main() {
-    module::use_everything();
-}
diff --git a/tests/codegen/debug-accessibility/tuple-fields.rs b/tests/codegen/debug-accessibility/tuple-fields.rs
deleted file mode 100644
index feec6e9eb41..00000000000
--- a/tests/codegen/debug-accessibility/tuple-fields.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ compile-flags: -C debuginfo=2
-
-#![allow(dead_code)]
-
-// Checks that visibility information is present in the debuginfo for tuple struct fields.
-
-mod module {
-    use std::hint::black_box;
-
-    struct TupleFields(u32, pub(crate) u32, pub(super) u32, pub u32);
-
-    // CHECK: [[TupleFields:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "TupleFields"{{.*}}flags: DIFlagPrivate{{.*}})
-    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "__0", scope: [[TupleFields]]{{.*}}flags: DIFlagPrivate{{.*}})
-    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "__1", scope: [[TupleFields]]{{.*}}flags: DIFlagProtected{{.*}})
-    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "__2", scope: [[TupleFields]]{{.*}}flags: DIFlagProtected{{.*}})
-    // CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "__3", scope: [[TupleFields]]{{.*}}flags: DIFlagPublic{{.*}})
-    pub fn use_everything() {
-        black_box(TupleFields(1, 2, 3, 4));
-    }
-}
-
-fn main() {
-    module::use_everything();
-}
diff --git a/tests/codegen/debug-alignment.rs b/tests/codegen/debug-alignment.rs
deleted file mode 100644
index 02fe05832a3..00000000000
--- a/tests/codegen/debug-alignment.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// Verifies that DWARF alignment is specified properly.
-//
-//@ compile-flags: -C debuginfo=2
-#![crate_type = "lib"]
-
-// CHECK: !DIGlobalVariable
-// CHECK: align: 32
-pub static A: u32 = 1;
diff --git a/tests/codegen/debug-column-msvc.rs b/tests/codegen/debug-column-msvc.rs
deleted file mode 100644
index 39f77f41329..00000000000
--- a/tests/codegen/debug-column-msvc.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Verify that no column information is emitted for MSVC targets
-//
-//@ only-msvc
-//@ compile-flags: -C debuginfo=2
-
-// CHECK-NOT: !DILexicalBlock({{.*}}column: {{.*}})
-// CHECK-NOT: !DILocation({{.*}}column: {{.*}})
-
-pub fn add(a: u32, b: u32) -> u32 {
-    a + b
-}
-
-fn main() {
-    let c = add(1, 2);
-    println!("{}", c);
-}
diff --git a/tests/codegen/debug-column.rs b/tests/codegen/debug-column.rs
deleted file mode 100644
index 2aa0a8a864c..00000000000
--- a/tests/codegen/debug-column.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Verify that debuginfo column numbers are 1-based byte offsets.
-//
-//@ ignore-msvc
-//@ compile-flags: -C debuginfo=2
-
-#[rustfmt::skip]
-fn main() {
-    unsafe {
-        // Column numbers are 1-based. Regression test for #65437.
-        // CHECK: call void @giraffe(){{( #[0-9]+)?}}, !dbg [[A:!.*]]
-        giraffe();
-
-        // Column numbers use byte offests. Regression test for #67360
-        // CHECK: call void @turtle(){{( #[0-9]+)?}}, !dbg [[B:!.*]]
-/* ż */ turtle();
-
-        // CHECK: [[A]] = !DILocation(line: 11, column: 9,
-        // CHECK: [[B]] = !DILocation(line: 15, column: 10,
-    }
-}
-
-extern "C" {
-    fn giraffe();
-    fn turtle();
-}
diff --git a/tests/codegen/debug-compile-unit-path.rs b/tests/codegen/debug-compile-unit-path.rs
deleted file mode 100644
index 6131d9d7351..00000000000
--- a/tests/codegen/debug-compile-unit-path.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ compile-flags: -g --remap-path-prefix={{cwd}}=/cwd/ --remap-path-prefix={{src-base}}=/base/
-//
-//
-// Ensure that we remap the compile unit directory and that we set it to the compilers current
-// working directory and not something else.
-#![crate_type = "rlib"]
-
-// CHECK-DAG: [[FILE:![0-9]*]] = !DIFile(filename: "/base/debug-compile-unit-path.rs{{.*}}", directory: "/cwd/")
-// CHECK-DAG: {{![0-9]*}} = distinct !DICompileUnit({{.*}}file: [[FILE]]
diff --git a/tests/codegen/debug-fndef-size.rs b/tests/codegen/debug-fndef-size.rs
deleted file mode 100644
index 8f716c34e7b..00000000000
--- a/tests/codegen/debug-fndef-size.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Verify that `i32::cmp` FnDef type is declared with a size of 0 and an
-// alignment of 8 bits (1 byte) in LLVM debuginfo.
-
-//@ compile-flags: -Copt-level=3 -g -Cno-prepopulate-passes
-//@ ignore-msvc the types are mangled differently
-
-use std::cmp::Ordering;
-
-fn foo<F: FnOnce(&i32, &i32) -> Ordering>(v1: i32, v2: i32, compare: F) -> Ordering {
-    compare(&v1, &v2)
-}
-
-pub fn main() {
-    foo(0, 1, i32::cmp);
-}
-
-// CHECK: %compare.dbg.spill = alloca [0 x i8], align 1
-// CHECK: dbg{{.}}declare({{(metadata )?}}ptr %compare.dbg.spill, {{(metadata )?}}![[VAR:.*]], {{(metadata )?}}!DIExpression()
-// CHECK: ![[TYPE:.*]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "fn(&i32, &i32) -> core::cmp::Ordering", baseType: !{{.*}}, align: 8, dwarfAddressSpace: {{.*}})
-// CHECK: ![[VAR]] = !DILocalVariable(name: "compare", scope: !{{.*}}, file: !{{.*}}, line: {{.*}}, type: ![[TYPE]], align: 8)
diff --git a/tests/codegen/debug-limited.rs b/tests/codegen/debug-limited.rs
deleted file mode 100644
index 89a4ef0ca90..00000000000
--- a/tests/codegen/debug-limited.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Verify that the limited debuginfo option emits llvm's FullDebugInfo, but no type info.
-//
-//@ compile-flags: -C debuginfo=limited
-
-#[repr(C)]
-struct StructType {
-    a: i64,
-    b: i32,
-}
-
-extern "C" {
-    fn creator() -> *mut StructType;
-    fn save(p: *const StructType);
-}
-
-fn main() {
-    unsafe {
-        let value: &mut StructType = &mut *creator();
-        value.a = 7;
-        save(value as *const StructType)
-    }
-}
-
-// CHECK: !DICompileUnit
-// CHECK: emissionKind: FullDebug
-// CHECK: !DILocation
-// CHECK-NOT: !DIBasicType
diff --git a/tests/codegen/debug-line-directives-only.rs b/tests/codegen/debug-line-directives-only.rs
deleted file mode 100644
index 709c8789bf8..00000000000
--- a/tests/codegen/debug-line-directives-only.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Verify that the only debuginfo generated are the line directives.
-//
-//@ compile-flags: -C debuginfo=line-directives-only
-
-#[repr(C)]
-struct StructType {
-    a: i64,
-    b: i32,
-}
-
-extern "C" {
-    fn creator() -> *mut StructType;
-    fn save(p: *const StructType);
-}
-
-fn main() {
-    unsafe {
-        let value: &mut StructType = &mut *creator();
-        value.a = 7;
-        save(value as *const StructType)
-    }
-}
-
-// CHECK: !DICompileUnit
-// CHECK: emissionKind: DebugDirectivesOnly
-// CHECK: !DILocation
-// CHECK-NOT: !DIBasicType
diff --git a/tests/codegen/debug-line-tables-only.rs b/tests/codegen/debug-line-tables-only.rs
deleted file mode 100644
index d50bffe6e60..00000000000
--- a/tests/codegen/debug-line-tables-only.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Verify that the only debuginfo generated are the line tables.
-//
-//@ compile-flags: -C debuginfo=line-tables-only
-
-#[repr(C)]
-struct StructType {
-    a: i64,
-    b: i32,
-}
-
-extern "C" {
-    fn creator() -> *mut StructType;
-    fn save(p: *const StructType);
-}
-
-fn main() {
-    unsafe {
-        let value: &mut StructType = &mut *creator();
-        value.a = 7;
-        save(value as *const StructType)
-    }
-}
-
-// CHECK: !DICompileUnit
-// CHECK: emissionKind: LineTablesOnly
-// CHECK: !DILocation
-// CHECK-NOT: !DIBasicType
diff --git a/tests/codegen/debug-linkage-name.rs b/tests/codegen/debug-linkage-name.rs
deleted file mode 100644
index e706040f331..00000000000
--- a/tests/codegen/debug-linkage-name.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Verifies that linkage name is omitted when it is
-// the same as variable / function name.
-//
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-//@ compile-flags: -C debuginfo=2 -Copt-level=0
-#![crate_type = "lib"]
-
-pub mod xyz {
-    // CHECK: !DIGlobalVariable(name: "A",
-    // CHECK:                   linkageName:
-    // CHECK-SAME:              line: 12,
-    pub static A: u32 = 1;
-
-    // CHECK: !DIGlobalVariable(name: "B",
-    // CHECK-NOT:               linkageName:
-    // CHECK-SAME:              line: 18,
-    #[no_mangle]
-    pub static B: u32 = 2;
-
-    // CHECK: !DIGlobalVariable(name: "C",
-    // CHECK-NOT:               linkageName:
-    // CHECK-SAME:              line: 24,
-    #[export_name = "C"]
-    pub static C: u32 = 2;
-
-    // CHECK: !DISubprogram(name: "e",
-    // CHECK:               linkageName:
-    // CHECK-SAME:          line: 29,
-    pub extern "C" fn e() {}
-
-    // CHECK: !DISubprogram(name: "f",
-    // CHECK-NOT:           linkageName:
-    // CHECK-SAME:          line: 35,
-    #[no_mangle]
-    pub extern "C" fn f() {}
-
-    // CHECK: !DISubprogram(name: "g",
-    // CHECK-NOT:           linkageName:
-    // CHECK-SAME:          line: 41,
-    #[export_name = "g"]
-    pub extern "C" fn g() {}
-}
diff --git a/tests/codegen/debug-vtable.rs b/tests/codegen/debug-vtable.rs
deleted file mode 100644
index 8a7b1cc3c4b..00000000000
--- a/tests/codegen/debug-vtable.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-// ignore-tidy-linelength
-//! This test checks the debuginfo for the expected 3 vtables is generated for correct names and
-//! number of entries.
-
-//@ revisions: MSVC NONMSVC
-//@[MSVC] only-msvc
-//@[NONMSVC] ignore-msvc
-
-// Use the v0 symbol mangling scheme to codegen order independent of rustc version.
-// Unnamed items like shims are generated in lexicographical order of their symbol name and in the
-// legacy mangling scheme rustc version and generic parameters are both hashed into a single part
-// of the name, thus randomizing item order with respect to rustc version.
-
-//@ compile-flags: -Cdebuginfo=2 -Copt-level=0 -Csymbol-mangling-version=v0
-
-// Make sure that vtables don't have the unnamed_addr attribute when debuginfo is enabled.
-// This helps debuggers more reliably map from dyn pointer to concrete type.
-// CHECK: @vtable.2 = private constant [
-// CHECK: @vtable.3 = private constant <{
-// CHECK: @vtable.4 = private constant <{
-
-// NONMSVC: ![[USIZE:[0-9]+]] = !DIBasicType(name: "usize"
-// MSVC: ![[USIZE:[0-9]+]] = !DIDerivedType(tag: DW_TAG_typedef, name: "usize"
-// NONMSVC: ![[PTR:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "*const ()"
-// MSVC: ![[PTR:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "ptr_const$<tuple$<> >"
-
-// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as debug_vtable::SomeTrait>::{vtable}"
-// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, debug_vtable::SomeTrait>::vtable$"
-
-// NONMSVC: ![[VTABLE_TY0:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "<debug_vtable::Foo as debug_vtable::SomeTrait>::{vtable_type}", {{.*}} size: {{320|160}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}} vtableHolder: ![[FOO_TYPE:[0-9]+]],
-// MSVC: ![[VTABLE_TY0:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "impl$<debug_vtable::Foo, debug_vtable::SomeTrait>::vtable_type$", {{.*}} size: {{320|160}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}} vtableHolder: ![[FOO_TYPE:[0-9]+]],
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "drop_in_place", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}})
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "size", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{64|32}})
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "align", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{128|64}})
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__method3", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}}, offset: {{192|96}})
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__method4", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}}, offset: {{256|128}})
-// CHECK: ![[FOO_TYPE]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Foo",
-
-// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as debug_vtable::SomeTraitWithGenerics<u64, i8>>::{vtable}"
-// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, debug_vtable::SomeTraitWithGenerics<u64,i8> >::vtable$"
-
-// NONMSVC: ![[VTABLE_TY1:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "<debug_vtable::Foo as debug_vtable::SomeTraitWithGenerics<u64, i8>>::{vtable_type}", {{.*}}, size: {{256|128}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
-// MSVC: ![[VTABLE_TY1:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "impl$<debug_vtable::Foo, debug_vtable::SomeTraitWithGenerics<u64,i8> >::vtable_type$", {{.*}}, size: {{256|128}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "drop_in_place", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}})
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "size", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{64|32}})
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "align", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{128|64}})
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__method3", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}}, offset: {{192|96}})
-
-// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as _>::{vtable}"
-// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, _>::vtable$"
-
-// NONMSVC: ![[VTABLE_TY2:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "<debug_vtable::Foo as _>::{vtable_type}", {{.*}}, size: {{192|96}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
-// MSVC: ![[VTABLE_TY2:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "impl$<debug_vtable::Foo, _>::vtable_type$", {{.*}}, size: {{192|96}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "drop_in_place", scope: ![[VTABLE_TY2]], {{.*}}, baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}})
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "size", scope: ![[VTABLE_TY2]], {{.*}}, baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{64|32}})
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "align", scope: ![[VTABLE_TY2]], {{.*}}, baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{128|64}})
-
-// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::bar::{closure_env#0} as core::ops::function::FnOnce<(core::option::Option<&dyn core::ops::function::Fn<(), Output=()>>)>>::{vtable}"
-// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::bar::closure_env$0, core::ops::function::FnOnce<tuple$<enum2$<core::option::Option<ref$<dyn$<core::ops::function::Fn<tuple$<>,assoc$<Output,tuple$<> > > > > > > > > >::vtable$"
-
-// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::generic_closure::{closure_env#0}<bool> as core::ops::function::FnOnce<()>>::{vtable}"
-// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::generic_closure::closure_env$0<bool>, core::ops::function::FnOnce<tuple$<> > >::vtable$
-
-// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::generic_closure::{closure_env#0}<u32> as core::ops::function::FnOnce<()>>::{vtable}"
-// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::generic_closure::closure_env$0<u32>, core::ops::function::FnOnce<tuple$<> > >::vtable$
-
-#![crate_type = "lib"]
-
-// Force emission for debuginfo for usize and *const() early..
-pub static mut XYZ: Option<(usize, *const ())> = None;
-
-pub struct Foo;
-
-pub trait SomeTrait {
-    fn method1(&self) -> u32;
-    fn method2(&self) -> u32;
-}
-
-impl SomeTrait for Foo {
-    fn method1(&self) -> u32 {
-        1
-    }
-    fn method2(&self) -> u32 {
-        2
-    }
-}
-
-pub trait SomeTraitWithGenerics<T, U> {
-    fn method1(&self) -> (T, U);
-}
-
-impl SomeTraitWithGenerics<u64, i8> for Foo {
-    fn method1(&self) -> (u64, i8) {
-        (1, 2)
-    }
-}
-
-pub fn foo(x: &Foo) -> (u32, (u64, i8), &dyn Send) {
-    let y: &dyn SomeTrait = x;
-    let z: &dyn SomeTraitWithGenerics<u64, i8> = x;
-    (y.method1(), z.method1(), x as &dyn Send)
-}
-
-// Constructing the debuginfo name for the FnOnce vtable below initially caused an ICE on MSVC
-// because the trait type contains a late bound region that needed to be erased before the type
-// layout for the niche enum `Option<&dyn Fn()>` could be computed.
-pub fn bar() -> Box<dyn FnOnce(Option<&dyn Fn()>)> {
-    Box::new(|_x: Option<&dyn Fn()>| {})
-}
-
-fn generic_closure<T: 'static>(x: T) -> Box<dyn FnOnce() -> T> {
-    Box::new(move || x)
-}
-
-pub fn instantiate_generic_closures() -> (Box<dyn FnOnce() -> u32>, Box<dyn FnOnce() -> bool>) {
-    (generic_closure(1u32), generic_closure(false))
-}
diff --git a/tests/codegen/debuginfo-constant-locals.rs b/tests/codegen/debuginfo-constant-locals.rs
deleted file mode 100644
index 580c69c05a5..00000000000
--- a/tests/codegen/debuginfo-constant-locals.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ compile-flags: -g -Copt-level=3
-
-// Check that simple constant values are preserved in debuginfo across both MIR opts and LLVM opts
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn check_it() {
-    let a = 1;
-    let b = 42;
-
-    foo(a + b);
-}
-
-#[inline(never)]
-fn foo(x: i32) {
-    std::process::exit(x);
-}
-
-// CHECK-LABEL: @check_it
-// CHECK: dbg{{.}}value({{(metadata )?}}i32 1, {{(metadata )?}}![[a_metadata:[0-9]+]], {{(metadata )?}}!DIExpression()
-// CHECK: dbg{{.}}value({{(metadata )?}}i32 42, {{(metadata )?}}![[b_metadata:[0-9]+]], {{(metadata )?}}!DIExpression()
-
-// CHECK: ![[a_metadata]] = !DILocalVariable(name: "a"
-// CHECK-SAME: line: 9
-
-// CHECK: ![[b_metadata]] = !DILocalVariable(name: "b"
-// CHECK-SAME: line: 10
diff --git a/tests/codegen/debuginfo-generic-closure-env-names.rs b/tests/codegen/debuginfo-generic-closure-env-names.rs
deleted file mode 100644
index 64bc58e1df7..00000000000
--- a/tests/codegen/debuginfo-generic-closure-env-names.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-// ignore-tidy-linelength
-//! This test checks that we get proper type names for closure environments and
-//! async-fn environments in debuginfo, especially making sure that generic arguments
-//! of the enclosing functions don't get lost.
-//!
-//! Unfortunately, the order that debuginfo gets emitted into LLVM IR becomes a bit hard
-//! to predict once async fns are involved, so DAG allows any order.
-//!
-//! Note that the test does not check async-fns when targeting MSVC because debuginfo for
-//! those does not follow the enum-fallback encoding yet and thus is incomplete.
-
-//@ revisions: MSVC NONMSVC
-//@[MSVC] only-msvc
-//@[NONMSVC] ignore-msvc
-
-// Use the v0 symbol mangling scheme to codegen order independent of rustc version.
-// Unnamed items like shims are generated in lexicographical order of their symbol name and in the
-// legacy mangling scheme rustc version and generic parameters are both hashed into a single part
-// of the name, thus randomizing item order with respect to rustc version.
-
-//@ compile-flags: -Cdebuginfo=2 -Copt-level=0 -Csymbol-mangling-version=v0
-//@ edition: 2021
-
-// non_generic_closure()
-// NONMSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}", scope: ![[non_generic_closure_NAMESPACE:[0-9]+]],
-// MSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "closure_env$0", scope: ![[non_generic_closure_NAMESPACE:[0-9]+]],
-// CHECK: ![[non_generic_closure_NAMESPACE]] = !DINamespace(name: "non_generic_closure"
-
-// CHECK: ![[function_containing_closure_NAMESPACE:[0-9]+]] = !DINamespace(name: "function_containing_closure"
-// CHECK: ![[generic_async_function_NAMESPACE:[0-9]+]] = !DINamespace(name: "generic_async_function"
-// CHECK: ![[generic_async_block_NAMESPACE:[0-9]+]] = !DINamespace(name: "generic_async_block"
-
-// function_containing_closure<u32>()
-// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}<u32>", scope: ![[function_containing_closure_NAMESPACE]]
-// MSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "closure_env$0<u32>", scope: ![[function_containing_closure_NAMESPACE]]
-
-// generic_async_function<Foo>()
-// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}<debuginfo_generic_closure_env_names::Foo>", scope: ![[generic_async_function_NAMESPACE]]
-
-// generic_async_function<u32>()
-// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}<u32>", scope: ![[generic_async_function_NAMESPACE]]
-
-// generic_async_block<Foo>()
-// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_block_env#0}<debuginfo_generic_closure_env_names::Foo>", scope: ![[generic_async_block_NAMESPACE]]
-
-// generic_async_block<u32>()
-// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_block_env#0}<u32>", scope: ![[generic_async_block_NAMESPACE]]
-
-// function_containing_closure<Foo>()
-// NONMSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}<debuginfo_generic_closure_env_names::Foo>", scope: ![[function_containing_closure_NAMESPACE]]
-// MSVC-DAG: !DICompositeType(tag: DW_TAG_structure_type, name: "closure_env$0<debuginfo_generic_closure_env_names::Foo>", scope: ![[function_containing_closure_NAMESPACE]]
-
-#![crate_type = "lib"]
-use std::future::Future;
-
-pub struct Foo;
-
-pub fn non_generic_closure(x: Foo) -> Box<dyn FnOnce() -> Foo> {
-    return Box::new(move || x);
-}
-
-fn function_containing_closure<T: 'static>(x: T) -> impl FnOnce() -> T {
-    // This static only exists to trigger generating the namespace debuginfo for
-    // `function_containing_closure` at a predictable, early point, which makes
-    // writing the FileCheck tests above simpler.
-    static _X: u8 = 0;
-
-    return move || x;
-}
-
-async fn generic_async_function<T: 'static>(x: T) -> T {
-    static _X: u8 = 0; // Same as above
-    x
-}
-
-fn generic_async_block<T: 'static>(x: T) -> impl Future<Output = T> {
-    static _X: u8 = 0; // Same as above
-    async move { x }
-}
-
-pub fn instantiate_generics() {
-    let _closure_u32 = function_containing_closure(7u32);
-    let _closure_foo = function_containing_closure(Foo);
-
-    let _async_fn_u32 = generic_async_function(42u32);
-    let _async_fn_foo = generic_async_function(Foo);
-
-    let _async_block_u32 = generic_async_block(64u32);
-    let _async_block_foo = generic_async_block(Foo);
-}
diff --git a/tests/codegen/debuginfo-inline-callsite-location.rs b/tests/codegen/debuginfo-inline-callsite-location.rs
deleted file mode 100644
index 59ade52ad32..00000000000
--- a/tests/codegen/debuginfo-inline-callsite-location.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ compile-flags: -g -Copt-level=3 -C panic=abort
-
-// Check that each inline call site for the same function uses the same "sub-program" so that LLVM
-// can correctly merge the debug info if it merges the inlined code (e.g., for merging of tail
-// calls to panic.
-
-// CHECK:       tail call void @{{[A-Za-z0-9_]+4core6option13unwrap_failed}}
-// CHECK-SAME:  !dbg ![[#first_dbg:]]
-// CHECK:       tail call void @{{[A-Za-z0-9_]+4core6option13unwrap_failed}}
-// CHECK-SAME:  !dbg ![[#second_dbg:]]
-
-// CHECK-DAG:   ![[#func_scope:]] = distinct !DISubprogram(name: "unwrap<i32>"
-// CHECK-DAG:   ![[#]] = !DILocalVariable(name: "self",{{( arg: 1,)?}} scope: ![[#func_scope]]
-// CHECK:       ![[#first_dbg]] = !DILocation(line: [[#]]
-// CHECK-SAME:  scope: ![[#func_scope]], inlinedAt: ![[#]])
-// CHECK:       ![[#second_dbg]] = !DILocation(line: [[#]]
-// CHECK-SAME:  scope: ![[#func_scope]], inlinedAt: ![[#]])
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-extern "C" fn add_numbers(x: &Option<i32>, y: &Option<i32>) -> i32 {
-    let x1 = x.unwrap();
-    let y1 = y.unwrap();
-
-    x1 + y1
-}
diff --git a/tests/codegen/debuginfo-proc-macro/auxiliary/macro_def.rs b/tests/codegen/debuginfo-proc-macro/auxiliary/macro_def.rs
deleted file mode 100644
index c0691b23275..00000000000
--- a/tests/codegen/debuginfo-proc-macro/auxiliary/macro_def.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-extern crate proc_macro;
-use proc_macro::*;
-
-#[proc_macro]
-pub fn square_twice(_item: TokenStream) -> TokenStream {
-    "(square(env::vars().count() as i32), square(env::vars().count() as i32))".parse().unwrap()
-}
diff --git a/tests/codegen/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs b/tests/codegen/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs
deleted file mode 100644
index 7530689d574..00000000000
--- a/tests/codegen/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-//@ compile-flags: -Cdebuginfo=2 -Copt-level=0 -Zmir-enable-passes=+Inline
-// MSVC is different because of the individual allocas.
-//@ ignore-msvc
-
-//@ proc-macro: macro_def.rs
-
-// Find the variable.
-// CHECK-DAG: ![[#var_dbg:]] = !DILocalVariable(name: "n",{{( arg: 1,)?}} scope: ![[#var_scope:]]
-
-// Find both dbg_declares. These will proceed the variable metadata, of course, so we're looking
-// backwards.
-// CHECK-DAG: dbg_declare(ptr %n.dbg.spill{{[0-9]}}, ![[#var_dbg]], !DIExpression(), ![[#var_loc2:]])
-// CHECK-DAG: dbg_declare(ptr %n.dbg.spill, ![[#var_dbg]], !DIExpression(), ![[#var_loc1:]])
-
-// Find the first location definition, looking forwards again.
-// CHECK: ![[#var_loc1]] = !DILocation
-// CHECK-SAME: scope: ![[#var_scope:]], inlinedAt: ![[#var_inlinedAt1:]]
-
-// Find the first location's inlinedAt
-// NB: If we fail here it's *probably* because we failed to produce two
-// different locations and ended up reusing an earlier one.
-// CHECK: ![[#var_inlinedAt1]] = !DILocation
-// CHECK-SAME: scope: ![[var_inlinedAt1_scope:]]
-
-// Find the second location definition, still looking forwards.
-// NB: If we failed to produce two different locations, the test will
-// definitely fail by this point (if it hasn't already) because we won't
-// be able to find the same line again.
-// CHECK: ![[#var_loc2]] = !DILocation
-// CHECK-SAME: scope: ![[#var_scope]], inlinedAt: ![[#var_inlinedAt2:]]
-
-// Find the second location's inlinedAt.
-// CHECK: ![[#var_inlinedAt2]] = !DILocation
-// CHECK-SAME: scope: ![[#var_inlinedAt2_scope:]]
-
-// Finally, check that a discriminator was emitted for the second scope.
-// FIXMEkhuey ideally we would check that *either* scope has a discriminator
-// but I don't know that it's possible to check that with FileCheck.
-// CHECK: ![[#var_inlinedAt2_scope]] = !DILexicalBlockFile
-// CHECK-SAME: discriminator: [[#]]
-extern crate macro_def;
-
-use std::env;
-
-fn square(n: i32) -> i32 {
-    n * n
-}
-
-fn main() {
-    let (z1, z2) = macro_def::square_twice!();
-    println!("{z1} == {z2}");
-}
diff --git a/tests/codegen/deduced-param-attrs.rs b/tests/codegen/deduced-param-attrs.rs
deleted file mode 100644
index 34504c80fad..00000000000
--- a/tests/codegen/deduced-param-attrs.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-#![allow(internal_features)]
-#![feature(unsized_fn_params)]
-
-use std::cell::Cell;
-use std::hint;
-
-// Check to make sure that we can deduce the `readonly` attribute from function bodies for
-// parameters passed indirectly.
-
-pub struct BigStruct {
-    blah: [i32; 1024],
-}
-
-pub struct BigCellContainer {
-    blah: [Cell<i32>; 1024],
-}
-
-// The by-value parameter for this big struct can be marked readonly.
-//
-// CHECK: @use_big_struct_immutably({{.*}} readonly {{.*}} %big_struct)
-#[no_mangle]
-pub fn use_big_struct_immutably(big_struct: BigStruct) {
-    hint::black_box(&big_struct);
-}
-
-// The by-value parameter for this big struct can't be marked readonly, because we mutate it.
-//
-// CHECK-NOT: @use_big_struct_mutably({{.*}} readonly {{.*}} %big_struct)
-#[no_mangle]
-pub fn use_big_struct_mutably(mut big_struct: BigStruct) {
-    big_struct.blah[987] = 654;
-    hint::black_box(&big_struct);
-}
-
-// The by-value parameter for this big struct can't be marked readonly, because it contains
-// UnsafeCell.
-//
-// CHECK-NOT: @use_big_cell_container({{.*}} readonly {{.*}} %big_cell_container)
-#[no_mangle]
-pub fn use_big_cell_container(big_cell_container: BigCellContainer) {
-    hint::black_box(&big_cell_container);
-}
-
-// Make sure that we don't mistakenly mark a big struct as `readonly` when passed through a generic
-// type parameter if it contains UnsafeCell.
-//
-// CHECK-NOT: @use_something({{.*}} readonly {{.*}} %something)
-#[no_mangle]
-#[inline(never)]
-pub fn use_something<T>(something: T) {
-    hint::black_box(&something);
-}
-
-#[no_mangle]
-pub fn forward_big_cell_container(big_cell_container: BigCellContainer) {
-    use_something(big_cell_container)
-}
diff --git a/tests/codegen/default-requires-uwtable.rs b/tests/codegen/default-requires-uwtable.rs
deleted file mode 100644
index 54a6e171db6..00000000000
--- a/tests/codegen/default-requires-uwtable.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ add-core-stubs
-//@ revisions: WINDOWS_ ANDROID_
-//@ compile-flags: -C panic=abort -Copt-level=0
-//@ [WINDOWS_] compile-flags: --target=x86_64-pc-windows-msvc
-//@ [WINDOWS_] needs-llvm-components: x86
-//@ [ANDROID_] compile-flags: --target=armv7-linux-androideabi
-//@ [ANDROID_] needs-llvm-components: arm
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: attributes #{{.*}} uwtable
-pub fn foo() {}
diff --git a/tests/codegen/default-visibility.rs b/tests/codegen/default-visibility.rs
deleted file mode 100644
index 88ff9fee254..00000000000
--- a/tests/codegen/default-visibility.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-// Verifies that `Session::default_visibility` is affected when using the related cmdline
-// flag.  This is a regression test for https://github.com/rust-lang/compiler-team/issues/782.  See
-// also https://github.com/rust-lang/rust/issues/73295 and
-// https://github.com/rust-lang/rust/issues/37530.
-
-//@ revisions:DEFAULT HIDDEN PROTECTED INTERPOSABLE
-//@[HIDDEN] compile-flags: -Zdefault-visibility=hidden
-//@[PROTECTED] compile-flags: -Zdefault-visibility=protected
-//@[INTERPOSABLE] compile-flags: -Zdefault-visibility=interposable
-
-// The test scenario is specifically about visibility of symbols exported out of dynamically linked
-// libraries.
-#![crate_type = "dylib"]
-
-// The test scenario needs to use a Rust-public, but non-explicitly-exported symbol
-// (e.g. the test doesn't use `#[no_mangle]`, because currently it implies that
-// the symbol should be exported;  we don't want that - we want to test the *default*
-// export setting instead).
-#[used]
-pub static tested_symbol: [u8; 6] = *b"foobar";
-
-// Exact LLVM IR differs depending on the target triple (e.g. `hidden constant`
-// vs `internal constant` vs `constant`).  Because of this, we only apply the
-// specific test expectations below to one specific target triple.  If needed,
-// additional targets can be covered by adding copies of this test file with
-// a different `only-X` directive.
-//
-//@     only-x86_64-unknown-linux-gnu
-
-// HIDDEN:       @{{.*}}default_visibility{{.*}}tested_symbol{{.*}} = hidden constant
-// PROTECTED:    @{{.*}}default_visibility{{.*}}tested_symbol{{.*}} = protected constant
-// INTERPOSABLE: @{{.*}}default_visibility{{.*}}tested_symbol{{.*}} = constant
-// DEFAULT:      @{{.*}}default_visibility{{.*}}tested_symbol{{.*}} = constant
-
-pub fn do_memcmp(left: &[u8], right: &[u8]) -> i32 {
-    left.cmp(right) as i32
-}
-
-// CHECK: define {{.*}} @{{.*}}do_memcmp{{.*}} {
-// CHECK: }
-
-// `do_memcmp` should invoke core::intrinsic::compare_bytes which emits a call
-// to the C symbol `memcmp` (at least on x86_64-unknown-linux-gnu). This symbol
-// should *not* be declared hidden or protected.
-
-// HIDDEN:       declare i32 @memcmp
-// PROTECTED:    declare i32 @memcmp
-// INTERPOSABLE: declare i32 @memcmp
-// DEFAULT:      declare i32 @memcmp
diff --git a/tests/codegen/direct-access-external-data.rs b/tests/codegen/direct-access-external-data.rs
deleted file mode 100644
index 5b2ff41ef05..00000000000
--- a/tests/codegen/direct-access-external-data.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ only-loongarch64-unknown-linux-gnu
-
-//@ revisions: DEFAULT DIRECT INDIRECT
-//@ [DEFAULT] compile-flags: -C relocation-model=static
-//@ [DIRECT] compile-flags: -C relocation-model=static -Z direct-access-external-data=yes
-//@ [INDIRECT] compile-flags: -C relocation-model=static -Z direct-access-external-data=no
-
-#![crate_type = "rlib"]
-
-// DEFAULT: @VAR = external {{.*}} global i32
-// DIRECT: @VAR = external dso_local {{.*}} global i32
-// INDIRECT: @VAR = external {{.*}} global i32
-
-extern "C" {
-    static VAR: i32;
-}
-
-#[no_mangle]
-pub fn get() -> i32 {
-    unsafe { VAR }
-}
diff --git a/tests/codegen/dllimports/auxiliary/dummy.rs b/tests/codegen/dllimports/auxiliary/dummy.rs
deleted file mode 100644
index ab3dbc6a300..00000000000
--- a/tests/codegen/dllimports/auxiliary/dummy.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//@ no-prefer-dynamic
-#![crate_type = "staticlib"]
-
-// Since codegen tests don't actually perform linking, this library doesn't need to export
-// any symbols.  It's here just to satisfy the compiler looking for a .lib file when processing
-// #[link(...)] attributes in wrapper.rs.
diff --git a/tests/codegen/dllimports/auxiliary/wrapper.rs b/tests/codegen/dllimports/auxiliary/wrapper.rs
deleted file mode 100644
index 00a29f7ee7e..00000000000
--- a/tests/codegen/dllimports/auxiliary/wrapper.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ no-prefer-dynamic
-#![crate_type = "rlib"]
-
-#[link(name = "dummy", kind = "dylib")]
-extern "C" {
-    pub fn dylib_func2(x: i32) -> i32;
-    pub static dylib_global2: i32;
-}
-
-#[link(name = "dummy", kind = "static")]
-extern "C" {
-    pub fn static_func2(x: i32) -> i32;
-    pub static static_global2: i32;
-}
diff --git a/tests/codegen/dllimports/main.rs b/tests/codegen/dllimports/main.rs
deleted file mode 100644
index 93d350a2238..00000000000
--- a/tests/codegen/dllimports/main.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-// This test is for *-windows-msvc only.
-//@ only-windows
-//@ ignore-gnu
-
-//@ aux-build:dummy.rs
-//@ aux-build:wrapper.rs
-
-extern crate wrapper;
-
-// Check that external symbols coming from foreign dylibs are adorned with 'dllimport',
-// whereas symbols coming from foreign staticlibs are not. (RFC-1717)
-
-// CHECK: @dylib_global1 = external dllimport local_unnamed_addr global i32
-// CHECK: @dylib_global2 = external dllimport local_unnamed_addr global i32
-// CHECK: @static_global1 = external local_unnamed_addr global i32
-// CHECK: @static_global2 = external local_unnamed_addr global i32
-
-// CHECK: declare dllimport noundef i32 @dylib_func1(i32 noundef)
-// CHECK: declare dllimport noundef i32 @dylib_func2(i32 noundef)
-// CHECK: declare noundef i32 @static_func1(i32 noundef)
-// CHECK: declare noundef i32 @static_func2(i32 noundef)
-
-#[link(name = "dummy", kind = "dylib")]
-extern "C" {
-    pub fn dylib_func1(x: i32) -> i32;
-    pub static dylib_global1: i32;
-}
-
-#[link(name = "dummy", kind = "static")]
-extern "C" {
-    pub fn static_func1(x: i32) -> i32;
-    pub static static_global1: i32;
-}
-
-fn main() {
-    unsafe {
-        dylib_func1(dylib_global1);
-        wrapper::dylib_func2(wrapper::dylib_global2);
-
-        static_func1(static_global1);
-        wrapper::static_func2(wrapper::static_global2);
-    }
-}
diff --git a/tests/codegen/dont_codegen_private_const_fn_only_used_in_const_eval.rs b/tests/codegen/dont_codegen_private_const_fn_only_used_in_const_eval.rs
deleted file mode 100644
index df50b4af809..00000000000
--- a/tests/codegen/dont_codegen_private_const_fn_only_used_in_const_eval.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//! This test checks that we do not monomorphize functions that are only
-//! used to evaluate static items, but never used in runtime code.
-
-//@compile-flags: --crate-type=lib -Copt-level=0
-
-#![feature(generic_const_items)]
-
-const fn foo() {}
-
-pub static FOO: () = foo();
-
-// CHECK-NOT: define{{.*}}foo{{.*}}
-
-const fn bar() {}
-
-pub const BAR: () = bar();
-
-// CHECK-NOT: define{{.*}}bar{{.*}}
-
-const fn baz() {}
-
-#[rustfmt::skip]
-pub const BAZ<const C: bool>: () = if C {
-    baz()
-};
-
-// CHECK: define{{.*}}baz{{.*}}
diff --git a/tests/codegen/drop-in-place-noalias.rs b/tests/codegen/drop-in-place-noalias.rs
deleted file mode 100644
index bff2f52781f..00000000000
--- a/tests/codegen/drop-in-place-noalias.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-// Tests that the compiler can apply `noalias` and other &mut attributes to `drop_in_place`.
-// Note that non-Unpin types should not get `noalias`, matching &mut behavior.
-
-#![crate_type = "lib"]
-
-use std::marker::PhantomPinned;
-
-// CHECK: define internal void @{{.*}}core{{.*}}ptr{{.*}}drop_in_place{{.*}}StructUnpin{{.*}}(ptr noalias noundef align 4 dereferenceable(12) %{{.+}})
-
-// CHECK: define internal void @{{.*}}core{{.*}}ptr{{.*}}drop_in_place{{.*}}StructNotUnpin{{.*}}(ptr noundef nonnull align 4 %{{.+}})
-
-pub struct StructUnpin {
-    a: i32,
-    b: i32,
-    c: i32,
-}
-
-impl Drop for StructUnpin {
-    fn drop(&mut self) {}
-}
-
-pub struct StructNotUnpin {
-    a: i32,
-    b: i32,
-    c: i32,
-    p: PhantomPinned,
-}
-
-impl Drop for StructNotUnpin {
-    fn drop(&mut self) {}
-}
-
-pub unsafe fn main(x: StructUnpin, y: StructNotUnpin) {
-    drop(x);
-    drop(y);
-}
diff --git a/tests/codegen/drop.rs b/tests/codegen/drop.rs
deleted file mode 100644
index b22a8ef27d2..00000000000
--- a/tests/codegen/drop.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ needs-unwind - this test verifies the amount of drop calls when unwinding is used
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-struct SomeUniqueName;
-
-impl Drop for SomeUniqueName {
-    #[inline(never)]
-    fn drop(&mut self) {}
-}
-
-#[inline(never)]
-pub fn possibly_unwinding() {}
-
-// CHECK-LABEL: @droppy
-#[no_mangle]
-pub fn droppy() {
-    // Check that there are exactly 6 drop calls. The cleanups for the unwinding should be reused,
-    // so that's one new drop call per call to possibly_unwinding(), and finally 3 drop calls for
-    // the regular function exit. We used to have problems with quadratic growths of drop calls in
-    // such functions.
-    // FIXME(eddyb) the `void @` forces a match on the instruction, instead of the
-    // comment, that's `; call core::ptr::drop_in_place::<drop::SomeUniqueName>`
-    // for the `v0` mangling, should switch to matching on that once `legacy` is gone.
-    // CHECK-COUNT-6: {{(call|invoke) void @.*}}drop_in_place{{.*}}SomeUniqueName
-    // CHECK-NOT: {{(call|invoke) void @.*}}drop_in_place{{.*}}SomeUniqueName
-    // The next line checks for the } that ends the function definition
-    // CHECK-LABEL: {{^[}]}}
-    let _s = SomeUniqueName;
-    possibly_unwinding();
-    let _s = SomeUniqueName;
-    possibly_unwinding();
-    let _s = SomeUniqueName;
-    possibly_unwinding();
-}
diff --git a/tests/codegen/dst-offset.rs b/tests/codegen/dst-offset.rs
deleted file mode 100644
index 2cf5fa9fac6..00000000000
--- a/tests/codegen/dst-offset.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-//! This file tests that we correctly generate GEP instructions for DST
-//! field offsets.
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(extern_types, sized_hierarchy)]
-
-use std::marker::PointeeSized;
-use std::ptr::addr_of;
-
-// Hack to get the correct type for usize
-// CHECK: @helper([[USIZE:i[0-9]+]] %_1)
-#[no_mangle]
-pub fn helper(_: usize) {}
-
-struct Dst<T: PointeeSized> {
-    x: u32,
-    y: u8,
-    z: T,
-}
-
-// CHECK: @dst_dyn_trait_offset(ptr align {{[0-9]+}} [[DATA_PTR:%.+]], ptr align {{[0-9]+}} [[VTABLE_PTR:%.+]])
-#[no_mangle]
-pub fn dst_dyn_trait_offset(s: &Dst<dyn Drop>) -> &dyn Drop {
-    // The alignment of dyn trait is unknown, so we compute the offset based on align from the
-    // vtable.
-
-    // CHECK: [[SIZE_PTR:%[0-9]+]] = getelementptr inbounds i8, ptr [[VTABLE_PTR]]
-    // CHECK: load [[USIZE]], ptr [[SIZE_PTR]]
-    // CHECK: [[ALIGN_PTR:%[0-9]+]] = getelementptr inbounds i8, ptr [[VTABLE_PTR]]
-    // CHECK: load [[USIZE]], ptr [[ALIGN_PTR]]
-
-    // CHECK: getelementptr inbounds i8, ptr [[DATA_PTR]]
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: ret
-    &s.z
-}
-
-// CHECK-LABEL: @dst_slice_offset
-#[no_mangle]
-pub fn dst_slice_offset(s: &Dst<[u16]>) -> &[u16] {
-    // The alignment of [u16] is known, so we generate a GEP directly.
-
-    // CHECK: start:
-    // CHECK-NEXT: getelementptr inbounds i8, {{.+}}, [[USIZE]] 6
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: ret
-    &s.z
-}
-
-#[repr(packed)]
-struct PackedDstSlice {
-    x: u32,
-    y: u8,
-    z: [u16],
-}
-
-// CHECK-LABEL: @packed_dst_slice_offset
-#[no_mangle]
-pub fn packed_dst_slice_offset(s: &PackedDstSlice) -> *const [u16] {
-    // The alignment of [u16] is known, so we generate a GEP directly.
-
-    // CHECK: start:
-    // CHECK-NEXT: getelementptr inbounds i8, {{.+}}, [[USIZE]] 5
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: ret
-    addr_of!(s.z)
-}
-
-extern "C" {
-    pub type Extern;
-}
-
-// CHECK-LABEL: @dst_extern
-#[no_mangle]
-pub fn dst_extern(s: &Dst<Extern>) -> &Extern {
-    // Computing the alignment of an extern type is currently unsupported and just panics.
-
-    // CHECK: call void @{{.+}}panic
-    &s.z
-}
diff --git a/tests/codegen/dst-vtable-align-nonzero.rs b/tests/codegen/dst-vtable-align-nonzero.rs
deleted file mode 100644
index 1404bd64f50..00000000000
--- a/tests/codegen/dst-vtable-align-nonzero.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-// This test checks that we annotate alignment loads from vtables with nonzero range metadata,
-// and that this allows LLVM to eliminate redundant `align >= 1` checks.
-
-pub trait Trait {
-    fn f(&self);
-}
-
-pub struct WrapperWithAlign1<T: ?Sized> {
-    x: u8,
-    y: T,
-}
-
-pub struct WrapperWithAlign2<T: ?Sized> {
-    x: u16,
-    y: T,
-}
-
-pub struct Struct<W: ?Sized> {
-    _field: i8,
-    dst: W,
-}
-
-// CHECK-LABEL: @eliminates_runtime_check_when_align_1
-#[no_mangle]
-pub fn eliminates_runtime_check_when_align_1(
-    x: &Struct<WrapperWithAlign1<dyn Trait>>,
-) -> &WrapperWithAlign1<dyn Trait> {
-    // CHECK: load [[USIZE:i[0-9]+]], {{.+}} !range [[RANGE_META:![0-9]+]]
-    // CHECK-NOT: llvm.umax
-    // CHECK-NOT: icmp
-    // CHECK-NOT: select
-    // CHECK: ret
-    &x.dst
-}
-
-// CHECK-LABEL: @does_not_eliminate_runtime_check_when_align_2
-#[no_mangle]
-pub fn does_not_eliminate_runtime_check_when_align_2(
-    x: &Struct<WrapperWithAlign2<dyn Trait>>,
-) -> &WrapperWithAlign2<dyn Trait> {
-    // CHECK: [[X0:%[0-9]+]] = load [[USIZE]], {{.+}} !range [[RANGE_META]]
-    // CHECK: {{icmp|llvm.umax}}
-    // CHECK: ret
-    &x.dst
-}
-
-// CHECK-LABEL: @align_load_from_align_of_val
-#[no_mangle]
-pub fn align_load_from_align_of_val(x: &dyn Trait) -> usize {
-    // CHECK: {{%[0-9]+}} = load [[USIZE]], {{.+}} !range [[RANGE_META]]
-    core::mem::align_of_val(x)
-}
-
-// CHECK-LABEL: @align_load_from_vtable_align_intrinsic
-#[no_mangle]
-pub unsafe fn align_load_from_vtable_align_intrinsic(x: &dyn Trait) -> usize {
-    let (data, vtable): (*const (), *const ()) = core::mem::transmute(x);
-    // CHECK: {{%[0-9]+}} = load [[USIZE]], {{.+}} !range [[RANGE_META]]
-    core::intrinsics::vtable_align(vtable)
-}
-
-// CHECK: [[RANGE_META]] = !{[[USIZE]] 1, [[USIZE]] 0}
diff --git a/tests/codegen/dst-vtable-size-range.rs b/tests/codegen/dst-vtable-size-range.rs
deleted file mode 100644
index 670f5e8d553..00000000000
--- a/tests/codegen/dst-vtable-size-range.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-// Check that we annotate size loads from vtables with 0..(isize::MAX + 1) range metadata.
-
-pub trait Trait {
-    fn f(&self);
-}
-
-// Note that rustc uses inclusive bounds, but LLVM uses exclusive bounds for range metadata.
-// CHECK-LABEL: @generate_exclusive_bound
-#[no_mangle]
-pub fn generate_exclusive_bound() -> usize {
-    // CHECK: ret [[USIZE:i[0-9]+]] [[EXCLUSIVE_BOUND:[-0-9]+]]
-    isize::MAX as usize + 1
-}
-
-// CHECK-LABEL: @size_load_from_size_of_val
-#[no_mangle]
-pub fn size_load_from_size_of_val(x: &dyn Trait) -> usize {
-    // CHECK: {{%[0-9]+}} = load [[USIZE]], {{.+}} !range [[RANGE_META:![0-9]+]]
-    core::mem::size_of_val(x)
-}
-
-// CHECK-LABEL: @size_load_from_vtable_size_intrinsic
-#[no_mangle]
-pub unsafe fn size_load_from_vtable_size_intrinsic(x: &dyn Trait) -> usize {
-    let (data, vtable): (*const (), *const ()) = core::mem::transmute(x);
-    // CHECK: {{%[0-9]+}} = load [[USIZE]], {{.+}} !range [[RANGE_META]]
-    core::intrinsics::vtable_size(vtable)
-}
-
-// CHECK: [[RANGE_META]] = !{[[USIZE]] 0, [[USIZE]] [[EXCLUSIVE_BOUND]]}
diff --git a/tests/codegen/ehcontguard_disabled.rs b/tests/codegen/ehcontguard_disabled.rs
deleted file mode 100644
index 9efb2721b3e..00000000000
--- a/tests/codegen/ehcontguard_disabled.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ compile-flags:
-
-#![crate_type = "lib"]
-
-// A basic test function.
-pub fn test() {}
-
-// Ensure the module flag ehcontguard is not present
-// CHECK-NOT: !"ehcontguard"
diff --git a/tests/codegen/ehcontguard_enabled.rs b/tests/codegen/ehcontguard_enabled.rs
deleted file mode 100644
index ecc5512fd5d..00000000000
--- a/tests/codegen/ehcontguard_enabled.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ compile-flags: -Z ehcont-guard
-
-#![crate_type = "lib"]
-
-// A basic test function.
-pub fn test() {}
-
-// Ensure the module flag ehcontguard=1 is present
-// CHECK: !"ehcontguard", i32 1
diff --git a/tests/codegen/emscripten-catch-unwind-js-eh.rs b/tests/codegen/emscripten-catch-unwind-js-eh.rs
deleted file mode 100644
index f43869cf218..00000000000
--- a/tests/codegen/emscripten-catch-unwind-js-eh.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-//@ compile-flags: -Copt-level=3 --target wasm32-unknown-emscripten
-//@ needs-llvm-components: webassembly
-
-// Emscripten has its own unique implementation of catch_unwind (in `codegen_emcc_try`),
-// make sure it generates something reasonable.
-
-#![feature(no_core, lang_items, intrinsics, rustc_attrs)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
-
-impl<T> Copy for *mut T {}
-
-#[rustc_intrinsic]
-fn size_of<T>() -> usize {
-    loop {}
-}
-
-#[rustc_intrinsic]
-unsafe fn catch_unwind(
-    try_fn: fn(_: *mut u8),
-    data: *mut u8,
-    catch_fn: fn(_: *mut u8, _: *mut u8),
-) -> i32;
-
-// CHECK-LABEL: @ptr_size
-#[no_mangle]
-pub fn ptr_size() -> usize {
-    // CHECK: ret [[PTR_SIZE:.*]]
-    size_of::<*mut u8>()
-}
-
-// CHECK-LABEL: @test_catch_unwind
-#[no_mangle]
-pub unsafe fn test_catch_unwind(
-    try_fn: fn(_: *mut u8),
-    data: *mut u8,
-    catch_fn: fn(_: *mut u8, _: *mut u8),
-) -> i32 {
-    // CHECK: start:
-    // CHECK: [[ALLOCA:%.*]] = alloca
-
-    // CHECK: catch.i:
-    // CHECK: [[LANDINGPAD:%.*]] = landingpad
-    // CHECK: [[EXCEPTION:%.*]] = extractvalue {{.*}} [[LANDINGPAD]], 0
-    // CHECK: [[SELECTOR:%.*]] = extractvalue {{.*}} [[LANDINGPAD]], 1
-
-    // CHECK: [[IS_RUST_EXN:%.*]] = icmp eq {{.*}}[[SELECTOR]]
-    // CHECK: [[IS_RUST_EXN_I8:%.*]] = zext i1 [[IS_RUST_EXN]] to i8
-
-    // CHECK: store ptr [[EXCEPTION]], ptr [[ALLOCA]]
-    // CHECK: [[IS_RUST_SLOT:%.*]] = getelementptr inbounds{{( nuw)?}} i8, ptr [[ALLOCA]], [[PTR_SIZE]]
-    // CHECK: store i8 [[IS_RUST_EXN_I8]], ptr [[IS_RUST_SLOT]]
-
-    // CHECK: call void %catch_fn(ptr %data, ptr nonnull [[ALLOCA]])
-
-    catch_unwind(try_fn, data, catch_fn)
-}
diff --git a/tests/codegen/emscripten-catch-unwind-wasm-eh.rs b/tests/codegen/emscripten-catch-unwind-wasm-eh.rs
deleted file mode 100644
index b0750d52268..00000000000
--- a/tests/codegen/emscripten-catch-unwind-wasm-eh.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-//@ compile-flags: -Copt-level=3 --target wasm32-unknown-emscripten -Z emscripten-wasm-eh
-//@ needs-llvm-components: webassembly
-
-// Emscripten catch_unwind using wasm exceptions
-
-#![feature(no_core, lang_items, intrinsics, rustc_attrs)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
-
-impl<T> Copy for *mut T {}
-
-#[rustc_intrinsic]
-fn size_of<T>() -> usize {
-    loop {}
-}
-#[rustc_intrinsic]
-unsafe fn catch_unwind(
-    try_fn: fn(_: *mut u8),
-    data: *mut u8,
-    catch_fn: fn(_: *mut u8, _: *mut u8),
-) -> i32;
-
-// CHECK-LABEL: @ptr_size
-#[no_mangle]
-pub fn ptr_size() -> usize {
-    // CHECK: ret [[PTR_SIZE:.*]]
-    size_of::<*mut u8>()
-}
-
-// CHECK-LABEL: @test_catch_unwind
-#[no_mangle]
-pub unsafe fn test_catch_unwind(
-    try_fn: fn(_: *mut u8),
-    data: *mut u8,
-    catch_fn: fn(_: *mut u8, _: *mut u8),
-) -> i32 {
-    // CHECK: start:
-    // CHECK: invoke void %try_fn(ptr %data)
-    // CHECK:         to label %__rust_try.exit unwind label %catchswitch.i
-    // CHECK:   catchswitch.i:                                    ; preds = %start
-    // CHECK:   %catchswitch1.i = catchswitch within none [label %catchpad.i] unwind to caller
-
-    // CHECK: catchpad.i:                                       ; preds = %catchswitch.i
-    // CHECK:   %catchpad2.i = catchpad within %catchswitch1.i [ptr null]
-    // CHECK:   %0 = tail call ptr @llvm.wasm.get.exception(token %catchpad2.i)
-    // CHECK:   %1 = tail call i32 @llvm.wasm.get.ehselector(token %catchpad2.i)
-    // CHECK:   call void %catch_fn(ptr %data, ptr %0) [ "funclet"(token %catchpad2.i) ]
-    // CHECK:   catchret from %catchpad2.i to label %__rust_try.exit
-
-    // CHECK: __rust_try.exit:                                  ; preds = %start, %catchpad.i
-    // CHECK:   %common.ret.op.i = phi i32 [ 0, %start ], [ 1, %catchpad.i ]
-    // CHECK:   ret i32 %common.ret.op.i
-
-    catch_unwind(try_fn, data, catch_fn)
-}
diff --git a/tests/codegen/enable-lto-unit-splitting.rs b/tests/codegen/enable-lto-unit-splitting.rs
deleted file mode 100644
index 51c2671bc4e..00000000000
--- a/tests/codegen/enable-lto-unit-splitting.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Verifies that "EnableSplitLTOUnit" module flag is added.
-//
-//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsplit-lto-unit
-
-#![crate_type = "lib"]
-
-pub fn foo() {}
-
-// CHECK: !{{[0-9]+}} = !{i32 4, !"EnableSplitLTOUnit", i32 1}
diff --git a/tests/codegen/enum/enum-aggregate.rs b/tests/codegen/enum/enum-aggregate.rs
deleted file mode 100644
index 0161e5f3fa1..00000000000
--- a/tests/codegen/enum/enum-aggregate.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-//@ compile-flags: -Copt-level=0 -Cno-prepopulate-passes
-//@ min-llvm-version: 19
-//@ only-64bit
-
-#![crate_type = "lib"]
-
-use std::cmp::Ordering;
-use std::num::NonZero;
-use std::ptr::NonNull;
-
-#[no_mangle]
-fn make_some_bool(x: bool) -> Option<bool> {
-    // CHECK-LABEL: i8 @make_some_bool(i1 zeroext %x)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %[[WIDER:.+]] = zext i1 %x to i8
-    // CHECK-NEXT: ret i8 %[[WIDER]]
-    Some(x)
-}
-
-#[no_mangle]
-fn make_none_bool() -> Option<bool> {
-    // CHECK-LABEL: i8 @make_none_bool()
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret i8 2
-    None
-}
-
-#[no_mangle]
-fn make_some_ordering(x: Ordering) -> Option<Ordering> {
-    // CHECK-LABEL: i8 @make_some_ordering(i8 %x)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret i8 %x
-    Some(x)
-}
-
-#[no_mangle]
-fn make_some_u16(x: u16) -> Option<u16> {
-    // CHECK-LABEL: { i16, i16 } @make_some_u16(i16 %x)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %0 = insertvalue { i16, i16 } { i16 1, i16 poison }, i16 %x, 1
-    // CHECK-NEXT: ret { i16, i16 } %0
-    Some(x)
-}
-
-#[no_mangle]
-fn make_none_u16() -> Option<u16> {
-    // CHECK-LABEL: { i16, i16 } @make_none_u16()
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret { i16, i16 } { i16 0, i16 undef }
-    None
-}
-
-#[no_mangle]
-fn make_some_nzu32(x: NonZero<u32>) -> Option<NonZero<u32>> {
-    // CHECK-LABEL: i32 @make_some_nzu32(i32 %x)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret i32 %x
-    Some(x)
-}
-
-#[no_mangle]
-fn make_ok_ptr(x: NonNull<u16>) -> Result<NonNull<u16>, usize> {
-    // CHECK-LABEL: { i64, ptr } @make_ok_ptr(ptr %x)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %0 = insertvalue { i64, ptr } { i64 0, ptr poison }, ptr %x, 1
-    // CHECK-NEXT: ret { i64, ptr } %0
-    Ok(x)
-}
-
-#[no_mangle]
-fn make_ok_int(x: usize) -> Result<usize, NonNull<u16>> {
-    // CHECK-LABEL: { i64, ptr } @make_ok_int(i64 %x)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %[[NOPROV:.+]] = getelementptr i8, ptr null, i64 %x
-    // CHECK-NEXT: %[[R:.+]] = insertvalue { i64, ptr } { i64 0, ptr poison }, ptr %[[NOPROV]], 1
-    // CHECK-NEXT: ret { i64, ptr } %[[R]]
-    Ok(x)
-}
-
-#[no_mangle]
-fn make_some_ref(x: &u16) -> Option<&u16> {
-    // CHECK-LABEL: ptr @make_some_ref(ptr align 2 %x)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret ptr %x
-    Some(x)
-}
-
-#[no_mangle]
-fn make_none_ref<'a>() -> Option<&'a u16> {
-    // CHECK-LABEL: ptr @make_none_ref()
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret ptr null
-    None
-}
-
-#[inline(never)]
-fn make_err_generic<E>(e: E) -> Result<u32, E> {
-    // CHECK-LABEL: define{{.+}}make_err_generic
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: call void @llvm.trap()
-    // CHECK-NEXT: ret i32 poison
-    Err(e)
-}
-
-#[no_mangle]
-fn make_uninhabited_err_indirectly(n: Never) -> Result<u32, Never> {
-    // CHECK-LABEL: i32 @make_uninhabited_err_indirectly()
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: call{{.+}}make_err_generic
-    make_err_generic(n)
-}
-
-#[no_mangle]
-fn make_fully_uninhabited_result(v: u32, n: Never) -> Result<(u32, Never), (Never, u32)> {
-    // Actually reaching this would be UB, so we don't actually build a result.
-
-    // CHECK-LABEL: { i32, i32 } @make_fully_uninhabited_result(i32 %v)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: call void @llvm.trap()
-    // CHECK-NEXT: call void @llvm.trap()
-    // CHECK-NEXT: call void @llvm.trap()
-    // CHECK-NEXT: unreachable
-    Ok((v, n))
-}
-
-enum Never {}
diff --git a/tests/codegen/enum/enum-bounds-check-derived-idx.rs b/tests/codegen/enum/enum-bounds-check-derived-idx.rs
deleted file mode 100644
index a5785f4addf..00000000000
--- a/tests/codegen/enum/enum-bounds-check-derived-idx.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// This test checks an optimization that is not guaranteed to work. This test case should not block
-// a future LLVM update.
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-pub enum Bar {
-    A = 1,
-    B = 3,
-}
-
-// CHECK-LABEL: @lookup_inc
-#[no_mangle]
-pub fn lookup_inc(buf: &[u8; 5], f: Bar) -> u8 {
-    // CHECK-NOT: panic_bounds_check
-    buf[f as usize + 1]
-}
-
-// CHECK-LABEL: @lookup_dec
-#[no_mangle]
-pub fn lookup_dec(buf: &[u8; 5], f: Bar) -> u8 {
-    // CHECK-NOT: panic_bounds_check
-    buf[f as usize - 1]
-}
diff --git a/tests/codegen/enum/enum-bounds-check-issue-13926.rs b/tests/codegen/enum/enum-bounds-check-issue-13926.rs
deleted file mode 100644
index 6e8e5035b0d..00000000000
--- a/tests/codegen/enum/enum-bounds-check-issue-13926.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// This test checks an optimization that is not guaranteed to work. This test case should not block
-// a future LLVM update.
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[repr(u8)]
-pub enum Exception {
-    Low = 5,
-    High = 10,
-}
-
-// CHECK-LABEL: @access
-#[no_mangle]
-pub fn access(array: &[usize; 12], exc: Exception) -> usize {
-    // CHECK-NOT: panic_bounds_check
-    array[(exc as u8 - 4) as usize]
-}
diff --git a/tests/codegen/enum/enum-bounds-check-issue-82871.rs b/tests/codegen/enum/enum-bounds-check-issue-82871.rs
deleted file mode 100644
index 3b8a146838a..00000000000
--- a/tests/codegen/enum/enum-bounds-check-issue-82871.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ compile-flags: -C opt-level=0
-
-#![crate_type = "lib"]
-
-#[repr(C)]
-pub enum E {
-    A,
-}
-
-// CHECK-LABEL: @index
-#[no_mangle]
-pub fn index(x: &[u32; 3], ind: E) -> u32 {
-    // Canary: we should be able to optimize out the bounds check, but we need
-    // to track the range of the discriminant result in order to be able to do that.
-    // oli-obk tried to add that, but that caused miscompilations all over the place.
-    // CHECK: panic_bounds_check
-    x[ind as usize]
-}
diff --git a/tests/codegen/enum/enum-bounds-check.rs b/tests/codegen/enum/enum-bounds-check.rs
deleted file mode 100644
index 5362598ca7c..00000000000
--- a/tests/codegen/enum/enum-bounds-check.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-pub enum Foo {
-    A,
-    B,
-}
-
-// CHECK-LABEL: @lookup
-#[no_mangle]
-pub fn lookup(buf: &[u8; 2], f: Foo) -> u8 {
-    // CHECK-NOT: panic_bounds_check
-    buf[f as usize]
-}
-
-pub enum Bar {
-    A = 2,
-    B = 3,
-}
-
-// CHECK-LABEL: @lookup_unmodified
-#[no_mangle]
-pub fn lookup_unmodified(buf: &[u8; 5], f: Bar) -> u8 {
-    // CHECK-NOT: panic_bounds_check
-    buf[f as usize]
-}
diff --git a/tests/codegen/enum/enum-debug-clike.rs b/tests/codegen/enum/enum-debug-clike.rs
deleted file mode 100644
index 89c803cce5e..00000000000
--- a/tests/codegen/enum/enum-debug-clike.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// This tests that debug info for "c-like" enums is properly emitted.
-// This is ignored for the fallback mode on MSVC due to problems with PDB.
-
-//
-//@ ignore-msvc
-//@ ignore-wasi wasi codegens the main symbol differently
-
-//@ compile-flags: -g -C no-prepopulate-passes
-
-// CHECK-LABEL: @main
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_enumeration_type,{{.*}}name: "E",{{.*}}flags: DIFlagEnumClass,{{.*}}
-// CHECK: {{.*}}DIEnumerator{{.*}}name: "A",{{.*}}value: {{[0-9].*}}
-// CHECK: {{.*}}DIEnumerator{{.*}}name: "B",{{.*}}value: {{[0-9].*}}
-// CHECK: {{.*}}DIEnumerator{{.*}}name: "C",{{.*}}value: {{[0-9].*}}
-
-#![allow(dead_code)]
-#![allow(unused_variables)]
-#![allow(unused_assignments)]
-
-enum E {
-    A,
-    B,
-    C,
-}
-
-pub fn main() {
-    let e = E::C;
-}
diff --git a/tests/codegen/enum/enum-debug-niche-2.rs b/tests/codegen/enum/enum-debug-niche-2.rs
deleted file mode 100644
index 80a4081f15b..00000000000
--- a/tests/codegen/enum/enum-debug-niche-2.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-//! This tests that optimized enum debug info accurately reflects the enum layout.
-//! This is ignored for the fallback mode on MSVC due to problems with PDB.
-//!
-//@ compile-flags: -g -C no-prepopulate-passes
-//@ ignore-msvc
-//
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_variant_part,{{.*}}size: 32,{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "Placeholder",{{.*}}extraData: i32 -1{{[,)].*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "Error",{{.*}}extraData: i32 0{{[,)].*}}
-#![feature(never_type)]
-
-#[derive(Copy, Clone)]
-pub struct Entity {
-    private: std::num::NonZero<u32>,
-}
-
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub struct Declaration;
-
-impl TypeFamily for Declaration {
-    type Base = Base;
-    type Placeholder = !;
-
-    fn intern_base_data(_: BaseKind<Self>) {}
-}
-
-#[derive(Copy, Clone)]
-pub struct Base;
-
-pub trait TypeFamily: Copy + 'static {
-    type Base: Copy;
-    type Placeholder: Copy;
-
-    fn intern_base_data(_: BaseKind<Self>);
-}
-
-#[derive(Copy, Clone)]
-pub enum BaseKind<F: TypeFamily> {
-    Named(Entity),
-    Placeholder(F::Placeholder),
-    Error,
-}
-
-pub fn main() {
-    let x = BaseKind::Error::<Declaration>;
-    let y = 7;
-}
diff --git a/tests/codegen/enum/enum-debug-niche.rs b/tests/codegen/enum/enum-debug-niche.rs
deleted file mode 100644
index 59e8b8a78b4..00000000000
--- a/tests/codegen/enum/enum-debug-niche.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-// This tests that optimized enum debug info accurately reflects the enum layout.
-// This is ignored for the fallback mode on MSVC due to problems with PDB.
-
-//@ ignore-msvc
-//@ ignore-wasi wasi codegens the main symbol differently
-
-//@ compile-flags: -g -C no-prepopulate-passes
-
-// CHECK-LABEL: @main
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_variant_part,{{.*}}discriminator:{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "A",{{.*}}extraData:{{.*}}
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "A",{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "B",{{.*}}extraData:{{.*}}
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "B",{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "C",{{.*}}extraData:{{.*}}
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "C",{{.*}}
-// CHECK-NOT: {{.*}}DIDerivedType{{.*}}name: "D",{{.*}}extraData:{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "D",{{.*}}
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "D",{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}flags: DIFlagArtificial{{.*}}
-
-#![allow(dead_code)]
-#![allow(unused_variables)]
-#![allow(unused_assignments)]
-
-enum E {
-    A,
-    B,
-    C,
-    D(bool),
-}
-
-pub fn main() {
-    let e = E::D(true);
-}
diff --git a/tests/codegen/enum/enum-debug-tagged.rs b/tests/codegen/enum/enum-debug-tagged.rs
deleted file mode 100644
index e8f147665b0..00000000000
--- a/tests/codegen/enum/enum-debug-tagged.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// This tests that debug info for tagged (ordinary) enums is properly emitted.
-// This is ignored for the fallback mode on MSVC due to problems with PDB.
-
-//@ ignore-msvc
-//@ ignore-wasi wasi codegens the main symbol differently
-
-//@ compile-flags: -g -C no-prepopulate-passes
-
-// CHECK-LABEL: @main
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "E",{{.*}}
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_variant_part,{{.*}}discriminator:{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "A",{{.*}}extraData:{{.*}}
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "A",{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "__0",{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "B",{{.*}}extraData:{{.*}}
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "B",{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "__0",{{.*}}
-// CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}flags: DIFlagArtificial{{.*}}
-
-#![allow(dead_code)]
-#![allow(unused_variables)]
-#![allow(unused_assignments)]
-
-enum E {
-    A(u32),
-    B(u32),
-}
-
-pub fn main() {
-    let e = E::A(23);
-}
diff --git a/tests/codegen/enum/enum-discriminant-eq.rs b/tests/codegen/enum/enum-discriminant-eq.rs
deleted file mode 100644
index 0494c5f551b..00000000000
--- a/tests/codegen/enum/enum-discriminant-eq.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-//@ min-llvm-version: 20
-//@ only-64bit
-
-// The `derive(PartialEq)` on enums with field-less variants compares discriminants,
-// so make sure we emit that in some reasonable way.
-
-#![crate_type = "lib"]
-#![feature(ascii_char)]
-#![feature(core_intrinsics)]
-#![feature(repr128)]
-
-use std::ascii::Char as AC;
-use std::cmp::Ordering;
-use std::intrinsics::discriminant_value;
-use std::num::NonZero;
-
-// A type that's bigger than `isize`, unlike the usual cases that have small tags.
-#[repr(u128)]
-pub enum Giant {
-    Two = 2,
-    Three = 3,
-    Four = 4,
-}
-
-#[unsafe(no_mangle)]
-pub fn opt_bool_eq_discr(a: Option<bool>, b: Option<bool>) -> bool {
-    // CHECK-LABEL: @opt_bool_eq_discr(
-    // CHECK: %[[A:.+]] = icmp ne i8 %a, 2
-    // CHECK: %[[B:.+]] = icmp eq i8 %b, 2
-    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
-    // CHECK: ret i1 %[[R]]
-
-    discriminant_value(&a) == discriminant_value(&b)
-}
-
-#[unsafe(no_mangle)]
-pub fn opt_ord_eq_discr(a: Option<Ordering>, b: Option<Ordering>) -> bool {
-    // CHECK-LABEL: @opt_ord_eq_discr(
-    // CHECK: %[[A:.+]] = icmp ne i8 %a, 2
-    // CHECK: %[[B:.+]] = icmp eq i8 %b, 2
-    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
-    // CHECK: ret i1 %[[R]]
-
-    discriminant_value(&a) == discriminant_value(&b)
-}
-
-#[unsafe(no_mangle)]
-pub fn opt_nz32_eq_discr(a: Option<NonZero<u32>>, b: Option<NonZero<u32>>) -> bool {
-    // CHECK-LABEL: @opt_nz32_eq_discr(
-    // CHECK: %[[A:.+]] = icmp ne i32 %a, 0
-    // CHECK: %[[B:.+]] = icmp eq i32 %b, 0
-    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
-    // CHECK: ret i1 %[[R]]
-
-    discriminant_value(&a) == discriminant_value(&b)
-}
-
-#[unsafe(no_mangle)]
-pub fn opt_ac_eq_discr(a: Option<AC>, b: Option<AC>) -> bool {
-    // CHECK-LABEL: @opt_ac_eq_discr(
-    // CHECK: %[[A:.+]] = icmp ne i8 %a, -128
-    // CHECK: %[[B:.+]] = icmp eq i8 %b, -128
-    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
-    // CHECK: ret i1 %[[R]]
-
-    discriminant_value(&a) == discriminant_value(&b)
-}
-
-#[unsafe(no_mangle)]
-pub fn opt_giant_eq_discr(a: Option<Giant>, b: Option<Giant>) -> bool {
-    // CHECK-LABEL: @opt_giant_eq_discr(
-    // CHECK: %[[A:.+]] = icmp ne i128 %a, 1
-    // CHECK: %[[B:.+]] = icmp eq i128 %b, 1
-    // CHECK: %[[R:.+]] = xor i1 %[[A]], %[[B]]
-    // CHECK: ret i1 %[[R]]
-
-    discriminant_value(&a) == discriminant_value(&b)
-}
-
-pub enum Mid<T> {
-    Before,
-    Thing(T),
-    After,
-}
-
-#[unsafe(no_mangle)]
-pub fn mid_bool_eq_discr(a: Mid<bool>, b: Mid<bool>) -> bool {
-    // CHECK-LABEL: @mid_bool_eq_discr(
-
-    // CHECK: %[[A_REL_DISCR:.+]] = add nsw i8 %a, -2
-    // CHECK: %[[A_IS_NICHE:.+]] = icmp samesign ugt i8 %a, 1
-    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %[[A_REL_DISCR]], 1
-    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
-    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
-
-    // CHECK: %[[B_REL_DISCR:.+]] = add nsw i8 %b, -2
-    // CHECK: %[[B_IS_NICHE:.+]] = icmp samesign ugt i8 %b, 1
-    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %[[B_REL_DISCR]], 1
-    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
-    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
-
-    // CHECK: ret i1 %[[R]]
-    discriminant_value(&a) == discriminant_value(&b)
-}
-
-#[unsafe(no_mangle)]
-pub fn mid_ord_eq_discr(a: Mid<Ordering>, b: Mid<Ordering>) -> bool {
-    // CHECK-LABEL: @mid_ord_eq_discr(
-
-    // CHECK: %[[A_REL_DISCR:.+]] = add nsw i8 %a, -2
-    // CHECK: %[[A_IS_NICHE:.+]] = icmp sgt i8 %a, 1
-    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %[[A_REL_DISCR]], 1
-    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
-    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
-
-    // CHECK: %[[B_REL_DISCR:.+]] = add nsw i8 %b, -2
-    // CHECK: %[[B_IS_NICHE:.+]] = icmp sgt i8 %b, 1
-    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %[[B_REL_DISCR]], 1
-    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
-    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
-
-    // CHECK: %[[R:.+]] = icmp eq i8 %[[A_DISCR]], %[[B_DISCR]]
-    // CHECK: ret i1 %[[R]]
-    discriminant_value(&a) == discriminant_value(&b)
-}
-
-#[unsafe(no_mangle)]
-pub fn mid_nz32_eq_discr(a: Mid<NonZero<u32>>, b: Mid<NonZero<u32>>) -> bool {
-    // CHECK-LABEL: @mid_nz32_eq_discr(
-    // CHECK: %[[R:.+]] = icmp eq i32 %a.0, %b.0
-    // CHECK: ret i1 %[[R]]
-    discriminant_value(&a) == discriminant_value(&b)
-}
-
-#[unsafe(no_mangle)]
-pub fn mid_ac_eq_discr(a: Mid<AC>, b: Mid<AC>) -> bool {
-    // CHECK-LABEL: @mid_ac_eq_discr(
-
-    // CHECK: %[[A_REL_DISCR:.+]] = xor i8 %a, -128
-    // CHECK: %[[A_IS_NICHE:.+]] = icmp slt i8 %a, 0
-    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i8 %a, -127
-    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
-    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i8 %[[A_REL_DISCR]], i8 1
-
-    // CHECK: %[[B_REL_DISCR:.+]] = xor i8 %b, -128
-    // CHECK: %[[B_IS_NICHE:.+]] = icmp slt i8 %b, 0
-    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i8 %b, -127
-    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
-    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i8 %[[B_REL_DISCR]], i8 1
-
-    // CHECK: %[[R:.+]] = icmp eq i8 %[[A_DISCR]], %[[B_DISCR]]
-    // CHECK: ret i1 %[[R]]
-    discriminant_value(&a) == discriminant_value(&b)
-}
-
-// FIXME: This should be improved once our LLVM fork picks up the fix for
-// <https://github.com/llvm/llvm-project/issues/134024>
-#[unsafe(no_mangle)]
-pub fn mid_giant_eq_discr(a: Mid<Giant>, b: Mid<Giant>) -> bool {
-    // CHECK-LABEL: @mid_giant_eq_discr(
-
-    // CHECK: %[[A_TRUNC:.+]] = trunc nuw nsw i128 %a to i64
-    // CHECK: %[[A_REL_DISCR:.+]] = add nsw i64 %[[A_TRUNC]], -5
-    // CHECK: %[[A_IS_NICHE:.+]] = icmp samesign ugt i128 %a, 4
-    // CHECK: %[[A_NOT_HOLE:.+]] = icmp ne i64 %[[A_REL_DISCR]], 1
-    // CHECK: tail call void @llvm.assume(i1 %[[A_NOT_HOLE]])
-    // CHECK: %[[A_DISCR:.+]] = select i1 %[[A_IS_NICHE]], i64 %[[A_REL_DISCR]], i64 1
-
-    // CHECK: %[[B_TRUNC:.+]] = trunc nuw nsw i128 %b to i64
-    // CHECK: %[[B_REL_DISCR:.+]] = add nsw i64 %[[B_TRUNC]], -5
-    // CHECK: %[[B_IS_NICHE:.+]] = icmp samesign ugt i128 %b, 4
-    // CHECK: %[[B_NOT_HOLE:.+]] = icmp ne i64 %[[B_REL_DISCR]], 1
-    // CHECK: tail call void @llvm.assume(i1 %[[B_NOT_HOLE]])
-    // CHECK: %[[B_DISCR:.+]] = select i1 %[[B_IS_NICHE]], i64 %[[B_REL_DISCR]], i64 1
-
-    // CHECK: %[[R:.+]] = icmp eq i64 %[[A_DISCR]], %[[B_DISCR]]
-    // CHECK: ret i1 %[[R]]
-    discriminant_value(&a) == discriminant_value(&b)
-}
-
-// In niche-encoded enums, testing for the untagged variant should optimize to a
-// straight-forward comparison looking for the natural range of the payload value.
-
-#[unsafe(no_mangle)]
-pub fn mid_bool_is_thing(a: Mid<bool>) -> bool {
-    // CHECK-LABEL: @mid_bool_is_thing(
-    // CHECK: %[[R:.+]] = icmp samesign ult i8 %a, 2
-    // CHECK: ret i1 %[[R]]
-    discriminant_value(&a) == 1
-}
-
-#[unsafe(no_mangle)]
-pub fn mid_ord_is_thing(a: Mid<Ordering>) -> bool {
-    // CHECK-LABEL: @mid_ord_is_thing(
-    // CHECK: %[[R:.+]] = icmp slt i8 %a, 2
-    // CHECK: ret i1 %[[R]]
-    discriminant_value(&a) == 1
-}
-
-#[unsafe(no_mangle)]
-pub fn mid_nz32_is_thing(a: Mid<NonZero<u32>>) -> bool {
-    // CHECK-LABEL: @mid_nz32_is_thing(
-    // CHECK: %[[R:.+]] = icmp eq i32 %a.0, 1
-    // CHECK: ret i1 %[[R]]
-    discriminant_value(&a) == 1
-}
-
-#[unsafe(no_mangle)]
-pub fn mid_ac_is_thing(a: Mid<AC>) -> bool {
-    // CHECK-LABEL: @mid_ac_is_thing(
-    // CHECK: %[[R:.+]] = icmp sgt i8 %a, -1
-    // CHECK: ret i1 %[[R]]
-    discriminant_value(&a) == 1
-}
-
-#[unsafe(no_mangle)]
-pub fn mid_giant_is_thing(a: Mid<Giant>) -> bool {
-    // CHECK-LABEL: @mid_giant_is_thing(
-    // CHECK: %[[R:.+]] = icmp samesign ult i128 %a, 5
-    // CHECK: ret i1 %[[R]]
-    discriminant_value(&a) == 1
-}
diff --git a/tests/codegen/enum/enum-discriminant-value.rs b/tests/codegen/enum/enum-discriminant-value.rs
deleted file mode 100644
index d6b0c6d6c10..00000000000
--- a/tests/codegen/enum/enum-discriminant-value.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Verify that DIEnumerator uses isUnsigned flag when appropriate.
-//
-//@ compile-flags: -g -C no-prepopulate-passes
-
-#[repr(i64)]
-pub enum I64 {
-    I64Min = i64::MIN,
-    I64Max = i64::MAX,
-}
-
-#[repr(u64)]
-pub enum U64 {
-    U64Min = u64::MIN,
-    U64Max = u64::MAX,
-}
-
-fn main() {
-    let _a = I64::I64Min;
-    let _b = I64::I64Max;
-    let _c = U64::U64Min;
-    let _d = U64::U64Max;
-}
-
-// CHECK: !DIEnumerator(name: "I64Min", value: -9223372036854775808)
-// CHECK: !DIEnumerator(name: "I64Max", value: 9223372036854775807)
-// CHECK: !DIEnumerator(name: "U64Min", value: 0, isUnsigned: true)
-// CHECK: !DIEnumerator(name: "U64Max", value: 18446744073709551615, isUnsigned: true)
diff --git a/tests/codegen/enum/enum-early-otherwise-branch.rs b/tests/codegen/enum/enum-early-otherwise-branch.rs
deleted file mode 100644
index 8d39d8e9b74..00000000000
--- a/tests/codegen/enum/enum-early-otherwise-branch.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-pub enum Enum {
-    A(u32),
-    B(u32),
-    C(u32),
-}
-
-#[no_mangle]
-pub fn foo(lhs: &Enum, rhs: &Enum) -> bool {
-    // CHECK-LABEL: define{{.*}}i1 @foo(
-    // CHECK-NOT: switch
-    // CHECK-NOT: br
-    // CHECK: [[SELECT:%.*]] = select
-    // CHECK-NEXT: ret i1 [[SELECT]]
-    // CHECK-NEXT: }
-    match (lhs, rhs) {
-        (Enum::A(lhs), Enum::A(rhs)) => lhs == rhs,
-        (Enum::B(lhs), Enum::B(rhs)) => lhs == rhs,
-        (Enum::C(lhs), Enum::C(rhs)) => lhs == rhs,
-        _ => false,
-    }
-}
diff --git a/tests/codegen/enum/enum-match.rs b/tests/codegen/enum/enum-match.rs
deleted file mode 100644
index 57db44ec74e..00000000000
--- a/tests/codegen/enum/enum-match.rs
+++ /dev/null
@@ -1,779 +0,0 @@
-//@ compile-flags: -Copt-level=1
-//@ only-64bit
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-// Check each of the 3 cases for `codegen_get_discr`.
-
-// FIXME: once our min-bar LLVM has `range` attributes, update the various
-// tests here to no longer have the `range`s and `nsw`s as optional.
-
-// Case 0: One tagged variant.
-pub enum Enum0 {
-    A(bool),
-    B,
-}
-
-// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match0(i8{{.+}}%0)
-// CHECK-NEXT: start:
-// CHECK-NEXT: %[[IS_B:.+]] = icmp eq i8 %0, 2
-// CHECK-NEXT: %[[TRUNC:.+]] = and i8 %0, 1
-// CHECK-NEXT: %[[R:.+]] = select i1 %[[IS_B]], i8 13, i8 %[[TRUNC]]
-// CHECK-NEXT: ret i8 %[[R]]
-#[no_mangle]
-pub fn match0(e: Enum0) -> u8 {
-    use Enum0::*;
-    match e {
-        A(b) => b as u8,
-        B => 13,
-    }
-}
-
-// Case 1: Niche values are on a boundary for `range`.
-pub enum Enum1 {
-    A(bool),
-    B,
-    C,
-}
-
-// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match1(i8{{.+}}%0)
-// CHECK-NEXT: start:
-// CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
-// CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
-// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp{{( samesign)?}} ugt i8 %0, 1
-// CHECK-NEXT: %[[NICHE_DISCR:.+]] = add nuw nsw i64 %[[REL_VAR_WIDE]], 1
-// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i64 %[[NICHE_DISCR]], i64 0
-// CHECK-NEXT: switch i64 %[[DISCR]]
-#[no_mangle]
-pub fn match1(e: Enum1) -> u8 {
-    use Enum1::*;
-    match e {
-        A(b) => b as u8,
-        B => 13,
-        C => 100,
-    }
-}
-
-// Case 2: Special cases don't apply.
-#[rustfmt::skip]
-pub enum X {
-    _2=2, _3, _4, _5, _6, _7, _8, _9, _10, _11,
-    _12, _13, _14, _15, _16, _17, _18, _19, _20,
-    _21, _22, _23, _24, _25, _26, _27, _28, _29,
-    _30, _31, _32, _33, _34, _35, _36, _37, _38,
-    _39, _40, _41, _42, _43, _44, _45, _46, _47,
-    _48, _49, _50, _51, _52, _53, _54, _55, _56,
-    _57, _58, _59, _60, _61, _62, _63, _64, _65,
-    _66, _67, _68, _69, _70, _71, _72, _73, _74,
-    _75, _76, _77, _78, _79, _80, _81, _82, _83,
-    _84, _85, _86, _87, _88, _89, _90, _91, _92,
-    _93, _94, _95, _96, _97, _98, _99, _100, _101,
-    _102, _103, _104, _105, _106, _107, _108, _109,
-    _110, _111, _112, _113, _114, _115, _116, _117,
-    _118, _119, _120, _121, _122, _123, _124, _125,
-    _126, _127, _128, _129, _130, _131, _132, _133,
-    _134, _135, _136, _137, _138, _139, _140, _141,
-    _142, _143, _144, _145, _146, _147, _148, _149,
-    _150, _151, _152, _153, _154, _155, _156, _157,
-    _158, _159, _160, _161, _162, _163, _164, _165,
-    _166, _167, _168, _169, _170, _171, _172, _173,
-    _174, _175, _176, _177, _178, _179, _180, _181,
-    _182, _183, _184, _185, _186, _187, _188, _189,
-    _190, _191, _192, _193, _194, _195, _196, _197,
-    _198, _199, _200, _201, _202, _203, _204, _205,
-    _206, _207, _208, _209, _210, _211, _212, _213,
-    _214, _215, _216, _217, _218, _219, _220, _221,
-    _222, _223, _224, _225, _226, _227, _228, _229,
-    _230, _231, _232, _233, _234, _235, _236, _237,
-    _238, _239, _240, _241, _242, _243, _244, _245,
-    _246, _247, _248, _249, _250, _251, _252, _253,
-}
-
-pub enum Enum2 {
-    A(X),
-    B,
-    C,
-    D,
-    E,
-}
-
-// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, -?[0-9]+\))?}} i8 @match2(i8{{.+}}%0)
-// CHECK-NEXT: start:
-// CHECK-NEXT: %[[REL_VAR:.+]] = add i8 %0, 2
-// CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
-// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp ult i8 %[[REL_VAR]], 4
-// CHECK-NEXT: %[[NICHE_DISCR:.+]] = add nuw nsw i64 %[[REL_VAR_WIDE]], 1
-// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i64 %[[NICHE_DISCR]], i64 0
-// CHECK-NEXT: switch i64 %[[DISCR]]
-#[no_mangle]
-pub fn match2(e: Enum2) -> u8 {
-    use Enum2::*;
-    match e {
-        A(b) => b as u8,
-        B => 13,
-        C => 100,
-        D => 200,
-        E => 250,
-    }
-}
-
-// And make sure it works even if the niched scalar is a pointer.
-// (For example, that we don't try to `sub` on pointers.)
-
-// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i16 -?[0-9]+, -?[0-9]+\))?}} i16 @match3(ptr{{.+}}%0)
-// CHECK-NEXT: start:
-// CHECK-NEXT: %[[IS_NULL:.+]] = icmp eq ptr %0, null
-// CHECK-NEXT: br i1 %[[IS_NULL]]
-#[no_mangle]
-pub fn match3(e: Option<&u8>) -> i16 {
-    match e {
-        Some(r) => *r as _,
-        None => -1,
-    }
-}
-
-// If the untagged variant is in the middle, there's an impossible value that's
-// not reflected in the `range` parameter attribute, so we assume it away.
-
-#[derive(PartialEq)]
-pub enum MiddleNiche {
-    A,
-    B,
-    C(bool),
-    D,
-    E,
-}
-
-// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 -?[0-9]+, -?[0-9]+\))?}} i8 @match4(i8{{.+}}%0)
-// CHECK-NEXT: start:
-// CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
-// CHECK-NEXT: %[[NOT_IMPOSSIBLE:.+]] = icmp ne i8 %[[REL_VAR]], 2
-// CHECK-NEXT: call void @llvm.assume(i1 %[[NOT_IMPOSSIBLE]])
-// CHECK-NEXT: %[[NOT_NICHE:.+]] = icmp{{( samesign)?}} ult i8 %0, 2
-// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[NOT_NICHE]], i8 2, i8 %[[REL_VAR]]
-// CHECK-NEXT: switch i8 %[[DISCR]]
-#[no_mangle]
-pub fn match4(e: MiddleNiche) -> u8 {
-    use MiddleNiche::*;
-    match e {
-        A => 13,
-        B => 100,
-        C(b) => b as u8,
-        D => 200,
-        E => 250,
-    }
-}
-
-// CHECK-LABEL: define{{.+}}i1 @match4_is_c(i8{{.+}}%e)
-// CHECK-NEXT: start
-// CHECK-NEXT: %[[NOT_IMPOSSIBLE:.+]] = icmp ne i8 %e, 4
-// CHECK-NEXT: call void @llvm.assume(i1 %[[NOT_IMPOSSIBLE]])
-// CHECK-NEXT: %[[IS_C:.+]] = icmp{{( samesign)?}} ult i8 %e, 2
-// CHECK-NEXT: ret i1 %[[IS_C]]
-#[no_mangle]
-pub fn match4_is_c(e: MiddleNiche) -> bool {
-    // Before #139098, this couldn't optimize out the `select` because it looked
-    // like it was possible for a `2` to be produced on both sides.
-
-    std::intrinsics::discriminant_value(&e) == 2
-}
-
-// You have to do something pretty obnoxious to get a variant index that doesn't
-// fit in the tag size, but it's possible
-
-pub enum Never {}
-
-pub enum HugeVariantIndex {
-    V000(Never),
-    V001(Never),
-    V002(Never),
-    V003(Never),
-    V004(Never),
-    V005(Never),
-    V006(Never),
-    V007(Never),
-    V008(Never),
-    V009(Never),
-    V010(Never),
-    V011(Never),
-    V012(Never),
-    V013(Never),
-    V014(Never),
-    V015(Never),
-    V016(Never),
-    V017(Never),
-    V018(Never),
-    V019(Never),
-    V020(Never),
-    V021(Never),
-    V022(Never),
-    V023(Never),
-    V024(Never),
-    V025(Never),
-    V026(Never),
-    V027(Never),
-    V028(Never),
-    V029(Never),
-    V030(Never),
-    V031(Never),
-    V032(Never),
-    V033(Never),
-    V034(Never),
-    V035(Never),
-    V036(Never),
-    V037(Never),
-    V038(Never),
-    V039(Never),
-    V040(Never),
-    V041(Never),
-    V042(Never),
-    V043(Never),
-    V044(Never),
-    V045(Never),
-    V046(Never),
-    V047(Never),
-    V048(Never),
-    V049(Never),
-    V050(Never),
-    V051(Never),
-    V052(Never),
-    V053(Never),
-    V054(Never),
-    V055(Never),
-    V056(Never),
-    V057(Never),
-    V058(Never),
-    V059(Never),
-    V060(Never),
-    V061(Never),
-    V062(Never),
-    V063(Never),
-    V064(Never),
-    V065(Never),
-    V066(Never),
-    V067(Never),
-    V068(Never),
-    V069(Never),
-    V070(Never),
-    V071(Never),
-    V072(Never),
-    V073(Never),
-    V074(Never),
-    V075(Never),
-    V076(Never),
-    V077(Never),
-    V078(Never),
-    V079(Never),
-    V080(Never),
-    V081(Never),
-    V082(Never),
-    V083(Never),
-    V084(Never),
-    V085(Never),
-    V086(Never),
-    V087(Never),
-    V088(Never),
-    V089(Never),
-    V090(Never),
-    V091(Never),
-    V092(Never),
-    V093(Never),
-    V094(Never),
-    V095(Never),
-    V096(Never),
-    V097(Never),
-    V098(Never),
-    V099(Never),
-    V100(Never),
-    V101(Never),
-    V102(Never),
-    V103(Never),
-    V104(Never),
-    V105(Never),
-    V106(Never),
-    V107(Never),
-    V108(Never),
-    V109(Never),
-    V110(Never),
-    V111(Never),
-    V112(Never),
-    V113(Never),
-    V114(Never),
-    V115(Never),
-    V116(Never),
-    V117(Never),
-    V118(Never),
-    V119(Never),
-    V120(Never),
-    V121(Never),
-    V122(Never),
-    V123(Never),
-    V124(Never),
-    V125(Never),
-    V126(Never),
-    V127(Never),
-    V128(Never),
-    V129(Never),
-    V130(Never),
-    V131(Never),
-    V132(Never),
-    V133(Never),
-    V134(Never),
-    V135(Never),
-    V136(Never),
-    V137(Never),
-    V138(Never),
-    V139(Never),
-    V140(Never),
-    V141(Never),
-    V142(Never),
-    V143(Never),
-    V144(Never),
-    V145(Never),
-    V146(Never),
-    V147(Never),
-    V148(Never),
-    V149(Never),
-    V150(Never),
-    V151(Never),
-    V152(Never),
-    V153(Never),
-    V154(Never),
-    V155(Never),
-    V156(Never),
-    V157(Never),
-    V158(Never),
-    V159(Never),
-    V160(Never),
-    V161(Never),
-    V162(Never),
-    V163(Never),
-    V164(Never),
-    V165(Never),
-    V166(Never),
-    V167(Never),
-    V168(Never),
-    V169(Never),
-    V170(Never),
-    V171(Never),
-    V172(Never),
-    V173(Never),
-    V174(Never),
-    V175(Never),
-    V176(Never),
-    V177(Never),
-    V178(Never),
-    V179(Never),
-    V180(Never),
-    V181(Never),
-    V182(Never),
-    V183(Never),
-    V184(Never),
-    V185(Never),
-    V186(Never),
-    V187(Never),
-    V188(Never),
-    V189(Never),
-    V190(Never),
-    V191(Never),
-    V192(Never),
-    V193(Never),
-    V194(Never),
-    V195(Never),
-    V196(Never),
-    V197(Never),
-    V198(Never),
-    V199(Never),
-    V200(Never),
-    V201(Never),
-    V202(Never),
-    V203(Never),
-    V204(Never),
-    V205(Never),
-    V206(Never),
-    V207(Never),
-    V208(Never),
-    V209(Never),
-    V210(Never),
-    V211(Never),
-    V212(Never),
-    V213(Never),
-    V214(Never),
-    V215(Never),
-    V216(Never),
-    V217(Never),
-    V218(Never),
-    V219(Never),
-    V220(Never),
-    V221(Never),
-    V222(Never),
-    V223(Never),
-    V224(Never),
-    V225(Never),
-    V226(Never),
-    V227(Never),
-    V228(Never),
-    V229(Never),
-    V230(Never),
-    V231(Never),
-    V232(Never),
-    V233(Never),
-    V234(Never),
-    V235(Never),
-    V236(Never),
-    V237(Never),
-    V238(Never),
-    V239(Never),
-    V240(Never),
-    V241(Never),
-    V242(Never),
-    V243(Never),
-    V244(Never),
-    V245(Never),
-    V246(Never),
-    V247(Never),
-    V248(Never),
-    V249(Never),
-    V250(Never),
-    V251(Never),
-    V252(Never),
-    V253(Never),
-    V254(Never),
-    V255(Never),
-    V256(Never),
-
-    Possible257,
-    Bool258(bool),
-    Possible259,
-}
-
-// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match5(i8{{.+}}%0)
-// CHECK-NEXT: start:
-// CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
-// CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
-// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp{{( samesign)?}} ugt i8 %0, 1
-// CHECK-NEXT: %[[NICHE_DISCR:.+]] = add nuw nsw i64 %[[REL_VAR_WIDE]], 257
-// CHECK-NEXT: %[[NOT_IMPOSSIBLE:.+]] = icmp ne i64 %[[NICHE_DISCR]], 258
-// CHECK-NEXT: call void @llvm.assume(i1 %[[NOT_IMPOSSIBLE]])
-// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i64 %[[NICHE_DISCR]], i64 258
-// CHECK-NEXT: switch i64 %[[DISCR]],
-// CHECK-NEXT:   i64 257,
-// CHECK-NEXT:   i64 258,
-// CHECK-NEXT:   i64 259,
-#[no_mangle]
-pub fn match5(e: HugeVariantIndex) -> u8 {
-    use HugeVariantIndex::*;
-    match e {
-        Possible257 => 13,
-        Bool258(b) => b as u8,
-        Possible259 => 100,
-    }
-}
-
-// Make an enum where the niche tags wrap both as signed and as unsigned, to hit
-// the most-fallback case where there's just nothing smart to do.
-
-pub enum E10Through65 {
-    D10 = 10,
-    D11 = 11,
-    D12 = 12,
-    D13 = 13,
-    D14 = 14,
-    D15 = 15,
-    D16 = 16,
-    D17 = 17,
-    D18 = 18,
-    D19 = 19,
-    D20 = 20,
-    D21 = 21,
-    D22 = 22,
-    D23 = 23,
-    D24 = 24,
-    D25 = 25,
-    D26 = 26,
-    D27 = 27,
-    D28 = 28,
-    D29 = 29,
-    D30 = 30,
-    D31 = 31,
-    D32 = 32,
-    D33 = 33,
-    D34 = 34,
-    D35 = 35,
-    D36 = 36,
-    D37 = 37,
-    D38 = 38,
-    D39 = 39,
-    D40 = 40,
-    D41 = 41,
-    D42 = 42,
-    D43 = 43,
-    D44 = 44,
-    D45 = 45,
-    D46 = 46,
-    D47 = 47,
-    D48 = 48,
-    D49 = 49,
-    D50 = 50,
-    D51 = 51,
-    D52 = 52,
-    D53 = 53,
-    D54 = 54,
-    D55 = 55,
-    D56 = 56,
-    D57 = 57,
-    D58 = 58,
-    D59 = 59,
-    D60 = 60,
-    D61 = 61,
-    D62 = 62,
-    D63 = 63,
-    D64 = 64,
-    D65 = 65,
-}
-
-pub enum Tricky {
-    Untagged(E10Through65),
-    V001,
-    V002,
-    V003,
-    V004,
-    V005,
-    V006,
-    V007,
-    V008,
-    V009,
-    V010,
-    V011,
-    V012,
-    V013,
-    V014,
-    V015,
-    V016,
-    V017,
-    V018,
-    V019,
-    V020,
-    V021,
-    V022,
-    V023,
-    V024,
-    V025,
-    V026,
-    V027,
-    V028,
-    V029,
-    V030,
-    V031,
-    V032,
-    V033,
-    V034,
-    V035,
-    V036,
-    V037,
-    V038,
-    V039,
-    V040,
-    V041,
-    V042,
-    V043,
-    V044,
-    V045,
-    V046,
-    V047,
-    V048,
-    V049,
-    V050,
-    V051,
-    V052,
-    V053,
-    V054,
-    V055,
-    V056,
-    V057,
-    V058,
-    V059,
-    V060,
-    V061,
-    V062,
-    V063,
-    V064,
-    V065,
-    V066,
-    V067,
-    V068,
-    V069,
-    V070,
-    V071,
-    V072,
-    V073,
-    V074,
-    V075,
-    V076,
-    V077,
-    V078,
-    V079,
-    V080,
-    V081,
-    V082,
-    V083,
-    V084,
-    V085,
-    V086,
-    V087,
-    V088,
-    V089,
-    V090,
-    V091,
-    V092,
-    V093,
-    V094,
-    V095,
-    V096,
-    V097,
-    V098,
-    V099,
-    V100,
-    V101,
-    V102,
-    V103,
-    V104,
-    V105,
-    V106,
-    V107,
-    V108,
-    V109,
-    V110,
-    V111,
-    V112,
-    V113,
-    V114,
-    V115,
-    V116,
-    V117,
-    V118,
-    V119,
-    V120,
-    V121,
-    V122,
-    V123,
-    V124,
-    V125,
-    V126,
-    V127,
-    V128,
-    V129,
-    V130,
-    V131,
-    V132,
-    V133,
-    V134,
-    V135,
-    V136,
-    V137,
-    V138,
-    V139,
-    V140,
-    V141,
-    V142,
-    V143,
-    V144,
-    V145,
-    V146,
-    V147,
-    V148,
-    V149,
-    V150,
-    V151,
-    V152,
-    V153,
-    V154,
-    V155,
-    V156,
-    V157,
-    V158,
-    V159,
-    V160,
-    V161,
-    V162,
-    V163,
-    V164,
-    V165,
-    V166,
-    V167,
-    V168,
-    V169,
-    V170,
-    V171,
-    V172,
-    V173,
-    V174,
-    V175,
-    V176,
-    V177,
-    V178,
-    V179,
-    V180,
-    V181,
-    V182,
-    V183,
-    V184,
-    V185,
-    V186,
-    V187,
-    V188,
-    V189,
-    V190,
-    V191,
-    V192,
-    V193,
-    V194,
-    V195,
-    V196,
-    V197,
-    V198,
-    V199,
-    V200,
-}
-
-const _: () = assert!(std::intrinsics::discriminant_value(&Tricky::V100) == 100);
-
-// CHECK-LABEL: define noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @discriminant6(i8 noundef %e)
-// CHECK-NEXT: start:
-// CHECK-NEXT: %[[REL_VAR:.+]] = add i8 %e, -66
-// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp ult i8 %[[REL_VAR]], -56
-// CHECK-NEXT: %[[TAGGED_DISCR:.+]] = add i8 %e, -65
-// CHECK-NEXT: %[[DISCR:.+]] = select i1 %[[IS_NICHE]], i8 %[[TAGGED_DISCR]], i8 0
-// CHECK-NEXT: ret i8 %[[DISCR]]
-#[no_mangle]
-pub fn discriminant6(e: Tricky) -> u8 {
-    std::intrinsics::discriminant_value(&e) as _
-}
-
-// Case from <https://github.com/rust-lang/rust/issues/104519>,
-// where sign-extension is important.
-
-pub enum OpenResult {
-    Ok(()),
-    Err(()),
-    TransportErr(TransportErr),
-}
-
-#[repr(i32)]
-pub enum TransportErr {
-    UnknownMethod = -2,
-}
-
-#[no_mangle]
-pub fn match7(result: OpenResult) -> u8 {
-    // CHECK-LABEL: define 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
-    // CHECK-NEXT: ret i8 %[[RET]]
-    match result {
-        OpenResult::Ok(()) => 0,
-        _ => 1,
-    }
-}
diff --git a/tests/codegen/enum/enum-two-variants-match.rs b/tests/codegen/enum/enum-two-variants-match.rs
deleted file mode 100644
index 12d9edc4d62..00000000000
--- a/tests/codegen/enum/enum-two-variants-match.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-//@ only-64bit (because these discriminants are isize)
-
-#![crate_type = "lib"]
-
-// This directly tests what we emit for these matches, rather than what happens
-// after optimization, so it doesn't need to worry about extra flags on the
-// instructions and is less susceptible to being broken on LLVM updates.
-
-// CHECK-LABEL: @option_match
-#[no_mangle]
-pub fn option_match(x: Option<i32>) -> u16 {
-    // CHECK-NOT: %x = alloca
-    // CHECK: %[[OUT:.+]] = alloca [2 x i8]
-    // CHECK-NOT: %x = alloca
-
-    // CHECK: %[[DISCR:.+]] = zext i32 %x.0 to i64
-    // CHECK: %[[COND:.+]] = trunc nuw i64 %[[DISCR]] to i1
-    // CHECK: br i1 %[[COND]], label %[[TRUE:[a-z0-9]+]], label %[[FALSE:[a-z0-9]+]]
-
-    // CHECK: [[TRUE]]:
-    // CHECK: store i16 13, ptr %[[OUT]]
-
-    // CHECK: [[FALSE]]:
-    // CHECK: store i16 42, ptr %[[OUT]]
-
-    // CHECK: %[[RET:.+]] = load i16, ptr %[[OUT]]
-    // CHECK: ret i16 %[[RET]]
-    match x {
-        Some(_) => 13,
-        None => 42,
-    }
-}
-
-// CHECK-LABEL: @result_match
-#[no_mangle]
-pub fn result_match(x: Result<u64, i64>) -> u16 {
-    // CHECK-NOT: %x = alloca
-    // CHECK: %[[OUT:.+]] = alloca [2 x i8]
-    // CHECK-NOT: %x = alloca
-
-    // CHECK: %[[COND:.+]] = trunc nuw i64 %x.0 to i1
-    // CHECK: br i1 %[[COND]], label %[[TRUE:[a-z0-9]+]], label %[[FALSE:[a-z0-9]+]]
-
-    // CHECK: [[TRUE]]:
-    // CHECK: store i16 13, ptr %[[OUT]]
-
-    // CHECK: [[FALSE]]:
-    // CHECK: store i16 42, ptr %[[OUT]]
-
-    // CHECK: %[[RET:.+]] = load i16, ptr %[[OUT]]
-    // CHECK: ret i16 %[[RET]]
-    match x {
-        Err(_) => 13,
-        Ok(_) => 42,
-    }
-}
-
-// CHECK-LABEL: @option_bool_match(
-#[no_mangle]
-pub fn option_bool_match(x: Option<bool>) -> char {
-    // CHECK: %[[RAW:.+]] = load i8, ptr %x
-    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %[[RAW]], 2
-    // CHECK: %[[OPT_DISCR:.+]] = select i1 %[[IS_NONE]], i64 0, i64 1
-    // CHECK: %[[OPT_DISCR_T:.+]] = trunc nuw i64 %[[OPT_DISCR]] to i1
-    // CHECK: br i1 %[[OPT_DISCR_T]], label %[[BB_SOME:.+]], label %[[BB_NONE:.+]]
-
-    // CHECK: [[BB_SOME]]:
-    // CHECK: %[[FIELD:.+]] = load i8, ptr %x
-    // CHECK: %[[FIELD_T:.+]] = trunc nuw i8 %[[FIELD]] to i1
-    // CHECK: br i1 %[[FIELD_T]]
-    match x {
-        None => 'n',
-        Some(false) => 'f',
-        Some(true) => 't',
-    }
-}
-
-use std::cmp::Ordering::{self, *};
-// CHECK-LABEL: @option_ordering_match(
-#[no_mangle]
-pub fn option_ordering_match(x: Option<Ordering>) -> char {
-    // CHECK: %[[RAW:.+]] = load i8, ptr %x
-    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %[[RAW]], 2
-    // CHECK: %[[OPT_DISCR:.+]] = select i1 %[[IS_NONE]], i64 0, i64 1
-    // CHECK: %[[OPT_DISCR_T:.+]] = trunc nuw i64 %[[OPT_DISCR]] to i1
-    // CHECK: br i1 %[[OPT_DISCR_T]], label %[[BB_SOME:.+]], label %[[BB_NONE:.+]]
-
-    // CHECK: [[BB_SOME]]:
-    // CHECK: %[[FIELD:.+]] = load i8, ptr %x
-    // CHECK: switch i8 %[[FIELD]], label %[[UNREACHABLE:.+]] [
-    // CHECK-NEXT: i8 -1, label
-    // CHECK-NEXT: i8 0, label
-    // CHECK-NEXT: i8 1, label
-    // CHECK-NEXT: ]
-
-    // CHECK: [[UNREACHABLE]]:
-    // CHECK-NEXT: unreachable
-    match x {
-        None => '?',
-        Some(Less) => '<',
-        Some(Equal) => '=',
-        Some(Greater) => '>',
-    }
-}
-
-// CHECK-LABEL: @option_nonzero_match(
-#[no_mangle]
-pub fn option_nonzero_match(x: Option<std::num::NonZero<u16>>) -> u16 {
-    // CHECK: %[[OUT:.+]] = alloca [2 x i8]
-
-    // CHECK: %[[IS_NONE:.+]] = icmp eq i16 %x, 0
-    // CHECK: %[[OPT_DISCR:.+]] = select i1 %[[IS_NONE]], i64 0, i64 1
-    // CHECK: %[[OPT_DISCR_T:.+]] = trunc nuw i64 %[[OPT_DISCR]] to i1
-    // CHECK: br i1 %[[OPT_DISCR_T]], label %[[BB_SOME:.+]], label %[[BB_NONE:.+]]
-
-    // CHECK: [[BB_SOME]]:
-    // CHECK: store i16 987, ptr %[[OUT]]
-
-    // CHECK: [[BB_NONE]]:
-    // CHECK: store i16 123, ptr %[[OUT]]
-
-    // CHECK: %[[RET:.+]] = load i16, ptr %[[OUT]]
-    // CHECK: ret i16 %[[RET]]
-
-    match x {
-        None => 123,
-        Some(_) => 987,
-    }
-}
diff --git a/tests/codegen/enum/enum-u128.rs b/tests/codegen/enum/enum-u128.rs
deleted file mode 100644
index 2676669f3e3..00000000000
--- a/tests/codegen/enum/enum-u128.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// This tests that debug info for "c-like" 128bit enums is properly emitted.
-// This is ignored for the fallback mode on MSVC due to problems with PDB.
-
-//
-//@ ignore-msvc
-//@ ignore-wasi wasi codegens the main symbol differently
-
-//@ compile-flags: -g -C no-prepopulate-passes
-
-// CHECK-LABEL: @main
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_enumeration_type,{{.*}}name: "Foo",{{.*}}flags: DIFlagEnumClass,{{.*}}
-// CHECK: {{.*}}DIEnumerator{{.*}}name: "Lo",{{.*}}value: 0,{{.*}}
-// CHECK: {{.*}}DIEnumerator{{.*}}name: "Hi",{{.*}}value: 18446744073709551616,{{.*}}
-// CHECK: {{.*}}DIEnumerator{{.*}}name: "Bar",{{.*}}value: 18446745000000000123,{{.*}}
-
-#[repr(u128)]
-pub enum Foo {
-    Lo,
-    Hi = 1 << 64,
-    Bar = 18_446_745_000_000_000_123,
-}
-
-pub fn main() {
-    let foo = Foo::Bar;
-}
diff --git a/tests/codegen/enum/unreachable_enum_default_branch.rs b/tests/codegen/enum/unreachable_enum_default_branch.rs
deleted file mode 100644
index 55b165fc111..00000000000
--- a/tests/codegen/enum/unreachable_enum_default_branch.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Int(u32);
-
-const A: Int = Int(201);
-const B: Int = Int(270);
-const C: Int = Int(153);
-
-// The code is from https://github.com/rust-lang/rust/issues/119520.
-// This code will basically turn into `matches!(x.partial_cmp(&A), Some(Greater | Equal))`.
-// The otherwise branch must be `Less`.
-// CHECK-LABEL: @implicit_match(
-// CHECK-SAME: [[TMP0:%.*]])
-// CHECK-NEXT:  start:
-// CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[TMP0]], -201
-// CHECK-NEXT:    icmp ult i32 [[TMP1]], 70
-// CHECK-NEXT:    icmp eq i32 [[TMP0]], 153
-// CHECK-NEXT:    [[SPEC_SELECT:%.*]] = or i1
-// CHECK-NEXT:    ret i1 [[SPEC_SELECT]]
-#[no_mangle]
-pub fn implicit_match(x: Int) -> bool {
-    (x >= A && x <= B) || x == C
-}
-
-// The code is from https://github.com/rust-lang/rust/issues/110097.
-// We expect it to generate the same optimized code as a full match.
-// CHECK-LABEL: @if_let(
-// CHECK: start:
-// CHECK-NOT: zext
-// CHECK: select
-// CHECK-NEXT: insertvalue
-// CHECK-NEXT: insertvalue
-// CHECK-NEXT: ret
-#[no_mangle]
-pub fn if_let(val: Result<i32, ()>) -> Result<i32, ()> {
-    if let Ok(x) = val { Ok(x * 2) } else { Err(()) }
-}
diff --git a/tests/codegen/ergonomic-clones/closure.rs b/tests/codegen/ergonomic-clones/closure.rs
deleted file mode 100644
index b6fc8172641..00000000000
--- a/tests/codegen/ergonomic-clones/closure.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0 -Zmir-opt-level=0
-
-#![crate_type = "lib"]
-
-#![feature(ergonomic_clones)]
-#![allow(incomplete_features)]
-
-use std::clone::UseCloned;
-
-pub fn ergonomic_clone_closure_move() -> String {
-    let s = String::from("hi");
-
-    // CHECK-NOT: ; call core::clone::impls::<impl core::clone::Clone for String>::clone
-    let cl = use || s;
-    cl()
-}
-
-#[derive(Clone)]
-struct Foo;
-
-impl UseCloned for Foo {}
-
-pub fn ergonomic_clone_closure_use_cloned() -> Foo {
-    let f = Foo;
-
-    // CHECK: ; call <closure::Foo as core::clone::Clone>::clone
-    let f1 = use || f;
-
-    // CHECK: ; call <closure::Foo as core::clone::Clone>::clone
-    let f2 = use || f;
-
-    f
-}
-
-pub fn ergonomic_clone_closure_copy() -> i32 {
-    let i = 1;
-
-    // CHECK-NOT: ; call core::clone::impls::<impl core::clone::Clone for i32>::clone
-    let i1 = use || i;
-
-    // CHECK-NOT: ; call core::clone::impls::<impl core::clone::Clone for i32>::clone
-    let i2 = use || i;
-
-    i
-}
-
-pub fn ergonomic_clone_closure_use_cloned_generics<T: UseCloned>(f: T) -> T {
-    // CHECK-NOT: ; call core::clone::impls::<impl core::clone::Clone for i32>::clone
-    let f1 = use || f;
-
-    // CHECK-NOT: ; call core::clone::impls::<impl core::clone::Clone for i32>::clone
-    let f2 = use || f;
-
-    f
-}
diff --git a/tests/codegen/error-provide.rs b/tests/codegen/error-provide.rs
deleted file mode 100644
index 7f091e34359..00000000000
--- a/tests/codegen/error-provide.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Codegen test for #126242
-
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-#![feature(error_generic_member_access)]
-use std::error::Request;
-use std::fmt;
-
-#[derive(Debug)]
-struct MyBacktrace1 {}
-
-#[derive(Debug)]
-struct MyBacktrace2 {}
-
-#[derive(Debug)]
-struct MyBacktrace3 {}
-
-#[derive(Debug)]
-struct MyError {
-    backtrace1: MyBacktrace1,
-    backtrace2: MyBacktrace2,
-    backtrace3: MyBacktrace3,
-    other: MyBacktrace3,
-}
-
-impl fmt::Display for MyError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Example Error")
-    }
-}
-
-impl std::error::Error for MyError {
-    // CHECK-LABEL: @provide
-    #[no_mangle]
-    fn provide<'a>(&'a self, request: &mut Request<'a>) {
-        // LLVM should be able to optimize multiple .provide_* calls into a switch table
-        // and eliminate redundant ones, rather than compare one-by-one.
-
-        // CHECK-NEXT: start:
-        // CHECK-NEXT: %[[SCRUTINEE:[^ ]+]] = load i128, ptr
-        // CHECK-NEXT: switch i128 %[[SCRUTINEE]], label %{{.*}} [
-        // CHECK-COUNT-3: i128 {{.*}}, label %{{.*}}
-        // CHECK-NEXT: ]
-        request
-            .provide_ref::<MyBacktrace1>(&self.backtrace1)
-            .provide_ref::<MyBacktrace3>(&self.other)
-            .provide_ref::<MyBacktrace2>(&self.backtrace2)
-            .provide_ref::<MyBacktrace3>(&self.backtrace3);
-    }
-}
diff --git a/tests/codegen/export-no-mangle.rs b/tests/codegen/export-no-mangle.rs
deleted file mode 100644
index 5040684f52e..00000000000
--- a/tests/codegen/export-no-mangle.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-mod private {
-    // CHECK: @FOO =
-    #[no_mangle]
-    pub static FOO: u32 = 3;
-
-    // CHECK: @BAR =
-    #[export_name = "BAR"]
-    static BAR: u32 = 3;
-
-    // CHECK: void @a()
-    #[no_mangle]
-    pub extern "C" fn a() {}
-
-    // CHECK: void @b()
-    #[export_name = "b"]
-    extern "C" fn b() {}
-
-    // CHECK: void @c()
-    #[export_name = "c"]
-    #[inline]
-    extern "C" fn c() {}
-
-    // CHECK: void @d()
-    #[export_name = "d"]
-    #[inline(always)]
-    extern "C" fn d() {}
-}
diff --git a/tests/codegen/external-no-mangle-fns.rs b/tests/codegen/external-no-mangle-fns.rs
deleted file mode 100644
index 35ab0fd7909..00000000000
--- a/tests/codegen/external-no-mangle-fns.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-// `#[no_mangle]`d functions always have external linkage, i.e., no `internal` in their `define`s
-
-#![crate_type = "lib"]
-#![no_std]
-
-// CHECK: define{{( dso_local)?}} void @a()
-#[no_mangle]
-fn a() {}
-
-// CHECK: define{{( dso_local)?}} void @b()
-#[no_mangle]
-pub fn b() {}
-
-mod private {
-    // CHECK: define{{( dso_local)?}} void @c()
-    #[no_mangle]
-    fn c() {}
-
-    // CHECK: define{{( dso_local)?}} void @d()
-    #[no_mangle]
-    pub fn d() {}
-}
-
-const HIDDEN: () = {
-    // CHECK: define{{( dso_local)?}} void @e()
-    #[no_mangle]
-    fn e() {}
-
-    // CHECK: define{{( dso_local)?}} void @f()
-    #[no_mangle]
-    pub fn f() {}
-};
-
-// The surrounding item should not accidentally become external
-// CHECK-LABEL: ; external_no_mangle_fns::x
-// CHECK-NEXT: ; Function Attrs:
-// CHECK-NEXT: define internal
-#[inline(never)]
-fn x() {
-    // CHECK: define{{( dso_local)?}} void @g()
-    #[no_mangle]
-    fn g() {
-        x();
-    }
-
-    // CHECK: define{{( dso_local)?}} void @h()
-    #[no_mangle]
-    pub fn h() {}
-
-    // side effect to keep `x` around
-    unsafe {
-        core::ptr::read_volatile(&42);
-    }
-}
-
-// CHECK: define{{( dso_local)?}} void @i()
-#[no_mangle]
-#[inline]
-fn i() {}
-
-// CHECK: define{{( dso_local)?}} void @j()
-#[no_mangle]
-#[inline]
-pub fn j() {}
-
-// CHECK: define{{( dso_local)?}} void @k()
-#[no_mangle]
-#[inline(always)]
-fn k() {}
-
-// CHECK: define{{( dso_local)?}} void @l()
-#[no_mangle]
-#[inline(always)]
-pub fn l() {}
diff --git a/tests/codegen/external-no-mangle-statics.rs b/tests/codegen/external-no-mangle-statics.rs
deleted file mode 100644
index 49f42ee977d..00000000000
--- a/tests/codegen/external-no-mangle-statics.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-//@ revisions: lib staticlib
-//@ ignore-emscripten default visibility is hidden
-//@ compile-flags: -Copt-level=3
-//@ [lib] compile-flags: --crate-type lib
-//@ [staticlib] compile-flags: --crate-type staticlib
-// `#[no_mangle]`d static variables always have external linkage, i.e., no `internal` in their
-// definitions
-
-// CHECK-DAG: @A = {{(dso_local )?}}local_unnamed_addr constant
-#[no_mangle]
-static A: u8 = 0;
-
-// CHECK-DAG: @B = {{(dso_local )?}}local_unnamed_addr global
-#[no_mangle]
-static mut B: u8 = 0;
-
-// CHECK-DAG: @C = {{(dso_local )?}}local_unnamed_addr constant
-#[no_mangle]
-pub static C: u8 = 0;
-
-// CHECK-DAG: @D = {{(dso_local )?}}local_unnamed_addr global
-#[no_mangle]
-pub static mut D: u8 = 0;
-
-mod private {
-    // CHECK-DAG: @E = {{(dso_local )?}}local_unnamed_addr constant
-    #[no_mangle]
-    static E: u8 = 0;
-
-    // CHECK-DAG: @F = {{(dso_local )?}}local_unnamed_addr global
-    #[no_mangle]
-    static mut F: u8 = 0;
-
-    // CHECK-DAG: @G = {{(dso_local )?}}local_unnamed_addr constant
-    #[no_mangle]
-    pub static G: u8 = 0;
-
-    // CHECK-DAG: @H = {{(dso_local )?}}local_unnamed_addr global
-    #[no_mangle]
-    pub static mut H: u8 = 0;
-}
-
-const HIDDEN: () = {
-    // CHECK-DAG: @I = {{(dso_local )?}}local_unnamed_addr constant
-    #[no_mangle]
-    static I: u8 = 0;
-
-    // CHECK-DAG: @J = {{(dso_local )?}}local_unnamed_addr global
-    #[no_mangle]
-    static mut J: u8 = 0;
-
-    // CHECK-DAG: @K = {{(dso_local )?}}local_unnamed_addr constant
-    #[no_mangle]
-    pub static K: u8 = 0;
-
-    // CHECK-DAG: @L = {{(dso_local )?}}local_unnamed_addr global
-    #[no_mangle]
-    pub static mut L: u8 = 0;
-};
-
-fn x() {
-    // CHECK-DAG: @M = {{(dso_local )?}}local_unnamed_addr constant
-    #[no_mangle]
-    static M: fn() = x;
-
-    // CHECK-DAG: @N = {{(dso_local )?}}local_unnamed_addr global
-    #[no_mangle]
-    static mut N: u8 = 0;
-
-    // CHECK-DAG: @O = {{(dso_local )?}}local_unnamed_addr constant
-    #[no_mangle]
-    pub static O: u8 = 0;
-
-    // CHECK-DAG: @P = {{(dso_local )?}}local_unnamed_addr global
-    #[no_mangle]
-    pub static mut P: u8 = 0;
-}
diff --git a/tests/codegen/f128-wasm32-callconv.rs b/tests/codegen/f128-wasm32-callconv.rs
deleted file mode 100644
index 7dccbda18f1..00000000000
--- a/tests/codegen/f128-wasm32-callconv.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//! Verify that Rust implements the expected calling convention for `f128`
-
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 --target wasm32-wasip1
-//@ needs-llvm-components: webassembly
-
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-#![feature(no_core, lang_items, f128)]
-
-extern crate minicore;
-
-extern "C" {
-    fn extern_call(arg0: f128);
-    fn extern_ret() -> f128;
-}
-
-#[no_mangle]
-pub extern "C" fn pass(_arg0: u32, arg1: f128) {
-    // CHECK-LABEL: @pass(
-    // an f128 is passed via registers
-    // CHECK-SAME: fp128 noundef %arg1
-    // CHECK: call void @extern_call
-    unsafe { extern_call(arg1) };
-}
-
-// Check that we produce the correct return ABI
-#[no_mangle]
-pub extern "C" fn ret(_arg0: u32, arg1: f128) -> f128 {
-    // CHECK-LABEL: @ret(
-    // but an f128 is returned via the stack
-    // CHECK-SAME: sret
-    // CHECK: store fp128 %arg1
-    // CHECK-NEXT: ret void
-    arg1
-}
-
-// Check that we consume the correct return ABI
-#[no_mangle]
-pub extern "C" fn forward(dst: *mut f128) {
-    // CHECK-LABEL: @forward
-    // CHECK-SAME: ptr{{.*}} %dst)
-    // without optimizatons, an intermediate alloca is used
-    // CHECK: call void @extern_ret
-    // CHECK: store fp128
-    // CHECK: ret void
-    unsafe { *dst = extern_ret() };
-}
diff --git a/tests/codegen/fastcall-inreg.rs b/tests/codegen/fastcall-inreg.rs
deleted file mode 100644
index 066943d6e7e..00000000000
--- a/tests/codegen/fastcall-inreg.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Checks if the "fastcall" calling convention marks function arguments
-// as "inreg" like the C/C++ compilers for the platforms.
-// x86 only.
-
-//@ add-core-stubs
-//@ compile-flags: --target i686-unknown-linux-gnu -Cno-prepopulate-passes -Copt-level=3
-//@ needs-llvm-components: x86
-
-#![crate_type = "lib"]
-#![no_core]
-#![feature(no_core, lang_items)]
-
-extern crate minicore;
-use minicore::*;
-
-pub mod tests {
-    // CHECK: @f1(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
-    #[no_mangle]
-    pub extern "fastcall" fn f1(_: i32, _: i32, _: i32) {}
-
-    // CHECK: @f2(ptr inreg noundef %_1, ptr inreg noundef %_2, ptr noundef %_3)
-    #[no_mangle]
-    pub extern "fastcall" fn f2(_: *const i32, _: *const i32, _: *const i32) {}
-
-    // CHECK: @f3(float noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3, i32 noundef %_4)
-    #[no_mangle]
-    pub extern "fastcall" fn f3(_: f32, _: i32, _: i32, _: i32) {}
-
-    // CHECK: @f4(i32 inreg noundef %_1, float noundef %_2, i32 inreg noundef %_3, i32 noundef %_4)
-    #[no_mangle]
-    pub extern "fastcall" fn f4(_: i32, _: f32, _: i32, _: i32) {}
-
-    // CHECK: @f5(i64 noundef %_1, i32 noundef %_2)
-    #[no_mangle]
-    pub extern "fastcall" fn f5(_: i64, _: i32) {}
-
-    // CHECK: @f6(i1 inreg noundef zeroext %_1, i32 inreg noundef %_2, i32 noundef %_3)
-    #[no_mangle]
-    pub extern "fastcall" fn f6(_: bool, _: i32, _: i32) {}
-}
diff --git a/tests/codegen/fatptr.rs b/tests/codegen/fatptr.rs
deleted file mode 100644
index 041807202b8..00000000000
--- a/tests/codegen/fatptr.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-pub trait T {}
-
-// CHECK-LABEL: @copy_fat_ptr
-#[no_mangle]
-pub fn copy_fat_ptr(x: &T) {
-    // CHECK-NOT: extractvalue
-    let x2 = x;
-}
diff --git a/tests/codegen/fewer-names.rs b/tests/codegen/fewer-names.rs
deleted file mode 100644
index ff7a916b619..00000000000
--- a/tests/codegen/fewer-names.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ compile-flags: -Coverflow-checks=no -Copt-level=3
-//@ revisions: YES NO
-//@ [YES]compile-flags: -Zfewer-names=yes
-//@ [NO] compile-flags: -Zfewer-names=no
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn sum(x: u32, y: u32) -> u32 {
-    // YES-LABEL: define{{.*}}i32 @sum(i32{{.*}} %0, i32{{.*}} %1)
-    // YES-NEXT:    %3 = add i32 %1, %0
-    // YES-NEXT:    ret i32 %3
-
-    // NO-LABEL: define{{.*}}i32 @sum(i32{{.*}} %x, i32{{.*}} %y)
-    // NO-NEXT:  start:
-    // NO-NEXT:    %z = add i32 %y, %x
-    // NO-NEXT:    ret i32 %z
-    let z = x + y;
-    z
-}
diff --git a/tests/codegen/fixed-x18.rs b/tests/codegen/fixed-x18.rs
deleted file mode 100644
index a5767cfa456..00000000000
--- a/tests/codegen/fixed-x18.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Test that the `reserve-x18` target feature is (not) emitted when
-// the `-Zfixed-x18` flag is (not) set.
-
-//@ add-core-stubs
-//@ revisions: unset set
-//@ needs-llvm-components: aarch64
-//@ compile-flags: --target aarch64-unknown-none
-//@ [set] compile-flags: -Zfixed-x18
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[no_mangle]
-pub fn foo() {
-    // CHECK: @foo() unnamed_addr #0
-
-    // unset-NOT: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+reserve-x18{{.*}} }
-    // set: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+reserve-x18{{.*}} }
-}
diff --git a/tests/codegen/float/algebraic.rs b/tests/codegen/float/algebraic.rs
deleted file mode 100644
index 818a4bcdfe3..00000000000
--- a/tests/codegen/float/algebraic.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-// Verify that algebraic intrinsics generate the correct LLVM calls
-
-// Ensure operations get inlined
-//@ compile-flags: -Copt-level=1
-
-#![crate_type = "lib"]
-#![feature(f16)]
-#![feature(f128)]
-#![feature(float_algebraic)]
-
-// CHECK-LABEL: @f16_algebraic_add
-#[no_mangle]
-pub fn f16_algebraic_add(a: f16, b: f16) -> f16 {
-    // CHECK: fadd reassoc nsz arcp contract half %{{.+}}, %{{.+}}
-    a.algebraic_add(b)
-}
-
-// CHECK-LABEL: @f16_algebraic_sub
-#[no_mangle]
-pub fn f16_algebraic_sub(a: f16, b: f16) -> f16 {
-    // CHECK: fsub reassoc nsz arcp contract half %{{.+}}, %{{.+}}
-    a.algebraic_sub(b)
-}
-
-// CHECK-LABEL: @f16_algebraic_mul
-#[no_mangle]
-pub fn f16_algebraic_mul(a: f16, b: f16) -> f16 {
-    // CHECK: fmul reassoc nsz arcp contract half %{{.+}}, %{{.+}}
-    a.algebraic_mul(b)
-}
-
-// CHECK-LABEL: @f16_algebraic_div
-#[no_mangle]
-pub fn f16_algebraic_div(a: f16, b: f16) -> f16 {
-    // CHECK: fdiv reassoc nsz arcp contract half %{{.+}}, %{{.+}}
-    a.algebraic_div(b)
-}
-
-// CHECK-LABEL: @f16_algebraic_rem
-#[no_mangle]
-pub fn f16_algebraic_rem(a: f16, b: f16) -> f16 {
-    // CHECK: frem reassoc nsz arcp contract half %{{.+}}, %{{.+}}
-    a.algebraic_rem(b)
-}
-
-// CHECK-LABEL: @f32_algebraic_add
-#[no_mangle]
-pub fn f32_algebraic_add(a: f32, b: f32) -> f32 {
-    // CHECK: fadd reassoc nsz arcp contract float %{{.+}}, %{{.+}}
-    a.algebraic_add(b)
-}
-
-// CHECK-LABEL: @f32_algebraic_sub
-#[no_mangle]
-pub fn f32_algebraic_sub(a: f32, b: f32) -> f32 {
-    // CHECK: fsub reassoc nsz arcp contract float %{{.+}}, %{{.+}}
-    a.algebraic_sub(b)
-}
-
-// CHECK-LABEL: @f32_algebraic_mul
-#[no_mangle]
-pub fn f32_algebraic_mul(a: f32, b: f32) -> f32 {
-    // CHECK: fmul reassoc nsz arcp contract float %{{.+}}, %{{.+}}
-    a.algebraic_mul(b)
-}
-
-// CHECK-LABEL: @f32_algebraic_div
-#[no_mangle]
-pub fn f32_algebraic_div(a: f32, b: f32) -> f32 {
-    // CHECK: fdiv reassoc nsz arcp contract float %{{.+}}, %{{.+}}
-    a.algebraic_div(b)
-}
-
-// CHECK-LABEL: @f32_algebraic_rem
-#[no_mangle]
-pub fn f32_algebraic_rem(a: f32, b: f32) -> f32 {
-    // CHECK: frem reassoc nsz arcp contract float %{{.+}}, %{{.+}}
-    a.algebraic_rem(b)
-}
-
-// CHECK-LABEL: @f64_algebraic_add
-#[no_mangle]
-pub fn f64_algebraic_add(a: f64, b: f64) -> f64 {
-    // CHECK: fadd reassoc nsz arcp contract double %{{.+}}, %{{.+}}
-    a.algebraic_add(b)
-}
-
-// CHECK-LABEL: @f64_algebraic_sub
-#[no_mangle]
-pub fn f64_algebraic_sub(a: f64, b: f64) -> f64 {
-    // CHECK: fsub reassoc nsz arcp contract double %{{.+}}, %{{.+}}
-    a.algebraic_sub(b)
-}
-
-// CHECK-LABEL: @f64_algebraic_mul
-#[no_mangle]
-pub fn f64_algebraic_mul(a: f64, b: f64) -> f64 {
-    // CHECK: fmul reassoc nsz arcp contract double %{{.+}}, %{{.+}}
-    a.algebraic_mul(b)
-}
-
-// CHECK-LABEL: @f64_algebraic_div
-#[no_mangle]
-pub fn f64_algebraic_div(a: f64, b: f64) -> f64 {
-    // CHECK: fdiv reassoc nsz arcp contract double %{{.+}}, %{{.+}}
-    a.algebraic_div(b)
-}
-
-// CHECK-LABEL: @f64_algebraic_rem
-#[no_mangle]
-pub fn f64_algebraic_rem(a: f64, b: f64) -> f64 {
-    // CHECK: frem reassoc nsz arcp contract double %{{.+}}, %{{.+}}
-    a.algebraic_rem(b)
-}
-
-// CHECK-LABEL: @f128_algebraic_add
-#[no_mangle]
-pub fn f128_algebraic_add(a: f128, b: f128) -> f128 {
-    // CHECK: fadd reassoc nsz arcp contract fp128 %{{.+}}, %{{.+}}
-    a.algebraic_add(b)
-}
-
-// CHECK-LABEL: @f128_algebraic_sub
-#[no_mangle]
-pub fn f128_algebraic_sub(a: f128, b: f128) -> f128 {
-    // CHECK: fsub reassoc nsz arcp contract fp128 %{{.+}}, %{{.+}}
-    a.algebraic_sub(b)
-}
-
-// CHECK-LABEL: @f128_algebraic_mul
-#[no_mangle]
-pub fn f128_algebraic_mul(a: f128, b: f128) -> f128 {
-    // CHECK: fmul reassoc nsz arcp contract fp128 %{{.+}}, %{{.+}}
-    a.algebraic_mul(b)
-}
-
-// CHECK-LABEL: @f128_algebraic_div
-#[no_mangle]
-pub fn f128_algebraic_div(a: f128, b: f128) -> f128 {
-    // CHECK: fdiv reassoc nsz arcp contract fp128 %{{.+}}, %{{.+}}
-    a.algebraic_div(b)
-}
-
-// CHECK-LABEL: @f128_algebraic_rem
-#[no_mangle]
-pub fn f128_algebraic_rem(a: f128, b: f128) -> f128 {
-    // CHECK: frem reassoc nsz arcp contract fp128 %{{.+}}, %{{.+}}
-    a.algebraic_rem(b)
-}
diff --git a/tests/codegen/float/f128.rs b/tests/codegen/float/f128.rs
deleted file mode 100644
index d87bab1172a..00000000000
--- a/tests/codegen/float/f128.rs
+++ /dev/null
@@ -1,441 +0,0 @@
-// 32-bit x86 returns float types differently to avoid the x87 stack.
-// 32-bit systems will return 128bit values using a return area pointer.
-// Emscripten aligns f128 to 8 bytes, not 16.
-//@ revisions: x86-sse x86-nosse bit32 bit64 emscripten
-//@[x86-sse] only-x86
-//@[x86-sse] only-rustc_abi-x86-sse2
-//@[x86-nosse] only-x86
-//@[x86-nosse] ignore-rustc_abi-x86-sse2
-//@[bit32] ignore-x86
-//@[bit32] ignore-emscripten
-//@[bit32] only-32bit
-//@[bit64] ignore-x86
-//@[bit64] ignore-emscripten
-//@[bit64] only-64bit
-//@[emscripten] only-emscripten
-
-// Verify that our intrinsics generate the correct LLVM calls for f128
-
-#![crate_type = "lib"]
-#![feature(f128)]
-#![feature(f16)]
-#![feature(core_intrinsics)]
-
-// CHECK-LABEL: i1 @f128_eq(
-#[no_mangle]
-pub fn f128_eq(a: f128, b: f128) -> bool {
-    // CHECK: fcmp oeq fp128 %{{.+}}, %{{.+}}
-    a == b
-}
-
-// CHECK-LABEL: i1 @f128_ne(
-#[no_mangle]
-pub fn f128_ne(a: f128, b: f128) -> bool {
-    // CHECK: fcmp une fp128 %{{.+}}, %{{.+}}
-    a != b
-}
-
-// CHECK-LABEL: i1 @f128_gt(
-#[no_mangle]
-pub fn f128_gt(a: f128, b: f128) -> bool {
-    // CHECK: fcmp ogt fp128 %{{.+}}, %{{.+}}
-    a > b
-}
-
-// CHECK-LABEL: i1 @f128_ge(
-#[no_mangle]
-pub fn f128_ge(a: f128, b: f128) -> bool {
-    // CHECK: fcmp oge fp128 %{{.+}}, %{{.+}}
-    a >= b
-}
-
-// CHECK-LABEL: i1 @f128_lt(
-#[no_mangle]
-pub fn f128_lt(a: f128, b: f128) -> bool {
-    // CHECK: fcmp olt fp128 %{{.+}}, %{{.+}}
-    a < b
-}
-
-// CHECK-LABEL: i1 @f128_le(
-#[no_mangle]
-pub fn f128_le(a: f128, b: f128) -> bool {
-    // CHECK: fcmp ole fp128 %{{.+}}, %{{.+}}
-    a <= b
-}
-
-// x86-nosse-LABEL: void @f128_neg({{.*}}sret([16 x i8])
-// x86-sse-LABEL: <16 x i8> @f128_neg(fp128
-// bit32-LABEL: void @f128_neg({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @f128_neg(
-// emscripten-LABEL: void @f128_neg({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f128_neg(a: f128) -> f128 {
-    // CHECK: fneg fp128
-    -a
-}
-
-// x86-nosse-LABEL: void @f128_add({{.*}}sret([16 x i8])
-// x86-sse-LABEL: <16 x i8> @f128_add(fp128
-// bit32-LABEL: void @f128_add({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @f128_add(
-// emscripten-LABEL: void @f128_add({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f128_add(a: f128, b: f128) -> f128 {
-    // CHECK: fadd fp128 %{{.+}}, %{{.+}}
-    a + b
-}
-
-// x86-nosse-LABEL: void @f128_sub({{.*}}sret([16 x i8])
-// x86-sse-LABEL: <16 x i8> @f128_sub(fp128
-// bit32-LABEL: void @f128_sub({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @f128_sub(
-// emscripten-LABEL: void @f128_sub({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f128_sub(a: f128, b: f128) -> f128 {
-    // CHECK: fsub fp128 %{{.+}}, %{{.+}}
-    a - b
-}
-
-// x86-nosse-LABEL: void @f128_mul({{.*}}sret([16 x i8])
-// x86-sse-LABEL: <16 x i8> @f128_mul(fp128
-// bit32-LABEL: void @f128_mul({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @f128_mul(
-// emscripten-LABEL: void @f128_mul({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f128_mul(a: f128, b: f128) -> f128 {
-    // CHECK: fmul fp128 %{{.+}}, %{{.+}}
-    a * b
-}
-
-// x86-nosse-LABEL: void @f128_div({{.*}}sret([16 x i8])
-// x86-sse-LABEL: <16 x i8> @f128_div(fp128
-// bit32-LABEL: void @f128_div({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @f128_div(
-// emscripten-LABEL: void @f128_div({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f128_div(a: f128, b: f128) -> f128 {
-    // CHECK: fdiv fp128 %{{.+}}, %{{.+}}
-    a / b
-}
-
-// x86-nosse-LABEL: void @f128_rem({{.*}}sret([16 x i8])
-// x86-sse-LABEL: <16 x i8> @f128_rem(fp128
-// bit32-LABEL: void @f128_rem({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @f128_rem(
-// emscripten-LABEL: void @f128_rem({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f128_rem(a: f128, b: f128) -> f128 {
-    // CHECK: frem fp128 %{{.+}}, %{{.+}}
-    a % b
-}
-
-// CHECK-LABEL: void @f128_add_assign(
-#[no_mangle]
-pub fn f128_add_assign(a: &mut f128, b: f128) {
-    // CHECK: fadd fp128 %{{.+}}, %{{.+}}
-    // CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
-    *a += b;
-}
-
-// CHECK-LABEL: void @f128_sub_assign(
-#[no_mangle]
-pub fn f128_sub_assign(a: &mut f128, b: f128) {
-    // CHECK: fsub fp128 %{{.+}}, %{{.+}}
-    // CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
-    *a -= b;
-}
-
-// CHECK-LABEL: void @f128_mul_assign(
-#[no_mangle]
-pub fn f128_mul_assign(a: &mut f128, b: f128) {
-    // CHECK: fmul fp128 %{{.+}}, %{{.+}}
-    // CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
-    *a *= b
-}
-
-// CHECK-LABEL: void @f128_div_assign(
-#[no_mangle]
-pub fn f128_div_assign(a: &mut f128, b: f128) {
-    // CHECK: fdiv fp128 %{{.+}}, %{{.+}}
-    // CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
-    *a /= b
-}
-
-// CHECK-LABEL: void @f128_rem_assign(
-#[no_mangle]
-pub fn f128_rem_assign(a: &mut f128, b: f128) {
-    // CHECK: frem fp128 %{{.+}}, %{{.+}}
-    // CHECK-NEXT: store fp128 %{{.+}}, ptr %{{.+}}
-    *a %= b
-}
-
-/* float to float conversions */
-
-// x86-sse-LABEL: <2 x i8> @f128_as_f16(
-// x86-nosse-LABEL: i16 @f128_as_f16(
-// bits32-LABEL: half @f128_as_f16(
-// bits64-LABEL: half @f128_as_f16(
-#[no_mangle]
-pub fn f128_as_f16(a: f128) -> f16 {
-    // CHECK: fptrunc fp128 %{{.+}} to half
-    a as f16
-}
-
-// x86-sse-LABEL: <4 x i8> @f128_as_f32(
-// x86-nosse-LABEL: i32 @f128_as_f32(
-// bit32-LABEL: float @f128_as_f32(
-// bit64-LABEL: float @f128_as_f32(
-// emscripten-LABEL: float @f128_as_f32(
-#[no_mangle]
-pub fn f128_as_f32(a: f128) -> f32 {
-    // CHECK: fptrunc fp128 %{{.+}} to float
-    a as f32
-}
-
-// x86-sse-LABEL: <8 x i8> @f128_as_f64(
-// x86-nosse-LABEL: void @f128_as_f64({{.*}}sret([8 x i8])
-// bit32-LABEL: double @f128_as_f64(
-// bit64-LABEL: double @f128_as_f64(
-// emscripten-LABEL: double @f128_as_f64(
-#[no_mangle]
-pub fn f128_as_f64(a: f128) -> f64 {
-    // CHECK: fptrunc fp128 %{{.+}} to double
-    a as f64
-}
-
-// x86-sse-LABEL: <16 x i8> @f128_as_self(
-// x86-nosse-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
-// bit32-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @f128_as_self(
-// emscripten-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f128_as_self(a: f128) -> f128 {
-    // x86: store fp128 %a, ptr %_0, align 16
-    // bit32: store fp128 %a, ptr %_0, align 16
-    // bit64: ret fp128 %{{.+}}
-    // emscripten: store fp128 %a, ptr %_0, align 8
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @f16_as_f128(
-// x86-nosse-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @f16_as_f128(
-// emscripten-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f16_as_f128(a: f16) -> f128 {
-    // CHECK: fpext half %{{.+}} to fp128
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @f32_as_f128(
-// x86-nosse-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @f32_as_f128(
-// emscripten-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f32_as_f128(a: f32) -> f128 {
-    // CHECK: fpext float %{{.+}} to fp128
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @f64_as_f128(
-// x86-nosse-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @f64_as_f128(
-// emscripten-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f64_as_f128(a: f64) -> f128 {
-    // CHECK: fpext double %{{.+}} to fp128
-    a as f128
-}
-
-/* float to int conversions */
-
-// CHECK-LABEL: i8 @f128_as_u8(
-#[no_mangle]
-pub fn f128_as_u8(a: f128) -> u8 {
-    // CHECK: call i8 @llvm.fptoui.sat.i8.f128(fp128 %{{.+}})
-    a as u8
-}
-
-#[no_mangle]
-pub fn f128_as_u16(a: f128) -> u16 {
-    // CHECK: call i16 @llvm.fptoui.sat.i16.f128(fp128 %{{.+}})
-    a as u16
-}
-
-// CHECK-LABEL: i32 @f128_as_u32(
-#[no_mangle]
-pub fn f128_as_u32(a: f128) -> u32 {
-    // CHECK: call i32 @llvm.fptoui.sat.i32.f128(fp128 %{{.+}})
-    a as u32
-}
-
-// CHECK-LABEL: i64 @f128_as_u64(
-#[no_mangle]
-pub fn f128_as_u64(a: f128) -> u64 {
-    // CHECK: call i64 @llvm.fptoui.sat.i64.f128(fp128 %{{.+}})
-    a as u64
-}
-
-// x86-sse-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
-// x86-nosse-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
-// bit64-LABEL: i128 @f128_as_u128(
-// emscripten-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f128_as_u128(a: f128) -> u128 {
-    // CHECK: call i128 @llvm.fptoui.sat.i128.f128(fp128 %{{.+}})
-    a as u128
-}
-
-// CHECK-LABEL: i8 @f128_as_i8(
-#[no_mangle]
-pub fn f128_as_i8(a: f128) -> i8 {
-    // CHECK: call i8 @llvm.fptosi.sat.i8.f128(fp128 %{{.+}})
-    a as i8
-}
-
-// CHECK-LABEL: i16 @f128_as_i16(
-#[no_mangle]
-pub fn f128_as_i16(a: f128) -> i16 {
-    // CHECK: call i16 @llvm.fptosi.sat.i16.f128(fp128 %{{.+}})
-    a as i16
-}
-// CHECK-LABEL: i32 @f128_as_i32(
-#[no_mangle]
-pub fn f128_as_i32(a: f128) -> i32 {
-    // CHECK: call i32 @llvm.fptosi.sat.i32.f128(fp128 %{{.+}})
-    a as i32
-}
-
-// CHECK-LABEL: i64 @f128_as_i64(
-#[no_mangle]
-pub fn f128_as_i64(a: f128) -> i64 {
-    // CHECK: call i64 @llvm.fptosi.sat.i64.f128(fp128 %{{.+}})
-    a as i64
-}
-
-// x86-sse-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
-// x86-nosse-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
-// bit64-LABEL: i128 @f128_as_i128(
-// emscripten-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn f128_as_i128(a: f128) -> i128 {
-    // CHECK: call i128 @llvm.fptosi.sat.i128.f128(fp128 %{{.+}})
-    a as i128
-}
-
-/* int to float conversions */
-
-// x86-sse-LABEL: <16 x i8> @u8_as_f128(
-// x86-nosse-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @u8_as_f128(
-// emscripten-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn u8_as_f128(a: u8) -> f128 {
-    // CHECK: uitofp i8 %{{.+}} to fp128
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @u16_as_f128(
-// x86-nosse-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @u16_as_f128(
-// emscripten-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn u16_as_f128(a: u16) -> f128 {
-    // CHECK: uitofp i16 %{{.+}} to fp128
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @u32_as_f128(
-// x86-nosse-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @u32_as_f128(
-// emscripten-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn u32_as_f128(a: u32) -> f128 {
-    // CHECK: uitofp i32 %{{.+}} to fp128
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @u64_as_f128(
-// x86-nosse-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @u64_as_f128(
-// emscripten-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn u64_as_f128(a: u64) -> f128 {
-    // CHECK: uitofp i64 %{{.+}} to fp128
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @u128_as_f128(
-// x86-nosse-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @u128_as_f128(
-// emscripten-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn u128_as_f128(a: u128) -> f128 {
-    // CHECK: uitofp i128 %{{.+}} to fp128
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @i8_as_f128(
-// x86-nosse-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @i8_as_f128(
-// emscripten-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn i8_as_f128(a: i8) -> f128 {
-    // CHECK: sitofp i8 %{{.+}} to fp128
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @i16_as_f128(
-// x86-nosse-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @i16_as_f128(
-// emscripten-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn i16_as_f128(a: i16) -> f128 {
-    // CHECK: sitofp i16 %{{.+}} to fp128
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @i32_as_f128(
-// x86-nosse-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @i32_as_f128(
-// emscripten-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn i32_as_f128(a: i32) -> f128 {
-    // CHECK: sitofp i32 %{{.+}} to fp128
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @i64_as_f128(
-// x86-nosse-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @i64_as_f128(
-// emscripten-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn i64_as_f128(a: i64) -> f128 {
-    // CHECK: sitofp i64 %{{.+}} to fp128
-    a as f128
-}
-
-// x86-sse-LABEL: <16 x i8> @i128_as_f128(
-// x86-nosse-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @i128_as_f128(
-// emscripten-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
-#[no_mangle]
-pub fn i128_as_f128(a: i128) -> f128 {
-    // CHECK: sitofp i128 %{{.+}} to fp128
-    a as f128
-}
diff --git a/tests/codegen/float/f16-f128-inline.rs b/tests/codegen/float/f16-f128-inline.rs
deleted file mode 100644
index aa2c38c209e..00000000000
--- a/tests/codegen/float/f16-f128-inline.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//@ revisions: default nopt
-//@[nopt] compile-flags: -Copt-level=0 -Zcross-crate-inline-threshold=never -Zmir-opt-level=0 -Cno-prepopulate-passes
-
-// Ensure that functions using `f16` and `f128` are always inlined to avoid crashes
-// when the backend does not support these types.
-
-#![crate_type = "lib"]
-#![feature(f128)]
-#![feature(f16)]
-
-pub fn f16_arg(_a: f16) {
-    // CHECK-NOT: f16_arg
-    todo!()
-}
-
-pub fn f16_ret() -> f16 {
-    // CHECK-NOT: f16_ret
-    todo!()
-}
-
-pub fn f128_arg(_a: f128) {
-    // CHECK-NOT: f128_arg
-    todo!()
-}
-
-pub fn f128_ret() -> f128 {
-    // CHECK-NOT: f128_ret
-    todo!()
-}
diff --git a/tests/codegen/float/f16.rs b/tests/codegen/float/f16.rs
deleted file mode 100644
index 0c40606ad8a..00000000000
--- a/tests/codegen/float/f16.rs
+++ /dev/null
@@ -1,364 +0,0 @@
-// 32-bit x86 returns float types differently to avoid the x87 stack.
-// 32-bit systems will return 128bit values using a return area pointer.
-//@ revisions: x86-sse x86-nosse bit32 bit64
-//@[x86-sse] only-x86
-//@[x86-sse] only-rustc_abi-x86-sse2
-//@[x86-nosse] only-x86
-//@[x86-nosse] ignore-rustc_abi-x86-sse2
-//@[bit32] ignore-x86
-//@[bit32] only-32bit
-//@[bit64] ignore-x86
-//@[bit64] only-64bit
-
-// Verify that our intrinsics generate the correct LLVM calls for f16
-
-#![crate_type = "lib"]
-#![feature(f128)]
-#![feature(f16)]
-#![feature(core_intrinsics)]
-
-/* arithmetic */
-
-// CHECK-LABEL: i1 @f16_eq(
-#[no_mangle]
-pub fn f16_eq(a: f16, b: f16) -> bool {
-    // CHECK: fcmp oeq half %{{.+}}, %{{.+}}
-    a == b
-}
-
-// CHECK-LABEL: i1 @f16_ne(
-#[no_mangle]
-pub fn f16_ne(a: f16, b: f16) -> bool {
-    // CHECK: fcmp une half %{{.+}}, %{{.+}}
-    a != b
-}
-
-// CHECK-LABEL: i1 @f16_gt(
-#[no_mangle]
-pub fn f16_gt(a: f16, b: f16) -> bool {
-    // CHECK: fcmp ogt half %{{.+}}, %{{.+}}
-    a > b
-}
-
-// CHECK-LABEL: i1 @f16_ge(
-#[no_mangle]
-pub fn f16_ge(a: f16, b: f16) -> bool {
-    // CHECK: fcmp oge half %{{.+}}, %{{.+}}
-    a >= b
-}
-
-// CHECK-LABEL: i1 @f16_lt(
-#[no_mangle]
-pub fn f16_lt(a: f16, b: f16) -> bool {
-    // CHECK: fcmp olt half %{{.+}}, %{{.+}}
-    a < b
-}
-
-// CHECK-LABEL: i1 @f16_le(
-#[no_mangle]
-pub fn f16_le(a: f16, b: f16) -> bool {
-    // CHECK: fcmp ole half %{{.+}}, %{{.+}}
-    a <= b
-}
-
-// This is where we check the argument and return ABI for f16.
-// bit32-LABEL: half @f16_neg(half
-// bit64-LABEL: half @f16_neg(half
-// x86-sse-LABEL: <2 x i8> @f16_neg(half
-// x86-nosse-LABEL: i16 @f16_neg(half
-#[no_mangle]
-pub fn f16_neg(a: f16) -> f16 {
-    // CHECK: fneg half %{{.+}}
-    -a
-}
-
-// CHECK-LABEL: @f16_add
-#[no_mangle]
-pub fn f16_add(a: f16, b: f16) -> f16 {
-    // CHECK: fadd half %{{.+}}, %{{.+}}
-    a + b
-}
-
-// CHECK-LABEL: @f16_sub
-#[no_mangle]
-pub fn f16_sub(a: f16, b: f16) -> f16 {
-    // CHECK: fsub half %{{.+}}, %{{.+}}
-    a - b
-}
-
-// CHECK-LABEL: @f16_mul
-#[no_mangle]
-pub fn f16_mul(a: f16, b: f16) -> f16 {
-    // CHECK: fmul half %{{.+}}, %{{.+}}
-    a * b
-}
-
-// CHECK-LABEL: @f16_div
-#[no_mangle]
-pub fn f16_div(a: f16, b: f16) -> f16 {
-    // CHECK: fdiv half %{{.+}}, %{{.+}}
-    a / b
-}
-
-// CHECK-LABEL: @f16_rem
-#[no_mangle]
-pub fn f16_rem(a: f16, b: f16) -> f16 {
-    // CHECK: frem half %{{.+}}, %{{.+}}
-    a % b
-}
-
-// CHECK-LABEL: void @f16_add_assign(
-#[no_mangle]
-pub fn f16_add_assign(a: &mut f16, b: f16) {
-    // CHECK: fadd half %{{.+}}, %{{.+}}
-    // CHECK-NEXT: store half %{{.+}}, ptr %{{.+}}
-    *a += b;
-}
-
-// CHECK-LABEL: void @f16_sub_assign(
-#[no_mangle]
-pub fn f16_sub_assign(a: &mut f16, b: f16) {
-    // CHECK: fsub half %{{.+}}, %{{.+}}
-    // CHECK-NEXT: store half %{{.+}}, ptr %{{.+}}
-    *a -= b;
-}
-
-// CHECK-LABEL: void @f16_mul_assign(
-#[no_mangle]
-pub fn f16_mul_assign(a: &mut f16, b: f16) {
-    // CHECK: fmul half %{{.+}}, %{{.+}}
-    // CHECK-NEXT: store half %{{.+}}, ptr %{{.+}}
-    *a *= b;
-}
-
-// CHECK-LABEL: void @f16_div_assign(
-#[no_mangle]
-pub fn f16_div_assign(a: &mut f16, b: f16) {
-    // CHECK: fdiv half %{{.+}}, %{{.+}}
-    // CHECK-NEXT: store half %{{.+}}, ptr %{{.+}}
-    *a /= b;
-}
-
-// CHECK-LABEL: void @f16_rem_assign(
-#[no_mangle]
-pub fn f16_rem_assign(a: &mut f16, b: f16) {
-    // CHECK: frem half %{{.+}}, %{{.+}}
-    // CHECK-NEXT: store half %{{.+}}, ptr %{{.+}}
-    *a %= b;
-}
-
-/* float to float conversions */
-
-// bit32-LABEL: half @f16_as_self(
-// bit64-LABEL: half @f16_as_self(
-// x86-sse-LABEL: <2 x i8> @f16_as_self(
-// x86-nosse-LABEL: i16 @f16_as_self(
-#[no_mangle]
-pub fn f16_as_self(a: f16) -> f16 {
-    // bit32-CHECK: ret half %{{.+}}
-    // bit64-CHECK: ret half %{{.+}}
-    // x86-sse-CHECK: bitcast half
-    // x86-nosse-CHECK: bitcast half
-    // x86-sse-CHECK: ret i16
-    // x86-nosse-CHECK: ret i16
-    a as f16
-}
-
-// x86-sse-LABEL: <4 x i8> @f16_as_f32(
-// x86-nosse-LABEL: i32 @f16_as_f32(
-// bit32-LABEL: float @f16_as_f32(
-// bit64-LABEL: float @f16_as_f32(
-#[no_mangle]
-pub fn f16_as_f32(a: f16) -> f32 {
-    // CHECK: fpext half %{{.+}} to float
-    a as f32
-}
-
-// x86-sse-LABEL: <8 x i8> @f16_as_f64(
-// x86-nosse-LABEL: void @f16_as_f64({{.*}}sret([8 x i8])
-// bit32-LABEL: double @f16_as_f64(
-// bit64-LABEL: double @f16_as_f64(
-#[no_mangle]
-pub fn f16_as_f64(a: f16) -> f64 {
-    // CHECK: fpext half %{{.+}} to double
-    a as f64
-}
-
-// x86-sse-LABEL: <16 x i8> @f16_as_f128(
-// x86-nosse-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
-// bit64-LABEL: fp128 @f16_as_f128(
-#[no_mangle]
-pub fn f16_as_f128(a: f16) -> f128 {
-    // CHECK: fpext half %{{.+}} to fp128
-    a as f128
-}
-
-// CHECK-LABEL: @f32_as_f16
-#[no_mangle]
-pub fn f32_as_f16(a: f32) -> f16 {
-    // CHECK: fptrunc float %{{.+}} to half
-    a as f16
-}
-
-// CHECK-LABEL: @f64_as_f16
-#[no_mangle]
-pub fn f64_as_f16(a: f64) -> f16 {
-    // CHECK: fptrunc double %{{.+}} to half
-    a as f16
-}
-
-// CHECK-LABEL: @f128_as_f16
-#[no_mangle]
-pub fn f128_as_f16(a: f128) -> f16 {
-    // CHECK: fptrunc fp128 %{{.+}} to half
-    a as f16
-}
-
-/* float to int conversions */
-
-// CHECK-LABEL: i8 @f16_as_u8(
-#[no_mangle]
-pub fn f16_as_u8(a: f16) -> u8 {
-    // CHECK: call i8 @llvm.fptoui.sat.i8.f16(half %{{.+}})
-    a as u8
-}
-
-#[no_mangle]
-pub fn f16_as_u16(a: f16) -> u16 {
-    // CHECK: call i16 @llvm.fptoui.sat.i16.f16(half %{{.+}})
-    a as u16
-}
-
-// CHECK-LABEL: i32 @f16_as_u32(
-#[no_mangle]
-pub fn f16_as_u32(a: f16) -> u32 {
-    // CHECK: call i32 @llvm.fptoui.sat.i32.f16(half %{{.+}})
-    a as u32
-}
-
-// CHECK-LABEL: i64 @f16_as_u64(
-#[no_mangle]
-pub fn f16_as_u64(a: f16) -> u64 {
-    // CHECK: call i64 @llvm.fptoui.sat.i64.f16(half %{{.+}})
-    a as u64
-}
-
-// x86-sse-LABEL: void @f16_as_u128({{.*}}sret([16 x i8])
-// x86-nosse-LABEL: void @f16_as_u128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @f16_as_u128({{.*}}sret([16 x i8])
-// bit64-LABEL: i128 @f16_as_u128(
-#[no_mangle]
-pub fn f16_as_u128(a: f16) -> u128 {
-    // CHECK: call i128 @llvm.fptoui.sat.i128.f16(half %{{.+}})
-    a as u128
-}
-
-// CHECK-LABEL: i8 @f16_as_i8(
-#[no_mangle]
-pub fn f16_as_i8(a: f16) -> i8 {
-    // CHECK: call i8 @llvm.fptosi.sat.i8.f16(half %{{.+}})
-    a as i8
-}
-
-// CHECK-LABEL: i16 @f16_as_i16(
-#[no_mangle]
-pub fn f16_as_i16(a: f16) -> i16 {
-    // CHECK: call i16 @llvm.fptosi.sat.i16.f16(half %{{.+}})
-    a as i16
-}
-// CHECK-LABEL: i32 @f16_as_i32(
-#[no_mangle]
-pub fn f16_as_i32(a: f16) -> i32 {
-    // CHECK: call i32 @llvm.fptosi.sat.i32.f16(half %{{.+}})
-    a as i32
-}
-
-// CHECK-LABEL: i64 @f16_as_i64(
-#[no_mangle]
-pub fn f16_as_i64(a: f16) -> i64 {
-    // CHECK: call i64 @llvm.fptosi.sat.i64.f16(half %{{.+}})
-    a as i64
-}
-
-// x86-sse-LABEL: void @f16_as_i128({{.*}}sret([16 x i8])
-// x86-nosse-LABEL: void @f16_as_i128({{.*}}sret([16 x i8])
-// bit32-LABEL: void @f16_as_i128({{.*}}sret([16 x i8])
-// bit64-LABEL: i128 @f16_as_i128(
-#[no_mangle]
-pub fn f16_as_i128(a: f16) -> i128 {
-    // CHECK: call i128 @llvm.fptosi.sat.i128.f16(half %{{.+}})
-    a as i128
-}
-
-/* int to float conversions */
-
-// CHECK-LABEL: @u8_as_f16
-#[no_mangle]
-pub fn u8_as_f16(a: u8) -> f16 {
-    // CHECK: uitofp i8 %{{.+}} to half
-    a as f16
-}
-
-// CHECK-LABEL: @u16_as_f16
-#[no_mangle]
-pub fn u16_as_f16(a: u16) -> f16 {
-    // CHECK: uitofp i16 %{{.+}} to half
-    a as f16
-}
-
-// CHECK-LABEL: @u32_as_f16
-#[no_mangle]
-pub fn u32_as_f16(a: u32) -> f16 {
-    // CHECK: uitofp i32 %{{.+}} to half
-    a as f16
-}
-
-// CHECK-LABEL: @u64_as_f16
-#[no_mangle]
-pub fn u64_as_f16(a: u64) -> f16 {
-    // CHECK: uitofp i64 %{{.+}} to half
-    a as f16
-}
-
-// CHECK-LABEL: @u128_as_f16
-#[no_mangle]
-pub fn u128_as_f16(a: u128) -> f16 {
-    // CHECK: uitofp i128 %{{.+}} to half
-    a as f16
-}
-
-// CHECK-LABEL: @i8_as_f16
-#[no_mangle]
-pub fn i8_as_f16(a: i8) -> f16 {
-    // CHECK: sitofp i8 %{{.+}} to half
-    a as f16
-}
-
-// CHECK-LABEL: @i16_as_f16
-#[no_mangle]
-pub fn i16_as_f16(a: i16) -> f16 {
-    // CHECK: sitofp i16 %{{.+}} to half
-    a as f16
-}
-
-// CHECK-LABEL: @i32_as_f16
-#[no_mangle]
-pub fn i32_as_f16(a: i32) -> f16 {
-    // CHECK: sitofp i32 %{{.+}} to half
-    a as f16
-}
-
-// CHECK-LABEL: @i64_as_f16
-#[no_mangle]
-pub fn i64_as_f16(a: i64) -> f16 {
-    // CHECK: sitofp i64 %{{.+}} to half
-    a as f16
-}
-
-// CHECK-LABEL: @i128_as_f16
-#[no_mangle]
-pub fn i128_as_f16(a: i128) -> f16 {
-    // CHECK: sitofp i128 %{{.+}} to half
-    a as f16
-}
diff --git a/tests/codegen/float_math.rs b/tests/codegen/float_math.rs
deleted file mode 100644
index 9a1e0b4d2d0..00000000000
--- a/tests/codegen/float_math.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::{
-    fadd_algebraic, fadd_fast, fdiv_algebraic, fdiv_fast, fmul_algebraic, fmul_fast,
-    frem_algebraic, frem_fast, fsub_algebraic, fsub_fast,
-};
-
-// CHECK-LABEL: @add
-#[no_mangle]
-pub fn add(x: f32, y: f32) -> f32 {
-    // CHECK: fadd float
-    // CHECK-NOT: fast
-    x + y
-}
-
-// CHECK-LABEL: @test_fadd_algebraic
-#[no_mangle]
-pub fn test_fadd_algebraic(x: f32, y: f32) -> f32 {
-    // CHECK: fadd reassoc nsz arcp contract float %x, %y
-    fadd_algebraic(x, y)
-}
-
-// CHECK-LABEL: @test_fsub_algebraic
-#[no_mangle]
-pub fn test_fsub_algebraic(x: f32, y: f32) -> f32 {
-    // CHECK: fsub reassoc nsz arcp contract float %x, %y
-    fsub_algebraic(x, y)
-}
-
-// CHECK-LABEL: @test_fmul_algebraic
-#[no_mangle]
-pub fn test_fmul_algebraic(x: f32, y: f32) -> f32 {
-    // CHECK: fmul reassoc nsz arcp contract float %x, %y
-    fmul_algebraic(x, y)
-}
-
-// CHECK-LABEL: @test_fdiv_algebraic
-#[no_mangle]
-pub fn test_fdiv_algebraic(x: f32, y: f32) -> f32 {
-    // CHECK: fdiv reassoc nsz arcp contract float %x, %y
-    fdiv_algebraic(x, y)
-}
-
-// CHECK-LABEL: @test_frem_algebraic
-#[no_mangle]
-pub fn test_frem_algebraic(x: f32, y: f32) -> f32 {
-    // CHECK: frem reassoc nsz arcp contract float %x, %y
-    frem_algebraic(x, y)
-}
-
-// CHECK-LABEL: @test_fadd_fast
-#[no_mangle]
-pub fn test_fadd_fast(x: f32, y: f32) -> f32 {
-    // CHECK: fadd fast float %x, %y
-    unsafe { fadd_fast(x, y) }
-}
-
-// CHECK-LABEL: @test_fsub_fast
-#[no_mangle]
-pub fn test_fsub_fast(x: f32, y: f32) -> f32 {
-    // CHECK: fsub fast float %x, %y
-    unsafe { fsub_fast(x, y) }
-}
-
-// CHECK-LABEL: @test_fmul_fast
-#[no_mangle]
-pub fn test_fmul_fast(x: f32, y: f32) -> f32 {
-    // CHECK: fmul fast float %x, %y
-    unsafe { fmul_fast(x, y) }
-}
-
-// CHECK-LABEL: @test_fdiv_fast
-#[no_mangle]
-pub fn test_fdiv_fast(x: f32, y: f32) -> f32 {
-    // CHECK: fdiv fast float %x, %y
-    unsafe { fdiv_fast(x, y) }
-}
-
-// CHECK-LABEL: @test_frem_fast
-#[no_mangle]
-pub fn test_frem_fast(x: f32, y: f32) -> f32 {
-    // CHECK: frem fast float %x, %y
-    unsafe { frem_fast(x, y) }
-}
diff --git a/tests/codegen/fn-impl-trait-self.rs b/tests/codegen/fn-impl-trait-self.rs
deleted file mode 100644
index 5799d23b5a0..00000000000
--- a/tests/codegen/fn-impl-trait-self.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -g
-//@ ignore-wasi wasi codegens the main symbol differently
-//
-// CHECK-LABEL: @main
-// MSVC: {{.*}}DIDerivedType(tag: DW_TAG_pointer_type, name: "recursive_type$ (*)()",{{.*}}
-// NONMSVC: {{.*}}DIDerivedType(tag: DW_TAG_pointer_type, name: "fn() -> <recursive_type>",{{.*}}
-//
-// CHECK: {{.*}}DISubroutineType{{.*}}
-// CHECK: {{.*}}DIBasicType(name: "<recur_type>", size: {{32|64}}, encoding: DW_ATE_unsigned)
-
-pub fn foo() -> impl Copy {
-    foo
-}
-
-fn main() {
-    let my_res = foo();
-}
diff --git a/tests/codegen/fn-parameters-on-different-lines-debuginfo.rs b/tests/codegen/fn-parameters-on-different-lines-debuginfo.rs
deleted file mode 100644
index 2097567f322..00000000000
--- a/tests/codegen/fn-parameters-on-different-lines-debuginfo.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//! Make sure that line debuginfo of function parameters are correct even if
-//! they are not on the same line. Regression test for
-// <https://github.com/rust-lang/rust/issues/45010>.
-
-//@ compile-flags: -g -Copt-level=0
-
-#[rustfmt::skip] // Having parameters on different lines is crucial for this test.
-pub fn foo(
-    x_parameter_not_in_std: i32,
-    y_parameter_not_in_std: i32,
-) -> i32 {
-    x_parameter_not_in_std + y_parameter_not_in_std
-}
-
-fn main() {
-    foo(42, 43); // Ensure `wasm32-wasip1` keeps `foo()` (even if `-Copt-level=0`)
-}
-
-// CHECK: !DILocalVariable(name: "x_parameter_not_in_std", arg: 1,
-// CHECK-SAME: line: 9
-// CHECK: !DILocalVariable(name: "y_parameter_not_in_std", arg: 2,
-// CHECK-SAME: line: 10
diff --git a/tests/codegen/force-frame-pointers.rs b/tests/codegen/force-frame-pointers.rs
deleted file mode 100644
index 88c918945d6..00000000000
--- a/tests/codegen/force-frame-pointers.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ revisions: Always NonLeaf
-//@ [Always] compile-flags: -Cforce-frame-pointers=yes
-//@ [NonLeaf] compile-flags: -Cforce-frame-pointers=non-leaf
-//@ compile-flags: -Zunstable-options
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-//@ [NonLeaf] ignore-illumos
-//@ [NonLeaf] ignore-openbsd
-//@ [NonLeaf] ignore-x86
-//@ [NonLeaf] ignore-x86_64-apple-darwin
-//@ [NonLeaf] ignore-windows-gnu
-//@ [NonLeaf] ignore-thumb
-// result is platform-dependent based on platform's frame pointer settings
-
-#![crate_type = "lib"]
-
-// Always: attributes #{{.*}} "frame-pointer"="all"
-// NonLeaf: attributes #{{.*}} "frame-pointer"="non-leaf"
-pub fn foo() {}
diff --git a/tests/codegen/force-no-unwind-tables.rs b/tests/codegen/force-no-unwind-tables.rs
deleted file mode 100644
index 1de5e0858e0..00000000000
--- a/tests/codegen/force-no-unwind-tables.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -C panic=abort -C force-unwind-tables=n
-//@ ignore-windows: unwind tables are required for panics on Windows
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: define{{.*}}void @foo
-// CHECK-NOT: attributes #{{.*}} uwtable
-#[no_mangle]
-fn foo() {
-    panic!();
-}
diff --git a/tests/codegen/force-unwind-tables.rs b/tests/codegen/force-unwind-tables.rs
deleted file mode 100644
index a2ef8a10454..00000000000
--- a/tests/codegen/force-unwind-tables.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -C force-unwind-tables=y -Copt-level=0
-
-#![crate_type = "lib"]
-
-// CHECK: attributes #{{.*}} uwtable
-pub fn foo() {}
diff --git a/tests/codegen/frame-pointer-cli-control.rs b/tests/codegen/frame-pointer-cli-control.rs
deleted file mode 100644
index a65dd132763..00000000000
--- a/tests/codegen/frame-pointer-cli-control.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: --crate-type=rlib -Copt-level=0
-//@ revisions: force-on aarch64-apple aarch64-apple-on aarch64-apple-off
-//@ [force-on] compile-flags: -Cforce-frame-pointers=on
-//@ [aarch64-apple] needs-llvm-components: aarch64
-//@ [aarch64-apple] compile-flags: --target=aarch64-apple-darwin
-//@ [aarch64-apple-on] needs-llvm-components: aarch64
-//@ [aarch64-apple-on] compile-flags: --target=aarch64-apple-darwin -Cforce-frame-pointers=on
-//@ [aarch64-apple-off] needs-llvm-components: aarch64
-//@ [aarch64-apple-off] compile-flags: --target=aarch64-apple-darwin -Cforce-frame-pointers=off
-/*!
-
-Tests the extent to which frame pointers can be controlled by the CLI.
-The behavior of our frame pointer options, at present, is an irreversible ratchet, where
-a "weaker" option that allows omitting frame pointers may be overridden by the target demanding
-that all code (or all non-leaf code, more often) must be compiled with frame pointers.
-This was discussed on 2025-05-22 in the T-compiler meeting and accepted as an intentional change,
-ratifying the prior decisions by compiler contributors and reviewers as correct,
-though it was also acknowledged that the flag allows somewhat confusing inputs.
-
-We find aarch64-apple-darwin useful because of its icy-clear policy regarding frame pointers,
-e.g. <https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms> says:
-
-* The frame pointer register (x29) must always address a valid frame record. Some functions —
-  such as leaf functions or tail calls — may opt not to create an entry in this list.
-  As a result, stack traces are always meaningful, even without debug information.
-
-Many Rust fn, if externally visible, may be expected to follow target ABI by tools or asm code!
-This can make it a problem to generate ABI-incorrect code, which may mean "with frame pointers".
-For this and other reasons, `-Cforce-frame-pointers=off` cannot override the target definition.
-This can cause some confusion because it is "reverse polarity" relative to C compilers, which have
-commands like `-fomit-frame-pointer`, `-fomit-leaf-frame-pointer`, or `-fno-omit-frame-pointer`!
-
-Specific cases where platforms or tools rely on frame pointers for sound or correct unwinding:
-- illumos: <https://smartos.org/bugview/OS-7515>
-- aarch64-windows: <https://github.com/rust-lang/rust/issues/123686>
-- aarch64-linux: <https://github.com/rust-lang/rust/issues/123733>
-- dtrace (freebsd and openbsd): <https://github.com/rust-lang/rust/issues/97723>
-- openbsd: <https://github.com/rust-lang/rust/issues/43575>
-- i686-msvc <https://github.com/rust-lang/backtrace-rs/pull/584#issuecomment-1966177530>
-- i686-mingw: <https://github.com/rust-lang/rust/commit/3f1d3948d6d434b34dd47f132c126a6cb6b8a4ab>
-*/
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-
-// CHECK: i32 @peach{{.*}}[[PEACH_ATTRS:\#[0-9]+]] {
-#[no_mangle]
-pub fn peach(x: u32) -> u32 {
-    x
-}
-
-// CHECK: attributes [[PEACH_ATTRS]] = {
-// force-on-SAME: {{.*}}"frame-pointer"="all"
-// aarch64-apple-SAME: {{.*}}"frame-pointer"="non-leaf"
-// aarch64-apple-on-SAME: {{.*}}"frame-pointer"="all"
-//
-// yes, we are testing this doesn't do anything:
-// aarch64-apple-off-SAME: {{.*}}"frame-pointer"="non-leaf"
-// CHECK-SAME: }
diff --git a/tests/codegen/frame-pointer.rs b/tests/codegen/frame-pointer.rs
deleted file mode 100644
index 23989653fa8..00000000000
--- a/tests/codegen/frame-pointer.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: --crate-type=rlib -Copt-level=0
-//@ revisions: aarch64-apple aarch64-linux force x64-apple x64-linux
-//@ [aarch64-apple] needs-llvm-components: aarch64
-//@ [aarch64-apple] compile-flags: --target=aarch64-apple-darwin
-//@ [aarch64-linux] needs-llvm-components: aarch64
-//@ [aarch64-linux] compile-flags: --target=aarch64-unknown-linux-gnu
-//@ [force] needs-llvm-components: x86
-//@ [force] compile-flags: --target=x86_64-unknown-linux-gnu -Cforce-frame-pointers=yes
-//@ [x64-apple] needs-llvm-components: x86
-//@ [x64-apple] compile-flags: --target=x86_64-apple-darwin
-//@ [x64-linux] needs-llvm-components: x86
-//@ [x64-linux] compile-flags: --target=x86_64-unknown-linux-gnu
-
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: define i32 @peach{{.*}}[[PEACH_ATTRS:\#[0-9]+]] {
-#[no_mangle]
-pub fn peach(x: u32) -> u32 {
-    x
-}
-
-// CHECK: attributes [[PEACH_ATTRS]] = {
-// x64-linux-NOT: {{.*}}"frame-pointer"{{.*}}
-// x64-apple-SAME: {{.*}}"frame-pointer"="all"
-// force-SAME: {{.*}}"frame-pointer"="all"
-//
-// AAPCS64 demands frame pointers:
-// aarch64-linux-SAME: {{.*}}"frame-pointer"="non-leaf"
-// aarch64-apple-SAME: {{.*}}"frame-pointer"="non-leaf"
-// CHECK-SAME: }
diff --git a/tests/codegen/function-arguments-noopt.rs b/tests/codegen/function-arguments-noopt.rs
deleted file mode 100644
index c80f119696d..00000000000
--- a/tests/codegen/function-arguments-noopt.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-//@ compile-flags: -C opt-level=0 -C no-prepopulate-passes
-
-// This test checks that arguments/returns in opt-level=0 builds,
-// while lacking attributes used for optimization, still have ABI-affecting attributes.
-
-#![crate_type = "lib"]
-#![feature(rustc_attrs)]
-
-pub struct S {
-    _field: [i32; 8],
-}
-
-// CHECK: zeroext i1 @boolean(i1 zeroext %x)
-#[no_mangle]
-pub fn boolean(x: bool) -> bool {
-    x
-}
-
-// CHECK-LABEL: @boolean_call
-#[no_mangle]
-pub fn boolean_call(x: bool, f: fn(bool) -> bool) -> bool {
-    // CHECK: call zeroext i1 %f(i1 zeroext %x)
-    f(x)
-}
-
-// CHECK: align 4 ptr @borrow(ptr align 4 %x)
-#[no_mangle]
-pub fn borrow(x: &i32) -> &i32 {
-    x
-}
-
-// CHECK: align 4 ptr @borrow_mut(ptr align 4 %x)
-#[no_mangle]
-pub fn borrow_mut(x: &mut i32) -> &mut i32 {
-    x
-}
-
-// CHECK-LABEL: @borrow_call
-#[no_mangle]
-pub fn borrow_call(x: &i32, f: fn(&i32) -> &i32) -> &i32 {
-    // CHECK: call align 4 ptr %f(ptr align 4 %x)
-    f(x)
-}
-
-// CHECK: void @struct_(ptr sret([32 x i8]) align 4{{( %_0)?}}, ptr align 4 %x)
-#[no_mangle]
-pub fn struct_(x: S) -> S {
-    x
-}
-
-// CHECK-LABEL: @struct_call
-#[no_mangle]
-pub fn struct_call(x: S, f: fn(S) -> S) -> S {
-    // CHECK: call void %f(ptr sret([32 x i8]) align 4{{( %_0)?}}, ptr align 4 %{{.+}})
-    f(x)
-}
-
-// CHECK: { i1, i8 } @enum_(i1 zeroext %x.0, i8 %x.1)
-#[no_mangle]
-pub fn enum_(x: Option<u8>) -> Option<u8> {
-    x
-}
-
-// CHECK-LABEL: @enum_call
-#[no_mangle]
-pub fn enum_call(x: Option<u8>, f: fn(Option<u8>) -> Option<u8>) -> Option<u8> {
-    // CHECK: call { i1, i8 } %f(i1 zeroext %x.0, i8 %x.1)
-    f(x)
-}
diff --git a/tests/codegen/function-arguments.rs b/tests/codegen/function-arguments.rs
deleted file mode 100644
index c8cd8526ae5..00000000000
--- a/tests/codegen/function-arguments.rs
+++ /dev/null
@@ -1,278 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-#![crate_type = "lib"]
-#![feature(rustc_attrs)]
-#![feature(allocator_api)]
-
-use std::marker::PhantomPinned;
-use std::mem::MaybeUninit;
-use std::num::NonZero;
-use std::ptr::NonNull;
-
-pub struct S {
-    _field: [i32; 8],
-}
-
-pub struct UnsafeInner {
-    _field: std::cell::UnsafeCell<i16>,
-}
-
-pub struct NotUnpin {
-    _field: i32,
-    _marker: PhantomPinned,
-}
-
-pub enum MyBool {
-    True,
-    False,
-}
-
-// CHECK: noundef zeroext i1 @boolean(i1 noundef zeroext %x)
-#[no_mangle]
-pub fn boolean(x: bool) -> bool {
-    x
-}
-
-// CHECK: i8 @maybeuninit_boolean(i8{{.*}} %x)
-#[no_mangle]
-pub fn maybeuninit_boolean(x: MaybeUninit<bool>) -> MaybeUninit<bool> {
-    x
-}
-
-// CHECK: noundef zeroext i1 @enum_bool(i1 noundef zeroext %x)
-#[no_mangle]
-pub fn enum_bool(x: MyBool) -> MyBool {
-    x
-}
-
-// CHECK: i8 @maybeuninit_enum_bool(i8{{.*}} %x)
-#[no_mangle]
-pub fn maybeuninit_enum_bool(x: MaybeUninit<MyBool>) -> MaybeUninit<MyBool> {
-    x
-}
-
-// CHECK: noundef{{( range\(i32 0, 1114112\))?}} i32 @char(i32{{.*}}{{( range\(i32 0, 1114112\))?}} %x)
-#[no_mangle]
-pub fn char(x: char) -> char {
-    x
-}
-
-// CHECK: i32 @maybeuninit_char(i32{{.*}} %x)
-#[no_mangle]
-pub fn maybeuninit_char(x: MaybeUninit<char>) -> MaybeUninit<char> {
-    x
-}
-
-// CHECK: noundef i64 @int(i64 noundef %x)
-#[no_mangle]
-pub fn int(x: u64) -> u64 {
-    x
-}
-
-// CHECK: noundef{{( range\(i64 1, 0\))?}} i64 @nonzero_int(i64 noundef{{( range\(i64 1, 0\))?}} %x)
-#[no_mangle]
-pub fn nonzero_int(x: NonZero<u64>) -> NonZero<u64> {
-    x
-}
-
-// CHECK: noundef i64 @option_nonzero_int(i64 noundef %x)
-#[no_mangle]
-pub fn option_nonzero_int(x: Option<NonZero<u64>>) -> Option<NonZero<u64>> {
-    x
-}
-
-// CHECK: @readonly_borrow(ptr noalias noundef readonly align 4 dereferenceable(4) %_1)
-// FIXME #25759 This should also have `nocapture`
-#[no_mangle]
-pub fn readonly_borrow(_: &i32) {}
-
-// CHECK: noundef align 4 dereferenceable(4) ptr @readonly_borrow_ret()
-#[no_mangle]
-pub fn readonly_borrow_ret() -> &'static i32 {
-    loop {}
-}
-
-// CHECK: @static_borrow(ptr noalias noundef readonly align 4 dereferenceable(4) %_1)
-// static borrow may be captured
-#[no_mangle]
-pub fn static_borrow(_: &'static i32) {}
-
-// CHECK: @named_borrow(ptr noalias noundef readonly align 4 dereferenceable(4) %_1)
-// borrow with named lifetime may be captured
-#[no_mangle]
-pub fn named_borrow<'r>(_: &'r i32) {}
-
-// CHECK: @unsafe_borrow(ptr noundef nonnull align 2 %_1)
-// unsafe interior means this isn't actually readonly and there may be aliases ...
-#[no_mangle]
-pub fn unsafe_borrow(_: &UnsafeInner) {}
-
-// CHECK: @mutable_unsafe_borrow(ptr noalias noundef align 2 dereferenceable(2) %_1)
-// ... unless this is a mutable borrow, those never alias
-#[no_mangle]
-pub fn mutable_unsafe_borrow(_: &mut UnsafeInner) {}
-
-// CHECK: @mutable_borrow(ptr noalias noundef align 4 dereferenceable(4) %_1)
-// FIXME #25759 This should also have `nocapture`
-#[no_mangle]
-pub fn mutable_borrow(_: &mut i32) {}
-
-// CHECK: noundef align 4 dereferenceable(4) ptr @mutable_borrow_ret()
-#[no_mangle]
-pub fn mutable_borrow_ret() -> &'static mut i32 {
-    loop {}
-}
-
-#[no_mangle]
-// CHECK: @mutable_notunpin_borrow(ptr noundef nonnull align 4 %_1)
-// This one is *not* `noalias` because it might be self-referential.
-// It is also not `dereferenceable` due to
-// <https://github.com/rust-lang/unsafe-code-guidelines/issues/381>.
-pub fn mutable_notunpin_borrow(_: &mut NotUnpin) {}
-
-// CHECK: @notunpin_borrow(ptr noalias noundef readonly align 4 dereferenceable(4) %_1)
-// But `&NotUnpin` behaves perfectly normal.
-#[no_mangle]
-pub fn notunpin_borrow(_: &NotUnpin) {}
-
-// CHECK: @indirect_struct(ptr noalias{{( nocapture)?}} noundef readonly align 4{{( captures\(none\))?}} dereferenceable(32) %_1)
-#[no_mangle]
-pub fn indirect_struct(_: S) {}
-
-// CHECK: @borrowed_struct(ptr noalias noundef readonly align 4 dereferenceable(32) %_1)
-// FIXME #25759 This should also have `nocapture`
-#[no_mangle]
-pub fn borrowed_struct(_: &S) {}
-
-// CHECK: @option_borrow(ptr noalias noundef readonly align 4 dereferenceable_or_null(4) %_x)
-#[no_mangle]
-pub fn option_borrow(_x: Option<&i32>) {}
-
-// CHECK: @option_borrow_mut(ptr noalias noundef align 4 dereferenceable_or_null(4) %_x)
-#[no_mangle]
-pub fn option_borrow_mut(_x: Option<&mut i32>) {}
-
-// Function that must NOT have `dereferenceable` or `align`.
-#[rustc_layout_scalar_valid_range_start(16)]
-pub struct RestrictedAddress(&'static i16);
-enum E {
-    A(RestrictedAddress),
-    B,
-    C,
-}
-// If the `nonnull` ever goes missing, you might have to tweak the
-// scalar_valid_range on `RestrictedAddress` to get it back. You
-// might even have to add a `rustc_layout_scalar_valid_range_end`.
-// CHECK: @nonnull_and_nondereferenceable(ptr noundef nonnull %_x)
-#[no_mangle]
-pub fn nonnull_and_nondereferenceable(_x: E) {}
-
-// CHECK: @raw_struct(ptr noundef %_1)
-#[no_mangle]
-pub fn raw_struct(_: *const S) {}
-
-// CHECK: @raw_option_nonnull_struct(ptr noundef %_1)
-#[no_mangle]
-pub fn raw_option_nonnull_struct(_: Option<NonNull<S>>) {}
-
-// `Box` can get deallocated during execution of the function, so it should
-// not get `dereferenceable`.
-// CHECK: noundef nonnull align 4 ptr @_box(ptr noalias noundef nonnull align 4 %x)
-#[no_mangle]
-pub fn _box(x: Box<i32>) -> Box<i32> {
-    x
-}
-
-// With a custom allocator, it should *not* have `noalias`. (See
-// <https://github.com/rust-lang/miri/issues/3341> for why.) The second argument is the allocator,
-// which is a reference here that still carries `noalias` as usual.
-// CHECK: @_box_custom(ptr noundef nonnull align 4 %x.0, ptr noalias noundef nonnull readonly align 1 %x.1)
-#[no_mangle]
-pub fn _box_custom(x: Box<i32, &std::alloc::Global>) {
-    drop(x)
-}
-
-// CHECK: noundef nonnull align 4 ptr @notunpin_box(ptr noundef nonnull align 4 %x)
-#[no_mangle]
-pub fn notunpin_box(x: Box<NotUnpin>) -> Box<NotUnpin> {
-    x
-}
-
-// CHECK: @struct_return(ptr{{( dead_on_unwind)?}} noalias{{( nocapture)?}} noundef{{( writable)?}} sret([32 x i8]) align 4{{( captures\(none\))?}} dereferenceable(32){{( %_0)?}})
-#[no_mangle]
-pub fn struct_return() -> S {
-    S { _field: [0, 0, 0, 0, 0, 0, 0, 0] }
-}
-
-// Hack to get the correct size for the length part in slices
-// CHECK: @helper([[USIZE:i[0-9]+]] noundef %_1)
-#[no_mangle]
-pub fn helper(_: usize) {}
-
-// CHECK: @slice(ptr noalias noundef nonnull readonly align 1 %_1.0, [[USIZE]] noundef %_1.1)
-// FIXME #25759 This should also have `nocapture`
-#[no_mangle]
-pub fn slice(_: &[u8]) {}
-
-// CHECK: @mutable_slice(ptr noalias noundef nonnull align 1 %_1.0, [[USIZE]] noundef %_1.1)
-// FIXME #25759 This should also have `nocapture`
-#[no_mangle]
-pub fn mutable_slice(_: &mut [u8]) {}
-
-// CHECK: @unsafe_slice(ptr noundef nonnull align 2 %_1.0, [[USIZE]] noundef %_1.1)
-// unsafe interior means this isn't actually readonly and there may be aliases ...
-#[no_mangle]
-pub fn unsafe_slice(_: &[UnsafeInner]) {}
-
-// CHECK: @raw_slice(ptr noundef %_1.0, [[USIZE]] noundef %_1.1)
-#[no_mangle]
-pub fn raw_slice(_: *const [u8]) {}
-
-// CHECK: @str(ptr noalias noundef nonnull readonly align 1 %_1.0, [[USIZE]] noundef %_1.1)
-// FIXME #25759 This should also have `nocapture`
-#[no_mangle]
-pub fn str(_: &[u8]) {}
-
-// CHECK: @trait_borrow(ptr noundef nonnull align 1 %_1.0, {{.+}} noalias noundef readonly align {{.*}} dereferenceable({{.*}}) %_1.1)
-// FIXME #25759 This should also have `nocapture`
-#[no_mangle]
-pub fn trait_borrow(_: &dyn Drop) {}
-
-// CHECK: @option_trait_borrow(ptr noundef align 1 %x.0, ptr %x.1)
-#[no_mangle]
-pub fn option_trait_borrow(x: Option<&dyn Drop>) {}
-
-// CHECK: @option_trait_borrow_mut(ptr noundef align 1 %x.0, ptr %x.1)
-#[no_mangle]
-pub fn option_trait_borrow_mut(x: Option<&mut dyn Drop>) {}
-
-// CHECK: @trait_raw(ptr noundef %_1.0, {{.+}} noalias noundef readonly align {{.*}} dereferenceable({{.*}}) %_1.1)
-#[no_mangle]
-pub fn trait_raw(_: *const dyn Drop) {}
-
-// CHECK: @trait_box(ptr noalias noundef nonnull align 1{{( %0)?}}, {{.+}} noalias noundef readonly align {{.*}} dereferenceable({{.*}}){{( %1)?}})
-#[no_mangle]
-pub fn trait_box(_: Box<dyn Drop + Unpin>) {}
-
-// CHECK: { ptr, ptr } @trait_option(ptr noalias noundef align 1 %x.0, ptr %x.1)
-#[no_mangle]
-pub fn trait_option(x: Option<Box<dyn Drop + Unpin>>) -> Option<Box<dyn Drop + Unpin>> {
-    x
-}
-
-// CHECK: { ptr, [[USIZE]] } @return_slice(ptr noalias noundef nonnull readonly align 2 %x.0, [[USIZE]] noundef %x.1)
-#[no_mangle]
-pub fn return_slice(x: &[u16]) -> &[u16] {
-    x
-}
-
-// CHECK: { i16, i16 } @enum_id_1(i16 noundef{{( range\(i16 0, 3\))?}} %x.0, i16 %x.1)
-#[no_mangle]
-pub fn enum_id_1(x: Option<Result<u16, u16>>) -> Option<Result<u16, u16>> {
-    x
-}
-
-// CHECK: { i1, i8 } @enum_id_2(i1 noundef zeroext %x.0, i8 %x.1)
-#[no_mangle]
-pub fn enum_id_2(x: Option<u8>) -> Option<u8> {
-    x
-}
diff --git a/tests/codegen/function-return.rs b/tests/codegen/function-return.rs
deleted file mode 100644
index 4127f516038..00000000000
--- a/tests/codegen/function-return.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Test that the `fn_ret_thunk_extern` function attribute is (not) emitted when
-// the `-Zfunction-return={keep,thunk-extern}` flag is (not) set.
-
-//@ add-core-stubs
-//@ revisions: unset keep thunk-extern keep-thunk-extern thunk-extern-keep
-//@ needs-llvm-components: x86
-//@ compile-flags: --target x86_64-unknown-linux-gnu
-//@ [keep] compile-flags: -Zfunction-return=keep
-//@ [thunk-extern] compile-flags: -Zfunction-return=thunk-extern
-//@ [keep-thunk-extern] compile-flags: -Zfunction-return=keep -Zfunction-return=thunk-extern
-//@ [thunk-extern-keep] compile-flags: -Zfunction-return=thunk-extern -Zfunction-return=keep
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[no_mangle]
-pub fn foo() {
-    // CHECK: @foo() unnamed_addr #0
-
-    // unset-NOT: fn_ret_thunk_extern
-    // keep-NOT: fn_ret_thunk_extern
-    // thunk-extern: attributes #0 = { {{.*}}fn_ret_thunk_extern{{.*}} }
-    // keep-thunk-extern: attributes #0 = { {{.*}}fn_ret_thunk_extern{{.*}} }
-    // thunk-extern-keep-NOT: fn_ret_thunk_extern
-}
-
-// unset-NOT: !{{[0-9]+}} = !{i32 4, !"function_return_thunk_extern", i32 1}
-// keep-NOT: !{{[0-9]+}} = !{i32 4, !"function_return_thunk_extern", i32 1}
-// thunk-extern: !{{[0-9]+}} = !{i32 4, !"function_return_thunk_extern", i32 1}
-// keep-thunk-extern: !{{[0-9]+}} = !{i32 4, !"function_return_thunk_extern", i32 1}
-// thunk-extern-keep-NOT: !{{[0-9]+}} = !{i32 4, !"function_return_thunk_extern", i32 1}
diff --git a/tests/codegen/gdb_debug_script_load.rs b/tests/codegen/gdb_debug_script_load.rs
deleted file mode 100644
index 3e92eba10b1..00000000000
--- a/tests/codegen/gdb_debug_script_load.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-//@ ignore-windows
-//@ ignore-apple
-//@ ignore-wasm
-//@ ignore-emscripten
-
-//@ compile-flags: -g -C no-prepopulate-passes -Cpanic=abort
-
-#![feature(lang_items)]
-#![no_std]
-
-#[panic_handler]
-fn panic_handler(_: &core::panic::PanicInfo) -> ! {
-    loop {}
-}
-
-#[no_mangle]
-extern "C" fn rust_eh_personality() {
-    loop {}
-}
-
-// Needs rustc to generate `main` as that's where the magic load is inserted.
-// IOW, we cannot write this test with `#![no_main]`.
-// CHECK-LABEL: @main
-// CHECK: load volatile i8, {{.+}} @__rustc_debug_gdb_scripts_section__
-
-#[lang = "start"]
-fn lang_start<T: 'static>(
-    _main: fn() -> T,
-    _argc: isize,
-    _argv: *const *const u8,
-    _sigpipe: u8,
-) -> isize {
-    return 0;
-}
-
-fn main() {}
diff --git a/tests/codegen/generic-debug.rs b/tests/codegen/generic-debug.rs
deleted file mode 100644
index 0ad0b074657..00000000000
--- a/tests/codegen/generic-debug.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ ignore-wasi wasi codegens the main symbol differently
-
-//@ compile-flags: -g -C no-prepopulate-passes
-
-// CHECK-LABEL: @main
-// CHECK: {{.*}}DICompositeType{{.*}}tag: DW_TAG_structure_type,{{.*}}name: "Generic<i32>",{{.*}}
-// CHECK: {{.*}}DITemplateTypeParameter{{.*}}name: "Type",{{.*}}
-
-#![allow(dead_code)]
-#![allow(unused_variables)]
-#![allow(unused_assignments)]
-
-pub struct Generic<Type>(Type);
-
-fn main() {
-    let generic = Generic(10);
-}
diff --git a/tests/codegen/gep-index.rs b/tests/codegen/gep-index.rs
deleted file mode 100644
index bfb2511af87..00000000000
--- a/tests/codegen/gep-index.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//! Check that index and offset use the same getelementptr format.
-
-//@ revisions: NO-OPT OPT
-//@[NO-OPT] compile-flags: -Copt-level=0
-//@[OPT] compile-flags: -Copt-level=1
-
-#![crate_type = "lib"]
-
-struct Foo(i32, i32);
-
-// 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
-    &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
-    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
-    &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
-    unsafe { a.add(index) }
-}
diff --git a/tests/codegen/gpu-kernel-abi.rs b/tests/codegen/gpu-kernel-abi.rs
deleted file mode 100644
index 8ac376d9338..00000000000
--- a/tests/codegen/gpu-kernel-abi.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Checks that the gpu-kernel calling convention correctly translates to LLVM calling conventions.
-
-//@ add-core-stubs
-//@ revisions: nvptx
-//@ [nvptx] compile-flags: --crate-type=rlib --target=nvptx64-nvidia-cuda
-//@ [nvptx] needs-llvm-components: nvptx
-#![feature(no_core, lang_items, abi_gpu_kernel)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// nvptx: define ptx_kernel void @fun(i32
-#[no_mangle]
-pub extern "gpu-kernel" fn fun(_: i32) {}
diff --git a/tests/codegen/gpu_offload/gpu_host.rs b/tests/codegen/gpu_offload/gpu_host.rs
deleted file mode 100644
index 513e27426bc..00000000000
--- a/tests/codegen/gpu_offload/gpu_host.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-//@ compile-flags: -Zoffload=Enable -Zunstable-options -C opt-level=3  -Clto=fat
-//@ no-prefer-dynamic
-//@ needs-enzyme
-
-// This test is verifying that we generate __tgt_target_data_*_mapper before and after a call to the
-// kernel_1. Better documentation to what each global or variable means is available in the gpu
-// offlaod code, or the LLVM offload documentation. This code does not launch any GPU kernels yet,
-// and will be rewritten once a proper offload frontend has landed.
-//
-// We currently only handle memory transfer for specific calls to functions named `kernel_{num}`,
-// when inside of a function called main. This, too, is a temporary workaround for not having a
-// frontend.
-
-#![no_main]
-
-#[unsafe(no_mangle)]
-fn main() {
-    let mut x = [3.0; 256];
-    kernel_1(&mut x);
-    core::hint::black_box(&x);
-}
-
-// CHECK: %struct.__tgt_offload_entry = type { i64, i16, i16, i32, ptr, ptr, i64, i64, ptr }
-// CHECK: %struct.__tgt_kernel_arguments = type { i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, i64, i64, [3 x i32], [3 x i32], i32 }
-// CHECK: %struct.ident_t = type { i32, i32, i32, i32, ptr }
-// CHECK: %struct.__tgt_bin_desc = type { i32, ptr, ptr, ptr }
-
-// CHECK: @.offload_sizes.1 = private unnamed_addr constant [1 x i64] [i64 1024]
-// CHECK: @.offload_maptypes.1 = private unnamed_addr constant [1 x i64] [i64 3]
-// CHECK: @.kernel_1.region_id = weak unnamed_addr constant i8 0
-// CHECK: @.offloading.entry_name.1 = internal unnamed_addr constant [9 x i8] c"kernel_1\00", section ".llvm.rodata.offloading", align 1
-// CHECK: @.offloading.entry.kernel_1 = weak constant %struct.__tgt_offload_entry { i64 0, i16 1, i16 1, i32 0, ptr @.kernel_1.region_id, ptr @.offloading.entry_name.1, i64 0, i64 0, ptr null }, section ".omp_offloading_entries", align 1
-// CHECK: @my_struct_global2 = external global %struct.__tgt_kernel_arguments
-// CHECK: @0 = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00", align 1
-// CHECK: @1 = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 22, ptr @0 }, align 8
-
-// CHECK:  Function Attrs:
-// CHECK-NEXT: define{{( dso_local)?}} void @main()
-// CHECK-NEXT: start:
-// CHECK-NEXT:   %0 = alloca [8 x i8], align 8
-// CHECK-NEXT:   %x = alloca [1024 x i8], align 16
-// CHECK-NEXT:   %EmptyDesc = alloca %struct.__tgt_bin_desc, align 8
-// CHECK-NEXT:   %.offload_baseptrs = alloca [1 x ptr], align 8
-// CHECK-NEXT:   %.offload_ptrs = alloca [1 x ptr], align 8
-// CHECK-NEXT:   %.offload_sizes = alloca [1 x i64], align 8
-// CHECK-NEXT:   %x.addr = alloca ptr, align 8
-// CHECK-NEXT:   store ptr %x, ptr %x.addr, align 8
-// CHECK-NEXT:   %1 = load ptr, ptr %x.addr, align 8
-// CHECK-NEXT:   %2 = getelementptr inbounds float, ptr %1, i32 0
-// CHECK:        call void @llvm.memset.p0.i64(ptr align 8 %EmptyDesc, i8 0, i64 32, i1 false)
-// CHECK-NEXT:   call void @__tgt_register_lib(ptr %EmptyDesc)
-// CHECK-NEXT:   call void @__tgt_init_all_rtls()
-// CHECK-NEXT:   %3 = getelementptr inbounds [1 x ptr], ptr %.offload_baseptrs, i32 0, i32 0
-// CHECK-NEXT:   store ptr %1, ptr %3, align 8
-// CHECK-NEXT:   %4 = getelementptr inbounds [1 x ptr], ptr %.offload_ptrs, i32 0, i32 0
-// CHECK-NEXT:   store ptr %2, ptr %4, align 8
-// CHECK-NEXT:   %5 = getelementptr inbounds [1 x i64], ptr %.offload_sizes, i32 0, i32 0
-// CHECK-NEXT:   store i64 1024, ptr %5, align 8
-// CHECK-NEXT:   %6 = getelementptr inbounds [1 x ptr], ptr %.offload_baseptrs, i32 0, i32 0
-// CHECK-NEXT:   %7 = getelementptr inbounds [1 x ptr], ptr %.offload_ptrs, i32 0, i32 0
-// CHECK-NEXT:   %8 = getelementptr inbounds [1 x i64], ptr %.offload_sizes, i32 0, i32 0
-// CHECK-NEXT:   call void @__tgt_target_data_begin_mapper(ptr @1, i64 -1, i32 1, ptr %6, ptr %7, ptr %8, ptr @.offload_maptypes.1, ptr null, ptr null)
-// CHECK-NEXT:   call void @kernel_1(ptr noalias noundef nonnull align 4 dereferenceable(1024) %x)
-// CHECK-NEXT:   %9 = getelementptr inbounds [1 x ptr], ptr %.offload_baseptrs, i32 0, i32 0
-// CHECK-NEXT:   %10 = getelementptr inbounds [1 x ptr], ptr %.offload_ptrs, i32 0, i32 0
-// CHECK-NEXT:   %11 = getelementptr inbounds [1 x i64], ptr %.offload_sizes, i32 0, i32 0
-// CHECK-NEXT:   call void @__tgt_target_data_end_mapper(ptr @1, i64 -1, i32 1, ptr %9, ptr %10, ptr %11, ptr @.offload_maptypes.1, ptr null, ptr null)
-// CHECK-NEXT:   call void @__tgt_unregister_lib(ptr %EmptyDesc)
-// CHECK:        store ptr %x, ptr %0, align 8
-// CHECK-NEXT:   call void asm sideeffect "", "r,~{memory}"(ptr nonnull %0)
-// CHECK:        ret void
-// CHECK-NEXT: }
-
-#[unsafe(no_mangle)]
-#[inline(never)]
-pub fn kernel_1(x: &mut [f32; 256]) {
-    for i in 0..256 {
-        x[i] = 21.0;
-    }
-}
diff --git a/tests/codegen/hint/cold_path.rs b/tests/codegen/hint/cold_path.rs
deleted file mode 100644
index 149abe474f6..00000000000
--- a/tests/codegen/hint/cold_path.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-#![feature(cold_path)]
-
-use std::hint::cold_path;
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_a() {
-    println!("path a");
-}
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_b() {
-    println!("path b");
-}
-
-#[no_mangle]
-pub fn test1(x: bool) {
-    if x {
-        path_a();
-    } else {
-        cold_path();
-        path_b();
-    }
-
-    // CHECK-LABEL: @test1(
-    // CHECK: br i1 %x, label %bb1, label %bb2, !prof ![[NUM:[0-9]+]]
-    // CHECK: bb2:
-    // CHECK: path_b
-    // CHECK: bb1:
-    // CHECK: path_a
-}
-
-#[no_mangle]
-pub fn test2(x: i32) {
-    match x > 0 {
-        true => path_a(),
-        false => {
-            cold_path();
-            path_b()
-        }
-    }
-
-    // CHECK-LABEL: @test2(
-    // CHECK: br i1 %_2, label %bb2, label %bb1, !prof ![[NUM]]
-    // CHECK: bb1:
-    // CHECK: path_b
-    // CHECK: bb2:
-    // CHECK: path_a
-}
-
-// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 2000, i32 1}
diff --git a/tests/codegen/hint/likely.rs b/tests/codegen/hint/likely.rs
deleted file mode 100644
index 75f9e7aae36..00000000000
--- a/tests/codegen/hint/likely.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-#![feature(likely_unlikely)]
-
-use std::hint::likely;
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_a() {
-    println!("path a");
-}
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_b() {
-    println!("path b");
-}
-
-#[no_mangle]
-pub fn test1(x: bool) {
-    if likely(x) {
-        path_a();
-    } else {
-        path_b();
-    }
-
-    // CHECK-LABEL: @test1(
-    // CHECK: br i1 %x, label %bb2, label %bb3, !prof ![[NUM:[0-9]+]]
-    // CHECK: bb3:
-    // CHECK: path_b
-    // CHECK: bb2:
-    // CHECK: path_a
-}
-
-#[no_mangle]
-pub fn test2(x: i32) {
-    match likely(x > 0) {
-        true => path_a(),
-        false => path_b(),
-    }
-
-    // CHECK-LABEL: @test2(
-    // CHECK: br i1 %_2, label %bb2, label %bb3, !prof ![[NUM]]
-    // CHECK: bb3:
-    // CHECK: path_b
-    // CHECK: bb2:
-    // CHECK: path_a
-}
-
-#[no_mangle]
-pub fn test3(x: i8) {
-    match likely(x < 7) {
-        true => path_a(),
-        _ => path_b(),
-    }
-
-    // CHECK-LABEL: @test3(
-    // CHECK: br i1 %_2, label %bb2, label %bb3, !prof ![[NUM]]
-    // CHECK: bb3:
-    // CHECK: path_b
-    // CHECK: bb2:
-    // CHECK: path_a
-}
-
-#[no_mangle]
-pub fn test4(x: u64) {
-    match likely(x != 33) {
-        false => path_a(),
-        _ => path_b(),
-    }
-
-    // CHECK-LABEL: @test4(
-    // CHECK: br i1 %0, label %bb3, label %bb2, !prof ![[NUM2:[0-9]+]]
-    // CHECK: bb3:
-    // CHECK: path_a
-    // CHECK: bb2:
-    // CHECK: path_b
-}
-
-// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 2000, i32 1}
-// CHECK: ![[NUM2]] = !{!"branch_weights", {{(!"expected", )?}}i32 1, i32 2000}
diff --git a/tests/codegen/hint/unlikely.rs b/tests/codegen/hint/unlikely.rs
deleted file mode 100644
index 248b1e2537e..00000000000
--- a/tests/codegen/hint/unlikely.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-#![feature(likely_unlikely)]
-
-use std::hint::unlikely;
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_a() {
-    println!("path a");
-}
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_b() {
-    println!("path b");
-}
-
-#[no_mangle]
-pub fn test1(x: bool) {
-    if unlikely(x) {
-        path_a();
-    } else {
-        path_b();
-    }
-
-    // CHECK-LABEL: @test1(
-    // CHECK: br i1 %x, label %bb2, label %bb4, !prof ![[NUM:[0-9]+]]
-    // CHECK: bb4:
-    // CHECK: path_b
-    // CHECK: bb2:
-    // CHECK: path_a
-}
-
-#[no_mangle]
-pub fn test2(x: i32) {
-    match unlikely(x > 0) {
-        true => path_a(),
-        false => path_b(),
-    }
-
-    // CHECK-LABEL: @test2(
-    // CHECK: br i1 %_2, label %bb2, label %bb4, !prof ![[NUM]]
-    // CHECK: bb4:
-    // CHECK: path_b
-    // CHECK: bb2:
-    // CHECK: path_a
-}
-
-#[no_mangle]
-pub fn test3(x: i8) {
-    match unlikely(x < 7) {
-        true => path_a(),
-        _ => path_b(),
-    }
-
-    // CHECK-LABEL: @test3(
-    // CHECK: br i1 %_2, label %bb2, label %bb4, !prof ![[NUM]]
-    // CHECK: bb4:
-    // CHECK: path_b
-    // CHECK: bb2:
-    // CHECK: path_a
-}
-
-#[no_mangle]
-pub fn test4(x: u64) {
-    match unlikely(x != 33) {
-        false => path_a(),
-        _ => path_b(),
-    }
-
-    // CHECK-LABEL: @test4(
-    // CHECK: br i1 %0, label %bb4, label %bb2, !prof ![[NUM2:[0-9]+]]
-    // CHECK: bb4:
-    // CHECK: path_a
-    // CHECK: bb2:
-    // CHECK: path_b
-}
-
-// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 1, i32 2000}
diff --git a/tests/codegen/i128-wasm32-callconv.rs b/tests/codegen/i128-wasm32-callconv.rs
deleted file mode 100644
index 9d73d270ef3..00000000000
--- a/tests/codegen/i128-wasm32-callconv.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//! Verify that Rust implements the expected calling convention for `i128`/`u128`.
-
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 --target wasm32-wasip1
-//@ needs-llvm-components: webassembly
-
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-#![feature(no_core, lang_items)]
-
-extern crate minicore;
-
-extern "C" {
-    fn extern_call(arg0: i128);
-    fn extern_ret() -> i128;
-}
-
-#[no_mangle]
-pub extern "C" fn pass(_arg0: u32, arg1: i128) {
-    // CHECK-LABEL: @pass(
-    // an i128 is passed via registers
-    // CHECK-SAME: i128 noundef %arg1
-    // CHECK: call void @extern_call
-    unsafe { extern_call(arg1) };
-}
-
-// Check that we produce the correct return ABI
-#[no_mangle]
-pub extern "C" fn ret(_arg0: u32, arg1: i128) -> i128 {
-    // CHECK-LABEL: @ret(
-    // but an i128 is returned via the stack
-    // CHECK-SAME: sret
-    // CHECK: store i128 %arg1
-    // CHECK-NEXT: ret void
-    arg1
-}
-
-// Check that we consume the correct return ABI
-#[no_mangle]
-pub extern "C" fn forward(dst: *mut i128) {
-    // CHECK-LABEL: @forward
-    // CHECK-SAME: ptr{{.*}} %dst)
-    // without optimizatons, an intermediate alloca is used
-    // CHECK: call void @extern_ret
-    // CHECK: store i128
-    // CHECK: ret void
-    unsafe { *dst = extern_ret() };
-}
diff --git a/tests/codegen/i128-x86-align.rs b/tests/codegen/i128-x86-align.rs
deleted file mode 100644
index 75802b0c505..00000000000
--- a/tests/codegen/i128-x86-align.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-//@ only-x86_64
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --crate-type=lib
-
-// On LLVM 17 and earlier LLVM's own data layout specifies that i128 has 8 byte alignment,
-// while rustc wants it to have 16 byte alignment. This test checks that we handle this
-// correctly.
-
-// CHECK: %ScalarPair = type { i32, [3 x i32], i128 }
-
-#![feature(core_intrinsics)]
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct ScalarPair {
-    a: i32,
-    b: i128,
-}
-
-#[no_mangle]
-pub fn load(x: &ScalarPair) -> ScalarPair {
-    // CHECK-LABEL: @load(
-    // CHECK-SAME: sret([32 x i8]) align 16
-    // CHECK-SAME: dereferenceable(32) %_0,
-    // CHECK-SAME: align 16
-    // CHECK-SAME: dereferenceable(32) %x
-    // CHECK:      [[A:%.*]] = load i32, ptr %x, align 16
-    // CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr %x, i64 16
-    // CHECK-NEXT: [[B:%.*]] = load i128, ptr [[GEP]], align 16
-    // CHECK-NEXT: store i32 [[A]], ptr %_0, align 16
-    // CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr %_0, i64 16
-    // CHECK-NEXT: store i128 [[B]], ptr [[GEP]], align 16
-    // CHECK-NEXT: ret void
-    *x
-}
-
-#[no_mangle]
-pub fn store(x: &mut ScalarPair) {
-    // CHECK-LABEL: @store(
-    // CHECK-SAME: align 16
-    // CHECK-SAME: dereferenceable(32) %x
-    // CHECK:      store i32 1, ptr %x, align 16
-    // CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr %x, i64 16
-    // CHECK-NEXT: store i128 2, ptr [[GEP]], align 16
-    *x = ScalarPair { a: 1, b: 2 };
-}
-
-#[no_mangle]
-pub fn alloca() {
-    // CHECK-LABEL: @alloca(
-    // CHECK:      [[X:%.*]] = alloca [32 x i8], align 16
-    // CHECK:      store i32 1, ptr %x, align 16
-    // CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr %x, i64 16
-    // CHECK-NEXT: store i128 2, ptr [[GEP]], align 16
-    let mut x = ScalarPair { a: 1, b: 2 };
-    store(&mut x);
-}
-
-#[no_mangle]
-pub fn load_volatile(x: &ScalarPair) -> ScalarPair {
-    // CHECK-LABEL: @load_volatile(
-    // CHECK-SAME: sret([32 x i8]) align 16
-    // CHECK-SAME: dereferenceable(32) %_0,
-    // CHECK-SAME: align 16
-    // CHECK-SAME: dereferenceable(32) %x
-    // CHECK:      [[LOAD:%.*]] = load volatile %ScalarPair, ptr %x, align 16
-    // CHECK-NEXT: store %ScalarPair [[LOAD]], ptr %_0, align 16
-    // CHECK-NEXT: ret void
-    unsafe { std::intrinsics::volatile_load(x) }
-}
-
-#[no_mangle]
-pub fn transmute(x: ScalarPair) -> (std::mem::MaybeUninit<i128>, i128) {
-    // CHECK-LABEL: @transmute(
-    // CHECK-SAME:  sret([32 x i8]) align 16
-    // CHECK-SAME:  dereferenceable(32) %_0,
-    // CHECK-SAME:  i32 noundef %x.0, i128 noundef %x.1
-    // CHECK:       store i32 %x.0, ptr %_0, align 16
-    // CHECK-NEXT:  [[GEP:%.*]] = getelementptr inbounds i8, ptr %_0, i64 16
-    // CHECK-NEXT:  store i128 %x.1, ptr [[GEP]], align 16
-    // CHECK-NEXT:  ret void
-    unsafe { std::mem::transmute(x) }
-}
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct Struct {
-    a: i32,
-    b: i32,
-    c: i128,
-}
-
-#[no_mangle]
-pub fn store_struct(x: &mut Struct) {
-    // CHECK-LABEL: @store_struct(
-    // CHECK-SAME: align 16
-    // CHECK-SAME: dereferenceable(32) %x
-    // CHECK:      [[TMP:%.*]] = alloca [32 x i8], align 16
-    // CHECK:      store i32 1, ptr [[TMP]], align 16
-    // CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds i8, ptr [[TMP]], i64 4
-    // CHECK-NEXT: store i32 2, ptr [[GEP1]], align 4
-    // CHECK-NEXT: [[GEP2:%.*]] = getelementptr inbounds i8, ptr [[TMP]], i64 16
-    // CHECK-NEXT: store i128 3, ptr [[GEP2]], align 16
-    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 16 %x, ptr align 16 [[TMP]], i64 32, i1 false)
-    *x = Struct { a: 1, b: 2, c: 3 };
-}
diff --git a/tests/codegen/i128-x86-callconv.rs b/tests/codegen/i128-x86-callconv.rs
deleted file mode 100644
index 41c30c09c1a..00000000000
--- a/tests/codegen/i128-x86-callconv.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-//! Verify that Rust implements the expected calling convention for `i128`/`u128`.
-
-// Eliminate intermediate instructions during `nop` tests
-//@ compile-flags: -Copt-level=1
-
-//@ add-core-stubs
-//@ revisions: MSVC MINGW softfloat
-//@ [MSVC] needs-llvm-components: x86
-//@ [MSVC] compile-flags: --target x86_64-pc-windows-msvc
-// Use `WIN` as a common prefix for MSVC and MINGW but *not* the softfloat test.
-//@ [MSVC] filecheck-flags: --check-prefix=WIN
-//@ [MINGW] needs-llvm-components: x86
-//@ [MINGW] compile-flags: --target x86_64-pc-windows-gnu
-//@ [MINGW] filecheck-flags: --check-prefix=WIN
-// The `x86_64-unknown-uefi` target also uses the Windows calling convention,
-// but does not have SSE registers available.
-//@ [softfloat] needs-llvm-components: x86
-//@ [softfloat] compile-flags: --target x86_64-unknown-uefi
-
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-#![feature(no_core, lang_items)]
-
-extern crate minicore;
-
-extern "C" {
-    fn extern_call(arg0: i128);
-    fn extern_ret() -> i128;
-}
-
-#[no_mangle]
-pub extern "C" fn pass(_arg0: u32, arg1: i128) {
-    // CHECK-LABEL: @pass(
-    // i128 is passed indirectly on Windows. It should load the pointer to the stack and pass
-    // a pointer to that allocation. The softfloat ABI works the same.
-    // CHECK-SAME: %_arg0, ptr{{.*}} %arg1)
-    // CHECK: [[PASS:%[_0-9]+]] = alloca [16 x i8], align 16
-    // CHECK: [[LOADED:%[_0-9]+]] = load i128, ptr %arg1
-    // CHECK: store i128 [[LOADED]], ptr [[PASS]]
-    // CHECK: call void @extern_call
-    unsafe { extern_call(arg1) };
-}
-
-// Check that we produce the correct return ABI
-#[no_mangle]
-pub extern "C" fn ret(_arg0: u32, arg1: i128) -> i128 {
-    // WIN-LABEL: @ret(
-    // i128 is returned in xmm0 on Windows
-    // FIXME(#134288): This may change for the `-msvc` targets in the future.
-    // WIN-SAME: i32{{.*}} %_arg0, ptr{{.*}} %arg1)
-    // WIN: [[LOADED:%[_0-9]+]] = load <16 x i8>, ptr %arg1
-    // WIN-NEXT: ret <16 x i8> [[LOADED]]
-    // The softfloat ABI returns this indirectly.
-    // softfloat-LABEL: i128 @ret(i32{{.*}} %_arg0, ptr{{.*}} %arg1)
-    arg1
-}
-
-// Check that we consume the correct return ABI
-#[no_mangle]
-pub extern "C" fn forward(dst: *mut i128) {
-    // CHECK-LABEL: @forward
-    // WIN-SAME: ptr{{.*}} %dst)
-    // WIN: [[RETURNED:%[_0-9]+]] = tail call <16 x i8> @extern_ret()
-    // WIN: store <16 x i8> [[RETURNED]], ptr %dst
-    // WIN: ret void
-    // softfloat: [[RETURNED:%[_0-9]+]] = tail call {{.*}}i128 @extern_ret()
-    unsafe { *dst = extern_ret() };
-}
-
-#[repr(C)]
-struct RetAggregate {
-    a: i32,
-    b: i128,
-}
-
-#[no_mangle]
-pub extern "C" fn ret_aggregate(_arg0: u32, arg1: i128) -> RetAggregate {
-    // CHECK-LABEL: @ret_aggregate(
-    // Aggregates should also be returned indirectly
-    // CHECK-SAME: ptr{{.*}}sret([32 x i8]){{.*}}[[RET:%[_0-9]+]], i32{{.*}}%_arg0, ptr{{.*}}%arg1)
-    // CHECK: [[LOADED:%[_0-9]+]] = load i128, ptr %arg1
-    // CHECK: [[GEP:%[_0-9]+]] = getelementptr{{.*}}, ptr [[RET]]
-    // CHECK: store i128 [[LOADED]], ptr [[GEP]]
-    // CHECK: ret void
-    RetAggregate { a: 1, b: arg1 }
-}
diff --git a/tests/codegen/infallible-unwrap-in-opt-z.rs b/tests/codegen/infallible-unwrap-in-opt-z.rs
deleted file mode 100644
index c2297c58e77..00000000000
--- a/tests/codegen/infallible-unwrap-in-opt-z.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//@ compile-flags: -C opt-level=z
-//@ edition: 2021
-
-#![crate_type = "lib"]
-
-// From <https://github.com/rust-lang/rust/issues/115463>
-
-// CHECK-LABEL: @read_up_to_8(
-#[no_mangle]
-pub fn read_up_to_8(buf: &[u8]) -> u64 {
-    // CHECK-NOT: unwrap_failed
-    if buf.len() < 4 {
-        // actual instance has more code.
-        return 0;
-    }
-    let lo = u32::from_le_bytes(buf[..4].try_into().unwrap()) as u64;
-    let hi = u32::from_le_bytes(buf[buf.len() - 4..][..4].try_into().unwrap()) as u64;
-    lo | (hi << 8 * (buf.len() as u64 - 4))
-}
-
-// CHECK-LABEL: @checking_unwrap_expectation(
-#[no_mangle]
-pub fn checking_unwrap_expectation(buf: &[u8]) -> &[u8; 4] {
-    // CHECK: call void @{{.*core6result13unwrap_failed}}
-    buf.try_into().unwrap()
-}
diff --git a/tests/codegen/inherit_overflow.rs b/tests/codegen/inherit_overflow.rs
deleted file mode 100644
index e4a5ef39fc5..00000000000
--- a/tests/codegen/inherit_overflow.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ compile-flags: -Zmir-enable-passes=+Inline,+GVN --crate-type lib
-//@ revisions: ASSERT NOASSERT
-//@[ASSERT] compile-flags: -Coverflow-checks=on
-//@[NOASSERT] compile-flags: -Coverflow-checks=off
-
-// CHECK-LABEL: define{{.*}} @assertion
-// ASSERT: call void @{{.*4core9panicking11panic_const24panic_const_add_overflow}}
-// NOASSERT: ret i8 0
-#[no_mangle]
-pub fn assertion() -> u8 {
-    // Optimized MIR will replace this `CheckedBinaryOp` by `const (0, true)`.
-    // Verify that codegen does or does not emit the panic.
-    <u8 as std::ops::Add>::add(255, 1)
-}
diff --git a/tests/codegen/inline-always-works-always.rs b/tests/codegen/inline-always-works-always.rs
deleted file mode 100644
index 07200fd9e37..00000000000
--- a/tests/codegen/inline-always-works-always.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ revisions: NO-OPT SIZE-OPT SPEED-OPT
-//@[NO-OPT] compile-flags: -Copt-level=0
-//@[SIZE-OPT] compile-flags: -Copt-level=s
-//@[SPEED-OPT] compile-flags: -Copt-level=3
-
-#![crate_type = "rlib"]
-
-#[no_mangle]
-#[inline(always)]
-pub extern "C" fn callee() -> u32 {
-    4 + 4
-}
-
-// CHECK-LABEL: caller
-// SIZE-OPT: ret i32 8
-// SPEED-OPT: ret i32 8
-// NO-OPT: ret i32 8
-#[no_mangle]
-pub extern "C" fn caller() -> u32 {
-    callee()
-}
diff --git a/tests/codegen/inline-debuginfo.rs b/tests/codegen/inline-debuginfo.rs
deleted file mode 100644
index 1e1c9037f5c..00000000000
--- a/tests/codegen/inline-debuginfo.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-#![crate_type = "rlib"]
-//@ compile-flags: -Copt-level=3 -g
-//
-
-#[no_mangle]
-#[inline(always)]
-pub extern "C" fn callee(x: u32) -> u32 {
-    x + 4
-}
-
-// CHECK-LABEL: caller
-// CHECK: dbg{{.}}value({{(metadata )?}}i32 %y, {{(metadata )?}}!{{.*}}, {{(metadata )?}}!DIExpression(DW_OP_constu, 3, DW_OP_minus, DW_OP_stack_value){{.*}} [[A:![0-9]+]]
-// CHECK: [[A]] = !DILocation(line: {{.*}}, scope: {{.*}}, inlinedAt: {{.*}})
-#[no_mangle]
-pub extern "C" fn caller(y: u32) -> u32 {
-    callee(y - 3)
-}
diff --git a/tests/codegen/inline-function-args-debug-info.rs b/tests/codegen/inline-function-args-debug-info.rs
deleted file mode 100644
index c31419cb914..00000000000
--- a/tests/codegen/inline-function-args-debug-info.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// This test checks that debug information includes function argument indexes even if the function
-// gets inlined by MIR inlining. Without function argument indexes, `info args` in gdb won't show
-// arguments and their values for the current function.
-
-//@ compile-flags: -Zinline-mir=yes -Cdebuginfo=2
-//@ edition: 2021
-
-#![crate_type = "lib"]
-
-#[inline(never)]
-pub fn outer_function(x: usize, y: usize) -> usize {
-    inner_function(x, y) + 1
-}
-
-#[inline]
-fn inner_function(aaaa: usize, bbbb: usize) -> usize {
-    // CHECK: !DILocalVariable(name: "aaaa", arg: 1
-    // CHECK-SAME: line: 16
-    // CHECK-NOT: !DILexicalBlock(
-    // CHECK: !DILocalVariable(name: "bbbb", arg: 2
-    // CHECK-SAME: line: 16
-    aaaa + bbbb
-}
diff --git a/tests/codegen/inline-hint.rs b/tests/codegen/inline-hint.rs
deleted file mode 100644
index 3d46885d5a2..00000000000
--- a/tests/codegen/inline-hint.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Checks that closures, constructors, and shims except
-// for a drop glue receive inline hint by default.
-//
-//@ compile-flags: -Cno-prepopulate-passes -Csymbol-mangling-version=v0 -Zinline-mir=no
-#![crate_type = "lib"]
-
-pub fn f() {
-    let a = A;
-    let b = (0i32, 1i32, 2i32, 3 as *const i32);
-    let c = || {};
-
-    a(String::new(), String::new());
-    b.clone();
-    c();
-}
-
-struct A(String, String);
-
-// CHECK:      ; core::ptr::drop_in_place::<inline_hint::A>
-// CHECK-NEXT: ; Function Attrs:
-// CHECK-NOT:  inlinehint
-// CHECK-SAME: {{$}}
-
-// CHECK:      ; <(i32, i32, i32, *const i{{16|32|64}}) as core::clone::Clone>::clone
-// CHECK-NEXT: ; Function Attrs: inlinehint
-
-// CHECK:      ; inline_hint::f::{closure#0}
-// CHECK-NEXT: ; Function Attrs: inlinehint
-
-// CHECK:      ; inline_hint::A
-// CHECK-NEXT: ; Function Attrs: inlinehint
diff --git a/tests/codegen/instrument-coverage/instrument-coverage-off.rs b/tests/codegen/instrument-coverage/instrument-coverage-off.rs
deleted file mode 100644
index e44d6c65874..00000000000
--- a/tests/codegen/instrument-coverage/instrument-coverage-off.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Test that `-Cinstrument-coverage=off` does not add coverage instrumentation to LLVM IR.
-
-//@ compile-flags: -Zno-profiler-runtime
-//@ revisions: n no off false_ zero
-//@ [n] compile-flags: -Cinstrument-coverage=n
-//@ [no] compile-flags: -Cinstrument-coverage=no
-//@ [off] compile-flags: -Cinstrument-coverage=off
-//@ [false_] compile-flags: -Cinstrument-coverage=false
-//@ [zero] compile-flags: -Cinstrument-coverage=0
-
-// CHECK-NOT: __llvm_profile_filename
-// CHECK-NOT: __llvm_coverage_mapping
-
-#![crate_type = "lib"]
-
-#[inline(never)]
-fn some_function() {}
-
-pub fn some_other_function() {
-    some_function();
-}
diff --git a/tests/codegen/instrument-coverage/instrument-coverage.rs b/tests/codegen/instrument-coverage/instrument-coverage.rs
deleted file mode 100644
index 23d23651c72..00000000000
--- a/tests/codegen/instrument-coverage/instrument-coverage.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Test that `-Cinstrument-coverage` creates expected __llvm_profile_filename symbol in LLVM IR.
-
-//@ compile-flags: -Zno-profiler-runtime
-//@ revisions: default y yes on true_ all
-//@ [default] compile-flags: -Cinstrument-coverage
-//@ [y] compile-flags: -Cinstrument-coverage=y
-//@ [yes] compile-flags: -Cinstrument-coverage=yes
-//@ [on] compile-flags: -Cinstrument-coverage=on
-//@ [true_] compile-flags: -Cinstrument-coverage=true
-//@ [all] compile-flags: -Cinstrument-coverage=all
-
-// CHECK-DAG: @__llvm_coverage_mapping
-// CHECK-DAG: @__llvm_profile_filename = {{.*}}"default_%m_%p.profraw\00"{{.*}}
-
-#![crate_type = "lib"]
-
-#[inline(never)]
-fn some_function() {}
-
-pub fn some_other_function() {
-    some_function();
-}
diff --git a/tests/codegen/instrument-coverage/testprog.rs b/tests/codegen/instrument-coverage/testprog.rs
deleted file mode 100644
index 9e918499d57..00000000000
--- a/tests/codegen/instrument-coverage/testprog.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-//@ edition: 2021
-//@ compile-flags: -Zno-profiler-runtime
-//@ compile-flags: -Cinstrument-coverage -Copt-level=0
-//@ revisions: LINUX DARWIN WIN
-
-//@ [LINUX] only-linux
-//@ [LINUX] filecheck-flags: -DINSTR_PROF_DATA=__llvm_prf_data
-//@ [LINUX] filecheck-flags: -DINSTR_PROF_NAME=__llvm_prf_names
-//@ [LINUX] filecheck-flags: -DINSTR_PROF_CNTS=__llvm_prf_cnts
-//@ [LINUX] filecheck-flags: -DINSTR_PROF_COVMAP=__llvm_covmap
-//@ [LINUX] filecheck-flags: -DINSTR_PROF_COVFUN=__llvm_covfun
-//@ [LINUX] filecheck-flags: '-DCOMDAT_IF_SUPPORTED=, comdat'
-
-//@ [DARWIN] only-apple
-//@ [DARWIN] filecheck-flags: -DINSTR_PROF_DATA=__DATA,__llvm_prf_data,regular,live_support
-//@ [DARWIN] filecheck-flags: -DINSTR_PROF_NAME=__DATA,__llvm_prf_names
-//@ [DARWIN] filecheck-flags: -DINSTR_PROF_CNTS=__DATA,__llvm_prf_cnts
-//@ [DARWIN] filecheck-flags: -DINSTR_PROF_COVMAP=__LLVM_COV,__llvm_covmap
-//@ [DARWIN] filecheck-flags: -DINSTR_PROF_COVFUN=__LLVM_COV,__llvm_covfun
-//@ [DARWIN] filecheck-flags: -DCOMDAT_IF_SUPPORTED=
-
-//@ [WIN] only-windows
-//@ [WIN] filecheck-flags: -DINSTR_PROF_DATA=.lprfd$M
-//@ [WIN] filecheck-flags: -DINSTR_PROF_NAME=.lprfn$M
-//@ [WIN] filecheck-flags: -DINSTR_PROF_CNTS=.lprfc$M
-//@ [WIN] filecheck-flags: -DINSTR_PROF_COVMAP=.lcovmap$M
-//@ [WIN] filecheck-flags: -DINSTR_PROF_COVFUN=.lcovfun$M
-//@ [WIN] filecheck-flags: '-DCOMDAT_IF_SUPPORTED=, comdat'
-
-// ignore-tidy-linelength
-
-pub fn will_be_called() -> &'static str {
-    let val = "called";
-    println!("{}", val);
-    val
-}
-
-pub fn will_not_be_called() -> bool {
-    println!("should not have been called");
-    false
-}
-
-pub fn print<T>(left: &str, value: T, right: &str)
-where
-    T: std::fmt::Display,
-{
-    println!("{}{}{}", left, value, right);
-}
-
-pub fn wrap_with<F, T>(inner: T, should_wrap: bool, wrapper: F)
-where
-    F: FnOnce(&T),
-{
-    if should_wrap {
-        wrapper(&inner)
-    }
-}
-
-fn main() {
-    let less = 1;
-    let more = 100;
-
-    if less < more {
-        wrap_with(will_be_called(), less < more, |inner| print(" ***", inner, "*** "));
-        wrap_with(will_be_called(), more < less, |inner| print(" ***", inner, "*** "));
-    } else {
-        wrap_with(will_not_be_called(), true, |inner| print("wrapped result is: ", inner, ""));
-    }
-}
-
-// Check for metadata, variables, declarations, and function definitions injected
-// into LLVM IR when compiling with -Cinstrument-coverage.
-
-// WIN:          $__llvm_profile_runtime_user = comdat any
-
-// CHECK-DAG:    @__llvm_coverage_mapping = private constant {{.*}}, section "[[INSTR_PROF_COVMAP]]", align 8
-
-// CHECK-DAG:    @__covrec_{{[A-F0-9]+}}u = linkonce_odr hidden constant {{.*}}, section "[[INSTR_PROF_COVFUN]]"[[COMDAT_IF_SUPPORTED]], align 8
-
-// WIN:          @__llvm_profile_runtime = external{{.*}}global i32
-
-// CHECK:        @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called = {{private|internal}} global
-// CHECK-SAME:   section "[[INSTR_PROF_CNTS]]"{{.*}}, align 8
-
-// CHECK:        @__profd__R{{[a-zA-Z0-9_]+}}testprog14will_be_called = {{private|internal}} global
-// CHECK-SAME:   @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called
-// CHECK-SAME:   section "[[INSTR_PROF_DATA]]"{{.*}}, align 8
-
-// CHECK:        @__profc__R{{[a-zA-Z0-9_]+}}testprog4main = {{private|internal}} global
-// CHECK-SAME:   section "[[INSTR_PROF_CNTS]]"{{.*}}, align 8
-
-// CHECK:        @__profd__R{{[a-zA-Z0-9_]+}}testprog4main = {{private|internal}} global
-// CHECK-SAME:   @__profc__R{{[a-zA-Z0-9_]+}}testprog4main
-// CHECK-SAME:   section "[[INSTR_PROF_DATA]]"{{.*}}, align 8
-
-// CHECK:        @__llvm_prf_nm = private constant
-// CHECK-SAME:   section "[[INSTR_PROF_NAME]]", align 1
-
-// CHECK:        @llvm.used = appending global
-// CHECK-SAME:   @__llvm_coverage_mapping
-// CHECK-SAME:   @__llvm_prf_nm
-// CHECK-SAME:   section "llvm.metadata"
-
-// CHECK:        define internal { {{.*}} } @_R{{[a-zA-Z0-9_]+}}testprog14will_be_called() unnamed_addr #{{[0-9]+}} {
-// CHECK-NEXT:   start:
-// CHECK-NOT:    define internal
-// CHECK:        atomicrmw add ptr
-// CHECK-SAME:   @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called,
-
-// CHECK:        declare void @llvm.instrprof.increment(ptr, i64, i32, i32) #[[LLVM_INSTRPROF_INCREMENT_ATTR:[0-9]+]]
-
-// WIN:          define linkonce_odr hidden i32 @__llvm_profile_runtime_user() #[[LLVM_PROFILE_RUNTIME_USER_ATTR:[0-9]+]] comdat {
-// WIN-NEXT:     %1 = load i32, ptr @__llvm_profile_runtime
-// WIN-NEXT:     ret i32 %1
-// WIN-NEXT:     }
-
-// CHECK:        attributes #[[LLVM_INSTRPROF_INCREMENT_ATTR]] = { nounwind }
-// WIN:          attributes #[[LLVM_PROFILE_RUNTIME_USER_ATTR]] = { noinline }
diff --git a/tests/codegen/instrument-mcount.rs b/tests/codegen/instrument-mcount.rs
deleted file mode 100644
index 8c97535d4a8..00000000000
--- a/tests/codegen/instrument-mcount.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//
-//@ compile-flags: -Z instrument-mcount -Copt-level=0
-
-#![crate_type = "lib"]
-
-// CHECK: attributes #{{.*}} "frame-pointer"="all" "instrument-function-entry-inlined"="{{.*}}mcount{{.*}}"
-pub fn foo() {}
diff --git a/tests/codegen/instrument-xray/basic.rs b/tests/codegen/instrument-xray/basic.rs
deleted file mode 100644
index 7aaebf41e36..00000000000
--- a/tests/codegen/instrument-xray/basic.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Checks that `-Z instrument-xray` produces expected instrumentation.
-//
-//@ needs-xray
-//@ compile-flags: -Z instrument-xray=always -Copt-level=0
-
-#![crate_type = "lib"]
-
-// CHECK: attributes #{{.*}} "function-instrument"="xray-always"
-pub fn function() {}
diff --git a/tests/codegen/instrument-xray/options-combine.rs b/tests/codegen/instrument-xray/options-combine.rs
deleted file mode 100644
index d1e3b78e6b2..00000000000
--- a/tests/codegen/instrument-xray/options-combine.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Checks that `-Z instrument-xray` options can be specified multiple times.
-//
-//@ needs-xray
-//@ compile-flags: -Z instrument-xray=skip-exit -Copt-level=0
-//@ compile-flags: -Z instrument-xray=instruction-threshold=123 -Copt-level=0
-//@ compile-flags: -Z instrument-xray=instruction-threshold=456 -Copt-level=0
-
-#![crate_type = "lib"]
-
-// CHECK:      attributes #{{.*}} "xray-instruction-threshold"="456" "xray-skip-exit"
-// CHECK-NOT:  attributes #{{.*}} "xray-instruction-threshold"="123"
-pub fn function() {}
diff --git a/tests/codegen/instrument-xray/options-override.rs b/tests/codegen/instrument-xray/options-override.rs
deleted file mode 100644
index 428fb723edb..00000000000
--- a/tests/codegen/instrument-xray/options-override.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Checks that the last `-Z instrument-xray` option wins.
-//
-//@ needs-xray
-//@ compile-flags: -Z instrument-xray=always -Copt-level=0
-//@ compile-flags: -Z instrument-xray=never -Copt-level=0
-
-#![crate_type = "lib"]
-
-// CHECK:      attributes #{{.*}} "function-instrument"="xray-never"
-// CHECK-NOT:  attributes #{{.*}} "function-instrument"="xray-always"
-pub fn function() {}
diff --git a/tests/codegen/integer-cmp.rs b/tests/codegen/integer-cmp.rs
deleted file mode 100644
index 812fa8e4a42..00000000000
--- a/tests/codegen/integer-cmp.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-// This is test for more optimal Ord implementation for integers.
-// See <https://github.com/rust-lang/rust/issues/63758> for more info.
-
-//@ revisions: llvm-pre-20 llvm-20
-//@ [llvm-20] min-llvm-version: 20
-//@ [llvm-pre-20] max-llvm-major-version: 19
-//@ compile-flags: -C opt-level=3 -Zmerge-functions=disabled
-
-#![crate_type = "lib"]
-
-use std::cmp::Ordering;
-
-// CHECK-LABEL: @cmp_signed
-#[no_mangle]
-pub fn cmp_signed(a: i64, b: i64) -> Ordering {
-    // llvm-20: call{{.*}} i8 @llvm.scmp.i8.i64
-    // llvm-pre-20: icmp slt
-    // llvm-pre-20: icmp ne
-    // llvm-pre-20: zext i1
-    // llvm-pre-20: select i1
-    a.cmp(&b)
-}
-
-// CHECK-LABEL: @cmp_unsigned
-#[no_mangle]
-pub fn cmp_unsigned(a: u32, b: u32) -> Ordering {
-    // llvm-20: call{{.*}} i8 @llvm.ucmp.i8.i32
-    // llvm-pre-20: icmp ult
-    // llvm-pre-20: icmp ne
-    // llvm-pre-20: zext i1
-    // llvm-pre-20: select i1
-    a.cmp(&b)
-}
-
-// CHECK-LABEL: @cmp_char
-#[no_mangle]
-pub fn cmp_char(a: char, b: char) -> Ordering {
-    // llvm-20: call{{.*}} i8 @llvm.ucmp.i8.i32
-    // llvm-pre-20: icmp ult
-    // llvm-pre-20: icmp ne
-    // llvm-pre-20: zext i1
-    // llvm-pre-20: select i1
-    a.cmp(&b)
-}
-
-// CHECK-LABEL: @cmp_tuple
-#[no_mangle]
-pub fn cmp_tuple(a: (i16, u16), b: (i16, u16)) -> Ordering {
-    // llvm-20-DAG: call{{.*}} i8 @llvm.ucmp.i8.i16
-    // llvm-20-DAG: call{{.*}} i8 @llvm.scmp.i8.i16
-    // llvm-20: ret i8
-    // llvm-pre-20: icmp slt
-    // llvm-pre-20: icmp ne
-    // llvm-pre-20: zext i1
-    // llvm-pre-20: select i1
-    // llvm-pre-20: icmp ult
-    // llvm-pre-20: icmp ne
-    // llvm-pre-20: zext i1
-    // llvm-pre-20: select i1
-    // llvm-pre-20: select i1
-    a.cmp(&b)
-}
diff --git a/tests/codegen/integer-overflow.rs b/tests/codegen/integer-overflow.rs
deleted file mode 100644
index 80362247a86..00000000000
--- a/tests/codegen/integer-overflow.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C overflow-checks=on
-
-#![crate_type = "lib"]
-
-pub struct S1<'a> {
-    data: &'a [u8],
-    position: usize,
-}
-
-// CHECK-LABEL: @slice_no_index_order
-#[no_mangle]
-pub fn slice_no_index_order<'a>(s: &'a mut S1, n: usize) -> &'a [u8] {
-    // CHECK-NOT: slice_index_order_fail
-    let d = &s.data[s.position..s.position + n];
-    s.position += n;
-    return d;
-}
-
-// CHECK-LABEL: @test_check
-#[no_mangle]
-pub fn test_check<'a>(s: &'a mut S1, x: usize, y: usize) -> &'a [u8] {
-    // CHECK: slice_index_order_fail
-    &s.data[x..y]
-}
diff --git a/tests/codegen/internalize-closures.rs b/tests/codegen/internalize-closures.rs
deleted file mode 100644
index f226ea6faac..00000000000
--- a/tests/codegen/internalize-closures.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Zmir-opt-level=0
-
-pub fn main() {
-    // We want to make sure that closures get 'internal' linkage instead of
-    // 'weak_odr' when they are not shared between codegen units
-    // FIXME(eddyb) `legacy` mangling uses `{{closure}}`, while `v0`
-    // uses `{closure#0}`, switch to the latter once `legacy` is gone.
-    // CHECK-LABEL: ; internalize_closures::main::{{.*}}closure
-    // CHECK-NEXT: ; Function Attrs:
-    // CHECK-NEXT: define internal
-    let c = |x: i32| x + 1;
-    let _ = c(1);
-}
diff --git a/tests/codegen/intrinsic-no-unnamed-attr.rs b/tests/codegen/intrinsic-no-unnamed-attr.rs
deleted file mode 100644
index 4bec579831d..00000000000
--- a/tests/codegen/intrinsic-no-unnamed-attr.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![feature(core_intrinsics)]
-
-use std::intrinsics::sqrtf32;
-
-// CHECK: @llvm.sqrt.f32(float) #{{[0-9]*}}
-
-fn main() {
-    unsafe {
-        sqrtf32(0.0f32);
-    }
-}
diff --git a/tests/codegen/intrinsics/aggregate-thin-pointer.rs b/tests/codegen/intrinsics/aggregate-thin-pointer.rs
deleted file mode 100644
index bd590ce9180..00000000000
--- a/tests/codegen/intrinsics/aggregate-thin-pointer.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Z mir-enable-passes=-InstSimplify
-//@ only-64bit (so I don't need to worry about usize)
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::aggregate_raw_ptr;
-
-// InstSimplify replaces these with casts if it can, which means they're almost
-// never seen in codegen, but PR#121571 found a way, so add a test for it.
-
-#[inline(never)]
-pub fn opaque(_p: &*const i32) {}
-
-// CHECK-LABEL: @thin_ptr_via_aggregate(
-#[no_mangle]
-pub unsafe fn thin_ptr_via_aggregate(p: *const ()) {
-    // CHECK: %mem = alloca
-    // CHECK: store ptr %p, ptr %mem
-    // CHECK: call {{.+}}aggregate_thin_pointer{{.+}} %mem)
-    let mem = aggregate_raw_ptr(p, ());
-    opaque(&mem);
-}
diff --git a/tests/codegen/intrinsics/carrying_mul_add.rs b/tests/codegen/intrinsics/carrying_mul_add.rs
deleted file mode 100644
index 21fb49a3786..00000000000
--- a/tests/codegen/intrinsics/carrying_mul_add.rs
+++ /dev/null
@@ -1,136 +0,0 @@
-//@ revisions: RAW OPT
-//@ compile-flags: -C opt-level=1
-//@[RAW] compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-#![feature(core_intrinsics_fallbacks)]
-
-// Note that LLVM seems to sometimes permute the order of arguments to mul and add,
-// so these tests don't check the arguments in the optimized revision.
-
-use std::intrinsics::{carrying_mul_add, fallback};
-
-// The fallbacks are emitted even when they're never used, but optimize out.
-
-// RAW: wide_mul_u128
-// OPT-NOT: wide_mul_u128
-
-// CHECK-LABEL: @cma_u8
-#[no_mangle]
-pub unsafe fn cma_u8(a: u8, b: u8, c: u8, d: u8) -> (u8, u8) {
-    // CHECK: [[A:%.+]] = zext i8 %a to i16
-    // CHECK: [[B:%.+]] = zext i8 %b to i16
-    // CHECK: [[C:%.+]] = zext i8 %c to i16
-    // CHECK: [[D:%.+]] = zext i8 %d to i16
-    // CHECK: [[AB:%.+]] = mul nuw i16
-    // RAW-SAME: [[A]], [[B]]
-    // CHECK: [[ABC:%.+]] = add nuw i16
-    // RAW-SAME: [[AB]], [[C]]
-    // CHECK: [[ABCD:%.+]] = add nuw i16
-    // RAW-SAME: [[ABC]], [[D]]
-    // CHECK: [[LOW:%.+]] = trunc i16 [[ABCD]] to i8
-    // CHECK: [[HIGHW:%.+]] = lshr i16 [[ABCD]], 8
-    // RAW: [[HIGH:%.+]] = trunc i16 [[HIGHW]] to i8
-    // OPT: [[HIGH:%.+]] = trunc nuw i16 [[HIGHW]] to i8
-    // CHECK: [[PAIR0:%.+]] = insertvalue { i8, i8 } poison, i8 [[LOW]], 0
-    // CHECK: [[PAIR1:%.+]] = insertvalue { i8, i8 } [[PAIR0]], i8 [[HIGH]], 1
-    // OPT: ret { i8, i8 } [[PAIR1]]
-    carrying_mul_add(a, b, c, d)
-}
-
-// CHECK-LABEL: @cma_u32
-#[no_mangle]
-pub unsafe fn cma_u32(a: u32, b: u32, c: u32, d: u32) -> (u32, u32) {
-    // CHECK: [[A:%.+]] = zext i32 %a to i64
-    // CHECK: [[B:%.+]] = zext i32 %b to i64
-    // CHECK: [[C:%.+]] = zext i32 %c to i64
-    // CHECK: [[D:%.+]] = zext i32 %d to i64
-    // CHECK: [[AB:%.+]] = mul nuw i64
-    // RAW-SAME: [[A]], [[B]]
-    // CHECK: [[ABC:%.+]] = add nuw i64
-    // RAW-SAME: [[AB]], [[C]]
-    // CHECK: [[ABCD:%.+]] = add nuw i64
-    // RAW-SAME: [[ABC]], [[D]]
-    // CHECK: [[LOW:%.+]] = trunc i64 [[ABCD]] to i32
-    // CHECK: [[HIGHW:%.+]] = lshr i64 [[ABCD]], 32
-    // RAW: [[HIGH:%.+]] = trunc i64 [[HIGHW]] to i32
-    // OPT: [[HIGH:%.+]] = trunc nuw i64 [[HIGHW]] to i32
-    // CHECK: [[PAIR0:%.+]] = insertvalue { i32, i32 } poison, i32 [[LOW]], 0
-    // CHECK: [[PAIR1:%.+]] = insertvalue { i32, i32 } [[PAIR0]], i32 [[HIGH]], 1
-    // OPT: ret { i32, i32 } [[PAIR1]]
-    carrying_mul_add(a, b, c, d)
-}
-
-// CHECK-LABEL: @cma_u128
-// CHECK-SAME: sret{{.+}}dereferenceable(32){{.+}}%_0,{{.+}}%a,{{.+}}%b,{{.+}}%c,{{.+}}%d
-#[no_mangle]
-pub unsafe fn cma_u128(a: u128, b: u128, c: u128, d: u128) -> (u128, u128) {
-    // CHECK: [[A:%.+]] = zext i128 %a to i256
-    // CHECK: [[B:%.+]] = zext i128 %b to i256
-    // CHECK: [[C:%.+]] = zext i128 %c to i256
-    // CHECK: [[D:%.+]] = zext i128 %d to i256
-    // CHECK: [[AB:%.+]] = mul nuw i256
-    // RAW-SAME: [[A]], [[B]]
-    // CHECK: [[ABC:%.+]] = add nuw i256
-    // RAW-SAME: [[AB]], [[C]]
-    // CHECK: [[ABCD:%.+]] = add nuw i256
-    // RAW-SAME: [[ABC]], [[D]]
-    // CHECK: [[LOW:%.+]] = trunc i256 [[ABCD]] to i128
-    // CHECK: [[HIGHW:%.+]] = lshr i256 [[ABCD]], 128
-    // RAW: [[HIGH:%.+]] = trunc i256 [[HIGHW]] to i128
-    // OPT: [[HIGH:%.+]] = trunc nuw i256 [[HIGHW]] to i128
-    // RAW: [[PAIR0:%.+]] = insertvalue { i128, i128 } poison, i128 [[LOW]], 0
-    // RAW: [[PAIR1:%.+]] = insertvalue { i128, i128 } [[PAIR0]], i128 [[HIGH]], 1
-    // OPT: store i128 [[LOW]], ptr %_0
-    // OPT: [[P1:%.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %_0, {{i32|i64}} 16
-    // OPT: store i128 [[HIGH]], ptr [[P1]]
-    // CHECK: ret void
-    carrying_mul_add(a, b, c, d)
-}
-
-// CHECK-LABEL: @cma_i128
-// CHECK-SAME: sret{{.+}}dereferenceable(32){{.+}}%_0,{{.+}}%a,{{.+}}%b,{{.+}}%c,{{.+}}%d
-#[no_mangle]
-pub unsafe fn cma_i128(a: i128, b: i128, c: i128, d: i128) -> (u128, i128) {
-    // CHECK: [[A:%.+]] = sext i128 %a to i256
-    // CHECK: [[B:%.+]] = sext i128 %b to i256
-    // CHECK: [[C:%.+]] = sext i128 %c to i256
-    // CHECK: [[D:%.+]] = sext i128 %d to i256
-    // CHECK: [[AB:%.+]] = mul nsw i256
-    // RAW-SAME: [[A]], [[B]]
-    // CHECK: [[ABC:%.+]] = add nsw i256
-    // RAW-SAME: [[AB]], [[C]]
-    // CHECK: [[ABCD:%.+]] = add nsw i256
-    // RAW-SAME: [[ABC]], [[D]]
-    // CHECK: [[LOW:%.+]] = trunc i256 [[ABCD]] to i128
-    // CHECK: [[HIGHW:%.+]] = lshr i256 [[ABCD]], 128
-    // RAW: [[HIGH:%.+]] = trunc i256 [[HIGHW]] to i128
-    // OPT: [[HIGH:%.+]] = trunc nuw i256 [[HIGHW]] to i128
-    // RAW: [[PAIR0:%.+]] = insertvalue { i128, i128 } poison, i128 [[LOW]], 0
-    // RAW: [[PAIR1:%.+]] = insertvalue { i128, i128 } [[PAIR0]], i128 [[HIGH]], 1
-    // OPT: store i128 [[LOW]], ptr %_0
-    // OPT: [[P1:%.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %_0, {{i32|i64}} 16
-    // OPT: store i128 [[HIGH]], ptr [[P1]]
-    // CHECK: ret void
-    carrying_mul_add(a, b, c, d)
-}
-
-// CHECK-LABEL: @fallback_cma_u32
-#[no_mangle]
-pub unsafe fn fallback_cma_u32(a: u32, b: u32, c: u32, d: u32) -> (u32, u32) {
-    // OPT-DAG: [[A:%.+]] = zext i32 %a to i64
-    // OPT-DAG: [[B:%.+]] = zext i32 %b to i64
-    // OPT-DAG: [[AB:%.+]] = mul nuw i64
-    // OPT-DAG: [[C:%.+]] = zext i32 %c to i64
-    // OPT-DAG: [[ABC:%.+]] = add nuw i64{{.+}}[[C]]
-    // OPT-DAG: [[D:%.+]] = zext i32 %d to i64
-    // OPT-DAG: [[ABCD:%.+]] = add nuw i64{{.+}}[[D]]
-    // OPT-DAG: [[LOW:%.+]] = trunc i64 [[ABCD]] to i32
-    // OPT-DAG: [[HIGHW:%.+]] = lshr i64 [[ABCD]], 32
-    // OPT-DAG: [[HIGH:%.+]] = trunc nuw i64 [[HIGHW]] to i32
-    // OPT-DAG: [[PAIR0:%.+]] = insertvalue { i32, i32 } poison, i32 [[LOW]], 0
-    // OPT-DAG: [[PAIR1:%.+]] = insertvalue { i32, i32 } [[PAIR0]], i32 [[HIGH]], 1
-    // OPT-DAG: ret { i32, i32 } [[PAIR1]]
-    fallback::CarryingMulAdd::carrying_mul_add(a, b, c, d)
-}
diff --git a/tests/codegen/intrinsics/cold_path.rs b/tests/codegen/intrinsics/cold_path.rs
deleted file mode 100644
index fd75324b671..00000000000
--- a/tests/codegen/intrinsics/cold_path.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::cold_path;
-
-#[no_mangle]
-pub fn test_cold_path(x: bool) {
-    cold_path();
-}
-
-// CHECK-LABEL: @test_cold_path(
-// CHECK-NOT: cold_path
diff --git a/tests/codegen/intrinsics/cold_path2.rs b/tests/codegen/intrinsics/cold_path2.rs
deleted file mode 100644
index 0891c878fd9..00000000000
--- a/tests/codegen/intrinsics/cold_path2.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//@ compile-flags: -O
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::cold_path;
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_a() {
-    println!("path a");
-}
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_b() {
-    println!("path b");
-}
-
-#[no_mangle]
-pub fn test(x: Option<bool>) {
-    if let Some(_) = x {
-        path_a();
-    } else {
-        cold_path();
-        path_b();
-    }
-
-    // CHECK-LABEL: void @test(i8{{.+}}%x)
-    // CHECK: %[[IS_NONE:.+]] = icmp eq i8 %x, 2
-    // CHECK: br i1 %[[IS_NONE]], label %bb2, label %bb1, !prof ![[NUM:[0-9]+]]
-    // CHECK: bb1:
-    // CHECK: path_a
-    // CHECK: bb2:
-    // CHECK: path_b
-}
-
-// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 1, i32 2000}
diff --git a/tests/codegen/intrinsics/cold_path3.rs b/tests/codegen/intrinsics/cold_path3.rs
deleted file mode 100644
index bf3347de665..00000000000
--- a/tests/codegen/intrinsics/cold_path3.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-//@ compile-flags: -O
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::cold_path;
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_a() {
-    println!("path a");
-}
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_b() {
-    println!("path b");
-}
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_c() {
-    println!("path c");
-}
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_d() {
-    println!("path d");
-}
-
-#[no_mangle]
-pub fn test(x: Option<u32>) {
-    match x {
-        Some(0) => path_a(),
-        Some(1) => {
-            cold_path();
-            path_b()
-        }
-        Some(2) => path_c(),
-        Some(3) => {
-            cold_path();
-            path_d()
-        }
-        _ => path_a(),
-    }
-
-    // CHECK-LABEL: @test(
-    // CHECK: switch i32 %1, label %bb1 [
-    // CHECK: i32 0, label %bb6
-    // CHECK: i32 1, label %bb5
-    // CHECK: i32 2, label %bb4
-    // CHECK: i32 3, label %bb3
-    // CHECK: ], !prof ![[NUM1:[0-9]+]]
-}
-
-#[no_mangle]
-pub fn test2(x: Option<u32>) {
-    match x {
-        Some(10) => path_a(),
-        Some(11) => {
-            cold_path();
-            path_b()
-        }
-        Some(12) => {
-            unsafe { core::intrinsics::unreachable() };
-            path_c()
-        }
-        Some(13) => {
-            cold_path();
-            path_d()
-        }
-        _ => {
-            cold_path();
-            path_a()
-        }
-    }
-
-    // CHECK-LABEL: @test2(
-    // CHECK: switch i32 %1, label %bb1 [
-    // CHECK: i32 10, label %bb5
-    // CHECK: i32 11, label %bb4
-    // CHECK: i32 13, label %bb3
-    // CHECK: ], !prof ![[NUM2:[0-9]+]]
-}
-
-// CHECK: ![[NUM1]] = !{!"branch_weights", i32 2000, i32 2000, i32 1, i32 2000, i32 1}
-// CHECK: ![[NUM2]] = !{!"branch_weights", i32 1, i32 2000, i32 1, i32 1}
diff --git a/tests/codegen/intrinsics/compare_bytes.rs b/tests/codegen/intrinsics/compare_bytes.rs
deleted file mode 100644
index 3ab0e4e97e0..00000000000
--- a/tests/codegen/intrinsics/compare_bytes.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//@ revisions: INT32 INT16
-//@ compile-flags: -Copt-level=3
-//@ [INT32] ignore-16bit
-//@ [INT16] only-16bit
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::compare_bytes;
-
-#[no_mangle]
-// CHECK-LABEL: @bytes_cmp(
-pub unsafe fn bytes_cmp(a: *const u8, b: *const u8, n: usize) -> i32 {
-    // INT32: %[[TEMP:.+]] = tail call i32 @memcmp(ptr %a, ptr %b, {{i32|i64}} %n)
-    // INT32-NOT: sext
-    // INT32: ret i32 %[[TEMP]]
-
-    // INT16: %[[TEMP1:.+]] = tail call i16 @memcmp(ptr %a, ptr %b, i16 %n)
-    // INT16: %[[TEMP2:.+]] = sext i16 %[[TEMP1]] to i32
-    // INT16: ret i32 %[[TEMP2]]
-    compare_bytes(a, b, n)
-}
-
-// Ensure that, even though there's an `sext` emitted by the intrinsic,
-// that doesn't end up pessiming checks against zero.
-#[no_mangle]
-// CHECK-LABEL: @bytes_eq(
-pub unsafe fn bytes_eq(a: *const u8, b: *const u8, n: usize) -> bool {
-    // CHECK: call {{.+}} @{{bcmp|memcmp}}(ptr %a, ptr %b, {{i16|i32|i64}} %n)
-    // CHECK-NOT: sext
-    // INT32: icmp eq i32
-    // INT16: icmp eq i16
-    compare_bytes(a, b, n) == 0_i32
-}
diff --git a/tests/codegen/intrinsics/const_eval_select.rs b/tests/codegen/intrinsics/const_eval_select.rs
deleted file mode 100644
index baa985b00cd..00000000000
--- a/tests/codegen/intrinsics/const_eval_select.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(const_eval_select)]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::const_eval_select;
-
-const fn foo(_: i32) -> i32 {
-    1
-}
-
-#[no_mangle]
-pub fn hi(n: i32) -> i32 {
-    n
-}
-
-#[no_mangle]
-pub unsafe fn hey() {
-    // CHECK: call i32 @hi(i32
-    const_eval_select((42,), foo, hi);
-}
diff --git a/tests/codegen/intrinsics/ctlz.rs b/tests/codegen/intrinsics/ctlz.rs
deleted file mode 100644
index 0d54d21ce12..00000000000
--- a/tests/codegen/intrinsics/ctlz.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::{ctlz, ctlz_nonzero};
-
-// CHECK-LABEL: @ctlz_u16
-#[no_mangle]
-pub unsafe fn ctlz_u16(x: u16) -> u32 {
-    // CHECK: %[[tmp:.*]] = call i16 @llvm.ctlz.i16(i16 %x, i1 false)
-    // CHECK: zext i16 %[[tmp]] to i32
-    ctlz(x)
-}
-
-// CHECK-LABEL: @ctlz_nzu16
-#[no_mangle]
-pub unsafe fn ctlz_nzu16(x: u16) -> u32 {
-    // CHECK: %[[tmp:.*]] = call i16 @llvm.ctlz.i16(i16 %x, i1 true)
-    // CHECK: zext i16 %[[tmp]] to i32
-    ctlz_nonzero(x)
-}
-
-// CHECK-LABEL: @ctlz_u32
-#[no_mangle]
-pub unsafe fn ctlz_u32(x: u32) -> u32 {
-    // CHECK: call i32 @llvm.ctlz.i32(i32 %x, i1 false)
-    // CHECK-NOT: zext
-    // CHECK-NOT: trunc
-    ctlz(x)
-}
-
-// CHECK-LABEL: @ctlz_nzu32
-#[no_mangle]
-pub unsafe fn ctlz_nzu32(x: u32) -> u32 {
-    // CHECK: call i32 @llvm.ctlz.i32(i32 %x, i1 true)
-    // CHECK-NOT: zext
-    // CHECK-NOT: trunc
-    ctlz_nonzero(x)
-}
-
-// CHECK-LABEL: @ctlz_u64
-#[no_mangle]
-pub unsafe fn ctlz_u64(x: u64) -> u32 {
-    // CHECK: %[[tmp:.*]] = call i64 @llvm.ctlz.i64(i64 %x, i1 false)
-    // CHECK: trunc i64 %[[tmp]] to i32
-    ctlz(x)
-}
-
-// CHECK-LABEL: @ctlz_nzu64
-#[no_mangle]
-pub unsafe fn ctlz_nzu64(x: u64) -> u32 {
-    // CHECK: %[[tmp:.*]] = call i64 @llvm.ctlz.i64(i64 %x, i1 true)
-    // CHECK: trunc i64 %[[tmp]] to i32
-    ctlz_nonzero(x)
-}
diff --git a/tests/codegen/intrinsics/ctpop.rs b/tests/codegen/intrinsics/ctpop.rs
deleted file mode 100644
index f4043325de9..00000000000
--- a/tests/codegen/intrinsics/ctpop.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::ctpop;
-
-// CHECK-LABEL: @ctpop_u16
-#[no_mangle]
-pub unsafe fn ctpop_u16(x: u16) -> u32 {
-    // CHECK: %[[tmp:.*]] = call i16 @llvm.ctpop.i16(i16 %x)
-    // CHECK: zext i16 %[[tmp]] to i32
-    ctpop(x)
-}
-
-// CHECK-LABEL: @ctpop_u32
-#[no_mangle]
-pub unsafe fn ctpop_u32(x: u32) -> u32 {
-    // CHECK: call i32 @llvm.ctpop.i32(i32 %x)
-    // CHECK-NOT: zext
-    // CHECK-NOT: trunc
-    ctpop(x)
-}
-
-// CHECK-LABEL: @ctpop_u64
-#[no_mangle]
-pub unsafe fn ctpop_u64(x: u64) -> u32 {
-    // CHECK: %[[tmp:.*]] = call i64 @llvm.ctpop.i64(i64 %x)
-    // CHECK: trunc i64 %[[tmp]] to i32
-    ctpop(x)
-}
diff --git a/tests/codegen/intrinsics/disjoint_bitor.rs b/tests/codegen/intrinsics/disjoint_bitor.rs
deleted file mode 100644
index fc45439ee0b..00000000000
--- a/tests/codegen/intrinsics/disjoint_bitor.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Z mir-opt-level=0
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::disjoint_bitor;
-
-// CHECK-LABEL: @disjoint_bitor_signed
-#[no_mangle]
-pub unsafe fn disjoint_bitor_signed(x: i32, y: i32) -> i32 {
-    // CHECK: or disjoint i32 %x, %y
-    disjoint_bitor(x, y)
-}
-
-// CHECK-LABEL: @disjoint_bitor_unsigned
-#[no_mangle]
-pub unsafe fn disjoint_bitor_unsigned(x: u64, y: u64) -> u64 {
-    // CHECK: or disjoint i64 %x, %y
-    disjoint_bitor(x, y)
-}
-
-// CHECK-LABEL: @disjoint_bitor_literal
-#[no_mangle]
-pub unsafe fn disjoint_bitor_literal() -> u8 {
-    // This is a separate check because even without any passes,
-    // LLVM will fold so it's not an instruction, which can assert in LLVM.
-
-    // CHECK: store i8 3
-    disjoint_bitor(1, 2)
-}
diff --git a/tests/codegen/intrinsics/exact_div.rs b/tests/codegen/intrinsics/exact_div.rs
deleted file mode 100644
index dc625ba7fe4..00000000000
--- a/tests/codegen/intrinsics/exact_div.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::exact_div;
-
-// CHECK-LABEL: @exact_sdiv
-#[no_mangle]
-pub unsafe fn exact_sdiv(x: i32, y: i32) -> i32 {
-    // CHECK: sdiv exact
-    exact_div(x, y)
-}
-
-// CHECK-LABEL: @exact_udiv
-#[no_mangle]
-pub unsafe fn exact_udiv(x: u32, y: u32) -> u32 {
-    // CHECK: udiv exact
-    exact_div(x, y)
-}
diff --git a/tests/codegen/intrinsics/likely.rs b/tests/codegen/intrinsics/likely.rs
deleted file mode 100644
index c5e3c466f45..00000000000
--- a/tests/codegen/intrinsics/likely.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::likely;
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_a() {
-    println!("path a");
-}
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_b() {
-    println!("path b");
-}
-
-#[no_mangle]
-pub fn test_likely(x: bool) {
-    if likely(x) {
-        path_a();
-    } else {
-        path_b();
-    }
-}
-
-// CHECK-LABEL: @test_likely(
-// CHECK: br i1 %x, label %bb2, label %bb3, !prof ![[NUM:[0-9]+]]
-// CHECK: bb3:
-// CHECK-NOT: cold_path
-// CHECK: path_b
-// CHECK: bb2:
-// CHECK: path_a
-// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 2000, i32 1}
diff --git a/tests/codegen/intrinsics/likely_assert.rs b/tests/codegen/intrinsics/likely_assert.rs
deleted file mode 100644
index 87ffb4ee3fb..00000000000
--- a/tests/codegen/intrinsics/likely_assert.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn test_assert(x: bool) {
-    assert!(x);
-}
-
-// check that assert! emits branch weights
-
-// CHECK-LABEL: @test_assert(
-// CHECK: br i1 %x, label %bb2, label %bb1, !prof ![[NUM:[0-9]+]]
-// CHECK: bb1:
-// CHECK: panic
-// CHECK: bb2:
-// CHECK: ret void
-// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 2000, i32 1}
diff --git a/tests/codegen/intrinsics/mask.rs b/tests/codegen/intrinsics/mask.rs
deleted file mode 100644
index 5344274678c..00000000000
--- a/tests/codegen/intrinsics/mask.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ compile-flags: -Copt-level=0
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-// CHECK-LABEL: @mask_ptr
-// CHECK-SAME: [[WORD:i[0-9]+]] %mask
-#[no_mangle]
-pub fn mask_ptr(ptr: *const u16, mask: usize) -> *const u16 {
-    // CHECK: call
-    // CHECK-SAME: @llvm.ptrmask.{{p0|p0i8}}.[[WORD]](ptr {{%ptr|%1}}, [[WORD]] %mask)
-    core::intrinsics::ptr_mask(ptr, mask)
-}
diff --git a/tests/codegen/intrinsics/nontemporal.rs b/tests/codegen/intrinsics/nontemporal.rs
deleted file mode 100644
index a151d4bd297..00000000000
--- a/tests/codegen/intrinsics/nontemporal.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3
-//@revisions: with_nontemporal without_nontemporal
-//@[with_nontemporal] compile-flags: --target aarch64-unknown-linux-gnu
-//@[with_nontemporal] needs-llvm-components: aarch64
-//@[without_nontemporal] compile-flags: --target x86_64-unknown-linux-gnu
-//@[without_nontemporal] needs-llvm-components: x86
-
-// Ensure that we *do* emit the `!nontemporal` flag on architectures where it
-// is well-behaved, but do *not* emit it on architectures where it is ill-behaved.
-// For more context, see <https://github.com/rust-lang/rust/issues/114582> and
-// <https://github.com/llvm/llvm-project/issues/64521>.
-
-#![feature(no_core, lang_items, intrinsics)]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-#[rustc_intrinsic]
-pub unsafe fn nontemporal_store<T>(ptr: *mut T, val: T);
-
-#[no_mangle]
-pub fn a(a: &mut u32, b: u32) {
-    // CHECK-LABEL: define{{.*}}void @a
-    // with_nontemporal: store i32 %b, ptr %a, align 4, !nontemporal
-    // without_nontemporal-NOT: nontemporal
-    unsafe {
-        nontemporal_store(a, b);
-    }
-}
diff --git a/tests/codegen/intrinsics/offset.rs b/tests/codegen/intrinsics/offset.rs
deleted file mode 100644
index cf0c7c7ac7d..00000000000
--- a/tests/codegen/intrinsics/offset.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::offset;
-
-// CHECK-LABEL: ptr @offset_zst
-// CHECK-SAME: (ptr noundef %p, [[SIZE:i[0-9]+]] noundef %d)
-#[no_mangle]
-pub unsafe fn offset_zst(p: *const (), d: usize) -> *const () {
-    // CHECK-NOT: getelementptr
-    // CHECK: ret ptr %p
-    offset(p, d)
-}
-
-// CHECK-LABEL: ptr @offset_isize
-// CHECK-SAME: (ptr noundef %p, [[SIZE]] noundef %d)
-#[no_mangle]
-pub unsafe fn offset_isize(p: *const u32, d: isize) -> *const u32 {
-    // CHECK: %[[R:.*]] = getelementptr inbounds i32, ptr %p, [[SIZE]] %d
-    // CHECK-NEXT: ret ptr %[[R]]
-    offset(p, d)
-}
-
-// CHECK-LABEL: ptr @offset_usize
-// CHECK-SAME: (ptr noundef %p, [[SIZE]] noundef %d)
-#[no_mangle]
-pub unsafe fn offset_usize(p: *const u64, d: usize) -> *const u64 {
-    // CHECK: %[[R:.*]] = getelementptr inbounds{{( nuw)?}} i64, ptr %p, [[SIZE]] %d
-    // CHECK-NEXT: ret ptr %[[R]]
-    offset(p, d)
-}
diff --git a/tests/codegen/intrinsics/offset_from.rs b/tests/codegen/intrinsics/offset_from.rs
deleted file mode 100644
index ef1a77ef184..00000000000
--- a/tests/codegen/intrinsics/offset_from.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ compile-flags: -C opt-level=1
-//@ only-64bit (because we're using [ui]size)
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-//! Basic optimizations are enabled because otherwise `x86_64-gnu-nopt` had an alloca.
-//! Uses a type with non-power-of-two size to avoid normalizations to shifts.
-
-use std::intrinsics::*;
-
-type RGB = [u8; 3];
-
-// CHECK-LABEL: @offset_from_odd_size
-#[no_mangle]
-pub unsafe fn offset_from_odd_size(a: *const RGB, b: *const RGB) -> isize {
-    // CHECK: start
-    // CHECK-NEXT: ptrtoint
-    // CHECK-NEXT: ptrtoint
-    // CHECK-NEXT: sub i64
-    // CHECK-NEXT: sdiv exact i64 %{{[0-9]+}}, 3
-    // CHECK-NEXT: ret i64
-    ptr_offset_from(a, b)
-}
-
-// CHECK-LABEL: @offset_from_unsigned_odd_size
-#[no_mangle]
-pub unsafe fn offset_from_unsigned_odd_size(a: *const RGB, b: *const RGB) -> usize {
-    // CHECK: start
-    // CHECK-NEXT: ptrtoint
-    // CHECK-NEXT: ptrtoint
-    // CHECK-NEXT: sub nuw i64
-    // CHECK-NEXT: udiv exact i64 %{{[0-9]+}}, 3
-    // CHECK-NEXT: ret i64
-    ptr_offset_from_unsigned(a, b)
-}
diff --git a/tests/codegen/intrinsics/prefetch.rs b/tests/codegen/intrinsics/prefetch.rs
deleted file mode 100644
index 3f9f21c85cb..00000000000
--- a/tests/codegen/intrinsics/prefetch.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::{
-    prefetch_read_data, prefetch_read_instruction, prefetch_write_data, prefetch_write_instruction,
-};
-
-#[no_mangle]
-pub fn check_prefetch_read_data(data: &[i8]) {
-    unsafe {
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 0, i32 1)
-        prefetch_read_data(data.as_ptr(), 0);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 1, i32 1)
-        prefetch_read_data(data.as_ptr(), 1);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 2, i32 1)
-        prefetch_read_data(data.as_ptr(), 2);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 3, i32 1)
-        prefetch_read_data(data.as_ptr(), 3);
-    }
-}
-
-#[no_mangle]
-pub fn check_prefetch_write_data(data: &[i8]) {
-    unsafe {
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 0, i32 1)
-        prefetch_write_data(data.as_ptr(), 0);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 1, i32 1)
-        prefetch_write_data(data.as_ptr(), 1);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 2, i32 1)
-        prefetch_write_data(data.as_ptr(), 2);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 3, i32 1)
-        prefetch_write_data(data.as_ptr(), 3);
-    }
-}
-
-#[no_mangle]
-pub fn check_prefetch_read_instruction(data: &[i8]) {
-    unsafe {
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 0, i32 0)
-        prefetch_read_instruction(data.as_ptr(), 0);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 1, i32 0)
-        prefetch_read_instruction(data.as_ptr(), 1);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 2, i32 0)
-        prefetch_read_instruction(data.as_ptr(), 2);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 0, i32 3, i32 0)
-        prefetch_read_instruction(data.as_ptr(), 3);
-    }
-}
-
-#[no_mangle]
-pub fn check_prefetch_write_instruction(data: &[i8]) {
-    unsafe {
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 0, i32 0)
-        prefetch_write_instruction(data.as_ptr(), 0);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 1, i32 0)
-        prefetch_write_instruction(data.as_ptr(), 1);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 2, i32 0)
-        prefetch_write_instruction(data.as_ptr(), 2);
-        // CHECK: call void @llvm.prefetch{{.*}}({{.*}}, i32 1, i32 3, i32 0)
-        prefetch_write_instruction(data.as_ptr(), 3);
-    }
-}
diff --git a/tests/codegen/intrinsics/ptr_metadata.rs b/tests/codegen/intrinsics/ptr_metadata.rs
deleted file mode 100644
index 044dbc20486..00000000000
--- a/tests/codegen/intrinsics/ptr_metadata.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Z inline-mir
-//@ only-64bit (so I don't need to worry about usize)
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::ptr_metadata;
-
-// CHECK-LABEL: @thin_metadata(
-#[no_mangle]
-pub fn thin_metadata(p: *const ()) {
-    // CHECK: start
-    // CHECK-NEXT: ret void
-    ptr_metadata(p)
-}
-
-// CHECK-LABEL: @slice_metadata(
-#[no_mangle]
-pub fn slice_metadata(p: *const [u8]) -> usize {
-    // CHECK: start
-    // CHECK-NEXT: ret i64 %p.1
-    ptr_metadata(p)
-}
-
-// CHECK-LABEL: @dyn_byte_offset(
-#[no_mangle]
-pub unsafe fn dyn_byte_offset(
-    p: *const dyn std::fmt::Debug,
-    n: usize,
-) -> *const dyn std::fmt::Debug {
-    // CHECK: %[[Q:.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %p.0, i64 %n
-    // CHECK: %[[TEMP1:.+]] = insertvalue { ptr, ptr } poison, ptr %[[Q]], 0
-    // CHECK: %[[TEMP2:.+]] = insertvalue { ptr, ptr } %[[TEMP1]], ptr %p.1, 1
-    // CHECK: ret { ptr, ptr } %[[TEMP2]]
-    p.byte_add(n)
-}
diff --git a/tests/codegen/intrinsics/rotate_left.rs b/tests/codegen/intrinsics/rotate_left.rs
deleted file mode 100644
index 4f6c5cbaed6..00000000000
--- a/tests/codegen/intrinsics/rotate_left.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::rotate_left;
-
-// CHECK-LABEL: @rotate_left_u16
-#[no_mangle]
-pub unsafe fn rotate_left_u16(x: u16, shift: u32) -> u16 {
-    // CHECK: %[[tmp:.*]] = trunc i32 %shift to i16
-    // CHECK: call i16 @llvm.fshl.i16(i16 %x, i16 %x, i16 %[[tmp]])
-    rotate_left(x, shift)
-}
-
-// CHECK-LABEL: @rotate_left_u32
-#[no_mangle]
-pub unsafe fn rotate_left_u32(x: u32, shift: u32) -> u32 {
-    // CHECK-NOT: trunc
-    // CHECK-NOT: zext
-    // CHECK: call i32 @llvm.fshl.i32(i32 %x, i32 %x, i32 %shift)
-    rotate_left(x, shift)
-}
-
-// CHECK-LABEL: @rotate_left_u64
-#[no_mangle]
-pub unsafe fn rotate_left_u64(x: u64, shift: u32) -> u64 {
-    // CHECK: %[[tmp:.*]] = zext i32 %shift to i64
-    // CHECK: call i64 @llvm.fshl.i64(i64 %x, i64 %x, i64 %[[tmp]])
-    rotate_left(x, shift)
-}
diff --git a/tests/codegen/intrinsics/rustc_intrinsic_must_be_overridden.rs b/tests/codegen/intrinsics/rustc_intrinsic_must_be_overridden.rs
deleted file mode 100644
index b41e441d309..00000000000
--- a/tests/codegen/intrinsics/rustc_intrinsic_must_be_overridden.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ revisions: OPT0 OPT1
-//@ [OPT0] compile-flags: -Copt-level=0
-//@ [OPT1] compile-flags: -Copt-level=1
-//@ compile-flags: -Cno-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-// CHECK-NOT: core::intrinsics::size_of_val
-
-#[no_mangle]
-pub unsafe fn size_of_val(ptr: *const i32) -> usize {
-    core::intrinsics::size_of_val(ptr)
-}
diff --git a/tests/codegen/intrinsics/select_unpredictable.rs b/tests/codegen/intrinsics/select_unpredictable.rs
deleted file mode 100644
index ad7120c6fb8..00000000000
--- a/tests/codegen/intrinsics/select_unpredictable.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-
-#![feature(core_intrinsics)]
-#![crate_type = "lib"]
-
-/* Test the intrinsic */
-
-#[no_mangle]
-pub fn test_int(p: bool, a: u64, b: u64) -> u64 {
-    // CHECK-LABEL: define{{.*}} @test_int
-    // CHECK: select i1 %p, i64 %a, i64 %b, !unpredictable
-    core::intrinsics::select_unpredictable(p, a, b)
-}
-
-#[no_mangle]
-pub fn test_pair(p: bool, a: (u64, u64), b: (u64, u64)) -> (u64, u64) {
-    // CHECK-LABEL: define{{.*}} @test_pair
-    // CHECK: select i1 %p, {{.*}}, !unpredictable
-    core::intrinsics::select_unpredictable(p, a, b)
-}
-
-struct Large {
-    e: [u64; 100],
-}
-
-#[no_mangle]
-pub fn test_struct(p: bool, a: Large, b: Large) -> Large {
-    // CHECK-LABEL: define{{.*}} @test_struct
-    // CHECK: select i1 %p, {{.*}}, !unpredictable
-    core::intrinsics::select_unpredictable(p, a, b)
-}
-
-// ZSTs should not need a `select` expression.
-#[no_mangle]
-pub fn test_zst(p: bool, a: (), b: ()) -> () {
-    // CHECK-LABEL: define{{.*}} @test_zst
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret void
-    core::intrinsics::select_unpredictable(p, a, b)
-}
-
-/* Test the user-facing version */
-
-#[no_mangle]
-pub fn test_int2(p: bool, a: u64, b: u64) -> u64 {
-    // CHECK-LABEL: define{{.*}} @test_int2
-    // CHECK: select i1 %p, i64 %a, i64 %b, !unpredictable
-    core::hint::select_unpredictable(p, a, b)
-}
-
-#[no_mangle]
-pub fn test_pair2(p: bool, a: (u64, u64), b: (u64, u64)) -> (u64, u64) {
-    // CHECK-LABEL: define{{.*}} @test_pair2
-    // CHECK: select i1 %p, {{.*}}, !unpredictable
-    core::hint::select_unpredictable(p, a, b)
-}
-
-#[no_mangle]
-pub fn test_struct2(p: bool, a: Large, b: Large) -> Large {
-    // CHECK-LABEL: define{{.*}} @test_struct2
-    // CHECK: select i1 %p, {{.*}}, !unpredictable
-    core::hint::select_unpredictable(p, a, b)
-}
-
-#[no_mangle]
-pub fn test_zst2(p: bool, a: (), b: ()) -> () {
-    // CHECK-LABEL: define{{.*}} @test_zst2
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret void
-    core::hint::select_unpredictable(p, a, b)
-}
diff --git a/tests/codegen/intrinsics/three_way_compare.rs b/tests/codegen/intrinsics/three_way_compare.rs
deleted file mode 100644
index 95fcb636f7c..00000000000
--- a/tests/codegen/intrinsics/three_way_compare.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ revisions: DEBUG OPTIM
-//@ [DEBUG] compile-flags: -C opt-level=0
-//@ [OPTIM] compile-flags: -C opt-level=3
-//@ compile-flags: -C no-prepopulate-passes
-//@ min-llvm-version: 20
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::three_way_compare;
-
-#[no_mangle]
-// CHECK-LABEL: @signed_cmp
-// CHECK-SAME: (i16{{.*}} %a, i16{{.*}} %b)
-pub fn signed_cmp(a: i16, b: i16) -> std::cmp::Ordering {
-    // CHECK: %[[CMP:.+]] = call i8 @llvm.scmp.i8.i16(i16 %a, i16 %b)
-    // CHECK-NEXT: ret i8 %[[CMP]]
-    three_way_compare(a, b)
-}
-
-#[no_mangle]
-// CHECK-LABEL: @unsigned_cmp
-// CHECK-SAME: (i16{{.*}} %a, i16{{.*}} %b)
-pub fn unsigned_cmp(a: u16, b: u16) -> std::cmp::Ordering {
-    // CHECK: %[[CMP:.+]] = call i8 @llvm.ucmp.i8.i16(i16 %a, i16 %b)
-    // CHECK-NEXT: ret i8 %[[CMP]]
-    three_way_compare(a, b)
-}
diff --git a/tests/codegen/intrinsics/transmute-niched.rs b/tests/codegen/intrinsics/transmute-niched.rs
deleted file mode 100644
index 8ff5cc8ee4f..00000000000
--- a/tests/codegen/intrinsics/transmute-niched.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-//@ revisions: OPT DBG
-//@ [OPT] compile-flags: -C opt-level=3 -C no-prepopulate-passes
-//@ [DBG] compile-flags: -C opt-level=0 -C no-prepopulate-passes
-//@ only-64bit (so I don't need to worry about usize)
-#![crate_type = "lib"]
-
-use std::mem::transmute;
-use std::num::NonZero;
-use std::ptr::NonNull;
-
-#[repr(u8)]
-pub enum SmallEnum {
-    A = 10,
-    B = 11,
-    C = 12,
-}
-
-// CHECK-LABEL: @check_to_enum(
-#[no_mangle]
-pub unsafe fn check_to_enum(x: i8) -> SmallEnum {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // OPT: %0 = sub i8 %x, 10
-    // OPT: %1 = icmp ule i8 %0, 2
-    // OPT: call void @llvm.assume(i1 %1)
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // CHECK: ret i8 %x
-
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_from_enum(
-#[no_mangle]
-pub unsafe fn check_from_enum(x: SmallEnum) -> i8 {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // OPT: %0 = sub i8 %x, 10
-    // OPT: %1 = icmp ule i8 %0, 2
-    // OPT: call void @llvm.assume(i1 %1)
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // CHECK: ret i8 %x
-
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_to_ordering(
-#[no_mangle]
-pub unsafe fn check_to_ordering(x: u8) -> std::cmp::Ordering {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // OPT: %0 = sub i8 %x, -1
-    // OPT: %1 = icmp ule i8 %0, 2
-    // OPT: call void @llvm.assume(i1 %1)
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // CHECK: ret i8 %x
-
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_from_ordering(
-#[no_mangle]
-pub unsafe fn check_from_ordering(x: std::cmp::Ordering) -> u8 {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // OPT: %0 = sub i8 %x, -1
-    // OPT: %1 = icmp ule i8 %0, 2
-    // OPT: call void @llvm.assume(i1 %1)
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // CHECK: ret i8 %x
-
-    transmute(x)
-}
-
-#[repr(i32)]
-pub enum Minus100ToPlus100 {
-    A = -100,
-    B = -90,
-    C = -80,
-    D = -70,
-    E = -60,
-    F = -50,
-    G = -40,
-    H = -30,
-    I = -20,
-    J = -10,
-    K = 0,
-    L = 10,
-    M = 20,
-    N = 30,
-    O = 40,
-    P = 50,
-    Q = 60,
-    R = 70,
-    S = 80,
-    T = 90,
-    U = 100,
-}
-
-// CHECK-LABEL: @check_enum_from_char(
-#[no_mangle]
-pub unsafe fn check_enum_from_char(x: char) -> Minus100ToPlus100 {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // OPT: %0 = icmp ule i32 %x, 1114111
-    // OPT: call void @llvm.assume(i1 %0)
-    // OPT: %1 = sub i32 %x, -100
-    // OPT: %2 = icmp ule i32 %1, 200
-    // OPT: call void @llvm.assume(i1 %2)
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // CHECK: ret i32 %x
-
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_enum_to_char(
-#[no_mangle]
-pub unsafe fn check_enum_to_char(x: Minus100ToPlus100) -> char {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // OPT: %0 = sub i32 %x, -100
-    // OPT: %1 = icmp ule i32 %0, 200
-    // OPT: call void @llvm.assume(i1 %1)
-    // OPT: %2 = icmp ule i32 %x, 1114111
-    // OPT: call void @llvm.assume(i1 %2)
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // CHECK: ret i32 %x
-
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_swap_pair(
-#[no_mangle]
-pub unsafe fn check_swap_pair(x: (char, NonZero<u32>)) -> (NonZero<u32>, char) {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // OPT: %0 = icmp ule i32 %x.0, 1114111
-    // OPT: call void @llvm.assume(i1 %0)
-    // OPT: %1 = sub i32 %x.0, 1
-    // OPT: %2 = icmp ule i32 %1, -2
-    // OPT: call void @llvm.assume(i1 %2)
-    // OPT: %3 = sub i32 %x.1, 1
-    // OPT: %4 = icmp ule i32 %3, -2
-    // OPT: call void @llvm.assume(i1 %4)
-    // OPT: %5 = icmp ule i32 %x.1, 1114111
-    // OPT: call void @llvm.assume(i1 %5)
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // CHECK: %[[P1:.+]] = insertvalue { i32, i32 } poison, i32 %x.0, 0
-    // CHECK: %[[P2:.+]] = insertvalue { i32, i32 } %[[P1]], i32 %x.1, 1
-    // CHECK: ret { i32, i32 } %[[P2]]
-
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_bool_from_ordering(
-#[no_mangle]
-pub unsafe fn check_bool_from_ordering(x: std::cmp::Ordering) -> bool {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // OPT: %0 = sub i8 %x, -1
-    // OPT: %1 = icmp ule i8 %0, 2
-    // OPT: call void @llvm.assume(i1 %1)
-    // OPT: %2 = icmp ule i8 %x, 1
-    // OPT: call void @llvm.assume(i1 %2)
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // CHECK: %[[R:.+]] = trunc{{( nuw)?}} i8 %x to i1
-    // CHECK: ret i1 %[[R]]
-
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_bool_to_ordering(
-#[no_mangle]
-pub unsafe fn check_bool_to_ordering(x: bool) -> std::cmp::Ordering {
-    // CHECK: %_0 = zext i1 %x to i8
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // OPT: %0 = icmp ule i8 %_0, 1
-    // OPT: call void @llvm.assume(i1 %0)
-    // OPT: %1 = sub i8 %_0, -1
-    // OPT: %2 = icmp ule i8 %1, 2
-    // OPT: call void @llvm.assume(i1 %2)
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // CHECK: ret i8 %_0
-
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_nonnull_to_ptr(
-#[no_mangle]
-pub unsafe fn check_nonnull_to_ptr(x: NonNull<u8>) -> *const u8 {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // OPT: %0 = icmp ne ptr %x, null
-    // OPT: call void @llvm.assume(i1 %0)
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // CHECK: ret ptr %x
-
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_ptr_to_nonnull(
-#[no_mangle]
-pub unsafe fn check_ptr_to_nonnull(x: *const u8) -> NonNull<u8> {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // OPT: %0 = icmp ne ptr %x, null
-    // OPT: call void @llvm.assume(i1 %0)
-    // CHECK-NOT: icmp
-    // CHECK-NOT: assume
-    // CHECK: ret ptr %x
-
-    transmute(x)
-}
diff --git a/tests/codegen/intrinsics/transmute-x64.rs b/tests/codegen/intrinsics/transmute-x64.rs
deleted file mode 100644
index 8c9480ab091..00000000000
--- a/tests/codegen/intrinsics/transmute-x64.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-//@ only-x86_64 (it's using arch-specific types)
-
-#![crate_type = "lib"]
-
-use std::arch::x86_64::{__m128, __m128i, __m256i};
-use std::mem::transmute;
-
-// CHECK-LABEL: @check_sse_pair_to_avx(
-#[no_mangle]
-pub unsafe fn check_sse_pair_to_avx(x: (__m128i, __m128i)) -> __m256i {
-    // CHECK: start:
-    // CHECK-NOT: alloca
-    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 32 %_0, ptr align 16 %x, i64 32, i1 false)
-    // CHECK-NEXT: ret void
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_sse_pair_from_avx(
-#[no_mangle]
-pub unsafe fn check_sse_pair_from_avx(x: __m256i) -> (__m128i, __m128i) {
-    // CHECK: start:
-    // CHECK-NOT: alloca
-    // CHECK-NEXT: %[[TEMP:.+]] = load <4 x i64>, ptr %x, align 32
-    // CHECK-NEXT: store <4 x i64> %[[TEMP]], ptr %_0, align 16
-    // CHECK-NEXT: ret void
-    transmute(x)
-}
diff --git a/tests/codegen/intrinsics/transmute.rs b/tests/codegen/intrinsics/transmute.rs
deleted file mode 100644
index c9a1cd58af3..00000000000
--- a/tests/codegen/intrinsics/transmute.rs
+++ /dev/null
@@ -1,497 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-//@ only-64bit (so I don't need to worry about usize)
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-#![feature(custom_mir)]
-#![allow(unreachable_code)]
-
-// Some of these need custom MIR to not get removed by MIR optimizations.
-use std::intrinsics::mir::*;
-use std::intrinsics::{transmute, transmute_unchecked};
-use std::mem::MaybeUninit;
-use std::num::NonZero;
-
-pub enum ZstNever {}
-
-#[repr(align(2))]
-pub struct BigNever(ZstNever, u16, ZstNever);
-
-#[repr(align(8))]
-pub struct Scalar64(i64);
-
-#[repr(C, align(4))]
-pub struct Aggregate64(u16, u8, i8, f32);
-
-#[repr(C)]
-pub struct Aggregate8(u8);
-
-// CHECK-LABEL: @check_bigger_size(
-#[no_mangle]
-pub unsafe fn check_bigger_size(x: u16) -> u32 {
-    // CHECK: store i1 true, ptr poison, align 1
-    transmute_unchecked(x)
-}
-
-// CHECK-LABEL: @check_smaller_size(
-#[no_mangle]
-pub unsafe fn check_smaller_size(x: u32) -> u16 {
-    // CHECK: store i1 true, ptr poison, align 1
-    transmute_unchecked(x)
-}
-
-// CHECK-LABEL: @check_smaller_array(
-#[no_mangle]
-pub unsafe fn check_smaller_array(x: [u32; 7]) -> [u32; 3] {
-    // CHECK: store i1 true, ptr poison, align 1
-    transmute_unchecked(x)
-}
-
-// CHECK-LABEL: @check_bigger_array(
-#[no_mangle]
-pub unsafe fn check_bigger_array(x: [u32; 3]) -> [u32; 7] {
-    // CHECK: store i1 true, ptr poison, align 1
-    transmute_unchecked(x)
-}
-
-// CHECK-LABEL: @check_to_empty_array(
-#[no_mangle]
-#[custom_mir(dialect = "runtime", phase = "optimized")]
-pub unsafe fn check_to_empty_array(x: [u32; 5]) -> [u32; 0] {
-    // CHECK: start
-    // CHECK-NEXT: store i1 true, ptr poison, align 1
-    // CHECK-NEXT: ret void
-    mir! {
-        {
-            RET = CastTransmute(x);
-            Return()
-        }
-    }
-}
-
-// CHECK-LABEL: @check_from_empty_array(
-#[no_mangle]
-#[custom_mir(dialect = "runtime", phase = "optimized")]
-pub unsafe fn check_from_empty_array(x: [u32; 0]) -> [u32; 5] {
-    // CHECK: start
-    // CHECK-NEXT: store i1 true, ptr poison, align 1
-    // CHECK-NEXT: ret void
-    mir! {
-        {
-            RET = CastTransmute(x);
-            Return()
-        }
-    }
-}
-
-// CHECK-LABEL: @check_to_uninhabited(
-#[no_mangle]
-#[custom_mir(dialect = "runtime", phase = "optimized")]
-pub unsafe fn check_to_uninhabited(x: u16) {
-    // CHECK: start
-    // CHECK-NEXT: store i1 true, ptr poison, align 1
-    // CHECK-NEXT: ret void
-    mir! {
-        let temp: BigNever;
-        {
-            temp = CastTransmute(x);
-            Return()
-        }
-    }
-}
-
-// CHECK-LABEL: @check_from_uninhabited(
-#[no_mangle]
-#[custom_mir(dialect = "runtime", phase = "optimized")]
-pub unsafe fn check_from_uninhabited(x: BigNever) -> u16 {
-    // CHECK: start
-    // CHECK-NEXT: store i1 true, ptr poison, align 1
-    // CHECK-NEXT: ret i16 poison
-    mir! {
-        {
-            RET = CastTransmute(x);
-            Return()
-        }
-    }
-}
-
-// CHECK-LABEL: @check_intermediate_passthrough(
-#[no_mangle]
-pub unsafe fn check_intermediate_passthrough(x: u32) -> i32 {
-    // CHECK: start
-    // CHECK: %[[TMP:.+]] = add i32 1, %x
-    // CHECK: %[[RET:.+]] = add i32 %[[TMP]], 1
-    // CHECK: ret i32 %[[RET]]
-    unsafe { transmute::<u32, i32>(1 + x) + 1 }
-}
-
-// CHECK-LABEL: @check_nop_pair(
-#[no_mangle]
-pub unsafe fn check_nop_pair(x: (u8, i8)) -> (i8, u8) {
-    // CHECK-NOT: alloca
-    // CHECK: %0 = insertvalue { i8, i8 } poison, i8 %x.0, 0
-    // CHECK: %1 = insertvalue { i8, i8 } %0, i8 %x.1, 1
-    // CHECK: ret { i8, i8 } %1
-    unsafe { transmute(x) }
-}
-
-// CHECK-LABEL: @check_to_newtype(
-#[no_mangle]
-pub unsafe fn check_to_newtype(x: u64) -> Scalar64 {
-    // CHECK-NOT: alloca
-    // CHECK: ret i64 %x
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_from_newtype(
-#[no_mangle]
-pub unsafe fn check_from_newtype(x: Scalar64) -> u64 {
-    // CHECK-NOT: alloca
-    // CHECK: ret i64 %x
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_aggregate_to_bool(
-#[no_mangle]
-pub unsafe fn check_aggregate_to_bool(x: Aggregate8) -> bool {
-    // CHECK: %x = alloca [1 x i8], align 1
-    // CHECK: %[[BYTE:.+]] = load i8, ptr %x, align 1
-    // CHECK: %[[BOOL:.+]] = trunc nuw i8 %[[BYTE]] to i1
-    // CHECK: ret i1 %[[BOOL]]
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_aggregate_from_bool(
-#[no_mangle]
-pub unsafe fn check_aggregate_from_bool(x: bool) -> Aggregate8 {
-    // CHECK: %_0 = alloca [1 x i8], align 1
-    // CHECK: %[[BYTE:.+]] = zext i1 %x to i8
-    // CHECK: store i8 %[[BYTE]], ptr %_0, align 1
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_byte_to_bool(
-#[no_mangle]
-pub unsafe fn check_byte_to_bool(x: u8) -> bool {
-    // CHECK-NOT: alloca
-    // CHECK: %[[R:.+]] = trunc nuw i8 %x to i1
-    // CHECK: ret i1 %[[R]]
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_byte_from_bool(
-#[no_mangle]
-pub unsafe fn check_byte_from_bool(x: bool) -> u8 {
-    // CHECK-NOT: alloca
-    // CHECK: %[[R:.+]] = zext i1 %x to i8
-    // CHECK: ret i8 %[[R:.+]]
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_to_pair(
-#[no_mangle]
-pub unsafe fn check_to_pair(x: u64) -> Option<i32> {
-    // CHECK: %_0 = alloca [8 x i8], align 4
-    // CHECK: store i64 %x, ptr %_0, align 4
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_from_pair(
-#[no_mangle]
-pub unsafe fn check_from_pair(x: Option<i32>) -> u64 {
-    // The two arguments are of types that are only 4-aligned, but they're
-    // immediates so we can write using the destination alloca's alignment.
-    const { assert!(std::mem::align_of::<Option<i32>>() == 4) };
-
-    // CHECK: %_0 = alloca [8 x i8], align 8
-    // CHECK: store i32 %x.0, ptr %_0, align 8
-    // CHECK: store i32 %x.1, ptr %0, align 4
-    // CHECK: %[[R:.+]] = load i64, ptr %_0, align 8
-    // CHECK: ret i64 %[[R]]
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_to_float(
-#[no_mangle]
-pub unsafe fn check_to_float(x: u32) -> f32 {
-    // CHECK-NOT: alloca
-    // CHECK: %_0 = bitcast i32 %x to float
-    // CHECK: ret float %_0
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_from_float(
-#[no_mangle]
-pub unsafe fn check_from_float(x: f32) -> u32 {
-    // CHECK-NOT: alloca
-    // CHECK: %_0 = bitcast float %x to i32
-    // CHECK: ret i32 %_0
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_to_bytes(
-#[no_mangle]
-pub unsafe fn check_to_bytes(x: u32) -> [u8; 4] {
-    // CHECK: %_0 = alloca [4 x i8], align 1
-    // CHECK: store i32 %x, ptr %_0, align 1
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_from_bytes(
-#[no_mangle]
-pub unsafe fn check_from_bytes(x: [u8; 4]) -> u32 {
-    // CHECK: %x = alloca [4 x i8], align 1
-    // CHECK: %[[VAL:.+]] = load i32, ptr %x, align 1
-    // CHECK: ret i32 %[[VAL]]
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_to_aggregate(
-#[no_mangle]
-pub unsafe fn check_to_aggregate(x: u64) -> Aggregate64 {
-    // CHECK: %_0 = alloca [8 x i8], align 4
-    // CHECK: store i64 %x, ptr %_0, align 4
-    // CHECK: %0 = load i64, ptr %_0, align 4
-    // CHECK: ret i64 %0
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_from_aggregate(
-#[no_mangle]
-pub unsafe fn check_from_aggregate(x: Aggregate64) -> u64 {
-    // CHECK: %x = alloca [8 x i8], align 4
-    // CHECK: %[[VAL:.+]] = load i64, ptr %x, align 4
-    // CHECK: ret i64 %[[VAL]]
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_long_array_less_aligned(
-#[no_mangle]
-pub unsafe fn check_long_array_less_aligned(x: [u64; 100]) -> [u16; 400] {
-    // CHECK-NEXT: start
-    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 2 %_0, ptr align 8 %x, i64 800, i1 false)
-    // CHECK-NEXT: ret void
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_long_array_more_aligned(
-#[no_mangle]
-pub unsafe fn check_long_array_more_aligned(x: [u8; 100]) -> [u32; 25] {
-    // CHECK-NEXT: start
-    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %_0, ptr align 1 %x, i64 100, i1 false)
-    // CHECK-NEXT: ret void
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_pair_with_bool(
-#[no_mangle]
-pub unsafe fn check_pair_with_bool(x: (u8, bool)) -> (bool, i8) {
-    // CHECK-NOT: alloca
-    // CHECK: trunc nuw i8 %x.0 to i1
-    // CHECK: zext i1 %x.1 to i8
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_float_to_pointer(
-#[no_mangle]
-pub unsafe fn check_float_to_pointer(x: f64) -> *const () {
-    // CHECK-NOT: alloca
-    // CHECK: %0 = bitcast double %x to i64
-    // CHECK: %_0 = getelementptr i8, ptr null, i64 %0
-    // CHECK: ret ptr %_0
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_float_from_pointer(
-#[no_mangle]
-pub unsafe fn check_float_from_pointer(x: *const ()) -> f64 {
-    // CHECK-NOT: alloca
-    // CHECK: %0 = ptrtoint ptr %x to i64
-    // CHECK: %_0 = bitcast i64 %0 to double
-    // CHECK: ret double %_0
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_array_to_pair(
-#[no_mangle]
-pub unsafe fn check_array_to_pair(x: [u8; 16]) -> (i64, u64) {
-    // CHECK-NOT: alloca
-    // CHECK: %[[FST:.+]] = load i64, ptr %{{.+}}, align 1, !noundef !
-    // CHECK: %[[SND:.+]] = load i64, ptr %{{.+}}, align 1, !noundef !
-    // CHECK: %[[PAIR0:.+]] = insertvalue { i64, i64 } poison, i64 %[[FST]], 0
-    // CHECK: %[[PAIR01:.+]] = insertvalue { i64, i64 } %[[PAIR0]], i64 %[[SND]], 1
-    // CHECK: ret { i64, i64 } %[[PAIR01]]
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_pair_to_array(
-#[no_mangle]
-pub unsafe fn check_pair_to_array(x: (i64, u64)) -> [u8; 16] {
-    // CHECK-NOT: alloca
-    // CHECK: store i64 %x.0, ptr %{{.+}}, align 1
-    // CHECK: store i64 %x.1, ptr %{{.+}}, align 1
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_heterogeneous_integer_pair(
-#[no_mangle]
-pub unsafe fn check_heterogeneous_integer_pair(x: (i32, bool)) -> (bool, u32) {
-    // CHECK: store i32 %x.0
-    // CHECK: %[[WIDER:.+]] = zext i1 %x.1 to i8
-    // CHECK: store i8 %[[WIDER]]
-
-    // CHECK: %[[BYTE:.+]] = load i8
-    // CHECK: trunc nuw i8 %[[BYTE:.+]] to i1
-    // CHECK: load i32
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_heterogeneous_float_pair(
-#[no_mangle]
-pub unsafe fn check_heterogeneous_float_pair(x: (f64, f32)) -> (f32, f64) {
-    // CHECK: store double %x.0
-    // CHECK: store float %x.1
-    // CHECK: %[[A:.+]] = load float
-    // CHECK: %[[B:.+]] = load double
-    // CHECK: %[[P:.+]] = insertvalue { float, double } poison, float %[[A]], 0
-    // CHECK: insertvalue { float, double } %[[P]], double %[[B]], 1
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_issue_110005(
-#[no_mangle]
-pub unsafe fn check_issue_110005(x: (usize, bool)) -> Option<Box<[u8]>> {
-    // CHECK: store i64 %x.0
-    // CHECK: %[[WIDER:.+]] = zext i1 %x.1 to i8
-    // CHECK: store i8 %[[WIDER]]
-    // CHECK: load ptr
-    // CHECK: load i64
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_pair_to_dst_ref(
-#[no_mangle]
-pub unsafe fn check_pair_to_dst_ref<'a>(x: (usize, usize)) -> &'a [u8] {
-    // CHECK: %_0.0 = getelementptr i8, ptr null, i64 %x.0
-    // CHECK: %0 = icmp ne ptr %_0.0, null
-    // CHECK: call void @llvm.assume(i1 %0)
-    // CHECK: %1 = insertvalue { ptr, i64 } poison, ptr %_0.0, 0
-    // CHECK: %2 = insertvalue { ptr, i64 } %1, i64 %x.1, 1
-    // CHECK: ret { ptr, i64 } %2
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_issue_109992(
-#[no_mangle]
-#[custom_mir(dialect = "runtime", phase = "optimized")]
-pub unsafe fn check_issue_109992(x: ()) -> [(); 1] {
-    // This uses custom MIR to avoid MIR optimizations having removed ZST ops.
-
-    // CHECK: start
-    // CHECK-NEXT: ret void
-    mir! {
-        {
-            RET = CastTransmute(x);
-            Return()
-        }
-    }
-}
-
-// CHECK-LABEL: @check_unit_to_never(
-#[no_mangle]
-#[custom_mir(dialect = "runtime", phase = "optimized")]
-pub unsafe fn check_unit_to_never(x: ()) {
-    // This uses custom MIR to avoid MIR optimizations having removed ZST ops.
-
-    // CHECK: start
-    // CHECK-NEXT: store i1 true, ptr poison, align 1
-    // CHECK-NEXT: ret void
-    mir! {
-        let temp: ZstNever;
-        {
-            temp = CastTransmute(x);
-            Return()
-        }
-    }
-}
-
-// CHECK-LABEL: @check_unit_from_never(
-#[no_mangle]
-#[custom_mir(dialect = "runtime", phase = "optimized")]
-pub unsafe fn check_unit_from_never(x: ZstNever) -> () {
-    // This uses custom MIR to avoid MIR optimizations having removed ZST ops.
-
-    // CHECK: start
-    // CHECK-NEXT: store i1 true, ptr poison, align 1
-    // CHECK-NEXT: ret void
-    mir! {
-        {
-            RET = CastTransmute(x);
-            Return()
-        }
-    }
-}
-
-// CHECK-LABEL: @check_maybe_uninit_pair(i16 %x.0, i64 %x.1)
-#[no_mangle]
-pub unsafe fn check_maybe_uninit_pair(
-    x: (MaybeUninit<u16>, MaybeUninit<u64>),
-) -> (MaybeUninit<i64>, MaybeUninit<i16>) {
-    // Thanks to `MaybeUninit` this is actually defined behaviour,
-    // unlike the examples above with pairs of primitives.
-
-    // CHECK: store i16 %x.0
-    // CHECK: store i64 %x.1
-    // CHECK: load i64
-    // CHECK-NOT: noundef
-    // CHECK: load i16
-    // CHECK-NOT: noundef
-    // CHECK: ret { i64, i16 }
-    transmute(x)
-}
-
-#[repr(align(8))]
-pub struct HighAlignScalar(u8);
-
-// CHECK-LABEL: @check_to_overalign(
-#[no_mangle]
-pub unsafe fn check_to_overalign(x: u64) -> HighAlignScalar {
-    // CHECK: %_0 = alloca [8 x i8], align 8
-    // CHECK: store i64 %x, ptr %_0, align 8
-    // CHECK: %0 = load i64, ptr %_0, align 8
-    // CHECK: ret i64 %0
-    transmute(x)
-}
-
-// CHECK-LABEL: @check_from_overalign(
-#[no_mangle]
-pub unsafe fn check_from_overalign(x: HighAlignScalar) -> u64 {
-    // CHECK: %x = alloca [8 x i8], align 8
-    // CHECK: %[[VAL:.+]] = load i64, ptr %x, align 8
-    // CHECK: ret i64 %[[VAL]]
-    transmute(x)
-}
-
-#[repr(transparent)]
-struct Level1(std::num::NonZero<u32>);
-#[repr(transparent)]
-struct Level2(Level1);
-#[repr(transparent)]
-struct Level3(Level2);
-
-// CHECK-LABEL: @repeatedly_transparent_transmute
-// CHECK-SAME: (i32{{.+}}%[[ARG:[^)]+]])
-#[no_mangle]
-#[custom_mir(dialect = "runtime", phase = "optimized")]
-pub unsafe fn repeatedly_transparent_transmute(x: NonZero<u32>) -> Level3 {
-    // CHECK: start
-    // CHECK-NEXT: ret i32 %[[ARG]]
-    mir! {
-        {
-            let A = CastTransmute::<NonZero<u32>, Level1>(x);
-            let B = CastTransmute::<Level1, Level2>(A);
-            RET = CastTransmute::<Level2, Level3>(B);
-            Return()
-        }
-    }
-}
diff --git a/tests/codegen/intrinsics/typed_swap.rs b/tests/codegen/intrinsics/typed_swap.rs
deleted file mode 100644
index 6b55078407a..00000000000
--- a/tests/codegen/intrinsics/typed_swap.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-//@ revisions: OPT0 OPT3
-//@ [OPT0] compile-flags: -Copt-level=0
-//@ [OPT3] compile-flags: -Copt-level=3
-//@ compile-flags: -C no-prepopulate-passes
-//@ only-64bit (so I don't need to worry about usize)
-// ignore-tidy-linelength (the memcpy calls get long)
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::typed_swap_nonoverlapping;
-
-// CHECK-LABEL: @swap_unit(
-#[no_mangle]
-pub unsafe fn swap_unit(x: &mut (), y: &mut ()) {
-    // CHECK: start
-    // CHECK-NEXT: ret void
-    typed_swap_nonoverlapping(x, y)
-}
-
-// CHECK-LABEL: @swap_i32(
-#[no_mangle]
-pub unsafe fn swap_i32(x: &mut i32, y: &mut i32) {
-    // CHECK-NOT: alloca
-
-    // CHECK: %[[TEMP:.+]] = load i32, ptr %x, align 4
-    // OPT3-SAME: !noundef
-    // OPT0: %[[TEMP2:.+]] = load i32, ptr %y, align 4
-    // OPT0: store i32 %[[TEMP2]], ptr %x, align 4
-    // OPT0-NOT: memcpy
-    // OPT3-NOT: load
-    // OPT3: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %x, ptr align 4 %y, i64 4, i1 false)
-    // CHECK: store i32 %[[TEMP]], ptr %y, align 4
-    // CHECK: ret void
-    typed_swap_nonoverlapping(x, y)
-}
-
-// CHECK-LABEL: @swap_pair(
-#[no_mangle]
-pub unsafe fn swap_pair(x: &mut (i32, u32), y: &mut (i32, u32)) {
-    // CHECK-NOT: alloca
-
-    // CHECK: load i32
-    // OPT3-SAME: !noundef
-    // CHECK: load i32
-    // OPT3-SAME: !noundef
-    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %x, ptr align 4 %y, i64 8, i1 false)
-    // CHECK: store i32
-    // CHECK: store i32
-    typed_swap_nonoverlapping(x, y)
-}
-
-// CHECK-LABEL: @swap_str(
-#[no_mangle]
-pub unsafe fn swap_str<'a>(x: &mut &'a str, y: &mut &'a str) {
-    // CHECK-NOT: alloca
-
-    // CHECK: load ptr
-    // OPT3-SAME: !nonnull
-    // OPT3-SAME: !noundef
-    // CHECK: load i64
-    // OPT3-SAME: !noundef
-    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %x, ptr align 8 %y, i64 16, i1 false)
-    // CHECK: store ptr
-    // CHECK: store i64
-    typed_swap_nonoverlapping(x, y)
-}
-
-// OPT0-LABEL: @swap_string(
-#[no_mangle]
-pub unsafe fn swap_string(x: &mut String, y: &mut String) {
-    // OPT0: %[[TEMP:.+]] = alloca {{.+}}, align 8
-    // OPT0: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %[[TEMP]], ptr align 8 %x, i64 24, i1 false)
-    // OPT0: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %x, ptr align 8 %y, i64 24, i1 false)
-    // OPT0: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %y, ptr align 8 %[[TEMP]], i64 24, i1 false)
-    typed_swap_nonoverlapping(x, y)
-}
diff --git a/tests/codegen/intrinsics/unchecked_math.rs b/tests/codegen/intrinsics/unchecked_math.rs
deleted file mode 100644
index 419c120ede9..00000000000
--- a/tests/codegen/intrinsics/unchecked_math.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::*;
-
-// CHECK-LABEL: @unchecked_add_signed
-#[no_mangle]
-pub unsafe fn unchecked_add_signed(a: i32, b: i32) -> i32 {
-    // CHECK: add nsw
-    unchecked_add(a, b)
-}
-
-// CHECK-LABEL: @unchecked_add_unsigned
-#[no_mangle]
-pub unsafe fn unchecked_add_unsigned(a: u32, b: u32) -> u32 {
-    // CHECK: add nuw
-    unchecked_add(a, b)
-}
-
-// CHECK-LABEL: @unchecked_sub_signed
-#[no_mangle]
-pub unsafe fn unchecked_sub_signed(a: i32, b: i32) -> i32 {
-    // CHECK: sub nsw
-    unchecked_sub(a, b)
-}
-
-// CHECK-LABEL: @unchecked_sub_unsigned
-#[no_mangle]
-pub unsafe fn unchecked_sub_unsigned(a: u32, b: u32) -> u32 {
-    // CHECK: sub nuw
-    unchecked_sub(a, b)
-}
-
-// CHECK-LABEL: @unchecked_mul_signed
-#[no_mangle]
-pub unsafe fn unchecked_mul_signed(a: i32, b: i32) -> i32 {
-    // CHECK: mul nsw
-    unchecked_mul(a, b)
-}
-
-// CHECK-LABEL: @unchecked_mul_unsigned
-#[no_mangle]
-pub unsafe fn unchecked_mul_unsigned(a: u32, b: u32) -> u32 {
-    // CHECK: mul nuw
-    unchecked_mul(a, b)
-}
diff --git a/tests/codegen/intrinsics/unlikely.rs b/tests/codegen/intrinsics/unlikely.rs
deleted file mode 100644
index 90ebf070d27..00000000000
--- a/tests/codegen/intrinsics/unlikely.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::unlikely;
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_a() {
-    println!("path a");
-}
-
-#[inline(never)]
-#[no_mangle]
-pub fn path_b() {
-    println!("path b");
-}
-
-#[no_mangle]
-pub fn test_unlikely(x: bool) {
-    if unlikely(x) {
-        path_a();
-    } else {
-        path_b();
-    }
-}
-
-// CHECK-LABEL: @test_unlikely(
-// CHECK: br i1 %x, label %bb2, label %bb4, !prof ![[NUM:[0-9]+]]
-// CHECK: bb4:
-// CHECK: path_b
-// CHECK: bb2:
-// CHECK-NOT: cold_path
-// CHECK: path_a
-// CHECK: ![[NUM]] = !{!"branch_weights", {{(!"expected", )?}}i32 1, i32 2000}
diff --git a/tests/codegen/intrinsics/volatile.rs b/tests/codegen/intrinsics/volatile.rs
deleted file mode 100644
index 2dea5ecb2ca..00000000000
--- a/tests/codegen/intrinsics/volatile.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics;
-
-// CHECK-LABEL: @volatile_copy_memory
-#[no_mangle]
-pub unsafe fn volatile_copy_memory(a: *mut u8, b: *const u8) {
-    // CHECK: llvm.memmove.{{\w*(.*true)}}
-    intrinsics::volatile_copy_memory(a, b, 1)
-}
-
-// CHECK-LABEL: @volatile_copy_nonoverlapping_memory
-#[no_mangle]
-pub unsafe fn volatile_copy_nonoverlapping_memory(a: *mut u8, b: *const u8) {
-    // CHECK: llvm.memcpy.{{\w*(.*true)}}
-    intrinsics::volatile_copy_nonoverlapping_memory(a, b, 1)
-}
-
-// CHECK-LABEL: @volatile_set_memory
-#[no_mangle]
-pub unsafe fn volatile_set_memory(a: *mut u8, b: u8) {
-    // CHECK: llvm.memset.{{\w*(.*true)}}
-    intrinsics::volatile_set_memory(a, b, 1)
-}
-
-// CHECK-LABEL: @volatile_load
-#[no_mangle]
-pub unsafe fn volatile_load(a: *const u8) -> u8 {
-    // CHECK: load volatile
-    intrinsics::volatile_load(a)
-}
-
-// CHECK-LABEL: @volatile_store
-#[no_mangle]
-pub unsafe fn volatile_store(a: *mut u8, b: u8) {
-    // CHECK: store volatile
-    intrinsics::volatile_store(a, b)
-}
-
-// CHECK-LABEL: @unaligned_volatile_load
-#[no_mangle]
-pub unsafe fn unaligned_volatile_load(a: *const u8) -> u8 {
-    // CHECK: load volatile
-    intrinsics::unaligned_volatile_load(a)
-}
-
-// CHECK-LABEL: @unaligned_volatile_store
-#[no_mangle]
-pub unsafe fn unaligned_volatile_store(a: *mut u8, b: u8) {
-    // CHECK: store volatile
-    intrinsics::unaligned_volatile_store(a, b)
-}
diff --git a/tests/codegen/intrinsics/volatile_order.rs b/tests/codegen/intrinsics/volatile_order.rs
deleted file mode 100644
index 99469831a6c..00000000000
--- a/tests/codegen/intrinsics/volatile_order.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-use std::intrinsics::*;
-
-pub unsafe fn test_volatile_order() {
-    let mut a: Box<u8> = Box::new(0);
-    // CHECK: load volatile
-    let x = volatile_load(&*a);
-    // CHECK: load volatile
-    let x = volatile_load(&*a);
-    // CHECK: store volatile
-    volatile_store(&mut *a, 12);
-    // CHECK: store volatile
-    unaligned_volatile_store(&mut *a, 12);
-    // CHECK: llvm.memset.p0
-    volatile_set_memory(&mut *a, 12, 1)
-}
diff --git a/tests/codegen/is_val_statically_known.rs b/tests/codegen/is_val_statically_known.rs
deleted file mode 100644
index 8119d3a3bf6..00000000000
--- a/tests/codegen/is_val_statically_known.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-//@ compile-flags: --crate-type=lib -Zmerge-functions=disabled -Copt-level=3
-
-#![feature(core_intrinsics)]
-#![feature(f16, f128)]
-
-use std::intrinsics::is_val_statically_known;
-
-pub struct A(u32);
-pub enum B {
-    Ye(u32),
-}
-
-#[inline]
-pub fn _u32(a: u32) -> i32 {
-    if is_val_statically_known(a) { 1 } else { 0 }
-}
-
-// CHECK-LABEL: @_u32_true(
-#[no_mangle]
-pub fn _u32_true() -> i32 {
-    // CHECK: ret i32 1
-    _u32(1)
-}
-
-// CHECK-LABEL: @_u32_false(
-#[no_mangle]
-pub fn _u32_false(a: u32) -> i32 {
-    // CHECK: ret i32 0
-    _u32(a)
-}
-
-#[inline]
-pub fn _bool(b: bool) -> i32 {
-    if is_val_statically_known(b) { 3 } else { 2 }
-}
-
-// CHECK-LABEL: @_bool_true(
-#[no_mangle]
-pub fn _bool_true() -> i32 {
-    // CHECK: ret i32 3
-    _bool(true)
-}
-
-// CHECK-LABEL: @_bool_false(
-#[no_mangle]
-pub fn _bool_false(b: bool) -> i32 {
-    // CHECK: ret i32 2
-    _bool(b)
-}
-
-#[inline]
-pub fn _iref(a: &u8) -> i32 {
-    if is_val_statically_known(a) { 5 } else { 4 }
-}
-
-// CHECK-LABEL: @_iref_borrow(
-#[no_mangle]
-pub fn _iref_borrow() -> i32 {
-    // CHECK: ret i32 4
-    _iref(&0)
-}
-
-// CHECK-LABEL: @_iref_arg(
-#[no_mangle]
-pub fn _iref_arg(a: &u8) -> i32 {
-    // CHECK: ret i32 4
-    _iref(a)
-}
-
-#[inline]
-pub fn _slice_ref(a: &[u8]) -> i32 {
-    if is_val_statically_known(a) { 7 } else { 6 }
-}
-
-// CHECK-LABEL: @_slice_ref_borrow(
-#[no_mangle]
-pub fn _slice_ref_borrow() -> i32 {
-    // CHECK: ret i32 6
-    _slice_ref(&[0; 3])
-}
-
-// CHECK-LABEL: @_slice_ref_arg(
-#[no_mangle]
-pub fn _slice_ref_arg(a: &[u8]) -> i32 {
-    // CHECK: ret i32 6
-    _slice_ref(a)
-}
-
-#[inline]
-pub fn _f16(a: f16) -> i32 {
-    if is_val_statically_known(a) { 1 } else { 0 }
-}
-
-// CHECK-LABEL: @_f16_true(
-#[no_mangle]
-pub fn _f16_true() -> i32 {
-    // CHECK: ret i32 1
-    _f16(1.0)
-}
-
-// CHECK-LABEL: @_f16_false(
-#[no_mangle]
-pub fn _f16_false(a: f16) -> i32 {
-    // CHECK: ret i32 0
-    _f16(a)
-}
-
-#[inline]
-pub fn _f32(a: f32) -> i32 {
-    if is_val_statically_known(a) { 1 } else { 0 }
-}
-
-// CHECK-LABEL: @_f32_true(
-#[no_mangle]
-pub fn _f32_true() -> i32 {
-    // CHECK: ret i32 1
-    _f32(1.0)
-}
-
-// CHECK-LABEL: @_f32_false(
-#[no_mangle]
-pub fn _f32_false(a: f32) -> i32 {
-    // CHECK: ret i32 0
-    _f32(a)
-}
-
-#[inline]
-pub fn _f64(a: f64) -> i32 {
-    if is_val_statically_known(a) { 1 } else { 0 }
-}
-
-// CHECK-LABEL: @_f64_true(
-#[no_mangle]
-pub fn _f64_true() -> i32 {
-    // CHECK: ret i32 1
-    _f64(1.0)
-}
-
-// CHECK-LABEL: @_f64_false(
-#[no_mangle]
-pub fn _f64_false(a: f64) -> i32 {
-    // CHECK: ret i32 0
-    _f64(a)
-}
-
-#[inline]
-pub fn _f128(a: f128) -> i32 {
-    if is_val_statically_known(a) { 1 } else { 0 }
-}
-
-// CHECK-LABEL: @_f128_true(
-#[no_mangle]
-pub fn _f128_true() -> i32 {
-    // CHECK: ret i32 1
-    _f128(1.0)
-}
-
-// CHECK-LABEL: @_f128_false(
-#[no_mangle]
-pub fn _f128_false(a: f128) -> i32 {
-    // CHECK: ret i32 0
-    _f128(a)
-}
diff --git a/tests/codegen/issue-97217.rs b/tests/codegen/issue-97217.rs
deleted file mode 100644
index ef9acc5fc93..00000000000
--- a/tests/codegen/issue-97217.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ compile-flags: -C opt-level=3
-#![crate_type = "lib"]
-
-// Regression test for issue 97217 (the following should result in no allocations)
-
-// CHECK-LABEL: @issue97217
-#[no_mangle]
-pub fn issue97217() -> i32 {
-    // drop_in_place should be inlined and never appear
-    // CHECK-NOT: drop_in_place
-
-    // __rust_alloc should be optimized out
-    // CHECK-NOT: __rust_alloc
-
-    let v1 = vec![5, 6, 7];
-    let v1_iter = v1.iter();
-    let total: i32 = v1_iter.sum();
-    println!("{}", total);
-    total
-}
diff --git a/tests/codegen/issues/issue-101048.rs b/tests/codegen/issues/issue-101048.rs
deleted file mode 100644
index cfe65e758fd..00000000000
--- a/tests/codegen/issues/issue-101048.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn all_zero(data: &[u64]) -> bool {
-    // CHECK-LABEL: @all_zero(
-    // CHECK: [[PHI:%.*]] = phi i1
-    // CHECK-NOT: phi i8
-    // CHECK-NOT: zext
-    data.iter().copied().fold(true, |acc, x| acc & (x == 0))
-}
diff --git a/tests/codegen/issues/issue-101082.rs b/tests/codegen/issues/issue-101082.rs
deleted file mode 100644
index 8d15921ddb4..00000000000
--- a/tests/codegen/issues/issue-101082.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ revisions: host x86-64 x86-64-v3
-//@ min-llvm-version: 20
-
-//@[host] ignore-x86_64
-
-// Set the base cpu explicitly, in case the default has been changed.
-//@[x86-64] only-x86_64
-//@[x86-64] compile-flags: -Ctarget-cpu=x86-64
-
-// FIXME(cuviper) x86-64-v3 in particular regressed in #131563, and the workaround
-// 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"]
-
-#[no_mangle]
-pub fn test() -> usize {
-    // CHECK-LABEL: @test(
-    // CHECK: ret {{i64|i32}} 165
-    let values = [23, 16, 54, 3, 60, 9];
-    let mut acc = 0;
-    for item in values {
-        acc += item;
-    }
-    acc
-}
-
-#[no_mangle]
-pub fn test_eight() -> usize {
-    // CHECK-LABEL: @test_eight(
-    // CHECK: ret {{i64|i32}} 220
-    let values = [23, 16, 54, 3, 60, 9, 13, 42];
-    let mut acc = 0;
-    for item in values {
-        acc += item;
-    }
-    acc
-}
diff --git a/tests/codegen/issues/issue-101814.rs b/tests/codegen/issues/issue-101814.rs
deleted file mode 100644
index 668ec8476e8..00000000000
--- a/tests/codegen/issues/issue-101814.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn test(a: [i32; 10]) -> i32 {
-    // CHECK-LABEL: @test(
-    // CHECK: [[L1:%.+]] = load i32
-    // CHECK: [[L2:%.+]] = load i32
-    // CHECK: [[R:%.+]] = add i32 [[L1]], [[L2]]
-    // CHECK: ret i32 [[R]]
-    let mut sum = 0;
-    for v in a.iter().skip(8) {
-        sum += v;
-    }
-
-    sum
-}
diff --git a/tests/codegen/issues/issue-103132.rs b/tests/codegen/issues/issue-103132.rs
deleted file mode 100644
index 623cab92806..00000000000
--- a/tests/codegen/issues/issue-103132.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C overflow-checks
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn test(arr: &[u8], weight: u32) {
-    // CHECK-LABEL: @test(
-    // CHECK-NOT: panic
-    let weight = weight.min(256 * 256 * 256);
-
-    for x in arr {
-        assert!(weight <= 256 * 256 * 256);
-        let result = *x as u32 * weight;
-    }
-}
diff --git a/tests/codegen/issues/issue-103285-ptr-addr-overflow-check.rs b/tests/codegen/issues/issue-103285-ptr-addr-overflow-check.rs
deleted file mode 100644
index 3ada5412e83..00000000000
--- a/tests/codegen/issues/issue-103285-ptr-addr-overflow-check.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C debug-assertions=yes
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn test(src: *const u8, dst: *const u8) -> usize {
-    // CHECK-LABEL: @test(
-    // CHECK-NOT: panic
-    let src_usize = src.addr();
-    let dst_usize = dst.addr();
-    if src_usize > dst_usize {
-        return src_usize - dst_usize;
-    }
-    return 0;
-}
diff --git a/tests/codegen/issues/issue-103327.rs b/tests/codegen/issues/issue-103327.rs
deleted file mode 100644
index 4de3cfd12a0..00000000000
--- a/tests/codegen/issues/issue-103327.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn test(a: i32, b: i32) -> bool {
-    // CHECK-LABEL: @test(
-    // CHECK: ret i1 true
-    let c1 = (a >= 0) && (a <= 10);
-    let c2 = (b >= 0) && (b <= 20);
-
-    if c1 & c2 { a + 100 != b } else { true }
-}
diff --git a/tests/codegen/issues/issue-103840.rs b/tests/codegen/issues/issue-103840.rs
deleted file mode 100644
index c6c5098bdd0..00000000000
--- a/tests/codegen/issues/issue-103840.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-pub fn foo(t: &mut Vec<usize>) {
-    // CHECK-NOT: __rust_dealloc
-    let mut taken = std::mem::take(t);
-    taken.pop();
-    *t = taken;
-}
diff --git a/tests/codegen/issues/issue-105386-ub-in-debuginfo.rs b/tests/codegen/issues/issue-105386-ub-in-debuginfo.rs
deleted file mode 100644
index 848aa910b58..00000000000
--- a/tests/codegen/issues/issue-105386-ub-in-debuginfo.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ compile-flags: --crate-type=lib -Copt-level=3 -Cdebuginfo=2 -Cno-prepopulate-passes -Zmir-enable-passes=-ScalarReplacementOfAggregates
-// MIR SROA will decompose the closure
-#![feature(stmt_expr_attributes)]
-
-pub struct S([usize; 8]);
-
-#[no_mangle]
-pub fn outer_function(x: S, y: S) -> usize {
-    (#[inline(always)]
-    || {
-        let _z = x;
-        y.0[0]
-    })()
-}
-
-// Check that we do not attempt to load from the spilled arg before it is assigned to
-// when generating debuginfo.
-// CHECK-LABEL: @outer_function
-// CHECK: [[spill:%.*]] = alloca
-// CHECK-NOT: [[ptr_tmp:%.*]] = getelementptr inbounds i8, ptr [[spill]]
-// CHECK-NOT: [[load:%.*]] = load ptr, ptr
-// CHECK: call void @llvm.lifetime.start{{.*}}({{.*}}, ptr [[spill]])
-// CHECK: [[inner:%.*]] = getelementptr inbounds i8, ptr [[spill]]
-// CHECK: call void @llvm.memcpy{{.*}}(ptr {{align .*}} [[inner]], ptr {{align .*}} %x
diff --git a/tests/codegen/issues/issue-106369.rs b/tests/codegen/issues/issue-106369.rs
deleted file mode 100644
index 3583d20c9fa..00000000000
--- a/tests/codegen/issues/issue-106369.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// From <https://github.com/rust-lang/rust/issues/106369#issuecomment-1369095304>
-
-// CHECK-LABEL: @issue_106369(
-#[no_mangle]
-pub unsafe fn issue_106369(ptr: *const &i32) -> bool {
-    // CHECK-NOT: icmp
-    // CHECK: ret i1 true
-    // CHECK-NOT: icmp
-    Some(std::ptr::read(ptr)).is_some()
-}
diff --git a/tests/codegen/issues/issue-107681-unwrap_unchecked.rs b/tests/codegen/issues/issue-107681-unwrap_unchecked.rs
deleted file mode 100644
index 69aefc6b1fb..00000000000
--- a/tests/codegen/issues/issue-107681-unwrap_unchecked.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-// Test for #107681.
-// Make sure we don't create `br` or `select` instructions.
-
-#![crate_type = "lib"]
-
-use std::iter::Copied;
-use std::slice::Iter;
-
-#[no_mangle]
-pub unsafe fn foo(x: &mut Copied<Iter<'_, u32>>) -> u32 {
-    // CHECK-LABEL: @foo(
-    // CHECK-NOT: br
-    // CHECK-NOT: select
-    // CHECK: [[RET:%.*]] = load i32, ptr
-    // CHECK-NEXT: ret i32 [[RET]]
-    x.next().unwrap_unchecked()
-}
diff --git a/tests/codegen/issues/issue-108395-branchy-bool-match.rs b/tests/codegen/issues/issue-108395-branchy-bool-match.rs
deleted file mode 100644
index 96387e791b0..00000000000
--- a/tests/codegen/issues/issue-108395-branchy-bool-match.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-//! Test for <https://github.com/rust-lang/rust/issues/108395>. Check that
-//! matching on two bools with wildcards does not produce branches.
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @wildcard(
-#[no_mangle]
-pub fn wildcard(a: u16, b: u16, v: u16) -> u16 {
-    // CHECK-NOT: br
-    match (a == v, b == v) {
-        (true, false) => 0,
-        (false, true) => u16::MAX,
-        _ => 1 << 15, // half
-    }
-}
-
-// CHECK-LABEL: @exhaustive(
-#[no_mangle]
-pub fn exhaustive(a: u16, b: u16, v: u16) -> u16 {
-    // CHECK-NOT: br
-    match (a == v, b == v) {
-        (true, false) => 0,
-        (false, true) => u16::MAX,
-        (true, true) => 1 << 15,
-        (false, false) => 1 << 15,
-    }
-}
diff --git a/tests/codegen/issues/issue-109328-split_first.rs b/tests/codegen/issues/issue-109328-split_first.rs
deleted file mode 100644
index 26235edfc19..00000000000
--- a/tests/codegen/issues/issue-109328-split_first.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @foo
-// CHECK-NEXT: {{.*}}:
-// CHECK-NEXT: getelementptr inbounds
-// CHECK-NEXT: load [[TYPE:i(32|64)]]
-// CHECK-NEXT: icmp eq [[TYPE]]
-// CHECK-NEXT: br i1
-#[no_mangle]
-pub fn foo(input: &mut &[u64]) -> Option<u64> {
-    let (first, rest) = input.split_first()?;
-    *input = rest;
-    Some(*first)
-}
diff --git a/tests/codegen/issues/issue-110797-enum-jump-same.rs b/tests/codegen/issues/issue-110797-enum-jump-same.rs
deleted file mode 100644
index b5f7c08795b..00000000000
--- a/tests/codegen/issues/issue-110797-enum-jump-same.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-pub enum K {
-    A(Box<[i32]>),
-    B(Box<[u8]>),
-    C(Box<[String]>),
-    D(Box<[u16]>),
-}
-
-// CHECK-LABEL: @get_len
-// CHECK-NEXT: {{.*}}:
-// CHECK-NEXT: getelementptr inbounds
-// CHECK-NEXT: load [[TYPE:i(32|64)]]
-// CHECK-NEXT: ret [[TYPE]]
-#[no_mangle]
-pub fn get_len(arg: &K) -> usize {
-    match arg {
-        K::A(ref lst) => lst.len(),
-        K::B(ref lst) => lst.len(),
-        K::C(ref lst) => lst.len(),
-        K::D(ref lst) => lst.len(),
-    }
-}
diff --git a/tests/codegen/issues/issue-111603.rs b/tests/codegen/issues/issue-111603.rs
deleted file mode 100644
index 2ba5a3f876a..00000000000
--- a/tests/codegen/issues/issue-111603.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-#![feature(get_mut_unchecked, new_uninit)]
-
-use std::sync::Arc;
-
-// CHECK-LABEL: @new_from_array
-#[no_mangle]
-pub fn new_from_array(x: u64) -> Arc<[u64]> {
-    // Ensure that we only generate one alloca for the array.
-
-    // CHECK: alloca
-    // CHECK-SAME: [8000 x i8]
-    // CHECK-NOT: alloca
-    let array = [x; 1000];
-    Arc::new(array)
-}
-
-// CHECK-LABEL: @new_uninit
-#[no_mangle]
-pub fn new_uninit(x: u64) -> Arc<[u64; 1000]> {
-    // CHECK: call alloc::sync::arcinner_layout_for_value_layout
-    // CHECK-NOT: call alloc::sync::arcinner_layout_for_value_layout
-    let mut arc = Arc::new_uninit();
-    unsafe { Arc::get_mut_unchecked(&mut arc) }.write([x; 1000]);
-    unsafe { arc.assume_init() }
-}
-
-// CHECK-LABEL: @new_uninit_slice
-#[no_mangle]
-pub fn new_uninit_slice(x: u64) -> Arc<[u64]> {
-    // CHECK: call alloc::sync::arcinner_layout_for_value_layout
-    // CHECK-NOT: call alloc::sync::arcinner_layout_for_value_layout
-    let mut arc = Arc::new_uninit_slice(1000);
-    for elem in unsafe { Arc::get_mut_unchecked(&mut arc) } {
-        elem.write(x);
-    }
-    unsafe { arc.assume_init() }
-}
diff --git a/tests/codegen/issues/issue-112509-slice-get-andthen-get.rs b/tests/codegen/issues/issue-112509-slice-get-andthen-get.rs
deleted file mode 100644
index 3909b203d08..00000000000
--- a/tests/codegen/issues/issue-112509-slice-get-andthen-get.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @write_u8_variant_a
-// CHECK-NEXT: {{.*}}:
-// CHECK-NEXT: icmp ugt
-// CHECK-NEXT: getelementptr
-// CHECK-NEXT: select i1 {{.+}} null
-// CHECK-NEXT: insertvalue
-// CHECK-NEXT: insertvalue
-// CHECK-NEXT: ret
-#[no_mangle]
-pub fn write_u8_variant_a(bytes: &mut [u8], buf: u8, offset: usize) -> Option<&mut [u8]> {
-    let buf = buf.to_le_bytes();
-    bytes.get_mut(offset..).and_then(|bytes| bytes.get_mut(..buf.len()))
-}
diff --git a/tests/codegen/issues/issue-113757-bounds-check-after-cmp-max.rs b/tests/codegen/issues/issue-113757-bounds-check-after-cmp-max.rs
deleted file mode 100644
index d495adf9980..00000000000
--- a/tests/codegen/issues/issue-113757-bounds-check-after-cmp-max.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// in Rust 1.73, -O and opt-level=3 optimizes differently
-//@ compile-flags: -C opt-level=3
-#![crate_type = "lib"]
-
-use std::cmp::max;
-
-// CHECK-LABEL: @foo
-// CHECK-NOT: slice_start_index_len_fail
-// CHECK-NOT: unreachable
-#[no_mangle]
-pub fn foo(v: &mut Vec<u8>, size: usize) -> Option<&mut [u8]> {
-    if v.len() > max(1, size) {
-        let start = v.len() - size;
-        Some(&mut v[start..])
-    } else {
-        None
-    }
-}
diff --git a/tests/codegen/issues/issue-114312.rs b/tests/codegen/issues/issue-114312.rs
deleted file mode 100644
index 61355dd5873..00000000000
--- a/tests/codegen/issues/issue-114312.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64-unknown-linux-gnu
-
-// We want to check that this function does not mis-optimize to loop jumping.
-
-#![crate_type = "lib"]
-
-#[repr(C)]
-pub enum Expr {
-    Sum,
-    // must have more than usize data
-    Sub(usize, u8),
-}
-
-#[no_mangle]
-pub extern "C" fn issue_114312(expr: Expr) {
-    // CHECK-LABEL: @issue_114312(
-    // CHECK-SAME: byval
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret void
-    match expr {
-        Expr::Sum => {}
-        Expr::Sub(_, _) => issue_114312(Expr::Sum),
-    }
-}
diff --git a/tests/codegen/issues/issue-115385-llvm-jump-threading.rs b/tests/codegen/issues/issue-115385-llvm-jump-threading.rs
deleted file mode 100644
index 8cabd94f202..00000000000
--- a/tests/codegen/issues/issue-115385-llvm-jump-threading.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Ccodegen-units=1
-
-#![crate_type = "lib"]
-
-#[repr(i64)]
-pub enum Boolean {
-    False = 0,
-    True = 1,
-}
-
-impl Clone for Boolean {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl Copy for Boolean {}
-
-extern "C" {
-    fn set_value(foo: *mut i64);
-    fn bar();
-}
-
-pub fn foo(x: bool) {
-    let mut foo = core::mem::MaybeUninit::<i64>::uninit();
-    unsafe {
-        set_value(foo.as_mut_ptr());
-    }
-
-    if x {
-        let l1 = unsafe { *foo.as_mut_ptr().cast::<Boolean>() };
-        if matches!(l1, Boolean::False) {
-            unsafe {
-                *foo.as_mut_ptr() = 0;
-            }
-        }
-    }
-
-    let l2 = unsafe { *foo.as_mut_ptr() };
-    if l2 == 2 {
-        // CHECK: call void @bar
-        unsafe {
-            bar();
-        }
-    }
-}
diff --git a/tests/codegen/issues/issue-116878.rs b/tests/codegen/issues/issue-116878.rs
deleted file mode 100644
index daf46c8bb55..00000000000
--- a/tests/codegen/issues/issue-116878.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-/// Make sure no bounds checks are emitted after a `get_unchecked`.
-// CHECK-LABEL: @unchecked_slice_no_bounds_check
-#[no_mangle]
-pub unsafe fn unchecked_slice_no_bounds_check(s: &[u8]) -> u8 {
-    let a = *s.get_unchecked(1);
-    // CHECK-NOT: panic_bounds_check
-    a + s[0]
-}
diff --git a/tests/codegen/issues/issue-118306.rs b/tests/codegen/issues/issue-118306.rs
deleted file mode 100644
index f12dc7cdfe2..00000000000
--- a/tests/codegen/issues/issue-118306.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-// Test for #118306.
-// Make sure we don't create `br` or `select` instructions.
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-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], 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 {
-        1 | 2 => 1,
-        3 => 2,
-        _ => 0,
-    }
-}
diff --git a/tests/codegen/issues/issue-118392.rs b/tests/codegen/issues/issue-118392.rs
deleted file mode 100644
index 07de8d9b237..00000000000
--- a/tests/codegen/issues/issue-118392.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @div2
-// CHECK: ashr i32 %a, 1
-// CHECK-NEXT: ret i32
-#[no_mangle]
-pub fn div2(a: i32) -> i32 {
-    a.div_euclid(2)
-}
diff --git a/tests/codegen/issues/issue-119422.rs b/tests/codegen/issues/issue-119422.rs
deleted file mode 100644
index 17ae71605b5..00000000000
--- a/tests/codegen/issues/issue-119422.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-//! This test checks that compiler don't generate useless compares to zeros
-//! for `NonZero` integer types.
-//!
-//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-//@ edition: 2021
-//@ only-64bit (because the LLVM type of i64 for usize shows up)
-#![crate_type = "lib"]
-
-use core::num::NonZero;
-use core::ptr::NonNull;
-
-// CHECK-LABEL: @check_non_null
-#[no_mangle]
-pub fn check_non_null(x: NonNull<u8>) -> bool {
-    // CHECK: ret i1 false
-    x.as_ptr().is_null()
-}
-
-// CHECK-LABEL: @equals_zero_is_false_u8
-#[no_mangle]
-pub fn equals_zero_is_false_u8(x: NonZero<u8>) -> bool {
-    // CHECK-NOT: br
-    // CHECK: ret i1 false
-    // CHECK-NOT: br
-    x.get() == 0
-}
-
-// CHECK-LABEL: @not_equals_zero_is_true_u8
-#[no_mangle]
-pub fn not_equals_zero_is_true_u8(x: NonZero<u8>) -> bool {
-    // CHECK-NOT: br
-    // CHECK: ret i1 true
-    // CHECK-NOT: br
-    x.get() != 0
-}
-
-// CHECK-LABEL: @equals_zero_is_false_i8
-#[no_mangle]
-pub fn equals_zero_is_false_i8(x: NonZero<i8>) -> bool {
-    // CHECK-NOT: br
-    // CHECK: ret i1 false
-    // CHECK-NOT: br
-    x.get() == 0
-}
-
-// CHECK-LABEL: @not_equals_zero_is_true_i8
-#[no_mangle]
-pub fn not_equals_zero_is_true_i8(x: NonZero<i8>) -> bool {
-    // CHECK-NOT: br
-    // CHECK: ret i1 true
-    // CHECK-NOT: br
-    x.get() != 0
-}
-
-// CHECK-LABEL: @usize_try_from_u32
-#[no_mangle]
-pub fn usize_try_from_u32(x: NonZero<u32>) -> NonZero<usize> {
-    // CHECK-NOT: br
-    // CHECK: zext i32 %{{.*}} to i64
-    // CHECK-NOT: br
-    // CHECK: ret i64
-    x.try_into().unwrap()
-}
-
-// CHECK-LABEL: @isize_try_from_i32
-#[no_mangle]
-pub fn isize_try_from_i32(x: NonZero<i32>) -> NonZero<isize> {
-    // CHECK-NOT: br
-    // CHECK: sext i32 %{{.*}} to i64
-    // CHECK-NOT: br
-    // CHECK: ret i64
-    x.try_into().unwrap()
-}
-
-// CHECK-LABEL: @u64_from_nonzero_is_not_zero
-#[no_mangle]
-pub fn u64_from_nonzero_is_not_zero(x: NonZero<u64>) -> bool {
-    // CHECK-NOT: br
-    // CHECK: ret i1 false
-    // CHECK-NOT: br
-    let v: u64 = x.into();
-    v == 0
-}
diff --git a/tests/codegen/issues/issue-121719-common-field-offset.rs b/tests/codegen/issues/issue-121719-common-field-offset.rs
deleted file mode 100644
index 9f5f44e0375..00000000000
--- a/tests/codegen/issues/issue-121719-common-field-offset.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-//! This test checks that match branches which all access a field
-//! at the same offset are merged together.
-//!
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-#[repr(C)]
-pub struct A {
-    x: f64,
-    y: u64,
-}
-#[repr(C)]
-pub struct B {
-    x: f64,
-    y: u32,
-}
-#[repr(C)]
-pub struct C {
-    x: f64,
-    y: u16,
-}
-#[repr(C)]
-pub struct D {
-    x: f64,
-    y: u8,
-}
-
-pub enum E {
-    A(A),
-    B(B),
-    C(C),
-    D(D),
-}
-
-// CHECK-LABEL: @match_on_e
-#[no_mangle]
-pub fn match_on_e(e: &E) -> &f64 {
-    // CHECK: start:
-    // CHECK-NEXT: getelementptr
-    // CHECK-NEXT: ret
-    match e {
-        E::A(A { x, .. }) | E::B(B { x, .. }) | E::C(C { x, .. }) | E::D(D { x, .. }) => x,
-    }
-}
diff --git a/tests/codegen/issues/issue-122600-ptr-discriminant-update.rs b/tests/codegen/issues/issue-122600-ptr-discriminant-update.rs
deleted file mode 100644
index 853a1ff36b1..00000000000
--- a/tests/codegen/issues/issue-122600-ptr-discriminant-update.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// The bug here was that it was loading and storing the whole value.
-// It's ok for it to load the discriminant,
-// to preserve the UB from `unreachable_unchecked`,
-// but it better only store the constant discriminant of `B`.
-
-pub enum State {
-    A([u8; 753]),
-    B([u8; 753]),
-}
-
-// CHECK-LABEL: @update
-#[no_mangle]
-pub unsafe fn update(s: *mut State) {
-    // CHECK-NOT: alloca
-
-    // CHECK-NOT: load
-    // CHECK-NOT: store
-    // CHECK-NOT: memcpy
-    // CHECK-NOT: 75{{3|4}}
-
-    // CHECK: %[[TAG:.+]] = load i8, ptr %s, align 1
-    // CHECK-NEXT: trunc nuw i8 %[[TAG]] to i1
-
-    // CHECK-NOT: load
-    // CHECK-NOT: store
-    // CHECK-NOT: memcpy
-    // CHECK-NOT: 75{{3|4}}
-
-    // CHECK: store i8 1, ptr %s, align 1
-
-    // CHECK-NOT: load
-    // CHECK-NOT: store
-    // CHECK-NOT: memcpy
-    // CHECK-NOT: 75{{3|4}}
-
-    // CHECK: ret
-    let State::A(v) = s.read() else { std::hint::unreachable_unchecked() };
-    s.write(State::B(v));
-}
diff --git a/tests/codegen/issues/issue-123712-str-to-lower-autovectorization.rs b/tests/codegen/issues/issue-123712-str-to-lower-autovectorization.rs
deleted file mode 100644
index 11ee10e8cc3..00000000000
--- a/tests/codegen/issues/issue-123712-str-to-lower-autovectorization.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ only-x86_64
-//@ compile-flags: -C opt-level=3
-#![crate_type = "lib"]
-#![no_std]
-#![feature(str_internals)]
-
-extern crate alloc;
-
-/// Ensure that the ascii-prefix loop for `str::to_lowercase` and `str::to_uppercase` uses vector
-/// instructions.
-///
-/// The llvm ir should be the same for all targets that support some form of simd. Only targets
-/// without any simd instructions would see scalarized ir.
-/// Unfortunately, there is no `only-simd` directive to only run this test on only such platforms,
-/// and using test revisions would still require the core libraries for all platforms.
-// CHECK-LABEL: @lower_while_ascii
-// CHECK: [[A:%[0-9]]] = load <16 x i8>
-// CHECK-NEXT: [[B:%[0-9]]] = icmp slt <16 x i8> [[A]], zeroinitializer
-// CHECK-NEXT: [[C:%[0-9]]] = bitcast <16 x i1> [[B]] to i16
-#[no_mangle]
-pub fn lower_while_ascii(s: &str) -> (alloc::string::String, &str) {
-    alloc::str::convert_while_ascii(s, u8::to_ascii_lowercase)
-}
diff --git a/tests/codegen/issues/issue-126585.rs b/tests/codegen/issues/issue-126585.rs
deleted file mode 100644
index 466dab64cdc..00000000000
--- a/tests/codegen/issues/issue-126585.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ compile-flags: -Copt-level=s
-//@ only-x86_64
-
-// Test for #126585.
-// Ensure that this IR doesn't have extra undef phi input, which also guarantees that this asm
-// doesn't have subsequent labels and unnecessary `jmp` instructions.
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-fn checked_div_round(a: u64, b: u64) -> Option<u64> {
-    // CHECK-LABEL: @checked_div_round
-    // CHECK: phi
-    // CHECK-NOT: undef
-    // CHECK: phi
-    // CHECK-NOT: undef
-    match b {
-        0 => None,
-        1 => Some(a),
-        // `a / b` is computable and `(a % b) * 2` can not overflow since `b >= 2`.
-        b => Some(a / b + if (a % b) * 2 >= b { 1 } else { 0 }),
-    }
-}
diff --git a/tests/codegen/issues/issue-129795.rs b/tests/codegen/issues/issue-129795.rs
deleted file mode 100644
index dc64ee35c97..00000000000
--- a/tests/codegen/issues/issue-129795.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ min-llvm-version: 20
-#![crate_type = "lib"]
-
-// Ensure that a modulo operation with an operand that is known to be
-// a power-of-two is properly optimized.
-
-// CHECK-LABEL: @modulo_with_power_of_two_divisor
-// CHECK: add i64 %divisor, -1
-// CHECK-NEXT: and i64
-// CHECK-NEXT: ret i64
-#[no_mangle]
-pub fn modulo_with_power_of_two_divisor(dividend: u64, divisor: u64) -> u64 {
-    assert!(divisor.is_power_of_two());
-    // should be optimized to (dividend & (divisor - 1))
-    dividend % divisor
-}
diff --git a/tests/codegen/issues/issue-13018.rs b/tests/codegen/issues/issue-13018.rs
deleted file mode 100644
index 8040018b931..00000000000
--- a/tests/codegen/issues/issue-13018.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-// A drop([...].clone()) sequence on an Rc should be a no-op
-// In particular, no call to __rust_dealloc should be emitted
-//
-// We use a cdylib since it's a leaf unit for Rust purposes, so doesn't codegen -Zshare-generics
-// code.
-#![crate_type = "cdylib"]
-use std::rc::Rc;
-
-pub fn foo(t: &Rc<Vec<usize>>) {
-    // CHECK-NOT: __rust_dealloc
-    drop(t.clone());
-}
diff --git a/tests/codegen/issues/issue-136329-optnone-noinline.rs b/tests/codegen/issues/issue-136329-optnone-noinline.rs
deleted file mode 100644
index 57c9e47a499..00000000000
--- a/tests/codegen/issues/issue-136329-optnone-noinline.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! Ensure that `#[optimize(none)]` functions are never inlined
-
-//@ compile-flags: -Copt-level=3
-
-#![feature(optimize_attribute)]
-
-#[optimize(none)]
-pub fn foo() {
-    let _x = 123;
-}
-
-// CHECK-LABEL: define{{.*}}void @bar
-// CHECK: start:
-// CHECK: {{.*}}call {{.*}}void
-// CHECK: ret void
-#[no_mangle]
-pub fn bar() {
-    foo();
-}
-
-fn main() {}
diff --git a/tests/codegen/issues/issue-15953.rs b/tests/codegen/issues/issue-15953.rs
deleted file mode 100644
index 70e597ac1dd..00000000000
--- a/tests/codegen/issues/issue-15953.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Test that llvm generates `memcpy` for moving a value
-// inside a function and moving an argument.
-
-struct Foo {
-    x: Vec<i32>,
-}
-
-#[inline(never)]
-#[no_mangle]
-// CHECK: memcpy
-fn interior(x: Vec<i32>) -> Vec<i32> {
-    let Foo { x } = Foo { x };
-    x
-}
-
-#[inline(never)]
-#[no_mangle]
-// CHECK: memcpy
-fn exterior(x: Vec<i32>) -> Vec<i32> {
-    x
-}
-
-fn main() {
-    let x = interior(Vec::new());
-    println!("{:?}", x);
-
-    let x = exterior(Vec::new());
-    println!("{:?}", x);
-}
diff --git a/tests/codegen/issues/issue-27130.rs b/tests/codegen/issues/issue-27130.rs
deleted file mode 100644
index 594e02af097..00000000000
--- a/tests/codegen/issues/issue-27130.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @trim_in_place
-#[no_mangle]
-pub fn trim_in_place(a: &mut &[u8]) {
-    while a.first() == Some(&42) {
-        // CHECK-NOT: slice_index_order_fail
-        *a = &a[1..];
-    }
-}
-
-// CHECK-LABEL: @trim_in_place2
-#[no_mangle]
-pub fn trim_in_place2(a: &mut &[u8]) {
-    while let Some(&42) = a.first() {
-        // CHECK-NOT: slice_index_order_fail
-        *a = &a[2..];
-    }
-}
diff --git a/tests/codegen/issues/issue-32031.rs b/tests/codegen/issues/issue-32031.rs
deleted file mode 100644
index 559e8d947fb..00000000000
--- a/tests/codegen/issues/issue-32031.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-// 32-bit x86 returns `f32` and `f64` differently to avoid the x87 stack.
-//@ revisions: x86 other
-//@[x86] only-rustc_abi-x86-sse2
-//@[other] ignore-x86
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub struct F32(f32);
-
-// other: define{{.*}}float @add_newtype_f32(float %a, float %b)
-// x86: define{{.*}}<4 x i8> @add_newtype_f32(float %a, float %b)
-#[inline(never)]
-#[no_mangle]
-pub fn add_newtype_f32(a: F32, b: F32) -> F32 {
-    F32(a.0 + b.0)
-}
-
-#[no_mangle]
-pub struct F64(f64);
-
-// other: define{{.*}}double @add_newtype_f64(double %a, double %b)
-// x86: define{{.*}}<8 x i8> @add_newtype_f64(double %a, double %b)
-#[inline(never)]
-#[no_mangle]
-pub fn add_newtype_f64(a: F64, b: F64) -> F64 {
-    F64(a.0 + b.0)
-}
diff --git a/tests/codegen/issues/issue-32364.rs b/tests/codegen/issues/issue-32364.rs
deleted file mode 100644
index 016981d1947..00000000000
--- a/tests/codegen/issues/issue-32364.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Test that `extern "stdcall"` is properly translated.
-
-//@ only-x86
-
-//@ compile-flags: -C no-prepopulate-passes
-
-struct Foo;
-
-impl Foo {
-    // CHECK: define internal x86_stdcallcc void @{{.*}}foo{{.*}}()
-    #[inline(never)]
-    pub extern "stdcall" fn foo<T>() {}
-}
-
-fn main() {
-    Foo::foo::<Foo>();
-}
diff --git a/tests/codegen/issues/issue-34634.rs b/tests/codegen/issues/issue-34634.rs
deleted file mode 100644
index d32fa97ec38..00000000000
--- a/tests/codegen/issues/issue-34634.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Test that `wrapping_div` only checks divisor once.
-// This test checks that there is only a single compare against -1 and -1 is not present as a
-// switch case (the second check present until rustc 1.12).
-// This test also verifies that a single panic call is generated (for the division by zero case).
-
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @f
-#[no_mangle]
-pub fn f(x: i32, y: i32) -> i32 {
-    // CHECK-COUNT-1: icmp eq i32 %y, -1
-    // CHECK-COUNT-1: panic
-    // CHECK-NOT: i32 -1, label
-    x.wrapping_div(y)
-}
diff --git a/tests/codegen/issues/issue-34947-pow-i32.rs b/tests/codegen/issues/issue-34947-pow-i32.rs
deleted file mode 100644
index b4750cd35bc..00000000000
--- a/tests/codegen/issues/issue-34947-pow-i32.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @issue_34947
-#[no_mangle]
-pub fn issue_34947(x: i32) -> i32 {
-    // CHECK: mul
-    // CHECK-NEXT: mul
-    // CHECK-NEXT: mul
-    // CHECK-NEXT: ret
-    x.pow(5)
-}
diff --git a/tests/codegen/issues/issue-36010-some-box-is_some.rs b/tests/codegen/issues/issue-36010-some-box-is_some.rs
deleted file mode 100644
index c9a8262162d..00000000000
--- a/tests/codegen/issues/issue-36010-some-box-is_some.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![crate_type = "lib"]
-
-//@ compile-flags: -Copt-level=3
-
-use std::mem;
-
-fn foo<T>(a: &mut T, b: T) -> bool {
-    let b = Some(mem::replace(a, b));
-    let ret = b.is_some();
-    mem::forget(b);
-    return ret;
-}
-
-// CHECK-LABEL: @foo_u32
-// CHECK: store i32
-// CHECK-NEXT: ret i1 true
-#[no_mangle]
-pub fn foo_u32(a: &mut u32, b: u32) -> bool {
-    foo(a, b)
-}
-
-// CHECK-LABEL: @foo_box
-// CHECK: store ptr
-// CHECK-NEXT: ret i1 true
-#[no_mangle]
-pub fn foo_box(a: &mut Box<u32>, b: Box<u32>) -> bool {
-    foo(a, b)
-}
diff --git a/tests/codegen/issues/issue-37945.rs b/tests/codegen/issues/issue-37945.rs
deleted file mode 100644
index 23d0eab8ae4..00000000000
--- a/tests/codegen/issues/issue-37945.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-//@ ignore-32bit LLVM has a bug with them
-
-// Check that LLVM understands that `Iter` pointer is not null. Issue #37945.
-
-#![crate_type = "lib"]
-
-use std::slice::Iter;
-
-#[no_mangle]
-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]])
-    // 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}}
-    // CHECK-NEXT:    ret i1 [[B:%.*]]
-    { xs }.next().is_none()
-}
-
-#[no_mangle]
-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]])
-    // 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}}
-    // CHECK-NEXT:    ret i1 [[D:%.*]]
-    xs.map(|&x| x).next().is_none()
-}
diff --git a/tests/codegen/issues/issue-45222.rs b/tests/codegen/issues/issue-45222.rs
deleted file mode 100644
index 0201363c41a..00000000000
--- a/tests/codegen/issues/issue-45222.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// verify that LLVM recognizes a loop involving 0..=n and will const-fold it.
-
-// Example from original issue #45222
-
-fn foo2(n: u64) -> u64 {
-    let mut count = 0;
-    for _ in 0..n {
-        for j in (0..=n).rev() {
-            count += j;
-        }
-    }
-    count
-}
-
-// CHECK-LABEL: @check_foo2
-#[no_mangle]
-pub fn check_foo2() -> u64 {
-    // CHECK: ret i64 500005000000000
-    foo2(100000)
-}
-
-// Simplified example of #45222
-//
-// Temporarily disabled in #68835 to fix a soundness hole.
-//
-// fn triangle_inc(n: u64) -> u64 {
-//     let mut count = 0;
-//     for j in 0 ..= n {
-//         count += j;
-//     }
-//     count
-// }
-//
-// // COMMENTEDCHECK-LABEL: @check_triangle_inc
-// #[no_mangle]
-// pub fn check_triangle_inc() -> u64 {
-//     // COMMENTEDCHECK: ret i64 5000050000
-//     triangle_inc(100000)
-// }
-
-// Demo in #48012
-
-fn foo3r(n: u64) -> u64 {
-    let mut count = 0;
-    (0..n).for_each(|_| {
-        (0..=n).rev().for_each(|j| {
-            count += j;
-        })
-    });
-    count
-}
-
-// CHECK-LABEL: @check_foo3r
-#[no_mangle]
-pub fn check_foo3r() -> u64 {
-    // CHECK: ret i64 500050000000
-    foo3r(10000)
-}
diff --git a/tests/codegen/issues/issue-45466.rs b/tests/codegen/issues/issue-45466.rs
deleted file mode 100644
index 164a27ef5d4..00000000000
--- a/tests/codegen/issues/issue-45466.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "rlib"]
-
-// CHECK-LABEL: @memzero
-// CHECK-NOT: store
-// CHECK: call void @llvm.memset
-// CHECK-NOT: store
-#[no_mangle]
-pub fn memzero(data: &mut [u8]) {
-    for i in 0..data.len() {
-        data[i] = 0;
-    }
-}
diff --git a/tests/codegen/issues/issue-45964-bounds-check-slice-pos.rs b/tests/codegen/issues/issue-45964-bounds-check-slice-pos.rs
deleted file mode 100644
index a48bb2a1ccf..00000000000
--- a/tests/codegen/issues/issue-45964-bounds-check-slice-pos.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// This test case checks that slice::{r}position functions do not
-// prevent optimizing away bounds checks
-
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "rlib"]
-
-// CHECK-LABEL: @test
-#[no_mangle]
-pub fn test(y: &[u32], x: &u32, z: &u32) -> bool {
-    let result = match y.iter().position(|a| a == x) {
-        Some(p) => Ok(p),
-        None => Err(()),
-    };
-
-    if let Ok(p) = result {
-        // CHECK-NOT: panic
-        y[p] == *z
-    } else {
-        false
-    }
-}
-
-// CHECK-LABEL: @rtest
-#[no_mangle]
-pub fn rtest(y: &[u32], x: &u32, z: &u32) -> bool {
-    let result = match y.iter().rposition(|a| a == x) {
-        Some(p) => Ok(p),
-        None => Err(()),
-    };
-
-    if let Ok(p) = result {
-        // CHECK-NOT: panic
-        y[p] == *z
-    } else {
-        false
-    }
-}
diff --git a/tests/codegen/issues/issue-47278.rs b/tests/codegen/issues/issue-47278.rs
deleted file mode 100644
index 4f0a5bdf36f..00000000000
--- a/tests/codegen/issues/issue-47278.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// -C no-prepopulate-passes
-#![crate_type = "staticlib"]
-
-#[repr(C)]
-pub struct Foo(u64);
-
-// CHECK: define {{.*}} @foo(
-#[no_mangle]
-pub extern "C" fn foo(_: Foo) -> Foo {
-    loop {}
-}
diff --git a/tests/codegen/issues/issue-47442.rs b/tests/codegen/issues/issue-47442.rs
deleted file mode 100644
index 445234e55ad..00000000000
--- a/tests/codegen/issues/issue-47442.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// check that we don't emit unneeded `resume` cleanup blocks for every
-// destructor.
-
-// CHECK-NOT: Unwind
-
-#![feature(test)]
-#![crate_type = "rlib"]
-
-extern crate test;
-
-struct Foo {}
-
-impl Drop for Foo {
-    fn drop(&mut self) {
-        test::black_box(());
-    }
-}
-
-#[no_mangle]
-pub fn foo() {
-    let _foo = Foo {};
-}
diff --git a/tests/codegen/issues/issue-56267-2.rs b/tests/codegen/issues/issue-56267-2.rs
deleted file mode 100644
index 98e3732777e..00000000000
--- a/tests/codegen/issues/issue-56267-2.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "rlib"]
-
-#[allow(dead_code)]
-pub struct Foo<T> {
-    foo: u64,
-    bar: T,
-}
-
-// The load from bar.1 should have alignment 4. Not checking
-// other loads here, as the alignment will be platform-dependent.
-
-// CHECK: %{{.+}} = load i32, ptr %{{.+}}, align 4
-#[no_mangle]
-pub fn test(x: Foo<(i32, i32)>) -> (i32, i32) {
-    x.bar
-}
diff --git a/tests/codegen/issues/issue-56267.rs b/tests/codegen/issues/issue-56267.rs
deleted file mode 100644
index cabcc298482..00000000000
--- a/tests/codegen/issues/issue-56267.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "rlib"]
-
-#[allow(dead_code)]
-pub struct Foo<T> {
-    foo: u64,
-    bar: T,
-}
-
-// The store writing to bar.1 should have alignment 4. Not checking
-// other stores here, as the alignment will be platform-dependent.
-
-// CHECK: store i32 [[TMP1:%.+]], ptr [[TMP2:%.+]], align 4
-#[no_mangle]
-pub fn test(x: (i32, i32)) -> Foo<(i32, i32)> {
-    Foo { foo: 0, bar: x }
-}
diff --git a/tests/codegen/issues/issue-56927.rs b/tests/codegen/issues/issue-56927.rs
deleted file mode 100644
index 415ef073e03..00000000000
--- a/tests/codegen/issues/issue-56927.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-// 32bit MSVC does not align things properly so we suppress high alignment annotations (#112480)
-//@ ignore-i686-pc-windows-msvc
-//@ ignore-i686-pc-windows-gnu
-
-#![crate_type = "rlib"]
-
-#[repr(align(16))]
-pub struct S {
-    arr: [u32; 4],
-}
-
-// CHECK-LABEL: @test1
-// CHECK: store i32 0, ptr %{{.+}}, align 16
-// CHECK: store i32 1, ptr %{{.+}}, align 4
-// CHECK: store i32 2, ptr %{{.+}}, align 8
-// CHECK: store i32 3, ptr %{{.+}}, align 4
-#[no_mangle]
-pub fn test1(s: &mut S) {
-    s.arr[0] = 0;
-    s.arr[1] = 1;
-    s.arr[2] = 2;
-    s.arr[3] = 3;
-}
-
-// CHECK-LABEL: @test2
-// CHECK: store i32 4, ptr %{{.+}}, align 4
-#[allow(unconditional_panic)]
-#[no_mangle]
-pub fn test2(s: &mut S) {
-    s.arr[usize::MAX / 4 + 1] = 4;
-}
-
-// CHECK-LABEL: @test3
-// CHECK: store i32 5, ptr %{{.+}}, align 4
-#[no_mangle]
-pub fn test3(s: &mut S, i: usize) {
-    s.arr[i] = 5;
-}
-
-// CHECK-LABEL: @test4
-// CHECK: store i32 6, ptr %{{.+}}, align 4
-#[no_mangle]
-pub fn test4(s: &mut S) {
-    s.arr = [6; 4];
-}
diff --git a/tests/codegen/issues/issue-58881.rs b/tests/codegen/issues/issue-58881.rs
deleted file mode 100644
index ba6285f3972..00000000000
--- a/tests/codegen/issues/issue-58881.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-//
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-extern "C" {
-    fn variadic_fn(_: i32, ...);
-}
-
-#[repr(C)]
-struct Foo(u8);
-#[repr(C)]
-struct Bar(u64, u64, u64);
-
-// Ensure that emit arguments of the correct type.
-pub unsafe fn test_call_variadic() {
-    // CHECK: call void (i32, ...) @variadic_fn(i32 0, i8 {{.*}}, ptr {{.*}})
-    variadic_fn(0, Foo(0), Bar(0, 0, 0))
-}
diff --git a/tests/codegen/issues/issue-59352.rs b/tests/codegen/issues/issue-59352.rs
deleted file mode 100644
index cb4383d4a30..00000000000
--- a/tests/codegen/issues/issue-59352.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// This test is a mirror of mir-opt/issues/issue-59352.rs. The LLVM inliner doesn't inline
-// `char::method::is_digit()` and `char::method::to_digit()`, probably because of their size.
-//
-// Currently, the MIR optimizer isn't capable of removing the unreachable panic in this test case.
-// Once the optimizer can do that, mir-opt/issues/issue-59352.rs will need to be updated and this
-// test case should be removed as it will become redundant.
-
-// mir-opt-level=3 enables inlining and enables LLVM to optimize away the unreachable panic call.
-//@ compile-flags: -Copt-level=3 -Z mir-opt-level=3
-
-#![crate_type = "rlib"]
-
-// CHECK-LABEL: @num_to_digit
-#[no_mangle]
-pub fn num_to_digit(num: char) -> u32 {
-    // CHECK-NOT: panic
-    if num.is_digit(8) { num.to_digit(8).unwrap() } else { 0 }
-}
diff --git a/tests/codegen/issues/issue-64219-fn-ptr-call-returning-never-is-noreturn.rs b/tests/codegen/issues/issue-64219-fn-ptr-call-returning-never-is-noreturn.rs
deleted file mode 100644
index 86d020e1751..00000000000
--- a/tests/codegen/issues/issue-64219-fn-ptr-call-returning-never-is-noreturn.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//! Test for https://github.com/rust-lang/rust/issues/64219
-//! Check if `noreturn` attribute is applied on calls to
-//! function pointers returning `!` (never type).
-
-#![crate_type = "lib"]
-
-extern "C" {
-    static FOO: fn() -> !;
-}
-
-// CHECK-LABEL: @foo
-#[no_mangle]
-pub unsafe fn foo() {
-    // CHECK: call
-    // CHECK-SAME: [[NUM:#[0-9]+$]]
-    FOO();
-}
-
-// CHECK: attributes [[NUM]] = {{{.*}} noreturn {{.*}}}
diff --git a/tests/codegen/issues/issue-68667-unwrap-combinators.rs b/tests/codegen/issues/issue-68667-unwrap-combinators.rs
deleted file mode 100644
index 7f4a32109fe..00000000000
--- a/tests/codegen/issues/issue-68667-unwrap-combinators.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![crate_type = "lib"]
-
-//@ compile-flags: -Copt-level=3
-
-// MIR inlining now optimizes this code.
-
-// CHECK-LABEL: @unwrap_combinators
-// CHECK: {{icmp|trunc}}
-// CHECK-NEXT: icmp
-// CHECK-NEXT: select i1
-// CHECK-NEXT: ret i1
-#[no_mangle]
-pub fn unwrap_combinators(a: Option<i32>, b: i32) -> bool {
-    a.map(|t| t >= b).unwrap_or(false)
-}
diff --git a/tests/codegen/issues/issue-69101-bounds-check.rs b/tests/codegen/issues/issue-69101-bounds-check.rs
deleted file mode 100644
index 953b79aa263..00000000000
--- a/tests/codegen/issues/issue-69101-bounds-check.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// Make sure no bounds checks are emitted in the loop when upfront slicing
-// ensures that the slices are big enough.
-// In particular, bounds checks were not always optimized out if the upfront
-// check was for a greater len than the loop requires.
-// (i.e. `already_sliced_no_bounds_check` was not always optimized even when
-// `already_sliced_no_bounds_check_exact` was)
-// CHECK-LABEL: @already_sliced_no_bounds_check
-#[no_mangle]
-pub fn already_sliced_no_bounds_check(a: &[u8], b: &[u8], c: &mut [u8]) {
-    // CHECK: slice_end_index_len_fail
-    // CHECK-NOT: panic_bounds_check
-    let _ = (&a[..2048], &b[..2048], &mut c[..2048]);
-    for i in 0..1024 {
-        c[i] = a[i] ^ b[i];
-    }
-}
-
-// CHECK-LABEL: @already_sliced_no_bounds_check_exact
-#[no_mangle]
-pub fn already_sliced_no_bounds_check_exact(a: &[u8], b: &[u8], c: &mut [u8]) {
-    // CHECK: slice_end_index_len_fail
-    // CHECK-NOT: panic_bounds_check
-    let _ = (&a[..1024], &b[..1024], &mut c[..1024]);
-    for i in 0..1024 {
-        c[i] = a[i] ^ b[i];
-    }
-}
-
-// Make sure we're checking for the right thing: there can be a panic if the slice is too small.
-// CHECK-LABEL: @already_sliced_bounds_check
-#[no_mangle]
-pub fn already_sliced_bounds_check(a: &[u8], b: &[u8], c: &mut [u8]) {
-    // CHECK: slice_end_index_len_fail
-    // CHECK: panic_bounds_check
-    let _ = (&a[..1023], &b[..2048], &mut c[..2048]);
-    for i in 0..1024 {
-        c[i] = a[i] ^ b[i];
-    }
-}
diff --git a/tests/codegen/issues/issue-73031.rs b/tests/codegen/issues/issue-73031.rs
deleted file mode 100644
index 80dea9b5bc2..00000000000
--- a/tests/codegen/issues/issue-73031.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// Test that LLVM can eliminate the unreachable `All::None` branch.
-
-pub enum All {
-    None,
-    Foo,
-    Bar,
-}
-
-// CHECK-LABEL: @issue_73031
-#[no_mangle]
-pub fn issue_73031(a: &mut All, q: i32) -> i32 {
-    *a = if q == 5 { All::Foo } else { All::Bar };
-    match *a {
-        // CHECK-NOT: panic
-        All::None => panic!(),
-        All::Foo => 1,
-        All::Bar => 2,
-    }
-}
diff --git a/tests/codegen/issues/issue-73258.rs b/tests/codegen/issues/issue-73258.rs
deleted file mode 100644
index 936a7554496..00000000000
--- a/tests/codegen/issues/issue-73258.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// Adapted from <https://github.com/rust-lang/rust/issues/73258#issue-637346014>
-
-#[derive(Clone, Copy)]
-#[repr(u8)]
-pub enum Foo {
-    A,
-    B,
-    C,
-    D,
-}
-
-// CHECK-LABEL: @issue_73258(
-#[no_mangle]
-pub unsafe fn issue_73258(ptr: *const Foo) -> Foo {
-    // CHECK-NOT: icmp
-    // CHECK-NOT: call
-    // CHECK-NOT: br
-    // CHECK-NOT: select
-
-    // CHECK: %[[R:.+]] = load i8
-    // CHECK-SAME: !range !
-
-    // CHECK-NOT: icmp
-    // CHECK-NOT: call
-    // CHECK-NOT: br
-    // CHECK-NOT: select
-
-    // CHECK: ret i8 %[[R]]
-
-    // CHECK-NOT: icmp
-    // CHECK-NOT: call
-    // CHECK-NOT: br
-    // CHECK-NOT: select
-    let k: Option<Foo> = Some(ptr.read());
-    return k.unwrap();
-}
diff --git a/tests/codegen/issues/issue-73338-effecient-cmp.rs b/tests/codegen/issues/issue-73338-effecient-cmp.rs
deleted file mode 100644
index 71641a5457b..00000000000
--- a/tests/codegen/issues/issue-73338-effecient-cmp.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-// This test checks that comparison operation
-// generated by #[derive(PartialOrd)]
-// doesn't contain jumps for C enums
-
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[repr(u32)]
-#[derive(Copy, Clone, Eq, PartialEq, PartialOrd)]
-pub enum Foo {
-    Zero,
-    One,
-    Two,
-}
-
-#[no_mangle]
-pub fn compare_less(a: Foo, b: Foo) -> bool {
-    // CHECK-NOT: br {{.*}}
-    a < b
-}
-
-#[no_mangle]
-pub fn compare_le(a: Foo, b: Foo) -> bool {
-    // CHECK-NOT: br {{.*}}
-    a <= b
-}
-
-#[no_mangle]
-pub fn compare_ge(a: Foo, b: Foo) -> bool {
-    // CHECK-NOT: br {{.*}}
-    a >= b
-}
-
-#[no_mangle]
-pub fn compare_greater(a: Foo, b: Foo) -> bool {
-    // CHECK-NOT: br {{.*}}
-    a > b
-}
diff --git a/tests/codegen/issues/issue-73396-bounds-check-after-position.rs b/tests/codegen/issues/issue-73396-bounds-check-after-position.rs
deleted file mode 100644
index 1e2c25babe0..00000000000
--- a/tests/codegen/issues/issue-73396-bounds-check-after-position.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// Make sure no bounds checks are emitted when slicing or indexing
-// with an index from `position()` or `rposition()`.
-
-// CHECK-LABEL: @position_slice_to_no_bounds_check
-#[no_mangle]
-pub fn position_slice_to_no_bounds_check(s: &[u8]) -> &[u8] {
-    // CHECK-NOT: panic
-    // CHECK-NOT: slice_start_index_len_fail
-    // CHECK-NOT: slice_end_index_len_fail
-    // CHECK-NOT: panic_bounds_check
-    // CHECK-NOT: unreachable
-    if let Some(idx) = s.iter().position(|b| *b == b'\\') { &s[..idx] } else { s }
-}
-
-// CHECK-LABEL: @position_slice_from_no_bounds_check
-#[no_mangle]
-pub fn position_slice_from_no_bounds_check(s: &[u8]) -> &[u8] {
-    // CHECK-NOT: panic
-    // CHECK-NOT: slice_start_index_len_fail
-    // CHECK-NOT: slice_end_index_len_fail
-    // CHECK-NOT: panic_bounds_check
-    // CHECK-NOT: unreachable
-    if let Some(idx) = s.iter().position(|b| *b == b'\\') { &s[idx..] } else { s }
-}
-
-// CHECK-LABEL: @position_index_no_bounds_check
-#[no_mangle]
-pub fn position_index_no_bounds_check(s: &[u8]) -> u8 {
-    // CHECK-NOT: panic
-    // CHECK-NOT: slice_start_index_len_fail
-    // CHECK-NOT: slice_end_index_len_fail
-    // CHECK-NOT: panic_bounds_check
-    // CHECK-NOT: unreachable
-    if let Some(idx) = s.iter().position(|b| *b == b'\\') { s[idx] } else { 42 }
-}
-// CHECK-LABEL: @rposition_slice_to_no_bounds_check
-#[no_mangle]
-pub fn rposition_slice_to_no_bounds_check(s: &[u8]) -> &[u8] {
-    // CHECK-NOT: panic
-    // CHECK-NOT: slice_start_index_len_fail
-    // CHECK-NOT: slice_end_index_len_fail
-    // CHECK-NOT: panic_bounds_check
-    // CHECK-NOT: unreachable
-    if let Some(idx) = s.iter().rposition(|b| *b == b'\\') { &s[..idx] } else { s }
-}
-
-// CHECK-LABEL: @rposition_slice_from_no_bounds_check
-#[no_mangle]
-pub fn rposition_slice_from_no_bounds_check(s: &[u8]) -> &[u8] {
-    // CHECK-NOT: panic
-    // CHECK-NOT: slice_start_index_len_fail
-    // CHECK-NOT: slice_end_index_len_fail
-    // CHECK-NOT: panic_bounds_check
-    // CHECK-NOT: unreachable
-    if let Some(idx) = s.iter().rposition(|b| *b == b'\\') { &s[idx..] } else { s }
-}
-
-// CHECK-LABEL: @rposition_index_no_bounds_check
-#[no_mangle]
-pub fn rposition_index_no_bounds_check(s: &[u8]) -> u8 {
-    // CHECK-NOT: panic
-    // CHECK-NOT: slice_start_index_len_fail
-    // CHECK-NOT: slice_end_index_len_fail
-    // CHECK-NOT: panic_bounds_check
-    // CHECK-NOT: unreachable
-    if let Some(idx) = s.iter().rposition(|b| *b == b'\\') { s[idx] } else { 42 }
-}
diff --git a/tests/codegen/issues/issue-73827-bounds-check-index-in-subexpr.rs b/tests/codegen/issues/issue-73827-bounds-check-index-in-subexpr.rs
deleted file mode 100644
index e9dd0d1bf23..00000000000
--- a/tests/codegen/issues/issue-73827-bounds-check-index-in-subexpr.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// This test checks that bounds checks are elided when
-// index is part of a (x | y) < C style condition
-
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @get
-#[no_mangle]
-pub fn get(array: &[u8; 8], x: usize, y: usize) -> u8 {
-    if x > 7 || y > 7 {
-        0
-    } else {
-        // CHECK-NOT: panic_bounds_check
-        array[y]
-    }
-}
diff --git a/tests/codegen/issues/issue-74938-array-split-at.rs b/tests/codegen/issues/issue-74938-array-split-at.rs
deleted file mode 100644
index 9d3e23d642b..00000000000
--- a/tests/codegen/issues/issue-74938-array-split-at.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-const N: usize = 3;
-pub type T = u8;
-
-// CHECK-LABEL: @split_multiple
-// CHECK-NOT: unreachable
-#[no_mangle]
-pub fn split_multiple(slice: &[T]) -> (&[T], &[T]) {
-    let len = slice.len() / N;
-    slice.split_at(len * N)
-}
diff --git a/tests/codegen/issues/issue-75525-bounds-checks.rs b/tests/codegen/issues/issue-75525-bounds-checks.rs
deleted file mode 100644
index 5dfbd350010..00000000000
--- a/tests/codegen/issues/issue-75525-bounds-checks.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Regression test for #75525, verifies that no bounds checks are generated.
-
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @f0
-// CHECK-NOT: panic
-#[no_mangle]
-pub fn f0(idx: usize, buf: &[u8; 10]) -> u8 {
-    if idx < 8 { buf[idx + 1] } else { 0 }
-}
-
-// CHECK-LABEL: @f1
-// CHECK-NOT: panic
-#[no_mangle]
-pub fn f1(idx: usize, buf: &[u8; 10]) -> u8 {
-    if idx > 5 && idx < 8 { buf[idx - 1] } else { 0 }
-}
-
-// CHECK-LABEL: @f2
-// CHECK-NOT: panic
-#[no_mangle]
-pub fn f2(idx: usize, buf: &[u8; 10]) -> u8 {
-    if idx > 5 && idx < 8 { buf[idx] } else { 0 }
-}
diff --git a/tests/codegen/issues/issue-75546.rs b/tests/codegen/issues/issue-75546.rs
deleted file mode 100644
index 1e1e6543a88..00000000000
--- a/tests/codegen/issues/issue-75546.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// Test that LLVM can eliminate the impossible `i == 0` check.
-
-// CHECK-LABEL: @issue_75546
-#[no_mangle]
-pub fn issue_75546() {
-    let mut i = 1u32;
-    while i < u32::MAX {
-        // CHECK-NOT: panic
-        if i == 0 {
-            panic!();
-        }
-        i += 1;
-    }
-}
diff --git a/tests/codegen/issues/issue-75659.rs b/tests/codegen/issues/issue-75659.rs
deleted file mode 100644
index 0960bfdb6b0..00000000000
--- a/tests/codegen/issues/issue-75659.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// This test checks that the call to memchr/slice_contains is optimized away
-// when searching in small slices.
-
-//@ compile-flags: -Copt-level=3 -Zinline-mir=false
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @foo1
-#[no_mangle]
-pub fn foo1(x: u8, data: &[u8; 1]) -> bool {
-    // CHECK-NOT: memchr
-    // CHECK-NOT: slice_contains
-    data.contains(&x)
-}
-
-// CHECK-LABEL: @foo2
-#[no_mangle]
-pub fn foo2(x: u8, data: &[u8; 2]) -> bool {
-    // CHECK-NOT: memchr
-    // CHECK-NOT: slice_contains
-    data.contains(&x)
-}
-
-// CHECK-LABEL: @foo3
-#[no_mangle]
-pub fn foo3(x: u8, data: &[u8; 3]) -> bool {
-    // CHECK-NOT: memchr
-    // CHECK-NOT: slice_contains
-    data.contains(&x)
-}
-
-// CHECK-LABEL: @foo4
-#[no_mangle]
-pub fn foo4(x: u8, data: &[u8; 4]) -> bool {
-    // CHECK-NOT: memchr
-    // CHECK-NOT: slice_contains
-    data.contains(&x)
-}
-
-// CHECK-LABEL: @foo8
-#[no_mangle]
-pub fn foo8(x: u8, data: &[u8; 8]) -> bool {
-    // CHECK-NOT: memchr
-    // CHECK-NOT: slice_contains
-    data.contains(&x)
-}
-
-// CHECK-LABEL: @foo8_i8
-#[no_mangle]
-pub fn foo8_i8(x: i8, data: &[i8; 8]) -> bool {
-    // CHECK-NOT: memchr
-    // CHECK-NOT: slice_contains
-    !data.contains(&x)
-}
-
-// Check that the general case isn't inlined
-// CHECK-LABEL: @foo80
-#[no_mangle]
-pub fn foo80(x: u8, data: &[u8; 80]) -> bool {
-    // CHECK: call core::slice::memchr
-    data.contains(&x)
-}
diff --git a/tests/codegen/issues/issue-75978.rs b/tests/codegen/issues/issue-75978.rs
deleted file mode 100644
index f4b0bc36329..00000000000
--- a/tests/codegen/issues/issue-75978.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn test() -> u32 {
-    // CHECK-LABEL: @test(
-    // CHECK: ret i32 13
-    let s = [1, 2, 3, 4, 5, 6, 7];
-
-    let mut iter = s.iter();
-    let mut sum = 0;
-    while let Some(_) = iter.next() {
-        sum += iter.next().map_or(1, |&x| x)
-    }
-
-    sum
-}
diff --git a/tests/codegen/issues/issue-77812.rs b/tests/codegen/issues/issue-77812.rs
deleted file mode 100644
index 09e2376c30d..00000000000
--- a/tests/codegen/issues/issue-77812.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// Test that LLVM can eliminate the unreachable `Variant::Zero` branch.
-
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub enum Variant {
-    Zero,
-    One,
-    Two,
-}
-
-extern "C" {
-    fn exf1();
-    fn exf2();
-}
-
-pub static mut GLOBAL: Variant = Variant::Zero;
-
-// CHECK-LABEL: @issue_77812
-#[no_mangle]
-pub unsafe fn issue_77812() {
-    let g = GLOBAL;
-    if g != Variant::Zero {
-        match g {
-            Variant::One => exf1(),
-            Variant::Two => exf2(),
-            // CHECK-NOT: panic
-            Variant::Zero => panic!(),
-        }
-    }
-}
diff --git a/tests/codegen/issues/issue-84268.rs b/tests/codegen/issues/issue-84268.rs
deleted file mode 100644
index 1dc55a909ad..00000000000
--- a/tests/codegen/issues/issue-84268.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ compile-flags: -Copt-level=3 --crate-type=rlib
-#![feature(core_intrinsics, repr_simd)]
-
-use std::intrinsics::simd::{simd_eq, simd_fabs};
-
-#[repr(simd)]
-pub struct V([f32; 4]);
-
-#[repr(simd)]
-pub struct M([i32; 4]);
-
-#[no_mangle]
-// CHECK-LABEL: @is_infinite
-pub fn is_infinite(v: V) -> M {
-    // CHECK: fabs
-    // CHECK: cmp oeq
-    unsafe { simd_eq(simd_fabs(v), V([f32::INFINITY; 4])) }
-}
diff --git a/tests/codegen/issues/issue-85872-multiple-reverse.rs b/tests/codegen/issues/issue-85872-multiple-reverse.rs
deleted file mode 100644
index 6f566ddee6b..00000000000
--- a/tests/codegen/issues/issue-85872-multiple-reverse.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn u16_be_to_arch(mut data: [u8; 2]) -> [u8; 2] {
-    // CHECK-LABEL: @u16_be_to_arch
-    // CHECK: @llvm.bswap.i16
-    data.reverse();
-    data
-}
-
-#[no_mangle]
-pub fn u32_be_to_arch(mut data: [u8; 4]) -> [u8; 4] {
-    // CHECK-LABEL: @u32_be_to_arch
-    // CHECK: @llvm.bswap.i32
-    data.reverse();
-    data
-}
diff --git a/tests/codegen/issues/issue-86106.rs b/tests/codegen/issues/issue-86106.rs
deleted file mode 100644
index 8d1ce116d26..00000000000
--- a/tests/codegen/issues/issue-86106.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-//@ only-64bit llvm appears to use stores instead of memset on 32bit
-//@ compile-flags: -C opt-level=3 -Z merge-functions=disabled
-//@ needs-deterministic-layouts
-
-// The below two functions ensure that both `String::new()` and `"".to_string()`
-// produce the identical code.
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: define {{(dso_local )?}}void @string_new
-#[no_mangle]
-pub fn string_new() -> String {
-    // CHECK-NOT: load i8
-    // CHECK: store i{{32|64}}
-    // CHECK-NEXT: getelementptr
-    // CHECK-NEXT: store ptr
-    // CHECK-NEXT: getelementptr
-    // CHECK-NEXT: store i{{32|64}}
-    // CHECK-NEXT: ret void
-    String::new()
-}
-
-// CHECK-LABEL: define {{(dso_local )?}}void @empty_to_string
-#[no_mangle]
-pub fn empty_to_string() -> String {
-    // CHECK-NOT: load i8
-    // CHECK: store i{{32|64}}
-    // CHECK-NEXT: getelementptr
-    // CHECK-NEXT: store ptr
-    // CHECK-NEXT: getelementptr
-    // CHECK-NEXT: store i{{32|64}}
-    // CHECK-NEXT: ret void
-    "".to_string()
-}
-
-// The below two functions ensure that both `vec![]` and `vec![].clone()`
-// produce the identical code.
-
-// CHECK-LABEL: @empty_vec
-#[no_mangle]
-pub fn empty_vec() -> Vec<u8> {
-    // CHECK: store i{{32|64}}
-    // CHECK-NOT: load i8
-    // CHECK-NEXT: getelementptr
-    // CHECK-NEXT: store ptr
-    // CHECK-NEXT: getelementptr
-    // CHECK-NEXT: store i{{32|64}}
-    // CHECK-NEXT: ret void
-    vec![]
-}
-
-// CHECK-LABEL: @empty_vec_clone
-#[no_mangle]
-pub fn empty_vec_clone() -> Vec<u8> {
-    // CHECK: store i{{32|64}}
-    // CHECK-NOT: load i8
-    // CHECK-NEXT: getelementptr
-    // CHECK-NEXT: store ptr
-    // CHECK-NEXT: getelementptr
-    // CHECK-NEXT: store i{{32|64}}
-    // CHECK-NEXT: ret void
-    vec![].clone()
-}
diff --git a/tests/codegen/issues/issue-86109-eliminate-div-by-zero-check.rs b/tests/codegen/issues/issue-86109-eliminate-div-by-zero-check.rs
deleted file mode 100644
index 345c09738b6..00000000000
--- a/tests/codegen/issues/issue-86109-eliminate-div-by-zero-check.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//! Test for https://github.com/rust-lang/rust/issues/86109
-//! Check LLVM can eliminate the impossible division by zero check by
-//! ensuring there is no call (to panic) instruction.
-//!
-//! This has been fixed since `rustc 1.70.0`.
-
-#![crate_type = "lib"]
-
-type T = i16;
-
-// CHECK-LABEL: @foo
-#[no_mangle]
-pub fn foo(start: T) -> T {
-    // CHECK-NOT: panic
-    if start <= 0 {
-        return 0;
-    }
-    let mut count = 0;
-    for i in start..10_000 {
-        if 752 % i != 0 {
-            count += 1;
-        }
-    }
-    count
-}
diff --git a/tests/codegen/issues/issue-93036-assert-index.rs b/tests/codegen/issues/issue-93036-assert-index.rs
deleted file mode 100644
index 46f45c2f06e..00000000000
--- a/tests/codegen/issues/issue-93036-assert-index.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-// CHECK-LABEL: @foo
-// CHECK-NOT: unreachable
-pub fn foo(arr: &mut [u32]) {
-    for i in 0..arr.len() {
-        for j in 0..i {
-            assert!(j < arr.len());
-        }
-    }
-}
diff --git a/tests/codegen/issues/issue-96274.rs b/tests/codegen/issues/issue-96274.rs
deleted file mode 100644
index 2425ec53e4e..00000000000
--- a/tests/codegen/issues/issue-96274.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-use std::mem::MaybeUninit;
-
-pub fn maybe_uninit() -> [MaybeUninit<u8>; 3000] {
-    // CHECK-NOT: memset
-    [MaybeUninit::uninit(); 3000]
-}
-
-pub fn maybe_uninit_const<T>() -> [MaybeUninit<T>; 8192] {
-    // CHECK-NOT: memset
-    [const { MaybeUninit::uninit() }; 8192]
-}
diff --git a/tests/codegen/issues/issue-96497-slice-size-nowrap.rs b/tests/codegen/issues/issue-96497-slice-size-nowrap.rs
deleted file mode 100644
index 7b3a20a295e..00000000000
--- a/tests/codegen/issues/issue-96497-slice-size-nowrap.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// This test case checks that LLVM is aware that computing the size of a slice cannot wrap.
-// The possibility of wrapping results in an additional branch when dropping boxed slices
-// in some situations, see https://github.com/rust-lang/rust/issues/96497#issuecomment-1112865218
-
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @simple_size_of_nowrap
-#[no_mangle]
-pub fn simple_size_of_nowrap(x: &[u32]) -> usize {
-    // Make sure the shift used to compute the size has a nowrap flag.
-
-    // CHECK: [[A:%.*]] = shl nuw nsw {{.*}}, 2
-    // CHECK-NEXT: ret {{.*}} [[A]]
-    core::mem::size_of_val(x)
-}
-
-// CHECK-LABEL: @drop_write
-#[no_mangle]
-pub fn drop_write(mut x: Box<[u32]>) {
-    // Check that this write is optimized out.
-    // This depends on the size calculation not wrapping,
-    // since otherwise LLVM can't tell that the memory is always deallocated if the slice len > 0.
-
-    // CHECK-NOT: store i32 42
-    x[1] = 42;
-}
-
-// CHECK-LABEL: @slice_size_plus_2
-#[no_mangle]
-pub fn slice_size_plus_2(x: &[u16]) -> usize {
-    // Before #136575 this didn't get the `nuw` in the add.
-
-    // CHECK: [[BYTES:%.+]] = shl nuw nsw {{i16|i32|i64}} %x.1, 1
-    // CHECK: = add nuw {{i16|i32|i64}} [[BYTES]], 2
-    core::mem::size_of_val(x) + 2
-}
diff --git a/tests/codegen/issues/issue-98294-get-mut-copy-from-slice-opt.rs b/tests/codegen/issues/issue-98294-get-mut-copy-from-slice-opt.rs
deleted file mode 100644
index 76adcf9fd45..00000000000
--- a/tests/codegen/issues/issue-98294-get-mut-copy-from-slice-opt.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// There should be no calls to panic / len_mismatch_fail.
-
-#[no_mangle]
-pub fn test(a: &mut [u8], offset: usize, bytes: &[u8]) {
-    // CHECK-LABEL: @test(
-    // CHECK-NOT: call
-    // CHECK: call void @llvm.memcpy
-    // CHECK-NOT: call
-    // CHECK: }
-    if let Some(dst) = a.get_mut(offset..offset + bytes.len()) {
-        dst.copy_from_slice(bytes);
-    }
-}
diff --git a/tests/codegen/issues/issue-98678-async.rs b/tests/codegen/issues/issue-98678-async.rs
deleted file mode 100644
index 3dd06bb5194..00000000000
--- a/tests/codegen/issues/issue-98678-async.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// ignore-tidy-linelength
-//! This test verifies the accuracy of emitted file and line debuginfo metadata for async blocks and
-//! async functions.
-
-//@ revisions: MSVC NONMSVC
-//@[MSVC] only-msvc
-//@[NONMSVC] ignore-msvc
-//@ edition:2021
-//@ compile-flags: --crate-type=lib -Copt-level=0 -Cdebuginfo=2 -Zdebug-info-type-line-numbers=true
-
-// NONMSVC-DAG: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*[/\\]}}issue-98678-async.rs{{".*}})
-// MSVC: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*}}\\issue-98678-async.rs{{".*}})
-
-// NONMSVC-DAG: !DISubprogram(name: "foo",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-// MSVC-DAG: !DISubprogram(name: "foo",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-pub async fn foo() -> u8 {
-    5
-}
-
-pub fn bar() -> impl std::future::Future<Output = u8> {
-    // NONMSVC: !DICompositeType({{.*"}}{async_block_env#0}{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-    // MSVC-DAG: !DICompositeType({{.*"}}enum2$<issue_98678_async::bar::async_block_env$0>{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-    async {
-        let x: u8 = foo().await;
-        x + 5
-    }
-}
diff --git a/tests/codegen/issues/issue-98678-closure-coroutine.rs b/tests/codegen/issues/issue-98678-closure-coroutine.rs
deleted file mode 100644
index 8763bcb799d..00000000000
--- a/tests/codegen/issues/issue-98678-closure-coroutine.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// ignore-tidy-linelength
-//! This test verifies the accuracy of emitted file and line debuginfo metadata for closures and
-//! coroutines.
-
-#![feature(coroutines, stmt_expr_attributes)]
-
-//@ revisions: MSVC NONMSVC
-//@[MSVC] only-msvc
-//@[NONMSVC] ignore-msvc
-//@ compile-flags: --crate-type=lib -Copt-level=0 -Cdebuginfo=2 -Zdebug-info-type-line-numbers=true
-
-// NONMSVC-DAG: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*[/\\]}}issue-98678-closure-coroutine.rs{{".*}})
-// MSVC-DAG: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*}}\\issue-98678-closure-coroutine.rs{{".*}})
-
-pub fn foo() {
-    // NONMSVC-DAG: !DICompositeType({{.*"}}{closure_env#0}{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-    // MSVC-DAG: !DICompositeType({{.*"}}closure_env$0{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-    let closure = |x| x;
-    closure(0);
-
-    // NONMSVC-DAG: !DICompositeType({{.*"[{]}}coroutine_env#1{{[}]".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 3]],
-    // MSVC-DAG: !DICompositeType({{.*".*foo::}}coroutine_env$1>{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-    let _coroutine = #[coroutine]
-    || yield 1;
-}
diff --git a/tests/codegen/issues/issue-98678-enum.rs b/tests/codegen/issues/issue-98678-enum.rs
deleted file mode 100644
index 87bf8797293..00000000000
--- a/tests/codegen/issues/issue-98678-enum.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-// ignore-tidy-linelength
-//! This test verifies the accuracy of emitted file and line debuginfo metadata enums.
-
-//@ revisions: MSVC NONMSVC
-//@[MSVC] only-msvc
-//@[NONMSVC] ignore-msvc
-//@ compile-flags: --crate-type=lib -Copt-level=0 -Cdebuginfo=2 -Zdebug-info-type-line-numbers=true
-
-// NONMSVC: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*[/\\]}}issue-98678-enum.rs{{".*}})
-// MSVC: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*}}\\issue-98678-enum.rs{{".*}})
-
-// NONMSVC: !DICompositeType({{.*"}}SingleCase{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-// MSVC: !DICompositeType({{.*"}}enum2$<issue_98678_enum::SingleCase>{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-pub enum SingleCase {
-    // NONMSVC: !DIDerivedType(tag: DW_TAG_member, name: "One",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-    // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "One",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-    One,
-}
-
-// NONMSVC: !DICompositeType({{.*"}}MultipleDataCases{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-// MSVC: !DICompositeType({{.*"}}enum2$<issue_98678_enum::MultipleDataCases>{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-pub enum MultipleDataCases {
-    // NONMSVC: !DIDerivedType(tag: DW_TAG_member, name: "Case1",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-    // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Case1",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-    Case1(u32),
-    // NONMSVC: !DIDerivedType(tag: DW_TAG_member, name: "Case2",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-    // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Case2",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-    Case2(i64),
-}
-
-// NONMSVC: !DICompositeType({{.*"}}NicheLayout{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-// MSVC: !DICompositeType({{.*"}}enum2$<issue_98678_enum::NicheLayout>{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-pub enum NicheLayout {
-    // NONMSVC: !DIDerivedType(tag: DW_TAG_member, name: "Something",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-    // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Something",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-    Something(&'static u32),
-    // NONMSVC: !DIDerivedType(tag: DW_TAG_member, name: "Nothing",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 2]],
-    // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "Nothing",{{.*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-    Nothing,
-}
-
-pub fn foo(_: SingleCase, _: MultipleDataCases, _: NicheLayout) {}
diff --git a/tests/codegen/issues/issue-98678-struct-union.rs b/tests/codegen/issues/issue-98678-struct-union.rs
deleted file mode 100644
index a83a585a433..00000000000
--- a/tests/codegen/issues/issue-98678-struct-union.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// ignore-tidy-linelength
-//! This test verifies the accuracy of emitted file and line debuginfo metadata for structs and
-//! unions.
-
-//@ revisions: MSVC NONMSVC
-//@[MSVC] only-msvc
-//@[NONMSVC] ignore-msvc
-//@ compile-flags: --crate-type=lib -Copt-level=0 -Cdebuginfo=2 -Zdebug-info-type-line-numbers=true
-
-// NONMSVC: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*[/\\]}}issue-98678-struct-union.rs{{".*}})
-// MSVC: ![[#FILE:]] = !DIFile({{.*}}filename:{{.*}}\\issue-98678-struct-union.rs{{".*}})
-
-// CHECK: !DICompositeType({{.*"}}MyType{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-pub struct MyType {
-    // CHECK: !DIDerivedType({{.*"}}i{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-    i: i32,
-}
-
-// CHECK: !DICompositeType({{.*"}}MyUnion{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-pub union MyUnion {
-    // CHECK: !DIDerivedType({{.*"}}i{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-    i: i32,
-    // CHECK: !DIDerivedType({{.*"}}f{{".*}}file: ![[#FILE]]{{.*}}line: [[# @LINE + 1]],
-    f: f32,
-}
-
-pub fn foo(_: MyType, _: MyUnion) {}
diff --git a/tests/codegen/issues/issue-99960.rs b/tests/codegen/issues/issue-99960.rs
deleted file mode 100644
index 571a9be967d..00000000000
--- a/tests/codegen/issues/issue-99960.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn test(dividend: i64, divisor: i64) -> Option<i64> {
-    // CHECK-LABEL: @test(
-    // CHECK-NOT: panic
-    if dividend > i64::min_value() && divisor != 0 { Some(dividend / divisor) } else { None }
-}
diff --git a/tests/codegen/issues/looping-over-ne-bytes-133528.rs b/tests/codegen/issues/looping-over-ne-bytes-133528.rs
deleted file mode 100644
index 35acf765d69..00000000000
--- a/tests/codegen/issues/looping-over-ne-bytes-133528.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ min-llvm-version: 20
-#![crate_type = "lib"]
-
-/// Ensure the function is properly optimized
-/// In the issue #133528, the function was not getting optimized
-/// whereas, a version with `bytes` wrapped into a `black_box` was optimized
-/// It was probably a LLVM bug that was fixed in LLVM 20
-
-// CHECK-LABEL: @looping_over_ne_bytes
-// CHECK: icmp eq i64 %input, -1
-// CHECK-NEXT: ret i1
-#[no_mangle]
-fn looping_over_ne_bytes(input: u64) -> bool {
-    let bytes = input.to_ne_bytes();
-    bytes.iter().all(|x| *x == !0)
-}
diff --git a/tests/codegen/issues/str-to-string-128690.rs b/tests/codegen/issues/str-to-string-128690.rs
deleted file mode 100644
index d9e69764be2..00000000000
--- a/tests/codegen/issues/str-to-string-128690.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//@ compile-flags: -C opt-level=3 -Z merge-functions=disabled
-#![crate_type = "lib"]
-
-//! Make sure str::to_string is specialized not to use fmt machinery.
-//!
-//! Note that the `CHECK-NOT`s here try to match on calls to functions under `core::fmt`.
-
-// CHECK-LABEL: define {{(dso_local )?}}void @one_ref
-#[no_mangle]
-pub fn one_ref(input: &str) -> String {
-    // CHECK-NOT: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
-    input.to_string()
-}
-
-// CHECK-LABEL: define {{(dso_local )?}}void @two_ref
-#[no_mangle]
-pub fn two_ref(input: &&str) -> String {
-    // CHECK-NOT: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
-    input.to_string()
-}
-
-// CHECK-LABEL: define {{(dso_local )?}}void @thirteen_ref
-#[no_mangle]
-pub fn thirteen_ref(input: &&&&&&&&&&&&&str) -> String {
-    // CHECK-NOT: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
-    input.to_string()
-}
-
-// This is a known performance cliff because of the macro-generated
-// specialized impl. If this test suddenly starts failing,
-// consider removing the `to_string_str!` macro in `alloc/str/string.rs`.
-//
-// CHECK-LABEL: define {{(dso_local )?}}void @fourteen_ref
-#[no_mangle]
-pub fn fourteen_ref(input: &&&&&&&&&&&&&&str) -> String {
-    // CHECK: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
-    input.to_string()
-}
diff --git a/tests/codegen/iter-repeat-n-trivial-drop.rs b/tests/codegen/iter-repeat-n-trivial-drop.rs
deleted file mode 100644
index 28173530324..00000000000
--- a/tests/codegen/iter-repeat-n-trivial-drop.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-//@ compile-flags: -C opt-level=3
-//@ only-x86_64
-//@ needs-deterministic-layouts
-
-#![crate_type = "lib"]
-#![feature(iter_repeat_n)]
-#![feature(array_repeat)]
-
-#[derive(Clone)]
-pub struct NotCopy(u16);
-
-impl Drop for NotCopy {
-    fn drop(&mut self) {}
-}
-
-// For a type where `Drop::drop` doesn't do anything observable and a clone is the
-// same as a move, make sure that the extra case for the last item disappears.
-
-#[no_mangle]
-// CHECK-LABEL: @iter_repeat_n_next
-pub fn iter_repeat_n_next(it: &mut std::iter::RepeatN<NotCopy>) -> Option<NotCopy> {
-    // CHECK-NEXT: start:
-    // CHECK-NOT: br
-    // CHECK: %[[COUNT:.+]] = load i64
-    // CHECK-NEXT: %[[COUNT_ZERO:.+]] = icmp eq i64 %[[COUNT]], 0
-    // CHECK-NEXT: br i1 %[[COUNT_ZERO]], label %[[EMPTY:.+]], label %[[NOT_EMPTY:.+]]
-
-    // CHECK: [[NOT_EMPTY]]:
-    // CHECK-NOT: br
-    // CHECK: %[[DEC:.+]] = add i64 %[[COUNT]], -1
-    // CHECK-NEXT: %[[VAL:.+]] = load i16
-    // CHECK-NEXT: store i64 %[[DEC]]
-    // CHECK-NEXT: br label %[[EMPTY]]
-
-    // CHECK: [[EMPTY]]:
-    // CHECK-NOT: br
-    // CHECK: phi i16
-    // CHECK-SAME: [ %[[VAL]], %[[NOT_EMPTY]] ]
-    // CHECK-NOT: br
-    // CHECK: ret
-
-    it.next()
-}
-
-// And as a result, using the iterator can optimize without special cases for
-// the last iteration, like `memset`ing all the items in one call.
-
-#[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 1, 0\) )?}}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;
-    let mut v = Vec::with_capacity(n);
-    v.extend(std::iter::repeat_n(42_u8, n));
-    v
-}
-
-// Array repeat uses `RepeatN::next_unchecked` internally,
-// so also check that the distinction disappears there.
-
-#[no_mangle]
-// CHECK-LABEL: @array_repeat_not_copy
-pub unsafe fn array_repeat_not_copy(item: NotCopy) -> [NotCopy; 8] {
-    // CHECK: insertelement {{.+}} i16 %item
-    // CHECK: shufflevector <8 x i16> {{.+}} zeroinitializer
-    // CHECK: store <8 x i16>
-    std::array::repeat(item)
-}
diff --git a/tests/codegen/layout-size-checks.rs b/tests/codegen/layout-size-checks.rs
deleted file mode 100644
index d64a7055e0b..00000000000
--- a/tests/codegen/layout-size-checks.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-use std::alloc::Layout;
-
-type RGB48 = [u16; 3];
-
-// CHECK-LABEL: @layout_array_rgb48
-#[no_mangle]
-pub fn layout_array_rgb48(n: usize) -> Layout {
-    // CHECK-NOT: llvm.umul.with.overflow.i64
-    // CHECK: icmp ugt i64 %n, 1537228672809129301
-    // CHECK-NOT: llvm.umul.with.overflow.i64
-    // CHECK: mul nuw nsw i64 %n, 6
-    // CHECK-NOT: llvm.umul.with.overflow.i64
-    Layout::array::<RGB48>(n).unwrap()
-}
-
-// CHECK-LABEL: @layout_array_i32
-#[no_mangle]
-pub fn layout_array_i32(n: usize) -> Layout {
-    // CHECK-NOT: llvm.umul.with.overflow.i64
-    // CHECK: icmp ugt i64 %n, 2305843009213693951
-    // CHECK-NOT: llvm.umul.with.overflow.i64
-    // CHECK: shl nuw nsw i64 %n, 2
-    // CHECK-NOT: llvm.umul.with.overflow.i64
-    Layout::array::<i32>(n).unwrap()
-}
diff --git a/tests/codegen/lib-optimizations/iter-sum.rs b/tests/codegen/lib-optimizations/iter-sum.rs
deleted file mode 100644
index a054ffffe74..00000000000
--- a/tests/codegen/lib-optimizations/iter-sum.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64 (vectorization varies between architectures)
-#![crate_type = "lib"]
-
-// Ensure that slice + take + sum gets vectorized.
-// Currently this relies on the slice::Iter::try_fold implementation
-// CHECK-LABEL: @slice_take_sum
-#[no_mangle]
-pub fn slice_take_sum(s: &[u64], l: usize) -> u64 {
-    // CHECK: vector.body:
-    // CHECK: ret
-    s.iter().take(l).sum()
-}
diff --git a/tests/codegen/lib-optimizations/slice_rotate.rs b/tests/codegen/lib-optimizations/slice_rotate.rs
deleted file mode 100644
index aa4bb3b528c..00000000000
--- a/tests/codegen/lib-optimizations/slice_rotate.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// Ensure that the simple case of rotating by a constant 1 optimizes to the obvious thing
-
-// CHECK-LABEL: @rotate_left_by_one
-#[no_mangle]
-pub fn rotate_left_by_one(slice: &mut [i32]) {
-    // CHECK-NOT: phi
-    // CHECK-NOT: call
-    // CHECK-NOT: load
-    // CHECK-NOT: store
-    // CHECK-NOT: getelementptr
-    // CHECK: %[[END:.+]] = getelementptr
-    // CHECK-NEXT: %[[DIM:.+]] = getelementptr
-    // CHECK-NEXT: %[[LAST:.+]] = load
-    // CHECK-NEXT: %[[FIRST:.+]] = shl
-    // CHECK-NEXT: call void @llvm.memmove
-    // CHECK-NEXT: store i32 %[[LAST]], ptr %[[DIM:.+]]
-    // CHECK-NOT: phi
-    // CHECK-NOT: call
-    // CHECK-NOT: load
-    // CHECK-NOT: store
-    // CHECK-NOT: getelementptr
-    // CHECK: ret void
-    if !slice.is_empty() {
-        slice.rotate_left(1);
-    }
-}
diff --git a/tests/codegen/lifetime_start_end.rs b/tests/codegen/lifetime_start_end.rs
deleted file mode 100644
index 0639e7640aa..00000000000
--- a/tests/codegen/lifetime_start_end.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Zmir-opt-level=0
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @test
-#[no_mangle]
-pub fn test() {
-    let a = 0u8;
-    &a; // keep variable in an alloca
-
-    // CHECK: call void @llvm.lifetime.start{{.*}}(i{{[0-9 ]+}}, ptr %a)
-
-    {
-        let b = &Some(a);
-        &b; // keep variable in an alloca
-
-        // CHECK: call void @llvm.lifetime.start{{.*}}(i{{[0-9 ]+}}, {{.*}})
-
-        // CHECK: call void @llvm.lifetime.start{{.*}}(i{{[0-9 ]+}}, {{.*}})
-
-        // CHECK: call void @llvm.lifetime.end{{.*}}(i{{[0-9 ]+}}, {{.*}})
-
-        // CHECK: call void @llvm.lifetime.end{{.*}}(i{{[0-9 ]+}}, {{.*}})
-    }
-
-    let c = 1u8;
-    &c; // keep variable in an alloca
-
-    // CHECK: call void @llvm.lifetime.start{{.*}}(i{{[0-9 ]+}}, ptr %c)
-
-    // CHECK: call void @llvm.lifetime.end{{.*}}(i{{[0-9 ]+}}, ptr %c)
-
-    // CHECK: call void @llvm.lifetime.end{{.*}}(i{{[0-9 ]+}}, ptr %a)
-}
diff --git a/tests/codegen/link-dead-code.rs b/tests/codegen/link-dead-code.rs
deleted file mode 100644
index 93e1d84d9c7..00000000000
--- a/tests/codegen/link-dead-code.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ compile-flags:-Clink-dead-code
-
-#![crate_type = "rlib"]
-
-// This test makes sure that, when -Clink-dead-code is specified, we generate
-// code for functions that would otherwise be skipped.
-
-// CHECK-LABEL: ; link_dead_code::const_fn
-// CHECK-NEXT: ; Function Attrs:
-// CHECK-NEXT: define hidden
-const fn const_fn() -> i32 {
-    1
-}
-
-// CHECK-LABEL: ; link_dead_code::inline_fn
-// CHECK-NEXT: ; Function Attrs:
-// CHECK-NEXT: define hidden
-#[inline]
-fn inline_fn() -> i32 {
-    2
-}
-
-// CHECK-LABEL: ; link_dead_code::private_fn
-// CHECK-NEXT: ; Function Attrs:
-// CHECK-NEXT: define hidden
-fn private_fn() -> i32 {
-    3
-}
diff --git a/tests/codegen/link_section.rs b/tests/codegen/link_section.rs
deleted file mode 100644
index f62f6948079..00000000000
--- a/tests/codegen/link_section.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ ignore-wasm32 custom sections work differently on wasm
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-// CHECK: @VAR1 = {{(dso_local )?}}constant [4 x i8] c"\01\00\00\00", section ".test_one"
-#[no_mangle]
-#[link_section = ".test_one"]
-#[cfg(target_endian = "little")]
-pub static VAR1: u32 = 1;
-
-#[no_mangle]
-#[link_section = ".test_one"]
-#[cfg(target_endian = "big")]
-pub static VAR1: u32 = 0x01000000;
-
-pub enum E {
-    A(u32),
-    B(f32),
-}
-
-// CHECK: @VAR2 = {{(dso_local )?}}constant {{.*}}, section ".test_two"
-#[no_mangle]
-#[link_section = ".test_two"]
-pub static VAR2: E = E::A(666);
-
-// CHECK: @VAR3 = {{(dso_local )?}}constant {{.*}}, section ".test_three"
-#[no_mangle]
-#[link_section = ".test_three"]
-pub static VAR3: E = E::B(1.);
-
-// CHECK: define {{(dso_local )?}}void @fn1() {{.*}} section ".test_four" {
-#[no_mangle]
-#[link_section = ".test_four"]
-pub fn fn1() {}
diff --git a/tests/codegen/llvm-ident.rs b/tests/codegen/llvm-ident.rs
deleted file mode 100644
index 923e99bb282..00000000000
--- a/tests/codegen/llvm-ident.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Verifies that the `!llvm.ident` named metadata is emitted.
-//
-//@ revisions: NONE OPT DEBUG
-//
-//@ [OPT] compile-flags: -Copt-level=2
-//@ [DEBUG] compile-flags: -Cdebuginfo=2
-
-// The named metadata should contain a single metadata node (see
-// `LLVMRustPrepareThinLTOImport` for details).
-// CHECK: !llvm.ident = !{![[ID:[0-9]+]]}
-
-// In addition, check that the metadata node has the expected content.
-// CHECK: ![[ID]] = !{!"rustc version 1.{{.*}}"}
-
-fn main() {}
diff --git a/tests/codegen/llvm_module_flags.rs b/tests/codegen/llvm_module_flags.rs
deleted file mode 100644
index d3fae0c3927..00000000000
--- a/tests/codegen/llvm_module_flags.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-// Test for -Z llvm_module_flags
-//@ compile-flags: -Z llvm_module_flag=foo:u32:123:error -Z llvm_module_flag=bar:u32:42:max
-
-fn main() {}
-
-// CHECK: !{i32 1, !"foo", i32 123}
-// CHECK: !{i32 7, !"bar", i32 42}
diff --git a/tests/codegen/loads.rs b/tests/codegen/loads.rs
deleted file mode 100644
index 88d67642b72..00000000000
--- a/tests/codegen/loads.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Zmir-opt-level=0 -Copt-level=3
-
-#![crate_type = "lib"]
-
-use std::mem::MaybeUninit;
-use std::num::NonZero;
-
-pub struct Bytes {
-    a: u8,
-    b: u8,
-    c: u8,
-    d: u8,
-}
-
-#[derive(Copy, Clone)]
-pub enum MyBool {
-    True,
-    False,
-}
-
-#[repr(align(16))]
-pub struct Align16(u128);
-
-// CHECK: @ptr_alignment_helper({{.*}}align [[PTR_ALIGNMENT:[0-9]+]]
-#[no_mangle]
-pub fn ptr_alignment_helper(x: &&()) {}
-
-// CHECK-LABEL: @load_ref
-#[no_mangle]
-pub fn load_ref<'a>(x: &&'a i32) -> &'a i32 {
-    // CHECK: load ptr, ptr %x, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_4_META:[0-9]+]], !noundef !{{[0-9]+}}
-    *x
-}
-
-// CHECK-LABEL: @load_ref_higher_alignment
-#[no_mangle]
-pub fn load_ref_higher_alignment<'a>(x: &&'a Align16) -> &'a Align16 {
-    // CHECK: load ptr, ptr %x, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_16_META:[0-9]+]], !noundef !{{[0-9]+}}
-    *x
-}
-
-// CHECK-LABEL: @load_scalar_pair
-#[no_mangle]
-pub fn load_scalar_pair<'a>(x: &(&'a i32, &'a Align16)) -> (&'a i32, &'a Align16) {
-    // CHECK: load ptr, ptr %{{.+}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_4_META]], !noundef !{{[0-9]+}}
-    // CHECK: load ptr, ptr %{{.+}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_16_META]], !noundef !{{[0-9]+}}
-    *x
-}
-
-// CHECK-LABEL: @load_raw_pointer
-#[no_mangle]
-pub fn load_raw_pointer<'a>(x: &*const i32) -> *const i32 {
-    // loaded raw pointer should not have !nonnull or !align metadata
-    // CHECK: load ptr, ptr %x, align [[PTR_ALIGNMENT]], !noundef ![[NOUNDEF:[0-9]+]]{{$}}
-    *x
-}
-
-// CHECK-LABEL: @load_box
-#[no_mangle]
-pub fn load_box<'a>(x: Box<Box<i32>>) -> Box<i32> {
-    // CHECK: load ptr, ptr %{{.*}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_4_META]], !noundef !{{[0-9]+}}
-    *x
-}
-
-// CHECK-LABEL: @load_bool
-#[no_mangle]
-pub fn load_bool(x: &bool) -> bool {
-    // CHECK: load i8, ptr %x, align 1, !range ![[BOOL_RANGE:[0-9]+]], !noundef !{{[0-9]+}}
-    *x
-}
-
-// CHECK-LABEL: @load_maybeuninit_bool
-#[no_mangle]
-pub fn load_maybeuninit_bool(x: &MaybeUninit<bool>) -> MaybeUninit<bool> {
-    // CHECK: load i8, ptr %x, align 1{{$}}
-    *x
-}
-
-// CHECK-LABEL: @load_enum_bool
-#[no_mangle]
-pub fn load_enum_bool(x: &MyBool) -> MyBool {
-    // CHECK: load i8, ptr %x, align 1, !range ![[BOOL_RANGE]], !noundef !{{[0-9]+}}
-    *x
-}
-
-// CHECK-LABEL: @load_maybeuninit_enum_bool
-#[no_mangle]
-pub fn load_maybeuninit_enum_bool(x: &MaybeUninit<MyBool>) -> MaybeUninit<MyBool> {
-    // CHECK: load i8, ptr %x, align 1{{$}}
-    *x
-}
-
-// CHECK-LABEL: @load_int
-#[no_mangle]
-pub fn load_int(x: &u16) -> u16 {
-    // CHECK: load i16, ptr %x, align 2, !noundef ![[NOUNDEF]]{{$}}
-    *x
-}
-
-// CHECK-LABEL: @load_nonzero_int
-#[no_mangle]
-pub fn load_nonzero_int(x: &NonZero<u16>) -> NonZero<u16> {
-    // CHECK: load i16, ptr %x, align 2, !range ![[NONZEROU16_RANGE:[0-9]+]], !noundef !{{[0-9]+}}
-    *x
-}
-
-// CHECK-LABEL: @load_option_nonzero_int
-#[no_mangle]
-pub fn load_option_nonzero_int(x: &Option<NonZero<u16>>) -> Option<NonZero<u16>> {
-    // CHECK: load i16, ptr %x, align 2, !noundef ![[NOUNDEF]]{{$}}
-    *x
-}
-
-// CHECK-LABEL: @borrow
-#[no_mangle]
-pub fn borrow(x: &i32) -> &i32 {
-    // CHECK: load ptr, ptr %x{{.*}}, !nonnull
-    &x; // keep variable in an alloca
-    x
-}
-
-// CHECK-LABEL: @_box
-#[no_mangle]
-pub fn _box(x: Box<i32>) -> i32 {
-    // CHECK: load ptr, ptr %x{{.*}}, align [[PTR_ALIGNMENT]]
-    *x
-}
-
-// CHECK-LABEL: small_array_alignment
-// The array is loaded as i32, but its alignment is lower, go with 1 byte to avoid target
-// dependent alignment
-#[no_mangle]
-pub fn small_array_alignment(x: [i8; 4]) -> [i8; 4] {
-    // CHECK: [[VAR:%[0-9]+]] = load i32, ptr %{{.*}}, align 1
-    // CHECK: ret i32 [[VAR]]
-    x
-}
-
-// CHECK-LABEL: small_struct_alignment
-// The struct is loaded as i32, but its alignment is lower, go with 1 byte to avoid target
-// dependent alignment
-#[no_mangle]
-pub fn small_struct_alignment(x: Bytes) -> Bytes {
-    // CHECK: [[VAR:%[0-9]+]] = load i32, ptr %{{.*}}, align 1
-    // CHECK: ret i32 [[VAR]]
-    x
-}
-
-// CHECK-DAG: ![[BOOL_RANGE]] = !{i8 0, i8 2}
-// CHECK-DAG: ![[NONZEROU16_RANGE]] = !{i16 1, i16 0}
-// CHECK-DAG: ![[ALIGN_4_META]] = !{i64 4}
-// CHECK-DAG: ![[ALIGN_16_META]] = !{i64 16}
diff --git a/tests/codegen/local-generics-in-exe-internalized.rs b/tests/codegen/local-generics-in-exe-internalized.rs
deleted file mode 100644
index 8dbc41382b5..00000000000
--- a/tests/codegen/local-generics-in-exe-internalized.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Zshare-generics=yes -Zinline-mir=no
-
-// Check that local generics are internalized if they are in the same CGU
-
-// CHECK-LABEL: ; local_generics_in_exe_internalized::foo
-// CHECK-NEXT: ; Function Attrs:
-// CHECK-NEXT: define internal
-pub fn foo<T>(x: T, y: T) -> (T, T) {
-    (x, y)
-}
-
-fn main() {
-    let _ = foo(0u8, 1u8);
-}
diff --git a/tests/codegen/loongarch-abi/call-llvm-intrinsics.rs b/tests/codegen/loongarch-abi/call-llvm-intrinsics.rs
deleted file mode 100644
index 9a50f7b8e3a..00000000000
--- a/tests/codegen/loongarch-abi/call-llvm-intrinsics.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-//@ only-loongarch64
-
-#![feature(link_llvm_intrinsics)]
-#![crate_type = "lib"]
-
-struct A;
-
-impl Drop for A {
-    fn drop(&mut self) {
-        println!("A");
-    }
-}
-
-extern "C" {
-    #[link_name = "llvm.sqrt.f32"]
-    fn sqrt(x: f32) -> f32;
-}
-
-pub fn do_call() {
-    let _a = A;
-
-    unsafe {
-        // Ensure that we `call` LLVM intrinsics instead of trying to `invoke` them
-        // CHECK: store float 4.000000e+00, ptr %{{.}}, align 4
-        // CHECK: load float, ptr %{{.}}, align 4
-        // CHECK: call float @llvm.sqrt.f32(float %{{.}}
-        sqrt(4.0);
-    }
-}
diff --git a/tests/codegen/loongarch-abi/loongarch64-lp64d-abi.rs b/tests/codegen/loongarch-abi/loongarch64-lp64d-abi.rs
deleted file mode 100644
index 93c8d60930b..00000000000
--- a/tests/codegen/loongarch-abi/loongarch64-lp64d-abi.rs
+++ /dev/null
@@ -1,299 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target loongarch64-unknown-linux-gnu
-//@ needs-llvm-components: loongarch
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: define void @f_fpr_tracking(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, i8 noundef zeroext %i)
-#[no_mangle]
-pub extern "C" fn f_fpr_tracking(
-    a: f64,
-    b: f64,
-    c: f64,
-    d: f64,
-    e: f64,
-    f: f64,
-    g: f64,
-    h: f64,
-    i: u8,
-) {
-}
-
-#[repr(C)]
-pub struct Double {
-    f: f64,
-}
-
-#[repr(C)]
-pub struct DoubleDouble {
-    f: f64,
-    g: f64,
-}
-
-#[repr(C)]
-pub struct DoubleFloat {
-    f: f64,
-    g: f32,
-}
-
-// CHECK: define void @f_double_s_arg(double %0)
-#[no_mangle]
-pub extern "C" fn f_double_s_arg(a: Double) {}
-
-// CHECK: define double @f_ret_double_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_s() -> Double {
-    Double { f: 1. }
-}
-
-// CHECK: define void @f_double_double_s_arg({ double, double } %0)
-#[no_mangle]
-pub extern "C" fn f_double_double_s_arg(a: DoubleDouble) {}
-
-// CHECK: define { double, double } @f_ret_double_double_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_double_s() -> DoubleDouble {
-    DoubleDouble { f: 1., g: 2. }
-}
-
-// CHECK: define void @f_double_float_s_arg({ double, float } %0)
-#[no_mangle]
-pub extern "C" fn f_double_float_s_arg(a: DoubleFloat) {}
-
-// CHECK: define { double, float } @f_ret_double_float_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_float_s() -> DoubleFloat {
-    DoubleFloat { f: 1., g: 2. }
-}
-
-// CHECK: define void @f_double_double_s_arg_insufficient_fprs(double %0, double %1, double %2, double %3, double %4, double %5, double %6, [2 x i64] %7)
-#[no_mangle]
-pub extern "C" fn f_double_double_s_arg_insufficient_fprs(
-    a: f64,
-    b: f64,
-    c: f64,
-    d: f64,
-    e: f64,
-    f: f64,
-    g: f64,
-    h: DoubleDouble,
-) {
-}
-
-#[repr(C)]
-pub struct DoubleInt8 {
-    f: f64,
-    i: i8,
-}
-
-#[repr(C)]
-pub struct DoubleUInt8 {
-    f: f64,
-    i: u8,
-}
-
-#[repr(C)]
-pub struct DoubleInt32 {
-    f: f64,
-    i: i32,
-}
-
-#[repr(C)]
-pub struct DoubleInt64 {
-    f: f64,
-    i: i64,
-}
-
-// CHECK: define void @f_double_int8_s_arg({ double, i8 } %0)
-#[no_mangle]
-pub extern "C" fn f_double_int8_s_arg(a: DoubleInt8) {}
-
-// CHECK: define { double, i8 } @f_ret_double_int8_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_int8_s() -> DoubleInt8 {
-    DoubleInt8 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_double_int32_s_arg({ double, i32 } %0)
-#[no_mangle]
-pub extern "C" fn f_double_int32_s_arg(a: DoubleInt32) {}
-
-// CHECK: define { double, i32 } @f_ret_double_int32_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_int32_s() -> DoubleInt32 {
-    DoubleInt32 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_double_uint8_s_arg({ double, i8 } %0)
-#[no_mangle]
-pub extern "C" fn f_double_uint8_s_arg(a: DoubleUInt8) {}
-
-// CHECK: define { double, i8 } @f_ret_double_uint8_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_uint8_s() -> DoubleUInt8 {
-    DoubleUInt8 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_double_int64_s_arg({ double, i64 } %0)
-#[no_mangle]
-pub extern "C" fn f_double_int64_s_arg(a: DoubleInt64) {}
-
-// CHECK: define { double, i64 } @f_ret_double_int64_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_int64_s() -> DoubleInt64 {
-    DoubleInt64 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_double_int8_s_arg_insufficient_gprs(i32 noundef signext %a, i32 noundef signext %b, i32 noundef signext %c, i32 noundef signext %d, i32 noundef signext %e, i32 noundef signext %f, i32 noundef signext %g, i32 noundef signext %h, [2 x i64] %0)
-#[no_mangle]
-pub extern "C" fn f_double_int8_s_arg_insufficient_gprs(
-    a: i32,
-    b: i32,
-    c: i32,
-    d: i32,
-    e: i32,
-    f: i32,
-    g: i32,
-    h: i32,
-    i: DoubleInt8,
-) {
-}
-
-// CHECK: define void @f_struct_double_int8_insufficient_fprs(float %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, [2 x i64] %8)
-#[no_mangle]
-pub extern "C" fn f_struct_double_int8_insufficient_fprs(
-    a: f32,
-    b: f64,
-    c: f64,
-    d: f64,
-    e: f64,
-    f: f64,
-    g: f64,
-    h: f64,
-    i: DoubleInt8,
-) {
-}
-
-#[repr(C)]
-pub struct DoubleArr1 {
-    a: [f64; 1],
-}
-
-// CHECK: define void @f_doublearr1_s_arg(double %0)
-#[no_mangle]
-pub extern "C" fn f_doublearr1_s_arg(a: DoubleArr1) {}
-
-// CHECK: define double @f_ret_doublearr1_s()
-#[no_mangle]
-pub extern "C" fn f_ret_doublearr1_s() -> DoubleArr1 {
-    DoubleArr1 { a: [1.] }
-}
-
-#[repr(C)]
-pub struct DoubleArr2 {
-    a: [f64; 2],
-}
-
-// CHECK: define void @f_doublearr2_s_arg({ double, double } %0)
-#[no_mangle]
-pub extern "C" fn f_doublearr2_s_arg(a: DoubleArr2) {}
-
-// CHECK: define { double, double } @f_ret_doublearr2_s()
-#[no_mangle]
-pub extern "C" fn f_ret_doublearr2_s() -> DoubleArr2 {
-    DoubleArr2 { a: [1., 2.] }
-}
-
-#[repr(C)]
-pub struct Tricky1 {
-    f: [f64; 1],
-}
-
-#[repr(C)]
-pub struct DoubleArr2Tricky1 {
-    g: [Tricky1; 2],
-}
-
-// CHECK: define void @f_doublearr2_tricky1_s_arg({ double, double } %0)
-#[no_mangle]
-pub extern "C" fn f_doublearr2_tricky1_s_arg(a: DoubleArr2Tricky1) {}
-
-// CHECK: define { double, double } @f_ret_doublearr2_tricky1_s()
-#[no_mangle]
-pub extern "C" fn f_ret_doublearr2_tricky1_s() -> DoubleArr2Tricky1 {
-    DoubleArr2Tricky1 { g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
-}
-
-#[repr(C)]
-pub struct EmptyStruct {}
-
-#[repr(C)]
-pub struct DoubleArr2Tricky2 {
-    s: EmptyStruct,
-    g: [Tricky1; 2],
-}
-
-// CHECK: define void @f_doublearr2_tricky2_s_arg({ double, double } %0)
-#[no_mangle]
-pub extern "C" fn f_doublearr2_tricky2_s_arg(a: DoubleArr2Tricky2) {}
-
-// CHECK: define { double, double } @f_ret_doublearr2_tricky2_s()
-#[no_mangle]
-pub extern "C" fn f_ret_doublearr2_tricky2_s() -> DoubleArr2Tricky2 {
-    DoubleArr2Tricky2 { s: EmptyStruct {}, g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
-}
-
-#[repr(C)]
-pub struct IntDoubleInt {
-    a: i32,
-    b: f64,
-    c: i32,
-}
-
-// CHECK: define void @f_int_double_int_s_arg(ptr noalias{{( nocapture)?}} noundef align 8{{( captures\(none\))?}} dereferenceable(24) %a)
-#[no_mangle]
-pub extern "C" fn f_int_double_int_s_arg(a: IntDoubleInt) {}
-
-// CHECK: define void @f_ret_int_double_int_s(ptr{{( dead_on_unwind)?}} noalias{{( nocapture)?}} noundef{{( writable)?}} sret([24 x i8]) align 8{{( captures\(none\))?}} dereferenceable(24) %_0)
-#[no_mangle]
-pub extern "C" fn f_ret_int_double_int_s() -> IntDoubleInt {
-    IntDoubleInt { a: 1, b: 2., c: 3 }
-}
-
-#[repr(C)]
-pub struct CharCharDouble {
-    a: u8,
-    b: u8,
-    c: f64,
-}
-
-// CHECK: define void @f_char_char_double_s_arg([2 x i64] %0)
-#[no_mangle]
-pub extern "C" fn f_char_char_double_s_arg(a: CharCharDouble) {}
-
-// CHECK: define [2 x i64] @f_ret_char_char_double_s()
-#[no_mangle]
-pub extern "C" fn f_ret_char_char_double_s() -> CharCharDouble {
-    CharCharDouble { a: 1, b: 2, c: 3. }
-}
-
-#[repr(C)]
-pub union DoubleU {
-    a: f64,
-}
-
-// CHECK: define void @f_double_u_arg(i64 %0)
-#[no_mangle]
-pub extern "C" fn f_double_u_arg(a: DoubleU) {}
-
-// CHECK: define i64 @f_ret_double_u()
-#[no_mangle]
-pub extern "C" fn f_ret_double_u() -> DoubleU {
-    unsafe { DoubleU { a: 1. } }
-}
diff --git a/tests/codegen/lto-removes-invokes.rs b/tests/codegen/lto-removes-invokes.rs
deleted file mode 100644
index 3640bd1ab86..00000000000
--- a/tests/codegen/lto-removes-invokes.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ compile-flags: -C lto -C panic=abort -Copt-level=3
-//@ no-prefer-dynamic
-
-fn main() {
-    foo();
-}
-
-#[no_mangle]
-#[inline(never)]
-fn foo() {
-    let _a = Box::new(3);
-    bar();
-    // CHECK-LABEL: define dso_local void @foo
-    // CHECK: call void @bar
-}
-
-#[inline(never)]
-#[no_mangle]
-fn bar() {
-    println!("hello!");
-}
diff --git a/tests/codegen/macos/i686-macosx-deployment-target.rs b/tests/codegen/macos/i686-macosx-deployment-target.rs
deleted file mode 100644
index cfa91e61cb0..00000000000
--- a/tests/codegen/macos/i686-macosx-deployment-target.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Checks that we correctly modify the target when MACOSX_DEPLOYMENT_TARGET is set.
-// See issue #60235.
-
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 --target=i686-apple-darwin --crate-type=rlib
-//@ needs-llvm-components: x86
-//@ rustc-env:MACOSX_DEPLOYMENT_TARGET=10.14
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C)]
-pub struct Bool {
-    b: bool,
-}
-
-// CHECK: target triple = "i686-apple-macosx10.14.0"
-#[no_mangle]
-pub extern "C" fn structbool() -> Bool {
-    Bool { b: true }
-}
diff --git a/tests/codegen/macos/i686-no-macosx-deployment-target.rs b/tests/codegen/macos/i686-no-macosx-deployment-target.rs
deleted file mode 100644
index 25ec5f6acbb..00000000000
--- a/tests/codegen/macos/i686-no-macosx-deployment-target.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Checks that we leave the target alone MACOSX_DEPLOYMENT_TARGET is unset.
-// See issue #60235.
-
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 --target=i686-apple-darwin --crate-type=rlib
-//@ needs-llvm-components: x86
-//@ unset-rustc-env:MACOSX_DEPLOYMENT_TARGET
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C)]
-pub struct Bool {
-    b: bool,
-}
-
-// CHECK: target triple = "i686-apple-macosx10.12.0"
-#[no_mangle]
-pub extern "C" fn structbool() -> Bool {
-    Bool { b: true }
-}
diff --git a/tests/codegen/macos/x86_64-macosx-deployment-target.rs b/tests/codegen/macos/x86_64-macosx-deployment-target.rs
deleted file mode 100644
index 8ea95ba0575..00000000000
--- a/tests/codegen/macos/x86_64-macosx-deployment-target.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Checks that we correctly modify the target when MACOSX_DEPLOYMENT_TARGET is set.
-// See issue #60235.
-
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 --target=x86_64-apple-darwin --crate-type=rlib
-//@ needs-llvm-components: x86
-//@ rustc-env:MACOSX_DEPLOYMENT_TARGET=10.14
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C)]
-pub struct Bool {
-    b: bool,
-}
-
-// CHECK: target triple = "x86_64-apple-macosx10.14.0"
-#[no_mangle]
-pub extern "C" fn structbool() -> Bool {
-    Bool { b: true }
-}
diff --git a/tests/codegen/macos/x86_64-no-macosx-deployment-target.rs b/tests/codegen/macos/x86_64-no-macosx-deployment-target.rs
deleted file mode 100644
index 474094957ae..00000000000
--- a/tests/codegen/macos/x86_64-no-macosx-deployment-target.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Checks that we leave the target alone when MACOSX_DEPLOYMENT_TARGET is unset.
-// See issue #60235.
-
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 --target=x86_64-apple-darwin --crate-type=rlib
-//@ needs-llvm-components: x86
-//@ unset-rustc-env:MACOSX_DEPLOYMENT_TARGET
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C)]
-pub struct Bool {
-    b: bool,
-}
-
-// CHECK: target triple = "x86_64-apple-macosx10.12.0"
-#[no_mangle]
-pub extern "C" fn structbool() -> Bool {
-    Bool { b: true }
-}
diff --git a/tests/codegen/mainsubprogram.rs b/tests/codegen/mainsubprogram.rs
deleted file mode 100644
index ce3fe3c8608..00000000000
--- a/tests/codegen/mainsubprogram.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-// This test depends on a patch that was committed to upstream LLVM
-// before 4.0, formerly backported to the Rust LLVM fork.
-
-//@ ignore-apple
-//@ ignore-wasi
-
-//@ compile-flags: -g -C no-prepopulate-passes
-
-// CHECK-LABEL: @main
-// CHECK: {{.*}}DISubprogram{{.*}}name: "main",{{.*}}DI{{(SP)?}}FlagMainSubprogram{{.*}}
-
-pub fn main() {}
diff --git a/tests/codegen/match-optimized.rs b/tests/codegen/match-optimized.rs
deleted file mode 100644
index 7b409e619a8..00000000000
--- a/tests/codegen/match-optimized.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -Cno-prepopulate-passes -Copt-level=3
-
-#![crate_type = "lib"]
-
-pub enum E {
-    A,
-    B,
-    C,
-}
-
-// CHECK-LABEL: @exhaustive_match
-#[no_mangle]
-pub fn exhaustive_match(e: E) -> u8 {
-    // CHECK: switch{{.*}}, label %[[OTHERWISE:[a-zA-Z0-9_]+]] [
-    // CHECK-NEXT: i[[TY:[0-9]+]] [[DISCR:[0-9]+]], label %[[A:[a-zA-Z0-9_]+]]
-    // CHECK-NEXT: i[[TY:[0-9]+]] [[DISCR:[0-9]+]], label %[[B:[a-zA-Z0-9_]+]]
-    // CHECK-NEXT: i[[TY:[0-9]+]] [[DISCR:[0-9]+]], label %[[C:[a-zA-Z0-9_]+]]
-    // CHECK-NEXT: ]
-    // CHECK: [[OTHERWISE]]:
-    // CHECK-NEXT: unreachable
-    //
-    // CHECK: [[A]]:
-    // CHECK-NEXT: store i8 0, ptr %_0, align 1
-    // CHECK-NEXT: br label %[[EXIT:[a-zA-Z0-9_]+]]
-    // CHECK: [[B]]:
-    // CHECK-NEXT: store i8 1, ptr %_0, align 1
-    // CHECK-NEXT: br label %[[EXIT]]
-    // CHECK: [[C]]:
-    // CHECK-NEXT: store i8 3, ptr %_0, align 1
-    // CHECK-NEXT: br label %[[EXIT]]
-    match e {
-        E::A => 0,
-        E::B => 1,
-        E::C => 3,
-    }
-}
-
-#[repr(u16)]
-pub enum E2 {
-    A = 13,
-    B = 42,
-}
-
-// For optimized code we produce a switch with an unreachable target as the `otherwise` so LLVM
-// knows the possible values. Compare with `tests/codegen/match-unoptimized.rs`.
-
-// CHECK-LABEL: @exhaustive_match_2
-#[no_mangle]
-pub fn exhaustive_match_2(e: E2) -> u8 {
-    // CHECK: switch i16 %{{.+}}, label %[[UNREACH:.+]] [
-    // CHECK-NEXT: i16 13,
-    // CHECK-NEXT: i16 42,
-    // CHECK-NEXT: ]
-    // CHECK: [[UNREACH]]:
-    // CHECK-NEXT: unreachable
-    match e {
-        E2::A => 0,
-        E2::B => 1,
-    }
-}
diff --git a/tests/codegen/match-optimizes-away.rs b/tests/codegen/match-optimizes-away.rs
deleted file mode 100644
index 5e9be72a09f..00000000000
--- a/tests/codegen/match-optimizes-away.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-#![crate_type = "lib"]
-
-pub enum Three {
-    A,
-    B,
-    C,
-}
-
-#[repr(u16)]
-pub enum Four {
-    A,
-    B,
-    C,
-    D,
-}
-
-#[no_mangle]
-pub fn three_valued(x: Three) -> Three {
-    // CHECK-LABEL: i8 @three_valued(i8{{.+}}%x)
-    // CHECK-NEXT: {{^.*:$}}
-    // CHECK-NEXT: ret i8 %x
-    match x {
-        Three::A => Three::A,
-        Three::B => Three::B,
-        Three::C => Three::C,
-    }
-}
-
-#[no_mangle]
-pub fn four_valued(x: Four) -> Four {
-    // CHECK-LABEL: i16 @four_valued(i16{{.+}}%x)
-    // CHECK-NEXT: {{^.*:$}}
-    // CHECK-NEXT: ret i16 %x
-    match x {
-        Four::A => Four::A,
-        Four::B => Four::B,
-        Four::C => Four::C,
-        Four::D => Four::D,
-    }
-}
diff --git a/tests/codegen/match-unoptimized.rs b/tests/codegen/match-unoptimized.rs
deleted file mode 100644
index 3dfe78c3e16..00000000000
--- a/tests/codegen/match-unoptimized.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-
-#![crate_type = "lib"]
-
-#[repr(u16)]
-pub enum E2 {
-    A = 13,
-    B = 42,
-}
-
-// For unoptimized code we produce a `br` instead of a `switch`. Compare with
-// `tests/codegen/match-optimized.rs`
-
-// CHECK-LABEL: @exhaustive_match_2
-#[no_mangle]
-pub fn exhaustive_match_2(e: E2) -> u8 {
-    // CHECK: %[[CMP:.+]] = icmp eq i16 %{{.+}}, 13
-    // CHECK-NEXT: br i1 %[[CMP:.+]],
-    match e {
-        E2::A => 0,
-        E2::B => 1,
-    }
-}
diff --git a/tests/codegen/maybeuninit-rvo.rs b/tests/codegen/maybeuninit-rvo.rs
deleted file mode 100644
index 097aa610f1b..00000000000
--- a/tests/codegen/maybeuninit-rvo.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ needs-unwind
-#![feature(c_unwind)]
-#![crate_type = "lib"]
-
-pub struct Foo([u8; 1000]);
-
-extern "C" {
-    fn init(p: *mut Foo);
-}
-
-pub fn new_from_uninit() -> Foo {
-    // CHECK-LABEL: new_from_uninit
-    // CHECK-NOT: call void @llvm.memcpy.
-    let mut x = std::mem::MaybeUninit::uninit();
-    unsafe {
-        init(x.as_mut_ptr());
-        x.assume_init()
-    }
-}
-
-extern "C-unwind" {
-    fn init_unwind(p: *mut Foo);
-}
-
-pub fn new_from_uninit_unwind() -> Foo {
-    // CHECK-LABEL: new_from_uninit_unwind
-    // CHECK-NOT: call void @llvm.memcpy.
-    let mut x = std::mem::MaybeUninit::uninit();
-    unsafe {
-        init_unwind(x.as_mut_ptr());
-        x.assume_init()
-    }
-}
diff --git a/tests/codegen/mem-replace-big-type.rs b/tests/codegen/mem-replace-big-type.rs
deleted file mode 100644
index 0b2229ba7d1..00000000000
--- a/tests/codegen/mem-replace-big-type.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// This test ensures that `mem::replace::<T>` only ever calls `@llvm.memcpy`
-// with `size_of::<T>()` as the size, and never goes through any wrapper that
-// may e.g. multiply `size_of::<T>()` with a variable "count" (which is only
-// known to be `1` after inlining).
-
-//@ compile-flags: -C no-prepopulate-passes -Zinline-mir=no
-//@ ignore-std-debug-assertions
-// Reason: precondition checks in ptr::read make them a bad candidate for MIR inlining
-//@ needs-deterministic-layouts
-
-#![crate_type = "lib"]
-
-#[repr(C, align(8))]
-pub struct Big([u64; 7]);
-pub fn replace_big(dst: &mut Big, src: Big) -> Big {
-    // Back in 1.68, this emitted six `memcpy`s.
-    // `read_via_copy` in 1.69 got that down to three.
-    // `write_via_move` and nvro get this down to the essential two.
-    std::mem::replace(dst, src)
-}
-
-// NOTE(eddyb) the `CHECK-NOT`s ensure that the only calls of `@llvm.memcpy` in
-// the entire output, are the direct calls we want, from `ptr::replace`.
-
-// CHECK-NOT: call void @llvm.memcpy
-
-// For a large type, we expect exactly three `memcpy`s
-// CHECK-LABEL: define internal void @{{.+}}mem{{.+}}replace{{.+}}(ptr
-// CHECK-SAME: sret([56 x i8]){{.+}}[[RESULT:%.+]], ptr{{.+}}%dest, ptr{{.+}}%src)
-// CHECK-NOT: call void @llvm.memcpy
-// CHECK: call void @llvm.memcpy.{{.+}}(ptr align 8 [[RESULT]], ptr align 8 %dest, i{{.*}} 56, i1 false)
-// CHECK-NOT: call void @llvm.memcpy
-// CHECK: call void @llvm.memcpy.{{.+}}(ptr align 8 %dest, ptr align 8 %src, i{{.*}} 56, i1 false)
-// CHECK-NOT: call void @llvm.memcpy
-
-// CHECK-NOT: call void @llvm.memcpy
diff --git a/tests/codegen/mem-replace-simple-type.rs b/tests/codegen/mem-replace-simple-type.rs
deleted file mode 100644
index 9f3c6bacb71..00000000000
--- a/tests/codegen/mem-replace-simple-type.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-//@ only-x86_64 (to not worry about usize differing)
-//@ ignore-std-debug-assertions
-// Reason: precondition checks make mem::replace not a candidate for MIR inlining
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-// CHECK-LABEL: @replace_usize(
-pub fn replace_usize(r: &mut usize, v: usize) -> usize {
-    // CHECK-NOT: alloca
-    // CHECK: %[[R:.+]] = load i64, ptr %r
-    // CHECK: store i64 %v, ptr %r
-    // CHECK: ret i64 %[[R]]
-    std::mem::replace(r, v)
-}
-
-#[no_mangle]
-// CHECK-LABEL: @replace_ref_str(
-pub fn replace_ref_str<'a>(r: &mut &'a str, v: &'a str) -> &'a str {
-    // CHECK-NOT: alloca
-    // CHECK: %[[A:.+]] = load ptr
-    // CHECK: %[[B:.+]] = load i64
-    // CHECK-NOT: store
-    // CHECK-NOT: load
-    // CHECK: store ptr
-    // CHECK: store i64
-    // CHECK-NOT: load
-    // CHECK-NOT: store
-    // CHECK: %[[P1:.+]] = insertvalue { ptr, i64 } poison, ptr %[[A]], 0
-    // CHECK: %[[P2:.+]] = insertvalue { ptr, i64 } %[[P1]], i64 %[[B]], 1
-    // CHECK: ret { ptr, i64 } %[[P2]]
-    std::mem::replace(r, v)
-}
-
-#[no_mangle]
-// CHECK-LABEL: @replace_short_array_3(
-// CHECK-SAME: ptr{{.+}}sret{{.+}}%[[RET:.+]], ptr{{.+}}%r, ptr{{.+}}%v
-pub fn replace_short_array_3(r: &mut [u32; 3], v: [u32; 3]) -> [u32; 3] {
-    // CHECK-NOT: alloca
-    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %[[RET]], ptr align 4 %r, i64 12, i1 false)
-    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %r, ptr align 4 %v, i64 12, i1 false)
-    std::mem::replace(r, v)
-}
-
-#[no_mangle]
-// CHECK-LABEL: @replace_short_array_4(
-// CHECK-SAME: ptr{{.+}}sret{{.+}}%[[RET:.+]], ptr{{.+}}%r, ptr{{.+}}%v
-pub fn replace_short_array_4(r: &mut [u32; 4], v: [u32; 4]) -> [u32; 4] {
-    // CHECK-NOT: alloca
-    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %[[RET]], ptr align 4 %r, i64 16, i1 false)
-    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %r, ptr align 4 %v, i64 16, i1 false)
-    std::mem::replace(r, v)
-}
diff --git a/tests/codegen/merge-functions.rs b/tests/codegen/merge-functions.rs
deleted file mode 100644
index b9d3727ce11..00000000000
--- a/tests/codegen/merge-functions.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ revisions: O Os
-//@[Os] compile-flags: -Copt-level=s
-//@[O] compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// CHECK: @func{{2|1}} = {{.*}}alias{{.*}}@func{{1|2}}
-
-#[no_mangle]
-pub fn func1(c: char) -> bool {
-    c == 's' || c == 'm' || c == 'h' || c == 'd' || c == 'w'
-}
-
-#[no_mangle]
-pub fn func2(c: char) -> bool {
-    matches!(c, 's' | 'm' | 'h' | 'd' | 'w')
-}
diff --git a/tests/codegen/meta-filecheck/check-prefix.rs b/tests/codegen/meta-filecheck/check-prefix.rs
deleted file mode 100644
index 98bec68627e..00000000000
--- a/tests/codegen/meta-filecheck/check-prefix.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-// Simple test that uses the default CHECK prefix and should always succeed.
-
-// CHECK: main
-fn main() {}
diff --git a/tests/codegen/meta-filecheck/filecheck-flags.rs b/tests/codegen/meta-filecheck/filecheck-flags.rs
deleted file mode 100644
index 8e451cf4fdc..00000000000
--- a/tests/codegen/meta-filecheck/filecheck-flags.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// Arguments provided via `filecheck-flags` should be passed to `filecheck`.
-
-//@ revisions: good bad
-//@ [good] filecheck-flags: --check-prefix=CUSTOM
-//@ [bad] should-fail
-
-// CUSTOM: main
-fn main() {}
diff --git a/tests/codegen/meta-filecheck/msvc-prefix-bad.rs b/tests/codegen/meta-filecheck/msvc-prefix-bad.rs
deleted file mode 100644
index f9984c74e2a..00000000000
--- a/tests/codegen/meta-filecheck/msvc-prefix-bad.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-// This is exactly like `msvc-prefix-good.rs`, except that it should always fail.
-
-//@ should-fail
-
-// MSVC: text that should not match
-// NONMSVC: text that should not match
-fn main() {}
diff --git a/tests/codegen/meta-filecheck/no-directives.rs b/tests/codegen/meta-filecheck/no-directives.rs
deleted file mode 100644
index 2cab263604e..00000000000
--- a/tests/codegen/meta-filecheck/no-directives.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-// A test that doesn't include any filecheck directives should fail.
-
-//@ should-fail
-
-fn main() {}
diff --git a/tests/codegen/meta-filecheck/revision-prefix.rs b/tests/codegen/meta-filecheck/revision-prefix.rs
deleted file mode 100644
index 431066e3acc..00000000000
--- a/tests/codegen/meta-filecheck/revision-prefix.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// The current revision name is registered as a filecheck prefix.
-
-//@ revisions: GOOD BAD
-//@ [BAD] should-fail
-
-// GOOD: main
-// BAD: text that should not match
-fn main() {}
diff --git a/tests/codegen/method-declaration.rs b/tests/codegen/method-declaration.rs
deleted file mode 100644
index de2f96a5151..00000000000
--- a/tests/codegen/method-declaration.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//@ compile-flags: -g -Cno-prepopulate-passes
-
-// Verify that we added a declaration for a method.
-
-// CHECK: define{{.*}}@method{{.*}} !dbg ![[METHOD_DEF_DBG:[0-9]+]]
-// CHECK: define{{.*}}@function{{.*}} !dbg ![[FUNC_DEF_DBG:[0-9]+]]
-
-#![crate_type = "lib"]
-
-// CHECK-DAG: ![[FOO_DBG:[0-9]+]] = !DICompositeType(tag: {{.*}} name: "Foo", {{.*}} identifier:
-pub struct Foo;
-
-impl Foo {
-    // CHECK-DAG: ![[METHOD_DEF_DBG]] = distinct !DISubprogram(name: "method"{{.*}}, scope: ![[FOO_DBG]]{{.*}}DISPFlagDefinition{{.*}}, declaration: ![[METHOD_DECL_DBG:[0-9]+]]
-    // CHECK-DAG: ![[METHOD_DECL_DBG]] = !DISubprogram(name: "method"{{.*}}, scope: ![[FOO_DBG]]
-    #[no_mangle]
-    pub fn method() {}
-}
-
-// CHECK: ![[FUNC_DEF_DBG]] = distinct !DISubprogram(name: "function"
-// CHECK-NOT: declaration
-// CHECK-SAME: DISPFlagDefinition
-// CHECK-NOT: declaration
-// CHECK-SAME: )
-#[no_mangle]
-pub fn function() {}
diff --git a/tests/codegen/min-function-alignment.rs b/tests/codegen/min-function-alignment.rs
deleted file mode 100644
index ea5f957e81f..00000000000
--- a/tests/codegen/min-function-alignment.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-//@ revisions: align16 align1024
-//@ compile-flags: -C no-prepopulate-passes -Z mir-opt-level=0 -Clink-dead-code
-//@ [align16] compile-flags: -Zmin-function-alignment=16
-//@ [align1024] compile-flags: -Zmin-function-alignment=1024
-//@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
-
-#![crate_type = "lib"]
-// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
-#![feature(rustc_attrs)]
-#![feature(fn_align)]
-
-// Functions without explicit alignment use the global minimum.
-//
-// NOTE: this function deliberately has zero (0) attributes! That is to make sure that
-// `-Zmin-function-alignment` is applied regardless of whether attributes are used.
-//
-// CHECK-LABEL: no_explicit_align
-// align16: align 16
-// align1024: align 1024
-pub fn no_explicit_align() {}
-
-// CHECK-LABEL: @lower_align
-// align16: align 16
-// align1024: align 1024
-#[no_mangle]
-#[rustc_align(8)]
-pub fn lower_align() {}
-
-// the higher value of min-function-alignment and the align attribute wins out
-//
-// CHECK-LABEL: @higher_align
-// align16: align 32
-// align1024: align 1024
-#[no_mangle]
-#[rustc_align(32)]
-pub fn higher_align() {}
-
-// cold functions follow the same rules as other functions
-//
-// in GCC, the `-falign-functions` does not apply to cold functions, but
-// `-Zmin-function-alignment` applies to all functions.
-//
-// CHECK-LABEL: @no_explicit_align_cold
-// align16: align 16
-// align1024: align 1024
-#[no_mangle]
-#[cold]
-pub fn no_explicit_align_cold() {}
diff --git a/tests/codegen/mir-aggregate-no-alloca.rs b/tests/codegen/mir-aggregate-no-alloca.rs
deleted file mode 100644
index 77d367ed5da..00000000000
--- a/tests/codegen/mir-aggregate-no-alloca.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-// 32-bit systems will return 128bit values using a return area pointer.
-//@ revisions: bit32 bit64
-//@[bit32] only-32bit
-//@[bit64] only-64bit
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Z randomize-layout=no
-
-#![crate_type = "lib"]
-
-#[repr(transparent)]
-pub struct Transparent32(u32);
-
-// CHECK: i32 @make_transparent(i32{{.*}} %x)
-#[no_mangle]
-pub fn make_transparent(x: u32) -> Transparent32 {
-    // CHECK-NOT: alloca
-    // CHECK: ret i32 %x
-    let a = Transparent32(x);
-    a
-}
-
-// CHECK: i32 @make_closure(i32{{.*}} %x)
-#[no_mangle]
-pub fn make_closure(x: i32) -> impl Fn(i32) -> i32 {
-    // CHECK-NOT: alloca
-    // CHECK: ret i32 %x
-    move |y| x + y
-}
-
-#[repr(transparent)]
-pub struct TransparentPair((), (u16, u16), ());
-
-// CHECK: { i16, i16 } @make_transparent_pair(i16 noundef %x.0, i16 noundef %x.1)
-#[no_mangle]
-pub fn make_transparent_pair(x: (u16, u16)) -> TransparentPair {
-    // CHECK-NOT: alloca
-    // CHECK: %[[TEMP0:.+]] = insertvalue { i16, i16 } poison, i16 %x.0, 0
-    // CHECK: %[[TEMP1:.+]] = insertvalue { i16, i16 } %[[TEMP0]], i16 %x.1, 1
-    // CHECK: ret { i16, i16 } %[[TEMP1]]
-    let a = TransparentPair((), x, ());
-    a
-}
-
-// CHECK-LABEL: { i32, i32 } @make_2_tuple(i32{{.*}} %x)
-#[no_mangle]
-pub fn make_2_tuple(x: u32) -> (u32, u32) {
-    // CHECK-NOT: alloca
-    // CHECK: %[[TEMP0:.+]] = insertvalue { i32, i32 } poison, i32 %x, 0
-    // CHECK: %[[TEMP1:.+]] = insertvalue { i32, i32 } %[[TEMP0]], i32 %x, 1
-    // CHECK: ret { i32, i32 } %[[TEMP1]]
-    let pair = (x, x);
-    pair
-}
-
-// CHECK-LABEL: i8 @make_cell_of_bool(i1 noundef zeroext %b)
-#[no_mangle]
-pub fn make_cell_of_bool(b: bool) -> std::cell::Cell<bool> {
-    // CHECK: %[[BYTE:.+]] = zext i1 %b to i8
-    // CHECK: ret i8 %[[BYTE]]
-    std::cell::Cell::new(b)
-}
-
-// CHECK-LABEL: { i8, i16 } @make_cell_of_bool_and_short(i1 noundef zeroext %b, i16{{.*}} %s)
-#[no_mangle]
-pub fn make_cell_of_bool_and_short(b: bool, s: u16) -> std::cell::Cell<(bool, u16)> {
-    // CHECK-NOT: alloca
-    // CHECK: %[[BYTE:.+]] = zext i1 %b to i8
-    // CHECK: %[[TEMP0:.+]] = insertvalue { i8, i16 } poison, i8 %[[BYTE]], 0
-    // CHECK: %[[TEMP1:.+]] = insertvalue { i8, i16 } %[[TEMP0]], i16 %s, 1
-    // CHECK: ret { i8, i16 } %[[TEMP1]]
-    std::cell::Cell::new((b, s))
-}
-
-// CHECK-LABEL: { i1, i1 } @make_tuple_of_bools(i1 noundef zeroext %a, i1 noundef zeroext %b)
-#[no_mangle]
-pub fn make_tuple_of_bools(a: bool, b: bool) -> (bool, bool) {
-    // CHECK-NOT: alloca
-    // CHECK: %[[TEMP0:.+]] = insertvalue { i1, i1 } poison, i1 %a, 0
-    // CHECK: %[[TEMP1:.+]] = insertvalue { i1, i1 } %[[TEMP0]], i1 %b, 1
-    // CHECK: ret { i1, i1 } %[[TEMP1]]
-    (a, b)
-}
-
-pub struct Struct0();
-
-// CHECK-LABEL: void @make_struct_0()
-#[no_mangle]
-pub fn make_struct_0() -> Struct0 {
-    // CHECK: ret void
-    let s = Struct0();
-    s
-}
-
-pub struct Struct1(i32);
-
-// CHECK-LABEL: i32 @make_struct_1(i32{{.*}} %a)
-#[no_mangle]
-pub fn make_struct_1(a: i32) -> Struct1 {
-    // CHECK: ret i32 %a
-    let s = Struct1(a);
-    s
-}
-
-pub struct Struct2Asc(i16, i64);
-
-// bit32-LABEL: void @make_struct_2_asc({{.*}} sret({{[^,]*}}) {{.*}} %s,
-// bit64-LABEL: { i64, i16 } @make_struct_2_asc(
-// CHECK-SAME: i16{{.*}} %a, i64 noundef %b)
-#[no_mangle]
-pub fn make_struct_2_asc(a: i16, b: i64) -> Struct2Asc {
-    // CHECK-NOT: alloca
-    // bit32: %[[GEP:.+]] = getelementptr inbounds i8, ptr %s, i32 8
-    // bit32: store i16 %a, ptr %[[GEP]]
-    // bit32: store i64 %b, ptr %s
-    // bit64: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %b, 0
-    // bit64: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %a, 1
-    // bit64: ret { i64, i16 } %[[TEMP1]]
-    let s = Struct2Asc(a, b);
-    s
-}
-
-pub struct Struct2Desc(i64, i16);
-
-// bit32-LABEL: void @make_struct_2_desc({{.*}} sret({{[^,]*}}) {{.*}} %s,
-// bit64-LABEL: { i64, i16 } @make_struct_2_desc(
-// CHECK-SAME: i64 noundef %a, i16{{.*}} %b)
-#[no_mangle]
-pub fn make_struct_2_desc(a: i64, b: i16) -> Struct2Desc {
-    // CHECK-NOT: alloca
-    // bit32: store i64 %a, ptr %s
-    // bit32: %[[GEP:.+]] = getelementptr inbounds i8, ptr %s, i32 8
-    // bit32: store i16 %b, ptr %[[GEP]]
-    // bit64: %[[TEMP0:.+]] = insertvalue { i64, i16 } poison, i64 %a, 0
-    // bit64: %[[TEMP1:.+]] = insertvalue { i64, i16 } %[[TEMP0]], i16 %b, 1
-    // bit64: ret { i64, i16 } %[[TEMP1]]
-    let s = Struct2Desc(a, b);
-    s
-}
diff --git a/tests/codegen/mir-inlined-line-numbers.rs b/tests/codegen/mir-inlined-line-numbers.rs
deleted file mode 100644
index cfe43a6cf89..00000000000
--- a/tests/codegen/mir-inlined-line-numbers.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ compile-flags: -Copt-level=3 -g
-
-#![crate_type = "lib"]
-
-#[inline(always)]
-fn foo() {
-    bar();
-}
-
-#[inline(never)]
-#[no_mangle]
-fn bar() {
-    panic!();
-}
-
-#[no_mangle]
-pub fn example() {
-    foo();
-}
-
-// CHECK-LABEL: @example
-// CHECK:   tail call void @bar(){{( #[0-9]+)?}}, !dbg [[DBG_ID:![0-9]+]]
-// CHECK: [[DBG_ID]] = !DILocation(line: 7,
-// CHECK-SAME:                     inlinedAt: [[INLINE_ID:![0-9]+]])
-// CHECK: [[INLINE_ID]] = !DILocation(line: 18,
diff --git a/tests/codegen/mir_zst_stores.rs b/tests/codegen/mir_zst_stores.rs
deleted file mode 100644
index ff1d429cffd..00000000000
--- a/tests/codegen/mir_zst_stores.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-use std::marker::PhantomData;
-
-#[derive(Copy, Clone)]
-struct Zst {
-    phantom: PhantomData<Zst>,
-}
-
-// CHECK-LABEL: @mir
-// CHECK-NOT: store{{.*}}undef
-#[no_mangle]
-pub fn mir() {
-    let x = Zst { phantom: PhantomData };
-    let y = (x, 0);
-    drop(y);
-    drop((0, x));
-}
diff --git a/tests/codegen/move-before-nocapture-ref-arg.rs b/tests/codegen/move-before-nocapture-ref-arg.rs
deleted file mode 100644
index 2ebd645e1c3..00000000000
--- a/tests/codegen/move-before-nocapture-ref-arg.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Verify that move before the call of the function with noalias, nocapture, readonly.
-// #107436
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[repr(C)]
-pub struct ThreeSlices<'a>(&'a [u32], &'a [u32], &'a [u32]);
-
-#[no_mangle]
-pub fn sum_slices(val: ThreeSlices) -> u32 {
-    // CHECK-NOT: memcpy
-    let val = val;
-    sum(&val)
-}
-
-#[no_mangle]
-#[inline(never)]
-pub fn sum(val: &ThreeSlices) -> u32 {
-    val.0.iter().sum::<u32>() + val.1.iter().sum::<u32>() + val.2.iter().sum::<u32>()
-}
diff --git a/tests/codegen/move-operands.rs b/tests/codegen/move-operands.rs
deleted file mode 100644
index ddad231b762..00000000000
--- a/tests/codegen/move-operands.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Verify that optimized MIR only copies `a` once.
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-type T = [u8; 256];
-
-#[no_mangle]
-pub fn f(a: T, b: fn(_: T, _: T)) {
-    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 %{{.*}}, ptr align 1 %{{.*}}, {{.*}} 256, i1 false)
-    // CHECK-NOT: call void @llvm.memcpy.{{.*}}(ptr align 1 %{{.*}}, ptr align 1 %{{.*}}, {{.*}} 256, i1 false)
-    b(a, a)
-}
diff --git a/tests/codegen/naked-asan.rs b/tests/codegen/naked-asan.rs
deleted file mode 100644
index 46218cf79d6..00000000000
--- a/tests/codegen/naked-asan.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//@ add-core-stubs
-//@ needs-llvm-components: x86
-//@ compile-flags: --target x86_64-unknown-linux-gnu -Zsanitizer=address -Ctarget-feature=-crt-static
-
-// Make sure we do not request sanitizers for naked functions.
-
-#![crate_type = "lib"]
-#![feature(no_core)]
-#![no_std]
-#![no_core]
-#![feature(abi_x86_interrupt)]
-
-extern crate minicore;
-use minicore::*;
-
-#[no_mangle]
-pub fn caller() {
-    unsafe { asm!("call {}", sym page_fault_handler) }
-}
-
-// CHECK: declare x86_intrcc void @page_fault_handler(){{.*}}#[[ATTRS:[0-9]+]]
-#[unsafe(naked)]
-#[no_mangle]
-pub extern "x86-interrupt" fn page_fault_handler() {
-    naked_asm!("ud2")
-}
-
-// CHECK: #[[ATTRS]] =
-// CHECK-NOT: sanitize_address
-// CHECK: !llvm.module.flags
diff --git a/tests/codegen/naked-fn/aligned.rs b/tests/codegen/naked-fn/aligned.rs
deleted file mode 100644
index d7281c4219a..00000000000
--- a/tests/codegen/naked-fn/aligned.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-//@ needs-asm-support
-//@ ignore-arm no "ret" mnemonic
-//@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
-
-#![crate_type = "lib"]
-// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
-#![feature(rustc_attrs)]
-#![feature(fn_align)]
-
-use std::arch::naked_asm;
-
-// CHECK: .balign 16
-// CHECK-LABEL: naked_empty:
-#[rustc_align(16)]
-#[no_mangle]
-#[unsafe(naked)]
-pub extern "C" fn naked_empty() {
-    // CHECK: ret
-    naked_asm!("ret")
-}
diff --git a/tests/codegen/naked-fn/generics.rs b/tests/codegen/naked-fn/generics.rs
deleted file mode 100644
index 865be00d91e..00000000000
--- a/tests/codegen/naked-fn/generics.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-use std::arch::naked_asm;
-
-#[no_mangle]
-fn test(x: u64) {
-    // just making sure these symbols get used
-    using_const_generics::<1>(x);
-    using_const_generics::<2>(x);
-
-    generic_function::<i64>(x as i64);
-
-    let foo = Foo(x);
-
-    foo.method();
-    foo.trait_method();
-}
-
-// CHECK: .balign 4
-// CHECK: add rax, 2
-// CHECK: add rax, 42
-
-// CHECK: .balign 4
-// CHECK: add rax, 1
-// CHECK: add rax, 42
-
-#[unsafe(naked)]
-pub extern "C" fn using_const_generics<const N: u64>(x: u64) -> u64 {
-    const M: u64 = 42;
-
-    naked_asm!(
-        "xor rax, rax",
-        "add rax, rdi",
-        "add rax, {}",
-        "add rax, {}",
-        "ret",
-        const N,
-        const M,
-    )
-}
-
-trait Invert {
-    fn invert(self) -> Self;
-}
-
-impl Invert for i64 {
-    fn invert(self) -> Self {
-        -1 * self
-    }
-}
-
-// CHECK: .balign 4
-// CHECK-LABEL: generic_function:
-// CHECK: call
-// CHECK: ret
-
-#[unsafe(naked)]
-#[no_mangle]
-pub extern "C" fn generic_function<T: Invert>(x: i64) -> i64 {
-    naked_asm!(
-        "call {}",
-        "ret",
-        sym <T as Invert>::invert,
-    )
-}
-
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-struct Foo(u64);
-
-// CHECK: .balign 4
-// CHECK-LABEL: method:
-// CHECK: mov rax, rdi
-
-impl Foo {
-    #[unsafe(naked)]
-    #[no_mangle]
-    extern "C" fn method(self) -> u64 {
-        naked_asm!("mov rax, rdi", "ret")
-    }
-}
-
-// CHECK: .balign 4
-// CHECK-LABEL: trait_method:
-// CHECK: mov rax, rdi
-
-trait Bar {
-    extern "C" fn trait_method(self) -> u64;
-}
-
-impl Bar for Foo {
-    #[unsafe(naked)]
-    #[no_mangle]
-    extern "C" fn trait_method(self) -> u64 {
-        naked_asm!("mov rax, rdi", "ret")
-    }
-}
-
-// CHECK: .balign 4
-// CHECK-LABEL: naked_with_args_and_return:
-// CHECK: lea rax, [rdi + rsi]
-
-// this previously ICE'd, see https://github.com/rust-lang/rust/issues/124375
-#[unsafe(naked)]
-#[no_mangle]
-pub unsafe extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize {
-    naked_asm!("lea rax, [rdi + rsi]", "ret");
-}
diff --git a/tests/codegen/naked-fn/instruction-set.rs b/tests/codegen/naked-fn/instruction-set.rs
deleted file mode 100644
index 67560c5aba7..00000000000
--- a/tests/codegen/naked-fn/instruction-set.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-//@ add-core-stubs
-//@ revisions: arm-mode thumb-mode
-//@ [arm-mode] compile-flags: --target armv5te-none-eabi
-//@ [thumb-mode] compile-flags: --target thumbv5te-none-eabi
-//@ [arm-mode] needs-llvm-components: arm
-//@ [thumb-mode] needs-llvm-components: arm
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items, rustc_attrs)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// arm-mode: .arm
-// thumb-mode: .thumb
-// CHECK-LABEL: test_unspecified:
-// CHECK: bx lr
-// CHECK: .popsection
-// arm-mode: .arm
-// thumb-mode: .thumb
-#[no_mangle]
-#[unsafe(naked)]
-extern "C" fn test_unspecified() {
-    naked_asm!("bx lr");
-}
-
-// CHECK: .thumb
-// CHECK: .thumb_func
-// CHECK-LABEL: test_thumb:
-// CHECK: bx lr
-// CHECK: .popsection
-// arm-mode: .arm
-// thumb-mode: .thumb
-#[no_mangle]
-#[unsafe(naked)]
-#[instruction_set(arm::t32)]
-extern "C" fn test_thumb() {
-    naked_asm!("bx lr");
-}
-
-// CHECK: .arm
-// CHECK-LABEL: test_arm:
-// CHECK: bx lr
-// CHECK: .popsection
-// arm-mode: .arm
-// thumb-mode: .thumb
-#[no_mangle]
-#[unsafe(naked)]
-#[instruction_set(arm::a32)]
-extern "C" fn test_arm() {
-    naked_asm!("bx lr");
-}
diff --git a/tests/codegen/naked-fn/min-function-alignment.rs b/tests/codegen/naked-fn/min-function-alignment.rs
deleted file mode 100644
index 406e9334fa5..00000000000
--- a/tests/codegen/naked-fn/min-function-alignment.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0 -Zmin-function-alignment=16
-//@ needs-asm-support
-//@ ignore-arm no "ret" mnemonic
-//@ ignore-wasm32 aligning functions is not currently supported on wasm (#143368)
-
-// FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
-#![feature(rustc_attrs)]
-#![feature(fn_align)]
-#![crate_type = "lib"]
-
-// functions without explicit alignment use the global minimum
-//
-// CHECK: .balign 16
-#[no_mangle]
-#[unsafe(naked)]
-pub extern "C" fn naked_no_explicit_align() {
-    core::arch::naked_asm!("ret")
-}
-
-// CHECK: .balign 16
-#[no_mangle]
-#[rustc_align(8)]
-#[unsafe(naked)]
-pub extern "C" fn naked_lower_align() {
-    core::arch::naked_asm!("ret")
-}
-
-// CHECK: .balign 32
-#[no_mangle]
-#[rustc_align(32)]
-#[unsafe(naked)]
-pub extern "C" fn naked_higher_align() {
-    core::arch::naked_asm!("ret")
-}
-
-// cold functions follow the same rules as other functions
-//
-// in GCC, the `-falign-functions` does not apply to cold functions, but
-// `-Zmin-function-alignment` applies to all functions.
-//
-// CHECK: .balign 16
-#[no_mangle]
-#[cold]
-#[unsafe(naked)]
-pub extern "C" fn no_explicit_align_cold() {
-    core::arch::naked_asm!("ret")
-}
diff --git a/tests/codegen/naked-fn/naked-functions.rs b/tests/codegen/naked-fn/naked-functions.rs
deleted file mode 100644
index 344af6eb42f..00000000000
--- a/tests/codegen/naked-fn/naked-functions.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-//@ add-core-stubs
-//@ revisions: linux win_x86 win_i686 macos thumb
-//
-//@[linux] compile-flags: --target x86_64-unknown-linux-gnu
-//@[linux] needs-llvm-components: x86
-//@[win_x86] compile-flags: --target x86_64-pc-windows-gnu
-//@[win_x86] needs-llvm-components: x86
-//@[win_i686] compile-flags: --target i686-pc-windows-gnu
-//@[win_i686] needs-llvm-components: x86
-//@[macos] compile-flags: --target aarch64-apple-darwin
-//@[macos] needs-llvm-components: arm
-//@[thumb] compile-flags: --target thumbv7em-none-eabi
-//@[thumb] needs-llvm-components: arm
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items, rustc_attrs)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// linux,win: .intel_syntax
-//
-// linux:    .pushsection .text.naked_empty,\22ax\22, @progbits
-// macos:    .pushsection __TEXT,__text,regular,pure_instructions
-// win_x86:  .pushsection .text.naked_empty,\22xr\22
-// win_i686: .pushsection .text._naked_empty,\22xr\22
-// thumb:    .pushsection .text.naked_empty,\22ax\22, %progbits
-//
-// CHECK: .balign 4
-//
-// linux,win,thumb: .globl naked_empty
-// macos: .globl _naked_empty
-//
-// CHECK-NOT: .private_extern
-// CHECK-NOT: .hidden
-//
-// linux: .type naked_empty, @function
-//
-// win_x86:  .def naked_empty
-// win_i686: .def _naked_empty
-//
-// win_x86,win_i686: .scl 2
-// win_x86,win_i686: .type 32
-// win_x86,win_i686: .endef
-//
-// thumb: .type naked_empty, %function
-// thumb: .thumb
-// thumb: .thumb_func
-//
-// CHECK-LABEL: naked_empty:
-//
-// linux,macos,win: ret
-// thumb: bx lr
-//
-// CHECK: .popsection
-//
-// thumb: .thumb
-//
-// linux,win: .att_syntax
-
-#[no_mangle]
-#[unsafe(naked)]
-pub extern "C" fn naked_empty() {
-    #[cfg(not(all(target_arch = "arm", target_feature = "thumb-mode")))]
-    naked_asm!("ret");
-
-    #[cfg(all(target_arch = "arm", target_feature = "thumb-mode"))]
-    naked_asm!("bx lr");
-}
-
-// linux,win: .intel_syntax
-//
-// linux:    .pushsection .text.naked_with_args_and_return,\22ax\22, @progbits
-// macos:    .pushsection __TEXT,__text,regular,pure_instructions
-// win_x86:  .pushsection .text.naked_with_args_and_return,\22xr\22
-// win_i686: .pushsection .text._naked_with_args_and_return,\22xr\22
-// thumb:    .pushsection .text.naked_with_args_and_return,\22ax\22, %progbits
-//
-// CHECK: .balign 4
-//
-// linux,win,thumb: .globl naked_with_args_and_return
-// macos: .globl _naked_with_args_and_return
-//
-// CHECK-NOT: .private_extern
-// CHECK-NOT: .hidden
-//
-// linux: .type naked_with_args_and_return, @function
-//
-// win_x86:  .def naked_with_args_and_return
-// win_i686: .def _naked_with_args_and_return
-//
-// win_x86,win_i686: .scl 2
-// win_x86,win_i686: .type 32
-// win_x86,win_i686: .endef
-//
-// thumb: .type naked_with_args_and_return, %function
-// thumb: .thumb
-// thumb: .thumb_func
-//
-// CHECK-LABEL: naked_with_args_and_return:
-//
-// linux, win_x86,win_i686: lea rax, [rdi + rsi]
-// macos: add x0, x0, x1
-// thumb: adds r0, r0, r1
-//
-// linux,macos,win: ret
-// thumb: bx lr
-//
-// CHECK: .popsection
-//
-// thumb: .thumb
-//
-// linux,win: .att_syntax
-
-#[no_mangle]
-#[unsafe(naked)]
-pub extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize {
-    #[cfg(any(target_os = "windows", target_os = "linux"))]
-    {
-        naked_asm!("lea rax, [rdi + rsi]", "ret")
-    }
-
-    #[cfg(target_os = "macos")]
-    {
-        naked_asm!("add x0, x0, x1", "ret")
-    }
-
-    #[cfg(all(target_arch = "arm", target_feature = "thumb-mode"))]
-    {
-        naked_asm!("adds r0, r0, r1", "bx lr")
-    }
-}
-
-// linux:            .pushsection .text.some_different_name,\22ax\22, @progbits
-// macos:            .pushsection .text.some_different_name,regular,pure_instructions
-// win_x86,win_i686: .pushsection .text.some_different_name,\22xr\22
-// thumb:            .pushsection .text.some_different_name,\22ax\22, %progbits
-// CHECK-LABEL: test_link_section:
-#[no_mangle]
-#[unsafe(naked)]
-#[link_section = ".text.some_different_name"]
-pub extern "C" fn test_link_section() {
-    #[cfg(not(all(target_arch = "arm", target_feature = "thumb-mode")))]
-    naked_asm!("ret");
-
-    #[cfg(all(target_arch = "arm", target_feature = "thumb-mode"))]
-    naked_asm!("bx lr");
-}
-
-// win_x86:  .def fastcall_cc
-// win_i686: .def @fastcall_cc@4
-//
-// win_x86,win_i686: .scl 2
-// win_x86,win_i686: .type 32
-// win_x86,win_i686: .endef
-//
-// win_x86-LABEL: fastcall_cc:
-// win_i686-LABEL: @fastcall_cc@4:
-#[cfg(target_os = "windows")]
-#[no_mangle]
-#[unsafe(naked)]
-pub extern "fastcall" fn fastcall_cc(x: i32) -> i32 {
-    naked_asm!("ret");
-}
diff --git a/tests/codegen/no-alloca-inside-if-false.rs b/tests/codegen/no-alloca-inside-if-false.rs
deleted file mode 100644
index a231c7e808a..00000000000
--- a/tests/codegen/no-alloca-inside-if-false.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ compile-flags: -Cno-prepopulate-passes -Copt-level=0 -Cpanic=abort
-// Check that there's an alloca for the reference and the vector, but nothing else.
-// We use panic=abort because unwinding panics give hint::black_box a cleanup block, which has
-// another alloca.
-
-#![crate_type = "lib"]
-
-#[inline(never)]
-fn test<const SIZE: usize>() {
-    // CHECK-LABEL: no_alloca_inside_if_false::test
-    // CHECK: start:
-    // CHECK-NEXT: alloca [{{12|24}} x i8]
-    // CHECK-NOT: alloca
-    if const { SIZE < 4096 } {
-        let arr = [0u8; SIZE];
-        std::hint::black_box(&arr);
-    } else {
-        let vec = vec![0u8; SIZE];
-        std::hint::black_box(&vec);
-    }
-}
-
-// CHECK-LABEL: @main
-#[no_mangle]
-pub fn main() {
-    test::<8192>();
-}
diff --git a/tests/codegen/no-assumes-on-casts.rs b/tests/codegen/no-assumes-on-casts.rs
deleted file mode 100644
index 9c00dc2c015..00000000000
--- a/tests/codegen/no-assumes-on-casts.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![crate_type = "lib"]
-
-//@ compile-flags: -Cno-prepopulate-passes
-
-// CHECK-LABEL: fna
-#[no_mangle]
-pub fn fna(a: i16) -> i32 {
-    a as i32
-    // CHECK-NOT: assume
-    // CHECK: sext
-}
-
-// CHECK-LABEL: fnb
-#[no_mangle]
-pub fn fnb(a: u16) -> u32 {
-    a as u32
-    // CHECK-NOT: assume
-    // CHECK: zext
-}
diff --git a/tests/codegen/no-dllimport-w-cross-lang-lto.rs b/tests/codegen/no-dllimport-w-cross-lang-lto.rs
deleted file mode 100644
index c71eddfa287..00000000000
--- a/tests/codegen/no-dllimport-w-cross-lang-lto.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// This test makes sure that functions get annotated with the proper
-// "target-cpu" attribute in LLVM.
-
-//@ no-prefer-dynamic
-//@ only-msvc
-//@ compile-flags: -C linker-plugin-lto
-
-#![crate_type = "rlib"]
-
-// CHECK-NOT: @{{.*}}__imp_{{.*}}GLOBAL{{.*}} = global i8*
-
-pub static GLOBAL: u32 = 0;
-pub static mut GLOBAL2: u32 = 0;
diff --git a/tests/codegen/no-jump-tables.rs b/tests/codegen/no-jump-tables.rs
deleted file mode 100644
index e49de7e9dc1..00000000000
--- a/tests/codegen/no-jump-tables.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Test that the `no-jump-tables` function attribute are (not) emitted when
-// the `-Zno-jump-tables` flag is (not) set.
-
-//@ add-core-stubs
-//@ revisions: unset set
-//@ needs-llvm-components: x86
-//@ compile-flags: --target x86_64-unknown-linux-gnu
-//@ [set] compile-flags: -Zno-jump-tables
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[no_mangle]
-pub fn foo() {
-    // CHECK: @foo() unnamed_addr #0
-
-    // unset-NOT: attributes #0 = { {{.*}}"no-jump-tables"="true"{{.*}} }
-    // set: attributes #0 = { {{.*}}"no-jump-tables"="true"{{.*}} }
-}
diff --git a/tests/codegen/no-plt.rs b/tests/codegen/no-plt.rs
deleted file mode 100644
index 3a3546ff7c4..00000000000
--- a/tests/codegen/no-plt.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -C relocation-model=pic -Z plt=no
-
-#![crate_type = "lib"]
-
-// We need a function which is normally called through the PLT.
-extern "C" {
-    // CHECK: Function Attrs:{{.*}}nonlazybind
-    fn getenv(name: *const u8) -> *mut u8;
-}
-
-// Ensure the function gets referenced.
-pub unsafe fn call_through_plt() -> *mut u8 {
-    getenv(b"\0".as_ptr())
-}
-
-// Ensure intrinsics also skip the PLT
-// CHECK: !"RtLibUseGOT"
diff --git a/tests/codegen/no-redundant-item-monomorphization.rs b/tests/codegen/no-redundant-item-monomorphization.rs
deleted file mode 100644
index 466037c3770..00000000000
--- a/tests/codegen/no-redundant-item-monomorphization.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Test to make sure that inner functions within a polymorphic outer function
-// don't get re-codegened when the outer function is monomorphized. The test
-// code monomorphizes the outer functions several times, but the magic constants
-// used in the inner functions should each appear only once in the generated IR.
-
-// issue: rust-lang/rust#7349
-//@ compile-flags: -Cno-prepopulate-passes -Copt-level=0
-
-// CHECK-COUNT-1: ret i32 8675309
-// CHECK-COUNT-1: ret i32 11235813
-
-fn outer<T>() {
-    #[allow(dead_code)]
-    fn inner() -> u32 {
-        8675309
-    }
-    inner();
-}
-
-extern "C" fn outer_foreign<T>() {
-    #[allow(dead_code)]
-    fn inner() -> u32 {
-        11235813
-    }
-    inner();
-}
-
-fn main() {
-    outer::<isize>();
-    outer::<usize>();
-    outer_foreign::<isize>();
-    outer_foreign::<usize>();
-}
diff --git a/tests/codegen/no_builtins-at-crate.rs b/tests/codegen/no_builtins-at-crate.rs
deleted file mode 100644
index ba1d31f60c3..00000000000
--- a/tests/codegen/no_builtins-at-crate.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ compile-flags: -C opt-level=1
-
-#![no_builtins]
-#![crate_type = "lib"]
-
-// CHECK: define
-// CHECK-SAME: @__aeabi_memcpy
-// CHECK-SAME: #0
-#[no_mangle]
-pub unsafe extern "C" fn __aeabi_memcpy(dest: *mut u8, src: *const u8, size: usize) {
-    // CHECK: call
-    // CHECK-SAME: @memcpy(
-    memcpy(dest, src, size);
-}
-
-// CHECK: declare
-// CHECK-SAME: @memcpy
-// CHECK-SAME: #0
-extern "C" {
-    pub fn memcpy(dest: *mut u8, src: *const u8, n: usize) -> *mut u8;
-}
-
-// CHECK: attributes #0
-// CHECK-SAME: "no-builtins"
diff --git a/tests/codegen/noalias-box-off.rs b/tests/codegen/noalias-box-off.rs
deleted file mode 100644
index 664c7950280..00000000000
--- a/tests/codegen/noalias-box-off.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z box-noalias=no
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @box_should_not_have_noalias_if_disabled(
-// CHECK-NOT: noalias
-// CHECK-SAME: %foo)
-#[no_mangle]
-pub fn box_should_not_have_noalias_if_disabled(foo: Box<u8>) {
-    drop(foo);
-}
diff --git a/tests/codegen/noalias-box.rs b/tests/codegen/noalias-box.rs
deleted file mode 100644
index cccde775977..00000000000
--- a/tests/codegen/noalias-box.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @box_should_have_noalias_by_default(
-// CHECK: noalias
-#[no_mangle]
-pub fn box_should_have_noalias_by_default(_b: Box<u8>) {}
diff --git a/tests/codegen/noalias-flag.rs b/tests/codegen/noalias-flag.rs
deleted file mode 100644
index 67ba68ee6f8..00000000000
--- a/tests/codegen/noalias-flag.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Zmutable-noalias=no
-
-#![crate_type = "lib"]
-
-// `-Zmutable-noalias=no` should disable noalias on mut refs...
-
-// CHECK-LABEL: @test_mut_ref(
-// CHECK-NOT: noalias
-// CHECK-SAME: %x
-#[no_mangle]
-pub fn test_mut_ref(x: &mut i32) -> &mut i32 {
-    x
-}
-
-// ...but not on shared refs
-
-// CHECK-LABEL: @test_ref(
-// CHECK-SAME: noalias
-// CHECK-SAME: %x
-#[no_mangle]
-pub fn test_ref(x: &i32) -> &i32 {
-    x
-}
diff --git a/tests/codegen/noalias-freeze.rs b/tests/codegen/noalias-freeze.rs
deleted file mode 100644
index 32c84014026..00000000000
--- a/tests/codegen/noalias-freeze.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//@ compile-flags: -Copt-level=1
-
-// References returned by a Frozen pointer type
-// could be marked as "noalias", which caused miscompilation errors.
-// This test runs the most minimal possible code that can reproduce this bug,
-// and checks that noalias does not appear.
-// See https://github.com/rust-lang/rust/issues/46239
-
-#![crate_type = "lib"]
-
-fn project<T>(x: &(T,)) -> &T {
-    &x.0
-}
-
-fn dummy() {}
-
-// CHECK-LABEL: @foo(
-// CHECK-NOT: noalias
-#[no_mangle]
-pub fn foo() {
-    let f = (dummy as fn(),);
-    (*project(&f))();
-}
diff --git a/tests/codegen/noalias-refcell.rs b/tests/codegen/noalias-refcell.rs
deleted file mode 100644
index b37adf92b9c..00000000000
--- a/tests/codegen/noalias-refcell.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Z mutable-noalias=yes
-
-#![crate_type = "lib"]
-
-use std::cell::{Ref, RefCell, RefMut};
-
-// Make sure that none of the arguments get a `noalias` attribute, because
-// the `RefCell` might alias writes after either `Ref`/`RefMut` is dropped.
-
-// CHECK-LABEL: @maybe_aliased(
-// CHECK-NOT: noalias
-// CHECK-SAME: %_refcell
-#[no_mangle]
-pub unsafe fn maybe_aliased(_: Ref<'_, i32>, _: RefMut<'_, i32>, _refcell: &RefCell<i32>) {}
diff --git a/tests/codegen/noalias-rwlockreadguard.rs b/tests/codegen/noalias-rwlockreadguard.rs
deleted file mode 100644
index c676dc32399..00000000000
--- a/tests/codegen/noalias-rwlockreadguard.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes -Z mutable-noalias=yes
-
-#![crate_type = "lib"]
-
-use std::sync::{RwLock, RwLockReadGuard};
-
-// Make sure that `RwLockReadGuard` does not get a `noalias` attribute, because
-// the `RwLock` might alias writes after it is dropped.
-
-// CHECK-LABEL: @maybe_aliased(
-// CHECK-NOT: noalias
-// CHECK-SAME: %_data
-#[no_mangle]
-pub unsafe fn maybe_aliased(_: RwLockReadGuard<'_, i32>, _data: &RwLock<i32>) {}
diff --git a/tests/codegen/noalias-unpin.rs b/tests/codegen/noalias-unpin.rs
deleted file mode 100644
index 30a8b399b97..00000000000
--- a/tests/codegen/noalias-unpin.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z mutable-noalias=yes
-
-#![crate_type = "lib"]
-
-pub struct SelfRef {
-    self_ref: *mut SelfRef,
-    _pin: std::marker::PhantomPinned,
-}
-
-// CHECK-LABEL: @test_self_ref(
-// CHECK-NOT: noalias
-#[no_mangle]
-pub unsafe fn test_self_ref(s: &mut SelfRef) {
-    (*s.self_ref).self_ref = std::ptr::null_mut();
-}
diff --git a/tests/codegen/non-terminate/infinite-loop-1.rs b/tests/codegen/non-terminate/infinite-loop-1.rs
deleted file mode 100644
index 9eab4939aee..00000000000
--- a/tests/codegen/non-terminate/infinite-loop-1.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -C opt-level=3
-
-#![crate_type = "lib"]
-
-fn infinite_loop() -> u8 {
-    loop {}
-}
-
-// CHECK-LABEL: @test
-#[no_mangle]
-fn test() -> u8 {
-    // CHECK-NOT: unreachable
-    // CHECK: br label %{{.+}}
-    // CHECK-NOT: unreachable
-    let x = infinite_loop();
-    x
-}
diff --git a/tests/codegen/non-terminate/infinite-loop-2.rs b/tests/codegen/non-terminate/infinite-loop-2.rs
deleted file mode 100644
index da29361cc96..00000000000
--- a/tests/codegen/non-terminate/infinite-loop-2.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ compile-flags: -C opt-level=3
-
-#![crate_type = "lib"]
-
-fn infinite_loop() -> u8 {
-    let i = 2;
-    while i > 1 {}
-    1
-}
-
-// CHECK-LABEL: @test
-#[no_mangle]
-fn test() -> u8 {
-    // CHECK-NOT: unreachable
-    // CHECK: br label %{{.+}}
-    // CHECK-NOT: unreachable
-    let x = infinite_loop();
-    x
-}
diff --git a/tests/codegen/non-terminate/infinite-recursion.rs b/tests/codegen/non-terminate/infinite-recursion.rs
deleted file mode 100644
index 19123639896..00000000000
--- a/tests/codegen/non-terminate/infinite-recursion.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ compile-flags: -C opt-level=3
-
-#![crate_type = "lib"]
-#![allow(unconditional_recursion)]
-
-// CHECK-LABEL: @infinite_recursion
-#[no_mangle]
-fn infinite_recursion() -> u8 {
-    // CHECK-NOT: ret i8 undef
-    // CHECK: br label %{{.+}}
-    // CHECK-NOT: ret i8 undef
-    infinite_recursion()
-}
diff --git a/tests/codegen/non-terminate/nonempty-infinite-loop.rs b/tests/codegen/non-terminate/nonempty-infinite-loop.rs
deleted file mode 100644
index 0db4ee61b1b..00000000000
--- a/tests/codegen/non-terminate/nonempty-infinite-loop.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ compile-flags: -C opt-level=3
-
-#![crate_type = "lib"]
-
-// Verify that we don't miscompile this even if rustc didn't apply the trivial loop detection to
-// insert the sideeffect intrinsic.
-
-fn infinite_loop() -> u8 {
-    let mut x = 0;
-    // CHECK-NOT: sideeffect
-    loop {
-        if x == 42 {
-            x = 0;
-        } else {
-            x = 42;
-        }
-    }
-}
-
-// CHECK-LABEL: @test
-#[no_mangle]
-fn test() -> u8 {
-    // CHECK-NOT: unreachable
-    // CHECK: br label %{{.+}}
-    // CHECK-NOT: unreachable
-    let x = infinite_loop();
-    x
-}
diff --git a/tests/codegen/noreturn-uninhabited.rs b/tests/codegen/noreturn-uninhabited.rs
deleted file mode 100644
index a10795d3f3c..00000000000
--- a/tests/codegen/noreturn-uninhabited.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//@ compile-flags: -g -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-#[derive(Clone, Copy)]
-pub enum EmptyEnum {}
-
-#[no_mangle]
-pub fn empty(x: &EmptyEnum) -> EmptyEnum {
-    // CHECK: @empty({{.*}}) unnamed_addr #0
-    // CHECK-NOT: ret void
-    // CHECK: call void @llvm.trap()
-    // CHECK: unreachable
-    *x
-}
-
-pub struct Foo(String, EmptyEnum);
-
-#[no_mangle]
-pub fn foo(x: String, y: &EmptyEnum) -> Foo {
-    // CHECK: @foo({{.*}}) unnamed_addr #0
-    // CHECK-NOT: ret %Foo
-    // CHECK: call void @llvm.trap()
-    // CHECK: unreachable
-    Foo(x, *y)
-}
-
-// CHECK: attributes #0 = {{{.*}} noreturn {{.*}}}
-
-// CHECK: DISubprogram(name: "empty", {{.*}} DIFlagNoReturn
-// CHECK: DISubprogram(name: "foo", {{.*}} DIFlagNoReturn
diff --git a/tests/codegen/noreturnflag.rs b/tests/codegen/noreturnflag.rs
deleted file mode 100644
index d9bb30b2703..00000000000
--- a/tests/codegen/noreturnflag.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//@ compile-flags: -g -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn foo() -> ! {
-    // CHECK: @foo() unnamed_addr #0
-    loop {}
-}
-
-pub enum EmptyEnum {}
-
-#[no_mangle]
-pub fn bar() -> EmptyEnum {
-    // CHECK: @bar() unnamed_addr #0
-    loop {}
-}
-
-// CHECK: attributes #0 = {{{.*}} noreturn {{.*}}}
-
-// CHECK: DISubprogram(name: "foo", {{.*}} DIFlagNoReturn
-// CHECK: DISubprogram(name: "bar", {{.*}} DIFlagNoReturn
diff --git a/tests/codegen/nounwind.rs b/tests/codegen/nounwind.rs
deleted file mode 100644
index c910644458a..00000000000
--- a/tests/codegen/nounwind.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ aux-build:nounwind.rs
-//@ compile-flags: -C no-prepopulate-passes -C panic=abort -C metadata=a
-//@ ignore-android
-
-#![crate_type = "lib"]
-
-extern crate nounwind;
-
-#[no_mangle]
-pub fn foo() {
-    nounwind::bar();
-    // CHECK: @foo() unnamed_addr #0
-    // CHECK: @bar() unnamed_addr #0
-    // CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
-}
diff --git a/tests/codegen/nrvo.rs b/tests/codegen/nrvo.rs
deleted file mode 100644
index 7972186bfe5..00000000000
--- a/tests/codegen/nrvo.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// Ensure that we do not call `memcpy` for the following function.
-// `memset` and `init` should be called directly on the return pointer.
-#[no_mangle]
-pub fn nrvo(init: fn(&mut [u8; 4096])) -> [u8; 4096] {
-    // CHECK-LABEL: nrvo
-    // CHECK: @llvm.memset
-    // FIXME: turn on nrvo then check-not: @llvm.memcpy
-    // CHECK: ret
-    // CHECK-EMPTY
-    let mut buf = [0; 4096];
-    init(&mut buf);
-    buf
-}
diff --git a/tests/codegen/optimize-attr-1.rs b/tests/codegen/optimize-attr-1.rs
deleted file mode 100644
index db6bdcf9a8b..00000000000
--- a/tests/codegen/optimize-attr-1.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//@ revisions: NO-OPT SIZE-OPT SPEED-OPT
-//@[NO-OPT] compile-flags: -Copt-level=0 -Ccodegen-units=1
-//@[SIZE-OPT] compile-flags: -Copt-level=s -Ccodegen-units=1
-//@[SPEED-OPT] compile-flags: -Copt-level=3 -Ccodegen-units=1
-
-#![feature(optimize_attribute)]
-#![crate_type = "rlib"]
-
-// CHECK-LABEL: define{{.*}}i32 @nothing
-// CHECK-SAME: [[NOTHING_ATTRS:#[0-9]+]]
-// SIZE-OPT: ret i32 4
-// SPEED-OPT: ret i32 4
-#[no_mangle]
-pub fn nothing() -> i32 {
-    2 + 2
-}
-
-// CHECK-LABEL: define{{.*}}i32 @size
-// CHECK-SAME: [[SIZE_ATTRS:#[0-9]+]]
-// SIZE-OPT: ret i32 6
-// SPEED-OPT: ret i32 6
-#[optimize(size)]
-#[no_mangle]
-pub fn size() -> i32 {
-    3 + 3
-}
-
-// CHECK-LABEL: define{{.*}}i32 @speed
-// NO-OPT-SAME: [[NOTHING_ATTRS]]
-// SPEED-OPT-SAME: [[NOTHING_ATTRS]]
-// SIZE-OPT-SAME: [[SPEED_ATTRS:#[0-9]+]]
-// SIZE-OPT: ret i32 8
-// SPEED-OPT: ret i32 8
-#[optimize(speed)]
-#[no_mangle]
-pub fn speed() -> i32 {
-    4 + 4
-}
-
-// CHECK-LABEL: define{{.*}}i32 @none
-// CHECK-SAME: [[NONE_ATTRS:#[0-9]+]]
-// SIZE-OPT: alloca
-// SPEED-OPT: alloca
-#[no_mangle]
-#[optimize(none)]
-pub fn none() -> i32 {
-    let arr = [0, 1, 2, 3, 4];
-    arr[4]
-}
-
-// NO-OPT-DAG: attributes [[SIZE_ATTRS]] = {{.*}}minsize{{.*}}optsize{{.*}}
-// SPEED-OPT-DAG: attributes [[SIZE_ATTRS]] = {{.*}}minsize{{.*}}optsize{{.*}}
-// SIZE-OPT-DAG: attributes [[NOTHING_ATTRS]] = {{.*}}optsize{{.*}}
-// SIZE-OPT-DAG: attributes [[SIZE_ATTRS]] = {{.*}}minsize{{.*}}optsize{{.*}}
-// CHECK-DAG: attributes [[NONE_ATTRS]] = {{.*}}noinline{{.*}}optnone{{.*}}
-
-// SIZE-OPT-DAG: attributes [[SPEED_ATTRS]]
-// SIZE-OPT-NOT: minsize
-// SIZE-OPT-NOT: optsize
diff --git a/tests/codegen/option-as-slice.rs b/tests/codegen/option-as-slice.rs
deleted file mode 100644
index 39b34a2035b..00000000000
--- a/tests/codegen/option-as-slice.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z randomize-layout=no
-//@ only-x86_64
-#![crate_type = "lib"]
-
-extern crate core;
-
-use core::num::NonZero;
-use core::option::Option;
-
-// CHECK-LABEL: @u64_opt_as_slice
-#[no_mangle]
-pub fn u64_opt_as_slice(o: &Option<u64>) -> &[u64] {
-    // CHECK-NOT: select
-    // CHECK-NOT: br
-    // CHECK-NOT: switch
-    // CHECK-NOT: icmp
-    // CHECK: %[[LEN:.+]] = load i64
-    // CHECK-SAME: !range ![[META_U64:[0-9]+]],
-    // CHECK-SAME: !noundef
-    // CHECK-NOT: select
-    // CHECK-NOT: br
-    // CHECK-NOT: switch
-    // CHECK-NOT: icmp
-    // CHECK: %[[T0:.+]] = insertvalue { ptr, i64 } poison, ptr %{{.+}}, 0
-    // CHECK-NEXT: %[[T1:.+]] = insertvalue { ptr, i64 } %[[T0]], i64 %[[LEN]], 1
-    // CHECK-NEXT: ret { ptr, i64 } %[[T1]]
-    o.as_slice()
-}
-
-// CHECK-LABEL: @nonzero_u64_opt_as_slice
-#[no_mangle]
-pub fn nonzero_u64_opt_as_slice(o: &Option<NonZero<u64>>) -> &[NonZero<u64>] {
-    // CHECK-NOT: select
-    // CHECK-NOT: br
-    // CHECK-NOT: switch
-    // CHECK-NOT: icmp
-    // CHECK: %[[NZ:.+]] = icmp ne i64 %{{.+}}, 0
-    // CHECK-NEXT: %[[LEN:.+]] = zext i1 %[[NZ]] to i64
-    // CHECK-NOT: select
-    // CHECK-NOT: br
-    // CHECK-NOT: switch
-    // CHECK-NOT: icmp
-    // CHECK: %[[T0:.+]] = insertvalue { ptr, i64 } poison, ptr %o, 0
-    // CHECK-NEXT: %[[T1:.+]] = insertvalue { ptr, i64 } %[[T0]], i64 %[[LEN]], 1
-    // CHECK-NEXT: ret { ptr, i64 } %[[T1]]
-    o.as_slice()
-}
-
-// CHECK-LABEL: @u8_opt_as_slice
-#[no_mangle]
-pub fn u8_opt_as_slice(o: &Option<u8>) -> &[u8] {
-    // CHECK-NOT: select
-    // CHECK-NOT: br
-    // CHECK-NOT: switch
-    // CHECK-NOT: icmp
-    // CHECK: %[[TAG:.+]] = load i8
-    // CHECK-SAME: !range ![[META_U8:[0-9]+]],
-    // CHECK-SAME: !noundef
-    // CHECK: %[[LEN:.+]] = zext{{.*}} i8 %[[TAG]] to i64
-    // CHECK-NOT: select
-    // CHECK-NOT: br
-    // CHECK-NOT: switch
-    // CHECK-NOT: icmp
-    // CHECK: %[[T0:.+]] = insertvalue { ptr, i64 } poison, ptr %{{.+}}, 0
-    // CHECK-NEXT: %[[T1:.+]] = insertvalue { ptr, i64 } %[[T0]], i64 %[[LEN]], 1
-    // CHECK-NEXT: ret { ptr, i64 } %[[T1]]
-    o.as_slice()
-}
-
-// CHECK: ![[META_U64]] = !{i64 0, i64 2}
-// CHECK: ![[META_U8]] = !{i8 0, i8 2}
diff --git a/tests/codegen/option-niche-eq.rs b/tests/codegen/option-niche-eq.rs
deleted file mode 100644
index 3900cb79aa2..00000000000
--- a/tests/codegen/option-niche-eq.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-//@ revisions: REGULAR LLVM21
-//@ min-llvm-version: 20
-//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-//@ [LLVM21] min-llvm-version: 21
-#![crate_type = "lib"]
-
-extern crate core;
-use core::cmp::Ordering;
-use core::num::NonZero;
-use core::ptr::NonNull;
-
-// CHECK-LABEL: @non_zero_eq
-#[no_mangle]
-pub fn non_zero_eq(l: Option<NonZero<u32>>, r: Option<NonZero<u32>>) -> bool {
-    // CHECK: start:
-    // CHECK-NEXT: icmp eq i32
-    // CHECK-NEXT: ret i1
-    l == r
-}
-
-// CHECK-LABEL: @non_zero_signed_eq
-#[no_mangle]
-pub fn non_zero_signed_eq(l: Option<NonZero<i64>>, r: Option<NonZero<i64>>) -> bool {
-    // CHECK: start:
-    // CHECK-NEXT: icmp eq i64
-    // CHECK-NEXT: ret i1
-    l == r
-}
-
-// FIXME(#49892)
-// This currently relies on a manual implementation of `PartialOrd`/`Ord` for `Option`
-// Once LLVM is better able to optimize this pattern, we can return to using a derive.
-// CHECK-LABEL: @non_zero_ord
-#[no_mangle]
-pub fn non_zero_ord(a: Option<NonZero<u32>>, b: Option<NonZero<u32>>) -> bool {
-    // CHECK: start:
-    // CHECK-NEXT: icmp ult i32
-    // CHECK-NEXT: ret i1
-    a < b
-}
-
-// CHECK-LABEL: @non_null_eq
-#[no_mangle]
-pub fn non_null_eq(l: Option<NonNull<u8>>, r: Option<NonNull<u8>>) -> bool {
-    // CHECK: start:
-    // CHECK-NEXT: icmp eq ptr
-    // CHECK-NEXT: ret i1
-    l == r
-}
-
-// CHECK-LABEL: @ordering_eq
-#[no_mangle]
-pub fn ordering_eq(l: Option<Ordering>, r: Option<Ordering>) -> bool {
-    // CHECK: start:
-    // CHECK-NEXT: icmp eq i8
-    // CHECK-NEXT: ret i1
-    l == r
-}
-
-#[derive(PartialEq)]
-pub enum EnumWithNiche {
-    A,
-    B,
-    C,
-    D,
-    E,
-    F,
-    G,
-}
-
-// CHECK-LABEL: @niche_eq
-#[no_mangle]
-pub fn niche_eq(l: Option<EnumWithNiche>, r: Option<EnumWithNiche>) -> bool {
-    // CHECK: start:
-    // CHECK-NEXT: icmp eq i8
-    // CHECK-NEXT: ret i1
-    l == r
-}
-
-// LLVM21-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
-    l == r
-}
diff --git a/tests/codegen/option-niche-unfixed/option-nonzero-eq.rs b/tests/codegen/option-niche-unfixed/option-nonzero-eq.rs
deleted file mode 100644
index 308856cfb7e..00000000000
--- a/tests/codegen/option-niche-unfixed/option-nonzero-eq.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ should-fail
-//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-//! FIXME(#49892)
-//! Test that the derived implementation of `PartialEq` for `Option` is not fully
-//! optimized by LLVM. If this starts passing, the test and manual impl should
-//! be removed.
-#![crate_type = "lib"]
-
-use std::num::NonZero;
-
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub enum Option<T> {
-    None,
-    Some(T),
-}
-
-// CHECK-LABEL: @non_zero_eq
-#[no_mangle]
-pub fn non_zero_eq(l: Option<NonZero<u32>>, r: Option<NonZero<u32>>) -> bool {
-    // CHECK: start:
-    // CHECK-NEXT: icmp eq i32
-    // CHECK-NEXT: ret i1
-    l == r
-}
diff --git a/tests/codegen/overaligned-constant.rs b/tests/codegen/overaligned-constant.rs
deleted file mode 100644
index 0f5977880f2..00000000000
--- a/tests/codegen/overaligned-constant.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-// GVN may create indirect constants with higher alignment than their type requires. Verify that we
-// do not ICE during codegen, and that the LLVM constant has the higher alignment.
-//
-//@ compile-flags: -Zmir-opt-level=0 -Zmir-enable-passes=+GVN
-//@ compile-flags: -Cno-prepopulate-passes --crate-type=lib
-//@ only-64bit
-
-struct S(i32);
-
-struct SmallStruct(f32, Option<S>, &'static [f32]);
-
-// CHECK: [[const:@.*]] = private unnamed_addr constant
-// CHECK-SAME: , align 8
-
-#[no_mangle]
-pub fn overaligned_constant() {
-    // CHECK-LABEL: @overaligned_constant
-    // CHECK: [[full:%_.*]] = alloca [32 x i8], align 8
-    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[full]], ptr align 8 [[const]], i64 32, i1 false)
-    let mut s = S(1);
-
-    s.0 = 3;
-
-    // SMALL_VAL corresponds to a MIR allocation with alignment 8.
-    const SMALL_VAL: SmallStruct = SmallStruct(4., Some(S(1)), &[]);
-
-    // In pre-codegen MIR:
-    // `a` is a scalar 4.
-    // `b` is an indirect constant at `SMALL_VAL`'s alloc with 0 offset.
-    // `c` is the empty slice.
-    //
-    // As a consequence, during codegen, we create a LLVM allocation for `SMALL_VAL`, with
-    // alignment 8, but only use the `Option<S>` field, at offset 0 with alignment 4.
-    let SmallStruct(a, b, c) = SMALL_VAL;
-}
diff --git a/tests/codegen/packed.rs b/tests/codegen/packed.rs
deleted file mode 100644
index 6f62719282e..00000000000
--- a/tests/codegen/packed.rs
+++ /dev/null
@@ -1,153 +0,0 @@
-//
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-#[repr(packed)]
-pub struct Packed1 {
-    dealign: u8,
-    data: u32,
-}
-
-#[repr(packed(2))]
-pub struct Packed2 {
-    dealign: u8,
-    data: u32,
-}
-
-// CHECK-LABEL: @write_pkd1
-#[no_mangle]
-pub fn write_pkd1(pkd: &mut Packed1) -> u32 {
-    // CHECK: %{{.*}} = load i32, ptr %{{.*}}, align 1
-    // CHECK: store i32 42, ptr %{{.*}}, align 1
-    let result = pkd.data;
-    pkd.data = 42;
-    result
-}
-
-// CHECK-LABEL: @write_pkd2
-#[no_mangle]
-pub fn write_pkd2(pkd: &mut Packed2) -> u32 {
-    // CHECK: %{{.*}} = load i32, ptr %{{.*}}, align 2
-    // CHECK: store i32 42, ptr %{{.*}}, align 2
-    let result = pkd.data;
-    pkd.data = 42;
-    result
-}
-
-pub struct Array([i32; 8]);
-#[repr(packed)]
-pub struct BigPacked1 {
-    dealign: u8,
-    data: Array,
-}
-
-#[repr(packed(2))]
-pub struct BigPacked2 {
-    dealign: u8,
-    data: Array,
-}
-
-// CHECK-LABEL: @call_pkd1
-#[no_mangle]
-pub fn call_pkd1(f: fn() -> Array) -> BigPacked1 {
-    // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca [32 x i8]
-    // CHECK: call void %{{.*}}(ptr{{( captures(none))?}} noalias{{( nocapture)?}} noundef sret{{.*}} dereferenceable(32) [[ALLOCA]])
-    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 %{{.*}}, ptr align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false)
-    // check that calls whose destination is a field of a packed struct
-    // go through an alloca rather than calling the function with an
-    // unaligned destination.
-    BigPacked1 { dealign: 0, data: f() }
-}
-
-// CHECK-LABEL: @call_pkd2
-#[no_mangle]
-pub fn call_pkd2(f: fn() -> Array) -> BigPacked2 {
-    // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca [32 x i8]
-    // CHECK: call void %{{.*}}(ptr{{( captures(none))?}} noalias{{( nocapture)?}} noundef sret{{.*}} dereferenceable(32) [[ALLOCA]])
-    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 2 %{{.*}}, ptr align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false)
-    // check that calls whose destination is a field of a packed struct
-    // go through an alloca rather than calling the function with an
-    // unaligned destination.
-    BigPacked2 { dealign: 0, data: f() }
-}
-
-// CHECK-LABEL: @write_packed_array1
-// CHECK: store i32 0, ptr %{{.+}}, align 1
-// CHECK: store i32 1, ptr %{{.+}}, align 1
-// CHECK: store i32 2, ptr %{{.+}}, align 1
-#[no_mangle]
-pub fn write_packed_array1(p: &mut BigPacked1) {
-    p.data.0[0] = 0;
-    p.data.0[1] = 1;
-    p.data.0[2] = 2;
-}
-
-// CHECK-LABEL: @write_packed_array2
-// CHECK: store i32 0, ptr %{{.+}}, align 2
-// CHECK: store i32 1, ptr %{{.+}}, align 2
-// CHECK: store i32 2, ptr %{{.+}}, align 2
-#[no_mangle]
-pub fn write_packed_array2(p: &mut BigPacked2) {
-    p.data.0[0] = 0;
-    p.data.0[1] = 1;
-    p.data.0[2] = 2;
-}
-
-// CHECK-LABEL: @repeat_packed_array1
-// CHECK: store i32 42, ptr %{{.+}}, align 1
-#[no_mangle]
-pub fn repeat_packed_array1(p: &mut BigPacked1) {
-    p.data.0 = [42; 8];
-}
-
-// CHECK-LABEL: @repeat_packed_array2
-// CHECK: store i32 42, ptr %{{.+}}, align 2
-#[no_mangle]
-pub fn repeat_packed_array2(p: &mut BigPacked2) {
-    p.data.0 = [42; 8];
-}
-
-#[repr(packed)]
-#[derive(Copy, Clone)]
-pub struct Packed1Pair(u8, u32);
-
-#[repr(packed(2))]
-#[derive(Copy, Clone)]
-pub struct Packed2Pair(u8, u32);
-
-// CHECK-LABEL: @pkd1_pair
-#[no_mangle]
-pub fn pkd1_pair(pair1: &mut Packed1Pair, pair2: &mut Packed1Pair) {
-    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 %{{.*}}, ptr align 1 %{{.*}}, i{{[0-9]+}} 5, i1 false)
-    *pair2 = *pair1;
-}
-
-// CHECK-LABEL: @pkd2_pair
-#[no_mangle]
-pub fn pkd2_pair(pair1: &mut Packed2Pair, pair2: &mut Packed2Pair) {
-    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 2 %{{.*}}, ptr align 2 %{{.*}}, i{{[0-9]+}} 6, i1 false)
-    *pair2 = *pair1;
-}
-
-#[repr(packed)]
-#[derive(Copy, Clone)]
-pub struct Packed1NestedPair((u32, u32));
-
-#[repr(packed(2))]
-#[derive(Copy, Clone)]
-pub struct Packed2NestedPair((u32, u32));
-
-// CHECK-LABEL: @pkd1_nested_pair
-#[no_mangle]
-pub fn pkd1_nested_pair(pair1: &mut Packed1NestedPair, pair2: &mut Packed1NestedPair) {
-    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 %{{.*}}, ptr align 1 %{{.*}}, i{{[0-9]+}} 8, i1 false)
-    *pair2 = *pair1;
-}
-
-// CHECK-LABEL: @pkd2_nested_pair
-#[no_mangle]
-pub fn pkd2_nested_pair(pair1: &mut Packed2NestedPair, pair2: &mut Packed2NestedPair) {
-    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 2 %{{.*}}, ptr align 2 %{{.*}}, i{{[0-9]+}} 8, i1 false)
-    *pair2 = *pair1;
-}
diff --git a/tests/codegen/panic-abort-windows.rs b/tests/codegen/panic-abort-windows.rs
deleted file mode 100644
index 17fdd9cc726..00000000000
--- a/tests/codegen/panic-abort-windows.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// This test is for *-windows only.
-//@ only-windows
-
-//@ compile-flags: -C no-prepopulate-passes -C panic=abort -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK: Function Attrs: nounwind uwtable
-// CHECK-NEXT: define void @normal_uwtable()
-#[no_mangle]
-pub fn normal_uwtable() {}
-
-// CHECK: Function Attrs: nounwind uwtable
-// CHECK-NEXT: define void @extern_uwtable()
-#[no_mangle]
-pub extern "C" fn extern_uwtable() {}
diff --git a/tests/codegen/panic-in-drop-abort.rs b/tests/codegen/panic-in-drop-abort.rs
deleted file mode 100644
index e89170e56ed..00000000000
--- a/tests/codegen/panic-in-drop-abort.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-//@ compile-flags: -Z panic-in-drop=abort -Copt-level=3
-//@ ignore-msvc
-
-// Ensure that unwinding code paths are eliminated from the output after
-// optimization.
-
-// This test uses ignore-msvc, because the expected optimization does not happen on targets using
-// SEH exceptions with the new LLVM pass manager anymore, see
-// https://github.com/llvm/llvm-project/issues/51311.
-
-// CHECK-NOT: {{(call|invoke).*}}should_not_appear_in_output
-
-#![crate_type = "lib"]
-use std::any::Any;
-use std::mem::forget;
-
-pub struct ExternDrop;
-impl Drop for ExternDrop {
-    #[inline(always)]
-    fn drop(&mut self) {
-        // This call may potentially unwind.
-        extern "Rust" {
-            fn extern_drop();
-        }
-        unsafe {
-            extern_drop();
-        }
-    }
-}
-
-struct AssertNeverDrop;
-impl Drop for AssertNeverDrop {
-    #[inline(always)]
-    fn drop(&mut self) {
-        // This call should be optimized away as unreachable.
-        extern "C" {
-            fn should_not_appear_in_output();
-        }
-        unsafe {
-            should_not_appear_in_output();
-        }
-    }
-}
-
-#[no_mangle]
-pub fn normal_drop(x: ExternDrop) {
-    let guard = AssertNeverDrop;
-    drop(x);
-    forget(guard);
-}
-
-#[no_mangle]
-pub fn indirect_drop(x: Box<dyn Any>) {
-    let guard = AssertNeverDrop;
-    drop(x);
-    forget(guard);
-}
diff --git a/tests/codegen/panic-unwind-default-uwtable.rs b/tests/codegen/panic-unwind-default-uwtable.rs
deleted file mode 100644
index 06f616c519b..00000000000
--- a/tests/codegen/panic-unwind-default-uwtable.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//@ compile-flags: -C panic=unwind -C no-prepopulate-passes -Copt-level=0
-
-#![crate_type = "lib"]
-
-// CHECK: attributes #{{.*}} uwtable
-pub fn foo() {}
diff --git a/tests/codegen/patchable-function-entry/patchable-function-entry-both-flags.rs b/tests/codegen/patchable-function-entry/patchable-function-entry-both-flags.rs
deleted file mode 100644
index 72204c78a49..00000000000
--- a/tests/codegen/patchable-function-entry/patchable-function-entry-both-flags.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-//@ compile-flags: -Z patchable-function-entry=15,10
-
-#![feature(patchable_function_entry)]
-#![crate_type = "lib"]
-
-// This should have the default, as set by the compile flags
-#[no_mangle]
-pub fn fun0() {}
-
-// The attribute should override the compile flags
-#[no_mangle]
-#[patchable_function_entry(prefix_nops = 1, entry_nops = 2)]
-pub fn fun1() {}
-
-// If we override an attribute to 0 or unset, the attribute should go away
-#[no_mangle]
-#[patchable_function_entry(entry_nops = 0)]
-pub fn fun2() {}
-
-// The attribute should override the compile flags
-#[no_mangle]
-#[patchable_function_entry(prefix_nops = 20, entry_nops = 1)]
-pub fn fun3() {}
-
-// The attribute should override the compile flags
-#[no_mangle]
-#[patchable_function_entry(prefix_nops = 2, entry_nops = 19)]
-pub fn fun4() {}
-
-// The attribute should override patchable-function-entry to 3 and
-// patchable-function-prefix to the default of 0, clearing it entirely
-#[no_mangle]
-#[patchable_function_entry(entry_nops = 3)]
-pub fn fun5() {}
-
-// The attribute should override patchable-function-prefix to 4
-// and patchable-function-entry to the default of 0, clearing it entirely
-#[no_mangle]
-#[patchable_function_entry(prefix_nops = 4)]
-pub fn fun6() {}
-
-// CHECK: @fun0() unnamed_addr #0
-// CHECK: @fun1() unnamed_addr #1
-// CHECK: @fun2() unnamed_addr #2
-// CHECK: @fun3() unnamed_addr #3
-// CHECK: @fun4() unnamed_addr #4
-// CHECK: @fun5() unnamed_addr #5
-// CHECK: @fun6() unnamed_addr #6
-
-// CHECK: attributes #0 = { {{.*}}"patchable-function-entry"="5"{{.*}}"patchable-function-prefix"="10" {{.*}} }
-// CHECK: attributes #1 = { {{.*}}"patchable-function-entry"="2"{{.*}}"patchable-function-prefix"="1" {{.*}} }
-
-// CHECK-NOT: attributes #2 = { {{.*}}patchable-function-entry{{.*}} }
-// CHECK-NOT: attributes #2 = { {{.*}}patchable-function-prefix{{.*}} }
-// CHECK: attributes #2 = { {{.*}} }
-
-// CHECK: attributes #3 = { {{.*}}"patchable-function-entry"="1"{{.*}}"patchable-function-prefix"="20" {{.*}} }
-// CHECK: attributes #4 = { {{.*}}"patchable-function-entry"="19"{{.*}}"patchable-function-prefix"="2" {{.*}} }
-
-// CHECK: attributes #5 = { {{.*}}"patchable-function-entry"="3"{{.*}} }
-// CHECK-NOT: attributes #5 = { {{.*}}patchable-function-prefix{{.*}} }
-
-// CHECK: attributes #6 = { {{.*}}"patchable-function-prefix"="4"{{.*}} }
-// CHECK-NOT: attributes #6 = { {{.*}}patchable-function-entry{{.*}} }
diff --git a/tests/codegen/patchable-function-entry/patchable-function-entry-no-flag.rs b/tests/codegen/patchable-function-entry/patchable-function-entry-no-flag.rs
deleted file mode 100644
index 3a7078fe551..00000000000
--- a/tests/codegen/patchable-function-entry/patchable-function-entry-no-flag.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-#![feature(patchable_function_entry)]
-#![crate_type = "lib"]
-
-// No patchable function entry should be set
-#[no_mangle]
-pub fn fun0() {}
-
-// The attribute should work even without compiler flags
-#[no_mangle]
-#[patchable_function_entry(prefix_nops = 1, entry_nops = 2)]
-pub fn fun1() {}
-
-// The attribute should work even without compiler flags
-// and only set patchable-function-entry to 3.
-#[no_mangle]
-#[patchable_function_entry(entry_nops = 3)]
-pub fn fun2() {}
-
-// The attribute should work even without compiler flags
-// and only set patchable-function-prefix to 4.
-#[no_mangle]
-#[patchable_function_entry(prefix_nops = 4)]
-pub fn fun3() {}
-
-// CHECK: @fun0() unnamed_addr #0
-// CHECK: @fun1() unnamed_addr #1
-// CHECK: @fun2() unnamed_addr #2
-// CHECK: @fun3() unnamed_addr #3
-
-// CHECK-NOT: attributes #0 = { {{.*}}patchable-function-entry{{.*}} }
-// CHECK-NOT: attributes #0 = { {{.*}}patchable-function-prefix{{.*}} }
-
-// CHECK: attributes #1 = { {{.*}}"patchable-function-entry"="2"{{.*}}"patchable-function-prefix"="1" {{.*}} }
-
-// CHECK: attributes #2 = { {{.*}}"patchable-function-entry"="3"{{.*}} }
-// CHECK-NOT: attributes #2 = { {{.*}}patchable-function-prefix{{.*}} }
-
-// CHECK: attributes #3 = { {{.*}}"patchable-function-prefix"="4"{{.*}} }
-// CHECK-NOT: attributes #3 = { {{.*}}patchable-function-entry{{.*}} }
diff --git a/tests/codegen/patchable-function-entry/patchable-function-entry-one-flag.rs b/tests/codegen/patchable-function-entry/patchable-function-entry-one-flag.rs
deleted file mode 100644
index 8bdd61e461b..00000000000
--- a/tests/codegen/patchable-function-entry/patchable-function-entry-one-flag.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//@ compile-flags: -Z patchable-function-entry=15
-
-#![feature(patchable_function_entry)]
-#![crate_type = "lib"]
-
-// This should have the default, as set by the compile flags
-#[no_mangle]
-pub fn fun0() {}
-
-// The attribute should override the compile flags
-#[no_mangle]
-#[patchable_function_entry(prefix_nops = 1, entry_nops = 2)]
-pub fn fun1() {}
-
-// If we override an attribute to 0 or unset, the attribute should go away
-#[no_mangle]
-#[patchable_function_entry(entry_nops = 0)]
-pub fn fun2() {}
-
-// The attribute should override the compile flags
-#[no_mangle]
-#[patchable_function_entry(prefix_nops = 20, entry_nops = 1)]
-pub fn fun3() {}
-
-// The attribute should override the compile flags
-#[no_mangle]
-#[patchable_function_entry(prefix_nops = 2, entry_nops = 19)]
-pub fn fun4() {}
-
-// The attribute should override patchable-function-entry to 3
-// and patchable-function-prefix to the default of 0, clearing it entirely
-#[no_mangle]
-#[patchable_function_entry(entry_nops = 3)]
-pub fn fun5() {}
-
-// The attribute should override patchable-function-prefix to 4
-// and patchable-function-entry to the default of 0, clearing it entirely
-#[no_mangle]
-#[patchable_function_entry(prefix_nops = 4)]
-pub fn fun6() {}
-
-// CHECK: @fun0() unnamed_addr #0
-// CHECK: @fun1() unnamed_addr #1
-// CHECK: @fun2() unnamed_addr #2
-// CHECK: @fun3() unnamed_addr #3
-// CHECK: @fun4() unnamed_addr #4
-// CHECK: @fun5() unnamed_addr #5
-// CHECK: @fun6() unnamed_addr #6
-
-// CHECK: attributes #0 = { {{.*}}"patchable-function-entry"="15" {{.*}} }
-// CHECK-NOT: attributes #0 = { {{.*}}patchable-function-prefix{{.*}} }
-
-// CHECK: attributes #1 = { {{.*}}"patchable-function-entry"="2"{{.*}}"patchable-function-prefix"="1" {{.*}} }
-
-// CHECK-NOT: attributes #2 = { {{.*}}patchable-function-entry{{.*}} }
-// CHECK-NOT: attributes #2 = { {{.*}}patchable-function-prefix{{.*}} }
-// CHECK: attributes #2 = { {{.*}} }
-
-// CHECK: attributes #3 = { {{.*}}"patchable-function-entry"="1"{{.*}}"patchable-function-prefix"="20" {{.*}} }
-// CHECK: attributes #4 = { {{.*}}"patchable-function-entry"="19"{{.*}}"patchable-function-prefix"="2" {{.*}} }
-
-// CHECK: attributes #5 = { {{.*}}"patchable-function-entry"="3"{{.*}} }
-// CHECK-NOT: attributes #5 = { {{.*}}patchable-function-prefix{{.*}} }
-
-// CHECK: attributes #6 = { {{.*}}"patchable-function-prefix"="4"{{.*}} }
-// CHECK-NOT: attributes #6 = { {{.*}}patchable-function-entry{{.*}} }
diff --git a/tests/codegen/pattern_type_symbols.rs b/tests/codegen/pattern_type_symbols.rs
deleted file mode 100644
index e86a9ef27de..00000000000
--- a/tests/codegen/pattern_type_symbols.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//! Check that symbol names with pattern types in them are
-//! different from the same symbol with the base type
-
-//@ compile-flags: -Csymbol-mangling-version=v0 -Copt-level=0 --crate-type=lib
-
-#![feature(pattern_types)]
-#![feature(pattern_type_macro)]
-
-use std::pat::pattern_type;
-
-type NanoU32 = crate::pattern_type!(u32 is 0..=999_999_999);
-
-fn foo<T>() {}
-
-pub fn bar() {
-    // CHECK: call pattern_type_symbols::foo::<u32>
-    // CHECK: call void @_RINvC[[CRATE_IDENT:[a-zA-Z0-9]{12}]]_20pattern_type_symbols3foomEB2_
-    foo::<u32>();
-    // CHECK: call pattern_type_symbols::foo::<(u32, [(); 0], [(); 999999999])>
-    // CHECK: call void @_RINvC[[CRATE_IDENT]]_20pattern_type_symbols3fooTmAum0_Aum3b9ac9ff_EEB2_
-    foo::<NanoU32>();
-}
diff --git a/tests/codegen/personality_lifetimes.rs b/tests/codegen/personality_lifetimes.rs
deleted file mode 100644
index cd81db63953..00000000000
--- a/tests/codegen/personality_lifetimes.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ ignore-msvc
-//@ needs-unwind
-
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-struct S;
-
-impl Drop for S {
-    #[inline(never)]
-    fn drop(&mut self) {}
-}
-
-#[inline(never)]
-fn might_unwind() {}
-
-// CHECK-LABEL: @test
-#[no_mangle]
-pub fn test() {
-    let _s = S;
-    // Check that the personality slot alloca gets a lifetime start in each cleanup block, not just
-    // in the first one.
-    // CHECK: [[SLOT:%[0-9]+]] = alloca [{{[0-9]+}} x i8]
-    // CHECK-LABEL: cleanup:
-    // CHECK: call void @llvm.lifetime.start.{{.*}}({{.*}})
-    // CHECK-LABEL: cleanup1:
-    // CHECK: call void @llvm.lifetime.start.{{.*}}({{.*}})
-    might_unwind();
-    let _t = S;
-    might_unwind();
-}
diff --git a/tests/codegen/pgo-counter-bias.rs b/tests/codegen/pgo-counter-bias.rs
deleted file mode 100644
index 48e815dda04..00000000000
--- a/tests/codegen/pgo-counter-bias.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Test that __llvm_profile_counter_bias does not get internalized by lto.
-
-//@ ignore-apple -runtime-counter-relocation not honored on Mach-O
-//@ compile-flags: -Cprofile-generate -Cllvm-args=-runtime-counter-relocation -Clto=fat
-//@ compile-flags: -Zno-profiler-runtime
-//@ no-prefer-dynamic
-
-// CHECK: @__llvm_profile_counter_bias = {{.*}}global
-
-pub fn main() {}
diff --git a/tests/codegen/pgo-instrumentation.rs b/tests/codegen/pgo-instrumentation.rs
deleted file mode 100644
index a8f12ccce1c..00000000000
--- a/tests/codegen/pgo-instrumentation.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Test that `-Cprofile-generate` creates expected instrumentation artifacts in LLVM IR.
-
-//@ compile-flags: -Zno-profiler-runtime
-//@ compile-flags: -Cprofile-generate -Ccodegen-units=1
-
-// CHECK: @__llvm_profile_raw_version =
-// CHECK-DAG: @__profc_{{.*}}pgo_instrumentation{{.*}}some_function{{.*}} = {{.*}}global
-// CHECK-DAG: @__profd_{{.*}}pgo_instrumentation{{.*}}some_function{{.*}} = {{.*}}global
-// CHECK-DAG: @__profc_{{.*}}pgo_instrumentation{{.*}}some_other_function{{.*}} = {{.*}}global
-// CHECK-DAG: @__profd_{{.*}}pgo_instrumentation{{.*}}some_other_function{{.*}} = {{.*}}global
-// CHECK: @__llvm_profile_filename = {{.*}}"default_%m.profraw\00"{{.*}}
-
-#![crate_type = "lib"]
-
-#[inline(never)]
-fn some_function() {}
-
-pub fn some_other_function() {
-    some_function();
-}
diff --git a/tests/codegen/pic-relocation-model.rs b/tests/codegen/pic-relocation-model.rs
deleted file mode 100644
index a1d1678a6bd..00000000000
--- a/tests/codegen/pic-relocation-model.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ compile-flags: -C relocation-model=pic -Copt-level=0
-
-#![crate_type = "rlib"]
-
-// CHECK: define i8 @call_foreign_fn()
-#[no_mangle]
-pub fn call_foreign_fn() -> u8 {
-    unsafe { foreign_fn() }
-}
-
-// (Allow but do not require `zeroext` here, because it is not worth effort to
-// spell out which targets have it and which ones do not; see rust#97800.)
-
-// CHECK: declare{{( zeroext)?}} i8 @foreign_fn()
-extern "C" {
-    fn foreign_fn() -> u8;
-}
-
-// CHECK: !{i32 {{[78]}}, !"PIC Level", i32 2}
diff --git a/tests/codegen/pie-relocation-model.rs b/tests/codegen/pie-relocation-model.rs
deleted file mode 100644
index cb8de91ccd7..00000000000
--- a/tests/codegen/pie-relocation-model.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//@ compile-flags: -C relocation-model=pie -Copt-level=0
-//@ only-x86_64-unknown-linux-gnu
-
-#![crate_type = "rlib"]
-
-// With PIE we know local functions cannot be interpositioned, we can mark them
-// as dso_local.
-// CHECK: define dso_local i8 @call_foreign_fn()
-#[no_mangle]
-pub fn call_foreign_fn() -> u8 {
-    unsafe { foreign_fn() }
-}
-
-// External functions are still marked as non-dso_local, since we don't know if the symbol
-// is defined in the binary or in the shared library.
-// CHECK: declare i8 @foreign_fn()
-extern "C" {
-    fn foreign_fn() -> u8;
-}
-
-// CHECK: !{i32 {{[78]}}, !"PIC Level", i32 2}
-// CHECK: !{i32 7, !"PIE Level", i32 2}
diff --git a/tests/codegen/placement-new.rs b/tests/codegen/placement-new.rs
deleted file mode 100644
index 7f7f0033bec..00000000000
--- a/tests/codegen/placement-new.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ compile-flags: -Zmerge-functions=disabled
-#![crate_type = "lib"]
-
-// Test to check that types with "complex" destructors, but trivial `Default` impls
-// are constructed directly into the allocation in `Box::default` and `Arc::default`.
-
-use std::rc::Rc;
-use std::sync::Arc;
-
-// CHECK-LABEL: @box_default_inplace
-#[no_mangle]
-pub fn box_default_inplace() -> Box<(String, String)> {
-    // CHECK-NOT: alloca
-    // CHECK: [[BOX:%.*]] = {{.*}}call {{.*}}__rust_alloc(
-    // CHECK-NOT: call void @llvm.memcpy
-    // CHECK: ret ptr [[BOX]]
-    Box::default()
-}
-
-// CHECK-LABEL: @rc_default_inplace
-#[no_mangle]
-pub fn rc_default_inplace() -> Rc<(String, String)> {
-    // CHECK-NOT: alloca
-    // CHECK: [[RC:%.*]] = {{.*}}call {{.*}}__rust_alloc(
-    // CHECK-NOT: call void @llvm.memcpy
-    // CHECK: ret ptr [[RC]]
-    Rc::default()
-}
-
-// CHECK-LABEL: @arc_default_inplace
-#[no_mangle]
-pub fn arc_default_inplace() -> Arc<(String, String)> {
-    // CHECK-NOT: alloca
-    // CHECK: [[ARC:%.*]] = {{.*}}call {{.*}}__rust_alloc(
-    // CHECK-NOT: call void @llvm.memcpy
-    // CHECK: ret ptr [[ARC]]
-    Arc::default()
-}
diff --git a/tests/codegen/powerpc64le-struct-align-128.rs b/tests/codegen/powerpc64le-struct-align-128.rs
deleted file mode 100644
index c1c1ac26485..00000000000
--- a/tests/codegen/powerpc64le-struct-align-128.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-// Test that structs aligned to 128 bits are passed with the correct ABI on powerpc64le.
-// This is similar to aarch64-struct-align-128.rs, but for ppc.
-
-//@ add-core-stubs
-//@ compile-flags: --target powerpc64le-unknown-linux-gnu
-//@ needs-llvm-components: powerpc
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C)]
-pub struct Align8 {
-    pub a: u64,
-    pub b: u64,
-}
-
-#[repr(transparent)]
-pub struct Transparent8 {
-    a: Align8,
-}
-
-#[repr(C)]
-pub struct Wrapped8 {
-    a: Align8,
-}
-
-extern "C" {
-    // CHECK: declare void @test_8([2 x i64], [2 x i64], [2 x i64])
-    fn test_8(a: Align8, b: Transparent8, c: Wrapped8);
-}
-
-#[repr(C)]
-#[repr(align(16))]
-pub struct Align16 {
-    pub a: u64,
-    pub b: u64,
-}
-
-#[repr(transparent)]
-pub struct Transparent16 {
-    a: Align16,
-}
-
-#[repr(C)]
-pub struct Wrapped16 {
-    pub a: Align16,
-}
-
-extern "C" {
-    // It's important that this produces [1 x i128]  rather than just i128!
-    // CHECK: declare void @test_16([1 x i128], [1 x i128], [1 x i128])
-    fn test_16(a: Align16, b: Transparent16, c: Wrapped16);
-}
-
-#[repr(C)]
-#[repr(align(32))]
-pub struct Align32 {
-    pub a: u64,
-    pub b: u64,
-    pub c: u64,
-}
-
-#[repr(transparent)]
-pub struct Transparent32 {
-    a: Align32,
-}
-
-#[repr(C)]
-pub struct Wrapped32 {
-    pub a: Align32,
-}
-
-extern "C" {
-    // CHECK: declare void @test_32([2 x i128], [2 x i128], [2 x i128])
-    fn test_32(a: Align32, b: Transparent32, c: Wrapped32);
-}
-
-pub unsafe fn main(
-    a1: Align8,
-    a2: Transparent8,
-    a3: Wrapped8,
-    b1: Align16,
-    b2: Transparent16,
-    b3: Wrapped16,
-    c1: Align32,
-    c2: Transparent32,
-    c3: Wrapped32,
-) {
-    test_8(a1, a2, a3);
-    test_16(b1, b2, b3);
-    test_32(c1, c2, c3);
-}
diff --git a/tests/codegen/precondition-checks.rs b/tests/codegen/precondition-checks.rs
deleted file mode 100644
index 16812ca1720..00000000000
--- a/tests/codegen/precondition-checks.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ compile-flags: -Cno-prepopulate-passes -Copt-level=0 -Cdebug-assertions=no
-
-// This test ensures that in a debug build which turns off debug assertions, we do not monomorphize
-// any of the standard library's unsafe precondition checks.
-// The naive codegen of those checks contains the actual check underneath an `if false`, which
-// could be optimized out if optimizations are enabled. But if we rely on optimizations to remove
-// panic branches, then we can't link compiler_builtins without optimizing it, which means that
-// -Zbuild-std doesn't work with -Copt-level=0.
-//
-// In other words, this tests for a mandatory optimization.
-
-#![crate_type = "lib"]
-
-use std::ptr::NonNull;
-
-// CHECK-LABEL: ; core::ptr::non_null::NonNull<T>::new_unchecked
-// CHECK-NOT: call
-// CHECK: }
-
-// CHECK-LABEL: @nonnull_new
-#[no_mangle]
-pub unsafe fn nonnull_new(ptr: *mut u8) -> NonNull<u8> {
-    // CHECK: ; call core::ptr::non_null::NonNull<T>::new_unchecked
-    unsafe { NonNull::new_unchecked(ptr) }
-}
diff --git a/tests/codegen/ptr-arithmetic.rs b/tests/codegen/ptr-arithmetic.rs
deleted file mode 100644
index fc4441ef448..00000000000
--- a/tests/codegen/ptr-arithmetic.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: ptr @i32_add(
-// 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: ret ptr %[[TEMP]]
-    p.add(n)
-}
-
-// Ensure we tell LLVM that the negation in `sub` can't overflow.
-
-// CHECK-LABEL: ptr @i32_sub(
-// CHECK-SAME: [[WORD:i[0-9]+]] noundef %n)
-#[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: ret ptr %[[TEMP]]
-    p.sub(n)
-}
-
-// CHECK-LABEL: ptr @i32_offset(
-// 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: ret ptr %[[TEMP]]
-    p.offset(d)
-}
diff --git a/tests/codegen/ptr-read-metadata.rs b/tests/codegen/ptr-read-metadata.rs
deleted file mode 100644
index b38cfdbff88..00000000000
--- a/tests/codegen/ptr-read-metadata.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-
-#![crate_type = "lib"]
-
-// Ensure that various forms of reading pointers correctly annotate the `load`s
-// with `!noundef` and `!range` metadata to enable extra optimization.
-
-use std::mem::MaybeUninit;
-
-// CHECK-LABEL: define {{(dso_local )?}}noundef i8 @copy_byte(
-#[no_mangle]
-pub unsafe fn copy_byte(p: *const u8) -> u8 {
-    // CHECK-NOT: load
-    // CHECK: load i8, ptr %p, align 1
-    // CHECK-SAME: !noundef !
-    // CHECK-NOT: load
-    *p
-}
-
-// CHECK-LABEL: define {{(dso_local )?}}noundef i8 @read_byte(
-#[no_mangle]
-pub unsafe fn read_byte(p: *const u8) -> u8 {
-    // CHECK-NOT: load
-    // CHECK: load i8, ptr %p, align 1
-    // CHECK-SAME: !noundef !
-    // CHECK-NOT: load
-    p.read()
-}
-
-// CHECK-LABEL: define {{(dso_local )?}}i8 @read_byte_maybe_uninit(
-#[no_mangle]
-pub unsafe fn read_byte_maybe_uninit(p: *const MaybeUninit<u8>) -> MaybeUninit<u8> {
-    // CHECK-NOT: load
-    // CHECK: load i8, ptr %p, align 1
-    // CHECK-NOT: noundef
-    // CHECK-NOT: load
-    p.read()
-}
-
-// CHECK-LABEL: define {{(dso_local )?}}noundef i8 @read_byte_assume_init(
-#[no_mangle]
-pub unsafe fn read_byte_assume_init(p: &MaybeUninit<u8>) -> u8 {
-    // CHECK-NOT: load
-    // CHECK: load i8, ptr %p, align 1
-    // CHECK-SAME: !noundef !
-    // CHECK-NOT: load
-    p.assume_init_read()
-}
-
-// CHECK-LABEL: define {{(dso_local )?}}noundef {{(range\(.*\) )?}}i32 @copy_char(
-#[no_mangle]
-pub unsafe fn copy_char(p: *const char) -> char {
-    // CHECK-NOT: load
-    // CHECK: load i32, ptr %p
-    // CHECK-SAME: !range ![[RANGE:[0-9]+]]
-    // CHECK-SAME: !noundef !
-    // CHECK-NOT: load
-    *p
-}
-
-// CHECK-LABEL: define {{(dso_local )?}}noundef {{(range\(.*\) )?}}i32 @read_char(
-#[no_mangle]
-pub unsafe fn read_char(p: *const char) -> char {
-    // CHECK-NOT: load
-    // CHECK: load i32, ptr %p
-    // CHECK-SAME: !range ![[RANGE]]
-    // CHECK-SAME: !noundef !
-    // CHECK-NOT: load
-    p.read()
-}
-
-// CHECK-LABEL: define {{(dso_local )?}}i32 @read_char_maybe_uninit(
-#[no_mangle]
-pub unsafe fn read_char_maybe_uninit(p: *const MaybeUninit<char>) -> MaybeUninit<char> {
-    // CHECK-NOT: load
-    // CHECK: load i32, ptr %p
-    // CHECK-NOT: range
-    // CHECK-NOT: noundef
-    // CHECK-NOT: load
-    p.read()
-}
-
-// CHECK-LABEL: define {{(dso_local )?}}noundef {{(range\(.*\) )?}}i32 @read_char_assume_init(
-#[no_mangle]
-pub unsafe fn read_char_assume_init(p: &MaybeUninit<char>) -> char {
-    // CHECK-NOT: load
-    // CHECK: load i32, ptr %p
-    // CHECK-SAME: !range ![[RANGE]]
-    // CHECK-SAME: !noundef !
-    // CHECK-NOT: load
-    p.assume_init_read()
-}
-
-// CHECK: ![[RANGE]] = !{i32 0, i32 1114112}
diff --git a/tests/codegen/range-attribute.rs b/tests/codegen/range-attribute.rs
deleted file mode 100644
index b81ff9ab3e2..00000000000
--- a/tests/codegen/range-attribute.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Checks that range metadata gets emitted on functions result and arguments
-// with scalar value.
-
-// 32-bit systems will return 128bit values using a return area pointer.
-//@ revisions: bit32 bit64
-//@[bit32] only-32bit
-//@[bit64] only-64bit
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-use std::num::NonZero;
-
-// Hack to get the correct size for usize
-// CHECK: @helper([[USIZE:i[0-9]+]] noundef %_1)
-#[no_mangle]
-pub fn helper(_: usize) {}
-
-// bit32: void @nonzero_int({{.*}} sret([16 x i8]) {{.*}}, i128 noundef range(i128 1, 0) %x)
-// bit64: noundef range(i128 1, 0) i128 @nonzero_int(i128 noundef range(i128 1, 0) %x)
-#[no_mangle]
-pub fn nonzero_int(x: NonZero<u128>) -> NonZero<u128> {
-    x
-}
-
-// CHECK: noundef range(i8 0, 3) i8 @optional_bool(i8{{.*}} range(i8 0, 3) %x)
-#[no_mangle]
-pub fn optional_bool(x: Option<bool>) -> Option<bool> {
-    x
-}
-
-pub enum Enum0 {
-    A(bool),
-    B,
-    C,
-}
-
-// CHECK: noundef range(i8 0, 4) i8 @enum0_value(i8{{.*}} range(i8 0, 4) %x)
-#[no_mangle]
-pub fn enum0_value(x: Enum0) -> Enum0 {
-    x
-}
-
-pub enum Enum1 {
-    A(u64),
-    B(u64),
-    C(u64),
-}
-
-// bit32: void @enum1_value({{.*}} sret({{[^,]*}}) {{[^,]*}}, [[ENUM1_TYP:i[0-9]+]]
-// bit64: { [[ENUM1_TYP:i[0-9]+]], i64 } @enum1_value([[ENUM1_TYP]]
-// CHECK-SAME: noundef range([[ENUM1_TYP]] 0, 3) %x.0, i64 noundef %x.1)
-#[no_mangle]
-pub fn enum1_value(x: Enum1) -> Enum1 {
-    x
-}
-
-pub enum Enum2 {
-    A(Enum0),
-    B(Enum0),
-    C(Enum0),
-}
-
-// CHECK: { i8, i8 } @enum2_value(i8 noundef range(i8 0, 3) %x.0, i8 noundef %x.1)
-#[no_mangle]
-pub fn enum2_value(x: Enum2) -> Enum2 {
-    x
-}
-
-// CHECK: noundef [[USIZE]] @takes_slice(ptr noalias noundef nonnull readonly align 4 %x.0, [[USIZE]] noundef %x.1)
-#[no_mangle]
-pub fn takes_slice(x: &[i32]) -> usize {
-    x.len()
-}
diff --git a/tests/codegen/range-loop.rs b/tests/codegen/range-loop.rs
deleted file mode 100644
index b131beb40dd..00000000000
--- a/tests/codegen/range-loop.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-//@ ignore-std-debug-assertions
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-// Ensure that MIR optimizations have cleaned things up enough that the IR we
-// emit is good even without running the LLVM optimizations.
-
-// CHECK-NOT: define
-
-// CHECK-LABEL: define{{.+}}void @call_for_zero_to_n
-#[no_mangle]
-pub fn call_for_zero_to_n(n: u32, f: fn(u32)) {
-    // CHECK: start:
-    // CHECK-NOT: alloca
-    // CHECK: %[[IND:.+]] = alloca [4 x i8]
-    // CHECK-NEXT: %[[ALWAYS_SOME_OPTION:.+]] = alloca
-    // CHECK-NOT: alloca
-    // CHECK: store i32 0, ptr %[[IND]],
-    // CHECK: br label %[[HEAD:.+]]
-
-    // CHECK: [[HEAD]]:
-    // CHECK: %[[T1:.+]] = load i32, ptr %[[IND]],
-    // CHECK: %[[NOT_DONE:.+]] = icmp ult i32 %[[T1]], %n
-    // CHECK: br i1 %[[NOT_DONE]], label %[[BODY:.+]], label %[[BREAK:.+]]
-
-    // CHECK: [[BREAK]]:
-    // CHECK: ret void
-
-    // CHECK: [[BODY]]:
-    // CHECK: %[[T2:.+]] = load i32, ptr %[[IND]],
-    // CHECK: %[[T3:.+]] = add nuw i32 %[[T2]], 1
-    // CHECK: store i32 %[[T3]], ptr %[[IND]],
-
-    // CHECK: store i32 %[[T2]]
-    // CHECK: %[[T4:.+]] = load i32
-    // CHECK: call void %f(i32{{.+}}%[[T4]])
-
-    for i in 0..n {
-        f(i);
-    }
-}
-
-// CHECK-NOT: define
diff --git a/tests/codegen/range_to_inclusive.rs b/tests/codegen/range_to_inclusive.rs
deleted file mode 100644
index 6d939f40f55..00000000000
--- a/tests/codegen/range_to_inclusive.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//! Test that `RangeTo` and `RangeToInclusive` generate identical
-//! (and optimal) code; #63646
-//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-#![crate_type = "lib"]
-
-#[no_mangle]
-// CHECK-LABEL: range_to(
-pub fn range_to(a: i32, mut b: i32) -> i32 {
-    // CHECK: %1 = and i32 %0, %a
-    // CHECK-NEXT: ret i32 %1
-    for _ in 0..65 {
-        b &= a;
-    }
-
-    b
-}
-
-#[no_mangle]
-// CHECK-LABEL: range_to_inclusive(
-pub fn range_to_inclusive(a: i32, mut b: i32) -> i32 {
-    // CHECK: %1 = and i32 %0, %a
-    // CHECK-NEXT: ret i32 %1
-    for _ in 0..=64 {
-        b &= a;
-    }
-
-    b
-}
diff --git a/tests/codegen/refs.rs b/tests/codegen/refs.rs
deleted file mode 100644
index 97c36295085..00000000000
--- a/tests/codegen/refs.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Zmir-opt-level=0 -Copt-level=0
-
-#![crate_type = "lib"]
-
-// Hack to get the correct size for the length part in slices
-// CHECK: @helper([[USIZE:i[0-9]+]] %_1)
-#[no_mangle]
-pub fn helper(_: usize) {}
-
-// CHECK-LABEL: @ref_dst
-#[no_mangle]
-pub fn ref_dst(s: &[u8]) {
-    // We used to generate an extra alloca and memcpy to ref the dst, so check that we copy
-    // directly to the alloca for "x"
-    // CHECK: store ptr %s.0, {{.*}} %x
-    // CHECK: [[X1:%[0-9]+]] = getelementptr inbounds i8, {{.*}} %x, {{i32 4|i64 8}}
-    // CHECK: store [[USIZE]] %s.1, {{.*}} [[X1]]
-
-    let x = &*s;
-    &x; // keep variable in an alloca
-}
diff --git a/tests/codegen/reg-struct-return.rs b/tests/codegen/reg-struct-return.rs
deleted file mode 100644
index dfc9f8c519c..00000000000
--- a/tests/codegen/reg-struct-return.rs
+++ /dev/null
@@ -1,206 +0,0 @@
-// Checks how `reg-struct-return` flag works with different calling conventions:
-// Return struct with 8/16/32/64 bit size will be converted into i8/i16/i32/i64
-// (like abi_return_struct_as_int target spec).
-// x86 only.
-
-//@ revisions: ENABLED DISABLED
-//@ add-core-stubs
-//@ compile-flags: --target i686-unknown-linux-gnu -Cno-prepopulate-passes -Copt-level=3
-//@ [ENABLED] compile-flags: -Zreg-struct-return
-//@ needs-llvm-components: x86
-
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-#![feature(no_core, lang_items)]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C)]
-pub struct Foo {
-    x: u32,
-    y: u32,
-}
-
-#[repr(C)]
-pub struct Foo1 {
-    x: u32,
-}
-
-#[repr(C)]
-pub struct Foo2 {
-    x: bool,
-    y: bool,
-    z: i16,
-}
-
-#[repr(C)]
-pub struct Foo3 {
-    x: i16,
-    y: bool,
-    z: bool,
-}
-
-#[repr(C)]
-pub struct Foo4 {
-    x: char,
-    y: bool,
-    z: u8,
-}
-
-#[repr(C)]
-pub struct Foo5 {
-    x: u32,
-    y: u16,
-    z: u8,
-    a: bool,
-}
-
-#[repr(C)]
-pub struct FooOversize1 {
-    x: u32,
-    y: u32,
-    z: u32,
-}
-
-#[repr(C)]
-pub struct FooOversize2 {
-    f0: u16,
-    f1: u16,
-    f2: u16,
-    f3: u16,
-    f4: u16,
-}
-
-#[repr(C)]
-pub struct FooFloat1 {
-    x: f32,
-    y: f32,
-}
-
-#[repr(C)]
-pub struct FooFloat2 {
-    x: f64,
-}
-
-#[repr(C)]
-pub struct FooFloat3 {
-    x: f32,
-}
-
-pub mod tests {
-    use {
-        Foo, Foo1, Foo2, Foo3, Foo4, Foo5, FooFloat1, FooFloat2, FooFloat3, FooOversize1,
-        FooOversize2,
-    };
-
-    // ENABLED: i64 @f1()
-    // DISABLED: void @f1(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "fastcall" fn f1() -> Foo {
-        Foo { x: 1, y: 2 }
-    }
-
-    // CHECK: { i32, i32 } @f2()
-    #[no_mangle]
-    pub extern "Rust" fn f2() -> Foo {
-        Foo { x: 1, y: 2 }
-    }
-
-    // ENABLED: i64 @f3()
-    // DISABLED: void @f3(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "C" fn f3() -> Foo {
-        Foo { x: 1, y: 2 }
-    }
-
-    // ENABLED: i64 @f4()
-    // DISABLED: void @f4(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "cdecl" fn f4() -> Foo {
-        Foo { x: 1, y: 2 }
-    }
-
-    // ENABLED: i64 @f5()
-    // DISABLED: void @f5(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "stdcall" fn f5() -> Foo {
-        Foo { x: 1, y: 2 }
-    }
-
-    // ENABLED: i64 @f6()
-    // DISABLED: void @f6(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "thiscall" fn f6() -> Foo {
-        Foo { x: 1, y: 2 }
-    }
-
-    // ENABLED: i32 @f7()
-    // DISABLED: void @f7(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "C" fn f7() -> Foo1 {
-        Foo1 { x: 1 }
-    }
-
-    // ENABLED: i32 @f8()
-    // DISABLED: void @f8(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "C" fn f8() -> Foo2 {
-        Foo2 { x: true, y: false, z: 5 }
-    }
-
-    // ENABLED: i32 @f9()
-    // DISABLED: void @f9(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "C" fn f9() -> Foo3 {
-        Foo3 { x: 5, y: false, z: true }
-    }
-
-    // ENABLED: i64 @f10()
-    // DISABLED: void @f10(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "C" fn f10() -> Foo4 {
-        Foo4 { x: 'x', y: true, z: 170 }
-    }
-
-    // ENABLED: i64 @f11()
-    // DISABLED: void @f11(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "C" fn f11() -> Foo5 {
-        Foo5 { x: 1, y: 2, z: 3, a: true }
-    }
-
-    // CHECK: void @f12(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "C" fn f12() -> FooOversize1 {
-        FooOversize1 { x: 1, y: 2, z: 3 }
-    }
-
-    // CHECK: void @f13(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "C" fn f13() -> FooOversize2 {
-        FooOversize2 { f0: 1, f1: 2, f2: 3, f3: 4, f4: 5 }
-    }
-
-    // ENABLED: i64 @f14()
-    // DISABLED: void @f14(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "C" fn f14() -> FooFloat1 {
-        FooFloat1 { x: 1.0, y: 1.0 }
-    }
-
-    // ENABLED: double @f15()
-    // DISABLED: void @f15(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "C" fn f15() -> FooFloat2 {
-        FooFloat2 { x: 1.0 }
-    }
-
-    // ENABLED: float @f16()
-    // DISABLED: void @f16(ptr {{.*}}sret
-    #[no_mangle]
-    pub extern "C" fn f16() -> FooFloat3 {
-        FooFloat3 { x: 1.0 }
-    }
-}
diff --git a/tests/codegen/regparm-inreg.rs b/tests/codegen/regparm-inreg.rs
deleted file mode 100644
index 15702804dfd..00000000000
--- a/tests/codegen/regparm-inreg.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-// Checks how `regparm` flag works with different calling conventions:
-// marks function arguments as "inreg" like the C/C++ compilers for the platforms.
-// x86 only.
-
-//@ add-core-stubs
-//@ compile-flags: --target i686-unknown-linux-gnu -Cno-prepopulate-passes -Copt-level=3 -Ctarget-feature=+avx
-//@ needs-llvm-components: x86
-
-//@ revisions:regparm0 regparm1 regparm2 regparm3
-//@[regparm0] compile-flags: -Zregparm=0
-//@[regparm1] compile-flags: -Zregparm=1
-//@[regparm2] compile-flags: -Zregparm=2
-//@[regparm3] compile-flags: -Zregparm=3
-
-#![crate_type = "lib"]
-#![no_core]
-#![feature(no_core, lang_items, repr_simd)]
-
-extern crate minicore;
-use minicore::*;
-
-pub mod tests {
-    // regparm doesn't work for "fastcall" calling conv (only 2 inregs)
-    // CHECK: @f1(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
-    #[no_mangle]
-    pub extern "fastcall" fn f1(_: i32, _: i32, _: i32) {}
-
-    // regparm0: @f3(i32 noundef %_1, i32 noundef %_2, i32 noundef %_3)
-    // regparm1: @f3(i32 inreg noundef %_1, i32 noundef %_2, i32 noundef %_3)
-    // regparm2: @f3(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
-    // regparm3: @f3(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3)
-    #[no_mangle]
-    pub extern "C" fn f3(_: i32, _: i32, _: i32) {}
-
-    // regparm0: @f4(i32 noundef %_1, i32 noundef %_2, i32 noundef %_3)
-    // regparm1: @f4(i32 inreg noundef %_1, i32 noundef %_2, i32 noundef %_3)
-    // regparm2: @f4(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
-    // regparm3: @f4(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3)
-    #[no_mangle]
-    pub extern "cdecl" fn f4(_: i32, _: i32, _: i32) {}
-
-    // regparm0: @f5(i32 noundef %_1, i32 noundef %_2, i32 noundef %_3)
-    // regparm1: @f5(i32 inreg noundef %_1, i32 noundef %_2, i32 noundef %_3)
-    // regparm2: @f5(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
-    // regparm3: @f5(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3)
-    #[no_mangle]
-    pub extern "stdcall" fn f5(_: i32, _: i32, _: i32) {}
-
-    // regparm doesn't work for thiscall
-    // CHECK: @f6(i32 noundef %_1, i32 noundef %_2, i32 noundef %_3)
-    #[no_mangle]
-    pub extern "thiscall" fn f6(_: i32, _: i32, _: i32) {}
-
-    struct S1 {
-        x1: i32,
-    }
-    // regparm0: @f7(i32 noundef %_1, i32 noundef %_2, i32 noundef %_3, i32 noundef %_4)
-    // regparm1: @f7(i32 inreg noundef %_1, i32 noundef %_2, i32 noundef %_3, i32 noundef %_4)
-    // regparm2: @f7(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3, i32 noundef %_4)
-    // regparm3: @f7(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3,
-    // regparm3-SAME: i32 noundef %_4)
-    #[no_mangle]
-    pub extern "C" fn f7(_: i32, _: i32, _: S1, _: i32) {}
-
-    #[repr(C)]
-    struct S2 {
-        x1: i32,
-        x2: i32,
-    }
-    // regparm0: @f8(i32 noundef %_1, i32 noundef %_2, ptr {{.*}} %_3, i32 noundef %_4)
-    // regparm1: @f8(i32 inreg noundef %_1, i32 noundef %_2, ptr {{.*}} %_3, i32 noundef %_4)
-    // regparm2: @f8(i32 inreg noundef %_1, i32 inreg noundef %_2, ptr {{.*}} %_3, i32 noundef %_4)
-    // regparm3: @f8(i32 inreg noundef %_1, i32 inreg noundef %_2, ptr {{.*}} %_3,
-    // regparm3-SAME: i32 inreg noundef %_4)
-    #[no_mangle]
-    pub extern "C" fn f8(_: i32, _: i32, _: S2, _: i32) {}
-
-    // regparm0: @f9(i1 noundef zeroext %_1, i16 noundef signext %_2, i64 noundef %_3,
-    // regparm0-SAME: i128 noundef %_4)
-    // regparm1: @f9(i1 inreg noundef zeroext %_1, i16 noundef signext %_2, i64 noundef %_3,
-    // regparm1-SAME: i128 noundef %_4)
-    // regparm2: @f9(i1 inreg noundef zeroext %_1, i16 inreg noundef signext %_2, i64 noundef %_3,
-    // regparm2-SAME: i128 noundef %_4)
-    // regparm3: @f9(i1 inreg noundef zeroext %_1, i16 inreg noundef signext %_2, i64 noundef %_3,
-    // regparm3-SAME: i128 noundef %_4)
-    #[no_mangle]
-    pub extern "C" fn f9(_: bool, _: i16, _: i64, _: u128) {}
-
-    // regparm0: @f10(float noundef %_1, double noundef %_2, i1 noundef zeroext %_3,
-    // regparm0-SAME: i16 noundef signext %_4)
-    // regparm1: @f10(float noundef %_1, double noundef %_2, i1 inreg noundef zeroext %_3,
-    // regparm1-SAME: i16 noundef signext %_4)
-    // regparm2: @f10(float noundef %_1, double noundef %_2, i1 inreg noundef zeroext %_3,
-    // regparm2-SAME: i16 inreg noundef signext %_4)
-    // regparm3: @f10(float noundef %_1, double noundef %_2, i1 inreg noundef zeroext %_3,
-    // regparm3-SAME: i16 inreg noundef signext %_4)
-    #[no_mangle]
-    pub extern "C" fn f10(_: f32, _: f64, _: bool, _: i16) {}
-
-    #[allow(non_camel_case_types)]
-    #[repr(simd)]
-    pub struct __m128([f32; 4]);
-
-    // regparm0: @f11(i32 noundef %_1, <4 x float> %_2, i32 noundef %_3, i32 noundef %_4)
-    // regparm1: @f11(i32 inreg noundef %_1, <4 x float> %_2, i32 noundef %_3, i32 noundef %_4)
-    // regparm2: @f11(i32 inreg noundef %_1, <4 x float> %_2, i32 inreg noundef %_3,
-    // regparm2-SAME: i32 noundef %_4)
-    // regparm3: @f11(i32 inreg noundef %_1, <4 x float> %_2, i32 inreg noundef %_3,
-    // regparm3-SAME: i32 inreg noundef %_4)
-    #[no_mangle]
-    pub extern "C" fn f11(_: i32, _: __m128, _: i32, _: i32) {}
-
-    #[allow(non_camel_case_types)]
-    #[repr(simd)]
-    pub struct __m256([f32; 8]);
-
-    // regparm0: @f12(i32 noundef %_1, <8 x float> %_2, i32 noundef %_3, i32 noundef %_4)
-    // regparm1: @f12(i32 inreg noundef %_1, <8 x float> %_2, i32 noundef %_3, i32 noundef %_4)
-    // regparm2: @f12(i32 inreg noundef %_1, <8 x float> %_2, i32 inreg noundef %_3,
-    // regparm2-SAME: i32 noundef %_4)
-    // regparm3: @f12(i32 inreg noundef %_1, <8 x float> %_2, i32 inreg noundef %_3,
-    // regparm3-SAME: i32 inreg noundef %_4)
-    #[no_mangle]
-    pub extern "C" fn f12(_: i32, _: __m256, _: i32, _: i32) {}
-}
diff --git a/tests/codegen/remap_path_prefix/aux_mod.rs b/tests/codegen/remap_path_prefix/aux_mod.rs
deleted file mode 100644
index 3217e9e51e7..00000000000
--- a/tests/codegen/remap_path_prefix/aux_mod.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//@ ignore-auxiliary (used by `./main.rs`)
-
-#[inline]
-pub fn some_aux_mod_function() -> i32 {
-    1234
-}
diff --git a/tests/codegen/remap_path_prefix/auxiliary/remap_path_prefix_aux.rs b/tests/codegen/remap_path_prefix/auxiliary/remap_path_prefix_aux.rs
deleted file mode 100644
index 7afc16ec72f..00000000000
--- a/tests/codegen/remap_path_prefix/auxiliary/remap_path_prefix_aux.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//
-
-//@ compile-flags: -g  --remap-path-prefix={{cwd}}=/the/aux-cwd --remap-path-prefix={{src-base}}/remap_path_prefix/auxiliary=/the/aux-src
-
-#[inline]
-pub fn some_aux_function() -> i32 {
-    1234
-}
diff --git a/tests/codegen/remap_path_prefix/auxiliary/xcrate-generic.rs b/tests/codegen/remap_path_prefix/auxiliary/xcrate-generic.rs
deleted file mode 100644
index 9d5cdfe063b..00000000000
--- a/tests/codegen/remap_path_prefix/auxiliary/xcrate-generic.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//
-//@ compile-flags: -g  --remap-path-prefix={{cwd}}=/the/aux-cwd --remap-path-prefix={{src-base}}/remap_path_prefix/auxiliary=/the/aux-src
-
-#![crate_type = "lib"]
-
-pub fn foo<T: Default>() -> T {
-    T::default()
-}
diff --git a/tests/codegen/remap_path_prefix/issue-73167-remap-std.rs b/tests/codegen/remap_path_prefix/issue-73167-remap-std.rs
deleted file mode 100644
index eb610168dd3..00000000000
--- a/tests/codegen/remap_path_prefix/issue-73167-remap-std.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ ignore-windows
-
-//@ compile-flags: -g  -C no-prepopulate-passes -Z simulate-remapped-rust-src-base=/rustc/xyz
-
-// Here we check that importing std will not cause real path to std source files
-// to leak. If rustc was compiled with remap-debuginfo = true, this should be
-// true automatically. If paths to std library hasn't been remapped, we use the
-// above simulate-remapped-rust-src-base option to do it temporarily
-
-// CHECK: !DIFile(filename: "{{/rustc/.*/library/std/src/panic.rs}}"
-fn main() {
-    std::thread::spawn(|| {
-        println!("hello");
-    });
-}
diff --git a/tests/codegen/remap_path_prefix/main.rs b/tests/codegen/remap_path_prefix/main.rs
deleted file mode 100644
index 7d17b3b67cf..00000000000
--- a/tests/codegen/remap_path_prefix/main.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ ignore-windows
-//
-
-//@ compile-flags: -g  -C no-prepopulate-passes --remap-path-prefix={{cwd}}=/the/cwd --remap-path-prefix={{src-base}}=/the/src -Zinline-mir=no
-//@ aux-build:remap_path_prefix_aux.rs
-
-extern crate remap_path_prefix_aux;
-
-// Here we check that submodules and include files are found using the path without
-// remapping. This test requires that rustc is called with an absolute path.
-mod aux_mod;
-include!("aux_mod.rs");
-
-// Here we check that the expansion of the file!() macro is mapped.
-// CHECK: @alloc_5761061597a97f66e13ef2ff92712c4b = private unnamed_addr constant [34 x i8] c"/the/src/remap_path_prefix/main.rs"
-pub static FILE_PATH: &'static str = file!();
-
-fn main() {
-    remap_path_prefix_aux::some_aux_function();
-    aux_mod::some_aux_mod_function();
-    some_aux_mod_function();
-}
-
-// Here we check that local debuginfo is mapped correctly.
-// CHECK: !DIFile(filename: "/the/src/remap_path_prefix/main.rs", directory: ""
-
-// And here that debuginfo from other crates are expanded to absolute paths.
-// CHECK: !DIFile(filename: "/the/aux-src/remap_path_prefix_aux.rs", directory: ""
diff --git a/tests/codegen/remap_path_prefix/xcrate-generic.rs b/tests/codegen/remap_path_prefix/xcrate-generic.rs
deleted file mode 100644
index db69b72d904..00000000000
--- a/tests/codegen/remap_path_prefix/xcrate-generic.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ ignore-windows
-//@ compile-flags: -g -C metadata=foo -C no-prepopulate-passes
-//@ aux-build:xcrate-generic.rs
-
-#![crate_type = "lib"]
-
-extern crate xcrate_generic;
-
-pub fn foo() {
-    println!("{}", xcrate_generic::foo::<u32>());
-}
-
-// Here we check that local debuginfo is mapped correctly.
-// CHECK: !DIFile(filename: "/the/aux-src/xcrate-generic.rs", directory: ""
diff --git a/tests/codegen/repeat-operand-zero-len.rs b/tests/codegen/repeat-operand-zero-len.rs
deleted file mode 100644
index b4cec42a07c..00000000000
--- a/tests/codegen/repeat-operand-zero-len.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ compile-flags: -Copt-level=1 -Cno-prepopulate-passes
-
-// This test is here to hit the `Rvalue::Repeat` case in `codegen_rvalue_operand`.
-// It only applies when the resulting array is a ZST, so the test is written in
-// such a way as to keep MIR optimizations from seeing that fact and removing
-// the local and statement altogether. (At the time of writing, no other codegen
-// test hit that code path, nor did a stage 2 build of the compiler.)
-
-#![crate_type = "lib"]
-
-#[repr(transparent)]
-pub struct Wrapper<T, const N: usize>([T; N]);
-
-// CHECK-LABEL: define {{.+}}do_repeat{{.+}}(i32 noundef %x)
-// CHECK-NEXT: start:
-// CHECK-NOT: alloca
-// CHECK-NEXT: ret void
-#[inline(never)]
-pub fn do_repeat<T: Copy, const N: usize>(x: T) -> Wrapper<T, N> {
-    Wrapper([x; N])
-}
-
-// CHECK-LABEL: @trigger_repeat_zero_len
-#[no_mangle]
-pub fn trigger_repeat_zero_len() -> Wrapper<u32, 0> {
-    // CHECK: call void {{.+}}do_repeat{{.+}}(i32 noundef 4)
-    do_repeat(4)
-}
diff --git a/tests/codegen/repeat-operand-zst-elem.rs b/tests/codegen/repeat-operand-zst-elem.rs
deleted file mode 100644
index c3637759afa..00000000000
--- a/tests/codegen/repeat-operand-zst-elem.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//@ compile-flags: -Copt-level=1 -Cno-prepopulate-passes
-
-// This test is here to hit the `Rvalue::Repeat` case in `codegen_rvalue_operand`.
-// It only applies when the resulting array is a ZST, so the test is written in
-// such a way as to keep MIR optimizations from seeing that fact and removing
-// the local and statement altogether. (At the time of writing, no other codegen
-// test hit that code path, nor did a stage 2 build of the compiler.)
-
-#![crate_type = "lib"]
-
-#[repr(transparent)]
-pub struct Wrapper<T, const N: usize>([T; N]);
-
-// CHECK-LABEL: define {{.+}}do_repeat{{.+}}()
-// CHECK-NEXT: start:
-// CHECK-NOT: alloca
-// CHECK-NEXT: ret void
-#[inline(never)]
-pub fn do_repeat<T: Copy, const N: usize>(x: T) -> Wrapper<T, N> {
-    Wrapper([x; N])
-}
-
-// CHECK-LABEL: @trigger_repeat_zst_elem
-#[no_mangle]
-pub fn trigger_repeat_zst_elem() -> Wrapper<(), 8> {
-    // CHECK: call void {{.+}}do_repeat{{.+}}()
-    do_repeat(())
-}
diff --git a/tests/codegen/repeat-trusted-len.rs b/tests/codegen/repeat-trusted-len.rs
deleted file mode 100644
index 95379535971..00000000000
--- a/tests/codegen/repeat-trusted-len.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//
-
-#![crate_type = "lib"]
-
-use std::iter;
-
-// CHECK-LABEL: @repeat_take_collect
-#[no_mangle]
-pub fn repeat_take_collect() -> Vec<u8> {
-    // CHECK: call void @llvm.memset.{{.+}}(ptr {{.*}}align 1{{.*}} %{{.*}}, i8 42, i{{[0-9]+}} 100000, i1 false)
-    iter::repeat(42).take(100000).collect()
-}
-
-// CHECK-LABEL: @repeat_with_take_collect
-#[no_mangle]
-pub fn repeat_with_take_collect() -> Vec<u8> {
-    // CHECK: call void @llvm.memset.{{.+}}(ptr {{.*}}align 1{{.*}} %{{.*}}, i8 13, i{{[0-9]+}} 12345, i1 false)
-    iter::repeat_with(|| 13).take(12345).collect()
-}
diff --git a/tests/codegen/repr/transparent-byval-struct-ptr.rs b/tests/codegen/repr/transparent-byval-struct-ptr.rs
deleted file mode 100644
index 0918884144f..00000000000
--- a/tests/codegen/repr/transparent-byval-struct-ptr.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-//@ add-core-stubs
-//@ revisions: i686-linux i686-freebsd x64-linux x64-apple
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-//@[i686-linux] compile-flags: --target i686-unknown-linux-gnu
-//@[i686-linux] needs-llvm-components: x86
-//@[i686-freebsd] compile-flags: --target i686-unknown-freebsd
-//@[i686-freebsd] needs-llvm-components: x86
-//@[x64-linux] compile-flags: --target x86_64-unknown-linux-gnu
-//@[x64-linux] needs-llvm-components: x86
-//@[x64-apple] compile-flags: --target x86_64-apple-darwin
-//@[x64-apple] needs-llvm-components: x86
-
-// See ./transparent.rs
-// Some platforms pass large aggregates using immediate arrays in LLVMIR
-// Other platforms pass large aggregates using by-value struct pointer in LLVMIR
-// Yet more platforms pass large aggregates using opaque pointer in LLVMIR
-// This covers the "by-value struct pointer" case.
-
-#![feature(no_core, lang_items, transparent_unions)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-impl Copy for BigS {}
-impl Copy for BigU {}
-
-#[repr(C)]
-pub struct BigS([u32; 16]);
-
-#[repr(transparent)]
-pub struct TsBigS(BigS);
-
-#[repr(transparent)]
-pub union TuBigS {
-    field: BigS,
-}
-
-#[repr(transparent)]
-pub enum TeBigS {
-    Variant(BigS),
-}
-
-// CHECK: define{{.*}}void @test_BigS(ptr [[BIGS_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGS_RET_ATTRS2:.*]], ptr [[BIGS_ARG_ATTRS1:.*]] byval([64 x i8]) [[BIGS_ARG_ATTRS2:.*]])
-#[no_mangle]
-pub extern "C" fn test_BigS(_: BigS) -> BigS {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TsBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]] byval([64 x i8]) [[BIGS_ARG_ATTRS2:.*]])
-#[no_mangle]
-pub extern "C" fn test_TsBigS(_: TsBigS) -> TsBigS {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TuBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]] byval([64 x i8]) [[BIGS_ARG_ATTRS2:.*]])
-#[no_mangle]
-pub extern "C" fn test_TuBigS(_: TuBigS) -> TuBigS {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TeBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]] byval([64 x i8]) [[BIGS_ARG_ATTRS2]])
-#[no_mangle]
-pub extern "C" fn test_TeBigS(_: TeBigS) -> TeBigS {
-    loop {}
-}
-
-#[repr(C)]
-pub union BigU {
-    foo: [u32; 16],
-}
-
-#[repr(transparent)]
-pub struct TsBigU(BigU);
-
-#[repr(transparent)]
-pub union TuBigU {
-    field: BigU,
-}
-
-#[repr(transparent)]
-pub enum TeBigU {
-    Variant(BigU),
-}
-
-// CHECK: define{{.*}}void @test_BigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1:.*]] byval([64 x i8]) [[BIGU_ARG_ATTRS2:.*]])
-#[no_mangle]
-pub extern "C" fn test_BigU(_: BigU) -> BigU {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TsBigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]] byval([64 x i8]) [[BIGU_ARG_ATTRS2]])
-#[no_mangle]
-pub extern "C" fn test_TsBigU(_: TsBigU) -> TsBigU {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TuBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]] byval([64 x i8]) [[BIGU_ARG_ATTRS2]])
-#[no_mangle]
-pub extern "C" fn test_TuBigU(_: TuBigU) -> TuBigU {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TeBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]] byval([64 x i8]) [[BIGU_ARG_ATTRS2]])
-#[no_mangle]
-pub extern "C" fn test_TeBigU(_: TeBigU) -> TeBigU {
-    loop {}
-}
diff --git a/tests/codegen/repr/transparent-imm-array.rs b/tests/codegen/repr/transparent-imm-array.rs
deleted file mode 100644
index 6dad0447784..00000000000
--- a/tests/codegen/repr/transparent-imm-array.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-//@ add-core-stubs
-//@ revisions: arm-linux arm-android armv7-linux armv7-android mips thumb sparc
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-//@[arm-linux] compile-flags: --target arm-unknown-linux-gnueabi
-//@[arm-linux] needs-llvm-components: arm
-//@[arm-android] compile-flags: --target arm-linux-androideabi
-//@[arm-android] needs-llvm-components: arm
-//@[armv7-linux] compile-flags: --target armv7-unknown-linux-gnueabi
-//@[armv7-linux] needs-llvm-components: arm
-//@[armv7-android] compile-flags: --target armv7-linux-androideabi
-//@[armv7-android] needs-llvm-components: arm
-//@[mips] compile-flags: --target mips-unknown-linux-gnu
-//@[mips] needs-llvm-components: mips
-//@[thumb] compile-flags: --target thumbv7neon-linux-androideabi
-//@[thumb] needs-llvm-components: arm
-//@[sparc] compile-flags: --target sparc-unknown-linux-gnu
-//@[sparc] needs-llvm-components: sparc
-
-// See ./transparent.rs
-// Some platforms pass large aggregates using immediate arrays in LLVMIR
-// Other platforms pass large aggregates using by-value struct pointer in LLVMIR
-// Yet more platforms pass large aggregates using opaque pointer in LLVMIR
-// This covers the "immediate array" case.
-
-#![feature(no_core, lang_items, transparent_unions)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-impl Copy for BigS {}
-impl Copy for BigU {}
-
-#[repr(C)]
-pub struct BigS([u32; 16]);
-
-#[repr(transparent)]
-pub struct TsBigS(BigS);
-
-#[repr(transparent)]
-pub union TuBigS {
-    field: BigS,
-}
-
-#[repr(transparent)]
-pub enum TeBigS {
-    Variant(BigS),
-}
-
-// CHECK: define void @test_BigS(ptr [[BIGS_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGS_RET_ATTRS2:.*]], [16 x i32]
-#[no_mangle]
-pub extern "C" fn test_BigS(_: BigS) -> BigS {
-    loop {}
-}
-
-// CHECK: define void @test_TsBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [16 x i32]
-#[no_mangle]
-pub extern "C" fn test_TsBigS(_: TsBigS) -> TsBigS {
-    loop {}
-}
-
-// CHECK: define void @test_TuBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [16 x i32]
-#[no_mangle]
-pub extern "C" fn test_TuBigS(_: TuBigS) -> TuBigS {
-    loop {}
-}
-
-// CHECK: define void @test_TeBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [16 x i32]
-#[no_mangle]
-pub extern "C" fn test_TeBigS(_: TeBigS) -> TeBigS {
-    loop {}
-}
-
-#[repr(C)]
-pub union BigU {
-    foo: [u32; 16],
-}
-
-#[repr(transparent)]
-pub struct TsBigU(BigU);
-
-#[repr(transparent)]
-pub union TuBigU {
-    field: BigU,
-}
-
-#[repr(transparent)]
-pub enum TeBigU {
-    Variant(BigU),
-}
-
-// CHECK: define void @test_BigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], [16 x i32]
-#[no_mangle]
-pub extern "C" fn test_BigU(_: BigU) -> BigU {
-    loop {}
-}
-
-// CHECK: define void @test_TsBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [16 x i32]
-#[no_mangle]
-pub extern "C" fn test_TsBigU(_: TsBigU) -> TsBigU {
-    loop {}
-}
-
-// CHECK: define void @test_TuBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [16 x i32]
-#[no_mangle]
-pub extern "C" fn test_TuBigU(_: TuBigU) -> TuBigU {
-    loop {}
-}
-
-// CHECK: define void @test_TeBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [16 x i32]
-#[no_mangle]
-pub extern "C" fn test_TeBigU(_: TeBigU) -> TeBigU {
-    loop {}
-}
diff --git a/tests/codegen/repr/transparent-mips64.rs b/tests/codegen/repr/transparent-mips64.rs
deleted file mode 100644
index 98901350154..00000000000
--- a/tests/codegen/repr/transparent-mips64.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-//@ add-core-stubs
-//@ revisions: mips64 mips64el
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-//@[mips64] compile-flags: --target mips64-unknown-linux-gnuabi64
-//@[mips64] needs-llvm-components: mips
-//@[mips64el] compile-flags: --target mips64el-unknown-linux-gnuabi64
-//@[mips64el] needs-llvm-components: mips
-
-// See ./transparent.rs
-
-#![feature(no_core, lang_items, transparent_unions)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-impl Copy for BigS {}
-impl Copy for BigU {}
-
-#[repr(C)]
-pub struct BigS([u32; 16]);
-
-#[repr(transparent)]
-pub struct TsBigS(BigS);
-
-#[repr(transparent)]
-pub union TuBigS {
-    field: BigS,
-}
-
-#[repr(transparent)]
-pub enum TeBigS {
-    Variant(BigS),
-}
-
-// CHECK: define void @test_BigS(ptr [[BIGS_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGS_RET_ATTRS2:.*]], [8 x i64]
-#[no_mangle]
-pub extern "C" fn test_BigS(_: BigS) -> BigS {
-    loop {}
-}
-
-// CHECK: define void @test_TsBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [8 x i64]
-#[no_mangle]
-pub extern "C" fn test_TsBigS(_: TsBigS) -> TsBigS {
-    loop {}
-}
-
-// CHECK: define void @test_TuBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [8 x i64]
-#[no_mangle]
-pub extern "C" fn test_TuBigS(_: TuBigS) -> TuBigS {
-    loop {}
-}
-
-// CHECK: define void @test_TeBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], [8 x i64]
-#[no_mangle]
-pub extern "C" fn test_TeBigS(_: TeBigS) -> TeBigS {
-    loop {}
-}
-
-#[repr(C)]
-pub union BigU {
-    foo: [u32; 16],
-}
-
-#[repr(transparent)]
-pub struct TsBigU(BigU);
-
-#[repr(transparent)]
-pub union TuBigU {
-    field: BigU,
-}
-
-#[repr(transparent)]
-pub enum TeBigU {
-    Variant(BigU),
-}
-
-// CHECK: define void @test_BigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], [8 x i64]
-#[no_mangle]
-pub extern "C" fn test_BigU(_: BigU) -> BigU {
-    loop {}
-}
-
-// CHECK: define void @test_TsBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [8 x i64]
-#[no_mangle]
-pub extern "C" fn test_TsBigU(_: TsBigU) -> TsBigU {
-    loop {}
-}
-
-// CHECK: define void @test_TuBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [8 x i64]
-#[no_mangle]
-pub extern "C" fn test_TuBigU(_: TuBigU) -> TuBigU {
-    loop {}
-}
-
-// CHECK: define void @test_TeBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2]], [8 x i64]
-#[no_mangle]
-pub extern "C" fn test_TeBigU(_: TeBigU) -> TeBigU {
-    loop {}
-}
diff --git a/tests/codegen/repr/transparent-opaque-ptr.rs b/tests/codegen/repr/transparent-opaque-ptr.rs
deleted file mode 100644
index 7911370c478..00000000000
--- a/tests/codegen/repr/transparent-opaque-ptr.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-//@ add-core-stubs
-//@ revisions: aarch64-linux aarch64-darwin wasm32-wasip1
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-//@[aarch64-linux] compile-flags: --target aarch64-unknown-linux-gnu
-//@[aarch64-linux] needs-llvm-components: aarch64
-//@[aarch64-darwin] compile-flags: --target aarch64-apple-darwin
-//@[aarch64-darwin] needs-llvm-components: aarch64
-//@[wasm32-wasip1] compile-flags: --target wasm32-wasip1
-//@[wasm32-wasip1] needs-llvm-components: webassembly
-
-// See ./transparent.rs
-// Some platforms pass large aggregates using immediate arrays in LLVMIR
-// Other platforms pass large aggregates using by-value struct pointer in LLVMIR
-// Yet more platforms pass large aggregates using opaque pointer in LLVMIR
-// This covers the "opaque pointer" case.
-
-#![feature(no_core, lang_items, transparent_unions)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-impl Copy for BigS {}
-impl Copy for BigU {}
-
-#[repr(C)]
-pub struct BigS([u32; 16]);
-
-#[repr(transparent)]
-pub struct TsBigS(BigS);
-
-#[repr(transparent)]
-pub union TuBigS {
-    field: BigS,
-}
-
-#[repr(transparent)]
-pub enum TeBigS {
-    Variant(BigS),
-}
-
-// CHECK: define{{.*}}void @test_BigS(ptr [[BIGS_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGS_RET_ATTRS2:.*]], ptr [[BIGS_ARG_ATTRS1:.*]])
-#[no_mangle]
-pub extern "C" fn test_BigS(_: BigS) -> BigS {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TsBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]])
-#[no_mangle]
-pub extern "C" fn test_TsBigS(_: TsBigS) -> TsBigS {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TuBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]])
-#[no_mangle]
-pub extern "C" fn test_TuBigS(_: TuBigS) -> TuBigS {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TeBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr [[BIGS_ARG_ATTRS1]])
-#[no_mangle]
-pub extern "C" fn test_TeBigS(_: TeBigS) -> TeBigS {
-    loop {}
-}
-
-#[repr(C)]
-pub union BigU {
-    foo: [u32; 16],
-}
-
-#[repr(transparent)]
-pub struct TsBigU(BigU);
-
-#[repr(transparent)]
-pub union TuBigU {
-    field: BigU,
-}
-
-#[repr(transparent)]
-pub enum TeBigU {
-    Variant(BigU),
-}
-
-// CHECK: define{{.*}}void @test_BigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1:.*]])
-#[no_mangle]
-pub extern "C" fn test_BigU(_: BigU) -> BigU {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TsBigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]])
-#[no_mangle]
-pub extern "C" fn test_TsBigU(_: TsBigU) -> TsBigU {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TuBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]])
-#[no_mangle]
-pub extern "C" fn test_TuBigU(_: TuBigU) -> TuBigU {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TeBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr [[BIGU_ARG_ATTRS1]])
-#[no_mangle]
-pub extern "C" fn test_TeBigU(_: TeBigU) -> TeBigU {
-    loop {}
-}
diff --git a/tests/codegen/repr/transparent-sparc64.rs b/tests/codegen/repr/transparent-sparc64.rs
deleted file mode 100644
index 62bfc8a5fce..00000000000
--- a/tests/codegen/repr/transparent-sparc64.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target sparc64-unknown-linux-gnu
-//@ needs-llvm-components: sparc
-
-// See ./transparent.rs
-
-#![feature(no_core, lang_items, transparent_unions)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-impl Copy for BigS {}
-impl Copy for BigU {}
-
-#[repr(C)]
-pub struct BigS([u32; 16]);
-
-#[repr(transparent)]
-pub struct TsBigS(BigS);
-
-#[repr(transparent)]
-pub union TuBigS {
-    field: BigS,
-}
-
-#[repr(transparent)]
-pub enum TeBigS {
-    Variant(BigS),
-}
-
-// CHECK: define{{.*}}void @test_BigS(ptr [[BIGS_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGS_RET_ATTRS2:.*]], ptr
-// CHECK-NOT: byval
-// CHECK-SAME: %{{[0-9a-z_]+}})
-#[no_mangle]
-pub extern "C" fn test_BigS(_: BigS) -> BigS {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TsBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr
-// CHECK-NOT: byval
-// CHECK-SAME: %{{[0-9a-z_]+}})
-#[no_mangle]
-pub extern "C" fn test_TsBigS(_: TsBigS) -> TsBigS {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TuBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr
-// CHECK-NOT: byval
-// CHECK-SAME: %{{[0-9a-z_]+}})
-#[no_mangle]
-pub extern "C" fn test_TuBigS(_: TuBigS) -> TuBigS {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TeBigS(ptr [[BIGS_RET_ATTRS1]] sret([64 x i8]) [[BIGS_RET_ATTRS2]], ptr
-// CHECK-NOT: byval
-// CHECK-SAME: %{{[0-9a-z_]+}})
-#[no_mangle]
-pub extern "C" fn test_TeBigS(_: TeBigS) -> TeBigS {
-    loop {}
-}
-
-#[repr(C)]
-pub union BigU {
-    foo: [u32; 16],
-}
-
-#[repr(transparent)]
-pub struct TsBigU(BigU);
-
-#[repr(transparent)]
-pub union TuBigU {
-    field: BigU,
-}
-
-#[repr(transparent)]
-pub enum TeBigU {
-    Variant(BigU),
-}
-
-// CHECK: define{{.*}}void @test_BigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr
-// CHECK-NOT: byval
-// CHECK-SAME: %{{[0-9a-z_]+}})
-#[no_mangle]
-pub extern "C" fn test_BigU(_: BigU) -> BigU {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TsBigU(ptr [[BIGU_RET_ATTRS1:.*]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr
-// CHECK-NOT: byval
-// CHECK-SAME: %{{[0-9a-z_]+}})
-#[no_mangle]
-pub extern "C" fn test_TsBigU(_: TsBigU) -> TsBigU {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TuBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr
-// CHECK-NOT: byval
-// CHECK-SAME: %{{[0-9a-z_]+}})
-#[no_mangle]
-pub extern "C" fn test_TuBigU(_: TuBigU) -> TuBigU {
-    loop {}
-}
-
-// CHECK: define{{.*}}void @test_TeBigU(ptr [[BIGU_RET_ATTRS1]] sret([64 x i8]) [[BIGU_RET_ATTRS2:.*]], ptr
-// CHECK-NOT: byval
-// CHECK-SAME: %{{[0-9a-z_]+}})
-#[no_mangle]
-pub extern "C" fn test_TeBigU(_: TeBigU) -> TeBigU {
-    loop {}
-}
diff --git a/tests/codegen/repr/transparent-sysv64.rs b/tests/codegen/repr/transparent-sysv64.rs
deleted file mode 100644
index 3efc3f7c391..00000000000
--- a/tests/codegen/repr/transparent-sysv64.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//@ add-core-stubs
-//@ revisions: linux apple win
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-//@[linux] compile-flags: --target x86_64-unknown-linux-gnu
-//@[linux] needs-llvm-components: x86
-//@[apple] compile-flags: --target x86_64-apple-darwin
-//@[apple] needs-llvm-components: x86
-//@[win] compile-flags: --target x86_64-pc-windows-msvc
-//@[win] needs-llvm-components: x86
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C)]
-pub struct Rgb8 {
-    r: u8,
-    g: u8,
-    b: u8,
-}
-
-#[repr(transparent)]
-pub struct Rgb8Wrap(Rgb8);
-
-// CHECK: i24 @test_Rgb8Wrap(i24{{( %0)?}})
-#[no_mangle]
-pub extern "sysv64" fn test_Rgb8Wrap(_: Rgb8Wrap) -> Rgb8Wrap {
-    loop {}
-}
-
-#[repr(C)]
-pub union FloatBits {
-    float: f32,
-    bits: u32,
-}
-
-#[repr(transparent)]
-pub struct SmallUnion(FloatBits);
-
-// CHECK: i32 @test_SmallUnion(i32{{( %0)?}})
-#[no_mangle]
-pub extern "sysv64" fn test_SmallUnion(_: SmallUnion) -> SmallUnion {
-    loop {}
-}
diff --git a/tests/codegen/repr/transparent.rs b/tests/codegen/repr/transparent.rs
deleted file mode 100644
index 29b627462a4..00000000000
--- a/tests/codegen/repr/transparent.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-//@ ignore-riscv64 riscv64 has an i128 type used with test_Vector
-//@ ignore-s390x s390x with default march passes vector types per reference
-//@ ignore-loongarch64 see codegen/loongarch-abi for loongarch function call tests
-
-// This codegen test embeds assumptions about how certain "C" psABIs are handled
-// so it doesn't apply to all architectures or even all OS
-// For RISCV: see codegen/riscv-abi
-// For LoongArch: see codegen/loongarch-abi
-
-#![crate_type = "lib"]
-#![feature(repr_simd, transparent_unions, arm_target_feature, mips_target_feature)]
-
-use std::marker::PhantomData;
-
-#[derive(Copy, Clone)]
-pub struct Zst1;
-#[derive(Copy, Clone)]
-pub struct Zst2(());
-
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct F32(f32);
-
-// CHECK: define{{.*}}float @test_F32(float noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_F32(_: F32) -> F32 {
-    loop {}
-}
-
-#[repr(transparent)]
-pub struct Ptr(*mut u8);
-
-// CHECK: define{{.*}}ptr @test_Ptr(ptr noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_Ptr(_: Ptr) -> Ptr {
-    loop {}
-}
-
-#[repr(transparent)]
-pub struct WithZst(u64, Zst1);
-
-// CHECK: define{{.*}}i64 @test_WithZst(i64 noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_WithZst(_: WithZst) -> WithZst {
-    loop {}
-}
-
-#[repr(transparent)]
-pub struct WithZeroSizedArray(*const f32, [i8; 0]);
-
-// CHECK: define{{.*}}ptr @test_WithZeroSizedArray(ptr noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_WithZeroSizedArray(_: WithZeroSizedArray) -> WithZeroSizedArray {
-    loop {}
-}
-
-#[repr(transparent)]
-pub struct Generic<T>(T);
-
-// CHECK: define{{.*}}double @test_Generic(double noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_Generic(_: Generic<f64>) -> Generic<f64> {
-    loop {}
-}
-
-#[repr(transparent)]
-pub struct GenericPlusZst<T>(T, Zst2);
-
-#[repr(u8)]
-pub enum Bool {
-    True,
-    False,
-    FileNotFound,
-}
-
-// CHECK: define{{( dso_local)?}} noundef{{( zeroext)?( range\(i8 0, 3\))?}} i8 @test_Gpz(i8 noundef{{( zeroext)?( range\(i8 0, 3\))?}} %_1)
-#[no_mangle]
-pub extern "C" fn test_Gpz(_: GenericPlusZst<Bool>) -> GenericPlusZst<Bool> {
-    loop {}
-}
-
-#[repr(transparent)]
-pub struct LifetimePhantom<'a, T: 'a>(*const T, PhantomData<&'a T>);
-
-// CHECK: define{{.*}}ptr @test_LifetimePhantom(ptr noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_LifetimePhantom(_: LifetimePhantom<i16>) -> LifetimePhantom<i16> {
-    loop {}
-}
-
-// This works despite current alignment resrictions because PhantomData is always align(1)
-#[repr(transparent)]
-pub struct UnitPhantom<T, U> {
-    val: T,
-    unit: PhantomData<U>,
-}
-
-pub struct Px;
-
-// CHECK: define{{.*}}float @test_UnitPhantom(float noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_UnitPhantom(_: UnitPhantom<f32, Px>) -> UnitPhantom<f32, Px> {
-    loop {}
-}
-
-#[repr(transparent)]
-pub struct TwoZsts(Zst1, i8, Zst2);
-
-// CHECK: define{{( dso_local)?}} noundef{{( signext)?}} i8 @test_TwoZsts(i8 noundef{{( signext)?}} %_1)
-#[no_mangle]
-pub extern "C" fn test_TwoZsts(_: TwoZsts) -> TwoZsts {
-    loop {}
-}
-
-#[repr(transparent)]
-pub struct Nested1(Zst2, Generic<f64>);
-
-// CHECK: define{{.*}}double @test_Nested1(double noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_Nested1(_: Nested1) -> Nested1 {
-    loop {}
-}
-
-#[repr(transparent)]
-pub struct Nested2(Nested1, Zst1);
-
-// CHECK: define{{.*}}double @test_Nested2(double noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_Nested2(_: Nested2) -> Nested2 {
-    loop {}
-}
-
-#[repr(simd)]
-struct f32x4([f32; 4]);
-
-#[repr(transparent)]
-pub struct Vector(f32x4);
-
-// CHECK: define{{.*}}<4 x float> @test_Vector(<4 x float> %_1)
-#[no_mangle]
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-pub extern "C" fn test_Vector(_: Vector) -> Vector {
-    loop {}
-}
-
-trait Mirror {
-    type It: ?Sized;
-}
-impl<T: ?Sized> Mirror for T {
-    type It = Self;
-}
-
-#[repr(transparent)]
-pub struct StructWithProjection(<f32 as Mirror>::It);
-
-// CHECK: define{{.*}}float @test_Projection(float noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_Projection(_: StructWithProjection) -> StructWithProjection {
-    loop {}
-}
-
-#[repr(transparent)]
-pub enum EnumF32 {
-    Variant(F32),
-}
-
-// CHECK: define{{.*}}float @test_EnumF32(float noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_EnumF32(_: EnumF32) -> EnumF32 {
-    loop {}
-}
-
-#[repr(transparent)]
-pub enum EnumF32WithZsts {
-    Variant(Zst1, F32, Zst2),
-}
-
-// CHECK: define{{.*}}float @test_EnumF32WithZsts(float noundef %_1)
-#[no_mangle]
-pub extern "C" fn test_EnumF32WithZsts(_: EnumF32WithZsts) -> EnumF32WithZsts {
-    loop {}
-}
-
-#[repr(transparent)]
-pub union UnionF32 {
-    field: F32,
-}
-
-// CHECK: define{{.*}} float @test_UnionF32(float %_1)
-#[no_mangle]
-pub extern "C" fn test_UnionF32(_: UnionF32) -> UnionF32 {
-    loop {}
-}
-
-#[repr(transparent)]
-pub union UnionF32WithZsts {
-    zst1: Zst1,
-    field: F32,
-    zst2: Zst2,
-}
-
-// CHECK: define{{.*}}float @test_UnionF32WithZsts(float %_1)
-#[no_mangle]
-pub extern "C" fn test_UnionF32WithZsts(_: UnionF32WithZsts) -> UnionF32WithZsts {
-    loop {}
-}
-
-// All that remains to be tested are aggregates. They are tested in separate files called
-// transparent-*.rs  with `only-*` or `ignore-*` directives, because the expected LLVM IR
-// function signatures vary so much that it's not reasonably possible to cover all of them with a
-// single CHECK line.
-//
-// You may be wondering why we don't just compare the return types and argument types for equality
-// with FileCheck regex captures. Well, rustc doesn't perform newtype unwrapping on newtypes
-// containing aggregates. This is OK on all ABIs we support, but because LLVM has not gotten rid of
-// pointee types yet, the IR function signature will be syntactically different (%Foo* vs
-// %FooWrapper*).
diff --git a/tests/codegen/retpoline.rs b/tests/codegen/retpoline.rs
deleted file mode 100644
index 915c2c3d797..00000000000
--- a/tests/codegen/retpoline.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// ignore-tidy-linelength
-// Test that the
-// `retpoline-external-thunk`, `retpoline-indirect-branches`, `retpoline-indirect-calls`
-// target features are (not) emitted when the `retpoline/retpoline-external-thunk` flag is (not) set.
-
-//@ add-core-stubs
-//@ revisions: disabled enabled_retpoline enabled_retpoline_external_thunk
-//@ needs-llvm-components: x86
-//@ compile-flags: --target x86_64-unknown-linux-gnu
-//@ [enabled_retpoline] compile-flags: -Zretpoline
-//@ [enabled_retpoline_external_thunk] compile-flags: -Zretpoline-external-thunk
-#![crate_type = "lib"]
-#![feature(no_core)]
-#![no_core]
-extern crate minicore;
-
-#[no_mangle]
-pub fn foo() {
-    // CHECK: @foo() unnamed_addr #0
-
-    // disabled-NOT: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+retpoline-external-thunk{{.*}} }
-    // disabled-NOT: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+retpoline-indirect-branches{{.*}} }
-    // disabled-NOT: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+retpoline-indirect-calls{{.*}} }
-
-    // enabled_retpoline: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+retpoline-indirect-branches,+retpoline-indirect-calls{{.*}} }
-    // enabled_retpoline_external_thunk: attributes #0 = { {{.*}}"target-features"="{{[^"]*}}+retpoline-external-thunk,+retpoline-indirect-branches,+retpoline-indirect-calls{{.*}} }
-}
diff --git a/tests/codegen/riscv-abi/call-llvm-intrinsics.rs b/tests/codegen/riscv-abi/call-llvm-intrinsics.rs
deleted file mode 100644
index e72a649a530..00000000000
--- a/tests/codegen/riscv-abi/call-llvm-intrinsics.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-//@ only-riscv64
-
-#![feature(link_llvm_intrinsics)]
-#![crate_type = "lib"]
-
-struct A;
-
-impl Drop for A {
-    fn drop(&mut self) {
-        println!("A");
-    }
-}
-
-extern "C" {
-    #[link_name = "llvm.sqrt.f32"]
-    fn sqrt(x: f32) -> f32;
-}
-
-pub fn do_call() {
-    let _a = A;
-
-    unsafe {
-        // Ensure that we `call` LLVM intrinsics instead of trying to `invoke` them
-        // CHECK: store float 4.000000e+00, ptr %{{.}}, align 4
-        // CHECK: call float @llvm.sqrt.f32(float %{{.}}
-        sqrt(4.0);
-    }
-}
diff --git a/tests/codegen/riscv-abi/cast-local-large-enough.rs b/tests/codegen/riscv-abi/cast-local-large-enough.rs
deleted file mode 100644
index 9d21d73b459..00000000000
--- a/tests/codegen/riscv-abi/cast-local-large-enough.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=0 -Cdebuginfo=0 --target riscv64gc-unknown-linux-gnu
-//@ needs-llvm-components: riscv
-
-#![feature(no_core, lang_items)]
-#![no_std]
-#![no_core]
-#![crate_type = "lib"]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C, align(64))]
-struct Aligned(f64);
-
-#[repr(C, align(64))]
-struct AlignedPair(f32, f64);
-
-impl Copy for Aligned {}
-impl Copy for AlignedPair {}
-
-// CHECK-LABEL: define double @read_aligned
-#[unsafe(no_mangle)]
-pub extern "C" fn read_aligned(x: &Aligned) -> Aligned {
-    // CHECK: %[[TEMP:.*]] = alloca [64 x i8], align 64
-    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 64 %[[TEMP]], ptr align 64 %[[PTR:.*]], i64 64, i1 false)
-    // CHECK-NEXT: %[[RES:.*]] = load double, ptr %[[TEMP]], align 64
-    // CHECK-NEXT: ret double %[[RES]]
-    *x
-}
-
-// CHECK-LABEL: define { float, double } @read_aligned_pair
-#[unsafe(no_mangle)]
-pub extern "C" fn read_aligned_pair(x: &AlignedPair) -> AlignedPair {
-    // CHECK: %[[TEMP:.*]] = alloca [64 x i8], align 64
-    // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 64 %[[TEMP]], ptr align 64 %[[PTR:.*]], i64 64, i1 false)
-    // CHECK-NEXT: %[[FIRST:.*]] = load float, ptr %[[TEMP]], align 64
-    // CHECK-NEXT: %[[SECOND_PTR:.*]] = getelementptr inbounds i8, ptr %[[TEMP]], i64 8
-    // CHECK-NEXT: %[[SECOND:.*]] = load double, ptr %[[SECOND_PTR]], align 8
-    // CHECK-NEXT: %[[RES1:.*]] = insertvalue { float, double } poison, float %[[FIRST]], 0
-    // CHECK-NEXT: %[[RES2:.*]] = insertvalue { float, double } %[[RES1]], double %[[SECOND]], 1
-    // CHECK-NEXT: ret { float, double } %[[RES2]]
-    *x
-}
diff --git a/tests/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs b/tests/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
deleted file mode 100644
index df99f6969fc..00000000000
--- a/tests/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: --target riscv64gc-unknown-linux-gnu -Copt-level=3 -C no-prepopulate-passes -C panic=abort
-//@ needs-llvm-components: riscv
-
-#![crate_type = "lib"]
-#![no_core]
-#![feature(no_core, lang_items)]
-#![allow(improper_ctypes)]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: define void @f_void()
-#[no_mangle]
-pub extern "C" fn f_void() {}
-
-// CHECK: define noundef zeroext i1 @f_scalar_0(i1 noundef zeroext %a)
-#[no_mangle]
-pub extern "C" fn f_scalar_0(a: bool) -> bool {
-    a
-}
-
-// CHECK: define noundef signext i8 @f_scalar_1(i8 noundef signext %x)
-#[no_mangle]
-pub extern "C" fn f_scalar_1(x: i8) -> i8 {
-    x
-}
-
-// CHECK: define noundef zeroext i8 @f_scalar_2(i8 noundef zeroext %x)
-#[no_mangle]
-pub extern "C" fn f_scalar_2(x: u8) -> u8 {
-    x
-}
-
-// CHECK: define noundef signext i32 @f_scalar_3(i32 noundef signext %x)
-#[no_mangle]
-pub extern "C" fn f_scalar_3(x: i32) -> u32 {
-    x as u32
-}
-
-// CHECK: define noundef i64 @f_scalar_4(i64 noundef %x)
-#[no_mangle]
-pub extern "C" fn f_scalar_4(x: i64) -> i64 {
-    x
-}
-
-// CHECK: define float @f_fp_scalar_1(float %0)
-#[no_mangle]
-pub extern "C" fn f_fp_scalar_1(x: f32) -> f32 {
-    x
-}
-// CHECK: define double @f_fp_scalar_2(double %0)
-#[no_mangle]
-pub extern "C" fn f_fp_scalar_2(x: f64) -> f64 {
-    x
-}
-
-#[repr(C)]
-pub struct Empty {}
-
-// CHECK: define void @f_agg_empty_struct()
-#[no_mangle]
-pub extern "C" fn f_agg_empty_struct(e: Empty) -> Empty {
-    e
-}
-
-#[repr(C)]
-pub struct Tiny {
-    a: u16,
-    b: u16,
-    c: u16,
-    d: u16,
-}
-
-// CHECK: define void @f_agg_tiny(i64 %0)
-#[no_mangle]
-pub extern "C" fn f_agg_tiny(mut e: Tiny) {}
-
-// CHECK: define i64 @f_agg_tiny_ret()
-#[no_mangle]
-pub extern "C" fn f_agg_tiny_ret() -> Tiny {
-    Tiny { a: 1, b: 2, c: 3, d: 4 }
-}
-
-#[repr(C)]
-pub struct Small {
-    a: i64,
-    b: *mut i64,
-}
-
-// CHECK: define void @f_agg_small([2 x i64] %0)
-#[no_mangle]
-pub extern "C" fn f_agg_small(mut x: Small) {}
-
-// CHECK: define [2 x i64] @f_agg_small_ret()
-#[no_mangle]
-pub extern "C" fn f_agg_small_ret() -> Small {
-    Small { a: 1, b: 0 as *mut _ }
-}
-
-#[repr(C)]
-pub struct SmallAligned {
-    a: i128,
-}
-
-// CHECK: define void @f_agg_small_aligned(i128 %0)
-#[no_mangle]
-pub extern "C" fn f_agg_small_aligned(mut x: SmallAligned) {}
-
-#[repr(C)]
-pub struct Large {
-    a: i64,
-    b: i64,
-    c: i64,
-    d: i64,
-}
-
-// CHECK: define void @f_agg_large(ptr {{.*}}%x)
-#[no_mangle]
-pub extern "C" fn f_agg_large(mut x: Large) {}
-
-// CHECK: define void @f_agg_large_ret(ptr {{.*}}sret{{.*}}, i32 noundef signext %i, i8 noundef signext %j)
-#[no_mangle]
-pub extern "C" fn f_agg_large_ret(i: i32, j: i8) -> Large {
-    Large { a: 1, b: 2, c: 3, d: 4 }
-}
-
-// CHECK: define void @f_scalar_stack_1(i64 %0, [2 x i64] %1, i128 %2, ptr {{.*}}%d, i8 noundef zeroext %e, i8 noundef signext %f, i8 noundef %g, i8 noundef %h)
-#[no_mangle]
-pub extern "C" fn f_scalar_stack_1(
-    a: Tiny,
-    b: Small,
-    c: SmallAligned,
-    d: Large,
-    e: u8,
-    f: i8,
-    g: u8,
-    h: i8,
-) {
-}
-
-// CHECK: define void @f_scalar_stack_2(ptr {{.*}}sret{{.*}} %_0, i64 noundef %a, i128 %0, i128 %1, i64 noundef %d, i8 noundef zeroext %e, i8 noundef %f, i8 noundef %g)
-#[no_mangle]
-pub extern "C" fn f_scalar_stack_2(
-    a: u64,
-    b: SmallAligned,
-    c: SmallAligned,
-    d: u64,
-    e: u8,
-    f: i8,
-    g: u8,
-) -> Large {
-    Large { a: a as i64, b: e as i64, c: f as i64, d: g as i64 }
-}
-
-extern "C" {
-    fn f_va_callee(_: i32, ...) -> i32;
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn f_va_caller() {
-    // CHECK: call noundef signext i32 (i32, ...) @f_va_callee(i32 noundef signext 1, i32 noundef signext 2, i64 noundef 3, double {{.*}}, double {{.*}}, i64 {{.*}}, [2 x i64] {{.*}}, i128 {{.*}}, ptr {{.*}})
-    f_va_callee(
-        1,
-        2i32,
-        3i64,
-        4.0f64,
-        5.0f64,
-        Tiny { a: 1, b: 2, c: 3, d: 4 },
-        Small { a: 10, b: 0 as *mut _ },
-        SmallAligned { a: 11 },
-        Large { a: 12, b: 13, c: 14, d: 15 },
-    );
-    // CHECK: call noundef signext i32 (i32, ...) @f_va_callee(i32 noundef signext 1, i32 noundef signext 2, i32 noundef signext 3, i32 noundef signext 4, i128 {{.*}}, i32 noundef signext 6, i32 noundef signext 7, i32 noundef 8, i32 noundef 9)
-    f_va_callee(1, 2i32, 3i32, 4i32, SmallAligned { a: 5 }, 6i32, 7i32, 8i32, 9i32);
-}
diff --git a/tests/codegen/riscv-abi/riscv64-lp64d-abi.rs b/tests/codegen/riscv-abi/riscv64-lp64d-abi.rs
deleted file mode 100644
index d768ab9381a..00000000000
--- a/tests/codegen/riscv-abi/riscv64-lp64d-abi.rs
+++ /dev/null
@@ -1,299 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target riscv64gc-unknown-linux-gnu
-//@ needs-llvm-components: riscv
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: define void @f_fpr_tracking(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, i8 noundef zeroext %i)
-#[no_mangle]
-pub extern "C" fn f_fpr_tracking(
-    a: f64,
-    b: f64,
-    c: f64,
-    d: f64,
-    e: f64,
-    f: f64,
-    g: f64,
-    h: f64,
-    i: u8,
-) {
-}
-
-#[repr(C)]
-pub struct Double {
-    f: f64,
-}
-
-#[repr(C)]
-pub struct DoubleDouble {
-    f: f64,
-    g: f64,
-}
-
-#[repr(C)]
-pub struct DoubleFloat {
-    f: f64,
-    g: f32,
-}
-
-// CHECK: define void @f_double_s_arg(double %0)
-#[no_mangle]
-pub extern "C" fn f_double_s_arg(a: Double) {}
-
-// CHECK: define double @f_ret_double_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_s() -> Double {
-    Double { f: 1. }
-}
-
-// CHECK: define void @f_double_double_s_arg({ double, double } %0)
-#[no_mangle]
-pub extern "C" fn f_double_double_s_arg(a: DoubleDouble) {}
-
-// CHECK: define { double, double } @f_ret_double_double_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_double_s() -> DoubleDouble {
-    DoubleDouble { f: 1., g: 2. }
-}
-
-// CHECK: define void @f_double_float_s_arg({ double, float } %0)
-#[no_mangle]
-pub extern "C" fn f_double_float_s_arg(a: DoubleFloat) {}
-
-// CHECK: define { double, float } @f_ret_double_float_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_float_s() -> DoubleFloat {
-    DoubleFloat { f: 1., g: 2. }
-}
-
-// CHECK: define void @f_double_double_s_arg_insufficient_fprs(double %0, double %1, double %2, double %3, double %4, double %5, double %6, [2 x i64] %7)
-#[no_mangle]
-pub extern "C" fn f_double_double_s_arg_insufficient_fprs(
-    a: f64,
-    b: f64,
-    c: f64,
-    d: f64,
-    e: f64,
-    f: f64,
-    g: f64,
-    h: DoubleDouble,
-) {
-}
-
-#[repr(C)]
-pub struct DoubleInt8 {
-    f: f64,
-    i: i8,
-}
-
-#[repr(C)]
-pub struct DoubleUInt8 {
-    f: f64,
-    i: u8,
-}
-
-#[repr(C)]
-pub struct DoubleInt32 {
-    f: f64,
-    i: i32,
-}
-
-#[repr(C)]
-pub struct DoubleInt64 {
-    f: f64,
-    i: i64,
-}
-
-// CHECK: define void @f_double_int8_s_arg({ double, i8 } %0)
-#[no_mangle]
-pub extern "C" fn f_double_int8_s_arg(a: DoubleInt8) {}
-
-// CHECK: define { double, i8 } @f_ret_double_int8_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_int8_s() -> DoubleInt8 {
-    DoubleInt8 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_double_int32_s_arg({ double, i32 } %0)
-#[no_mangle]
-pub extern "C" fn f_double_int32_s_arg(a: DoubleInt32) {}
-
-// CHECK: define { double, i32 } @f_ret_double_int32_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_int32_s() -> DoubleInt32 {
-    DoubleInt32 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_double_uint8_s_arg({ double, i8 } %0)
-#[no_mangle]
-pub extern "C" fn f_double_uint8_s_arg(a: DoubleUInt8) {}
-
-// CHECK: define { double, i8 } @f_ret_double_uint8_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_uint8_s() -> DoubleUInt8 {
-    DoubleUInt8 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_double_int64_s_arg({ double, i64 } %0)
-#[no_mangle]
-pub extern "C" fn f_double_int64_s_arg(a: DoubleInt64) {}
-
-// CHECK: define { double, i64 } @f_ret_double_int64_s()
-#[no_mangle]
-pub extern "C" fn f_ret_double_int64_s() -> DoubleInt64 {
-    DoubleInt64 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_double_int8_s_arg_insufficient_gprs(i32 noundef signext %a, i32 noundef signext %b, i32 noundef signext %c, i32 noundef signext %d, i32 noundef signext %e, i32 noundef signext %f, i32 noundef signext %g, i32 noundef signext %h, [2 x i64] %0)
-#[no_mangle]
-pub extern "C" fn f_double_int8_s_arg_insufficient_gprs(
-    a: i32,
-    b: i32,
-    c: i32,
-    d: i32,
-    e: i32,
-    f: i32,
-    g: i32,
-    h: i32,
-    i: DoubleInt8,
-) {
-}
-
-// CHECK: define void @f_struct_double_int8_insufficient_fprs(float %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, [2 x i64] %8)
-#[no_mangle]
-pub extern "C" fn f_struct_double_int8_insufficient_fprs(
-    a: f32,
-    b: f64,
-    c: f64,
-    d: f64,
-    e: f64,
-    f: f64,
-    g: f64,
-    h: f64,
-    i: DoubleInt8,
-) {
-}
-
-#[repr(C)]
-pub struct DoubleArr1 {
-    a: [f64; 1],
-}
-
-// CHECK: define void @f_doublearr1_s_arg(double %0)
-#[no_mangle]
-pub extern "C" fn f_doublearr1_s_arg(a: DoubleArr1) {}
-
-// CHECK: define double @f_ret_doublearr1_s()
-#[no_mangle]
-pub extern "C" fn f_ret_doublearr1_s() -> DoubleArr1 {
-    DoubleArr1 { a: [1.] }
-}
-
-#[repr(C)]
-pub struct DoubleArr2 {
-    a: [f64; 2],
-}
-
-// CHECK: define void @f_doublearr2_s_arg({ double, double } %0)
-#[no_mangle]
-pub extern "C" fn f_doublearr2_s_arg(a: DoubleArr2) {}
-
-// CHECK: define { double, double } @f_ret_doublearr2_s()
-#[no_mangle]
-pub extern "C" fn f_ret_doublearr2_s() -> DoubleArr2 {
-    DoubleArr2 { a: [1., 2.] }
-}
-
-#[repr(C)]
-pub struct Tricky1 {
-    f: [f64; 1],
-}
-
-#[repr(C)]
-pub struct DoubleArr2Tricky1 {
-    g: [Tricky1; 2],
-}
-
-// CHECK: define void @f_doublearr2_tricky1_s_arg({ double, double } %0)
-#[no_mangle]
-pub extern "C" fn f_doublearr2_tricky1_s_arg(a: DoubleArr2Tricky1) {}
-
-// CHECK: define { double, double } @f_ret_doublearr2_tricky1_s()
-#[no_mangle]
-pub extern "C" fn f_ret_doublearr2_tricky1_s() -> DoubleArr2Tricky1 {
-    DoubleArr2Tricky1 { g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
-}
-
-#[repr(C)]
-pub struct EmptyStruct {}
-
-#[repr(C)]
-pub struct DoubleArr2Tricky2 {
-    s: EmptyStruct,
-    g: [Tricky1; 2],
-}
-
-// CHECK: define void @f_doublearr2_tricky2_s_arg({ double, double } %0)
-#[no_mangle]
-pub extern "C" fn f_doublearr2_tricky2_s_arg(a: DoubleArr2Tricky2) {}
-
-// CHECK: define { double, double } @f_ret_doublearr2_tricky2_s()
-#[no_mangle]
-pub extern "C" fn f_ret_doublearr2_tricky2_s() -> DoubleArr2Tricky2 {
-    DoubleArr2Tricky2 { s: EmptyStruct {}, g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
-}
-
-#[repr(C)]
-pub struct IntDoubleInt {
-    a: i32,
-    b: f64,
-    c: i32,
-}
-
-// CHECK: define void @f_int_double_int_s_arg(ptr {{.*}} %a)
-#[no_mangle]
-pub extern "C" fn f_int_double_int_s_arg(a: IntDoubleInt) {}
-
-// CHECK: define void @f_ret_int_double_int_s(ptr {{.*}} sret([24 x i8]) align 8 {{.*}}dereferenceable(24) %_0)
-#[no_mangle]
-pub extern "C" fn f_ret_int_double_int_s() -> IntDoubleInt {
-    IntDoubleInt { a: 1, b: 2., c: 3 }
-}
-
-#[repr(C)]
-pub struct CharCharDouble {
-    a: u8,
-    b: u8,
-    c: f64,
-}
-
-// CHECK: define void @f_char_char_double_s_arg([2 x i64] %0)
-#[no_mangle]
-pub extern "C" fn f_char_char_double_s_arg(a: CharCharDouble) {}
-
-// CHECK: define [2 x i64] @f_ret_char_char_double_s()
-#[no_mangle]
-pub extern "C" fn f_ret_char_char_double_s() -> CharCharDouble {
-    CharCharDouble { a: 1, b: 2, c: 3. }
-}
-
-#[repr(C)]
-pub union DoubleU {
-    a: f64,
-}
-
-// CHECK: define void @f_double_u_arg(i64 %0)
-#[no_mangle]
-pub extern "C" fn f_double_u_arg(a: DoubleU) {}
-
-// CHECK: define i64 @f_ret_double_u()
-#[no_mangle]
-pub extern "C" fn f_ret_double_u() -> DoubleU {
-    unsafe { DoubleU { a: 1. } }
-}
diff --git a/tests/codegen/riscv-abi/riscv64-lp64f-lp64d-abi.rs b/tests/codegen/riscv-abi/riscv64-lp64f-lp64d-abi.rs
deleted file mode 100644
index 361f0322690..00000000000
--- a/tests/codegen/riscv-abi/riscv64-lp64f-lp64d-abi.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target riscv64gc-unknown-linux-gnu
-//@ needs-llvm-components: riscv
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: define void @f_fpr_tracking(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, i8 noundef zeroext %i)
-#[no_mangle]
-pub extern "C" fn f_fpr_tracking(
-    a: f32,
-    b: f32,
-    c: f32,
-    d: f32,
-    e: f32,
-    f: f32,
-    g: f32,
-    h: f32,
-    i: u8,
-) {
-}
-
-#[repr(C)]
-pub struct Float {
-    f: f32,
-}
-
-#[repr(C)]
-pub struct FloatFloat {
-    f: f32,
-    g: f32,
-}
-
-// CHECK: define void @f_float_s_arg(float %0)
-#[no_mangle]
-pub extern "C" fn f_float_s_arg(a: Float) {}
-
-// CHECK: define float @f_ret_float_s()
-#[no_mangle]
-pub extern "C" fn f_ret_float_s() -> Float {
-    Float { f: 1. }
-}
-
-// CHECK: define void @f_float_float_s_arg({ float, float } %0)
-#[no_mangle]
-pub extern "C" fn f_float_float_s_arg(a: FloatFloat) {}
-
-// CHECK: define { float, float } @f_ret_float_float_s()
-#[no_mangle]
-pub extern "C" fn f_ret_float_float_s() -> FloatFloat {
-    FloatFloat { f: 1., g: 2. }
-}
-
-// CHECK: define void @f_float_float_s_arg_insufficient_fprs(float %0, float %1, float %2, float %3, float %4, float %5, float %6, i64 %7)
-#[no_mangle]
-pub extern "C" fn f_float_float_s_arg_insufficient_fprs(
-    a: f32,
-    b: f32,
-    c: f32,
-    d: f32,
-    e: f32,
-    f: f32,
-    g: f32,
-    h: FloatFloat,
-) {
-}
-
-#[repr(C)]
-pub struct FloatInt8 {
-    f: f32,
-    i: i8,
-}
-
-#[repr(C)]
-pub struct FloatUInt8 {
-    f: f32,
-    i: u8,
-}
-
-#[repr(C)]
-pub struct FloatInt32 {
-    f: f32,
-    i: i32,
-}
-
-#[repr(C)]
-pub struct FloatInt64 {
-    f: f32,
-    i: i64,
-}
-
-// CHECK: define void @f_float_int8_s_arg({ float, i8 } %0)
-#[no_mangle]
-pub extern "C" fn f_float_int8_s_arg(a: FloatInt8) {}
-
-// CHECK: define { float, i8 } @f_ret_float_int8_s()
-#[no_mangle]
-pub extern "C" fn f_ret_float_int8_s() -> FloatInt8 {
-    FloatInt8 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_float_int32_s_arg({ float, i32 } %0)
-#[no_mangle]
-pub extern "C" fn f_float_int32_s_arg(a: FloatInt32) {}
-
-// CHECK: define { float, i32 } @f_ret_float_int32_s()
-#[no_mangle]
-pub extern "C" fn f_ret_float_int32_s() -> FloatInt32 {
-    FloatInt32 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_float_uint8_s_arg({ float, i8 } %0)
-#[no_mangle]
-pub extern "C" fn f_float_uint8_s_arg(a: FloatUInt8) {}
-
-// CHECK: define { float, i8 } @f_ret_float_uint8_s()
-#[no_mangle]
-pub extern "C" fn f_ret_float_uint8_s() -> FloatUInt8 {
-    FloatUInt8 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_float_int64_s_arg({ float, i64 } %0)
-#[no_mangle]
-pub extern "C" fn f_float_int64_s_arg(a: FloatInt64) {}
-
-// CHECK: define { float, i64 } @f_ret_float_int64_s()
-#[no_mangle]
-pub extern "C" fn f_ret_float_int64_s() -> FloatInt64 {
-    FloatInt64 { f: 1., i: 2 }
-}
-
-// CHECK: define void @f_float_int8_s_arg_insufficient_gprs(i32 noundef signext %a, i32 noundef signext %b, i32 noundef signext %c, i32 noundef signext %d, i32 noundef signext %e, i32 noundef signext %f, i32 noundef signext %g, i32 noundef signext %h, i64 %0)
-#[no_mangle]
-pub extern "C" fn f_float_int8_s_arg_insufficient_gprs(
-    a: i32,
-    b: i32,
-    c: i32,
-    d: i32,
-    e: i32,
-    f: i32,
-    g: i32,
-    h: i32,
-    i: FloatInt8,
-) {
-}
-
-// CHECK: define void @f_struct_float_int8_insufficient_fprs(float %0, float %1, float %2,  float %3, float %4, float %5, float %6, float %7, i64 %8)
-#[no_mangle]
-pub extern "C" fn f_struct_float_int8_insufficient_fprs(
-    a: f32,
-    b: f32,
-    c: f32,
-    d: f32,
-    e: f32,
-    f: f32,
-    g: f32,
-    h: f32,
-    i: FloatInt8,
-) {
-}
-
-#[repr(C)]
-pub struct FloatArr1 {
-    a: [f32; 1],
-}
-
-// CHECK: define void @f_floatarr1_s_arg(float %0)
-#[no_mangle]
-pub extern "C" fn f_floatarr1_s_arg(a: FloatArr1) {}
-
-// CHECK: define float @f_ret_floatarr1_s()
-#[no_mangle]
-pub extern "C" fn f_ret_floatarr1_s() -> FloatArr1 {
-    FloatArr1 { a: [1.] }
-}
-
-#[repr(C)]
-pub struct FloatArr2 {
-    a: [f32; 2],
-}
-
-// CHECK: define void @f_floatarr2_s_arg({ float, float } %0)
-#[no_mangle]
-pub extern "C" fn f_floatarr2_s_arg(a: FloatArr2) {}
-
-// CHECK: define { float, float } @f_ret_floatarr2_s()
-#[no_mangle]
-pub extern "C" fn f_ret_floatarr2_s() -> FloatArr2 {
-    FloatArr2 { a: [1., 2.] }
-}
-
-#[repr(C)]
-pub struct Tricky1 {
-    f: [f32; 1],
-}
-
-#[repr(C)]
-pub struct FloatArr2Tricky1 {
-    g: [Tricky1; 2],
-}
-
-// CHECK: define void @f_floatarr2_tricky1_s_arg({ float, float } %0)
-#[no_mangle]
-pub extern "C" fn f_floatarr2_tricky1_s_arg(a: FloatArr2Tricky1) {}
-
-// CHECK: define { float, float } @f_ret_floatarr2_tricky1_s()
-#[no_mangle]
-pub extern "C" fn f_ret_floatarr2_tricky1_s() -> FloatArr2Tricky1 {
-    FloatArr2Tricky1 { g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
-}
-
-#[repr(C)]
-pub struct EmptyStruct {}
-
-#[repr(C)]
-pub struct FloatArr2Tricky2 {
-    s: EmptyStruct,
-    g: [Tricky1; 2],
-}
-
-// CHECK: define void @f_floatarr2_tricky2_s_arg({ float, float } %0)
-#[no_mangle]
-pub extern "C" fn f_floatarr2_tricky2_s_arg(a: FloatArr2Tricky2) {}
-
-// CHECK: define { float, float } @f_ret_floatarr2_tricky2_s()
-#[no_mangle]
-pub extern "C" fn f_ret_floatarr2_tricky2_s() -> FloatArr2Tricky2 {
-    FloatArr2Tricky2 { s: EmptyStruct {}, g: [Tricky1 { f: [1.] }, Tricky1 { f: [2.] }] }
-}
-
-#[repr(C)]
-pub struct IntFloatInt {
-    a: i32,
-    b: f32,
-    c: i32,
-}
-
-// CHECK: define void @f_int_float_int_s_arg([2 x i64] %0)
-#[no_mangle]
-pub extern "C" fn f_int_float_int_s_arg(a: IntFloatInt) {}
-
-// CHECK: define [2 x i64] @f_ret_int_float_int_s()
-#[no_mangle]
-pub extern "C" fn f_ret_int_float_int_s() -> IntFloatInt {
-    IntFloatInt { a: 1, b: 2., c: 3 }
-}
-
-#[repr(C)]
-pub struct CharCharFloat {
-    a: u8,
-    b: u8,
-    c: f32,
-}
-
-// CHECK: define void @f_char_char_float_s_arg(i64 %0)
-#[no_mangle]
-pub extern "C" fn f_char_char_float_s_arg(a: CharCharFloat) {}
-
-// CHECK: define i64 @f_ret_char_char_float_s()
-#[no_mangle]
-pub extern "C" fn f_ret_char_char_float_s() -> CharCharFloat {
-    CharCharFloat { a: 1, b: 2, c: 3. }
-}
-
-#[repr(C)]
-pub union FloatU {
-    a: f32,
-}
-
-// CHECK: define void @f_float_u_arg(i64 %0)
-#[no_mangle]
-pub extern "C" fn f_float_u_arg(a: FloatU) {}
-
-// CHECK: define i64 @f_ret_float_u()
-#[no_mangle]
-pub extern "C" fn f_ret_float_u() -> FloatU {
-    unsafe { FloatU { a: 1. } }
-}
diff --git a/tests/codegen/riscv-target-abi.rs b/tests/codegen/riscv-target-abi.rs
deleted file mode 100644
index d41fcb4dd84..00000000000
--- a/tests/codegen/riscv-target-abi.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ add-core-stubs
-//@ revisions:riscv64gc riscv32gc riscv32imac
-
-//@[riscv64gc] compile-flags: --target=riscv64gc-unknown-linux-gnu
-//@[riscv64gc] needs-llvm-components: riscv
-// riscv64gc: !{i32 1, !"target-abi", !"lp64d"}
-
-//@[riscv32gc] compile-flags: --target=riscv32gc-unknown-linux-musl
-//@[riscv32gc] needs-llvm-components: riscv
-// riscv32gc: !{i32 1, !"target-abi", !"ilp32d"}
-
-//@[riscv32imac] compile-flags: --target=riscv32imac-unknown-none-elf
-//@[riscv32imac] needs-llvm-components: riscv
-// riscv32imac: !{i32 1, !"target-abi", !"ilp32"}
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
diff --git a/tests/codegen/rust-abi-arch-specific-adjustment.rs b/tests/codegen/rust-abi-arch-specific-adjustment.rs
deleted file mode 100644
index 561f081c700..00000000000
--- a/tests/codegen/rust-abi-arch-specific-adjustment.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-//@ revisions: riscv64 loongarch64
-
-//@[riscv64] only-riscv64
-//@[riscv64] compile-flags: --target riscv64gc-unknown-linux-gnu
-//@[riscv64] needs-llvm-components: riscv
-
-//@[loongarch64] only-loongarch64
-//@[loongarch64] compile-flags: --target loongarch64-unknown-linux-gnu
-//@[loongarch64] needs-llvm-components: loongarch
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-// riscv64:     define noundef i8 @arg_attr_u8(i8 noundef zeroext %x)
-// loongarch64: define noundef i8 @arg_attr_u8(i8 noundef zeroext %x)
-pub fn arg_attr_u8(x: u8) -> u8 {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef i16 @arg_attr_u16(i16 noundef zeroext %x)
-// loongarch64: define noundef i16 @arg_attr_u16(i16 noundef zeroext %x)
-pub fn arg_attr_u16(x: u16) -> u16 {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef i32 @arg_attr_u32(i32 noundef signext %x)
-// loongarch64: define noundef i32 @arg_attr_u32(i32 noundef signext %x)
-pub fn arg_attr_u32(x: u32) -> u32 {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef i64 @arg_attr_u64(i64 noundef %x)
-// loongarch64: define noundef i64 @arg_attr_u64(i64 noundef %x)
-pub fn arg_attr_u64(x: u64) -> u64 {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef i128 @arg_attr_u128(i128 noundef %x)
-// loongarch64: define noundef i128 @arg_attr_u128(i128 noundef %x)
-pub fn arg_attr_u128(x: u128) -> u128 {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef i8 @arg_attr_i8(i8 noundef signext %x)
-// loongarch64: define noundef i8 @arg_attr_i8(i8 noundef signext %x)
-pub fn arg_attr_i8(x: i8) -> i8 {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef i16 @arg_attr_i16(i16 noundef signext %x)
-// loongarch64: define noundef i16 @arg_attr_i16(i16 noundef signext %x)
-pub fn arg_attr_i16(x: i16) -> i16 {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef i32 @arg_attr_i32(i32 noundef signext %x)
-// loongarch64: define noundef i32 @arg_attr_i32(i32 noundef signext %x)
-pub fn arg_attr_i32(x: i32) -> i32 {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef i64 @arg_attr_i64(i64 noundef %x)
-// loongarch64: define noundef i64 @arg_attr_i64(i64 noundef %x)
-pub fn arg_attr_i64(x: i64) -> i64 {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef i128 @arg_attr_i128(i128 noundef %x)
-// loongarch64: define noundef i128 @arg_attr_i128(i128 noundef %x)
-pub fn arg_attr_i128(x: i128) -> i128 {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef zeroext i1 @arg_attr_bool(i1 noundef zeroext %x)
-// loongarch64: define noundef zeroext i1 @arg_attr_bool(i1 noundef zeroext %x)
-pub fn arg_attr_bool(x: bool) -> bool {
-    x
-}
-
-#[no_mangle]
-// ignore-tidy-linelength
-// riscv64:     define noundef{{( range\(i32 0, 1114112\))?}} i32 @arg_attr_char(i32 noundef signext{{( range\(i32 0, 1114112\))?}} %x)
-// loongarch64: define noundef{{( range\(i32 0, 1114112\))?}} i32 @arg_attr_char(i32 noundef signext{{( range\(i32 0, 1114112\))?}} %x)
-pub fn arg_attr_char(x: char) -> char {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef float @arg_attr_f32(float noundef %x)
-// loongarch64: define noundef float @arg_attr_f32(float noundef %x)
-pub fn arg_attr_f32(x: f32) -> f32 {
-    x
-}
-
-#[no_mangle]
-// riscv64:     define noundef double @arg_attr_f64(double noundef %x)
-// loongarch64: define noundef double @arg_attr_f64(double noundef %x)
-pub fn arg_attr_f64(x: f64) -> f64 {
-    x
-}
diff --git a/tests/codegen/s390x-simd.rs b/tests/codegen/s390x-simd.rs
deleted file mode 100644
index ac39357519e..00000000000
--- a/tests/codegen/s390x-simd.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-//! test that s390x vector types are passed using `PassMode::Direct`
-//! see also https://github.com/rust-lang/rust/issues/135744
-//@ add-core-stubs
-//@ compile-flags: --target s390x-unknown-linux-gnu -Copt-level=3
-//@ needs-llvm-components: systemz
-
-#![crate_type = "rlib"]
-#![feature(no_core, asm_experimental_arch)]
-#![feature(s390x_target_feature, simd_ffi, link_llvm_intrinsics, repr_simd)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(simd)]
-struct i8x16([i8; 16]);
-
-#[repr(simd)]
-struct i16x8([i16; 8]);
-
-#[repr(simd)]
-struct i32x4([i32; 4]);
-
-#[repr(simd)]
-struct i64x2([i64; 2]);
-
-#[repr(simd)]
-struct f32x4([f32; 4]);
-
-#[repr(simd)]
-struct f64x2([f64; 2]);
-
-#[allow(improper_ctypes)]
-extern "C" {
-    #[link_name = "llvm.smax.v16i8"]
-    fn vmxb(a: i8x16, b: i8x16) -> i8x16;
-    #[link_name = "llvm.smax.v8i16"]
-    fn vmxh(a: i16x8, b: i16x8) -> i16x8;
-    #[link_name = "llvm.smax.v4i32"]
-    fn vmxf(a: i32x4, b: i32x4) -> i32x4;
-    #[link_name = "llvm.smax.v2i64"]
-    fn vmxg(a: i64x2, b: i64x2) -> i64x2;
-}
-
-// CHECK-LABEL: define <16 x i8> @max_i8x16
-// CHECK-SAME: <16 x i8> %a, <16 x i8> %b
-// CHECK: call <16 x i8> @llvm.smax.v16i8(<16 x i8> %a, <16 x i8> %b)
-#[no_mangle]
-#[target_feature(enable = "vector")]
-pub unsafe extern "C" fn max_i8x16(a: i8x16, b: i8x16) -> i8x16 {
-    vmxb(a, b)
-}
-
-// CHECK-LABEL: define <8 x i16> @max_i16x8
-// CHECK-SAME: <8 x i16> %a, <8 x i16> %b
-// CHECK: call <8 x i16> @llvm.smax.v8i16(<8 x i16> %a, <8 x i16> %b)
-#[no_mangle]
-#[target_feature(enable = "vector")]
-pub unsafe extern "C" fn max_i16x8(a: i16x8, b: i16x8) -> i16x8 {
-    vmxh(a, b)
-}
-
-// CHECK-LABEL: define <4 x i32> @max_i32x4
-// CHECK-SAME: <4 x i32> %a, <4 x i32> %b
-// CHECK: call <4 x i32> @llvm.smax.v4i32(<4 x i32> %a, <4 x i32> %b)
-#[no_mangle]
-#[target_feature(enable = "vector")]
-pub unsafe extern "C" fn max_i32x4(a: i32x4, b: i32x4) -> i32x4 {
-    vmxf(a, b)
-}
-
-// CHECK-LABEL: define <2 x i64> @max_i64x2
-// CHECK-SAME: <2 x i64> %a, <2 x i64> %b
-// CHECK: call <2 x i64> @llvm.smax.v2i64(<2 x i64> %a, <2 x i64> %b)
-#[no_mangle]
-#[target_feature(enable = "vector")]
-pub unsafe extern "C" fn max_i64x2(a: i64x2, b: i64x2) -> i64x2 {
-    vmxg(a, b)
-}
-
-// CHECK-LABEL: define <4 x float> @choose_f32x4
-// CHECK-SAME: <4 x float> %a, <4 x float> %b
-#[no_mangle]
-#[target_feature(enable = "vector")]
-pub unsafe extern "C" fn choose_f32x4(a: f32x4, b: f32x4, c: bool) -> f32x4 {
-    if c { a } else { b }
-}
-
-// CHECK-LABEL: define <2 x double> @choose_f64x2
-// CHECK-SAME: <2 x double> %a, <2 x double> %b
-#[no_mangle]
-#[target_feature(enable = "vector")]
-pub unsafe extern "C" fn choose_f64x2(a: f64x2, b: f64x2, c: bool) -> f64x2 {
-    if c { a } else { b }
-}
-
-#[repr(C)]
-struct Wrapper<T>(T);
-
-#[no_mangle]
-#[inline(never)]
-#[target_feature(enable = "vector")]
-pub unsafe extern "C" fn max_wrapper_i8x16(a: Wrapper<i8x16>, b: Wrapper<i8x16>) -> Wrapper<i8x16> {
-    // CHECK-LABEL: max_wrapper_i8x16
-    // CHECK-SAME: sret([16 x i8])
-    // CHECK-SAME: <16 x i8>
-    // CHECK-SAME: <16 x i8>
-    // CHECK: call <16 x i8> @llvm.smax.v16i8
-    // CHECK-SAME: <16 x i8>
-    // CHECK-SAME: <16 x i8>
-    Wrapper(vmxb(a.0, b.0))
-}
-
-#[no_mangle]
-#[inline(never)]
-#[target_feature(enable = "vector")]
-pub unsafe extern "C" fn max_wrapper_i64x2(a: Wrapper<i64x2>, b: Wrapper<i64x2>) -> Wrapper<i64x2> {
-    // CHECK-LABEL: max_wrapper_i64x2
-    // CHECK-SAME: sret([16 x i8])
-    // CHECK-SAME: <16 x i8>
-    // CHECK-SAME: <16 x i8>
-    // CHECK: call <2 x i64> @llvm.smax.v2i64
-    // CHECK-SAME: <2 x i64>
-    // CHECK-SAME: <2 x i64>
-    Wrapper(vmxg(a.0, b.0))
-}
-
-#[no_mangle]
-#[inline(never)]
-#[target_feature(enable = "vector")]
-pub unsafe extern "C" fn choose_wrapper_f64x2(
-    a: Wrapper<f64x2>,
-    b: Wrapper<f64x2>,
-    c: bool,
-) -> Wrapper<f64x2> {
-    // CHECK-LABEL: choose_wrapper_f64x2
-    // CHECK-SAME: sret([16 x i8])
-    // CHECK-SAME: <16 x i8>
-    // CHECK-SAME: <16 x i8>
-    Wrapper(choose_f64x2(a.0, b.0, c))
-}
-
-// CHECK: declare <2 x i64> @llvm.smax.v2i64(<2 x i64>, <2 x i64>)
diff --git a/tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs b/tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
deleted file mode 100644
index e1d7dc2d631..00000000000
--- a/tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ add-core-stubs
-//@ revisions: aarch64 android
-//@[aarch64] compile-flags: --target aarch64-unknown-none -Zfixed-x18 -Zsanitizer=shadow-call-stack
-//@[aarch64] needs-llvm-components: aarch64
-//@[android] compile-flags: --target aarch64-linux-android -Zsanitizer=shadow-call-stack
-//@[android] needs-llvm-components: aarch64
-
-#![allow(internal_features)]
-#![crate_type = "rlib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: ; Function Attrs:{{.*}}shadowcallstack
-#[no_mangle]
-pub fn foo() {}
-
-// CHECK: attributes #0 = {{.*}}shadowcallstack{{.*}}
diff --git a/tests/codegen/sanitizer/address-sanitizer-globals-tracking.rs b/tests/codegen/sanitizer/address-sanitizer-globals-tracking.rs
deleted file mode 100644
index f319306f93f..00000000000
--- a/tests/codegen/sanitizer/address-sanitizer-globals-tracking.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Verifies that AddressSanitizer symbols show up as expected in LLVM IR with `-Zsanitizer`.
-// This is a regression test for https://github.com/rust-lang/rust/issues/113404
-//
-// Notes about the `compile-flags` below:
-//
-// * The original issue only reproed with LTO - this is why this angle has
-//   extra test coverage via different `revisions`
-// * To observe the failure/repro at LLVM-IR level we need to use `staticlib`
-//   which necessitates `-C prefer-dynamic=false` - without the latter flag,
-//   we would have run into "cannot prefer dynamic linking when performing LTO".
-//
-// The test is restricted to `only-linux`, because the sanitizer-related instrumentation is target
-// specific.  In particular, `___asan_globals_registered` is only used in the
-// `InstrumentGlobalsELF` and `InstrumentGlobalsMachO` code paths.  The `only-linux` filter is
-// narrower than really needed (i.e. narrower than ELF-or-MachO), but this seems ok - having a
-// linux-only regression test should be sufficient here.
-//
-//@ needs-sanitizer-address
-//@ only-linux
-//
-//@ revisions:ASAN ASAN-FAT-LTO
-//@                compile-flags: -Zsanitizer=address -Ctarget-feature=-crt-static
-//@[ASAN]          compile-flags:
-//@[ASAN-FAT-LTO]  compile-flags: -Cprefer-dynamic=false -Clto=fat
-
-#![crate_type = "staticlib"]
-
-// The test below mimics `CACHED_POW10` from `library/core/src/num/flt2dec/strategy/grisu.rs` which
-// (because of incorrect handling of `___asan_globals_registered` during LTO) was incorrectly
-// reported as an ODR violation in https://crbug.com/1459233#c1.  Before this bug was fixed,
-// `___asan_globals_registered` would show up as `internal global i64` rather than `common hidden
-// global i64`.  (The test expectations ignore the exact type because on `arm-android` the type
-// is `i32` rather than `i64`.)
-//
-// CHECK: @___asan_globals_registered = common hidden global
-// CHECK: @__start_asan_globals = extern_weak hidden global
-// CHECK: @__stop_asan_globals = extern_weak hidden global
-#[no_mangle]
-pub static CACHED_POW10: [(u64, i16, i16); 4] = [
-    (0xe61acf033d1a45df, -1087, -308),
-    (0xab70fe17c79ac6ca, -1060, -300),
-    (0xff77b1fcbebcdc4f, -1034, -292),
-    (0xbe5691ef416bd60c, -1007, -284),
-];
diff --git a/tests/codegen/sanitizer/cfi/add-canonical-jump-tables-flag.rs b/tests/codegen/sanitizer/cfi/add-canonical-jump-tables-flag.rs
deleted file mode 100644
index 22577e2a3c4..00000000000
--- a/tests/codegen/sanitizer/cfi/add-canonical-jump-tables-flag.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Verifies that "CFI Canonical Jump Tables" module flag is added.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
-
-#![crate_type = "lib"]
-
-pub fn foo() {}
-
-// CHECK: !{{[0-9]+}} = !{i32 4, !"CFI Canonical Jump Tables", i32 1}
diff --git a/tests/codegen/sanitizer/cfi/add-cfi-normalize-integers-flag.rs b/tests/codegen/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
deleted file mode 100644
index a54a6d84a80..00000000000
--- a/tests/codegen/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Verifies that "cfi-normalize-integers" module flag is added.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers
-
-#![crate_type = "lib"]
-
-pub fn foo() {}
-
-// CHECK: !{{[0-9]+}} = !{i32 4, !"cfi-normalize-integers", i32 1}
diff --git a/tests/codegen/sanitizer/cfi/add-enable-split-lto-unit-flag.rs b/tests/codegen/sanitizer/cfi/add-enable-split-lto-unit-flag.rs
deleted file mode 100644
index 283b8f26102..00000000000
--- a/tests/codegen/sanitizer/cfi/add-enable-split-lto-unit-flag.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Verifies that "EnableSplitLTOUnit" module flag is added.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
-
-#![crate_type = "lib"]
-
-pub fn foo() {}
-
-// CHECK: !{{[0-9]+}} = !{i32 4, !"EnableSplitLTOUnit", i32 1}
diff --git a/tests/codegen/sanitizer/cfi/dbg-location-on-cfi-blocks.rs b/tests/codegen/sanitizer/cfi/dbg-location-on-cfi-blocks.rs
deleted file mode 100644
index df65960dfe0..00000000000
--- a/tests/codegen/sanitizer/cfi/dbg-location-on-cfi-blocks.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Verifies that the parent block's debug information are assigned to the inserted cfi block.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static -Cdebuginfo=1
-
-#![crate_type = "lib"]
-
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}foo{{.*}}!dbg !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-    // CHECK:       start:
-    // CHECK:       [[TT:%.+]] = call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"{{[[:print:]]+}}"), !dbg !{{[0-9]+}}
-    // CHECK-NEXT:  br i1 [[TT]], label %type_test.pass, label %type_test.fail, !dbg !{{[0-9]+}}
-    // CHECK:       type_test.pass:                                   ; preds = %start
-    // CHECK-NEXT:  {{%.+}} = call i32 %f(i32{{.*}} %arg), !dbg !{{[0-9]+}}
-    // CHECK:       type_test.fail:                                   ; preds = %start
-    // CHECK-NEXT:  call void @llvm.trap(), !dbg !{{[0-9]+}}
-    // CHECK-NEXT:  unreachable, !dbg !{{[0-9]+}}
-    f(arg)
-}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-checks-attr-no-sanitize.rs b/tests/codegen/sanitizer/cfi/emit-type-checks-attr-no-sanitize.rs
deleted file mode 100644
index 71ccdc8ca62..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-checks-attr-no-sanitize.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Verifies that pointer type membership tests for indirect calls are omitted.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(no_sanitize)]
-
-#[no_sanitize(cfi)]
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: emit_type_checks_attr_no_sanitize::foo
-    // CHECK:       Function Attrs: {{.*}}
-    // CHECK-LABEL: define{{.*}}foo{{.*}}!type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-    // CHECK:       start:
-    // CHECK-NEXT:  {{%.+}} = call i32 %f(i32{{.*}} %arg)
-    // CHECK-NEXT:  ret i32 {{%.+}}
-    f(arg)
-}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-checks.rs b/tests/codegen/sanitizer/cfi/emit-type-checks.rs
deleted file mode 100644
index ebc66a015df..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-checks.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Verifies that pointer type membership tests for indirect calls are emitted.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
-
-#![crate_type = "lib"]
-
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}foo{{.*}}!type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-    // CHECK:       start:
-    // CHECK:       [[TT:%.+]] = call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"{{[[:print:]]+}}")
-    // CHECK-NEXT:  br i1 [[TT]], label %type_test.pass, label %type_test.fail
-    // CHECK:       type_test.pass:
-    // CHECK-NEXT:  {{%.+}} = call i32 %f(i32{{.*}} %arg)
-    // CHECK:       type_test.fail:
-    // CHECK-NEXT:  call void @llvm.trap()
-    // CHECK-NEXT:  unreachable
-    f(arg)
-}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs
deleted file mode 100644
index 9bc2e42db0f..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-attr-cfi-encoding.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-// Verifies that user-defined CFI encoding for types are emitted.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(cfi_encoding, extern_types)]
-
-#[cfi_encoding = "3Foo"]
-pub struct Type1(i32);
-
-extern "C" {
-    #[cfi_encoding = "3Bar"]
-    type Type2;
-}
-
-#[cfi_encoding = "3Baz"]
-#[repr(transparent)]
-pub struct Type3(i32);
-
-#[cfi_encoding = "i"]
-pub struct Type4(i32);
-
-#[cfi_encoding = "j"]
-#[repr(transparent)]
-pub struct Type5(u32);
-
-pub fn foo0(_: Type1) {}
-// CHECK: define{{.*}}foo0{{.*}}!type ![[TYPE0:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo1(_: Type1, _: Type1) {}
-// CHECK: define{{.*}}foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: Type1, _: Type1, _: Type1) {}
-// CHECK: define{{.*}}foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: *mut Type2) {}
-// CHECK: define{{.*}}foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo4(_: *mut Type2, _: *mut Type2) {}
-// CHECK: define{{.*}}foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo5(_: *mut Type2, _: *mut Type2, _: *mut Type2) {}
-// CHECK: define{{.*}}foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo6(_: *mut Type3) {}
-// CHECK: define{{.*}}foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo7(_: *mut Type3, _: *mut Type3) {}
-// CHECK: define{{.*}}foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo8(_: *mut Type3, _: *mut Type3, _: *mut Type3) {}
-// CHECK: define{{.*}}foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo9(_: Type4) {}
-// CHECK: define{{.*}}foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo10(_: Type4, _: Type4) {}
-// CHECK: define{{.*}}foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo11(_: Type4, _: Type4, _: Type4) {}
-// CHECK: define{{.*}}foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo12(_: Type5) {}
-// CHECK: define{{.*}}foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo13(_: Type5, _: Type5) {}
-// CHECK: define{{.*}}foo13{{.*}}!type ![[TYPE13:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo14(_: Type5, _: Type5, _: Type5) {}
-// CHECK: define{{.*}}foo14{{.*}}!type ![[TYPE14:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE0]] = !{i64 0, !"_ZTSFv3FooE"}
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFv3FooS_E"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFv3FooS_S_E"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvP3BarE"}
-// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvP3BarS0_E"}
-// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvP3BarS0_S0_E"}
-// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvP3BazE"}
-// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvP3BazS0_E"}
-// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvP3BazS0_S0_E"}
-// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFviE"}
-// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFviiE"}
-// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFviiiE"}
-// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvjE"}
-// CHECK: ![[TYPE13]] = !{i64 0, !"_ZTSFvjjE"}
-// CHECK: ![[TYPE14]] = !{i64 0, !"_ZTSFvjjjE"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs
deleted file mode 100644
index 9048c6a1f18..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-const-generics.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Verifies that type metadata identifiers for functions are emitted correctly
-// for const generics.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(type_alias_impl_trait)]
-
-extern crate core;
-
-pub type Type1 = impl Send;
-
-#[define_opaque(Type1)]
-pub fn foo()
-where
-    Type1: 'static,
-{
-    pub struct Foo<T, const N: usize>([T; N]);
-    let _: Type1 = Foo([0; 32]);
-}
-
-pub fn foo1(_: Type1) {}
-// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: Type1, _: Type1) {}
-// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: Type1, _: Type1, _: Type1) {}
-// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo3FooIu3i32Lu5usize32EEE"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo3FooIu3i32Lu5usize32EES2_E"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo3FooIu3i32Lu5usize32EES2_S2_E"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs
deleted file mode 100644
index 8fec275fd06..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Verifies that type metadata identifiers for drop functions are emitted correctly.
-//
-// Non needs_drop drop glue isn't codegen'd at all, so we don't try to check the IDs there. But we
-// do check it's not emitted which should help catch bugs if we do start generating it again in the
-// future.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: define{{.*}}4core3ptr47drop_in_place$LT$dyn$u20$core..marker..Send$GT$
-// CHECK-SAME:  {{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-// CHECK:       call i1 @llvm.type.test(ptr {{%.+}}, metadata !"_ZTSFvPu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops4drop4Dropu6regionEE")
-
-struct EmptyDrop;
-// CHECK-NOT: define{{.*}}4core3ptr{{[0-9]+}}drop_in_place$LT${{.*}}EmptyDrop$GT${{.*}}!type ![[TYPE1]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-struct PresentDrop;
-
-impl Drop for PresentDrop {
-    fn drop(&mut self) {}
-    // CHECK: define{{.*}}4core3ptr{{[0-9]+}}drop_in_place$LT${{.*}}PresentDrop$GT${{.*}}!type ![[TYPE1]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-}
-
-pub fn foo() {
-    let _ = Box::new(EmptyDrop) as Box<dyn Send>;
-    let _ = Box::new(PresentDrop) as Box<dyn Send>;
-}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvPu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops4drop4Dropu6regionEE"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs
deleted file mode 100644
index 7e60aafff68..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-function-types.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Verifies that type metadata identifiers for functions are emitted correctly
-// for function types.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-
-#![crate_type = "lib"]
-
-pub fn foo1(_: fn(i32) -> i32) {}
-// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: fn(i32) -> i32, _: fn(i32) -> i32) {}
-// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: fn(i32) -> i32, _: fn(i32) -> i32, _: fn(i32) -> i32) {}
-// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo4(_: &dyn Fn(i32) -> i32) {}
-// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo5(_: &dyn Fn(i32) -> i32, _: &dyn Fn(i32) -> i32) {}
-// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo6(_: &dyn Fn(i32) -> i32, _: &dyn Fn(i32) -> i32, _: &dyn Fn(i32) -> i32) {}
-// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo7(_: &dyn FnMut(i32) -> i32) {}
-// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo8(_: &dyn FnMut(i32) -> i32, _: &dyn FnMut(i32) -> i32) {}
-// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo9(_: &dyn FnMut(i32) -> i32, _: &dyn FnMut(i32) -> i32, _: &dyn FnMut(i32) -> i32) {}
-// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo10(_: &dyn FnOnce(i32) -> i32) {}
-// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo11(_: &dyn FnOnce(i32) -> i32, _: &dyn FnOnce(i32) -> i32) {}
-// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo12(_: &dyn FnOnce(i32) -> i32, _: &dyn FnOnce(i32) -> i32, _: &dyn FnOnce(i32) -> i32) {}
-// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvPFu3i32S_EE"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvPFu3i32S_ES0_E"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvPFu3i32S_ES0_S0_E"}
-// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function2FnIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEEE"}
-// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function2FnIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_E"}
-// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function2FnIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_S5_E"}
-// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function5FnMutIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEEE"}
-// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function5FnMutIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_E"}
-// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function5FnMutIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_S5_E"}
-// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnceIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEEE"}
-// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnceIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_E"}
-// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnceIu5tupleIu3i32EEu{{[0-9]+}}NtNtNtNtC{{[[:print:]]+}}_4core3ops8function6FnOnce6OutputIS0_ES_u6regionEES5_S5_E"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs
deleted file mode 100644
index 36d2e8c9f25..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-lifetimes.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Verifies that type metadata identifiers for functions are emitted correctly
-// for lifetimes/regions.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(type_alias_impl_trait)]
-
-extern crate core;
-
-pub type Type1 = impl Send;
-
-#[define_opaque(Type1)]
-pub fn foo<'a>()
-where
-    Type1: 'static,
-{
-    pub struct Foo<'a>(&'a i32);
-    pub struct Bar<'a, 'b>(&'a i32, &'b Foo<'b>);
-    let _: Type1 = Bar;
-}
-
-pub fn foo1(_: Type1) {}
-// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: Type1, _: Type1) {}
-// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: Type1, _: Type1, _: Type1) {}
-// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs
deleted file mode 100644
index 9d611777ff0..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-method-secondary-typeid.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-// Verifies that a secondary type metadata identifier is assigned to methods with their concrete
-// self so they can be used as function pointers.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-
-#![crate_type = "lib"]
-
-trait Trait1 {
-    fn foo(&self);
-}
-
-struct Type1;
-
-impl Trait1 for Type1 {
-    fn foo(&self) {}
-    // CHECK: define{{.*}}3foo{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u6regionEEE"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type1EE"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
deleted file mode 100644
index a8ba8db1be3..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-paths.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-// Verifies that type metadata identifiers for functions are emitted correctly
-// for paths.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-
-#![crate_type = "lib"]
-#![feature(type_alias_impl_trait)]
-
-extern crate core;
-
-pub type Type1 = impl Send;
-pub type Type2 = impl Send;
-pub type Type3 = impl Send;
-pub type Type4 = impl Send;
-
-#[define_opaque(Type1, Type2, Type4)]
-pub fn foo() {
-    // Type in extern path
-    extern "C" {
-        fn bar();
-    }
-    let _: Type1 = bar;
-
-    // Type in closure path
-    || {
-        pub struct Foo;
-        let _: Type2 = Foo;
-    };
-
-    // Type in const path
-    const {
-        pub struct Foo;
-        #[define_opaque(Type3)]
-        fn bar() -> Type3 {
-            Foo
-        }
-    };
-
-    // Type in impl path
-    struct Foo;
-    impl Foo {
-        fn bar(&self) {}
-    }
-    let _: Type4 = <Foo>::bar;
-}
-
-// Force arguments to be passed by using a reference. Otherwise, they may end up PassMode::Ignore
-
-pub fn foo1(_: &Type1) {}
-// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: &Type1, _: &Type1) {}
-// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: &Type1, _: &Type1, _: &Type1) {}
-// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo4(_: &Type2) {}
-// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo5(_: &Type2, _: &Type2) {}
-// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo6(_: &Type2, _: &Type2, _: &Type2) {}
-// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo7(_: &Type3) {}
-// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo8(_: &Type3, _: &Type3) {}
-// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo9(_: &Type3, _: &Type3, _: &Type3) {}
-// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo10(_: &Type4) {}
-// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo11(_: &Type4, _: &Type4) {}
-// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo12(_: &Type4, _: &Type4, _: &Type4) {}
-// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNFNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo10{{[{}][{}]}}extern{{[}][}]}}3barEE"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNFNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo10{{[{}][{}]}}extern{{[}][}]}}3barES0_E"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNFNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo10{{[{}][{}]}}extern{{[}][}]}}3barES0_S0_E"}
-// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNCNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo11{{[{}][{}]}}closure{{[}][}]}}3FooEE"}
-// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNCNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo11{{[{}][{}]}}closure{{[}][}]}}3FooES0_E"}
-// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNCNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo11{{[{}][{}]}}closure{{[}][}]}}3FooES0_S0_E"}
-// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNkNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo12{{[{}][{}]}}constant{{[}][}]}}3FooEE"}
-// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNkNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo12{{[{}][{}]}}constant{{[}][}]}}3FooES0_E"}
-// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtNkNvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo12{{[{}][{}]}}constant{{[}][}]}}3FooES0_S0_E"}
-// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNINvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo8{{[{}][{}]}}impl{{[}][}]}}3barEE"}
-// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNINvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo8{{[{}][{}]}}impl{{[}][}]}}3barES0_E"}
-// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NvNINvC{{[[:print:]]+}}_{{[[:print:]]+}}3foo8{{[{}][{}]}}impl{{[}][}]}}3barES0_S0_E"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs
deleted file mode 100644
index d37bb740f55..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-pointer-types.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-// Verifies that type metadata identifiers for functions are emitted correctly
-// for pointer types.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-
-#![crate_type = "lib"]
-
-pub fn foo1(_: &mut i32) {}
-// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: &mut i32, _: &i32) {}
-// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: &mut i32, _: &i32, _: &i32) {}
-// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo4(_: &i32) {}
-// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo5(_: &i32, _: &mut i32) {}
-// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo6(_: &i32, _: &mut i32, _: &mut i32) {}
-// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo7(_: *mut i32) {}
-// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo8(_: *mut i32, _: *const i32) {}
-// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo9(_: *mut i32, _: *const i32, _: *const i32) {}
-// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo10(_: *const i32) {}
-// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo11(_: *const i32, _: *mut i32) {}
-// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo12(_: *const i32, _: *mut i32, _: *mut i32) {}
-// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo13(_: fn(i32) -> i32) {}
-// CHECK: define{{.*}}5foo13{{.*}}!type ![[TYPE13:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo14(_: fn(i32) -> i32, _: fn(i32) -> i32) {}
-// CHECK: define{{.*}}5foo14{{.*}}!type ![[TYPE14:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo15(_: fn(i32) -> i32, _: fn(i32) -> i32, _: fn(i32) -> i32) {}
-// CHECK: define{{.*}}5foo15{{.*}}!type ![[TYPE15:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvU3mutu3refIu3i32EE"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvU3mutu3refIu3i32ES0_E"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvU3mutu3refIu3i32ES0_S0_E"}
-// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIu3i32EE"}
-// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIu3i32EU3mutS0_E"}
-// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIu3i32EU3mutS0_S1_E"}
-// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvPu3i32E"}
-// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvPu3i32PKS_E"}
-// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvPu3i32PKS_S2_E"}
-// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvPKu3i32E"}
-// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvPKu3i32PS_E"}
-// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvPKu3i32PS_S2_E"}
-// CHECK: ![[TYPE13]] = !{i64 0, !"_ZTSFvPFu3i32S_EE"}
-// CHECK: ![[TYPE14]] = !{i64 0, !"_ZTSFvPFu3i32S_ES0_E"}
-// CHECK: ![[TYPE15]] = !{i64 0, !"_ZTSFvPFu3i32S_ES0_S0_E"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
deleted file mode 100644
index 7d9e4d05872..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-primitive-types.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-// Verifies that type metadata identifiers for functions are emitted correctly
-// for primitive types.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-
-#![crate_type = "lib"]
-
-extern crate core;
-use core::ffi::*;
-
-pub fn foo1(_: ()) {}
-// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: (), _: c_void) {}
-// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: (), _: c_void, _: c_void) {}
-// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo4(_: *mut ()) {}
-// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo5(_: *mut (), _: *mut c_void) {}
-// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo6(_: *mut (), _: *mut c_void, _: *mut c_void) {}
-// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo7(_: *const ()) {}
-// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo8(_: *const (), _: *const c_void) {}
-// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo9(_: *const (), _: *const c_void, _: *const c_void) {}
-// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo10(_: bool) {}
-// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo11(_: bool, _: bool) {}
-// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo12(_: bool, _: bool, _: bool) {}
-// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo13(_: i8) {}
-// CHECK: define{{.*}}5foo13{{.*}}!type ![[TYPE13:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo14(_: i8, _: i8) {}
-// CHECK: define{{.*}}5foo14{{.*}}!type ![[TYPE14:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo15(_: i8, _: i8, _: i8) {}
-// CHECK: define{{.*}}5foo15{{.*}}!type ![[TYPE15:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo16(_: i16) {}
-// CHECK: define{{.*}}5foo16{{.*}}!type ![[TYPE16:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo17(_: i16, _: i16) {}
-// CHECK: define{{.*}}5foo17{{.*}}!type ![[TYPE17:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo18(_: i16, _: i16, _: i16) {}
-// CHECK: define{{.*}}5foo18{{.*}}!type ![[TYPE18:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo19(_: i32) {}
-// CHECK: define{{.*}}5foo19{{.*}}!type ![[TYPE19:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo20(_: i32, _: i32) {}
-// CHECK: define{{.*}}5foo20{{.*}}!type ![[TYPE20:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo21(_: i32, _: i32, _: i32) {}
-// CHECK: define{{.*}}5foo21{{.*}}!type ![[TYPE21:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo22(_: i64) {}
-// CHECK: define{{.*}}5foo22{{.*}}!type ![[TYPE22:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo23(_: i64, _: i64) {}
-// CHECK: define{{.*}}5foo23{{.*}}!type ![[TYPE23:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo24(_: i64, _: i64, _: i64) {}
-// CHECK: define{{.*}}5foo24{{.*}}!type ![[TYPE24:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo25(_: i128) {}
-// CHECK: define{{.*}}5foo25{{.*}}!type ![[TYPE25:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo26(_: i128, _: i128) {}
-// CHECK: define{{.*}}5foo26{{.*}}!type ![[TYPE26:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo27(_: i128, _: i128, _: i128) {}
-// CHECK: define{{.*}}5foo27{{.*}}!type ![[TYPE27:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo28(_: isize) {}
-// CHECK: define{{.*}}5foo28{{.*}}!type ![[TYPE28:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo29(_: isize, _: isize) {}
-// CHECK: define{{.*}}5foo29{{.*}}!type ![[TYPE29:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo30(_: isize, _: isize, _: isize) {}
-// CHECK: define{{.*}}5foo30{{.*}}!type ![[TYPE30:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo31(_: u8) {}
-// CHECK: define{{.*}}5foo31{{.*}}!type ![[TYPE31:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo32(_: u8, _: u8) {}
-// CHECK: define{{.*}}5foo32{{.*}}!type ![[TYPE32:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo33(_: u8, _: u8, _: u8) {}
-// CHECK: define{{.*}}5foo33{{.*}}!type ![[TYPE33:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo34(_: u16) {}
-// CHECK: define{{.*}}5foo34{{.*}}!type ![[TYPE34:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo35(_: u16, _: u16) {}
-// CHECK: define{{.*}}5foo35{{.*}}!type ![[TYPE35:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo36(_: u16, _: u16, _: u16) {}
-// CHECK: define{{.*}}5foo36{{.*}}!type ![[TYPE36:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo37(_: u32) {}
-// CHECK: define{{.*}}5foo37{{.*}}!type ![[TYPE37:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo38(_: u32, _: u32) {}
-// CHECK: define{{.*}}5foo38{{.*}}!type ![[TYPE38:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo39(_: u32, _: u32, _: u32) {}
-// CHECK: define{{.*}}5foo39{{.*}}!type ![[TYPE39:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo40(_: u64) {}
-// CHECK: define{{.*}}5foo40{{.*}}!type ![[TYPE40:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo41(_: u64, _: u64) {}
-// CHECK: define{{.*}}5foo41{{.*}}!type ![[TYPE41:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo42(_: u64, _: u64, _: u64) {}
-// CHECK: define{{.*}}5foo42{{.*}}!type ![[TYPE42:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo43(_: u128) {}
-// CHECK: define{{.*}}5foo43{{.*}}!type ![[TYPE43:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo44(_: u128, _: u128) {}
-// CHECK: define{{.*}}5foo44{{.*}}!type ![[TYPE44:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo45(_: u128, _: u128, _: u128) {}
-// CHECK: define{{.*}}5foo45{{.*}}!type ![[TYPE45:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo46(_: usize) {}
-// CHECK: define{{.*}}5foo46{{.*}}!type ![[TYPE46:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo47(_: usize, _: usize) {}
-// CHECK: define{{.*}}5foo47{{.*}}!type ![[TYPE47:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo48(_: usize, _: usize, _: usize) {}
-// CHECK: define{{.*}}5foo48{{.*}}!type ![[TYPE48:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo49(_: f32) {}
-// CHECK: define{{.*}}5foo49{{.*}}!type ![[TYPE49:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo50(_: f32, _: f32) {}
-// CHECK: define{{.*}}5foo50{{.*}}!type ![[TYPE50:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo51(_: f32, _: f32, _: f32) {}
-// CHECK: define{{.*}}5foo51{{.*}}!type ![[TYPE51:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo52(_: f64) {}
-// CHECK: define{{.*}}5foo52{{.*}}!type ![[TYPE52:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo53(_: f64, _: f64) {}
-// CHECK: define{{.*}}5foo53{{.*}}!type ![[TYPE53:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo54(_: f64, _: f64, _: f64) {}
-// CHECK: define{{.*}}5foo54{{.*}}!type ![[TYPE54:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo55(_: char) {}
-// CHECK: define{{.*}}5foo55{{.*}}!type ![[TYPE55:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo56(_: char, _: char) {}
-// CHECK: define{{.*}}5foo56{{.*}}!type ![[TYPE56:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo57(_: char, _: char, _: char) {}
-// CHECK: define{{.*}}5foo57{{.*}}!type ![[TYPE57:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo58(_: &str) {}
-// CHECK: define{{.*}}5foo58{{.*}}!type ![[TYPE58:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo59(_: &str, _: &str) {}
-// CHECK: define{{.*}}5foo59{{.*}}!type ![[TYPE59:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo60(_: &str, _: &str, _: &str) {}
-// CHECK: define{{.*}}5foo60{{.*}}!type ![[TYPE60:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvvE"}
-// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvPvE"}
-// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvPvS_E"}
-// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvPvS_S_E"}
-// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvPKvE"}
-// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvPKvS0_E"}
-// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvPKvS0_S0_E"}
-// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvbE"}
-// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvbbE"}
-// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvbbbE"}
-// CHECK: ![[TYPE13]] = !{i64 0, !"_ZTSFvu2i8E"}
-// CHECK: ![[TYPE14]] = !{i64 0, !"_ZTSFvu2i8S_E"}
-// CHECK: ![[TYPE15]] = !{i64 0, !"_ZTSFvu2i8S_S_E"}
-// CHECK: ![[TYPE16]] = !{i64 0, !"_ZTSFvu3i16E"}
-// CHECK: ![[TYPE17]] = !{i64 0, !"_ZTSFvu3i16S_E"}
-// CHECK: ![[TYPE18]] = !{i64 0, !"_ZTSFvu3i16S_S_E"}
-// CHECK: ![[TYPE19]] = !{i64 0, !"_ZTSFvu3i32E"}
-// CHECK: ![[TYPE20]] = !{i64 0, !"_ZTSFvu3i32S_E"}
-// CHECK: ![[TYPE21]] = !{i64 0, !"_ZTSFvu3i32S_S_E"}
-// CHECK: ![[TYPE22]] = !{i64 0, !"_ZTSFvu3i64E"}
-// CHECK: ![[TYPE23]] = !{i64 0, !"_ZTSFvu3i64S_E"}
-// CHECK: ![[TYPE24]] = !{i64 0, !"_ZTSFvu3i64S_S_E"}
-// CHECK: ![[TYPE25]] = !{i64 0, !"_ZTSFvu4i128E"}
-// CHECK: ![[TYPE26]] = !{i64 0, !"_ZTSFvu4i128S_E"}
-// CHECK: ![[TYPE27]] = !{i64 0, !"_ZTSFvu4i128S_S_E"}
-// CHECK: ![[TYPE28]] = !{i64 0, !"_ZTSFvu5isizeE"}
-// CHECK: ![[TYPE29]] = !{i64 0, !"_ZTSFvu5isizeS_E"}
-// CHECK: ![[TYPE30]] = !{i64 0, !"_ZTSFvu5isizeS_S_E"}
-// CHECK: ![[TYPE31]] = !{i64 0, !"_ZTSFvu2u8E"}
-// CHECK: ![[TYPE32]] = !{i64 0, !"_ZTSFvu2u8S_E"}
-// CHECK: ![[TYPE33]] = !{i64 0, !"_ZTSFvu2u8S_S_E"}
-// CHECK: ![[TYPE34]] = !{i64 0, !"_ZTSFvu3u16E"}
-// CHECK: ![[TYPE35]] = !{i64 0, !"_ZTSFvu3u16S_E"}
-// CHECK: ![[TYPE36]] = !{i64 0, !"_ZTSFvu3u16S_S_E"}
-// CHECK: ![[TYPE37]] = !{i64 0, !"_ZTSFvu3u32E"}
-// CHECK: ![[TYPE38]] = !{i64 0, !"_ZTSFvu3u32S_E"}
-// CHECK: ![[TYPE39]] = !{i64 0, !"_ZTSFvu3u32S_S_E"}
-// CHECK: ![[TYPE40]] = !{i64 0, !"_ZTSFvu3u64E"}
-// CHECK: ![[TYPE41]] = !{i64 0, !"_ZTSFvu3u64S_E"}
-// CHECK: ![[TYPE42]] = !{i64 0, !"_ZTSFvu3u64S_S_E"}
-// CHECK: ![[TYPE43]] = !{i64 0, !"_ZTSFvu4u128E"}
-// CHECK: ![[TYPE44]] = !{i64 0, !"_ZTSFvu4u128S_E"}
-// CHECK: ![[TYPE45]] = !{i64 0, !"_ZTSFvu4u128S_S_E"}
-// CHECK: ![[TYPE46]] = !{i64 0, !"_ZTSFvu5usizeE"}
-// CHECK: ![[TYPE47]] = !{i64 0, !"_ZTSFvu5usizeS_E"}
-// CHECK: ![[TYPE48]] = !{i64 0, !"_ZTSFvu5usizeS_S_E"}
-// CHECK: ![[TYPE49]] = !{i64 0, !"_ZTSFvfE"}
-// CHECK: ![[TYPE50]] = !{i64 0, !"_ZTSFvffE"}
-// CHECK: ![[TYPE51]] = !{i64 0, !"_ZTSFvfffE"}
-// CHECK: ![[TYPE52]] = !{i64 0, !"_ZTSFvdE"}
-// CHECK: ![[TYPE53]] = !{i64 0, !"_ZTSFvddE"}
-// CHECK: ![[TYPE54]] = !{i64 0, !"_ZTSFvdddE"}
-// CHECK: ![[TYPE55]] = !{i64 0, !"_ZTSFvu4charE"}
-// CHECK: ![[TYPE56]] = !{i64 0, !"_ZTSFvu4charS_E"}
-// CHECK: ![[TYPE57]] = !{i64 0, !"_ZTSFvu4charS_S_E"}
-// CHECK: ![[TYPE58]] = !{i64 0, !"_ZTSFvu3refIu3strEE"}
-// CHECK: ![[TYPE59]] = !{i64 0, !"_ZTSFvu3refIu3strES0_E"}
-// CHECK: ![[TYPE60]] = !{i64 0, !"_ZTSFvu3refIu3strES0_S0_E"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs
deleted file mode 100644
index 0f97c70f3f9..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-repr-transparent-types.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Verifies that type metadata identifiers for functions are emitted correctly
-// for repr transparent types.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-
-#![crate_type = "lib"]
-
-extern crate core;
-use core::ffi::*;
-use std::marker::PhantomData;
-
-struct Foo(i32);
-
-// repr(transparent) user-defined type
-#[repr(transparent)]
-pub struct Type1 {
-    member1: (),
-    member2: PhantomData<i32>,
-    member3: Foo,
-}
-
-// Self-referencing repr(transparent) user-defined type
-#[repr(transparent)]
-pub struct Type2<'a> {
-    member1: (),
-    member2: PhantomData<i32>,
-    member3: &'a Type2<'a>,
-}
-
-pub struct Bar(i32);
-
-// repr(transparent) user-defined generic type
-#[repr(transparent)]
-pub struct Type3<T>(T);
-
-// repr(transparent) wrapper which engages in self-reference
-#[repr(transparent)]
-pub struct Type4(Type4Helper<Type4>);
-#[repr(transparent)]
-pub struct Type4Helper<T>(*mut T);
-
-pub fn foo1(_: Type1) {}
-// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: Type1, _: Type1) {}
-// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: Type1, _: Type1, _: Type1) {}
-// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo4(_: Type2) {}
-// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo5(_: Type2, _: Type2) {}
-// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo6(_: Type2, _: Type2, _: Type2) {}
-// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo7(_: Type3<Bar>) {}
-// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo8(_: Type3<Bar>, _: Type3<Bar>) {}
-// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo9(_: Type3<Bar>, _: Type3<Bar>, _: Type3<Bar>) {}
-// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo10(_: Type4) {}
-// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo11(_: Type4, _: Type4) {}
-// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo12(_: Type4, _: Type4, _: Type4) {}
-// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3FooE"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3FooS_E"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3FooS_S_E"}
-// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIvEE"}
-// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIvES_E"}
-// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIvES_S_E"}
-// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3BarE"}
-// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3BarS_E"}
-// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}3BarS_S_E"}
-// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvPu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4E"}
-// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvPu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4S0_E"}
-// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvPu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4S0_S0_E"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs
deleted file mode 100644
index bdee3f47a83..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-sequence-types.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// Verifies that type metadata identifiers for functions are emitted correctly
-// for sequence types.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-
-#![crate_type = "lib"]
-
-pub fn foo1(_: (i32, i32)) {}
-// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: (i32, i32), _: (i32, i32)) {}
-// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: (i32, i32), _: (i32, i32), _: (i32, i32)) {}
-// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo4(_: [i32; 32]) {}
-// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo5(_: [i32; 32], _: [i32; 32]) {}
-// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo6(_: [i32; 32], _: [i32; 32], _: [i32; 32]) {}
-// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo7(_: &[i32]) {}
-// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo8(_: &[i32], _: &[i32]) {}
-// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo9(_: &[i32], _: &[i32], _: &[i32]) {}
-// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu5tupleIu3i32S_EE"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu5tupleIu3i32S_ES0_E"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu5tupleIu3i32S_ES0_S0_E"}
-// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvA32u3i32E"}
-// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvA32u3i32S0_E"}
-// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvA32u3i32S0_S0_E"}
-// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu3refIu5sliceIu3i32EEE"}
-// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu3refIu5sliceIu3i32EES1_E"}
-// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu3refIu5sliceIu3i32EES1_S1_E"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs
deleted file mode 100644
index 55e816178f8..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-trait-types.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-// Verifies that type metadata identifiers for functions are emitted correctly
-// for trait types.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-
-#![crate_type = "lib"]
-
-extern crate core;
-
-pub trait Trait1 {
-    fn foo(&self);
-}
-
-#[derive(Clone, Copy)]
-pub struct Type1;
-
-impl Trait1 for Type1 {
-    fn foo(&self) {}
-}
-
-pub trait Trait2<T> {
-    fn bar(&self);
-}
-
-pub struct Type2;
-
-impl Trait2<i32> for Type2 {
-    fn bar(&self) {}
-}
-
-pub trait Trait3<T> {
-    fn baz(&self, _: &T);
-}
-
-pub struct Type3;
-
-impl<T, U> Trait3<U> for T {
-    fn baz(&self, _: &U) {}
-}
-
-pub trait Trait4<'a, T> {
-    type Output: 'a;
-    fn qux(&self, _: &T) -> Self::Output;
-}
-
-pub struct Type4;
-
-impl<'a, T, U> Trait4<'a, U> for T {
-    type Output = &'a i32;
-    fn qux(&self, _: &U) -> Self::Output {
-        &0
-    }
-}
-
-pub trait Trait5<T, const N: usize> {
-    fn quux(&self, _: &[T; N]);
-}
-
-#[derive(Copy, Clone)]
-pub struct Type5;
-
-impl<T, U, const N: usize> Trait5<U, N> for T {
-    fn quux(&self, _: &[U; N]) {}
-}
-
-pub fn foo1(_: &dyn Send) {}
-// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: &dyn Send, _: &dyn Send) {}
-// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: &dyn Send, _: &dyn Send, _: &dyn Send) {}
-// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo4(_: &(dyn Send + Sync)) {}
-// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo5(_: &(dyn Send + Sync), _: &(dyn Sync + Send)) {}
-// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo6(_: &(dyn Send + Sync), _: &(dyn Sync + Send), _: &(dyn Sync + Send)) {}
-// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo7(_: &(dyn Trait1 + Send)) {}
-// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo8(_: &(dyn Trait1 + Send), _: &(dyn Trait1 + Send)) {}
-// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo9(_: &(dyn Trait1 + Send), _: &(dyn Trait1 + Send), _: &(dyn Trait1 + Send)) {}
-// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo10(_: &(dyn Trait1 + Send + Sync)) {}
-// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo11(_: &(dyn Trait1 + Send + Sync), _: &(dyn Trait1 + Sync + Send)) {}
-// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo12(
-    _: &(dyn Trait1 + Send + Sync),
-    _: &(dyn Trait1 + Sync + Send),
-    _: &(dyn Trait1 + Sync + Send),
-) {
-}
-// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo13(_: &dyn Trait1) {}
-// CHECK: define{{.*}}5foo13{{.*}}!type ![[TYPE13:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo14(_: &dyn Trait1, _: &dyn Trait1) {}
-// CHECK: define{{.*}}5foo14{{.*}}!type ![[TYPE14:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo15(_: &dyn Trait1, _: &dyn Trait1, _: &dyn Trait1) {}
-// CHECK: define{{.*}}5foo15{{.*}}!type ![[TYPE15:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo16<T>(_: &dyn Trait2<T>) {}
-pub fn bar16() {
-    let a = Type2;
-    foo16(&a);
-}
-// CHECK: define{{.*}}5foo16{{.*}}!type ![[TYPE16:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo17<T>(_: &dyn Trait2<T>, _: &dyn Trait2<T>) {}
-pub fn bar17() {
-    let a = Type2;
-    foo17(&a, &a);
-}
-// CHECK: define{{.*}}5foo17{{.*}}!type ![[TYPE17:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo18<T>(_: &dyn Trait2<T>, _: &dyn Trait2<T>, _: &dyn Trait2<T>) {}
-pub fn bar18() {
-    let a = Type2;
-    foo18(&a, &a, &a);
-}
-// CHECK: define{{.*}}5foo18{{.*}}!type ![[TYPE18:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo19(_: &dyn Trait3<Type3>) {}
-// CHECK: define{{.*}}5foo19{{.*}}!type ![[TYPE19:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo20(_: &dyn Trait3<Type3>, _: &dyn Trait3<Type3>) {}
-// CHECK: define{{.*}}5foo20{{.*}}!type ![[TYPE20:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo21(_: &dyn Trait3<Type3>, _: &dyn Trait3<Type3>, _: &dyn Trait3<Type3>) {}
-// CHECK: define{{.*}}5foo21{{.*}}!type ![[TYPE21:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo22<'a>(_: &dyn Trait4<'a, Type4, Output = &'a i32>) {}
-// CHECK: define{{.*}}5foo22{{.*}}!type ![[TYPE22:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo23<'a>(
-    _: &dyn Trait4<'a, Type4, Output = &'a i32>,
-    _: &dyn Trait4<'a, Type4, Output = &'a i32>,
-) {
-}
-// CHECK: define{{.*}}5foo23{{.*}}!type ![[TYPE23:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo24<'a>(
-    _: &dyn Trait4<'a, Type4, Output = &'a i32>,
-    _: &dyn Trait4<'a, Type4, Output = &'a i32>,
-    _: &dyn Trait4<'a, Type4, Output = &'a i32>,
-) {
-}
-// CHECK: define{{.*}}5foo24{{.*}}!type ![[TYPE24:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo25(_: &dyn Trait5<Type5, 32>) {}
-// CHECK: define{{.*}}5foo25{{.*}}!type ![[TYPE25:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo26(_: &dyn Trait5<Type5, 32>, _: &dyn Trait5<Type5, 32>) {}
-// CHECK: define{{.*}}5foo26{{.*}}!type ![[TYPE26:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo27(_: &dyn Trait5<Type5, 32>, _: &dyn Trait5<Type5, 32>, _: &dyn Trait5<Type5, 32>) {}
-// CHECK: define{{.*}}5foo27{{.*}}!type ![[TYPE27:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE13]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u6regionEEE"}
-// CHECK: ![[TYPE16]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait2Iu3i32Eu6regionEEE"}
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEEE"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEES2_E"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEES2_S2_E"}
-// FIXME(rcvalle): Enforce autotraits ordering when encoding (e.g., alphabetical order)
-// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEEE"}
-// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEES3_E"}
-// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEES3_S3_E"}
-// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEEE"}
-// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEES3_E"}
-// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker4Sendu6regionEES3_S3_E"}
-// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEEE"}
-// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEES4_E"}
-// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u{{[0-9]+}}NtNtC{{[[:print:]]+}}_4core6marker{{(4Send|4Sync)}}u6regionEES4_S4_E"}
-// CHECK: ![[TYPE14]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u6regionEES2_E"}
-// CHECK: ![[TYPE15]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait1u6regionEES2_S2_E"}
-// CHECK: ![[TYPE17]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait2Iu3i32Eu6regionEES3_E"}
-// CHECK: ![[TYPE18]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait2Iu3i32Eu6regionEES3_S3_E"}
-// CHECK: ![[TYPE19]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait3Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type3Eu6regionEEE"}
-// CHECK: ![[TYPE20]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait3Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type3Eu6regionEES3_E"}
-// CHECK: ![[TYPE21]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait3Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type3Eu6regionEES3_S3_E"}
-// CHECK: ![[TYPE22]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait4Iu6regionu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4Eu{{[0-9]+}}NtNtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait46OutputIS_S0_Eu3refIu3i32ES_EEE"}
-// CHECK: ![[TYPE23]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait4Iu6regionu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4Eu{{[0-9]+}}NtNtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait46OutputIS_S0_Eu3refIu3i32ES_EES6_E"}
-// CHECK: ![[TYPE24]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait4Iu6regionu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type4Eu{{[0-9]+}}NtNtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait46OutputIS_S0_Eu3refIu3i32ES_EES6_S6_E"}
-// CHECK: ![[TYPE25]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait5Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type5Lu5usize32EEu6regionEEE"}
-// CHECK: ![[TYPE26]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait5Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type5Lu5usize32EEu6regionEES5_E"}
-// CHECK: ![[TYPE27]] = !{i64 0, !"_ZTSFvu3refIu3dynIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Trait5Iu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Type5Lu5usize32EEu6regionEES5_S5_E"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs
deleted file mode 100644
index c1f3ca61afe..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-user-defined-types.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Verifies that type metadata identifiers for functions are emitted correctly
-// for user-defined types.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-
-#![crate_type = "lib"]
-#![feature(extern_types)]
-
-pub struct Struct1<T> {
-    member1: T,
-}
-
-pub enum Enum1<T> {
-    Variant1(T),
-}
-
-pub union Union1<T> {
-    member1: std::mem::ManuallyDrop<T>,
-}
-
-extern "C" {
-    pub type type1;
-}
-
-pub fn foo1(_: &Struct1<i32>) {}
-// CHECK: define{{.*}}4foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: &Struct1<i32>, _: &Struct1<i32>) {}
-// CHECK: define{{.*}}4foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: &Struct1<i32>, _: &Struct1<i32>, _: &Struct1<i32>) {}
-// CHECK: define{{.*}}4foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo4(_: &Enum1<i32>) {}
-// CHECK: define{{.*}}4foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo5(_: &Enum1<i32>, _: &Enum1<i32>) {}
-// CHECK: define{{.*}}4foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo6(_: &Enum1<i32>, _: &Enum1<i32>, _: &Enum1<i32>) {}
-// CHECK: define{{.*}}4foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo7(_: &Union1<i32>) {}
-// CHECK: define{{.*}}4foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo8(_: &Union1<i32>, _: &Union1<i32>) {}
-// CHECK: define{{.*}}4foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo9(_: &Union1<i32>, _: &Union1<i32>, _: &Union1<i32>) {}
-// CHECK: define{{.*}}4foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo10(_: *mut type1) {}
-// CHECK: define{{.*}}5foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo11(_: *mut type1, _: *mut type1) {}
-// CHECK: define{{.*}}5foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo12(_: *mut type1, _: *mut type1, _: *mut type1) {}
-// CHECK: define{{.*}}5foo12{{.*}}!type ![[TYPE12:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}7Struct1Iu3i32EEE"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}7Struct1Iu3i32EES1_E"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}7Struct1Iu3i32EES1_S1_E"}
-// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Enum1Iu3i32EEE"}
-// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Enum1Iu3i32EES1_E"}
-// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}5Enum1Iu3i32EES1_S1_E"}
-// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Union1Iu3i32EEE"}
-// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Union1Iu3i32EES1_E"}
-// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvu3refIu{{[0-9]+}}NtC{{[[:print:]]+}}_{{[[:print:]]+}}6Union1Iu3i32EES1_S1_E"}
-// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvP5type1E"}
-// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvP5type1S0_E"}
-// CHECK: ![[TYPE12]] = !{i64 0, !"_ZTSFvP5type1S0_S0_E"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs
deleted file mode 100644
index 32637b64b3e..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-generalized.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Verifies that generalized type metadata for functions are emitted.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-generalize-pointers
-
-#![crate_type = "lib"]
-
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}foo
-    // CHECK-SAME:  {{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_E.generalized")
-    f(arg)
-}
-
-pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}bar
-    // CHECK-SAME:  {{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_E.generalized")
-    f(arg1, arg2)
-}
-
-pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}baz
-    // CHECK-SAME:  {{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_S_E.generalized")
-    f(arg1, arg2, arg3)
-}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFu3i32PKvS_E.generalized"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFu3i32PKvS_S_E.generalized"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFu3i32PKvS_S_S_E.generalized"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
deleted file mode 100644
index 51121b0aef1..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized-generalized.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Verifies that normalized and generalized type metadata for functions are emitted.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers -Zsanitizer-cfi-generalize-pointers
-
-#![crate_type = "lib"]
-
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}foo
-    // CHECK-SAME:  {{.*}}![[TYPE1:[0-9]+]]
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_E.normalized.generalized")
-    f(arg)
-}
-
-pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}bar
-    // CHECK-SAME:  {{.*}}![[TYPE2:[0-9]+]]
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_E.normalized.generalized")
-    f(arg1, arg2)
-}
-
-pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}baz
-    // CHECK-SAME:  {{.*}}![[TYPE3:[0-9]+]]
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_S_E.normalized.generalized")
-    f(arg1, arg2, arg3)
-}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFu3i32PKvS_E.normalized.generalized"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFu3i32PKvS_S_E.normalized.generalized"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFu3i32PKvS_S_S_E.normalized.generalized"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs
deleted file mode 100644
index 1cfdd23006e..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi-normalized.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Verifies that normalized type metadata for functions are emitted.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers
-
-#![crate_type = "lib"]
-
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}foo
-    // CHECK-SAME:  {{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_E.normalized")
-    f(arg)
-}
-
-pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}bar
-    // CHECK-SAME:  {{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_E.normalized")
-    f(arg1, arg2)
-}
-
-pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}baz
-    // CHECK-SAME:  {{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_S_E.normalized")
-    f(arg1, arg2, arg3)
-}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFu3i32PFS_S_ES_E.normalized"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFu3i32PFS_S_S_ES_S_E.normalized"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFu3i32PFS_S_S_S_ES_S_S_E.normalized"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs
deleted file mode 100644
index 56ab1ce4b35..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-itanium-cxx-abi.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Verifies that type metadata for functions are emitted.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi
-
-#![crate_type = "lib"]
-
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}foo
-    // CHECK-SAME:  {{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_E")
-    f(arg)
-}
-
-pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}bar
-    // CHECK-SAME:  {{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_E")
-    f(arg1, arg2)
-}
-
-pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}baz
-    // CHECK-SAME:  {{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%0}}, metadata !"_ZTSFu3i32S_S_S_E")
-    f(arg1, arg2, arg3)
-}
-
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFu3i32PFS_S_ES_E"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFu3i32PFS_S_S_ES_S_E"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFu3i32PFS_S_S_S_ES_S_S_E"}
diff --git a/tests/codegen/sanitizer/cfi/emit-type-metadata-trait-objects.rs b/tests/codegen/sanitizer/cfi/emit-type-metadata-trait-objects.rs
deleted file mode 100644
index 0e57ce322d1..00000000000
--- a/tests/codegen/sanitizer/cfi/emit-type-metadata-trait-objects.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-// Verifies that type metadata identifiers for trait objects are emitted correctly.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Copt-level=0 -Ctarget-feature=-crt-static -Zsanitizer=cfi
-
-#![crate_type = "lib"]
-
-pub trait Trait1 {
-    fn foo(&self);
-}
-
-#[derive(Clone, Copy)]
-pub struct Type1;
-
-impl Trait1 for Type1 {
-    fn foo(&self) {}
-}
-
-pub trait Trait2<T> {
-    fn bar(&self);
-}
-
-pub struct Type2;
-
-impl Trait2<i32> for Type2 {
-    fn bar(&self) {}
-}
-
-pub trait Trait3<T> {
-    fn baz(&self, _: &T);
-}
-
-pub struct Type3;
-
-impl<T, U> Trait3<U> for T {
-    fn baz(&self, _: &U) {}
-}
-
-pub trait Trait4<'a, T> {
-    type Output: 'a;
-    fn qux(&self, _: &T) -> Self::Output;
-}
-
-pub struct Type4;
-
-impl<'a, T, U> Trait4<'a, U> for T {
-    type Output = &'a i32;
-    fn qux(&self, _: &U) -> Self::Output {
-        &0
-    }
-}
-
-pub trait Trait5<T, const N: usize> {
-    fn quux(&self, _: &[T; N]);
-}
-
-#[derive(Copy, Clone)]
-pub struct Type5;
-
-impl<T, U, const N: usize> Trait5<U, N> for T {
-    fn quux(&self, _: &[U; N]) {}
-}
-
-pub fn foo1(a: &dyn Trait1) {
-    a.foo();
-    // CHECK-LABEL: define{{.*}}4foo1{{.*}}!type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE1:[[:print:]]+]]")
-}
-
-pub fn bar1() {
-    let a = Type1;
-    let b = &a as &dyn Trait1;
-    b.foo();
-    // CHECK-LABEL: define{{.*}}4bar1{{.*}}!type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE2:[[:print:]]+]]")
-}
-
-pub fn foo2<T>(a: &dyn Trait2<T>) {
-    a.bar();
-    // CHECK-LABEL: define{{.*}}4foo2{{.*}}!type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE2:[[:print:]]+]]")
-}
-
-pub fn bar2() {
-    let a = Type2;
-    foo2(&a);
-    let b = &a as &dyn Trait2<i32>;
-    b.bar();
-    // CHECK-LABEL: define{{.*}}4bar2{{.*}}!type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE2:[[:print:]]+]]")
-}
-
-pub fn foo3(a: &dyn Trait3<Type3>) {
-    let b = Type3;
-    a.baz(&b);
-    // CHECK-LABEL: define{{.*}}4foo3{{.*}}!type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE3:[[:print:]]+]]")
-}
-
-pub fn bar3() {
-    let a = Type3;
-    foo3(&a);
-    let b = &a as &dyn Trait3<Type3>;
-    b.baz(&a);
-    // CHECK-LABEL: define{{.*}}4bar3{{.*}}!type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE3:[[:print:]]+]]")
-}
-
-pub fn foo4<'a>(a: &dyn Trait4<'a, Type4, Output = &'a i32>) {
-    let b = Type4;
-    a.qux(&b);
-    // CHECK-LABEL: define{{.*}}4foo4{{.*}}!type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE4:[[:print:]]+]]")
-}
-
-pub fn bar4<'a>() {
-    let a = Type4;
-    foo4(&a);
-    let b = &a as &dyn Trait4<'a, Type4, Output = &'a i32>;
-    b.qux(&a);
-    // CHECK-LABEL: define{{.*}}4bar4{{.*}}!type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE4:[[:print:]]+]]")
-}
-
-pub fn foo5(a: &dyn Trait5<Type5, 32>) {
-    let b = &[Type5; 32];
-    a.quux(&b);
-    // CHECK-LABEL: define{{.*}}4foo5{{.*}}!type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE5:[[:print:]]+]]")
-}
-
-pub fn bar5() {
-    let a = &[Type5; 32];
-    foo5(&a);
-    let b = &a as &dyn Trait5<Type5, 32>;
-    b.quux(&a);
-    // CHECK-LABEL: define{{.*}}4bar5{{.*}}!type !{{[0-9]+}}
-    // CHECK:       call i1 @llvm.type.test(ptr {{%f|%[0-9]}}, metadata !"[[TYPE5:[[:print:]]+]]")
-}
-
-// CHECK: !{{[0-9]+}} = !{i64 0, !"[[TYPE1]]"}
-// CHECK: !{{[0-9]+}} = !{i64 0, !"[[TYPE2]]"}
-// CHECK: !{{[0-9]+}} = !{i64 0, !"[[TYPE3]]"}
-// CHECK: !{{[0-9]+}} = !{i64 0, !"[[TYPE4]]"}
-// CHECK: !{{[0-9]+}} = !{i64 0, !"[[TYPE5]]"}
diff --git a/tests/codegen/sanitizer/cfi/external_weak_symbols.rs b/tests/codegen/sanitizer/cfi/external_weak_symbols.rs
deleted file mode 100644
index 00e9b5029af..00000000000
--- a/tests/codegen/sanitizer/cfi/external_weak_symbols.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Verifies that type metadata identifiers for for weakly-linked symbols are
-// emitted correctly.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clinker-plugin-lto -Copt-level=0 -Zsanitizer=cfi -Ctarget-feature=-crt-static
-#![crate_type = "bin"]
-#![feature(linkage)]
-
-unsafe extern "C" {
-    #[linkage = "extern_weak"]
-    static FOO: Option<unsafe extern "C" fn(f64) -> ()>;
-}
-// CHECK: @_rust_extern_with_linkage_FOO = internal global ptr @FOO
-
-fn main() {
-    unsafe {
-        if let Some(method) = FOO {
-            method(4.2);
-            // CHECK: call i1 @llvm.type.test(ptr {{%method|%0}}, metadata !"_ZTSFvdE")
-        }
-    }
-}
-
-// CHECK: declare !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}} extern_weak void @FOO(double) unnamed_addr #{{[0-9]+}}
diff --git a/tests/codegen/sanitizer/cfi/generalize-pointers.rs b/tests/codegen/sanitizer/cfi/generalize-pointers.rs
deleted file mode 100644
index 57004da6f8e..00000000000
--- a/tests/codegen/sanitizer/cfi/generalize-pointers.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Verifies that pointer types are generalized.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-generalize-pointers -Copt-level=0
-
-#![crate_type = "lib"]
-
-extern crate core;
-
-pub fn foo0(_: &mut i32) {}
-// CHECK: define{{.*}}foo0{{.*}}!type ![[TYPE0:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo1(_: &mut i32, _: &mut i32) {}
-// CHECK: define{{.*}}foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo2(_: &mut i32, _: &mut i32, _: &mut i32) {}
-// CHECK: define{{.*}}foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo3(_: &i32) {}
-// CHECK: define{{.*}}foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo4(_: &i32, _: &i32) {}
-// CHECK: define{{.*}}foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo5(_: &i32, _: &i32, _: &i32) {}
-// CHECK: define{{.*}}foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo6(_: *mut i32) {}
-// CHECK: define{{.*}}foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo7(_: *mut i32, _: *mut i32) {}
-// CHECK: define{{.*}}foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo8(_: *mut i32, _: *mut i32, _: *mut i32) {}
-// CHECK: define{{.*}}foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo9(_: *const i32) {}
-// CHECK: define{{.*}}foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo10(_: *const i32, _: *const i32) {}
-// CHECK: define{{.*}}foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-pub fn foo11(_: *const i32, _: *const i32, _: *const i32) {}
-// CHECK: define{{.*}}foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE0]] = !{i64 0, !"_ZTSFvU3mutu3refIvEE.generalized"}
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvU3mutu3refIvES0_E.generalized"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvU3mutu3refIvES0_S0_E.generalized"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu3refIvEE.generalized"}
-// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3refIvES_E.generalized"}
-// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3refIvES_S_E.generalized"}
-// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFvPvE.generalized"}
-// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFvPvS_E.generalized"}
-// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFvPvS_S_E.generalized"}
-// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFvPKvE.generalized"}
-// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFvPKvS0_E.generalized"}
-// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFvPKvS0_S0_E.generalized"}
diff --git a/tests/codegen/sanitizer/cfi/normalize-integers.rs b/tests/codegen/sanitizer/cfi/normalize-integers.rs
deleted file mode 100644
index 770ee4e64e0..00000000000
--- a/tests/codegen/sanitizer/cfi/normalize-integers.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Verifies that integer types are normalized.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Cno-prepopulate-passes -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers -Copt-level=0
-
-#![crate_type = "lib"]
-
-extern crate core;
-
-pub fn foo0(_: bool) {}
-// CHECK: define{{.*}}foo0{{.*}}!type ![[TYPE0:[0-9]+]] !type !{{[0-9]+}}
-pub fn foo1(_: bool, _: bool) {}
-// CHECK: define{{.*}}foo1{{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}}
-pub fn foo2(_: bool, _: bool, _: bool) {}
-// CHECK: define{{.*}}foo2{{.*}}!type ![[TYPE2:[0-9]+]] !type !{{[0-9]+}}
-pub fn foo3(_: char) {}
-// CHECK: define{{.*}}foo3{{.*}}!type ![[TYPE3:[0-9]+]] !type !{{[0-9]+}}
-pub fn foo4(_: char, _: char) {}
-// CHECK: define{{.*}}foo4{{.*}}!type ![[TYPE4:[0-9]+]] !type !{{[0-9]+}}
-pub fn foo5(_: char, _: char, _: char) {}
-// CHECK: define{{.*}}foo5{{.*}}!type ![[TYPE5:[0-9]+]] !type !{{[0-9]+}}
-pub fn foo6(_: isize) {}
-// CHECK: define{{.*}}foo6{{.*}}!type ![[TYPE6:[0-9]+]] !type !{{[0-9]+}}
-pub fn foo7(_: isize, _: isize) {}
-// CHECK: define{{.*}}foo7{{.*}}!type ![[TYPE7:[0-9]+]] !type !{{[0-9]+}}
-pub fn foo8(_: isize, _: isize, _: isize) {}
-// CHECK: define{{.*}}foo8{{.*}}!type ![[TYPE8:[0-9]+]] !type !{{[0-9]+}}
-pub fn foo9(_: (), _: usize) {}
-// CHECK: define{{.*}}foo9{{.*}}!type ![[TYPE9:[0-9]+]] !type !{{[0-9]+}}
-pub fn foo10(_: (), _: usize, _: usize) {}
-// CHECK: define{{.*}}foo10{{.*}}!type ![[TYPE10:[0-9]+]] !type !{{[0-9]+}}
-pub fn foo11(_: (), _: usize, _: usize, _: usize) {}
-// CHECK: define{{.*}}foo11{{.*}}!type ![[TYPE11:[0-9]+]] !type !{{[0-9]+}}
-
-// CHECK: ![[TYPE0]] = !{i64 0, !"_ZTSFvu2u8E.normalized"}
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvu2u8S_E.normalized"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"_ZTSFvu2u8S_S_E.normalized"}
-// CHECK: ![[TYPE3]] = !{i64 0, !"_ZTSFvu3u32E.normalized"}
-// CHECK: ![[TYPE4]] = !{i64 0, !"_ZTSFvu3u32S_E.normalized"}
-// CHECK: ![[TYPE5]] = !{i64 0, !"_ZTSFvu3u32S_S_E.normalized"}
-// CHECK: ![[TYPE6]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64|u4i128}}E.normalized"}
-// CHECK: ![[TYPE7]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64|u4i128}}S_E.normalized"}
-// CHECK: ![[TYPE8]] = !{i64 0, !"_ZTSFv{{u3i16|u3i32|u3i64|u4i128}}S_S_E.normalized"}
-// CHECK: ![[TYPE9]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64|u4u128}}E.normalized"}
-// CHECK: ![[TYPE10]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64|u4u128}}S_E.normalized"}
-// CHECK: ![[TYPE11]] = !{i64 0, !"_ZTSFv{{u3u16|u3u32|u3u64|u4u128}}S_S_E.normalized"}
diff --git a/tests/codegen/sanitizer/dataflow-instrument-functions.rs b/tests/codegen/sanitizer/dataflow-instrument-functions.rs
deleted file mode 100644
index a2d0d63cc17..00000000000
--- a/tests/codegen/sanitizer/dataflow-instrument-functions.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// Verifies that functions are instrumented.
-//
-//@ needs-sanitizer-dataflow
-//@ compile-flags: -Copt-level=0 -Zsanitizer=dataflow
-
-#![crate_type = "lib"]
-
-pub fn foo() {}
-// CHECK: define{{.*}}foo{{.*}}.dfsan
diff --git a/tests/codegen/sanitizer/kasan-emits-instrumentation.rs b/tests/codegen/sanitizer/kasan-emits-instrumentation.rs
deleted file mode 100644
index 774c9ab53f1..00000000000
--- a/tests/codegen/sanitizer/kasan-emits-instrumentation.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Verifies that `-Zsanitizer=kernel-address` emits sanitizer instrumentation.
-
-//@ add-core-stubs
-//@ compile-flags: -Zsanitizer=kernel-address -Copt-level=0
-//@ revisions: aarch64 riscv64imac riscv64gc x86_64
-//@[aarch64] compile-flags: --target aarch64-unknown-none
-//@[aarch64] needs-llvm-components: aarch64
-//@[riscv64imac] compile-flags: --target riscv64imac-unknown-none-elf
-//@[riscv64imac] needs-llvm-components: riscv
-//@[riscv64gc] compile-flags: --target riscv64gc-unknown-none-elf
-//@[riscv64gc] needs-llvm-components: riscv
-//@[x86_64] compile-flags: --target x86_64-unknown-none
-//@[x86_64] needs-llvm-components: x86
-
-#![crate_type = "rlib"]
-#![feature(no_core, no_sanitize, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK-LABEL: ; kasan_emits_instrumentation::unsanitized
-// CHECK-NEXT:  ; Function Attrs:
-// CHECK-NOT:   sanitize_address
-// CHECK:       start:
-// CHECK-NOT:   call void @__asan_report_load
-// CHECK:       }
-#[no_sanitize(address)]
-pub fn unsanitized(b: &mut u8) -> u8 {
-    *b
-}
-
-// CHECK-LABEL: ; kasan_emits_instrumentation::sanitized
-// CHECK-NEXT:  ; Function Attrs:
-// CHECK:       sanitize_address
-// CHECK:       start:
-// CHECK:       call void @__asan_report_load
-// CHECK:       }
-pub fn sanitized(b: &mut u8) -> u8 {
-    *b
-}
diff --git a/tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs b/tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
deleted file mode 100644
index 0be1ff19774..00000000000
--- a/tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Verifies that "cfi-normalize-integers" module flag is added.
-//
-//@ add-core-stubs
-//@ revisions: aarch64 x86_64
-//@ [aarch64] compile-flags: --target aarch64-unknown-none
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [x86_64] compile-flags: --target x86_64-unknown-none
-//@ [x86_64] needs-llvm-components: x86
-//@ compile-flags: -Ctarget-feature=-crt-static -Zsanitizer=kcfi -Zsanitizer-cfi-normalize-integers
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn foo() {}
-
-// CHECK: !{{[0-9]+}} = !{i32 4, !"cfi-normalize-integers", i32 1}
diff --git a/tests/codegen/sanitizer/kcfi/add-kcfi-arity-flag.rs b/tests/codegen/sanitizer/kcfi/add-kcfi-arity-flag.rs
deleted file mode 100644
index 9a2290901d6..00000000000
--- a/tests/codegen/sanitizer/kcfi/add-kcfi-arity-flag.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Verifies that "kcfi-arity" module flag is added.
-//
-//@ add-core-stubs
-//@ revisions: x86_64
-//@ [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"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn foo() {}
-
-// CHECK: !{{[0-9]+}} = !{i32 4, !"kcfi-arity", i32 1}
diff --git a/tests/codegen/sanitizer/kcfi/add-kcfi-flag.rs b/tests/codegen/sanitizer/kcfi/add-kcfi-flag.rs
deleted file mode 100644
index eabe0409c9a..00000000000
--- a/tests/codegen/sanitizer/kcfi/add-kcfi-flag.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Verifies that "kcfi" module flag is added.
-//
-//@ add-core-stubs
-//@ revisions: aarch64 x86_64
-//@ [aarch64] compile-flags: --target aarch64-unknown-none
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [x86_64] compile-flags: --target x86_64-unknown-none
-//@ [x86_64] needs-llvm-components: x86
-//@ compile-flags: -Ctarget-feature=-crt-static -Zsanitizer=kcfi
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn foo() {}
-
-// CHECK: !{{[0-9]+}} = !{i32 4, !"kcfi", i32 1}
diff --git a/tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs b/tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs
deleted file mode 100644
index 2f18c9d84b9..00000000000
--- a/tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Verifies that "kcfi-offset" module flag is added.
-//
-//@ add-core-stubs
-//@ revisions: aarch64 x86_64
-//@ [aarch64] compile-flags: --target aarch64-unknown-none
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [x86_64] compile-flags: --target x86_64-unknown-none
-//@ [x86_64] needs-llvm-components: x86
-//@ compile-flags: -Ctarget-feature=-crt-static -Zsanitizer=kcfi -Z patchable-function-entry=4,3
-
-#![feature(no_core, lang_items, patchable_function_entry)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn foo() {}
-
-// CHECK: !{{[0-9]+}} = !{i32 4, !"kcfi-offset", i32 3}
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs
deleted file mode 100644
index 6b40918dd3a..00000000000
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Verifies that KCFI operand bundles are omitted.
-//
-//@ add-core-stubs
-//@ revisions: aarch64 x86_64
-//@ [aarch64] compile-flags: --target aarch64-unknown-none
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [x86_64] compile-flags: --target x86_64-unknown-none
-//@ [x86_64] needs-llvm-components:
-//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(no_core, no_sanitize, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[no_sanitize(kcfi)]
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: emit_kcfi_operand_bundle_attr_no_sanitize::foo
-    // CHECK:       Function Attrs: {{.*}}
-    // CHECK-LABEL: define{{.*}}foo{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       start:
-    // CHECK-NOT:   {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 {{[-0-9]+}}) ]
-    // CHECK:       ret i32 {{%.+}}
-    f(arg)
-}
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs
deleted file mode 100644
index 942b50deb02..00000000000
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Verifies that generalized KCFI type metadata for functions are emitted.
-//
-//@ add-core-stubs
-//@ revisions: aarch64 x86_64
-//@ [aarch64] compile-flags: --target aarch64-unknown-none
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [x86_64] compile-flags: --target x86_64-unknown-none
-//@ [x86_64] needs-llvm-components:
-//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Zsanitizer-cfi-generalize-pointers
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}foo
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE1:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 233085384) ]
-    f(arg)
-}
-
-pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}bar
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE2:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2){{.*}}[ "kcfi"(i32 435418021) ]
-    f(arg1, arg2)
-}
-
-pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}baz
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE3:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2, i32 {{(noundef )*}}%arg3){{.*}}[ "kcfi"(i32 -1003721339) ]
-    f(arg1, arg2, arg3)
-}
-
-// CHECK: ![[TYPE1]] = !{i32 -1741689296}
-// CHECK: ![[TYPE2]] = !{i32 489439372}
-// CHECK: ![[TYPE3]] = !{i32 2026563871}
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs
deleted file mode 100644
index c89d9bdd121..00000000000
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Verifies that normalized and generalized KCFI type metadata for functions are emitted.
-//
-//@ add-core-stubs
-//@ revisions: aarch64 x86_64
-//@ [aarch64] compile-flags: --target aarch64-unknown-none
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [x86_64] compile-flags: --target x86_64-unknown-none
-//@ [x86_64] needs-llvm-components:
-//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Zsanitizer-cfi-normalize-integers -Zsanitizer-cfi-generalize-pointers
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}foo
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE1:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 -686570305) ]
-    f(arg)
-}
-
-pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}bar
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE2:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2){{.*}}[ "kcfi"(i32 1281038450) ]
-    f(arg1, arg2)
-}
-
-pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}baz
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE3:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2, i32 {{(noundef )*}}%arg3){{.*}}[ "kcfi"(i32 -1751512973) ]
-    f(arg1, arg2, arg3)
-}
-
-// CHECK: ![[TYPE1]] = !{i32 975484707}
-// CHECK: ![[TYPE2]] = !{i32 1658833102}
-// CHECK: ![[TYPE3]] = !{i32 230429758}
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs
deleted file mode 100644
index 220cae1a4fa..00000000000
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Verifies that normalized KCFI type metadata for functions are emitted.
-//
-//@ add-core-stubs
-//@ revisions: aarch64 x86_64
-//@ [aarch64] compile-flags: --target aarch64-unknown-none
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [x86_64] compile-flags: --target x86_64-unknown-none
-//@ [x86_64] needs-llvm-components:
-//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Zsanitizer-cfi-normalize-integers
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}foo
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE1:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 -841055669) ]
-    f(arg)
-}
-
-pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}bar
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE2:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2){{.*}}[ "kcfi"(i32 1390819368) ]
-    f(arg1, arg2)
-}
-
-pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}baz
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE3:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2, i32 {{(noundef )*}}%arg3){{.*}}[ "kcfi"(i32 586925835) ]
-    f(arg1, arg2, arg3)
-}
-
-// CHECK: ![[TYPE1]] = !{i32 -458317079}
-// CHECK: ![[TYPE2]] = !{i32 1737138182}
-// CHECK: ![[TYPE3]] = !{i32 197182412}
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs
deleted file mode 100644
index bb9a0005903..00000000000
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Verifies that KCFI type metadata for functions are emitted.
-//
-//@ add-core-stubs
-//@ revisions: aarch64 x86_64
-//@ [aarch64] compile-flags: --target aarch64-unknown-none
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [x86_64] compile-flags: --target x86_64-unknown-none
-//@ [x86_64] needs-llvm-components:
-//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}foo
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE1:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 -1666898348) ]
-    f(arg)
-}
-
-pub fn bar(f: fn(i32, i32) -> i32, arg1: i32, arg2: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}bar
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE2:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2){{.*}}[ "kcfi"(i32 -1789026986) ]
-    f(arg1, arg2)
-}
-
-pub fn baz(f: fn(i32, i32, i32) -> i32, arg1: i32, arg2: i32, arg3: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}baz
-    // CHECK-SAME:  {{.*}}!{{<unknown kind #36>|kcfi_type}} ![[TYPE3:[0-9]+]]
-    // CHECK:       {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg1, i32 {{(noundef )*}}%arg2, i32 {{(noundef )*}}%arg3){{.*}}[ "kcfi"(i32 1248878270) ]
-    f(arg1, arg2, arg3)
-}
-
-// CHECK: ![[TYPE1]] = !{i32 653723426}
-// CHECK: ![[TYPE2]] = !{i32 412174924}
-// CHECK: ![[TYPE3]] = !{i32 -636668840}
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle.rs
deleted file mode 100644
index 8b844b99142..00000000000
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Verifies that KCFI operand bundles are emitted.
-//
-//@ add-core-stubs
-//@ revisions: aarch64 x86_64
-//@ [aarch64] compile-flags: --target aarch64-unknown-none
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [x86_64] compile-flags: --target x86_64-unknown-none
-//@ [x86_64] needs-llvm-components:
-//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
-    // CHECK-LABEL: define{{.*}}foo{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       start:
-    // CHECK-NEXT:  {{%.+}} = call {{(noundef )*}}i32 %f(i32 {{(noundef )*}}%arg){{.*}}[ "kcfi"(i32 {{[-0-9]+}}) ]
-    // CHECK-NEXT:  ret i32 {{%.+}}
-    f(arg)
-}
diff --git a/tests/codegen/sanitizer/kcfi/emit-type-metadata-trait-objects.rs b/tests/codegen/sanitizer/kcfi/emit-type-metadata-trait-objects.rs
deleted file mode 100644
index 15c107bea15..00000000000
--- a/tests/codegen/sanitizer/kcfi/emit-type-metadata-trait-objects.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-// Verifies that type metadata identifiers for trait objects are emitted correctly.
-//
-//@ add-core-stubs
-//@ revisions: aarch64 x86_64
-//@ [aarch64] compile-flags: --target aarch64-unknown-none
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [x86_64] compile-flags: --target x86_64-unknown-none
-//@ [x86_64] needs-llvm-components:
-//@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(arbitrary_self_types, no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub trait Trait1 {
-    fn foo(&self);
-}
-
-pub struct Type1;
-
-impl Trait1 for Type1 {
-    fn foo(&self) {}
-}
-
-pub trait Trait2<T> {
-    fn bar(&self);
-}
-
-pub struct Type2;
-
-impl Trait2<i32> for Type2 {
-    fn bar(&self) {}
-}
-
-pub trait Trait3<T> {
-    fn baz(&self, _: &T);
-}
-
-pub struct Type3;
-
-impl<T, U> Trait3<U> for T {
-    fn baz(&self, _: &U) {}
-}
-
-pub trait Trait4<'a, T> {
-    type Output: 'a;
-    fn qux(&self, _: &T) -> Self::Output;
-}
-
-pub struct Type4;
-
-impl<'a, T, U> Trait4<'a, U> for T {
-    type Output = &'a i32;
-    fn qux(&self, _: &U) -> Self::Output {
-        &0
-    }
-}
-
-pub trait Trait5<T, const N: usize> {
-    fn quux(&self, _: &[T; N]);
-}
-
-pub struct Type5;
-
-impl Copy for Type5 {}
-
-impl<T, U, const N: usize> Trait5<U, N> for T {
-    fn quux(&self, _: &[U; N]) {}
-}
-
-pub fn foo1(a: &dyn Trait1) {
-    a.foo();
-    // CHECK-LABEL: define{{.*}}4foo1{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE1:[[:print:]]+]]) ]
-}
-
-pub fn bar1() {
-    let a = Type1;
-    let b = &a as &dyn Trait1;
-    b.foo();
-    // CHECK-LABEL: define{{.*}}4bar1{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE1:[[:print:]]+]]) ]
-}
-
-pub fn foo2<T>(a: &dyn Trait2<T>) {
-    a.bar();
-    // CHECK-LABEL: define{{.*}}4foo2{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE2:[[:print:]]+]]) ]
-}
-
-pub fn bar2() {
-    let a = Type2;
-    foo2(&a);
-    let b = &a as &dyn Trait2<i32>;
-    b.bar();
-    // CHECK-LABEL: define{{.*}}4bar2{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE2:[[:print:]]+]]) ]
-}
-
-pub fn foo3(a: &dyn Trait3<Type3>) {
-    let b = Type3;
-    a.baz(&b);
-    // CHECK-LABEL: define{{.*}}4foo3{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}, ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE3:[[:print:]]+]]) ]
-}
-
-pub fn bar3() {
-    let a = Type3;
-    foo3(&a);
-    let b = &a as &dyn Trait3<Type3>;
-    b.baz(&a);
-    // CHECK-LABEL: define{{.*}}4bar3{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}, ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE3:[[:print:]]+]]) ]
-}
-
-pub fn foo4<'a>(a: &dyn Trait4<'a, Type4, Output = &'a i32>) {
-    let b = Type4;
-    a.qux(&b);
-    // CHECK-LABEL: define{{.*}}4foo4{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       call align 4 ptr %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}, ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE4:[[:print:]]+]]) ]
-}
-
-pub fn bar4<'a>() {
-    let a = Type4;
-    foo4(&a);
-    let b = &a as &dyn Trait4<'a, Type4, Output = &'a i32>;
-    b.qux(&a);
-    // CHECK-LABEL: define{{.*}}4bar4{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       call align 4 ptr %{{[0-9]}}(ptr align 1 {{%[a-z]\.0|%_[0-9]}}, ptr align 1 {{%[a-z]\.0|%_[0-9]}}){{.*}}[ "kcfi"(i32 [[TYPE4:[[:print:]]+]]) ]
-}
-
-pub fn foo5(a: &dyn Trait5<Type5, 32>) {
-    let b = &[Type5; 32];
-    a.quux(&b);
-    // CHECK-LABEL: define{{.*}}4foo5{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z](\.0)*|%_[0-9]+]}}, ptr align 1 {{%[a-z](\.0)*|%_[0-9]+}}){{.*}}[ "kcfi"(i32 [[TYPE5:[[:print:]]+]]) ]
-}
-
-pub fn bar5() {
-    let a = &[Type5; 32];
-    foo5(&a);
-    let b = &a as &dyn Trait5<Type5, 32>;
-    b.quux(&a);
-    // CHECK-LABEL: define{{.*}}4bar5{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
-    // CHECK:       call void %{{[0-9]}}(ptr align 1 {{%[a-z](\.0)*|%_[0-9]+]}}, ptr align 1 {{%[a-z](\.0)*|%_[0-9]+}}){{.*}}[ "kcfi"(i32 [[TYPE5:[[:print:]]+]]) ]
-}
-
-// CHECK: !{{[0-9]+}} = !{i32 [[TYPE1]]}
-// CHECK: !{{[0-9]+}} = !{i32 [[TYPE2]]}
-// CHECK: !{{[0-9]+}} = !{i32 [[TYPE3]]}
-// CHECK: !{{[0-9]+}} = !{i32 [[TYPE4]]}
-// CHECK: !{{[0-9]+}} = !{i32 [[TYPE5]]}
diff --git a/tests/codegen/sanitizer/kcfi/naked-function.rs b/tests/codegen/sanitizer/kcfi/naked-function.rs
deleted file mode 100644
index 2c8cdc919b8..00000000000
--- a/tests/codegen/sanitizer/kcfi/naked-function.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-//@ add-core-stubs
-//@ revisions: aarch64 x86_64
-//@ [aarch64] compile-flags: --target aarch64-unknown-none
-//@ [aarch64] needs-llvm-components: aarch64
-//@ [x86_64] compile-flags: --target x86_64-unknown-none
-//@ [x86_64] needs-llvm-components: x86
-//@ compile-flags: -Ctarget-feature=-crt-static -Zsanitizer=kcfi -Cno-prepopulate-passes -Copt-level=0
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-struct Thing;
-trait MyTrait {
-    #[unsafe(naked)]
-    extern "C" fn my_naked_function() {
-        // the real function is defined
-        // CHECK: .globl
-        // CHECK-SAME: my_naked_function
-        naked_asm!("ret")
-    }
-}
-impl MyTrait for Thing {}
-
-// the shim calls the real function
-// CHECK-LABEL: define
-// CHECK-SAME: my_naked_function
-// CHECK-SAME: reify.shim.fnptr
-
-// CHECK-LABEL: main
-#[unsafe(no_mangle)]
-pub fn main() {
-    // Trick the compiler into generating an indirect call.
-    const F: extern "C" fn() = Thing::my_naked_function;
-
-    // main calls the shim function
-    // CHECK: call void
-    // CHECK-SAME: my_naked_function
-    // CHECK-SAME: reify.shim.fnptr
-    (F)();
-}
-
-// CHECK: declare !kcfi_type
-// CHECK-SAME: my_naked_function
diff --git a/tests/codegen/sanitizer/memory-track-origins.rs b/tests/codegen/sanitizer/memory-track-origins.rs
deleted file mode 100644
index 318c277e10c..00000000000
--- a/tests/codegen/sanitizer/memory-track-origins.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Verifies that MemorySanitizer track-origins level can be controlled
-// with -Zsanitizer-memory-track-origins option.
-//
-//@ needs-sanitizer-memory
-//@ revisions:MSAN-0 MSAN-1 MSAN-2 MSAN-1-LTO MSAN-2-LTO
-//
-//@ compile-flags: -Zsanitizer=memory -Ctarget-feature=-crt-static
-//@[MSAN-0] compile-flags:
-//@[MSAN-1] compile-flags: -Zsanitizer-memory-track-origins=1
-//@[MSAN-2] compile-flags: -Zsanitizer-memory-track-origins
-//@[MSAN-1-LTO] compile-flags: -Zsanitizer-memory-track-origins=1 -C lto=fat
-//@[MSAN-2-LTO] compile-flags: -Zsanitizer-memory-track-origins -C lto=fat
-
-#![crate_type = "lib"]
-
-// MSAN-0-NOT: @__msan_track_origins
-// MSAN-1:     @__msan_track_origins = weak_odr {{.*}}constant i32 1
-// MSAN-2:     @__msan_track_origins = weak_odr {{.*}}constant i32 2
-// MSAN-1-LTO: @__msan_track_origins = weak_odr {{.*}}constant i32 1
-// MSAN-2-LTO: @__msan_track_origins = weak_odr {{.*}}constant i32 2
-//
-// MSAN-0-LABEL: define void @copy(
-// MSAN-1-LABEL: define void @copy(
-// MSAN-2-LABEL: define void @copy(
-#[no_mangle]
-pub fn copy(dst: &mut i32, src: &i32) {
-    // MSAN-0-NOT: call i32 @__msan_chain_origin(
-    // MSAN-1-NOT: call i32 @__msan_chain_origin(
-    // MSAN-2:     call i32 @__msan_chain_origin(
-    *dst = *src;
-}
diff --git a/tests/codegen/sanitizer/memtag-attr-check.rs b/tests/codegen/sanitizer/memtag-attr-check.rs
deleted file mode 100644
index ffe3a2322a2..00000000000
--- a/tests/codegen/sanitizer/memtag-attr-check.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-// This tests that the sanitize_memtag attribute is
-// applied when enabling the memtag sanitizer.
-//
-//@ needs-sanitizer-memtag
-//@ compile-flags: -Zsanitizer=memtag -Ctarget-feature=+mte -Copt-level=0
-
-#![crate_type = "lib"]
-
-// CHECK: ; Function Attrs:{{.*}}sanitize_memtag
-pub fn tagged() {}
-
-// CHECK: attributes #0 = {{.*}}sanitize_memtag
diff --git a/tests/codegen/sanitizer/no-sanitize-inlining.rs b/tests/codegen/sanitizer/no-sanitize-inlining.rs
deleted file mode 100644
index 4bd832d2ab1..00000000000
--- a/tests/codegen/sanitizer/no-sanitize-inlining.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Verifies that no_sanitize attribute prevents inlining when
-// given sanitizer is enabled, but has no effect on inlining otherwise.
-//
-//@ needs-sanitizer-address
-//@ needs-sanitizer-leak
-//@ revisions: ASAN LSAN
-//@       compile-flags: -Copt-level=3 -Zmir-opt-level=4 -Ctarget-feature=-crt-static
-//@[ASAN] compile-flags: -Zsanitizer=address
-//@[LSAN] compile-flags: -Zsanitizer=leak
-
-#![crate_type = "lib"]
-#![feature(no_sanitize)]
-
-// ASAN-LABEL: define void @test
-// ASAN:         call {{.*}} @random_inline
-// ASAN:       }
-//
-// LSAN-LABEL: define void @test
-// LSAN-NOT:     call
-// LSAN:       }
-#[no_mangle]
-pub fn test(n: &mut u32) {
-    random_inline(n);
-}
-
-#[no_sanitize(address)]
-#[inline]
-#[no_mangle]
-pub fn random_inline(n: &mut u32) {
-    *n = 42;
-}
diff --git a/tests/codegen/sanitizer/no-sanitize.rs b/tests/codegen/sanitizer/no-sanitize.rs
deleted file mode 100644
index 2a309f6b9c6..00000000000
--- a/tests/codegen/sanitizer/no-sanitize.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-// Verifies that no_sanitize attribute can be used to
-// selectively disable sanitizer instrumentation.
-//
-//@ needs-sanitizer-address
-//@ compile-flags: -Zsanitizer=address -Ctarget-feature=-crt-static -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(no_sanitize)]
-
-// CHECK:     @UNSANITIZED = constant{{.*}} no_sanitize_address
-// CHECK-NOT: @__asan_global_UNSANITIZED
-#[no_mangle]
-#[no_sanitize(address)]
-pub static UNSANITIZED: u32 = 0;
-
-// CHECK: @__asan_global_SANITIZED
-#[no_mangle]
-pub static SANITIZED: u32 = 0;
-
-// CHECK-LABEL: ; no_sanitize::unsanitized
-// CHECK-NEXT:  ; Function Attrs:
-// CHECK-NOT:   sanitize_address
-// CHECK:       start:
-// CHECK-NOT:   call void @__asan_report_load
-// CHECK:       }
-#[no_sanitize(address)]
-pub fn unsanitized(b: &mut u8) -> u8 {
-    *b
-}
-
-// CHECK-LABEL: ; no_sanitize::sanitized
-// CHECK-NEXT:  ; Function Attrs:
-// CHECK:       sanitize_address
-// CHECK:       start:
-// CHECK:       call void @__asan_report_load
-// CHECK:       }
-pub fn sanitized(b: &mut u8) -> u8 {
-    *b
-}
diff --git a/tests/codegen/sanitizer/riscv64-shadow-call-stack.rs b/tests/codegen/sanitizer/riscv64-shadow-call-stack.rs
deleted file mode 100644
index 945e46218d0..00000000000
--- a/tests/codegen/sanitizer/riscv64-shadow-call-stack.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: --target riscv64imac-unknown-none-elf -Zsanitizer=shadow-call-stack
-//@ needs-llvm-components: riscv
-
-#![allow(internal_features)]
-#![crate_type = "rlib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// CHECK: ; Function Attrs:{{.*}}shadowcallstack
-// CHECK: define dso_local void @foo() unnamed_addr #0
-#[no_mangle]
-pub fn foo() {}
-
-// CHECK: attributes #0 = {{.*}}shadowcallstack{{.*}}
diff --git a/tests/codegen/sanitizer/safestack-attr-check.rs b/tests/codegen/sanitizer/safestack-attr-check.rs
deleted file mode 100644
index 050a60333af..00000000000
--- a/tests/codegen/sanitizer/safestack-attr-check.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// This tests that the safestack attribute is applied when enabling the safe-stack sanitizer.
-//
-//@ needs-sanitizer-safestack
-//@ compile-flags: -Zsanitizer=safestack -Copt-level=0
-
-#![crate_type = "lib"]
-
-// CHECK: ; Function Attrs:{{.*}}safestack
-pub fn tagged() {}
-
-// CHECK: attributes #0 = {{.*}}safestack
diff --git a/tests/codegen/sanitizer/sanitizer-recover.rs b/tests/codegen/sanitizer/sanitizer-recover.rs
deleted file mode 100644
index 6b659320481..00000000000
--- a/tests/codegen/sanitizer/sanitizer-recover.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Verifies that AddressSanitizer and MemorySanitizer
-// recovery mode can be enabled with -Zsanitizer-recover.
-//
-//@ needs-sanitizer-address
-//@ needs-sanitizer-memory
-//@ revisions:ASAN ASAN-RECOVER MSAN MSAN-RECOVER MSAN-RECOVER-LTO
-//@ no-prefer-dynamic
-//
-//@                   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
-//@[MSAN]             compile-flags: -Zsanitizer=memory
-//@[MSAN-RECOVER]     compile-flags: -Zsanitizer=memory  -Zsanitizer-recover=memory
-//@[MSAN-RECOVER-LTO] compile-flags: -Zsanitizer=memory  -Zsanitizer-recover=memory -C lto=fat
-//
-// MSAN-NOT:         @__msan_keep_going
-// MSAN-RECOVER:     @__msan_keep_going = weak_odr {{.*}}constant i32 1
-// MSAN-RECOVER-LTO: @__msan_keep_going = weak_odr {{.*}}constant i32 1
-
-// ASAN-LABEL: define dso_local i32 @penguin(
-// ASAN:         call void @__asan_report_load4(i64 %0)
-// ASAN:         unreachable
-// ASAN:       }
-//
-// ASAN-RECOVER-LABEL: define dso_local i32 @penguin(
-// ASAN-RECOVER:         call void @__asan_report_load4_noabort(
-// ASAN-RECOVER-NOT:     unreachable
-// ASAN:               }
-//
-// MSAN-LABEL: define dso_local noundef i32 @penguin(
-// MSAN:         call void @__msan_warning{{(_with_origin_noreturn\(i32 0\)|_noreturn\(\))}}
-// MSAN:         unreachable
-// MSAN:       }
-//
-// MSAN-RECOVER-LABEL: define dso_local noundef i32 @penguin(
-// MSAN-RECOVER:         call void @__msan_warning{{(_with_origin\(i32 0\)|\(\))}}
-// MSAN-RECOVER-NOT:     unreachable
-// MSAN-RECOVER:       }
-//
-// MSAN-RECOVER-LTO-LABEL: define dso_local noundef i32 @penguin(
-// MSAN-RECOVER-LTO:          call void @__msan_warning{{(_with_origin\(i32 0\)|\(\))}}
-// MSAN-RECOVER-LTO-NOT:      unreachable
-// MSAN-RECOVER-LTO:       }
-//
-#[no_mangle]
-pub fn penguin(p: &mut i32) -> i32 {
-    *p
-}
-
-fn main() {}
diff --git a/tests/codegen/sanitizer/scs-attr-check.rs b/tests/codegen/sanitizer/scs-attr-check.rs
deleted file mode 100644
index 6f4cbc2c0a6..00000000000
--- a/tests/codegen/sanitizer/scs-attr-check.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// This tests that the shadowcallstack attribute is
-// applied when enabling the shadow-call-stack sanitizer.
-//
-//@ needs-sanitizer-shadow-call-stack
-//@ compile-flags: -Zsanitizer=shadow-call-stack
-
-#![crate_type = "lib"]
-#![feature(no_sanitize)]
-
-// CHECK: ; sanitizer_scs_attr_check::scs
-// CHECK-NEXT: ; Function Attrs:{{.*}}shadowcallstack
-pub fn scs() {}
-
-// CHECK: ; sanitizer_scs_attr_check::no_scs
-// CHECK-NOT: ; Function Attrs:{{.*}}shadowcallstack
-#[no_sanitize(shadow_call_stack)]
-pub fn no_scs() {}
diff --git a/tests/codegen/scalar-pair-bool.rs b/tests/codegen/scalar-pair-bool.rs
deleted file mode 100644
index def3b32f71a..00000000000
--- a/tests/codegen/scalar-pair-bool.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK: define{{.*}}{ i1, i1 } @pair_bool_bool(i1 noundef zeroext %pair.0, i1 noundef zeroext %pair.1)
-#[no_mangle]
-pub fn pair_bool_bool(pair: (bool, bool)) -> (bool, bool) {
-    pair
-}
-
-// CHECK: define{{.*}}{ i1, i32 } @pair_bool_i32(i1 noundef zeroext %pair.0, i32 noundef %pair.1)
-#[no_mangle]
-pub fn pair_bool_i32(pair: (bool, i32)) -> (bool, i32) {
-    pair
-}
-
-// CHECK: define{{.*}}{ i32, i1 } @pair_i32_bool(i32 noundef %pair.0, i1 noundef zeroext %pair.1)
-#[no_mangle]
-pub fn pair_i32_bool(pair: (i32, bool)) -> (i32, bool) {
-    pair
-}
-
-// CHECK: define{{.*}}{ i1, i1 } @pair_and_or(i1 noundef zeroext %_1.0, i1 noundef zeroext %_1.1)
-#[no_mangle]
-pub fn pair_and_or((a, b): (bool, bool)) -> (bool, bool) {
-    // Make sure it can operate directly on the unpacked args
-    // (but it might not be using simple and/or instructions)
-    // CHECK-DAG: %_1.0
-    // CHECK-DAG: %_1.1
-    (a && b, a || b)
-}
-
-// CHECK: define{{.*}}void @pair_branches(i1 noundef zeroext %_1.0, i1 noundef zeroext %_1.1)
-#[no_mangle]
-pub fn pair_branches((a, b): (bool, bool)) {
-    // Make sure it can branch directly on the unpacked bool args
-    // CHECK: br i1 %_1.0
-    if a {
-        println!("Hello!");
-    }
-    // CHECK: br i1 %_1.1
-    if b {
-        println!("Goodbye!");
-    }
-}
diff --git a/tests/codegen/set-discriminant-invalid.rs b/tests/codegen/set-discriminant-invalid.rs
deleted file mode 100644
index dd584ef1c14..00000000000
--- a/tests/codegen/set-discriminant-invalid.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//@ compile-flags: -C opt-level=0
-#![crate_type = "lib"]
-
-pub enum ApiError {}
-#[allow(dead_code)]
-pub struct TokioError {
-    b: bool,
-}
-pub enum Error {
-    Api { source: ApiError },
-    Ethereum,
-    Tokio { source: TokioError },
-}
-struct Api;
-impl IntoError<Error> for Api {
-    type Source = ApiError;
-    // CHECK-LABEL: @into_error
-    // CHECK: llvm.trap()
-    // Also check the next instruction to make sure we do not match against `trap`
-    // elsewhere in the code.
-    // CHECK-NEXT: ret i8 poison
-    #[no_mangle]
-    fn into_error(self, error: Self::Source) -> Error {
-        Error::Api { source: error }
-    }
-}
-
-pub trait IntoError<E> {
-    /// The underlying error
-    type Source;
-
-    /// Combine the information to produce the error
-    fn into_error(self, source: Self::Source) -> E;
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
deleted file mode 100644
index baf445d0a1b..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_fabs;
-
-// CHECK-LABEL: @fabs_32x2
-#[no_mangle]
-pub unsafe fn fabs_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.fabs.v2f32
-    simd_fabs(a)
-}
-
-// CHECK-LABEL: @fabs_32x4
-#[no_mangle]
-pub unsafe fn fabs_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.fabs.v4f32
-    simd_fabs(a)
-}
-
-// CHECK-LABEL: @fabs_32x8
-#[no_mangle]
-pub unsafe fn fabs_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.fabs.v8f32
-    simd_fabs(a)
-}
-
-// CHECK-LABEL: @fabs_32x16
-#[no_mangle]
-pub unsafe fn fabs_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.fabs.v16f32
-    simd_fabs(a)
-}
-
-// CHECK-LABEL: @fabs_64x4
-#[no_mangle]
-pub unsafe fn fabs_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.fabs.v4f64
-    simd_fabs(a)
-}
-
-// CHECK-LABEL: @fabs_64x2
-#[no_mangle]
-pub unsafe fn fabs_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.fabs.v2f64
-    simd_fabs(a)
-}
-
-// CHECK-LABEL: @fabs_64x8
-#[no_mangle]
-pub unsafe fn fabs_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.fabs.v8f64
-    simd_fabs(a)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
deleted file mode 100644
index 096de569274..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_ceil;
-
-// CHECK-LABEL: @ceil_32x2
-#[no_mangle]
-pub unsafe fn ceil_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.ceil.v2f32
-    simd_ceil(a)
-}
-
-// CHECK-LABEL: @ceil_32x4
-#[no_mangle]
-pub unsafe fn ceil_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.ceil.v4f32
-    simd_ceil(a)
-}
-
-// CHECK-LABEL: @ceil_32x8
-#[no_mangle]
-pub unsafe fn ceil_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.ceil.v8f32
-    simd_ceil(a)
-}
-
-// CHECK-LABEL: @ceil_32x16
-#[no_mangle]
-pub unsafe fn ceil_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.ceil.v16f32
-    simd_ceil(a)
-}
-
-// CHECK-LABEL: @ceil_64x4
-#[no_mangle]
-pub unsafe fn ceil_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.ceil.v4f64
-    simd_ceil(a)
-}
-
-// CHECK-LABEL: @ceil_64x2
-#[no_mangle]
-pub unsafe fn ceil_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.ceil.v2f64
-    simd_ceil(a)
-}
-
-// CHECK-LABEL: @ceil_64x8
-#[no_mangle]
-pub unsafe fn ceil_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.ceil.v8f64
-    simd_ceil(a)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
deleted file mode 100644
index 5b2197924bc..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_fcos;
-
-// CHECK-LABEL: @fcos_32x2
-#[no_mangle]
-pub unsafe fn fcos_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.cos.v2f32
-    simd_fcos(a)
-}
-
-// CHECK-LABEL: @fcos_32x4
-#[no_mangle]
-pub unsafe fn fcos_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.cos.v4f32
-    simd_fcos(a)
-}
-
-// CHECK-LABEL: @fcos_32x8
-#[no_mangle]
-pub unsafe fn fcos_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.cos.v8f32
-    simd_fcos(a)
-}
-
-// CHECK-LABEL: @fcos_32x16
-#[no_mangle]
-pub unsafe fn fcos_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.cos.v16f32
-    simd_fcos(a)
-}
-
-// CHECK-LABEL: @fcos_64x4
-#[no_mangle]
-pub unsafe fn fcos_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.cos.v4f64
-    simd_fcos(a)
-}
-
-// CHECK-LABEL: @fcos_64x2
-#[no_mangle]
-pub unsafe fn fcos_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.cos.v2f64
-    simd_fcos(a)
-}
-
-// CHECK-LABEL: @fcos_64x8
-#[no_mangle]
-pub unsafe fn fcos_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.cos.v8f64
-    simd_fcos(a)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
deleted file mode 100644
index d4eadb36c65..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_fexp;
-
-// CHECK-LABEL: @exp_32x2
-#[no_mangle]
-pub unsafe fn exp_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.exp.v2f32
-    simd_fexp(a)
-}
-
-// CHECK-LABEL: @exp_32x4
-#[no_mangle]
-pub unsafe fn exp_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.exp.v4f32
-    simd_fexp(a)
-}
-
-// CHECK-LABEL: @exp_32x8
-#[no_mangle]
-pub unsafe fn exp_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.exp.v8f32
-    simd_fexp(a)
-}
-
-// CHECK-LABEL: @exp_32x16
-#[no_mangle]
-pub unsafe fn exp_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.exp.v16f32
-    simd_fexp(a)
-}
-
-// CHECK-LABEL: @exp_64x4
-#[no_mangle]
-pub unsafe fn exp_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.exp.v4f64
-    simd_fexp(a)
-}
-
-// CHECK-LABEL: @exp_64x2
-#[no_mangle]
-pub unsafe fn exp_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.exp.v2f64
-    simd_fexp(a)
-}
-
-// CHECK-LABEL: @exp_64x8
-#[no_mangle]
-pub unsafe fn exp_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.exp.v8f64
-    simd_fexp(a)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
deleted file mode 100644
index d32015b7990..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_fexp2;
-
-// CHECK-LABEL: @exp2_32x2
-#[no_mangle]
-pub unsafe fn exp2_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.exp2.v2f32
-    simd_fexp2(a)
-}
-
-// CHECK-LABEL: @exp2_32x4
-#[no_mangle]
-pub unsafe fn exp2_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.exp2.v4f32
-    simd_fexp2(a)
-}
-
-// CHECK-LABEL: @exp2_32x8
-#[no_mangle]
-pub unsafe fn exp2_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.exp2.v8f32
-    simd_fexp2(a)
-}
-
-// CHECK-LABEL: @exp2_32x16
-#[no_mangle]
-pub unsafe fn exp2_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.exp2.v16f32
-    simd_fexp2(a)
-}
-
-// CHECK-LABEL: @exp2_64x4
-#[no_mangle]
-pub unsafe fn exp2_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.exp2.v4f64
-    simd_fexp2(a)
-}
-
-// CHECK-LABEL: @exp2_64x2
-#[no_mangle]
-pub unsafe fn exp2_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.exp2.v2f64
-    simd_fexp2(a)
-}
-
-// CHECK-LABEL: @exp2_64x8
-#[no_mangle]
-pub unsafe fn exp2_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.exp2.v8f64
-    simd_fexp2(a)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
deleted file mode 100644
index 1e1c8ce0c35..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_floor;
-
-// CHECK-LABEL: @floor_32x2
-#[no_mangle]
-pub unsafe fn floor_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.floor.v2f32
-    simd_floor(a)
-}
-
-// CHECK-LABEL: @floor_32x4
-#[no_mangle]
-pub unsafe fn floor_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.floor.v4f32
-    simd_floor(a)
-}
-
-// CHECK-LABEL: @floor_32x8
-#[no_mangle]
-pub unsafe fn floor_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.floor.v8f32
-    simd_floor(a)
-}
-
-// CHECK-LABEL: @floor_32x16
-#[no_mangle]
-pub unsafe fn floor_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.floor.v16f32
-    simd_floor(a)
-}
-
-// CHECK-LABEL: @floor_64x4
-#[no_mangle]
-pub unsafe fn floor_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.floor.v4f64
-    simd_floor(a)
-}
-
-// CHECK-LABEL: @floor_64x2
-#[no_mangle]
-pub unsafe fn floor_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.floor.v2f64
-    simd_floor(a)
-}
-
-// CHECK-LABEL: @floor_64x8
-#[no_mangle]
-pub unsafe fn floor_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.floor.v8f64
-    simd_floor(a)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
deleted file mode 100644
index 982077d81f9..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_fma;
-
-// CHECK-LABEL: @fma_32x2
-#[no_mangle]
-pub unsafe fn fma_32x2(a: f32x2, b: f32x2, c: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.fma.v2f32
-    simd_fma(a, b, c)
-}
-
-// CHECK-LABEL: @fma_32x4
-#[no_mangle]
-pub unsafe fn fma_32x4(a: f32x4, b: f32x4, c: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.fma.v4f32
-    simd_fma(a, b, c)
-}
-
-// CHECK-LABEL: @fma_32x8
-#[no_mangle]
-pub unsafe fn fma_32x8(a: f32x8, b: f32x8, c: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.fma.v8f32
-    simd_fma(a, b, c)
-}
-
-// CHECK-LABEL: @fma_32x16
-#[no_mangle]
-pub unsafe fn fma_32x16(a: f32x16, b: f32x16, c: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.fma.v16f32
-    simd_fma(a, b, c)
-}
-
-// CHECK-LABEL: @fma_64x4
-#[no_mangle]
-pub unsafe fn fma_64x4(a: f64x4, b: f64x4, c: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.fma.v4f64
-    simd_fma(a, b, c)
-}
-
-// CHECK-LABEL: @fma_64x2
-#[no_mangle]
-pub unsafe fn fma_64x2(a: f64x2, b: f64x2, c: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.fma.v2f64
-    simd_fma(a, b, c)
-}
-
-// CHECK-LABEL: @fma_64x8
-#[no_mangle]
-pub unsafe fn fma_64x8(a: f64x8, b: f64x8, c: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.fma.v8f64
-    simd_fma(a, b, c)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
deleted file mode 100644
index e20a591f573..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_fsqrt;
-
-// CHECK-LABEL: @fsqrt_32x2
-#[no_mangle]
-pub unsafe fn fsqrt_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.sqrt.v2f32
-    simd_fsqrt(a)
-}
-
-// CHECK-LABEL: @fsqrt_32x4
-#[no_mangle]
-pub unsafe fn fsqrt_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.sqrt.v4f32
-    simd_fsqrt(a)
-}
-
-// CHECK-LABEL: @fsqrt_32x8
-#[no_mangle]
-pub unsafe fn fsqrt_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.sqrt.v8f32
-    simd_fsqrt(a)
-}
-
-// CHECK-LABEL: @fsqrt_32x16
-#[no_mangle]
-pub unsafe fn fsqrt_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.sqrt.v16f32
-    simd_fsqrt(a)
-}
-
-// CHECK-LABEL: @fsqrt_64x4
-#[no_mangle]
-pub unsafe fn fsqrt_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.sqrt.v4f64
-    simd_fsqrt(a)
-}
-
-// CHECK-LABEL: @fsqrt_64x2
-#[no_mangle]
-pub unsafe fn fsqrt_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.sqrt.v2f64
-    simd_fsqrt(a)
-}
-
-// CHECK-LABEL: @fsqrt_64x8
-#[no_mangle]
-pub unsafe fn fsqrt_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.sqrt.v8f64
-    simd_fsqrt(a)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
deleted file mode 100644
index bf1ffc76330..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_flog;
-
-// CHECK-LABEL: @log_32x2
-#[no_mangle]
-pub unsafe fn log_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.log.v2f32
-    simd_flog(a)
-}
-
-// CHECK-LABEL: @log_32x4
-#[no_mangle]
-pub unsafe fn log_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.log.v4f32
-    simd_flog(a)
-}
-
-// CHECK-LABEL: @log_32x8
-#[no_mangle]
-pub unsafe fn log_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.log.v8f32
-    simd_flog(a)
-}
-
-// CHECK-LABEL: @log_32x16
-#[no_mangle]
-pub unsafe fn log_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.log.v16f32
-    simd_flog(a)
-}
-
-// CHECK-LABEL: @log_64x4
-#[no_mangle]
-pub unsafe fn log_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.log.v4f64
-    simd_flog(a)
-}
-
-// CHECK-LABEL: @log_64x2
-#[no_mangle]
-pub unsafe fn log_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.log.v2f64
-    simd_flog(a)
-}
-
-// CHECK-LABEL: @log_64x8
-#[no_mangle]
-pub unsafe fn log_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.log.v8f64
-    simd_flog(a)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
deleted file mode 100644
index ccf484e0e41..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_flog10;
-
-// CHECK-LABEL: @log10_32x2
-#[no_mangle]
-pub unsafe fn log10_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.log10.v2f32
-    simd_flog10(a)
-}
-
-// CHECK-LABEL: @log10_32x4
-#[no_mangle]
-pub unsafe fn log10_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.log10.v4f32
-    simd_flog10(a)
-}
-
-// CHECK-LABEL: @log10_32x8
-#[no_mangle]
-pub unsafe fn log10_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.log10.v8f32
-    simd_flog10(a)
-}
-
-// CHECK-LABEL: @log10_32x16
-#[no_mangle]
-pub unsafe fn log10_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.log10.v16f32
-    simd_flog10(a)
-}
-
-// CHECK-LABEL: @log10_64x4
-#[no_mangle]
-pub unsafe fn log10_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.log10.v4f64
-    simd_flog10(a)
-}
-
-// CHECK-LABEL: @log10_64x2
-#[no_mangle]
-pub unsafe fn log10_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.log10.v2f64
-    simd_flog10(a)
-}
-
-// CHECK-LABEL: @log10_64x8
-#[no_mangle]
-pub unsafe fn log10_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.log10.v8f64
-    simd_flog10(a)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
deleted file mode 100644
index 677d8b01e84..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_flog2;
-
-// CHECK-LABEL: @log2_32x2
-#[no_mangle]
-pub unsafe fn log2_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.log2.v2f32
-    simd_flog2(a)
-}
-
-// CHECK-LABEL: @log2_32x4
-#[no_mangle]
-pub unsafe fn log2_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.log2.v4f32
-    simd_flog2(a)
-}
-
-// CHECK-LABEL: @log2_32x8
-#[no_mangle]
-pub unsafe fn log2_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.log2.v8f32
-    simd_flog2(a)
-}
-
-// CHECK-LABEL: @log2_32x16
-#[no_mangle]
-pub unsafe fn log2_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.log2.v16f32
-    simd_flog2(a)
-}
-
-// CHECK-LABEL: @log2_64x4
-#[no_mangle]
-pub unsafe fn log2_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.log2.v4f64
-    simd_flog2(a)
-}
-
-// CHECK-LABEL: @log2_64x2
-#[no_mangle]
-pub unsafe fn log2_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.log2.v2f64
-    simd_flog2(a)
-}
-
-// CHECK-LABEL: @log2_64x8
-#[no_mangle]
-pub unsafe fn log2_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.log2.v8f64
-    simd_flog2(a)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs
deleted file mode 100644
index 8dd464a1bff..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::{simd_fmax, simd_fmin};
-
-// 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-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)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
deleted file mode 100644
index 48becc72c0b..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_fsin;
-
-// CHECK-LABEL: @fsin_32x2
-#[no_mangle]
-pub unsafe fn fsin_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.sin.v2f32
-    simd_fsin(a)
-}
-
-// CHECK-LABEL: @fsin_32x4
-#[no_mangle]
-pub unsafe fn fsin_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.sin.v4f32
-    simd_fsin(a)
-}
-
-// CHECK-LABEL: @fsin_32x8
-#[no_mangle]
-pub unsafe fn fsin_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.sin.v8f32
-    simd_fsin(a)
-}
-
-// CHECK-LABEL: @fsin_32x16
-#[no_mangle]
-pub unsafe fn fsin_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.sin.v16f32
-    simd_fsin(a)
-}
-
-// CHECK-LABEL: @fsin_64x4
-#[no_mangle]
-pub unsafe fn fsin_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.sin.v4f64
-    simd_fsin(a)
-}
-
-// CHECK-LABEL: @fsin_64x2
-#[no_mangle]
-pub unsafe fn fsin_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.sin.v2f64
-    simd_fsin(a)
-}
-
-// CHECK-LABEL: @fsin_64x8
-#[no_mangle]
-pub unsafe fn fsin_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.sin.v8f64
-    simd_fsin(a)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
deleted file mode 100644
index 06d46889715..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
+++ /dev/null
@@ -1,579 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-#![deny(unused)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
-
-// NOTE(eddyb) `%{{x|0}}` is used because on some targets (e.g. WASM)
-// SIMD vectors are passed directly, resulting in `%x` being a vector,
-// while on others they're passed indirectly, resulting in `%x` being
-// a pointer to a vector, and `%0` a vector loaded from that pointer.
-// This is controlled by the target spec option `simd_types_indirect`.
-// The same applies to `%{{y|1}}` as well.
-
-// CHECK-LABEL: @sadd_i8x2
-#[no_mangle]
-pub unsafe fn sadd_i8x2(x: i8x2, y: i8x2) -> i8x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %{{x|0}}, <2 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i8x4
-#[no_mangle]
-pub unsafe fn sadd_i8x4(x: i8x4, y: i8x4) -> i8x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.sadd.sat.v4i8(<4 x i8> %{{x|0}}, <4 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i8x8
-#[no_mangle]
-pub unsafe fn sadd_i8x8(x: i8x8, y: i8x8) -> i8x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.sadd.sat.v8i8(<8 x i8> %{{x|0}}, <8 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i8x16
-#[no_mangle]
-pub unsafe fn sadd_i8x16(x: i8x16, y: i8x16) -> i8x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.sadd.sat.v16i8(<16 x i8> %{{x|0}}, <16 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i8x32
-#[no_mangle]
-pub unsafe fn sadd_i8x32(x: i8x32, y: i8x32) -> i8x32 {
-    // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.sadd.sat.v32i8(<32 x i8> %{{x|0}}, <32 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i8x64
-#[no_mangle]
-pub unsafe fn sadd_i8x64(x: i8x64, y: i8x64) -> i8x64 {
-    // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.sadd.sat.v64i8(<64 x i8> %{{x|0}}, <64 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i16x2
-#[no_mangle]
-pub unsafe fn sadd_i16x2(x: i16x2, y: i16x2) -> i16x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.sadd.sat.v2i16(<2 x i16> %{{x|0}}, <2 x i16> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i16x4
-#[no_mangle]
-pub unsafe fn sadd_i16x4(x: i16x4, y: i16x4) -> i16x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.sadd.sat.v4i16(<4 x i16> %{{x|0}}, <4 x i16> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i16x8
-#[no_mangle]
-pub unsafe fn sadd_i16x8(x: i16x8, y: i16x8) -> i16x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.sadd.sat.v8i16(<8 x i16> %{{x|0}}, <8 x i16> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i16x16
-#[no_mangle]
-pub unsafe fn sadd_i16x16(x: i16x16, y: i16x16) -> i16x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.sadd.sat.v16i16(<16 x i16> %{{x|0}}, <16 x i16> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i16x32
-#[no_mangle]
-pub unsafe fn sadd_i16x32(x: i16x32, y: i16x32) -> i16x32 {
-    // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.sadd.sat.v32i16(<32 x i16> %{{x|0}}, <32 x i16> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i32x2
-#[no_mangle]
-pub unsafe fn sadd_i32x2(x: i32x2, y: i32x2) -> i32x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.sadd.sat.v2i32(<2 x i32> %{{x|0}}, <2 x i32> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i32x4
-#[no_mangle]
-pub unsafe fn sadd_i32x4(x: i32x4, y: i32x4) -> i32x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.sadd.sat.v4i32(<4 x i32> %{{x|0}}, <4 x i32> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i32x8
-#[no_mangle]
-pub unsafe fn sadd_i32x8(x: i32x8, y: i32x8) -> i32x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.sadd.sat.v8i32(<8 x i32> %{{x|0}}, <8 x i32> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i32x16
-#[no_mangle]
-pub unsafe fn sadd_i32x16(x: i32x16, y: i32x16) -> i32x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.sadd.sat.v16i32(<16 x i32> %{{x|0}}, <16 x i32> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i64x2
-#[no_mangle]
-pub unsafe fn sadd_i64x2(x: i64x2, y: i64x2) -> i64x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.sadd.sat.v2i64(<2 x i64> %{{x|0}}, <2 x i64> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i64x4
-#[no_mangle]
-pub unsafe fn sadd_i64x4(x: i64x4, y: i64x4) -> i64x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.sadd.sat.v4i64(<4 x i64> %{{x|0}}, <4 x i64> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i64x8
-#[no_mangle]
-pub unsafe fn sadd_i64x8(x: i64x8, y: i64x8) -> i64x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.sadd.sat.v8i64(<8 x i64> %{{x|0}}, <8 x i64> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i128x2
-#[no_mangle]
-pub unsafe fn sadd_i128x2(x: i128x2, y: i128x2) -> i128x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.sadd.sat.v2i128(<2 x i128> %{{x|0}}, <2 x i128> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @sadd_i128x4
-#[no_mangle]
-pub unsafe fn sadd_i128x4(x: i128x4, y: i128x4) -> i128x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.sadd.sat.v4i128(<4 x i128> %{{x|0}}, <4 x i128> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u8x2
-#[no_mangle]
-pub unsafe fn uadd_u8x2(x: u8x2, y: u8x2) -> u8x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %{{x|0}}, <2 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u8x4
-#[no_mangle]
-pub unsafe fn uadd_u8x4(x: u8x4, y: u8x4) -> u8x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.uadd.sat.v4i8(<4 x i8> %{{x|0}}, <4 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u8x8
-#[no_mangle]
-pub unsafe fn uadd_u8x8(x: u8x8, y: u8x8) -> u8x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.uadd.sat.v8i8(<8 x i8> %{{x|0}}, <8 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u8x16
-#[no_mangle]
-pub unsafe fn uadd_u8x16(x: u8x16, y: u8x16) -> u8x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.uadd.sat.v16i8(<16 x i8> %{{x|0}}, <16 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u8x32
-#[no_mangle]
-pub unsafe fn uadd_u8x32(x: u8x32, y: u8x32) -> u8x32 {
-    // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.uadd.sat.v32i8(<32 x i8> %{{x|0}}, <32 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u8x64
-#[no_mangle]
-pub unsafe fn uadd_u8x64(x: u8x64, y: u8x64) -> u8x64 {
-    // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.uadd.sat.v64i8(<64 x i8> %{{x|0}}, <64 x i8> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u16x2
-#[no_mangle]
-pub unsafe fn uadd_u16x2(x: u16x2, y: u16x2) -> u16x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.uadd.sat.v2i16(<2 x i16> %{{x|0}}, <2 x i16> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u16x4
-#[no_mangle]
-pub unsafe fn uadd_u16x4(x: u16x4, y: u16x4) -> u16x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.uadd.sat.v4i16(<4 x i16> %{{x|0}}, <4 x i16> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u16x8
-#[no_mangle]
-pub unsafe fn uadd_u16x8(x: u16x8, y: u16x8) -> u16x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.uadd.sat.v8i16(<8 x i16> %{{x|0}}, <8 x i16> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u16x16
-#[no_mangle]
-pub unsafe fn uadd_u16x16(x: u16x16, y: u16x16) -> u16x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.uadd.sat.v16i16(<16 x i16> %{{x|0}}, <16 x i16> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u16x32
-#[no_mangle]
-pub unsafe fn uadd_u16x32(x: u16x32, y: u16x32) -> u16x32 {
-    // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.uadd.sat.v32i16(<32 x i16> %{{x|0}}, <32 x i16> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u32x2
-#[no_mangle]
-pub unsafe fn uadd_u32x2(x: u32x2, y: u32x2) -> u32x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.uadd.sat.v2i32(<2 x i32> %{{x|0}}, <2 x i32> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u32x4
-#[no_mangle]
-pub unsafe fn uadd_u32x4(x: u32x4, y: u32x4) -> u32x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.uadd.sat.v4i32(<4 x i32> %{{x|0}}, <4 x i32> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u32x8
-#[no_mangle]
-pub unsafe fn uadd_u32x8(x: u32x8, y: u32x8) -> u32x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.uadd.sat.v8i32(<8 x i32> %{{x|0}}, <8 x i32> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u32x16
-#[no_mangle]
-pub unsafe fn uadd_u32x16(x: u32x16, y: u32x16) -> u32x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.uadd.sat.v16i32(<16 x i32> %{{x|0}}, <16 x i32> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u64x2
-#[no_mangle]
-pub unsafe fn uadd_u64x2(x: u64x2, y: u64x2) -> u64x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.uadd.sat.v2i64(<2 x i64> %{{x|0}}, <2 x i64> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u64x4
-#[no_mangle]
-pub unsafe fn uadd_u64x4(x: u64x4, y: u64x4) -> u64x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.uadd.sat.v4i64(<4 x i64> %{{x|0}}, <4 x i64> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u64x8
-#[no_mangle]
-pub unsafe fn uadd_u64x8(x: u64x8, y: u64x8) -> u64x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.uadd.sat.v8i64(<8 x i64> %{{x|0}}, <8 x i64> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u128x2
-#[no_mangle]
-pub unsafe fn uadd_u128x2(x: u128x2, y: u128x2) -> u128x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.uadd.sat.v2i128(<2 x i128> %{{x|0}}, <2 x i128> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @uadd_u128x4
-#[no_mangle]
-pub unsafe fn uadd_u128x4(x: u128x4, y: u128x4) -> u128x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.uadd.sat.v4i128(<4 x i128> %{{x|0}}, <4 x i128> %{{y|1}})
-    simd_saturating_add(x, y)
-}
-
-// CHECK-LABEL: @ssub_i8x2
-#[no_mangle]
-pub unsafe fn ssub_i8x2(x: i8x2, y: i8x2) -> i8x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %{{x|0}}, <2 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i8x4
-#[no_mangle]
-pub unsafe fn ssub_i8x4(x: i8x4, y: i8x4) -> i8x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.ssub.sat.v4i8(<4 x i8> %{{x|0}}, <4 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i8x8
-#[no_mangle]
-pub unsafe fn ssub_i8x8(x: i8x8, y: i8x8) -> i8x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.ssub.sat.v8i8(<8 x i8> %{{x|0}}, <8 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i8x16
-#[no_mangle]
-pub unsafe fn ssub_i8x16(x: i8x16, y: i8x16) -> i8x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.ssub.sat.v16i8(<16 x i8> %{{x|0}}, <16 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i8x32
-#[no_mangle]
-pub unsafe fn ssub_i8x32(x: i8x32, y: i8x32) -> i8x32 {
-    // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.ssub.sat.v32i8(<32 x i8> %{{x|0}}, <32 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i8x64
-#[no_mangle]
-pub unsafe fn ssub_i8x64(x: i8x64, y: i8x64) -> i8x64 {
-    // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.ssub.sat.v64i8(<64 x i8> %{{x|0}}, <64 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i16x2
-#[no_mangle]
-pub unsafe fn ssub_i16x2(x: i16x2, y: i16x2) -> i16x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.ssub.sat.v2i16(<2 x i16> %{{x|0}}, <2 x i16> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i16x4
-#[no_mangle]
-pub unsafe fn ssub_i16x4(x: i16x4, y: i16x4) -> i16x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.ssub.sat.v4i16(<4 x i16> %{{x|0}}, <4 x i16> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i16x8
-#[no_mangle]
-pub unsafe fn ssub_i16x8(x: i16x8, y: i16x8) -> i16x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.ssub.sat.v8i16(<8 x i16> %{{x|0}}, <8 x i16> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i16x16
-#[no_mangle]
-pub unsafe fn ssub_i16x16(x: i16x16, y: i16x16) -> i16x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.ssub.sat.v16i16(<16 x i16> %{{x|0}}, <16 x i16> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i16x32
-#[no_mangle]
-pub unsafe fn ssub_i16x32(x: i16x32, y: i16x32) -> i16x32 {
-    // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.ssub.sat.v32i16(<32 x i16> %{{x|0}}, <32 x i16> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i32x2
-#[no_mangle]
-pub unsafe fn ssub_i32x2(x: i32x2, y: i32x2) -> i32x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.ssub.sat.v2i32(<2 x i32> %{{x|0}}, <2 x i32> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i32x4
-#[no_mangle]
-pub unsafe fn ssub_i32x4(x: i32x4, y: i32x4) -> i32x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.ssub.sat.v4i32(<4 x i32> %{{x|0}}, <4 x i32> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i32x8
-#[no_mangle]
-pub unsafe fn ssub_i32x8(x: i32x8, y: i32x8) -> i32x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.ssub.sat.v8i32(<8 x i32> %{{x|0}}, <8 x i32> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i32x16
-#[no_mangle]
-pub unsafe fn ssub_i32x16(x: i32x16, y: i32x16) -> i32x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.ssub.sat.v16i32(<16 x i32> %{{x|0}}, <16 x i32> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i64x2
-#[no_mangle]
-pub unsafe fn ssub_i64x2(x: i64x2, y: i64x2) -> i64x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.ssub.sat.v2i64(<2 x i64> %{{x|0}}, <2 x i64> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i64x4
-#[no_mangle]
-pub unsafe fn ssub_i64x4(x: i64x4, y: i64x4) -> i64x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.ssub.sat.v4i64(<4 x i64> %{{x|0}}, <4 x i64> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i64x8
-#[no_mangle]
-pub unsafe fn ssub_i64x8(x: i64x8, y: i64x8) -> i64x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.ssub.sat.v8i64(<8 x i64> %{{x|0}}, <8 x i64> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i128x2
-#[no_mangle]
-pub unsafe fn ssub_i128x2(x: i128x2, y: i128x2) -> i128x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.ssub.sat.v2i128(<2 x i128> %{{x|0}}, <2 x i128> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @ssub_i128x4
-#[no_mangle]
-pub unsafe fn ssub_i128x4(x: i128x4, y: i128x4) -> i128x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.ssub.sat.v4i128(<4 x i128> %{{x|0}}, <4 x i128> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u8x2
-#[no_mangle]
-pub unsafe fn usub_u8x2(x: u8x2, y: u8x2) -> u8x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %{{x|0}}, <2 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u8x4
-#[no_mangle]
-pub unsafe fn usub_u8x4(x: u8x4, y: u8x4) -> u8x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.usub.sat.v4i8(<4 x i8> %{{x|0}}, <4 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u8x8
-#[no_mangle]
-pub unsafe fn usub_u8x8(x: u8x8, y: u8x8) -> u8x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.usub.sat.v8i8(<8 x i8> %{{x|0}}, <8 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u8x16
-#[no_mangle]
-pub unsafe fn usub_u8x16(x: u8x16, y: u8x16) -> u8x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.usub.sat.v16i8(<16 x i8> %{{x|0}}, <16 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u8x32
-#[no_mangle]
-pub unsafe fn usub_u8x32(x: u8x32, y: u8x32) -> u8x32 {
-    // CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.usub.sat.v32i8(<32 x i8> %{{x|0}}, <32 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u8x64
-#[no_mangle]
-pub unsafe fn usub_u8x64(x: u8x64, y: u8x64) -> u8x64 {
-    // CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.usub.sat.v64i8(<64 x i8> %{{x|0}}, <64 x i8> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u16x2
-#[no_mangle]
-pub unsafe fn usub_u16x2(x: u16x2, y: u16x2) -> u16x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.usub.sat.v2i16(<2 x i16> %{{x|0}}, <2 x i16> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u16x4
-#[no_mangle]
-pub unsafe fn usub_u16x4(x: u16x4, y: u16x4) -> u16x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.usub.sat.v4i16(<4 x i16> %{{x|0}}, <4 x i16> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u16x8
-#[no_mangle]
-pub unsafe fn usub_u16x8(x: u16x8, y: u16x8) -> u16x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.usub.sat.v8i16(<8 x i16> %{{x|0}}, <8 x i16> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u16x16
-#[no_mangle]
-pub unsafe fn usub_u16x16(x: u16x16, y: u16x16) -> u16x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.usub.sat.v16i16(<16 x i16> %{{x|0}}, <16 x i16> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u16x32
-#[no_mangle]
-pub unsafe fn usub_u16x32(x: u16x32, y: u16x32) -> u16x32 {
-    // CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.usub.sat.v32i16(<32 x i16> %{{x|0}}, <32 x i16> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u32x2
-#[no_mangle]
-pub unsafe fn usub_u32x2(x: u32x2, y: u32x2) -> u32x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.usub.sat.v2i32(<2 x i32> %{{x|0}}, <2 x i32> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u32x4
-#[no_mangle]
-pub unsafe fn usub_u32x4(x: u32x4, y: u32x4) -> u32x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.usub.sat.v4i32(<4 x i32> %{{x|0}}, <4 x i32> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u32x8
-#[no_mangle]
-pub unsafe fn usub_u32x8(x: u32x8, y: u32x8) -> u32x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.usub.sat.v8i32(<8 x i32> %{{x|0}}, <8 x i32> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u32x16
-#[no_mangle]
-pub unsafe fn usub_u32x16(x: u32x16, y: u32x16) -> u32x16 {
-    // CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.usub.sat.v16i32(<16 x i32> %{{x|0}}, <16 x i32> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u64x2
-#[no_mangle]
-pub unsafe fn usub_u64x2(x: u64x2, y: u64x2) -> u64x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.usub.sat.v2i64(<2 x i64> %{{x|0}}, <2 x i64> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u64x4
-#[no_mangle]
-pub unsafe fn usub_u64x4(x: u64x4, y: u64x4) -> u64x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.usub.sat.v4i64(<4 x i64> %{{x|0}}, <4 x i64> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u64x8
-#[no_mangle]
-pub unsafe fn usub_u64x8(x: u64x8, y: u64x8) -> u64x8 {
-    // CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.usub.sat.v8i64(<8 x i64> %{{x|0}}, <8 x i64> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u128x2
-#[no_mangle]
-pub unsafe fn usub_u128x2(x: u128x2, y: u128x2) -> u128x2 {
-    // CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.usub.sat.v2i128(<2 x i128> %{{x|0}}, <2 x i128> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
-
-// CHECK-LABEL: @usub_u128x4
-#[no_mangle]
-pub unsafe fn usub_u128x4(x: u128x4, y: u128x4) -> u128x4 {
-    // CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.usub.sat.v4i128(<4 x i128> %{{x|0}}, <4 x i128> %{{y|1}})
-    simd_saturating_sub(x, y)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
deleted file mode 100644
index 294262d8152..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-//
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_bitmask;
-
-// NOTE(eddyb) `%{{x|1}}` is used because on some targets (e.g. WASM)
-// SIMD vectors are passed directly, resulting in `%x` being a vector,
-// while on others they're passed indirectly, resulting in `%x` being
-// a pointer to a vector, and `%1` a vector loaded from that pointer.
-// This is controlled by the target spec option `simd_types_indirect`.
-
-// CHECK-LABEL: @bitmask_int
-#[no_mangle]
-pub unsafe fn bitmask_int(x: i32x2) -> u8 {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{x|1}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: [[C:%[0-9]+]] = bitcast <2 x i1> [[B]] to i2
-    // CHECK: %{{[0-9]+}} = zext i2 [[C]] to i8
-    simd_bitmask(x)
-}
-
-// CHECK-LABEL: @bitmask_uint
-#[no_mangle]
-pub unsafe fn bitmask_uint(x: u32x2) -> u8 {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{x|1}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: [[C:%[0-9]+]] = bitcast <2 x i1> [[B]] to i2
-    // CHECK: %{{[0-9]+}} = zext i2 [[C]] to i8
-    simd_bitmask(x)
-}
-
-// CHECK-LABEL: @bitmask_int16
-#[no_mangle]
-pub unsafe fn bitmask_int16(x: i8x16) -> u16 {
-    // CHECK: [[A:%[0-9]+]] = lshr <16 x i8> %{{x|1|2}}, {{<i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>|splat \(i8 7\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <16 x i8> [[A]] to <16 x i1>
-    // CHECK: %{{[0-9]+}} = bitcast <16 x i1> [[B]] to i16
-    // CHECK-NOT: zext
-    simd_bitmask(x)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs
deleted file mode 100644
index 690bfb432f9..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_gather;
-
-pub type Vec2<T> = Simd<T, 2>;
-pub type Vec4<T> = Simd<T, 4>;
-
-// CHECK-LABEL: @gather_f32x2
-#[no_mangle]
-pub unsafe fn gather_f32x2(
-    pointers: Vec2<*const f32>,
-    mask: Vec2<i32>,
-    values: Vec2<f32>,
-) -> Vec2<f32> {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: call <2 x float> @llvm.masked.gather.v2f32.v2p0(<2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]], <2 x float> {{.*}})
-    simd_gather(values, pointers, mask)
-}
-
-// CHECK-LABEL: @gather_f32x2_unsigned
-#[no_mangle]
-pub unsafe fn gather_f32x2_unsigned(
-    pointers: Vec2<*const f32>,
-    mask: Vec2<u32>,
-    values: Vec2<f32>,
-) -> Vec2<f32> {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: call <2 x float> @llvm.masked.gather.v2f32.v2p0(<2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]], <2 x float> {{.*}})
-    simd_gather(values, pointers, mask)
-}
-
-// CHECK-LABEL: @gather_pf32x2
-#[no_mangle]
-pub unsafe fn gather_pf32x2(
-    pointers: Vec2<*const *const f32>,
-    mask: Vec2<i32>,
-    values: Vec2<*const f32>,
-) -> Vec2<*const f32> {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: call <2 x ptr> @llvm.masked.gather.v2p0.v2p0(<2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]], <2 x ptr> {{.*}})
-    simd_gather(values, pointers, mask)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
deleted file mode 100644
index fda315dc66c..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_masked_load;
-
-pub type Vec2<T> = Simd<T, 2>;
-pub type Vec4<T> = Simd<T, 4>;
-
-// CHECK-LABEL: @load_f32x2
-#[no_mangle]
-pub unsafe fn load_f32x2(mask: Vec2<i32>, pointer: *const f32, values: Vec2<f32>) -> Vec2<f32> {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: call <2 x float> @llvm.masked.load.v2f32.p0(ptr {{.*}}, i32 4, <2 x i1> [[B]], <2 x float> {{.*}})
-    simd_masked_load(mask, pointer, values)
-}
-
-// CHECK-LABEL: @load_f32x2_unsigned
-#[no_mangle]
-pub unsafe fn load_f32x2_unsigned(
-    mask: Vec2<u32>,
-    pointer: *const f32,
-    values: Vec2<f32>,
-) -> Vec2<f32> {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: call <2 x float> @llvm.masked.load.v2f32.p0(ptr {{.*}}, i32 4, <2 x i1> [[B]], <2 x float> {{.*}})
-    simd_masked_load(mask, pointer, values)
-}
-
-// CHECK-LABEL: @load_pf32x4
-#[no_mangle]
-pub unsafe fn load_pf32x4(
-    mask: Vec4<i32>,
-    pointer: *const *const f32,
-    values: Vec4<*const f32>,
-) -> Vec4<*const f32> {
-    // CHECK: [[A:%[0-9]+]] = lshr <4 x i32> {{.*}}, {{<i32 31, i32 31, i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <4 x i32> [[A]] to <4 x i1>
-    // CHECK: call <4 x ptr> @llvm.masked.load.v4p0.p0(ptr {{.*}}, i32 {{.*}}, <4 x i1> [[B]], <4 x ptr> {{.*}})
-    simd_masked_load(mask, pointer, values)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
deleted file mode 100644
index 6ca7388d464..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_masked_store;
-
-pub type Vec2<T> = Simd<T, 2>;
-pub type Vec4<T> = Simd<T, 4>;
-
-// CHECK-LABEL: @store_f32x2
-#[no_mangle]
-pub unsafe fn store_f32x2(mask: Vec2<i32>, pointer: *mut f32, values: Vec2<f32>) {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: call void @llvm.masked.store.v2f32.p0(<2 x float> {{.*}}, ptr {{.*}}, i32 4, <2 x i1> [[B]])
-    simd_masked_store(mask, pointer, values)
-}
-
-// CHECK-LABEL: @store_f32x2_unsigned
-#[no_mangle]
-pub unsafe fn store_f32x2_unsigned(mask: Vec2<u32>, pointer: *mut f32, values: Vec2<f32>) {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: call void @llvm.masked.store.v2f32.p0(<2 x float> {{.*}}, ptr {{.*}}, i32 4, <2 x i1> [[B]])
-    simd_masked_store(mask, pointer, values)
-}
-
-// CHECK-LABEL: @store_pf32x4
-#[no_mangle]
-pub unsafe fn store_pf32x4(mask: Vec4<i32>, pointer: *mut *const f32, values: Vec4<*const f32>) {
-    // CHECK: [[A:%[0-9]+]] = lshr <4 x i32> {{.*}}, {{<i32 31, i32 31, i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <4 x i32> [[A]] to <4 x i1>
-    // CHECK: call void @llvm.masked.store.v4p0.p0(<4 x ptr> {{.*}}, ptr {{.*}}, i32 {{.*}}, <4 x i1> [[B]])
-    simd_masked_store(mask, pointer, values)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs
deleted file mode 100644
index 743652966e1..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::simd_scatter;
-
-pub type Vec2<T> = Simd<T, 2>;
-pub type Vec4<T> = Simd<T, 4>;
-
-// CHECK-LABEL: @scatter_f32x2
-#[no_mangle]
-pub unsafe fn scatter_f32x2(pointers: Vec2<*mut f32>, mask: Vec2<i32>, values: Vec2<f32>) {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: call void @llvm.masked.scatter.v2f32.v2p0(<2 x float> {{.*}}, <2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]]
-    simd_scatter(values, pointers, mask)
-}
-
-// CHECK-LABEL: @scatter_f32x2_unsigned
-#[no_mangle]
-pub unsafe fn scatter_f32x2_unsigned(pointers: Vec2<*mut f32>, mask: Vec2<u32>, values: Vec2<f32>) {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: call void @llvm.masked.scatter.v2f32.v2p0(<2 x float> {{.*}}, <2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]]
-    simd_scatter(values, pointers, mask)
-}
-
-// CHECK-LABEL: @scatter_pf32x2
-#[no_mangle]
-pub unsafe fn scatter_pf32x2(
-    pointers: Vec2<*mut *const f32>,
-    mask: Vec2<i32>,
-    values: Vec2<*const f32>,
-) {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: call void @llvm.masked.scatter.v2p0.v2p0(<2 x ptr> {{.*}}, <2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]]
-    simd_scatter(values, pointers, mask)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs
deleted file mode 100644
index 2c0bad21f44..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::{simd_select, simd_select_bitmask};
-
-pub type b8x4 = i8x4;
-
-// CHECK-LABEL: @select_m8
-#[no_mangle]
-pub unsafe fn select_m8(m: b8x4, a: f32x4, b: f32x4) -> f32x4 {
-    // CHECK: [[A:%[0-9]+]] = lshr <4 x i8> %{{.*}}, {{<i8 7, i8 7, i8 7, i8 7>|splat \(i8 7\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <4 x i8> [[A]] to <4 x i1>
-    // CHECK: select <4 x i1> [[B]]
-    simd_select(m, a, b)
-}
-
-// CHECK-LABEL: @select_m32
-#[no_mangle]
-pub unsafe fn select_m32(m: i32x4, a: f32x4, b: f32x4) -> f32x4 {
-    // CHECK: [[A:%[0-9]+]] = lshr <4 x i32> %{{.*}}, {{<i32 31, i32 31, i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <4 x i32> [[A]] to <4 x i1>
-    // CHECK: select <4 x i1> [[B]]
-    simd_select(m, a, b)
-}
-
-// CHECK-LABEL: @select_m32_unsigned
-#[no_mangle]
-pub unsafe fn select_m32_unsigned(m: u32x4, a: f32x4, b: f32x4) -> f32x4 {
-    // CHECK: [[A:%[0-9]+]] = lshr <4 x i32> %{{.*}}, {{<i32 31, i32 31, i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <4 x i32> [[A]] to <4 x i1>
-    // CHECK: select <4 x i1> [[B]]
-    simd_select(m, a, b)
-}
-
-// CHECK-LABEL: @select_bitmask
-#[no_mangle]
-pub unsafe fn select_bitmask(m: i8, a: f32x8, b: f32x8) -> f32x8 {
-    // CHECK: [[A:%[0-9]+]] = bitcast i8 {{.*}} to <8 x i1>
-    // CHECK: select <8 x i1> [[A]]
-    simd_select_bitmask(m, a, b)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs
deleted file mode 100644
index 79f00a6ed60..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-use std::intrinsics::simd::{simd_reduce_all, simd_reduce_any};
-
-pub type mask32x2 = Simd<i32, 2>;
-pub type mask8x16 = Simd<i8, 16>;
-
-// NOTE(eddyb) `%{{x|1}}` is used because on some targets (e.g. WASM)
-// SIMD vectors are passed directly, resulting in `%x` being a vector,
-// while on others they're passed indirectly, resulting in `%x` being
-// a pointer to a vector, and `%1` a vector loaded from that pointer.
-// This is controlled by the target spec option `simd_types_indirect`.
-
-// CHECK-LABEL: @reduce_any_32x2
-#[no_mangle]
-pub unsafe fn reduce_any_32x2(x: mask32x2) -> bool {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{x|1}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: [[C:%[0-9]+]] = call i1 @llvm.vector.reduce.or.v2i1(<2 x i1> [[B]])
-    // CHECK: %{{[0-9]+}} = zext i1 [[C]] to i8
-    simd_reduce_any(x)
-}
-
-// CHECK-LABEL: @reduce_all_32x2
-#[no_mangle]
-pub unsafe fn reduce_all_32x2(x: mask32x2) -> bool {
-    // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{x|1}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
-    // CHECK: [[C:%[0-9]+]] = call i1 @llvm.vector.reduce.and.v2i1(<2 x i1> [[B]])
-    // CHECK: %{{[0-9]+}} = zext i1 [[C]] to i8
-    simd_reduce_all(x)
-}
-
-// CHECK-LABEL: @reduce_any_8x16
-#[no_mangle]
-pub unsafe fn reduce_any_8x16(x: mask8x16) -> bool {
-    // CHECK: [[A:%[0-9]+]] = lshr <16 x i8> %{{x|1}}, {{<i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>|splat \(i8 7\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <16 x i8> [[A]] to <16 x i1>
-    // CHECK: [[C:%[0-9]+]] = call i1 @llvm.vector.reduce.or.v16i1(<16 x i1> [[B]])
-    // CHECK: %{{[0-9]+}} = zext i1 [[C]] to i8
-    simd_reduce_any(x)
-}
-
-// CHECK-LABEL: @reduce_all_8x16
-#[no_mangle]
-pub unsafe fn reduce_all_8x16(x: mask8x16) -> bool {
-    // CHECK: [[A:%[0-9]+]] = lshr <16 x i8> %{{x|1}}, {{<i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>|splat \(i8 7\)}}
-    // CHECK: [[B:%[0-9]+]] = trunc <16 x i8> [[A]] to <16 x i1>
-    // CHECK: [[C:%[0-9]+]] = call i1 @llvm.vector.reduce.and.v16i1(<16 x i1> [[B]])
-    // CHECK: %{{[0-9]+}} = zext i1 [[C]] to i8
-    simd_reduce_all(x)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
deleted file mode 100644
index 05c2f7e1bdf..00000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-//@ compile-flags: -C no-prepopulate-passes
-// 32bit MSVC does not align things properly so we suppress high alignment annotations (#112480)
-//@ ignore-i686-pc-windows-msvc
-//@ ignore-i686-pc-windows-gnu
-
-#![crate_type = "lib"]
-#![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::*;
-
-pub type S<const N: usize> = Simd<f32, N>;
-pub type T = Simd<f32, 4>;
-
-// CHECK-LABEL: @array_align(
-#[no_mangle]
-pub fn array_align() -> usize {
-    // CHECK: ret [[USIZE:i[0-9]+]] [[ARRAY_ALIGN:[0-9]+]]
-    const { std::mem::align_of::<f32>() }
-}
-
-// CHECK-LABEL: @vector_align(
-#[no_mangle]
-pub fn vector_align() -> usize {
-    // CHECK: ret [[USIZE]] [[VECTOR_ALIGN:[0-9]+]]
-    const { std::mem::align_of::<T>() }
-}
-
-// CHECK-LABEL: @build_array_s
-#[no_mangle]
-pub fn build_array_s(x: [f32; 4]) -> S<4> {
-    // CHECK: call void @llvm.memcpy.{{.+}}({{.*}} align [[VECTOR_ALIGN]] {{.*}} align [[ARRAY_ALIGN]] {{.*}}, [[USIZE]] 16, i1 false)
-    Simd(x)
-}
-
-// CHECK-LABEL: @build_array_transmute_s
-#[no_mangle]
-pub fn build_array_transmute_s(x: [f32; 4]) -> S<4> {
-    // CHECK: call void @llvm.memcpy.{{.+}}({{.*}} align [[VECTOR_ALIGN]] {{.*}} align [[ARRAY_ALIGN]] {{.*}}, [[USIZE]] 16, i1 false)
-    unsafe { std::mem::transmute(x) }
-}
-
-// CHECK-LABEL: @build_array_t
-#[no_mangle]
-pub fn build_array_t(x: [f32; 4]) -> T {
-    // CHECK: call void @llvm.memcpy.{{.+}}({{.*}} align [[VECTOR_ALIGN]] {{.*}} align [[ARRAY_ALIGN]] {{.*}}, [[USIZE]] 16, i1 false)
-    Simd(x)
-}
-
-// CHECK-LABEL: @build_array_transmute_t
-#[no_mangle]
-pub fn build_array_transmute_t(x: [f32; 4]) -> T {
-    // CHECK: call void @llvm.memcpy.{{.+}}({{.*}} align [[VECTOR_ALIGN]] {{.*}} align [[ARRAY_ALIGN]] {{.*}}, [[USIZE]] 16, i1 false)
-    unsafe { std::mem::transmute(x) }
-}
diff --git a/tests/codegen/simd/aggregate-simd.rs b/tests/codegen/simd/aggregate-simd.rs
deleted file mode 100644
index 57a301d634c..00000000000
--- a/tests/codegen/simd/aggregate-simd.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-//@ compile-flags: -C opt-level=3 -C no-prepopulate-passes
-//@ only-64bit
-
-#![feature(core_intrinsics, repr_simd)]
-#![no_std]
-#![crate_type = "lib"]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use core::intrinsics::simd::{simd_add, simd_extract};
-
-use minisimd::*;
-
-#[repr(transparent)]
-pub struct Transparent<T>(T);
-
-// These tests don't actually care about the add/extract, but it ensures the
-// aggregated temporaries are only used in potentially-SSA ways.
-
-#[no_mangle]
-pub fn simd_aggregate_pot(x: [u32; 4], y: [u32; 4]) -> u32 {
-    // CHECK-LABEL: simd_aggregate_pot
-    // CHECK: %a = load <4 x i32>, ptr %x, align 4
-    // CHECK: %b = load <4 x i32>, ptr %y, align 4
-    // CHECK: add <4 x i32> %a, %b
-
-    unsafe {
-        let a = Simd(x);
-        let b = Simd(y);
-        let c = simd_add(a, b);
-        simd_extract(c, 1)
-    }
-}
-
-#[no_mangle]
-pub fn simd_aggregate_npot(x: [u32; 7], y: [u32; 7]) -> u32 {
-    // CHECK-LABEL: simd_aggregate_npot
-    // CHECK: %a = load <7 x i32>, ptr %x, align 4
-    // CHECK: %b = load <7 x i32>, ptr %y, align 4
-    // CHECK: add <7 x i32> %a, %b
-
-    unsafe {
-        let a = Simd(x);
-        let b = Simd(y);
-        let c = simd_add(a, b);
-        simd_extract(c, 1)
-    }
-}
-
-#[no_mangle]
-pub fn packed_simd_aggregate_pot(x: [u32; 4], y: [u32; 4]) -> u32 {
-    // CHECK-LABEL: packed_simd_aggregate_pot
-    // CHECK: %a = load <4 x i32>, ptr %x, align 4
-    // CHECK: %b = load <4 x i32>, ptr %y, align 4
-    // CHECK: add <4 x i32> %a, %b
-
-    unsafe {
-        let a = PackedSimd(x);
-        let b = PackedSimd(y);
-        let c = simd_add(a, b);
-        simd_extract(c, 1)
-    }
-}
-
-#[no_mangle]
-pub fn packed_simd_aggregate_npot(x: [u32; 7], y: [u32; 7]) -> u32 {
-    // CHECK-LABEL: packed_simd_aggregate_npot
-    // CHECK: %b = alloca [28 x i8], align 4
-    // CHECK: %a = alloca [28 x i8], align 4
-    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %a, ptr align 4 %x, i64 28, i1 false)
-    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %b, ptr align 4 %y, i64 28, i1 false)
-    // CHECK: %[[TEMPA:.+]] = load <7 x i32>, ptr %a, align 4
-    // CHECK: %[[TEMPB:.+]] = load <7 x i32>, ptr %b, align 4
-    // CHECK: add <7 x i32> %[[TEMPA]], %[[TEMPB]]
-
-    unsafe {
-        let a = PackedSimd(x);
-        let b = PackedSimd(y);
-        let c = simd_add(a, b);
-        simd_extract(c, 1)
-    }
-}
-
-#[no_mangle]
-pub fn transparent_simd_aggregate(x: [u32; 4]) -> u32 {
-    // The transparent wrapper can just use the same SSA value as its field.
-    // No extra processing or spilling needed.
-
-    // CHECK-LABEL: transparent_simd_aggregate
-    // CHECK-NOT: alloca
-    // CHECK: %[[RET:.+]] = alloca [4 x i8]
-    // CHECK-NOT: alloca
-    // CHECK: %a = load <4 x i32>, ptr %x, align 4
-    // CHECK: %[[TEMP:.+]] = extractelement <4 x i32> %a, i32 1
-    // CHECK: store i32 %[[TEMP]], ptr %[[RET]]
-
-    unsafe {
-        let a = Simd(x);
-        let b = Transparent(a);
-        simd_extract(b.0, 1)
-    }
-}
diff --git a/tests/codegen/simd/extract-insert-dyn.rs b/tests/codegen/simd/extract-insert-dyn.rs
deleted file mode 100644
index 729f0145314..00000000000
--- a/tests/codegen/simd/extract-insert-dyn.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-//@compile-flags: -C opt-level=3 -C no-prepopulate-passes
-
-#![feature(
-    core_intrinsics,
-    repr_simd,
-    arm_target_feature,
-    mips_target_feature,
-    s390x_target_feature
-)]
-#![no_std]
-#![crate_type = "lib"]
-#![allow(non_camel_case_types)]
-
-// Test that `core::intrinsics::simd::{simd_extract_dyn, simd_insert_dyn}`
-// lower to an LLVM extractelement or insertelement operation.
-
-use core::intrinsics::simd::{simd_extract, simd_extract_dyn, simd_insert, simd_insert_dyn};
-
-#[repr(simd)]
-#[derive(Clone, Copy)]
-pub struct u32x16([u32; 16]);
-
-#[repr(simd)]
-#[derive(Clone, Copy)]
-pub struct i8x16([i8; 16]);
-
-// CHECK-LABEL: dyn_simd_extract
-// CHECK: extractelement <16 x i8> %x, i32 %idx
-#[no_mangle]
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
-unsafe extern "C" fn dyn_simd_extract(x: i8x16, idx: u32) -> i8 {
-    simd_extract_dyn(x, idx)
-}
-
-// CHECK-LABEL: literal_dyn_simd_extract
-// CHECK: extractelement <16 x i8> %x, i32 7
-#[no_mangle]
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
-unsafe extern "C" fn literal_dyn_simd_extract(x: i8x16) -> i8 {
-    simd_extract_dyn(x, 7)
-}
-
-// CHECK-LABEL: const_dyn_simd_extract
-// CHECK: extractelement <16 x i8> %x, i32 7
-#[no_mangle]
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
-unsafe extern "C" fn const_dyn_simd_extract(x: i8x16) -> i8 {
-    simd_extract_dyn(x, const { 3 + 4 })
-}
-
-// CHECK-LABEL: const_simd_extract
-// CHECK: extractelement <16 x i8> %x, i32 7
-#[no_mangle]
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
-unsafe extern "C" fn const_simd_extract(x: i8x16) -> i8 {
-    simd_extract(x, const { 3 + 4 })
-}
-
-// CHECK-LABEL: dyn_simd_insert
-// CHECK: insertelement <16 x i8> %x, i8 %e, i32 %idx
-#[no_mangle]
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
-unsafe extern "C" fn dyn_simd_insert(x: i8x16, e: i8, idx: u32) -> i8x16 {
-    simd_insert_dyn(x, idx, e)
-}
-
-// CHECK-LABEL: literal_dyn_simd_insert
-// CHECK: insertelement <16 x i8> %x, i8 %e, i32 7
-#[no_mangle]
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
-unsafe extern "C" fn literal_dyn_simd_insert(x: i8x16, e: i8) -> i8x16 {
-    simd_insert_dyn(x, 7, e)
-}
-
-// CHECK-LABEL: const_dyn_simd_insert
-// CHECK: insertelement <16 x i8> %x, i8 %e, i32 7
-#[no_mangle]
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
-unsafe extern "C" fn const_dyn_simd_insert(x: i8x16, e: i8) -> i8x16 {
-    simd_insert_dyn(x, const { 3 + 4 }, e)
-}
-
-// CHECK-LABEL: const_simd_insert
-// CHECK: insertelement <16 x i8> %x, i8 %e, i32 7
-#[no_mangle]
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
-unsafe extern "C" fn const_simd_insert(x: i8x16, e: i8) -> i8x16 {
-    simd_insert(x, const { 3 + 4 }, e)
-}
diff --git a/tests/codegen/simd/packed-simd-alignment.rs b/tests/codegen/simd/packed-simd-alignment.rs
deleted file mode 100644
index 53e88d8e5cf..00000000000
--- a/tests/codegen/simd/packed-simd-alignment.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-//@ compile-flags: -Cno-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-// make sure that codegen emits correctly-aligned loads and stores for repr(packed, simd) types
-// the alignment of a load should be no less than T, and no more than the size of the vector type
-use std::intrinsics::simd as intrinsics;
-
-#[derive(Copy, Clone)]
-#[repr(packed, simd)]
-struct f32x3([f32; 3]);
-
-#[derive(Copy, Clone)]
-#[repr(packed, simd)]
-struct f32x4([f32; 4]);
-
-// CHECK-LABEL: load_f32x3
-#[no_mangle]
-pub fn load_f32x3(floats: &f32x3) -> f32x3 {
-    // FIXME: Is a memcpy really the best we can do?
-    // CHECK: @llvm.memcpy.{{.*}}ptr align 4 {{.*}}ptr align 4
-    *floats
-}
-
-// CHECK-LABEL: load_f32x4
-#[no_mangle]
-pub fn load_f32x4(floats: &f32x4) -> f32x4 {
-    // CHECK: load <4 x float>, ptr %{{[a-z0-9_]*}}, align {{4|8|16}}
-    *floats
-}
-
-// CHECK-LABEL: add_f32x3
-#[no_mangle]
-pub fn add_f32x3(x: f32x3, y: f32x3) -> f32x3 {
-    // CHECK: load <3 x float>, ptr %{{[a-z0-9_]*}}, align 4
-    unsafe { intrinsics::simd_add(x, y) }
-}
-
-// CHECK-LABEL: add_f32x4
-#[no_mangle]
-pub fn add_f32x4(x: f32x4, y: f32x4) -> f32x4 {
-    // CHECK: load <4 x float>, ptr %{{[a-z0-9_]*}}, align {{4|8|16}}
-    unsafe { intrinsics::simd_add(x, y) }
-}
diff --git a/tests/codegen/simd/packed-simd.rs b/tests/codegen/simd/packed-simd.rs
deleted file mode 100644
index 70c03fcc955..00000000000
--- a/tests/codegen/simd/packed-simd.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-//@ revisions:opt3 noopt
-//@ only-x86_64
-//@[opt3] compile-flags: -Copt-level=3
-//@[noopt] compile-flags: -Cno-prepopulate-passes
-
-#![crate_type = "lib"]
-#![no_std]
-#![feature(repr_simd, core_intrinsics)]
-use core::intrinsics::simd as intrinsics;
-use core::{mem, ptr};
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use minisimd::{PackedSimd, Simd as FullSimd};
-
-// Test codegen for not only "packed" but also "fully aligned" SIMD types, and conversion between
-// them. A repr(packed,simd) type with 3 elements can't exceed its element alignment, whereas the
-// same type as repr(simd) will instead have padding.
-
-// non-powers-of-two have padding and need to be expanded to full vectors
-fn load<T, const N: usize>(v: PackedSimd<T, N>) -> FullSimd<T, N> {
-    unsafe {
-        let mut tmp = mem::MaybeUninit::<FullSimd<T, N>>::uninit();
-        ptr::copy_nonoverlapping(&v as *const _, tmp.as_mut_ptr().cast(), 1);
-        tmp.assume_init()
-    }
-}
-
-// CHECK-LABEL: square_packed_full
-// CHECK-SAME: ptr{{[a-z_ ]*}} sret([[RET_TYPE:[^)]+]]) [[RET_ALIGN:align (8|16)]]{{[^%]*}} [[RET_VREG:%[_0-9]*]]
-// CHECK-SAME: ptr{{[a-z_ ]*}} align 4
-#[no_mangle]
-pub fn square_packed_full(x: PackedSimd<f32, 3>) -> FullSimd<f32, 3> {
-    // CHECK-NEXT: start
-    // noopt: alloca [[RET_TYPE]], [[RET_ALIGN]]
-    // CHECK: load <3 x float>
-    let x = load(x);
-    // CHECK: [[VREG:%[a-z0-9_]+]] = fmul <3 x float>
-    // CHECK-NEXT: store <3 x float> [[VREG]], ptr [[RET_VREG]], [[RET_ALIGN]]
-    // CHECK-NEXT: ret void
-    unsafe { intrinsics::simd_mul(x, x) }
-}
-
-// CHECK-LABEL: square_packed
-// CHECK-SAME: ptr{{[a-z_ ]*}} sret([[RET_TYPE:[^)]+]]) [[RET_ALIGN:align 4]]{{[^%]*}} [[RET_VREG:%[_0-9]*]]
-// CHECK-SAME: ptr{{[a-z_ ]*}} align 4
-#[no_mangle]
-pub fn square_packed(x: PackedSimd<f32, 3>) -> PackedSimd<f32, 3> {
-    // CHECK-NEXT: start
-    // CHECK-NEXT: load <3 x float>
-    // noopt-NEXT: load <3 x float>
-    // CHECK-NEXT: [[VREG:%[a-z0-9_]+]] = fmul <3 x float>
-    // CHECK-NEXT: store <3 x float> [[VREG]], ptr [[RET_VREG]], [[RET_ALIGN]]
-    // CHECK-NEXT: ret void
-    unsafe { intrinsics::simd_mul(x, x) }
-}
diff --git a/tests/codegen/simd/simd-wide-sum.rs b/tests/codegen/simd/simd-wide-sum.rs
deleted file mode 100644
index 95117b2c748..00000000000
--- a/tests/codegen/simd/simd-wide-sum.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//@ revisions: llvm mir-opt3
-//@ compile-flags: -C opt-level=3 -Z merge-functions=disabled
-//@ edition: 2021
-//@ only-x86_64
-//@ [mir-opt3]compile-flags: -Zmir-opt-level=3
-//@ [mir-opt3]build-pass
-
-// mir-opt3 is a regression test for https://github.com/rust-lang/rust/issues/98016
-
-#![crate_type = "lib"]
-#![feature(portable_simd)]
-
-use std::simd::prelude::*;
-const N: usize = 16;
-
-#[no_mangle]
-// CHECK-LABEL: @wider_reduce_simd
-pub fn wider_reduce_simd(x: Simd<u8, N>) -> u16 {
-    // CHECK: zext <16 x i8>
-    // CHECK-SAME: to <16 x i16>
-    // CHECK: call i16 @llvm.vector.reduce.add.v16i16(<16 x i16>
-    let x: Simd<u16, N> = x.cast();
-    x.reduce_sum()
-}
-
-#[no_mangle]
-// CHECK-LABEL: @wider_reduce_loop
-pub fn wider_reduce_loop(x: Simd<u8, N>) -> u16 {
-    // CHECK: zext <16 x i8>
-    // CHECK-SAME: to <16 x i16>
-    // CHECK: call i16 @llvm.vector.reduce.add.v16i16(<16 x i16>
-    let mut sum = 0_u16;
-    for i in 0..N {
-        sum += u16::from(x[i]);
-    }
-    sum
-}
-
-#[no_mangle]
-// CHECK-LABEL: @wider_reduce_iter
-pub fn wider_reduce_iter(x: Simd<u8, N>) -> u16 {
-    // CHECK: zext <16 x i8>
-    // CHECK-SAME: to <16 x i16>
-    // CHECK: call i16 @llvm.vector.reduce.add.v16i16(<16 x i16>
-    x.as_array().iter().copied().map(u16::from).sum()
-}
-
-// This iterator one is the most interesting, as it's the one
-// which used to not auto-vectorize due to a suboptimality in the
-// `<array::IntoIter as Iterator>::fold` implementation.
-
-#[no_mangle]
-// CHECK-LABEL: @wider_reduce_into_iter
-pub fn wider_reduce_into_iter(x: Simd<u8, N>) -> u16 {
-    // CHECK: zext <16 x i8>
-    // CHECK-SAME: to <16 x i16>
-    // CHECK: call i16 @llvm.vector.reduce.add.v16i16(<16 x i16>
-    x.to_array().into_iter().map(u16::from).sum()
-}
diff --git a/tests/codegen/simd/simd_arith_offset.rs b/tests/codegen/simd/simd_arith_offset.rs
deleted file mode 100644
index 210b4e9bb50..00000000000
--- a/tests/codegen/simd/simd_arith_offset.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-//@ only-64bit (because the LLVM type of i64 for usize shows up)
-//
-
-#![crate_type = "lib"]
-#![feature(repr_simd, core_intrinsics)]
-
-#[path = "../../auxiliary/minisimd.rs"]
-mod minisimd;
-use std::intrinsics::simd::simd_arith_offset;
-
-use minisimd::*;
-
-/// A vector of *const T.
-pub type SimdConstPtr<T, const LANES: usize> = Simd<*const T, LANES>;
-
-// CHECK-LABEL: smoke
-#[no_mangle]
-pub fn smoke(ptrs: SimdConstPtr<u8, 8>, offsets: Simd<usize, 8>) -> SimdConstPtr<u8, 8> {
-    // CHECK: getelementptr i8, <8 x ptr> %0, <8 x i64> %1
-    unsafe { simd_arith_offset(ptrs, offsets) }
-}
diff --git a/tests/codegen/simd/swap-simd-types.rs b/tests/codegen/simd/swap-simd-types.rs
deleted file mode 100644
index c063cc683a6..00000000000
--- a/tests/codegen/simd/swap-simd-types.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C target-feature=+avx
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-use std::mem::swap;
-
-// SIMD types are highly-aligned already, so make sure the swap code leaves their
-// types alone and doesn't pessimize them (such as by swapping them as `usize`s).
-extern crate core;
-use core::arch::x86_64::__m256;
-
-// CHECK-LABEL: @swap_single_m256
-#[no_mangle]
-pub fn swap_single_m256(x: &mut __m256, y: &mut __m256) {
-    // CHECK-NOT: alloca
-    // CHECK: load <8 x float>{{.+}}align 32
-    // CHECK: store <8 x float>{{.+}}align 32
-    swap(x, y)
-}
-
-// CHECK-LABEL: @swap_m256_slice
-#[no_mangle]
-pub fn swap_m256_slice(x: &mut [__m256], y: &mut [__m256]) {
-    // CHECK-NOT: alloca
-    // CHECK-COUNT-2: load <4 x i64>{{.+}}align 32
-    // CHECK-COUNT-2: store <4 x i64>{{.+}}align 32
-    if x.len() == y.len() {
-        x.swap_with_slice(y);
-    }
-}
-
-// CHECK-LABEL: @swap_bytes32
-#[no_mangle]
-pub fn swap_bytes32(x: &mut [u8; 32], y: &mut [u8; 32]) {
-    // CHECK-NOT: alloca
-    // CHECK-COUNT-2: load <4 x i64>{{.+}}align 1
-    // CHECK-COUNT-2: store <4 x i64>{{.+}}align 1
-    swap(x, y)
-}
diff --git a/tests/codegen/simd/unpadded-simd.rs b/tests/codegen/simd/unpadded-simd.rs
deleted file mode 100644
index ef067a15702..00000000000
--- a/tests/codegen/simd/unpadded-simd.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Make sure that no 0-sized padding is inserted in structs and that
-// structs are represented as expected by Neon intrinsics in LLVM.
-// See #87254.
-
-#![crate_type = "lib"]
-#![feature(repr_simd, abi_unadjusted)]
-
-#[derive(Copy, Clone)]
-#[repr(simd)]
-pub struct int16x4_t(pub [i16; 4]);
-
-#[derive(Copy, Clone)]
-pub struct int16x4x2_t(pub int16x4_t, pub int16x4_t);
-
-// CHECK: %int16x4x2_t = type { <4 x i16>, <4 x i16> }
-#[no_mangle]
-extern "unadjusted" fn takes_int16x4x2_t(t: int16x4x2_t) -> int16x4x2_t {
-    t
-}
diff --git a/tests/codegen/skip-mono-inside-if-false.rs b/tests/codegen/skip-mono-inside-if-false.rs
deleted file mode 100644
index 8b95de99dd3..00000000000
--- a/tests/codegen/skip-mono-inside-if-false.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-//@ compile-flags: -Cno-prepopulate-passes -Copt-level=0
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn demo_for_i32() {
-    generic_impl::<i32>();
-}
-
-// Two important things here:
-// - We replace the "then" block with `unreachable` to avoid linking problems
-// - We neither declare nor define the `big_impl` that said block "calls".
-
-// CHECK-LABEL: ; skip_mono_inside_if_false::generic_impl
-// CHECK: start:
-// CHECK-NEXT: br label %[[ELSE_BRANCH:bb[0-9]+]]
-// CHECK: [[ELSE_BRANCH]]:
-// CHECK-NEXT: call skip_mono_inside_if_false::small_impl
-// CHECK: bb{{[0-9]+}}:
-// CHECK-NEXT: ret void
-// CHECK: bb{{[0-9+]}}:
-// CHECK-NEXT: unreachable
-
-fn generic_impl<T>() {
-    trait MagicTrait {
-        const IS_BIG: bool;
-    }
-    impl<T> MagicTrait for T {
-        const IS_BIG: bool = std::mem::size_of::<T>() > 10;
-    }
-    if T::IS_BIG {
-        big_impl::<T>();
-    } else {
-        small_impl::<T>();
-    }
-}
-
-#[inline(never)]
-fn small_impl<T>() {}
-#[inline(never)]
-fn big_impl<T>() {}
diff --git a/tests/codegen/slice-as_chunks.rs b/tests/codegen/slice-as_chunks.rs
deleted file mode 100644
index 337eb8981f6..00000000000
--- a/tests/codegen/slice-as_chunks.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-64bit (because the LLVM type of i64 for usize shows up)
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @chunks4
-#[no_mangle]
-pub fn chunks4(x: &[u8]) -> &[[u8; 4]] {
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: lshr i64 %x.1, 2
-    // CHECK-NOT: shl
-    // CHECK-NOT: mul
-    // CHECK-NOT: udiv
-    // CHECK-NOT: urem
-    // CHECK: ret
-    x.as_chunks().0
-}
-
-// CHECK-LABEL: @chunks4_with_remainder
-#[no_mangle]
-pub fn chunks4_with_remainder(x: &[u8]) -> (&[[u8; 4]], &[u8]) {
-    // CHECK-DAG: and i64 %x.1, -4
-    // CHECK-DAG: and i64 %x.1, 3
-    // CHECK-DAG: lshr
-    // CHECK-NOT: mul
-    // CHECK-NOT: udiv
-    // CHECK-NOT: urem
-    // CHECK: ret
-    x.as_chunks()
-}
diff --git a/tests/codegen/slice-indexing.rs b/tests/codegen/slice-indexing.rs
deleted file mode 100644
index d957ccfb5ef..00000000000
--- a/tests/codegen/slice-indexing.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-64bit (because the LLVM type of i64 for usize shows up)
-
-#![crate_type = "lib"]
-
-use std::ops::Range;
-
-// CHECK-LABEL: @index_by_range(
-#[no_mangle]
-pub fn index_by_range(x: &[u16], r: Range<usize>) -> &[u16] {
-    // CHECK: sub nuw i64
-    &x[r]
-}
-
-// CHECK-LABEL: @get_unchecked_by_range(
-#[no_mangle]
-pub unsafe fn get_unchecked_by_range(x: &[u16], r: Range<usize>) -> &[u16] {
-    // CHECK: sub nuw i64
-    x.get_unchecked(r)
-}
-
-// CHECK-LABEL: @index_mut_by_range(
-#[no_mangle]
-pub fn index_mut_by_range(x: &mut [i32], r: Range<usize>) -> &mut [i32] {
-    // CHECK: sub nuw i64
-    &mut x[r]
-}
-
-// CHECK-LABEL: @get_unchecked_mut_by_range(
-#[no_mangle]
-pub unsafe fn get_unchecked_mut_by_range(x: &mut [i32], r: Range<usize>) -> &mut [i32] {
-    // CHECK: sub nuw i64
-    x.get_unchecked_mut(r)
-}
-
-// CHECK-LABEL: @str_index_by_range(
-#[no_mangle]
-pub fn str_index_by_range(x: &str, r: Range<usize>) -> &str {
-    // CHECK: sub nuw i64
-    &x[r]
-}
-
-// CHECK-LABEL: @str_get_unchecked_by_range(
-#[no_mangle]
-pub unsafe fn str_get_unchecked_by_range(x: &str, r: Range<usize>) -> &str {
-    // CHECK: sub nuw i64
-    x.get_unchecked(r)
-}
-
-// CHECK-LABEL: @str_index_mut_by_range(
-#[no_mangle]
-pub fn str_index_mut_by_range(x: &mut str, r: Range<usize>) -> &mut str {
-    // CHECK: sub nuw i64
-    &mut x[r]
-}
-
-// CHECK-LABEL: @str_get_unchecked_mut_by_range(
-#[no_mangle]
-pub unsafe fn str_get_unchecked_mut_by_range(x: &mut str, r: Range<usize>) -> &mut str {
-    // CHECK: sub nuw i64
-    x.get_unchecked_mut(r)
-}
-
-// CHECK-LABEL: @slice_repeated_indexing(
-#[no_mangle]
-pub fn slice_repeated_indexing(dst: &mut [u8], offset: usize) {
-    let mut i = offset;
-    // CHECK: panic_bounds_check
-    dst[i] = 1;
-    i += 1;
-    // CHECK: panic_bounds_check
-    dst[i] = 2;
-    i += 1;
-    // CHECK: panic_bounds_check
-    dst[i] = 3;
-    i += 1;
-    // CHECK: panic_bounds_check
-    dst[i] = 4;
-}
-
-// CHECK-LABEL: @slice_repeated_indexing_coalesced(
-#[no_mangle]
-pub fn slice_repeated_indexing_coalesced(dst: &mut [u8], offset: usize) {
-    let mut i = offset;
-    if i.checked_add(4).unwrap() <= dst.len() {
-        // CHECK-NOT: panic_bounds_check
-        dst[i] = 1;
-        i += 1;
-        // CHECK-NOT: panic_bounds_check
-        dst[i] = 2;
-        i += 1;
-        // CHECK-NOT: panic_bounds_check
-        dst[i] = 3;
-        i += 1;
-        // CHECK-NOT: panic_bounds_check
-        dst[i] = 4;
-    }
-    // CHECK: ret
-}
diff --git a/tests/codegen/slice-init.rs b/tests/codegen/slice-init.rs
deleted file mode 100644
index 950e0b0c10d..00000000000
--- a/tests/codegen/slice-init.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @zero_sized_elem
-#[no_mangle]
-pub fn zero_sized_elem() {
-    // CHECK-NOT: br label %repeat_loop_header{{.*}}
-    // CHECK-NOT: call void @llvm.memset.p0
-    let x = [(); 4];
-    opaque(&x);
-}
-
-// CHECK-LABEL: @zero_len_array
-#[no_mangle]
-pub fn zero_len_array() {
-    // CHECK-NOT: br label %repeat_loop_header{{.*}}
-    // CHECK-NOT: call void @llvm.memset.p0
-    let x = [4; 0];
-    opaque(&x);
-}
-
-// CHECK-LABEL: @byte_array
-#[no_mangle]
-pub fn byte_array() {
-    // CHECK: call void @llvm.memset.{{.+}}(ptr {{.*}}, i8 7, i{{[0-9]+}} 4
-    // CHECK-NOT: br label %repeat_loop_header{{.*}}
-    let x = [7u8; 4];
-    opaque(&x);
-}
-
-#[allow(dead_code)]
-#[derive(Copy, Clone)]
-enum Init {
-    Loop,
-    Memset,
-}
-
-// CHECK-LABEL: @byte_enum_array
-#[no_mangle]
-pub fn byte_enum_array() {
-    // CHECK: call void @llvm.memset.{{.+}}(ptr {{.*}}, i8 {{.*}}, i{{[0-9]+}} 4
-    // CHECK-NOT: br label %repeat_loop_header{{.*}}
-    let x = [Init::Memset; 4];
-    opaque(&x);
-}
-
-// CHECK-LABEL: @zeroed_integer_array
-#[no_mangle]
-pub fn zeroed_integer_array() {
-    // CHECK: call void @llvm.memset.{{.+}}(ptr {{.*}}, i8 0, i{{[0-9]+}} 16
-    // CHECK-NOT: br label %repeat_loop_header{{.*}}
-    let x = [0u32; 4];
-    opaque(&x);
-}
-
-// CHECK-LABEL: @nonzero_integer_array
-#[no_mangle]
-pub fn nonzero_integer_array() {
-    // CHECK: br label %repeat_loop_header{{.*}}
-    // CHECK-NOT: call void @llvm.memset.p0
-    let x = [0x1a_2b_3c_4d_u32; 4];
-    opaque(&x);
-}
-
-const N: usize = 100;
-
-// CHECK-LABEL: @u16_init_one_bytes
-#[no_mangle]
-pub fn u16_init_one_bytes() -> [u16; N] {
-    // CHECK-NOT: select
-    // CHECK-NOT: br
-    // CHECK-NOT: switch
-    // CHECK-NOT: icmp
-    // CHECK: call void @llvm.memset.p0
-    [const { u16::from_be_bytes([1, 1]) }; N]
-}
-
-// FIXME: undef bytes can just be initialized with the same value as the
-// defined bytes, if the defines bytes are all the same.
-// CHECK-LABEL: @option_none_init
-#[no_mangle]
-pub fn option_none_init() -> [Option<u8>; N] {
-    // CHECK-NOT: select
-    // CHECK: br label %repeat_loop_header{{.*}}
-    // CHECK-NOT: switch
-    // CHECK: icmp
-    // CHECK-NOT: call void @llvm.memset.p0
-    [None; N]
-}
-
-use std::mem::MaybeUninit;
-
-// FIXME: This could be optimized into a memset.
-// Regression test for <https://github.com/rust-lang/rust/issues/137892>.
-#[no_mangle]
-pub fn half_uninit() -> [(u128, MaybeUninit<u128>); N] {
-    // CHECK-NOT: select
-    // CHECK: br label %repeat_loop_header{{.*}}
-    // CHECK-NOT: switch
-    // CHECK: icmp
-    // CHECK-NOT: call void @llvm.memset.p0
-    [const { (0, MaybeUninit::uninit()) }; N]
-}
-
-// Use an opaque function to prevent rustc from removing useless drops.
-#[inline(never)]
-pub fn opaque(_: impl Sized) {}
diff --git a/tests/codegen/slice-is-ascii.rs b/tests/codegen/slice-is-ascii.rs
deleted file mode 100644
index 67537c871a0..00000000000
--- a/tests/codegen/slice-is-ascii.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ only-x86_64
-//@ compile-flags: -C opt-level=3 -C target-cpu=x86-64
-#![crate_type = "lib"]
-
-/// Check that the fast-path of `is_ascii` uses a `pmovmskb` instruction.
-/// Platforms lacking an equivalent instruction use other techniques for
-/// optimizing `is_ascii`.
-// CHECK-LABEL: @is_ascii_autovectorized
-#[no_mangle]
-pub fn is_ascii_autovectorized(s: &[u8]) -> bool {
-    // CHECK: load <32 x i8>
-    // CHECK-NEXT: icmp slt <32 x i8>
-    // CHECK-NEXT: bitcast <32 x i1>
-    // CHECK-NEXT: icmp eq i32
-    s.is_ascii()
-}
diff --git a/tests/codegen/slice-iter-fold.rs b/tests/codegen/slice-iter-fold.rs
deleted file mode 100644
index 55ab34661c3..00000000000
--- a/tests/codegen/slice-iter-fold.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @slice_fold_to_last
-#[no_mangle]
-pub fn slice_fold_to_last(slice: &[i32]) -> Option<&i32> {
-    // CHECK-NOT: loop
-    // CHECK-NOT: br
-    // CHECK-NOT: call
-    // CHECK: ret
-    slice.iter().fold(None, |_, i| Some(i))
-}
diff --git a/tests/codegen/slice-iter-len-eq-zero.rs b/tests/codegen/slice-iter-len-eq-zero.rs
deleted file mode 100644
index 6998d98e498..00000000000
--- a/tests/codegen/slice-iter-len-eq-zero.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ needs-deterministic-layouts (opposite scalar pair orders breaks it)
-#![crate_type = "lib"]
-
-type Demo = [u8; 3];
-
-// CHECK-LABEL: @slice_iter_len_eq_zero
-#[no_mangle]
-pub fn slice_iter_len_eq_zero(y: std::slice::Iter<'_, Demo>) -> bool {
-    // CHECK-NOT: sub
-    // CHECK: %[[RET:.+]] = icmp eq ptr {{%y.0, %y.1|%y.1, %y.0}}
-    // CHECK: ret i1 %[[RET]]
-    y.len() == 0
-}
-
-// CHECK-LABEL: @slice_iter_len_eq_zero_ref
-#[no_mangle]
-pub fn slice_iter_len_eq_zero_ref(y: &mut std::slice::Iter<'_, Demo>) -> bool {
-    // CHECK-NOT: sub
-    // CHECK: %[[A:.+]] = load ptr
-    // CHECK-SAME: !nonnull
-    // CHECK: %[[B:.+]] = load ptr
-    // CHECK-SAME: !nonnull
-    // CHECK: %[[RET:.+]] = icmp eq ptr %[[A]], %[[B]]
-    // CHECK: ret i1 %[[RET]]
-    y.len() == 0
-}
-
-struct MyZST;
-
-// CHECK-LABEL: @slice_zst_iter_len_eq_zero
-#[no_mangle]
-pub fn slice_zst_iter_len_eq_zero(y: std::slice::Iter<'_, MyZST>) -> bool {
-    // CHECK: %[[RET:.+]] = icmp eq ptr %y.1, null
-    // CHECK: ret i1 %[[RET]]
-    y.len() == 0
-}
-
-// CHECK-LABEL: @slice_zst_iter_len_eq_zero_ref
-#[no_mangle]
-pub fn slice_zst_iter_len_eq_zero_ref(y: &mut std::slice::Iter<'_, MyZST>) -> bool {
-    // CHECK: %[[LEN:.+]] = load ptr
-    // CHECK-NOT: !nonnull
-    // CHECK: %[[RET:.+]] = icmp eq ptr %[[LEN]], null
-    // CHECK: ret i1 %[[RET]]
-    y.len() == 0
-}
-
-// CHECK-LABEL: @array_into_iter_len_eq_zero
-#[no_mangle]
-pub fn array_into_iter_len_eq_zero(y: std::array::IntoIter<Demo, 123>) -> bool {
-    // This should be able to just check that the indexes are equal, and not
-    // need any subtractions or comparisons to handle `start > end`.
-
-    // CHECK-NOT: icmp
-    // CHECK-NOT: sub
-    // CHECK: %_0 = icmp eq {{i16|i32|i64}}
-    // CHECK: ret i1 %_0
-    y.len() == 0
-}
diff --git a/tests/codegen/slice-iter-nonnull.rs b/tests/codegen/slice-iter-nonnull.rs
deleted file mode 100644
index 87907e7ad0a..00000000000
--- a/tests/codegen/slice-iter-nonnull.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ needs-deterministic-layouts
-#![crate_type = "lib"]
-#![feature(exact_size_is_empty)]
-
-// The slice iterator used to `assume` that the `start` pointer was non-null.
-// That ought to be unneeded, though, since the type is `NonNull`, so this test
-// confirms that the appropriate metadata is included to denote that.
-
-// It also used to `assume` the `end` pointer was non-null, but that's no longer
-// needed as the code changed to read it as a `NonNull`, and thus gets the
-// appropriate `!nonnull` annotations naturally.
-
-// CHECK-LABEL: @slice_iter_next(
-#[no_mangle]
-pub fn slice_iter_next<'a>(it: &mut std::slice::Iter<'a, u32>) -> Option<&'a u32> {
-    // CHECK: %[[START:.+]] = load ptr, ptr %it,
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: %[[ENDP:.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %it, {{i32 4|i64 8}}
-    // CHECK: %[[END:.+]] = load ptr, ptr %[[ENDP]]
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: icmp eq ptr %[[START]], %[[END]]
-
-    // CHECK: store ptr{{.+}}, ptr %it,
-
-    it.next()
-}
-
-// CHECK-LABEL: @slice_iter_next_back(
-#[no_mangle]
-pub fn slice_iter_next_back<'a>(it: &mut std::slice::Iter<'a, u32>) -> Option<&'a u32> {
-    // CHECK: %[[ENDP:.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %it, {{i32 4|i64 8}}
-    // CHECK: %[[END:.+]] = load ptr, ptr %[[ENDP]]
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: %[[START:.+]] = load ptr, ptr %it,
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: icmp eq ptr %[[START]], %[[END]]
-
-    // CHECK: store ptr{{.+}}, ptr %[[ENDP]],
-
-    it.next_back()
-}
-
-// The slice iterator `new` methods used to `assume` that the pointer is non-null,
-// but passing slices already requires that, to the extent that LLVM actually
-// removed the `call @llvm.assume` anyway.  These tests just demonstrate that the
-// attribute is there, and confirms adding the assume back doesn't do anything.
-
-// CHECK-LABEL: @slice_iter_new
-// CHECK-SAME: (ptr noalias noundef nonnull {{.+}} %slice.0, {{.+}} noundef %slice.1)
-#[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-NOT: slice
-    // CHECK: insertvalue {{.+}} ptr %slice.0, 0
-    // CHECK-NOT: slice
-    // CHECK: insertvalue {{.+}} ptr %[[END]], 1
-    // CHECK-NOT: slice
-    // CHECK: }
-    slice.iter()
-}
-
-// CHECK-LABEL: @slice_iter_mut_new
-// CHECK-SAME: (ptr noalias noundef nonnull {{.+}} %slice.0, {{.+}} noundef %slice.1)
-#[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-NOT: slice
-    // CHECK: insertvalue {{.+}} ptr %slice.0, 0
-    // CHECK-NOT: slice
-    // CHECK: insertvalue {{.+}} ptr %[[END]], 1
-    // CHECK-NOT: slice
-    // CHECK: }
-    slice.iter_mut()
-}
-
-// CHECK-LABEL: @slice_iter_is_empty
-#[no_mangle]
-pub fn slice_iter_is_empty(it: &std::slice::Iter<'_, u32>) -> bool {
-    // CHECK: %[[ENDP:.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %it, {{i32 4|i64 8}}
-    // CHECK: %[[END:.+]] = load ptr, ptr %[[ENDP]]
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: %[[START:.+]] = load ptr, ptr %it,
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-
-    // CHECK: %[[RET:.+]] = icmp eq ptr %[[START]], %[[END]]
-    // CHECK: ret i1 %[[RET]]
-    it.is_empty()
-}
-
-// CHECK-LABEL: @slice_iter_len
-#[no_mangle]
-pub fn slice_iter_len(it: &std::slice::Iter<'_, u32>) -> usize {
-    // CHECK: %[[ENDP:.+]] = getelementptr inbounds{{( nuw)?}} i8, ptr %it, {{i32 4|i64 8}}
-    // CHECK: %[[END:.+]] = load ptr, ptr %[[ENDP]]
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: %[[START:.+]] = load ptr, ptr %it,
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-
-    // CHECK: ptrtoint
-    // CHECK: ptrtoint
-    // CHECK: sub nuw
-    // CHECK: lshr exact
-    it.len()
-}
diff --git a/tests/codegen/slice-last-elements-optimization.rs b/tests/codegen/slice-last-elements-optimization.rs
deleted file mode 100644
index b90f91d7b17..00000000000
--- a/tests/codegen/slice-last-elements-optimization.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-//@ min-llvm-version: 20
-#![crate_type = "lib"]
-
-// This test verifies that LLVM 20 properly optimizes the bounds check
-// when accessing the last few elements of a slice with proper conditions.
-// Previously, this would generate an unreachable branch to
-// slice_start_index_len_fail even when the bounds check was provably safe.
-
-// CHECK-LABEL: @last_four_initial(
-#[no_mangle]
-pub fn last_four_initial(s: &[u8]) -> &[u8] {
-    // Previously this would generate a branch to slice_start_index_len_fail
-    // that is unreachable. The LLVM 20 fix should eliminate this branch.
-    // CHECK-NOT: slice_start_index_len_fail
-    // CHECK-NOT: unreachable
-    let start = if s.len() <= 4 { 0 } else { s.len() - 4 };
-    &s[start..]
-}
-
-// CHECK-LABEL: @last_four_optimized(
-#[no_mangle]
-pub fn last_four_optimized(s: &[u8]) -> &[u8] {
-    // This version was already correctly optimized before the fix in LLVM 20.
-    // CHECK-NOT: slice_start_index_len_fail
-    // CHECK-NOT: unreachable
-    if s.len() <= 4 { &s[0..] } else { &s[s.len() - 4..] }
-}
-
-// Just to verify we're correctly checking for the right thing
-// CHECK-LABEL: @test_bounds_check_happens(
-#[no_mangle]
-pub fn test_bounds_check_happens(s: &[u8], i: usize) -> &[u8] {
-    // CHECK: slice_start_index_len_fail
-    &s[i..]
-}
diff --git a/tests/codegen/slice-pointer-nonnull-unwrap.rs b/tests/codegen/slice-pointer-nonnull-unwrap.rs
deleted file mode 100644
index 35e4bf2c661..00000000000
--- a/tests/codegen/slice-pointer-nonnull-unwrap.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-use std::ptr::NonNull;
-
-// CHECK-LABEL: @slice_ptr_len_1
-// CHECK-NEXT: {{.*}}:
-// CHECK-NEXT: ret {{i(32|64)}} %ptr.1
-#[no_mangle]
-pub fn slice_ptr_len_1(ptr: *const [u8]) -> usize {
-    let ptr = ptr.cast_mut();
-    if let Some(ptr) = NonNull::new(ptr) {
-        ptr.len()
-    } else {
-        // We know ptr is null, so we know ptr.wrapping_byte_add(1) is not null.
-        NonNull::new(ptr.wrapping_byte_add(1)).unwrap().len()
-    }
-}
diff --git a/tests/codegen/slice-position-bounds-check.rs b/tests/codegen/slice-position-bounds-check.rs
deleted file mode 100644
index 0d1d1d869ae..00000000000
--- a/tests/codegen/slice-position-bounds-check.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C panic=abort
-#![crate_type = "lib"]
-
-fn search<T: Ord + Eq>(arr: &mut [T], a: &T) -> Result<usize, ()> {
-    match arr.iter().position(|x| x == a) {
-        Some(p) => Ok(p),
-        None => Err(()),
-    }
-}
-
-// CHECK-LABEL: @position_no_bounds_check
-#[no_mangle]
-pub fn position_no_bounds_check(y: &mut [u32], x: &u32, z: &u32) -> bool {
-    // This contains "call assume" so we cannot just rule out all calls
-    // CHECK-NOT: panic_bounds_check
-    if let Ok(p) = search(y, x) { y[p] == *z } else { false }
-}
-
-// just to make sure that panicking really emits "panic_bounds_check" somewhere in the IR
-// CHECK-LABEL: @test_check
-#[no_mangle]
-pub fn test_check(y: &[i32]) -> i32 {
-    // CHECK: panic_bounds_check
-    y[12]
-}
diff --git a/tests/codegen/slice-ref-equality.rs b/tests/codegen/slice-ref-equality.rs
deleted file mode 100644
index 2940378da3c..00000000000
--- a/tests/codegen/slice-ref-equality.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-#![crate_type = "lib"]
-
-use std::num::NonZero;
-
-// #71602 reported a simple array comparison just generating a loop.
-// This was originally fixed by ensuring it generates a single bcmp,
-// but we now generate it as a load+icmp instead. `is_zero_slice` was
-// tweaked to still test the case of comparison against a slice,
-// and `is_zero_array` tests the new array-specific behaviour.
-// The optimization was then extended to short slice-to-array comparisons,
-// so the first test here now has a long slice to still get the bcmp.
-
-// CHECK-LABEL: @is_zero_slice_long
-#[no_mangle]
-pub fn is_zero_slice_long(data: &[u8; 456]) -> bool {
-    // CHECK: %[[BCMP:.+]] = tail call i32 @{{bcmp|memcmp}}({{.+}})
-    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[BCMP]], 0
-    // CHECK-NEXT: ret i1 %[[EQ]]
-    &data[..] == [0; 456]
-}
-
-// CHECK-LABEL: @is_zero_slice_short
-#[no_mangle]
-pub fn is_zero_slice_short(data: &[u8; 4]) -> bool {
-    // CHECK: %[[LOAD:.+]] = load i32, ptr %{{.+}}, align 1
-    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[LOAD]], 0
-    // CHECK-NEXT: ret i1 %[[EQ]]
-    &data[..] == [0; 4]
-}
-
-// CHECK-LABEL: @is_zero_array
-#[no_mangle]
-pub fn is_zero_array(data: &[u8; 4]) -> bool {
-    // CHECK: %[[LOAD:.+]] = load i32, ptr %{{.+}}, align 1
-    // CHECK-NEXT: %[[EQ:.+]] = icmp eq i32 %[[LOAD]], 0
-    // CHECK-NEXT: ret i1 %[[EQ]]
-    *data == [0; 4]
-}
-
-// The following test the extra specializations to make sure that slice
-// equality for non-byte types also just emit a `bcmp`, not a loop.
-
-// CHECK-LABEL: @eq_slice_of_nested_u8(
-// CHECK-SAME: [[USIZE:i16|i32|i64]] noundef %x.1
-// CHECK-SAME: [[USIZE]] noundef %y.1
-#[no_mangle]
-fn eq_slice_of_nested_u8(x: &[[u8; 3]], y: &[[u8; 3]]) -> bool {
-    // CHECK: icmp eq [[USIZE]] %x.1, %y.1
-    // CHECK: %[[BYTES:.+]] = mul nuw nsw [[USIZE]] {{%x.1|%y.1}}, 3
-    // CHECK: tail call{{( noundef)?}} i32 @{{bcmp|memcmp}}(ptr
-    // CHECK-SAME: , [[USIZE]]{{( noundef)?}} %[[BYTES]])
-    x == y
-}
-
-// CHECK-LABEL: @eq_slice_of_i32(
-// CHECK-SAME: [[USIZE:i16|i32|i64]] noundef %x.1
-// CHECK-SAME: [[USIZE]] noundef %y.1
-#[no_mangle]
-fn eq_slice_of_i32(x: &[i32], y: &[i32]) -> bool {
-    // CHECK: icmp eq [[USIZE]] %x.1, %y.1
-    // CHECK: %[[BYTES:.+]] = shl nuw nsw [[USIZE]] {{%x.1|%y.1}}, 2
-    // CHECK: tail call{{( noundef)?}} i32 @{{bcmp|memcmp}}(ptr
-    // CHECK-SAME: , [[USIZE]]{{( noundef)?}} %[[BYTES]])
-    x == y
-}
-
-// CHECK-LABEL: @eq_slice_of_nonzero(
-// CHECK-SAME: [[USIZE:i16|i32|i64]] noundef %x.1
-// CHECK-SAME: [[USIZE]] noundef %y.1
-#[no_mangle]
-fn eq_slice_of_nonzero(x: &[NonZero<i32>], y: &[NonZero<i32>]) -> bool {
-    // CHECK: icmp eq [[USIZE]] %x.1, %y.1
-    // CHECK: %[[BYTES:.+]] = shl nuw nsw [[USIZE]] {{%x.1|%y.1}}, 2
-    // CHECK: tail call{{( noundef)?}} i32 @{{bcmp|memcmp}}(ptr
-    // CHECK-SAME: , [[USIZE]]{{( noundef)?}} %[[BYTES]])
-    x == y
-}
-
-// CHECK-LABEL: @eq_slice_of_option_of_nonzero(
-// CHECK-SAME: [[USIZE:i16|i32|i64]] noundef %x.1
-// CHECK-SAME: [[USIZE]] noundef %y.1
-#[no_mangle]
-fn eq_slice_of_option_of_nonzero(x: &[Option<NonZero<i16>>], y: &[Option<NonZero<i16>>]) -> bool {
-    // CHECK: icmp eq [[USIZE]] %x.1, %y.1
-    // CHECK: %[[BYTES:.+]] = shl nuw nsw [[USIZE]] {{%x.1|%y.1}}, 1
-    // CHECK: tail call{{( noundef)?}} i32 @{{bcmp|memcmp}}(ptr
-    // CHECK-SAME: , [[USIZE]]{{( noundef)?}} %[[BYTES]])
-    x == y
-}
diff --git a/tests/codegen/slice-reverse.rs b/tests/codegen/slice-reverse.rs
deleted file mode 100644
index e58d1c1d9d8..00000000000
--- a/tests/codegen/slice-reverse.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-//@ ignore-std-debug-assertions (debug assertions prevent generating shufflevector)
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @slice_reverse_u8
-#[no_mangle]
-pub fn slice_reverse_u8(slice: &mut [u8]) {
-    // CHECK-NOT: panic_bounds_check
-    // CHECK-NOT: slice_end_index_len_fail
-    // CHECK: shufflevector <{{[0-9]+}} x i8>
-    // CHECK-NOT: panic_bounds_check
-    // CHECK-NOT: slice_end_index_len_fail
-    slice.reverse();
-}
-
-// CHECK-LABEL: @slice_reverse_i32
-#[no_mangle]
-pub fn slice_reverse_i32(slice: &mut [i32]) {
-    // CHECK-NOT: panic_bounds_check
-    // CHECK-NOT: slice_end_index_len_fail
-    // CHECK: shufflevector <{{[0-9]+}} x i32>
-    // CHECK-NOT: panic_bounds_check
-    // CHECK-NOT: slice_end_index_len_fail
-    slice.reverse();
-}
diff --git a/tests/codegen/slice-split-at.rs b/tests/codegen/slice-split-at.rs
deleted file mode 100644
index 07018cf9c91..00000000000
--- a/tests/codegen/slice-split-at.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// Check that no panic is generated in `split_at` when calculating the index for
-// the tail chunk using `checked_sub`.
-//
-// Tests written for refactored implementations of:
-// `<[T]>::{split_last_chunk, split_last_chunk_mut, last_chunk, last_chunk_mut}`
-
-// CHECK-LABEL: @split_at_last_chunk
-#[no_mangle]
-pub fn split_at_last_chunk(s: &[u8], chunk_size: usize) -> Option<(&[u8], &[u8])> {
-    // CHECK-NOT: panic
-    let Some(index) = s.len().checked_sub(chunk_size) else { return None };
-    Some(s.split_at(index))
-}
-
-// CHECK-LABEL: @split_at_mut_last_chunk
-#[no_mangle]
-pub fn split_at_mut_last_chunk(s: &mut [u8], chunk_size: usize) -> Option<(&mut [u8], &mut [u8])> {
-    // CHECK-NOT: panic
-    let Some(index) = s.len().checked_sub(chunk_size) else { return None };
-    Some(s.split_at_mut(index))
-}
diff --git a/tests/codegen/slice-windows-no-bounds-check.rs b/tests/codegen/slice-windows-no-bounds-check.rs
deleted file mode 100644
index 87e89b14f06..00000000000
--- a/tests/codegen/slice-windows-no-bounds-check.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-#![crate_type = "lib"]
-
-//@ compile-flags: -Copt-level=3
-
-use std::slice::Windows;
-
-// CHECK-LABEL: @naive_string_search
-#[no_mangle]
-pub fn naive_string_search(haystack: &str, needle: &str) -> Option<usize> {
-    if needle.is_empty() {
-        return Some(0);
-    }
-    // CHECK-NOT: panic
-    // CHECK-NOT: fail
-    haystack.as_bytes().windows(needle.len()).position(|sub| sub == needle.as_bytes())
-}
-
-// CHECK-LABEL: @next
-#[no_mangle]
-pub fn next<'a>(w: &mut Windows<'a, u32>) -> Option<&'a [u32]> {
-    // CHECK-NOT: panic
-    // CHECK-NOT: fail
-    w.next()
-}
-
-// CHECK-LABEL: @next_back
-#[no_mangle]
-pub fn next_back<'a>(w: &mut Windows<'a, u32>) -> Option<&'a [u32]> {
-    // CHECK-NOT: panic
-    // CHECK-NOT: fail
-    w.next_back()
-}
diff --git a/tests/codegen/slice_as_from_ptr_range.rs b/tests/codegen/slice_as_from_ptr_range.rs
deleted file mode 100644
index 2073f05c07f..00000000000
--- a/tests/codegen/slice_as_from_ptr_range.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-64bit (because we're using [ui]size)
-
-#![crate_type = "lib"]
-#![feature(slice_from_ptr_range)]
-
-// This is intentionally using a non-power-of-two array length,
-// as that's where the optimization differences show up
-
-// CHECK-LABEL: @flatten_via_ptr_range
-#[no_mangle]
-pub fn flatten_via_ptr_range(slice_of_arrays: &[[i32; 13]]) -> &[i32] {
-    // CHECK-NOT: lshr
-    // CHECK-NOT: udiv
-    // CHECK: mul nuw nsw i64 %{{.+}}, 13
-    // CHECK-NOT: lshr
-    // CHECK-NOT: udiv
-    let r = slice_of_arrays.as_ptr_range();
-    let r = r.start.cast()..r.end.cast();
-    unsafe { core::slice::from_ptr_range(r) }
-}
diff --git a/tests/codegen/some-abis-do-extend-params-to-32-bits.rs b/tests/codegen/some-abis-do-extend-params-to-32-bits.rs
deleted file mode 100644
index 6ca6697588f..00000000000
--- a/tests/codegen/some-abis-do-extend-params-to-32-bits.rs
+++ /dev/null
@@ -1,236 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: -Cno-prepopulate-passes -Copt-level=0
-
-//@ revisions:x86_64 i686 aarch64-apple aarch64-windows aarch64-linux arm riscv
-
-//@[x86_64] compile-flags: --target x86_64-unknown-uefi
-//@[x86_64] needs-llvm-components: x86
-//@[i686] compile-flags: --target i686-unknown-linux-musl
-//@[i686] needs-llvm-components: x86
-//@[aarch64-windows] compile-flags: --target aarch64-pc-windows-msvc
-//@[aarch64-windows] needs-llvm-components: aarch64
-//@[aarch64-linux] compile-flags: --target aarch64-unknown-linux-gnu
-//@[aarch64-linux] needs-llvm-components: aarch64
-//@[aarch64-apple] compile-flags: --target aarch64-apple-darwin
-//@[aarch64-apple] needs-llvm-components: aarch64
-//@[arm] compile-flags: --target armv7r-none-eabi
-//@[arm] needs-llvm-components: arm
-//@[riscv] compile-flags: --target riscv64gc-unknown-none-elf
-//@[riscv] needs-llvm-components: riscv
-
-// See bottom of file for a corresponding C source file that is meant to yield
-// equivalent declarations.
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-// The patterns in this file are written in the style of a table to make the
-// uniformities and distinctions more apparent.
-//
-//                  ZERO/SIGN-EXTENDING TO 32 BITS            NON-EXTENDING
-//                  ==============================  =======================
-// x86_64:          void @c_arg_u8(i8 zeroext %_a)
-// i686:            void @c_arg_u8(i8 zeroext %_a)
-// aarch64-apple:   void @c_arg_u8(i8 zeroext %_a)
-// aarch64-windows:                                  void @c_arg_u8(i8 %_a)
-// aarch64-linux:                                    void @c_arg_u8(i8 %_a)
-// arm:             void @c_arg_u8(i8 zeroext %_a)
-// riscv:           void @c_arg_u8(i8 zeroext %_a)
-#[no_mangle]
-pub extern "C" fn c_arg_u8(_a: u8) {}
-
-// x86_64:          void @c_arg_u16(i16 zeroext %_a)
-// i686:            void @c_arg_u16(i16 zeroext %_a)
-// aarch64-apple:   void @c_arg_u16(i16 zeroext %_a)
-// aarch64-windows:                                 void @c_arg_u16(i16 %_a)
-// aarch64-linux:                                   void @c_arg_u16(i16 %_a)
-// arm:             void @c_arg_u16(i16 zeroext %_a)
-// riscv:           void @c_arg_u16(i16 zeroext %_a)
-#[no_mangle]
-pub extern "C" fn c_arg_u16(_a: u16) {}
-
-// x86_64:          void @c_arg_u32(i32 %_a)
-// i686:            void @c_arg_u32(i32 %_a)
-// aarch64-apple:   void @c_arg_u32(i32 %_a)
-// aarch64-windows:                                 void @c_arg_u32(i32 %_a)
-// aarch64-linux:                                   void @c_arg_u32(i32 %_a)
-// arm:             void @c_arg_u32(i32 %_a)
-// riscv:           void @c_arg_u32(i32 signext %_a)
-#[no_mangle]
-pub extern "C" fn c_arg_u32(_a: u32) {}
-
-// x86_64:          void @c_arg_u64(i64 %_a)
-// i686:            void @c_arg_u64(i64 %_a)
-// aarch64-apple:   void @c_arg_u64(i64 %_a)
-// aarch64-windows:                                 void @c_arg_u64(i64 %_a)
-// aarch64-linux:                                   void @c_arg_u64(i64 %_a)
-// arm:             void @c_arg_u64(i64 %_a)
-// riscv:           void @c_arg_u64(i64 %_a)
-#[no_mangle]
-pub extern "C" fn c_arg_u64(_a: u64) {}
-
-// x86_64:          void @c_arg_i8(i8 signext %_a)
-// i686:            void @c_arg_i8(i8 signext %_a)
-// aarch64-apple:   void @c_arg_i8(i8 signext %_a)
-// aarch64-windows:                                  void @c_arg_i8(i8 %_a)
-// aarch64-linux:                                    void @c_arg_i8(i8 %_a)
-// arm:             void @c_arg_i8(i8 signext %_a)
-// riscv:           void @c_arg_i8(i8 signext %_a)
-#[no_mangle]
-pub extern "C" fn c_arg_i8(_a: i8) {}
-
-// x86_64:          void @c_arg_i16(i16 signext %_a)
-// i686:            void @c_arg_i16(i16 signext %_a)
-// aarch64-apple:   void @c_arg_i16(i16 signext %_a)
-// aarch64-windows:                                 void @c_arg_i16(i16 %_a)
-// aarch64-linux:                                   void @c_arg_i16(i16 %_a)
-// arm:             void @c_arg_i16(i16 signext %_a)
-// riscv:           void @c_arg_i16(i16 signext %_a)
-#[no_mangle]
-pub extern "C" fn c_arg_i16(_a: i16) {}
-
-// x86_64:          void @c_arg_i32(i32 %_a)
-// i686:            void @c_arg_i32(i32 %_a)
-// aarch64-apple:   void @c_arg_i32(i32 %_a)
-// aarch64-windows:                                 void @c_arg_i32(i32 %_a)
-// aarch64-linux:                                   void @c_arg_i32(i32 %_a)
-// arm:             void @c_arg_i32(i32 %_a)
-// riscv:           void @c_arg_i32(i32 signext %_a)
-#[no_mangle]
-pub extern "C" fn c_arg_i32(_a: i32) {}
-
-// x86_64:          void @c_arg_i64(i64 %_a)
-// i686:            void @c_arg_i64(i64 %_a)
-// aarch64-apple:   void @c_arg_i64(i64 %_a)
-// aarch64-windows:                                 void @c_arg_i64(i64 %_a)
-// aarch64-linux:                                   void @c_arg_i64(i64 %_a)
-// arm:             void @c_arg_i64(i64 %_a)
-// riscv:           void @c_arg_i64(i64 %_a)
-#[no_mangle]
-pub extern "C" fn c_arg_i64(_a: i64) {}
-
-// x86_64:          zeroext i8 @c_ret_u8()
-// i686:            zeroext i8 @c_ret_u8()
-// aarch64-apple:   zeroext i8 @c_ret_u8()
-// aarch64-windows:                                 i8 @c_ret_u8()
-// aarch64-linux:                                   i8 @c_ret_u8()
-// arm:             zeroext i8 @c_ret_u8()
-// riscv:           zeroext i8 @c_ret_u8()
-#[no_mangle]
-pub extern "C" fn c_ret_u8() -> u8 {
-    0
-}
-
-// x86_64:          zeroext i16 @c_ret_u16()
-// i686:            zeroext i16 @c_ret_u16()
-// aarch64-apple:   zeroext i16 @c_ret_u16()
-// aarch64-windows:                                 i16 @c_ret_u16()
-// aarch64-linux:                                   i16 @c_ret_u16()
-// arm:             zeroext i16 @c_ret_u16()
-// riscv:           zeroext i16 @c_ret_u16()
-#[no_mangle]
-pub extern "C" fn c_ret_u16() -> u16 {
-    0
-}
-
-// x86_64:          i32 @c_ret_u32()
-// i686:            i32 @c_ret_u32()
-// aarch64-apple:   i32 @c_ret_u32()
-// aarch64-windows:                                 i32 @c_ret_u32()
-// aarch64-linux:                                   i32 @c_ret_u32()
-// arm:             i32 @c_ret_u32()
-// riscv:           signext i32 @c_ret_u32()
-#[no_mangle]
-pub extern "C" fn c_ret_u32() -> u32 {
-    0
-}
-
-// x86_64:          i64 @c_ret_u64()
-// i686:            i64 @c_ret_u64()
-// aarch64-apple:   i64 @c_ret_u64()
-// aarch64-windows:                                 i64 @c_ret_u64()
-// aarch64-linux:                                   i64 @c_ret_u64()
-// arm:             i64 @c_ret_u64()
-// riscv:           i64 @c_ret_u64()
-#[no_mangle]
-pub extern "C" fn c_ret_u64() -> u64 {
-    0
-}
-
-// x86_64:          signext i8 @c_ret_i8()
-// i686:            signext i8 @c_ret_i8()
-// aarch64-apple:   signext i8 @c_ret_i8()
-// aarch64-windows:                                 i8 @c_ret_i8()
-// aarch64-linux:                                   i8 @c_ret_i8()
-// arm:             signext i8 @c_ret_i8()
-// riscv:           signext i8 @c_ret_i8()
-#[no_mangle]
-pub extern "C" fn c_ret_i8() -> i8 {
-    0
-}
-
-// x86_64:          signext i16 @c_ret_i16()
-// i686:            signext i16 @c_ret_i16()
-// aarch64-apple:   signext i16 @c_ret_i16()
-// aarch64-windows:                                 i16 @c_ret_i16()
-// aarch64-linux:                                   i16 @c_ret_i16()
-// arm:             signext i16 @c_ret_i16()
-// riscv:           signext i16 @c_ret_i16()
-#[no_mangle]
-pub extern "C" fn c_ret_i16() -> i16 {
-    0
-}
-
-// x86_64:          i32 @c_ret_i32()
-// i686:            i32 @c_ret_i32()
-// aarch64-apple:   i32 @c_ret_i32()
-// aarch64-windows:                                 i32 @c_ret_i32()
-// aarch64-linux:                                   i32 @c_ret_i32()
-// arm:             i32 @c_ret_i32()
-// riscv:           signext i32 @c_ret_i32()
-#[no_mangle]
-pub extern "C" fn c_ret_i32() -> i32 {
-    0
-}
-
-// x86_64:          i64 @c_ret_i64()
-// i686:            i64 @c_ret_i64()
-// aarch64-apple:   i64 @c_ret_i64()
-// aarch64-windows:                                 i64 @c_ret_i64()
-// aarch64-linux:                                   i64 @c_ret_i64()
-// arm:             i64 @c_ret_i64()
-// riscv:           i64 @c_ret_i64()
-#[no_mangle]
-pub extern "C" fn c_ret_i64() -> i64 {
-    0
-}
-
-const C_SOURCE_FILE: &'static str = r##"
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdio.h>
-
-void c_arg_u8(uint8_t _a) { }
-void c_arg_u16(uint16_t _a) { }
-void c_arg_u32(uint32_t _a) { }
-void c_arg_u64(uint64_t _a) { }
-
-void c_arg_i8(int8_t _a) { }
-void c_arg_i16(int16_t _a) { }
-void c_arg_i32(int32_t _a) { }
-void c_arg_i64(int64_t _a) { }
-
-uint8_t  c_ret_u8()  { return 0; }
-uint16_t c_ret_u16() { return 0; }
-uint32_t c_ret_u32() { return 0; }
-uint64_t c_ret_u64() { return 0; }
-
-int8_t   c_ret_i8()  { return 0; }
-int16_t  c_ret_i16() { return 0; }
-int32_t  c_ret_i32() { return 0; }
-int64_t  c_ret_i64() { return 0; }
-"##;
diff --git a/tests/codegen/some-global-nonnull.rs b/tests/codegen/some-global-nonnull.rs
deleted file mode 100644
index bb4d12e1c76..00000000000
--- a/tests/codegen/some-global-nonnull.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @test
-// CHECK-NEXT: start:
-// CHECK-NEXT: tail call void @ext_fn0()
-#[no_mangle]
-pub fn test() {
-    test_inner(Some(inner0));
-}
-
-fn test_inner(f_maybe: Option<fn()>) {
-    if let Some(f) = f_maybe {
-        f();
-    }
-}
-
-fn inner0() {
-    unsafe { ext_fn0() };
-}
-
-extern "C" {
-    fn ext_fn0();
-}
diff --git a/tests/codegen/sparc-struct-abi.rs b/tests/codegen/sparc-struct-abi.rs
deleted file mode 100644
index 32d2c5bb0ef..00000000000
--- a/tests/codegen/sparc-struct-abi.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-// Checks that we correctly codegen extern "C" functions returning structs.
-// See issues #52638 and #86163.
-
-//@ add-core-stubs
-//@ compile-flags: -Copt-level=3 --target=sparc64-unknown-linux-gnu --crate-type=rlib
-//@ needs-llvm-components: sparc
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[repr(C)]
-pub struct Bool {
-    b: bool,
-}
-
-// CHECK: define{{.*}} i64 @structbool()
-// CHECK-NEXT: start:
-// CHECK-NEXT: ret i64 72057594037927936
-#[no_mangle]
-pub extern "C" fn structbool() -> Bool {
-    Bool { b: true }
-}
-
-#[repr(C)]
-pub struct BoolFloat {
-    b: bool,
-    f: f32,
-}
-
-// CHECK: define inreg { i32, float } @structboolfloat()
-// CHECK-NEXT: start:
-// CHECK-NEXT: ret { i32, float } { i32 16777216, float 0x40091EB860000000 }
-#[no_mangle]
-pub extern "C" fn structboolfloat() -> BoolFloat {
-    BoolFloat { b: true, f: 3.14 }
-}
-
-// CHECK: define void @structboolfloat_input({ i32, float } inreg %0)
-// CHECK-NEXT: start:
-#[no_mangle]
-pub extern "C" fn structboolfloat_input(a: BoolFloat) {}
-
-#[repr(C)]
-pub struct ShortDouble {
-    s: i16,
-    d: f64,
-}
-
-// CHECK: define { i64, double } @structshortdouble()
-// CHECK-NEXT: start:
-// CHECK-NEXT: ret { i64, double } { i64 34621422135410688, double 3.140000e+00 }
-#[no_mangle]
-pub extern "C" fn structshortdouble() -> ShortDouble {
-    ShortDouble { s: 123, d: 3.14 }
-}
-
-// CHECK: define void @structshortdouble_input({ i64, double } %0)
-// CHECK-NEXT: start:
-#[no_mangle]
-pub extern "C" fn structshortdouble_input(a: ShortDouble) {}
-
-#[repr(C)]
-pub struct FloatLongFloat {
-    f: f32,
-    i: i64,
-    g: f32,
-}
-
-// CHECK: define inreg { float, i32, i64, float, i32 } @structfloatlongfloat()
-// CHECK-NEXT: start:
-// CHECK-NEXT: ret { float, i32, i64, float, i32 } { float 0x3FB99999A0000000, i32 undef, i64 123, float 0x40091EB860000000, i32 undef }
-#[no_mangle]
-pub extern "C" fn structfloatlongfloat() -> FloatLongFloat {
-    FloatLongFloat { f: 0.1, i: 123, g: 3.14 }
-}
-
-#[repr(C)]
-pub struct FloatFloat {
-    f: f32,
-    g: f32,
-}
-
-#[repr(C)]
-pub struct NestedStructs {
-    a: FloatFloat,
-    b: FloatFloat,
-}
-
-// CHECK: define inreg { float, float, float, float } @structnestestructs()
-// CHECK-NEXT: start:
-// CHECK-NEXT: ret { float, float, float, float } { float 0x3FB99999A0000000, float 0x3FF19999A0000000, float 0x40019999A0000000, float 0x400A666660000000 }
-#[no_mangle]
-pub extern "C" fn structnestestructs() -> NestedStructs {
-    NestedStructs { a: FloatFloat { f: 0.1, g: 1.1 }, b: FloatFloat { f: 2.2, g: 3.3 } }
-}
diff --git a/tests/codegen/split-lto-unit.rs b/tests/codegen/split-lto-unit.rs
deleted file mode 100644
index 7858a0e7b79..00000000000
--- a/tests/codegen/split-lto-unit.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Verifies that "EnableSplitLTOUnit" module flag is added.
-//
-//@ needs-sanitizer-cfi
-//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsplit-lto-unit
-
-#![crate_type = "lib"]
-
-pub fn foo() {}
-
-// CHECK: !{{[0-9]+}} = !{i32 4, !"EnableSplitLTOUnit", i32 1}
diff --git a/tests/codegen/src-hash-algorithm/src-hash-algorithm-md5.rs b/tests/codegen/src-hash-algorithm/src-hash-algorithm-md5.rs
deleted file mode 100644
index 7aec8d545dc..00000000000
--- a/tests/codegen/src-hash-algorithm/src-hash-algorithm-md5.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//@ compile-flags: -g -Z src-hash-algorithm=md5 -Copt-level=0
-
-#![crate_type = "lib"]
-
-pub fn test() {}
-// CHECK: checksumkind: CSK_MD5
diff --git a/tests/codegen/src-hash-algorithm/src-hash-algorithm-sha1.rs b/tests/codegen/src-hash-algorithm/src-hash-algorithm-sha1.rs
deleted file mode 100644
index 5389c32f938..00000000000
--- a/tests/codegen/src-hash-algorithm/src-hash-algorithm-sha1.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//@ compile-flags: -g -Z src-hash-algorithm=sha1 -Copt-level=0
-
-#![crate_type = "lib"]
-
-pub fn test() {}
-// CHECK: checksumkind: CSK_SHA1
diff --git a/tests/codegen/src-hash-algorithm/src-hash-algorithm-sha256.rs b/tests/codegen/src-hash-algorithm/src-hash-algorithm-sha256.rs
deleted file mode 100644
index 520890c47f1..00000000000
--- a/tests/codegen/src-hash-algorithm/src-hash-algorithm-sha256.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//@ compile-flags: -g -Z src-hash-algorithm=sha256 -Copt-level=0
-
-#![crate_type = "lib"]
-
-pub fn test() {}
-// CHECK: checksumkind: CSK_SHA256
diff --git a/tests/codegen/sroa-fragment-debuginfo.rs b/tests/codegen/sroa-fragment-debuginfo.rs
deleted file mode 100644
index 0413cf96894..00000000000
--- a/tests/codegen/sroa-fragment-debuginfo.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-//@ compile-flags: -g -Zmir-opt-level=0 -Zmir-enable-passes=+ScalarReplacementOfAggregates
-//@ compile-flags: -Cno-prepopulate-passes
-//
-// Tested offsets are only correct for x86_64.
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-pub struct ExtraSlice<'input> {
-    slice: &'input [u8],
-    extra: u32,
-}
-
-#[no_mangle]
-pub fn extra(s: &[u8]) {
-    // CHECK: void @extra(
-    // CHECK: %slice.dbg.spill1 = alloca [4 x i8],
-    // CHECK: %slice.dbg.spill = alloca [16 x i8],
-    // CHECK: %s.dbg.spill = alloca [16 x i8],
-    // CHECK: dbg{{.}}declare({{(metadata )?}}ptr %s.dbg.spill, {{(metadata )?}}![[S_EXTRA:.*]], {{(metadata )?}}!DIExpression()
-    // CHECK: dbg{{.}}declare({{(metadata )?}}ptr %slice.dbg.spill, {{(metadata )?}}![[SLICE_EXTRA:.*]], {{(metadata )?}}!DIExpression(DW_OP_LLVM_fragment, 0, 128)
-    // CHECK: dbg{{.}}declare({{(metadata )?}}ptr %slice.dbg.spill1, {{(metadata )?}}![[SLICE_EXTRA]], {{(metadata )?}}!DIExpression(DW_OP_LLVM_fragment, 128, 32)
-    let slice = ExtraSlice { slice: s, extra: s.len() as u32 };
-}
-
-struct Zst;
-
-pub struct ZstSlice<'input> {
-    slice: &'input [u8],
-    extra: Zst,
-}
-
-#[no_mangle]
-pub fn zst(s: &[u8]) {
-    // The field `extra` is a ZST. The fragment for the field `slice` encompasses the whole
-    // variable, so is not a fragment. In that case, the variable must have no fragment.
-
-    // CHECK: void @zst(
-    // CHECK-NOT: dbg{{.}}declare({{(metadata )?}}ptr %slice.dbg.spill, {{(metadata )?}}!{}, {{(metadata )?}}!DIExpression(DW_OP_LLVM_fragment,
-    // CHECK: dbg{{.}}declare({{(metadata )?}}ptr %{{.*}}, {{(metadata )?}}![[SLICE_ZST:.*]], {{(metadata )?}}!DIExpression()
-    // CHECK-NOT: dbg{{.}}declare({{(metadata )?}}ptr %{{.*}}, {{(metadata )?}}![[SLICE_ZST]],
-    let slice = ZstSlice { slice: s, extra: Zst };
-}
-
-// CHECK: ![[S_EXTRA]] = !DILocalVariable(name: "s",
-// CHECK: ![[SLICE_EXTRA]] = !DILocalVariable(name: "slice",
diff --git a/tests/codegen/sse42-implies-crc32.rs b/tests/codegen/sse42-implies-crc32.rs
deleted file mode 100644
index 8a9c496a3a5..00000000000
--- a/tests/codegen/sse42-implies-crc32.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ only-x86_64
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[cfg(target_arch = "x86_64")]
-#[target_feature(enable = "sse4.2")]
-#[no_mangle]
-pub unsafe fn crc32sse(v: u8) -> u32 {
-    use std::arch::x86_64::*;
-    let out = !0u32;
-    _mm_crc32_u8(out, v)
-}
-
-// CHECK: attributes #0 {{.*"target-features"=".*\+sse4.2,\+crc32.*"}}
diff --git a/tests/codegen/stack-probes-inline.rs b/tests/codegen/stack-probes-inline.rs
deleted file mode 100644
index 746272b0994..00000000000
--- a/tests/codegen/stack-probes-inline.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Check the "probe-stack" attribute for targets with `StackProbeType::Inline`,
-// or `StackProbeType::InlineOrCall` when running on newer LLVM.
-
-//@ add-core-stubs
-//@ compile-flags: -C no-prepopulate-passes
-//@ revisions: aarch64 powerpc powerpc64 powerpc64le s390x i686 x86_64
-//@[aarch64] compile-flags: --target aarch64-unknown-linux-gnu
-//@[aarch64] needs-llvm-components: aarch64
-//@[powerpc] compile-flags: --target powerpc-unknown-linux-gnu
-//@[powerpc] needs-llvm-components: powerpc
-//@[powerpc64] compile-flags: --target powerpc64-unknown-linux-gnu
-//@[powerpc64] needs-llvm-components: powerpc
-//@[powerpc64le] compile-flags: --target powerpc64le-unknown-linux-gnu
-//@[powerpc64le] needs-llvm-components: powerpc
-//@[s390x] compile-flags: --target s390x-unknown-linux-gnu
-//@[s390x] needs-llvm-components: systemz
-//@[i686] compile-flags: --target i686-unknown-linux-gnu
-//@[i686] needs-llvm-components: x86
-//@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu
-//@[x86_64] needs-llvm-components: x86
-
-#![crate_type = "rlib"]
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[no_mangle]
-pub fn foo() {
-    // CHECK: @foo() unnamed_addr #0
-    // CHECK: attributes #0 = { {{.*}}"probe-stack"="inline-asm"{{.*}} }
-}
diff --git a/tests/codegen/stack-protector.rs b/tests/codegen/stack-protector.rs
deleted file mode 100644
index 8ab25b470cd..00000000000
--- a/tests/codegen/stack-protector.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//@ revisions: all strong basic none
-//@ ignore-nvptx64 stack protector not supported
-//@ [all] compile-flags: -Z stack-protector=all
-//@ [strong] compile-flags: -Z stack-protector=strong
-//@ [basic] compile-flags: -Z stack-protector=basic
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn foo() {
-    // CHECK: @foo() unnamed_addr #0
-
-    // all-NOT: attributes #0 = { {{.*}}sspstrong {{.*}} }
-    // all-NOT: attributes #0 = { {{.*}}ssp {{.*}} }
-    // all: attributes #0 = { {{.*}}sspreq {{.*}} }
-    // all-NOT: attributes #0 = { {{.*}}sspstrong {{.*}} }
-    // all-NOT: attributes #0 = { {{.*}}ssp {{.*}} }
-
-    // strong-NOT: attributes #0 = { {{.*}}sspreq {{.*}} }
-    // strong-NOT: attributes #0 = { {{.*}}ssp {{.*}} }
-    // strong: attributes #0 = { {{.*}}sspstrong {{.*}} }
-    // strong-NOT: attributes #0 = { {{.*}}sspreq {{.*}} }
-    // strong-NOT: attributes #0 = { {{.*}}ssp {{.*}} }
-
-    // basic-NOT: attributes #0 = { {{.*}}sspreq {{.*}} }
-    // basic-NOT: attributes #0 = { {{.*}}sspstrong {{.*}} }
-    // basic: attributes #0 = { {{.*}}ssp {{.*}} }
-    // basic-NOT: attributes #0 = { {{.*}}sspreq {{.*}} }
-    // basic-NOT: attributes #0 = { {{.*}}sspstrong {{.*}} }
-
-    // none-NOT: attributes #0 = { {{.*}}sspreq {{.*}} }
-    // none-NOT: attributes #0 = { {{.*}}sspstrong {{.*}} }
-    // none-NOT: attributes #0 = { {{.*}}ssp {{.*}} }
-}
diff --git a/tests/codegen/static-relocation-model-msvc.rs b/tests/codegen/static-relocation-model-msvc.rs
deleted file mode 100644
index 4d30e6ec505..00000000000
--- a/tests/codegen/static-relocation-model-msvc.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Verify linkage of external symbols in the static relocation model on MSVC.
-//
-//@ compile-flags: -Copt-level=3 -C relocation-model=static
-//@ aux-build: extern_decl.rs
-//@ only-x86_64-pc-windows-msvc
-
-#![crate_type = "rlib"]
-
-extern crate extern_decl;
-
-// The `extern_decl` definitions are imported from a statically linked rust
-// crate, thus they are expected to be marked `dso_local` without `dllimport`.
-//
-// The `access_extern()` symbol is from this compilation unit, thus we expect
-// it to be marked `dso_local` as well, given the static relocation model.
-//
-// CHECK: @extern_static = external dso_local local_unnamed_addr global i8
-// CHECK: define dso_local noundef i8 @access_extern() {{.*}}
-// CHECK: declare dso_local noundef i8 @extern_fn() {{.*}}
-
-#[no_mangle]
-pub fn access_extern() -> u8 {
-    unsafe { extern_decl::extern_fn() + extern_decl::extern_static }
-}
diff --git a/tests/codegen/staticlib-external-inline-fns.rs b/tests/codegen/staticlib-external-inline-fns.rs
deleted file mode 100644
index 23316a2d9a5..00000000000
--- a/tests/codegen/staticlib-external-inline-fns.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "staticlib"]
-
-// CHECK: define{{.*}}void @a()
-#[no_mangle]
-#[inline]
-pub extern "C" fn a() {}
-
-// CHECK: define{{.*}}void @b()
-#[export_name = "b"]
-#[inline]
-pub extern "C" fn b() {}
-
-// CHECK: define{{.*}}void @c()
-#[no_mangle]
-#[inline]
-extern "C" fn c() {}
-
-// CHECK: define{{.*}}void @d()
-#[export_name = "d"]
-#[inline]
-extern "C" fn d() {}
-
-// CHECK: define{{.*}}void @e()
-#[no_mangle]
-#[inline(always)]
-pub extern "C" fn e() {}
-
-// CHECK: define{{.*}}void @f()
-#[export_name = "f"]
-#[inline(always)]
-pub extern "C" fn f() {}
-
-// CHECK: define{{.*}}void @g()
-#[no_mangle]
-#[inline(always)]
-extern "C" fn g() {}
-
-// CHECK: define{{.*}}void @h()
-#[export_name = "h"]
-#[inline(always)]
-extern "C" fn h() {}
diff --git a/tests/codegen/step_by-overflow-checks.rs b/tests/codegen/step_by-overflow-checks.rs
deleted file mode 100644
index 53800e9f879..00000000000
--- a/tests/codegen/step_by-overflow-checks.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-use std::iter::StepBy;
-use std::slice::Iter;
-
-// The constructor for `StepBy` ensures we can never end up needing to do zero
-// checks on denominators, so check that the code isn't emitting panic paths.
-
-// CHECK-LABEL: @step_by_len_std
-#[no_mangle]
-pub fn step_by_len_std(x: &StepBy<Iter<i32>>) -> usize {
-    // CHECK-NOT: div_by_zero
-    // CHECK: udiv
-    // CHECK-NOT: div_by_zero
-    x.len()
-}
-
-// CHECK-LABEL: @step_by_len_naive
-#[no_mangle]
-pub fn step_by_len_naive(x: Iter<i32>, step_minus_one: usize) -> usize {
-    // CHECK: udiv
-    // CHECK: call{{.+}}div_by_zero
-    x.len() / (step_minus_one + 1)
-}
diff --git a/tests/codegen/stores.rs b/tests/codegen/stores.rs
deleted file mode 100644
index aa3090db6d3..00000000000
--- a/tests/codegen/stores.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-//
-
-#![crate_type = "lib"]
-
-pub struct Bytes {
-    a: u8,
-    b: u8,
-    c: u8,
-    d: u8,
-}
-
-// CHECK-LABEL: small_array_alignment
-// The array is stored as i32, but its alignment is lower, go with 1 byte to avoid target
-// dependent alignment
-#[no_mangle]
-pub fn small_array_alignment(x: &mut [i8; 4], y: [i8; 4]) {
-    // CHECK: [[TMP:%.+]] = alloca [4 x i8], align 4
-    // CHECK: %y = alloca [4 x i8], align 1
-    // CHECK: store i32 %0, ptr [[TMP]]
-    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 {{.+}}, ptr align 4 {{.+}}, i{{[0-9]+}} 4, i1 false)
-    *x = y;
-}
-
-// CHECK-LABEL: small_struct_alignment
-// The struct is stored as i32, but its alignment is lower, go with 1 byte to avoid target
-// dependent alignment
-#[no_mangle]
-pub fn small_struct_alignment(x: &mut Bytes, y: Bytes) {
-    // CHECK: [[TMP:%.+]] = alloca [4 x i8], align 4
-    // CHECK: %y = alloca [4 x i8], align 1
-    // CHECK: store i32 %0, ptr [[TMP]]
-    // CHECK: call void @llvm.memcpy.{{.*}}(ptr align 1 {{.+}}, ptr align 4 {{.+}}, i{{[0-9]+}} 4, i1 false)
-    *x = y;
-}
diff --git a/tests/codegen/string-push.rs b/tests/codegen/string-push.rs
deleted file mode 100644
index cf5f6bb1aa3..00000000000
--- a/tests/codegen/string-push.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Check that `String::push` is optimized enough not to call `memcpy`.
-
-//@ compile-flags: -O
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @string_push_does_not_call_memcpy
-#[no_mangle]
-pub fn string_push_does_not_call_memcpy(s: &mut String, ch: char) {
-    // CHECK-NOT: call void @llvm.memcpy
-    s.push(ch);
-}
diff --git a/tests/codegen/swap-large-types.rs b/tests/codegen/swap-large-types.rs
deleted file mode 100644
index 08c486affd9..00000000000
--- a/tests/codegen/swap-large-types.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-use std::mem::swap;
-use std::ptr::{copy_nonoverlapping, read, write};
-
-type KeccakBuffer = [[u64; 5]; 5];
-
-// A basic read+copy+write swap implementation ends up copying one of the values
-// to stack for large types, which is completely unnecessary as the lack of
-// overlap means we can just do whatever fits in registers at a time.
-
-// The tests here (after the first one showing that the problem still exists)
-// are less about testing *exactly* what the codegen is, and more about testing
-// 1) That things are swapped directly from one argument to the other,
-//    never going through stack along the way, and
-// 2) That we're doing the swapping for big things using large vector types,
-//    rather then `i64` or `<8 x i8>` (or, even worse, `i8`) at a time.
-//
-// (There are separate tests for intrinsics::typed_swap_nonoverlapping that
-//  check that it, as an intrinsic, are emitting exactly what it should.)
-
-// CHECK-LABEL: @swap_basic
-#[no_mangle]
-pub fn swap_basic(x: &mut KeccakBuffer, y: &mut KeccakBuffer) {
-    // CHECK: alloca [200 x i8]
-
-    // SAFETY: exclusive references are always valid to read/write,
-    // are non-overlapping, and nothing here panics so it's drop-safe.
-    unsafe {
-        let z = read(x);
-        copy_nonoverlapping(y, x, 1);
-        write(y, z);
-    }
-}
-
-// CHECK-LABEL: @swap_std
-#[no_mangle]
-pub fn swap_std(x: &mut KeccakBuffer, y: &mut KeccakBuffer) {
-    // CHECK-NOT: alloca
-    // CHECK: load <{{2|4}} x i64>
-    // CHECK: store <{{2|4}} x i64>
-    swap(x, y)
-}
-
-// CHECK-LABEL: @swap_slice
-#[no_mangle]
-pub fn swap_slice(x: &mut [KeccakBuffer], y: &mut [KeccakBuffer]) {
-    // CHECK-NOT: alloca
-    // CHECK: load <{{2|4}} x i64>
-    // CHECK: store <{{2|4}} x i64>
-    if x.len() == y.len() {
-        x.swap_with_slice(y);
-    }
-}
-
-type OneKilobyteBuffer = [u8; 1024];
-
-// CHECK-LABEL: @swap_1kb_slices
-#[no_mangle]
-pub fn swap_1kb_slices(x: &mut [OneKilobyteBuffer], y: &mut [OneKilobyteBuffer]) {
-    // CHECK-NOT: alloca
-
-    // CHECK-NOT: load i32
-    // CHECK-NOT: store i32
-    // CHECK-NOT: load i16
-    // CHECK-NOT: store i16
-    // CHECK-NOT: load i8
-    // CHECK-NOT: store i8
-
-    // CHECK: load <{{2|4}} x i64>{{.+}}align 1,
-    // CHECK: store <{{2|4}} x i64>{{.+}}align 1,
-
-    // CHECK-NOT: load i32
-    // CHECK-NOT: store i32
-    // CHECK-NOT: load i16
-    // CHECK-NOT: store i16
-    // CHECK-NOT: load i8
-    // CHECK-NOT: store i8
-
-    if x.len() == y.len() {
-        x.swap_with_slice(y);
-    }
-}
-
-#[repr(align(64))]
-pub struct BigButHighlyAligned([u8; 64 * 3]);
-
-// CHECK-LABEL: @swap_big_aligned
-#[no_mangle]
-pub fn swap_big_aligned(x: &mut BigButHighlyAligned, y: &mut BigButHighlyAligned) {
-    // CHECK-NOT: call void @llvm.memcpy
-    // CHECK-NOT: load i32
-    // CHECK-NOT: store i32
-    // CHECK-NOT: load i16
-    // CHECK-NOT: store i16
-    // CHECK-NOT: load i8
-    // CHECK-NOT: store i8
-
-    // CHECK-COUNT-2: load <{{2|4}} x i64>{{.+}}align 64,
-    // CHECK-COUNT-2: store <{{2|4}} x i64>{{.+}}align 64,
-
-    // CHECK-COUNT-2: load <{{2|4}} x i64>{{.+}}align 32,
-    // CHECK-COUNT-2: store <{{2|4}} x i64>{{.+}}align 32,
-
-    // CHECK-NOT: load i32
-    // CHECK-NOT: store i32
-    // CHECK-NOT: load i16
-    // CHECK-NOT: store i16
-    // CHECK-NOT: load i8
-    // CHECK-NOT: store i8
-    // CHECK-NOT: call void @llvm.memcpy
-    swap(x, y)
-}
diff --git a/tests/codegen/swap-small-types.rs b/tests/codegen/swap-small-types.rs
deleted file mode 100644
index 7aa613ae9c2..00000000000
--- a/tests/codegen/swap-small-types.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-//@ only-x86_64
-//@ min-llvm-version: 20
-//@ ignore-std-debug-assertions (`ptr::swap_nonoverlapping` has one which blocks some optimizations)
-
-#![crate_type = "lib"]
-
-use std::mem::swap;
-
-type RGB48 = [u16; 3];
-
-// CHECK-LABEL: @swap_rgb48_manually(
-#[no_mangle]
-pub fn swap_rgb48_manually(x: &mut RGB48, y: &mut RGB48) {
-    // FIXME: See #115212 for why this has an alloca again
-
-    // CHECK: alloca [6 x i8], align 2
-    // CHECK: call void @llvm.memcpy.p0.p0.i64({{.+}}, i64 6, i1 false)
-    // CHECK: call void @llvm.memcpy.p0.p0.i64({{.+}}, i64 6, i1 false)
-    // CHECK: call void @llvm.memcpy.p0.p0.i64({{.+}}, i64 6, i1 false)
-
-    let temp = *x;
-    *x = *y;
-    *y = temp;
-}
-
-// CHECK-LABEL: @swap_rgb48
-#[no_mangle]
-pub fn swap_rgb48(x: &mut RGB48, y: &mut RGB48) {
-    // CHECK-NOT: alloca
-
-    // Swapping `i48` might be cleaner in LLVM-IR here, but `i32`+`i16` isn't bad,
-    // and is closer to the assembly it generates anyway.
-
-    // CHECK-NOT: load{{ }}
-    // CHECK: load i32{{.+}}align 2
-    // CHECK-NEXT: load i32{{.+}}align 2
-    // CHECK-NEXT: store i32{{.+}}align 2
-    // CHECK-NEXT: store i32{{.+}}align 2
-    // CHECK: load i16{{.+}}align 2
-    // CHECK-NEXT: load i16{{.+}}align 2
-    // CHECK-NEXT: store i16{{.+}}align 2
-    // CHECK-NEXT: store i16{{.+}}align 2
-    // CHECK-NOT: store{{ }}
-    swap(x, y)
-}
-
-type RGBA64 = [u16; 4];
-
-// CHECK-LABEL: @swap_rgba64
-#[no_mangle]
-pub fn swap_rgba64(x: &mut RGBA64, y: &mut RGBA64) {
-    // CHECK-NOT: alloca
-    // CHECK-DAG: %[[XVAL:.+]] = load i64, ptr %x, align 2
-    // CHECK-DAG: %[[YVAL:.+]] = load i64, ptr %y, align 2
-    // CHECK-DAG: store i64 %[[YVAL]], ptr %x, align 2
-    // CHECK-DAG: store i64 %[[XVAL]], ptr %y, align 2
-    swap(x, y)
-}
-
-// CHECK-LABEL: @swap_vecs
-#[no_mangle]
-pub fn swap_vecs(x: &mut Vec<u32>, y: &mut Vec<u32>) {
-    // CHECK-NOT: alloca
-    // There are plenty more loads and stores than just these,
-    // but at least one sure better be 64-bit (for size or capacity).
-    // CHECK: load i64
-    // CHECK: load i64
-    // CHECK: store i64
-    // CHECK: store i64
-    // CHECK: ret void
-    swap(x, y)
-}
-
-// CHECK-LABEL: @swap_slices
-#[no_mangle]
-pub fn swap_slices<'a>(x: &mut &'a [u32], y: &mut &'a [u32]) {
-    // CHECK-NOT: alloca
-    // CHECK: load ptr
-    // CHECK: load i64
-    // CHECK: call void @llvm.memcpy.p0.p0.i64({{.+}}, i64 16, i1 false)
-    // CHECK: store ptr
-    // CHECK: store i64
-    swap(x, y)
-}
-
-type RGB24 = [u8; 3];
-
-// CHECK-LABEL: @swap_rgb24_slices
-#[no_mangle]
-pub fn swap_rgb24_slices(x: &mut [RGB24], y: &mut [RGB24]) {
-    // CHECK-NOT: alloca
-
-    // CHECK: mul nuw nsw i64 %{{x|y}}.1, 3
-
-    // CHECK: load <{{[0-9]+}} x i64>
-    // CHECK: store <{{[0-9]+}} x i64>
-
-    // CHECK-COUNT-2: load i32
-    // CHECK-COUNT-2: store i32
-    // CHECK-COUNT-2: load i16
-    // CHECK-COUNT-2: store i16
-    // CHECK-COUNT-2: load i8
-    // CHECK-COUNT-2: store i8
-    if x.len() == y.len() {
-        x.swap_with_slice(y);
-    }
-}
-
-type RGBA32 = [u8; 4];
-
-// CHECK-LABEL: @swap_rgba32_slices
-#[no_mangle]
-pub fn swap_rgba32_slices(x: &mut [RGBA32], y: &mut [RGBA32]) {
-    // CHECK-NOT: alloca
-
-    // Because the size in bytes in a multiple of 4, we can skip the smallest sizes.
-
-    // CHECK: load <{{[0-9]+}} x i64>
-    // CHECK: store <{{[0-9]+}} x i64>
-
-    // CHECK-COUNT-2: load i32
-    // CHECK-COUNT-2: store i32
-
-    // CHECK-NOT: load i16
-    // CHECK-NOT: store i16
-    // CHECK-NOT: load i8
-    // CHECK-NOT: store i8
-
-    if x.len() == y.len() {
-        x.swap_with_slice(y);
-    }
-}
-
-// Strings have a non-power-of-two size, but have pointer alignment,
-// so we swap usizes instead of dropping all the way down to bytes.
-const _: () = assert!(!std::mem::size_of::<String>().is_power_of_two());
-
-// CHECK-LABEL: @swap_string_slices
-#[no_mangle]
-pub fn swap_string_slices(x: &mut [String], y: &mut [String]) {
-    // CHECK-NOT: alloca
-    // CHECK: load <{{[0-9]+}} x i64>{{.+}}, align 8,
-    // CHECK: store <{{[0-9]+}} x i64>{{.+}}, align 8,
-    if x.len() == y.len() {
-        x.swap_with_slice(y);
-    }
-}
-
-#[repr(C, packed)]
-pub struct Packed {
-    pub first: bool,
-    pub second: usize,
-}
-
-// CHECK-LABEL: @swap_packed_structs
-#[no_mangle]
-pub fn swap_packed_structs(x: &mut Packed, y: &mut Packed) {
-    // CHECK-NOT: alloca
-
-    // CHECK-NOT: load
-    // CHECK-NOT: store
-
-    // CHECK: %[[A:.+]] = load i64, ptr %x, align 1,
-    // CHECK-NEXT: %[[B:.+]] = load i64, ptr %y, align 1,
-    // CHECK-NEXT: store i64 %[[B]], ptr %x, align 1,
-    // CHECK-NEXT: store i64 %[[A]], ptr %y, align 1,
-
-    // CHECK-NOT: load
-    // CHECK-NOT: store
-
-    // CHECK: %[[C:.+]] = load i8, ptr %[[X8:.+]], align 1,
-    // CHECK-NEXT: %[[D:.+]] = load i8, ptr %[[Y8:.+]], align 1,
-    // CHECK-NEXT: store i8 %[[D]], ptr %[[X8]], align 1,
-    // CHECK-NEXT: store i8 %[[C]], ptr %[[Y8]], align 1,
-
-    // CHECK-NOT: load
-    // CHECK-NOT: store
-
-    // CHECK: ret void
-    swap(x, y)
-}
diff --git a/tests/codegen/target-cpu-on-functions.rs b/tests/codegen/target-cpu-on-functions.rs
deleted file mode 100644
index 25c10e7ce44..00000000000
--- a/tests/codegen/target-cpu-on-functions.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// This test makes sure that functions get annotated with the proper
-// "target-cpu" attribute in LLVM.
-
-//@ no-prefer-dynamic
-//
-//@ compile-flags: -C no-prepopulate-passes -C panic=abort -C linker-plugin-lto -Cpasses=name-anon-globals
-
-#![crate_type = "staticlib"]
-
-// CHECK-LABEL: define {{.*}} @exported() {{.*}} #0
-#[no_mangle]
-pub extern "C" fn exported() {
-    not_exported();
-}
-
-// CHECK-LABEL: ; target_cpu_on_functions::not_exported
-// CHECK-NEXT: ; Function Attrs:
-// CHECK-NEXT: define {{.*}}() {{.*}} #1
-#[inline(never)]
-fn not_exported() {}
-
-// CHECK: attributes #0 = {{.*}} "target-cpu"="{{.*}}"
diff --git a/tests/codegen/target-feature-inline-closure.rs b/tests/codegen/target-feature-inline-closure.rs
deleted file mode 100644
index 5d54444f994..00000000000
--- a/tests/codegen/target-feature-inline-closure.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ only-x86_64
-// Set the base cpu explicitly, in case the default has been changed.
-//@ compile-flags: -Copt-level=3 -Ctarget-cpu=x86-64
-
-#![crate_type = "lib"]
-
-#[cfg(target_arch = "x86_64")]
-use std::arch::x86_64::*;
-
-// CHECK-LABEL: @with_avx
-#[no_mangle]
-#[cfg(target_arch = "x86_64")]
-#[target_feature(enable = "avx")]
-fn with_avx(x: __m256) -> __m256 {
-    // CHECK: fadd <8 x float>
-    let add = {
-        #[inline(always)]
-        |x, y| unsafe { _mm256_add_ps(x, y) }
-    };
-    add(x, x)
-}
-
-// CHECK-LABEL: @without_avx
-#[no_mangle]
-#[cfg(target_arch = "x86_64")]
-unsafe fn without_avx(x: __m256) -> __m256 {
-    // CHECK-NOT: fadd <8 x float>
-    let add = {
-        #[inline(always)]
-        |x, y| unsafe { _mm256_add_ps(x, y) }
-    };
-    add(x, x)
-}
diff --git a/tests/codegen/target-feature-negative-implication.rs b/tests/codegen/target-feature-negative-implication.rs
deleted file mode 100644
index 36cd82dd8cf..00000000000
--- a/tests/codegen/target-feature-negative-implication.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ add-core-stubs
-//@ needs-llvm-components: x86
-//@ compile-flags: --target=x86_64-unknown-linux-gnu
-//@ compile-flags: -Ctarget-feature=-avx2
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-#[no_mangle]
-pub unsafe fn banana() {
-    // CHECK-LABEL: @banana()
-    // CHECK-SAME: [[BANANAATTRS:#[0-9]+]] {
-}
-
-// CHECK: attributes [[BANANAATTRS]]
-// CHECK-SAME: -avx512
diff --git a/tests/codegen/target-feature-overrides.rs b/tests/codegen/target-feature-overrides.rs
deleted file mode 100644
index 63a586d388b..00000000000
--- a/tests/codegen/target-feature-overrides.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// ignore-tidy-linelength
-//@ add-core-stubs
-//@ revisions: COMPAT INCOMPAT
-//@ needs-llvm-components: x86
-//@ compile-flags: --target=x86_64-unknown-linux-gnu -Copt-level=3
-//@ [COMPAT] compile-flags: -Ctarget-feature=+avx2
-//@ [INCOMPAT] compile-flags: -Ctarget-feature=-avx2,-avx
-
-// See also tests/assembly-llvm/target-feature-multiple.rs
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-extern "C" {
-    fn peach() -> u32;
-}
-
-#[inline]
-#[target_feature(enable = "avx")]
-#[no_mangle]
-pub unsafe fn apple() -> u32 {
-    // CHECK-LABEL: @apple()
-    // CHECK-SAME: [[APPLEATTRS:#[0-9]+]] {
-    // CHECK: {{.*}}call{{.*}}@peach
-    peach()
-}
-
-// target features same as global
-#[no_mangle]
-pub unsafe fn banana() -> u32 {
-    // CHECK-LABEL: @banana()
-    // CHECK-SAME: [[BANANAATTRS:#[0-9]+]] {
-    // COMPAT: {{.*}}call{{.*}}@peach
-    // INCOMPAT: {{.*}}call{{.*}}@apple
-    apple() // Compatible for inline in COMPAT revision and can't be inlined in INCOMPAT
-}
-
-// CHECK: attributes [[APPLEATTRS]]
-// COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
-// INCOMPAT-SAME: "target-features"="{{(-[^,]+,)*}}-avx2{{(,-[^,]+)*}},-avx{{(,-[^,]+)*}},+avx{{(,\+[^,]+)*}}"
-// CHECK: attributes [[BANANAATTRS]]
-// COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
-// INCOMPAT-SAME: "target-features"="{{(-[^,]+,)*}}-avx2{{(,-[^,]+)*}},-avx{{(,-[^,]+)*}}"
diff --git a/tests/codegen/terminating-catchpad.rs b/tests/codegen/terminating-catchpad.rs
deleted file mode 100644
index a2ec19871d1..00000000000
--- a/tests/codegen/terminating-catchpad.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//@ revisions: emscripten wasi seh
-//@[emscripten] compile-flags: --target wasm32-unknown-emscripten -Z emscripten-wasm-eh
-//@[wasi] compile-flags: --target wasm32-wasip1 -C panic=unwind
-//@[seh] compile-flags: --target x86_64-pc-windows-msvc
-//@[emscripten] needs-llvm-components: webassembly
-//@[wasi] needs-llvm-components: webassembly
-//@[seh] needs-llvm-components: x86
-
-// Ensure a catch-all generates:
-// - `catchpad ... [ptr null]` on Wasm (otherwise LLVM gets confused)
-// - `catchpad ... [ptr null, i32 64, ptr null]` on Windows (otherwise we catch SEH exceptions)
-
-#![feature(no_core, lang_items, rustc_attrs)]
-#![crate_type = "lib"]
-#![no_std]
-#![no_core]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-unsafe extern "C-unwind" {
-    safe fn unwinds();
-}
-
-#[lang = "panic_cannot_unwind"]
-fn panic_cannot_unwind() -> ! {
-    loop {}
-}
-
-#[no_mangle]
-#[rustc_nounwind]
-pub fn doesnt_unwind() {
-    // emscripten: %catchpad = catchpad within %catchswitch [ptr null]
-    // wasi: %catchpad = catchpad within %catchswitch [ptr null]
-    // seh: %catchpad = catchpad within %catchswitch [ptr null, i32 64, ptr null]
-    unwinds();
-}
diff --git a/tests/codegen/thread-local.rs b/tests/codegen/thread-local.rs
deleted file mode 100644
index 41df8c9be1b..00000000000
--- a/tests/codegen/thread-local.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ aux-build:thread_local_aux.rs
-//@ ignore-windows FIXME(#134939)
-//@ ignore-wasm globals are used instead of thread locals
-//@ ignore-emscripten globals are used instead of thread locals
-//@ ignore-android does not use #[thread_local]
-//@ ignore-nto does not use #[thread_local]
-
-#![crate_type = "lib"]
-
-extern crate thread_local_aux as aux;
-
-use std::cell::Cell;
-
-thread_local!(static A: Cell<u32> = const { Cell::new(1) });
-
-// CHECK: [[TLS_AUX:@.+]] = external thread_local{{.*}} global i64
-// CHECK: [[TLS:@.+]] = internal thread_local{{.*}} global
-
-// CHECK-LABEL: @get
-#[no_mangle]
-fn get() -> u32 {
-    // CHECK: [[PTR:%.+]] = tail call {{.*}} ptr @llvm.threadlocal.address.p0(ptr [[TLS]])
-    // CHECK-NEXT: [[RET_0:%.+]] = load i32, ptr [[PTR]]
-    // CHECK-NEXT: ret i32 [[RET_0]]
-    A.with(|a| a.get())
-}
-
-// CHECK-LABEL: @set
-#[no_mangle]
-fn set(v: u32) {
-    // CHECK: [[PTR:%.+]] = tail call {{.*}} ptr @llvm.threadlocal.address.p0(ptr [[TLS]])
-    // CHECK-NEXT: store i32 %0, ptr [[PTR]]
-    // CHECK-NEXT: ret void
-    A.with(|a| a.set(v))
-}
-
-// CHECK-LABEL: @get_aux
-#[no_mangle]
-fn get_aux() -> u64 {
-    // CHECK: [[PTR:%.+]] = tail call {{.*}} ptr @llvm.threadlocal.address.p0(ptr [[TLS_AUX]])
-    // CHECK-NEXT: [[RET_1:%.+]] = load i64, ptr [[PTR]]
-    // CHECK-NEXT: ret i64 [[RET_1]]
-    aux::A.with(|a| a.get())
-}
-
-// CHECK-LABEL: @set_aux
-#[no_mangle]
-fn set_aux(v: u64) {
-    // CHECK: [[PTR:%.+]] = tail call {{.*}} ptr @llvm.threadlocal.address.p0(ptr [[TLS_AUX]])
-    // CHECK-NEXT: store i64 %0, ptr [[PTR]]
-    // CHECK-NEXT: ret void
-    aux::A.with(|a| a.set(v))
-}
diff --git a/tests/codegen/tied-features-strength.rs b/tests/codegen/tied-features-strength.rs
deleted file mode 100644
index 81499c070d1..00000000000
--- a/tests/codegen/tied-features-strength.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// ignore-tidy-linelength
-//@ add-core-stubs
-//@ revisions: ENABLE_SVE DISABLE_SVE DISABLE_NEON ENABLE_NEON
-//@ compile-flags: --crate-type=rlib --target=aarch64-unknown-linux-gnu
-//@ needs-llvm-components: aarch64
-
-// Rust made SVE require neon.
-//@ [ENABLE_SVE] compile-flags: -C target-feature=+sve -Copt-level=0
-// ENABLE_SVE: attributes #0
-// ENABLE_SVE-SAME: +neon
-// ENABLE_SVE-SAME: +sve
-
-// However, disabling SVE does not disable neon.
-//@ [DISABLE_SVE] compile-flags: -C target-feature=-sve -Copt-level=0
-// DISABLE_SVE: attributes #0
-// DISABLE_SVE-NOT: -neon
-// DISABLE_SVE-SAME: -sve
-
-// OTOH, neon fn `fp-armv8` are fully tied; toggling neon must toggle `fp-armv8` the same way.
-//@ [DISABLE_NEON] compile-flags: -C target-feature=-neon -Copt-level=0
-// DISABLE_NEON: attributes #0
-// DISABLE_NEON-SAME: -neon
-// DISABLE_NEON-SAME: -fp-armv8
-
-//@ [ENABLE_NEON] compile-flags: -C target-feature=+neon -Copt-level=0
-// ENABLE_NEON: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fp-armv8,?)|(\+neon,?))*}}" }
-
-#![feature(no_core, lang_items)]
-#![no_core]
-
-extern crate minicore;
-use minicore::*;
-
-pub fn test() {}
diff --git a/tests/codegen/to_vec.rs b/tests/codegen/to_vec.rs
deleted file mode 100644
index 4f6e77188d8..00000000000
--- a/tests/codegen/to_vec.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @copy_to_vec
-#[no_mangle]
-fn copy_to_vec(s: &[u64]) -> Vec<u64> {
-    s.to_vec()
-    // CHECK: call void @llvm.memcpy
-}
diff --git a/tests/codegen/trailing_zeros.rs b/tests/codegen/trailing_zeros.rs
deleted file mode 100644
index 0816a980992..00000000000
--- a/tests/codegen/trailing_zeros.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @trailing_zeros_ge
-#[no_mangle]
-pub fn trailing_zeros_ge(val: u32) -> bool {
-    // CHECK: %[[AND:.*]] = and i32 %val, 7
-    // CHECK: %[[ICMP:.*]] = icmp eq i32 %[[AND]], 0
-    // CHECK: ret i1 %[[ICMP]]
-    val.trailing_zeros() >= 3
-}
-
-// CHECK-LABEL: @trailing_zeros_gt
-#[no_mangle]
-pub fn trailing_zeros_gt(val: u64) -> bool {
-    // CHECK: %[[AND:.*]] = and i64 %val, 15
-    // CHECK: %[[ICMP:.*]] = icmp eq i64 %[[AND]], 0
-    // CHECK: ret i1 %[[ICMP]]
-    val.trailing_zeros() > 3
-}
diff --git a/tests/codegen/transmute-optimized.rs b/tests/codegen/transmute-optimized.rs
deleted file mode 100644
index 477fdc6de90..00000000000
--- a/tests/codegen/transmute-optimized.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-#![crate_type = "lib"]
-
-// This tests that LLVM can optimize based on the niches in the source or
-// destination types for transmutes.
-
-#[repr(u32)]
-pub enum AlwaysZero32 {
-    X = 0,
-}
-
-// CHECK-LABEL: i32 @issue_109958(i32
-#[no_mangle]
-pub fn issue_109958(x: AlwaysZero32) -> i32 {
-    // CHECK: ret i32 0
-    unsafe { std::mem::transmute(x) }
-}
-
-// CHECK-LABEL: i1 @reference_is_null(ptr
-#[no_mangle]
-pub fn reference_is_null(x: &i32) -> bool {
-    // CHECK: ret i1 false
-    let p: *const i32 = unsafe { std::mem::transmute(x) };
-    p.is_null()
-}
-
-// CHECK-LABEL: i1 @non_null_is_null(ptr
-#[no_mangle]
-pub fn non_null_is_null(x: std::ptr::NonNull<i32>) -> bool {
-    // CHECK: ret i1 false
-    let p: *const i32 = unsafe { std::mem::transmute(x) };
-    p.is_null()
-}
-
-// CHECK-LABEL: i1 @non_zero_is_null(
-#[no_mangle]
-pub fn non_zero_is_null(x: std::num::NonZero<usize>) -> bool {
-    // CHECK: ret i1 false
-    let p: *const i32 = unsafe { std::mem::transmute(x) };
-    p.is_null()
-}
-
-// CHECK-LABEL: i1 @non_null_is_zero(ptr
-#[no_mangle]
-pub fn non_null_is_zero(x: std::ptr::NonNull<i32>) -> bool {
-    // CHECK: ret i1 false
-    let a: isize = unsafe { std::mem::transmute(x) };
-    a == 0
-}
-
-// CHECK-LABEL: i1 @bool_ordering_is_ge(i1
-#[no_mangle]
-pub fn bool_ordering_is_ge(x: bool) -> bool {
-    // CHECK: ret i1 true
-    let y: std::cmp::Ordering = unsafe { std::mem::transmute(x) };
-    y.is_ge()
-}
-
-// CHECK-LABEL: i1 @ordering_is_ge_then_transmute_to_bool(i8
-#[no_mangle]
-pub fn ordering_is_ge_then_transmute_to_bool(x: std::cmp::Ordering) -> bool {
-    let r = x.is_ge();
-    let _: bool = unsafe { std::mem::transmute(x) };
-    r
-}
-
-// CHECK-LABEL: i32 @normal_div(i32
-#[no_mangle]
-pub fn normal_div(a: u32, b: u32) -> u32 {
-    // CHECK: call core::panicking::panic
-    a / b
-}
-
-// CHECK-LABEL: i32 @div_transmute_nonzero(i32
-#[no_mangle]
-pub fn div_transmute_nonzero(a: u32, b: std::num::NonZero<i32>) -> u32 {
-    // CHECK-NOT: call core::panicking::panic
-    // CHECK: %[[R:.+]] = udiv i32 %a, %b
-    // CHECK-NEXT: ret i32 %[[R]]
-    // CHECK-NOT: call core::panicking::panic
-    let d: u32 = unsafe { std::mem::transmute(b) };
-    a / d
-}
-
-#[repr(i8)]
-pub enum OneTwoThree {
-    One = 1,
-    Two = 2,
-    Three = 3,
-}
-
-// CHECK-LABEL: i8 @ordering_transmute_onetwothree(i8
-#[no_mangle]
-pub unsafe fn ordering_transmute_onetwothree(x: std::cmp::Ordering) -> OneTwoThree {
-    // CHECK: ret i8 1
-    std::mem::transmute(x)
-}
-
-// CHECK-LABEL: i8 @onetwothree_transmute_ordering(i8
-#[no_mangle]
-pub unsafe fn onetwothree_transmute_ordering(x: OneTwoThree) -> std::cmp::Ordering {
-    // CHECK: ret i8 1
-    std::mem::transmute(x)
-}
-
-// CHECK-LABEL: i1 @char_is_negative(i32
-#[no_mangle]
-pub fn char_is_negative(c: char) -> bool {
-    // CHECK: ret i1 false
-    let x: i32 = unsafe { std::mem::transmute(c) };
-    x < 0
-}
-
-// CHECK-LABEL: i1 @transmute_to_char_is_negative(i32
-#[no_mangle]
-pub fn transmute_to_char_is_negative(x: i32) -> bool {
-    // CHECK: ret i1 false
-    let _c: char = unsafe { std::mem::transmute(x) };
-    x < 0
-}
diff --git a/tests/codegen/transmute-scalar.rs b/tests/codegen/transmute-scalar.rs
deleted file mode 100644
index ce1b0558b2e..00000000000
--- a/tests/codegen/transmute-scalar.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-//@ add-core-stubs
-//@ compile-flags: -C opt-level=0 -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(no_core, repr_simd, arm_target_feature, mips_target_feature, s390x_target_feature)]
-#![no_core]
-extern crate minicore;
-
-use minicore::*;
-
-// With opaque ptrs in LLVM, `transmute` can load/store any `alloca` as any type,
-// without needing to pointercast, and SRoA will turn that into a `bitcast`.
-// Thus memory-to-memory transmutes don't need to generate them ourselves.
-
-// However, `bitcast`s and `ptrtoint`s and `inttoptr`s are still worth doing when
-// that allows us to avoid the `alloca`s entirely; see `rvalue_creates_operand`.
-
-// CHECK-LABEL: define{{.*}}i32 @f32_to_bits(float %x)
-// CHECK: %_0 = bitcast float %x to i32
-// CHECK-NEXT: ret i32 %_0
-#[no_mangle]
-pub fn f32_to_bits(x: f32) -> u32 {
-    unsafe { mem::transmute(x) }
-}
-
-// CHECK-LABEL: define{{.*}}i8 @bool_to_byte(i1 zeroext %b)
-// CHECK: %_0 = zext i1 %b to i8
-// CHECK-NEXT: ret i8 %_0
-#[no_mangle]
-pub fn bool_to_byte(b: bool) -> u8 {
-    unsafe { mem::transmute(b) }
-}
-
-// CHECK-LABEL: define{{.*}}zeroext i1 @byte_to_bool(i8{{.*}} %byte)
-// CHECK: %_0 = trunc{{( nuw)?}} i8 %byte to i1
-// CHECK-NEXT: ret i1 %_0
-#[no_mangle]
-pub unsafe fn byte_to_bool(byte: u8) -> bool {
-    mem::transmute(byte)
-}
-
-// CHECK-LABEL: define{{.*}}ptr @ptr_to_ptr(ptr %p)
-// CHECK: ret ptr %p
-#[no_mangle]
-pub fn ptr_to_ptr(p: *mut u16) -> *mut u8 {
-    unsafe { mem::transmute(p) }
-}
-
-// CHECK: define{{.*}}[[USIZE:i[0-9]+]] @ptr_to_int(ptr %p)
-// CHECK: %_0 = ptrtoint ptr %p to [[USIZE]]
-// CHECK-NEXT: ret [[USIZE]] %_0
-#[no_mangle]
-pub fn ptr_to_int(p: *mut u16) -> usize {
-    unsafe { mem::transmute(p) }
-}
-
-// CHECK: define{{.*}}ptr @int_to_ptr([[USIZE]] %i)
-// CHECK: %_0 = getelementptr i8, ptr null, [[USIZE]] %i
-// CHECK-NEXT: ret ptr %_0
-#[no_mangle]
-pub fn int_to_ptr(i: usize) -> *mut u16 {
-    unsafe { mem::transmute(i) }
-}
-
-// This is the one case where signedness matters to transmuting:
-// the LLVM type is `i8` here because of `repr(i8)`,
-// whereas below with the `repr(u8)` it's `i1` in LLVM instead.
-#[repr(i8)]
-pub enum FakeBoolSigned {
-    False = 0,
-    True = 1,
-}
-
-// CHECK-LABEL: define{{.*}}i8 @bool_to_fake_bool_signed(i1 zeroext %b)
-// CHECK: %_0 = zext i1 %b to i8
-// CHECK-NEXT: ret i8 %_0
-#[no_mangle]
-pub fn bool_to_fake_bool_signed(b: bool) -> FakeBoolSigned {
-    unsafe { mem::transmute(b) }
-}
-
-// CHECK-LABEL: define{{.*}}i1 @fake_bool_signed_to_bool(i8 %b)
-// CHECK: %_0 = trunc nuw i8 %b to i1
-// CHECK-NEXT: ret i1 %_0
-#[no_mangle]
-pub fn fake_bool_signed_to_bool(b: FakeBoolSigned) -> bool {
-    unsafe { mem::transmute(b) }
-}
-
-#[repr(u8)]
-pub enum FakeBoolUnsigned {
-    False = 0,
-    True = 1,
-}
-
-// CHECK-LABEL: define{{.*}}i1 @bool_to_fake_bool_unsigned(i1 zeroext %b)
-// CHECK: ret i1 %b
-#[no_mangle]
-pub fn bool_to_fake_bool_unsigned(b: bool) -> FakeBoolUnsigned {
-    unsafe { mem::transmute(b) }
-}
-
-// CHECK-LABEL: define{{.*}}i1 @fake_bool_unsigned_to_bool(i1 zeroext %b)
-// CHECK: ret i1 %b
-#[no_mangle]
-pub fn fake_bool_unsigned_to_bool(b: FakeBoolUnsigned) -> bool {
-    unsafe { mem::transmute(b) }
-}
-
-#[repr(simd)]
-struct S([i64; 1]);
-
-// CHECK-LABEL: define{{.*}}i64 @single_element_simd_to_scalar(<1 x i64> %b)
-// CHECK-NEXT: start:
-// CHECK-NEXT: %[[RET:.+]] = alloca [8 x i8]
-// CHECK-NEXT: store <1 x i64> %b, ptr %[[RET]]
-// CHECK-NEXT: %[[TEMP:.+]] = load i64, ptr %[[RET]]
-// CHECK-NEXT: ret i64 %[[TEMP]]
-#[no_mangle]
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
-pub extern "C" fn single_element_simd_to_scalar(b: S) -> i64 {
-    unsafe { mem::transmute(b) }
-}
-
-// CHECK-LABEL: define{{.*}}<1 x i64> @scalar_to_single_element_simd(i64 %b)
-// CHECK-NEXT: start:
-// CHECK-NEXT: %[[RET:.+]] = alloca [8 x i8]
-// CHECK-NEXT: store i64 %b, ptr %[[RET]]
-// CHECK-NEXT: %[[TEMP:.+]] = load <1 x i64>, ptr %[[RET]]
-// CHECK-NEXT: ret <1 x i64> %[[TEMP]]
-#[no_mangle]
-#[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
-#[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
-#[cfg_attr(target_arch = "x86", target_feature(enable = "sse"))]
-#[cfg_attr(target_arch = "mips", target_feature(enable = "msa"))]
-#[cfg_attr(target_arch = "s390x", target_feature(enable = "vector"))]
-pub extern "C" fn scalar_to_single_element_simd(b: i64) -> S {
-    unsafe { mem::transmute(b) }
-}
diff --git a/tests/codegen/try_question_mark_nop.rs b/tests/codegen/try_question_mark_nop.rs
deleted file mode 100644
index 398c9a580bc..00000000000
--- a/tests/codegen/try_question_mark_nop.rs
+++ /dev/null
@@ -1,243 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-//@ edition: 2021
-//@ only-x86_64
-//@ revisions: NINETEEN TWENTY
-//@[NINETEEN] exact-llvm-major-version: 19
-//@[TWENTY] min-llvm-version: 20
-
-#![crate_type = "lib"]
-#![feature(try_blocks)]
-
-use std::ops::ControlFlow::{self, Break, Continue};
-use std::ptr::NonNull;
-
-// CHECK-LABEL: @option_nop_match_32
-#[no_mangle]
-pub fn option_nop_match_32(x: Option<u32>) -> Option<u32> {
-    // CHECK: start:
-    // CHECK-NEXT: [[TRUNC:%.*]] = trunc nuw i32 %0 to i1
-
-    // NINETEEN-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i32 %0, i32 0
-    // NINETEEN-NEXT: [[REG2:%.*]] = insertvalue { i32, i32 } poison, i32 [[SELECT]], 0
-    // NINETEEN-NEXT: [[REG3:%.*]] = insertvalue { i32, i32 } [[REG2]], i32 %1, 1
-
-    // TWENTY-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i32 %1, i32 undef
-    // TWENTY-NEXT: [[REG2:%.*]] = insertvalue { i32, i32 } poison, i32 %0, 0
-    // TWENTY-NEXT: [[REG3:%.*]] = insertvalue { i32, i32 } [[REG2]], i32 [[SELECT]], 1
-
-    // CHECK-NEXT: ret { i32, i32 } [[REG3]]
-    match x {
-        Some(x) => Some(x),
-        None => None,
-    }
-}
-
-// CHECK-LABEL: @option_nop_traits_32
-#[no_mangle]
-pub fn option_nop_traits_32(x: Option<u32>) -> Option<u32> {
-    // CHECK: start:
-    // TWENTY-NEXT: %[[IS_SOME:.+]] = trunc nuw i32 %0 to i1
-    // TWENTY-NEXT: select i1 %[[IS_SOME]], i32 %1, i32 undef
-    // CHECK-NEXT: insertvalue { i32, i32 }
-    // CHECK-NEXT: insertvalue { i32, i32 }
-    // CHECK-NEXT: ret { i32, i32 }
-    try { x? }
-}
-
-// CHECK-LABEL: @result_nop_match_32
-#[no_mangle]
-pub fn result_nop_match_32(x: Result<i32, u32>) -> Result<i32, u32> {
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue { i32, i32 }
-    // CHECK-NEXT: insertvalue { i32, i32 }
-    // CHECK-NEXT: ret { i32, i32 }
-    match x {
-        Ok(x) => Ok(x),
-        Err(x) => Err(x),
-    }
-}
-
-// CHECK-LABEL: @result_nop_traits_32
-#[no_mangle]
-pub fn result_nop_traits_32(x: Result<i32, u32>) -> Result<i32, u32> {
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue { i32, i32 }
-    // CHECK-NEXT: insertvalue { i32, i32 }
-    // CHECK-NEXT: ret { i32, i32 }
-    try { x? }
-}
-
-// CHECK-LABEL: @control_flow_nop_match_32
-#[no_mangle]
-pub fn control_flow_nop_match_32(x: ControlFlow<i32, u32>) -> ControlFlow<i32, u32> {
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue { i32, i32 }
-    // CHECK-NEXT: insertvalue { i32, i32 }
-    // CHECK-NEXT: ret { i32, i32 }
-    match x {
-        Continue(x) => Continue(x),
-        Break(x) => Break(x),
-    }
-}
-
-// CHECK-LABEL: @control_flow_nop_traits_32
-#[no_mangle]
-pub fn control_flow_nop_traits_32(x: ControlFlow<i32, u32>) -> ControlFlow<i32, u32> {
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue { i32, i32 }
-    // CHECK-NEXT: insertvalue { i32, i32 }
-    // CHECK-NEXT: ret { i32, i32 }
-    try { x? }
-}
-
-// CHECK-LABEL: @option_nop_match_64
-#[no_mangle]
-pub fn option_nop_match_64(x: Option<u64>) -> Option<u64> {
-    // CHECK: start:
-    // CHECK-NEXT: [[TRUNC:%.*]] = trunc nuw i64 %0 to i1
-
-    // NINETEEN-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i64 %0, i64 0
-    // NINETEEN-NEXT: [[REG2:%.*]] = insertvalue { i64, i64 } poison, i64 [[SELECT]], 0
-    // NINETEEN-NEXT: [[REG3:%.*]] = insertvalue { i64, i64 } [[REG2]], i64 %1, 1
-
-    // TWENTY-NEXT: [[SELECT:%.*]] = select i1 [[TRUNC]], i64 %1, i64 undef
-    // TWENTY-NEXT: [[REG2:%.*]] = insertvalue { i64, i64 } poison, i64 %0, 0
-    // TWENTY-NEXT: [[REG3:%.*]] = insertvalue { i64, i64 } [[REG2]], i64 [[SELECT]], 1
-
-    // CHECK-NEXT: ret { i64, i64 } [[REG3]]
-    match x {
-        Some(x) => Some(x),
-        None => None,
-    }
-}
-
-// CHECK-LABEL: @option_nop_traits_64
-#[no_mangle]
-pub fn option_nop_traits_64(x: Option<u64>) -> Option<u64> {
-    // CHECK: start:
-    // TWENTY-NEXT: %[[TRUNC:[0-9]+]] = trunc nuw i64 %0 to i1
-    // TWENTY-NEXT: %[[SEL:\.[0-9]+]] = select i1 %[[TRUNC]], i64 %1, i64 undef
-    // CHECK-NEXT: insertvalue { i64, i64 }
-    // CHECK-NEXT: insertvalue { i64, i64 }
-    // CHECK-NEXT: ret { i64, i64 }
-    try { x? }
-}
-
-// CHECK-LABEL: @result_nop_match_64
-#[no_mangle]
-pub fn result_nop_match_64(x: Result<i64, u64>) -> Result<i64, u64> {
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue { i64, i64 }
-    // CHECK-NEXT: insertvalue { i64, i64 }
-    // CHECK-NEXT: ret { i64, i64 }
-    match x {
-        Ok(x) => Ok(x),
-        Err(x) => Err(x),
-    }
-}
-
-// CHECK-LABEL: @result_nop_traits_64
-#[no_mangle]
-pub fn result_nop_traits_64(x: Result<i64, u64>) -> Result<i64, u64> {
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue { i64, i64 }
-    // CHECK-NEXT: insertvalue { i64, i64 }
-    // CHECK-NEXT: ret { i64, i64 }
-    try { x? }
-}
-
-// CHECK-LABEL: @control_flow_nop_match_64
-#[no_mangle]
-pub fn control_flow_nop_match_64(x: ControlFlow<i64, u64>) -> ControlFlow<i64, u64> {
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue { i64, i64 }
-    // CHECK-NEXT: insertvalue { i64, i64 }
-    // CHECK-NEXT: ret { i64, i64 }
-    match x {
-        Continue(x) => Continue(x),
-        Break(x) => Break(x),
-    }
-}
-
-// CHECK-LABEL: @control_flow_nop_traits_64
-#[no_mangle]
-pub fn control_flow_nop_traits_64(x: ControlFlow<i64, u64>) -> ControlFlow<i64, u64> {
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue { i64, i64 }
-    // CHECK-NEXT: insertvalue { i64, i64 }
-    // CHECK-NEXT: ret { i64, i64 }
-    try { x? }
-}
-
-// CHECK-LABEL: @result_nop_match_128
-#[no_mangle]
-pub fn result_nop_match_128(x: Result<i128, u128>) -> Result<i128, u128> {
-    // CHECK: start:
-    // CHECK-NEXT: store i128
-    // CHECK-NEXT: getelementptr inbounds {{(nuw )?}}i8
-    // CHECK-NEXT: store i128
-    // CHECK-NEXT: ret void
-    match x {
-        Ok(x) => Ok(x),
-        Err(x) => Err(x),
-    }
-}
-
-// CHECK-LABEL: @result_nop_traits_128
-#[no_mangle]
-pub fn result_nop_traits_128(x: Result<i128, u128>) -> Result<i128, u128> {
-    // CHECK: start:
-    // CHECK-NEXT: getelementptr inbounds {{(nuw )?}}i8
-    // CHECK-NEXT: store i128
-    // CHECK-NEXT: store i128
-    // CHECK-NEXT: ret void
-    try { x? }
-}
-
-// CHECK-LABEL: @control_flow_nop_match_128
-#[no_mangle]
-pub fn control_flow_nop_match_128(x: ControlFlow<i128, u128>) -> ControlFlow<i128, u128> {
-    // CHECK: start:
-    // CHECK-NEXT: store i128
-    // CHECK-NEXT: getelementptr inbounds {{(nuw )?}}i8
-    // CHECK-NEXT: store i128
-    // CHECK-NEXT: ret void
-    match x {
-        Continue(x) => Continue(x),
-        Break(x) => Break(x),
-    }
-}
-
-// CHECK-LABEL: @control_flow_nop_traits_128
-#[no_mangle]
-pub fn control_flow_nop_traits_128(x: ControlFlow<i128, u128>) -> ControlFlow<i128, u128> {
-    // CHECK: start:
-    // CHECK-NEXT: getelementptr inbounds {{(nuw )?}}i8
-    // CHECK-NEXT: store i128
-    // CHECK-NEXT: store i128
-    // CHECK-NEXT: ret void
-    try { x? }
-}
-
-// CHECK-LABEL: @result_nop_match_ptr
-#[no_mangle]
-pub fn result_nop_match_ptr(x: Result<usize, Box<()>>) -> Result<usize, Box<()>> {
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue { i{{[0-9]+}}, ptr }
-    // CHECK-NEXT: insertvalue { i{{[0-9]+}}, ptr }
-    // CHECK-NEXT: ret
-    match x {
-        Ok(x) => Ok(x),
-        Err(x) => Err(x),
-    }
-}
-
-// CHECK-LABEL: @result_nop_traits_ptr
-#[no_mangle]
-pub fn result_nop_traits_ptr(x: Result<u64, NonNull<()>>) -> Result<u64, NonNull<()>> {
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue { i{{[0-9]+}}, ptr }
-    // CHECK-NEXT: insertvalue { i{{[0-9]+}}, ptr }
-    // CHECK-NEXT: ret
-    try { x? }
-}
diff --git a/tests/codegen/tune-cpu-on-functions.rs b/tests/codegen/tune-cpu-on-functions.rs
deleted file mode 100644
index f50245b797f..00000000000
--- a/tests/codegen/tune-cpu-on-functions.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-// This test makes sure that functions get annotated with the proper
-// "tune-cpu" attribute in LLVM.
-
-//@ no-prefer-dynamic
-//
-//@ compile-flags: -C no-prepopulate-passes -C panic=abort -C linker-plugin-lto -Cpasses=name-anon-globals -Z tune-cpu=generic -Copt-level=0
-
-#![crate_type = "staticlib"]
-
-// CHECK-LABEL: define {{.*}} @exported() {{.*}} #0
-#[no_mangle]
-pub extern "C" fn exported() {
-    not_exported();
-}
-
-// CHECK-LABEL: ; tune_cpu_on_functions::not_exported
-// CHECK-NEXT: ; Function Attrs:
-// CHECK-NEXT: define {{.*}}() {{.*}} #0
-fn not_exported() {}
-
-// CHECK: attributes #0 = {{.*}} "tune-cpu"="{{.*}}"
diff --git a/tests/codegen/tuple-layout-opt.rs b/tests/codegen/tuple-layout-opt.rs
deleted file mode 100644
index 5b2f65e7aa7..00000000000
--- a/tests/codegen/tuple-layout-opt.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// 32-bit systems will return 128bit values using a return area pointer.
-//@ revisions: bit32 bit64
-//@[bit32] only-32bit
-//@[bit64] only-64bit
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-
-// Test that tuples get optimized layout, in particular with a ZST in the last field (#63244)
-
-#![crate_type = "lib"]
-
-type ScalarZstLast = (u128, ());
-// bit32: define {{(dso_local )?}}void @test_ScalarZstLast({{.*}} sret([16 x i8]) {{.*}}, i128 %_1)
-// bit64: define {{(dso_local )?}}i128 @test_ScalarZstLast(i128 %_1)
-#[no_mangle]
-pub fn test_ScalarZstLast(_: ScalarZstLast) -> ScalarZstLast {
-    loop {}
-}
-
-type ScalarZstFirst = ((), u128);
-// bit32: define {{(dso_local )?}}void @test_ScalarZstFirst({{.*}} sret([16 x i8]) {{.*}}, i128 %_1)
-// bit64: define {{(dso_local )?}}i128 @test_ScalarZstFirst(i128 %_1)
-#[no_mangle]
-pub fn test_ScalarZstFirst(_: ScalarZstFirst) -> ScalarZstFirst {
-    loop {}
-}
-
-type ScalarPairZstLast = (u8, u128, ());
-// CHECK: define {{(dso_local )?}}void @test_ScalarPairZstLast(ptr sret({{[^,]*}})
-// CHECK-SAME: %_0, i128 %_1.0, i8 %_1.1)
-#[no_mangle]
-pub fn test_ScalarPairZstLast(_: ScalarPairZstLast) -> ScalarPairZstLast {
-    loop {}
-}
-
-type ScalarPairZstFirst = ((), u8, u128);
-// CHECK: define {{(dso_local )?}}void @test_ScalarPairZstFirst(ptr sret({{[^,]*}})
-// CHECK-SAME: %_0, i8 %_1.0, i128 %_1.1)
-#[no_mangle]
-pub fn test_ScalarPairZstFirst(_: ScalarPairZstFirst) -> ScalarPairZstFirst {
-    loop {}
-}
-
-type ScalarPairLotsOfZsts = ((), u8, (), u128, ());
-// CHECK: define {{(dso_local )?}}void @test_ScalarPairLotsOfZsts(ptr sret({{[^,]*}})
-// CHECK-SAME: %_0, i128 %_1.0, i8 %_1.1)
-#[no_mangle]
-pub fn test_ScalarPairLotsOfZsts(_: ScalarPairLotsOfZsts) -> ScalarPairLotsOfZsts {
-    loop {}
-}
-
-type ScalarPairLottaNesting = (((), ((), u8, (), u128, ())), ());
-// CHECK: define {{(dso_local )?}}void @test_ScalarPairLottaNesting(ptr sret({{[^,]*}})
-// CHECK-SAME: %_0, i128 %_1.0, i8 %_1.1)
-#[no_mangle]
-pub fn test_ScalarPairLottaNesting(_: ScalarPairLottaNesting) -> ScalarPairLottaNesting {
-    loop {}
-}
diff --git a/tests/codegen/ub-checks.rs b/tests/codegen/ub-checks.rs
deleted file mode 100644
index 67f5bff08d5..00000000000
--- a/tests/codegen/ub-checks.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// With -Zub-checks=yes (enabled by default by -Cdebug-assertions=yes) we will produce a runtime
-// check that the index to slice::get_unchecked is in-bounds of the slice. That is tested for by
-// tests/ui/precondition-checks/out-of-bounds-get-unchecked.rs
-//
-// This test ensures that such a runtime check is *not* emitted when debug-assertions are enabled,
-// but ub-checks are explicitly disabled.
-
-//@ revisions: DEBUG NOCHECKS
-//@ [DEBUG] compile-flags:
-//@ [NOCHECKS] compile-flags: -Zub-checks=no
-//@ compile-flags: -Copt-level=3 -Cdebug-assertions=yes
-
-#![crate_type = "lib"]
-
-use std::ops::Range;
-
-// CHECK-LABEL: @slice_get_unchecked(
-#[no_mangle]
-pub unsafe fn slice_get_unchecked(x: &[i32], i: usize) -> &i32 {
-    //    CHECK: icmp ult
-    // NOCHECKS: tail call void @llvm.assume
-    //    DEBUG: br i1
-    //    DEBUG: call core::panicking::panic_nounwind
-    //    DEBUG: unreachable
-    //    CHECK: getelementptr inbounds
-    //    CHECK: ret ptr
-    x.get_unchecked(i)
-}
diff --git a/tests/codegen/unchecked-float-casts.rs b/tests/codegen/unchecked-float-casts.rs
deleted file mode 100644
index d1869abc87b..00000000000
--- a/tests/codegen/unchecked-float-casts.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// This file tests that we don't generate any code for saturation when using the
-// unchecked intrinsics.
-
-//@ compile-flags: -C opt-level=3
-//@ ignore-wasm32 the wasm target is tested in `wasm_casts_*`
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @f32_to_u32
-#[no_mangle]
-pub fn f32_to_u32(x: f32) -> u32 {
-    // CHECK: fptoui
-    // CHECK-NOT: fcmp
-    // CHECK-NOT: icmp
-    // CHECK-NOT: select
-    unsafe { x.to_int_unchecked() }
-}
-
-// CHECK-LABEL: @f32_to_i32
-#[no_mangle]
-pub fn f32_to_i32(x: f32) -> i32 {
-    // CHECK: fptosi
-    // CHECK-NOT: fcmp
-    // CHECK-NOT: icmp
-    // CHECK-NOT: select
-    unsafe { x.to_int_unchecked() }
-}
-
-#[no_mangle]
-pub fn f64_to_u16(x: f64) -> u16 {
-    // CHECK: fptoui
-    // CHECK-NOT: fcmp
-    // CHECK-NOT: icmp
-    // CHECK-NOT: select
-    unsafe { x.to_int_unchecked() }
-}
diff --git a/tests/codegen/unchecked_shifts.rs b/tests/codegen/unchecked_shifts.rs
deleted file mode 100644
index 3f533718a2d..00000000000
--- a/tests/codegen/unchecked_shifts.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-// This runs mir-opts to inline the standard library call, but doesn't run LLVM
-// optimizations so it doesn't need to worry about them adding more flags.
-
-#![crate_type = "lib"]
-#![feature(unchecked_shifts)]
-#![feature(core_intrinsics)]
-
-// CHECK-LABEL: @unchecked_shl_unsigned_same
-#[no_mangle]
-pub unsafe fn unchecked_shl_unsigned_same(a: u32, b: u32) -> u32 {
-    // CHECK-NOT: assume
-    // CHECK-NOT: and i32
-    // CHECK: shl i32 %a, %b
-    // CHECK-NOT: and i32
-    a.unchecked_shl(b)
-}
-
-// CHECK-LABEL: @unchecked_shl_unsigned_smaller
-#[no_mangle]
-pub unsafe fn unchecked_shl_unsigned_smaller(a: u16, b: u32) -> u16 {
-    // CHECK-NOT: assume
-    // CHECK: %[[TRUNC:.+]] = trunc nuw i32 %b to i16
-    // CHECK: shl i16 %a, %[[TRUNC]]
-    a.unchecked_shl(b)
-}
-
-// CHECK-LABEL: @unchecked_shl_unsigned_bigger
-#[no_mangle]
-pub unsafe fn unchecked_shl_unsigned_bigger(a: u64, b: u32) -> u64 {
-    // CHECK-NOT: assume
-    // CHECK: %[[EXT:.+]] = zext i32 %b to i64
-    // CHECK: shl i64 %a, %[[EXT]]
-    a.unchecked_shl(b)
-}
-
-// CHECK-LABEL: @unchecked_shr_signed_same
-#[no_mangle]
-pub unsafe fn unchecked_shr_signed_same(a: i32, b: u32) -> i32 {
-    // CHECK-NOT: assume
-    // CHECK-NOT: and i32
-    // CHECK: ashr i32 %a, %b
-    // CHECK-NOT: and i32
-    a.unchecked_shr(b)
-}
-
-// CHECK-LABEL: @unchecked_shr_signed_smaller
-#[no_mangle]
-pub unsafe fn unchecked_shr_signed_smaller(a: i16, b: u32) -> i16 {
-    // CHECK-NOT: assume
-    // CHECK: %[[TRUNC:.+]] = trunc nuw i32 %b to i16
-    // CHECK: ashr i16 %a, %[[TRUNC]]
-    a.unchecked_shr(b)
-}
-
-// CHECK-LABEL: @unchecked_shr_signed_bigger
-#[no_mangle]
-pub unsafe fn unchecked_shr_signed_bigger(a: i64, b: u32) -> i64 {
-    // CHECK-NOT: assume
-    // CHECK: %[[EXT:.+]] = zext i32 %b to i64
-    // CHECK: ashr i64 %a, %[[EXT]]
-    a.unchecked_shr(b)
-}
-
-// CHECK-LABEL: @unchecked_shr_u128_i8
-#[no_mangle]
-pub unsafe fn unchecked_shr_u128_i8(a: u128, b: i8) -> u128 {
-    // CHECK-NOT: assume
-    // CHECK: %[[EXT:.+]] = zext i8 %b to i128
-    // CHECK: lshr i128 %a, %[[EXT]]
-    std::intrinsics::unchecked_shr(a, b)
-}
-
-// CHECK-LABEL: @unchecked_shl_i128_u8
-#[no_mangle]
-pub unsafe fn unchecked_shl_i128_u8(a: i128, b: u8) -> i128 {
-    // CHECK-NOT: assume
-    // CHECK: %[[EXT:.+]] = zext i8 %b to i128
-    // CHECK: shl i128 %a, %[[EXT]]
-    std::intrinsics::unchecked_shl(a, b)
-}
-
-// CHECK-LABEL: @unchecked_shl_u8_i128
-#[no_mangle]
-pub unsafe fn unchecked_shl_u8_i128(a: u8, b: i128) -> u8 {
-    // CHECK-NOT: assume
-    // CHECK: %[[TRUNC:.+]] = trunc nuw i128 %b to i8
-    // CHECK: shl i8 %a, %[[TRUNC]]
-    std::intrinsics::unchecked_shl(a, b)
-}
-
-// CHECK-LABEL: @unchecked_shr_i8_u128
-#[no_mangle]
-pub unsafe fn unchecked_shr_i8_u128(a: i8, b: u128) -> i8 {
-    // CHECK-NOT: assume
-    // CHECK: %[[TRUNC:.+]] = trunc nuw i128 %b to i8
-    // CHECK: ashr i8 %a, %[[TRUNC]]
-    std::intrinsics::unchecked_shr(a, b)
-}
diff --git a/tests/codegen/uninhabited-transparent-return-abi.rs b/tests/codegen/uninhabited-transparent-return-abi.rs
deleted file mode 100644
index face1577c3f..00000000000
--- a/tests/codegen/uninhabited-transparent-return-abi.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-// See https://github.com/rust-lang/rust/issues/135802
-
-#![crate_type = "lib"]
-
-enum Void {}
-
-// Should be ABI-compatible with T, but wasn't prior to the PR adding this test.
-#[repr(transparent)]
-struct NoReturn<T>(T, Void);
-
-// Returned by invisible reference (in most ABIs)
-#[allow(dead_code)]
-struct Large(u64, u64, u64);
-
-extern "Rust" {
-    fn opaque() -> NoReturn<Large>;
-    fn opaque_with_arg(rsi: u32) -> NoReturn<Large>;
-}
-
-// CHECK-LABEL: @test_uninhabited_ret_by_ref
-#[no_mangle]
-pub fn test_uninhabited_ret_by_ref() {
-    // CHECK: %_1 = alloca [24 x i8], align {{8|4}}
-    // CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %_1)
-    // CHECK-NEXT: call void @opaque({{.*}} sret([24 x i8]) {{.*}} %_1) #2
-    // CHECK-NEXT: unreachable
-    unsafe {
-        opaque();
-    }
-}
-
-// CHECK-LABEL: @test_uninhabited_ret_by_ref_with_arg
-#[no_mangle]
-pub fn test_uninhabited_ret_by_ref_with_arg(rsi: u32) {
-    // CHECK: %_2 = alloca [24 x i8], align {{8|4}}
-    // CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %_2)
-    // CHECK-NEXT: call void @opaque_with_arg({{.*}} sret([24 x i8]) {{.*}} %_2, i32 noundef %rsi) #2
-    // CHECK-NEXT: unreachable
-    unsafe {
-        opaque_with_arg(rsi);
-    }
-}
diff --git a/tests/codegen/uninit-consts.rs b/tests/codegen/uninit-consts.rs
deleted file mode 100644
index bde71a35c47..00000000000
--- a/tests/codegen/uninit-consts.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-// Check that we use undef (and not zero) for uninitialized bytes in constants.
-
-#![crate_type = "lib"]
-
-use std::mem::MaybeUninit;
-
-pub struct PartiallyUninit {
-    x: u32,
-    y: MaybeUninit<[u8; 10]>,
-}
-
-// CHECK: [[FULLY_UNINIT:@.*]] = private unnamed_addr constant [10 x i8] undef
-
-// CHECK: [[PARTIALLY_UNINIT:@.*]] = private unnamed_addr constant <{ [4 x i8], [12 x i8] }> <{ [4 x i8] c"{{\\EF\\BE\\AD\\DE|\\DE\\AD\\BE\\EF}}", [12 x i8] undef }>, align 4
-
-// This shouldn't contain undef, since it contains more chunks
-// than the default value of uninit_const_chunk_threshold.
-// CHECK: [[UNINIT_PADDING_HUGE:@.*]] = private unnamed_addr constant [32768 x i8] c"{{.+}}", align 4
-
-// CHECK: [[FULLY_UNINIT_HUGE:@.*]] = private unnamed_addr constant [16384 x i8] undef
-
-// CHECK-LABEL: @fully_uninit
-#[no_mangle]
-pub const fn fully_uninit() -> MaybeUninit<[u8; 10]> {
-    const M: MaybeUninit<[u8; 10]> = MaybeUninit::uninit();
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 1 %_0, ptr align 1 {{.*}}[[FULLY_UNINIT]]{{.*}}, i{{(32|64)}} 10, i1 false)
-    M
-}
-
-// CHECK-LABEL: @partially_uninit
-#[no_mangle]
-pub const fn partially_uninit() -> PartiallyUninit {
-    const X: PartiallyUninit = PartiallyUninit { x: 0xdeadbeef, y: MaybeUninit::uninit() };
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 4 %_0, ptr align 4 {{.*}}[[PARTIALLY_UNINIT]]{{.*}}, i{{(32|64)}} 16, i1 false)
-    X
-}
-
-// CHECK-LABEL: @uninit_padding_huge
-#[no_mangle]
-pub const fn uninit_padding_huge() -> [(u32, u8); 4096] {
-    const X: [(u32, u8); 4096] = [(123, 45); 4096];
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 4 %_0, ptr align 4 {{.*}}[[UNINIT_PADDING_HUGE]]{{.*}}, i{{(32|64)}} 32768, i1 false)
-    X
-}
-
-// CHECK-LABEL: @fully_uninit_huge
-#[no_mangle]
-pub const fn fully_uninit_huge() -> MaybeUninit<[u32; 4096]> {
-    const F: MaybeUninit<[u32; 4096]> = MaybeUninit::uninit();
-    // CHECK: call void @llvm.memcpy.{{.+}}(ptr align 4 %_0, ptr align 4 {{.*}}[[FULLY_UNINIT_HUGE]]{{.*}}, i{{(32|64)}} 16384, i1 false)
-    F
-}
diff --git a/tests/codegen/uninit-repeat-in-aggregate.rs b/tests/codegen/uninit-repeat-in-aggregate.rs
deleted file mode 100644
index 0fa2eb7d56c..00000000000
--- a/tests/codegen/uninit-repeat-in-aggregate.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-use std::mem::MaybeUninit;
-
-// We need to make sure len is at offset 0, otherwise codegen needs an extra instruction
-#[repr(C)]
-pub struct SmallVec<T> {
-    pub len: u64,
-    pub arr: [MaybeUninit<T>; 24],
-}
-
-// CHECK-LABEL: @uninit_arr_via_const
-#[no_mangle]
-pub fn uninit_arr_via_const() -> SmallVec<String> {
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: store i64 0,
-    // CHECK-NEXT: ret
-    SmallVec { len: 0, arr: [const { MaybeUninit::uninit() }; 24] }
-}
diff --git a/tests/codegen/union-abi.rs b/tests/codegen/union-abi.rs
deleted file mode 100644
index 28acc4de2f3..00000000000
--- a/tests/codegen/union-abi.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-//@ ignore-emscripten vectors passed directly
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-// 32-bit x86 returns `f32` differently to avoid the x87 stack.
-// 32-bit systems will return 128bit values using a return area pointer.
-//@ revisions: x86-sse x86-nosse bit32 bit64
-//@[x86-sse] only-x86
-//@[x86-sse] only-rustc_abi-x86-sse2
-//@[x86-nosse] only-x86
-//@[x86-nosse] ignore-rustc_abi-x86-sse2
-//@[bit32] ignore-x86
-//@[bit32] only-32bit
-//@[bit64] ignore-x86
-//@[bit64] only-64bit
-
-// This test that using union forward the abi of the inner type, as
-// discussed in #54668
-
-#![crate_type = "lib"]
-#![feature(repr_simd)]
-
-#[derive(Copy, Clone)]
-pub enum Unhab {}
-
-#[repr(simd)]
-#[derive(Copy, Clone)]
-pub struct i64x4([i64; 4]);
-
-#[derive(Copy, Clone)]
-pub union UnionI64x4 {
-    a: (),
-    b: i64x4,
-}
-
-// CHECK: define {{(dso_local )?}}void @test_UnionI64x4(ptr {{.*}} %_1)
-#[no_mangle]
-pub fn test_UnionI64x4(_: UnionI64x4) {
-    loop {}
-}
-
-pub union UnionI64x4_ {
-    a: i64x4,
-    b: (),
-    c: i64x4,
-    d: Unhab,
-    e: ((), ()),
-    f: UnionI64x4,
-}
-
-// CHECK: define {{(dso_local )?}}void @test_UnionI64x4_(ptr {{.*}} %_1)
-#[no_mangle]
-pub fn test_UnionI64x4_(_: UnionI64x4_) {
-    loop {}
-}
-
-pub union UnionI64x4I64 {
-    a: i64x4,
-    b: i64,
-}
-
-// CHECK: define {{(dso_local )?}}void @test_UnionI64x4I64(ptr {{.*}} %_1)
-#[no_mangle]
-pub fn test_UnionI64x4I64(_: UnionI64x4I64) {
-    loop {}
-}
-
-pub union UnionI64x4Tuple {
-    a: i64x4,
-    b: (i64, i64, i64, i64),
-}
-
-// CHECK: define {{(dso_local )?}}void @test_UnionI64x4Tuple(ptr {{.*}} %_1)
-#[no_mangle]
-pub fn test_UnionI64x4Tuple(_: UnionI64x4Tuple) {
-    loop {}
-}
-
-pub union UnionF32 {
-    a: f32,
-}
-
-// x86-sse: define {{(dso_local )?}}<4 x i8> @test_UnionF32(float %_1)
-// x86-nosse: define {{(dso_local )?}}i32 @test_UnionF32(float %_1)
-// bit32: define {{(dso_local )?}}float @test_UnionF32(float %_1)
-// bit64: define {{(dso_local )?}}float @test_UnionF32(float %_1)
-#[no_mangle]
-pub fn test_UnionF32(_: UnionF32) -> UnionF32 {
-    loop {}
-}
-
-pub union UnionF32F32 {
-    a: f32,
-    b: f32,
-}
-
-// x86-sse: define {{(dso_local )?}}<4 x i8> @test_UnionF32F32(float %_1)
-// x86-nosse: define {{(dso_local )?}}i32 @test_UnionF32F32(float %_1)
-// bit32: define {{(dso_local )?}}float @test_UnionF32F32(float %_1)
-// bit64: define {{(dso_local )?}}float @test_UnionF32F32(float %_1)
-#[no_mangle]
-pub fn test_UnionF32F32(_: UnionF32F32) -> UnionF32F32 {
-    loop {}
-}
-
-pub union UnionF32U32 {
-    a: f32,
-    b: u32,
-}
-
-// CHECK: define {{(dso_local )?}}i32 @test_UnionF32U32(i32{{( %0)?}})
-#[no_mangle]
-pub fn test_UnionF32U32(_: UnionF32U32) -> UnionF32U32 {
-    loop {}
-}
-
-pub union UnionU128 {
-    a: u128,
-}
-// x86-sse: define {{(dso_local )?}}void @test_UnionU128({{.*}}sret([16 x i8]){{.*}}, i128 %_1)
-// x86-nosse: define {{(dso_local )?}}void @test_UnionU128({{.*}}sret([16 x i8]){{.*}}, i128 %_1)
-// bit32: define {{(dso_local )?}}void @test_UnionU128({{.*}}sret([16 x i8]){{.*}}, i128 %_1)
-// bit64: define {{(dso_local )?}}i128 @test_UnionU128(i128 %_1)
-#[no_mangle]
-pub fn test_UnionU128(_: UnionU128) -> UnionU128 {
-    loop {}
-}
-
-#[repr(C)]
-pub union CUnionU128 {
-    a: u128,
-}
-// CHECK: define {{(dso_local )?}}void @test_CUnionU128(ptr {{.*}} %_1)
-#[no_mangle]
-pub fn test_CUnionU128(_: CUnionU128) {
-    loop {}
-}
-
-pub union UnionBool {
-    b: bool,
-}
-// CHECK: define {{(dso_local )?}}noundef zeroext i1 @test_UnionBool(i8{{.*}} %b)
-#[no_mangle]
-pub fn test_UnionBool(b: UnionBool) -> bool {
-    unsafe { b.b }
-}
-// CHECK: %_0 = trunc{{( nuw)?}} i8 %b to i1
diff --git a/tests/codegen/union-aggregate.rs b/tests/codegen/union-aggregate.rs
deleted file mode 100644
index aac66c5dcdd..00000000000
--- a/tests/codegen/union-aggregate.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-//@ compile-flags: -Copt-level=0 -Cno-prepopulate-passes
-//@ min-llvm-version: 19
-//@ only-64bit
-
-#![crate_type = "lib"]
-#![feature(transparent_unions)]
-#![feature(repr_simd)]
-
-#[repr(transparent)]
-union MU<T: Copy> {
-    uninit: (),
-    value: T,
-}
-
-use std::cmp::Ordering;
-use std::num::NonZero;
-use std::ptr::NonNull;
-
-#[no_mangle]
-fn make_mu_bool(x: bool) -> MU<bool> {
-    // CHECK-LABEL: i8 @make_mu_bool(i1 zeroext %x)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %[[WIDER:.+]] = zext i1 %x to i8
-    // CHECK-NEXT: ret i8 %[[WIDER]]
-    MU { value: x }
-}
-
-#[no_mangle]
-fn make_mu_bool_uninit() -> MU<bool> {
-    // CHECK-LABEL: i8 @make_mu_bool_uninit()
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret i8 undef
-    MU { uninit: () }
-}
-
-#[no_mangle]
-fn make_mu_ref(x: &u16) -> MU<&u16> {
-    // CHECK-LABEL: ptr @make_mu_ref(ptr align 2 %x)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret ptr %x
-    MU { value: x }
-}
-
-#[no_mangle]
-fn make_mu_ref_uninit<'a>() -> MU<&'a u16> {
-    // CHECK-LABEL: ptr @make_mu_ref_uninit()
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret ptr undef
-    MU { uninit: () }
-}
-
-#[no_mangle]
-fn make_mu_str(x: &str) -> MU<&str> {
-    // CHECK-LABEL: { ptr, i64 } @make_mu_str(ptr align 1 %x.0, i64 %x.1)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %0 = insertvalue { ptr, i64 } poison, ptr %x.0, 0
-    // CHECK-NEXT: %1 = insertvalue { ptr, i64 } %0, i64 %x.1, 1
-    // CHECK-NEXT: ret { ptr, i64 } %1
-    MU { value: x }
-}
-
-#[no_mangle]
-fn make_mu_str_uninit<'a>() -> MU<&'a str> {
-    // CHECK-LABEL: { ptr, i64 } @make_mu_str_uninit()
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret { ptr, i64 } undef
-    MU { uninit: () }
-}
-
-#[no_mangle]
-fn make_mu_pair(x: (u8, u32)) -> MU<(u8, u32)> {
-    // CHECK-LABEL: { i8, i32 } @make_mu_pair(i8 %x.0, i32 %x.1)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %0 = insertvalue { i8, i32 } poison, i8 %x.0, 0
-    // CHECK-NEXT: %1 = insertvalue { i8, i32 } %0, i32 %x.1, 1
-    // CHECK-NEXT: ret { i8, i32 } %1
-    MU { value: x }
-}
-
-#[no_mangle]
-fn make_mu_pair_uninit() -> MU<(u8, u32)> {
-    // CHECK-LABEL: { i8, i32 } @make_mu_pair_uninit()
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret { i8, i32 } undef
-    MU { uninit: () }
-}
-
-#[repr(simd)]
-#[derive(Copy, Clone)]
-struct I32X32([i32; 32]);
-
-#[no_mangle]
-fn make_mu_simd(x: I32X32) -> MU<I32X32> {
-    // CHECK-LABEL: void @make_mu_simd(ptr{{.+}}%_0, ptr{{.+}}%x)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: %[[TEMP:.+]] = load <32 x i32>, ptr %x,
-    // CHECK-NEXT: store <32 x i32> %[[TEMP]], ptr %_0,
-    // CHECK-NEXT: ret void
-    MU { value: x }
-}
-
-#[no_mangle]
-fn make_mu_simd_uninit() -> MU<I32X32> {
-    // CHECK-LABEL: void @make_mu_simd_uninit(ptr{{.+}}%_0)
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ret void
-    MU { uninit: () }
-}
diff --git a/tests/codegen/unwind-abis/aapcs-unwind-abi.rs b/tests/codegen/unwind-abis/aapcs-unwind-abi.rs
deleted file mode 100644
index ecace722e0d..00000000000
--- a/tests/codegen/unwind-abis/aapcs-unwind-abi.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ needs-llvm-components: arm
-//@ compile-flags: --target=armv7-unknown-linux-gnueabihf --crate-type=rlib -Cno-prepopulate-passes
-#![no_core]
-#![feature(no_core, lang_items)]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-// Test that `nounwind` attributes are correctly applied to exported `aapcs` and
-// `aapcs-unwind` extern functions. `aapcs-unwind` functions MUST NOT have this attribute. We
-// disable optimizations above to prevent LLVM from inferring the attribute.
-
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
-#[no_mangle]
-pub extern "aapcs" fn rust_item_that_cannot_unwind() {}
-
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
-#[no_mangle]
-pub extern "aapcs-unwind" fn rust_item_that_can_unwind() {}
-
-// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
-// sure that the first item is correctly marked with the `nounwind` attribute:
-//
-// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
-//
-// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
-//
-// CHECK: attributes #1 = {
-// CHECK-NOT: nounwind
-// CHECK: }
diff --git a/tests/codegen/unwind-abis/c-unwind-abi-panic-abort.rs b/tests/codegen/unwind-abis/c-unwind-abi-panic-abort.rs
deleted file mode 100644
index 8d2745ba2f7..00000000000
--- a/tests/codegen/unwind-abis/c-unwind-abi-panic-abort.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ compile-flags: -C panic=abort
-
-// Test that `nounwind` attributes are also applied to extern `C-unwind` Rust functions
-// when the code is compiled with `panic=abort`.
-
-#![crate_type = "lib"]
-
-// CHECK: @rust_item_that_can_unwind() unnamed_addr [[ATTR0:#[0-9]+]]
-#[no_mangle]
-pub unsafe extern "C-unwind" fn rust_item_that_can_unwind() {
-    // Handle both legacy and v0 symbol mangling.
-    // CHECK: call void @{{.*core9panicking19panic_cannot_unwind}}
-    may_unwind();
-}
-
-extern "C-unwind" {
-    // CHECK: @may_unwind() unnamed_addr [[ATTR1:#[0-9]+]]
-    fn may_unwind();
-}
-
-// Now, make sure that the LLVM attributes for this functions are correct.  First, make
-// sure that the first item is correctly marked with the `nounwind` attribute:
-//
-// CHECK: attributes [[ATTR0]] = { {{.*}}nounwind{{.*}} }
-//
-// Now, check that foreign item is correctly marked without the `nounwind` attribute.
-// CHECK-NOT: attributes [[ATTR1]] = { {{.*}}nounwind{{.*}} }
diff --git a/tests/codegen/unwind-abis/c-unwind-abi.rs b/tests/codegen/unwind-abis/c-unwind-abi.rs
deleted file mode 100644
index 46c08b5fc4f..00000000000
--- a/tests/codegen/unwind-abis/c-unwind-abi.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ compile-flags: -C opt-level=0
-//@ needs-unwind
-
-// Test that `nounwind` attributes are correctly applied to exported `C` and `C-unwind` extern
-// functions. `C-unwind` functions MUST NOT have this attribute. We disable optimizations above
-// to prevent LLVM from inferring the attribute.
-
-#![crate_type = "lib"]
-
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
-#[no_mangle]
-pub extern "C" fn rust_item_that_cannot_unwind() {}
-
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
-#[no_mangle]
-pub extern "C-unwind" fn rust_item_that_can_unwind() {}
-
-// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
-// sure that the first item is correctly marked with the `nounwind` attribute:
-//
-// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
-//
-// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
-//
-// CHECK: attributes #1 = {
-// CHECK-NOT: nounwind
-// CHECK: }
diff --git a/tests/codegen/unwind-abis/cdecl-unwind-abi.rs b/tests/codegen/unwind-abis/cdecl-unwind-abi.rs
deleted file mode 100644
index 8e643d6ce49..00000000000
--- a/tests/codegen/unwind-abis/cdecl-unwind-abi.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ compile-flags: -C opt-level=0
-//@ needs-unwind
-
-// Test that `nounwind` attributes are correctly applied to exported `cdecl` and
-// `cdecl-unwind` extern functions. `cdecl-unwind` functions MUST NOT have this attribute. We
-// disable optimizations above to prevent LLVM from inferring the attribute.
-
-#![crate_type = "lib"]
-
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
-#[no_mangle]
-pub extern "cdecl" fn rust_item_that_cannot_unwind() {}
-
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
-#[no_mangle]
-pub extern "cdecl-unwind" fn rust_item_that_can_unwind() {}
-
-// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
-// sure that the first item is correctly marked with the `nounwind` attribute:
-//
-// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
-//
-// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
-//
-// CHECK: attributes #1 = {
-// CHECK-NOT: nounwind
-// CHECK: }
diff --git a/tests/codegen/unwind-abis/fastcall-unwind-abi.rs b/tests/codegen/unwind-abis/fastcall-unwind-abi.rs
deleted file mode 100644
index 7df46813ed1..00000000000
--- a/tests/codegen/unwind-abis/fastcall-unwind-abi.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ needs-llvm-components: x86
-//@ compile-flags: --target=i686-pc-windows-msvc --crate-type=rlib -Cno-prepopulate-passes
-#![no_core]
-#![feature(no_core, lang_items)]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-// Test that `nounwind` attributes are correctly applied to exported `fastcall` and
-// `fastcall-unwind` extern functions. `fastcall-unwind` functions MUST NOT have this attribute. We
-// disable optimizations above to prevent LLVM from inferring the attribute.
-
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
-#[no_mangle]
-pub extern "fastcall" fn rust_item_that_cannot_unwind() {}
-
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
-#[no_mangle]
-pub extern "fastcall-unwind" fn rust_item_that_can_unwind() {}
-
-// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
-// sure that the first item is correctly marked with the `nounwind` attribute:
-//
-// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
-//
-// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
-//
-// CHECK: attributes #1 = {
-// CHECK-NOT: nounwind
-// CHECK: }
diff --git a/tests/codegen/unwind-abis/nounwind-on-stable-panic-abort.rs b/tests/codegen/unwind-abis/nounwind-on-stable-panic-abort.rs
deleted file mode 100644
index d27cbd60437..00000000000
--- a/tests/codegen/unwind-abis/nounwind-on-stable-panic-abort.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -C opt-level=0 -Cpanic=abort
-
-#![crate_type = "lib"]
-
-// We disable optimizations to prevent LLVM from inferring the attribute.
-
-// CHECK: Function Attrs:{{.*}}nounwind
-// CHECK-NEXT: @foo
-#[no_mangle]
-pub extern "C" fn foo() {}
-
-// CHECK: Function Attrs:{{.*}}nounwind
-// CHECK-NEXT: @bar
-#[no_mangle]
-pub fn bar() {}
diff --git a/tests/codegen/unwind-abis/nounwind.rs b/tests/codegen/unwind-abis/nounwind.rs
deleted file mode 100644
index e40ed48ca73..00000000000
--- a/tests/codegen/unwind-abis/nounwind.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ compile-flags: -C opt-level=0 -Cpanic=abort
-//@ needs-unwind
-
-#![crate_type = "lib"]
-
-// We disable optimizations to prevent LLVM from inferring the attribute.
-
-// CHECK: Function Attrs:{{.*}}nounwind
-// CHECK-NEXT: @foo
-#[no_mangle]
-pub extern "C" fn foo() {}
-
-// CHECK: Function Attrs:{{.*}}nounwind
-// CHECK-NEXT: @bar
-#[no_mangle]
-pub fn bar() {}
diff --git a/tests/codegen/unwind-abis/stdcall-unwind-abi.rs b/tests/codegen/unwind-abis/stdcall-unwind-abi.rs
deleted file mode 100644
index cc06ee12549..00000000000
--- a/tests/codegen/unwind-abis/stdcall-unwind-abi.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ needs-llvm-components: x86
-//@ compile-flags: --target=i686-pc-windows-msvc --crate-type=rlib -Cno-prepopulate-passes
-#![no_core]
-#![feature(no_core, lang_items)]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-// Test that `nounwind` attributes are correctly applied to exported `stdcall` and `stdcall-unwind`
-// extern functions. `stdcall-unwind` functions MUST NOT have this attribute. We disable
-// optimizations above to prevent LLVM from inferring the attribute.
-
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
-#[no_mangle]
-pub extern "stdcall" fn rust_item_that_cannot_unwind() {}
-
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
-#[no_mangle]
-pub extern "stdcall-unwind" fn rust_item_that_can_unwind() {}
-
-// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
-// sure that the first item is correctly marked with the `nounwind` attribute:
-//
-// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
-//
-// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
-//
-// CHECK: attributes #1 = {
-// CHECK-NOT: nounwind
-// CHECK: }
diff --git a/tests/codegen/unwind-abis/system-unwind-abi.rs b/tests/codegen/unwind-abis/system-unwind-abi.rs
deleted file mode 100644
index 5f910248346..00000000000
--- a/tests/codegen/unwind-abis/system-unwind-abi.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//@ compile-flags: -C opt-level=0
-//@ needs-unwind
-
-// Test that `nounwind` attributes are correctly applied to exported `system` and `system-unwind`
-// extern functions. `system-unwind` functions MUST NOT have this attribute. We disable
-// optimizations above to prevent LLVM from inferring the attribute.
-
-#![crate_type = "lib"]
-
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
-#[no_mangle]
-pub extern "system" fn rust_item_that_cannot_unwind() {}
-
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
-#[no_mangle]
-pub extern "system-unwind" fn rust_item_that_can_unwind() {}
-
-// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
-// sure that the first item is correctly marked with the `nounwind` attribute:
-//
-// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
-//
-// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
-//
-// CHECK: attributes #1 = {
-// CHECK-NOT: nounwind
-// CHECK: }
diff --git a/tests/codegen/unwind-abis/sysv64-unwind-abi.rs b/tests/codegen/unwind-abis/sysv64-unwind-abi.rs
deleted file mode 100644
index 69bfaf80b4b..00000000000
--- a/tests/codegen/unwind-abis/sysv64-unwind-abi.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ needs-llvm-components: x86
-//@ compile-flags: --target=x86_64-unknown-linux-gnu --crate-type=rlib -Cno-prepopulate-passes
-#![no_core]
-#![feature(no_core, lang_items)]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-// Test that `nounwind` attributes are correctly applied to exported `sysv64` and
-// `sysv64-unwind` extern functions. `sysv64-unwind` functions MUST NOT have this attribute. We
-// disable optimizations above to prevent LLVM from inferring the attribute.
-
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
-#[no_mangle]
-pub extern "sysv64" fn rust_item_that_cannot_unwind() {}
-
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
-#[no_mangle]
-pub extern "sysv64-unwind" fn rust_item_that_can_unwind() {}
-
-// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
-// sure that the first item is correctly marked with the `nounwind` attribute:
-//
-// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
-//
-// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
-//
-// CHECK: attributes #1 = {
-// CHECK-NOT: nounwind
-// CHECK: }
diff --git a/tests/codegen/unwind-abis/thiscall-unwind-abi.rs b/tests/codegen/unwind-abis/thiscall-unwind-abi.rs
deleted file mode 100644
index 05f6b8b70e1..00000000000
--- a/tests/codegen/unwind-abis/thiscall-unwind-abi.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ needs-llvm-components: x86
-//@ compile-flags: --target=i686-pc-windows-msvc --crate-type=rlib -Cno-prepopulate-passes
-#![no_core]
-#![feature(no_core, lang_items)]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-// Test that `nounwind` attributes are correctly applied to exported `thiscall` and
-// `thiscall-unwind` extern functions. `thiscall-unwind` functions MUST NOT have this attribute. We
-// disable optimizations above to prevent LLVM from inferring the attribute.
-
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
-#[no_mangle]
-pub extern "thiscall" fn rust_item_that_cannot_unwind() {}
-
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
-#[no_mangle]
-pub extern "thiscall-unwind" fn rust_item_that_can_unwind() {}
-
-// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
-// sure that the first item is correctly marked with the `nounwind` attribute:
-//
-// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
-//
-// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
-//
-// CHECK: attributes #1 = {
-// CHECK-NOT: nounwind
-// CHECK: }
diff --git a/tests/codegen/unwind-abis/vectorcall-unwind-abi.rs b/tests/codegen/unwind-abis/vectorcall-unwind-abi.rs
deleted file mode 100644
index d001a16b32a..00000000000
--- a/tests/codegen/unwind-abis/vectorcall-unwind-abi.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ needs-llvm-components: x86
-//@ compile-flags: --target=i686-pc-windows-msvc --crate-type=rlib -Cno-prepopulate-passes
-#![no_core]
-#![feature(no_core, lang_items, abi_vectorcall)]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-// Test that `nounwind` attributes are correctly applied to exported `vectorcall` and
-// `vectorcall-unwind` extern functions. `vectorcall-unwind` functions MUST NOT have this attribute.
-// We disable optimizations above to prevent LLVM from inferring the attribute.
-
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
-#[no_mangle]
-pub extern "vectorcall" fn rust_item_that_cannot_unwind() {}
-
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
-#[no_mangle]
-pub extern "vectorcall-unwind" fn rust_item_that_can_unwind() {}
-
-// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
-// sure that the first item is correctly marked with the `nounwind` attribute:
-//
-// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
-//
-// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
-//
-// CHECK: attributes #1 = {
-// CHECK-NOT: nounwind
-// CHECK: }
diff --git a/tests/codegen/unwind-abis/win64-unwind-abi.rs b/tests/codegen/unwind-abis/win64-unwind-abi.rs
deleted file mode 100644
index 257f00b54e4..00000000000
--- a/tests/codegen/unwind-abis/win64-unwind-abi.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//@ needs-llvm-components: x86
-//@ compile-flags: --target=x86_64-unknown-linux-gnu --crate-type=rlib -Cno-prepopulate-passes
-#![no_core]
-#![feature(no_core, lang_items)]
-
-#[lang = "pointee_sized"]
-pub trait PointeeSized {}
-
-#[lang = "meta_sized"]
-pub trait MetaSized: PointeeSized {}
-
-#[lang = "sized"]
-pub trait Sized: MetaSized {}
-
-// Test that `nounwind` attributes are correctly applied to exported `win64` and
-// `win64-unwind` extern functions. `win64-unwind` functions MUST NOT have this attribute. We
-// disable optimizations above to prevent LLVM from inferring the attribute.
-
-// CHECK: @rust_item_that_cannot_unwind() unnamed_addr #0 {
-#[no_mangle]
-pub extern "win64" fn rust_item_that_cannot_unwind() {}
-
-// CHECK: @rust_item_that_can_unwind() unnamed_addr #1 {
-#[no_mangle]
-pub extern "win64-unwind" fn rust_item_that_can_unwind() {}
-
-// Now, make some assertions that the LLVM attributes for these functions are correct.  First, make
-// sure that the first item is correctly marked with the `nounwind` attribute:
-//
-// CHECK: attributes #0 = { {{.*}}nounwind{{.*}} }
-//
-// Next, let's assert that the second item, which CAN unwind, does not have this attribute.
-//
-// CHECK: attributes #1 = {
-// CHECK-NOT: nounwind
-// CHECK: }
diff --git a/tests/codegen/unwind-and-panic-abort.rs b/tests/codegen/unwind-and-panic-abort.rs
deleted file mode 100644
index 8efa140058a..00000000000
--- a/tests/codegen/unwind-and-panic-abort.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ compile-flags: -C panic=abort
-
-#![crate_type = "lib"]
-
-extern "C-unwind" {
-    fn bar();
-}
-
-// CHECK: Function Attrs:{{.*}}nounwind
-// CHECK-NEXT: define{{.*}}void @foo
-// Handle both legacy and v0 symbol mangling.
-// CHECK: call void @{{.*core9panicking19panic_cannot_unwind}}
-#[no_mangle]
-pub unsafe extern "C" fn foo() {
-    bar();
-}
diff --git a/tests/codegen/unwind-extern-exports.rs b/tests/codegen/unwind-extern-exports.rs
deleted file mode 100644
index e692fd1a547..00000000000
--- a/tests/codegen/unwind-extern-exports.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -C opt-level=0
-//@ needs-unwind
-
-#![crate_type = "lib"]
-
-// Make sure these all do *not* get the attribute.
-// We disable optimizations to prevent LLVM from inferring the attribute.
-// CHECK-NOT: nounwind
-
-// "C" ABI
-pub extern "C-unwind" fn foo_unwind() {}
-
-// "Rust"
-// (`extern "Rust"` could be removed as all `fn` get it implicitly; we leave it in for clarity.)
-pub fn bar() {}
diff --git a/tests/codegen/unwind-extern-imports.rs b/tests/codegen/unwind-extern-imports.rs
deleted file mode 100644
index dfae8aae64a..00000000000
--- a/tests/codegen/unwind-extern-imports.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-//@ needs-unwind
-
-#![crate_type = "lib"]
-
-extern "C" {
-    // CHECK: Function Attrs:{{.*}}nounwind
-    // CHECK-NEXT: declare{{.*}}void @extern_fn
-    fn extern_fn();
-}
-
-extern "C-unwind" {
-    // CHECK-NOT: nounwind
-    // CHECK: declare{{.*}}void @c_unwind_extern_fn
-    fn c_unwind_extern_fn();
-}
-
-pub unsafe fn force_declare() {
-    extern_fn();
-    c_unwind_extern_fn();
-}
diff --git a/tests/codegen/unwind-landingpad-cold.rs b/tests/codegen/unwind-landingpad-cold.rs
deleted file mode 100644
index fb095e04650..00000000000
--- a/tests/codegen/unwind-landingpad-cold.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -Cno-prepopulate-passes
-//@ needs-unwind
-#![crate_type = "lib"]
-
-// This test checks that drop calls in unwind landing pads
-// get the `cold` attribute.
-
-// CHECK-LABEL: @check_cold
-// CHECK: {{(call|invoke) void .+}}drop_in_place{{.+}} [[ATTRIBUTES:#[0-9]+]]
-// CHECK: attributes [[ATTRIBUTES]] = { cold }
-#[no_mangle]
-pub fn check_cold(f: fn(), x: Box<u32>) {
-    // this may unwind
-    f();
-}
diff --git a/tests/codegen/unwind-landingpad-inline.rs b/tests/codegen/unwind-landingpad-inline.rs
deleted file mode 100644
index 1cf606279e6..00000000000
--- a/tests/codegen/unwind-landingpad-inline.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-// This test checks that we can inline drop_in_place in
-// unwind landing pads.
-
-// Without inlining, the box pointers escape via the call to drop_in_place,
-// and LLVM will not optimize out the pointer comparison.
-// With inlining, everything should be optimized out.
-// See https://github.com/rust-lang/rust/issues/46515
-// CHECK-LABEL: @check_no_escape_in_landingpad
-// CHECK: start:
-// CHECK-NEXT: ; call __rustc::__rust_no_alloc_shim_is_unstable_v2
-// CHECK-NEXT: tail call void @[[NO_ALLOC_SHIM:_R.+__rust_no_alloc_shim_is_unstable_v2]]()
-// CHECK-NEXT: ; call __rustc::__rust_no_alloc_shim_is_unstable_v2
-// CHECK-NEXT: tail call void @[[NO_ALLOC_SHIM]]()
-// CHECK-NEXT: ret void
-#[no_mangle]
-pub fn check_no_escape_in_landingpad(f: fn()) {
-    let x = &*Box::new(0);
-    let y = &*Box::new(0);
-
-    if x as *const _ == y as *const _ {
-        f();
-    }
-}
-
-// Without inlining, the compiler can't tell that
-// dropping an empty string (in a landing pad) does nothing.
-// With inlining, the landing pad should be optimized out.
-// See https://github.com/rust-lang/rust/issues/87055
-// CHECK-LABEL: @check_eliminate_noop_drop
-// CHECK: call void %g()
-// CHECK-NEXT: ret void
-#[no_mangle]
-pub fn check_eliminate_noop_drop(g: fn()) {
-    let _var = String::new();
-    g();
-}
diff --git a/tests/codegen/used_with_arg.rs b/tests/codegen/used_with_arg.rs
deleted file mode 100644
index 4515cb2aed0..00000000000
--- a/tests/codegen/used_with_arg.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![crate_type = "lib"]
-#![feature(used_with_arg)]
-
-// CHECK: @llvm.used = appending global {{.*}}USED_LINKER
-#[used(linker)]
-static mut USED_LINKER: [usize; 1] = [0];
-
-// CHECK-NEXT: @llvm.compiler.used = appending global {{.*}}USED_COMPILER
-#[used(compiler)]
-static mut USED_COMPILER: [usize; 1] = [0];
diff --git a/tests/codegen/var-names.rs b/tests/codegen/var-names.rs
deleted file mode 100644
index 40720e19761..00000000000
--- a/tests/codegen/var-names.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: define{{.*}}i32 @test(i32{{.*}} %a, i32{{.*}} %b)
-#[no_mangle]
-pub fn test(a: u32, b: u32) -> u32 {
-    let c = a + b;
-    // CHECK: %c = add i32 %a, %b
-    let d = c;
-    let e = d * a;
-    // CHECK-NEXT: %e = mul i32 %c, %a
-    e
-    // CHECK-NEXT: ret i32 %e
-}
diff --git a/tests/codegen/vec-as-ptr.rs b/tests/codegen/vec-as-ptr.rs
deleted file mode 100644
index 5c997802640..00000000000
--- a/tests/codegen/vec-as-ptr.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
-
-#![crate_type = "lib"]
-
-// Test that even though we return a *const u8 not a &[u8] or a NonNull<u8>, LLVM knows that this
-// pointer is nonnull.
-// CHECK: nonnull ptr @vec_as_ptr
-#[no_mangle]
-pub fn vec_as_ptr(v: &Vec<u8>) -> *const u8 {
-    v.as_ptr()
-}
-
-// Test that even though we return a *const u8 not a &[u8] or a NonNull<u8>, LLVM knows that this
-// pointer is nonnull.
-// CHECK: nonnull ptr @vec_as_mut_ptr
-#[no_mangle]
-pub fn vec_as_mut_ptr(v: &mut Vec<u8>) -> *mut u8 {
-    v.as_mut_ptr()
-}
diff --git a/tests/codegen/vec-calloc.rs b/tests/codegen/vec-calloc.rs
deleted file mode 100644
index d1c320ead01..00000000000
--- a/tests/codegen/vec-calloc.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-//@ only-x86_64
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @vec_zero_bytes
-#[no_mangle]
-pub fn vec_zero_bytes(n: usize) -> Vec<u8> {
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-    // CHECK-NOT: call {{.*}}llvm.memset
-
-    // CHECK: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-    // CHECK-NOT: call {{.*}}llvm.memset
-
-    // CHECK: ret void
-    vec![0; n]
-}
-
-// CHECK-LABEL: @vec_one_bytes
-#[no_mangle]
-pub fn vec_one_bytes(n: usize) -> Vec<u8> {
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK: call {{.*}}__rust_alloc(
-    // CHECK: call {{.*}}llvm.memset
-
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK: ret void
-    vec![1; n]
-}
-
-// CHECK-LABEL: @vec_zero_scalar
-#[no_mangle]
-pub fn vec_zero_scalar(n: usize) -> Vec<i32> {
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: ret void
-    vec![0; n]
-}
-
-// CHECK-LABEL: @vec_one_scalar
-#[no_mangle]
-pub fn vec_one_scalar(n: usize) -> Vec<i32> {
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK: call {{.*}}__rust_alloc(
-
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK: ret void
-    vec![1; n]
-}
-
-// CHECK-LABEL: @vec_zero_rgb48
-#[no_mangle]
-pub fn vec_zero_rgb48(n: usize) -> Vec<[u16; 3]> {
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: ret void
-    vec![[0, 0, 0]; n]
-}
-
-// CHECK-LABEL: @vec_zero_array_16
-#[no_mangle]
-pub fn vec_zero_array_16(n: usize) -> Vec<[i64; 16]> {
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: ret void
-    vec![[0_i64; 16]; n]
-}
-
-// CHECK-LABEL: @vec_zero_tuple
-#[no_mangle]
-pub fn vec_zero_tuple(n: usize) -> Vec<(i16, u8, char)> {
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: ret void
-    vec![(0, 0, '\0'); n]
-}
-
-// CHECK-LABEL: @vec_non_zero_tuple
-#[no_mangle]
-pub fn vec_non_zero_tuple(n: usize) -> Vec<(i16, u8, char)> {
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK: call {{.*}}__rust_alloc(
-
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK: ret void
-    vec![(0, 0, 'A'); n]
-}
-
-// CHECK-LABEL: @vec_option_bool
-#[no_mangle]
-pub fn vec_option_bool(n: usize) -> Vec<Option<bool>> {
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: ret void
-    vec![Some(false); n]
-}
-
-// CHECK-LABEL: @vec_option_i32
-#[no_mangle]
-pub fn vec_option_i32(n: usize) -> Vec<Option<i32>> {
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: call {{.*}}__rust_alloc_zeroed(
-
-    // CHECK-NOT: call {{.*}}alloc::vec::from_elem
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-
-    // CHECK: ret void
-    vec![None; n]
-}
-
-// Ensure that __rust_alloc_zeroed gets the right attributes for LLVM to optimize it away.
-// CHECK: declare noalias noundef ptr @{{.*}}__rust_alloc_zeroed(i64 noundef, i64 allocalign noundef) unnamed_addr [[RUST_ALLOC_ZEROED_ATTRS:#[0-9]+]]
-
-// CHECK-DAG: attributes [[RUST_ALLOC_ZEROED_ATTRS]] = { {{.*}} allockind("alloc,zeroed,aligned") allocsize(0) uwtable "alloc-family"="__rust_alloc" {{.*}} }
diff --git a/tests/codegen/vec-in-place.rs b/tests/codegen/vec-in-place.rs
deleted file mode 100644
index a5ef8653b99..00000000000
--- a/tests/codegen/vec-in-place.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-//@ ignore-std-debug-assertions (FIXME: checks for call detect scoped noalias metadata)
-//@ compile-flags: -Copt-level=3 -Z merge-functions=disabled
-#![crate_type = "lib"]
-
-// Ensure that trivial casts of vec elements are O(1)
-
-pub struct Wrapper<T>(T);
-
-// previously repr(C) caused the optimization to fail
-#[repr(C)]
-pub struct Foo {
-    a: u64,
-    b: u64,
-    c: u64,
-    d: u64,
-}
-
-// implementing Copy exercises the TrustedRandomAccess specialization inside the in-place
-// specialization
-#[derive(Copy, Clone)]
-pub struct Bar {
-    a: u64,
-    b: u64,
-    c: u64,
-    d: u64,
-}
-
-// this exercises the try-fold codepath
-pub struct Baz {
-    a: u64,
-    b: u64,
-    c: u64,
-    d: u64,
-}
-
-// CHECK-LABEL: @vec_iterator_cast_primitive
-#[no_mangle]
-pub fn vec_iterator_cast_primitive(vec: Vec<i8>) -> Vec<u8> {
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-    vec.into_iter().map(|e| e as u8).collect()
-}
-
-// CHECK-LABEL: @vec_iterator_cast_wrapper
-#[no_mangle]
-pub fn vec_iterator_cast_wrapper(vec: Vec<u8>) -> Vec<Wrapper<u8>> {
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-    vec.into_iter().map(|e| Wrapper(e)).collect()
-}
-
-// CHECK-LABEL: @vec_iterator_cast_signed
-#[no_mangle]
-pub fn vec_iterator_cast_signed(vec: Vec<i32>) -> Vec<u32> {
-    // CHECK-NOT: and i{{[0-9]+}} %{{.*}}, {{[0-9]+}}
-    vec.into_iter().map(|e| u32::from_ne_bytes(e.to_ne_bytes())).collect()
-}
-
-// CHECK-LABEL: @vec_iterator_cast_signed_nested
-#[no_mangle]
-pub fn vec_iterator_cast_signed_nested(vec: Vec<Vec<i32>>) -> Vec<Vec<u32>> {
-    // CHECK-NOT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
-    // CHECK-NOT: %{{.*}} = udiv
-    vec.into_iter()
-        .map(|e| e.into_iter().map(|e| u32::from_ne_bytes(e.to_ne_bytes())).collect())
-        .collect()
-}
-
-// CHECK-LABEL: @vec_iterator_cast_unwrap
-#[no_mangle]
-pub fn vec_iterator_cast_unwrap(vec: Vec<Wrapper<u8>>) -> Vec<u8> {
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-    vec.into_iter().map(|e| e.0).collect()
-}
-
-// CHECK-LABEL: @vec_iterator_cast_aggregate
-#[no_mangle]
-pub fn vec_iterator_cast_aggregate(vec: Vec<[u64; 4]>) -> Vec<Foo> {
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-    vec.into_iter().map(|e| unsafe { std::mem::transmute(e) }).collect()
-}
-
-// CHECK-LABEL: @vec_iterator_cast_deaggregate_tra
-#[no_mangle]
-pub fn vec_iterator_cast_deaggregate_tra(vec: Vec<Bar>) -> Vec<[u64; 4]> {
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-
-    // Safety: For the purpose of this test we assume that Bar layout matches [u64; 4].
-    // This currently is not guaranteed for repr(Rust) types, but it happens to work here and
-    // the UCG may add additional guarantees for homogenous types in the future that would make this
-    // correct.
-    vec.into_iter().map(|e| unsafe { std::mem::transmute(e) }).collect()
-}
-
-// CHECK-LABEL: @vec_iterator_cast_deaggregate_fold
-#[no_mangle]
-pub fn vec_iterator_cast_deaggregate_fold(vec: Vec<Baz>) -> Vec<[u64; 4]> {
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-    // CHECK: call{{.+}}void @llvm.assume(i1 %{{.+}})
-    // CHECK-NOT: loop
-    // CHECK-NOT: call
-
-    // Safety: For the purpose of this test we assume that Bar layout matches [u64; 4].
-    // This currently is not guaranteed for repr(Rust) types, but it happens to work here and
-    // the UCG may add additional guarantees for homogenous types in the future that would make this
-    // correct.
-    vec.into_iter().map(|e| unsafe { std::mem::transmute(e) }).collect()
-}
-
-// CHECK-LABEL: @vec_iterator_cast_unwrap_drop
-#[no_mangle]
-pub fn vec_iterator_cast_unwrap_drop(vec: Vec<Wrapper<String>>) -> Vec<String> {
-    // CHECK-NOT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
-    // CHECK-NOT: %{{.*}} = mul
-    // CHECK-NOT: %{{.*}} = udiv
-    // CHECK: call
-    // CHECK-SAME: void @llvm.assume(i1 %{{.+}})
-    // CHECK-NOT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
-    // CHECK-NOT: call
-    // CHECK-NOT: %{{.*}} = mul
-    // CHECK-NOT: %{{.*}} = udiv
-    // CHECK: ret void
-
-    vec.into_iter().map(|Wrapper(e)| e).collect()
-}
-
-// CHECK-LABEL: @vec_iterator_cast_wrap_drop
-#[no_mangle]
-pub fn vec_iterator_cast_wrap_drop(vec: Vec<String>) -> Vec<Wrapper<String>> {
-    // CHECK-NOT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
-    // CHECK-NOT: %{{.*}} = mul
-    // CHECK-NOT: %{{.*}} = udiv
-    // CHECK: call
-    // CHECK-SAME: void @llvm.assume(i1 %{{.+}})
-    // CHECK-NOT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}
-    // CHECK-NOT: call
-    // CHECK-NOT: %{{.*}} = mul
-    // CHECK-NOT: %{{.*}} = udiv
-    // CHECK: ret void
-
-    vec.into_iter().map(Wrapper).collect()
-}
diff --git a/tests/codegen/vec-iter-collect-len.rs b/tests/codegen/vec-iter-collect-len.rs
deleted file mode 100644
index 807548ef883..00000000000
--- a/tests/codegen/vec-iter-collect-len.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn get_len() -> usize {
-    // CHECK-LABEL: @get_len
-    // CHECK-NEXT: start:
-    // CHECK-NEXT: ; call __rustc::__rust_no_alloc_shim_is_unstable_v2
-    // CHECK-NEXT: tail call void @_R{{.+}}__rust_no_alloc_shim_is_unstable_v2()
-    // CHECK-NEXT: ret i{{[0-9]+}} 3
-    [1, 2, 3].iter().collect::<Vec<_>>().len()
-}
diff --git a/tests/codegen/vec-iter.rs b/tests/codegen/vec-iter.rs
deleted file mode 100644
index 4ed00d2d34f..00000000000
--- a/tests/codegen/vec-iter.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-#![feature(exact_size_is_empty)]
-
-use std::vec;
-
-// CHECK-LABEL: @vec_iter_len_nonnull
-#[no_mangle]
-pub fn vec_iter_len_nonnull(it: &vec::IntoIter<u8>) -> usize {
-    // CHECK: load ptr
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: load ptr
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: sub nuw
-    // CHECK: ret
-    it.len()
-}
-
-// CHECK-LABEL: @vec_iter_is_empty_nonnull
-#[no_mangle]
-pub fn vec_iter_is_empty_nonnull(it: &vec::IntoIter<u8>) -> bool {
-    // CHECK: load ptr
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: load ptr
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: ret
-    it.is_empty()
-}
-
-// CHECK-LABEL: @vec_iter_next_nonnull
-#[no_mangle]
-pub fn vec_iter_next_nonnull(it: &mut vec::IntoIter<u8>) -> Option<u8> {
-    // CHECK: load ptr
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: load ptr
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: ret
-    it.next()
-}
-
-// CHECK-LABEL: @vec_iter_next_back_nonnull
-#[no_mangle]
-pub fn vec_iter_next_back_nonnull(it: &mut vec::IntoIter<u8>) -> Option<u8> {
-    // CHECK: load ptr
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: load ptr
-    // CHECK-SAME: !nonnull
-    // CHECK-SAME: !noundef
-    // CHECK: ret
-    it.next_back()
-}
diff --git a/tests/codegen/vec-len-invariant.rs b/tests/codegen/vec-len-invariant.rs
deleted file mode 100644
index 033181c2bfb..00000000000
--- a/tests/codegen/vec-len-invariant.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ only-64bit
-//
-// This test confirms that we do not reload the length of a Vec after growing it in push.
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @should_load_once
-#[no_mangle]
-pub fn should_load_once(v: &mut Vec<u8>) {
-    // CHECK: load i64
-    // CHECK: call {{.*}}grow_one
-    // CHECK-NOT: load i64
-    // CHECK: add {{.*}}, 1
-    v.push(1);
-}
diff --git a/tests/codegen/vec-optimizes-away.rs b/tests/codegen/vec-optimizes-away.rs
deleted file mode 100644
index 93b55454b10..00000000000
--- a/tests/codegen/vec-optimizes-away.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ compile-flags: -Copt-level=3
-#![crate_type = "lib"]
-
-#[no_mangle]
-pub fn sum_me() -> i32 {
-    // CHECK-LABEL: @sum_me
-    // CHECK-NEXT: {{^.*:$}}
-    // CHECK-NEXT: ; call __rustc::__rust_no_alloc_shim_is_unstable_v2
-    // CHECK-NEXT: tail call void @_R{{.+}}__rust_no_alloc_shim_is_unstable_v2()
-    // CHECK-NEXT: ret i32 6
-    vec![1, 2, 3].iter().sum::<i32>()
-}
diff --git a/tests/codegen/vec-reserve-extend.rs b/tests/codegen/vec-reserve-extend.rs
deleted file mode 100644
index 4d3f23ccecf..00000000000
--- a/tests/codegen/vec-reserve-extend.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @should_reserve_once
-#[no_mangle]
-pub fn should_reserve_once(v: &mut Vec<u8>) {
-    // CHECK: tail call void @llvm.assume
-    v.try_reserve(3).unwrap();
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: call {{.*}}do_reserve_and_handle
-    // CHECK-NOT: call {{.*}}__rust_alloc(
-    v.extend([1, 2, 3]);
-}
diff --git a/tests/codegen/vec-shrink-panik.rs b/tests/codegen/vec-shrink-panik.rs
deleted file mode 100644
index 23dd300d48c..00000000000
--- a/tests/codegen/vec-shrink-panik.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-// LLVM 17 realizes double panic is not possible and doesn't generate calls
-// to panic_cannot_unwind.
-//@ compile-flags: -Copt-level=3
-//@ ignore-std-debug-assertions (plain old debug assertions)
-//@ needs-unwind
-#![crate_type = "lib"]
-#![feature(shrink_to)]
-
-// Make sure that `Vec::shrink_to_fit` never emits panics via `RawVec::shrink_to_fit`,
-// "Tried to shrink to a larger capacity", because the length is *always* <= capacity.
-
-// CHECK-LABEL: @shrink_to_fit
-#[no_mangle]
-pub fn shrink_to_fit(vec: &mut Vec<u32>) {
-    // CHECK-NOT: panic
-    vec.shrink_to_fit();
-}
-
-// CHECK-LABEL: @issue71861
-#[no_mangle]
-pub fn issue71861(vec: Vec<u32>) -> Box<[u32]> {
-    // CHECK-NOT: panic
-    vec.into_boxed_slice()
-}
-
-// CHECK-LABEL: @issue75636
-#[no_mangle]
-pub fn issue75636<'a>(iter: &[&'a str]) -> Box<[&'a str]> {
-    // CHECK-NOT: panic
-    iter.iter().copied().collect()
-}
diff --git a/tests/codegen/vec-with-capacity.rs b/tests/codegen/vec-with-capacity.rs
deleted file mode 100644
index 777bbcc4fcb..00000000000
--- a/tests/codegen/vec-with-capacity.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ compile-flags: -Copt-level=3
-//@ ignore-std-debug-assertions
-// (with debug assertions turned on, `assert_unchecked` generates a real assertion)
-
-#![crate_type = "lib"]
-#![feature(try_with_capacity)]
-
-// CHECK-LABEL: @with_capacity_does_not_grow1
-#[no_mangle]
-pub fn with_capacity_does_not_grow1() -> Vec<u32> {
-    let v = Vec::with_capacity(1234);
-    // CHECK: call {{.*}}__rust_alloc(
-    // CHECK-NOT: call {{.*}}__rust_realloc
-    // CHECK-NOT: call {{.*}}capacity_overflow
-    // CHECK-NOT: call {{.*}}finish_grow
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: memcpy
-    // CHECK-NOT: memset
-    v
-}
-
-// CHECK-LABEL: @try_with_capacity_does_not_grow2
-#[no_mangle]
-pub fn try_with_capacity_does_not_grow2() -> Option<Vec<Vec<u8>>> {
-    let v = Vec::try_with_capacity(1234).ok()?;
-    // CHECK: call {{.*}}__rust_alloc(
-    // CHECK-NOT: call {{.*}}__rust_realloc
-    // CHECK-NOT: call {{.*}}capacity_overflow
-    // CHECK-NOT: call {{.*}}finish_grow
-    // CHECK-NOT: call {{.*}}handle_alloc_error
-    // CHECK-NOT: call {{.*}}reserve
-    // CHECK-NOT: memcpy
-    // CHECK-NOT: memset
-    Some(v)
-}
diff --git a/tests/codegen/vec_pop_push_noop.rs b/tests/codegen/vec_pop_push_noop.rs
deleted file mode 100644
index 3e375219fe0..00000000000
--- a/tests/codegen/vec_pop_push_noop.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-#[no_mangle]
-// CHECK-LABEL: @noop(
-pub fn noop(v: &mut Vec<u8>) {
-    // CHECK-NOT: grow_one
-    // CHECK-NOT: call
-    // CHECK: tail call void @llvm.assume
-    // CHECK-NOT: grow_one
-    // CHECK-NOT: call
-    // CHECK: {{ret|[}]}}
-    if let Some(x) = v.pop() {
-        v.push(x)
-    }
-}
-
-#[no_mangle]
-// CHECK-LABEL: @push_byte(
-pub fn push_byte(v: &mut Vec<u8>) {
-    // CHECK: call {{.*}}grow_one
-    v.push(3);
-}
diff --git a/tests/codegen/vecdeque-drain.rs b/tests/codegen/vecdeque-drain.rs
deleted file mode 100644
index a5e5da65013..00000000000
--- a/tests/codegen/vecdeque-drain.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-// Check that draining at the front or back doesn't copy memory.
-
-//@ compile-flags: -Copt-level=3
-//@ needs-deterministic-layouts
-//@ ignore-std-debug-assertions (FIXME: checks for call detect scoped noalias metadata)
-
-#![crate_type = "lib"]
-
-use std::collections::VecDeque;
-
-// CHECK-LABEL: @clear
-// CHECK-NOT: call
-// CHECK-NOT: br
-// CHECK: getelementptr inbounds
-// CHECK-NEXT: {{call void @llvm.memset|store}}
-// CHECK-NEXT: ret void
-#[no_mangle]
-pub fn clear(v: &mut VecDeque<i32>) {
-    v.drain(..);
-}
-
-// CHECK-LABEL: @truncate
-// CHECK-NOT: call
-// CHECK: br
-// CHECK-NOT: call
-// CHECK: br
-// CHECK-NOT: call
-// CHECK: br
-// CHECK-NOT: call
-// CHECK: br
-// CHECK-NOT: call
-// CHECK-NOT: br
-// CHECK: ret void
-#[no_mangle]
-pub fn truncate(v: &mut VecDeque<i32>, n: usize) {
-    if n < v.len() {
-        v.drain(n..);
-    }
-}
-
-// CHECK-LABEL: @advance
-// CHECK-NOT: call
-// CHECK: br
-// CHECK-NOT: call
-// CHECK: br
-// CHECK-NOT: call
-// CHECK: br
-// CHECK-NOT: call
-// CHECK: br
-// CHECK-NOT: call
-// CHECK: br
-// CHECK-NOT: call
-// CHECK-NOT: br
-// CHECK: ret void
-#[no_mangle]
-pub fn advance(v: &mut VecDeque<i32>, n: usize) {
-    if n < v.len() {
-        v.drain(..n);
-    } else {
-        v.clear();
-    }
-}
-
-// CHECK-LABEL: @remove
-// CHECK: call
-// CHECK: ret void
-#[no_mangle]
-pub fn remove(v: &mut VecDeque<i32>, a: usize, b: usize) {
-    v.drain(a..b);
-}
diff --git a/tests/codegen/vecdeque-nonempty-get-no-panic.rs b/tests/codegen/vecdeque-nonempty-get-no-panic.rs
deleted file mode 100644
index 1f886b096bb..00000000000
--- a/tests/codegen/vecdeque-nonempty-get-no-panic.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-// Guards against regression for optimization discussed in issue #80836
-
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-use std::collections::VecDeque;
-
-// CHECK-LABEL: @front
-// CHECK: ret void
-#[no_mangle]
-pub fn front(v: VecDeque<usize>) {
-    if !v.is_empty() {
-        v.get(0).unwrap();
-    }
-}
diff --git a/tests/codegen/vecdeque_no_panic.rs b/tests/codegen/vecdeque_no_panic.rs
deleted file mode 100644
index 3166842afca..00000000000
--- a/tests/codegen/vecdeque_no_panic.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// This test checks that `VecDeque::front[_mut]()` and `VecDeque::back[_mut]()` can't panic.
-
-//@ compile-flags: -Copt-level=3
-//@ ignore-std-debug-assertions (plain old debug assertions)
-
-#![crate_type = "lib"]
-
-use std::collections::VecDeque;
-
-// CHECK-LABEL: @dont_panic
-#[no_mangle]
-pub fn dont_panic(v: &mut VecDeque<usize>) {
-    // CHECK-NOT: expect
-    // CHECK-NOT: panic
-    v.front();
-    v.front_mut();
-    v.back();
-    v.back_mut();
-}
diff --git a/tests/codegen/vecdeque_pop_push.rs b/tests/codegen/vecdeque_pop_push.rs
deleted file mode 100644
index 5afa1b2248b..00000000000
--- a/tests/codegen/vecdeque_pop_push.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-use std::collections::VecDeque;
-
-#[no_mangle]
-// CHECK-LABEL: @noop_back(
-pub fn noop_back(v: &mut VecDeque<u8>) {
-    // CHECK-NOT: grow
-    // CHECK: tail call void @llvm.assume
-    // CHECK-NOT: grow
-    // CHECK: ret
-    if let Some(x) = v.pop_back() {
-        v.push_back(x);
-    }
-}
-
-#[no_mangle]
-// CHECK-LABEL: @noop_front(
-pub fn noop_front(v: &mut VecDeque<u8>) {
-    // CHECK-NOT: grow
-    // CHECK: tail call void @llvm.assume
-    // CHECK-NOT: grow
-    // CHECK: ret
-    if let Some(x) = v.pop_front() {
-        v.push_front(x);
-    }
-}
-
-#[no_mangle]
-// CHECK-LABEL: @move_byte_front_to_back(
-pub fn move_byte_front_to_back(v: &mut VecDeque<u8>) {
-    // CHECK-NOT: grow
-    // CHECK: tail call void @llvm.assume
-    // CHECK-NOT: grow
-    // CHECK: ret
-    if let Some(x) = v.pop_front() {
-        v.push_back(x);
-    }
-}
-
-#[no_mangle]
-// CHECK-LABEL: @move_byte_back_to_front(
-pub fn move_byte_back_to_front(v: &mut VecDeque<u8>) {
-    // CHECK-NOT: grow
-    // CHECK: tail call void @llvm.assume
-    // CHECK-NOT: grow
-    // CHECK: ret
-    if let Some(x) = v.pop_back() {
-        v.push_front(x);
-    }
-}
-
-#[no_mangle]
-// CHECK-LABEL: @push_back_byte(
-pub fn push_back_byte(v: &mut VecDeque<u8>) {
-    // CHECK: call {{.*}}grow
-    v.push_back(3);
-}
-
-#[no_mangle]
-// CHECK-LABEL: @push_front_byte(
-pub fn push_front_byte(v: &mut VecDeque<u8>) {
-    // CHECK: call {{.*}}grow
-    v.push_front(3);
-}
diff --git a/tests/codegen/virtual-call-attrs-issue-137646.rs b/tests/codegen/virtual-call-attrs-issue-137646.rs
deleted file mode 100644
index 5e453947f27..00000000000
--- a/tests/codegen/virtual-call-attrs-issue-137646.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//! Regression test for https://github.com/rust-lang/rust/issues/137646.
-//! Since we don't know the exact implementation of the virtual call,
-//! it might write to parameters, we can't infer the readonly attribute.
-//@ compile-flags: -C opt-level=3 -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-#![feature(rustc_attrs)]
-
-pub trait Trait {
-    #[rustc_nounwind]
-    fn m(&self, _: (i32, i32, i32)) {}
-}
-
-#[no_mangle]
-pub fn foo(trait_: &dyn Trait) {
-    // CHECK-LABEL: @foo(
-    // CHECK: call void
-    // CHECK-NOT: readonly
-    trait_.m((1, 1, 1));
-}
-
-#[no_mangle]
-#[rustc_nounwind]
-pub fn foo_nounwind(trait_: &dyn Trait) {
-    // CHECK-LABEL: @foo_nounwind(
-    // FIXME: Here should be invoke.
-    // COM: CHECK: invoke
-    trait_.m((1, 1, 1));
-}
-
-#[no_mangle]
-pub extern "C" fn c_nounwind(trait_: &dyn Trait) {
-    // CHECK-LABEL: @c_nounwind(
-    // FIXME: Here should be invoke.
-    // COM: CHECK: invoke
-    trait_.m((1, 1, 1));
-}
diff --git a/tests/codegen/virtual-function-elimination-32bit.rs b/tests/codegen/virtual-function-elimination-32bit.rs
deleted file mode 100644
index c9919cecccf..00000000000
--- a/tests/codegen/virtual-function-elimination-32bit.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//@ compile-flags: -Zvirtual-function-elimination -Clto -Copt-level=3 -Csymbol-mangling-version=v0
-//@ ignore-64bit
-
-// CHECK: @vtable.0 = {{.*}}, !type ![[TYPE0:[0-9]+]], !vcall_visibility ![[VCALL_VIS0:[0-9]+]]
-
-#![crate_type = "lib"]
-
-trait T {
-    // CHECK-LABEL: ; <virtual_function_elimination_32bit::S as virtual_function_elimination_32bit::T>::used
-    fn used(&self) -> i32 {
-        1
-    }
-    // CHECK-LABEL-NOT: {{.*}}::unused
-    fn unused(&self) -> i32 {
-        2
-    }
-}
-
-#[derive(Copy, Clone)]
-struct S;
-
-impl T for S {}
-
-fn taking_t(t: &dyn T) -> i32 {
-    // CHECK: @llvm.type.checked.load({{.*}}, i32 12, metadata !"[[MANGLED_TYPE0:[0-9a-zA-Z_]+]]")
-    t.used()
-}
-
-pub fn main() {
-    let s = S;
-    taking_t(&s);
-}
-
-// CHECK: ![[TYPE0]] = !{i32 0, !"[[MANGLED_TYPE0]]"}
-// CHECK: ![[VCALL_VIS0]] = !{i64 2}
diff --git a/tests/codegen/virtual-function-elimination.rs b/tests/codegen/virtual-function-elimination.rs
deleted file mode 100644
index 26604478c11..00000000000
--- a/tests/codegen/virtual-function-elimination.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-//@ compile-flags: -Zvirtual-function-elimination -Clto -Copt-level=3 -Csymbol-mangling-version=v0
-//@ ignore-32bit
-
-// CHECK: @vtable.0 = {{.*}}, !type ![[TYPE0:[0-9]+]], !vcall_visibility ![[VCALL_VIS0:[0-9]+]]
-// CHECK: @vtable.1 = {{.*}}, !type ![[TYPE1:[0-9]+]], !vcall_visibility ![[VCALL_VIS0:[0-9]+]]
-// CHECK: @vtable.2 = {{.*}}, !type ![[TYPE2:[0-9]+]], !vcall_visibility ![[VCALL_VIS2:[0-9]+]]
-
-#![crate_type = "lib"]
-
-use std::rc::Rc;
-
-trait T {
-    // CHECK-LABEL: ; <virtual_function_elimination::S as virtual_function_elimination::T>::used
-    fn used(&self) -> i32 {
-        1
-    }
-    // CHECK-LABEL: ; <virtual_function_elimination::S as virtual_function_elimination::T>::used_through_sub_trait
-    fn used_through_sub_trait(&self) -> i32 {
-        3
-    }
-    // CHECK-LABEL: ; <virtual_function_elimination::S as virtual_function_elimination::T>::by_rc
-    fn by_rc(self: Rc<Self>) -> i32 {
-        self.used() + self.used()
-    }
-    // CHECK-LABEL-NOT: {{.*}}::unused
-    fn unused(&self) -> i32 {
-        2
-    }
-    // CHECK-LABEL-NOT: {{.*}}::by_rc_unused
-    fn by_rc_unused(self: Rc<Self>) -> i32 {
-        self.by_rc()
-    }
-}
-
-trait U: T {
-    // CHECK-LABEL: ; <virtual_function_elimination::S as virtual_function_elimination::U>::subtrait_used
-    fn subtrait_used(&self) -> i32 {
-        4
-    }
-    // CHECK-LABEL-NOT: {{.*}}::subtrait_unused
-    fn subtrait_unused(&self) -> i32 {
-        5
-    }
-}
-
-pub trait V {
-    // CHECK-LABEL: ; <virtual_function_elimination::S as virtual_function_elimination::V>::public_function
-    fn public_function(&self) -> i32;
-}
-
-#[derive(Copy, Clone)]
-struct S;
-
-impl T for S {}
-
-impl U for S {}
-
-impl V for S {
-    fn public_function(&self) -> i32 {
-        6
-    }
-}
-
-fn taking_t(t: &dyn T) -> i32 {
-    // CHECK: @llvm.type.checked.load({{.*}}, i32 24, metadata !"[[MANGLED_TYPE0:[0-9a-zA-Z_]+]]")
-    t.used()
-}
-
-fn taking_rc_t(t: Rc<dyn T>) -> i32 {
-    // CHECK: @llvm.type.checked.load({{.*}}, i32 40, metadata !"[[MANGLED_TYPE0:[0-9a-zA-Z_]+]]")
-    t.by_rc()
-}
-
-fn taking_u(u: &dyn U) -> i32 {
-    // CHECK: @llvm.type.checked.load({{.*}}, i32 64, metadata !"[[MANGLED_TYPE1:[0-9a-zA-Z_]+]]")
-    // CHECK: @llvm.type.checked.load({{.*}}, i32 24, metadata !"[[MANGLED_TYPE1:[0-9a-zA-Z_]+]]")
-    // CHECK: @llvm.type.checked.load({{.*}}, i32 32, metadata !"[[MANGLED_TYPE1:[0-9a-zA-Z_]+]]")
-    u.subtrait_used() + u.used() + u.used_through_sub_trait()
-}
-
-pub fn taking_v(v: &dyn V) -> i32 {
-    // CHECK: @llvm.type.checked.load({{.*}}, i32 24, metadata !"NtC[[CRATE_IDENT:[a-zA-Z0-9]{12}]]_28virtual_function_elimination1V")
-    v.public_function()
-}
-
-pub fn main() {
-    let s = S;
-    taking_t(&s);
-    taking_rc_t(Rc::new(s));
-    taking_u(&s);
-    taking_v(&s);
-}
-
-// CHECK: ![[TYPE0]] = !{i64 0, !"[[MANGLED_TYPE0]]"}
-// CHECK: ![[VCALL_VIS0]] = !{i64 2}
-// CHECK: ![[TYPE1]] = !{i64 0, !"[[MANGLED_TYPE1]]"}
-// CHECK: ![[TYPE2]] = !{i64 0, !"NtC[[CRATE_IDENT]]_28virtual_function_elimination1V"}
-// CHECK: ![[VCALL_VIS2]] = !{i64 1}
diff --git a/tests/codegen/vtable-loads.rs b/tests/codegen/vtable-loads.rs
deleted file mode 100644
index aa103ec6f7c..00000000000
--- a/tests/codegen/vtable-loads.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ compile-flags: -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @loop_skips_vtable_load
-#[no_mangle]
-pub fn loop_skips_vtable_load(x: &dyn Fn()) {
-    // CHECK: load ptr, ptr %0{{.*}}, !invariant.load
-    // CHECK-NEXT: tail call void %1
-    // CHECK-NOT: load ptr
-    x();
-    for _ in 0..100 {
-        // CHECK: tail call void %1
-        x();
-    }
-}
diff --git a/tests/codegen/vtable-upcast.rs b/tests/codegen/vtable-upcast.rs
deleted file mode 100644
index 9e13e8dd68a..00000000000
--- a/tests/codegen/vtable-upcast.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-//! This file tests that we correctly generate GEP instructions for vtable upcasting.
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-
-#![crate_type = "lib"]
-
-pub trait Base {
-    fn base(&self);
-}
-
-pub trait A: Base {
-    fn a(&self);
-}
-
-pub trait B: Base {
-    fn b(&self);
-}
-
-pub trait Diamond: A + B {
-    fn diamond(&self);
-}
-
-// CHECK-LABEL: upcast_a_to_base
-#[no_mangle]
-pub fn upcast_a_to_base(x: &dyn A) -> &dyn Base {
-    // Requires no adjustment, since its vtable is extended from `Base`.
-
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: ret
-    x as &dyn Base
-}
-
-// CHECK-LABEL: upcast_b_to_base
-#[no_mangle]
-pub fn upcast_b_to_base(x: &dyn B) -> &dyn Base {
-    // Requires no adjustment, since its vtable is extended from `Base`.
-
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: ret
-    x as &dyn Base
-}
-
-// CHECK-LABEL: upcast_diamond_to_a
-#[no_mangle]
-pub fn upcast_diamond_to_a(x: &dyn Diamond) -> &dyn A {
-    // Requires no adjustment, since its vtable is extended from `A` (as the first supertrait).
-
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: ret
-    x as &dyn A
-}
-
-// CHECK-LABEL: upcast_diamond_to_b
-// CHECK-SAME: (ptr align {{[0-9]+}} [[DATA_PTR:%.+]], ptr align {{[0-9]+}} [[VTABLE_PTR:%.+]])
-#[no_mangle]
-pub fn upcast_diamond_to_b(x: &dyn Diamond) -> &dyn B {
-    // Requires adjustment, since it's a non-first supertrait.
-
-    // CHECK: start:
-    // CHECK-NEXT: [[UPCAST_SLOT_PTR:%.+]] = getelementptr inbounds i8, ptr [[VTABLE_PTR]]
-    // CHECK-NEXT: [[UPCAST_VTABLE_PTR:%.+]] = load ptr, ptr [[UPCAST_SLOT_PTR]]
-    // CHECK-NEXT: [[FAT_PTR_1:%.+]] = insertvalue { ptr, ptr } poison, ptr [[DATA_PTR]], 0
-    // CHECK-NEXT: [[FAT_PTR_2:%.+]] = insertvalue { ptr, ptr } [[FAT_PTR_1]], ptr [[UPCAST_VTABLE_PTR]], 1
-    // CHECK-NEXT: ret { ptr, ptr } [[FAT_PTR_2]]
-    x as &dyn B
-}
-
-// CHECK-LABEL: upcast_diamond_to_b
-#[no_mangle]
-pub fn upcast_diamond_to_base(x: &dyn Diamond) -> &dyn Base {
-    // Requires no adjustment, since `Base` is the first supertrait of `A`,
-    // which is the first supertrait of `Diamond`.
-
-    // CHECK: start:
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: insertvalue
-    // CHECK-NEXT: ret
-    x as &dyn Base
-}
diff --git a/tests/codegen/wasm_casts_trapping.rs b/tests/codegen/wasm_casts_trapping.rs
deleted file mode 100644
index 0908acd85fc..00000000000
--- a/tests/codegen/wasm_casts_trapping.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-//@ only-wasm32
-//@ compile-flags: -C target-feature=-nontrapping-fptoint
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @cast_f64_i64
-#[no_mangle]
-pub fn cast_f64_i64(a: f64) -> i64 {
-    // CHECK-NOT: fptosi double {{.*}} to i64
-    // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
-    // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i64.f64{{.*}}
-    a as _
-}
-
-// CHECK-LABEL: @cast_f64_i32
-#[no_mangle]
-pub fn cast_f64_i32(a: f64) -> i32 {
-    // CHECK-NOT: fptosi double {{.*}} to i32
-    // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
-    // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i32.f64{{.*}}
-    a as _
-}
-
-// CHECK-LABEL: @cast_f32_i64
-#[no_mangle]
-pub fn cast_f32_i64(a: f32) -> i64 {
-    // CHECK-NOT: fptosi float {{.*}} to i64
-    // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
-    // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i64.f32{{.*}}
-    a as _
-}
-
-// CHECK-LABEL: @cast_f32_i32
-#[no_mangle]
-pub fn cast_f32_i32(a: f32) -> i32 {
-    // CHECK-NOT: fptosi float {{.*}} to i32
-    // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
-    // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i32.f32{{.*}}
-    a as _
-}
-
-// CHECK-LABEL: @cast_f64_u64
-#[no_mangle]
-pub fn cast_f64_u64(a: f64) -> u64 {
-    // CHECK-NOT: fptoui double {{.*}} to i64
-    // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
-    // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i64.f64{{.*}}
-    a as _
-}
-
-// CHECK-LABEL: @cast_f64_u32
-#[no_mangle]
-pub fn cast_f64_u32(a: f64) -> u32 {
-    // CHECK-NOT: fptoui double {{.*}} to i32
-    // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
-    // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i32.f64{{.*}}
-    a as _
-}
-
-// CHECK-LABEL: @cast_f32_u64
-#[no_mangle]
-pub fn cast_f32_u64(a: f32) -> u64 {
-    // CHECK-NOT: fptoui float {{.*}} to i64
-    // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
-    // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i64.f32{{.*}}
-    a as _
-}
-
-// CHECK-LABEL: @cast_f32_u32
-#[no_mangle]
-pub fn cast_f32_u32(a: f32) -> u32 {
-    // CHECK-NOT: fptoui float {{.*}} to i32
-    // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
-    // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i32.f32{{.*}}
-    a as _
-}
-
-// CHECK-LABEL: @cast_f32_u8
-#[no_mangle]
-pub fn cast_f32_u8(a: f32) -> u8 {
-    // CHECK-NOT: fptoui float {{.*}} to i8
-    // CHECK-NOT: select i1 {{.*}}, i8 {{.*}}, i8 {{.*}}
-    // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i8.f32{{.*}}
-    a as _
-}
-
-// CHECK-LABEL: @cast_unchecked_f64_i64
-#[no_mangle]
-pub unsafe fn cast_unchecked_f64_i64(a: f64) -> i64 {
-    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
-    // CHECK-NEXT: ret i64 {{.*}}
-    a.to_int_unchecked()
-}
-
-// CHECK-LABEL: @cast_unchecked_f64_i32
-#[no_mangle]
-pub unsafe fn cast_unchecked_f64_i32(a: f64) -> i32 {
-    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
-    // CHECK-NEXT: ret i32 {{.*}}
-    a.to_int_unchecked()
-}
-
-// CHECK-LABEL: @cast_unchecked_f32_i64
-#[no_mangle]
-pub unsafe fn cast_unchecked_f32_i64(a: f32) -> i64 {
-    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
-    // CHECK-NEXT: ret i64 {{.*}}
-    a.to_int_unchecked()
-}
-
-// CHECK-LABEL: @cast_unchecked_f32_i32
-#[no_mangle]
-pub unsafe fn cast_unchecked_f32_i32(a: f32) -> i32 {
-    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
-    // CHECK-NEXT: ret i32 {{.*}}
-    a.to_int_unchecked()
-}
-
-// CHECK-LABEL: @cast_unchecked_f64_u64
-#[no_mangle]
-pub unsafe fn cast_unchecked_f64_u64(a: f64) -> u64 {
-    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
-    // CHECK-NEXT: ret i64 {{.*}}
-    a.to_int_unchecked()
-}
-
-// CHECK-LABEL: @cast_unchecked_f64_u32
-#[no_mangle]
-pub unsafe fn cast_unchecked_f64_u32(a: f64) -> u32 {
-    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
-    // CHECK-NEXT: ret i32 {{.*}}
-    a.to_int_unchecked()
-}
-
-// CHECK-LABEL: @cast_unchecked_f32_u64
-#[no_mangle]
-pub unsafe fn cast_unchecked_f32_u64(a: f32) -> u64 {
-    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
-    // CHECK-NEXT: ret i64 {{.*}}
-    a.to_int_unchecked()
-}
-
-// CHECK-LABEL: @cast_unchecked_f32_u32
-#[no_mangle]
-pub unsafe fn cast_unchecked_f32_u32(a: f32) -> u32 {
-    // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
-    // CHECK-NEXT: ret i32 {{.*}}
-    a.to_int_unchecked()
-}
-
-// CHECK-LABEL: @cast_unchecked_f32_u8
-#[no_mangle]
-pub unsafe fn cast_unchecked_f32_u8(a: f32) -> u8 {
-    // CHECK-NOT: {{.*}} call {{.*}} @llvm.wasm.trunc.{{.*}}
-    // CHECK: fptoui float {{.*}} to i8
-    // CHECK-NEXT: ret i8 {{.*}}
-    a.to_int_unchecked()
-}
diff --git a/tests/codegen/wasm_exceptions.rs b/tests/codegen/wasm_exceptions.rs
deleted file mode 100644
index 07b8ae6e9d7..00000000000
--- a/tests/codegen/wasm_exceptions.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//@ only-wasm32
-//@ compile-flags: -C panic=unwind -Z emscripten-wasm-eh
-
-#![crate_type = "lib"]
-#![feature(core_intrinsics)]
-
-extern "C-unwind" {
-    fn may_panic();
-}
-
-extern "C" {
-    fn log_number(number: usize);
-}
-
-struct LogOnDrop;
-
-impl Drop for LogOnDrop {
-    fn drop(&mut self) {
-        unsafe {
-            log_number(0);
-        }
-    }
-}
-
-// CHECK-LABEL: @test_cleanup() {{.*}} @__gxx_wasm_personality_v0
-#[no_mangle]
-pub fn test_cleanup() {
-    let _log_on_drop = LogOnDrop;
-    unsafe {
-        may_panic();
-    }
-
-    // CHECK-NOT: call
-    // CHECK: invoke void @may_panic()
-    // CHECK: %cleanuppad = cleanuppad within none []
-}
-
-// CHECK-LABEL: @test_rtry() {{.*}} @__gxx_wasm_personality_v0
-#[no_mangle]
-pub fn test_rtry() {
-    unsafe {
-        core::intrinsics::catch_unwind(
-            |_| {
-                may_panic();
-            },
-            core::ptr::null_mut(),
-            |data, exception| {
-                log_number(data as usize);
-                log_number(exception as usize);
-            },
-        );
-    }
-
-    // CHECK-NOT: call
-    // CHECK: invoke void @may_panic()
-    // CHECK: {{.*}} = catchswitch within none [label {{.*}}] unwind to caller
-    // CHECK: {{.*}} = catchpad within {{.*}} [ptr null]
-    // CHECK: catchret
-}
diff --git a/tests/codegen/zip.rs b/tests/codegen/zip.rs
deleted file mode 100644
index 38ecf7c15c6..00000000000
--- a/tests/codegen/zip.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ compile-flags: -Cno-prepopulate-passes -Copt-level=3
-
-#![crate_type = "lib"]
-
-// CHECK-LABEL: @zip_copy
-#[no_mangle]
-pub fn zip_copy(xs: &[u8], ys: &mut [u8]) {
-    // CHECK: memcpy
-    for (x, y) in xs.iter().zip(ys) {
-        *y = *x;
-    }
-}
-
-// CHECK-LABEL: @zip_copy_mapped
-#[no_mangle]
-pub fn zip_copy_mapped(xs: &[u8], ys: &mut [u8]) {
-    // CHECK: memcpy
-    for (x, y) in xs.iter().map(|&x| x).zip(ys) {
-        *y = x;
-    }
-}
diff --git a/tests/codegen/zst-offset.rs b/tests/codegen/zst-offset.rs
deleted file mode 100644
index 475394a8815..00000000000
--- a/tests/codegen/zst-offset.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
-
-#![crate_type = "lib"]
-#![feature(repr_simd)]
-
-// Hack to get the correct size for the length part in slices
-// CHECK: @helper([[USIZE:i[0-9]+]] %_1)
-#[no_mangle]
-pub fn helper(_: usize) {}
-
-// Check that we correctly generate a GEP for a ZST that is not included in Scalar layout
-// CHECK-LABEL: @scalar_layout
-#[no_mangle]
-pub fn scalar_layout(s: &(u64, ())) {
-    // CHECK: getelementptr inbounds i8, {{.+}}, [[USIZE]] 8
-    let x = &s.1;
-    witness(&x); // keep variable in an alloca
-}
-
-// Check that we correctly generate a GEP for a ZST that is not included in ScalarPair layout
-// CHECK-LABEL: @scalarpair_layout
-#[no_mangle]
-pub fn scalarpair_layout(s: &(u64, u32, ())) {
-    // CHECK: getelementptr inbounds i8, {{.+}}, [[USIZE]] 12
-    let x = &s.2;
-    witness(&x); // keep variable in an alloca
-}
-
-#[repr(simd)]
-pub struct U64x4([u64; 4]);
-
-// Check that we correctly generate a GEP for a ZST that is not included in Vector layout
-// CHECK-LABEL: @vector_layout
-#[no_mangle]
-pub fn vector_layout(s: &(U64x4, ())) {
-    // CHECK: getelementptr inbounds i8, {{.+}}, [[USIZE]] 32
-    let x = &s.1;
-    witness(&x); // keep variable in an alloca
-}
-
-#[inline(never)]
-fn witness(_: &impl Sized) {}
diff --git a/tests/run-make/llvm-ident/rmake.rs b/tests/run-make/llvm-ident/rmake.rs
index 47e6fc4de15..b4d30ee7bfb 100644
--- a/tests/run-make/llvm-ident/rmake.rs
+++ b/tests/run-make/llvm-ident/rmake.rs
@@ -27,7 +27,7 @@ fn main() {
 
     // Check LLVM IR files (including temporary outputs) have `!llvm.ident`
     // named metadata, reusing the related codegen test.
-    let llvm_ident_path = source_root().join("tests/codegen/llvm-ident.rs");
+    let llvm_ident_path = source_root().join("tests/codegen-llvm/llvm-ident.rs");
     let files = shallow_find_files(".", |path| has_extension(path, "ll"));
     for file in files {
         llvm_filecheck().input_file(file).arg(&llvm_ident_path).run();
diff --git a/tests/ui/abi/fixed_x18.rs b/tests/ui/abi/fixed_x18.rs
index 09d16303033..baf215ba903 100644
--- a/tests/ui/abi/fixed_x18.rs
+++ b/tests/ui/abi/fixed_x18.rs
@@ -1,5 +1,5 @@
 // This tests that -Zfixed-x18 causes a compilation failure on targets other than aarch64.
-// Behavior on aarch64 is tested by tests/codegen/fixed-x18.rs.
+// Behavior on aarch64 is tested by tests/codegen-llvm/fixed-x18.rs.
 //
 //@ revisions: x64 i686 arm riscv32 riscv64
 //@ dont-check-compiler-stderr
diff --git a/triagebot.toml b/triagebot.toml
index e34e4a88f42..162e244c0ad 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -304,7 +304,7 @@ trigger_files = [
     # Tests
     "tests/assembly-llvm",
     "tests/auxiliary",
-    "tests/codegen",
+    "tests/codegen-llvm",
     "tests/codegen-units",
     "tests/COMPILER_TESTS.md",
     "tests/coverage",
@@ -558,10 +558,10 @@ trigger_files = [
     "src/doc/unstable-book/src/language-features/cfg-sanitize.md",
     "src/doc/unstable-book/src/language-features/cfi-encoding.md",
     "src/doc/unstable-book/src/language-features/no-sanitize.md",
-    "tests/codegen/sanitizer",
-    "tests/codegen/split-lto-unit.rs",
-    "tests/codegen/stack-probes-inline.rs",
-    "tests/codegen/stack-protector.rs",
+    "tests/codegen-llvm/sanitizer",
+    "tests/codegen-llvm/split-lto-unit.rs",
+    "tests/codegen-llvm/stack-probes-inline.rs",
+    "tests/codegen-llvm/stack-protector.rs",
     "tests/ui/sanitizer",
     "tests/ui/stack-protector"
 ]
@@ -1183,16 +1183,16 @@ cc = ["@Urgau"]
 [mentions."src/doc/rustc/src/platform-support"]
 cc = ["@Noratrieb"]
 
-[mentions."tests/codegen/sanitizer"]
+[mentions."tests/codegen-llvm/sanitizer"]
 cc = ["@rcvalle"]
 
-[mentions."tests/codegen/split-lto-unit.rs"]
+[mentions."tests/codegen-llvm/split-lto-unit.rs"]
 cc = ["@rust-lang/project-exploit-mitigations", "@rcvalle"]
 
-[mentions."tests/codegen/stack-probes-inline.rs"]
+[mentions."tests/codegen-llvm/stack-probes-inline.rs"]
 cc = ["@rust-lang/project-exploit-mitigations", "@rcvalle"]
 
-[mentions."tests/codegen/stack-protector.rs"]
+[mentions."tests/codegen-llvm/stack-protector.rs"]
 cc = ["@rust-lang/project-exploit-mitigations", "@rcvalle"]
 
 [mentions."tests/ui/sanitizer"]
-- 
cgit 1.4.1-3-g733a5


From 6bfa00816d7e4dcb0aee9fe547bc75dfe59dc613 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 21 Jul 2025 11:51:36 +0200
Subject: Only run `tests/assembly-*` and `tests/codegen-*` tests if they match
 the current codegen backend

---
 src/tools/compiletest/src/common.rs |  4 ++--
 src/tools/compiletest/src/lib.rs    | 19 ++++++++++++++++++-
 2 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 12084fa0b15..aceae3e3a3b 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -57,8 +57,8 @@ impl TestMode {
 string_enum! {
     #[derive(Clone, Copy, PartialEq, Debug)]
     pub enum TestSuite {
-        Assembly => "assembly",
-        Codegen => "codegen",
+        AssemblyLlvm => "assembly-llvm",
+        CodegenLlvm => "codegen-llvm",
         CodegenUnits => "codegen-units",
         Coverage => "coverage",
         CoverageRunRustdoc => "coverage-run-rustdoc",
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 41bed8ed8a0..c712185733c 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -31,7 +31,7 @@ use std::time::SystemTime;
 use std::{env, fs, vec};
 
 use build_helper::git::{get_git_modified_files, get_git_untracked_files};
-use camino::{Utf8Path, Utf8PathBuf};
+use camino::{Utf8Component, Utf8Path, Utf8PathBuf};
 use getopts::Options;
 use rayon::iter::{ParallelBridge, ParallelIterator};
 use tracing::debug;
@@ -799,6 +799,23 @@ fn collect_tests_from_dir(
         return Ok(TestCollector::new());
     }
 
+    let mut components = dir.components().rev();
+    if let Some(Utf8Component::Normal(last)) = components.next()
+        && let Some(("assembly" | "codegen", backend)) = last.split_once('-')
+        && let Some(Utf8Component::Normal(parent)) = components.next()
+        && parent == "tests"
+        && let Ok(backend) = CodegenBackend::try_from(backend)
+        && backend != cx.config.codegen_backend
+    {
+        // We ignore asm tests which don't match the current codegen backend.
+        warning!(
+            "Ignoring tests in `{dir}` because they don't match the configured codegen \
+             backend (`{}`)",
+            cx.config.codegen_backend.as_str(),
+        );
+        return Ok(TestCollector::new());
+    }
+
     // For run-make tests, a "test file" is actually a directory that contains an `rmake.rs`.
     if cx.config.mode == TestMode::RunMake {
         let mut collector = TestCollector::new();
-- 
cgit 1.4.1-3-g733a5


From 5b2de8ab27e4a319e23817b61830a5cc6fd1745e Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 09:26:12 +0200
Subject: Move `std_detect` from `library/stdarch` to `library`

---
 library/std_detect/Cargo.toml                      |  41 ++
 library/std_detect/LICENSE-APACHE                  | 201 +++++++++
 library/std_detect/LICENSE-MIT                     |  25 ++
 library/std_detect/README.md                       |  93 ++++
 library/std_detect/src/detect/arch/aarch64.rs      | 259 +++++++++++
 library/std_detect/src/detect/arch/arm.rs          |  29 ++
 library/std_detect/src/detect/arch/loongarch.rs    |  51 +++
 library/std_detect/src/detect/arch/mips.rs         |  12 +
 library/std_detect/src/detect/arch/mips64.rs       |  12 +
 library/std_detect/src/detect/arch/mod.rs          |  75 ++++
 library/std_detect/src/detect/arch/powerpc.rs      |  30 ++
 library/std_detect/src/detect/arch/powerpc64.rs    |  30 ++
 library/std_detect/src/detect/arch/riscv.rs        | 344 +++++++++++++++
 library/std_detect/src/detect/arch/s390x.rs        |  81 ++++
 library/std_detect/src/detect/arch/x86.rs          | 278 ++++++++++++
 library/std_detect/src/detect/bit.rs               |   9 +
 library/std_detect/src/detect/cache.rs             | 223 ++++++++++
 library/std_detect/src/detect/macros.rs            | 204 +++++++++
 library/std_detect/src/detect/mod.rs               | 121 ++++++
 library/std_detect/src/detect/os/aarch64.rs        | 130 ++++++
 library/std_detect/src/detect/os/darwin/aarch64.rs | 155 +++++++
 .../std_detect/src/detect/os/freebsd/aarch64.rs    |   3 +
 library/std_detect/src/detect/os/freebsd/arm.rs    |  36 ++
 library/std_detect/src/detect/os/freebsd/auxvec.rs |  66 +++
 library/std_detect/src/detect/os/freebsd/mod.rs    |  22 +
 .../std_detect/src/detect/os/freebsd/powerpc.rs    |  21 +
 library/std_detect/src/detect/os/linux/aarch64.rs  | 484 +++++++++++++++++++++
 library/std_detect/src/detect/os/linux/arm.rs      |  34 ++
 library/std_detect/src/detect/os/linux/auxvec.rs   | 341 +++++++++++++++
 .../std_detect/src/detect/os/linux/loongarch.rs    |  68 +++
 library/std_detect/src/detect/os/linux/mips.rs     |  23 +
 library/std_detect/src/detect/os/linux/mod.rs      |  67 +++
 library/std_detect/src/detect/os/linux/powerpc.rs  |  35 ++
 library/std_detect/src/detect/os/linux/riscv.rs    | 330 ++++++++++++++
 library/std_detect/src/detect/os/linux/s390x.rs    | 152 +++++++
 .../std_detect/src/detect/os/openbsd/aarch64.rs    |  55 +++
 library/std_detect/src/detect/os/other.rs          |   8 +
 library/std_detect/src/detect/os/riscv.rs          | 203 +++++++++
 .../std_detect/src/detect/os/windows/aarch64.rs    | 125 ++++++
 library/std_detect/src/detect/os/x86.rs            | 335 ++++++++++++++
 .../detect/test_data/linux-artificial-aarch64.auxv | Bin 0 -> 336 bytes
 .../test_data/linux-empty-hwcap2-aarch64.auxv      | Bin 0 -> 336 bytes
 .../src/detect/test_data/linux-hwcap2-aarch64.auxv | Bin 0 -> 336 bytes
 .../detect/test_data/linux-no-hwcap2-aarch64.auxv  | Bin 0 -> 320 bytes
 .../src/detect/test_data/linux-rpi3.auxv           | Bin 0 -> 160 bytes
 .../macos-virtualbox-linux-x86-4850HQ.auxv         | Bin 0 -> 160 bytes
 library/std_detect/src/lib.rs                      |  36 ++
 library/std_detect/tests/cpu-detection.rs          | 354 +++++++++++++++
 library/std_detect/tests/macro_trailing_commas.rs  | 109 +++++
 library/std_detect/tests/x86-specific.rs           | 117 +++++
 library/stdarch/crates/std_detect/Cargo.toml       |  41 --
 library/stdarch/crates/std_detect/LICENSE-APACHE   | 201 ---------
 library/stdarch/crates/std_detect/LICENSE-MIT      |  25 --
 library/stdarch/crates/std_detect/README.md        |  93 ----
 .../crates/std_detect/src/detect/arch/aarch64.rs   | 259 -----------
 .../crates/std_detect/src/detect/arch/arm.rs       |  29 --
 .../crates/std_detect/src/detect/arch/loongarch.rs |  51 ---
 .../crates/std_detect/src/detect/arch/mips.rs      |  12 -
 .../crates/std_detect/src/detect/arch/mips64.rs    |  12 -
 .../crates/std_detect/src/detect/arch/mod.rs       |  75 ----
 .../crates/std_detect/src/detect/arch/powerpc.rs   |  30 --
 .../crates/std_detect/src/detect/arch/powerpc64.rs |  30 --
 .../crates/std_detect/src/detect/arch/riscv.rs     | 344 ---------------
 .../crates/std_detect/src/detect/arch/s390x.rs     |  81 ----
 .../crates/std_detect/src/detect/arch/x86.rs       | 278 ------------
 .../stdarch/crates/std_detect/src/detect/bit.rs    |   9 -
 .../stdarch/crates/std_detect/src/detect/cache.rs  | 223 ----------
 .../stdarch/crates/std_detect/src/detect/macros.rs | 204 ---------
 .../stdarch/crates/std_detect/src/detect/mod.rs    | 121 ------
 .../crates/std_detect/src/detect/os/aarch64.rs     | 130 ------
 .../std_detect/src/detect/os/darwin/aarch64.rs     | 155 -------
 .../std_detect/src/detect/os/freebsd/aarch64.rs    |   3 -
 .../crates/std_detect/src/detect/os/freebsd/arm.rs |  36 --
 .../std_detect/src/detect/os/freebsd/auxvec.rs     |  66 ---
 .../crates/std_detect/src/detect/os/freebsd/mod.rs |  22 -
 .../std_detect/src/detect/os/freebsd/powerpc.rs    |  21 -
 .../std_detect/src/detect/os/linux/aarch64.rs      | 484 ---------------------
 .../crates/std_detect/src/detect/os/linux/arm.rs   |  34 --
 .../std_detect/src/detect/os/linux/auxvec.rs       | 341 ---------------
 .../std_detect/src/detect/os/linux/loongarch.rs    |  68 ---
 .../crates/std_detect/src/detect/os/linux/mips.rs  |  23 -
 .../crates/std_detect/src/detect/os/linux/mod.rs   |  67 ---
 .../std_detect/src/detect/os/linux/powerpc.rs      |  35 --
 .../crates/std_detect/src/detect/os/linux/riscv.rs | 330 --------------
 .../crates/std_detect/src/detect/os/linux/s390x.rs | 152 -------
 .../std_detect/src/detect/os/openbsd/aarch64.rs    |  55 ---
 .../crates/std_detect/src/detect/os/other.rs       |   8 -
 .../crates/std_detect/src/detect/os/riscv.rs       | 203 ---------
 .../std_detect/src/detect/os/windows/aarch64.rs    | 125 ------
 .../stdarch/crates/std_detect/src/detect/os/x86.rs | 335 --------------
 .../detect/test_data/linux-artificial-aarch64.auxv | Bin 336 -> 0 bytes
 .../test_data/linux-empty-hwcap2-aarch64.auxv      | Bin 336 -> 0 bytes
 .../src/detect/test_data/linux-hwcap2-aarch64.auxv | Bin 336 -> 0 bytes
 .../detect/test_data/linux-no-hwcap2-aarch64.auxv  | Bin 320 -> 0 bytes
 .../src/detect/test_data/linux-rpi3.auxv           | Bin 160 -> 0 bytes
 .../macos-virtualbox-linux-x86-4850HQ.auxv         | Bin 160 -> 0 bytes
 library/stdarch/crates/std_detect/src/lib.rs       |  36 --
 .../crates/std_detect/tests/cpu-detection.rs       | 354 ---------------
 .../std_detect/tests/macro_trailing_commas.rs      | 109 -----
 .../crates/std_detect/tests/x86-specific.rs        | 117 -----
 100 files changed, 5427 insertions(+), 5427 deletions(-)
 create mode 100644 library/std_detect/Cargo.toml
 create mode 100644 library/std_detect/LICENSE-APACHE
 create mode 100644 library/std_detect/LICENSE-MIT
 create mode 100644 library/std_detect/README.md
 create mode 100644 library/std_detect/src/detect/arch/aarch64.rs
 create mode 100644 library/std_detect/src/detect/arch/arm.rs
 create mode 100644 library/std_detect/src/detect/arch/loongarch.rs
 create mode 100644 library/std_detect/src/detect/arch/mips.rs
 create mode 100644 library/std_detect/src/detect/arch/mips64.rs
 create mode 100644 library/std_detect/src/detect/arch/mod.rs
 create mode 100644 library/std_detect/src/detect/arch/powerpc.rs
 create mode 100644 library/std_detect/src/detect/arch/powerpc64.rs
 create mode 100644 library/std_detect/src/detect/arch/riscv.rs
 create mode 100644 library/std_detect/src/detect/arch/s390x.rs
 create mode 100644 library/std_detect/src/detect/arch/x86.rs
 create mode 100644 library/std_detect/src/detect/bit.rs
 create mode 100644 library/std_detect/src/detect/cache.rs
 create mode 100644 library/std_detect/src/detect/macros.rs
 create mode 100644 library/std_detect/src/detect/mod.rs
 create mode 100644 library/std_detect/src/detect/os/aarch64.rs
 create mode 100644 library/std_detect/src/detect/os/darwin/aarch64.rs
 create mode 100644 library/std_detect/src/detect/os/freebsd/aarch64.rs
 create mode 100644 library/std_detect/src/detect/os/freebsd/arm.rs
 create mode 100644 library/std_detect/src/detect/os/freebsd/auxvec.rs
 create mode 100644 library/std_detect/src/detect/os/freebsd/mod.rs
 create mode 100644 library/std_detect/src/detect/os/freebsd/powerpc.rs
 create mode 100644 library/std_detect/src/detect/os/linux/aarch64.rs
 create mode 100644 library/std_detect/src/detect/os/linux/arm.rs
 create mode 100644 library/std_detect/src/detect/os/linux/auxvec.rs
 create mode 100644 library/std_detect/src/detect/os/linux/loongarch.rs
 create mode 100644 library/std_detect/src/detect/os/linux/mips.rs
 create mode 100644 library/std_detect/src/detect/os/linux/mod.rs
 create mode 100644 library/std_detect/src/detect/os/linux/powerpc.rs
 create mode 100644 library/std_detect/src/detect/os/linux/riscv.rs
 create mode 100644 library/std_detect/src/detect/os/linux/s390x.rs
 create mode 100644 library/std_detect/src/detect/os/openbsd/aarch64.rs
 create mode 100644 library/std_detect/src/detect/os/other.rs
 create mode 100644 library/std_detect/src/detect/os/riscv.rs
 create mode 100644 library/std_detect/src/detect/os/windows/aarch64.rs
 create mode 100644 library/std_detect/src/detect/os/x86.rs
 create mode 100644 library/std_detect/src/detect/test_data/linux-artificial-aarch64.auxv
 create mode 100644 library/std_detect/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv
 create mode 100644 library/std_detect/src/detect/test_data/linux-hwcap2-aarch64.auxv
 create mode 100644 library/std_detect/src/detect/test_data/linux-no-hwcap2-aarch64.auxv
 create mode 100644 library/std_detect/src/detect/test_data/linux-rpi3.auxv
 create mode 100644 library/std_detect/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv
 create mode 100644 library/std_detect/src/lib.rs
 create mode 100644 library/std_detect/tests/cpu-detection.rs
 create mode 100644 library/std_detect/tests/macro_trailing_commas.rs
 create mode 100644 library/std_detect/tests/x86-specific.rs
 delete mode 100644 library/stdarch/crates/std_detect/Cargo.toml
 delete mode 100644 library/stdarch/crates/std_detect/LICENSE-APACHE
 delete mode 100644 library/stdarch/crates/std_detect/LICENSE-MIT
 delete mode 100644 library/stdarch/crates/std_detect/README.md
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/arch/aarch64.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/arch/arm.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/arch/loongarch.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/arch/mips.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/arch/mips64.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/arch/mod.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/arch/powerpc.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/arch/powerpc64.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/arch/riscv.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/arch/s390x.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/arch/x86.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/bit.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/cache.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/macros.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/mod.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/aarch64.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/darwin/aarch64.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/freebsd/aarch64.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/freebsd/arm.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/freebsd/auxvec.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/freebsd/mod.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/freebsd/powerpc.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/linux/aarch64.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/linux/arm.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/linux/auxvec.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/linux/loongarch.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/linux/mips.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/linux/mod.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/linux/powerpc.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/linux/riscv.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/linux/s390x.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/openbsd/aarch64.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/other.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/riscv.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/windows/aarch64.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/os/x86.rs
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/test_data/linux-artificial-aarch64.auxv
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/test_data/linux-hwcap2-aarch64.auxv
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/test_data/linux-no-hwcap2-aarch64.auxv
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/test_data/linux-rpi3.auxv
 delete mode 100644 library/stdarch/crates/std_detect/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv
 delete mode 100644 library/stdarch/crates/std_detect/src/lib.rs
 delete mode 100644 library/stdarch/crates/std_detect/tests/cpu-detection.rs
 delete mode 100644 library/stdarch/crates/std_detect/tests/macro_trailing_commas.rs
 delete mode 100644 library/stdarch/crates/std_detect/tests/x86-specific.rs

diff --git a/library/std_detect/Cargo.toml b/library/std_detect/Cargo.toml
new file mode 100644
index 00000000000..f990e724125
--- /dev/null
+++ b/library/std_detect/Cargo.toml
@@ -0,0 +1,41 @@
+[package]
+name = "std_detect"
+version = "0.1.5"
+authors = [
+    "Alex Crichton <alex@alexcrichton.com>",
+    "Andrew Gallant <jamslam@gmail.com>",
+    "Gonzalo Brito Gadeschi <gonzalobg88@gmail.com>",
+]
+description = "`std::detect` - Rust's standard library run-time CPU feature detection."
+homepage = "https://github.com/rust-lang/stdarch"
+repository = "https://github.com/rust-lang/stdarch"
+readme = "README.md"
+keywords = ["std", "run-time", "feature", "detection"]
+categories = ["hardware-support"]
+license = "MIT OR Apache-2.0"
+edition = "2024"
+
+[badges]
+is-it-maintained-issue-resolution = { repository = "rust-lang/stdarch" }
+is-it-maintained-open-issues = { repository = "rust-lang/stdarch" }
+maintenance = { status = "experimental" }
+
+[dependencies]
+cfg-if = "1.0.0"
+
+# When built as part of libstd
+core = { version = "1.0.0", optional = true, package = "rustc-std-workspace-core" }
+alloc = { version = "1.0.0", optional = true, package = "rustc-std-workspace-alloc" }
+
+[target.'cfg(not(windows))'.dependencies]
+libc = { version = "0.2.0", optional = true, default-features = false }
+
+[features]
+default = [ "std_detect_dlsym_getauxval", "std_detect_file_io" ]
+std_detect_file_io = [ "libc" ]
+std_detect_dlsym_getauxval = [ "libc" ]
+std_detect_env_override = [ "libc" ]
+rustc-dep-of-std = [
+    "core",
+    "alloc",
+]
diff --git a/library/std_detect/LICENSE-APACHE b/library/std_detect/LICENSE-APACHE
new file mode 100644
index 00000000000..16fe87b06e8
--- /dev/null
+++ b/library/std_detect/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/library/std_detect/LICENSE-MIT b/library/std_detect/LICENSE-MIT
new file mode 100644
index 00000000000..52d82415d8b
--- /dev/null
+++ b/library/std_detect/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2017 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/library/std_detect/README.md b/library/std_detect/README.md
new file mode 100644
index 00000000000..edc90d319a1
--- /dev/null
+++ b/library/std_detect/README.md
@@ -0,0 +1,93 @@
+`std::detect` - Rust's standard library run-time CPU feature detection
+=======
+
+The private `std::detect` module implements run-time feature detection in Rust's
+standard library. This allows detecting whether the CPU the binary runs on
+supports certain features, like SIMD instructions.
+
+# Usage
+
+`std::detect` APIs are available as part of `libstd`. Prefer using it via the
+standard library than through this crate. Unstable features of `std::detect` are
+available on nightly Rust behind various feature-gates.
+
+If you need run-time feature detection in `#[no_std]` environments, Rust `core`
+library cannot help you. By design, Rust `core` is platform independent, but
+performing run-time feature detection requires a certain level of cooperation
+from the platform.
+
+You can then manually include `std_detect` as a dependency to get similar
+run-time feature detection support than the one offered by Rust's standard
+library. We intend to make `std_detect` more flexible and configurable in this
+regard to better serve the needs of `#[no_std]` targets.
+
+# Features
+
+* `std_detect_dlsym_getauxval` (enabled by default, requires `libc`): Enable to
+use `libc::dlsym` to query whether [`getauxval`] is linked into the binary. When
+this is not the case, this feature allows other fallback methods to perform
+run-time feature detection. When this feature is disabled, `std_detect` assumes
+that [`getauxval`] is linked to the binary. If that is not the case the behavior
+is undefined.
+
+  Note: This feature is ignored on `*-linux-{gnu,musl,ohos}*` and `*-android*` targets
+  because we can safely assume `getauxval` is linked to the binary.
+  * `*-linux-gnu*` targets ([since Rust 1.64](https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.html))
+    have glibc requirements higher than [glibc 2.16 that added `getauxval`](https://sourceware.org/legacy-ml/libc-announce/2012/msg00000.html).
+  * `*-linux-musl*` targets ([at least since Rust 1.15](https://github.com/rust-lang/rust/blob/1.15.0/src/ci/docker/x86_64-musl/build-musl.sh#L15))
+    use musl newer than [musl 1.1.0 that added `getauxval`](https://git.musl-libc.org/cgit/musl/tree/WHATSNEW?h=v1.1.0#n1197)
+  * `*-linux-ohos*` targets use a [fork of musl 1.2](https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/native-lib/musl.md)
+  * `*-android*` targets ([since Rust 1.68](https://blog.rust-lang.org/2023/01/09/android-ndk-update-r25.html))
+    have the minimum supported API level higher than [Android 4.3 (API level 18) that added `getauxval`](https://github.com/aosp-mirror/platform_bionic/blob/d3ebc2f7c49a9893b114124d4a6b315f3a328764/libc/include/sys/auxv.h#L49).
+
+* `std_detect_file_io` (enabled by default, requires `std`): Enable to perform run-time feature
+detection using file APIs (e.g. `/proc/self/auxv`, etc.) if other more performant
+methods fail. This feature requires `libstd` as a dependency, preventing the
+crate from working on applications in which `std` is not available.
+
+[`getauxval`]: https://man7.org/linux/man-pages/man3/getauxval.3.html
+
+# Platform support
+
+* All `x86`/`x86_64` targets are supported on all platforms by querying the
+  `cpuid` instruction directly for the features supported by the hardware and
+  the operating system. `std_detect` assumes that the binary is an user-space
+  application.
+
+* Linux/Android:
+  * `arm{32, 64}`, `mips{32,64}{,el}`, `powerpc{32,64}{,le}`, `loongarch{32,64}`, `s390x`:
+    `std_detect` supports these on Linux by querying ELF auxiliary vectors (using `getauxval`
+    when available), and if that fails, by querying `/proc/self/auxv`.
+  * `arm64`: partial support for doing run-time feature detection by directly
+    querying `mrs` is implemented for Linux >= 4.11, but not enabled by default.
+  * `riscv{32,64}`:
+    `std_detect` supports these on Linux by querying `riscv_hwprobe`, and
+    by querying ELF auxiliary vectors (using `getauxval` when available).
+
+* FreeBSD:
+  * `arm32`, `powerpc64`: `std_detect` supports these on FreeBSD by querying ELF
+    auxiliary vectors using `sysctl`.
+  * `arm64`: run-time feature detection is implemented by directly querying `mrs`.
+
+* OpenBSD:
+  * `arm64`: run-time feature detection is implemented by querying `sysctl`.
+
+* Windows:
+  * `arm64`: run-time feature detection is implemented by querying `IsProcessorFeaturePresent`.
+
+# License
+
+This project is licensed under either of
+
+ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+   http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or
+   http://opensource.org/licenses/MIT)
+
+at your option.
+
+# Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in `std_detect` by you, as defined in the Apache-2.0 license,
+shall be dual licensed as above, without any additional terms or conditions.
diff --git a/library/std_detect/src/detect/arch/aarch64.rs b/library/std_detect/src/detect/arch/aarch64.rs
new file mode 100644
index 00000000000..13570a25c1c
--- /dev/null
+++ b/library/std_detect/src/detect/arch/aarch64.rs
@@ -0,0 +1,259 @@
+//! Aarch64 run-time features.
+
+features! {
+    @TARGET: aarch64;
+    @CFG: any(target_arch = "aarch64", target_arch = "arm64ec");
+    @MACRO_NAME: is_aarch64_feature_detected;
+    @MACRO_ATTRS:
+    /// This macro tests, at runtime, whether an `aarch64` feature is enabled on aarch64 platforms.
+    /// Currently most features are only supported on linux-based platforms.
+    ///
+    /// This macro takes one argument which is a string literal of the feature being tested for.
+    /// The feature names are mostly taken from their FEAT_* definitions in the [ARM Architecture
+    /// Reference Manual][docs].
+    ///
+    /// ## Supported arguments
+    ///
+    /// * `"aes"` - FEAT_AES & FEAT_PMULL
+    /// * `"asimd"` or "neon" - FEAT_AdvSIMD
+    /// * `"bf16"` - FEAT_BF16
+    /// * `"bti"` - FEAT_BTI
+    /// * `"crc"` - FEAT_CRC
+    /// * `"cssc"` - FEAT_CSSC
+    /// * `"dit"` - FEAT_DIT
+    /// * `"dotprod"` - FEAT_DotProd
+    /// * `"dpb"` - FEAT_DPB
+    /// * `"dpb2"` - FEAT_DPB2
+    /// * `"ecv"` - FEAT_ECV
+    /// * `"f32mm"` - FEAT_F32MM
+    /// * `"f64mm"` - FEAT_F64MM
+    /// * `"faminmax"` - FEAT_FAMINMAX
+    /// * `"fcma"` - FEAT_FCMA
+    /// * `"fhm"` - FEAT_FHM
+    /// * `"flagm"` - FEAT_FLAGM
+    /// * `"flagm2"` - FEAT_FLAGM2
+    /// * `"fp"` - FEAT_FP
+    /// * `"fp16"` - FEAT_FP16
+    /// * `"fp8"` - FEAT_FP8
+    /// * `"fp8dot2"` - FEAT_FP8DOT2
+    /// * `"fp8dot4"` - FEAT_FP8DOT4
+    /// * `"fp8fma"` - FEAT_FP8FMA
+    /// * `"fpmr"` - FEAT_FPMR
+    /// * `"frintts"` - FEAT_FRINTTS
+    /// * `"hbc"` - FEAT_HBC
+    /// * `"i8mm"` - FEAT_I8MM
+    /// * `"jsconv"` - FEAT_JSCVT
+    /// * `"lse"` - FEAT_LSE
+    /// * `"lse128"` - FEAT_LSE128
+    /// * `"lse2"` - FEAT_LSE2
+    /// * `"lut"` - FEAT_LUT
+    /// * `"mops"` - FEAT_MOPS
+    /// * `"mte"` - FEAT_MTE & FEAT_MTE2
+    /// * `"paca"` - FEAT_PAuth (address authentication)
+    /// * `"pacg"` - FEAT_Pauth (generic authentication)
+    /// * `"pauth-lr"` - FEAT_PAuth_LR
+    /// * `"pmull"` - FEAT_PMULL
+    /// * `"rand"` - FEAT_RNG
+    /// * `"rcpc"` - FEAT_LRCPC
+    /// * `"rcpc2"` - FEAT_LRCPC2
+    /// * `"rcpc3"` - FEAT_LRCPC3
+    /// * `"rdm"` - FEAT_RDM
+    /// * `"sb"` - FEAT_SB
+    /// * `"sha2"` - FEAT_SHA1 & FEAT_SHA256
+    /// * `"sha3"` - FEAT_SHA512 & FEAT_SHA3
+    /// * `"sm4"` - FEAT_SM3 & FEAT_SM4
+    /// * `"sme"` - FEAT_SME
+    /// * `"sme-b16b16"` - FEAT_SME_B16B16
+    /// * `"sme-f16f16"` - FEAT_SME_F16F16
+    /// * `"sme-f64f64"` - FEAT_SME_F64F64
+    /// * `"sme-f8f16"` - FEAT_SME_F8F16
+    /// * `"sme-f8f32"` - FEAT_SME_F8F32
+    /// * `"sme-fa64"` - FEAT_SME_FA64
+    /// * `"sme-i16i64"` - FEAT_SME_I16I64
+    /// * `"sme-lutv2"` - FEAT_SME_LUTv2
+    /// * `"sme2"` - FEAT_SME2
+    /// * `"sme2p1"` - FEAT_SME2p1
+    /// * `"ssbs"` - FEAT_SSBS & FEAT_SSBS2
+    /// * `"ssve-fp8dot2"` - FEAT_SSVE_FP8DOT2
+    /// * `"ssve-fp8dot4"` - FEAT_SSVE_FP8DOT4
+    /// * `"ssve-fp8fma"` - FEAT_SSVE_FP8FMA
+    /// * `"sve"` - FEAT_SVE
+    /// * `"sve-b16b16"` - FEAT_SVE_B16B16 (SVE or SME Z-targeting instructions)
+    /// * `"sve2"` - FEAT_SVE2
+    /// * `"sve2-aes"` - FEAT_SVE_AES & FEAT_SVE_PMULL128 (SVE2 AES crypto)
+    /// * `"sve2-bitperm"` - FEAT_SVE2_BitPerm
+    /// * `"sve2-sha3"` - FEAT_SVE2_SHA3
+    /// * `"sve2-sm4"` - FEAT_SVE2_SM4
+    /// * `"sve2p1"` - FEAT_SVE2p1
+    /// * `"tme"` - FEAT_TME
+    /// * `"wfxt"` - FEAT_WFxT
+    ///
+    /// [docs]: https://developer.arm.com/documentation/ddi0487/latest
+    #[stable(feature = "simd_aarch64", since = "1.60.0")]
+    @BIND_FEATURE_NAME: "asimd"; "neon";
+    @NO_RUNTIME_DETECTION: "ras";
+    @NO_RUNTIME_DETECTION: "v8.1a";
+    @NO_RUNTIME_DETECTION: "v8.2a";
+    @NO_RUNTIME_DETECTION: "v8.3a";
+    @NO_RUNTIME_DETECTION: "v8.4a";
+    @NO_RUNTIME_DETECTION: "v8.5a";
+    @NO_RUNTIME_DETECTION: "v8.6a";
+    @NO_RUNTIME_DETECTION: "v8.7a";
+    @NO_RUNTIME_DETECTION: "v8.8a";
+    @NO_RUNTIME_DETECTION: "v8.9a";
+    @NO_RUNTIME_DETECTION: "v9.1a";
+    @NO_RUNTIME_DETECTION: "v9.2a";
+    @NO_RUNTIME_DETECTION: "v9.3a";
+    @NO_RUNTIME_DETECTION: "v9.4a";
+    @NO_RUNTIME_DETECTION: "v9.5a";
+    @NO_RUNTIME_DETECTION: "v9a";
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] asimd: "neon";
+    /// FEAT_AdvSIMD (Advanced SIMD/NEON)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] pmull: "pmull";
+    implied by target_features: ["aes"];
+    /// FEAT_PMULL (Polynomial Multiply) - Implied by `aes` target_feature
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] fp: "fp";
+    implied by target_features: ["neon"];
+    /// FEAT_FP (Floating point support) - Implied by `neon` target_feature
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] aes: "aes";
+    /// FEAT_AES (AES SIMD instructions) & FEAT_PMULL (PMULL{2}, 64-bit operand variants)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] bf16: "bf16";
+    /// FEAT_BF16 (BFloat16 type, plus MM instructions, plus ASIMD support)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] bti: "bti";
+    /// FEAT_BTI (Branch Target Identification)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] crc: "crc";
+    /// FEAT_CRC32 (Cyclic Redundancy Check)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] cssc: "cssc";
+    /// FEAT_CSSC (Common Short Sequence Compression instructions)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] dit: "dit";
+    /// FEAT_DIT (Data Independent Timing instructions)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] dpb: "dpb";
+    /// FEAT_DPB (aka dcpop - data cache clean to point of persistence)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] dpb2: "dpb2";
+    /// FEAT_DPB2 (aka dcpodp - data cache clean to point of deep persistence)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] dotprod: "dotprod";
+    /// FEAT_DotProd (Vector Dot-Product - ASIMDDP)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] ecv: "ecv";
+    /// FEAT_ECV (Enhanced Counter Virtualization)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] f32mm: "f32mm";
+    /// FEAT_F32MM (single-precision matrix multiplication)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] f64mm: "f64mm";
+    /// FEAT_F64MM (double-precision matrix multiplication)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] faminmax: "faminmax";
+    /// FEAT_FAMINMAX (FAMIN and FAMAX SIMD/SVE/SME instructions)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] fcma: "fcma";
+    /// FEAT_FCMA (float complex number operations)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] fhm: "fhm";
+    /// FEAT_FHM (fp16 multiplication instructions)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] flagm: "flagm";
+    /// FEAT_FLAGM (flag manipulation instructions)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] flagm2: "flagm2";
+    /// FEAT_FLAGM2 (flag manipulation instructions)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] fp16: "fp16";
+    /// FEAT_FP16 (Half-float support)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] fp8: "fp8";
+    /// FEAT_FP8 (F8CVT Instructions)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] fp8dot2: "fp8dot2";
+    /// FEAT_FP8DOT2 (F8DP2 Instructions)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] fp8dot4: "fp8dot4";
+    /// FEAT_FP8DOT4 (F8DP4 Instructions)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] fp8fma: "fp8fma";
+    /// FEAT_FP8FMA (F8FMA Instructions)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] fpmr: "fpmr";
+    without cfg check: true;
+    /// FEAT_FPMR (Special-purpose AArch64-FPMR register)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] frintts: "frintts";
+    /// FEAT_FRINTTS (float to integer rounding instructions)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] hbc: "hbc";
+    /// FEAT_HBC (Hinted conditional branches)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] i8mm: "i8mm";
+    /// FEAT_I8MM (integer matrix multiplication, plus ASIMD support)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] jsconv: "jsconv";
+    /// FEAT_JSCVT (JavaScript float conversion instructions)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] lse: "lse";
+    /// FEAT_LSE (Large System Extension - atomics)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] lse128: "lse128";
+    /// FEAT_LSE128 (128-bit atomics)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] lse2: "lse2";
+    /// FEAT_LSE2 (unaligned and register-pair atomics)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] lut: "lut";
+    /// FEAT_LUT (Lookup Table Instructions)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] mops: "mops";
+    /// FEAT_MOPS (Standardization of memory operations)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] mte: "mte";
+    /// FEAT_MTE & FEAT_MTE2 (Memory Tagging Extension)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] paca: "paca";
+    /// FEAT_PAuth (address authentication)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] pacg: "pacg";
+    /// FEAT_PAuth (generic authentication)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] pauth_lr: "pauth-lr";
+    /// FEAT_PAuth_LR
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] rand: "rand";
+    /// FEAT_RNG (Random Number Generator)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] rcpc: "rcpc";
+    /// FEAT_LRCPC (Release consistent Processor consistent)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] rcpc2: "rcpc2";
+    /// FEAT_LRCPC2 (RCPC with immediate offsets)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] rcpc3: "rcpc3";
+    /// FEAT_LRCPC3 (RCPC Instructions v3)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] rdm: "rdm";
+    /// FEAT_RDM (Rounding Doubling Multiply - ASIMDRDM)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sb: "sb";
+    /// FEAT_SB (speculation barrier)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sha2: "sha2";
+    /// FEAT_SHA1 & FEAT_SHA256 (SHA1 & SHA2-256 instructions)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sha3: "sha3";
+    /// FEAT_SHA512 & FEAT_SHA3 (SHA2-512 & SHA3 instructions)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sm4: "sm4";
+    /// FEAT_SM3 & FEAT_SM4 (SM3 & SM4 instructions)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme: "sme";
+    /// FEAT_SME (Scalable Matrix Extension)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme2: "sme2";
+    /// FEAT_SME2 (SME Version 2)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme2p1: "sme2p1";
+    /// FEAT_SME2p1 (SME Version 2.1)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_b16b16: "sme-b16b16";
+    /// FEAT_SME_B16B16
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_f16f16: "sme-f16f16";
+    /// FEAT_SME_F16F16 (Non-widening half-precision FP16 to FP16 arithmetic for SME2)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_f64f64: "sme-f64f64";
+    /// FEAT_SME_F64F64 (Double-precision floating-point outer product instructions)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_f8f16: "sme-f8f16";
+    /// FEAT_SME_F8F16
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_f8f32: "sme-f8f32";
+    /// FEAT_SME_F8F32
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_fa64: "sme-fa64";
+    /// FEAT_SME_FA64 (Full A64 instruction set support in Streaming SVE mode)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_i16i64: "sme-i16i64";
+    /// FEAT_SME_I16I64 (16-bit to 64-bit integer widening outer product instructions)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_lutv2: "sme-lutv2";
+    /// FEAT_SME_LUTv2 (LUTI4 Instruction)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] ssbs: "ssbs";
+    /// FEAT_SSBS & FEAT_SSBS2 (speculative store bypass safe)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] ssve_fp8dot2: "ssve-fp8dot2";
+    /// FEAT_SSVE_FP8DOT2
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] ssve_fp8dot4: "ssve-fp8dot4";
+    /// FEAT_SSVE_FP8DOT4
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] ssve_fp8fma: "ssve-fp8fma";
+    /// FEAT_SSVE_FP8FMA
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve: "sve";
+    /// FEAT_SVE (Scalable Vector Extension)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve2: "sve2";
+    /// FEAT_SVE2 (Scalable Vector Extension 2)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sve2p1: "sve2p1";
+    /// FEAT_SVE2p1 (Scalable Vector Extension 2.1)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve2_aes: "sve2-aes";
+    /// FEAT_SVE_AES & FEAT_SVE_PMULL128 (SVE2 AES crypto)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sve_b16b16: "sve-b16b16";
+    /// FEAT_SVE_B16B16 (SVE or SME Z-targeting instructions)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve2_bitperm: "sve2-bitperm";
+    /// FEAT_SVE_BitPerm (SVE2 bit permutation instructions)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve2_sha3: "sve2-sha3";
+    /// FEAT_SVE_SHA3 (SVE2 SHA3 crypto)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve2_sm4: "sve2-sm4";
+    /// FEAT_SVE_SM4 (SVE2 SM4 crypto)
+    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] tme: "tme";
+    /// FEAT_TME (Transactional Memory Extensions)
+    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] wfxt: "wfxt";
+    /// FEAT_WFxT (WFET and WFIT Instructions)
+}
diff --git a/library/std_detect/src/detect/arch/arm.rs b/library/std_detect/src/detect/arch/arm.rs
new file mode 100644
index 00000000000..c3c8883ce31
--- /dev/null
+++ b/library/std_detect/src/detect/arch/arm.rs
@@ -0,0 +1,29 @@
+//! Run-time feature detection on ARM Aarch32.
+
+features! {
+    @TARGET: arm;
+    @CFG: target_arch = "arm";
+    @MACRO_NAME: is_arm_feature_detected;
+    @MACRO_ATTRS:
+    /// Checks if `arm` feature is enabled.
+    #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")]
+    @NO_RUNTIME_DETECTION: "v7";
+    @NO_RUNTIME_DETECTION: "vfp2";
+    @NO_RUNTIME_DETECTION: "vfp3";
+    @NO_RUNTIME_DETECTION: "vfp4";
+    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] neon: "neon";
+    /// ARM Advanced SIMD (NEON) - Aarch32
+    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] pmull: "pmull";
+    without cfg check: true;
+    /// Polynomial Multiply
+    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] crc: "crc";
+    /// CRC32 (Cyclic Redundancy Check)
+    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] aes: "aes";
+    /// FEAT_AES (AES instructions)
+    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] sha2: "sha2";
+    /// FEAT_SHA1 & FEAT_SHA256 (SHA1 & SHA2-256 instructions)
+    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] i8mm: "i8mm";
+    /// FEAT_I8MM (integer matrix multiplication, plus ASIMD support)
+    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] dotprod: "dotprod";
+    /// FEAT_DotProd (Vector Dot-Product - ASIMDDP)
+}
diff --git a/library/std_detect/src/detect/arch/loongarch.rs b/library/std_detect/src/detect/arch/loongarch.rs
new file mode 100644
index 00000000000..68fc600fa8e
--- /dev/null
+++ b/library/std_detect/src/detect/arch/loongarch.rs
@@ -0,0 +1,51 @@
+//! Run-time feature detection on LoongArch.
+
+features! {
+    @TARGET: loongarch;
+    @CFG: any(target_arch = "loongarch32", target_arch = "loongarch64");
+    @MACRO_NAME: is_loongarch_feature_detected;
+    @MACRO_ATTRS:
+    /// Checks if `loongarch` feature is enabled.
+    /// Supported arguments are:
+    ///
+    /// * `"f"`
+    /// * `"d"`
+    /// * `"frecipe"`
+    /// * `"div32"`
+    /// * `"lsx"`
+    /// * `"lasx"`
+    /// * `"lam-bh"`
+    /// * `"lamcas"`
+    /// * `"ld-seq-sa"`
+    /// * `"scq"`
+    /// * `"lbt"`
+    /// * `"lvz"`
+    /// * `"ual"`
+    #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")]
+    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] f: "f";
+    /// F
+    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] d: "d";
+    /// D
+    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] frecipe: "frecipe";
+    /// Frecipe
+    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] div32: "div32";
+    /// Div32
+    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] lsx: "lsx";
+    /// LSX
+    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] lasx: "lasx";
+    /// LASX
+    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] lam_bh: "lam-bh";
+    /// LAM-BH
+    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] lamcas: "lamcas";
+    /// LAM-CAS
+    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] ld_seq_sa: "ld-seq-sa";
+    /// LD-SEQ-SA
+    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] scq: "scq";
+    /// SCQ
+    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] lbt: "lbt";
+    /// LBT
+    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] lvz: "lvz";
+    /// LVZ
+    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] ual: "ual";
+    /// UAL
+}
diff --git a/library/std_detect/src/detect/arch/mips.rs b/library/std_detect/src/detect/arch/mips.rs
new file mode 100644
index 00000000000..e185fdfcaac
--- /dev/null
+++ b/library/std_detect/src/detect/arch/mips.rs
@@ -0,0 +1,12 @@
+//! Run-time feature detection on MIPS.
+
+features! {
+    @TARGET: mips;
+    @CFG: target_arch = "mips";
+    @MACRO_NAME: is_mips_feature_detected;
+    @MACRO_ATTRS:
+    /// Checks if `mips` feature is enabled.
+    #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")]
+    @FEATURE: #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")] msa: "msa";
+    /// MIPS SIMD Architecture (MSA)
+}
diff --git a/library/std_detect/src/detect/arch/mips64.rs b/library/std_detect/src/detect/arch/mips64.rs
new file mode 100644
index 00000000000..69fe4869d30
--- /dev/null
+++ b/library/std_detect/src/detect/arch/mips64.rs
@@ -0,0 +1,12 @@
+//! Run-time feature detection on MIPS64.
+
+features! {
+    @TARGET: mips64;
+    @CFG: target_arch = "mips64";
+    @MACRO_NAME: is_mips64_feature_detected;
+    @MACRO_ATTRS:
+    /// Checks if `mips64` feature is enabled.
+    #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")]
+    @FEATURE: #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")] msa: "msa";
+    /// MIPS SIMD Architecture (MSA)
+}
diff --git a/library/std_detect/src/detect/arch/mod.rs b/library/std_detect/src/detect/arch/mod.rs
new file mode 100644
index 00000000000..b0be554ed89
--- /dev/null
+++ b/library/std_detect/src/detect/arch/mod.rs
@@ -0,0 +1,75 @@
+#![allow(dead_code)]
+
+use cfg_if::cfg_if;
+
+// Export the macros for all supported architectures.
+#[macro_use]
+mod x86;
+#[macro_use]
+mod arm;
+#[macro_use]
+mod aarch64;
+#[macro_use]
+mod riscv;
+#[macro_use]
+mod powerpc;
+#[macro_use]
+mod powerpc64;
+#[macro_use]
+mod mips;
+#[macro_use]
+mod mips64;
+#[macro_use]
+mod loongarch;
+#[macro_use]
+mod s390x;
+
+cfg_if! {
+    if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
+        #[stable(feature = "simd_x86", since = "1.27.0")]
+        pub use x86::*;
+    } else if #[cfg(target_arch = "arm")] {
+        #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")]
+        pub use arm::*;
+    } else if #[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))] {
+        #[stable(feature = "simd_aarch64", since = "1.60.0")]
+        pub use aarch64::*;
+    } else if #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))] {
+        #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")]
+        pub use riscv::*;
+    } else if #[cfg(target_arch = "powerpc")] {
+        #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")]
+        pub use powerpc::*;
+    } else if #[cfg(target_arch = "powerpc64")] {
+        #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")]
+        pub use powerpc64::*;
+    } else if #[cfg(target_arch = "mips")] {
+        #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")]
+        pub use mips::*;
+    } else if #[cfg(target_arch = "mips64")] {
+        #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")]
+        pub use mips64::*;
+    } else if #[cfg(any(target_arch = "loongarch32", target_arch = "loongarch64"))] {
+        #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")]
+        pub use loongarch::*;
+    } else if #[cfg(target_arch = "s390x")] {
+        #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+        pub use s390x::*;
+    } else {
+        // Unimplemented architecture:
+        #[doc(hidden)]
+        pub(crate) enum Feature {
+            Null
+        }
+        #[doc(hidden)]
+        #[unstable(feature = "stdarch_internal", issue = "none")]
+        pub mod __is_feature_detected {}
+
+        impl Feature {
+            #[doc(hidden)]
+            pub(crate) fn from_str(_s: &str) -> Result<Feature, ()> { Err(()) }
+            #[doc(hidden)]
+            pub(crate) fn to_str(self) -> &'static str { "" }
+        }
+    }
+}
diff --git a/library/std_detect/src/detect/arch/powerpc.rs b/library/std_detect/src/detect/arch/powerpc.rs
new file mode 100644
index 00000000000..c390993a48a
--- /dev/null
+++ b/library/std_detect/src/detect/arch/powerpc.rs
@@ -0,0 +1,30 @@
+//! Run-time feature detection on PowerPC.
+
+features! {
+    @TARGET: powerpc;
+    @CFG: target_arch = "powerpc";
+    @MACRO_NAME: is_powerpc_feature_detected;
+    @MACRO_ATTRS:
+    /// Checks if `powerpc` feature is enabled.
+    #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")]
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] altivec: "altivec";
+    /// Altivec
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] vsx: "vsx";
+    /// VSX
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8: "power8";
+    without cfg check: true;
+    /// Power8
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_altivec: "power8-altivec";
+    /// Power8 altivec
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_vector: "power8-vector";
+    /// Power8 vector
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_crypto: "power8-crypto";
+    /// Power8 crypto
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9: "power9";
+    without cfg check: true;
+    /// Power9
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9_altivec: "power9-altivec";
+    /// Power9 altivec
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9_vector: "power9-vector";
+    /// Power9 vector
+}
diff --git a/library/std_detect/src/detect/arch/powerpc64.rs b/library/std_detect/src/detect/arch/powerpc64.rs
new file mode 100644
index 00000000000..cf05baa6f79
--- /dev/null
+++ b/library/std_detect/src/detect/arch/powerpc64.rs
@@ -0,0 +1,30 @@
+//! Run-time feature detection on PowerPC64.
+
+features! {
+    @TARGET: powerpc64;
+    @CFG: target_arch = "powerpc64";
+    @MACRO_NAME: is_powerpc64_feature_detected;
+    @MACRO_ATTRS:
+    /// Checks if `powerpc` feature is enabled.
+    #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")]
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] altivec: "altivec";
+    /// Altivec
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] vsx: "vsx";
+    /// VSX
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8: "power8";
+    without cfg check: true;
+    /// Power8
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_altivec: "power8-altivec";
+    /// Power8 altivec
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_vector: "power8-vector";
+    /// Power8 vector
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_crypto: "power8-crypto";
+    /// Power8 crypto
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9: "power9";
+    without cfg check: true;
+    /// Power9
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9_altivec: "power9-altivec";
+    /// Power9 altivec
+    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9_vector: "power9-vector";
+    /// Power9 vector
+}
diff --git a/library/std_detect/src/detect/arch/riscv.rs b/library/std_detect/src/detect/arch/riscv.rs
new file mode 100644
index 00000000000..b86190d7bbf
--- /dev/null
+++ b/library/std_detect/src/detect/arch/riscv.rs
@@ -0,0 +1,344 @@
+//! Run-time feature detection on RISC-V.
+
+features! {
+    @TARGET: riscv;
+    @CFG: any(target_arch = "riscv32", target_arch = "riscv64");
+    @MACRO_NAME: is_riscv_feature_detected;
+    @MACRO_ATTRS:
+    /// A macro to test at *runtime* whether instruction sets are available on
+    /// RISC-V platforms.
+    ///
+    /// RISC-V standard defined the base sets and the extension sets.
+    /// The base sets are RV32I, RV64I, RV32E or RV128I. Any RISC-V platform
+    /// must support one base set and/or multiple extension sets.
+    ///
+    /// Any RISC-V standard instruction sets can be in state of either ratified,
+    /// frozen or draft. The version and status of current standard instruction
+    /// sets can be checked out from preface section of the [ISA manual].
+    ///
+    /// Platform may define and support their own custom instruction sets with
+    /// ISA prefix X. These sets are highly platform specific and should be
+    /// detected with their own platform support crates.
+    ///
+    /// [ISA manual]: https://riscv.org/specifications/ratified/
+    ///
+    /// # Platform-specific/agnostic Behavior and Availability
+    ///
+    /// Runtime detection depends on the platform-specific feature detection
+    /// facility and its availability per feature is
+    /// highly platform/version-specific.
+    ///
+    /// Still, a best-effort attempt is performed to enable subset/dependent
+    /// features if a superset feature is enabled regardless of the platform.
+    /// For instance, if the A extension (`"a"`) is enabled, its subsets (the
+    /// Zalrsc and Zaamo extensions; `"zalrsc"` and `"zaamo"`) are also enabled.
+    /// Likewise, if the F extension (`"f"`) is enabled, one of its dependencies
+    /// (the Zicsr extension `"zicsr"`) is also enabled.
+    ///
+    /// # Unprivileged Specification
+    ///
+    /// The supported ratified RISC-V instruction sets are as follows:
+    ///
+    /// * RV32E: `"rv32e"`
+    /// * RV32I: `"rv32i"`
+    /// * RV64I: `"rv64i"`
+    /// * A: `"a"`
+    ///   * Zaamo: `"zaamo"`
+    ///   * Zalrsc: `"zalrsc"`
+    /// * B: `"b"`
+    ///   * Zba: `"zba"`
+    ///   * Zbb: `"zbb"`
+    ///   * Zbs: `"zbs"`
+    /// * C: `"c"`
+    ///   * Zca: `"zca"`
+    ///   * Zcd: `"zcd"` (if D is enabled)
+    ///   * Zcf: `"zcf"` (if F is enabled on RV32)
+    /// * D: `"d"`
+    /// * F: `"f"`
+    /// * M: `"m"`
+    /// * Q: `"q"`
+    /// * V: `"v"`
+    ///   * Zve32x: `"zve32x"`
+    ///   * Zve32f: `"zve32f"`
+    ///   * Zve64x: `"zve64x"`
+    ///   * Zve64f: `"zve64f"`
+    ///   * Zve64d: `"zve64d"`
+    /// * Zicbom: `"zicbom"`
+    /// * Zicboz: `"zicboz"`
+    /// * Zicntr: `"zicntr"`
+    /// * Zicond: `"zicond"`
+    /// * Zicsr: `"zicsr"`
+    /// * Zifencei: `"zifencei"`
+    /// * Zihintntl: `"zihintntl"`
+    /// * Zihintpause: `"zihintpause"`
+    /// * Zihpm: `"zihpm"`
+    /// * Zimop: `"zimop"`
+    /// * Zacas: `"zacas"`
+    /// * Zawrs: `"zawrs"`
+    /// * Zfa: `"zfa"`
+    /// * Zfbfmin: `"zfbfmin"`
+    /// * Zfh: `"zfh"`
+    ///   * Zfhmin: `"zfhmin"`
+    /// * Zfinx: `"zfinx"`
+    /// * Zdinx: `"zdinx"`
+    /// * Zhinx: `"zhinx"`
+    ///   * Zhinxmin: `"zhinxmin"`
+    /// * Zcb: `"zcb"`
+    /// * Zcmop: `"zcmop"`
+    /// * Zbc: `"zbc"`
+    /// * Zbkb: `"zbkb"`
+    /// * Zbkc: `"zbkc"`
+    /// * Zbkx: `"zbkx"`
+    /// * Zk: `"zk"`
+    /// * Zkn: `"zkn"`
+    ///   * Zknd: `"zknd"`
+    ///   * Zkne: `"zkne"`
+    ///   * Zknh: `"zknh"`
+    /// * Zkr: `"zkr"`
+    /// * Zks: `"zks"`
+    ///   * Zksed: `"zksed"`
+    ///   * Zksh: `"zksh"`
+    /// * Zkt: `"zkt"`
+    /// * Zvbb: `"zvbb"`
+    /// * Zvbc: `"zvbc"`
+    /// * Zvfbfmin: `"zvfbfmin"`
+    /// * Zvfbfwma: `"zvfbfwma"`
+    /// * Zvfh: `"zvfh"`
+    ///   * Zvfhmin: `"zvfhmin"`
+    /// * Zvkb: `"zvkb"`
+    /// * Zvkg: `"zvkg"`
+    /// * Zvkn: `"zvkn"`
+    ///   * Zvkned: `"zvkned"`
+    ///   * Zvknha: `"zvknha"`
+    ///   * Zvknhb: `"zvknhb"`
+    /// * Zvknc: `"zvknc"`
+    /// * Zvkng: `"zvkng"`
+    /// * Zvks: `"zvks"`
+    ///   * Zvksed: `"zvksed"`
+    ///   * Zvksh: `"zvksh"`
+    /// * Zvksc: `"zvksc"`
+    /// * Zvksg: `"zvksg"`
+    /// * Zvkt: `"zvkt"`
+    /// * Ztso: `"ztso"`
+    ///
+    /// There's also bases and extensions marked as standard instruction set,
+    /// but they are in frozen or draft state. These instruction sets are also
+    /// reserved by this macro and can be detected in the future platforms.
+    ///
+    /// Draft RISC-V instruction sets:
+    ///
+    /// * RV128I: `"rv128i"`
+    /// * J: `"j"`
+    /// * P: `"p"`
+    /// * Zam: `"zam"`
+    ///
+    /// # Performance Hints
+    ///
+    /// The two features below define performance hints for unaligned
+    /// scalar/vector memory accesses, respectively.  If enabled, it denotes that
+    /// corresponding unaligned memory access is reasonably fast.
+    ///
+    /// * `"unaligned-scalar-mem"`
+    ///   * Runtime detection requires Linux kernel version 6.4 or later.
+    /// * `"unaligned-vector-mem"`
+    ///   * Runtime detection requires Linux kernel version 6.13 or later.
+    #[stable(feature = "riscv_ratified", since = "1.78.0")]
+
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] rv32i: "rv32i";
+    without cfg check: true;
+    /// RV32I Base Integer Instruction Set
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] rv32e: "rv32e";
+    without cfg check: true;
+    /// RV32E Base Integer Instruction Set
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] rv64i: "rv64i";
+    without cfg check: true;
+    /// RV64I Base Integer Instruction Set
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] rv128i: "rv128i";
+    without cfg check: true;
+    /// RV128I Base Integer Instruction Set
+
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] unaligned_scalar_mem: "unaligned-scalar-mem";
+    /// Has reasonably performant unaligned scalar
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] unaligned_vector_mem: "unaligned-vector-mem";
+    /// Has reasonably performant unaligned vector
+
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicsr: "zicsr";
+    /// "Zicsr" Extension for Control and Status Register (CSR) Instructions
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicntr: "zicntr";
+    /// "Zicntr" Extension for Base Counters and Timers
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zihpm: "zihpm";
+    /// "Zihpm" Extension for Hardware Performance Counters
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zifencei: "zifencei";
+    /// "Zifencei" Extension for Instruction-Fetch Fence
+
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zihintntl: "zihintntl";
+    /// "Zihintntl" Extension for Non-Temporal Locality Hints
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zihintpause: "zihintpause";
+    /// "Zihintpause" Extension for Pause Hint
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zimop: "zimop";
+    /// "Zimop" Extension for May-Be-Operations
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicbom: "zicbom";
+    /// "Zicbom" Extension for Cache-Block Management Instructions
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicboz: "zicboz";
+    /// "Zicboz" Extension for Cache-Block Zero Instruction
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicond: "zicond";
+    /// "Zicond" Extension for Integer Conditional Operations
+
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] m: "m";
+    /// "M" Extension for Integer Multiplication and Division
+
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] a: "a";
+    /// "A" Extension for Atomic Instructions
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zalrsc: "zalrsc";
+    /// "Zalrsc" Extension for Load-Reserved/Store-Conditional Instructions
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zaamo: "zaamo";
+    /// "Zaamo" Extension for Atomic Memory Operations
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zawrs: "zawrs";
+    /// "Zawrs" Extension for Wait-on-Reservation-Set Instructions
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zacas: "zacas";
+    /// "Zacas" Extension for Atomic Compare-and-Swap (CAS) Instructions
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zam: "zam";
+    without cfg check: true;
+    /// "Zam" Extension for Misaligned Atomics
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] ztso: "ztso";
+    /// "Ztso" Extension for Total Store Ordering
+
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] f: "f";
+    /// "F" Extension for Single-Precision Floating-Point
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] d: "d";
+    /// "D" Extension for Double-Precision Floating-Point
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] q: "q";
+    without cfg check: true;
+    /// "Q" Extension for Quad-Precision Floating-Point
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zfh: "zfh";
+    /// "Zfh" Extension for Half-Precision Floating-Point
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zfhmin: "zfhmin";
+    /// "Zfhmin" Extension for Minimal Half-Precision Floating-Point
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zfa: "zfa";
+    /// "Zfa" Extension for Additional Floating-Point Instructions
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zfbfmin: "zfbfmin";
+    /// "Zfbfmin" Extension for Scalar BF16 Converts
+
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zfinx: "zfinx";
+    /// "Zfinx" Extension for Single-Precision Floating-Point in Integer Registers
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zdinx: "zdinx";
+    /// "Zdinx" Extension for Double-Precision Floating-Point in Integer Registers
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zhinx: "zhinx";
+    /// "Zhinx" Extension for Half-Precision Floating-Point in Integer Registers
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zhinxmin: "zhinxmin";
+    /// "Zhinxmin" Extension for Minimal Half-Precision Floating-Point in Integer Registers
+
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] c: "c";
+    /// "C" Extension for Compressed Instructions
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zca: "zca";
+    /// "Zca" Compressed Instructions excluding Floating-Point Loads/Stores
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcf: "zcf";
+    without cfg check: true;
+    /// "Zcf" Compressed Instructions for Single-Precision Floating-Point Loads/Stores on RV32
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcd: "zcd";
+    without cfg check: true;
+    /// "Zcd" Compressed Instructions for Double-Precision Floating-Point Loads/Stores
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcb: "zcb";
+    /// "Zcb" Simple Code-size Saving Compressed Instructions
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcmop: "zcmop";
+    /// "Zcmop" Extension for Compressed May-Be-Operations
+
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] b: "b";
+    /// "B" Extension for Bit Manipulation
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zba: "zba";
+    /// "Zba" Extension for Address Generation
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbb: "zbb";
+    /// "Zbb" Extension for Basic Bit-Manipulation
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbc: "zbc";
+    /// "Zbc" Extension for Carry-less Multiplication
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbs: "zbs";
+    /// "Zbs" Extension for Single-Bit Instructions
+
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbkb: "zbkb";
+    /// "Zbkb" Extension for Bit-Manipulation for Cryptography
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbkc: "zbkc";
+    /// "Zbkc" Extension for Carry-less Multiplication for Cryptography
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbkx: "zbkx";
+    /// "Zbkx" Extension for Crossbar Permutations
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zknd: "zknd";
+    /// "Zknd" Cryptography Extension for NIST Suite: AES Decryption
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zkne: "zkne";
+    /// "Zkne" Cryptography Extension for NIST Suite: AES Encryption
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zknh: "zknh";
+    /// "Zknh" Cryptography Extension for NIST Suite: Hash Function Instructions
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zksed: "zksed";
+    /// "Zksed" Cryptography Extension for ShangMi Suite: SM4 Block Cipher Instructions
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zksh: "zksh";
+    /// "Zksh" Cryptography Extension for ShangMi Suite: SM3 Hash Function Instructions
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zkr: "zkr";
+    /// "Zkr" Entropy Source Extension
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zkn: "zkn";
+    /// "Zkn" Cryptography Extension for NIST Algorithm Suite
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zks: "zks";
+    /// "Zks" Cryptography Extension for ShangMi Algorithm Suite
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zk: "zk";
+    /// "Zk" Cryptography Extension for Standard Scalar Cryptography
+    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zkt: "zkt";
+    /// "Zkt" Cryptography Extension for Data Independent Execution Latency
+
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] v: "v";
+    /// "V" Extension for Vector Operations
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zve32x: "zve32x";
+    /// "Zve32x" Vector Extension for Embedded Processors (32-bit+; Integer)
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zve32f: "zve32f";
+    /// "Zve32f" Vector Extension for Embedded Processors (32-bit+; with Single-Precision Floating-Point)
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zve64x: "zve64x";
+    /// "Zve64x" Vector Extension for Embedded Processors (64-bit+; Integer)
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zve64f: "zve64f";
+    /// "Zve64f" Vector Extension for Embedded Processors (64-bit+; with Single-Precision Floating-Point)
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zve64d: "zve64d";
+    /// "Zve64d" Vector Extension for Embedded Processors (64-bit+; with Double-Precision Floating-Point)
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvfh: "zvfh";
+    /// "Zvfh" Vector Extension for Half-Precision Floating-Point
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvfhmin: "zvfhmin";
+    /// "Zvfhmin" Vector Extension for Minimal Half-Precision Floating-Point
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvfbfmin: "zvfbfmin";
+    /// "Zvfbfmin" Vector Extension for BF16 Converts
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvfbfwma: "zvfbfwma";
+    /// "Zvfbfwma" Vector Extension for BF16 Widening Multiply-Add
+
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvbb: "zvbb";
+    /// "Zvbb" Extension for Vector Basic Bit-Manipulation
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvbc: "zvbc";
+    /// "Zvbc" Extension for Vector Carryless Multiplication
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkb: "zvkb";
+    /// "Zvkb" Extension for Vector Cryptography Bit-Manipulation
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkg: "zvkg";
+    /// "Zvkg" Cryptography Extension for Vector GCM/GMAC
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkned: "zvkned";
+    /// "Zvkned" Cryptography Extension for NIST Suite: Vector AES Block Cipher
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvknha: "zvknha";
+    /// "Zvknha" Cryptography Extension for Vector SHA-2 Secure Hash (SHA-256)
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvknhb: "zvknhb";
+    /// "Zvknhb" Cryptography Extension for Vector SHA-2 Secure Hash (SHA-256/512)
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvksed: "zvksed";
+    /// "Zvksed" Cryptography Extension for ShangMi Suite: Vector SM4 Block Cipher
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvksh: "zvksh";
+    /// "Zvksh" Cryptography Extension for ShangMi Suite: Vector SM3 Secure Hash
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkn: "zvkn";
+    /// "Zvkn" Cryptography Extension for NIST Algorithm Suite
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvknc: "zvknc";
+    /// "Zvknc" Cryptography Extension for NIST Algorithm Suite with Carryless Multiply
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkng: "zvkng";
+    /// "Zvkng" Cryptography Extension for NIST Algorithm Suite with GCM
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvks: "zvks";
+    /// "Zvks" Cryptography Extension for ShangMi Algorithm Suite
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvksc: "zvksc";
+    /// "Zvksc" Cryptography Extension for ShangMi Algorithm Suite with Carryless Multiply
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvksg: "zvksg";
+    /// "Zvksg" Cryptography Extension for ShangMi Algorithm Suite with GCM
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkt: "zvkt";
+    /// "Zvkt" Extension for Vector Data-Independent Execution Latency
+
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] j: "j";
+    without cfg check: true;
+    /// "J" Extension for Dynamically Translated Languages
+    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] p: "p";
+    without cfg check: true;
+    /// "P" Extension for Packed-SIMD Instructions
+}
diff --git a/library/std_detect/src/detect/arch/s390x.rs b/library/std_detect/src/detect/arch/s390x.rs
new file mode 100644
index 00000000000..4c20d011680
--- /dev/null
+++ b/library/std_detect/src/detect/arch/s390x.rs
@@ -0,0 +1,81 @@
+//! Run-time feature detection on s390x.
+
+features! {
+    @TARGET: s390x;
+    @CFG: target_arch = "s390x";
+    @MACRO_NAME: is_s390x_feature_detected;
+    @MACRO_ATTRS:
+    /// Checks if `s390x` feature is enabled.
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] concurrent_functions: "concurrent-functions";
+    /// s390x concurrent-functions facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] deflate_conversion: "deflate-conversion";
+    /// s390x deflate-conversion facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] enhanced_sort: "enhanced-sort";
+    /// s390x enhanced-sort facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] guarded_storage: "guarded-storage";
+    /// s390x guarded-storage facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] high_word: "high-word";
+    /// s390x high-word facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension3: "message-security-assist-extension3";
+    /// s390x message-security-assist-extension3 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension4: "message-security-assist-extension4";
+    /// s390x message-security-assist-extension4 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension5: "message-security-assist-extension5";
+    /// s390x message-security-assist-extension5 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension8: "message-security-assist-extension8";
+    /// s390x message-security-assist-extension8 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension9: "message-security-assist-extension9";
+    /// s390x message-security-assist-extension9 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension12: "message-security-assist-extension12";
+    /// s390x message-security-assist-extension12 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] miscellaneous_extensions_2: "miscellaneous-extensions-2";
+    /// s390x miscellaneous-extensions-2 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] miscellaneous_extensions_3: "miscellaneous-extensions-3";
+    /// s390x miscellaneous-extensions-3 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] miscellaneous_extensions_4: "miscellaneous-extensions-4";
+    /// s390x miscellaneous-extensions-4 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] nnp_assist: "nnp-assist";
+    /// s390x nnp-assist facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] transactional_execution: "transactional-execution";
+    /// s390x transactional-execution facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector: "vector";
+    /// s390x vector facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_enhancements_1: "vector-enhancements-1";
+    /// s390x vector-enhancements-1 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_enhancements_2: "vector-enhancements-2";
+    /// s390x vector-enhancements-2 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_enhancements_3: "vector-enhancements-3";
+    /// s390x vector-enhancements-3 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_packed_decimal: "vector-packed-decimal";
+    /// s390x vector-packed-decimal facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_packed_decimal_enhancement: "vector-packed-decimal-enhancement";
+    /// s390x vector-packed-decimal-enhancement facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_packed_decimal_enhancement_2: "vector-packed-decimal-enhancement-2";
+    /// s390x vector-packed-decimal-enhancement-2 facility
+    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
+    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_packed_decimal_enhancement_3: "vector-packed-decimal-enhancement-3";
+    /// s390x vector-packed-decimal-enhancement-3 facility
+}
diff --git a/library/std_detect/src/detect/arch/x86.rs b/library/std_detect/src/detect/arch/x86.rs
new file mode 100644
index 00000000000..28b3e3cfb35
--- /dev/null
+++ b/library/std_detect/src/detect/arch/x86.rs
@@ -0,0 +1,278 @@
+//! This module implements minimal run-time feature detection for x86.
+//!
+//! The features are detected using the `detect_features` function below.
+//! This function uses the CPUID instruction to read the feature flags from the
+//! CPU and encodes them in a `usize` where each bit position represents
+//! whether a feature is available (bit is set) or unavailable (bit is cleared).
+//!
+//! The enum `Feature` is used to map bit positions to feature names, and the
+//! the `__crate::detect::check_for!` macro is used to map string literals (e.g.,
+//! "avx") to these bit positions (e.g., `Feature::avx`).
+//!
+//! The run-time feature detection is performed by the
+//! `__crate::detect::check_for(Feature) -> bool` function. On its first call,
+//! this functions queries the CPU for the available features and stores them
+//! in a global `AtomicUsize` variable. The query is performed by just checking
+//! whether the feature bit in this global variable is set or cleared.
+
+features! {
+    @TARGET: x86;
+    @CFG: any(target_arch = "x86", target_arch = "x86_64");
+    @MACRO_NAME: is_x86_feature_detected;
+    @MACRO_ATTRS:
+    /// A macro to test at *runtime* whether a CPU feature is available on
+    /// x86/x86-64 platforms.
+    ///
+    /// This macro is provided in the standard library and will detect at runtime
+    /// whether the specified CPU feature is detected. This does **not** resolve at
+    /// compile time unless the specified feature is already enabled for the entire
+    /// crate. Runtime detection currently relies mostly on the `cpuid` instruction.
+    ///
+    /// This macro only takes one argument which is a string literal of the feature
+    /// being tested for. The feature names supported are the lowercase versions of
+    /// the ones defined by Intel in [their documentation][docs].
+    ///
+    /// ## Supported arguments
+    ///
+    /// This macro supports the same names that `#[target_feature]` supports. Unlike
+    /// `#[target_feature]`, however, this macro does not support names separated
+    /// with a comma. Instead testing for multiple features must be done through
+    /// separate macro invocations for now.
+    ///
+    /// Supported arguments are:
+    ///
+    /// * `"aes"`
+    /// * `"pclmulqdq"`
+    /// * `"rdrand"`
+    /// * `"rdseed"`
+    /// * `"tsc"`
+    /// * `"mmx"`
+    /// * `"sse"`
+    /// * `"sse2"`
+    /// * `"sse3"`
+    /// * `"ssse3"`
+    /// * `"sse4.1"`
+    /// * `"sse4.2"`
+    /// * `"sse4a"`
+    /// * `"sha"`
+    /// * `"avx"`
+    /// * `"avx2"`
+    /// * `"sha512"`
+    /// * `"sm3"`
+    /// * `"sm4"`
+    /// * `"avx512f"`
+    /// * `"avx512cd"`
+    /// * `"avx512er"`
+    /// * `"avx512pf"`
+    /// * `"avx512bw"`
+    /// * `"avx512dq"`
+    /// * `"avx512vl"`
+    /// * `"avx512ifma"`
+    /// * `"avx512vbmi"`
+    /// * `"avx512vpopcntdq"`
+    /// * `"avx512vbmi2"`
+    /// * `"gfni"`
+    /// * `"vaes"`
+    /// * `"vpclmulqdq"`
+    /// * `"avx512vnni"`
+    /// * `"avx512bitalg"`
+    /// * `"avx512bf16"`
+    /// * `"avx512vp2intersect"`
+    /// * `"avx512fp16"`
+    /// * `"avxvnni"`
+    /// * `"avxifma"`
+    /// * `"avxneconvert"`
+    /// * `"avxvnniint8"`
+    /// * `"avxvnniint16"`
+    /// * `"amx-tile"`
+    /// * `"amx-int8"`
+    /// * `"amx-bf16"`
+    /// * `"amx-fp16"`
+    /// * `"amx-complex"`
+    /// * `"amx-avx512"`
+    /// * `"amx-fp8"`
+    /// * `"amx-movrs"`
+    /// * `"amx-tf32"`
+    /// * `"amx-transpose"`
+    /// * `"f16c"`
+    /// * `"fma"`
+    /// * `"bmi1"`
+    /// * `"bmi2"`
+    /// * `"abm"`
+    /// * `"lzcnt"`
+    /// * `"tbm"`
+    /// * `"popcnt"`
+    /// * `"fxsr"`
+    /// * `"xsave"`
+    /// * `"xsaveopt"`
+    /// * `"xsaves"`
+    /// * `"xsavec"`
+    /// * `"cmpxchg16b"`
+    /// * `"kl"`
+    /// * `"widekl"`
+    /// * `"adx"`
+    /// * `"rtm"`
+    /// * `"movbe"`
+    /// * `"ermsb"`
+    /// * `"movrs"`
+    /// * `"xop"`
+    ///
+    /// [docs]: https://software.intel.com/sites/landingpage/IntrinsicsGuide
+    #[stable(feature = "simd_x86", since = "1.27.0")]
+    @BIND_FEATURE_NAME: "abm"; "lzcnt"; // abm is a synonym for lzcnt
+    @BIND_FEATURE_NAME: "avx512gfni"; "gfni"; #[deprecated(since = "1.67.0", note = "the `avx512gfni` feature has been renamed to `gfni`")];
+    @BIND_FEATURE_NAME: "avx512vaes"; "vaes"; #[deprecated(since = "1.67.0", note = "the `avx512vaes` feature has been renamed to `vaes`")];
+    @BIND_FEATURE_NAME: "avx512vpclmulqdq"; "vpclmulqdq"; #[deprecated(since = "1.67.0", note = "the `avx512vpclmulqdq` feature has been renamed to `vpclmulqdq`")];
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] aes: "aes";
+    /// AES (Advanced Encryption Standard New Instructions AES-NI)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] pclmulqdq: "pclmulqdq";
+    /// CLMUL (Carry-less Multiplication)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] rdrand: "rdrand";
+    /// RDRAND
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] rdseed: "rdseed";
+    /// RDSEED
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] tsc: "tsc";
+    without cfg check: true;
+    /// TSC (Time Stamp Counter)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] mmx: "mmx";
+    without cfg check: true;
+    /// MMX (MultiMedia eXtensions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse: "sse";
+    /// SSE (Streaming SIMD Extensions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse2: "sse2";
+    /// SSE2 (Streaming SIMD Extensions 2)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse3: "sse3";
+    /// SSE3 (Streaming SIMD Extensions 3)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] ssse3: "ssse3";
+    /// SSSE3 (Supplemental Streaming SIMD Extensions 3)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse4_1: "sse4.1";
+    /// SSE4.1 (Streaming SIMD Extensions 4.1)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse4_2: "sse4.2";
+    /// SSE4.2 (Streaming SIMD Extensions 4.2)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse4a: "sse4a";
+    /// SSE4a (Streaming SIMD Extensions 4a)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sha: "sha";
+    /// SHA
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx: "avx";
+    /// AVX (Advanced Vector Extensions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx2: "avx2";
+    /// AVX2 (Advanced Vector Extensions 2)
+    @FEATURE: #[stable(feature = "sha512_sm_x86", since = "1.89.0")] sha512: "sha512";
+    /// SHA512
+    @FEATURE: #[stable(feature = "sha512_sm_x86", since = "1.89.0")] sm3: "sm3";
+    /// SM3
+    @FEATURE: #[stable(feature = "sha512_sm_x86", since = "1.89.0")] sm4: "sm4";
+    /// SM4
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512f: "avx512f" ;
+    /// AVX-512 F (Foundation)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512cd: "avx512cd" ;
+    /// AVX-512 CD (Conflict Detection Instructions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512er: "avx512er";
+    without cfg check: true;
+    /// AVX-512 ER (Expo nential and Reciprocal Instructions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512pf: "avx512pf";
+    without cfg check: true;
+    /// AVX-512 PF (Prefetch Instructions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512bw: "avx512bw";
+    /// AVX-512 BW (Byte and Word Instructions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512dq: "avx512dq";
+    /// AVX-512 DQ (Doubleword and Quadword)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vl: "avx512vl";
+    /// AVX-512 VL (Vector Length Extensions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512ifma: "avx512ifma";
+    /// AVX-512 IFMA (Integer Fused Multiply Add)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vbmi: "avx512vbmi";
+    /// AVX-512 VBMI (Vector Byte Manipulation Instructions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vpopcntdq: "avx512vpopcntdq";
+    /// AVX-512 VPOPCNTDQ (Vector Population Count Doubleword and Quadword)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vbmi2: "avx512vbmi2";
+    /// AVX-512 VBMI2 (Additional byte, word, dword and qword capabilities)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] gfni: "gfni";
+    /// AVX-512 GFNI (Galois Field New Instruction)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] vaes: "vaes";
+    /// AVX-512 VAES (Vector AES instruction)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] vpclmulqdq: "vpclmulqdq";
+    /// AVX-512 VPCLMULQDQ (Vector PCLMULQDQ instructions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vnni: "avx512vnni";
+    /// AVX-512 VNNI (Vector Neural Network Instructions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512bitalg: "avx512bitalg";
+    /// AVX-512 BITALG (Support for VPOPCNT\[B,W\] and VPSHUFBITQMB)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512bf16: "avx512bf16";
+    /// AVX-512 BF16 (BFLOAT16 instructions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vp2intersect: "avx512vp2intersect";
+    /// AVX-512 P2INTERSECT
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512fp16: "avx512fp16";
+    /// AVX-512 FP16 (FLOAT16 instructions)
+    @FEATURE: #[stable(feature = "avx512_target_feature", since = "1.89.0")] avxifma: "avxifma";
+    /// AVX-IFMA (Integer Fused Multiply Add)
+    @FEATURE: #[stable(feature = "avx512_target_feature", since = "1.89.0")] avxneconvert: "avxneconvert";
+    /// AVX-NE-CONVERT (Exceptionless Convert)
+    @FEATURE: #[stable(feature = "avx512_target_feature", since = "1.89.0")] avxvnni: "avxvnni";
+    /// AVX-VNNI (Vector Neural Network Instructions)
+    @FEATURE: #[stable(feature = "avx512_target_feature", since = "1.89.0")] avxvnniint16: "avxvnniint16";
+    /// AVX-VNNI_INT8 (VNNI with 16-bit Integers)
+    @FEATURE: #[stable(feature = "avx512_target_feature", since = "1.89.0")] avxvnniint8: "avxvnniint8";
+    /// AVX-VNNI_INT16 (VNNI with 8-bit integers)
+    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_tile: "amx-tile";
+    /// AMX (Advanced Matrix Extensions) - Tile load/store
+    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_int8: "amx-int8";
+    /// AMX-INT8 (Operations on 8-bit integers)
+    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_bf16: "amx-bf16";
+    /// AMX-BF16 (BFloat16 Operations)
+    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_fp16: "amx-fp16";
+    /// AMX-FP16 (Float16 Operations)
+    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_complex: "amx-complex";
+    /// AMX-COMPLEX (Complex number Operations)
+    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_avx512: "amx-avx512";
+    /// AMX-AVX512 (AVX512 operations extended to matrices)
+    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_fp8: "amx-fp8";
+    /// AMX-FP8 (Float8 Operations)
+    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_movrs: "amx-movrs";
+    /// AMX-MOVRS (Matrix MOVERS operations)
+    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_tf32: "amx-tf32";
+    /// AMX-TF32 (TensorFloat32 Operations)
+    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_transpose: "amx-transpose";
+    /// AMX-TRANSPOSE (Matrix Transpose Operations)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] f16c: "f16c";
+    /// F16C (Conversions between IEEE-754 `binary16` and `binary32` formats)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] fma: "fma";
+    /// FMA (Fused Multiply Add)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] bmi1: "bmi1" ;
+    /// BMI1 (Bit Manipulation Instructions 1)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] bmi2: "bmi2" ;
+    /// BMI2 (Bit Manipulation Instructions 2)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] lzcnt: "lzcnt";
+    /// ABM (Advanced Bit Manipulation) / LZCNT (Leading Zero Count)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] tbm: "tbm";
+    /// TBM (Trailing Bit Manipulation)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] popcnt: "popcnt";
+    /// POPCNT (Population Count)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] fxsr: "fxsr";
+    /// FXSR (Floating-point context fast save and restore)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] xsave: "xsave";
+    /// XSAVE (Save Processor Extended States)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] xsaveopt: "xsaveopt";
+    /// XSAVEOPT (Save Processor Extended States Optimized)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] xsaves: "xsaves";
+    /// XSAVES (Save Processor Extended States Supervisor)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] xsavec: "xsavec";
+    /// XSAVEC (Save Processor Extended States Compacted)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] cmpxchg16b: "cmpxchg16b";
+    /// CMPXCH16B (16-byte compare-and-swap instruction)
+    @FEATURE: #[stable(feature = "keylocker_x86", since = "1.89.0")] kl: "kl";
+    /// Intel Key Locker
+    @FEATURE: #[stable(feature = "keylocker_x86", since = "1.89.0")] widekl: "widekl";
+    /// Intel Key Locker Wide
+    @FEATURE: #[stable(feature = "simd_x86_adx", since = "1.33.0")] adx: "adx";
+    /// ADX, Intel ADX (Multi-Precision Add-Carry Instruction Extensions)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] rtm: "rtm";
+    /// RTM, Intel (Restricted Transactional Memory)
+    @FEATURE: #[stable(feature = "movbe_target_feature", since = "1.67.0")] movbe: "movbe";
+    /// MOVBE (Move Data After Swapping Bytes)
+    @FEATURE: #[unstable(feature = "movrs_target_feature", issue = "137976")] movrs: "movrs";
+    /// MOVRS (Move data with the read-shared hint)
+    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] ermsb: "ermsb";
+    /// ERMSB, Enhanced REP MOVSB and STOSB
+    @FEATURE: #[unstable(feature = "xop_target_feature", issue = "127208")] xop: "xop";
+    /// XOP: eXtended Operations (AMD)
+}
diff --git a/library/std_detect/src/detect/bit.rs b/library/std_detect/src/detect/bit.rs
new file mode 100644
index 00000000000..6f06c5523e4
--- /dev/null
+++ b/library/std_detect/src/detect/bit.rs
@@ -0,0 +1,9 @@
+//! Bit manipulation utilities.
+
+/// Tests the `bit` of `x`.
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn test(x: usize, bit: u32) -> bool {
+    debug_assert!(bit < usize::BITS, "bit index out-of-bounds");
+    x & (1 << bit) != 0
+}
diff --git a/library/std_detect/src/detect/cache.rs b/library/std_detect/src/detect/cache.rs
new file mode 100644
index 00000000000..83bcedea612
--- /dev/null
+++ b/library/std_detect/src/detect/cache.rs
@@ -0,0 +1,223 @@
+//! Caches run-time feature detection so that it only needs to be computed
+//! once.
+
+#![allow(dead_code)] // not used on all platforms
+
+use core::sync::atomic::Ordering;
+
+use core::sync::atomic::AtomicUsize;
+
+/// Sets the `bit` of `x`.
+#[inline]
+const fn set_bit(x: u128, bit: u32) -> u128 {
+    x | 1 << bit
+}
+
+/// Tests the `bit` of `x`.
+#[inline]
+const fn test_bit(x: u128, bit: u32) -> bool {
+    x & (1 << bit) != 0
+}
+
+/// Unset the `bit of `x`.
+#[inline]
+const fn unset_bit(x: u128, bit: u32) -> u128 {
+    x & !(1 << bit)
+}
+
+/// Maximum number of features that can be cached.
+const CACHE_CAPACITY: u32 = 93;
+
+/// This type is used to initialize the cache
+// The derived `Default` implementation will initialize the field to zero,
+// which is what we want.
+#[derive(Copy, Clone, Default, PartialEq, Eq)]
+pub(crate) struct Initializer(u128);
+
+// NOTE: the `debug_assert!` would catch that we do not add more Features than
+// the one fitting our cache.
+impl Initializer {
+    /// Tests the `bit` of the cache.
+    #[inline]
+    pub(crate) fn test(self, bit: u32) -> bool {
+        debug_assert!(
+            bit < CACHE_CAPACITY,
+            "too many features, time to increase the cache size!"
+        );
+        test_bit(self.0, bit)
+    }
+
+    /// Sets the `bit` of the cache.
+    #[inline]
+    pub(crate) fn set(&mut self, bit: u32) {
+        debug_assert!(
+            bit < CACHE_CAPACITY,
+            "too many features, time to increase the cache size!"
+        );
+        let v = self.0;
+        self.0 = set_bit(v, bit);
+    }
+
+    /// Unsets the `bit` of the cache.
+    #[inline]
+    pub(crate) fn unset(&mut self, bit: u32) {
+        debug_assert!(
+            bit < CACHE_CAPACITY,
+            "too many features, time to increase the cache size!"
+        );
+        let v = self.0;
+        self.0 = unset_bit(v, bit);
+    }
+}
+
+/// This global variable is a cache of the features supported by the CPU.
+// Note: the third slot is only used in x86
+// Another Slot can be added if needed without any change to `Initializer`
+static CACHE: [Cache; 3] = [
+    Cache::uninitialized(),
+    Cache::uninitialized(),
+    Cache::uninitialized(),
+];
+
+/// Feature cache with capacity for `size_of::<usize>() * 8 - 1` features.
+///
+/// Note: 0 is used to represent an uninitialized cache, and (at least) the most
+/// significant bit is set on any cache which has been initialized.
+///
+/// Note: we use `Relaxed` atomic operations, because we are only interested in
+/// the effects of operations on a single memory location. That is, we only need
+/// "modification order", and not the full-blown "happens before".
+struct Cache(AtomicUsize);
+
+impl Cache {
+    const CAPACITY: u32 = (core::mem::size_of::<usize>() * 8 - 1) as u32;
+    const MASK: usize = (1 << Cache::CAPACITY) - 1;
+    const INITIALIZED_BIT: usize = 1usize << Cache::CAPACITY;
+
+    /// Creates an uninitialized cache.
+    #[allow(clippy::declare_interior_mutable_const)]
+    const fn uninitialized() -> Self {
+        Cache(AtomicUsize::new(0))
+    }
+
+    /// Is the `bit` in the cache set? Returns `None` if the cache has not been initialized.
+    #[inline]
+    pub(crate) fn test(&self, bit: u32) -> Option<bool> {
+        let cached = self.0.load(Ordering::Relaxed);
+        if cached == 0 {
+            None
+        } else {
+            Some(test_bit(cached as u128, bit))
+        }
+    }
+
+    /// Initializes the cache.
+    #[inline]
+    fn initialize(&self, value: usize) -> usize {
+        debug_assert_eq!((value & !Cache::MASK), 0);
+        self.0
+            .store(value | Cache::INITIALIZED_BIT, Ordering::Relaxed);
+        value
+    }
+}
+
+cfg_if::cfg_if! {
+    if #[cfg(feature = "std_detect_env_override")] {
+        #[inline]
+        fn disable_features(disable: &[u8], value: &mut Initializer) {
+            if let Ok(disable) = core::str::from_utf8(disable) {
+                for v in disable.split(" ") {
+                    let _ = super::Feature::from_str(v).map(|v| value.unset(v as u32));
+                }
+            }
+        }
+
+        #[inline]
+        fn initialize(mut value: Initializer) -> Initializer {
+            use core::ffi::CStr;
+            const RUST_STD_DETECT_UNSTABLE: &CStr = c"RUST_STD_DETECT_UNSTABLE";
+            cfg_if::cfg_if! {
+                if #[cfg(windows)] {
+                    use alloc::vec;
+                    #[link(name = "kernel32")]
+                    unsafe extern "system" {
+                        fn GetEnvironmentVariableA(name: *const u8, buffer: *mut u8, size: u32) -> u32;
+                    }
+                    let len = unsafe { GetEnvironmentVariableA(RUST_STD_DETECT_UNSTABLE.as_ptr().cast::<u8>(), core::ptr::null_mut(), 0) };
+                    if len > 0 {
+                        // +1 to include the null terminator.
+                        let mut env = vec![0; len as usize + 1];
+                        let len = unsafe { GetEnvironmentVariableA(RUST_STD_DETECT_UNSTABLE.as_ptr().cast::<u8>(), env.as_mut_ptr(), len + 1) };
+                        if len > 0 {
+                            disable_features(&env[..len as usize], &mut value);
+                        }
+                    }
+                } else {
+                    let env = unsafe {
+                        libc::getenv(RUST_STD_DETECT_UNSTABLE.as_ptr())
+                    };
+                    if !env.is_null() {
+                        let len = unsafe { libc::strlen(env) };
+                        let env = unsafe { core::slice::from_raw_parts(env as *const u8, len) };
+                        disable_features(env, &mut value);
+                    }
+                }
+            }
+            do_initialize(value);
+            value
+        }
+    } else {
+        #[inline]
+        fn initialize(value: Initializer) -> Initializer {
+            do_initialize(value);
+            value
+        }
+    }
+}
+
+#[inline]
+fn do_initialize(value: Initializer) {
+    CACHE[0].initialize((value.0) as usize & Cache::MASK);
+    CACHE[1].initialize((value.0 >> Cache::CAPACITY) as usize & Cache::MASK);
+    CACHE[2].initialize((value.0 >> (2 * Cache::CAPACITY)) as usize & Cache::MASK);
+}
+
+// We only have to detect features once, and it's fairly costly, so hint to LLVM
+// that it should assume that cache hits are more common than misses (which is
+// the point of caching). It's possibly unfortunate that this function needs to
+// reach across modules like this to call `os::detect_features`, but it produces
+// the best code out of several attempted variants.
+//
+// The `Initializer` that the cache was initialized with is returned, so that
+// the caller can call `test()` on it without having to load the value from the
+// cache again.
+#[cold]
+fn detect_and_initialize() -> Initializer {
+    initialize(super::os::detect_features())
+}
+
+/// Tests the `bit` of the storage. If the storage has not been initialized,
+/// initializes it with the result of `os::detect_features()`.
+///
+/// On its first invocation, it detects the CPU features and caches them in the
+/// `CACHE` global variable as an `AtomicU64`.
+///
+/// It uses the `Feature` variant to index into this variable as a bitset. If
+/// the bit is set, the feature is enabled, and otherwise it is disabled.
+///
+/// If the feature `std_detect_env_override` is enabled looks for the env
+/// variable `RUST_STD_DETECT_UNSTABLE` and uses its content to disable
+/// Features that would had been otherwise detected.
+#[inline]
+pub(crate) fn test(bit: u32) -> bool {
+    let (relative_bit, idx) = if bit < Cache::CAPACITY {
+        (bit, 0)
+    } else if bit < 2 * Cache::CAPACITY {
+        (bit - Cache::CAPACITY, 1)
+    } else {
+        (bit - 2 * Cache::CAPACITY, 2)
+    };
+    CACHE[idx]
+        .test(relative_bit)
+        .unwrap_or_else(|| detect_and_initialize().test(bit))
+}
diff --git a/library/std_detect/src/detect/macros.rs b/library/std_detect/src/detect/macros.rs
new file mode 100644
index 00000000000..a2994fb7daa
--- /dev/null
+++ b/library/std_detect/src/detect/macros.rs
@@ -0,0 +1,204 @@
+#[macro_export]
+#[allow_internal_unstable(stdarch_internal)]
+#[unstable(feature = "stdarch_internal", issue = "none")]
+macro_rules! detect_feature {
+    ($feature:tt, $feature_lit:tt) => {
+        $crate::detect_feature!($feature, $feature_lit : $feature_lit)
+    };
+    ($feature:tt, $feature_lit:tt : $($target_feature_lit:tt),*) => {
+        $(cfg!(target_feature = $target_feature_lit) ||)*
+            $crate::detect::__is_feature_detected::$feature()
+    };
+    ($feature:tt, $feature_lit:tt, without cfg check: true) => {
+        $crate::detect::__is_feature_detected::$feature()
+    };
+}
+
+#[allow(unused_macros, reason = "it's used in the features! macro below")]
+macro_rules! check_cfg_feature {
+    ($feature:tt, $feature_lit:tt) => {
+        check_cfg_feature!($feature, $feature_lit : $feature_lit)
+    };
+    ($feature:tt, $feature_lit:tt : $($target_feature_lit:tt),*) => {
+        $(cfg!(target_feature = $target_feature_lit);)*
+    };
+    ($feature:tt, $feature_lit:tt, without cfg check: $feature_cfg_check:literal) => {
+        #[allow(unexpected_cfgs, reason = $feature_lit)]
+        { cfg!(target_feature = $feature_lit) }
+    };
+}
+
+#[allow(unused)]
+macro_rules! features {
+    (
+      @TARGET: $target:ident;
+      @CFG: $cfg:meta;
+      @MACRO_NAME: $macro_name:ident;
+      @MACRO_ATTRS: $(#[$macro_attrs:meta])*
+      $(@BIND_FEATURE_NAME: $bind_feature:tt; $feature_impl:tt; $(#[$deprecate_attr:meta];)?)*
+      $(@NO_RUNTIME_DETECTION: $nort_feature:tt; )*
+      $(@FEATURE: #[$stability_attr:meta] $feature:ident: $feature_lit:tt;
+          $(without cfg check: $feature_cfg_check:tt;)?
+          $(implied by target_features: [$($target_feature_lit:tt),*];)?
+          $(#[$feature_comment:meta])*)*
+    ) => {
+        #[macro_export]
+        $(#[$macro_attrs])*
+        #[allow_internal_unstable(stdarch_internal)]
+        #[cfg($cfg)]
+        #[doc(cfg($cfg))]
+        macro_rules! $macro_name {
+            $(
+                ($feature_lit) => {
+                    $crate::detect_feature!($feature, $feature_lit $(, without cfg check: $feature_cfg_check)? $(: $($target_feature_lit),*)?)
+                };
+            )*
+            $(
+                ($bind_feature) => {
+                    {
+                        $(
+                            #[$deprecate_attr] macro_rules! deprecated_feature { {} => {}; }
+                            deprecated_feature! {};
+                        )?
+                        $crate::$macro_name!($feature_impl)
+                    }
+                };
+            )*
+            $(
+                ($nort_feature) => {
+                    compile_error!(
+                        concat!(
+                            stringify!($nort_feature),
+                            " feature cannot be detected at run-time"
+                        )
+                    )
+                };
+            )*
+            ($t:tt,) => {
+                    $crate::$macro_name!($t);
+            };
+            ($t:tt) => {
+                compile_error!(
+                    concat!(
+                        concat!("unknown ", stringify!($target)),
+                        concat!(" target feature: ", $t)
+                    )
+                )
+            };
+        }
+
+        $(#[$macro_attrs])*
+        #[macro_export]
+        #[cfg(not($cfg))]
+        #[doc(cfg($cfg))]
+        macro_rules! $macro_name {
+            $(
+                ($feature_lit) => {
+                    compile_error!(
+                        concat!(
+                            r#"This macro cannot be used on the current target.
+                            You can prevent it from being used in other architectures by
+                            guarding it behind a cfg("#,
+                            stringify!($cfg),
+                            ")."
+                        )
+                    )
+                };
+            )*
+            $(
+                ($bind_feature) => { $crate::$macro_name!($feature_impl) };
+            )*
+            $(
+                ($nort_feature) => {
+                    compile_error!(
+                        concat!(
+                            stringify!($nort_feature),
+                            " feature cannot be detected at run-time"
+                        )
+                    )
+                };
+            )*
+            ($t:tt,) => {
+                    $crate::$macro_name!($t);
+            };
+            ($t:tt) => {
+                compile_error!(
+                    concat!(
+                        concat!("unknown ", stringify!($target)),
+                        concat!(" target feature: ", $t)
+                    )
+                )
+            };
+        }
+
+        #[test]
+        #[deny(unexpected_cfgs)]
+        #[deny(unfulfilled_lint_expectations)]
+        fn unexpected_cfgs() {
+            $(
+                check_cfg_feature!($feature, $feature_lit $(, without cfg check: $feature_cfg_check)? $(: $($target_feature_lit),*)?);
+            )*
+        }
+
+        /// Each variant denotes a position in a bitset for a particular feature.
+        ///
+        /// PLEASE: do not use this, it is an implementation detail subject
+        /// to change.
+        #[doc(hidden)]
+        #[allow(non_camel_case_types)]
+        #[derive(Copy, Clone)]
+        #[repr(u8)]
+        #[unstable(feature = "stdarch_internal", issue = "none")]
+        #[cfg($cfg)]
+        pub(crate) enum Feature {
+            $(
+                $(#[$feature_comment])*
+                $feature,
+            )*
+
+            // Do not add variants after last:
+            _last
+        }
+
+        #[cfg($cfg)]
+        impl Feature {
+            pub(crate) fn to_str(self) -> &'static str {
+                match self {
+                    $(Feature::$feature => $feature_lit,)*
+                    Feature::_last => unreachable!(),
+                }
+            }
+
+            #[cfg(feature = "std_detect_env_override")]
+            pub(crate) fn from_str(s: &str) -> Result<Feature, ()> {
+                match s {
+                    $($feature_lit => Ok(Feature::$feature),)*
+                    _ => Err(())
+                }
+            }
+        }
+
+        /// Each function performs run-time feature detection for a single
+        /// feature. This allow us to use stability attributes on a per feature
+        /// basis.
+        ///
+        /// PLEASE: do not use this, it is an implementation detail subject
+        /// to change.
+        #[doc(hidden)]
+        #[cfg($cfg)]
+        #[unstable(feature = "stdarch_internal", issue = "none")]
+        pub mod __is_feature_detected {
+            $(
+
+                /// PLEASE: do not use this, it is an implementation detail
+                /// subject to change.
+                #[inline]
+                #[doc(hidden)]
+                #[$stability_attr]
+                pub fn $feature() -> bool {
+                    $crate::detect::check_for($crate::detect::Feature::$feature)
+                }
+            )*
+        }
+    };
+}
diff --git a/library/std_detect/src/detect/mod.rs b/library/std_detect/src/detect/mod.rs
new file mode 100644
index 00000000000..a9e9709c1f6
--- /dev/null
+++ b/library/std_detect/src/detect/mod.rs
@@ -0,0 +1,121 @@
+//! This module implements run-time feature detection.
+//!
+//! The `is_{arch}_feature_detected!("feature-name")` macros take the name of a
+//! feature as a string-literal, and return a boolean indicating whether the
+//! feature is enabled at run-time or not.
+//!
+//! These macros do two things:
+//! * map the string-literal into an integer stored as a `Feature` enum,
+//! * call a `os::check_for(x: Feature)` function that returns `true` if the
+//! feature is enabled.
+//!
+//! The `Feature` enums are also implemented in the `arch/{target_arch}.rs`
+//! modules.
+//!
+//! The `check_for` functions are, in general, Operating System dependent. Most
+//! architectures do not allow user-space programs to query the feature bits
+//! due to security concerns (x86 is the big exception). These functions are
+//! implemented in the `os/{target_os}.rs` modules.
+
+use cfg_if::cfg_if;
+
+#[macro_use]
+mod macros;
+
+mod arch;
+
+// This module needs to be public because the `is_{arch}_feature_detected!`
+// macros expand calls to items within it in user crates.
+#[doc(hidden)]
+#[unstable(feature = "stdarch_internal", issue = "none")]
+pub use self::arch::__is_feature_detected;
+
+pub(crate) use self::arch::Feature;
+
+mod bit;
+mod cache;
+
+cfg_if! {
+    if #[cfg(miri)] {
+        // When running under miri all target-features that are not enabled at
+        // compile-time are reported as disabled at run-time.
+        //
+        // For features for which `cfg(target_feature)` returns true,
+        // this run-time detection logic is never called.
+        #[path = "os/other.rs"]
+        mod os;
+    } else if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
+        // On x86/x86_64 no OS specific functionality is required.
+        #[path = "os/x86.rs"]
+        mod os;
+    } else if #[cfg(all(any(target_os = "linux", target_os = "android"), feature = "libc"))] {
+        #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
+        #[path = "os/riscv.rs"]
+        mod riscv;
+        #[path = "os/linux/mod.rs"]
+        mod os;
+    } else if #[cfg(all(target_os = "freebsd", feature = "libc"))] {
+        #[cfg(target_arch = "aarch64")]
+        #[path = "os/aarch64.rs"]
+        mod aarch64;
+        #[path = "os/freebsd/mod.rs"]
+        mod os;
+    } else if #[cfg(all(target_os = "openbsd", target_arch = "aarch64", feature = "libc"))] {
+        #[allow(dead_code)] // we don't use code that calls the mrs instruction.
+        #[path = "os/aarch64.rs"]
+        mod aarch64;
+        #[path = "os/openbsd/aarch64.rs"]
+        mod os;
+    } else if #[cfg(all(target_os = "windows", any(target_arch = "aarch64", target_arch = "arm64ec")))] {
+        #[path = "os/windows/aarch64.rs"]
+        mod os;
+    } else if #[cfg(all(target_vendor = "apple", target_arch = "aarch64", feature = "libc"))] {
+        #[path = "os/darwin/aarch64.rs"]
+        mod os;
+    } else {
+        #[path = "os/other.rs"]
+        mod os;
+    }
+}
+
+/// Performs run-time feature detection.
+#[inline]
+#[allow(dead_code)]
+fn check_for(x: Feature) -> bool {
+    cache::test(x as u32)
+}
+
+/// Returns an `Iterator<Item=(&'static str, bool)>` where
+/// `Item.0` is the feature name, and `Item.1` is a `bool` which
+/// is `true` if the feature is supported by the host and `false` otherwise.
+#[unstable(feature = "stdarch_internal", issue = "none")]
+pub fn features() -> impl Iterator<Item = (&'static str, bool)> {
+    cfg_if! {
+        if #[cfg(any(
+            target_arch = "x86",
+            target_arch = "x86_64",
+            target_arch = "arm",
+            target_arch = "aarch64",
+            target_arch = "arm64ec",
+            target_arch = "riscv32",
+            target_arch = "riscv64",
+            target_arch = "powerpc",
+            target_arch = "powerpc64",
+            target_arch = "mips",
+            target_arch = "mips64",
+            target_arch = "loongarch32",
+            target_arch = "loongarch64",
+            target_arch = "s390x",
+        ))] {
+            (0_u8..Feature::_last as u8).map(|discriminant: u8| {
+                #[allow(bindings_with_variant_name)] // RISC-V has Feature::f
+                let f: Feature = unsafe { core::mem::transmute(discriminant) };
+                let name: &'static str = f.to_str();
+                let enabled: bool = check_for(f);
+                (name, enabled)
+            })
+        } else {
+            None.into_iter()
+        }
+    }
+}
diff --git a/library/std_detect/src/detect/os/aarch64.rs b/library/std_detect/src/detect/os/aarch64.rs
new file mode 100644
index 00000000000..1ff2a17e6e1
--- /dev/null
+++ b/library/std_detect/src/detect/os/aarch64.rs
@@ -0,0 +1,130 @@
+//! Run-time feature detection for Aarch64 on any OS that emulates the mrs instruction.
+//!
+//! On FreeBSD >= 12.0, Linux >= 4.11 and other operating systems, it is possible to use
+//! privileged system registers from userspace to check CPU feature support.
+//!
+//! AArch64 system registers ID_AA64ISAR0_EL1, ID_AA64PFR0_EL1, ID_AA64ISAR1_EL1
+//! have bits dedicated to features like AdvSIMD, CRC32, AES, atomics (LSE), etc.
+//! Each part of the register indicates the level of support for a certain feature, e.g.
+//! when ID_AA64ISAR0_EL1\[7:4\] is >= 1, AES is supported; when it's >= 2, PMULL is supported.
+//!
+//! For proper support of [SoCs where different cores have different capabilities](https://medium.com/@jadr2ddude/a-big-little-problem-a-tale-of-big-little-gone-wrong-e7778ce744bb),
+//! the OS has to always report only the features supported by all cores, like [FreeBSD does](https://reviews.freebsd.org/D17137#393947).
+//!
+//! References:
+//!
+//! - [Zircon implementation](https://fuchsia.googlesource.com/zircon/+/master/kernel/arch/arm64/feature.cpp)
+//! - [Linux documentation](https://www.kernel.org/doc/Documentation/arm64/cpu-feature-registers.txt)
+//! - [ARM documentation](https://developer.arm.com/documentation/ddi0601/2022-12/AArch64-Registers?lang=en)
+
+use crate::detect::{Feature, cache};
+use core::arch::asm;
+
+/// Try to read the features from the system registers.
+///
+/// This will cause SIGILL if the current OS is not trapping the mrs instruction.
+pub(crate) fn detect_features() -> cache::Initializer {
+    // ID_AA64ISAR0_EL1 - Instruction Set Attribute Register 0
+    let aa64isar0: u64;
+    unsafe {
+        asm!(
+            "mrs {}, ID_AA64ISAR0_EL1",
+            out(reg) aa64isar0,
+            options(pure, nomem, preserves_flags, nostack)
+        );
+    }
+
+    // ID_AA64ISAR1_EL1 - Instruction Set Attribute Register 1
+    let aa64isar1: u64;
+    unsafe {
+        asm!(
+            "mrs {}, ID_AA64ISAR1_EL1",
+            out(reg) aa64isar1,
+            options(pure, nomem, preserves_flags, nostack)
+        );
+    }
+
+    // ID_AA64MMFR2_EL1 - AArch64 Memory Model Feature Register 2
+    let aa64mmfr2: u64;
+    unsafe {
+        asm!(
+            "mrs {}, ID_AA64MMFR2_EL1",
+            out(reg) aa64mmfr2,
+            options(pure, nomem, preserves_flags, nostack)
+        );
+    }
+
+    // ID_AA64PFR0_EL1 - Processor Feature Register 0
+    let aa64pfr0: u64;
+    unsafe {
+        asm!(
+            "mrs {}, ID_AA64PFR0_EL1",
+            out(reg) aa64pfr0,
+            options(pure, nomem, preserves_flags, nostack)
+        );
+    }
+
+    parse_system_registers(aa64isar0, aa64isar1, aa64mmfr2, Some(aa64pfr0))
+}
+
+pub(crate) fn parse_system_registers(
+    aa64isar0: u64,
+    aa64isar1: u64,
+    aa64mmfr2: u64,
+    aa64pfr0: Option<u64>,
+) -> cache::Initializer {
+    let mut value = cache::Initializer::default();
+
+    let mut enable_feature = |f, enable| {
+        if enable {
+            value.set(f as u32);
+        }
+    };
+
+    // ID_AA64ISAR0_EL1 - Instruction Set Attribute Register 0
+    enable_feature(Feature::pmull, bits_shift(aa64isar0, 7, 4) >= 2);
+    enable_feature(Feature::tme, bits_shift(aa64isar0, 27, 24) == 1);
+    enable_feature(Feature::lse, bits_shift(aa64isar0, 23, 20) >= 2);
+    enable_feature(Feature::crc, bits_shift(aa64isar0, 19, 16) >= 1);
+
+    // ID_AA64PFR0_EL1 - Processor Feature Register 0
+    if let Some(aa64pfr0) = aa64pfr0 {
+        let fp = bits_shift(aa64pfr0, 19, 16) < 0xF;
+        let fphp = bits_shift(aa64pfr0, 19, 16) >= 1;
+        let asimd = bits_shift(aa64pfr0, 23, 20) < 0xF;
+        let asimdhp = bits_shift(aa64pfr0, 23, 20) >= 1;
+        enable_feature(Feature::fp, fp);
+        enable_feature(Feature::fp16, fphp);
+        // SIMD support requires float support - if half-floats are
+        // supported, it also requires half-float support:
+        enable_feature(Feature::asimd, fp && asimd && (!fphp | asimdhp));
+        // SIMD extensions require SIMD support:
+        enable_feature(Feature::aes, asimd && bits_shift(aa64isar0, 7, 4) >= 2);
+        let sha1 = bits_shift(aa64isar0, 11, 8) >= 1;
+        let sha2 = bits_shift(aa64isar0, 15, 12) >= 1;
+        enable_feature(Feature::sha2, asimd && sha1 && sha2);
+        enable_feature(Feature::rdm, asimd && bits_shift(aa64isar0, 31, 28) >= 1);
+        enable_feature(
+            Feature::dotprod,
+            asimd && bits_shift(aa64isar0, 47, 44) >= 1,
+        );
+        enable_feature(Feature::sve, asimd && bits_shift(aa64pfr0, 35, 32) >= 1);
+    }
+
+    // ID_AA64ISAR1_EL1 - Instruction Set Attribute Register 1
+    // Check for either APA or API field
+    enable_feature(Feature::paca, bits_shift(aa64isar1, 11, 4) >= 1);
+    enable_feature(Feature::rcpc, bits_shift(aa64isar1, 23, 20) >= 1);
+    // Check for either GPA or GPI field
+    enable_feature(Feature::pacg, bits_shift(aa64isar1, 31, 24) >= 1);
+
+    // ID_AA64MMFR2_EL1 - AArch64 Memory Model Feature Register 2
+    enable_feature(Feature::lse2, bits_shift(aa64mmfr2, 35, 32) >= 1);
+
+    value
+}
+
+#[inline]
+fn bits_shift(x: u64, high: usize, low: usize) -> u64 {
+    (x >> low) & ((1 << (high - low + 1)) - 1)
+}
diff --git a/library/std_detect/src/detect/os/darwin/aarch64.rs b/library/std_detect/src/detect/os/darwin/aarch64.rs
new file mode 100644
index 00000000000..44d921689e5
--- /dev/null
+++ b/library/std_detect/src/detect/os/darwin/aarch64.rs
@@ -0,0 +1,155 @@
+//! Run-time feature detection for aarch64 on Darwin (macOS/iOS/tvOS/watchOS/visionOS).
+//!
+//! <https://developer.apple.com/documentation/kernel/1387446-sysctlbyname/determining_instruction_set_characteristics>
+
+use crate::detect::{Feature, cache};
+use core::ffi::CStr;
+
+#[inline]
+fn _sysctlbyname(name: &CStr) -> bool {
+    use libc;
+
+    let mut enabled: i32 = 0;
+    let mut enabled_len: usize = 4;
+    let enabled_ptr = &mut enabled as *mut i32 as *mut libc::c_void;
+
+    let ret = unsafe {
+        libc::sysctlbyname(
+            name.as_ptr(),
+            enabled_ptr,
+            &mut enabled_len,
+            core::ptr::null_mut(),
+            0,
+        )
+    };
+
+    match ret {
+        0 => enabled != 0,
+        _ => false,
+    }
+}
+
+/// Try to read the features using sysctlbyname.
+pub(crate) fn detect_features() -> cache::Initializer {
+    let mut value = cache::Initializer::default();
+
+    let mut enable_feature = |f, enable| {
+        if enable {
+            value.set(f as u32);
+        }
+    };
+
+    // Armv8.0 features not using the standard identifiers
+    let fp = _sysctlbyname(c"hw.optional.floatingpoint");
+    let asimd = _sysctlbyname(c"hw.optional.AdvSIMD");
+    let crc = _sysctlbyname(c"hw.optional.armv8_crc32");
+
+    // Armv8 and Armv9 features using the standard identifiers
+    let aes = _sysctlbyname(c"hw.optional.arm.FEAT_AES");
+    let bf16 = _sysctlbyname(c"hw.optional.arm.FEAT_BF16");
+    let bti = _sysctlbyname(c"hw.optional.arm.FEAT_BTI");
+    let cssc = _sysctlbyname(c"hw.optional.arm.FEAT_CSSC");
+    let dit = _sysctlbyname(c"hw.optional.arm.FEAT_DIT");
+    let dpb = _sysctlbyname(c"hw.optional.arm.FEAT_DPB");
+    let dpb2 = _sysctlbyname(c"hw.optional.arm.FEAT_DPB2");
+    let dotprod = _sysctlbyname(c"hw.optional.arm.FEAT_DotProd");
+    let ecv = _sysctlbyname(c"hw.optional.arm.FEAT_ECV");
+    let fcma = _sysctlbyname(c"hw.optional.arm.FEAT_FCMA");
+    let fhm = _sysctlbyname(c"hw.optional.arm.FEAT_FHM");
+    let fp16 = _sysctlbyname(c"hw.optional.arm.FEAT_FP16");
+    let frintts = _sysctlbyname(c"hw.optional.arm.FEAT_FRINTTS");
+    let flagm = _sysctlbyname(c"hw.optional.arm.FEAT_FlagM");
+    let flagm2 = _sysctlbyname(c"hw.optional.arm.FEAT_FlagM2");
+    let hbc = _sysctlbyname(c"hw.optional.arm.FEAT_HBC");
+    let i8mm = _sysctlbyname(c"hw.optional.arm.FEAT_I8MM");
+    let jsconv = _sysctlbyname(c"hw.optional.arm.FEAT_JSCVT");
+    let rcpc = _sysctlbyname(c"hw.optional.arm.FEAT_LRCPC");
+    let rcpc2 = _sysctlbyname(c"hw.optional.arm.FEAT_LRCPC2");
+    let lse = _sysctlbyname(c"hw.optional.arm.FEAT_LSE");
+    let lse2 = _sysctlbyname(c"hw.optional.arm.FEAT_LSE2");
+    let pauth = _sysctlbyname(c"hw.optional.arm.FEAT_PAuth");
+    let pmull = _sysctlbyname(c"hw.optional.arm.FEAT_PMULL");
+    let rdm = _sysctlbyname(c"hw.optional.arm.FEAT_RDM");
+    let sb = _sysctlbyname(c"hw.optional.arm.FEAT_SB");
+    let sha1 = _sysctlbyname(c"hw.optional.arm.FEAT_SHA1");
+    let sha256 = _sysctlbyname(c"hw.optional.arm.FEAT_SHA256");
+    let sha3 = _sysctlbyname(c"hw.optional.arm.FEAT_SHA3");
+    let sha512 = _sysctlbyname(c"hw.optional.arm.FEAT_SHA512");
+    let sme = _sysctlbyname(c"hw.optional.arm.FEAT_SME");
+    let sme2 = _sysctlbyname(c"hw.optional.arm.FEAT_SME2");
+    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 wfxt = _sysctlbyname(c"hw.optional.arm.FEAT_WFxT");
+
+    // The following features are not exposed by `is_aarch64_feature_detected`,
+    // but *are* reported by `sysctl`. They are here as documentation that they
+    // exist, and may potentially be exposed later.
+    /*
+    let afp = _sysctlbyname(c"hw.optional.arm.FEAT_AFP");
+    let csv2 = _sysctlbyname(c"hw.optional.arm.FEAT_CSV2");
+    let csv3 = _sysctlbyname(c"hw.optional.arm.FEAT_CSV3");
+    let ebf16 = _sysctlbyname(c"hw.optional.arm.FEAT_EBF16");
+    let fpac = _sysctlbyname(c"hw.optional.arm.FEAT_FPAC");
+    let fpaccombine = _sysctlbyname(c"hw.optional.arm.FEAT_FPACCOMBINE");
+    let pacimp = _sysctlbyname(c"hw.optional.arm.FEAT_PACIMP");
+    let pauth2 = _sysctlbyname(c"hw.optional.arm.FEAT_PAuth2");
+    let rpres = _sysctlbyname(c"hw.optional.arm.FEAT_RPRES");
+    let specres = _sysctlbyname(c"hw.optional.arm.FEAT_SPECRES");
+    let specres2 = _sysctlbyname(c"hw.optional.arm.FEAT_SPECRES2");
+     */
+
+    // The following "features" are reported by `sysctl` but are mandatory parts
+    // of SME or SME2, and so are not exposed separately by
+    // `is_aarch64_feature_detected`.  They are here to document their
+    // existence, in case they're needed in the future.
+    /*
+    let sme_b16f32 = _sysctlbyname(c"hw.optional.arm.SME_B16F32");
+    let sme_bi32i32 = _sysctlbyname(c"hw.optional.arm.SME_BI32I32");
+    let sme_f16f32 = _sysctlbyname(c"hw.optional.arm.SME_F16F32");
+    let sme_f32f32 = _sysctlbyname(c"hw.optional.arm.SME_F32F32");
+    let sme_i16i32 = _sysctlbyname(c"hw.optional.arm.SME_I16I32");
+    let sme_i8i32 = _sysctlbyname(c"hw.optional.arm.SME_I8I32");
+     */
+
+    enable_feature(Feature::aes, aes && pmull);
+    enable_feature(Feature::asimd, asimd);
+    enable_feature(Feature::bf16, bf16);
+    enable_feature(Feature::bti, bti);
+    enable_feature(Feature::crc, crc);
+    enable_feature(Feature::cssc, cssc);
+    enable_feature(Feature::dit, dit);
+    enable_feature(Feature::dotprod, dotprod);
+    enable_feature(Feature::dpb, dpb);
+    enable_feature(Feature::dpb2, dpb2);
+    enable_feature(Feature::ecv, ecv);
+    enable_feature(Feature::fcma, fcma);
+    enable_feature(Feature::fhm, fhm);
+    enable_feature(Feature::flagm, flagm);
+    enable_feature(Feature::flagm2, flagm2);
+    enable_feature(Feature::fp, fp);
+    enable_feature(Feature::fp16, fp16);
+    enable_feature(Feature::frintts, frintts);
+    enable_feature(Feature::hbc, hbc);
+    enable_feature(Feature::i8mm, i8mm);
+    enable_feature(Feature::jsconv, jsconv);
+    enable_feature(Feature::lse, lse);
+    enable_feature(Feature::lse2, lse2);
+    enable_feature(Feature::paca, pauth);
+    enable_feature(Feature::pacg, pauth);
+    enable_feature(Feature::pmull, aes && pmull);
+    enable_feature(Feature::rcpc, rcpc);
+    enable_feature(Feature::rcpc2, rcpc2);
+    enable_feature(Feature::rdm, rdm);
+    enable_feature(Feature::sb, sb);
+    enable_feature(Feature::sha2, sha1 && sha256 && asimd);
+    enable_feature(Feature::sha3, sha512 && sha3 && asimd);
+    enable_feature(Feature::sme, sme);
+    enable_feature(Feature::sme2, sme2);
+    enable_feature(Feature::sme_f64f64, sme_f64f64);
+    enable_feature(Feature::sme_i16i64, sme_i16i64);
+    enable_feature(Feature::ssbs, ssbs);
+    enable_feature(Feature::wfxt, wfxt);
+
+    value
+}
diff --git a/library/std_detect/src/detect/os/freebsd/aarch64.rs b/library/std_detect/src/detect/os/freebsd/aarch64.rs
new file mode 100644
index 00000000000..ccc48f53605
--- /dev/null
+++ b/library/std_detect/src/detect/os/freebsd/aarch64.rs
@@ -0,0 +1,3 @@
+//! Run-time feature detection for Aarch64 on FreeBSD.
+
+pub(crate) use super::super::aarch64::detect_features;
diff --git a/library/std_detect/src/detect/os/freebsd/arm.rs b/library/std_detect/src/detect/os/freebsd/arm.rs
new file mode 100644
index 00000000000..0a15156e1bd
--- /dev/null
+++ b/library/std_detect/src/detect/os/freebsd/arm.rs
@@ -0,0 +1,36 @@
+//! Run-time feature detection for ARM on FreeBSD
+
+use super::auxvec;
+use crate::detect::{Feature, cache};
+
+// Defined in machine/elf.h.
+// https://github.com/freebsd/freebsd-src/blob/deb63adf945d446ed91a9d84124c71f15ae571d1/sys/arm/include/elf.h
+const HWCAP_NEON: usize = 0x00001000;
+const HWCAP2_AES: usize = 0x00000001;
+const HWCAP2_PMULL: usize = 0x00000002;
+const HWCAP2_SHA1: usize = 0x00000004;
+const HWCAP2_SHA2: usize = 0x00000008;
+const HWCAP2_CRC32: usize = 0x00000010;
+
+/// Try to read the features from the auxiliary vector
+pub(crate) fn detect_features() -> cache::Initializer {
+    let mut value = cache::Initializer::default();
+    let enable_feature = |value: &mut cache::Initializer, f, enable| {
+        if enable {
+            value.set(f as u32);
+        }
+    };
+
+    if let Ok(auxv) = auxvec::auxv() {
+        enable_feature(&mut value, Feature::neon, auxv.hwcap & HWCAP_NEON != 0);
+        enable_feature(&mut value, Feature::pmull, auxv.hwcap2 & HWCAP2_PMULL != 0);
+        enable_feature(&mut value, Feature::crc, auxv.hwcap2 & HWCAP2_CRC32 != 0);
+        enable_feature(&mut value, Feature::aes, auxv.hwcap2 & HWCAP2_AES != 0);
+        // SHA2 requires SHA1 & SHA2 features
+        let sha1 = auxv.hwcap2 & HWCAP2_SHA1 != 0;
+        let sha2 = auxv.hwcap2 & HWCAP2_SHA2 != 0;
+        enable_feature(&mut value, Feature::sha2, sha1 && sha2);
+        return value;
+    }
+    value
+}
diff --git a/library/std_detect/src/detect/os/freebsd/auxvec.rs b/library/std_detect/src/detect/os/freebsd/auxvec.rs
new file mode 100644
index 00000000000..4e72bf22d76
--- /dev/null
+++ b/library/std_detect/src/detect/os/freebsd/auxvec.rs
@@ -0,0 +1,66 @@
+//! Parses ELF auxiliary vectors.
+#![cfg_attr(
+    any(
+        target_arch = "aarch64",
+        target_arch = "arm",
+        target_arch = "powerpc64",
+        target_arch = "riscv64"
+    ),
+    allow(dead_code)
+)]
+
+/// Cache HWCAP bitfields of the ELF Auxiliary Vector.
+///
+/// If an entry cannot be read all the bits in the bitfield are set to zero.
+/// This should be interpreted as all the features being disabled.
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct AuxVec {
+    pub hwcap: usize,
+    pub hwcap2: usize,
+}
+
+/// ELF Auxiliary Vector
+///
+/// The auxiliary vector is a memory region in a running ELF program's stack
+/// composed of (key: usize, value: usize) pairs.
+///
+/// The keys used in the aux vector are platform dependent. For FreeBSD, they are
+/// defined in [sys/elf_common.h][elf_common_h]. The hardware capabilities of a given
+/// CPU can be queried with the  `AT_HWCAP` and `AT_HWCAP2` keys.
+///
+/// Note that run-time feature detection is not invoked for features that can
+/// be detected at compile-time.
+///
+/// [elf_common.h]: https://svnweb.freebsd.org/base/release/12.0.0/sys/sys/elf_common.h?revision=341707
+pub(crate) fn auxv() -> Result<AuxVec, ()> {
+    let hwcap = archauxv(libc::AT_HWCAP);
+    let hwcap2 = archauxv(libc::AT_HWCAP2);
+    // Zero could indicate that no features were detected, but it's also used to
+    // indicate an error. In particular, on many platforms AT_HWCAP2 will be
+    // legitimately zero, since it contains the most recent feature flags.
+    if hwcap != 0 || hwcap2 != 0 {
+        return Ok(AuxVec { hwcap, hwcap2 });
+    }
+    Err(())
+}
+
+/// Tries to read the `key` from the auxiliary vector.
+fn archauxv(key: libc::c_int) -> usize {
+    const OUT_LEN: libc::c_int = core::mem::size_of::<libc::c_ulong>() as libc::c_int;
+    let mut out: libc::c_ulong = 0;
+    unsafe {
+        // elf_aux_info is available on FreeBSD 12.0+ and 11.4+:
+        // https://github.com/freebsd/freebsd-src/commit/0b08ae2120cdd08c20a2b806e2fcef4d0a36c470
+        // https://github.com/freebsd/freebsd-src/blob/release/11.4.0/sys/sys/auxv.h
+        // FreeBSD 11 support in std has been removed in Rust 1.75 (https://github.com/rust-lang/rust/pull/114521),
+        // so we can safely use this function.
+        let res = libc::elf_aux_info(
+            key,
+            &mut out as *mut libc::c_ulong as *mut libc::c_void,
+            OUT_LEN,
+        );
+        // If elf_aux_info fails, `out` will be left at zero (which is the proper default value).
+        debug_assert!(res == 0 || out == 0);
+    }
+    out as usize
+}
diff --git a/library/std_detect/src/detect/os/freebsd/mod.rs b/library/std_detect/src/detect/os/freebsd/mod.rs
new file mode 100644
index 00000000000..ade7fb6269d
--- /dev/null
+++ b/library/std_detect/src/detect/os/freebsd/mod.rs
@@ -0,0 +1,22 @@
+//! Run-time feature detection on FreeBSD
+
+mod auxvec;
+
+cfg_if::cfg_if! {
+    if #[cfg(target_arch = "aarch64")] {
+        mod aarch64;
+        pub(crate) use self::aarch64::detect_features;
+    } else if #[cfg(target_arch = "arm")] {
+        mod arm;
+        pub(crate) use self::arm::detect_features;
+    } else if #[cfg(target_arch = "powerpc64")] {
+        mod powerpc;
+        pub(crate) use self::powerpc::detect_features;
+    } else {
+        use crate::detect::cache;
+        /// Performs run-time feature detection.
+        pub(crate) fn detect_features() -> cache::Initializer {
+            cache::Initializer::default()
+        }
+    }
+}
diff --git a/library/std_detect/src/detect/os/freebsd/powerpc.rs b/library/std_detect/src/detect/os/freebsd/powerpc.rs
new file mode 100644
index 00000000000..d03af68cd08
--- /dev/null
+++ b/library/std_detect/src/detect/os/freebsd/powerpc.rs
@@ -0,0 +1,21 @@
+//! Run-time feature detection for PowerPC on FreeBSD.
+
+use super::auxvec;
+use crate::detect::{Feature, cache};
+
+pub(crate) fn detect_features() -> cache::Initializer {
+    let mut value = cache::Initializer::default();
+    let enable_feature = |value: &mut cache::Initializer, f, enable| {
+        if enable {
+            value.set(f as u32);
+        }
+    };
+
+    if let Ok(auxv) = auxvec::auxv() {
+        enable_feature(&mut value, Feature::altivec, auxv.hwcap & 0x10000000 != 0);
+        enable_feature(&mut value, Feature::vsx, auxv.hwcap & 0x00000080 != 0);
+        enable_feature(&mut value, Feature::power8, auxv.hwcap2 & 0x80000000 != 0);
+        return value;
+    }
+    value
+}
diff --git a/library/std_detect/src/detect/os/linux/aarch64.rs b/library/std_detect/src/detect/os/linux/aarch64.rs
new file mode 100644
index 00000000000..22a9cefff7b
--- /dev/null
+++ b/library/std_detect/src/detect/os/linux/aarch64.rs
@@ -0,0 +1,484 @@
+//! Run-time feature detection for Aarch64 on Linux.
+
+use super::auxvec;
+use crate::detect::{Feature, bit, cache};
+
+/// Try to read the features from the auxiliary vector.
+pub(crate) fn detect_features() -> cache::Initializer {
+    #[cfg(target_os = "android")]
+    let is_exynos9810 = {
+        // Samsung Exynos 9810 has a bug that big and little cores have different
+        // ISAs. And on older Android (pre-9), the kernel incorrectly reports
+        // that features available only on some cores are available on all cores.
+        // https://reviews.llvm.org/D114523
+        let mut arch = [0_u8; libc::PROP_VALUE_MAX as usize];
+        let len = unsafe {
+            libc::__system_property_get(c"ro.arch".as_ptr(), arch.as_mut_ptr() as *mut libc::c_char)
+        };
+        // On Exynos, ro.arch is not available on Android 12+, but it is fine
+        // because Android 9+ includes the fix.
+        len > 0 && arch.starts_with(b"exynos9810")
+    };
+    #[cfg(not(target_os = "android"))]
+    let is_exynos9810 = false;
+
+    if let Ok(auxv) = auxvec::auxv() {
+        let hwcap: AtHwcap = auxv.into();
+        return hwcap.cache(is_exynos9810);
+    }
+    cache::Initializer::default()
+}
+
+/// These values are part of the platform-specific [asm/hwcap.h][hwcap] .
+///
+/// The names match those used for cpuinfo.
+///
+/// [hwcap]: https://github.com/torvalds/linux/blob/master/arch/arm64/include/uapi/asm/hwcap.h
+#[derive(Debug, Default, PartialEq)]
+struct AtHwcap {
+    // AT_HWCAP
+    fp: bool,
+    asimd: bool,
+    // evtstrm: No LLVM support.
+    aes: bool,
+    pmull: bool,
+    sha1: bool,
+    sha2: bool,
+    crc32: bool,
+    atomics: bool,
+    fphp: bool,
+    asimdhp: bool,
+    // cpuid: No LLVM support.
+    asimdrdm: bool,
+    jscvt: bool,
+    fcma: bool,
+    lrcpc: bool,
+    dcpop: bool,
+    sha3: bool,
+    sm3: bool,
+    sm4: bool,
+    asimddp: bool,
+    sha512: bool,
+    sve: bool,
+    fhm: bool,
+    dit: bool,
+    uscat: bool,
+    ilrcpc: bool,
+    flagm: bool,
+    ssbs: bool,
+    sb: bool,
+    paca: bool,
+    pacg: bool,
+
+    // AT_HWCAP2
+    dcpodp: bool,
+    sve2: bool,
+    sveaes: bool,
+    svepmull: bool,
+    svebitperm: bool,
+    svesha3: bool,
+    svesm4: bool,
+    flagm2: bool,
+    frint: bool,
+    // svei8mm: See i8mm feature.
+    svef32mm: bool,
+    svef64mm: bool,
+    // svebf16: See bf16 feature.
+    i8mm: bool,
+    bf16: bool,
+    // dgh: No LLVM support.
+    rng: bool,
+    bti: bool,
+    mte: bool,
+    ecv: bool,
+    // afp: bool,
+    // rpres: bool,
+    // mte3: bool,
+    sme: bool,
+    smei16i64: bool,
+    smef64f64: bool,
+    // smei8i32: bool,
+    // smef16f32: bool,
+    // smeb16f32: bool,
+    // smef32f32: bool,
+    smefa64: bool,
+    wfxt: bool,
+    // ebf16: bool,
+    // sveebf16: bool,
+    cssc: bool,
+    // rprfm: bool,
+    sve2p1: bool,
+    sme2: bool,
+    sme2p1: bool,
+    // smei16i32: bool,
+    // smebi32i32: bool,
+    smeb16b16: bool,
+    smef16f16: bool,
+    mops: bool,
+    hbc: bool,
+    sveb16b16: bool,
+    lrcpc3: bool,
+    lse128: bool,
+    fpmr: bool,
+    lut: bool,
+    faminmax: bool,
+    f8cvt: bool,
+    f8fma: bool,
+    f8dp4: bool,
+    f8dp2: bool,
+    f8e4m3: bool,
+    f8e5m2: bool,
+    smelutv2: bool,
+    smef8f16: bool,
+    smef8f32: bool,
+    smesf8fma: bool,
+    smesf8dp4: bool,
+    smesf8dp2: bool,
+    // pauthlr: bool,
+}
+
+impl From<auxvec::AuxVec> for AtHwcap {
+    /// Reads AtHwcap from the auxiliary vector.
+    fn from(auxv: auxvec::AuxVec) -> Self {
+        AtHwcap {
+            fp: bit::test(auxv.hwcap, 0),
+            asimd: bit::test(auxv.hwcap, 1),
+            // evtstrm: bit::test(auxv.hwcap, 2),
+            aes: bit::test(auxv.hwcap, 3),
+            pmull: bit::test(auxv.hwcap, 4),
+            sha1: bit::test(auxv.hwcap, 5),
+            sha2: bit::test(auxv.hwcap, 6),
+            crc32: bit::test(auxv.hwcap, 7),
+            atomics: bit::test(auxv.hwcap, 8),
+            fphp: bit::test(auxv.hwcap, 9),
+            asimdhp: bit::test(auxv.hwcap, 10),
+            // cpuid: bit::test(auxv.hwcap, 11),
+            asimdrdm: bit::test(auxv.hwcap, 12),
+            jscvt: bit::test(auxv.hwcap, 13),
+            fcma: bit::test(auxv.hwcap, 14),
+            lrcpc: bit::test(auxv.hwcap, 15),
+            dcpop: bit::test(auxv.hwcap, 16),
+            sha3: bit::test(auxv.hwcap, 17),
+            sm3: bit::test(auxv.hwcap, 18),
+            sm4: bit::test(auxv.hwcap, 19),
+            asimddp: bit::test(auxv.hwcap, 20),
+            sha512: bit::test(auxv.hwcap, 21),
+            sve: bit::test(auxv.hwcap, 22),
+            fhm: bit::test(auxv.hwcap, 23),
+            dit: bit::test(auxv.hwcap, 24),
+            uscat: bit::test(auxv.hwcap, 25),
+            ilrcpc: bit::test(auxv.hwcap, 26),
+            flagm: bit::test(auxv.hwcap, 27),
+            ssbs: bit::test(auxv.hwcap, 28),
+            sb: bit::test(auxv.hwcap, 29),
+            paca: bit::test(auxv.hwcap, 30),
+            pacg: bit::test(auxv.hwcap, 31),
+
+            // AT_HWCAP2
+            dcpodp: bit::test(auxv.hwcap2, 0),
+            sve2: bit::test(auxv.hwcap2, 1),
+            sveaes: bit::test(auxv.hwcap2, 2),
+            svepmull: bit::test(auxv.hwcap2, 3),
+            svebitperm: bit::test(auxv.hwcap2, 4),
+            svesha3: bit::test(auxv.hwcap2, 5),
+            svesm4: bit::test(auxv.hwcap2, 6),
+            flagm2: bit::test(auxv.hwcap2, 7),
+            frint: bit::test(auxv.hwcap2, 8),
+            // svei8mm: bit::test(auxv.hwcap2, 9),
+            svef32mm: bit::test(auxv.hwcap2, 10),
+            svef64mm: bit::test(auxv.hwcap2, 11),
+            // svebf16: bit::test(auxv.hwcap2, 12),
+            i8mm: bit::test(auxv.hwcap2, 13),
+            bf16: bit::test(auxv.hwcap2, 14),
+            // dgh: bit::test(auxv.hwcap2, 15),
+            rng: bit::test(auxv.hwcap2, 16),
+            bti: bit::test(auxv.hwcap2, 17),
+            mte: bit::test(auxv.hwcap2, 18),
+            ecv: bit::test(auxv.hwcap2, 19),
+            // afp: bit::test(auxv.hwcap2, 20),
+            // rpres: bit::test(auxv.hwcap2, 21),
+            // mte3: bit::test(auxv.hwcap2, 22),
+            sme: bit::test(auxv.hwcap2, 23),
+            smei16i64: bit::test(auxv.hwcap2, 24),
+            smef64f64: bit::test(auxv.hwcap2, 25),
+            // smei8i32: bit::test(auxv.hwcap2, 26),
+            // smef16f32: bit::test(auxv.hwcap2, 27),
+            // smeb16f32: bit::test(auxv.hwcap2, 28),
+            // smef32f32: bit::test(auxv.hwcap2, 29),
+            smefa64: bit::test(auxv.hwcap2, 30),
+            wfxt: bit::test(auxv.hwcap2, 31),
+            // ebf16: bit::test(auxv.hwcap2, 32),
+            // sveebf16: bit::test(auxv.hwcap2, 33),
+            cssc: bit::test(auxv.hwcap2, 34),
+            // rprfm: bit::test(auxv.hwcap2, 35),
+            sve2p1: bit::test(auxv.hwcap2, 36),
+            sme2: bit::test(auxv.hwcap2, 37),
+            sme2p1: bit::test(auxv.hwcap2, 38),
+            // smei16i32: bit::test(auxv.hwcap2, 39),
+            // smebi32i32: bit::test(auxv.hwcap2, 40),
+            smeb16b16: bit::test(auxv.hwcap2, 41),
+            smef16f16: bit::test(auxv.hwcap2, 42),
+            mops: bit::test(auxv.hwcap2, 43),
+            hbc: bit::test(auxv.hwcap2, 44),
+            sveb16b16: bit::test(auxv.hwcap2, 45),
+            lrcpc3: bit::test(auxv.hwcap2, 46),
+            lse128: bit::test(auxv.hwcap2, 47),
+            fpmr: bit::test(auxv.hwcap2, 48),
+            lut: bit::test(auxv.hwcap2, 49),
+            faminmax: bit::test(auxv.hwcap2, 50),
+            f8cvt: bit::test(auxv.hwcap2, 51),
+            f8fma: bit::test(auxv.hwcap2, 52),
+            f8dp4: bit::test(auxv.hwcap2, 53),
+            f8dp2: bit::test(auxv.hwcap2, 54),
+            f8e4m3: bit::test(auxv.hwcap2, 55),
+            f8e5m2: bit::test(auxv.hwcap2, 56),
+            smelutv2: bit::test(auxv.hwcap2, 57),
+            smef8f16: bit::test(auxv.hwcap2, 58),
+            smef8f32: bit::test(auxv.hwcap2, 59),
+            smesf8fma: bit::test(auxv.hwcap2, 60),
+            smesf8dp4: bit::test(auxv.hwcap2, 61),
+            smesf8dp2: bit::test(auxv.hwcap2, 62),
+            // pauthlr: bit::test(auxv.hwcap2, ??),
+        }
+    }
+}
+
+impl AtHwcap {
+    /// Initializes the cache from the feature -bits.
+    ///
+    /// The feature dependencies here come directly from LLVM's feature definitions:
+    /// https://github.com/llvm/llvm-project/blob/main/llvm/lib/Target/AArch64/AArch64.td
+    fn cache(self, is_exynos9810: bool) -> cache::Initializer {
+        let mut value = cache::Initializer::default();
+        {
+            let mut enable_feature = |f, enable| {
+                if enable {
+                    value.set(f as u32);
+                }
+            };
+
+            // Samsung Exynos 9810 has a bug that big and little cores have different
+            // ISAs. And on older Android (pre-9), the kernel incorrectly reports
+            // that features available only on some cores are available on all cores.
+            // So, only check features that are known to be available on exynos-m3:
+            // $ rustc --print cfg --target aarch64-linux-android -C target-cpu=exynos-m3 | grep target_feature
+            // See also https://github.com/rust-lang/stdarch/pull/1378#discussion_r1103748342.
+            if is_exynos9810 {
+                enable_feature(Feature::fp, self.fp);
+                enable_feature(Feature::crc, self.crc32);
+                // ASIMD support requires float support - if half-floats are
+                // supported, it also requires half-float support:
+                let asimd = self.fp && self.asimd && (!self.fphp | self.asimdhp);
+                enable_feature(Feature::asimd, asimd);
+                // Cryptographic extensions require ASIMD
+                // AES also covers FEAT_PMULL
+                enable_feature(Feature::aes, self.aes && self.pmull && asimd);
+                enable_feature(Feature::sha2, self.sha1 && self.sha2 && asimd);
+                return value;
+            }
+
+            enable_feature(Feature::fp, self.fp);
+            // Half-float support requires float support
+            enable_feature(Feature::fp16, self.fp && self.fphp);
+            // FHM (fp16fml in LLVM) requires half float support
+            enable_feature(Feature::fhm, self.fphp && self.fhm);
+            enable_feature(Feature::pmull, self.pmull);
+            enable_feature(Feature::crc, self.crc32);
+            enable_feature(Feature::lse, self.atomics);
+            enable_feature(Feature::lse2, self.uscat);
+            enable_feature(Feature::lse128, self.lse128 && self.atomics);
+            enable_feature(Feature::rcpc, self.lrcpc);
+            // RCPC2 (rcpc-immo in LLVM) requires RCPC support
+            let rcpc2 = self.ilrcpc && self.lrcpc;
+            enable_feature(Feature::rcpc2, rcpc2);
+            enable_feature(Feature::rcpc3, self.lrcpc3 && rcpc2);
+            enable_feature(Feature::dit, self.dit);
+            enable_feature(Feature::flagm, self.flagm);
+            enable_feature(Feature::flagm2, self.flagm2);
+            enable_feature(Feature::ssbs, self.ssbs);
+            enable_feature(Feature::sb, self.sb);
+            enable_feature(Feature::paca, self.paca);
+            enable_feature(Feature::pacg, self.pacg);
+            // enable_feature(Feature::pauth_lr, self.pauthlr);
+            enable_feature(Feature::dpb, self.dcpop);
+            enable_feature(Feature::dpb2, self.dcpodp);
+            enable_feature(Feature::rand, self.rng);
+            enable_feature(Feature::bti, self.bti);
+            enable_feature(Feature::mte, self.mte);
+            // jsconv requires float support
+            enable_feature(Feature::jsconv, self.jscvt && self.fp);
+            enable_feature(Feature::rdm, self.asimdrdm);
+            enable_feature(Feature::dotprod, self.asimddp);
+            enable_feature(Feature::frintts, self.frint);
+
+            // FEAT_I8MM & FEAT_BF16 also include optional SVE components which linux exposes
+            // separately. We ignore that distinction here.
+            enable_feature(Feature::i8mm, self.i8mm);
+            enable_feature(Feature::bf16, self.bf16);
+
+            // ASIMD support requires float support - if half-floats are
+            // supported, it also requires half-float support:
+            let asimd = self.fp && self.asimd && (!self.fphp | self.asimdhp);
+            enable_feature(Feature::asimd, asimd);
+            // ASIMD extensions require ASIMD support:
+            enable_feature(Feature::fcma, self.fcma && asimd);
+            enable_feature(Feature::sve, self.sve && asimd);
+
+            // SVE extensions require SVE & ASIMD
+            enable_feature(Feature::f32mm, self.svef32mm && self.sve && asimd);
+            enable_feature(Feature::f64mm, self.svef64mm && self.sve && asimd);
+
+            // Cryptographic extensions require ASIMD
+            enable_feature(Feature::aes, self.aes && asimd);
+            enable_feature(Feature::sha2, self.sha1 && self.sha2 && asimd);
+            // SHA512/SHA3 require SHA1 & SHA256
+            enable_feature(
+                Feature::sha3,
+                self.sha512 && self.sha3 && self.sha1 && self.sha2 && asimd,
+            );
+            enable_feature(Feature::sm4, self.sm3 && self.sm4 && asimd);
+
+            // SVE2 requires SVE
+            let sve2 = self.sve2 && self.sve && asimd;
+            enable_feature(Feature::sve2, sve2);
+            enable_feature(Feature::sve2p1, self.sve2p1 && sve2);
+            // SVE2 extensions require SVE2 and crypto features
+            enable_feature(
+                Feature::sve2_aes,
+                self.sveaes && self.svepmull && sve2 && self.aes,
+            );
+            enable_feature(
+                Feature::sve2_sm4,
+                self.svesm4 && sve2 && self.sm3 && self.sm4,
+            );
+            enable_feature(
+                Feature::sve2_sha3,
+                self.svesha3 && sve2 && self.sha512 && self.sha3 && self.sha1 && self.sha2,
+            );
+            enable_feature(Feature::sve2_bitperm, self.svebitperm && self.sve2);
+            enable_feature(Feature::sve_b16b16, self.bf16 && self.sveb16b16);
+            enable_feature(Feature::hbc, self.hbc);
+            enable_feature(Feature::mops, self.mops);
+            enable_feature(Feature::ecv, self.ecv);
+            enable_feature(Feature::lut, self.lut);
+            enable_feature(Feature::cssc, self.cssc);
+            enable_feature(Feature::fpmr, self.fpmr);
+            enable_feature(Feature::faminmax, self.faminmax);
+            let fp8 = self.f8cvt && self.faminmax && self.lut && self.bf16;
+            enable_feature(Feature::fp8, fp8);
+            let fp8fma = self.f8fma && fp8;
+            enable_feature(Feature::fp8fma, fp8fma);
+            let fp8dot4 = self.f8dp4 && fp8fma;
+            enable_feature(Feature::fp8dot4, fp8dot4);
+            enable_feature(Feature::fp8dot2, self.f8dp2 && fp8dot4);
+            enable_feature(Feature::wfxt, self.wfxt);
+            let sme = self.sme && self.bf16;
+            enable_feature(Feature::sme, sme);
+            enable_feature(Feature::sme_i16i64, self.smei16i64 && sme);
+            enable_feature(Feature::sme_f64f64, self.smef64f64 && sme);
+            enable_feature(Feature::sme_fa64, self.smefa64 && sme && sve2);
+            let sme2 = self.sme2 && sme;
+            enable_feature(Feature::sme2, sme2);
+            enable_feature(Feature::sme2p1, self.sme2p1 && sme2);
+            enable_feature(
+                Feature::sme_b16b16,
+                sme2 && self.bf16 && self.sveb16b16 && self.smeb16b16,
+            );
+            enable_feature(Feature::sme_f16f16, self.smef16f16 && sme2);
+            enable_feature(Feature::sme_lutv2, self.smelutv2);
+            let sme_f8f32 = self.smef8f32 && sme2 && fp8;
+            enable_feature(Feature::sme_f8f32, sme_f8f32);
+            enable_feature(Feature::sme_f8f16, self.smef8f16 && sme_f8f32);
+            let ssve_fp8fma = self.smesf8fma && sme2 && fp8;
+            enable_feature(Feature::ssve_fp8fma, ssve_fp8fma);
+            let ssve_fp8dot4 = self.smesf8dp4 && ssve_fp8fma;
+            enable_feature(Feature::ssve_fp8dot4, ssve_fp8dot4);
+            enable_feature(Feature::ssve_fp8dot2, self.smesf8dp2 && ssve_fp8dot4);
+        }
+        value
+    }
+}
+
+#[cfg(target_endian = "little")]
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(feature = "std_detect_file_io")]
+    mod auxv_from_file {
+        use super::auxvec::auxv_from_file;
+        use super::*;
+        // The baseline hwcaps used in the (artificial) auxv test files.
+        fn baseline_hwcaps() -> AtHwcap {
+            AtHwcap {
+                fp: true,
+                asimd: true,
+                aes: true,
+                pmull: true,
+                sha1: true,
+                sha2: true,
+                crc32: true,
+                atomics: true,
+                fphp: true,
+                asimdhp: true,
+                asimdrdm: true,
+                lrcpc: true,
+                dcpop: true,
+                asimddp: true,
+                ssbs: true,
+                ..AtHwcap::default()
+            }
+        }
+
+        #[test]
+        fn linux_empty_hwcap2_aarch64() {
+            let file = concat!(
+                env!("CARGO_MANIFEST_DIR"),
+                "/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv"
+            );
+            println!("file: {file}");
+            let v = auxv_from_file(file).unwrap();
+            println!("HWCAP : 0x{:0x}", v.hwcap);
+            println!("HWCAP2: 0x{:0x}", v.hwcap2);
+            assert_eq!(AtHwcap::from(v), baseline_hwcaps());
+        }
+        #[test]
+        fn linux_no_hwcap2_aarch64() {
+            let file = concat!(
+                env!("CARGO_MANIFEST_DIR"),
+                "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv"
+            );
+            println!("file: {file}");
+            let v = auxv_from_file(file).unwrap();
+            println!("HWCAP : 0x{:0x}", v.hwcap);
+            println!("HWCAP2: 0x{:0x}", v.hwcap2);
+            assert_eq!(AtHwcap::from(v), baseline_hwcaps());
+        }
+        #[test]
+        fn linux_hwcap2_aarch64() {
+            let file = concat!(
+                env!("CARGO_MANIFEST_DIR"),
+                "/src/detect/test_data/linux-hwcap2-aarch64.auxv"
+            );
+            println!("file: {file}");
+            let v = auxv_from_file(file).unwrap();
+            println!("HWCAP : 0x{:0x}", v.hwcap);
+            println!("HWCAP2: 0x{:0x}", v.hwcap2);
+            assert_eq!(
+                AtHwcap::from(v),
+                AtHwcap {
+                    // Some other HWCAP bits.
+                    paca: true,
+                    pacg: true,
+                    // HWCAP2-only bits.
+                    dcpodp: true,
+                    frint: true,
+                    rng: true,
+                    bti: true,
+                    mte: true,
+                    ..baseline_hwcaps()
+                }
+            );
+        }
+    }
+}
diff --git a/library/std_detect/src/detect/os/linux/arm.rs b/library/std_detect/src/detect/os/linux/arm.rs
new file mode 100644
index 00000000000..bbb173227d0
--- /dev/null
+++ b/library/std_detect/src/detect/os/linux/arm.rs
@@ -0,0 +1,34 @@
+//! Run-time feature detection for ARM on Linux.
+
+use super::auxvec;
+use crate::detect::{Feature, bit, cache};
+
+/// Try to read the features from the auxiliary vector.
+pub(crate) fn detect_features() -> cache::Initializer {
+    let mut value = cache::Initializer::default();
+    let enable_feature = |value: &mut cache::Initializer, f, enable| {
+        if enable {
+            value.set(f as u32);
+        }
+    };
+
+    // The values are part of the platform-specific [asm/hwcap.h][hwcap]
+    //
+    // [hwcap]: https://github.com/torvalds/linux/blob/master/arch/arm/include/uapi/asm/hwcap.h
+    if let Ok(auxv) = auxvec::auxv() {
+        enable_feature(&mut value, Feature::i8mm, bit::test(auxv.hwcap, 27));
+        enable_feature(&mut value, Feature::dotprod, bit::test(auxv.hwcap, 24));
+        enable_feature(&mut value, Feature::neon, bit::test(auxv.hwcap, 12));
+        enable_feature(&mut value, Feature::pmull, bit::test(auxv.hwcap2, 1));
+        enable_feature(&mut value, Feature::crc, bit::test(auxv.hwcap2, 4));
+        enable_feature(&mut value, Feature::aes, bit::test(auxv.hwcap2, 0));
+        // SHA2 requires SHA1 & SHA2 features
+        enable_feature(
+            &mut value,
+            Feature::sha2,
+            bit::test(auxv.hwcap2, 2) && bit::test(auxv.hwcap2, 3),
+        );
+        return value;
+    }
+    value
+}
diff --git a/library/std_detect/src/detect/os/linux/auxvec.rs b/library/std_detect/src/detect/os/linux/auxvec.rs
new file mode 100644
index 00000000000..54f52aa7533
--- /dev/null
+++ b/library/std_detect/src/detect/os/linux/auxvec.rs
@@ -0,0 +1,341 @@
+//! Parses ELF auxiliary vectors.
+#![allow(dead_code)]
+
+pub(crate) const AT_NULL: usize = 0;
+
+/// Key to access the CPU Hardware capabilities bitfield.
+pub(crate) const AT_HWCAP: usize = 16;
+/// Key to access the CPU Hardware capabilities 2 bitfield.
+#[cfg(any(
+    target_arch = "aarch64",
+    target_arch = "arm",
+    target_arch = "powerpc",
+    target_arch = "powerpc64",
+    target_arch = "s390x",
+))]
+pub(crate) const AT_HWCAP2: usize = 26;
+
+/// Cache HWCAP bitfields of the ELF Auxiliary Vector.
+///
+/// If an entry cannot be read all the bits in the bitfield are set to zero.
+/// This should be interpreted as all the features being disabled.
+#[derive(Debug, Copy, Clone)]
+#[cfg_attr(test, derive(PartialEq))]
+pub(crate) struct AuxVec {
+    pub hwcap: usize,
+    #[cfg(any(
+        target_arch = "aarch64",
+        target_arch = "arm",
+        target_arch = "powerpc",
+        target_arch = "powerpc64",
+        target_arch = "s390x",
+    ))]
+    pub hwcap2: usize,
+}
+
+/// ELF Auxiliary Vector
+///
+/// The auxiliary vector is a memory region in a running ELF program's stack
+/// composed of (key: usize, value: usize) pairs.
+///
+/// The keys used in the aux vector are platform dependent. For Linux, they are
+/// defined in [linux/auxvec.h][auxvec_h]. The hardware capabilities of a given
+/// CPU can be queried with the  `AT_HWCAP` and `AT_HWCAP2` keys.
+///
+/// There is no perfect way of reading the auxiliary vector.
+///
+/// - If the `std_detect_dlsym_getauxval` cargo feature is enabled, this will use
+///   `getauxval` if its linked to the binary, and otherwise proceed to a fallback implementation.
+///   When `std_detect_dlsym_getauxval` is disabled, this will assume that `getauxval` is
+///   linked to the binary - if that is not the case the behavior is undefined.
+/// - Otherwise, if the `std_detect_file_io` cargo feature is enabled, it will
+///   try to read `/proc/self/auxv`.
+/// - If that fails, this function returns an error.
+///
+/// Note that run-time feature detection is not invoked for features that can
+/// be detected at compile-time.
+///
+///  Note: The `std_detect_dlsym_getauxval` cargo feature is ignored on
+/// `*-linux-{gnu,musl,ohos}*` and `*-android*` targets because we can safely assume `getauxval`
+/// is linked to the binary.
+/// - `*-linux-gnu*` targets ([since Rust 1.64](https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.html))
+///   have glibc requirements higher than [glibc 2.16 that added `getauxval`](https://sourceware.org/legacy-ml/libc-announce/2012/msg00000.html).
+/// - `*-linux-musl*` targets ([at least since Rust 1.15](https://github.com/rust-lang/rust/blob/1.15.0/src/ci/docker/x86_64-musl/build-musl.sh#L15))
+///   use musl newer than [musl 1.1.0 that added `getauxval`](https://git.musl-libc.org/cgit/musl/tree/WHATSNEW?h=v1.1.0#n1197)
+/// - `*-linux-ohos*` targets use a [fork of musl 1.2](https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/native-lib/musl.md)
+/// - `*-android*` targets ([since Rust 1.68](https://blog.rust-lang.org/2023/01/09/android-ndk-update-r25.html))
+///   have the minimum supported API level higher than [Android 4.3 (API level 18) that added `getauxval`](https://github.com/aosp-mirror/platform_bionic/blob/d3ebc2f7c49a9893b114124d4a6b315f3a328764/libc/include/sys/auxv.h#L49).
+///
+/// For more information about when `getauxval` is available check the great
+/// [`auxv` crate documentation][auxv_docs].
+///
+/// [auxvec_h]: https://github.com/torvalds/linux/blob/master/include/uapi/linux/auxvec.h
+/// [auxv_docs]: https://docs.rs/auxv/0.3.3/auxv/
+pub(crate) fn auxv() -> Result<AuxVec, ()> {
+    // Try to call a getauxval function.
+    if let Ok(hwcap) = getauxval(AT_HWCAP) {
+        // Targets with only AT_HWCAP:
+        #[cfg(any(
+            target_arch = "riscv32",
+            target_arch = "riscv64",
+            target_arch = "mips",
+            target_arch = "mips64",
+            target_arch = "loongarch32",
+            target_arch = "loongarch64",
+        ))]
+        {
+            // Zero could indicate that no features were detected, but it's also used to indicate
+            // an error. In either case, try the fallback.
+            if hwcap != 0 {
+                return Ok(AuxVec { hwcap });
+            }
+        }
+
+        // Targets with AT_HWCAP and AT_HWCAP2:
+        #[cfg(any(
+            target_arch = "aarch64",
+            target_arch = "arm",
+            target_arch = "powerpc",
+            target_arch = "powerpc64",
+            target_arch = "s390x",
+        ))]
+        {
+            if let Ok(hwcap2) = getauxval(AT_HWCAP2) {
+                // Zero could indicate that no features were detected, but it's also used to indicate
+                // an error. In particular, on many platforms AT_HWCAP2 will be legitimately zero,
+                // since it contains the most recent feature flags. Use the fallback only if no
+                // features were detected at all.
+                if hwcap != 0 || hwcap2 != 0 {
+                    return Ok(AuxVec { hwcap, hwcap2 });
+                }
+            }
+        }
+
+        // Intentionnaly not used
+        let _ = hwcap;
+    }
+
+    #[cfg(feature = "std_detect_file_io")]
+    {
+        // If calling getauxval fails, try to read the auxiliary vector from
+        // its file:
+        auxv_from_file("/proc/self/auxv")
+    }
+    #[cfg(not(feature = "std_detect_file_io"))]
+    {
+        Err(())
+    }
+}
+
+/// Tries to read the `key` from the auxiliary vector by calling the
+/// `getauxval` function. If the function is not linked, this function return `Err`.
+fn getauxval(key: usize) -> Result<usize, ()> {
+    type F = unsafe extern "C" fn(libc::c_ulong) -> libc::c_ulong;
+    cfg_if::cfg_if! {
+        if #[cfg(all(
+            feature = "std_detect_dlsym_getauxval",
+            not(all(
+                target_os = "linux",
+                any(target_env = "gnu", target_env = "musl", target_env = "ohos"),
+            )),
+            not(target_os = "android"),
+        ))] {
+            let ffi_getauxval: F = unsafe {
+                let ptr = libc::dlsym(libc::RTLD_DEFAULT, c"getauxval".as_ptr());
+                if ptr.is_null() {
+                    return Err(());
+                }
+                core::mem::transmute(ptr)
+            };
+        } else {
+            let ffi_getauxval: F = libc::getauxval;
+        }
+    }
+    Ok(unsafe { ffi_getauxval(key as libc::c_ulong) as usize })
+}
+
+/// Tries to read the auxiliary vector from the `file`. If this fails, this
+/// function returns `Err`.
+#[cfg(feature = "std_detect_file_io")]
+pub(super) fn auxv_from_file(file: &str) -> Result<AuxVec, ()> {
+    let file = super::read_file(file)?;
+
+    // See <https://github.com/torvalds/linux/blob/v5.15/include/uapi/linux/auxvec.h>.
+    //
+    // The auxiliary vector contains at most 34 (key,value) fields: from
+    // `AT_MINSIGSTKSZ` to `AT_NULL`, but its number may increase.
+    let len = file.len();
+    let mut buf = alloc::vec![0_usize; 1 + len / core::mem::size_of::<usize>()];
+    unsafe {
+        core::ptr::copy_nonoverlapping(file.as_ptr(), buf.as_mut_ptr() as *mut u8, len);
+    }
+
+    auxv_from_buf(&buf)
+}
+
+/// Tries to interpret the `buffer` as an auxiliary vector. If that fails, this
+/// function returns `Err`.
+#[cfg(feature = "std_detect_file_io")]
+fn auxv_from_buf(buf: &[usize]) -> Result<AuxVec, ()> {
+    // Targets with only AT_HWCAP:
+    #[cfg(any(
+        target_arch = "riscv32",
+        target_arch = "riscv64",
+        target_arch = "mips",
+        target_arch = "mips64",
+        target_arch = "loongarch32",
+        target_arch = "loongarch64",
+    ))]
+    {
+        for el in buf.chunks(2) {
+            match el[0] {
+                AT_NULL => break,
+                AT_HWCAP => return Ok(AuxVec { hwcap: el[1] }),
+                _ => (),
+            }
+        }
+    }
+    // Targets with AT_HWCAP and AT_HWCAP2:
+    #[cfg(any(
+        target_arch = "aarch64",
+        target_arch = "arm",
+        target_arch = "powerpc",
+        target_arch = "powerpc64",
+        target_arch = "s390x",
+    ))]
+    {
+        let mut hwcap = None;
+        // For some platforms, AT_HWCAP2 was added recently, so let it default to zero.
+        let mut hwcap2 = 0;
+        for el in buf.chunks(2) {
+            match el[0] {
+                AT_NULL => break,
+                AT_HWCAP => hwcap = Some(el[1]),
+                AT_HWCAP2 => hwcap2 = el[1],
+                _ => (),
+            }
+        }
+
+        if let Some(hwcap) = hwcap {
+            return Ok(AuxVec { hwcap, hwcap2 });
+        }
+    }
+    // Suppress unused variable
+    let _ = buf;
+    Err(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // FIXME: on mips/mips64 getauxval returns 0, and /proc/self/auxv
+    // does not always contain the AT_HWCAP key under qemu.
+    #[cfg(any(
+        target_arch = "arm",
+        target_arch = "powerpc",
+        target_arch = "powerpc64",
+        target_arch = "s390x",
+    ))]
+    #[test]
+    fn auxv_crate() {
+        let v = auxv();
+        if let Ok(hwcap) = getauxval(AT_HWCAP) {
+            let rt_hwcap = v.expect("failed to find hwcap key").hwcap;
+            assert_eq!(rt_hwcap, hwcap);
+        }
+
+        // Targets with AT_HWCAP and AT_HWCAP2:
+        #[cfg(any(
+            target_arch = "aarch64",
+            target_arch = "arm",
+            target_arch = "powerpc",
+            target_arch = "powerpc64",
+            target_arch = "s390x",
+        ))]
+        {
+            if let Ok(hwcap2) = getauxval(AT_HWCAP2) {
+                let rt_hwcap2 = v.expect("failed to find hwcap2 key").hwcap2;
+                assert_eq!(rt_hwcap2, hwcap2);
+            }
+        }
+    }
+
+    #[test]
+    fn auxv_dump() {
+        if let Ok(auxvec) = auxv() {
+            println!("{:?}", auxvec);
+        } else {
+            println!("both getauxval() and reading /proc/self/auxv failed!");
+        }
+    }
+
+    #[cfg(feature = "std_detect_file_io")]
+    cfg_if::cfg_if! {
+        if #[cfg(target_arch = "arm")] {
+            #[test]
+            fn linux_rpi3() {
+                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-rpi3.auxv");
+                println!("file: {file}");
+                let v = auxv_from_file(file).unwrap();
+                assert_eq!(v.hwcap, 4174038);
+                assert_eq!(v.hwcap2, 16);
+            }
+
+            #[test]
+            fn linux_macos_vb() {
+                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv");
+                println!("file: {file}");
+                // The file contains HWCAP but not HWCAP2. In that case, we treat HWCAP2 as zero.
+                let v = auxv_from_file(file).unwrap();
+                assert_eq!(v.hwcap, 126614527);
+                assert_eq!(v.hwcap2, 0);
+            }
+        } else if #[cfg(target_arch = "aarch64")] {
+            #[cfg(target_endian = "little")]
+            #[test]
+            fn linux_artificial_aarch64() {
+                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-artificial-aarch64.auxv");
+                println!("file: {file}");
+                let v = auxv_from_file(file).unwrap();
+                assert_eq!(v.hwcap, 0x0123456789abcdef);
+                assert_eq!(v.hwcap2, 0x02468ace13579bdf);
+            }
+            #[cfg(target_endian = "little")]
+            #[test]
+            fn linux_no_hwcap2_aarch64() {
+                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv");
+                println!("file: {file}");
+                let v = auxv_from_file(file).unwrap();
+                // An absent HWCAP2 is treated as zero, and does not prevent acceptance of HWCAP.
+                assert_ne!(v.hwcap, 0);
+                assert_eq!(v.hwcap2, 0);
+            }
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "std_detect_file_io")]
+    fn auxv_dump_procfs() {
+        if let Ok(auxvec) = auxv_from_file("/proc/self/auxv") {
+            println!("{:?}", auxvec);
+        } else {
+            println!("reading /proc/self/auxv failed!");
+        }
+    }
+
+    #[cfg(any(
+        target_arch = "aarch64",
+        target_arch = "arm",
+        target_arch = "powerpc",
+        target_arch = "powerpc64",
+        target_arch = "s390x",
+    ))]
+    #[test]
+    #[cfg(feature = "std_detect_file_io")]
+    fn auxv_crate_procfs() {
+        if let Ok(procfs_auxv) = auxv_from_file("/proc/self/auxv") {
+            assert_eq!(auxv().unwrap(), procfs_auxv);
+        }
+    }
+}
diff --git a/library/std_detect/src/detect/os/linux/loongarch.rs b/library/std_detect/src/detect/os/linux/loongarch.rs
new file mode 100644
index 00000000000..14cc7a73183
--- /dev/null
+++ b/library/std_detect/src/detect/os/linux/loongarch.rs
@@ -0,0 +1,68 @@
+//! Run-time feature detection for LoongArch on Linux.
+
+use super::auxvec;
+use crate::detect::{Feature, bit, cache};
+use core::arch::asm;
+
+/// Try to read the features from the auxiliary vector.
+pub(crate) fn detect_features() -> cache::Initializer {
+    let mut value = cache::Initializer::default();
+    let enable_feature = |value: &mut cache::Initializer, feature, enable| {
+        if enable {
+            value.set(feature as u32);
+        }
+    };
+
+    // The values are part of the platform-specific [cpucfg]
+    //
+    // [cpucfg]: LoongArch Reference Manual Volume 1: Basic Architecture v1.1
+    let cpucfg2: usize;
+    unsafe {
+        asm!(
+            "cpucfg {}, {}",
+            out(reg) cpucfg2, in(reg) 2,
+            options(pure, nomem, preserves_flags, nostack)
+        );
+    }
+    let cpucfg3: usize;
+    unsafe {
+        asm!(
+            "cpucfg {}, {}",
+            out(reg) cpucfg3, in(reg) 3,
+            options(pure, nomem, preserves_flags, nostack)
+        );
+    }
+    enable_feature(&mut value, Feature::frecipe, bit::test(cpucfg2, 25));
+    enable_feature(&mut value, Feature::div32, bit::test(cpucfg2, 26));
+    enable_feature(&mut value, Feature::lam_bh, bit::test(cpucfg2, 27));
+    enable_feature(&mut value, Feature::lamcas, bit::test(cpucfg2, 28));
+    enable_feature(&mut value, Feature::scq, bit::test(cpucfg2, 30));
+    enable_feature(&mut value, Feature::ld_seq_sa, bit::test(cpucfg3, 23));
+
+    // The values are part of the platform-specific [asm/hwcap.h][hwcap]
+    //
+    // [hwcap]: https://github.com/torvalds/linux/blob/master/arch/loongarch/include/uapi/asm/hwcap.h
+    if let Ok(auxv) = auxvec::auxv() {
+        enable_feature(
+            &mut value,
+            Feature::f,
+            bit::test(cpucfg2, 1) && bit::test(auxv.hwcap, 3),
+        );
+        enable_feature(
+            &mut value,
+            Feature::d,
+            bit::test(cpucfg2, 2) && bit::test(auxv.hwcap, 3),
+        );
+        enable_feature(&mut value, Feature::lsx, bit::test(auxv.hwcap, 4));
+        enable_feature(&mut value, Feature::lasx, bit::test(auxv.hwcap, 5));
+        enable_feature(
+            &mut value,
+            Feature::lbt,
+            bit::test(auxv.hwcap, 10) && bit::test(auxv.hwcap, 11) && bit::test(auxv.hwcap, 12),
+        );
+        enable_feature(&mut value, Feature::lvz, bit::test(auxv.hwcap, 9));
+        enable_feature(&mut value, Feature::ual, bit::test(auxv.hwcap, 2));
+        return value;
+    }
+    value
+}
diff --git a/library/std_detect/src/detect/os/linux/mips.rs b/library/std_detect/src/detect/os/linux/mips.rs
new file mode 100644
index 00000000000..0cfa8869887
--- /dev/null
+++ b/library/std_detect/src/detect/os/linux/mips.rs
@@ -0,0 +1,23 @@
+//! Run-time feature detection for MIPS on Linux.
+
+use super::auxvec;
+use crate::detect::{Feature, bit, cache};
+
+/// Try to read the features from the auxiliary vector.
+pub(crate) fn detect_features() -> cache::Initializer {
+    let mut value = cache::Initializer::default();
+    let enable_feature = |value: &mut cache::Initializer, f, enable| {
+        if enable {
+            value.set(f as u32);
+        }
+    };
+
+    // The values are part of the platform-specific [asm/hwcap.h][hwcap]
+    //
+    // [hwcap]: https://github.com/torvalds/linux/blob/master/arch/mips/include/uapi/asm/hwcap.h
+    if let Ok(auxv) = auxvec::auxv() {
+        enable_feature(&mut value, Feature::msa, bit::test(auxv.hwcap, 1));
+        return value;
+    }
+    value
+}
diff --git a/library/std_detect/src/detect/os/linux/mod.rs b/library/std_detect/src/detect/os/linux/mod.rs
new file mode 100644
index 00000000000..9accd41717b
--- /dev/null
+++ b/library/std_detect/src/detect/os/linux/mod.rs
@@ -0,0 +1,67 @@
+//! Run-time feature detection on Linux
+//!
+#[cfg(feature = "std_detect_file_io")]
+use alloc::vec::Vec;
+
+mod auxvec;
+
+#[cfg(feature = "std_detect_file_io")]
+fn read_file(path: &str) -> Result<Vec<u8>, ()> {
+    let mut path = Vec::from(path.as_bytes());
+    path.push(0);
+
+    unsafe {
+        let file = libc::open(path.as_ptr() as *const libc::c_char, libc::O_RDONLY);
+        if file == -1 {
+            return Err(());
+        }
+
+        let mut data = Vec::new();
+        loop {
+            data.reserve(4096);
+            let spare = data.spare_capacity_mut();
+            match libc::read(file, spare.as_mut_ptr() as *mut _, spare.len()) {
+                -1 => {
+                    libc::close(file);
+                    return Err(());
+                }
+                0 => break,
+                n => data.set_len(data.len() + n as usize),
+            }
+        }
+
+        libc::close(file);
+        Ok(data)
+    }
+}
+
+cfg_if::cfg_if! {
+    if #[cfg(target_arch = "aarch64")] {
+        mod aarch64;
+        pub(crate) use self::aarch64::detect_features;
+    } else if #[cfg(target_arch = "arm")] {
+        mod arm;
+        pub(crate) use self::arm::detect_features;
+    } else if #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))] {
+        mod riscv;
+        pub(crate) use self::riscv::detect_features;
+    } else if #[cfg(any(target_arch = "mips", target_arch = "mips64"))] {
+        mod mips;
+        pub(crate) use self::mips::detect_features;
+    } else if #[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))] {
+        mod powerpc;
+        pub(crate) use self::powerpc::detect_features;
+    } else if #[cfg(any(target_arch = "loongarch32", target_arch = "loongarch64"))] {
+        mod loongarch;
+        pub(crate) use self::loongarch::detect_features;
+    } else if #[cfg(target_arch = "s390x")] {
+        mod s390x;
+        pub(crate) use self::s390x::detect_features;
+    } else {
+        use crate::detect::cache;
+        /// Performs run-time feature detection.
+        pub(crate) fn detect_features() -> cache::Initializer {
+            cache::Initializer::default()
+        }
+    }
+}
diff --git a/library/std_detect/src/detect/os/linux/powerpc.rs b/library/std_detect/src/detect/os/linux/powerpc.rs
new file mode 100644
index 00000000000..6a4f7e715d9
--- /dev/null
+++ b/library/std_detect/src/detect/os/linux/powerpc.rs
@@ -0,0 +1,35 @@
+//! Run-time feature detection for PowerPC on Linux.
+
+use super::auxvec;
+use crate::detect::{Feature, cache};
+
+/// Try to read the features from the auxiliary vector.
+pub(crate) fn detect_features() -> cache::Initializer {
+    let mut value = cache::Initializer::default();
+    let enable_feature = |value: &mut cache::Initializer, f, enable| {
+        if enable {
+            value.set(f as u32);
+        }
+    };
+
+    // The values are part of the platform-specific [asm/cputable.h][cputable]
+    //
+    // [cputable]: https://github.com/torvalds/linux/blob/master/arch/powerpc/include/uapi/asm/cputable.h
+    if let Ok(auxv) = auxvec::auxv() {
+        // note: the PowerPC values are the mask to do the test (instead of the
+        // index of the bit to test like in ARM and Aarch64)
+        enable_feature(&mut value, Feature::altivec, auxv.hwcap & 0x10000000 != 0);
+        enable_feature(&mut value, Feature::vsx, auxv.hwcap & 0x00000080 != 0);
+        let power8_features = auxv.hwcap2 & 0x80000000 != 0;
+        enable_feature(&mut value, Feature::power8, power8_features);
+        enable_feature(&mut value, Feature::power8_altivec, power8_features);
+        enable_feature(&mut value, Feature::power8_crypto, power8_features);
+        enable_feature(&mut value, Feature::power8_vector, power8_features);
+        let power9_features = auxv.hwcap2 & 0x00800000 != 0;
+        enable_feature(&mut value, Feature::power9, power9_features);
+        enable_feature(&mut value, Feature::power9_altivec, power9_features);
+        enable_feature(&mut value, Feature::power9_vector, power9_features);
+        return value;
+    }
+    value
+}
diff --git a/library/std_detect/src/detect/os/linux/riscv.rs b/library/std_detect/src/detect/os/linux/riscv.rs
new file mode 100644
index 00000000000..db20538af95
--- /dev/null
+++ b/library/std_detect/src/detect/os/linux/riscv.rs
@@ -0,0 +1,330 @@
+//! Run-time feature detection for RISC-V on Linux.
+//!
+//! On RISC-V, detection using auxv only supports single-letter extensions.
+//! So, we use riscv_hwprobe that supports multi-letter extensions if available.
+//! <https://www.kernel.org/doc/html/latest/arch/riscv/hwprobe.html>
+
+use core::ptr;
+
+use super::super::riscv::imply_features;
+use super::auxvec;
+use crate::detect::{Feature, bit, cache};
+
+// See <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/prctl.h?h=v6.15>
+// for runtime status query constants.
+const PR_RISCV_V_GET_CONTROL: libc::c_int = 70;
+const PR_RISCV_V_VSTATE_CTRL_ON: libc::c_int = 2;
+const PR_RISCV_V_VSTATE_CTRL_CUR_MASK: libc::c_int = 3;
+
+// See <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/include/uapi/asm/hwprobe.h?h=v6.15>
+// for riscv_hwprobe struct and hardware probing constants.
+
+#[repr(C)]
+struct riscv_hwprobe {
+    key: i64,
+    value: u64,
+}
+
+impl riscv_hwprobe {
+    // key is overwritten to -1 if not supported by riscv_hwprobe syscall.
+    pub fn get(&self) -> Option<u64> {
+        (self.key != -1).then_some(self.value)
+    }
+}
+
+#[allow(non_upper_case_globals)]
+const __NR_riscv_hwprobe: libc::c_long = 258;
+
+const RISCV_HWPROBE_KEY_BASE_BEHAVIOR: i64 = 3;
+const RISCV_HWPROBE_BASE_BEHAVIOR_IMA: u64 = 1 << 0;
+
+const RISCV_HWPROBE_KEY_IMA_EXT_0: i64 = 4;
+const RISCV_HWPROBE_IMA_FD: u64 = 1 << 0;
+const RISCV_HWPROBE_IMA_C: u64 = 1 << 1;
+const RISCV_HWPROBE_IMA_V: u64 = 1 << 2;
+const RISCV_HWPROBE_EXT_ZBA: u64 = 1 << 3;
+const RISCV_HWPROBE_EXT_ZBB: u64 = 1 << 4;
+const RISCV_HWPROBE_EXT_ZBS: u64 = 1 << 5;
+const RISCV_HWPROBE_EXT_ZICBOZ: u64 = 1 << 6;
+const RISCV_HWPROBE_EXT_ZBC: u64 = 1 << 7;
+const RISCV_HWPROBE_EXT_ZBKB: u64 = 1 << 8;
+const RISCV_HWPROBE_EXT_ZBKC: u64 = 1 << 9;
+const RISCV_HWPROBE_EXT_ZBKX: u64 = 1 << 10;
+const RISCV_HWPROBE_EXT_ZKND: u64 = 1 << 11;
+const RISCV_HWPROBE_EXT_ZKNE: u64 = 1 << 12;
+const RISCV_HWPROBE_EXT_ZKNH: u64 = 1 << 13;
+const RISCV_HWPROBE_EXT_ZKSED: u64 = 1 << 14;
+const RISCV_HWPROBE_EXT_ZKSH: u64 = 1 << 15;
+const RISCV_HWPROBE_EXT_ZKT: u64 = 1 << 16;
+const RISCV_HWPROBE_EXT_ZVBB: u64 = 1 << 17;
+const RISCV_HWPROBE_EXT_ZVBC: u64 = 1 << 18;
+const RISCV_HWPROBE_EXT_ZVKB: u64 = 1 << 19;
+const RISCV_HWPROBE_EXT_ZVKG: u64 = 1 << 20;
+const RISCV_HWPROBE_EXT_ZVKNED: u64 = 1 << 21;
+const RISCV_HWPROBE_EXT_ZVKNHA: u64 = 1 << 22;
+const RISCV_HWPROBE_EXT_ZVKNHB: u64 = 1 << 23;
+const RISCV_HWPROBE_EXT_ZVKSED: u64 = 1 << 24;
+const RISCV_HWPROBE_EXT_ZVKSH: u64 = 1 << 25;
+const RISCV_HWPROBE_EXT_ZVKT: u64 = 1 << 26;
+const RISCV_HWPROBE_EXT_ZFH: u64 = 1 << 27;
+const RISCV_HWPROBE_EXT_ZFHMIN: u64 = 1 << 28;
+const RISCV_HWPROBE_EXT_ZIHINTNTL: u64 = 1 << 29;
+const RISCV_HWPROBE_EXT_ZVFH: u64 = 1 << 30;
+const RISCV_HWPROBE_EXT_ZVFHMIN: u64 = 1 << 31;
+const RISCV_HWPROBE_EXT_ZFA: u64 = 1 << 32;
+const RISCV_HWPROBE_EXT_ZTSO: u64 = 1 << 33;
+const RISCV_HWPROBE_EXT_ZACAS: u64 = 1 << 34;
+const RISCV_HWPROBE_EXT_ZICOND: u64 = 1 << 35;
+const RISCV_HWPROBE_EXT_ZIHINTPAUSE: u64 = 1 << 36;
+const RISCV_HWPROBE_EXT_ZVE32X: u64 = 1 << 37;
+const RISCV_HWPROBE_EXT_ZVE32F: u64 = 1 << 38;
+const RISCV_HWPROBE_EXT_ZVE64X: u64 = 1 << 39;
+const RISCV_HWPROBE_EXT_ZVE64F: u64 = 1 << 40;
+const RISCV_HWPROBE_EXT_ZVE64D: u64 = 1 << 41;
+const RISCV_HWPROBE_EXT_ZIMOP: u64 = 1 << 42;
+const RISCV_HWPROBE_EXT_ZCA: u64 = 1 << 43;
+const RISCV_HWPROBE_EXT_ZCB: u64 = 1 << 44;
+const RISCV_HWPROBE_EXT_ZCD: u64 = 1 << 45;
+const RISCV_HWPROBE_EXT_ZCF: u64 = 1 << 46;
+const RISCV_HWPROBE_EXT_ZCMOP: u64 = 1 << 47;
+const RISCV_HWPROBE_EXT_ZAWRS: u64 = 1 << 48;
+// Excluded because it only reports the existence of `prctl`-based pointer masking control.
+// const RISCV_HWPROBE_EXT_SUPM: u64 = 1 << 49;
+const RISCV_HWPROBE_EXT_ZICNTR: u64 = 1 << 50;
+const RISCV_HWPROBE_EXT_ZIHPM: u64 = 1 << 51;
+const RISCV_HWPROBE_EXT_ZFBFMIN: u64 = 1 << 52;
+const RISCV_HWPROBE_EXT_ZVFBFMIN: u64 = 1 << 53;
+const RISCV_HWPROBE_EXT_ZVFBFWMA: u64 = 1 << 54;
+const RISCV_HWPROBE_EXT_ZICBOM: u64 = 1 << 55;
+const RISCV_HWPROBE_EXT_ZAAMO: u64 = 1 << 56;
+const RISCV_HWPROBE_EXT_ZALRSC: u64 = 1 << 57;
+
+const RISCV_HWPROBE_KEY_CPUPERF_0: i64 = 5;
+const RISCV_HWPROBE_MISALIGNED_FAST: u64 = 3;
+const RISCV_HWPROBE_MISALIGNED_MASK: u64 = 7;
+
+const RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF: i64 = 9;
+const RISCV_HWPROBE_MISALIGNED_SCALAR_FAST: u64 = 3;
+
+const RISCV_HWPROBE_KEY_MISALIGNED_VECTOR_PERF: i64 = 10;
+const RISCV_HWPROBE_MISALIGNED_VECTOR_FAST: u64 = 3;
+
+// syscall returns an unsupported error if riscv_hwprobe is not supported,
+// so we can safely use this function on older versions of Linux.
+fn _riscv_hwprobe(out: &mut [riscv_hwprobe]) -> bool {
+    unsafe fn __riscv_hwprobe(
+        pairs: *mut riscv_hwprobe,
+        pair_count: libc::size_t,
+        cpu_set_size: libc::size_t,
+        cpus: *mut libc::c_ulong,
+        flags: libc::c_uint,
+    ) -> libc::c_long {
+        unsafe {
+            libc::syscall(
+                __NR_riscv_hwprobe,
+                pairs,
+                pair_count,
+                cpu_set_size,
+                cpus,
+                flags,
+            )
+        }
+    }
+
+    unsafe { __riscv_hwprobe(out.as_mut_ptr(), out.len(), 0, ptr::null_mut(), 0) == 0 }
+}
+
+/// Read list of supported features from (1) the auxiliary vector
+/// and (2) the results of `riscv_hwprobe` and `prctl` system calls.
+pub(crate) fn detect_features() -> cache::Initializer {
+    let mut value = cache::Initializer::default();
+    let mut enable_feature = |feature, enable| {
+        if enable {
+            value.set(feature as u32);
+        }
+    };
+
+    // Use auxiliary vector to enable single-letter ISA extensions.
+    // The values are part of the platform-specific [asm/hwcap.h][hwcap]
+    //
+    // [hwcap]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/include/uapi/asm/hwcap.h?h=v6.15
+    let auxv = auxvec::auxv().expect("read auxvec"); // should not fail on RISC-V platform
+    let mut has_i = bit::test(auxv.hwcap, (b'i' - b'a').into());
+    #[allow(clippy::eq_op)]
+    enable_feature(Feature::a, bit::test(auxv.hwcap, (b'a' - b'a').into()));
+    enable_feature(Feature::c, bit::test(auxv.hwcap, (b'c' - b'a').into()));
+    enable_feature(Feature::d, bit::test(auxv.hwcap, (b'd' - b'a').into()));
+    enable_feature(Feature::f, bit::test(auxv.hwcap, (b'f' - b'a').into()));
+    enable_feature(Feature::m, bit::test(auxv.hwcap, (b'm' - b'a').into()));
+    let has_v = bit::test(auxv.hwcap, (b'v' - b'a').into());
+    let mut is_v_set = false;
+
+    // Use riscv_hwprobe syscall to query more extensions and
+    // performance-related capabilities.
+    'hwprobe: {
+        macro_rules! init {
+            { $($name: ident : $key: expr),* $(,)? } => {
+                #[repr(usize)]
+                enum Indices { $($name),* }
+                let mut t = [$(riscv_hwprobe { key: $key, value: 0 }),*];
+                macro_rules! data_mut { () => { &mut t } }
+                macro_rules! query { [$idx: ident] => { t[Indices::$idx as usize].get() } }
+            }
+        }
+        init! {
+            BaseBehavior: RISCV_HWPROBE_KEY_BASE_BEHAVIOR,
+            Extensions:   RISCV_HWPROBE_KEY_IMA_EXT_0,
+            MisalignedScalarPerf: RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF,
+            MisalignedVectorPerf: RISCV_HWPROBE_KEY_MISALIGNED_VECTOR_PERF,
+            MisalignedScalarPerfFallback: RISCV_HWPROBE_KEY_CPUPERF_0,
+        };
+        if !_riscv_hwprobe(data_mut!()) {
+            break 'hwprobe;
+        }
+
+        // Query scalar misaligned behavior.
+        if let Some(value) = query![MisalignedScalarPerf] {
+            enable_feature(
+                Feature::unaligned_scalar_mem,
+                value == RISCV_HWPROBE_MISALIGNED_SCALAR_FAST,
+            );
+        } else if let Some(value) = query![MisalignedScalarPerfFallback] {
+            // Deprecated method for fallback
+            enable_feature(
+                Feature::unaligned_scalar_mem,
+                value & RISCV_HWPROBE_MISALIGNED_MASK == RISCV_HWPROBE_MISALIGNED_FAST,
+            );
+        }
+
+        // Query vector misaligned behavior.
+        if let Some(value) = query![MisalignedVectorPerf] {
+            enable_feature(
+                Feature::unaligned_vector_mem,
+                value == RISCV_HWPROBE_MISALIGNED_VECTOR_FAST,
+            );
+        }
+
+        // Query whether "I" base and extensions "M" and "A" (as in the ISA
+        // manual version 2.2) are enabled.  "I" base at that time corresponds
+        // to "I", "Zicsr", "Zicntr" and "Zifencei" (as in the ISA manual version
+        // 20240411).
+        // This is a current requirement of
+        // `RISCV_HWPROBE_KEY_IMA_EXT_0`-based tests.
+        if query![BaseBehavior].is_none_or(|value| value & RISCV_HWPROBE_BASE_BEHAVIOR_IMA == 0) {
+            break 'hwprobe;
+        }
+        has_i = true;
+        enable_feature(Feature::zicsr, true);
+        enable_feature(Feature::zicntr, true);
+        enable_feature(Feature::zifencei, true);
+        enable_feature(Feature::m, true);
+        enable_feature(Feature::a, true);
+
+        // Enable features based on `RISCV_HWPROBE_KEY_IMA_EXT_0`.
+        let Some(ima_ext_0) = query![Extensions] else {
+            break 'hwprobe;
+        };
+        let test = |mask| (ima_ext_0 & mask) != 0;
+
+        enable_feature(Feature::d, test(RISCV_HWPROBE_IMA_FD)); // F is implied.
+        enable_feature(Feature::c, test(RISCV_HWPROBE_IMA_C));
+
+        enable_feature(Feature::zicntr, test(RISCV_HWPROBE_EXT_ZICNTR));
+        enable_feature(Feature::zihpm, test(RISCV_HWPROBE_EXT_ZIHPM));
+
+        enable_feature(Feature::zihintntl, test(RISCV_HWPROBE_EXT_ZIHINTNTL));
+        enable_feature(Feature::zihintpause, test(RISCV_HWPROBE_EXT_ZIHINTPAUSE));
+        enable_feature(Feature::zimop, test(RISCV_HWPROBE_EXT_ZIMOP));
+        enable_feature(Feature::zicbom, test(RISCV_HWPROBE_EXT_ZICBOM));
+        enable_feature(Feature::zicboz, test(RISCV_HWPROBE_EXT_ZICBOZ));
+        enable_feature(Feature::zicond, test(RISCV_HWPROBE_EXT_ZICOND));
+
+        enable_feature(Feature::zalrsc, test(RISCV_HWPROBE_EXT_ZALRSC));
+        enable_feature(Feature::zaamo, test(RISCV_HWPROBE_EXT_ZAAMO));
+        enable_feature(Feature::zawrs, test(RISCV_HWPROBE_EXT_ZAWRS));
+        enable_feature(Feature::zacas, test(RISCV_HWPROBE_EXT_ZACAS));
+        enable_feature(Feature::ztso, test(RISCV_HWPROBE_EXT_ZTSO));
+
+        enable_feature(Feature::zba, test(RISCV_HWPROBE_EXT_ZBA));
+        enable_feature(Feature::zbb, test(RISCV_HWPROBE_EXT_ZBB));
+        enable_feature(Feature::zbs, test(RISCV_HWPROBE_EXT_ZBS));
+        enable_feature(Feature::zbc, test(RISCV_HWPROBE_EXT_ZBC));
+
+        enable_feature(Feature::zbkb, test(RISCV_HWPROBE_EXT_ZBKB));
+        enable_feature(Feature::zbkc, test(RISCV_HWPROBE_EXT_ZBKC));
+        enable_feature(Feature::zbkx, test(RISCV_HWPROBE_EXT_ZBKX));
+        enable_feature(Feature::zknd, test(RISCV_HWPROBE_EXT_ZKND));
+        enable_feature(Feature::zkne, test(RISCV_HWPROBE_EXT_ZKNE));
+        enable_feature(Feature::zknh, test(RISCV_HWPROBE_EXT_ZKNH));
+        enable_feature(Feature::zksed, test(RISCV_HWPROBE_EXT_ZKSED));
+        enable_feature(Feature::zksh, test(RISCV_HWPROBE_EXT_ZKSH));
+        enable_feature(Feature::zkt, test(RISCV_HWPROBE_EXT_ZKT));
+
+        enable_feature(Feature::zcmop, test(RISCV_HWPROBE_EXT_ZCMOP));
+        enable_feature(Feature::zca, test(RISCV_HWPROBE_EXT_ZCA));
+        enable_feature(Feature::zcf, test(RISCV_HWPROBE_EXT_ZCF));
+        enable_feature(Feature::zcd, test(RISCV_HWPROBE_EXT_ZCD));
+        enable_feature(Feature::zcb, test(RISCV_HWPROBE_EXT_ZCB));
+
+        enable_feature(Feature::zfh, test(RISCV_HWPROBE_EXT_ZFH));
+        enable_feature(Feature::zfhmin, test(RISCV_HWPROBE_EXT_ZFHMIN));
+        enable_feature(Feature::zfa, test(RISCV_HWPROBE_EXT_ZFA));
+        enable_feature(Feature::zfbfmin, test(RISCV_HWPROBE_EXT_ZFBFMIN));
+
+        // Use prctl (if any) to determine whether the vector extension
+        // is enabled on the current thread (assuming the entire process
+        // share the same status).  If prctl fails (e.g. QEMU userland emulator
+        // as of version 9.2.3), use auxiliary vector to retrieve the default
+        // vector status on the process startup.
+        let has_vectors = {
+            let v_status = unsafe { libc::prctl(PR_RISCV_V_GET_CONTROL) };
+            if v_status >= 0 {
+                (v_status & PR_RISCV_V_VSTATE_CTRL_CUR_MASK) == PR_RISCV_V_VSTATE_CTRL_ON
+            } else {
+                has_v
+            }
+        };
+        if has_vectors {
+            enable_feature(Feature::v, test(RISCV_HWPROBE_IMA_V));
+            enable_feature(Feature::zve32x, test(RISCV_HWPROBE_EXT_ZVE32X));
+            enable_feature(Feature::zve32f, test(RISCV_HWPROBE_EXT_ZVE32F));
+            enable_feature(Feature::zve64x, test(RISCV_HWPROBE_EXT_ZVE64X));
+            enable_feature(Feature::zve64f, test(RISCV_HWPROBE_EXT_ZVE64F));
+            enable_feature(Feature::zve64d, test(RISCV_HWPROBE_EXT_ZVE64D));
+
+            enable_feature(Feature::zvbb, test(RISCV_HWPROBE_EXT_ZVBB));
+            enable_feature(Feature::zvbc, test(RISCV_HWPROBE_EXT_ZVBC));
+            enable_feature(Feature::zvkb, test(RISCV_HWPROBE_EXT_ZVKB));
+            enable_feature(Feature::zvkg, test(RISCV_HWPROBE_EXT_ZVKG));
+            enable_feature(Feature::zvkned, test(RISCV_HWPROBE_EXT_ZVKNED));
+            enable_feature(Feature::zvknha, test(RISCV_HWPROBE_EXT_ZVKNHA));
+            enable_feature(Feature::zvknhb, test(RISCV_HWPROBE_EXT_ZVKNHB));
+            enable_feature(Feature::zvksed, test(RISCV_HWPROBE_EXT_ZVKSED));
+            enable_feature(Feature::zvksh, test(RISCV_HWPROBE_EXT_ZVKSH));
+            enable_feature(Feature::zvkt, test(RISCV_HWPROBE_EXT_ZVKT));
+
+            enable_feature(Feature::zvfh, test(RISCV_HWPROBE_EXT_ZVFH));
+            enable_feature(Feature::zvfhmin, test(RISCV_HWPROBE_EXT_ZVFHMIN));
+            enable_feature(Feature::zvfbfmin, test(RISCV_HWPROBE_EXT_ZVFBFMIN));
+            enable_feature(Feature::zvfbfwma, test(RISCV_HWPROBE_EXT_ZVFBFWMA));
+        }
+        is_v_set = true;
+    };
+
+    // Set V purely depending on the auxiliary vector
+    // only if no fine-grained vector extension detection is available.
+    if !is_v_set {
+        enable_feature(Feature::v, has_v);
+    }
+
+    // Handle base ISA.
+    // If future RV128I is supported, implement with `enable_feature` here.
+    // Note that we should use `target_arch` instead of `target_pointer_width`
+    // to avoid misdetection caused by experimental ABIs such as RV64ILP32.
+    #[cfg(target_arch = "riscv64")]
+    enable_feature(Feature::rv64i, has_i);
+    #[cfg(target_arch = "riscv32")]
+    enable_feature(Feature::rv32i, has_i);
+
+    imply_features(value)
+}
diff --git a/library/std_detect/src/detect/os/linux/s390x.rs b/library/std_detect/src/detect/os/linux/s390x.rs
new file mode 100644
index 00000000000..9b53f526d61
--- /dev/null
+++ b/library/std_detect/src/detect/os/linux/s390x.rs
@@ -0,0 +1,152 @@
+//! Run-time feature detection for s390x on Linux.
+
+use super::auxvec;
+use crate::detect::{Feature, bit, cache};
+
+/// Try to read the features from the auxiliary vector
+pub(crate) fn detect_features() -> cache::Initializer {
+    let opt_hwcap: Option<AtHwcap> = auxvec::auxv().ok().map(Into::into);
+    let facilities = ExtendedFacilityList::new();
+    cache(opt_hwcap, facilities)
+}
+
+#[derive(Debug, Default, PartialEq)]
+struct AtHwcap {
+    esan3: bool,
+    zarch: bool,
+    stfle: bool,
+    msa: bool,
+    ldisp: bool,
+    eimm: bool,
+    dfp: bool,
+    hpage: bool,
+    etf3eh: bool,
+    high_gprs: bool,
+    te: bool,
+    vxrs: bool,
+    vxrs_bcd: bool,
+    vxrs_ext: bool,
+    gs: bool,
+    vxrs_ext2: bool,
+    vxrs_pde: bool,
+    sort: bool,
+    dflt: bool,
+    vxrs_pde2: bool,
+    nnpa: bool,
+    pci_mio: bool,
+    sie: bool,
+}
+
+impl From<auxvec::AuxVec> for AtHwcap {
+    /// Reads AtHwcap from the auxiliary vector.
+    fn from(auxv: auxvec::AuxVec) -> Self {
+        AtHwcap {
+            esan3: bit::test(auxv.hwcap, 0),
+            zarch: bit::test(auxv.hwcap, 1),
+            stfle: bit::test(auxv.hwcap, 2),
+            msa: bit::test(auxv.hwcap, 3),
+            ldisp: bit::test(auxv.hwcap, 4),
+            eimm: bit::test(auxv.hwcap, 5),
+            dfp: bit::test(auxv.hwcap, 6),
+            hpage: bit::test(auxv.hwcap, 7),
+            etf3eh: bit::test(auxv.hwcap, 8),
+            high_gprs: bit::test(auxv.hwcap, 9),
+            te: bit::test(auxv.hwcap, 10),
+            vxrs: bit::test(auxv.hwcap, 11),
+            vxrs_bcd: bit::test(auxv.hwcap, 12),
+            vxrs_ext: bit::test(auxv.hwcap, 13),
+            gs: bit::test(auxv.hwcap, 14),
+            vxrs_ext2: bit::test(auxv.hwcap, 15),
+            vxrs_pde: bit::test(auxv.hwcap, 16),
+            sort: bit::test(auxv.hwcap, 17),
+            dflt: bit::test(auxv.hwcap, 18),
+            vxrs_pde2: bit::test(auxv.hwcap, 19),
+            nnpa: bit::test(auxv.hwcap, 20),
+            pci_mio: bit::test(auxv.hwcap, 21),
+            sie: bit::test(auxv.hwcap, 22),
+        }
+    }
+}
+
+struct ExtendedFacilityList([u64; 4]);
+
+impl ExtendedFacilityList {
+    fn new() -> Self {
+        let mut result: [u64; 4] = [0; 4];
+        // SAFETY: rust/llvm only support s390x version with the `stfle` instruction.
+        unsafe {
+            core::arch::asm!(
+                // equivalently ".insn s, 0xb2b00000, 0({1})",
+                "stfle 0({})",
+                in(reg_addr) result.as_mut_ptr() ,
+                inout("r0") result.len() as u64 - 1 => _,
+                options(nostack)
+            );
+        }
+        Self(result)
+    }
+
+    const fn get_bit(&self, n: usize) -> bool {
+        // NOTE: bits are numbered from the left.
+        self.0[n / 64] & (1 << (63 - (n % 64))) != 0
+    }
+}
+
+/// Initializes the cache from the feature bits.
+///
+/// These values are part of the platform-specific [asm/elf.h][kernel], and are a selection of the
+/// fields found in the [Facility Indications].
+///
+/// [Facility Indications]: https://www.ibm.com/support/pages/sites/default/files/2021-05/SA22-7871-10.pdf#page=63
+/// [kernel]: https://github.com/torvalds/linux/blob/b62cef9a5c673f1b8083159f5dc03c1c5daced2f/arch/s390/include/asm/elf.h#L129
+fn cache(hwcap: Option<AtHwcap>, facilities: ExtendedFacilityList) -> cache::Initializer {
+    let mut value = cache::Initializer::default();
+
+    {
+        let mut enable_if_set = |bit_index, f| {
+            if facilities.get_bit(bit_index) {
+                value.set(f as u32);
+            }
+        };
+
+        // We use HWCAP for `vector` because it requires both hardware and kernel support.
+        if let Some(AtHwcap { vxrs: true, .. }) = hwcap {
+            // vector and related
+
+            enable_if_set(129, Feature::vector);
+
+            enable_if_set(135, Feature::vector_enhancements_1);
+            enable_if_set(148, Feature::vector_enhancements_2);
+            enable_if_set(198, Feature::vector_enhancements_3);
+
+            enable_if_set(134, Feature::vector_packed_decimal);
+            enable_if_set(152, Feature::vector_packed_decimal_enhancement);
+            enable_if_set(192, Feature::vector_packed_decimal_enhancement_2);
+            enable_if_set(199, Feature::vector_packed_decimal_enhancement_3);
+
+            enable_if_set(165, Feature::nnp_assist);
+        }
+
+        // others
+
+        enable_if_set(76, Feature::message_security_assist_extension3);
+        enable_if_set(77, Feature::message_security_assist_extension4);
+        enable_if_set(57, Feature::message_security_assist_extension5);
+        enable_if_set(146, Feature::message_security_assist_extension8);
+        enable_if_set(155, Feature::message_security_assist_extension9);
+        enable_if_set(86, Feature::message_security_assist_extension12);
+
+        enable_if_set(58, Feature::miscellaneous_extensions_2);
+        enable_if_set(61, Feature::miscellaneous_extensions_3);
+        enable_if_set(84, Feature::miscellaneous_extensions_4);
+
+        enable_if_set(45, Feature::high_word);
+        enable_if_set(73, Feature::transactional_execution);
+        enable_if_set(133, Feature::guarded_storage);
+        enable_if_set(150, Feature::enhanced_sort);
+        enable_if_set(151, Feature::deflate_conversion);
+        enable_if_set(201, Feature::concurrent_functions);
+    }
+
+    value
+}
diff --git a/library/std_detect/src/detect/os/openbsd/aarch64.rs b/library/std_detect/src/detect/os/openbsd/aarch64.rs
new file mode 100644
index 00000000000..cfe4ad10ad6
--- /dev/null
+++ b/library/std_detect/src/detect/os/openbsd/aarch64.rs
@@ -0,0 +1,55 @@
+//! Run-time feature detection for Aarch64 on OpenBSD.
+//!
+//! OpenBSD doesn't trap the mrs instruction, but exposes the system registers through sysctl.
+//! https://github.com/openbsd/src/commit/d335af936b9d7dd9cf655cae1ce19560c45de6c8
+//! https://github.com/golang/go/commit/cd54ef1f61945459486e9eea2f016d99ef1da925
+
+use crate::detect::cache;
+use core::{mem::MaybeUninit, ptr};
+
+// Defined in machine/cpu.h.
+// https://github.com/openbsd/src/blob/72ccc03bd11da614f31f7ff76e3f6fce99bc1c79/sys/arch/arm64/include/cpu.h#L25-L40
+const CPU_ID_AA64ISAR0: libc::c_int = 2;
+const CPU_ID_AA64ISAR1: libc::c_int = 3;
+const CPU_ID_AA64MMFR2: libc::c_int = 7;
+const CPU_ID_AA64PFR0: libc::c_int = 8;
+
+/// Try to read the features from the system registers.
+pub(crate) fn detect_features() -> cache::Initializer {
+    // ID_AA64ISAR0_EL1 and ID_AA64ISAR1_EL1 are supported on OpenBSD 7.1+.
+    // https://github.com/openbsd/src/commit/d335af936b9d7dd9cf655cae1ce19560c45de6c8
+    // Others are supported on OpenBSD 7.3+.
+    // https://github.com/openbsd/src/commit/c7654cd65262d532212f65123ee3905ba200365c
+    // sysctl returns an unsupported error if operation is not supported,
+    // so we can safely use this function on older versions of OpenBSD.
+    let aa64isar0 = sysctl64(&[libc::CTL_MACHDEP, CPU_ID_AA64ISAR0]).unwrap_or(0);
+    let aa64isar1 = sysctl64(&[libc::CTL_MACHDEP, CPU_ID_AA64ISAR1]).unwrap_or(0);
+    let aa64mmfr2 = sysctl64(&[libc::CTL_MACHDEP, CPU_ID_AA64MMFR2]).unwrap_or(0);
+    // Do not use unwrap_or(0) because in fp and asimd fields, 0 indicates that
+    // the feature is available.
+    let aa64pfr0 = sysctl64(&[libc::CTL_MACHDEP, CPU_ID_AA64PFR0]);
+
+    super::aarch64::parse_system_registers(aa64isar0, aa64isar1, aa64mmfr2, aa64pfr0)
+}
+
+#[inline]
+fn sysctl64(mib: &[libc::c_int]) -> Option<u64> {
+    const OUT_LEN: libc::size_t = core::mem::size_of::<u64>();
+    let mut out = MaybeUninit::<u64>::uninit();
+    let mut out_len = OUT_LEN;
+    let res = unsafe {
+        libc::sysctl(
+            mib.as_ptr(),
+            mib.len() as libc::c_uint,
+            out.as_mut_ptr() as *mut libc::c_void,
+            &mut out_len,
+            ptr::null_mut(),
+            0,
+        )
+    };
+    if res == -1 || out_len != OUT_LEN {
+        return None;
+    }
+    // SAFETY: we've checked that sysctl was successful and `out` was filled.
+    Some(unsafe { out.assume_init() })
+}
diff --git a/library/std_detect/src/detect/os/other.rs b/library/std_detect/src/detect/os/other.rs
new file mode 100644
index 00000000000..091fafc4ebf
--- /dev/null
+++ b/library/std_detect/src/detect/os/other.rs
@@ -0,0 +1,8 @@
+//! Other operating systems
+
+use crate::detect::cache;
+
+#[allow(dead_code)]
+pub(crate) fn detect_features() -> cache::Initializer {
+    cache::Initializer::default()
+}
diff --git a/library/std_detect/src/detect/os/riscv.rs b/library/std_detect/src/detect/os/riscv.rs
new file mode 100644
index 00000000000..4c59ede8029
--- /dev/null
+++ b/library/std_detect/src/detect/os/riscv.rs
@@ -0,0 +1,203 @@
+//! Run-time feature detection utility for RISC-V.
+//!
+//! On RISC-V, full feature detection needs a help of one or more
+//! feature detection mechanisms (usually provided by the operating system).
+//!
+//! RISC-V architecture defines many extensions and some have dependency to others.
+//! More importantly, some of them cannot be enabled without resolving such
+//! dependencies due to limited set of features that such mechanisms provide.
+//!
+//! This module provides an OS-independent utility to process such relations
+//! between RISC-V extensions.
+
+use crate::detect::{Feature, cache};
+
+/// Imply features by the given set of enabled features.
+///
+/// Note that it does not perform any consistency checks including existence of
+/// conflicting extensions and/or complicated requirements.  Eliminating such
+/// inconsistencies is the responsibility of the feature detection logic and
+/// its provider(s).
+pub(crate) fn imply_features(mut value: cache::Initializer) -> cache::Initializer {
+    loop {
+        // Check convergence of the feature flags later.
+        let prev = value;
+
+        // Expect that the optimizer turns repeated operations into
+        // a fewer number of bit-manipulation operations.
+        macro_rules! imply {
+            // Regular implication:
+            // A1 => (B1[, B2...]), A2 => (B1[, B2...]) and so on.
+            ($($from: ident)|+ => $($to: ident)&+) => {
+                if [$(Feature::$from as u32),+].iter().any(|&x| value.test(x)) {
+                    $(
+                        value.set(Feature::$to as u32);
+                    )+
+                }
+            };
+            // Implication with multiple requirements:
+            // A1 && A2 ... => (B1[, B2...]).
+            ($($from: ident)&+ => $($to: ident)&+) => {
+                if [$(Feature::$from as u32),+].iter().all(|&x| value.test(x)) {
+                    $(
+                        value.set(Feature::$to as u32);
+                    )+
+                }
+            };
+        }
+        macro_rules! group {
+            ($group: ident == $($member: ident)&+) => {
+                // Forward implication as defined in the specifications.
+                imply!($group => $($member)&+);
+                // Reverse implication to "group extension" from its members.
+                // This is not a part of specifications but convenient for
+                // feature detection and implemented in e.g. LLVM.
+                imply!($($member)&+ => $group);
+            };
+        }
+
+        /*
+            If a dependency/implication is not explicitly stated in the
+            specification, it is denoted as a comment as follows:
+            "defined as subset":
+                The latter extension is described as a subset of the former
+                (but the evidence is weak).
+            "functional":
+                The former extension is functionally a superset of the latter
+                (no direct references though).
+        */
+
+        imply!(zvbb => zvkb);
+
+        // Certain set of vector cryptography extensions form a group.
+        group!(zvkn == zvkned & zvknhb & zvkb & zvkt);
+        group!(zvknc == zvkn & zvbc);
+        group!(zvkng == zvkn & zvkg);
+        group!(zvks == zvksed & zvksh & zvkb & zvkt);
+        group!(zvksc == zvks & zvbc);
+        group!(zvksg == zvks & zvkg);
+
+        imply!(zvknhb => zvknha); // functional
+
+        // For vector cryptography, Zvknhb and Zvbc require integer arithmetic
+        // with EEW=64 (Zve64x) while others not depending on them
+        // require EEW=32 (Zve32x).
+        imply!(zvknhb | zvbc => zve64x);
+        imply!(zvbb | zvkb | zvkg | zvkned | zvknha | zvksed | zvksh => zve32x);
+
+        imply!(zbc => zbkc); // defined as subset
+        group!(zkn == zbkb & zbkc & zbkx & zkne & zknd & zknh);
+        group!(zks == zbkb & zbkc & zbkx & zksed & zksh);
+        group!(zk == zkn & zkr & zkt);
+
+        imply!(zacas => zaamo);
+        group!(a == zalrsc & zaamo);
+
+        group!(b == zba & zbb & zbs);
+
+        imply!(zcf => zca & f);
+        imply!(zcd => zca & d);
+        imply!(zcmop | zcb => zca);
+
+        imply!(zhinx => zhinxmin);
+        imply!(zdinx | zhinxmin => zfinx);
+
+        imply!(zvfh => zvfhmin); // functional
+        imply!(zvfh => zve32f & zfhmin);
+        imply!(zvfhmin => zve32f);
+        imply!(zvfbfwma => zvfbfmin & zfbfmin);
+        imply!(zvfbfmin => zve32f);
+
+        imply!(v => zve64d);
+        imply!(zve64d => zve64f & d);
+        imply!(zve64f => zve64x & zve32f);
+        imply!(zve64x => zve32x);
+        imply!(zve32f => zve32x & f);
+
+        imply!(zfh => zfhmin);
+        imply!(q => d);
+        imply!(d | zfhmin | zfa => f);
+        imply!(zfbfmin => f); // and some of (not all) "Zfh" instructions.
+
+        // Relatively complex implication rules from the "C" extension.
+        imply!(c => zca);
+        imply!(c & d => zcd);
+        #[cfg(target_arch = "riscv32")]
+        imply!(c & f => zcf);
+
+        imply!(zicntr | zihpm | f | zfinx | zve32x => zicsr);
+
+        // Loop until the feature flags converge.
+        if prev == value {
+            return value;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn simple_direct() {
+        let mut value = cache::Initializer::default();
+        value.set(Feature::f as u32);
+        // F (and other extensions with CSRs) -> Zicsr
+        assert!(imply_features(value).test(Feature::zicsr as u32));
+    }
+
+    #[test]
+    fn simple_indirect() {
+        let mut value = cache::Initializer::default();
+        value.set(Feature::q as u32);
+        // Q -> D, D -> F, F -> Zicsr
+        assert!(imply_features(value).test(Feature::zicsr as u32));
+    }
+
+    #[test]
+    fn complex_zcd() {
+        let mut value = cache::Initializer::default();
+        // C & D -> Zcd
+        value.set(Feature::c as u32);
+        assert!(!imply_features(value).test(Feature::zcd as u32));
+        value.set(Feature::d as u32);
+        assert!(imply_features(value).test(Feature::zcd as u32));
+    }
+
+    #[test]
+    fn group_simple_forward() {
+        let mut value = cache::Initializer::default();
+        // A -> Zalrsc & Zaamo (forward implication)
+        value.set(Feature::a as u32);
+        let value = imply_features(value);
+        assert!(value.test(Feature::zalrsc as u32));
+        assert!(value.test(Feature::zaamo as u32));
+    }
+
+    #[test]
+    fn group_simple_backward() {
+        let mut value = cache::Initializer::default();
+        // Zalrsc & Zaamo -> A (reverse implication)
+        value.set(Feature::zalrsc as u32);
+        value.set(Feature::zaamo as u32);
+        assert!(imply_features(value).test(Feature::a as u32));
+    }
+
+    #[test]
+    fn group_complex_convergence() {
+        let mut value = cache::Initializer::default();
+        // Needs 3 iterations to converge
+        // (and 4th iteration for convergence checking):
+        // 1.  [Zvksc] -> Zvks & Zvbc
+        // 2.  Zvks -> Zvksed & Zvksh & Zvkb & Zvkt
+        // 3a. [Zvkned] & [Zvknhb] & [Zvkb] & Zvkt -> {Zvkn}
+        // 3b. Zvkn & Zvbc -> {Zvknc}
+        value.set(Feature::zvksc as u32);
+        value.set(Feature::zvkned as u32);
+        value.set(Feature::zvknhb as u32);
+        value.set(Feature::zvkb as u32);
+        let value = imply_features(value);
+        assert!(value.test(Feature::zvkn as u32));
+        assert!(value.test(Feature::zvknc as u32));
+    }
+}
diff --git a/library/std_detect/src/detect/os/windows/aarch64.rs b/library/std_detect/src/detect/os/windows/aarch64.rs
new file mode 100644
index 00000000000..937f9f26eed
--- /dev/null
+++ b/library/std_detect/src/detect/os/windows/aarch64.rs
@@ -0,0 +1,125 @@
+//! Run-time feature detection for Aarch64 on Windows.
+
+use crate::detect::{Feature, cache};
+
+/// Try to read the features using IsProcessorFeaturePresent.
+pub(crate) fn detect_features() -> cache::Initializer {
+    type DWORD = u32;
+    type BOOL = i32;
+
+    const FALSE: BOOL = 0;
+    // The following Microsoft documents isn't updated for aarch64.
+    // https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-isprocessorfeaturepresent
+    // These are defined in winnt.h of Windows SDK
+    const PF_ARM_VFP_32_REGISTERS_AVAILABLE: u32 = 18;
+    const PF_ARM_NEON_INSTRUCTIONS_AVAILABLE: u32 = 19;
+    const PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE: u32 = 30;
+    const PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE: u32 = 31;
+    const PF_ARM_V81_ATOMIC_INSTRUCTIONS_AVAILABLE: u32 = 34;
+    const PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE: u32 = 43;
+    const PF_ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE: u32 = 44;
+    const PF_ARM_V83_LRCPC_INSTRUCTIONS_AVAILABLE: u32 = 45;
+    const PF_ARM_SVE_INSTRUCTIONS_AVAILABLE: u32 = 46;
+    const PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE: u32 = 47;
+    const PF_ARM_SVE2_1_INSTRUCTIONS_AVAILABLE: u32 = 48;
+    const PF_ARM_SVE_AES_INSTRUCTIONS_AVAILABLE: u32 = 49;
+    const PF_ARM_SVE_PMULL128_INSTRUCTIONS_AVAILABLE: u32 = 50;
+    const PF_ARM_SVE_BITPERM_INSTRUCTIONS_AVAILABLE: u32 = 51;
+    // const PF_ARM_SVE_BF16_INSTRUCTIONS_AVAILABLE: u32 = 52;
+    // const PF_ARM_SVE_EBF16_INSTRUCTIONS_AVAILABLE: u32 = 53;
+    const PF_ARM_SVE_B16B16_INSTRUCTIONS_AVAILABLE: u32 = 54;
+    const PF_ARM_SVE_SHA3_INSTRUCTIONS_AVAILABLE: u32 = 55;
+    const PF_ARM_SVE_SM4_INSTRUCTIONS_AVAILABLE: u32 = 56;
+    // const PF_ARM_SVE_I8MM_INSTRUCTIONS_AVAILABLE: u32 = 57;
+    // const PF_ARM_SVE_F32MM_INSTRUCTIONS_AVAILABLE: u32 = 58;
+    // const PF_ARM_SVE_F64MM_INSTRUCTIONS_AVAILABLE: u32 = 59;
+
+    unsafe extern "system" {
+        fn IsProcessorFeaturePresent(ProcessorFeature: DWORD) -> BOOL;
+    }
+
+    let mut value = cache::Initializer::default();
+    {
+        let mut enable_feature = |f, enable| {
+            if enable {
+                value.set(f as u32);
+            }
+        };
+
+        // Some features may be supported on current CPU,
+        // but no way to detect it by OS API.
+        // Also, we require unsafe block for the extern "system" calls.
+        unsafe {
+            enable_feature(
+                Feature::fp,
+                IsProcessorFeaturePresent(PF_ARM_VFP_32_REGISTERS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::asimd,
+                IsProcessorFeaturePresent(PF_ARM_NEON_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::crc,
+                IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::lse,
+                IsProcessorFeaturePresent(PF_ARM_V81_ATOMIC_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::dotprod,
+                IsProcessorFeaturePresent(PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::jsconv,
+                IsProcessorFeaturePresent(PF_ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::rcpc,
+                IsProcessorFeaturePresent(PF_ARM_V83_LRCPC_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::sve,
+                IsProcessorFeaturePresent(PF_ARM_SVE_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::sve2,
+                IsProcessorFeaturePresent(PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::sve2p1,
+                IsProcessorFeaturePresent(PF_ARM_SVE2_1_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::sve2_aes,
+                IsProcessorFeaturePresent(PF_ARM_SVE_AES_INSTRUCTIONS_AVAILABLE) != FALSE
+                    && IsProcessorFeaturePresent(PF_ARM_SVE_PMULL128_INSTRUCTIONS_AVAILABLE)
+                        != FALSE,
+            );
+            enable_feature(
+                Feature::sve2_bitperm,
+                IsProcessorFeaturePresent(PF_ARM_SVE_BITPERM_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::sve_b16b16,
+                IsProcessorFeaturePresent(PF_ARM_SVE_B16B16_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::sve2_sha3,
+                IsProcessorFeaturePresent(PF_ARM_SVE_SHA3_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            enable_feature(
+                Feature::sve2_sm4,
+                IsProcessorFeaturePresent(PF_ARM_SVE_SM4_INSTRUCTIONS_AVAILABLE) != FALSE,
+            );
+            // PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE means aes, sha1, sha2 and
+            // pmull support
+            let crypto =
+                IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE) != FALSE;
+            enable_feature(Feature::aes, crypto);
+            enable_feature(Feature::pmull, crypto);
+            enable_feature(Feature::sha2, crypto);
+        }
+    }
+    value
+}
diff --git a/library/std_detect/src/detect/os/x86.rs b/library/std_detect/src/detect/os/x86.rs
new file mode 100644
index 00000000000..8565c2f85e2
--- /dev/null
+++ b/library/std_detect/src/detect/os/x86.rs
@@ -0,0 +1,335 @@
+//! x86 run-time feature detection is OS independent.
+
+#[cfg(target_arch = "x86")]
+use core::arch::x86::*;
+#[cfg(target_arch = "x86_64")]
+use core::arch::x86_64::*;
+
+use core::mem;
+
+use crate::detect::{Feature, bit, cache};
+
+/// Run-time feature detection on x86 works by using the CPUID instruction.
+///
+/// The [CPUID Wikipedia page][wiki_cpuid] contains
+/// all the information about which flags to set to query which values, and in
+/// which registers these are reported.
+///
+/// The definitive references are:
+/// - [Intel 64 and IA-32 Architectures Software Developer's Manual Volume 2:
+///   Instruction Set Reference, A-Z][intel64_ref].
+/// - [AMD64 Architecture Programmer's Manual, Volume 3: General-Purpose and
+///   System Instructions][amd64_ref].
+///
+/// [wiki_cpuid]: https://en.wikipedia.org/wiki/CPUID
+/// [intel64_ref]: http://www.intel.de/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-instruction-set-reference-manual-325383.pdf
+/// [amd64_ref]: http://support.amd.com/TechDocs/24594.pdf
+#[allow(clippy::similar_names)]
+pub(crate) fn detect_features() -> cache::Initializer {
+    let mut value = cache::Initializer::default();
+
+    if cfg!(target_env = "sgx") {
+        // doesn't support this because it is untrusted data
+        return value;
+    }
+
+    // Calling `__cpuid`/`__cpuid_count` from here on is safe because the CPU
+    // has `cpuid` support.
+
+    // 0. EAX = 0: Basic Information:
+    // - EAX returns the "Highest Function Parameter", that is, the maximum
+    // leaf value for subsequent calls of `cpuinfo` in range [0,
+    // 0x8000_0000]. - The vendor ID is stored in 12 u8 ascii chars,
+    // returned in EBX, EDX, and   ECX (in that order):
+    let (max_basic_leaf, vendor_id) = unsafe {
+        let CpuidResult {
+            eax: max_basic_leaf,
+            ebx,
+            ecx,
+            edx,
+        } = __cpuid(0);
+        let vendor_id: [[u8; 4]; 3] = [ebx.to_ne_bytes(), edx.to_ne_bytes(), ecx.to_ne_bytes()];
+        let vendor_id: [u8; 12] = mem::transmute(vendor_id);
+        (max_basic_leaf, vendor_id)
+    };
+
+    if max_basic_leaf < 1 {
+        // Earlier Intel 486, CPUID not implemented
+        return value;
+    }
+
+    // EAX = 1, ECX = 0: Queries "Processor Info and Feature Bits";
+    // Contains information about most x86 features.
+    let CpuidResult {
+        ecx: proc_info_ecx,
+        edx: proc_info_edx,
+        ..
+    } = unsafe { __cpuid(0x0000_0001_u32) };
+
+    // EAX = 7: Queries "Extended Features";
+    // Contains information about bmi,bmi2, and avx2 support.
+    let (
+        extended_features_ebx,
+        extended_features_ecx,
+        extended_features_edx,
+        extended_features_eax_leaf_1,
+        extended_features_edx_leaf_1,
+    ) = if max_basic_leaf >= 7 {
+        let CpuidResult { ebx, ecx, edx, .. } = unsafe { __cpuid(0x0000_0007_u32) };
+        let CpuidResult {
+            eax: eax_1,
+            edx: edx_1,
+            ..
+        } = unsafe { __cpuid_count(0x0000_0007_u32, 0x0000_0001_u32) };
+        (ebx, ecx, edx, eax_1, edx_1)
+    } else {
+        (0, 0, 0, 0, 0) // CPUID does not support "Extended Features"
+    };
+
+    // EAX = 0x8000_0000, ECX = 0: Get Highest Extended Function Supported
+    // - EAX returns the max leaf value for extended information, that is,
+    // `cpuid` calls in range [0x8000_0000; u32::MAX]:
+    let CpuidResult {
+        eax: extended_max_basic_leaf,
+        ..
+    } = unsafe { __cpuid(0x8000_0000_u32) };
+
+    // EAX = 0x8000_0001, ECX=0: Queries "Extended Processor Info and Feature
+    // Bits"
+    let extended_proc_info_ecx = if extended_max_basic_leaf >= 1 {
+        let CpuidResult { ecx, .. } = unsafe { __cpuid(0x8000_0001_u32) };
+        ecx
+    } else {
+        0
+    };
+
+    {
+        // borrows value till the end of this scope:
+        let mut enable = |r, rb, f| {
+            let present = bit::test(r as usize, rb);
+            if present {
+                value.set(f as u32);
+            }
+            present
+        };
+
+        enable(proc_info_ecx, 0, Feature::sse3);
+        enable(proc_info_ecx, 1, Feature::pclmulqdq);
+        enable(proc_info_ecx, 9, Feature::ssse3);
+        enable(proc_info_ecx, 13, Feature::cmpxchg16b);
+        enable(proc_info_ecx, 19, Feature::sse4_1);
+        enable(proc_info_ecx, 20, Feature::sse4_2);
+        enable(proc_info_ecx, 22, Feature::movbe);
+        enable(proc_info_ecx, 23, Feature::popcnt);
+        enable(proc_info_ecx, 25, Feature::aes);
+        let f16c = enable(proc_info_ecx, 29, Feature::f16c);
+        enable(proc_info_ecx, 30, Feature::rdrand);
+        enable(extended_features_ebx, 18, Feature::rdseed);
+        enable(extended_features_ebx, 19, Feature::adx);
+        enable(extended_features_ebx, 11, Feature::rtm);
+        enable(proc_info_edx, 4, Feature::tsc);
+        enable(proc_info_edx, 23, Feature::mmx);
+        enable(proc_info_edx, 24, Feature::fxsr);
+        enable(proc_info_edx, 25, Feature::sse);
+        enable(proc_info_edx, 26, Feature::sse2);
+        enable(extended_features_ebx, 29, Feature::sha);
+
+        enable(extended_features_ecx, 8, Feature::gfni);
+        enable(extended_features_ecx, 9, Feature::vaes);
+        enable(extended_features_ecx, 10, Feature::vpclmulqdq);
+
+        enable(extended_features_ebx, 3, Feature::bmi1);
+        enable(extended_features_ebx, 8, Feature::bmi2);
+
+        enable(extended_features_ebx, 9, Feature::ermsb);
+
+        enable(extended_features_eax_leaf_1, 31, Feature::movrs);
+
+        // Detect if CPUID.19h available
+        if bit::test(extended_features_ecx as usize, 23) {
+            let CpuidResult { ebx, .. } = unsafe { __cpuid(0x19) };
+            enable(ebx, 0, Feature::kl);
+            enable(ebx, 2, Feature::widekl);
+        }
+
+        // `XSAVE` and `AVX` support:
+        let cpu_xsave = bit::test(proc_info_ecx as usize, 26);
+        if cpu_xsave {
+            // 0. Here the CPU supports `XSAVE`.
+
+            // 1. Detect `OSXSAVE`, that is, whether the OS is AVX enabled and
+            // supports saving the state of the AVX/AVX2 vector registers on
+            // context-switches, see:
+            //
+            // - [intel: is avx enabled?][is_avx_enabled],
+            // - [mozilla: sse.cpp][mozilla_sse_cpp].
+            //
+            // [is_avx_enabled]: https://software.intel.com/en-us/blogs/2011/04/14/is-avx-enabled
+            // [mozilla_sse_cpp]: https://hg.mozilla.org/mozilla-central/file/64bab5cbb9b6/mozglue/build/SSE.cpp#l190
+            let cpu_osxsave = bit::test(proc_info_ecx as usize, 27);
+
+            if cpu_osxsave {
+                // 2. The OS must have signaled the CPU that it supports saving and
+                // restoring the:
+                //
+                // * SSE -> `XCR0.SSE[1]`
+                // * AVX -> `XCR0.AVX[2]`
+                // * AVX-512 -> `XCR0.AVX-512[7:5]`.
+                // * AMX -> `XCR0.AMX[18:17]`
+                //
+                // by setting the corresponding bits of `XCR0` to `1`.
+                //
+                // This is safe because the CPU supports `xsave`
+                // and the OS has set `osxsave`.
+                let xcr0 = unsafe { _xgetbv(0) };
+                // Test `XCR0.SSE[1]` and `XCR0.AVX[2]` with the mask `0b110 == 6`:
+                let os_avx_support = xcr0 & 6 == 6;
+                // Test `XCR0.AVX-512[7:5]` with the mask `0b1110_0000 == 0xe0`:
+                let os_avx512_support = xcr0 & 0xe0 == 0xe0;
+                // Test `XCR0.AMX[18:17]` with the mask `0b110_0000_0000_0000_0000 == 0x60000`
+                let os_amx_support = xcr0 & 0x60000 == 0x60000;
+
+                // Only if the OS and the CPU support saving/restoring the AVX
+                // registers we enable `xsave` support:
+                if os_avx_support {
+                    // See "13.3 ENABLING THE XSAVE FEATURE SET AND XSAVE-ENABLED
+                    // FEATURES" in the "Intel® 64 and IA-32 Architectures Software
+                    // Developer’s Manual, Volume 1: Basic Architecture":
+                    //
+                    // "Software enables the XSAVE feature set by setting
+                    // CR4.OSXSAVE[bit 18] to 1 (e.g., with the MOV to CR4
+                    // instruction). If this bit is 0, execution of any of XGETBV,
+                    // XRSTOR, XRSTORS, XSAVE, XSAVEC, XSAVEOPT, XSAVES, and XSETBV
+                    // causes an invalid-opcode exception (#UD)"
+                    //
+                    enable(proc_info_ecx, 26, Feature::xsave);
+
+                    // For `xsaveopt`, `xsavec`, and `xsaves` we need to query:
+                    // Processor Extended State Enumeration Sub-leaf (EAX = 0DH,
+                    // ECX = 1):
+                    if max_basic_leaf >= 0xd {
+                        let CpuidResult {
+                            eax: proc_extended_state1_eax,
+                            ..
+                        } = unsafe { __cpuid_count(0xd_u32, 1) };
+                        enable(proc_extended_state1_eax, 0, Feature::xsaveopt);
+                        enable(proc_extended_state1_eax, 1, Feature::xsavec);
+                        enable(proc_extended_state1_eax, 3, Feature::xsaves);
+                    }
+
+                    // FMA (uses 256-bit wide registers):
+                    let fma = enable(proc_info_ecx, 12, Feature::fma);
+
+                    // And AVX/AVX2:
+                    enable(proc_info_ecx, 28, Feature::avx);
+                    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);
+                    enable(extended_features_edx_leaf_1, 5, Feature::avxneconvert);
+                    enable(extended_features_edx_leaf_1, 10, Feature::avxvnniint16);
+
+                    enable(extended_features_eax_leaf_1, 0, Feature::sha512);
+                    enable(extended_features_eax_leaf_1, 1, Feature::sm3);
+                    enable(extended_features_eax_leaf_1, 2, Feature::sm4);
+
+                    // For AVX-512 the OS also needs to support saving/restoring
+                    // the extended state, only then we enable AVX-512 support:
+                    // Also, Rust makes `avx512f` imply `fma` and `f16c`, because
+                    // otherwise the assembler is broken. But Intel doesn't guarantee
+                    // that `fma` and `f16c` are available with `avx512f`, so we
+                    // need to check for them separately.
+                    if os_avx512_support && f16c && fma {
+                        enable(extended_features_ebx, 16, Feature::avx512f);
+                        enable(extended_features_ebx, 17, Feature::avx512dq);
+                        enable(extended_features_ebx, 21, Feature::avx512ifma);
+                        enable(extended_features_ebx, 26, Feature::avx512pf);
+                        enable(extended_features_ebx, 27, Feature::avx512er);
+                        enable(extended_features_ebx, 28, Feature::avx512cd);
+                        enable(extended_features_ebx, 30, Feature::avx512bw);
+                        enable(extended_features_ebx, 31, Feature::avx512vl);
+                        enable(extended_features_ecx, 1, Feature::avx512vbmi);
+                        enable(extended_features_ecx, 6, Feature::avx512vbmi2);
+                        enable(extended_features_ecx, 11, Feature::avx512vnni);
+                        enable(extended_features_ecx, 12, Feature::avx512bitalg);
+                        enable(extended_features_ecx, 14, Feature::avx512vpopcntdq);
+                        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);
+
+                    if max_basic_leaf >= 0x1e {
+                        let CpuidResult {
+                            eax: amx_feature_flags_eax,
+                            ..
+                        } = unsafe { __cpuid_count(0x1e_u32, 1) };
+
+                        enable(amx_feature_flags_eax, 4, Feature::amx_fp8);
+                        enable(amx_feature_flags_eax, 5, Feature::amx_transpose);
+                        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);
+                    }
+                }
+            }
+        }
+
+        // This detects ABM on AMD CPUs and LZCNT on Intel CPUs.
+        // On intel CPUs with popcnt, lzcnt implements the
+        // "missing part" of ABM, so we map both to the same
+        // internal feature.
+        //
+        // The `is_x86_feature_detected!("lzcnt")` macro then
+        // internally maps to Feature::abm.
+        enable(extended_proc_info_ecx, 5, Feature::lzcnt);
+
+        // As Hygon Dhyana originates from AMD technology and shares most of the architecture with
+        // AMD's family 17h, but with different CPU Vendor ID("HygonGenuine")/Family series
+        // number(Family 18h).
+        //
+        // For CPUID feature bits, Hygon Dhyana(family 18h) share the same definition with AMD
+        // family 17h.
+        //
+        // Related AMD CPUID specification is https://www.amd.com/system/files/TechDocs/25481.pdf.
+        // Related Hygon kernel patch can be found on
+        // http://lkml.kernel.org/r/5ce86123a7b9dad925ac583d88d2f921040e859b.1538583282.git.puwen@hygon.cn
+        if vendor_id == *b"AuthenticAMD" || vendor_id == *b"HygonGenuine" {
+            // These features are available on AMD arch CPUs:
+            enable(extended_proc_info_ecx, 6, Feature::sse4a);
+            enable(extended_proc_info_ecx, 21, Feature::tbm);
+            enable(extended_proc_info_ecx, 11, Feature::xop);
+        }
+    }
+
+    // Unfortunately, some Skylake chips erroneously report support for BMI1 and
+    // BMI2 without actual support. These chips don't support AVX, and it seems
+    // that all Intel chips with non-erroneous support BMI do (I didn't check
+    // other vendors), so we can disable these flags for chips that don't also
+    // report support for AVX.
+    //
+    // It's possible this will pessimize future chips that do support BMI and
+    // not AVX, but this seems minor compared to a hard crash you get when
+    // executing an unsupported instruction (to put it another way, it's safe
+    // for us to under-report CPU features, but not to over-report them). Still,
+    // to limit any impact this may have in the future, we only do this for
+    // Intel chips, as it's a bug only present in their chips.
+    //
+    // This bug is documented as `SKL052` in the errata section of this document:
+    // http://www.intel.com/content/dam/www/public/us/en/documents/specification-updates/desktop-6th-gen-core-family-spec-update.pdf
+    if vendor_id == *b"GenuineIntel" && !value.test(Feature::avx as u32) {
+        value.unset(Feature::bmi1 as u32);
+        value.unset(Feature::bmi2 as u32);
+    }
+
+    value
+}
diff --git a/library/std_detect/src/detect/test_data/linux-artificial-aarch64.auxv b/library/std_detect/src/detect/test_data/linux-artificial-aarch64.auxv
new file mode 100644
index 00000000000..ec826afcf38
Binary files /dev/null and b/library/std_detect/src/detect/test_data/linux-artificial-aarch64.auxv differ
diff --git a/library/std_detect/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv b/library/std_detect/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv
new file mode 100644
index 00000000000..95537b73f20
Binary files /dev/null and b/library/std_detect/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv differ
diff --git a/library/std_detect/src/detect/test_data/linux-hwcap2-aarch64.auxv b/library/std_detect/src/detect/test_data/linux-hwcap2-aarch64.auxv
new file mode 100644
index 00000000000..1d87264b221
Binary files /dev/null and b/library/std_detect/src/detect/test_data/linux-hwcap2-aarch64.auxv differ
diff --git a/library/std_detect/src/detect/test_data/linux-no-hwcap2-aarch64.auxv b/library/std_detect/src/detect/test_data/linux-no-hwcap2-aarch64.auxv
new file mode 100644
index 00000000000..35f01cc767c
Binary files /dev/null and b/library/std_detect/src/detect/test_data/linux-no-hwcap2-aarch64.auxv differ
diff --git a/library/std_detect/src/detect/test_data/linux-rpi3.auxv b/library/std_detect/src/detect/test_data/linux-rpi3.auxv
new file mode 100644
index 00000000000..0538e661f63
Binary files /dev/null and b/library/std_detect/src/detect/test_data/linux-rpi3.auxv differ
diff --git a/library/std_detect/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv b/library/std_detect/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv
new file mode 100644
index 00000000000..75abc02d178
Binary files /dev/null and b/library/std_detect/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv differ
diff --git a/library/std_detect/src/lib.rs b/library/std_detect/src/lib.rs
new file mode 100644
index 00000000000..ab1b77bad5b
--- /dev/null
+++ b/library/std_detect/src/lib.rs
@@ -0,0 +1,36 @@
+//! Run-time feature detection for the Rust standard library.
+//!
+//! To detect whether a feature is enabled in the system running the binary
+//! use one of the appropriate macro for the target:
+//!
+//! * `x86` and `x86_64`: [`is_x86_feature_detected`]
+//! * `arm`: [`is_arm_feature_detected`]
+//! * `aarch64`: [`is_aarch64_feature_detected`]
+//! * `riscv`: [`is_riscv_feature_detected`]
+//! * `mips`: [`is_mips_feature_detected`]
+//! * `mips64`: [`is_mips64_feature_detected`]
+//! * `powerpc`: [`is_powerpc_feature_detected`]
+//! * `powerpc64`: [`is_powerpc64_feature_detected`]
+//! * `loongarch`: [`is_loongarch_feature_detected`]
+//! * `s390x`: [`is_s390x_feature_detected`]
+
+#![unstable(feature = "stdarch_internal", issue = "none")]
+#![feature(staged_api, doc_cfg, allow_internal_unstable)]
+#![deny(rust_2018_idioms)]
+#![allow(clippy::shadow_reuse)]
+#![cfg_attr(test, allow(unused_imports))]
+#![no_std]
+#![allow(internal_features)]
+
+#[cfg(test)]
+#[macro_use]
+extern crate std;
+
+// rust-lang/rust#83888: removing `extern crate` gives an error that `vec_spare>
+#[cfg_attr(feature = "std_detect_file_io", allow(unused_extern_crates))]
+#[cfg(feature = "std_detect_file_io")]
+extern crate alloc;
+
+#[doc(hidden)]
+#[unstable(feature = "stdarch_internal", issue = "none")]
+pub mod detect;
diff --git a/library/std_detect/tests/cpu-detection.rs b/library/std_detect/tests/cpu-detection.rs
new file mode 100644
index 00000000000..7976aedc758
--- /dev/null
+++ b/library/std_detect/tests/cpu-detection.rs
@@ -0,0 +1,354 @@
+#![allow(internal_features)]
+#![feature(stdarch_internal)]
+#![cfg_attr(target_arch = "arm", feature(stdarch_arm_feature_detection))]
+#![cfg_attr(
+    any(target_arch = "aarch64", target_arch = "arm64ec"),
+    feature(stdarch_aarch64_feature_detection)
+)]
+#![cfg_attr(
+    any(target_arch = "riscv32", target_arch = "riscv64"),
+    feature(stdarch_riscv_feature_detection)
+)]
+#![cfg_attr(target_arch = "powerpc", feature(stdarch_powerpc_feature_detection))]
+#![cfg_attr(target_arch = "powerpc64", feature(stdarch_powerpc_feature_detection))]
+#![cfg_attr(target_arch = "s390x", feature(stdarch_s390x_feature_detection))]
+#![allow(clippy::unwrap_used, clippy::use_debug, clippy::print_stdout)]
+
+#[cfg_attr(
+    any(
+        target_arch = "arm",
+        target_arch = "aarch64",
+        target_arch = "arm64ec",
+        target_arch = "riscv32",
+        target_arch = "riscv64",
+        target_arch = "powerpc",
+        target_arch = "powerpc64",
+        target_arch = "s390x",
+    ),
+    macro_use
+)]
+extern crate std_detect;
+
+#[test]
+fn all() {
+    for (f, e) in std_detect::detect::features() {
+        println!("{f}: {e}");
+    }
+}
+
+#[test]
+#[cfg(all(target_arch = "arm", target_os = "freebsd"))]
+fn arm_freebsd() {
+    println!("neon: {}", is_arm_feature_detected!("neon"));
+    println!("pmull: {}", is_arm_feature_detected!("pmull"));
+    println!("crc: {}", is_arm_feature_detected!("crc"));
+    println!("aes: {}", is_arm_feature_detected!("aes"));
+    println!("sha2: {}", is_arm_feature_detected!("sha2"));
+}
+
+#[test]
+#[cfg(all(target_arch = "arm", any(target_os = "linux", target_os = "android")))]
+fn arm_linux() {
+    println!("neon: {}", is_arm_feature_detected!("neon"));
+    println!("pmull: {}", is_arm_feature_detected!("pmull"));
+    println!("crc: {}", is_arm_feature_detected!("crc"));
+    println!("aes: {}", is_arm_feature_detected!("aes"));
+    println!("sha2: {}", is_arm_feature_detected!("sha2"));
+    println!("dotprod: {}", is_arm_feature_detected!("dotprod"));
+    println!("i8mm: {}", is_arm_feature_detected!("i8mm"));
+}
+
+#[test]
+#[cfg(all(
+    target_arch = "aarch64",
+    any(target_os = "linux", target_os = "android")
+))]
+fn aarch64_linux() {
+    println!("asimd: {}", is_aarch64_feature_detected!("asimd"));
+    println!("neon: {}", is_aarch64_feature_detected!("neon"));
+    println!("pmull: {}", is_aarch64_feature_detected!("pmull"));
+    println!("fp: {}", is_aarch64_feature_detected!("fp"));
+    println!("fp16: {}", is_aarch64_feature_detected!("fp16"));
+    println!("sve: {}", is_aarch64_feature_detected!("sve"));
+    println!("crc: {}", is_aarch64_feature_detected!("crc"));
+    println!("lse: {}", is_aarch64_feature_detected!("lse"));
+    println!("lse2: {}", is_aarch64_feature_detected!("lse2"));
+    println!("lse128: {}", is_aarch64_feature_detected!("lse128"));
+    println!("rdm: {}", is_aarch64_feature_detected!("rdm"));
+    println!("rcpc: {}", is_aarch64_feature_detected!("rcpc"));
+    println!("rcpc2: {}", is_aarch64_feature_detected!("rcpc2"));
+    println!("rcpc3: {}", is_aarch64_feature_detected!("rcpc3"));
+    println!("dotprod: {}", is_aarch64_feature_detected!("dotprod"));
+    println!("tme: {}", is_aarch64_feature_detected!("tme"));
+    println!("fhm: {}", is_aarch64_feature_detected!("fhm"));
+    println!("dit: {}", is_aarch64_feature_detected!("dit"));
+    println!("flagm: {}", is_aarch64_feature_detected!("flagm"));
+    println!("flagm2: {}", is_aarch64_feature_detected!("flagm2"));
+    println!("ssbs: {}", is_aarch64_feature_detected!("ssbs"));
+    println!("sb: {}", is_aarch64_feature_detected!("sb"));
+    println!("paca: {}", is_aarch64_feature_detected!("paca"));
+    println!("pacg: {}", is_aarch64_feature_detected!("pacg"));
+    // println!("pauth-lr: {}", is_aarch64_feature_detected!("pauth-lr"));
+    println!("dpb: {}", is_aarch64_feature_detected!("dpb"));
+    println!("dpb2: {}", is_aarch64_feature_detected!("dpb2"));
+    println!("sve-b16b16: {}", is_aarch64_feature_detected!("sve-b16b16"));
+    println!("sve2: {}", is_aarch64_feature_detected!("sve2"));
+    println!("sve2p1: {}", is_aarch64_feature_detected!("sve2p1"));
+    println!("sve2-aes: {}", is_aarch64_feature_detected!("sve2-aes"));
+    println!("sve2-sm4: {}", is_aarch64_feature_detected!("sve2-sm4"));
+    println!("sve2-sha3: {}", is_aarch64_feature_detected!("sve2-sha3"));
+    println!(
+        "sve2-bitperm: {}",
+        is_aarch64_feature_detected!("sve2-bitperm")
+    );
+    println!("frintts: {}", is_aarch64_feature_detected!("frintts"));
+    println!("i8mm: {}", is_aarch64_feature_detected!("i8mm"));
+    println!("f32mm: {}", is_aarch64_feature_detected!("f32mm"));
+    println!("f64mm: {}", is_aarch64_feature_detected!("f64mm"));
+    println!("bf16: {}", is_aarch64_feature_detected!("bf16"));
+    println!("rand: {}", is_aarch64_feature_detected!("rand"));
+    println!("bti: {}", is_aarch64_feature_detected!("bti"));
+    println!("mte: {}", is_aarch64_feature_detected!("mte"));
+    println!("jsconv: {}", is_aarch64_feature_detected!("jsconv"));
+    println!("fcma: {}", is_aarch64_feature_detected!("fcma"));
+    println!("aes: {}", is_aarch64_feature_detected!("aes"));
+    println!("sha2: {}", is_aarch64_feature_detected!("sha2"));
+    println!("sha3: {}", is_aarch64_feature_detected!("sha3"));
+    println!("sm4: {}", is_aarch64_feature_detected!("sm4"));
+    println!("hbc: {}", is_aarch64_feature_detected!("hbc"));
+    println!("mops: {}", is_aarch64_feature_detected!("mops"));
+    println!("ecv: {}", is_aarch64_feature_detected!("ecv"));
+    println!("cssc: {}", is_aarch64_feature_detected!("cssc"));
+    println!("fpmr: {}", is_aarch64_feature_detected!("fpmr"));
+    println!("lut: {}", is_aarch64_feature_detected!("lut"));
+    println!("faminmax: {}", is_aarch64_feature_detected!("faminmax"));
+    println!("fp8: {}", is_aarch64_feature_detected!("fp8"));
+    println!("fp8fma: {}", is_aarch64_feature_detected!("fp8fma"));
+    println!("fp8dot4: {}", is_aarch64_feature_detected!("fp8dot4"));
+    println!("fp8dot2: {}", is_aarch64_feature_detected!("fp8dot2"));
+    println!("wfxt: {}", is_aarch64_feature_detected!("wfxt"));
+    println!("sme: {}", is_aarch64_feature_detected!("sme"));
+    println!("sme-b16b16: {}", is_aarch64_feature_detected!("sme-b16b16"));
+    println!("sme-i16i64: {}", is_aarch64_feature_detected!("sme-i16i64"));
+    println!("sme-f64f64: {}", is_aarch64_feature_detected!("sme-f64f64"));
+    println!("sme-fa64: {}", is_aarch64_feature_detected!("sme-fa64"));
+    println!("sme2: {}", is_aarch64_feature_detected!("sme2"));
+    println!("sme2p1: {}", is_aarch64_feature_detected!("sme2p1"));
+    println!("sme-f16f16: {}", is_aarch64_feature_detected!("sme-f16f16"));
+    println!("sme-lutv2: {}", is_aarch64_feature_detected!("sme-lutv2"));
+    println!("sme-f8f16: {}", is_aarch64_feature_detected!("sme-f8f16"));
+    println!("sme-f8f32: {}", is_aarch64_feature_detected!("sme-f8f32"));
+    println!(
+        "ssve-fp8fma: {}",
+        is_aarch64_feature_detected!("ssve-fp8fma")
+    );
+    println!(
+        "ssve-fp8dot4: {}",
+        is_aarch64_feature_detected!("ssve-fp8dot4")
+    );
+    println!(
+        "ssve-fp8dot2: {}",
+        is_aarch64_feature_detected!("ssve-fp8dot2")
+    );
+}
+
+#[test]
+#[cfg(all(
+    any(target_arch = "aarch64", target_arch = "arm64ec"),
+    target_os = "windows"
+))]
+fn aarch64_windows() {
+    println!("asimd: {:?}", is_aarch64_feature_detected!("asimd"));
+    println!("fp: {:?}", is_aarch64_feature_detected!("fp"));
+    println!("crc: {:?}", is_aarch64_feature_detected!("crc"));
+    println!("lse: {:?}", is_aarch64_feature_detected!("lse"));
+    println!("dotprod: {:?}", is_aarch64_feature_detected!("dotprod"));
+    println!("jsconv: {:?}", is_aarch64_feature_detected!("jsconv"));
+    println!("rcpc: {:?}", is_aarch64_feature_detected!("rcpc"));
+    println!("aes: {:?}", is_aarch64_feature_detected!("aes"));
+    println!("pmull: {:?}", is_aarch64_feature_detected!("pmull"));
+    println!("sha2: {:?}", is_aarch64_feature_detected!("sha2"));
+}
+
+#[test]
+#[cfg(all(
+    target_arch = "aarch64",
+    any(target_os = "freebsd", target_os = "openbsd")
+))]
+fn aarch64_bsd() {
+    println!("asimd: {:?}", is_aarch64_feature_detected!("asimd"));
+    println!("pmull: {:?}", is_aarch64_feature_detected!("pmull"));
+    println!("fp: {:?}", is_aarch64_feature_detected!("fp"));
+    println!("fp16: {:?}", is_aarch64_feature_detected!("fp16"));
+    println!("sve: {:?}", is_aarch64_feature_detected!("sve"));
+    println!("crc: {:?}", is_aarch64_feature_detected!("crc"));
+    println!("lse: {:?}", is_aarch64_feature_detected!("lse"));
+    println!("lse2: {:?}", is_aarch64_feature_detected!("lse2"));
+    println!("rdm: {:?}", is_aarch64_feature_detected!("rdm"));
+    println!("rcpc: {:?}", is_aarch64_feature_detected!("rcpc"));
+    println!("dotprod: {:?}", is_aarch64_feature_detected!("dotprod"));
+    println!("tme: {:?}", is_aarch64_feature_detected!("tme"));
+    println!("paca: {:?}", is_aarch64_feature_detected!("paca"));
+    println!("pacg: {:?}", is_aarch64_feature_detected!("pacg"));
+    println!("aes: {:?}", is_aarch64_feature_detected!("aes"));
+    println!("sha2: {:?}", is_aarch64_feature_detected!("sha2"));
+}
+
+#[test]
+#[cfg(all(target_arch = "aarch64", target_vendor = "apple"))]
+fn aarch64_darwin() {
+    println!("asimd: {:?}", is_aarch64_feature_detected!("asimd"));
+    println!("fp: {:?}", is_aarch64_feature_detected!("fp"));
+    println!("fp16: {:?}", is_aarch64_feature_detected!("fp16"));
+    println!("pmull: {:?}", is_aarch64_feature_detected!("pmull"));
+    println!("crc: {:?}", is_aarch64_feature_detected!("crc"));
+    println!("lse: {:?}", is_aarch64_feature_detected!("lse"));
+    println!("lse2: {:?}", is_aarch64_feature_detected!("lse2"));
+    println!("rdm: {:?}", is_aarch64_feature_detected!("rdm"));
+    println!("rcpc: {:?}", is_aarch64_feature_detected!("rcpc"));
+    println!("rcpc2: {:?}", is_aarch64_feature_detected!("rcpc2"));
+    println!("dotprod: {:?}", is_aarch64_feature_detected!("dotprod"));
+    println!("fhm: {:?}", is_aarch64_feature_detected!("fhm"));
+    println!("flagm: {:?}", is_aarch64_feature_detected!("flagm"));
+    println!("ssbs: {:?}", is_aarch64_feature_detected!("ssbs"));
+    println!("sb: {:?}", is_aarch64_feature_detected!("sb"));
+    println!("paca: {:?}", is_aarch64_feature_detected!("paca"));
+    println!("dpb: {:?}", is_aarch64_feature_detected!("dpb"));
+    println!("dpb2: {:?}", is_aarch64_feature_detected!("dpb2"));
+    println!("frintts: {:?}", is_aarch64_feature_detected!("frintts"));
+    println!("i8mm: {:?}", is_aarch64_feature_detected!("i8mm"));
+    println!("bf16: {:?}", is_aarch64_feature_detected!("bf16"));
+    println!("bti: {:?}", is_aarch64_feature_detected!("bti"));
+    println!("fcma: {:?}", is_aarch64_feature_detected!("fcma"));
+    println!("jsconv: {:?}", is_aarch64_feature_detected!("jsconv"));
+    println!("aes: {:?}", is_aarch64_feature_detected!("aes"));
+    println!("sha2: {:?}", is_aarch64_feature_detected!("sha2"));
+    println!("sha3: {:?}", is_aarch64_feature_detected!("sha3"));
+}
+
+#[test]
+#[cfg(all(
+    any(target_arch = "riscv32", target_arch = "riscv64"),
+    any(target_os = "linux", target_os = "android")
+))]
+fn riscv_linux() {
+    println!("rv32i: {}", is_riscv_feature_detected!("rv32i"));
+    println!("rv32e: {}", is_riscv_feature_detected!("rv32e"));
+    println!("rv64i: {}", is_riscv_feature_detected!("rv64i"));
+    println!("rv128i: {}", is_riscv_feature_detected!("rv128i"));
+    println!(
+        "unaligned-scalar-mem: {}",
+        is_riscv_feature_detected!("unaligned-scalar-mem")
+    );
+    println!(
+        "unaligned-vector-mem: {}",
+        is_riscv_feature_detected!("unaligned-vector-mem")
+    );
+    println!("zicsr: {}", is_riscv_feature_detected!("zicsr"));
+    println!("zicntr: {}", is_riscv_feature_detected!("zicntr"));
+    println!("zihpm: {}", is_riscv_feature_detected!("zihpm"));
+    println!("zifencei: {}", is_riscv_feature_detected!("zifencei"));
+    println!("zihintntl: {}", is_riscv_feature_detected!("zihintntl"));
+    println!("zihintpause: {}", is_riscv_feature_detected!("zihintpause"));
+    println!("zimop: {}", is_riscv_feature_detected!("zimop"));
+    println!("zicbom: {}", is_riscv_feature_detected!("zicbom"));
+    println!("zicboz: {}", is_riscv_feature_detected!("zicboz"));
+    println!("zicond: {}", is_riscv_feature_detected!("zicond"));
+    println!("m: {}", is_riscv_feature_detected!("m"));
+    println!("a: {}", is_riscv_feature_detected!("a"));
+    println!("zalrsc: {}", is_riscv_feature_detected!("zalrsc"));
+    println!("zaamo: {}", is_riscv_feature_detected!("zaamo"));
+    println!("zawrs: {}", is_riscv_feature_detected!("zawrs"));
+    println!("zacas: {}", is_riscv_feature_detected!("zacas"));
+    println!("zam: {}", is_riscv_feature_detected!("zam"));
+    println!("ztso: {}", is_riscv_feature_detected!("ztso"));
+    println!("f: {}", is_riscv_feature_detected!("f"));
+    println!("d: {}", is_riscv_feature_detected!("d"));
+    println!("q: {}", is_riscv_feature_detected!("q"));
+    println!("zfh: {}", is_riscv_feature_detected!("zfh"));
+    println!("zfhmin: {}", is_riscv_feature_detected!("zfhmin"));
+    println!("zfa: {}", is_riscv_feature_detected!("zfa"));
+    println!("zfbfmin: {}", is_riscv_feature_detected!("zfbfmin"));
+    println!("zfinx: {}", is_riscv_feature_detected!("zfinx"));
+    println!("zdinx: {}", is_riscv_feature_detected!("zdinx"));
+    println!("zhinx: {}", is_riscv_feature_detected!("zhinx"));
+    println!("zhinxmin: {}", is_riscv_feature_detected!("zhinxmin"));
+    println!("c: {}", is_riscv_feature_detected!("c"));
+    println!("zca: {}", is_riscv_feature_detected!("zca"));
+    println!("zcf: {}", is_riscv_feature_detected!("zcf"));
+    println!("zcd: {}", is_riscv_feature_detected!("zcd"));
+    println!("zcb: {}", is_riscv_feature_detected!("zcb"));
+    println!("zcmop: {}", is_riscv_feature_detected!("zcmop"));
+    println!("b: {}", is_riscv_feature_detected!("b"));
+    println!("zba: {}", is_riscv_feature_detected!("zba"));
+    println!("zbb: {}", is_riscv_feature_detected!("zbb"));
+    println!("zbc: {}", is_riscv_feature_detected!("zbc"));
+    println!("zbs: {}", is_riscv_feature_detected!("zbs"));
+    println!("zbkb: {}", is_riscv_feature_detected!("zbkb"));
+    println!("zbkc: {}", is_riscv_feature_detected!("zbkc"));
+    println!("zbkx: {}", is_riscv_feature_detected!("zbkx"));
+    println!("zknd: {}", is_riscv_feature_detected!("zknd"));
+    println!("zkne: {}", is_riscv_feature_detected!("zkne"));
+    println!("zknh: {}", is_riscv_feature_detected!("zknh"));
+    println!("zksed: {}", is_riscv_feature_detected!("zksed"));
+    println!("zksh: {}", is_riscv_feature_detected!("zksh"));
+    println!("zkr: {}", is_riscv_feature_detected!("zkr"));
+    println!("zkn: {}", is_riscv_feature_detected!("zkn"));
+    println!("zks: {}", is_riscv_feature_detected!("zks"));
+    println!("zk: {}", is_riscv_feature_detected!("zk"));
+    println!("zkt: {}", is_riscv_feature_detected!("zkt"));
+    println!("v: {}", is_riscv_feature_detected!("v"));
+    println!("zve32x: {}", is_riscv_feature_detected!("zve32x"));
+    println!("zve32f: {}", is_riscv_feature_detected!("zve32f"));
+    println!("zve64x: {}", is_riscv_feature_detected!("zve64x"));
+    println!("zve64f: {}", is_riscv_feature_detected!("zve64f"));
+    println!("zve64d: {}", is_riscv_feature_detected!("zve64d"));
+    println!("zvfh: {}", is_riscv_feature_detected!("zvfh"));
+    println!("zvfhmin: {}", is_riscv_feature_detected!("zvfhmin"));
+    println!("zvfbfmin: {}", is_riscv_feature_detected!("zvfbfmin"));
+    println!("zvfbfwma: {}", is_riscv_feature_detected!("zvfbfwma"));
+    println!("zvbb: {}", is_riscv_feature_detected!("zvbb"));
+    println!("zvbc: {}", is_riscv_feature_detected!("zvbc"));
+    println!("zvkb: {}", is_riscv_feature_detected!("zvkb"));
+    println!("zvkg: {}", is_riscv_feature_detected!("zvkg"));
+    println!("zvkned: {}", is_riscv_feature_detected!("zvkned"));
+    println!("zvknha: {}", is_riscv_feature_detected!("zvknha"));
+    println!("zvknhb: {}", is_riscv_feature_detected!("zvknhb"));
+    println!("zvksed: {}", is_riscv_feature_detected!("zvksed"));
+    println!("zvksh: {}", is_riscv_feature_detected!("zvksh"));
+    println!("zvkn: {}", is_riscv_feature_detected!("zvkn"));
+    println!("zvknc: {}", is_riscv_feature_detected!("zvknc"));
+    println!("zvkng: {}", is_riscv_feature_detected!("zvkng"));
+    println!("zvks: {}", is_riscv_feature_detected!("zvks"));
+    println!("zvksc: {}", is_riscv_feature_detected!("zvksc"));
+    println!("zvksg: {}", is_riscv_feature_detected!("zvksg"));
+    println!("zvkt: {}", is_riscv_feature_detected!("zvkt"));
+    println!("j: {}", is_riscv_feature_detected!("j"));
+    println!("p: {}", is_riscv_feature_detected!("p"));
+}
+
+#[test]
+#[cfg(all(target_arch = "powerpc", target_os = "linux"))]
+fn powerpc_linux() {
+    println!("altivec: {}", is_powerpc_feature_detected!("altivec"));
+    println!("vsx: {}", is_powerpc_feature_detected!("vsx"));
+    println!("power8: {}", is_powerpc_feature_detected!("power8"));
+}
+
+#[test]
+#[cfg(all(
+    target_arch = "powerpc64",
+    any(target_os = "linux", target_os = "freebsd"),
+))]
+fn powerpc64_linux_or_freebsd() {
+    println!("altivec: {}", is_powerpc64_feature_detected!("altivec"));
+    println!("vsx: {}", is_powerpc64_feature_detected!("vsx"));
+    println!("power8: {}", is_powerpc64_feature_detected!("power8"));
+    println!("power9: {}", is_powerpc64_feature_detected!("power9"));
+}
+
+#[test]
+#[cfg(all(target_arch = "s390x", target_os = "linux",))]
+fn s390x_linux() {
+    println!("vector: {}", is_s390x_feature_detected!("vector"));
+}
diff --git a/library/std_detect/tests/macro_trailing_commas.rs b/library/std_detect/tests/macro_trailing_commas.rs
new file mode 100644
index 00000000000..2fee0abdd57
--- /dev/null
+++ b/library/std_detect/tests/macro_trailing_commas.rs
@@ -0,0 +1,109 @@
+#![allow(internal_features)]
+#![cfg_attr(
+    any(
+        target_arch = "arm",
+        target_arch = "aarch64",
+        target_arch = "arm64ec",
+        target_arch = "x86",
+        target_arch = "x86_64",
+        target_arch = "powerpc",
+        target_arch = "powerpc64",
+        target_arch = "s390x",
+        target_arch = "riscv32",
+        target_arch = "riscv64",
+        target_arch = "loongarch32",
+        target_arch = "loongarch64"
+    ),
+    feature(stdarch_internal)
+)]
+#![cfg_attr(target_arch = "arm", feature(stdarch_arm_feature_detection))]
+#![cfg_attr(
+    any(target_arch = "aarch64", target_arch = "arm64ec"),
+    feature(stdarch_aarch64_feature_detection)
+)]
+#![cfg_attr(
+    any(target_arch = "powerpc", target_arch = "powerpc64"),
+    feature(stdarch_powerpc_feature_detection)
+)]
+#![cfg_attr(target_arch = "s390x", feature(stdarch_s390x_feature_detection))]
+#![cfg_attr(
+    any(target_arch = "riscv32", target_arch = "riscv64"),
+    feature(stdarch_riscv_feature_detection)
+)]
+#![cfg_attr(
+    any(target_arch = "loongarch32", target_arch = "loongarch64"),
+    feature(stdarch_loongarch_feature_detection)
+)]
+
+#[cfg(any(
+    target_arch = "arm",
+    target_arch = "aarch64",
+    target_arch = "arm64ec",
+    target_arch = "x86",
+    target_arch = "x86_64",
+    target_arch = "powerpc",
+    target_arch = "powerpc64",
+    target_arch = "s390x",
+    target_arch = "riscv32",
+    target_arch = "riscv64",
+    target_arch = "loongarch32",
+    target_arch = "loongarch64"
+))]
+#[macro_use]
+extern crate std_detect;
+
+#[test]
+#[cfg(target_arch = "arm")]
+fn arm() {
+    let _ = is_arm_feature_detected!("neon");
+    let _ = is_arm_feature_detected!("neon",);
+}
+
+#[test]
+#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
+fn aarch64() {
+    let _ = is_aarch64_feature_detected!("fp");
+    let _ = is_aarch64_feature_detected!("fp",);
+}
+
+#[test]
+#[cfg(any(target_arch = "loongarch32", target_arch = "loongarch64"))]
+fn loongarch() {
+    let _ = is_loongarch_feature_detected!("lsx");
+    let _ = is_loongarch_feature_detected!("lsx",);
+}
+
+#[test]
+#[cfg(target_arch = "powerpc")]
+fn powerpc() {
+    let _ = is_powerpc_feature_detected!("altivec");
+    let _ = is_powerpc_feature_detected!("altivec",);
+}
+
+#[test]
+#[cfg(target_arch = "powerpc64")]
+fn powerpc64() {
+    let _ = is_powerpc64_feature_detected!("altivec");
+    let _ = is_powerpc64_feature_detected!("altivec",);
+}
+
+#[test]
+#[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
+fn riscv() {
+    let _ = is_riscv_feature_detected!("zk");
+    let _ = is_riscv_feature_detected!("zk",);
+}
+
+#[test]
+#[cfg(target_arch = "s390x")]
+fn s390x() {
+    let _ = is_s390x_feature_detected!("vector");
+    let _ = is_s390x_feature_detected!("vector",);
+}
+
+#[test]
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+fn x86() {
+    let _ = is_x86_feature_detected!("sse");
+    let _ = is_x86_feature_detected!("sse",);
+}
diff --git a/library/std_detect/tests/x86-specific.rs b/library/std_detect/tests/x86-specific.rs
new file mode 100644
index 00000000000..d9ec79821ba
--- /dev/null
+++ b/library/std_detect/tests/x86-specific.rs
@@ -0,0 +1,117 @@
+#![cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+#![allow(internal_features)]
+#![feature(
+    stdarch_internal,
+    x86_amx_intrinsics,
+    xop_target_feature,
+    movrs_target_feature
+)]
+
+#[macro_use]
+extern crate std_detect;
+
+#[test]
+fn dump() {
+    println!("aes: {:?}", is_x86_feature_detected!("aes"));
+    println!("pclmulqdq: {:?}", is_x86_feature_detected!("pclmulqdq"));
+    println!("rdrand: {:?}", is_x86_feature_detected!("rdrand"));
+    println!("rdseed: {:?}", is_x86_feature_detected!("rdseed"));
+    println!("tsc: {:?}", is_x86_feature_detected!("tsc"));
+    println!("sse: {:?}", is_x86_feature_detected!("sse"));
+    println!("sse2: {:?}", is_x86_feature_detected!("sse2"));
+    println!("sse3: {:?}", is_x86_feature_detected!("sse3"));
+    println!("ssse3: {:?}", is_x86_feature_detected!("ssse3"));
+    println!("sse4.1: {:?}", is_x86_feature_detected!("sse4.1"));
+    println!("sse4.2: {:?}", is_x86_feature_detected!("sse4.2"));
+    println!("sse4a: {:?}", is_x86_feature_detected!("sse4a"));
+    println!("sha: {:?}", is_x86_feature_detected!("sha"));
+    println!("f16c: {:?}", is_x86_feature_detected!("f16c"));
+    println!("avx: {:?}", is_x86_feature_detected!("avx"));
+    println!("avx2: {:?}", is_x86_feature_detected!("avx2"));
+    println!("sha512: {:?}", is_x86_feature_detected!("sha512"));
+    println!("sm3: {:?}", is_x86_feature_detected!("sm3"));
+    println!("sm4: {:?}", is_x86_feature_detected!("sm4"));
+    println!("avx512f: {:?}", is_x86_feature_detected!("avx512f"));
+    println!("avx512cd: {:?}", is_x86_feature_detected!("avx512cd"));
+    println!("avx512er: {:?}", is_x86_feature_detected!("avx512er"));
+    println!("avx512pf: {:?}", is_x86_feature_detected!("avx512pf"));
+    println!("avx512bw: {:?}", is_x86_feature_detected!("avx512bw"));
+    println!("avx512dq: {:?}", is_x86_feature_detected!("avx512dq"));
+    println!("avx512vl: {:?}", is_x86_feature_detected!("avx512vl"));
+    println!("avx512_ifma: {:?}", is_x86_feature_detected!("avx512ifma"));
+    println!("avx512vbmi {:?}", is_x86_feature_detected!("avx512vbmi"));
+    println!(
+        "avx512_vpopcntdq: {:?}",
+        is_x86_feature_detected!("avx512vpopcntdq")
+    );
+    println!("avx512vbmi2: {:?}", is_x86_feature_detected!("avx512vbmi2"));
+    println!("gfni: {:?}", is_x86_feature_detected!("gfni"));
+    println!("vaes: {:?}", is_x86_feature_detected!("vaes"));
+    println!("vpclmulqdq: {:?}", is_x86_feature_detected!("vpclmulqdq"));
+    println!("avx512vnni: {:?}", is_x86_feature_detected!("avx512vnni"));
+    println!(
+        "avx512bitalg: {:?}",
+        is_x86_feature_detected!("avx512bitalg")
+    );
+    println!("avx512bf16: {:?}", is_x86_feature_detected!("avx512bf16"));
+    println!(
+        "avx512vp2intersect: {:?}",
+        is_x86_feature_detected!("avx512vp2intersect")
+    );
+    println!("avx512fp16: {:?}", is_x86_feature_detected!("avx512fp16"));
+    println!("fma: {:?}", is_x86_feature_detected!("fma"));
+    println!("abm: {:?}", is_x86_feature_detected!("abm"));
+    println!("bmi: {:?}", is_x86_feature_detected!("bmi1"));
+    println!("bmi2: {:?}", is_x86_feature_detected!("bmi2"));
+    println!("tbm: {:?}", is_x86_feature_detected!("tbm"));
+    println!("popcnt: {:?}", is_x86_feature_detected!("popcnt"));
+    println!("lzcnt: {:?}", is_x86_feature_detected!("lzcnt"));
+    println!("fxsr: {:?}", is_x86_feature_detected!("fxsr"));
+    println!("xsave: {:?}", is_x86_feature_detected!("xsave"));
+    println!("xsaveopt: {:?}", is_x86_feature_detected!("xsaveopt"));
+    println!("xsaves: {:?}", is_x86_feature_detected!("xsaves"));
+    println!("xsavec: {:?}", is_x86_feature_detected!("xsavec"));
+    println!("cmpxchg16b: {:?}", is_x86_feature_detected!("cmpxchg16b"));
+    println!("adx: {:?}", is_x86_feature_detected!("adx"));
+    println!("rtm: {:?}", is_x86_feature_detected!("rtm"));
+    println!("movbe: {:?}", is_x86_feature_detected!("movbe"));
+    println!("avxvnni: {:?}", is_x86_feature_detected!("avxvnni"));
+    println!("avxvnniint8: {:?}", is_x86_feature_detected!("avxvnniint8"));
+    println!(
+        "avxneconvert: {:?}",
+        is_x86_feature_detected!("avxneconvert")
+    );
+    println!("avxifma: {:?}", is_x86_feature_detected!("avxifma"));
+    println!(
+        "avxvnniint16: {:?}",
+        is_x86_feature_detected!("avxvnniint16")
+    );
+    println!("amx-bf16: {:?}", is_x86_feature_detected!("amx-bf16"));
+    println!("amx-tile: {:?}", is_x86_feature_detected!("amx-tile"));
+    println!("amx-int8: {:?}", is_x86_feature_detected!("amx-int8"));
+    println!("amx-fp16: {:?}", is_x86_feature_detected!("amx-fp16"));
+    println!("amx-complex: {:?}", is_x86_feature_detected!("amx-complex"));
+    println!("xop: {:?}", is_x86_feature_detected!("xop"));
+    println!("kl: {:?}", is_x86_feature_detected!("kl"));
+    println!("widekl: {:?}", is_x86_feature_detected!("widekl"));
+    println!("movrs: {:?}", is_x86_feature_detected!("movrs"));
+    println!("amx-fp8: {:?}", is_x86_feature_detected!("amx-fp8"));
+    println!(
+        "amx-transpose: {:?}",
+        is_x86_feature_detected!("amx-transpose")
+    );
+    println!("amx-tf32: {:?}", is_x86_feature_detected!("amx-tf32"));
+    println!("amx-avx512: {:?}", is_x86_feature_detected!("amx-avx512"));
+    println!("amx-movrs: {:?}", is_x86_feature_detected!("amx-movrs"));
+}
+
+#[test]
+#[allow(deprecated)]
+fn x86_deprecated() {
+    println!("avx512gfni {:?}", is_x86_feature_detected!("avx512gfni"));
+    println!("avx512vaes {:?}", is_x86_feature_detected!("avx512vaes"));
+    println!(
+        "avx512vpclmulqdq {:?}",
+        is_x86_feature_detected!("avx512vpclmulqdq")
+    );
+}
diff --git a/library/stdarch/crates/std_detect/Cargo.toml b/library/stdarch/crates/std_detect/Cargo.toml
deleted file mode 100644
index f990e724125..00000000000
--- a/library/stdarch/crates/std_detect/Cargo.toml
+++ /dev/null
@@ -1,41 +0,0 @@
-[package]
-name = "std_detect"
-version = "0.1.5"
-authors = [
-    "Alex Crichton <alex@alexcrichton.com>",
-    "Andrew Gallant <jamslam@gmail.com>",
-    "Gonzalo Brito Gadeschi <gonzalobg88@gmail.com>",
-]
-description = "`std::detect` - Rust's standard library run-time CPU feature detection."
-homepage = "https://github.com/rust-lang/stdarch"
-repository = "https://github.com/rust-lang/stdarch"
-readme = "README.md"
-keywords = ["std", "run-time", "feature", "detection"]
-categories = ["hardware-support"]
-license = "MIT OR Apache-2.0"
-edition = "2024"
-
-[badges]
-is-it-maintained-issue-resolution = { repository = "rust-lang/stdarch" }
-is-it-maintained-open-issues = { repository = "rust-lang/stdarch" }
-maintenance = { status = "experimental" }
-
-[dependencies]
-cfg-if = "1.0.0"
-
-# When built as part of libstd
-core = { version = "1.0.0", optional = true, package = "rustc-std-workspace-core" }
-alloc = { version = "1.0.0", optional = true, package = "rustc-std-workspace-alloc" }
-
-[target.'cfg(not(windows))'.dependencies]
-libc = { version = "0.2.0", optional = true, default-features = false }
-
-[features]
-default = [ "std_detect_dlsym_getauxval", "std_detect_file_io" ]
-std_detect_file_io = [ "libc" ]
-std_detect_dlsym_getauxval = [ "libc" ]
-std_detect_env_override = [ "libc" ]
-rustc-dep-of-std = [
-    "core",
-    "alloc",
-]
diff --git a/library/stdarch/crates/std_detect/LICENSE-APACHE b/library/stdarch/crates/std_detect/LICENSE-APACHE
deleted file mode 100644
index 16fe87b06e8..00000000000
--- a/library/stdarch/crates/std_detect/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/library/stdarch/crates/std_detect/LICENSE-MIT b/library/stdarch/crates/std_detect/LICENSE-MIT
deleted file mode 100644
index 52d82415d8b..00000000000
--- a/library/stdarch/crates/std_detect/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2017 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/library/stdarch/crates/std_detect/README.md b/library/stdarch/crates/std_detect/README.md
deleted file mode 100644
index edc90d319a1..00000000000
--- a/library/stdarch/crates/std_detect/README.md
+++ /dev/null
@@ -1,93 +0,0 @@
-`std::detect` - Rust's standard library run-time CPU feature detection
-=======
-
-The private `std::detect` module implements run-time feature detection in Rust's
-standard library. This allows detecting whether the CPU the binary runs on
-supports certain features, like SIMD instructions.
-
-# Usage
-
-`std::detect` APIs are available as part of `libstd`. Prefer using it via the
-standard library than through this crate. Unstable features of `std::detect` are
-available on nightly Rust behind various feature-gates.
-
-If you need run-time feature detection in `#[no_std]` environments, Rust `core`
-library cannot help you. By design, Rust `core` is platform independent, but
-performing run-time feature detection requires a certain level of cooperation
-from the platform.
-
-You can then manually include `std_detect` as a dependency to get similar
-run-time feature detection support than the one offered by Rust's standard
-library. We intend to make `std_detect` more flexible and configurable in this
-regard to better serve the needs of `#[no_std]` targets.
-
-# Features
-
-* `std_detect_dlsym_getauxval` (enabled by default, requires `libc`): Enable to
-use `libc::dlsym` to query whether [`getauxval`] is linked into the binary. When
-this is not the case, this feature allows other fallback methods to perform
-run-time feature detection. When this feature is disabled, `std_detect` assumes
-that [`getauxval`] is linked to the binary. If that is not the case the behavior
-is undefined.
-
-  Note: This feature is ignored on `*-linux-{gnu,musl,ohos}*` and `*-android*` targets
-  because we can safely assume `getauxval` is linked to the binary.
-  * `*-linux-gnu*` targets ([since Rust 1.64](https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.html))
-    have glibc requirements higher than [glibc 2.16 that added `getauxval`](https://sourceware.org/legacy-ml/libc-announce/2012/msg00000.html).
-  * `*-linux-musl*` targets ([at least since Rust 1.15](https://github.com/rust-lang/rust/blob/1.15.0/src/ci/docker/x86_64-musl/build-musl.sh#L15))
-    use musl newer than [musl 1.1.0 that added `getauxval`](https://git.musl-libc.org/cgit/musl/tree/WHATSNEW?h=v1.1.0#n1197)
-  * `*-linux-ohos*` targets use a [fork of musl 1.2](https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/native-lib/musl.md)
-  * `*-android*` targets ([since Rust 1.68](https://blog.rust-lang.org/2023/01/09/android-ndk-update-r25.html))
-    have the minimum supported API level higher than [Android 4.3 (API level 18) that added `getauxval`](https://github.com/aosp-mirror/platform_bionic/blob/d3ebc2f7c49a9893b114124d4a6b315f3a328764/libc/include/sys/auxv.h#L49).
-
-* `std_detect_file_io` (enabled by default, requires `std`): Enable to perform run-time feature
-detection using file APIs (e.g. `/proc/self/auxv`, etc.) if other more performant
-methods fail. This feature requires `libstd` as a dependency, preventing the
-crate from working on applications in which `std` is not available.
-
-[`getauxval`]: https://man7.org/linux/man-pages/man3/getauxval.3.html
-
-# Platform support
-
-* All `x86`/`x86_64` targets are supported on all platforms by querying the
-  `cpuid` instruction directly for the features supported by the hardware and
-  the operating system. `std_detect` assumes that the binary is an user-space
-  application.
-
-* Linux/Android:
-  * `arm{32, 64}`, `mips{32,64}{,el}`, `powerpc{32,64}{,le}`, `loongarch{32,64}`, `s390x`:
-    `std_detect` supports these on Linux by querying ELF auxiliary vectors (using `getauxval`
-    when available), and if that fails, by querying `/proc/self/auxv`.
-  * `arm64`: partial support for doing run-time feature detection by directly
-    querying `mrs` is implemented for Linux >= 4.11, but not enabled by default.
-  * `riscv{32,64}`:
-    `std_detect` supports these on Linux by querying `riscv_hwprobe`, and
-    by querying ELF auxiliary vectors (using `getauxval` when available).
-
-* FreeBSD:
-  * `arm32`, `powerpc64`: `std_detect` supports these on FreeBSD by querying ELF
-    auxiliary vectors using `sysctl`.
-  * `arm64`: run-time feature detection is implemented by directly querying `mrs`.
-
-* OpenBSD:
-  * `arm64`: run-time feature detection is implemented by querying `sysctl`.
-
-* Windows:
-  * `arm64`: run-time feature detection is implemented by querying `IsProcessorFeaturePresent`.
-
-# License
-
-This project is licensed under either of
-
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-   http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or
-   http://opensource.org/licenses/MIT)
-
-at your option.
-
-# Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in `std_detect` by you, as defined in the Apache-2.0 license,
-shall be dual licensed as above, without any additional terms or conditions.
diff --git a/library/stdarch/crates/std_detect/src/detect/arch/aarch64.rs b/library/stdarch/crates/std_detect/src/detect/arch/aarch64.rs
deleted file mode 100644
index 13570a25c1c..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/arch/aarch64.rs
+++ /dev/null
@@ -1,259 +0,0 @@
-//! Aarch64 run-time features.
-
-features! {
-    @TARGET: aarch64;
-    @CFG: any(target_arch = "aarch64", target_arch = "arm64ec");
-    @MACRO_NAME: is_aarch64_feature_detected;
-    @MACRO_ATTRS:
-    /// This macro tests, at runtime, whether an `aarch64` feature is enabled on aarch64 platforms.
-    /// Currently most features are only supported on linux-based platforms.
-    ///
-    /// This macro takes one argument which is a string literal of the feature being tested for.
-    /// The feature names are mostly taken from their FEAT_* definitions in the [ARM Architecture
-    /// Reference Manual][docs].
-    ///
-    /// ## Supported arguments
-    ///
-    /// * `"aes"` - FEAT_AES & FEAT_PMULL
-    /// * `"asimd"` or "neon" - FEAT_AdvSIMD
-    /// * `"bf16"` - FEAT_BF16
-    /// * `"bti"` - FEAT_BTI
-    /// * `"crc"` - FEAT_CRC
-    /// * `"cssc"` - FEAT_CSSC
-    /// * `"dit"` - FEAT_DIT
-    /// * `"dotprod"` - FEAT_DotProd
-    /// * `"dpb"` - FEAT_DPB
-    /// * `"dpb2"` - FEAT_DPB2
-    /// * `"ecv"` - FEAT_ECV
-    /// * `"f32mm"` - FEAT_F32MM
-    /// * `"f64mm"` - FEAT_F64MM
-    /// * `"faminmax"` - FEAT_FAMINMAX
-    /// * `"fcma"` - FEAT_FCMA
-    /// * `"fhm"` - FEAT_FHM
-    /// * `"flagm"` - FEAT_FLAGM
-    /// * `"flagm2"` - FEAT_FLAGM2
-    /// * `"fp"` - FEAT_FP
-    /// * `"fp16"` - FEAT_FP16
-    /// * `"fp8"` - FEAT_FP8
-    /// * `"fp8dot2"` - FEAT_FP8DOT2
-    /// * `"fp8dot4"` - FEAT_FP8DOT4
-    /// * `"fp8fma"` - FEAT_FP8FMA
-    /// * `"fpmr"` - FEAT_FPMR
-    /// * `"frintts"` - FEAT_FRINTTS
-    /// * `"hbc"` - FEAT_HBC
-    /// * `"i8mm"` - FEAT_I8MM
-    /// * `"jsconv"` - FEAT_JSCVT
-    /// * `"lse"` - FEAT_LSE
-    /// * `"lse128"` - FEAT_LSE128
-    /// * `"lse2"` - FEAT_LSE2
-    /// * `"lut"` - FEAT_LUT
-    /// * `"mops"` - FEAT_MOPS
-    /// * `"mte"` - FEAT_MTE & FEAT_MTE2
-    /// * `"paca"` - FEAT_PAuth (address authentication)
-    /// * `"pacg"` - FEAT_Pauth (generic authentication)
-    /// * `"pauth-lr"` - FEAT_PAuth_LR
-    /// * `"pmull"` - FEAT_PMULL
-    /// * `"rand"` - FEAT_RNG
-    /// * `"rcpc"` - FEAT_LRCPC
-    /// * `"rcpc2"` - FEAT_LRCPC2
-    /// * `"rcpc3"` - FEAT_LRCPC3
-    /// * `"rdm"` - FEAT_RDM
-    /// * `"sb"` - FEAT_SB
-    /// * `"sha2"` - FEAT_SHA1 & FEAT_SHA256
-    /// * `"sha3"` - FEAT_SHA512 & FEAT_SHA3
-    /// * `"sm4"` - FEAT_SM3 & FEAT_SM4
-    /// * `"sme"` - FEAT_SME
-    /// * `"sme-b16b16"` - FEAT_SME_B16B16
-    /// * `"sme-f16f16"` - FEAT_SME_F16F16
-    /// * `"sme-f64f64"` - FEAT_SME_F64F64
-    /// * `"sme-f8f16"` - FEAT_SME_F8F16
-    /// * `"sme-f8f32"` - FEAT_SME_F8F32
-    /// * `"sme-fa64"` - FEAT_SME_FA64
-    /// * `"sme-i16i64"` - FEAT_SME_I16I64
-    /// * `"sme-lutv2"` - FEAT_SME_LUTv2
-    /// * `"sme2"` - FEAT_SME2
-    /// * `"sme2p1"` - FEAT_SME2p1
-    /// * `"ssbs"` - FEAT_SSBS & FEAT_SSBS2
-    /// * `"ssve-fp8dot2"` - FEAT_SSVE_FP8DOT2
-    /// * `"ssve-fp8dot4"` - FEAT_SSVE_FP8DOT4
-    /// * `"ssve-fp8fma"` - FEAT_SSVE_FP8FMA
-    /// * `"sve"` - FEAT_SVE
-    /// * `"sve-b16b16"` - FEAT_SVE_B16B16 (SVE or SME Z-targeting instructions)
-    /// * `"sve2"` - FEAT_SVE2
-    /// * `"sve2-aes"` - FEAT_SVE_AES & FEAT_SVE_PMULL128 (SVE2 AES crypto)
-    /// * `"sve2-bitperm"` - FEAT_SVE2_BitPerm
-    /// * `"sve2-sha3"` - FEAT_SVE2_SHA3
-    /// * `"sve2-sm4"` - FEAT_SVE2_SM4
-    /// * `"sve2p1"` - FEAT_SVE2p1
-    /// * `"tme"` - FEAT_TME
-    /// * `"wfxt"` - FEAT_WFxT
-    ///
-    /// [docs]: https://developer.arm.com/documentation/ddi0487/latest
-    #[stable(feature = "simd_aarch64", since = "1.60.0")]
-    @BIND_FEATURE_NAME: "asimd"; "neon";
-    @NO_RUNTIME_DETECTION: "ras";
-    @NO_RUNTIME_DETECTION: "v8.1a";
-    @NO_RUNTIME_DETECTION: "v8.2a";
-    @NO_RUNTIME_DETECTION: "v8.3a";
-    @NO_RUNTIME_DETECTION: "v8.4a";
-    @NO_RUNTIME_DETECTION: "v8.5a";
-    @NO_RUNTIME_DETECTION: "v8.6a";
-    @NO_RUNTIME_DETECTION: "v8.7a";
-    @NO_RUNTIME_DETECTION: "v8.8a";
-    @NO_RUNTIME_DETECTION: "v8.9a";
-    @NO_RUNTIME_DETECTION: "v9.1a";
-    @NO_RUNTIME_DETECTION: "v9.2a";
-    @NO_RUNTIME_DETECTION: "v9.3a";
-    @NO_RUNTIME_DETECTION: "v9.4a";
-    @NO_RUNTIME_DETECTION: "v9.5a";
-    @NO_RUNTIME_DETECTION: "v9a";
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] asimd: "neon";
-    /// FEAT_AdvSIMD (Advanced SIMD/NEON)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] pmull: "pmull";
-    implied by target_features: ["aes"];
-    /// FEAT_PMULL (Polynomial Multiply) - Implied by `aes` target_feature
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] fp: "fp";
-    implied by target_features: ["neon"];
-    /// FEAT_FP (Floating point support) - Implied by `neon` target_feature
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] aes: "aes";
-    /// FEAT_AES (AES SIMD instructions) & FEAT_PMULL (PMULL{2}, 64-bit operand variants)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] bf16: "bf16";
-    /// FEAT_BF16 (BFloat16 type, plus MM instructions, plus ASIMD support)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] bti: "bti";
-    /// FEAT_BTI (Branch Target Identification)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] crc: "crc";
-    /// FEAT_CRC32 (Cyclic Redundancy Check)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] cssc: "cssc";
-    /// FEAT_CSSC (Common Short Sequence Compression instructions)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] dit: "dit";
-    /// FEAT_DIT (Data Independent Timing instructions)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] dpb: "dpb";
-    /// FEAT_DPB (aka dcpop - data cache clean to point of persistence)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] dpb2: "dpb2";
-    /// FEAT_DPB2 (aka dcpodp - data cache clean to point of deep persistence)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] dotprod: "dotprod";
-    /// FEAT_DotProd (Vector Dot-Product - ASIMDDP)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] ecv: "ecv";
-    /// FEAT_ECV (Enhanced Counter Virtualization)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] f32mm: "f32mm";
-    /// FEAT_F32MM (single-precision matrix multiplication)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] f64mm: "f64mm";
-    /// FEAT_F64MM (double-precision matrix multiplication)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] faminmax: "faminmax";
-    /// FEAT_FAMINMAX (FAMIN and FAMAX SIMD/SVE/SME instructions)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] fcma: "fcma";
-    /// FEAT_FCMA (float complex number operations)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] fhm: "fhm";
-    /// FEAT_FHM (fp16 multiplication instructions)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] flagm: "flagm";
-    /// FEAT_FLAGM (flag manipulation instructions)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] flagm2: "flagm2";
-    /// FEAT_FLAGM2 (flag manipulation instructions)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] fp16: "fp16";
-    /// FEAT_FP16 (Half-float support)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] fp8: "fp8";
-    /// FEAT_FP8 (F8CVT Instructions)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] fp8dot2: "fp8dot2";
-    /// FEAT_FP8DOT2 (F8DP2 Instructions)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] fp8dot4: "fp8dot4";
-    /// FEAT_FP8DOT4 (F8DP4 Instructions)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] fp8fma: "fp8fma";
-    /// FEAT_FP8FMA (F8FMA Instructions)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] fpmr: "fpmr";
-    without cfg check: true;
-    /// FEAT_FPMR (Special-purpose AArch64-FPMR register)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] frintts: "frintts";
-    /// FEAT_FRINTTS (float to integer rounding instructions)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] hbc: "hbc";
-    /// FEAT_HBC (Hinted conditional branches)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] i8mm: "i8mm";
-    /// FEAT_I8MM (integer matrix multiplication, plus ASIMD support)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] jsconv: "jsconv";
-    /// FEAT_JSCVT (JavaScript float conversion instructions)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] lse: "lse";
-    /// FEAT_LSE (Large System Extension - atomics)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] lse128: "lse128";
-    /// FEAT_LSE128 (128-bit atomics)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] lse2: "lse2";
-    /// FEAT_LSE2 (unaligned and register-pair atomics)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] lut: "lut";
-    /// FEAT_LUT (Lookup Table Instructions)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] mops: "mops";
-    /// FEAT_MOPS (Standardization of memory operations)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] mte: "mte";
-    /// FEAT_MTE & FEAT_MTE2 (Memory Tagging Extension)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] paca: "paca";
-    /// FEAT_PAuth (address authentication)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] pacg: "pacg";
-    /// FEAT_PAuth (generic authentication)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] pauth_lr: "pauth-lr";
-    /// FEAT_PAuth_LR
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] rand: "rand";
-    /// FEAT_RNG (Random Number Generator)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] rcpc: "rcpc";
-    /// FEAT_LRCPC (Release consistent Processor consistent)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] rcpc2: "rcpc2";
-    /// FEAT_LRCPC2 (RCPC with immediate offsets)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] rcpc3: "rcpc3";
-    /// FEAT_LRCPC3 (RCPC Instructions v3)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] rdm: "rdm";
-    /// FEAT_RDM (Rounding Doubling Multiply - ASIMDRDM)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sb: "sb";
-    /// FEAT_SB (speculation barrier)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sha2: "sha2";
-    /// FEAT_SHA1 & FEAT_SHA256 (SHA1 & SHA2-256 instructions)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sha3: "sha3";
-    /// FEAT_SHA512 & FEAT_SHA3 (SHA2-512 & SHA3 instructions)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sm4: "sm4";
-    /// FEAT_SM3 & FEAT_SM4 (SM3 & SM4 instructions)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme: "sme";
-    /// FEAT_SME (Scalable Matrix Extension)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme2: "sme2";
-    /// FEAT_SME2 (SME Version 2)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme2p1: "sme2p1";
-    /// FEAT_SME2p1 (SME Version 2.1)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_b16b16: "sme-b16b16";
-    /// FEAT_SME_B16B16
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_f16f16: "sme-f16f16";
-    /// FEAT_SME_F16F16 (Non-widening half-precision FP16 to FP16 arithmetic for SME2)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_f64f64: "sme-f64f64";
-    /// FEAT_SME_F64F64 (Double-precision floating-point outer product instructions)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_f8f16: "sme-f8f16";
-    /// FEAT_SME_F8F16
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_f8f32: "sme-f8f32";
-    /// FEAT_SME_F8F32
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_fa64: "sme-fa64";
-    /// FEAT_SME_FA64 (Full A64 instruction set support in Streaming SVE mode)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_i16i64: "sme-i16i64";
-    /// FEAT_SME_I16I64 (16-bit to 64-bit integer widening outer product instructions)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sme_lutv2: "sme-lutv2";
-    /// FEAT_SME_LUTv2 (LUTI4 Instruction)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] ssbs: "ssbs";
-    /// FEAT_SSBS & FEAT_SSBS2 (speculative store bypass safe)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] ssve_fp8dot2: "ssve-fp8dot2";
-    /// FEAT_SSVE_FP8DOT2
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] ssve_fp8dot4: "ssve-fp8dot4";
-    /// FEAT_SSVE_FP8DOT4
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] ssve_fp8fma: "ssve-fp8fma";
-    /// FEAT_SSVE_FP8FMA
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve: "sve";
-    /// FEAT_SVE (Scalable Vector Extension)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve2: "sve2";
-    /// FEAT_SVE2 (Scalable Vector Extension 2)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sve2p1: "sve2p1";
-    /// FEAT_SVE2p1 (Scalable Vector Extension 2.1)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve2_aes: "sve2-aes";
-    /// FEAT_SVE_AES & FEAT_SVE_PMULL128 (SVE2 AES crypto)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] sve_b16b16: "sve-b16b16";
-    /// FEAT_SVE_B16B16 (SVE or SME Z-targeting instructions)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve2_bitperm: "sve2-bitperm";
-    /// FEAT_SVE_BitPerm (SVE2 bit permutation instructions)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve2_sha3: "sve2-sha3";
-    /// FEAT_SVE_SHA3 (SVE2 SHA3 crypto)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] sve2_sm4: "sve2-sm4";
-    /// FEAT_SVE_SM4 (SVE2 SM4 crypto)
-    @FEATURE: #[stable(feature = "simd_aarch64", since = "1.60.0")] tme: "tme";
-    /// FEAT_TME (Transactional Memory Extensions)
-    @FEATURE: #[unstable(feature = "stdarch_aarch64_feature_detection", issue = "127764")] wfxt: "wfxt";
-    /// FEAT_WFxT (WFET and WFIT Instructions)
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/arch/arm.rs b/library/stdarch/crates/std_detect/src/detect/arch/arm.rs
deleted file mode 100644
index c3c8883ce31..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/arch/arm.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//! Run-time feature detection on ARM Aarch32.
-
-features! {
-    @TARGET: arm;
-    @CFG: target_arch = "arm";
-    @MACRO_NAME: is_arm_feature_detected;
-    @MACRO_ATTRS:
-    /// Checks if `arm` feature is enabled.
-    #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")]
-    @NO_RUNTIME_DETECTION: "v7";
-    @NO_RUNTIME_DETECTION: "vfp2";
-    @NO_RUNTIME_DETECTION: "vfp3";
-    @NO_RUNTIME_DETECTION: "vfp4";
-    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] neon: "neon";
-    /// ARM Advanced SIMD (NEON) - Aarch32
-    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] pmull: "pmull";
-    without cfg check: true;
-    /// Polynomial Multiply
-    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] crc: "crc";
-    /// CRC32 (Cyclic Redundancy Check)
-    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] aes: "aes";
-    /// FEAT_AES (AES instructions)
-    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] sha2: "sha2";
-    /// FEAT_SHA1 & FEAT_SHA256 (SHA1 & SHA2-256 instructions)
-    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] i8mm: "i8mm";
-    /// FEAT_I8MM (integer matrix multiplication, plus ASIMD support)
-    @FEATURE: #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")] dotprod: "dotprod";
-    /// FEAT_DotProd (Vector Dot-Product - ASIMDDP)
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/arch/loongarch.rs b/library/stdarch/crates/std_detect/src/detect/arch/loongarch.rs
deleted file mode 100644
index 68fc600fa8e..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/arch/loongarch.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-//! Run-time feature detection on LoongArch.
-
-features! {
-    @TARGET: loongarch;
-    @CFG: any(target_arch = "loongarch32", target_arch = "loongarch64");
-    @MACRO_NAME: is_loongarch_feature_detected;
-    @MACRO_ATTRS:
-    /// Checks if `loongarch` feature is enabled.
-    /// Supported arguments are:
-    ///
-    /// * `"f"`
-    /// * `"d"`
-    /// * `"frecipe"`
-    /// * `"div32"`
-    /// * `"lsx"`
-    /// * `"lasx"`
-    /// * `"lam-bh"`
-    /// * `"lamcas"`
-    /// * `"ld-seq-sa"`
-    /// * `"scq"`
-    /// * `"lbt"`
-    /// * `"lvz"`
-    /// * `"ual"`
-    #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")]
-    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] f: "f";
-    /// F
-    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] d: "d";
-    /// D
-    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] frecipe: "frecipe";
-    /// Frecipe
-    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] div32: "div32";
-    /// Div32
-    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] lsx: "lsx";
-    /// LSX
-    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] lasx: "lasx";
-    /// LASX
-    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] lam_bh: "lam-bh";
-    /// LAM-BH
-    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] lamcas: "lamcas";
-    /// LAM-CAS
-    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] ld_seq_sa: "ld-seq-sa";
-    /// LD-SEQ-SA
-    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] scq: "scq";
-    /// SCQ
-    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] lbt: "lbt";
-    /// LBT
-    @FEATURE: #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")] lvz: "lvz";
-    /// LVZ
-    @FEATURE: #[unstable(feature = "stdarch_loongarch_feature_detection", issue = "117425")] ual: "ual";
-    /// UAL
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/arch/mips.rs b/library/stdarch/crates/std_detect/src/detect/arch/mips.rs
deleted file mode 100644
index e185fdfcaac..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/arch/mips.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//! Run-time feature detection on MIPS.
-
-features! {
-    @TARGET: mips;
-    @CFG: target_arch = "mips";
-    @MACRO_NAME: is_mips_feature_detected;
-    @MACRO_ATTRS:
-    /// Checks if `mips` feature is enabled.
-    #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")]
-    @FEATURE: #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")] msa: "msa";
-    /// MIPS SIMD Architecture (MSA)
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/arch/mips64.rs b/library/stdarch/crates/std_detect/src/detect/arch/mips64.rs
deleted file mode 100644
index 69fe4869d30..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/arch/mips64.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//! Run-time feature detection on MIPS64.
-
-features! {
-    @TARGET: mips64;
-    @CFG: target_arch = "mips64";
-    @MACRO_NAME: is_mips64_feature_detected;
-    @MACRO_ATTRS:
-    /// Checks if `mips64` feature is enabled.
-    #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")]
-    @FEATURE: #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")] msa: "msa";
-    /// MIPS SIMD Architecture (MSA)
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/arch/mod.rs b/library/stdarch/crates/std_detect/src/detect/arch/mod.rs
deleted file mode 100644
index b0be554ed89..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/arch/mod.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-#![allow(dead_code)]
-
-use cfg_if::cfg_if;
-
-// Export the macros for all supported architectures.
-#[macro_use]
-mod x86;
-#[macro_use]
-mod arm;
-#[macro_use]
-mod aarch64;
-#[macro_use]
-mod riscv;
-#[macro_use]
-mod powerpc;
-#[macro_use]
-mod powerpc64;
-#[macro_use]
-mod mips;
-#[macro_use]
-mod mips64;
-#[macro_use]
-mod loongarch;
-#[macro_use]
-mod s390x;
-
-cfg_if! {
-    if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
-        #[stable(feature = "simd_x86", since = "1.27.0")]
-        pub use x86::*;
-    } else if #[cfg(target_arch = "arm")] {
-        #[unstable(feature = "stdarch_arm_feature_detection", issue = "111190")]
-        pub use arm::*;
-    } else if #[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))] {
-        #[stable(feature = "simd_aarch64", since = "1.60.0")]
-        pub use aarch64::*;
-    } else if #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))] {
-        #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")]
-        pub use riscv::*;
-    } else if #[cfg(target_arch = "powerpc")] {
-        #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")]
-        pub use powerpc::*;
-    } else if #[cfg(target_arch = "powerpc64")] {
-        #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")]
-        pub use powerpc64::*;
-    } else if #[cfg(target_arch = "mips")] {
-        #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")]
-        pub use mips::*;
-    } else if #[cfg(target_arch = "mips64")] {
-        #[unstable(feature = "stdarch_mips_feature_detection", issue = "111188")]
-        pub use mips64::*;
-    } else if #[cfg(any(target_arch = "loongarch32", target_arch = "loongarch64"))] {
-        #[stable(feature = "stdarch_loongarch_feature", since = "1.89.0")]
-        pub use loongarch::*;
-    } else if #[cfg(target_arch = "s390x")] {
-        #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-        pub use s390x::*;
-    } else {
-        // Unimplemented architecture:
-        #[doc(hidden)]
-        pub(crate) enum Feature {
-            Null
-        }
-        #[doc(hidden)]
-        #[unstable(feature = "stdarch_internal", issue = "none")]
-        pub mod __is_feature_detected {}
-
-        impl Feature {
-            #[doc(hidden)]
-            pub(crate) fn from_str(_s: &str) -> Result<Feature, ()> { Err(()) }
-            #[doc(hidden)]
-            pub(crate) fn to_str(self) -> &'static str { "" }
-        }
-    }
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/arch/powerpc.rs b/library/stdarch/crates/std_detect/src/detect/arch/powerpc.rs
deleted file mode 100644
index c390993a48a..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/arch/powerpc.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! Run-time feature detection on PowerPC.
-
-features! {
-    @TARGET: powerpc;
-    @CFG: target_arch = "powerpc";
-    @MACRO_NAME: is_powerpc_feature_detected;
-    @MACRO_ATTRS:
-    /// Checks if `powerpc` feature is enabled.
-    #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")]
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] altivec: "altivec";
-    /// Altivec
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] vsx: "vsx";
-    /// VSX
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8: "power8";
-    without cfg check: true;
-    /// Power8
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_altivec: "power8-altivec";
-    /// Power8 altivec
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_vector: "power8-vector";
-    /// Power8 vector
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_crypto: "power8-crypto";
-    /// Power8 crypto
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9: "power9";
-    without cfg check: true;
-    /// Power9
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9_altivec: "power9-altivec";
-    /// Power9 altivec
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9_vector: "power9-vector";
-    /// Power9 vector
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/arch/powerpc64.rs b/library/stdarch/crates/std_detect/src/detect/arch/powerpc64.rs
deleted file mode 100644
index cf05baa6f79..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/arch/powerpc64.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! Run-time feature detection on PowerPC64.
-
-features! {
-    @TARGET: powerpc64;
-    @CFG: target_arch = "powerpc64";
-    @MACRO_NAME: is_powerpc64_feature_detected;
-    @MACRO_ATTRS:
-    /// Checks if `powerpc` feature is enabled.
-    #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")]
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] altivec: "altivec";
-    /// Altivec
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] vsx: "vsx";
-    /// VSX
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8: "power8";
-    without cfg check: true;
-    /// Power8
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_altivec: "power8-altivec";
-    /// Power8 altivec
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_vector: "power8-vector";
-    /// Power8 vector
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power8_crypto: "power8-crypto";
-    /// Power8 crypto
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9: "power9";
-    without cfg check: true;
-    /// Power9
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9_altivec: "power9-altivec";
-    /// Power9 altivec
-    @FEATURE: #[unstable(feature = "stdarch_powerpc_feature_detection", issue = "111191")] power9_vector: "power9-vector";
-    /// Power9 vector
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/arch/riscv.rs b/library/stdarch/crates/std_detect/src/detect/arch/riscv.rs
deleted file mode 100644
index b86190d7bbf..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/arch/riscv.rs
+++ /dev/null
@@ -1,344 +0,0 @@
-//! Run-time feature detection on RISC-V.
-
-features! {
-    @TARGET: riscv;
-    @CFG: any(target_arch = "riscv32", target_arch = "riscv64");
-    @MACRO_NAME: is_riscv_feature_detected;
-    @MACRO_ATTRS:
-    /// A macro to test at *runtime* whether instruction sets are available on
-    /// RISC-V platforms.
-    ///
-    /// RISC-V standard defined the base sets and the extension sets.
-    /// The base sets are RV32I, RV64I, RV32E or RV128I. Any RISC-V platform
-    /// must support one base set and/or multiple extension sets.
-    ///
-    /// Any RISC-V standard instruction sets can be in state of either ratified,
-    /// frozen or draft. The version and status of current standard instruction
-    /// sets can be checked out from preface section of the [ISA manual].
-    ///
-    /// Platform may define and support their own custom instruction sets with
-    /// ISA prefix X. These sets are highly platform specific and should be
-    /// detected with their own platform support crates.
-    ///
-    /// [ISA manual]: https://riscv.org/specifications/ratified/
-    ///
-    /// # Platform-specific/agnostic Behavior and Availability
-    ///
-    /// Runtime detection depends on the platform-specific feature detection
-    /// facility and its availability per feature is
-    /// highly platform/version-specific.
-    ///
-    /// Still, a best-effort attempt is performed to enable subset/dependent
-    /// features if a superset feature is enabled regardless of the platform.
-    /// For instance, if the A extension (`"a"`) is enabled, its subsets (the
-    /// Zalrsc and Zaamo extensions; `"zalrsc"` and `"zaamo"`) are also enabled.
-    /// Likewise, if the F extension (`"f"`) is enabled, one of its dependencies
-    /// (the Zicsr extension `"zicsr"`) is also enabled.
-    ///
-    /// # Unprivileged Specification
-    ///
-    /// The supported ratified RISC-V instruction sets are as follows:
-    ///
-    /// * RV32E: `"rv32e"`
-    /// * RV32I: `"rv32i"`
-    /// * RV64I: `"rv64i"`
-    /// * A: `"a"`
-    ///   * Zaamo: `"zaamo"`
-    ///   * Zalrsc: `"zalrsc"`
-    /// * B: `"b"`
-    ///   * Zba: `"zba"`
-    ///   * Zbb: `"zbb"`
-    ///   * Zbs: `"zbs"`
-    /// * C: `"c"`
-    ///   * Zca: `"zca"`
-    ///   * Zcd: `"zcd"` (if D is enabled)
-    ///   * Zcf: `"zcf"` (if F is enabled on RV32)
-    /// * D: `"d"`
-    /// * F: `"f"`
-    /// * M: `"m"`
-    /// * Q: `"q"`
-    /// * V: `"v"`
-    ///   * Zve32x: `"zve32x"`
-    ///   * Zve32f: `"zve32f"`
-    ///   * Zve64x: `"zve64x"`
-    ///   * Zve64f: `"zve64f"`
-    ///   * Zve64d: `"zve64d"`
-    /// * Zicbom: `"zicbom"`
-    /// * Zicboz: `"zicboz"`
-    /// * Zicntr: `"zicntr"`
-    /// * Zicond: `"zicond"`
-    /// * Zicsr: `"zicsr"`
-    /// * Zifencei: `"zifencei"`
-    /// * Zihintntl: `"zihintntl"`
-    /// * Zihintpause: `"zihintpause"`
-    /// * Zihpm: `"zihpm"`
-    /// * Zimop: `"zimop"`
-    /// * Zacas: `"zacas"`
-    /// * Zawrs: `"zawrs"`
-    /// * Zfa: `"zfa"`
-    /// * Zfbfmin: `"zfbfmin"`
-    /// * Zfh: `"zfh"`
-    ///   * Zfhmin: `"zfhmin"`
-    /// * Zfinx: `"zfinx"`
-    /// * Zdinx: `"zdinx"`
-    /// * Zhinx: `"zhinx"`
-    ///   * Zhinxmin: `"zhinxmin"`
-    /// * Zcb: `"zcb"`
-    /// * Zcmop: `"zcmop"`
-    /// * Zbc: `"zbc"`
-    /// * Zbkb: `"zbkb"`
-    /// * Zbkc: `"zbkc"`
-    /// * Zbkx: `"zbkx"`
-    /// * Zk: `"zk"`
-    /// * Zkn: `"zkn"`
-    ///   * Zknd: `"zknd"`
-    ///   * Zkne: `"zkne"`
-    ///   * Zknh: `"zknh"`
-    /// * Zkr: `"zkr"`
-    /// * Zks: `"zks"`
-    ///   * Zksed: `"zksed"`
-    ///   * Zksh: `"zksh"`
-    /// * Zkt: `"zkt"`
-    /// * Zvbb: `"zvbb"`
-    /// * Zvbc: `"zvbc"`
-    /// * Zvfbfmin: `"zvfbfmin"`
-    /// * Zvfbfwma: `"zvfbfwma"`
-    /// * Zvfh: `"zvfh"`
-    ///   * Zvfhmin: `"zvfhmin"`
-    /// * Zvkb: `"zvkb"`
-    /// * Zvkg: `"zvkg"`
-    /// * Zvkn: `"zvkn"`
-    ///   * Zvkned: `"zvkned"`
-    ///   * Zvknha: `"zvknha"`
-    ///   * Zvknhb: `"zvknhb"`
-    /// * Zvknc: `"zvknc"`
-    /// * Zvkng: `"zvkng"`
-    /// * Zvks: `"zvks"`
-    ///   * Zvksed: `"zvksed"`
-    ///   * Zvksh: `"zvksh"`
-    /// * Zvksc: `"zvksc"`
-    /// * Zvksg: `"zvksg"`
-    /// * Zvkt: `"zvkt"`
-    /// * Ztso: `"ztso"`
-    ///
-    /// There's also bases and extensions marked as standard instruction set,
-    /// but they are in frozen or draft state. These instruction sets are also
-    /// reserved by this macro and can be detected in the future platforms.
-    ///
-    /// Draft RISC-V instruction sets:
-    ///
-    /// * RV128I: `"rv128i"`
-    /// * J: `"j"`
-    /// * P: `"p"`
-    /// * Zam: `"zam"`
-    ///
-    /// # Performance Hints
-    ///
-    /// The two features below define performance hints for unaligned
-    /// scalar/vector memory accesses, respectively.  If enabled, it denotes that
-    /// corresponding unaligned memory access is reasonably fast.
-    ///
-    /// * `"unaligned-scalar-mem"`
-    ///   * Runtime detection requires Linux kernel version 6.4 or later.
-    /// * `"unaligned-vector-mem"`
-    ///   * Runtime detection requires Linux kernel version 6.13 or later.
-    #[stable(feature = "riscv_ratified", since = "1.78.0")]
-
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] rv32i: "rv32i";
-    without cfg check: true;
-    /// RV32I Base Integer Instruction Set
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] rv32e: "rv32e";
-    without cfg check: true;
-    /// RV32E Base Integer Instruction Set
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] rv64i: "rv64i";
-    without cfg check: true;
-    /// RV64I Base Integer Instruction Set
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] rv128i: "rv128i";
-    without cfg check: true;
-    /// RV128I Base Integer Instruction Set
-
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] unaligned_scalar_mem: "unaligned-scalar-mem";
-    /// Has reasonably performant unaligned scalar
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] unaligned_vector_mem: "unaligned-vector-mem";
-    /// Has reasonably performant unaligned vector
-
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicsr: "zicsr";
-    /// "Zicsr" Extension for Control and Status Register (CSR) Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicntr: "zicntr";
-    /// "Zicntr" Extension for Base Counters and Timers
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zihpm: "zihpm";
-    /// "Zihpm" Extension for Hardware Performance Counters
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zifencei: "zifencei";
-    /// "Zifencei" Extension for Instruction-Fetch Fence
-
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zihintntl: "zihintntl";
-    /// "Zihintntl" Extension for Non-Temporal Locality Hints
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zihintpause: "zihintpause";
-    /// "Zihintpause" Extension for Pause Hint
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zimop: "zimop";
-    /// "Zimop" Extension for May-Be-Operations
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicbom: "zicbom";
-    /// "Zicbom" Extension for Cache-Block Management Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicboz: "zicboz";
-    /// "Zicboz" Extension for Cache-Block Zero Instruction
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zicond: "zicond";
-    /// "Zicond" Extension for Integer Conditional Operations
-
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] m: "m";
-    /// "M" Extension for Integer Multiplication and Division
-
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] a: "a";
-    /// "A" Extension for Atomic Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zalrsc: "zalrsc";
-    /// "Zalrsc" Extension for Load-Reserved/Store-Conditional Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zaamo: "zaamo";
-    /// "Zaamo" Extension for Atomic Memory Operations
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zawrs: "zawrs";
-    /// "Zawrs" Extension for Wait-on-Reservation-Set Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zacas: "zacas";
-    /// "Zacas" Extension for Atomic Compare-and-Swap (CAS) Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zam: "zam";
-    without cfg check: true;
-    /// "Zam" Extension for Misaligned Atomics
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] ztso: "ztso";
-    /// "Ztso" Extension for Total Store Ordering
-
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] f: "f";
-    /// "F" Extension for Single-Precision Floating-Point
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] d: "d";
-    /// "D" Extension for Double-Precision Floating-Point
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] q: "q";
-    without cfg check: true;
-    /// "Q" Extension for Quad-Precision Floating-Point
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zfh: "zfh";
-    /// "Zfh" Extension for Half-Precision Floating-Point
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zfhmin: "zfhmin";
-    /// "Zfhmin" Extension for Minimal Half-Precision Floating-Point
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zfa: "zfa";
-    /// "Zfa" Extension for Additional Floating-Point Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zfbfmin: "zfbfmin";
-    /// "Zfbfmin" Extension for Scalar BF16 Converts
-
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zfinx: "zfinx";
-    /// "Zfinx" Extension for Single-Precision Floating-Point in Integer Registers
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zdinx: "zdinx";
-    /// "Zdinx" Extension for Double-Precision Floating-Point in Integer Registers
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zhinx: "zhinx";
-    /// "Zhinx" Extension for Half-Precision Floating-Point in Integer Registers
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zhinxmin: "zhinxmin";
-    /// "Zhinxmin" Extension for Minimal Half-Precision Floating-Point in Integer Registers
-
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] c: "c";
-    /// "C" Extension for Compressed Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zca: "zca";
-    /// "Zca" Compressed Instructions excluding Floating-Point Loads/Stores
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcf: "zcf";
-    without cfg check: true;
-    /// "Zcf" Compressed Instructions for Single-Precision Floating-Point Loads/Stores on RV32
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcd: "zcd";
-    without cfg check: true;
-    /// "Zcd" Compressed Instructions for Double-Precision Floating-Point Loads/Stores
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcb: "zcb";
-    /// "Zcb" Simple Code-size Saving Compressed Instructions
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zcmop: "zcmop";
-    /// "Zcmop" Extension for Compressed May-Be-Operations
-
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] b: "b";
-    /// "B" Extension for Bit Manipulation
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zba: "zba";
-    /// "Zba" Extension for Address Generation
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbb: "zbb";
-    /// "Zbb" Extension for Basic Bit-Manipulation
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbc: "zbc";
-    /// "Zbc" Extension for Carry-less Multiplication
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbs: "zbs";
-    /// "Zbs" Extension for Single-Bit Instructions
-
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbkb: "zbkb";
-    /// "Zbkb" Extension for Bit-Manipulation for Cryptography
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbkc: "zbkc";
-    /// "Zbkc" Extension for Carry-less Multiplication for Cryptography
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zbkx: "zbkx";
-    /// "Zbkx" Extension for Crossbar Permutations
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zknd: "zknd";
-    /// "Zknd" Cryptography Extension for NIST Suite: AES Decryption
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zkne: "zkne";
-    /// "Zkne" Cryptography Extension for NIST Suite: AES Encryption
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zknh: "zknh";
-    /// "Zknh" Cryptography Extension for NIST Suite: Hash Function Instructions
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zksed: "zksed";
-    /// "Zksed" Cryptography Extension for ShangMi Suite: SM4 Block Cipher Instructions
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zksh: "zksh";
-    /// "Zksh" Cryptography Extension for ShangMi Suite: SM3 Hash Function Instructions
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zkr: "zkr";
-    /// "Zkr" Entropy Source Extension
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zkn: "zkn";
-    /// "Zkn" Cryptography Extension for NIST Algorithm Suite
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zks: "zks";
-    /// "Zks" Cryptography Extension for ShangMi Algorithm Suite
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zk: "zk";
-    /// "Zk" Cryptography Extension for Standard Scalar Cryptography
-    @FEATURE: #[stable(feature = "riscv_ratified", since = "1.78.0")] zkt: "zkt";
-    /// "Zkt" Cryptography Extension for Data Independent Execution Latency
-
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] v: "v";
-    /// "V" Extension for Vector Operations
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zve32x: "zve32x";
-    /// "Zve32x" Vector Extension for Embedded Processors (32-bit+; Integer)
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zve32f: "zve32f";
-    /// "Zve32f" Vector Extension for Embedded Processors (32-bit+; with Single-Precision Floating-Point)
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zve64x: "zve64x";
-    /// "Zve64x" Vector Extension for Embedded Processors (64-bit+; Integer)
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zve64f: "zve64f";
-    /// "Zve64f" Vector Extension for Embedded Processors (64-bit+; with Single-Precision Floating-Point)
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zve64d: "zve64d";
-    /// "Zve64d" Vector Extension for Embedded Processors (64-bit+; with Double-Precision Floating-Point)
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvfh: "zvfh";
-    /// "Zvfh" Vector Extension for Half-Precision Floating-Point
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvfhmin: "zvfhmin";
-    /// "Zvfhmin" Vector Extension for Minimal Half-Precision Floating-Point
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvfbfmin: "zvfbfmin";
-    /// "Zvfbfmin" Vector Extension for BF16 Converts
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvfbfwma: "zvfbfwma";
-    /// "Zvfbfwma" Vector Extension for BF16 Widening Multiply-Add
-
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvbb: "zvbb";
-    /// "Zvbb" Extension for Vector Basic Bit-Manipulation
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvbc: "zvbc";
-    /// "Zvbc" Extension for Vector Carryless Multiplication
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkb: "zvkb";
-    /// "Zvkb" Extension for Vector Cryptography Bit-Manipulation
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkg: "zvkg";
-    /// "Zvkg" Cryptography Extension for Vector GCM/GMAC
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkned: "zvkned";
-    /// "Zvkned" Cryptography Extension for NIST Suite: Vector AES Block Cipher
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvknha: "zvknha";
-    /// "Zvknha" Cryptography Extension for Vector SHA-2 Secure Hash (SHA-256)
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvknhb: "zvknhb";
-    /// "Zvknhb" Cryptography Extension for Vector SHA-2 Secure Hash (SHA-256/512)
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvksed: "zvksed";
-    /// "Zvksed" Cryptography Extension for ShangMi Suite: Vector SM4 Block Cipher
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvksh: "zvksh";
-    /// "Zvksh" Cryptography Extension for ShangMi Suite: Vector SM3 Secure Hash
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkn: "zvkn";
-    /// "Zvkn" Cryptography Extension for NIST Algorithm Suite
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvknc: "zvknc";
-    /// "Zvknc" Cryptography Extension for NIST Algorithm Suite with Carryless Multiply
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkng: "zvkng";
-    /// "Zvkng" Cryptography Extension for NIST Algorithm Suite with GCM
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvks: "zvks";
-    /// "Zvks" Cryptography Extension for ShangMi Algorithm Suite
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvksc: "zvksc";
-    /// "Zvksc" Cryptography Extension for ShangMi Algorithm Suite with Carryless Multiply
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvksg: "zvksg";
-    /// "Zvksg" Cryptography Extension for ShangMi Algorithm Suite with GCM
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] zvkt: "zvkt";
-    /// "Zvkt" Extension for Vector Data-Independent Execution Latency
-
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] j: "j";
-    without cfg check: true;
-    /// "J" Extension for Dynamically Translated Languages
-    @FEATURE: #[unstable(feature = "stdarch_riscv_feature_detection", issue = "111192")] p: "p";
-    without cfg check: true;
-    /// "P" Extension for Packed-SIMD Instructions
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/arch/s390x.rs b/library/stdarch/crates/std_detect/src/detect/arch/s390x.rs
deleted file mode 100644
index 4c20d011680..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/arch/s390x.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-//! Run-time feature detection on s390x.
-
-features! {
-    @TARGET: s390x;
-    @CFG: target_arch = "s390x";
-    @MACRO_NAME: is_s390x_feature_detected;
-    @MACRO_ATTRS:
-    /// Checks if `s390x` feature is enabled.
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] concurrent_functions: "concurrent-functions";
-    /// s390x concurrent-functions facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] deflate_conversion: "deflate-conversion";
-    /// s390x deflate-conversion facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] enhanced_sort: "enhanced-sort";
-    /// s390x enhanced-sort facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] guarded_storage: "guarded-storage";
-    /// s390x guarded-storage facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] high_word: "high-word";
-    /// s390x high-word facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension3: "message-security-assist-extension3";
-    /// s390x message-security-assist-extension3 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension4: "message-security-assist-extension4";
-    /// s390x message-security-assist-extension4 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension5: "message-security-assist-extension5";
-    /// s390x message-security-assist-extension5 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension8: "message-security-assist-extension8";
-    /// s390x message-security-assist-extension8 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension9: "message-security-assist-extension9";
-    /// s390x message-security-assist-extension9 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] message_security_assist_extension12: "message-security-assist-extension12";
-    /// s390x message-security-assist-extension12 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] miscellaneous_extensions_2: "miscellaneous-extensions-2";
-    /// s390x miscellaneous-extensions-2 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] miscellaneous_extensions_3: "miscellaneous-extensions-3";
-    /// s390x miscellaneous-extensions-3 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] miscellaneous_extensions_4: "miscellaneous-extensions-4";
-    /// s390x miscellaneous-extensions-4 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] nnp_assist: "nnp-assist";
-    /// s390x nnp-assist facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] transactional_execution: "transactional-execution";
-    /// s390x transactional-execution facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector: "vector";
-    /// s390x vector facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_enhancements_1: "vector-enhancements-1";
-    /// s390x vector-enhancements-1 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_enhancements_2: "vector-enhancements-2";
-    /// s390x vector-enhancements-2 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_enhancements_3: "vector-enhancements-3";
-    /// s390x vector-enhancements-3 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_packed_decimal: "vector-packed-decimal";
-    /// s390x vector-packed-decimal facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_packed_decimal_enhancement: "vector-packed-decimal-enhancement";
-    /// s390x vector-packed-decimal-enhancement facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_packed_decimal_enhancement_2: "vector-packed-decimal-enhancement-2";
-    /// s390x vector-packed-decimal-enhancement-2 facility
-    #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")]
-    @FEATURE: #[unstable(feature = "stdarch_s390x_feature_detection", issue = "135413")] vector_packed_decimal_enhancement_3: "vector-packed-decimal-enhancement-3";
-    /// s390x vector-packed-decimal-enhancement-3 facility
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/arch/x86.rs b/library/stdarch/crates/std_detect/src/detect/arch/x86.rs
deleted file mode 100644
index 28b3e3cfb35..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/arch/x86.rs
+++ /dev/null
@@ -1,278 +0,0 @@
-//! This module implements minimal run-time feature detection for x86.
-//!
-//! The features are detected using the `detect_features` function below.
-//! This function uses the CPUID instruction to read the feature flags from the
-//! CPU and encodes them in a `usize` where each bit position represents
-//! whether a feature is available (bit is set) or unavailable (bit is cleared).
-//!
-//! The enum `Feature` is used to map bit positions to feature names, and the
-//! the `__crate::detect::check_for!` macro is used to map string literals (e.g.,
-//! "avx") to these bit positions (e.g., `Feature::avx`).
-//!
-//! The run-time feature detection is performed by the
-//! `__crate::detect::check_for(Feature) -> bool` function. On its first call,
-//! this functions queries the CPU for the available features and stores them
-//! in a global `AtomicUsize` variable. The query is performed by just checking
-//! whether the feature bit in this global variable is set or cleared.
-
-features! {
-    @TARGET: x86;
-    @CFG: any(target_arch = "x86", target_arch = "x86_64");
-    @MACRO_NAME: is_x86_feature_detected;
-    @MACRO_ATTRS:
-    /// A macro to test at *runtime* whether a CPU feature is available on
-    /// x86/x86-64 platforms.
-    ///
-    /// This macro is provided in the standard library and will detect at runtime
-    /// whether the specified CPU feature is detected. This does **not** resolve at
-    /// compile time unless the specified feature is already enabled for the entire
-    /// crate. Runtime detection currently relies mostly on the `cpuid` instruction.
-    ///
-    /// This macro only takes one argument which is a string literal of the feature
-    /// being tested for. The feature names supported are the lowercase versions of
-    /// the ones defined by Intel in [their documentation][docs].
-    ///
-    /// ## Supported arguments
-    ///
-    /// This macro supports the same names that `#[target_feature]` supports. Unlike
-    /// `#[target_feature]`, however, this macro does not support names separated
-    /// with a comma. Instead testing for multiple features must be done through
-    /// separate macro invocations for now.
-    ///
-    /// Supported arguments are:
-    ///
-    /// * `"aes"`
-    /// * `"pclmulqdq"`
-    /// * `"rdrand"`
-    /// * `"rdseed"`
-    /// * `"tsc"`
-    /// * `"mmx"`
-    /// * `"sse"`
-    /// * `"sse2"`
-    /// * `"sse3"`
-    /// * `"ssse3"`
-    /// * `"sse4.1"`
-    /// * `"sse4.2"`
-    /// * `"sse4a"`
-    /// * `"sha"`
-    /// * `"avx"`
-    /// * `"avx2"`
-    /// * `"sha512"`
-    /// * `"sm3"`
-    /// * `"sm4"`
-    /// * `"avx512f"`
-    /// * `"avx512cd"`
-    /// * `"avx512er"`
-    /// * `"avx512pf"`
-    /// * `"avx512bw"`
-    /// * `"avx512dq"`
-    /// * `"avx512vl"`
-    /// * `"avx512ifma"`
-    /// * `"avx512vbmi"`
-    /// * `"avx512vpopcntdq"`
-    /// * `"avx512vbmi2"`
-    /// * `"gfni"`
-    /// * `"vaes"`
-    /// * `"vpclmulqdq"`
-    /// * `"avx512vnni"`
-    /// * `"avx512bitalg"`
-    /// * `"avx512bf16"`
-    /// * `"avx512vp2intersect"`
-    /// * `"avx512fp16"`
-    /// * `"avxvnni"`
-    /// * `"avxifma"`
-    /// * `"avxneconvert"`
-    /// * `"avxvnniint8"`
-    /// * `"avxvnniint16"`
-    /// * `"amx-tile"`
-    /// * `"amx-int8"`
-    /// * `"amx-bf16"`
-    /// * `"amx-fp16"`
-    /// * `"amx-complex"`
-    /// * `"amx-avx512"`
-    /// * `"amx-fp8"`
-    /// * `"amx-movrs"`
-    /// * `"amx-tf32"`
-    /// * `"amx-transpose"`
-    /// * `"f16c"`
-    /// * `"fma"`
-    /// * `"bmi1"`
-    /// * `"bmi2"`
-    /// * `"abm"`
-    /// * `"lzcnt"`
-    /// * `"tbm"`
-    /// * `"popcnt"`
-    /// * `"fxsr"`
-    /// * `"xsave"`
-    /// * `"xsaveopt"`
-    /// * `"xsaves"`
-    /// * `"xsavec"`
-    /// * `"cmpxchg16b"`
-    /// * `"kl"`
-    /// * `"widekl"`
-    /// * `"adx"`
-    /// * `"rtm"`
-    /// * `"movbe"`
-    /// * `"ermsb"`
-    /// * `"movrs"`
-    /// * `"xop"`
-    ///
-    /// [docs]: https://software.intel.com/sites/landingpage/IntrinsicsGuide
-    #[stable(feature = "simd_x86", since = "1.27.0")]
-    @BIND_FEATURE_NAME: "abm"; "lzcnt"; // abm is a synonym for lzcnt
-    @BIND_FEATURE_NAME: "avx512gfni"; "gfni"; #[deprecated(since = "1.67.0", note = "the `avx512gfni` feature has been renamed to `gfni`")];
-    @BIND_FEATURE_NAME: "avx512vaes"; "vaes"; #[deprecated(since = "1.67.0", note = "the `avx512vaes` feature has been renamed to `vaes`")];
-    @BIND_FEATURE_NAME: "avx512vpclmulqdq"; "vpclmulqdq"; #[deprecated(since = "1.67.0", note = "the `avx512vpclmulqdq` feature has been renamed to `vpclmulqdq`")];
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] aes: "aes";
-    /// AES (Advanced Encryption Standard New Instructions AES-NI)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] pclmulqdq: "pclmulqdq";
-    /// CLMUL (Carry-less Multiplication)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] rdrand: "rdrand";
-    /// RDRAND
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] rdseed: "rdseed";
-    /// RDSEED
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] tsc: "tsc";
-    without cfg check: true;
-    /// TSC (Time Stamp Counter)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] mmx: "mmx";
-    without cfg check: true;
-    /// MMX (MultiMedia eXtensions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse: "sse";
-    /// SSE (Streaming SIMD Extensions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse2: "sse2";
-    /// SSE2 (Streaming SIMD Extensions 2)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse3: "sse3";
-    /// SSE3 (Streaming SIMD Extensions 3)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] ssse3: "ssse3";
-    /// SSSE3 (Supplemental Streaming SIMD Extensions 3)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse4_1: "sse4.1";
-    /// SSE4.1 (Streaming SIMD Extensions 4.1)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse4_2: "sse4.2";
-    /// SSE4.2 (Streaming SIMD Extensions 4.2)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sse4a: "sse4a";
-    /// SSE4a (Streaming SIMD Extensions 4a)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] sha: "sha";
-    /// SHA
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx: "avx";
-    /// AVX (Advanced Vector Extensions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx2: "avx2";
-    /// AVX2 (Advanced Vector Extensions 2)
-    @FEATURE: #[stable(feature = "sha512_sm_x86", since = "1.89.0")] sha512: "sha512";
-    /// SHA512
-    @FEATURE: #[stable(feature = "sha512_sm_x86", since = "1.89.0")] sm3: "sm3";
-    /// SM3
-    @FEATURE: #[stable(feature = "sha512_sm_x86", since = "1.89.0")] sm4: "sm4";
-    /// SM4
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512f: "avx512f" ;
-    /// AVX-512 F (Foundation)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512cd: "avx512cd" ;
-    /// AVX-512 CD (Conflict Detection Instructions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512er: "avx512er";
-    without cfg check: true;
-    /// AVX-512 ER (Expo nential and Reciprocal Instructions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512pf: "avx512pf";
-    without cfg check: true;
-    /// AVX-512 PF (Prefetch Instructions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512bw: "avx512bw";
-    /// AVX-512 BW (Byte and Word Instructions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512dq: "avx512dq";
-    /// AVX-512 DQ (Doubleword and Quadword)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vl: "avx512vl";
-    /// AVX-512 VL (Vector Length Extensions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512ifma: "avx512ifma";
-    /// AVX-512 IFMA (Integer Fused Multiply Add)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vbmi: "avx512vbmi";
-    /// AVX-512 VBMI (Vector Byte Manipulation Instructions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vpopcntdq: "avx512vpopcntdq";
-    /// AVX-512 VPOPCNTDQ (Vector Population Count Doubleword and Quadword)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vbmi2: "avx512vbmi2";
-    /// AVX-512 VBMI2 (Additional byte, word, dword and qword capabilities)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] gfni: "gfni";
-    /// AVX-512 GFNI (Galois Field New Instruction)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] vaes: "vaes";
-    /// AVX-512 VAES (Vector AES instruction)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] vpclmulqdq: "vpclmulqdq";
-    /// AVX-512 VPCLMULQDQ (Vector PCLMULQDQ instructions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vnni: "avx512vnni";
-    /// AVX-512 VNNI (Vector Neural Network Instructions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512bitalg: "avx512bitalg";
-    /// AVX-512 BITALG (Support for VPOPCNT\[B,W\] and VPSHUFBITQMB)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512bf16: "avx512bf16";
-    /// AVX-512 BF16 (BFLOAT16 instructions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512vp2intersect: "avx512vp2intersect";
-    /// AVX-512 P2INTERSECT
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] avx512fp16: "avx512fp16";
-    /// AVX-512 FP16 (FLOAT16 instructions)
-    @FEATURE: #[stable(feature = "avx512_target_feature", since = "1.89.0")] avxifma: "avxifma";
-    /// AVX-IFMA (Integer Fused Multiply Add)
-    @FEATURE: #[stable(feature = "avx512_target_feature", since = "1.89.0")] avxneconvert: "avxneconvert";
-    /// AVX-NE-CONVERT (Exceptionless Convert)
-    @FEATURE: #[stable(feature = "avx512_target_feature", since = "1.89.0")] avxvnni: "avxvnni";
-    /// AVX-VNNI (Vector Neural Network Instructions)
-    @FEATURE: #[stable(feature = "avx512_target_feature", since = "1.89.0")] avxvnniint16: "avxvnniint16";
-    /// AVX-VNNI_INT8 (VNNI with 16-bit Integers)
-    @FEATURE: #[stable(feature = "avx512_target_feature", since = "1.89.0")] avxvnniint8: "avxvnniint8";
-    /// AVX-VNNI_INT16 (VNNI with 8-bit integers)
-    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_tile: "amx-tile";
-    /// AMX (Advanced Matrix Extensions) - Tile load/store
-    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_int8: "amx-int8";
-    /// AMX-INT8 (Operations on 8-bit integers)
-    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_bf16: "amx-bf16";
-    /// AMX-BF16 (BFloat16 Operations)
-    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_fp16: "amx-fp16";
-    /// AMX-FP16 (Float16 Operations)
-    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_complex: "amx-complex";
-    /// AMX-COMPLEX (Complex number Operations)
-    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_avx512: "amx-avx512";
-    /// AMX-AVX512 (AVX512 operations extended to matrices)
-    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_fp8: "amx-fp8";
-    /// AMX-FP8 (Float8 Operations)
-    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_movrs: "amx-movrs";
-    /// AMX-MOVRS (Matrix MOVERS operations)
-    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_tf32: "amx-tf32";
-    /// AMX-TF32 (TensorFloat32 Operations)
-    @FEATURE: #[unstable(feature = "x86_amx_intrinsics", issue = "126622")] amx_transpose: "amx-transpose";
-    /// AMX-TRANSPOSE (Matrix Transpose Operations)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] f16c: "f16c";
-    /// F16C (Conversions between IEEE-754 `binary16` and `binary32` formats)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] fma: "fma";
-    /// FMA (Fused Multiply Add)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] bmi1: "bmi1" ;
-    /// BMI1 (Bit Manipulation Instructions 1)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] bmi2: "bmi2" ;
-    /// BMI2 (Bit Manipulation Instructions 2)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] lzcnt: "lzcnt";
-    /// ABM (Advanced Bit Manipulation) / LZCNT (Leading Zero Count)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] tbm: "tbm";
-    /// TBM (Trailing Bit Manipulation)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] popcnt: "popcnt";
-    /// POPCNT (Population Count)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] fxsr: "fxsr";
-    /// FXSR (Floating-point context fast save and restore)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] xsave: "xsave";
-    /// XSAVE (Save Processor Extended States)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] xsaveopt: "xsaveopt";
-    /// XSAVEOPT (Save Processor Extended States Optimized)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] xsaves: "xsaves";
-    /// XSAVES (Save Processor Extended States Supervisor)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] xsavec: "xsavec";
-    /// XSAVEC (Save Processor Extended States Compacted)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] cmpxchg16b: "cmpxchg16b";
-    /// CMPXCH16B (16-byte compare-and-swap instruction)
-    @FEATURE: #[stable(feature = "keylocker_x86", since = "1.89.0")] kl: "kl";
-    /// Intel Key Locker
-    @FEATURE: #[stable(feature = "keylocker_x86", since = "1.89.0")] widekl: "widekl";
-    /// Intel Key Locker Wide
-    @FEATURE: #[stable(feature = "simd_x86_adx", since = "1.33.0")] adx: "adx";
-    /// ADX, Intel ADX (Multi-Precision Add-Carry Instruction Extensions)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] rtm: "rtm";
-    /// RTM, Intel (Restricted Transactional Memory)
-    @FEATURE: #[stable(feature = "movbe_target_feature", since = "1.67.0")] movbe: "movbe";
-    /// MOVBE (Move Data After Swapping Bytes)
-    @FEATURE: #[unstable(feature = "movrs_target_feature", issue = "137976")] movrs: "movrs";
-    /// MOVRS (Move data with the read-shared hint)
-    @FEATURE: #[stable(feature = "simd_x86", since = "1.27.0")] ermsb: "ermsb";
-    /// ERMSB, Enhanced REP MOVSB and STOSB
-    @FEATURE: #[unstable(feature = "xop_target_feature", issue = "127208")] xop: "xop";
-    /// XOP: eXtended Operations (AMD)
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/bit.rs b/library/stdarch/crates/std_detect/src/detect/bit.rs
deleted file mode 100644
index 6f06c5523e4..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/bit.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//! Bit manipulation utilities.
-
-/// Tests the `bit` of `x`.
-#[allow(dead_code)]
-#[inline]
-pub(crate) fn test(x: usize, bit: u32) -> bool {
-    debug_assert!(bit < usize::BITS, "bit index out-of-bounds");
-    x & (1 << bit) != 0
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/cache.rs b/library/stdarch/crates/std_detect/src/detect/cache.rs
deleted file mode 100644
index 83bcedea612..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/cache.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-//! Caches run-time feature detection so that it only needs to be computed
-//! once.
-
-#![allow(dead_code)] // not used on all platforms
-
-use core::sync::atomic::Ordering;
-
-use core::sync::atomic::AtomicUsize;
-
-/// Sets the `bit` of `x`.
-#[inline]
-const fn set_bit(x: u128, bit: u32) -> u128 {
-    x | 1 << bit
-}
-
-/// Tests the `bit` of `x`.
-#[inline]
-const fn test_bit(x: u128, bit: u32) -> bool {
-    x & (1 << bit) != 0
-}
-
-/// Unset the `bit of `x`.
-#[inline]
-const fn unset_bit(x: u128, bit: u32) -> u128 {
-    x & !(1 << bit)
-}
-
-/// Maximum number of features that can be cached.
-const CACHE_CAPACITY: u32 = 93;
-
-/// This type is used to initialize the cache
-// The derived `Default` implementation will initialize the field to zero,
-// which is what we want.
-#[derive(Copy, Clone, Default, PartialEq, Eq)]
-pub(crate) struct Initializer(u128);
-
-// NOTE: the `debug_assert!` would catch that we do not add more Features than
-// the one fitting our cache.
-impl Initializer {
-    /// Tests the `bit` of the cache.
-    #[inline]
-    pub(crate) fn test(self, bit: u32) -> bool {
-        debug_assert!(
-            bit < CACHE_CAPACITY,
-            "too many features, time to increase the cache size!"
-        );
-        test_bit(self.0, bit)
-    }
-
-    /// Sets the `bit` of the cache.
-    #[inline]
-    pub(crate) fn set(&mut self, bit: u32) {
-        debug_assert!(
-            bit < CACHE_CAPACITY,
-            "too many features, time to increase the cache size!"
-        );
-        let v = self.0;
-        self.0 = set_bit(v, bit);
-    }
-
-    /// Unsets the `bit` of the cache.
-    #[inline]
-    pub(crate) fn unset(&mut self, bit: u32) {
-        debug_assert!(
-            bit < CACHE_CAPACITY,
-            "too many features, time to increase the cache size!"
-        );
-        let v = self.0;
-        self.0 = unset_bit(v, bit);
-    }
-}
-
-/// This global variable is a cache of the features supported by the CPU.
-// Note: the third slot is only used in x86
-// Another Slot can be added if needed without any change to `Initializer`
-static CACHE: [Cache; 3] = [
-    Cache::uninitialized(),
-    Cache::uninitialized(),
-    Cache::uninitialized(),
-];
-
-/// Feature cache with capacity for `size_of::<usize>() * 8 - 1` features.
-///
-/// Note: 0 is used to represent an uninitialized cache, and (at least) the most
-/// significant bit is set on any cache which has been initialized.
-///
-/// Note: we use `Relaxed` atomic operations, because we are only interested in
-/// the effects of operations on a single memory location. That is, we only need
-/// "modification order", and not the full-blown "happens before".
-struct Cache(AtomicUsize);
-
-impl Cache {
-    const CAPACITY: u32 = (core::mem::size_of::<usize>() * 8 - 1) as u32;
-    const MASK: usize = (1 << Cache::CAPACITY) - 1;
-    const INITIALIZED_BIT: usize = 1usize << Cache::CAPACITY;
-
-    /// Creates an uninitialized cache.
-    #[allow(clippy::declare_interior_mutable_const)]
-    const fn uninitialized() -> Self {
-        Cache(AtomicUsize::new(0))
-    }
-
-    /// Is the `bit` in the cache set? Returns `None` if the cache has not been initialized.
-    #[inline]
-    pub(crate) fn test(&self, bit: u32) -> Option<bool> {
-        let cached = self.0.load(Ordering::Relaxed);
-        if cached == 0 {
-            None
-        } else {
-            Some(test_bit(cached as u128, bit))
-        }
-    }
-
-    /// Initializes the cache.
-    #[inline]
-    fn initialize(&self, value: usize) -> usize {
-        debug_assert_eq!((value & !Cache::MASK), 0);
-        self.0
-            .store(value | Cache::INITIALIZED_BIT, Ordering::Relaxed);
-        value
-    }
-}
-
-cfg_if::cfg_if! {
-    if #[cfg(feature = "std_detect_env_override")] {
-        #[inline]
-        fn disable_features(disable: &[u8], value: &mut Initializer) {
-            if let Ok(disable) = core::str::from_utf8(disable) {
-                for v in disable.split(" ") {
-                    let _ = super::Feature::from_str(v).map(|v| value.unset(v as u32));
-                }
-            }
-        }
-
-        #[inline]
-        fn initialize(mut value: Initializer) -> Initializer {
-            use core::ffi::CStr;
-            const RUST_STD_DETECT_UNSTABLE: &CStr = c"RUST_STD_DETECT_UNSTABLE";
-            cfg_if::cfg_if! {
-                if #[cfg(windows)] {
-                    use alloc::vec;
-                    #[link(name = "kernel32")]
-                    unsafe extern "system" {
-                        fn GetEnvironmentVariableA(name: *const u8, buffer: *mut u8, size: u32) -> u32;
-                    }
-                    let len = unsafe { GetEnvironmentVariableA(RUST_STD_DETECT_UNSTABLE.as_ptr().cast::<u8>(), core::ptr::null_mut(), 0) };
-                    if len > 0 {
-                        // +1 to include the null terminator.
-                        let mut env = vec![0; len as usize + 1];
-                        let len = unsafe { GetEnvironmentVariableA(RUST_STD_DETECT_UNSTABLE.as_ptr().cast::<u8>(), env.as_mut_ptr(), len + 1) };
-                        if len > 0 {
-                            disable_features(&env[..len as usize], &mut value);
-                        }
-                    }
-                } else {
-                    let env = unsafe {
-                        libc::getenv(RUST_STD_DETECT_UNSTABLE.as_ptr())
-                    };
-                    if !env.is_null() {
-                        let len = unsafe { libc::strlen(env) };
-                        let env = unsafe { core::slice::from_raw_parts(env as *const u8, len) };
-                        disable_features(env, &mut value);
-                    }
-                }
-            }
-            do_initialize(value);
-            value
-        }
-    } else {
-        #[inline]
-        fn initialize(value: Initializer) -> Initializer {
-            do_initialize(value);
-            value
-        }
-    }
-}
-
-#[inline]
-fn do_initialize(value: Initializer) {
-    CACHE[0].initialize((value.0) as usize & Cache::MASK);
-    CACHE[1].initialize((value.0 >> Cache::CAPACITY) as usize & Cache::MASK);
-    CACHE[2].initialize((value.0 >> (2 * Cache::CAPACITY)) as usize & Cache::MASK);
-}
-
-// We only have to detect features once, and it's fairly costly, so hint to LLVM
-// that it should assume that cache hits are more common than misses (which is
-// the point of caching). It's possibly unfortunate that this function needs to
-// reach across modules like this to call `os::detect_features`, but it produces
-// the best code out of several attempted variants.
-//
-// The `Initializer` that the cache was initialized with is returned, so that
-// the caller can call `test()` on it without having to load the value from the
-// cache again.
-#[cold]
-fn detect_and_initialize() -> Initializer {
-    initialize(super::os::detect_features())
-}
-
-/// Tests the `bit` of the storage. If the storage has not been initialized,
-/// initializes it with the result of `os::detect_features()`.
-///
-/// On its first invocation, it detects the CPU features and caches them in the
-/// `CACHE` global variable as an `AtomicU64`.
-///
-/// It uses the `Feature` variant to index into this variable as a bitset. If
-/// the bit is set, the feature is enabled, and otherwise it is disabled.
-///
-/// If the feature `std_detect_env_override` is enabled looks for the env
-/// variable `RUST_STD_DETECT_UNSTABLE` and uses its content to disable
-/// Features that would had been otherwise detected.
-#[inline]
-pub(crate) fn test(bit: u32) -> bool {
-    let (relative_bit, idx) = if bit < Cache::CAPACITY {
-        (bit, 0)
-    } else if bit < 2 * Cache::CAPACITY {
-        (bit - Cache::CAPACITY, 1)
-    } else {
-        (bit - 2 * Cache::CAPACITY, 2)
-    };
-    CACHE[idx]
-        .test(relative_bit)
-        .unwrap_or_else(|| detect_and_initialize().test(bit))
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/macros.rs b/library/stdarch/crates/std_detect/src/detect/macros.rs
deleted file mode 100644
index a2994fb7daa..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/macros.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-#[macro_export]
-#[allow_internal_unstable(stdarch_internal)]
-#[unstable(feature = "stdarch_internal", issue = "none")]
-macro_rules! detect_feature {
-    ($feature:tt, $feature_lit:tt) => {
-        $crate::detect_feature!($feature, $feature_lit : $feature_lit)
-    };
-    ($feature:tt, $feature_lit:tt : $($target_feature_lit:tt),*) => {
-        $(cfg!(target_feature = $target_feature_lit) ||)*
-            $crate::detect::__is_feature_detected::$feature()
-    };
-    ($feature:tt, $feature_lit:tt, without cfg check: true) => {
-        $crate::detect::__is_feature_detected::$feature()
-    };
-}
-
-#[allow(unused_macros, reason = "it's used in the features! macro below")]
-macro_rules! check_cfg_feature {
-    ($feature:tt, $feature_lit:tt) => {
-        check_cfg_feature!($feature, $feature_lit : $feature_lit)
-    };
-    ($feature:tt, $feature_lit:tt : $($target_feature_lit:tt),*) => {
-        $(cfg!(target_feature = $target_feature_lit);)*
-    };
-    ($feature:tt, $feature_lit:tt, without cfg check: $feature_cfg_check:literal) => {
-        #[allow(unexpected_cfgs, reason = $feature_lit)]
-        { cfg!(target_feature = $feature_lit) }
-    };
-}
-
-#[allow(unused)]
-macro_rules! features {
-    (
-      @TARGET: $target:ident;
-      @CFG: $cfg:meta;
-      @MACRO_NAME: $macro_name:ident;
-      @MACRO_ATTRS: $(#[$macro_attrs:meta])*
-      $(@BIND_FEATURE_NAME: $bind_feature:tt; $feature_impl:tt; $(#[$deprecate_attr:meta];)?)*
-      $(@NO_RUNTIME_DETECTION: $nort_feature:tt; )*
-      $(@FEATURE: #[$stability_attr:meta] $feature:ident: $feature_lit:tt;
-          $(without cfg check: $feature_cfg_check:tt;)?
-          $(implied by target_features: [$($target_feature_lit:tt),*];)?
-          $(#[$feature_comment:meta])*)*
-    ) => {
-        #[macro_export]
-        $(#[$macro_attrs])*
-        #[allow_internal_unstable(stdarch_internal)]
-        #[cfg($cfg)]
-        #[doc(cfg($cfg))]
-        macro_rules! $macro_name {
-            $(
-                ($feature_lit) => {
-                    $crate::detect_feature!($feature, $feature_lit $(, without cfg check: $feature_cfg_check)? $(: $($target_feature_lit),*)?)
-                };
-            )*
-            $(
-                ($bind_feature) => {
-                    {
-                        $(
-                            #[$deprecate_attr] macro_rules! deprecated_feature { {} => {}; }
-                            deprecated_feature! {};
-                        )?
-                        $crate::$macro_name!($feature_impl)
-                    }
-                };
-            )*
-            $(
-                ($nort_feature) => {
-                    compile_error!(
-                        concat!(
-                            stringify!($nort_feature),
-                            " feature cannot be detected at run-time"
-                        )
-                    )
-                };
-            )*
-            ($t:tt,) => {
-                    $crate::$macro_name!($t);
-            };
-            ($t:tt) => {
-                compile_error!(
-                    concat!(
-                        concat!("unknown ", stringify!($target)),
-                        concat!(" target feature: ", $t)
-                    )
-                )
-            };
-        }
-
-        $(#[$macro_attrs])*
-        #[macro_export]
-        #[cfg(not($cfg))]
-        #[doc(cfg($cfg))]
-        macro_rules! $macro_name {
-            $(
-                ($feature_lit) => {
-                    compile_error!(
-                        concat!(
-                            r#"This macro cannot be used on the current target.
-                            You can prevent it from being used in other architectures by
-                            guarding it behind a cfg("#,
-                            stringify!($cfg),
-                            ")."
-                        )
-                    )
-                };
-            )*
-            $(
-                ($bind_feature) => { $crate::$macro_name!($feature_impl) };
-            )*
-            $(
-                ($nort_feature) => {
-                    compile_error!(
-                        concat!(
-                            stringify!($nort_feature),
-                            " feature cannot be detected at run-time"
-                        )
-                    )
-                };
-            )*
-            ($t:tt,) => {
-                    $crate::$macro_name!($t);
-            };
-            ($t:tt) => {
-                compile_error!(
-                    concat!(
-                        concat!("unknown ", stringify!($target)),
-                        concat!(" target feature: ", $t)
-                    )
-                )
-            };
-        }
-
-        #[test]
-        #[deny(unexpected_cfgs)]
-        #[deny(unfulfilled_lint_expectations)]
-        fn unexpected_cfgs() {
-            $(
-                check_cfg_feature!($feature, $feature_lit $(, without cfg check: $feature_cfg_check)? $(: $($target_feature_lit),*)?);
-            )*
-        }
-
-        /// Each variant denotes a position in a bitset for a particular feature.
-        ///
-        /// PLEASE: do not use this, it is an implementation detail subject
-        /// to change.
-        #[doc(hidden)]
-        #[allow(non_camel_case_types)]
-        #[derive(Copy, Clone)]
-        #[repr(u8)]
-        #[unstable(feature = "stdarch_internal", issue = "none")]
-        #[cfg($cfg)]
-        pub(crate) enum Feature {
-            $(
-                $(#[$feature_comment])*
-                $feature,
-            )*
-
-            // Do not add variants after last:
-            _last
-        }
-
-        #[cfg($cfg)]
-        impl Feature {
-            pub(crate) fn to_str(self) -> &'static str {
-                match self {
-                    $(Feature::$feature => $feature_lit,)*
-                    Feature::_last => unreachable!(),
-                }
-            }
-
-            #[cfg(feature = "std_detect_env_override")]
-            pub(crate) fn from_str(s: &str) -> Result<Feature, ()> {
-                match s {
-                    $($feature_lit => Ok(Feature::$feature),)*
-                    _ => Err(())
-                }
-            }
-        }
-
-        /// Each function performs run-time feature detection for a single
-        /// feature. This allow us to use stability attributes on a per feature
-        /// basis.
-        ///
-        /// PLEASE: do not use this, it is an implementation detail subject
-        /// to change.
-        #[doc(hidden)]
-        #[cfg($cfg)]
-        #[unstable(feature = "stdarch_internal", issue = "none")]
-        pub mod __is_feature_detected {
-            $(
-
-                /// PLEASE: do not use this, it is an implementation detail
-                /// subject to change.
-                #[inline]
-                #[doc(hidden)]
-                #[$stability_attr]
-                pub fn $feature() -> bool {
-                    $crate::detect::check_for($crate::detect::Feature::$feature)
-                }
-            )*
-        }
-    };
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/mod.rs b/library/stdarch/crates/std_detect/src/detect/mod.rs
deleted file mode 100644
index a9e9709c1f6..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/mod.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-//! This module implements run-time feature detection.
-//!
-//! The `is_{arch}_feature_detected!("feature-name")` macros take the name of a
-//! feature as a string-literal, and return a boolean indicating whether the
-//! feature is enabled at run-time or not.
-//!
-//! These macros do two things:
-//! * map the string-literal into an integer stored as a `Feature` enum,
-//! * call a `os::check_for(x: Feature)` function that returns `true` if the
-//! feature is enabled.
-//!
-//! The `Feature` enums are also implemented in the `arch/{target_arch}.rs`
-//! modules.
-//!
-//! The `check_for` functions are, in general, Operating System dependent. Most
-//! architectures do not allow user-space programs to query the feature bits
-//! due to security concerns (x86 is the big exception). These functions are
-//! implemented in the `os/{target_os}.rs` modules.
-
-use cfg_if::cfg_if;
-
-#[macro_use]
-mod macros;
-
-mod arch;
-
-// This module needs to be public because the `is_{arch}_feature_detected!`
-// macros expand calls to items within it in user crates.
-#[doc(hidden)]
-#[unstable(feature = "stdarch_internal", issue = "none")]
-pub use self::arch::__is_feature_detected;
-
-pub(crate) use self::arch::Feature;
-
-mod bit;
-mod cache;
-
-cfg_if! {
-    if #[cfg(miri)] {
-        // When running under miri all target-features that are not enabled at
-        // compile-time are reported as disabled at run-time.
-        //
-        // For features for which `cfg(target_feature)` returns true,
-        // this run-time detection logic is never called.
-        #[path = "os/other.rs"]
-        mod os;
-    } else if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
-        // On x86/x86_64 no OS specific functionality is required.
-        #[path = "os/x86.rs"]
-        mod os;
-    } else if #[cfg(all(any(target_os = "linux", target_os = "android"), feature = "libc"))] {
-        #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
-        #[path = "os/riscv.rs"]
-        mod riscv;
-        #[path = "os/linux/mod.rs"]
-        mod os;
-    } else if #[cfg(all(target_os = "freebsd", feature = "libc"))] {
-        #[cfg(target_arch = "aarch64")]
-        #[path = "os/aarch64.rs"]
-        mod aarch64;
-        #[path = "os/freebsd/mod.rs"]
-        mod os;
-    } else if #[cfg(all(target_os = "openbsd", target_arch = "aarch64", feature = "libc"))] {
-        #[allow(dead_code)] // we don't use code that calls the mrs instruction.
-        #[path = "os/aarch64.rs"]
-        mod aarch64;
-        #[path = "os/openbsd/aarch64.rs"]
-        mod os;
-    } else if #[cfg(all(target_os = "windows", any(target_arch = "aarch64", target_arch = "arm64ec")))] {
-        #[path = "os/windows/aarch64.rs"]
-        mod os;
-    } else if #[cfg(all(target_vendor = "apple", target_arch = "aarch64", feature = "libc"))] {
-        #[path = "os/darwin/aarch64.rs"]
-        mod os;
-    } else {
-        #[path = "os/other.rs"]
-        mod os;
-    }
-}
-
-/// Performs run-time feature detection.
-#[inline]
-#[allow(dead_code)]
-fn check_for(x: Feature) -> bool {
-    cache::test(x as u32)
-}
-
-/// Returns an `Iterator<Item=(&'static str, bool)>` where
-/// `Item.0` is the feature name, and `Item.1` is a `bool` which
-/// is `true` if the feature is supported by the host and `false` otherwise.
-#[unstable(feature = "stdarch_internal", issue = "none")]
-pub fn features() -> impl Iterator<Item = (&'static str, bool)> {
-    cfg_if! {
-        if #[cfg(any(
-            target_arch = "x86",
-            target_arch = "x86_64",
-            target_arch = "arm",
-            target_arch = "aarch64",
-            target_arch = "arm64ec",
-            target_arch = "riscv32",
-            target_arch = "riscv64",
-            target_arch = "powerpc",
-            target_arch = "powerpc64",
-            target_arch = "mips",
-            target_arch = "mips64",
-            target_arch = "loongarch32",
-            target_arch = "loongarch64",
-            target_arch = "s390x",
-        ))] {
-            (0_u8..Feature::_last as u8).map(|discriminant: u8| {
-                #[allow(bindings_with_variant_name)] // RISC-V has Feature::f
-                let f: Feature = unsafe { core::mem::transmute(discriminant) };
-                let name: &'static str = f.to_str();
-                let enabled: bool = check_for(f);
-                (name, enabled)
-            })
-        } else {
-            None.into_iter()
-        }
-    }
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/aarch64.rs b/library/stdarch/crates/std_detect/src/detect/os/aarch64.rs
deleted file mode 100644
index 1ff2a17e6e1..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/aarch64.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-//! Run-time feature detection for Aarch64 on any OS that emulates the mrs instruction.
-//!
-//! On FreeBSD >= 12.0, Linux >= 4.11 and other operating systems, it is possible to use
-//! privileged system registers from userspace to check CPU feature support.
-//!
-//! AArch64 system registers ID_AA64ISAR0_EL1, ID_AA64PFR0_EL1, ID_AA64ISAR1_EL1
-//! have bits dedicated to features like AdvSIMD, CRC32, AES, atomics (LSE), etc.
-//! Each part of the register indicates the level of support for a certain feature, e.g.
-//! when ID_AA64ISAR0_EL1\[7:4\] is >= 1, AES is supported; when it's >= 2, PMULL is supported.
-//!
-//! For proper support of [SoCs where different cores have different capabilities](https://medium.com/@jadr2ddude/a-big-little-problem-a-tale-of-big-little-gone-wrong-e7778ce744bb),
-//! the OS has to always report only the features supported by all cores, like [FreeBSD does](https://reviews.freebsd.org/D17137#393947).
-//!
-//! References:
-//!
-//! - [Zircon implementation](https://fuchsia.googlesource.com/zircon/+/master/kernel/arch/arm64/feature.cpp)
-//! - [Linux documentation](https://www.kernel.org/doc/Documentation/arm64/cpu-feature-registers.txt)
-//! - [ARM documentation](https://developer.arm.com/documentation/ddi0601/2022-12/AArch64-Registers?lang=en)
-
-use crate::detect::{Feature, cache};
-use core::arch::asm;
-
-/// Try to read the features from the system registers.
-///
-/// This will cause SIGILL if the current OS is not trapping the mrs instruction.
-pub(crate) fn detect_features() -> cache::Initializer {
-    // ID_AA64ISAR0_EL1 - Instruction Set Attribute Register 0
-    let aa64isar0: u64;
-    unsafe {
-        asm!(
-            "mrs {}, ID_AA64ISAR0_EL1",
-            out(reg) aa64isar0,
-            options(pure, nomem, preserves_flags, nostack)
-        );
-    }
-
-    // ID_AA64ISAR1_EL1 - Instruction Set Attribute Register 1
-    let aa64isar1: u64;
-    unsafe {
-        asm!(
-            "mrs {}, ID_AA64ISAR1_EL1",
-            out(reg) aa64isar1,
-            options(pure, nomem, preserves_flags, nostack)
-        );
-    }
-
-    // ID_AA64MMFR2_EL1 - AArch64 Memory Model Feature Register 2
-    let aa64mmfr2: u64;
-    unsafe {
-        asm!(
-            "mrs {}, ID_AA64MMFR2_EL1",
-            out(reg) aa64mmfr2,
-            options(pure, nomem, preserves_flags, nostack)
-        );
-    }
-
-    // ID_AA64PFR0_EL1 - Processor Feature Register 0
-    let aa64pfr0: u64;
-    unsafe {
-        asm!(
-            "mrs {}, ID_AA64PFR0_EL1",
-            out(reg) aa64pfr0,
-            options(pure, nomem, preserves_flags, nostack)
-        );
-    }
-
-    parse_system_registers(aa64isar0, aa64isar1, aa64mmfr2, Some(aa64pfr0))
-}
-
-pub(crate) fn parse_system_registers(
-    aa64isar0: u64,
-    aa64isar1: u64,
-    aa64mmfr2: u64,
-    aa64pfr0: Option<u64>,
-) -> cache::Initializer {
-    let mut value = cache::Initializer::default();
-
-    let mut enable_feature = |f, enable| {
-        if enable {
-            value.set(f as u32);
-        }
-    };
-
-    // ID_AA64ISAR0_EL1 - Instruction Set Attribute Register 0
-    enable_feature(Feature::pmull, bits_shift(aa64isar0, 7, 4) >= 2);
-    enable_feature(Feature::tme, bits_shift(aa64isar0, 27, 24) == 1);
-    enable_feature(Feature::lse, bits_shift(aa64isar0, 23, 20) >= 2);
-    enable_feature(Feature::crc, bits_shift(aa64isar0, 19, 16) >= 1);
-
-    // ID_AA64PFR0_EL1 - Processor Feature Register 0
-    if let Some(aa64pfr0) = aa64pfr0 {
-        let fp = bits_shift(aa64pfr0, 19, 16) < 0xF;
-        let fphp = bits_shift(aa64pfr0, 19, 16) >= 1;
-        let asimd = bits_shift(aa64pfr0, 23, 20) < 0xF;
-        let asimdhp = bits_shift(aa64pfr0, 23, 20) >= 1;
-        enable_feature(Feature::fp, fp);
-        enable_feature(Feature::fp16, fphp);
-        // SIMD support requires float support - if half-floats are
-        // supported, it also requires half-float support:
-        enable_feature(Feature::asimd, fp && asimd && (!fphp | asimdhp));
-        // SIMD extensions require SIMD support:
-        enable_feature(Feature::aes, asimd && bits_shift(aa64isar0, 7, 4) >= 2);
-        let sha1 = bits_shift(aa64isar0, 11, 8) >= 1;
-        let sha2 = bits_shift(aa64isar0, 15, 12) >= 1;
-        enable_feature(Feature::sha2, asimd && sha1 && sha2);
-        enable_feature(Feature::rdm, asimd && bits_shift(aa64isar0, 31, 28) >= 1);
-        enable_feature(
-            Feature::dotprod,
-            asimd && bits_shift(aa64isar0, 47, 44) >= 1,
-        );
-        enable_feature(Feature::sve, asimd && bits_shift(aa64pfr0, 35, 32) >= 1);
-    }
-
-    // ID_AA64ISAR1_EL1 - Instruction Set Attribute Register 1
-    // Check for either APA or API field
-    enable_feature(Feature::paca, bits_shift(aa64isar1, 11, 4) >= 1);
-    enable_feature(Feature::rcpc, bits_shift(aa64isar1, 23, 20) >= 1);
-    // Check for either GPA or GPI field
-    enable_feature(Feature::pacg, bits_shift(aa64isar1, 31, 24) >= 1);
-
-    // ID_AA64MMFR2_EL1 - AArch64 Memory Model Feature Register 2
-    enable_feature(Feature::lse2, bits_shift(aa64mmfr2, 35, 32) >= 1);
-
-    value
-}
-
-#[inline]
-fn bits_shift(x: u64, high: usize, low: usize) -> u64 {
-    (x >> low) & ((1 << (high - low + 1)) - 1)
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/darwin/aarch64.rs b/library/stdarch/crates/std_detect/src/detect/os/darwin/aarch64.rs
deleted file mode 100644
index 44d921689e5..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/darwin/aarch64.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-//! Run-time feature detection for aarch64 on Darwin (macOS/iOS/tvOS/watchOS/visionOS).
-//!
-//! <https://developer.apple.com/documentation/kernel/1387446-sysctlbyname/determining_instruction_set_characteristics>
-
-use crate::detect::{Feature, cache};
-use core::ffi::CStr;
-
-#[inline]
-fn _sysctlbyname(name: &CStr) -> bool {
-    use libc;
-
-    let mut enabled: i32 = 0;
-    let mut enabled_len: usize = 4;
-    let enabled_ptr = &mut enabled as *mut i32 as *mut libc::c_void;
-
-    let ret = unsafe {
-        libc::sysctlbyname(
-            name.as_ptr(),
-            enabled_ptr,
-            &mut enabled_len,
-            core::ptr::null_mut(),
-            0,
-        )
-    };
-
-    match ret {
-        0 => enabled != 0,
-        _ => false,
-    }
-}
-
-/// Try to read the features using sysctlbyname.
-pub(crate) fn detect_features() -> cache::Initializer {
-    let mut value = cache::Initializer::default();
-
-    let mut enable_feature = |f, enable| {
-        if enable {
-            value.set(f as u32);
-        }
-    };
-
-    // Armv8.0 features not using the standard identifiers
-    let fp = _sysctlbyname(c"hw.optional.floatingpoint");
-    let asimd = _sysctlbyname(c"hw.optional.AdvSIMD");
-    let crc = _sysctlbyname(c"hw.optional.armv8_crc32");
-
-    // Armv8 and Armv9 features using the standard identifiers
-    let aes = _sysctlbyname(c"hw.optional.arm.FEAT_AES");
-    let bf16 = _sysctlbyname(c"hw.optional.arm.FEAT_BF16");
-    let bti = _sysctlbyname(c"hw.optional.arm.FEAT_BTI");
-    let cssc = _sysctlbyname(c"hw.optional.arm.FEAT_CSSC");
-    let dit = _sysctlbyname(c"hw.optional.arm.FEAT_DIT");
-    let dpb = _sysctlbyname(c"hw.optional.arm.FEAT_DPB");
-    let dpb2 = _sysctlbyname(c"hw.optional.arm.FEAT_DPB2");
-    let dotprod = _sysctlbyname(c"hw.optional.arm.FEAT_DotProd");
-    let ecv = _sysctlbyname(c"hw.optional.arm.FEAT_ECV");
-    let fcma = _sysctlbyname(c"hw.optional.arm.FEAT_FCMA");
-    let fhm = _sysctlbyname(c"hw.optional.arm.FEAT_FHM");
-    let fp16 = _sysctlbyname(c"hw.optional.arm.FEAT_FP16");
-    let frintts = _sysctlbyname(c"hw.optional.arm.FEAT_FRINTTS");
-    let flagm = _sysctlbyname(c"hw.optional.arm.FEAT_FlagM");
-    let flagm2 = _sysctlbyname(c"hw.optional.arm.FEAT_FlagM2");
-    let hbc = _sysctlbyname(c"hw.optional.arm.FEAT_HBC");
-    let i8mm = _sysctlbyname(c"hw.optional.arm.FEAT_I8MM");
-    let jsconv = _sysctlbyname(c"hw.optional.arm.FEAT_JSCVT");
-    let rcpc = _sysctlbyname(c"hw.optional.arm.FEAT_LRCPC");
-    let rcpc2 = _sysctlbyname(c"hw.optional.arm.FEAT_LRCPC2");
-    let lse = _sysctlbyname(c"hw.optional.arm.FEAT_LSE");
-    let lse2 = _sysctlbyname(c"hw.optional.arm.FEAT_LSE2");
-    let pauth = _sysctlbyname(c"hw.optional.arm.FEAT_PAuth");
-    let pmull = _sysctlbyname(c"hw.optional.arm.FEAT_PMULL");
-    let rdm = _sysctlbyname(c"hw.optional.arm.FEAT_RDM");
-    let sb = _sysctlbyname(c"hw.optional.arm.FEAT_SB");
-    let sha1 = _sysctlbyname(c"hw.optional.arm.FEAT_SHA1");
-    let sha256 = _sysctlbyname(c"hw.optional.arm.FEAT_SHA256");
-    let sha3 = _sysctlbyname(c"hw.optional.arm.FEAT_SHA3");
-    let sha512 = _sysctlbyname(c"hw.optional.arm.FEAT_SHA512");
-    let sme = _sysctlbyname(c"hw.optional.arm.FEAT_SME");
-    let sme2 = _sysctlbyname(c"hw.optional.arm.FEAT_SME2");
-    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 wfxt = _sysctlbyname(c"hw.optional.arm.FEAT_WFxT");
-
-    // The following features are not exposed by `is_aarch64_feature_detected`,
-    // but *are* reported by `sysctl`. They are here as documentation that they
-    // exist, and may potentially be exposed later.
-    /*
-    let afp = _sysctlbyname(c"hw.optional.arm.FEAT_AFP");
-    let csv2 = _sysctlbyname(c"hw.optional.arm.FEAT_CSV2");
-    let csv3 = _sysctlbyname(c"hw.optional.arm.FEAT_CSV3");
-    let ebf16 = _sysctlbyname(c"hw.optional.arm.FEAT_EBF16");
-    let fpac = _sysctlbyname(c"hw.optional.arm.FEAT_FPAC");
-    let fpaccombine = _sysctlbyname(c"hw.optional.arm.FEAT_FPACCOMBINE");
-    let pacimp = _sysctlbyname(c"hw.optional.arm.FEAT_PACIMP");
-    let pauth2 = _sysctlbyname(c"hw.optional.arm.FEAT_PAuth2");
-    let rpres = _sysctlbyname(c"hw.optional.arm.FEAT_RPRES");
-    let specres = _sysctlbyname(c"hw.optional.arm.FEAT_SPECRES");
-    let specres2 = _sysctlbyname(c"hw.optional.arm.FEAT_SPECRES2");
-     */
-
-    // The following "features" are reported by `sysctl` but are mandatory parts
-    // of SME or SME2, and so are not exposed separately by
-    // `is_aarch64_feature_detected`.  They are here to document their
-    // existence, in case they're needed in the future.
-    /*
-    let sme_b16f32 = _sysctlbyname(c"hw.optional.arm.SME_B16F32");
-    let sme_bi32i32 = _sysctlbyname(c"hw.optional.arm.SME_BI32I32");
-    let sme_f16f32 = _sysctlbyname(c"hw.optional.arm.SME_F16F32");
-    let sme_f32f32 = _sysctlbyname(c"hw.optional.arm.SME_F32F32");
-    let sme_i16i32 = _sysctlbyname(c"hw.optional.arm.SME_I16I32");
-    let sme_i8i32 = _sysctlbyname(c"hw.optional.arm.SME_I8I32");
-     */
-
-    enable_feature(Feature::aes, aes && pmull);
-    enable_feature(Feature::asimd, asimd);
-    enable_feature(Feature::bf16, bf16);
-    enable_feature(Feature::bti, bti);
-    enable_feature(Feature::crc, crc);
-    enable_feature(Feature::cssc, cssc);
-    enable_feature(Feature::dit, dit);
-    enable_feature(Feature::dotprod, dotprod);
-    enable_feature(Feature::dpb, dpb);
-    enable_feature(Feature::dpb2, dpb2);
-    enable_feature(Feature::ecv, ecv);
-    enable_feature(Feature::fcma, fcma);
-    enable_feature(Feature::fhm, fhm);
-    enable_feature(Feature::flagm, flagm);
-    enable_feature(Feature::flagm2, flagm2);
-    enable_feature(Feature::fp, fp);
-    enable_feature(Feature::fp16, fp16);
-    enable_feature(Feature::frintts, frintts);
-    enable_feature(Feature::hbc, hbc);
-    enable_feature(Feature::i8mm, i8mm);
-    enable_feature(Feature::jsconv, jsconv);
-    enable_feature(Feature::lse, lse);
-    enable_feature(Feature::lse2, lse2);
-    enable_feature(Feature::paca, pauth);
-    enable_feature(Feature::pacg, pauth);
-    enable_feature(Feature::pmull, aes && pmull);
-    enable_feature(Feature::rcpc, rcpc);
-    enable_feature(Feature::rcpc2, rcpc2);
-    enable_feature(Feature::rdm, rdm);
-    enable_feature(Feature::sb, sb);
-    enable_feature(Feature::sha2, sha1 && sha256 && asimd);
-    enable_feature(Feature::sha3, sha512 && sha3 && asimd);
-    enable_feature(Feature::sme, sme);
-    enable_feature(Feature::sme2, sme2);
-    enable_feature(Feature::sme_f64f64, sme_f64f64);
-    enable_feature(Feature::sme_i16i64, sme_i16i64);
-    enable_feature(Feature::ssbs, ssbs);
-    enable_feature(Feature::wfxt, wfxt);
-
-    value
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/freebsd/aarch64.rs b/library/stdarch/crates/std_detect/src/detect/os/freebsd/aarch64.rs
deleted file mode 100644
index ccc48f53605..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/freebsd/aarch64.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Run-time feature detection for Aarch64 on FreeBSD.
-
-pub(crate) use super::super::aarch64::detect_features;
diff --git a/library/stdarch/crates/std_detect/src/detect/os/freebsd/arm.rs b/library/stdarch/crates/std_detect/src/detect/os/freebsd/arm.rs
deleted file mode 100644
index 0a15156e1bd..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/freebsd/arm.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//! Run-time feature detection for ARM on FreeBSD
-
-use super::auxvec;
-use crate::detect::{Feature, cache};
-
-// Defined in machine/elf.h.
-// https://github.com/freebsd/freebsd-src/blob/deb63adf945d446ed91a9d84124c71f15ae571d1/sys/arm/include/elf.h
-const HWCAP_NEON: usize = 0x00001000;
-const HWCAP2_AES: usize = 0x00000001;
-const HWCAP2_PMULL: usize = 0x00000002;
-const HWCAP2_SHA1: usize = 0x00000004;
-const HWCAP2_SHA2: usize = 0x00000008;
-const HWCAP2_CRC32: usize = 0x00000010;
-
-/// Try to read the features from the auxiliary vector
-pub(crate) fn detect_features() -> cache::Initializer {
-    let mut value = cache::Initializer::default();
-    let enable_feature = |value: &mut cache::Initializer, f, enable| {
-        if enable {
-            value.set(f as u32);
-        }
-    };
-
-    if let Ok(auxv) = auxvec::auxv() {
-        enable_feature(&mut value, Feature::neon, auxv.hwcap & HWCAP_NEON != 0);
-        enable_feature(&mut value, Feature::pmull, auxv.hwcap2 & HWCAP2_PMULL != 0);
-        enable_feature(&mut value, Feature::crc, auxv.hwcap2 & HWCAP2_CRC32 != 0);
-        enable_feature(&mut value, Feature::aes, auxv.hwcap2 & HWCAP2_AES != 0);
-        // SHA2 requires SHA1 & SHA2 features
-        let sha1 = auxv.hwcap2 & HWCAP2_SHA1 != 0;
-        let sha2 = auxv.hwcap2 & HWCAP2_SHA2 != 0;
-        enable_feature(&mut value, Feature::sha2, sha1 && sha2);
-        return value;
-    }
-    value
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/freebsd/auxvec.rs b/library/stdarch/crates/std_detect/src/detect/os/freebsd/auxvec.rs
deleted file mode 100644
index 4e72bf22d76..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/freebsd/auxvec.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//! Parses ELF auxiliary vectors.
-#![cfg_attr(
-    any(
-        target_arch = "aarch64",
-        target_arch = "arm",
-        target_arch = "powerpc64",
-        target_arch = "riscv64"
-    ),
-    allow(dead_code)
-)]
-
-/// Cache HWCAP bitfields of the ELF Auxiliary Vector.
-///
-/// If an entry cannot be read all the bits in the bitfield are set to zero.
-/// This should be interpreted as all the features being disabled.
-#[derive(Debug, Copy, Clone)]
-pub(crate) struct AuxVec {
-    pub hwcap: usize,
-    pub hwcap2: usize,
-}
-
-/// ELF Auxiliary Vector
-///
-/// The auxiliary vector is a memory region in a running ELF program's stack
-/// composed of (key: usize, value: usize) pairs.
-///
-/// The keys used in the aux vector are platform dependent. For FreeBSD, they are
-/// defined in [sys/elf_common.h][elf_common_h]. The hardware capabilities of a given
-/// CPU can be queried with the  `AT_HWCAP` and `AT_HWCAP2` keys.
-///
-/// Note that run-time feature detection is not invoked for features that can
-/// be detected at compile-time.
-///
-/// [elf_common.h]: https://svnweb.freebsd.org/base/release/12.0.0/sys/sys/elf_common.h?revision=341707
-pub(crate) fn auxv() -> Result<AuxVec, ()> {
-    let hwcap = archauxv(libc::AT_HWCAP);
-    let hwcap2 = archauxv(libc::AT_HWCAP2);
-    // Zero could indicate that no features were detected, but it's also used to
-    // indicate an error. In particular, on many platforms AT_HWCAP2 will be
-    // legitimately zero, since it contains the most recent feature flags.
-    if hwcap != 0 || hwcap2 != 0 {
-        return Ok(AuxVec { hwcap, hwcap2 });
-    }
-    Err(())
-}
-
-/// Tries to read the `key` from the auxiliary vector.
-fn archauxv(key: libc::c_int) -> usize {
-    const OUT_LEN: libc::c_int = core::mem::size_of::<libc::c_ulong>() as libc::c_int;
-    let mut out: libc::c_ulong = 0;
-    unsafe {
-        // elf_aux_info is available on FreeBSD 12.0+ and 11.4+:
-        // https://github.com/freebsd/freebsd-src/commit/0b08ae2120cdd08c20a2b806e2fcef4d0a36c470
-        // https://github.com/freebsd/freebsd-src/blob/release/11.4.0/sys/sys/auxv.h
-        // FreeBSD 11 support in std has been removed in Rust 1.75 (https://github.com/rust-lang/rust/pull/114521),
-        // so we can safely use this function.
-        let res = libc::elf_aux_info(
-            key,
-            &mut out as *mut libc::c_ulong as *mut libc::c_void,
-            OUT_LEN,
-        );
-        // If elf_aux_info fails, `out` will be left at zero (which is the proper default value).
-        debug_assert!(res == 0 || out == 0);
-    }
-    out as usize
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/freebsd/mod.rs b/library/stdarch/crates/std_detect/src/detect/os/freebsd/mod.rs
deleted file mode 100644
index ade7fb6269d..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/freebsd/mod.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//! Run-time feature detection on FreeBSD
-
-mod auxvec;
-
-cfg_if::cfg_if! {
-    if #[cfg(target_arch = "aarch64")] {
-        mod aarch64;
-        pub(crate) use self::aarch64::detect_features;
-    } else if #[cfg(target_arch = "arm")] {
-        mod arm;
-        pub(crate) use self::arm::detect_features;
-    } else if #[cfg(target_arch = "powerpc64")] {
-        mod powerpc;
-        pub(crate) use self::powerpc::detect_features;
-    } else {
-        use crate::detect::cache;
-        /// Performs run-time feature detection.
-        pub(crate) fn detect_features() -> cache::Initializer {
-            cache::Initializer::default()
-        }
-    }
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/freebsd/powerpc.rs b/library/stdarch/crates/std_detect/src/detect/os/freebsd/powerpc.rs
deleted file mode 100644
index d03af68cd08..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/freebsd/powerpc.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! Run-time feature detection for PowerPC on FreeBSD.
-
-use super::auxvec;
-use crate::detect::{Feature, cache};
-
-pub(crate) fn detect_features() -> cache::Initializer {
-    let mut value = cache::Initializer::default();
-    let enable_feature = |value: &mut cache::Initializer, f, enable| {
-        if enable {
-            value.set(f as u32);
-        }
-    };
-
-    if let Ok(auxv) = auxvec::auxv() {
-        enable_feature(&mut value, Feature::altivec, auxv.hwcap & 0x10000000 != 0);
-        enable_feature(&mut value, Feature::vsx, auxv.hwcap & 0x00000080 != 0);
-        enable_feature(&mut value, Feature::power8, auxv.hwcap2 & 0x80000000 != 0);
-        return value;
-    }
-    value
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/linux/aarch64.rs b/library/stdarch/crates/std_detect/src/detect/os/linux/aarch64.rs
deleted file mode 100644
index 22a9cefff7b..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/linux/aarch64.rs
+++ /dev/null
@@ -1,484 +0,0 @@
-//! Run-time feature detection for Aarch64 on Linux.
-
-use super::auxvec;
-use crate::detect::{Feature, bit, cache};
-
-/// Try to read the features from the auxiliary vector.
-pub(crate) fn detect_features() -> cache::Initializer {
-    #[cfg(target_os = "android")]
-    let is_exynos9810 = {
-        // Samsung Exynos 9810 has a bug that big and little cores have different
-        // ISAs. And on older Android (pre-9), the kernel incorrectly reports
-        // that features available only on some cores are available on all cores.
-        // https://reviews.llvm.org/D114523
-        let mut arch = [0_u8; libc::PROP_VALUE_MAX as usize];
-        let len = unsafe {
-            libc::__system_property_get(c"ro.arch".as_ptr(), arch.as_mut_ptr() as *mut libc::c_char)
-        };
-        // On Exynos, ro.arch is not available on Android 12+, but it is fine
-        // because Android 9+ includes the fix.
-        len > 0 && arch.starts_with(b"exynos9810")
-    };
-    #[cfg(not(target_os = "android"))]
-    let is_exynos9810 = false;
-
-    if let Ok(auxv) = auxvec::auxv() {
-        let hwcap: AtHwcap = auxv.into();
-        return hwcap.cache(is_exynos9810);
-    }
-    cache::Initializer::default()
-}
-
-/// These values are part of the platform-specific [asm/hwcap.h][hwcap] .
-///
-/// The names match those used for cpuinfo.
-///
-/// [hwcap]: https://github.com/torvalds/linux/blob/master/arch/arm64/include/uapi/asm/hwcap.h
-#[derive(Debug, Default, PartialEq)]
-struct AtHwcap {
-    // AT_HWCAP
-    fp: bool,
-    asimd: bool,
-    // evtstrm: No LLVM support.
-    aes: bool,
-    pmull: bool,
-    sha1: bool,
-    sha2: bool,
-    crc32: bool,
-    atomics: bool,
-    fphp: bool,
-    asimdhp: bool,
-    // cpuid: No LLVM support.
-    asimdrdm: bool,
-    jscvt: bool,
-    fcma: bool,
-    lrcpc: bool,
-    dcpop: bool,
-    sha3: bool,
-    sm3: bool,
-    sm4: bool,
-    asimddp: bool,
-    sha512: bool,
-    sve: bool,
-    fhm: bool,
-    dit: bool,
-    uscat: bool,
-    ilrcpc: bool,
-    flagm: bool,
-    ssbs: bool,
-    sb: bool,
-    paca: bool,
-    pacg: bool,
-
-    // AT_HWCAP2
-    dcpodp: bool,
-    sve2: bool,
-    sveaes: bool,
-    svepmull: bool,
-    svebitperm: bool,
-    svesha3: bool,
-    svesm4: bool,
-    flagm2: bool,
-    frint: bool,
-    // svei8mm: See i8mm feature.
-    svef32mm: bool,
-    svef64mm: bool,
-    // svebf16: See bf16 feature.
-    i8mm: bool,
-    bf16: bool,
-    // dgh: No LLVM support.
-    rng: bool,
-    bti: bool,
-    mte: bool,
-    ecv: bool,
-    // afp: bool,
-    // rpres: bool,
-    // mte3: bool,
-    sme: bool,
-    smei16i64: bool,
-    smef64f64: bool,
-    // smei8i32: bool,
-    // smef16f32: bool,
-    // smeb16f32: bool,
-    // smef32f32: bool,
-    smefa64: bool,
-    wfxt: bool,
-    // ebf16: bool,
-    // sveebf16: bool,
-    cssc: bool,
-    // rprfm: bool,
-    sve2p1: bool,
-    sme2: bool,
-    sme2p1: bool,
-    // smei16i32: bool,
-    // smebi32i32: bool,
-    smeb16b16: bool,
-    smef16f16: bool,
-    mops: bool,
-    hbc: bool,
-    sveb16b16: bool,
-    lrcpc3: bool,
-    lse128: bool,
-    fpmr: bool,
-    lut: bool,
-    faminmax: bool,
-    f8cvt: bool,
-    f8fma: bool,
-    f8dp4: bool,
-    f8dp2: bool,
-    f8e4m3: bool,
-    f8e5m2: bool,
-    smelutv2: bool,
-    smef8f16: bool,
-    smef8f32: bool,
-    smesf8fma: bool,
-    smesf8dp4: bool,
-    smesf8dp2: bool,
-    // pauthlr: bool,
-}
-
-impl From<auxvec::AuxVec> for AtHwcap {
-    /// Reads AtHwcap from the auxiliary vector.
-    fn from(auxv: auxvec::AuxVec) -> Self {
-        AtHwcap {
-            fp: bit::test(auxv.hwcap, 0),
-            asimd: bit::test(auxv.hwcap, 1),
-            // evtstrm: bit::test(auxv.hwcap, 2),
-            aes: bit::test(auxv.hwcap, 3),
-            pmull: bit::test(auxv.hwcap, 4),
-            sha1: bit::test(auxv.hwcap, 5),
-            sha2: bit::test(auxv.hwcap, 6),
-            crc32: bit::test(auxv.hwcap, 7),
-            atomics: bit::test(auxv.hwcap, 8),
-            fphp: bit::test(auxv.hwcap, 9),
-            asimdhp: bit::test(auxv.hwcap, 10),
-            // cpuid: bit::test(auxv.hwcap, 11),
-            asimdrdm: bit::test(auxv.hwcap, 12),
-            jscvt: bit::test(auxv.hwcap, 13),
-            fcma: bit::test(auxv.hwcap, 14),
-            lrcpc: bit::test(auxv.hwcap, 15),
-            dcpop: bit::test(auxv.hwcap, 16),
-            sha3: bit::test(auxv.hwcap, 17),
-            sm3: bit::test(auxv.hwcap, 18),
-            sm4: bit::test(auxv.hwcap, 19),
-            asimddp: bit::test(auxv.hwcap, 20),
-            sha512: bit::test(auxv.hwcap, 21),
-            sve: bit::test(auxv.hwcap, 22),
-            fhm: bit::test(auxv.hwcap, 23),
-            dit: bit::test(auxv.hwcap, 24),
-            uscat: bit::test(auxv.hwcap, 25),
-            ilrcpc: bit::test(auxv.hwcap, 26),
-            flagm: bit::test(auxv.hwcap, 27),
-            ssbs: bit::test(auxv.hwcap, 28),
-            sb: bit::test(auxv.hwcap, 29),
-            paca: bit::test(auxv.hwcap, 30),
-            pacg: bit::test(auxv.hwcap, 31),
-
-            // AT_HWCAP2
-            dcpodp: bit::test(auxv.hwcap2, 0),
-            sve2: bit::test(auxv.hwcap2, 1),
-            sveaes: bit::test(auxv.hwcap2, 2),
-            svepmull: bit::test(auxv.hwcap2, 3),
-            svebitperm: bit::test(auxv.hwcap2, 4),
-            svesha3: bit::test(auxv.hwcap2, 5),
-            svesm4: bit::test(auxv.hwcap2, 6),
-            flagm2: bit::test(auxv.hwcap2, 7),
-            frint: bit::test(auxv.hwcap2, 8),
-            // svei8mm: bit::test(auxv.hwcap2, 9),
-            svef32mm: bit::test(auxv.hwcap2, 10),
-            svef64mm: bit::test(auxv.hwcap2, 11),
-            // svebf16: bit::test(auxv.hwcap2, 12),
-            i8mm: bit::test(auxv.hwcap2, 13),
-            bf16: bit::test(auxv.hwcap2, 14),
-            // dgh: bit::test(auxv.hwcap2, 15),
-            rng: bit::test(auxv.hwcap2, 16),
-            bti: bit::test(auxv.hwcap2, 17),
-            mte: bit::test(auxv.hwcap2, 18),
-            ecv: bit::test(auxv.hwcap2, 19),
-            // afp: bit::test(auxv.hwcap2, 20),
-            // rpres: bit::test(auxv.hwcap2, 21),
-            // mte3: bit::test(auxv.hwcap2, 22),
-            sme: bit::test(auxv.hwcap2, 23),
-            smei16i64: bit::test(auxv.hwcap2, 24),
-            smef64f64: bit::test(auxv.hwcap2, 25),
-            // smei8i32: bit::test(auxv.hwcap2, 26),
-            // smef16f32: bit::test(auxv.hwcap2, 27),
-            // smeb16f32: bit::test(auxv.hwcap2, 28),
-            // smef32f32: bit::test(auxv.hwcap2, 29),
-            smefa64: bit::test(auxv.hwcap2, 30),
-            wfxt: bit::test(auxv.hwcap2, 31),
-            // ebf16: bit::test(auxv.hwcap2, 32),
-            // sveebf16: bit::test(auxv.hwcap2, 33),
-            cssc: bit::test(auxv.hwcap2, 34),
-            // rprfm: bit::test(auxv.hwcap2, 35),
-            sve2p1: bit::test(auxv.hwcap2, 36),
-            sme2: bit::test(auxv.hwcap2, 37),
-            sme2p1: bit::test(auxv.hwcap2, 38),
-            // smei16i32: bit::test(auxv.hwcap2, 39),
-            // smebi32i32: bit::test(auxv.hwcap2, 40),
-            smeb16b16: bit::test(auxv.hwcap2, 41),
-            smef16f16: bit::test(auxv.hwcap2, 42),
-            mops: bit::test(auxv.hwcap2, 43),
-            hbc: bit::test(auxv.hwcap2, 44),
-            sveb16b16: bit::test(auxv.hwcap2, 45),
-            lrcpc3: bit::test(auxv.hwcap2, 46),
-            lse128: bit::test(auxv.hwcap2, 47),
-            fpmr: bit::test(auxv.hwcap2, 48),
-            lut: bit::test(auxv.hwcap2, 49),
-            faminmax: bit::test(auxv.hwcap2, 50),
-            f8cvt: bit::test(auxv.hwcap2, 51),
-            f8fma: bit::test(auxv.hwcap2, 52),
-            f8dp4: bit::test(auxv.hwcap2, 53),
-            f8dp2: bit::test(auxv.hwcap2, 54),
-            f8e4m3: bit::test(auxv.hwcap2, 55),
-            f8e5m2: bit::test(auxv.hwcap2, 56),
-            smelutv2: bit::test(auxv.hwcap2, 57),
-            smef8f16: bit::test(auxv.hwcap2, 58),
-            smef8f32: bit::test(auxv.hwcap2, 59),
-            smesf8fma: bit::test(auxv.hwcap2, 60),
-            smesf8dp4: bit::test(auxv.hwcap2, 61),
-            smesf8dp2: bit::test(auxv.hwcap2, 62),
-            // pauthlr: bit::test(auxv.hwcap2, ??),
-        }
-    }
-}
-
-impl AtHwcap {
-    /// Initializes the cache from the feature -bits.
-    ///
-    /// The feature dependencies here come directly from LLVM's feature definitions:
-    /// https://github.com/llvm/llvm-project/blob/main/llvm/lib/Target/AArch64/AArch64.td
-    fn cache(self, is_exynos9810: bool) -> cache::Initializer {
-        let mut value = cache::Initializer::default();
-        {
-            let mut enable_feature = |f, enable| {
-                if enable {
-                    value.set(f as u32);
-                }
-            };
-
-            // Samsung Exynos 9810 has a bug that big and little cores have different
-            // ISAs. And on older Android (pre-9), the kernel incorrectly reports
-            // that features available only on some cores are available on all cores.
-            // So, only check features that are known to be available on exynos-m3:
-            // $ rustc --print cfg --target aarch64-linux-android -C target-cpu=exynos-m3 | grep target_feature
-            // See also https://github.com/rust-lang/stdarch/pull/1378#discussion_r1103748342.
-            if is_exynos9810 {
-                enable_feature(Feature::fp, self.fp);
-                enable_feature(Feature::crc, self.crc32);
-                // ASIMD support requires float support - if half-floats are
-                // supported, it also requires half-float support:
-                let asimd = self.fp && self.asimd && (!self.fphp | self.asimdhp);
-                enable_feature(Feature::asimd, asimd);
-                // Cryptographic extensions require ASIMD
-                // AES also covers FEAT_PMULL
-                enable_feature(Feature::aes, self.aes && self.pmull && asimd);
-                enable_feature(Feature::sha2, self.sha1 && self.sha2 && asimd);
-                return value;
-            }
-
-            enable_feature(Feature::fp, self.fp);
-            // Half-float support requires float support
-            enable_feature(Feature::fp16, self.fp && self.fphp);
-            // FHM (fp16fml in LLVM) requires half float support
-            enable_feature(Feature::fhm, self.fphp && self.fhm);
-            enable_feature(Feature::pmull, self.pmull);
-            enable_feature(Feature::crc, self.crc32);
-            enable_feature(Feature::lse, self.atomics);
-            enable_feature(Feature::lse2, self.uscat);
-            enable_feature(Feature::lse128, self.lse128 && self.atomics);
-            enable_feature(Feature::rcpc, self.lrcpc);
-            // RCPC2 (rcpc-immo in LLVM) requires RCPC support
-            let rcpc2 = self.ilrcpc && self.lrcpc;
-            enable_feature(Feature::rcpc2, rcpc2);
-            enable_feature(Feature::rcpc3, self.lrcpc3 && rcpc2);
-            enable_feature(Feature::dit, self.dit);
-            enable_feature(Feature::flagm, self.flagm);
-            enable_feature(Feature::flagm2, self.flagm2);
-            enable_feature(Feature::ssbs, self.ssbs);
-            enable_feature(Feature::sb, self.sb);
-            enable_feature(Feature::paca, self.paca);
-            enable_feature(Feature::pacg, self.pacg);
-            // enable_feature(Feature::pauth_lr, self.pauthlr);
-            enable_feature(Feature::dpb, self.dcpop);
-            enable_feature(Feature::dpb2, self.dcpodp);
-            enable_feature(Feature::rand, self.rng);
-            enable_feature(Feature::bti, self.bti);
-            enable_feature(Feature::mte, self.mte);
-            // jsconv requires float support
-            enable_feature(Feature::jsconv, self.jscvt && self.fp);
-            enable_feature(Feature::rdm, self.asimdrdm);
-            enable_feature(Feature::dotprod, self.asimddp);
-            enable_feature(Feature::frintts, self.frint);
-
-            // FEAT_I8MM & FEAT_BF16 also include optional SVE components which linux exposes
-            // separately. We ignore that distinction here.
-            enable_feature(Feature::i8mm, self.i8mm);
-            enable_feature(Feature::bf16, self.bf16);
-
-            // ASIMD support requires float support - if half-floats are
-            // supported, it also requires half-float support:
-            let asimd = self.fp && self.asimd && (!self.fphp | self.asimdhp);
-            enable_feature(Feature::asimd, asimd);
-            // ASIMD extensions require ASIMD support:
-            enable_feature(Feature::fcma, self.fcma && asimd);
-            enable_feature(Feature::sve, self.sve && asimd);
-
-            // SVE extensions require SVE & ASIMD
-            enable_feature(Feature::f32mm, self.svef32mm && self.sve && asimd);
-            enable_feature(Feature::f64mm, self.svef64mm && self.sve && asimd);
-
-            // Cryptographic extensions require ASIMD
-            enable_feature(Feature::aes, self.aes && asimd);
-            enable_feature(Feature::sha2, self.sha1 && self.sha2 && asimd);
-            // SHA512/SHA3 require SHA1 & SHA256
-            enable_feature(
-                Feature::sha3,
-                self.sha512 && self.sha3 && self.sha1 && self.sha2 && asimd,
-            );
-            enable_feature(Feature::sm4, self.sm3 && self.sm4 && asimd);
-
-            // SVE2 requires SVE
-            let sve2 = self.sve2 && self.sve && asimd;
-            enable_feature(Feature::sve2, sve2);
-            enable_feature(Feature::sve2p1, self.sve2p1 && sve2);
-            // SVE2 extensions require SVE2 and crypto features
-            enable_feature(
-                Feature::sve2_aes,
-                self.sveaes && self.svepmull && sve2 && self.aes,
-            );
-            enable_feature(
-                Feature::sve2_sm4,
-                self.svesm4 && sve2 && self.sm3 && self.sm4,
-            );
-            enable_feature(
-                Feature::sve2_sha3,
-                self.svesha3 && sve2 && self.sha512 && self.sha3 && self.sha1 && self.sha2,
-            );
-            enable_feature(Feature::sve2_bitperm, self.svebitperm && self.sve2);
-            enable_feature(Feature::sve_b16b16, self.bf16 && self.sveb16b16);
-            enable_feature(Feature::hbc, self.hbc);
-            enable_feature(Feature::mops, self.mops);
-            enable_feature(Feature::ecv, self.ecv);
-            enable_feature(Feature::lut, self.lut);
-            enable_feature(Feature::cssc, self.cssc);
-            enable_feature(Feature::fpmr, self.fpmr);
-            enable_feature(Feature::faminmax, self.faminmax);
-            let fp8 = self.f8cvt && self.faminmax && self.lut && self.bf16;
-            enable_feature(Feature::fp8, fp8);
-            let fp8fma = self.f8fma && fp8;
-            enable_feature(Feature::fp8fma, fp8fma);
-            let fp8dot4 = self.f8dp4 && fp8fma;
-            enable_feature(Feature::fp8dot4, fp8dot4);
-            enable_feature(Feature::fp8dot2, self.f8dp2 && fp8dot4);
-            enable_feature(Feature::wfxt, self.wfxt);
-            let sme = self.sme && self.bf16;
-            enable_feature(Feature::sme, sme);
-            enable_feature(Feature::sme_i16i64, self.smei16i64 && sme);
-            enable_feature(Feature::sme_f64f64, self.smef64f64 && sme);
-            enable_feature(Feature::sme_fa64, self.smefa64 && sme && sve2);
-            let sme2 = self.sme2 && sme;
-            enable_feature(Feature::sme2, sme2);
-            enable_feature(Feature::sme2p1, self.sme2p1 && sme2);
-            enable_feature(
-                Feature::sme_b16b16,
-                sme2 && self.bf16 && self.sveb16b16 && self.smeb16b16,
-            );
-            enable_feature(Feature::sme_f16f16, self.smef16f16 && sme2);
-            enable_feature(Feature::sme_lutv2, self.smelutv2);
-            let sme_f8f32 = self.smef8f32 && sme2 && fp8;
-            enable_feature(Feature::sme_f8f32, sme_f8f32);
-            enable_feature(Feature::sme_f8f16, self.smef8f16 && sme_f8f32);
-            let ssve_fp8fma = self.smesf8fma && sme2 && fp8;
-            enable_feature(Feature::ssve_fp8fma, ssve_fp8fma);
-            let ssve_fp8dot4 = self.smesf8dp4 && ssve_fp8fma;
-            enable_feature(Feature::ssve_fp8dot4, ssve_fp8dot4);
-            enable_feature(Feature::ssve_fp8dot2, self.smesf8dp2 && ssve_fp8dot4);
-        }
-        value
-    }
-}
-
-#[cfg(target_endian = "little")]
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[cfg(feature = "std_detect_file_io")]
-    mod auxv_from_file {
-        use super::auxvec::auxv_from_file;
-        use super::*;
-        // The baseline hwcaps used in the (artificial) auxv test files.
-        fn baseline_hwcaps() -> AtHwcap {
-            AtHwcap {
-                fp: true,
-                asimd: true,
-                aes: true,
-                pmull: true,
-                sha1: true,
-                sha2: true,
-                crc32: true,
-                atomics: true,
-                fphp: true,
-                asimdhp: true,
-                asimdrdm: true,
-                lrcpc: true,
-                dcpop: true,
-                asimddp: true,
-                ssbs: true,
-                ..AtHwcap::default()
-            }
-        }
-
-        #[test]
-        fn linux_empty_hwcap2_aarch64() {
-            let file = concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv"
-            );
-            println!("file: {file}");
-            let v = auxv_from_file(file).unwrap();
-            println!("HWCAP : 0x{:0x}", v.hwcap);
-            println!("HWCAP2: 0x{:0x}", v.hwcap2);
-            assert_eq!(AtHwcap::from(v), baseline_hwcaps());
-        }
-        #[test]
-        fn linux_no_hwcap2_aarch64() {
-            let file = concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv"
-            );
-            println!("file: {file}");
-            let v = auxv_from_file(file).unwrap();
-            println!("HWCAP : 0x{:0x}", v.hwcap);
-            println!("HWCAP2: 0x{:0x}", v.hwcap2);
-            assert_eq!(AtHwcap::from(v), baseline_hwcaps());
-        }
-        #[test]
-        fn linux_hwcap2_aarch64() {
-            let file = concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/src/detect/test_data/linux-hwcap2-aarch64.auxv"
-            );
-            println!("file: {file}");
-            let v = auxv_from_file(file).unwrap();
-            println!("HWCAP : 0x{:0x}", v.hwcap);
-            println!("HWCAP2: 0x{:0x}", v.hwcap2);
-            assert_eq!(
-                AtHwcap::from(v),
-                AtHwcap {
-                    // Some other HWCAP bits.
-                    paca: true,
-                    pacg: true,
-                    // HWCAP2-only bits.
-                    dcpodp: true,
-                    frint: true,
-                    rng: true,
-                    bti: true,
-                    mte: true,
-                    ..baseline_hwcaps()
-                }
-            );
-        }
-    }
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/linux/arm.rs b/library/stdarch/crates/std_detect/src/detect/os/linux/arm.rs
deleted file mode 100644
index bbb173227d0..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/linux/arm.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//! Run-time feature detection for ARM on Linux.
-
-use super::auxvec;
-use crate::detect::{Feature, bit, cache};
-
-/// Try to read the features from the auxiliary vector.
-pub(crate) fn detect_features() -> cache::Initializer {
-    let mut value = cache::Initializer::default();
-    let enable_feature = |value: &mut cache::Initializer, f, enable| {
-        if enable {
-            value.set(f as u32);
-        }
-    };
-
-    // The values are part of the platform-specific [asm/hwcap.h][hwcap]
-    //
-    // [hwcap]: https://github.com/torvalds/linux/blob/master/arch/arm/include/uapi/asm/hwcap.h
-    if let Ok(auxv) = auxvec::auxv() {
-        enable_feature(&mut value, Feature::i8mm, bit::test(auxv.hwcap, 27));
-        enable_feature(&mut value, Feature::dotprod, bit::test(auxv.hwcap, 24));
-        enable_feature(&mut value, Feature::neon, bit::test(auxv.hwcap, 12));
-        enable_feature(&mut value, Feature::pmull, bit::test(auxv.hwcap2, 1));
-        enable_feature(&mut value, Feature::crc, bit::test(auxv.hwcap2, 4));
-        enable_feature(&mut value, Feature::aes, bit::test(auxv.hwcap2, 0));
-        // SHA2 requires SHA1 & SHA2 features
-        enable_feature(
-            &mut value,
-            Feature::sha2,
-            bit::test(auxv.hwcap2, 2) && bit::test(auxv.hwcap2, 3),
-        );
-        return value;
-    }
-    value
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/linux/auxvec.rs b/library/stdarch/crates/std_detect/src/detect/os/linux/auxvec.rs
deleted file mode 100644
index 54f52aa7533..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/linux/auxvec.rs
+++ /dev/null
@@ -1,341 +0,0 @@
-//! Parses ELF auxiliary vectors.
-#![allow(dead_code)]
-
-pub(crate) const AT_NULL: usize = 0;
-
-/// Key to access the CPU Hardware capabilities bitfield.
-pub(crate) const AT_HWCAP: usize = 16;
-/// Key to access the CPU Hardware capabilities 2 bitfield.
-#[cfg(any(
-    target_arch = "aarch64",
-    target_arch = "arm",
-    target_arch = "powerpc",
-    target_arch = "powerpc64",
-    target_arch = "s390x",
-))]
-pub(crate) const AT_HWCAP2: usize = 26;
-
-/// Cache HWCAP bitfields of the ELF Auxiliary Vector.
-///
-/// If an entry cannot be read all the bits in the bitfield are set to zero.
-/// This should be interpreted as all the features being disabled.
-#[derive(Debug, Copy, Clone)]
-#[cfg_attr(test, derive(PartialEq))]
-pub(crate) struct AuxVec {
-    pub hwcap: usize,
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "arm",
-        target_arch = "powerpc",
-        target_arch = "powerpc64",
-        target_arch = "s390x",
-    ))]
-    pub hwcap2: usize,
-}
-
-/// ELF Auxiliary Vector
-///
-/// The auxiliary vector is a memory region in a running ELF program's stack
-/// composed of (key: usize, value: usize) pairs.
-///
-/// The keys used in the aux vector are platform dependent. For Linux, they are
-/// defined in [linux/auxvec.h][auxvec_h]. The hardware capabilities of a given
-/// CPU can be queried with the  `AT_HWCAP` and `AT_HWCAP2` keys.
-///
-/// There is no perfect way of reading the auxiliary vector.
-///
-/// - If the `std_detect_dlsym_getauxval` cargo feature is enabled, this will use
-///   `getauxval` if its linked to the binary, and otherwise proceed to a fallback implementation.
-///   When `std_detect_dlsym_getauxval` is disabled, this will assume that `getauxval` is
-///   linked to the binary - if that is not the case the behavior is undefined.
-/// - Otherwise, if the `std_detect_file_io` cargo feature is enabled, it will
-///   try to read `/proc/self/auxv`.
-/// - If that fails, this function returns an error.
-///
-/// Note that run-time feature detection is not invoked for features that can
-/// be detected at compile-time.
-///
-///  Note: The `std_detect_dlsym_getauxval` cargo feature is ignored on
-/// `*-linux-{gnu,musl,ohos}*` and `*-android*` targets because we can safely assume `getauxval`
-/// is linked to the binary.
-/// - `*-linux-gnu*` targets ([since Rust 1.64](https://blog.rust-lang.org/2022/08/01/Increasing-glibc-kernel-requirements.html))
-///   have glibc requirements higher than [glibc 2.16 that added `getauxval`](https://sourceware.org/legacy-ml/libc-announce/2012/msg00000.html).
-/// - `*-linux-musl*` targets ([at least since Rust 1.15](https://github.com/rust-lang/rust/blob/1.15.0/src/ci/docker/x86_64-musl/build-musl.sh#L15))
-///   use musl newer than [musl 1.1.0 that added `getauxval`](https://git.musl-libc.org/cgit/musl/tree/WHATSNEW?h=v1.1.0#n1197)
-/// - `*-linux-ohos*` targets use a [fork of musl 1.2](https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/native-lib/musl.md)
-/// - `*-android*` targets ([since Rust 1.68](https://blog.rust-lang.org/2023/01/09/android-ndk-update-r25.html))
-///   have the minimum supported API level higher than [Android 4.3 (API level 18) that added `getauxval`](https://github.com/aosp-mirror/platform_bionic/blob/d3ebc2f7c49a9893b114124d4a6b315f3a328764/libc/include/sys/auxv.h#L49).
-///
-/// For more information about when `getauxval` is available check the great
-/// [`auxv` crate documentation][auxv_docs].
-///
-/// [auxvec_h]: https://github.com/torvalds/linux/blob/master/include/uapi/linux/auxvec.h
-/// [auxv_docs]: https://docs.rs/auxv/0.3.3/auxv/
-pub(crate) fn auxv() -> Result<AuxVec, ()> {
-    // Try to call a getauxval function.
-    if let Ok(hwcap) = getauxval(AT_HWCAP) {
-        // Targets with only AT_HWCAP:
-        #[cfg(any(
-            target_arch = "riscv32",
-            target_arch = "riscv64",
-            target_arch = "mips",
-            target_arch = "mips64",
-            target_arch = "loongarch32",
-            target_arch = "loongarch64",
-        ))]
-        {
-            // Zero could indicate that no features were detected, but it's also used to indicate
-            // an error. In either case, try the fallback.
-            if hwcap != 0 {
-                return Ok(AuxVec { hwcap });
-            }
-        }
-
-        // Targets with AT_HWCAP and AT_HWCAP2:
-        #[cfg(any(
-            target_arch = "aarch64",
-            target_arch = "arm",
-            target_arch = "powerpc",
-            target_arch = "powerpc64",
-            target_arch = "s390x",
-        ))]
-        {
-            if let Ok(hwcap2) = getauxval(AT_HWCAP2) {
-                // Zero could indicate that no features were detected, but it's also used to indicate
-                // an error. In particular, on many platforms AT_HWCAP2 will be legitimately zero,
-                // since it contains the most recent feature flags. Use the fallback only if no
-                // features were detected at all.
-                if hwcap != 0 || hwcap2 != 0 {
-                    return Ok(AuxVec { hwcap, hwcap2 });
-                }
-            }
-        }
-
-        // Intentionnaly not used
-        let _ = hwcap;
-    }
-
-    #[cfg(feature = "std_detect_file_io")]
-    {
-        // If calling getauxval fails, try to read the auxiliary vector from
-        // its file:
-        auxv_from_file("/proc/self/auxv")
-    }
-    #[cfg(not(feature = "std_detect_file_io"))]
-    {
-        Err(())
-    }
-}
-
-/// Tries to read the `key` from the auxiliary vector by calling the
-/// `getauxval` function. If the function is not linked, this function return `Err`.
-fn getauxval(key: usize) -> Result<usize, ()> {
-    type F = unsafe extern "C" fn(libc::c_ulong) -> libc::c_ulong;
-    cfg_if::cfg_if! {
-        if #[cfg(all(
-            feature = "std_detect_dlsym_getauxval",
-            not(all(
-                target_os = "linux",
-                any(target_env = "gnu", target_env = "musl", target_env = "ohos"),
-            )),
-            not(target_os = "android"),
-        ))] {
-            let ffi_getauxval: F = unsafe {
-                let ptr = libc::dlsym(libc::RTLD_DEFAULT, c"getauxval".as_ptr());
-                if ptr.is_null() {
-                    return Err(());
-                }
-                core::mem::transmute(ptr)
-            };
-        } else {
-            let ffi_getauxval: F = libc::getauxval;
-        }
-    }
-    Ok(unsafe { ffi_getauxval(key as libc::c_ulong) as usize })
-}
-
-/// Tries to read the auxiliary vector from the `file`. If this fails, this
-/// function returns `Err`.
-#[cfg(feature = "std_detect_file_io")]
-pub(super) fn auxv_from_file(file: &str) -> Result<AuxVec, ()> {
-    let file = super::read_file(file)?;
-
-    // See <https://github.com/torvalds/linux/blob/v5.15/include/uapi/linux/auxvec.h>.
-    //
-    // The auxiliary vector contains at most 34 (key,value) fields: from
-    // `AT_MINSIGSTKSZ` to `AT_NULL`, but its number may increase.
-    let len = file.len();
-    let mut buf = alloc::vec![0_usize; 1 + len / core::mem::size_of::<usize>()];
-    unsafe {
-        core::ptr::copy_nonoverlapping(file.as_ptr(), buf.as_mut_ptr() as *mut u8, len);
-    }
-
-    auxv_from_buf(&buf)
-}
-
-/// Tries to interpret the `buffer` as an auxiliary vector. If that fails, this
-/// function returns `Err`.
-#[cfg(feature = "std_detect_file_io")]
-fn auxv_from_buf(buf: &[usize]) -> Result<AuxVec, ()> {
-    // Targets with only AT_HWCAP:
-    #[cfg(any(
-        target_arch = "riscv32",
-        target_arch = "riscv64",
-        target_arch = "mips",
-        target_arch = "mips64",
-        target_arch = "loongarch32",
-        target_arch = "loongarch64",
-    ))]
-    {
-        for el in buf.chunks(2) {
-            match el[0] {
-                AT_NULL => break,
-                AT_HWCAP => return Ok(AuxVec { hwcap: el[1] }),
-                _ => (),
-            }
-        }
-    }
-    // Targets with AT_HWCAP and AT_HWCAP2:
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "arm",
-        target_arch = "powerpc",
-        target_arch = "powerpc64",
-        target_arch = "s390x",
-    ))]
-    {
-        let mut hwcap = None;
-        // For some platforms, AT_HWCAP2 was added recently, so let it default to zero.
-        let mut hwcap2 = 0;
-        for el in buf.chunks(2) {
-            match el[0] {
-                AT_NULL => break,
-                AT_HWCAP => hwcap = Some(el[1]),
-                AT_HWCAP2 => hwcap2 = el[1],
-                _ => (),
-            }
-        }
-
-        if let Some(hwcap) = hwcap {
-            return Ok(AuxVec { hwcap, hwcap2 });
-        }
-    }
-    // Suppress unused variable
-    let _ = buf;
-    Err(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // FIXME: on mips/mips64 getauxval returns 0, and /proc/self/auxv
-    // does not always contain the AT_HWCAP key under qemu.
-    #[cfg(any(
-        target_arch = "arm",
-        target_arch = "powerpc",
-        target_arch = "powerpc64",
-        target_arch = "s390x",
-    ))]
-    #[test]
-    fn auxv_crate() {
-        let v = auxv();
-        if let Ok(hwcap) = getauxval(AT_HWCAP) {
-            let rt_hwcap = v.expect("failed to find hwcap key").hwcap;
-            assert_eq!(rt_hwcap, hwcap);
-        }
-
-        // Targets with AT_HWCAP and AT_HWCAP2:
-        #[cfg(any(
-            target_arch = "aarch64",
-            target_arch = "arm",
-            target_arch = "powerpc",
-            target_arch = "powerpc64",
-            target_arch = "s390x",
-        ))]
-        {
-            if let Ok(hwcap2) = getauxval(AT_HWCAP2) {
-                let rt_hwcap2 = v.expect("failed to find hwcap2 key").hwcap2;
-                assert_eq!(rt_hwcap2, hwcap2);
-            }
-        }
-    }
-
-    #[test]
-    fn auxv_dump() {
-        if let Ok(auxvec) = auxv() {
-            println!("{:?}", auxvec);
-        } else {
-            println!("both getauxval() and reading /proc/self/auxv failed!");
-        }
-    }
-
-    #[cfg(feature = "std_detect_file_io")]
-    cfg_if::cfg_if! {
-        if #[cfg(target_arch = "arm")] {
-            #[test]
-            fn linux_rpi3() {
-                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-rpi3.auxv");
-                println!("file: {file}");
-                let v = auxv_from_file(file).unwrap();
-                assert_eq!(v.hwcap, 4174038);
-                assert_eq!(v.hwcap2, 16);
-            }
-
-            #[test]
-            fn linux_macos_vb() {
-                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv");
-                println!("file: {file}");
-                // The file contains HWCAP but not HWCAP2. In that case, we treat HWCAP2 as zero.
-                let v = auxv_from_file(file).unwrap();
-                assert_eq!(v.hwcap, 126614527);
-                assert_eq!(v.hwcap2, 0);
-            }
-        } else if #[cfg(target_arch = "aarch64")] {
-            #[cfg(target_endian = "little")]
-            #[test]
-            fn linux_artificial_aarch64() {
-                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-artificial-aarch64.auxv");
-                println!("file: {file}");
-                let v = auxv_from_file(file).unwrap();
-                assert_eq!(v.hwcap, 0x0123456789abcdef);
-                assert_eq!(v.hwcap2, 0x02468ace13579bdf);
-            }
-            #[cfg(target_endian = "little")]
-            #[test]
-            fn linux_no_hwcap2_aarch64() {
-                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv");
-                println!("file: {file}");
-                let v = auxv_from_file(file).unwrap();
-                // An absent HWCAP2 is treated as zero, and does not prevent acceptance of HWCAP.
-                assert_ne!(v.hwcap, 0);
-                assert_eq!(v.hwcap2, 0);
-            }
-        }
-    }
-
-    #[test]
-    #[cfg(feature = "std_detect_file_io")]
-    fn auxv_dump_procfs() {
-        if let Ok(auxvec) = auxv_from_file("/proc/self/auxv") {
-            println!("{:?}", auxvec);
-        } else {
-            println!("reading /proc/self/auxv failed!");
-        }
-    }
-
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "arm",
-        target_arch = "powerpc",
-        target_arch = "powerpc64",
-        target_arch = "s390x",
-    ))]
-    #[test]
-    #[cfg(feature = "std_detect_file_io")]
-    fn auxv_crate_procfs() {
-        if let Ok(procfs_auxv) = auxv_from_file("/proc/self/auxv") {
-            assert_eq!(auxv().unwrap(), procfs_auxv);
-        }
-    }
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/linux/loongarch.rs b/library/stdarch/crates/std_detect/src/detect/os/linux/loongarch.rs
deleted file mode 100644
index 14cc7a73183..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/linux/loongarch.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//! Run-time feature detection for LoongArch on Linux.
-
-use super::auxvec;
-use crate::detect::{Feature, bit, cache};
-use core::arch::asm;
-
-/// Try to read the features from the auxiliary vector.
-pub(crate) fn detect_features() -> cache::Initializer {
-    let mut value = cache::Initializer::default();
-    let enable_feature = |value: &mut cache::Initializer, feature, enable| {
-        if enable {
-            value.set(feature as u32);
-        }
-    };
-
-    // The values are part of the platform-specific [cpucfg]
-    //
-    // [cpucfg]: LoongArch Reference Manual Volume 1: Basic Architecture v1.1
-    let cpucfg2: usize;
-    unsafe {
-        asm!(
-            "cpucfg {}, {}",
-            out(reg) cpucfg2, in(reg) 2,
-            options(pure, nomem, preserves_flags, nostack)
-        );
-    }
-    let cpucfg3: usize;
-    unsafe {
-        asm!(
-            "cpucfg {}, {}",
-            out(reg) cpucfg3, in(reg) 3,
-            options(pure, nomem, preserves_flags, nostack)
-        );
-    }
-    enable_feature(&mut value, Feature::frecipe, bit::test(cpucfg2, 25));
-    enable_feature(&mut value, Feature::div32, bit::test(cpucfg2, 26));
-    enable_feature(&mut value, Feature::lam_bh, bit::test(cpucfg2, 27));
-    enable_feature(&mut value, Feature::lamcas, bit::test(cpucfg2, 28));
-    enable_feature(&mut value, Feature::scq, bit::test(cpucfg2, 30));
-    enable_feature(&mut value, Feature::ld_seq_sa, bit::test(cpucfg3, 23));
-
-    // The values are part of the platform-specific [asm/hwcap.h][hwcap]
-    //
-    // [hwcap]: https://github.com/torvalds/linux/blob/master/arch/loongarch/include/uapi/asm/hwcap.h
-    if let Ok(auxv) = auxvec::auxv() {
-        enable_feature(
-            &mut value,
-            Feature::f,
-            bit::test(cpucfg2, 1) && bit::test(auxv.hwcap, 3),
-        );
-        enable_feature(
-            &mut value,
-            Feature::d,
-            bit::test(cpucfg2, 2) && bit::test(auxv.hwcap, 3),
-        );
-        enable_feature(&mut value, Feature::lsx, bit::test(auxv.hwcap, 4));
-        enable_feature(&mut value, Feature::lasx, bit::test(auxv.hwcap, 5));
-        enable_feature(
-            &mut value,
-            Feature::lbt,
-            bit::test(auxv.hwcap, 10) && bit::test(auxv.hwcap, 11) && bit::test(auxv.hwcap, 12),
-        );
-        enable_feature(&mut value, Feature::lvz, bit::test(auxv.hwcap, 9));
-        enable_feature(&mut value, Feature::ual, bit::test(auxv.hwcap, 2));
-        return value;
-    }
-    value
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/linux/mips.rs b/library/stdarch/crates/std_detect/src/detect/os/linux/mips.rs
deleted file mode 100644
index 0cfa8869887..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/linux/mips.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//! Run-time feature detection for MIPS on Linux.
-
-use super::auxvec;
-use crate::detect::{Feature, bit, cache};
-
-/// Try to read the features from the auxiliary vector.
-pub(crate) fn detect_features() -> cache::Initializer {
-    let mut value = cache::Initializer::default();
-    let enable_feature = |value: &mut cache::Initializer, f, enable| {
-        if enable {
-            value.set(f as u32);
-        }
-    };
-
-    // The values are part of the platform-specific [asm/hwcap.h][hwcap]
-    //
-    // [hwcap]: https://github.com/torvalds/linux/blob/master/arch/mips/include/uapi/asm/hwcap.h
-    if let Ok(auxv) = auxvec::auxv() {
-        enable_feature(&mut value, Feature::msa, bit::test(auxv.hwcap, 1));
-        return value;
-    }
-    value
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/linux/mod.rs b/library/stdarch/crates/std_detect/src/detect/os/linux/mod.rs
deleted file mode 100644
index 9accd41717b..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/linux/mod.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-//! Run-time feature detection on Linux
-//!
-#[cfg(feature = "std_detect_file_io")]
-use alloc::vec::Vec;
-
-mod auxvec;
-
-#[cfg(feature = "std_detect_file_io")]
-fn read_file(path: &str) -> Result<Vec<u8>, ()> {
-    let mut path = Vec::from(path.as_bytes());
-    path.push(0);
-
-    unsafe {
-        let file = libc::open(path.as_ptr() as *const libc::c_char, libc::O_RDONLY);
-        if file == -1 {
-            return Err(());
-        }
-
-        let mut data = Vec::new();
-        loop {
-            data.reserve(4096);
-            let spare = data.spare_capacity_mut();
-            match libc::read(file, spare.as_mut_ptr() as *mut _, spare.len()) {
-                -1 => {
-                    libc::close(file);
-                    return Err(());
-                }
-                0 => break,
-                n => data.set_len(data.len() + n as usize),
-            }
-        }
-
-        libc::close(file);
-        Ok(data)
-    }
-}
-
-cfg_if::cfg_if! {
-    if #[cfg(target_arch = "aarch64")] {
-        mod aarch64;
-        pub(crate) use self::aarch64::detect_features;
-    } else if #[cfg(target_arch = "arm")] {
-        mod arm;
-        pub(crate) use self::arm::detect_features;
-    } else if #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))] {
-        mod riscv;
-        pub(crate) use self::riscv::detect_features;
-    } else if #[cfg(any(target_arch = "mips", target_arch = "mips64"))] {
-        mod mips;
-        pub(crate) use self::mips::detect_features;
-    } else if #[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))] {
-        mod powerpc;
-        pub(crate) use self::powerpc::detect_features;
-    } else if #[cfg(any(target_arch = "loongarch32", target_arch = "loongarch64"))] {
-        mod loongarch;
-        pub(crate) use self::loongarch::detect_features;
-    } else if #[cfg(target_arch = "s390x")] {
-        mod s390x;
-        pub(crate) use self::s390x::detect_features;
-    } else {
-        use crate::detect::cache;
-        /// Performs run-time feature detection.
-        pub(crate) fn detect_features() -> cache::Initializer {
-            cache::Initializer::default()
-        }
-    }
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/linux/powerpc.rs b/library/stdarch/crates/std_detect/src/detect/os/linux/powerpc.rs
deleted file mode 100644
index 6a4f7e715d9..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/linux/powerpc.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//! Run-time feature detection for PowerPC on Linux.
-
-use super::auxvec;
-use crate::detect::{Feature, cache};
-
-/// Try to read the features from the auxiliary vector.
-pub(crate) fn detect_features() -> cache::Initializer {
-    let mut value = cache::Initializer::default();
-    let enable_feature = |value: &mut cache::Initializer, f, enable| {
-        if enable {
-            value.set(f as u32);
-        }
-    };
-
-    // The values are part of the platform-specific [asm/cputable.h][cputable]
-    //
-    // [cputable]: https://github.com/torvalds/linux/blob/master/arch/powerpc/include/uapi/asm/cputable.h
-    if let Ok(auxv) = auxvec::auxv() {
-        // note: the PowerPC values are the mask to do the test (instead of the
-        // index of the bit to test like in ARM and Aarch64)
-        enable_feature(&mut value, Feature::altivec, auxv.hwcap & 0x10000000 != 0);
-        enable_feature(&mut value, Feature::vsx, auxv.hwcap & 0x00000080 != 0);
-        let power8_features = auxv.hwcap2 & 0x80000000 != 0;
-        enable_feature(&mut value, Feature::power8, power8_features);
-        enable_feature(&mut value, Feature::power8_altivec, power8_features);
-        enable_feature(&mut value, Feature::power8_crypto, power8_features);
-        enable_feature(&mut value, Feature::power8_vector, power8_features);
-        let power9_features = auxv.hwcap2 & 0x00800000 != 0;
-        enable_feature(&mut value, Feature::power9, power9_features);
-        enable_feature(&mut value, Feature::power9_altivec, power9_features);
-        enable_feature(&mut value, Feature::power9_vector, power9_features);
-        return value;
-    }
-    value
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/linux/riscv.rs b/library/stdarch/crates/std_detect/src/detect/os/linux/riscv.rs
deleted file mode 100644
index db20538af95..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/linux/riscv.rs
+++ /dev/null
@@ -1,330 +0,0 @@
-//! Run-time feature detection for RISC-V on Linux.
-//!
-//! On RISC-V, detection using auxv only supports single-letter extensions.
-//! So, we use riscv_hwprobe that supports multi-letter extensions if available.
-//! <https://www.kernel.org/doc/html/latest/arch/riscv/hwprobe.html>
-
-use core::ptr;
-
-use super::super::riscv::imply_features;
-use super::auxvec;
-use crate::detect::{Feature, bit, cache};
-
-// See <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/prctl.h?h=v6.15>
-// for runtime status query constants.
-const PR_RISCV_V_GET_CONTROL: libc::c_int = 70;
-const PR_RISCV_V_VSTATE_CTRL_ON: libc::c_int = 2;
-const PR_RISCV_V_VSTATE_CTRL_CUR_MASK: libc::c_int = 3;
-
-// See <https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/include/uapi/asm/hwprobe.h?h=v6.15>
-// for riscv_hwprobe struct and hardware probing constants.
-
-#[repr(C)]
-struct riscv_hwprobe {
-    key: i64,
-    value: u64,
-}
-
-impl riscv_hwprobe {
-    // key is overwritten to -1 if not supported by riscv_hwprobe syscall.
-    pub fn get(&self) -> Option<u64> {
-        (self.key != -1).then_some(self.value)
-    }
-}
-
-#[allow(non_upper_case_globals)]
-const __NR_riscv_hwprobe: libc::c_long = 258;
-
-const RISCV_HWPROBE_KEY_BASE_BEHAVIOR: i64 = 3;
-const RISCV_HWPROBE_BASE_BEHAVIOR_IMA: u64 = 1 << 0;
-
-const RISCV_HWPROBE_KEY_IMA_EXT_0: i64 = 4;
-const RISCV_HWPROBE_IMA_FD: u64 = 1 << 0;
-const RISCV_HWPROBE_IMA_C: u64 = 1 << 1;
-const RISCV_HWPROBE_IMA_V: u64 = 1 << 2;
-const RISCV_HWPROBE_EXT_ZBA: u64 = 1 << 3;
-const RISCV_HWPROBE_EXT_ZBB: u64 = 1 << 4;
-const RISCV_HWPROBE_EXT_ZBS: u64 = 1 << 5;
-const RISCV_HWPROBE_EXT_ZICBOZ: u64 = 1 << 6;
-const RISCV_HWPROBE_EXT_ZBC: u64 = 1 << 7;
-const RISCV_HWPROBE_EXT_ZBKB: u64 = 1 << 8;
-const RISCV_HWPROBE_EXT_ZBKC: u64 = 1 << 9;
-const RISCV_HWPROBE_EXT_ZBKX: u64 = 1 << 10;
-const RISCV_HWPROBE_EXT_ZKND: u64 = 1 << 11;
-const RISCV_HWPROBE_EXT_ZKNE: u64 = 1 << 12;
-const RISCV_HWPROBE_EXT_ZKNH: u64 = 1 << 13;
-const RISCV_HWPROBE_EXT_ZKSED: u64 = 1 << 14;
-const RISCV_HWPROBE_EXT_ZKSH: u64 = 1 << 15;
-const RISCV_HWPROBE_EXT_ZKT: u64 = 1 << 16;
-const RISCV_HWPROBE_EXT_ZVBB: u64 = 1 << 17;
-const RISCV_HWPROBE_EXT_ZVBC: u64 = 1 << 18;
-const RISCV_HWPROBE_EXT_ZVKB: u64 = 1 << 19;
-const RISCV_HWPROBE_EXT_ZVKG: u64 = 1 << 20;
-const RISCV_HWPROBE_EXT_ZVKNED: u64 = 1 << 21;
-const RISCV_HWPROBE_EXT_ZVKNHA: u64 = 1 << 22;
-const RISCV_HWPROBE_EXT_ZVKNHB: u64 = 1 << 23;
-const RISCV_HWPROBE_EXT_ZVKSED: u64 = 1 << 24;
-const RISCV_HWPROBE_EXT_ZVKSH: u64 = 1 << 25;
-const RISCV_HWPROBE_EXT_ZVKT: u64 = 1 << 26;
-const RISCV_HWPROBE_EXT_ZFH: u64 = 1 << 27;
-const RISCV_HWPROBE_EXT_ZFHMIN: u64 = 1 << 28;
-const RISCV_HWPROBE_EXT_ZIHINTNTL: u64 = 1 << 29;
-const RISCV_HWPROBE_EXT_ZVFH: u64 = 1 << 30;
-const RISCV_HWPROBE_EXT_ZVFHMIN: u64 = 1 << 31;
-const RISCV_HWPROBE_EXT_ZFA: u64 = 1 << 32;
-const RISCV_HWPROBE_EXT_ZTSO: u64 = 1 << 33;
-const RISCV_HWPROBE_EXT_ZACAS: u64 = 1 << 34;
-const RISCV_HWPROBE_EXT_ZICOND: u64 = 1 << 35;
-const RISCV_HWPROBE_EXT_ZIHINTPAUSE: u64 = 1 << 36;
-const RISCV_HWPROBE_EXT_ZVE32X: u64 = 1 << 37;
-const RISCV_HWPROBE_EXT_ZVE32F: u64 = 1 << 38;
-const RISCV_HWPROBE_EXT_ZVE64X: u64 = 1 << 39;
-const RISCV_HWPROBE_EXT_ZVE64F: u64 = 1 << 40;
-const RISCV_HWPROBE_EXT_ZVE64D: u64 = 1 << 41;
-const RISCV_HWPROBE_EXT_ZIMOP: u64 = 1 << 42;
-const RISCV_HWPROBE_EXT_ZCA: u64 = 1 << 43;
-const RISCV_HWPROBE_EXT_ZCB: u64 = 1 << 44;
-const RISCV_HWPROBE_EXT_ZCD: u64 = 1 << 45;
-const RISCV_HWPROBE_EXT_ZCF: u64 = 1 << 46;
-const RISCV_HWPROBE_EXT_ZCMOP: u64 = 1 << 47;
-const RISCV_HWPROBE_EXT_ZAWRS: u64 = 1 << 48;
-// Excluded because it only reports the existence of `prctl`-based pointer masking control.
-// const RISCV_HWPROBE_EXT_SUPM: u64 = 1 << 49;
-const RISCV_HWPROBE_EXT_ZICNTR: u64 = 1 << 50;
-const RISCV_HWPROBE_EXT_ZIHPM: u64 = 1 << 51;
-const RISCV_HWPROBE_EXT_ZFBFMIN: u64 = 1 << 52;
-const RISCV_HWPROBE_EXT_ZVFBFMIN: u64 = 1 << 53;
-const RISCV_HWPROBE_EXT_ZVFBFWMA: u64 = 1 << 54;
-const RISCV_HWPROBE_EXT_ZICBOM: u64 = 1 << 55;
-const RISCV_HWPROBE_EXT_ZAAMO: u64 = 1 << 56;
-const RISCV_HWPROBE_EXT_ZALRSC: u64 = 1 << 57;
-
-const RISCV_HWPROBE_KEY_CPUPERF_0: i64 = 5;
-const RISCV_HWPROBE_MISALIGNED_FAST: u64 = 3;
-const RISCV_HWPROBE_MISALIGNED_MASK: u64 = 7;
-
-const RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF: i64 = 9;
-const RISCV_HWPROBE_MISALIGNED_SCALAR_FAST: u64 = 3;
-
-const RISCV_HWPROBE_KEY_MISALIGNED_VECTOR_PERF: i64 = 10;
-const RISCV_HWPROBE_MISALIGNED_VECTOR_FAST: u64 = 3;
-
-// syscall returns an unsupported error if riscv_hwprobe is not supported,
-// so we can safely use this function on older versions of Linux.
-fn _riscv_hwprobe(out: &mut [riscv_hwprobe]) -> bool {
-    unsafe fn __riscv_hwprobe(
-        pairs: *mut riscv_hwprobe,
-        pair_count: libc::size_t,
-        cpu_set_size: libc::size_t,
-        cpus: *mut libc::c_ulong,
-        flags: libc::c_uint,
-    ) -> libc::c_long {
-        unsafe {
-            libc::syscall(
-                __NR_riscv_hwprobe,
-                pairs,
-                pair_count,
-                cpu_set_size,
-                cpus,
-                flags,
-            )
-        }
-    }
-
-    unsafe { __riscv_hwprobe(out.as_mut_ptr(), out.len(), 0, ptr::null_mut(), 0) == 0 }
-}
-
-/// Read list of supported features from (1) the auxiliary vector
-/// and (2) the results of `riscv_hwprobe` and `prctl` system calls.
-pub(crate) fn detect_features() -> cache::Initializer {
-    let mut value = cache::Initializer::default();
-    let mut enable_feature = |feature, enable| {
-        if enable {
-            value.set(feature as u32);
-        }
-    };
-
-    // Use auxiliary vector to enable single-letter ISA extensions.
-    // The values are part of the platform-specific [asm/hwcap.h][hwcap]
-    //
-    // [hwcap]: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/riscv/include/uapi/asm/hwcap.h?h=v6.15
-    let auxv = auxvec::auxv().expect("read auxvec"); // should not fail on RISC-V platform
-    let mut has_i = bit::test(auxv.hwcap, (b'i' - b'a').into());
-    #[allow(clippy::eq_op)]
-    enable_feature(Feature::a, bit::test(auxv.hwcap, (b'a' - b'a').into()));
-    enable_feature(Feature::c, bit::test(auxv.hwcap, (b'c' - b'a').into()));
-    enable_feature(Feature::d, bit::test(auxv.hwcap, (b'd' - b'a').into()));
-    enable_feature(Feature::f, bit::test(auxv.hwcap, (b'f' - b'a').into()));
-    enable_feature(Feature::m, bit::test(auxv.hwcap, (b'm' - b'a').into()));
-    let has_v = bit::test(auxv.hwcap, (b'v' - b'a').into());
-    let mut is_v_set = false;
-
-    // Use riscv_hwprobe syscall to query more extensions and
-    // performance-related capabilities.
-    'hwprobe: {
-        macro_rules! init {
-            { $($name: ident : $key: expr),* $(,)? } => {
-                #[repr(usize)]
-                enum Indices { $($name),* }
-                let mut t = [$(riscv_hwprobe { key: $key, value: 0 }),*];
-                macro_rules! data_mut { () => { &mut t } }
-                macro_rules! query { [$idx: ident] => { t[Indices::$idx as usize].get() } }
-            }
-        }
-        init! {
-            BaseBehavior: RISCV_HWPROBE_KEY_BASE_BEHAVIOR,
-            Extensions:   RISCV_HWPROBE_KEY_IMA_EXT_0,
-            MisalignedScalarPerf: RISCV_HWPROBE_KEY_MISALIGNED_SCALAR_PERF,
-            MisalignedVectorPerf: RISCV_HWPROBE_KEY_MISALIGNED_VECTOR_PERF,
-            MisalignedScalarPerfFallback: RISCV_HWPROBE_KEY_CPUPERF_0,
-        };
-        if !_riscv_hwprobe(data_mut!()) {
-            break 'hwprobe;
-        }
-
-        // Query scalar misaligned behavior.
-        if let Some(value) = query![MisalignedScalarPerf] {
-            enable_feature(
-                Feature::unaligned_scalar_mem,
-                value == RISCV_HWPROBE_MISALIGNED_SCALAR_FAST,
-            );
-        } else if let Some(value) = query![MisalignedScalarPerfFallback] {
-            // Deprecated method for fallback
-            enable_feature(
-                Feature::unaligned_scalar_mem,
-                value & RISCV_HWPROBE_MISALIGNED_MASK == RISCV_HWPROBE_MISALIGNED_FAST,
-            );
-        }
-
-        // Query vector misaligned behavior.
-        if let Some(value) = query![MisalignedVectorPerf] {
-            enable_feature(
-                Feature::unaligned_vector_mem,
-                value == RISCV_HWPROBE_MISALIGNED_VECTOR_FAST,
-            );
-        }
-
-        // Query whether "I" base and extensions "M" and "A" (as in the ISA
-        // manual version 2.2) are enabled.  "I" base at that time corresponds
-        // to "I", "Zicsr", "Zicntr" and "Zifencei" (as in the ISA manual version
-        // 20240411).
-        // This is a current requirement of
-        // `RISCV_HWPROBE_KEY_IMA_EXT_0`-based tests.
-        if query![BaseBehavior].is_none_or(|value| value & RISCV_HWPROBE_BASE_BEHAVIOR_IMA == 0) {
-            break 'hwprobe;
-        }
-        has_i = true;
-        enable_feature(Feature::zicsr, true);
-        enable_feature(Feature::zicntr, true);
-        enable_feature(Feature::zifencei, true);
-        enable_feature(Feature::m, true);
-        enable_feature(Feature::a, true);
-
-        // Enable features based on `RISCV_HWPROBE_KEY_IMA_EXT_0`.
-        let Some(ima_ext_0) = query![Extensions] else {
-            break 'hwprobe;
-        };
-        let test = |mask| (ima_ext_0 & mask) != 0;
-
-        enable_feature(Feature::d, test(RISCV_HWPROBE_IMA_FD)); // F is implied.
-        enable_feature(Feature::c, test(RISCV_HWPROBE_IMA_C));
-
-        enable_feature(Feature::zicntr, test(RISCV_HWPROBE_EXT_ZICNTR));
-        enable_feature(Feature::zihpm, test(RISCV_HWPROBE_EXT_ZIHPM));
-
-        enable_feature(Feature::zihintntl, test(RISCV_HWPROBE_EXT_ZIHINTNTL));
-        enable_feature(Feature::zihintpause, test(RISCV_HWPROBE_EXT_ZIHINTPAUSE));
-        enable_feature(Feature::zimop, test(RISCV_HWPROBE_EXT_ZIMOP));
-        enable_feature(Feature::zicbom, test(RISCV_HWPROBE_EXT_ZICBOM));
-        enable_feature(Feature::zicboz, test(RISCV_HWPROBE_EXT_ZICBOZ));
-        enable_feature(Feature::zicond, test(RISCV_HWPROBE_EXT_ZICOND));
-
-        enable_feature(Feature::zalrsc, test(RISCV_HWPROBE_EXT_ZALRSC));
-        enable_feature(Feature::zaamo, test(RISCV_HWPROBE_EXT_ZAAMO));
-        enable_feature(Feature::zawrs, test(RISCV_HWPROBE_EXT_ZAWRS));
-        enable_feature(Feature::zacas, test(RISCV_HWPROBE_EXT_ZACAS));
-        enable_feature(Feature::ztso, test(RISCV_HWPROBE_EXT_ZTSO));
-
-        enable_feature(Feature::zba, test(RISCV_HWPROBE_EXT_ZBA));
-        enable_feature(Feature::zbb, test(RISCV_HWPROBE_EXT_ZBB));
-        enable_feature(Feature::zbs, test(RISCV_HWPROBE_EXT_ZBS));
-        enable_feature(Feature::zbc, test(RISCV_HWPROBE_EXT_ZBC));
-
-        enable_feature(Feature::zbkb, test(RISCV_HWPROBE_EXT_ZBKB));
-        enable_feature(Feature::zbkc, test(RISCV_HWPROBE_EXT_ZBKC));
-        enable_feature(Feature::zbkx, test(RISCV_HWPROBE_EXT_ZBKX));
-        enable_feature(Feature::zknd, test(RISCV_HWPROBE_EXT_ZKND));
-        enable_feature(Feature::zkne, test(RISCV_HWPROBE_EXT_ZKNE));
-        enable_feature(Feature::zknh, test(RISCV_HWPROBE_EXT_ZKNH));
-        enable_feature(Feature::zksed, test(RISCV_HWPROBE_EXT_ZKSED));
-        enable_feature(Feature::zksh, test(RISCV_HWPROBE_EXT_ZKSH));
-        enable_feature(Feature::zkt, test(RISCV_HWPROBE_EXT_ZKT));
-
-        enable_feature(Feature::zcmop, test(RISCV_HWPROBE_EXT_ZCMOP));
-        enable_feature(Feature::zca, test(RISCV_HWPROBE_EXT_ZCA));
-        enable_feature(Feature::zcf, test(RISCV_HWPROBE_EXT_ZCF));
-        enable_feature(Feature::zcd, test(RISCV_HWPROBE_EXT_ZCD));
-        enable_feature(Feature::zcb, test(RISCV_HWPROBE_EXT_ZCB));
-
-        enable_feature(Feature::zfh, test(RISCV_HWPROBE_EXT_ZFH));
-        enable_feature(Feature::zfhmin, test(RISCV_HWPROBE_EXT_ZFHMIN));
-        enable_feature(Feature::zfa, test(RISCV_HWPROBE_EXT_ZFA));
-        enable_feature(Feature::zfbfmin, test(RISCV_HWPROBE_EXT_ZFBFMIN));
-
-        // Use prctl (if any) to determine whether the vector extension
-        // is enabled on the current thread (assuming the entire process
-        // share the same status).  If prctl fails (e.g. QEMU userland emulator
-        // as of version 9.2.3), use auxiliary vector to retrieve the default
-        // vector status on the process startup.
-        let has_vectors = {
-            let v_status = unsafe { libc::prctl(PR_RISCV_V_GET_CONTROL) };
-            if v_status >= 0 {
-                (v_status & PR_RISCV_V_VSTATE_CTRL_CUR_MASK) == PR_RISCV_V_VSTATE_CTRL_ON
-            } else {
-                has_v
-            }
-        };
-        if has_vectors {
-            enable_feature(Feature::v, test(RISCV_HWPROBE_IMA_V));
-            enable_feature(Feature::zve32x, test(RISCV_HWPROBE_EXT_ZVE32X));
-            enable_feature(Feature::zve32f, test(RISCV_HWPROBE_EXT_ZVE32F));
-            enable_feature(Feature::zve64x, test(RISCV_HWPROBE_EXT_ZVE64X));
-            enable_feature(Feature::zve64f, test(RISCV_HWPROBE_EXT_ZVE64F));
-            enable_feature(Feature::zve64d, test(RISCV_HWPROBE_EXT_ZVE64D));
-
-            enable_feature(Feature::zvbb, test(RISCV_HWPROBE_EXT_ZVBB));
-            enable_feature(Feature::zvbc, test(RISCV_HWPROBE_EXT_ZVBC));
-            enable_feature(Feature::zvkb, test(RISCV_HWPROBE_EXT_ZVKB));
-            enable_feature(Feature::zvkg, test(RISCV_HWPROBE_EXT_ZVKG));
-            enable_feature(Feature::zvkned, test(RISCV_HWPROBE_EXT_ZVKNED));
-            enable_feature(Feature::zvknha, test(RISCV_HWPROBE_EXT_ZVKNHA));
-            enable_feature(Feature::zvknhb, test(RISCV_HWPROBE_EXT_ZVKNHB));
-            enable_feature(Feature::zvksed, test(RISCV_HWPROBE_EXT_ZVKSED));
-            enable_feature(Feature::zvksh, test(RISCV_HWPROBE_EXT_ZVKSH));
-            enable_feature(Feature::zvkt, test(RISCV_HWPROBE_EXT_ZVKT));
-
-            enable_feature(Feature::zvfh, test(RISCV_HWPROBE_EXT_ZVFH));
-            enable_feature(Feature::zvfhmin, test(RISCV_HWPROBE_EXT_ZVFHMIN));
-            enable_feature(Feature::zvfbfmin, test(RISCV_HWPROBE_EXT_ZVFBFMIN));
-            enable_feature(Feature::zvfbfwma, test(RISCV_HWPROBE_EXT_ZVFBFWMA));
-        }
-        is_v_set = true;
-    };
-
-    // Set V purely depending on the auxiliary vector
-    // only if no fine-grained vector extension detection is available.
-    if !is_v_set {
-        enable_feature(Feature::v, has_v);
-    }
-
-    // Handle base ISA.
-    // If future RV128I is supported, implement with `enable_feature` here.
-    // Note that we should use `target_arch` instead of `target_pointer_width`
-    // to avoid misdetection caused by experimental ABIs such as RV64ILP32.
-    #[cfg(target_arch = "riscv64")]
-    enable_feature(Feature::rv64i, has_i);
-    #[cfg(target_arch = "riscv32")]
-    enable_feature(Feature::rv32i, has_i);
-
-    imply_features(value)
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/linux/s390x.rs b/library/stdarch/crates/std_detect/src/detect/os/linux/s390x.rs
deleted file mode 100644
index 9b53f526d61..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/linux/s390x.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-//! Run-time feature detection for s390x on Linux.
-
-use super::auxvec;
-use crate::detect::{Feature, bit, cache};
-
-/// Try to read the features from the auxiliary vector
-pub(crate) fn detect_features() -> cache::Initializer {
-    let opt_hwcap: Option<AtHwcap> = auxvec::auxv().ok().map(Into::into);
-    let facilities = ExtendedFacilityList::new();
-    cache(opt_hwcap, facilities)
-}
-
-#[derive(Debug, Default, PartialEq)]
-struct AtHwcap {
-    esan3: bool,
-    zarch: bool,
-    stfle: bool,
-    msa: bool,
-    ldisp: bool,
-    eimm: bool,
-    dfp: bool,
-    hpage: bool,
-    etf3eh: bool,
-    high_gprs: bool,
-    te: bool,
-    vxrs: bool,
-    vxrs_bcd: bool,
-    vxrs_ext: bool,
-    gs: bool,
-    vxrs_ext2: bool,
-    vxrs_pde: bool,
-    sort: bool,
-    dflt: bool,
-    vxrs_pde2: bool,
-    nnpa: bool,
-    pci_mio: bool,
-    sie: bool,
-}
-
-impl From<auxvec::AuxVec> for AtHwcap {
-    /// Reads AtHwcap from the auxiliary vector.
-    fn from(auxv: auxvec::AuxVec) -> Self {
-        AtHwcap {
-            esan3: bit::test(auxv.hwcap, 0),
-            zarch: bit::test(auxv.hwcap, 1),
-            stfle: bit::test(auxv.hwcap, 2),
-            msa: bit::test(auxv.hwcap, 3),
-            ldisp: bit::test(auxv.hwcap, 4),
-            eimm: bit::test(auxv.hwcap, 5),
-            dfp: bit::test(auxv.hwcap, 6),
-            hpage: bit::test(auxv.hwcap, 7),
-            etf3eh: bit::test(auxv.hwcap, 8),
-            high_gprs: bit::test(auxv.hwcap, 9),
-            te: bit::test(auxv.hwcap, 10),
-            vxrs: bit::test(auxv.hwcap, 11),
-            vxrs_bcd: bit::test(auxv.hwcap, 12),
-            vxrs_ext: bit::test(auxv.hwcap, 13),
-            gs: bit::test(auxv.hwcap, 14),
-            vxrs_ext2: bit::test(auxv.hwcap, 15),
-            vxrs_pde: bit::test(auxv.hwcap, 16),
-            sort: bit::test(auxv.hwcap, 17),
-            dflt: bit::test(auxv.hwcap, 18),
-            vxrs_pde2: bit::test(auxv.hwcap, 19),
-            nnpa: bit::test(auxv.hwcap, 20),
-            pci_mio: bit::test(auxv.hwcap, 21),
-            sie: bit::test(auxv.hwcap, 22),
-        }
-    }
-}
-
-struct ExtendedFacilityList([u64; 4]);
-
-impl ExtendedFacilityList {
-    fn new() -> Self {
-        let mut result: [u64; 4] = [0; 4];
-        // SAFETY: rust/llvm only support s390x version with the `stfle` instruction.
-        unsafe {
-            core::arch::asm!(
-                // equivalently ".insn s, 0xb2b00000, 0({1})",
-                "stfle 0({})",
-                in(reg_addr) result.as_mut_ptr() ,
-                inout("r0") result.len() as u64 - 1 => _,
-                options(nostack)
-            );
-        }
-        Self(result)
-    }
-
-    const fn get_bit(&self, n: usize) -> bool {
-        // NOTE: bits are numbered from the left.
-        self.0[n / 64] & (1 << (63 - (n % 64))) != 0
-    }
-}
-
-/// Initializes the cache from the feature bits.
-///
-/// These values are part of the platform-specific [asm/elf.h][kernel], and are a selection of the
-/// fields found in the [Facility Indications].
-///
-/// [Facility Indications]: https://www.ibm.com/support/pages/sites/default/files/2021-05/SA22-7871-10.pdf#page=63
-/// [kernel]: https://github.com/torvalds/linux/blob/b62cef9a5c673f1b8083159f5dc03c1c5daced2f/arch/s390/include/asm/elf.h#L129
-fn cache(hwcap: Option<AtHwcap>, facilities: ExtendedFacilityList) -> cache::Initializer {
-    let mut value = cache::Initializer::default();
-
-    {
-        let mut enable_if_set = |bit_index, f| {
-            if facilities.get_bit(bit_index) {
-                value.set(f as u32);
-            }
-        };
-
-        // We use HWCAP for `vector` because it requires both hardware and kernel support.
-        if let Some(AtHwcap { vxrs: true, .. }) = hwcap {
-            // vector and related
-
-            enable_if_set(129, Feature::vector);
-
-            enable_if_set(135, Feature::vector_enhancements_1);
-            enable_if_set(148, Feature::vector_enhancements_2);
-            enable_if_set(198, Feature::vector_enhancements_3);
-
-            enable_if_set(134, Feature::vector_packed_decimal);
-            enable_if_set(152, Feature::vector_packed_decimal_enhancement);
-            enable_if_set(192, Feature::vector_packed_decimal_enhancement_2);
-            enable_if_set(199, Feature::vector_packed_decimal_enhancement_3);
-
-            enable_if_set(165, Feature::nnp_assist);
-        }
-
-        // others
-
-        enable_if_set(76, Feature::message_security_assist_extension3);
-        enable_if_set(77, Feature::message_security_assist_extension4);
-        enable_if_set(57, Feature::message_security_assist_extension5);
-        enable_if_set(146, Feature::message_security_assist_extension8);
-        enable_if_set(155, Feature::message_security_assist_extension9);
-        enable_if_set(86, Feature::message_security_assist_extension12);
-
-        enable_if_set(58, Feature::miscellaneous_extensions_2);
-        enable_if_set(61, Feature::miscellaneous_extensions_3);
-        enable_if_set(84, Feature::miscellaneous_extensions_4);
-
-        enable_if_set(45, Feature::high_word);
-        enable_if_set(73, Feature::transactional_execution);
-        enable_if_set(133, Feature::guarded_storage);
-        enable_if_set(150, Feature::enhanced_sort);
-        enable_if_set(151, Feature::deflate_conversion);
-        enable_if_set(201, Feature::concurrent_functions);
-    }
-
-    value
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/openbsd/aarch64.rs b/library/stdarch/crates/std_detect/src/detect/os/openbsd/aarch64.rs
deleted file mode 100644
index cfe4ad10ad6..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/openbsd/aarch64.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//! Run-time feature detection for Aarch64 on OpenBSD.
-//!
-//! OpenBSD doesn't trap the mrs instruction, but exposes the system registers through sysctl.
-//! https://github.com/openbsd/src/commit/d335af936b9d7dd9cf655cae1ce19560c45de6c8
-//! https://github.com/golang/go/commit/cd54ef1f61945459486e9eea2f016d99ef1da925
-
-use crate::detect::cache;
-use core::{mem::MaybeUninit, ptr};
-
-// Defined in machine/cpu.h.
-// https://github.com/openbsd/src/blob/72ccc03bd11da614f31f7ff76e3f6fce99bc1c79/sys/arch/arm64/include/cpu.h#L25-L40
-const CPU_ID_AA64ISAR0: libc::c_int = 2;
-const CPU_ID_AA64ISAR1: libc::c_int = 3;
-const CPU_ID_AA64MMFR2: libc::c_int = 7;
-const CPU_ID_AA64PFR0: libc::c_int = 8;
-
-/// Try to read the features from the system registers.
-pub(crate) fn detect_features() -> cache::Initializer {
-    // ID_AA64ISAR0_EL1 and ID_AA64ISAR1_EL1 are supported on OpenBSD 7.1+.
-    // https://github.com/openbsd/src/commit/d335af936b9d7dd9cf655cae1ce19560c45de6c8
-    // Others are supported on OpenBSD 7.3+.
-    // https://github.com/openbsd/src/commit/c7654cd65262d532212f65123ee3905ba200365c
-    // sysctl returns an unsupported error if operation is not supported,
-    // so we can safely use this function on older versions of OpenBSD.
-    let aa64isar0 = sysctl64(&[libc::CTL_MACHDEP, CPU_ID_AA64ISAR0]).unwrap_or(0);
-    let aa64isar1 = sysctl64(&[libc::CTL_MACHDEP, CPU_ID_AA64ISAR1]).unwrap_or(0);
-    let aa64mmfr2 = sysctl64(&[libc::CTL_MACHDEP, CPU_ID_AA64MMFR2]).unwrap_or(0);
-    // Do not use unwrap_or(0) because in fp and asimd fields, 0 indicates that
-    // the feature is available.
-    let aa64pfr0 = sysctl64(&[libc::CTL_MACHDEP, CPU_ID_AA64PFR0]);
-
-    super::aarch64::parse_system_registers(aa64isar0, aa64isar1, aa64mmfr2, aa64pfr0)
-}
-
-#[inline]
-fn sysctl64(mib: &[libc::c_int]) -> Option<u64> {
-    const OUT_LEN: libc::size_t = core::mem::size_of::<u64>();
-    let mut out = MaybeUninit::<u64>::uninit();
-    let mut out_len = OUT_LEN;
-    let res = unsafe {
-        libc::sysctl(
-            mib.as_ptr(),
-            mib.len() as libc::c_uint,
-            out.as_mut_ptr() as *mut libc::c_void,
-            &mut out_len,
-            ptr::null_mut(),
-            0,
-        )
-    };
-    if res == -1 || out_len != OUT_LEN {
-        return None;
-    }
-    // SAFETY: we've checked that sysctl was successful and `out` was filled.
-    Some(unsafe { out.assume_init() })
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/other.rs b/library/stdarch/crates/std_detect/src/detect/os/other.rs
deleted file mode 100644
index 091fafc4ebf..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/other.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//! Other operating systems
-
-use crate::detect::cache;
-
-#[allow(dead_code)]
-pub(crate) fn detect_features() -> cache::Initializer {
-    cache::Initializer::default()
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/riscv.rs b/library/stdarch/crates/std_detect/src/detect/os/riscv.rs
deleted file mode 100644
index 4c59ede8029..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/riscv.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-//! Run-time feature detection utility for RISC-V.
-//!
-//! On RISC-V, full feature detection needs a help of one or more
-//! feature detection mechanisms (usually provided by the operating system).
-//!
-//! RISC-V architecture defines many extensions and some have dependency to others.
-//! More importantly, some of them cannot be enabled without resolving such
-//! dependencies due to limited set of features that such mechanisms provide.
-//!
-//! This module provides an OS-independent utility to process such relations
-//! between RISC-V extensions.
-
-use crate::detect::{Feature, cache};
-
-/// Imply features by the given set of enabled features.
-///
-/// Note that it does not perform any consistency checks including existence of
-/// conflicting extensions and/or complicated requirements.  Eliminating such
-/// inconsistencies is the responsibility of the feature detection logic and
-/// its provider(s).
-pub(crate) fn imply_features(mut value: cache::Initializer) -> cache::Initializer {
-    loop {
-        // Check convergence of the feature flags later.
-        let prev = value;
-
-        // Expect that the optimizer turns repeated operations into
-        // a fewer number of bit-manipulation operations.
-        macro_rules! imply {
-            // Regular implication:
-            // A1 => (B1[, B2...]), A2 => (B1[, B2...]) and so on.
-            ($($from: ident)|+ => $($to: ident)&+) => {
-                if [$(Feature::$from as u32),+].iter().any(|&x| value.test(x)) {
-                    $(
-                        value.set(Feature::$to as u32);
-                    )+
-                }
-            };
-            // Implication with multiple requirements:
-            // A1 && A2 ... => (B1[, B2...]).
-            ($($from: ident)&+ => $($to: ident)&+) => {
-                if [$(Feature::$from as u32),+].iter().all(|&x| value.test(x)) {
-                    $(
-                        value.set(Feature::$to as u32);
-                    )+
-                }
-            };
-        }
-        macro_rules! group {
-            ($group: ident == $($member: ident)&+) => {
-                // Forward implication as defined in the specifications.
-                imply!($group => $($member)&+);
-                // Reverse implication to "group extension" from its members.
-                // This is not a part of specifications but convenient for
-                // feature detection and implemented in e.g. LLVM.
-                imply!($($member)&+ => $group);
-            };
-        }
-
-        /*
-            If a dependency/implication is not explicitly stated in the
-            specification, it is denoted as a comment as follows:
-            "defined as subset":
-                The latter extension is described as a subset of the former
-                (but the evidence is weak).
-            "functional":
-                The former extension is functionally a superset of the latter
-                (no direct references though).
-        */
-
-        imply!(zvbb => zvkb);
-
-        // Certain set of vector cryptography extensions form a group.
-        group!(zvkn == zvkned & zvknhb & zvkb & zvkt);
-        group!(zvknc == zvkn & zvbc);
-        group!(zvkng == zvkn & zvkg);
-        group!(zvks == zvksed & zvksh & zvkb & zvkt);
-        group!(zvksc == zvks & zvbc);
-        group!(zvksg == zvks & zvkg);
-
-        imply!(zvknhb => zvknha); // functional
-
-        // For vector cryptography, Zvknhb and Zvbc require integer arithmetic
-        // with EEW=64 (Zve64x) while others not depending on them
-        // require EEW=32 (Zve32x).
-        imply!(zvknhb | zvbc => zve64x);
-        imply!(zvbb | zvkb | zvkg | zvkned | zvknha | zvksed | zvksh => zve32x);
-
-        imply!(zbc => zbkc); // defined as subset
-        group!(zkn == zbkb & zbkc & zbkx & zkne & zknd & zknh);
-        group!(zks == zbkb & zbkc & zbkx & zksed & zksh);
-        group!(zk == zkn & zkr & zkt);
-
-        imply!(zacas => zaamo);
-        group!(a == zalrsc & zaamo);
-
-        group!(b == zba & zbb & zbs);
-
-        imply!(zcf => zca & f);
-        imply!(zcd => zca & d);
-        imply!(zcmop | zcb => zca);
-
-        imply!(zhinx => zhinxmin);
-        imply!(zdinx | zhinxmin => zfinx);
-
-        imply!(zvfh => zvfhmin); // functional
-        imply!(zvfh => zve32f & zfhmin);
-        imply!(zvfhmin => zve32f);
-        imply!(zvfbfwma => zvfbfmin & zfbfmin);
-        imply!(zvfbfmin => zve32f);
-
-        imply!(v => zve64d);
-        imply!(zve64d => zve64f & d);
-        imply!(zve64f => zve64x & zve32f);
-        imply!(zve64x => zve32x);
-        imply!(zve32f => zve32x & f);
-
-        imply!(zfh => zfhmin);
-        imply!(q => d);
-        imply!(d | zfhmin | zfa => f);
-        imply!(zfbfmin => f); // and some of (not all) "Zfh" instructions.
-
-        // Relatively complex implication rules from the "C" extension.
-        imply!(c => zca);
-        imply!(c & d => zcd);
-        #[cfg(target_arch = "riscv32")]
-        imply!(c & f => zcf);
-
-        imply!(zicntr | zihpm | f | zfinx | zve32x => zicsr);
-
-        // Loop until the feature flags converge.
-        if prev == value {
-            return value;
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn simple_direct() {
-        let mut value = cache::Initializer::default();
-        value.set(Feature::f as u32);
-        // F (and other extensions with CSRs) -> Zicsr
-        assert!(imply_features(value).test(Feature::zicsr as u32));
-    }
-
-    #[test]
-    fn simple_indirect() {
-        let mut value = cache::Initializer::default();
-        value.set(Feature::q as u32);
-        // Q -> D, D -> F, F -> Zicsr
-        assert!(imply_features(value).test(Feature::zicsr as u32));
-    }
-
-    #[test]
-    fn complex_zcd() {
-        let mut value = cache::Initializer::default();
-        // C & D -> Zcd
-        value.set(Feature::c as u32);
-        assert!(!imply_features(value).test(Feature::zcd as u32));
-        value.set(Feature::d as u32);
-        assert!(imply_features(value).test(Feature::zcd as u32));
-    }
-
-    #[test]
-    fn group_simple_forward() {
-        let mut value = cache::Initializer::default();
-        // A -> Zalrsc & Zaamo (forward implication)
-        value.set(Feature::a as u32);
-        let value = imply_features(value);
-        assert!(value.test(Feature::zalrsc as u32));
-        assert!(value.test(Feature::zaamo as u32));
-    }
-
-    #[test]
-    fn group_simple_backward() {
-        let mut value = cache::Initializer::default();
-        // Zalrsc & Zaamo -> A (reverse implication)
-        value.set(Feature::zalrsc as u32);
-        value.set(Feature::zaamo as u32);
-        assert!(imply_features(value).test(Feature::a as u32));
-    }
-
-    #[test]
-    fn group_complex_convergence() {
-        let mut value = cache::Initializer::default();
-        // Needs 3 iterations to converge
-        // (and 4th iteration for convergence checking):
-        // 1.  [Zvksc] -> Zvks & Zvbc
-        // 2.  Zvks -> Zvksed & Zvksh & Zvkb & Zvkt
-        // 3a. [Zvkned] & [Zvknhb] & [Zvkb] & Zvkt -> {Zvkn}
-        // 3b. Zvkn & Zvbc -> {Zvknc}
-        value.set(Feature::zvksc as u32);
-        value.set(Feature::zvkned as u32);
-        value.set(Feature::zvknhb as u32);
-        value.set(Feature::zvkb as u32);
-        let value = imply_features(value);
-        assert!(value.test(Feature::zvkn as u32));
-        assert!(value.test(Feature::zvknc as u32));
-    }
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/windows/aarch64.rs b/library/stdarch/crates/std_detect/src/detect/os/windows/aarch64.rs
deleted file mode 100644
index 937f9f26eed..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/windows/aarch64.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-//! Run-time feature detection for Aarch64 on Windows.
-
-use crate::detect::{Feature, cache};
-
-/// Try to read the features using IsProcessorFeaturePresent.
-pub(crate) fn detect_features() -> cache::Initializer {
-    type DWORD = u32;
-    type BOOL = i32;
-
-    const FALSE: BOOL = 0;
-    // The following Microsoft documents isn't updated for aarch64.
-    // https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-isprocessorfeaturepresent
-    // These are defined in winnt.h of Windows SDK
-    const PF_ARM_VFP_32_REGISTERS_AVAILABLE: u32 = 18;
-    const PF_ARM_NEON_INSTRUCTIONS_AVAILABLE: u32 = 19;
-    const PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE: u32 = 30;
-    const PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE: u32 = 31;
-    const PF_ARM_V81_ATOMIC_INSTRUCTIONS_AVAILABLE: u32 = 34;
-    const PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE: u32 = 43;
-    const PF_ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE: u32 = 44;
-    const PF_ARM_V83_LRCPC_INSTRUCTIONS_AVAILABLE: u32 = 45;
-    const PF_ARM_SVE_INSTRUCTIONS_AVAILABLE: u32 = 46;
-    const PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE: u32 = 47;
-    const PF_ARM_SVE2_1_INSTRUCTIONS_AVAILABLE: u32 = 48;
-    const PF_ARM_SVE_AES_INSTRUCTIONS_AVAILABLE: u32 = 49;
-    const PF_ARM_SVE_PMULL128_INSTRUCTIONS_AVAILABLE: u32 = 50;
-    const PF_ARM_SVE_BITPERM_INSTRUCTIONS_AVAILABLE: u32 = 51;
-    // const PF_ARM_SVE_BF16_INSTRUCTIONS_AVAILABLE: u32 = 52;
-    // const PF_ARM_SVE_EBF16_INSTRUCTIONS_AVAILABLE: u32 = 53;
-    const PF_ARM_SVE_B16B16_INSTRUCTIONS_AVAILABLE: u32 = 54;
-    const PF_ARM_SVE_SHA3_INSTRUCTIONS_AVAILABLE: u32 = 55;
-    const PF_ARM_SVE_SM4_INSTRUCTIONS_AVAILABLE: u32 = 56;
-    // const PF_ARM_SVE_I8MM_INSTRUCTIONS_AVAILABLE: u32 = 57;
-    // const PF_ARM_SVE_F32MM_INSTRUCTIONS_AVAILABLE: u32 = 58;
-    // const PF_ARM_SVE_F64MM_INSTRUCTIONS_AVAILABLE: u32 = 59;
-
-    unsafe extern "system" {
-        fn IsProcessorFeaturePresent(ProcessorFeature: DWORD) -> BOOL;
-    }
-
-    let mut value = cache::Initializer::default();
-    {
-        let mut enable_feature = |f, enable| {
-            if enable {
-                value.set(f as u32);
-            }
-        };
-
-        // Some features may be supported on current CPU,
-        // but no way to detect it by OS API.
-        // Also, we require unsafe block for the extern "system" calls.
-        unsafe {
-            enable_feature(
-                Feature::fp,
-                IsProcessorFeaturePresent(PF_ARM_VFP_32_REGISTERS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::asimd,
-                IsProcessorFeaturePresent(PF_ARM_NEON_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::crc,
-                IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::lse,
-                IsProcessorFeaturePresent(PF_ARM_V81_ATOMIC_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::dotprod,
-                IsProcessorFeaturePresent(PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::jsconv,
-                IsProcessorFeaturePresent(PF_ARM_V83_JSCVT_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::rcpc,
-                IsProcessorFeaturePresent(PF_ARM_V83_LRCPC_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::sve,
-                IsProcessorFeaturePresent(PF_ARM_SVE_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::sve2,
-                IsProcessorFeaturePresent(PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::sve2p1,
-                IsProcessorFeaturePresent(PF_ARM_SVE2_1_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::sve2_aes,
-                IsProcessorFeaturePresent(PF_ARM_SVE_AES_INSTRUCTIONS_AVAILABLE) != FALSE
-                    && IsProcessorFeaturePresent(PF_ARM_SVE_PMULL128_INSTRUCTIONS_AVAILABLE)
-                        != FALSE,
-            );
-            enable_feature(
-                Feature::sve2_bitperm,
-                IsProcessorFeaturePresent(PF_ARM_SVE_BITPERM_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::sve_b16b16,
-                IsProcessorFeaturePresent(PF_ARM_SVE_B16B16_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::sve2_sha3,
-                IsProcessorFeaturePresent(PF_ARM_SVE_SHA3_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            enable_feature(
-                Feature::sve2_sm4,
-                IsProcessorFeaturePresent(PF_ARM_SVE_SM4_INSTRUCTIONS_AVAILABLE) != FALSE,
-            );
-            // PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE means aes, sha1, sha2 and
-            // pmull support
-            let crypto =
-                IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE) != FALSE;
-            enable_feature(Feature::aes, crypto);
-            enable_feature(Feature::pmull, crypto);
-            enable_feature(Feature::sha2, crypto);
-        }
-    }
-    value
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/os/x86.rs b/library/stdarch/crates/std_detect/src/detect/os/x86.rs
deleted file mode 100644
index 8565c2f85e2..00000000000
--- a/library/stdarch/crates/std_detect/src/detect/os/x86.rs
+++ /dev/null
@@ -1,335 +0,0 @@
-//! x86 run-time feature detection is OS independent.
-
-#[cfg(target_arch = "x86")]
-use core::arch::x86::*;
-#[cfg(target_arch = "x86_64")]
-use core::arch::x86_64::*;
-
-use core::mem;
-
-use crate::detect::{Feature, bit, cache};
-
-/// Run-time feature detection on x86 works by using the CPUID instruction.
-///
-/// The [CPUID Wikipedia page][wiki_cpuid] contains
-/// all the information about which flags to set to query which values, and in
-/// which registers these are reported.
-///
-/// The definitive references are:
-/// - [Intel 64 and IA-32 Architectures Software Developer's Manual Volume 2:
-///   Instruction Set Reference, A-Z][intel64_ref].
-/// - [AMD64 Architecture Programmer's Manual, Volume 3: General-Purpose and
-///   System Instructions][amd64_ref].
-///
-/// [wiki_cpuid]: https://en.wikipedia.org/wiki/CPUID
-/// [intel64_ref]: http://www.intel.de/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-instruction-set-reference-manual-325383.pdf
-/// [amd64_ref]: http://support.amd.com/TechDocs/24594.pdf
-#[allow(clippy::similar_names)]
-pub(crate) fn detect_features() -> cache::Initializer {
-    let mut value = cache::Initializer::default();
-
-    if cfg!(target_env = "sgx") {
-        // doesn't support this because it is untrusted data
-        return value;
-    }
-
-    // Calling `__cpuid`/`__cpuid_count` from here on is safe because the CPU
-    // has `cpuid` support.
-
-    // 0. EAX = 0: Basic Information:
-    // - EAX returns the "Highest Function Parameter", that is, the maximum
-    // leaf value for subsequent calls of `cpuinfo` in range [0,
-    // 0x8000_0000]. - The vendor ID is stored in 12 u8 ascii chars,
-    // returned in EBX, EDX, and   ECX (in that order):
-    let (max_basic_leaf, vendor_id) = unsafe {
-        let CpuidResult {
-            eax: max_basic_leaf,
-            ebx,
-            ecx,
-            edx,
-        } = __cpuid(0);
-        let vendor_id: [[u8; 4]; 3] = [ebx.to_ne_bytes(), edx.to_ne_bytes(), ecx.to_ne_bytes()];
-        let vendor_id: [u8; 12] = mem::transmute(vendor_id);
-        (max_basic_leaf, vendor_id)
-    };
-
-    if max_basic_leaf < 1 {
-        // Earlier Intel 486, CPUID not implemented
-        return value;
-    }
-
-    // EAX = 1, ECX = 0: Queries "Processor Info and Feature Bits";
-    // Contains information about most x86 features.
-    let CpuidResult {
-        ecx: proc_info_ecx,
-        edx: proc_info_edx,
-        ..
-    } = unsafe { __cpuid(0x0000_0001_u32) };
-
-    // EAX = 7: Queries "Extended Features";
-    // Contains information about bmi,bmi2, and avx2 support.
-    let (
-        extended_features_ebx,
-        extended_features_ecx,
-        extended_features_edx,
-        extended_features_eax_leaf_1,
-        extended_features_edx_leaf_1,
-    ) = if max_basic_leaf >= 7 {
-        let CpuidResult { ebx, ecx, edx, .. } = unsafe { __cpuid(0x0000_0007_u32) };
-        let CpuidResult {
-            eax: eax_1,
-            edx: edx_1,
-            ..
-        } = unsafe { __cpuid_count(0x0000_0007_u32, 0x0000_0001_u32) };
-        (ebx, ecx, edx, eax_1, edx_1)
-    } else {
-        (0, 0, 0, 0, 0) // CPUID does not support "Extended Features"
-    };
-
-    // EAX = 0x8000_0000, ECX = 0: Get Highest Extended Function Supported
-    // - EAX returns the max leaf value for extended information, that is,
-    // `cpuid` calls in range [0x8000_0000; u32::MAX]:
-    let CpuidResult {
-        eax: extended_max_basic_leaf,
-        ..
-    } = unsafe { __cpuid(0x8000_0000_u32) };
-
-    // EAX = 0x8000_0001, ECX=0: Queries "Extended Processor Info and Feature
-    // Bits"
-    let extended_proc_info_ecx = if extended_max_basic_leaf >= 1 {
-        let CpuidResult { ecx, .. } = unsafe { __cpuid(0x8000_0001_u32) };
-        ecx
-    } else {
-        0
-    };
-
-    {
-        // borrows value till the end of this scope:
-        let mut enable = |r, rb, f| {
-            let present = bit::test(r as usize, rb);
-            if present {
-                value.set(f as u32);
-            }
-            present
-        };
-
-        enable(proc_info_ecx, 0, Feature::sse3);
-        enable(proc_info_ecx, 1, Feature::pclmulqdq);
-        enable(proc_info_ecx, 9, Feature::ssse3);
-        enable(proc_info_ecx, 13, Feature::cmpxchg16b);
-        enable(proc_info_ecx, 19, Feature::sse4_1);
-        enable(proc_info_ecx, 20, Feature::sse4_2);
-        enable(proc_info_ecx, 22, Feature::movbe);
-        enable(proc_info_ecx, 23, Feature::popcnt);
-        enable(proc_info_ecx, 25, Feature::aes);
-        let f16c = enable(proc_info_ecx, 29, Feature::f16c);
-        enable(proc_info_ecx, 30, Feature::rdrand);
-        enable(extended_features_ebx, 18, Feature::rdseed);
-        enable(extended_features_ebx, 19, Feature::adx);
-        enable(extended_features_ebx, 11, Feature::rtm);
-        enable(proc_info_edx, 4, Feature::tsc);
-        enable(proc_info_edx, 23, Feature::mmx);
-        enable(proc_info_edx, 24, Feature::fxsr);
-        enable(proc_info_edx, 25, Feature::sse);
-        enable(proc_info_edx, 26, Feature::sse2);
-        enable(extended_features_ebx, 29, Feature::sha);
-
-        enable(extended_features_ecx, 8, Feature::gfni);
-        enable(extended_features_ecx, 9, Feature::vaes);
-        enable(extended_features_ecx, 10, Feature::vpclmulqdq);
-
-        enable(extended_features_ebx, 3, Feature::bmi1);
-        enable(extended_features_ebx, 8, Feature::bmi2);
-
-        enable(extended_features_ebx, 9, Feature::ermsb);
-
-        enable(extended_features_eax_leaf_1, 31, Feature::movrs);
-
-        // Detect if CPUID.19h available
-        if bit::test(extended_features_ecx as usize, 23) {
-            let CpuidResult { ebx, .. } = unsafe { __cpuid(0x19) };
-            enable(ebx, 0, Feature::kl);
-            enable(ebx, 2, Feature::widekl);
-        }
-
-        // `XSAVE` and `AVX` support:
-        let cpu_xsave = bit::test(proc_info_ecx as usize, 26);
-        if cpu_xsave {
-            // 0. Here the CPU supports `XSAVE`.
-
-            // 1. Detect `OSXSAVE`, that is, whether the OS is AVX enabled and
-            // supports saving the state of the AVX/AVX2 vector registers on
-            // context-switches, see:
-            //
-            // - [intel: is avx enabled?][is_avx_enabled],
-            // - [mozilla: sse.cpp][mozilla_sse_cpp].
-            //
-            // [is_avx_enabled]: https://software.intel.com/en-us/blogs/2011/04/14/is-avx-enabled
-            // [mozilla_sse_cpp]: https://hg.mozilla.org/mozilla-central/file/64bab5cbb9b6/mozglue/build/SSE.cpp#l190
-            let cpu_osxsave = bit::test(proc_info_ecx as usize, 27);
-
-            if cpu_osxsave {
-                // 2. The OS must have signaled the CPU that it supports saving and
-                // restoring the:
-                //
-                // * SSE -> `XCR0.SSE[1]`
-                // * AVX -> `XCR0.AVX[2]`
-                // * AVX-512 -> `XCR0.AVX-512[7:5]`.
-                // * AMX -> `XCR0.AMX[18:17]`
-                //
-                // by setting the corresponding bits of `XCR0` to `1`.
-                //
-                // This is safe because the CPU supports `xsave`
-                // and the OS has set `osxsave`.
-                let xcr0 = unsafe { _xgetbv(0) };
-                // Test `XCR0.SSE[1]` and `XCR0.AVX[2]` with the mask `0b110 == 6`:
-                let os_avx_support = xcr0 & 6 == 6;
-                // Test `XCR0.AVX-512[7:5]` with the mask `0b1110_0000 == 0xe0`:
-                let os_avx512_support = xcr0 & 0xe0 == 0xe0;
-                // Test `XCR0.AMX[18:17]` with the mask `0b110_0000_0000_0000_0000 == 0x60000`
-                let os_amx_support = xcr0 & 0x60000 == 0x60000;
-
-                // Only if the OS and the CPU support saving/restoring the AVX
-                // registers we enable `xsave` support:
-                if os_avx_support {
-                    // See "13.3 ENABLING THE XSAVE FEATURE SET AND XSAVE-ENABLED
-                    // FEATURES" in the "Intel® 64 and IA-32 Architectures Software
-                    // Developer’s Manual, Volume 1: Basic Architecture":
-                    //
-                    // "Software enables the XSAVE feature set by setting
-                    // CR4.OSXSAVE[bit 18] to 1 (e.g., with the MOV to CR4
-                    // instruction). If this bit is 0, execution of any of XGETBV,
-                    // XRSTOR, XRSTORS, XSAVE, XSAVEC, XSAVEOPT, XSAVES, and XSETBV
-                    // causes an invalid-opcode exception (#UD)"
-                    //
-                    enable(proc_info_ecx, 26, Feature::xsave);
-
-                    // For `xsaveopt`, `xsavec`, and `xsaves` we need to query:
-                    // Processor Extended State Enumeration Sub-leaf (EAX = 0DH,
-                    // ECX = 1):
-                    if max_basic_leaf >= 0xd {
-                        let CpuidResult {
-                            eax: proc_extended_state1_eax,
-                            ..
-                        } = unsafe { __cpuid_count(0xd_u32, 1) };
-                        enable(proc_extended_state1_eax, 0, Feature::xsaveopt);
-                        enable(proc_extended_state1_eax, 1, Feature::xsavec);
-                        enable(proc_extended_state1_eax, 3, Feature::xsaves);
-                    }
-
-                    // FMA (uses 256-bit wide registers):
-                    let fma = enable(proc_info_ecx, 12, Feature::fma);
-
-                    // And AVX/AVX2:
-                    enable(proc_info_ecx, 28, Feature::avx);
-                    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);
-                    enable(extended_features_edx_leaf_1, 5, Feature::avxneconvert);
-                    enable(extended_features_edx_leaf_1, 10, Feature::avxvnniint16);
-
-                    enable(extended_features_eax_leaf_1, 0, Feature::sha512);
-                    enable(extended_features_eax_leaf_1, 1, Feature::sm3);
-                    enable(extended_features_eax_leaf_1, 2, Feature::sm4);
-
-                    // For AVX-512 the OS also needs to support saving/restoring
-                    // the extended state, only then we enable AVX-512 support:
-                    // Also, Rust makes `avx512f` imply `fma` and `f16c`, because
-                    // otherwise the assembler is broken. But Intel doesn't guarantee
-                    // that `fma` and `f16c` are available with `avx512f`, so we
-                    // need to check for them separately.
-                    if os_avx512_support && f16c && fma {
-                        enable(extended_features_ebx, 16, Feature::avx512f);
-                        enable(extended_features_ebx, 17, Feature::avx512dq);
-                        enable(extended_features_ebx, 21, Feature::avx512ifma);
-                        enable(extended_features_ebx, 26, Feature::avx512pf);
-                        enable(extended_features_ebx, 27, Feature::avx512er);
-                        enable(extended_features_ebx, 28, Feature::avx512cd);
-                        enable(extended_features_ebx, 30, Feature::avx512bw);
-                        enable(extended_features_ebx, 31, Feature::avx512vl);
-                        enable(extended_features_ecx, 1, Feature::avx512vbmi);
-                        enable(extended_features_ecx, 6, Feature::avx512vbmi2);
-                        enable(extended_features_ecx, 11, Feature::avx512vnni);
-                        enable(extended_features_ecx, 12, Feature::avx512bitalg);
-                        enable(extended_features_ecx, 14, Feature::avx512vpopcntdq);
-                        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);
-
-                    if max_basic_leaf >= 0x1e {
-                        let CpuidResult {
-                            eax: amx_feature_flags_eax,
-                            ..
-                        } = unsafe { __cpuid_count(0x1e_u32, 1) };
-
-                        enable(amx_feature_flags_eax, 4, Feature::amx_fp8);
-                        enable(amx_feature_flags_eax, 5, Feature::amx_transpose);
-                        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);
-                    }
-                }
-            }
-        }
-
-        // This detects ABM on AMD CPUs and LZCNT on Intel CPUs.
-        // On intel CPUs with popcnt, lzcnt implements the
-        // "missing part" of ABM, so we map both to the same
-        // internal feature.
-        //
-        // The `is_x86_feature_detected!("lzcnt")` macro then
-        // internally maps to Feature::abm.
-        enable(extended_proc_info_ecx, 5, Feature::lzcnt);
-
-        // As Hygon Dhyana originates from AMD technology and shares most of the architecture with
-        // AMD's family 17h, but with different CPU Vendor ID("HygonGenuine")/Family series
-        // number(Family 18h).
-        //
-        // For CPUID feature bits, Hygon Dhyana(family 18h) share the same definition with AMD
-        // family 17h.
-        //
-        // Related AMD CPUID specification is https://www.amd.com/system/files/TechDocs/25481.pdf.
-        // Related Hygon kernel patch can be found on
-        // http://lkml.kernel.org/r/5ce86123a7b9dad925ac583d88d2f921040e859b.1538583282.git.puwen@hygon.cn
-        if vendor_id == *b"AuthenticAMD" || vendor_id == *b"HygonGenuine" {
-            // These features are available on AMD arch CPUs:
-            enable(extended_proc_info_ecx, 6, Feature::sse4a);
-            enable(extended_proc_info_ecx, 21, Feature::tbm);
-            enable(extended_proc_info_ecx, 11, Feature::xop);
-        }
-    }
-
-    // Unfortunately, some Skylake chips erroneously report support for BMI1 and
-    // BMI2 without actual support. These chips don't support AVX, and it seems
-    // that all Intel chips with non-erroneous support BMI do (I didn't check
-    // other vendors), so we can disable these flags for chips that don't also
-    // report support for AVX.
-    //
-    // It's possible this will pessimize future chips that do support BMI and
-    // not AVX, but this seems minor compared to a hard crash you get when
-    // executing an unsupported instruction (to put it another way, it's safe
-    // for us to under-report CPU features, but not to over-report them). Still,
-    // to limit any impact this may have in the future, we only do this for
-    // Intel chips, as it's a bug only present in their chips.
-    //
-    // This bug is documented as `SKL052` in the errata section of this document:
-    // http://www.intel.com/content/dam/www/public/us/en/documents/specification-updates/desktop-6th-gen-core-family-spec-update.pdf
-    if vendor_id == *b"GenuineIntel" && !value.test(Feature::avx as u32) {
-        value.unset(Feature::bmi1 as u32);
-        value.unset(Feature::bmi2 as u32);
-    }
-
-    value
-}
diff --git a/library/stdarch/crates/std_detect/src/detect/test_data/linux-artificial-aarch64.auxv b/library/stdarch/crates/std_detect/src/detect/test_data/linux-artificial-aarch64.auxv
deleted file mode 100644
index ec826afcf38..00000000000
Binary files a/library/stdarch/crates/std_detect/src/detect/test_data/linux-artificial-aarch64.auxv and /dev/null differ
diff --git a/library/stdarch/crates/std_detect/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv b/library/stdarch/crates/std_detect/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv
deleted file mode 100644
index 95537b73f20..00000000000
Binary files a/library/stdarch/crates/std_detect/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv and /dev/null differ
diff --git a/library/stdarch/crates/std_detect/src/detect/test_data/linux-hwcap2-aarch64.auxv b/library/stdarch/crates/std_detect/src/detect/test_data/linux-hwcap2-aarch64.auxv
deleted file mode 100644
index 1d87264b221..00000000000
Binary files a/library/stdarch/crates/std_detect/src/detect/test_data/linux-hwcap2-aarch64.auxv and /dev/null differ
diff --git a/library/stdarch/crates/std_detect/src/detect/test_data/linux-no-hwcap2-aarch64.auxv b/library/stdarch/crates/std_detect/src/detect/test_data/linux-no-hwcap2-aarch64.auxv
deleted file mode 100644
index 35f01cc767c..00000000000
Binary files a/library/stdarch/crates/std_detect/src/detect/test_data/linux-no-hwcap2-aarch64.auxv and /dev/null differ
diff --git a/library/stdarch/crates/std_detect/src/detect/test_data/linux-rpi3.auxv b/library/stdarch/crates/std_detect/src/detect/test_data/linux-rpi3.auxv
deleted file mode 100644
index 0538e661f63..00000000000
Binary files a/library/stdarch/crates/std_detect/src/detect/test_data/linux-rpi3.auxv and /dev/null differ
diff --git a/library/stdarch/crates/std_detect/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv b/library/stdarch/crates/std_detect/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv
deleted file mode 100644
index 75abc02d178..00000000000
Binary files a/library/stdarch/crates/std_detect/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv and /dev/null differ
diff --git a/library/stdarch/crates/std_detect/src/lib.rs b/library/stdarch/crates/std_detect/src/lib.rs
deleted file mode 100644
index ab1b77bad5b..00000000000
--- a/library/stdarch/crates/std_detect/src/lib.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//! Run-time feature detection for the Rust standard library.
-//!
-//! To detect whether a feature is enabled in the system running the binary
-//! use one of the appropriate macro for the target:
-//!
-//! * `x86` and `x86_64`: [`is_x86_feature_detected`]
-//! * `arm`: [`is_arm_feature_detected`]
-//! * `aarch64`: [`is_aarch64_feature_detected`]
-//! * `riscv`: [`is_riscv_feature_detected`]
-//! * `mips`: [`is_mips_feature_detected`]
-//! * `mips64`: [`is_mips64_feature_detected`]
-//! * `powerpc`: [`is_powerpc_feature_detected`]
-//! * `powerpc64`: [`is_powerpc64_feature_detected`]
-//! * `loongarch`: [`is_loongarch_feature_detected`]
-//! * `s390x`: [`is_s390x_feature_detected`]
-
-#![unstable(feature = "stdarch_internal", issue = "none")]
-#![feature(staged_api, doc_cfg, allow_internal_unstable)]
-#![deny(rust_2018_idioms)]
-#![allow(clippy::shadow_reuse)]
-#![cfg_attr(test, allow(unused_imports))]
-#![no_std]
-#![allow(internal_features)]
-
-#[cfg(test)]
-#[macro_use]
-extern crate std;
-
-// rust-lang/rust#83888: removing `extern crate` gives an error that `vec_spare>
-#[cfg_attr(feature = "std_detect_file_io", allow(unused_extern_crates))]
-#[cfg(feature = "std_detect_file_io")]
-extern crate alloc;
-
-#[doc(hidden)]
-#[unstable(feature = "stdarch_internal", issue = "none")]
-pub mod detect;
diff --git a/library/stdarch/crates/std_detect/tests/cpu-detection.rs b/library/stdarch/crates/std_detect/tests/cpu-detection.rs
deleted file mode 100644
index 7976aedc758..00000000000
--- a/library/stdarch/crates/std_detect/tests/cpu-detection.rs
+++ /dev/null
@@ -1,354 +0,0 @@
-#![allow(internal_features)]
-#![feature(stdarch_internal)]
-#![cfg_attr(target_arch = "arm", feature(stdarch_arm_feature_detection))]
-#![cfg_attr(
-    any(target_arch = "aarch64", target_arch = "arm64ec"),
-    feature(stdarch_aarch64_feature_detection)
-)]
-#![cfg_attr(
-    any(target_arch = "riscv32", target_arch = "riscv64"),
-    feature(stdarch_riscv_feature_detection)
-)]
-#![cfg_attr(target_arch = "powerpc", feature(stdarch_powerpc_feature_detection))]
-#![cfg_attr(target_arch = "powerpc64", feature(stdarch_powerpc_feature_detection))]
-#![cfg_attr(target_arch = "s390x", feature(stdarch_s390x_feature_detection))]
-#![allow(clippy::unwrap_used, clippy::use_debug, clippy::print_stdout)]
-
-#[cfg_attr(
-    any(
-        target_arch = "arm",
-        target_arch = "aarch64",
-        target_arch = "arm64ec",
-        target_arch = "riscv32",
-        target_arch = "riscv64",
-        target_arch = "powerpc",
-        target_arch = "powerpc64",
-        target_arch = "s390x",
-    ),
-    macro_use
-)]
-extern crate std_detect;
-
-#[test]
-fn all() {
-    for (f, e) in std_detect::detect::features() {
-        println!("{f}: {e}");
-    }
-}
-
-#[test]
-#[cfg(all(target_arch = "arm", target_os = "freebsd"))]
-fn arm_freebsd() {
-    println!("neon: {}", is_arm_feature_detected!("neon"));
-    println!("pmull: {}", is_arm_feature_detected!("pmull"));
-    println!("crc: {}", is_arm_feature_detected!("crc"));
-    println!("aes: {}", is_arm_feature_detected!("aes"));
-    println!("sha2: {}", is_arm_feature_detected!("sha2"));
-}
-
-#[test]
-#[cfg(all(target_arch = "arm", any(target_os = "linux", target_os = "android")))]
-fn arm_linux() {
-    println!("neon: {}", is_arm_feature_detected!("neon"));
-    println!("pmull: {}", is_arm_feature_detected!("pmull"));
-    println!("crc: {}", is_arm_feature_detected!("crc"));
-    println!("aes: {}", is_arm_feature_detected!("aes"));
-    println!("sha2: {}", is_arm_feature_detected!("sha2"));
-    println!("dotprod: {}", is_arm_feature_detected!("dotprod"));
-    println!("i8mm: {}", is_arm_feature_detected!("i8mm"));
-}
-
-#[test]
-#[cfg(all(
-    target_arch = "aarch64",
-    any(target_os = "linux", target_os = "android")
-))]
-fn aarch64_linux() {
-    println!("asimd: {}", is_aarch64_feature_detected!("asimd"));
-    println!("neon: {}", is_aarch64_feature_detected!("neon"));
-    println!("pmull: {}", is_aarch64_feature_detected!("pmull"));
-    println!("fp: {}", is_aarch64_feature_detected!("fp"));
-    println!("fp16: {}", is_aarch64_feature_detected!("fp16"));
-    println!("sve: {}", is_aarch64_feature_detected!("sve"));
-    println!("crc: {}", is_aarch64_feature_detected!("crc"));
-    println!("lse: {}", is_aarch64_feature_detected!("lse"));
-    println!("lse2: {}", is_aarch64_feature_detected!("lse2"));
-    println!("lse128: {}", is_aarch64_feature_detected!("lse128"));
-    println!("rdm: {}", is_aarch64_feature_detected!("rdm"));
-    println!("rcpc: {}", is_aarch64_feature_detected!("rcpc"));
-    println!("rcpc2: {}", is_aarch64_feature_detected!("rcpc2"));
-    println!("rcpc3: {}", is_aarch64_feature_detected!("rcpc3"));
-    println!("dotprod: {}", is_aarch64_feature_detected!("dotprod"));
-    println!("tme: {}", is_aarch64_feature_detected!("tme"));
-    println!("fhm: {}", is_aarch64_feature_detected!("fhm"));
-    println!("dit: {}", is_aarch64_feature_detected!("dit"));
-    println!("flagm: {}", is_aarch64_feature_detected!("flagm"));
-    println!("flagm2: {}", is_aarch64_feature_detected!("flagm2"));
-    println!("ssbs: {}", is_aarch64_feature_detected!("ssbs"));
-    println!("sb: {}", is_aarch64_feature_detected!("sb"));
-    println!("paca: {}", is_aarch64_feature_detected!("paca"));
-    println!("pacg: {}", is_aarch64_feature_detected!("pacg"));
-    // println!("pauth-lr: {}", is_aarch64_feature_detected!("pauth-lr"));
-    println!("dpb: {}", is_aarch64_feature_detected!("dpb"));
-    println!("dpb2: {}", is_aarch64_feature_detected!("dpb2"));
-    println!("sve-b16b16: {}", is_aarch64_feature_detected!("sve-b16b16"));
-    println!("sve2: {}", is_aarch64_feature_detected!("sve2"));
-    println!("sve2p1: {}", is_aarch64_feature_detected!("sve2p1"));
-    println!("sve2-aes: {}", is_aarch64_feature_detected!("sve2-aes"));
-    println!("sve2-sm4: {}", is_aarch64_feature_detected!("sve2-sm4"));
-    println!("sve2-sha3: {}", is_aarch64_feature_detected!("sve2-sha3"));
-    println!(
-        "sve2-bitperm: {}",
-        is_aarch64_feature_detected!("sve2-bitperm")
-    );
-    println!("frintts: {}", is_aarch64_feature_detected!("frintts"));
-    println!("i8mm: {}", is_aarch64_feature_detected!("i8mm"));
-    println!("f32mm: {}", is_aarch64_feature_detected!("f32mm"));
-    println!("f64mm: {}", is_aarch64_feature_detected!("f64mm"));
-    println!("bf16: {}", is_aarch64_feature_detected!("bf16"));
-    println!("rand: {}", is_aarch64_feature_detected!("rand"));
-    println!("bti: {}", is_aarch64_feature_detected!("bti"));
-    println!("mte: {}", is_aarch64_feature_detected!("mte"));
-    println!("jsconv: {}", is_aarch64_feature_detected!("jsconv"));
-    println!("fcma: {}", is_aarch64_feature_detected!("fcma"));
-    println!("aes: {}", is_aarch64_feature_detected!("aes"));
-    println!("sha2: {}", is_aarch64_feature_detected!("sha2"));
-    println!("sha3: {}", is_aarch64_feature_detected!("sha3"));
-    println!("sm4: {}", is_aarch64_feature_detected!("sm4"));
-    println!("hbc: {}", is_aarch64_feature_detected!("hbc"));
-    println!("mops: {}", is_aarch64_feature_detected!("mops"));
-    println!("ecv: {}", is_aarch64_feature_detected!("ecv"));
-    println!("cssc: {}", is_aarch64_feature_detected!("cssc"));
-    println!("fpmr: {}", is_aarch64_feature_detected!("fpmr"));
-    println!("lut: {}", is_aarch64_feature_detected!("lut"));
-    println!("faminmax: {}", is_aarch64_feature_detected!("faminmax"));
-    println!("fp8: {}", is_aarch64_feature_detected!("fp8"));
-    println!("fp8fma: {}", is_aarch64_feature_detected!("fp8fma"));
-    println!("fp8dot4: {}", is_aarch64_feature_detected!("fp8dot4"));
-    println!("fp8dot2: {}", is_aarch64_feature_detected!("fp8dot2"));
-    println!("wfxt: {}", is_aarch64_feature_detected!("wfxt"));
-    println!("sme: {}", is_aarch64_feature_detected!("sme"));
-    println!("sme-b16b16: {}", is_aarch64_feature_detected!("sme-b16b16"));
-    println!("sme-i16i64: {}", is_aarch64_feature_detected!("sme-i16i64"));
-    println!("sme-f64f64: {}", is_aarch64_feature_detected!("sme-f64f64"));
-    println!("sme-fa64: {}", is_aarch64_feature_detected!("sme-fa64"));
-    println!("sme2: {}", is_aarch64_feature_detected!("sme2"));
-    println!("sme2p1: {}", is_aarch64_feature_detected!("sme2p1"));
-    println!("sme-f16f16: {}", is_aarch64_feature_detected!("sme-f16f16"));
-    println!("sme-lutv2: {}", is_aarch64_feature_detected!("sme-lutv2"));
-    println!("sme-f8f16: {}", is_aarch64_feature_detected!("sme-f8f16"));
-    println!("sme-f8f32: {}", is_aarch64_feature_detected!("sme-f8f32"));
-    println!(
-        "ssve-fp8fma: {}",
-        is_aarch64_feature_detected!("ssve-fp8fma")
-    );
-    println!(
-        "ssve-fp8dot4: {}",
-        is_aarch64_feature_detected!("ssve-fp8dot4")
-    );
-    println!(
-        "ssve-fp8dot2: {}",
-        is_aarch64_feature_detected!("ssve-fp8dot2")
-    );
-}
-
-#[test]
-#[cfg(all(
-    any(target_arch = "aarch64", target_arch = "arm64ec"),
-    target_os = "windows"
-))]
-fn aarch64_windows() {
-    println!("asimd: {:?}", is_aarch64_feature_detected!("asimd"));
-    println!("fp: {:?}", is_aarch64_feature_detected!("fp"));
-    println!("crc: {:?}", is_aarch64_feature_detected!("crc"));
-    println!("lse: {:?}", is_aarch64_feature_detected!("lse"));
-    println!("dotprod: {:?}", is_aarch64_feature_detected!("dotprod"));
-    println!("jsconv: {:?}", is_aarch64_feature_detected!("jsconv"));
-    println!("rcpc: {:?}", is_aarch64_feature_detected!("rcpc"));
-    println!("aes: {:?}", is_aarch64_feature_detected!("aes"));
-    println!("pmull: {:?}", is_aarch64_feature_detected!("pmull"));
-    println!("sha2: {:?}", is_aarch64_feature_detected!("sha2"));
-}
-
-#[test]
-#[cfg(all(
-    target_arch = "aarch64",
-    any(target_os = "freebsd", target_os = "openbsd")
-))]
-fn aarch64_bsd() {
-    println!("asimd: {:?}", is_aarch64_feature_detected!("asimd"));
-    println!("pmull: {:?}", is_aarch64_feature_detected!("pmull"));
-    println!("fp: {:?}", is_aarch64_feature_detected!("fp"));
-    println!("fp16: {:?}", is_aarch64_feature_detected!("fp16"));
-    println!("sve: {:?}", is_aarch64_feature_detected!("sve"));
-    println!("crc: {:?}", is_aarch64_feature_detected!("crc"));
-    println!("lse: {:?}", is_aarch64_feature_detected!("lse"));
-    println!("lse2: {:?}", is_aarch64_feature_detected!("lse2"));
-    println!("rdm: {:?}", is_aarch64_feature_detected!("rdm"));
-    println!("rcpc: {:?}", is_aarch64_feature_detected!("rcpc"));
-    println!("dotprod: {:?}", is_aarch64_feature_detected!("dotprod"));
-    println!("tme: {:?}", is_aarch64_feature_detected!("tme"));
-    println!("paca: {:?}", is_aarch64_feature_detected!("paca"));
-    println!("pacg: {:?}", is_aarch64_feature_detected!("pacg"));
-    println!("aes: {:?}", is_aarch64_feature_detected!("aes"));
-    println!("sha2: {:?}", is_aarch64_feature_detected!("sha2"));
-}
-
-#[test]
-#[cfg(all(target_arch = "aarch64", target_vendor = "apple"))]
-fn aarch64_darwin() {
-    println!("asimd: {:?}", is_aarch64_feature_detected!("asimd"));
-    println!("fp: {:?}", is_aarch64_feature_detected!("fp"));
-    println!("fp16: {:?}", is_aarch64_feature_detected!("fp16"));
-    println!("pmull: {:?}", is_aarch64_feature_detected!("pmull"));
-    println!("crc: {:?}", is_aarch64_feature_detected!("crc"));
-    println!("lse: {:?}", is_aarch64_feature_detected!("lse"));
-    println!("lse2: {:?}", is_aarch64_feature_detected!("lse2"));
-    println!("rdm: {:?}", is_aarch64_feature_detected!("rdm"));
-    println!("rcpc: {:?}", is_aarch64_feature_detected!("rcpc"));
-    println!("rcpc2: {:?}", is_aarch64_feature_detected!("rcpc2"));
-    println!("dotprod: {:?}", is_aarch64_feature_detected!("dotprod"));
-    println!("fhm: {:?}", is_aarch64_feature_detected!("fhm"));
-    println!("flagm: {:?}", is_aarch64_feature_detected!("flagm"));
-    println!("ssbs: {:?}", is_aarch64_feature_detected!("ssbs"));
-    println!("sb: {:?}", is_aarch64_feature_detected!("sb"));
-    println!("paca: {:?}", is_aarch64_feature_detected!("paca"));
-    println!("dpb: {:?}", is_aarch64_feature_detected!("dpb"));
-    println!("dpb2: {:?}", is_aarch64_feature_detected!("dpb2"));
-    println!("frintts: {:?}", is_aarch64_feature_detected!("frintts"));
-    println!("i8mm: {:?}", is_aarch64_feature_detected!("i8mm"));
-    println!("bf16: {:?}", is_aarch64_feature_detected!("bf16"));
-    println!("bti: {:?}", is_aarch64_feature_detected!("bti"));
-    println!("fcma: {:?}", is_aarch64_feature_detected!("fcma"));
-    println!("jsconv: {:?}", is_aarch64_feature_detected!("jsconv"));
-    println!("aes: {:?}", is_aarch64_feature_detected!("aes"));
-    println!("sha2: {:?}", is_aarch64_feature_detected!("sha2"));
-    println!("sha3: {:?}", is_aarch64_feature_detected!("sha3"));
-}
-
-#[test]
-#[cfg(all(
-    any(target_arch = "riscv32", target_arch = "riscv64"),
-    any(target_os = "linux", target_os = "android")
-))]
-fn riscv_linux() {
-    println!("rv32i: {}", is_riscv_feature_detected!("rv32i"));
-    println!("rv32e: {}", is_riscv_feature_detected!("rv32e"));
-    println!("rv64i: {}", is_riscv_feature_detected!("rv64i"));
-    println!("rv128i: {}", is_riscv_feature_detected!("rv128i"));
-    println!(
-        "unaligned-scalar-mem: {}",
-        is_riscv_feature_detected!("unaligned-scalar-mem")
-    );
-    println!(
-        "unaligned-vector-mem: {}",
-        is_riscv_feature_detected!("unaligned-vector-mem")
-    );
-    println!("zicsr: {}", is_riscv_feature_detected!("zicsr"));
-    println!("zicntr: {}", is_riscv_feature_detected!("zicntr"));
-    println!("zihpm: {}", is_riscv_feature_detected!("zihpm"));
-    println!("zifencei: {}", is_riscv_feature_detected!("zifencei"));
-    println!("zihintntl: {}", is_riscv_feature_detected!("zihintntl"));
-    println!("zihintpause: {}", is_riscv_feature_detected!("zihintpause"));
-    println!("zimop: {}", is_riscv_feature_detected!("zimop"));
-    println!("zicbom: {}", is_riscv_feature_detected!("zicbom"));
-    println!("zicboz: {}", is_riscv_feature_detected!("zicboz"));
-    println!("zicond: {}", is_riscv_feature_detected!("zicond"));
-    println!("m: {}", is_riscv_feature_detected!("m"));
-    println!("a: {}", is_riscv_feature_detected!("a"));
-    println!("zalrsc: {}", is_riscv_feature_detected!("zalrsc"));
-    println!("zaamo: {}", is_riscv_feature_detected!("zaamo"));
-    println!("zawrs: {}", is_riscv_feature_detected!("zawrs"));
-    println!("zacas: {}", is_riscv_feature_detected!("zacas"));
-    println!("zam: {}", is_riscv_feature_detected!("zam"));
-    println!("ztso: {}", is_riscv_feature_detected!("ztso"));
-    println!("f: {}", is_riscv_feature_detected!("f"));
-    println!("d: {}", is_riscv_feature_detected!("d"));
-    println!("q: {}", is_riscv_feature_detected!("q"));
-    println!("zfh: {}", is_riscv_feature_detected!("zfh"));
-    println!("zfhmin: {}", is_riscv_feature_detected!("zfhmin"));
-    println!("zfa: {}", is_riscv_feature_detected!("zfa"));
-    println!("zfbfmin: {}", is_riscv_feature_detected!("zfbfmin"));
-    println!("zfinx: {}", is_riscv_feature_detected!("zfinx"));
-    println!("zdinx: {}", is_riscv_feature_detected!("zdinx"));
-    println!("zhinx: {}", is_riscv_feature_detected!("zhinx"));
-    println!("zhinxmin: {}", is_riscv_feature_detected!("zhinxmin"));
-    println!("c: {}", is_riscv_feature_detected!("c"));
-    println!("zca: {}", is_riscv_feature_detected!("zca"));
-    println!("zcf: {}", is_riscv_feature_detected!("zcf"));
-    println!("zcd: {}", is_riscv_feature_detected!("zcd"));
-    println!("zcb: {}", is_riscv_feature_detected!("zcb"));
-    println!("zcmop: {}", is_riscv_feature_detected!("zcmop"));
-    println!("b: {}", is_riscv_feature_detected!("b"));
-    println!("zba: {}", is_riscv_feature_detected!("zba"));
-    println!("zbb: {}", is_riscv_feature_detected!("zbb"));
-    println!("zbc: {}", is_riscv_feature_detected!("zbc"));
-    println!("zbs: {}", is_riscv_feature_detected!("zbs"));
-    println!("zbkb: {}", is_riscv_feature_detected!("zbkb"));
-    println!("zbkc: {}", is_riscv_feature_detected!("zbkc"));
-    println!("zbkx: {}", is_riscv_feature_detected!("zbkx"));
-    println!("zknd: {}", is_riscv_feature_detected!("zknd"));
-    println!("zkne: {}", is_riscv_feature_detected!("zkne"));
-    println!("zknh: {}", is_riscv_feature_detected!("zknh"));
-    println!("zksed: {}", is_riscv_feature_detected!("zksed"));
-    println!("zksh: {}", is_riscv_feature_detected!("zksh"));
-    println!("zkr: {}", is_riscv_feature_detected!("zkr"));
-    println!("zkn: {}", is_riscv_feature_detected!("zkn"));
-    println!("zks: {}", is_riscv_feature_detected!("zks"));
-    println!("zk: {}", is_riscv_feature_detected!("zk"));
-    println!("zkt: {}", is_riscv_feature_detected!("zkt"));
-    println!("v: {}", is_riscv_feature_detected!("v"));
-    println!("zve32x: {}", is_riscv_feature_detected!("zve32x"));
-    println!("zve32f: {}", is_riscv_feature_detected!("zve32f"));
-    println!("zve64x: {}", is_riscv_feature_detected!("zve64x"));
-    println!("zve64f: {}", is_riscv_feature_detected!("zve64f"));
-    println!("zve64d: {}", is_riscv_feature_detected!("zve64d"));
-    println!("zvfh: {}", is_riscv_feature_detected!("zvfh"));
-    println!("zvfhmin: {}", is_riscv_feature_detected!("zvfhmin"));
-    println!("zvfbfmin: {}", is_riscv_feature_detected!("zvfbfmin"));
-    println!("zvfbfwma: {}", is_riscv_feature_detected!("zvfbfwma"));
-    println!("zvbb: {}", is_riscv_feature_detected!("zvbb"));
-    println!("zvbc: {}", is_riscv_feature_detected!("zvbc"));
-    println!("zvkb: {}", is_riscv_feature_detected!("zvkb"));
-    println!("zvkg: {}", is_riscv_feature_detected!("zvkg"));
-    println!("zvkned: {}", is_riscv_feature_detected!("zvkned"));
-    println!("zvknha: {}", is_riscv_feature_detected!("zvknha"));
-    println!("zvknhb: {}", is_riscv_feature_detected!("zvknhb"));
-    println!("zvksed: {}", is_riscv_feature_detected!("zvksed"));
-    println!("zvksh: {}", is_riscv_feature_detected!("zvksh"));
-    println!("zvkn: {}", is_riscv_feature_detected!("zvkn"));
-    println!("zvknc: {}", is_riscv_feature_detected!("zvknc"));
-    println!("zvkng: {}", is_riscv_feature_detected!("zvkng"));
-    println!("zvks: {}", is_riscv_feature_detected!("zvks"));
-    println!("zvksc: {}", is_riscv_feature_detected!("zvksc"));
-    println!("zvksg: {}", is_riscv_feature_detected!("zvksg"));
-    println!("zvkt: {}", is_riscv_feature_detected!("zvkt"));
-    println!("j: {}", is_riscv_feature_detected!("j"));
-    println!("p: {}", is_riscv_feature_detected!("p"));
-}
-
-#[test]
-#[cfg(all(target_arch = "powerpc", target_os = "linux"))]
-fn powerpc_linux() {
-    println!("altivec: {}", is_powerpc_feature_detected!("altivec"));
-    println!("vsx: {}", is_powerpc_feature_detected!("vsx"));
-    println!("power8: {}", is_powerpc_feature_detected!("power8"));
-}
-
-#[test]
-#[cfg(all(
-    target_arch = "powerpc64",
-    any(target_os = "linux", target_os = "freebsd"),
-))]
-fn powerpc64_linux_or_freebsd() {
-    println!("altivec: {}", is_powerpc64_feature_detected!("altivec"));
-    println!("vsx: {}", is_powerpc64_feature_detected!("vsx"));
-    println!("power8: {}", is_powerpc64_feature_detected!("power8"));
-    println!("power9: {}", is_powerpc64_feature_detected!("power9"));
-}
-
-#[test]
-#[cfg(all(target_arch = "s390x", target_os = "linux",))]
-fn s390x_linux() {
-    println!("vector: {}", is_s390x_feature_detected!("vector"));
-}
diff --git a/library/stdarch/crates/std_detect/tests/macro_trailing_commas.rs b/library/stdarch/crates/std_detect/tests/macro_trailing_commas.rs
deleted file mode 100644
index 2fee0abdd57..00000000000
--- a/library/stdarch/crates/std_detect/tests/macro_trailing_commas.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-#![allow(internal_features)]
-#![cfg_attr(
-    any(
-        target_arch = "arm",
-        target_arch = "aarch64",
-        target_arch = "arm64ec",
-        target_arch = "x86",
-        target_arch = "x86_64",
-        target_arch = "powerpc",
-        target_arch = "powerpc64",
-        target_arch = "s390x",
-        target_arch = "riscv32",
-        target_arch = "riscv64",
-        target_arch = "loongarch32",
-        target_arch = "loongarch64"
-    ),
-    feature(stdarch_internal)
-)]
-#![cfg_attr(target_arch = "arm", feature(stdarch_arm_feature_detection))]
-#![cfg_attr(
-    any(target_arch = "aarch64", target_arch = "arm64ec"),
-    feature(stdarch_aarch64_feature_detection)
-)]
-#![cfg_attr(
-    any(target_arch = "powerpc", target_arch = "powerpc64"),
-    feature(stdarch_powerpc_feature_detection)
-)]
-#![cfg_attr(target_arch = "s390x", feature(stdarch_s390x_feature_detection))]
-#![cfg_attr(
-    any(target_arch = "riscv32", target_arch = "riscv64"),
-    feature(stdarch_riscv_feature_detection)
-)]
-#![cfg_attr(
-    any(target_arch = "loongarch32", target_arch = "loongarch64"),
-    feature(stdarch_loongarch_feature_detection)
-)]
-
-#[cfg(any(
-    target_arch = "arm",
-    target_arch = "aarch64",
-    target_arch = "arm64ec",
-    target_arch = "x86",
-    target_arch = "x86_64",
-    target_arch = "powerpc",
-    target_arch = "powerpc64",
-    target_arch = "s390x",
-    target_arch = "riscv32",
-    target_arch = "riscv64",
-    target_arch = "loongarch32",
-    target_arch = "loongarch64"
-))]
-#[macro_use]
-extern crate std_detect;
-
-#[test]
-#[cfg(target_arch = "arm")]
-fn arm() {
-    let _ = is_arm_feature_detected!("neon");
-    let _ = is_arm_feature_detected!("neon",);
-}
-
-#[test]
-#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
-fn aarch64() {
-    let _ = is_aarch64_feature_detected!("fp");
-    let _ = is_aarch64_feature_detected!("fp",);
-}
-
-#[test]
-#[cfg(any(target_arch = "loongarch32", target_arch = "loongarch64"))]
-fn loongarch() {
-    let _ = is_loongarch_feature_detected!("lsx");
-    let _ = is_loongarch_feature_detected!("lsx",);
-}
-
-#[test]
-#[cfg(target_arch = "powerpc")]
-fn powerpc() {
-    let _ = is_powerpc_feature_detected!("altivec");
-    let _ = is_powerpc_feature_detected!("altivec",);
-}
-
-#[test]
-#[cfg(target_arch = "powerpc64")]
-fn powerpc64() {
-    let _ = is_powerpc64_feature_detected!("altivec");
-    let _ = is_powerpc64_feature_detected!("altivec",);
-}
-
-#[test]
-#[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
-fn riscv() {
-    let _ = is_riscv_feature_detected!("zk");
-    let _ = is_riscv_feature_detected!("zk",);
-}
-
-#[test]
-#[cfg(target_arch = "s390x")]
-fn s390x() {
-    let _ = is_s390x_feature_detected!("vector");
-    let _ = is_s390x_feature_detected!("vector",);
-}
-
-#[test]
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn x86() {
-    let _ = is_x86_feature_detected!("sse");
-    let _ = is_x86_feature_detected!("sse",);
-}
diff --git a/library/stdarch/crates/std_detect/tests/x86-specific.rs b/library/stdarch/crates/std_detect/tests/x86-specific.rs
deleted file mode 100644
index d9ec79821ba..00000000000
--- a/library/stdarch/crates/std_detect/tests/x86-specific.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-#![cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-#![allow(internal_features)]
-#![feature(
-    stdarch_internal,
-    x86_amx_intrinsics,
-    xop_target_feature,
-    movrs_target_feature
-)]
-
-#[macro_use]
-extern crate std_detect;
-
-#[test]
-fn dump() {
-    println!("aes: {:?}", is_x86_feature_detected!("aes"));
-    println!("pclmulqdq: {:?}", is_x86_feature_detected!("pclmulqdq"));
-    println!("rdrand: {:?}", is_x86_feature_detected!("rdrand"));
-    println!("rdseed: {:?}", is_x86_feature_detected!("rdseed"));
-    println!("tsc: {:?}", is_x86_feature_detected!("tsc"));
-    println!("sse: {:?}", is_x86_feature_detected!("sse"));
-    println!("sse2: {:?}", is_x86_feature_detected!("sse2"));
-    println!("sse3: {:?}", is_x86_feature_detected!("sse3"));
-    println!("ssse3: {:?}", is_x86_feature_detected!("ssse3"));
-    println!("sse4.1: {:?}", is_x86_feature_detected!("sse4.1"));
-    println!("sse4.2: {:?}", is_x86_feature_detected!("sse4.2"));
-    println!("sse4a: {:?}", is_x86_feature_detected!("sse4a"));
-    println!("sha: {:?}", is_x86_feature_detected!("sha"));
-    println!("f16c: {:?}", is_x86_feature_detected!("f16c"));
-    println!("avx: {:?}", is_x86_feature_detected!("avx"));
-    println!("avx2: {:?}", is_x86_feature_detected!("avx2"));
-    println!("sha512: {:?}", is_x86_feature_detected!("sha512"));
-    println!("sm3: {:?}", is_x86_feature_detected!("sm3"));
-    println!("sm4: {:?}", is_x86_feature_detected!("sm4"));
-    println!("avx512f: {:?}", is_x86_feature_detected!("avx512f"));
-    println!("avx512cd: {:?}", is_x86_feature_detected!("avx512cd"));
-    println!("avx512er: {:?}", is_x86_feature_detected!("avx512er"));
-    println!("avx512pf: {:?}", is_x86_feature_detected!("avx512pf"));
-    println!("avx512bw: {:?}", is_x86_feature_detected!("avx512bw"));
-    println!("avx512dq: {:?}", is_x86_feature_detected!("avx512dq"));
-    println!("avx512vl: {:?}", is_x86_feature_detected!("avx512vl"));
-    println!("avx512_ifma: {:?}", is_x86_feature_detected!("avx512ifma"));
-    println!("avx512vbmi {:?}", is_x86_feature_detected!("avx512vbmi"));
-    println!(
-        "avx512_vpopcntdq: {:?}",
-        is_x86_feature_detected!("avx512vpopcntdq")
-    );
-    println!("avx512vbmi2: {:?}", is_x86_feature_detected!("avx512vbmi2"));
-    println!("gfni: {:?}", is_x86_feature_detected!("gfni"));
-    println!("vaes: {:?}", is_x86_feature_detected!("vaes"));
-    println!("vpclmulqdq: {:?}", is_x86_feature_detected!("vpclmulqdq"));
-    println!("avx512vnni: {:?}", is_x86_feature_detected!("avx512vnni"));
-    println!(
-        "avx512bitalg: {:?}",
-        is_x86_feature_detected!("avx512bitalg")
-    );
-    println!("avx512bf16: {:?}", is_x86_feature_detected!("avx512bf16"));
-    println!(
-        "avx512vp2intersect: {:?}",
-        is_x86_feature_detected!("avx512vp2intersect")
-    );
-    println!("avx512fp16: {:?}", is_x86_feature_detected!("avx512fp16"));
-    println!("fma: {:?}", is_x86_feature_detected!("fma"));
-    println!("abm: {:?}", is_x86_feature_detected!("abm"));
-    println!("bmi: {:?}", is_x86_feature_detected!("bmi1"));
-    println!("bmi2: {:?}", is_x86_feature_detected!("bmi2"));
-    println!("tbm: {:?}", is_x86_feature_detected!("tbm"));
-    println!("popcnt: {:?}", is_x86_feature_detected!("popcnt"));
-    println!("lzcnt: {:?}", is_x86_feature_detected!("lzcnt"));
-    println!("fxsr: {:?}", is_x86_feature_detected!("fxsr"));
-    println!("xsave: {:?}", is_x86_feature_detected!("xsave"));
-    println!("xsaveopt: {:?}", is_x86_feature_detected!("xsaveopt"));
-    println!("xsaves: {:?}", is_x86_feature_detected!("xsaves"));
-    println!("xsavec: {:?}", is_x86_feature_detected!("xsavec"));
-    println!("cmpxchg16b: {:?}", is_x86_feature_detected!("cmpxchg16b"));
-    println!("adx: {:?}", is_x86_feature_detected!("adx"));
-    println!("rtm: {:?}", is_x86_feature_detected!("rtm"));
-    println!("movbe: {:?}", is_x86_feature_detected!("movbe"));
-    println!("avxvnni: {:?}", is_x86_feature_detected!("avxvnni"));
-    println!("avxvnniint8: {:?}", is_x86_feature_detected!("avxvnniint8"));
-    println!(
-        "avxneconvert: {:?}",
-        is_x86_feature_detected!("avxneconvert")
-    );
-    println!("avxifma: {:?}", is_x86_feature_detected!("avxifma"));
-    println!(
-        "avxvnniint16: {:?}",
-        is_x86_feature_detected!("avxvnniint16")
-    );
-    println!("amx-bf16: {:?}", is_x86_feature_detected!("amx-bf16"));
-    println!("amx-tile: {:?}", is_x86_feature_detected!("amx-tile"));
-    println!("amx-int8: {:?}", is_x86_feature_detected!("amx-int8"));
-    println!("amx-fp16: {:?}", is_x86_feature_detected!("amx-fp16"));
-    println!("amx-complex: {:?}", is_x86_feature_detected!("amx-complex"));
-    println!("xop: {:?}", is_x86_feature_detected!("xop"));
-    println!("kl: {:?}", is_x86_feature_detected!("kl"));
-    println!("widekl: {:?}", is_x86_feature_detected!("widekl"));
-    println!("movrs: {:?}", is_x86_feature_detected!("movrs"));
-    println!("amx-fp8: {:?}", is_x86_feature_detected!("amx-fp8"));
-    println!(
-        "amx-transpose: {:?}",
-        is_x86_feature_detected!("amx-transpose")
-    );
-    println!("amx-tf32: {:?}", is_x86_feature_detected!("amx-tf32"));
-    println!("amx-avx512: {:?}", is_x86_feature_detected!("amx-avx512"));
-    println!("amx-movrs: {:?}", is_x86_feature_detected!("amx-movrs"));
-}
-
-#[test]
-#[allow(deprecated)]
-fn x86_deprecated() {
-    println!("avx512gfni {:?}", is_x86_feature_detected!("avx512gfni"));
-    println!("avx512vaes {:?}", is_x86_feature_detected!("avx512vaes"));
-    println!(
-        "avx512vpclmulqdq {:?}",
-        is_x86_feature_detected!("avx512vpclmulqdq")
-    );
-}
-- 
cgit 1.4.1-3-g733a5


From b23ab7888a06f548e8d9a5951e97cb68399e31b3 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 09:51:28 +0200
Subject: Make `std_detect` a direct dependency of `std`

---
 library/Cargo.lock            |  4 ++--
 library/std/Cargo.toml        |  7 ++-----
 library/std_detect/Cargo.toml | 12 +++---------
 3 files changed, 7 insertions(+), 16 deletions(-)

diff --git a/library/Cargo.lock b/library/Cargo.lock
index 8b5275e5065..94155e08398 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -340,10 +340,10 @@ dependencies = [
 name = "std_detect"
 version = "0.1.5"
 dependencies = [
+ "alloc",
  "cfg-if",
+ "core",
  "libc",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
 ]
 
 [[package]]
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 5c3132a7375..ba1e1f5218a 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -23,9 +23,7 @@ unwind = { path = "../unwind" }
 hashbrown = { version = "0.15", default-features = false, features = [
     'rustc-dep-of-std',
 ] }
-std_detect = { path = "../stdarch/crates/std_detect", public = true, default-features = false, features = [
-    'rustc-dep-of-std',
-] }
+std_detect = { path = "../std_detect", public = true }
 
 # Dependencies of the `backtrace` crate
 rustc-demangle = { version = "0.1.24", features = ['rustc-dep-of-std'] }
@@ -118,8 +116,7 @@ optimize_for_size = ["core/optimize_for_size", "alloc/optimize_for_size"]
 debug_refcell = ["core/debug_refcell"]
 
 
-# Enable std_detect default features for stdarch/crates/std_detect:
-# https://github.com/rust-lang/stdarch/blob/master/crates/std_detect/Cargo.toml
+# Enable std_detect features:
 std_detect_file_io = ["std_detect/std_detect_file_io"]
 std_detect_dlsym_getauxval = ["std_detect/std_detect_dlsym_getauxval"]
 
diff --git a/library/std_detect/Cargo.toml b/library/std_detect/Cargo.toml
index f990e724125..8d91454726b 100644
--- a/library/std_detect/Cargo.toml
+++ b/library/std_detect/Cargo.toml
@@ -22,20 +22,14 @@ maintenance = { status = "experimental" }
 
 [dependencies]
 cfg-if = "1.0.0"
-
-# When built as part of libstd
-core = { version = "1.0.0", optional = true, package = "rustc-std-workspace-core" }
-alloc = { version = "1.0.0", optional = true, package = "rustc-std-workspace-alloc" }
+core = { path = "../core" }
+alloc = { path = "../alloc" }
 
 [target.'cfg(not(windows))'.dependencies]
 libc = { version = "0.2.0", optional = true, default-features = false }
 
 [features]
-default = [ "std_detect_dlsym_getauxval", "std_detect_file_io" ]
+default = []
 std_detect_file_io = [ "libc" ]
 std_detect_dlsym_getauxval = [ "libc" ]
 std_detect_env_override = [ "libc" ]
-rustc-dep-of-std = [
-    "core",
-    "alloc",
-]
-- 
cgit 1.4.1-3-g733a5


From 1057a2213af6fd273da86f13edeae559bfdd587d Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 10:08:50 +0200
Subject: Allow platform-specific code in `std_detect`

---
 src/tools/tidy/src/pal.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/tidy/src/pal.rs b/src/tools/tidy/src/pal.rs
index b7d4a331891..5b8b44429bb 100644
--- a/src/tools/tidy/src/pal.rs
+++ b/src/tools/tidy/src/pal.rs
@@ -37,6 +37,7 @@ use crate::walk::{filter_dirs, walk};
 // Paths that may contain platform-specific code.
 const EXCEPTION_PATHS: &[&str] = &[
     "library/compiler-builtins",
+    "library/std_detect",
     "library/windows_targets",
     "library/panic_abort",
     "library/panic_unwind",
-- 
cgit 1.4.1-3-g733a5


From ee6f2c5276c3e19b919abb61693e66b0ded9c8ba Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 10:08:58 +0200
Subject: Reformat `std_detect`

---
 library/std_detect/src/detect/cache.rs             | 38 ++++------------
 library/std_detect/src/detect/mod.rs               |  1 -
 library/std_detect/src/detect/os/aarch64.rs        |  8 ++--
 library/std_detect/src/detect/os/darwin/aarch64.rs | 11 ++---
 library/std_detect/src/detect/os/freebsd/auxvec.rs |  7 +--
 library/std_detect/src/detect/os/linux/aarch64.rs  | 10 +----
 .../std_detect/src/detect/os/linux/loongarch.rs    | 15 ++-----
 library/std_detect/src/detect/os/linux/riscv.rs    | 11 +----
 .../std_detect/src/detect/os/openbsd/aarch64.rs    |  4 +-
 library/std_detect/src/detect/os/x86.rs            | 39 +++++------------
 library/std_detect/tests/cpu-detection.rs          | 50 +++++-----------------
 library/std_detect/tests/x86-specific.rs           | 42 ++++--------------
 12 files changed, 54 insertions(+), 182 deletions(-)

diff --git a/library/std_detect/src/detect/cache.rs b/library/std_detect/src/detect/cache.rs
index 83bcedea612..1a42e091463 100644
--- a/library/std_detect/src/detect/cache.rs
+++ b/library/std_detect/src/detect/cache.rs
@@ -3,9 +3,7 @@
 
 #![allow(dead_code)] // not used on all platforms
 
-use core::sync::atomic::Ordering;
-
-use core::sync::atomic::AtomicUsize;
+use core::sync::atomic::{AtomicUsize, Ordering};
 
 /// Sets the `bit` of `x`.
 #[inline]
@@ -40,20 +38,14 @@ impl Initializer {
     /// Tests the `bit` of the cache.
     #[inline]
     pub(crate) fn test(self, bit: u32) -> bool {
-        debug_assert!(
-            bit < CACHE_CAPACITY,
-            "too many features, time to increase the cache size!"
-        );
+        debug_assert!(bit < CACHE_CAPACITY, "too many features, time to increase the cache size!");
         test_bit(self.0, bit)
     }
 
     /// Sets the `bit` of the cache.
     #[inline]
     pub(crate) fn set(&mut self, bit: u32) {
-        debug_assert!(
-            bit < CACHE_CAPACITY,
-            "too many features, time to increase the cache size!"
-        );
+        debug_assert!(bit < CACHE_CAPACITY, "too many features, time to increase the cache size!");
         let v = self.0;
         self.0 = set_bit(v, bit);
     }
@@ -61,10 +53,7 @@ impl Initializer {
     /// Unsets the `bit` of the cache.
     #[inline]
     pub(crate) fn unset(&mut self, bit: u32) {
-        debug_assert!(
-            bit < CACHE_CAPACITY,
-            "too many features, time to increase the cache size!"
-        );
+        debug_assert!(bit < CACHE_CAPACITY, "too many features, time to increase the cache size!");
         let v = self.0;
         self.0 = unset_bit(v, bit);
     }
@@ -73,11 +62,7 @@ impl Initializer {
 /// This global variable is a cache of the features supported by the CPU.
 // Note: the third slot is only used in x86
 // Another Slot can be added if needed without any change to `Initializer`
-static CACHE: [Cache; 3] = [
-    Cache::uninitialized(),
-    Cache::uninitialized(),
-    Cache::uninitialized(),
-];
+static CACHE: [Cache; 3] = [Cache::uninitialized(), Cache::uninitialized(), Cache::uninitialized()];
 
 /// Feature cache with capacity for `size_of::<usize>() * 8 - 1` features.
 ///
@@ -104,19 +89,14 @@ impl Cache {
     #[inline]
     pub(crate) fn test(&self, bit: u32) -> Option<bool> {
         let cached = self.0.load(Ordering::Relaxed);
-        if cached == 0 {
-            None
-        } else {
-            Some(test_bit(cached as u128, bit))
-        }
+        if cached == 0 { None } else { Some(test_bit(cached as u128, bit)) }
     }
 
     /// Initializes the cache.
     #[inline]
     fn initialize(&self, value: usize) -> usize {
         debug_assert_eq!((value & !Cache::MASK), 0);
-        self.0
-            .store(value | Cache::INITIALIZED_BIT, Ordering::Relaxed);
+        self.0.store(value | Cache::INITIALIZED_BIT, Ordering::Relaxed);
         value
     }
 }
@@ -217,7 +197,5 @@ pub(crate) fn test(bit: u32) -> bool {
     } else {
         (bit - 2 * Cache::CAPACITY, 2)
     };
-    CACHE[idx]
-        .test(relative_bit)
-        .unwrap_or_else(|| detect_and_initialize().test(bit))
+    CACHE[idx].test(relative_bit).unwrap_or_else(|| detect_and_initialize().test(bit))
 }
diff --git a/library/std_detect/src/detect/mod.rs b/library/std_detect/src/detect/mod.rs
index a9e9709c1f6..f936a5a1345 100644
--- a/library/std_detect/src/detect/mod.rs
+++ b/library/std_detect/src/detect/mod.rs
@@ -29,7 +29,6 @@ mod arch;
 #[doc(hidden)]
 #[unstable(feature = "stdarch_internal", issue = "none")]
 pub use self::arch::__is_feature_detected;
-
 pub(crate) use self::arch::Feature;
 
 mod bit;
diff --git a/library/std_detect/src/detect/os/aarch64.rs b/library/std_detect/src/detect/os/aarch64.rs
index 1ff2a17e6e1..c2c754ccf8d 100644
--- a/library/std_detect/src/detect/os/aarch64.rs
+++ b/library/std_detect/src/detect/os/aarch64.rs
@@ -17,9 +17,10 @@
 //! - [Linux documentation](https://www.kernel.org/doc/Documentation/arm64/cpu-feature-registers.txt)
 //! - [ARM documentation](https://developer.arm.com/documentation/ddi0601/2022-12/AArch64-Registers?lang=en)
 
-use crate::detect::{Feature, cache};
 use core::arch::asm;
 
+use crate::detect::{Feature, cache};
+
 /// Try to read the features from the system registers.
 ///
 /// This will cause SIGILL if the current OS is not trapping the mrs instruction.
@@ -104,10 +105,7 @@ pub(crate) fn parse_system_registers(
         let sha2 = bits_shift(aa64isar0, 15, 12) >= 1;
         enable_feature(Feature::sha2, asimd && sha1 && sha2);
         enable_feature(Feature::rdm, asimd && bits_shift(aa64isar0, 31, 28) >= 1);
-        enable_feature(
-            Feature::dotprod,
-            asimd && bits_shift(aa64isar0, 47, 44) >= 1,
-        );
+        enable_feature(Feature::dotprod, asimd && bits_shift(aa64isar0, 47, 44) >= 1);
         enable_feature(Feature::sve, asimd && bits_shift(aa64pfr0, 35, 32) >= 1);
     }
 
diff --git a/library/std_detect/src/detect/os/darwin/aarch64.rs b/library/std_detect/src/detect/os/darwin/aarch64.rs
index 44d921689e5..f5409361d93 100644
--- a/library/std_detect/src/detect/os/darwin/aarch64.rs
+++ b/library/std_detect/src/detect/os/darwin/aarch64.rs
@@ -2,9 +2,10 @@
 //!
 //! <https://developer.apple.com/documentation/kernel/1387446-sysctlbyname/determining_instruction_set_characteristics>
 
-use crate::detect::{Feature, cache};
 use core::ffi::CStr;
 
+use crate::detect::{Feature, cache};
+
 #[inline]
 fn _sysctlbyname(name: &CStr) -> bool {
     use libc;
@@ -14,13 +15,7 @@ fn _sysctlbyname(name: &CStr) -> bool {
     let enabled_ptr = &mut enabled as *mut i32 as *mut libc::c_void;
 
     let ret = unsafe {
-        libc::sysctlbyname(
-            name.as_ptr(),
-            enabled_ptr,
-            &mut enabled_len,
-            core::ptr::null_mut(),
-            0,
-        )
+        libc::sysctlbyname(name.as_ptr(), enabled_ptr, &mut enabled_len, core::ptr::null_mut(), 0)
     };
 
     match ret {
diff --git a/library/std_detect/src/detect/os/freebsd/auxvec.rs b/library/std_detect/src/detect/os/freebsd/auxvec.rs
index 4e72bf22d76..2a7b87c05d1 100644
--- a/library/std_detect/src/detect/os/freebsd/auxvec.rs
+++ b/library/std_detect/src/detect/os/freebsd/auxvec.rs
@@ -54,11 +54,8 @@ fn archauxv(key: libc::c_int) -> usize {
         // https://github.com/freebsd/freebsd-src/blob/release/11.4.0/sys/sys/auxv.h
         // FreeBSD 11 support in std has been removed in Rust 1.75 (https://github.com/rust-lang/rust/pull/114521),
         // so we can safely use this function.
-        let res = libc::elf_aux_info(
-            key,
-            &mut out as *mut libc::c_ulong as *mut libc::c_void,
-            OUT_LEN,
-        );
+        let res =
+            libc::elf_aux_info(key, &mut out as *mut libc::c_ulong as *mut libc::c_void, OUT_LEN);
         // If elf_aux_info fails, `out` will be left at zero (which is the proper default value).
         debug_assert!(res == 0 || out == 0);
     }
diff --git a/library/std_detect/src/detect/os/linux/aarch64.rs b/library/std_detect/src/detect/os/linux/aarch64.rs
index 22a9cefff7b..0de4beeae8b 100644
--- a/library/std_detect/src/detect/os/linux/aarch64.rs
+++ b/library/std_detect/src/detect/os/linux/aarch64.rs
@@ -343,14 +343,8 @@ impl AtHwcap {
             enable_feature(Feature::sve2, sve2);
             enable_feature(Feature::sve2p1, self.sve2p1 && sve2);
             // SVE2 extensions require SVE2 and crypto features
-            enable_feature(
-                Feature::sve2_aes,
-                self.sveaes && self.svepmull && sve2 && self.aes,
-            );
-            enable_feature(
-                Feature::sve2_sm4,
-                self.svesm4 && sve2 && self.sm3 && self.sm4,
-            );
+            enable_feature(Feature::sve2_aes, self.sveaes && self.svepmull && sve2 && self.aes);
+            enable_feature(Feature::sve2_sm4, self.svesm4 && sve2 && self.sm3 && self.sm4);
             enable_feature(
                 Feature::sve2_sha3,
                 self.svesha3 && sve2 && self.sha512 && self.sha3 && self.sha1 && self.sha2,
diff --git a/library/std_detect/src/detect/os/linux/loongarch.rs b/library/std_detect/src/detect/os/linux/loongarch.rs
index 14cc7a73183..e97fda11d08 100644
--- a/library/std_detect/src/detect/os/linux/loongarch.rs
+++ b/library/std_detect/src/detect/os/linux/loongarch.rs
@@ -1,8 +1,9 @@
 //! Run-time feature detection for LoongArch on Linux.
 
+use core::arch::asm;
+
 use super::auxvec;
 use crate::detect::{Feature, bit, cache};
-use core::arch::asm;
 
 /// Try to read the features from the auxiliary vector.
 pub(crate) fn detect_features() -> cache::Initializer {
@@ -43,16 +44,8 @@ pub(crate) fn detect_features() -> cache::Initializer {
     //
     // [hwcap]: https://github.com/torvalds/linux/blob/master/arch/loongarch/include/uapi/asm/hwcap.h
     if let Ok(auxv) = auxvec::auxv() {
-        enable_feature(
-            &mut value,
-            Feature::f,
-            bit::test(cpucfg2, 1) && bit::test(auxv.hwcap, 3),
-        );
-        enable_feature(
-            &mut value,
-            Feature::d,
-            bit::test(cpucfg2, 2) && bit::test(auxv.hwcap, 3),
-        );
+        enable_feature(&mut value, Feature::f, bit::test(cpucfg2, 1) && bit::test(auxv.hwcap, 3));
+        enable_feature(&mut value, Feature::d, bit::test(cpucfg2, 2) && bit::test(auxv.hwcap, 3));
         enable_feature(&mut value, Feature::lsx, bit::test(auxv.hwcap, 4));
         enable_feature(&mut value, Feature::lasx, bit::test(auxv.hwcap, 5));
         enable_feature(
diff --git a/library/std_detect/src/detect/os/linux/riscv.rs b/library/std_detect/src/detect/os/linux/riscv.rs
index db20538af95..dbb3664890e 100644
--- a/library/std_detect/src/detect/os/linux/riscv.rs
+++ b/library/std_detect/src/detect/os/linux/riscv.rs
@@ -119,16 +119,7 @@ fn _riscv_hwprobe(out: &mut [riscv_hwprobe]) -> bool {
         cpus: *mut libc::c_ulong,
         flags: libc::c_uint,
     ) -> libc::c_long {
-        unsafe {
-            libc::syscall(
-                __NR_riscv_hwprobe,
-                pairs,
-                pair_count,
-                cpu_set_size,
-                cpus,
-                flags,
-            )
-        }
+        unsafe { libc::syscall(__NR_riscv_hwprobe, pairs, pair_count, cpu_set_size, cpus, flags) }
     }
 
     unsafe { __riscv_hwprobe(out.as_mut_ptr(), out.len(), 0, ptr::null_mut(), 0) == 0 }
diff --git a/library/std_detect/src/detect/os/openbsd/aarch64.rs b/library/std_detect/src/detect/os/openbsd/aarch64.rs
index cfe4ad10ad6..2fae47b05c4 100644
--- a/library/std_detect/src/detect/os/openbsd/aarch64.rs
+++ b/library/std_detect/src/detect/os/openbsd/aarch64.rs
@@ -4,8 +4,10 @@
 //! https://github.com/openbsd/src/commit/d335af936b9d7dd9cf655cae1ce19560c45de6c8
 //! https://github.com/golang/go/commit/cd54ef1f61945459486e9eea2f016d99ef1da925
 
+use core::mem::MaybeUninit;
+use core::ptr;
+
 use crate::detect::cache;
-use core::{mem::MaybeUninit, ptr};
 
 // Defined in machine/cpu.h.
 // https://github.com/openbsd/src/blob/72ccc03bd11da614f31f7ff76e3f6fce99bc1c79/sys/arch/arm64/include/cpu.h#L25-L40
diff --git a/library/std_detect/src/detect/os/x86.rs b/library/std_detect/src/detect/os/x86.rs
index 8565c2f85e2..20f848ab05c 100644
--- a/library/std_detect/src/detect/os/x86.rs
+++ b/library/std_detect/src/detect/os/x86.rs
@@ -4,7 +4,6 @@
 use core::arch::x86::*;
 #[cfg(target_arch = "x86_64")]
 use core::arch::x86_64::*;
-
 use core::mem;
 
 use crate::detect::{Feature, bit, cache};
@@ -42,12 +41,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
     // 0x8000_0000]. - The vendor ID is stored in 12 u8 ascii chars,
     // returned in EBX, EDX, and   ECX (in that order):
     let (max_basic_leaf, vendor_id) = unsafe {
-        let CpuidResult {
-            eax: max_basic_leaf,
-            ebx,
-            ecx,
-            edx,
-        } = __cpuid(0);
+        let CpuidResult { eax: max_basic_leaf, ebx, ecx, edx } = __cpuid(0);
         let vendor_id: [[u8; 4]; 3] = [ebx.to_ne_bytes(), edx.to_ne_bytes(), ecx.to_ne_bytes()];
         let vendor_id: [u8; 12] = mem::transmute(vendor_id);
         (max_basic_leaf, vendor_id)
@@ -60,11 +54,8 @@ pub(crate) fn detect_features() -> cache::Initializer {
 
     // EAX = 1, ECX = 0: Queries "Processor Info and Feature Bits";
     // Contains information about most x86 features.
-    let CpuidResult {
-        ecx: proc_info_ecx,
-        edx: proc_info_edx,
-        ..
-    } = unsafe { __cpuid(0x0000_0001_u32) };
+    let CpuidResult { ecx: proc_info_ecx, edx: proc_info_edx, .. } =
+        unsafe { __cpuid(0x0000_0001_u32) };
 
     // EAX = 7: Queries "Extended Features";
     // Contains information about bmi,bmi2, and avx2 support.
@@ -76,11 +67,8 @@ pub(crate) fn detect_features() -> cache::Initializer {
         extended_features_edx_leaf_1,
     ) = if max_basic_leaf >= 7 {
         let CpuidResult { ebx, ecx, edx, .. } = unsafe { __cpuid(0x0000_0007_u32) };
-        let CpuidResult {
-            eax: eax_1,
-            edx: edx_1,
-            ..
-        } = unsafe { __cpuid_count(0x0000_0007_u32, 0x0000_0001_u32) };
+        let CpuidResult { eax: eax_1, edx: edx_1, .. } =
+            unsafe { __cpuid_count(0x0000_0007_u32, 0x0000_0001_u32) };
         (ebx, ecx, edx, eax_1, edx_1)
     } else {
         (0, 0, 0, 0, 0) // CPUID does not support "Extended Features"
@@ -89,10 +77,7 @@ pub(crate) fn detect_features() -> cache::Initializer {
     // EAX = 0x8000_0000, ECX = 0: Get Highest Extended Function Supported
     // - EAX returns the max leaf value for extended information, that is,
     // `cpuid` calls in range [0x8000_0000; u32::MAX]:
-    let CpuidResult {
-        eax: extended_max_basic_leaf,
-        ..
-    } = unsafe { __cpuid(0x8000_0000_u32) };
+    let CpuidResult { eax: extended_max_basic_leaf, .. } = unsafe { __cpuid(0x8000_0000_u32) };
 
     // EAX = 0x8000_0001, ECX=0: Queries "Extended Processor Info and Feature
     // Bits"
@@ -208,10 +193,8 @@ pub(crate) fn detect_features() -> cache::Initializer {
                     // Processor Extended State Enumeration Sub-leaf (EAX = 0DH,
                     // ECX = 1):
                     if max_basic_leaf >= 0xd {
-                        let CpuidResult {
-                            eax: proc_extended_state1_eax,
-                            ..
-                        } = unsafe { __cpuid_count(0xd_u32, 1) };
+                        let CpuidResult { eax: proc_extended_state1_eax, .. } =
+                            unsafe { __cpuid_count(0xd_u32, 1) };
                         enable(proc_extended_state1_eax, 0, Feature::xsaveopt);
                         enable(proc_extended_state1_eax, 1, Feature::xsavec);
                         enable(proc_extended_state1_eax, 3, Feature::xsaves);
@@ -269,10 +252,8 @@ pub(crate) fn detect_features() -> cache::Initializer {
                     enable(extended_features_edx_leaf_1, 8, Feature::amx_complex);
 
                     if max_basic_leaf >= 0x1e {
-                        let CpuidResult {
-                            eax: amx_feature_flags_eax,
-                            ..
-                        } = unsafe { __cpuid_count(0x1e_u32, 1) };
+                        let CpuidResult { eax: amx_feature_flags_eax, .. } =
+                            unsafe { __cpuid_count(0x1e_u32, 1) };
 
                         enable(amx_feature_flags_eax, 4, Feature::amx_fp8);
                         enable(amx_feature_flags_eax, 5, Feature::amx_transpose);
diff --git a/library/std_detect/tests/cpu-detection.rs b/library/std_detect/tests/cpu-detection.rs
index 7976aedc758..09a73572c1f 100644
--- a/library/std_detect/tests/cpu-detection.rs
+++ b/library/std_detect/tests/cpu-detection.rs
@@ -59,10 +59,7 @@ fn arm_linux() {
 }
 
 #[test]
-#[cfg(all(
-    target_arch = "aarch64",
-    any(target_os = "linux", target_os = "android")
-))]
+#[cfg(all(target_arch = "aarch64", any(target_os = "linux", target_os = "android")))]
 fn aarch64_linux() {
     println!("asimd: {}", is_aarch64_feature_detected!("asimd"));
     println!("neon: {}", is_aarch64_feature_detected!("neon"));
@@ -97,10 +94,7 @@ fn aarch64_linux() {
     println!("sve2-aes: {}", is_aarch64_feature_detected!("sve2-aes"));
     println!("sve2-sm4: {}", is_aarch64_feature_detected!("sve2-sm4"));
     println!("sve2-sha3: {}", is_aarch64_feature_detected!("sve2-sha3"));
-    println!(
-        "sve2-bitperm: {}",
-        is_aarch64_feature_detected!("sve2-bitperm")
-    );
+    println!("sve2-bitperm: {}", is_aarch64_feature_detected!("sve2-bitperm"));
     println!("frintts: {}", is_aarch64_feature_detected!("frintts"));
     println!("i8mm: {}", is_aarch64_feature_detected!("i8mm"));
     println!("f32mm: {}", is_aarch64_feature_detected!("f32mm"));
@@ -138,25 +132,13 @@ fn aarch64_linux() {
     println!("sme-lutv2: {}", is_aarch64_feature_detected!("sme-lutv2"));
     println!("sme-f8f16: {}", is_aarch64_feature_detected!("sme-f8f16"));
     println!("sme-f8f32: {}", is_aarch64_feature_detected!("sme-f8f32"));
-    println!(
-        "ssve-fp8fma: {}",
-        is_aarch64_feature_detected!("ssve-fp8fma")
-    );
-    println!(
-        "ssve-fp8dot4: {}",
-        is_aarch64_feature_detected!("ssve-fp8dot4")
-    );
-    println!(
-        "ssve-fp8dot2: {}",
-        is_aarch64_feature_detected!("ssve-fp8dot2")
-    );
+    println!("ssve-fp8fma: {}", is_aarch64_feature_detected!("ssve-fp8fma"));
+    println!("ssve-fp8dot4: {}", is_aarch64_feature_detected!("ssve-fp8dot4"));
+    println!("ssve-fp8dot2: {}", is_aarch64_feature_detected!("ssve-fp8dot2"));
 }
 
 #[test]
-#[cfg(all(
-    any(target_arch = "aarch64", target_arch = "arm64ec"),
-    target_os = "windows"
-))]
+#[cfg(all(any(target_arch = "aarch64", target_arch = "arm64ec"), target_os = "windows"))]
 fn aarch64_windows() {
     println!("asimd: {:?}", is_aarch64_feature_detected!("asimd"));
     println!("fp: {:?}", is_aarch64_feature_detected!("fp"));
@@ -171,10 +153,7 @@ fn aarch64_windows() {
 }
 
 #[test]
-#[cfg(all(
-    target_arch = "aarch64",
-    any(target_os = "freebsd", target_os = "openbsd")
-))]
+#[cfg(all(target_arch = "aarch64", any(target_os = "freebsd", target_os = "openbsd")))]
 fn aarch64_bsd() {
     println!("asimd: {:?}", is_aarch64_feature_detected!("asimd"));
     println!("pmull: {:?}", is_aarch64_feature_detected!("pmull"));
@@ -236,14 +215,8 @@ fn riscv_linux() {
     println!("rv32e: {}", is_riscv_feature_detected!("rv32e"));
     println!("rv64i: {}", is_riscv_feature_detected!("rv64i"));
     println!("rv128i: {}", is_riscv_feature_detected!("rv128i"));
-    println!(
-        "unaligned-scalar-mem: {}",
-        is_riscv_feature_detected!("unaligned-scalar-mem")
-    );
-    println!(
-        "unaligned-vector-mem: {}",
-        is_riscv_feature_detected!("unaligned-vector-mem")
-    );
+    println!("unaligned-scalar-mem: {}", is_riscv_feature_detected!("unaligned-scalar-mem"));
+    println!("unaligned-vector-mem: {}", is_riscv_feature_detected!("unaligned-vector-mem"));
     println!("zicsr: {}", is_riscv_feature_detected!("zicsr"));
     println!("zicntr: {}", is_riscv_feature_detected!("zicntr"));
     println!("zihpm: {}", is_riscv_feature_detected!("zihpm"));
@@ -336,10 +309,7 @@ fn powerpc_linux() {
 }
 
 #[test]
-#[cfg(all(
-    target_arch = "powerpc64",
-    any(target_os = "linux", target_os = "freebsd"),
-))]
+#[cfg(all(target_arch = "powerpc64", any(target_os = "linux", target_os = "freebsd"),))]
 fn powerpc64_linux_or_freebsd() {
     println!("altivec: {}", is_powerpc64_feature_detected!("altivec"));
     println!("vsx: {}", is_powerpc64_feature_detected!("vsx"));
diff --git a/library/std_detect/tests/x86-specific.rs b/library/std_detect/tests/x86-specific.rs
index d9ec79821ba..2ed2bb2a99e 100644
--- a/library/std_detect/tests/x86-specific.rs
+++ b/library/std_detect/tests/x86-specific.rs
@@ -1,11 +1,6 @@
 #![cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 #![allow(internal_features)]
-#![feature(
-    stdarch_internal,
-    x86_amx_intrinsics,
-    xop_target_feature,
-    movrs_target_feature
-)]
+#![feature(stdarch_internal, x86_amx_intrinsics, xop_target_feature, movrs_target_feature)]
 
 #[macro_use]
 extern crate std_detect;
@@ -40,24 +35,15 @@ fn dump() {
     println!("avx512vl: {:?}", is_x86_feature_detected!("avx512vl"));
     println!("avx512_ifma: {:?}", is_x86_feature_detected!("avx512ifma"));
     println!("avx512vbmi {:?}", is_x86_feature_detected!("avx512vbmi"));
-    println!(
-        "avx512_vpopcntdq: {:?}",
-        is_x86_feature_detected!("avx512vpopcntdq")
-    );
+    println!("avx512_vpopcntdq: {:?}", is_x86_feature_detected!("avx512vpopcntdq"));
     println!("avx512vbmi2: {:?}", is_x86_feature_detected!("avx512vbmi2"));
     println!("gfni: {:?}", is_x86_feature_detected!("gfni"));
     println!("vaes: {:?}", is_x86_feature_detected!("vaes"));
     println!("vpclmulqdq: {:?}", is_x86_feature_detected!("vpclmulqdq"));
     println!("avx512vnni: {:?}", is_x86_feature_detected!("avx512vnni"));
-    println!(
-        "avx512bitalg: {:?}",
-        is_x86_feature_detected!("avx512bitalg")
-    );
+    println!("avx512bitalg: {:?}", is_x86_feature_detected!("avx512bitalg"));
     println!("avx512bf16: {:?}", is_x86_feature_detected!("avx512bf16"));
-    println!(
-        "avx512vp2intersect: {:?}",
-        is_x86_feature_detected!("avx512vp2intersect")
-    );
+    println!("avx512vp2intersect: {:?}", is_x86_feature_detected!("avx512vp2intersect"));
     println!("avx512fp16: {:?}", is_x86_feature_detected!("avx512fp16"));
     println!("fma: {:?}", is_x86_feature_detected!("fma"));
     println!("abm: {:?}", is_x86_feature_detected!("abm"));
@@ -77,15 +63,9 @@ fn dump() {
     println!("movbe: {:?}", is_x86_feature_detected!("movbe"));
     println!("avxvnni: {:?}", is_x86_feature_detected!("avxvnni"));
     println!("avxvnniint8: {:?}", is_x86_feature_detected!("avxvnniint8"));
-    println!(
-        "avxneconvert: {:?}",
-        is_x86_feature_detected!("avxneconvert")
-    );
+    println!("avxneconvert: {:?}", is_x86_feature_detected!("avxneconvert"));
     println!("avxifma: {:?}", is_x86_feature_detected!("avxifma"));
-    println!(
-        "avxvnniint16: {:?}",
-        is_x86_feature_detected!("avxvnniint16")
-    );
+    println!("avxvnniint16: {:?}", is_x86_feature_detected!("avxvnniint16"));
     println!("amx-bf16: {:?}", is_x86_feature_detected!("amx-bf16"));
     println!("amx-tile: {:?}", is_x86_feature_detected!("amx-tile"));
     println!("amx-int8: {:?}", is_x86_feature_detected!("amx-int8"));
@@ -96,10 +76,7 @@ fn dump() {
     println!("widekl: {:?}", is_x86_feature_detected!("widekl"));
     println!("movrs: {:?}", is_x86_feature_detected!("movrs"));
     println!("amx-fp8: {:?}", is_x86_feature_detected!("amx-fp8"));
-    println!(
-        "amx-transpose: {:?}",
-        is_x86_feature_detected!("amx-transpose")
-    );
+    println!("amx-transpose: {:?}", is_x86_feature_detected!("amx-transpose"));
     println!("amx-tf32: {:?}", is_x86_feature_detected!("amx-tf32"));
     println!("amx-avx512: {:?}", is_x86_feature_detected!("amx-avx512"));
     println!("amx-movrs: {:?}", is_x86_feature_detected!("amx-movrs"));
@@ -110,8 +87,5 @@ fn dump() {
 fn x86_deprecated() {
     println!("avx512gfni {:?}", is_x86_feature_detected!("avx512gfni"));
     println!("avx512vaes {:?}", is_x86_feature_detected!("avx512vaes"));
-    println!(
-        "avx512vpclmulqdq {:?}",
-        is_x86_feature_detected!("avx512vpclmulqdq")
-    );
+    println!("avx512vpclmulqdq {:?}", is_x86_feature_detected!("avx512vpclmulqdq"));
 }
-- 
cgit 1.4.1-3-g733a5


From 8dc2abb5c3a8de5982dd979ddaf722b4b6cc40fd Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 10:15:38 +0200
Subject: Update stdarch README

---
 library/stdarch/README.md | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/library/stdarch/README.md b/library/stdarch/README.md
index 9a35f4cd6ff..50905b49e80 100644
--- a/library/stdarch/README.md
+++ b/library/stdarch/README.md
@@ -4,16 +4,8 @@ stdarch - Rust's standard library SIMD components
 [![Actions Status](https://github.com/rust-lang/stdarch/workflows/CI/badge.svg)](https://github.com/rust-lang/stdarch/actions)
 
 
-# Crates
-
-This repository contains two main crates:
-
-* [`core_arch`](crates/core_arch/README.md) implements `core::arch` - Rust's
-  core library architecture-specific intrinsics, and
+This repository contains the [`core_arch`](crates/core_arch/README.md) crate, which implements `core::arch` - Rust's core library architecture-specific intrinsics.
   
-* [`std_detect`](crates/std_detect/README.md) implements `std::detect` - Rust's
-  standard library run-time CPU feature detection.
-
 The `std::simd` component now lives in the
 [`packed_simd_2`](https://github.com/rust-lang/packed_simd) crate.
 
-- 
cgit 1.4.1-3-g733a5


From e07a1bbb79fc3fb400ac4a2f25bb37cd8a0c245b Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 10:23:36 +0200
Subject: Move tests around to appease `tidy`

---
 library/std_detect/src/detect/macros.rs            |   2 +-
 library/std_detect/src/detect/os/linux/aarch64.rs  |  82 +--------------
 .../src/detect/os/linux/aarch64/tests.rs           |  77 ++++++++++++++
 library/std_detect/src/detect/os/linux/auxvec.rs   | 114 +--------------------
 .../std_detect/src/detect/os/linux/auxvec/tests.rs | 111 ++++++++++++++++++++
 library/std_detect/src/detect/os/riscv.rs          |  67 +-----------
 library/std_detect/src/detect/os/riscv/tests.rs    |  64 ++++++++++++
 src/tools/tidy/src/unit_tests.rs                   |   3 +-
 8 files changed, 258 insertions(+), 262 deletions(-)
 create mode 100644 library/std_detect/src/detect/os/linux/aarch64/tests.rs
 create mode 100644 library/std_detect/src/detect/os/linux/auxvec/tests.rs
 create mode 100644 library/std_detect/src/detect/os/riscv/tests.rs

diff --git a/library/std_detect/src/detect/macros.rs b/library/std_detect/src/detect/macros.rs
index a2994fb7daa..c2a006d3753 100644
--- a/library/std_detect/src/detect/macros.rs
+++ b/library/std_detect/src/detect/macros.rs
@@ -131,7 +131,7 @@ macro_rules! features {
             };
         }
 
-        #[test]
+        #[test] //tidy:skip
         #[deny(unexpected_cfgs)]
         #[deny(unfulfilled_lint_expectations)]
         fn unexpected_cfgs() {
diff --git a/library/std_detect/src/detect/os/linux/aarch64.rs b/library/std_detect/src/detect/os/linux/aarch64.rs
index 0de4beeae8b..87a9d6ebb88 100644
--- a/library/std_detect/src/detect/os/linux/aarch64.rs
+++ b/library/std_detect/src/detect/os/linux/aarch64.rs
@@ -395,84 +395,4 @@ impl AtHwcap {
 
 #[cfg(target_endian = "little")]
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[cfg(feature = "std_detect_file_io")]
-    mod auxv_from_file {
-        use super::auxvec::auxv_from_file;
-        use super::*;
-        // The baseline hwcaps used in the (artificial) auxv test files.
-        fn baseline_hwcaps() -> AtHwcap {
-            AtHwcap {
-                fp: true,
-                asimd: true,
-                aes: true,
-                pmull: true,
-                sha1: true,
-                sha2: true,
-                crc32: true,
-                atomics: true,
-                fphp: true,
-                asimdhp: true,
-                asimdrdm: true,
-                lrcpc: true,
-                dcpop: true,
-                asimddp: true,
-                ssbs: true,
-                ..AtHwcap::default()
-            }
-        }
-
-        #[test]
-        fn linux_empty_hwcap2_aarch64() {
-            let file = concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv"
-            );
-            println!("file: {file}");
-            let v = auxv_from_file(file).unwrap();
-            println!("HWCAP : 0x{:0x}", v.hwcap);
-            println!("HWCAP2: 0x{:0x}", v.hwcap2);
-            assert_eq!(AtHwcap::from(v), baseline_hwcaps());
-        }
-        #[test]
-        fn linux_no_hwcap2_aarch64() {
-            let file = concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv"
-            );
-            println!("file: {file}");
-            let v = auxv_from_file(file).unwrap();
-            println!("HWCAP : 0x{:0x}", v.hwcap);
-            println!("HWCAP2: 0x{:0x}", v.hwcap2);
-            assert_eq!(AtHwcap::from(v), baseline_hwcaps());
-        }
-        #[test]
-        fn linux_hwcap2_aarch64() {
-            let file = concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/src/detect/test_data/linux-hwcap2-aarch64.auxv"
-            );
-            println!("file: {file}");
-            let v = auxv_from_file(file).unwrap();
-            println!("HWCAP : 0x{:0x}", v.hwcap);
-            println!("HWCAP2: 0x{:0x}", v.hwcap2);
-            assert_eq!(
-                AtHwcap::from(v),
-                AtHwcap {
-                    // Some other HWCAP bits.
-                    paca: true,
-                    pacg: true,
-                    // HWCAP2-only bits.
-                    dcpodp: true,
-                    frint: true,
-                    rng: true,
-                    bti: true,
-                    mte: true,
-                    ..baseline_hwcaps()
-                }
-            );
-        }
-    }
-}
+mod tests;
diff --git a/library/std_detect/src/detect/os/linux/aarch64/tests.rs b/library/std_detect/src/detect/os/linux/aarch64/tests.rs
new file mode 100644
index 00000000000..a3562f2fd93
--- /dev/null
+++ b/library/std_detect/src/detect/os/linux/aarch64/tests.rs
@@ -0,0 +1,77 @@
+use super::*;
+
+#[cfg(feature = "std_detect_file_io")]
+mod auxv_from_file {
+    use super::auxvec::auxv_from_file;
+    use super::*;
+    // The baseline hwcaps used in the (artificial) auxv test files.
+    fn baseline_hwcaps() -> AtHwcap {
+        AtHwcap {
+            fp: true,
+            asimd: true,
+            aes: true,
+            pmull: true,
+            sha1: true,
+            sha2: true,
+            crc32: true,
+            atomics: true,
+            fphp: true,
+            asimdhp: true,
+            asimdrdm: true,
+            lrcpc: true,
+            dcpop: true,
+            asimddp: true,
+            ssbs: true,
+            ..AtHwcap::default()
+        }
+    }
+
+    #[test]
+    fn linux_empty_hwcap2_aarch64() {
+        let file = concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/src/detect/test_data/linux-empty-hwcap2-aarch64.auxv"
+        );
+        println!("file: {file}");
+        let v = auxv_from_file(file).unwrap();
+        println!("HWCAP : 0x{:0x}", v.hwcap);
+        println!("HWCAP2: 0x{:0x}", v.hwcap2);
+        assert_eq!(AtHwcap::from(v), baseline_hwcaps());
+    }
+    #[test]
+    fn linux_no_hwcap2_aarch64() {
+        let file = concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv"
+        );
+        println!("file: {file}");
+        let v = auxv_from_file(file).unwrap();
+        println!("HWCAP : 0x{:0x}", v.hwcap);
+        println!("HWCAP2: 0x{:0x}", v.hwcap2);
+        assert_eq!(AtHwcap::from(v), baseline_hwcaps());
+    }
+    #[test]
+    fn linux_hwcap2_aarch64() {
+        let file =
+            concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-hwcap2-aarch64.auxv");
+        println!("file: {file}");
+        let v = auxv_from_file(file).unwrap();
+        println!("HWCAP : 0x{:0x}", v.hwcap);
+        println!("HWCAP2: 0x{:0x}", v.hwcap2);
+        assert_eq!(
+            AtHwcap::from(v),
+            AtHwcap {
+                // Some other HWCAP bits.
+                paca: true,
+                pacg: true,
+                // HWCAP2-only bits.
+                dcpodp: true,
+                frint: true,
+                rng: true,
+                bti: true,
+                mte: true,
+                ..baseline_hwcaps()
+            }
+        );
+    }
+}
diff --git a/library/std_detect/src/detect/os/linux/auxvec.rs b/library/std_detect/src/detect/os/linux/auxvec.rs
index 54f52aa7533..1ed395f45b9 100644
--- a/library/std_detect/src/detect/os/linux/auxvec.rs
+++ b/library/std_detect/src/detect/os/linux/auxvec.rs
@@ -226,116 +226,4 @@ fn auxv_from_buf(buf: &[usize]) -> Result<AuxVec, ()> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    // FIXME: on mips/mips64 getauxval returns 0, and /proc/self/auxv
-    // does not always contain the AT_HWCAP key under qemu.
-    #[cfg(any(
-        target_arch = "arm",
-        target_arch = "powerpc",
-        target_arch = "powerpc64",
-        target_arch = "s390x",
-    ))]
-    #[test]
-    fn auxv_crate() {
-        let v = auxv();
-        if let Ok(hwcap) = getauxval(AT_HWCAP) {
-            let rt_hwcap = v.expect("failed to find hwcap key").hwcap;
-            assert_eq!(rt_hwcap, hwcap);
-        }
-
-        // Targets with AT_HWCAP and AT_HWCAP2:
-        #[cfg(any(
-            target_arch = "aarch64",
-            target_arch = "arm",
-            target_arch = "powerpc",
-            target_arch = "powerpc64",
-            target_arch = "s390x",
-        ))]
-        {
-            if let Ok(hwcap2) = getauxval(AT_HWCAP2) {
-                let rt_hwcap2 = v.expect("failed to find hwcap2 key").hwcap2;
-                assert_eq!(rt_hwcap2, hwcap2);
-            }
-        }
-    }
-
-    #[test]
-    fn auxv_dump() {
-        if let Ok(auxvec) = auxv() {
-            println!("{:?}", auxvec);
-        } else {
-            println!("both getauxval() and reading /proc/self/auxv failed!");
-        }
-    }
-
-    #[cfg(feature = "std_detect_file_io")]
-    cfg_if::cfg_if! {
-        if #[cfg(target_arch = "arm")] {
-            #[test]
-            fn linux_rpi3() {
-                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-rpi3.auxv");
-                println!("file: {file}");
-                let v = auxv_from_file(file).unwrap();
-                assert_eq!(v.hwcap, 4174038);
-                assert_eq!(v.hwcap2, 16);
-            }
-
-            #[test]
-            fn linux_macos_vb() {
-                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv");
-                println!("file: {file}");
-                // The file contains HWCAP but not HWCAP2. In that case, we treat HWCAP2 as zero.
-                let v = auxv_from_file(file).unwrap();
-                assert_eq!(v.hwcap, 126614527);
-                assert_eq!(v.hwcap2, 0);
-            }
-        } else if #[cfg(target_arch = "aarch64")] {
-            #[cfg(target_endian = "little")]
-            #[test]
-            fn linux_artificial_aarch64() {
-                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-artificial-aarch64.auxv");
-                println!("file: {file}");
-                let v = auxv_from_file(file).unwrap();
-                assert_eq!(v.hwcap, 0x0123456789abcdef);
-                assert_eq!(v.hwcap2, 0x02468ace13579bdf);
-            }
-            #[cfg(target_endian = "little")]
-            #[test]
-            fn linux_no_hwcap2_aarch64() {
-                let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv");
-                println!("file: {file}");
-                let v = auxv_from_file(file).unwrap();
-                // An absent HWCAP2 is treated as zero, and does not prevent acceptance of HWCAP.
-                assert_ne!(v.hwcap, 0);
-                assert_eq!(v.hwcap2, 0);
-            }
-        }
-    }
-
-    #[test]
-    #[cfg(feature = "std_detect_file_io")]
-    fn auxv_dump_procfs() {
-        if let Ok(auxvec) = auxv_from_file("/proc/self/auxv") {
-            println!("{:?}", auxvec);
-        } else {
-            println!("reading /proc/self/auxv failed!");
-        }
-    }
-
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "arm",
-        target_arch = "powerpc",
-        target_arch = "powerpc64",
-        target_arch = "s390x",
-    ))]
-    #[test]
-    #[cfg(feature = "std_detect_file_io")]
-    fn auxv_crate_procfs() {
-        if let Ok(procfs_auxv) = auxv_from_file("/proc/self/auxv") {
-            assert_eq!(auxv().unwrap(), procfs_auxv);
-        }
-    }
-}
+mod tests;
diff --git a/library/std_detect/src/detect/os/linux/auxvec/tests.rs b/library/std_detect/src/detect/os/linux/auxvec/tests.rs
new file mode 100644
index 00000000000..c0e0ae12a05
--- /dev/null
+++ b/library/std_detect/src/detect/os/linux/auxvec/tests.rs
@@ -0,0 +1,111 @@
+use super::*;
+
+// FIXME: on mips/mips64 getauxval returns 0, and /proc/self/auxv
+// does not always contain the AT_HWCAP key under qemu.
+#[cfg(any(
+    target_arch = "arm",
+    target_arch = "powerpc",
+    target_arch = "powerpc64",
+    target_arch = "s390x",
+))]
+#[test]
+fn auxv_crate() {
+    let v = auxv();
+    if let Ok(hwcap) = getauxval(AT_HWCAP) {
+        let rt_hwcap = v.expect("failed to find hwcap key").hwcap;
+        assert_eq!(rt_hwcap, hwcap);
+    }
+
+    // Targets with AT_HWCAP and AT_HWCAP2:
+    #[cfg(any(
+        target_arch = "aarch64",
+        target_arch = "arm",
+        target_arch = "powerpc",
+        target_arch = "powerpc64",
+        target_arch = "s390x",
+    ))]
+    {
+        if let Ok(hwcap2) = getauxval(AT_HWCAP2) {
+            let rt_hwcap2 = v.expect("failed to find hwcap2 key").hwcap2;
+            assert_eq!(rt_hwcap2, hwcap2);
+        }
+    }
+}
+
+#[test]
+fn auxv_dump() {
+    if let Ok(auxvec) = auxv() {
+        println!("{:?}", auxvec);
+    } else {
+        println!("both getauxval() and reading /proc/self/auxv failed!");
+    }
+}
+
+#[cfg(feature = "std_detect_file_io")]
+cfg_if::cfg_if! {
+    if #[cfg(target_arch = "arm")] {
+        #[test]
+        fn linux_rpi3() {
+            let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-rpi3.auxv");
+            println!("file: {file}");
+            let v = auxv_from_file(file).unwrap();
+            assert_eq!(v.hwcap, 4174038);
+            assert_eq!(v.hwcap2, 16);
+        }
+
+        #[test]
+        fn linux_macos_vb() {
+            let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv");
+            println!("file: {file}");
+            // The file contains HWCAP but not HWCAP2. In that case, we treat HWCAP2 as zero.
+            let v = auxv_from_file(file).unwrap();
+            assert_eq!(v.hwcap, 126614527);
+            assert_eq!(v.hwcap2, 0);
+        }
+    } else if #[cfg(target_arch = "aarch64")] {
+        #[cfg(target_endian = "little")]
+        #[test]
+        fn linux_artificial_aarch64() {
+            let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-artificial-aarch64.auxv");
+            println!("file: {file}");
+            let v = auxv_from_file(file).unwrap();
+            assert_eq!(v.hwcap, 0x0123456789abcdef);
+            assert_eq!(v.hwcap2, 0x02468ace13579bdf);
+        }
+        #[cfg(target_endian = "little")]
+        #[test]
+        fn linux_no_hwcap2_aarch64() {
+            let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv");
+            println!("file: {file}");
+            let v = auxv_from_file(file).unwrap();
+            // An absent HWCAP2 is treated as zero, and does not prevent acceptance of HWCAP.
+            assert_ne!(v.hwcap, 0);
+            assert_eq!(v.hwcap2, 0);
+        }
+    }
+}
+
+#[test]
+#[cfg(feature = "std_detect_file_io")]
+fn auxv_dump_procfs() {
+    if let Ok(auxvec) = auxv_from_file("/proc/self/auxv") {
+        println!("{:?}", auxvec);
+    } else {
+        println!("reading /proc/self/auxv failed!");
+    }
+}
+
+#[cfg(any(
+    target_arch = "aarch64",
+    target_arch = "arm",
+    target_arch = "powerpc",
+    target_arch = "powerpc64",
+    target_arch = "s390x",
+))]
+#[test]
+#[cfg(feature = "std_detect_file_io")]
+fn auxv_crate_procfs() {
+    if let Ok(procfs_auxv) = auxv_from_file("/proc/self/auxv") {
+        assert_eq!(auxv().unwrap(), procfs_auxv);
+    }
+}
diff --git a/library/std_detect/src/detect/os/riscv.rs b/library/std_detect/src/detect/os/riscv.rs
index 4c59ede8029..46b7dd71eb3 100644
--- a/library/std_detect/src/detect/os/riscv.rs
+++ b/library/std_detect/src/detect/os/riscv.rs
@@ -135,69 +135,4 @@ pub(crate) fn imply_features(mut value: cache::Initializer) -> cache::Initialize
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn simple_direct() {
-        let mut value = cache::Initializer::default();
-        value.set(Feature::f as u32);
-        // F (and other extensions with CSRs) -> Zicsr
-        assert!(imply_features(value).test(Feature::zicsr as u32));
-    }
-
-    #[test]
-    fn simple_indirect() {
-        let mut value = cache::Initializer::default();
-        value.set(Feature::q as u32);
-        // Q -> D, D -> F, F -> Zicsr
-        assert!(imply_features(value).test(Feature::zicsr as u32));
-    }
-
-    #[test]
-    fn complex_zcd() {
-        let mut value = cache::Initializer::default();
-        // C & D -> Zcd
-        value.set(Feature::c as u32);
-        assert!(!imply_features(value).test(Feature::zcd as u32));
-        value.set(Feature::d as u32);
-        assert!(imply_features(value).test(Feature::zcd as u32));
-    }
-
-    #[test]
-    fn group_simple_forward() {
-        let mut value = cache::Initializer::default();
-        // A -> Zalrsc & Zaamo (forward implication)
-        value.set(Feature::a as u32);
-        let value = imply_features(value);
-        assert!(value.test(Feature::zalrsc as u32));
-        assert!(value.test(Feature::zaamo as u32));
-    }
-
-    #[test]
-    fn group_simple_backward() {
-        let mut value = cache::Initializer::default();
-        // Zalrsc & Zaamo -> A (reverse implication)
-        value.set(Feature::zalrsc as u32);
-        value.set(Feature::zaamo as u32);
-        assert!(imply_features(value).test(Feature::a as u32));
-    }
-
-    #[test]
-    fn group_complex_convergence() {
-        let mut value = cache::Initializer::default();
-        // Needs 3 iterations to converge
-        // (and 4th iteration for convergence checking):
-        // 1.  [Zvksc] -> Zvks & Zvbc
-        // 2.  Zvks -> Zvksed & Zvksh & Zvkb & Zvkt
-        // 3a. [Zvkned] & [Zvknhb] & [Zvkb] & Zvkt -> {Zvkn}
-        // 3b. Zvkn & Zvbc -> {Zvknc}
-        value.set(Feature::zvksc as u32);
-        value.set(Feature::zvkned as u32);
-        value.set(Feature::zvknhb as u32);
-        value.set(Feature::zvkb as u32);
-        let value = imply_features(value);
-        assert!(value.test(Feature::zvkn as u32));
-        assert!(value.test(Feature::zvknc as u32));
-    }
-}
+mod tests;
diff --git a/library/std_detect/src/detect/os/riscv/tests.rs b/library/std_detect/src/detect/os/riscv/tests.rs
new file mode 100644
index 00000000000..99a81dee05a
--- /dev/null
+++ b/library/std_detect/src/detect/os/riscv/tests.rs
@@ -0,0 +1,64 @@
+use super::*;
+
+#[test]
+fn simple_direct() {
+    let mut value = cache::Initializer::default();
+    value.set(Feature::f as u32);
+    // F (and other extensions with CSRs) -> Zicsr
+    assert!(imply_features(value).test(Feature::zicsr as u32));
+}
+
+#[test]
+fn simple_indirect() {
+    let mut value = cache::Initializer::default();
+    value.set(Feature::q as u32);
+    // Q -> D, D -> F, F -> Zicsr
+    assert!(imply_features(value).test(Feature::zicsr as u32));
+}
+
+#[test]
+fn complex_zcd() {
+    let mut value = cache::Initializer::default();
+    // C & D -> Zcd
+    value.set(Feature::c as u32);
+    assert!(!imply_features(value).test(Feature::zcd as u32));
+    value.set(Feature::d as u32);
+    assert!(imply_features(value).test(Feature::zcd as u32));
+}
+
+#[test]
+fn group_simple_forward() {
+    let mut value = cache::Initializer::default();
+    // A -> Zalrsc & Zaamo (forward implication)
+    value.set(Feature::a as u32);
+    let value = imply_features(value);
+    assert!(value.test(Feature::zalrsc as u32));
+    assert!(value.test(Feature::zaamo as u32));
+}
+
+#[test]
+fn group_simple_backward() {
+    let mut value = cache::Initializer::default();
+    // Zalrsc & Zaamo -> A (reverse implication)
+    value.set(Feature::zalrsc as u32);
+    value.set(Feature::zaamo as u32);
+    assert!(imply_features(value).test(Feature::a as u32));
+}
+
+#[test]
+fn group_complex_convergence() {
+    let mut value = cache::Initializer::default();
+    // Needs 3 iterations to converge
+    // (and 4th iteration for convergence checking):
+    // 1.  [Zvksc] -> Zvks & Zvbc
+    // 2.  Zvks -> Zvksed & Zvksh & Zvkb & Zvkt
+    // 3a. [Zvkned] & [Zvknhb] & [Zvkb] & Zvkt -> {Zvkn}
+    // 3b. Zvkn & Zvbc -> {Zvknc}
+    value.set(Feature::zvksc as u32);
+    value.set(Feature::zvkned as u32);
+    value.set(Feature::zvknhb as u32);
+    value.set(Feature::zvkb as u32);
+    let value = imply_features(value);
+    assert!(value.test(Feature::zvkn as u32));
+    assert!(value.test(Feature::zvknc as u32));
+}
diff --git a/src/tools/tidy/src/unit_tests.rs b/src/tools/tidy/src/unit_tests.rs
index 90ef36d5882..df9146b5147 100644
--- a/src/tools/tidy/src/unit_tests.rs
+++ b/src/tools/tidy/src/unit_tests.rs
@@ -56,7 +56,8 @@ pub fn check(root_path: &Path, bad: &mut bool) {
             let line = line.trim();
             let is_test = || line.contains("#[test]") && !line.contains("`#[test]");
             let is_bench = || line.contains("#[bench]") && !line.contains("`#[bench]");
-            if !line.starts_with("//") && (is_test() || is_bench()) {
+            let manual_skip = line.contains("//tidy:skip");
+            if !line.starts_with("//") && (is_test() || is_bench()) && !manual_skip {
                 let explanation = if is_core {
                     "`core` unit tests and benchmarks must be placed into `coretests`"
                 } else if is_alloc {
-- 
cgit 1.4.1-3-g733a5


From ffa97a647e3786add894093aa2cc7561c7c64607 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 4 Jul 2025 15:25:28 +0200
Subject: Fix warning

---
 library/std_detect/tests/cpu-detection.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/library/std_detect/tests/cpu-detection.rs b/library/std_detect/tests/cpu-detection.rs
index 09a73572c1f..5ad32d83237 100644
--- a/library/std_detect/tests/cpu-detection.rs
+++ b/library/std_detect/tests/cpu-detection.rs
@@ -27,6 +27,16 @@
     ),
     macro_use
 )]
+#[cfg(any(
+    target_arch = "arm",
+    target_arch = "aarch64",
+    target_arch = "arm64ec",
+    target_arch = "riscv32",
+    target_arch = "riscv64",
+    target_arch = "powerpc",
+    target_arch = "powerpc64",
+    target_arch = "s390x",
+))]
 extern crate std_detect;
 
 #[test]
-- 
cgit 1.4.1-3-g733a5


From 608297247a776a32c4aca08f1784caca8a3c33e8 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Sun, 13 Jul 2025 13:08:17 +0200
Subject: Remove `std_detect` from stdarch examples

---
 library/stdarch/Cargo.lock           | 23 -----------------------
 library/stdarch/examples/Cargo.toml  |  1 -
 library/stdarch/examples/connect5.rs | 16 ++++++++++++----
 library/stdarch/examples/hex.rs      |  8 ++++++--
 4 files changed, 18 insertions(+), 30 deletions(-)

diff --git a/library/stdarch/Cargo.lock b/library/stdarch/Cargo.lock
index 4806682e6e0..21ce304db0d 100644
--- a/library/stdarch/Cargo.lock
+++ b/library/stdarch/Cargo.lock
@@ -580,18 +580,6 @@ version = "0.1.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "989e6739f80c4ad5b13e0fd7fe89531180375b18520cc8c82080e4dc4035b84f"
 
-[[package]]
-name = "rustc-std-workspace-alloc"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9d441c3b2ebf55cebf796bfdc265d67fa09db17b7bb6bd4be75c509e1e8fec3"
-
-[[package]]
-name = "rustc-std-workspace-core"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa9c45b374136f52f2d6311062c7146bff20fec063c3f5d46a410bd937746955"
-
 [[package]]
 name = "ryu"
 version = "1.0.20"
@@ -694,16 +682,6 @@ dependencies = [
  "syn 2.0.104",
 ]
 
-[[package]]
-name = "std_detect"
-version = "0.1.5"
-dependencies = [
- "cfg-if",
- "libc",
- "rustc-std-workspace-alloc",
- "rustc-std-workspace-core",
-]
-
 [[package]]
 name = "stdarch-gen-arm"
 version = "0.1.0"
@@ -756,7 +734,6 @@ dependencies = [
  "core_arch",
  "quickcheck",
  "rand",
- "std_detect",
 ]
 
 [[package]]
diff --git a/library/stdarch/examples/Cargo.toml b/library/stdarch/examples/Cargo.toml
index 61184494e15..61451edee84 100644
--- a/library/stdarch/examples/Cargo.toml
+++ b/library/stdarch/examples/Cargo.toml
@@ -12,7 +12,6 @@ default-run = "hex"
 
 [dependencies]
 core_arch = { path = "../crates/core_arch" }
-std_detect = { path = "../crates/std_detect" }
 quickcheck = "1.0"
 rand = "0.8"
 
diff --git a/library/stdarch/examples/connect5.rs b/library/stdarch/examples/connect5.rs
index 1d8e0f0990a..371b28552b3 100644
--- a/library/stdarch/examples/connect5.rs
+++ b/library/stdarch/examples/connect5.rs
@@ -40,9 +40,13 @@ use std::cmp;
 use std::time::Instant;
 
 #[cfg(target_arch = "x86")]
-use {core_arch::arch::x86::*, std_detect::is_x86_feature_detected};
+use core_arch::arch::x86::*;
 #[cfg(target_arch = "x86_64")]
-use {core_arch::arch::x86_64::*, std_detect::is_x86_feature_detected};
+use core_arch::arch::x86_64::*;
+#[cfg(target_arch = "x86")]
+use std::is_x86_feature_detected;
+#[cfg(target_arch = "x86_64")]
+use std::is_x86_feature_detected;
 
 // types
 
@@ -558,8 +562,12 @@ fn search(pos: &Pos, alpha: i32, beta: i32, depth: i32, _ply: i32) -> i32 {
     assert_ne!(bm, MOVE_NONE);
     assert!(bs >= -EVAL_INF && bs <= EVAL_INF);
 
-    // best move at the root node, best score elsewhere
-    if _ply == 0 { bm } else { bs }
+    //best move at the root node, best score elsewhere
+    if _ply == 0 {
+        bm
+    } else {
+        bs
+    }
 }
 
 /// Evaluation function: give different scores to different patterns after a fixed depth.
diff --git a/library/stdarch/examples/hex.rs b/library/stdarch/examples/hex.rs
index e393ad72716..95ffbaf666c 100644
--- a/library/stdarch/examples/hex.rs
+++ b/library/stdarch/examples/hex.rs
@@ -36,9 +36,13 @@ use std::{
 };
 
 #[cfg(target_arch = "x86")]
-use {core_arch::arch::x86::*, std_detect::is_x86_feature_detected};
+use core_arch::arch::x86::*;
 #[cfg(target_arch = "x86_64")]
-use {core_arch::arch::x86_64::*, std_detect::is_x86_feature_detected};
+use core_arch::arch::x86_64::*;
+#[cfg(target_arch = "x86")]
+use std::is_x86_feature_detected;
+#[cfg(target_arch = "x86_64")]
+use std::is_x86_feature_detected;
 
 fn main() {
     let mut input = Vec::new();
-- 
cgit 1.4.1-3-g733a5


From 847f8db5ad2d3b369ce97935dd770a15280ddf96 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Sun, 13 Jul 2025 13:41:22 +0200
Subject: Remove `std_detect` from stdarch's CI

---
 library/stdarch/.github/workflows/main.yml | 13 +--------
 library/stdarch/ci/build-std-detect.sh     | 46 ------------------------------
 library/stdarch/ci/dox.sh                  |  3 --
 library/stdarch/ci/run-docker.sh           |  1 -
 library/stdarch/ci/run.sh                  | 10 +------
 5 files changed, 2 insertions(+), 71 deletions(-)
 delete mode 100755 library/stdarch/ci/build-std-detect.sh

diff --git a/library/stdarch/.github/workflows/main.yml b/library/stdarch/.github/workflows/main.yml
index 59aad0b5d01..048ce986460 100644
--- a/library/stdarch/.github/workflows/main.yml
+++ b/library/stdarch/.github/workflows/main.yml
@@ -258,7 +258,7 @@ jobs:
   # Check that the generated files agree with the checked-in versions.
   check-stdarch-gen:
     needs: [style]
-    name: Check stdarch-gen-{arm, loongarch} output 
+    name: Check stdarch-gen-{arm, loongarch} output
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
@@ -277,22 +277,11 @@ jobs:
         cargo run --bin=stdarch-gen-loongarch --release -- crates/stdarch-gen-loongarch/lasx.spec
         git diff --exit-code
 
-  build-std-detect:
-    needs: [style]
-    name: Build std_detect
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install Rust
-      run: rustup update nightly && rustup default nightly
-    - run: ./ci/build-std-detect.sh
-
   conclusion:
     needs:
       - docs
       - verify
       - test
-      - build-std-detect
       - check-stdarch-gen
     runs-on: ubuntu-latest
     # We need to ensure this job does *not* get skipped if its dependencies fail,
diff --git a/library/stdarch/ci/build-std-detect.sh b/library/stdarch/ci/build-std-detect.sh
deleted file mode 100755
index e79a497cc35..00000000000
--- a/library/stdarch/ci/build-std-detect.sh
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/usr/bin/env bash
-
-# Build std_detect on non-Linux & non-x86 targets.
-#
-# In std_detect, non-x86 targets have OS-specific implementations,
-# but we can test only Linux in CI. This script builds targets supported
-# by std_detect but cannot be tested in CI.
-
-set -ex
-cd "$(dirname "$0")"/..
-
-targets=(
-    # Linux
-    aarch64-unknown-linux-musl
-    armv5te-unknown-linux-musleabi
-    aarch64-unknown-linux-ohos
-    armv7-unknown-linux-ohos
-
-    # Android
-    aarch64-linux-android
-    arm-linux-androideabi
-
-    # FreeBSD
-    aarch64-unknown-freebsd
-    armv6-unknown-freebsd
-    powerpc-unknown-freebsd
-    powerpc64-unknown-freebsd
-
-    # OpenBSD
-    aarch64-unknown-openbsd
-
-    # Windows
-    aarch64-pc-windows-msvc
-)
-
-rustup component add rust-src # for -Z build-std
-
-cd crates/std_detect
-for target in "${targets[@]}"; do
-    if rustup target add "${target}" &>/dev/null; then
-        cargo build --target "${target}"
-    else
-        # tier 3 targets requires -Z build-std.
-        cargo build -Z build-std="core,alloc" --target "${target}"
-    fi
-done
diff --git a/library/stdarch/ci/dox.sh b/library/stdarch/ci/dox.sh
index 910265fad84..94d76d43047 100755
--- a/library/stdarch/ci/dox.sh
+++ b/library/stdarch/ci/dox.sh
@@ -16,10 +16,7 @@ dox() {
   cargo clean --target "${1}"
 
   cargo build --verbose --target "${1}" --manifest-path crates/core_arch/Cargo.toml
-  cargo build --verbose --target "${1}" --manifest-path crates/std_detect/Cargo.toml
-
   cargo doc --verbose --target "${1}" --manifest-path crates/core_arch/Cargo.toml
-  cargo doc --verbose --target "${1}" --manifest-path crates/std_detect/Cargo.toml
 }
 
 if [ -z "$1" ]; then
diff --git a/library/stdarch/ci/run-docker.sh b/library/stdarch/ci/run-docker.sh
index 657353004dc..d7aa50a8c96 100755
--- a/library/stdarch/ci/run-docker.sh
+++ b/library/stdarch/ci/run-docker.sh
@@ -37,7 +37,6 @@ run() {
       --env NORUN \
       --env RUSTFLAGS \
       --env CARGO_UNSTABLE_BUILD_STD \
-      --env RUST_STD_DETECT_UNSTABLE \
       --volume "${HOME}/.cargo":/cargo \
       --volume "$(rustc --print sysroot)":/rust:ro \
       --volume "$(pwd)":/checkout:ro \
diff --git a/library/stdarch/ci/run.sh b/library/stdarch/ci/run.sh
index 78a808b46a0..aa4479395d5 100755
--- a/library/stdarch/ci/run.sh
+++ b/library/stdarch/ci/run.sh
@@ -78,20 +78,12 @@ cargo_test() {
 }
 
 CORE_ARCH="--manifest-path=crates/core_arch/Cargo.toml"
-STD_DETECT="--manifest-path=crates/std_detect/Cargo.toml"
 STDARCH_EXAMPLES="--manifest-path=examples/Cargo.toml"
 INTRINSIC_TEST="--manifest-path=crates/intrinsic-test/Cargo.toml"
 
 cargo_test "${CORE_ARCH} ${PROFILE}"
 
 if [ "$NOSTD" != "1" ]; then
-    cargo_test "${STD_DETECT} ${PROFILE}"
-
-    cargo_test "${STD_DETECT} --no-default-features"
-    cargo_test "${STD_DETECT} --no-default-features --features=std_detect_file_io"
-    cargo_test "${STD_DETECT} --no-default-features --features=std_detect_dlsym_getauxval"
-    cargo_test "${STD_DETECT} --no-default-features --features=std_detect_dlsym_getauxval,std_detect_file_io"
-
     cargo_test "${STDARCH_EXAMPLES} ${PROFILE}"
 fi
 
@@ -139,7 +131,7 @@ case ${TARGET} in
         cargo_test "${PROFILE}"
         ;;
 
-    # Setup aarch64 & armv7 specific variables, the runner, along with some 
+    # Setup aarch64 & armv7 specific variables, the runner, along with some
     # tests to skip
     aarch64-unknown-linux-gnu*)
         TEST_CPPFLAGS="-fuse-ld=lld -I/usr/aarch64-linux-gnu/include/ -I/usr/aarch64-linux-gnu/include/c++/9/aarch64-linux-gnu/"
-- 
cgit 1.4.1-3-g733a5


From cbd9fe012acad68ce8ea2cb90b23589cd2bb0c31 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Sun, 13 Jul 2025 14:37:28 +0200
Subject: Bless bootstrap tests

---
 src/bootstrap/src/core/builder/tests.rs | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/bootstrap/src/core/builder/tests.rs b/src/bootstrap/src/core/builder/tests.rs
index 105d4229e75..6ea5d4e6553 100644
--- a/src/bootstrap/src/core/builder/tests.rs
+++ b/src/bootstrap/src/core/builder/tests.rs
@@ -999,7 +999,7 @@ mod snapshot {
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustdoc 0 <host>
-        [doc] std 1 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        [doc] std 1 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,std_detect,sysroot,test,unwind]
         ");
     }
 
@@ -1048,7 +1048,7 @@ mod snapshot {
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,std_detect,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> LintDocs 1 <host>
         [build] rustc 0 <host> -> RustInstaller 1 <host>
@@ -1090,7 +1090,7 @@ mod snapshot {
         [build] rustc 1 <host> -> WasmComponentLd 2 <host>
         [build] rustc 1 <host> -> LlvmBitcodeLinker 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,std_detect,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> LintDocs 1 <host>
         [build] rustc 0 <host> -> RustInstaller 1 <host>
@@ -1126,8 +1126,8 @@ mod snapshot {
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
-        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,std_detect,sysroot,test,unwind]
+        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,std_detect,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> LintDocs 1 <host>
         [build] rustc 0 <host> -> RustInstaller 1 <host>
@@ -1163,7 +1163,7 @@ mod snapshot {
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,std_detect,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> LintDocs 1 <host>
         [build] rustc 1 <host> -> std 1 <target1>
@@ -1200,8 +1200,8 @@ mod snapshot {
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
-        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        [doc] std 2 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,std_detect,sysroot,test,unwind]
+        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,std_detect,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> LintDocs 1 <host>
         [build] rustc 1 <host> -> std 1 <target1>
@@ -1242,7 +1242,7 @@ mod snapshot {
         [build] rustc 1 <host> -> std 1 <host>
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,std_detect,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 0 <host> -> RustInstaller 1 <host>
         [dist] docs <target1>
@@ -1274,7 +1274,7 @@ mod snapshot {
         [build] rustc 1 <host> -> rustc 2 <host>
         [build] rustc 1 <host> -> WasmComponentLd 2 <host>
         [build] rustdoc 1 <host>
-        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        [doc] std 2 <target1> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,std_detect,sysroot,test,unwind]
         [build] rustc 2 <host> -> std 2 <host>
         [build] rustc 1 <host> -> std 1 <target1>
         [build] rustc 2 <host> -> std 2 <target1>
@@ -1620,7 +1620,7 @@ mod snapshot {
         [build] llvm <host>
         [build] rustc 0 <host> -> rustc 1 <host>
         [build] rustdoc 0 <host>
-        [doc] std 1 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,sysroot,test,unwind]
+        [doc] std 1 <host> crates=[alloc,compiler_builtins,core,panic_abort,panic_unwind,proc_macro,std,std_detect,sysroot,test,unwind]
         ");
     }
 
-- 
cgit 1.4.1-3-g733a5


From 5e52677a82c6c146469561c97ca4c63a75242102 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Mon, 14 Jul 2025 21:57:08 +0200
Subject: Remove licenses from std-detect

They are subsumed by the main repo licenses.
---
 library/std_detect/LICENSE-APACHE | 201 --------------------------------------
 library/std_detect/LICENSE-MIT    |  25 -----
 2 files changed, 226 deletions(-)
 delete mode 100644 library/std_detect/LICENSE-APACHE
 delete mode 100644 library/std_detect/LICENSE-MIT

diff --git a/library/std_detect/LICENSE-APACHE b/library/std_detect/LICENSE-APACHE
deleted file mode 100644
index 16fe87b06e8..00000000000
--- a/library/std_detect/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/library/std_detect/LICENSE-MIT b/library/std_detect/LICENSE-MIT
deleted file mode 100644
index 52d82415d8b..00000000000
--- a/library/std_detect/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2017 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-- 
cgit 1.4.1-3-g733a5


From 81d90d8257e59bc27acd6ec98f3cce3d27de6755 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 18 Jul 2025 08:49:28 +0200
Subject: Improve error messages of auxv loading

---
 library/std_detect/src/detect/os/linux/auxvec.rs | 17 +++++++++++------
 library/std_detect/src/detect/os/linux/mod.rs    | 10 ++++++----
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/library/std_detect/src/detect/os/linux/auxvec.rs b/library/std_detect/src/detect/os/linux/auxvec.rs
index 1ed395f45b9..443caaaa186 100644
--- a/library/std_detect/src/detect/os/linux/auxvec.rs
+++ b/library/std_detect/src/detect/os/linux/auxvec.rs
@@ -119,7 +119,7 @@ pub(crate) fn auxv() -> Result<AuxVec, ()> {
     {
         // If calling getauxval fails, try to read the auxiliary vector from
         // its file:
-        auxv_from_file("/proc/self/auxv")
+        auxv_from_file("/proc/self/auxv").map_err(|_| ())
     }
     #[cfg(not(feature = "std_detect_file_io"))]
     {
@@ -157,17 +157,22 @@ fn getauxval(key: usize) -> Result<usize, ()> {
 /// Tries to read the auxiliary vector from the `file`. If this fails, this
 /// function returns `Err`.
 #[cfg(feature = "std_detect_file_io")]
-pub(super) fn auxv_from_file(file: &str) -> Result<AuxVec, ()> {
+pub(super) fn auxv_from_file(file: &str) -> Result<AuxVec, alloc::string::String> {
     let file = super::read_file(file)?;
+    auxv_from_file_bytes(&file)
+}
 
+/// Read auxiliary vector from a slice of bytes.
+#[cfg(feature = "std_detect_file_io")]
+pub(super) fn auxv_from_file_bytes(bytes: &[u8]) -> Result<AuxVec, alloc::string::String> {
     // See <https://github.com/torvalds/linux/blob/v5.15/include/uapi/linux/auxvec.h>.
     //
     // The auxiliary vector contains at most 34 (key,value) fields: from
     // `AT_MINSIGSTKSZ` to `AT_NULL`, but its number may increase.
-    let len = file.len();
+    let len = bytes.len();
     let mut buf = alloc::vec![0_usize; 1 + len / core::mem::size_of::<usize>()];
     unsafe {
-        core::ptr::copy_nonoverlapping(file.as_ptr(), buf.as_mut_ptr() as *mut u8, len);
+        core::ptr::copy_nonoverlapping(bytes.as_ptr(), buf.as_mut_ptr() as *mut u8, len);
     }
 
     auxv_from_buf(&buf)
@@ -176,7 +181,7 @@ pub(super) fn auxv_from_file(file: &str) -> Result<AuxVec, ()> {
 /// Tries to interpret the `buffer` as an auxiliary vector. If that fails, this
 /// function returns `Err`.
 #[cfg(feature = "std_detect_file_io")]
-fn auxv_from_buf(buf: &[usize]) -> Result<AuxVec, ()> {
+fn auxv_from_buf(buf: &[usize]) -> Result<AuxVec, alloc::string::String> {
     // Targets with only AT_HWCAP:
     #[cfg(any(
         target_arch = "riscv32",
@@ -222,7 +227,7 @@ fn auxv_from_buf(buf: &[usize]) -> Result<AuxVec, ()> {
     }
     // Suppress unused variable
     let _ = buf;
-    Err(())
+    Err(alloc::string::String::from("hwcap not found"))
 }
 
 #[cfg(test)]
diff --git a/library/std_detect/src/detect/os/linux/mod.rs b/library/std_detect/src/detect/os/linux/mod.rs
index 9accd41717b..5ae2aaeab5b 100644
--- a/library/std_detect/src/detect/os/linux/mod.rs
+++ b/library/std_detect/src/detect/os/linux/mod.rs
@@ -6,14 +6,16 @@ use alloc::vec::Vec;
 mod auxvec;
 
 #[cfg(feature = "std_detect_file_io")]
-fn read_file(path: &str) -> Result<Vec<u8>, ()> {
-    let mut path = Vec::from(path.as_bytes());
+fn read_file(orig_path: &str) -> Result<Vec<u8>, alloc::string::String> {
+    use alloc::format;
+
+    let mut path = Vec::from(orig_path.as_bytes());
     path.push(0);
 
     unsafe {
         let file = libc::open(path.as_ptr() as *const libc::c_char, libc::O_RDONLY);
         if file == -1 {
-            return Err(());
+            return Err(format!("Cannot open file at {orig_path}"));
         }
 
         let mut data = Vec::new();
@@ -23,7 +25,7 @@ fn read_file(path: &str) -> Result<Vec<u8>, ()> {
             match libc::read(file, spare.as_mut_ptr() as *mut _, spare.len()) {
                 -1 => {
                     libc::close(file);
-                    return Err(());
+                    return Err(format!("Error while reading from file at {orig_path}"));
                 }
                 0 => break,
                 n => data.set_len(data.len() + n as usize),
-- 
cgit 1.4.1-3-g733a5


From 9a1179c4de485759d8d8f3bf978e26fc4e86af64 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Fri, 18 Jul 2025 08:49:59 +0200
Subject: Embed auxv files directly into the test binary

---
 .../std_detect/src/detect/os/linux/auxvec/tests.rs | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/library/std_detect/src/detect/os/linux/auxvec/tests.rs b/library/std_detect/src/detect/os/linux/auxvec/tests.rs
index c0e0ae12a05..536615fa272 100644
--- a/library/std_detect/src/detect/os/linux/auxvec/tests.rs
+++ b/library/std_detect/src/detect/os/linux/auxvec/tests.rs
@@ -44,21 +44,21 @@ fn auxv_dump() {
 #[cfg(feature = "std_detect_file_io")]
 cfg_if::cfg_if! {
     if #[cfg(target_arch = "arm")] {
+        // The tests below can be executed under qemu, where we do not have access to the test
+        // files on disk, so we need to embed them with `include_bytes!`.
         #[test]
         fn linux_rpi3() {
-            let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-rpi3.auxv");
-            println!("file: {file}");
-            let v = auxv_from_file(file).unwrap();
+            let auxv = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-rpi3.auxv"));
+            let v = auxv_from_file_bytes(auxv).unwrap();
             assert_eq!(v.hwcap, 4174038);
             assert_eq!(v.hwcap2, 16);
         }
 
         #[test]
         fn linux_macos_vb() {
-            let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv");
-            println!("file: {file}");
+            let auxv = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/macos-virtualbox-linux-x86-4850HQ.auxv"));
             // The file contains HWCAP but not HWCAP2. In that case, we treat HWCAP2 as zero.
-            let v = auxv_from_file(file).unwrap();
+            let v = auxv_from_file_bytes(auxv).unwrap();
             assert_eq!(v.hwcap, 126614527);
             assert_eq!(v.hwcap2, 0);
         }
@@ -66,18 +66,16 @@ cfg_if::cfg_if! {
         #[cfg(target_endian = "little")]
         #[test]
         fn linux_artificial_aarch64() {
-            let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-artificial-aarch64.auxv");
-            println!("file: {file}");
-            let v = auxv_from_file(file).unwrap();
+            let auxv = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-artificial-aarch64.auxv"));
+            let v = auxv_from_file_bytes(auxv).unwrap();
             assert_eq!(v.hwcap, 0x0123456789abcdef);
             assert_eq!(v.hwcap2, 0x02468ace13579bdf);
         }
         #[cfg(target_endian = "little")]
         #[test]
         fn linux_no_hwcap2_aarch64() {
-            let file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv");
-            println!("file: {file}");
-            let v = auxv_from_file(file).unwrap();
+            let auxv = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/detect/test_data/linux-no-hwcap2-aarch64.auxv"));
+            let v = auxv_from_file_bytes(auxv).unwrap();
             // An absent HWCAP2 is treated as zero, and does not prevent acceptance of HWCAP.
             assert_ne!(v.hwcap, 0);
             assert_eq!(v.hwcap2, 0);
-- 
cgit 1.4.1-3-g733a5


From a343926954a525f491756c3c9714417ae9ccc121 Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Wed, 23 Jul 2025 14:58:49 +0200
Subject: Prepare for merging from rust-lang/rust

This updates the rust-version file to 5a30e4307f0506bed87eeecd171f8366fdbda1dc.
---
 library/stdarch/rust-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/stdarch/rust-version b/library/stdarch/rust-version
index 5102178848e..622dce1c121 100644
--- a/library/stdarch/rust-version
+++ b/library/stdarch/rust-version
@@ -1 +1 @@
-040e2f8b9ff2d76fbe2146d6003e297ed4532088
+5a30e4307f0506bed87eeecd171f8366fdbda1dc
-- 
cgit 1.4.1-3-g733a5


From 0b88bea0d5169af3b3f9326274bda8b9c4a31823 Mon Sep 17 00:00:00 2001
From: Jake Goulding <jake.goulding@gmail.com>
Date: Wed, 23 Jul 2025 11:35:50 -0400
Subject: Move `dist-apple-various` from x86_64 to aarch64

`macos-13` is going away soonish.
---
 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 0a6ebe44b3d..e16f00547c1 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -478,7 +478,7 @@ auto:
       NO_LLVM_ASSERTIONS: 1
       NO_DEBUG_ASSERTIONS: 1
       NO_OVERFLOW_CHECKS: 1
-    <<: *job-macos
+    <<: *job-macos-m1
 
   - name: x86_64-apple-1
     env:
-- 
cgit 1.4.1-3-g733a5


From 8f0ffa8125f00af923098b30f390f6597b89d80d Mon Sep 17 00:00:00 2001
From: Jakub Beránek <berykubik@gmail.com>
Date: Wed, 23 Jul 2025 15:01:42 +0200
Subject: Reformat code

---
 library/stdarch/examples/connect5.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/library/stdarch/examples/connect5.rs b/library/stdarch/examples/connect5.rs
index 371b28552b3..f24657b1483 100644
--- a/library/stdarch/examples/connect5.rs
+++ b/library/stdarch/examples/connect5.rs
@@ -563,11 +563,7 @@ fn search(pos: &Pos, alpha: i32, beta: i32, depth: i32, _ply: i32) -> i32 {
     assert!(bs >= -EVAL_INF && bs <= EVAL_INF);
 
     //best move at the root node, best score elsewhere
-    if _ply == 0 {
-        bm
-    } else {
-        bs
-    }
+    if _ply == 0 { bm } else { bs }
 }
 
 /// Evaluation function: give different scores to different patterns after a fixed depth.
-- 
cgit 1.4.1-3-g733a5